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