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