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 EXPORT_SYMBOL_GPL(acpi_os_map_memory); 208 209 void acpi_os_unmap_memory(void __iomem * virt, acpi_size size) 210 { 211 iounmap(virt); 212 } 213 EXPORT_SYMBOL_GPL(acpi_os_unmap_memory); 214 215 #ifdef ACPI_FUTURE_USAGE 216 acpi_status 217 acpi_os_get_physical_address(void *virt, acpi_physical_address * phys) 218 { 219 if (!phys || !virt) 220 return AE_BAD_PARAMETER; 221 222 *phys = virt_to_phys(virt); 223 224 return AE_OK; 225 } 226 #endif 227 228 #define ACPI_MAX_OVERRIDE_LEN 100 229 230 static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN]; 231 232 acpi_status 233 acpi_os_predefined_override(const struct acpi_predefined_names *init_val, 234 acpi_string * new_val) 235 { 236 if (!init_val || !new_val) 237 return AE_BAD_PARAMETER; 238 239 *new_val = NULL; 240 if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) { 241 printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n", 242 acpi_os_name); 243 *new_val = acpi_os_name; 244 } 245 246 return AE_OK; 247 } 248 249 acpi_status 250 acpi_os_table_override(struct acpi_table_header * existing_table, 251 struct acpi_table_header ** new_table) 252 { 253 if (!existing_table || !new_table) 254 return AE_BAD_PARAMETER; 255 256 #ifdef CONFIG_ACPI_CUSTOM_DSDT 257 if (strncmp(existing_table->signature, "DSDT", 4) == 0) 258 *new_table = (struct acpi_table_header *)AmlCode; 259 else 260 *new_table = NULL; 261 #else 262 *new_table = NULL; 263 #endif 264 return AE_OK; 265 } 266 267 static irqreturn_t acpi_irq(int irq, void *dev_id, struct pt_regs *regs) 268 { 269 return (*acpi_irq_handler) (acpi_irq_context) ? IRQ_HANDLED : IRQ_NONE; 270 } 271 272 acpi_status 273 acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler, 274 void *context) 275 { 276 unsigned int irq; 277 278 /* 279 * Ignore the GSI from the core, and use the value in our copy of the 280 * FADT. It may not be the same if an interrupt source override exists 281 * for the SCI. 282 */ 283 gsi = acpi_fadt.sci_int; 284 if (acpi_gsi_to_irq(gsi, &irq) < 0) { 285 printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n", 286 gsi); 287 return AE_OK; 288 } 289 290 acpi_irq_handler = handler; 291 acpi_irq_context = context; 292 if (request_irq(irq, acpi_irq, SA_SHIRQ, "acpi", acpi_irq)) { 293 printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq); 294 return AE_NOT_ACQUIRED; 295 } 296 acpi_irq_irq = irq; 297 298 return AE_OK; 299 } 300 301 acpi_status acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler) 302 { 303 if (irq) { 304 free_irq(irq, acpi_irq); 305 acpi_irq_handler = NULL; 306 acpi_irq_irq = 0; 307 } 308 309 return AE_OK; 310 } 311 312 /* 313 * Running in interpreter thread context, safe to sleep 314 */ 315 316 void acpi_os_sleep(acpi_integer ms) 317 { 318 schedule_timeout_interruptible(msecs_to_jiffies(ms)); 319 } 320 321 EXPORT_SYMBOL(acpi_os_sleep); 322 323 void acpi_os_stall(u32 us) 324 { 325 while (us) { 326 u32 delay = 1000; 327 328 if (delay > us) 329 delay = us; 330 udelay(delay); 331 touch_nmi_watchdog(); 332 us -= delay; 333 } 334 } 335 336 EXPORT_SYMBOL(acpi_os_stall); 337 338 /* 339 * Support ACPI 3.0 AML Timer operand 340 * Returns 64-bit free-running, monotonically increasing timer 341 * with 100ns granularity 342 */ 343 u64 acpi_os_get_timer(void) 344 { 345 static u64 t; 346 347 #ifdef CONFIG_HPET 348 /* TBD: use HPET if available */ 349 #endif 350 351 #ifdef CONFIG_X86_PM_TIMER 352 /* TBD: default to PM timer if HPET was not available */ 353 #endif 354 if (!t) 355 printk(KERN_ERR PREFIX "acpi_os_get_timer() TBD\n"); 356 357 return ++t; 358 } 359 360 acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width) 361 { 362 u32 dummy; 363 364 if (!value) 365 value = &dummy; 366 367 switch (width) { 368 case 8: 369 *(u8 *) value = inb(port); 370 break; 371 case 16: 372 *(u16 *) value = inw(port); 373 break; 374 case 32: 375 *(u32 *) value = inl(port); 376 break; 377 default: 378 BUG(); 379 } 380 381 return AE_OK; 382 } 383 384 EXPORT_SYMBOL(acpi_os_read_port); 385 386 acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width) 387 { 388 switch (width) { 389 case 8: 390 outb(value, port); 391 break; 392 case 16: 393 outw(value, port); 394 break; 395 case 32: 396 outl(value, port); 397 break; 398 default: 399 BUG(); 400 } 401 402 return AE_OK; 403 } 404 405 EXPORT_SYMBOL(acpi_os_write_port); 406 407 acpi_status 408 acpi_os_read_memory(acpi_physical_address phys_addr, u32 * value, u32 width) 409 { 410 u32 dummy; 411 void __iomem *virt_addr; 412 int iomem = 0; 413 414 if (efi_enabled) { 415 if (EFI_MEMORY_WB & efi_mem_attributes(phys_addr)) { 416 /* HACK ALERT! We can use readb/w/l on real memory too.. */ 417 virt_addr = (void __iomem *)phys_to_virt(phys_addr); 418 } else { 419 iomem = 1; 420 virt_addr = ioremap(phys_addr, width); 421 } 422 } else 423 virt_addr = (void __iomem *)phys_to_virt(phys_addr); 424 if (!value) 425 value = &dummy; 426 427 switch (width) { 428 case 8: 429 *(u8 *) value = readb(virt_addr); 430 break; 431 case 16: 432 *(u16 *) value = readw(virt_addr); 433 break; 434 case 32: 435 *(u32 *) value = readl(virt_addr); 436 break; 437 default: 438 BUG(); 439 } 440 441 if (efi_enabled) { 442 if (iomem) 443 iounmap(virt_addr); 444 } 445 446 return AE_OK; 447 } 448 449 acpi_status 450 acpi_os_write_memory(acpi_physical_address phys_addr, u32 value, u32 width) 451 { 452 void __iomem *virt_addr; 453 int iomem = 0; 454 455 if (efi_enabled) { 456 if (EFI_MEMORY_WB & efi_mem_attributes(phys_addr)) { 457 /* HACK ALERT! We can use writeb/w/l on real memory too */ 458 virt_addr = (void __iomem *)phys_to_virt(phys_addr); 459 } else { 460 iomem = 1; 461 virt_addr = ioremap(phys_addr, width); 462 } 463 } else 464 virt_addr = (void __iomem *)phys_to_virt(phys_addr); 465 466 switch (width) { 467 case 8: 468 writeb(value, virt_addr); 469 break; 470 case 16: 471 writew(value, virt_addr); 472 break; 473 case 32: 474 writel(value, virt_addr); 475 break; 476 default: 477 BUG(); 478 } 479 480 if (iomem) 481 iounmap(virt_addr); 482 483 return AE_OK; 484 } 485 486 acpi_status 487 acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg, 488 void *value, u32 width) 489 { 490 int result, size; 491 492 if (!value) 493 return AE_BAD_PARAMETER; 494 495 switch (width) { 496 case 8: 497 size = 1; 498 break; 499 case 16: 500 size = 2; 501 break; 502 case 32: 503 size = 4; 504 break; 505 default: 506 return AE_ERROR; 507 } 508 509 BUG_ON(!raw_pci_ops); 510 511 result = raw_pci_ops->read(pci_id->segment, pci_id->bus, 512 PCI_DEVFN(pci_id->device, pci_id->function), 513 reg, size, value); 514 515 return (result ? AE_ERROR : AE_OK); 516 } 517 518 EXPORT_SYMBOL(acpi_os_read_pci_configuration); 519 520 acpi_status 521 acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg, 522 acpi_integer value, u32 width) 523 { 524 int result, size; 525 526 switch (width) { 527 case 8: 528 size = 1; 529 break; 530 case 16: 531 size = 2; 532 break; 533 case 32: 534 size = 4; 535 break; 536 default: 537 return AE_ERROR; 538 } 539 540 BUG_ON(!raw_pci_ops); 541 542 result = raw_pci_ops->write(pci_id->segment, pci_id->bus, 543 PCI_DEVFN(pci_id->device, pci_id->function), 544 reg, size, value); 545 546 return (result ? AE_ERROR : AE_OK); 547 } 548 549 /* TODO: Change code to take advantage of driver model more */ 550 static void acpi_os_derive_pci_id_2(acpi_handle rhandle, /* upper bound */ 551 acpi_handle chandle, /* current node */ 552 struct acpi_pci_id **id, 553 int *is_bridge, u8 * bus_number) 554 { 555 acpi_handle handle; 556 struct acpi_pci_id *pci_id = *id; 557 acpi_status status; 558 unsigned long temp; 559 acpi_object_type type; 560 u8 tu8; 561 562 acpi_get_parent(chandle, &handle); 563 if (handle != rhandle) { 564 acpi_os_derive_pci_id_2(rhandle, handle, &pci_id, is_bridge, 565 bus_number); 566 567 status = acpi_get_type(handle, &type); 568 if ((ACPI_FAILURE(status)) || (type != ACPI_TYPE_DEVICE)) 569 return; 570 571 status = 572 acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, 573 &temp); 574 if (ACPI_SUCCESS(status)) { 575 pci_id->device = ACPI_HIWORD(ACPI_LODWORD(temp)); 576 pci_id->function = ACPI_LOWORD(ACPI_LODWORD(temp)); 577 578 if (*is_bridge) 579 pci_id->bus = *bus_number; 580 581 /* any nicer way to get bus number of bridge ? */ 582 status = 583 acpi_os_read_pci_configuration(pci_id, 0x0e, &tu8, 584 8); 585 if (ACPI_SUCCESS(status) 586 && ((tu8 & 0x7f) == 1 || (tu8 & 0x7f) == 2)) { 587 status = 588 acpi_os_read_pci_configuration(pci_id, 0x18, 589 &tu8, 8); 590 if (!ACPI_SUCCESS(status)) { 591 /* Certainly broken... FIX ME */ 592 return; 593 } 594 *is_bridge = 1; 595 pci_id->bus = tu8; 596 status = 597 acpi_os_read_pci_configuration(pci_id, 0x19, 598 &tu8, 8); 599 if (ACPI_SUCCESS(status)) { 600 *bus_number = tu8; 601 } 602 } else 603 *is_bridge = 0; 604 } 605 } 606 } 607 608 void acpi_os_derive_pci_id(acpi_handle rhandle, /* upper bound */ 609 acpi_handle chandle, /* current node */ 610 struct acpi_pci_id **id) 611 { 612 int is_bridge = 1; 613 u8 bus_number = (*id)->bus; 614 615 acpi_os_derive_pci_id_2(rhandle, chandle, id, &is_bridge, &bus_number); 616 } 617 618 static void acpi_os_execute_deferred(void *context) 619 { 620 struct acpi_os_dpc *dpc = NULL; 621 622 ACPI_FUNCTION_TRACE("os_execute_deferred"); 623 624 dpc = (struct acpi_os_dpc *)context; 625 if (!dpc) { 626 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid (NULL) context.\n")); 627 return_VOID; 628 } 629 630 dpc->function(dpc->context); 631 632 kfree(dpc); 633 634 return_VOID; 635 } 636 637 acpi_status 638 acpi_os_queue_for_execution(u32 priority, 639 acpi_osd_exec_callback function, void *context) 640 { 641 acpi_status status = AE_OK; 642 struct acpi_os_dpc *dpc; 643 struct work_struct *task; 644 645 ACPI_FUNCTION_TRACE("os_queue_for_execution"); 646 647 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 648 "Scheduling function [%p(%p)] for deferred execution.\n", 649 function, context)); 650 651 if (!function) 652 return_ACPI_STATUS(AE_BAD_PARAMETER); 653 654 /* 655 * Allocate/initialize DPC structure. Note that this memory will be 656 * freed by the callee. The kernel handles the tq_struct list in a 657 * way that allows us to also free its memory inside the callee. 658 * Because we may want to schedule several tasks with different 659 * parameters we can't use the approach some kernel code uses of 660 * having a static tq_struct. 661 * We can save time and code by allocating the DPC and tq_structs 662 * from the same memory. 663 */ 664 665 dpc = 666 kmalloc(sizeof(struct acpi_os_dpc) + sizeof(struct work_struct), 667 GFP_ATOMIC); 668 if (!dpc) 669 return_ACPI_STATUS(AE_NO_MEMORY); 670 671 dpc->function = function; 672 dpc->context = context; 673 674 task = (void *)(dpc + 1); 675 INIT_WORK(task, acpi_os_execute_deferred, (void *)dpc); 676 677 if (!queue_work(kacpid_wq, task)) { 678 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 679 "Call to queue_work() failed.\n")); 680 kfree(dpc); 681 status = AE_ERROR; 682 } 683 684 return_ACPI_STATUS(status); 685 } 686 687 EXPORT_SYMBOL(acpi_os_queue_for_execution); 688 689 void acpi_os_wait_events_complete(void *context) 690 { 691 flush_workqueue(kacpid_wq); 692 } 693 694 EXPORT_SYMBOL(acpi_os_wait_events_complete); 695 696 /* 697 * Allocate the memory for a spinlock and initialize it. 698 */ 699 acpi_status acpi_os_create_lock(acpi_handle * out_handle) 700 { 701 spinlock_t *lock_ptr; 702 703 ACPI_FUNCTION_TRACE("os_create_lock"); 704 705 lock_ptr = acpi_os_allocate(sizeof(spinlock_t)); 706 707 spin_lock_init(lock_ptr); 708 709 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating spinlock[%p].\n", lock_ptr)); 710 711 *out_handle = lock_ptr; 712 713 return_ACPI_STATUS(AE_OK); 714 } 715 716 /* 717 * Deallocate the memory for a spinlock. 718 */ 719 void acpi_os_delete_lock(acpi_handle handle) 720 { 721 ACPI_FUNCTION_TRACE("os_create_lock"); 722 723 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting spinlock[%p].\n", handle)); 724 725 acpi_os_free(handle); 726 727 return_VOID; 728 } 729 730 acpi_status 731 acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle) 732 { 733 struct semaphore *sem = NULL; 734 735 ACPI_FUNCTION_TRACE("os_create_semaphore"); 736 737 sem = acpi_os_allocate(sizeof(struct semaphore)); 738 if (!sem) 739 return_ACPI_STATUS(AE_NO_MEMORY); 740 memset(sem, 0, sizeof(struct semaphore)); 741 742 sema_init(sem, initial_units); 743 744 *handle = (acpi_handle *) sem; 745 746 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n", 747 *handle, initial_units)); 748 749 return_ACPI_STATUS(AE_OK); 750 } 751 752 EXPORT_SYMBOL(acpi_os_create_semaphore); 753 754 /* 755 * TODO: A better way to delete semaphores? Linux doesn't have a 756 * 'delete_semaphore()' function -- may result in an invalid 757 * pointer dereference for non-synchronized consumers. Should 758 * we at least check for blocked threads and signal/cancel them? 759 */ 760 761 acpi_status acpi_os_delete_semaphore(acpi_handle handle) 762 { 763 struct semaphore *sem = (struct semaphore *)handle; 764 765 ACPI_FUNCTION_TRACE("os_delete_semaphore"); 766 767 if (!sem) 768 return_ACPI_STATUS(AE_BAD_PARAMETER); 769 770 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle)); 771 772 acpi_os_free(sem); 773 sem = NULL; 774 775 return_ACPI_STATUS(AE_OK); 776 } 777 778 EXPORT_SYMBOL(acpi_os_delete_semaphore); 779 780 /* 781 * TODO: The kernel doesn't have a 'down_timeout' function -- had to 782 * improvise. The process is to sleep for one scheduler quantum 783 * until the semaphore becomes available. Downside is that this 784 * may result in starvation for timeout-based waits when there's 785 * lots of semaphore activity. 786 * 787 * TODO: Support for units > 1? 788 */ 789 acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout) 790 { 791 acpi_status status = AE_OK; 792 struct semaphore *sem = (struct semaphore *)handle; 793 int ret = 0; 794 795 ACPI_FUNCTION_TRACE("os_wait_semaphore"); 796 797 if (!sem || (units < 1)) 798 return_ACPI_STATUS(AE_BAD_PARAMETER); 799 800 if (units > 1) 801 return_ACPI_STATUS(AE_SUPPORT); 802 803 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n", 804 handle, units, timeout)); 805 806 if (in_atomic()) 807 timeout = 0; 808 809 switch (timeout) { 810 /* 811 * No Wait: 812 * -------- 813 * A zero timeout value indicates that we shouldn't wait - just 814 * acquire the semaphore if available otherwise return AE_TIME 815 * (a.k.a. 'would block'). 816 */ 817 case 0: 818 if (down_trylock(sem)) 819 status = AE_TIME; 820 break; 821 822 /* 823 * Wait Indefinitely: 824 * ------------------ 825 */ 826 case ACPI_WAIT_FOREVER: 827 down(sem); 828 break; 829 830 /* 831 * Wait w/ Timeout: 832 * ---------------- 833 */ 834 default: 835 // TODO: A better timeout algorithm? 836 { 837 int i = 0; 838 static const int quantum_ms = 1000 / HZ; 839 840 ret = down_trylock(sem); 841 for (i = timeout; (i > 0 && ret != 0); i -= quantum_ms) { 842 schedule_timeout_interruptible(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 */ 1064 1065 acpi_cpu_flags acpi_os_acquire_lock(acpi_handle handle) 1066 { 1067 acpi_cpu_flags flags; 1068 spin_lock_irqsave((spinlock_t *) handle, flags); 1069 return flags; 1070 } 1071 1072 /* 1073 * Release a spinlock. See above. 1074 */ 1075 1076 void acpi_os_release_lock(acpi_handle handle, acpi_cpu_flags flags) 1077 { 1078 spin_unlock_irqrestore((spinlock_t *) handle, flags); 1079 } 1080 1081 #ifndef ACPI_USE_LOCAL_CACHE 1082 1083 /******************************************************************************* 1084 * 1085 * FUNCTION: acpi_os_create_cache 1086 * 1087 * PARAMETERS: CacheName - Ascii name for the cache 1088 * ObjectSize - Size of each cached object 1089 * MaxDepth - Maximum depth of the cache (in objects) 1090 * ReturnCache - Where the new cache object is returned 1091 * 1092 * RETURN: Status 1093 * 1094 * DESCRIPTION: Create a cache object 1095 * 1096 ******************************************************************************/ 1097 1098 acpi_status 1099 acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache) 1100 { 1101 *cache = kmem_cache_create(name, size, 0, 0, NULL, NULL); 1102 return AE_OK; 1103 } 1104 1105 /******************************************************************************* 1106 * 1107 * FUNCTION: acpi_os_purge_cache 1108 * 1109 * PARAMETERS: Cache - Handle to cache object 1110 * 1111 * RETURN: Status 1112 * 1113 * DESCRIPTION: Free all objects within the requested cache. 1114 * 1115 ******************************************************************************/ 1116 1117 acpi_status acpi_os_purge_cache(acpi_cache_t * cache) 1118 { 1119 (void)kmem_cache_shrink(cache); 1120 return (AE_OK); 1121 } 1122 1123 /******************************************************************************* 1124 * 1125 * FUNCTION: acpi_os_delete_cache 1126 * 1127 * PARAMETERS: Cache - Handle to cache object 1128 * 1129 * RETURN: Status 1130 * 1131 * DESCRIPTION: Free all objects within the requested cache and delete the 1132 * cache object. 1133 * 1134 ******************************************************************************/ 1135 1136 acpi_status acpi_os_delete_cache(acpi_cache_t * cache) 1137 { 1138 (void)kmem_cache_destroy(cache); 1139 return (AE_OK); 1140 } 1141 1142 /******************************************************************************* 1143 * 1144 * FUNCTION: acpi_os_release_object 1145 * 1146 * PARAMETERS: Cache - Handle to cache object 1147 * Object - The object to be released 1148 * 1149 * RETURN: None 1150 * 1151 * DESCRIPTION: Release an object to the specified cache. If cache is full, 1152 * the object is deleted. 1153 * 1154 ******************************************************************************/ 1155 1156 acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object) 1157 { 1158 kmem_cache_free(cache, object); 1159 return (AE_OK); 1160 } 1161 1162 /******************************************************************************* 1163 * 1164 * FUNCTION: acpi_os_acquire_object 1165 * 1166 * PARAMETERS: Cache - Handle to cache object 1167 * ReturnObject - Where the object is returned 1168 * 1169 * RETURN: Status 1170 * 1171 * DESCRIPTION: Get an object from the specified cache. If cache is empty, 1172 * the object is allocated. 1173 * 1174 ******************************************************************************/ 1175 1176 void *acpi_os_acquire_object(acpi_cache_t * cache) 1177 { 1178 void *object = kmem_cache_alloc(cache, GFP_KERNEL); 1179 WARN_ON(!object); 1180 return object; 1181 } 1182 1183 #endif 1184