drivers/acpi/hardware/hwregs.c

   1
   2 /*******************************************************************************
   3  *
   4  * Module Name: hwregs - Read/write access functions for the various ACPI
   5  *                       control and status registers.
   6  *
   7  ******************************************************************************/
   8
   9 /*
  10  * Copyright (C) 2000 - 2008, Intel Corp.
  11  * All rights reserved.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions, and the following disclaimer,
  18  *    without modification.
  19  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  20  *    substantially similar to the "NO WARRANTY" disclaimer below
  21  *    ("Disclaimer") and any redistribution must be conditioned upon
  22  *    including a substantially similar Disclaimer requirement for further
  23  *    binary redistribution.
  24  * 3. Neither the names of the above-listed copyright holders nor the names
  25  *    of any contributors may be used to endorse or promote products derived
  26  *    from this software without specific prior written permission.
  27  *
  28  * Alternatively, this software may be distributed under the terms of the
  29  * GNU General Public License ("GPL") version 2 as published by the Free
  30  * Software Foundation.
  31  *
  32  * NO WARRANTY
  33  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  34  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  35  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  36  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  37  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  38  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  39  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  40  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  41  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  42  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  43  * POSSIBILITY OF SUCH DAMAGES.
  44  */
  45
  46 #include <acpi/acpi.h>
  47 #include <acpi/acnamesp.h>
  48 #include <acpi/acevents.h>
  49
  50 #define _COMPONENT          ACPI_HARDWARE
  51 ACPI_MODULE_NAME("hwregs")
  52
  53 /*******************************************************************************
  54  *
  55  * FUNCTION:    acpi_hw_clear_acpi_status
  56  *
  57  * PARAMETERS:  None
  58  *
  59  * RETURN:      Status
  60  *
  61  * DESCRIPTION: Clears all fixed and general purpose status bits
  62  *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
  63  *
  64  ******************************************************************************/
  65 acpi_status acpi_hw_clear_acpi_status(void)
  66 {
  67         acpi_status status;
  68         acpi_cpu_flags lock_flags = 0;
  69
  70         ACPI_FUNCTION_TRACE(hw_clear_acpi_status);
  71
  72         ACPI_DEBUG_PRINT((ACPI_DB_IO, "About to write %04X to %04X\n",
  73                           ACPI_BITMASK_ALL_FIXED_STATUS,
  74                           (u16) acpi_gbl_FADT.xpm1a_event_block.address));
  75
  76         lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
  77
  78         status = acpi_hw_register_write(ACPI_REGISTER_PM1_STATUS,
  79                                         ACPI_BITMASK_ALL_FIXED_STATUS);
  80         if (ACPI_FAILURE(status)) {
  81                 goto unlock_and_exit;
  82         }
  83
  84         /* Clear the fixed events */
  85
  86         if (acpi_gbl_FADT.xpm1b_event_block.address) {
  87                 status = acpi_write(ACPI_BITMASK_ALL_FIXED_STATUS,
  88                                     &acpi_gbl_FADT.xpm1b_event_block);
  89                 if (ACPI_FAILURE(status)) {
  90                         goto unlock_and_exit;
  91                 }
  92         }
  93
  94         /* Clear the GPE Bits in all GPE registers in all GPE blocks */
  95
  96         status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block, NULL);
  97
  98       unlock_and_exit:
  99         acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags);
 100         return_ACPI_STATUS(status);
 101 }
 102
 103 /*******************************************************************************
 104  *
 105  * FUNCTION:    acpi_hw_get_register_bit_mask
 106  *
 107  * PARAMETERS:  register_id         - Index of ACPI Register to access
 108  *
 109  * RETURN:      The bitmask to be used when accessing the register
 110  *
 111  * DESCRIPTION: Map register_id into a register bitmask.
 112  *
 113  ******************************************************************************/
 114
 115 struct acpi_bit_register_info *acpi_hw_get_bit_register_info(u32 register_id)
 116 {
 117         ACPI_FUNCTION_ENTRY();
 118
 119         if (register_id > ACPI_BITREG_MAX) {
 120                 ACPI_ERROR((AE_INFO, "Invalid BitRegister ID: %X",
 121                             register_id));
 122                 return (NULL);
 123         }
 124
 125         return (&acpi_gbl_bit_register_info[register_id]);
 126 }
 127
 128 /******************************************************************************
 129  *
 130  * FUNCTION:    acpi_hw_register_read
 131  *
 132  * PARAMETERS:  register_id         - ACPI Register ID
 133  *              return_value        - Where the register value is returned
 134  *
 135  * RETURN:      Status and the value read.
 136  *
 137  * DESCRIPTION: Read from the specified ACPI register
 138  *
 139  ******************************************************************************/
 140 acpi_status
 141 acpi_hw_register_read(u32 register_id, u32 * return_value)
 142 {
 143         u32 value1 = 0;
 144         u32 value2 = 0;
 145         acpi_status status;
 146
 147         ACPI_FUNCTION_TRACE(hw_register_read);
 148
 149         switch (register_id) {
 150         case ACPI_REGISTER_PM1_STATUS:  /* 16-bit access */
 151
 152                 status = acpi_read(&value1, &acpi_gbl_FADT.xpm1a_event_block);
 153                 if (ACPI_FAILURE(status)) {
 154                         goto exit;
 155                 }
 156
 157                 /* PM1B is optional */
 158
 159                 status = acpi_read(&value2, &acpi_gbl_FADT.xpm1b_event_block);
 160                 value1 |= value2;
 161                 break;
 162
 163         case ACPI_REGISTER_PM1_ENABLE:  /* 16-bit access */
 164
 165                 status = acpi_read(&value1, &acpi_gbl_xpm1a_enable);
 166                 if (ACPI_FAILURE(status)) {
 167                         goto exit;
 168                 }
 169
 170                 /* PM1B is optional */
 171
 172                 status = acpi_read(&value2, &acpi_gbl_xpm1b_enable);
 173                 value1 |= value2;
 174                 break;
 175
 176         case ACPI_REGISTER_PM1_CONTROL: /* 16-bit access */
 177
 178                 status = acpi_read(&value1, &acpi_gbl_FADT.xpm1a_control_block);
 179                 if (ACPI_FAILURE(status)) {
 180                         goto exit;
 181                 }
 182
 183                 status = acpi_read(&value2, &acpi_gbl_FADT.xpm1b_control_block);
 184                 value1 |= value2;
 185                 break;
 186
 187         case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
 188
 189                 status = acpi_read(&value1, &acpi_gbl_FADT.xpm2_control_block);
 190                 break;
 191
 192         case ACPI_REGISTER_PM_TIMER:    /* 32-bit access */
 193
 194                 status = acpi_read(&value1, &acpi_gbl_FADT.xpm_timer_block);
 195                 break;
 196
 197         case ACPI_REGISTER_SMI_COMMAND_BLOCK:   /* 8-bit access */
 198
 199                 status =
 200                     acpi_os_read_port(acpi_gbl_FADT.smi_command, &value1, 8);
 201                 break;
 202
 203         default:
 204                 ACPI_ERROR((AE_INFO, "Unknown Register ID: %X", register_id));
 205                 status = AE_BAD_PARAMETER;
 206                 break;
 207         }
 208
 209       exit:
 210
 211         if (ACPI_SUCCESS(status)) {
 212                 *return_value = value1;
 213         }
 214
 215         return_ACPI_STATUS(status);
 216 }
 217
 218 /******************************************************************************
 219  *
 220  * FUNCTION:    acpi_hw_register_write
 221  *
 222  * PARAMETERS:  register_id         - ACPI Register ID
 223  *              Value               - The value to write
 224  *
 225  * RETURN:      Status
 226  *
 227  * DESCRIPTION: Write to the specified ACPI register
 228  *
 229  * NOTE: In accordance with the ACPI specification, this function automatically
 230  * preserves the value of the following bits, meaning that these bits cannot be
 231  * changed via this interface:
 232  *
 233  * PM1_CONTROL[0] = SCI_EN
 234  * PM1_CONTROL[9]
 235  * PM1_STATUS[11]
 236  *
 237  * ACPI References:
 238  * 1) Hardware Ignored Bits: When software writes to a register with ignored
 239  *      bit fields, it preserves the ignored bit fields
 240  * 2) SCI_EN: OSPM always preserves this bit position
 241  *
 242  ******************************************************************************/
 243
 244 acpi_status acpi_hw_register_write(u32 register_id, u32 value)
 245 {
 246         acpi_status status;
 247         u32 read_value;
 248
 249         ACPI_FUNCTION_TRACE(hw_register_write);
 250
 251         switch (register_id) {
 252         case ACPI_REGISTER_PM1_STATUS:  /* 16-bit access */
 253
 254                 /* Perform a read first to preserve certain bits (per ACPI spec) */
 255
 256                 status = acpi_hw_register_read(ACPI_REGISTER_PM1_STATUS,
 257                                                &read_value);
 258                 if (ACPI_FAILURE(status)) {
 259                         goto exit;
 260                 }
 261
 262                 /* Insert the bits to be preserved */
 263
 264                 ACPI_INSERT_BITS(value, ACPI_PM1_STATUS_PRESERVED_BITS,
 265                                  read_value);
 266
 267                 /* Now we can write the data */
 268
 269                 status = acpi_write(value, &acpi_gbl_FADT.xpm1a_event_block);
 270                 if (ACPI_FAILURE(status)) {
 271                         goto exit;
 272                 }
 273
 274                 /* PM1B is optional */
 275
 276                 status = acpi_write(value, &acpi_gbl_FADT.xpm1b_event_block);
 277                 break;
 278
 279         case ACPI_REGISTER_PM1_ENABLE:  /* 16-bit access */
 280
 281                 status = acpi_write(value, &acpi_gbl_xpm1a_enable);
 282                 if (ACPI_FAILURE(status)) {
 283                         goto exit;
 284                 }
 285
 286                 /* PM1B is optional */
 287
 288                 status = acpi_write(value, &acpi_gbl_xpm1b_enable);
 289                 break;
 290
 291         case ACPI_REGISTER_PM1_CONTROL: /* 16-bit access */
 292
 293                 /*
 294                  * Perform a read first to preserve certain bits (per ACPI spec)
 295                  */
 296                 status = acpi_hw_register_read(ACPI_REGISTER_PM1_CONTROL,
 297                                                &read_value);
 298                 if (ACPI_FAILURE(status)) {
 299                         goto exit;
 300                 }
 301
 302                 /* Insert the bits to be preserved */
 303
 304                 ACPI_INSERT_BITS(value, ACPI_PM1_CONTROL_PRESERVED_BITS,
 305                                  read_value);
 306
 307                 /* Now we can write the data */
 308
 309                 status = acpi_write(value, &acpi_gbl_FADT.xpm1a_control_block);
 310                 if (ACPI_FAILURE(status)) {
 311                         goto exit;
 312                 }
 313
 314                 status = acpi_write(value, &acpi_gbl_FADT.xpm1b_control_block);
 315                 break;
 316
 317         case ACPI_REGISTER_PM1A_CONTROL:        /* 16-bit access */
 318
 319                 status = acpi_write(value, &acpi_gbl_FADT.xpm1a_control_block);
 320                 break;
 321
 322         case ACPI_REGISTER_PM1B_CONTROL:        /* 16-bit access */
 323
 324                 status = acpi_write(value, &acpi_gbl_FADT.xpm1b_control_block);
 325                 break;
 326
 327         case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
 328
 329                 status = acpi_write(value, &acpi_gbl_FADT.xpm2_control_block);
 330                 break;
 331
 332         case ACPI_REGISTER_PM_TIMER:    /* 32-bit access */
 333
 334                 status = acpi_write(value, &acpi_gbl_FADT.xpm_timer_block);
 335                 break;
 336
 337         case ACPI_REGISTER_SMI_COMMAND_BLOCK:   /* 8-bit access */
 338
 339                 /* SMI_CMD is currently always in IO space */
 340
 341                 status =
 342                     acpi_os_write_port(acpi_gbl_FADT.smi_command, value, 8);
 343                 break;
 344
 345         default:
 346                 status = AE_BAD_PARAMETER;
 347                 break;
 348         }
 349
 350       exit:
 351         return_ACPI_STATUS(status);
 352 }