/****************************************************************************** * * Module Name: osunixxf - UNIX OSL interfaces * *****************************************************************************/ /* * Copyright (C) 2000 - 2011, Intel Corp. * All rights reserved. * * 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. * * Alternatively, this software may be distributed under the terms of the * GNU General Public License ("GPL") version 2 as published by the Free * Software Foundation. * * NO WARRANTY * 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 MERCHANTIBILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * HOLDERS OR CONTRIBUTORS BE LIABLE FOR 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 DAMAGES. */ /* * These interfaces are required in order to compile the ASL compiler and the * various ACPICA tools under Linux or other Unix-like system. * * Note: Use #define __APPLE__ for OS X generation. */ #include #include #include #include #include #include #include #include #include "acpi.h" #include "accommon.h" #include "amlcode.h" #include "acparser.h" #include "acdebug.h" #define _COMPONENT ACPI_OS_SERVICES ACPI_MODULE_NAME ("osunixxf") extern FILE *AcpiGbl_DebugFile; FILE *AcpiGbl_OutputFile; /* Upcalls to AcpiExec */ ACPI_PHYSICAL_ADDRESS AeLocalGetRootPointer ( void); void AeTableOverride ( ACPI_TABLE_HEADER *ExistingTable, ACPI_TABLE_HEADER **NewTable); typedef void* (*PTHREAD_CALLBACK) (void *); /* Apple-specific */ #ifdef __APPLE__ #define sem_destroy sem_close #endif /****************************************************************************** * * FUNCTION: AcpiOsInitialize, AcpiOsTerminate * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Init and terminate. Nothing to do. * *****************************************************************************/ ACPI_STATUS AcpiOsInitialize ( void) { AcpiGbl_OutputFile = stdout; return (AE_OK); } ACPI_STATUS AcpiOsTerminate ( void) { return (AE_OK); } /****************************************************************************** * * FUNCTION: AcpiOsGetRootPointer * * PARAMETERS: None * * RETURN: RSDP physical address * * DESCRIPTION: Gets the ACPI root pointer (RSDP) * *****************************************************************************/ ACPI_PHYSICAL_ADDRESS AcpiOsGetRootPointer ( void) { return (AeLocalGetRootPointer ()); } /****************************************************************************** * * 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: 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 * *****************************************************************************/ void ACPI_INTERNAL_VAR_XFACE AcpiOsPrintf ( const char *Fmt, ...) { va_list Args; va_start (Args, Fmt); AcpiOsVprintf (Fmt, Args); va_end (Args); } /****************************************************************************** * * FUNCTION: AcpiOsVprintf * * PARAMETERS: fmt - Standard printf format * args - Argument list * * RETURN: None * * DESCRIPTION: Formatted output with argument list pointer * *****************************************************************************/ void AcpiOsVprintf ( const char *Fmt, va_list Args) { INT32 Count = 0; 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 */ Count = vfprintf (AcpiGbl_DebugFile, Fmt, Args); } else { /* No redirection, send output to console (once only!) */ Flags |= ACPI_DB_CONSOLE_OUTPUT; } } if (Flags & ACPI_DB_CONSOLE_OUTPUT) { Count = vfprintf (AcpiGbl_OutputFile, Fmt, Args); } } /****************************************************************************** * * FUNCTION: AcpiOsGetLine * * PARAMETERS: fmt - Standard printf format * args - Argument list * * RETURN: Actual bytes read * * DESCRIPTION: Formatted input with argument list pointer * *****************************************************************************/ UINT32 AcpiOsGetLine ( char *Buffer) { UINT8 Temp; UINT32 i; for (i = 0; ; i++) { scanf ("%1c", &Temp); if (!Temp || Temp == '\n') { break; } Buffer [i] = Temp; } /* Null terminate the buffer */ Buffer [i] = 0; /* Return the number of bytes in the string */ return (i); } /****************************************************************************** * * 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; } /****************************************************************************** * * 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); } /****************************************************************************** * * 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__ { char *SemaphoreName = tmpnam (NULL); 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); } if (sem_destroy (Sem) == -1) { return (AE_BAD_PARAMETER); } return (AE_OK); } /****************************************************************************** * * FUNCTION: AcpiOsWaitSemaphore * * PARAMETERS: Handle - Handle returned by AcpiOsCreateSemaphore * Units - How many units to wait for * Timeout - How long to wait * * RETURN: Status * * DESCRIPTION: Wait for units * *****************************************************************************/ ACPI_STATUS AcpiOsWaitSemaphore ( ACPI_HANDLE Handle, UINT32 Units, UINT16 Timeout) { ACPI_STATUS Status = AE_OK; sem_t *Sem = (sem_t *) Handle; struct timespec T; if (!Sem) { return (AE_BAD_PARAMETER); } switch (Timeout) { /* * 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: if (sem_wait (Sem)) { Status = (AE_TIME); } break; /* Wait with Timeout */ default: T.tv_sec = Timeout / 1000; T.tv_nsec = (Timeout - (T.tv_sec * 1000)) * 1000000; #ifdef ACPI_USE_ALTERNATE_TIMEOUT /* * Alternate timeout mechanism for environments where * sem_timedwait is not available or does not work properly. */ while (Timeout) { if (sem_trywait (Sem) == 0) { /* Got the semaphore */ return (AE_OK); } usleep (1000); /* one millisecond */ Timeout--; } Status = (AE_TIME); #else if (sem_timedwait (Sem, &T)) { 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: 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); } /****************************************************************************** * * 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 (milliseconds / 1000); /* Sleep for whole seconds */ /* * Arg to usleep() must be less than 1,000,000 (1 second) */ usleep ((milliseconds % 1000) * 1000); /* Sleep for remaining usecs */ } /****************************************************************************** * * FUNCTION: AcpiOsGetTimer * * PARAMETERS: None * * RETURN: Current time in 100 nanosecond units * * DESCRIPTION: Get the current system time * *****************************************************************************/ UINT64 AcpiOsGetTimer ( void) { struct timeval time; gettimeofday (&time, NULL); /* Seconds * 10^7 = 100ns(10^-7), Microseconds(10^-6) * 10^1 = 100ns */ return (((UINT64) time.tv_sec * 10000000) + ((UINT64) time.tv_usec * 10)); } /****************************************************************************** * * FUNCTION: AcpiOsReadPciConfiguration * * PARAMETERS: PciId - Seg/Bus/Dev * Register - 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 Register, UINT64 *Value, UINT32 Width) { return (AE_OK); } /****************************************************************************** * * FUNCTION: AcpiOsWritePciConfiguration * * PARAMETERS: PciId - Seg/Bus/Dev * Register - 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 Register, 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 * * RETURN: Value read from physical memory address * * DESCRIPTION: Read data from a physical memory address * *****************************************************************************/ ACPI_STATUS AcpiOsReadMemory ( ACPI_PHYSICAL_ADDRESS Address, UINT32 *Value, UINT32 Width) { switch (Width) { case 8: case 16: case 32: *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 * * RETURN: None * * DESCRIPTION: Write data to a physical memory address * *****************************************************************************/ ACPI_STATUS AcpiOsWriteMemory ( ACPI_PHYSICAL_ADDRESS Address, UINT32 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: AcpiOsGetThreadId * * PARAMETERS: None * * RETURN: Id of the running thread * * DESCRIPTION: Get the ID of the current (running) thread * *****************************************************************************/ ACPI_THREAD_ID AcpiOsGetThreadId ( void) { return (ACPI_CAST_PTHREAD_T (pthread_self())); } /****************************************************************************** * * FUNCTION: AcpiOsSignal * * PARAMETERS: Function - ACPI CA 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); }