Changeset 3632

Timestamp:

10/02/08 21:20:22 (7 weeks ago)

Author:

myles

Message:

Whitespace cleanup (trivial).

Signed-off-by: Myles Watson <mylesgw@…>
Acked-by: Myles Watson <mylesgw@…>

Location:

trunk/coreboot-v2/src/northbridge/amd/amdk8

Files:

• Config.lb (modified) (1 diff)
• amdk8_acpi.c (modified) (8 diffs)
• amdk8_f.h (modified) (7 diffs)
• amdk8_f_pci.c (modified) (4 diffs)
• coherent_ht.c (modified) (78 diffs)
• debug.c (modified) (13 diffs)
• early_ht.c (modified) (6 diffs)
• get_sblk_pci1234.c (modified) (8 diffs)
• incoherent_ht.c (modified) (43 diffs)
• northbridge.c (modified) (45 diffs)
• raminit.c (modified) (50 diffs)
• raminit_f_dqs.c (modified) (90 diffs)
• raminit_test.c (modified) (10 diffs)
• reset_test.c (modified) (1 diff)
• resourcemap.c (modified) (3 diffs)
• setup_resource_map.c (modified) (7 diffs)
• spd_ddr2.h (modified) (4 diffs)
• ssdt.dsl (modified) (2 diffs)

trunk/coreboot-v2/src/northbridge/amd/amdk8/Config.lb

@@ -20 +20 @@
 if HAVE_ACPI_TABLES
         object amdk8_acpi.o
-        makerule ssdt.c
-                depends "$(TOP)/src/northbridge/amd/amdk8/ssdt.dsl"
-                action  "iasl -p $(PWD)/ssdt -tc $(TOP)/src/northbridge/amd/amdk8/ssdt.dsl"
-                action  "perl -pi -e 's/AmlCode/AmlCode_ssdt/g' ssdt.hex"
-                action  "mv ssdt.hex ssdt.c"
-        end
-        object ./ssdt.o
+        makerule ssdt.c
+                depends "$(TOP)/src/northbridge/amd/amdk8/ssdt.dsl"
+                action  "iasl -p $(PWD)/ssdt -tc $(TOP)/src/northbridge/amd/amdk8/ssdt.dsl"
+                action  "perl -pi -e 's/AmlCode/AmlCode_ssdt/g' ssdt.hex"
+                action  "mv ssdt.hex ssdt.c"
+        end
+        object ./ssdt.o
 end
 

trunk/coreboot-v2/src/northbridge/amd/amdk8/amdk8_acpi.c

