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