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