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