10d02842fSSascha Wildner /******************************************************************************
20d02842fSSascha Wildner *
30d02842fSSascha Wildner * Module Name: oswinxf - Windows OSL
40d02842fSSascha Wildner *
50d02842fSSascha Wildner *****************************************************************************/
60d02842fSSascha Wildner
7b4315fc7SSascha Wildner /******************************************************************************
8b4315fc7SSascha Wildner *
9b4315fc7SSascha Wildner * 1. Copyright Notice
10b4315fc7SSascha Wildner *
11*383048acSSascha Wildner * Some or all of this work - Copyright (c) 1999 - 2021, Intel Corp.
120d02842fSSascha Wildner * All rights reserved.
130d02842fSSascha Wildner *
14b4315fc7SSascha Wildner * 2. License
15b4315fc7SSascha Wildner *
16b4315fc7SSascha Wildner * 2.1. This is your license from Intel Corp. under its intellectual property
17b4315fc7SSascha Wildner * rights. You may have additional license terms from the party that provided
18b4315fc7SSascha Wildner * you this software, covering your right to use that party's intellectual
19b4315fc7SSascha Wildner * property rights.
20b4315fc7SSascha Wildner *
21b4315fc7SSascha Wildner * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22b4315fc7SSascha Wildner * copy of the source code appearing in this file ("Covered Code") an
23b4315fc7SSascha Wildner * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24b4315fc7SSascha Wildner * base code distributed originally by Intel ("Original Intel Code") to copy,
25b4315fc7SSascha Wildner * make derivatives, distribute, use and display any portion of the Covered
26b4315fc7SSascha Wildner * Code in any form, with the right to sublicense such rights; and
27b4315fc7SSascha Wildner *
28b4315fc7SSascha Wildner * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29b4315fc7SSascha Wildner * license (with the right to sublicense), under only those claims of Intel
30b4315fc7SSascha Wildner * patents that are infringed by the Original Intel Code, to make, use, sell,
31b4315fc7SSascha Wildner * offer to sell, and import the Covered Code and derivative works thereof
32b4315fc7SSascha Wildner * solely to the minimum extent necessary to exercise the above copyright
33b4315fc7SSascha Wildner * license, and in no event shall the patent license extend to any additions
34b4315fc7SSascha Wildner * to or modifications of the Original Intel Code. No other license or right
35b4315fc7SSascha Wildner * is granted directly or by implication, estoppel or otherwise;
36b4315fc7SSascha Wildner *
37b4315fc7SSascha Wildner * The above copyright and patent license is granted only if the following
38b4315fc7SSascha Wildner * conditions are met:
39b4315fc7SSascha Wildner *
40b4315fc7SSascha Wildner * 3. Conditions
41b4315fc7SSascha Wildner *
42b4315fc7SSascha Wildner * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43b4315fc7SSascha Wildner * Redistribution of source code of any substantial portion of the Covered
44b4315fc7SSascha Wildner * Code or modification with rights to further distribute source must include
45b4315fc7SSascha Wildner * the above Copyright Notice, the above License, this list of Conditions,
46b4315fc7SSascha Wildner * and the following Disclaimer and Export Compliance provision. In addition,
47b4315fc7SSascha Wildner * Licensee must cause all Covered Code to which Licensee contributes to
48b4315fc7SSascha Wildner * contain a file documenting the changes Licensee made to create that Covered
49b4315fc7SSascha Wildner * Code and the date of any change. Licensee must include in that file the
50b4315fc7SSascha Wildner * documentation of any changes made by any predecessor Licensee. Licensee
51b4315fc7SSascha Wildner * must include a prominent statement that the modification is derived,
52b4315fc7SSascha Wildner * directly or indirectly, from Original Intel Code.
53b4315fc7SSascha Wildner *
54b4315fc7SSascha Wildner * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55b4315fc7SSascha Wildner * Redistribution of source code of any substantial portion of the Covered
56b4315fc7SSascha Wildner * Code or modification without rights to further distribute source must
57b4315fc7SSascha Wildner * include the following Disclaimer and Export Compliance provision in the
58b4315fc7SSascha Wildner * documentation and/or other materials provided with distribution. In
59b4315fc7SSascha Wildner * addition, Licensee may not authorize further sublicense of source of any
60b4315fc7SSascha Wildner * portion of the Covered Code, and must include terms to the effect that the
61b4315fc7SSascha Wildner * license from Licensee to its licensee is limited to the intellectual
62b4315fc7SSascha Wildner * property embodied in the software Licensee provides to its licensee, and
63b4315fc7SSascha Wildner * not to intellectual property embodied in modifications its licensee may
64b4315fc7SSascha Wildner * make.
65b4315fc7SSascha Wildner *
66b4315fc7SSascha Wildner * 3.3. Redistribution of Executable. Redistribution in executable form of any
67b4315fc7SSascha Wildner * substantial portion of the Covered Code or modification must reproduce the
68b4315fc7SSascha Wildner * above Copyright Notice, and the following Disclaimer and Export Compliance
69b4315fc7SSascha Wildner * provision in the documentation and/or other materials provided with the
70b4315fc7SSascha Wildner * distribution.
71b4315fc7SSascha Wildner *
72b4315fc7SSascha Wildner * 3.4. Intel retains all right, title, and interest in and to the Original
73b4315fc7SSascha Wildner * Intel Code.
74b4315fc7SSascha Wildner *
75b4315fc7SSascha Wildner * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76b4315fc7SSascha Wildner * Intel shall be used in advertising or otherwise to promote the sale, use or
77b4315fc7SSascha Wildner * other dealings in products derived from or relating to the Covered Code
78b4315fc7SSascha Wildner * without prior written authorization from Intel.
79b4315fc7SSascha Wildner *
80b4315fc7SSascha Wildner * 4. Disclaimer and Export Compliance
81b4315fc7SSascha Wildner *
82b4315fc7SSascha Wildner * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83b4315fc7SSascha Wildner * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84b4315fc7SSascha Wildner * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85b4315fc7SSascha Wildner * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86b4315fc7SSascha Wildner * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87b4315fc7SSascha Wildner * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88b4315fc7SSascha Wildner * PARTICULAR PURPOSE.
89b4315fc7SSascha Wildner *
90b4315fc7SSascha Wildner * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91b4315fc7SSascha Wildner * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92b4315fc7SSascha Wildner * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93b4315fc7SSascha Wildner * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94b4315fc7SSascha Wildner * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95b4315fc7SSascha Wildner * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96b4315fc7SSascha Wildner * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97b4315fc7SSascha Wildner * LIMITED REMEDY.
98b4315fc7SSascha Wildner *
99b4315fc7SSascha Wildner * 4.3. Licensee shall not export, either directly or indirectly, any of this
100b4315fc7SSascha Wildner * software or system incorporating such software without first obtaining any
101b4315fc7SSascha Wildner * required license or other approval from the U. S. Department of Commerce or
102b4315fc7SSascha Wildner * any other agency or department of the United States Government. In the
103b4315fc7SSascha Wildner * event Licensee exports any such software from the United States or
104b4315fc7SSascha Wildner * re-exports any such software from a foreign destination, Licensee shall
105b4315fc7SSascha Wildner * ensure that the distribution and export/re-export of the software is in
106b4315fc7SSascha Wildner * compliance with all laws, regulations, orders, or other restrictions of the
107b4315fc7SSascha Wildner * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108b4315fc7SSascha Wildner * any of its subsidiaries will export/re-export any technical data, process,
109b4315fc7SSascha Wildner * software, or service, directly or indirectly, to any country for which the
110b4315fc7SSascha Wildner * United States government or any agency thereof requires an export license,
111b4315fc7SSascha Wildner * other governmental approval, or letter of assurance, without first obtaining
112b4315fc7SSascha Wildner * such license, approval or letter.
113b4315fc7SSascha Wildner *
114b4315fc7SSascha Wildner *****************************************************************************
115b4315fc7SSascha Wildner *
116b4315fc7SSascha Wildner * Alternatively, you may choose to be licensed under the terms of the
117b4315fc7SSascha Wildner * following license:
118b4315fc7SSascha Wildner *
1190d02842fSSascha Wildner * Redistribution and use in source and binary forms, with or without
1200d02842fSSascha Wildner * modification, are permitted provided that the following conditions
1210d02842fSSascha Wildner * are met:
1220d02842fSSascha Wildner * 1. Redistributions of source code must retain the above copyright
1230d02842fSSascha Wildner * notice, this list of conditions, and the following disclaimer,
1240d02842fSSascha Wildner * without modification.
1250d02842fSSascha Wildner * 2. Redistributions in binary form must reproduce at minimum a disclaimer
1260d02842fSSascha Wildner * substantially similar to the "NO WARRANTY" disclaimer below
1270d02842fSSascha Wildner * ("Disclaimer") and any redistribution must be conditioned upon
1280d02842fSSascha Wildner * including a substantially similar Disclaimer requirement for further
1290d02842fSSascha Wildner * binary redistribution.
1300d02842fSSascha Wildner * 3. Neither the names of the above-listed copyright holders nor the names
1310d02842fSSascha Wildner * of any contributors may be used to endorse or promote products derived
1320d02842fSSascha Wildner * from this software without specific prior written permission.
1330d02842fSSascha Wildner *
134b4315fc7SSascha Wildner * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135b4315fc7SSascha Wildner * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136b4315fc7SSascha Wildner * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137b4315fc7SSascha Wildner * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138b4315fc7SSascha Wildner * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139b4315fc7SSascha Wildner * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140b4315fc7SSascha Wildner * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141b4315fc7SSascha Wildner * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142b4315fc7SSascha Wildner * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143b4315fc7SSascha Wildner * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144b4315fc7SSascha Wildner * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145b4315fc7SSascha Wildner *
146b4315fc7SSascha Wildner * Alternatively, you may choose to be licensed under the terms of the
1470d02842fSSascha Wildner * GNU General Public License ("GPL") version 2 as published by the Free
1480d02842fSSascha Wildner * Software Foundation.
1490d02842fSSascha Wildner *
150b4315fc7SSascha Wildner *****************************************************************************/
1510d02842fSSascha Wildner
1520d02842fSSascha Wildner #include "acpi.h"
1530d02842fSSascha Wildner #include "accommon.h"
1540d02842fSSascha Wildner
1550d02842fSSascha Wildner #ifdef WIN32
1560d02842fSSascha Wildner #pragma warning(disable:4115) /* warning C4115: named type definition in parentheses (caused by rpcasync.h> */
1570d02842fSSascha Wildner
1580d02842fSSascha Wildner #include <windows.h>
1590d02842fSSascha Wildner #include <winbase.h>
1600d02842fSSascha Wildner
1610d02842fSSascha Wildner #elif WIN64
1620d02842fSSascha Wildner #include <windowsx.h>
1630d02842fSSascha Wildner #endif
1640d02842fSSascha Wildner
1650d02842fSSascha Wildner #include <stdio.h>
1660d02842fSSascha Wildner #include <stdlib.h>
1670d02842fSSascha Wildner #include <stdarg.h>
1680d02842fSSascha Wildner #include <process.h>
1690d02842fSSascha Wildner #include <time.h>
1700d02842fSSascha Wildner
1710d02842fSSascha Wildner #define _COMPONENT ACPI_OS_SERVICES
1720d02842fSSascha Wildner ACPI_MODULE_NAME ("oswinxf")
1730d02842fSSascha Wildner
1740d02842fSSascha Wildner
1750d02842fSSascha Wildner UINT64 TimerFrequency;
176c1776041SSascha Wildner char TableName[ACPI_NAMESEG_SIZE + 1];
1770d02842fSSascha Wildner
1780d02842fSSascha Wildner #define ACPI_OS_DEBUG_TIMEOUT 30000 /* 30 seconds */
1790d02842fSSascha Wildner
1800d02842fSSascha Wildner
1810d02842fSSascha Wildner /* Upcalls to AcpiExec application */
1820d02842fSSascha Wildner
1830d02842fSSascha Wildner void
1840d02842fSSascha Wildner AeTableOverride (
1850d02842fSSascha Wildner ACPI_TABLE_HEADER *ExistingTable,
1860d02842fSSascha Wildner ACPI_TABLE_HEADER **NewTable);
1870d02842fSSascha Wildner
1880d02842fSSascha Wildner /*
1890d02842fSSascha Wildner * Real semaphores are only used for a multi-threaded application
1900d02842fSSascha Wildner */
1910d02842fSSascha Wildner #ifndef ACPI_SINGLE_THREADED
1920d02842fSSascha Wildner
1930d02842fSSascha Wildner /* Semaphore information structure */
1940d02842fSSascha Wildner
1950d02842fSSascha Wildner typedef struct acpi_os_semaphore_info
1960d02842fSSascha Wildner {
1970d02842fSSascha Wildner UINT16 MaxUnits;
1980d02842fSSascha Wildner UINT16 CurrentUnits;
1990d02842fSSascha Wildner void *OsHandle;
2000d02842fSSascha Wildner
2010d02842fSSascha Wildner } ACPI_OS_SEMAPHORE_INFO;
2020d02842fSSascha Wildner
2030d02842fSSascha Wildner /* Need enough semaphores to run the large aslts suite */
2040d02842fSSascha Wildner
2050d02842fSSascha Wildner #define ACPI_OS_MAX_SEMAPHORES 256
2060d02842fSSascha Wildner
2070d02842fSSascha Wildner ACPI_OS_SEMAPHORE_INFO AcpiGbl_Semaphores[ACPI_OS_MAX_SEMAPHORES];
2080d02842fSSascha Wildner
2090d02842fSSascha Wildner #endif /* ACPI_SINGLE_THREADED */
2100d02842fSSascha Wildner
2110d02842fSSascha Wildner /******************************************************************************
2120d02842fSSascha Wildner *
2130d02842fSSascha Wildner * FUNCTION: AcpiOsTerminate
2140d02842fSSascha Wildner *
2150d02842fSSascha Wildner * PARAMETERS: None
2160d02842fSSascha Wildner *
2170d02842fSSascha Wildner * RETURN: Status
2180d02842fSSascha Wildner *
2190d02842fSSascha Wildner * DESCRIPTION: Nothing to do for windows
2200d02842fSSascha Wildner *
2210d02842fSSascha Wildner *****************************************************************************/
2220d02842fSSascha Wildner
2230d02842fSSascha Wildner ACPI_STATUS
AcpiOsTerminate(void)2240d02842fSSascha Wildner AcpiOsTerminate (
2250d02842fSSascha Wildner void)
2260d02842fSSascha Wildner {
2270d02842fSSascha Wildner return (AE_OK);
2280d02842fSSascha Wildner }
2290d02842fSSascha Wildner
2300d02842fSSascha Wildner
2310d02842fSSascha Wildner /******************************************************************************
2320d02842fSSascha Wildner *
2330d02842fSSascha Wildner * FUNCTION: AcpiOsInitialize
2340d02842fSSascha Wildner *
2350d02842fSSascha Wildner * PARAMETERS: None
2360d02842fSSascha Wildner *
2370d02842fSSascha Wildner * RETURN: Status
2380d02842fSSascha Wildner *
2390d02842fSSascha Wildner * DESCRIPTION: Init this OSL
2400d02842fSSascha Wildner *
2410d02842fSSascha Wildner *****************************************************************************/
2420d02842fSSascha Wildner
2430d02842fSSascha Wildner ACPI_STATUS
AcpiOsInitialize(void)2440d02842fSSascha Wildner AcpiOsInitialize (
2450d02842fSSascha Wildner void)
2460d02842fSSascha Wildner {
2475f39c7e7SSascha Wildner ACPI_STATUS Status;
2480d02842fSSascha Wildner LARGE_INTEGER LocalTimerFrequency;
2490d02842fSSascha Wildner
2500d02842fSSascha Wildner
2510d02842fSSascha Wildner #ifndef ACPI_SINGLE_THREADED
2520d02842fSSascha Wildner /* Clear the semaphore info array */
2530d02842fSSascha Wildner
2540d02842fSSascha Wildner memset (AcpiGbl_Semaphores, 0x00, sizeof (AcpiGbl_Semaphores));
2550d02842fSSascha Wildner #endif
2560d02842fSSascha Wildner
2570d02842fSSascha Wildner AcpiGbl_OutputFile = stdout;
2580d02842fSSascha Wildner
2590d02842fSSascha Wildner /* Get the timer frequency for use in AcpiOsGetTimer */
2600d02842fSSascha Wildner
2610d02842fSSascha Wildner TimerFrequency = 0;
2620d02842fSSascha Wildner if (QueryPerformanceFrequency (&LocalTimerFrequency))
2630d02842fSSascha Wildner {
2640d02842fSSascha Wildner /* Frequency is in ticks per second */
2650d02842fSSascha Wildner
2660d02842fSSascha Wildner TimerFrequency = LocalTimerFrequency.QuadPart;
2670d02842fSSascha Wildner }
2680d02842fSSascha Wildner
2695f39c7e7SSascha Wildner Status = AcpiOsCreateLock (&AcpiGbl_PrintLock);
2705f39c7e7SSascha Wildner if (ACPI_FAILURE (Status))
2715f39c7e7SSascha Wildner {
2725f39c7e7SSascha Wildner return (Status);
2735f39c7e7SSascha Wildner }
2745f39c7e7SSascha Wildner
2750d02842fSSascha Wildner return (AE_OK);
2760d02842fSSascha Wildner }
2770d02842fSSascha Wildner
2780d02842fSSascha Wildner
2795f39c7e7SSascha Wildner #ifndef ACPI_USE_NATIVE_RSDP_POINTER
2800d02842fSSascha Wildner /******************************************************************************
2810d02842fSSascha Wildner *
2820d02842fSSascha Wildner * FUNCTION: AcpiOsGetRootPointer
2830d02842fSSascha Wildner *
2840d02842fSSascha Wildner * PARAMETERS: None
2850d02842fSSascha Wildner *
2860d02842fSSascha Wildner * RETURN: RSDP physical address
2870d02842fSSascha Wildner *
2880d02842fSSascha Wildner * DESCRIPTION: Gets the root pointer (RSDP)
2890d02842fSSascha Wildner *
2900d02842fSSascha Wildner *****************************************************************************/
2910d02842fSSascha Wildner
2920d02842fSSascha Wildner ACPI_PHYSICAL_ADDRESS
AcpiOsGetRootPointer(void)2930d02842fSSascha Wildner AcpiOsGetRootPointer (
2940d02842fSSascha Wildner void)
2950d02842fSSascha Wildner {
2960d02842fSSascha Wildner
2975f39c7e7SSascha Wildner return (0);
2980d02842fSSascha Wildner }
2995f39c7e7SSascha Wildner #endif
3000d02842fSSascha Wildner
3010d02842fSSascha Wildner
3020d02842fSSascha Wildner /******************************************************************************
3030d02842fSSascha Wildner *
3040d02842fSSascha Wildner * FUNCTION: AcpiOsPredefinedOverride
3050d02842fSSascha Wildner *
3060d02842fSSascha Wildner * PARAMETERS: InitVal - Initial value of the predefined object
3070d02842fSSascha Wildner * NewVal - The new value for the object
3080d02842fSSascha Wildner *
3090d02842fSSascha Wildner * RETURN: Status, pointer to value. Null pointer returned if not
3100d02842fSSascha Wildner * overriding.
3110d02842fSSascha Wildner *
3120d02842fSSascha Wildner * DESCRIPTION: Allow the OS to override predefined names
3130d02842fSSascha Wildner *
3140d02842fSSascha Wildner *****************************************************************************/
3150d02842fSSascha Wildner
3160d02842fSSascha Wildner ACPI_STATUS
AcpiOsPredefinedOverride(const ACPI_PREDEFINED_NAMES * InitVal,ACPI_STRING * NewVal)3170d02842fSSascha Wildner AcpiOsPredefinedOverride (
3180d02842fSSascha Wildner const ACPI_PREDEFINED_NAMES *InitVal,
3190d02842fSSascha Wildner ACPI_STRING *NewVal)
3200d02842fSSascha Wildner {
3210d02842fSSascha Wildner
3220d02842fSSascha Wildner if (!InitVal || !NewVal)
3230d02842fSSascha Wildner {
3240d02842fSSascha Wildner return (AE_BAD_PARAMETER);
3250d02842fSSascha Wildner }
3260d02842fSSascha Wildner
3270d02842fSSascha Wildner *NewVal = NULL;
3280d02842fSSascha Wildner return (AE_OK);
3290d02842fSSascha Wildner }
3300d02842fSSascha Wildner
3310d02842fSSascha Wildner
3320d02842fSSascha Wildner /******************************************************************************
3330d02842fSSascha Wildner *
3340d02842fSSascha Wildner * FUNCTION: AcpiOsTableOverride
3350d02842fSSascha Wildner *
3360d02842fSSascha Wildner * PARAMETERS: ExistingTable - Header of current table (probably firmware)
3370d02842fSSascha Wildner * NewTable - Where an entire new table is returned.
3380d02842fSSascha Wildner *
3390d02842fSSascha Wildner * RETURN: Status, pointer to new table. Null pointer returned if no
3400d02842fSSascha Wildner * table is available to override
3410d02842fSSascha Wildner *
3420d02842fSSascha Wildner * DESCRIPTION: Return a different version of a table if one is available
3430d02842fSSascha Wildner *
3440d02842fSSascha Wildner *****************************************************************************/
3450d02842fSSascha Wildner
3460d02842fSSascha Wildner ACPI_STATUS
AcpiOsTableOverride(ACPI_TABLE_HEADER * ExistingTable,ACPI_TABLE_HEADER ** NewTable)3470d02842fSSascha Wildner AcpiOsTableOverride (
3480d02842fSSascha Wildner ACPI_TABLE_HEADER *ExistingTable,
3490d02842fSSascha Wildner ACPI_TABLE_HEADER **NewTable)
3500d02842fSSascha Wildner {
3510d02842fSSascha Wildner
3520d02842fSSascha Wildner if (!ExistingTable || !NewTable)
3530d02842fSSascha Wildner {
3540d02842fSSascha Wildner return (AE_BAD_PARAMETER);
3550d02842fSSascha Wildner }
3560d02842fSSascha Wildner
3570d02842fSSascha Wildner *NewTable = NULL;
3580d02842fSSascha Wildner
3590d02842fSSascha Wildner
3600d02842fSSascha Wildner #ifdef ACPI_EXEC_APP
3610d02842fSSascha Wildner
3620d02842fSSascha Wildner /* Call back up to AcpiExec */
3630d02842fSSascha Wildner
3640d02842fSSascha Wildner AeTableOverride (ExistingTable, NewTable);
3650d02842fSSascha Wildner #endif
3660d02842fSSascha Wildner
3670d02842fSSascha Wildner return (AE_OK);
3680d02842fSSascha Wildner }
3690d02842fSSascha Wildner
3700d02842fSSascha Wildner
3710d02842fSSascha Wildner /******************************************************************************
3720d02842fSSascha Wildner *
3730d02842fSSascha Wildner * FUNCTION: AcpiOsPhysicalTableOverride
3740d02842fSSascha Wildner *
3750d02842fSSascha Wildner * PARAMETERS: ExistingTable - Header of current table (probably firmware)
3760d02842fSSascha Wildner * NewAddress - Where new table address is returned
3770d02842fSSascha Wildner * (Physical address)
3780d02842fSSascha Wildner * NewTableLength - Where new table length is returned
3790d02842fSSascha Wildner *
3800d02842fSSascha Wildner * RETURN: Status, address/length of new table. Null pointer returned
3810d02842fSSascha Wildner * if no table is available to override.
3820d02842fSSascha Wildner *
3830d02842fSSascha Wildner * DESCRIPTION: Returns AE_SUPPORT, function not used in user space.
3840d02842fSSascha Wildner *
3850d02842fSSascha Wildner *****************************************************************************/
3860d02842fSSascha Wildner
3870d02842fSSascha Wildner ACPI_STATUS
AcpiOsPhysicalTableOverride(ACPI_TABLE_HEADER * ExistingTable,ACPI_PHYSICAL_ADDRESS * NewAddress,UINT32 * NewTableLength)3880d02842fSSascha Wildner AcpiOsPhysicalTableOverride (
3890d02842fSSascha Wildner ACPI_TABLE_HEADER *ExistingTable,
3900d02842fSSascha Wildner ACPI_PHYSICAL_ADDRESS *NewAddress,
3910d02842fSSascha Wildner UINT32 *NewTableLength)
3920d02842fSSascha Wildner {
3930d02842fSSascha Wildner
3940d02842fSSascha Wildner return (AE_SUPPORT);
3950d02842fSSascha Wildner }
3960d02842fSSascha Wildner
3970d02842fSSascha Wildner
3980d02842fSSascha Wildner /******************************************************************************
3990d02842fSSascha Wildner *
40038b5d46cSSascha Wildner * FUNCTION: AcpiOsEnterSleep
40138b5d46cSSascha Wildner *
40238b5d46cSSascha Wildner * PARAMETERS: SleepState - Which sleep state to enter
40338b5d46cSSascha Wildner * RegaValue - Register A value
40438b5d46cSSascha Wildner * RegbValue - Register B value
40538b5d46cSSascha Wildner *
40638b5d46cSSascha Wildner * RETURN: Status
40738b5d46cSSascha Wildner *
40838b5d46cSSascha Wildner * DESCRIPTION: A hook before writing sleep registers to enter the sleep
40938b5d46cSSascha Wildner * state. Return AE_CTRL_SKIP to skip further sleep register
41038b5d46cSSascha Wildner * writes.
41138b5d46cSSascha Wildner *
41238b5d46cSSascha Wildner *****************************************************************************/
41338b5d46cSSascha Wildner
41438b5d46cSSascha Wildner ACPI_STATUS
AcpiOsEnterSleep(UINT8 SleepState,UINT32 RegaValue,UINT32 RegbValue)41538b5d46cSSascha Wildner AcpiOsEnterSleep (
41638b5d46cSSascha Wildner UINT8 SleepState,
41738b5d46cSSascha Wildner UINT32 RegaValue,
41838b5d46cSSascha Wildner UINT32 RegbValue)
41938b5d46cSSascha Wildner {
42038b5d46cSSascha Wildner
42138b5d46cSSascha Wildner return (AE_OK);
42238b5d46cSSascha Wildner }
42338b5d46cSSascha Wildner
42438b5d46cSSascha Wildner
42538b5d46cSSascha Wildner /******************************************************************************
42638b5d46cSSascha Wildner *
4270d02842fSSascha Wildner * FUNCTION: AcpiOsGetTimer
4280d02842fSSascha Wildner *
4290d02842fSSascha Wildner * PARAMETERS: None
4300d02842fSSascha Wildner *
4310d02842fSSascha Wildner * RETURN: Current ticks in 100-nanosecond units
4320d02842fSSascha Wildner *
4330d02842fSSascha Wildner * DESCRIPTION: Get the value of a system timer
4340d02842fSSascha Wildner *
4350d02842fSSascha Wildner ******************************************************************************/
4360d02842fSSascha Wildner
4370d02842fSSascha Wildner UINT64
AcpiOsGetTimer(void)4380d02842fSSascha Wildner AcpiOsGetTimer (
4390d02842fSSascha Wildner void)
4400d02842fSSascha Wildner {
4410d02842fSSascha Wildner LARGE_INTEGER Timer;
4420d02842fSSascha Wildner
4430d02842fSSascha Wildner
4440d02842fSSascha Wildner /* Attempt to use hi-granularity timer first */
4450d02842fSSascha Wildner
4460d02842fSSascha Wildner if (TimerFrequency &&
4470d02842fSSascha Wildner QueryPerformanceCounter (&Timer))
4480d02842fSSascha Wildner {
4490d02842fSSascha Wildner /* Convert to 100 nanosecond ticks */
4500d02842fSSascha Wildner
4510d02842fSSascha Wildner return ((UINT64) ((Timer.QuadPart * (UINT64) ACPI_100NSEC_PER_SEC) /
4520d02842fSSascha Wildner TimerFrequency));
4530d02842fSSascha Wildner }
4540d02842fSSascha Wildner
4550d02842fSSascha Wildner /* Fall back to the lo-granularity timer */
4560d02842fSSascha Wildner
4570d02842fSSascha Wildner else
4580d02842fSSascha Wildner {
4590d02842fSSascha Wildner /* Convert milliseconds to 100 nanosecond ticks */
4600d02842fSSascha Wildner
461e5412f1eSSascha Wildner return (GetTickCount64() * ACPI_100NSEC_PER_MSEC);
4620d02842fSSascha Wildner }
4630d02842fSSascha Wildner }
4640d02842fSSascha Wildner
4650d02842fSSascha Wildner
4660d02842fSSascha Wildner /******************************************************************************
4670d02842fSSascha Wildner *
4680d02842fSSascha Wildner * FUNCTION: AcpiOsReadable
4690d02842fSSascha Wildner *
4700d02842fSSascha Wildner * PARAMETERS: Pointer - Area to be verified
4710d02842fSSascha Wildner * Length - Size of area
4720d02842fSSascha Wildner *
4730d02842fSSascha Wildner * RETURN: TRUE if readable for entire length
4740d02842fSSascha Wildner *
4750d02842fSSascha Wildner * DESCRIPTION: Verify that a pointer is valid for reading
4760d02842fSSascha Wildner *
4770d02842fSSascha Wildner *****************************************************************************/
4780d02842fSSascha Wildner
4790d02842fSSascha Wildner BOOLEAN
AcpiOsReadable(void * Pointer,ACPI_SIZE Length)4800d02842fSSascha Wildner AcpiOsReadable (
4810d02842fSSascha Wildner void *Pointer,
4820d02842fSSascha Wildner ACPI_SIZE Length)
4830d02842fSSascha Wildner {
4840d02842fSSascha Wildner
4850d02842fSSascha Wildner return ((BOOLEAN) !IsBadReadPtr (Pointer, Length));
4860d02842fSSascha Wildner }
4870d02842fSSascha Wildner
4880d02842fSSascha Wildner
4890d02842fSSascha Wildner /******************************************************************************
4900d02842fSSascha Wildner *
4910d02842fSSascha Wildner * FUNCTION: AcpiOsWritable
4920d02842fSSascha Wildner *
4930d02842fSSascha Wildner * PARAMETERS: Pointer - Area to be verified
4940d02842fSSascha Wildner * Length - Size of area
4950d02842fSSascha Wildner *
4960d02842fSSascha Wildner * RETURN: TRUE if writable for entire length
4970d02842fSSascha Wildner *
4980d02842fSSascha Wildner * DESCRIPTION: Verify that a pointer is valid for writing
4990d02842fSSascha Wildner *
5000d02842fSSascha Wildner *****************************************************************************/
5010d02842fSSascha Wildner
5020d02842fSSascha Wildner BOOLEAN
AcpiOsWritable(void * Pointer,ACPI_SIZE Length)5030d02842fSSascha Wildner AcpiOsWritable (
5040d02842fSSascha Wildner void *Pointer,
5050d02842fSSascha Wildner ACPI_SIZE Length)
5060d02842fSSascha Wildner {
5070d02842fSSascha Wildner
5080d02842fSSascha Wildner return ((BOOLEAN) !IsBadWritePtr (Pointer, Length));
5090d02842fSSascha Wildner }
5100d02842fSSascha Wildner
5110d02842fSSascha Wildner
5120d02842fSSascha Wildner /******************************************************************************
5130d02842fSSascha Wildner *
5140d02842fSSascha Wildner * FUNCTION: AcpiOsRedirectOutput
5150d02842fSSascha Wildner *
5160d02842fSSascha Wildner * PARAMETERS: Destination - An open file handle/pointer
5170d02842fSSascha Wildner *
5180d02842fSSascha Wildner * RETURN: None
5190d02842fSSascha Wildner *
5200d02842fSSascha Wildner * DESCRIPTION: Causes redirect of AcpiOsPrintf and AcpiOsVprintf
5210d02842fSSascha Wildner *
5220d02842fSSascha Wildner *****************************************************************************/
5230d02842fSSascha Wildner
5240d02842fSSascha Wildner void
AcpiOsRedirectOutput(void * Destination)5250d02842fSSascha Wildner AcpiOsRedirectOutput (
5260d02842fSSascha Wildner void *Destination)
5270d02842fSSascha Wildner {
5280d02842fSSascha Wildner
5290d02842fSSascha Wildner AcpiGbl_OutputFile = Destination;
5300d02842fSSascha Wildner }
5310d02842fSSascha Wildner
5320d02842fSSascha Wildner
5330d02842fSSascha Wildner /******************************************************************************
5340d02842fSSascha Wildner *
5350d02842fSSascha Wildner * FUNCTION: AcpiOsPrintf
5360d02842fSSascha Wildner *
5370d02842fSSascha Wildner * PARAMETERS: Fmt, ... - Standard printf format
5380d02842fSSascha Wildner *
5390d02842fSSascha Wildner * RETURN: None
5400d02842fSSascha Wildner *
5410d02842fSSascha Wildner * DESCRIPTION: Formatted output
5420d02842fSSascha Wildner *
5430d02842fSSascha Wildner *****************************************************************************/
5440d02842fSSascha Wildner
5450d02842fSSascha Wildner void ACPI_INTERNAL_VAR_XFACE
AcpiOsPrintf(const char * Fmt,...)5460d02842fSSascha Wildner AcpiOsPrintf (
5470d02842fSSascha Wildner const char *Fmt,
5480d02842fSSascha Wildner ...)
5490d02842fSSascha Wildner {
5500d02842fSSascha Wildner va_list Args;
5510d02842fSSascha Wildner UINT8 Flags;
5520d02842fSSascha Wildner
5530d02842fSSascha Wildner
5540d02842fSSascha Wildner Flags = AcpiGbl_DbOutputFlags;
5550d02842fSSascha Wildner if (Flags & ACPI_DB_REDIRECTABLE_OUTPUT)
5560d02842fSSascha Wildner {
5570d02842fSSascha Wildner /* Output is directable to either a file (if open) or the console */
5580d02842fSSascha Wildner
5590d02842fSSascha Wildner if (AcpiGbl_DebugFile)
5600d02842fSSascha Wildner {
5610d02842fSSascha Wildner /* Output file is open, send the output there */
5620d02842fSSascha Wildner
5630d02842fSSascha Wildner va_start (Args, Fmt);
5640d02842fSSascha Wildner vfprintf (AcpiGbl_DebugFile, Fmt, Args);
5650d02842fSSascha Wildner va_end (Args);
5660d02842fSSascha Wildner }
5670d02842fSSascha Wildner else
5680d02842fSSascha Wildner {
5690d02842fSSascha Wildner /* No redirection, send output to console (once only!) */
5700d02842fSSascha Wildner
5710d02842fSSascha Wildner Flags |= ACPI_DB_CONSOLE_OUTPUT;
5720d02842fSSascha Wildner }
5730d02842fSSascha Wildner }
5740d02842fSSascha Wildner
5750d02842fSSascha Wildner if (Flags & ACPI_DB_CONSOLE_OUTPUT)
5760d02842fSSascha Wildner {
5770d02842fSSascha Wildner va_start (Args, Fmt);
5780d02842fSSascha Wildner vfprintf (AcpiGbl_OutputFile, Fmt, Args);
5790d02842fSSascha Wildner va_end (Args);
5800d02842fSSascha Wildner }
5810d02842fSSascha Wildner
5820d02842fSSascha Wildner return;
5830d02842fSSascha Wildner }
5840d02842fSSascha Wildner
5850d02842fSSascha Wildner
5860d02842fSSascha Wildner /******************************************************************************
5870d02842fSSascha Wildner *
5880d02842fSSascha Wildner * FUNCTION: AcpiOsVprintf
5890d02842fSSascha Wildner *
5900d02842fSSascha Wildner * PARAMETERS: Fmt - Standard printf format
5910d02842fSSascha Wildner * Args - Argument list
5920d02842fSSascha Wildner *
5930d02842fSSascha Wildner * RETURN: None
5940d02842fSSascha Wildner *
5950d02842fSSascha Wildner * DESCRIPTION: Formatted output with argument list pointer
5960d02842fSSascha Wildner *
5970d02842fSSascha Wildner *****************************************************************************/
5980d02842fSSascha Wildner
5990d02842fSSascha Wildner void
AcpiOsVprintf(const char * Fmt,va_list Args)6000d02842fSSascha Wildner AcpiOsVprintf (
6010d02842fSSascha Wildner const char *Fmt,
6020d02842fSSascha Wildner va_list Args)
6030d02842fSSascha Wildner {
6040d02842fSSascha Wildner INT32 Count = 0;
6050d02842fSSascha Wildner UINT8 Flags;
6060d02842fSSascha Wildner
6070d02842fSSascha Wildner
6080d02842fSSascha Wildner Flags = AcpiGbl_DbOutputFlags;
6090d02842fSSascha Wildner if (Flags & ACPI_DB_REDIRECTABLE_OUTPUT)
6100d02842fSSascha Wildner {
6110d02842fSSascha Wildner /* Output is directable to either a file (if open) or the console */
6120d02842fSSascha Wildner
6130d02842fSSascha Wildner if (AcpiGbl_DebugFile)
6140d02842fSSascha Wildner {
6150d02842fSSascha Wildner /* Output file is open, send the output there */
6160d02842fSSascha Wildner
6170d02842fSSascha Wildner Count = vfprintf (AcpiGbl_DebugFile, Fmt, Args);
6180d02842fSSascha Wildner }
6190d02842fSSascha Wildner else
6200d02842fSSascha Wildner {
6210d02842fSSascha Wildner /* No redirection, send output to console (once only!) */
6220d02842fSSascha Wildner
6230d02842fSSascha Wildner Flags |= ACPI_DB_CONSOLE_OUTPUT;
6240d02842fSSascha Wildner }
6250d02842fSSascha Wildner }
6260d02842fSSascha Wildner
6270d02842fSSascha Wildner if (Flags & ACPI_DB_CONSOLE_OUTPUT)
6280d02842fSSascha Wildner {
6290d02842fSSascha Wildner Count = vfprintf (AcpiGbl_OutputFile, Fmt, Args);
6300d02842fSSascha Wildner }
6310d02842fSSascha Wildner
6320d02842fSSascha Wildner return;
6330d02842fSSascha Wildner }
6340d02842fSSascha Wildner
6350d02842fSSascha Wildner
6360d02842fSSascha Wildner /******************************************************************************
6370d02842fSSascha Wildner *
6380d02842fSSascha Wildner * FUNCTION: AcpiOsGetLine
6390d02842fSSascha Wildner *
6400d02842fSSascha Wildner * PARAMETERS: Buffer - Where to return the command line
6410d02842fSSascha Wildner * BufferLength - Maximum length of Buffer
6420d02842fSSascha Wildner * BytesRead - Where the actual byte count is returned
6430d02842fSSascha Wildner *
6440d02842fSSascha Wildner * RETURN: Status and actual bytes read
6450d02842fSSascha Wildner *
6460d02842fSSascha Wildner * DESCRIPTION: Formatted input with argument list pointer
6470d02842fSSascha Wildner *
6480d02842fSSascha Wildner *****************************************************************************/
6490d02842fSSascha Wildner
6500d02842fSSascha Wildner ACPI_STATUS
AcpiOsGetLine(char * Buffer,UINT32 BufferLength,UINT32 * BytesRead)6510d02842fSSascha Wildner AcpiOsGetLine (
6520d02842fSSascha Wildner char *Buffer,
6530d02842fSSascha Wildner UINT32 BufferLength,
6540d02842fSSascha Wildner UINT32 *BytesRead)
6550d02842fSSascha Wildner {
6560d02842fSSascha Wildner int Temp;
6570d02842fSSascha Wildner UINT32 i;
6580d02842fSSascha Wildner
6590d02842fSSascha Wildner
6600d02842fSSascha Wildner for (i = 0; ; i++)
6610d02842fSSascha Wildner {
6620d02842fSSascha Wildner if (i >= BufferLength)
6630d02842fSSascha Wildner {
6640d02842fSSascha Wildner return (AE_BUFFER_OVERFLOW);
6650d02842fSSascha Wildner }
6660d02842fSSascha Wildner
6670d02842fSSascha Wildner if ((Temp = getchar ()) == EOF)
6680d02842fSSascha Wildner {
6690d02842fSSascha Wildner return (AE_ERROR);
6700d02842fSSascha Wildner }
6710d02842fSSascha Wildner
6720d02842fSSascha Wildner if (!Temp || Temp == '\n')
6730d02842fSSascha Wildner {
6740d02842fSSascha Wildner break;
6750d02842fSSascha Wildner }
6760d02842fSSascha Wildner
6770d02842fSSascha Wildner Buffer [i] = (char) Temp;
6780d02842fSSascha Wildner }
6790d02842fSSascha Wildner
6800d02842fSSascha Wildner /* Null terminate the buffer */
6810d02842fSSascha Wildner
6820d02842fSSascha Wildner Buffer [i] = 0;
6830d02842fSSascha Wildner
6840d02842fSSascha Wildner /* Return the number of bytes in the string */
6850d02842fSSascha Wildner
6860d02842fSSascha Wildner if (BytesRead)
6870d02842fSSascha Wildner {
6880d02842fSSascha Wildner *BytesRead = i;
6890d02842fSSascha Wildner }
690820c5b08SSascha Wildner
6910d02842fSSascha Wildner return (AE_OK);
6920d02842fSSascha Wildner }
6930d02842fSSascha Wildner
6940d02842fSSascha Wildner
6955f39c7e7SSascha Wildner #ifndef ACPI_USE_NATIVE_MEMORY_MAPPING
6960d02842fSSascha Wildner /******************************************************************************
6970d02842fSSascha Wildner *
6980d02842fSSascha Wildner * FUNCTION: AcpiOsMapMemory
6990d02842fSSascha Wildner *
7000d02842fSSascha Wildner * PARAMETERS: Where - Physical address of memory to be mapped
7010d02842fSSascha Wildner * Length - How much memory to map
7020d02842fSSascha Wildner *
7030d02842fSSascha Wildner * RETURN: Pointer to mapped memory. Null on error.
7040d02842fSSascha Wildner *
7050d02842fSSascha Wildner * DESCRIPTION: Map physical memory into caller's address space
7060d02842fSSascha Wildner *
7070d02842fSSascha Wildner *****************************************************************************/
7080d02842fSSascha Wildner
7090d02842fSSascha Wildner void *
AcpiOsMapMemory(ACPI_PHYSICAL_ADDRESS Where,ACPI_SIZE Length)7100d02842fSSascha Wildner AcpiOsMapMemory (
7110d02842fSSascha Wildner ACPI_PHYSICAL_ADDRESS Where,
7120d02842fSSascha Wildner ACPI_SIZE Length)
7130d02842fSSascha Wildner {
7140d02842fSSascha Wildner
7150d02842fSSascha Wildner return (ACPI_TO_POINTER ((ACPI_SIZE) Where));
7160d02842fSSascha Wildner }
7170d02842fSSascha Wildner
7180d02842fSSascha Wildner
7190d02842fSSascha Wildner /******************************************************************************
7200d02842fSSascha Wildner *
7210d02842fSSascha Wildner * FUNCTION: AcpiOsUnmapMemory
7220d02842fSSascha Wildner *
7230d02842fSSascha Wildner * PARAMETERS: Where - Logical address of memory to be unmapped
7240d02842fSSascha Wildner * Length - How much memory to unmap
7250d02842fSSascha Wildner *
7260d02842fSSascha Wildner * RETURN: None.
7270d02842fSSascha Wildner *
7280d02842fSSascha Wildner * DESCRIPTION: Delete a previously created mapping. Where and Length must
7290d02842fSSascha Wildner * correspond to a previous mapping exactly.
7300d02842fSSascha Wildner *
7310d02842fSSascha Wildner *****************************************************************************/
7320d02842fSSascha Wildner
7330d02842fSSascha Wildner void
AcpiOsUnmapMemory(void * Where,ACPI_SIZE Length)7340d02842fSSascha Wildner AcpiOsUnmapMemory (
7350d02842fSSascha Wildner void *Where,
7360d02842fSSascha Wildner ACPI_SIZE Length)
7370d02842fSSascha Wildner {
7380d02842fSSascha Wildner
7390d02842fSSascha Wildner return;
7400d02842fSSascha Wildner }
7415f39c7e7SSascha Wildner #endif
7420d02842fSSascha Wildner
7430d02842fSSascha Wildner
7440d02842fSSascha Wildner /******************************************************************************
7450d02842fSSascha Wildner *
7460d02842fSSascha Wildner * FUNCTION: AcpiOsAllocate
7470d02842fSSascha Wildner *
7480d02842fSSascha Wildner * PARAMETERS: Size - Amount to allocate, in bytes
7490d02842fSSascha Wildner *
7500d02842fSSascha Wildner * RETURN: Pointer to the new allocation. Null on error.
7510d02842fSSascha Wildner *
7520d02842fSSascha Wildner * DESCRIPTION: Allocate memory. Algorithm is dependent on the OS.
7530d02842fSSascha Wildner *
7540d02842fSSascha Wildner *****************************************************************************/
7550d02842fSSascha Wildner
7560d02842fSSascha Wildner void *
AcpiOsAllocate(ACPI_SIZE Size)7570d02842fSSascha Wildner AcpiOsAllocate (
7580d02842fSSascha Wildner ACPI_SIZE Size)
7590d02842fSSascha Wildner {
7600d02842fSSascha Wildner void *Mem;
7610d02842fSSascha Wildner
7620d02842fSSascha Wildner
7630d02842fSSascha Wildner Mem = (void *) malloc ((size_t) Size);
7640d02842fSSascha Wildner return (Mem);
7650d02842fSSascha Wildner }
7660d02842fSSascha Wildner
7670d02842fSSascha Wildner
7685f39c7e7SSascha Wildner #ifdef USE_NATIVE_ALLOCATE_ZEROED
7695f39c7e7SSascha Wildner /******************************************************************************
7705f39c7e7SSascha Wildner *
7715f39c7e7SSascha Wildner * FUNCTION: AcpiOsAllocateZeroed
7725f39c7e7SSascha Wildner *
7735f39c7e7SSascha Wildner * PARAMETERS: Size - Amount to allocate, in bytes
7745f39c7e7SSascha Wildner *
7755f39c7e7SSascha Wildner * RETURN: Pointer to the new allocation. Null on error.
7765f39c7e7SSascha Wildner *
7775f39c7e7SSascha Wildner * DESCRIPTION: Allocate and zero memory. Algorithm is dependent on the OS.
7785f39c7e7SSascha Wildner *
7795f39c7e7SSascha Wildner *****************************************************************************/
7805f39c7e7SSascha Wildner
7815f39c7e7SSascha Wildner void *
AcpiOsAllocateZeroed(ACPI_SIZE Size)7825f39c7e7SSascha Wildner AcpiOsAllocateZeroed (
7835f39c7e7SSascha Wildner ACPI_SIZE Size)
7845f39c7e7SSascha Wildner {
7855f39c7e7SSascha Wildner void *Mem;
7865f39c7e7SSascha Wildner
7875f39c7e7SSascha Wildner
7885f39c7e7SSascha Wildner Mem = (void *) calloc (1, (size_t) Size);
7895f39c7e7SSascha Wildner return (Mem);
7905f39c7e7SSascha Wildner }
7915f39c7e7SSascha Wildner #endif
7925f39c7e7SSascha Wildner
7935f39c7e7SSascha Wildner
7940d02842fSSascha Wildner /******************************************************************************
7950d02842fSSascha Wildner *
7960d02842fSSascha Wildner * FUNCTION: AcpiOsFree
7970d02842fSSascha Wildner *
7980d02842fSSascha Wildner * PARAMETERS: Mem - Pointer to previously allocated memory
7990d02842fSSascha Wildner *
8000d02842fSSascha Wildner * RETURN: None.
8010d02842fSSascha Wildner *
8020d02842fSSascha Wildner * DESCRIPTION: Free memory allocated via AcpiOsAllocate
8030d02842fSSascha Wildner *
8040d02842fSSascha Wildner *****************************************************************************/
8050d02842fSSascha Wildner
8060d02842fSSascha Wildner void
AcpiOsFree(void * Mem)8070d02842fSSascha Wildner AcpiOsFree (
8080d02842fSSascha Wildner void *Mem)
8090d02842fSSascha Wildner {
8100d02842fSSascha Wildner
8110d02842fSSascha Wildner free (Mem);
8120d02842fSSascha Wildner }
8130d02842fSSascha Wildner
8140d02842fSSascha Wildner
8150d02842fSSascha Wildner #ifdef ACPI_SINGLE_THREADED
8160d02842fSSascha Wildner /******************************************************************************
8170d02842fSSascha Wildner *
8180d02842fSSascha Wildner * FUNCTION: Semaphore stub functions
8190d02842fSSascha Wildner *
8200d02842fSSascha Wildner * DESCRIPTION: Stub functions used for single-thread applications that do
8210d02842fSSascha Wildner * not require semaphore synchronization. Full implementations
8220d02842fSSascha Wildner * of these functions appear after the stubs.
8230d02842fSSascha Wildner *
8240d02842fSSascha Wildner *****************************************************************************/
8250d02842fSSascha Wildner
8260d02842fSSascha Wildner ACPI_STATUS
AcpiOsCreateSemaphore(UINT32 MaxUnits,UINT32 InitialUnits,ACPI_HANDLE * OutHandle)8270d02842fSSascha Wildner AcpiOsCreateSemaphore (
8280d02842fSSascha Wildner UINT32 MaxUnits,
8290d02842fSSascha Wildner UINT32 InitialUnits,
8300d02842fSSascha Wildner ACPI_HANDLE *OutHandle)
8310d02842fSSascha Wildner {
8320d02842fSSascha Wildner *OutHandle = (ACPI_HANDLE) 1;
8330d02842fSSascha Wildner return (AE_OK);
8340d02842fSSascha Wildner }
8350d02842fSSascha Wildner
8360d02842fSSascha Wildner ACPI_STATUS
AcpiOsDeleteSemaphore(ACPI_HANDLE Handle)8370d02842fSSascha Wildner AcpiOsDeleteSemaphore (
8380d02842fSSascha Wildner ACPI_HANDLE Handle)
8390d02842fSSascha Wildner {
8400d02842fSSascha Wildner return (AE_OK);
8410d02842fSSascha Wildner }
8420d02842fSSascha Wildner
8430d02842fSSascha Wildner ACPI_STATUS
AcpiOsWaitSemaphore(ACPI_HANDLE Handle,UINT32 Units,UINT16 Timeout)8440d02842fSSascha Wildner AcpiOsWaitSemaphore (
8450d02842fSSascha Wildner ACPI_HANDLE Handle,
8460d02842fSSascha Wildner UINT32 Units,
8470d02842fSSascha Wildner UINT16 Timeout)
8480d02842fSSascha Wildner {
8490d02842fSSascha Wildner return (AE_OK);
8500d02842fSSascha Wildner }
8510d02842fSSascha Wildner
8520d02842fSSascha Wildner ACPI_STATUS
AcpiOsSignalSemaphore(ACPI_HANDLE Handle,UINT32 Units)8530d02842fSSascha Wildner AcpiOsSignalSemaphore (
8540d02842fSSascha Wildner ACPI_HANDLE Handle,
8550d02842fSSascha Wildner UINT32 Units)
8560d02842fSSascha Wildner {
8570d02842fSSascha Wildner return (AE_OK);
8580d02842fSSascha Wildner }
8590d02842fSSascha Wildner
8600d02842fSSascha Wildner #else
8610d02842fSSascha Wildner /******************************************************************************
8620d02842fSSascha Wildner *
8630d02842fSSascha Wildner * FUNCTION: AcpiOsCreateSemaphore
8640d02842fSSascha Wildner *
8650d02842fSSascha Wildner * PARAMETERS: MaxUnits - Maximum units that can be sent
8660d02842fSSascha Wildner * InitialUnits - Units to be assigned to the new semaphore
8670d02842fSSascha Wildner * OutHandle - Where a handle will be returned
8680d02842fSSascha Wildner *
8690d02842fSSascha Wildner * RETURN: Status
8700d02842fSSascha Wildner *
8710d02842fSSascha Wildner * DESCRIPTION: Create an OS semaphore
8720d02842fSSascha Wildner *
8730d02842fSSascha Wildner *****************************************************************************/
8740d02842fSSascha Wildner
8750d02842fSSascha Wildner ACPI_STATUS
AcpiOsCreateSemaphore(UINT32 MaxUnits,UINT32 InitialUnits,ACPI_SEMAPHORE * OutHandle)8760d02842fSSascha Wildner AcpiOsCreateSemaphore (
8770d02842fSSascha Wildner UINT32 MaxUnits,
8780d02842fSSascha Wildner UINT32 InitialUnits,
8790d02842fSSascha Wildner ACPI_SEMAPHORE *OutHandle)
8800d02842fSSascha Wildner {
8810d02842fSSascha Wildner void *Mutex;
8820d02842fSSascha Wildner UINT32 i;
8830d02842fSSascha Wildner
8840d02842fSSascha Wildner ACPI_FUNCTION_NAME (OsCreateSemaphore);
8850d02842fSSascha Wildner
8860d02842fSSascha Wildner
8870d02842fSSascha Wildner if (MaxUnits == ACPI_UINT32_MAX)
8880d02842fSSascha Wildner {
8890d02842fSSascha Wildner MaxUnits = 255;
8900d02842fSSascha Wildner }
8910d02842fSSascha Wildner
8920d02842fSSascha Wildner if (InitialUnits == ACPI_UINT32_MAX)
8930d02842fSSascha Wildner {
8940d02842fSSascha Wildner InitialUnits = MaxUnits;
8950d02842fSSascha Wildner }
8960d02842fSSascha Wildner
8970d02842fSSascha Wildner if (InitialUnits > MaxUnits)
8980d02842fSSascha Wildner {
8990d02842fSSascha Wildner return (AE_BAD_PARAMETER);
9000d02842fSSascha Wildner }
9010d02842fSSascha Wildner
9020d02842fSSascha Wildner /* Find an empty slot */
9030d02842fSSascha Wildner
9040d02842fSSascha Wildner for (i = 0; i < ACPI_OS_MAX_SEMAPHORES; i++)
9050d02842fSSascha Wildner {
9060d02842fSSascha Wildner if (!AcpiGbl_Semaphores[i].OsHandle)
9070d02842fSSascha Wildner {
9080d02842fSSascha Wildner break;
9090d02842fSSascha Wildner }
9100d02842fSSascha Wildner }
9110d02842fSSascha Wildner if (i >= ACPI_OS_MAX_SEMAPHORES)
9120d02842fSSascha Wildner {
9130d02842fSSascha Wildner ACPI_EXCEPTION ((AE_INFO, AE_LIMIT,
914820c5b08SSascha Wildner "Reached max semaphores (%u), could not create",
915820c5b08SSascha Wildner ACPI_OS_MAX_SEMAPHORES));
9160d02842fSSascha Wildner return (AE_LIMIT);
9170d02842fSSascha Wildner }
9180d02842fSSascha Wildner
9190d02842fSSascha Wildner /* Create an OS semaphore */
9200d02842fSSascha Wildner
9210d02842fSSascha Wildner Mutex = CreateSemaphore (NULL, InitialUnits, MaxUnits, NULL);
9220d02842fSSascha Wildner if (!Mutex)
9230d02842fSSascha Wildner {
9240d02842fSSascha Wildner ACPI_ERROR ((AE_INFO, "Could not create semaphore"));
9250d02842fSSascha Wildner return (AE_NO_MEMORY);
9260d02842fSSascha Wildner }
9270d02842fSSascha Wildner
9280d02842fSSascha Wildner AcpiGbl_Semaphores[i].MaxUnits = (UINT16) MaxUnits;
9290d02842fSSascha Wildner AcpiGbl_Semaphores[i].CurrentUnits = (UINT16) InitialUnits;
9300d02842fSSascha Wildner AcpiGbl_Semaphores[i].OsHandle = Mutex;
9310d02842fSSascha Wildner
932820c5b08SSascha Wildner ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX,
933820c5b08SSascha Wildner "Handle=%u, Max=%u, Current=%u, OsHandle=%p\n",
9340d02842fSSascha Wildner i, MaxUnits, InitialUnits, Mutex));
9350d02842fSSascha Wildner
9360d02842fSSascha Wildner *OutHandle = (void *) i;
9370d02842fSSascha Wildner return (AE_OK);
9380d02842fSSascha Wildner }
9390d02842fSSascha Wildner
9400d02842fSSascha Wildner
9410d02842fSSascha Wildner /******************************************************************************
9420d02842fSSascha Wildner *
9430d02842fSSascha Wildner * FUNCTION: AcpiOsDeleteSemaphore
9440d02842fSSascha Wildner *
9450d02842fSSascha Wildner * PARAMETERS: Handle - Handle returned by AcpiOsCreateSemaphore
9460d02842fSSascha Wildner *
9470d02842fSSascha Wildner * RETURN: Status
9480d02842fSSascha Wildner *
9490d02842fSSascha Wildner * DESCRIPTION: Delete an OS semaphore
9500d02842fSSascha Wildner *
9510d02842fSSascha Wildner *****************************************************************************/
9520d02842fSSascha Wildner
9530d02842fSSascha Wildner ACPI_STATUS
AcpiOsDeleteSemaphore(ACPI_SEMAPHORE Handle)9540d02842fSSascha Wildner AcpiOsDeleteSemaphore (
9550d02842fSSascha Wildner ACPI_SEMAPHORE Handle)
9560d02842fSSascha Wildner {
9570d02842fSSascha Wildner UINT32 Index = (UINT32) Handle;
9580d02842fSSascha Wildner
9590d02842fSSascha Wildner
9600d02842fSSascha Wildner if ((Index >= ACPI_OS_MAX_SEMAPHORES) ||
9610d02842fSSascha Wildner !AcpiGbl_Semaphores[Index].OsHandle)
9620d02842fSSascha Wildner {
9630d02842fSSascha Wildner return (AE_BAD_PARAMETER);
9640d02842fSSascha Wildner }
9650d02842fSSascha Wildner
9660d02842fSSascha Wildner CloseHandle (AcpiGbl_Semaphores[Index].OsHandle);
9670d02842fSSascha Wildner AcpiGbl_Semaphores[Index].OsHandle = NULL;
9680d02842fSSascha Wildner return (AE_OK);
9690d02842fSSascha Wildner }
9700d02842fSSascha Wildner
9710d02842fSSascha Wildner
9720d02842fSSascha Wildner /******************************************************************************
9730d02842fSSascha Wildner *
9740d02842fSSascha Wildner * FUNCTION: AcpiOsWaitSemaphore
9750d02842fSSascha Wildner *
9760d02842fSSascha Wildner * PARAMETERS: Handle - Handle returned by AcpiOsCreateSemaphore
9770d02842fSSascha Wildner * Units - How many units to wait for
9780d02842fSSascha Wildner * Timeout - How long to wait
9790d02842fSSascha Wildner *
9800d02842fSSascha Wildner * RETURN: Status
9810d02842fSSascha Wildner *
9820d02842fSSascha Wildner * DESCRIPTION: Wait for units
9830d02842fSSascha Wildner *
9840d02842fSSascha Wildner *****************************************************************************/
9850d02842fSSascha Wildner
9860d02842fSSascha Wildner ACPI_STATUS
AcpiOsWaitSemaphore(ACPI_SEMAPHORE Handle,UINT32 Units,UINT16 Timeout)9870d02842fSSascha Wildner AcpiOsWaitSemaphore (
9880d02842fSSascha Wildner ACPI_SEMAPHORE Handle,
9890d02842fSSascha Wildner UINT32 Units,
9900d02842fSSascha Wildner UINT16 Timeout)
9910d02842fSSascha Wildner {
9920d02842fSSascha Wildner UINT32 Index = (UINT32) Handle;
9930d02842fSSascha Wildner UINT32 WaitStatus;
9940d02842fSSascha Wildner UINT32 OsTimeout = Timeout;
9950d02842fSSascha Wildner
9960d02842fSSascha Wildner
9970d02842fSSascha Wildner ACPI_FUNCTION_ENTRY ();
9980d02842fSSascha Wildner
9990d02842fSSascha Wildner
10000d02842fSSascha Wildner if ((Index >= ACPI_OS_MAX_SEMAPHORES) ||
10010d02842fSSascha Wildner !AcpiGbl_Semaphores[Index].OsHandle)
10020d02842fSSascha Wildner {
10030d02842fSSascha Wildner return (AE_BAD_PARAMETER);
10040d02842fSSascha Wildner }
10050d02842fSSascha Wildner
10060d02842fSSascha Wildner if (Units > 1)
10070d02842fSSascha Wildner {
10080d02842fSSascha Wildner printf ("WaitSemaphore: Attempt to receive %u units\n", Units);
10090d02842fSSascha Wildner return (AE_NOT_IMPLEMENTED);
10100d02842fSSascha Wildner }
10110d02842fSSascha Wildner
10120d02842fSSascha Wildner if (Timeout == ACPI_WAIT_FOREVER)
10130d02842fSSascha Wildner {
10140d02842fSSascha Wildner OsTimeout = INFINITE;
10150d02842fSSascha Wildner if (AcpiGbl_DebugTimeout)
10160d02842fSSascha Wildner {
10170d02842fSSascha Wildner /* The debug timeout will prevent hang conditions */
10180d02842fSSascha Wildner
10190d02842fSSascha Wildner OsTimeout = ACPI_OS_DEBUG_TIMEOUT;
10200d02842fSSascha Wildner }
10210d02842fSSascha Wildner }
10220d02842fSSascha Wildner else
10230d02842fSSascha Wildner {
10240d02842fSSascha Wildner /* Add 10ms to account for clock tick granularity */
10250d02842fSSascha Wildner
10260d02842fSSascha Wildner OsTimeout += 10;
10270d02842fSSascha Wildner }
10280d02842fSSascha Wildner
1029820c5b08SSascha Wildner WaitStatus = WaitForSingleObject (
1030820c5b08SSascha Wildner AcpiGbl_Semaphores[Index].OsHandle, OsTimeout);
10310d02842fSSascha Wildner if (WaitStatus == WAIT_TIMEOUT)
10320d02842fSSascha Wildner {
10330d02842fSSascha Wildner if (AcpiGbl_DebugTimeout)
10340d02842fSSascha Wildner {
10350d02842fSSascha Wildner ACPI_EXCEPTION ((AE_INFO, AE_TIME,
10360d02842fSSascha Wildner "Debug timeout on semaphore 0x%04X (%ums)\n",
10370d02842fSSascha Wildner Index, ACPI_OS_DEBUG_TIMEOUT));
10380d02842fSSascha Wildner }
1039820c5b08SSascha Wildner
10400d02842fSSascha Wildner return (AE_TIME);
10410d02842fSSascha Wildner }
10420d02842fSSascha Wildner
10430d02842fSSascha Wildner if (AcpiGbl_Semaphores[Index].CurrentUnits == 0)
10440d02842fSSascha Wildner {
1045820c5b08SSascha Wildner ACPI_ERROR ((AE_INFO,
1046820c5b08SSascha Wildner "%s - No unit received. Timeout 0x%X, OS_Status 0x%X",
10470d02842fSSascha Wildner AcpiUtGetMutexName (Index), Timeout, WaitStatus));
10480d02842fSSascha Wildner
10490d02842fSSascha Wildner return (AE_OK);
10500d02842fSSascha Wildner }
10510d02842fSSascha Wildner
10520d02842fSSascha Wildner AcpiGbl_Semaphores[Index].CurrentUnits--;
10530d02842fSSascha Wildner return (AE_OK);
10540d02842fSSascha Wildner }
10550d02842fSSascha Wildner
10560d02842fSSascha Wildner
10570d02842fSSascha Wildner /******************************************************************************
10580d02842fSSascha Wildner *
10590d02842fSSascha Wildner * FUNCTION: AcpiOsSignalSemaphore
10600d02842fSSascha Wildner *
10610d02842fSSascha Wildner * PARAMETERS: Handle - Handle returned by AcpiOsCreateSemaphore
10620d02842fSSascha Wildner * Units - Number of units to send
10630d02842fSSascha Wildner *
10640d02842fSSascha Wildner * RETURN: Status
10650d02842fSSascha Wildner *
10660d02842fSSascha Wildner * DESCRIPTION: Send units
10670d02842fSSascha Wildner *
10680d02842fSSascha Wildner *****************************************************************************/
10690d02842fSSascha Wildner
10700d02842fSSascha Wildner ACPI_STATUS
AcpiOsSignalSemaphore(ACPI_SEMAPHORE Handle,UINT32 Units)10710d02842fSSascha Wildner AcpiOsSignalSemaphore (
10720d02842fSSascha Wildner ACPI_SEMAPHORE Handle,
10730d02842fSSascha Wildner UINT32 Units)
10740d02842fSSascha Wildner {
10750d02842fSSascha Wildner UINT32 Index = (UINT32) Handle;
10760d02842fSSascha Wildner
10770d02842fSSascha Wildner
10780d02842fSSascha Wildner ACPI_FUNCTION_ENTRY ();
10790d02842fSSascha Wildner
10800d02842fSSascha Wildner
10810d02842fSSascha Wildner if (Index >= ACPI_OS_MAX_SEMAPHORES)
10820d02842fSSascha Wildner {
10830d02842fSSascha Wildner printf ("SignalSemaphore: Index/Handle out of range: %2.2X\n", Index);
10840d02842fSSascha Wildner return (AE_BAD_PARAMETER);
10850d02842fSSascha Wildner }
10860d02842fSSascha Wildner
10870d02842fSSascha Wildner if (!AcpiGbl_Semaphores[Index].OsHandle)
10880d02842fSSascha Wildner {
10890d02842fSSascha Wildner printf ("SignalSemaphore: Null OS handle, Index %2.2X\n", Index);
10900d02842fSSascha Wildner return (AE_BAD_PARAMETER);
10910d02842fSSascha Wildner }
10920d02842fSSascha Wildner
10930d02842fSSascha Wildner if (Units > 1)
10940d02842fSSascha Wildner {
10950d02842fSSascha Wildner printf ("SignalSemaphore: Attempt to signal %u units, Index %2.2X\n", Units, Index);
10960d02842fSSascha Wildner return (AE_NOT_IMPLEMENTED);
10970d02842fSSascha Wildner }
10980d02842fSSascha Wildner
10990d02842fSSascha Wildner if ((AcpiGbl_Semaphores[Index].CurrentUnits + 1) >
11000d02842fSSascha Wildner AcpiGbl_Semaphores[Index].MaxUnits)
11010d02842fSSascha Wildner {
11020d02842fSSascha Wildner ACPI_ERROR ((AE_INFO,
11030d02842fSSascha Wildner "Oversignalled semaphore[%u]! Current %u Max %u",
11040d02842fSSascha Wildner Index, AcpiGbl_Semaphores[Index].CurrentUnits,
11050d02842fSSascha Wildner AcpiGbl_Semaphores[Index].MaxUnits));
11060d02842fSSascha Wildner
11070d02842fSSascha Wildner return (AE_LIMIT);
11080d02842fSSascha Wildner }
11090d02842fSSascha Wildner
11100d02842fSSascha Wildner AcpiGbl_Semaphores[Index].CurrentUnits++;
11110d02842fSSascha Wildner ReleaseSemaphore (AcpiGbl_Semaphores[Index].OsHandle, Units, NULL);
11120d02842fSSascha Wildner
11130d02842fSSascha Wildner return (AE_OK);
11140d02842fSSascha Wildner }
11150d02842fSSascha Wildner
11160d02842fSSascha Wildner #endif /* ACPI_SINGLE_THREADED */
11170d02842fSSascha Wildner
11180d02842fSSascha Wildner
11190d02842fSSascha Wildner /******************************************************************************
11200d02842fSSascha Wildner *
11210d02842fSSascha Wildner * FUNCTION: Spinlock interfaces
11220d02842fSSascha Wildner *
11230d02842fSSascha Wildner * DESCRIPTION: Map these interfaces to semaphore interfaces
11240d02842fSSascha Wildner *
11250d02842fSSascha Wildner *****************************************************************************/
11260d02842fSSascha Wildner
11270d02842fSSascha Wildner ACPI_STATUS
AcpiOsCreateLock(ACPI_SPINLOCK * OutHandle)11280d02842fSSascha Wildner AcpiOsCreateLock (
11290d02842fSSascha Wildner ACPI_SPINLOCK *OutHandle)
11300d02842fSSascha Wildner {
11310d02842fSSascha Wildner return (AcpiOsCreateSemaphore (1, 1, OutHandle));
11320d02842fSSascha Wildner }
11330d02842fSSascha Wildner
11340d02842fSSascha Wildner void
AcpiOsDeleteLock(ACPI_SPINLOCK Handle)11350d02842fSSascha Wildner AcpiOsDeleteLock (
11360d02842fSSascha Wildner ACPI_SPINLOCK Handle)
11370d02842fSSascha Wildner {
11380d02842fSSascha Wildner AcpiOsDeleteSemaphore (Handle);
11390d02842fSSascha Wildner }
11400d02842fSSascha Wildner
11410d02842fSSascha Wildner ACPI_CPU_FLAGS
AcpiOsAcquireLock(ACPI_SPINLOCK Handle)11420d02842fSSascha Wildner AcpiOsAcquireLock (
11430d02842fSSascha Wildner ACPI_SPINLOCK Handle)
11440d02842fSSascha Wildner {
11450d02842fSSascha Wildner AcpiOsWaitSemaphore (Handle, 1, 0xFFFF);
11460d02842fSSascha Wildner return (0);
11470d02842fSSascha Wildner }
11480d02842fSSascha Wildner
11490d02842fSSascha Wildner void
AcpiOsReleaseLock(ACPI_SPINLOCK Handle,ACPI_CPU_FLAGS Flags)11500d02842fSSascha Wildner AcpiOsReleaseLock (
11510d02842fSSascha Wildner ACPI_SPINLOCK Handle,
11520d02842fSSascha Wildner ACPI_CPU_FLAGS Flags)
11530d02842fSSascha Wildner {
11540d02842fSSascha Wildner AcpiOsSignalSemaphore (Handle, 1);
11550d02842fSSascha Wildner }
11560d02842fSSascha Wildner
11570d02842fSSascha Wildner
11580d02842fSSascha Wildner #if ACPI_FUTURE_IMPLEMENTATION
11590d02842fSSascha Wildner
11600d02842fSSascha Wildner /* Mutex interfaces, just implement with a semaphore */
11610d02842fSSascha Wildner
11620d02842fSSascha Wildner ACPI_STATUS
AcpiOsCreateMutex(ACPI_MUTEX * OutHandle)11630d02842fSSascha Wildner AcpiOsCreateMutex (
11640d02842fSSascha Wildner ACPI_MUTEX *OutHandle)
11650d02842fSSascha Wildner {
11660d02842fSSascha Wildner return (AcpiOsCreateSemaphore (1, 1, OutHandle));
11670d02842fSSascha Wildner }
11680d02842fSSascha Wildner
11690d02842fSSascha Wildner void
AcpiOsDeleteMutex(ACPI_MUTEX Handle)11700d02842fSSascha Wildner AcpiOsDeleteMutex (
11710d02842fSSascha Wildner ACPI_MUTEX Handle)
11720d02842fSSascha Wildner {
11730d02842fSSascha Wildner AcpiOsDeleteSemaphore (Handle);
11740d02842fSSascha Wildner }
11750d02842fSSascha Wildner
11760d02842fSSascha Wildner ACPI_STATUS
AcpiOsAcquireMutex(ACPI_MUTEX Handle,UINT16 Timeout)11770d02842fSSascha Wildner AcpiOsAcquireMutex (
11780d02842fSSascha Wildner ACPI_MUTEX Handle,
11790d02842fSSascha Wildner UINT16 Timeout)
11800d02842fSSascha Wildner {
11810d02842fSSascha Wildner AcpiOsWaitSemaphore (Handle, 1, Timeout);
11820d02842fSSascha Wildner return (0);
11830d02842fSSascha Wildner }
11840d02842fSSascha Wildner
11850d02842fSSascha Wildner void
AcpiOsReleaseMutex(ACPI_MUTEX Handle)11860d02842fSSascha Wildner AcpiOsReleaseMutex (
11870d02842fSSascha Wildner ACPI_MUTEX Handle)
11880d02842fSSascha Wildner {
11890d02842fSSascha Wildner AcpiOsSignalSemaphore (Handle, 1);
11900d02842fSSascha Wildner }
11910d02842fSSascha Wildner #endif
11920d02842fSSascha Wildner
11930d02842fSSascha Wildner
11940d02842fSSascha Wildner /******************************************************************************
11950d02842fSSascha Wildner *
11960d02842fSSascha Wildner * FUNCTION: AcpiOsInstallInterruptHandler
11970d02842fSSascha Wildner *
11980d02842fSSascha Wildner * PARAMETERS: InterruptNumber - Level handler should respond to.
11990d02842fSSascha Wildner * ServiceRoutine - Address of the ACPI interrupt handler
12000d02842fSSascha Wildner * Context - User context
12010d02842fSSascha Wildner *
12020d02842fSSascha Wildner * RETURN: Handle to the newly installed handler.
12030d02842fSSascha Wildner *
12040d02842fSSascha Wildner * DESCRIPTION: Install an interrupt handler. Used to install the ACPI
12050d02842fSSascha Wildner * OS-independent handler.
12060d02842fSSascha Wildner *
12070d02842fSSascha Wildner *****************************************************************************/
12080d02842fSSascha Wildner
12090d02842fSSascha Wildner UINT32
AcpiOsInstallInterruptHandler(UINT32 InterruptNumber,ACPI_OSD_HANDLER ServiceRoutine,void * Context)12100d02842fSSascha Wildner AcpiOsInstallInterruptHandler (
12110d02842fSSascha Wildner UINT32 InterruptNumber,
12120d02842fSSascha Wildner ACPI_OSD_HANDLER ServiceRoutine,
12130d02842fSSascha Wildner void *Context)
12140d02842fSSascha Wildner {
12150d02842fSSascha Wildner
12160d02842fSSascha Wildner return (AE_OK);
12170d02842fSSascha Wildner }
12180d02842fSSascha Wildner
12190d02842fSSascha Wildner
12200d02842fSSascha Wildner /******************************************************************************
12210d02842fSSascha Wildner *
12220d02842fSSascha Wildner * FUNCTION: AcpiOsRemoveInterruptHandler
12230d02842fSSascha Wildner *
12240d02842fSSascha Wildner * PARAMETERS: Handle - Returned when handler was installed
12250d02842fSSascha Wildner *
12260d02842fSSascha Wildner * RETURN: Status
12270d02842fSSascha Wildner *
12280d02842fSSascha Wildner * DESCRIPTION: Uninstalls an interrupt handler.
12290d02842fSSascha Wildner *
12300d02842fSSascha Wildner *****************************************************************************/
12310d02842fSSascha Wildner
12320d02842fSSascha Wildner ACPI_STATUS
AcpiOsRemoveInterruptHandler(UINT32 InterruptNumber,ACPI_OSD_HANDLER ServiceRoutine)12330d02842fSSascha Wildner AcpiOsRemoveInterruptHandler (
12340d02842fSSascha Wildner UINT32 InterruptNumber,
12350d02842fSSascha Wildner ACPI_OSD_HANDLER ServiceRoutine)
12360d02842fSSascha Wildner {
12370d02842fSSascha Wildner
12380d02842fSSascha Wildner return (AE_OK);
12390d02842fSSascha Wildner }
12400d02842fSSascha Wildner
12410d02842fSSascha Wildner
12420d02842fSSascha Wildner /******************************************************************************
12430d02842fSSascha Wildner *
12440d02842fSSascha Wildner * FUNCTION: AcpiOsStall
12450d02842fSSascha Wildner *
12460d02842fSSascha Wildner * PARAMETERS: Microseconds - Time to stall
12470d02842fSSascha Wildner *
12480d02842fSSascha Wildner * RETURN: None. Blocks until stall is completed.
12490d02842fSSascha Wildner *
12500d02842fSSascha Wildner * DESCRIPTION: Sleep at microsecond granularity
12510d02842fSSascha Wildner *
12520d02842fSSascha Wildner *****************************************************************************/
12530d02842fSSascha Wildner
12540d02842fSSascha Wildner void
AcpiOsStall(UINT32 Microseconds)12550d02842fSSascha Wildner AcpiOsStall (
12560d02842fSSascha Wildner UINT32 Microseconds)
12570d02842fSSascha Wildner {
12580d02842fSSascha Wildner
12590d02842fSSascha Wildner Sleep ((Microseconds / ACPI_USEC_PER_MSEC) + 1);
12600d02842fSSascha Wildner return;
12610d02842fSSascha Wildner }
12620d02842fSSascha Wildner
12630d02842fSSascha Wildner
12640d02842fSSascha Wildner /******************************************************************************
12650d02842fSSascha Wildner *
12660d02842fSSascha Wildner * FUNCTION: AcpiOsSleep
12670d02842fSSascha Wildner *
12680d02842fSSascha Wildner * PARAMETERS: Milliseconds - Time to sleep
12690d02842fSSascha Wildner *
12700d02842fSSascha Wildner * RETURN: None. Blocks until sleep is completed.
12710d02842fSSascha Wildner *
12720d02842fSSascha Wildner * DESCRIPTION: Sleep at millisecond granularity
12730d02842fSSascha Wildner *
12740d02842fSSascha Wildner *****************************************************************************/
12750d02842fSSascha Wildner
12760d02842fSSascha Wildner void
AcpiOsSleep(UINT64 Milliseconds)12770d02842fSSascha Wildner AcpiOsSleep (
12780d02842fSSascha Wildner UINT64 Milliseconds)
12790d02842fSSascha Wildner {
12800d02842fSSascha Wildner
12810d02842fSSascha Wildner /* Add 10ms to account for clock tick granularity */
12820d02842fSSascha Wildner
12830d02842fSSascha Wildner Sleep (((unsigned long) Milliseconds) + 10);
12840d02842fSSascha Wildner return;
12850d02842fSSascha Wildner }
12860d02842fSSascha Wildner
12870d02842fSSascha Wildner
12880d02842fSSascha Wildner /******************************************************************************
12890d02842fSSascha Wildner *
12900d02842fSSascha Wildner * FUNCTION: AcpiOsReadPciConfiguration
12910d02842fSSascha Wildner *
12920d02842fSSascha Wildner * PARAMETERS: PciId - Seg/Bus/Dev
12930d02842fSSascha Wildner * Register - Device Register
12940d02842fSSascha Wildner * Value - Buffer where value is placed
12950d02842fSSascha Wildner * Width - Number of bits
12960d02842fSSascha Wildner *
12970d02842fSSascha Wildner * RETURN: Status
12980d02842fSSascha Wildner *
12990d02842fSSascha Wildner * DESCRIPTION: Read data from PCI configuration space
13000d02842fSSascha Wildner *
13010d02842fSSascha Wildner *****************************************************************************/
13020d02842fSSascha Wildner
13030d02842fSSascha Wildner ACPI_STATUS
AcpiOsReadPciConfiguration(ACPI_PCI_ID * PciId,UINT32 Register,UINT64 * Value,UINT32 Width)13040d02842fSSascha Wildner AcpiOsReadPciConfiguration (
13050d02842fSSascha Wildner ACPI_PCI_ID *PciId,
13060d02842fSSascha Wildner UINT32 Register,
13070d02842fSSascha Wildner UINT64 *Value,
13080d02842fSSascha Wildner UINT32 Width)
13090d02842fSSascha Wildner {
13100d02842fSSascha Wildner
13110d02842fSSascha Wildner *Value = 0;
13120d02842fSSascha Wildner return (AE_OK);
13130d02842fSSascha Wildner }
13140d02842fSSascha Wildner
13150d02842fSSascha Wildner
13160d02842fSSascha Wildner /******************************************************************************
13170d02842fSSascha Wildner *
13180d02842fSSascha Wildner * FUNCTION: AcpiOsWritePciConfiguration
13190d02842fSSascha Wildner *
13200d02842fSSascha Wildner * PARAMETERS: PciId - Seg/Bus/Dev
13210d02842fSSascha Wildner * Register - Device Register
13220d02842fSSascha Wildner * Value - Value to be written
13230d02842fSSascha Wildner * Width - Number of bits
13240d02842fSSascha Wildner *
13250d02842fSSascha Wildner * RETURN: Status
13260d02842fSSascha Wildner *
13270d02842fSSascha Wildner * DESCRIPTION: Write data to PCI configuration space
13280d02842fSSascha Wildner *
13290d02842fSSascha Wildner *****************************************************************************/
13300d02842fSSascha Wildner
13310d02842fSSascha Wildner ACPI_STATUS
AcpiOsWritePciConfiguration(ACPI_PCI_ID * PciId,UINT32 Register,UINT64 Value,UINT32 Width)13320d02842fSSascha Wildner AcpiOsWritePciConfiguration (
13330d02842fSSascha Wildner ACPI_PCI_ID *PciId,
13340d02842fSSascha Wildner UINT32 Register,
13350d02842fSSascha Wildner UINT64 Value,
13360d02842fSSascha Wildner UINT32 Width)
13370d02842fSSascha Wildner {
13380d02842fSSascha Wildner
13390d02842fSSascha Wildner return (AE_OK);
13400d02842fSSascha Wildner }
13410d02842fSSascha Wildner
13420d02842fSSascha Wildner
13430d02842fSSascha Wildner /******************************************************************************
13440d02842fSSascha Wildner *
13450d02842fSSascha Wildner * FUNCTION: AcpiOsReadPort
13460d02842fSSascha Wildner *
13470d02842fSSascha Wildner * PARAMETERS: Address - Address of I/O port/register to read
13480d02842fSSascha Wildner * Value - Where value is placed
13490d02842fSSascha Wildner * Width - Number of bits
13500d02842fSSascha Wildner *
13510d02842fSSascha Wildner * RETURN: Value read from port
13520d02842fSSascha Wildner *
13530d02842fSSascha Wildner * DESCRIPTION: Read data from an I/O port or register
13540d02842fSSascha Wildner *
13550d02842fSSascha Wildner *****************************************************************************/
13560d02842fSSascha Wildner
13570d02842fSSascha Wildner ACPI_STATUS
AcpiOsReadPort(ACPI_IO_ADDRESS Address,UINT32 * Value,UINT32 Width)13580d02842fSSascha Wildner AcpiOsReadPort (
13590d02842fSSascha Wildner ACPI_IO_ADDRESS Address,
13600d02842fSSascha Wildner UINT32 *Value,
13610d02842fSSascha Wildner UINT32 Width)
13620d02842fSSascha Wildner {
13630d02842fSSascha Wildner ACPI_FUNCTION_NAME (OsReadPort);
13640d02842fSSascha Wildner
13650d02842fSSascha Wildner
13660d02842fSSascha Wildner switch (Width)
13670d02842fSSascha Wildner {
13680d02842fSSascha Wildner case 8:
13690d02842fSSascha Wildner
13700d02842fSSascha Wildner *Value = 0xFF;
13710d02842fSSascha Wildner break;
13720d02842fSSascha Wildner
13730d02842fSSascha Wildner case 16:
13740d02842fSSascha Wildner
13750d02842fSSascha Wildner *Value = 0xFFFF;
13760d02842fSSascha Wildner break;
13770d02842fSSascha Wildner
13780d02842fSSascha Wildner case 32:
13790d02842fSSascha Wildner
13800d02842fSSascha Wildner *Value = 0xFFFFFFFF;
13810d02842fSSascha Wildner break;
13820d02842fSSascha Wildner
13830d02842fSSascha Wildner default:
13840d02842fSSascha Wildner
13850d02842fSSascha Wildner ACPI_ERROR ((AE_INFO, "Bad width parameter: %X", Width));
13860d02842fSSascha Wildner return (AE_BAD_PARAMETER);
13870d02842fSSascha Wildner }
13880d02842fSSascha Wildner
13890d02842fSSascha Wildner return (AE_OK);
13900d02842fSSascha Wildner }
13910d02842fSSascha Wildner
13920d02842fSSascha Wildner
13930d02842fSSascha Wildner /******************************************************************************
13940d02842fSSascha Wildner *
13950d02842fSSascha Wildner * FUNCTION: AcpiOsWritePort
13960d02842fSSascha Wildner *
13970d02842fSSascha Wildner * PARAMETERS: Address - Address of I/O port/register to write
13980d02842fSSascha Wildner * Value - Value to write
13990d02842fSSascha Wildner * Width - Number of bits
14000d02842fSSascha Wildner *
14010d02842fSSascha Wildner * RETURN: None
14020d02842fSSascha Wildner *
14030d02842fSSascha Wildner * DESCRIPTION: Write data to an I/O port or register
14040d02842fSSascha Wildner *
14050d02842fSSascha Wildner *****************************************************************************/
14060d02842fSSascha Wildner
14070d02842fSSascha Wildner ACPI_STATUS
AcpiOsWritePort(ACPI_IO_ADDRESS Address,UINT32 Value,UINT32 Width)14080d02842fSSascha Wildner AcpiOsWritePort (
14090d02842fSSascha Wildner ACPI_IO_ADDRESS Address,
14100d02842fSSascha Wildner UINT32 Value,
14110d02842fSSascha Wildner UINT32 Width)
14120d02842fSSascha Wildner {
14130d02842fSSascha Wildner ACPI_FUNCTION_NAME (OsWritePort);
14140d02842fSSascha Wildner
14150d02842fSSascha Wildner
14160d02842fSSascha Wildner if ((Width == 8) || (Width == 16) || (Width == 32))
14170d02842fSSascha Wildner {
14180d02842fSSascha Wildner return (AE_OK);
14190d02842fSSascha Wildner }
14200d02842fSSascha Wildner
14210d02842fSSascha Wildner ACPI_ERROR ((AE_INFO, "Bad width parameter: %X", Width));
14220d02842fSSascha Wildner return (AE_BAD_PARAMETER);
14230d02842fSSascha Wildner }
14240d02842fSSascha Wildner
14250d02842fSSascha Wildner
14260d02842fSSascha Wildner /******************************************************************************
14270d02842fSSascha Wildner *
14280d02842fSSascha Wildner * FUNCTION: AcpiOsReadMemory
14290d02842fSSascha Wildner *
14300d02842fSSascha Wildner * PARAMETERS: Address - Physical Memory Address to read
14310d02842fSSascha Wildner * Value - Where value is placed
14320d02842fSSascha Wildner * Width - Number of bits (8,16,32, or 64)
14330d02842fSSascha Wildner *
14340d02842fSSascha Wildner * RETURN: Value read from physical memory address. Always returned
14350d02842fSSascha Wildner * as a 64-bit integer, regardless of the read width.
14360d02842fSSascha Wildner *
14370d02842fSSascha Wildner * DESCRIPTION: Read data from a physical memory address
14380d02842fSSascha Wildner *
14390d02842fSSascha Wildner *****************************************************************************/
14400d02842fSSascha Wildner
14410d02842fSSascha Wildner ACPI_STATUS
AcpiOsReadMemory(ACPI_PHYSICAL_ADDRESS Address,UINT64 * Value,UINT32 Width)14420d02842fSSascha Wildner AcpiOsReadMemory (
14430d02842fSSascha Wildner ACPI_PHYSICAL_ADDRESS Address,
14440d02842fSSascha Wildner UINT64 *Value,
14450d02842fSSascha Wildner UINT32 Width)
14460d02842fSSascha Wildner {
14470d02842fSSascha Wildner
14480d02842fSSascha Wildner switch (Width)
14490d02842fSSascha Wildner {
14500d02842fSSascha Wildner case 8:
14510d02842fSSascha Wildner case 16:
14520d02842fSSascha Wildner case 32:
14530d02842fSSascha Wildner case 64:
14540d02842fSSascha Wildner
14550d02842fSSascha Wildner *Value = 0;
14560d02842fSSascha Wildner break;
14570d02842fSSascha Wildner
14580d02842fSSascha Wildner default:
14590d02842fSSascha Wildner
14600d02842fSSascha Wildner return (AE_BAD_PARAMETER);
14610d02842fSSascha Wildner break;
14620d02842fSSascha Wildner }
14630d02842fSSascha Wildner
14640d02842fSSascha Wildner return (AE_OK);
14650d02842fSSascha Wildner }
14660d02842fSSascha Wildner
14670d02842fSSascha Wildner
14680d02842fSSascha Wildner /******************************************************************************
14690d02842fSSascha Wildner *
14700d02842fSSascha Wildner * FUNCTION: AcpiOsWriteMemory
14710d02842fSSascha Wildner *
14720d02842fSSascha Wildner * PARAMETERS: Address - Physical Memory Address to write
14730d02842fSSascha Wildner * Value - Value to write
14740d02842fSSascha Wildner * Width - Number of bits (8,16,32, or 64)
14750d02842fSSascha Wildner *
14760d02842fSSascha Wildner * RETURN: None
14770d02842fSSascha Wildner *
14780d02842fSSascha Wildner * DESCRIPTION: Write data to a physical memory address
14790d02842fSSascha Wildner *
14800d02842fSSascha Wildner *****************************************************************************/
14810d02842fSSascha Wildner
14820d02842fSSascha Wildner ACPI_STATUS
AcpiOsWriteMemory(ACPI_PHYSICAL_ADDRESS Address,UINT64 Value,UINT32 Width)14830d02842fSSascha Wildner AcpiOsWriteMemory (
14840d02842fSSascha Wildner ACPI_PHYSICAL_ADDRESS Address,
14850d02842fSSascha Wildner UINT64 Value,
14860d02842fSSascha Wildner UINT32 Width)
14870d02842fSSascha Wildner {
14880d02842fSSascha Wildner
14890d02842fSSascha Wildner return (AE_OK);
14900d02842fSSascha Wildner }
14910d02842fSSascha Wildner
14920d02842fSSascha Wildner
14930d02842fSSascha Wildner /******************************************************************************
14940d02842fSSascha Wildner *
14950d02842fSSascha Wildner * FUNCTION: AcpiOsSignal
14960d02842fSSascha Wildner *
14970d02842fSSascha Wildner * PARAMETERS: Function - ACPICA signal function code
14980d02842fSSascha Wildner * Info - Pointer to function-dependent structure
14990d02842fSSascha Wildner *
15000d02842fSSascha Wildner * RETURN: Status
15010d02842fSSascha Wildner *
15020d02842fSSascha Wildner * DESCRIPTION: Miscellaneous functions. Example implementation only.
15030d02842fSSascha Wildner *
15040d02842fSSascha Wildner *****************************************************************************/
15050d02842fSSascha Wildner
15060d02842fSSascha Wildner ACPI_STATUS
AcpiOsSignal(UINT32 Function,void * Info)15070d02842fSSascha Wildner AcpiOsSignal (
15080d02842fSSascha Wildner UINT32 Function,
15090d02842fSSascha Wildner void *Info)
15100d02842fSSascha Wildner {
15110d02842fSSascha Wildner
15120d02842fSSascha Wildner switch (Function)
15130d02842fSSascha Wildner {
15140d02842fSSascha Wildner case ACPI_SIGNAL_FATAL:
15150d02842fSSascha Wildner
15160d02842fSSascha Wildner break;
15170d02842fSSascha Wildner
15180d02842fSSascha Wildner case ACPI_SIGNAL_BREAKPOINT:
15190d02842fSSascha Wildner
15200d02842fSSascha Wildner break;
15210d02842fSSascha Wildner
15220d02842fSSascha Wildner default:
15230d02842fSSascha Wildner
15240d02842fSSascha Wildner break;
15250d02842fSSascha Wildner }
15260d02842fSSascha Wildner
15270d02842fSSascha Wildner return (AE_OK);
15280d02842fSSascha Wildner }
15290d02842fSSascha Wildner
15300d02842fSSascha Wildner
15310d02842fSSascha Wildner /******************************************************************************
15320d02842fSSascha Wildner *
15330d02842fSSascha Wildner * FUNCTION: Local cache interfaces
15340d02842fSSascha Wildner *
15350d02842fSSascha Wildner * DESCRIPTION: Implements cache interfaces via malloc/free for testing
15360d02842fSSascha Wildner * purposes only.
15370d02842fSSascha Wildner *
15380d02842fSSascha Wildner *****************************************************************************/
15390d02842fSSascha Wildner
15400d02842fSSascha Wildner #ifndef ACPI_USE_LOCAL_CACHE
15410d02842fSSascha Wildner
15420d02842fSSascha Wildner ACPI_STATUS
AcpiOsCreateCache(char * CacheName,UINT16 ObjectSize,UINT16 MaxDepth,ACPI_CACHE_T ** ReturnCache)15430d02842fSSascha Wildner AcpiOsCreateCache (
15440d02842fSSascha Wildner char *CacheName,
15450d02842fSSascha Wildner UINT16 ObjectSize,
15460d02842fSSascha Wildner UINT16 MaxDepth,
15470d02842fSSascha Wildner ACPI_CACHE_T **ReturnCache)
15480d02842fSSascha Wildner {
15490d02842fSSascha Wildner ACPI_MEMORY_LIST *NewCache;
15500d02842fSSascha Wildner
15510d02842fSSascha Wildner
15520d02842fSSascha Wildner NewCache = malloc (sizeof (ACPI_MEMORY_LIST));
15530d02842fSSascha Wildner if (!NewCache)
15540d02842fSSascha Wildner {
15550d02842fSSascha Wildner return (AE_NO_MEMORY);
15560d02842fSSascha Wildner }
15570d02842fSSascha Wildner
15580d02842fSSascha Wildner memset (NewCache, 0, sizeof (ACPI_MEMORY_LIST));
15590d02842fSSascha Wildner NewCache->ListName = CacheName;
15600d02842fSSascha Wildner NewCache->ObjectSize = ObjectSize;
15610d02842fSSascha Wildner NewCache->MaxDepth = MaxDepth;
15620d02842fSSascha Wildner
15630d02842fSSascha Wildner *ReturnCache = (ACPI_CACHE_T) NewCache;
15640d02842fSSascha Wildner return (AE_OK);
15650d02842fSSascha Wildner }
15660d02842fSSascha Wildner
15670d02842fSSascha Wildner ACPI_STATUS
AcpiOsDeleteCache(ACPI_CACHE_T * Cache)15680d02842fSSascha Wildner AcpiOsDeleteCache (
15690d02842fSSascha Wildner ACPI_CACHE_T *Cache)
15700d02842fSSascha Wildner {
15710d02842fSSascha Wildner free (Cache);
15720d02842fSSascha Wildner return (AE_OK);
15730d02842fSSascha Wildner }
15740d02842fSSascha Wildner
15750d02842fSSascha Wildner ACPI_STATUS
AcpiOsPurgeCache(ACPI_CACHE_T * Cache)15760d02842fSSascha Wildner AcpiOsPurgeCache (
15770d02842fSSascha Wildner ACPI_CACHE_T *Cache)
15780d02842fSSascha Wildner {
15790d02842fSSascha Wildner return (AE_OK);
15800d02842fSSascha Wildner }
15810d02842fSSascha Wildner
15820d02842fSSascha Wildner void *
AcpiOsAcquireObject(ACPI_CACHE_T * Cache)15830d02842fSSascha Wildner AcpiOsAcquireObject (
15840d02842fSSascha Wildner ACPI_CACHE_T *Cache)
15850d02842fSSascha Wildner {
15860d02842fSSascha Wildner void *NewObject;
15870d02842fSSascha Wildner
15880d02842fSSascha Wildner NewObject = malloc (((ACPI_MEMORY_LIST *) Cache)->ObjectSize);
15890d02842fSSascha Wildner memset (NewObject, 0, ((ACPI_MEMORY_LIST *) Cache)->ObjectSize);
15900d02842fSSascha Wildner
15910d02842fSSascha Wildner return (NewObject);
15920d02842fSSascha Wildner }
15930d02842fSSascha Wildner
15940d02842fSSascha Wildner ACPI_STATUS
AcpiOsReleaseObject(ACPI_CACHE_T * Cache,void * Object)15950d02842fSSascha Wildner AcpiOsReleaseObject (
15960d02842fSSascha Wildner ACPI_CACHE_T *Cache,
15970d02842fSSascha Wildner void *Object)
15980d02842fSSascha Wildner {
15990d02842fSSascha Wildner free (Object);
16000d02842fSSascha Wildner return (AE_OK);
16010d02842fSSascha Wildner }
16020d02842fSSascha Wildner
16030d02842fSSascha Wildner #endif /* ACPI_USE_LOCAL_CACHE */
16040d02842fSSascha Wildner
16050d02842fSSascha Wildner
16060d02842fSSascha Wildner /* Optional multi-thread support */
16070d02842fSSascha Wildner
16080d02842fSSascha Wildner #ifndef ACPI_SINGLE_THREADED
16090d02842fSSascha Wildner /******************************************************************************
16100d02842fSSascha Wildner *
16110d02842fSSascha Wildner * FUNCTION: AcpiOsGetThreadId
16120d02842fSSascha Wildner *
16130d02842fSSascha Wildner * PARAMETERS: None
16140d02842fSSascha Wildner *
16150d02842fSSascha Wildner * RETURN: Id of the running thread
16160d02842fSSascha Wildner *
16170d02842fSSascha Wildner * DESCRIPTION: Get the Id of the current (running) thread
16180d02842fSSascha Wildner *
16190d02842fSSascha Wildner *****************************************************************************/
16200d02842fSSascha Wildner
16210d02842fSSascha Wildner ACPI_THREAD_ID
AcpiOsGetThreadId(void)16220d02842fSSascha Wildner AcpiOsGetThreadId (
16230d02842fSSascha Wildner void)
16240d02842fSSascha Wildner {
16250d02842fSSascha Wildner DWORD ThreadId;
16260d02842fSSascha Wildner
16270d02842fSSascha Wildner /* Ensure ID is never 0 */
16280d02842fSSascha Wildner
16290d02842fSSascha Wildner ThreadId = GetCurrentThreadId ();
16300d02842fSSascha Wildner return ((ACPI_THREAD_ID) (ThreadId + 1));
16310d02842fSSascha Wildner }
16320d02842fSSascha Wildner
16330d02842fSSascha Wildner
16340d02842fSSascha Wildner /******************************************************************************
16350d02842fSSascha Wildner *
16360d02842fSSascha Wildner * FUNCTION: AcpiOsExecute
16370d02842fSSascha Wildner *
16380d02842fSSascha Wildner * PARAMETERS: Type - Type of execution
16390d02842fSSascha Wildner * Function - Address of the function to execute
16400d02842fSSascha Wildner * Context - Passed as a parameter to the function
16410d02842fSSascha Wildner *
16420d02842fSSascha Wildner * RETURN: Status
16430d02842fSSascha Wildner *
16440d02842fSSascha Wildner * DESCRIPTION: Execute a new thread
16450d02842fSSascha Wildner *
16460d02842fSSascha Wildner *****************************************************************************/
16470d02842fSSascha Wildner
16480d02842fSSascha Wildner ACPI_STATUS
AcpiOsExecute(ACPI_EXECUTE_TYPE Type,ACPI_OSD_EXEC_CALLBACK Function,void * Context)16490d02842fSSascha Wildner AcpiOsExecute (
16500d02842fSSascha Wildner ACPI_EXECUTE_TYPE Type,
16510d02842fSSascha Wildner ACPI_OSD_EXEC_CALLBACK Function,
16520d02842fSSascha Wildner void *Context)
16530d02842fSSascha Wildner {
16540d02842fSSascha Wildner
16550d02842fSSascha Wildner _beginthread (Function, (unsigned) 0, Context);
16560d02842fSSascha Wildner return (0);
16570d02842fSSascha Wildner }
16580d02842fSSascha Wildner
16595f39c7e7SSascha Wildner #else /* ACPI_SINGLE_THREADED */
16605f39c7e7SSascha Wildner ACPI_THREAD_ID
AcpiOsGetThreadId(void)16615f39c7e7SSascha Wildner AcpiOsGetThreadId (
16625f39c7e7SSascha Wildner void)
16635f39c7e7SSascha Wildner {
16645f39c7e7SSascha Wildner return (1);
16655f39c7e7SSascha Wildner }
16665f39c7e7SSascha Wildner
16675f39c7e7SSascha Wildner ACPI_STATUS
AcpiOsExecute(ACPI_EXECUTE_TYPE Type,ACPI_OSD_EXEC_CALLBACK Function,void * Context)16685f39c7e7SSascha Wildner AcpiOsExecute (
16695f39c7e7SSascha Wildner ACPI_EXECUTE_TYPE Type,
16705f39c7e7SSascha Wildner ACPI_OSD_EXEC_CALLBACK Function,
16715f39c7e7SSascha Wildner void *Context)
16725f39c7e7SSascha Wildner {
16735f39c7e7SSascha Wildner
16745f39c7e7SSascha Wildner Function (Context);
16755f39c7e7SSascha Wildner return (AE_OK);
16765f39c7e7SSascha Wildner }
16775f39c7e7SSascha Wildner
16780d02842fSSascha Wildner #endif /* ACPI_SINGLE_THREADED */
16790d02842fSSascha Wildner
16800d02842fSSascha Wildner
16810d02842fSSascha Wildner /******************************************************************************
16820d02842fSSascha Wildner *
16830d02842fSSascha Wildner * FUNCTION: AcpiOsWaitEventsComplete
16840d02842fSSascha Wildner *
16850d02842fSSascha Wildner * PARAMETERS: None
16860d02842fSSascha Wildner *
16870d02842fSSascha Wildner * RETURN: None
16880d02842fSSascha Wildner *
16890d02842fSSascha Wildner * DESCRIPTION: Wait for all asynchronous events to complete. This
16900d02842fSSascha Wildner * implementation does nothing.
16910d02842fSSascha Wildner *
16920d02842fSSascha Wildner *****************************************************************************/
16930d02842fSSascha Wildner
16940d02842fSSascha Wildner void
AcpiOsWaitEventsComplete(void)16950d02842fSSascha Wildner AcpiOsWaitEventsComplete (
16960d02842fSSascha Wildner void)
16970d02842fSSascha Wildner {
1698820c5b08SSascha Wildner
16990d02842fSSascha Wildner return;
17000d02842fSSascha Wildner }
1701