1 /* 2 * acpi_osl.c - OS-dependent functions ($Revision: 83 $) 3 * 4 * Copyright (C) 2000 Andrew Henroid 5 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 6 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 7 * Copyright (c) 2008 Intel Corporation 8 * Author: Matthew Wilcox <willy@linux.intel.com> 9 * 10 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License as published by 14 * the Free Software Foundation; either version 2 of the License, or 15 * (at your option) any later version. 16 * 17 * This program is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 * GNU General Public License for more details. 21 * 22 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 23 * 24 */ 25 26 #include <linux/module.h> 27 #include <linux/kernel.h> 28 #include <linux/slab.h> 29 #include <linux/mm.h> 30 #include <linux/highmem.h> 31 #include <linux/pci.h> 32 #include <linux/interrupt.h> 33 #include <linux/kmod.h> 34 #include <linux/delay.h> 35 #include <linux/workqueue.h> 36 #include <linux/nmi.h> 37 #include <linux/acpi.h> 38 #include <linux/efi.h> 39 #include <linux/ioport.h> 40 #include <linux/list.h> 41 #include <linux/jiffies.h> 42 #include <linux/semaphore.h> 43 44 #include <asm/io.h> 45 #include <linux/uaccess.h> 46 #include <linux/io-64-nonatomic-lo-hi.h> 47 48 #include "acpica/accommon.h" 49 #include "acpica/acnamesp.h" 50 #include "internal.h" 51 52 #define _COMPONENT ACPI_OS_SERVICES 53 ACPI_MODULE_NAME("osl"); 54 55 struct acpi_os_dpc { 56 acpi_osd_exec_callback function; 57 void *context; 58 struct work_struct work; 59 }; 60 61 #ifdef ENABLE_DEBUGGER 62 #include <linux/kdb.h> 63 64 /* stuff for debugger support */ 65 int acpi_in_debugger; 66 EXPORT_SYMBOL(acpi_in_debugger); 67 #endif /*ENABLE_DEBUGGER */ 68 69 static int (*__acpi_os_prepare_sleep)(u8 sleep_state, u32 pm1a_ctrl, 70 u32 pm1b_ctrl); 71 static int (*__acpi_os_prepare_extended_sleep)(u8 sleep_state, u32 val_a, 72 u32 val_b); 73 74 static acpi_osd_handler acpi_irq_handler; 75 static void *acpi_irq_context; 76 static struct workqueue_struct *kacpid_wq; 77 static struct workqueue_struct *kacpi_notify_wq; 78 static struct workqueue_struct *kacpi_hotplug_wq; 79 static bool acpi_os_initialized; 80 unsigned int acpi_sci_irq = INVALID_ACPI_IRQ; 81 bool acpi_permanent_mmap = false; 82 83 /* 84 * This list of permanent mappings is for memory that may be accessed from 85 * interrupt context, where we can't do the ioremap(). 86 */ 87 struct acpi_ioremap { 88 struct list_head list; 89 void __iomem *virt; 90 acpi_physical_address phys; 91 acpi_size size; 92 unsigned long refcount; 93 }; 94 95 static LIST_HEAD(acpi_ioremaps); 96 static DEFINE_MUTEX(acpi_ioremap_lock); 97 98 static void __init acpi_request_region (struct acpi_generic_address *gas, 99 unsigned int length, char *desc) 100 { 101 u64 addr; 102 103 /* Handle possible alignment issues */ 104 memcpy(&addr, &gas->address, sizeof(addr)); 105 if (!addr || !length) 106 return; 107 108 /* Resources are never freed */ 109 if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO) 110 request_region(addr, length, desc); 111 else if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) 112 request_mem_region(addr, length, desc); 113 } 114 115 static int __init acpi_reserve_resources(void) 116 { 117 acpi_request_region(&acpi_gbl_FADT.xpm1a_event_block, acpi_gbl_FADT.pm1_event_length, 118 "ACPI PM1a_EVT_BLK"); 119 120 acpi_request_region(&acpi_gbl_FADT.xpm1b_event_block, acpi_gbl_FADT.pm1_event_length, 121 "ACPI PM1b_EVT_BLK"); 122 123 acpi_request_region(&acpi_gbl_FADT.xpm1a_control_block, acpi_gbl_FADT.pm1_control_length, 124 "ACPI PM1a_CNT_BLK"); 125 126 acpi_request_region(&acpi_gbl_FADT.xpm1b_control_block, acpi_gbl_FADT.pm1_control_length, 127 "ACPI PM1b_CNT_BLK"); 128 129 if (acpi_gbl_FADT.pm_timer_length == 4) 130 acpi_request_region(&acpi_gbl_FADT.xpm_timer_block, 4, "ACPI PM_TMR"); 131 132 acpi_request_region(&acpi_gbl_FADT.xpm2_control_block, acpi_gbl_FADT.pm2_control_length, 133 "ACPI PM2_CNT_BLK"); 134 135 /* Length of GPE blocks must be a non-negative multiple of 2 */ 136 137 if (!(acpi_gbl_FADT.gpe0_block_length & 0x1)) 138 acpi_request_region(&acpi_gbl_FADT.xgpe0_block, 139 acpi_gbl_FADT.gpe0_block_length, "ACPI GPE0_BLK"); 140 141 if (!(acpi_gbl_FADT.gpe1_block_length & 0x1)) 142 acpi_request_region(&acpi_gbl_FADT.xgpe1_block, 143 acpi_gbl_FADT.gpe1_block_length, "ACPI GPE1_BLK"); 144 145 return 0; 146 } 147 fs_initcall_sync(acpi_reserve_resources); 148 149 void acpi_os_printf(const char *fmt, ...) 150 { 151 va_list args; 152 va_start(args, fmt); 153 acpi_os_vprintf(fmt, args); 154 va_end(args); 155 } 156 EXPORT_SYMBOL(acpi_os_printf); 157 158 void acpi_os_vprintf(const char *fmt, va_list args) 159 { 160 static char buffer[512]; 161 162 vsprintf(buffer, fmt, args); 163 164 #ifdef ENABLE_DEBUGGER 165 if (acpi_in_debugger) { 166 kdb_printf("%s", buffer); 167 } else { 168 if (printk_get_level(buffer)) 169 printk("%s", buffer); 170 else 171 printk(KERN_CONT "%s", buffer); 172 } 173 #else 174 if (acpi_debugger_write_log(buffer) < 0) { 175 if (printk_get_level(buffer)) 176 printk("%s", buffer); 177 else 178 printk(KERN_CONT "%s", buffer); 179 } 180 #endif 181 } 182 183 #ifdef CONFIG_KEXEC 184 static unsigned long acpi_rsdp; 185 static int __init setup_acpi_rsdp(char *arg) 186 { 187 return kstrtoul(arg, 16, &acpi_rsdp); 188 } 189 early_param("acpi_rsdp", setup_acpi_rsdp); 190 #endif 191 192 acpi_physical_address __init acpi_os_get_root_pointer(void) 193 { 194 acpi_physical_address pa; 195 196 #ifdef CONFIG_KEXEC 197 if (acpi_rsdp) 198 return acpi_rsdp; 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) 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) 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 621 * Returns 64-bit free-running, monotonically increasing timer 622 * with 100ns granularity 623 */ 624 u64 acpi_os_get_timer(void) 625 { 626 u64 time_ns = ktime_to_ns(ktime_get()); 627 do_div(time_ns, 100); 628 return time_ns; 629 } 630 631 acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width) 632 { 633 u32 dummy; 634 635 if (!value) 636 value = &dummy; 637 638 *value = 0; 639 if (width <= 8) { 640 *(u8 *) value = inb(port); 641 } else if (width <= 16) { 642 *(u16 *) value = inw(port); 643 } else if (width <= 32) { 644 *(u32 *) value = inl(port); 645 } else { 646 BUG(); 647 } 648 649 return AE_OK; 650 } 651 652 EXPORT_SYMBOL(acpi_os_read_port); 653 654 acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width) 655 { 656 if (width <= 8) { 657 outb(value, port); 658 } else if (width <= 16) { 659 outw(value, port); 660 } else if (width <= 32) { 661 outl(value, port); 662 } else { 663 BUG(); 664 } 665 666 return AE_OK; 667 } 668 669 EXPORT_SYMBOL(acpi_os_write_port); 670 671 int acpi_os_read_iomem(void __iomem *virt_addr, u64 *value, u32 width) 672 { 673 674 switch (width) { 675 case 8: 676 *(u8 *) value = readb(virt_addr); 677 break; 678 case 16: 679 *(u16 *) value = readw(virt_addr); 680 break; 681 case 32: 682 *(u32 *) value = readl(virt_addr); 683 break; 684 case 64: 685 *(u64 *) value = readq(virt_addr); 686 break; 687 default: 688 return -EINVAL; 689 } 690 691 return 0; 692 } 693 694 acpi_status 695 acpi_os_read_memory(acpi_physical_address phys_addr, u64 *value, u32 width) 696 { 697 void __iomem *virt_addr; 698 unsigned int size = width / 8; 699 bool unmap = false; 700 u64 dummy; 701 int error; 702 703 rcu_read_lock(); 704 virt_addr = acpi_map_vaddr_lookup(phys_addr, size); 705 if (!virt_addr) { 706 rcu_read_unlock(); 707 virt_addr = acpi_os_ioremap(phys_addr, size); 708 if (!virt_addr) 709 return AE_BAD_ADDRESS; 710 unmap = true; 711 } 712 713 if (!value) 714 value = &dummy; 715 716 error = acpi_os_read_iomem(virt_addr, value, width); 717 BUG_ON(error); 718 719 if (unmap) 720 iounmap(virt_addr); 721 else 722 rcu_read_unlock(); 723 724 return AE_OK; 725 } 726 727 acpi_status 728 acpi_os_write_memory(acpi_physical_address phys_addr, u64 value, u32 width) 729 { 730 void __iomem *virt_addr; 731 unsigned int size = width / 8; 732 bool unmap = false; 733 734 rcu_read_lock(); 735 virt_addr = acpi_map_vaddr_lookup(phys_addr, size); 736 if (!virt_addr) { 737 rcu_read_unlock(); 738 virt_addr = acpi_os_ioremap(phys_addr, size); 739 if (!virt_addr) 740 return AE_BAD_ADDRESS; 741 unmap = true; 742 } 743 744 switch (width) { 745 case 8: 746 writeb(value, virt_addr); 747 break; 748 case 16: 749 writew(value, virt_addr); 750 break; 751 case 32: 752 writel(value, virt_addr); 753 break; 754 case 64: 755 writeq(value, virt_addr); 756 break; 757 default: 758 BUG(); 759 } 760 761 if (unmap) 762 iounmap(virt_addr); 763 else 764 rcu_read_unlock(); 765 766 return AE_OK; 767 } 768 769 acpi_status 770 acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg, 771 u64 *value, u32 width) 772 { 773 int result, size; 774 u32 value32; 775 776 if (!value) 777 return AE_BAD_PARAMETER; 778 779 switch (width) { 780 case 8: 781 size = 1; 782 break; 783 case 16: 784 size = 2; 785 break; 786 case 32: 787 size = 4; 788 break; 789 default: 790 return AE_ERROR; 791 } 792 793 result = raw_pci_read(pci_id->segment, pci_id->bus, 794 PCI_DEVFN(pci_id->device, pci_id->function), 795 reg, size, &value32); 796 *value = value32; 797 798 return (result ? AE_ERROR : AE_OK); 799 } 800 801 acpi_status 802 acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg, 803 u64 value, u32 width) 804 { 805 int result, size; 806 807 switch (width) { 808 case 8: 809 size = 1; 810 break; 811 case 16: 812 size = 2; 813 break; 814 case 32: 815 size = 4; 816 break; 817 default: 818 return AE_ERROR; 819 } 820 821 result = raw_pci_write(pci_id->segment, pci_id->bus, 822 PCI_DEVFN(pci_id->device, pci_id->function), 823 reg, size, value); 824 825 return (result ? AE_ERROR : AE_OK); 826 } 827 828 static void acpi_os_execute_deferred(struct work_struct *work) 829 { 830 struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work); 831 832 dpc->function(dpc->context); 833 kfree(dpc); 834 } 835 836 #ifdef CONFIG_ACPI_DEBUGGER 837 static struct acpi_debugger acpi_debugger; 838 static bool acpi_debugger_initialized; 839 840 int acpi_register_debugger(struct module *owner, 841 const struct acpi_debugger_ops *ops) 842 { 843 int ret = 0; 844 845 mutex_lock(&acpi_debugger.lock); 846 if (acpi_debugger.ops) { 847 ret = -EBUSY; 848 goto err_lock; 849 } 850 851 acpi_debugger.owner = owner; 852 acpi_debugger.ops = ops; 853 854 err_lock: 855 mutex_unlock(&acpi_debugger.lock); 856 return ret; 857 } 858 EXPORT_SYMBOL(acpi_register_debugger); 859 860 void acpi_unregister_debugger(const struct acpi_debugger_ops *ops) 861 { 862 mutex_lock(&acpi_debugger.lock); 863 if (ops == acpi_debugger.ops) { 864 acpi_debugger.ops = NULL; 865 acpi_debugger.owner = NULL; 866 } 867 mutex_unlock(&acpi_debugger.lock); 868 } 869 EXPORT_SYMBOL(acpi_unregister_debugger); 870 871 int acpi_debugger_create_thread(acpi_osd_exec_callback function, void *context) 872 { 873 int ret; 874 int (*func)(acpi_osd_exec_callback, void *); 875 struct module *owner; 876 877 if (!acpi_debugger_initialized) 878 return -ENODEV; 879 mutex_lock(&acpi_debugger.lock); 880 if (!acpi_debugger.ops) { 881 ret = -ENODEV; 882 goto err_lock; 883 } 884 if (!try_module_get(acpi_debugger.owner)) { 885 ret = -ENODEV; 886 goto err_lock; 887 } 888 func = acpi_debugger.ops->create_thread; 889 owner = acpi_debugger.owner; 890 mutex_unlock(&acpi_debugger.lock); 891 892 ret = func(function, context); 893 894 mutex_lock(&acpi_debugger.lock); 895 module_put(owner); 896 err_lock: 897 mutex_unlock(&acpi_debugger.lock); 898 return ret; 899 } 900 901 ssize_t acpi_debugger_write_log(const char *msg) 902 { 903 ssize_t ret; 904 ssize_t (*func)(const char *); 905 struct module *owner; 906 907 if (!acpi_debugger_initialized) 908 return -ENODEV; 909 mutex_lock(&acpi_debugger.lock); 910 if (!acpi_debugger.ops) { 911 ret = -ENODEV; 912 goto err_lock; 913 } 914 if (!try_module_get(acpi_debugger.owner)) { 915 ret = -ENODEV; 916 goto err_lock; 917 } 918 func = acpi_debugger.ops->write_log; 919 owner = acpi_debugger.owner; 920 mutex_unlock(&acpi_debugger.lock); 921 922 ret = func(msg); 923 924 mutex_lock(&acpi_debugger.lock); 925 module_put(owner); 926 err_lock: 927 mutex_unlock(&acpi_debugger.lock); 928 return ret; 929 } 930 931 ssize_t acpi_debugger_read_cmd(char *buffer, size_t buffer_length) 932 { 933 ssize_t ret; 934 ssize_t (*func)(char *, size_t); 935 struct module *owner; 936 937 if (!acpi_debugger_initialized) 938 return -ENODEV; 939 mutex_lock(&acpi_debugger.lock); 940 if (!acpi_debugger.ops) { 941 ret = -ENODEV; 942 goto err_lock; 943 } 944 if (!try_module_get(acpi_debugger.owner)) { 945 ret = -ENODEV; 946 goto err_lock; 947 } 948 func = acpi_debugger.ops->read_cmd; 949 owner = acpi_debugger.owner; 950 mutex_unlock(&acpi_debugger.lock); 951 952 ret = func(buffer, buffer_length); 953 954 mutex_lock(&acpi_debugger.lock); 955 module_put(owner); 956 err_lock: 957 mutex_unlock(&acpi_debugger.lock); 958 return ret; 959 } 960 961 int acpi_debugger_wait_command_ready(void) 962 { 963 int ret; 964 int (*func)(bool, char *, size_t); 965 struct module *owner; 966 967 if (!acpi_debugger_initialized) 968 return -ENODEV; 969 mutex_lock(&acpi_debugger.lock); 970 if (!acpi_debugger.ops) { 971 ret = -ENODEV; 972 goto err_lock; 973 } 974 if (!try_module_get(acpi_debugger.owner)) { 975 ret = -ENODEV; 976 goto err_lock; 977 } 978 func = acpi_debugger.ops->wait_command_ready; 979 owner = acpi_debugger.owner; 980 mutex_unlock(&acpi_debugger.lock); 981 982 ret = func(acpi_gbl_method_executing, 983 acpi_gbl_db_line_buf, ACPI_DB_LINE_BUFFER_SIZE); 984 985 mutex_lock(&acpi_debugger.lock); 986 module_put(owner); 987 err_lock: 988 mutex_unlock(&acpi_debugger.lock); 989 return ret; 990 } 991 992 int acpi_debugger_notify_command_complete(void) 993 { 994 int ret; 995 int (*func)(void); 996 struct module *owner; 997 998 if (!acpi_debugger_initialized) 999 return -ENODEV; 1000 mutex_lock(&acpi_debugger.lock); 1001 if (!acpi_debugger.ops) { 1002 ret = -ENODEV; 1003 goto err_lock; 1004 } 1005 if (!try_module_get(acpi_debugger.owner)) { 1006 ret = -ENODEV; 1007 goto err_lock; 1008 } 1009 func = acpi_debugger.ops->notify_command_complete; 1010 owner = acpi_debugger.owner; 1011 mutex_unlock(&acpi_debugger.lock); 1012 1013 ret = func(); 1014 1015 mutex_lock(&acpi_debugger.lock); 1016 module_put(owner); 1017 err_lock: 1018 mutex_unlock(&acpi_debugger.lock); 1019 return ret; 1020 } 1021 1022 int __init acpi_debugger_init(void) 1023 { 1024 mutex_init(&acpi_debugger.lock); 1025 acpi_debugger_initialized = true; 1026 return 0; 1027 } 1028 #endif 1029 1030 /******************************************************************************* 1031 * 1032 * FUNCTION: acpi_os_execute 1033 * 1034 * PARAMETERS: Type - Type of the callback 1035 * Function - Function to be executed 1036 * Context - Function parameters 1037 * 1038 * RETURN: Status 1039 * 1040 * DESCRIPTION: Depending on type, either queues function for deferred execution or 1041 * immediately executes function on a separate thread. 1042 * 1043 ******************************************************************************/ 1044 1045 acpi_status acpi_os_execute(acpi_execute_type type, 1046 acpi_osd_exec_callback function, void *context) 1047 { 1048 acpi_status status = AE_OK; 1049 struct acpi_os_dpc *dpc; 1050 struct workqueue_struct *queue; 1051 int ret; 1052 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 1053 "Scheduling function [%p(%p)] for deferred execution.\n", 1054 function, context)); 1055 1056 if (type == OSL_DEBUGGER_MAIN_THREAD) { 1057 ret = acpi_debugger_create_thread(function, context); 1058 if (ret) { 1059 pr_err("Call to kthread_create() failed.\n"); 1060 status = AE_ERROR; 1061 } 1062 goto out_thread; 1063 } 1064 1065 /* 1066 * Allocate/initialize DPC structure. Note that this memory will be 1067 * freed by the callee. The kernel handles the work_struct list in a 1068 * way that allows us to also free its memory inside the callee. 1069 * Because we may want to schedule several tasks with different 1070 * parameters we can't use the approach some kernel code uses of 1071 * having a static work_struct. 1072 */ 1073 1074 dpc = kzalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC); 1075 if (!dpc) 1076 return AE_NO_MEMORY; 1077 1078 dpc->function = function; 1079 dpc->context = context; 1080 1081 /* 1082 * To prevent lockdep from complaining unnecessarily, make sure that 1083 * there is a different static lockdep key for each workqueue by using 1084 * INIT_WORK() for each of them separately. 1085 */ 1086 if (type == OSL_NOTIFY_HANDLER) { 1087 queue = kacpi_notify_wq; 1088 INIT_WORK(&dpc->work, acpi_os_execute_deferred); 1089 } else if (type == OSL_GPE_HANDLER) { 1090 queue = kacpid_wq; 1091 INIT_WORK(&dpc->work, acpi_os_execute_deferred); 1092 } else { 1093 pr_err("Unsupported os_execute type %d.\n", type); 1094 status = AE_ERROR; 1095 } 1096 1097 if (ACPI_FAILURE(status)) 1098 goto err_workqueue; 1099 1100 /* 1101 * On some machines, a software-initiated SMI causes corruption unless 1102 * the SMI runs on CPU 0. An SMI can be initiated by any AML, but 1103 * typically it's done in GPE-related methods that are run via 1104 * workqueues, so we can avoid the known corruption cases by always 1105 * queueing on CPU 0. 1106 */ 1107 ret = queue_work_on(0, queue, &dpc->work); 1108 if (!ret) { 1109 printk(KERN_ERR PREFIX 1110 "Call to queue_work() failed.\n"); 1111 status = AE_ERROR; 1112 } 1113 err_workqueue: 1114 if (ACPI_FAILURE(status)) 1115 kfree(dpc); 1116 out_thread: 1117 return status; 1118 } 1119 EXPORT_SYMBOL(acpi_os_execute); 1120 1121 void acpi_os_wait_events_complete(void) 1122 { 1123 /* 1124 * Make sure the GPE handler or the fixed event handler is not used 1125 * on another CPU after removal. 1126 */ 1127 if (acpi_sci_irq_valid()) 1128 synchronize_hardirq(acpi_sci_irq); 1129 flush_workqueue(kacpid_wq); 1130 flush_workqueue(kacpi_notify_wq); 1131 } 1132 1133 struct acpi_hp_work { 1134 struct work_struct work; 1135 struct acpi_device *adev; 1136 u32 src; 1137 }; 1138 1139 static void acpi_hotplug_work_fn(struct work_struct *work) 1140 { 1141 struct acpi_hp_work *hpw = container_of(work, struct acpi_hp_work, work); 1142 1143 acpi_os_wait_events_complete(); 1144 acpi_device_hotplug(hpw->adev, hpw->src); 1145 kfree(hpw); 1146 } 1147 1148 acpi_status acpi_hotplug_schedule(struct acpi_device *adev, u32 src) 1149 { 1150 struct acpi_hp_work *hpw; 1151 1152 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 1153 "Scheduling hotplug event (%p, %u) for deferred execution.\n", 1154 adev, src)); 1155 1156 hpw = kmalloc(sizeof(*hpw), GFP_KERNEL); 1157 if (!hpw) 1158 return AE_NO_MEMORY; 1159 1160 INIT_WORK(&hpw->work, acpi_hotplug_work_fn); 1161 hpw->adev = adev; 1162 hpw->src = src; 1163 /* 1164 * We can't run hotplug code in kacpid_wq/kacpid_notify_wq etc., because 1165 * the hotplug code may call driver .remove() functions, which may 1166 * invoke flush_scheduled_work()/acpi_os_wait_events_complete() to flush 1167 * these workqueues. 1168 */ 1169 if (!queue_work(kacpi_hotplug_wq, &hpw->work)) { 1170 kfree(hpw); 1171 return AE_ERROR; 1172 } 1173 return AE_OK; 1174 } 1175 1176 bool acpi_queue_hotplug_work(struct work_struct *work) 1177 { 1178 return queue_work(kacpi_hotplug_wq, work); 1179 } 1180 1181 acpi_status 1182 acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle) 1183 { 1184 struct semaphore *sem = NULL; 1185 1186 sem = acpi_os_allocate_zeroed(sizeof(struct semaphore)); 1187 if (!sem) 1188 return AE_NO_MEMORY; 1189 1190 sema_init(sem, initial_units); 1191 1192 *handle = (acpi_handle *) sem; 1193 1194 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n", 1195 *handle, initial_units)); 1196 1197 return AE_OK; 1198 } 1199 1200 /* 1201 * TODO: A better way to delete semaphores? Linux doesn't have a 1202 * 'delete_semaphore()' function -- may result in an invalid 1203 * pointer dereference for non-synchronized consumers. Should 1204 * we at least check for blocked threads and signal/cancel them? 1205 */ 1206 1207 acpi_status acpi_os_delete_semaphore(acpi_handle handle) 1208 { 1209 struct semaphore *sem = (struct semaphore *)handle; 1210 1211 if (!sem) 1212 return AE_BAD_PARAMETER; 1213 1214 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle)); 1215 1216 BUG_ON(!list_empty(&sem->wait_list)); 1217 kfree(sem); 1218 sem = NULL; 1219 1220 return AE_OK; 1221 } 1222 1223 /* 1224 * TODO: Support for units > 1? 1225 */ 1226 acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout) 1227 { 1228 acpi_status status = AE_OK; 1229 struct semaphore *sem = (struct semaphore *)handle; 1230 long jiffies; 1231 int ret = 0; 1232 1233 if (!acpi_os_initialized) 1234 return AE_OK; 1235 1236 if (!sem || (units < 1)) 1237 return AE_BAD_PARAMETER; 1238 1239 if (units > 1) 1240 return AE_SUPPORT; 1241 1242 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n", 1243 handle, units, timeout)); 1244 1245 if (timeout == ACPI_WAIT_FOREVER) 1246 jiffies = MAX_SCHEDULE_TIMEOUT; 1247 else 1248 jiffies = msecs_to_jiffies(timeout); 1249 1250 ret = down_timeout(sem, jiffies); 1251 if (ret) 1252 status = AE_TIME; 1253 1254 if (ACPI_FAILURE(status)) { 1255 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, 1256 "Failed to acquire semaphore[%p|%d|%d], %s", 1257 handle, units, timeout, 1258 acpi_format_exception(status))); 1259 } else { 1260 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, 1261 "Acquired semaphore[%p|%d|%d]", handle, 1262 units, timeout)); 1263 } 1264 1265 return status; 1266 } 1267 1268 /* 1269 * TODO: Support for units > 1? 1270 */ 1271 acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units) 1272 { 1273 struct semaphore *sem = (struct semaphore *)handle; 1274 1275 if (!acpi_os_initialized) 1276 return AE_OK; 1277 1278 if (!sem || (units < 1)) 1279 return AE_BAD_PARAMETER; 1280 1281 if (units > 1) 1282 return AE_SUPPORT; 1283 1284 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle, 1285 units)); 1286 1287 up(sem); 1288 1289 return AE_OK; 1290 } 1291 1292 acpi_status acpi_os_get_line(char *buffer, u32 buffer_length, u32 *bytes_read) 1293 { 1294 #ifdef ENABLE_DEBUGGER 1295 if (acpi_in_debugger) { 1296 u32 chars; 1297 1298 kdb_read(buffer, buffer_length); 1299 1300 /* remove the CR kdb includes */ 1301 chars = strlen(buffer) - 1; 1302 buffer[chars] = '\0'; 1303 } 1304 #else 1305 int ret; 1306 1307 ret = acpi_debugger_read_cmd(buffer, buffer_length); 1308 if (ret < 0) 1309 return AE_ERROR; 1310 if (bytes_read) 1311 *bytes_read = ret; 1312 #endif 1313 1314 return AE_OK; 1315 } 1316 EXPORT_SYMBOL(acpi_os_get_line); 1317 1318 acpi_status acpi_os_wait_command_ready(void) 1319 { 1320 int ret; 1321 1322 ret = acpi_debugger_wait_command_ready(); 1323 if (ret < 0) 1324 return AE_ERROR; 1325 return AE_OK; 1326 } 1327 1328 acpi_status acpi_os_notify_command_complete(void) 1329 { 1330 int ret; 1331 1332 ret = acpi_debugger_notify_command_complete(); 1333 if (ret < 0) 1334 return AE_ERROR; 1335 return AE_OK; 1336 } 1337 1338 acpi_status acpi_os_signal(u32 function, void *info) 1339 { 1340 switch (function) { 1341 case ACPI_SIGNAL_FATAL: 1342 printk(KERN_ERR PREFIX "Fatal opcode executed\n"); 1343 break; 1344 case ACPI_SIGNAL_BREAKPOINT: 1345 /* 1346 * AML Breakpoint 1347 * ACPI spec. says to treat it as a NOP unless 1348 * you are debugging. So if/when we integrate 1349 * AML debugger into the kernel debugger its 1350 * hook will go here. But until then it is 1351 * not useful to print anything on breakpoints. 1352 */ 1353 break; 1354 default: 1355 break; 1356 } 1357 1358 return AE_OK; 1359 } 1360 1361 static int __init acpi_os_name_setup(char *str) 1362 { 1363 char *p = acpi_os_name; 1364 int count = ACPI_MAX_OVERRIDE_LEN - 1; 1365 1366 if (!str || !*str) 1367 return 0; 1368 1369 for (; count-- && *str; str++) { 1370 if (isalnum(*str) || *str == ' ' || *str == ':') 1371 *p++ = *str; 1372 else if (*str == '\'' || *str == '"') 1373 continue; 1374 else 1375 break; 1376 } 1377 *p = 0; 1378 1379 return 1; 1380 1381 } 1382 1383 __setup("acpi_os_name=", acpi_os_name_setup); 1384 1385 /* 1386 * Disable the auto-serialization of named objects creation methods. 1387 * 1388 * This feature is enabled by default. It marks the AML control methods 1389 * that contain the opcodes to create named objects as "Serialized". 1390 */ 1391 static int __init acpi_no_auto_serialize_setup(char *str) 1392 { 1393 acpi_gbl_auto_serialize_methods = FALSE; 1394 pr_info("ACPI: auto-serialization disabled\n"); 1395 1396 return 1; 1397 } 1398 1399 __setup("acpi_no_auto_serialize", acpi_no_auto_serialize_setup); 1400 1401 /* Check of resource interference between native drivers and ACPI 1402 * OperationRegions (SystemIO and System Memory only). 1403 * IO ports and memory declared in ACPI might be used by the ACPI subsystem 1404 * in arbitrary AML code and can interfere with legacy drivers. 1405 * acpi_enforce_resources= can be set to: 1406 * 1407 * - strict (default) (2) 1408 * -> further driver trying to access the resources will not load 1409 * - lax (1) 1410 * -> further driver trying to access the resources will load, but you 1411 * get a system message that something might go wrong... 1412 * 1413 * - no (0) 1414 * -> ACPI Operation Region resources will not be registered 1415 * 1416 */ 1417 #define ENFORCE_RESOURCES_STRICT 2 1418 #define ENFORCE_RESOURCES_LAX 1 1419 #define ENFORCE_RESOURCES_NO 0 1420 1421 static unsigned int acpi_enforce_resources = ENFORCE_RESOURCES_STRICT; 1422 1423 static int __init acpi_enforce_resources_setup(char *str) 1424 { 1425 if (str == NULL || *str == '\0') 1426 return 0; 1427 1428 if (!strcmp("strict", str)) 1429 acpi_enforce_resources = ENFORCE_RESOURCES_STRICT; 1430 else if (!strcmp("lax", str)) 1431 acpi_enforce_resources = ENFORCE_RESOURCES_LAX; 1432 else if (!strcmp("no", str)) 1433 acpi_enforce_resources = ENFORCE_RESOURCES_NO; 1434 1435 return 1; 1436 } 1437 1438 __setup("acpi_enforce_resources=", acpi_enforce_resources_setup); 1439 1440 /* Check for resource conflicts between ACPI OperationRegions and native 1441 * drivers */ 1442 int acpi_check_resource_conflict(const struct resource *res) 1443 { 1444 acpi_adr_space_type space_id; 1445 acpi_size length; 1446 u8 warn = 0; 1447 int clash = 0; 1448 1449 if (acpi_enforce_resources == ENFORCE_RESOURCES_NO) 1450 return 0; 1451 if (!(res->flags & IORESOURCE_IO) && !(res->flags & IORESOURCE_MEM)) 1452 return 0; 1453 1454 if (res->flags & IORESOURCE_IO) 1455 space_id = ACPI_ADR_SPACE_SYSTEM_IO; 1456 else 1457 space_id = ACPI_ADR_SPACE_SYSTEM_MEMORY; 1458 1459 length = resource_size(res); 1460 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO) 1461 warn = 1; 1462 clash = acpi_check_address_range(space_id, res->start, length, warn); 1463 1464 if (clash) { 1465 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO) { 1466 if (acpi_enforce_resources == ENFORCE_RESOURCES_LAX) 1467 printk(KERN_NOTICE "ACPI: This conflict may" 1468 " cause random problems and system" 1469 " instability\n"); 1470 printk(KERN_INFO "ACPI: If an ACPI driver is available" 1471 " for this device, you should use it instead of" 1472 " the native driver\n"); 1473 } 1474 if (acpi_enforce_resources == ENFORCE_RESOURCES_STRICT) 1475 return -EBUSY; 1476 } 1477 return 0; 1478 } 1479 EXPORT_SYMBOL(acpi_check_resource_conflict); 1480 1481 int acpi_check_region(resource_size_t start, resource_size_t n, 1482 const char *name) 1483 { 1484 struct resource res = { 1485 .start = start, 1486 .end = start + n - 1, 1487 .name = name, 1488 .flags = IORESOURCE_IO, 1489 }; 1490 1491 return acpi_check_resource_conflict(&res); 1492 } 1493 EXPORT_SYMBOL(acpi_check_region); 1494 1495 static acpi_status acpi_deactivate_mem_region(acpi_handle handle, u32 level, 1496 void *_res, void **return_value) 1497 { 1498 struct acpi_mem_space_context **mem_ctx; 1499 union acpi_operand_object *handler_obj; 1500 union acpi_operand_object *region_obj2; 1501 union acpi_operand_object *region_obj; 1502 struct resource *res = _res; 1503 acpi_status status; 1504 1505 region_obj = acpi_ns_get_attached_object(handle); 1506 if (!region_obj) 1507 return AE_OK; 1508 1509 handler_obj = region_obj->region.handler; 1510 if (!handler_obj) 1511 return AE_OK; 1512 1513 if (region_obj->region.space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) 1514 return AE_OK; 1515 1516 if (!(region_obj->region.flags & AOPOBJ_SETUP_COMPLETE)) 1517 return AE_OK; 1518 1519 region_obj2 = acpi_ns_get_secondary_object(region_obj); 1520 if (!region_obj2) 1521 return AE_OK; 1522 1523 mem_ctx = (void *)®ion_obj2->extra.region_context; 1524 1525 if (!(mem_ctx[0]->address >= res->start && 1526 mem_ctx[0]->address < res->end)) 1527 return AE_OK; 1528 1529 status = handler_obj->address_space.setup(region_obj, 1530 ACPI_REGION_DEACTIVATE, 1531 NULL, (void **)mem_ctx); 1532 if (ACPI_SUCCESS(status)) 1533 region_obj->region.flags &= ~(AOPOBJ_SETUP_COMPLETE); 1534 1535 return status; 1536 } 1537 1538 /** 1539 * acpi_release_memory - Release any mappings done to a memory region 1540 * @handle: Handle to namespace node 1541 * @res: Memory resource 1542 * @level: A level that terminates the search 1543 * 1544 * Walks through @handle and unmaps all SystemMemory Operation Regions that 1545 * overlap with @res and that have already been activated (mapped). 1546 * 1547 * This is a helper that allows drivers to place special requirements on memory 1548 * region that may overlap with operation regions, primarily allowing them to 1549 * safely map the region as non-cached memory. 1550 * 1551 * The unmapped Operation Regions will be automatically remapped next time they 1552 * are called, so the drivers do not need to do anything else. 1553 */ 1554 acpi_status acpi_release_memory(acpi_handle handle, struct resource *res, 1555 u32 level) 1556 { 1557 if (!(res->flags & IORESOURCE_MEM)) 1558 return AE_TYPE; 1559 1560 return acpi_walk_namespace(ACPI_TYPE_REGION, handle, level, 1561 acpi_deactivate_mem_region, NULL, res, NULL); 1562 } 1563 EXPORT_SYMBOL_GPL(acpi_release_memory); 1564 1565 /* 1566 * Let drivers know whether the resource checks are effective 1567 */ 1568 int acpi_resources_are_enforced(void) 1569 { 1570 return acpi_enforce_resources == ENFORCE_RESOURCES_STRICT; 1571 } 1572 EXPORT_SYMBOL(acpi_resources_are_enforced); 1573 1574 /* 1575 * Deallocate the memory for a spinlock. 1576 */ 1577 void acpi_os_delete_lock(acpi_spinlock handle) 1578 { 1579 ACPI_FREE(handle); 1580 } 1581 1582 /* 1583 * Acquire a spinlock. 1584 * 1585 * handle is a pointer to the spinlock_t. 1586 */ 1587 1588 acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp) 1589 { 1590 acpi_cpu_flags flags; 1591 spin_lock_irqsave(lockp, flags); 1592 return flags; 1593 } 1594 1595 /* 1596 * Release a spinlock. See above. 1597 */ 1598 1599 void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags) 1600 { 1601 spin_unlock_irqrestore(lockp, flags); 1602 } 1603 1604 #ifndef ACPI_USE_LOCAL_CACHE 1605 1606 /******************************************************************************* 1607 * 1608 * FUNCTION: acpi_os_create_cache 1609 * 1610 * PARAMETERS: name - Ascii name for the cache 1611 * size - Size of each cached object 1612 * depth - Maximum depth of the cache (in objects) <ignored> 1613 * cache - Where the new cache object is returned 1614 * 1615 * RETURN: status 1616 * 1617 * DESCRIPTION: Create a cache object 1618 * 1619 ******************************************************************************/ 1620 1621 acpi_status 1622 acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache) 1623 { 1624 *cache = kmem_cache_create(name, size, 0, 0, NULL); 1625 if (*cache == NULL) 1626 return AE_ERROR; 1627 else 1628 return AE_OK; 1629 } 1630 1631 /******************************************************************************* 1632 * 1633 * FUNCTION: acpi_os_purge_cache 1634 * 1635 * PARAMETERS: Cache - Handle to cache object 1636 * 1637 * RETURN: Status 1638 * 1639 * DESCRIPTION: Free all objects within the requested cache. 1640 * 1641 ******************************************************************************/ 1642 1643 acpi_status acpi_os_purge_cache(acpi_cache_t * cache) 1644 { 1645 kmem_cache_shrink(cache); 1646 return (AE_OK); 1647 } 1648 1649 /******************************************************************************* 1650 * 1651 * FUNCTION: acpi_os_delete_cache 1652 * 1653 * PARAMETERS: Cache - Handle to cache object 1654 * 1655 * RETURN: Status 1656 * 1657 * DESCRIPTION: Free all objects within the requested cache and delete the 1658 * cache object. 1659 * 1660 ******************************************************************************/ 1661 1662 acpi_status acpi_os_delete_cache(acpi_cache_t * cache) 1663 { 1664 kmem_cache_destroy(cache); 1665 return (AE_OK); 1666 } 1667 1668 /******************************************************************************* 1669 * 1670 * FUNCTION: acpi_os_release_object 1671 * 1672 * PARAMETERS: Cache - Handle to cache object 1673 * Object - The object to be released 1674 * 1675 * RETURN: None 1676 * 1677 * DESCRIPTION: Release an object to the specified cache. If cache is full, 1678 * the object is deleted. 1679 * 1680 ******************************************************************************/ 1681 1682 acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object) 1683 { 1684 kmem_cache_free(cache, object); 1685 return (AE_OK); 1686 } 1687 #endif 1688 1689 static int __init acpi_no_static_ssdt_setup(char *s) 1690 { 1691 acpi_gbl_disable_ssdt_table_install = TRUE; 1692 pr_info("ACPI: static SSDT installation disabled\n"); 1693 1694 return 0; 1695 } 1696 1697 early_param("acpi_no_static_ssdt", acpi_no_static_ssdt_setup); 1698 1699 static int __init acpi_disable_return_repair(char *s) 1700 { 1701 printk(KERN_NOTICE PREFIX 1702 "ACPI: Predefined validation mechanism disabled\n"); 1703 acpi_gbl_disable_auto_repair = TRUE; 1704 1705 return 1; 1706 } 1707 1708 __setup("acpica_no_return_repair", acpi_disable_return_repair); 1709 1710 acpi_status __init acpi_os_initialize(void) 1711 { 1712 acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1a_event_block); 1713 acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1b_event_block); 1714 acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe0_block); 1715 acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe1_block); 1716 if (acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER) { 1717 /* 1718 * Use acpi_os_map_generic_address to pre-map the reset 1719 * register if it's in system memory. 1720 */ 1721 int rv; 1722 1723 rv = acpi_os_map_generic_address(&acpi_gbl_FADT.reset_register); 1724 pr_debug(PREFIX "%s: map reset_reg status %d\n", __func__, rv); 1725 } 1726 acpi_os_initialized = true; 1727 1728 return AE_OK; 1729 } 1730 1731 acpi_status __init acpi_os_initialize1(void) 1732 { 1733 kacpid_wq = alloc_workqueue("kacpid", 0, 1); 1734 kacpi_notify_wq = alloc_workqueue("kacpi_notify", 0, 1); 1735 kacpi_hotplug_wq = alloc_ordered_workqueue("kacpi_hotplug", 0); 1736 BUG_ON(!kacpid_wq); 1737 BUG_ON(!kacpi_notify_wq); 1738 BUG_ON(!kacpi_hotplug_wq); 1739 acpi_osi_init(); 1740 return AE_OK; 1741 } 1742 1743 acpi_status acpi_os_terminate(void) 1744 { 1745 if (acpi_irq_handler) { 1746 acpi_os_remove_interrupt_handler(acpi_gbl_FADT.sci_interrupt, 1747 acpi_irq_handler); 1748 } 1749 1750 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe1_block); 1751 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe0_block); 1752 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1b_event_block); 1753 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1a_event_block); 1754 if (acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER) 1755 acpi_os_unmap_generic_address(&acpi_gbl_FADT.reset_register); 1756 1757 destroy_workqueue(kacpid_wq); 1758 destroy_workqueue(kacpi_notify_wq); 1759 destroy_workqueue(kacpi_hotplug_wq); 1760 1761 return AE_OK; 1762 } 1763 1764 acpi_status acpi_os_prepare_sleep(u8 sleep_state, u32 pm1a_control, 1765 u32 pm1b_control) 1766 { 1767 int rc = 0; 1768 if (__acpi_os_prepare_sleep) 1769 rc = __acpi_os_prepare_sleep(sleep_state, 1770 pm1a_control, pm1b_control); 1771 if (rc < 0) 1772 return AE_ERROR; 1773 else if (rc > 0) 1774 return AE_CTRL_TERMINATE; 1775 1776 return AE_OK; 1777 } 1778 1779 void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state, 1780 u32 pm1a_ctrl, u32 pm1b_ctrl)) 1781 { 1782 __acpi_os_prepare_sleep = func; 1783 } 1784 1785 #if (ACPI_REDUCED_HARDWARE) 1786 acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state, u32 val_a, 1787 u32 val_b) 1788 { 1789 int rc = 0; 1790 if (__acpi_os_prepare_extended_sleep) 1791 rc = __acpi_os_prepare_extended_sleep(sleep_state, 1792 val_a, val_b); 1793 if (rc < 0) 1794 return AE_ERROR; 1795 else if (rc > 0) 1796 return AE_CTRL_TERMINATE; 1797 1798 return AE_OK; 1799 } 1800 #else 1801 acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state, u32 val_a, 1802 u32 val_b) 1803 { 1804 return AE_OK; 1805 } 1806 #endif 1807 1808 void acpi_os_set_prepare_extended_sleep(int (*func)(u8 sleep_state, 1809 u32 val_a, u32 val_b)) 1810 { 1811 __acpi_os_prepare_extended_sleep = func; 1812 } 1813 1814 acpi_status acpi_os_enter_sleep(u8 sleep_state, 1815 u32 reg_a_value, u32 reg_b_value) 1816 { 1817 acpi_status status; 1818 1819 if (acpi_gbl_reduced_hardware) 1820 status = acpi_os_prepare_extended_sleep(sleep_state, 1821 reg_a_value, 1822 reg_b_value); 1823 else 1824 status = acpi_os_prepare_sleep(sleep_state, 1825 reg_a_value, reg_b_value); 1826 return status; 1827 } 1828