Eric Lee / smarc-ti-linux-kernel

Download as
Browse Code »

Commit 58557add70dcae1dd7df1d039c99f27edc7f4ece

Authored by Jiang Liu
Committed by Greg Kroah-Hartman
1 parent 2f455ae129

x86/irq: Fix regression caused by commit b568b8601f05 

commit 1ea76fbadd667b19c4fa4466f3a3b55a505e83d9 upstream.

Commit b568b8601f05 ("Treat SCI interrupt as normal GSI interrupt")
accidently removes support of legacy PIC interrupt when fixing a
regression for Xen, which causes a nasty regression on HP/Compaq
nc6000 where we fail to register the ACPI interrupt, and thus
lose eg. thermal notifications leading a potentially overheated
machine.

So reintroduce support of legacy PIC based ACPI SCI interrupt.

Reported-by: Ville Syrjälä <syrjala@sci.fi>
Tested-by: Ville Syrjälä <syrjala@sci.fi>
Signed-off-by: Jiang Liu <jiang.liu@linux.intel.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: Pavel Machek <pavel@ucw.cz>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Len Brown <len.brown@intel.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Cc: Sander Eikelenboom <linux@eikelenboom.it>
Cc: linux-pm@vger.kernel.org
Link: http://lkml.kernel.org/r/1424052673-22974-1-git-send-email-jiang.liu@linux.intel.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Showing 1 changed file with 5 additions and 0 deletions Inline Diff