@@ -50 +50 @@
 unsigned long acpi_create_madt_lapics(unsigned long current)
 {
-        device_t cpu;
-        int cpu_index = 0;
-
-        for(cpu = all_devices; cpu; cpu = cpu->next) {
-                if ((cpu->path.type != DEVICE_PATH_APIC) ||
-                        (cpu->bus->dev->path.type != DEVICE_PATH_APIC_CLUSTER))
-                {
-                        continue;
-                }
-                if (!cpu->enabled) {
-                        continue;
-                }
-                current += acpi_create_madt_lapic((acpi_madt_lapic_t *)current, cpu_index, cpu->path.u.apic.apic_id);
-                cpu_index++;
-
-        }
-
-        return current;
+        device_t cpu;
+        int cpu_index = 0;
+
+        for(cpu = all_devices; cpu; cpu = cpu->next) {
+                if ((cpu->path.type != DEVICE_PATH_APIC) ||
+                        (cpu->bus->dev->path.type != DEVICE_PATH_APIC_CLUSTER))
+                {
+                        continue;
+                }
+                if (!cpu->enabled) {
+                        continue;
+                }
+                current += acpi_create_madt_lapic((acpi_madt_lapic_t *)current, cpu_index, cpu->path.u.apic.apic_id);
+                cpu_index++;
+
+        }
+
+        return current;
 }
 
 unsigned long acpi_create_madt_lapic_nmis(unsigned long current, u16 flags, u8 lint)
 {
-        device_t cpu;
-        int cpu_index = 0;
-
-        for(cpu = all_devices; cpu; cpu = cpu->next) {
-                if ((cpu->path.type != DEVICE_PATH_APIC) ||
-                        (cpu->bus->dev->path.type != DEVICE_PATH_APIC_CLUSTER))
-                {
-                        continue;
-                }
-                if (!cpu->enabled) {
-                        continue;
-                }
-                current += acpi_create_madt_lapic_nmi((acpi_madt_lapic_nmi_t *)current, cpu_index, flags, lint);
-                cpu_index++;
-
-        }
-
-        return current;
-}
+        device_t cpu;
+        int cpu_index = 0;
+
+        for(cpu = all_devices; cpu; cpu = cpu->next) {
+                if ((cpu->path.type != DEVICE_PATH_APIC) ||
+                        (cpu->bus->dev->path.type != DEVICE_PATH_APIC_CLUSTER))
+                {
+                        continue;
+                }
+                if (!cpu->enabled) {
+                        continue;
+                }
+                current += acpi_create_madt_lapic_nmi((acpi_madt_lapic_nmi_t *)current, cpu_index, flags, lint);
+                cpu_index++;
+
+        }
+
+        return current;
+}
+
 unsigned long acpi_create_srat_lapics(unsigned long current)
 {
-        device_t cpu;
-        int cpu_index = 0;
-
-        for(cpu = all_devices; cpu; cpu = cpu->next) {
-                if ((cpu->path.type != DEVICE_PATH_APIC) ||
-                        (cpu->bus->dev->path.type != DEVICE_PATH_APIC_CLUSTER))
-                {
-                        continue;
-                }
-                if (!cpu->enabled) {
-                        continue;
-                }
-                printk_debug("SRAT: lapic cpu_index=%02x, node_id=%02x, apic_id=%02x\n", cpu_index, cpu->path.u.apic.node_id, cpu->path.u.apic.apic_id);
-                current += acpi_create_srat_lapic((acpi_srat_lapic_t *)current, cpu->path.u.apic.node_id, cpu->path.u.apic.apic_id);
-                cpu_index++;
-
-        }
-
-        return current;
-}
-
-
+        device_t cpu;
+        int cpu_index = 0;
+
+        for(cpu = all_devices; cpu; cpu = cpu->next) {
+                if ((cpu->path.type != DEVICE_PATH_APIC) ||
+                        (cpu->bus->dev->path.type != DEVICE_PATH_APIC_CLUSTER))
+                {
+                        continue;
+                }
+                if (!cpu->enabled) {
+                        continue;
+                }
+                printk_debug("SRAT: lapic cpu_index=%02x, node_id=%02x, apic_id=%02x\n", cpu_index, cpu->path.u.apic.node_id, cpu->path.u.apic.apic_id);
+                current += acpi_create_srat_lapic((acpi_srat_lapic_t *)current, cpu->path.u.apic.node_id, cpu->path.u.apic.apic_id);
+                cpu_index++;
+
+        }
+
+        return current;
+}
 
 static unsigned long resk(uint64_t value)
 {
-        unsigned long resultk;
-        if (value < (1ULL << 42)) {
-                resultk = value >> 10;
-        }
-        else {
-                resultk = 0xffffffff;
-        }
-        return resultk;
-}
-
+        unsigned long resultk;
+        if (value < (1ULL << 42)) {
+                resultk = value >> 10;
+        }
+        else {
+                resultk = 0xffffffff;
+        }
+        return resultk;
+}
 
 struct acpi_srat_mem_state {
-        unsigned long current;
+        unsigned long current;
 };
 
 void set_srat_mem(void *gp, struct device *dev, struct resource *res)
 {
-        struct acpi_srat_mem_state *state = gp;
-        unsigned long basek, sizek;
-        basek = resk(res->base);
-        sizek = resk(res->size);
-
-        printk_debug("set_srat_mem: dev %s, res->index=%04x startk=%08x, sizek=%08x\n",
-                     dev_path(dev), res->index, basek, sizek);
-        /*
-                0-640K must be on node 0
-                next range is from 1M---
-                So will cut off before 1M in the mem range
-        */
-        if((basek+sizek)<1024) return;
-
-        if(basek<1024) {
-                sizek -= 1024 - basek;
-                basek = 1024;
-        }
-
-        state->current += acpi_create_srat_mem((acpi_srat_mem_t *)state->current, (res->index & 0xf), basek, sizek, 1); // need to figure out NV
+        struct acpi_srat_mem_state *state = gp;
+        unsigned long basek, sizek;
+        basek = resk(res->base);
+        sizek = resk(res->size);
+
+        printk_debug("set_srat_mem: dev %s, res->index=%04x startk=%08x, sizek=%08x\n",
+                     dev_path(dev), res->index, basek, sizek);
+        /*
+                0-640K must be on node 0
+                next range is from 1M---
+                So will cut off before 1M in the mem range
+        */
+        if((basek+sizek)<1024) return;
+
+        if(basek<1024) {
+                sizek -= 1024 - basek;
+                basek = 1024;
+        }
+
+        state->current += acpi_create_srat_mem((acpi_srat_mem_t *)state->current, (res->index & 0xf), basek, sizek, 1); // need to figure out NV
 }
 
 unsigned long acpi_fill_srat(unsigned long current)
 {
-        struct acpi_srat_mem_state srat_mem_state;
-
-        /* create all subtables for processors */
-        current = acpi_create_srat_lapics(current);
-
-        /* create all subteble for memory range */
-
-        /* 0-640K must be on node 0 */
-        current += acpi_create_srat_mem((acpi_srat_mem_t *)current, 0, 0, 640, 1);//enable
-#if 1
-        srat_mem_state.current = current;
-        search_global_resources(
-                IORESOURCE_MEM | IORESOURCE_CACHEABLE, IORESOURCE_MEM | IORESOURCE_CACHEABLE,
-                set_srat_mem, &srat_mem_state);
-
-        current = srat_mem_state.current;
-#endif
-        return current;
+        struct acpi_srat_mem_state srat_mem_state;
+
+        /* create all subtables for processors */
+        current = acpi_create_srat_lapics(current);
+
+        /* create all subteble for memory range */
+
+        /* 0-640K must be on node 0 */
+        current += acpi_create_srat_mem((acpi_srat_mem_t *)current, 0, 0, 640, 1);//enable
+
+        srat_mem_state.current = current;
+        search_global_resources(
+                IORESOURCE_MEM | IORESOURCE_CACHEABLE, IORESOURCE_MEM | IORESOURCE_CACHEABLE,
+                set_srat_mem, &srat_mem_state);
+
+        current = srat_mem_state.current;
+
+        return current;
 }
 
