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 * 8 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 23 * 24 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 25 * 26 */ 27 28 #include <linux/config.h> 29 #include <linux/module.h> 30 #include <linux/kernel.h> 31 #include <linux/slab.h> 32 #include <linux/mm.h> 33 #include <linux/pci.h> 34 #include <linux/smp_lock.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/kthread.h> 41 #include <acpi/acpi.h> 42 #include <asm/io.h> 43 #include <acpi/acpi_bus.h> 44 #include <acpi/processor.h> 45 #include <asm/uaccess.h> 46 47 #include <linux/efi.h> 48 49 #define _COMPONENT ACPI_OS_SERVICES 50 ACPI_MODULE_NAME("osl") 51 #define PREFIX "ACPI: " 52 struct acpi_os_dpc { 53 acpi_osd_exec_callback function; 54 void *context; 55 }; 56 57 #ifdef CONFIG_ACPI_CUSTOM_DSDT 58 #include CONFIG_ACPI_CUSTOM_DSDT_FILE 59 #endif 60 61 #ifdef ENABLE_DEBUGGER 62 #include <linux/kdb.h> 63 64 /* stuff for debugger support */ 65 int acpi_in_debugger; 66 EXPORT_SYMBOL(acpi_in_debugger); 67 68 extern char line_buf[80]; 69 #endif /*ENABLE_DEBUGGER */ 70 71 int acpi_specific_hotkey_enabled = TRUE; 72 EXPORT_SYMBOL(acpi_specific_hotkey_enabled); 73 74 static unsigned int acpi_irq_irq; 75 static acpi_osd_handler acpi_irq_handler; 76 static void *acpi_irq_context; 77 static struct workqueue_struct *kacpid_wq; 78 79 acpi_status acpi_os_initialize(void) 80 { 81 return AE_OK; 82 } 83 84 acpi_status acpi_os_initialize1(void) 85 { 86 /* 87 * Initialize PCI configuration space access, as we'll need to access 88 * it while walking the namespace (bus 0 and root bridges w/ _BBNs). 89 */ 90 if (!raw_pci_ops) { 91 printk(KERN_ERR PREFIX 92 "Access to PCI configuration space unavailable\n"); 93 return AE_NULL_ENTRY; 94 } 95 kacpid_wq = create_singlethread_workqueue("kacpid"); 96 BUG_ON(!kacpid_wq); 97 98 return AE_OK; 99 } 100 101 acpi_status acpi_os_terminate(void) 102 { 103 if (acpi_irq_handler) { 104 acpi_os_remove_interrupt_handler(acpi_irq_irq, 105 acpi_irq_handler); 106 } 107 108 destroy_workqueue(kacpid_wq); 109 110 return AE_OK; 111 } 112 113 void acpi_os_printf(const char *fmt, ...) 114 { 115 va_list args; 116 va_start(args, fmt); 117 acpi_os_vprintf(fmt, args); 118 va_end(args); 119 } 120 121 EXPORT_SYMBOL(acpi_os_printf); 122 123 void acpi_os_vprintf(const char *fmt, va_list args) 124 { 125 static char buffer[512]; 126 127 vsprintf(buffer, fmt, args); 128 129 #ifdef ENABLE_DEBUGGER 130 if (acpi_in_debugger) { 131 kdb_printf("%s", buffer); 132 } else { 133 printk("%s", buffer); 134 } 135 #else 136 printk("%s", buffer); 137 #endif 138 } 139 140 extern int acpi_in_resume; 141 void *acpi_os_allocate(acpi_size size) 142 { 143 if (acpi_in_resume) 144 return kmalloc(size, GFP_ATOMIC); 145 else 146 return kmalloc(size, GFP_KERNEL); 147 } 148 149 void acpi_os_free(void *ptr) 150 { 151 kfree(ptr); 152 } 153 154 EXPORT_SYMBOL(acpi_os_free); 155 156 acpi_status acpi_os_get_root_pointer(u32 flags, struct acpi_pointer *addr) 157 { 158 if (efi_enabled) { 159 addr->pointer_type = ACPI_PHYSICAL_POINTER; 160 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR) 161 addr->pointer.physical = efi.acpi20; 162 else if (efi.acpi != EFI_INVALID_TABLE_ADDR) 163 addr->pointer.physical = efi.acpi; 164 else { 165 printk(KERN_ERR PREFIX 166 "System description tables not found\n"); 167 return AE_NOT_FOUND; 168 } 169 } else { 170 if (ACPI_FAILURE(acpi_find_root_pointer(flags, addr))) { 171 printk(KERN_ERR PREFIX 172 "System description tables not found\n"); 173 return AE_NOT_FOUND; 174 } 175 } 176 177 return AE_OK; 178 } 179 180 acpi_status 181 acpi_os_map_memory(acpi_physical_address phys, acpi_size size, 182 void __iomem ** virt) 183 { 184 if (phys > ULONG_MAX) { 185 printk(KERN_ERR PREFIX "Cannot map memory that high\n"); 186 return AE_BAD_PARAMETER; 187 } 188 /* 189 * ioremap checks to ensure this is in reserved space 190 */ 191 *virt = ioremap((unsigned long)phys, size); 192 193 if (!*virt) 194 return AE_NO_MEMORY; 195 196 return AE_OK; 197 } 198 EXPORT_SYMBOL_GPL(acpi_os_map_memory); 199 200 void acpi_os_unmap_memory(void __iomem * virt, acpi_size size) 201 { 202 iounmap(virt); 203 } 204 EXPORT_SYMBOL_GPL(acpi_os_unmap_memory); 205 206 #ifdef ACPI_FUTURE_USAGE 207 acpi_status 208 acpi_os_get_physical_address(void *virt, acpi_physical_address * phys) 209 { 210 if (!phys || !virt) 211 return AE_BAD_PARAMETER; 212 213 *phys = virt_to_phys(virt); 214 215 return AE_OK; 216 } 217 #endif 218 219 #define ACPI_MAX_OVERRIDE_LEN 100 220 221 static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN]; 222 223 acpi_status 224 acpi_os_predefined_override(const struct acpi_predefined_names *init_val, 225 acpi_string * new_val) 226 { 227 if (!init_val || !new_val) 228 return AE_BAD_PARAMETER; 229 230 *new_val = NULL; 231 if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) { 232 printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n", 233 acpi_os_name); 234 *new_val = acpi_os_name; 235 } 236 237 return AE_OK; 238 } 239 240 acpi_status 241 acpi_os_table_override(struct acpi_table_header * existing_table, 242 struct acpi_table_header ** new_table) 243 { 244 if (!existing_table || !new_table) 245 return AE_BAD_PARAMETER; 246 247 #ifdef CONFIG_ACPI_CUSTOM_DSDT 248 if (strncmp(existing_table->signature, "DSDT", 4) == 0) 249 *new_table = (struct acpi_table_header *)AmlCode; 250 else 251 *new_table = NULL; 252 #else 253 *new_table = NULL; 254 #endif 255 return AE_OK; 256 } 257 258 static irqreturn_t acpi_irq(int irq, void *dev_id, struct pt_regs *regs) 259 { 260 return (*acpi_irq_handler) (acpi_irq_context) ? IRQ_HANDLED : IRQ_NONE; 261 } 262 263 acpi_status 264 acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler, 265 void *context) 266 { 267 unsigned int irq; 268 269 /* 270 * Ignore the GSI from the core, and use the value in our copy of the 271 * FADT. It may not be the same if an interrupt source override exists 272 * for the SCI. 273 */ 274 gsi = acpi_fadt.sci_int; 275 if (acpi_gsi_to_irq(gsi, &irq) < 0) { 276 printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n", 277 gsi); 278 return AE_OK; 279 } 280 281 acpi_irq_handler = handler; 282 acpi_irq_context = context; 283 if (request_irq(irq, acpi_irq, SA_SHIRQ, "acpi", acpi_irq)) { 284 printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq); 285 return AE_NOT_ACQUIRED; 286 } 287 acpi_irq_irq = irq; 288 289 return AE_OK; 290 } 291 292 acpi_status acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler) 293 { 294 if (irq) { 295 free_irq(irq, acpi_irq); 296 acpi_irq_handler = NULL; 297 acpi_irq_irq = 0; 298 } 299 300 return AE_OK; 301 } 302 303 /* 304 * Running in interpreter thread context, safe to sleep 305 */ 306 307 void acpi_os_sleep(acpi_integer ms) 308 { 309 schedule_timeout_interruptible(msecs_to_jiffies(ms)); 310 } 311 312 EXPORT_SYMBOL(acpi_os_sleep); 313 314 void acpi_os_stall(u32 us) 315 { 316 while (us) { 317 u32 delay = 1000; 318 319 if (delay > us) 320 delay = us; 321 udelay(delay); 322 touch_nmi_watchdog(); 323 us -= delay; 324 } 325 } 326 327 EXPORT_SYMBOL(acpi_os_stall); 328 329 /* 330 * Support ACPI 3.0 AML Timer operand 331 * Returns 64-bit free-running, monotonically increasing timer 332 * with 100ns granularity 333 */ 334 u64 acpi_os_get_timer(void) 335 { 336 static u64 t; 337 338 #ifdef CONFIG_HPET 339 /* TBD: use HPET if available */ 340 #endif 341 342 #ifdef CONFIG_X86_PM_TIMER 343 /* TBD: default to PM timer if HPET was not available */ 344 #endif 345 if (!t) 346 printk(KERN_ERR PREFIX "acpi_os_get_timer() TBD\n"); 347 348 return ++t; 349 } 350 351 acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width) 352 { 353 u32 dummy; 354 355 if (!value) 356 value = &dummy; 357 358 switch (width) { 359 case 8: 360 *(u8 *) value = inb(port); 361 break; 362 case 16: 363 *(u16 *) value = inw(port); 364 break; 365 case 32: 366 *(u32 *) value = inl(port); 367 break; 368 default: 369 BUG(); 370 } 371 372 return AE_OK; 373 } 374 375 EXPORT_SYMBOL(acpi_os_read_port); 376 377 acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width) 378 { 379 switch (width) { 380 case 8: 381 outb(value, port); 382 break; 383 case 16: 384 outw(value, port); 385 break; 386 case 32: 387 outl(value, port); 388 break; 389 default: 390 BUG(); 391 } 392 393 return AE_OK; 394 } 395 396 EXPORT_SYMBOL(acpi_os_write_port); 397 398 acpi_status 399 acpi_os_read_memory(acpi_physical_address phys_addr, u32 * value, u32 width) 400 { 401 u32 dummy; 402 void __iomem *virt_addr; 403 404 virt_addr = ioremap(phys_addr, width); 405 if (!value) 406 value = &dummy; 407 408 switch (width) { 409 case 8: 410 *(u8 *) value = readb(virt_addr); 411 break; 412 case 16: 413 *(u16 *) value = readw(virt_addr); 414 break; 415 case 32: 416 *(u32 *) value = readl(virt_addr); 417 break; 418 default: 419 BUG(); 420 } 421 422 iounmap(virt_addr); 423 424 return AE_OK; 425 } 426 427 acpi_status 428 acpi_os_write_memory(acpi_physical_address phys_addr, u32 value, u32 width) 429 { 430 void __iomem *virt_addr; 431 432 virt_addr = ioremap(phys_addr, width); 433 434 switch (width) { 435 case 8: 436 writeb(value, virt_addr); 437 break; 438 case 16: 439 writew(value, virt_addr); 440 break; 441 case 32: 442 writel(value, virt_addr); 443 break; 444 default: 445 BUG(); 446 } 447 448 iounmap(virt_addr); 449 450 return AE_OK; 451 } 452 453 acpi_status 454 acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg, 455 void *value, u32 width) 456 { 457 int result, size; 458 459 if (!value) 460 return AE_BAD_PARAMETER; 461 462 switch (width) { 463 case 8: 464 size = 1; 465 break; 466 case 16: 467 size = 2; 468 break; 469 case 32: 470 size = 4; 471 break; 472 default: 473 return AE_ERROR; 474 } 475 476 BUG_ON(!raw_pci_ops); 477 478 result = raw_pci_ops->read(pci_id->segment, pci_id->bus, 479 PCI_DEVFN(pci_id->device, pci_id->function), 480 reg, size, value); 481 482 return (result ? AE_ERROR : AE_OK); 483 } 484 485 EXPORT_SYMBOL(acpi_os_read_pci_configuration); 486 487 acpi_status 488 acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg, 489 acpi_integer value, u32 width) 490 { 491 int result, size; 492 493 switch (width) { 494 case 8: 495 size = 1; 496 break; 497 case 16: 498 size = 2; 499 break; 500 case 32: 501 size = 4; 502 break; 503 default: 504 return AE_ERROR; 505 } 506 507 BUG_ON(!raw_pci_ops); 508 509 result = raw_pci_ops->write(pci_id->segment, pci_id->bus, 510 PCI_DEVFN(pci_id->device, pci_id->function), 511 reg, size, value); 512 513 return (result ? AE_ERROR : AE_OK); 514 } 515 516 /* TODO: Change code to take advantage of driver model more */ 517 static void acpi_os_derive_pci_id_2(acpi_handle rhandle, /* upper bound */ 518 acpi_handle chandle, /* current node */ 519 struct acpi_pci_id **id, 520 int *is_bridge, u8 * bus_number) 521 { 522 acpi_handle handle; 523 struct acpi_pci_id *pci_id = *id; 524 acpi_status status; 525 unsigned long temp; 526 acpi_object_type type; 527 u8 tu8; 528 529 acpi_get_parent(chandle, &handle); 530 if (handle != rhandle) { 531 acpi_os_derive_pci_id_2(rhandle, handle, &pci_id, is_bridge, 532 bus_number); 533 534 status = acpi_get_type(handle, &type); 535 if ((ACPI_FAILURE(status)) || (type != ACPI_TYPE_DEVICE)) 536 return; 537 538 status = 539 acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, 540 &temp); 541 if (ACPI_SUCCESS(status)) { 542 pci_id->device = ACPI_HIWORD(ACPI_LODWORD(temp)); 543 pci_id->function = ACPI_LOWORD(ACPI_LODWORD(temp)); 544 545 if (*is_bridge) 546 pci_id->bus = *bus_number; 547 548 /* any nicer way to get bus number of bridge ? */ 549 status = 550 acpi_os_read_pci_configuration(pci_id, 0x0e, &tu8, 551 8); 552 if (ACPI_SUCCESS(status) 553 && ((tu8 & 0x7f) == 1 || (tu8 & 0x7f) == 2)) { 554 status = 555 acpi_os_read_pci_configuration(pci_id, 0x18, 556 &tu8, 8); 557 if (!ACPI_SUCCESS(status)) { 558 /* Certainly broken... FIX ME */ 559 return; 560 } 561 *is_bridge = 1; 562 pci_id->bus = tu8; 563 status = 564 acpi_os_read_pci_configuration(pci_id, 0x19, 565 &tu8, 8); 566 if (ACPI_SUCCESS(status)) { 567 *bus_number = tu8; 568 } 569 } else 570 *is_bridge = 0; 571 } 572 } 573 } 574 575 void acpi_os_derive_pci_id(acpi_handle rhandle, /* upper bound */ 576 acpi_handle chandle, /* current node */ 577 struct acpi_pci_id **id) 578 { 579 int is_bridge = 1; 580 u8 bus_number = (*id)->bus; 581 582 acpi_os_derive_pci_id_2(rhandle, chandle, id, &is_bridge, &bus_number); 583 } 584 585 static void acpi_os_execute_deferred(void *context) 586 { 587 struct acpi_os_dpc *dpc = NULL; 588 589 ACPI_FUNCTION_TRACE("os_execute_deferred"); 590 591 dpc = (struct acpi_os_dpc *)context; 592 if (!dpc) { 593 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid (NULL) context.\n")); 594 return_VOID; 595 } 596 597 dpc->function(dpc->context); 598 599 kfree(dpc); 600 601 return_VOID; 602 } 603 604 static int acpi_os_execute_thread(void *context) 605 { 606 struct acpi_os_dpc *dpc = (struct acpi_os_dpc *)context; 607 if (dpc) { 608 dpc->function(dpc->context); 609 kfree(dpc); 610 } 611 do_exit(0); 612 } 613 614 /******************************************************************************* 615 * 616 * FUNCTION: acpi_os_execute 617 * 618 * PARAMETERS: Type - Type of the callback 619 * Function - Function to be executed 620 * Context - Function parameters 621 * 622 * RETURN: Status 623 * 624 * DESCRIPTION: Depending on type, either queues function for deferred execution or 625 * immediately executes function on a separate thread. 626 * 627 ******************************************************************************/ 628 629 acpi_status acpi_os_execute(acpi_execute_type type, 630 acpi_osd_exec_callback function, void *context) 631 { 632 acpi_status status = AE_OK; 633 struct acpi_os_dpc *dpc; 634 struct work_struct *task; 635 struct task_struct *p; 636 637 if (!function) 638 return AE_BAD_PARAMETER; 639 /* 640 * Allocate/initialize DPC structure. Note that this memory will be 641 * freed by the callee. The kernel handles the tq_struct list in a 642 * way that allows us to also free its memory inside the callee. 643 * Because we may want to schedule several tasks with different 644 * parameters we can't use the approach some kernel code uses of 645 * having a static tq_struct. 646 * We can save time and code by allocating the DPC and tq_structs 647 * from the same memory. 648 */ 649 if (type == OSL_NOTIFY_HANDLER) { 650 dpc = kmalloc(sizeof(struct acpi_os_dpc), GFP_KERNEL); 651 } else { 652 dpc = kmalloc(sizeof(struct acpi_os_dpc) + 653 sizeof(struct work_struct), GFP_ATOMIC); 654 } 655 if (!dpc) 656 return AE_NO_MEMORY; 657 dpc->function = function; 658 dpc->context = context; 659 660 if (type == OSL_NOTIFY_HANDLER) { 661 p = kthread_create(acpi_os_execute_thread, dpc, "kacpid_notify"); 662 if (!IS_ERR(p)) { 663 wake_up_process(p); 664 } else { 665 status = AE_NO_MEMORY; 666 kfree(dpc); 667 } 668 } else { 669 task = (void *)(dpc + 1); 670 INIT_WORK(task, acpi_os_execute_deferred, (void *)dpc); 671 if (!queue_work(kacpid_wq, task)) { 672 status = AE_ERROR; 673 kfree(dpc); 674 } 675 } 676 return status; 677 } 678 679 EXPORT_SYMBOL(acpi_os_execute); 680 681 void acpi_os_wait_events_complete(void *context) 682 { 683 flush_workqueue(kacpid_wq); 684 } 685 686 EXPORT_SYMBOL(acpi_os_wait_events_complete); 687 688 /* 689 * Allocate the memory for a spinlock and initialize it. 690 */ 691 acpi_status acpi_os_create_lock(acpi_handle * out_handle) 692 { 693 spinlock_t *lock_ptr; 694 695 ACPI_FUNCTION_TRACE("os_create_lock"); 696 697 lock_ptr = acpi_os_allocate(sizeof(spinlock_t)); 698 699 spin_lock_init(lock_ptr); 700 701 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating spinlock[%p].\n", lock_ptr)); 702 703 *out_handle = lock_ptr; 704 705 return_ACPI_STATUS(AE_OK); 706 } 707 708 /* 709 * Deallocate the memory for a spinlock. 710 */ 711 void acpi_os_delete_lock(acpi_handle handle) 712 { 713 ACPI_FUNCTION_TRACE("os_create_lock"); 714 715 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting spinlock[%p].\n", handle)); 716 717 acpi_os_free(handle); 718 719 return_VOID; 720 } 721 722 acpi_status 723 acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle) 724 { 725 struct semaphore *sem = NULL; 726 727 ACPI_FUNCTION_TRACE("os_create_semaphore"); 728 729 sem = acpi_os_allocate(sizeof(struct semaphore)); 730 if (!sem) 731 return_ACPI_STATUS(AE_NO_MEMORY); 732 memset(sem, 0, sizeof(struct semaphore)); 733 734 sema_init(sem, initial_units); 735 736 *handle = (acpi_handle *) sem; 737 738 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n", 739 *handle, initial_units)); 740 741 return_ACPI_STATUS(AE_OK); 742 } 743 744 EXPORT_SYMBOL(acpi_os_create_semaphore); 745 746 /* 747 * TODO: A better way to delete semaphores? Linux doesn't have a 748 * 'delete_semaphore()' function -- may result in an invalid 749 * pointer dereference for non-synchronized consumers. Should 750 * we at least check for blocked threads and signal/cancel them? 751 */ 752 753 acpi_status acpi_os_delete_semaphore(acpi_handle handle) 754 { 755 struct semaphore *sem = (struct semaphore *)handle; 756 757 ACPI_FUNCTION_TRACE("os_delete_semaphore"); 758 759 if (!sem) 760 return_ACPI_STATUS(AE_BAD_PARAMETER); 761 762 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle)); 763 764 acpi_os_free(sem); 765 sem = NULL; 766 767 return_ACPI_STATUS(AE_OK); 768 } 769 770 EXPORT_SYMBOL(acpi_os_delete_semaphore); 771 772 /* 773 * TODO: The kernel doesn't have a 'down_timeout' function -- had to 774 * improvise. The process is to sleep for one scheduler quantum 775 * until the semaphore becomes available. Downside is that this 776 * may result in starvation for timeout-based waits when there's 777 * lots of semaphore activity. 778 * 779 * TODO: Support for units > 1? 780 */ 781 acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout) 782 { 783 acpi_status status = AE_OK; 784 struct semaphore *sem = (struct semaphore *)handle; 785 int ret = 0; 786 787 ACPI_FUNCTION_TRACE("os_wait_semaphore"); 788 789 if (!sem || (units < 1)) 790 return_ACPI_STATUS(AE_BAD_PARAMETER); 791 792 if (units > 1) 793 return_ACPI_STATUS(AE_SUPPORT); 794 795 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n", 796 handle, units, timeout)); 797 798 switch (timeout) { 799 /* 800 * No Wait: 801 * -------- 802 * A zero timeout value indicates that we shouldn't wait - just 803 * acquire the semaphore if available otherwise return AE_TIME 804 * (a.k.a. 'would block'). 805 */ 806 case 0: 807 if (down_trylock(sem)) 808 status = AE_TIME; 809 break; 810 811 /* 812 * Wait Indefinitely: 813 * ------------------ 814 */ 815 case ACPI_WAIT_FOREVER: 816 down(sem); 817 break; 818 819 /* 820 * Wait w/ Timeout: 821 * ---------------- 822 */ 823 default: 824 // TODO: A better timeout algorithm? 825 { 826 int i = 0; 827 static const int quantum_ms = 1000 / HZ; 828 829 ret = down_trylock(sem); 830 for (i = timeout; (i > 0 && ret != 0); i -= quantum_ms) { 831 schedule_timeout_interruptible(1); 832 ret = down_trylock(sem); 833 } 834 835 if (ret != 0) 836 status = AE_TIME; 837 } 838 break; 839 } 840 841 if (ACPI_FAILURE(status)) { 842 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 843 "Failed to acquire semaphore[%p|%d|%d], %s\n", 844 handle, units, timeout, 845 acpi_format_exception(status))); 846 } else { 847 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, 848 "Acquired semaphore[%p|%d|%d]\n", handle, 849 units, timeout)); 850 } 851 852 return_ACPI_STATUS(status); 853 } 854 855 EXPORT_SYMBOL(acpi_os_wait_semaphore); 856 857 /* 858 * TODO: Support for units > 1? 859 */ 860 acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units) 861 { 862 struct semaphore *sem = (struct semaphore *)handle; 863 864 ACPI_FUNCTION_TRACE("os_signal_semaphore"); 865 866 if (!sem || (units < 1)) 867 return_ACPI_STATUS(AE_BAD_PARAMETER); 868 869 if (units > 1) 870 return_ACPI_STATUS(AE_SUPPORT); 871 872 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle, 873 units)); 874 875 up(sem); 876 877 return_ACPI_STATUS(AE_OK); 878 } 879 880 EXPORT_SYMBOL(acpi_os_signal_semaphore); 881 882 #ifdef ACPI_FUTURE_USAGE 883 u32 acpi_os_get_line(char *buffer) 884 { 885 886 #ifdef ENABLE_DEBUGGER 887 if (acpi_in_debugger) { 888 u32 chars; 889 890 kdb_read(buffer, sizeof(line_buf)); 891 892 /* remove the CR kdb includes */ 893 chars = strlen(buffer) - 1; 894 buffer[chars] = '\0'; 895 } 896 #endif 897 898 return 0; 899 } 900 #endif /* ACPI_FUTURE_USAGE */ 901 902 /* Assumes no unreadable holes inbetween */ 903 u8 acpi_os_readable(void *ptr, acpi_size len) 904 { 905 #if defined(__i386__) || defined(__x86_64__) 906 char tmp; 907 return !__get_user(tmp, (char __user *)ptr) 908 && !__get_user(tmp, (char __user *)ptr + len - 1); 909 #endif 910 return 1; 911 } 912 913 #ifdef ACPI_FUTURE_USAGE 914 u8 acpi_os_writable(void *ptr, acpi_size len) 915 { 916 /* could do dummy write (racy) or a kernel page table lookup. 917 The later may be difficult at early boot when kmap doesn't work yet. */ 918 return 1; 919 } 920 #endif 921 922 acpi_status acpi_os_signal(u32 function, void *info) 923 { 924 switch (function) { 925 case ACPI_SIGNAL_FATAL: 926 printk(KERN_ERR PREFIX "Fatal opcode executed\n"); 927 break; 928 case ACPI_SIGNAL_BREAKPOINT: 929 /* 930 * AML Breakpoint 931 * ACPI spec. says to treat it as a NOP unless 932 * you are debugging. So if/when we integrate 933 * AML debugger into the kernel debugger its 934 * hook will go here. But until then it is 935 * not useful to print anything on breakpoints. 936 */ 937 break; 938 default: 939 break; 940 } 941 942 return AE_OK; 943 } 944 945 EXPORT_SYMBOL(acpi_os_signal); 946 947 static int __init acpi_os_name_setup(char *str) 948 { 949 char *p = acpi_os_name; 950 int count = ACPI_MAX_OVERRIDE_LEN - 1; 951 952 if (!str || !*str) 953 return 0; 954 955 for (; count-- && str && *str; str++) { 956 if (isalnum(*str) || *str == ' ' || *str == ':') 957 *p++ = *str; 958 else if (*str == '\'' || *str == '"') 959 continue; 960 else 961 break; 962 } 963 *p = 0; 964 965 return 1; 966 967 } 968 969 __setup("acpi_os_name=", acpi_os_name_setup); 970 971 /* 972 * _OSI control 973 * empty string disables _OSI 974 * TBD additional string adds to _OSI 975 */ 976 static int __init acpi_osi_setup(char *str) 977 { 978 if (str == NULL || *str == '\0') { 979 printk(KERN_INFO PREFIX "_OSI method disabled\n"); 980 acpi_gbl_create_osi_method = FALSE; 981 } else { 982 /* TBD */ 983 printk(KERN_ERR PREFIX "_OSI additional string ignored -- %s\n", 984 str); 985 } 986 987 return 1; 988 } 989 990 __setup("acpi_osi=", acpi_osi_setup); 991 992 /* enable serialization to combat AE_ALREADY_EXISTS errors */ 993 static int __init acpi_serialize_setup(char *str) 994 { 995 printk(KERN_INFO PREFIX "serialize enabled\n"); 996 997 acpi_gbl_all_methods_serialized = TRUE; 998 999 return 1; 1000 } 1001 1002 __setup("acpi_serialize", acpi_serialize_setup); 1003 1004 /* 1005 * Wake and Run-Time GPES are expected to be separate. 1006 * We disable wake-GPEs at run-time to prevent spurious 1007 * interrupts. 1008 * 1009 * However, if a system exists that shares Wake and 1010 * Run-time events on the same GPE this flag is available 1011 * to tell Linux to keep the wake-time GPEs enabled at run-time. 1012 */ 1013 static int __init acpi_wake_gpes_always_on_setup(char *str) 1014 { 1015 printk(KERN_INFO PREFIX "wake GPEs not disabled\n"); 1016 1017 acpi_gbl_leave_wake_gpes_disabled = FALSE; 1018 1019 return 1; 1020 } 1021 1022 __setup("acpi_wake_gpes_always_on", acpi_wake_gpes_always_on_setup); 1023 1024 static int __init acpi_hotkey_setup(char *str) 1025 { 1026 acpi_specific_hotkey_enabled = FALSE; 1027 return 1; 1028 } 1029 1030 __setup("acpi_generic_hotkey", acpi_hotkey_setup); 1031 1032 /* 1033 * max_cstate is defined in the base kernel so modules can 1034 * change it w/o depending on the state of the processor module. 1035 */ 1036 unsigned int max_cstate = ACPI_PROCESSOR_MAX_POWER; 1037 1038 EXPORT_SYMBOL(max_cstate); 1039 1040 /* 1041 * Acquire a spinlock. 1042 * 1043 * handle is a pointer to the spinlock_t. 1044 */ 1045 1046 acpi_cpu_flags acpi_os_acquire_lock(acpi_handle handle) 1047 { 1048 acpi_cpu_flags flags; 1049 spin_lock_irqsave((spinlock_t *) handle, flags); 1050 return flags; 1051 } 1052 1053 /* 1054 * Release a spinlock. See above. 1055 */ 1056 1057 void acpi_os_release_lock(acpi_handle handle, acpi_cpu_flags flags) 1058 { 1059 spin_unlock_irqrestore((spinlock_t *) handle, flags); 1060 } 1061 1062 #ifndef ACPI_USE_LOCAL_CACHE 1063 1064 /******************************************************************************* 1065 * 1066 * FUNCTION: acpi_os_create_cache 1067 * 1068 * PARAMETERS: name - Ascii name for the cache 1069 * size - Size of each cached object 1070 * depth - Maximum depth of the cache (in objects) <ignored> 1071 * cache - Where the new cache object is returned 1072 * 1073 * RETURN: status 1074 * 1075 * DESCRIPTION: Create a cache object 1076 * 1077 ******************************************************************************/ 1078 1079 acpi_status 1080 acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache) 1081 { 1082 *cache = kmem_cache_create(name, size, 0, 0, NULL, NULL); 1083 if (cache == NULL) 1084 return AE_ERROR; 1085 else 1086 return AE_OK; 1087 } 1088 1089 /******************************************************************************* 1090 * 1091 * FUNCTION: acpi_os_purge_cache 1092 * 1093 * PARAMETERS: Cache - Handle to cache object 1094 * 1095 * RETURN: Status 1096 * 1097 * DESCRIPTION: Free all objects within the requested cache. 1098 * 1099 ******************************************************************************/ 1100 1101 acpi_status acpi_os_purge_cache(acpi_cache_t * cache) 1102 { 1103 (void)kmem_cache_shrink(cache); 1104 return (AE_OK); 1105 } 1106 1107 /******************************************************************************* 1108 * 1109 * FUNCTION: acpi_os_delete_cache 1110 * 1111 * PARAMETERS: Cache - Handle to cache object 1112 * 1113 * RETURN: Status 1114 * 1115 * DESCRIPTION: Free all objects within the requested cache and delete the 1116 * cache object. 1117 * 1118 ******************************************************************************/ 1119 1120 acpi_status acpi_os_delete_cache(acpi_cache_t * cache) 1121 { 1122 (void)kmem_cache_destroy(cache); 1123 return (AE_OK); 1124 } 1125 1126 /******************************************************************************* 1127 * 1128 * FUNCTION: acpi_os_release_object 1129 * 1130 * PARAMETERS: Cache - Handle to cache object 1131 * Object - The object to be released 1132 * 1133 * RETURN: None 1134 * 1135 * DESCRIPTION: Release an object to the specified cache. If cache is full, 1136 * the object is deleted. 1137 * 1138 ******************************************************************************/ 1139 1140 acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object) 1141 { 1142 kmem_cache_free(cache, object); 1143 return (AE_OK); 1144 } 1145 1146 /******************************************************************************* 1147 * 1148 * FUNCTION: acpi_os_acquire_object 1149 * 1150 * PARAMETERS: Cache - Handle to cache object 1151 * ReturnObject - Where the object is returned 1152 * 1153 * RETURN: Status 1154 * 1155 * DESCRIPTION: Return a zero-filled object. 1156 * 1157 ******************************************************************************/ 1158 1159 void *acpi_os_acquire_object(acpi_cache_t * cache) 1160 { 1161 void *object = kmem_cache_zalloc(cache, GFP_KERNEL); 1162 WARN_ON(!object); 1163 return object; 1164 } 1165 1166 /****************************************************************************** 1167 * 1168 * FUNCTION: acpi_os_validate_interface 1169 * 1170 * PARAMETERS: interface - Requested interface to be validated 1171 * 1172 * RETURN: AE_OK if interface is supported, AE_SUPPORT otherwise 1173 * 1174 * DESCRIPTION: Match an interface string to the interfaces supported by the 1175 * host. Strings originate from an AML call to the _OSI method. 1176 * 1177 *****************************************************************************/ 1178 1179 acpi_status 1180 acpi_os_validate_interface (char *interface) 1181 { 1182 1183 return AE_SUPPORT; 1184 } 1185 1186 1187 /****************************************************************************** 1188 * 1189 * FUNCTION: acpi_os_validate_address 1190 * 1191 * PARAMETERS: space_id - ACPI space ID 1192 * address - Physical address 1193 * length - Address length 1194 * 1195 * RETURN: AE_OK if address/length is valid for the space_id. Otherwise, 1196 * should return AE_AML_ILLEGAL_ADDRESS. 1197 * 1198 * DESCRIPTION: Validate a system address via the host OS. Used to validate 1199 * the addresses accessed by AML operation regions. 1200 * 1201 *****************************************************************************/ 1202 1203 acpi_status 1204 acpi_os_validate_address ( 1205 u8 space_id, 1206 acpi_physical_address address, 1207 acpi_size length) 1208 { 1209 1210 return AE_OK; 1211 } 1212 1213 1214 #endif 1215