1 /****************************************************************************** 2 * 3 * Module Name: osunixxf - UNIX OSL interfaces 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2018, 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_enter_sleep 322 * 323 * PARAMETERS: sleep_state - Which sleep state to enter 324 * rega_value - Register A value 325 * regb_value - Register B value 326 * 327 * RETURN: Status 328 * 329 * DESCRIPTION: A hook before writing sleep registers to enter the sleep 330 * state. Return AE_CTRL_TERMINATE to skip further sleep register 331 * writes. 332 * 333 *****************************************************************************/ 334 335 acpi_status acpi_os_enter_sleep(u8 sleep_state, u32 rega_value, u32 regb_value) 336 { 337 338 return (AE_OK); 339 } 340 341 /****************************************************************************** 342 * 343 * FUNCTION: acpi_os_redirect_output 344 * 345 * PARAMETERS: destination - An open file handle/pointer 346 * 347 * RETURN: None 348 * 349 * DESCRIPTION: Causes redirect of acpi_os_printf and acpi_os_vprintf 350 * 351 *****************************************************************************/ 352 353 void acpi_os_redirect_output(void *destination) 354 { 355 356 acpi_gbl_output_file = destination; 357 } 358 359 /****************************************************************************** 360 * 361 * FUNCTION: acpi_os_printf 362 * 363 * PARAMETERS: fmt, ... - Standard printf format 364 * 365 * RETURN: None 366 * 367 * DESCRIPTION: Formatted output. Note: very similar to acpi_os_vprintf 368 * (performance), changes should be tracked in both functions. 369 * 370 *****************************************************************************/ 371 372 void ACPI_INTERNAL_VAR_XFACE acpi_os_printf(const char *fmt, ...) 373 { 374 va_list args; 375 u8 flags; 376 377 flags = acpi_gbl_db_output_flags; 378 if (flags & ACPI_DB_REDIRECTABLE_OUTPUT) { 379 380 /* Output is directable to either a file (if open) or the console */ 381 382 if (acpi_gbl_debug_file) { 383 384 /* Output file is open, send the output there */ 385 386 va_start(args, fmt); 387 vfprintf(acpi_gbl_debug_file, fmt, args); 388 va_end(args); 389 } else { 390 /* No redirection, send output to console (once only!) */ 391 392 flags |= ACPI_DB_CONSOLE_OUTPUT; 393 } 394 } 395 396 if (flags & ACPI_DB_CONSOLE_OUTPUT) { 397 va_start(args, fmt); 398 vfprintf(acpi_gbl_output_file, fmt, args); 399 va_end(args); 400 } 401 } 402 403 /****************************************************************************** 404 * 405 * FUNCTION: acpi_os_vprintf 406 * 407 * PARAMETERS: fmt - Standard printf format 408 * args - Argument list 409 * 410 * RETURN: None 411 * 412 * DESCRIPTION: Formatted output with argument list pointer. Note: very 413 * similar to acpi_os_printf, changes should be tracked in both 414 * functions. 415 * 416 *****************************************************************************/ 417 418 void acpi_os_vprintf(const char *fmt, va_list args) 419 { 420 u8 flags; 421 char buffer[ACPI_VPRINTF_BUFFER_SIZE]; 422 423 /* 424 * We build the output string in a local buffer because we may be 425 * outputting the buffer twice. Using vfprintf is problematic because 426 * some implementations modify the args pointer/structure during 427 * execution. Thus, we use the local buffer for portability. 428 * 429 * Note: Since this module is intended for use by the various ACPICA 430 * utilities/applications, we can safely declare the buffer on the stack. 431 * Also, This function is used for relatively small error messages only. 432 */ 433 vsnprintf(buffer, ACPI_VPRINTF_BUFFER_SIZE, fmt, args); 434 435 flags = acpi_gbl_db_output_flags; 436 if (flags & ACPI_DB_REDIRECTABLE_OUTPUT) { 437 438 /* Output is directable to either a file (if open) or the console */ 439 440 if (acpi_gbl_debug_file) { 441 442 /* Output file is open, send the output there */ 443 444 fputs(buffer, acpi_gbl_debug_file); 445 } else { 446 /* No redirection, send output to console (once only!) */ 447 448 flags |= ACPI_DB_CONSOLE_OUTPUT; 449 } 450 } 451 452 if (flags & ACPI_DB_CONSOLE_OUTPUT) { 453 fputs(buffer, acpi_gbl_output_file); 454 } 455 } 456 457 #ifndef ACPI_EXEC_APP 458 /****************************************************************************** 459 * 460 * FUNCTION: acpi_os_get_line 461 * 462 * PARAMETERS: buffer - Where to return the command line 463 * buffer_length - Maximum length of Buffer 464 * bytes_read - Where the actual byte count is returned 465 * 466 * RETURN: Status and actual bytes read 467 * 468 * DESCRIPTION: Get the next input line from the terminal. NOTE: For the 469 * acpi_exec utility, we use the acgetline module instead to 470 * provide line-editing and history support. 471 * 472 *****************************************************************************/ 473 474 acpi_status acpi_os_get_line(char *buffer, u32 buffer_length, u32 *bytes_read) 475 { 476 int input_char; 477 u32 end_of_line; 478 479 /* Standard acpi_os_get_line for all utilities except acpi_exec */ 480 481 for (end_of_line = 0;; end_of_line++) { 482 if (end_of_line >= buffer_length) { 483 return (AE_BUFFER_OVERFLOW); 484 } 485 486 if ((input_char = getchar()) == EOF) { 487 return (AE_ERROR); 488 } 489 490 if (!input_char || input_char == _ASCII_NEWLINE) { 491 break; 492 } 493 494 buffer[end_of_line] = (char)input_char; 495 } 496 497 /* Null terminate the buffer */ 498 499 buffer[end_of_line] = 0; 500 501 /* Return the number of bytes in the string */ 502 503 if (bytes_read) { 504 *bytes_read = end_of_line; 505 } 506 507 return (AE_OK); 508 } 509 #endif 510 511 #ifndef ACPI_USE_NATIVE_MEMORY_MAPPING 512 /****************************************************************************** 513 * 514 * FUNCTION: acpi_os_map_memory 515 * 516 * PARAMETERS: where - Physical address of memory to be mapped 517 * length - How much memory to map 518 * 519 * RETURN: Pointer to mapped memory. Null on error. 520 * 521 * DESCRIPTION: Map physical memory into caller's address space 522 * 523 *****************************************************************************/ 524 525 void *acpi_os_map_memory(acpi_physical_address where, acpi_size length) 526 { 527 528 return (ACPI_TO_POINTER((acpi_size)where)); 529 } 530 531 /****************************************************************************** 532 * 533 * FUNCTION: acpi_os_unmap_memory 534 * 535 * PARAMETERS: where - Logical address of memory to be unmapped 536 * length - How much memory to unmap 537 * 538 * RETURN: None. 539 * 540 * DESCRIPTION: Delete a previously created mapping. Where and Length must 541 * correspond to a previous mapping exactly. 542 * 543 *****************************************************************************/ 544 545 void acpi_os_unmap_memory(void *where, acpi_size length) 546 { 547 548 return; 549 } 550 #endif 551 552 /****************************************************************************** 553 * 554 * FUNCTION: acpi_os_allocate 555 * 556 * PARAMETERS: size - Amount to allocate, in bytes 557 * 558 * RETURN: Pointer to the new allocation. Null on error. 559 * 560 * DESCRIPTION: Allocate memory. Algorithm is dependent on the OS. 561 * 562 *****************************************************************************/ 563 564 void *acpi_os_allocate(acpi_size size) 565 { 566 void *mem; 567 568 mem = (void *)malloc((size_t) size); 569 return (mem); 570 } 571 572 #ifdef USE_NATIVE_ALLOCATE_ZEROED 573 /****************************************************************************** 574 * 575 * FUNCTION: acpi_os_allocate_zeroed 576 * 577 * PARAMETERS: size - Amount to allocate, in bytes 578 * 579 * RETURN: Pointer to the new allocation. Null on error. 580 * 581 * DESCRIPTION: Allocate and zero memory. Algorithm is dependent on the OS. 582 * 583 *****************************************************************************/ 584 585 void *acpi_os_allocate_zeroed(acpi_size size) 586 { 587 void *mem; 588 589 mem = (void *)calloc(1, (size_t) size); 590 return (mem); 591 } 592 #endif 593 594 /****************************************************************************** 595 * 596 * FUNCTION: acpi_os_free 597 * 598 * PARAMETERS: mem - Pointer to previously allocated memory 599 * 600 * RETURN: None. 601 * 602 * DESCRIPTION: Free memory allocated via acpi_os_allocate 603 * 604 *****************************************************************************/ 605 606 void acpi_os_free(void *mem) 607 { 608 609 free(mem); 610 } 611 612 #ifdef ACPI_SINGLE_THREADED 613 /****************************************************************************** 614 * 615 * FUNCTION: Semaphore stub functions 616 * 617 * DESCRIPTION: Stub functions used for single-thread applications that do 618 * not require semaphore synchronization. Full implementations 619 * of these functions appear after the stubs. 620 * 621 *****************************************************************************/ 622 623 acpi_status 624 acpi_os_create_semaphore(u32 max_units, 625 u32 initial_units, acpi_handle *out_handle) 626 { 627 *out_handle = (acpi_handle)1; 628 return (AE_OK); 629 } 630 631 acpi_status acpi_os_delete_semaphore(acpi_handle handle) 632 { 633 return (AE_OK); 634 } 635 636 acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout) 637 { 638 return (AE_OK); 639 } 640 641 acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units) 642 { 643 return (AE_OK); 644 } 645 646 #else 647 /****************************************************************************** 648 * 649 * FUNCTION: acpi_os_create_semaphore 650 * 651 * PARAMETERS: initial_units - Units to be assigned to the new semaphore 652 * out_handle - Where a handle will be returned 653 * 654 * RETURN: Status 655 * 656 * DESCRIPTION: Create an OS semaphore 657 * 658 *****************************************************************************/ 659 660 acpi_status 661 acpi_os_create_semaphore(u32 max_units, 662 u32 initial_units, acpi_handle *out_handle) 663 { 664 sem_t *sem; 665 666 if (!out_handle) { 667 return (AE_BAD_PARAMETER); 668 } 669 #ifdef __APPLE__ 670 { 671 static int semaphore_count = 0; 672 char semaphore_name[32]; 673 674 snprintf(semaphore_name, sizeof(semaphore_name), "acpi_sem_%d", 675 semaphore_count++); 676 printf("%s\n", semaphore_name); 677 sem = 678 sem_open(semaphore_name, O_EXCL | O_CREAT, 0755, 679 initial_units); 680 if (!sem) { 681 return (AE_NO_MEMORY); 682 } 683 sem_unlink(semaphore_name); /* This just deletes the name */ 684 } 685 686 #else 687 sem = acpi_os_allocate(sizeof(sem_t)); 688 if (!sem) { 689 return (AE_NO_MEMORY); 690 } 691 692 if (sem_init(sem, 0, initial_units) == -1) { 693 acpi_os_free(sem); 694 return (AE_BAD_PARAMETER); 695 } 696 #endif 697 698 *out_handle = (acpi_handle)sem; 699 return (AE_OK); 700 } 701 702 /****************************************************************************** 703 * 704 * FUNCTION: acpi_os_delete_semaphore 705 * 706 * PARAMETERS: handle - Handle returned by acpi_os_create_semaphore 707 * 708 * RETURN: Status 709 * 710 * DESCRIPTION: Delete an OS semaphore 711 * 712 *****************************************************************************/ 713 714 acpi_status acpi_os_delete_semaphore(acpi_handle handle) 715 { 716 sem_t *sem = (sem_t *) handle; 717 718 if (!sem) { 719 return (AE_BAD_PARAMETER); 720 } 721 #ifdef __APPLE__ 722 if (sem_close(sem) == -1) { 723 return (AE_BAD_PARAMETER); 724 } 725 #else 726 if (sem_destroy(sem) == -1) { 727 return (AE_BAD_PARAMETER); 728 } 729 #endif 730 731 return (AE_OK); 732 } 733 734 /****************************************************************************** 735 * 736 * FUNCTION: acpi_os_wait_semaphore 737 * 738 * PARAMETERS: handle - Handle returned by acpi_os_create_semaphore 739 * units - How many units to wait for 740 * msec_timeout - How long to wait (milliseconds) 741 * 742 * RETURN: Status 743 * 744 * DESCRIPTION: Wait for units 745 * 746 *****************************************************************************/ 747 748 acpi_status 749 acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 msec_timeout) 750 { 751 acpi_status status = AE_OK; 752 sem_t *sem = (sem_t *) handle; 753 int ret_val; 754 #ifndef ACPI_USE_ALTERNATE_TIMEOUT 755 struct timespec time; 756 #endif 757 758 if (!sem) { 759 return (AE_BAD_PARAMETER); 760 } 761 762 switch (msec_timeout) { 763 /* 764 * No Wait: 765 * -------- 766 * A zero timeout value indicates that we shouldn't wait - just 767 * acquire the semaphore if available otherwise return AE_TIME 768 * (a.k.a. 'would block'). 769 */ 770 case 0: 771 772 if (sem_trywait(sem) == -1) { 773 status = (AE_TIME); 774 } 775 break; 776 777 /* Wait Indefinitely */ 778 779 case ACPI_WAIT_FOREVER: 780 781 while (((ret_val = sem_wait(sem)) == -1) && (errno == EINTR)) { 782 continue; /* Restart if interrupted */ 783 } 784 if (ret_val != 0) { 785 status = (AE_TIME); 786 } 787 break; 788 789 /* Wait with msec_timeout */ 790 791 default: 792 793 #ifdef ACPI_USE_ALTERNATE_TIMEOUT 794 /* 795 * Alternate timeout mechanism for environments where 796 * sem_timedwait is not available or does not work properly. 797 */ 798 while (msec_timeout) { 799 if (sem_trywait(sem) == 0) { 800 801 /* Got the semaphore */ 802 return (AE_OK); 803 } 804 805 if (msec_timeout >= 10) { 806 msec_timeout -= 10; 807 usleep(10 * ACPI_USEC_PER_MSEC); /* ten milliseconds */ 808 } else { 809 msec_timeout--; 810 usleep(ACPI_USEC_PER_MSEC); /* one millisecond */ 811 } 812 } 813 status = (AE_TIME); 814 #else 815 /* 816 * The interface to sem_timedwait is an absolute time, so we need to 817 * get the current time, then add in the millisecond Timeout value. 818 */ 819 if (clock_gettime(CLOCK_REALTIME, &time) == -1) { 820 perror("clock_gettime"); 821 return (AE_TIME); 822 } 823 824 time.tv_sec += (msec_timeout / ACPI_MSEC_PER_SEC); 825 time.tv_nsec += 826 ((msec_timeout % ACPI_MSEC_PER_SEC) * ACPI_NSEC_PER_MSEC); 827 828 /* Handle nanosecond overflow (field must be less than one second) */ 829 830 if (time.tv_nsec >= ACPI_NSEC_PER_SEC) { 831 time.tv_sec += (time.tv_nsec / ACPI_NSEC_PER_SEC); 832 time.tv_nsec = (time.tv_nsec % ACPI_NSEC_PER_SEC); 833 } 834 835 while (((ret_val = sem_timedwait(sem, &time)) == -1) 836 && (errno == EINTR)) { 837 continue; /* Restart if interrupted */ 838 839 } 840 841 if (ret_val != 0) { 842 if (errno != ETIMEDOUT) { 843 perror("sem_timedwait"); 844 } 845 status = (AE_TIME); 846 } 847 #endif 848 break; 849 } 850 851 return (status); 852 } 853 854 /****************************************************************************** 855 * 856 * FUNCTION: acpi_os_signal_semaphore 857 * 858 * PARAMETERS: handle - Handle returned by acpi_os_create_semaphore 859 * units - Number of units to send 860 * 861 * RETURN: Status 862 * 863 * DESCRIPTION: Send units 864 * 865 *****************************************************************************/ 866 867 acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units) 868 { 869 sem_t *sem = (sem_t *) handle; 870 871 if (!sem) { 872 return (AE_BAD_PARAMETER); 873 } 874 875 if (sem_post(sem) == -1) { 876 return (AE_LIMIT); 877 } 878 879 return (AE_OK); 880 } 881 882 #endif /* ACPI_SINGLE_THREADED */ 883 884 /****************************************************************************** 885 * 886 * FUNCTION: Spinlock interfaces 887 * 888 * DESCRIPTION: Map these interfaces to semaphore interfaces 889 * 890 *****************************************************************************/ 891 892 acpi_status acpi_os_create_lock(acpi_spinlock * out_handle) 893 { 894 895 return (acpi_os_create_semaphore(1, 1, out_handle)); 896 } 897 898 void acpi_os_delete_lock(acpi_spinlock handle) 899 { 900 acpi_os_delete_semaphore(handle); 901 } 902 903 acpi_cpu_flags acpi_os_acquire_lock(acpi_handle handle) 904 { 905 acpi_os_wait_semaphore(handle, 1, 0xFFFF); 906 return (0); 907 } 908 909 void acpi_os_release_lock(acpi_spinlock handle, acpi_cpu_flags flags) 910 { 911 acpi_os_signal_semaphore(handle, 1); 912 } 913 914 /****************************************************************************** 915 * 916 * FUNCTION: acpi_os_install_interrupt_handler 917 * 918 * PARAMETERS: interrupt_number - Level handler should respond to. 919 * isr - Address of the ACPI interrupt handler 920 * except_ptr - Where status is returned 921 * 922 * RETURN: Handle to the newly installed handler. 923 * 924 * DESCRIPTION: Install an interrupt handler. Used to install the ACPI 925 * OS-independent handler. 926 * 927 *****************************************************************************/ 928 929 u32 930 acpi_os_install_interrupt_handler(u32 interrupt_number, 931 acpi_osd_handler service_routine, 932 void *context) 933 { 934 935 return (AE_OK); 936 } 937 938 /****************************************************************************** 939 * 940 * FUNCTION: acpi_os_remove_interrupt_handler 941 * 942 * PARAMETERS: handle - Returned when handler was installed 943 * 944 * RETURN: Status 945 * 946 * DESCRIPTION: Uninstalls an interrupt handler. 947 * 948 *****************************************************************************/ 949 950 acpi_status 951 acpi_os_remove_interrupt_handler(u32 interrupt_number, 952 acpi_osd_handler service_routine) 953 { 954 955 return (AE_OK); 956 } 957 958 /****************************************************************************** 959 * 960 * FUNCTION: acpi_os_stall 961 * 962 * PARAMETERS: microseconds - Time to sleep 963 * 964 * RETURN: Blocks until sleep is completed. 965 * 966 * DESCRIPTION: Sleep at microsecond granularity 967 * 968 *****************************************************************************/ 969 970 void acpi_os_stall(u32 microseconds) 971 { 972 973 if (microseconds) { 974 usleep(microseconds); 975 } 976 } 977 978 /****************************************************************************** 979 * 980 * FUNCTION: acpi_os_sleep 981 * 982 * PARAMETERS: milliseconds - Time to sleep 983 * 984 * RETURN: Blocks until sleep is completed. 985 * 986 * DESCRIPTION: Sleep at millisecond granularity 987 * 988 *****************************************************************************/ 989 990 void acpi_os_sleep(u64 milliseconds) 991 { 992 993 /* Sleep for whole seconds */ 994 995 sleep(milliseconds / ACPI_MSEC_PER_SEC); 996 997 /* 998 * Sleep for remaining microseconds. 999 * Arg to usleep() is in usecs and must be less than 1,000,000 (1 second). 1000 */ 1001 usleep((milliseconds % ACPI_MSEC_PER_SEC) * ACPI_USEC_PER_MSEC); 1002 } 1003 1004 /****************************************************************************** 1005 * 1006 * FUNCTION: acpi_os_get_timer 1007 * 1008 * PARAMETERS: None 1009 * 1010 * RETURN: Current time in 100 nanosecond units 1011 * 1012 * DESCRIPTION: Get the current system time 1013 * 1014 *****************************************************************************/ 1015 1016 u64 acpi_os_get_timer(void) 1017 { 1018 struct timeval time; 1019 1020 /* This timer has sufficient resolution for user-space application code */ 1021 1022 gettimeofday(&time, NULL); 1023 1024 /* (Seconds * 10^7 = 100ns(10^-7)) + (Microseconds(10^-6) * 10^1 = 100ns) */ 1025 1026 return (((u64)time.tv_sec * ACPI_100NSEC_PER_SEC) + 1027 ((u64)time.tv_usec * ACPI_100NSEC_PER_USEC)); 1028 } 1029 1030 /****************************************************************************** 1031 * 1032 * FUNCTION: acpi_os_read_pci_configuration 1033 * 1034 * PARAMETERS: pci_id - Seg/Bus/Dev 1035 * pci_register - Device Register 1036 * value - Buffer where value is placed 1037 * width - Number of bits 1038 * 1039 * RETURN: Status 1040 * 1041 * DESCRIPTION: Read data from PCI configuration space 1042 * 1043 *****************************************************************************/ 1044 1045 acpi_status 1046 acpi_os_read_pci_configuration(struct acpi_pci_id *pci_id, 1047 u32 pci_register, u64 *value, u32 width) 1048 { 1049 1050 *value = 0; 1051 return (AE_OK); 1052 } 1053 1054 /****************************************************************************** 1055 * 1056 * FUNCTION: acpi_os_write_pci_configuration 1057 * 1058 * PARAMETERS: pci_id - Seg/Bus/Dev 1059 * pci_register - Device Register 1060 * value - Value to be written 1061 * width - Number of bits 1062 * 1063 * RETURN: Status. 1064 * 1065 * DESCRIPTION: Write data to PCI configuration space 1066 * 1067 *****************************************************************************/ 1068 1069 acpi_status 1070 acpi_os_write_pci_configuration(struct acpi_pci_id *pci_id, 1071 u32 pci_register, u64 value, u32 width) 1072 { 1073 1074 return (AE_OK); 1075 } 1076 1077 /****************************************************************************** 1078 * 1079 * FUNCTION: acpi_os_read_port 1080 * 1081 * PARAMETERS: address - Address of I/O port/register to read 1082 * value - Where value is placed 1083 * width - Number of bits 1084 * 1085 * RETURN: Value read from port 1086 * 1087 * DESCRIPTION: Read data from an I/O port or register 1088 * 1089 *****************************************************************************/ 1090 1091 acpi_status acpi_os_read_port(acpi_io_address address, u32 *value, u32 width) 1092 { 1093 1094 switch (width) { 1095 case 8: 1096 1097 *value = 0xFF; 1098 break; 1099 1100 case 16: 1101 1102 *value = 0xFFFF; 1103 break; 1104 1105 case 32: 1106 1107 *value = 0xFFFFFFFF; 1108 break; 1109 1110 default: 1111 1112 return (AE_BAD_PARAMETER); 1113 } 1114 1115 return (AE_OK); 1116 } 1117 1118 /****************************************************************************** 1119 * 1120 * FUNCTION: acpi_os_write_port 1121 * 1122 * PARAMETERS: address - Address of I/O port/register to write 1123 * value - Value to write 1124 * width - Number of bits 1125 * 1126 * RETURN: None 1127 * 1128 * DESCRIPTION: Write data to an I/O port or register 1129 * 1130 *****************************************************************************/ 1131 1132 acpi_status acpi_os_write_port(acpi_io_address address, u32 value, u32 width) 1133 { 1134 1135 return (AE_OK); 1136 } 1137 1138 /****************************************************************************** 1139 * 1140 * FUNCTION: acpi_os_read_memory 1141 * 1142 * PARAMETERS: address - Physical Memory Address to read 1143 * value - Where value is placed 1144 * width - Number of bits (8,16,32, or 64) 1145 * 1146 * RETURN: Value read from physical memory address. Always returned 1147 * as a 64-bit integer, regardless of the read width. 1148 * 1149 * DESCRIPTION: Read data from a physical memory address 1150 * 1151 *****************************************************************************/ 1152 1153 acpi_status 1154 acpi_os_read_memory(acpi_physical_address address, u64 *value, u32 width) 1155 { 1156 1157 switch (width) { 1158 case 8: 1159 case 16: 1160 case 32: 1161 case 64: 1162 1163 *value = 0; 1164 break; 1165 1166 default: 1167 1168 return (AE_BAD_PARAMETER); 1169 } 1170 return (AE_OK); 1171 } 1172 1173 /****************************************************************************** 1174 * 1175 * FUNCTION: acpi_os_write_memory 1176 * 1177 * PARAMETERS: address - Physical Memory Address to write 1178 * value - Value to write 1179 * width - Number of bits (8,16,32, or 64) 1180 * 1181 * RETURN: None 1182 * 1183 * DESCRIPTION: Write data to a physical memory address 1184 * 1185 *****************************************************************************/ 1186 1187 acpi_status 1188 acpi_os_write_memory(acpi_physical_address address, u64 value, u32 width) 1189 { 1190 1191 return (AE_OK); 1192 } 1193 1194 /****************************************************************************** 1195 * 1196 * FUNCTION: acpi_os_readable 1197 * 1198 * PARAMETERS: pointer - Area to be verified 1199 * length - Size of area 1200 * 1201 * RETURN: TRUE if readable for entire length 1202 * 1203 * DESCRIPTION: Verify that a pointer is valid for reading 1204 * 1205 *****************************************************************************/ 1206 1207 u8 acpi_os_readable(void *pointer, acpi_size length) 1208 { 1209 1210 return (TRUE); 1211 } 1212 1213 /****************************************************************************** 1214 * 1215 * FUNCTION: acpi_os_writable 1216 * 1217 * PARAMETERS: pointer - Area to be verified 1218 * length - Size of area 1219 * 1220 * RETURN: TRUE if writable for entire length 1221 * 1222 * DESCRIPTION: Verify that a pointer is valid for writing 1223 * 1224 *****************************************************************************/ 1225 1226 u8 acpi_os_writable(void *pointer, acpi_size length) 1227 { 1228 1229 return (TRUE); 1230 } 1231 1232 /****************************************************************************** 1233 * 1234 * FUNCTION: acpi_os_signal 1235 * 1236 * PARAMETERS: function - ACPI A signal function code 1237 * info - Pointer to function-dependent structure 1238 * 1239 * RETURN: Status 1240 * 1241 * DESCRIPTION: Miscellaneous functions. Example implementation only. 1242 * 1243 *****************************************************************************/ 1244 1245 acpi_status acpi_os_signal(u32 function, void *info) 1246 { 1247 1248 switch (function) { 1249 case ACPI_SIGNAL_FATAL: 1250 1251 break; 1252 1253 case ACPI_SIGNAL_BREAKPOINT: 1254 1255 break; 1256 1257 default: 1258 1259 break; 1260 } 1261 1262 return (AE_OK); 1263 } 1264 1265 /* Optional multi-thread support */ 1266 1267 #ifndef ACPI_SINGLE_THREADED 1268 /****************************************************************************** 1269 * 1270 * FUNCTION: acpi_os_get_thread_id 1271 * 1272 * PARAMETERS: None 1273 * 1274 * RETURN: Id of the running thread 1275 * 1276 * DESCRIPTION: Get the ID of the current (running) thread 1277 * 1278 *****************************************************************************/ 1279 1280 acpi_thread_id acpi_os_get_thread_id(void) 1281 { 1282 pthread_t thread; 1283 1284 thread = pthread_self(); 1285 return (ACPI_CAST_PTHREAD_T(thread)); 1286 } 1287 1288 /****************************************************************************** 1289 * 1290 * FUNCTION: acpi_os_execute 1291 * 1292 * PARAMETERS: type - Type of execution 1293 * function - Address of the function to execute 1294 * context - Passed as a parameter to the function 1295 * 1296 * RETURN: Status. 1297 * 1298 * DESCRIPTION: Execute a new thread 1299 * 1300 *****************************************************************************/ 1301 1302 acpi_status 1303 acpi_os_execute(acpi_execute_type type, 1304 acpi_osd_exec_callback function, void *context) 1305 { 1306 pthread_t thread; 1307 int ret; 1308 1309 ret = 1310 pthread_create(&thread, NULL, (PTHREAD_CALLBACK) function, context); 1311 if (ret) { 1312 acpi_os_printf("Create thread failed"); 1313 } 1314 return (0); 1315 } 1316 1317 #else /* ACPI_SINGLE_THREADED */ 1318 acpi_thread_id acpi_os_get_thread_id(void) 1319 { 1320 return (1); 1321 } 1322 1323 acpi_status 1324 acpi_os_execute(acpi_execute_type type, 1325 acpi_osd_exec_callback function, void *context) 1326 { 1327 1328 function(context); 1329 1330 return (AE_OK); 1331 } 1332 1333 #endif /* ACPI_SINGLE_THREADED */ 1334 1335 /****************************************************************************** 1336 * 1337 * FUNCTION: acpi_os_wait_events_complete 1338 * 1339 * PARAMETERS: None 1340 * 1341 * RETURN: None 1342 * 1343 * DESCRIPTION: Wait for all asynchronous events to complete. This 1344 * implementation does nothing. 1345 * 1346 *****************************************************************************/ 1347 1348 void acpi_os_wait_events_complete(void) 1349 { 1350 return; 1351 } 1352