@@ -185 +183 @@
         /* fill the first 8 byte with that num */
         /* fill the next num*num byte with distance, local is 10, 1 hop mean 20, and 2 hop with 30.... */
-        
+
         /* because We has assume that we know the topology of the HT connection, So we can have set if we know the node_num */
         static uint8_t hops_8[] = {   0, 1, 1, 2, 2, 3, 3, 4,
@@ -193 +191 @@
                                       2, 3, 1, 2, 0, 1, 1, 2,
                                       3, 2, 2, 1, 1, 0, 2, 1,
-                                      3, 4, 2, 3, 1, 2, 0, 1,    
+                                      3, 4, 2, 3, 1, 2, 0, 1,
                                       4, 4, 3, 2, 2, 1, 1, 0 };
 
@@ -209 +207 @@
         for(i=0;i<sysconf.hc_possible_num;i++) {
                 if((sysconf.pci1234[i]&1) !=1 ) continue;
-                outer_node[(sysconf.pci1234[i] >> 4) & 0xf] = 1; // mark the outer node         
+                outer_node[(sysconf.pci1234[i] >> 4) & 0xf] = 1; // mark the outer node
         }
 #endif
-        
+
         for(i=0;i<nodes;i++) {
                 for(j=0;j<nodes; j++) {
@@ -235 +233 @@
                                 }
                                 p[i*nodes+j] = hops_8[i*nodes+j] * 2 + latency_factor + 10;
-#else   
+#else
                                 p[i*nodes+j] = hops_8[i*nodes+j] * 2 + 10;
 #endif
@@ -244 +242 @@
         }
 
