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