acpi.c 24.4 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 *  acpi.c - Architecture-Specific Low-Level ACPI Support
 *
 *  Copyright (C) 1999 VA Linux Systems
 *  Copyright (C) 1999,2000 Walt Drummond <drummond@valinux.com>
 *  Copyright (C) 2000, 2002-2003 Hewlett-Packard Co.
 *	David Mosberger-Tang <davidm@hpl.hp.com>
 *  Copyright (C) 2000 Intel Corp.
 *  Copyright (C) 2000,2001 J.I. Lee <jung-ik.lee@intel.com>
 *  Copyright (C) 2001 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 *  Copyright (C) 2001 Jenna Hall <jenna.s.hall@intel.com>
 *  Copyright (C) 2001 Takayoshi Kochi <t-kochi@bq.jp.nec.com>
 *  Copyright (C) 2002 Erich Focht <efocht@ess.nec.de>
14
 *  Copyright (C) 2004 Ashok Raj <ashok.raj@intel.com>
Linus Torvalds's avatar
Linus Torvalds committed
15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#include <linux/config.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/smp.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/irq.h>
#include <linux/acpi.h>
#include <linux/efi.h>
#include <linux/mmzone.h>
#include <linux/nodemask.h>
#include <asm/io.h>
#include <asm/iosapic.h>
#include <asm/machvec.h>
#include <asm/page.h>
#include <asm/system.h>
#include <asm/numa.h>
#include <asm/sal.h>
#include <asm/cyclone.h>

#define BAD_MADT_ENTRY(entry, end) (                                        \
		(!entry) || (unsigned long)entry + sizeof(*entry) > end ||  \
		((acpi_table_entry_header *)entry)->length != sizeof(*entry))

#define PREFIX			"ACPI: "

void (*pm_idle) (void);
EXPORT_SYMBOL(pm_idle);
void (*pm_power_off) (void);
EXPORT_SYMBOL(pm_power_off);

unsigned char acpi_kbd_controller_present = 1;
unsigned char acpi_legacy_devices;

71 72 73 74 75
static unsigned int __initdata acpi_madt_rev;

unsigned int acpi_cpei_override;
unsigned int acpi_cpei_phys_cpuid;

Linus Torvalds's avatar
Linus Torvalds committed
76
#define MAX_SAPICS 256
77
u16 ia64_acpiid_to_sapicid[MAX_SAPICS] = {[0 ... MAX_SAPICS - 1] = -1 };
Len Brown's avatar
Len Brown committed
78

Linus Torvalds's avatar
Linus Torvalds committed
79 80
EXPORT_SYMBOL(ia64_acpiid_to_sapicid);

Len Brown's avatar
Len Brown committed
81
const char *acpi_get_sysname(void)
Linus Torvalds's avatar
Linus Torvalds committed
82 83 84 85 86 87 88 89 90
{
#ifdef CONFIG_IA64_GENERIC
	unsigned long rsdp_phys;
	struct acpi20_table_rsdp *rsdp;
	struct acpi_table_xsdt *xsdt;
	struct acpi_table_header *hdr;

	rsdp_phys = acpi_find_rsdp();
	if (!rsdp_phys) {
Len Brown's avatar
Len Brown committed
91 92
		printk(KERN_ERR
		       "ACPI 2.0 RSDP not found, default to \"dig\"\n");
Linus Torvalds's avatar
Linus Torvalds committed
93 94 95
		return "dig";
	}

Len Brown's avatar
Len Brown committed
96
	rsdp = (struct acpi20_table_rsdp *)__va(rsdp_phys);
Linus Torvalds's avatar
Linus Torvalds committed
97
	if (strncmp(rsdp->signature, RSDP_SIG, sizeof(RSDP_SIG) - 1)) {
Len Brown's avatar
Len Brown committed
98 99
		printk(KERN_ERR
		       "ACPI 2.0 RSDP signature incorrect, default to \"dig\"\n");
Linus Torvalds's avatar
Linus Torvalds committed
100 101 102
		return "dig";
	}

Len Brown's avatar
Len Brown committed
103
	xsdt = (struct acpi_table_xsdt *)__va(rsdp->xsdt_address);
Linus Torvalds's avatar
Linus Torvalds committed
104 105
	hdr = &xsdt->header;
	if (strncmp(hdr->signature, XSDT_SIG, sizeof(XSDT_SIG) - 1)) {
Len Brown's avatar
Len Brown committed
106 107
		printk(KERN_ERR
		       "ACPI 2.0 XSDT signature incorrect, default to \"dig\"\n");
Linus Torvalds's avatar
Linus Torvalds committed
108 109 110 111 112
		return "dig";
	}

	if (!strcmp(hdr->oem_id, "HP")) {
		return "hpzx1";
Len Brown's avatar
Len Brown committed
113
	} else if (!strcmp(hdr->oem_id, "SGI")) {
Linus Torvalds's avatar
Linus Torvalds committed
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
		return "sn2";
	}

	return "dig";
#else
# if defined (CONFIG_IA64_HP_SIM)
	return "hpsim";
# elif defined (CONFIG_IA64_HP_ZX1)
	return "hpzx1";
# elif defined (CONFIG_IA64_HP_ZX1_SWIOTLB)
	return "hpzx1_swiotlb";
# elif defined (CONFIG_IA64_SGI_SN2)
	return "sn2";
# elif defined (CONFIG_IA64_DIG)
	return "dig";
# else
#	error Unknown platform.  Fix acpi.c.
# endif
#endif
}

Len Brown's avatar
Len Brown committed
135
#ifdef CONFIG_ACPI
Linus Torvalds's avatar
Linus Torvalds committed
136 137 138 139 140 141 142 143 144 145 146 147 148 149

#define ACPI_MAX_PLATFORM_INTERRUPTS	256

