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