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