xref: /openbmc/linux/drivers/acpi/osl.c (revision e2f1cf25)
1 /*
2  *  acpi_osl.c - OS-dependent functions ($Revision: 83 $)
3  *
4  *  Copyright (C) 2000       Andrew Henroid
5  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
6  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
7  *  Copyright (c) 2008 Intel Corporation
8  *   Author: Matthew Wilcox <willy@linux.intel.com>
9  *
10  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
11  *
12  *  This program is free software; you can redistribute it and/or modify
13  *  it under the terms of the GNU General Public License as published by
14  *  the Free Software Foundation; either version 2 of the License, or
15  *  (at your option) any later version.
16  *
17  *  This program is distributed in the hope that it will be useful,
18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  *  GNU General Public License for more details.
21  *
22  *  You should have received a copy of the GNU General Public License
23  *  along with this program; if not, write to the Free Software
24  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
25  *
26  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
27  *
28  */
29 
30 #include <linux/module.h>
31 #include <linux/kernel.h>
32 #include <linux/slab.h>
33 #include <linux/mm.h>
34 #include <linux/highmem.h>
35 #include <linux/pci.h>
36 #include <linux/interrupt.h>
37 #include <linux/kmod.h>
38 #include <linux/delay.h>
39 #include <linux/workqueue.h>
40 #include <linux/nmi.h>
41 #include <linux/acpi.h>
42 #include <linux/efi.h>
43 #include <linux/ioport.h>
44 #include <linux/list.h>
45 #include <linux/jiffies.h>
46 #include <linux/semaphore.h>
47 
48 #include <asm/io.h>
49 #include <asm/uaccess.h>
50 
51 #include "internal.h"
52 
53 #define _COMPONENT		ACPI_OS_SERVICES
54 ACPI_MODULE_NAME("osl");
55 
56 struct acpi_os_dpc {
57 	acpi_osd_exec_callback function;
58 	void *context;
59 	struct work_struct work;
60 };
61 
62 #ifdef CONFIG_ACPI_CUSTOM_DSDT
63 #include CONFIG_ACPI_CUSTOM_DSDT_FILE
64 #endif
65 
66 #ifdef ENABLE_DEBUGGER
67 #include <linux/kdb.h>
68 
69 /* stuff for debugger support */
70 int acpi_in_debugger;
71 EXPORT_SYMBOL(acpi_in_debugger);
72 
73 extern char line_buf[80];
74 #endif				/*ENABLE_DEBUGGER */
75 
76 static int (*__acpi_os_prepare_sleep)(u8 sleep_state, u32 pm1a_ctrl,
77 				      u32 pm1b_ctrl);
78 static int (*__acpi_os_prepare_extended_sleep)(u8 sleep_state, u32 val_a,
79 				      u32 val_b);
80 
81 static acpi_osd_handler acpi_irq_handler;
82 static void *acpi_irq_context;
83 static struct workqueue_struct *kacpid_wq;
84 static struct workqueue_struct *kacpi_notify_wq;
85 static struct workqueue_struct *kacpi_hotplug_wq;
86 
87 /*
88  * This list of permanent mappings is for memory that may be accessed from
89  * interrupt context, where we can't do the ioremap().
90  */
91 struct acpi_ioremap {
92 	struct list_head list;
93 	void __iomem *virt;
94 	acpi_physical_address phys;
95 	acpi_size size;
96 	unsigned long refcount;
97 };
98 
99 static LIST_HEAD(acpi_ioremaps);
100 static DEFINE_MUTEX(acpi_ioremap_lock);
101 
102 static void __init acpi_osi_setup_late(void);
103 
104 /*
105  * The story of _OSI(Linux)
106  *
107  * From pre-history through Linux-2.6.22,
108  * Linux responded TRUE upon a BIOS OSI(Linux) query.
109  *
110  * Unfortunately, reference BIOS writers got wind of this
111  * and put OSI(Linux) in their example code, quickly exposing
112  * this string as ill-conceived and opening the door to
113  * an un-bounded number of BIOS incompatibilities.
114  *
115  * For example, OSI(Linux) was used on resume to re-POST a
116  * video card on one system, because Linux at that time
117  * could not do a speedy restore in its native driver.
118  * But then upon gaining quick native restore capability,
119  * Linux has no way to tell the BIOS to skip the time-consuming
120  * POST -- putting Linux at a permanent performance disadvantage.
121  * On another system, the BIOS writer used OSI(Linux)
122  * to infer native OS support for IPMI!  On other systems,
123  * OSI(Linux) simply got in the way of Linux claiming to
124  * be compatible with other operating systems, exposing
125  * BIOS issues such as skipped device initialization.
126  *
127  * So "Linux" turned out to be a really poor chose of
128  * OSI string, and from Linux-2.6.23 onward we respond FALSE.
129  *
130  * BIOS writers should NOT query _OSI(Linux) on future systems.
131  * Linux will complain on the console when it sees it, and return FALSE.
132  * To get Linux to return TRUE for your system  will require
133  * a kernel source update to add a DMI entry,
134  * or boot with "acpi_osi=Linux"
135  */
136 
137 static struct osi_linux {
138 	unsigned int	enable:1;
139 	unsigned int	dmi:1;
140 	unsigned int	cmdline:1;
141 	unsigned int	default_disabling:1;
142 } osi_linux = {0, 0, 0, 0};
143 
144 static u32 acpi_osi_handler(acpi_string interface, u32 supported)
145 {
146 	if (!strcmp("Linux", interface)) {
147 
148 		printk_once(KERN_NOTICE FW_BUG PREFIX
149 			"BIOS _OSI(Linux) query %s%s\n",
150 			osi_linux.enable ? "honored" : "ignored",
151 			osi_linux.cmdline ? " via cmdline" :
152 			osi_linux.dmi ? " via DMI" : "");
153 	}
154 
155 	if (!strcmp("Darwin", interface)) {
156 		/*
157 		 * Apple firmware will behave poorly if it receives positive
158 		 * answers to "Darwin" and any other OS. Respond positively
159 		 * to Darwin and then disable all other vendor strings.
160 		 */
161 		acpi_update_interfaces(ACPI_DISABLE_ALL_VENDOR_STRINGS);
162 		supported = ACPI_UINT32_MAX;
163 	}
164 
165 	return supported;
166 }
167 
168 static void __init acpi_request_region (struct acpi_generic_address *gas,
169 	unsigned int length, char *desc)
170 {
171 	u64 addr;
172 
173 	/* Handle possible alignment issues */
174 	memcpy(&addr, &gas->address, sizeof(addr));
175 	if (!addr || !length)
176 		return;
177 
178 	/* Resources are never freed */
179 	if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO)
180 		request_region(addr, length, desc);
181 	else if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
182 		request_mem_region(addr, length, desc);
183 }
184 
185 static int __init acpi_reserve_resources(void)
186 {
187 	acpi_request_region(&acpi_gbl_FADT.xpm1a_event_block, acpi_gbl_FADT.pm1_event_length,
188 		"ACPI PM1a_EVT_BLK");
189 
190 	acpi_request_region(&acpi_gbl_FADT.xpm1b_event_block, acpi_gbl_FADT.pm1_event_length,
191 		"ACPI PM1b_EVT_BLK");
192 
193 	acpi_request_region(&acpi_gbl_FADT.xpm1a_control_block, acpi_gbl_FADT.pm1_control_length,
194 		"ACPI PM1a_CNT_BLK");
195 
196 	acpi_request_region(&acpi_gbl_FADT.xpm1b_control_block, acpi_gbl_FADT.pm1_control_length,
197 		"ACPI PM1b_CNT_BLK");
198 
199 	if (acpi_gbl_FADT.pm_timer_length == 4)
200 		acpi_request_region(&acpi_gbl_FADT.xpm_timer_block, 4, "ACPI PM_TMR");
201 
202 	acpi_request_region(&acpi_gbl_FADT.xpm2_control_block, acpi_gbl_FADT.pm2_control_length,
203 		"ACPI PM2_CNT_BLK");
204 
205 	/* Length of GPE blocks must be a non-negative multiple of 2 */
206 
207 	if (!(acpi_gbl_FADT.gpe0_block_length & 0x1))
208 		acpi_request_region(&acpi_gbl_FADT.xgpe0_block,
209 			       acpi_gbl_FADT.gpe0_block_length, "ACPI GPE0_BLK");
210 
211 	if (!(acpi_gbl_FADT.gpe1_block_length & 0x1))
212 		acpi_request_region(&acpi_gbl_FADT.xgpe1_block,
213 			       acpi_gbl_FADT.gpe1_block_length, "ACPI GPE1_BLK");
214 
215 	return 0;
216 }
217 fs_initcall_sync(acpi_reserve_resources);
218 
219 void acpi_os_printf(const char *fmt, ...)
220 {
221 	va_list args;
222 	va_start(args, fmt);
223 	acpi_os_vprintf(fmt, args);
224 	va_end(args);
225 }
226 
227 void acpi_os_vprintf(const char *fmt, va_list args)
228 {
229 	static char buffer[512];
230 
231 	vsprintf(buffer, fmt, args);
232 
233 #ifdef ENABLE_DEBUGGER
234 	if (acpi_in_debugger) {
235 		kdb_printf("%s", buffer);
236 	} else {
237 		printk(KERN_CONT "%s", buffer);
238 	}
239 #else
240 	printk(KERN_CONT "%s", buffer);
241 #endif
242 }
243 
244 #ifdef CONFIG_KEXEC
245 static unsigned long acpi_rsdp;
246 static int __init setup_acpi_rsdp(char *arg)
247 {
248 	if (kstrtoul(arg, 16, &acpi_rsdp))
249 		return -EINVAL;
250 	return 0;
251 }
252 early_param("acpi_rsdp", setup_acpi_rsdp);
253 #endif
254 
255 acpi_physical_address __init acpi_os_get_root_pointer(void)
256 {
257 #ifdef CONFIG_KEXEC
258 	if (acpi_rsdp)
259 		return acpi_rsdp;
260 #endif
261 
262 	if (efi_enabled(EFI_CONFIG_TABLES)) {
263 		if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
264 			return efi.acpi20;
265 		else if (efi.acpi != EFI_INVALID_TABLE_ADDR)
266 			return efi.acpi;
267 		else {
268 			printk(KERN_ERR PREFIX
269 			       "System description tables not found\n");
270 			return 0;
271 		}
272 	} else if (IS_ENABLED(CONFIG_ACPI_LEGACY_TABLES_LOOKUP)) {
273 		acpi_physical_address pa = 0;
274 
275 		acpi_find_root_pointer(&pa);
276 		return pa;
277 	}
278 
279 	return 0;
280 }
281 
282 /* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
283 static struct acpi_ioremap *
284 acpi_map_lookup(acpi_physical_address phys, acpi_size size)
285 {
286 	struct acpi_ioremap *map;
287 
288 	list_for_each_entry_rcu(map, &acpi_ioremaps, list)
289 		if (map->phys <= phys &&
290 		    phys + size <= map->phys + map->size)
291 			return map;
292 
293 	return NULL;
294 }
295 
296 /* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
297 static void __iomem *
298 acpi_map_vaddr_lookup(acpi_physical_address phys, unsigned int size)
299 {
300 	struct acpi_ioremap *map;
301 
302 	map = acpi_map_lookup(phys, size);
303 	if (map)
304 		return map->virt + (phys - map->phys);
305 
306 	return NULL;
307 }
308 
309 void __iomem *acpi_os_get_iomem(acpi_physical_address phys, unsigned int size)
310 {
311 	struct acpi_ioremap *map;
312 	void __iomem *virt = NULL;
313 
314 	mutex_lock(&acpi_ioremap_lock);
315 	map = acpi_map_lookup(phys, size);
316 	if (map) {
317 		virt = map->virt + (phys - map->phys);
318 		map->refcount++;
319 	}
320 	mutex_unlock(&acpi_ioremap_lock);
321 	return virt;
322 }
323 EXPORT_SYMBOL_GPL(acpi_os_get_iomem);
324 
325 /* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
326 static struct acpi_ioremap *
327 acpi_map_lookup_virt(void __iomem *virt, acpi_size size)
328 {
329 	struct acpi_ioremap *map;
330 
331 	list_for_each_entry_rcu(map, &acpi_ioremaps, list)
332 		if (map->virt <= virt &&
333 		    virt + size <= map->virt + map->size)
334 			return map;
335 
336 	return NULL;
337 }
338 
339 #if defined(CONFIG_IA64) || defined(CONFIG_ARM64)
340 /* ioremap will take care of cache attributes */
341 #define should_use_kmap(pfn)   0
342 #else
343 #define should_use_kmap(pfn)   page_is_ram(pfn)
344 #endif
345 
346 static void __iomem *acpi_map(acpi_physical_address pg_off, unsigned long pg_sz)
347 {
348 	unsigned long pfn;
349 
350 	pfn = pg_off >> PAGE_SHIFT;
351 	if (should_use_kmap(pfn)) {
352 		if (pg_sz > PAGE_SIZE)
353 			return NULL;
354 		return (void __iomem __force *)kmap(pfn_to_page(pfn));
355 	} else
356 		return acpi_os_ioremap(pg_off, pg_sz);
357 }
358 
359 static void acpi_unmap(acpi_physical_address pg_off, void __iomem *vaddr)
360 {
361 	unsigned long pfn;
362 
363 	pfn = pg_off >> PAGE_SHIFT;
364 	if (should_use_kmap(pfn))
365 		kunmap(pfn_to_page(pfn));
366 	else
367 		iounmap(vaddr);
368 }
369 
370 void __iomem *__init_refok
371 acpi_os_map_iomem(acpi_physical_address phys, acpi_size size)
372 {
373 	struct acpi_ioremap *map;
374 	void __iomem *virt;
375 	acpi_physical_address pg_off;
376 	acpi_size pg_sz;
377 
378 	if (phys > ULONG_MAX) {
379 		printk(KERN_ERR PREFIX "Cannot map memory that high\n");
380 		return NULL;
381 	}
382 
383 	if (!acpi_gbl_permanent_mmap)
384 		return __acpi_map_table((unsigned long)phys, size);
385 
386 	mutex_lock(&acpi_ioremap_lock);
387 	/* Check if there's a suitable mapping already. */
388 	map = acpi_map_lookup(phys, size);
389 	if (map) {
390 		map->refcount++;
391 		goto out;
392 	}
393 
394 	map = kzalloc(sizeof(*map), GFP_KERNEL);
395 	if (!map) {
396 		mutex_unlock(&acpi_ioremap_lock);
397 		return NULL;
398 	}
399 
400 	pg_off = round_down(phys, PAGE_SIZE);
401 	pg_sz = round_up(phys + size, PAGE_SIZE) - pg_off;
402 	virt = acpi_map(pg_off, pg_sz);
403 	if (!virt) {
404 		mutex_unlock(&acpi_ioremap_lock);
405 		kfree(map);
406 		return NULL;
407 	}
408 
409 	INIT_LIST_HEAD(&map->list);
410 	map->virt = virt;
411 	map->phys = pg_off;
412 	map->size = pg_sz;
413 	map->refcount = 1;
414 
415 	list_add_tail_rcu(&map->list, &acpi_ioremaps);
416 
417 out:
418 	mutex_unlock(&acpi_ioremap_lock);
419 	return map->virt + (phys - map->phys);
420 }
421 EXPORT_SYMBOL_GPL(acpi_os_map_iomem);
422 
423 void *__init_refok
424 acpi_os_map_memory(acpi_physical_address phys, acpi_size size)
425 {
426 	return (void *)acpi_os_map_iomem(phys, size);
427 }
428 EXPORT_SYMBOL_GPL(acpi_os_map_memory);
429 
430 static void acpi_os_drop_map_ref(struct acpi_ioremap *map)
431 {
432 	if (!--map->refcount)
433 		list_del_rcu(&map->list);
434 }
435 
436 static void acpi_os_map_cleanup(struct acpi_ioremap *map)
437 {
438 	if (!map->refcount) {
439 		synchronize_rcu_expedited();
440 		acpi_unmap(map->phys, map->virt);
441 		kfree(map);
442 	}
443 }
444 
445 void __ref acpi_os_unmap_iomem(void __iomem *virt, acpi_size size)
446 {
447 	struct acpi_ioremap *map;
448 
449 	if (!acpi_gbl_permanent_mmap) {
450 		__acpi_unmap_table(virt, size);
451 		return;
452 	}
453 
454 	mutex_lock(&acpi_ioremap_lock);
455 	map = acpi_map_lookup_virt(virt, size);
456 	if (!map) {
457 		mutex_unlock(&acpi_ioremap_lock);
458 		WARN(true, PREFIX "%s: bad address %p\n", __func__, virt);
459 		return;
460 	}
461 	acpi_os_drop_map_ref(map);
462 	mutex_unlock(&acpi_ioremap_lock);
463 
464 	acpi_os_map_cleanup(map);
465 }
466 EXPORT_SYMBOL_GPL(acpi_os_unmap_iomem);
467 
468 void __ref acpi_os_unmap_memory(void *virt, acpi_size size)
469 {
470 	return acpi_os_unmap_iomem((void __iomem *)virt, size);
471 }
472 EXPORT_SYMBOL_GPL(acpi_os_unmap_memory);
473 
474 void __init early_acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
475 {
476 	if (!acpi_gbl_permanent_mmap)
477 		__acpi_unmap_table(virt, size);
478 }
479 
480 int acpi_os_map_generic_address(struct acpi_generic_address *gas)
481 {
482 	u64 addr;
483 	void __iomem *virt;
484 
485 	if (gas->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
486 		return 0;
487 
488 	/* Handle possible alignment issues */
489 	memcpy(&addr, &gas->address, sizeof(addr));
490 	if (!addr || !gas->bit_width)
491 		return -EINVAL;
492 
493 	virt = acpi_os_map_iomem(addr, gas->bit_width / 8);
494 	if (!virt)
495 		return -EIO;
496 
497 	return 0;
498 }
499 EXPORT_SYMBOL(acpi_os_map_generic_address);
500 
501 void acpi_os_unmap_generic_address(struct acpi_generic_address *gas)
502 {
503 	u64 addr;
504 	struct acpi_ioremap *map;
505 
506 	if (gas->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
507 		return;
508 
509 	/* Handle possible alignment issues */
510 	memcpy(&addr, &gas->address, sizeof(addr));
511 	if (!addr || !gas->bit_width)
512 		return;
513 
514 	mutex_lock(&acpi_ioremap_lock);
515 	map = acpi_map_lookup(addr, gas->bit_width / 8);
516 	if (!map) {
517 		mutex_unlock(&acpi_ioremap_lock);
518 		return;
519 	}
520 	acpi_os_drop_map_ref(map);
521 	mutex_unlock(&acpi_ioremap_lock);
522 
523 	acpi_os_map_cleanup(map);
524 }
525 EXPORT_SYMBOL(acpi_os_unmap_generic_address);
526 
527 #ifdef ACPI_FUTURE_USAGE
528 acpi_status
529 acpi_os_get_physical_address(void *virt, acpi_physical_address * phys)
530 {
531 	if (!phys || !virt)
532 		return AE_BAD_PARAMETER;
533 
534 	*phys = virt_to_phys(virt);
535 
536 	return AE_OK;
537 }
538 #endif
539 
540 #ifdef CONFIG_ACPI_REV_OVERRIDE_POSSIBLE
541 static bool acpi_rev_override;
542 
543 int __init acpi_rev_override_setup(char *str)
544 {
545 	acpi_rev_override = true;
546 	return 1;
547 }
548 __setup("acpi_rev_override", acpi_rev_override_setup);
549 #else
550 #define acpi_rev_override	false
551 #endif
552 
553 #define ACPI_MAX_OVERRIDE_LEN 100
554 
555 static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN];
556 
557 acpi_status
558 acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
559 			    char **new_val)
560 {
561 	if (!init_val || !new_val)
562 		return AE_BAD_PARAMETER;
563 
564 	*new_val = NULL;
565 	if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {
566 		printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n",
567 		       acpi_os_name);
568 		*new_val = acpi_os_name;
569 	}
570 
571 	if (!memcmp(init_val->name, "_REV", 4) && acpi_rev_override) {
572 		printk(KERN_INFO PREFIX "Overriding _REV return value to 5\n");
573 		*new_val = (char *)5;
574 	}
575 
576 	return AE_OK;
577 }
578 
579 #ifdef CONFIG_ACPI_INITRD_TABLE_OVERRIDE
580 #include <linux/earlycpio.h>
581 #include <linux/memblock.h>
582 
583 static u64 acpi_tables_addr;
584 static int all_tables_size;
585 
586 /* Copied from acpica/tbutils.c:acpi_tb_checksum() */
587 static u8 __init acpi_table_checksum(u8 *buffer, u32 length)
588 {
589 	u8 sum = 0;
590 	u8 *end = buffer + length;
591 
592 	while (buffer < end)
593 		sum = (u8) (sum + *(buffer++));
594 	return sum;
595 }
596 
597 /* All but ACPI_SIG_RSDP and ACPI_SIG_FACS: */
598 static const char * const table_sigs[] = {
599 	ACPI_SIG_BERT, ACPI_SIG_CPEP, ACPI_SIG_ECDT, ACPI_SIG_EINJ,
600 	ACPI_SIG_ERST, ACPI_SIG_HEST, ACPI_SIG_MADT, ACPI_SIG_MSCT,
601 	ACPI_SIG_SBST, ACPI_SIG_SLIT, ACPI_SIG_SRAT, ACPI_SIG_ASF,
602 	ACPI_SIG_BOOT, ACPI_SIG_DBGP, ACPI_SIG_DMAR, ACPI_SIG_HPET,
603 	ACPI_SIG_IBFT, ACPI_SIG_IVRS, ACPI_SIG_MCFG, ACPI_SIG_MCHI,
604 	ACPI_SIG_SLIC, ACPI_SIG_SPCR, ACPI_SIG_SPMI, ACPI_SIG_TCPA,
605 	ACPI_SIG_UEFI, ACPI_SIG_WAET, ACPI_SIG_WDAT, ACPI_SIG_WDDT,
606 	ACPI_SIG_WDRT, ACPI_SIG_DSDT, ACPI_SIG_FADT, ACPI_SIG_PSDT,
607 	ACPI_SIG_RSDT, ACPI_SIG_XSDT, ACPI_SIG_SSDT, NULL };
608 
609 #define ACPI_HEADER_SIZE sizeof(struct acpi_table_header)
610 
611 #define ACPI_OVERRIDE_TABLES 64
612 static struct cpio_data __initdata acpi_initrd_files[ACPI_OVERRIDE_TABLES];
613 
614 #define MAP_CHUNK_SIZE   (NR_FIX_BTMAPS << PAGE_SHIFT)
615 
616 void __init acpi_initrd_override(void *data, size_t size)
617 {
618 	int sig, no, table_nr = 0, total_offset = 0;
619 	long offset = 0;
620 	struct acpi_table_header *table;
621 	char cpio_path[32] = "kernel/firmware/acpi/";
622 	struct cpio_data file;
623 
624 	if (data == NULL || size == 0)
625 		return;
626 
627 	for (no = 0; no < ACPI_OVERRIDE_TABLES; no++) {
628 		file = find_cpio_data(cpio_path, data, size, &offset);
629 		if (!file.data)
630 			break;
631 
632 		data += offset;
633 		size -= offset;
634 
635 		if (file.size < sizeof(struct acpi_table_header)) {
636 			pr_err("ACPI OVERRIDE: Table smaller than ACPI header [%s%s]\n",
637 				cpio_path, file.name);
638 			continue;
639 		}
640 
641 		table = file.data;
642 
643 		for (sig = 0; table_sigs[sig]; sig++)
644 			if (!memcmp(table->signature, table_sigs[sig], 4))
645 				break;
646 
647 		if (!table_sigs[sig]) {
648 			pr_err("ACPI OVERRIDE: Unknown signature [%s%s]\n",
649 				cpio_path, file.name);
650 			continue;
651 		}
652 		if (file.size != table->length) {
653 			pr_err("ACPI OVERRIDE: File length does not match table length [%s%s]\n",
654 				cpio_path, file.name);
655 			continue;
656 		}
657 		if (acpi_table_checksum(file.data, table->length)) {
658 			pr_err("ACPI OVERRIDE: Bad table checksum [%s%s]\n",
659 				cpio_path, file.name);
660 			continue;
661 		}
662 
663 		pr_info("%4.4s ACPI table found in initrd [%s%s][0x%x]\n",
664 			table->signature, cpio_path, file.name, table->length);
665 
666 		all_tables_size += table->length;
667 		acpi_initrd_files[table_nr].data = file.data;
668 		acpi_initrd_files[table_nr].size = file.size;
669 		table_nr++;
670 	}
671 	if (table_nr == 0)
672 		return;
673 
674 	acpi_tables_addr =
675 		memblock_find_in_range(0, max_low_pfn_mapped << PAGE_SHIFT,
676 				       all_tables_size, PAGE_SIZE);
677 	if (!acpi_tables_addr) {
678 		WARN_ON(1);
679 		return;
680 	}
681 	/*
682 	 * Only calling e820_add_reserve does not work and the
683 	 * tables are invalid (memory got used) later.
684 	 * memblock_reserve works as expected and the tables won't get modified.
685 	 * But it's not enough on X86 because ioremap will
686 	 * complain later (used by acpi_os_map_memory) that the pages
687 	 * that should get mapped are not marked "reserved".
688 	 * Both memblock_reserve and e820_add_region (via arch_reserve_mem_area)
689 	 * works fine.
690 	 */
691 	memblock_reserve(acpi_tables_addr, all_tables_size);
692 	arch_reserve_mem_area(acpi_tables_addr, all_tables_size);
693 
694 	/*
695 	 * early_ioremap only can remap 256k one time. If we map all
696 	 * tables one time, we will hit the limit. Need to map chunks
697 	 * one by one during copying the same as that in relocate_initrd().
698 	 */
699 	for (no = 0; no < table_nr; no++) {
700 		unsigned char *src_p = acpi_initrd_files[no].data;
701 		phys_addr_t size = acpi_initrd_files[no].size;
702 		phys_addr_t dest_addr = acpi_tables_addr + total_offset;
703 		phys_addr_t slop, clen;
704 		char *dest_p;
705 
706 		total_offset += size;
707 
708 		while (size) {
709 			slop = dest_addr & ~PAGE_MASK;
710 			clen = size;
711 			if (clen > MAP_CHUNK_SIZE - slop)
712 				clen = MAP_CHUNK_SIZE - slop;
713 			dest_p = early_ioremap(dest_addr & PAGE_MASK,
714 						 clen + slop);
715 			memcpy(dest_p + slop, src_p, clen);
716 			early_iounmap(dest_p, clen + slop);
717 			src_p += clen;
718 			dest_addr += clen;
719 			size -= clen;
720 		}
721 	}
722 }
723 #endif /* CONFIG_ACPI_INITRD_TABLE_OVERRIDE */
724 
725 static void acpi_table_taint(struct acpi_table_header *table)
726 {
727 	pr_warn(PREFIX
728 		"Override [%4.4s-%8.8s], this is unsafe: tainting kernel\n",
729 		table->signature, table->oem_table_id);
730 	add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE);
731 }
732 
733 
734 acpi_status
735 acpi_os_table_override(struct acpi_table_header * existing_table,
736 		       struct acpi_table_header ** new_table)
737 {
738 	if (!existing_table || !new_table)
739 		return AE_BAD_PARAMETER;
740 
741 	*new_table = NULL;
742 
743 #ifdef CONFIG_ACPI_CUSTOM_DSDT
744 	if (strncmp(existing_table->signature, "DSDT", 4) == 0)
745 		*new_table = (struct acpi_table_header *)AmlCode;
746 #endif
747 	if (*new_table != NULL)
748 		acpi_table_taint(existing_table);
749 	return AE_OK;
750 }
751 
752 acpi_status
753 acpi_os_physical_table_override(struct acpi_table_header *existing_table,
754 				acpi_physical_address *address,
755 				u32 *table_length)
756 {
757 #ifndef CONFIG_ACPI_INITRD_TABLE_OVERRIDE
758 	*table_length = 0;
759 	*address = 0;
760 	return AE_OK;
761 #else
762 	int table_offset = 0;
763 	struct acpi_table_header *table;
764 
765 	*table_length = 0;
766 	*address = 0;
767 
768 	if (!acpi_tables_addr)
769 		return AE_OK;
770 
771 	do {
772 		if (table_offset + ACPI_HEADER_SIZE > all_tables_size) {
773 			WARN_ON(1);
774 			return AE_OK;
775 		}
776 
777 		table = acpi_os_map_memory(acpi_tables_addr + table_offset,
778 					   ACPI_HEADER_SIZE);
779 
780 		if (table_offset + table->length > all_tables_size) {
781 			acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
782 			WARN_ON(1);
783 			return AE_OK;
784 		}
785 
786 		table_offset += table->length;
787 
788 		if (memcmp(existing_table->signature, table->signature, 4)) {
789 			acpi_os_unmap_memory(table,
790 				     ACPI_HEADER_SIZE);
791 			continue;
792 		}
793 
794 		/* Only override tables with matching oem id */
795 		if (memcmp(table->oem_table_id, existing_table->oem_table_id,
796 			   ACPI_OEM_TABLE_ID_SIZE)) {
797 			acpi_os_unmap_memory(table,
798 				     ACPI_HEADER_SIZE);
799 			continue;
800 		}
801 
802 		table_offset -= table->length;
803 		*table_length = table->length;
804 		acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
805 		*address = acpi_tables_addr + table_offset;
806 		break;
807 	} while (table_offset + ACPI_HEADER_SIZE < all_tables_size);
808 
809 	if (*address != 0)
810 		acpi_table_taint(existing_table);
811 	return AE_OK;
812 #endif
813 }
814 
815 static irqreturn_t acpi_irq(int irq, void *dev_id)
816 {
817 	u32 handled;
818 
819 	handled = (*acpi_irq_handler) (acpi_irq_context);
820 
821 	if (handled) {
822 		acpi_irq_handled++;
823 		return IRQ_HANDLED;
824 	} else {
825 		acpi_irq_not_handled++;
826 		return IRQ_NONE;
827 	}
828 }
829 
830 acpi_status
831 acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler,
832 				  void *context)
833 {
834 	unsigned int irq;
835 
836 	acpi_irq_stats_init();
837 
838 	/*
839 	 * ACPI interrupts different from the SCI in our copy of the FADT are
840 	 * not supported.
841 	 */
842 	if (gsi != acpi_gbl_FADT.sci_interrupt)
843 		return AE_BAD_PARAMETER;
844 
845 	if (acpi_irq_handler)
846 		return AE_ALREADY_ACQUIRED;
847 
848 	if (acpi_gsi_to_irq(gsi, &irq) < 0) {
849 		printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n",
850 		       gsi);
851 		return AE_OK;
852 	}
853 
854 	acpi_irq_handler = handler;
855 	acpi_irq_context = context;
856 	if (request_irq(irq, acpi_irq, IRQF_SHARED, "acpi", acpi_irq)) {
857 		printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq);
858 		acpi_irq_handler = NULL;
859 		return AE_NOT_ACQUIRED;
860 	}
861 
862 	return AE_OK;
863 }
864 
865 acpi_status acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler)
866 {
867 	if (irq != acpi_gbl_FADT.sci_interrupt)
868 		return AE_BAD_PARAMETER;
869 
870 	free_irq(irq, acpi_irq);
871 	acpi_irq_handler = NULL;
872 
873 	return AE_OK;
874 }
875 
876 /*
877  * Running in interpreter thread context, safe to sleep
878  */
879 
880 void acpi_os_sleep(u64 ms)
881 {
882 	msleep(ms);
883 }
884 
885 void acpi_os_stall(u32 us)
886 {
887 	while (us) {
888 		u32 delay = 1000;
889 
890 		if (delay > us)
891 			delay = us;
892 		udelay(delay);
893 		touch_nmi_watchdog();
894 		us -= delay;
895 	}
896 }
897 
898 /*
899  * Support ACPI 3.0 AML Timer operand
900  * Returns 64-bit free-running, monotonically increasing timer
901  * with 100ns granularity
902  */
903 u64 acpi_os_get_timer(void)
904 {
905 	u64 time_ns = ktime_to_ns(ktime_get());
906 	do_div(time_ns, 100);
907 	return time_ns;
908 }
909 
910 acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width)
911 {
912 	u32 dummy;
913 
914 	if (!value)
915 		value = &dummy;
916 
917 	*value = 0;
918 	if (width <= 8) {
919 		*(u8 *) value = inb(port);
920 	} else if (width <= 16) {
921 		*(u16 *) value = inw(port);
922 	} else if (width <= 32) {
923 		*(u32 *) value = inl(port);
924 	} else {
925 		BUG();
926 	}
927 
928 	return AE_OK;
929 }
930 
931 EXPORT_SYMBOL(acpi_os_read_port);
932 
933 acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
934 {
935 	if (width <= 8) {
936 		outb(value, port);
937 	} else if (width <= 16) {
938 		outw(value, port);
939 	} else if (width <= 32) {
940 		outl(value, port);
941 	} else {
942 		BUG();
943 	}
944 
945 	return AE_OK;
946 }
947 
948 EXPORT_SYMBOL(acpi_os_write_port);
949 
950 #ifdef readq
951 static inline u64 read64(const volatile void __iomem *addr)
952 {
953 	return readq(addr);
954 }
955 #else
956 static inline u64 read64(const volatile void __iomem *addr)
957 {
958 	u64 l, h;
959 	l = readl(addr);
960 	h = readl(addr+4);
961 	return l | (h << 32);
962 }
963 #endif
964 
965 acpi_status
966 acpi_os_read_memory(acpi_physical_address phys_addr, u64 *value, u32 width)
967 {
968 	void __iomem *virt_addr;
969 	unsigned int size = width / 8;
970 	bool unmap = false;
971 	u64 dummy;
972 
973 	rcu_read_lock();
974 	virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
975 	if (!virt_addr) {
976 		rcu_read_unlock();
977 		virt_addr = acpi_os_ioremap(phys_addr, size);
978 		if (!virt_addr)
979 			return AE_BAD_ADDRESS;
980 		unmap = true;
981 	}
982 
983 	if (!value)
984 		value = &dummy;
985 
986 	switch (width) {
987 	case 8:
988 		*(u8 *) value = readb(virt_addr);
989 		break;
990 	case 16:
991 		*(u16 *) value = readw(virt_addr);
992 		break;
993 	case 32:
994 		*(u32 *) value = readl(virt_addr);
995 		break;
996 	case 64:
997 		*(u64 *) value = read64(virt_addr);
998 		break;
999 	default:
1000 		BUG();
1001 	}
1002 
1003 	if (unmap)
1004 		iounmap(virt_addr);
1005 	else
1006 		rcu_read_unlock();
1007 
1008 	return AE_OK;
1009 }
1010 
1011 #ifdef writeq
1012 static inline void write64(u64 val, volatile void __iomem *addr)
1013 {
1014 	writeq(val, addr);
1015 }
1016 #else
1017 static inline void write64(u64 val, volatile void __iomem *addr)
1018 {
1019 	writel(val, addr);
1020 	writel(val>>32, addr+4);
1021 }
1022 #endif
1023 
1024 acpi_status
1025 acpi_os_write_memory(acpi_physical_address phys_addr, u64 value, u32 width)
1026 {
1027 	void __iomem *virt_addr;
1028 	unsigned int size = width / 8;
1029 	bool unmap = false;
1030 
1031 	rcu_read_lock();
1032 	virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
1033 	if (!virt_addr) {
1034 		rcu_read_unlock();
1035 		virt_addr = acpi_os_ioremap(phys_addr, size);
1036 		if (!virt_addr)
1037 			return AE_BAD_ADDRESS;
1038 		unmap = true;
1039 	}
1040 
1041 	switch (width) {
1042 	case 8:
1043 		writeb(value, virt_addr);
1044 		break;
1045 	case 16:
1046 		writew(value, virt_addr);
1047 		break;
1048 	case 32:
1049 		writel(value, virt_addr);
1050 		break;
1051 	case 64:
1052 		write64(value, virt_addr);
1053 		break;
1054 	default:
1055 		BUG();
1056 	}
1057 
1058 	if (unmap)
1059 		iounmap(virt_addr);
1060 	else
1061 		rcu_read_unlock();
1062 
1063 	return AE_OK;
1064 }
1065 
1066 acpi_status
1067 acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
1068 			       u64 *value, u32 width)
1069 {
1070 	int result, size;
1071 	u32 value32;
1072 
1073 	if (!value)
1074 		return AE_BAD_PARAMETER;
1075 
1076 	switch (width) {
1077 	case 8:
1078 		size = 1;
1079 		break;
1080 	case 16:
1081 		size = 2;
1082 		break;
1083 	case 32:
1084 		size = 4;
1085 		break;
1086 	default:
1087 		return AE_ERROR;
1088 	}
1089 
1090 	result = raw_pci_read(pci_id->segment, pci_id->bus,
1091 				PCI_DEVFN(pci_id->device, pci_id->function),
1092 				reg, size, &value32);
1093 	*value = value32;
1094 
1095 	return (result ? AE_ERROR : AE_OK);
1096 }
1097 
1098 acpi_status
1099 acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
1100 				u64 value, u32 width)
1101 {
1102 	int result, size;
1103 
1104 	switch (width) {
1105 	case 8:
1106 		size = 1;
1107 		break;
1108 	case 16:
1109 		size = 2;
1110 		break;
1111 	case 32:
1112 		size = 4;
1113 		break;
1114 	default:
1115 		return AE_ERROR;
1116 	}
1117 
1118 	result = raw_pci_write(pci_id->segment, pci_id->bus,
1119 				PCI_DEVFN(pci_id->device, pci_id->function),
1120 				reg, size, value);
1121 
1122 	return (result ? AE_ERROR : AE_OK);
1123 }
1124 
1125 static void acpi_os_execute_deferred(struct work_struct *work)
1126 {
1127 	struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
1128 
1129 	dpc->function(dpc->context);
1130 	kfree(dpc);
1131 }
1132 
1133 /*******************************************************************************
1134  *
1135  * FUNCTION:    acpi_os_execute
1136  *
1137  * PARAMETERS:  Type               - Type of the callback
1138  *              Function           - Function to be executed
1139  *              Context            - Function parameters
1140  *
1141  * RETURN:      Status
1142  *
1143  * DESCRIPTION: Depending on type, either queues function for deferred execution or
1144  *              immediately executes function on a separate thread.
1145  *
1146  ******************************************************************************/
1147 
1148 acpi_status acpi_os_execute(acpi_execute_type type,
1149 			    acpi_osd_exec_callback function, void *context)
1150 {
1151 	acpi_status status = AE_OK;
1152 	struct acpi_os_dpc *dpc;
1153 	struct workqueue_struct *queue;
1154 	int ret;
1155 	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
1156 			  "Scheduling function [%p(%p)] for deferred execution.\n",
1157 			  function, context));
1158 
1159 	/*
1160 	 * Allocate/initialize DPC structure.  Note that this memory will be
1161 	 * freed by the callee.  The kernel handles the work_struct list  in a
1162 	 * way that allows us to also free its memory inside the callee.
1163 	 * Because we may want to schedule several tasks with different
1164 	 * parameters we can't use the approach some kernel code uses of
1165 	 * having a static work_struct.
1166 	 */
1167 
1168 	dpc = kzalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC);
1169 	if (!dpc)
1170 		return AE_NO_MEMORY;
1171 
1172 	dpc->function = function;
1173 	dpc->context = context;
1174 
1175 	/*
1176 	 * To prevent lockdep from complaining unnecessarily, make sure that
1177 	 * there is a different static lockdep key for each workqueue by using
1178 	 * INIT_WORK() for each of them separately.
1179 	 */
1180 	if (type == OSL_NOTIFY_HANDLER) {
1181 		queue = kacpi_notify_wq;
1182 		INIT_WORK(&dpc->work, acpi_os_execute_deferred);
1183 	} else {
1184 		queue = kacpid_wq;
1185 		INIT_WORK(&dpc->work, acpi_os_execute_deferred);
1186 	}
1187 
1188 	/*
1189 	 * On some machines, a software-initiated SMI causes corruption unless
1190 	 * the SMI runs on CPU 0.  An SMI can be initiated by any AML, but
1191 	 * typically it's done in GPE-related methods that are run via
1192 	 * workqueues, so we can avoid the known corruption cases by always
1193 	 * queueing on CPU 0.
1194 	 */
1195 	ret = queue_work_on(0, queue, &dpc->work);
1196 
1197 	if (!ret) {
1198 		printk(KERN_ERR PREFIX
1199 			  "Call to queue_work() failed.\n");
1200 		status = AE_ERROR;
1201 		kfree(dpc);
1202 	}
1203 	return status;
1204 }
1205 EXPORT_SYMBOL(acpi_os_execute);
1206 
1207 void acpi_os_wait_events_complete(void)
1208 {
1209 	/*
1210 	 * Make sure the GPE handler or the fixed event handler is not used
1211 	 * on another CPU after removal.
1212 	 */
1213 	if (acpi_irq_handler)
1214 		synchronize_hardirq(acpi_gbl_FADT.sci_interrupt);
1215 	flush_workqueue(kacpid_wq);
1216 	flush_workqueue(kacpi_notify_wq);
1217 }
1218 
1219 struct acpi_hp_work {
1220 	struct work_struct work;
1221 	struct acpi_device *adev;
1222 	u32 src;
1223 };
1224 
1225 static void acpi_hotplug_work_fn(struct work_struct *work)
1226 {
1227 	struct acpi_hp_work *hpw = container_of(work, struct acpi_hp_work, work);
1228 
1229 	acpi_os_wait_events_complete();
1230 	acpi_device_hotplug(hpw->adev, hpw->src);
1231 	kfree(hpw);
1232 }
1233 
1234 acpi_status acpi_hotplug_schedule(struct acpi_device *adev, u32 src)
1235 {
1236 	struct acpi_hp_work *hpw;
1237 
1238 	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
1239 		  "Scheduling hotplug event (%p, %u) for deferred execution.\n",
1240 		  adev, src));
1241 
1242 	hpw = kmalloc(sizeof(*hpw), GFP_KERNEL);
1243 	if (!hpw)
1244 		return AE_NO_MEMORY;
1245 
1246 	INIT_WORK(&hpw->work, acpi_hotplug_work_fn);
1247 	hpw->adev = adev;
1248 	hpw->src = src;
1249 	/*
1250 	 * We can't run hotplug code in kacpid_wq/kacpid_notify_wq etc., because
1251 	 * the hotplug code may call driver .remove() functions, which may
1252 	 * invoke flush_scheduled_work()/acpi_os_wait_events_complete() to flush
1253 	 * these workqueues.
1254 	 */
1255 	if (!queue_work(kacpi_hotplug_wq, &hpw->work)) {
1256 		kfree(hpw);
1257 		return AE_ERROR;
1258 	}
1259 	return AE_OK;
1260 }
1261 
1262 bool acpi_queue_hotplug_work(struct work_struct *work)
1263 {
1264 	return queue_work(kacpi_hotplug_wq, work);
1265 }
1266 
1267 acpi_status
1268 acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
1269 {
1270 	struct semaphore *sem = NULL;
1271 
1272 	sem = acpi_os_allocate_zeroed(sizeof(struct semaphore));
1273 	if (!sem)
1274 		return AE_NO_MEMORY;
1275 
1276 	sema_init(sem, initial_units);
1277 
1278 	*handle = (acpi_handle *) sem;
1279 
1280 	ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
1281 			  *handle, initial_units));
1282 
1283 	return AE_OK;
1284 }
1285 
1286 /*
1287  * TODO: A better way to delete semaphores?  Linux doesn't have a
1288  * 'delete_semaphore()' function -- may result in an invalid
1289  * pointer dereference for non-synchronized consumers.	Should
1290  * we at least check for blocked threads and signal/cancel them?
1291  */
1292 
1293 acpi_status acpi_os_delete_semaphore(acpi_handle handle)
1294 {
1295 	struct semaphore *sem = (struct semaphore *)handle;
1296 
1297 	if (!sem)
1298 		return AE_BAD_PARAMETER;
1299 
1300 	ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
1301 
1302 	BUG_ON(!list_empty(&sem->wait_list));
1303 	kfree(sem);
1304 	sem = NULL;
1305 
1306 	return AE_OK;
1307 }
1308 
1309 /*
1310  * TODO: Support for units > 1?
1311  */
1312 acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
1313 {
1314 	acpi_status status = AE_OK;
1315 	struct semaphore *sem = (struct semaphore *)handle;
1316 	long jiffies;
1317 	int ret = 0;
1318 
1319 	if (!sem || (units < 1))
1320 		return AE_BAD_PARAMETER;
1321 
1322 	if (units > 1)
1323 		return AE_SUPPORT;
1324 
1325 	ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
1326 			  handle, units, timeout));
1327 
1328 	if (timeout == ACPI_WAIT_FOREVER)
1329 		jiffies = MAX_SCHEDULE_TIMEOUT;
1330 	else
1331 		jiffies = msecs_to_jiffies(timeout);
1332 
1333 	ret = down_timeout(sem, jiffies);
1334 	if (ret)
1335 		status = AE_TIME;
1336 
1337 	if (ACPI_FAILURE(status)) {
1338 		ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
1339 				  "Failed to acquire semaphore[%p|%d|%d], %s",
1340 				  handle, units, timeout,
1341 				  acpi_format_exception(status)));
1342 	} else {
1343 		ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
1344 				  "Acquired semaphore[%p|%d|%d]", handle,
1345 				  units, timeout));
1346 	}
1347 
1348 	return status;
1349 }
1350 
1351 /*
1352  * TODO: Support for units > 1?
1353  */
1354 acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
1355 {
1356 	struct semaphore *sem = (struct semaphore *)handle;
1357 
1358 	if (!sem || (units < 1))
1359 		return AE_BAD_PARAMETER;
1360 
1361 	if (units > 1)
1362 		return AE_SUPPORT;
1363 
1364 	ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
1365 			  units));
1366 
1367 	up(sem);
1368 
1369 	return AE_OK;
1370 }
1371 
1372 #ifdef ACPI_FUTURE_USAGE
1373 u32 acpi_os_get_line(char *buffer)
1374 {
1375 
1376 #ifdef ENABLE_DEBUGGER
1377 	if (acpi_in_debugger) {
1378 		u32 chars;
1379 
1380 		kdb_read(buffer, sizeof(line_buf));
1381 
1382 		/* remove the CR kdb includes */
1383 		chars = strlen(buffer) - 1;
1384 		buffer[chars] = '\0';
1385 	}
1386 #endif
1387 
1388 	return 0;
1389 }
1390 #endif				/*  ACPI_FUTURE_USAGE  */
1391 
1392 acpi_status acpi_os_signal(u32 function, void *info)
1393 {
1394 	switch (function) {
1395 	case ACPI_SIGNAL_FATAL:
1396 		printk(KERN_ERR PREFIX "Fatal opcode executed\n");
1397 		break;
1398 	case ACPI_SIGNAL_BREAKPOINT:
1399 		/*
1400 		 * AML Breakpoint
1401 		 * ACPI spec. says to treat it as a NOP unless
1402 		 * you are debugging.  So if/when we integrate
1403 		 * AML debugger into the kernel debugger its
1404 		 * hook will go here.  But until then it is
1405 		 * not useful to print anything on breakpoints.
1406 		 */
1407 		break;
1408 	default:
1409 		break;
1410 	}
1411 
1412 	return AE_OK;
1413 }
1414 
1415 static int __init acpi_os_name_setup(char *str)
1416 {
1417 	char *p = acpi_os_name;
1418 	int count = ACPI_MAX_OVERRIDE_LEN - 1;
1419 
1420 	if (!str || !*str)
1421 		return 0;
1422 
1423 	for (; count-- && *str; str++) {
1424 		if (isalnum(*str) || *str == ' ' || *str == ':')
1425 			*p++ = *str;
1426 		else if (*str == '\'' || *str == '"')
1427 			continue;
1428 		else
1429 			break;
1430 	}
1431 	*p = 0;
1432 
1433 	return 1;
1434 
1435 }
1436 
1437 __setup("acpi_os_name=", acpi_os_name_setup);
1438 
1439 #define	OSI_STRING_LENGTH_MAX 64	/* arbitrary */
1440 #define	OSI_STRING_ENTRIES_MAX 16	/* arbitrary */
1441 
1442 struct osi_setup_entry {
1443 	char string[OSI_STRING_LENGTH_MAX];
1444 	bool enable;
1445 };
1446 
1447 static struct osi_setup_entry
1448 		osi_setup_entries[OSI_STRING_ENTRIES_MAX] __initdata = {
1449 	{"Module Device", true},
1450 	{"Processor Device", true},
1451 	{"3.0 _SCP Extensions", true},
1452 	{"Processor Aggregator Device", true},
1453 };
1454 
1455 void __init acpi_osi_setup(char *str)
1456 {
1457 	struct osi_setup_entry *osi;
1458 	bool enable = true;
1459 	int i;
1460 
1461 	if (!acpi_gbl_create_osi_method)
1462 		return;
1463 
1464 	if (str == NULL || *str == '\0') {
1465 		printk(KERN_INFO PREFIX "_OSI method disabled\n");
1466 		acpi_gbl_create_osi_method = FALSE;
1467 		return;
1468 	}
1469 
1470 	if (*str == '!') {
1471 		str++;
1472 		if (*str == '\0') {
1473 			osi_linux.default_disabling = 1;
1474 			return;
1475 		} else if (*str == '*') {
1476 			acpi_update_interfaces(ACPI_DISABLE_ALL_STRINGS);
1477 			for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1478 				osi = &osi_setup_entries[i];
1479 				osi->enable = false;
1480 			}
1481 			return;
1482 		}
1483 		enable = false;
1484 	}
1485 
1486 	for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1487 		osi = &osi_setup_entries[i];
1488 		if (!strcmp(osi->string, str)) {
1489 			osi->enable = enable;
1490 			break;
1491 		} else if (osi->string[0] == '\0') {
1492 			osi->enable = enable;
1493 			strncpy(osi->string, str, OSI_STRING_LENGTH_MAX);
1494 			break;
1495 		}
1496 	}
1497 }
1498 
1499 static void __init set_osi_linux(unsigned int enable)
1500 {
1501 	if (osi_linux.enable != enable)
1502 		osi_linux.enable = enable;
1503 
1504 	if (osi_linux.enable)
1505 		acpi_osi_setup("Linux");
1506 	else
1507 		acpi_osi_setup("!Linux");
1508 
1509 	return;
1510 }
1511 
1512 static void __init acpi_cmdline_osi_linux(unsigned int enable)
1513 {
1514 	osi_linux.cmdline = 1;	/* cmdline set the default and override DMI */
1515 	osi_linux.dmi = 0;
1516 	set_osi_linux(enable);
1517 
1518 	return;
1519 }
1520 
1521 void __init acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d)
1522 {
1523 	printk(KERN_NOTICE PREFIX "DMI detected: %s\n", d->ident);
1524 
1525 	if (enable == -1)
1526 		return;
1527 
1528 	osi_linux.dmi = 1;	/* DMI knows that this box asks OSI(Linux) */
1529 	set_osi_linux(enable);
1530 
1531 	return;
1532 }
1533 
1534 /*
1535  * Modify the list of "OS Interfaces" reported to BIOS via _OSI
1536  *
1537  * empty string disables _OSI
1538  * string starting with '!' disables that string
1539  * otherwise string is added to list, augmenting built-in strings
1540  */
1541 static void __init acpi_osi_setup_late(void)
1542 {
1543 	struct osi_setup_entry *osi;
1544 	char *str;
1545 	int i;
1546 	acpi_status status;
1547 
1548 	if (osi_linux.default_disabling) {
1549 		status = acpi_update_interfaces(ACPI_DISABLE_ALL_VENDOR_STRINGS);
1550 
1551 		if (ACPI_SUCCESS(status))
1552 			printk(KERN_INFO PREFIX "Disabled all _OSI OS vendors\n");
1553 	}
1554 
1555 	for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1556 		osi = &osi_setup_entries[i];
1557 		str = osi->string;
1558 
1559 		if (*str == '\0')
1560 			break;
1561 		if (osi->enable) {
1562 			status = acpi_install_interface(str);
1563 
1564 			if (ACPI_SUCCESS(status))
1565 				printk(KERN_INFO PREFIX "Added _OSI(%s)\n", str);
1566 		} else {
1567 			status = acpi_remove_interface(str);
1568 
1569 			if (ACPI_SUCCESS(status))
1570 				printk(KERN_INFO PREFIX "Deleted _OSI(%s)\n", str);
1571 		}
1572 	}
1573 }
1574 
1575 static int __init osi_setup(char *str)
1576 {
1577 	if (str && !strcmp("Linux", str))
1578 		acpi_cmdline_osi_linux(1);
1579 	else if (str && !strcmp("!Linux", str))
1580 		acpi_cmdline_osi_linux(0);
1581 	else
1582 		acpi_osi_setup(str);
1583 
1584 	return 1;
1585 }
1586 
1587 __setup("acpi_osi=", osi_setup);
1588 
1589 /*
1590  * Disable the auto-serialization of named objects creation methods.
1591  *
1592  * This feature is enabled by default.  It marks the AML control methods
1593  * that contain the opcodes to create named objects as "Serialized".
1594  */
1595 static int __init acpi_no_auto_serialize_setup(char *str)
1596 {
1597 	acpi_gbl_auto_serialize_methods = FALSE;
1598 	pr_info("ACPI: auto-serialization disabled\n");
1599 
1600 	return 1;
1601 }
1602 
1603 __setup("acpi_no_auto_serialize", acpi_no_auto_serialize_setup);
1604 
1605 /* Check of resource interference between native drivers and ACPI
1606  * OperationRegions (SystemIO and System Memory only).
1607  * IO ports and memory declared in ACPI might be used by the ACPI subsystem
1608  * in arbitrary AML code and can interfere with legacy drivers.
1609  * acpi_enforce_resources= can be set to:
1610  *
1611  *   - strict (default) (2)
1612  *     -> further driver trying to access the resources will not load
1613  *   - lax              (1)
1614  *     -> further driver trying to access the resources will load, but you
1615  *     get a system message that something might go wrong...
1616  *
1617  *   - no               (0)
1618  *     -> ACPI Operation Region resources will not be registered
1619  *
1620  */
1621 #define ENFORCE_RESOURCES_STRICT 2
1622 #define ENFORCE_RESOURCES_LAX    1
1623 #define ENFORCE_RESOURCES_NO     0
1624 
1625 static unsigned int acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1626 
1627 static int __init acpi_enforce_resources_setup(char *str)
1628 {
1629 	if (str == NULL || *str == '\0')
1630 		return 0;
1631 
1632 	if (!strcmp("strict", str))
1633 		acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1634 	else if (!strcmp("lax", str))
1635 		acpi_enforce_resources = ENFORCE_RESOURCES_LAX;
1636 	else if (!strcmp("no", str))
1637 		acpi_enforce_resources = ENFORCE_RESOURCES_NO;
1638 
1639 	return 1;
1640 }
1641 
1642 __setup("acpi_enforce_resources=", acpi_enforce_resources_setup);
1643 
1644 /* Check for resource conflicts between ACPI OperationRegions and native
1645  * drivers */
1646 int acpi_check_resource_conflict(const struct resource *res)
1647 {
1648 	acpi_adr_space_type space_id;
1649 	acpi_size length;
1650 	u8 warn = 0;
1651 	int clash = 0;
1652 
1653 	if (acpi_enforce_resources == ENFORCE_RESOURCES_NO)
1654 		return 0;
1655 	if (!(res->flags & IORESOURCE_IO) && !(res->flags & IORESOURCE_MEM))
1656 		return 0;
1657 
1658 	if (res->flags & IORESOURCE_IO)
1659 		space_id = ACPI_ADR_SPACE_SYSTEM_IO;
1660 	else
1661 		space_id = ACPI_ADR_SPACE_SYSTEM_MEMORY;
1662 
1663 	length = resource_size(res);
1664 	if (acpi_enforce_resources != ENFORCE_RESOURCES_NO)
1665 		warn = 1;
1666 	clash = acpi_check_address_range(space_id, res->start, length, warn);
1667 
1668 	if (clash) {
1669 		if (acpi_enforce_resources != ENFORCE_RESOURCES_NO) {
1670 			if (acpi_enforce_resources == ENFORCE_RESOURCES_LAX)
1671 				printk(KERN_NOTICE "ACPI: This conflict may"
1672 				       " cause random problems and system"
1673 				       " instability\n");
1674 			printk(KERN_INFO "ACPI: If an ACPI driver is available"
1675 			       " for this device, you should use it instead of"
1676 			       " the native driver\n");
1677 		}
1678 		if (acpi_enforce_resources == ENFORCE_RESOURCES_STRICT)
1679 			return -EBUSY;
1680 	}
1681 	return 0;
1682 }
1683 EXPORT_SYMBOL(acpi_check_resource_conflict);
1684 
1685 int acpi_check_region(resource_size_t start, resource_size_t n,
1686 		      const char *name)
1687 {
1688 	struct resource res = {
1689 		.start = start,
1690 		.end   = start + n - 1,
1691 		.name  = name,
1692 		.flags = IORESOURCE_IO,
1693 	};
1694 
1695 	return acpi_check_resource_conflict(&res);
1696 }
1697 EXPORT_SYMBOL(acpi_check_region);
1698 
1699 /*
1700  * Let drivers know whether the resource checks are effective
1701  */
1702 int acpi_resources_are_enforced(void)
1703 {
1704 	return acpi_enforce_resources == ENFORCE_RESOURCES_STRICT;
1705 }
1706 EXPORT_SYMBOL(acpi_resources_are_enforced);
1707 
1708 bool acpi_osi_is_win8(void)
1709 {
1710 	return acpi_gbl_osi_data >= ACPI_OSI_WIN_8;
1711 }
1712 EXPORT_SYMBOL(acpi_osi_is_win8);
1713 
1714 /*
1715  * Deallocate the memory for a spinlock.
1716  */
1717 void acpi_os_delete_lock(acpi_spinlock handle)
1718 {
1719 	ACPI_FREE(handle);
1720 }
1721 
1722 /*
1723  * Acquire a spinlock.
1724  *
1725  * handle is a pointer to the spinlock_t.
1726  */
1727 
1728 acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp)
1729 {
1730 	acpi_cpu_flags flags;
1731 	spin_lock_irqsave(lockp, flags);
1732 	return flags;
1733 }
1734 
1735 /*
1736  * Release a spinlock. See above.
1737  */
1738 
1739 void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
1740 {
1741 	spin_unlock_irqrestore(lockp, flags);
1742 }
1743 
1744 #ifndef ACPI_USE_LOCAL_CACHE
1745 
1746 /*******************************************************************************
1747  *
1748  * FUNCTION:    acpi_os_create_cache
1749  *
1750  * PARAMETERS:  name      - Ascii name for the cache
1751  *              size      - Size of each cached object
1752  *              depth     - Maximum depth of the cache (in objects) <ignored>
1753  *              cache     - Where the new cache object is returned
1754  *
1755  * RETURN:      status
1756  *
1757  * DESCRIPTION: Create a cache object
1758  *
1759  ******************************************************************************/
1760 
1761 acpi_status
1762 acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
1763 {
1764 	*cache = kmem_cache_create(name, size, 0, 0, NULL);
1765 	if (*cache == NULL)
1766 		return AE_ERROR;
1767 	else
1768 		return AE_OK;
1769 }
1770 
1771 /*******************************************************************************
1772  *
1773  * FUNCTION:    acpi_os_purge_cache
1774  *
1775  * PARAMETERS:  Cache           - Handle to cache object
1776  *
1777  * RETURN:      Status
1778  *
1779  * DESCRIPTION: Free all objects within the requested cache.
1780  *
1781  ******************************************************************************/
1782 
1783 acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
1784 {
1785 	kmem_cache_shrink(cache);
1786 	return (AE_OK);
1787 }
1788 
1789 /*******************************************************************************
1790  *
1791  * FUNCTION:    acpi_os_delete_cache
1792  *
1793  * PARAMETERS:  Cache           - Handle to cache object
1794  *
1795  * RETURN:      Status
1796  *
1797  * DESCRIPTION: Free all objects within the requested cache and delete the
1798  *              cache object.
1799  *
1800  ******************************************************************************/
1801 
1802 acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
1803 {
1804 	kmem_cache_destroy(cache);
1805 	return (AE_OK);
1806 }
1807 
1808 /*******************************************************************************
1809  *
1810  * FUNCTION:    acpi_os_release_object
1811  *
1812  * PARAMETERS:  Cache       - Handle to cache object
1813  *              Object      - The object to be released
1814  *
1815  * RETURN:      None
1816  *
1817  * DESCRIPTION: Release an object to the specified cache.  If cache is full,
1818  *              the object is deleted.
1819  *
1820  ******************************************************************************/
1821 
1822 acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
1823 {
1824 	kmem_cache_free(cache, object);
1825 	return (AE_OK);
1826 }
1827 #endif
1828 
1829 static int __init acpi_no_static_ssdt_setup(char *s)
1830 {
1831 	acpi_gbl_disable_ssdt_table_install = TRUE;
1832 	pr_info("ACPI: static SSDT installation disabled\n");
1833 
1834 	return 0;
1835 }
1836 
1837 early_param("acpi_no_static_ssdt", acpi_no_static_ssdt_setup);
1838 
1839 static int __init acpi_disable_return_repair(char *s)
1840 {
1841 	printk(KERN_NOTICE PREFIX
1842 	       "ACPI: Predefined validation mechanism disabled\n");
1843 	acpi_gbl_disable_auto_repair = TRUE;
1844 
1845 	return 1;
1846 }
1847 
1848 __setup("acpica_no_return_repair", acpi_disable_return_repair);
1849 
1850 acpi_status __init acpi_os_initialize(void)
1851 {
1852 	acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1853 	acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1854 	acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe0_block);
1855 	acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe1_block);
1856 	if (acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER) {
1857 		/*
1858 		 * Use acpi_os_map_generic_address to pre-map the reset
1859 		 * register if it's in system memory.
1860 		 */
1861 		int rv;
1862 
1863 		rv = acpi_os_map_generic_address(&acpi_gbl_FADT.reset_register);
1864 		pr_debug(PREFIX "%s: map reset_reg status %d\n", __func__, rv);
1865 	}
1866 
1867 	return AE_OK;
1868 }
1869 
1870 acpi_status __init acpi_os_initialize1(void)
1871 {
1872 	kacpid_wq = alloc_workqueue("kacpid", 0, 1);
1873 	kacpi_notify_wq = alloc_workqueue("kacpi_notify", 0, 1);
1874 	kacpi_hotplug_wq = alloc_ordered_workqueue("kacpi_hotplug", 0);
1875 	BUG_ON(!kacpid_wq);
1876 	BUG_ON(!kacpi_notify_wq);
1877 	BUG_ON(!kacpi_hotplug_wq);
1878 	acpi_install_interface_handler(acpi_osi_handler);
1879 	acpi_osi_setup_late();
1880 	return AE_OK;
1881 }
1882 
1883 acpi_status acpi_os_terminate(void)
1884 {
1885 	if (acpi_irq_handler) {
1886 		acpi_os_remove_interrupt_handler(acpi_gbl_FADT.sci_interrupt,
1887 						 acpi_irq_handler);
1888 	}
1889 
1890 	acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe1_block);
1891 	acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe0_block);
1892 	acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1893 	acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1894 	if (acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER)
1895 		acpi_os_unmap_generic_address(&acpi_gbl_FADT.reset_register);
1896 
1897 	destroy_workqueue(kacpid_wq);
1898 	destroy_workqueue(kacpi_notify_wq);
1899 	destroy_workqueue(kacpi_hotplug_wq);
1900 
1901 	return AE_OK;
1902 }
1903 
1904 acpi_status acpi_os_prepare_sleep(u8 sleep_state, u32 pm1a_control,
1905 				  u32 pm1b_control)
1906 {
1907 	int rc = 0;
1908 	if (__acpi_os_prepare_sleep)
1909 		rc = __acpi_os_prepare_sleep(sleep_state,
1910 					     pm1a_control, pm1b_control);
1911 	if (rc < 0)
1912 		return AE_ERROR;
1913 	else if (rc > 0)
1914 		return AE_CTRL_SKIP;
1915 
1916 	return AE_OK;
1917 }
1918 
1919 void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state,
1920 			       u32 pm1a_ctrl, u32 pm1b_ctrl))
1921 {
1922 	__acpi_os_prepare_sleep = func;
1923 }
1924 
1925 acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state, u32 val_a,
1926 				  u32 val_b)
1927 {
1928 	int rc = 0;
1929 	if (__acpi_os_prepare_extended_sleep)
1930 		rc = __acpi_os_prepare_extended_sleep(sleep_state,
1931 					     val_a, val_b);
1932 	if (rc < 0)
1933 		return AE_ERROR;
1934 	else if (rc > 0)
1935 		return AE_CTRL_SKIP;
1936 
1937 	return AE_OK;
1938 }
1939 
1940 void acpi_os_set_prepare_extended_sleep(int (*func)(u8 sleep_state,
1941 			       u32 val_a, u32 val_b))
1942 {
1943 	__acpi_os_prepare_extended_sleep = func;
1944 }
1945