/* Array to record platform interrupt vectors for generic interrupt routing. */
int platform_intr_list[ACPI_MAX_PLATFORM_INTERRUPTS] = {
	[0 ... ACPI_MAX_PLATFORM_INTERRUPTS - 1] = -1
};

enum acpi_irq_model_id acpi_irq_model = ACPI_IRQ_MODEL_IOSAPIC;

/*
 * Interrupt routing API for device drivers.  Provides interrupt vector for
 * a generic platform event.  Currently only CPEI is implemented.
 */
Len Brown's avatar
Len Brown committed
150
int acpi_request_vector(u32 int_type)
Linus Torvalds's avatar
Linus Torvalds committed
151 152 153 154 155 156 157
{
	int vector = -1;

	if (int_type < ACPI_MAX_PLATFORM_INTERRUPTS) {
		/* corrected platform error interrupt */
		vector = platform_intr_list[int_type];
	} else
Len Brown's avatar
Len Brown committed
158 159
		printk(KERN_ERR
		       "acpi_request_vector(): invalid interrupt type\n");
Linus Torvalds's avatar
Linus Torvalds committed
160 161 162
	return vector;
}

Len Brown's avatar
Len Brown committed
163
char *__acpi_map_table(unsigned long phys_addr, unsigned long size)
Linus Torvalds's avatar
Linus Torvalds committed
164 165 166 167 168 169 170 171
{
	return __va(phys_addr);
}

/* --------------------------------------------------------------------------
                            Boot-time Table Parsing
   -------------------------------------------------------------------------- */

Len Brown's avatar
Len Brown committed
172 173 174 175
static int total_cpus __initdata;
static int available_cpus __initdata;
struct acpi_table_madt *acpi_madt __initdata;
static u8 has_8259;
Linus Torvalds's avatar
Linus Torvalds committed
176 177

