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