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 <device/pci.h>
  28
  29 u8 acpi_checksum(u8 *table, u32 length)
  30 {
  31         u8 ret=0;
  32         while (length--) {
  33                 ret += *table;
  34                 table++;
  35         }
  36         return -ret;
  37 }
  38
  39 /*
  40  * add an acpi table to rsdt structure, and recalculate checksum
  41  */
  42
  43 void acpi_add_table(acpi_rsdt_t *rsdt, void *table)
  44 {
  45         int i;
  46
  47         int entries_num = ARRAY_SIZE(rsdt->entry);
  48
  49         for (i=0; i<entries_num; i++) {
  50                 if(rsdt->entry[i]==0) {
  51                         rsdt->entry[i]=(u32)table;
  52                         /* fix length to stop kernel winging about invalid entries */
  53                         rsdt->header.length = sizeof(acpi_header_t) + (sizeof(u32) * (i+1));
  54                         /* fix checksum */
  55                         /* hope this won't get optimized away */
  56                         rsdt->header.checksum=0;
  57                         rsdt->header.checksum=acpi_checksum((u8 *)rsdt,
  58                                         rsdt->header.length);
  59
  60                         printk_debug("ACPI: added table %d/%d Length now %d\n",i+1, entries_num, rsdt->header.length);
  61                         return;
  62                 }
  63         }
  64
  65         printk_warning("ACPI: could not add ACPI table to RSDT. failed.\n");
  66 }
  67
  68 int acpi_create_mcfg_mmconfig(acpi_mcfg_mmconfig_t *mmconfig, u32 base, u16 seg_nr, u8 start, u8 end)
  69 {
  70         mmconfig->base_address = base;
  71         mmconfig->base_reserved = 0;
  72         mmconfig->pci_segment_group_number = seg_nr;
  73         mmconfig->start_bus_number = start;
  74         mmconfig->end_bus_number = end;
  75         return (sizeof(acpi_mcfg_mmconfig_t));
  76 }
  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 int acpi_create_srat_lapic(acpi_srat_lapic_t *lapic, u8 node, u8 apic)
 185 {
 186         lapic->type=0;
 187         lapic->length=sizeof(acpi_srat_lapic_t);
 188         lapic->flags=1;
 189
 190         lapic->proximity_domain_7_0 = node;
 191         lapic->apic_id=apic;
 192
 193         return(lapic->length);
 194 }
 195
 196 int acpi_create_srat_mem(acpi_srat_mem_t *mem, u8 node, u32 basek,u32 sizek, u32 flags)
 197 {
 198         mem->type=1;
 199         mem->length=sizeof(acpi_srat_mem_t);
 200
 201         mem->base_address_low = (basek<<10);
 202         mem->base_address_high = (basek>>(32-10));
 203
 204         mem->length_low = (sizek<<10);
 205         mem->length_high = (sizek>>(32-10));
 206
 207         mem->proximity_domain = node;
 208
 209         mem->flags = flags;
 210
 211         return(mem->length);
 212 }
 213
 214 void acpi_create_srat(acpi_srat_t *srat)
 215 {
 216
 217         acpi_header_t *header=&(srat->header);
 218         unsigned long current=(unsigned long)srat+sizeof(acpi_srat_t);
 219
 220         memset((void *)srat, 0, sizeof(acpi_srat_t));
 221
 222         /* fill out header fields */
 223         memcpy(header->signature, SRAT_NAME, 4);
 224         memcpy(header->oem_id, OEM_ID, 6);
 225         memcpy(header->oem_table_id, SRAT_TABLE, 8);
 226         memcpy(header->asl_compiler_id, ASLC, 4);
 227
 228         header->length = sizeof(acpi_srat_t);
 229         header->revision = 1;
 230
 231         srat->resv     = 0x1; /* BACK COMP */
 232
 233         current = acpi_fill_srat(current);
 234
 235         /* recalculate length */
 236         header->length= current - (unsigned long)srat;
 237
 238         header->checksum        = acpi_checksum((void *)srat, header->length);
 239 }
 240
 241 void acpi_create_slit(acpi_slit_t *slit)
 242 {
 243
 244         acpi_header_t *header=&(slit->header);
 245         unsigned long current=(unsigned long)slit+sizeof(acpi_slit_t);
 246
 247         memset((void *)slit, 0, sizeof(acpi_slit_t));
 248
 249         /* fill out header fields */
 250         memcpy(header->signature, SLIT_NAME, 4);
 251         memcpy(header->oem_id, OEM_ID, 6);
 252         memcpy(header->oem_table_id, SLIT_TABLE, 8);
 253         memcpy(header->asl_compiler_id, ASLC, 4);
 254
 255         header->length = sizeof(acpi_slit_t);
 256         header->revision = 1;
 257
 258 //        current = acpi_fill_slit(current);
 259
 260         /* recalculate length */
 261         header->length= current - (unsigned long)slit;
 262
 263         header->checksum        = acpi_checksum((void *)slit, header->length);
 264 }
 265
 266 void acpi_create_hpet(acpi_hpet_t *hpet)
 267 {
 268 #define HPET_ADDR  0xfed00000ULL
 269         acpi_header_t *header=&(hpet->header);
 270         acpi_addr_t *addr=&(hpet->addr);
 271
 272         memset((void *)hpet, 0, sizeof(acpi_hpet_t));
 273
 274         /* fill out header fields */
 275         memcpy(header->signature, HPET_NAME, 4);
 276         memcpy(header->oem_id, OEM_ID, 6);
 277         memcpy(header->oem_table_id, HPET_TABLE, 8);
 278         memcpy(header->asl_compiler_id, ASLC, 4);
 279
 280         header->length = sizeof(acpi_hpet_t);
 281         header->revision = 1;
 282
 283         /* fill out HPET address */
 284         addr->space_id          = 0; /* Memory */
 285         addr->bit_width         = 64;
 286         addr->bit_offset        = 0;
 287         addr->addrl             = HPET_ADDR & 0xffffffff;
 288         addr->addrh             = HPET_ADDR >> 32;
 289
 290         hpet->id        = 0x102282a0; /* AMD ? */
 291         hpet->number    = 0;
 292         hpet->min_tick  = 4096;
 293
 294         header->checksum        = acpi_checksum((void *)hpet, sizeof(acpi_hpet_t));
 295 }
 296
 297 void acpi_create_facs(acpi_facs_t *facs)
 298 {
 299         memset( (void *)facs,0, sizeof(acpi_facs_t));
 300
 301         memcpy(facs->signature,"FACS",4);
 302         facs->length = sizeof(acpi_facs_t);
 303         facs->hardware_signature = 0;
 304         facs->firmware_waking_vector = 0;
 305         facs->global_lock = 0;
 306         facs->flags = 0;
 307         facs->x_firmware_waking_vector_l = 0;
 308         facs->x_firmware_waking_vector_h = 0;
 309         facs->version = 1;
 310 }
 311
 312 void acpi_write_rsdt(acpi_rsdt_t *rsdt)
 313 {
 314         acpi_header_t *header=&(rsdt->header);
 315
 316         /* fill out header fields */
 317         memcpy(header->signature, RSDT_NAME, 4);
 318         memcpy(header->oem_id, OEM_ID, 6);
 319         memcpy(header->oem_table_id, RSDT_TABLE, 8);
 320         memcpy(header->asl_compiler_id, ASLC, 4);
 321
 322         header->length = sizeof(acpi_rsdt_t);
 323         header->revision = 1;
 324
 325         /* fill out entries */
 326
 327         // entries are filled in later, we come with an empty set.
 328
 329         /* fix checksum */
 330
 331         header->checksum        = acpi_checksum((void *)rsdt, sizeof(acpi_rsdt_t));
 332 }
 333
 334 void acpi_write_rsdp(acpi_rsdp_t *rsdp, acpi_rsdt_t *rsdt)
 335 {
 336         memcpy(rsdp->signature, RSDP_SIG, 8);
 337         memcpy(rsdp->oem_id, OEM_ID, 6);
 338
 339         rsdp->length            = sizeof(acpi_rsdp_t);
 340         rsdp->rsdt_address      = (u32)rsdt;
 341         rsdp->checksum          = acpi_checksum((void *)rsdp, 20);
 342         rsdp->ext_checksum      = acpi_checksum((void *)rsdp, sizeof(acpi_rsdp_t));
 343 }
 344
 345