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