text: /******************************************************************************
   *
   * Module Name: osunixxf - UNIX OSL interfaces
   *
   *****************************************************************************/
  
  /******************************************************************************
   *
   * 1. Copyright Notice
   *
   * Some or all of this work - Copyright (c) 1999 - 2020, Intel Corp.
   * All rights reserved.
   *
   * 2. License
   *
   * 2.1. This is your license from Intel Corp. under its intellectual property
   * rights. You may have additional license terms from the party that provided
   * you this software, covering your right to use that party's intellectual
   * property rights.
   *
   * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
   * copy of the source code appearing in this file ("Covered Code") an
   * irrevocable, perpetual, worldwide license under Intel's copyrights in the
   * base code distributed originally by Intel ("Original Intel Code") to copy,
   * make derivatives, distribute, use and display any portion of the Covered
   * Code in any form, with the right to sublicense such rights; and
   *
   * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
   * license (with the right to sublicense), under only those claims of Intel
   * patents that are infringed by the Original Intel Code, to make, use, sell,
   * offer to sell, and import the Covered Code and derivative works thereof
   * solely to the minimum extent necessary to exercise the above copyright
   * license, and in no event shall the patent license extend to any additions
   * to or modifications of the Original Intel Code. No other license or right
   * is granted directly or by implication, estoppel or otherwise;
   *
   * The above copyright and patent license is granted only if the following
   * conditions are met:
   *
   * 3. Conditions
   *
   * 3.1. Redistribution of Source with Rights to Further Distribute Source.
   * Redistribution of source code of any substantial portion of the Covered
   * Code or modification with rights to further distribute source must include
   * the above Copyright Notice, the above License, this list of Conditions,
   * and the following Disclaimer and Export Compliance provision. In addition,
   * Licensee must cause all Covered Code to which Licensee contributes to
   * contain a file documenting the changes Licensee made to create that Covered
   * Code and the date of any change. Licensee must include in that file the
   * documentation of any changes made by any predecessor Licensee. Licensee
   * must include a prominent statement that the modification is derived,
   * directly or indirectly, from Original Intel Code.
   *
   * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
   * Redistribution of source code of any substantial portion of the Covered
   * Code or modification without rights to further distribute source must
   * include the following Disclaimer and Export Compliance provision in the
   * documentation and/or other materials provided with distribution. In
   * addition, Licensee may not authorize further sublicense of source of any
   * portion of the Covered Code, and must include terms to the effect that the
   * license from Licensee to its licensee is limited to the intellectual
   * property embodied in the software Licensee provides to its licensee, and
   * not to intellectual property embodied in modifications its licensee may
   * make.
   *
   * 3.3. Redistribution of Executable. Redistribution in executable form of any
   * substantial portion of the Covered Code or modification must reproduce the
   * above Copyright Notice, and the following Disclaimer and Export Compliance
   * provision in the documentation and/or other materials provided with the
   * distribution.
   *
   * 3.4. Intel retains all right, title, and interest in and to the Original
   * Intel Code.
   *
   * 3.5. Neither the name Intel nor any other trademark owned or controlled by
   * Intel shall be used in advertising or otherwise to promote the sale, use or
   * other dealings in products derived from or relating to the Covered Code
   * without prior written authorization from Intel.
   *
   * 4. Disclaimer and Export Compliance
   *
   * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
   * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
   * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
   * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
   * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
   * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
   * PARTICULAR PURPOSE.
   *
   * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
   * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
   * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
   * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
   * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
   * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
   * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
   * LIMITED REMEDY.
   *
   * 4.3. Licensee shall not export, either directly or indirectly, any of this
   * software or system incorporating such software without first obtaining any
   * required license or other approval from the U. S. Department of Commerce or
   * any other agency or department of the United States Government. In the
   * event Licensee exports any such software from the United States or
   * re-exports any such software from a foreign destination, Licensee shall
   * ensure that the distribution and export/re-export of the software is in
   * compliance with all laws, regulations, orders, or other restrictions of the
   * U.S. Export Administration Regulations. Licensee agrees that neither it nor
   * any of its subsidiaries will export/re-export any technical data, process,
   * software, or service, directly or indirectly, to any country for which the
   * United States government or any agency thereof requires an export license,
   * other governmental approval, or letter of assurance, without first obtaining
   * such license, approval or letter.
   *
   *****************************************************************************
   *
   * Alternatively, you may choose to be licensed under the terms of the
   * following license:
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions, and the following disclaimer,
   *    without modification.
   * 2. Redistributions in binary form must reproduce at minimum a disclaimer
   *    substantially similar to the "NO WARRANTY" disclaimer below
   *    ("Disclaimer") and any redistribution must be conditioned upon
   *    including a substantially similar Disclaimer requirement for further
   *    binary redistribution.
   * 3. Neither the names of the above-listed copyright holders nor the names
   *    of any contributors may be used to endorse or promote products derived
   *    from this software without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *
   * Alternatively, you may choose to be licensed under the terms of the
   * GNU General Public License ("GPL") version 2 as published by the Free
   * Software Foundation.
   *
   *****************************************************************************/
  
  /*
   * These interfaces are required in order to compile the ASL compiler and the
   * various ACPICA tools under Linux or other Unix-like system.
   */
  #include "acpi.h"
  #include "accommon.h"
  #include "amlcode.h"
  #include "acparser.h"
  #include "acdebug.h"
  
  #include <stdio.h>
  #include <stdlib.h>
  #include <stdarg.h>
  #include <unistd.h>
  #include <sys/time.h>
  #include <semaphore.h>
  #include <pthread.h>
  #include <errno.h>
  
  #define _COMPONENT          ACPI_OS_SERVICES
          ACPI_MODULE_NAME    ("osunixxf")
  
  
  /* Upcalls to AcpiExec */
  
  void
  AeTableOverride (
      ACPI_TABLE_HEADER       *ExistingTable,
      ACPI_TABLE_HEADER       **NewTable);
  
  typedef void* (*PTHREAD_CALLBACK) (void *);
  
  /* Buffer used by AcpiOsVprintf */
  
  #define ACPI_VPRINTF_BUFFER_SIZE    512
  #define _ASCII_NEWLINE              '\n'
  
  /* Terminal support for AcpiExec only */
  
  #ifdef ACPI_EXEC_APP
  #include <termios.h>
  
  struct termios              OriginalTermAttributes;
  int                         TermAttributesWereSet = 0;
  
  ACPI_STATUS
  AcpiUtReadLine (
      char                    *Buffer,
      UINT32                  BufferLength,
      UINT32                  *BytesRead);
  
  static void
  OsEnterLineEditMode (
      void);
  
  static void
  OsExitLineEditMode (
      void);
  
  
  /******************************************************************************
   *
   * FUNCTION:    OsEnterLineEditMode, OsExitLineEditMode
   *
   * PARAMETERS:  None
   *
   * RETURN:      None
   *
   * DESCRIPTION: Enter/Exit the raw character input mode for the terminal.
   *
   * Interactive line-editing support for the AML debugger. Used with the
   * common/acgetline module.
   *
   * readline() is not used because of non-portability. It is not available
   * on all systems, and if it is, often the package must be manually installed.
   *
   * Therefore, we use the POSIX tcgetattr/tcsetattr and do the minimal line
   * editing that we need in AcpiOsGetLine.
   *
   * If the POSIX tcgetattr/tcsetattr interfaces are unavailable, these
   * calls will also work:
   *     For OsEnterLineEditMode: system ("stty cbreak -echo")
   *     For OsExitLineEditMode:  system ("stty cooked echo")
   *
   *****************************************************************************/
  
  static void
  OsEnterLineEditMode (
      void)
  {
      struct termios          LocalTermAttributes;
  
  
      TermAttributesWereSet = 0;
  
      /* STDIN must be a terminal */
  
      if (!isatty (STDIN_FILENO))
      {
          return;
      }
  
      /* Get and keep the original attributes */
  
      if (tcgetattr (STDIN_FILENO, &OriginalTermAttributes))
      {
          fprintf (stderr, "Could not get terminal attributes!\n");
          return;
      }
  
      /* Set the new attributes to enable raw character input */
  
      memcpy (&LocalTermAttributes, &OriginalTermAttributes,
          sizeof (struct termios));
  
      LocalTermAttributes.c_lflag &= ~(ICANON | ECHO);
      LocalTermAttributes.c_cc[VMIN] = 1;
      LocalTermAttributes.c_cc[VTIME] = 0;
  
      if (tcsetattr (STDIN_FILENO, TCSANOW, &LocalTermAttributes))
      {
          fprintf (stderr, "Could not set terminal attributes!\n");
          return;
      }
  
      TermAttributesWereSet = 1;
  }
  
  
  static void
  OsExitLineEditMode (
      void)
  {
  
      if (!TermAttributesWereSet)
      {
          return;
      }
  
      /* Set terminal attributes back to the original values */
  
      if (tcsetattr (STDIN_FILENO, TCSANOW, &OriginalTermAttributes))
      {
          fprintf (stderr, "Could not restore terminal attributes!\n");
      }
  }
  
  
  #else
  
  /* These functions are not needed for other ACPICA utilities */
  
  #define OsEnterLineEditMode()
  #define OsExitLineEditMode()
  #endif
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsInitialize, AcpiOsTerminate
   *
   * PARAMETERS:  None
   *
   * RETURN:      Status
   *
   * DESCRIPTION: Initialize and terminate this module.
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsInitialize (
      void)
  {
      ACPI_STATUS            Status;
  
  
      AcpiGbl_OutputFile = stdout;
  
      OsEnterLineEditMode ();
  
      Status = AcpiOsCreateLock (&AcpiGbl_PrintLock);
      if (ACPI_FAILURE (Status))
      {
          return (Status);
      }
  
      return (AE_OK);
  }
  
  ACPI_STATUS
  AcpiOsTerminate (
      void)
  {
  
      OsExitLineEditMode ();
      return (AE_OK);
  }
  
  
  #ifndef ACPI_USE_NATIVE_RSDP_POINTER
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsGetRootPointer
   *
   * PARAMETERS:  None
   *
   * RETURN:      RSDP physical address
   *
   * DESCRIPTION: Gets the ACPI root pointer (RSDP)
   *
   *****************************************************************************/
  
  ACPI_PHYSICAL_ADDRESS
  AcpiOsGetRootPointer (
      void)
  {
  
      return (0);
  }
  #endif
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsPredefinedOverride
   *
   * PARAMETERS:  InitVal             - Initial value of the predefined object
   *              NewVal              - The new value for the object
   *
   * RETURN:      Status, pointer to value. Null pointer returned if not
   *              overriding.
   *
   * DESCRIPTION: Allow the OS to override predefined names
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsPredefinedOverride (
      const ACPI_PREDEFINED_NAMES *InitVal,
      ACPI_STRING                 *NewVal)
  {
  
      if (!InitVal || !NewVal)
      {
          return (AE_BAD_PARAMETER);
      }
  
      *NewVal = NULL;
      return (AE_OK);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsTableOverride
   *
   * PARAMETERS:  ExistingTable       - Header of current table (probably
   *                                    firmware)
   *              NewTable            - Where an entire new table is returned.
   *
   * RETURN:      Status, pointer to new table. Null pointer returned if no
   *              table is available to override
   *
   * DESCRIPTION: Return a different version of a table if one is available
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsTableOverride (
      ACPI_TABLE_HEADER       *ExistingTable,
      ACPI_TABLE_HEADER       **NewTable)
  {
  
      if (!ExistingTable || !NewTable)
      {
          return (AE_BAD_PARAMETER);
      }
  
      *NewTable = NULL;
  
  #ifdef ACPI_EXEC_APP
  
      AeTableOverride (ExistingTable, NewTable);
      return (AE_OK);
  #else
  
      return (AE_NO_ACPI_TABLES);
  #endif
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsPhysicalTableOverride
   *
   * PARAMETERS:  ExistingTable       - Header of current table (probably firmware)
   *              NewAddress          - Where new table address is returned
   *                                    (Physical address)
   *              NewTableLength      - Where new table length is returned
   *
   * RETURN:      Status, address/length of new table. Null pointer returned
   *              if no table is available to override.
   *
   * DESCRIPTION: Returns AE_SUPPORT, function not used in user space.
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsPhysicalTableOverride (
      ACPI_TABLE_HEADER       *ExistingTable,
      ACPI_PHYSICAL_ADDRESS   *NewAddress,
      UINT32                  *NewTableLength)
  {
  
      return (AE_SUPPORT);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsEnterSleep
   *
   * PARAMETERS:  SleepState          - Which sleep state to enter
   *              RegaValue           - Register A value
   *              RegbValue           - Register B value
   *
   * RETURN:      Status
   *
   * DESCRIPTION: A hook before writing sleep registers to enter the sleep
   *              state. Return AE_CTRL_TERMINATE to skip further sleep register
   *              writes.
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsEnterSleep (
      UINT8                   SleepState,
      UINT32                  RegaValue,
      UINT32                  RegbValue)
  {
  
      return (AE_OK);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsRedirectOutput
   *
   * PARAMETERS:  Destination         - An open file handle/pointer
   *
   * RETURN:      None
   *
   * DESCRIPTION: Causes redirect of AcpiOsPrintf and AcpiOsVprintf
   *
   *****************************************************************************/
  
  void
  AcpiOsRedirectOutput (
      void                    *Destination)
  {
  
      AcpiGbl_OutputFile = Destination;
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsPrintf
   *
   * PARAMETERS:  fmt, ...            - Standard printf format
   *
   * RETURN:      None
   *
   * DESCRIPTION: Formatted output. Note: very similar to AcpiOsVprintf
   *              (performance), changes should be tracked in both functions.
   *
   *****************************************************************************/
  
  void ACPI_INTERNAL_VAR_XFACE
  AcpiOsPrintf (
      const char              *Fmt,
      ...)
  {
      va_list                 Args;
      UINT8                   Flags;
  
  
      Flags = AcpiGbl_DbOutputFlags;
      if (Flags & ACPI_DB_REDIRECTABLE_OUTPUT)
      {
          /* Output is directable to either a file (if open) or the console */
  
          if (AcpiGbl_DebugFile)
          {
              /* Output file is open, send the output there */
  
              va_start (Args, Fmt);
              vfprintf (AcpiGbl_DebugFile, Fmt, Args);
              va_end (Args);
          }
          else
          {
              /* No redirection, send output to console (once only!) */
  
              Flags |= ACPI_DB_CONSOLE_OUTPUT;
          }
      }
  
      if (Flags & ACPI_DB_CONSOLE_OUTPUT)
      {
          va_start (Args, Fmt);
          vfprintf (AcpiGbl_OutputFile, Fmt, Args);
          va_end (Args);
      }
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsVprintf
   *
   * PARAMETERS:  fmt                 - Standard printf format
   *              args                - Argument list
   *
   * RETURN:      None
   *
   * DESCRIPTION: Formatted output with argument list pointer. Note: very
   *              similar to AcpiOsPrintf, changes should be tracked in both
   *              functions.
   *
   *****************************************************************************/
  
  void
  AcpiOsVprintf (
      const char              *Fmt,
      va_list                 Args)
  {
      UINT8                   Flags;
      char                    Buffer[ACPI_VPRINTF_BUFFER_SIZE];
  
  
      /*
       * We build the output string in a local buffer because we may be
       * outputting the buffer twice. Using vfprintf is problematic because
       * some implementations modify the args pointer/structure during
       * execution. Thus, we use the local buffer for portability.
       *
       * Note: Since this module is intended for use by the various ACPICA
       * utilities/applications, we can safely declare the buffer on the stack.
       * Also, This function is used for relatively small error messages only.
       */
      vsnprintf (Buffer, ACPI_VPRINTF_BUFFER_SIZE, Fmt, Args);
  
      Flags = AcpiGbl_DbOutputFlags;
      if (Flags & ACPI_DB_REDIRECTABLE_OUTPUT)
      {
          /* Output is directable to either a file (if open) or the console */
  
          if (AcpiGbl_DebugFile)
          {
              /* Output file is open, send the output there */
  
              fputs (Buffer, AcpiGbl_DebugFile);
          }
          else
          {
              /* No redirection, send output to console (once only!) */
  
              Flags |= ACPI_DB_CONSOLE_OUTPUT;
          }
      }
  
      if (Flags & ACPI_DB_CONSOLE_OUTPUT)
      {
          fputs (Buffer, AcpiGbl_OutputFile);
      }
  }
  
  
  #ifndef ACPI_EXEC_APP
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsGetLine
   *
   * PARAMETERS:  Buffer              - Where to return the command line
   *              BufferLength        - Maximum length of Buffer
   *              BytesRead           - Where the actual byte count is returned
   *
   * RETURN:      Status and actual bytes read
   *
   * DESCRIPTION: Get the next input line from the terminal. NOTE: For the
   *              AcpiExec utility, we use the acgetline module instead to
   *              provide line-editing and history support.
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsGetLine (
      char                    *Buffer,
      UINT32                  BufferLength,
      UINT32                  *BytesRead)
  {
      int                     InputChar;
      UINT32                  EndOfLine;
  
  
      /* Standard AcpiOsGetLine for all utilities except AcpiExec */
  
      for (EndOfLine = 0; ; EndOfLine++)
      {
          if (EndOfLine >= BufferLength)
          {
              return (AE_BUFFER_OVERFLOW);
          }
  
          if ((InputChar = getchar ()) == EOF)
          {
              return (AE_ERROR);
          }
  
          if (!InputChar || InputChar == _ASCII_NEWLINE)
          {
              break;
          }
  
          Buffer[EndOfLine] = (char) InputChar;
      }
  
      /* Null terminate the buffer */
  
      Buffer[EndOfLine] = 0;
  
      /* Return the number of bytes in the string */
  
      if (BytesRead)
      {
          *BytesRead = EndOfLine;
      }
  
      return (AE_OK);
  }
  #endif
  
  
  #ifndef ACPI_USE_NATIVE_MEMORY_MAPPING
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsMapMemory
   *
   * PARAMETERS:  where               - Physical address of memory to be mapped
   *              length              - How much memory to map
   *
   * RETURN:      Pointer to mapped memory. Null on error.
   *
   * DESCRIPTION: Map physical memory into caller's address space
   *
   *****************************************************************************/
  
  void *
  AcpiOsMapMemory (
      ACPI_PHYSICAL_ADDRESS   where,
      ACPI_SIZE               length)
  {
  
      return (ACPI_TO_POINTER ((ACPI_SIZE) where));
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsUnmapMemory
   *
   * PARAMETERS:  where               - Logical address of memory to be unmapped
   *              length              - How much memory to unmap
   *
   * RETURN:      None.
   *
   * DESCRIPTION: Delete a previously created mapping. Where and Length must
   *              correspond to a previous mapping exactly.
   *
   *****************************************************************************/
  
  void
  AcpiOsUnmapMemory (
      void                    *where,
      ACPI_SIZE               length)
  {
  
      return;
  }
  #endif
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsAllocate
   *
   * PARAMETERS:  Size                - Amount to allocate, in bytes
   *
   * RETURN:      Pointer to the new allocation. Null on error.
   *
   * DESCRIPTION: Allocate memory. Algorithm is dependent on the OS.
   *
   *****************************************************************************/
  
  void *
  AcpiOsAllocate (
      ACPI_SIZE               size)
  {
      void                    *Mem;
  
  
      Mem = (void *) malloc ((size_t) size);
      return (Mem);
  }
  
  
  #ifdef USE_NATIVE_ALLOCATE_ZEROED
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsAllocateZeroed
   *
   * PARAMETERS:  Size                - Amount to allocate, in bytes
   *
   * RETURN:      Pointer to the new allocation. Null on error.
   *
   * DESCRIPTION: Allocate and zero memory. Algorithm is dependent on the OS.
   *
   *****************************************************************************/
  
  void *
  AcpiOsAllocateZeroed (
      ACPI_SIZE               size)
  {
      void                    *Mem;
  
  
      Mem = (void *) calloc (1, (size_t) size);
      return (Mem);
  }
  #endif
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsFree
   *
   * PARAMETERS:  mem                 - Pointer to previously allocated memory
   *
   * RETURN:      None.
   *
   * DESCRIPTION: Free memory allocated via AcpiOsAllocate
   *
   *****************************************************************************/
  
  void
  AcpiOsFree (
      void                    *mem)
  {
  
      free (mem);
  }
  
  
  #ifdef ACPI_SINGLE_THREADED
  /******************************************************************************
   *
   * FUNCTION:    Semaphore stub functions
   *
   * DESCRIPTION: Stub functions used for single-thread applications that do
   *              not require semaphore synchronization. Full implementations
   *              of these functions appear after the stubs.
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsCreateSemaphore (
      UINT32              MaxUnits,
      UINT32              InitialUnits,
      ACPI_HANDLE         *OutHandle)
  {
      *OutHandle = (ACPI_HANDLE) 1;
      return (AE_OK);
  }
  
  ACPI_STATUS
  AcpiOsDeleteSemaphore (
      ACPI_HANDLE         Handle)
  {
      return (AE_OK);
  }
  
  ACPI_STATUS
  AcpiOsWaitSemaphore (
      ACPI_HANDLE         Handle,
      UINT32              Units,
      UINT16              Timeout)
  {
      return (AE_OK);
  }
  
  ACPI_STATUS
  AcpiOsSignalSemaphore (
      ACPI_HANDLE         Handle,
      UINT32              Units)
  {
      return (AE_OK);
  }
  
  #else
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsCreateSemaphore
   *
   * PARAMETERS:  InitialUnits        - Units to be assigned to the new semaphore
   *              OutHandle           - Where a handle will be returned
   *
   * RETURN:      Status
   *
   * DESCRIPTION: Create an OS semaphore
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsCreateSemaphore (
      UINT32              MaxUnits,
      UINT32              InitialUnits,
      ACPI_HANDLE         *OutHandle)
  {
      sem_t               *Sem;
  
  
      if (!OutHandle)
      {
          return (AE_BAD_PARAMETER);
      }
  
  #ifdef __APPLE__
      {
          static int      SemaphoreCount = 0;
          char            SemaphoreName[32];
  
          snprintf (SemaphoreName, sizeof (SemaphoreName), "acpi_sem_%d",
              SemaphoreCount++);
          printf ("%s\n", SemaphoreName);
          Sem = sem_open (SemaphoreName, O_EXCL|O_CREAT, 0755, InitialUnits);
          if (!Sem)
          {
              return (AE_NO_MEMORY);
          }
          sem_unlink (SemaphoreName); /* This just deletes the name */
      }
  
  #else
      Sem = AcpiOsAllocate (sizeof (sem_t));
      if (!Sem)
      {
          return (AE_NO_MEMORY);
      }
  
      if (sem_init (Sem, 0, InitialUnits) == -1)
      {
          AcpiOsFree (Sem);
          return (AE_BAD_PARAMETER);
      }
  #endif
  
      *OutHandle = (ACPI_HANDLE) Sem;
      return (AE_OK);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsDeleteSemaphore
   *
   * PARAMETERS:  Handle              - Handle returned by AcpiOsCreateSemaphore
   *
   * RETURN:      Status
   *
   * DESCRIPTION: Delete an OS semaphore
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsDeleteSemaphore (
      ACPI_HANDLE         Handle)
  {
      sem_t               *Sem = (sem_t *) Handle;
  
  
      if (!Sem)
      {
          return (AE_BAD_PARAMETER);
      }
  
  #ifdef __APPLE__
      if (sem_close (Sem) == -1)
      {
          return (AE_BAD_PARAMETER);
      }
  #else
      if (sem_destroy (Sem) == -1)
      {
          return (AE_BAD_PARAMETER);
      }
  #endif
  
      return (AE_OK);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsWaitSemaphore
   *
   * PARAMETERS:  Handle              - Handle returned by AcpiOsCreateSemaphore
   *              Units               - How many units to wait for
   *              MsecTimeout         - How long to wait (milliseconds)
   *
   * RETURN:      Status
   *
   * DESCRIPTION: Wait for units
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsWaitSemaphore (
      ACPI_HANDLE         Handle,
      UINT32              Units,
      UINT16              MsecTimeout)
  {
      ACPI_STATUS         Status = AE_OK;
      sem_t               *Sem = (sem_t *) Handle;
      int                 RetVal;
  #ifndef ACPI_USE_ALTERNATE_TIMEOUT
      struct timespec     Time;
  #endif
  
  
      if (!Sem)
      {
          return (AE_BAD_PARAMETER);
      }
  
      switch (MsecTimeout)
      {
      /*
       * No Wait:
       * --------
       * A zero timeout value indicates that we shouldn't wait - just
       * acquire the semaphore if available otherwise return AE_TIME
       * (a.k.a. 'would block').
       */
      case 0:
  
          if (sem_trywait(Sem) == -1)
          {
              Status = (AE_TIME);
          }
          break;
  
      /* Wait Indefinitely */
  
      case ACPI_WAIT_FOREVER:
  
          while (((RetVal = sem_wait (Sem)) == -1) && (errno == EINTR))
          {
              continue;   /* Restart if interrupted */
          }
          if (RetVal != 0)
          {
              Status = (AE_TIME);
          }
          break;
  
  
      /* Wait with MsecTimeout */
  
      default:
  
  #ifdef ACPI_USE_ALTERNATE_TIMEOUT
          /*
           * Alternate timeout mechanism for environments where
           * sem_timedwait is not available or does not work properly.
           */
          while (MsecTimeout)
          {
              if (sem_trywait (Sem) == 0)
              {
                  /* Got the semaphore */
                  return (AE_OK);
              }
  
              if (MsecTimeout >= 10)
              {
                  MsecTimeout -= 10;
                  usleep (10 * ACPI_USEC_PER_MSEC); /* ten milliseconds */
              }
              else
              {
                  MsecTimeout--;
                  usleep (ACPI_USEC_PER_MSEC); /* one millisecond */
              }
          }
          Status = (AE_TIME);
  #else
          /*
           * The interface to sem_timedwait is an absolute time, so we need to
           * get the current time, then add in the millisecond Timeout value.
           */
          if (clock_gettime (CLOCK_REALTIME, &Time) == -1)
          {
              perror ("clock_gettime");
              return (AE_TIME);
          }
  
          Time.tv_sec += (MsecTimeout / ACPI_MSEC_PER_SEC);
          Time.tv_nsec += ((MsecTimeout % ACPI_MSEC_PER_SEC) * ACPI_NSEC_PER_MSEC);
  
          /* Handle nanosecond overflow (field must be less than one second) */
  
          if (Time.tv_nsec >= ACPI_NSEC_PER_SEC)
          {
              Time.tv_sec += (Time.tv_nsec / ACPI_NSEC_PER_SEC);
              Time.tv_nsec = (Time.tv_nsec % ACPI_NSEC_PER_SEC);
          }
  
          while (((RetVal = sem_timedwait (Sem, &Time)) == -1) && (errno == EINTR))
          {
              continue;   /* Restart if interrupted */
  
          }
  
          if (RetVal != 0)
          {
              if (errno != ETIMEDOUT)
              {
                  perror ("sem_timedwait");
              }
              Status = (AE_TIME);
          }
  #endif
          break;
      }
  
      return (Status);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsSignalSemaphore
   *
   * PARAMETERS:  Handle              - Handle returned by AcpiOsCreateSemaphore
   *              Units               - Number of units to send
   *
   * RETURN:      Status
   *
   * DESCRIPTION: Send units
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsSignalSemaphore (
      ACPI_HANDLE         Handle,
      UINT32              Units)
  {
      sem_t               *Sem = (sem_t *)Handle;
  
  
      if (!Sem)
      {
          return (AE_BAD_PARAMETER);
      }
  
      if (sem_post (Sem) == -1)
      {
          return (AE_LIMIT);
      }
  
      return (AE_OK);
  }
  
  #endif /* ACPI_SINGLE_THREADED */
  
  
  /******************************************************************************
   *
   * FUNCTION:    Spinlock interfaces
   *
   * DESCRIPTION: Map these interfaces to semaphore interfaces
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsCreateLock (
      ACPI_SPINLOCK           *OutHandle)
  {
  
      return (AcpiOsCreateSemaphore (1, 1, OutHandle));
  }
  
  
  void
  AcpiOsDeleteLock (
      ACPI_SPINLOCK           Handle)
  {
      AcpiOsDeleteSemaphore (Handle);
  }
  
  
  ACPI_CPU_FLAGS
  AcpiOsAcquireLock (
      ACPI_HANDLE             Handle)
  {
      AcpiOsWaitSemaphore (Handle, 1, 0xFFFF);
      return (0);
  }
  
  
  void
  AcpiOsReleaseLock (
      ACPI_SPINLOCK           Handle,
      ACPI_CPU_FLAGS          Flags)
  {
      AcpiOsSignalSemaphore (Handle, 1);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsInstallInterruptHandler
   *
   * PARAMETERS:  InterruptNumber     - Level handler should respond to.
   *              Isr                 - Address of the ACPI interrupt handler
   *              ExceptPtr           - Where status is returned
   *
   * RETURN:      Handle to the newly installed handler.
   *
   * DESCRIPTION: Install an interrupt handler. Used to install the ACPI
   *              OS-independent handler.
   *
   *****************************************************************************/
  
  UINT32
  AcpiOsInstallInterruptHandler (
      UINT32                  InterruptNumber,
      ACPI_OSD_HANDLER        ServiceRoutine,
      void                    *Context)
  {
  
      return (AE_OK);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsRemoveInterruptHandler
   *
   * PARAMETERS:  Handle              - Returned when handler was installed
   *
   * RETURN:      Status
   *
   * DESCRIPTION: Uninstalls an interrupt handler.
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsRemoveInterruptHandler (
      UINT32                  InterruptNumber,
      ACPI_OSD_HANDLER        ServiceRoutine)
  {
  
      return (AE_OK);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsStall
   *
   * PARAMETERS:  microseconds        - Time to sleep
   *
   * RETURN:      Blocks until sleep is completed.
   *
   * DESCRIPTION: Sleep at microsecond granularity
   *
   *****************************************************************************/
  
  void
  AcpiOsStall (
      UINT32                  microseconds)
  {
  
      if (microseconds)
      {
          usleep (microseconds);
      }
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsSleep
   *
   * PARAMETERS:  milliseconds        - Time to sleep
   *
   * RETURN:      Blocks until sleep is completed.
   *
   * DESCRIPTION: Sleep at millisecond granularity
   *
   *****************************************************************************/
  
  void
  AcpiOsSleep (
      UINT64                  milliseconds)
  {
  
      /* Sleep for whole seconds */
  
      sleep (milliseconds / ACPI_MSEC_PER_SEC);
  
      /*
       * Sleep for remaining microseconds.
       * Arg to usleep() is in usecs and must be less than 1,000,000 (1 second).
       */
      usleep ((milliseconds % ACPI_MSEC_PER_SEC) * ACPI_USEC_PER_MSEC);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsGetTimer
   *
   * PARAMETERS:  None
   *
   * RETURN:      Current time in 100 nanosecond units
   *
   * DESCRIPTION: Get the current system time
   *
   *****************************************************************************/
  
  UINT64
  AcpiOsGetTimer (
      void)
  {
      struct timeval          time;
  
  
      /* This timer has sufficient resolution for user-space application code */
  
      gettimeofday (&time, NULL);
  
      /* (Seconds * 10^7 = 100ns(10^-7)) + (Microseconds(10^-6) * 10^1 = 100ns) */
  
      return (((UINT64) time.tv_sec * ACPI_100NSEC_PER_SEC) +
              ((UINT64) time.tv_usec * ACPI_100NSEC_PER_USEC));
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsReadPciConfiguration
   *
   * PARAMETERS:  PciId               - Seg/Bus/Dev
   *              PciRegister         - Device Register
   *              Value               - Buffer where value is placed
   *              Width               - Number of bits
   *
   * RETURN:      Status
   *
   * DESCRIPTION: Read data from PCI configuration space
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsReadPciConfiguration (
      ACPI_PCI_ID             *PciId,
      UINT32                  PciRegister,
      UINT64                  *Value,
      UINT32                  Width)
  {
  
      *Value = 0;
      return (AE_OK);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsWritePciConfiguration
   *
   * PARAMETERS:  PciId               - Seg/Bus/Dev
   *              PciRegister         - Device Register
   *              Value               - Value to be written
   *              Width               - Number of bits
   *
   * RETURN:      Status.
   *
   * DESCRIPTION: Write data to PCI configuration space
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsWritePciConfiguration (
      ACPI_PCI_ID             *PciId,
      UINT32                  PciRegister,
      UINT64                  Value,
      UINT32                  Width)
  {
  
      return (AE_OK);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsReadPort
   *
   * PARAMETERS:  Address             - Address of I/O port/register to read
   *              Value               - Where value is placed
   *              Width               - Number of bits
   *
   * RETURN:      Value read from port
   *
   * DESCRIPTION: Read data from an I/O port or register
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsReadPort (
      ACPI_IO_ADDRESS         Address,
      UINT32                  *Value,
      UINT32                  Width)
  {
  
      switch (Width)
      {
      case 8:
  
          *Value = 0xFF;
          break;
  
      case 16:
  
          *Value = 0xFFFF;
          break;
  
      case 32:
  
          *Value = 0xFFFFFFFF;
          break;
  
      default:
  
          return (AE_BAD_PARAMETER);
      }
  
      return (AE_OK);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsWritePort
   *
   * PARAMETERS:  Address             - Address of I/O port/register to write
   *              Value               - Value to write
   *              Width               - Number of bits
   *
   * RETURN:      None
   *
   * DESCRIPTION: Write data to an I/O port or register
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsWritePort (
      ACPI_IO_ADDRESS         Address,
      UINT32                  Value,
      UINT32                  Width)
  {
  
      return (AE_OK);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsReadMemory
   *
   * PARAMETERS:  Address             - Physical Memory Address to read
   *              Value               - Where value is placed
   *              Width               - Number of bits (8,16,32, or 64)
   *
   * RETURN:      Value read from physical memory address. Always returned
   *              as a 64-bit integer, regardless of the read width.
   *
   * DESCRIPTION: Read data from a physical memory address
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsReadMemory (
      ACPI_PHYSICAL_ADDRESS   Address,
      UINT64                  *Value,
      UINT32                  Width)
  {
  
      switch (Width)
      {
      case 8:
      case 16:
      case 32:
      case 64:
  
          *Value = 0;
          break;
  
      default:
  
          return (AE_BAD_PARAMETER);
      }
      return (AE_OK);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsWriteMemory
   *
   * PARAMETERS:  Address             - Physical Memory Address to write
   *              Value               - Value to write
   *              Width               - Number of bits (8,16,32, or 64)
   *
   * RETURN:      None
   *
   * DESCRIPTION: Write data to a physical memory address
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsWriteMemory (
      ACPI_PHYSICAL_ADDRESS   Address,
      UINT64                  Value,
      UINT32                  Width)
  {
  
      return (AE_OK);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsReadable
   *
   * PARAMETERS:  Pointer             - Area to be verified
   *              Length              - Size of area
   *
   * RETURN:      TRUE if readable for entire length
   *
   * DESCRIPTION: Verify that a pointer is valid for reading
   *
   *****************************************************************************/
  
  BOOLEAN
  AcpiOsReadable (
      void                    *Pointer,
      ACPI_SIZE               Length)
  {
  
      return (TRUE);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsWritable
   *
   * PARAMETERS:  Pointer             - Area to be verified
   *              Length              - Size of area
   *
   * RETURN:      TRUE if writable for entire length
   *
   * DESCRIPTION: Verify that a pointer is valid for writing
   *
   *****************************************************************************/
  
  BOOLEAN
  AcpiOsWritable (
      void                    *Pointer,
      ACPI_SIZE               Length)
  {
  
      return (TRUE);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsSignal
   *
   * PARAMETERS:  Function            - ACPI A signal function code
   *              Info                - Pointer to function-dependent structure
   *
   * RETURN:      Status
   *
   * DESCRIPTION: Miscellaneous functions. Example implementation only.
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsSignal (
      UINT32                  Function,
      void                    *Info)
  {
  
      switch (Function)
      {
      case ACPI_SIGNAL_FATAL:
  
          break;
  
      case ACPI_SIGNAL_BREAKPOINT:
  
          break;
  
      default:
  
          break;
      }
  
      return (AE_OK);
  }
  
  /* Optional multi-thread support */
  
  #ifndef ACPI_SINGLE_THREADED
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsGetThreadId
   *
   * PARAMETERS:  None
   *
   * RETURN:      Id of the running thread
   *
   * DESCRIPTION: Get the ID of the current (running) thread
   *
   *****************************************************************************/
  
  ACPI_THREAD_ID
  AcpiOsGetThreadId (
      void)
  {
      pthread_t               thread;
  
  
      thread = pthread_self();
      return (ACPI_CAST_PTHREAD_T (thread));
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsExecute
   *
   * PARAMETERS:  Type                - Type of execution
   *              Function            - Address of the function to execute
   *              Context             - Passed as a parameter to the function
   *
   * RETURN:      Status.
   *
   * DESCRIPTION: Execute a new thread
   *
   *****************************************************************************/
  
  ACPI_STATUS
  AcpiOsExecute (
      ACPI_EXECUTE_TYPE       Type,
      ACPI_OSD_EXEC_CALLBACK  Function,
      void                    *Context)
  {
      pthread_t               thread;
      int                     ret;
  
  
      ret = pthread_create (&thread, NULL, (PTHREAD_CALLBACK) Function, Context);
      if (ret)
      {
          AcpiOsPrintf("Create thread failed");
      }
      return (0);
  }
  
  #else /* ACPI_SINGLE_THREADED */
  ACPI_THREAD_ID
  AcpiOsGetThreadId (
      void)
  {
      return (1);
  }
  
  ACPI_STATUS
  AcpiOsExecute (
      ACPI_EXECUTE_TYPE       Type,
      ACPI_OSD_EXEC_CALLBACK  Function,
      void                    *Context)
  {
  
      Function (Context);
  
      return (AE_OK);
  }
  
  #endif /* ACPI_SINGLE_THREADED */
  
  
  /******************************************************************************
   *
   * FUNCTION:    AcpiOsWaitEventsComplete
   *
   * PARAMETERS:  None
   *
   * RETURN:      None
   *
   * DESCRIPTION: Wait for all asynchronous events to complete. This
   *              implementation does nothing.
   *
   *****************************************************************************/
  
  void
  AcpiOsWaitEventsComplete (
      void)
  {
      return;
  }
  