src/northbridge/amd/amdk8/amdk8_acpi.c

   1 /*============================================================================
   2 Copyright 2005 ADVANCED MICRO DEVICES, INC. All Rights Reserved.
   3 This software and any related documentation (the "Materials") are the
   4 confidential proprietary information of AMD. Unless otherwise provided in a
   5 software agreement specifically licensing the Materials, the Materials are
   6 provided in confidence and may not be distributed, modified, or reproduced in
   7 whole or in part by any means.
   8 LIMITATION OF LIABILITY: THE MATERIALS ARE PROVIDED "AS IS" WITHOUT ANY
   9 EXPRESS OR IMPLIED WARRANTY OF ANY KIND, INCLUDING BUT NOT LIMITED TO
  10 WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT, TITLE, FITNESS FOR ANY
  11 PARTICULAR PURPOSE, OR WARRANTIES ARISING FROM CONDUCT, COURSE OF DEALING, OR
  12 USAGE OF TRADE. IN NO EVENT SHALL AMD OR ITS LICENSORS BE LIABLE FOR ANY
  13 DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF PROFITS,
  14 BUSINESS INTERRUPTION, OR LOSS OF INFORMATION) ARISING OUT OF THE USE OF OR
  15 INABILITY TO USE THE MATERIALS, EVEN IF AMD HAS BEEN ADVISED OF THE
  16 POSSIBILITY OF SUCH DAMAGES. BECAUSE SOME JURISDICTIONS PROHIBIT THE EXCLUSION
  17 OR LIMITATION OF LIABILITY FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES, THE ABOVE
  18 LIMITATION MAY NOT APPLY TO YOU.
  19 AMD does not assume any responsibility for any errors which may appear in the
  20 Materials nor any responsibility to support or update the Materials. AMD
  21 retains the right to modify the Materials at any time, without notice, and is
  22 not obligated to provide such modified Materials to you.
  23 NO SUPPORT OBLIGATION: AMD is not obligated to furnish, support, or make any
  24 further information, software, technical information, know-how, or show-how
  25 available to you.
  26 U.S. GOVERNMENT RESTRICTED RIGHTS: The Materials are provided with "RESTRICTED
  27 RIGHTS." Use, duplication, or disclosure by the Government is subject to the
  28 restrictions as set forth in FAR 52.227-14 and DFAR 252.227-7013, et seq., or
  29 its successor. Use of the Materials by the Government constitutes
  30 acknowledgement of AMD's proprietary rights in them.
  31 ============================================================================*/
  32 // 2005.9 serengeti support
  33 // by yhlu
  34 //
  35
  36 /*
  37  * 2005.9 yhlu add madt lapic creat dynamically and SRAT related
  38  */
  39
  40 #include <console/console.h>
  41 #include <string.h>
  42 #include <arch/acpi.h>
  43 #include <arch/acpigen.h>
  44 #include <device/pci.h>
  45 #include <cpu/x86/msr.h>
  46 #include <cpu/amd/mtrr.h>
  47 #include <cpu/amd/amdk8_sysconf.h>
  48
  49 //it seems some functions can be moved arch/i386/boot/acpi.c
  50
  51 unsigned long acpi_create_madt_lapics(unsigned long current)
  52 {
  53         device_t cpu;
  54         int cpu_index = 0;
  55
  56         for(cpu = all_devices; cpu; cpu = cpu->next) {
  57                 if ((cpu->path.type != DEVICE_PATH_APIC) ||
  58                     (cpu->bus->dev->path.type != DEVICE_PATH_APIC_CLUSTER)) {
  59                         continue;
  60                 }
  61                 if (!cpu->enabled) {
  62                         continue;
  63                 }
  64                 current += acpi_create_madt_lapic((acpi_madt_lapic_t *)current, cpu_index, cpu->path.apic.apic_id);
  65                 cpu_index++;
  66         }
  67         return current;
  68 }
  69
  70 unsigned long acpi_create_madt_lapic_nmis(unsigned long current, u16 flags, u8 lint)
  71 {
  72         device_t cpu;
  73         int cpu_index = 0;
  74
  75         for(cpu = all_devices; cpu; cpu = cpu->next) {
  76                 if ((cpu->path.type != DEVICE_PATH_APIC) ||
  77                     (cpu->bus->dev->path.type != DEVICE_PATH_APIC_CLUSTER)) {
  78                         continue;
  79                 }
  80                 if (!cpu->enabled) {
  81                         continue;
  82                 }
  83                 current += acpi_create_madt_lapic_nmi((acpi_madt_lapic_nmi_t *)current, cpu_index, flags, lint);
  84                 cpu_index++;
  85         }
  86         return current;
  87 }
  88
  89 unsigned long acpi_create_srat_lapics(unsigned long current)
  90 {
  91         device_t cpu;
  92         int cpu_index = 0;
  93
  94         for(cpu = all_devices; cpu; cpu = cpu->next) {
  95                 if ((cpu->path.type != DEVICE_PATH_APIC) ||
  96                     (cpu->bus->dev->path.type != DEVICE_PATH_APIC_CLUSTER)) {
  97                         continue;
  98                 }
  99                 if (!cpu->enabled) {
 100                         continue;
 101                 }
 102                 printk_debug("SRAT: lapic cpu_index=%02x, node_id=%02x, apic_id=%02x\n", cpu_index, cpu->path.apic.node_id, cpu->path.apic.apic_id);
 103                 current += acpi_create_srat_lapic((acpi_srat_lapic_t *)current, cpu->path.apic.node_id, cpu->path.apic.apic_id);
 104                 cpu_index++;
 105         }
 106         return current;
 107 }
 108
 109 static unsigned long resk(uint64_t value)
 110 {
 111         unsigned long resultk;
 112         if (value < (1ULL << 42)) {
 113                 resultk = value >> 10;
 114         } else {
 115                 resultk = 0xffffffff;
 116         }
 117         return resultk;
 118 }
 119
 120 struct acpi_srat_mem_state {
 121         unsigned long current;
 122 };
 123
 124 void set_srat_mem(void *gp, struct device *dev, struct resource *res)
 125 {
 126         struct acpi_srat_mem_state *state = gp;
 127         unsigned long basek, sizek;
 128         basek = resk(res->base);
 129         sizek = resk(res->size);
 130
 131         printk_debug("set_srat_mem: dev %s, res->index=%04lx startk=%08lx, sizek=%08lx\n",
 132                      dev_path(dev), res->index, basek, sizek);
 133         /*
 134          * 0-640K must be on node 0
 135          * next range is from 1M---
 136          * So will cut off before 1M in the mem range
 137          */
 138         if((basek+sizek)<1024) return;
 139
 140         if(basek<1024) {
 141                 sizek -= 1024 - basek;
 142                 basek = 1024;
 143         }
 144
 145         // need to figure out NV
 146         state->current += acpi_create_srat_mem((acpi_srat_mem_t *)state->current, (res->index & 0xf), basek, sizek, 1);
 147 }
 148
 149 unsigned long acpi_fill_srat(unsigned long current)
 150 {
 151         struct acpi_srat_mem_state srat_mem_state;
 152
 153         /* create all subtables for processors */
 154         current = acpi_create_srat_lapics(current);
 155
 156         /* create all subteble for memory range */
 157
 158         /* 0-640K must be on node 0 */
 159         current += acpi_create_srat_mem((acpi_srat_mem_t *)current, 0, 0, 640, 1);//enable
 160
 161         srat_mem_state.current = current;
 162         search_global_resources(
 163                 IORESOURCE_MEM | IORESOURCE_CACHEABLE, IORESOURCE_MEM | IORESOURCE_CACHEABLE,
 164                 set_srat_mem, &srat_mem_state);
 165
 166         current = srat_mem_state.current;
 167         return current;
 168 }
 169
 170 unsigned long acpi_fill_slit(unsigned long current)
 171 {
 172         /* need to find out the node num at first */
 173         /* fill the first 8 byte with that num */
 174         /* fill the next num*num byte with distance, local is 10, 1 hop mean 20, and 2 hop with 30.... */
 175
 176         /* because We has assume that we know the topology of the HT connection, So we can have set if we know the node_num */
 177         static u8 hops_8[] = {   0, 1, 1, 2, 2, 3, 3, 4,
 178                                       1, 0, 2, 1, 3, 2, 4, 3,
 179                                       1, 2, 0, 1, 1, 2, 2, 3,
 180                                       2, 1, 1, 0, 2, 1, 3, 2,
 181                                       2, 3, 1, 2, 0, 1, 1, 2,
 182                                       3, 2, 2, 1, 1, 0, 2, 1,
 183                                       3, 4, 2, 3, 1, 2, 0, 1,
 184                                       4, 4, 3, 2, 2, 1, 1, 0 };
 185
 186 //      u8 outer_node[8];
 187
 188         u8 *p = (u8 *)current;
 189         int nodes = sysconf.nodes;
 190         int i,j;
 191         memset(p, 0, 8+nodes*nodes);
 192 //      memset((u8 *)outer_node, 0, 8);
 193         *p = (u8) nodes;
 194         p += 8;
 195
 196 #if 0
 197         for(i=0;i<sysconf.hc_possible_num;i++) {
 198                 if((sysconf.pci1234[i]&1) !=1 ) continue;
 199                 outer_node[(sysconf.pci1234[i] >> 4) & 0xf] = 1; // mark the outer node
 200         }
 201 #endif
 202
 203         for(i=0;i<nodes;i++) {
 204                 for(j=0;j<nodes; j++) {
 205                         if(i==j) {
 206                                 p[i*nodes+j] = 10;
 207                         } else {
 208 #if 0
 209                                 int k;
 210                                 u8 latency_factor = 0;
 211                                 int k_start, k_end;
 212                                 if(i<j) {
 213                                         k_start = i;
 214                                         k_end = j;
 215                                 } else {
 216                                         k_start = j;
 217                                         k_end = i;
 218                                 }
 219                                 for(k=k_start;k<=k_end; k++) {
 220                                         if(outer_node[k]) {
 221                                                 latency_factor = 1;
 222                                                 break;
 223                                         }
 224                                 }
 225                                 p[i*nodes+j] = hops_8[i*nodes+j] * 2 + latency_factor + 10;
 226 #else
 227                                 p[i*nodes+j] = hops_8[i*nodes+j] * 2 + 10;
 228 #endif
 229
 230                         }
 231                 }
 232         }
 233
 234         current += 8+nodes*nodes;
 235
 236         return current;
 237 }
 238
 239 static int k8acpi_write_HT(void) {
 240         device_t dev;
 241         uint32_t dword;
 242         int len, lenp, i;
 243
 244         len = acpigen_write_name("HCLK");
 245         lenp = acpigen_write_package(HC_POSSIBLE_NUM);
 246
 247         for(i=0;i<sysconf.hc_possible_num;i++) {
 248                 lenp += acpigen_write_dword(sysconf.pci1234[i]);
 249         }
 250         for(i=sysconf.hc_possible_num; i<HC_POSSIBLE_NUM; i++) { // in case we set array size to other than 8
 251                 lenp += acpigen_write_dword(0x0);
 252         }
 253
 254         acpigen_patch_len(lenp - 1);
 255         len += lenp;
 256
 257         len += acpigen_write_name("HCDN");
 258         lenp = acpigen_write_package(HC_POSSIBLE_NUM);
 259
 260         for(i=0;i<sysconf.hc_possible_num;i++) {
 261                 lenp += acpigen_write_dword(sysconf.hcdn[i]);
 262         }
 263         for(i=sysconf.hc_possible_num; i<HC_POSSIBLE_NUM; i++) { // in case we set array size to other than 8
 264                 lenp += acpigen_write_dword(0x20202020);
 265         }
 266         acpigen_patch_len(lenp - 1);
 267         len += lenp;
 268
 269         return len;
 270 }
 271
 272 static int k8acpi_write_pci_data(int dlen, char *name, int offset) {
 273         device_t dev;
 274         uint32_t dword;
 275         int len, lenp, i;
 276
 277         dev = dev_find_slot(0, PCI_DEVFN(0x18, 1));
 278
 279         len = acpigen_write_name(name);
 280         lenp = acpigen_write_package(dlen);
 281         for(i=0; i<dlen; i++) {
 282                 dword = pci_read_config32(dev, offset+i*4);
 283                 lenp += acpigen_write_dword(dword);
 284         }
 285         // minus the opcode
 286         acpigen_patch_len(lenp - 1);
 287         return len + lenp;
 288 }
 289
 290 int k8acpi_write_vars(void)
 291 {
 292         int lens;
 293         msr_t msr;
 294         char pscope[] = "\\._SB_PCI0";
 295
 296         lens = acpigen_write_scope(pscope);
 297         lens += k8acpi_write_pci_data(4, "BUSN", 0xe0);
 298         lens += k8acpi_write_pci_data(8, "PCIO", 0xc0);
 299         lens += k8acpi_write_pci_data(16, "MMIO", 0x80);
 300         lens += acpigen_write_name_byte("SBLK", sysconf.sblk);
 301         lens += acpigen_write_name_byte("CBST",
 302             ((sysconf.pci1234[0] >> 12) & 0xff) ? 0xf : 0x0);
 303         lens += acpigen_write_name_dword("SBDN", sysconf.sbdn);
 304         msr = rdmsr(TOP_MEM);
 305         lens += acpigen_write_name_dword("TOM1", msr.lo);
 306         msr = rdmsr(TOP_MEM2);
 307         lens += acpigen_write_name_qword("TOM2", (((uint64_t) msr.hi) << 32) | msr.lo);
 308
 309         lens += k8acpi_write_HT();
 310         //minus opcode
 311         acpigen_patch_len(lens - 1);
 312         return lens;
 313 }