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