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