FreeBSD/Linux Kernel Cross Reference
sys/contrib/dev/acpica/os_specific/service_layers/osunixxf.c

     /******************************************************************************
      *
      * Module Name: osunixxf - UNIX OSL interfaces
      *
      *****************************************************************************/
     
     /******************************************************************************
      *
      * 1. Copyright Notice
     *
     * Some or all of this work - Copyright (c) 1999 - 2022, 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 <contrib/dev/acpica/include/acpi.h>
   #include <contrib/dev/acpica/include/accommon.h>
   #include <contrib/dev/acpica/include/amlcode.h>
   #include <contrib/dev/acpica/include/acparser.h>
   #include <contrib/dev/acpica/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;
  }

Cache object: d449469120c6c2600256d2025b06c151