arch/x86/kernel/acpi/boot.c
Diff comments   View file @ 58557ad
1 /* 1 /*
2 * boot.c - Architecture-Specific Low-Level ACPI Boot Support 2 * boot.c - Architecture-Specific Low-Level ACPI Boot Support
3 * 3 *
4 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 4 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
5 * Copyright (C) 2001 Jun Nakajima <jun.nakajima@intel.com> 5 * Copyright (C) 2001 Jun Nakajima <jun.nakajima@intel.com>
6 * 6 *
7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8 * 8 *
9 * This program is free software; you can redistribute it and/or modify 9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by 10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or 11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version. 12 * (at your option) any later version.
13 * 13 *
14 * This program is distributed in the hope that it will be useful, 14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details. 17 * GNU General Public License for more details.
18 * 18 *
19 * You should have received a copy of the GNU General Public License 19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software 20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 * 22 *
23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
24 */ 24 */
25 25
26 #include <linux/init.h> 26 #include <linux/init.h>
27 #include <linux/acpi.h> 27 #include <linux/acpi.h>
28 #include <linux/acpi_pmtmr.h> 28 #include <linux/acpi_pmtmr.h>
29 #include <linux/efi.h> 29 #include <linux/efi.h>
30 #include <linux/cpumask.h> 30 #include <linux/cpumask.h>
31 #include <linux/module.h> 31 #include <linux/module.h>
32 #include <linux/dmi.h> 32 #include <linux/dmi.h>
33 #include <linux/irq.h> 33 #include <linux/irq.h>
34 #include <linux/irqdomain.h> 34 #include <linux/irqdomain.h>
35 #include <linux/slab.h> 35 #include <linux/slab.h>
36 #include <linux/bootmem.h> 36 #include <linux/bootmem.h>
37 #include <linux/ioport.h> 37 #include <linux/ioport.h>
38 #include <linux/pci.h> 38 #include <linux/pci.h>
39 39
40 #include <asm/pci_x86.h> 40 #include <asm/pci_x86.h>
41 #include <asm/pgtable.h> 41 #include <asm/pgtable.h>
42 #include <asm/io_apic.h> 42 #include <asm/io_apic.h>
43 #include <asm/apic.h> 43 #include <asm/apic.h>
44 #include <asm/io.h> 44 #include <asm/io.h>
45 #include <asm/mpspec.h> 45 #include <asm/mpspec.h>
46 #include <asm/smp.h> 46 #include <asm/smp.h>
47 #include <asm/i8259.h> 47 #include <asm/i8259.h>
48 48
49 #include "sleep.h" /* To include x86_acpi_suspend_lowlevel */ 49 #include "sleep.h" /* To include x86_acpi_suspend_lowlevel */
50 static int __initdata acpi_force = 0; 50 static int __initdata acpi_force = 0;
51 int acpi_disabled; 51 int acpi_disabled;
52 EXPORT_SYMBOL(acpi_disabled); 52 EXPORT_SYMBOL(acpi_disabled);
53 53
54 #ifdef CONFIG_X86_64 54 #ifdef CONFIG_X86_64
55 # include <asm/proto.h> 55 # include <asm/proto.h>
56 #endif /* X86 */ 56 #endif /* X86 */
57 57
58 #define PREFIX "ACPI: " 58 #define PREFIX "ACPI: "
59 59
60 int acpi_noirq; /* skip ACPI IRQ initialization */ 60 int acpi_noirq; /* skip ACPI IRQ initialization */
61 int acpi_pci_disabled; /* skip ACPI PCI scan and IRQ initialization */ 61 int acpi_pci_disabled; /* skip ACPI PCI scan and IRQ initialization */
62 EXPORT_SYMBOL(acpi_pci_disabled); 62 EXPORT_SYMBOL(acpi_pci_disabled);
63 63
64 int acpi_lapic; 64 int acpi_lapic;
65 int acpi_ioapic; 65 int acpi_ioapic;
66 int acpi_strict; 66 int acpi_strict;
67 int acpi_disable_cmcff; 67 int acpi_disable_cmcff;
68 68
69 u8 acpi_sci_flags __initdata; 69 u8 acpi_sci_flags __initdata;
70 int acpi_sci_override_gsi __initdata; 70 int acpi_sci_override_gsi __initdata;
71 int acpi_skip_timer_override __initdata; 71 int acpi_skip_timer_override __initdata;
72 int acpi_use_timer_override __initdata; 72 int acpi_use_timer_override __initdata;
73 int acpi_fix_pin2_polarity __initdata; 73 int acpi_fix_pin2_polarity __initdata;
74 74
75 #ifdef CONFIG_X86_LOCAL_APIC 75 #ifdef CONFIG_X86_LOCAL_APIC
76 static u64 acpi_lapic_addr __initdata = APIC_DEFAULT_PHYS_BASE; 76 static u64 acpi_lapic_addr __initdata = APIC_DEFAULT_PHYS_BASE;
77 #endif 77 #endif
78 78
79 /* 79 /*
80 * Locks related to IOAPIC hotplug 80 * Locks related to IOAPIC hotplug
81 * Hotplug side: 81 * Hotplug side:
82 * ->device_hotplug_lock 82 * ->device_hotplug_lock
83 * ->acpi_ioapic_lock 83 * ->acpi_ioapic_lock
84 * ->ioapic_lock 84 * ->ioapic_lock
85 * Interrupt mapping side: 85 * Interrupt mapping side:
86 * ->acpi_ioapic_lock 86 * ->acpi_ioapic_lock
87 * ->ioapic_mutex 87 * ->ioapic_mutex
88 * ->ioapic_lock 88 * ->ioapic_lock
89 */ 89 */
90 static DEFINE_MUTEX(acpi_ioapic_lock); 90 static DEFINE_MUTEX(acpi_ioapic_lock);
91 91
92 /* -------------------------------------------------------------------------- 92 /* --------------------------------------------------------------------------
93 Boot-time Configuration 93 Boot-time Configuration
94 -------------------------------------------------------------------------- */ 94 -------------------------------------------------------------------------- */
95 95
96 /* 96 /*
97 * The default interrupt routing model is PIC (8259). This gets 97 * The default interrupt routing model is PIC (8259). This gets
98 * overridden if IOAPICs are enumerated (below). 98 * overridden if IOAPICs are enumerated (below).
99 */ 99 */
100 enum acpi_irq_model_id acpi_irq_model = ACPI_IRQ_MODEL_PIC; 100 enum acpi_irq_model_id acpi_irq_model = ACPI_IRQ_MODEL_PIC;
101 101
102 102
103 /* 103 /*
104 * ISA irqs by default are the first 16 gsis but can be 104 * ISA irqs by default are the first 16 gsis but can be
105 * any gsi as specified by an interrupt source override. 105 * any gsi as specified by an interrupt source override.
106 */ 106 */
107 static u32 isa_irq_to_gsi[NR_IRQS_LEGACY] __read_mostly = { 107 static u32 isa_irq_to_gsi[NR_IRQS_LEGACY] __read_mostly = {
108 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 108 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
109 }; 109 };
110 110
111 #define ACPI_INVALID_GSI INT_MIN 111 #define ACPI_INVALID_GSI INT_MIN
112 112
113 /* 113 /*
114 * This is just a simple wrapper around early_ioremap(), 114 * This is just a simple wrapper around early_ioremap(),
115 * with sanity checks for phys == 0 and size == 0. 115 * with sanity checks for phys == 0 and size == 0.
116 */ 116 */
117 char *__init __acpi_map_table(unsigned long phys, unsigned long size) 117 char *__init __acpi_map_table(unsigned long phys, unsigned long size)
118 { 118 {
119 119
120 if (!phys || !size) 120 if (!phys || !size)
121 return NULL; 121 return NULL;
122 122
123 return early_ioremap(phys, size); 123 return early_ioremap(phys, size);
124 } 124 }
125 125
126 void __init __acpi_unmap_table(char *map, unsigned long size) 126 void __init __acpi_unmap_table(char *map, unsigned long size)
127 { 127 {
128 if (!map || !size) 128 if (!map || !size)
129 return; 129 return;
130 130
131 early_iounmap(map, size); 131 early_iounmap(map, size);
132 } 132 }
133 133
134 #ifdef CONFIG_X86_LOCAL_APIC 134 #ifdef CONFIG_X86_LOCAL_APIC
135 static int __init acpi_parse_madt(struct acpi_table_header *table) 135 static int __init acpi_parse_madt(struct acpi_table_header *table)
136 { 136 {
137 struct acpi_table_madt *madt = NULL; 137 struct acpi_table_madt *madt = NULL;
138 138
139 if (!cpu_has_apic) 139 if (!cpu_has_apic)
140 return -EINVAL; 140 return -EINVAL;
141 141
142 madt = (struct acpi_table_madt *)table; 142 madt = (struct acpi_table_madt *)table;
143 if (!madt) { 143 if (!madt) {
144 printk(KERN_WARNING PREFIX "Unable to map MADT\n"); 144 printk(KERN_WARNING PREFIX "Unable to map MADT\n");
145 return -ENODEV; 145 return -ENODEV;
146 } 146 }
147 147
148 if (madt->address) { 148 if (madt->address) {
149 acpi_lapic_addr = (u64) madt->address; 149 acpi_lapic_addr = (u64) madt->address;
150 150
151 printk(KERN_DEBUG PREFIX "Local APIC address 0x%08x\n", 151 printk(KERN_DEBUG PREFIX "Local APIC address 0x%08x\n",
152 madt->address); 152 madt->address);
153 } 153 }
154 154
155 default_acpi_madt_oem_check(madt->header.oem_id, 155 default_acpi_madt_oem_check(madt->header.oem_id,
156 madt->header.oem_table_id); 156 madt->header.oem_table_id);
157 157
158 return 0; 158 return 0;
159 } 159 }
160 160
161 /** 161 /**
162 * acpi_register_lapic - register a local apic and generates a logic cpu number 162 * acpi_register_lapic - register a local apic and generates a logic cpu number
163 * @id: local apic id to register 163 * @id: local apic id to register
164 * @enabled: this cpu is enabled or not 164 * @enabled: this cpu is enabled or not
165 * 165 *
166 * Returns the logic cpu number which maps to the local apic 166 * Returns the logic cpu number which maps to the local apic
167 */ 167 */
168 static int acpi_register_lapic(int id, u8 enabled) 168 static int acpi_register_lapic(int id, u8 enabled)
169 { 169 {
170 unsigned int ver = 0; 170 unsigned int ver = 0;
171 171
172 if (id >= MAX_LOCAL_APIC) { 172 if (id >= MAX_LOCAL_APIC) {
173 printk(KERN_INFO PREFIX "skipped apicid that is too big\n"); 173 printk(KERN_INFO PREFIX "skipped apicid that is too big\n");
174 return -EINVAL; 174 return -EINVAL;
175 } 175 }
176 176
177 if (!enabled) { 177 if (!enabled) {
178 ++disabled_cpus; 178 ++disabled_cpus;
179 return -EINVAL; 179 return -EINVAL;
180 } 180 }
181 181
182 if (boot_cpu_physical_apicid != -1U) 182 if (boot_cpu_physical_apicid != -1U)
183 ver = apic_version[boot_cpu_physical_apicid]; 183 ver = apic_version[boot_cpu_physical_apicid];
184 184
185 return generic_processor_info(id, ver); 185 return generic_processor_info(id, ver);
186 } 186 }
187 187
188 static int __init 188 static int __init
189 acpi_parse_x2apic(struct acpi_subtable_header *header, const unsigned long end) 189 acpi_parse_x2apic(struct acpi_subtable_header *header, const unsigned long end)
190 { 190 {
191 struct acpi_madt_local_x2apic *processor = NULL; 191 struct acpi_madt_local_x2apic *processor = NULL;
192 int apic_id; 192 int apic_id;
193 u8 enabled; 193 u8 enabled;
194 194
195 processor = (struct acpi_madt_local_x2apic *)header; 195 processor = (struct acpi_madt_local_x2apic *)header;
196 196
197 if (BAD_MADT_ENTRY(processor, end)) 197 if (BAD_MADT_ENTRY(processor, end))
198 return -EINVAL; 198 return -EINVAL;
199 199
200 acpi_table_print_madt_entry(header); 200 acpi_table_print_madt_entry(header);
201 201
202 apic_id = processor->local_apic_id; 202 apic_id = processor->local_apic_id;
203 enabled = processor->lapic_flags & ACPI_MADT_ENABLED; 203 enabled = processor->lapic_flags & ACPI_MADT_ENABLED;
204 #ifdef CONFIG_X86_X2APIC 204 #ifdef CONFIG_X86_X2APIC
205 /* 205 /*
206 * We need to register disabled CPU as well to permit 206 * We need to register disabled CPU as well to permit
207 * counting disabled CPUs. This allows us to size 207 * counting disabled CPUs. This allows us to size
208 * cpus_possible_map more accurately, to permit 208 * cpus_possible_map more accurately, to permit
209 * to not preallocating memory for all NR_CPUS 209 * to not preallocating memory for all NR_CPUS
210 * when we use CPU hotplug. 210 * when we use CPU hotplug.
211 */ 211 */
212 if (!apic->apic_id_valid(apic_id) && enabled) 212 if (!apic->apic_id_valid(apic_id) && enabled)
213 printk(KERN_WARNING PREFIX "x2apic entry ignored\n"); 213 printk(KERN_WARNING PREFIX "x2apic entry ignored\n");
214 else 214 else
215 acpi_register_lapic(apic_id, enabled); 215 acpi_register_lapic(apic_id, enabled);
216 #else 216 #else
217 printk(KERN_WARNING PREFIX "x2apic entry ignored\n"); 217 printk(KERN_WARNING PREFIX "x2apic entry ignored\n");
218 #endif 218 #endif
219 219
220 return 0; 220 return 0;
221 } 221 }
222 222
223 static int __init 223 static int __init
224 acpi_parse_lapic(struct acpi_subtable_header * header, const unsigned long end) 224 acpi_parse_lapic(struct acpi_subtable_header * header, const unsigned long end)
225 { 225 {
226 struct acpi_madt_local_apic *processor = NULL; 226 struct acpi_madt_local_apic *processor = NULL;
227 227
228 processor = (struct acpi_madt_local_apic *)header; 228 processor = (struct acpi_madt_local_apic *)header;
229 229
230 if (BAD_MADT_ENTRY(processor, end)) 230 if (BAD_MADT_ENTRY(processor, end))
231 return -EINVAL; 231 return -EINVAL;
232 232
233 acpi_table_print_madt_entry(header); 233 acpi_table_print_madt_entry(header);
234 234
235 /* 235 /*
236 * We need to register disabled CPU as well to permit 236 * We need to register disabled CPU as well to permit
237 * counting disabled CPUs. This allows us to size 237 * counting disabled CPUs. This allows us to size
238 * cpus_possible_map more accurately, to permit 238 * cpus_possible_map more accurately, to permit
239 * to not preallocating memory for all NR_CPUS 239 * to not preallocating memory for all NR_CPUS
240 * when we use CPU hotplug. 240 * when we use CPU hotplug.
241 */ 241 */
242 acpi_register_lapic(processor->id, /* APIC ID */ 242 acpi_register_lapic(processor->id, /* APIC ID */
243 processor->lapic_flags & ACPI_MADT_ENABLED); 243 processor->lapic_flags & ACPI_MADT_ENABLED);
244 244
245 return 0; 245 return 0;
246 } 246 }
247 247
248 static int __init 248 static int __init
249 acpi_parse_sapic(struct acpi_subtable_header *header, const unsigned long end) 249 acpi_parse_sapic(struct acpi_subtable_header *header, const unsigned long end)
250 { 250 {
251 struct acpi_madt_local_sapic *processor = NULL; 251 struct acpi_madt_local_sapic *processor = NULL;
252 252
253 processor = (struct acpi_madt_local_sapic *)header; 253 processor = (struct acpi_madt_local_sapic *)header;
254 254
255 if (BAD_MADT_ENTRY(processor, end)) 255 if (BAD_MADT_ENTRY(processor, end))
256 return -EINVAL; 256 return -EINVAL;
257 257
258 acpi_table_print_madt_entry(header); 258 acpi_table_print_madt_entry(header);
259 259
260 acpi_register_lapic((processor->id << 8) | processor->eid,/* APIC ID */ 260 acpi_register_lapic((processor->id << 8) | processor->eid,/* APIC ID */
261 processor->lapic_flags & ACPI_MADT_ENABLED); 261 processor->lapic_flags & ACPI_MADT_ENABLED);
262 262
263 return 0; 263 return 0;
264 } 264 }
265 265
266 static int __init 266 static int __init
267 acpi_parse_lapic_addr_ovr(struct acpi_subtable_header * header, 267 acpi_parse_lapic_addr_ovr(struct acpi_subtable_header * header,
268 const unsigned long end) 268 const unsigned long end)
269 { 269 {
270 struct acpi_madt_local_apic_override *lapic_addr_ovr = NULL; 270 struct acpi_madt_local_apic_override *lapic_addr_ovr = NULL;
271 271
272 lapic_addr_ovr = (struct acpi_madt_local_apic_override *)header; 272 lapic_addr_ovr = (struct acpi_madt_local_apic_override *)header;
273 273
274 if (BAD_MADT_ENTRY(lapic_addr_ovr, end)) 274 if (BAD_MADT_ENTRY(lapic_addr_ovr, end))
275 return -EINVAL; 275 return -EINVAL;
276 276
277 acpi_lapic_addr = lapic_addr_ovr->address; 277 acpi_lapic_addr = lapic_addr_ovr->address;
278 278
279 return 0; 279 return 0;
280 } 280 }
281 281
282 static int __init 282 static int __init
283 acpi_parse_x2apic_nmi(struct acpi_subtable_header *header, 283 acpi_parse_x2apic_nmi(struct acpi_subtable_header *header,
284 const unsigned long end) 284 const unsigned long end)
285 { 285 {
286 struct acpi_madt_local_x2apic_nmi *x2apic_nmi = NULL; 286 struct acpi_madt_local_x2apic_nmi *x2apic_nmi = NULL;
287 287
288 x2apic_nmi = (struct acpi_madt_local_x2apic_nmi *)header; 288 x2apic_nmi = (struct acpi_madt_local_x2apic_nmi *)header;
289 289
290 if (BAD_MADT_ENTRY(x2apic_nmi, end)) 290 if (BAD_MADT_ENTRY(x2apic_nmi, end))
291 return -EINVAL; 291 return -EINVAL;
292 292
293 acpi_table_print_madt_entry(header); 293 acpi_table_print_madt_entry(header);
294 294
295 if (x2apic_nmi->lint != 1) 295 if (x2apic_nmi->lint != 1)
296 printk(KERN_WARNING PREFIX "NMI not connected to LINT 1!\n"); 296 printk(KERN_WARNING PREFIX "NMI not connected to LINT 1!\n");
297 297
298 return 0; 298 return 0;
299 } 299 }
300 300
301 static int __init 301 static int __init
302 acpi_parse_lapic_nmi(struct acpi_subtable_header * header, const unsigned long end) 302 acpi_parse_lapic_nmi(struct acpi_subtable_header * header, const unsigned long end)
303 { 303 {
304 struct acpi_madt_local_apic_nmi *lapic_nmi = NULL; 304 struct acpi_madt_local_apic_nmi *lapic_nmi = NULL;
305 305
306 lapic_nmi = (struct acpi_madt_local_apic_nmi *)header; 306 lapic_nmi = (struct acpi_madt_local_apic_nmi *)header;
307 307
308 if (BAD_MADT_ENTRY(lapic_nmi, end)) 308 if (BAD_MADT_ENTRY(lapic_nmi, end))
309 return -EINVAL; 309 return -EINVAL;
310 310
311 acpi_table_print_madt_entry(header); 311 acpi_table_print_madt_entry(header);
312 312
313 if (lapic_nmi->lint != 1) 313 if (lapic_nmi->lint != 1)
314 printk(KERN_WARNING PREFIX "NMI not connected to LINT 1!\n"); 314 printk(KERN_WARNING PREFIX "NMI not connected to LINT 1!\n");
315 315
316 return 0; 316 return 0;
317 } 317 }
318 318
319 #endif /*CONFIG_X86_LOCAL_APIC */ 319 #endif /*CONFIG_X86_LOCAL_APIC */
320 320
321 #ifdef CONFIG_X86_IO_APIC 321 #ifdef CONFIG_X86_IO_APIC
322 #define MP_ISA_BUS 0 322 #define MP_ISA_BUS 0
323 323
324 static void __init mp_override_legacy_irq(u8 bus_irq, u8 polarity, u8 trigger, 324 static void __init mp_override_legacy_irq(u8 bus_irq, u8 polarity, u8 trigger,
325 u32 gsi) 325 u32 gsi)
326 { 326 {
327 int ioapic; 327 int ioapic;
328 int pin; 328 int pin;
329 struct mpc_intsrc mp_irq; 329 struct mpc_intsrc mp_irq;
330 330
331 /* 331 /*
332 * Convert 'gsi' to 'ioapic.pin'. 332 * Convert 'gsi' to 'ioapic.pin'.
333 */ 333 */
334 ioapic = mp_find_ioapic(gsi); 334 ioapic = mp_find_ioapic(gsi);
335 if (ioapic < 0) 335 if (ioapic < 0)
336 return; 336 return;
337 pin = mp_find_ioapic_pin(ioapic, gsi); 337 pin = mp_find_ioapic_pin(ioapic, gsi);
338 338
339 /* 339 /*
340 * TBD: This check is for faulty timer entries, where the override 340 * TBD: This check is for faulty timer entries, where the override
341 * erroneously sets the trigger to level, resulting in a HUGE 341 * erroneously sets the trigger to level, resulting in a HUGE
342 * increase of timer interrupts! 342 * increase of timer interrupts!
343 */ 343 */
344 if ((bus_irq == 0) && (trigger == 3)) 344 if ((bus_irq == 0) && (trigger == 3))
345 trigger = 1; 345 trigger = 1;
346 346
347 mp_irq.type = MP_INTSRC; 347 mp_irq.type = MP_INTSRC;
348 mp_irq.irqtype = mp_INT; 348 mp_irq.irqtype = mp_INT;
349 mp_irq.irqflag = (trigger << 2) | polarity; 349 mp_irq.irqflag = (trigger << 2) | polarity;
350 mp_irq.srcbus = MP_ISA_BUS; 350 mp_irq.srcbus = MP_ISA_BUS;
351 mp_irq.srcbusirq = bus_irq; /* IRQ */ 351 mp_irq.srcbusirq = bus_irq; /* IRQ */
352 mp_irq.dstapic = mpc_ioapic_id(ioapic); /* APIC ID */ 352 mp_irq.dstapic = mpc_ioapic_id(ioapic); /* APIC ID */
353 mp_irq.dstirq = pin; /* INTIN# */ 353 mp_irq.dstirq = pin; /* INTIN# */
354 354
355 mp_save_irq(&mp_irq); 355 mp_save_irq(&mp_irq);
356 356
357 /* 357 /*
358 * Reset default identity mapping if gsi is also an legacy IRQ, 358 * Reset default identity mapping if gsi is also an legacy IRQ,
359 * otherwise there will be more than one entry with the same GSI 359 * otherwise there will be more than one entry with the same GSI
360 * and acpi_isa_irq_to_gsi() may give wrong result. 360 * and acpi_isa_irq_to_gsi() may give wrong result.
361 */ 361 */
362 if (gsi < nr_legacy_irqs() && isa_irq_to_gsi[gsi] == gsi) 362 if (gsi < nr_legacy_irqs() && isa_irq_to_gsi[gsi] == gsi)
363 isa_irq_to_gsi[gsi] = ACPI_INVALID_GSI; 363 isa_irq_to_gsi[gsi] = ACPI_INVALID_GSI;
364 isa_irq_to_gsi[bus_irq] = gsi; 364 isa_irq_to_gsi[bus_irq] = gsi;
365 } 365 }
366 366
367 static int mp_config_acpi_gsi(struct device *dev, u32 gsi, int trigger, 367 static int mp_config_acpi_gsi(struct device *dev, u32 gsi, int trigger,
368 int polarity) 368 int polarity)
369 { 369 {
370 #ifdef CONFIG_X86_MPPARSE 370 #ifdef CONFIG_X86_MPPARSE
371 struct mpc_intsrc mp_irq; 371 struct mpc_intsrc mp_irq;
372 struct pci_dev *pdev; 372 struct pci_dev *pdev;
373 unsigned char number; 373 unsigned char number;
374 unsigned int devfn; 374 unsigned int devfn;
375 int ioapic; 375 int ioapic;
376 u8 pin; 376 u8 pin;
377 377
378 if (!acpi_ioapic) 378 if (!acpi_ioapic)
379 return 0; 379 return 0;
380 if (!dev || !dev_is_pci(dev)) 380 if (!dev || !dev_is_pci(dev))
381 return 0; 381 return 0;
382 382
383 pdev = to_pci_dev(dev); 383 pdev = to_pci_dev(dev);
384 number = pdev->bus->number; 384 number = pdev->bus->number;
385 devfn = pdev->devfn; 385 devfn = pdev->devfn;
386 pin = pdev->pin; 386 pin = pdev->pin;
387 /* print the entry should happen on mptable identically */ 387 /* print the entry should happen on mptable identically */
388 mp_irq.type = MP_INTSRC; 388 mp_irq.type = MP_INTSRC;
389 mp_irq.irqtype = mp_INT; 389 mp_irq.irqtype = mp_INT;
390 mp_irq.irqflag = (trigger == ACPI_EDGE_SENSITIVE ? 4 : 0x0c) | 390 mp_irq.irqflag = (trigger == ACPI_EDGE_SENSITIVE ? 4 : 0x0c) |
391 (polarity == ACPI_ACTIVE_HIGH ? 1 : 3); 391 (polarity == ACPI_ACTIVE_HIGH ? 1 : 3);
392 mp_irq.srcbus = number; 392 mp_irq.srcbus = number;
393 mp_irq.srcbusirq = (((devfn >> 3) & 0x1f) << 2) | ((pin - 1) & 3); 393 mp_irq.srcbusirq = (((devfn >> 3) & 0x1f) << 2) | ((pin - 1) & 3);
394 ioapic = mp_find_ioapic(gsi); 394 ioapic = mp_find_ioapic(gsi);
395 mp_irq.dstapic = mpc_ioapic_id(ioapic); 395 mp_irq.dstapic = mpc_ioapic_id(ioapic);
396 mp_irq.dstirq = mp_find_ioapic_pin(ioapic, gsi); 396 mp_irq.dstirq = mp_find_ioapic_pin(ioapic, gsi);
397 397
398 mp_save_irq(&mp_irq); 398 mp_save_irq(&mp_irq);
399 #endif 399 #endif
400 return 0; 400 return 0;
401 } 401 }
402 402
403 static int mp_register_gsi(struct device *dev, u32 gsi, int trigger, 403 static int mp_register_gsi(struct device *dev, u32 gsi, int trigger,
404 int polarity) 404 int polarity)
405 { 405 {
406 int irq, node; 406 int irq, node;
407 407
408 if (acpi_irq_model != ACPI_IRQ_MODEL_IOAPIC) 408 if (acpi_irq_model != ACPI_IRQ_MODEL_IOAPIC)
409 return gsi; 409 return gsi;
410 410
411 trigger = trigger == ACPI_EDGE_SENSITIVE ? 0 : 1; 411 trigger = trigger == ACPI_EDGE_SENSITIVE ? 0 : 1;
412 polarity = polarity == ACPI_ACTIVE_HIGH ? 0 : 1; 412 polarity = polarity == ACPI_ACTIVE_HIGH ? 0 : 1;
413 node = dev ? dev_to_node(dev) : NUMA_NO_NODE; 413 node = dev ? dev_to_node(dev) : NUMA_NO_NODE;
414 if (mp_set_gsi_attr(gsi, trigger, polarity, node)) { 414 if (mp_set_gsi_attr(gsi, trigger, polarity, node)) {
415 pr_warn("Failed to set pin attr for GSI%d\n", gsi); 415 pr_warn("Failed to set pin attr for GSI%d\n", gsi);
416 return -1; 416 return -1;
417 } 417 }
418 418
419 irq = mp_map_gsi_to_irq(gsi, IOAPIC_MAP_ALLOC); 419 irq = mp_map_gsi_to_irq(gsi, IOAPIC_MAP_ALLOC);
420 if (irq < 0) 420 if (irq < 0)
421 return irq; 421 return irq;
422 422
423 /* Don't set up the ACPI SCI because it's already set up */ 423 /* Don't set up the ACPI SCI because it's already set up */
424 if (enable_update_mptable && acpi_gbl_FADT.sci_interrupt != gsi) 424 if (enable_update_mptable && acpi_gbl_FADT.sci_interrupt != gsi)
425 mp_config_acpi_gsi(dev, gsi, trigger, polarity); 425 mp_config_acpi_gsi(dev, gsi, trigger, polarity);
426 426
427 return irq; 427 return irq;
428 } 428 }
429 429
430 static void mp_unregister_gsi(u32 gsi) 430 static void mp_unregister_gsi(u32 gsi)
431 { 431 {
432 int irq; 432 int irq;
433 433
434 if (acpi_irq_model != ACPI_IRQ_MODEL_IOAPIC) 434 if (acpi_irq_model != ACPI_IRQ_MODEL_IOAPIC)
435 return; 435 return;
436 436
437 irq = mp_map_gsi_to_irq(gsi, 0); 437 irq = mp_map_gsi_to_irq(gsi, 0);
438 if (irq > 0) 438 if (irq > 0)
439 mp_unmap_irq(irq); 439 mp_unmap_irq(irq);
440 } 440 }
441 441
442 static struct irq_domain_ops acpi_irqdomain_ops = { 442 static struct irq_domain_ops acpi_irqdomain_ops = {
443 .map = mp_irqdomain_map, 443 .map = mp_irqdomain_map,
444 .unmap = mp_irqdomain_unmap, 444 .unmap = mp_irqdomain_unmap,
445 }; 445 };
446 446
447 static int __init 447 static int __init
448 acpi_parse_ioapic(struct acpi_subtable_header * header, const unsigned long end) 448 acpi_parse_ioapic(struct acpi_subtable_header * header, const unsigned long end)
449 { 449 {
450 struct acpi_madt_io_apic *ioapic = NULL; 450 struct acpi_madt_io_apic *ioapic = NULL;
451 struct ioapic_domain_cfg cfg = { 451 struct ioapic_domain_cfg cfg = {
452 .type = IOAPIC_DOMAIN_DYNAMIC, 452 .type = IOAPIC_DOMAIN_DYNAMIC,
453 .ops = &acpi_irqdomain_ops, 453 .ops = &acpi_irqdomain_ops,
454 }; 454 };
455 455
456 ioapic = (struct acpi_madt_io_apic *)header; 456 ioapic = (struct acpi_madt_io_apic *)header;
457 457
458 if (BAD_MADT_ENTRY(ioapic, end)) 458 if (BAD_MADT_ENTRY(ioapic, end))
459 return -EINVAL; 459 return -EINVAL;
460 460
461 acpi_table_print_madt_entry(header); 461 acpi_table_print_madt_entry(header);
462 462
463 /* Statically assign IRQ numbers for IOAPICs hosting legacy IRQs */ 463 /* Statically assign IRQ numbers for IOAPICs hosting legacy IRQs */
464 if (ioapic->global_irq_base < nr_legacy_irqs()) 464 if (ioapic->global_irq_base < nr_legacy_irqs())
465 cfg.type = IOAPIC_DOMAIN_LEGACY; 465 cfg.type = IOAPIC_DOMAIN_LEGACY;
466 466
467 mp_register_ioapic(ioapic->id, ioapic->address, ioapic->global_irq_base, 467 mp_register_ioapic(ioapic->id, ioapic->address, ioapic->global_irq_base,
468 &cfg); 468 &cfg);
469 469
470 return 0; 470 return 0;
471 } 471 }
472 472
473 /* 473 /*
474 * Parse Interrupt Source Override for the ACPI SCI 474 * Parse Interrupt Source Override for the ACPI SCI
475 */ 475 */
476 static void __init acpi_sci_ioapic_setup(u8 bus_irq, u16 polarity, u16 trigger, u32 gsi) 476 static void __init acpi_sci_ioapic_setup(u8 bus_irq, u16 polarity, u16 trigger, u32 gsi)
477 { 477 {
478 if (trigger == 0) /* compatible SCI trigger is level */ 478 if (trigger == 0) /* compatible SCI trigger is level */
479 trigger = 3; 479 trigger = 3;
480 480
481 if (polarity == 0) /* compatible SCI polarity is low */ 481 if (polarity == 0) /* compatible SCI polarity is low */
482 polarity = 3; 482 polarity = 3;
483 483
484 /* Command-line over-ride via acpi_sci= */ 484 /* Command-line over-ride via acpi_sci= */
485 if (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) 485 if (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)
486 trigger = (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2; 486 trigger = (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2;
487 487
488 if (acpi_sci_flags & ACPI_MADT_POLARITY_MASK) 488 if (acpi_sci_flags & ACPI_MADT_POLARITY_MASK)
489 polarity = acpi_sci_flags & ACPI_MADT_POLARITY_MASK; 489 polarity = acpi_sci_flags & ACPI_MADT_POLARITY_MASK;
490 490
491 mp_override_legacy_irq(bus_irq, polarity, trigger, gsi); 491 mp_override_legacy_irq(bus_irq, polarity, trigger, gsi);
492 492
493 /* 493 /*
494 * stash over-ride to indicate we've been here 494 * stash over-ride to indicate we've been here
495 * and for later update of acpi_gbl_FADT 495 * and for later update of acpi_gbl_FADT
496 */ 496 */
497 acpi_sci_override_gsi = gsi; 497 acpi_sci_override_gsi = gsi;
498 return; 498 return;
499 } 499 }
500 500
501 static int __init 501 static int __init
502 acpi_parse_int_src_ovr(struct acpi_subtable_header * header, 502 acpi_parse_int_src_ovr(struct acpi_subtable_header * header,
503 const unsigned long end) 503 const unsigned long end)
504 { 504 {
505 struct acpi_madt_interrupt_override *intsrc = NULL; 505 struct acpi_madt_interrupt_override *intsrc = NULL;
506 506
507 intsrc = (struct acpi_madt_interrupt_override *)header; 507 intsrc = (struct acpi_madt_interrupt_override *)header;
508 508
509 if (BAD_MADT_ENTRY(intsrc, end)) 509 if (BAD_MADT_ENTRY(intsrc, end))
510 return -EINVAL; 510 return -EINVAL;
511 511
512 acpi_table_print_madt_entry(header); 512 acpi_table_print_madt_entry(header);
513 513
514 if (intsrc->source_irq == acpi_gbl_FADT.sci_interrupt) { 514 if (intsrc->source_irq == acpi_gbl_FADT.sci_interrupt) {
515 acpi_sci_ioapic_setup(intsrc->source_irq, 515 acpi_sci_ioapic_setup(intsrc->source_irq,
516 intsrc->inti_flags & ACPI_MADT_POLARITY_MASK, 516 intsrc->inti_flags & ACPI_MADT_POLARITY_MASK,
517 (intsrc->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2, 517 (intsrc->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2,
518 intsrc->global_irq); 518 intsrc->global_irq);
519 return 0; 519 return 0;
520 } 520 }
521 521
522 if (intsrc->source_irq == 0) { 522 if (intsrc->source_irq == 0) {
523 if (acpi_skip_timer_override) { 523 if (acpi_skip_timer_override) {
524 printk(PREFIX "BIOS IRQ0 override ignored.\n"); 524 printk(PREFIX "BIOS IRQ0 override ignored.\n");
525 return 0; 525 return 0;
526 } 526 }
527 527
528 if ((intsrc->global_irq == 2) && acpi_fix_pin2_polarity 528 if ((intsrc->global_irq == 2) && acpi_fix_pin2_polarity
529 && (intsrc->inti_flags & ACPI_MADT_POLARITY_MASK)) { 529 && (intsrc->inti_flags & ACPI_MADT_POLARITY_MASK)) {
530 intsrc->inti_flags &= ~ACPI_MADT_POLARITY_MASK; 530 intsrc->inti_flags &= ~ACPI_MADT_POLARITY_MASK;
531 printk(PREFIX "BIOS IRQ0 pin2 override: forcing polarity to high active.\n"); 531 printk(PREFIX "BIOS IRQ0 pin2 override: forcing polarity to high active.\n");
532 } 532 }
533 } 533 }
534 534
535 mp_override_legacy_irq(intsrc->source_irq, 535 mp_override_legacy_irq(intsrc->source_irq,
536 intsrc->inti_flags & ACPI_MADT_POLARITY_MASK, 536 intsrc->inti_flags & ACPI_MADT_POLARITY_MASK,
537 (intsrc->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2, 537 (intsrc->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2,
538 intsrc->global_irq); 538 intsrc->global_irq);
539 539
540 return 0; 540 return 0;
541 } 541 }
542 542
543 static int __init 543 static int __init
544 acpi_parse_nmi_src(struct acpi_subtable_header * header, const unsigned long end) 544 acpi_parse_nmi_src(struct acpi_subtable_header * header, const unsigned long end)
545 { 545 {
546 struct acpi_madt_nmi_source *nmi_src = NULL; 546 struct acpi_madt_nmi_source *nmi_src = NULL;
547 547
548 nmi_src = (struct acpi_madt_nmi_source *)header; 548 nmi_src = (struct acpi_madt_nmi_source *)header;
549 549
550 if (BAD_MADT_ENTRY(nmi_src, end)) 550 if (BAD_MADT_ENTRY(nmi_src, end))
551 return -EINVAL; 551 return -EINVAL;
552 552
553 acpi_table_print_madt_entry(header); 553 acpi_table_print_madt_entry(header);
554 554
555 /* TBD: Support nimsrc entries? */ 555 /* TBD: Support nimsrc entries? */
556 556
557 return 0; 557 return 0;
558 } 558 }
559 559
560 #endif /* CONFIG_X86_IO_APIC */ 560 #endif /* CONFIG_X86_IO_APIC */
561 561
562 /* 562 /*
563 * acpi_pic_sci_set_trigger() 563 * acpi_pic_sci_set_trigger()
564 * 564 *
565 * use ELCR to set PIC-mode trigger type for SCI 565 * use ELCR to set PIC-mode trigger type for SCI
566 * 566 *
567 * If a PIC-mode SCI is not recognized or gives spurious IRQ7's 567 * If a PIC-mode SCI is not recognized or gives spurious IRQ7's
568 * it may require Edge Trigger -- use "acpi_sci=edge" 568 * it may require Edge Trigger -- use "acpi_sci=edge"
569 * 569 *
570 * Port 0x4d0-4d1 are ECLR1 and ECLR2, the Edge/Level Control Registers 570 * Port 0x4d0-4d1 are ECLR1 and ECLR2, the Edge/Level Control Registers
571 * for the 8259 PIC. bit[n] = 1 means irq[n] is Level, otherwise Edge. 571 * for the 8259 PIC. bit[n] = 1 means irq[n] is Level, otherwise Edge.
572 * ECLR1 is IRQs 0-7 (IRQ 0, 1, 2 must be 0) 572 * ECLR1 is IRQs 0-7 (IRQ 0, 1, 2 must be 0)
573 * ECLR2 is IRQs 8-15 (IRQ 8, 13 must be 0) 573 * ECLR2 is IRQs 8-15 (IRQ 8, 13 must be 0)
574 */ 574 */
575 575
576 void __init acpi_pic_sci_set_trigger(unsigned int irq, u16 trigger) 576 void __init acpi_pic_sci_set_trigger(unsigned int irq, u16 trigger)
577 { 577 {
578 unsigned int mask = 1 << irq; 578 unsigned int mask = 1 << irq;
579 unsigned int old, new; 579 unsigned int old, new;
580 580
581 /* Real old ELCR mask */ 581 /* Real old ELCR mask */
582 old = inb(0x4d0) | (inb(0x4d1) << 8); 582 old = inb(0x4d0) | (inb(0x4d1) << 8);
583 583
584 /* 584 /*
585 * If we use ACPI to set PCI IRQs, then we should clear ELCR 585 * If we use ACPI to set PCI IRQs, then we should clear ELCR
586 * since we will set it correctly as we enable the PCI irq 586 * since we will set it correctly as we enable the PCI irq
587 * routing. 587 * routing.
588 */ 588 */
589 new = acpi_noirq ? old : 0; 589 new = acpi_noirq ? old : 0;
590 590
591 /* 591 /*
592 * Update SCI information in the ELCR, it isn't in the PCI 592 * Update SCI information in the ELCR, it isn't in the PCI
593 * routing tables.. 593 * routing tables..
594 */ 594 */
595 switch (trigger) { 595 switch (trigger) {
596 case 1: /* Edge - clear */ 596 case 1: /* Edge - clear */
597 new &= ~mask; 597 new &= ~mask;
598 break; 598 break;
599 case 3: /* Level - set */ 599 case 3: /* Level - set */
600 new |= mask; 600 new |= mask;
601 break; 601 break;
602 } 602 }
603 603
604 if (old == new) 604 if (old == new)
605 return; 605 return;
606 606
607 printk(PREFIX "setting ELCR to %04x (from %04x)\n", new, old); 607 printk(PREFIX "setting ELCR to %04x (from %04x)\n", new, old);
608 outb(new, 0x4d0); 608 outb(new, 0x4d0);
609 outb(new >> 8, 0x4d1); 609 outb(new >> 8, 0x4d1);
610 } 610 }
611 611
612 int acpi_gsi_to_irq(u32 gsi, unsigned int *irqp) 612 int acpi_gsi_to_irq(u32 gsi, unsigned int *irqp)
613 { 613 {
614 int rc, irq, trigger, polarity; 614 int rc, irq, trigger, polarity;
615 615
616 if (acpi_irq_model == ACPI_IRQ_MODEL_PIC) {
617 *irqp = gsi;
618 return 0;
619 }
620
616 rc = acpi_get_override_irq(gsi, &trigger, &polarity); 621 rc = acpi_get_override_irq(gsi, &trigger, &polarity);
617 if (rc == 0) { 622 if (rc == 0) {
618 trigger = trigger ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE; 623 trigger = trigger ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE;
619 polarity = polarity ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH; 624 polarity = polarity ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH;
620 irq = acpi_register_gsi(NULL, gsi, trigger, polarity); 625 irq = acpi_register_gsi(NULL, gsi, trigger, polarity);
621 if (irq >= 0) { 626 if (irq >= 0) {
622 *irqp = irq; 627 *irqp = irq;
623 return 0; 628 return 0;
624 } 629 }
625 } 630 }
626 631
627 return -1; 632 return -1;
628 } 633 }
629 EXPORT_SYMBOL_GPL(acpi_gsi_to_irq); 634 EXPORT_SYMBOL_GPL(acpi_gsi_to_irq);
630 635
631 int acpi_isa_irq_to_gsi(unsigned isa_irq, u32 *gsi) 636 int acpi_isa_irq_to_gsi(unsigned isa_irq, u32 *gsi)
632 { 637 {
633 if (isa_irq < nr_legacy_irqs() && 638 if (isa_irq < nr_legacy_irqs() &&
634 isa_irq_to_gsi[isa_irq] != ACPI_INVALID_GSI) { 639 isa_irq_to_gsi[isa_irq] != ACPI_INVALID_GSI) {
635 *gsi = isa_irq_to_gsi[isa_irq]; 640 *gsi = isa_irq_to_gsi[isa_irq];
636 return 0; 641 return 0;
637 } 642 }
638 643
639 return -1; 644 return -1;
640 } 645 }
641 646
642 static int acpi_register_gsi_pic(struct device *dev, u32 gsi, 647 static int acpi_register_gsi_pic(struct device *dev, u32 gsi,
643 int trigger, int polarity) 648 int trigger, int polarity)
644 { 649 {
645 #ifdef CONFIG_PCI 650 #ifdef CONFIG_PCI
646 /* 651 /*
647 * Make sure all (legacy) PCI IRQs are set as level-triggered. 652 * Make sure all (legacy) PCI IRQs are set as level-triggered.
648 */ 653 */
649 if (trigger == ACPI_LEVEL_SENSITIVE) 654 if (trigger == ACPI_LEVEL_SENSITIVE)
650 eisa_set_level_irq(gsi); 655 eisa_set_level_irq(gsi);
651 #endif 656 #endif
652 657
653 return gsi; 658 return gsi;
654 } 659 }
655 660
656 static int acpi_register_gsi_ioapic(struct device *dev, u32 gsi, 661 static int acpi_register_gsi_ioapic(struct device *dev, u32 gsi,
657 int trigger, int polarity) 662 int trigger, int polarity)
658 { 663 {
659 int irq = gsi; 664 int irq = gsi;
660 665
661 #ifdef CONFIG_X86_IO_APIC 666 #ifdef CONFIG_X86_IO_APIC
662 mutex_lock(&acpi_ioapic_lock); 667 mutex_lock(&acpi_ioapic_lock);
663 irq = mp_register_gsi(dev, gsi, trigger, polarity); 668 irq = mp_register_gsi(dev, gsi, trigger, polarity);
664 mutex_unlock(&acpi_ioapic_lock); 669 mutex_unlock(&acpi_ioapic_lock);
665 #endif 670 #endif
666 671
667 return irq; 672 return irq;
668 } 673 }
669 674
670 static void acpi_unregister_gsi_ioapic(u32 gsi) 675 static void acpi_unregister_gsi_ioapic(u32 gsi)
671 { 676 {
672 #ifdef CONFIG_X86_IO_APIC 677 #ifdef CONFIG_X86_IO_APIC
673 mutex_lock(&acpi_ioapic_lock); 678 mutex_lock(&acpi_ioapic_lock);
674 mp_unregister_gsi(gsi); 679 mp_unregister_gsi(gsi);
675 mutex_unlock(&acpi_ioapic_lock); 680 mutex_unlock(&acpi_ioapic_lock);
676 #endif 681 #endif
677 } 682 }
678 683
679 int (*__acpi_register_gsi)(struct device *dev, u32 gsi, 684 int (*__acpi_register_gsi)(struct device *dev, u32 gsi,
680 int trigger, int polarity) = acpi_register_gsi_pic; 685 int trigger, int polarity) = acpi_register_gsi_pic;
681 void (*__acpi_unregister_gsi)(u32 gsi) = NULL; 686 void (*__acpi_unregister_gsi)(u32 gsi) = NULL;
682 687
683 #ifdef CONFIG_ACPI_SLEEP 688 #ifdef CONFIG_ACPI_SLEEP
684 int (*acpi_suspend_lowlevel)(void) = x86_acpi_suspend_lowlevel; 689 int (*acpi_suspend_lowlevel)(void) = x86_acpi_suspend_lowlevel;
685 #else 690 #else
686 int (*acpi_suspend_lowlevel)(void); 691 int (*acpi_suspend_lowlevel)(void);
687 #endif 692 #endif
688 693
689 /* 694 /*
690 * success: return IRQ number (>=0) 695 * success: return IRQ number (>=0)
691 * failure: return < 0 696 * failure: return < 0
692 */ 697 */
693 int acpi_register_gsi(struct device *dev, u32 gsi, int trigger, int polarity) 698 int acpi_register_gsi(struct device *dev, u32 gsi, int trigger, int polarity)
694 { 699 {
695 return __acpi_register_gsi(dev, gsi, trigger, polarity); 700 return __acpi_register_gsi(dev, gsi, trigger, polarity);
696 } 701 }
697 EXPORT_SYMBOL_GPL(acpi_register_gsi); 702 EXPORT_SYMBOL_GPL(acpi_register_gsi);
698 703
699 void acpi_unregister_gsi(u32 gsi) 704 void acpi_unregister_gsi(u32 gsi)
700 { 705 {
701 if (__acpi_unregister_gsi) 706 if (__acpi_unregister_gsi)
702 __acpi_unregister_gsi(gsi); 707 __acpi_unregister_gsi(gsi);
703 } 708 }
704 EXPORT_SYMBOL_GPL(acpi_unregister_gsi); 709 EXPORT_SYMBOL_GPL(acpi_unregister_gsi);
705 710
706 #ifdef CONFIG_X86_LOCAL_APIC 711 #ifdef CONFIG_X86_LOCAL_APIC
707 static void __init acpi_set_irq_model_ioapic(void) 712 static void __init acpi_set_irq_model_ioapic(void)
708 { 713 {
709 acpi_irq_model = ACPI_IRQ_MODEL_IOAPIC; 714 acpi_irq_model = ACPI_IRQ_MODEL_IOAPIC;
710 __acpi_register_gsi = acpi_register_gsi_ioapic; 715 __acpi_register_gsi = acpi_register_gsi_ioapic;
711 __acpi_unregister_gsi = acpi_unregister_gsi_ioapic; 716 __acpi_unregister_gsi = acpi_unregister_gsi_ioapic;
712 acpi_ioapic = 1; 717 acpi_ioapic = 1;
713 } 718 }
714 #endif 719 #endif
715 720
716 /* 721 /*
717 * ACPI based hotplug support for CPU 722 * ACPI based hotplug support for CPU
718 */ 723 */
719 #ifdef CONFIG_ACPI_HOTPLUG_CPU 724 #ifdef CONFIG_ACPI_HOTPLUG_CPU
720 #include <acpi/processor.h> 725 #include <acpi/processor.h>
721 726
722 static void acpi_map_cpu2node(acpi_handle handle, int cpu, int physid) 727 static void acpi_map_cpu2node(acpi_handle handle, int cpu, int physid)
723 { 728 {
724 #ifdef CONFIG_ACPI_NUMA 729 #ifdef CONFIG_ACPI_NUMA
725 int nid; 730 int nid;
726 731
727 nid = acpi_get_node(handle); 732 nid = acpi_get_node(handle);
728 if (nid != -1) { 733 if (nid != -1) {
729 set_apicid_to_node(physid, nid); 734 set_apicid_to_node(physid, nid);
730 numa_set_node(cpu, nid); 735 numa_set_node(cpu, nid);
731 } 736 }
732 #endif 737 #endif
733 } 738 }
734 739
735 static int _acpi_map_lsapic(acpi_handle handle, int physid, int *pcpu) 740 static int _acpi_map_lsapic(acpi_handle handle, int physid, int *pcpu)
736 { 741 {
737 int cpu; 742 int cpu;
738 743
739 cpu = acpi_register_lapic(physid, ACPI_MADT_ENABLED); 744 cpu = acpi_register_lapic(physid, ACPI_MADT_ENABLED);
740 if (cpu < 0) { 745 if (cpu < 0) {
741 pr_info(PREFIX "Unable to map lapic to logical cpu number\n"); 746 pr_info(PREFIX "Unable to map lapic to logical cpu number\n");
742 return cpu; 747 return cpu;
743 } 748 }
744 749
745 acpi_processor_set_pdc(handle); 750 acpi_processor_set_pdc(handle);
746 acpi_map_cpu2node(handle, cpu, physid); 751 acpi_map_cpu2node(handle, cpu, physid);
747 752
748 *pcpu = cpu; 753 *pcpu = cpu;
749 return 0; 754 return 0;
750 } 755 }
751 756
752 /* wrapper to silence section mismatch warning */ 757 /* wrapper to silence section mismatch warning */
753 int __ref acpi_map_cpu(acpi_handle handle, int physid, int *pcpu) 758 int __ref acpi_map_cpu(acpi_handle handle, int physid, int *pcpu)
754 { 759 {
755 return _acpi_map_lsapic(handle, physid, pcpu); 760 return _acpi_map_lsapic(handle, physid, pcpu);
756 } 761 }
757 EXPORT_SYMBOL(acpi_map_cpu); 762 EXPORT_SYMBOL(acpi_map_cpu);
758 763
759 int acpi_unmap_cpu(int cpu) 764 int acpi_unmap_cpu(int cpu)
760 { 765 {
761 #ifdef CONFIG_ACPI_NUMA 766 #ifdef CONFIG_ACPI_NUMA
762 set_apicid_to_node(per_cpu(x86_cpu_to_apicid, cpu), NUMA_NO_NODE); 767 set_apicid_to_node(per_cpu(x86_cpu_to_apicid, cpu), NUMA_NO_NODE);
763 #endif 768 #endif
764 769
765 per_cpu(x86_cpu_to_apicid, cpu) = -1; 770 per_cpu(x86_cpu_to_apicid, cpu) = -1;
766 set_cpu_present(cpu, false); 771 set_cpu_present(cpu, false);
767 num_processors--; 772 num_processors--;
768 773
769 return (0); 774 return (0);
770 } 775 }
771 EXPORT_SYMBOL(acpi_unmap_cpu); 776 EXPORT_SYMBOL(acpi_unmap_cpu);
772 #endif /* CONFIG_ACPI_HOTPLUG_CPU */ 777 #endif /* CONFIG_ACPI_HOTPLUG_CPU */
773 778
774 int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base) 779 int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base)
775 { 780 {
776 int ret = -ENOSYS; 781 int ret = -ENOSYS;
777 #ifdef CONFIG_ACPI_HOTPLUG_IOAPIC 782 #ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
778 int ioapic_id; 783 int ioapic_id;
779 u64 addr; 784 u64 addr;
780 struct ioapic_domain_cfg cfg = { 785 struct ioapic_domain_cfg cfg = {
781 .type = IOAPIC_DOMAIN_DYNAMIC, 786 .type = IOAPIC_DOMAIN_DYNAMIC,
782 .ops = &acpi_irqdomain_ops, 787 .ops = &acpi_irqdomain_ops,
783 }; 788 };
784 789
785 ioapic_id = acpi_get_ioapic_id(handle, gsi_base, &addr); 790 ioapic_id = acpi_get_ioapic_id(handle, gsi_base, &addr);
786 if (ioapic_id < 0) { 791 if (ioapic_id < 0) {
787 unsigned long long uid; 792 unsigned long long uid;
788 acpi_status status; 793 acpi_status status;
789 794
790 status = acpi_evaluate_integer(handle, METHOD_NAME__UID, 795 status = acpi_evaluate_integer(handle, METHOD_NAME__UID,
791 NULL, &uid); 796 NULL, &uid);
792 if (ACPI_FAILURE(status)) { 797 if (ACPI_FAILURE(status)) {
793 acpi_handle_warn(handle, "failed to get IOAPIC ID.\n"); 798 acpi_handle_warn(handle, "failed to get IOAPIC ID.\n");
794 return -EINVAL; 799 return -EINVAL;
795 } 800 }
796 ioapic_id = (int)uid; 801 ioapic_id = (int)uid;
797 } 802 }
798 803
799 mutex_lock(&acpi_ioapic_lock); 804 mutex_lock(&acpi_ioapic_lock);
800 ret = mp_register_ioapic(ioapic_id, phys_addr, gsi_base, &cfg); 805 ret = mp_register_ioapic(ioapic_id, phys_addr, gsi_base, &cfg);
801 mutex_unlock(&acpi_ioapic_lock); 806 mutex_unlock(&acpi_ioapic_lock);
802 #endif 807 #endif
803 808
804 return ret; 809 return ret;
805 } 810 }
806 EXPORT_SYMBOL(acpi_register_ioapic); 811 EXPORT_SYMBOL(acpi_register_ioapic);
807 812
808 int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base) 813 int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base)
809 { 814 {
810 int ret = -ENOSYS; 815 int ret = -ENOSYS;
811 816
812 #ifdef CONFIG_ACPI_HOTPLUG_IOAPIC 817 #ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
813 mutex_lock(&acpi_ioapic_lock); 818 mutex_lock(&acpi_ioapic_lock);
814 ret = mp_unregister_ioapic(gsi_base); 819 ret = mp_unregister_ioapic(gsi_base);
815 mutex_unlock(&acpi_ioapic_lock); 820 mutex_unlock(&acpi_ioapic_lock);
816 #endif 821 #endif
817 822
818 return ret; 823 return ret;
819 } 824 }
820 EXPORT_SYMBOL(acpi_unregister_ioapic); 825 EXPORT_SYMBOL(acpi_unregister_ioapic);
821 826
822 /** 827 /**
823 * acpi_ioapic_registered - Check whether IOAPIC assoicatied with @gsi_base 828 * acpi_ioapic_registered - Check whether IOAPIC assoicatied with @gsi_base
824 * has been registered 829 * has been registered
825 * @handle: ACPI handle of the IOAPIC deivce 830 * @handle: ACPI handle of the IOAPIC deivce
826 * @gsi_base: GSI base associated with the IOAPIC 831 * @gsi_base: GSI base associated with the IOAPIC
827 * 832 *
828 * Assume caller holds some type of lock to serialize acpi_ioapic_registered() 833 * Assume caller holds some type of lock to serialize acpi_ioapic_registered()
829 * with acpi_register_ioapic()/acpi_unregister_ioapic(). 834 * with acpi_register_ioapic()/acpi_unregister_ioapic().
830 */ 835 */
831 int acpi_ioapic_registered(acpi_handle handle, u32 gsi_base) 836 int acpi_ioapic_registered(acpi_handle handle, u32 gsi_base)
832 { 837 {
833 int ret = 0; 838 int ret = 0;
834 839
835 #ifdef CONFIG_ACPI_HOTPLUG_IOAPIC 840 #ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
836 mutex_lock(&acpi_ioapic_lock); 841 mutex_lock(&acpi_ioapic_lock);
837 ret = mp_ioapic_registered(gsi_base); 842 ret = mp_ioapic_registered(gsi_base);
838 mutex_unlock(&acpi_ioapic_lock); 843 mutex_unlock(&acpi_ioapic_lock);
839 #endif 844 #endif
840 845
841 return ret; 846 return ret;
842 } 847 }
843 848
844 static int __init acpi_parse_sbf(struct acpi_table_header *table) 849 static int __init acpi_parse_sbf(struct acpi_table_header *table)
845 { 850 {
846 struct acpi_table_boot *sb; 851 struct acpi_table_boot *sb;
847 852
848 sb = (struct acpi_table_boot *)table; 853 sb = (struct acpi_table_boot *)table;
849 if (!sb) { 854 if (!sb) {
850 printk(KERN_WARNING PREFIX "Unable to map SBF\n"); 855 printk(KERN_WARNING PREFIX "Unable to map SBF\n");
851 return -ENODEV; 856 return -ENODEV;
852 } 857 }
853 858
854 sbf_port = sb->cmos_index; /* Save CMOS port */ 859 sbf_port = sb->cmos_index; /* Save CMOS port */
855 860
856 return 0; 861 return 0;
857 } 862 }
858 863
859 #ifdef CONFIG_HPET_TIMER 864 #ifdef CONFIG_HPET_TIMER
860 #include <asm/hpet.h> 865 #include <asm/hpet.h>
861 866
862 static struct resource *hpet_res __initdata; 867 static struct resource *hpet_res __initdata;
863 868
864 static int __init acpi_parse_hpet(struct acpi_table_header *table) 869 static int __init acpi_parse_hpet(struct acpi_table_header *table)
865 { 870 {
866 struct acpi_table_hpet *hpet_tbl; 871 struct acpi_table_hpet *hpet_tbl;
867 872
868 hpet_tbl = (struct acpi_table_hpet *)table; 873 hpet_tbl = (struct acpi_table_hpet *)table;
869 if (!hpet_tbl) { 874 if (!hpet_tbl) {
870 printk(KERN_WARNING PREFIX "Unable to map HPET\n"); 875 printk(KERN_WARNING PREFIX "Unable to map HPET\n");
871 return -ENODEV; 876 return -ENODEV;
872 } 877 }
873 878
874 if (hpet_tbl->address.space_id != ACPI_SPACE_MEM) { 879 if (hpet_tbl->address.space_id != ACPI_SPACE_MEM) {
875 printk(KERN_WARNING PREFIX "HPET timers must be located in " 880 printk(KERN_WARNING PREFIX "HPET timers must be located in "
876 "memory.\n"); 881 "memory.\n");
877 return -1; 882 return -1;
878 } 883 }
879 884
880 hpet_address = hpet_tbl->address.address; 885 hpet_address = hpet_tbl->address.address;
881 hpet_blockid = hpet_tbl->sequence; 886 hpet_blockid = hpet_tbl->sequence;
882 887
883 /* 888 /*
884 * Some broken BIOSes advertise HPET at 0x0. We really do not 889 * Some broken BIOSes advertise HPET at 0x0. We really do not
885 * want to allocate a resource there. 890 * want to allocate a resource there.
886 */ 891 */
887 if (!hpet_address) { 892 if (!hpet_address) {
888 printk(KERN_WARNING PREFIX 893 printk(KERN_WARNING PREFIX
889 "HPET id: %#x base: %#lx is invalid\n", 894 "HPET id: %#x base: %#lx is invalid\n",
890 hpet_tbl->id, hpet_address); 895 hpet_tbl->id, hpet_address);
891 return 0; 896 return 0;
892 } 897 }
893 #ifdef CONFIG_X86_64 898 #ifdef CONFIG_X86_64
894 /* 899 /*
895 * Some even more broken BIOSes advertise HPET at 900 * Some even more broken BIOSes advertise HPET at
896 * 0xfed0000000000000 instead of 0xfed00000. Fix it up and add 901 * 0xfed0000000000000 instead of 0xfed00000. Fix it up and add
897 * some noise: 902 * some noise:
898 */ 903 */
899 if (hpet_address == 0xfed0000000000000UL) { 904 if (hpet_address == 0xfed0000000000000UL) {
900 if (!hpet_force_user) { 905 if (!hpet_force_user) {
901 printk(KERN_WARNING PREFIX "HPET id: %#x " 906 printk(KERN_WARNING PREFIX "HPET id: %#x "
902 "base: 0xfed0000000000000 is bogus\n " 907 "base: 0xfed0000000000000 is bogus\n "
903 "try hpet=force on the kernel command line to " 908 "try hpet=force on the kernel command line to "
904 "fix it up to 0xfed00000.\n", hpet_tbl->id); 909 "fix it up to 0xfed00000.\n", hpet_tbl->id);
905 hpet_address = 0; 910 hpet_address = 0;
906 return 0; 911 return 0;
907 } 912 }
908 printk(KERN_WARNING PREFIX 913 printk(KERN_WARNING PREFIX
909 "HPET id: %#x base: 0xfed0000000000000 fixed up " 914 "HPET id: %#x base: 0xfed0000000000000 fixed up "
910 "to 0xfed00000.\n", hpet_tbl->id); 915 "to 0xfed00000.\n", hpet_tbl->id);
911 hpet_address >>= 32; 916 hpet_address >>= 32;
912 } 917 }
913 #endif 918 #endif
914 printk(KERN_INFO PREFIX "HPET id: %#x base: %#lx\n", 919 printk(KERN_INFO PREFIX "HPET id: %#x base: %#lx\n",
915 hpet_tbl->id, hpet_address); 920 hpet_tbl->id, hpet_address);
916 921
917 /* 922 /*
918 * Allocate and initialize the HPET firmware resource for adding into 923 * Allocate and initialize the HPET firmware resource for adding into
919 * the resource tree during the lateinit timeframe. 924 * the resource tree during the lateinit timeframe.
920 */ 925 */
921 #define HPET_RESOURCE_NAME_SIZE 9 926 #define HPET_RESOURCE_NAME_SIZE 9
922 hpet_res = alloc_bootmem(sizeof(*hpet_res) + HPET_RESOURCE_NAME_SIZE); 927 hpet_res = alloc_bootmem(sizeof(*hpet_res) + HPET_RESOURCE_NAME_SIZE);
923 928
924 hpet_res->name = (void *)&hpet_res[1]; 929 hpet_res->name = (void *)&hpet_res[1];
925 hpet_res->flags = IORESOURCE_MEM; 930 hpet_res->flags = IORESOURCE_MEM;
926 snprintf((char *)hpet_res->name, HPET_RESOURCE_NAME_SIZE, "HPET %u", 931 snprintf((char *)hpet_res->name, HPET_RESOURCE_NAME_SIZE, "HPET %u",
927 hpet_tbl->sequence); 932 hpet_tbl->sequence);
928 933
929 hpet_res->start = hpet_address; 934 hpet_res->start = hpet_address;
930 hpet_res->end = hpet_address + (1 * 1024) - 1; 935 hpet_res->end = hpet_address + (1 * 1024) - 1;
931 936
932 return 0; 937 return 0;
933 } 938 }
934 939
935 /* 940 /*
936 * hpet_insert_resource inserts the HPET resources used into the resource 941 * hpet_insert_resource inserts the HPET resources used into the resource
937 * tree. 942 * tree.
938 */ 943 */
939 static __init int hpet_insert_resource(void) 944 static __init int hpet_insert_resource(void)
940 { 945 {
941 if (!hpet_res) 946 if (!hpet_res)
942 return 1; 947 return 1;
943 948
944 return insert_resource(&iomem_resource, hpet_res); 949 return insert_resource(&iomem_resource, hpet_res);
945 } 950 }
946 951
947 late_initcall(hpet_insert_resource); 952 late_initcall(hpet_insert_resource);
948 953
949 #else 954 #else
950 #define acpi_parse_hpet NULL 955 #define acpi_parse_hpet NULL
951 #endif 956 #endif
952 957
953 static int __init acpi_parse_fadt(struct acpi_table_header *table) 958 static int __init acpi_parse_fadt(struct acpi_table_header *table)
954 { 959 {
955 960
956 #ifdef CONFIG_X86_PM_TIMER 961 #ifdef CONFIG_X86_PM_TIMER
957 /* detect the location of the ACPI PM Timer */ 962 /* detect the location of the ACPI PM Timer */
958 if (acpi_gbl_FADT.header.revision >= FADT2_REVISION_ID) { 963 if (acpi_gbl_FADT.header.revision >= FADT2_REVISION_ID) {
959 /* FADT rev. 2 */ 964 /* FADT rev. 2 */
960 if (acpi_gbl_FADT.xpm_timer_block.space_id != 965 if (acpi_gbl_FADT.xpm_timer_block.space_id !=
961 ACPI_ADR_SPACE_SYSTEM_IO) 966 ACPI_ADR_SPACE_SYSTEM_IO)
962 return 0; 967 return 0;
963 968
964 pmtmr_ioport = acpi_gbl_FADT.xpm_timer_block.address; 969 pmtmr_ioport = acpi_gbl_FADT.xpm_timer_block.address;
965 /* 970 /*
966 * "X" fields are optional extensions to the original V1.0 971 * "X" fields are optional extensions to the original V1.0
967 * fields, so we must selectively expand V1.0 fields if the 972 * fields, so we must selectively expand V1.0 fields if the
968 * corresponding X field is zero. 973 * corresponding X field is zero.
969 */ 974 */
970 if (!pmtmr_ioport) 975 if (!pmtmr_ioport)
971 pmtmr_ioport = acpi_gbl_FADT.pm_timer_block; 976 pmtmr_ioport = acpi_gbl_FADT.pm_timer_block;
972 } else { 977 } else {
973 /* FADT rev. 1 */ 978 /* FADT rev. 1 */
974 pmtmr_ioport = acpi_gbl_FADT.pm_timer_block; 979 pmtmr_ioport = acpi_gbl_FADT.pm_timer_block;
975 } 980 }
976 if (pmtmr_ioport) 981 if (pmtmr_ioport)
977 printk(KERN_INFO PREFIX "PM-Timer IO Port: %#x\n", 982 printk(KERN_INFO PREFIX "PM-Timer IO Port: %#x\n",
978 pmtmr_ioport); 983 pmtmr_ioport);
979 #endif 984 #endif
980 return 0; 985 return 0;
981 } 986 }
982 987
983 #ifdef CONFIG_X86_LOCAL_APIC 988 #ifdef CONFIG_X86_LOCAL_APIC
984 /* 989 /*
985 * Parse LAPIC entries in MADT 990 * Parse LAPIC entries in MADT
986 * returns 0 on success, < 0 on error 991 * returns 0 on success, < 0 on error
987 */ 992 */
988 993
989 static int __init early_acpi_parse_madt_lapic_addr_ovr(void) 994 static int __init early_acpi_parse_madt_lapic_addr_ovr(void)
990 { 995 {
991 int count; 996 int count;
992 997
993 if (!cpu_has_apic) 998 if (!cpu_has_apic)
994 return -ENODEV; 999 return -ENODEV;
995 1000
996 /* 1001 /*
997 * Note that the LAPIC address is obtained from the MADT (32-bit value) 1002 * Note that the LAPIC address is obtained from the MADT (32-bit value)
998 * and (optionally) overriden by a LAPIC_ADDR_OVR entry (64-bit value). 1003 * and (optionally) overriden by a LAPIC_ADDR_OVR entry (64-bit value).
999 */ 1004 */
1000 1005
1001 count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE, 1006 count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE,
1002 acpi_parse_lapic_addr_ovr, 0); 1007 acpi_parse_lapic_addr_ovr, 0);
1003 if (count < 0) { 1008 if (count < 0) {
1004 printk(KERN_ERR PREFIX 1009 printk(KERN_ERR PREFIX
1005 "Error parsing LAPIC address override entry\n"); 1010 "Error parsing LAPIC address override entry\n");
1006 return count; 1011 return count;
1007 } 1012 }
1008 1013
1009 register_lapic_address(acpi_lapic_addr); 1014 register_lapic_address(acpi_lapic_addr);
1010 1015
1011 return count; 1016 return count;
1012 } 1017 }
1013 1018
1014 static int __init acpi_parse_madt_lapic_entries(void) 1019 static int __init acpi_parse_madt_lapic_entries(void)
1015 { 1020 {
1016 int count; 1021 int count;
1017 int x2count = 0; 1022 int x2count = 0;
1018 1023
1019 if (!cpu_has_apic) 1024 if (!cpu_has_apic)
1020 return -ENODEV; 1025 return -ENODEV;
1021 1026
1022 /* 1027 /*
1023 * Note that the LAPIC address is obtained from the MADT (32-bit value) 1028 * Note that the LAPIC address is obtained from the MADT (32-bit value)
1024 * and (optionally) overriden by a LAPIC_ADDR_OVR entry (64-bit value). 1029 * and (optionally) overriden by a LAPIC_ADDR_OVR entry (64-bit value).
1025 */ 1030 */
1026 1031
1027 count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE, 1032 count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE,
1028 acpi_parse_lapic_addr_ovr, 0); 1033 acpi_parse_lapic_addr_ovr, 0);
1029 if (count < 0) { 1034 if (count < 0) {
1030 printk(KERN_ERR PREFIX 1035 printk(KERN_ERR PREFIX
1031 "Error parsing LAPIC address override entry\n"); 1036 "Error parsing LAPIC address override entry\n");
1032 return count; 1037 return count;
1033 } 1038 }
1034 1039
1035 register_lapic_address(acpi_lapic_addr); 1040 register_lapic_address(acpi_lapic_addr);
1036 1041
1037 count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_SAPIC, 1042 count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_SAPIC,
1038 acpi_parse_sapic, MAX_LOCAL_APIC); 1043 acpi_parse_sapic, MAX_LOCAL_APIC);
1039 1044
1040 if (!count) { 1045 if (!count) {
1041 x2count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_X2APIC, 1046 x2count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_X2APIC,
1042 acpi_parse_x2apic, MAX_LOCAL_APIC); 1047 acpi_parse_x2apic, MAX_LOCAL_APIC);
1043 count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC, 1048 count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC,
1044 acpi_parse_lapic, MAX_LOCAL_APIC); 1049 acpi_parse_lapic, MAX_LOCAL_APIC);
1045 } 1050 }
1046 if (!count && !x2count) { 1051 if (!count && !x2count) {
1047 printk(KERN_ERR PREFIX "No LAPIC entries present\n"); 1052 printk(KERN_ERR PREFIX "No LAPIC entries present\n");
1048 /* TBD: Cleanup to allow fallback to MPS */ 1053 /* TBD: Cleanup to allow fallback to MPS */
1049 return -ENODEV; 1054 return -ENODEV;
1050 } else if (count < 0 || x2count < 0) { 1055 } else if (count < 0 || x2count < 0) {
1051 printk(KERN_ERR PREFIX "Error parsing LAPIC entry\n"); 1056 printk(KERN_ERR PREFIX "Error parsing LAPIC entry\n");
1052 /* TBD: Cleanup to allow fallback to MPS */ 1057 /* TBD: Cleanup to allow fallback to MPS */
1053 return count; 1058 return count;
1054 } 1059 }
1055 1060
1056 x2count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_X2APIC_NMI, 1061 x2count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_X2APIC_NMI,
1057 acpi_parse_x2apic_nmi, 0); 1062 acpi_parse_x2apic_nmi, 0);
1058 count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_NMI, 1063 count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_NMI,
1059 acpi_parse_lapic_nmi, 0); 1064 acpi_parse_lapic_nmi, 0);
1060 if (count < 0 || x2count < 0) { 1065 if (count < 0 || x2count < 0) {
1061 printk(KERN_ERR PREFIX "Error parsing LAPIC NMI entry\n"); 1066 printk(KERN_ERR PREFIX "Error parsing LAPIC NMI entry\n");
1062 /* TBD: Cleanup to allow fallback to MPS */ 1067 /* TBD: Cleanup to allow fallback to MPS */
1063 return count; 1068 return count;
1064 } 1069 }
1065 return 0; 1070 return 0;
1066 } 1071 }
1067 #endif /* CONFIG_X86_LOCAL_APIC */ 1072 #endif /* CONFIG_X86_LOCAL_APIC */
1068 1073
1069 #ifdef CONFIG_X86_IO_APIC 1074 #ifdef CONFIG_X86_IO_APIC
1070 static void __init mp_config_acpi_legacy_irqs(void) 1075 static void __init mp_config_acpi_legacy_irqs(void)
1071 { 1076 {
1072 int i; 1077 int i;
1073 struct mpc_intsrc mp_irq; 1078 struct mpc_intsrc mp_irq;
1074 1079
1075 #ifdef CONFIG_EISA 1080 #ifdef CONFIG_EISA
1076 /* 1081 /*
1077 * Fabricate the legacy ISA bus (bus #31). 1082 * Fabricate the legacy ISA bus (bus #31).
1078 */ 1083 */
1079 mp_bus_id_to_type[MP_ISA_BUS] = MP_BUS_ISA; 1084 mp_bus_id_to_type[MP_ISA_BUS] = MP_BUS_ISA;
1080 #endif 1085 #endif
1081 set_bit(MP_ISA_BUS, mp_bus_not_pci); 1086 set_bit(MP_ISA_BUS, mp_bus_not_pci);
1082 pr_debug("Bus #%d is ISA\n", MP_ISA_BUS); 1087 pr_debug("Bus #%d is ISA\n", MP_ISA_BUS);
1083 1088
1084 /* 1089 /*
1085 * Use the default configuration for the IRQs 0-15. Unless 1090 * Use the default configuration for the IRQs 0-15. Unless
1086 * overridden by (MADT) interrupt source override entries. 1091 * overridden by (MADT) interrupt source override entries.
1087 */ 1092 */
1088 for (i = 0; i < nr_legacy_irqs(); i++) { 1093 for (i = 0; i < nr_legacy_irqs(); i++) {
1089 int ioapic, pin; 1094 int ioapic, pin;
1090 unsigned int dstapic; 1095 unsigned int dstapic;
1091 int idx; 1096 int idx;
1092 u32 gsi; 1097 u32 gsi;
1093 1098
1094 /* Locate the gsi that irq i maps to. */ 1099 /* Locate the gsi that irq i maps to. */
1095 if (acpi_isa_irq_to_gsi(i, &gsi)) 1100 if (acpi_isa_irq_to_gsi(i, &gsi))
1096 continue; 1101 continue;
1097 1102
1098 /* 1103 /*
1099 * Locate the IOAPIC that manages the ISA IRQ. 1104 * Locate the IOAPIC that manages the ISA IRQ.
1100 */ 1105 */
1101 ioapic = mp_find_ioapic(gsi); 1106 ioapic = mp_find_ioapic(gsi);
1102 if (ioapic < 0) 1107 if (ioapic < 0)
1103 continue; 1108 continue;
1104 pin = mp_find_ioapic_pin(ioapic, gsi); 1109 pin = mp_find_ioapic_pin(ioapic, gsi);
1105 dstapic = mpc_ioapic_id(ioapic); 1110 dstapic = mpc_ioapic_id(ioapic);
1106 1111
1107 for (idx = 0; idx < mp_irq_entries; idx++) { 1112 for (idx = 0; idx < mp_irq_entries; idx++) {
1108 struct mpc_intsrc *irq = mp_irqs + idx; 1113 struct mpc_intsrc *irq = mp_irqs + idx;
1109 1114
1110 /* Do we already have a mapping for this ISA IRQ? */ 1115 /* Do we already have a mapping for this ISA IRQ? */
1111 if (irq->srcbus == MP_ISA_BUS && irq->srcbusirq == i) 1116 if (irq->srcbus == MP_ISA_BUS && irq->srcbusirq == i)
1112 break; 1117 break;
1113 1118
1114 /* Do we already have a mapping for this IOAPIC pin */ 1119 /* Do we already have a mapping for this IOAPIC pin */
1115 if (irq->dstapic == dstapic && irq->dstirq == pin) 1120 if (irq->dstapic == dstapic && irq->dstirq == pin)
1116 break; 1121 break;
1117 } 1122 }
1118 1123
1119 if (idx != mp_irq_entries) { 1124 if (idx != mp_irq_entries) {
1120 printk(KERN_DEBUG "ACPI: IRQ%d used by override.\n", i); 1125 printk(KERN_DEBUG "ACPI: IRQ%d used by override.\n", i);
1121 continue; /* IRQ already used */ 1126 continue; /* IRQ already used */
1122 } 1127 }
1123 1128
1124 mp_irq.type = MP_INTSRC; 1129 mp_irq.type = MP_INTSRC;
1125 mp_irq.irqflag = 0; /* Conforming */ 1130 mp_irq.irqflag = 0; /* Conforming */
1126 mp_irq.srcbus = MP_ISA_BUS; 1131 mp_irq.srcbus = MP_ISA_BUS;
1127 mp_irq.dstapic = dstapic; 1132 mp_irq.dstapic = dstapic;
1128 mp_irq.irqtype = mp_INT; 1133 mp_irq.irqtype = mp_INT;
1129 mp_irq.srcbusirq = i; /* Identity mapped */ 1134 mp_irq.srcbusirq = i; /* Identity mapped */
1130 mp_irq.dstirq = pin; 1135 mp_irq.dstirq = pin;
1131 1136
1132 mp_save_irq(&mp_irq); 1137 mp_save_irq(&mp_irq);
1133 } 1138 }
1134 } 1139 }
1135 1140
1136 /* 1141 /*
1137 * Parse IOAPIC related entries in MADT 1142 * Parse IOAPIC related entries in MADT
1138 * returns 0 on success, < 0 on error 1143 * returns 0 on success, < 0 on error
1139 */ 1144 */
1140 static int __init acpi_parse_madt_ioapic_entries(void) 1145 static int __init acpi_parse_madt_ioapic_entries(void)
1141 { 1146 {
1142 int count; 1147 int count;
1143 1148
1144 /* 1149 /*
1145 * ACPI interpreter is required to complete interrupt setup, 1150 * ACPI interpreter is required to complete interrupt setup,
1146 * so if it is off, don't enumerate the io-apics with ACPI. 1151 * so if it is off, don't enumerate the io-apics with ACPI.
1147 * If MPS is present, it will handle them, 1152 * If MPS is present, it will handle them,
1148 * otherwise the system will stay in PIC mode 1153 * otherwise the system will stay in PIC mode
1149 */ 1154 */
1150 if (acpi_disabled || acpi_noirq) 1155 if (acpi_disabled || acpi_noirq)
1151 return -ENODEV; 1156 return -ENODEV;
1152 1157
1153 if (!cpu_has_apic) 1158 if (!cpu_has_apic)
1154 return -ENODEV; 1159 return -ENODEV;
1155 1160
1156 /* 1161 /*
1157 * if "noapic" boot option, don't look for IO-APICs 1162 * if "noapic" boot option, don't look for IO-APICs
1158 */ 1163 */
1159 if (skip_ioapic_setup) { 1164 if (skip_ioapic_setup) {
1160 printk(KERN_INFO PREFIX "Skipping IOAPIC probe " 1165 printk(KERN_INFO PREFIX "Skipping IOAPIC probe "
1161 "due to 'noapic' option.\n"); 1166 "due to 'noapic' option.\n");
1162 return -ENODEV; 1167 return -ENODEV;
1163 } 1168 }
1164 1169
1165 count = acpi_table_parse_madt(ACPI_MADT_TYPE_IO_APIC, acpi_parse_ioapic, 1170 count = acpi_table_parse_madt(ACPI_MADT_TYPE_IO_APIC, acpi_parse_ioapic,
1166 MAX_IO_APICS); 1171 MAX_IO_APICS);
1167 if (!count) { 1172 if (!count) {
1168 printk(KERN_ERR PREFIX "No IOAPIC entries present\n"); 1173 printk(KERN_ERR PREFIX "No IOAPIC entries present\n");
1169 return -ENODEV; 1174 return -ENODEV;
1170 } else if (count < 0) { 1175 } else if (count < 0) {
1171 printk(KERN_ERR PREFIX "Error parsing IOAPIC entry\n"); 1176 printk(KERN_ERR PREFIX "Error parsing IOAPIC entry\n");
1172 return count; 1177 return count;
1173 } 1178 }
1174 1179
1175 count = acpi_table_parse_madt(ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, 1180 count = acpi_table_parse_madt(ACPI_MADT_TYPE_INTERRUPT_OVERRIDE,
1176 acpi_parse_int_src_ovr, nr_irqs); 1181 acpi_parse_int_src_ovr, nr_irqs);
1177 if (count < 0) { 1182 if (count < 0) {
1178 printk(KERN_ERR PREFIX 1183 printk(KERN_ERR PREFIX
1179 "Error parsing interrupt source overrides entry\n"); 1184 "Error parsing interrupt source overrides entry\n");
1180 /* TBD: Cleanup to allow fallback to MPS */ 1185 /* TBD: Cleanup to allow fallback to MPS */
1181 return count; 1186 return count;
1182 } 1187 }
1183 1188
1184 /* 1189 /*
1185 * If BIOS did not supply an INT_SRC_OVR for the SCI 1190 * If BIOS did not supply an INT_SRC_OVR for the SCI
1186 * pretend we got one so we can set the SCI flags. 1191 * pretend we got one so we can set the SCI flags.
1187 */ 1192 */
1188 if (!acpi_sci_override_gsi) 1193 if (!acpi_sci_override_gsi)
1189 acpi_sci_ioapic_setup(acpi_gbl_FADT.sci_interrupt, 0, 0, 1194 acpi_sci_ioapic_setup(acpi_gbl_FADT.sci_interrupt, 0, 0,
1190 acpi_gbl_FADT.sci_interrupt); 1195 acpi_gbl_FADT.sci_interrupt);
1191 1196
1192 /* Fill in identity legacy mappings where no override */ 1197 /* Fill in identity legacy mappings where no override */
1193 mp_config_acpi_legacy_irqs(); 1198 mp_config_acpi_legacy_irqs();
1194 1199
1195 count = acpi_table_parse_madt(ACPI_MADT_TYPE_NMI_SOURCE, 1200 count = acpi_table_parse_madt(ACPI_MADT_TYPE_NMI_SOURCE,
1196 acpi_parse_nmi_src, nr_irqs); 1201 acpi_parse_nmi_src, nr_irqs);
1197 if (count < 0) { 1202 if (count < 0) {
1198 printk(KERN_ERR PREFIX "Error parsing NMI SRC entry\n"); 1203 printk(KERN_ERR PREFIX "Error parsing NMI SRC entry\n");
1199 /* TBD: Cleanup to allow fallback to MPS */ 1204 /* TBD: Cleanup to allow fallback to MPS */
1200 return count; 1205 return count;
1201 } 1206 }
1202 1207
1203 return 0; 1208 return 0;
1204 } 1209 }
1205 #else 1210 #else
1206 static inline int acpi_parse_madt_ioapic_entries(void) 1211 static inline int acpi_parse_madt_ioapic_entries(void)
1207 { 1212 {
1208 return -1; 1213 return -1;
1209 } 1214 }
1210 #endif /* !CONFIG_X86_IO_APIC */ 1215 #endif /* !CONFIG_X86_IO_APIC */
1211 1216
1212 static void __init early_acpi_process_madt(void) 1217 static void __init early_acpi_process_madt(void)
1213 { 1218 {
1214 #ifdef CONFIG_X86_LOCAL_APIC 1219 #ifdef CONFIG_X86_LOCAL_APIC
1215 int error; 1220 int error;
1216 1221
1217 if (!acpi_table_parse(ACPI_SIG_MADT, acpi_parse_madt)) { 1222 if (!acpi_table_parse(ACPI_SIG_MADT, acpi_parse_madt)) {
1218 1223
1219 /* 1224 /*
1220 * Parse MADT LAPIC entries 1225 * Parse MADT LAPIC entries
1221 */ 1226 */
1222 error = early_acpi_parse_madt_lapic_addr_ovr(); 1227 error = early_acpi_parse_madt_lapic_addr_ovr();
1223 if (!error) { 1228 if (!error) {
1224 acpi_lapic = 1; 1229 acpi_lapic = 1;
1225 smp_found_config = 1; 1230 smp_found_config = 1;
1226 } 1231 }
1227 if (error == -EINVAL) { 1232 if (error == -EINVAL) {
1228 /* 1233 /*
1229 * Dell Precision Workstation 410, 610 come here. 1234 * Dell Precision Workstation 410, 610 come here.
1230 */ 1235 */
1231 printk(KERN_ERR PREFIX 1236 printk(KERN_ERR PREFIX
1232 "Invalid BIOS MADT, disabling ACPI\n"); 1237 "Invalid BIOS MADT, disabling ACPI\n");
1233 disable_acpi(); 1238 disable_acpi();
1234 } 1239 }
1235 } 1240 }
1236 #endif 1241 #endif
1237 } 1242 }
1238 1243
1239 static void __init acpi_process_madt(void) 1244 static void __init acpi_process_madt(void)
1240 { 1245 {
1241 #ifdef CONFIG_X86_LOCAL_APIC 1246 #ifdef CONFIG_X86_LOCAL_APIC
1242 int error; 1247 int error;
1243 1248
1244 if (!acpi_table_parse(ACPI_SIG_MADT, acpi_parse_madt)) { 1249 if (!acpi_table_parse(ACPI_SIG_MADT, acpi_parse_madt)) {
1245 1250
1246 /* 1251 /*
1247 * Parse MADT LAPIC entries 1252 * Parse MADT LAPIC entries
1248 */ 1253 */
1249 error = acpi_parse_madt_lapic_entries(); 1254 error = acpi_parse_madt_lapic_entries();
1250 if (!error) { 1255 if (!error) {
1251 acpi_lapic = 1; 1256 acpi_lapic = 1;
1252 1257
1253 /* 1258 /*
1254 * Parse MADT IO-APIC entries 1259 * Parse MADT IO-APIC entries
1255 */ 1260 */
1256 mutex_lock(&acpi_ioapic_lock); 1261 mutex_lock(&acpi_ioapic_lock);
1257 error = acpi_parse_madt_ioapic_entries(); 1262 error = acpi_parse_madt_ioapic_entries();
1258 mutex_unlock(&acpi_ioapic_lock); 1263 mutex_unlock(&acpi_ioapic_lock);
1259 if (!error) { 1264 if (!error) {
1260 acpi_set_irq_model_ioapic(); 1265 acpi_set_irq_model_ioapic();
1261 1266
1262 smp_found_config = 1; 1267 smp_found_config = 1;
1263 } 1268 }
1264 } 1269 }
1265 if (error == -EINVAL) { 1270 if (error == -EINVAL) {
1266 /* 1271 /*
1267 * Dell Precision Workstation 410, 610 come here. 1272 * Dell Precision Workstation 410, 610 come here.
1268 */ 1273 */
1269 printk(KERN_ERR PREFIX 1274 printk(KERN_ERR PREFIX
1270 "Invalid BIOS MADT, disabling ACPI\n"); 1275 "Invalid BIOS MADT, disabling ACPI\n");
1271 disable_acpi(); 1276 disable_acpi();
1272 } 1277 }
1273 } else { 1278 } else {
1274 /* 1279 /*
1275 * ACPI found no MADT, and so ACPI wants UP PIC mode. 1280 * ACPI found no MADT, and so ACPI wants UP PIC mode.
1276 * In the event an MPS table was found, forget it. 1281 * In the event an MPS table was found, forget it.
1277 * Boot with "acpi=off" to use MPS on such a system. 1282 * Boot with "acpi=off" to use MPS on such a system.
1278 */ 1283 */
1279 if (smp_found_config) { 1284 if (smp_found_config) {
1280 printk(KERN_WARNING PREFIX 1285 printk(KERN_WARNING PREFIX
1281 "No APIC-table, disabling MPS\n"); 1286 "No APIC-table, disabling MPS\n");
1282 smp_found_config = 0; 1287 smp_found_config = 0;
1283 } 1288 }
1284 } 1289 }
1285 1290
1286 /* 1291 /*
1287 * ACPI supports both logical (e.g. Hyper-Threading) and physical 1292 * ACPI supports both logical (e.g. Hyper-Threading) and physical
1288 * processors, where MPS only supports physical. 1293 * processors, where MPS only supports physical.
1289 */ 1294 */
1290 if (acpi_lapic && acpi_ioapic) 1295 if (acpi_lapic && acpi_ioapic)
1291 printk(KERN_INFO "Using ACPI (MADT) for SMP configuration " 1296 printk(KERN_INFO "Using ACPI (MADT) for SMP configuration "
1292 "information\n"); 1297 "information\n");
1293 else if (acpi_lapic) 1298 else if (acpi_lapic)
1294 printk(KERN_INFO "Using ACPI for processor (LAPIC) " 1299 printk(KERN_INFO "Using ACPI for processor (LAPIC) "
1295 "configuration information\n"); 1300 "configuration information\n");
1296 #endif 1301 #endif
1297 return; 1302 return;
1298 } 1303 }
1299 1304
1300 static int __init disable_acpi_irq(const struct dmi_system_id *d) 1305 static int __init disable_acpi_irq(const struct dmi_system_id *d)
1301 { 1306 {
1302 if (!acpi_force) { 1307 if (!acpi_force) {
1303 printk(KERN_NOTICE "%s detected: force use of acpi=noirq\n", 1308 printk(KERN_NOTICE "%s detected: force use of acpi=noirq\n",
1304 d->ident); 1309 d->ident);
1305 acpi_noirq_set(); 1310 acpi_noirq_set();
1306 } 1311 }
1307 return 0; 1312 return 0;
1308 } 1313 }
1309 1314
1310 static int __init disable_acpi_pci(const struct dmi_system_id *d) 1315 static int __init disable_acpi_pci(const struct dmi_system_id *d)
1311 { 1316 {
1312 if (!acpi_force) { 1317 if (!acpi_force) {
1313 printk(KERN_NOTICE "%s detected: force use of pci=noacpi\n", 1318 printk(KERN_NOTICE "%s detected: force use of pci=noacpi\n",
1314 d->ident); 1319 d->ident);
1315 acpi_disable_pci(); 1320 acpi_disable_pci();
1316 } 1321 }
1317 return 0; 1322 return 0;
1318 } 1323 }
1319 1324
1320 static int __init dmi_disable_acpi(const struct dmi_system_id *d) 1325 static int __init dmi_disable_acpi(const struct dmi_system_id *d)
1321 { 1326 {
1322 if (!acpi_force) { 1327 if (!acpi_force) {
1323 printk(KERN_NOTICE "%s detected: acpi off\n", d->ident); 1328 printk(KERN_NOTICE "%s detected: acpi off\n", d->ident);
1324 disable_acpi(); 1329 disable_acpi();
1325 } else { 1330 } else {
1326 printk(KERN_NOTICE 1331 printk(KERN_NOTICE
1327 "Warning: DMI blacklist says broken, but acpi forced\n"); 1332 "Warning: DMI blacklist says broken, but acpi forced\n");
1328 } 1333 }
1329 return 0; 1334 return 0;
1330 } 1335 }
1331 1336
1332 /* 1337 /*
1333 * Force ignoring BIOS IRQ0 override 1338 * Force ignoring BIOS IRQ0 override
1334 */ 1339 */
1335 static int __init dmi_ignore_irq0_timer_override(const struct dmi_system_id *d) 1340 static int __init dmi_ignore_irq0_timer_override(const struct dmi_system_id *d)
1336 { 1341 {
1337 if (!acpi_skip_timer_override) { 1342 if (!acpi_skip_timer_override) {
1338 pr_notice("%s detected: Ignoring BIOS IRQ0 override\n", 1343 pr_notice("%s detected: Ignoring BIOS IRQ0 override\n",
1339 d->ident); 1344 d->ident);
1340 acpi_skip_timer_override = 1; 1345 acpi_skip_timer_override = 1;
1341 } 1346 }
1342 return 0; 1347 return 0;
1343 } 1348 }
1344 1349
1345 /* 1350 /*
1346 * If your system is blacklisted here, but you find that acpi=force 1351 * If your system is blacklisted here, but you find that acpi=force
1347 * works for you, please contact linux-acpi@vger.kernel.org 1352 * works for you, please contact linux-acpi@vger.kernel.org
1348 */ 1353 */
1349 static struct dmi_system_id __initdata acpi_dmi_table[] = { 1354 static struct dmi_system_id __initdata acpi_dmi_table[] = {
1350 /* 1355 /*
1351 * Boxes that need ACPI disabled 1356 * Boxes that need ACPI disabled
1352 */ 1357 */
1353 { 1358 {
1354 .callback = dmi_disable_acpi, 1359 .callback = dmi_disable_acpi,
1355 .ident = "IBM Thinkpad", 1360 .ident = "IBM Thinkpad",
1356 .matches = { 1361 .matches = {
1357 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1362 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"),
1358 DMI_MATCH(DMI_BOARD_NAME, "2629H1G"), 1363 DMI_MATCH(DMI_BOARD_NAME, "2629H1G"),
1359 }, 1364 },
1360 }, 1365 },
1361 1366
1362 /* 1367 /*
1363 * Boxes that need ACPI PCI IRQ routing disabled 1368 * Boxes that need ACPI PCI IRQ routing disabled
1364 */ 1369 */
1365 { 1370 {
1366 .callback = disable_acpi_irq, 1371 .callback = disable_acpi_irq,
1367 .ident = "ASUS A7V", 1372 .ident = "ASUS A7V",
1368 .matches = { 1373 .matches = {
1369 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC"), 1374 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC"),
1370 DMI_MATCH(DMI_BOARD_NAME, "<A7V>"), 1375 DMI_MATCH(DMI_BOARD_NAME, "<A7V>"),
1371 /* newer BIOS, Revision 1011, does work */ 1376 /* newer BIOS, Revision 1011, does work */
1372 DMI_MATCH(DMI_BIOS_VERSION, 1377 DMI_MATCH(DMI_BIOS_VERSION,
1373 "ASUS A7V ACPI BIOS Revision 1007"), 1378 "ASUS A7V ACPI BIOS Revision 1007"),
1374 }, 1379 },
1375 }, 1380 },
1376 { 1381 {
1377 /* 1382 /*
1378 * Latest BIOS for IBM 600E (1.16) has bad pcinum 1383 * Latest BIOS for IBM 600E (1.16) has bad pcinum
1379 * for LPC bridge, which is needed for the PCI 1384 * for LPC bridge, which is needed for the PCI
1380 * interrupt links to work. DSDT fix is in bug 5966. 1385 * interrupt links to work. DSDT fix is in bug 5966.
1381 * 2645, 2646 model numbers are shared with 600/600E/600X 1386 * 2645, 2646 model numbers are shared with 600/600E/600X
1382 */ 1387 */
1383 .callback = disable_acpi_irq, 1388 .callback = disable_acpi_irq,
1384 .ident = "IBM Thinkpad 600 Series 2645", 1389 .ident = "IBM Thinkpad 600 Series 2645",
1385 .matches = { 1390 .matches = {
1386 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1391 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"),
1387 DMI_MATCH(DMI_BOARD_NAME, "2645"), 1392 DMI_MATCH(DMI_BOARD_NAME, "2645"),
1388 }, 1393 },
1389 }, 1394 },
1390 { 1395 {
1391 .callback = disable_acpi_irq, 1396 .callback = disable_acpi_irq,
1392 .ident = "IBM Thinkpad 600 Series 2646", 1397 .ident = "IBM Thinkpad 600 Series 2646",
1393 .matches = { 1398 .matches = {
1394 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1399 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"),
1395 DMI_MATCH(DMI_BOARD_NAME, "2646"), 1400 DMI_MATCH(DMI_BOARD_NAME, "2646"),
1396 }, 1401 },
1397 }, 1402 },
1398 /* 1403 /*
1399 * Boxes that need ACPI PCI IRQ routing and PCI scan disabled 1404 * Boxes that need ACPI PCI IRQ routing and PCI scan disabled
1400 */ 1405 */
1401 { /* _BBN 0 bug */ 1406 { /* _BBN 0 bug */
1402 .callback = disable_acpi_pci, 1407 .callback = disable_acpi_pci,
1403 .ident = "ASUS PR-DLS", 1408 .ident = "ASUS PR-DLS",
1404 .matches = { 1409 .matches = {
1405 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1410 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
1406 DMI_MATCH(DMI_BOARD_NAME, "PR-DLS"), 1411 DMI_MATCH(DMI_BOARD_NAME, "PR-DLS"),
1407 DMI_MATCH(DMI_BIOS_VERSION, 1412 DMI_MATCH(DMI_BIOS_VERSION,
1408 "ASUS PR-DLS ACPI BIOS Revision 1010"), 1413 "ASUS PR-DLS ACPI BIOS Revision 1010"),
1409 DMI_MATCH(DMI_BIOS_DATE, "03/21/2003") 1414 DMI_MATCH(DMI_BIOS_DATE, "03/21/2003")
1410 }, 1415 },
1411 }, 1416 },
1412 { 1417 {
1413 .callback = disable_acpi_pci, 1418 .callback = disable_acpi_pci,
1414 .ident = "Acer TravelMate 36x Laptop", 1419 .ident = "Acer TravelMate 36x Laptop",
1415 .matches = { 1420 .matches = {
1416 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 1421 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
1417 DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 360"), 1422 DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 360"),
1418 }, 1423 },
1419 }, 1424 },
1420 {} 1425 {}
1421 }; 1426 };
1422 1427
1423 /* second table for DMI checks that should run after early-quirks */ 1428 /* second table for DMI checks that should run after early-quirks */
1424 static struct dmi_system_id __initdata acpi_dmi_table_late[] = { 1429 static struct dmi_system_id __initdata acpi_dmi_table_late[] = {
1425 /* 1430 /*
1426 * HP laptops which use a DSDT reporting as HP/SB400/10000, 1431 * HP laptops which use a DSDT reporting as HP/SB400/10000,
1427 * which includes some code which overrides all temperature 1432 * which includes some code which overrides all temperature
1428 * trip points to 16C if the INTIN2 input of the I/O APIC 1433 * trip points to 16C if the INTIN2 input of the I/O APIC
1429 * is enabled. This input is incorrectly designated the 1434 * is enabled. This input is incorrectly designated the
1430 * ISA IRQ 0 via an interrupt source override even though 1435 * ISA IRQ 0 via an interrupt source override even though
1431 * it is wired to the output of the master 8259A and INTIN0 1436 * it is wired to the output of the master 8259A and INTIN0
1432 * is not connected at all. Force ignoring BIOS IRQ0 1437 * is not connected at all. Force ignoring BIOS IRQ0
1433 * override in that cases. 1438 * override in that cases.
1434 */ 1439 */
1435 { 1440 {
1436 .callback = dmi_ignore_irq0_timer_override, 1441 .callback = dmi_ignore_irq0_timer_override,
1437 .ident = "HP nx6115 laptop", 1442 .ident = "HP nx6115 laptop",
1438 .matches = { 1443 .matches = {
1439 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1444 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1440 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6115"), 1445 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6115"),
1441 }, 1446 },
1442 }, 1447 },
1443 { 1448 {
1444 .callback = dmi_ignore_irq0_timer_override, 1449 .callback = dmi_ignore_irq0_timer_override,
1445 .ident = "HP NX6125 laptop", 1450 .ident = "HP NX6125 laptop",
1446 .matches = { 1451 .matches = {
1447 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1452 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1448 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6125"), 1453 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6125"),
1449 }, 1454 },
1450 }, 1455 },
1451 { 1456 {
1452 .callback = dmi_ignore_irq0_timer_override, 1457 .callback = dmi_ignore_irq0_timer_override,
1453 .ident = "HP NX6325 laptop", 1458 .ident = "HP NX6325 laptop",
1454 .matches = { 1459 .matches = {
1455 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1460 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1456 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6325"), 1461 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6325"),
1457 }, 1462 },
1458 }, 1463 },
1459 { 1464 {
1460 .callback = dmi_ignore_irq0_timer_override, 1465 .callback = dmi_ignore_irq0_timer_override,
1461 .ident = "HP 6715b laptop", 1466 .ident = "HP 6715b laptop",
1462 .matches = { 1467 .matches = {
1463 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1468 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1464 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq 6715b"), 1469 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq 6715b"),
1465 }, 1470 },
1466 }, 1471 },
1467 { 1472 {
1468 .callback = dmi_ignore_irq0_timer_override, 1473 .callback = dmi_ignore_irq0_timer_override,
1469 .ident = "FUJITSU SIEMENS", 1474 .ident = "FUJITSU SIEMENS",
1470 .matches = { 1475 .matches = {
1471 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 1476 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1472 DMI_MATCH(DMI_PRODUCT_NAME, "AMILO PRO V2030"), 1477 DMI_MATCH(DMI_PRODUCT_NAME, "AMILO PRO V2030"),
1473 }, 1478 },
1474 }, 1479 },
1475 {} 1480 {}
1476 }; 1481 };
1477 1482
1478 /* 1483 /*
1479 * acpi_boot_table_init() and acpi_boot_init() 1484 * acpi_boot_table_init() and acpi_boot_init()
1480 * called from setup_arch(), always. 1485 * called from setup_arch(), always.
1481 * 1. checksums all tables 1486 * 1. checksums all tables
1482 * 2. enumerates lapics 1487 * 2. enumerates lapics
1483 * 3. enumerates io-apics 1488 * 3. enumerates io-apics
1484 * 1489 *
1485 * acpi_table_init() is separate to allow reading SRAT without 1490 * acpi_table_init() is separate to allow reading SRAT without
1486 * other side effects. 1491 * other side effects.
1487 * 1492 *
1488 * side effects of acpi_boot_init: 1493 * side effects of acpi_boot_init:
1489 * acpi_lapic = 1 if LAPIC found 1494 * acpi_lapic = 1 if LAPIC found
1490 * acpi_ioapic = 1 if IOAPIC found 1495 * acpi_ioapic = 1 if IOAPIC found
1491 * if (acpi_lapic && acpi_ioapic) smp_found_config = 1; 1496 * if (acpi_lapic && acpi_ioapic) smp_found_config = 1;
1492 * if acpi_blacklisted() acpi_disabled = 1; 1497 * if acpi_blacklisted() acpi_disabled = 1;
1493 * acpi_irq_model=... 1498 * acpi_irq_model=...
1494 * ... 1499 * ...
1495 */ 1500 */
1496 1501
1497 void __init acpi_boot_table_init(void) 1502 void __init acpi_boot_table_init(void)
1498 { 1503 {
1499 dmi_check_system(acpi_dmi_table); 1504 dmi_check_system(acpi_dmi_table);
1500 1505
1501 /* 1506 /*
1502 * If acpi_disabled, bail out 1507 * If acpi_disabled, bail out
1503 */ 1508 */
1504 if (acpi_disabled) 1509 if (acpi_disabled)
1505 return; 1510 return;
1506 1511
1507 /* 1512 /*
1508 * Initialize the ACPI boot-time table parser. 1513 * Initialize the ACPI boot-time table parser.
1509 */ 1514 */
1510 if (acpi_table_init()) { 1515 if (acpi_table_init()) {
1511 disable_acpi(); 1516 disable_acpi();
1512 return; 1517 return;
1513 } 1518 }
1514 1519
1515 acpi_table_parse(ACPI_SIG_BOOT, acpi_parse_sbf); 1520 acpi_table_parse(ACPI_SIG_BOOT, acpi_parse_sbf);
1516 1521
1517 /* 1522 /*
1518 * blacklist may disable ACPI entirely 1523 * blacklist may disable ACPI entirely
1519 */ 1524 */
1520 if (acpi_blacklisted()) { 1525 if (acpi_blacklisted()) {
1521 if (acpi_force) { 1526 if (acpi_force) {
1522 printk(KERN_WARNING PREFIX "acpi=force override\n"); 1527 printk(KERN_WARNING PREFIX "acpi=force override\n");
1523 } else { 1528 } else {
1524 printk(KERN_WARNING PREFIX "Disabling ACPI support\n"); 1529 printk(KERN_WARNING PREFIX "Disabling ACPI support\n");
1525 disable_acpi(); 1530 disable_acpi();
1526 return; 1531 return;
1527 } 1532 }
1528 } 1533 }
1529 } 1534 }
1530 1535
1531 int __init early_acpi_boot_init(void) 1536 int __init early_acpi_boot_init(void)
1532 { 1537 {
1533 /* 1538 /*
1534 * If acpi_disabled, bail out 1539 * If acpi_disabled, bail out
1535 */ 1540 */
1536 if (acpi_disabled) 1541 if (acpi_disabled)
1537 return 1; 1542 return 1;
1538 1543
1539 /* 1544 /*
1540 * Process the Multiple APIC Description Table (MADT), if present 1545 * Process the Multiple APIC Description Table (MADT), if present
1541 */ 1546 */
1542 early_acpi_process_madt(); 1547 early_acpi_process_madt();
1543 1548
1544 return 0; 1549 return 0;
1545 } 1550 }
1546 1551
1547 int __init acpi_boot_init(void) 1552 int __init acpi_boot_init(void)
1548 { 1553 {
1549 /* those are executed after early-quirks are executed */ 1554 /* those are executed after early-quirks are executed */
1550 dmi_check_system(acpi_dmi_table_late); 1555 dmi_check_system(acpi_dmi_table_late);
1551 1556
1552 /* 1557 /*
1553 * If acpi_disabled, bail out 1558 * If acpi_disabled, bail out
1554 */ 1559 */
1555 if (acpi_disabled) 1560 if (acpi_disabled)
1556 return 1; 1561 return 1;
1557 1562
1558 acpi_table_parse(ACPI_SIG_BOOT, acpi_parse_sbf); 1563 acpi_table_parse(ACPI_SIG_BOOT, acpi_parse_sbf);
1559 1564
1560 /* 1565 /*
1561 * set sci_int and PM timer address 1566 * set sci_int and PM timer address
1562 */ 1567 */
1563 acpi_table_parse(ACPI_SIG_FADT, acpi_parse_fadt); 1568 acpi_table_parse(ACPI_SIG_FADT, acpi_parse_fadt);
1564 1569
1565 /* 1570 /*
1566 * Process the Multiple APIC Description Table (MADT), if present 1571 * Process the Multiple APIC Description Table (MADT), if present
1567 */ 1572 */
1568 acpi_process_madt(); 1573 acpi_process_madt();
1569 1574
1570 acpi_table_parse(ACPI_SIG_HPET, acpi_parse_hpet); 1575 acpi_table_parse(ACPI_SIG_HPET, acpi_parse_hpet);
1571 1576
1572 if (!acpi_noirq) 1577 if (!acpi_noirq)
1573 x86_init.pci.init = pci_acpi_init; 1578 x86_init.pci.init = pci_acpi_init;
1574 1579
1575 return 0; 1580 return 0;
1576 } 1581 }
1577 1582
1578 static int __init parse_acpi(char *arg) 1583 static int __init parse_acpi(char *arg)
1579 { 1584 {
1580 if (!arg) 1585 if (!arg)
1581 return -EINVAL; 1586 return -EINVAL;
1582 1587
1583 /* "acpi=off" disables both ACPI table parsing and interpreter */ 1588 /* "acpi=off" disables both ACPI table parsing and interpreter */
1584 if (strcmp(arg, "off") == 0) { 1589 if (strcmp(arg, "off") == 0) {
1585 disable_acpi(); 1590 disable_acpi();
1586 } 1591 }
1587 /* acpi=force to over-ride black-list */ 1592 /* acpi=force to over-ride black-list */
1588 else if (strcmp(arg, "force") == 0) { 1593 else if (strcmp(arg, "force") == 0) {
1589 acpi_force = 1; 1594 acpi_force = 1;
1590 acpi_disabled = 0; 1595 acpi_disabled = 0;
1591 } 1596 }
1592 /* acpi=strict disables out-of-spec workarounds */ 1597 /* acpi=strict disables out-of-spec workarounds */
1593 else if (strcmp(arg, "strict") == 0) { 1598 else if (strcmp(arg, "strict") == 0) {
1594 acpi_strict = 1; 1599 acpi_strict = 1;
1595 } 1600 }
1596 /* acpi=rsdt use RSDT instead of XSDT */ 1601 /* acpi=rsdt use RSDT instead of XSDT */
1597 else if (strcmp(arg, "rsdt") == 0) { 1602 else if (strcmp(arg, "rsdt") == 0) {
1598 acpi_gbl_do_not_use_xsdt = TRUE; 1603 acpi_gbl_do_not_use_xsdt = TRUE;
1599 } 1604 }
1600 /* "acpi=noirq" disables ACPI interrupt routing */ 1605 /* "acpi=noirq" disables ACPI interrupt routing */
1601 else if (strcmp(arg, "noirq") == 0) { 1606 else if (strcmp(arg, "noirq") == 0) {
1602 acpi_noirq_set(); 1607 acpi_noirq_set();
1603 } 1608 }
1604 /* "acpi=copy_dsdt" copys DSDT */ 1609 /* "acpi=copy_dsdt" copys DSDT */
1605 else if (strcmp(arg, "copy_dsdt") == 0) { 1610 else if (strcmp(arg, "copy_dsdt") == 0) {
1606 acpi_gbl_copy_dsdt_locally = 1; 1611 acpi_gbl_copy_dsdt_locally = 1;
1607 } 1612 }
1608 /* "acpi=nocmcff" disables FF mode for corrected errors */ 1613 /* "acpi=nocmcff" disables FF mode for corrected errors */
1609 else if (strcmp(arg, "nocmcff") == 0) { 1614 else if (strcmp(arg, "nocmcff") == 0) {
1610 acpi_disable_cmcff = 1; 1615 acpi_disable_cmcff = 1;
1611 } else { 1616 } else {
1612 /* Core will printk when we return error. */ 1617 /* Core will printk when we return error. */
1613 return -EINVAL; 1618 return -EINVAL;
1614 } 1619 }
1615 return 0; 1620 return 0;
1616 } 1621 }
1617 early_param("acpi", parse_acpi); 1622 early_param("acpi", parse_acpi);
1618 1623
1619 /* FIXME: Using pci= for an ACPI parameter is a travesty. */ 1624 /* FIXME: Using pci= for an ACPI parameter is a travesty. */
1620 static int __init parse_pci(char *arg) 1625 static int __init parse_pci(char *arg)
1621 { 1626 {
1622 if (arg && strcmp(arg, "noacpi") == 0) 1627 if (arg && strcmp(arg, "noacpi") == 0)
1623 acpi_disable_pci(); 1628 acpi_disable_pci();
1624 return 0; 1629 return 0;
1625 } 1630 }
1626 early_param("pci", parse_pci); 1631 early_param("pci", parse_pci);
1627 1632
1628 int __init acpi_mps_check(void) 1633 int __init acpi_mps_check(void)
1629 { 1634 {
1630 #if defined(CONFIG_X86_LOCAL_APIC) && !defined(CONFIG_X86_MPPARSE) 1635 #if defined(CONFIG_X86_LOCAL_APIC) && !defined(CONFIG_X86_MPPARSE)
1631 /* mptable code is not built-in*/ 1636 /* mptable code is not built-in*/
1632 if (acpi_disabled || acpi_noirq) { 1637 if (acpi_disabled || acpi_noirq) {
1633 printk(KERN_WARNING "MPS support code is not built-in.\n" 1638 printk(KERN_WARNING "MPS support code is not built-in.\n"
1634 "Using acpi=off or acpi=noirq or pci=noacpi " 1639 "Using acpi=off or acpi=noirq or pci=noacpi "
1635 "may have problem\n"); 1640 "may have problem\n");
1636 return 1; 1641 return 1;
1637 } 1642 }
1638 #endif 1643 #endif
1639 return 0; 1644 return 0;
1640 } 1645 }
1641 1646
1642 #ifdef CONFIG_X86_IO_APIC 1647 #ifdef CONFIG_X86_IO_APIC
1643 static int __init parse_acpi_skip_timer_override(char *arg) 1648 static int __init parse_acpi_skip_timer_override(char *arg)
1644 { 1649 {
1645 acpi_skip_timer_override = 1; 1650 acpi_skip_timer_override = 1;
1646 return 0; 1651 return 0;
1647 } 1652 }
1648 early_param("acpi_skip_timer_override", parse_acpi_skip_timer_override); 1653 early_param("acpi_skip_timer_override", parse_acpi_skip_timer_override);
1649 1654
1650 static int __init parse_acpi_use_timer_override(char *arg) 1655 static int __init parse_acpi_use_timer_override(char *arg)
1651 { 1656 {
1652 acpi_use_timer_override = 1; 1657 acpi_use_timer_override = 1;
1653 return 0; 1658 return 0;
1654 } 1659 }
1655 early_param("acpi_use_timer_override", parse_acpi_use_timer_override); 1660 early_param("acpi_use_timer_override", parse_acpi_use_timer_override);
1656 #endif /* CONFIG_X86_IO_APIC */ 1661 #endif /* CONFIG_X86_IO_APIC */
1657 1662
1658 static int __init setup_acpi_sci(char *s) 1663 static int __init setup_acpi_sci(char *s)
1659 { 1664 {
1660 if (!s) 1665 if (!s)
1661 return -EINVAL; 1666 return -EINVAL;
1662 if (!strcmp(s, "edge")) 1667 if (!strcmp(s, "edge"))
1663 acpi_sci_flags = ACPI_MADT_TRIGGER_EDGE | 1668 acpi_sci_flags = ACPI_MADT_TRIGGER_EDGE |
1664 (acpi_sci_flags & ~ACPI_MADT_TRIGGER_MASK); 1669 (acpi_sci_flags & ~ACPI_MADT_TRIGGER_MASK);
1665 else if (!strcmp(s, "level")) 1670 else if (!strcmp(s, "level"))
1666 acpi_sci_flags = ACPI_MADT_TRIGGER_LEVEL | 1671 acpi_sci_flags = ACPI_MADT_TRIGGER_LEVEL |
1667 (acpi_sci_flags & ~ACPI_MADT_TRIGGER_MASK); 1672 (acpi_sci_flags & ~ACPI_MADT_TRIGGER_MASK);
1668 else if (!strcmp(s, "high")) 1673 else if (!strcmp(s, "high"))
1669 acpi_sci_flags = ACPI_MADT_POLARITY_ACTIVE_HIGH | 1674 acpi_sci_flags = ACPI_MADT_POLARITY_ACTIVE_HIGH |
1670 (acpi_sci_flags & ~ACPI_MADT_POLARITY_MASK); 1675 (acpi_sci_flags & ~ACPI_MADT_POLARITY_MASK);
1671 else if (!strcmp(s, "low")) 1676 else if (!strcmp(s, "low"))
1672 acpi_sci_flags = ACPI_MADT_POLARITY_ACTIVE_LOW | 1677 acpi_sci_flags = ACPI_MADT_POLARITY_ACTIVE_LOW |
1673 (acpi_sci_flags & ~ACPI_MADT_POLARITY_MASK); 1678 (acpi_sci_flags & ~ACPI_MADT_POLARITY_MASK);
1674 else 1679 else
1675 return -EINVAL; 1680 return -EINVAL;
1676 return 0; 1681 return 0;
1677 } 1682 }
1678 early_param("acpi_sci", setup_acpi_sci); 1683 early_param("acpi_sci", setup_acpi_sci);
1679 1684
1680 int __acpi_acquire_global_lock(unsigned int *lock) 1685 int __acpi_acquire_global_lock(unsigned int *lock)
1681 { 1686 {
1682 unsigned int old, new, val; 1687 unsigned int old, new, val;
1683 do { 1688 do {
1684 old = *lock; 1689 old = *lock;
1685 new = (((old & ~0x3) + 2) + ((old >> 1) & 0x1)); 1690 new = (((old & ~0x3) + 2) + ((old >> 1) & 0x1));
1686 val = cmpxchg(lock, old, new); 1691 val = cmpxchg(lock, old, new);
1687 } while (unlikely (val != old)); 1692 } while (unlikely (val != old));
1688 return (new < 3) ? -1 : 0; 1693 return (new < 3) ? -1 : 0;
1689 } 1694 }
1690 1695
1691 int __acpi_release_global_lock(unsigned int *lock) 1696 int __acpi_release_global_lock(unsigned int *lock)
1692 { 1697 {
1693 unsigned int old, new, val; 1698 unsigned int old, new, val;
1694 do { 1699 do {
1695 old = *lock; 1700 old = *lock;
1696 new = old & ~0x3; 1701 new = old & ~0x3;
1697 val = cmpxchg(lock, old, new); 1702 val = cmpxchg(lock, old, new);
1698 } while (unlikely (val != old)); 1703 } while (unlikely (val != old));
1699 return old & 0x1; 1704 return old & 0x1;
1700 } 1705 }
1701 1706
1702 void __init arch_reserve_mem_area(acpi_physical_address addr, size_t size) 1707 void __init arch_reserve_mem_area(acpi_physical_address addr, size_t size)
1703 { 1708 {
1704 e820_add_region(addr, size, E820_ACPI); 1709 e820_add_region(addr, size, E820_ACPI);
1705 update_e820(); 1710 update_e820();
1706 } 1711 }
1707 1712