sravan/system76-coreboot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
system76-coreboot/src/northbridge/intel/i855pm/raminit.c
Ronald G. Minnich 52c2277a1b adl855pc support 
git-svn-id: svn://svn.coreboot.org/coreboot/trunk@1772 2b7e53f0-3cfb-0310-b3e9-8179ed1497e1
2004-11-10 15:12:48 +00:00

1595 lines
42 KiB
C
Raw Blame History

/* This was originally for the e7500, modified for i855pm
*/
/* the 855pm uses only
* memory type (must be ddr)
* number of row addresses, not counting bank addresses
* number of column addresses
* number of so-dimm banks
* ecc, no ecc
* refresh rate/type
* number banks on each device
*
* that's it. No other bytes are used.
* these are bytes
* 2, 3, 4, 5, 11, 12 17
*/
/* converted to C 6/2004 yhlu */
#define DEBUG_RAM_CONFIG 1
#undef ASM_CONSOLE_LOGLEVEL
#define ASM_CONSOLE_LOGLEVEL 9
#define dumpnorth() dump_pci_device(PCI_DEV(0, 0, 1))
/* 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*/
/* WOW! this could be bad! sets casl to 2 without checking! */
#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<4;i++) {*/
for(i=0;i<1;i++) {
/* Set the ram command */
byte = pci_read_config8(ctrl->d0, 0x70);
byte &= 0x8f;
byte |= (uint8_t)(value & 0xff);
#if DEBUG_RAM_CONFIG
print_debug("R:");
print_debug_hex8(byte);
print_debug("\r\n");
#endif
pci_write_config8(ctrl->d0, 0x70, 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);
#if DEBUG_RAM_CONFIG
print_debug("Done\r\n");
#endif
/* Go to the next base address */
dword += 0x0200000;
}
/* 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, 0x60);
/* Transform it into the form expected by SDRAM */
dword = ram_cas_latency[(byte>>5) & 1];
#warning RAM_MRS -- using BROKEN hard-wired CAS 2.0. FIX ME SOON
/*
*/
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, 0x70);
byte &= 0x8f;
byte |= (RAM_COMMAND_NORMAL << 4);
pci_write_config8(ctrl->d0, 0x70, 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, 0x70);
dword |= (1 << 29);
pci_write_config32(ctrl->d0, 0x70, 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 */
0x40, 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
* 0x60
* [31:31] tWTR -- MBZ
* [30:30] tWR 0 is 2, 1 is 3 clocks
* [29:28] back to back write-read commands spacing
* different rows
* 00 4, 01 3, 10 2, 11 reserved
*
* [27:26] same or different
* CL + .5x BL + TA(RD-WR) - DQSS
* wow that's hard!
* 00 7, 01 6, 10 5, 11 4
* 00 4, 01 3, 10 2, 11 reserved
*
* [25:25] Back to Back Read-read spacing
* .5xBL + TA(RD-RD)
* 0 4 , 1 3
*
* [24:15] Reserved
*
* [14:12] Refresh cycle time
* 000 14, 001 13, 010 12, 011 11, 100 10, 101 9, 110 8, 111 7
*
* [11:11] tRAS, max
* 0 120 us, 1 reserved
*
* [10:09] Active to Precharge (tRAS)
* 00 == 8 clocks
* 01 == 7 clocks
* 10 == 6 clocks
* 11 == 5 clocks
* [08:07] Reserved
* [06:05] Cas Latency (tCL)
* 00 == 2.5 Clocks
* 01 == 2.0 Clocks (default)
* 10 == Reserved
* 11 == Reserved
* [04:04] Reserved
* [03:02] Ras# to Cas# Delay (tRCD)
* 00 == 4 DRAM Clocks
* 01 == 3 DRAM Clocks
* 10 == 2 DRAM Clocks
* 11 == reserved
* [01:00] DRAM RAS# to Precharge (tRP)
* 00 == 4 DRAM Clocks
* 01 == 3 DRAM Clocks
* 10 == 2 DRAM Clocks
* 11 == reserved
*/
#define DRT_CAS_2_5 (0<<5)
#define DRT_CAS_2_0 (1<<5)
#define DRT_CAS_MASK (3<<5)
#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
#endif
/* bios is 0x2a004425 */
/* default hardware is 18004425 */
/* no setting for now */
/* 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
*/
0x70, 0xdf0f6c7f, 0,
/* undocumnted shit */
0x80, 0, 0xaf0031,
};
/*
* 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.
*
*/
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_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_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.
*/
/* the hell with that! just use byte 31 -- rgm */
value = spd_read_byte(device, 31); /* size * 4 MB */
value = log2(value);
/* this is in 4 MB chunks, or 32 MBits chunks.
* log base 2 of 32 Mbits is log2 of (32*1024*1024) is 25
* so add 25
*/
value += 25;
sz.side1 = value;
sz.side2 = 0;
#if DEBUG_RAM_CONFIG
print_debug("returned size log 2 in bits is :");
print_debug_hex32(value);
print_debug("\r\n");
#endif
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;
uint16_t word=0x7777;
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");
}
/* Convert to the format needed for the DRA register */
/* subtract 3 (there are 8 bytes)
* then subtract 11
* (since 12 bit size should map to a value of 1)
* so subtract 14 total
*/
sz.side1-=14;
/* Place in the %ebp the dra place holder */ /*i*/
word &= ~(7<<i);
word |= 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");
}
/* Convert to the format needed for the DRA register */
sz.side2-=14;
/* Place in the %ebp the dra place holder */ /*i*/
word &= ~(7<<i);
word |= sz.side2<<((i<<3) + 4 );
}
}
/* go to the next DIMM */
}
/* Write the new row attributes register */
pci_write_config32(ctrl->d0, 0x50, word);
return dimm_mask;
}
#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 -> 15.6us
*/
1, 0xff, 2, 1, 1, 1
};
#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;
/* on this chipset we only do refresh "slow" or "fast" for now */
/* we start out assuming "slow" (15.6 microseconds) */
uint32_t refrate = 1; /* better than 7.8 */
/* Read the inititial state */
dword = pci_read_config32(ctrl->d0, 0x70);
/* WTF? */
/*dword |= 0x10000;*/
#if 0 /* DEBUG_RAM_CONFIG*/
print_debug("spd_detect_dimms: 0x70.l is:");
print_debug_hex32(dword);
print_debug("\r\n");
#endif
#if 0
/* Test if ECC cmos option is enabled */
/* Clear the ecc enable */
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 ) {
#if DEBUG_RAM_CONFIG
print_debug("spd_detect_dimms:\r\n");
#endif
/* Clear the ecc enable */
dword &= ~(3 << 20);
#if 0 &&DEBUG_RAM_CONFIG
print_debug("spd_detect_dimms: no ecc so set:");
print_debug_hex32(dword);
print_debug("\r\n");
#endif
}
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");}*/
#if DEBUG_RAM_CONFIG
print_debug("spd_detect_dimms: ref rate index:");
print_debug_hex8(value);
print_debug("\r\n");
#endif
if (value == 2) /* have to go faster */
refrate = 2;
#if 0 &&DEBUG_RAM_CONFIG
print_debug("spd_detect_dimms: dword is now w/refresh:");
print_debug_hex32(dword);
print_debug("\r\n");
#endif
/* no applicability here but there are similar things
* we'll try later.
*/
#if 0
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 */
}
#endif
/* go to the next DIMM */
}
/* set the refrate now */
dword |= (refrate << 7);
/* Now write the controller mode */
pci_write_config32(ctrl->d0, 0x70, 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);
/*
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
*/
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<<i);
}
pci_write_config32(ctrl->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_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 const unsigned int bustimings[8] = {
/* first four are for GM part */
266, 200, 200, -1,
/* and then the GME part */
266, 200, 200, 333
};
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;
/* well, shit. Intel has not seen fit to document the observed
* setting for these bits. On my chipset it is 3 right now, and
* that's not in the table documented for this chip.
* What a shame. We will assume 133 mhz I guess? not sure.
* also they say in one place it is two bits and in another
* they say it is 3 bits! we'll assume two bits, that's
* the only one that makes sense.
*/
uint32_t rambusfrequency;
uint32_t ramindex;
/* what kind of chip is it? */
/* only bit that really matters is high order bit ... */
/* here is a problem with the memory controller struct ...
* ram control is spread across d0/d1 on this part!
*/
ramindex = pci_read_config8(PCI_DEV(0,0,0), 0x44);
ramindex >>= 5;
/* compute the index into the table. Use the type of chip
* as the high order bit and the 0:0.3:c0 & 7 as the low
* order four bits.
*/
ramindex |= pci_read_config8(PCI_DEV(0,0,3), 0xc0) & 7;
/* we now have an index into the clock rate table ... */
rambusfrequency = bustimings[ramindex];
/* Read the inititial state */
dword = pci_read_config32(ctrl->d0, 0x60);
#if DEBUG_RAM_CONFIG >= 10
print_debug("spd_detect_dimms: bus timing index: ");
print_debug_hex32(ramindex);
print_debug(" and speed ");
print_debug_hex32(rambusfrequency);
print_debug("\r\n");
#endif
/* for now, since we are on deadline, set to "known good" and
* fix later.
*/
pci_write_config32(ctrl->d0, 0x60, 0x2a004425);
return dimm_mask;
/*
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
*/
/* HERE. WHat's the frequency kenneth? */
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, 0x60, 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);
}
}
}
return dimm_mask;
}
static uint32_t set_dimm_size(const struct mem_controller *ctrl, struct dimm_size sz, uint32_t memsz, unsigned index)
{
int i;
uint32_t base0, base1;
uint32_t dch;
uint8_t byte;
/* I think size2 is always 0 ... */
/* Double the size if we are using dual channel memory */
if (sz.side1 != sz.side2) {
sz.side2 = 0;
}
/* Make certain side1 of the dimm is at least 32MB */
/* This 28 is weird.
* sz.size1 is log2 size in bits.
* so what's 28? So think of it as this:
* in log2 space: 10 + 10 + 8, i.e. 1024 * 1024 * 256 or
* 256 Mbits, or 32 Mbytes.
*/
/* this is from the e7500 code and it's just wrong for small dimes (< 64 MB)
* However, realistically, this case will never happen! the dimms are all bigger ...
* so skip the conditional completely.
* if (sz.side1 >= (28)) { }
*/
memsz += (1 << (sz.side1 - (28)) ) ;
/* Write the size of side 1 of the dimm */
#if DEBUG_RAM_CONFIG
print_debug("Write size ");
print_debug_hex8(memsz);
print_debug(" to ");
print_debug_hex8(0x40 + index);
print_debug("\r\n");
#endif
byte = memsz;
pci_write_config8(ctrl->d0, 0x40+index, byte);
/* now, fill in DRBs where no physical slot exists */
for(i=index+1;i<4;i++) {
pci_write_config8(ctrl->d0, 0x40+i, byte);
}
return memsz;
}
#define LAST_DRB_SLOT 0x43
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);
}
#if 0
/* 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);
}
#endif
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;
/* skip for now until we just get "known good" up
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);
dump_pci_device(PCI_DEV(0,0,1));
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.
*/
static void ram_postinit(const struct mem_controller *ctrl) {
#if DEBUG_RAM_CONFIG
dumpnorth();
#endif
/*spd_set_ram_size(ctrl);*/
}
#define FIRST_NORMAL_REFERENCE() CALL_LABEL(ram_postinit)
#define SPECIAL_FINISHUP() CALL_LABEL(dram_finish)
#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, 0x70);
dword >>=20;
dword &=1;
if(dword == 1) {
#if DEBUG_RAM_CONFIG
print_debug(ecc_pre_init);
#endif
#if DEBUG_RAM_CONFIG
print_debug(ecc_post_init);
#endif
#if 0
/* Clear the ECC error bits */
dword = pci_read_config32(ctrl->d0, 0x7c); /* FCS_EN */
dword |= (1<<17);
pci_write_config32(ctrl->d0, 0x7c, dword);
#endif
}
#if DEBUG_RAM_CONFIG
dumpnorth();
#endif
/* verify_ram(); */
}
#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 */
void udelay(int usecs)
{
int i;
for(i = 0; i < usecs; i++)
outb(i&0xff, 0x80);
}
#if 0
static void DO_DELAY(void){
udelay(200);
}
#endif
#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 */
/* let the games begin. More undocumented shit, so we'll just set it
* as intel sets it
*/
mchtst = pci_read_config32(ctrl->d0, 0x68);
#if DEBUG_RAM_CONFIG
print_debug(ram_enable_1);
print_debug_hex32(mchtst);
dumpnorth();
#endif
/*
mchtst = 0x10f10038;
pci_write_config32(ctrl->d0, 0x68, mchtst);
* can't find a ram power register ...
*/
#if DEBUG_RAM_CONFIG
print_debug(ram_enable_2);
#endif
/* A 200us delay is needed */
DO_DELAY
EXTRA_DELAY
/* 3. Apply NOP */
#if DEBUG_RAM_CONFIG
dump_pci_device(PCI_DEV(0, 0, 0)) ;
print_debug(ram_enable_3);
#endif
RAM_NOP(ctrl);
EXTRA_DELAY
#undef DEBUG_RAM_CONFIG
#define DEBUG_RAM_CONFIG 0
/* 4 Precharge all */
#if DEBUG_RAM_CONFIG
print_debug(ram_enable_4);
#endif
#undef DEBUG_RAM_CONFIG
#define DEBUG_RAM_CONFIG 0
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);
{ char *c = (char *) 0;
*c = 'a';
print_debug("Test: ");
print_debug_hex8(*c);
print_debug("\r\n");
}
}
Reference in New Issue View Git Blame Copy Permalink