boot.c 45.6 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
/*
 *  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>
28
#include <linux/acpi_pmtmr.h>
Linus Torvalds's avatar
Linus Torvalds committed
29
#include <linux/efi.h>
30
#include <linux/cpumask.h>
Linus Torvalds's avatar
Linus Torvalds committed
31
#include <linux/module.h>
32
#include <linux/dmi.h>
33
#include <linux/irq.h>
34 35
#include <linux/bootmem.h>
#include <linux/ioport.h>
Linus Torvalds's avatar
Linus Torvalds committed
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
#include <asm/smp.h>
Linus Torvalds's avatar
Linus Torvalds committed
43

44
static int __initdata acpi_force = 0;
45
u32 acpi_rsdt_forced;
46 47 48 49 50 51 52
#ifdef	CONFIG_ACPI
int acpi_disabled = 0;
#else
int acpi_disabled = 1;
#endif
EXPORT_SYMBOL(acpi_disabled);

Linus Torvalds's avatar
Linus Torvalds committed
53
#ifdef	CONFIG_X86_64
Ingo Molnar's avatar
Ingo Molnar committed
54
# include <asm/proto.h>
Len Brown's avatar
Len Brown committed
55
#endif				/* X86 */
Linus Torvalds's avatar
Linus Torvalds committed
56 57 58

#define BAD_MADT_ENTRY(entry, end) (					    \
		(!entry) || (unsigned long)entry + sizeof(*entry) > end ||  \
59
		((struct acpi_subtable_header *)entry)->length < sizeof(*entry))
Linus Torvalds's avatar
Linus Torvalds committed
60 61 62

#define PREFIX			"ACPI: "

Andrew Morton's avatar
Andrew Morton committed
63
int acpi_noirq;				/* skip ACPI IRQ initialization */
64 65
int acpi_pci_disabled;		/* skip ACPI PCI scan and IRQ initialization */
EXPORT_SYMBOL(acpi_pci_disabled);
Linus Torvalds's avatar
Linus Torvalds committed
66 67 68 69 70 71
int acpi_ht __initdata = 1;	/* enable HT */

int acpi_lapic;
int acpi_ioapic;
int acpi_strict;

72
u8 acpi_sci_flags __initdata;
Linus Torvalds's avatar
Linus Torvalds committed
73 74
int acpi_sci_override_gsi __initdata;
int acpi_skip_timer_override __initdata;
75
int acpi_use_timer_override __initdata;
Linus Torvalds's avatar
Linus Torvalds committed
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90

#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
Simon Arlott's avatar
Simon Arlott committed
91
 * overridden if IOAPICs are enumerated (below).
Linus Torvalds's avatar
Linus Torvalds committed
92
 */
Len Brown's avatar
Len Brown committed
93
enum acpi_irq_model_id acpi_irq_model = ACPI_IRQ_MODEL_PIC;
Linus Torvalds's avatar
Linus Torvalds committed
94 95 96 97 98 99 100 101 102 103 104 105 106 107


/*
 * 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.
 */
108
char *__init __acpi_map_table(unsigned long phys, unsigned long size)
Linus Torvalds's avatar
Linus Torvalds committed
109 110
{

Yinghai Lu's avatar
Yinghai Lu committed
111 112 113
	if (!phys || !size)
		return NULL;

114 115 116 117 118 119
	return early_ioremap(phys, size);
}
void __init __acpi_unmap_table(char *map, unsigned long size)
{
	if (!map || !size)
		return;
Linus Torvalds's avatar
Linus Torvalds committed
120

121
	early_iounmap(map, size);
Linus Torvalds's avatar
Linus Torvalds committed
122 123 124
}

#ifdef CONFIG_PCI_MMCONFIG
125 126 127

static int acpi_mcfg_64bit_base_addr __initdata = FALSE;

128
/* The physical address of the MMCONFIG aperture.  Set from ACPI tables. */
129
struct acpi_mcfg_allocation *pci_mmcfg_config;
130 131
int pci_mmcfg_config_num;

132 133 134 135 136 137 138 139
static int __init acpi_mcfg_oem_check(struct acpi_table_mcfg *mcfg)
{
	if (!strcmp(mcfg->header.oem_id, "SGI"))
		acpi_mcfg_64bit_base_addr = TRUE;

	return 0;
}

140
int __init acpi_parse_mcfg(struct acpi_table_header *header)
Linus Torvalds's avatar
Linus Torvalds committed
141 142
{
	struct acpi_table_mcfg *mcfg;
143 144
	unsigned long i;
	int config_size;
Linus Torvalds's avatar
Linus Torvalds committed
145

146
	if (!header)
Linus Torvalds's avatar
Linus Torvalds committed
147 148
		return -EINVAL;

149
	mcfg = (struct acpi_table_mcfg *)header;
Linus Torvalds's avatar
Linus Torvalds committed
150

151 152
	/* how many config structures do we have */
	pci_mmcfg_config_num = 0;
153
	i = header->length - sizeof(struct acpi_table_mcfg);
154
	while (i >= sizeof(struct acpi_mcfg_allocation)) {
155
		++pci_mmcfg_config_num;
156
		i -= sizeof(struct acpi_mcfg_allocation);
157 158 159
	};
	if (pci_mmcfg_config_num == 0) {
		printk(KERN_ERR PREFIX "MMCONFIG has no entries\n");
Linus Torvalds's avatar
Linus Torvalds committed
160 161 162
		return -ENODEV;
	}

163 164 165 166 167 168 169 170
	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;
	}

