+#include <cpu/k8/mtrr.h>
#define MEMORY_SUSE_SOLO 1 /* SuSE Solo configuration */
#define MEMORY_LNXI_SOLO 2 /* LNXI Solo configuration */
#define MEMORY_LNXI_HDAMA 3 /* LNXI HDAMA configuration */
print_debug("done.\r\n");
}
+
+struct dimm_size {
+ unsigned long side1;
+ unsigned long side2;
+};
+static struct dimm_size spd_get_dimm_size(unsigned device)
+{
+ /* Calculate the log base 2 size of a DIMM in bits */
+ struct dimm_size sz;
+ int value, low;
+ sz.side1 = 0;
+ sz.side2 = 0;
+
+ /* Note it might be easier to use byte 31 here, it has the DIMM size as
+ * a multiple of 4MB. The way we do it now we can size both
+ * sides of an assymetric dimm.
+ */
+ value = smbus_read_byte(device, 3); /* rows */
+ if (value < 0) return sz;
+ sz.side1 += value & 0xf;
+
+ value = smbus_read_byte(device, 4); /* columns */
+ if (value < 0) return sz;
+ sz.side1 += value & 0xf;
+
+ value = smbus_read_byte(device, 17); /* banks */
+ if (value < 0) return sz;
+ sz.side1 += log2(value & 0xff);
+
+ /* Get the module data widht and convert it to a power of two */
+ value = smbus_read_byte(device, 7); /* (high byte) */
+ if (value < 0) return sz;
+ value &= 0xff;
+ value <<= 8;
+
+ low = smbus_read_byte(device, 6); /* (low byte) */
+ if (low < 0) return sz;
+ value = value | (low & 0xff);
+ sz.side1 += log2(value);
+
+ /* side 2 */
+ value = smbus_read_byte(device, 5); /* number of physical banks */
+ if (value <= 1) return sz;
+
+ /* Start with the symmetrical case */
+ sz.side2 = sz.side1;
+
+ value = smbus_read_byte(device, 3); /* rows */
+ if (value < 0) return sz;
+ if ((value & 0xf0) == 0) return sz; /* If symmetrical we are done */
+ sz.side2 -= (value & 0x0f); /* Subtract out rows on side 1 */
+ sz.side2 += ((value >> 4) & 0x0f); /* Add in rows on side 2 */
+
+ value = smbus_read_byte(device, 4); /* columns */
+ if (value < 0) return sz;
+ sz.side2 -= (value & 0x0f); /* Subtract out columns on side 1 */
+ sz.side2 += ((value >> 4) & 0x0f); /* Add in columsn on side 2 */
+ return sz;
+}
+
+static unsigned spd_to_dimm_side0(unsigned device)
+{
+ return (device - SMBUS_MEM_DEVICE_START) << 1;
+}
+
+static unsigned spd_to_dimm_side1(unsigned device)
+{
+ return ((device - SMBUS_MEM_DEVICE_START) << 1) + 1;
+}
+
+static void set_dimm_size(unsigned long size, unsigned index)
+{
+ unsigned value = 0;
+ /* Make certain the dimm is at least 32MB */
+ if (size >= (25 + 3)) {
+ /* Place the dimm size in 32 MB quantities in the bits 31 - 21.
+ * The initialize dimm size is in bits.
+ * Set the base enable bit0.
+ */
+ value = (1 << ((size - (25 + 3)) + 21)) | 1;
+ }
+ /* Set the appropriate DIMM base address register */
+ pci_write_config32(PCI_DEV(0, 0x18, 2), 0x40 + (index << 2), value);
+}
+
+static void spd_set_ram_size(void)
+{
+ unsigned device;
+ for(device = SMBUS_MEM_DEVICE_START;
+ device <= SMBUS_MEM_DEVICE_END;
+ device += SMBUS_MEM_DEVICE_INC)
+ {
+ struct dimm_size sz;
+ sz = spd_get_dimm_size(device);
+ set_dimm_size(sz.side1, spd_to_dimm_side0(device));
+ set_dimm_size(sz.side2, spd_to_dimm_side1(device));
+ }
+}
+
+static void set_top_mem(unsigned tom_k)
+{
+ /* Error if I don't have memory */
+ if (!tom_k) {
+ die("No memory");
+ }
+ /* Now set top of memory */
+ msr_t msr;
+ msr.lo = (tom_k & 0x003fffff) << 10;
+ msr.hi = (tom_k & 0xffc00000) >> 22;
+ wrmsr(TOP_MEM, msr);
+
+#if 1
+ /* And report the amount of memory. (I run out of registers if i don't) */
+ print_debug("RAM: 0x");
+ print_debug_hex32(tom_k);
+ print_debug(" KB\r\n");
+#endif
+}
+
+static void order_dimms(void)
+{
+ unsigned long tom;
+ unsigned mask;
+ unsigned index;
+
+ /* Remember which registers we have used in the high 8 bits of tom */
+ tom = 0;
+ for(;;) {
+ /* Find the largest remaining canidate */
+ unsigned canidate;
+ uint32_t csbase, csmask;
+ unsigned size;
+ csbase = 0;
+ canidate = 0;
+ for(index = 0; index < 8; index++) {
+ uint32_t value;
+ value = pci_read_config32(PCI_DEV(0, 0x18, 2), 0x40 + (index << 2));
+
+ /* Is it enabled? */
+ if (!(value & 1)) {
+ continue;
+ }
+
+ /* Is it greater? */
+ if (value <= csbase) {
+ continue;
+ }
+
+ /* Has it already been selected */
+ if (tom & (1 << (index + 24))) {
+ continue;
+ }
+ /* I have a new canidate */
+ csbase = value;
+ canidate = index;
+ }
+ /* See if I have found a new canidate */
+ if (csbase == 0) {
+ break;
+ }
+
+ /* Remember I have used this register */
+ tom |= (1 << (canidate + 24));
+
+ /* Remember the dimm size */
+ size = csbase >> 21;
+
+ /* Recompute the cs base register value */
+ csbase = (tom << 21) | 1;
+
+ /* Increment the top of memory */
+ tom += size;
+
+ /* Compute the memory mask */
+ csmask = ((size -1) << 21);
+ csmask |= 0xfe00; /* For now don't optimize */
+
+ /* Write the new base register */
+ pci_write_config32(PCI_DEV(0, 0x18, 2), 0x40 + (canidate << 2), csbase);
+ pci_write_config32(PCI_DEV(0, 0x18, 2), 0x60 + (canidate << 2), csmask);
+
+ }
+ set_top_mem((tom & ~0xff000000) << 15);
+}
+
+
#define DRAM_CONFIG_LOW 0x90
#define DCL_DLL_Disable (1<<0)
#define DCL_D_DRV (1<<1)
#define DCL_MemClrStatus (1<<11)
#define DCL_DimmEcEn (1<<17)
-#define NODE_ID 0x60
-#define HT_INIT_CONTROL 0x6c
-#define HTIC_ColdR_Detect (1<<4)
-#define HTIC_BIOSR_Detect (1<<5)
-#define HTIC_INIT_Detect (1<<6)
-
-static void sdram_set_spd_registers(void)
+static void spd_set_ecc_mode(void)
{
unsigned long dcl;
dcl = pci_read_config32(PCI_DEV(0, 0x18, 2), DRAM_CONFIG_LOW);
/* Until I know what is going on disable ECC support */
dcl &= ~DCL_DimmEcEn;
pci_write_config32(PCI_DEV(0, 0x18, 2), DRAM_CONFIG_LOW, dcl);
+
+}
+static void sdram_set_spd_registers(void)
+{
+ spd_set_ram_size();
+ spd_set_ecc_mode();
+ order_dimms();
}
#define TIMEOUT_LOOPS 300000
{
struct block *block;
struct triple *ret;
+ /* If I am an OP_PIECE jump to the real instruction */
+ if (base->op == OP_PIECE) {
+ base = MISC(base, 0);
+ }
block = block_of_triple(state, base);
ret = build_triple(state, op, type, left, right,
base->filename, base->line, base->col);
{
struct block *block;
struct triple *ret;
+ int zlhs;
+ /* If I am an OP_PIECE jump to the real instruction */
+ if (base->op == OP_PIECE) {
+ base = MISC(base, 0);
+ }
+ /* If I have a left hand side skip over it */
+ zlhs = TRIPLE_LHS(base->sizes);
+ if (zlhs && (base->op != OP_WRITE) && (base->op != OP_STORE)) {
+ base = LHS(base, zlhs - 1);
+ }
+
block = block_of_triple(state, base);
ret = build_triple(state, op, type, left, right,
base->filename, base->line, base->col);
fprintf(fp, " %-10p", ins->param[i]);
}
for(; i < 2; i++) {
- printf(" ");
+ fprintf(fp, " ");
}
fprintf(fp, " @ %s:%d.%d\n",
ins->filename, ins->line, ins->col);
struct triple *ins;
struct triple_reg_set *live;
size_t count;
+ int constraints;
};
static void least_conflict(struct compile_state *state,
struct reg_block *blocks, struct triple_reg_set *live,
struct live_range_edge *edge;
struct triple_reg_set *set;
size_t count;
-
-#if 0
-#define HI() fprintf(stderr, "%-10p(%-15s) %d\n", ins, tops(ins->op), __LINE__)
-#else
-#define HI()
-#endif
+ int constraints;
#warning "FIXME handle instructions with left hand sides..."
/* Only instructions that introduce a new definition
* can be the conflict instruction.
*/
if (!triple_is_def(state, ins)) {
-HI();
return;
}
for(set = live; set; set = set->next) {
struct live_range *lr;
lr = conflict->rstate->lrd[set->member->id].lr;
+ /* Ignore it if there cannot be an edge between these two nodes */
+ if (!arch_regcm_intersect(conflict->ref_range->classes, lr->classes)) {
+ continue;
+ }
for(edge = conflict->ref_range->edges; edge; edge = edge->next) {
if (edge->node == lr) {
break;
}
}
if (!edge && (lr != conflict->ref_range)) {
-HI();
return;
}
count++;
}
if (count <= 1) {
-HI();
return;
}
+#if 0
/* See if there is an uncolored member in this subset.
*/
for(set = live; set; set = set->next) {
}
}
if (!set && (conflict->ref_range != REG_UNSET)) {
-HI();
+ return;
+ }
+#endif
+
+ /* See if any of the live registers are constrained,
+ * if not it won't be productive to pick this as
+ * a conflict instruction.
+ */
+ constraints = 0;
+ for(set = live; set; set = set->next) {
+ struct triple_set *uset;
+ struct reg_info info;
+ unsigned classes;
+ unsigned cur_size, size;
+ /* Skip this instruction */
+ if (set->member == ins) {
+ continue;
+ }
+ /* Find how many registers this value can potentially
+ * be assigned to.
+ */
+ classes = arch_type_to_regcm(state, set->member->type);
+ size = regc_max_size(state, classes);
+
+ /* Find how many registers we allow this value to
+ * be assigned to.
+ */
+ info = arch_reg_lhs(state, set->member, 0);
+
+ /* If the value does not live in a register it
+ * isn't constrained.
+ */
+ if (info.reg == REG_UNNEEDED) {
+ continue;
+ }
+
+ if ((info.reg == REG_UNSET) || (info.reg >= MAX_REGISTERS)) {
+ cur_size = regc_max_size(state, info.regcm);
+ } else {
+ cur_size = 1;
+ }
+
+ /* If there is no difference between potential and
+ * actual register count there is not a constraint
+ */
+ if (cur_size >= size) {
+ continue;
+ }
+
+ /* If this live_range feeds into conflict->inds
+ * it isn't a constraint we can relieve.
+ */
+ for(uset = set->member->use; uset; uset = uset->next) {
+ if (uset->member == ins) {
+ break;
+ }
+ }
+ if (uset) {
+ continue;
+ }
+ constraints = 1;
+ break;
+ }
+ /* Don't drop canidates with constraints */
+ if (conflict->constraints && !constraints) {
return;
}
+#if 0
+ fprintf(stderr, "conflict ins? %p %s count: %d constraints: %d\n",
+ ins, tops(ins->op), count, constraints);
+#endif
/* Find the instruction with the largest possible subset of
* conflict ranges and that dominates any other instruction
* with an equal sized set of conflicting ranges.
/* Remember the canidate instruction */
conflict->ins = ins;
conflict->count = count;
+ conflict->constraints = constraints;
/* Free the old collection of live registers */
for(set = conflict->live; set; set = next) {
next = set->next;
;
}
}
-HI();
return;
}
struct least_conflict *conflict)
{
-#if 0
- static void verify_blocks(struct compile_state *stae);
- verify_blocks(state);
- print_blocks(state, stderr);
- print_dominators(state, stderr);
-#endif
/* there are 3 kinds ways conflicts can occure.
* 1) the life time of 2 values simply overlap.
* 2) the 2 values feed into the same instruction.
* is at or after the instruction.
*/
memset(conflict, 0, sizeof(*conflict));
- conflict->rstate = rstate;
- conflict->ref_range = ref_range;
- conflict->ins = 0;
- conflict->count = 0;
- conflict->live = 0;
+ conflict->rstate = rstate;
+ conflict->ref_range = ref_range;
+ conflict->ins = 0;
+ conflict->live = 0;
+ conflict->count = 0;
+ conflict->constraints = 0;
walk_variable_lifetimes(state, rstate->blocks, least_conflict, conflict);
if (!conflict->ins) {
- struct live_range_edge *edge;
- struct live_range_def *lrd;
- fprintf(stderr, "edges:\n");
- for(edge = ref_range->edges; edge; edge = edge->next) {
- lrd = edge->node->defs;
- do {
- fprintf(stderr, " %-10p(%s)", lrd->def, tops(lrd->def->op));
- lrd = lrd->next;
- } while(lrd != edge->node->defs);
- fprintf(stderr, "|\n");
- }
- fprintf(stderr, "range:\n");
- lrd = ref_range->defs;
- do {
- fprintf(stderr, " %-10p(%s)", lrd->def, tops(lrd->def->op));
- lrd = lrd->next;
- } while(lrd != ref_range->defs);
- fprintf(stderr,"\n");
internal_error(state, ref_range->defs->def, "No conflict ins?");
}
if (!conflict->live) {
internal_error(state, ref_range->defs->def, "No conflict live?");
}
+#if 0
+ fprintf(stderr, "conflict ins: %p %s count: %d constraints: %d\n",
+ conflict->ins, tops(conflict->ins->op),
+ conflict->count, conflict->constraints);
+#endif
return;
}
* be assigned to.
*/
info = arch_reg_lhs(state, cset->member, 0);
+
+ /* If the register doesn't need a register
+ * splitting it can't help.
+ */
+ if (info.reg == REG_UNNEEDED) {
+ continue;
+ }
#warning "FIXME do I need a call to arch_reg_rhs around here somewhere?"
if ((info.reg == REG_UNSET) || (info.reg >= MAX_REGISTERS)) {
cur_size = regc_max_size(state, info.regcm);
{
struct triple *new;
+#if 0
+ fprintf(stderr, "split_ranges %d %s %p\n",
+ rstate->passes, tops(range->defs->def->op), range->defs->def);
+#endif
if ((range->color == REG_UNNEEDED) ||
(rstate->passes >= rstate->max_passes)) {
return 0;
if (arch_select_free_register(state, used, range->classes) == REG_UNSET) {
struct least_conflict conflict;
+#if 0
+ fprintf(stderr, "find_range_conflict\n");
+#endif
/* Find where in the set of registers the conflict
* actually occurs.
*/
*
*/
#warning "WISHLIST implement live range splitting..."
+#if 0
+ print_blocks(state, stderr);
+ print_dominators(state, stderr);
+
+#endif
return 0;
}
}
new->id = rstate->defs;
rstate->defs++;
#if 0
- fprintf(stderr, "new: %p\n", new);
+ fprintf(stderr, "new: %p old: %s %p\n",
+ new, tops(RHS(new, 0)->op), RHS(new, 0));
+#endif
+#if 0
+ print_blocks(state, stderr);
+ print_dominators(state, stderr);
+
#endif
return 1;
}
arch_select_free_register(state, used, range->classes);
}
if (range->color == REG_UNSET) {
+ struct live_range_def *lrd;
int i;
if (split_ranges(state, rstate, used, range)) {
return 0;
}
for(edge = range->edges; edge; edge = edge->next) {
- if (edge->node->color == REG_UNSET) {
- continue;
- }
- warning(state, edge->node->defs->def, "reg %s",
+ warning(state, edge->node->defs->def, "edge reg %s",
arch_reg_str(edge->node->color));
+ lrd = edge->node->defs;
+ do {
+ warning(state, lrd->def, " %s",
+ tops(lrd->def->op));
+ lrd = lrd->next;
+ } while(lrd != edge->node->defs);
}
+ warning(state, range->defs->def, "range: ");
+ lrd = range->defs;
+ do {
+ warning(state, lrd->def, " %s",
+ tops(lrd->def->op));
+ lrd = lrd->next;
+ } while(lrd != range->defs);
+
warning(state, range->defs->def, "classes: %x",
range->classes);
for(i = 0; i < MAX_REGISTERS; i++) {
projects / coreboot.git / commitdiff