src/arch/i386/boot/acpi.c

   1 /*
   2  * coreboot ACPI Table support
   3  * written by Stefan Reinauer <stepan@openbios.org>
   4  *  Copyright (C) 2004 SUSE LINUX AG
   5  *  Copyright (C) 2005-2009 coresystems GmbH
   6  *
   7  * ACPI FADT, FACS, and DSDT table support added by
   8  * Nick Barker <nick.barker9@btinternet.com>, and those portions
   9  *  (C) Copyright 2004 Nick Barker
  10  *
  11  * Copyright 2005 ADVANCED MICRO DEVICES, INC. All Rights Reserved.
  12  * 2005.9 yhlu add SRAT table generation
  13  */
  14
  15 /*
  16  * Each system port implementing ACPI has to provide two functions:
  17  *
  18  *   write_acpi_tables()
  19  *   acpi_dump_apics()
  20  *
  21  * See AMD Solo, Island Aruma or Via Epia-M port for more details.
  22  */
  23
  24 #include <console/console.h>
  25 #include <string.h>
  26 #include <arch/acpi.h>
  27 #include <arch/acpigen.h>
  28 #include <device/pci.h>
  29
  30 u8 acpi_checksum(u8 *table, u32 length)
  31 {
  32         u8 ret=0;
  33         while (length--) {
  34                 ret += *table;
  35                 table++;
  36         }
  37         return -ret;
  38 }
  39
  40 /*
  41  * add an acpi table to rsdt structure, and recalculate checksum
  42  */
  43
  44 void acpi_add_table(acpi_rsdt_t *rsdt, void *table)
  45 {
  46         int i;
  47
  48         int entries_num = ARRAY_SIZE(rsdt->entry);
  49
  50         for (i=0; i<entries_num; i++) {
  51                 if(rsdt->entry[i]==0) {
  52                         rsdt->entry[i]=(u32)table;
  53                         /* fix length to stop kernel winging about invalid entries */
  54                         rsdt->header.length = sizeof(acpi_header_t) + (sizeof(u32) * (i+1));
  55                         /* fix checksum */
  56                         /* hope this won't get optimized away */
  57                         rsdt->header.checksum=0;
  58                         rsdt->header.checksum=acpi_checksum((u8 *)rsdt,
  59                                         rsdt->header.length);
  60
  61                         printk_debug("ACPI: added table %d/%d Length now %d\n",i+1, entries_num, rsdt->header.length);
  62                         return;
  63                 }
  64         }
  65
  66         printk_warning("ACPI: could not add ACPI table to RSDT. failed.\n");
  67 }
  68
  69 int acpi_create_mcfg_mmconfig(acpi_mcfg_mmconfig_t *mmconfig, u32 base, u16 seg_nr, u8 start, u8 end)
  70 {
  71         mmconfig->base_address = base;
  72         mmconfig->base_reserved = 0;
  73         mmconfig->pci_segment_group_number = seg_nr;
  74         mmconfig->start_bus_number = start;
  75         mmconfig->end_bus_number = end;
  76         return (sizeof(acpi_mcfg_mmconfig_t));
  77 }
  78
  79 int acpi_create_madt_lapic(acpi_madt_lapic_t *lapic, u8 cpu, u8 apic)
  80 {
  81         lapic->type=0;
  82         lapic->length=sizeof(acpi_madt_lapic_t);
  83         lapic->flags=1;
  84
  85         lapic->processor_id=cpu;
  86         lapic->apic_id=apic;
  87
  88         return(lapic->length);
  89 }
  90
  91 unsigned long acpi_create_madt_lapics(unsigned long current)
  92 {
  93         device_t cpu;
  94         int cpu_index = 0;
  95
  96         for(cpu = all_devices; cpu; cpu = cpu->next) {
  97                 if ((cpu->path.type != DEVICE_PATH_APIC) ||
  98                    (cpu->bus->dev->path.type != DEVICE_PATH_APIC_CLUSTER)) {
  99                         continue;
 100                 }
 101                 if (!cpu->enabled) {
 102                         continue;
 103                 }
 104                 current += acpi_create_madt_lapic((acpi_madt_lapic_t *)current, cpu_index, cpu->path.apic.apic_id);
 105                 cpu_index++;
 106         }
 107         return current;
 108 }
 109
 110 int acpi_create_madt_ioapic(acpi_madt_ioapic_t *ioapic, u8 id, u32 addr,u32 gsi_base)
 111 {
 112         ioapic->type=1;
 113         ioapic->length=sizeof(acpi_madt_ioapic_t);
 114         ioapic->reserved=0x00;
 115         ioapic->gsi_base=gsi_base;
 116
 117         ioapic->ioapic_id=id;
 118         ioapic->ioapic_addr=addr;
 119
 120         return(ioapic->length);
 121 }
 122
 123 int acpi_create_madt_irqoverride(acpi_madt_irqoverride_t *irqoverride,
 124                 u8 bus, u8 source, u32 gsirq, u16 flags)
 125 {
 126         irqoverride->type=2;
 127         irqoverride->length=sizeof(acpi_madt_irqoverride_t);
 128         irqoverride->bus=bus;
 129         irqoverride->source=source;
 130         irqoverride->gsirq=gsirq;
 131         irqoverride->flags=flags;
 132
 133         return(irqoverride->length);
 134 }
 135
 136 int acpi_create_madt_lapic_nmi(acpi_madt_lapic_nmi_t *lapic_nmi, u8 cpu,
 137                 u16 flags, u8 lint)
 138 {
 139         lapic_nmi->type=4;
 140         lapic_nmi->length=sizeof(acpi_madt_lapic_nmi_t);
 141
 142         lapic_nmi->flags=flags;
 143         lapic_nmi->processor_id=cpu;
 144         lapic_nmi->lint=lint;
 145
 146         return(lapic_nmi->length);
 147 }
 148
 149 void acpi_create_madt(acpi_madt_t *madt)
 150 {
 151 #define LOCAL_APIC_ADDR 0xfee00000ULL
 152
 153         acpi_header_t *header=&(madt->header);
 154         unsigned long current=(unsigned long)madt+sizeof(acpi_madt_t);
 155
 156         memset((void *)madt, 0, sizeof(acpi_madt_t));
 157
 158         /* fill out header fields */
 159         memcpy(header->signature, MADT_NAME, 4);
 160         memcpy(header->oem_id, OEM_ID, 6);
 161         memcpy(header->oem_table_id, MADT_TABLE, 8);
 162         memcpy(header->asl_compiler_id, ASLC, 4);
 163
 164         header->length = sizeof(acpi_madt_t);
 165         header->revision = 1;
 166
 167         madt->lapic_addr= LOCAL_APIC_ADDR;
 168         madt->flags     = 0x1; /* PCAT_COMPAT */
 169
 170         current = acpi_fill_madt(current);
 171
 172         /* recalculate length */
 173         header->length= current - (unsigned long)madt;
 174
 175         header->checksum        = acpi_checksum((void *)madt, header->length);
 176 }
 177
 178 void acpi_create_mcfg(acpi_mcfg_t *mcfg)
 179 {
 180
 181         acpi_header_t *header=&(mcfg->header);
 182         unsigned long current=(unsigned long)mcfg+sizeof(acpi_mcfg_t);
 183
 184         memset((void *)mcfg, 0, sizeof(acpi_mcfg_t));
 185
 186         /* fill out header fields */
 187         memcpy(header->signature, MCFG_NAME, 4);
 188         memcpy(header->oem_id, OEM_ID, 6);
 189         memcpy(header->oem_table_id, MCFG_TABLE, 8);
 190         memcpy(header->asl_compiler_id, ASLC, 4);
 191
 192         header->length = sizeof(acpi_mcfg_t);
 193         header->revision = 1;
 194
 195         current = acpi_fill_mcfg(current);
 196
 197         /* recalculate length */
 198         header->length= current - (unsigned long)mcfg;
 199
 200         header->checksum        = acpi_checksum((void *)mcfg, header->length);
 201 }
 202
 203 /* this can be overriden by platform ACPI setup code,
 204    if it calls acpi_create_ssdt_generator */
 205 unsigned long __attribute__((weak)) acpi_fill_ssdt_generator(unsigned long current,
 206                                                     char *oem_table_id) {
 207         return current;
 208 }
 209
 210 void acpi_create_ssdt_generator(acpi_header_t *ssdt, char *oem_table_id)
 211 {
 212         unsigned long current=(unsigned long)ssdt+sizeof(acpi_header_t);
 213         memset((void *)ssdt, 0, sizeof(acpi_header_t));
 214         memcpy(&ssdt->signature, SSDT_NAME, 4);
 215         ssdt->revision = 2;
 216         memcpy(&ssdt->oem_id, OEM_ID, 6);
 217         memcpy(&ssdt->oem_table_id, oem_table_id, 8);
 218         ssdt->oem_revision = 42;
 219         memcpy(&ssdt->asl_compiler_id, "GENAML", 4);
 220         ssdt->asl_compiler_revision = 42;
 221         ssdt->length = sizeof(acpi_header_t);
 222
 223         acpigen_set_current((char *) current);
 224         current = acpi_fill_ssdt_generator(current, oem_table_id);
 225
 226         /* recalculate length */
 227         ssdt->length = current - (unsigned long)ssdt;
 228         ssdt->checksum = acpi_checksum((void *)ssdt, ssdt->length);
 229 }
 230
 231 int acpi_create_srat_lapic(acpi_srat_lapic_t *lapic, u8 node, u8 apic)
 232 {
 233         memset((void *)lapic, 0, sizeof(acpi_srat_lapic_t));
 234         lapic->type=0;
 235         lapic->length=sizeof(acpi_srat_lapic_t);
 236         lapic->flags=1;
 237
 238         lapic->proximity_domain_7_0 = node;
 239         lapic->apic_id=apic;
 240
 241         return(lapic->length);
 242 }
 243
 244 int acpi_create_srat_mem(acpi_srat_mem_t *mem, u8 node, u32 basek,u32 sizek, u32 flags)
 245 {
 246         mem->type=1;
 247         mem->length=sizeof(acpi_srat_mem_t);
 248
 249         mem->base_address_low = (basek<<10);
 250         mem->base_address_high = (basek>>(32-10));
 251
 252         mem->length_low = (sizek<<10);
 253         mem->length_high = (sizek>>(32-10));
 254
 255         mem->proximity_domain = node;
 256
 257         mem->flags = flags;
 258
 259         return(mem->length);
 260 }
 261
 262 void acpi_create_srat(acpi_srat_t *srat)
 263 {
 264
 265         acpi_header_t *header=&(srat->header);
 266         unsigned long current=(unsigned long)srat+sizeof(acpi_srat_t);
 267
 268         memset((void *)srat, 0, sizeof(acpi_srat_t));
 269
 270         /* fill out header fields */
 271         memcpy(header->signature, SRAT_NAME, 4);
 272         memcpy(header->oem_id, OEM_ID, 6);
 273         memcpy(header->oem_table_id, SRAT_TABLE, 8);
 274         memcpy(header->asl_compiler_id, ASLC, 4);
 275
 276         header->length = sizeof(acpi_srat_t);
 277         header->revision = 1;
 278
 279         srat->resv     = 0x1; /* BACK COMP */
 280
 281         current = acpi_fill_srat(current);
 282
 283         /* recalculate length */
 284         header->length= current - (unsigned long)srat;
 285
 286         header->checksum        = acpi_checksum((void *)srat, header->length);
 287 }
 288
 289 void acpi_create_slit(acpi_slit_t *slit)
 290 {
 291
 292         acpi_header_t *header=&(slit->header);
 293         unsigned long current=(unsigned long)slit+sizeof(acpi_slit_t);
 294
 295         memset((void *)slit, 0, sizeof(acpi_slit_t));
 296
 297         /* fill out header fields */
 298         memcpy(header->signature, SLIT_NAME, 4);
 299         memcpy(header->oem_id, OEM_ID, 6);
 300         memcpy(header->oem_table_id, SLIT_TABLE, 8);
 301         memcpy(header->asl_compiler_id, ASLC, 4);
 302
 303         header->length = sizeof(acpi_slit_t);
 304         header->revision = 1;
 305
 306         current = acpi_fill_slit(current);
 307
 308         /* recalculate length */
 309         header->length= current - (unsigned long)slit;
 310
 311         header->checksum        = acpi_checksum((void *)slit, header->length);
 312 }
 313
 314 void acpi_create_hpet(acpi_hpet_t *hpet)
 315 {
 316 #define HPET_ADDR  0xfed00000ULL
 317         acpi_header_t *header=&(hpet->header);
 318         acpi_addr_t *addr=&(hpet->addr);
 319
 320         memset((void *)hpet, 0, sizeof(acpi_hpet_t));
 321
 322         /* fill out header fields */
 323         memcpy(header->signature, HPET_NAME, 4);
 324         memcpy(header->oem_id, OEM_ID, 6);
 325         memcpy(header->oem_table_id, HPET_TABLE, 8);
 326         memcpy(header->asl_compiler_id, ASLC, 4);
 327
 328         header->length = sizeof(acpi_hpet_t);
 329         header->revision = 1;
 330
 331         /* fill out HPET address */
 332         addr->space_id          = 0; /* Memory */
 333         addr->bit_width         = 64;
 334         addr->bit_offset        = 0;
 335         addr->addrl             = HPET_ADDR & 0xffffffff;
 336         addr->addrh             = HPET_ADDR >> 32;
 337
 338         hpet->id        = 0x102282a0; /* AMD ? */
 339         hpet->number    = 0;
 340         hpet->min_tick  = 4096;
 341
 342         header->checksum        = acpi_checksum((void *)hpet, sizeof(acpi_hpet_t));
 343 }
 344 void acpi_create_facs(acpi_facs_t *facs)
 345 {
 346
 347         memset( (void *)facs,0, sizeof(acpi_facs_t));
 348
 349         memcpy(facs->signature, FACS_NAME, 4);
 350         facs->length = sizeof(acpi_facs_t);
 351         facs->hardware_signature = 0;
 352         facs->firmware_waking_vector = 0;
 353         facs->global_lock = 0;
 354         facs->flags = 0;
 355         facs->x_firmware_waking_vector_l = 0;
 356         facs->x_firmware_waking_vector_h = 0;
 357         facs->version = 1;
 358 }
 359
 360 void acpi_write_rsdt(acpi_rsdt_t *rsdt)
 361 {
 362         acpi_header_t *header=&(rsdt->header);
 363
 364         /* fill out header fields */
 365         memcpy(header->signature, RSDT_NAME, 4);
 366         memcpy(header->oem_id, OEM_ID, 6);
 367         memcpy(header->oem_table_id, RSDT_TABLE, 8);
 368         memcpy(header->asl_compiler_id, ASLC, 4);
 369
 370         header->length = sizeof(acpi_rsdt_t);
 371         header->revision = 1;
 372
 373         /* fill out entries */
 374
 375         // entries are filled in later, we come with an empty set.
 376
 377         /* fix checksum */
 378
 379         header->checksum        = acpi_checksum((void *)rsdt, sizeof(acpi_rsdt_t));
 380 }
 381
 382 void acpi_write_rsdp(acpi_rsdp_t *rsdp, acpi_rsdt_t *rsdt)
 383 {
 384         memcpy(rsdp->signature, RSDP_SIG, 8);
 385         memcpy(rsdp->oem_id, OEM_ID, 6);
 386         rsdp->length            = sizeof(acpi_rsdp_t);
 387         rsdp->rsdt_address      = (u32)rsdt;
 388         rsdp->revision          = 2;
 389         rsdp->checksum          = acpi_checksum((void *)rsdp, 20);
 390         rsdp->ext_checksum      = acpi_checksum((void *)rsdp, sizeof(acpi_rsdp_t));
 391 }
 392
 393 #if CONFIG_HAVE_ACPI_RESUME == 1
 394 void suspend_resume(void)
 395 {
 396         void *wake_vec;
 397
 398 #if 0
 399 #if CONFIG_MEM_TRAIN_SEQ != 0
 400         #error "So far it works on AMD and CONFIG_MEM_TRAIN_SEQ == 0"
 401 #endif
 402
 403 #if CONFIG_RAMBASE < 0x1F00000
 404         #error "For ACPI RESUME you need to have CONFIG_RAMBASE at least 31MB"
 405         #error "Chipset support (S3_NVRAM_EARLY and ACPI_IS_WAKEUP_EARLY functions and memory ctrl)"
 406         #error "And coreboot memory reserved in mainboard.c"
 407 #endif
 408 #endif
 409         /* if we happen to be resuming find wakeup vector and jump to OS */
 410         wake_vec = acpi_find_wakeup_vector();
 411         if (wake_vec)
 412                 acpi_jump_to_wakeup(wake_vec);
 413 }
 414
 415 /* this is to be filled by SB code - startup value what was found */
 416 u8 acpi_slp_type = 0;
 417
 418 int acpi_get_sleep_type(void)
 419 {
 420         return acpi_slp_type;
 421 }
 422
 423 int acpi_is_wakeup(void)
 424 {
 425         return (acpi_slp_type == 3);
 426 }
 427
 428 static acpi_rsdp_t *valid_rsdp(acpi_rsdp_t *rsdp)
 429 {
 430         if (strncmp((char *)rsdp, RSDP_SIG, sizeof(RSDP_SIG) - 1) != 0)
 431                 return NULL;
 432
 433         printk_debug("Looking on %p for valid checksum\n", rsdp);
 434
 435         if (acpi_checksum((void *)rsdp, 20) != 0)
 436                 return NULL;
 437         printk_debug("Checksum 1 passed\n");
 438
 439         if ((rsdp->revision > 1) && (acpi_checksum((void *)rsdp,
 440                                                 rsdp->length) != 0))
 441                 return NULL;
 442
 443         printk_debug("Checksum 2 passed all OK\n");
 444
 445         return rsdp;
 446 }
 447
 448 static acpi_rsdp_t *rsdp;
 449
 450 void *acpi_get_wakeup_rsdp(void)
 451 {
 452         return rsdp;
 453 }
 454
 455 void *acpi_find_wakeup_vector(void)
 456 {
 457         char *p, *end;
 458
 459         acpi_rsdt_t *rsdt;
 460         acpi_facs_t *facs;
 461         acpi_fadt_t *fadt;
 462         void  *wake_vec;
 463         int i;
 464
 465         rsdp = NULL;
 466
 467         if (!acpi_is_wakeup())
 468                 return NULL;
 469
 470         printk_debug("Trying to find the wakeup vector ...\n");
 471
 472         /* find RSDP */
 473         for (p = (char *) 0xe0000; p <  (char *) 0xfffff; p+=16) {
 474                 if ((rsdp = valid_rsdp((acpi_rsdp_t *) p)))
 475                         break;
 476         }
 477
 478         if (rsdp == NULL)
 479                 return NULL;
 480
 481         printk_debug("RSDP found at %p\n", rsdp);
 482         rsdt = (acpi_rsdt_t *) rsdp->rsdt_address;
 483
 484         end = (char *) rsdt + rsdt->header.length;
 485         printk_debug("RSDT found at %p ends at %p\n", rsdt, end);
 486
 487         for (i = 0; ((char *) &rsdt->entry[i]) < end; i++) {
 488                 fadt = (acpi_fadt_t *) rsdt->entry[i];
 489                 if (strncmp((char *)fadt, FADT_NAME, sizeof(FADT_NAME) - 1) == 0)
 490                         break;
 491                 fadt = NULL;
 492         }
 493
 494         if (fadt == NULL)
 495                 return NULL;
 496
 497         printk_debug("FADT found at %p\n", fadt);
 498         facs = (acpi_facs_t *)fadt->firmware_ctrl;
 499
 500         if (facs == NULL) {
 501                 printk_debug("No FACS found, wake up from S3 not possible.\n");
 502                 return NULL;
 503         }
 504
 505         printk_debug("FACS found at %p\n", facs);
 506         wake_vec = (void *) facs->firmware_waking_vector;
 507         printk_debug("OS waking vector is %p\n", wake_vec);
 508         return wake_vec;
 509 }
 510
 511 extern char *lowmem_backup;
 512 extern char *lowmem_backup_ptr;
 513 extern int lowmem_backup_size;
 514
 515 void acpi_jump_to_wakeup(void *vector)
 516 {
 517         /* just restore the SMP trampoline and continue with wakeup on assembly level */
 518         memcpy(lowmem_backup_ptr, lowmem_backup, lowmem_backup_size);
 519         acpi_jmp_to_realm_wakeup((u32) vector);
 520 }
 521 #endif