/* This was originally for the e7500, modified for i855pm */ /* converted to C 6/2004 yhlu */ #define DEBUG_RAM_CONFIG 1 #define dumpnorth() dump_pci_device(PCI_DEV(0, 0, 0)) /* DDR DIMM Mode register Definitions */ #define BURST_2 (1<<0) #define BURST_4 (2<<0) #define BURST_8 (3<<0) #define BURST_SEQUENTIAL (0<<3) #define BURST_INTERLEAVED (1<<3) #define CAS_2_0 (0x2<<4) #define CAS_3_0 (0x3<<4) #define CAS_1_5 (0x5<<4) #define CAS_2_5 (0x6<<4) #define MODE_NORM (0 << 7) #define MODE_DLL_RESET (2 << 7) #define MODE_TEST (1 << 7) #define BURST_LENGTH BURST_4 #define BURST_TYPE BURST_INTERLEAVED #define CAS_LATENCY CAS_2_0 //#define CAS_LATENCY CAS_2_5 //#define CAS_LATENCY CAS_1_5 #define MRS_VALUE (MODE_NORM | CAS_LATENCY | BURST_TYPE | BURST_LENGTH) #define EMRS_VALUE 0x000 #define MD_SHIFT 4 #define RAM_COMMAND_NONE 0x0 #define RAM_COMMAND_NOP 0x1 #define RAM_COMMAND_PRECHARGE 0x2 #define RAM_COMMAND_MRS 0x3 #define RAM_COMMAND_EMRS 0x4 #define RAM_COMMAND_CBR 0x6 #define RAM_COMMAND_NORMAL 0x7 static inline void do_ram_command (const struct mem_controller *ctrl, uint32_t value) { uint32_t dword; uint8_t byte; int i; uint32_t result; #if DEBUG_RAM_CONFIG >= 2 print_debug("P:"); print_debug_hex8(value); print_debug("\r\n"); #endif /* %ecx - initial address to read from */ /* Compute the offset */ dword = value >> 16; for(i=0;i<8;i++) { /* Set the ram command */ byte = pci_read_config8(ctrl->d0, 0x7c); byte &= 0x8f; byte |= (uint8_t)(value & 0xff); pci_write_config8(ctrl->d0, 0x7c, byte); /* Assert the command to the memory */ #if DEBUG_RAM_CONFIG >= 2 print_debug("R:"); print_debug_hex32(dword); print_debug("\r\n"); #endif result = read32(dword); /* Go to the next base address */ dword += 0x04000000; } /* The command has been sent to all dimms so get out */ } static inline void RAM_CMD(const struct mem_controller *ctrl, uint32_t command, uint32_t offset) { uint32_t value = ((offset) << (MD_SHIFT + 16))|((command << 4) & 0x70) ; do_ram_command(ctrl, value); } #define RAM_NOP(ctrl) RAM_CMD(ctrl, RAM_COMMAND_NOP, 0) #define RAM_PRECHARGE(ctrl) RAM_CMD(ctrl, RAM_COMMAND_PRECHARGE, 0) #define RAM_CBR(ctrl) RAM_CMD(ctrl, RAM_COMMAND_CBR, 0) #define RAM_EMRS(ctrl) RAM_CMD(ctrl, RAM_COMMAND_EMRS, EMRS_VALUE) static const uint8_t ram_cas_latency[] = { CAS_2_5, CAS_2_0, CAS_1_5, CAS_2_5 }; static inline void ram_mrs(const struct mem_controller *ctrl, uint32_t value){ /* Read the cas latency setting */ uint8_t byte; uint32_t dword; byte = pci_read_config8(ctrl->d0, 0x78); /* Transform it into the form expected by SDRAM */ dword = ram_cas_latency[(byte>>4) & 3]; value |= (dword<<(16+MD_SHIFT)); value |= (MODE_NORM | BURST_TYPE | BURST_LENGTH) << (16+MD_SHIFT); do_ram_command(ctrl, value); } #define RAM_MRS(ctrl, dll_reset) ram_mrs( ctrl, (dll_reset << (8+MD_SHIFT+ 16)) | ((RAM_COMMAND_MRS <<4)& 0x70) ) static void RAM_NORMAL(const struct mem_controller *ctrl) { uint8_t byte; byte = pci_read_config8(ctrl->d0, 0x7c); byte &= 0x8f; byte |= (RAM_COMMAND_NORMAL << 4); pci_write_config8(ctrl->d0, 0x7c, byte); } static void RAM_RESET_DDR_PTR(const struct mem_controller *ctrl) { uint8_t byte; byte = pci_read_config8(ctrl->d0, 0x88); byte |= (1 << 4 ); pci_write_config8(ctrl->d0, 0x88, byte); byte = pci_read_config8(ctrl->d0, 0x88); byte &= ~(1 << 4); pci_write_config8(ctrl->d0, 0x88, byte); } static void ENABLE_REFRESH(const struct mem_controller *ctrl) { uint32_t dword; dword = pci_read_config32(ctrl->d0, 0x7c); dword |= (1 << 29); pci_write_config32(ctrl->d0, 0x7c, dword); } /* * Table: constant_register_values */ static const long register_values[] = { /* DRB - DRAM Row Boundary Registers * 0x60 - 0x63 * An array of 8 byte registers, which hold the ending * memory address assigned to each pair of DIMMS, in 32MB * granularity. */ /* Conservatively say each row has 32MB of ram, we will fix this up later */ 0x60, 0x00000000, (0x01 << 0) | (0x02 << 8) | (0x03 << 16) | (0x04 << 24), /* DRA - DRAM Row Attribute Register * 0x70 Row 0,1 * 0x71 Row 2,3 * [2:0] Row Attributes for both rows * 001 == 2KB * 010 == 4KB * 011 == 8KB * 100 == 16KB * Others == Reserved */ /* leave it alone for now -- seems bad to set it at all 0x70, 0x00000000, (((0<<3)|(0<<0))<< 0) | (((0<<3)|(0<<0))<< 4) | (((0<<3)|(0<<0))<< 8) | (((0<<3)|(0<<0))<<12) | (((0<<3)|(0<<0))<<16) | (((0<<3)|(0<<0))<<20) | (((0<<3)|(0<<0))<<24) | (((0<<3)|(0<<0))<<28), */ /* DRT - DRAM Time Register * 0x78 * [31:31] Additional CKE to CS Clock for Read/Write * [30:30] Additional CKE to CS clock for Precharge/Activate * [29:29] Back to Back Write-Read Turn Around * Intel recommends set to 1 * * [28:28] Back to Back Read-Write Turn Around * Intel recommends 0 for CL 2.5 and 1 for CL 2 * * [27:27] Back to Back Read Turn Around * Intel recommends 1 for all configs * * [26:24] Read Delay (tRD) * 000 == 9 clocks * 001 == 8 clocks * 010 == 7 clocks * 011 == 6 clocks * 100 == 5 clocks * 101 == 4 clocks * 110 == 3 clocks * Others == Reserved * [23:20] Reserved * [19:19] No Wake for DDR page closes * 0 is default * [18:16] Page Close Counter * 000 == infinite * 010 == 8-15 clocks * 011 == 16-31 clocks * 100 == 64-127 clocks * 101 == 128-255 clocks * 110 == 192-383 clocks * 111 == 255-510 clocks * * [15:12] Reserved * [11:11] DQS Slave DLL Dynamic Management * power saving, when set to 1, slave DLLS disabled * we'll leave it at 0 for now * [10:09] Active to Precharge (tRAS) * 00 == 7 clocks * 01 == 6 clocks * 10 == 5 clocks * 11 == Reserved * [08:06] Reserved * [05:04] Cas Latency (tCL) * 00 == 2.5 Clocks * 01 == 2.0 Clocks (default) * 10 == 1.5 Clocks * 11 == Reserved * [03:03] Reserved * [02:02] Ras# to Cas# Delay (tRCD) * 0 == 3 DRAM Clocks * 1 == 2 DRAM Clocks * [01:01] Reserved * [00:00] DRAM RAS# to Precharge (tRP) * 0 == 3 DRAM Clocks * 1 == 2 DRAM Clocks */ #define DRT_CAS_2_5 (0<<4) #define DRT_CAS_2_0 (1<<4) #define DRT_CAS_1_5 (2<<4) #define DRT_CAS_MASK (3<<4) #if CAS_LATENCY == CAS_2_5 #define DRT_CL DRT_CAS_2_5 #elif CAS_LATENCY == CAS_2_0 #define DRT_CL DRT_CAS_2_0 #elif CAS_LATENCY == CAS_1_5 #define DRT_CL DRT_CAS_1_5 #endif /* Most unaggressive settings possible */ /* clear bits 26:24,18:16,11,10:9,5:4,2:2,0 */ /* ~ (7<<26)|(7<<18)|(1<<11)|(3<<10)|(3<<5)|(1<<2)|1 */ // 0x78, 0xc0fff8c4, (1<<29)|(1<<28)|(1<<27)|(2<<24)|(2<<9)|DRT_CL|(1<<3)|(1<<1)|(1<<0), // 0x78, 0xc0f8f8c0, (1<<29)|(1<<28)|(1<<27)|(1<<24)|(1<<16)|(2<<9)|DRT_CL|(1<<3)|(3<<1)|(1<<0), // 0x78, 0xc0f8f9c0, (1<<29)|(1<<28)|(1<<27)|(1<<24)|(1<<16)|(2<<9)|DRT_CL|(1<<3)|(3<<1)|(1<<0), 0x78, ~((7<<26)|(7<<18)|(1<<11)|(3<<10)|(3<<5)|(1<<2)|1), (1<<29)|(1<<28)|(9<<26)|(0<<18)|(0<<11)|(0<<10)|(0<<5)|(0<<2)|(0<<0), /* FDHC - Fixed DRAM Hole Control * 0x97 * [7:7] Hole_Enable * 0 == No memory Hole * 1 == Memory Hole from 15MB to 16MB * [6:0] Reserved * * PAM - Programmable Attribute Map * 0x90 [3:0] Reserved * 0x90 [5:4] 0xF0000 - 0xFFFFF * 0x91 [1:0] 0xC0000 - 0xC3FFF * 0x91 [5:4] 0xC4000 - 0xC7FFF * 0x92 [1:0] 0xC8000 - 0xCBFFF * 0x92 [5:4] 0xCC000 - 0xCFFFF * 0x93 [1:0] 0xD0000 - 0xD3FFF * 0x93 [5:4] 0xD4000 - 0xD7FFF * 0x94 [1:0] 0xD8000 - 0xDBFFF * 0x94 [5:4] 0xDC000 - 0xDFFFF * 0x95 [1:0] 0xE0000 - 0xE3FFF * 0x95 [5:4] 0xE4000 - 0xE7FFF * 0x96 [1:0] 0xE8000 - 0xEBFFF * 0x96 [5:4] 0xEC000 - 0xEFFFF * 00 == DRAM Disabled (All Access go to memory mapped I/O space) * 01 == Read Only (Reads to DRAM, Writes to memory mapped I/O space) * 10 == Write Only (Writes to DRAM, Reads to memory mapped I/O space) * 11 == Normal (All Access go to DRAM) */ 0x90, 0xcccccf7f, (0x00 << 0) | (0x30 << 8) | (0x33 << 16) | (0x33 << 24), 0x94, 0xcccccccc, (0x33 << 0) | (0x33 << 8) | (0x33 << 16) | (0x33 << 24), /* FIXME why was I attempting to set a reserved bit? */ /* 0x0100040f */ /* DRC - DRAM Contoller Mode Register * 0x7c * [31:30] Rev # * [29:29] Initialization Complete * 0 == Not Complete * 1 == Complete * [28:27] Dynamic Power Down Enable (leave at 0 for now) * [27:24] Reserved * [23:23] Reduced Comamnd Drive Delay (leave at 0 for now) * [22:22] Reduced Command Drive Enable (leave at 0 for now) * [21:21] DRAM Data Integrity Mode * 0 == Disabled, no ECC * 1 == Error checking, with correction * [20:20] Reserved * [19:18] Reserved * Must equal 00 * [17:17] (Intel Undocumented) should always be set to * [16:16] Disable SCK Tri-state in C3/S1-m * 0 == 2n Rule * 1 == 1n rule * [15:14] Reserved * [13:13] Dynamic CS Disable * [12:12] SM Interface Tristate enable * [11:11] Reserved * [10:08] Refresh mode select * 000 == Refresh disabled * 001 == Refresh interval 15.6 usec * 010 == Refresh interval 7.8 usec * 011 == Refresh interval 64 usec * 111 == Reserved * [07:07] Reserved * [06:04] Mode Select (SMS) * 000 == Self Refresh Mode * 001 == NOP Command * 010 == All Banks Precharge * 011 == Mode Register Set * 100 == Extended Mode Register Set * 101 == Reserved * 110 == CBR Refresh * 111 == Normal Operation * [03:01] Reserved * [00:00] DRAM type --hardwired to 1 to indicate DDR */ // .long 0x7c, 0xffcefcff, (1<<22)|(2 << 20)|(1 << 16)| (0 << 8), // .long 0x7c, 0xff8cfcff, (1<<22)|(2 << 20)|(1 << 17)|(1 << 16)| (0 << 8), // .long 0x7c, 0xff80fcff, (1<<22)|(2 << 20)|(1 << 18)|(1 << 17)|(1 << 16)| (0 << 8), // 0x7c, 0xff82fcff, (1<<22)|(2 << 20)|(1 << 18)|(1 << 16)| (0 << 8), 0x7c, 0xff82f8ff, (1<<22)|(2 << 20)|(1 << 18)|(1 << 16)| (0 << 8), }; /* * Routine: ram_set_registers * Arguments: none * Results: none * Trashed: %eax, %ebx, %ecx, %edx, %esi, %eflags * Effects: Do basic ram setup that does not depend on serial * presence detect information. * This sets PCI configuration registers to known good * values based on the table: * constant_register_values * Which are a triple of configuration regiser, mask, and value. * */ /* from 1M or 512K */ #define RCOMP_MMIO 0x100000 /* DDR RECOMP table */ static const long ddr_rcomp_1[] = { 0x44332211, 0xc9776655, 0xffffffff, 0xffffffff, 0x22111111, 0x55444332, 0xfffca876, 0xffffffff, }; static const long ddr_rcomp_2[] = { 0x00000000, 0x76543210, 0xffffeca8, 0xffffffff, 0x21000000, 0xa8765432, 0xffffffec, 0xffffffff, }; static const long ddr_rcomp_3[] = { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x88888888, 0x88888888, 0x88888888, 0x88888888, }; #define rcomp_init_str "Setting RCOMP registers.\r\n" static void write_8dwords(uint32_t src_addr, uint32_t dst_addr) { int i; uint32_t dword; for(i=0;i<8;i++) { dword = read32(src_addr); write32(dst_addr, dword); src_addr+=4; dst_addr+=4; } } //#define SLOW_DOWN_IO inb(0x80); #define SLOW_DOWN_IO udelay(40); static void ram_set_rcomp_regs(const struct mem_controller *ctrl) { uint32_t dword; #if DEBUG_RAM_CONFIG print_debug(rcomp_init_str); #endif /*enable access to the rcomp bar */ /* for e7501 they also set bit 31 ... */ dword = pci_read_config32(ctrl->d0, 0x0f4); dword |= 1<<22; pci_write_config32(ctrl->d0, 0x0f4, dword); /* Set the MMIO address to 512K */ pci_write_config32(ctrl->d0, 0x14, RCOMP_MMIO); dword = read32(RCOMP_MMIO + 0x20); dword |= (1<<9); write32(RCOMP_MMIO + 0x20, dword); #ifdef NOTNOW /* Begin to write the RCOMP registers */ write8(RCOMP_MMIO + 0x2c, 0xff); write32(RCOMP_MMIO + 0x30, 0x01040444); write8(RCOMP_MMIO + 0x34, 0x04); write32(RCOMP_MMIO + 0x40, 0); write16(RCOMP_MMIO + 0x44, 0); write16(RCOMP_MMIO + 0x48, 0); write16(RCOMP_MMIO + 0x50, 0); write_8dwords((uint32_t)ddr_rcomp_1, RCOMP_MMIO + 0x60); write_8dwords((uint32_t)ddr_rcomp_2, RCOMP_MMIO + 0x80); write_8dwords((uint32_t)ddr_rcomp_2, RCOMP_MMIO + 0xa0); write_8dwords((uint32_t)ddr_rcomp_2, RCOMP_MMIO + 0x140); write_8dwords((uint32_t)ddr_rcomp_2, RCOMP_MMIO + 0x1c0); write_8dwords((uint32_t)ddr_rcomp_3, RCOMP_MMIO + 0x180); #if 0 /* Print the RCOMP registers */ movl $RCOMP_MMIO, %ecx 1: movl %ecx, %eax andb $0x0f, %al jnz 2f CONSOLE_INFO_TX_CHAR($'\r') CONSOLE_INFO_TX_CHAR($'\n') CONSOLE_INFO_TX_HEX32(%ecx) CONSOLE_INFO_TX_CHAR($' ') CONSOLE_INFO_TX_CHAR($'-') CONSOLE_INFO_TX_CHAR($' ') 2: movl (%ecx), %eax CONSOLE_INFO_TX_HEX32(%eax) CONSOLE_INFO_TX_CHAR($' ') addl $4, %ecx cmpl $(RCOMP_MMIO + 0x1e0), %ecx jnz 1b CONSOLE_INFO_TX_CHAR($'\r') CONSOLE_INFO_TX_CHAR($'\n') #endif dword = read32(RCOMP_MMIO + 0x20); dword &= ~(3); dword |= 1; write32(RCOMP_MMIO + 0x20, dword); /* Wait 40 usec */ SLOW_DOWN_IO; /* unblock updates */ dword = read32(RCOMP_MMIO + 0x20); dword &= ~(1<<9); write32(RCOMP_MMIO+0x20, dword); dword |= (1<<8); write32(RCOMP_MMIO+0x20, dword); dword &= ~(1<<8); write32(RCOMP_MMIO+0x20, dword); /* Wait 40 usec */ SLOW_DOWN_IO; #endif /*disable access to the rcomp bar */ dword = pci_read_config32(ctrl->d0, 0x0f4); dword &= ~(1<<22); pci_write_config32(ctrl->d0, 0x0f4, dword); } static void ram_set_d0f0_regs(const struct mem_controller *ctrl) { #if DEBUG_RAM_CONFIG dumpnorth(); #endif int i; int max; max = sizeof(register_values)/sizeof(register_values[0]); for(i = 0; i < max; i += 3) { uint32_t reg; #if DEBUG_RAM_CONFIG print_debug_hex32(register_values[i]); print_debug(" <-"); print_debug_hex32(register_values[i+2]); print_debug("\r\n"); #endif reg = pci_read_config32(ctrl->d0,register_values[i]); reg &= register_values[i+1]; reg |= register_values[i+2] & ~(register_values[i+1]); pci_write_config32(ctrl->d0,register_values[i], reg); } #if DEBUG_RAM_CONFIG dumpnorth(); #endif } static void sdram_set_registers(const struct mem_controller *ctrl){ ram_set_rcomp_regs(ctrl); ram_set_d0f0_regs(ctrl); } /* * Routine: sdram_spd_get_page_size * Arguments: %bl SMBUS_MEM_DEVICE * Results: * %edi log base 2 page size of DIMM side 1 in bits * %esi log base 2 page size of DIMM side 2 in bits * * Preserved: %ebx (except %bh), %ebp * * Trashed: %eax, %bh, %ecx, %edx, %esp, %eflags * Used: %eax, %ebx, %ecx, %edx, %esi, %edi, %esp, %eflags * * Effects: Uses serial presence detect to set %edi & %esi * to the page size of a dimm. * Notes: * %bl SMBUS_MEM_DEVICE * %edi holds the page size for the first side of the DIMM. * %esi holds the page size for the second side of the DIMM. * memory size is represent as a power of 2. * * This routine may be worth moving into generic code somewhere. */ struct dimm_page_size { unsigned long side1; unsigned long side2; }; static struct dimm_page_size sdram_spd_get_page_size(unsigned device) { uint32_t ecx; int value; struct dimm_page_size pgsz; pgsz.side1 = 0; pgsz.side2 = 0; value = spd_read_byte(device, 4); /* columns */ if(value < 0) goto hw_err; pgsz.side1 = value & 0xf; /* Get the module data width and convert it to a power of two */ value = spd_read_byte(device,7); /* (high byte) */ if(value < 0) goto hw_err; ecx = value & 0xff; ecx <<= 8; value = spd_read_byte(device, 6); /* (low byte) */ if(value < 0) goto hw_err; ecx |= (value & 0xff); pgsz.side1 += log2(ecx); /* compute cheap log base 2 */ /* side two */ value = spd_read_byte(device, 5); /* number of physical banks */ if(value < 0) goto hw_err; if(value==1) goto out; if(value!=2) goto val_err; /* Start with the symmetrical case */ pgsz.side2 = pgsz.side1; value = spd_read_byte(device,4); /* columns */ if(value < 0) goto hw_err; if((value & 0xf0)==0 ) goto out; pgsz.side2 -=value & 0xf; /* Subtract out columns on side 1 */ pgsz.side2 +=(value>>4)& 0xf; /* Add in columns on side 2 */ goto out; val_err: die("Bad SPD value\r\n"); /* If an hw_error occurs report that I have no memory */ hw_err: pgsz.side1 = 0; pgsz.side2 = 0; out: return pgsz; } /* * Routine: sdram_spd_get_width * Arguments: %bl SMBUS_MEM_DEVICE * Results: * %edi width of SDRAM chips on DIMM side 1 in bits * %esi width of SDRAM chips on DIMM side 2 in bits * * Preserved: %ebx (except %bh), %ebp * * Trashed: %eax, %bh, %ecx, %edx, %esp, %eflags * Used: %eax, %ebx, %ecx, %edx, %esi, %edi, %esp, %eflags * * Effects: Uses serial presence detect to set %edi & %esi * to the width of a dimm. * Notes: * %bl SMBUS_MEM_DEVICE * %edi holds the width for the first side of the DIMM. * %esi holds the width for the second side of the DIMM. * memory size is represent as a power of 2. * * This routine may be worth moving into generic code somewhere. */ struct dimm_width { unsigned side1; unsigned side2; }; static struct dimm_width sdram_spd_get_width(unsigned device) { int value; struct dimm_width wd; uint32_t ecx; wd.side1 = 0; wd.side2 = 0; value = spd_read_byte(device, 13); /* sdram width */ if(value < 0 ) goto hw_err; ecx = value; wd.side1 = value & 0x7f; /* side two */ value = spd_read_byte(device, 5); /* number of physical banks */ if(value < 0 ) goto hw_err; if(value <=1 ) goto out; /* Start with the symmetrical case */ wd.side2 = wd.side1; if((ecx & 0x80)==0) goto out; wd.side2 <<=1; hw_err: wd.side1 = 0; wd.side2 = 0; out: return wd; } /* * Routine: sdram_spd_get_dimm_size * Arguments: %bl SMBUS_MEM_DEVICE * Results: * %edi log base 2 size of DIMM side 1 in bits * %esi log base 2 size of DIMM side 2 in bits * * Preserved: %ebx (except %bh), %ebp * * Trashed: %eax, %bh, %ecx, %edx, %esp, %eflags * Used: %eax, %ebx, %ecx, %edx, %esi, %edi, %esp, %eflags * * Effects: Uses serial presence detect to set %edi & %esi * the size of a dimm. * Notes: * %bl SMBUS_MEM_DEVICE * %edi holds the memory size for the first side of the DIMM. * %esi holds the memory size for the second side of the DIMM. * memory size is represent as a power of 2. * * This routine may be worth moving into generic code somewhere. */ 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 = spd_read_byte(device, 3); /* rows */ if (value < 0) goto hw_err; // if ((value & 0xf) == 0) goto val_err; sz.side1 += value & 0xf; value = spd_read_byte(device, 4); /* columns */ if (value < 0) goto hw_err; // if ((value & 0xf) == 0) goto val_err; sz.side1 += value & 0xf; value = spd_read_byte(device, 17); /* banks */ if (value < 0) goto hw_err; // if ((value & 0xff) == 0) goto val_err; value &=0xff; sz.side1 += log2(value); /* Get the module data width and convert it to a power of two */ value = spd_read_byte(device, 7); /* (high byte) */ if (value < 0) goto hw_err; value &= 0xff; value <<= 8; low = spd_read_byte(device, 6); /* (low byte) */ if (low < 0) goto hw_err; value |= (low & 0xff); // if ((value != 72) && (value != 64)) goto val_err; sz.side1 += log2(value); /* side 2 */ value = spd_read_byte(device, 5); /* number of physical banks */ if (value < 0) goto hw_err; if (value == 1) goto out; // if (value != 2) goto val_err; /* Start with the symmetrical case */ sz.side2 = sz.side1; value = spd_read_byte(device, 3); /* rows */ if (value < 0) goto hw_err; if ((value & 0xf0) == 0) goto out; /* 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 = spd_read_byte(device, 4); /* columns */ if (value < 0) goto hw_err; // if ((value & 0xff) == 0) goto val_err; sz.side2 -= (value & 0x0f); /* Subtract out columns on side 1 */ sz.side2 += ((value >> 4) & 0x0f); /* Add in columsn on side 2 */ goto out; val_err: die("Bad SPD value\r\n"); /* If an hw_error occurs report that I have no memory */ hw_err: sz.side1 = 0; sz.side2 = 0; out: return sz; } /* * This is a place holder fill this out * Routine: spd_set_row_attributes * Arguments: %bl SMBUS_MEM_DEVICE * Results: * %edi log base 2 size of DIMM side 1 in bits * %esi log base 2 size of DIMM side 2 in bits * * Preserved: %ebx (except %bh), %ebp * * Trashed: %eax, %bh, %ecx, %edx, %esp, %eflags * Used: %eax, %ebx, %ecx, %edx, %esi, %edi, %esp, %eflags * * Effects: Uses serial presence detect to set %edi & %esi * the size of a dimm. * Notes: * %bl SMBUS_MEM_DEVICE * %edi holds the memory size for the first side of the DIMM. * %esi holds the memory size for the second side of the DIMM. * memory size is represent as a power of 2. * * This routine may be worth moving into generic code somewhere. */ static long spd_set_row_attributes(const struct mem_controller *ctrl, long dimm_mask) { int i; uint32_t dword=0; int value; /* Walk through all dimms and find the interesection of the support * for ecc sdram and refresh rates */ for(i = 0; i < DIMM_SOCKETS; i++) { if (!(dimm_mask & (1 << i))) { continue; } /* Test to see if I have ecc sdram */ struct dimm_page_size sz; sz = sdram_spd_get_page_size(ctrl->channel0[i]); /* SDRAM type */ #if DEBUG_RAM_CONFIG print_debug("page size ="); print_debug_hex32(sz.side1); print_debug(" "); print_debug_hex32(sz.side2); print_debug("\r\n"); #endif /* Test to see if the dimm is present */ if( sz.side1 !=0) { /* Test for a valid dimm width */ if((sz.side1 <15) || (sz.side1>18) ) { print_err("unsupported page size\r\n"); } /* double because I have 2 channels */ sz.side1++; /* Convert to the format needed for the DRA register */ sz.side1-=14; /* Place in the %ebp the dra place holder */ //i dword |= sz.side1<<(i<<3); /* Test to see if the second side is present */ if( sz.side2 !=0) { /* Test for a valid dimm width */ if((sz.side2 <15) || (sz.side2>18) ) { print_err("unsupported page size\r\n"); } /* double because I have 2 channels */ sz.side2++; /* Convert to the format needed for the DRA register */ sz.side2-=14; /* Place in the %ebp the dra place holder */ //i dword |= sz.side2<<((i<<3) + 4 ); } } /* Now add the SDRAM chip width to the DRA */ struct dimm_width wd; wd = sdram_spd_get_width(ctrl->channel0[i]); #if DEBUG_RAM_CONFIG print_debug("width ="); print_debug_hex32(wd.side1); print_debug(" "); print_debug_hex32(wd.side2); print_debug("\r\n"); #endif if(wd.side1 == 0) continue; if(wd.side1 == 4) { /* Enable an x4 device */ dword |= 0x08 << (i<<3); } if(wd.side2 == 0) continue; if(wd.side2 == 4) { /* Enable an x4 device */ dword |= 0x08 << ((i<<3 ) + 4); } /* go to the next DIMM */ } /* Write the new row attributes register */ pci_write_config32(ctrl->d0, 0x70, dword); return dimm_mask; } #if 0 /* * Routine: sdram_read_paired_byte * Arguments: %esp return address * %bl device on the smbus to read from * %bh address on the smbus to read * Results: * zf clear * byte read in %al * On Error: * zf set * %eax trashed * * Preserved: %ebx, %esi, %edi * * Trashed: %eax, %ecx, %edx, %ebp, %esp, %eflags * Used: %eax, %ebx, %ecx, %edx, %esp, %eflags * * Effects: Reads two spd bytes from both ram channesl * and errors if they are not equal. * It then returns the equal result. */ static spd_read_paired_byte () { movl %esp, %ebp CALLSP(smbus_read_byte) setnz %cl movb %al, %ch addb $(SMBUS_MEM_CHANNEL_OFF), %bl CALLSP(smbus_read_byte) movb %ch, %ah setnz %ch subb $(SMBUS_MEM_CHANNEL_OFF), %bl /* See if dimms on both sides are equally present */ cmp %cl, %ch jne sdram_presence_mismatch /* Leave if I have no data */ testb %cl, %cl jz spd_verify_byte_out /* Verify the data is identical */ cmp %ah, %al jne sdram_value_mismatch /* Clear the zero flag */ testb %cl, %cl spd_verify_byte_out: movl %ebp, %esp RETSP } /* * Routine: spd_verify_dimms * Arguments: none * Results: none * Preserved: none * Trashed: %eax, %ebx, %ecx, %edx, %ebp, %esi, %edi, %esp, %eflags * Used: %eax, %ebx, %ecx, %edx, %ebp, %esi, %edi, %esp, %eflags * * Effects: * - Verify all interesting spd information * matches for both dimm channels. * - Additional error checks that can be easily done * here are computed as well, so I don't need to * worry about them later. */ static spd_verify_dimms() { movl $(SMBUS_MEM_DEVICE_START), %ebx spd_verify_dimm: /* Verify this is DDR SDRAM */ movb $2, %bh CALLSP(spd_read_paired_byte) jz spd_verify_next_dimm cmpb $7, %al jne invalid_dimm_type /* Verify the row addresses */ movb $3, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data testb $0x0f, %al jz spd_invalid_data /* Column addresses */ movb $4, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data testb $0xf, %al jz spd_invalid_data /* Physical Banks */ movb $5, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data cmp $1, %al jb spd_invalid_data cmp $2, %al ja spd_invalid_data /* Module Data Width */ movb $7, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data cmpb $0, %al jne spd_invalid_data movb $6, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data cmpb $64, %al je 1f cmpb $72, %al je 1f jmp spd_unsupported_data 1: /* Cycle time at highest CAS latency CL=X */ movb $9, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data /* SDRAM type */ movb $11, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data /* Refresh Interval */ movb $12, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data /* SDRAM Width */ movb $13, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data andb $0x7f, %al cmpb $4, %al je 1f cmpb $8, %al je 1f jmp spd_unsupported_data 1: /* Back-to-Back Random Column Accesses */ movb $15, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data testb %al, %al jz spd_invalid_data cmpb $4, %al ja spd_unsupported_data /* Burst Lengths */ movb $16, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data testb $(1<<2), %al jz spd_unsupported_data /* Logical Banks */ movb $17, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data testb %al, %al jz spd_invalid_data /* Supported CAS Latencies */ movb $18, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data testb $(1 << 1), %al /* CL 1.5 */ jnz 1f testb $(1 << 2), %al /* CL 2.0 */ jnz 1f testb $(1 << 3), %al /* CL 2.5 */ jnz 1f jmp spd_unsupported_data 1: /* Cycle time at Cas Latency (CLX - 0.5) */ movb $23, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data /* Cycle time at Cas Latency (CLX - 1.0) */ movb $26, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data /* tRP Row precharge time */ movb $27, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data testb $0xfc, %al jz spd_invalid_data /* tRCD RAS to CAS */ movb $29, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data testb $0xfc, %al jz spd_invalid_data /* tRAS Activate to Precharge */ movb $30, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data testb %al, %al jz spd_invalid_data /* Module Bank Density */ movb $31, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data testb $(1<<2), %al /* 16MB */ jnz spd_unsupported_data testb $(1<<3), %al jnz spd_unsupported_data /* 32MB */ /* Address and Command Hold Time After Clock */ movb $33, %bh CALLSP(spd_read_paired_byte) jz spd_missing_data spd_verify_next_dimm: /* go to the next DIMM */ addb $(SMBUS_MEM_DEVICE_INC), %bl /* increment the smbus device */ cmpb $SMBUS_MEM_DEVICE_END, %bl jbe spd_verify_dimm spd_verify_dimms_out: RET_LABEL(spd_verify_dimms) } #endif #define spd_pre_init "Reading SPD data...\r\n" #define spd_pre_set "setting based on SPD data...\r\n" #define spd_post_init "done\r\n" static const uint32_t refresh_rate_rank[]= { /* Refresh rates ordered from most conservative (lowest) * to most agressive (highest) * disabled 0 -> rank 3 * 15.6usec 1 -> rank 1 * 7.8 usec 2 -> rank 0 * 64usec 3 -> rank 2 */ 3, 1, 0, 2 }; static const uint32_t refresh_rate_index[] = { /* Map the spd refresh rates to memory controller settings * 15.625us -> 15.6us * 3.9us -> err * 7.8us -> 7.8us * 31.3s -> 15.6us * 62.5us -> 15.6us * 125us -> 64us */ 1, 0xff, 2, 1, 1, 3 }; #define MAX_SPD_REFRESH_RATE 5 static long spd_set_dram_controller_mode (const struct mem_controller *ctrl, long dimm_mask) { int i; uint32_t dword; int value; uint32_t ecx; uint32_t edx; /* Read the inititial state */ dword = pci_read_config32(ctrl->d0, 0x7c); #if 0 /* Test if ECC cmos option is enabled */ movb $RTC_BOOT_BYTE, %al outb %al, $0x70 inb $0x71, %al testb $(1<<2), %al jnz 1f /* Clear the ecc enable */ andl $~(3 << 20), %esi 1: #endif /* Walk through all dimms and find the interesection of the support * for ecc sdram and refresh rates */ for(i = 0; i < DIMM_SOCKETS; i++) { if (!(dimm_mask & (1 << i))) { continue; } /* Test to see if I have ecc sdram */ value = spd_read_byte(ctrl->channel0[i], 11); /* SDRAM type */ if(value < 0) continue; if(value !=2 ) { /* Clear the ecc enable */ dword &= ~(3 << 20); } value = spd_read_byte(ctrl->channel0[i], 12); /* SDRAM refresh rate */ if(value < 0 ) continue; value &= 0x7f; if(value > MAX_SPD_REFRESH_RATE) { print_err("unsupported refresh rate\r\n");} // if(value == 0xff) { print_err("unsupported refresh rate\r\n");} ecx = refresh_rate_index[value]; /* Isolate the old refresh rate setting */ /* Load the refresh rate ranks */ edx = refresh_rate_rank[(dword >> 8) & 3]<<8; edx |= refresh_rate_rank[ecx] & 0xff; /* See if the new refresh rate is more conservative than the old * refresh rate setting. (Lower ranks are more conservative) */ if((edx & 0xff)< ((edx >> 8) & 0xff) ) { /* Clear the old refresh rate */ dword &= ~(3<<8); /* Move in the new refresh rate */ dword |= (ecx<<8); } value = spd_read_byte(ctrl->channel0[i], 33); /* Address and command hold time after clock */ if(value < 0) continue; if(value >= 0xa0) { /* At 133Mhz this constant should be 0x75 */ dword &= ~(1<<16); /* Use two clock cyles instead of one */ } /* go to the next DIMM */ } /* Now write the controller mode */ pci_write_config32(ctrl->d0, 0x7c, dword); return dimm_mask; } static long spd_enable_clocks(const struct mem_controller *ctrl, long dimm_mask) { int i; uint32_t dword; int value; /* Read the inititial state */ dword = pci_read_config32(ctrl->d0, 0x8c); #if 0 # Intel clears top bit here, should we? # No the default is on and for normal timming it should be on. Tom Z andl $0x7f, %esi #endif for(i = 0; i < DIMM_SOCKETS; i++) { if (!(dimm_mask & (1 << i))) { continue; } /* Read any spd byte to see if the dimm is present */ value = spd_read_byte(ctrl->channel0[i], 5); /* Physical Banks */ if(value < 0) continue; dword &= ~(1<d0, 0x8c, dword); return dimm_mask; } static const uint16_t cas_latency_80[] = { /* For cas latency 2.0 0x01 works and until I see a large test sample * I am not prepared to change this value, to the intel recommended value * of 0x0d. Eric Biederman */ /* The E7501 requires b1 rather than 01 for CAS2 or memory will be hosed * CAS 1.5 is claimed to be unsupported, will try to test that * will need to determine correct values for other CAS values * (perhaps b5, b1, b6?) * Steven James 02/06/2003 */ //# .byte 0x05, 0x01, 0x06 //# .byte 0xb5, 0xb1, 0xb6 0x0, 0x0bb1, 0x0662 /* RCVEN */ }; static const uint16_t cas_latency_80_4dimms[] = { 0x0, 0x0bb1, 0x0882 }; static const uint8_t cas_latency_78[] = { DRT_CAS_1_5, DRT_CAS_2_0, DRT_CAS_2_5 }; static long spd_set_cas_latency(const struct mem_controller *ctrl, long dimm_mask) { /* Walk through all dimms and find the interesection of the * supported cas latencies. */ int i; /* Initially allow cas latencies 2.5, 2.0 * which the chipset supports. */ uint32_t dword = (1<<3)| (1<<2);// esi uint32_t edi; uint32_t ecx; unsigned device; int value; uint8_t byte; uint16_t word; for(i = 0; i < DIMM_SOCKETS; i++) { if (!(dimm_mask & (1 << i))) { continue; } value = spd_read_byte(ctrl->channel0[i], 18); if(value < 0) continue; /* Find the highest supported cas latency */ ecx = log2(value & 0xff); edi = (1<< ecx); /* Remember the supported cas latencies */ ecx = (value & 0xff); /* Verify each cas latency at 133Mhz */ /* Verify slowest/highest CAS latency */ value = spd_read_byte(ctrl->channel0[i], 9); if(value < 0 ) continue; if(value > 0x75 ) { /* The bus is too fast so we cannot support this case latency */ ecx &= ~edi; } /* Verify the highest CAS latency - 0.5 clocks */ edi >>= 1; if(edi != 0) { value = spd_read_byte(ctrl->channel0[i], 23); if(value < 0 ) continue; if(value > 0x75) { /* The bus is too fast so we cannot support this cas latency */ ecx &= ~edi; } } /* Verify the highest CAS latency - 1.0 clocks */ edi >>=1; if(edi !=0) { value = spd_read_byte(ctrl->channel0[i], 25); if(value < 0 ) continue; if(value > 0x75) { /* The bus is too fast so we cannot support this cas latency */ ecx &= ~edi; } } /* Now find which cas latencies are supported for the bus */ dword &= ecx; /* go to the next DIMM */ } /* After all of the arduous calculation setup with the fastest * cas latency I can use. */ value = __builtin_bsf(dword); // bsrl = log2 how about bsfl? if(value ==0 ) return -1; ecx = value -1; byte = pci_read_config8(ctrl->d0, 0x78); byte &= ~(DRT_CAS_MASK); byte |= cas_latency_78[ecx]; pci_write_config8(ctrl->d0,0x78, byte); /* set master DLL reset */ dword = pci_read_config32(ctrl->d0, 0x88); dword |= (1<<26); /* the rest of the references are words */ // ecx<<=1; // don't need shift left, because we already define that in u16 array pci_write_config32(ctrl->d0, 0x88, dword); dword &= 0x0c0000ff; /* patch try register 88 is undocumented tnz */ dword |= 0xd2109800; pci_write_config32(ctrl->d0, 0x88, dword); word = pci_read_config16(ctrl->d0, 0x80); word &= ~(0x0fff); word |= cas_latency_80[ecx]; dword = pci_read_config32(ctrl->d0, 0x70); if((dword & 0xff) !=0 ) { dword >>=8; if((dword & 0xff)!=0) { dword >>=8; if((dword & 0xff)!=0) { dword >>= 8; if( (dword & 0xff)!=0) { word &=~(0x0fff); /* we have dimms in all 4 slots */ word |=cas_latency_80_4dimms[ecx]; } } } } pci_write_config16(ctrl->d0, 0x80, word); dword = pci_read_config32(ctrl->d0, 0x88); /* reset master DLL reset */ dword &= ~(1<<26); pci_write_config32(ctrl->d0, 0x88, dword); RAM_RESET_DDR_PTR(ctrl); return dimm_mask; } static long spd_set_dram_timing(const struct mem_controller *ctrl, long dimm_mask) { /* Walk through all dimms and find the interesection of the * supported dram timings. */ int i; uint32_t dword; int value; /* Read the inititial state */ dword = pci_read_config32(ctrl->d0, 0x78); #if 0 # Intel clears top bit here, should we? # No the default is on and for normal timming it should be on. Tom Z andl $0x7f, %esi #endif for(i = 0; i < DIMM_SOCKETS; i++) { if (!(dimm_mask & (1 << i))) { continue; } /* Trp */ value = spd_read_byte(ctrl->channel0[i], 27); if(value < 0) continue; if(value > (15<<2)) { /* At 133Mhz if row precharge time is above than 15ns than we * need 3 clocks not 2 clocks. */ dword &= ~(1<<0); } /* Trcd */ value = spd_read_byte(ctrl->channel0[i],29); if(value < 0 ) continue; if(value > (15<<2)) { /* At 133Mhz if the Minimum ras to cas delay is about 15ns we * need 3 clocks not 2 clocks. */ dword &= ~((1<<3)|(1<<1)); } /* Tras */ value = spd_read_byte(ctrl->channel0[i],30); if(value < 0 ) continue; /* Convert tRAS from ns to 133Mhz clock cycles */ value <<=1; /* mult by 2 to make 7.5 15 */ value += 15; /* Make certain we round up */ value --; value &= 0xff; /* Clear the upper bits of eax */ value /= 15; /* Don't even process small timings */ if(value >5) { uint32_t tmp; /* Die if the value is to large */ if(value>7) { die ("unsupported_rcd\r\n"); } /* Convert to clocks - 5 */ value -=5; /* Convert the existing value into clocks - 5 */ tmp = (~((dword>>9) & 3) - 1) & 3; /* See if we need a slower timing */ if(value > tmp ) { /* O.k. put in our slower timing */ dword &= ~(3<<9); dword |= ((~(value + 1)) & 3)<<9 ; } } /* Trd */ /* Set to a 7 clock read delay. This is for 133Mhz * with a CAS latency of 2.5 if 2.0 a 6 clock * delay is good */ if( (pci_read_config8(ctrl->d0, 0x78) & 0x30) ==0 ){ dword &= ~(7<<24); /* CAS latency is 2.5, make 7 clks */ } /* * Back to Back Read Turn Around */ /* Set to a 3 clock back to back read turn around. This * is good for CAS latencys 2.5 and 2.0 */ dword |= (1<<27); /* * Back to Back Read-Write Turn Around */ /* Set to a 5 clock back to back read to write turn around. * 4 is a good delay if the CAS latency is 2.0 */ if( ( pci_read_config8(ctrl->d0, 0x78) & (1<<4)) == 0) { dword &= ~(1<<28); } /* * Back to Back Write-Read Turn Around */ /* Set to a 2 clock back to back write to read turn around. * This is good for 2.5 and 2.0 CAS Latencies. */ dword |= (1<<29); } pci_write_config32(ctrl->d0, 0x78, dword); return dimm_mask; } static unsigned int spd_detect_dimms(const struct mem_controller *ctrl) { unsigned dimm_mask; int i; dimm_mask = 0; #if DEBUG_RAM_CONFIG print_debug("spd_detect_dimms:\r\n"); #endif for(i = 0; i < DIMM_SOCKETS; i++) { int byte; unsigned device; #if DEBUG_RAM_CONFIG print_debug_hex32(i); print_debug("\r\n"); #endif device = ctrl->channel0[i]; if (device) { byte = spd_read_byte(ctrl->channel0[i], 2); /* Type */ if (byte == 7) { dimm_mask |= (1 << i); } } #if 1 device = ctrl->channel1[i]; if (device) { byte = spd_read_byte(ctrl->channel1[i], 2); if (byte == 7) { dimm_mask |= (1 << (i + DIMM_SOCKETS)); } } #endif } #if 1 i = (dimm_mask>>DIMM_SOCKETS); if(i != (dimm_mask & ( (1<= (25 + 4)) { memsz += (1 << (sz.side1 - (25 + 4)) ) ; } /* Write the size of side 1 of the dimm */ byte = memsz; pci_write_config8(ctrl->d0, 0x60+(index<<1), byte); /* Make certain side2 of the dimm is at least 64MB */ if (sz.side2 >= (25 + 4)) { memsz += (1 << (sz.side2 - (25 + 4)) ) ; } /* Write the size of side 2 of the dimm */ byte = memsz; pci_write_config8(ctrl->d0, 0x61+(index<<1), byte); /* now, fill in DRBs where no physical slot exists */ for(i=index+1;i<4;i++) { pci_write_config8(ctrl->d0, 0x60+(i<<1),byte); pci_write_config8(ctrl->d0, 0x61+(i<<1),byte); } return memsz; } /* LAST_DRB_SLOT is a constant for any E7500 board */ #define LAST_DRB_SLOT 0x67 static long spd_set_ram_size(const struct mem_controller *ctrl, long dimm_mask) { int i; uint32_t memsz=0; uint16_t word; for(i = 0; i < DIMM_SOCKETS; i++) { struct dimm_size sz; if (!(dimm_mask & (1 << i))) { continue; } sz = spd_get_dimm_size(ctrl->channel0[i]); #if DEBUG_RAM_CONFIG print_debug("dimm size ="); print_debug_hex32(sz.side1); print_debug(" "); print_debug_hex32(sz.side2); print_debug("\r\n"); #endif if (sz.side1 == 0) { return -1; /* Report SPD error */ } memsz = set_dimm_size(ctrl, sz, memsz, i); } /* For now hardset everything at 128MB boundaries */ /* %ebp has the ram size in multiples of 64MB */ // cmpl $0, %ebp /* test if there is no mem - smbus went bad */ // jz no_memory_bad_smbus if(memsz < 0x30) { /* I should really adjust all of this in C after I have resources * to all of the pcie devices. */ /* Round up to 128M granularity */ memsz++; memsz &= 0xfe; memsz<<= 10; word = memsz; pci_write_config16(ctrl->d0, 0xc4, word); } else { /* FIXME will this work with 3.5G of ram? */ /* Put TOLM at 3G */ pci_write_config16(ctrl->d0, 0xc4, 0xc000); /* Hard code a 1G remap window, right after the ram */ if(memsz< 0x40){ word = 0x40; /* Ensure we are over 4G */ } else { word = memsz; } pci_write_config16(ctrl->d0, 0xc6, word); word += 0x10; pci_write_config16(ctrl->d0, 0xc8, word); } return dimm_mask; } static void sdram_set_spd_registers(const struct mem_controller *ctrl) { long dimm_mask; #if DEBUG_RAM_CONFIG print_debug(spd_pre_init); #endif //activate_spd_rom(ctrl); dimm_mask = spd_detect_dimms(ctrl); if (!(dimm_mask & ((1 << DIMM_SOCKETS) - 1))) { print_debug("No memory for this controller\n"); return; } dimm_mask = spd_enable_clocks(ctrl, dimm_mask); if (dimm_mask < 0) goto hw_spd_err; //spd_verify_dimms(ctrl); #if DEBUG_RAM_CONFIG print_debug(spd_pre_set); #endif dimm_mask = spd_set_row_attributes(ctrl,dimm_mask); if (dimm_mask < 0) goto hw_spd_err; dimm_mask = spd_set_dram_controller_mode(ctrl,dimm_mask); if (dimm_mask < 0) goto hw_spd_err; dimm_mask = spd_set_cas_latency(ctrl,dimm_mask); if (dimm_mask < 0) goto hw_spd_err; dimm_mask = spd_set_dram_timing(ctrl,dimm_mask); if (dimm_mask < 0) goto hw_spd_err; #if DEBUG_RAM_CONFIG print_debug(spd_post_init); #endif //moved from dram_post_init spd_set_ram_size(ctrl, dimm_mask); return; hw_spd_err: /* Unrecoverable error reading SPD data */ print_err("SPD error - reset\r\n"); hard_reset(); return; } /* I have finally seen ram bad enough to cause LinuxBIOS * to die in mysterious ways, before booting up far * enough to run a memory tester. This code attempts * to catch this blatantly bad ram, with a spot check. * For most cases you should boot all of the way up * and run a memory tester. */ /* Ensure I read/write each stick of bank of memory && * that I do more than 1000 bytes to avoid the northbridge cache. * Only 64M of each side of each DIMM is currently mapped, * so we can handle > 4GB of ram here. */ #if 0 #define bank_msg "Bank " #define side_msg " Side " static void verify_ram() { xorl %ecx, %ecx /* Check to see if the RAM is present, * in the specified bank and side. */ 1: movl %ecx, %ebx shrl $1, %ebx addl $((5<<8) | SMBUS_MEM_DEVICE_START), %ebx CALLSP(smbus_read_byte) jz 5f testl $1, %ecx jz 2f cmpb $2, %al jne 5f /* Display the bank and side we are spot checking. */ 2: CONSOLE_INFO_TX_STRING($bank_msg) movl %ecx, %ebx shrl $1, %ebx incl %ebx CONSOLE_INFO_TX_HEX8(%bl) CONSOLE_INFO_TX_STRING($side_msg) movl %ecx, %ebx andl $1, %ebx CONSOLE_INFO_TX_HEX8(%bl) /* Compute the memory address to spot check. */ movl %ecx, %ebx xorl %eax, %eax 3: testl %ebx, %ebx jz 4f addl $0x04000000, %eax decl %ebx jmp 3b 4: /* Spot check 512K of RAM */ movl %eax, %ebx addl $0x0007ffff, %ebx CALLSP(spot_check) 5: /* Now find the next bank and side to spot check */ incl %ecx cmpl $((SMBUS_MEM_DEVICE_END - SMBUS_MEM_DEVICE_START)<<1), %ecx jb 1b RET_LABEL(verify_ram) } #endif #if 0 static void ram_postinit(const struct mem_controller *ctrl) { #if DEBUG_RAM_CONFIG dumpnorth(); #endif /* Include a test to verify that memory is more or less working o.k. * This test is to catch programming errors and hardware that is out of * spec, not a test to see if the memory dimms are working 100% */ //# CALL_LABEL(verify_ram) spd_set_ram_size(ctrl); } #define FIRST_NORMAL_REFERENCE() CALL_LABEL(ram_postinit) #define SPECIAL_FINISHUP() CALL_LABEL(dram_finish) #endif #define ecc_pre_init "Initializing ECC state...\r\n" #define ecc_post_init "ECC state initialized.\r\n" static void dram_finish(const struct mem_controller *ctrl) { uint32_t dword; uint8_t byte; /* Test to see if ECC support is enabled */ dword = pci_read_config32(ctrl->d0, 0x7c); dword >>=20; dword &=3; if(dword == 2) { #if DEBUG_RAM_CONFIG print_debug(ecc_pre_init); #endif /* Initialize ECC bits , use ECC zero mode (new to 7501)*/ pci_write_config8(ctrl->d0, 0x52, 0x06); pci_write_config8(ctrl->d0, 0x52, 0x07); do { byte = pci_read_config8(ctrl->d0, 0x52); } while ( (byte & 0x08 ) == 0); pci_write_config8(ctrl->d0, 0x52, byte & 0xfc); #if DEBUG_RAM_CONFIG print_debug(ecc_post_init); #endif /* Clear the ECC error bits */ pci_write_config8(ctrl->d0f1, 0x80, 0x03); /* dev 0, function 1, offset 80 */ pci_write_config8(ctrl->d0f1, 0x82, 0x03); /* dev 0, function 1, offset 82 */ pci_write_config32(ctrl->d0f1, 0x40, 1<<18); /* clear dev 0, function 1, offset 40; bit 18 by writing a 1 to it */ pci_write_config32(ctrl->d0f1, 0x44, 1<<18); /* clear dev 0, function 1, offset 44; bit 18 by writing a 1 to it */ pci_write_config8(ctrl->d0, 0x52, 0x0d); } dword = pci_read_config32(ctrl->d0, 0x7c); /* FCS_EN */ dword |= (1<<17); pci_write_config32(ctrl->d0, 0x7c, dword); #if DEBUG_RAM_CONFIG dumpnorth(); #endif // verify_ram(); } #if 0 #define ERRFUNC(x, str) mem_err(x, str) ERRFUNC(invalid_dimm_type, "Invalid dimm type") ERRFUNC(spd_missing_data, "Missing sdram spd data") ERRFUNC(spd_invalid_data, "Invalid sdram spd data") ERRFUNC(spd_unsupported_data, "Unsupported sdram spd value") ERRFUNC(unsupported_page_size, "Unsupported page size") ERRFUNC(sdram_presence_mismatch, "DIMM presence mismatch") ERRFUNC(sdram_value_mismatch, "spd data does not match") ERRFUNC(unsupported_refresh_rate, "Unsuported spd refresh rate") ERRFUNC(inconsistent_cas_latencies, "No cas latency supported by all dimms") ERRFUNC(unsupported_rcd, "Unsupported ras to cas delay") #undef ERRFUNC #define mem_err_err "ERROR: " #define mem_err_pair " on dimm pair " #define mem_err_byte " spd byte " static void mem_err { movl %ebx, %edi CONSOLE_ERR_TX_STRING($mem_err_err) CONSOLE_ERR_TX_STRING(%esi) CONSOLE_ERR_TX_STRING($mem_err_pair) movl %edi, %ebx subb $(SMBUS_MEM_DEVICE_START), %bl CONSOLE_ERR_TX_HEX8(%bl) CONSOLE_ERR_TX_STRING($mem_err_byte) movl %edi, %ebx CONSOLE_ERR_TX_HEX8(%bh) jmp mem_stop } #endif #if ASM_CONSOLE_LOGLEVEL > BIOS_DEBUG #define ram_enable_1 "Ram Enable 1\r\n" #define ram_enable_2 "Ram Enable 2\r\n" #define ram_enable_3 "Ram Enable 3\r\n" #define ram_enable_4 "Ram Enable 4\r\n" #define ram_enable_5 "Ram Enable 5\r\n" #define ram_enable_6 "Ram Enable 6\r\n" #define ram_enable_7 "Ram Enable 7\r\n" #define ram_enable_8 "Ram Enable 8\r\n" #define ram_enable_9 "Ram Enable 9\r\n" #define ram_enable_10 "Ram Enable 10\r\n" #define ram_enable_11 "Ram Enable 11\r\n" #endif /* Estimate that SLOW_DOWN_IO takes about 50&76us*/ /* delay for 200us */ #define DO_DELAY \ udelay(200); // for(i=0; i<16;i++) { SLOW_DOWN_IO } #define EXTRA_DELAY DO_DELAY static void sdram_enable(int controllers, const struct mem_controller *ctrl) { int i; uint32_t mchtst; /* 1 & 2 Power up and start clocks */ /* arg! the parts are memory mapped! For now, just grab address 0xc0000000 as the base, since I want to use * constants, not variables, for this. */ mchtst = pci_read_config32(ctrl->d0, 0xf4); mchtst |= (1 << 22); pci_write_config32(ctrl->d0, 0xf4, mchtst); #if DEBUG_RAM_CONFIG print_debug(ram_enable_1); print_debug(ram_enable_2); #endif /* A 200us delay is needed */ DO_DELAY EXTRA_DELAY /* 3. Apply NOP */ #if DEBUG_RAM_CONFIG print_debug(ram_enable_3); #endif RAM_NOP(ctrl); EXTRA_DELAY /* 4 Precharge all */ #if DEBUG_RAM_CONFIG print_debug(ram_enable_4); #endif RAM_PRECHARGE(ctrl); EXTRA_DELAY /* wait until the all banks idle state... */ /* 5. Issue EMRS to enable DLL */ #if DEBUG_RAM_CONFIG print_debug(ram_enable_5); #endif RAM_EMRS(ctrl); EXTRA_DELAY /* 6. Reset DLL */ #if DEBUG_RAM_CONFIG print_debug(ram_enable_6); #endif RAM_MRS(ctrl,1); EXTRA_DELAY /* Ensure a 200us delay between the DLL reset in step 6 and the final * mode register set in step 9. * Infineon needs this before any other command is sent to the ram. */ DO_DELAY EXTRA_DELAY /* 7 Precharge all */ #if DEBUG_RAM_CONFIG print_debug(ram_enable_7); #endif RAM_PRECHARGE(ctrl); EXTRA_DELAY /* 8 Now we need 2 AUTO REFRESH / CBR cycles to be performed */ #if DEBUG_RAM_CONFIG print_debug(ram_enable_8); #endif RAM_CBR(ctrl); EXTRA_DELAY RAM_CBR(ctrl); EXTRA_DELAY /* And for good luck 6 more CBRs */ RAM_CBR(ctrl); EXTRA_DELAY RAM_CBR(ctrl); EXTRA_DELAY RAM_CBR(ctrl); EXTRA_DELAY RAM_CBR(ctrl); EXTRA_DELAY RAM_CBR(ctrl); EXTRA_DELAY RAM_CBR(ctrl); EXTRA_DELAY /* 9 mode register set */ #if DEBUG_RAM_CONFIG print_debug(ram_enable_9); #endif RAM_MRS(ctrl,0); EXTRA_DELAY /* 10 DDR Receive FIFO RE-Sync */ #if DEBUG_RAM_CONFIG print_debug(ram_enable_10); #endif RAM_RESET_DDR_PTR(ctrl); EXTRA_DELAY /* 11 normal operation */ #if DEBUG_RAM_CONFIG print_debug(ram_enable_11); #endif RAM_NORMAL(ctrl); // special from v1 //FIRST_NORMAL_REFERENCE(); //spd_set_ram_size(ctrl, 0x03); /* Finally enable refresh */ ENABLE_REFRESH(ctrl); //SPECIAL_FINISHUP(); dram_finish(ctrl); }