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