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