hwgpe.c revision 99679 
1
2/******************************************************************************
3 *
4 * Module Name: hwgpe - Low level GPE enable/disable/clear functions
5 *              $Revision: 41 $
6 *
7 *****************************************************************************/
8
9/******************************************************************************
10 *
11 * 1. Copyright Notice
12 *
13 * Some or all of this work - Copyright (c) 1999 - 2002, 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:    AcpiHwGetGpeBitMask
128 *
129 * PARAMETERS:  GpeNumber       - The GPE
130 *
131 * RETURN:      Gpe register bitmask for this gpe level
132 *
133 * DESCRIPTION: Get the bitmask for this GPE
134 *
135 ******************************************************************************/
136
137UINT8
138AcpiHwGetGpeBitMask (
139    UINT32                  GpeNumber)
140{
141    return (AcpiGbl_GpeNumberInfo [AcpiEvGetGpeNumberIndex (GpeNumber)].BitMask);
142}
143
144
145/******************************************************************************
146 *
147 * FUNCTION:    AcpiHwEnableGpe
148 *
149 * PARAMETERS:  GpeNumber       - The GPE
150 *
151 * RETURN:      None
152 *
153 * DESCRIPTION: Enable a single GPE.
154 *
155 ******************************************************************************/
156
157ACPI_STATUS
158AcpiHwEnableGpe (
159    UINT32                  GpeNumber)
160{
161    UINT32                  InByte;
162    UINT32                  RegisterIndex;
163    UINT8                   BitMask;
164    ACPI_STATUS             Status;
165
166
167    ACPI_FUNCTION_ENTRY ();
168
169
170    /* Translate GPE number to index into global registers array. */
171
172    RegisterIndex = AcpiEvGetGpeRegisterIndex (GpeNumber);
173
174    /* Get the register bitmask for this GPE */
175
176    BitMask = AcpiHwGetGpeBitMask (GpeNumber);
177
178    /*
179     * Read the current value of the register, set the appropriate bit
180     * to enable the GPE, and write out the new register.
181     */
182    Status = AcpiHwLowLevelRead (8, &InByte,
183                    &AcpiGbl_GpeRegisterInfo[RegisterIndex].EnableAddress, 0);
184    if (ACPI_FAILURE (Status))
185    {
186        return (Status);
187    }
188
189    Status = AcpiHwLowLevelWrite (8, (InByte | BitMask),
190                    &AcpiGbl_GpeRegisterInfo[RegisterIndex].EnableAddress, 0);
191
192    return (Status);
193}
194
195
196/******************************************************************************
197 *
198 * FUNCTION:    AcpiHwEnableGpeForWakeup
199 *
200 * PARAMETERS:  GpeNumber       - The GPE
201 *
202 * RETURN:      None
203 *
204 * DESCRIPTION: Keep track of which GPEs the OS has requested not be
205 *              disabled when going to sleep.
206 *
207 ******************************************************************************/
208
209void
210AcpiHwEnableGpeForWakeup (
211    UINT32                  GpeNumber)
212{
213    UINT32                  RegisterIndex;
214    UINT8                   BitMask;
215
216
217    ACPI_FUNCTION_ENTRY ();
218
219
220    /* Translate GPE number to index into global registers array. */
221
222    RegisterIndex = AcpiEvGetGpeRegisterIndex (GpeNumber);
223
224    /* Get the register bitmask for this GPE */
225
226    BitMask = AcpiHwGetGpeBitMask (GpeNumber);
227
228    /*
229     * Set the bit so we will not disable this when sleeping
230     */
231    AcpiGbl_GpeRegisterInfo[RegisterIndex].WakeEnable |= BitMask;
232}
233
234
235/******************************************************************************
236 *
237 * FUNCTION:    AcpiHwDisableGpe
238 *
239 * PARAMETERS:  GpeNumber       - The GPE
240 *
241 * RETURN:      None
242 *
243 * DESCRIPTION: Disable a single GPE.
244 *
245 ******************************************************************************/
246
247ACPI_STATUS
248AcpiHwDisableGpe (
249    UINT32                  GpeNumber)
250{
251    UINT32                  InByte;
252    UINT32                  RegisterIndex;
253    UINT8                   BitMask;
254    ACPI_STATUS             Status;
255
256
257    ACPI_FUNCTION_ENTRY ();
258
259
260    /* Translate GPE number to index into global registers array. */
261
262    RegisterIndex = AcpiEvGetGpeRegisterIndex (GpeNumber);
263
264    /* Get the register bitmask for this GPE */
265
266    BitMask = AcpiHwGetGpeBitMask (GpeNumber);
267
268    /*
269     * Read the current value of the register, clear the appropriate bit,
270     * and write out the new register value to disable the GPE.
271     */
272    Status = AcpiHwLowLevelRead (8, &InByte,
273                    &AcpiGbl_GpeRegisterInfo[RegisterIndex].EnableAddress, 0);
274    if (ACPI_FAILURE (Status))
275    {
276        return (Status);
277    }
278
279    Status = AcpiHwLowLevelWrite (8, (InByte & ~BitMask),
280                    &AcpiGbl_GpeRegisterInfo[RegisterIndex].EnableAddress, 0);
281    if (ACPI_FAILURE (Status))
282    {
283        return (Status);
284    }
285
286    AcpiHwDisableGpeForWakeup(GpeNumber);
287    return (AE_OK);
288}
289
290
291/******************************************************************************
292 *
293 * FUNCTION:    AcpiHwDisableGpeForWakeup
294 *
295 * PARAMETERS:  GpeNumber       - The GPE
296 *
297 * RETURN:      None
298 *
299 * DESCRIPTION: Keep track of which GPEs the OS has requested not be
300 *              disabled when going to sleep.
301 *
302 ******************************************************************************/
303
304void
305AcpiHwDisableGpeForWakeup (
306    UINT32                  GpeNumber)
307{
308    UINT32                  RegisterIndex;
309    UINT8                   BitMask;
310
311
312    ACPI_FUNCTION_ENTRY ();
313
314
315    /* Translate GPE number to index into global registers array. */
316
317    RegisterIndex = AcpiEvGetGpeRegisterIndex (GpeNumber);
318
319    /* Get the register bitmask for this GPE */
320
321    BitMask = AcpiHwGetGpeBitMask (GpeNumber);
322
323    /*
324     * Clear the bit so we will disable this when sleeping
325     */
326    AcpiGbl_GpeRegisterInfo[RegisterIndex].WakeEnable &= ~BitMask;
327}
328
329
330/******************************************************************************
331 *
332 * FUNCTION:    AcpiHwClearGpe
333 *
334 * PARAMETERS:  GpeNumber       - The GPE
335 *
336 * RETURN:      None
337 *
338 * DESCRIPTION: Clear a single GPE.
339 *
340 ******************************************************************************/
341
342ACPI_STATUS
343AcpiHwClearGpe (
344    UINT32                  GpeNumber)
345{
346    UINT32                  RegisterIndex;
347    UINT8                   BitMask;
348    ACPI_STATUS             Status;
349
350
351    ACPI_FUNCTION_ENTRY ();
352
353
354    /* Translate GPE number to index into global registers array. */
355
356    RegisterIndex = AcpiEvGetGpeRegisterIndex (GpeNumber);
357
358    /* Get the register bitmask for this GPE */
359
360    BitMask = AcpiHwGetGpeBitMask (GpeNumber);
361
362    /*
363     * Write a one to the appropriate bit in the status register to
364     * clear this GPE.
365     */
366    Status = AcpiHwLowLevelWrite (8, BitMask,
367                    &AcpiGbl_GpeRegisterInfo[RegisterIndex].StatusAddress, 0);
368
369    return (Status);
370}
371
372
373/******************************************************************************
374 *
375 * FUNCTION:    AcpiHwGetGpeStatus
376 *
377 * PARAMETERS:  GpeNumber       - The GPE
378 *
379 * RETURN:      None
380 *
381 * DESCRIPTION: Return the status of a single GPE.
382 *
383 ******************************************************************************/
384
385ACPI_STATUS
386AcpiHwGetGpeStatus (
387    UINT32                  GpeNumber,
388    ACPI_EVENT_STATUS       *EventStatus)
389{
390    UINT32                  InByte = 0;
391    UINT32                  RegisterIndex = 0;
392    UINT8                   BitMask = 0;
393    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
394    ACPI_STATUS             Status;
395
396
397    ACPI_FUNCTION_ENTRY ();
398
399
400    if (!EventStatus)
401    {
402        return (AE_BAD_PARAMETER);
403    }
404
405    (*EventStatus) = 0;
406
407    /* Translate GPE number to index into global registers array. */
408
409    RegisterIndex = AcpiEvGetGpeRegisterIndex (GpeNumber);
410    GpeRegisterInfo = &AcpiGbl_GpeRegisterInfo[RegisterIndex];
411
412    /* Get the register bitmask for this GPE */
413
414    BitMask = AcpiHwGetGpeBitMask (GpeNumber);
415
416    /* GPE Enabled? */
417
418    Status = AcpiHwLowLevelRead (8, &InByte, &GpeRegisterInfo->EnableAddress, 0);
419    if (ACPI_FAILURE (Status))
420    {
421        return (Status);
422    }
423
424    if (BitMask & InByte)
425    {
426        (*EventStatus) |= ACPI_EVENT_FLAG_ENABLED;
427    }
428
429    /* GPE Enabled for wake? */
430
431    if (BitMask & GpeRegisterInfo->WakeEnable)
432    {
433        (*EventStatus) |= ACPI_EVENT_FLAG_WAKE_ENABLED;
434    }
435
436    /* GPE active (set)? */
437
438    Status = AcpiHwLowLevelRead (8, &InByte, &GpeRegisterInfo->StatusAddress, 0);
439    if (ACPI_FAILURE (Status))
440    {
441        return (Status);
442    }
443
444    if (BitMask & InByte)
445    {
446        (*EventStatus) |= ACPI_EVENT_FLAG_SET;
447    }
448    return (AE_OK);
449}
450
451
452/******************************************************************************
453 *
454 * FUNCTION:    AcpiHwDisableNonWakeupGpes
455 *
456 * PARAMETERS:  None
457 *
458 * RETURN:      None
459 *
460 * DESCRIPTION: Disable all non-wakeup GPEs
461 *              Call with interrupts disabled. The interrupt handler also
462 *              modifies AcpiGbl_GpeRegisterInfo[i].Enable, so it should not be
463 *              given the chance to run until after non-wake GPEs are
464 *              re-enabled.
465 *
466 ******************************************************************************/
467
468ACPI_STATUS
469AcpiHwDisableNonWakeupGpes (
470    void)
471{
472    UINT32                  i;
473    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
474    UINT32                  InValue;
475    ACPI_STATUS             Status;
476
477
478    ACPI_FUNCTION_ENTRY ();
479
480
481    for (i = 0; i < AcpiGbl_GpeRegisterCount; i++)
482    {
483        GpeRegisterInfo = &AcpiGbl_GpeRegisterInfo[i];
484
485        /*
486         * Read the enabled status of all GPEs. We
487         * will be using it to restore all the GPEs later.
488         */
489        Status = AcpiHwLowLevelRead (8, &InValue,
490                    &GpeRegisterInfo->EnableAddress, 0);
491        if (ACPI_FAILURE (Status))
492        {
493            return (Status);
494        }
495
496        GpeRegisterInfo->Enable = (UINT8) InValue;
497
498        /*
499         * Disable all GPEs except wakeup GPEs.
500         */
501        Status = AcpiHwLowLevelWrite (8, GpeRegisterInfo->WakeEnable,
502                &GpeRegisterInfo->EnableAddress, 0);
503        if (ACPI_FAILURE (Status))
504        {
505            return (Status);
506        }
507    }
508    return (AE_OK);
509}
510
511
512/******************************************************************************
513 *
514 * FUNCTION:    AcpiHwEnableNonWakeupGpes
515 *
516 * PARAMETERS:  None
517 *
518 * RETURN:      None
519 *
520 * DESCRIPTION: Enable all non-wakeup GPEs we previously enabled.
521 *
522 ******************************************************************************/
523
524ACPI_STATUS
525AcpiHwEnableNonWakeupGpes (
526    void)
527{
528    UINT32                  i;
529    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo;
530    ACPI_STATUS             Status;
531
532
533    ACPI_FUNCTION_ENTRY ();
534
535
536    for (i = 0; i < AcpiGbl_GpeRegisterCount; i++)
537    {
538        GpeRegisterInfo = &AcpiGbl_GpeRegisterInfo[i];
539
540        /*
541         * We previously stored the enabled status of all GPEs.
542         * Blast them back in.
543         */
544        Status = AcpiHwLowLevelWrite (8, GpeRegisterInfo->Enable,
545                    &GpeRegisterInfo->EnableAddress, 0);
546        if (ACPI_FAILURE (Status))
547        {
548            return (Status);
549        }
550    }
551    return (AE_OK);
552}
553