hwgpe.c revision 128212 
195927Stjr
295927Stjr/******************************************************************************
395927Stjr *
495927Stjr * Module Name: hwgpe - Low level GPE enable/disable/clear functions
595927Stjr *              $Revision: 57 $
6 *
7 *****************************************************************************/
8
9/******************************************************************************
10 *
11 * 1. Copyright Notice
12 *
13 * Some or all of this work - Copyright (c) 1999 - 2004, Intel Corp.
14 * All rights reserved.
15 *
16 * 2. License
17 *
18 * 2.1. This is your license from Intel Corp. under its intellectual property
19 * rights.  You may have additional license terms from the party that provided
20 * you this software, covering your right to use that party's intellectual
21 * property rights.
22 *
23 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
24 * copy of the source code appearing in this file ("Covered Code") an
25 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
26 * base code distributed originally by Intel ("Original Intel Code") to copy,
27 * make derivatives, distribute, use and display any portion of the Covered
28 * Code in any form, with the right to sublicense such rights; and
29 *
30 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
31 * license (with the right to sublicense), under only those claims of Intel
32 * patents that are infringed by the Original Intel Code, to make, use, sell,
33 * offer to sell, and import the Covered Code and derivative works thereof
34 * solely to the minimum extent necessary to exercise the above copyright
35 * license, and in no event shall the patent license extend to any additions
36 * to or modifications of the Original Intel Code.  No other license or right
37 * is granted directly or by implication, estoppel or otherwise;
38 *
39 * The above copyright and patent license is granted only if the following
40 * conditions are met:
41 *
42 * 3. Conditions
43 *
44 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
45 * Redistribution of source code of any substantial portion of the Covered
46 * Code or modification with rights to further distribute source must include
47 * the above Copyright Notice, the above License, this list of Conditions,
48 * and the following Disclaimer and Export Compliance provision.  In addition,
49 * Licensee must cause all Covered Code to which Licensee contributes to
50 * contain a file documenting the changes Licensee made to create that Covered
51 * Code and the date of any change.  Licensee must include in that file the
52 * documentation of any changes made by any predecessor Licensee.  Licensee
53 * must include a prominent statement that the modification is derived,
54 * directly or indirectly, from Original Intel Code.
55 *
56 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
57 * Redistribution of source code of any substantial portion of the Covered
58 * Code or modification without rights to further distribute source must
59 * include the following Disclaimer and Export Compliance provision in the
60 * documentation and/or other materials provided with distribution.  In
61 * addition, Licensee may not authorize further sublicense of source of any
62 * portion of the Covered Code, and must include terms to the effect that the
63 * license from Licensee to its licensee is limited to the intellectual
64 * property embodied in the software Licensee provides to its licensee, and
65 * not to intellectual property embodied in modifications its licensee may
66 * make.
67 *
68 * 3.3. Redistribution of Executable. Redistribution in executable form of any
69 * substantial portion of the Covered Code or modification must reproduce the
70 * above Copyright Notice, and the following Disclaimer and Export Compliance
71 * provision in the documentation and/or other materials provided with the
72 * distribution.
73 *
74 * 3.4. Intel retains all right, title, and interest in and to the Original
75 * Intel Code.
76 *
77 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
78 * Intel shall be used in advertising or otherwise to promote the sale, use or
79 * other dealings in products derived from or relating to the Covered Code
80 * without prior written authorization from Intel.
81 *
82 * 4. Disclaimer and Export Compliance
83 *
84 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
85 * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
86 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
87 * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
88 * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
89 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
90 * PARTICULAR PURPOSE.
91 *
92 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
93 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
94 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
95 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
96 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
97 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
98 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
99 * LIMITED REMEDY.
100 *
101 * 4.3. Licensee shall not export, either directly or indirectly, any of this
102 * software or system incorporating such software without first obtaining any
103 * required license or other approval from the U. S. Department of Commerce or
104 * any other agency or department of the United States Government.  In the
105 * event Licensee exports any such software from the United States or
106 * re-exports any such software from a foreign destination, Licensee shall
107 * ensure that the distribution and export/re-export of the software is in
108 * compliance with all laws, regulations, orders, or other restrictions of the
109 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
110 * any of its subsidiaries will export/re-export any technical data, process,
111 * software, or service, directly or indirectly, to any country for which the
112 * United States government or any agency thereof requires an export license,
113 * other governmental approval, or letter of assurance, without first obtaining
114 * such license, approval or letter.
115 *
116 *****************************************************************************/
117
118#include "acpi.h"
119#include "acevents.h"
120
121#define _COMPONENT          ACPI_HARDWARE
122        ACPI_MODULE_NAME    ("hwgpe")
123
124
125/******************************************************************************
126 *
127 * FUNCTION:    AcpiHwEnableGpe
128 *
129 * PARAMETERS:  GpeEventInfo        - Info block for the GPE to be enabled
130 *
131 * RETURN:      Status
132 *
133 * DESCRIPTION: Enable a single GPE.
134 *
135 ******************************************************************************/
136
137ACPI_STATUS
138AcpiHwEnableGpe (
139    ACPI_GPE_EVENT_INFO     *GpeEventInfo)
140{
141    UINT32                  InByte;
142    ACPI_STATUS             Status;
143
144
145    ACPI_FUNCTION_ENTRY ();
146
147
148    /*
149     * Read the current value of the register, set the appropriate bit
150     * to enable the GPE, and write out the new register.
151     */
152    Status = AcpiHwLowLevelRead (8, &InByte,
153                    &GpeEventInfo->RegisterInfo->EnableAddress);
154    if (ACPI_FAILURE (Status))
155    {
156        return (Status);
157    }
158
159    /* Write with the new GPE bit enabled */
160
161    Status = AcpiHwLowLevelWrite (8, (InByte | GpeEventInfo->BitMask),
162                    &GpeEventInfo->RegisterInfo->EnableAddress);
163
164    return (Status);
165}
166
167
168/******************************************************************************
169 *
170 * FUNCTION:    AcpiHwEnableGpeForWakeup
171 *
172 * PARAMETERS:  GpeEventInfo        - Info block for the GPE to be enabled
173 *
174 * RETURN:      None
175 *
176 * DESCRIPTION: Keep track of which GPEs the OS has requested not be
177 *              disabled when going to sleep.
178 *
179 ******************************************************************************/
180
181void
182AcpiHwEnableGpeForWakeup (
183    ACPI_GPE_EVENT_INFO     *GpeEventInfo)
184{
185    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
186
187
188    ACPI_FUNCTION_ENTRY ();
189
190
191    /* Get the info block for the entire GPE register */
192
193    GpeRegisterInfo = GpeEventInfo->RegisterInfo;
194    if (!GpeRegisterInfo)
195    {
196        return;
197    }
198
199    /*
200     * Set the bit so we will not enable this GPE when sleeping (and disable
201     * it upon wake)
202     */
203    GpeRegisterInfo->WakeEnable |= GpeEventInfo->BitMask;
204    GpeEventInfo->Flags |= (ACPI_GPE_TYPE_WAKE | ACPI_GPE_ENABLED);
205}
206
207
208/******************************************************************************
209 *
210 * FUNCTION:    AcpiHwDisableGpe
211 *
212 * PARAMETERS:  GpeEventInfo        - Info block for the GPE to be disabled
213 *
214 * RETURN:      Status
215 *
216 * DESCRIPTION: Disable a single GPE.
217 *
218 ******************************************************************************/
219
220ACPI_STATUS
221AcpiHwDisableGpe (
222    ACPI_GPE_EVENT_INFO     *GpeEventInfo)
223{
224    UINT32                  InByte;
225    ACPI_STATUS             Status;
226    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
227
228
229    ACPI_FUNCTION_ENTRY ();
230
231
232    /* Get the info block for the entire GPE register */
233
234    GpeRegisterInfo = GpeEventInfo->RegisterInfo;
235    if (!GpeRegisterInfo)
236    {
237        return (AE_BAD_PARAMETER);
238    }
239
240    /*
241     * Read the current value of the register, clear the appropriate bit,
242     * and write out the new register value to disable the GPE.
243     */
244    Status = AcpiHwLowLevelRead (8, &InByte,
245                    &GpeRegisterInfo->EnableAddress);
246    if (ACPI_FAILURE (Status))
247    {
248        return (Status);
249    }
250
251    /* Write the byte with this GPE bit cleared */
252
253    Status = AcpiHwLowLevelWrite (8, (InByte & ~(GpeEventInfo->BitMask)),
254                    &GpeRegisterInfo->EnableAddress);
255    if (ACPI_FAILURE (Status))
256    {
257        return (Status);
258    }
259
260    /* Make sure this GPE is disabled for wake, also */
261
262    AcpiHwDisableGpeForWakeup (GpeEventInfo);
263    return (AE_OK);
264}
265
266
267/******************************************************************************
268 *
269 * FUNCTION:    AcpiHwDisableGpeForWakeup
270 *
271 * PARAMETERS:  GpeEventInfo        - Info block for the GPE to be disabled
272 *
273 * RETURN:      None
274 *
275 * DESCRIPTION: Keep track of which GPEs the OS has requested not be
276 *              disabled when going to sleep.
277 *
278 ******************************************************************************/
279
280void
281AcpiHwDisableGpeForWakeup (
282    ACPI_GPE_EVENT_INFO     *GpeEventInfo)
283{
284    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
285
286
287    ACPI_FUNCTION_ENTRY ();
288
289
290    /* Get the info block for the entire GPE register */
291
292    GpeRegisterInfo = GpeEventInfo->RegisterInfo;
293    if (!GpeRegisterInfo)
294    {
295        return;
296    }
297
298    /* Clear the bit so we will disable this when sleeping */
299
300    GpeRegisterInfo->WakeEnable &= ~(GpeEventInfo->BitMask);
301}
302
303
304/******************************************************************************
305 *
306 * FUNCTION:    AcpiHwClearGpe
307 *
308 * PARAMETERS:  GpeEventInfo        - Info block for the GPE to be cleared
309 *
310 * RETURN:      StatusStatus
311 *
312 * DESCRIPTION: Clear the status bit for a single GPE.
313 *
314 ******************************************************************************/
315
316ACPI_STATUS
317AcpiHwClearGpe (
318    ACPI_GPE_EVENT_INFO     *GpeEventInfo)
319{
320    ACPI_STATUS             Status;
321
322
323    ACPI_FUNCTION_ENTRY ();
324
325
326    /*
327     * Write a one to the appropriate bit in the status register to
328     * clear this GPE.
329     */
330    Status = AcpiHwLowLevelWrite (8, GpeEventInfo->BitMask,
331                    &GpeEventInfo->RegisterInfo->StatusAddress);
332
333    return (Status);
334}
335
336
337/******************************************************************************
338 *
339 * FUNCTION:    AcpiHwGetGpeStatus
340 *
341 * PARAMETERS:  GpeEventInfo        - Info block for the GPE to queried
342 *              EventStatus         - Where the GPE status is returned
343 *
344 * RETURN:      Status
345 *
346 * DESCRIPTION: Return the status of a single GPE.
347 *
348 ******************************************************************************/
349
350ACPI_STATUS
351AcpiHwGetGpeStatus (
352    ACPI_GPE_EVENT_INFO     *GpeEventInfo,
353    ACPI_EVENT_STATUS       *EventStatus)
354{
355    UINT32                  InByte;
356    UINT8                   BitMask;
357    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
358    ACPI_STATUS             Status;
359    ACPI_EVENT_STATUS       LocalEventStatus = 0;
360
361
362    ACPI_FUNCTION_ENTRY ();
363
364
365    if (!EventStatus)
366    {
367        return (AE_BAD_PARAMETER);
368    }
369
370    /* Get the info block for the entire GPE register */
371
372    GpeRegisterInfo = GpeEventInfo->RegisterInfo;
373
374    /* Get the register bitmask for this GPE */
375
376    BitMask = GpeEventInfo->BitMask;
377
378    /* GPE Enabled? */
379
380    Status = AcpiHwLowLevelRead (8, &InByte, &GpeRegisterInfo->EnableAddress);
381    if (ACPI_FAILURE (Status))
382    {
383        goto UnlockAndExit;
384    }
385
386    if (BitMask & InByte)
387    {
388        LocalEventStatus |= ACPI_EVENT_FLAG_ENABLED;
389    }
390
391    /* GPE Enabled for wake? */
392
393    if (BitMask & GpeRegisterInfo->WakeEnable)
394    {
395        LocalEventStatus |= ACPI_EVENT_FLAG_WAKE_ENABLED;
396    }
397
398    /* GPE active (set)? */
399
400    Status = AcpiHwLowLevelRead (8, &InByte, &GpeRegisterInfo->StatusAddress);
401    if (ACPI_FAILURE (Status))
402    {
403        goto UnlockAndExit;
404    }
405
406    if (BitMask & InByte)
407    {
408        LocalEventStatus |= ACPI_EVENT_FLAG_SET;
409    }
410
411    /* Set return value */
412
413    (*EventStatus) = LocalEventStatus;
414
415
416UnlockAndExit:
417    return (Status);
418}
419
420
421/******************************************************************************
422 *
423 * FUNCTION:    AcpiHwDisableGpeBlock
424 *
425 * PARAMETERS:  GpeXruptInfo        - GPE Interrupt info
426 *              GpeBlock            - Gpe Block info
427 *
428 * RETURN:      Status
429 *
430 * DESCRIPTION: Disable all GPEs within a GPE block
431 *
432 ******************************************************************************/
433
434ACPI_STATUS
435AcpiHwDisableGpeBlock (
436    ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
437    ACPI_GPE_BLOCK_INFO     *GpeBlock)
438{
439    UINT32                  i;
440    ACPI_STATUS             Status;
441
442
443    /* Examine each GPE Register within the block */
444
445    for (i = 0; i < GpeBlock->RegisterCount; i++)
446    {
447        /* Disable all GPEs in this register */
448
449        Status = AcpiHwLowLevelWrite (8, 0x00,
450                    &GpeBlock->RegisterInfo[i].EnableAddress);
451        if (ACPI_FAILURE (Status))
452        {
453            return (Status);
454        }
455    }
456
457    return (AE_OK);
458}
459
460
461/******************************************************************************
462 *
463 * FUNCTION:    AcpiHwClearGpeBlock
464 *
465 * PARAMETERS:  GpeXruptInfo        - GPE Interrupt info
466 *              GpeBlock            - Gpe Block info
467 *
468 * RETURN:      Status
469 *
470 * DESCRIPTION: Clear status bits for all GPEs within a GPE block
471 *
472 ******************************************************************************/
473
474ACPI_STATUS
475AcpiHwClearGpeBlock (
476    ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
477    ACPI_GPE_BLOCK_INFO     *GpeBlock)
478{
479    UINT32                  i;
480    ACPI_STATUS             Status;
481
482
483    /* Examine each GPE Register within the block */
484
485    for (i = 0; i < GpeBlock->RegisterCount; i++)
486    {
487        /* Clear status on all GPEs in this register */
488
489        Status = AcpiHwLowLevelWrite (8, 0xFF,
490                    &GpeBlock->RegisterInfo[i].StatusAddress);
491        if (ACPI_FAILURE (Status))
492        {
493            return (Status);
494        }
495    }
496
497    return (AE_OK);
498}
499
500
501/******************************************************************************
502 *
503 * FUNCTION:    AcpiHwPrepareGpeBlockForSleep
504 *
505 * PARAMETERS:  GpeXruptInfo        - GPE Interrupt info
506 *              GpeBlock            - Gpe Block info
507 *
508 * RETURN:      Status
509 *
510 * DESCRIPTION: Disable all runtime GPEs and enable all wakeup GPEs -- within
511 *              a single GPE block
512 *
513 ******************************************************************************/
514
515static ACPI_STATUS
516AcpiHwPrepareGpeBlockForSleep (
517    ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
518    ACPI_GPE_BLOCK_INFO     *GpeBlock)
519{
520    UINT32                  i;
521    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
522    UINT32                  InValue;
523    ACPI_STATUS             Status;
524
525
526    /* Get the register info for the entire GPE block */
527
528    GpeRegisterInfo = GpeBlock->RegisterInfo;
529
530    /* Examine each GPE Register within the block */
531
532    for (i = 0; i < GpeBlock->RegisterCount; i++)
533    {
534        /*
535         * Read the enabled/disabled status of all GPEs. We
536         * will be using it to restore all the GPEs later.
537         *
538         * NOTE:  Wake GPEs are are ALL disabled at this time, so when we wake
539         * and restore this register, they will be automatically disabled.
540         */
541        Status = AcpiHwLowLevelRead (8, &InValue,
542                    &GpeRegisterInfo->EnableAddress);
543        if (ACPI_FAILURE (Status))
544        {
545            return (Status);
546        }
547
548        GpeRegisterInfo->Enable = (UINT8) InValue;
549
550        /*
551         * 1) Disable all runtime GPEs
552         * 2) Enable all wakeup GPEs
553         */
554        Status = AcpiHwLowLevelWrite (8, GpeRegisterInfo->WakeEnable,
555                &GpeRegisterInfo->EnableAddress);
556        if (ACPI_FAILURE (Status))
557        {
558            return (Status);
559        }
560
561        /* Point to next GPE register */
562
563        GpeRegisterInfo++;
564    }
565
566    return (AE_OK);
567}
568
569
570/******************************************************************************
571 *
572 * FUNCTION:    AcpiHwPrepareGpesForSleep
573 *
574 * PARAMETERS:  None
575 *
576 * RETURN:      Status
577 *
578 * DESCRIPTION: Disable all runtime GPEs, enable all wake GPEs.
579 *              Called with interrupts disabled. The interrupt handler also
580 *              modifies GpeRegisterInfo->Enable, so it should not be
581 *              given the chance to run until after the runtime GPEs are
582 *              re-enabled.
583 *
584 ******************************************************************************/
585
586ACPI_STATUS
587AcpiHwPrepareGpesForSleep (
588    void)
589{
590    ACPI_STATUS             Status;
591
592
593    ACPI_FUNCTION_ENTRY ();
594
595
596    Status = AcpiEvWalkGpeList (AcpiHwPrepareGpeBlockForSleep);
597    return (Status);
598}
599
600
601/******************************************************************************
602 *
603 * FUNCTION:    AcpiHwRestoreGpeBlockOnWake
604 *
605 * PARAMETERS:  GpeXruptInfo        - GPE Interrupt info
606 *              GpeBlock            - Gpe Block info
607 *
608 * RETURN:      Status
609 *
610 * DESCRIPTION: Enable all runtime GPEs and disable all wake GPEs -- in one
611 *              GPE block
612 *
613 ******************************************************************************/
614
615static ACPI_STATUS
616AcpiHwRestoreGpeBlockOnWake (
617    ACPI_GPE_XRUPT_INFO     *GpeXruptInfo,
618    ACPI_GPE_BLOCK_INFO     *GpeBlock)
619{
620    UINT32                  i;
621    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
622    ACPI_STATUS             Status;
623
624
625    /* This callback processes one entire GPE block */
626
627    /* Get the register info for the entire GPE block */
628
629    GpeRegisterInfo = GpeBlock->RegisterInfo;
630
631    /* Examine each GPE register within the block */
632
633    for (i = 0; i < GpeBlock->RegisterCount; i++)
634    {
635        /* Clear the entire status register */
636
637        Status = AcpiHwLowLevelWrite (8, 0xFF,
638                    &GpeBlock->RegisterInfo[i].StatusAddress);
639        if (ACPI_FAILURE (Status))
640        {
641            return (Status);
642        }
643
644        /*
645         * Restore the GPE Enable register, which will do the following:
646         *
647         * 1) Disable all wakeup GPEs
648         * 2) Enable all runtime GPEs
649         *
650         *  (On sleep, we saved the enabled status of all GPEs)
651         */
652        Status = AcpiHwLowLevelWrite (8, GpeRegisterInfo->Enable,
653                    &GpeRegisterInfo->EnableAddress);
654        if (ACPI_FAILURE (Status))
655        {
656            return (Status);
657        }
658
659        /* Point to next GPE register */
660
661        GpeRegisterInfo++;
662    }
663
664    return (AE_OK);
665}
666
667
668/******************************************************************************
669 *
670 * FUNCTION:    AcpiHwRestoreGpesOnWake
671 *
672 * PARAMETERS:  None
673 *
674 * RETURN:      Status
675 *
676 * DESCRIPTION: Enable all runtime GPEs and disable all wake GPEs -- in all
677 *              GPE blocks
678 *
679 ******************************************************************************/
680
681ACPI_STATUS
682AcpiHwRestoreGpesOnWake (
683    void)
684{
685    ACPI_STATUS             Status;
686
687
688    ACPI_FUNCTION_ENTRY ();
689
690
691    Status = AcpiEvWalkGpeList (AcpiHwRestoreGpeBlockOnWake);
692    return (Status);
693}
694