1 /******************************************************************************
2  *
3  * Module Name: hwgpe - Low level GPE enable/disable/clear functions
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2015, 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 #include "acpi.h"
45 #include "accommon.h"
46 #include "acevents.h"
47 
48 #define _COMPONENT          ACPI_HARDWARE
49         ACPI_MODULE_NAME    ("hwgpe")
50 
51 #if (!ACPI_REDUCED_HARDWARE) /* Entire module */
52 
53 /* Local prototypes */
54 
55 static ACPI_STATUS
56 AcpiHwEnableWakeupGpeBlock (
57     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
58     ACPI_GPE_BLOCK_INFO     *GpeBlock,
59     void                    *Context);
60 
61 static ACPI_STATUS
62 AcpiHwGpeEnableWrite (
63     UINT8                   EnableMask,
64     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo);
65 
66 
67 /******************************************************************************
68  *
69  * FUNCTION:    AcpiHwGetGpeRegisterBit
70  *
71  * PARAMETERS:  GpeEventInfo        - Info block for the GPE
72  *
73  * RETURN:      Register mask with a one in the GPE bit position
74  *
75  * DESCRIPTION: Compute the register mask for this GPE. One bit is set in the
76  *              correct position for the input GPE.
77  *
78  ******************************************************************************/
79 
80 UINT32
81 AcpiHwGetGpeRegisterBit (
82     ACPI_GPE_EVENT_INFO     *GpeEventInfo)
83 {
84 
85     return ((UINT32) 1 <<
86         (GpeEventInfo->GpeNumber - GpeEventInfo->RegisterInfo->BaseGpeNumber));
87 }
88 
89 
90 /******************************************************************************
91  *
92  * FUNCTION:    AcpiHwLowSetGpe
93  *
94  * PARAMETERS:  GpeEventInfo        - Info block for the GPE to be disabled
95  *              Action              - Enable or disable
96  *
97  * RETURN:      Status
98  *
99  * DESCRIPTION: Enable or disable a single GPE in the parent enable register.
100  *              The EnableMask field of the involved GPE register must be
101  *              updated by the caller if necessary.
102  *
103  ******************************************************************************/
104 
105 ACPI_STATUS
106 AcpiHwLowSetGpe (
107     ACPI_GPE_EVENT_INFO     *GpeEventInfo,
108     UINT32                  Action)
109 {
110     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
111     ACPI_STATUS             Status;
112     UINT32                  EnableMask;
113     UINT32                  RegisterBit;
114 
115 
116     ACPI_FUNCTION_ENTRY ();
117 
118 
119     /* Get the info block for the entire GPE register */
120 
121     GpeRegisterInfo = GpeEventInfo->RegisterInfo;
122     if (!GpeRegisterInfo)
123     {
124         return (AE_NOT_EXIST);
125     }
126 
127     /* Get current value of the enable register that contains this GPE */
128 
129     Status = AcpiHwRead (&EnableMask, &GpeRegisterInfo->EnableAddress);
130     if (ACPI_FAILURE (Status))
131     {
132         return (Status);
133     }
134 
135     /* Set or clear just the bit that corresponds to this GPE */
136 
137     RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
138     switch (Action)
139     {
140     case ACPI_GPE_CONDITIONAL_ENABLE:
141 
142         /* Only enable if the corresponding EnableMask bit is set */
143 
144         if (!(RegisterBit & GpeRegisterInfo->EnableMask))
145         {
146             return (AE_BAD_PARAMETER);
147         }
148 
149         /*lint -fallthrough */
150 
151     case ACPI_GPE_ENABLE:
152 
153         ACPI_SET_BIT (EnableMask, RegisterBit);
154         break;
155 
156     case ACPI_GPE_DISABLE:
157 
158         ACPI_CLEAR_BIT (EnableMask, RegisterBit);
159         break;
160 
161     default:
162 
163         ACPI_ERROR ((AE_INFO, "Invalid GPE Action, %u", Action));
164         return (AE_BAD_PARAMETER);
165     }
166 
167     /* Write the updated enable mask */
168 
169     Status = AcpiHwWrite (EnableMask, &GpeRegisterInfo->EnableAddress);
170     return (Status);
171 }
172 
173 
174 /******************************************************************************
175  *
176  * FUNCTION:    AcpiHwClearGpe
177  *
178  * PARAMETERS:  GpeEventInfo        - Info block for the GPE to be cleared
179  *
180  * RETURN:      Status
181  *
182  * DESCRIPTION: Clear the status bit for a single GPE.
183  *
184  ******************************************************************************/
185 
186 ACPI_STATUS
187 AcpiHwClearGpe (
188     ACPI_GPE_EVENT_INFO     *GpeEventInfo)
189 {
190     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
191     ACPI_STATUS             Status;
192     UINT32                  RegisterBit;
193 
194 
195     ACPI_FUNCTION_ENTRY ();
196 
197     /* Get the info block for the entire GPE register */
198 
199     GpeRegisterInfo = GpeEventInfo->RegisterInfo;
200     if (!GpeRegisterInfo)
201     {
202         return (AE_NOT_EXIST);
203     }
204 
205     /*
206      * Write a one to the appropriate bit in the status register to
207      * clear this GPE.
208      */
209     RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
210 
211     Status = AcpiHwWrite (RegisterBit,
212                     &GpeRegisterInfo->StatusAddress);
213 
214     return (Status);
215 }
216 
217 
218 /******************************************************************************
219  *
220  * FUNCTION:    AcpiHwGetGpeStatus
221  *
222  * PARAMETERS:  GpeEventInfo        - Info block for the GPE to queried
223  *              EventStatus         - Where the GPE status is returned
224  *
225  * RETURN:      Status
226  *
227  * DESCRIPTION: Return the status of a single GPE.
228  *
229  ******************************************************************************/
230 
231 ACPI_STATUS
232 AcpiHwGetGpeStatus (
233     ACPI_GPE_EVENT_INFO     *GpeEventInfo,
234     ACPI_EVENT_STATUS       *EventStatus)
235 {
236     UINT32                  InByte;
237     UINT32                  RegisterBit;
238     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
239     ACPI_EVENT_STATUS       LocalEventStatus = 0;
240     ACPI_STATUS             Status;
241 
242 
243     ACPI_FUNCTION_ENTRY ();
244 
245 
246     if (!EventStatus)
247     {
248         return (AE_BAD_PARAMETER);
249     }
250 
251     /* GPE currently handled? */
252 
253     if (ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags) !=
254             ACPI_GPE_DISPATCH_NONE)
255     {
256         LocalEventStatus |= ACPI_EVENT_FLAG_HAS_HANDLER;
257     }
258 
259     /* Get the info block for the entire GPE register */
260 
261     GpeRegisterInfo = GpeEventInfo->RegisterInfo;
262 
263     /* Get the register bitmask for this GPE */
264 
265     RegisterBit = AcpiHwGetGpeRegisterBit (GpeEventInfo);
266 
267     /* GPE currently enabled? (enabled for runtime?) */
268 
269     if (RegisterBit & GpeRegisterInfo->EnableForRun)
270     {
271         LocalEventStatus |= ACPI_EVENT_FLAG_ENABLED;
272     }
273 
274     /* GPE enabled for wake? */
275 
276     if (RegisterBit & GpeRegisterInfo->EnableForWake)
277     {
278         LocalEventStatus |= ACPI_EVENT_FLAG_WAKE_ENABLED;
279     }
280 
281     /* GPE currently enabled (enable bit == 1)? */
282 
283     Status = AcpiHwRead (&InByte, &GpeRegisterInfo->EnableAddress);
284     if (ACPI_FAILURE (Status))
285     {
286         return (Status);
287     }
288 
289     if (RegisterBit & InByte)
290     {
291         LocalEventStatus |= ACPI_EVENT_FLAG_ENABLE_SET;
292     }
293 
294     /* GPE currently active (status bit == 1)? */
295 
296     Status = AcpiHwRead (&InByte, &GpeRegisterInfo->StatusAddress);
297     if (ACPI_FAILURE (Status))
298     {
299         return (Status);
300     }
301 
302     if (RegisterBit & InByte)
303     {
304         LocalEventStatus |= ACPI_EVENT_FLAG_STATUS_SET;
305     }
306 
307     /* Set return value */
308 
309     (*EventStatus) = LocalEventStatus;
310     return (AE_OK);
311 }
312 
313 
314 /******************************************************************************
315  *
316  * FUNCTION:    AcpiHwGpeEnableWrite
317  *
318  * PARAMETERS:  EnableMask          - Bit mask to write to the GPE register
319  *              GpeRegisterInfo     - Gpe Register info
320  *
321  * RETURN:      Status
322  *
323  * DESCRIPTION: Write the enable mask byte to the given GPE register.
324  *
325  ******************************************************************************/
326 
327 static ACPI_STATUS
328 AcpiHwGpeEnableWrite (
329     UINT8                   EnableMask,
330     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo)
331 {
332     ACPI_STATUS             Status;
333 
334 
335     GpeRegisterInfo->EnableMask = EnableMask;
336     Status = AcpiHwWrite (EnableMask, &GpeRegisterInfo->EnableAddress);
337 
338     return (Status);
339 }
340 
341 
342 /******************************************************************************
343  *
344  * FUNCTION:    AcpiHwDisableGpeBlock
345  *
346  * PARAMETERS:  GpeXruptInfo        - GPE Interrupt info
347  *              GpeBlock            - Gpe Block info
348  *
349  * RETURN:      Status
350  *
351  * DESCRIPTION: Disable all GPEs within a single GPE block
352  *
353  ******************************************************************************/
354 
355 ACPI_STATUS
356 AcpiHwDisableGpeBlock (
357     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
358     ACPI_GPE_BLOCK_INFO     *GpeBlock,
359     void                    *Context)
360 {
361     UINT32                  i;
362     ACPI_STATUS             Status;
363 
364 
365     /* Examine each GPE Register within the block */
366 
367     for (i = 0; i < GpeBlock->RegisterCount; i++)
368     {
369         /* Disable all GPEs in this register */
370 
371         Status = AcpiHwGpeEnableWrite (0x00, &GpeBlock->RegisterInfo[i]);
372         if (ACPI_FAILURE (Status))
373         {
374             return (Status);
375         }
376     }
377 
378     return (AE_OK);
379 }
380 
381 
382 /******************************************************************************
383  *
384  * FUNCTION:    AcpiHwClearGpeBlock
385  *
386  * PARAMETERS:  GpeXruptInfo        - GPE Interrupt info
387  *              GpeBlock            - Gpe Block info
388  *
389  * RETURN:      Status
390  *
391  * DESCRIPTION: Clear status bits for all GPEs within a single GPE block
392  *
393  ******************************************************************************/
394 
395 ACPI_STATUS
396 AcpiHwClearGpeBlock (
397     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
398     ACPI_GPE_BLOCK_INFO     *GpeBlock,
399     void                    *Context)
400 {
401     UINT32                  i;
402     ACPI_STATUS             Status;
403 
404 
405     /* Examine each GPE Register within the block */
406 
407     for (i = 0; i < GpeBlock->RegisterCount; i++)
408     {
409         /* Clear status on all GPEs in this register */
410 
411         Status = AcpiHwWrite (0xFF, &GpeBlock->RegisterInfo[i].StatusAddress);
412         if (ACPI_FAILURE (Status))
413         {
414             return (Status);
415         }
416     }
417 
418     return (AE_OK);
419 }
420 
421 
422 /******************************************************************************
423  *
424  * FUNCTION:    AcpiHwEnableRuntimeGpeBlock
425  *
426  * PARAMETERS:  GpeXruptInfo        - GPE Interrupt info
427  *              GpeBlock            - Gpe Block info
428  *
429  * RETURN:      Status
430  *
431  * DESCRIPTION: Enable all "runtime" GPEs within a single GPE block. Includes
432  *              combination wake/run GPEs.
433  *
434  ******************************************************************************/
435 
436 ACPI_STATUS
437 AcpiHwEnableRuntimeGpeBlock (
438     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
439     ACPI_GPE_BLOCK_INFO     *GpeBlock,
440     void                    *Context)
441 {
442     UINT32                  i;
443     ACPI_STATUS             Status;
444     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
445 
446 
447     /* NOTE: assumes that all GPEs are currently disabled */
448 
449     /* Examine each GPE Register within the block */
450 
451     for (i = 0; i < GpeBlock->RegisterCount; i++)
452     {
453         GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
454         if (!GpeRegisterInfo->EnableForRun)
455         {
456             continue;
457         }
458 
459         /* Enable all "runtime" GPEs in this register */
460 
461         Status = AcpiHwGpeEnableWrite (GpeRegisterInfo->EnableForRun,
462                     GpeRegisterInfo);
463         if (ACPI_FAILURE (Status))
464         {
465             return (Status);
466         }
467     }
468 
469     return (AE_OK);
470 }
471 
472 
473 /******************************************************************************
474  *
475  * FUNCTION:    AcpiHwEnableWakeupGpeBlock
476  *
477  * PARAMETERS:  GpeXruptInfo        - GPE Interrupt info
478  *              GpeBlock            - Gpe Block info
479  *
480  * RETURN:      Status
481  *
482  * DESCRIPTION: Enable all "wake" GPEs within a single GPE block. Includes
483  *              combination wake/run GPEs.
484  *
485  ******************************************************************************/
486 
487 static ACPI_STATUS
488 AcpiHwEnableWakeupGpeBlock (
489     ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
490     ACPI_GPE_BLOCK_INFO     *GpeBlock,
491     void                    *Context)
492 {
493     UINT32                  i;
494     ACPI_STATUS             Status;
495     ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
496 
497 
498     /* Examine each GPE Register within the block */
499 
500     for (i = 0; i < GpeBlock->RegisterCount; i++)
501     {
502         GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
503 
504         /*
505          * Enable all "wake" GPEs in this register and disable the
506          * remaining ones.
507          */
508         Status = AcpiHwGpeEnableWrite (GpeRegisterInfo->EnableForWake,
509                     GpeRegisterInfo);
510         if (ACPI_FAILURE (Status))
511         {
512             return (Status);
513         }
514     }
515 
516     return (AE_OK);
517 }
518 
519 
520 /******************************************************************************
521  *
522  * FUNCTION:    AcpiHwDisableAllGpes
523  *
524  * PARAMETERS:  None
525  *
526  * RETURN:      Status
527  *
528  * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
529  *
530  ******************************************************************************/
531 
532 ACPI_STATUS
533 AcpiHwDisableAllGpes (
534     void)
535 {
536     ACPI_STATUS             Status;
537 
538 
539     ACPI_FUNCTION_TRACE (HwDisableAllGpes);
540 
541 
542     Status = AcpiEvWalkGpeList (AcpiHwDisableGpeBlock, NULL);
543     Status = AcpiEvWalkGpeList (AcpiHwClearGpeBlock, NULL);
544     return_ACPI_STATUS (Status);
545 }
546 
547 
548 /******************************************************************************
549  *
550  * FUNCTION:    AcpiHwEnableAllRuntimeGpes
551  *
552  * PARAMETERS:  None
553  *
554  * RETURN:      Status
555  *
556  * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
557  *
558  ******************************************************************************/
559 
560 ACPI_STATUS
561 AcpiHwEnableAllRuntimeGpes (
562     void)
563 {
564     ACPI_STATUS             Status;
565 
566 
567     ACPI_FUNCTION_TRACE (HwEnableAllRuntimeGpes);
568 
569 
570     Status = AcpiEvWalkGpeList (AcpiHwEnableRuntimeGpeBlock, NULL);
571     return_ACPI_STATUS (Status);
572 }
573 
574 
575 /******************************************************************************
576  *
577  * FUNCTION:    AcpiHwEnableAllWakeupGpes
578  *
579  * PARAMETERS:  None
580  *
581  * RETURN:      Status
582  *
583  * DESCRIPTION: Enable all "wakeup" GPEs, in all GPE blocks
584  *
585  ******************************************************************************/
586 
587 ACPI_STATUS
588 AcpiHwEnableAllWakeupGpes (
589     void)
590 {
591     ACPI_STATUS             Status;
592 
593 
594     ACPI_FUNCTION_TRACE (HwEnableAllWakeupGpes);
595 
596 
597     Status = AcpiEvWalkGpeList (AcpiHwEnableWakeupGpeBlock, NULL);
598     return_ACPI_STATUS (Status);
599 }
600 
601 #endif /* !ACPI_REDUCED_HARDWARE */
602