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