static int __init
Len Brown's avatar
Len Brown committed
178 179
acpi_parse_lapic_addr_ovr(acpi_table_entry_header * header,
			  const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
180 181 182
{
	struct acpi_table_lapic_addr_ovr *lapic;

Len Brown's avatar
Len Brown committed
183
	lapic = (struct acpi_table_lapic_addr_ovr *)header;
Linus Torvalds's avatar
Linus Torvalds committed
184 185 186 187 188 189 190 191 192 193 194 195

	if (BAD_MADT_ENTRY(lapic, end))
		return -EINVAL;

	if (lapic->address) {
		iounmap(ipi_base_addr);
		ipi_base_addr = ioremap(lapic->address, 0);
	}
	return 0;
}

static int __init
Len Brown's avatar
Len Brown committed
196
acpi_parse_lsapic(acpi_table_entry_header * header, const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
197 198 199
{
	struct acpi_table_lsapic *lsapic;

Len Brown's avatar
Len Brown committed
200
	lsapic = (struct acpi_table_lsapic *)header;
Linus Torvalds's avatar
Linus Torvalds committed
201 202 203 204 205 206

	if (BAD_MADT_ENTRY(lsapic, end))
		return -EINVAL;

	if (lsapic->flags.enabled) {
#ifdef CONFIG_SMP
Len Brown's avatar
Len Brown committed
207 208
		smp_boot_data.cpu_phys_id[available_cpus] =
		    (lsapic->id << 8) | lsapic->eid;
Linus Torvalds's avatar
Linus Torvalds committed
209
#endif
Len Brown's avatar
Len Brown committed
210 211
		ia64_acpiid_to_sapicid[lsapic->acpi_id] =
		    (lsapic->id << 8) | lsapic->eid;
Linus Torvalds's avatar
Linus Torvalds committed
212 213 214 215 216 217 218 219
		++available_cpus;
	}

	total_cpus++;
	return 0;
}

static int __init
Len Brown's avatar
Len Brown committed
220
acpi_parse_lapic_nmi(acpi_table_entry_header * header, const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
221 222 223
{
	struct acpi_table_lapic_nmi *lacpi_nmi;

Len Brown's avatar
Len Brown committed
224
	lacpi_nmi = (struct acpi_table_lapic_nmi *)header;
Linus Torvalds's avatar
Linus Torvalds committed
225 226 227 228 229 230 231 232 233

	if (BAD_MADT_ENTRY(lacpi_nmi, end))
		return -EINVAL;

	/* TBD: Support lapic_nmi entries */
	return 0;
}

static int __init
Len Brown's avatar
Len Brown committed
234
acpi_parse_iosapic(acpi_table_entry_header * header, const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
235 236 237
{
	struct acpi_table_iosapic *iosapic;

Len Brown's avatar
Len Brown committed
238
	iosapic = (struct acpi_table_iosapic *)header;
Linus Torvalds's avatar
Linus Torvalds committed
239 240 241 242

	if (BAD_MADT_ENTRY(iosapic, end))
		return -EINVAL;

243
	return iosapic_init(iosapic->address, iosapic->global_irq_base);
Linus Torvalds's avatar
Linus Torvalds committed
244 245 246
}

static int __init
Len Brown's avatar
Len Brown committed
247 248
acpi_parse_plat_int_src(acpi_table_entry_header * header,
			const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
249 250 251 252
{
	struct acpi_table_plat_int_src *plintsrc;
	int vector;

Len Brown's avatar
Len Brown committed
253
	plintsrc = (struct acpi_table_plat_int_src *)header;
Linus Torvalds's avatar
Linus Torvalds committed
254 255 256 257 258 259 260 261 262 263 264 265 266

	if (BAD_MADT_ENTRY(plintsrc, end))
		return -EINVAL;

	/*
	 * Get vector assignment for this interrupt, set attributes,
	 * and program the IOSAPIC routing table.
	 */
	vector = iosapic_register_platform_intr(plintsrc->type,
						plintsrc->global_irq,
						plintsrc->iosapic_vector,
						plintsrc->eid,
						plintsrc->id,
Len Brown's avatar
Len Brown committed
267 268 269 270 271 272
						(plintsrc->flags.polarity ==
						 1) ? IOSAPIC_POL_HIGH :
						IOSAPIC_POL_LOW,
						(plintsrc->flags.trigger ==
						 1) ? IOSAPIC_EDGE :
						IOSAPIC_LEVEL);
Linus Torvalds's avatar
Linus Torvalds committed
273 274

	platform_intr_list[plintsrc->type] = vector;
275 276 277 278 279 280 281 282 283
	if (acpi_madt_rev > 1) {
		acpi_cpei_override = plintsrc->plint_flags.cpei_override_flag;
	}

	/*
	 * Save the physical id, so we can check when its being removed
	 */
	acpi_cpei_phys_cpuid = ((plintsrc->id << 8) | (plintsrc->eid)) & 0xffff;

Linus Torvalds's avatar
Linus Torvalds committed
284 285 286
	return 0;
}

287
#ifdef CONFIG_HOTPLUG_CPU
288 289 290
unsigned int can_cpei_retarget(void)
{
	extern int cpe_vector;
Ashok Raj's avatar
Ashok Raj committed
291
	extern unsigned int force_cpei_retarget;
292 293 294 295 296 297

	/*
	 * Only if CPEI is supported and the override flag
	 * is present, otherwise return that its re-targettable
	 * if we are in polling mode.
	 */
Ashok Raj's avatar
Ashok Raj committed
298 299 300 301 302 303 304
	if (cpe_vector > 0) {
		if (acpi_cpei_override || force_cpei_retarget)
			return 1;
		else
			return 0;
	}
	return 1;
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
}

unsigned int is_cpu_cpei_target(unsigned int cpu)
{
	unsigned int logical_id;

	logical_id = cpu_logical_id(acpi_cpei_phys_cpuid);

	if (logical_id == cpu)
		return 1;
	else
		return 0;
}

void set_cpei_target_cpu(unsigned int cpu)
{
	acpi_cpei_phys_cpuid = cpu_physical_id(cpu);
}
323
#endif
324 325 326 327 328 329

unsigned int get_cpei_target_cpu(void)
{
	return acpi_cpei_phys_cpuid;
}

Linus Torvalds's avatar
Linus Torvalds committed
330
static int __init
Len Brown's avatar
Len Brown committed
331 332
acpi_parse_int_src_ovr(acpi_table_entry_header * header,
		       const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
333 334 335
{
	struct acpi_table_int_src_ovr *p;

Len Brown's avatar
Len Brown committed
336
	p = (struct acpi_table_int_src_ovr *)header;
Linus Torvalds's avatar
Linus Torvalds committed
337 338 339 340 341

	if (BAD_MADT_ENTRY(p, end))
		return -EINVAL;

	iosapic_override_isa_irq(p->bus_irq, p->global_irq,
Len Brown's avatar
Len Brown committed
342 343 344 345
				 (p->flags.polarity ==
				  1) ? IOSAPIC_POL_HIGH : IOSAPIC_POL_LOW,
				 (p->flags.trigger ==
				  1) ? IOSAPIC_EDGE : IOSAPIC_LEVEL);
Linus Torvalds's avatar
Linus Torvalds committed
346 347 348 349
	return 0;
}

static int __init
Len Brown's avatar
Len Brown committed
350
acpi_parse_nmi_src(acpi_table_entry_header * header, const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
351 352 353
{
	struct acpi_table_nmi_src *nmi_src;

Len Brown's avatar
Len Brown committed
354
	nmi_src = (struct acpi_table_nmi_src *)header;
Linus Torvalds's avatar
Linus Torvalds committed
355 356 357 358 359 360 361 362

	if (BAD_MADT_ENTRY(nmi_src, end))
		return -EINVAL;

	/* TBD: Support nimsrc entries */
	return 0;
}

Len Brown's avatar
Len Brown committed
363
static void __init acpi_madt_oem_check(char *oem_id, char *oem_table_id)
Linus Torvalds's avatar
Linus Torvalds committed
364
{
Len Brown's avatar
Len Brown committed
365
	if (!strncmp(oem_id, "IBM", 3) && (!strncmp(oem_table_id, "SERMOW", 6))) {
Linus Torvalds's avatar
Linus Torvalds committed
366 367 368 369 370 371 372 373 374 375 376 377

		/*
		 * Unfortunately ITC_DRIFT is not yet part of the
		 * official SAL spec, so the ITC_DRIFT bit is not
		 * set by the BIOS on this hardware.
		 */
		sal_platform_features |= IA64_SAL_PLATFORM_FEATURE_ITC_DRIFT;

		cyclone_setup();
	}
}

Len Brown's avatar
Len Brown committed
378
static int __init acpi_parse_madt(unsigned long phys_addr, unsigned long size)
Linus Torvalds's avatar
Linus Torvalds committed
379 380 381 382
{
	if (!phys_addr || !size)
		return -EINVAL;

Len Brown's avatar
Len Brown committed
383
	acpi_madt = (struct acpi_table_madt *)__va(phys_addr);
Linus Torvalds's avatar
Linus Torvalds committed
384

385 386
	acpi_madt_rev = acpi_madt->header.revision;

Linus Torvalds's avatar
Linus Torvalds committed
387 388
	/* remember the value for reference after free_initmem() */
#ifdef CONFIG_ITANIUM
Len Brown's avatar
Len Brown committed
389
	has_8259 = 1;		/* Firmware on old Itanium systems is broken */
Linus Torvalds's avatar
Linus Torvalds committed
390 391 392 393 394 395 396 397 398 399 400 401 402
#else
	has_8259 = acpi_madt->flags.pcat_compat;
#endif
	iosapic_system_init(has_8259);

	/* Get base address of IPI Message Block */

	if (acpi_madt->lapic_address)
		ipi_base_addr = ioremap(acpi_madt->lapic_address, 0);

	printk(KERN_INFO PREFIX "Local APIC address %p\n", ipi_base_addr);

	acpi_madt_oem_check(acpi_madt->header.oem_id,
Len Brown's avatar
Len Brown committed
403
			    acpi_madt->header.oem_table_id);
Linus Torvalds's avatar
Linus Torvalds committed
404 405 406 407 408 409 410 411 412 413

	return 0;
}

#ifdef CONFIG_ACPI_NUMA

#undef SLIT_DEBUG

#define PXM_FLAG_LEN ((MAX_PXM_DOMAINS + 1)/32)

Len Brown's avatar
Len Brown committed
414
static int __initdata srat_num_cpus;	/* number of cpus */
Linus Torvalds's avatar
Linus Torvalds committed
415 416 417 418 419 420 421 422 423 424 425 426
static u32 __devinitdata pxm_flag[PXM_FLAG_LEN];
#define pxm_bit_set(bit)	(set_bit(bit,(void *)pxm_flag))
#define pxm_bit_test(bit)	(test_bit(bit,(void *)pxm_flag))
/* maps to convert between proximity domain and logical node ID */
int __devinitdata pxm_to_nid_map[MAX_PXM_DOMAINS];
int __initdata nid_to_pxm_map[MAX_NUMNODES];
static struct acpi_table_slit __initdata *slit_table;

/*
 * ACPI 2.0 SLIT (System Locality Information Table)
 * http://devresource.hp.com/devresource/Docs/TechPapers/IA64/slit.pdf
 */
Len Brown's avatar
Len Brown committed
427
void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
Linus Torvalds's avatar
Linus Torvalds committed
428 429 430 431
{
	u32 len;

	len = sizeof(struct acpi_table_header) + 8
Len Brown's avatar
Len Brown committed
432
	    + slit->localities * slit->localities;
Linus Torvalds's avatar
Linus Torvalds committed
433
	if (slit->header.length != len) {
Len Brown's avatar
Len Brown committed
434 435
		printk(KERN_ERR
		       "ACPI 2.0 SLIT: size mismatch: %d expected, %d actual\n",
Linus Torvalds's avatar
Linus Torvalds committed
436 437 438 439 440 441 442 443
		       len, slit->header.length);
		memset(numa_slit, 10, sizeof(numa_slit));
		return;
	}
	slit_table = slit;
}

void __init
Len Brown's avatar
Len Brown committed
444
acpi_numa_processor_affinity_init(struct acpi_table_processor_affinity *pa)
Linus Torvalds's avatar
Linus Torvalds committed
445
{
446 447 448
	if (!pa->flags.enabled)
		return;

Linus Torvalds's avatar
Linus Torvalds committed
449 450 451
	/* record this node in proximity bitmap */
	pxm_bit_set(pa->proximity_domain);

Len Brown's avatar
Len Brown committed
452 453
	node_cpuid[srat_num_cpus].phys_id =
	    (pa->apic_id << 8) | (pa->lsapic_eid);
Linus Torvalds's avatar
Linus Torvalds committed
454 455 456 457 458 459
	/* nid should be overridden as logical node id later */
	node_cpuid[srat_num_cpus].nid = pa->proximity_domain;
	srat_num_cpus++;
}

void __init
Len Brown's avatar
Len Brown committed
460
acpi_numa_memory_affinity_init(struct acpi_table_memory_affinity *ma)
Linus Torvalds's avatar
Linus Torvalds committed
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496
{
	unsigned long paddr, size;
	u8 pxm;
	struct node_memblk_s *p, *q, *pend;

	pxm = ma->proximity_domain;

	/* fill node memory chunk structure */
	paddr = ma->base_addr_hi;
	paddr = (paddr << 32) | ma->base_addr_lo;
	size = ma->length_hi;
	size = (size << 32) | ma->length_lo;

	/* Ignore disabled entries */
	if (!ma->flags.enabled)
		return;

	/* record this node in proximity bitmap */
	pxm_bit_set(pxm);

	/* Insertion sort based on base address */
	pend = &node_memblk[num_node_memblks];
	for (p = &node_memblk[0]; p < pend; p++) {
		if (paddr < p->start_paddr)
			break;
	}
	if (p < pend) {
		for (q = pend - 1; q >= p; q--)
			*(q + 1) = *q;
	}
	p->start_paddr = paddr;
	p->size = size;
	p->nid = pxm;
	num_node_memblks++;
}

Len Brown's avatar
Len Brown committed
497
void __init acpi_numa_arch_fixup(void)
Linus Torvalds's avatar
Linus Torvalds committed
498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542
{
	int i, j, node_from, node_to;

	/* If there's no SRAT, fix the phys_id and mark node 0 online */
	if (srat_num_cpus == 0) {
		node_set_online(0);
		node_cpuid[0].phys_id = hard_smp_processor_id();
		return;
	}

	/*
	 * MCD - This can probably be dropped now.  No need for pxm ID to node ID
	 * mapping with sparse node numbering iff MAX_PXM_DOMAINS <= MAX_NUMNODES.
	 */
	/* calculate total number of nodes in system from PXM bitmap */
	memset(pxm_to_nid_map, -1, sizeof(pxm_to_nid_map));
	memset(nid_to_pxm_map, -1, sizeof(nid_to_pxm_map));
	nodes_clear(node_online_map);
	for (i = 0; i < MAX_PXM_DOMAINS; i++) {
		if (pxm_bit_test(i)) {
			int nid = num_online_nodes();
			pxm_to_nid_map[i] = nid;
			nid_to_pxm_map[nid] = i;
			node_set_online(nid);
		}
	}

	/* set logical node id in memory chunk structure */
	for (i = 0; i < num_node_memblks; i++)
		node_memblk[i].nid = pxm_to_nid_map[node_memblk[i].nid];

	/* assign memory bank numbers for each chunk on each node */
	for_each_online_node(i) {
		int bank;

		bank = 0;
		for (j = 0; j < num_node_memblks; j++)
			if (node_memblk[j].nid == i)
				node_memblk[j].bank = bank++;
	}

	/* set logical node id in cpu structure */
	for (i = 0; i < srat_num_cpus; i++)
		node_cpuid[i].nid = pxm_to_nid_map[node_cpuid[i].nid];

Len Brown's avatar
Len Brown committed
543 544 545 546
	printk(KERN_INFO "Number of logical nodes in system = %d\n",
	       num_online_nodes());
	printk(KERN_INFO "Number of memory chunks in system = %d\n",
	       num_node_memblks);
Linus Torvalds's avatar
Linus Torvalds committed
547

Len Brown's avatar
Len Brown committed
548 549
	if (!slit_table)
		return;
Linus Torvalds's avatar
Linus Torvalds committed
550
	memset(numa_slit, -1, sizeof(numa_slit));
Len Brown's avatar
Len Brown committed
551
	for (i = 0; i < slit_table->localities; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
552 553 554
		if (!pxm_bit_test(i))
			continue;
		node_from = pxm_to_nid_map[i];
Len Brown's avatar
Len Brown committed
555
		for (j = 0; j < slit_table->localities; j++) {
Linus Torvalds's avatar
Linus Torvalds committed
556 557 558 559
			if (!pxm_bit_test(j))
				continue;
			node_to = pxm_to_nid_map[j];
			node_distance(node_from, node_to) =
Len Brown's avatar
Len Brown committed
560
			    slit_table->entry[i * slit_table->localities + j];
Linus Torvalds's avatar
Linus Torvalds committed
561 562 563 564 565 566 567
		}
	}

#ifdef SLIT_DEBUG
	printk("ACPI 2.0 SLIT locality table:\n");
	for_each_online_node(i) {
		for_each_online_node(j)
Len Brown's avatar
Len Brown committed
568
		    printk("%03d ", node_distance(i, j));
Linus Torvalds's avatar
Linus Torvalds committed
569 570 571 572
		printk("\n");
	}
#endif
}
Len Brown's avatar
Len Brown committed
573
#endif				/* CONFIG_ACPI_NUMA */
Linus Torvalds's avatar
Linus Torvalds committed
574

575 576 577 578
/*
 * success: return IRQ number (>=0)
 * failure: return < 0
 */
579
int acpi_register_gsi(u32 gsi, int triggering, int polarity)
Linus Torvalds's avatar
Linus Torvalds committed
580 581 582 583 584
{
	if (has_8259 && gsi < 16)
		return isa_irq_to_vector(gsi);

	return iosapic_register_intr(gsi,
585
				     (polarity ==
Len Brown's avatar
Len Brown committed
586 587
				      ACPI_ACTIVE_HIGH) ? IOSAPIC_POL_HIGH :
				     IOSAPIC_POL_LOW,
588
				     (triggering ==
Len Brown's avatar
Len Brown committed
589 590
				      ACPI_EDGE_SENSITIVE) ? IOSAPIC_EDGE :
				     IOSAPIC_LEVEL);
Linus Torvalds's avatar
Linus Torvalds committed
591
}
Len Brown's avatar
Len Brown committed
592

Linus Torvalds's avatar
Linus Torvalds committed
593 594
EXPORT_SYMBOL(acpi_register_gsi);

Len Brown's avatar
Len Brown committed
595
void acpi_unregister_gsi(u32 gsi)
Linus Torvalds's avatar
Linus Torvalds committed
596 597 598
{
	iosapic_unregister_intr(gsi);
}
Len Brown's avatar
Len Brown committed
599

Linus Torvalds's avatar
Linus Torvalds committed
600 601
EXPORT_SYMBOL(acpi_unregister_gsi);

Len Brown's avatar
Len Brown committed
602
static int __init acpi_parse_fadt(unsigned long phys_addr, unsigned long size)
Linus Torvalds's avatar
Linus Torvalds committed
603 604 605 606 607 608 609
{
	struct acpi_table_header *fadt_header;
	struct fadt_descriptor_rev2 *fadt;

	if (!phys_addr || !size)
		return -EINVAL;

Len Brown's avatar
Len Brown committed
610
	fadt_header = (struct acpi_table_header *)__va(phys_addr);
Linus Torvalds's avatar
Linus Torvalds committed
611
	if (fadt_header->revision != 3)
Len Brown's avatar
Len Brown committed
612
		return -ENODEV;	/* Only deal with ACPI 2.0 FADT */
Linus Torvalds's avatar
Linus Torvalds committed
613

Len Brown's avatar
Len Brown committed
614
	fadt = (struct fadt_descriptor_rev2 *)fadt_header;
Linus Torvalds's avatar
Linus Torvalds committed
615 616 617 618 619 620 621 622 623 624 625

	if (!(fadt->iapc_boot_arch & BAF_8042_KEYBOARD_CONTROLLER))
		acpi_kbd_controller_present = 0;

	if (fadt->iapc_boot_arch & BAF_LEGACY_DEVICES)
		acpi_legacy_devices = 1;

	acpi_register_gsi(fadt->sci_int, ACPI_LEVEL_SENSITIVE, ACPI_ACTIVE_LOW);
	return 0;
}

Len Brown's avatar
Len Brown committed
626
unsigned long __init acpi_find_rsdp(void)
Linus Torvalds's avatar
Linus Torvalds committed
627 628 629 630 631 632
{
	unsigned long rsdp_phys = 0;

	if (efi.acpi20)
		rsdp_phys = __pa(efi.acpi20);
	else if (efi.acpi)
Len Brown's avatar
Len Brown committed
633 634
		printk(KERN_WARNING PREFIX
		       "v1.0/r0.71 tables no longer supported\n");
Linus Torvalds's avatar
Linus Torvalds committed
635 636 637
	return rsdp_phys;
}

Len Brown's avatar
Len Brown committed
638
int __init acpi_boot_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
{

	/*
	 * MADT
	 * ----
	 * Parse the Multiple APIC Description Table (MADT), if exists.
	 * Note that this table provides platform SMP configuration
	 * information -- the successor to MPS tables.
	 */

	if (acpi_table_parse(ACPI_APIC, acpi_parse_madt) < 1) {
		printk(KERN_ERR PREFIX "Can't find MADT\n");
		goto skip_madt;
	}

	/* Local APIC */

Len Brown's avatar
Len Brown committed
656 657 658 659
	if (acpi_table_parse_madt
	    (ACPI_MADT_LAPIC_ADDR_OVR, acpi_parse_lapic_addr_ovr, 0) < 0)
		printk(KERN_ERR PREFIX
		       "Error parsing LAPIC address override entry\n");
Linus Torvalds's avatar
Linus Torvalds committed
660

Len Brown's avatar
Len Brown committed
661 662 663 664
	if (acpi_table_parse_madt(ACPI_MADT_LSAPIC, acpi_parse_lsapic, NR_CPUS)
	    < 1)
		printk(KERN_ERR PREFIX
		       "Error parsing MADT - no LAPIC entries\n");
Linus Torvalds's avatar
Linus Torvalds committed
665

Len Brown's avatar
Len Brown committed
666 667
	if (acpi_table_parse_madt(ACPI_MADT_LAPIC_NMI, acpi_parse_lapic_nmi, 0)
	    < 0)
Linus Torvalds's avatar
Linus Torvalds committed
668 669 670 671
		printk(KERN_ERR PREFIX "Error parsing LAPIC NMI entry\n");

	/* I/O APIC */

Len Brown's avatar
Len Brown committed
672 673 674 675
	if (acpi_table_parse_madt
	    (ACPI_MADT_IOSAPIC, acpi_parse_iosapic, NR_IOSAPICS) < 1)
		printk(KERN_ERR PREFIX
		       "Error parsing MADT - no IOSAPIC entries\n");
Linus Torvalds's avatar
Linus Torvalds committed
676 677 678

	/* System-Level Interrupt Routing */

Len Brown's avatar
Len Brown committed
679 680 681 682 683
	if (acpi_table_parse_madt
	    (ACPI_MADT_PLAT_INT_SRC, acpi_parse_plat_int_src,
	     ACPI_MAX_PLATFORM_INTERRUPTS) < 0)
		printk(KERN_ERR PREFIX
		       "Error parsing platform interrupt source entry\n");
Linus Torvalds's avatar
Linus Torvalds committed
684

Len Brown's avatar
Len Brown committed
685 686 687 688
	if (acpi_table_parse_madt
	    (ACPI_MADT_INT_SRC_OVR, acpi_parse_int_src_ovr, 0) < 0)
		printk(KERN_ERR PREFIX
		       "Error parsing interrupt source overrides entry\n");
Linus Torvalds's avatar
Linus Torvalds committed
689 690 691

	if (acpi_table_parse_madt(ACPI_MADT_NMI_SRC, acpi_parse_nmi_src, 0) < 0)
		printk(KERN_ERR PREFIX "Error parsing NMI SRC entry\n");
Len Brown's avatar
Len Brown committed
692
      skip_madt:
Linus Torvalds's avatar
Linus Torvalds committed
693 694 695 696 697 698 699 700 701 702 703 704 705 706

	/*
	 * FADT says whether a legacy keyboard controller is present.
	 * The FADT also contains an SCI_INT line, by which the system
	 * gets interrupts such as power and sleep buttons.  If it's not
	 * on a Legacy interrupt, it needs to be setup.
	 */
	if (acpi_table_parse(ACPI_FADT, acpi_parse_fadt) < 1)
		printk(KERN_ERR PREFIX "Can't find FADT\n");

#ifdef CONFIG_SMP
	if (available_cpus == 0) {
		printk(KERN_INFO "ACPI: Found 0 CPUS; assuming 1\n");
		printk(KERN_INFO "CPU 0 (0x%04x)", hard_smp_processor_id());
Len Brown's avatar
Len Brown committed
707 708 709
		smp_boot_data.cpu_phys_id[available_cpus] =
		    hard_smp_processor_id();
		available_cpus = 1;	/* We've got at least one of these, no? */
Linus Torvalds's avatar
Linus Torvalds committed
710 711 712 713 714 715 716 717
	}
	smp_boot_data.cpu_count = available_cpus;

	smp_build_cpu_map();
# ifdef CONFIG_ACPI_NUMA
	if (srat_num_cpus == 0) {
		int cpu, i = 1;
		for (cpu = 0; cpu < smp_boot_data.cpu_count; cpu++)
Len Brown's avatar
Len Brown committed
718 719 720 721
			if (smp_boot_data.cpu_phys_id[cpu] !=
			    hard_smp_processor_id())
				node_cpuid[i++].phys_id =
				    smp_boot_data.cpu_phys_id[cpu];
Linus Torvalds's avatar
Linus Torvalds committed
722 723
	}
# endif
Tony Luck's avatar
Tony Luck committed
724 725 726
#endif
#ifdef CONFIG_ACPI_NUMA
	build_cpu_to_node_map();
Linus Torvalds's avatar
Linus Torvalds committed
727 728
#endif
	/* Make boot-up look pretty */
Len Brown's avatar
Len Brown committed
729 730
	printk(KERN_INFO "%d CPUs available, %d CPUs total\n", available_cpus,
	       total_cpus);
Linus Torvalds's avatar
Linus Torvalds committed
731 732 733
	return 0;
}

Len Brown's avatar
Len Brown committed
734
int acpi_gsi_to_irq(u32 gsi, unsigned int *irq)
Linus Torvalds's avatar
Linus Torvalds committed
735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754
{
	int vector;

	if (has_8259 && gsi < 16)
		*irq = isa_irq_to_vector(gsi);
	else {
		vector = gsi_to_vector(gsi);
		if (vector == -1)
			return -1;

		*irq = vector;
	}
	return 0;
}

/*
 *  ACPI based hotplug CPU support
 */
#ifdef CONFIG_ACPI_HOTPLUG_CPU
static
Len Brown's avatar
Len Brown committed
755
int acpi_map_cpu2node(acpi_handle handle, int cpu, long physid)
Linus Torvalds's avatar
Linus Torvalds committed
756 757
{
#ifdef CONFIG_ACPI_NUMA
Len Brown's avatar
Len Brown committed
758
	int pxm_id;
Linus Torvalds's avatar
Linus Torvalds committed
759 760 761 762 763 764 765

	pxm_id = acpi_get_pxm(handle);

	/*
	 * Assuming that the container driver would have set the proximity
	 * domain and would have initialized pxm_to_nid_map[pxm_id] && pxm_flag
	 */
Len Brown's avatar
Len Brown committed
766
	node_cpuid[cpu].nid = (pxm_id < 0) ? 0 : pxm_to_nid_map[pxm_id];
Linus Torvalds's avatar
Linus Torvalds committed
767

Len Brown's avatar
Len Brown committed
768
	node_cpuid[cpu].phys_id = physid;
Linus Torvalds's avatar
Linus Torvalds committed
769
#endif
Len Brown's avatar
Len Brown committed
770
	return (0);
Linus Torvalds's avatar
Linus Torvalds committed
771 772
}

773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805
int additional_cpus __initdata = -1;

static __init int setup_additional_cpus(char *s)
{
	if (s)
		additional_cpus = simple_strtol(s, NULL, 0);

	return 0;
}

early_param("additional_cpus", setup_additional_cpus);

/*
 * cpu_possible_map should be static, it cannot change as cpu's
 * are onlined, or offlined. The reason is per-cpu data-structures
 * are allocated by some modules at init time, and dont expect to
 * do this dynamically on cpu arrival/departure.
 * cpu_present_map on the other hand can change dynamically.
 * In case when cpu_hotplug is not compiled, then we resort to current
 * behaviour, which is cpu_possible == cpu_present.
 * - Ashok Raj
 *
 * Three ways to find out the number of additional hotplug CPUs:
 * - If the BIOS specified disabled CPUs in ACPI/mptables use that.
 * - The user can overwrite it with additional_cpus=NUM
 * - Otherwise don't reserve additional CPUs.
 */
__init void prefill_possible_map(void)
{
	int i;
	int possible, disabled_cpus;

	disabled_cpus = total_cpus - available_cpus;
806

807
 	if (additional_cpus == -1) {
808
 		if (disabled_cpus > 0)
809
			additional_cpus = disabled_cpus;
810
 		else
811
			additional_cpus = 0;
812 813 814 815
 	}

	possible = available_cpus + additional_cpus;

816 817 818 819
	if (possible > NR_CPUS)
		possible = NR_CPUS;

	printk(KERN_INFO "SMP: Allowing %d CPUs, %d hotplug CPUs\n",
820
		possible, max((possible - available_cpus), 0));
821 822 823 824 825

	for (i = 0; i < possible; i++)
		cpu_set(i, cpu_possible_map);
}

Len Brown's avatar
Len Brown committed
826
int acpi_map_lsapic(acpi_handle handle, int *pcpu)
Linus Torvalds's avatar
Linus Torvalds committed
827
{
Len Brown's avatar
Len Brown committed
828
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
Linus Torvalds's avatar
Linus Torvalds committed
829 830 831 832 833
	union acpi_object *obj;
	struct acpi_table_lsapic *lsapic;
	cpumask_t tmp_map;
	long physid;
	int cpu;
Len Brown's avatar
Len Brown committed
834

Linus Torvalds's avatar
Linus Torvalds committed
835 836 837
	if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
		return -EINVAL;

Len Brown's avatar
Len Brown committed
838
	if (!buffer.length || !buffer.pointer)
Linus Torvalds's avatar
Linus Torvalds committed
839
		return -EINVAL;
Len Brown's avatar
Len Brown committed
840

Linus Torvalds's avatar
Linus Torvalds committed
841 842 843 844 845 846 847 848 849 850 851 852 853 854 855
	obj = buffer.pointer;
	if (obj->type != ACPI_TYPE_BUFFER ||
	    obj->buffer.length < sizeof(*lsapic)) {
		acpi_os_free(buffer.pointer);
		return -EINVAL;
	}

	lsapic = (struct acpi_table_lsapic *)obj->buffer.pointer;

	if ((lsapic->header.type != ACPI_MADT_LSAPIC) ||
	    (!lsapic->flags.enabled)) {
		acpi_os_free(buffer.pointer);
		return -EINVAL;
	}

Len Brown's avatar
Len Brown committed
856
	physid = ((lsapic->id << 8) | (lsapic->eid));
Linus Torvalds's avatar
Linus Torvalds committed
857 858 859 860 861 862 863

	acpi_os_free(buffer.pointer);
	buffer.length = ACPI_ALLOCATE_BUFFER;
	buffer.pointer = NULL;

	cpus_complement(tmp_map, cpu_present_map);
	cpu = first_cpu(tmp_map);
Len Brown's avatar
Len Brown committed
864
	if (cpu >= NR_CPUS)
Linus Torvalds's avatar
Linus Torvalds committed
865 866 867 868
		return -EINVAL;

	acpi_map_cpu2node(handle, cpu, physid);

Len Brown's avatar
Len Brown committed
869
	cpu_set(cpu, cpu_present_map);
Linus Torvalds's avatar
Linus Torvalds committed
870 871 872 873
	ia64_cpu_to_sapicid[cpu] = physid;
	ia64_acpiid_to_sapicid[lsapic->acpi_id] = ia64_cpu_to_sapicid[cpu];

	*pcpu = cpu;
Len Brown's avatar
Len Brown committed
874
	return (0);
Linus Torvalds's avatar
Linus Torvalds committed
875 876
}

Len Brown's avatar
Len Brown committed
877
EXPORT_SYMBOL(acpi_map_lsapic);
Linus Torvalds's avatar
Linus Torvalds committed
878

Len Brown's avatar
Len Brown committed
879
int acpi_unmap_lsapic(int cpu)
Linus Torvalds's avatar
Linus Torvalds committed
880 881 882
{
	int i;

Len Brown's avatar
Len Brown committed
883 884 885 886 887 888
	for (i = 0; i < MAX_SAPICS; i++) {
		if (ia64_acpiid_to_sapicid[i] == ia64_cpu_to_sapicid[cpu]) {
			ia64_acpiid_to_sapicid[i] = -1;
			break;
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
889
	ia64_cpu_to_sapicid[cpu] = -1;
Len Brown's avatar
Len Brown committed
890
	cpu_clear(cpu, cpu_present_map);
Linus Torvalds's avatar
Linus Torvalds committed
891 892 893 894 895

#ifdef CONFIG_ACPI_NUMA
	/* NUMA specific cleanup's */
#endif

Len Brown's avatar
Len Brown committed
896
	return (0);
Linus Torvalds's avatar
Linus Torvalds committed
897
}
Len Brown's avatar
Len Brown committed
898

Linus Torvalds's avatar
Linus Torvalds committed
899
EXPORT_SYMBOL(acpi_unmap_lsapic);
Len Brown's avatar
Len Brown committed
900
#endif				/* CONFIG_ACPI_HOTPLUG_CPU */
Linus Torvalds's avatar
Linus Torvalds committed
901 902

#ifdef CONFIG_ACPI_NUMA
903
static acpi_status __devinit
Len Brown's avatar
Len Brown committed
904
acpi_map_iosapic(acpi_handle handle, u32 depth, void *context, void **ret)
Linus Torvalds's avatar
Linus Torvalds committed
905
{
Len Brown's avatar
Len Brown committed
906
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
Linus Torvalds's avatar
Linus Torvalds committed
907 908 909
	union acpi_object *obj;
	struct acpi_table_iosapic *iosapic;
	unsigned int gsi_base;
910
	int pxm, node;
Linus Torvalds's avatar
Linus Torvalds committed
911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937

	/* Only care about objects w/ a method that returns the MADT */
	if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
		return AE_OK;

	if (!buffer.length || !buffer.pointer)
		return AE_OK;

	obj = buffer.pointer;
	if (obj->type != ACPI_TYPE_BUFFER ||
	    obj->buffer.length < sizeof(*iosapic)) {
		acpi_os_free(buffer.pointer);
		return AE_OK;
	}

	iosapic = (struct acpi_table_iosapic *)obj->buffer.pointer;

	if (iosapic->header.type != ACPI_MADT_IOSAPIC) {
		acpi_os_free(buffer.pointer);
		return AE_OK;
	}

	gsi_base = iosapic->global_irq_base;

	acpi_os_free(buffer.pointer);

	/*
938
	 * OK, it's an IOSAPIC MADT entry, look for a _PXM value to tell
Linus Torvalds's avatar
Linus Torvalds committed
939 940
	 * us which node to associate this with.
	 */
941 942
	pxm = acpi_get_pxm(handle);
	if (pxm < 0)
Linus Torvalds's avatar
Linus Torvalds committed
943 944
		return AE_OK;

945
	node = pxm_to_nid_map[pxm];
Linus Torvalds's avatar
Linus Torvalds committed
946 947 948 949 950 951 952 953 954

	if (node >= MAX_NUMNODES || !node_online(node) ||
	    cpus_empty(node_to_cpumask(node)))
		return AE_OK;

	/* We know a gsi to node mapping! */
	map_iosapic_to_node(gsi_base, node);
	return AE_OK;
}
955 956 957 958 959 960 961 962 963 964

static int __init
acpi_map_iosapics (void)
{
	acpi_get_devices(NULL, acpi_map_iosapic, NULL, NULL);
	return 0;
}

fs_initcall(acpi_map_iosapics);
#endif				/* CONFIG_ACPI_NUMA */
965

Len Brown's avatar
Len Brown committed
966
int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base)
967
{
968 969 970 971 972
	int err;

	if ((err = iosapic_init(phys_addr, gsi_base)))
		return err;

973
#ifdef CONFIG_ACPI_NUMA
974
	acpi_map_iosapic(handle, 0, NULL, NULL);
Len Brown's avatar
Len Brown committed
975
#endif				/* CONFIG_ACPI_NUMA */
976 977

	return 0;
978
}
Len Brown's avatar
Len Brown committed
979

980 981
EXPORT_SYMBOL(acpi_register_ioapic);

Len Brown's avatar
Len Brown committed
982
int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base)
983
{
984
	return iosapic_remove(gsi_base);
985
}
Len Brown's avatar
Len Brown committed
986

987 988
EXPORT_SYMBOL(acpi_unregister_ioapic);

Len Brown's avatar
Len Brown committed
989
#endif				/* CONFIG_ACPI */