diff options
Diffstat (limited to 'source/os_specific/service_layers/oswinxf.c')
| -rw-r--r-- | source/os_specific/service_layers/oswinxf.c | 1481 |
1 files changed, 1481 insertions, 0 deletions
diff --git a/source/os_specific/service_layers/oswinxf.c b/source/os_specific/service_layers/oswinxf.c new file mode 100644 index 0000000..008dcb3 --- /dev/null +++ b/source/os_specific/service_layers/oswinxf.c @@ -0,0 +1,1481 @@ +/****************************************************************************** + * + * Module Name: oswinxf - Windows OSL + * + *****************************************************************************/ + +/* + * Copyright (C) 2000 - 2012, 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. + */ + +#include "acpi.h" +#include "accommon.h" + +#ifdef WIN32 +#pragma warning(disable:4115) /* warning C4115: named type definition in parentheses (caused by rpcasync.h> */ + +#include <windows.h> +#include <winbase.h> + +#elif WIN64 +#include <windowsx.h> +#endif + +#include <stdio.h> +#include <stdlib.h> +#include <stdarg.h> +#include <process.h> +#include <time.h> + +#define _COMPONENT ACPI_OS_SERVICES + ACPI_MODULE_NAME ("oswinxf") + + +extern FILE *AcpiGbl_DebugFile; +extern BOOLEAN AcpiGbl_DebugTimeout; + +FILE *AcpiGbl_OutputFile; +UINT64 TimerFrequency; +char TableName[ACPI_NAME_SIZE + 1]; + +#define ACPI_OS_DEBUG_TIMEOUT 30000 /* 30 seconds */ + + +/* Upcalls to application */ + +ACPI_PHYSICAL_ADDRESS +AeLocalGetRootPointer ( + void); + +void +AeTableOverride ( + ACPI_TABLE_HEADER *ExistingTable, + ACPI_TABLE_HEADER **NewTable); + +ACPI_TABLE_HEADER * +OsGetTable ( + char *Signature); + + +/* + * Real semaphores are only used for a multi-threaded application + */ +#ifndef ACPI_SINGLE_THREADED + +/* Semaphore information structure */ + +typedef struct acpi_os_semaphore_info +{ + UINT16 MaxUnits; + UINT16 CurrentUnits; + void *OsHandle; + +} ACPI_OS_SEMAPHORE_INFO; + +/* Need enough semaphores to run the large aslts suite */ + +#define ACPI_OS_MAX_SEMAPHORES 256 + +ACPI_OS_SEMAPHORE_INFO AcpiGbl_Semaphores[ACPI_OS_MAX_SEMAPHORES]; + +#endif /* ACPI_SINGLE_THREADED */ + + +/****************************************************************************** + * + * FUNCTION: AcpiOsTerminate + * + * PARAMETERS: None + * + * RETURN: Status + * + * DESCRIPTION: Nothing to do for windows + * + *****************************************************************************/ + +ACPI_STATUS +AcpiOsTerminate ( + void) +{ + return (AE_OK); +} + + +/****************************************************************************** + * + * FUNCTION: AcpiOsInitialize + * + * PARAMETERS: None + * + * RETURN: Status + * + * DESCRIPTION: Init this OSL + * + *****************************************************************************/ + +ACPI_STATUS +AcpiOsInitialize ( + void) +{ + LARGE_INTEGER LocalTimerFrequency; + + +#ifndef ACPI_SINGLE_THREADED + /* Clear the semaphore info array */ + + memset (AcpiGbl_Semaphores, 0x00, sizeof (AcpiGbl_Semaphores)); +#endif + + AcpiGbl_OutputFile = stdout; + + /* Get the timer frequency for use in AcpiOsGetTimer */ + + TimerFrequency = 0; + if (QueryPerformanceFrequency (&LocalTimerFrequency)) + { + /* Frequency is in ticks per second */ + + TimerFrequency = LocalTimerFrequency.QuadPart; + } + + return (AE_OK); +} + + +/****************************************************************************** + * + * FUNCTION: AcpiOsGetRootPointer + * + * PARAMETERS: None + * + * RETURN: RSDP physical address + * + * DESCRIPTION: Gets the 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 + + /* Call back up to AcpiExec */ + + AeTableOverride (ExistingTable, NewTable); +#endif + + +#ifdef ACPI_ASL_COMPILER + + /* Attempt to get the table from the registry */ + + /* Construct a null-terminated string from table signature */ + + TableName[ACPI_NAME_SIZE] = 0; + ACPI_STRNCPY (TableName, ExistingTable->Signature, ACPI_NAME_SIZE); + + *NewTable = OsGetTable (TableName); + if (*NewTable) + { + AcpiOsPrintf ("Table [%s] obtained from registry, %u bytes\n", + TableName, (*NewTable)->Length); + } + else + { + AcpiOsPrintf ("Could not read table %s from registry\n", TableName); + } +#endif + + return (AE_OK); +} + + +/****************************************************************************** + * + * 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: AcpiOsGetTimer + * + * PARAMETERS: None + * + * RETURN: Current ticks in 100-nanosecond units + * + * DESCRIPTION: Get the value of a system timer + * + ******************************************************************************/ + +UINT64 +AcpiOsGetTimer ( + void) +{ + LARGE_INTEGER Timer; + + + /* Attempt to use hi-granularity timer first */ + + if (TimerFrequency && + QueryPerformanceCounter (&Timer)) + { + /* Convert to 100 nanosecond ticks */ + + return ((UINT64) ((Timer.QuadPart * (UINT64) 10000000) / TimerFrequency)); + } + + /* Fall back to the lo-granularity timer */ + + else + { + /* Convert milliseconds to 100 nanosecond ticks */ + + return ((UINT64) GetTickCount() * 10000); + } +} + + +/****************************************************************************** + * + * 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 ((BOOLEAN) !IsBadReadPtr (Pointer, Length)); +} + + +/****************************************************************************** + * + * 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 ((BOOLEAN) !IsBadWritePtr (Pointer, Length)); +} + + +/****************************************************************************** + * + * 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); + return; +} + + +/****************************************************************************** + * + * 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); + } + + return; +} + + +/****************************************************************************** + * + * 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: Formatted input with argument list pointer + * + *****************************************************************************/ + +ACPI_STATUS +AcpiOsGetLine ( + char *Buffer, + UINT32 BufferLength, + UINT32 *BytesRead) +{ + char Temp; + UINT32 i; + + + for (i = 0; ; i++) + { + if (i >= BufferLength) + { + return (AE_BUFFER_OVERFLOW); + } + + 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 */ + + if (BytesRead) + { + *BytesRead = i; + } + return (AE_OK); +} + + +/****************************************************************************** + * + * 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: MaxUnits - Maximum units that can be sent + * 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_SEMAPHORE *OutHandle) +{ + void *Mutex; + UINT32 i; + + ACPI_FUNCTION_NAME (OsCreateSemaphore); + + + if (MaxUnits == ACPI_UINT32_MAX) + { + MaxUnits = 255; + } + + if (InitialUnits == ACPI_UINT32_MAX) + { + InitialUnits = MaxUnits; + } + + if (InitialUnits > MaxUnits) + { + return (AE_BAD_PARAMETER); + } + + /* Find an empty slot */ + + for (i = 0; i < ACPI_OS_MAX_SEMAPHORES; i++) + { + if (!AcpiGbl_Semaphores[i].OsHandle) + { + break; + } + } + if (i >= ACPI_OS_MAX_SEMAPHORES) + { + ACPI_EXCEPTION ((AE_INFO, AE_LIMIT, + "Reached max semaphores (%u), could not create", ACPI_OS_MAX_SEMAPHORES)); + return (AE_LIMIT); + } + + /* Create an OS semaphore */ + + Mutex = CreateSemaphore (NULL, InitialUnits, MaxUnits, NULL); + if (!Mutex) + { + ACPI_ERROR ((AE_INFO, "Could not create semaphore")); + return (AE_NO_MEMORY); + } + + AcpiGbl_Semaphores[i].MaxUnits = (UINT16) MaxUnits; + AcpiGbl_Semaphores[i].CurrentUnits = (UINT16) InitialUnits; + AcpiGbl_Semaphores[i].OsHandle = Mutex; + + ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Handle=%u, Max=%u, Current=%u, OsHandle=%p\n", + i, MaxUnits, InitialUnits, Mutex)); + + *OutHandle = (void *) i; + return (AE_OK); +} + + +/****************************************************************************** + * + * FUNCTION: AcpiOsDeleteSemaphore + * + * PARAMETERS: Handle - Handle returned by AcpiOsCreateSemaphore + * + * RETURN: Status + * + * DESCRIPTION: Delete an OS semaphore + * + *****************************************************************************/ + +ACPI_STATUS +AcpiOsDeleteSemaphore ( + ACPI_SEMAPHORE Handle) +{ + UINT32 Index = (UINT32) Handle; + + + if ((Index >= ACPI_OS_MAX_SEMAPHORES) || + !AcpiGbl_Semaphores[Index].OsHandle) + { + return (AE_BAD_PARAMETER); + } + + CloseHandle (AcpiGbl_Semaphores[Index].OsHandle); + AcpiGbl_Semaphores[Index].OsHandle = NULL; + 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_SEMAPHORE Handle, + UINT32 Units, + UINT16 Timeout) +{ + UINT32 Index = (UINT32) Handle; + UINT32 WaitStatus; + UINT32 OsTimeout = Timeout; + + + ACPI_FUNCTION_ENTRY (); + + + if ((Index >= ACPI_OS_MAX_SEMAPHORES) || + !AcpiGbl_Semaphores[Index].OsHandle) + { + return (AE_BAD_PARAMETER); + } + + if (Units > 1) + { + printf ("WaitSemaphore: Attempt to receive %u units\n", Units); + return (AE_NOT_IMPLEMENTED); + } + + if (Timeout == ACPI_WAIT_FOREVER) + { + OsTimeout = INFINITE; + if (AcpiGbl_DebugTimeout) + { + /* The debug timeout will prevent hang conditions */ + + OsTimeout = ACPI_OS_DEBUG_TIMEOUT; + } + } + else + { + /* Add 10ms to account for clock tick granularity */ + + OsTimeout += 10; + } + + WaitStatus = WaitForSingleObject (AcpiGbl_Semaphores[Index].OsHandle, OsTimeout); + if (WaitStatus == WAIT_TIMEOUT) + { + if (AcpiGbl_DebugTimeout) + { + ACPI_EXCEPTION ((AE_INFO, AE_TIME, + "Debug timeout on semaphore 0x%04X (%ums)\n", + Index, ACPI_OS_DEBUG_TIMEOUT)); + } + return (AE_TIME); + } + + if (AcpiGbl_Semaphores[Index].CurrentUnits == 0) + { + ACPI_ERROR ((AE_INFO, "%s - No unit received. Timeout 0x%X, OS_Status 0x%X", + AcpiUtGetMutexName (Index), Timeout, WaitStatus)); + + return (AE_OK); + } + + AcpiGbl_Semaphores[Index].CurrentUnits--; + return (AE_OK); +} + + +/****************************************************************************** + * + * FUNCTION: AcpiOsSignalSemaphore + * + * PARAMETERS: Handle - Handle returned by AcpiOsCreateSemaphore + * Units - Number of units to send + * + * RETURN: Status + * + * DESCRIPTION: Send units + * + *****************************************************************************/ + +ACPI_STATUS +AcpiOsSignalSemaphore ( + ACPI_SEMAPHORE Handle, + UINT32 Units) +{ + UINT32 Index = (UINT32) Handle; + + + ACPI_FUNCTION_ENTRY (); + + + if (Index >= ACPI_OS_MAX_SEMAPHORES) + { + printf ("SignalSemaphore: Index/Handle out of range: %2.2X\n", Index); + return (AE_BAD_PARAMETER); + } + + if (!AcpiGbl_Semaphores[Index].OsHandle) + { + printf ("SignalSemaphore: Null OS handle, Index %2.2X\n", Index); + return (AE_BAD_PARAMETER); + } + + if (Units > 1) + { + printf ("SignalSemaphore: Attempt to signal %u units, Index %2.2X\n", Units, Index); + return (AE_NOT_IMPLEMENTED); + } + + if ((AcpiGbl_Semaphores[Index].CurrentUnits + 1) > + AcpiGbl_Semaphores[Index].MaxUnits) + { + ACPI_ERROR ((AE_INFO, + "Oversignalled semaphore[%u]! Current %u Max %u", + Index, AcpiGbl_Semaphores[Index].CurrentUnits, + AcpiGbl_Semaphores[Index].MaxUnits)); + + return (AE_LIMIT); + } + + AcpiGbl_Semaphores[Index].CurrentUnits++; + ReleaseSemaphore (AcpiGbl_Semaphores[Index].OsHandle, Units, NULL); + + 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_SPINLOCK Handle) +{ + AcpiOsWaitSemaphore (Handle, 1, 0xFFFF); + return (0); +} + +void +AcpiOsReleaseLock ( + ACPI_SPINLOCK Handle, + ACPI_CPU_FLAGS Flags) +{ + AcpiOsSignalSemaphore (Handle, 1); +} + + +#if ACPI_FUTURE_IMPLEMENTATION + +/* Mutex interfaces, just implement with a semaphore */ + +ACPI_STATUS +AcpiOsCreateMutex ( + ACPI_MUTEX *OutHandle) +{ + return (AcpiOsCreateSemaphore (1, 1, OutHandle)); +} + +void +AcpiOsDeleteMutex ( + ACPI_MUTEX Handle) +{ + AcpiOsDeleteSemaphore (Handle); +} + +ACPI_STATUS +AcpiOsAcquireMutex ( + ACPI_MUTEX Handle, + UINT16 Timeout) +{ + AcpiOsWaitSemaphore (Handle, 1, Timeout); + return (0); +} + +void +AcpiOsReleaseMutex ( + ACPI_MUTEX Handle) +{ + AcpiOsSignalSemaphore (Handle, 1); +} +#endif + + +/****************************************************************************** + * + * FUNCTION: AcpiOsInstallInterruptHandler + * + * PARAMETERS: InterruptNumber - Level handler should respond to. + * ServiceRoutine - Address of the ACPI interrupt handler + * Context - User context + * + * 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 stall + * + * RETURN: None. Blocks until stall is completed. + * + * DESCRIPTION: Sleep at microsecond granularity + * + *****************************************************************************/ + +void +AcpiOsStall ( + UINT32 Microseconds) +{ + + Sleep ((Microseconds / 1000) + 1); + return; +} + + +/****************************************************************************** + * + * FUNCTION: AcpiOsSleep + * + * PARAMETERS: Milliseconds - Time to sleep + * + * RETURN: None. Blocks until sleep is completed. + * + * DESCRIPTION: Sleep at millisecond granularity + * + *****************************************************************************/ + +void +AcpiOsSleep ( + UINT64 Milliseconds) +{ + + /* Add 10ms to account for clock tick granularity */ + + Sleep (((unsigned long) Milliseconds) + 10); + return; +} + + +/****************************************************************************** + * + * 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) +{ + ACPI_FUNCTION_NAME (OsReadPort); + + + switch (Width) + { + case 8: + *Value = 0xFF; + break; + + case 16: + *Value = 0xFFFF; + break; + + case 32: + *Value = 0xFFFFFFFF; + break; + + default: + ACPI_ERROR ((AE_INFO, "Bad width parameter: %X", Width)); + 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) +{ + ACPI_FUNCTION_NAME (OsWritePort); + + + if ((Width == 8) || (Width == 16) || (Width == 32)) + { + return (AE_OK); + } + + ACPI_ERROR ((AE_INFO, "Bad width parameter: %X", Width)); + return (AE_BAD_PARAMETER); +} + + +/****************************************************************************** + * + * 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); + break; + } + + 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: 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); +} + + +/****************************************************************************** + * + * FUNCTION: Local cache interfaces + * + * DESCRIPTION: Implements cache interfaces via malloc/free for testing + * purposes only. + * + *****************************************************************************/ + +#ifndef ACPI_USE_LOCAL_CACHE + +ACPI_STATUS +AcpiOsCreateCache ( + char *CacheName, + UINT16 ObjectSize, + UINT16 MaxDepth, + ACPI_CACHE_T **ReturnCache) +{ + ACPI_MEMORY_LIST *NewCache; + + + NewCache = malloc (sizeof (ACPI_MEMORY_LIST)); + if (!NewCache) + { + return (AE_NO_MEMORY); + } + + memset (NewCache, 0, sizeof (ACPI_MEMORY_LIST)); + NewCache->LinkOffset = 8; + NewCache->ListName = CacheName; + NewCache->ObjectSize = ObjectSize; + NewCache->MaxDepth = MaxDepth; + + *ReturnCache = (ACPI_CACHE_T) NewCache; + return (AE_OK); +} + +ACPI_STATUS +AcpiOsDeleteCache ( + ACPI_CACHE_T *Cache) +{ + free (Cache); + return (AE_OK); +} + +ACPI_STATUS +AcpiOsPurgeCache ( + ACPI_CACHE_T *Cache) +{ + return (AE_OK); +} + +void * +AcpiOsAcquireObject ( + ACPI_CACHE_T *Cache) +{ + void *NewObject; + + NewObject = malloc (((ACPI_MEMORY_LIST *) Cache)->ObjectSize); + memset (NewObject, 0, ((ACPI_MEMORY_LIST *) Cache)->ObjectSize); + + return (NewObject); +} + +ACPI_STATUS +AcpiOsReleaseObject ( + ACPI_CACHE_T *Cache, + void *Object) +{ + free (Object); + return (AE_OK); +} + +#endif /* ACPI_USE_LOCAL_CACHE */ + + +/* 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) +{ + DWORD ThreadId; + + /* Ensure ID is never 0 */ + + ThreadId = GetCurrentThreadId (); + return ((ACPI_THREAD_ID) (ThreadId + 1)); +} + + +/****************************************************************************** + * + * 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) +{ + + _beginthread (Function, (unsigned) 0, Context); + return (0); +} + +#endif /* ACPI_SINGLE_THREADED */ + |
