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