1/******************************************************************************
2 *
3 * Module Name: evxfevnt - External Interfaces, ACPI event disable/enable
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2023, 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
67ACPI_STATUS
68AcpiEnable (
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
116ACPI_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
131ACPI_STATUS
132AcpiDisable (
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
173ACPI_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
189ACPI_STATUS
190AcpiEnableEvent (
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
246ACPI_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
262ACPI_STATUS
263AcpiDisableEvent (
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
317ACPI_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
332ACPI_STATUS
333AcpiClearEvent (
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
367ACPI_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
384ACPI_STATUS
385AcpiGetEventStatus (
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
449ACPI_EXPORT_SYMBOL (AcpiGetEventStatus)
450
451#endif /* !ACPI_REDUCED_HARDWARE */
452