-        current += 8+nodes*nodes;
-
-        return current;
+        current += 8+nodes*nodes;
+
+        return current;
 }
 
@@ -256 +254 @@
 static void int_to_stream(uint32_t val, uint8_t *dest)
 {
-        int i;
-        for(i=0;i<4;i++) {
-                *(dest+i) = (val >> (8*i)) & 0xff;
-        }
+        int i;
+        for(i=0;i<4;i++) {
+                *(dest+i) = (val >> (8*i)) & 0xff;
+        }
 }
 
@@ -267 +265 @@
 void update_ssdt(void *ssdt)
 {
-        uint8_t *BUSN;
-        uint8_t *MMIO;
-        uint8_t *PCIO;
-        uint8_t *SBLK;
-        uint8_t *TOM1;
-        uint8_t *SBDN;
-        uint8_t *HCLK;
-        uint8_t *HCDN;
+        uint8_t *BUSN;
+        uint8_t *MMIO;
+        uint8_t *PCIO;
+        uint8_t *SBLK;
+        uint8_t *TOM1;
+        uint8_t *SBDN;
+        uint8_t *HCLK;
+        uint8_t *HCDN;
         uint8_t *CBST;
 
-        int i;
-        device_t dev;
-        uint32_t dword;
-        msr_t msr;
-
-        BUSN = ssdt+0x3a; //+5 will be next BUSN
-        MMIO = ssdt+0x57; //+5 will be next MMIO
-        PCIO = ssdt+0xaf; //+5 will be next PCIO
-        SBLK = ssdt+0xdc; // one byte
-        TOM1 = ssdt+0xe3; //
-        SBDN = ssdt+0xed;//
-        HCLK = ssdt+0xfa; //+5 will be next HCLK
-        HCDN = ssdt+0x12a; //+5 will be next HCDN
+        int i;
+        device_t dev;
+        uint32_t dword;
+        msr_t msr;
+
+        BUSN = ssdt+0x3a; //+5 will be next BUSN
+        MMIO = ssdt+0x57; //+5 will be next MMIO
+        PCIO = ssdt+0xaf; //+5 will be next PCIO
+        SBLK = ssdt+0xdc; // one byte
+        TOM1 = ssdt+0xe3; //
+        SBDN = ssdt+0xed; //
+        HCLK = ssdt+0xfa; //+5 will be next HCLK
+        HCDN = ssdt+0x12a; //+5 will be next HCDN
         CBST = ssdt+0x157; //
 
-        dev = dev_find_slot(0, PCI_DEVFN(0x18, 1));
-        for(i=0;i<4;i++) {
-                dword = pci_read_config32(dev, 0xe0+i*4);
-                int_to_stream(dword, BUSN+i*5);
-        }
-        for(i=0;i<0x10;i++) {
-                dword = pci_read_config32(dev, 0x80+i*4);
-                int_to_stream(dword, MMIO+i*5);
-        }
-        for(i=0;i<0x08;i++) {
-                dword = pci_read_config32(dev, 0xc0+i*4);
-                int_to_stream(dword, PCIO+i*5);
-        }
-
-        *SBLK = (uint8_t)(sysconf.sblk);
-
-        msr = rdmsr(TOP_MEM);
-        int_to_stream(msr.lo, TOM1);
-
-        for(i=0;i<sysconf.hc_possible_num;i++) {
-                int_to_stream(sysconf.pci1234[i], HCLK + i*5);
-                int_to_stream(sysconf.hcdn[i],    HCDN + i*5);
-        }
-        for(i=sysconf.hc_possible_num; i<HC_POSSIBLE_NUM; i++) { // in case we set array size to other than 8
-                int_to_stream(0x00000000, HCLK + i*5);
-                int_to_stream(0x20202020, HCDN + i*5);
-        }
-
-        int_to_stream(sysconf.sbdn, SBDN);
+        dev = dev_find_slot(0, PCI_DEVFN(0x18, 1));
+        for(i=0;i<4;i++) {
+                dword = pci_read_config32(dev, 0xe0+i*4);
+                int_to_stream(dword, BUSN+i*5);
+        }
+        for(i=0;i<0x10;i++) {
+                dword = pci_read_config32(dev, 0x80+i*4);
+                int_to_stream(dword, MMIO+i*5);
+        }
+        for(i=0;i<0x08;i++) {
+                dword = pci_read_config32(dev, 0xc0+i*4);
+                int_to_stream(dword, PCIO+i*5);
+        }
+
+        *SBLK = (uint8_t)(sysconf.sblk);
+
+        msr = rdmsr(TOP_MEM);
+        int_to_stream(msr.lo, TOM1);
+
+        for(i=0;i<sysconf.hc_possible_num;i++) {
+                int_to_stream(sysconf.pci1234[i], HCLK + i*5);
+                int_to_stream(sysconf.hcdn[i],    HCDN + i*5);
+        }
+        for(i=sysconf.hc_possible_num; i<HC_POSSIBLE_NUM; i++) { // in case we set array size to other than 8
+                int_to_stream(0x00000000, HCLK + i*5);
+                int_to_stream(0x20202020, HCDN + i*5);
+        }
+
+        int_to_stream(sysconf.sbdn, SBDN);
 
         if((sysconf.pci1234[0] >> 12) & 0xff) { //sb chain on  other than bus 0

trunk/coreboot-v2/src/northbridge/amd/amdk8/amdk8_f.h

@@ -462 +462 @@
 
 struct dimm_size {
-        uint8_t per_rank; // it is rows + col + bank_lines + data lines */
-        uint8_t rows;
-        uint8_t col;
-        uint8_t bank; //1, 2, 3 mean 2, 4, 8
-        uint8_t rank;
+        uint8_t per_rank; // it is rows + col + bank_lines + data lines */
+        uint8_t rows;
+        uint8_t col;
+        uint8_t bank; //1, 2, 3 mean 2, 4, 8
+        uint8_t rank;
 } __attribute__((packed));
 
 struct mem_info { // pernode
-        uint32_t dimm_mask;
-        struct dimm_size sz[DIMM_SOCKETS];
-        uint32_t x4_mask;
-        uint32_t x16_mask;
+        uint32_t dimm_mask;
+        struct dimm_size sz[DIMM_SOCKETS];
+        uint32_t x4_mask;
+        uint32_t x16_mask;
         uint32_t single_rank_mask;
-        uint32_t page_1k_mask;
-//        uint32_t ecc_mask;
-//        uint32_t registered_mask;
-        uint8_t is_opteron;
-        uint8_t is_registered;
-        uint8_t is_ecc;
-        uint8_t is_Width128;
+        uint32_t page_1k_mask;
+//      uint32_t ecc_mask;
+//      uint32_t registered_mask;
+        uint8_t is_opteron;
+        uint8_t is_registered;
+        uint8_t is_ecc;
+        uint8_t is_Width128;
         uint8_t is_64MuxMode;
-        uint8_t memclk_set; // we need to use this to retrieve the mem param
+        uint8_t memclk_set; // we need to use this to retrieve the mem param
         uint8_t rsv[2];
 } __attribute__((packed));
 
 struct link_pair_st {
-        device_t udev;
-        uint32_t upos;
-        uint32_t uoffs;
-        device_t dev;
-        uint32_t pos;
-        uint32_t offs;
+        device_t udev;
+        uint32_t upos;
+        uint32_t uoffs;
+        device_t dev;
+        uint32_t pos;
+        uint32_t offs;
 
 } __attribute__((packed));
 
 struct sys_info {
-        uint8_t ctrl_present[NODE_NUMS];
-        struct mem_info meminfo[NODE_NUMS];
+        uint8_t ctrl_present[NODE_NUMS];
+        struct mem_info meminfo[NODE_NUMS];
         struct mem_controller ctrl[NODE_NUMS];
         uint8_t mem_trained[NODE_NUMS]; //0: no dimm, 1: trained, 0x80: not started, 0x81: recv1 fail, 0x82: Pos Fail, 0x83:recv2 fail
-        uint32_t tom_k;
-        uint32_t tom2_k;
+        uint32_t tom_k;
+        uint32_t tom2_k;
 
         uint32_t mem_base[NODE_NUMS];
@@ -512 +512 @@
         uint8_t dqs_rcvr_dly_a[NODE_NUMS*2*8]; //8 node, channel 2, receiver 8
         uint32_t nodes;
-        struct link_pair_st link_pair[16];// enough? only in_conherent
-        uint32_t link_pair_num;
-        uint32_t ht_c_num;
+        struct link_pair_st link_pair[16];// enough? only in_conherent
+        uint32_t link_pair_num;
+        uint32_t ht_c_num;
         uint32_t sbdn;
         uint32_t sblk;
@@ -527 +527 @@
 {
 
-        int i;
-        uint32_t mask = 0;
+        int i;
+        uint32_t mask = 0;
         unsigned needs_reset = 0;
 
@@ -534 +534 @@
         if(sysinfo->nodes == 1) return; // in case only one cpu installed       
 
-        for(i=1; i<sysinfo->nodes; i++) {
-                /* Skip everything if I don't have any memory on this controller */
-                if(sysinfo->mem_trained[i]==0x00) continue;
-
-                mask |= (1<<i);
-
-        }
-
-        i = 1;
-        while(1) {
+        for(i=1; i<sysinfo->nodes; i++) {
+                /* Skip everything if I don't have any memory on this controller */
+                if(sysinfo->mem_trained[i]==0x00) continue;
+
+                mask |= (1<<i);
+
+        }
+
+        i = 1;
+        while(1) {
                 if(mask & (1<<i)) {
                         if((sysinfo->mem_trained[i])!=0x80) {
@@ -550 +550 @@
                 }
 
-                if(!mask) break;
+                if(!mask) break;
 
 #if 0
@@ -557 +557 @@
 #endif
 
-                i++;
-                i%=sysinfo->nodes;
+                i++;
+                i%=sysinfo->nodes;
         }
 
@@ -567 +567 @@
                 printk_debug("mem_trained[%02x]=%02x\n", i, sysinfo->mem_trained[i]); 
 #endif
-                switch(sysinfo->mem_trained[i]) {
+                switch(sysinfo->mem_trained[i]) {
                 case 0: //don't need train
                 case 1: //trained

trunk/coreboot-v2/src/northbridge/amd/amdk8/amdk8_f_pci.c

@@ -5 +5 @@
 static uint32_t pci_read_config32_index(device_t dev, uint32_t index_reg, uint32_t index)
 {
-        uint32_t dword;
+        uint32_t dword;
 
-        pci_write_config32(dev, index_reg, index);
+        pci_write_config32(dev, index_reg, index);
 
-        dword = pci_read_config32(dev, index_reg+0x4);
+        dword = pci_read_config32(dev, index_reg+0x4);
 
-        return dword;
+        return dword;
 }
 
@@ -17 +17 @@
 {
 
-        pci_write_config32(dev, index_reg, index);
+        pci_write_config32(dev, index_reg, index);
 
-        pci_write_config32(dev, index_reg + 0x4, data);
+        pci_write_config32(dev, index_reg + 0x4, data);
 
 }
@@ -26 +26 @@
 {