boot.c 30.7 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
/*
 *  boot.c - Architecture-Specific Low-Level ACPI Boot Support
 *
 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 *  Copyright (C) 2001 Jun Nakajima <jun.nakajima@intel.com>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  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/init.h>
#include <linux/acpi.h>
#include <linux/efi.h>
29
#include <linux/cpumask.h>
Linus Torvalds's avatar
Linus Torvalds committed
30
#include <linux/module.h>
31
#include <linux/dmi.h>
32
#include <linux/irq.h>
33 34
#include <linux/bootmem.h>
#include <linux/ioport.h>
Linus Torvalds's avatar
Linus Torvalds committed
35 36 37 38 39 40 41

#include <asm/pgtable.h>
#include <asm/io_apic.h>
#include <asm/apic.h>
#include <asm/io.h>
#include <asm/mpspec.h>

42
static int __initdata acpi_force = 0;
43

44 45 46 47 48 49 50
#ifdef	CONFIG_ACPI
int acpi_disabled = 0;
#else
int acpi_disabled = 1;
#endif
EXPORT_SYMBOL(acpi_disabled);

Linus Torvalds's avatar
Linus Torvalds committed
51 52 53 54
#ifdef	CONFIG_X86_64

#include <asm/proto.h>

55 56 57
static inline int acpi_madt_oem_check(char *oem_id, char *oem_table_id) { return 0; }


Len Brown's avatar
Len Brown committed
58
#else				/* X86 */
Linus Torvalds's avatar
Linus Torvalds committed
59 60 61 62

#ifdef	CONFIG_X86_LOCAL_APIC
#include <mach_apic.h>
#include <mach_mpparse.h>
Len Brown's avatar
Len Brown committed
63
#endif				/* CONFIG_X86_LOCAL_APIC */
Linus Torvalds's avatar
Linus Torvalds committed
64

Len Brown's avatar
Len Brown committed
65
#endif				/* X86 */
Linus Torvalds's avatar
Linus Torvalds committed
66 67 68

#define BAD_MADT_ENTRY(entry, end) (					    \
		(!entry) || (unsigned long)entry + sizeof(*entry) > end ||  \
69
		((struct acpi_subtable_header *)entry)->length < sizeof(*entry))
Linus Torvalds's avatar
Linus Torvalds committed
70 71 72

#define PREFIX			"ACPI: "

73
int acpi_noirq;				/* skip ACPI IRQ initialization */
Len Brown's avatar
Len Brown committed
74
int acpi_pci_disabled __initdata;	/* skip ACPI PCI scan and IRQ initialization */
Linus Torvalds's avatar
Linus Torvalds committed
75 76 77 78 79 80 81
int acpi_ht __initdata = 1;	/* enable HT */

int acpi_lapic;
int acpi_ioapic;
int acpi_strict;
EXPORT_SYMBOL(acpi_strict);

82
u8 acpi_sci_flags __initdata;
Linus Torvalds's avatar
Linus Torvalds committed
83 84
int acpi_sci_override_gsi __initdata;
int acpi_skip_timer_override __initdata;
85
int acpi_use_timer_override __initdata;
Linus Torvalds's avatar
Linus Torvalds committed
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102

#ifdef CONFIG_X86_LOCAL_APIC
static u64 acpi_lapic_addr __initdata = APIC_DEFAULT_PHYS_BASE;
#endif

#ifndef __HAVE_ARCH_CMPXCHG
#warning ACPI uses CMPXCHG, i486 and later hardware
#endif

/* --------------------------------------------------------------------------
                              Boot-time Configuration
   -------------------------------------------------------------------------- */

/*
 * The default interrupt routing model is PIC (8259).  This gets
 * overriden if IOAPICs are enumerated (below).
 */
Len Brown's avatar
Len Brown committed
103
enum acpi_irq_model_id acpi_irq_model = ACPI_IRQ_MODEL_PIC;
Linus Torvalds's avatar
Linus Torvalds committed
104 105 106 107 108 109 110

#ifdef	CONFIG_X86_64

/* rely on all ACPI tables being in the direct mapping */
char *__acpi_map_table(unsigned long phys_addr, unsigned long size)
{
	if (!phys_addr || !size)
Len Brown's avatar
Len Brown committed
111
		return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
112

113
	if (phys_addr+size <= (end_pfn_map << PAGE_SHIFT) + PAGE_SIZE)
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 135 136 137
		return __va(phys_addr);

	return NULL;
}

#else

/*
 * Temporarily use the virtual area starting from FIX_IO_APIC_BASE_END,
 * to map the target physical address. The problem is that set_fixmap()
 * provides a single page, and it is possible that the page is not
 * sufficient.
 * By using this area, we can map up to MAX_IO_APICS pages temporarily,
 * i.e. until the next __va_range() call.
 *
 * Important Safety Note:  The fixed I/O APIC page numbers are *subtracted*
 * from the fixed base.  That's why we start at FIX_IO_APIC_BASE_END and
 * count idx down while incrementing the phys address.
 */
char *__acpi_map_table(unsigned long phys, unsigned long size)
{
	unsigned long base, offset, mapped_size;
	int idx;

Len Brown's avatar
Len Brown committed
138 139
	if (phys + size < 8 * 1024 * 1024)
		return __va(phys);
Linus Torvalds's avatar
Linus Torvalds committed
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157

	offset = phys & (PAGE_SIZE - 1);
	mapped_size = PAGE_SIZE - offset;
	set_fixmap(FIX_ACPI_END, phys);
	base = fix_to_virt(FIX_ACPI_END);

	/*
	 * Most cases can be covered by the below.
	 */
	idx = FIX_ACPI_END;
	while (mapped_size < size) {
		if (--idx < FIX_ACPI_BEGIN)
			return NULL;	/* cannot handle this */
		phys += PAGE_SIZE;
		set_fixmap(idx, phys);
		mapped_size += PAGE_SIZE;
	}

Len Brown's avatar
Len Brown committed
158
	return ((unsigned char *)base + offset);
Linus Torvalds's avatar
Linus Torvalds committed
159 160 161 162
}
#endif

#ifdef CONFIG_PCI_MMCONFIG
163
/* The physical address of the MMCONFIG aperture.  Set from ACPI tables. */
164
struct acpi_mcfg_allocation *pci_mmcfg_config;
165 166
int pci_mmcfg_config_num;

