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