tools/power/acpi/os_specific/service_layers/osunixxf.c

   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 }