167
int __init acpi_parse_mcfg(struct acpi_table_header *header)
Linus Torvalds's avatar
Linus Torvalds committed
168 169
{
	struct acpi_table_mcfg *mcfg;
170 171
	unsigned long i;
	int config_size;
Linus Torvalds's avatar
Linus Torvalds committed
172

173
	if (!header)
Linus Torvalds's avatar
Linus Torvalds committed
174 175
		return -EINVAL;

176
	mcfg = (struct acpi_table_mcfg *)header;
Linus Torvalds's avatar
Linus Torvalds committed
177

178 179
	/* how many config structures do we have */
	pci_mmcfg_config_num = 0;
180
	i = header->length - sizeof(struct acpi_table_mcfg);
181
	while (i >= sizeof(struct acpi_mcfg_allocation)) {
182
		++pci_mmcfg_config_num;
183
		i -= sizeof(struct acpi_mcfg_allocation);
184 185 186
	};
	if (pci_mmcfg_config_num == 0) {
		printk(KERN_ERR PREFIX "MMCONFIG has no entries\n");
Linus Torvalds's avatar
Linus Torvalds committed
187 188 189
		return -ENODEV;
	}

190 191 192 193 194 195 196 197
	config_size = pci_mmcfg_config_num * sizeof(*pci_mmcfg_config);
	pci_mmcfg_config = kmalloc(config_size, GFP_KERNEL);
	if (!pci_mmcfg_config) {
		printk(KERN_WARNING PREFIX
		       "No memory for MCFG config tables\n");
		return -ENOMEM;
	}

198
	memcpy(pci_mmcfg_config, &mcfg[1], config_size);
199
	for (i = 0; i < pci_mmcfg_config_num; ++i) {
200
		if (pci_mmcfg_config[i].address > 0xFFFFFFFF) {
201 202
			printk(KERN_ERR PREFIX
			       "MMCONFIG not in low 4GB of memory\n");
203 204
			kfree(pci_mmcfg_config);
			pci_mmcfg_config_num = 0;
205 206 207
			return -ENODEV;
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
208 209 210

	return 0;
}
Len Brown's avatar
Len Brown committed
211
#endif				/* CONFIG_PCI_MMCONFIG */
Linus Torvalds's avatar
Linus Torvalds committed
212 213

#ifdef CONFIG_X86_LOCAL_APIC
214
static int __init acpi_parse_madt(struct acpi_table_header *table)
Linus Torvalds's avatar
Linus Torvalds committed
215
{
Len Brown's avatar
Len Brown committed
216
	struct acpi_table_madt *madt = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
217

218
	if (!cpu_has_apic)
Linus Torvalds's avatar
Linus Torvalds committed
219 220
		return -EINVAL;

221
	madt = (struct acpi_table_madt *)table;
Linus Torvalds's avatar
Linus Torvalds committed
222 223 224 225 226
	if (!madt) {
		printk(KERN_WARNING PREFIX "Unable to map MADT\n");
		return -ENODEV;
	}

227 228
	if (madt->address) {
		acpi_lapic_addr = (u64) madt->address;
Linus Torvalds's avatar
Linus Torvalds committed
229 230

		printk(KERN_DEBUG PREFIX "Local APIC address 0x%08x\n",
231
		       madt->address);
Linus Torvalds's avatar
Linus Torvalds committed
232 233 234
	}

	acpi_madt_oem_check(madt->header.oem_id, madt->header.oem_table_id);
Len Brown's avatar
Len Brown committed
235

Linus Torvalds's avatar
Linus Torvalds committed
236 237 238 239
	return 0;
}

static int __init
240
acpi_parse_lapic(struct acpi_subtable_header * header, const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
241
{
242
	struct acpi_madt_local_apic *processor = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
243

244
	processor = (struct acpi_madt_local_apic *)header;
Linus Torvalds's avatar
Linus Torvalds committed
245 246 247 248 249 250

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

	acpi_table_print_madt_entry(header);

251 252 253 254 255 256 257
	/*
	 * We need to register disabled CPU as well to permit
	 * counting disabled CPUs. This allows us to size
	 * cpus_possible_map more accurately, to permit
	 * to not preallocating memory for all NR_CPUS
	 * when we use CPU hotplug.
	 */
Len Brown's avatar
Len Brown committed
258
	mp_register_lapic(processor->id,	/* APIC ID */
259
			  processor->lapic_flags & ACPI_MADT_ENABLED);	/* Enabled? */
Linus Torvalds's avatar
Linus Torvalds committed
260 261 262 263 264

	return 0;
}

static int __init
265
acpi_parse_lapic_addr_ovr(struct acpi_subtable_header * header,
Len Brown's avatar
Len Brown committed
266
			  const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
267
{
268
	struct acpi_madt_local_apic_override *lapic_addr_ovr = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
269

270
	lapic_addr_ovr = (struct acpi_madt_local_apic_override *)header;
Linus Torvalds's avatar
Linus Torvalds committed
271 272 273 274 275 276 277 278 279 280

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

	acpi_lapic_addr = lapic_addr_ovr->address;

	return 0;
}

static int __init
281
acpi_parse_lapic_nmi(struct acpi_subtable_header * header, const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
282
{
283
	struct acpi_madt_local_apic_nmi *lapic_nmi = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
284

285
	lapic_nmi = (struct acpi_madt_local_apic_nmi *)header;
Linus Torvalds's avatar
Linus Torvalds committed
286 287 288 289 290 291 292 293 294 295 296 297

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

	acpi_table_print_madt_entry(header);

	if (lapic_nmi->lint != 1)
		printk(KERN_WARNING PREFIX "NMI not connected to LINT 1!\n");

	return 0;
}

Len Brown's avatar
Len Brown committed
298
#endif				/*CONFIG_X86_LOCAL_APIC */
Linus Torvalds's avatar
Linus Torvalds committed
299

300
#ifdef CONFIG_X86_IO_APIC
Linus Torvalds's avatar
Linus Torvalds committed
301 302

static int __init
303
acpi_parse_ioapic(struct acpi_subtable_header * header, const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
304
{
305
	struct acpi_madt_io_apic *ioapic = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
306

307
	ioapic = (struct acpi_madt_io_apic *)header;
Linus Torvalds's avatar
Linus Torvalds committed
308 309 310

	if (BAD_MADT_ENTRY(ioapic, end))
		return -EINVAL;
Len Brown's avatar
Len Brown committed
311

Linus Torvalds's avatar
Linus Torvalds committed
312 313
	acpi_table_print_madt_entry(header);

Len Brown's avatar
Len Brown committed
314 315 316
	mp_register_ioapic(ioapic->id,
			   ioapic->address, ioapic->global_irq_base);

Linus Torvalds's avatar
Linus Torvalds committed
317 318 319 320 321 322
	return 0;
}

/*
 * Parse Interrupt Source Override for the ACPI SCI
 */
323
static void __init acpi_sci_ioapic_setup(u32 gsi, u16 polarity, u16 trigger)
Linus Torvalds's avatar
Linus Torvalds committed
324 325 326 327 328 329 330 331
{
	if (trigger == 0)	/* compatible SCI trigger is level */
		trigger = 3;

	if (polarity == 0)	/* compatible SCI polarity is low */
		polarity = 3;

	/* Command-line over-ride via acpi_sci= */
332 333
	if (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)
		trigger = (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2;
Linus Torvalds's avatar
Linus Torvalds committed
334

335 336
	if (acpi_sci_flags & ACPI_MADT_POLARITY_MASK)
		polarity = acpi_sci_flags & ACPI_MADT_POLARITY_MASK;
Linus Torvalds's avatar
Linus Torvalds committed
337 338

	/*
Len Brown's avatar
Len Brown committed
339
	 * mp_config_acpi_legacy_irqs() already setup IRQs < 16
Linus Torvalds's avatar
Linus Torvalds committed
340 341 342
	 * If GSI is < 16, this will update its flags,
	 * else it will create a new mp_irqs[] entry.
	 */
343
	mp_override_legacy_irq(gsi, polarity, trigger, gsi);
Linus Torvalds's avatar
Linus Torvalds committed
344 345 346

	/*
	 * stash over-ride to indicate we've been here
347
	 * and for later update of acpi_gbl_FADT
Linus Torvalds's avatar
Linus Torvalds committed
348
	 */
349
	acpi_sci_override_gsi = gsi;
Linus Torvalds's avatar
Linus Torvalds committed
350 351 352 353
	return;
}

static int __init
354
acpi_parse_int_src_ovr(struct acpi_subtable_header * header,
Len Brown's avatar
Len Brown committed
355
		       const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
356
{
357
	struct acpi_madt_interrupt_override *intsrc = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
358

359
	intsrc = (struct acpi_madt_interrupt_override *)header;
Linus Torvalds's avatar
Linus Torvalds committed
360 361 362 363 364 365

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

	acpi_table_print_madt_entry(header);

366
	if (intsrc->source_irq == acpi_gbl_FADT.sci_interrupt) {
367
		acpi_sci_ioapic_setup(intsrc->global_irq,
368 369
				      intsrc->inti_flags & ACPI_MADT_POLARITY_MASK,
				      (intsrc->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2);
Linus Torvalds's avatar
Linus Torvalds committed
370 371 372 373
		return 0;
	}

	if (acpi_skip_timer_override &&
374
	    intsrc->source_irq == 0 && intsrc->global_irq == 2) {
Len Brown's avatar
Len Brown committed
375 376
		printk(PREFIX "BIOS IRQ0 pin2 override ignored.\n");
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
377 378
	}

379 380 381 382
	mp_override_legacy_irq(intsrc->source_irq,
				intsrc->inti_flags & ACPI_MADT_POLARITY_MASK,
				(intsrc->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2,
				intsrc->global_irq);
Linus Torvalds's avatar
Linus Torvalds committed
383 384 385 386 387

	return 0;
}

static int __init
388
acpi_parse_nmi_src(struct acpi_subtable_header * header, const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
389
{
390
	struct acpi_madt_nmi_source *nmi_src = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
391

392
	nmi_src = (struct acpi_madt_nmi_source *)header;
Linus Torvalds's avatar
Linus Torvalds committed
393 394 395 396 397 398 399 400 401 402 403

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

	acpi_table_print_madt_entry(header);

	/* TBD: Support nimsrc entries? */

	return 0;
}

Len Brown's avatar
Len Brown committed
404
#endif				/* CONFIG_X86_IO_APIC */
Linus Torvalds's avatar
Linus Torvalds committed
405 406 407

/*
 * acpi_pic_sci_set_trigger()
408
 *
Linus Torvalds's avatar
Linus Torvalds committed
409 410 411 412 413 414 415 416 417 418 419
 * use ELCR to set PIC-mode trigger type for SCI
 *
 * If a PIC-mode SCI is not recognized or gives spurious IRQ7's
 * it may require Edge Trigger -- use "acpi_sci=edge"
 *
 * Port 0x4d0-4d1 are ECLR1 and ECLR2, the Edge/Level Control Registers
 * for the 8259 PIC.  bit[n] = 1 means irq[n] is Level, otherwise Edge.
 * ECLR1 is IRQ's 0-7 (IRQ 0, 1, 2 must be 0)
 * ECLR2 is IRQ's 8-15 (IRQ 8, 13 must be 0)
 */

Len Brown's avatar
Len Brown committed
420
void __init acpi_pic_sci_set_trigger(unsigned int irq, u16 trigger)
Linus Torvalds's avatar
Linus Torvalds committed
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
{
	unsigned int mask = 1 << irq;
	unsigned int old, new;

	/* Real old ELCR mask */
	old = inb(0x4d0) | (inb(0x4d1) << 8);

	/*
	 * If we use ACPI to set PCI irq's, then we should clear ELCR
	 * since we will set it correctly as we enable the PCI irq
	 * routing.
	 */
	new = acpi_noirq ? old : 0;

	/*
	 * Update SCI information in the ELCR, it isn't in the PCI
	 * routing tables..
	 */
	switch (trigger) {
Len Brown's avatar
Len Brown committed
440
	case 1:		/* Edge - clear */
Linus Torvalds's avatar
Linus Torvalds committed
441 442
		new &= ~mask;
		break;
Len Brown's avatar
Len Brown committed
443
	case 3:		/* Level - set */
Linus Torvalds's avatar
Linus Torvalds committed
444 445 446 447 448 449 450 451 452 453 454 455 456 457
		new |= mask;
		break;
	}

	if (old == new)
		return;

	printk(PREFIX "setting ELCR to %04x (from %04x)\n", new, old);
	outb(new, 0x4d0);
	outb(new >> 8, 0x4d1);
}

int acpi_gsi_to_irq(u32 gsi, unsigned int *irq)
{
458
	*irq = gsi;
Linus Torvalds's avatar
Linus Torvalds committed
459 460 461
	return 0;
}

462 463 464 465
/*
 * success: return IRQ number (>=0)
 * failure: return < 0
 */
466
int acpi_register_gsi(u32 gsi, int triggering, int polarity)
Linus Torvalds's avatar
Linus Torvalds committed
467 468 469 470 471 472 473 474 475 476 477
{
	unsigned int irq;
	unsigned int plat_gsi = gsi;

#ifdef CONFIG_PCI
	/*
	 * Make sure all (legacy) PCI IRQs are set as level-triggered.
	 */
	if (acpi_irq_model == ACPI_IRQ_MODEL_PIC) {
		extern void eisa_set_level_irq(unsigned int irq);

478
		if (triggering == ACPI_LEVEL_SENSITIVE)
Len Brown's avatar
Len Brown committed
479
			eisa_set_level_irq(gsi);
Linus Torvalds's avatar
Linus Torvalds committed
480 481 482 483 484
	}
#endif

#ifdef CONFIG_X86_IO_APIC
	if (acpi_irq_model == ACPI_IRQ_MODEL_IOAPIC) {
485
		plat_gsi = mp_register_gsi(gsi, triggering, polarity);
Linus Torvalds's avatar
Linus Torvalds committed
486 487 488 489 490
	}
#endif
	acpi_gsi_to_irq(plat_gsi, &irq);
	return irq;
}
Len Brown's avatar
Len Brown committed
491

Linus Torvalds's avatar
Linus Torvalds committed
492 493 494 495 496 497
EXPORT_SYMBOL(acpi_register_gsi);

/*
 *  ACPI based hotplug support for CPU
 */
#ifdef CONFIG_ACPI_HOTPLUG_CPU
Len Brown's avatar
Len Brown committed
498
int acpi_map_lsapic(acpi_handle handle, int *pcpu)
Linus Torvalds's avatar
Linus Torvalds committed
499
{
500 501
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *obj;
502
	struct acpi_madt_local_apic *lapic;
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
	cpumask_t tmp_map, new_map;
	u8 physid;
	int cpu;

	if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
		return -EINVAL;

	if (!buffer.length || !buffer.pointer)
		return -EINVAL;

	obj = buffer.pointer;
	if (obj->type != ACPI_TYPE_BUFFER ||
	    obj->buffer.length < sizeof(*lapic)) {
		kfree(buffer.pointer);
		return -EINVAL;
	}

520
	lapic = (struct acpi_madt_local_apic *)obj->buffer.pointer;
521

522 523
	if (lapic->header.type != ACPI_MADT_TYPE_LOCAL_APIC ||
	    !(lapic->lapic_flags & ACPI_MADT_ENABLED)) {
524 525 526 527 528 529 530 531 532 533 534
		kfree(buffer.pointer);
		return -EINVAL;
	}

	physid = lapic->id;

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

	tmp_map = cpu_present_map;
535
	mp_register_lapic(physid, lapic->lapic_flags & ACPI_MADT_ENABLED);
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550

	/*
	 * If mp_register_lapic successfully generates a new logical cpu
	 * number, then the following will get us exactly what was mapped
	 */
	cpus_andnot(new_map, cpu_present_map, tmp_map);
	if (cpus_empty(new_map)) {
		printk ("Unable to map lapic to logical cpu number\n");
		return -EINVAL;
	}

	cpu = first_cpu(new_map);

	*pcpu = cpu;
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
551 552
}

Len Brown's avatar
Len Brown committed
553
EXPORT_SYMBOL(acpi_map_lsapic);
Linus Torvalds's avatar
Linus Torvalds committed
554

Len Brown's avatar
Len Brown committed
555
int acpi_unmap_lsapic(int cpu)
Linus Torvalds's avatar
Linus Torvalds committed
556
{
557 558 559 560 561
	x86_cpu_to_apicid[cpu] = -1;
	cpu_clear(cpu, cpu_present_map);
	num_processors--;

	return (0);
Linus Torvalds's avatar
Linus Torvalds committed
562
}
Len Brown's avatar
Len Brown committed
563

Linus Torvalds's avatar
Linus Torvalds committed
564
EXPORT_SYMBOL(acpi_unmap_lsapic);
Len Brown's avatar
Len Brown committed
565
#endif				/* CONFIG_ACPI_HOTPLUG_CPU */
Linus Torvalds's avatar
Linus Torvalds committed
566

Len Brown's avatar
Len Brown committed
567
int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base)
568 569 570 571
{
	/* TBD */
	return -EINVAL;
}
Len Brown's avatar
Len Brown committed
572

573 574
EXPORT_SYMBOL(acpi_register_ioapic);

Len Brown's avatar
Len Brown committed
575
int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base)
576 577 578 579
{
	/* TBD */
	return -EINVAL;
}
Len Brown's avatar
Len Brown committed
580

581 582
EXPORT_SYMBOL(acpi_unregister_ioapic);

Linus Torvalds's avatar
Linus Torvalds committed
583
static unsigned long __init
Len Brown's avatar
Len Brown committed
584
acpi_scan_rsdp(unsigned long start, unsigned long length)
Linus Torvalds's avatar
Linus Torvalds committed
585
{
Len Brown's avatar
Len Brown committed
586 587
	unsigned long offset = 0;
	unsigned long sig_len = sizeof("RSD PTR ") - 1;
Linus Torvalds's avatar
Linus Torvalds committed
588 589 590 591 592 593

	/*
	 * Scan all 16-byte boundaries of the physical memory region for the
	 * RSDP signature.
	 */
	for (offset = 0; offset < length; offset += 16) {
594
		if (strncmp((char *)(phys_to_virt(start) + offset), "RSD PTR ", sig_len))
Linus Torvalds's avatar
Linus Torvalds committed
595 596 597 598 599 600 601
			continue;
		return (start + offset);
	}

	return 0;
}

602
static int __init acpi_parse_sbf(struct acpi_table_header *table)
Linus Torvalds's avatar
Linus Torvalds committed
603
{
604
	struct acpi_table_boot *sb;
Linus Torvalds's avatar
Linus Torvalds committed
605

606
	sb = (struct acpi_table_boot *)table;
Linus Torvalds's avatar
Linus Torvalds committed
607 608 609 610 611
	if (!sb) {
		printk(KERN_WARNING PREFIX "Unable to map SBF\n");
		return -ENODEV;
	}

612
	sbf_port = sb->cmos_index;	/* Save CMOS port */
Linus Torvalds's avatar
Linus Torvalds committed
613 614 615 616 617 618

	return 0;
}

#ifdef CONFIG_HPET_TIMER

619
static int __init acpi_parse_hpet(struct acpi_table_header *table)
Linus Torvalds's avatar
Linus Torvalds committed
620 621
{
	struct acpi_table_hpet *hpet_tbl;
622 623
	struct resource *hpet_res;
	resource_size_t res_start;
Linus Torvalds's avatar
Linus Torvalds committed
624

625
	hpet_tbl = (struct acpi_table_hpet *)table;
Linus Torvalds's avatar
Linus Torvalds committed
626 627 628 629 630
	if (!hpet_tbl) {
		printk(KERN_WARNING PREFIX "Unable to map HPET\n");
		return -ENODEV;
	}

631
	if (hpet_tbl->address.space_id != ACPI_SPACE_MEM) {
Linus Torvalds's avatar
Linus Torvalds committed
632 633 634 635
		printk(KERN_WARNING PREFIX "HPET timers must be located in "
		       "memory.\n");
		return -1;
	}
636 637 638 639 640 641 642 643

#define HPET_RESOURCE_NAME_SIZE 9
	hpet_res = alloc_bootmem(sizeof(*hpet_res) + HPET_RESOURCE_NAME_SIZE);
	if (hpet_res) {
		memset(hpet_res, 0, sizeof(*hpet_res));
		hpet_res->name = (void *)&hpet_res[1];
		hpet_res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
		snprintf((char *)hpet_res->name, HPET_RESOURCE_NAME_SIZE,
644
			 "HPET %u", hpet_tbl->sequence);
645 646 647
		hpet_res->end = (1 * 1024) - 1;
	}

648 649
#ifdef CONFIG_X86_64
	vxtime.hpet_address = hpet_tbl->address.address;
Linus Torvalds's avatar
Linus Torvalds committed
650

Len Brown's avatar
Len Brown committed
651
	printk(KERN_INFO PREFIX "HPET id: %#x base: %#lx\n",
652
		hpet_tbl->id, vxtime.hpet_address);
653 654

	res_start = vxtime.hpet_address;
655
#else                          /* X86 */
Linus Torvalds's avatar
Linus Torvalds committed
656 657 658
	{
		extern unsigned long hpet_address;

659
		hpet_address = hpet_tbl->address.address;
Linus Torvalds's avatar
Linus Torvalds committed
660
		printk(KERN_INFO PREFIX "HPET id: %#x base: %#lx\n",
661
			hpet_tbl->id, hpet_address);
662 663

		res_start = hpet_address;
Linus Torvalds's avatar
Linus Torvalds committed
664
	}
665
#endif                         /* X86 */
Linus Torvalds's avatar
Linus Torvalds committed
666

667 668 669 670 671 672
	if (hpet_res) {
		hpet_res->start = res_start;
		hpet_res->end += res_start;
		insert_resource(&iomem_resource, hpet_res);
	}

Linus Torvalds's avatar
Linus Torvalds committed
673 674 675 676 677 678 679 680 681 682
	return 0;
}
#else
#define	acpi_parse_hpet	NULL
#endif

#ifdef CONFIG_X86_PM_TIMER
extern u32 pmtmr_ioport;
#endif

683
static int __init acpi_parse_fadt(struct acpi_table_header *table)
Linus Torvalds's avatar
Linus Torvalds committed
684
{
Jason Davis's avatar
Jason Davis committed
685

Linus Torvalds's avatar
Linus Torvalds committed
686 687
#ifdef CONFIG_X86_PM_TIMER
	/* detect the location of the ACPI PM Timer */
688
	if (acpi_gbl_FADT.header.revision >= FADT2_REVISION_ID) {
Linus Torvalds's avatar
Linus Torvalds committed
689
		/* FADT rev. 2 */
690
		if (acpi_gbl_FADT.xpm_timer_block.space_id !=
Len Brown's avatar
Len Brown committed
691
		    ACPI_ADR_SPACE_SYSTEM_IO)
Linus Torvalds's avatar
Linus Torvalds committed
692 693
			return 0;

694
		pmtmr_ioport = acpi_gbl_FADT.xpm_timer_block.address;
695 696 697 698 699 700
		/*
		 * "X" fields are optional extensions to the original V1.0
		 * fields, so we must selectively expand V1.0 fields if the
		 * corresponding X field is zero.
	 	 */
		if (!pmtmr_ioport)
701
			pmtmr_ioport = acpi_gbl_FADT.pm_timer_block;
Linus Torvalds's avatar
Linus Torvalds committed
702 703
	} else {
		/* FADT rev. 1 */
704
		pmtmr_ioport = acpi_gbl_FADT.pm_timer_block;
Linus Torvalds's avatar
Linus Torvalds committed
705 706
	}
	if (pmtmr_ioport)
Len Brown's avatar
Len Brown committed
707 708
		printk(KERN_INFO PREFIX "PM-Timer IO Port: %#x\n",
		       pmtmr_ioport);
Linus Torvalds's avatar
Linus Torvalds committed
709 710 711 712
#endif
	return 0;
}

Len Brown's avatar
Len Brown committed
713
unsigned long __init acpi_find_rsdp(void)
Linus Torvalds's avatar
Linus Torvalds committed
714
{
Len Brown's avatar
Len Brown committed
715
	unsigned long rsdp_phys = 0;
Linus Torvalds's avatar
Linus Torvalds committed
716 717

	if (efi_enabled) {
718 719 720 721
		if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
			return efi.acpi20;
		else if (efi.acpi != EFI_INVALID_TABLE_ADDR)
			return efi.acpi;
Linus Torvalds's avatar
Linus Torvalds committed
722 723 724 725 726
	}
	/*
	 * Scan memory looking for the RSDP signature. First search EBDA (low
	 * memory) paragraphs and then search upper memory (E0000-FFFFF).
	 */
Len Brown's avatar
Len Brown committed
727
	rsdp_phys = acpi_scan_rsdp(0, 0x400);
Linus Torvalds's avatar
Linus Torvalds committed
728
	if (!rsdp_phys)
Len Brown's avatar
Len Brown committed
729
		rsdp_phys = acpi_scan_rsdp(0xE0000, 0x20000);
Linus Torvalds's avatar
Linus Torvalds committed
730 731 732 733 734 735 736 737 738

	return rsdp_phys;
}

#ifdef	CONFIG_X86_LOCAL_APIC
/*
 * Parse LAPIC entries in MADT
 * returns 0 on success, < 0 on error
 */
Len Brown's avatar
Len Brown committed
739
static int __init acpi_parse_madt_lapic_entries(void)
Linus Torvalds's avatar
Linus Torvalds committed
740 741 742
{
	int count;

743 744 745
	if (!cpu_has_apic)
		return -ENODEV;

746
	/*
Linus Torvalds's avatar
Linus Torvalds committed
747 748 749 750
	 * Note that the LAPIC address is obtained from the MADT (32-bit value)
	 * and (optionally) overriden by a LAPIC_ADDR_OVR entry (64-bit value).
	 */

Len Brown's avatar
Len Brown committed
751
	count =
752
	    acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE,
Len Brown's avatar
Len Brown committed
753
				  acpi_parse_lapic_addr_ovr, 0);
Linus Torvalds's avatar
Linus Torvalds committed
754
	if (count < 0) {
Len Brown's avatar
Len Brown committed
755 756
		printk(KERN_ERR PREFIX
		       "Error parsing LAPIC address override entry\n");
Linus Torvalds's avatar
Linus Torvalds committed
757 758 759 760 761
		return count;
	}

	mp_register_lapic_address(acpi_lapic_addr);

762
	count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC, acpi_parse_lapic,
Len Brown's avatar
Len Brown committed
763 764
				      MAX_APICS);
	if (!count) {
Linus Torvalds's avatar
Linus Torvalds committed
765 766 767
		printk(KERN_ERR PREFIX "No LAPIC entries present\n");
		/* TBD: Cleanup to allow fallback to MPS */
		return -ENODEV;
Len Brown's avatar
Len Brown committed
768
	} else if (count < 0) {
Linus Torvalds's avatar
Linus Torvalds committed
769 770 771 772 773
		printk(KERN_ERR PREFIX "Error parsing LAPIC entry\n");
		/* TBD: Cleanup to allow fallback to MPS */
		return count;
	}

Len Brown's avatar
Len Brown committed
774
	count =
775
	    acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_NMI, acpi_parse_lapic_nmi, 0);
Linus Torvalds's avatar
Linus Torvalds committed
776 777 778 779 780 781 782
	if (count < 0) {
		printk(KERN_ERR PREFIX "Error parsing LAPIC NMI entry\n");
		/* TBD: Cleanup to allow fallback to MPS */
		return count;
	}
	return 0;
}
Len Brown's avatar
Len Brown committed
783
#endif				/* CONFIG_X86_LOCAL_APIC */
Linus Torvalds's avatar
Linus Torvalds committed
784

785
#ifdef	CONFIG_X86_IO_APIC
Linus Torvalds's avatar
Linus Torvalds committed
786 787 788 789
/*
 * Parse IOAPIC related entries in MADT
 * returns 0 on success, < 0 on error
 */
Len Brown's avatar
Len Brown committed
790
static int __init acpi_parse_madt_ioapic_entries(void)
Linus Torvalds's avatar
Linus Torvalds committed
791 792 793 794 795 796 797 798 799 800 801
{
	int count;

	/*
	 * ACPI interpreter is required to complete interrupt setup,
	 * so if it is off, don't enumerate the io-apics with ACPI.
	 * If MPS is present, it will handle them,
	 * otherwise the system will stay in PIC mode
	 */
	if (acpi_disabled || acpi_noirq) {
		return -ENODEV;
Len Brown's avatar
Len Brown committed
802
	}
Linus Torvalds's avatar
Linus Torvalds committed
803

804
	if (!cpu_has_apic)
805 806
		return -ENODEV;

Linus Torvalds's avatar
Linus Torvalds committed
807
	/*
Len Brown's avatar
Len Brown committed
808
	 * if "noapic" boot option, don't look for IO-APICs
Linus Torvalds's avatar
Linus Torvalds committed
809 810 811
	 */
	if (skip_ioapic_setup) {
		printk(KERN_INFO PREFIX "Skipping IOAPIC probe "
Len Brown's avatar
Len Brown committed
812
		       "due to 'noapic' option.\n");
Linus Torvalds's avatar
Linus Torvalds committed
813 814 815
		return -ENODEV;
	}

Len Brown's avatar
Len Brown committed
816
	count =
817
	    acpi_table_parse_madt(ACPI_MADT_TYPE_IO_APIC, acpi_parse_ioapic,
Len Brown's avatar
Len Brown committed
818
				  MAX_IO_APICS);
Linus Torvalds's avatar
Linus Torvalds committed
819 820 821
	if (!count) {
		printk(KERN_ERR PREFIX "No IOAPIC entries present\n");
		return -ENODEV;
Len Brown's avatar
Len Brown committed
822
	} else if (count < 0) {
Linus Torvalds's avatar
Linus Torvalds committed
823 824 825 826
		printk(KERN_ERR PREFIX "Error parsing IOAPIC entry\n");
		return count;
	}

Len Brown's avatar
Len Brown committed
827
	count =
828
	    acpi_table_parse_madt(ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, acpi_parse_int_src_ovr,
Len Brown's avatar
Len Brown committed
829
				  NR_IRQ_VECTORS);
Linus Torvalds's avatar
Linus Torvalds committed
830
	if (count < 0) {
Len Brown's avatar
Len Brown committed
831 832
		printk(KERN_ERR PREFIX
		       "Error parsing interrupt source overrides entry\n");
Linus Torvalds's avatar
Linus Torvalds committed
833 834 835 836 837 838 839 840 841
		/* TBD: Cleanup to allow fallback to MPS */
		return count;
	}

	/*
	 * If BIOS did not supply an INT_SRC_OVR for the SCI
	 * pretend we got one so we can set the SCI flags.
	 */
	if (!acpi_sci_override_gsi)
842
		acpi_sci_ioapic_setup(acpi_gbl_FADT.sci_interrupt, 0, 0);
Linus Torvalds's avatar
Linus Torvalds committed
843 844 845 846

	/* Fill in identity legacy mapings where no override */
	mp_config_acpi_legacy_irqs();

Len Brown's avatar
Len Brown committed
847
	count =
848
	    acpi_table_parse_madt(ACPI_MADT_TYPE_NMI_SOURCE, acpi_parse_nmi_src,
Len Brown's avatar
Len Brown committed
849
				  NR_IRQ_VECTORS);
Linus Torvalds's avatar
Linus Torvalds committed
850 851 852 853 854 855 856 857 858 859 860 861 862
	if (count < 0) {
		printk(KERN_ERR PREFIX "Error parsing NMI SRC entry\n");
		/* TBD: Cleanup to allow fallback to MPS */
		return count;
	}

	return 0;
}
#else
static inline int acpi_parse_madt_ioapic_entries(void)
{
	return -1;
}
863
#endif	/* !CONFIG_X86_IO_APIC */
Linus Torvalds's avatar
Linus Torvalds committed
864

Len Brown's avatar
Len Brown committed
865
static void __init acpi_process_madt(void)
Linus Torvalds's avatar
Linus Torvalds committed
866 867
{
#ifdef CONFIG_X86_LOCAL_APIC
868
	int error;
Linus Torvalds's avatar
Linus Torvalds committed
869

870
	if (!acpi_table_parse(ACPI_SIG_MADT, acpi_parse_madt)) {
Linus Torvalds's avatar
Linus Torvalds committed
871 872 873 874 875 876 877 878

		/*
		 * Parse MADT LAPIC entries
		 */
		error = acpi_parse_madt_lapic_entries();
		if (!error) {
			acpi_lapic = 1;

879 880 881
#ifdef CONFIG_X86_GENERICARCH
			generic_bigsmp_probe();
#endif
Linus Torvalds's avatar
Linus Torvalds committed
882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898
			/*
			 * Parse MADT IO-APIC entries
			 */
			error = acpi_parse_madt_ioapic_entries();
			if (!error) {
				acpi_irq_model = ACPI_IRQ_MODEL_IOAPIC;
				acpi_irq_balance_set(NULL);
				acpi_ioapic = 1;

				smp_found_config = 1;
				clustered_apic_check();
			}
		}
		if (error == -EINVAL) {
			/*
			 * Dell Precision Workstation 410, 610 come here.
			 */
Len Brown's avatar
Len Brown committed
899 900
			printk(KERN_ERR PREFIX
			       "Invalid BIOS MADT, disabling ACPI\n");
Linus Torvalds's avatar
Linus Torvalds committed
901 902 903 904 905 906 907
			disable_acpi();
		}
	}
#endif
	return;
}

908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932
#ifdef __i386__

static int __init disable_acpi_irq(struct dmi_system_id *d)
{
	if (!acpi_force) {
		printk(KERN_NOTICE "%s detected: force use of acpi=noirq\n",
		       d->ident);
		acpi_noirq_set();
	}
	return 0;
}

static int __init disable_acpi_pci(struct dmi_system_id *d)
{
	if (!acpi_force) {
		printk(KERN_NOTICE "%s detected: force use of pci=noacpi\n",
		       d->ident);
		acpi_disable_pci();
	}
	return 0;
}

static int __init dmi_disable_acpi(struct dmi_system_id *d)
{
	if (!acpi_force) {
Len Brown's avatar
Len Brown committed
933
		printk(KERN_NOTICE "%s detected: acpi off\n", d->ident);
934 935 936 937 938 939 940 941 942 943 944 945 946 947
		disable_acpi();
	} else {
		printk(KERN_NOTICE
		       "Warning: DMI blacklist says broken, but acpi forced\n");
	}
	return 0;
}

/*
 * Limit ACPI to CPU enumeration for HT
 */
static int __init force_acpi_ht(struct dmi_system_id *d)
{
	if (!acpi_force) {
Len Brown's avatar
Len Brown committed
948 949
		printk(KERN_NOTICE "%s detected: force use of acpi=ht\n",
		       d->ident);
950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967
		disable_acpi();
		acpi_ht = 1;
	} else {
		printk(KERN_NOTICE
		       "Warning: acpi=force overrules DMI blacklist: acpi=ht\n");
	}
	return 0;
}

/*
 * If your system is blacklisted here, but you find that acpi=force
 * works for you, please contact acpi-devel@sourceforge.net
 */
static struct dmi_system_id __initdata acpi_dmi_table[] = {
	/*
	 * Boxes that need ACPI disabled
	 */
	{
Len Brown's avatar
Len Brown committed
968 969 970 971 972 973 974
	 .callback = dmi_disable_acpi,
	 .ident = "IBM Thinkpad",
	 .matches = {
		     DMI_MATCH(DMI_BOARD_VENDOR, "IBM"),
		     DMI_MATCH(DMI_BOARD_NAME, "2629H1G"),
		     },
	 },
975 976 977 978 979

	/*
	 * Boxes that need acpi=ht
	 */
	{
Len Brown's avatar
Len Brown committed
980 981 982 983 984 985 986
	 .callback = force_acpi_ht,
	 .ident = "FSC Primergy T850",
	 .matches = {
		     DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
		     DMI_MATCH(DMI_PRODUCT_NAME, "PRIMERGY T850"),
		     },
	 },
987
	{
Len Brown's avatar
Len Brown committed
988 989 990 991 992 993 994
	 .callback = force_acpi_ht,
	 .ident = "DELL GX240",
	 .matches = {
		     DMI_MATCH(DMI_BOARD_VENDOR, "Dell Computer Corporation"),
		     DMI_MATCH(DMI_BOARD_NAME, "OptiPlex GX240"),
		     },
	 },
995
	{
Len Brown's avatar
Len Brown committed
996 997 998 999 1000 1001 1002
	 .callback = force_acpi_ht,
	 .ident = "HP VISUALIZE NT Workstation",
	 .matches = {
		     DMI_MATCH(DMI_BOARD_VENDOR, "Hewlett-Packard"),
		     DMI_MATCH(DMI_PRODUCT_NAME, "HP VISUALIZE NT Workstation"),
		     },
	 },
1003
	{
Len Brown's avatar
Len Brown committed
1004 1005 1006 1007 1008 1009 1010
	 .callback = force_acpi_ht,
	 .ident = "Compaq Workstation W8000",
	 .matches = {
		     DMI_MATCH(DMI_SYS_VENDOR, "Compaq"),
		     DMI_MATCH(DMI_PRODUCT_NAME, "Workstation W8000"),
		     },
	 },
1011
	{
Len Brown's avatar
Len Brown committed
1012 1013 1014 1015 1016 1017 1018
	 .callback = force_acpi_ht,
	 .ident = "ASUS P4B266",
	 .matches = {
		     DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
		     DMI_MATCH(DMI_BOARD_NAME, "P4B266"),
		     },
	 },
1019
	{
Len Brown's avatar
Len Brown committed
1020 1021 1022 1023 1024 1025 1026
	 .callback = force_acpi_ht,
	 .ident = "ASUS P2B-DS",
	 .matches = {
		     DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
		     DMI_MATCH(DMI_BOARD_NAME, "P2B-DS"),
		     },
	 },
1027
	{
Len Brown's avatar
Len Brown committed
1028 1029 1030 1031 1032 1033 1034
	 .callback = force_acpi_ht,
	 .ident = "ASUS CUR-DLS",
	 .matches = {
		     DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
		     DMI_MATCH(DMI_BOARD_NAME, "CUR-DLS"),
		     },
	 },
1035
	{
Len Brown's avatar
Len Brown committed
1036 1037 1038 1039 1040 1041 1042
	 .callback = force_acpi_ht,
	 .ident = "ABIT i440BX-W83977",
	 .matches = {
		     DMI_MATCH(DMI_BOARD_VENDOR, "ABIT <http://www.abit.com>"),
		     DMI_MATCH(DMI_BOARD_NAME, "i440BX-W83977 (BP6)"),
		     },
	 },
1043
	{
Len Brown's avatar
Len Brown committed
1044 1045 1046 1047 1048 1049 1050
	 .callback = force_acpi_ht,
	 .ident = "IBM Bladecenter",
	 .matches = {
		     DMI_MATCH(DMI_BOARD_VENDOR, "IBM"),
		     DMI_MATCH(DMI_BOARD_NAME, "IBM eServer BladeCenter HS20"),
		     },
	 },
1051
	{
Len Brown's avatar
Len Brown committed
1052 1053 1054 1055 1056 1057 1058
	 .callback = force_acpi_ht,
	 .ident = "IBM eServer xSeries 360",
	 .matches = {
		     DMI_MATCH(DMI_BOARD_VENDOR, "IBM"),
		     DMI_MATCH(DMI_BOARD_NAME, "eServer xSeries 360"),
		     },
	 },
1059
	{
Len Brown's avatar
Len Brown committed
1060 1061 1062 1063 1064 1065 1066
	 .callback = force_acpi_ht,
	 .ident = "IBM eserver xSeries 330",
	 .matches = {
		     DMI_MATCH(DMI_BOARD_VENDOR, "IBM"),
		     DMI_MATCH(DMI_BOARD_NAME, "eserver xSeries 330"),
		     },
	 },
1067
	{
Len Brown's avatar
Len Brown committed
1068 1069 1070 1071 1072 1073 1074
	 .callback = force_acpi_ht,
	 .ident = "IBM eserver xSeries 440",
	 .matches = {
		     DMI_MATCH(DMI_BOARD_VENDOR, "IBM"),
		     DMI_MATCH(DMI_PRODUCT_NAME, "eserver xSeries 440"),
		     },
	 },
1075 1076 1077 1078 1079

	/*
	 * Boxes that need ACPI PCI IRQ routing disabled
	 */
	{
Len Brown's avatar
Len Brown committed
1080 1081 1082 1083 1084 1085 1086 1087 1088 1089
	 .callback = disable_acpi_irq,
	 .ident = "ASUS A7V",
	 .matches = {
		     DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC"),
		     DMI_MATCH(DMI_BOARD_NAME, "<A7V>"),
		     /* newer BIOS, Revision 1011, does work */
		     DMI_MATCH(DMI_BIOS_VERSION,
			       "ASUS A7V ACPI BIOS Revision 1007"),
		     },
	 },
1090 1091 1092 1093

	/*
	 * Boxes that need ACPI PCI IRQ routing and PCI scan disabled
	 */
Len Brown's avatar
Len Brown committed
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104
	{			/* _BBN 0 bug */
	 .callback = disable_acpi_pci,
	 .ident = "ASUS PR-DLS",
	 .matches = {
		     DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
		     DMI_MATCH(DMI_BOARD_NAME, "PR-DLS"),
		     DMI_MATCH(DMI_BIOS_VERSION,
			       "ASUS PR-DLS ACPI BIOS Revision 1010"),
		     DMI_MATCH(DMI_BIOS_DATE, "03/21/2003")
		     },
	 },
1105
	{
Len Brown's avatar
Len Brown committed
1106 1107 1108 1109 1110 1111 1112 1113
	 .callback = disable_acpi_pci,
	 .ident = "Acer TravelMate 36x Laptop",
	 .matches = {
		     DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
		     DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 360"),
		     },
	 },
	{}
1114 1115
};

Len Brown's avatar
Len Brown committed
1116
#endif				/* __i386__ */
1117

Linus Torvalds's avatar
Linus Torvalds committed
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140
/*
 * acpi_boot_table_init() and acpi_boot_init()
 *  called from setup_arch(), always.
 *	1. checksums all tables
 *	2. enumerates lapics
 *	3. enumerates io-apics
 *
 * acpi_table_init() is separate to allow reading SRAT without
 * other side effects.
 *
 * side effects of acpi_boot_init:
 *	acpi_lapic = 1 if LAPIC found
 *	acpi_ioapic = 1 if IOAPIC found
 *	if (acpi_lapic && acpi_ioapic) smp_found_config = 1;
 *	if acpi_blacklisted() acpi_disabled = 1;
 *	acpi_irq_model=...
 *	...
 *
 * return value: (currently ignored)
 *	0: success
 *	!0: failure
 */

Len Brown's avatar
Len Brown committed
1141
int __init acpi_boot_table_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
1142 1143 1144
{
	int error;

1145 1146 1147 1148
#ifdef __i386__
	dmi_check_system(acpi_dmi_table);
#endif

Linus Torvalds's avatar
Linus Torvalds committed
1149 1150 1151 1152 1153
	/*
	 * If acpi_disabled, bail out
	 * One exception: acpi=ht continues far enough to enumerate LAPICs
	 */
	if (acpi_disabled && !acpi_ht)
Len Brown's avatar
Len Brown committed
1154
		return 1;
Linus Torvalds's avatar
Linus Torvalds committed
1155

1156
	/*
Linus Torvalds's avatar
Linus Torvalds committed
1157 1158 1159 1160 1161 1162 1163 1164
	 * Initialize the ACPI boot-time table parser.
	 */
	error = acpi_table_init();
	if (error) {
		disable_acpi();
		return error;
	}

1165
	acpi_table_parse(ACPI_SIG_BOOT, acpi_parse_sbf);
Linus Torvalds's avatar
Linus Torvalds committed
1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190

	/*
	 * blacklist may disable ACPI entirely
	 */
	error = acpi_blacklisted();
	if (error) {
		if (acpi_force) {
			printk(KERN_WARNING PREFIX "acpi=force override\n");
		} else {
			printk(KERN_WARNING PREFIX "Disabling ACPI support\n");
			disable_acpi();
			return error;
		}
	}

	return 0;
}

int __init acpi_boot_init(void)
{
	/*
	 * If acpi_disabled, bail out
	 * One exception: acpi=ht continues far enough to enumerate LAPICs
	 */
	if (acpi_disabled && !acpi_ht)
Len Brown's avatar
Len Brown committed
1191
		return 1;
Linus Torvalds's avatar
Linus Torvalds committed
1192

1193
	acpi_table_parse(ACPI_SIG_BOOT, acpi_parse_sbf);
Linus Torvalds's avatar
Linus Torvalds committed
1194 1195 1196 1197

	/*
	 * set sci_int and PM timer address
	 */
1198
	acpi_table_parse(ACPI_SIG_FADT, acpi_parse_fadt);
Linus Torvalds's avatar
Linus Torvalds committed
1199 1200 1201 1202 1203 1204

	/*
	 * Process the Multiple APIC Description Table (MADT), if present
	 */
	acpi_process_madt();

1205
	acpi_table_parse(ACPI_SIG_HPET, acpi_parse_hpet);
Linus Torvalds's avatar
Linus Torvalds committed
1206 1207 1208

	return 0;
}
1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261

static int __init parse_acpi(char *arg)
{
	if (!arg)
		return -EINVAL;

	/* "acpi=off" disables both ACPI table parsing and interpreter */
	if (strcmp(arg, "off") == 0) {
		disable_acpi();
	}
	/* acpi=force to over-ride black-list */
	else if (strcmp(arg, "force") == 0) {
		acpi_force = 1;
		acpi_ht = 1;
		acpi_disabled = 0;
	}
	/* acpi=strict disables out-of-spec workarounds */
	else if (strcmp(arg, "strict") == 0) {
		acpi_strict = 1;
	}
	/* Limit ACPI just to boot-time to enable HT */
	else if (strcmp(arg, "ht") == 0) {
		if (!acpi_force)
			disable_acpi();
		acpi_ht = 1;
	}
	/* "acpi=noirq" disables ACPI interrupt routing */
	else if (strcmp(arg, "noirq") == 0) {
		acpi_noirq_set();
	} else {
		/* Core will printk when we return error. */
		return -EINVAL;
	}
	return 0;
}
early_param("acpi", parse_acpi);

/* FIXME: Using pci= for an ACPI parameter is a travesty. */
static int __init parse_pci(char *arg)
{
	if (arg && strcmp(arg, "noacpi") == 0)
		acpi_disable_pci();
	return 0;
}
early_param("pci", parse_pci);

#ifdef CONFIG_X86_IO_APIC
static int __init parse_acpi_skip_timer_override(char *arg)
{
	acpi_skip_timer_override = 1;
	return 0;
}
early_param("acpi_skip_timer_override", parse_acpi_skip_timer_override);
1262 1263 1264 1265 1266 1267 1268

static int __init parse_acpi_use_timer_override(char *arg)
{
	acpi_use_timer_override = 1;
	return 0;
}
early_param("acpi_use_timer_override", parse_acpi_use_timer_override);
1269 1270 1271 1272 1273 1274 1275
#endif /* CONFIG_X86_IO_APIC */

static int __init setup_acpi_sci(char *s)
{
	if (!s)
		return -EINVAL;
	if (!strcmp(s, "edge"))
1276 1277
		acpi_sci_flags =  ACPI_MADT_TRIGGER_EDGE |
			(acpi_sci_flags & ~ACPI_MADT_TRIGGER_MASK);
1278
	else if (!strcmp(s, "level"))
1279 1280
		acpi_sci_flags = ACPI_MADT_TRIGGER_LEVEL |
			(acpi_sci_flags & ~ACPI_MADT_TRIGGER_MASK);
1281
	else if (!strcmp(s, "high"))
1282 1283
		acpi_sci_flags = ACPI_MADT_POLARITY_ACTIVE_HIGH |
			(acpi_sci_flags & ~ACPI_MADT_POLARITY_MASK);
1284
	else if (!strcmp(s, "low"))
1285 1286
		acpi_sci_flags = ACPI_MADT_POLARITY_ACTIVE_LOW |
			(acpi_sci_flags & ~ACPI_MADT_POLARITY_MASK);
1287 1288 1289 1290 1291
	else
		return -EINVAL;
	return 0;
}
early_param("acpi_sci", setup_acpi_sci);
1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313

int __acpi_acquire_global_lock(unsigned int *lock)
{
	unsigned int old, new, val;
	do {
		old = *lock;
		new = (((old & ~0x3) + 2) + ((old >> 1) & 0x1));
		val = cmpxchg(lock, old, new);
	} while (unlikely (val != old));
	return (new < 3) ? -1 : 0;
}

int __acpi_release_global_lock(unsigned int *lock)
{
	unsigned int old, new, val;
	do {
		old = *lock;
		new = old & ~0x3;
		val = cmpxchg(lock, old, new);
	} while (unlikely (val != old));
	return old & 0x1;
}