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