src/arch/i386/boot/acpi.c

   1 /*
   2  * coreboot ACPI Table support
   3  * written by Stefan Reinauer <stepan@openbios.org>
   4  *  (C) 2004 SUSE LINUX AG
   5  *  (C) 2005 Stefan Reinauer
   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
  80 int acpi_create_madt_lapic(acpi_madt_lapic_t *lapic, u8 cpu, u8 apic)
  81 {
  82         lapic->type=0;
  83         lapic->length=sizeof(acpi_madt_lapic_t);
  84         lapic->flags=1;
  85
  86         lapic->processor_id=cpu;
  87         lapic->apic_id=apic;
  88
  89         return(lapic->length);
  90 }
  91
  92 int acpi_create_madt_ioapic(acpi_madt_ioapic_t *ioapic, u8 id, u32 addr,u32 gsi_base)
  93 {
  94         ioapic->type=1;
  95         ioapic->length=sizeof(acpi_madt_ioapic_t);
  96         ioapic->reserved=0x00;
  97         ioapic->gsi_base=gsi_base;
  98
  99         ioapic->ioapic_id=id;
 100         ioapic->ioapic_addr=addr;
 101
 102         return(ioapic->length);
 103 }
 104
 105 int acpi_create_madt_irqoverride(acpi_madt_irqoverride_t *irqoverride,
 106                 u8 bus, u8 source, u32 gsirq, u16 flags)
 107 {
 108         irqoverride->type=2;
 109         irqoverride->length=sizeof(acpi_madt_irqoverride_t);
 110         irqoverride->bus=bus;
 111         irqoverride->source=source;
 112         irqoverride->gsirq=gsirq;
 113         irqoverride->flags=flags;
 114
 115         return(irqoverride->length);
 116 }
 117
 118 int acpi_create_madt_lapic_nmi(acpi_madt_lapic_nmi_t *lapic_nmi, u8 cpu,
 119                 u16 flags, u8 lint)
 120 {
 121         lapic_nmi->type=4;
 122         lapic_nmi->length=sizeof(acpi_madt_lapic_nmi_t);
 123
 124         lapic_nmi->flags=flags;
 125         lapic_nmi->processor_id=cpu;
 126         lapic_nmi->lint=lint;
 127
 128         return(lapic_nmi->length);
 129 }
 130
 131 void acpi_create_madt(acpi_madt_t *madt)
 132 {
 133 #define LOCAL_APIC_ADDR 0xfee00000ULL
 134
 135         acpi_header_t *header=&(madt->header);
 136         unsigned long current=(unsigned long)madt+sizeof(acpi_madt_t);
 137
 138         memset((void *)madt, 0, sizeof(acpi_madt_t));
 139
 140         /* fill out header fields */
 141         memcpy(header->signature, MADT_NAME, 4);
 142         memcpy(header->oem_id, OEM_ID, 6);
 143         memcpy(header->oem_table_id, MADT_TABLE, 8);
 144         memcpy(header->asl_compiler_id, ASLC, 4);
 145
 146         header->length = sizeof(acpi_madt_t);
 147         header->revision = 1;
 148
 149         madt->lapic_addr= LOCAL_APIC_ADDR;
 150         madt->flags     = 0x1; /* PCAT_COMPAT */
 151
 152         current = acpi_fill_madt(current);
 153
 154         /* recalculate length */
 155         header->length= current - (unsigned long)madt;
 156
 157         header->checksum        = acpi_checksum((void *)madt, header->length);
 158 }
 159
 160 void acpi_create_mcfg(acpi_mcfg_t *mcfg)
 161 {
 162
 163         acpi_header_t *header=&(mcfg->header);
 164         unsigned long current=(unsigned long)mcfg+sizeof(acpi_mcfg_t);
 165
 166         memset((void *)mcfg, 0, sizeof(acpi_mcfg_t));
 167
 168         /* fill out header fields */
 169         memcpy(header->signature, MCFG_NAME, 4);
 170         memcpy(header->oem_id, OEM_ID, 6);
 171         memcpy(header->oem_table_id, MCFG_TABLE, 8);
 172         memcpy(header->asl_compiler_id, ASLC, 4);
 173
 174         header->length = sizeof(acpi_mcfg_t);
 175         header->revision = 1;
 176
 177         current = acpi_fill_mcfg(current);
 178
 179         /* recalculate length */
 180         header->length= current - (unsigned long)mcfg;
 181
 182         header->checksum        = acpi_checksum((void *)mcfg, header->length);
 183 }
 184
 185 /* this can be overriden by platform ACPI setup code,
 186    if it calls acpi_create_ssdt_generator */
 187 unsigned long __attribute__((weak)) acpi_fill_ssdt_generator(unsigned long current,
 188                                                     char *oem_table_id) {
 189         return current;
 190 }
 191
 192 void acpi_create_ssdt_generator(acpi_header_t *ssdt, char *oem_table_id)
 193 {
 194         unsigned long current=(unsigned long)ssdt+sizeof(acpi_header_t);
 195         memset((void *)ssdt, 0, sizeof(acpi_header_t));
 196         memcpy(&ssdt->signature, SSDT_NAME, 4);
 197         ssdt->revision = 2;
 198         memcpy(&ssdt->oem_id, OEM_ID, 6);
 199         memcpy(&ssdt->oem_table_id, oem_table_id, 8);
 200         ssdt->oem_revision = 42;
 201         memcpy(&ssdt->asl_compiler_id, "GENAML", 4);
 202         ssdt->asl_compiler_revision = 42;
 203         ssdt->length = sizeof(acpi_header_t);
 204
 205         acpigen_set_current((unsigned char *) current);
 206         current = acpi_fill_ssdt_generator(current, oem_table_id);
 207
 208         /* recalculate length */
 209         ssdt->length = current - (unsigned long)ssdt;
 210         ssdt->checksum = acpi_checksum((void *)ssdt, ssdt->length);
 211 }
 212
 213 int acpi_create_srat_lapic(acpi_srat_lapic_t *lapic, u8 node, u8 apic)
 214 {
 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
 326 void acpi_create_facs(acpi_facs_t *facs)
 327 {
 328         memset( (void *)facs,0, sizeof(acpi_facs_t));
 329
 330         memcpy(facs->signature,"FACS",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
 368         rsdp->length            = sizeof(acpi_rsdp_t);
 369         rsdp->rsdt_address      = (u32)rsdt;
 370         rsdp->checksum          = acpi_checksum((void *)rsdp, 20);
 371         rsdp->ext_checksum      = acpi_checksum((void *)rsdp, sizeof(acpi_rsdp_t));
 372 }
 373
 374