1 /****************************************************************************** 2 * 3 * Module Name: osunixxf - UNIX OSL interfaces 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2014, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 /* 45 * These interfaces are required in order to compile the ASL compiler and the 46 * various ACPICA tools under Linux or other Unix-like system. 47 */ 48 #include <acpi/acpi.h> 49 #include "accommon.h" 50 #include "amlcode.h" 51 #include "acparser.h" 52 #include "acdebug.h" 53 54 #include <stdio.h> 55 #include <stdlib.h> 56 #include <stdarg.h> 57 #include <unistd.h> 58 #include <sys/time.h> 59 #include <semaphore.h> 60 #include <pthread.h> 61 #include <errno.h> 62 63 #define _COMPONENT ACPI_OS_SERVICES 64 ACPI_MODULE_NAME("osunixxf") 65 66 u8 acpi_gbl_debug_timeout = FALSE; 67 68 /* Upcalls to acpi_exec */ 69 70 void 71 ae_table_override(struct acpi_table_header *existing_table, 72 struct acpi_table_header **new_table); 73 74 typedef void *(*PTHREAD_CALLBACK) (void *); 75 76 /* Buffer used by acpi_os_vprintf */ 77 78 #define ACPI_VPRINTF_BUFFER_SIZE 512 79 #define _ASCII_NEWLINE '\n' 80 81 /* Terminal support for acpi_exec only */ 82 83 #ifdef ACPI_EXEC_APP 84 #include <termios.h> 85 86 struct termios original_term_attributes; 87 int term_attributes_were_set = 0; 88 89 acpi_status acpi_ut_read_line(char *buffer, u32 buffer_length, u32 *bytes_read); 90 91 static void os_enter_line_edit_mode(void); 92 93 static void os_exit_line_edit_mode(void); 94 95 /****************************************************************************** 96 * 97 * FUNCTION: os_enter_line_edit_mode, os_exit_line_edit_mode 98 * 99 * PARAMETERS: None 100 * 101 * RETURN: None 102 * 103 * DESCRIPTION: Enter/Exit the raw character input mode for the terminal. 104 * 105 * Interactive line-editing support for the AML debugger. Used with the 106 * common/acgetline module. 107 * 108 * readline() is not used because of non-portability. It is not available 109 * on all systems, and if it is, often the package must be manually installed. 110 * 111 * Therefore, we use the POSIX tcgetattr/tcsetattr and do the minimal line 112 * editing that we need in acpi_os_get_line. 113 * 114 * If the POSIX tcgetattr/tcsetattr interfaces are unavailable, these 115 * calls will also work: 116 * For os_enter_line_edit_mode: system ("stty cbreak -echo") 117 * For os_exit_line_edit_mode: system ("stty cooked echo") 118 * 119 *****************************************************************************/ 120 121 static void os_enter_line_edit_mode(void) 122 { 123 struct termios local_term_attributes; 124 125 term_attributes_were_set = 0; 126 127 /* STDIN must be a terminal */ 128 129 if (!isatty(STDIN_FILENO)) { 130 return; 131 } 132 133 /* Get and keep the original attributes */ 134 135 if (tcgetattr(STDIN_FILENO, &original_term_attributes)) { 136 fprintf(stderr, "Could not get terminal attributes!\n"); 137 return; 138 } 139 140 /* Set the new attributes to enable raw character input */ 141 142 memcpy(&local_term_attributes, &original_term_attributes, 143 sizeof(struct termios)); 144 145 local_term_attributes.c_lflag &= ~(ICANON | ECHO); 146 local_term_attributes.c_cc[VMIN] = 1; 147 local_term_attributes.c_cc[VTIME] = 0; 148 149 if (tcsetattr(STDIN_FILENO, TCSANOW, &local_term_attributes)) { 150 fprintf(stderr, "Could not set terminal attributes!\n"); 151 return; 152 } 153 154 term_attributes_were_set = 1; 155 } 156 157 static void os_exit_line_edit_mode(void) 158 { 159 160 if (!term_attributes_were_set) { 161 return; 162 } 163 164 /* Set terminal attributes back to the original values */ 165 166 if (tcsetattr(STDIN_FILENO, TCSANOW, &original_term_attributes)) { 167 fprintf(stderr, "Could not restore terminal attributes!\n"); 168 } 169 } 170 171 #else 172 173 /* These functions are not needed for other ACPICA utilities */ 174 175 #define os_enter_line_edit_mode() 176 #define os_exit_line_edit_mode() 177 #endif 178 179 /****************************************************************************** 180 * 181 * FUNCTION: acpi_os_initialize, acpi_os_terminate 182 * 183 * PARAMETERS: None 184 * 185 * RETURN: Status 186 * 187 * DESCRIPTION: Initialize and terminate this module. 188 * 189 *****************************************************************************/ 190 191 acpi_status acpi_os_initialize(void) 192 { 193 acpi_status status; 194 195 acpi_gbl_output_file = stdout; 196 197 os_enter_line_edit_mode(); 198 199 status = acpi_os_create_lock(&acpi_gbl_print_lock); 200 if (ACPI_FAILURE(status)) { 201 return (status); 202 } 203 204 return (AE_OK); 205 } 206 207 acpi_status acpi_os_terminate(void) 208 { 209 210 os_exit_line_edit_mode(); 211 return (AE_OK); 212 } 213 214 #ifndef ACPI_USE_NATIVE_RSDP_POINTER 215 /****************************************************************************** 216 * 217 * FUNCTION: acpi_os_get_root_pointer 218 * 219 * PARAMETERS: None 220 * 221 * RETURN: RSDP physical address 222 * 223 * DESCRIPTION: Gets the ACPI root pointer (RSDP) 224 * 225 *****************************************************************************/ 226 227 acpi_physical_address acpi_os_get_root_pointer(void) 228 { 229 230 return (0); 231 } 232 #endif 233 234 /****************************************************************************** 235 * 236 * FUNCTION: acpi_os_predefined_override 237 * 238 * PARAMETERS: init_val - Initial value of the predefined object 239 * new_val - The new value for the object 240 * 241 * RETURN: Status, pointer to value. Null pointer returned if not 242 * overriding. 243 * 244 * DESCRIPTION: Allow the OS to override predefined names 245 * 246 *****************************************************************************/ 247 248 acpi_status 249 acpi_os_predefined_override(const struct acpi_predefined_names * init_val, 250 acpi_string * new_val) 251 { 252 253 if (!init_val || !new_val) { 254 return (AE_BAD_PARAMETER); 255 } 256 257 *new_val = NULL; 258 return (AE_OK); 259 } 260 261 /****************************************************************************** 262 * 263 * FUNCTION: acpi_os_table_override 264 * 265 * PARAMETERS: existing_table - Header of current table (probably 266 * firmware) 267 * new_table - Where an entire new table is returned. 268 * 269 * RETURN: Status, pointer to new table. Null pointer returned if no 270 * table is available to override 271 * 272 * DESCRIPTION: Return a different version of a table if one is available 273 * 274 *****************************************************************************/ 275 276 acpi_status 277 acpi_os_table_override(struct acpi_table_header * existing_table, 278 struct acpi_table_header ** new_table) 279 { 280 281 if (!existing_table || !new_table) { 282 return (AE_BAD_PARAMETER); 283 } 284 285 *new_table = NULL; 286 287 #ifdef ACPI_EXEC_APP 288 289 ae_table_override(existing_table, new_table); 290 return (AE_OK); 291 #else 292 293 return (AE_NO_ACPI_TABLES); 294 #endif 295 } 296 297 /****************************************************************************** 298 * 299 * FUNCTION: acpi_os_physical_table_override 300 * 301 * PARAMETERS: existing_table - Header of current table (probably firmware) 302 * new_address - Where new table address is returned 303 * (Physical address) 304 * new_table_length - Where new table length is returned 305 * 306 * RETURN: Status, address/length of new table. Null pointer returned 307 * if no table is available to override. 308 * 309 * DESCRIPTION: Returns AE_SUPPORT, function not used in user space. 310 * 311 *****************************************************************************/ 312 313 acpi_status 314 acpi_os_physical_table_override(struct acpi_table_header * existing_table, 315 acpi_physical_address * new_address, 316 u32 *new_table_length) 317 { 318 319 return (AE_SUPPORT); 320 } 321 322 /****************************************************************************** 323 * 324 * FUNCTION: acpi_os_redirect_output 325 * 326 * PARAMETERS: destination - An open file handle/pointer 327 * 328 * RETURN: None 329 * 330 * DESCRIPTION: Causes redirect of acpi_os_printf and acpi_os_vprintf 331 * 332 *****************************************************************************/ 333 334 void acpi_os_redirect_output(void *destination) 335 { 336 337 acpi_gbl_output_file = destination; 338 } 339 340 /****************************************************************************** 341 * 342 * FUNCTION: acpi_os_printf 343 * 344 * PARAMETERS: fmt, ... - Standard printf format 345 * 346 * RETURN: None 347 * 348 * DESCRIPTION: Formatted output. Note: very similar to acpi_os_vprintf 349 * (performance), changes should be tracked in both functions. 350 * 351 *****************************************************************************/ 352 353 void ACPI_INTERNAL_VAR_XFACE acpi_os_printf(const char *fmt, ...) 354 { 355 va_list args; 356 u8 flags; 357 358 flags = acpi_gbl_db_output_flags; 359 if (flags & ACPI_DB_REDIRECTABLE_OUTPUT) { 360 361 /* Output is directable to either a file (if open) or the console */ 362 363 if (acpi_gbl_debug_file) { 364 365 /* Output file is open, send the output there */ 366 367 va_start(args, fmt); 368 vfprintf(acpi_gbl_debug_file, fmt, args); 369 va_end(args); 370 } else { 371 /* No redirection, send output to console (once only!) */ 372 373 flags |= ACPI_DB_CONSOLE_OUTPUT; 374 } 375 } 376 377 if (flags & ACPI_DB_CONSOLE_OUTPUT) { 378 va_start(args, fmt); 379 vfprintf(acpi_gbl_output_file, fmt, args); 380 va_end(args); 381 } 382 } 383 384 /****************************************************************************** 385 * 386 * FUNCTION: acpi_os_vprintf 387 * 388 * PARAMETERS: fmt - Standard printf format 389 * args - Argument list 390 * 391 * RETURN: None 392 * 393 * DESCRIPTION: Formatted output with argument list pointer. Note: very 394 * similar to acpi_os_printf, changes should be tracked in both 395 * functions. 396 * 397 *****************************************************************************/ 398 399 void acpi_os_vprintf(const char *fmt, va_list args) 400 { 401 u8 flags; 402 char buffer[ACPI_VPRINTF_BUFFER_SIZE]; 403 404 /* 405 * We build the output string in a local buffer because we may be 406 * outputting the buffer twice. Using vfprintf is problematic because 407 * some implementations modify the args pointer/structure during 408 * execution. Thus, we use the local buffer for portability. 409 * 410 * Note: Since this module is intended for use by the various ACPICA 411 * utilities/applications, we can safely declare the buffer on the stack. 412 * Also, This function is used for relatively small error messages only. 413 */ 414 vsnprintf(buffer, ACPI_VPRINTF_BUFFER_SIZE, fmt, args); 415 416 flags = acpi_gbl_db_output_flags; 417 if (flags & ACPI_DB_REDIRECTABLE_OUTPUT) { 418 419 /* Output is directable to either a file (if open) or the console */ 420 421 if (acpi_gbl_debug_file) { 422 423 /* Output file is open, send the output there */ 424 425 fputs(buffer, acpi_gbl_debug_file); 426 } else { 427 /* No redirection, send output to console (once only!) */ 428 429 flags |= ACPI_DB_CONSOLE_OUTPUT; 430 } 431 } 432 433 if (flags & ACPI_DB_CONSOLE_OUTPUT) { 434 fputs(buffer, acpi_gbl_output_file); 435 } 436 } 437 438 #ifndef ACPI_EXEC_APP 439 /****************************************************************************** 440 * 441 * FUNCTION: acpi_os_get_line 442 * 443 * PARAMETERS: buffer - Where to return the command line 444 * buffer_length - Maximum length of Buffer 445 * bytes_read - Where the actual byte count is returned 446 * 447 * RETURN: Status and actual bytes read 448 * 449 * DESCRIPTION: Get the next input line from the terminal. NOTE: For the 450 * acpi_exec utility, we use the acgetline module instead to 451 * provide line-editing and history support. 452 * 453 *****************************************************************************/ 454 455 acpi_status acpi_os_get_line(char *buffer, u32 buffer_length, u32 *bytes_read) 456 { 457 int input_char; 458 u32 end_of_line; 459 460 /* Standard acpi_os_get_line for all utilities except acpi_exec */ 461 462 for (end_of_line = 0;; end_of_line++) { 463 if (end_of_line >= buffer_length) { 464 return (AE_BUFFER_OVERFLOW); 465 } 466 467 if ((input_char = getchar()) == EOF) { 468 return (AE_ERROR); 469 } 470 471 if (!input_char || input_char == _ASCII_NEWLINE) { 472 break; 473 } 474 475 buffer[end_of_line] = (char)input_char; 476 } 477 478 /* Null terminate the buffer */ 479 480 buffer[end_of_line] = 0; 481 482 /* Return the number of bytes in the string */ 483 484 if (bytes_read) { 485 *bytes_read = end_of_line; 486 } 487 488 return (AE_OK); 489 } 490 #endif 491 492 #ifndef ACPI_USE_NATIVE_MEMORY_MAPPING 493 /****************************************************************************** 494 * 495 * FUNCTION: acpi_os_map_memory 496 * 497 * PARAMETERS: where - Physical address of memory to be mapped 498 * length - How much memory to map 499 * 500 * RETURN: Pointer to mapped memory. Null on error. 501 * 502 * DESCRIPTION: Map physical memory into caller's address space 503 * 504 *****************************************************************************/ 505 506 void *acpi_os_map_memory(acpi_physical_address where, acpi_size length) 507 { 508 509 return (ACPI_TO_POINTER((acpi_size) where)); 510 } 511 512 /****************************************************************************** 513 * 514 * FUNCTION: acpi_os_unmap_memory 515 * 516 * PARAMETERS: where - Logical address of memory to be unmapped 517 * length - How much memory to unmap 518 * 519 * RETURN: None. 520 * 521 * DESCRIPTION: Delete a previously created mapping. Where and Length must 522 * correspond to a previous mapping exactly. 523 * 524 *****************************************************************************/ 525 526 void acpi_os_unmap_memory(void *where, acpi_size length) 527 { 528 529 return; 530 } 531 #endif 532 533 /****************************************************************************** 534 * 535 * FUNCTION: acpi_os_allocate 536 * 537 * PARAMETERS: size - Amount to allocate, in bytes 538 * 539 * RETURN: Pointer to the new allocation. Null on error. 540 * 541 * DESCRIPTION: Allocate memory. Algorithm is dependent on the OS. 542 * 543 *****************************************************************************/ 544 545 void *acpi_os_allocate(acpi_size size) 546 { 547 void *mem; 548 549 mem = (void *)malloc((size_t) size); 550 return (mem); 551 } 552 553 #ifdef USE_NATIVE_ALLOCATE_ZEROED 554 /****************************************************************************** 555 * 556 * FUNCTION: acpi_os_allocate_zeroed 557 * 558 * PARAMETERS: size - Amount to allocate, in bytes 559 * 560 * RETURN: Pointer to the new allocation. Null on error. 561 * 562 * DESCRIPTION: Allocate and zero memory. Algorithm is dependent on the OS. 563 * 564 *****************************************************************************/ 565 566 void *acpi_os_allocate_zeroed(acpi_size size) 567 { 568 void *mem; 569 570 mem = (void *)calloc(1, (size_t) size); 571 return (mem); 572 } 573 #endif 574 575 /****************************************************************************** 576 * 577 * FUNCTION: acpi_os_free 578 * 579 * PARAMETERS: mem - Pointer to previously allocated memory 580 * 581 * RETURN: None. 582 * 583 * DESCRIPTION: Free memory allocated via acpi_os_allocate 584 * 585 *****************************************************************************/ 586 587 void acpi_os_free(void *mem) 588 { 589 590 free(mem); 591 } 592 593 #ifdef ACPI_SINGLE_THREADED 594 /****************************************************************************** 595 * 596 * FUNCTION: Semaphore stub functions 597 * 598 * DESCRIPTION: Stub functions used for single-thread applications that do 599 * not require semaphore synchronization. Full implementations 600 * of these functions appear after the stubs. 601 * 602 *****************************************************************************/ 603 604 acpi_status 605 acpi_os_create_semaphore(u32 max_units, 606 u32 initial_units, acpi_handle * out_handle) 607 { 608 *out_handle = (acpi_handle) 1; 609 return (AE_OK); 610 } 611 612 acpi_status acpi_os_delete_semaphore(acpi_handle handle) 613 { 614 return (AE_OK); 615 } 616 617 acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout) 618 { 619 return (AE_OK); 620 } 621 622 acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units) 623 { 624 return (AE_OK); 625 } 626 627 #else 628 /****************************************************************************** 629 * 630 * FUNCTION: acpi_os_create_semaphore 631 * 632 * PARAMETERS: initial_units - Units to be assigned to the new semaphore 633 * out_handle - Where a handle will be returned 634 * 635 * RETURN: Status 636 * 637 * DESCRIPTION: Create an OS semaphore 638 * 639 *****************************************************************************/ 640 641 acpi_status 642 acpi_os_create_semaphore(u32 max_units, 643 u32 initial_units, acpi_handle * out_handle) 644 { 645 sem_t *sem; 646 647 if (!out_handle) { 648 return (AE_BAD_PARAMETER); 649 } 650 #ifdef __APPLE__ 651 { 652 char *semaphore_name = tmpnam(NULL); 653 654 sem = 655 sem_open(semaphore_name, O_EXCL | O_CREAT, 0755, 656 initial_units); 657 if (!sem) { 658 return (AE_NO_MEMORY); 659 } 660 sem_unlink(semaphore_name); /* This just deletes the name */ 661 } 662 663 #else 664 sem = acpi_os_allocate(sizeof(sem_t)); 665 if (!sem) { 666 return (AE_NO_MEMORY); 667 } 668 669 if (sem_init(sem, 0, initial_units) == -1) { 670 acpi_os_free(sem); 671 return (AE_BAD_PARAMETER); 672 } 673 #endif 674 675 *out_handle = (acpi_handle) sem; 676 return (AE_OK); 677 } 678 679 /****************************************************************************** 680 * 681 * FUNCTION: acpi_os_delete_semaphore 682 * 683 * PARAMETERS: handle - Handle returned by acpi_os_create_semaphore 684 * 685 * RETURN: Status 686 * 687 * DESCRIPTION: Delete an OS semaphore 688 * 689 *****************************************************************************/ 690 691 acpi_status acpi_os_delete_semaphore(acpi_handle handle) 692 { 693 sem_t *sem = (sem_t *) handle; 694 695 if (!sem) { 696 return (AE_BAD_PARAMETER); 697 } 698 699 if (sem_destroy(sem) == -1) { 700 return (AE_BAD_PARAMETER); 701 } 702 703 return (AE_OK); 704 } 705 706 /****************************************************************************** 707 * 708 * FUNCTION: acpi_os_wait_semaphore 709 * 710 * PARAMETERS: handle - Handle returned by acpi_os_create_semaphore 711 * units - How many units to wait for 712 * msec_timeout - How long to wait (milliseconds) 713 * 714 * RETURN: Status 715 * 716 * DESCRIPTION: Wait for units 717 * 718 *****************************************************************************/ 719 720 acpi_status 721 acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 msec_timeout) 722 { 723 acpi_status status = AE_OK; 724 sem_t *sem = (sem_t *) handle; 725 #ifndef ACPI_USE_ALTERNATE_TIMEOUT 726 struct timespec time; 727 int ret_val; 728 #endif 729 730 if (!sem) { 731 return (AE_BAD_PARAMETER); 732 } 733 734 switch (msec_timeout) { 735 /* 736 * No Wait: 737 * -------- 738 * A zero timeout value indicates that we shouldn't wait - just 739 * acquire the semaphore if available otherwise return AE_TIME 740 * (a.k.a. 'would block'). 741 */ 742 case 0: 743 744 if (sem_trywait(sem) == -1) { 745 status = (AE_TIME); 746 } 747 break; 748 749 /* Wait Indefinitely */ 750 751 case ACPI_WAIT_FOREVER: 752 753 if (sem_wait(sem)) { 754 status = (AE_TIME); 755 } 756 break; 757 758 /* Wait with msec_timeout */ 759 760 default: 761 762 #ifdef ACPI_USE_ALTERNATE_TIMEOUT 763 /* 764 * Alternate timeout mechanism for environments where 765 * sem_timedwait is not available or does not work properly. 766 */ 767 while (msec_timeout) { 768 if (sem_trywait(sem) == 0) { 769 770 /* Got the semaphore */ 771 return (AE_OK); 772 } 773 774 if (msec_timeout >= 10) { 775 msec_timeout -= 10; 776 usleep(10 * ACPI_USEC_PER_MSEC); /* ten milliseconds */ 777 } else { 778 msec_timeout--; 779 usleep(ACPI_USEC_PER_MSEC); /* one millisecond */ 780 } 781 } 782 status = (AE_TIME); 783 #else 784 /* 785 * The interface to sem_timedwait is an absolute time, so we need to 786 * get the current time, then add in the millisecond Timeout value. 787 */ 788 if (clock_gettime(CLOCK_REALTIME, &time) == -1) { 789 perror("clock_gettime"); 790 return (AE_TIME); 791 } 792 793 time.tv_sec += (msec_timeout / ACPI_MSEC_PER_SEC); 794 time.tv_nsec += 795 ((msec_timeout % ACPI_MSEC_PER_SEC) * ACPI_NSEC_PER_MSEC); 796 797 /* Handle nanosecond overflow (field must be less than one second) */ 798 799 if (time.tv_nsec >= ACPI_NSEC_PER_SEC) { 800 time.tv_sec += (time.tv_nsec / ACPI_NSEC_PER_SEC); 801 time.tv_nsec = (time.tv_nsec % ACPI_NSEC_PER_SEC); 802 } 803 804 while (((ret_val = sem_timedwait(sem, &time)) == -1) 805 && (errno == EINTR)) { 806 continue; 807 } 808 809 if (ret_val != 0) { 810 if (errno != ETIMEDOUT) { 811 perror("sem_timedwait"); 812 } 813 status = (AE_TIME); 814 } 815 #endif 816 break; 817 } 818 819 return (status); 820 } 821 822 /****************************************************************************** 823 * 824 * FUNCTION: acpi_os_signal_semaphore 825 * 826 * PARAMETERS: handle - Handle returned by acpi_os_create_semaphore 827 * units - Number of units to send 828 * 829 * RETURN: Status 830 * 831 * DESCRIPTION: Send units 832 * 833 *****************************************************************************/ 834 835 acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units) 836 { 837 sem_t *sem = (sem_t *) handle; 838 839 if (!sem) { 840 return (AE_BAD_PARAMETER); 841 } 842 843 if (sem_post(sem) == -1) { 844 return (AE_LIMIT); 845 } 846 847 return (AE_OK); 848 } 849 850 #endif /* ACPI_SINGLE_THREADED */ 851 852 /****************************************************************************** 853 * 854 * FUNCTION: Spinlock interfaces 855 * 856 * DESCRIPTION: Map these interfaces to semaphore interfaces 857 * 858 *****************************************************************************/ 859 860 acpi_status acpi_os_create_lock(acpi_spinlock * out_handle) 861 { 862 863 return (acpi_os_create_semaphore(1, 1, out_handle)); 864 } 865 866 void acpi_os_delete_lock(acpi_spinlock handle) 867 { 868 acpi_os_delete_semaphore(handle); 869 } 870 871 acpi_cpu_flags acpi_os_acquire_lock(acpi_handle handle) 872 { 873 acpi_os_wait_semaphore(handle, 1, 0xFFFF); 874 return (0); 875 } 876 877 void acpi_os_release_lock(acpi_spinlock handle, acpi_cpu_flags flags) 878 { 879 acpi_os_signal_semaphore(handle, 1); 880 } 881 882 /****************************************************************************** 883 * 884 * FUNCTION: acpi_os_install_interrupt_handler 885 * 886 * PARAMETERS: interrupt_number - Level handler should respond to. 887 * isr - Address of the ACPI interrupt handler 888 * except_ptr - Where status is returned 889 * 890 * RETURN: Handle to the newly installed handler. 891 * 892 * DESCRIPTION: Install an interrupt handler. Used to install the ACPI 893 * OS-independent handler. 894 * 895 *****************************************************************************/ 896 897 u32 898 acpi_os_install_interrupt_handler(u32 interrupt_number, 899 acpi_osd_handler service_routine, 900 void *context) 901 { 902 903 return (AE_OK); 904 } 905 906 /****************************************************************************** 907 * 908 * FUNCTION: acpi_os_remove_interrupt_handler 909 * 910 * PARAMETERS: handle - Returned when handler was installed 911 * 912 * RETURN: Status 913 * 914 * DESCRIPTION: Uninstalls an interrupt handler. 915 * 916 *****************************************************************************/ 917 918 acpi_status 919 acpi_os_remove_interrupt_handler(u32 interrupt_number, 920 acpi_osd_handler service_routine) 921 { 922 923 return (AE_OK); 924 } 925 926 /****************************************************************************** 927 * 928 * FUNCTION: acpi_os_stall 929 * 930 * PARAMETERS: microseconds - Time to sleep 931 * 932 * RETURN: Blocks until sleep is completed. 933 * 934 * DESCRIPTION: Sleep at microsecond granularity 935 * 936 *****************************************************************************/ 937 938 void acpi_os_stall(u32 microseconds) 939 { 940 941 if (microseconds) { 942 usleep(microseconds); 943 } 944 } 945 946 /****************************************************************************** 947 * 948 * FUNCTION: acpi_os_sleep 949 * 950 * PARAMETERS: milliseconds - Time to sleep 951 * 952 * RETURN: Blocks until sleep is completed. 953 * 954 * DESCRIPTION: Sleep at millisecond granularity 955 * 956 *****************************************************************************/ 957 958 void acpi_os_sleep(u64 milliseconds) 959 { 960 961 /* Sleep for whole seconds */ 962 963 sleep(milliseconds / ACPI_MSEC_PER_SEC); 964 965 /* 966 * Sleep for remaining microseconds. 967 * Arg to usleep() is in usecs and must be less than 1,000,000 (1 second). 968 */ 969 usleep((milliseconds % ACPI_MSEC_PER_SEC) * ACPI_USEC_PER_MSEC); 970 } 971 972 /****************************************************************************** 973 * 974 * FUNCTION: acpi_os_get_timer 975 * 976 * PARAMETERS: None 977 * 978 * RETURN: Current time in 100 nanosecond units 979 * 980 * DESCRIPTION: Get the current system time 981 * 982 *****************************************************************************/ 983 984 u64 acpi_os_get_timer(void) 985 { 986 struct timeval time; 987 988 /* This timer has sufficient resolution for user-space application code */ 989 990 gettimeofday(&time, NULL); 991 992 /* (Seconds * 10^7 = 100ns(10^-7)) + (Microseconds(10^-6) * 10^1 = 100ns) */ 993 994 return (((u64)time.tv_sec * ACPI_100NSEC_PER_SEC) + 995 ((u64)time.tv_usec * ACPI_100NSEC_PER_USEC)); 996 } 997 998 /****************************************************************************** 999 * 1000 * FUNCTION: acpi_os_read_pci_configuration 1001 * 1002 * PARAMETERS: pci_id - Seg/Bus/Dev 1003 * pci_register - Device Register 1004 * value - Buffer where value is placed 1005 * width - Number of bits 1006 * 1007 * RETURN: Status 1008 * 1009 * DESCRIPTION: Read data from PCI configuration space 1010 * 1011 *****************************************************************************/ 1012 1013 acpi_status 1014 acpi_os_read_pci_configuration(struct acpi_pci_id *pci_id, 1015 u32 pci_register, u64 *value, u32 width) 1016 { 1017 1018 *value = 0; 1019 return (AE_OK); 1020 } 1021 1022 /****************************************************************************** 1023 * 1024 * FUNCTION: acpi_os_write_pci_configuration 1025 * 1026 * PARAMETERS: pci_id - Seg/Bus/Dev 1027 * pci_register - Device Register 1028 * value - Value to be written 1029 * width - Number of bits 1030 * 1031 * RETURN: Status. 1032 * 1033 * DESCRIPTION: Write data to PCI configuration space 1034 * 1035 *****************************************************************************/ 1036 1037 acpi_status 1038 acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, 1039 u32 pci_register, u64 value, u32 width) 1040 { 1041 1042 return (AE_OK); 1043 } 1044 1045 /****************************************************************************** 1046 * 1047 * FUNCTION: acpi_os_read_port 1048 * 1049 * PARAMETERS: address - Address of I/O port/register to read 1050 * value - Where value is placed 1051 * width - Number of bits 1052 * 1053 * RETURN: Value read from port 1054 * 1055 * DESCRIPTION: Read data from an I/O port or register 1056 * 1057 *****************************************************************************/ 1058 1059 acpi_status acpi_os_read_port(acpi_io_address address, u32 *value, u32 width) 1060 { 1061 1062 switch (width) { 1063 case 8: 1064 1065 *value = 0xFF; 1066 break; 1067 1068 case 16: 1069 1070 *value = 0xFFFF; 1071 break; 1072 1073 case 32: 1074 1075 *value = 0xFFFFFFFF; 1076 break; 1077 1078 default: 1079 1080 return (AE_BAD_PARAMETER); 1081 } 1082 1083 return (AE_OK); 1084 } 1085 1086 /****************************************************************************** 1087 * 1088 * FUNCTION: acpi_os_write_port 1089 * 1090 * PARAMETERS: address - Address of I/O port/register to write 1091 * value - Value to write 1092 * width - Number of bits 1093 * 1094 * RETURN: None 1095 * 1096 * DESCRIPTION: Write data to an I/O port or register 1097 * 1098 *****************************************************************************/ 1099 1100 acpi_status acpi_os_write_port(acpi_io_address address, u32 value, u32 width) 1101 { 1102 1103 return (AE_OK); 1104 } 1105 1106 /****************************************************************************** 1107 * 1108 * FUNCTION: acpi_os_read_memory 1109 * 1110 * PARAMETERS: address - Physical Memory Address to read 1111 * value - Where value is placed 1112 * width - Number of bits (8,16,32, or 64) 1113 * 1114 * RETURN: Value read from physical memory address. Always returned 1115 * as a 64-bit integer, regardless of the read width. 1116 * 1117 * DESCRIPTION: Read data from a physical memory address 1118 * 1119 *****************************************************************************/ 1120 1121 acpi_status 1122 acpi_os_read_memory(acpi_physical_address address, u64 *value, u32 width) 1123 { 1124 1125 switch (width) { 1126 case 8: 1127 case 16: 1128 case 32: 1129 case 64: 1130 1131 *value = 0; 1132 break; 1133 1134 default: 1135 1136 return (AE_BAD_PARAMETER); 1137 } 1138 return (AE_OK); 1139 } 1140 1141 /****************************************************************************** 1142 * 1143 * FUNCTION: acpi_os_write_memory 1144 * 1145 * PARAMETERS: address - Physical Memory Address to write 1146 * value - Value to write 1147 * width - Number of bits (8,16,32, or 64) 1148 * 1149 * RETURN: None 1150 * 1151 * DESCRIPTION: Write data to a physical memory address 1152 * 1153 *****************************************************************************/ 1154 1155 acpi_status 1156 acpi_os_write_memory(acpi_physical_address address, u64 value, u32 width) 1157 { 1158 1159 return (AE_OK); 1160 } 1161 1162 /****************************************************************************** 1163 * 1164 * FUNCTION: acpi_os_readable 1165 * 1166 * PARAMETERS: pointer - Area to be verified 1167 * length - Size of area 1168 * 1169 * RETURN: TRUE if readable for entire length 1170 * 1171 * DESCRIPTION: Verify that a pointer is valid for reading 1172 * 1173 *****************************************************************************/ 1174 1175 u8 acpi_os_readable(void *pointer, acpi_size length) 1176 { 1177 1178 return (TRUE); 1179 } 1180 1181 /****************************************************************************** 1182 * 1183 * FUNCTION: acpi_os_writable 1184 * 1185 * PARAMETERS: pointer - Area to be verified 1186 * length - Size of area 1187 * 1188 * RETURN: TRUE if writable for entire length 1189 * 1190 * DESCRIPTION: Verify that a pointer is valid for writing 1191 * 1192 *****************************************************************************/ 1193 1194 u8 acpi_os_writable(void *pointer, acpi_size length) 1195 { 1196 1197 return (TRUE); 1198 } 1199 1200 /****************************************************************************** 1201 * 1202 * FUNCTION: acpi_os_signal 1203 * 1204 * PARAMETERS: function - ACPI A signal function code 1205 * info - Pointer to function-dependent structure 1206 * 1207 * RETURN: Status 1208 * 1209 * DESCRIPTION: Miscellaneous functions. Example implementation only. 1210 * 1211 *****************************************************************************/ 1212 1213 acpi_status acpi_os_signal(u32 function, void *info) 1214 { 1215 1216 switch (function) { 1217 case ACPI_SIGNAL_FATAL: 1218 1219 break; 1220 1221 case ACPI_SIGNAL_BREAKPOINT: 1222 1223 break; 1224 1225 default: 1226 1227 break; 1228 } 1229 1230 return (AE_OK); 1231 } 1232 1233 /* Optional multi-thread support */ 1234 1235 #ifndef ACPI_SINGLE_THREADED 1236 /****************************************************************************** 1237 * 1238 * FUNCTION: acpi_os_get_thread_id 1239 * 1240 * PARAMETERS: None 1241 * 1242 * RETURN: Id of the running thread 1243 * 1244 * DESCRIPTION: Get the ID of the current (running) thread 1245 * 1246 *****************************************************************************/ 1247 1248 acpi_thread_id acpi_os_get_thread_id(void) 1249 { 1250 pthread_t thread; 1251 1252 thread = pthread_self(); 1253 return (ACPI_CAST_PTHREAD_T(thread)); 1254 } 1255 1256 /****************************************************************************** 1257 * 1258 * FUNCTION: acpi_os_execute 1259 * 1260 * PARAMETERS: type - Type of execution 1261 * function - Address of the function to execute 1262 * context - Passed as a parameter to the function 1263 * 1264 * RETURN: Status. 1265 * 1266 * DESCRIPTION: Execute a new thread 1267 * 1268 *****************************************************************************/ 1269 1270 acpi_status 1271 acpi_os_execute(acpi_execute_type type, 1272 acpi_osd_exec_callback function, void *context) 1273 { 1274 pthread_t thread; 1275 int ret; 1276 1277 ret = 1278 pthread_create(&thread, NULL, (PTHREAD_CALLBACK) function, context); 1279 if (ret) { 1280 acpi_os_printf("Create thread failed"); 1281 } 1282 return (0); 1283 } 1284 1285 #else /* ACPI_SINGLE_THREADED */ 1286 acpi_thread_id acpi_os_get_thread_id(void) 1287 { 1288 return (1); 1289 } 1290 1291 acpi_status 1292 acpi_os_execute(acpi_execute_type type, 1293 acpi_osd_exec_callback function, void *context) 1294 { 1295 1296 function(context); 1297 1298 return (AE_OK); 1299 } 1300 1301 #endif /* ACPI_SINGLE_THREADED */ 1302 1303 /****************************************************************************** 1304 * 1305 * FUNCTION: acpi_os_wait_events_complete 1306 * 1307 * PARAMETERS: None 1308 * 1309 * RETURN: None 1310 * 1311 * DESCRIPTION: Wait for all asynchronous events to complete. This 1312 * implementation does nothing. 1313 * 1314 *****************************************************************************/ 1315 1316 void acpi_os_wait_events_complete(void) 1317 { 1318 return; 1319 } 1320