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