1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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
54ACPI_MODULE_NAME("osl");
55
56struct 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
70int acpi_in_debugger;
71EXPORT_SYMBOL(acpi_in_debugger);
72
73extern char line_buf[80];
74#endif
75
76static int (*__acpi_os_prepare_sleep)(u8 sleep_state, u32 pm1a_ctrl,
77 u32 pm1b_ctrl);
78static int (*__acpi_os_prepare_extended_sleep)(u8 sleep_state, u32 val_a,
79 u32 val_b);
80
81static acpi_osd_handler acpi_irq_handler;
82static void *acpi_irq_context;
83static struct workqueue_struct *kacpid_wq;
84static struct workqueue_struct *kacpi_notify_wq;
85static struct workqueue_struct *kacpi_hotplug_wq;
86
87
88
89
90
91struct 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
99static LIST_HEAD(acpi_ioremaps);
100static DEFINE_MUTEX(acpi_ioremap_lock);
101
102static void __init acpi_osi_setup_late(void);
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137static 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
144static 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
158
159
160
161 acpi_update_interfaces(ACPI_DISABLE_ALL_VENDOR_STRINGS);
162 supported = ACPI_UINT32_MAX;
163 }
164
165 return supported;
166}
167
168static void __init acpi_request_region (struct acpi_generic_address *gas,
169 unsigned int length, char *desc)
170{
171 u64 addr;
172
173
174 memcpy(&addr, &gas->address, sizeof(addr));
175 if (!addr || !length)
176 return;
177
178
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
185static 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
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}
217device_initcall(acpi_reserve_resources);
218
219void 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
227void 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
245static unsigned long acpi_rsdp;
246static int __init setup_acpi_rsdp(char *arg)
247{
248 if (kstrtoul(arg, 16, &acpi_rsdp))
249 return -EINVAL;
250 return 0;
251}
252early_param("acpi_rsdp", setup_acpi_rsdp);
253#endif
254
255acpi_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
283static struct acpi_ioremap *
284acpi_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
297static void __iomem *
298acpi_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
309void __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}
323EXPORT_SYMBOL_GPL(acpi_os_get_iomem);
324
325
326static struct acpi_ioremap *
327acpi_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#ifndef CONFIG_IA64
340#define should_use_kmap(pfn) page_is_ram(pfn)
341#else
342
343#define should_use_kmap(pfn) 0
344#endif
345
346static 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
359static 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
370void __iomem *__init_refok
371acpi_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
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
417out:
418 mutex_unlock(&acpi_ioremap_lock);
419 return map->virt + (phys - map->phys);
420}
421EXPORT_SYMBOL_GPL(acpi_os_map_iomem);
422
423void *__init_refok
424acpi_os_map_memory(acpi_physical_address phys, acpi_size size)
425{
426 return (void *)acpi_os_map_iomem(phys, size);
427}
428EXPORT_SYMBOL_GPL(acpi_os_map_memory);
429
430static void acpi_os_drop_map_ref(struct acpi_ioremap *map)
431{
432 if (!--map->refcount)
433 list_del_rcu(&map->list);
434}
435
436static 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
445void __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}
466EXPORT_SYMBOL_GPL(acpi_os_unmap_iomem);
467
468void __ref acpi_os_unmap_memory(void *virt, acpi_size size)
469{
470 return acpi_os_unmap_iomem((void __iomem *)virt, size);
471}
472EXPORT_SYMBOL_GPL(acpi_os_unmap_memory);
473
474void __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
480int 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
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}
499EXPORT_SYMBOL(acpi_os_map_generic_address);
500
501void 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
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}
525EXPORT_SYMBOL(acpi_os_unmap_generic_address);
526
527#ifdef ACPI_FUTURE_USAGE
528acpi_status
529acpi_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#define ACPI_MAX_OVERRIDE_LEN 100
541
542static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN];
543
544acpi_status
545acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
546 acpi_string * new_val)
547{
548 if (!init_val || !new_val)
549 return AE_BAD_PARAMETER;
550
551 *new_val = NULL;
552 if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {
553 printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n",
554 acpi_os_name);
555 *new_val = acpi_os_name;
556 }
557
558 return AE_OK;
559}
560
561#ifdef CONFIG_ACPI_INITRD_TABLE_OVERRIDE
562#include <linux/earlycpio.h>
563#include <linux/memblock.h>
564
565static u64 acpi_tables_addr;
566static int all_tables_size;
567
568
569static u8 __init acpi_table_checksum(u8 *buffer, u32 length)
570{
571 u8 sum = 0;
572 u8 *end = buffer + length;
573
574 while (buffer < end)
575 sum = (u8) (sum + *(buffer++));
576 return sum;
577}
578
579
580static const char * const table_sigs[] = {
581 ACPI_SIG_BERT, ACPI_SIG_CPEP, ACPI_SIG_ECDT, ACPI_SIG_EINJ,
582 ACPI_SIG_ERST, ACPI_SIG_HEST, ACPI_SIG_MADT, ACPI_SIG_MSCT,
583 ACPI_SIG_SBST, ACPI_SIG_SLIT, ACPI_SIG_SRAT, ACPI_SIG_ASF,
584 ACPI_SIG_BOOT, ACPI_SIG_DBGP, ACPI_SIG_DMAR, ACPI_SIG_HPET,
585 ACPI_SIG_IBFT, ACPI_SIG_IVRS, ACPI_SIG_MCFG, ACPI_SIG_MCHI,
586 ACPI_SIG_SLIC, ACPI_SIG_SPCR, ACPI_SIG_SPMI, ACPI_SIG_TCPA,
587 ACPI_SIG_UEFI, ACPI_SIG_WAET, ACPI_SIG_WDAT, ACPI_SIG_WDDT,
588 ACPI_SIG_WDRT, ACPI_SIG_DSDT, ACPI_SIG_FADT, ACPI_SIG_PSDT,
589 ACPI_SIG_RSDT, ACPI_SIG_XSDT, ACPI_SIG_SSDT, NULL };
590
591#define ACPI_HEADER_SIZE sizeof(struct acpi_table_header)
592
593#define ACPI_OVERRIDE_TABLES 64
594static struct cpio_data __initdata acpi_initrd_files[ACPI_OVERRIDE_TABLES];
595
596#define MAP_CHUNK_SIZE (NR_FIX_BTMAPS << PAGE_SHIFT)
597
598void __init acpi_initrd_override(void *data, size_t size)
599{
600 int sig, no, table_nr = 0, total_offset = 0;
601 long offset = 0;
602 struct acpi_table_header *table;
603 char cpio_path[32] = "kernel/firmware/acpi/";
604 struct cpio_data file;
605
606 if (data == NULL || size == 0)
607 return;
608
609 for (no = 0; no < ACPI_OVERRIDE_TABLES; no++) {
610 file = find_cpio_data(cpio_path, data, size, &offset);
611 if (!file.data)
612 break;
613
614 data += offset;
615 size -= offset;
616
617 if (file.size < sizeof(struct acpi_table_header)) {
618 pr_err("ACPI OVERRIDE: Table smaller than ACPI header [%s%s]\n",
619 cpio_path, file.name);
620 continue;
621 }
622
623 table = file.data;
624
625 for (sig = 0; table_sigs[sig]; sig++)
626 if (!memcmp(table->signature, table_sigs[sig], 4))
627 break;
628
629 if (!table_sigs[sig]) {
630 pr_err("ACPI OVERRIDE: Unknown signature [%s%s]\n",
631 cpio_path, file.name);
632 continue;
633 }
634 if (file.size != table->length) {
635 pr_err("ACPI OVERRIDE: File length does not match table length [%s%s]\n",
636 cpio_path, file.name);
637 continue;
638 }
639 if (acpi_table_checksum(file.data, table->length)) {
640 pr_err("ACPI OVERRIDE: Bad table checksum [%s%s]\n",
641 cpio_path, file.name);
642 continue;
643 }
644
645 pr_info("%4.4s ACPI table found in initrd [%s%s][0x%x]\n",
646 table->signature, cpio_path, file.name, table->length);
647
648 all_tables_size += table->length;
649 acpi_initrd_files[table_nr].data = file.data;
650 acpi_initrd_files[table_nr].size = file.size;
651 table_nr++;
652 }
653 if (table_nr == 0)
654 return;
655
656 acpi_tables_addr =
657 memblock_find_in_range(0, max_low_pfn_mapped << PAGE_SHIFT,
658 all_tables_size, PAGE_SIZE);
659 if (!acpi_tables_addr) {
660 WARN_ON(1);
661 return;
662 }
663
664
665
666
667
668
669
670
671
672
673 memblock_reserve(acpi_tables_addr, all_tables_size);
674 arch_reserve_mem_area(acpi_tables_addr, all_tables_size);
675
676
677
678
679
680
681 for (no = 0; no < table_nr; no++) {
682 unsigned char *src_p = acpi_initrd_files[no].data;
683 phys_addr_t size = acpi_initrd_files[no].size;
684 phys_addr_t dest_addr = acpi_tables_addr + total_offset;
685 phys_addr_t slop, clen;
686 char *dest_p;
687
688 total_offset += size;
689
690 while (size) {
691 slop = dest_addr & ~PAGE_MASK;
692 clen = size;
693 if (clen > MAP_CHUNK_SIZE - slop)
694 clen = MAP_CHUNK_SIZE - slop;
695 dest_p = early_ioremap(dest_addr & PAGE_MASK,
696 clen + slop);
697 memcpy(dest_p + slop, src_p, clen);
698 early_iounmap(dest_p, clen + slop);
699 src_p += clen;
700 dest_addr += clen;
701 size -= clen;
702 }
703 }
704}
705#endif
706
707static void acpi_table_taint(struct acpi_table_header *table)
708{
709 pr_warn(PREFIX
710 "Override [%4.4s-%8.8s], this is unsafe: tainting kernel\n",
711 table->signature, table->oem_table_id);
712 add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE);
713}
714
715
716acpi_status
717acpi_os_table_override(struct acpi_table_header * existing_table,
718 struct acpi_table_header ** new_table)
719{
720 if (!existing_table || !new_table)
721 return AE_BAD_PARAMETER;
722
723 *new_table = NULL;
724
725#ifdef CONFIG_ACPI_CUSTOM_DSDT
726 if (strncmp(existing_table->signature, "DSDT", 4) == 0)
727 *new_table = (struct acpi_table_header *)AmlCode;
728#endif
729 if (*new_table != NULL)
730 acpi_table_taint(existing_table);
731 return AE_OK;
732}
733
734acpi_status
735acpi_os_physical_table_override(struct acpi_table_header *existing_table,
736 acpi_physical_address *address,
737 u32 *table_length)
738{
739#ifndef CONFIG_ACPI_INITRD_TABLE_OVERRIDE
740 *table_length = 0;
741 *address = 0;
742 return AE_OK;
743#else
744 int table_offset = 0;
745 struct acpi_table_header *table;
746
747 *table_length = 0;
748 *address = 0;
749
750 if (!acpi_tables_addr)
751 return AE_OK;
752
753 do {
754 if (table_offset + ACPI_HEADER_SIZE > all_tables_size) {
755 WARN_ON(1);
756 return AE_OK;
757 }
758
759 table = acpi_os_map_memory(acpi_tables_addr + table_offset,
760 ACPI_HEADER_SIZE);
761
762 if (table_offset + table->length > all_tables_size) {
763 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
764 WARN_ON(1);
765 return AE_OK;
766 }
767
768 table_offset += table->length;
769
770 if (memcmp(existing_table->signature, table->signature, 4)) {
771 acpi_os_unmap_memory(table,
772 ACPI_HEADER_SIZE);
773 continue;
774 }
775
776
777 if (memcmp(table->oem_table_id, existing_table->oem_table_id,
778 ACPI_OEM_TABLE_ID_SIZE)) {
779 acpi_os_unmap_memory(table,
780 ACPI_HEADER_SIZE);
781 continue;
782 }
783
784 table_offset -= table->length;
785 *table_length = table->length;
786 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
787 *address = acpi_tables_addr + table_offset;
788 break;
789 } while (table_offset + ACPI_HEADER_SIZE < all_tables_size);
790
791 if (*address != 0)
792 acpi_table_taint(existing_table);
793 return AE_OK;
794#endif
795}
796
797static irqreturn_t acpi_irq(int irq, void *dev_id)
798{
799 u32 handled;
800
801 handled = (*acpi_irq_handler) (acpi_irq_context);
802
803 if (handled) {
804 acpi_irq_handled++;
805 return IRQ_HANDLED;
806 } else {
807 acpi_irq_not_handled++;
808 return IRQ_NONE;
809 }
810}
811
812acpi_status
813acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler,
814 void *context)
815{
816 unsigned int irq;
817
818 acpi_irq_stats_init();
819
820
821
822
823
824 if (gsi != acpi_gbl_FADT.sci_interrupt)
825 return AE_BAD_PARAMETER;
826
827 if (acpi_irq_handler)
828 return AE_ALREADY_ACQUIRED;
829
830 if (acpi_gsi_to_irq(gsi, &irq) < 0) {
831 printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n",
832 gsi);
833 return AE_OK;
834 }
835
836 acpi_irq_handler = handler;
837 acpi_irq_context = context;
838 if (request_irq(irq, acpi_irq, IRQF_SHARED, "acpi", acpi_irq)) {
839 printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq);
840 acpi_irq_handler = NULL;
841 return AE_NOT_ACQUIRED;
842 }
843
844 return AE_OK;
845}
846
847acpi_status acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler)
848{
849 if (irq != acpi_gbl_FADT.sci_interrupt)
850 return AE_BAD_PARAMETER;
851
852 free_irq(irq, acpi_irq);
853 acpi_irq_handler = NULL;
854
855 return AE_OK;
856}
857
858
859
860
861
862void acpi_os_sleep(u64 ms)
863{
864 msleep(ms);
865}
866
867void acpi_os_stall(u32 us)
868{
869 while (us) {
870 u32 delay = 1000;
871
872 if (delay > us)
873 delay = us;
874 udelay(delay);
875 touch_nmi_watchdog();
876 us -= delay;
877 }
878}
879
880
881
882
883
884
885u64 acpi_os_get_timer(void)
886{
887 u64 time_ns = ktime_to_ns(ktime_get());
888 do_div(time_ns, 100);
889 return time_ns;
890}
891
892acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width)
893{
894 u32 dummy;
895
896 if (!value)
897 value = &dummy;
898
899 *value = 0;
900 if (width <= 8) {
901 *(u8 *) value = inb(port);
902 } else if (width <= 16) {
903 *(u16 *) value = inw(port);
904 } else if (width <= 32) {
905 *(u32 *) value = inl(port);
906 } else {
907 BUG();
908 }
909
910 return AE_OK;
911}
912
913EXPORT_SYMBOL(acpi_os_read_port);
914
915acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
916{
917 if (width <= 8) {
918 outb(value, port);
919 } else if (width <= 16) {
920 outw(value, port);
921 } else if (width <= 32) {
922 outl(value, port);
923 } else {
924 BUG();
925 }
926
927 return AE_OK;
928}
929
930EXPORT_SYMBOL(acpi_os_write_port);
931
932#ifdef readq
933static inline u64 read64(const volatile void __iomem *addr)
934{
935 return readq(addr);
936}
937#else
938static inline u64 read64(const volatile void __iomem *addr)
939{
940 u64 l, h;
941 l = readl(addr);
942 h = readl(addr+4);
943 return l | (h << 32);
944}
945#endif
946
947acpi_status
948acpi_os_read_memory(acpi_physical_address phys_addr, u64 *value, u32 width)
949{
950 void __iomem *virt_addr;
951 unsigned int size = width / 8;
952 bool unmap = false;
953 u64 dummy;
954
955 rcu_read_lock();
956 virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
957 if (!virt_addr) {
958 rcu_read_unlock();
959 virt_addr = acpi_os_ioremap(phys_addr, size);
960 if (!virt_addr)
961 return AE_BAD_ADDRESS;
962 unmap = true;
963 }
964
965 if (!value)
966 value = &dummy;
967
968 switch (width) {
969 case 8:
970 *(u8 *) value = readb(virt_addr);
971 break;
972 case 16:
973 *(u16 *) value = readw(virt_addr);
974 break;
975 case 32:
976 *(u32 *) value = readl(virt_addr);
977 break;
978 case 64:
979 *(u64 *) value = read64(virt_addr);
980 break;
981 default:
982 BUG();
983 }
984
985 if (unmap)
986 iounmap(virt_addr);
987 else
988 rcu_read_unlock();
989
990 return AE_OK;
991}
992
993#ifdef writeq
994static inline void write64(u64 val, volatile void __iomem *addr)
995{
996 writeq(val, addr);
997}
998#else
999static inline void write64(u64 val, volatile void __iomem *addr)
1000{
1001 writel(val, addr);
1002 writel(val>>32, addr+4);
1003}
1004#endif
1005
1006acpi_status
1007acpi_os_write_memory(acpi_physical_address phys_addr, u64 value, u32 width)
1008{
1009 void __iomem *virt_addr;
1010 unsigned int size = width / 8;
1011 bool unmap = false;
1012
1013 rcu_read_lock();
1014 virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
1015 if (!virt_addr) {
1016 rcu_read_unlock();
1017 virt_addr = acpi_os_ioremap(phys_addr, size);
1018 if (!virt_addr)
1019 return AE_BAD_ADDRESS;
1020 unmap = true;
1021 }
1022
1023 switch (width) {
1024 case 8:
1025 writeb(value, virt_addr);
1026 break;
1027 case 16:
1028 writew(value, virt_addr);
1029 break;
1030 case 32:
1031 writel(value, virt_addr);
1032 break;
1033 case 64:
1034 write64(value, virt_addr);
1035 break;
1036 default:
1037 BUG();
1038 }
1039
1040 if (unmap)
1041 iounmap(virt_addr);
1042 else
1043 rcu_read_unlock();
1044
1045 return AE_OK;
1046}
1047
1048acpi_status
1049acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
1050 u64 *value, u32 width)
1051{
1052 int result, size;
1053 u32 value32;
1054
1055 if (!value)
1056 return AE_BAD_PARAMETER;
1057
1058 switch (width) {
1059 case 8:
1060 size = 1;
1061 break;
1062 case 16:
1063 size = 2;
1064 break;
1065 case 32:
1066 size = 4;
1067 break;
1068 default:
1069 return AE_ERROR;
1070 }
1071
1072 result = raw_pci_read(pci_id->segment, pci_id->bus,
1073 PCI_DEVFN(pci_id->device, pci_id->function),
1074 reg, size, &value32);
1075 *value = value32;
1076
1077 return (result ? AE_ERROR : AE_OK);
1078}
1079
1080acpi_status
1081acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
1082 u64 value, u32 width)
1083{
1084 int result, size;
1085
1086 switch (width) {
1087 case 8:
1088 size = 1;
1089 break;
1090 case 16:
1091 size = 2;
1092 break;
1093 case 32:
1094 size = 4;
1095 break;
1096 default:
1097 return AE_ERROR;
1098 }
1099
1100 result = raw_pci_write(pci_id->segment, pci_id->bus,
1101 PCI_DEVFN(pci_id->device, pci_id->function),
1102 reg, size, value);
1103
1104 return (result ? AE_ERROR : AE_OK);
1105}
1106
1107static void acpi_os_execute_deferred(struct work_struct *work)
1108{
1109 struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
1110
1111 dpc->function(dpc->context);
1112 kfree(dpc);
1113}
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130acpi_status acpi_os_execute(acpi_execute_type type,
1131 acpi_osd_exec_callback function, void *context)
1132{
1133 acpi_status status = AE_OK;
1134 struct acpi_os_dpc *dpc;
1135 struct workqueue_struct *queue;
1136 int ret;
1137 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
1138 "Scheduling function [%p(%p)] for deferred execution.\n",
1139 function, context));
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150 dpc = kzalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC);
1151 if (!dpc)
1152 return AE_NO_MEMORY;
1153
1154 dpc->function = function;
1155 dpc->context = context;
1156
1157
1158
1159
1160
1161
1162 if (type == OSL_NOTIFY_HANDLER) {
1163 queue = kacpi_notify_wq;
1164 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
1165 } else {
1166 queue = kacpid_wq;
1167 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
1168 }
1169
1170
1171
1172
1173
1174
1175
1176
1177 ret = queue_work_on(0, queue, &dpc->work);
1178
1179 if (!ret) {
1180 printk(KERN_ERR PREFIX
1181 "Call to queue_work() failed.\n");
1182 status = AE_ERROR;
1183 kfree(dpc);
1184 }
1185 return status;
1186}
1187EXPORT_SYMBOL(acpi_os_execute);
1188
1189void acpi_os_wait_events_complete(void)
1190{
1191
1192
1193
1194
1195 if (acpi_irq_handler)
1196 synchronize_hardirq(acpi_gbl_FADT.sci_interrupt);
1197 flush_workqueue(kacpid_wq);
1198 flush_workqueue(kacpi_notify_wq);
1199}
1200
1201struct acpi_hp_work {
1202 struct work_struct work;
1203 struct acpi_device *adev;
1204 u32 src;
1205};
1206
1207static void acpi_hotplug_work_fn(struct work_struct *work)
1208{
1209 struct acpi_hp_work *hpw = container_of(work, struct acpi_hp_work, work);
1210
1211 acpi_os_wait_events_complete();
1212 acpi_device_hotplug(hpw->adev, hpw->src);
1213 kfree(hpw);
1214}
1215
1216acpi_status acpi_hotplug_schedule(struct acpi_device *adev, u32 src)
1217{
1218 struct acpi_hp_work *hpw;
1219
1220 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
1221 "Scheduling hotplug event (%p, %u) for deferred execution.\n",
1222 adev, src));
1223
1224 hpw = kmalloc(sizeof(*hpw), GFP_KERNEL);
1225 if (!hpw)
1226 return AE_NO_MEMORY;
1227
1228 INIT_WORK(&hpw->work, acpi_hotplug_work_fn);
1229 hpw->adev = adev;
1230 hpw->src = src;
1231
1232
1233
1234
1235
1236
1237 if (!queue_work(kacpi_hotplug_wq, &hpw->work)) {
1238 kfree(hpw);
1239 return AE_ERROR;
1240 }
1241 return AE_OK;
1242}
1243
1244bool acpi_queue_hotplug_work(struct work_struct *work)
1245{
1246 return queue_work(kacpi_hotplug_wq, work);
1247}
1248
1249acpi_status
1250acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
1251{
1252 struct semaphore *sem = NULL;
1253
1254 sem = acpi_os_allocate_zeroed(sizeof(struct semaphore));
1255 if (!sem)
1256 return AE_NO_MEMORY;
1257
1258 sema_init(sem, initial_units);
1259
1260 *handle = (acpi_handle *) sem;
1261
1262 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
1263 *handle, initial_units));
1264
1265 return AE_OK;
1266}
1267
1268
1269
1270
1271
1272
1273
1274
1275acpi_status acpi_os_delete_semaphore(acpi_handle handle)
1276{
1277 struct semaphore *sem = (struct semaphore *)handle;
1278
1279 if (!sem)
1280 return AE_BAD_PARAMETER;
1281
1282 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
1283
1284 BUG_ON(!list_empty(&sem->wait_list));
1285 kfree(sem);
1286 sem = NULL;
1287
1288 return AE_OK;
1289}
1290
1291
1292
1293
1294acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
1295{
1296 acpi_status status = AE_OK;
1297 struct semaphore *sem = (struct semaphore *)handle;
1298 long jiffies;
1299 int ret = 0;
1300
1301 if (!sem || (units < 1))
1302 return AE_BAD_PARAMETER;
1303
1304 if (units > 1)
1305 return AE_SUPPORT;
1306
1307 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
1308 handle, units, timeout));
1309
1310 if (timeout == ACPI_WAIT_FOREVER)
1311 jiffies = MAX_SCHEDULE_TIMEOUT;
1312 else
1313 jiffies = msecs_to_jiffies(timeout);
1314
1315 ret = down_timeout(sem, jiffies);
1316 if (ret)
1317 status = AE_TIME;
1318
1319 if (ACPI_FAILURE(status)) {
1320 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
1321 "Failed to acquire semaphore[%p|%d|%d], %s",
1322 handle, units, timeout,
1323 acpi_format_exception(status)));
1324 } else {
1325 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
1326 "Acquired semaphore[%p|%d|%d]", handle,
1327 units, timeout));
1328 }
1329
1330 return status;
1331}
1332
1333
1334
1335
1336acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
1337{
1338 struct semaphore *sem = (struct semaphore *)handle;
1339
1340 if (!sem || (units < 1))
1341 return AE_BAD_PARAMETER;
1342
1343 if (units > 1)
1344 return AE_SUPPORT;
1345
1346 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
1347 units));
1348
1349 up(sem);
1350
1351 return AE_OK;
1352}
1353
1354#ifdef ACPI_FUTURE_USAGE
1355u32 acpi_os_get_line(char *buffer)
1356{
1357
1358#ifdef ENABLE_DEBUGGER
1359 if (acpi_in_debugger) {
1360 u32 chars;
1361
1362 kdb_read(buffer, sizeof(line_buf));
1363
1364
1365 chars = strlen(buffer) - 1;
1366 buffer[chars] = '\0';
1367 }
1368#endif
1369
1370 return 0;
1371}
1372#endif
1373
1374acpi_status acpi_os_signal(u32 function, void *info)
1375{
1376 switch (function) {
1377 case ACPI_SIGNAL_FATAL:
1378 printk(KERN_ERR PREFIX "Fatal opcode executed\n");
1379 break;
1380 case ACPI_SIGNAL_BREAKPOINT:
1381
1382
1383
1384
1385
1386
1387
1388
1389 break;
1390 default:
1391 break;
1392 }
1393
1394 return AE_OK;
1395}
1396
1397static int __init acpi_os_name_setup(char *str)
1398{
1399 char *p = acpi_os_name;
1400 int count = ACPI_MAX_OVERRIDE_LEN - 1;
1401
1402 if (!str || !*str)
1403 return 0;
1404
1405 for (; count-- && *str; str++) {
1406 if (isalnum(*str) || *str == ' ' || *str == ':')
1407 *p++ = *str;
1408 else if (*str == '\'' || *str == '"')
1409 continue;
1410 else
1411 break;
1412 }
1413 *p = 0;
1414
1415 return 1;
1416
1417}
1418
1419__setup("acpi_os_name=", acpi_os_name_setup);
1420
1421#define OSI_STRING_LENGTH_MAX 64
1422#define OSI_STRING_ENTRIES_MAX 16
1423
1424struct osi_setup_entry {
1425 char string[OSI_STRING_LENGTH_MAX];
1426 bool enable;
1427};
1428
1429static struct osi_setup_entry
1430 osi_setup_entries[OSI_STRING_ENTRIES_MAX] __initdata = {
1431 {"Module Device", true},
1432 {"Processor Device", true},
1433 {"3.0 _SCP Extensions", true},
1434 {"Processor Aggregator Device", true},
1435};
1436
1437void __init acpi_osi_setup(char *str)
1438{
1439 struct osi_setup_entry *osi;
1440 bool enable = true;
1441 int i;
1442
1443 if (!acpi_gbl_create_osi_method)
1444 return;
1445
1446 if (str == NULL || *str == '\0') {
1447 printk(KERN_INFO PREFIX "_OSI method disabled\n");
1448 acpi_gbl_create_osi_method = FALSE;
1449 return;
1450 }
1451
1452 if (*str == '!') {
1453 str++;
1454 if (*str == '\0') {
1455 osi_linux.default_disabling = 1;
1456 return;
1457 } else if (*str == '*') {
1458 acpi_update_interfaces(ACPI_DISABLE_ALL_STRINGS);
1459 for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1460 osi = &osi_setup_entries[i];
1461 osi->enable = false;
1462 }
1463 return;
1464 }
1465 enable = false;
1466 }
1467
1468 for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1469 osi = &osi_setup_entries[i];
1470 if (!strcmp(osi->string, str)) {
1471 osi->enable = enable;
1472 break;
1473 } else if (osi->string[0] == '\0') {
1474 osi->enable = enable;
1475 strncpy(osi->string, str, OSI_STRING_LENGTH_MAX);
1476 break;
1477 }
1478 }
1479}
1480
1481static void __init set_osi_linux(unsigned int enable)
1482{
1483 if (osi_linux.enable != enable)
1484 osi_linux.enable = enable;
1485
1486 if (osi_linux.enable)
1487 acpi_osi_setup("Linux");
1488 else
1489 acpi_osi_setup("!Linux");
1490
1491 return;
1492}
1493
1494static void __init acpi_cmdline_osi_linux(unsigned int enable)
1495{
1496 osi_linux.cmdline = 1;
1497 osi_linux.dmi = 0;
1498 set_osi_linux(enable);
1499
1500 return;
1501}
1502
1503void __init acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d)
1504{
1505 printk(KERN_NOTICE PREFIX "DMI detected: %s\n", d->ident);
1506
1507 if (enable == -1)
1508 return;
1509
1510 osi_linux.dmi = 1;
1511 set_osi_linux(enable);
1512
1513 return;
1514}
1515
1516
1517
1518
1519
1520
1521
1522
1523static void __init acpi_osi_setup_late(void)
1524{
1525 struct osi_setup_entry *osi;
1526 char *str;
1527 int i;
1528 acpi_status status;
1529
1530 if (osi_linux.default_disabling) {
1531 status = acpi_update_interfaces(ACPI_DISABLE_ALL_VENDOR_STRINGS);
1532
1533 if (ACPI_SUCCESS(status))
1534 printk(KERN_INFO PREFIX "Disabled all _OSI OS vendors\n");
1535 }
1536
1537 for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1538 osi = &osi_setup_entries[i];
1539 str = osi->string;
1540
1541 if (*str == '\0')
1542 break;
1543 if (osi->enable) {
1544 status = acpi_install_interface(str);
1545
1546 if (ACPI_SUCCESS(status))
1547 printk(KERN_INFO PREFIX "Added _OSI(%s)\n", str);
1548 } else {
1549 status = acpi_remove_interface(str);
1550
1551 if (ACPI_SUCCESS(status))
1552 printk(KERN_INFO PREFIX "Deleted _OSI(%s)\n", str);
1553 }
1554 }
1555}
1556
1557static int __init osi_setup(char *str)
1558{
1559 if (str && !strcmp("Linux", str))
1560 acpi_cmdline_osi_linux(1);
1561 else if (str && !strcmp("!Linux", str))
1562 acpi_cmdline_osi_linux(0);
1563 else
1564 acpi_osi_setup(str);
1565
1566 return 1;
1567}
1568
1569__setup("acpi_osi=", osi_setup);
1570
1571
1572
1573
1574
1575
1576
1577static int __init acpi_no_auto_serialize_setup(char *str)
1578{
1579 acpi_gbl_auto_serialize_methods = FALSE;
1580 pr_info("ACPI: auto-serialization disabled\n");
1581
1582 return 1;
1583}
1584
1585__setup("acpi_no_auto_serialize", acpi_no_auto_serialize_setup);
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603#define ENFORCE_RESOURCES_STRICT 2
1604#define ENFORCE_RESOURCES_LAX 1
1605#define ENFORCE_RESOURCES_NO 0
1606
1607static unsigned int acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1608
1609static int __init acpi_enforce_resources_setup(char *str)
1610{
1611 if (str == NULL || *str == '\0')
1612 return 0;
1613
1614 if (!strcmp("strict", str))
1615 acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1616 else if (!strcmp("lax", str))
1617 acpi_enforce_resources = ENFORCE_RESOURCES_LAX;
1618 else if (!strcmp("no", str))
1619 acpi_enforce_resources = ENFORCE_RESOURCES_NO;
1620
1621 return 1;
1622}
1623
1624__setup("acpi_enforce_resources=", acpi_enforce_resources_setup);
1625
1626
1627
1628int acpi_check_resource_conflict(const struct resource *res)
1629{
1630 acpi_adr_space_type space_id;
1631 acpi_size length;
1632 u8 warn = 0;
1633 int clash = 0;
1634
1635 if (acpi_enforce_resources == ENFORCE_RESOURCES_NO)
1636 return 0;
1637 if (!(res->flags & IORESOURCE_IO) && !(res->flags & IORESOURCE_MEM))
1638 return 0;
1639
1640 if (res->flags & IORESOURCE_IO)
1641 space_id = ACPI_ADR_SPACE_SYSTEM_IO;
1642 else
1643 space_id = ACPI_ADR_SPACE_SYSTEM_MEMORY;
1644
1645 length = resource_size(res);
1646 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO)
1647 warn = 1;
1648 clash = acpi_check_address_range(space_id, res->start, length, warn);
1649
1650 if (clash) {
1651 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO) {
1652 if (acpi_enforce_resources == ENFORCE_RESOURCES_LAX)
1653 printk(KERN_NOTICE "ACPI: This conflict may"
1654 " cause random problems and system"
1655 " instability\n");
1656 printk(KERN_INFO "ACPI: If an ACPI driver is available"
1657 " for this device, you should use it instead of"
1658 " the native driver\n");
1659 }
1660 if (acpi_enforce_resources == ENFORCE_RESOURCES_STRICT)
1661 return -EBUSY;
1662 }
1663 return 0;
1664}
1665EXPORT_SYMBOL(acpi_check_resource_conflict);
1666
1667int acpi_check_region(resource_size_t start, resource_size_t n,
1668 const char *name)
1669{
1670 struct resource res = {
1671 .start = start,
1672 .end = start + n - 1,
1673 .name = name,
1674 .flags = IORESOURCE_IO,
1675 };
1676
1677 return acpi_check_resource_conflict(&res);
1678}
1679EXPORT_SYMBOL(acpi_check_region);
1680
1681
1682
1683
1684int acpi_resources_are_enforced(void)
1685{
1686 return acpi_enforce_resources == ENFORCE_RESOURCES_STRICT;
1687}
1688EXPORT_SYMBOL(acpi_resources_are_enforced);
1689
1690
1691
1692
1693void acpi_os_delete_lock(acpi_spinlock handle)
1694{
1695 ACPI_FREE(handle);
1696}
1697
1698
1699
1700
1701
1702
1703
1704acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp)
1705{
1706 acpi_cpu_flags flags;
1707 spin_lock_irqsave(lockp, flags);
1708 return flags;
1709}
1710
1711
1712
1713
1714
1715void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
1716{
1717 spin_unlock_irqrestore(lockp, flags);
1718}
1719
1720#ifndef ACPI_USE_LOCAL_CACHE
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737acpi_status
1738acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
1739{
1740 *cache = kmem_cache_create(name, size, 0, 0, NULL);
1741 if (*cache == NULL)
1742 return AE_ERROR;
1743 else
1744 return AE_OK;
1745}
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
1760{
1761 kmem_cache_shrink(cache);
1762 return (AE_OK);
1763}
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
1779{
1780 kmem_cache_destroy(cache);
1781 return (AE_OK);
1782}
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
1799{
1800 kmem_cache_free(cache, object);
1801 return (AE_OK);
1802}
1803#endif
1804
1805static int __init acpi_no_static_ssdt_setup(char *s)
1806{
1807 acpi_gbl_disable_ssdt_table_install = TRUE;
1808 pr_info("ACPI: static SSDT installation disabled\n");
1809
1810 return 0;
1811}
1812
1813early_param("acpi_no_static_ssdt", acpi_no_static_ssdt_setup);
1814
1815static int __init acpi_disable_return_repair(char *s)
1816{
1817 printk(KERN_NOTICE PREFIX
1818 "ACPI: Predefined validation mechanism disabled\n");
1819 acpi_gbl_disable_auto_repair = TRUE;
1820
1821 return 1;
1822}
1823
1824__setup("acpica_no_return_repair", acpi_disable_return_repair);
1825
1826acpi_status __init acpi_os_initialize(void)
1827{
1828 acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1829 acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1830 acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe0_block);
1831 acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe1_block);
1832 if (acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER) {
1833
1834
1835
1836
1837 int rv;
1838
1839 rv = acpi_os_map_generic_address(&acpi_gbl_FADT.reset_register);
1840 pr_debug(PREFIX "%s: map reset_reg status %d\n", __func__, rv);
1841 }
1842
1843 return AE_OK;
1844}
1845
1846acpi_status __init acpi_os_initialize1(void)
1847{
1848 kacpid_wq = alloc_workqueue("kacpid", 0, 1);
1849 kacpi_notify_wq = alloc_workqueue("kacpi_notify", 0, 1);
1850 kacpi_hotplug_wq = alloc_ordered_workqueue("kacpi_hotplug", 0);
1851 BUG_ON(!kacpid_wq);
1852 BUG_ON(!kacpi_notify_wq);
1853 BUG_ON(!kacpi_hotplug_wq);
1854 acpi_install_interface_handler(acpi_osi_handler);
1855 acpi_osi_setup_late();
1856 return AE_OK;
1857}
1858
1859acpi_status acpi_os_terminate(void)
1860{
1861 if (acpi_irq_handler) {
1862 acpi_os_remove_interrupt_handler(acpi_gbl_FADT.sci_interrupt,
1863 acpi_irq_handler);
1864 }
1865
1866 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe1_block);
1867 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe0_block);
1868 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1869 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1870 if (acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER)
1871 acpi_os_unmap_generic_address(&acpi_gbl_FADT.reset_register);
1872
1873 destroy_workqueue(kacpid_wq);
1874 destroy_workqueue(kacpi_notify_wq);
1875 destroy_workqueue(kacpi_hotplug_wq);
1876
1877 return AE_OK;
1878}
1879
1880acpi_status acpi_os_prepare_sleep(u8 sleep_state, u32 pm1a_control,
1881 u32 pm1b_control)
1882{
1883 int rc = 0;
1884 if (__acpi_os_prepare_sleep)
1885 rc = __acpi_os_prepare_sleep(sleep_state,
1886 pm1a_control, pm1b_control);
1887 if (rc < 0)
1888 return AE_ERROR;
1889 else if (rc > 0)
1890 return AE_CTRL_SKIP;
1891
1892 return AE_OK;
1893}
1894
1895void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state,
1896 u32 pm1a_ctrl, u32 pm1b_ctrl))
1897{
1898 __acpi_os_prepare_sleep = func;
1899}
1900
1901acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state, u32 val_a,
1902 u32 val_b)
1903{
1904 int rc = 0;
1905 if (__acpi_os_prepare_extended_sleep)
1906 rc = __acpi_os_prepare_extended_sleep(sleep_state,
1907 val_a, val_b);
1908 if (rc < 0)
1909 return AE_ERROR;
1910 else if (rc > 0)
1911 return AE_CTRL_SKIP;
1912
1913 return AE_OK;
1914}
1915
1916void acpi_os_set_prepare_extended_sleep(int (*func)(u8 sleep_state,
1917 u32 val_a, u32 val_b))
1918{
1919 __acpi_os_prepare_extended_sleep = func;
1920}
1921