Kevin O'Connor | 84ad59a | 2008-07-04 05:47:26 -0400 | [diff] [blame] | 1 | // Support for generating ACPI tables (on emulators) |
Kevin O'Connor | 276d4a9 | 2008-06-11 22:47:01 -0400 | [diff] [blame] | 2 | // |
| 3 | // Copyright (C) 2008 Kevin O'Connor <kevin@koconnor.net> |
| 4 | // Copyright (C) 2006 Fabrice Bellard |
| 5 | // |
| 6 | // This file may be distributed under the terms of the GNU GPLv3 license. |
| 7 | |
| 8 | #include "acpi.h" // struct rsdp_descriptor |
| 9 | #include "util.h" // memcpy |
| 10 | #include "memmap.h" // bios_table_cur_addr |
| 11 | #include "pci.h" // pci_find_device |
Kevin O'Connor | 9521e26 | 2008-07-04 13:04:29 -0400 | [diff] [blame] | 12 | #include "biosvar.h" // GET_EBDA |
Kevin O'Connor | 276d4a9 | 2008-06-11 22:47:01 -0400 | [diff] [blame] | 13 | |
| 14 | |
| 15 | /****************************************************/ |
| 16 | /* ACPI tables init */ |
| 17 | |
| 18 | /* Table structure from Linux kernel (the ACPI tables are under the |
| 19 | BSD license) */ |
| 20 | |
| 21 | #define ACPI_TABLE_HEADER_DEF /* ACPI common table header */ \ |
| 22 | u8 signature [4]; /* ACPI signature (4 ASCII characters) */\ |
| 23 | u32 length; /* Length of table, in bytes, including header */\ |
| 24 | u8 revision; /* ACPI Specification minor version # */\ |
| 25 | u8 checksum; /* To make sum of entire table == 0 */\ |
| 26 | u8 oem_id [6]; /* OEM identification */\ |
| 27 | u8 oem_table_id [8]; /* OEM table identification */\ |
| 28 | u32 oem_revision; /* OEM revision number */\ |
| 29 | u8 asl_compiler_id [4]; /* ASL compiler vendor ID */\ |
| 30 | u32 asl_compiler_revision; /* ASL compiler revision number */ |
| 31 | |
| 32 | |
| 33 | struct acpi_table_header /* ACPI common table header */ |
| 34 | { |
| 35 | ACPI_TABLE_HEADER_DEF |
| 36 | }; |
| 37 | |
| 38 | /* |
| 39 | * ACPI 1.0 Root System Description Table (RSDT) |
| 40 | */ |
| 41 | struct rsdt_descriptor_rev1 |
| 42 | { |
| 43 | ACPI_TABLE_HEADER_DEF /* ACPI common table header */ |
| 44 | u32 table_offset_entry [3]; /* Array of pointers to other */ |
| 45 | /* ACPI tables */ |
| 46 | }; |
| 47 | |
| 48 | /* |
| 49 | * ACPI 1.0 Firmware ACPI Control Structure (FACS) |
| 50 | */ |
| 51 | struct facs_descriptor_rev1 |
| 52 | { |
| 53 | u8 signature[4]; /* ACPI Signature */ |
| 54 | u32 length; /* Length of structure, in bytes */ |
| 55 | u32 hardware_signature; /* Hardware configuration signature */ |
| 56 | u32 firmware_waking_vector; /* ACPI OS waking vector */ |
| 57 | u32 global_lock; /* Global Lock */ |
| 58 | u32 S4bios_f : 1; /* Indicates if S4BIOS support is present */ |
| 59 | u32 reserved1 : 31; /* Must be 0 */ |
| 60 | u8 resverved3 [40]; /* Reserved - must be zero */ |
| 61 | }; |
| 62 | |
| 63 | |
| 64 | /* |
| 65 | * ACPI 1.0 Fixed ACPI Description Table (FADT) |
| 66 | */ |
| 67 | struct fadt_descriptor_rev1 |
| 68 | { |
| 69 | ACPI_TABLE_HEADER_DEF /* ACPI common table header */ |
| 70 | u32 firmware_ctrl; /* Physical address of FACS */ |
| 71 | u32 dsdt; /* Physical address of DSDT */ |
| 72 | u8 model; /* System Interrupt Model */ |
| 73 | u8 reserved1; /* Reserved */ |
| 74 | u16 sci_int; /* System vector of SCI interrupt */ |
| 75 | u32 smi_cmd; /* Port address of SMI command port */ |
| 76 | u8 acpi_enable; /* Value to write to smi_cmd to enable ACPI */ |
| 77 | u8 acpi_disable; /* Value to write to smi_cmd to disable ACPI */ |
| 78 | u8 S4bios_req; /* Value to write to SMI CMD to enter S4BIOS state */ |
| 79 | u8 reserved2; /* Reserved - must be zero */ |
| 80 | u32 pm1a_evt_blk; /* Port address of Power Mgt 1a acpi_event Reg Blk */ |
| 81 | u32 pm1b_evt_blk; /* Port address of Power Mgt 1b acpi_event Reg Blk */ |
| 82 | u32 pm1a_cnt_blk; /* Port address of Power Mgt 1a Control Reg Blk */ |
| 83 | u32 pm1b_cnt_blk; /* Port address of Power Mgt 1b Control Reg Blk */ |
| 84 | u32 pm2_cnt_blk; /* Port address of Power Mgt 2 Control Reg Blk */ |
| 85 | u32 pm_tmr_blk; /* Port address of Power Mgt Timer Ctrl Reg Blk */ |
| 86 | u32 gpe0_blk; /* Port addr of General Purpose acpi_event 0 Reg Blk */ |
| 87 | u32 gpe1_blk; /* Port addr of General Purpose acpi_event 1 Reg Blk */ |
| 88 | u8 pm1_evt_len; /* Byte length of ports at pm1_x_evt_blk */ |
| 89 | u8 pm1_cnt_len; /* Byte length of ports at pm1_x_cnt_blk */ |
| 90 | u8 pm2_cnt_len; /* Byte Length of ports at pm2_cnt_blk */ |
| 91 | u8 pm_tmr_len; /* Byte Length of ports at pm_tm_blk */ |
| 92 | u8 gpe0_blk_len; /* Byte Length of ports at gpe0_blk */ |
| 93 | u8 gpe1_blk_len; /* Byte Length of ports at gpe1_blk */ |
| 94 | u8 gpe1_base; /* Offset in gpe model where gpe1 events start */ |
| 95 | u8 reserved3; /* Reserved */ |
| 96 | u16 plvl2_lat; /* Worst case HW latency to enter/exit C2 state */ |
| 97 | u16 plvl3_lat; /* Worst case HW latency to enter/exit C3 state */ |
| 98 | u16 flush_size; /* Size of area read to flush caches */ |
| 99 | u16 flush_stride; /* Stride used in flushing caches */ |
| 100 | u8 duty_offset; /* Bit location of duty cycle field in p_cnt reg */ |
| 101 | u8 duty_width; /* Bit width of duty cycle field in p_cnt reg */ |
| 102 | u8 day_alrm; /* Index to day-of-month alarm in RTC CMOS RAM */ |
| 103 | u8 mon_alrm; /* Index to month-of-year alarm in RTC CMOS RAM */ |
| 104 | u8 century; /* Index to century in RTC CMOS RAM */ |
| 105 | u8 reserved4; /* Reserved */ |
| 106 | u8 reserved4a; /* Reserved */ |
| 107 | u8 reserved4b; /* Reserved */ |
| 108 | #if 0 |
| 109 | u32 wb_invd : 1; /* The wbinvd instruction works properly */ |
| 110 | u32 wb_invd_flush : 1; /* The wbinvd flushes but does not invalidate */ |
| 111 | u32 proc_c1 : 1; /* All processors support C1 state */ |
| 112 | u32 plvl2_up : 1; /* C2 state works on MP system */ |
| 113 | u32 pwr_button : 1; /* Power button is handled as a generic feature */ |
| 114 | u32 sleep_button : 1; /* Sleep button is handled as a generic feature, or not present */ |
| 115 | u32 fixed_rTC : 1; /* RTC wakeup stat not in fixed register space */ |
| 116 | u32 rtcs4 : 1; /* RTC wakeup stat not possible from S4 */ |
| 117 | u32 tmr_val_ext : 1; /* The tmr_val width is 32 bits (0 = 24 bits) */ |
| 118 | u32 reserved5 : 23; /* Reserved - must be zero */ |
| 119 | #else |
| 120 | u32 flags; |
| 121 | #endif |
| 122 | }; |
| 123 | |
| 124 | /* |
| 125 | * MADT values and structures |
| 126 | */ |
| 127 | |
| 128 | /* Values for MADT PCATCompat */ |
| 129 | |
| 130 | #define DUAL_PIC 0 |
| 131 | #define MULTIPLE_APIC 1 |
| 132 | |
| 133 | |
| 134 | /* Master MADT */ |
| 135 | |
| 136 | struct multiple_apic_table |
| 137 | { |
| 138 | ACPI_TABLE_HEADER_DEF /* ACPI common table header */ |
| 139 | u32 local_apic_address; /* Physical address of local APIC */ |
| 140 | #if 0 |
| 141 | u32 PCATcompat : 1; /* A one indicates system also has dual 8259s */ |
| 142 | u32 reserved1 : 31; |
| 143 | #else |
| 144 | u32 flags; |
| 145 | #endif |
| 146 | }; |
| 147 | |
| 148 | |
| 149 | /* Values for Type in APIC_HEADER_DEF */ |
| 150 | |
| 151 | #define APIC_PROCESSOR 0 |
| 152 | #define APIC_IO 1 |
| 153 | #define APIC_XRUPT_OVERRIDE 2 |
| 154 | #define APIC_NMI 3 |
| 155 | #define APIC_LOCAL_NMI 4 |
| 156 | #define APIC_ADDRESS_OVERRIDE 5 |
| 157 | #define APIC_IO_SAPIC 6 |
| 158 | #define APIC_LOCAL_SAPIC 7 |
| 159 | #define APIC_XRUPT_SOURCE 8 |
| 160 | #define APIC_RESERVED 9 /* 9 and greater are reserved */ |
| 161 | |
| 162 | /* |
| 163 | * MADT sub-structures (Follow MULTIPLE_APIC_DESCRIPTION_TABLE) |
| 164 | */ |
| 165 | #define APIC_HEADER_DEF /* Common APIC sub-structure header */\ |
| 166 | u8 type; \ |
| 167 | u8 length; |
| 168 | |
| 169 | /* Sub-structures for MADT */ |
| 170 | |
| 171 | struct madt_processor_apic |
| 172 | { |
| 173 | APIC_HEADER_DEF |
| 174 | u8 processor_id; /* ACPI processor id */ |
| 175 | u8 local_apic_id; /* Processor's local APIC id */ |
| 176 | #if 0 |
| 177 | u32 processor_enabled: 1; /* Processor is usable if set */ |
| 178 | u32 reserved2 : 31; /* Reserved, must be zero */ |
| 179 | #else |
| 180 | u32 flags; |
| 181 | #endif |
| 182 | }; |
| 183 | |
| 184 | struct madt_io_apic |
| 185 | { |
| 186 | APIC_HEADER_DEF |
| 187 | u8 io_apic_id; /* I/O APIC ID */ |
| 188 | u8 reserved; /* Reserved - must be zero */ |
| 189 | u32 address; /* APIC physical address */ |
| 190 | u32 interrupt; /* Global system interrupt where INTI |
| 191 | * lines start */ |
| 192 | }; |
| 193 | |
| 194 | #include "acpi-dsdt.hex" |
| 195 | |
| 196 | static inline u16 cpu_to_le16(u16 x) |
| 197 | { |
| 198 | return x; |
| 199 | } |
| 200 | |
| 201 | static inline u32 cpu_to_le32(u32 x) |
| 202 | { |
| 203 | return x; |
| 204 | } |
| 205 | |
| 206 | static void acpi_build_table_header(struct acpi_table_header *h, |
| 207 | char *sig, int len, u8 rev) |
| 208 | { |
| 209 | memcpy(h->signature, sig, 4); |
| 210 | h->length = cpu_to_le32(len); |
| 211 | h->revision = rev; |
Kevin O'Connor | 6cb8ba9 | 2008-08-17 11:03:24 -0400 | [diff] [blame] | 212 | memcpy(h->oem_id, CONFIG_APPNAME6, 6); |
| 213 | memcpy(h->oem_table_id, CONFIG_APPNAME4, 4); |
| 214 | memcpy(h->asl_compiler_id, CONFIG_APPNAME4, 4); |
Kevin O'Connor | 276d4a9 | 2008-06-11 22:47:01 -0400 | [diff] [blame] | 215 | memcpy(h->oem_table_id + 4, sig, 4); |
| 216 | h->oem_revision = cpu_to_le32(1); |
Kevin O'Connor | 276d4a9 | 2008-06-11 22:47:01 -0400 | [diff] [blame] | 217 | h->asl_compiler_revision = cpu_to_le32(1); |
| 218 | h->checksum = -checksum((void *)h, len); |
| 219 | } |
| 220 | |
| 221 | static int |
| 222 | acpi_build_processor_ssdt(u8 *ssdt) |
| 223 | { |
| 224 | u8 *ssdt_ptr = ssdt; |
| 225 | int i, length; |
Kevin O'Connor | 84ad59a | 2008-07-04 05:47:26 -0400 | [diff] [blame] | 226 | int smp_cpus = smp_probe(); |
Kevin O'Connor | 276d4a9 | 2008-06-11 22:47:01 -0400 | [diff] [blame] | 227 | int acpi_cpus = smp_cpus > 0xff ? 0xff : smp_cpus; |
| 228 | |
| 229 | ssdt_ptr[9] = 0; // checksum; |
| 230 | ssdt_ptr += sizeof(struct acpi_table_header); |
| 231 | |
| 232 | // caluculate the length of processor block and scope block excluding PkgLength |
| 233 | length = 0x0d * acpi_cpus + 4; |
| 234 | |
| 235 | // build processor scope header |
| 236 | *(ssdt_ptr++) = 0x10; // ScopeOp |
| 237 | if (length <= 0x3e) { |
| 238 | *(ssdt_ptr++) = length + 1; |
| 239 | } else { |
| 240 | *(ssdt_ptr++) = 0x7F; |
| 241 | *(ssdt_ptr++) = (length + 2) >> 6; |
| 242 | } |
| 243 | *(ssdt_ptr++) = '_'; // Name |
| 244 | *(ssdt_ptr++) = 'P'; |
| 245 | *(ssdt_ptr++) = 'R'; |
| 246 | *(ssdt_ptr++) = '_'; |
| 247 | |
| 248 | // build object for each processor |
| 249 | for(i=0;i<acpi_cpus;i++) { |
| 250 | *(ssdt_ptr++) = 0x5B; // ProcessorOp |
| 251 | *(ssdt_ptr++) = 0x83; |
| 252 | *(ssdt_ptr++) = 0x0B; // Length |
| 253 | *(ssdt_ptr++) = 'C'; // Name (CPUxx) |
| 254 | *(ssdt_ptr++) = 'P'; |
| 255 | if ((i & 0xf0) != 0) |
| 256 | *(ssdt_ptr++) = (i >> 4) < 0xa ? (i >> 4) + '0' : (i >> 4) + 'A' - 0xa; |
| 257 | else |
| 258 | *(ssdt_ptr++) = 'U'; |
| 259 | *(ssdt_ptr++) = (i & 0xf) < 0xa ? (i & 0xf) + '0' : (i & 0xf) + 'A' - 0xa; |
| 260 | *(ssdt_ptr++) = i; |
| 261 | *(ssdt_ptr++) = 0x10; // Processor block address |
| 262 | *(ssdt_ptr++) = 0xb0; |
| 263 | *(ssdt_ptr++) = 0; |
| 264 | *(ssdt_ptr++) = 0; |
| 265 | *(ssdt_ptr++) = 6; // Processor block length |
| 266 | } |
| 267 | |
| 268 | acpi_build_table_header((struct acpi_table_header *)ssdt, |
| 269 | "SSDT", ssdt_ptr - ssdt, 1); |
| 270 | |
| 271 | return ssdt_ptr - ssdt; |
| 272 | } |
| 273 | |
| 274 | /* base_addr must be a multiple of 4KB */ |
| 275 | void acpi_bios_init(void) |
| 276 | { |
Kevin O'Connor | d8a1811 | 2008-06-12 22:12:48 -0400 | [diff] [blame] | 277 | if (! CONFIG_ACPI) |
| 278 | return; |
| 279 | |
Kevin O'Connor | 7b49cd9 | 2008-11-08 10:35:26 -0500 | [diff] [blame^] | 280 | dprintf(3, "init ACPI tables\n"); |
| 281 | |
Kevin O'Connor | 276d4a9 | 2008-06-11 22:47:01 -0400 | [diff] [blame] | 282 | // This code is hardcoded for PIIX4 Power Management device. |
| 283 | PCIDevice d; |
Kevin O'Connor | 415c2dc | 2008-10-25 14:35:59 -0400 | [diff] [blame] | 284 | int ret = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_3 |
| 285 | , 0, &d); |
Kevin O'Connor | 276d4a9 | 2008-06-11 22:47:01 -0400 | [diff] [blame] | 286 | if (ret) |
| 287 | // Device not found |
| 288 | return; |
| 289 | |
| 290 | struct rsdp_descriptor *rsdp; |
| 291 | struct rsdt_descriptor_rev1 *rsdt; |
| 292 | struct fadt_descriptor_rev1 *fadt; |
| 293 | struct facs_descriptor_rev1 *facs; |
| 294 | struct multiple_apic_table *madt; |
| 295 | u8 *dsdt, *ssdt; |
| 296 | u32 base_addr, rsdt_addr, fadt_addr, addr, facs_addr, dsdt_addr, ssdt_addr; |
| 297 | u32 acpi_tables_size, madt_addr, madt_size; |
| 298 | int i; |
| 299 | |
| 300 | /* reserve memory space for tables */ |
Kevin O'Connor | 276d4a9 | 2008-06-11 22:47:01 -0400 | [diff] [blame] | 301 | bios_table_cur_addr = ALIGN(bios_table_cur_addr, 16); |
| 302 | rsdp = (void *)(bios_table_cur_addr); |
| 303 | bios_table_cur_addr += sizeof(*rsdp); |
Kevin O'Connor | 276d4a9 | 2008-06-11 22:47:01 -0400 | [diff] [blame] | 304 | |
| 305 | addr = base_addr = GET_EBDA(ram_size) - CONFIG_ACPI_DATA_SIZE; |
| 306 | add_e820(addr, CONFIG_ACPI_DATA_SIZE, E820_ACPI); |
| 307 | rsdt_addr = addr; |
| 308 | rsdt = (void *)(addr); |
| 309 | addr += sizeof(*rsdt); |
| 310 | |
| 311 | fadt_addr = addr; |
| 312 | fadt = (void *)(addr); |
| 313 | addr += sizeof(*fadt); |
| 314 | |
Kevin O'Connor | e06363e | 2008-08-29 21:12:03 -0400 | [diff] [blame] | 315 | addr = ALIGN(addr, 64); |
Kevin O'Connor | 276d4a9 | 2008-06-11 22:47:01 -0400 | [diff] [blame] | 316 | facs_addr = addr; |
| 317 | facs = (void *)(addr); |
| 318 | addr += sizeof(*facs); |
| 319 | |
| 320 | dsdt_addr = addr; |
| 321 | dsdt = (void *)(addr); |
| 322 | addr += sizeof(AmlCode); |
| 323 | |
| 324 | ssdt_addr = addr; |
| 325 | ssdt = (void *)(addr); |
| 326 | addr += acpi_build_processor_ssdt(ssdt); |
| 327 | |
Kevin O'Connor | 84ad59a | 2008-07-04 05:47:26 -0400 | [diff] [blame] | 328 | int smp_cpus = smp_probe(); |
Kevin O'Connor | e06363e | 2008-08-29 21:12:03 -0400 | [diff] [blame] | 329 | addr = ALIGN(addr, 8); |
Kevin O'Connor | 276d4a9 | 2008-06-11 22:47:01 -0400 | [diff] [blame] | 330 | madt_addr = addr; |
| 331 | madt_size = sizeof(*madt) + |
| 332 | sizeof(struct madt_processor_apic) * smp_cpus + |
| 333 | sizeof(struct madt_io_apic); |
| 334 | madt = (void *)(addr); |
| 335 | addr += madt_size; |
| 336 | |
| 337 | acpi_tables_size = addr - base_addr; |
| 338 | |
| 339 | dprintf(1, "ACPI tables: RSDP addr=0x%08lx" |
| 340 | " ACPI DATA addr=0x%08lx size=0x%x\n", |
| 341 | (unsigned long)rsdp, |
| 342 | (unsigned long)rsdt, acpi_tables_size); |
| 343 | |
| 344 | /* RSDP */ |
| 345 | memset(rsdp, 0, sizeof(*rsdp)); |
| 346 | memcpy(rsdp->signature, "RSD PTR ", 8); |
Kevin O'Connor | 6cb8ba9 | 2008-08-17 11:03:24 -0400 | [diff] [blame] | 347 | memcpy(rsdp->oem_id, CONFIG_APPNAME6, 6); |
Kevin O'Connor | 276d4a9 | 2008-06-11 22:47:01 -0400 | [diff] [blame] | 348 | rsdp->rsdt_physical_address = cpu_to_le32(rsdt_addr); |
| 349 | rsdp->checksum = -checksum((void *)rsdp, 20); |
| 350 | |
| 351 | /* RSDT */ |
| 352 | memset(rsdt, 0, sizeof(*rsdt)); |
| 353 | rsdt->table_offset_entry[0] = cpu_to_le32(fadt_addr); |
| 354 | rsdt->table_offset_entry[1] = cpu_to_le32(madt_addr); |
| 355 | rsdt->table_offset_entry[2] = cpu_to_le32(ssdt_addr); |
| 356 | acpi_build_table_header((struct acpi_table_header *)rsdt, |
| 357 | "RSDT", sizeof(*rsdt), 1); |
| 358 | |
| 359 | /* FADT */ |
| 360 | memset(fadt, 0, sizeof(*fadt)); |
| 361 | fadt->firmware_ctrl = cpu_to_le32(facs_addr); |
| 362 | fadt->dsdt = cpu_to_le32(dsdt_addr); |
| 363 | fadt->model = 1; |
| 364 | fadt->reserved1 = 0; |
| 365 | int pm_sci_int = pci_config_readb(d, PCI_INTERRUPT_LINE); |
| 366 | fadt->sci_int = cpu_to_le16(pm_sci_int); |
| 367 | fadt->smi_cmd = cpu_to_le32(BUILD_SMI_CMD_IO_ADDR); |
| 368 | fadt->acpi_enable = 0xf1; |
| 369 | fadt->acpi_disable = 0xf0; |
| 370 | fadt->pm1a_evt_blk = cpu_to_le32(BUILD_PM_IO_BASE); |
| 371 | fadt->pm1a_cnt_blk = cpu_to_le32(BUILD_PM_IO_BASE + 0x04); |
| 372 | fadt->pm_tmr_blk = cpu_to_le32(BUILD_PM_IO_BASE + 0x08); |
| 373 | fadt->pm1_evt_len = 4; |
| 374 | fadt->pm1_cnt_len = 2; |
| 375 | fadt->pm_tmr_len = 4; |
| 376 | fadt->plvl2_lat = cpu_to_le16(0xfff); // C2 state not supported |
| 377 | fadt->plvl3_lat = cpu_to_le16(0xfff); // C3 state not supported |
| 378 | /* WBINVD + PROC_C1 + PWR_BUTTON + SLP_BUTTON + FIX_RTC */ |
| 379 | fadt->flags = cpu_to_le32((1 << 0) | (1 << 2) | (1 << 4) | (1 << 5) | (1 << 6)); |
| 380 | acpi_build_table_header((struct acpi_table_header *)fadt, "FACP", |
| 381 | sizeof(*fadt), 1); |
| 382 | |
| 383 | /* FACS */ |
| 384 | memset(facs, 0, sizeof(*facs)); |
| 385 | memcpy(facs->signature, "FACS", 4); |
| 386 | facs->length = cpu_to_le32(sizeof(*facs)); |
| 387 | |
| 388 | /* DSDT */ |
| 389 | memcpy(dsdt, AmlCode, sizeof(AmlCode)); |
| 390 | |
| 391 | /* MADT */ |
| 392 | { |
| 393 | struct madt_processor_apic *apic; |
| 394 | struct madt_io_apic *io_apic; |
| 395 | |
| 396 | memset(madt, 0, madt_size); |
| 397 | madt->local_apic_address = cpu_to_le32(0xfee00000); |
| 398 | madt->flags = cpu_to_le32(1); |
| 399 | apic = (void *)(madt + 1); |
| 400 | for(i=0;i<smp_cpus;i++) { |
| 401 | apic->type = APIC_PROCESSOR; |
| 402 | apic->length = sizeof(*apic); |
| 403 | apic->processor_id = i; |
| 404 | apic->local_apic_id = i; |
| 405 | apic->flags = cpu_to_le32(1); |
| 406 | apic++; |
| 407 | } |
| 408 | io_apic = (void *)apic; |
| 409 | io_apic->type = APIC_IO; |
| 410 | io_apic->length = sizeof(*io_apic); |
| 411 | io_apic->io_apic_id = smp_cpus; |
| 412 | io_apic->address = cpu_to_le32(0xfec00000); |
| 413 | io_apic->interrupt = cpu_to_le32(0); |
| 414 | |
| 415 | acpi_build_table_header((struct acpi_table_header *)madt, |
| 416 | "APIC", madt_size, 1); |
| 417 | } |
| 418 | } |