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("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, "ACPI: %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 = DEFINE_RES_IO_NAMED(start, n, name);
1491
1492        return acpi_check_resource_conflict(&res);
1493}
1494EXPORT_SYMBOL(acpi_check_region);
1495
1496static acpi_status acpi_deactivate_mem_region(acpi_handle handle, u32 level,
1497                                              void *_res, void **return_value)
1498{
1499        struct acpi_mem_space_context **mem_ctx;
1500        union acpi_operand_object *handler_obj;
1501        union acpi_operand_object *region_obj2;
1502        union acpi_operand_object *region_obj;
1503        struct resource *res = _res;
1504        acpi_status status;
1505
1506        region_obj = acpi_ns_get_attached_object(handle);
1507        if (!region_obj)
1508                return AE_OK;
1509
1510        handler_obj = region_obj->region.handler;
1511        if (!handler_obj)
1512                return AE_OK;
1513
1514        if (region_obj->region.space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
1515                return AE_OK;
1516
1517        if (!(region_obj->region.flags & AOPOBJ_SETUP_COMPLETE))
1518                return AE_OK;
1519
1520        region_obj2 = acpi_ns_get_secondary_object(region_obj);
1521        if (!region_obj2)
1522                return AE_OK;
1523
1524        mem_ctx = (void *)&region_obj2->extra.region_context;
1525
1526        if (!(mem_ctx[0]->address >= res->start &&
1527              mem_ctx[0]->address < res->end))
1528                return AE_OK;
1529
1530        status = handler_obj->address_space.setup(region_obj,
1531                                                  ACPI_REGION_DEACTIVATE,
1532                                                  NULL, (void **)mem_ctx);
1533        if (ACPI_SUCCESS(status))
1534                region_obj->region.flags &= ~(AOPOBJ_SETUP_COMPLETE);
1535
1536        return status;
1537}
1538
1539/**
1540 * acpi_release_memory - Release any mappings done to a memory region
1541 * @handle: Handle to namespace node
1542 * @res: Memory resource
1543 * @level: A level that terminates the search
1544 *
1545 * Walks through @handle and unmaps all SystemMemory Operation Regions that
1546 * overlap with @res and that have already been activated (mapped).
1547 *
1548 * This is a helper that allows drivers to place special requirements on memory
1549 * region that may overlap with operation regions, primarily allowing them to
1550 * safely map the region as non-cached memory.
1551 *
1552 * The unmapped Operation Regions will be automatically remapped next time they
1553 * are called, so the drivers do not need to do anything else.
1554 */
1555acpi_status acpi_release_memory(acpi_handle handle, struct resource *res,
1556                                u32 level)
1557{
1558        acpi_status status;
1559
1560        if (!(res->flags & IORESOURCE_MEM))
1561                return AE_TYPE;
1562
1563        status = acpi_walk_namespace(ACPI_TYPE_REGION, handle, level,
1564                                     acpi_deactivate_mem_region, NULL,
1565                                     res, NULL);
1566        if (ACPI_FAILURE(status))
1567                return status;
1568
1569        /*
1570         * Wait for all of the mappings queued up for removal by
1571         * acpi_deactivate_mem_region() to actually go away.
1572         */
1573        synchronize_rcu();
1574        rcu_barrier();
1575        flush_scheduled_work();
1576
1577        return AE_OK;
1578}
1579EXPORT_SYMBOL_GPL(acpi_release_memory);
1580
1581/*
1582 * Let drivers know whether the resource checks are effective
1583 */
1584int acpi_resources_are_enforced(void)
1585{
1586        return acpi_enforce_resources == ENFORCE_RESOURCES_STRICT;
1587}
1588EXPORT_SYMBOL(acpi_resources_are_enforced);
1589
1590/*
1591 * Deallocate the memory for a spinlock.
1592 */
1593void acpi_os_delete_lock(acpi_spinlock handle)
1594{
1595        ACPI_FREE(handle);
1596}
1597
1598/*
1599 * Acquire a spinlock.
1600 *
1601 * handle is a pointer to the spinlock_t.
1602 */
1603
1604acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp)
1605        __acquires(lockp)
1606{
1607        acpi_cpu_flags flags;
1608        spin_lock_irqsave(lockp, flags);
1609        return flags;
1610}
1611
1612/*
1613 * Release a spinlock. See above.
1614 */
1615
1616void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
1617        __releases(lockp)
1618{
1619        spin_unlock_irqrestore(lockp, flags);
1620}
1621
1622#ifndef ACPI_USE_LOCAL_CACHE
1623
1624/*******************************************************************************
1625 *
1626 * FUNCTION:    acpi_os_create_cache
1627 *
1628 * PARAMETERS:  name      - Ascii name for the cache
1629 *              size      - Size of each cached object
1630 *              depth     - Maximum depth of the cache (in objects) <ignored>
1631 *              cache     - Where the new cache object is returned
1632 *
1633 * RETURN:      status
1634 *
1635 * DESCRIPTION: Create a cache object
1636 *
1637 ******************************************************************************/
1638
1639acpi_status
1640acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
1641{
1642        *cache = kmem_cache_create(name, size, 0, 0, NULL);
1643        if (*cache == NULL)
1644                return AE_ERROR;
1645        else
1646                return AE_OK;
1647}
1648
1649/*******************************************************************************
1650 *
1651 * FUNCTION:    acpi_os_purge_cache
1652 *
1653 * PARAMETERS:  Cache           - Handle to cache object
1654 *
1655 * RETURN:      Status
1656 *
1657 * DESCRIPTION: Free all objects within the requested cache.
1658 *
1659 ******************************************************************************/
1660
1661acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
1662{
1663        kmem_cache_shrink(cache);
1664        return (AE_OK);
1665}
1666
1667/*******************************************************************************
1668 *
1669 * FUNCTION:    acpi_os_delete_cache
1670 *
1671 * PARAMETERS:  Cache           - Handle to cache object
1672 *
1673 * RETURN:      Status
1674 *
1675 * DESCRIPTION: Free all objects within the requested cache and delete the
1676 *              cache object.
1677 *
1678 ******************************************************************************/
1679
1680acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
1681{
1682        kmem_cache_destroy(cache);
1683        return (AE_OK);
1684}
1685
1686/*******************************************************************************
1687 *
1688 * FUNCTION:    acpi_os_release_object
1689 *
1690 * PARAMETERS:  Cache       - Handle to cache object
1691 *              Object      - The object to be released
1692 *
1693 * RETURN:      None
1694 *
1695 * DESCRIPTION: Release an object to the specified cache.  If cache is full,
1696 *              the object is deleted.
1697 *
1698 ******************************************************************************/
1699
1700acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
1701{
1702        kmem_cache_free(cache, object);
1703        return (AE_OK);
1704}
1705#endif
1706
1707static int __init acpi_no_static_ssdt_setup(char *s)
1708{
1709        acpi_gbl_disable_ssdt_table_install = TRUE;
1710        pr_info("Static SSDT installation disabled\n");
1711
1712        return 0;
1713}
1714
1715early_param("acpi_no_static_ssdt", acpi_no_static_ssdt_setup);
1716
1717static int __init acpi_disable_return_repair(char *s)
1718{
1719        pr_notice("Predefined validation mechanism disabled\n");
1720        acpi_gbl_disable_auto_repair = TRUE;
1721
1722        return 1;
1723}
1724
1725__setup("acpica_no_return_repair", acpi_disable_return_repair);
1726
1727acpi_status __init acpi_os_initialize(void)
1728{
1729        acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1730        acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1731
1732        acpi_gbl_xgpe0_block_logical_address =
1733                (unsigned long)acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe0_block);
1734        acpi_gbl_xgpe1_block_logical_address =
1735                (unsigned long)acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe1_block);
1736
1737        if (acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER) {
1738                /*
1739                 * Use acpi_os_map_generic_address to pre-map the reset
1740                 * register if it's in system memory.
1741                 */
1742                void *rv;
1743
1744                rv = acpi_os_map_generic_address(&acpi_gbl_FADT.reset_register);
1745                pr_debug("%s: Reset register mapping %s\n", __func__,
1746                         rv ? "successful" : "failed");
1747        }
1748        acpi_os_initialized = true;
1749
1750        return AE_OK;
1751}
1752
1753acpi_status __init acpi_os_initialize1(void)
1754{
1755        kacpid_wq = alloc_workqueue("kacpid", 0, 1);
1756        kacpi_notify_wq = alloc_workqueue("kacpi_notify", 0, 1);
1757        kacpi_hotplug_wq = alloc_ordered_workqueue("kacpi_hotplug", 0);
1758        BUG_ON(!kacpid_wq);
1759        BUG_ON(!kacpi_notify_wq);
1760        BUG_ON(!kacpi_hotplug_wq);
1761        acpi_osi_init();
1762        return AE_OK;
1763}
1764
1765acpi_status acpi_os_terminate(void)
1766{
1767        if (acpi_irq_handler) {
1768                acpi_os_remove_interrupt_handler(acpi_gbl_FADT.sci_interrupt,
1769                                                 acpi_irq_handler);
1770        }
1771
1772        acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe1_block);
1773        acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe0_block);
1774        acpi_gbl_xgpe0_block_logical_address = 0UL;
1775        acpi_gbl_xgpe1_block_logical_address = 0UL;
1776
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        if (acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER)
1781                acpi_os_unmap_generic_address(&acpi_gbl_FADT.reset_register);
1782
1783        destroy_workqueue(kacpid_wq);
1784        destroy_workqueue(kacpi_notify_wq);
1785        destroy_workqueue(kacpi_hotplug_wq);
1786
1787        return AE_OK;
1788}
1789
1790acpi_status acpi_os_prepare_sleep(u8 sleep_state, u32 pm1a_control,
1791                                  u32 pm1b_control)
1792{
1793        int rc = 0;
1794        if (__acpi_os_prepare_sleep)
1795                rc = __acpi_os_prepare_sleep(sleep_state,
1796                                             pm1a_control, pm1b_control);
1797        if (rc < 0)
1798                return AE_ERROR;
1799        else if (rc > 0)
1800                return AE_CTRL_TERMINATE;
1801
1802        return AE_OK;
1803}
1804
1805void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state,
1806                               u32 pm1a_ctrl, u32 pm1b_ctrl))
1807{
1808        __acpi_os_prepare_sleep = func;
1809}
1810
1811#if (ACPI_REDUCED_HARDWARE)
1812acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state, u32 val_a,
1813                                  u32 val_b)
1814{
1815        int rc = 0;
1816        if (__acpi_os_prepare_extended_sleep)
1817                rc = __acpi_os_prepare_extended_sleep(sleep_state,
1818                                             val_a, val_b);
1819        if (rc < 0)
1820                return AE_ERROR;
1821        else if (rc > 0)
1822                return AE_CTRL_TERMINATE;
1823
1824        return AE_OK;
1825}
1826#else
1827acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state, u32 val_a,
1828                                  u32 val_b)
1829{
1830        return AE_OK;
1831}
1832#endif
1833
1834void acpi_os_set_prepare_extended_sleep(int (*func)(u8 sleep_state,
1835                               u32 val_a, u32 val_b))
1836{
1837        __acpi_os_prepare_extended_sleep = func;
1838}
1839
1840acpi_status acpi_os_enter_sleep(u8 sleep_state,
1841                                u32 reg_a_value, u32 reg_b_value)
1842{
1843        acpi_status status;
1844
1845        if (acpi_gbl_reduced_hardware)
1846                status = acpi_os_prepare_extended_sleep(sleep_state,
1847                                                        reg_a_value,
1848                                                        reg_b_value);
1849        else
1850                status = acpi_os_prepare_sleep(sleep_state,
1851                                               reg_a_value, reg_b_value);
1852        return status;
1853}
1854
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.