Some laptops return other values for working toucpads. Allow test_aux_port to
[dragonfly.git] / sys / contrib / dev / acpica-unix-20031203 / events / evxfevnt.c
1 /******************************************************************************
2  *
3  * Module Name: evxfevnt - External Interfaces, ACPI event disable/enable
4  *              $Revision: 73 $
5  *
6  *****************************************************************************/
7
8 /******************************************************************************
9  *
10  * 1. Copyright Notice
11  *
12  * Some or all of this work - Copyright (c) 1999 - 2003, Intel Corp.
13  * All rights reserved.
14  *
15  * 2. License
16  *
17  * 2.1. This is your license from Intel Corp. under its intellectual property
18  * rights.  You may have additional license terms from the party that provided
19  * you this software, covering your right to use that party's intellectual
20  * property rights.
21  *
22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
23  * copy of the source code appearing in this file ("Covered Code") an
24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
25  * base code distributed originally by Intel ("Original Intel Code") to copy,
26  * make derivatives, distribute, use and display any portion of the Covered
27  * Code in any form, with the right to sublicense such rights; and
28  *
29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
30  * license (with the right to sublicense), under only those claims of Intel
31  * patents that are infringed by the Original Intel Code, to make, use, sell,
32  * offer to sell, and import the Covered Code and derivative works thereof
33  * solely to the minimum extent necessary to exercise the above copyright
34  * license, and in no event shall the patent license extend to any additions
35  * to or modifications of the Original Intel Code.  No other license or right
36  * is granted directly or by implication, estoppel or otherwise;
37  *
38  * The above copyright and patent license is granted only if the following
39  * conditions are met:
40  *
41  * 3. Conditions
42  *
43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
44  * Redistribution of source code of any substantial prton of the Covered
45  * Code or modification with rights to further distribute source must include
46  * the above Copyright Notice, the above License, this list of Conditions,
47  * and the following Disclaimer and Export Compliance provision.  In addition,
48  * Licensee must cause all Covered Code to which Licensee contributes to
49  * contain a file documenting the changes Licensee made to create that Covered
50  * Code and the date of any change.  Licensee must include in that file the
51  * documentation of any changes made by any predecessor Licensee.  Licensee
52  * must include a prominent statement that the modification is derived,
53  * directly or indirectly, from Original Intel Code.
54  *
55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
56  * Redistribution of source code of any substantial portion of the Covered
57  * Code or modification without rights to further distribute source must
58  * include the following Disclaimer and Export Compliance provision in the
59  * documentation and/or other materials provided with distribution.  In
60  * addition, Licensee may not authorize further sublicense of source of any
61  * portion of the Covered Code, and must include terms to the effect that the
62  * license from Licensee to its licensee is limited to the intellectual
63  * property embodied in the software Licensee provides to its licensee, and
64  * not to intellectual property embodied in modifications its licensee may
65  * make.
66  *
67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
68  * substantial portion of the Covered Code or modification must reproduce the
69  * above Copyright Notice, and the following Disclaimer and Export Compliance
70  * provision in the documentation and/or other materials provided with the
71  * distribution.
72  *
73  * 3.4. Intel retains all right, title, and interest in and to the Original
74  * Intel Code.
75  *
76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
77  * Intel shall be used in advertising or otherwise to promote the sale, use or
78  * other dealings in products derived from or relating to the Covered Code
79  * without prior written authorization from Intel.
80  *
81  * 4. Disclaimer and Export Compliance
82  *
83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
89  * PARTICULAR PURPOSE.
90  *
91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
98  * LIMITED REMEDY.
99  *
100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
101  * software or system incorporating such software without first obtaining any
102  * required license or other approval from the U. S. Department of Commerce or
103  * any other agency or department of the United States Government.  In the
104  * event Licensee exports any such software from the United States or
105  * re-exports any such software from a foreign destination, Licensee shall
106  * ensure that the distribution and export/re-export of the software is in
107  * compliance with all laws, regulations, orders, or other restrictions of the
108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
109  * any of its subsidiaries will export/re-export any technical data, process,
110  * software, or service, directly or indirectly, to any country for which the
111  * United States government or any agency thereof requires an export license,
112  * other governmental approval, or letter of assurance, without first obtaining
113  * such license, approval or letter.
114  *
115  *****************************************************************************/
116
117
118 #define __EVXFEVNT_C__
119
120 #include "acpi.h"
121 #include "acevents.h"
122 #include "acnamesp.h"
123
124 #define _COMPONENT          ACPI_EVENTS
125         ACPI_MODULE_NAME    ("evxfevnt")
126
127
128 /*******************************************************************************
129  *
130  * FUNCTION:    AcpiEnable
131  *
132  * PARAMETERS:  None
133  *
134  * RETURN:      Status
135  *
136  * DESCRIPTION: Transfers the system into ACPI mode.
137  *
138  ******************************************************************************/
139
140 ACPI_STATUS
141 AcpiEnable (void)
142 {
143     ACPI_STATUS             Status = AE_OK;
144
145
146     ACPI_FUNCTION_TRACE ("AcpiEnable");
147
148
149     /* Make sure we have the FADT*/
150
151     if (!AcpiGbl_FADT)
152     {
153         ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "No FADT information present!\n"));
154         return_ACPI_STATUS (AE_NO_ACPI_TABLES);
155     }
156
157     if (AcpiHwGetMode() == ACPI_SYS_MODE_ACPI)
158     {
159         ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "System is already in ACPI mode\n"));
160     }
161     else
162     {
163         /* Transition to ACPI mode */
164
165         Status = AcpiHwSetMode (ACPI_SYS_MODE_ACPI);
166         if (ACPI_FAILURE (Status))
167         {
168             ACPI_REPORT_ERROR (("Could not transition to ACPI mode.\n"));
169             return_ACPI_STATUS (Status);
170         }
171
172         ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "Transition to ACPI mode successful\n"));
173     }
174
175     return_ACPI_STATUS (Status);
176 }
177
178
179 /*******************************************************************************
180  *
181  * FUNCTION:    AcpiDisable
182  *
183  * PARAMETERS:  None
184  *
185  * RETURN:      Status
186  *
187  * DESCRIPTION: Transfers the system into LEGACY mode.
188  *
189  ******************************************************************************/
190
191 ACPI_STATUS
192 AcpiDisable (void)
193 {
194     ACPI_STATUS             Status = AE_OK;
195
196
197     ACPI_FUNCTION_TRACE ("AcpiDisable");
198
199
200     if (!AcpiGbl_FADT)
201     {
202         ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "No FADT information present!\n"));
203         return_ACPI_STATUS (AE_NO_ACPI_TABLES);
204     }
205
206     if (AcpiHwGetMode() == ACPI_SYS_MODE_LEGACY)
207     {
208         ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "System is already in legacy (non-ACPI) mode\n"));
209     }
210     else
211     {
212         /* Transition to LEGACY mode */
213
214         Status = AcpiHwSetMode (ACPI_SYS_MODE_LEGACY);
215
216         if (ACPI_FAILURE (Status))
217         {
218             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not exit ACPI mode to legacy mode"));
219             return_ACPI_STATUS (Status);
220         }
221
222         ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "ACPI mode disabled\n"));
223     }
224
225     return_ACPI_STATUS (Status);
226 }
227
228
229 /*******************************************************************************
230  *
231  * FUNCTION:    AcpiEnableEvent
232  *
233  * PARAMETERS:  Event           - The fixed eventto be enabled
234  *              Flags           - Reserved
235  *
236  * RETURN:      Status
237  *
238  * DESCRIPTION: Enable an ACPI event (fixed)
239  *
240  ******************************************************************************/
241
242 ACPI_STATUS
243 AcpiEnableEvent (
244     UINT32                  Event,
245     UINT32                  Flags)
246 {
247     ACPI_STATUS             Status = AE_OK;
248     UINT32                  Value;
249
250
251     ACPI_FUNCTION_TRACE ("AcpiEnableEvent");
252
253
254     /* Decode the Fixed Event */
255
256     if (Event > ACPI_EVENT_MAX)
257     {
258         return_ACPI_STATUS (AE_BAD_PARAMETER);
259     }
260
261     /*
262      * Enable the requested fixed event (by writing a one to the
263      * enable register bit)
264      */
265     Status = AcpiSetRegister (AcpiGbl_FixedEventInfo[Event].EnableRegisterId,
266                 1, ACPI_MTX_LOCK);
267     if (ACPI_FAILURE (Status))
268     {
269         return_ACPI_STATUS (Status);
270     }
271
272     /* Make sure that the hardware responded */
273
274     Status = AcpiGetRegister (AcpiGbl_FixedEventInfo[Event].EnableRegisterId,
275                     &Value, ACPI_MTX_LOCK);
276     if (ACPI_FAILURE (Status))
277     {
278         return_ACPI_STATUS (Status);
279     }
280
281     if (Value != 1)
282     {
283         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
284             "Could not enable %s event\n", AcpiUtGetEventName (Event)));
285         return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE);
286     }
287
288     return_ACPI_STATUS (Status);
289 }
290
291
292 /*******************************************************************************
293  *
294  * FUNCTION:    AcpiEnableGpe
295  *
296  * PARAMETERS:  GpeDevice       - Parent GPE Device
297  *              GpeNumber       - GPE level within the GPE block
298  *              Flags           - Just enable, or also wake enable?
299  *                                Called from ISR or not
300  *
301  * RETURN:      Status
302  *
303  * DESCRIPTION: Enable an ACPI event (general purpose)
304  *
305  ******************************************************************************/
306
307 ACPI_STATUS
308 AcpiEnableGpe (
309     ACPI_HANDLE             GpeDevice,
310     UINT32                  GpeNumber,
311     UINT32                  Flags)
312 {
313     ACPI_STATUS             Status = AE_OK;
314     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
315
316
317     ACPI_FUNCTION_TRACE ("AcpiEnableGpe");
318
319
320     /* Use semaphore lock if not executing at interrupt level */
321
322     if (Flags & ACPI_NOT_ISR)
323     {
324         Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
325         if (ACPI_FAILURE (Status))
326         {
327             return_ACPI_STATUS (Status);
328         }
329     }
330
331     /* Ensure that we have a valid GPE number */
332
333     GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
334     if (!GpeEventInfo)
335     {
336         Status = AE_BAD_PARAMETER;
337         goto UnlockAndExit;
338     }
339
340     /* Enable the requested GPE number */
341
342     Status = AcpiHwEnableGpe (GpeEventInfo);
343     if (ACPI_FAILURE (Status))
344     {
345         goto UnlockAndExit;
346     }
347
348     if (Flags & ACPI_EVENT_WAKE_ENABLE)
349     {
350         AcpiHwEnableGpeForWakeup (GpeEventInfo);
351     }
352
353 UnlockAndExit:
354     if (Flags & ACPI_NOT_ISR)
355     {
356         (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
357     }
358     return_ACPI_STATUS (Status);
359 }
360
361
362 /*******************************************************************************
363  *
364  * FUNCTION:    AcpiDisableEvent
365  *
366  * PARAMETERS:  Event           - The fixed eventto be enabled
367  *              Flags           - Reserved
368  *
369  * RETURN:      Status
370  *
371  * DESCRIPTION: Disable an ACPI event (fixed)
372  *
373  ******************************************************************************/
374
375 ACPI_STATUS
376 AcpiDisableEvent (
377     UINT32                  Event,
378     UINT32                  Flags)
379 {
380     ACPI_STATUS             Status = AE_OK;
381     UINT32                  Value;
382
383
384     ACPI_FUNCTION_TRACE ("AcpiDisableEvent");
385
386
387     /* Decode the Fixed Event */
388
389     if (Event > ACPI_EVENT_MAX)
390     {
391         return_ACPI_STATUS (AE_BAD_PARAMETER);
392     }
393
394     /*
395      * Disable the requested fixed event (by writing a zero to the
396      * enable register bit)
397      */
398     Status = AcpiSetRegister (AcpiGbl_FixedEventInfo[Event].EnableRegisterId,
399                 0, ACPI_MTX_LOCK);
400     if (ACPI_FAILURE (Status))
401     {
402         return_ACPI_STATUS (Status);
403     }
404
405     Status = AcpiGetRegister (AcpiGbl_FixedEventInfo[Event].EnableRegisterId,
406                 &Value, ACPI_MTX_LOCK);
407     if (ACPI_FAILURE (Status))
408     {
409         return_ACPI_STATUS (Status);
410     }
411
412     if (Value != 0)
413     {
414         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
415             "Could not disable %s events\n", AcpiUtGetEventName (Event)));
416         return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE);
417     }
418
419     return_ACPI_STATUS (Status);
420 }
421
422
423 /*******************************************************************************
424  *
425  * FUNCTION:    AcpiDisableGpe
426  *
427  * PARAMETERS:  GpeDevice       - Parent GPE Device
428  *              GpeNumber       - GPE level within the GPE block
429  *              Flags           - Just enable, or also wake enable?
430  *                                Called from ISR or not
431  *
432  * RETURN:      Status
433  *
434  * DESCRIPTION: Disable an ACPI event (general purpose)
435  *
436  ******************************************************************************/
437
438 ACPI_STATUS
439 AcpiDisableGpe (
440     ACPI_HANDLE             GpeDevice,
441     UINT32                  GpeNumber,
442     UINT32                  Flags)
443 {
444     ACPI_STATUS             Status = AE_OK;
445     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
446
447
448     ACPI_FUNCTION_TRACE ("AcpiDisableGpe");
449
450
451     /* Use semaphore lock if not executing at interrupt level */
452
453     if (Flags & ACPI_NOT_ISR)
454     {
455         Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
456         if (ACPI_FAILURE (Status))
457         {
458             return_ACPI_STATUS (Status);
459         }
460     }
461
462     /* Ensure that we have a valid GPE number */
463
464     GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
465     if (!GpeEventInfo)
466     {
467         Status = AE_BAD_PARAMETER;
468         goto UnlockAndExit;
469     }
470
471     /*
472      * Only disable the requested GPE number for wake if specified.
473      * Otherwise, turn it totally off
474      */
475     if (Flags & ACPI_EVENT_WAKE_DISABLE)
476     {
477         AcpiHwDisableGpeForWakeup (GpeEventInfo);
478     }
479     else
480     {
481         Status = AcpiHwDisableGpe (GpeEventInfo);
482     }
483
484 UnlockAndExit:
485     if (Flags & ACPI_NOT_ISR)
486     {
487         (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
488     }
489     return_ACPI_STATUS (Status);
490 }
491
492
493 /*******************************************************************************
494  *
495  * FUNCTION:    AcpiClearEvent
496  *
497  * PARAMETERS:  Event           - The fixed event to be cleared
498  *
499  * RETURN:      Status
500  *
501  * DESCRIPTION: Clear an ACPI event (fixed)
502  *
503  ******************************************************************************/
504
505 ACPI_STATUS
506 AcpiClearEvent (
507     UINT32                  Event)
508 {
509     ACPI_STATUS             Status = AE_OK;
510
511
512     ACPI_FUNCTION_TRACE ("AcpiClearEvent");
513
514
515     /* Decode the Fixed Event */
516
517     if (Event > ACPI_EVENT_MAX)
518     {
519         return_ACPI_STATUS (AE_BAD_PARAMETER);
520     }
521
522     /*
523      * Clear the requested fixed event (By writing a one to the
524      * status register bit)
525      */
526     Status = AcpiSetRegister (AcpiGbl_FixedEventInfo[Event].StatusRegisterId,
527             1, ACPI_MTX_LOCK);
528
529     return_ACPI_STATUS (Status);
530 }
531
532
533 /*******************************************************************************
534  *
535  * FUNCTION:    AcpiClearGpe
536  *
537  * PARAMETERS:  GpeDevice       - Parent GPE Device
538  *              GpeNumber       - GPE level within the GPE block
539  *              Flags           - Called from an ISR or not
540  *
541  * RETURN:      Status
542  *
543  * DESCRIPTION: Clear an ACPI event (general purpose)
544  *
545  ******************************************************************************/
546
547 ACPI_STATUS
548 AcpiClearGpe (
549     ACPI_HANDLE             GpeDevice,
550     UINT32                  GpeNumber,
551     UINT32                  Flags)
552 {
553     ACPI_STATUS             Status = AE_OK;
554     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
555
556
557     ACPI_FUNCTION_TRACE ("AcpiClearGpe");
558
559
560     /* Use semaphore lock if not executing at interrupt level */
561
562     if (Flags & ACPI_NOT_ISR)
563     {
564         Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
565         if (ACPI_FAILURE (Status))
566         {
567             return_ACPI_STATUS (Status);
568         }
569     }
570
571     /* Ensure that we have a valid GPE number */
572
573     GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
574     if (!GpeEventInfo)
575     {
576         Status = AE_BAD_PARAMETER;
577         goto UnlockAndExit;
578     }
579
580     Status = AcpiHwClearGpe (GpeEventInfo);
581
582 UnlockAndExit:
583     if (Flags & ACPI_NOT_ISR)
584     {
585         (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
586     }
587     return_ACPI_STATUS (Status);
588 }
589
590
591 /*******************************************************************************
592  *
593  * FUNCTION:    AcpiGetEventStatus
594  *
595  * PARAMETERS:  Event           - The fixed event
596  *              Event Status    - Where the current status of the event will
597  *                                be returned
598  *
599  * RETURN:      Status
600  *
601  * DESCRIPTION: Obtains and returns the current status of the event
602  *
603  ******************************************************************************/
604
605 ACPI_STATUS
606 AcpiGetEventStatus (
607     UINT32                  Event,
608     ACPI_EVENT_STATUS       *EventStatus)
609 {
610     ACPI_STATUS             Status = AE_OK;
611
612
613     ACPI_FUNCTION_TRACE ("AcpiGetEventStatus");
614
615
616     if (!EventStatus)
617     {
618         return_ACPI_STATUS (AE_BAD_PARAMETER);
619     }
620
621     /* Decode the Fixed Event */
622
623     if (Event > ACPI_EVENT_MAX)
624     {
625         return_ACPI_STATUS (AE_BAD_PARAMETER);
626     }
627
628     /* Get the status of the requested fixed event */
629
630     Status = AcpiGetRegister (AcpiGbl_FixedEventInfo[Event].StatusRegisterId,
631                     EventStatus, ACPI_MTX_LOCK);
632
633     return_ACPI_STATUS (Status);
634 }
635
636
637 /*******************************************************************************
638  *
639  * FUNCTION:    AcpiGetGpeStatus
640  *
641  * PARAMETERS:  GpeDevice       - Parent GPE Device
642  *              GpeNumber       - GPE level within the GPE block
643  *              Flags           - Called from an ISR or not
644  *              Event Status    - Where the current status of the event will
645  *                                be returned
646  *
647  * RETURN:      Status
648  *
649  * DESCRIPTION: Get status of an event (general purpose)
650  *
651  ******************************************************************************/
652
653 ACPI_STATUS
654 AcpiGetGpeStatus (
655     ACPI_HANDLE             GpeDevice,
656     UINT32                  GpeNumber,
657     UINT32                  Flags,
658     ACPI_EVENT_STATUS       *EventStatus)
659 {
660     ACPI_STATUS             Status = AE_OK;
661     ACPI_GPE_EVENT_INFO     *GpeEventInfo;
662
663
664     ACPI_FUNCTION_TRACE ("AcpiGetGpeStatus");
665
666
667     /* Use semaphore lock if not executing at interrupt level */
668
669     if (Flags & ACPI_NOT_ISR)
670     {
671         Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
672         if (ACPI_FAILURE (Status))
673         {
674             return_ACPI_STATUS (Status);
675         }
676     }
677
678     /* Ensure that we have a valid GPE number */
679
680     GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);
681     if (!GpeEventInfo)
682     {
683         Status = AE_BAD_PARAMETER;
684         goto UnlockAndExit;
685     }
686
687     /* Obtain status on the requested GPE number */
688
689     Status = AcpiHwGetGpeStatus (GpeEventInfo, EventStatus);
690
691 UnlockAndExit:
692     if (Flags & ACPI_NOT_ISR)
693     {
694         (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
695     }
696     return_ACPI_STATUS (Status);
697 }
698
699
700 /*******************************************************************************
701  *
702  * FUNCTION:    AcpiInstallGpeBlock
703  *
704  * PARAMETERS:  GpeDevice           - Handle to the parent GPE Block Device
705  *              GpeBlockAddress     - Address and SpaceID
706  *              RegisterCount       - Number of GPE register pairs in the block
707  *              InterruptLevel      - H/W interrupt for the block
708  *
709  * RETURN:      Status
710  *
711  * DESCRIPTION: Create and Install a block of GPE registers
712  *
713  ******************************************************************************/
714
715 ACPI_STATUS
716 AcpiInstallGpeBlock (
717     ACPI_HANDLE             GpeDevice,
718     ACPI_GENERIC_ADDRESS    *GpeBlockAddress,
719     UINT32                  RegisterCount,
720     UINT32                  InterruptLevel)
721 {
722     ACPI_STATUS             Status;
723     ACPI_OPERAND_OBJECT     *ObjDesc;
724     ACPI_NAMESPACE_NODE     *Node;
725     ACPI_GPE_BLOCK_INFO     *GpeBlock;
726
727
728     ACPI_FUNCTION_TRACE ("AcpiInstallGpeBlock");
729
730
731     if ((!GpeDevice)       ||
732         (!GpeBlockAddress) ||
733         (!RegisterCount))
734     {
735         return_ACPI_STATUS (AE_BAD_PARAMETER);
736     }
737
738     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
739     if (ACPI_FAILURE (Status))
740     {
741         return (Status);
742     }
743
744     Node = AcpiNsMapHandleToNode (GpeDevice);
745     if (!Node)
746     {
747         Status = AE_BAD_PARAMETER;
748         goto UnlockAndExit;
749     }
750
751     /*
752      * For user-installed GPE Block Devices, the GpeBlockBaseNumber
753      * is always zero
754      */
755     Status = AcpiEvCreateGpeBlock (Node, GpeBlockAddress, RegisterCount,
756                     0, InterruptLevel, &GpeBlock);
757     if (ACPI_FAILURE (Status))
758     {
759         goto UnlockAndExit;
760     }
761
762     /* Get the DeviceObject attached to the node */
763
764     ObjDesc = AcpiNsGetAttachedObject (Node);
765     if (!ObjDesc)
766     {
767         /* No object, create a new one */
768
769         ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_DEVICE);
770         if (!ObjDesc)
771         {
772             Status = AE_NO_MEMORY;
773             goto UnlockAndExit;
774         }
775
776         Status = AcpiNsAttachObject (Node, ObjDesc, ACPI_TYPE_DEVICE);
777
778         /* Remove local reference to the object */
779
780         AcpiUtRemoveReference (ObjDesc);
781
782         if (ACPI_FAILURE (Status))
783         {
784             goto UnlockAndExit;
785         }
786     }
787
788     /* Install the GPE block in the DeviceObject */
789
790     ObjDesc->Device.GpeBlock = GpeBlock;
791
792
793 UnlockAndExit:
794     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
795     return_ACPI_STATUS (Status);
796 }
797
798
799 /*******************************************************************************
800  *
801  * FUNCTION:    AcpiRemoveGpeBlock
802  *
803  * PARAMETERS:  GpeDevice           - Handle to the parent GPE Block Device
804  *
805  * RETURN:      Status
806  *
807  * DESCRIPTION: Remove a previously installed block of GPE registers
808  *
809  ******************************************************************************/
810
811 ACPI_STATUS
812 AcpiRemoveGpeBlock (
813     ACPI_HANDLE             GpeDevice)
814 {
815     ACPI_OPERAND_OBJECT     *ObjDesc;
816     ACPI_STATUS             Status;
817     ACPI_NAMESPACE_NODE     *Node;
818
819
820     ACPI_FUNCTION_TRACE ("AcpiRemoveGpeBlock");
821
822
823     if (!GpeDevice)
824     {
825         return_ACPI_STATUS (AE_BAD_PARAMETER);
826     }
827
828     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
829     if (ACPI_FAILURE (Status))
830     {
831         return (Status);
832     }
833
834     Node = AcpiNsMapHandleToNode (GpeDevice);
835     if (!Node)
836     {
837         Status = AE_BAD_PARAMETER;
838         goto UnlockAndExit;
839     }
840
841     /* Get the DeviceObject attached to the node */
842
843     ObjDesc = AcpiNsGetAttachedObject (Node);
844     if (!ObjDesc ||
845         !ObjDesc->Device.GpeBlock)
846     {
847         return_ACPI_STATUS (AE_NULL_OBJECT);
848     }
849
850     /* Delete the GPE block (but not the DeviceObject) */
851
852     Status = AcpiEvDeleteGpeBlock (ObjDesc->Device.GpeBlock);
853     if (ACPI_SUCCESS (Status))
854     {
855         ObjDesc->Device.GpeBlock = NULL;
856     }
857
858 UnlockAndExit:
859     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
860     return_ACPI_STATUS (Status);
861 }
862