exsystem.c revision 225736 
1
2/******************************************************************************
3 *
4 * Module Name: exsystem - Interface to OS services
5 *
6 *****************************************************************************/
7
8/*
9 * Copyright (C) 2000 - 2011, Intel Corp.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 *    notice, this list of conditions, and the following disclaimer,
17 *    without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 *    substantially similar to the "NO WARRANTY" disclaimer below
20 *    ("Disclaimer") and any redistribution must be conditioned upon
21 *    including a substantially similar Disclaimer requirement for further
22 *    binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 *    of any contributors may be used to endorse or promote products derived
25 *    from this software without specific prior written permission.
26 *
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
30 *
31 * NO WARRANTY
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
43 */
44
45#define __EXSYSTEM_C__
46
47#include <contrib/dev/acpica/include/acpi.h>
48#include <contrib/dev/acpica/include/accommon.h>
49#include <contrib/dev/acpica/include/acinterp.h>
50
51#define _COMPONENT          ACPI_EXECUTER
52        ACPI_MODULE_NAME    ("exsystem")
53
54
55/*******************************************************************************
56 *
57 * FUNCTION:    AcpiExSystemWaitSemaphore
58 *
59 * PARAMETERS:  Semaphore       - Semaphore to wait on
60 *              Timeout         - Max time to wait
61 *
62 * RETURN:      Status
63 *
64 * DESCRIPTION: Implements a semaphore wait with a check to see if the
65 *              semaphore is available immediately.  If it is not, the
66 *              interpreter is released before waiting.
67 *
68 ******************************************************************************/
69
70ACPI_STATUS
71AcpiExSystemWaitSemaphore (
72    ACPI_SEMAPHORE          Semaphore,
73    UINT16                  Timeout)
74{
75    ACPI_STATUS             Status;
76
77
78    ACPI_FUNCTION_TRACE (ExSystemWaitSemaphore);
79
80
81    Status = AcpiOsWaitSemaphore (Semaphore, 1, ACPI_DO_NOT_WAIT);
82    if (ACPI_SUCCESS (Status))
83    {
84        return_ACPI_STATUS (Status);
85    }
86
87    if (Status == AE_TIME)
88    {
89        /* We must wait, so unlock the interpreter */
90
91        AcpiExRelinquishInterpreter ();
92
93        Status = AcpiOsWaitSemaphore (Semaphore, 1, Timeout);
94
95        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
96            "*** Thread awake after blocking, %s\n",
97            AcpiFormatException (Status)));
98
99        /* Reacquire the interpreter */
100
101       AcpiExReacquireInterpreter ();
102    }
103
104    return_ACPI_STATUS (Status);
105}
106
107
108/*******************************************************************************
109 *
110 * FUNCTION:    AcpiExSystemWaitMutex
111 *
112 * PARAMETERS:  Mutex           - Mutex to wait on
113 *              Timeout         - Max time to wait
114 *
115 * RETURN:      Status
116 *
117 * DESCRIPTION: Implements a mutex wait with a check to see if the
118 *              mutex is available immediately.  If it is not, the
119 *              interpreter is released before waiting.
120 *
121 ******************************************************************************/
122
123ACPI_STATUS
124AcpiExSystemWaitMutex (
125    ACPI_MUTEX              Mutex,
126    UINT16                  Timeout)
127{
128    ACPI_STATUS             Status;
129
130
131    ACPI_FUNCTION_TRACE (ExSystemWaitMutex);
132
133
134    Status = AcpiOsAcquireMutex (Mutex, ACPI_DO_NOT_WAIT);
135    if (ACPI_SUCCESS (Status))
136    {
137        return_ACPI_STATUS (Status);
138    }
139
140    if (Status == AE_TIME)
141    {
142        /* We must wait, so unlock the interpreter */
143
144        AcpiExRelinquishInterpreter ();
145
146        Status = AcpiOsAcquireMutex (Mutex, Timeout);
147
148        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
149            "*** Thread awake after blocking, %s\n",
150            AcpiFormatException (Status)));
151
152        /* Reacquire the interpreter */
153
154        AcpiExReacquireInterpreter ();
155    }
156
157    return_ACPI_STATUS (Status);
158}
159
160
161/*******************************************************************************
162 *
163 * FUNCTION:    AcpiExSystemDoStall
164 *
165 * PARAMETERS:  HowLong         - The amount of time to stall,
166 *                                in microseconds
167 *
168 * RETURN:      Status
169 *
170 * DESCRIPTION: Suspend running thread for specified amount of time.
171 *              Note: ACPI specification requires that Stall() does not
172 *              relinquish the processor, and delays longer than 100 usec
173 *              should use Sleep() instead.  We allow stalls up to 255 usec
174 *              for compatibility with other interpreters and existing BIOSs.
175 *
176 ******************************************************************************/
177
178ACPI_STATUS
179AcpiExSystemDoStall (
180    UINT32                  HowLong)
181{
182    ACPI_STATUS             Status = AE_OK;
183
184
185    ACPI_FUNCTION_ENTRY ();
186
187
188    if (HowLong > 255) /* 255 microseconds */
189    {
190        /*
191         * Longer than 255 usec, this is an error
192         *
193         * (ACPI specifies 100 usec as max, but this gives some slack in
194         * order to support existing BIOSs)
195         */
196        ACPI_ERROR ((AE_INFO, "Time parameter is too large (%u)",
197            HowLong));
198        Status = AE_AML_OPERAND_VALUE;
199    }
200    else
201    {
202        AcpiOsStall (HowLong);
203    }
204
205    return (Status);
206}
207
208
209/*******************************************************************************
210 *
211 * FUNCTION:    AcpiExSystemDoSleep
212 *
213 * PARAMETERS:  HowLong         - The amount of time to sleep,
214 *                                in milliseconds
215 *
216 * RETURN:      None
217 *
218 * DESCRIPTION: Sleep the running thread for specified amount of time.
219 *
220 ******************************************************************************/
221
222ACPI_STATUS
223AcpiExSystemDoSleep (
224    UINT64                  HowLong)
225{
226    ACPI_FUNCTION_ENTRY ();
227
228
229    /* Since this thread will sleep, we must release the interpreter */
230
231    AcpiExRelinquishInterpreter ();
232
233    /*
234     * For compatibility with other ACPI implementations and to prevent
235     * accidental deep sleeps, limit the sleep time to something reasonable.
236     */
237    if (HowLong > ACPI_MAX_SLEEP)
238    {
239        HowLong = ACPI_MAX_SLEEP;
240    }
241
242    AcpiOsSleep (HowLong);
243
244    /* And now we must get the interpreter again */
245
246    AcpiExReacquireInterpreter ();
247    return (AE_OK);
248}
249
250
251/*******************************************************************************
252 *
253 * FUNCTION:    AcpiExSystemSignalEvent
254 *
255 * PARAMETERS:  ObjDesc         - The object descriptor for this op
256 *
257 * RETURN:      Status
258 *
259 * DESCRIPTION: Provides an access point to perform synchronization operations
260 *              within the AML.
261 *
262 ******************************************************************************/
263
264ACPI_STATUS
265AcpiExSystemSignalEvent (
266    ACPI_OPERAND_OBJECT     *ObjDesc)
267{
268    ACPI_STATUS             Status = AE_OK;
269
270
271    ACPI_FUNCTION_TRACE (ExSystemSignalEvent);
272
273
274    if (ObjDesc)
275    {
276        Status = AcpiOsSignalSemaphore (ObjDesc->Event.OsSemaphore, 1);
277    }
278
279    return_ACPI_STATUS (Status);
280}
281
282
283/*******************************************************************************
284 *
285 * FUNCTION:    AcpiExSystemWaitEvent
286 *
287 * PARAMETERS:  TimeDesc        - The 'time to delay' object descriptor
288 *              ObjDesc         - The object descriptor for this op
289 *
290 * RETURN:      Status
291 *
292 * DESCRIPTION: Provides an access point to perform synchronization operations
293 *              within the AML.  This operation is a request to wait for an
294 *              event.
295 *
296 ******************************************************************************/
297
298ACPI_STATUS
299AcpiExSystemWaitEvent (
300    ACPI_OPERAND_OBJECT     *TimeDesc,
301    ACPI_OPERAND_OBJECT     *ObjDesc)
302{
303    ACPI_STATUS             Status = AE_OK;
304
305
306    ACPI_FUNCTION_TRACE (ExSystemWaitEvent);
307
308
309    if (ObjDesc)
310    {
311        Status = AcpiExSystemWaitSemaphore (ObjDesc->Event.OsSemaphore,
312                    (UINT16) TimeDesc->Integer.Value);
313    }
314
315    return_ACPI_STATUS (Status);
316}
317
318
319/*******************************************************************************
320 *
321 * FUNCTION:    AcpiExSystemResetEvent
322 *
323 * PARAMETERS:  ObjDesc         - The object descriptor for this op
324 *
325 * RETURN:      Status
326 *
327 * DESCRIPTION: Reset an event to a known state.
328 *
329 ******************************************************************************/
330
331ACPI_STATUS
332AcpiExSystemResetEvent (
333    ACPI_OPERAND_OBJECT     *ObjDesc)
334{
335    ACPI_STATUS             Status = AE_OK;
336    ACPI_SEMAPHORE          TempSemaphore;
337
338
339    ACPI_FUNCTION_ENTRY ();
340
341
342    /*
343     * We are going to simply delete the existing semaphore and
344     * create a new one!
345     */
346    Status = AcpiOsCreateSemaphore (ACPI_NO_UNIT_LIMIT, 0, &TempSemaphore);
347    if (ACPI_SUCCESS (Status))
348    {
349        (void) AcpiOsDeleteSemaphore (ObjDesc->Event.OsSemaphore);
350        ObjDesc->Event.OsSemaphore = TempSemaphore;
351    }
352
353    return (Status);
354}
355
356