ACPI, ia64: Use SRAT table rev to use 8bit or 16/32bit PXM fields (ia64)
[linux-3.10.git] / arch / ia64 / kernel / acpi.c
1 /*
2  *  acpi.c - Architecture-Specific Low-Level ACPI Support
3  *
4  *  Copyright (C) 1999 VA Linux Systems
5  *  Copyright (C) 1999,2000 Walt Drummond <drummond@valinux.com>
6  *  Copyright (C) 2000, 2002-2003 Hewlett-Packard Co.
7  *      David Mosberger-Tang <davidm@hpl.hp.com>
8  *  Copyright (C) 2000 Intel Corp.
9  *  Copyright (C) 2000,2001 J.I. Lee <jung-ik.lee@intel.com>
10  *  Copyright (C) 2001 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
11  *  Copyright (C) 2001 Jenna Hall <jenna.s.hall@intel.com>
12  *  Copyright (C) 2001 Takayoshi Kochi <t-kochi@bq.jp.nec.com>
13  *  Copyright (C) 2002 Erich Focht <efocht@ess.nec.de>
14  *  Copyright (C) 2004 Ashok Raj <ashok.raj@intel.com>
15  *
16  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
17  *
18  *  This program is free software; you can redistribute it and/or modify
19  *  it under the terms of the GNU General Public License as published by
20  *  the Free Software Foundation; either version 2 of the License, or
21  *  (at your option) any later version.
22  *
23  *  This program is distributed in the hope that it will be useful,
24  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
25  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
26  *  GNU General Public License for more details.
27  *
28  *  You should have received a copy of the GNU General Public License
29  *  along with this program; if not, write to the Free Software
30  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
31  *
32  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
33  */
34
35 #include <linux/module.h>
36 #include <linux/init.h>
37 #include <linux/kernel.h>
38 #include <linux/sched.h>
39 #include <linux/smp.h>
40 #include <linux/string.h>
41 #include <linux/types.h>
42 #include <linux/irq.h>
43 #include <linux/acpi.h>
44 #include <linux/efi.h>
45 #include <linux/mmzone.h>
46 #include <linux/nodemask.h>
47 #include <linux/slab.h>
48 #include <acpi/processor.h>
49 #include <asm/io.h>
50 #include <asm/iosapic.h>
51 #include <asm/machvec.h>
52 #include <asm/page.h>
53 #include <asm/system.h>
54 #include <asm/numa.h>
55 #include <asm/sal.h>
56 #include <asm/cyclone.h>
57 #include <asm/xen/hypervisor.h>
58
59 #define BAD_MADT_ENTRY(entry, end) (                                        \
60                 (!entry) || (unsigned long)entry + sizeof(*entry) > end ||  \
61                 ((struct acpi_subtable_header *)entry)->length < sizeof(*entry))
62
63 #define PREFIX                  "ACPI: "
64
65 u32 acpi_rsdt_forced;
66 unsigned int acpi_cpei_override;
67 unsigned int acpi_cpei_phys_cpuid;
68
69 unsigned long acpi_wakeup_address = 0;
70
71 #ifdef CONFIG_IA64_GENERIC
72 static unsigned long __init acpi_find_rsdp(void)
73 {
74         unsigned long rsdp_phys = 0;
75
76         if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
77                 rsdp_phys = efi.acpi20;
78         else if (efi.acpi != EFI_INVALID_TABLE_ADDR)
79                 printk(KERN_WARNING PREFIX
80                        "v1.0/r0.71 tables no longer supported\n");
81         return rsdp_phys;
82 }
83
84 const char __init *
85 acpi_get_sysname(void)
86 {
87         unsigned long rsdp_phys;
88         struct acpi_table_rsdp *rsdp;
89         struct acpi_table_xsdt *xsdt;
90         struct acpi_table_header *hdr;
91 #ifdef CONFIG_INTEL_IOMMU
92         u64 i, nentries;
93 #endif
94
95         rsdp_phys = acpi_find_rsdp();
96         if (!rsdp_phys) {
97                 printk(KERN_ERR
98                        "ACPI 2.0 RSDP not found, default to \"dig\"\n");
99                 return "dig";
100         }
101
102         rsdp = (struct acpi_table_rsdp *)__va(rsdp_phys);
103         if (strncmp(rsdp->signature, ACPI_SIG_RSDP, sizeof(ACPI_SIG_RSDP) - 1)) {
104                 printk(KERN_ERR
105                        "ACPI 2.0 RSDP signature incorrect, default to \"dig\"\n");
106                 return "dig";
107         }
108
109         xsdt = (struct acpi_table_xsdt *)__va(rsdp->xsdt_physical_address);
110         hdr = &xsdt->header;
111         if (strncmp(hdr->signature, ACPI_SIG_XSDT, sizeof(ACPI_SIG_XSDT) - 1)) {
112                 printk(KERN_ERR
113                        "ACPI 2.0 XSDT signature incorrect, default to \"dig\"\n");
114                 return "dig";
115         }
116
117         if (!strcmp(hdr->oem_id, "HP")) {
118                 return "hpzx1";
119         } else if (!strcmp(hdr->oem_id, "SGI")) {
120                 if (!strcmp(hdr->oem_table_id + 4, "UV"))
121                         return "uv";
122                 else
123                         return "sn2";
124         } else if (xen_pv_domain() && !strcmp(hdr->oem_id, "XEN")) {
125                 return "xen";
126         }
127
128 #ifdef CONFIG_INTEL_IOMMU
129         /* Look for Intel IOMMU */
130         nentries = (hdr->length - sizeof(*hdr)) /
131                          sizeof(xsdt->table_offset_entry[0]);
132         for (i = 0; i < nentries; i++) {
133                 hdr = __va(xsdt->table_offset_entry[i]);
134                 if (strncmp(hdr->signature, ACPI_SIG_DMAR,
135                         sizeof(ACPI_SIG_DMAR) - 1) == 0)
136                         return "dig_vtd";
137         }
138 #endif
139
140         return "dig";
141 }
142 #endif /* CONFIG_IA64_GENERIC */
143
144 #define ACPI_MAX_PLATFORM_INTERRUPTS    256
145
146 /* Array to record platform interrupt vectors for generic interrupt routing. */
147 int platform_intr_list[ACPI_MAX_PLATFORM_INTERRUPTS] = {
148         [0 ... ACPI_MAX_PLATFORM_INTERRUPTS - 1] = -1
149 };
150
151 enum acpi_irq_model_id acpi_irq_model = ACPI_IRQ_MODEL_IOSAPIC;
152
153 /*
154  * Interrupt routing API for device drivers.  Provides interrupt vector for
155  * a generic platform event.  Currently only CPEI is implemented.
156  */
157 int acpi_request_vector(u32 int_type)
158 {
159         int vector = -1;
160
161         if (int_type < ACPI_MAX_PLATFORM_INTERRUPTS) {
162                 /* corrected platform error interrupt */
163                 vector = platform_intr_list[int_type];
164         } else
165                 printk(KERN_ERR
166                        "acpi_request_vector(): invalid interrupt type\n");
167         return vector;
168 }
169
170 char *__init __acpi_map_table(unsigned long phys_addr, unsigned long size)
171 {
172         return __va(phys_addr);
173 }
174
175 void __init __acpi_unmap_table(char *map, unsigned long size)
176 {
177 }
178
179 /* --------------------------------------------------------------------------
180                             Boot-time Table Parsing
181    -------------------------------------------------------------------------- */
182
183 static int available_cpus __initdata;
184 struct acpi_table_madt *acpi_madt __initdata;
185 static u8 has_8259;
186
187 static int __init
188 acpi_parse_lapic_addr_ovr(struct acpi_subtable_header * header,
189                           const unsigned long end)
190 {
191         struct acpi_madt_local_apic_override *lapic;
192
193         lapic = (struct acpi_madt_local_apic_override *)header;
194
195         if (BAD_MADT_ENTRY(lapic, end))
196                 return -EINVAL;
197
198         if (lapic->address) {
199                 iounmap(ipi_base_addr);
200                 ipi_base_addr = ioremap(lapic->address, 0);
201         }
202         return 0;
203 }
204
205 static int __init
206 acpi_parse_lsapic(struct acpi_subtable_header * header, const unsigned long end)
207 {
208         struct acpi_madt_local_sapic *lsapic;
209
210         lsapic = (struct acpi_madt_local_sapic *)header;
211
212         /*Skip BAD_MADT_ENTRY check, as lsapic size could vary */
213
214         if (lsapic->lapic_flags & ACPI_MADT_ENABLED) {
215 #ifdef CONFIG_SMP
216                 smp_boot_data.cpu_phys_id[available_cpus] =
217                     (lsapic->id << 8) | lsapic->eid;
218 #endif
219                 ++available_cpus;
220         }
221
222         total_cpus++;
223         return 0;
224 }
225
226 static int __init
227 acpi_parse_lapic_nmi(struct acpi_subtable_header * header, const unsigned long end)
228 {
229         struct acpi_madt_local_apic_nmi *lacpi_nmi;
230
231         lacpi_nmi = (struct acpi_madt_local_apic_nmi *)header;
232
233         if (BAD_MADT_ENTRY(lacpi_nmi, end))
234                 return -EINVAL;
235
236         /* TBD: Support lapic_nmi entries */
237         return 0;
238 }
239
240 static int __init
241 acpi_parse_iosapic(struct acpi_subtable_header * header, const unsigned long end)
242 {
243         struct acpi_madt_io_sapic *iosapic;
244
245         iosapic = (struct acpi_madt_io_sapic *)header;
246
247         if (BAD_MADT_ENTRY(iosapic, end))
248                 return -EINVAL;
249
250         return iosapic_init(iosapic->address, iosapic->global_irq_base);
251 }
252
253 static unsigned int __initdata acpi_madt_rev;
254
255 static int __init
256 acpi_parse_plat_int_src(struct acpi_subtable_header * header,
257                         const unsigned long end)
258 {
259         struct acpi_madt_interrupt_source *plintsrc;
260         int vector;
261
262         plintsrc = (struct acpi_madt_interrupt_source *)header;
263
264         if (BAD_MADT_ENTRY(plintsrc, end))
265                 return -EINVAL;
266
267         /*
268          * Get vector assignment for this interrupt, set attributes,
269          * and program the IOSAPIC routing table.
270          */
271         vector = iosapic_register_platform_intr(plintsrc->type,
272                                                 plintsrc->global_irq,
273                                                 plintsrc->io_sapic_vector,
274                                                 plintsrc->eid,
275                                                 plintsrc->id,
276                                                 ((plintsrc->inti_flags & ACPI_MADT_POLARITY_MASK) ==
277                                                  ACPI_MADT_POLARITY_ACTIVE_HIGH) ?
278                                                 IOSAPIC_POL_HIGH : IOSAPIC_POL_LOW,
279                                                 ((plintsrc->inti_flags & ACPI_MADT_TRIGGER_MASK) ==
280                                                  ACPI_MADT_TRIGGER_EDGE) ?
281                                                 IOSAPIC_EDGE : IOSAPIC_LEVEL);
282
283         platform_intr_list[plintsrc->type] = vector;
284         if (acpi_madt_rev > 1) {
285                 acpi_cpei_override = plintsrc->flags & ACPI_MADT_CPEI_OVERRIDE;
286         }
287
288         /*
289          * Save the physical id, so we can check when its being removed
290          */
291         acpi_cpei_phys_cpuid = ((plintsrc->id << 8) | (plintsrc->eid)) & 0xffff;
292
293         return 0;
294 }
295
296 #ifdef CONFIG_HOTPLUG_CPU
297 unsigned int can_cpei_retarget(void)
298 {
299         extern int cpe_vector;
300         extern unsigned int force_cpei_retarget;
301
302         /*
303          * Only if CPEI is supported and the override flag
304          * is present, otherwise return that its re-targettable
305          * if we are in polling mode.
306          */
307         if (cpe_vector > 0) {
308                 if (acpi_cpei_override || force_cpei_retarget)
309                         return 1;
310                 else
311                         return 0;
312         }
313         return 1;
314 }
315
316 unsigned int is_cpu_cpei_target(unsigned int cpu)
317 {
318         unsigned int logical_id;
319
320         logical_id = cpu_logical_id(acpi_cpei_phys_cpuid);
321
322         if (logical_id == cpu)
323                 return 1;
324         else
325                 return 0;
326 }
327
328 void set_cpei_target_cpu(unsigned int cpu)
329 {
330         acpi_cpei_phys_cpuid = cpu_physical_id(cpu);
331 }
332 #endif
333
334 unsigned int get_cpei_target_cpu(void)
335 {
336         return acpi_cpei_phys_cpuid;
337 }
338
339 static int __init
340 acpi_parse_int_src_ovr(struct acpi_subtable_header * header,
341                        const unsigned long end)
342 {
343         struct acpi_madt_interrupt_override *p;
344
345         p = (struct acpi_madt_interrupt_override *)header;
346
347         if (BAD_MADT_ENTRY(p, end))
348                 return -EINVAL;
349
350         iosapic_override_isa_irq(p->source_irq, p->global_irq,
351                                  ((p->inti_flags & ACPI_MADT_POLARITY_MASK) ==
352                                   ACPI_MADT_POLARITY_ACTIVE_HIGH) ?
353                                  IOSAPIC_POL_HIGH : IOSAPIC_POL_LOW,
354                                  ((p->inti_flags & ACPI_MADT_TRIGGER_MASK) ==
355                                  ACPI_MADT_TRIGGER_EDGE) ?
356                                  IOSAPIC_EDGE : IOSAPIC_LEVEL);
357         return 0;
358 }
359
360 static int __init
361 acpi_parse_nmi_src(struct acpi_subtable_header * header, const unsigned long end)
362 {
363         struct acpi_madt_nmi_source *nmi_src;
364
365         nmi_src = (struct acpi_madt_nmi_source *)header;
366
367         if (BAD_MADT_ENTRY(nmi_src, end))
368                 return -EINVAL;
369
370         /* TBD: Support nimsrc entries */
371         return 0;
372 }
373
374 static void __init acpi_madt_oem_check(char *oem_id, char *oem_table_id)
375 {
376         if (!strncmp(oem_id, "IBM", 3) && (!strncmp(oem_table_id, "SERMOW", 6))) {
377
378                 /*
379                  * Unfortunately ITC_DRIFT is not yet part of the
380                  * official SAL spec, so the ITC_DRIFT bit is not
381                  * set by the BIOS on this hardware.
382                  */
383                 sal_platform_features |= IA64_SAL_PLATFORM_FEATURE_ITC_DRIFT;
384
385                 cyclone_setup();
386         }
387 }
388
389 static int __init acpi_parse_madt(struct acpi_table_header *table)
390 {
391         if (!table)
392                 return -EINVAL;
393
394         acpi_madt = (struct acpi_table_madt *)table;
395
396         acpi_madt_rev = acpi_madt->header.revision;
397
398         /* remember the value for reference after free_initmem() */
399 #ifdef CONFIG_ITANIUM
400         has_8259 = 1;           /* Firmware on old Itanium systems is broken */
401 #else
402         has_8259 = acpi_madt->flags & ACPI_MADT_PCAT_COMPAT;
403 #endif
404         iosapic_system_init(has_8259);
405
406         /* Get base address of IPI Message Block */
407
408         if (acpi_madt->address)
409                 ipi_base_addr = ioremap(acpi_madt->address, 0);
410
411         printk(KERN_INFO PREFIX "Local APIC address %p\n", ipi_base_addr);
412
413         acpi_madt_oem_check(acpi_madt->header.oem_id,
414                             acpi_madt->header.oem_table_id);
415
416         return 0;
417 }
418
419 #ifdef CONFIG_ACPI_NUMA
420
421 #undef SLIT_DEBUG
422
423 #define PXM_FLAG_LEN ((MAX_PXM_DOMAINS + 1)/32)
424
425 static int __initdata srat_num_cpus;    /* number of cpus */
426 static u32 __devinitdata pxm_flag[PXM_FLAG_LEN];
427 #define pxm_bit_set(bit)        (set_bit(bit,(void *)pxm_flag))
428 #define pxm_bit_test(bit)       (test_bit(bit,(void *)pxm_flag))
429 static struct acpi_table_slit __initdata *slit_table;
430 cpumask_t early_cpu_possible_map = CPU_MASK_NONE;
431
432 static int __init
433 get_processor_proximity_domain(struct acpi_srat_cpu_affinity *pa)
434 {
435         int pxm;
436
437         pxm = pa->proximity_domain_lo;
438         if (ia64_platform_is("sn2") || acpi_srat_revision >= 2)
439                 pxm += pa->proximity_domain_hi[0] << 8;
440         return pxm;
441 }
442
443 static int __init
444 get_memory_proximity_domain(struct acpi_srat_mem_affinity *ma)
445 {
446         int pxm;
447
448         pxm = ma->proximity_domain;
449         if (!ia64_platform_is("sn2") && acpi_srat_revision <= 1)
450                 pxm &= 0xff;
451
452         return pxm;
453 }
454
455 /*
456  * ACPI 2.0 SLIT (System Locality Information Table)
457  * http://devresource.hp.com/devresource/Docs/TechPapers/IA64/slit.pdf
458  */
459 void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
460 {
461         u32 len;
462
463         len = sizeof(struct acpi_table_header) + 8
464             + slit->locality_count * slit->locality_count;
465         if (slit->header.length != len) {
466                 printk(KERN_ERR
467                        "ACPI 2.0 SLIT: size mismatch: %d expected, %d actual\n",
468                        len, slit->header.length);
469                 return;
470         }
471         slit_table = slit;
472 }
473
474 void __init
475 acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa)
476 {
477         int pxm;
478
479         if (!(pa->flags & ACPI_SRAT_CPU_ENABLED))
480                 return;
481
482         if (srat_num_cpus >= ARRAY_SIZE(node_cpuid)) {
483                 printk_once(KERN_WARNING
484                             "node_cpuid[%ld] is too small, may not be able to use all cpus\n",
485                             ARRAY_SIZE(node_cpuid));
486                 return;
487         }
488         pxm = get_processor_proximity_domain(pa);
489
490         /* record this node in proximity bitmap */
491         pxm_bit_set(pxm);
492
493         node_cpuid[srat_num_cpus].phys_id =
494             (pa->apic_id << 8) | (pa->local_sapic_eid);
495         /* nid should be overridden as logical node id later */
496         node_cpuid[srat_num_cpus].nid = pxm;
497         cpu_set(srat_num_cpus, early_cpu_possible_map);
498         srat_num_cpus++;
499 }
500
501 void __init
502 acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
503 {
504         unsigned long paddr, size;
505         int pxm;
506         struct node_memblk_s *p, *q, *pend;
507
508         pxm = get_memory_proximity_domain(ma);
509
510         /* fill node memory chunk structure */
511         paddr = ma->base_address;
512         size = ma->length;
513
514         /* Ignore disabled entries */
515         if (!(ma->flags & ACPI_SRAT_MEM_ENABLED))
516                 return;
517
518         /* record this node in proximity bitmap */
519         pxm_bit_set(pxm);
520
521         /* Insertion sort based on base address */
522         pend = &node_memblk[num_node_memblks];
523         for (p = &node_memblk[0]; p < pend; p++) {
524                 if (paddr < p->start_paddr)
525                         break;
526         }
527         if (p < pend) {
528                 for (q = pend - 1; q >= p; q--)
529                         *(q + 1) = *q;
530         }
531         p->start_paddr = paddr;
532         p->size = size;
533         p->nid = pxm;
534         num_node_memblks++;
535 }
536
537 void __init acpi_numa_arch_fixup(void)
538 {
539         int i, j, node_from, node_to;
540
541         /* If there's no SRAT, fix the phys_id and mark node 0 online */
542         if (srat_num_cpus == 0) {
543                 node_set_online(0);
544                 node_cpuid[0].phys_id = hard_smp_processor_id();
545                 return;
546         }
547
548         /*
549          * MCD - This can probably be dropped now.  No need for pxm ID to node ID
550          * mapping with sparse node numbering iff MAX_PXM_DOMAINS <= MAX_NUMNODES.
551          */
552         nodes_clear(node_online_map);
553         for (i = 0; i < MAX_PXM_DOMAINS; i++) {
554                 if (pxm_bit_test(i)) {
555                         int nid = acpi_map_pxm_to_node(i);
556                         node_set_online(nid);
557                 }
558         }
559
560         /* set logical node id in memory chunk structure */
561         for (i = 0; i < num_node_memblks; i++)
562                 node_memblk[i].nid = pxm_to_node(node_memblk[i].nid);
563
564         /* assign memory bank numbers for each chunk on each node */
565         for_each_online_node(i) {
566                 int bank;
567
568                 bank = 0;
569                 for (j = 0; j < num_node_memblks; j++)
570                         if (node_memblk[j].nid == i)
571                                 node_memblk[j].bank = bank++;
572         }
573
574         /* set logical node id in cpu structure */
575         for_each_possible_early_cpu(i)
576                 node_cpuid[i].nid = pxm_to_node(node_cpuid[i].nid);
577
578         printk(KERN_INFO "Number of logical nodes in system = %d\n",
579                num_online_nodes());
580         printk(KERN_INFO "Number of memory chunks in system = %d\n",
581                num_node_memblks);
582
583         if (!slit_table) {
584                 for (i = 0; i < MAX_NUMNODES; i++)
585                         for (j = 0; j < MAX_NUMNODES; j++)
586                                 node_distance(i, j) = i == j ? LOCAL_DISTANCE :
587                                                         REMOTE_DISTANCE;
588                 return;
589         }
590
591         memset(numa_slit, -1, sizeof(numa_slit));
592         for (i = 0; i < slit_table->locality_count; i++) {
593                 if (!pxm_bit_test(i))
594                         continue;
595                 node_from = pxm_to_node(i);
596                 for (j = 0; j < slit_table->locality_count; j++) {
597                         if (!pxm_bit_test(j))
598                                 continue;
599                         node_to = pxm_to_node(j);
600                         node_distance(node_from, node_to) =
601                             slit_table->entry[i * slit_table->locality_count + j];
602                 }
603         }
604
605 #ifdef SLIT_DEBUG
606         printk("ACPI 2.0 SLIT locality table:\n");
607         for_each_online_node(i) {
608                 for_each_online_node(j)
609                     printk("%03d ", node_distance(i, j));
610                 printk("\n");
611         }
612 #endif
613 }
614 #endif                          /* CONFIG_ACPI_NUMA */
615
616 /*
617  * success: return IRQ number (>=0)
618  * failure: return < 0
619  */
620 int acpi_register_gsi(struct device *dev, u32 gsi, int triggering, int polarity)
621 {
622         if (acpi_irq_model == ACPI_IRQ_MODEL_PLATFORM)
623                 return gsi;
624
625         if (has_8259 && gsi < 16)
626                 return isa_irq_to_vector(gsi);
627
628         return iosapic_register_intr(gsi,
629                                      (polarity ==
630                                       ACPI_ACTIVE_HIGH) ? IOSAPIC_POL_HIGH :
631                                      IOSAPIC_POL_LOW,
632                                      (triggering ==
633                                       ACPI_EDGE_SENSITIVE) ? IOSAPIC_EDGE :
634                                      IOSAPIC_LEVEL);
635 }
636
637 void acpi_unregister_gsi(u32 gsi)
638 {
639         if (acpi_irq_model == ACPI_IRQ_MODEL_PLATFORM)
640                 return;
641
642         if (has_8259 && gsi < 16)
643                 return;
644
645         iosapic_unregister_intr(gsi);
646 }
647
648 static int __init acpi_parse_fadt(struct acpi_table_header *table)
649 {
650         struct acpi_table_header *fadt_header;
651         struct acpi_table_fadt *fadt;
652
653         if (!table)
654                 return -EINVAL;
655
656         fadt_header = (struct acpi_table_header *)table;
657         if (fadt_header->revision != 3)
658                 return -ENODEV; /* Only deal with ACPI 2.0 FADT */
659
660         fadt = (struct acpi_table_fadt *)fadt_header;
661
662         acpi_register_gsi(NULL, fadt->sci_interrupt, ACPI_LEVEL_SENSITIVE,
663                                  ACPI_ACTIVE_LOW);
664         return 0;
665 }
666
667 int __init early_acpi_boot_init(void)
668 {
669         int ret;
670
671         /*
672          * do a partial walk of MADT to determine how many CPUs
673          * we have including offline CPUs
674          */
675         if (acpi_table_parse(ACPI_SIG_MADT, acpi_parse_madt)) {
676                 printk(KERN_ERR PREFIX "Can't find MADT\n");
677                 return 0;
678         }
679
680         ret = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_SAPIC,
681                 acpi_parse_lsapic, NR_CPUS);
682         if (ret < 1)
683                 printk(KERN_ERR PREFIX
684                        "Error parsing MADT - no LAPIC entries\n");
685
686 #ifdef CONFIG_SMP
687         if (available_cpus == 0) {
688                 printk(KERN_INFO "ACPI: Found 0 CPUS; assuming 1\n");
689                 printk(KERN_INFO "CPU 0 (0x%04x)", hard_smp_processor_id());
690                 smp_boot_data.cpu_phys_id[available_cpus] =
691                     hard_smp_processor_id();
692                 available_cpus = 1;     /* We've got at least one of these, no? */
693         }
694         smp_boot_data.cpu_count = available_cpus;
695 #endif
696         /* Make boot-up look pretty */
697         printk(KERN_INFO "%d CPUs available, %d CPUs total\n", available_cpus,
698                total_cpus);
699
700         return 0;
701 }
702
703 int __init acpi_boot_init(void)
704 {
705
706         /*
707          * MADT
708          * ----
709          * Parse the Multiple APIC Description Table (MADT), if exists.
710          * Note that this table provides platform SMP configuration
711          * information -- the successor to MPS tables.
712          */
713
714         if (acpi_table_parse(ACPI_SIG_MADT, acpi_parse_madt)) {
715                 printk(KERN_ERR PREFIX "Can't find MADT\n");
716                 goto skip_madt;
717         }
718
719         /* Local APIC */
720
721         if (acpi_table_parse_madt
722             (ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE, acpi_parse_lapic_addr_ovr, 0) < 0)
723                 printk(KERN_ERR PREFIX
724                        "Error parsing LAPIC address override entry\n");
725
726         if (acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_NMI, acpi_parse_lapic_nmi, 0)
727             < 0)
728                 printk(KERN_ERR PREFIX "Error parsing LAPIC NMI entry\n");
729
730         /* I/O APIC */
731
732         if (acpi_table_parse_madt
733             (ACPI_MADT_TYPE_IO_SAPIC, acpi_parse_iosapic, NR_IOSAPICS) < 1) {
734                 if (!ia64_platform_is("sn2"))
735                         printk(KERN_ERR PREFIX
736                                "Error parsing MADT - no IOSAPIC entries\n");
737         }
738
739         /* System-Level Interrupt Routing */
740
741         if (acpi_table_parse_madt
742             (ACPI_MADT_TYPE_INTERRUPT_SOURCE, acpi_parse_plat_int_src,
743              ACPI_MAX_PLATFORM_INTERRUPTS) < 0)
744                 printk(KERN_ERR PREFIX
745                        "Error parsing platform interrupt source entry\n");
746
747         if (acpi_table_parse_madt
748             (ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, acpi_parse_int_src_ovr, 0) < 0)
749                 printk(KERN_ERR PREFIX
750                        "Error parsing interrupt source overrides entry\n");
751
752         if (acpi_table_parse_madt(ACPI_MADT_TYPE_NMI_SOURCE, acpi_parse_nmi_src, 0) < 0)
753                 printk(KERN_ERR PREFIX "Error parsing NMI SRC entry\n");
754       skip_madt:
755
756         /*
757          * FADT says whether a legacy keyboard controller is present.
758          * The FADT also contains an SCI_INT line, by which the system
759          * gets interrupts such as power and sleep buttons.  If it's not
760          * on a Legacy interrupt, it needs to be setup.
761          */
762         if (acpi_table_parse(ACPI_SIG_FADT, acpi_parse_fadt))
763                 printk(KERN_ERR PREFIX "Can't find FADT\n");
764
765 #ifdef CONFIG_ACPI_NUMA
766 #ifdef CONFIG_SMP
767         if (srat_num_cpus == 0) {
768                 int cpu, i = 1;
769                 for (cpu = 0; cpu < smp_boot_data.cpu_count; cpu++)
770                         if (smp_boot_data.cpu_phys_id[cpu] !=
771                             hard_smp_processor_id())
772                                 node_cpuid[i++].phys_id =
773                                     smp_boot_data.cpu_phys_id[cpu];
774         }
775 #endif
776         build_cpu_to_node_map();
777 #endif
778         return 0;
779 }
780
781 int acpi_gsi_to_irq(u32 gsi, unsigned int *irq)
782 {
783         int tmp;
784
785         if (has_8259 && gsi < 16)
786                 *irq = isa_irq_to_vector(gsi);
787         else {
788                 tmp = gsi_to_irq(gsi);
789                 if (tmp == -1)
790                         return -1;
791                 *irq = tmp;
792         }
793         return 0;
794 }
795
796 int acpi_isa_irq_to_gsi(unsigned isa_irq, u32 *gsi)
797 {
798         if (isa_irq >= 16)
799                 return -1;
800         *gsi = isa_irq;
801         return 0;
802 }
803
804 /*
805  *  ACPI based hotplug CPU support
806  */
807 #ifdef CONFIG_ACPI_HOTPLUG_CPU
808 static __cpuinit
809 int acpi_map_cpu2node(acpi_handle handle, int cpu, int physid)
810 {
811 #ifdef CONFIG_ACPI_NUMA
812         int pxm_id;
813         int nid;
814
815         pxm_id = acpi_get_pxm(handle);
816         /*
817          * We don't have cpu-only-node hotadd. But if the system equips
818          * SRAT table, pxm is already found and node is ready.
819          * So, just pxm_to_nid(pxm) is OK.
820          * This code here is for the system which doesn't have full SRAT
821          * table for possible cpus.
822          */
823         nid = acpi_map_pxm_to_node(pxm_id);
824         node_cpuid[cpu].phys_id = physid;
825         node_cpuid[cpu].nid = nid;
826 #endif
827         return (0);
828 }
829
830 int additional_cpus __initdata = -1;
831
832 static __init int setup_additional_cpus(char *s)
833 {
834         if (s)
835                 additional_cpus = simple_strtol(s, NULL, 0);
836
837         return 0;
838 }
839
840 early_param("additional_cpus", setup_additional_cpus);
841
842 /*
843  * cpu_possible_map should be static, it cannot change as CPUs
844  * are onlined, or offlined. The reason is per-cpu data-structures
845  * are allocated by some modules at init time, and dont expect to
846  * do this dynamically on cpu arrival/departure.
847  * cpu_present_map on the other hand can change dynamically.
848  * In case when cpu_hotplug is not compiled, then we resort to current
849  * behaviour, which is cpu_possible == cpu_present.
850  * - Ashok Raj
851  *
852  * Three ways to find out the number of additional hotplug CPUs:
853  * - If the BIOS specified disabled CPUs in ACPI/mptables use that.
854  * - The user can overwrite it with additional_cpus=NUM
855  * - Otherwise don't reserve additional CPUs.
856  */
857 __init void prefill_possible_map(void)
858 {
859         int i;
860         int possible, disabled_cpus;
861
862         disabled_cpus = total_cpus - available_cpus;
863
864         if (additional_cpus == -1) {
865                 if (disabled_cpus > 0)
866                         additional_cpus = disabled_cpus;
867                 else
868                         additional_cpus = 0;
869         }
870
871         possible = available_cpus + additional_cpus;
872
873         if (possible > nr_cpu_ids)
874                 possible = nr_cpu_ids;
875
876         printk(KERN_INFO "SMP: Allowing %d CPUs, %d hotplug CPUs\n",
877                 possible, max((possible - available_cpus), 0));
878
879         for (i = 0; i < possible; i++)
880                 set_cpu_possible(i, true);
881 }
882
883 static int __cpuinit _acpi_map_lsapic(acpi_handle handle, int *pcpu)
884 {
885         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
886         union acpi_object *obj;
887         struct acpi_madt_local_sapic *lsapic;
888         cpumask_t tmp_map;
889         int cpu, physid;
890
891         if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
892                 return -EINVAL;
893
894         if (!buffer.length || !buffer.pointer)
895                 return -EINVAL;
896
897         obj = buffer.pointer;
898         if (obj->type != ACPI_TYPE_BUFFER)
899         {
900                 kfree(buffer.pointer);
901                 return -EINVAL;
902         }
903
904         lsapic = (struct acpi_madt_local_sapic *)obj->buffer.pointer;
905
906         if ((lsapic->header.type != ACPI_MADT_TYPE_LOCAL_SAPIC) ||
907             (!(lsapic->lapic_flags & ACPI_MADT_ENABLED))) {
908                 kfree(buffer.pointer);
909                 return -EINVAL;
910         }
911
912         physid = ((lsapic->id << 8) | (lsapic->eid));
913
914         kfree(buffer.pointer);
915         buffer.length = ACPI_ALLOCATE_BUFFER;
916         buffer.pointer = NULL;
917
918         cpumask_complement(&tmp_map, cpu_present_mask);
919         cpu = cpumask_first(&tmp_map);
920         if (cpu >= nr_cpu_ids)
921                 return -EINVAL;
922
923         acpi_map_cpu2node(handle, cpu, physid);
924
925         cpu_set(cpu, cpu_present_map);
926         ia64_cpu_to_sapicid[cpu] = physid;
927
928         acpi_processor_set_pdc(handle);
929
930         *pcpu = cpu;
931         return (0);
932 }
933
934 /* wrapper to silence section mismatch warning */
935 int __ref acpi_map_lsapic(acpi_handle handle, int *pcpu)
936 {
937         return _acpi_map_lsapic(handle, pcpu);
938 }
939 EXPORT_SYMBOL(acpi_map_lsapic);
940
941 int acpi_unmap_lsapic(int cpu)
942 {
943         ia64_cpu_to_sapicid[cpu] = -1;
944         cpu_clear(cpu, cpu_present_map);
945
946 #ifdef CONFIG_ACPI_NUMA
947         /* NUMA specific cleanup's */
948 #endif
949
950         return (0);
951 }
952
953 EXPORT_SYMBOL(acpi_unmap_lsapic);
954 #endif                          /* CONFIG_ACPI_HOTPLUG_CPU */
955
956 #ifdef CONFIG_ACPI_NUMA
957 static acpi_status __devinit
958 acpi_map_iosapic(acpi_handle handle, u32 depth, void *context, void **ret)
959 {
960         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
961         union acpi_object *obj;
962         struct acpi_madt_io_sapic *iosapic;
963         unsigned int gsi_base;
964         int pxm, node;
965
966         /* Only care about objects w/ a method that returns the MADT */
967         if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
968                 return AE_OK;
969
970         if (!buffer.length || !buffer.pointer)
971                 return AE_OK;
972
973         obj = buffer.pointer;
974         if (obj->type != ACPI_TYPE_BUFFER ||
975             obj->buffer.length < sizeof(*iosapic)) {
976                 kfree(buffer.pointer);
977                 return AE_OK;
978         }
979
980         iosapic = (struct acpi_madt_io_sapic *)obj->buffer.pointer;
981
982         if (iosapic->header.type != ACPI_MADT_TYPE_IO_SAPIC) {
983                 kfree(buffer.pointer);
984                 return AE_OK;
985         }
986
987         gsi_base = iosapic->global_irq_base;
988
989         kfree(buffer.pointer);
990
991         /*
992          * OK, it's an IOSAPIC MADT entry, look for a _PXM value to tell
993          * us which node to associate this with.
994          */
995         pxm = acpi_get_pxm(handle);
996         if (pxm < 0)
997                 return AE_OK;
998
999         node = pxm_to_node(pxm);
1000
1001         if (node >= MAX_NUMNODES || !node_online(node) ||
1002             cpumask_empty(cpumask_of_node(node)))
1003                 return AE_OK;
1004
1005         /* We know a gsi to node mapping! */
1006         map_iosapic_to_node(gsi_base, node);
1007         return AE_OK;
1008 }
1009
1010 static int __init
1011 acpi_map_iosapics (void)
1012 {
1013         acpi_get_devices(NULL, acpi_map_iosapic, NULL, NULL);
1014         return 0;
1015 }
1016
1017 fs_initcall(acpi_map_iosapics);
1018 #endif                          /* CONFIG_ACPI_NUMA */
1019
1020 int __ref acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base)
1021 {
1022         int err;
1023
1024         if ((err = iosapic_init(phys_addr, gsi_base)))
1025                 return err;
1026
1027 #ifdef CONFIG_ACPI_NUMA
1028         acpi_map_iosapic(handle, 0, NULL, NULL);
1029 #endif                          /* CONFIG_ACPI_NUMA */
1030
1031         return 0;
1032 }
1033
1034 EXPORT_SYMBOL(acpi_register_ioapic);
1035
1036 int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base)
1037 {
1038         return iosapic_remove(gsi_base);
1039 }
1040
1041 EXPORT_SYMBOL(acpi_unregister_ioapic);
1042
1043 /*
1044  * acpi_suspend_lowlevel() - save kernel state and suspend.
1045  *
1046  * TBD when when IA64 starts to support suspend...
1047  */
1048 int acpi_suspend_lowlevel(void) { return 0; }