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:      None
  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_get_sleep_type_data
 106  *
 107  * PARAMETERS:  sleep_state         - Numeric sleep state
 108  *              *sleep_type_a        - Where SLP_TYPa is returned
 109  *              *sleep_type_b        - Where SLP_TYPb is returned
 110  *
 111  * RETURN:      Status - ACPI status
 112  *
 113  * DESCRIPTION: Obtain the SLP_TYPa and SLP_TYPb values for the requested sleep
 114  *              state.
 115  *
 116  ******************************************************************************/
 117
 118 acpi_status
 119 acpi_get_sleep_type_data(u8 sleep_state, u8 * sleep_type_a, u8 * sleep_type_b)
 120 {
 121         acpi_status status = AE_OK;
 122         struct acpi_evaluate_info *info;
 123
 124         ACPI_FUNCTION_TRACE(acpi_get_sleep_type_data);
 125
 126         /* Validate parameters */
 127
 128         if ((sleep_state > ACPI_S_STATES_MAX) || !sleep_type_a || !sleep_type_b) {
 129                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 130         }
 131
 132         /* Allocate the evaluation information block */
 133
 134         info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
 135         if (!info) {
 136                 return_ACPI_STATUS(AE_NO_MEMORY);
 137         }
 138
 139         info->pathname =
 140             ACPI_CAST_PTR(char, acpi_gbl_sleep_state_names[sleep_state]);
 141
 142         /* Evaluate the namespace object containing the values for this state */
 143
 144         status = acpi_ns_evaluate(info);
 145         if (ACPI_FAILURE(status)) {
 146                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 147                                   "%s while evaluating SleepState [%s]\n",
 148                                   acpi_format_exception(status),
 149                                   info->pathname));
 150
 151                 goto cleanup;
 152         }
 153
 154         /* Must have a return object */
 155
 156         if (!info->return_object) {
 157                 ACPI_ERROR((AE_INFO, "No Sleep State object returned from [%s]",
 158                             info->pathname));
 159                 status = AE_NOT_EXIST;
 160         }
 161
 162         /* It must be of type Package */
 163
 164         else if (ACPI_GET_OBJECT_TYPE(info->return_object) != ACPI_TYPE_PACKAGE) {
 165                 ACPI_ERROR((AE_INFO,
 166                             "Sleep State return object is not a Package"));
 167                 status = AE_AML_OPERAND_TYPE;
 168         }
 169
 170         /*
 171          * The package must have at least two elements. NOTE (March 2005): This
 172          * goes against the current ACPI spec which defines this object as a
 173          * package with one encoded DWORD element. However, existing practice
 174          * by BIOS vendors seems to be to have 2 or more elements, at least
 175          * one per sleep type (A/B).
 176          */
 177         else if (info->return_object->package.count < 2) {
 178                 ACPI_ERROR((AE_INFO,
 179                             "Sleep State return package does not have at least two elements"));
 180                 status = AE_AML_NO_OPERAND;
 181         }
 182
 183         /* The first two elements must both be of type Integer */
 184
 185         else if ((ACPI_GET_OBJECT_TYPE(info->return_object->package.elements[0])
 186                   != ACPI_TYPE_INTEGER) ||
 187                  (ACPI_GET_OBJECT_TYPE(info->return_object->package.elements[1])
 188                   != ACPI_TYPE_INTEGER)) {
 189                 ACPI_ERROR((AE_INFO,
 190                             "Sleep State return package elements are not both Integers (%s, %s)",
 191                             acpi_ut_get_object_type_name(info->return_object->
 192                                                          package.elements[0]),
 193                             acpi_ut_get_object_type_name(info->return_object->
 194                                                          package.elements[1])));
 195                 status = AE_AML_OPERAND_TYPE;
 196         } else {
 197                 /* Valid _Sx_ package size, type, and value */
 198
 199                 *sleep_type_a = (u8)
 200                     (info->return_object->package.elements[0])->integer.value;
 201                 *sleep_type_b = (u8)
 202                     (info->return_object->package.elements[1])->integer.value;
 203         }
 204
 205         if (ACPI_FAILURE(status)) {
 206                 ACPI_EXCEPTION((AE_INFO, status,
 207                                 "While evaluating SleepState [%s], bad Sleep object %p type %s",
 208                                 info->pathname, info->return_object,
 209                                 acpi_ut_get_object_type_name(info->
 210                                                              return_object)));
 211         }
 212
 213         acpi_ut_remove_reference(info->return_object);
 214
 215       cleanup:
 216         ACPI_FREE(info);
 217         return_ACPI_STATUS(status);
 218 }
 219
 220 ACPI_EXPORT_SYMBOL(acpi_get_sleep_type_data)
 221
 222 /*******************************************************************************
 223  *
 224  * FUNCTION:    acpi_hw_get_register_bit_mask
 225  *
 226  * PARAMETERS:  register_id         - Index of ACPI Register to access
 227  *
 228  * RETURN:      The bitmask to be used when accessing the register
 229  *
 230  * DESCRIPTION: Map register_id into a register bitmask.
 231  *
 232  ******************************************************************************/
 233 struct acpi_bit_register_info *acpi_hw_get_bit_register_info(u32 register_id)
 234 {
 235         ACPI_FUNCTION_ENTRY();
 236
 237         if (register_id > ACPI_BITREG_MAX) {
 238                 ACPI_ERROR((AE_INFO, "Invalid BitRegister ID: %X",
 239                             register_id));
 240                 return (NULL);
 241         }
 242
 243         return (&acpi_gbl_bit_register_info[register_id]);
 244 }
 245
 246 ACPI_EXPORT_SYMBOL(acpi_get_register_unlocked)
 247
 248 /*******************************************************************************
 249  *
 250  * FUNCTION:    acpi_get_register
 251  *
 252  * PARAMETERS:  register_id     - ID of ACPI bit_register to access
 253  *              return_value    - Value that was read from the register
 254  *
 255  * RETURN:      Status and the value read from specified Register. Value
 256  *              returned is normalized to bit0 (is shifted all the way right)
 257  *
 258  * DESCRIPTION: ACPI bit_register read function.
 259  *
 260  ******************************************************************************/
 261
 262 acpi_status acpi_get_register_unlocked(u32 register_id, u32 * return_value)
 263 {
 264         u32 register_value = 0;
 265         struct acpi_bit_register_info *bit_reg_info;
 266         acpi_status status;
 267
 268         ACPI_FUNCTION_TRACE(acpi_get_register);
 269
 270         /* Get the info structure corresponding to the requested ACPI Register */
 271
 272         bit_reg_info = acpi_hw_get_bit_register_info(register_id);
 273         if (!bit_reg_info) {
 274                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 275         }
 276
 277         /* Read from the register */
 278
 279         status = acpi_hw_register_read(bit_reg_info->parent_register,
 280                                        &register_value);
 281
 282         if (ACPI_SUCCESS(status)) {
 283
 284                 /* Normalize the value that was read */
 285
 286                 register_value =
 287                     ((register_value & bit_reg_info->access_bit_mask)
 288                      >> bit_reg_info->bit_position);
 289
 290                 *return_value = register_value;
 291
 292                 ACPI_DEBUG_PRINT((ACPI_DB_IO, "Read value %8.8X register %X\n",
 293                                   register_value,
 294                                   bit_reg_info->parent_register));
 295         }
 296
 297         return_ACPI_STATUS(status);
 298 }
 299
 300 acpi_status acpi_get_register(u32 register_id, u32 * return_value)
 301 {
 302         acpi_status status;
 303         acpi_cpu_flags flags;
 304         flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
 305         status = acpi_get_register_unlocked(register_id, return_value);
 306         acpi_os_release_lock(acpi_gbl_hardware_lock, flags);
 307         return status;
 308 }
 309
 310 ACPI_EXPORT_SYMBOL(acpi_get_register)
 311
 312 /*******************************************************************************
 313  *
 314  * FUNCTION:    acpi_set_register
 315  *
 316  * PARAMETERS:  register_id     - ID of ACPI bit_register to access
 317  *              Value           - (only used on write) value to write to the
 318  *                                Register, NOT pre-normalized to the bit pos
 319  *
 320  * RETURN:      Status
 321  *
 322  * DESCRIPTION: ACPI Bit Register write function.
 323  *
 324  ******************************************************************************/
 325 acpi_status acpi_set_register(u32 register_id, u32 value)
 326 {
 327         u32 register_value = 0;
 328         struct acpi_bit_register_info *bit_reg_info;
 329         acpi_status status;
 330         acpi_cpu_flags lock_flags;
 331
 332         ACPI_FUNCTION_TRACE_U32(acpi_set_register, register_id);
 333
 334         /* Get the info structure corresponding to the requested ACPI Register */
 335
 336         bit_reg_info = acpi_hw_get_bit_register_info(register_id);
 337         if (!bit_reg_info) {
 338                 ACPI_ERROR((AE_INFO, "Bad ACPI HW RegisterId: %X",
 339                             register_id));
 340                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 341         }
 342
 343         lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
 344
 345         /* Always do a register read first so we can insert the new bits  */
 346
 347         status = acpi_hw_register_read(bit_reg_info->parent_register,
 348                                        &register_value);
 349         if (ACPI_FAILURE(status)) {
 350                 goto unlock_and_exit;
 351         }
 352
 353         /*
 354          * Decode the Register ID
 355          * Register ID = [Register block ID] | [bit ID]
 356          *
 357          * Check bit ID to fine locate Register offset.
 358          * Check Mask to determine Register offset, and then read-write.
 359          */
 360         switch (bit_reg_info->parent_register) {
 361         case ACPI_REGISTER_PM1_STATUS:
 362
 363                 /*
 364                  * Status Registers are different from the rest. Clear by
 365                  * writing 1, and writing 0 has no effect. So, the only relevant
 366                  * information is the single bit we're interested in, all others should
 367                  * be written as 0 so they will be left unchanged.
 368                  */
 369                 value = ACPI_REGISTER_PREPARE_BITS(value,
 370                                                    bit_reg_info->bit_position,
 371                                                    bit_reg_info->
 372                                                    access_bit_mask);
 373                 if (value) {
 374                         status = acpi_hw_register_write(ACPI_REGISTER_PM1_STATUS,
 375                                                         (u16) value);
 376                         register_value = 0;
 377                 }
 378                 break;
 379
 380         case ACPI_REGISTER_PM1_ENABLE:
 381
 382                 ACPI_REGISTER_INSERT_VALUE(register_value,
 383                                            bit_reg_info->bit_position,
 384                                            bit_reg_info->access_bit_mask,
 385                                            value);
 386
 387                 status = acpi_hw_register_write(ACPI_REGISTER_PM1_ENABLE,
 388                                                 (u16) register_value);
 389                 break;
 390
 391         case ACPI_REGISTER_PM1_CONTROL:
 392
 393                 /*
 394                  * Write the PM1 Control register.
 395                  * Note that at this level, the fact that there are actually TWO
 396                  * registers (A and B - and B may not exist) is abstracted.
 397                  */
 398                 ACPI_DEBUG_PRINT((ACPI_DB_IO, "PM1 control: Read %X\n",
 399                                   register_value));
 400
 401                 ACPI_REGISTER_INSERT_VALUE(register_value,
 402                                            bit_reg_info->bit_position,
 403                                            bit_reg_info->access_bit_mask,
 404                                            value);
 405
 406                 status = acpi_hw_register_write(ACPI_REGISTER_PM1_CONTROL,
 407                                                 (u16) register_value);
 408                 break;
 409
 410         case ACPI_REGISTER_PM2_CONTROL:
 411
 412                 status = acpi_hw_register_read(ACPI_REGISTER_PM2_CONTROL,
 413                                                &register_value);
 414                 if (ACPI_FAILURE(status)) {
 415                         goto unlock_and_exit;
 416                 }
 417
 418                 ACPI_DEBUG_PRINT((ACPI_DB_IO,
 419                                   "PM2 control: Read %X from %8.8X%8.8X\n",
 420                                   register_value,
 421                                   ACPI_FORMAT_UINT64(acpi_gbl_FADT.
 422                                                      xpm2_control_block.
 423                                                      address)));
 424
 425                 ACPI_REGISTER_INSERT_VALUE(register_value,
 426                                            bit_reg_info->bit_position,
 427                                            bit_reg_info->access_bit_mask,
 428                                            value);
 429
 430                 ACPI_DEBUG_PRINT((ACPI_DB_IO,
 431                                   "About to write %4.4X to %8.8X%8.8X\n",
 432                                   register_value,
 433                                   ACPI_FORMAT_UINT64(acpi_gbl_FADT.
 434                                                      xpm2_control_block.
 435                                                      address)));
 436
 437                 status = acpi_hw_register_write(ACPI_REGISTER_PM2_CONTROL,
 438                                                 (u8) (register_value));
 439                 break;
 440
 441         default:
 442                 break;
 443         }
 444
 445       unlock_and_exit:
 446
 447         acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags);
 448
 449         /* Normalize the value that was read */
 450
 451         ACPI_DEBUG_EXEC(register_value =
 452                         ((register_value & bit_reg_info->access_bit_mask) >>
 453                          bit_reg_info->bit_position));
 454
 455         ACPI_DEBUG_PRINT((ACPI_DB_IO,
 456                           "Set bits: %8.8X actual %8.8X register %X\n", value,
 457                           register_value, bit_reg_info->parent_register));
 458         return_ACPI_STATUS(status);
 459 }
 460
 461 ACPI_EXPORT_SYMBOL(acpi_set_register)
 462
 463 /******************************************************************************
 464  *
 465  * FUNCTION:    acpi_hw_register_read
 466  *
 467  * PARAMETERS:  register_id         - ACPI Register ID
 468  *              return_value        - Where the register value is returned
 469  *
 470  * RETURN:      Status and the value read.
 471  *
 472  * DESCRIPTION: Read from the specified ACPI register
 473  *
 474  ******************************************************************************/
 475 acpi_status
 476 acpi_hw_register_read(u32 register_id, u32 * return_value)
 477 {
 478         u32 value1 = 0;
 479         u32 value2 = 0;
 480         acpi_status status;
 481
 482         ACPI_FUNCTION_TRACE(hw_register_read);
 483
 484         switch (register_id) {
 485         case ACPI_REGISTER_PM1_STATUS:  /* 16-bit access */
 486
 487                 status = acpi_read(&value1, &acpi_gbl_FADT.xpm1a_event_block);
 488                 if (ACPI_FAILURE(status)) {
 489                         goto exit;
 490                 }
 491
 492                 /* PM1B is optional */
 493
 494                 status = acpi_read(&value2, &acpi_gbl_FADT.xpm1b_event_block);
 495                 value1 |= value2;
 496                 break;
 497
 498         case ACPI_REGISTER_PM1_ENABLE:  /* 16-bit access */
 499
 500                 status = acpi_read(&value1, &acpi_gbl_xpm1a_enable);
 501                 if (ACPI_FAILURE(status)) {
 502                         goto exit;
 503                 }
 504
 505                 /* PM1B is optional */
 506
 507                 status = acpi_read(&value2, &acpi_gbl_xpm1b_enable);
 508                 value1 |= value2;
 509                 break;
 510
 511         case ACPI_REGISTER_PM1_CONTROL: /* 16-bit access */
 512
 513                 status = acpi_read(&value1, &acpi_gbl_FADT.xpm1a_control_block);
 514                 if (ACPI_FAILURE(status)) {
 515                         goto exit;
 516                 }
 517
 518                 status = acpi_read(&value2, &acpi_gbl_FADT.xpm1b_control_block);
 519                 value1 |= value2;
 520                 break;
 521
 522         case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
 523
 524                 status = acpi_read(&value1, &acpi_gbl_FADT.xpm2_control_block);
 525                 break;
 526
 527         case ACPI_REGISTER_PM_TIMER:    /* 32-bit access */
 528
 529                 status = acpi_read(&value1, &acpi_gbl_FADT.xpm_timer_block);
 530                 break;
 531
 532         case ACPI_REGISTER_SMI_COMMAND_BLOCK:   /* 8-bit access */
 533
 534                 status =
 535                     acpi_os_read_port(acpi_gbl_FADT.smi_command, &value1, 8);
 536                 break;
 537
 538         default:
 539                 ACPI_ERROR((AE_INFO, "Unknown Register ID: %X", register_id));
 540                 status = AE_BAD_PARAMETER;
 541                 break;
 542         }
 543
 544       exit:
 545
 546         if (ACPI_SUCCESS(status)) {
 547                 *return_value = value1;
 548         }
 549
 550         return_ACPI_STATUS(status);
 551 }
 552
 553 /******************************************************************************
 554  *
 555  * FUNCTION:    acpi_hw_register_write
 556  *
 557  * PARAMETERS:  register_id         - ACPI Register ID
 558  *              Value               - The value to write
 559  *
 560  * RETURN:      Status
 561  *
 562  * DESCRIPTION: Write to the specified ACPI register
 563  *
 564  * NOTE: In accordance with the ACPI specification, this function automatically
 565  * preserves the value of the following bits, meaning that these bits cannot be
 566  * changed via this interface:
 567  *
 568  * PM1_CONTROL[0] = SCI_EN
 569  * PM1_CONTROL[9]
 570  * PM1_STATUS[11]
 571  *
 572  * ACPI References:
 573  * 1) Hardware Ignored Bits: When software writes to a register with ignored
 574  *      bit fields, it preserves the ignored bit fields
 575  * 2) SCI_EN: OSPM always preserves this bit position
 576  *
 577  ******************************************************************************/
 578
 579 acpi_status acpi_hw_register_write(u32 register_id, u32 value)
 580 {
 581         acpi_status status;
 582         u32 read_value;
 583
 584         ACPI_FUNCTION_TRACE(hw_register_write);
 585
 586         switch (register_id) {
 587         case ACPI_REGISTER_PM1_STATUS:  /* 16-bit access */
 588
 589                 /* Perform a read first to preserve certain bits (per ACPI spec) */
 590
 591                 status = acpi_hw_register_read(ACPI_REGISTER_PM1_STATUS,
 592                                                &read_value);
 593                 if (ACPI_FAILURE(status)) {
 594                         goto exit;
 595                 }
 596
 597                 /* Insert the bits to be preserved */
 598
 599                 ACPI_INSERT_BITS(value, ACPI_PM1_STATUS_PRESERVED_BITS,
 600                                  read_value);
 601
 602                 /* Now we can write the data */
 603
 604                 status = acpi_write(value, &acpi_gbl_FADT.xpm1a_event_block);
 605                 if (ACPI_FAILURE(status)) {
 606                         goto exit;
 607                 }
 608
 609                 /* PM1B is optional */
 610
 611                 status = acpi_write(value, &acpi_gbl_FADT.xpm1b_event_block);
 612                 break;
 613
 614         case ACPI_REGISTER_PM1_ENABLE:  /* 16-bit access */
 615
 616                 status = acpi_write(value, &acpi_gbl_xpm1a_enable);
 617                 if (ACPI_FAILURE(status)) {
 618                         goto exit;
 619                 }
 620
 621                 /* PM1B is optional */
 622
 623                 status = acpi_write(value, &acpi_gbl_xpm1b_enable);
 624                 break;
 625
 626         case ACPI_REGISTER_PM1_CONTROL: /* 16-bit access */
 627
 628                 /*
 629                  * Perform a read first to preserve certain bits (per ACPI spec)
 630                  */
 631                 status = acpi_hw_register_read(ACPI_REGISTER_PM1_CONTROL,
 632                                                &read_value);
 633                 if (ACPI_FAILURE(status)) {
 634                         goto exit;
 635                 }
 636
 637                 /* Insert the bits to be preserved */
 638
 639                 ACPI_INSERT_BITS(value, ACPI_PM1_CONTROL_PRESERVED_BITS,
 640                                  read_value);
 641
 642                 /* Now we can write the data */
 643
 644                 status = acpi_write(value, &acpi_gbl_FADT.xpm1a_control_block);
 645                 if (ACPI_FAILURE(status)) {
 646                         goto exit;
 647                 }
 648
 649                 status = acpi_write(value, &acpi_gbl_FADT.xpm1b_control_block);
 650                 break;
 651
 652         case ACPI_REGISTER_PM1A_CONTROL:        /* 16-bit access */
 653
 654                 status = acpi_write(value, &acpi_gbl_FADT.xpm1a_control_block);
 655                 break;
 656
 657         case ACPI_REGISTER_PM1B_CONTROL:        /* 16-bit access */
 658
 659                 status = acpi_write(value, &acpi_gbl_FADT.xpm1b_control_block);
 660                 break;
 661
 662         case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
 663
 664                 status = acpi_write(value, &acpi_gbl_FADT.xpm2_control_block);
 665                 break;
 666
 667         case ACPI_REGISTER_PM_TIMER:    /* 32-bit access */
 668
 669                 status = acpi_write(value, &acpi_gbl_FADT.xpm_timer_block);
 670                 break;
 671
 672         case ACPI_REGISTER_SMI_COMMAND_BLOCK:   /* 8-bit access */
 673
 674                 /* SMI_CMD is currently always in IO space */
 675
 676                 status =
 677                     acpi_os_write_port(acpi_gbl_FADT.smi_command, value, 8);
 678                 break;
 679
 680         default:
 681                 status = AE_BAD_PARAMETER;
 682                 break;
 683         }
 684
 685       exit:
 686         return_ACPI_STATUS(status);
 687 }
 688
 689 /******************************************************************************
 690  *
 691  * FUNCTION:    acpi_read
 692  *
 693  * PARAMETERS:  Value               - Where the value is returned
 694  *              Reg                 - GAS register structure
 695  *
 696  * RETURN:      Status
 697  *
 698  * DESCRIPTION: Read from either memory or IO space.
 699  *
 700  ******************************************************************************/
 701
 702 acpi_status acpi_read(u32 *value, struct acpi_generic_address *reg)
 703 {
 704         u32 width;
 705         u64 address;
 706         acpi_status status;
 707
 708         ACPI_FUNCTION_NAME(acpi_read);
 709
 710         /*
 711          * Must have a valid pointer to a GAS structure, and
 712          * a non-zero address within. However, don't return an error
 713          * because the PM1A/B code must not fail if B isn't present.
 714          */
 715         if (!reg) {
 716                 return (AE_OK);
 717         }
 718
 719         /* Get a local copy of the address. Handles possible alignment issues */
 720
 721         ACPI_MOVE_64_TO_64(&address, &reg->address);
 722         if (!address) {
 723                 return (AE_OK);
 724         }
 725
 726         /* Supported widths are 8/16/32 */
 727
 728         width = reg->bit_width;
 729         if ((width != 8) && (width != 16) && (width != 32)) {
 730                 return (AE_SUPPORT);
 731         }
 732
 733         /* Initialize entire 32-bit return value to zero */
 734
 735         *value = 0;
 736
 737         /*
 738          * Two address spaces supported: Memory or IO.
 739          * PCI_Config is not supported here because the GAS struct is insufficient
 740          */
 741         switch (reg->space_id) {
 742         case ACPI_ADR_SPACE_SYSTEM_MEMORY:
 743
 744                 status = acpi_os_read_memory((acpi_physical_address) address,
 745                                              value, width);
 746                 break;
 747
 748         case ACPI_ADR_SPACE_SYSTEM_IO:
 749
 750                 status =
 751                     acpi_os_read_port((acpi_io_address) address, value, width);
 752                 break;
 753
 754         default:
 755                 ACPI_ERROR((AE_INFO,
 756                             "Unsupported address space: %X", reg->space_id));
 757                 return (AE_BAD_PARAMETER);
 758         }
 759
 760         ACPI_DEBUG_PRINT((ACPI_DB_IO,
 761                           "Read:  %8.8X width %2d from %8.8X%8.8X (%s)\n",
 762                           *value, width, ACPI_FORMAT_UINT64(address),
 763                           acpi_ut_get_region_name(reg->space_id)));
 764
 765         return (status);
 766 }
 767
 768 ACPI_EXPORT_SYMBOL(acpi_read)
 769
 770 /******************************************************************************
 771  *
 772  * FUNCTION:    acpi_write
 773  *
 774  * PARAMETERS:  Value               - To be written
 775  *              Reg                 - GAS register structure
 776  *
 777  * RETURN:      Status
 778  *
 779  * DESCRIPTION: Write to either memory or IO space.
 780  *
 781  ******************************************************************************/
 782
 783 acpi_status
 784 acpi_write(u32 value, struct acpi_generic_address *reg)
 785 {
 786         u32 width;
 787         u64 address;
 788         acpi_status status;
 789
 790         ACPI_FUNCTION_NAME(acpi_write);
 791
 792         /*
 793          * Must have a valid pointer to a GAS structure, and
 794          * a non-zero address within. However, don't return an error
 795          * because the PM1A/B code must not fail if B isn't present.
 796          */
 797         if (!reg) {
 798                 return (AE_OK);
 799         }
 800
 801         /* Get a local copy of the address. Handles possible alignment issues */
 802
 803         ACPI_MOVE_64_TO_64(&address, &reg->address);
 804         if (!address) {
 805                 return (AE_OK);
 806         }
 807
 808         /* Supported widths are 8/16/32 */
 809
 810         width = reg->bit_width;
 811         if ((width != 8) && (width != 16) && (width != 32)) {
 812                 return (AE_SUPPORT);
 813         }
 814
 815         /*
 816          * Two address spaces supported: Memory or IO.
 817          * PCI_Config is not supported here because the GAS struct is insufficient
 818          */
 819         switch (reg->space_id) {
 820         case ACPI_ADR_SPACE_SYSTEM_MEMORY:
 821
 822                 status = acpi_os_write_memory((acpi_physical_address) address,
 823                                               value, width);
 824                 break;
 825
 826         case ACPI_ADR_SPACE_SYSTEM_IO:
 827
 828                 status = acpi_os_write_port((acpi_io_address) address, value,
 829                                             width);
 830                 break;
 831
 832         default:
 833                 ACPI_ERROR((AE_INFO,
 834                             "Unsupported address space: %X", reg->space_id));
 835                 return (AE_BAD_PARAMETER);
 836         }
 837
 838         ACPI_DEBUG_PRINT((ACPI_DB_IO,
 839                           "Wrote: %8.8X width %2d   to %8.8X%8.8X (%s)\n",
 840                           value, width, ACPI_FORMAT_UINT64(address),
 841                           acpi_ut_get_region_name(reg->space_id)));
 842
 843         return (status);
 844 }
 845
 846 ACPI_EXPORT_SYMBOL(acpi_write)