drivers/acpi/osl.c

   1 /*
   2  *  acpi_osl.c - OS-dependent functions ($Revision: 83 $)
   3  *
   4  *  Copyright (C) 2000       Andrew Henroid
   5  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
   6  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
   7  *  Copyright (c) 2008 Intel Corporation
   8  *   Author: Matthew Wilcox <willy@linux.intel.com>
   9  *
  10  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, write to the Free Software
  24  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25  *
  26  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  27  *
  28  */
  29
  30 #include <linux/module.h>
  31 #include <linux/kernel.h>
  32 #include <linux/slab.h>
  33 #include <linux/mm.h>
  34 #include <linux/highmem.h>
  35 #include <linux/pci.h>
  36 #include <linux/interrupt.h>
  37 #include <linux/kmod.h>
  38 #include <linux/delay.h>
  39 #include <linux/workqueue.h>
  40 #include <linux/nmi.h>
  41 #include <linux/acpi.h>
  42 #include <linux/efi.h>
  43 #include <linux/ioport.h>
  44 #include <linux/list.h>
  45 #include <linux/jiffies.h>
  46 #include <linux/semaphore.h>
  47
  48 #include <asm/io.h>
  49 #include <asm/uaccess.h>
  50
  51 #include "internal.h"
  52
  53 #define _COMPONENT              ACPI_OS_SERVICES
  54 ACPI_MODULE_NAME("osl");
  55
  56 struct acpi_os_dpc {
  57         acpi_osd_exec_callback function;
  58         void *context;
  59         struct work_struct work;
  60 };
  61
  62 #ifdef CONFIG_ACPI_CUSTOM_DSDT
  63 #include CONFIG_ACPI_CUSTOM_DSDT_FILE
  64 #endif
  65
  66 #ifdef ENABLE_DEBUGGER
  67 #include <linux/kdb.h>
  68
  69 /* stuff for debugger support */
  70 int acpi_in_debugger;
  71 EXPORT_SYMBOL(acpi_in_debugger);
  72
  73 extern char line_buf[80];
  74 #endif                          /*ENABLE_DEBUGGER */
  75
  76 static int (*__acpi_os_prepare_sleep)(u8 sleep_state, u32 pm1a_ctrl,
  77                                       u32 pm1b_ctrl);
  78 static int (*__acpi_os_prepare_extended_sleep)(u8 sleep_state, u32 val_a,
  79                                       u32 val_b);
  80
  81 static acpi_osd_handler acpi_irq_handler;
  82 static void *acpi_irq_context;
  83 static struct workqueue_struct *kacpid_wq;
  84 static struct workqueue_struct *kacpi_notify_wq;
  85 static struct workqueue_struct *kacpi_hotplug_wq;
  86
  87 /*
  88  * This list of permanent mappings is for memory that may be accessed from
  89  * interrupt context, where we can't do the ioremap().
  90  */
  91 struct acpi_ioremap {
  92         struct list_head list;
  93         void __iomem *virt;
  94         acpi_physical_address phys;
  95         acpi_size size;
  96         unsigned long refcount;
  97 };
  98
  99 static LIST_HEAD(acpi_ioremaps);
 100 static DEFINE_MUTEX(acpi_ioremap_lock);
 101
 102 static void __init acpi_osi_setup_late(void);
 103
 104 /*
 105  * The story of _OSI(Linux)
 106  *
 107  * From pre-history through Linux-2.6.22,
 108  * Linux responded TRUE upon a BIOS OSI(Linux) query.
 109  *
 110  * Unfortunately, reference BIOS writers got wind of this
 111  * and put OSI(Linux) in their example code, quickly exposing
 112  * this string as ill-conceived and opening the door to
 113  * an un-bounded number of BIOS incompatibilities.
 114  *
 115  * For example, OSI(Linux) was used on resume to re-POST a
 116  * video card on one system, because Linux at that time
 117  * could not do a speedy restore in its native driver.
 118  * But then upon gaining quick native restore capability,
 119  * Linux has no way to tell the BIOS to skip the time-consuming
 120  * POST -- putting Linux at a permanent performance disadvantage.
 121  * On another system, the BIOS writer used OSI(Linux)
 122  * to infer native OS support for IPMI!  On other systems,
 123  * OSI(Linux) simply got in the way of Linux claiming to
 124  * be compatible with other operating systems, exposing
 125  * BIOS issues such as skipped device initialization.
 126  *
 127  * So "Linux" turned out to be a really poor chose of
 128  * OSI string, and from Linux-2.6.23 onward we respond FALSE.
 129  *
 130  * BIOS writers should NOT query _OSI(Linux) on future systems.
 131  * Linux will complain on the console when it sees it, and return FALSE.
 132  * To get Linux to return TRUE for your system  will require
 133  * a kernel source update to add a DMI entry,
 134  * or boot with "acpi_osi=Linux"
 135  */
 136
 137 static struct osi_linux {
 138         unsigned int    enable:1;
 139         unsigned int    dmi:1;
 140         unsigned int    cmdline:1;
 141         unsigned int    default_disabling:1;
 142 } osi_linux = {0, 0, 0, 0};
 143
 144 static u32 acpi_osi_handler(acpi_string interface, u32 supported)
 145 {
 146         if (!strcmp("Linux", interface)) {
 147
 148                 printk_once(KERN_NOTICE FW_BUG PREFIX
 149                         "BIOS _OSI(Linux) query %s%s\n",
 150                         osi_linux.enable ? "honored" : "ignored",
 151                         osi_linux.cmdline ? " via cmdline" :
 152                         osi_linux.dmi ? " via DMI" : "");
 153         }
 154
 155         return supported;
 156 }
 157
 158 static void __init acpi_request_region (struct acpi_generic_address *gas,
 159         unsigned int length, char *desc)
 160 {
 161         u64 addr;
 162
 163         /* Handle possible alignment issues */
 164         memcpy(&addr, &gas->address, sizeof(addr));
 165         if (!addr || !length)
 166                 return;
 167
 168         /* Resources are never freed */
 169         if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO)
 170                 request_region(addr, length, desc);
 171         else if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
 172                 request_mem_region(addr, length, desc);
 173 }
 174
 175 static int __init acpi_reserve_resources(void)
 176 {
 177         acpi_request_region(&acpi_gbl_FADT.xpm1a_event_block, acpi_gbl_FADT.pm1_event_length,
 178                 "ACPI PM1a_EVT_BLK");
 179
 180         acpi_request_region(&acpi_gbl_FADT.xpm1b_event_block, acpi_gbl_FADT.pm1_event_length,
 181                 "ACPI PM1b_EVT_BLK");
 182
 183         acpi_request_region(&acpi_gbl_FADT.xpm1a_control_block, acpi_gbl_FADT.pm1_control_length,
 184                 "ACPI PM1a_CNT_BLK");
 185
 186         acpi_request_region(&acpi_gbl_FADT.xpm1b_control_block, acpi_gbl_FADT.pm1_control_length,
 187                 "ACPI PM1b_CNT_BLK");
 188
 189         if (acpi_gbl_FADT.pm_timer_length == 4)
 190                 acpi_request_region(&acpi_gbl_FADT.xpm_timer_block, 4, "ACPI PM_TMR");
 191
 192         acpi_request_region(&acpi_gbl_FADT.xpm2_control_block, acpi_gbl_FADT.pm2_control_length,
 193                 "ACPI PM2_CNT_BLK");
 194
 195         /* Length of GPE blocks must be a non-negative multiple of 2 */
 196
 197         if (!(acpi_gbl_FADT.gpe0_block_length & 0x1))
 198                 acpi_request_region(&acpi_gbl_FADT.xgpe0_block,
 199                                acpi_gbl_FADT.gpe0_block_length, "ACPI GPE0_BLK");
 200
 201         if (!(acpi_gbl_FADT.gpe1_block_length & 0x1))
 202                 acpi_request_region(&acpi_gbl_FADT.xgpe1_block,
 203                                acpi_gbl_FADT.gpe1_block_length, "ACPI GPE1_BLK");
 204
 205         return 0;
 206 }
 207 device_initcall(acpi_reserve_resources);
 208
 209 void acpi_os_printf(const char *fmt, ...)
 210 {
 211         va_list args;
 212         va_start(args, fmt);
 213         acpi_os_vprintf(fmt, args);
 214         va_end(args);
 215 }
 216
 217 void acpi_os_vprintf(const char *fmt, va_list args)
 218 {
 219         static char buffer[512];
 220
 221         vsprintf(buffer, fmt, args);
 222
 223 #ifdef ENABLE_DEBUGGER
 224         if (acpi_in_debugger) {
 225                 kdb_printf("%s", buffer);
 226         } else {
 227                 printk(KERN_CONT "%s", buffer);
 228         }
 229 #else
 230         printk(KERN_CONT "%s", buffer);
 231 #endif
 232 }
 233
 234 #ifdef CONFIG_KEXEC
 235 static unsigned long acpi_rsdp;
 236 static int __init setup_acpi_rsdp(char *arg)
 237 {
 238         if (kstrtoul(arg, 16, &acpi_rsdp))
 239                 return -EINVAL;
 240         return 0;
 241 }
 242 early_param("acpi_rsdp", setup_acpi_rsdp);
 243 #endif
 244
 245 acpi_physical_address __init acpi_os_get_root_pointer(void)
 246 {
 247 #ifdef CONFIG_KEXEC
 248         if (acpi_rsdp)
 249                 return acpi_rsdp;
 250 #endif
 251
 252         if (efi_enabled(EFI_CONFIG_TABLES)) {
 253                 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
 254                         return efi.acpi20;
 255                 else if (efi.acpi != EFI_INVALID_TABLE_ADDR)
 256                         return efi.acpi;
 257                 else {
 258                         printk(KERN_ERR PREFIX
 259                                "System description tables not found\n");
 260                         return 0;
 261                 }
 262         } else {
 263                 acpi_physical_address pa = 0;
 264
 265                 acpi_find_root_pointer(&pa);
 266                 return pa;
 267         }
 268 }
 269
 270 /* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
 271 static struct acpi_ioremap *
 272 acpi_map_lookup(acpi_physical_address phys, acpi_size size)
 273 {
 274         struct acpi_ioremap *map;
 275
 276         list_for_each_entry_rcu(map, &acpi_ioremaps, list)
 277                 if (map->phys <= phys &&
 278                     phys + size <= map->phys + map->size)
 279                         return map;
 280
 281         return NULL;
 282 }
 283
 284 /* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
 285 static void __iomem *
 286 acpi_map_vaddr_lookup(acpi_physical_address phys, unsigned int size)
 287 {
 288         struct acpi_ioremap *map;
 289
 290         map = acpi_map_lookup(phys, size);
 291         if (map)
 292                 return map->virt + (phys - map->phys);
 293
 294         return NULL;
 295 }
 296
 297 void __iomem *acpi_os_get_iomem(acpi_physical_address phys, unsigned int size)
 298 {
 299         struct acpi_ioremap *map;
 300         void __iomem *virt = NULL;
 301
 302         mutex_lock(&acpi_ioremap_lock);
 303         map = acpi_map_lookup(phys, size);
 304         if (map) {
 305                 virt = map->virt + (phys - map->phys);
 306                 map->refcount++;
 307         }
 308         mutex_unlock(&acpi_ioremap_lock);
 309         return virt;
 310 }
 311 EXPORT_SYMBOL_GPL(acpi_os_get_iomem);
 312
 313 /* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
 314 static struct acpi_ioremap *
 315 acpi_map_lookup_virt(void __iomem *virt, acpi_size size)
 316 {
 317         struct acpi_ioremap *map;
 318
 319         list_for_each_entry_rcu(map, &acpi_ioremaps, list)
 320                 if (map->virt <= virt &&
 321                     virt + size <= map->virt + map->size)
 322                         return map;
 323
 324         return NULL;
 325 }
 326
 327 #ifndef CONFIG_IA64
 328 #define should_use_kmap(pfn)   page_is_ram(pfn)
 329 #else
 330 /* ioremap will take care of cache attributes */
 331 #define should_use_kmap(pfn)   0
 332 #endif
 333
 334 static void __iomem *acpi_map(acpi_physical_address pg_off, unsigned long pg_sz)
 335 {
 336         unsigned long pfn;
 337
 338         pfn = pg_off >> PAGE_SHIFT;
 339         if (should_use_kmap(pfn)) {
 340                 if (pg_sz > PAGE_SIZE)
 341                         return NULL;
 342                 return (void __iomem __force *)kmap(pfn_to_page(pfn));
 343         } else
 344                 return acpi_os_ioremap(pg_off, pg_sz);
 345 }
 346
 347 static void acpi_unmap(acpi_physical_address pg_off, void __iomem *vaddr)
 348 {
 349         unsigned long pfn;
 350
 351         pfn = pg_off >> PAGE_SHIFT;
 352         if (should_use_kmap(pfn))
 353                 kunmap(pfn_to_page(pfn));
 354         else
 355                 iounmap(vaddr);
 356 }
 357
 358 void __iomem *__init_refok
 359 acpi_os_map_iomem(acpi_physical_address phys, acpi_size size)
 360 {
 361         struct acpi_ioremap *map;
 362         void __iomem *virt;
 363         acpi_physical_address pg_off;
 364         acpi_size pg_sz;
 365
 366         if (phys > ULONG_MAX) {
 367                 printk(KERN_ERR PREFIX "Cannot map memory that high\n");
 368                 return NULL;
 369         }
 370
 371         if (!acpi_gbl_permanent_mmap)
 372                 return __acpi_map_table((unsigned long)phys, size);
 373
 374         mutex_lock(&acpi_ioremap_lock);
 375         /* Check if there's a suitable mapping already. */
 376         map = acpi_map_lookup(phys, size);
 377         if (map) {
 378                 map->refcount++;
 379                 goto out;
 380         }
 381
 382         map = kzalloc(sizeof(*map), GFP_KERNEL);
 383         if (!map) {
 384                 mutex_unlock(&acpi_ioremap_lock);
 385                 return NULL;
 386         }
 387
 388         pg_off = round_down(phys, PAGE_SIZE);
 389         pg_sz = round_up(phys + size, PAGE_SIZE) - pg_off;
 390         virt = acpi_map(pg_off, pg_sz);
 391         if (!virt) {
 392                 mutex_unlock(&acpi_ioremap_lock);
 393                 kfree(map);
 394                 return NULL;
 395         }
 396
 397         INIT_LIST_HEAD(&map->list);
 398         map->virt = virt;
 399         map->phys = pg_off;
 400         map->size = pg_sz;
 401         map->refcount = 1;
 402
 403         list_add_tail_rcu(&map->list, &acpi_ioremaps);
 404
 405 out:
 406         mutex_unlock(&acpi_ioremap_lock);
 407         return map->virt + (phys - map->phys);
 408 }
 409 EXPORT_SYMBOL_GPL(acpi_os_map_iomem);
 410
 411 void *__init_refok
 412 acpi_os_map_memory(acpi_physical_address phys, acpi_size size)
 413 {
 414         return (void *)acpi_os_map_iomem(phys, size);
 415 }
 416 EXPORT_SYMBOL_GPL(acpi_os_map_memory);
 417
 418 static void acpi_os_drop_map_ref(struct acpi_ioremap *map)
 419 {
 420         if (!--map->refcount)
 421                 list_del_rcu(&map->list);
 422 }
 423
 424 static void acpi_os_map_cleanup(struct acpi_ioremap *map)
 425 {
 426         if (!map->refcount) {
 427                 synchronize_rcu();
 428                 acpi_unmap(map->phys, map->virt);
 429                 kfree(map);
 430         }
 431 }
 432
 433 void __ref acpi_os_unmap_iomem(void __iomem *virt, acpi_size size)
 434 {
 435         struct acpi_ioremap *map;
 436
 437         if (!acpi_gbl_permanent_mmap) {
 438                 __acpi_unmap_table(virt, size);
 439                 return;
 440         }
 441
 442         mutex_lock(&acpi_ioremap_lock);
 443         map = acpi_map_lookup_virt(virt, size);
 444         if (!map) {
 445                 mutex_unlock(&acpi_ioremap_lock);
 446                 WARN(true, PREFIX "%s: bad address %p\n", __func__, virt);
 447                 return;
 448         }
 449         acpi_os_drop_map_ref(map);
 450         mutex_unlock(&acpi_ioremap_lock);
 451
 452         acpi_os_map_cleanup(map);
 453 }
 454 EXPORT_SYMBOL_GPL(acpi_os_unmap_iomem);
 455
 456 void __ref acpi_os_unmap_memory(void *virt, acpi_size size)
 457 {
 458         return acpi_os_unmap_iomem((void __iomem *)virt, size);
 459 }
 460 EXPORT_SYMBOL_GPL(acpi_os_unmap_memory);
 461
 462 void __init early_acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
 463 {
 464         if (!acpi_gbl_permanent_mmap)
 465                 __acpi_unmap_table(virt, size);
 466 }
 467
 468 int acpi_os_map_generic_address(struct acpi_generic_address *gas)
 469 {
 470         u64 addr;
 471         void __iomem *virt;
 472
 473         if (gas->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
 474                 return 0;
 475
 476         /* Handle possible alignment issues */
 477         memcpy(&addr, &gas->address, sizeof(addr));
 478         if (!addr || !gas->bit_width)
 479                 return -EINVAL;
 480
 481         virt = acpi_os_map_iomem(addr, gas->bit_width / 8);
 482         if (!virt)
 483                 return -EIO;
 484
 485         return 0;
 486 }
 487 EXPORT_SYMBOL(acpi_os_map_generic_address);
 488
 489 void acpi_os_unmap_generic_address(struct acpi_generic_address *gas)
 490 {
 491         u64 addr;
 492         struct acpi_ioremap *map;
 493
 494         if (gas->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
 495                 return;
 496
 497         /* Handle possible alignment issues */
 498         memcpy(&addr, &gas->address, sizeof(addr));
 499         if (!addr || !gas->bit_width)
 500                 return;
 501
 502         mutex_lock(&acpi_ioremap_lock);
 503         map = acpi_map_lookup(addr, gas->bit_width / 8);
 504         if (!map) {
 505                 mutex_unlock(&acpi_ioremap_lock);
 506                 return;
 507         }
 508         acpi_os_drop_map_ref(map);
 509         mutex_unlock(&acpi_ioremap_lock);
 510
 511         acpi_os_map_cleanup(map);
 512 }
 513 EXPORT_SYMBOL(acpi_os_unmap_generic_address);
 514
 515 #ifdef ACPI_FUTURE_USAGE
 516 acpi_status
 517 acpi_os_get_physical_address(void *virt, acpi_physical_address * phys)
 518 {
 519         if (!phys || !virt)
 520                 return AE_BAD_PARAMETER;
 521
 522         *phys = virt_to_phys(virt);
 523
 524         return AE_OK;
 525 }
 526 #endif
 527
 528 #define ACPI_MAX_OVERRIDE_LEN 100
 529
 530 static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN];
 531
 532 acpi_status
 533 acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
 534                             acpi_string * new_val)
 535 {
 536         if (!init_val || !new_val)
 537                 return AE_BAD_PARAMETER;
 538
 539         *new_val = NULL;
 540         if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {
 541                 printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n",
 542                        acpi_os_name);
 543                 *new_val = acpi_os_name;
 544         }
 545
 546         return AE_OK;
 547 }
 548
 549 #ifdef CONFIG_ACPI_INITRD_TABLE_OVERRIDE
 550 #include <linux/earlycpio.h>
 551 #include <linux/memblock.h>
 552
 553 static u64 acpi_tables_addr;
 554 static int all_tables_size;
 555
 556 /* Copied from acpica/tbutils.c:acpi_tb_checksum() */
 557 static u8 __init acpi_table_checksum(u8 *buffer, u32 length)
 558 {
 559         u8 sum = 0;
 560         u8 *end = buffer + length;
 561
 562         while (buffer < end)
 563                 sum = (u8) (sum + *(buffer++));
 564         return sum;
 565 }
 566
 567 /* All but ACPI_SIG_RSDP and ACPI_SIG_FACS: */
 568 static const char * const table_sigs[] = {
 569         ACPI_SIG_BERT, ACPI_SIG_CPEP, ACPI_SIG_ECDT, ACPI_SIG_EINJ,
 570         ACPI_SIG_ERST, ACPI_SIG_HEST, ACPI_SIG_MADT, ACPI_SIG_MSCT,
 571         ACPI_SIG_SBST, ACPI_SIG_SLIT, ACPI_SIG_SRAT, ACPI_SIG_ASF,
 572         ACPI_SIG_BOOT, ACPI_SIG_DBGP, ACPI_SIG_DMAR, ACPI_SIG_HPET,
 573         ACPI_SIG_IBFT, ACPI_SIG_IVRS, ACPI_SIG_MCFG, ACPI_SIG_MCHI,
 574         ACPI_SIG_SLIC, ACPI_SIG_SPCR, ACPI_SIG_SPMI, ACPI_SIG_TCPA,
 575         ACPI_SIG_UEFI, ACPI_SIG_WAET, ACPI_SIG_WDAT, ACPI_SIG_WDDT,
 576         ACPI_SIG_WDRT, ACPI_SIG_DSDT, ACPI_SIG_FADT, ACPI_SIG_PSDT,
 577         ACPI_SIG_RSDT, ACPI_SIG_XSDT, ACPI_SIG_SSDT, NULL };
 578
 579 #define ACPI_HEADER_SIZE sizeof(struct acpi_table_header)
 580
 581 #define ACPI_OVERRIDE_TABLES 64
 582 static struct cpio_data __initdata acpi_initrd_files[ACPI_OVERRIDE_TABLES];
 583
 584 #define MAP_CHUNK_SIZE   (NR_FIX_BTMAPS << PAGE_SHIFT)
 585
 586 void __init acpi_initrd_override(void *data, size_t size)
 587 {
 588         int sig, no, table_nr = 0, total_offset = 0;
 589         long offset = 0;
 590         struct acpi_table_header *table;
 591         char cpio_path[32] = "kernel/firmware/acpi/";
 592         struct cpio_data file;
 593
 594         if (data == NULL || size == 0)
 595                 return;
 596
 597         for (no = 0; no < ACPI_OVERRIDE_TABLES; no++) {
 598                 file = find_cpio_data(cpio_path, data, size, &offset);
 599                 if (!file.data)
 600                         break;
 601
 602                 data += offset;
 603                 size -= offset;
 604
 605                 if (file.size < sizeof(struct acpi_table_header)) {
 606                         pr_err("ACPI OVERRIDE: Table smaller than ACPI header [%s%s]\n",
 607                                 cpio_path, file.name);
 608                         continue;
 609                 }
 610
 611                 table = file.data;
 612
 613                 for (sig = 0; table_sigs[sig]; sig++)
 614                         if (!memcmp(table->signature, table_sigs[sig], 4))
 615                                 break;
 616
 617                 if (!table_sigs[sig]) {
 618                         pr_err("ACPI OVERRIDE: Unknown signature [%s%s]\n",
 619                                 cpio_path, file.name);
 620                         continue;
 621                 }
 622                 if (file.size != table->length) {
 623                         pr_err("ACPI OVERRIDE: File length does not match table length [%s%s]\n",
 624                                 cpio_path, file.name);
 625                         continue;
 626                 }
 627                 if (acpi_table_checksum(file.data, table->length)) {
 628                         pr_err("ACPI OVERRIDE: Bad table checksum [%s%s]\n",
 629                                 cpio_path, file.name);
 630                         continue;
 631                 }
 632
 633                 pr_info("%4.4s ACPI table found in initrd [%s%s][0x%x]\n",
 634                         table->signature, cpio_path, file.name, table->length);
 635
 636                 all_tables_size += table->length;
 637                 acpi_initrd_files[table_nr].data = file.data;
 638                 acpi_initrd_files[table_nr].size = file.size;
 639                 table_nr++;
 640         }
 641         if (table_nr == 0)
 642                 return;
 643
 644         acpi_tables_addr =
 645                 memblock_find_in_range(0, max_low_pfn_mapped << PAGE_SHIFT,
 646                                        all_tables_size, PAGE_SIZE);
 647         if (!acpi_tables_addr) {
 648                 WARN_ON(1);
 649                 return;
 650         }
 651         /*
 652          * Only calling e820_add_reserve does not work and the
 653          * tables are invalid (memory got used) later.
 654          * memblock_reserve works as expected and the tables won't get modified.
 655          * But it's not enough on X86 because ioremap will
 656          * complain later (used by acpi_os_map_memory) that the pages
 657          * that should get mapped are not marked "reserved".
 658          * Both memblock_reserve and e820_add_region (via arch_reserve_mem_area)
 659          * works fine.
 660          */
 661         memblock_reserve(acpi_tables_addr, all_tables_size);
 662         arch_reserve_mem_area(acpi_tables_addr, all_tables_size);
 663
 664         /*
 665          * early_ioremap only can remap 256k one time. If we map all
 666          * tables one time, we will hit the limit. Need to map chunks
 667          * one by one during copying the same as that in relocate_initrd().
 668          */
 669         for (no = 0; no < table_nr; no++) {
 670                 unsigned char *src_p = acpi_initrd_files[no].data;
 671                 phys_addr_t size = acpi_initrd_files[no].size;
 672                 phys_addr_t dest_addr = acpi_tables_addr + total_offset;
 673                 phys_addr_t slop, clen;
 674                 char *dest_p;
 675
 676                 total_offset += size;
 677
 678                 while (size) {
 679                         slop = dest_addr & ~PAGE_MASK;
 680                         clen = size;
 681                         if (clen > MAP_CHUNK_SIZE - slop)
 682                                 clen = MAP_CHUNK_SIZE - slop;
 683                         dest_p = early_ioremap(dest_addr & PAGE_MASK,
 684                                                  clen + slop);
 685                         memcpy(dest_p + slop, src_p, clen);
 686                         early_iounmap(dest_p, clen + slop);
 687                         src_p += clen;
 688                         dest_addr += clen;
 689                         size -= clen;
 690                 }
 691         }
 692 }
 693 #endif /* CONFIG_ACPI_INITRD_TABLE_OVERRIDE */
 694
 695 static void acpi_table_taint(struct acpi_table_header *table)
 696 {
 697         pr_warn(PREFIX
 698                 "Override [%4.4s-%8.8s], this is unsafe: tainting kernel\n",
 699                 table->signature, table->oem_table_id);
 700         add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE);
 701 }
 702
 703
 704 acpi_status
 705 acpi_os_table_override(struct acpi_table_header * existing_table,
 706                        struct acpi_table_header ** new_table)
 707 {
 708         if (!existing_table || !new_table)
 709                 return AE_BAD_PARAMETER;
 710
 711         *new_table = NULL;
 712
 713 #ifdef CONFIG_ACPI_CUSTOM_DSDT
 714         if (strncmp(existing_table->signature, "DSDT", 4) == 0)
 715                 *new_table = (struct acpi_table_header *)AmlCode;
 716 #endif
 717         if (*new_table != NULL)
 718                 acpi_table_taint(existing_table);
 719         return AE_OK;
 720 }
 721
 722 acpi_status
 723 acpi_os_physical_table_override(struct acpi_table_header *existing_table,
 724                                 acpi_physical_address *address,
 725                                 u32 *table_length)
 726 {
 727 #ifndef CONFIG_ACPI_INITRD_TABLE_OVERRIDE
 728         *table_length = 0;
 729         *address = 0;
 730         return AE_OK;
 731 #else
 732         int table_offset = 0;
 733         struct acpi_table_header *table;
 734
 735         *table_length = 0;
 736         *address = 0;
 737
 738         if (!acpi_tables_addr)
 739                 return AE_OK;
 740
 741         do {
 742                 if (table_offset + ACPI_HEADER_SIZE > all_tables_size) {
 743                         WARN_ON(1);
 744                         return AE_OK;
 745                 }
 746
 747                 table = acpi_os_map_memory(acpi_tables_addr + table_offset,
 748                                            ACPI_HEADER_SIZE);
 749
 750                 if (table_offset + table->length > all_tables_size) {
 751                         acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
 752                         WARN_ON(1);
 753                         return AE_OK;
 754                 }
 755
 756                 table_offset += table->length;
 757
 758                 if (memcmp(existing_table->signature, table->signature, 4)) {
 759                         acpi_os_unmap_memory(table,
 760                                      ACPI_HEADER_SIZE);
 761                         continue;
 762                 }
 763
 764                 /* Only override tables with matching oem id */
 765                 if (memcmp(table->oem_table_id, existing_table->oem_table_id,
 766                            ACPI_OEM_TABLE_ID_SIZE)) {
 767                         acpi_os_unmap_memory(table,
 768                                      ACPI_HEADER_SIZE);
 769                         continue;
 770                 }
 771
 772                 table_offset -= table->length;
 773                 *table_length = table->length;
 774                 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
 775                 *address = acpi_tables_addr + table_offset;
 776                 break;
 777         } while (table_offset + ACPI_HEADER_SIZE < all_tables_size);
 778
 779         if (*address != 0)
 780                 acpi_table_taint(existing_table);
 781         return AE_OK;
 782 #endif
 783 }
 784
 785 static irqreturn_t acpi_irq(int irq, void *dev_id)
 786 {
 787         u32 handled;
 788
 789         handled = (*acpi_irq_handler) (acpi_irq_context);
 790
 791         if (handled) {
 792                 acpi_irq_handled++;
 793                 return IRQ_HANDLED;
 794         } else {
 795                 acpi_irq_not_handled++;
 796                 return IRQ_NONE;
 797         }
 798 }
 799
 800 acpi_status
 801 acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler,
 802                                   void *context)
 803 {
 804         unsigned int irq;
 805
 806         acpi_irq_stats_init();
 807
 808         /*
 809          * ACPI interrupts different from the SCI in our copy of the FADT are
 810          * not supported.
 811          */
 812         if (gsi != acpi_gbl_FADT.sci_interrupt)
 813                 return AE_BAD_PARAMETER;
 814
 815         if (acpi_irq_handler)
 816                 return AE_ALREADY_ACQUIRED;
 817
 818         if (acpi_gsi_to_irq(gsi, &irq) < 0) {
 819                 printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n",
 820                        gsi);
 821                 return AE_OK;
 822         }
 823
 824         acpi_irq_handler = handler;
 825         acpi_irq_context = context;
 826         if (request_irq(irq, acpi_irq, IRQF_SHARED | IRQF_NO_SUSPEND, "acpi", acpi_irq)) {
 827                 printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq);
 828                 acpi_irq_handler = NULL;
 829                 return AE_NOT_ACQUIRED;
 830         }
 831
 832         return AE_OK;
 833 }
 834
 835 acpi_status acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler)
 836 {
 837         if (irq != acpi_gbl_FADT.sci_interrupt)
 838                 return AE_BAD_PARAMETER;
 839
 840         free_irq(irq, acpi_irq);
 841         acpi_irq_handler = NULL;
 842
 843         return AE_OK;
 844 }
 845
 846 /*
 847  * Running in interpreter thread context, safe to sleep
 848  */
 849
 850 void acpi_os_sleep(u64 ms)
 851 {
 852         msleep(ms);
 853 }
 854
 855 void acpi_os_stall(u32 us)
 856 {
 857         while (us) {
 858                 u32 delay = 1000;
 859
 860                 if (delay > us)
 861                         delay = us;
 862                 udelay(delay);
 863                 touch_nmi_watchdog();
 864                 us -= delay;
 865         }
 866 }
 867
 868 /*
 869  * Support ACPI 3.0 AML Timer operand
 870  * Returns 64-bit free-running, monotonically increasing timer
 871  * with 100ns granularity
 872  */
 873 u64 acpi_os_get_timer(void)
 874 {
 875         u64 time_ns = ktime_to_ns(ktime_get());
 876         do_div(time_ns, 100);
 877         return time_ns;
 878 }
 879
 880 acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width)
 881 {
 882         u32 dummy;
 883
 884         if (!value)
 885                 value = &dummy;
 886
 887         *value = 0;
 888         if (width <= 8) {
 889                 *(u8 *) value = inb(port);
 890         } else if (width <= 16) {
 891                 *(u16 *) value = inw(port);
 892         } else if (width <= 32) {
 893                 *(u32 *) value = inl(port);
 894         } else {
 895                 BUG();
 896         }
 897
 898         return AE_OK;
 899 }
 900
 901 EXPORT_SYMBOL(acpi_os_read_port);
 902
 903 acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
 904 {
 905         if (width <= 8) {
 906                 outb(value, port);
 907         } else if (width <= 16) {
 908                 outw(value, port);
 909         } else if (width <= 32) {
 910                 outl(value, port);
 911         } else {
 912                 BUG();
 913         }
 914
 915         return AE_OK;
 916 }
 917
 918 EXPORT_SYMBOL(acpi_os_write_port);
 919
 920 #ifdef readq
 921 static inline u64 read64(const volatile void __iomem *addr)
 922 {
 923         return readq(addr);
 924 }
 925 #else
 926 static inline u64 read64(const volatile void __iomem *addr)
 927 {
 928         u64 l, h;
 929         l = readl(addr);
 930         h = readl(addr+4);
 931         return l | (h << 32);
 932 }
 933 #endif
 934
 935 acpi_status
 936 acpi_os_read_memory(acpi_physical_address phys_addr, u64 *value, u32 width)
 937 {
 938         void __iomem *virt_addr;
 939         unsigned int size = width / 8;
 940         bool unmap = false;
 941         u64 dummy;
 942
 943         rcu_read_lock();
 944         virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
 945         if (!virt_addr) {
 946                 rcu_read_unlock();
 947                 virt_addr = acpi_os_ioremap(phys_addr, size);
 948                 if (!virt_addr)
 949                         return AE_BAD_ADDRESS;
 950                 unmap = true;
 951         }
 952
 953         if (!value)
 954                 value = &dummy;
 955
 956         switch (width) {
 957         case 8:
 958                 *(u8 *) value = readb(virt_addr);
 959                 break;
 960         case 16:
 961                 *(u16 *) value = readw(virt_addr);
 962                 break;
 963         case 32:
 964                 *(u32 *) value = readl(virt_addr);
 965                 break;
 966         case 64:
 967                 *(u64 *) value = read64(virt_addr);
 968                 break;
 969         default:
 970                 BUG();
 971         }
 972
 973         if (unmap)
 974                 iounmap(virt_addr);
 975         else
 976                 rcu_read_unlock();
 977
 978         return AE_OK;
 979 }
 980
 981 #ifdef writeq
 982 static inline void write64(u64 val, volatile void __iomem *addr)
 983 {
 984         writeq(val, addr);
 985 }
 986 #else
 987 static inline void write64(u64 val, volatile void __iomem *addr)
 988 {
 989         writel(val, addr);
 990         writel(val>>32, addr+4);
 991 }
 992 #endif
 993
 994 acpi_status
 995 acpi_os_write_memory(acpi_physical_address phys_addr, u64 value, u32 width)
 996 {
 997         void __iomem *virt_addr;
 998         unsigned int size = width / 8;
 999         bool unmap = false;
1000
1001         rcu_read_lock();
1002         virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
1003         if (!virt_addr) {
1004                 rcu_read_unlock();
1005                 virt_addr = acpi_os_ioremap(phys_addr, size);
1006                 if (!virt_addr)
1007                         return AE_BAD_ADDRESS;
1008                 unmap = true;
1009         }
1010
1011         switch (width) {
1012         case 8:
1013                 writeb(value, virt_addr);
1014                 break;
1015         case 16:
1016                 writew(value, virt_addr);
1017                 break;
1018         case 32:
1019                 writel(value, virt_addr);
1020                 break;
1021         case 64:
1022                 write64(value, virt_addr);
1023                 break;
1024         default:
1025                 BUG();
1026         }
1027
1028         if (unmap)
1029                 iounmap(virt_addr);
1030         else
1031                 rcu_read_unlock();
1032
1033         return AE_OK;
1034 }
1035
1036 acpi_status
1037 acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
1038                                u64 *value, u32 width)
1039 {
1040         int result, size;
1041         u32 value32;
1042
1043         if (!value)
1044                 return AE_BAD_PARAMETER;
1045
1046         switch (width) {
1047         case 8:
1048                 size = 1;
1049                 break;
1050         case 16:
1051                 size = 2;
1052                 break;
1053         case 32:
1054                 size = 4;
1055                 break;
1056         default:
1057                 return AE_ERROR;
1058         }
1059
1060         result = raw_pci_read(pci_id->segment, pci_id->bus,
1061                                 PCI_DEVFN(pci_id->device, pci_id->function),
1062                                 reg, size, &value32);
1063         *value = value32;
1064
1065         return (result ? AE_ERROR : AE_OK);
1066 }
1067
1068 acpi_status
1069 acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
1070                                 u64 value, u32 width)
1071 {
1072         int result, size;
1073
1074         switch (width) {
1075         case 8:
1076                 size = 1;
1077                 break;
1078         case 16:
1079                 size = 2;
1080                 break;
1081         case 32:
1082                 size = 4;
1083                 break;
1084         default:
1085                 return AE_ERROR;
1086         }
1087
1088         result = raw_pci_write(pci_id->segment, pci_id->bus,
1089                                 PCI_DEVFN(pci_id->device, pci_id->function),
1090                                 reg, size, value);
1091
1092         return (result ? AE_ERROR : AE_OK);
1093 }
1094
1095 static void acpi_os_execute_deferred(struct work_struct *work)
1096 {
1097         struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
1098
1099         dpc->function(dpc->context);
1100         kfree(dpc);
1101 }
1102
1103 /*******************************************************************************
1104  *
1105  * FUNCTION:    acpi_os_execute
1106  *
1107  * PARAMETERS:  Type               - Type of the callback
1108  *              Function           - Function to be executed
1109  *              Context            - Function parameters
1110  *
1111  * RETURN:      Status
1112  *
1113  * DESCRIPTION: Depending on type, either queues function for deferred execution or
1114  *              immediately executes function on a separate thread.
1115  *
1116  ******************************************************************************/
1117
1118 acpi_status acpi_os_execute(acpi_execute_type type,
1119                             acpi_osd_exec_callback function, void *context)
1120 {
1121         acpi_status status = AE_OK;
1122         struct acpi_os_dpc *dpc;
1123         struct workqueue_struct *queue;
1124         int ret;
1125         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
1126                           "Scheduling function [%p(%p)] for deferred execution.\n",
1127                           function, context));
1128
1129         /*
1130          * Allocate/initialize DPC structure.  Note that this memory will be
1131          * freed by the callee.  The kernel handles the work_struct list  in a
1132          * way that allows us to also free its memory inside the callee.
1133          * Because we may want to schedule several tasks with different
1134          * parameters we can't use the approach some kernel code uses of
1135          * having a static work_struct.
1136          */
1137
1138         dpc = kzalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC);
1139         if (!dpc)
1140                 return AE_NO_MEMORY;
1141
1142         dpc->function = function;
1143         dpc->context = context;
1144
1145         /*
1146          * To prevent lockdep from complaining unnecessarily, make sure that
1147          * there is a different static lockdep key for each workqueue by using
1148          * INIT_WORK() for each of them separately.
1149          */
1150         if (type == OSL_NOTIFY_HANDLER) {
1151                 queue = kacpi_notify_wq;
1152                 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
1153         } else {
1154                 queue = kacpid_wq;
1155                 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
1156         }
1157
1158         /*
1159          * On some machines, a software-initiated SMI causes corruption unless
1160          * the SMI runs on CPU 0.  An SMI can be initiated by any AML, but
1161          * typically it's done in GPE-related methods that are run via
1162          * workqueues, so we can avoid the known corruption cases by always
1163          * queueing on CPU 0.
1164          */
1165         ret = queue_work_on(0, queue, &dpc->work);
1166
1167         if (!ret) {
1168                 printk(KERN_ERR PREFIX
1169                           "Call to queue_work() failed.\n");
1170                 status = AE_ERROR;
1171                 kfree(dpc);
1172         }
1173         return status;
1174 }
1175 EXPORT_SYMBOL(acpi_os_execute);
1176
1177 void acpi_os_wait_events_complete(void)
1178 {
1179         flush_workqueue(kacpid_wq);
1180         flush_workqueue(kacpi_notify_wq);
1181 }
1182
1183 struct acpi_hp_work {
1184         struct work_struct work;
1185         struct acpi_device *adev;
1186         u32 src;
1187 };
1188
1189 static void acpi_hotplug_work_fn(struct work_struct *work)
1190 {
1191         struct acpi_hp_work *hpw = container_of(work, struct acpi_hp_work, work);
1192
1193         acpi_os_wait_events_complete();
1194         acpi_device_hotplug(hpw->adev, hpw->src);
1195         kfree(hpw);
1196 }
1197
1198 acpi_status acpi_hotplug_schedule(struct acpi_device *adev, u32 src)
1199 {
1200         struct acpi_hp_work *hpw;
1201
1202         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
1203                   "Scheduling hotplug event (%p, %u) for deferred execution.\n",
1204                   adev, src));
1205
1206         hpw = kmalloc(sizeof(*hpw), GFP_KERNEL);
1207         if (!hpw)
1208                 return AE_NO_MEMORY;
1209
1210         INIT_WORK(&hpw->work, acpi_hotplug_work_fn);
1211         hpw->adev = adev;
1212         hpw->src = src;
1213         /*
1214          * We can't run hotplug code in kacpid_wq/kacpid_notify_wq etc., because
1215          * the hotplug code may call driver .remove() functions, which may
1216          * invoke flush_scheduled_work()/acpi_os_wait_events_complete() to flush
1217          * these workqueues.
1218          */
1219         if (!queue_work(kacpi_hotplug_wq, &hpw->work)) {
1220                 kfree(hpw);
1221                 return AE_ERROR;
1222         }
1223         return AE_OK;
1224 }
1225
1226 bool acpi_queue_hotplug_work(struct work_struct *work)
1227 {
1228         return queue_work(kacpi_hotplug_wq, work);
1229 }
1230
1231 acpi_status
1232 acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
1233 {
1234         struct semaphore *sem = NULL;
1235
1236         sem = acpi_os_allocate_zeroed(sizeof(struct semaphore));
1237         if (!sem)
1238                 return AE_NO_MEMORY;
1239
1240         sema_init(sem, initial_units);
1241
1242         *handle = (acpi_handle *) sem;
1243
1244         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
1245                           *handle, initial_units));
1246
1247         return AE_OK;
1248 }
1249
1250 /*
1251  * TODO: A better way to delete semaphores?  Linux doesn't have a
1252  * 'delete_semaphore()' function -- may result in an invalid
1253  * pointer dereference for non-synchronized consumers.  Should
1254  * we at least check for blocked threads and signal/cancel them?
1255  */
1256
1257 acpi_status acpi_os_delete_semaphore(acpi_handle handle)
1258 {
1259         struct semaphore *sem = (struct semaphore *)handle;
1260
1261         if (!sem)
1262                 return AE_BAD_PARAMETER;
1263
1264         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
1265
1266         BUG_ON(!list_empty(&sem->wait_list));
1267         kfree(sem);
1268         sem = NULL;
1269
1270         return AE_OK;
1271 }
1272
1273 /*
1274  * TODO: Support for units > 1?
1275  */
1276 acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
1277 {
1278         acpi_status status = AE_OK;
1279         struct semaphore *sem = (struct semaphore *)handle;
1280         long jiffies;
1281         int ret = 0;
1282
1283         if (!sem || (units < 1))
1284                 return AE_BAD_PARAMETER;
1285
1286         if (units > 1)
1287                 return AE_SUPPORT;
1288
1289         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
1290                           handle, units, timeout));
1291
1292         if (timeout == ACPI_WAIT_FOREVER)
1293                 jiffies = MAX_SCHEDULE_TIMEOUT;
1294         else
1295                 jiffies = msecs_to_jiffies(timeout);
1296
1297         ret = down_timeout(sem, jiffies);
1298         if (ret)
1299                 status = AE_TIME;
1300
1301         if (ACPI_FAILURE(status)) {
1302                 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
1303                                   "Failed to acquire semaphore[%p|%d|%d], %s",
1304                                   handle, units, timeout,
1305                                   acpi_format_exception(status)));
1306         } else {
1307                 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
1308                                   "Acquired semaphore[%p|%d|%d]", handle,
1309                                   units, timeout));
1310         }
1311
1312         return status;
1313 }
1314
1315 /*
1316  * TODO: Support for units > 1?
1317  */
1318 acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
1319 {
1320         struct semaphore *sem = (struct semaphore *)handle;
1321
1322         if (!sem || (units < 1))
1323                 return AE_BAD_PARAMETER;
1324
1325         if (units > 1)
1326                 return AE_SUPPORT;
1327
1328         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
1329                           units));
1330
1331         up(sem);
1332
1333         return AE_OK;
1334 }
1335
1336 #ifdef ACPI_FUTURE_USAGE
1337 u32 acpi_os_get_line(char *buffer)
1338 {
1339
1340 #ifdef ENABLE_DEBUGGER
1341         if (acpi_in_debugger) {
1342                 u32 chars;
1343
1344                 kdb_read(buffer, sizeof(line_buf));
1345
1346                 /* remove the CR kdb includes */
1347                 chars = strlen(buffer) - 1;
1348                 buffer[chars] = '\0';
1349         }
1350 #endif
1351
1352         return 0;
1353 }
1354 #endif                          /*  ACPI_FUTURE_USAGE  */
1355
1356 acpi_status acpi_os_signal(u32 function, void *info)
1357 {
1358         switch (function) {
1359         case ACPI_SIGNAL_FATAL:
1360                 printk(KERN_ERR PREFIX "Fatal opcode executed\n");
1361                 break;
1362         case ACPI_SIGNAL_BREAKPOINT:
1363                 /*
1364                  * AML Breakpoint
1365                  * ACPI spec. says to treat it as a NOP unless
1366                  * you are debugging.  So if/when we integrate
1367                  * AML debugger into the kernel debugger its
1368                  * hook will go here.  But until then it is
1369                  * not useful to print anything on breakpoints.
1370                  */
1371                 break;
1372         default:
1373                 break;
1374         }
1375
1376         return AE_OK;
1377 }
1378
1379 static int __init acpi_os_name_setup(char *str)
1380 {
1381         char *p = acpi_os_name;
1382         int count = ACPI_MAX_OVERRIDE_LEN - 1;
1383
1384         if (!str || !*str)
1385                 return 0;
1386
1387         for (; count-- && *str; str++) {
1388                 if (isalnum(*str) || *str == ' ' || *str == ':')
1389                         *p++ = *str;
1390                 else if (*str == '\'' || *str == '"')
1391                         continue;
1392                 else
1393                         break;
1394         }
1395         *p = 0;
1396
1397         return 1;
1398
1399 }
1400
1401 __setup("acpi_os_name=", acpi_os_name_setup);
1402
1403 #define OSI_STRING_LENGTH_MAX 64        /* arbitrary */
1404 #define OSI_STRING_ENTRIES_MAX 16       /* arbitrary */
1405
1406 struct osi_setup_entry {
1407         char string[OSI_STRING_LENGTH_MAX];
1408         bool enable;
1409 };
1410
1411 static struct osi_setup_entry
1412                 osi_setup_entries[OSI_STRING_ENTRIES_MAX] __initdata = {
1413         {"Module Device", true},
1414         {"Processor Device", true},
1415         {"3.0 _SCP Extensions", true},
1416         {"Processor Aggregator Device", true},
1417 };
1418
1419 void __init acpi_osi_setup(char *str)
1420 {
1421         struct osi_setup_entry *osi;
1422         bool enable = true;
1423         int i;
1424
1425         if (!acpi_gbl_create_osi_method)
1426                 return;
1427
1428         if (str == NULL || *str == '\0') {
1429                 printk(KERN_INFO PREFIX "_OSI method disabled\n");
1430                 acpi_gbl_create_osi_method = FALSE;
1431                 return;
1432         }
1433
1434         if (*str == '!') {
1435                 str++;
1436                 if (*str == '\0') {
1437                         osi_linux.default_disabling = 1;
1438                         return;
1439                 } else if (*str == '*') {
1440                         acpi_update_interfaces(ACPI_DISABLE_ALL_STRINGS);
1441                         for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1442                                 osi = &osi_setup_entries[i];
1443                                 osi->enable = false;
1444                         }
1445                         return;
1446                 }
1447                 enable = false;
1448         }
1449
1450         for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1451                 osi = &osi_setup_entries[i];
1452                 if (!strcmp(osi->string, str)) {
1453                         osi->enable = enable;
1454                         break;
1455                 } else if (osi->string[0] == '\0') {
1456                         osi->enable = enable;
1457                         strncpy(osi->string, str, OSI_STRING_LENGTH_MAX);
1458                         break;
1459                 }
1460         }
1461 }
1462
1463 static void __init set_osi_linux(unsigned int enable)
1464 {
1465         if (osi_linux.enable != enable)
1466                 osi_linux.enable = enable;
1467
1468         if (osi_linux.enable)
1469                 acpi_osi_setup("Linux");
1470         else
1471                 acpi_osi_setup("!Linux");
1472
1473         return;
1474 }
1475
1476 static void __init acpi_cmdline_osi_linux(unsigned int enable)
1477 {
1478         osi_linux.cmdline = 1;  /* cmdline set the default and override DMI */
1479         osi_linux.dmi = 0;
1480         set_osi_linux(enable);
1481
1482         return;
1483 }
1484
1485 void __init acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d)
1486 {
1487         printk(KERN_NOTICE PREFIX "DMI detected: %s\n", d->ident);
1488
1489         if (enable == -1)
1490                 return;
1491
1492         osi_linux.dmi = 1;      /* DMI knows that this box asks OSI(Linux) */
1493         set_osi_linux(enable);
1494
1495         return;
1496 }
1497
1498 /*
1499  * Modify the list of "OS Interfaces" reported to BIOS via _OSI
1500  *
1501  * empty string disables _OSI
1502  * string starting with '!' disables that string
1503  * otherwise string is added to list, augmenting built-in strings
1504  */
1505 static void __init acpi_osi_setup_late(void)
1506 {
1507         struct osi_setup_entry *osi;
1508         char *str;
1509         int i;
1510         acpi_status status;
1511
1512         if (osi_linux.default_disabling) {
1513                 status = acpi_update_interfaces(ACPI_DISABLE_ALL_VENDOR_STRINGS);
1514
1515                 if (ACPI_SUCCESS(status))
1516                         printk(KERN_INFO PREFIX "Disabled all _OSI OS vendors\n");
1517         }
1518
1519         for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1520                 osi = &osi_setup_entries[i];
1521                 str = osi->string;
1522
1523                 if (*str == '\0')
1524                         break;
1525                 if (osi->enable) {
1526                         status = acpi_install_interface(str);
1527
1528                         if (ACPI_SUCCESS(status))
1529                                 printk(KERN_INFO PREFIX "Added _OSI(%s)\n", str);
1530                 } else {
1531                         status = acpi_remove_interface(str);
1532
1533                         if (ACPI_SUCCESS(status))
1534                                 printk(KERN_INFO PREFIX "Deleted _OSI(%s)\n", str);
1535                 }
1536         }
1537 }
1538
1539 static int __init osi_setup(char *str)
1540 {
1541         if (str && !strcmp("Linux", str))
1542                 acpi_cmdline_osi_linux(1);
1543         else if (str && !strcmp("!Linux", str))
1544                 acpi_cmdline_osi_linux(0);
1545         else
1546                 acpi_osi_setup(str);
1547
1548         return 1;
1549 }
1550
1551 __setup("acpi_osi=", osi_setup);
1552
1553 /*
1554  * Disable the auto-serialization of named objects creation methods.
1555  *
1556  * This feature is enabled by default.  It marks the AML control methods
1557  * that contain the opcodes to create named objects as "Serialized".
1558  */
1559 static int __init acpi_no_auto_serialize_setup(char *str)
1560 {
1561         acpi_gbl_auto_serialize_methods = FALSE;
1562         pr_info("ACPI: auto-serialization disabled\n");
1563
1564         return 1;
1565 }
1566
1567 __setup("acpi_no_auto_serialize", acpi_no_auto_serialize_setup);
1568
1569 /* Check of resource interference between native drivers and ACPI
1570  * OperationRegions (SystemIO and System Memory only).
1571  * IO ports and memory declared in ACPI might be used by the ACPI subsystem
1572  * in arbitrary AML code and can interfere with legacy drivers.
1573  * acpi_enforce_resources= can be set to:
1574  *
1575  *   - strict (default) (2)
1576  *     -> further driver trying to access the resources will not load
1577  *   - lax              (1)
1578  *     -> further driver trying to access the resources will load, but you
1579  *     get a system message that something might go wrong...
1580  *
1581  *   - no               (0)
1582  *     -> ACPI Operation Region resources will not be registered
1583  *
1584  */
1585 #define ENFORCE_RESOURCES_STRICT 2
1586 #define ENFORCE_RESOURCES_LAX    1
1587 #define ENFORCE_RESOURCES_NO     0
1588
1589 static unsigned int acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1590
1591 static int __init acpi_enforce_resources_setup(char *str)
1592 {
1593         if (str == NULL || *str == '\0')
1594                 return 0;
1595
1596         if (!strcmp("strict", str))
1597                 acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1598         else if (!strcmp("lax", str))
1599                 acpi_enforce_resources = ENFORCE_RESOURCES_LAX;
1600         else if (!strcmp("no", str))
1601                 acpi_enforce_resources = ENFORCE_RESOURCES_NO;
1602
1603         return 1;
1604 }
1605
1606 __setup("acpi_enforce_resources=", acpi_enforce_resources_setup);
1607
1608 /* Check for resource conflicts between ACPI OperationRegions and native
1609  * drivers */
1610 int acpi_check_resource_conflict(const struct resource *res)
1611 {
1612         acpi_adr_space_type space_id;
1613         acpi_size length;
1614         u8 warn = 0;
1615         int clash = 0;
1616
1617         if (acpi_enforce_resources == ENFORCE_RESOURCES_NO)
1618                 return 0;
1619         if (!(res->flags & IORESOURCE_IO) && !(res->flags & IORESOURCE_MEM))
1620                 return 0;
1621
1622         if (res->flags & IORESOURCE_IO)
1623                 space_id = ACPI_ADR_SPACE_SYSTEM_IO;
1624         else
1625                 space_id = ACPI_ADR_SPACE_SYSTEM_MEMORY;
1626
1627         length = resource_size(res);
1628         if (acpi_enforce_resources != ENFORCE_RESOURCES_NO)
1629                 warn = 1;
1630         clash = acpi_check_address_range(space_id, res->start, length, warn);
1631
1632         if (clash) {
1633                 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO) {
1634                         if (acpi_enforce_resources == ENFORCE_RESOURCES_LAX)
1635                                 printk(KERN_NOTICE "ACPI: This conflict may"
1636                                        " cause random problems and system"
1637                                        " instability\n");
1638                         printk(KERN_INFO "ACPI: If an ACPI driver is available"
1639                                " for this device, you should use it instead of"
1640                                " the native driver\n");
1641                 }
1642                 if (acpi_enforce_resources == ENFORCE_RESOURCES_STRICT)
1643                         return -EBUSY;
1644         }
1645         return 0;
1646 }
1647 EXPORT_SYMBOL(acpi_check_resource_conflict);
1648
1649 int acpi_check_region(resource_size_t start, resource_size_t n,
1650                       const char *name)
1651 {
1652         struct resource res = {
1653                 .start = start,
1654                 .end   = start + n - 1,
1655                 .name  = name,
1656                 .flags = IORESOURCE_IO,
1657         };
1658
1659         return acpi_check_resource_conflict(&res);
1660 }
1661 EXPORT_SYMBOL(acpi_check_region);
1662
1663 /*
1664  * Let drivers know whether the resource checks are effective
1665  */
1666 int acpi_resources_are_enforced(void)
1667 {
1668         return acpi_enforce_resources == ENFORCE_RESOURCES_STRICT;
1669 }
1670 EXPORT_SYMBOL(acpi_resources_are_enforced);
1671
1672 /*
1673  * Deallocate the memory for a spinlock.
1674  */
1675 void acpi_os_delete_lock(acpi_spinlock handle)
1676 {
1677         ACPI_FREE(handle);
1678 }
1679
1680 /*
1681  * Acquire a spinlock.
1682  *
1683  * handle is a pointer to the spinlock_t.
1684  */
1685
1686 acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp)
1687 {
1688         acpi_cpu_flags flags;
1689         spin_lock_irqsave(lockp, flags);
1690         return flags;
1691 }
1692
1693 /*
1694  * Release a spinlock. See above.
1695  */
1696
1697 void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
1698 {
1699         spin_unlock_irqrestore(lockp, flags);
1700 }
1701
1702 #ifndef ACPI_USE_LOCAL_CACHE
1703
1704 /*******************************************************************************
1705  *
1706  * FUNCTION:    acpi_os_create_cache
1707  *
1708  * PARAMETERS:  name      - Ascii name for the cache
1709  *              size      - Size of each cached object
1710  *              depth     - Maximum depth of the cache (in objects) <ignored>
1711  *              cache     - Where the new cache object is returned
1712  *
1713  * RETURN:      status
1714  *
1715  * DESCRIPTION: Create a cache object
1716  *
1717  ******************************************************************************/
1718
1719 acpi_status
1720 acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
1721 {
1722         *cache = kmem_cache_create(name, size, 0, 0, NULL);
1723         if (*cache == NULL)
1724                 return AE_ERROR;
1725         else
1726                 return AE_OK;
1727 }
1728
1729 /*******************************************************************************
1730  *
1731  * FUNCTION:    acpi_os_purge_cache
1732  *
1733  * PARAMETERS:  Cache           - Handle to cache object
1734  *
1735  * RETURN:      Status
1736  *
1737  * DESCRIPTION: Free all objects within the requested cache.
1738  *
1739  ******************************************************************************/
1740
1741 acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
1742 {
1743         kmem_cache_shrink(cache);
1744         return (AE_OK);
1745 }
1746
1747 /*******************************************************************************
1748  *
1749  * FUNCTION:    acpi_os_delete_cache
1750  *
1751  * PARAMETERS:  Cache           - Handle to cache object
1752  *
1753  * RETURN:      Status
1754  *
1755  * DESCRIPTION: Free all objects within the requested cache and delete the
1756  *              cache object.
1757  *
1758  ******************************************************************************/
1759
1760 acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
1761 {
1762         kmem_cache_destroy(cache);
1763         return (AE_OK);
1764 }
1765
1766 /*******************************************************************************
1767  *
1768  * FUNCTION:    acpi_os_release_object
1769  *
1770  * PARAMETERS:  Cache       - Handle to cache object
1771  *              Object      - The object to be released
1772  *
1773  * RETURN:      None
1774  *
1775  * DESCRIPTION: Release an object to the specified cache.  If cache is full,
1776  *              the object is deleted.
1777  *
1778  ******************************************************************************/
1779
1780 acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
1781 {
1782         kmem_cache_free(cache, object);
1783         return (AE_OK);
1784 }
1785 #endif
1786
1787 static int __init acpi_no_static_ssdt_setup(char *s)
1788 {
1789         acpi_gbl_disable_ssdt_table_install = TRUE;
1790         pr_info("ACPI: static SSDT installation disabled\n");
1791
1792         return 0;
1793 }
1794
1795 early_param("acpi_no_static_ssdt", acpi_no_static_ssdt_setup);
1796
1797 static int __init acpi_disable_return_repair(char *s)
1798 {
1799         printk(KERN_NOTICE PREFIX
1800                "ACPI: Predefined validation mechanism disabled\n");
1801         acpi_gbl_disable_auto_repair = TRUE;
1802
1803         return 1;
1804 }
1805
1806 __setup("acpica_no_return_repair", acpi_disable_return_repair);
1807
1808 acpi_status __init acpi_os_initialize(void)
1809 {
1810         acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1811         acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1812         acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe0_block);
1813         acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe1_block);
1814         if (acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER) {
1815                 /*
1816                  * Use acpi_os_map_generic_address to pre-map the reset
1817                  * register if it's in system memory.
1818                  */
1819                 int rv;
1820
1821                 rv = acpi_os_map_generic_address(&acpi_gbl_FADT.reset_register);
1822                 pr_debug(PREFIX "%s: map reset_reg status %d\n", __func__, rv);
1823         }
1824
1825         return AE_OK;
1826 }
1827
1828 acpi_status __init acpi_os_initialize1(void)
1829 {
1830         kacpid_wq = alloc_workqueue("kacpid", 0, 1);
1831         kacpi_notify_wq = alloc_workqueue("kacpi_notify", 0, 1);
1832         kacpi_hotplug_wq = alloc_ordered_workqueue("kacpi_hotplug", 0);
1833         BUG_ON(!kacpid_wq);
1834         BUG_ON(!kacpi_notify_wq);
1835         BUG_ON(!kacpi_hotplug_wq);
1836         acpi_install_interface_handler(acpi_osi_handler);
1837         acpi_osi_setup_late();
1838         return AE_OK;
1839 }
1840
1841 acpi_status acpi_os_terminate(void)
1842 {
1843         if (acpi_irq_handler) {
1844                 acpi_os_remove_interrupt_handler(acpi_gbl_FADT.sci_interrupt,
1845                                                  acpi_irq_handler);
1846         }
1847
1848         acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe1_block);
1849         acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe0_block);
1850         acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1851         acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1852         if (acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER)
1853                 acpi_os_unmap_generic_address(&acpi_gbl_FADT.reset_register);
1854
1855         destroy_workqueue(kacpid_wq);
1856         destroy_workqueue(kacpi_notify_wq);
1857         destroy_workqueue(kacpi_hotplug_wq);
1858
1859         return AE_OK;
1860 }
1861
1862 acpi_status acpi_os_prepare_sleep(u8 sleep_state, u32 pm1a_control,
1863                                   u32 pm1b_control)
1864 {
1865         int rc = 0;
1866         if (__acpi_os_prepare_sleep)
1867                 rc = __acpi_os_prepare_sleep(sleep_state,
1868                                              pm1a_control, pm1b_control);
1869         if (rc < 0)
1870                 return AE_ERROR;
1871         else if (rc > 0)
1872                 return AE_CTRL_SKIP;
1873
1874         return AE_OK;
1875 }
1876
1877 void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state,
1878                                u32 pm1a_ctrl, u32 pm1b_ctrl))
1879 {
1880         __acpi_os_prepare_sleep = func;
1881 }
1882
1883 acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state, u32 val_a,
1884                                   u32 val_b)
1885 {
1886         int rc = 0;
1887         if (__acpi_os_prepare_extended_sleep)
1888                 rc = __acpi_os_prepare_extended_sleep(sleep_state,
1889                                              val_a, val_b);
1890         if (rc < 0)
1891                 return AE_ERROR;
1892         else if (rc > 0)
1893                 return AE_CTRL_SKIP;
1894
1895         return AE_OK;
1896 }
1897
1898 void acpi_os_set_prepare_extended_sleep(int (*func)(u8 sleep_state,
1899                                u32 val_a, u32 val_b))
1900 {
1901         __acpi_os_prepare_extended_sleep = func;
1902 }