171
	memcpy(pci_mmcfg_config, &mcfg[1], config_size);
172 173 174

	acpi_mcfg_oem_check(mcfg);

175
	for (i = 0; i < pci_mmcfg_config_num; ++i) {
176 177
		if ((pci_mmcfg_config[i].address > 0xFFFFFFFF) &&
		    !acpi_mcfg_64bit_base_addr) {
178 179
			printk(KERN_ERR PREFIX
			       "MMCONFIG not in low 4GB of memory\n");
180 181
			kfree(pci_mmcfg_config);
			pci_mmcfg_config_num = 0;
182 183 184
			return -ENODEV;
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
185 186 187

	return 0;
}
Len Brown's avatar
Len Brown committed
188
#endif				/* CONFIG_PCI_MMCONFIG */
Linus Torvalds's avatar
Linus Torvalds committed
189 190

#ifdef CONFIG_X86_LOCAL_APIC
191
static int __init acpi_parse_madt(struct acpi_table_header *table)
Linus Torvalds's avatar
Linus Torvalds committed
192
{
Len Brown's avatar
Len Brown committed
193
	struct acpi_table_madt *madt = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
194

195
	if (!cpu_has_apic)
Linus Torvalds's avatar
Linus Torvalds committed
196 197
		return -EINVAL;

198
	madt = (struct acpi_table_madt *)table;
Linus Torvalds's avatar
Linus Torvalds committed
199 200 201 202 203
	if (!madt) {
		printk(KERN_WARNING PREFIX "Unable to map MADT\n");
		return -ENODEV;
	}

204 205
	if (madt->address) {
		acpi_lapic_addr = (u64) madt->address;
Linus Torvalds's avatar
Linus Torvalds committed
206 207

		printk(KERN_DEBUG PREFIX "Local APIC address 0x%08x\n",
208
		       madt->address);
Linus Torvalds's avatar
Linus Torvalds committed
209 210
	}

211 212
	default_acpi_madt_oem_check(madt->header.oem_id,
				    madt->header.oem_table_id);
Len Brown's avatar
Len Brown committed
213

Linus Torvalds's avatar
Linus Torvalds committed
214 215 216
	return 0;
}

217 218
static void __cpuinit acpi_register_lapic(int id, u8 enabled)
{
Yinghai Lu's avatar
Yinghai Lu committed
219 220
	unsigned int ver = 0;

221 222 223 224 225
	if (!enabled) {
		++disabled_cpus;
		return;
	}

Yinghai Lu's avatar
Yinghai Lu committed
226 227 228 229
	if (boot_cpu_physical_apicid != -1U)
		ver = apic_version[boot_cpu_physical_apicid];

	generic_processor_info(id, ver);
230 231
}

232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
static int __init
acpi_parse_x2apic(struct acpi_subtable_header *header, const unsigned long end)
{
	struct acpi_madt_local_x2apic *processor = NULL;

	processor = (struct acpi_madt_local_x2apic *)header;

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

	acpi_table_print_madt_entry(header);

#ifdef CONFIG_X86_X2APIC
	/*
	 * 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.
	 */
	acpi_register_lapic(processor->local_apic_id,	/* APIC ID */
			    processor->lapic_flags & ACPI_MADT_ENABLED);
#else
	printk(KERN_WARNING PREFIX "x2apic entry ignored\n");
#endif

	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
261
static int __init
262
acpi_parse_lapic(struct acpi_subtable_header * header, const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
263
{
264
	struct acpi_madt_local_apic *processor = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
265

266
	processor = (struct acpi_madt_local_apic *)header;
Linus Torvalds's avatar
Linus Torvalds committed
267 268 269 270 271 272

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

	acpi_table_print_madt_entry(header);

273 274 275 276 277 278 279
	/*
	 * 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.
	 */
280 281
	acpi_register_lapic(processor->id,	/* APIC ID */
			    processor->lapic_flags & ACPI_MADT_ENABLED);
Linus Torvalds's avatar
Linus Torvalds committed
282 283 284 285

	return 0;
}

286 287 288 289 290 291 292 293 294 295 296 297
static int __init
acpi_parse_sapic(struct acpi_subtable_header *header, const unsigned long end)
{
	struct acpi_madt_local_sapic *processor = NULL;

	processor = (struct acpi_madt_local_sapic *)header;

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

	acpi_table_print_madt_entry(header);

298 299
	acpi_register_lapic((processor->id << 8) | processor->eid,/* APIC ID */
			    processor->lapic_flags & ACPI_MADT_ENABLED);
300 301 302 303

	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
304
static int __init
305
acpi_parse_lapic_addr_ovr(struct acpi_subtable_header * header,
Len Brown's avatar
Len Brown committed
306
			  const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
307
{
308
	struct acpi_madt_local_apic_override *lapic_addr_ovr = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
309

310
	lapic_addr_ovr = (struct acpi_madt_local_apic_override *)header;
Linus Torvalds's avatar
Linus Torvalds committed
311 312 313 314 315 316 317 318 319

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

	acpi_lapic_addr = lapic_addr_ovr->address;

	return 0;
}

320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338
static int __init
acpi_parse_x2apic_nmi(struct acpi_subtable_header *header,
		      const unsigned long end)
{
	struct acpi_madt_local_x2apic_nmi *x2apic_nmi = NULL;

	x2apic_nmi = (struct acpi_madt_local_x2apic_nmi *)header;

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

	acpi_table_print_madt_entry(header);

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

	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
339
static int __init
340
acpi_parse_lapic_nmi(struct acpi_subtable_header * header, const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
341
{
342
	struct acpi_madt_local_apic_nmi *lapic_nmi = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
343

344
	lapic_nmi = (struct acpi_madt_local_apic_nmi *)header;
Linus Torvalds's avatar
Linus Torvalds committed
345 346 347 348 349 350 351 352 353 354 355 356

	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
357
#endif				/*CONFIG_X86_LOCAL_APIC */
Linus Torvalds's avatar
Linus Torvalds committed
358

359
#ifdef CONFIG_X86_IO_APIC
Linus Torvalds's avatar
Linus Torvalds committed
360 361

static int __init
362
acpi_parse_ioapic(struct acpi_subtable_header * header, const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
363
{
364
	struct acpi_madt_io_apic *ioapic = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
365

366
	ioapic = (struct acpi_madt_io_apic *)header;
Linus Torvalds's avatar
Linus Torvalds committed
367 368 369

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

Linus Torvalds's avatar
Linus Torvalds committed
371 372
	acpi_table_print_madt_entry(header);

Len Brown's avatar
Len Brown committed
373 374 375
	mp_register_ioapic(ioapic->id,
			   ioapic->address, ioapic->global_irq_base);

Linus Torvalds's avatar
Linus Torvalds committed
376 377 378 379 380 381
	return 0;
}

/*
 * Parse Interrupt Source Override for the ACPI SCI
 */
382
static void __init acpi_sci_ioapic_setup(u32 gsi, u16 polarity, u16 trigger)
Linus Torvalds's avatar
Linus Torvalds committed
383 384 385 386 387 388 389 390
{
	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= */
391 392
	if (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)
		trigger = (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2;
Linus Torvalds's avatar
Linus Torvalds committed
393

394 395
	if (acpi_sci_flags & ACPI_MADT_POLARITY_MASK)
		polarity = acpi_sci_flags & ACPI_MADT_POLARITY_MASK;
Linus Torvalds's avatar
Linus Torvalds committed
396 397

	/*
Len Brown's avatar
Len Brown committed
398
	 * mp_config_acpi_legacy_irqs() already setup IRQs < 16
Linus Torvalds's avatar
Linus Torvalds committed
399 400 401
	 * If GSI is < 16, this will update its flags,
	 * else it will create a new mp_irqs[] entry.
	 */
402
	mp_override_legacy_irq(gsi, polarity, trigger, gsi);
Linus Torvalds's avatar
Linus Torvalds committed
403 404 405

	/*
	 * stash over-ride to indicate we've been here
406
	 * and for later update of acpi_gbl_FADT
Linus Torvalds's avatar
Linus Torvalds committed
407
	 */
408
	acpi_sci_override_gsi = gsi;
Linus Torvalds's avatar
Linus Torvalds committed
409 410 411 412
	return;
}

static int __init
413
acpi_parse_int_src_ovr(struct acpi_subtable_header * header,
Len Brown's avatar
Len Brown committed
414
		       const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
415
{
416
	struct acpi_madt_interrupt_override *intsrc = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
417

418
	intsrc = (struct acpi_madt_interrupt_override *)header;
Linus Torvalds's avatar
Linus Torvalds committed
419 420 421 422 423 424

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

	acpi_table_print_madt_entry(header);

425
	if (intsrc->source_irq == acpi_gbl_FADT.sci_interrupt) {
426
		acpi_sci_ioapic_setup(intsrc->global_irq,
427 428
				      intsrc->inti_flags & ACPI_MADT_POLARITY_MASK,
				      (intsrc->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2);
Linus Torvalds's avatar
Linus Torvalds committed
429 430 431 432
		return 0;
	}

	if (acpi_skip_timer_override &&
433
	    intsrc->source_irq == 0 && intsrc->global_irq == 2) {
Len Brown's avatar
Len Brown committed
434 435
		printk(PREFIX "BIOS IRQ0 pin2 override ignored.\n");
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
436 437
	}

438 439 440 441
	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
442 443 444 445 446

	return 0;
}

static int __init
447
acpi_parse_nmi_src(struct acpi_subtable_header * header, const unsigned long end)
Linus Torvalds's avatar
Linus Torvalds committed
448
{
449
	struct acpi_madt_nmi_source *nmi_src = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
450

451
	nmi_src = (struct acpi_madt_nmi_source *)header;
Linus Torvalds's avatar
Linus Torvalds committed
452 453 454 455 456 457 458 459 460 461 462

	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
463
#endif				/* CONFIG_X86_IO_APIC */
Linus Torvalds's avatar
Linus Torvalds committed
464 465 466

/*
 * acpi_pic_sci_set_trigger()
467
 *
Linus Torvalds's avatar
Linus Torvalds committed
468 469 470 471 472 473 474
 * 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.
Simon Arlott's avatar
Simon Arlott committed
475 476
 * ECLR1 is IRQs 0-7 (IRQ 0, 1, 2 must be 0)
 * ECLR2 is IRQs 8-15 (IRQ 8, 13 must be 0)
Linus Torvalds's avatar
Linus Torvalds committed
477 478
 */

Len Brown's avatar
Len Brown committed
479
void __init acpi_pic_sci_set_trigger(unsigned int irq, u16 trigger)
Linus Torvalds's avatar
Linus Torvalds committed
480 481 482 483 484 485 486 487
{
	unsigned int mask = 1 << irq;
	unsigned int old, new;

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

	/*
Simon Arlott's avatar
Simon Arlott committed
488
	 * If we use ACPI to set PCI IRQs, then we should clear ELCR
Linus Torvalds's avatar
Linus Torvalds committed
489 490 491 492 493 494 495 496 497 498
	 * 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
499
	case 1:		/* Edge - clear */
Linus Torvalds's avatar
Linus Torvalds committed
500 501
		new &= ~mask;
		break;
Len Brown's avatar
Len Brown committed
502
	case 3:		/* Level - set */
Linus Torvalds's avatar
Linus Torvalds committed
503 504 505 506 507 508 509 510 511 512 513 514 515 516
		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)
{
517
	*irq = gsi;
Linus Torvalds's avatar
Linus Torvalds committed
518 519 520
	return 0;
}

521 522 523 524
/*
 * success: return IRQ number (>=0)
 * failure: return < 0
 */
525
int acpi_register_gsi(struct device *dev, u32 gsi, int triggering, int polarity)
Linus Torvalds's avatar
Linus Torvalds committed
526 527 528 529 530 531 532 533 534
{
	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) {
535
		if (triggering == ACPI_LEVEL_SENSITIVE)
Len Brown's avatar
Len Brown committed
536
			eisa_set_level_irq(gsi);
Linus Torvalds's avatar
Linus Torvalds committed
537 538 539 540 541
	}
#endif

#ifdef CONFIG_X86_IO_APIC
	if (acpi_irq_model == ACPI_IRQ_MODEL_IOAPIC) {
542
		plat_gsi = mp_register_gsi(dev, gsi, triggering, polarity);
Linus Torvalds's avatar
Linus Torvalds committed
543 544 545 546 547
	}
#endif
	acpi_gsi_to_irq(plat_gsi, &irq);
	return irq;
}
Len Brown's avatar
Len Brown committed
548

Linus Torvalds's avatar
Linus Torvalds committed
549 550 551 552
/*
 *  ACPI based hotplug support for CPU
 */
#ifdef CONFIG_ACPI_HOTPLUG_CPU
553 554

static int __cpuinit _acpi_map_lsapic(acpi_handle handle, int *pcpu)
Linus Torvalds's avatar
Linus Torvalds committed
555
{
556 557
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *obj;
558
	struct acpi_madt_local_apic *lapic;
559
	cpumask_var_t tmp_map, new_map;
560 561
	u8 physid;
	int cpu;
562
	int retval = -ENOMEM;
563 564 565 566 567 568 569 570 571 572 573 574 575 576

	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;
	}

577
	lapic = (struct acpi_madt_local_apic *)obj->buffer.pointer;
578

579 580
	if (lapic->header.type != ACPI_MADT_TYPE_LOCAL_APIC ||
	    !(lapic->lapic_flags & ACPI_MADT_ENABLED)) {
581 582 583 584 585 586 587 588 589 590
		kfree(buffer.pointer);
		return -EINVAL;
	}

	physid = lapic->id;

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

591 592 593 594 595 596 597
	if (!alloc_cpumask_var(&tmp_map, GFP_KERNEL))
		goto out;

	if (!alloc_cpumask_var(&new_map, GFP_KERNEL))
		goto free_tmp_map;

	cpumask_copy(tmp_map, cpu_present_mask);
598
	acpi_register_lapic(physid, lapic->lapic_flags & ACPI_MADT_ENABLED);
599 600 601 602 603

	/*
	 * If mp_register_lapic successfully generates a new logical cpu
	 * number, then the following will get us exactly what was mapped
	 */
604 605
	cpumask_andnot(new_map, cpu_present_mask, tmp_map);
	if (cpumask_empty(new_map)) {
606
		printk ("Unable to map lapic to logical cpu number\n");
607 608
		retval = -EINVAL;
		goto free_new_map;
609 610
	}

611
	cpu = cpumask_first(new_map);
612 613

	*pcpu = cpu;
614 615 616 617 618 619 620 621
	retval = 0;

free_new_map:
	free_cpumask_var(new_map);
free_tmp_map:
	free_cpumask_var(tmp_map);
out:
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
622 623
}

624 625 626 627 628
/* wrapper to silence section mismatch warning */
int __ref acpi_map_lsapic(acpi_handle handle, int *pcpu)
{
	return _acpi_map_lsapic(handle, pcpu);
}
Len Brown's avatar
Len Brown committed
629
EXPORT_SYMBOL(acpi_map_lsapic);
Linus Torvalds's avatar
Linus Torvalds committed
630

Len Brown's avatar
Len Brown committed
631
int acpi_unmap_lsapic(int cpu)
Linus Torvalds's avatar
Linus Torvalds committed
632
{
633
	per_cpu(x86_cpu_to_apicid, cpu) = -1;
634
	set_cpu_present(cpu, false);
635 636 637
	num_processors--;

	return (0);
Linus Torvalds's avatar
Linus Torvalds committed
638
}
Len Brown's avatar
Len Brown committed
639

Linus Torvalds's avatar
Linus Torvalds committed
640
EXPORT_SYMBOL(acpi_unmap_lsapic);
Len Brown's avatar
Len Brown committed
641
#endif				/* CONFIG_ACPI_HOTPLUG_CPU */
Linus Torvalds's avatar
Linus Torvalds committed
642

Len Brown's avatar
Len Brown committed
643
int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base)
644 645 646 647
{
	/* TBD */
	return -EINVAL;
}
Len Brown's avatar
Len Brown committed
648

649 650
EXPORT_SYMBOL(acpi_register_ioapic);

Len Brown's avatar
Len Brown committed
651
int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base)
652 653 654 655
{
	/* TBD */
	return -EINVAL;
}
Len Brown's avatar
Len Brown committed
656

657 658
EXPORT_SYMBOL(acpi_unregister_ioapic);

659
static int __init acpi_parse_sbf(struct acpi_table_header *table)
Linus Torvalds's avatar
Linus Torvalds committed
660
{
661
	struct acpi_table_boot *sb;
Linus Torvalds's avatar
Linus Torvalds committed
662

663
	sb = (struct acpi_table_boot *)table;
Linus Torvalds's avatar
Linus Torvalds committed
664 665 666 667 668
	if (!sb) {
		printk(KERN_WARNING PREFIX "Unable to map SBF\n");
		return -ENODEV;
	}

669
	sbf_port = sb->cmos_index;	/* Save CMOS port */
Linus Torvalds's avatar
Linus Torvalds committed
670 671 672 673 674

	return 0;
}

#ifdef CONFIG_HPET_TIMER
675
#include <asm/hpet.h>
Linus Torvalds's avatar
Linus Torvalds committed
676

677 678
static struct __initdata resource *hpet_res;

679
static int __init acpi_parse_hpet(struct acpi_table_header *table)
Linus Torvalds's avatar
Linus Torvalds committed
680 681 682
{
	struct acpi_table_hpet *hpet_tbl;

683
	hpet_tbl = (struct acpi_table_hpet *)table;
Linus Torvalds's avatar
Linus Torvalds committed
684 685 686 687 688
	if (!hpet_tbl) {
		printk(KERN_WARNING PREFIX "Unable to map HPET\n");
		return -ENODEV;
	}

689
	if (hpet_tbl->address.space_id != ACPI_SPACE_MEM) {
Linus Torvalds's avatar
Linus Torvalds committed
690 691 692 693
		printk(KERN_WARNING PREFIX "HPET timers must be located in "
		       "memory.\n");
		return -1;
	}
694

695
	hpet_address = hpet_tbl->address.address;
Thomas Gleixner's avatar
Thomas Gleixner committed
696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727

	/*
	 * Some broken BIOSes advertise HPET at 0x0. We really do not
	 * want to allocate a resource there.
	 */
	if (!hpet_address) {
		printk(KERN_WARNING PREFIX
		       "HPET id: %#x base: %#lx is invalid\n",
		       hpet_tbl->id, hpet_address);
		return 0;
	}
#ifdef CONFIG_X86_64
	/*
	 * Some even more broken BIOSes advertise HPET at
	 * 0xfed0000000000000 instead of 0xfed00000. Fix it up and add
	 * some noise:
	 */
	if (hpet_address == 0xfed0000000000000UL) {
		if (!hpet_force_user) {
			printk(KERN_WARNING PREFIX "HPET id: %#x "
			       "base: 0xfed0000000000000 is bogus\n "
			       "try hpet=force on the kernel command line to "
			       "fix it up to 0xfed00000.\n", hpet_tbl->id);
			hpet_address = 0;
			return 0;
		}
		printk(KERN_WARNING PREFIX
		       "HPET id: %#x base: 0xfed0000000000000 fixed up "
		       "to 0xfed00000.\n", hpet_tbl->id);
		hpet_address >>= 32;
	}
#endif
Len Brown's avatar
Len Brown committed
728
	printk(KERN_INFO PREFIX "HPET id: %#x base: %#lx\n",
729
	       hpet_tbl->id, hpet_address);
Linus Torvalds's avatar
Linus Torvalds committed
730

731 732 733 734 735 736 737 738 739 740 741 742 743 744 745
	/*
	 * Allocate and initialize the HPET firmware resource for adding into
	 * the resource tree during the lateinit timeframe.
	 */
#define HPET_RESOURCE_NAME_SIZE 9
	hpet_res = alloc_bootmem(sizeof(*hpet_res) + HPET_RESOURCE_NAME_SIZE);

	hpet_res->name = (void *)&hpet_res[1];
	hpet_res->flags = IORESOURCE_MEM;
	snprintf((char *)hpet_res->name, HPET_RESOURCE_NAME_SIZE, "HPET %u",
		 hpet_tbl->sequence);

	hpet_res->start = hpet_address;
	hpet_res->end = hpet_address + (1 * 1024) - 1;

Linus Torvalds's avatar
Linus Torvalds committed
746 747
	return 0;
}
748 749 750 751 752 753 754 755 756 757 758 759 760 761 762

/*
 * hpet_insert_resource inserts the HPET resources used into the resource
 * tree.
 */
static __init int hpet_insert_resource(void)
{
	if (!hpet_res)
		return 1;

	return insert_resource(&iomem_resource, hpet_res);
}

late_initcall(hpet_insert_resource);

Linus Torvalds's avatar
Linus Torvalds committed
763 764 765 766
#else
#define	acpi_parse_hpet	NULL
#endif

767
static int __init acpi_parse_fadt(struct acpi_table_header *table)
Linus Torvalds's avatar
Linus Torvalds committed
768
{
Jason Davis's avatar
Jason Davis committed
769

Linus Torvalds's avatar
Linus Torvalds committed
770 771
#ifdef CONFIG_X86_PM_TIMER
	/* detect the location of the ACPI PM Timer */
772
	if (acpi_gbl_FADT.header.revision >= FADT2_REVISION_ID) {
Linus Torvalds's avatar
Linus Torvalds committed
773
		/* FADT rev. 2 */
774
		if (acpi_gbl_FADT.xpm_timer_block.space_id !=
Len Brown's avatar
Len Brown committed
775
		    ACPI_ADR_SPACE_SYSTEM_IO)
Linus Torvalds's avatar
Linus Torvalds committed
776 777
			return 0;

778
		pmtmr_ioport = acpi_gbl_FADT.xpm_timer_block.address;
779 780 781 782 783 784
		/*
		 * "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)
785
			pmtmr_ioport = acpi_gbl_FADT.pm_timer_block;
Linus Torvalds's avatar
Linus Torvalds committed
786 787
	} else {
		/* FADT rev. 1 */
788
		pmtmr_ioport = acpi_gbl_FADT.pm_timer_block;
Linus Torvalds's avatar
Linus Torvalds committed
789 790
	}
	if (pmtmr_ioport)
Len Brown's avatar
Len Brown committed
791 792
		printk(KERN_INFO PREFIX "PM-Timer IO Port: %#x\n",
		       pmtmr_ioport);
Linus Torvalds's avatar
Linus Torvalds committed
793 794 795 796 797 798 799 800 801
#endif
	return 0;
}

#ifdef	CONFIG_X86_LOCAL_APIC
/*
 * Parse LAPIC entries in MADT
 * returns 0 on success, < 0 on error
 */
802 803 804 805 806 807

static void __init acpi_register_lapic_address(unsigned long address)
{
	mp_lapic_addr = address;

	set_fixmap_nocache(FIX_APIC_BASE, address);
Yinghai Lu's avatar
Yinghai Lu committed
808
	if (boot_cpu_physical_apicid == -1U) {
809
		boot_cpu_physical_apicid  = read_apic_id();
Yinghai Lu's avatar
Yinghai Lu committed
810 811 812
		apic_version[boot_cpu_physical_apicid] =
			 GET_APIC_VERSION(apic_read(APIC_LVR));
	}
813 814
}

815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840
static int __init early_acpi_parse_madt_lapic_addr_ovr(void)
{
	int count;

	if (!cpu_has_apic)
		return -ENODEV;

	/*
	 * 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).
	 */

	count =
	    acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE,
				  acpi_parse_lapic_addr_ovr, 0);
	if (count < 0) {
		printk(KERN_ERR PREFIX
		       "Error parsing LAPIC address override entry\n");
		return count;
	}

	acpi_register_lapic_address(acpi_lapic_addr);

	return count;
}

Len Brown's avatar
Len Brown committed
841
static int __init acpi_parse_madt_lapic_entries(void)
Linus Torvalds's avatar
Linus Torvalds committed
842 843
{
	int count;
844
	int x2count = 0;
Linus Torvalds's avatar
Linus Torvalds committed
845

846 847 848
	if (!cpu_has_apic)
		return -ENODEV;

849
	/*
Linus Torvalds's avatar
Linus Torvalds committed
850 851 852 853
	 * 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
854
	count =
855
	    acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE,
Len Brown's avatar
Len Brown committed
856
				  acpi_parse_lapic_addr_ovr, 0);
Linus Torvalds's avatar
Linus Torvalds committed
857
	if (count < 0) {
Len Brown's avatar
Len Brown committed
858 859
		printk(KERN_ERR PREFIX
		       "Error parsing LAPIC address override entry\n");
Linus Torvalds's avatar
Linus Torvalds committed
860 861 862
		return count;
	}

863
	acpi_register_lapic_address(acpi_lapic_addr);
Linus Torvalds's avatar
Linus Torvalds committed
864

865 866 867
	count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_SAPIC,
				      acpi_parse_sapic, MAX_APICS);

868 869 870
	if (!count) {
		x2count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_X2APIC,
						acpi_parse_x2apic, MAX_APICS);
871 872
		count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC,
					      acpi_parse_lapic, MAX_APICS);
873 874
	}
	if (!count && !x2count) {
Linus Torvalds's avatar
Linus Torvalds committed
875 876 877
		printk(KERN_ERR PREFIX "No LAPIC entries present\n");
		/* TBD: Cleanup to allow fallback to MPS */
		return -ENODEV;
878
	} else if (count < 0 || x2count < 0) {
Linus Torvalds's avatar
Linus Torvalds committed
879 880 881 882 883
		printk(KERN_ERR PREFIX "Error parsing LAPIC entry\n");
		/* TBD: Cleanup to allow fallback to MPS */
		return count;
	}

884 885 886
	x2count =
	    acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_X2APIC_NMI,
				  acpi_parse_x2apic_nmi, 0);
Len Brown's avatar
Len Brown committed
887
	count =
888
	    acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_NMI, acpi_parse_lapic_nmi, 0);
889
	if (count < 0 || x2count < 0) {
Linus Torvalds's avatar
Linus Torvalds committed
890 891 892 893 894 895
		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
896
#endif				/* CONFIG_X86_LOCAL_APIC */
Linus Torvalds's avatar
Linus Torvalds committed
897

898
#ifdef	CONFIG_X86_IO_APIC
899 900
#define MP_ISA_BUS		0

901
#ifdef CONFIG_X86_ES7000
902 903 904
extern int es7000_plat;
#endif

905 906 907 908 909 910
static struct {
	int apic_id;
	int gsi_base;
	int gsi_end;
	DECLARE_BITMAP(pin_programmed, MP_MAX_IOAPIC_PIN + 1);
} mp_ioapic_routing[MAX_IO_APICS];
911

912
int mp_find_ioapic(int gsi)
913 914 915 916 917 918 919 920 921 922 923 924 925 926
{
	int i = 0;

	/* Find the IOAPIC that manages this GSI. */
	for (i = 0; i < nr_ioapics; i++) {
		if ((gsi >= mp_ioapic_routing[i].gsi_base)
		    && (gsi <= mp_ioapic_routing[i].gsi_end))
			return i;
	}

	printk(KERN_ERR "ERROR: Unable to locate IOAPIC for GSI %d\n", gsi);
	return -1;
}

927 928 929 930 931 932 933 934 935 936
int mp_find_ioapic_pin(int ioapic, int gsi)
{
	if (WARN_ON(ioapic == -1))
		return -1;
	if (WARN_ON(gsi > mp_ioapic_routing[ioapic].gsi_end))
		return -1;

	return gsi - mp_ioapic_routing[ioapic].gsi_base;
}

937 938 939 940 941 942 943 944 945 946 947 948 949
static u8 __init uniq_ioapic_id(u8 id)
{
#ifdef CONFIG_X86_32
	if ((boot_cpu_data.x86_vendor == X86_VENDOR_INTEL) &&
	    !APIC_XAPIC(apic_version[boot_cpu_physical_apicid]))
		return io_apic_get_unique_id(nr_ioapics, id);
	else
		return id;
#else
	int i;
	DECLARE_BITMAP(used, 256);
	bitmap_zero(used, 256);
	for (i = 0; i < nr_ioapics; i++) {
950 951
		struct mpc_ioapic *ia = &mp_ioapics[i];
		__set_bit(ia->apicid, used);
952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982
	}
	if (!test_bit(id, used))
		return id;
	return find_first_zero_bit(used, 256);
#endif
}

static int bad_ioapic(unsigned long address)
{
	if (nr_ioapics >= MAX_IO_APICS) {
		printk(KERN_ERR "ERROR: Max # of I/O APICs (%d) exceeded "
		       "(found %d)\n", MAX_IO_APICS, nr_ioapics);
		panic("Recompile kernel with bigger MAX_IO_APICS!\n");
	}
	if (!address) {
		printk(KERN_ERR "WARNING: Bogus (zero) I/O APIC address"
		       " found in table, skipping!\n");
		return 1;
	}
	return 0;
}

void __init mp_register_ioapic(int id, u32 address, u32 gsi_base)
{
	int idx = 0;

	if (bad_ioapic(address))
		return;

	idx = nr_ioapics;

983 984 985
	mp_ioapics[idx].type = MP_IOAPIC;
	mp_ioapics[idx].flags = MPC_APIC_USABLE;
	mp_ioapics[idx].apicaddr = address;
986 987

	set_fixmap_nocache(FIX_IO_APIC_BASE_0 + idx, address);
988
	mp_ioapics[idx].apicid = uniq_ioapic_id(id);
989
#ifdef CONFIG_X86_32
990
	mp_ioapics[idx].apicver = io_apic_get_version(idx);
991
#else
992
	mp_ioapics[idx].apicver = 0;
993 994 995 996 997
#endif
	/*
	 * Build basic GSI lookup table to facilitate gsi->io_apic lookups
	 * and to prevent reprogramming of IOAPIC pins (PCI GSIs).
	 */
998
	mp_ioapic_routing[idx].apic_id = mp_ioapics[idx].apicid;
999 1000 1001 1002
	mp_ioapic_routing[idx].gsi_base = gsi_base;
	mp_ioapic_routing[idx].gsi_end = gsi_base +
	    io_apic_get_redir_entries(idx);

1003 1004 1005
	printk(KERN_INFO "IOAPIC[%d]: apic_id %d, version %d, address 0x%x, "
	       "GSI %d-%d\n", idx, mp_ioapics[idx].apicid,
	       mp_ioapics[idx].apicver, mp_ioapics[idx].apicaddr,
1006 1007 1008 1009 1010
	       mp_ioapic_routing[idx].gsi_base, mp_ioapic_routing[idx].gsi_end);

	nr_ioapics++;
}

1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
int __init acpi_probe_gsi(void)
{
	int idx;
	int gsi;
	int max_gsi = 0;

	if (acpi_disabled)
		return 0;

	if (!acpi_ioapic)
		return 0;

	max_gsi = 0;
	for (idx = 0; idx < nr_ioapics; idx++) {
		gsi = mp_ioapic_routing[idx].gsi_end;

		if (gsi > max_gsi)
			max_gsi = gsi;
	}

	return max_gsi + 1;
}

1034 1035
static void assign_to_mp_irq(struct mpc_intsrc *m,
				    struct mpc_intsrc *mp_irq)
1036
{
1037
	memcpy(mp_irq, m, sizeof(struct mpc_intsrc));
1038 1039
}

1040 1041
static int mp_irq_cmp(struct mpc_intsrc *mp_irq,
				struct mpc_intsrc *m)
1042
{
1043
	return memcmp(mp_irq, m, sizeof(struct mpc_intsrc));
1044 1045
}

1046
static void save_mp_irq(struct mpc_intsrc *m)
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
{
	int i;

	for (i = 0; i < mp_irq_entries; i++) {
		if (!mp_irq_cmp(&mp_irqs[i], m))
			return;
	}

	assign_to_mp_irq(m, &mp_irqs[mp_irq_entries]);
	if (++mp_irq_entries == MAX_IRQ_SOURCES)
		panic("Max # of irq sources exceeded!!\n");
}

1060 1061
void __init mp_override_legacy_irq(u8 bus_irq, u8 polarity, u8 trigger, u32 gsi)
{
1062 1063
	int ioapic;
	int pin;
1064
	struct mpc_intsrc mp_irq;
1065 1066 1067 1068 1069 1070 1071

	/*
	 * Convert 'gsi' to 'ioapic.pin'.
	 */
	ioapic = mp_find_ioapic(gsi);
	if (ioapic < 0)
		return;
1072
	pin = mp_find_ioapic_pin(ioapic, gsi);
1073 1074 1075 1076 1077 1078 1079 1080 1081

	/*
	 * TBD: This check is for faulty timer entries, where the override
	 *      erroneously sets the trigger to level, resulting in a HUGE
	 *      increase of timer interrupts!
	 */
	if ((bus_irq == 0) && (trigger == 3))
		trigger = 1;

1082 1083 1084 1085 1086 1087 1088
	mp_irq.type = MP_INTSRC;
	mp_irq.irqtype = mp_INT;
	mp_irq.irqflag = (trigger << 2) | polarity;
	mp_irq.srcbus = MP_ISA_BUS;
	mp_irq.srcbusirq = bus_irq;	/* IRQ */
	mp_irq.dstapic = mp_ioapics[ioapic].apicid; /* APIC ID */
	mp_irq.dstirq = pin;	/* INTIN# */
1089

1090
	save_mp_irq(&mp_irq);
1091 1092 1093 1094
}

void __init mp_config_acpi_legacy_irqs(void)
{
1095 1096 1097
	int i;
	int ioapic;
	unsigned int dstapic;
1098
	struct mpc_intsrc mp_irq;
1099 1100 1101 1102 1103 1104 1105 1106

#if defined (CONFIG_MCA) || defined (CONFIG_EISA)
	/*
	 * Fabricate the legacy ISA bus (bus #31).
	 */
	mp_bus_id_to_type[MP_ISA_BUS] = MP_BUS_ISA;
#endif
	set_bit(MP_ISA_BUS, mp_bus_not_pci);
1107
	pr_debug("Bus #%d is ISA\n", MP_ISA_BUS);
1108

1109
#ifdef CONFIG_X86_ES7000
1110 1111