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