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