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