Changeset 5073


Ignore:
Timestamp:
Feb 1, 2010, 10:51:18 PM (6 years ago)
Author:
linux_junkie
Message:

Alot of it is trivial clean ups and 830 is now able to initialize one row/side of memory at a time.
Signed-off-by: Joseph Smith <joe@…>
Acked-by: Stefan Reinauer <stepan@…>

Location:
trunk/src
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/mainboard/rca/rm4100/auto.c

    r5069 r5073  
    7070
    7171#include "northbridge/intel/i82830/raminit.c"
    72 #include "lib/generic_sdram.c"
    7372
    7473/**
     
    104103static void main(unsigned long bist)
    105104{
    106         static const struct mem_controller memctrl[] = {
    107                 {
    108                         .d0 = PCI_DEV(0, 0, 0),
    109                         .channel0 = {0x50, 0x51},
    110                 }
    111         };
    112 
    113105        if (bist == 0)
    114106                early_mtrr_init();
     
    130122        mb_early_setup();
    131123
    132         /* SDRAM init */
    133         sdram_set_registers(memctrl);
    134         sdram_set_spd_registers(memctrl);
    135         sdram_enable(0, memctrl);
     124        /* Initialize memory */
     125        sdram_initialize();
    136126
    137127        /* Check RAM. */
  • trunk/src/mainboard/thomson/ip1000/auto.c

    r5069 r5073  
    7070
    7171#include "northbridge/intel/i82830/raminit.c"
    72 #include "lib/generic_sdram.c"
    7372
    7473/**
     
    104103static void main(unsigned long bist)
    105104{
    106         static const struct mem_controller memctrl[] = {
    107                 {
    108                         .d0 = PCI_DEV(0, 0, 0),
    109                         .channel0 = {0x50, 0x51},
    110                 }
    111         };
    112 
    113105        if (bist == 0)
    114106                early_mtrr_init();
     
    130122        mb_early_setup();
    131123
    132         /* SDRAM init */
    133         sdram_set_registers(memctrl);
    134         sdram_set_spd_registers(memctrl);
    135         sdram_enable(0, memctrl);
     124        /* Initialize memory */
     125        sdram_initialize();
    136126
    137127        /* Check RAM. */
  • trunk/src/northbridge/intel/i82830/raminit.c

    r3653 r5073  
    22 * This file is part of the coreboot project.
    33 *
    4  * Copyright (C) 2008 Joseph Smith <joe@smittys.pointclark.net>
     4 * Copyright (C) 2008-2010 Joseph Smith <joe@settoplinux.org>
    55 *
    66 * This program is free software; you can redistribute it and/or modify
     
    6868
    6969/*-----------------------------------------------------------------------------
    70 SDRAM configuration functions.
     70DIMM-initialization functions.
    7171-----------------------------------------------------------------------------*/
    7272
    73 /* Send the specified RAM command to all DIMMs. */
    74 
    75 static void do_ram_command(const struct mem_controller *ctrl, uint32_t command,
    76                            uint32_t addr_offset)
    77 {
    78         int i;
    79         uint8_t dimm_start, dimm_end;
     73static void do_ram_command(uint32_t command)
     74{
    8075        uint32_t reg32;
    8176
    8277        /* Configure the RAM command. */
    83         reg32 = pci_read_config32(ctrl->d0, DRC);
     78        reg32 = pci_read_config32(NORTHBRIDGE, DRC);
    8479        /* Clear bits 29, 10-8, 6-4. */
    8580        reg32 &= 0xdffff88f;
    8681        reg32 |= command << 4;
    87         pci_write_config32(ctrl->d0, DRC, reg32);
    88 
    89         /* Send the ram command to each row of memory.
    90          * (DIMM_SOCKETS * 2) is the maximum number of rows possible.
    91          * Note: Each DRB defines the upper boundary address of
    92          * each SDRAM row in 32-MB granularity.
    93          */
     82        pci_write_config32(NORTHBRIDGE, DRC, reg32);
     83        PRINT_DEBUG("RAM command 0x");
     84        PRINT_DEBUG_HEX32(reg32);
     85        PRINT_DEBUG("\r\n");
     86}
     87
     88static void ram_read32(uint8_t dimm_start, uint32_t offset)
     89{
     90        if (offset == 0x55aa55aa) {
     91                PRINT_DEBUG("  Reading RAM at 0x");
     92                PRINT_DEBUG_HEX32(dimm_start * 32 * 1024 * 1024);
     93                PRINT_DEBUG(" => 0x");
     94                PRINT_DEBUG_HEX32(read32(dimm_start * 32 * 1024 * 1024));
     95                PRINT_DEBUG("\r\n");
     96
     97                PRINT_DEBUG("  Writing RAM at 0x");
     98                PRINT_DEBUG_HEX32(dimm_start * 32 * 1024 * 1024);
     99                PRINT_DEBUG(" <= 0x");
     100                PRINT_DEBUG_HEX32(offset);
     101                PRINT_DEBUG("\r\n");
     102                write32(dimm_start * 32 * 1024 * 1024, offset);
     103
     104                PRINT_DEBUG("  Reading RAM at 0x");
     105                PRINT_DEBUG_HEX32(dimm_start * 32 * 1024 * 1024);
     106                PRINT_DEBUG(" => 0x");
     107                PRINT_DEBUG_HEX32(read32(dimm_start * 32 * 1024 * 1024));
     108                PRINT_DEBUG("\r\n");
     109        } else {
     110                PRINT_DEBUG("  Sending RAM command to 0x");
     111                PRINT_DEBUG_HEX32((dimm_start * 32 * 1024 * 1024) + offset);
     112                PRINT_DEBUG("\r\n");
     113                read32((dimm_start * 32 * 1024 * 1024) + offset);
     114        }
     115}
     116
     117static void initialize_dimm_rows(void)
     118{
     119        int i, row;
     120        uint8_t dimm_start, dimm_end;
     121        unsigned device;
     122
    94123        dimm_start = 0;
    95124
    96         for (i = 0; i < (DIMM_SOCKETS * 2); i++) {
    97                 dimm_end = pci_read_config8(ctrl->d0, DRB + i);
     125        for (row = 0; row < (DIMM_SOCKETS * 2); row++) {
     126
     127                switch (row) {
     128                        case 0:
     129                                device = DIMM_SPD_BASE;
     130                                break;
     131                        case 1:
     132                                device = DIMM_SPD_BASE;
     133                                break;
     134                        case 2:
     135                                device = DIMM_SPD_BASE + 1;
     136                                break;
     137                        case 3:
     138                                device = DIMM_SPD_BASE + 1;
     139                                break;
     140                }
     141
     142                dimm_end = pci_read_config8(NORTHBRIDGE, DRB + row);
     143
    98144                if (dimm_end > dimm_start) {
    99                         PRINT_DEBUG("    Sending RAM command 0x");
    100                         PRINT_DEBUG_HEX32(reg32);
    101                         PRINT_DEBUG(" to 0x");
    102                         PRINT_DEBUG_HEX32((dimm_start * 32 * 1024 * 1024) + addr_offset);
    103                         PRINT_DEBUG("\r\n");
    104                         read32((dimm_start * 32 * 1024 * 1024) + addr_offset);
     145                        print_debug("Initializing SDRAM Row ");
     146                        print_debug_hex8(row);
     147                        print_debug("\r\n");
     148
     149                        /* NOP command */
     150                        PRINT_DEBUG(" NOP ");
     151                        do_ram_command(RAM_COMMAND_NOP);
     152                        ram_read32(dimm_start, 0);
     153                        udelay(200);
     154
     155                        /* Pre-charge all banks (at least 200 us after NOP) */
     156                        PRINT_DEBUG(" Pre-charging all banks ");
     157                        do_ram_command(RAM_COMMAND_PRECHARGE);
     158                        ram_read32(dimm_start, 0);
     159                        udelay(1);
     160
     161                        /* 8 CBR refreshes (Auto Refresh) */
     162                        PRINT_DEBUG(" 8 CBR refreshes ");
     163                        for (i = 0; i < 8; i++) {
     164                                do_ram_command(RAM_COMMAND_CBR);
     165                                ram_read32(dimm_start, 0);
     166                                udelay(1);
     167                        }
     168
     169                        /* MRS command */
     170                        /* TODO: Set offset 0x1d0 according to DRT values */
     171                        PRINT_DEBUG(" MRS ");
     172                        do_ram_command(RAM_COMMAND_MRS);
     173                        ram_read32(dimm_start, 0x1d0);
     174                        udelay(2);
     175
     176                        /* Set GMCH-M Mode Select bits back to NORMAL operation mode */
     177                        PRINT_DEBUG(" Normal operation mode ");
     178                        do_ram_command(RAM_COMMAND_NORMAL);
     179                        ram_read32(dimm_start, 0);
     180                        udelay(1);
     181
     182                        /* Perform a dummy memory read/write cycle */
     183                        PRINT_DEBUG(" Performing dummy read/write\r\n");
     184                        ram_read32(dimm_start, 0x55aa55aa);
     185                        udelay(1);
    105186                }
    106187                /* Set the start of the next DIMM. */
     
    123204        int i, module_density, dimm_banks;
    124205        sz.side1 = 0;
    125         module_density = spd_read_byte(device, 31);
    126         dimm_banks = spd_read_byte(device, 5);
     206        module_density = spd_read_byte(device, SPD_DENSITY_OF_EACH_ROW_ON_MODULE);
     207        dimm_banks = spd_read_byte(device, SPD_NUM_DIMM_BANKS);
    127208
    128209        /* Find the size of side1. */
     
    164245}
    165246
    166 static void spd_set_dram_size(const struct mem_controller *ctrl)
     247static void set_dram_row_boundaries(void)
    167248{
    168249        int i, value, drb1, drb2;
     
    171252                struct dimm_size sz;
    172253                unsigned device;
    173                 device = ctrl->channel0[i];
     254                device = DIMM_SPD_BASE + i;
    174255                drb1 = 0;
    175256                drb2 = 0;
    176257
    177258                /* First check if a DIMM is actually present. */
    178                 if (spd_read_byte(device, 2) == 0x4) {
     259                if (spd_read_byte(device, SPD_MEMORY_TYPE) == 0x4) {
    179260                        print_debug("Found DIMM in slot ");
    180261                        print_debug_hex8(i);
     
    191272                        print_debug(" on side 2\r\n");
    192273
     274                        /* - Memory compatibility checks - */
    193275                        /* Test for PC133 (i82830 only supports PC133) */
    194276                        /* PC133 SPD9 - cycle time is always 75 */
    195                         if (spd_read_byte(device, 9) != 0x75) {
     277                        if (spd_read_byte(device, SPD_MIN_CYCLE_TIME_AT_CAS_MAX) != 0x75) {
    196278                                print_err("SPD9 DIMM Is Not PC133 Compatable\r\n");
    197279                                die("HALT\r\n");
    198280                        }
    199281                        /* PC133 SPD10 - access time is always 54 */
    200                         if (spd_read_byte(device, 10) != 0x54) {
     282                        if (spd_read_byte(device, SPD_ACCESS_TIME_FROM_CLOCK) != 0x54) {
    201283                                print_err("SPD10 DIMM Is Not PC133 Compatable\r\n");
    202284                                die("HALT\r\n");
     
    226308                                die("HALT\r\n");
    227309                        }
     310                        /* - End Memory compatibility checks - */
    228311
    229312                        /* We need to divide size by 32 to set up the
     
    245328                /* Set the value for DRAM Row Boundary Registers */
    246329                if (i == 0) {
    247                         pci_write_config8(ctrl->d0, DRB, drb1);
    248                         pci_write_config8(ctrl->d0, DRB + 1, drb1 + drb2);
     330                        pci_write_config8(NORTHBRIDGE, DRB, drb1);
     331                        pci_write_config8(NORTHBRIDGE, DRB + 1, drb1 + drb2);
    249332                        PRINT_DEBUG("DRB 0x");
    250333                        PRINT_DEBUG_HEX8(DRB);
     
    258341                        PRINT_DEBUG("\r\n");
    259342                } else if (i == 1) {
    260                         value = pci_read_config8(ctrl->d0, DRB + 1);
    261                         pci_write_config8(ctrl->d0, DRB + 2, value + drb1);
    262                         pci_write_config8(ctrl->d0, DRB + 3,
    263                                           value + drb1 + drb2);
     343                        value = pci_read_config8(NORTHBRIDGE, DRB + 1);
     344                        pci_write_config8(NORTHBRIDGE, DRB + 2, value + drb1);
     345                        pci_write_config8(NORTHBRIDGE, DRB + 3, value + drb1 + drb2);
    264346                        PRINT_DEBUG("DRB2 0x");
    265347                        PRINT_DEBUG_HEX8(DRB + 2);
     
    277359                         * not initialize properly if we don't.
    278360                         */
    279                         value = pci_read_config8(ctrl->d0, DRB + 3);
    280                         pci_write_config8(ctrl->d0, DRB + 4, value);
    281                         pci_write_config8(ctrl->d0, DRB + 5, value);
    282                 }
    283         }
    284 }
    285 
    286 static void set_dram_row_attributes(const struct mem_controller *ctrl)
     361                        value = pci_read_config8(NORTHBRIDGE, DRB + 3);
     362                        pci_write_config8(NORTHBRIDGE, DRB + 4, value);
     363                        pci_write_config8(NORTHBRIDGE, DRB + 5, value);
     364                }
     365        }
     366}
     367
     368static void set_dram_row_attributes(void)
    287369{
    288370        int i, dra, col, width, value;
     
    290372        for (i = 0; i < DIMM_SOCKETS; i++) {
    291373                unsigned device;
    292                 device = ctrl->channel0[i];
     374                device = DIMM_SPD_BASE + i;
    293375
    294376                /* First check if a DIMM is actually present. */
    295                 if (spd_read_byte(device, 2) == 0x4) {
     377                if (spd_read_byte(device, SPD_MEMORY_TYPE) == 0x4) {
    296378                        print_debug("Found DIMM in slot ");
    297379                        print_debug_hex8(i);
     
    301383
    302384                        /* columns */
    303                         col = spd_read_byte(device, 4);
     385                        col = spd_read_byte(device, SPD_NUM_COLUMNS);
    304386
    305387                        /* data width */
    306                         width = spd_read_byte(device, 6);
     388                        width = spd_read_byte(device, SPD_MODULE_DATA_WIDTH_LSB);
    307389
    308390                        /* calculate page size in bits */
     
    313395
    314396                        /* # of banks of DIMM (single or double sided) */
    315                         value = spd_read_byte(device, 5);
     397                        value = spd_read_byte(device, SPD_NUM_DIMM_BANKS);
    316398
    317399                        if (value == 1) {
     
    356438
    357439                /* Set the value for DRAM Row Attribute Registers */
    358                 pci_write_config8(ctrl->d0, DRA + i, dra);
     440                pci_write_config8(NORTHBRIDGE, DRA + i, dra);
    359441                PRINT_DEBUG("DRA 0x");
    360442                PRINT_DEBUG_HEX8(DRA + i);
     
    365447}
    366448
    367 static void set_dram_timing(const struct mem_controller *ctrl)
     449static void set_dram_timing(void)
    368450{
    369451        /* Set the value for DRAM Timing Register */
    370452        /* TODO: Configure the value according to SPD values. */
    371         pci_write_config32(ctrl->d0, DRT, 0x00000010);
    372 }
    373 
    374 static void set_dram_buffer_strength(const struct mem_controller *ctrl)
     453        pci_write_config32(NORTHBRIDGE, DRT, 0x00000010);
     454}
     455
     456static void set_dram_buffer_strength(void)
    375457{
    376458        /* TODO: This needs to be set according to the DRAM tech
     
    381463
    382464        /* Set the value for System Memory Buffer Strength Control Registers */
    383         pci_write_config32(ctrl->d0, BUFF_SC, 0xFC9B491B);
     465        pci_write_config32(NORTHBRIDGE, BUFF_SC, 0xFC9B491B);
    384466}
    385467
     
    388470-----------------------------------------------------------------------------*/
    389471
    390 static void sdram_set_registers(const struct mem_controller *ctrl)
     472static void sdram_set_registers(void)
     473{
     474        PRINT_DEBUG("Setting initial sdram registers....\r\n");
     475
     476        /* Calculate the value for DRT DRAM Timing Register */
     477        set_dram_timing();
     478
     479        /* Setup System Memory Buffer Strength Control Registers */
     480        set_dram_buffer_strength();
     481
     482        /* Setup DRAM Row Boundary Registers */
     483        set_dram_row_boundaries();
     484
     485        /* Setup DRAM Row Attribute Registers */
     486        set_dram_row_attributes();
     487
     488        PRINT_DEBUG("Initial sdram registers have been set.\r\n");
     489}
     490
     491static void northbridge_set_registers(void)
    391492{
    392493        uint16_t value;
    393494        int igd_memory = 0;
    394495
    395         PRINT_DEBUG("Setting initial registers....\r\n");
     496        PRINT_DEBUG("Setting initial nothbridge registers....\r\n");
     497
     498        /* Set the value for Fixed DRAM Hole Control Register */
     499        pci_write_config8(NORTHBRIDGE, FDHC, 0x00);
     500
     501        /* Set the value for Programable Attribute Map Registers
     502         * Ideally, this should be R/W for as many ranges as possible.
     503         */
     504        pci_write_config8(NORTHBRIDGE, PAM0, 0x30);
     505        pci_write_config8(NORTHBRIDGE, PAM1, 0x33);
     506        pci_write_config8(NORTHBRIDGE, PAM2, 0x33);
     507        pci_write_config8(NORTHBRIDGE, PAM3, 0x33);
     508        pci_write_config8(NORTHBRIDGE, PAM4, 0x33);
     509        pci_write_config8(NORTHBRIDGE, PAM5, 0x33);
     510        pci_write_config8(NORTHBRIDGE, PAM6, 0x33);
     511
     512        /* Set the value for System Management RAM Control Register */
     513        pci_write_config8(NORTHBRIDGE, SMRAM, 0x02);
    396514
    397515        /* Set the value for GMCH Control Register #0 */
    398         pci_write_config16(ctrl->d0, GCC0, 0xA072);
     516        pci_write_config16(NORTHBRIDGE, GCC0, 0xA072);
     517
     518        /* Set the value for Aperture Base Configuration Register */
     519        pci_write_config32(NORTHBRIDGE, APBASE, 0x00000008);
    399520
    400521        /* Set the value for GMCH Control Register #1 */
     
    410531                break;
    411532        default: /* No memory */
    412                 pci_write_config16(ctrl->d0, GCC1, 0x0002);
     533                pci_write_config16(NORTHBRIDGE, GCC1, 0x0002);
    413534                igd_memory = 0x0;
    414535        }
    415536
    416         value = pci_read_config16(ctrl->d0, GCC1);
     537        value = pci_read_config16(NORTHBRIDGE, GCC1);
    417538        value |= igd_memory << 4;
    418         pci_write_config16(ctrl->d0, GCC1, value);
    419 
    420         /* Set the value for Aperture Base Configuration Register */
    421         pci_write_config32(ctrl->d0, APBASE, 0x00000008);
    422 
    423         /* Set the value for Register Range Base Address Register */
    424         pci_write_config32(ctrl->d0, RRBAR, 0x00000000);
    425 
    426         /* Set the value for Fixed DRAM Hole Control Register */
    427         pci_write_config8(ctrl->d0, FDHC, 0x00);
    428 
    429         /* Set the value for Programable Attribute Map Registers
    430          * Ideally, this should be R/W for as many ranges as possible.
    431          */
    432         pci_write_config8(ctrl->d0, PAM0, 0x30);
    433         pci_write_config8(ctrl->d0, PAM1, 0x33);
    434         pci_write_config8(ctrl->d0, PAM2, 0x33);
    435         pci_write_config8(ctrl->d0, PAM3, 0x33);
    436         pci_write_config8(ctrl->d0, PAM4, 0x33);
    437         pci_write_config8(ctrl->d0, PAM5, 0x33);
    438         pci_write_config8(ctrl->d0, PAM6, 0x33);
    439 
    440         /* Set the value for DRAM Throttling Control Register */
    441         pci_write_config32(ctrl->d0, DTC, 0x00000000);
    442 
    443         /* Set the value for System Management RAM Control Register */
    444         pci_write_config8(ctrl->d0, SMRAM, 0x02);
    445 
    446         /* Set the value for Extended System Management RAM Control Register */
    447         pci_write_config8(ctrl->d0, ESMRAMC, 0x38);
    448 
    449         PRINT_DEBUG("Initial registers have been set.\r\n");
    450 }
    451 
    452 static void sdram_set_spd_registers(const struct mem_controller *ctrl)
    453 {
    454         spd_set_dram_size(ctrl);
    455         set_dram_row_attributes(ctrl);
    456         set_dram_timing(ctrl);
    457         set_dram_buffer_strength(ctrl);
    458 }
    459 
    460 static void sdram_enable(int controllers, const struct mem_controller *ctrl)
     539        pci_write_config16(NORTHBRIDGE, GCC1, value);
     540
     541        PRINT_DEBUG("Initial northbridge registers have been set.\r\n");
     542}
     543
     544static void sdram_initialize(void)
    461545{
    462546        int i;
    463547        uint32_t reg32;
    464548
     549        /* Setup Initial SDRAM Registers */
     550        sdram_set_registers();
     551
    465552        /* 0. Wait until power/voltages and clocks are stable (200us). */
    466553        udelay(200);
    467554
    468         /* 1. Apply NOP. */
    469         PRINT_DEBUG("RAM Enable 1: Apply NOP\r\n");
    470         do_ram_command(ctrl, RAM_COMMAND_NOP, 0);
    471         udelay(200);
    472 
    473         /* 2. Precharge all. Wait tRP. */
    474         PRINT_DEBUG("RAM Enable 2: Precharge all\r\n");
    475         do_ram_command(ctrl, RAM_COMMAND_PRECHARGE, 0);
    476         udelay(1);
    477 
    478         /* 3. Perform 8 refresh cycles. Wait tRC each time. */
    479         PRINT_DEBUG("RAM Enable 3: CBR\r\n");
    480         for (i = 0; i < 8; i++) {
    481                 do_ram_command(ctrl, RAM_COMMAND_CBR, 0);
    482                 udelay(1);
    483         }
    484 
    485         /* 4. Mode register set. Wait two memory cycles. */
    486         /* TODO: Set offset according to DRT values */
    487         PRINT_DEBUG("RAM Enable 4: Mode register set\r\n");
    488         do_ram_command(ctrl, RAM_COMMAND_MRS, 0x1d0);
    489         udelay(2);
    490 
    491         /* 5. Normal operation (enables refresh) */
    492         PRINT_DEBUG("RAM Enable 5: Normal operation\r\n");
    493         do_ram_command(ctrl, RAM_COMMAND_NORMAL, 0);
    494         udelay(1);
    495 
    496         /* 6. Enable refresh and Set initialization complete. */
    497         PRINT_DEBUG("RAM Enable 6: Enable Refresh and IC\r\n");
    498         reg32 = pci_read_config32(ctrl->d0, DRC);
    499         reg32 |= ((RAM_COMMAND_REFRESH << 8) | (RAM_COMMAND_IC << 29));
    500         pci_write_config32(ctrl->d0, DRC, reg32);
     555        /* Initialize each row of memory one at a time */
     556        initialize_dimm_rows();
     557
     558        /* Enable Refresh */
     559        PRINT_DEBUG("Enabling Refresh\r\n");
     560        reg32 = pci_read_config32(NORTHBRIDGE, DRC);
     561        reg32 |= (RAM_COMMAND_REFRESH << 8);
     562        pci_write_config32(NORTHBRIDGE, DRC, reg32);
     563
     564        /* Set initialization complete */
     565        PRINT_DEBUG("Setting initialization complete\r\n");
     566        reg32 = pci_read_config32(NORTHBRIDGE, DRC);
     567        reg32 |= (RAM_COMMAND_IC << 29);
     568        pci_write_config32(NORTHBRIDGE, DRC, reg32);
     569
     570        /* Setup Initial Northbridge Registers */
     571        northbridge_set_registers();
    501572
    502573        PRINT_DEBUG("Northbridge following SDRAM init:\r\n");
  • trunk/src/northbridge/intel/i82830/raminit.h

    r3129 r5073  
    22 * This file is part of the coreboot project.
    33 *
    4  * Copyright (C) 2008 Joseph Smith <joe@smittys.pointclark.net>
     4 * Copyright (C) 2008-2010 Joseph Smith <joe@settoplinux.org>
    55 *
    66 * This program is free software; you can redistribute it and/or modify
     
    2222#define NORTHBRIDGE_INTEL_I82830_RAMINIT_H
    2323
     24/* 82830 Northbridge PCI device */
     25#define NORTHBRIDGE     PCI_DEV(0, 0, 0)
     26
    2427/* The 82830 supports max. 2 dual-sided SO-DIMMs. */
    2528#define DIMM_SOCKETS    2
    2629
    27 struct mem_controller {
    28         device_t d0;
    29         uint16_t channel0[DIMM_SOCKETS];
    30 };
     30/* DIMM0 is at 0x50, DIMM1 is at 0x51. */
     31#define DIMM_SPD_BASE   0x50
    3132
    3233#endif /* NORTHBRIDGE_INTEL_I82830_RAMINIT_H */
Note: See TracChangeset for help on using the changeset viewer.