1 /******************************************************************************
2  *
3  * Module Name: evxfevnt - External Interfaces, ACPI event disable/enable
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2021, 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 MERCHANTABILITY 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
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 
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 
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     /* If Hardware Reduced flag is set, there are no fixed events */
202 
203     if (AcpiGbl_ReducedHardware)
204     {
205         return_ACPI_STATUS (AE_OK);
206     }
207 
208     /* Decode the Fixed Event */
209 
210     if (Event > ACPI_EVENT_MAX)
211     {
212         return_ACPI_STATUS (AE_BAD_PARAMETER);
213     }
214 
215     /*
216      * Enable the requested fixed event (by writing a one to the enable
217      * register bit)
218      */
219     Status = AcpiWriteBitRegister (
220         AcpiGbl_FixedEventInfo[Event].EnableRegisterId,
221         ACPI_ENABLE_EVENT);
222     if (ACPI_FAILURE (Status))
223     {
224         return_ACPI_STATUS (Status);
225     }
226 
227     /* Make sure that the hardware responded */
228 
229     Status = AcpiReadBitRegister (
230         AcpiGbl_FixedEventInfo[Event].EnableRegisterId, &Value);
231     if (ACPI_FAILURE (Status))
232     {
233         return_ACPI_STATUS (Status);
234     }
235 
236     if (Value != 1)
237     {
238         ACPI_ERROR ((AE_INFO,
239             "Could not enable %s event", AcpiUtGetEventName (Event)));
240         return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE);
241     }
242 
243     return_ACPI_STATUS (Status);
244 }
245 
246 ACPI_EXPORT_SYMBOL (AcpiEnableEvent)
247 
248 
249 /*******************************************************************************
250  *
251  * FUNCTION:    AcpiDisableEvent
252  *
253  * PARAMETERS:  Event           - The fixed event to be disabled
254  *              Flags           - Reserved
255  *
256  * RETURN:      Status
257  *
258  * DESCRIPTION: Disable an ACPI event (fixed)
259  *
260  ******************************************************************************/
261 
262 ACPI_STATUS
263 AcpiDisableEvent (
264     UINT32                  Event,
265     UINT32                  Flags)
266 {
267     ACPI_STATUS             Status = AE_OK;
268     UINT32                  Value;
269 
270 
271     ACPI_FUNCTION_TRACE (AcpiDisableEvent);
272 
273 
274     /* If Hardware Reduced flag is set, there are no fixed events */
275 
276     if (AcpiGbl_ReducedHardware)
277     {
278         return_ACPI_STATUS (AE_OK);
279     }
280 
281     /* Decode the Fixed Event */
282 
283     if (Event > ACPI_EVENT_MAX)
284     {
285         return_ACPI_STATUS (AE_BAD_PARAMETER);
286     }
287 
288     /*
289      * Disable the requested fixed event (by writing a zero to the enable
290      * register bit)
291      */
292     Status = AcpiWriteBitRegister (
293         AcpiGbl_FixedEventInfo[Event].EnableRegisterId,
294         ACPI_DISABLE_EVENT);
295     if (ACPI_FAILURE (Status))
296     {
297         return_ACPI_STATUS (Status);
298     }
299 
300     Status = AcpiReadBitRegister (
301         AcpiGbl_FixedEventInfo[Event].EnableRegisterId, &Value);
302     if (ACPI_FAILURE (Status))
303     {
304         return_ACPI_STATUS (Status);
305     }
306 
307     if (Value != 0)
308     {
309         ACPI_ERROR ((AE_INFO,
310             "Could not disable %s events", AcpiUtGetEventName (Event)));
311         return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE);
312     }
313 
314     return_ACPI_STATUS (Status);
315 }
316 
317 ACPI_EXPORT_SYMBOL (AcpiDisableEvent)
318 
319 
320 /*******************************************************************************
321  *
322  * FUNCTION:    AcpiClearEvent
323  *
324  * PARAMETERS:  Event           - The fixed event to be cleared
325  *
326  * RETURN:      Status
327  *
328  * DESCRIPTION: Clear an ACPI event (fixed)
329  *
330  ******************************************************************************/
331 
332 ACPI_STATUS
333 AcpiClearEvent (
334     UINT32                  Event)
335 {
336     ACPI_STATUS             Status = AE_OK;
337 
338 
339     ACPI_FUNCTION_TRACE (AcpiClearEvent);
340 
341 
342     /* If Hardware Reduced flag is set, there are no fixed events */
343 
344     if (AcpiGbl_ReducedHardware)
345     {
346         return_ACPI_STATUS (AE_OK);
347     }
348 
349     /* Decode the Fixed Event */
350 
351     if (Event > ACPI_EVENT_MAX)
352     {
353         return_ACPI_STATUS (AE_BAD_PARAMETER);
354     }
355 
356     /*
357      * Clear the requested fixed event (By writing a one to the status
358      * register bit)
359      */
360     Status = AcpiWriteBitRegister (
361         AcpiGbl_FixedEventInfo[Event].StatusRegisterId,
362         ACPI_CLEAR_STATUS);
363 
364     return_ACPI_STATUS (Status);
365 }
366 
367 ACPI_EXPORT_SYMBOL (AcpiClearEvent)
368 
369 
370 /*******************************************************************************
371  *
372  * FUNCTION:    AcpiGetEventStatus
373  *
374  * PARAMETERS:  Event           - The fixed event
375  *              EventStatus     - Where the current status of the event will
376  *                                be returned
377  *
378  * RETURN:      Status
379  *
380  * DESCRIPTION: Obtains and returns the current status of the event
381  *
382  ******************************************************************************/
383 
384 ACPI_STATUS
385 AcpiGetEventStatus (
386     UINT32                  Event,
387     ACPI_EVENT_STATUS       *EventStatus)
388 {
389     ACPI_STATUS             Status;
390     ACPI_EVENT_STATUS       LocalEventStatus = 0;
391     UINT32                  InByte;
392 
393 
394     ACPI_FUNCTION_TRACE (AcpiGetEventStatus);
395 
396 
397     if (!EventStatus)
398     {
399         return_ACPI_STATUS (AE_BAD_PARAMETER);
400     }
401 
402     /* Decode the Fixed Event */
403 
404     if (Event > ACPI_EVENT_MAX)
405     {
406         return_ACPI_STATUS (AE_BAD_PARAMETER);
407     }
408 
409     /* Fixed event currently can be dispatched? */
410 
411     if (AcpiGbl_FixedEventHandlers[Event].Handler)
412     {
413         LocalEventStatus |= ACPI_EVENT_FLAG_HAS_HANDLER;
414     }
415 
416     /* Fixed event currently enabled? */
417 
418     Status = AcpiReadBitRegister (
419         AcpiGbl_FixedEventInfo[Event].EnableRegisterId, &InByte);
420     if (ACPI_FAILURE (Status))
421     {
422         return_ACPI_STATUS (Status);
423     }
424 
425     if (InByte)
426     {
427         LocalEventStatus |=
428             (ACPI_EVENT_FLAG_ENABLED | ACPI_EVENT_FLAG_ENABLE_SET);
429     }
430 
431     /* Fixed event currently active? */
432 
433     Status = AcpiReadBitRegister (
434         AcpiGbl_FixedEventInfo[Event].StatusRegisterId, &InByte);
435     if (ACPI_FAILURE (Status))
436     {
437         return_ACPI_STATUS (Status);
438     }
439 
440     if (InByte)
441     {
442         LocalEventStatus |= ACPI_EVENT_FLAG_STATUS_SET;
443     }
444 
445     (*EventStatus) = LocalEventStatus;
446     return_ACPI_STATUS (AE_OK);
447 }
448 
449 ACPI_EXPORT_SYMBOL (AcpiGetEventStatus)
450 
451 #endif /* !ACPI_REDUCED_HARDWARE */
452