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 int acpi_create_madt_ioapic(acpi_madt_ioapic_t *ioapic, u8 id, u32 addr,u32 gsi_base)
  92 {
  93         ioapic->type=1;
  94         ioapic->length=sizeof(acpi_madt_ioapic_t);
  95         ioapic->reserved=0x00;
  96         ioapic->gsi_base=gsi_base;
  97
  98         ioapic->ioapic_id=id;
  99         ioapic->ioapic_addr=addr;
 100
 101         return(ioapic->length);
 102 }
 103
 104 int acpi_create_madt_irqoverride(acpi_madt_irqoverride_t *irqoverride,
 105                 u8 bus, u8 source, u32 gsirq, u16 flags)
 106 {
 107         irqoverride->type=2;
 108         irqoverride->length=sizeof(acpi_madt_irqoverride_t);
 109         irqoverride->bus=bus;
 110         irqoverride->source=source;
 111         irqoverride->gsirq=gsirq;
 112         irqoverride->flags=flags;
 113
 114         return(irqoverride->length);
 115 }
 116
 117 int acpi_create_madt_lapic_nmi(acpi_madt_lapic_nmi_t *lapic_nmi, u8 cpu,
 118                 u16 flags, u8 lint)
 119 {
 120         lapic_nmi->type=4;
 121         lapic_nmi->length=sizeof(acpi_madt_lapic_nmi_t);
 122
 123         lapic_nmi->flags=flags;
 124         lapic_nmi->processor_id=cpu;
 125         lapic_nmi->lint=lint;
 126
 127         return(lapic_nmi->length);
 128 }
 129
 130 void acpi_create_madt(acpi_madt_t *madt)
 131 {
 132 #define LOCAL_APIC_ADDR 0xfee00000ULL
 133
 134         acpi_header_t *header=&(madt->header);
 135         unsigned long current=(unsigned long)madt+sizeof(acpi_madt_t);
 136
 137         memset((void *)madt, 0, sizeof(acpi_madt_t));
 138
 139         /* fill out header fields */
 140         memcpy(header->signature, MADT_NAME, 4);
 141         memcpy(header->oem_id, OEM_ID, 6);
 142         memcpy(header->oem_table_id, MADT_TABLE, 8);
 143         memcpy(header->asl_compiler_id, ASLC, 4);
 144
 145         header->length = sizeof(acpi_madt_t);
 146         header->revision = 1;
 147
 148         madt->lapic_addr= LOCAL_APIC_ADDR;
 149         madt->flags     = 0x1; /* PCAT_COMPAT */
 150
 151         current = acpi_fill_madt(current);
 152
 153         /* recalculate length */
 154         header->length= current - (unsigned long)madt;
 155
 156         header->checksum        = acpi_checksum((void *)madt, header->length);
 157 }
 158
 159 void acpi_create_mcfg(acpi_mcfg_t *mcfg)
 160 {
 161
 162         acpi_header_t *header=&(mcfg->header);
 163         unsigned long current=(unsigned long)mcfg+sizeof(acpi_mcfg_t);
 164
 165         memset((void *)mcfg, 0, sizeof(acpi_mcfg_t));
 166
 167         /* fill out header fields */
 168         memcpy(header->signature, MCFG_NAME, 4);
 169         memcpy(header->oem_id, OEM_ID, 6);
 170         memcpy(header->oem_table_id, MCFG_TABLE, 8);
 171         memcpy(header->asl_compiler_id, ASLC, 4);
 172
 173         header->length = sizeof(acpi_mcfg_t);
 174         header->revision = 1;
 175
 176         current = acpi_fill_mcfg(current);
 177
 178         /* recalculate length */
 179         header->length= current - (unsigned long)mcfg;
 180
 181         header->checksum        = acpi_checksum((void *)mcfg, header->length);
 182 }
 183
 184 /* this can be overriden by platform ACPI setup code,
 185    if it calls acpi_create_ssdt_generator */
 186 unsigned long __attribute__((weak)) acpi_fill_ssdt_generator(unsigned long current,
 187                                                     char *oem_table_id) {
 188         return current;
 189 }
 190
 191 void acpi_create_ssdt_generator(acpi_header_t *ssdt, char *oem_table_id)
 192 {
 193         unsigned long current=(unsigned long)ssdt+sizeof(acpi_header_t);
 194         memset((void *)ssdt, 0, sizeof(acpi_header_t));
 195         memcpy(&ssdt->signature, SSDT_NAME, 4);
 196         ssdt->revision = 2;
 197         memcpy(&ssdt->oem_id, OEM_ID, 6);
 198         memcpy(&ssdt->oem_table_id, oem_table_id, 8);
 199         ssdt->oem_revision = 42;
 200         memcpy(&ssdt->asl_compiler_id, "GENAML", 4);
 201         ssdt->asl_compiler_revision = 42;
 202         ssdt->length = sizeof(acpi_header_t);
 203
 204         acpigen_set_current((char *) current);
 205         current = acpi_fill_ssdt_generator(current, oem_table_id);
 206
 207         /* recalculate length */
 208         ssdt->length = current - (unsigned long)ssdt;
 209         ssdt->checksum = acpi_checksum((void *)ssdt, ssdt->length);
 210 }
 211
 212 int acpi_create_srat_lapic(acpi_srat_lapic_t *lapic, u8 node, u8 apic)
 213 {
 214         memset((void *)lapic, 0, sizeof(acpi_srat_lapic_t));
 215         lapic->type=0;
 216         lapic->length=sizeof(acpi_srat_lapic_t);
 217         lapic->flags=1;
 218
 219         lapic->proximity_domain_7_0 = node;
 220         lapic->apic_id=apic;
 221
 222         return(lapic->length);
 223 }
 224
 225 int acpi_create_srat_mem(acpi_srat_mem_t *mem, u8 node, u32 basek,u32 sizek, u32 flags)
 226 {
 227         mem->type=1;
 228         mem->length=sizeof(acpi_srat_mem_t);
 229
 230         mem->base_address_low = (basek<<10);
 231         mem->base_address_high = (basek>>(32-10));
 232
 233         mem->length_low = (sizek<<10);
 234         mem->length_high = (sizek>>(32-10));
 235
 236         mem->proximity_domain = node;
 237
 238         mem->flags = flags;
 239
 240         return(mem->length);
 241 }
 242
 243 void acpi_create_srat(acpi_srat_t *srat)
 244 {
 245
 246         acpi_header_t *header=&(srat->header);
 247         unsigned long current=(unsigned long)srat+sizeof(acpi_srat_t);
 248
 249         memset((void *)srat, 0, sizeof(acpi_srat_t));
 250
 251         /* fill out header fields */
 252         memcpy(header->signature, SRAT_NAME, 4);
 253         memcpy(header->oem_id, OEM_ID, 6);
 254         memcpy(header->oem_table_id, SRAT_TABLE, 8);
 255         memcpy(header->asl_compiler_id, ASLC, 4);
 256
 257         header->length = sizeof(acpi_srat_t);
 258         header->revision = 1;
 259
 260         srat->resv     = 0x1; /* BACK COMP */
 261
 262         current = acpi_fill_srat(current);
 263
 264         /* recalculate length */
 265         header->length= current - (unsigned long)srat;
 266
 267         header->checksum        = acpi_checksum((void *)srat, header->length);
 268 }
 269
 270 void acpi_create_slit(acpi_slit_t *slit)
 271 {
 272
 273         acpi_header_t *header=&(slit->header);
 274         unsigned long current=(unsigned long)slit+sizeof(acpi_slit_t);
 275
 276         memset((void *)slit, 0, sizeof(acpi_slit_t));
 277
 278         /* fill out header fields */
 279         memcpy(header->signature, SLIT_NAME, 4);
 280         memcpy(header->oem_id, OEM_ID, 6);
 281         memcpy(header->oem_table_id, SLIT_TABLE, 8);
 282         memcpy(header->asl_compiler_id, ASLC, 4);
 283
 284         header->length = sizeof(acpi_slit_t);
 285         header->revision = 1;
 286
 287         current = acpi_fill_slit(current);
 288
 289         /* recalculate length */
 290         header->length= current - (unsigned long)slit;
 291
 292         header->checksum        = acpi_checksum((void *)slit, header->length);
 293 }
 294
 295 void acpi_create_hpet(acpi_hpet_t *hpet)
 296 {
 297 #define HPET_ADDR  0xfed00000ULL
 298         acpi_header_t *header=&(hpet->header);
 299         acpi_addr_t *addr=&(hpet->addr);
 300
 301         memset((void *)hpet, 0, sizeof(acpi_hpet_t));
 302
 303         /* fill out header fields */
 304         memcpy(header->signature, HPET_NAME, 4);
 305         memcpy(header->oem_id, OEM_ID, 6);
 306         memcpy(header->oem_table_id, HPET_TABLE, 8);
 307         memcpy(header->asl_compiler_id, ASLC, 4);
 308
 309         header->length = sizeof(acpi_hpet_t);
 310         header->revision = 1;
 311
 312         /* fill out HPET address */
 313         addr->space_id          = 0; /* Memory */
 314         addr->bit_width         = 64;
 315         addr->bit_offset        = 0;
 316         addr->addrl             = HPET_ADDR & 0xffffffff;
 317         addr->addrh             = HPET_ADDR >> 32;
 318
 319         hpet->id        = 0x102282a0; /* AMD ? */
 320         hpet->number    = 0;
 321         hpet->min_tick  = 4096;
 322
 323         header->checksum        = acpi_checksum((void *)hpet, sizeof(acpi_hpet_t));
 324 }
 325 void acpi_create_facs(acpi_facs_t *facs)
 326 {
 327
 328         memset( (void *)facs,0, sizeof(acpi_facs_t));
 329
 330         memcpy(facs->signature, FACS_NAME, 4);
 331         facs->length = sizeof(acpi_facs_t);
 332         facs->hardware_signature = 0;
 333         facs->firmware_waking_vector = 0;
 334         facs->global_lock = 0;
 335         facs->flags = 0;
 336         facs->x_firmware_waking_vector_l = 0;
 337         facs->x_firmware_waking_vector_h = 0;
 338         facs->version = 1;
 339 }
 340
 341 void acpi_write_rsdt(acpi_rsdt_t *rsdt)
 342 {
 343         acpi_header_t *header=&(rsdt->header);
 344
 345         /* fill out header fields */
 346         memcpy(header->signature, RSDT_NAME, 4);
 347         memcpy(header->oem_id, OEM_ID, 6);
 348         memcpy(header->oem_table_id, RSDT_TABLE, 8);
 349         memcpy(header->asl_compiler_id, ASLC, 4);
 350
 351         header->length = sizeof(acpi_rsdt_t);
 352         header->revision = 1;
 353
 354         /* fill out entries */
 355
 356         // entries are filled in later, we come with an empty set.
 357
 358         /* fix checksum */
 359
 360         header->checksum        = acpi_checksum((void *)rsdt, sizeof(acpi_rsdt_t));
 361 }
 362
 363 void acpi_write_rsdp(acpi_rsdp_t *rsdp, acpi_rsdt_t *rsdt)
 364 {
 365         memcpy(rsdp->signature, RSDP_SIG, 8);
 366         memcpy(rsdp->oem_id, OEM_ID, 6);
 367         rsdp->length            = sizeof(acpi_rsdp_t);
 368         rsdp->rsdt_address      = (u32)rsdt;
 369         rsdp->revision          = 2;
 370         rsdp->checksum          = acpi_checksum((void *)rsdp, 20);
 371         rsdp->ext_checksum      = acpi_checksum((void *)rsdp, sizeof(acpi_rsdp_t));
 372 }
 373
 374 #if HAVE_ACPI_RESUME == 1
 375 void suspend_resume(void)
 376 {
 377         void *wake_vec;
 378
 379 #if 0
 380 #if MEM_TRAIN_SEQ != 0
 381         #error "So far it works on AMD and MEM_TRAIN_SEQ == 0"
 382 #endif
 383
 384 #if _RAMBASE < 0x1F00000
 385         #error "For ACPI RESUME you need to have _RAMBASE at least 31MB"
 386         #error "Chipset support (S3_NVRAM_EARLY and ACPI_IS_WAKEUP_EARLY functions and memory ctrl)"
 387         #error "And coreboot memory reserved in mainboard.c"
 388 #endif
 389 #endif
 390         /* if we happen to be resuming find wakeup vector and jump to OS */
 391         wake_vec = acpi_find_wakeup_vector();
 392         if (wake_vec)
 393                 acpi_jump_to_wakeup(wake_vec);
 394 }
 395
 396 /* this is to be filled by SB code - startup value what was found */
 397 u8 acpi_slp_type = 0;
 398
 399 int acpi_get_sleep_type(void)
 400 {
 401         return acpi_slp_type;
 402 }
 403
 404 int acpi_is_wakeup(void)
 405 {
 406         return (acpi_slp_type == 3);
 407 }
 408
 409 static acpi_rsdp_t *valid_rsdp(acpi_rsdp_t *rsdp)
 410 {
 411         if (strncmp((char *)rsdp, RSDP_SIG, sizeof(RSDP_SIG) - 1) != 0)
 412                 return NULL;
 413
 414         printk_debug("Looking on %p for valid checksum\n", rsdp);
 415
 416         if (acpi_checksum((void *)rsdp, 20) != 0)
 417                 return NULL;
 418         printk_debug("Checksum 1 passed\n");
 419
 420         if ((rsdp->revision > 1) && (acpi_checksum((void *)rsdp,
 421                                                 rsdp->length) != 0))
 422                 return NULL;
 423
 424         printk_debug("Checksum 2 passed all OK\n");
 425
 426         return rsdp;
 427 }
 428
 429 static acpi_rsdp_t *rsdp;
 430
 431 void *acpi_get_wakeup_rsdp(void)
 432 {
 433         return rsdp;
 434 }
 435
 436 void *acpi_find_wakeup_vector(void)
 437 {
 438         char *p, *end;
 439
 440         acpi_rsdt_t *rsdt;
 441         acpi_facs_t *facs;
 442         acpi_fadt_t *fadt;
 443         void  *wake_vec;
 444         int i;
 445
 446         rsdp = NULL;
 447
 448         if (!acpi_is_wakeup())
 449                 return NULL;
 450
 451         printk_debug("Trying to find the wakeup vector ...\n");
 452
 453         /* find RSDP */
 454         for (p = (char *) 0xe0000; p <  (char *) 0xfffff; p+=16) {
 455                 if ((rsdp = valid_rsdp((acpi_rsdp_t *) p)))
 456                         break;
 457         }
 458
 459         if (rsdp == NULL)
 460                 return NULL;
 461
 462         printk_debug("RSDP found at %p\n", rsdp);
 463         rsdt = (acpi_rsdt_t *) rsdp->rsdt_address;
 464
 465         end = (char *) rsdt + rsdt->header.length;
 466         printk_debug("RSDT found at %p ends at %p\n", rsdt, end);
 467
 468         for (i = 0; ((char *) &rsdt->entry[i]) < end; i++) {
 469                 fadt = (acpi_fadt_t *) rsdt->entry[i];
 470                 if (strncmp((char *)fadt, FADT_NAME, sizeof(FADT_NAME) - 1) == 0)
 471                         break;
 472                 fadt = NULL;
 473         }
 474
 475         if (fadt == NULL)
 476                 return NULL;
 477
 478         printk_debug("FADT found at %p\n", fadt);
 479         facs = fadt->firmware_ctrl;
 480
 481         if (facs == NULL) {
 482                 printk_debug("No FACS found, wake up from S3 not possible.\n");
 483                 return NULL;
 484         }
 485
 486         printk_debug("FACS found at %p\n", facs);
 487         wake_vec = (void *) facs->firmware_waking_vector;
 488         printk_debug("OS waking vector is %p\n", wake_vec);
 489         return wake_vec;
 490 }
 491
 492 extern char *lowmem_backup;
 493 extern char *lowmem_backup_ptr;
 494 extern int lowmem_backup_size;
 495
 496 void acpi_jump_to_wakeup(void *vector)
 497 {
 498         /* just restore the SMP trampoline and continue with wakeup on assembly level */
 499         memcpy(lowmem_backup_ptr, lowmem_backup, lowmem_backup_size);
 500         acpi_jmp_to_realm_wakeup((u32) vector);
 501 }
 502 #endif