drivers/acpi/hardware/hwgpe.c

   1 /******************************************************************************
   2  *
   3  * Module Name: hwgpe - Low level GPE enable/disable/clear functions
   4  *              $Revision: 25 $
   5  *
   6  *****************************************************************************/
   7
   8 /*
   9  *  Copyright (C) 2000 R. Byron Moore
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24  */
  25
  26 #include "acpi.h"
  27 #include "achware.h"
  28 #include "acnamesp.h"
  29 #include "acevents.h"
  30
  31 #define _COMPONENT          HARDWARE
  32          MODULE_NAME         ("hwgpe")
  33
  34
  35 /******************************************************************************
  36  *
  37  * FUNCTION:    Acpi_hw_enable_gpe
  38  *
  39  * PARAMETERS:  Gpe_number      - The GPE
  40  *
  41  * RETURN:      None
  42  *
  43  * DESCRIPTION: Enable a single GPE.
  44  *
  45  ******************************************************************************/
  46
  47 void
  48 acpi_hw_enable_gpe (
  49         u32                     gpe_number)
  50 {
  51         u8                      in_byte;
  52         u32                     register_index;
  53         u8                      bit_mask;
  54
  55         /*
  56          * Translate GPE number to index into global registers array.
  57          */
  58         register_index = acpi_gbl_gpe_valid[gpe_number];
  59
  60         /*
  61          * Figure out the bit offset for this GPE within the target register.
  62          */
  63         bit_mask = acpi_gbl_decode_to8bit [MOD_8 (gpe_number)];
  64
  65         /*
  66          * Read the current value of the register, set the appropriate bit
  67          * to enable the GPE, and write out the new register.
  68          */
  69         in_byte = acpi_os_in8 (acpi_gbl_gpe_registers[register_index].enable_addr);
  70         acpi_os_out8 (acpi_gbl_gpe_registers[register_index].enable_addr,
  71                          (u8)(in_byte | bit_mask));
  72 }
  73
  74
  75 /******************************************************************************
  76  *
  77  * FUNCTION:    Acpi_hw_disable_gpe
  78  *
  79  * PARAMETERS:  Gpe_number      - The GPE
  80  *
  81  * RETURN:      None
  82  *
  83  * DESCRIPTION: Disable a single GPE.
  84  *
  85  ******************************************************************************/
  86
  87 void
  88 acpi_hw_disable_gpe (
  89         u32                     gpe_number)
  90 {
  91         u8                      in_byte;
  92         u32                     register_index;
  93         u8                      bit_mask;
  94
  95         /*
  96          * Translate GPE number to index into global registers array.
  97          */
  98         register_index = acpi_gbl_gpe_valid[gpe_number];
  99
 100         /*
 101          * Figure out the bit offset for this GPE within the target register.
 102          */
 103         bit_mask = acpi_gbl_decode_to8bit [MOD_8 (gpe_number)];
 104
 105         /*
 106          * Read the current value of the register, clear the appropriate bit,
 107          * and write out the new register value to disable the GPE.
 108          */
 109         in_byte = acpi_os_in8 (acpi_gbl_gpe_registers[register_index].enable_addr);
 110         acpi_os_out8 (acpi_gbl_gpe_registers[register_index].enable_addr,
 111                          (u8)(in_byte & ~bit_mask));
 112 }
 113
 114
 115 /******************************************************************************
 116  *
 117  * FUNCTION:    Acpi_hw_clear_gpe
 118  *
 119  * PARAMETERS:  Gpe_number      - The GPE
 120  *
 121  * RETURN:      None
 122  *
 123  * DESCRIPTION: Clear a single GPE.
 124  *
 125  ******************************************************************************/
 126
 127 void
 128 acpi_hw_clear_gpe (
 129         u32                     gpe_number)
 130 {
 131         u32                     register_index;
 132         u8                      bit_mask;
 133
 134         /*
 135          * Translate GPE number to index into global registers array.
 136          */
 137         register_index = acpi_gbl_gpe_valid[gpe_number];
 138
 139         /*
 140          * Figure out the bit offset for this GPE within the target register.
 141          */
 142         bit_mask = acpi_gbl_decode_to8bit [MOD_8 (gpe_number)];
 143
 144         /*
 145          * Write a one to the appropriate bit in the status register to
 146          * clear this GPE.
 147          */
 148         acpi_os_out8 (acpi_gbl_gpe_registers[register_index].status_addr, bit_mask);
 149 }
 150
 151
 152 /******************************************************************************
 153  *
 154  * FUNCTION:    Acpi_hw_get_gpe_status
 155  *
 156  * PARAMETERS:  Gpe_number      - The GPE
 157  *
 158  * RETURN:      None
 159  *
 160  * DESCRIPTION: Return the status of a single GPE.
 161  *
 162  ******************************************************************************/
 163
 164 void
 165 acpi_hw_get_gpe_status (
 166         u32                     gpe_number,
 167         ACPI_EVENT_STATUS       *event_status)
 168 {
 169         u8                      in_byte = 0;
 170         u32                     register_index = 0;
 171         u8                      bit_mask = 0;
 172
 173         if (!event_status) {
 174                 return;
 175         }
 176
 177         (*event_status) = 0;
 178
 179         /*
 180          * Translate GPE number to index into global registers array.
 181          */
 182         register_index = acpi_gbl_gpe_valid[gpe_number];
 183
 184         /*
 185          * Figure out the bit offset for this GPE within the target register.
 186          */
 187         bit_mask = acpi_gbl_decode_to8bit [MOD_8 (gpe_number)];
 188
 189         /*
 190          * Enabled?:
 191          */
 192         in_byte = acpi_os_in8 (acpi_gbl_gpe_registers[register_index].enable_addr);
 193
 194         if (bit_mask & in_byte) {
 195                 (*event_status) |= ACPI_EVENT_FLAG_ENABLED;
 196         }
 197
 198         /*
 199          * Set?
 200          */
 201         in_byte = acpi_os_in8 (acpi_gbl_gpe_registers[register_index].status_addr);
 202
 203         if (bit_mask & in_byte) {
 204                 (*event_status) |= ACPI_EVENT_FLAG_SET;
 205         }
 206 }