xref: /titanic_41/usr/src/uts/intel/io/acpica/events/evxfevnt.c (revision de5d74c22760a6d2cefd94d0e7f0fd87214fb71f)
1 /******************************************************************************
2  *
3  * Module Name: evxfevnt - External Interfaces, ACPI event disable/enable
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2016, Intel Corp.
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43 
44 #define EXPORT_ACPI_INTERFACES
45 
46 #include "acpi.h"
47 #include "accommon.h"
48 #include "actables.h"
49 
50 #define _COMPONENT          ACPI_EVENTS
51         ACPI_MODULE_NAME    ("evxfevnt")
52 
53 
54 #if (!ACPI_REDUCED_HARDWARE) /* Entire module */
55 /*******************************************************************************
56  *
57  * FUNCTION:    AcpiEnable
58  *
59  * PARAMETERS:  None
60  *
61  * RETURN:      Status
62  *
63  * DESCRIPTION: Transfers the system into ACPI mode.
64  *
65  ******************************************************************************/
66 
67 ACPI_STATUS
AcpiEnable(void)68 AcpiEnable (
69     void)
70 {
71     ACPI_STATUS             Status = AE_OK;
72 
73 
74     ACPI_FUNCTION_TRACE (AcpiEnable);
75 
76 
77     /* ACPI tables must be present */
78 
79     if (AcpiGbl_FadtIndex == ACPI_INVALID_TABLE_INDEX)
80     {
81         return_ACPI_STATUS (AE_NO_ACPI_TABLES);
82     }
83 
84     /* If the Hardware Reduced flag is set, machine is always in acpi mode */
85 
86     if (AcpiGbl_ReducedHardware)
87     {
88         return_ACPI_STATUS (AE_OK);
89     }
90 
91     /* Check current mode */
92 
93     if (AcpiHwGetMode() == ACPI_SYS_MODE_ACPI)
94     {
95         ACPI_DEBUG_PRINT ((ACPI_DB_INIT,
96             "System is already in ACPI mode\n"));
97     }
98     else
99     {
100         /* Transition to ACPI mode */
101 
102         Status = AcpiHwSetMode (ACPI_SYS_MODE_ACPI);
103         if (ACPI_FAILURE (Status))
104         {
105             ACPI_ERROR ((AE_INFO, "Could not transition to ACPI mode"));
106             return_ACPI_STATUS (Status);
107         }
108 
109         ACPI_DEBUG_PRINT ((ACPI_DB_INIT,
110             "Transition to ACPI mode successful\n"));
111     }
112 
113     return_ACPI_STATUS (Status);
114 }
115 
ACPI_EXPORT_SYMBOL(AcpiEnable)116 ACPI_EXPORT_SYMBOL (AcpiEnable)
117 
118 
119 /*******************************************************************************
120  *
121  * FUNCTION:    AcpiDisable
122  *
123  * PARAMETERS:  None
124  *
125  * RETURN:      Status
126  *
127  * DESCRIPTION: Transfers the system into LEGACY (non-ACPI) mode.
128  *
129  ******************************************************************************/
130 
131 ACPI_STATUS
132 AcpiDisable (
133     void)
134 {
135     ACPI_STATUS             Status = AE_OK;
136 
137 
138     ACPI_FUNCTION_TRACE (AcpiDisable);
139 
140 
141     /* If the Hardware Reduced flag is set, machine is always in acpi mode */
142 
143     if (AcpiGbl_ReducedHardware)
144     {
145         return_ACPI_STATUS (AE_OK);
146     }
147 
148     if (AcpiHwGetMode() == ACPI_SYS_MODE_LEGACY)
149     {
150         ACPI_DEBUG_PRINT ((ACPI_DB_INIT,
151             "System is already in legacy (non-ACPI) mode\n"));
152     }
153     else
154     {
155         /* Transition to LEGACY mode */
156 
157         Status = AcpiHwSetMode (ACPI_SYS_MODE_LEGACY);
158 
159         if (ACPI_FAILURE (Status))
160         {
161             ACPI_ERROR ((AE_INFO,
162                 "Could not exit ACPI mode to legacy mode"));
163             return_ACPI_STATUS (Status);
164         }
165 
166         ACPI_DEBUG_PRINT ((ACPI_DB_INIT,
167             "ACPI mode disabled\n"));
168     }
169 
170     return_ACPI_STATUS (Status);
171 }
172 
ACPI_EXPORT_SYMBOL(AcpiDisable)173 ACPI_EXPORT_SYMBOL (AcpiDisable)
174 
175 
176 /*******************************************************************************
177  *
178  * FUNCTION:    AcpiEnableEvent
179  *
180  * PARAMETERS:  Event           - The fixed eventto be enabled
181  *              Flags           - Reserved
182  *
183  * RETURN:      Status
184  *
185  * DESCRIPTION: Enable an ACPI event (fixed)
186  *
187  ******************************************************************************/
188 
189 ACPI_STATUS
190 AcpiEnableEvent (
191     UINT32                  Event,
192     UINT32                  Flags)
193 {
194     ACPI_STATUS             Status = AE_OK;
195     UINT32                  Value;
196 
197 
198     ACPI_FUNCTION_TRACE (AcpiEnableEvent);
199 
200 
201     /* Decode the Fixed Event */
202 
203     if (Event > ACPI_EVENT_MAX)
204     {
205         return_ACPI_STATUS (AE_BAD_PARAMETER);
206     }
207 
208     /*
209      * Enable the requested fixed event (by writing a one to the enable
210      * register bit)
211      */
212     Status = AcpiWriteBitRegister (
213         AcpiGbl_FixedEventInfo[Event].EnableRegisterId,
214         ACPI_ENABLE_EVENT);
215     if (ACPI_FAILURE (Status))
216     {
217         return_ACPI_STATUS (Status);
218     }
219 
220     /* Make sure that the hardware responded */
221 
222     Status = AcpiReadBitRegister (
223         AcpiGbl_FixedEventInfo[Event].EnableRegisterId, &Value);
224     if (ACPI_FAILURE (Status))
225     {
226         return_ACPI_STATUS (Status);
227     }
228 
229     if (Value != 1)
230     {
231         ACPI_ERROR ((AE_INFO,
232             "Could not enable %s event", AcpiUtGetEventName (Event)));
233         return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE);
234     }
235 
236     return_ACPI_STATUS (Status);
237 }
238 
ACPI_EXPORT_SYMBOL(AcpiEnableEvent)239 ACPI_EXPORT_SYMBOL (AcpiEnableEvent)
240 
241 
242 /*******************************************************************************
243  *
244  * FUNCTION:    AcpiDisableEvent
245  *
246  * PARAMETERS:  Event           - The fixed event to be disabled
247  *              Flags           - Reserved
248  *
249  * RETURN:      Status
250  *
251  * DESCRIPTION: Disable an ACPI event (fixed)
252  *
253  ******************************************************************************/
254 
255 ACPI_STATUS
256 AcpiDisableEvent (
257     UINT32                  Event,
258     UINT32                  Flags)
259 {
260     ACPI_STATUS             Status = AE_OK;
261     UINT32                  Value;
262 
263 
264     ACPI_FUNCTION_TRACE (AcpiDisableEvent);
265 
266 
267     /* Decode the Fixed Event */
268 
269     if (Event > ACPI_EVENT_MAX)
270     {
271         return_ACPI_STATUS (AE_BAD_PARAMETER);
272     }
273 
274     /*
275      * Disable the requested fixed event (by writing a zero to the enable
276      * register bit)
277      */
278     Status = AcpiWriteBitRegister (
279         AcpiGbl_FixedEventInfo[Event].EnableRegisterId,
280         ACPI_DISABLE_EVENT);
281     if (ACPI_FAILURE (Status))
282     {
283         return_ACPI_STATUS (Status);
284     }
285 
286     Status = AcpiReadBitRegister (
287         AcpiGbl_FixedEventInfo[Event].EnableRegisterId, &Value);
288     if (ACPI_FAILURE (Status))
289     {
290         return_ACPI_STATUS (Status);
291     }
292 
293     if (Value != 0)
294     {
295         ACPI_ERROR ((AE_INFO,
296             "Could not disable %s events", AcpiUtGetEventName (Event)));
297         return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE);
298     }
299 
300     return_ACPI_STATUS (Status);
301 }
302 
ACPI_EXPORT_SYMBOL(AcpiDisableEvent)303 ACPI_EXPORT_SYMBOL (AcpiDisableEvent)
304 
305 
306 /*******************************************************************************
307  *
308  * FUNCTION:    AcpiClearEvent
309  *
310  * PARAMETERS:  Event           - The fixed event to be cleared
311  *
312  * RETURN:      Status
313  *
314  * DESCRIPTION: Clear an ACPI event (fixed)
315  *
316  ******************************************************************************/
317 
318 ACPI_STATUS
319 AcpiClearEvent (
320     UINT32                  Event)
321 {
322     ACPI_STATUS             Status = AE_OK;
323 
324 
325     ACPI_FUNCTION_TRACE (AcpiClearEvent);
326 
327 
328     /* Decode the Fixed Event */
329 
330     if (Event > ACPI_EVENT_MAX)
331     {
332         return_ACPI_STATUS (AE_BAD_PARAMETER);
333     }
334 
335     /*
336      * Clear the requested fixed event (By writing a one to the status
337      * register bit)
338      */
339     Status = AcpiWriteBitRegister (
340         AcpiGbl_FixedEventInfo[Event].StatusRegisterId,
341         ACPI_CLEAR_STATUS);
342 
343     return_ACPI_STATUS (Status);
344 }
345 
ACPI_EXPORT_SYMBOL(AcpiClearEvent)346 ACPI_EXPORT_SYMBOL (AcpiClearEvent)
347 
348 
349 /*******************************************************************************
350  *
351  * FUNCTION:    AcpiGetEventStatus
352  *
353  * PARAMETERS:  Event           - The fixed event
354  *              EventStatus     - Where the current status of the event will
355  *                                be returned
356  *
357  * RETURN:      Status
358  *
359  * DESCRIPTION: Obtains and returns the current status of the event
360  *
361  ******************************************************************************/
362 
363 ACPI_STATUS
364 AcpiGetEventStatus (
365     UINT32                  Event,
366     ACPI_EVENT_STATUS       *EventStatus)
367 {
368     ACPI_STATUS             Status;
369     ACPI_EVENT_STATUS       LocalEventStatus = 0;
370     UINT32                  InByte;
371 
372 
373     ACPI_FUNCTION_TRACE (AcpiGetEventStatus);
374 
375 
376     if (!EventStatus)
377     {
378         return_ACPI_STATUS (AE_BAD_PARAMETER);
379     }
380 
381     /* Decode the Fixed Event */
382 
383     if (Event > ACPI_EVENT_MAX)
384     {
385         return_ACPI_STATUS (AE_BAD_PARAMETER);
386     }
387 
388     /* Fixed event currently can be dispatched? */
389 
390     if (AcpiGbl_FixedEventHandlers[Event].Handler)
391     {
392         LocalEventStatus |= ACPI_EVENT_FLAG_HAS_HANDLER;
393     }
394 
395     /* Fixed event currently enabled? */
396 
397     Status = AcpiReadBitRegister (
398         AcpiGbl_FixedEventInfo[Event].EnableRegisterId, &InByte);
399     if (ACPI_FAILURE (Status))
400     {
401         return_ACPI_STATUS (Status);
402     }
403 
404     if (InByte)
405     {
406         LocalEventStatus |=
407             (ACPI_EVENT_FLAG_ENABLED | ACPI_EVENT_FLAG_ENABLE_SET);
408     }
409 
410     /* Fixed event currently active? */
411 
412     Status = AcpiReadBitRegister (
413         AcpiGbl_FixedEventInfo[Event].StatusRegisterId, &InByte);
414     if (ACPI_FAILURE (Status))
415     {
416         return_ACPI_STATUS (Status);
417     }
418 
419     if (InByte)
420     {
421         LocalEventStatus |= ACPI_EVENT_FLAG_STATUS_SET;
422     }
423 
424     (*EventStatus) = LocalEventStatus;
425     return_ACPI_STATUS (AE_OK);
426 }
427 
428 ACPI_EXPORT_SYMBOL (AcpiGetEventStatus)
429 
430 #endif /* !ACPI_REDUCED_HARDWARE */
431