]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/acpi/osl.c
Merge branch 'd3' into release
[~shefty/rdma-dev.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 <acpi/acpi.h>
53 #include <acpi/acpi_bus.h>
54 #include <acpi/processor.h>
55
56 #define _COMPONENT              ACPI_OS_SERVICES
57 ACPI_MODULE_NAME("osl");
58 #define PREFIX          "ACPI: "
59 struct acpi_os_dpc {
60         acpi_osd_exec_callback function;
61         void *context;
62         struct work_struct work;
63         int wait;
64 };
65
66 #ifdef CONFIG_ACPI_CUSTOM_DSDT
67 #include CONFIG_ACPI_CUSTOM_DSDT_FILE
68 #endif
69
70 #ifdef ENABLE_DEBUGGER
71 #include <linux/kdb.h>
72
73 /* stuff for debugger support */
74 int acpi_in_debugger;
75 EXPORT_SYMBOL(acpi_in_debugger);
76
77 extern char line_buf[80];
78 #endif                          /*ENABLE_DEBUGGER */
79
80 static acpi_osd_handler acpi_irq_handler;
81 static void *acpi_irq_context;
82 static struct workqueue_struct *kacpid_wq;
83 static struct workqueue_struct *kacpi_notify_wq;
84 struct workqueue_struct *kacpi_hotplug_wq;
85 EXPORT_SYMBOL(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 } osi_linux = {0, 0, 0};
142
143 static u32 acpi_osi_handler(acpi_string interface, u32 supported)
144 {
145         if (!strcmp("Linux", interface)) {
146
147                 printk_once(KERN_NOTICE FW_BUG PREFIX
148                         "BIOS _OSI(Linux) query %s%s\n",
149                         osi_linux.enable ? "honored" : "ignored",
150                         osi_linux.cmdline ? " via cmdline" :
151                         osi_linux.dmi ? " via DMI" : "");
152         }
153
154         return supported;
155 }
156
157 static void __init acpi_request_region (struct acpi_generic_address *gas,
158         unsigned int length, char *desc)
159 {
160         u64 addr;
161
162         /* Handle possible alignment issues */
163         memcpy(&addr, &gas->address, sizeof(addr));
164         if (!addr || !length)
165                 return;
166
167         /* Resources are never freed */
168         if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO)
169                 request_region(addr, length, desc);
170         else if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
171                 request_mem_region(addr, length, desc);
172 }
173
174 static int __init acpi_reserve_resources(void)
175 {
176         acpi_request_region(&acpi_gbl_FADT.xpm1a_event_block, acpi_gbl_FADT.pm1_event_length,
177                 "ACPI PM1a_EVT_BLK");
178
179         acpi_request_region(&acpi_gbl_FADT.xpm1b_event_block, acpi_gbl_FADT.pm1_event_length,
180                 "ACPI PM1b_EVT_BLK");
181
182         acpi_request_region(&acpi_gbl_FADT.xpm1a_control_block, acpi_gbl_FADT.pm1_control_length,
183                 "ACPI PM1a_CNT_BLK");
184
185         acpi_request_region(&acpi_gbl_FADT.xpm1b_control_block, acpi_gbl_FADT.pm1_control_length,
186                 "ACPI PM1b_CNT_BLK");
187
188         if (acpi_gbl_FADT.pm_timer_length == 4)
189                 acpi_request_region(&acpi_gbl_FADT.xpm_timer_block, 4, "ACPI PM_TMR");
190
191         acpi_request_region(&acpi_gbl_FADT.xpm2_control_block, acpi_gbl_FADT.pm2_control_length,
192                 "ACPI PM2_CNT_BLK");
193
194         /* Length of GPE blocks must be a non-negative multiple of 2 */
195
196         if (!(acpi_gbl_FADT.gpe0_block_length & 0x1))
197                 acpi_request_region(&acpi_gbl_FADT.xgpe0_block,
198                                acpi_gbl_FADT.gpe0_block_length, "ACPI GPE0_BLK");
199
200         if (!(acpi_gbl_FADT.gpe1_block_length & 0x1))
201                 acpi_request_region(&acpi_gbl_FADT.xgpe1_block,
202                                acpi_gbl_FADT.gpe1_block_length, "ACPI GPE1_BLK");
203
204         return 0;
205 }
206 device_initcall(acpi_reserve_resources);
207
208 void acpi_os_printf(const char *fmt, ...)
209 {
210         va_list args;
211         va_start(args, fmt);
212         acpi_os_vprintf(fmt, args);
213         va_end(args);
214 }
215
216 void acpi_os_vprintf(const char *fmt, va_list args)
217 {
218         static char buffer[512];
219
220         vsprintf(buffer, fmt, args);
221
222 #ifdef ENABLE_DEBUGGER
223         if (acpi_in_debugger) {
224                 kdb_printf("%s", buffer);
225         } else {
226                 printk(KERN_CONT "%s", buffer);
227         }
228 #else
229         printk(KERN_CONT "%s", buffer);
230 #endif
231 }
232
233 #ifdef CONFIG_KEXEC
234 static unsigned long acpi_rsdp;
235 static int __init setup_acpi_rsdp(char *arg)
236 {
237         acpi_rsdp = simple_strtoul(arg, NULL, 16);
238         return 0;
239 }
240 early_param("acpi_rsdp", setup_acpi_rsdp);
241 #endif
242
243 acpi_physical_address __init acpi_os_get_root_pointer(void)
244 {
245 #ifdef CONFIG_KEXEC
246         if (acpi_rsdp)
247                 return acpi_rsdp;
248 #endif
249
250         if (efi_enabled) {
251                 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
252                         return efi.acpi20;
253                 else if (efi.acpi != EFI_INVALID_TABLE_ADDR)
254                         return efi.acpi;
255                 else {
256                         printk(KERN_ERR PREFIX
257                                "System description tables not found\n");
258                         return 0;
259                 }
260         } else {
261                 acpi_physical_address pa = 0;
262
263                 acpi_find_root_pointer(&pa);
264                 return pa;
265         }
266 }
267
268 /* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
269 static struct acpi_ioremap *
270 acpi_map_lookup(acpi_physical_address phys, acpi_size size)
271 {
272         struct acpi_ioremap *map;
273
274         list_for_each_entry_rcu(map, &acpi_ioremaps, list)
275                 if (map->phys <= phys &&
276                     phys + size <= map->phys + map->size)
277                         return map;
278
279         return NULL;
280 }
281
282 /* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
283 static void __iomem *
284 acpi_map_vaddr_lookup(acpi_physical_address phys, unsigned int size)
285 {
286         struct acpi_ioremap *map;
287
288         map = acpi_map_lookup(phys, size);
289         if (map)
290                 return map->virt + (phys - map->phys);
291
292         return NULL;
293 }
294
295 void __iomem *acpi_os_get_iomem(acpi_physical_address phys, unsigned int size)
296 {
297         struct acpi_ioremap *map;
298         void __iomem *virt = NULL;
299
300         mutex_lock(&acpi_ioremap_lock);
301         map = acpi_map_lookup(phys, size);
302         if (map) {
303                 virt = map->virt + (phys - map->phys);
304                 map->refcount++;
305         }
306         mutex_unlock(&acpi_ioremap_lock);
307         return virt;
308 }
309 EXPORT_SYMBOL_GPL(acpi_os_get_iomem);
310
311 /* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
312 static struct acpi_ioremap *
313 acpi_map_lookup_virt(void __iomem *virt, acpi_size size)
314 {
315         struct acpi_ioremap *map;
316
317         list_for_each_entry_rcu(map, &acpi_ioremaps, list)
318                 if (map->virt <= virt &&
319                     virt + size <= map->virt + map->size)
320                         return map;
321
322         return NULL;
323 }
324
325 #ifndef CONFIG_IA64
326 #define should_use_kmap(pfn)   page_is_ram(pfn)
327 #else
328 /* ioremap will take care of cache attributes */
329 #define should_use_kmap(pfn)   0
330 #endif
331
332 static void __iomem *acpi_map(acpi_physical_address pg_off, unsigned long pg_sz)
333 {
334         unsigned long pfn;
335
336         pfn = pg_off >> PAGE_SHIFT;
337         if (should_use_kmap(pfn)) {
338                 if (pg_sz > PAGE_SIZE)
339                         return NULL;
340                 return (void __iomem __force *)kmap(pfn_to_page(pfn));
341         } else
342                 return acpi_os_ioremap(pg_off, pg_sz);
343 }
344
345 static void acpi_unmap(acpi_physical_address pg_off, void __iomem *vaddr)
346 {
347         unsigned long pfn;
348
349         pfn = pg_off >> PAGE_SHIFT;
350         if (should_use_kmap(pfn))
351                 kunmap(pfn_to_page(pfn));
352         else
353                 iounmap(vaddr);
354 }
355
356 void __iomem *__init_refok
357 acpi_os_map_memory(acpi_physical_address phys, acpi_size size)
358 {
359         struct acpi_ioremap *map;
360         void __iomem *virt;
361         acpi_physical_address pg_off;
362         acpi_size pg_sz;
363
364         if (phys > ULONG_MAX) {
365                 printk(KERN_ERR PREFIX "Cannot map memory that high\n");
366                 return NULL;
367         }
368
369         if (!acpi_gbl_permanent_mmap)
370                 return __acpi_map_table((unsigned long)phys, size);
371
372         mutex_lock(&acpi_ioremap_lock);
373         /* Check if there's a suitable mapping already. */
374         map = acpi_map_lookup(phys, size);
375         if (map) {
376                 map->refcount++;
377                 goto out;
378         }
379
380         map = kzalloc(sizeof(*map), GFP_KERNEL);
381         if (!map) {
382                 mutex_unlock(&acpi_ioremap_lock);
383                 return NULL;
384         }
385
386         pg_off = round_down(phys, PAGE_SIZE);
387         pg_sz = round_up(phys + size, PAGE_SIZE) - pg_off;
388         virt = acpi_map(pg_off, pg_sz);
389         if (!virt) {
390                 mutex_unlock(&acpi_ioremap_lock);
391                 kfree(map);
392                 return NULL;
393         }
394
395         INIT_LIST_HEAD(&map->list);
396         map->virt = virt;
397         map->phys = pg_off;
398         map->size = pg_sz;
399         map->refcount = 1;
400
401         list_add_tail_rcu(&map->list, &acpi_ioremaps);
402
403  out:
404         mutex_unlock(&acpi_ioremap_lock);
405         return map->virt + (phys - map->phys);
406 }
407 EXPORT_SYMBOL_GPL(acpi_os_map_memory);
408
409 static void acpi_os_drop_map_ref(struct acpi_ioremap *map)
410 {
411         if (!--map->refcount)
412                 list_del_rcu(&map->list);
413 }
414
415 static void acpi_os_map_cleanup(struct acpi_ioremap *map)
416 {
417         if (!map->refcount) {
418                 synchronize_rcu();
419                 acpi_unmap(map->phys, map->virt);
420                 kfree(map);
421         }
422 }
423
424 void __ref acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
425 {
426         struct acpi_ioremap *map;
427
428         if (!acpi_gbl_permanent_mmap) {
429                 __acpi_unmap_table(virt, size);
430                 return;
431         }
432
433         mutex_lock(&acpi_ioremap_lock);
434         map = acpi_map_lookup_virt(virt, size);
435         if (!map) {
436                 mutex_unlock(&acpi_ioremap_lock);
437                 WARN(true, PREFIX "%s: bad address %p\n", __func__, virt);
438                 return;
439         }
440         acpi_os_drop_map_ref(map);
441         mutex_unlock(&acpi_ioremap_lock);
442
443         acpi_os_map_cleanup(map);
444 }
445 EXPORT_SYMBOL_GPL(acpi_os_unmap_memory);
446
447 void __init early_acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
448 {
449         if (!acpi_gbl_permanent_mmap)
450                 __acpi_unmap_table(virt, size);
451 }
452
453 int acpi_os_map_generic_address(struct acpi_generic_address *gas)
454 {
455         u64 addr;
456         void __iomem *virt;
457
458         if (gas->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
459                 return 0;
460
461         /* Handle possible alignment issues */
462         memcpy(&addr, &gas->address, sizeof(addr));
463         if (!addr || !gas->bit_width)
464                 return -EINVAL;
465
466         virt = acpi_os_map_memory(addr, gas->bit_width / 8);
467         if (!virt)
468                 return -EIO;
469
470         return 0;
471 }
472 EXPORT_SYMBOL(acpi_os_map_generic_address);
473
474 void acpi_os_unmap_generic_address(struct acpi_generic_address *gas)
475 {
476         u64 addr;
477         struct acpi_ioremap *map;
478
479         if (gas->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
480                 return;
481
482         /* Handle possible alignment issues */
483         memcpy(&addr, &gas->address, sizeof(addr));
484         if (!addr || !gas->bit_width)
485                 return;
486
487         mutex_lock(&acpi_ioremap_lock);
488         map = acpi_map_lookup(addr, gas->bit_width / 8);
489         if (!map) {
490                 mutex_unlock(&acpi_ioremap_lock);
491                 return;
492         }
493         acpi_os_drop_map_ref(map);
494         mutex_unlock(&acpi_ioremap_lock);
495
496         acpi_os_map_cleanup(map);
497 }
498 EXPORT_SYMBOL(acpi_os_unmap_generic_address);
499
500 #ifdef ACPI_FUTURE_USAGE
501 acpi_status
502 acpi_os_get_physical_address(void *virt, acpi_physical_address * phys)
503 {
504         if (!phys || !virt)
505                 return AE_BAD_PARAMETER;
506
507         *phys = virt_to_phys(virt);
508
509         return AE_OK;
510 }
511 #endif
512
513 #define ACPI_MAX_OVERRIDE_LEN 100
514
515 static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN];
516
517 acpi_status
518 acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
519                             acpi_string * new_val)
520 {
521         if (!init_val || !new_val)
522                 return AE_BAD_PARAMETER;
523
524         *new_val = NULL;
525         if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {
526                 printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n",
527                        acpi_os_name);
528                 *new_val = acpi_os_name;
529         }
530
531         return AE_OK;
532 }
533
534 acpi_status
535 acpi_os_table_override(struct acpi_table_header * existing_table,
536                        struct acpi_table_header ** new_table)
537 {
538         if (!existing_table || !new_table)
539                 return AE_BAD_PARAMETER;
540
541         *new_table = NULL;
542
543 #ifdef CONFIG_ACPI_CUSTOM_DSDT
544         if (strncmp(existing_table->signature, "DSDT", 4) == 0)
545                 *new_table = (struct acpi_table_header *)AmlCode;
546 #endif
547         if (*new_table != NULL) {
548                 printk(KERN_WARNING PREFIX "Override [%4.4s-%8.8s], "
549                            "this is unsafe: tainting kernel\n",
550                        existing_table->signature,
551                        existing_table->oem_table_id);
552                 add_taint(TAINT_OVERRIDDEN_ACPI_TABLE);
553         }
554         return AE_OK;
555 }
556
557 acpi_status
558 acpi_os_physical_table_override(struct acpi_table_header *existing_table,
559                                 acpi_physical_address * new_address,
560                                 u32 *new_table_length)
561 {
562         return AE_SUPPORT;
563 }
564
565
566 static irqreturn_t acpi_irq(int irq, void *dev_id)
567 {
568         u32 handled;
569
570         handled = (*acpi_irq_handler) (acpi_irq_context);
571
572         if (handled) {
573                 acpi_irq_handled++;
574                 return IRQ_HANDLED;
575         } else {
576                 acpi_irq_not_handled++;
577                 return IRQ_NONE;
578         }
579 }
580
581 acpi_status
582 acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler,
583                                   void *context)
584 {
585         unsigned int irq;
586
587         acpi_irq_stats_init();
588
589         /*
590          * ACPI interrupts different from the SCI in our copy of the FADT are
591          * not supported.
592          */
593         if (gsi != acpi_gbl_FADT.sci_interrupt)
594                 return AE_BAD_PARAMETER;
595
596         if (acpi_irq_handler)
597                 return AE_ALREADY_ACQUIRED;
598
599         if (acpi_gsi_to_irq(gsi, &irq) < 0) {
600                 printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n",
601                        gsi);
602                 return AE_OK;
603         }
604
605         acpi_irq_handler = handler;
606         acpi_irq_context = context;
607         if (request_threaded_irq(irq, NULL, acpi_irq, IRQF_SHARED, "acpi",
608                                  acpi_irq)) {
609                 printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq);
610                 acpi_irq_handler = NULL;
611                 return AE_NOT_ACQUIRED;
612         }
613
614         return AE_OK;
615 }
616
617 acpi_status acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler)
618 {
619         if (irq != acpi_gbl_FADT.sci_interrupt)
620                 return AE_BAD_PARAMETER;
621
622         free_irq(irq, acpi_irq);
623         acpi_irq_handler = NULL;
624
625         return AE_OK;
626 }
627
628 /*
629  * Running in interpreter thread context, safe to sleep
630  */
631
632 void acpi_os_sleep(u64 ms)
633 {
634         schedule_timeout_interruptible(msecs_to_jiffies(ms));
635 }
636
637 void acpi_os_stall(u32 us)
638 {
639         while (us) {
640                 u32 delay = 1000;
641
642                 if (delay > us)
643                         delay = us;
644                 udelay(delay);
645                 touch_nmi_watchdog();
646                 us -= delay;
647         }
648 }
649
650 /*
651  * Support ACPI 3.0 AML Timer operand
652  * Returns 64-bit free-running, monotonically increasing timer
653  * with 100ns granularity
654  */
655 u64 acpi_os_get_timer(void)
656 {
657         static u64 t;
658
659 #ifdef  CONFIG_HPET
660         /* TBD: use HPET if available */
661 #endif
662
663 #ifdef  CONFIG_X86_PM_TIMER
664         /* TBD: default to PM timer if HPET was not available */
665 #endif
666         if (!t)
667                 printk(KERN_ERR PREFIX "acpi_os_get_timer() TBD\n");
668
669         return ++t;
670 }
671
672 acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width)
673 {
674         u32 dummy;
675
676         if (!value)
677                 value = &dummy;
678
679         *value = 0;
680         if (width <= 8) {
681                 *(u8 *) value = inb(port);
682         } else if (width <= 16) {
683                 *(u16 *) value = inw(port);
684         } else if (width <= 32) {
685                 *(u32 *) value = inl(port);
686         } else {
687                 BUG();
688         }
689
690         return AE_OK;
691 }
692
693 EXPORT_SYMBOL(acpi_os_read_port);
694
695 acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
696 {
697         if (width <= 8) {
698                 outb(value, port);
699         } else if (width <= 16) {
700                 outw(value, port);
701         } else if (width <= 32) {
702                 outl(value, port);
703         } else {
704                 BUG();
705         }
706
707         return AE_OK;
708 }
709
710 EXPORT_SYMBOL(acpi_os_write_port);
711
712 #ifdef readq
713 static inline u64 read64(const volatile void __iomem *addr)
714 {
715         return readq(addr);
716 }
717 #else
718 static inline u64 read64(const volatile void __iomem *addr)
719 {
720         u64 l, h;
721         l = readl(addr);
722         h = readl(addr+4);
723         return l | (h << 32);
724 }
725 #endif
726
727 acpi_status
728 acpi_os_read_memory(acpi_physical_address phys_addr, u64 *value, u32 width)
729 {
730         void __iomem *virt_addr;
731         unsigned int size = width / 8;
732         bool unmap = false;
733         u64 dummy;
734
735         rcu_read_lock();
736         virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
737         if (!virt_addr) {
738                 rcu_read_unlock();
739                 virt_addr = acpi_os_ioremap(phys_addr, size);
740                 if (!virt_addr)
741                         return AE_BAD_ADDRESS;
742                 unmap = true;
743         }
744
745         if (!value)
746                 value = &dummy;
747
748         switch (width) {
749         case 8:
750                 *(u8 *) value = readb(virt_addr);
751                 break;
752         case 16:
753                 *(u16 *) value = readw(virt_addr);
754                 break;
755         case 32:
756                 *(u32 *) value = readl(virt_addr);
757                 break;
758         case 64:
759                 *(u64 *) value = read64(virt_addr);
760                 break;
761         default:
762                 BUG();
763         }
764
765         if (unmap)
766                 iounmap(virt_addr);
767         else
768                 rcu_read_unlock();
769
770         return AE_OK;
771 }
772
773 #ifdef writeq
774 static inline void write64(u64 val, volatile void __iomem *addr)
775 {
776         writeq(val, addr);
777 }
778 #else
779 static inline void write64(u64 val, volatile void __iomem *addr)
780 {
781         writel(val, addr);
782         writel(val>>32, addr+4);
783 }
784 #endif
785
786 acpi_status
787 acpi_os_write_memory(acpi_physical_address phys_addr, u64 value, u32 width)
788 {
789         void __iomem *virt_addr;
790         unsigned int size = width / 8;
791         bool unmap = false;
792
793         rcu_read_lock();
794         virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
795         if (!virt_addr) {
796                 rcu_read_unlock();
797                 virt_addr = acpi_os_ioremap(phys_addr, size);
798                 if (!virt_addr)
799                         return AE_BAD_ADDRESS;
800                 unmap = true;
801         }
802
803         switch (width) {
804         case 8:
805                 writeb(value, virt_addr);
806                 break;
807         case 16:
808                 writew(value, virt_addr);
809                 break;
810         case 32:
811                 writel(value, virt_addr);
812                 break;
813         case 64:
814                 write64(value, virt_addr);
815                 break;
816         default:
817                 BUG();
818         }
819
820         if (unmap)
821                 iounmap(virt_addr);
822         else
823                 rcu_read_unlock();
824
825         return AE_OK;
826 }
827
828 acpi_status
829 acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
830                                u64 *value, u32 width)
831 {
832         int result, size;
833         u32 value32;
834
835         if (!value)
836                 return AE_BAD_PARAMETER;
837
838         switch (width) {
839         case 8:
840                 size = 1;
841                 break;
842         case 16:
843                 size = 2;
844                 break;
845         case 32:
846                 size = 4;
847                 break;
848         default:
849                 return AE_ERROR;
850         }
851
852         result = raw_pci_read(pci_id->segment, pci_id->bus,
853                                 PCI_DEVFN(pci_id->device, pci_id->function),
854                                 reg, size, &value32);
855         *value = value32;
856
857         return (result ? AE_ERROR : AE_OK);
858 }
859
860 acpi_status
861 acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
862                                 u64 value, u32 width)
863 {
864         int result, size;
865
866         switch (width) {
867         case 8:
868                 size = 1;
869                 break;
870         case 16:
871                 size = 2;
872                 break;
873         case 32:
874                 size = 4;
875                 break;
876         default:
877                 return AE_ERROR;
878         }
879
880         result = raw_pci_write(pci_id->segment, pci_id->bus,
881                                 PCI_DEVFN(pci_id->device, pci_id->function),
882                                 reg, size, value);
883
884         return (result ? AE_ERROR : AE_OK);
885 }
886
887 static void acpi_os_execute_deferred(struct work_struct *work)
888 {
889         struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
890
891         if (dpc->wait)
892                 acpi_os_wait_events_complete(NULL);
893
894         dpc->function(dpc->context);
895         kfree(dpc);
896 }
897
898 /*******************************************************************************
899  *
900  * FUNCTION:    acpi_os_execute
901  *
902  * PARAMETERS:  Type               - Type of the callback
903  *              Function           - Function to be executed
904  *              Context            - Function parameters
905  *
906  * RETURN:      Status
907  *
908  * DESCRIPTION: Depending on type, either queues function for deferred execution or
909  *              immediately executes function on a separate thread.
910  *
911  ******************************************************************************/
912
913 static acpi_status __acpi_os_execute(acpi_execute_type type,
914         acpi_osd_exec_callback function, void *context, int hp)
915 {
916         acpi_status status = AE_OK;
917         struct acpi_os_dpc *dpc;
918         struct workqueue_struct *queue;
919         int ret;
920         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
921                           "Scheduling function [%p(%p)] for deferred execution.\n",
922                           function, context));
923
924         /*
925          * Allocate/initialize DPC structure.  Note that this memory will be
926          * freed by the callee.  The kernel handles the work_struct list  in a
927          * way that allows us to also free its memory inside the callee.
928          * Because we may want to schedule several tasks with different
929          * parameters we can't use the approach some kernel code uses of
930          * having a static work_struct.
931          */
932
933         dpc = kmalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC);
934         if (!dpc)
935                 return AE_NO_MEMORY;
936
937         dpc->function = function;
938         dpc->context = context;
939
940         /*
941          * We can't run hotplug code in keventd_wq/kacpid_wq/kacpid_notify_wq
942          * because the hotplug code may call driver .remove() functions,
943          * which invoke flush_scheduled_work/acpi_os_wait_events_complete
944          * to flush these workqueues.
945          */
946         queue = hp ? kacpi_hotplug_wq :
947                 (type == OSL_NOTIFY_HANDLER ? kacpi_notify_wq : kacpid_wq);
948         dpc->wait = hp ? 1 : 0;
949
950         if (queue == kacpi_hotplug_wq)
951                 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
952         else if (queue == kacpi_notify_wq)
953                 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
954         else
955                 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
956
957         /*
958          * On some machines, a software-initiated SMI causes corruption unless
959          * the SMI runs on CPU 0.  An SMI can be initiated by any AML, but
960          * typically it's done in GPE-related methods that are run via
961          * workqueues, so we can avoid the known corruption cases by always
962          * queueing on CPU 0.
963          */
964         ret = queue_work_on(0, queue, &dpc->work);
965
966         if (!ret) {
967                 printk(KERN_ERR PREFIX
968                           "Call to queue_work() failed.\n");
969                 status = AE_ERROR;
970                 kfree(dpc);
971         }
972         return status;
973 }
974
975 acpi_status acpi_os_execute(acpi_execute_type type,
976                             acpi_osd_exec_callback function, void *context)
977 {
978         return __acpi_os_execute(type, function, context, 0);
979 }
980 EXPORT_SYMBOL(acpi_os_execute);
981
982 acpi_status acpi_os_hotplug_execute(acpi_osd_exec_callback function,
983         void *context)
984 {
985         return __acpi_os_execute(0, function, context, 1);
986 }
987
988 void acpi_os_wait_events_complete(void *context)
989 {
990         flush_workqueue(kacpid_wq);
991         flush_workqueue(kacpi_notify_wq);
992 }
993
994 EXPORT_SYMBOL(acpi_os_wait_events_complete);
995
996 acpi_status
997 acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
998 {
999         struct semaphore *sem = NULL;
1000
1001         sem = acpi_os_allocate(sizeof(struct semaphore));
1002         if (!sem)
1003                 return AE_NO_MEMORY;
1004         memset(sem, 0, sizeof(struct semaphore));
1005
1006         sema_init(sem, initial_units);
1007
1008         *handle = (acpi_handle *) sem;
1009
1010         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
1011                           *handle, initial_units));
1012
1013         return AE_OK;
1014 }
1015
1016 /*
1017  * TODO: A better way to delete semaphores?  Linux doesn't have a
1018  * 'delete_semaphore()' function -- may result in an invalid
1019  * pointer dereference for non-synchronized consumers.  Should
1020  * we at least check for blocked threads and signal/cancel them?
1021  */
1022
1023 acpi_status acpi_os_delete_semaphore(acpi_handle handle)
1024 {
1025         struct semaphore *sem = (struct semaphore *)handle;
1026
1027         if (!sem)
1028                 return AE_BAD_PARAMETER;
1029
1030         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
1031
1032         BUG_ON(!list_empty(&sem->wait_list));
1033         kfree(sem);
1034         sem = NULL;
1035
1036         return AE_OK;
1037 }
1038
1039 /*
1040  * TODO: Support for units > 1?
1041  */
1042 acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
1043 {
1044         acpi_status status = AE_OK;
1045         struct semaphore *sem = (struct semaphore *)handle;
1046         long jiffies;
1047         int ret = 0;
1048
1049         if (!sem || (units < 1))
1050                 return AE_BAD_PARAMETER;
1051
1052         if (units > 1)
1053                 return AE_SUPPORT;
1054
1055         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
1056                           handle, units, timeout));
1057
1058         if (timeout == ACPI_WAIT_FOREVER)
1059                 jiffies = MAX_SCHEDULE_TIMEOUT;
1060         else
1061                 jiffies = msecs_to_jiffies(timeout);
1062         
1063         ret = down_timeout(sem, jiffies);
1064         if (ret)
1065                 status = AE_TIME;
1066
1067         if (ACPI_FAILURE(status)) {
1068                 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
1069                                   "Failed to acquire semaphore[%p|%d|%d], %s",
1070                                   handle, units, timeout,
1071                                   acpi_format_exception(status)));
1072         } else {
1073                 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
1074                                   "Acquired semaphore[%p|%d|%d]", handle,
1075                                   units, timeout));
1076         }
1077
1078         return status;
1079 }
1080
1081 /*
1082  * TODO: Support for units > 1?
1083  */
1084 acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
1085 {
1086         struct semaphore *sem = (struct semaphore *)handle;
1087
1088         if (!sem || (units < 1))
1089                 return AE_BAD_PARAMETER;
1090
1091         if (units > 1)
1092                 return AE_SUPPORT;
1093
1094         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
1095                           units));
1096
1097         up(sem);
1098
1099         return AE_OK;
1100 }
1101
1102 #ifdef ACPI_FUTURE_USAGE
1103 u32 acpi_os_get_line(char *buffer)
1104 {
1105
1106 #ifdef ENABLE_DEBUGGER
1107         if (acpi_in_debugger) {
1108                 u32 chars;
1109
1110                 kdb_read(buffer, sizeof(line_buf));
1111
1112                 /* remove the CR kdb includes */
1113                 chars = strlen(buffer) - 1;
1114                 buffer[chars] = '\0';
1115         }
1116 #endif
1117
1118         return 0;
1119 }
1120 #endif                          /*  ACPI_FUTURE_USAGE  */
1121
1122 acpi_status acpi_os_signal(u32 function, void *info)
1123 {
1124         switch (function) {
1125         case ACPI_SIGNAL_FATAL:
1126                 printk(KERN_ERR PREFIX "Fatal opcode executed\n");
1127                 break;
1128         case ACPI_SIGNAL_BREAKPOINT:
1129                 /*
1130                  * AML Breakpoint
1131                  * ACPI spec. says to treat it as a NOP unless
1132                  * you are debugging.  So if/when we integrate
1133                  * AML debugger into the kernel debugger its
1134                  * hook will go here.  But until then it is
1135                  * not useful to print anything on breakpoints.
1136                  */
1137                 break;
1138         default:
1139                 break;
1140         }
1141
1142         return AE_OK;
1143 }
1144
1145 static int __init acpi_os_name_setup(char *str)
1146 {
1147         char *p = acpi_os_name;
1148         int count = ACPI_MAX_OVERRIDE_LEN - 1;
1149
1150         if (!str || !*str)
1151                 return 0;
1152
1153         for (; count-- && str && *str; str++) {
1154                 if (isalnum(*str) || *str == ' ' || *str == ':')
1155                         *p++ = *str;
1156                 else if (*str == '\'' || *str == '"')
1157                         continue;
1158                 else
1159                         break;
1160         }
1161         *p = 0;
1162
1163         return 1;
1164
1165 }
1166
1167 __setup("acpi_os_name=", acpi_os_name_setup);
1168
1169 #define OSI_STRING_LENGTH_MAX 64        /* arbitrary */
1170 #define OSI_STRING_ENTRIES_MAX 16       /* arbitrary */
1171
1172 struct osi_setup_entry {
1173         char string[OSI_STRING_LENGTH_MAX];
1174         bool enable;
1175 };
1176
1177 static struct osi_setup_entry __initdata
1178                 osi_setup_entries[OSI_STRING_ENTRIES_MAX] = {
1179         {"Module Device", true},
1180         {"Processor Device", true},
1181         {"3.0 _SCP Extensions", true},
1182         {"Processor Aggregator Device", true},
1183 };
1184
1185 void __init acpi_osi_setup(char *str)
1186 {
1187         struct osi_setup_entry *osi;
1188         bool enable = true;
1189         int i;
1190
1191         if (!acpi_gbl_create_osi_method)
1192                 return;
1193
1194         if (str == NULL || *str == '\0') {
1195                 printk(KERN_INFO PREFIX "_OSI method disabled\n");
1196                 acpi_gbl_create_osi_method = FALSE;
1197                 return;
1198         }
1199
1200         if (*str == '!') {
1201                 str++;
1202                 enable = false;
1203         }
1204
1205         for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1206                 osi = &osi_setup_entries[i];
1207                 if (!strcmp(osi->string, str)) {
1208                         osi->enable = enable;
1209                         break;
1210                 } else if (osi->string[0] == '\0') {
1211                         osi->enable = enable;
1212                         strncpy(osi->string, str, OSI_STRING_LENGTH_MAX);
1213                         break;
1214                 }
1215         }
1216 }
1217
1218 static void __init set_osi_linux(unsigned int enable)
1219 {
1220         if (osi_linux.enable != enable)
1221                 osi_linux.enable = enable;
1222
1223         if (osi_linux.enable)
1224                 acpi_osi_setup("Linux");
1225         else
1226                 acpi_osi_setup("!Linux");
1227
1228         return;
1229 }
1230
1231 static void __init acpi_cmdline_osi_linux(unsigned int enable)
1232 {
1233         osi_linux.cmdline = 1;  /* cmdline set the default and override DMI */
1234         osi_linux.dmi = 0;
1235         set_osi_linux(enable);
1236
1237         return;
1238 }
1239
1240 void __init acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d)
1241 {
1242         printk(KERN_NOTICE PREFIX "DMI detected: %s\n", d->ident);
1243
1244         if (enable == -1)
1245                 return;
1246
1247         osi_linux.dmi = 1;      /* DMI knows that this box asks OSI(Linux) */
1248         set_osi_linux(enable);
1249
1250         return;
1251 }
1252
1253 /*
1254  * Modify the list of "OS Interfaces" reported to BIOS via _OSI
1255  *
1256  * empty string disables _OSI
1257  * string starting with '!' disables that string
1258  * otherwise string is added to list, augmenting built-in strings
1259  */
1260 static void __init acpi_osi_setup_late(void)
1261 {
1262         struct osi_setup_entry *osi;
1263         char *str;
1264         int i;
1265         acpi_status status;
1266
1267         for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1268                 osi = &osi_setup_entries[i];
1269                 str = osi->string;
1270
1271                 if (*str == '\0')
1272                         break;
1273                 if (osi->enable) {
1274                         status = acpi_install_interface(str);
1275
1276                         if (ACPI_SUCCESS(status))
1277                                 printk(KERN_INFO PREFIX "Added _OSI(%s)\n", str);
1278                 } else {
1279                         status = acpi_remove_interface(str);
1280
1281                         if (ACPI_SUCCESS(status))
1282                                 printk(KERN_INFO PREFIX "Deleted _OSI(%s)\n", str);
1283                 }
1284         }
1285 }
1286
1287 static int __init osi_setup(char *str)
1288 {
1289         if (str && !strcmp("Linux", str))
1290                 acpi_cmdline_osi_linux(1);
1291         else if (str && !strcmp("!Linux", str))
1292                 acpi_cmdline_osi_linux(0);
1293         else
1294                 acpi_osi_setup(str);
1295
1296         return 1;
1297 }
1298
1299 __setup("acpi_osi=", osi_setup);
1300
1301 /* enable serialization to combat AE_ALREADY_EXISTS errors */
1302 static int __init acpi_serialize_setup(char *str)
1303 {
1304         printk(KERN_INFO PREFIX "serialize enabled\n");
1305
1306         acpi_gbl_all_methods_serialized = TRUE;
1307
1308         return 1;
1309 }
1310
1311 __setup("acpi_serialize", acpi_serialize_setup);
1312
1313 /* Check of resource interference between native drivers and ACPI
1314  * OperationRegions (SystemIO and System Memory only).
1315  * IO ports and memory declared in ACPI might be used by the ACPI subsystem
1316  * in arbitrary AML code and can interfere with legacy drivers.
1317  * acpi_enforce_resources= can be set to:
1318  *
1319  *   - strict (default) (2)
1320  *     -> further driver trying to access the resources will not load
1321  *   - lax              (1)
1322  *     -> further driver trying to access the resources will load, but you
1323  *     get a system message that something might go wrong...
1324  *
1325  *   - no               (0)
1326  *     -> ACPI Operation Region resources will not be registered
1327  *
1328  */
1329 #define ENFORCE_RESOURCES_STRICT 2
1330 #define ENFORCE_RESOURCES_LAX    1
1331 #define ENFORCE_RESOURCES_NO     0
1332
1333 static unsigned int acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1334
1335 static int __init acpi_enforce_resources_setup(char *str)
1336 {
1337         if (str == NULL || *str == '\0')
1338                 return 0;
1339
1340         if (!strcmp("strict", str))
1341                 acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1342         else if (!strcmp("lax", str))
1343                 acpi_enforce_resources = ENFORCE_RESOURCES_LAX;
1344         else if (!strcmp("no", str))
1345                 acpi_enforce_resources = ENFORCE_RESOURCES_NO;
1346
1347         return 1;
1348 }
1349
1350 __setup("acpi_enforce_resources=", acpi_enforce_resources_setup);
1351
1352 /* Check for resource conflicts between ACPI OperationRegions and native
1353  * drivers */
1354 int acpi_check_resource_conflict(const struct resource *res)
1355 {
1356         acpi_adr_space_type space_id;
1357         acpi_size length;
1358         u8 warn = 0;
1359         int clash = 0;
1360
1361         if (acpi_enforce_resources == ENFORCE_RESOURCES_NO)
1362                 return 0;
1363         if (!(res->flags & IORESOURCE_IO) && !(res->flags & IORESOURCE_MEM))
1364                 return 0;
1365
1366         if (res->flags & IORESOURCE_IO)
1367                 space_id = ACPI_ADR_SPACE_SYSTEM_IO;
1368         else
1369                 space_id = ACPI_ADR_SPACE_SYSTEM_MEMORY;
1370
1371         length = res->end - res->start + 1;
1372         if (acpi_enforce_resources != ENFORCE_RESOURCES_NO)
1373                 warn = 1;
1374         clash = acpi_check_address_range(space_id, res->start, length, warn);
1375
1376         if (clash) {
1377                 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO) {
1378                         if (acpi_enforce_resources == ENFORCE_RESOURCES_LAX)
1379                                 printk(KERN_NOTICE "ACPI: This conflict may"
1380                                        " cause random problems and system"
1381                                        " instability\n");
1382                         printk(KERN_INFO "ACPI: If an ACPI driver is available"
1383                                " for this device, you should use it instead of"
1384                                " the native driver\n");
1385                 }
1386                 if (acpi_enforce_resources == ENFORCE_RESOURCES_STRICT)
1387                         return -EBUSY;
1388         }
1389         return 0;
1390 }
1391 EXPORT_SYMBOL(acpi_check_resource_conflict);
1392
1393 int acpi_check_region(resource_size_t start, resource_size_t n,
1394                       const char *name)
1395 {
1396         struct resource res = {
1397                 .start = start,
1398                 .end   = start + n - 1,
1399                 .name  = name,
1400                 .flags = IORESOURCE_IO,
1401         };
1402
1403         return acpi_check_resource_conflict(&res);
1404 }
1405 EXPORT_SYMBOL(acpi_check_region);
1406
1407 /*
1408  * Let drivers know whether the resource checks are effective
1409  */
1410 int acpi_resources_are_enforced(void)
1411 {
1412         return acpi_enforce_resources == ENFORCE_RESOURCES_STRICT;
1413 }
1414 EXPORT_SYMBOL(acpi_resources_are_enforced);
1415
1416 /*
1417  * Deallocate the memory for a spinlock.
1418  */
1419 void acpi_os_delete_lock(acpi_spinlock handle)
1420 {
1421         ACPI_FREE(handle);
1422 }
1423
1424 /*
1425  * Acquire a spinlock.
1426  *
1427  * handle is a pointer to the spinlock_t.
1428  */
1429
1430 acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp)
1431 {
1432         acpi_cpu_flags flags;
1433         spin_lock_irqsave(lockp, flags);
1434         return flags;
1435 }
1436
1437 /*
1438  * Release a spinlock. See above.
1439  */
1440
1441 void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
1442 {
1443         spin_unlock_irqrestore(lockp, flags);
1444 }
1445
1446 #ifndef ACPI_USE_LOCAL_CACHE
1447
1448 /*******************************************************************************
1449  *
1450  * FUNCTION:    acpi_os_create_cache
1451  *
1452  * PARAMETERS:  name      - Ascii name for the cache
1453  *              size      - Size of each cached object
1454  *              depth     - Maximum depth of the cache (in objects) <ignored>
1455  *              cache     - Where the new cache object is returned
1456  *
1457  * RETURN:      status
1458  *
1459  * DESCRIPTION: Create a cache object
1460  *
1461  ******************************************************************************/
1462
1463 acpi_status
1464 acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
1465 {
1466         *cache = kmem_cache_create(name, size, 0, 0, NULL);
1467         if (*cache == NULL)
1468                 return AE_ERROR;
1469         else
1470                 return AE_OK;
1471 }
1472
1473 /*******************************************************************************
1474  *
1475  * FUNCTION:    acpi_os_purge_cache
1476  *
1477  * PARAMETERS:  Cache           - Handle to cache object
1478  *
1479  * RETURN:      Status
1480  *
1481  * DESCRIPTION: Free all objects within the requested cache.
1482  *
1483  ******************************************************************************/
1484
1485 acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
1486 {
1487         kmem_cache_shrink(cache);
1488         return (AE_OK);
1489 }
1490
1491 /*******************************************************************************
1492  *
1493  * FUNCTION:    acpi_os_delete_cache
1494  *
1495  * PARAMETERS:  Cache           - Handle to cache object
1496  *
1497  * RETURN:      Status
1498  *
1499  * DESCRIPTION: Free all objects within the requested cache and delete the
1500  *              cache object.
1501  *
1502  ******************************************************************************/
1503
1504 acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
1505 {
1506         kmem_cache_destroy(cache);
1507         return (AE_OK);
1508 }
1509
1510 /*******************************************************************************
1511  *
1512  * FUNCTION:    acpi_os_release_object
1513  *
1514  * PARAMETERS:  Cache       - Handle to cache object
1515  *              Object      - The object to be released
1516  *
1517  * RETURN:      None
1518  *
1519  * DESCRIPTION: Release an object to the specified cache.  If cache is full,
1520  *              the object is deleted.
1521  *
1522  ******************************************************************************/
1523
1524 acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
1525 {
1526         kmem_cache_free(cache, object);
1527         return (AE_OK);
1528 }
1529 #endif
1530
1531 acpi_status __init acpi_os_initialize(void)
1532 {
1533         acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1534         acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1535         acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe0_block);
1536         acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe1_block);
1537
1538         return AE_OK;
1539 }
1540
1541 acpi_status __init acpi_os_initialize1(void)
1542 {
1543         kacpid_wq = alloc_workqueue("kacpid", 0, 1);
1544         kacpi_notify_wq = alloc_workqueue("kacpi_notify", 0, 1);
1545         kacpi_hotplug_wq = alloc_workqueue("kacpi_hotplug", 0, 1);
1546         BUG_ON(!kacpid_wq);
1547         BUG_ON(!kacpi_notify_wq);
1548         BUG_ON(!kacpi_hotplug_wq);
1549         acpi_install_interface_handler(acpi_osi_handler);
1550         acpi_osi_setup_late();
1551         return AE_OK;
1552 }
1553
1554 acpi_status acpi_os_terminate(void)
1555 {
1556         if (acpi_irq_handler) {
1557                 acpi_os_remove_interrupt_handler(acpi_gbl_FADT.sci_interrupt,
1558                                                  acpi_irq_handler);
1559         }
1560
1561         acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe1_block);
1562         acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe0_block);
1563         acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1564         acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1565
1566         destroy_workqueue(kacpid_wq);
1567         destroy_workqueue(kacpi_notify_wq);
1568         destroy_workqueue(kacpi_hotplug_wq);
1569
1570         return AE_OK;
1571 }