hwregs.c 19.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9

/*******************************************************************************
 *
 * Module Name: hwregs - Read/write access functions for the various ACPI
 *                       control and status registers.
 *
 ******************************************************************************/

/*
10
 * Copyright (C) 2000 - 2012, Intel Corp.
L
Linus Torvalds 已提交
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer,
 *    without modification.
 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 *    substantially similar to the "NO WARRANTY" disclaimer below
 *    ("Disclaimer") and any redistribution must be conditioned upon
 *    including a substantially similar Disclaimer requirement for further
 *    binary redistribution.
 * 3. Neither the names of the above-listed copyright holders nor the names
 *    of any contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * NO WARRANTY
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 */

#include <acpi/acpi.h>
L
Len Brown 已提交
47 48 49
#include "accommon.h"
#include "acnamesp.h"
#include "acevents.h"
L
Linus Torvalds 已提交
50 51

#define _COMPONENT          ACPI_HARDWARE
L
Len Brown 已提交
52
ACPI_MODULE_NAME("hwregs")
L
Linus Torvalds 已提交
53

54
#if (!ACPI_REDUCED_HARDWARE)
55 56 57 58 59 60 61 62 63 64 65
/* Local Prototypes */
static acpi_status
acpi_hw_read_multiple(u32 *value,
		      struct acpi_generic_address *register_a,
		      struct acpi_generic_address *register_b);

static acpi_status
acpi_hw_write_multiple(u32 value,
		       struct acpi_generic_address *register_a,
		       struct acpi_generic_address *register_b);

66 67
#endif				/* !ACPI_REDUCED_HARDWARE */

68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
/******************************************************************************
 *
 * FUNCTION:    acpi_hw_validate_register
 *
 * PARAMETERS:  Reg                 - GAS register structure
 *              max_bit_width       - Max bit_width supported (32 or 64)
 *              Address             - Pointer to where the gas->address
 *                                    is returned
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Validate the contents of a GAS register. Checks the GAS
 *              pointer, Address, space_id, bit_width, and bit_offset.
 *
 ******************************************************************************/

acpi_status
acpi_hw_validate_register(struct acpi_generic_address *reg,
			  u8 max_bit_width, u64 *address)
{

	/* Must have a valid pointer to a GAS structure */

	if (!reg) {
		return (AE_BAD_PARAMETER);
	}

	/*
	 * Copy the target address. This handles possible alignment issues.
	 * Address must not be null. A null address also indicates an optional
	 * ACPI register that is not supported, so no error message.
	 */
	ACPI_MOVE_64_TO_64(address, &reg->address);
	if (!(*address)) {
		return (AE_BAD_ADDRESS);
	}

	/* Validate the space_iD */

	if ((reg->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&
	    (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO)) {
		ACPI_ERROR((AE_INFO,
			    "Unsupported address space: 0x%X", reg->space_id));
		return (AE_SUPPORT);
	}

	/* Validate the bit_width */

	if ((reg->bit_width != 8) &&
	    (reg->bit_width != 16) &&
	    (reg->bit_width != 32) && (reg->bit_width != max_bit_width)) {
		ACPI_ERROR((AE_INFO,
			    "Unsupported register bit width: 0x%X",
			    reg->bit_width));
		return (AE_SUPPORT);
	}

	/* Validate the bit_offset. Just a warning for now. */

	if (reg->bit_offset != 0) {
		ACPI_WARNING((AE_INFO,
			      "Unsupported register bit offset: 0x%X",
			      reg->bit_offset));
	}

	return (AE_OK);
}

/******************************************************************************
 *
 * FUNCTION:    acpi_hw_read
 *
 * PARAMETERS:  Value               - Where the value is returned
 *              Reg                 - GAS register structure
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Read from either memory or IO space. This is a 32-bit max
 *              version of acpi_read, used internally since the overhead of
 *              64-bit values is not needed.
 *
 * LIMITATIONS: <These limitations also apply to acpi_hw_write>
 *      bit_width must be exactly 8, 16, or 32.
 *      space_iD must be system_memory or system_iO.
 *      bit_offset and access_width are currently ignored, as there has
 *          not been a need to implement these.
 *
 ******************************************************************************/

acpi_status acpi_hw_read(u32 *value, struct acpi_generic_address *reg)
{
	u64 address;
	acpi_status status;

	ACPI_FUNCTION_NAME(hw_read);

	/* Validate contents of the GAS register */

	status = acpi_hw_validate_register(reg, 32, &address);
	if (ACPI_FAILURE(status)) {
		return (status);
	}

	/* Initialize entire 32-bit return value to zero */

	*value = 0;

	/*
	 * Two address spaces supported: Memory or IO. PCI_Config is
	 * not supported here because the GAS structure is insufficient
	 */
	if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
		status = acpi_os_read_memory((acpi_physical_address)
					     address, value, reg->bit_width);
	} else {		/* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */

		status = acpi_hw_read_port((acpi_io_address)
					   address, value, reg->bit_width);
	}

	ACPI_DEBUG_PRINT((ACPI_DB_IO,
			  "Read:  %8.8X width %2d from %8.8X%8.8X (%s)\n",
			  *value, reg->bit_width, ACPI_FORMAT_UINT64(address),
			  acpi_ut_get_region_name(reg->space_id)));

	return (status);
}

/******************************************************************************
 *
 * FUNCTION:    acpi_hw_write
 *
 * PARAMETERS:  Value               - Value to be written
 *              Reg                 - GAS register structure
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Write to either memory or IO space. This is a 32-bit max
 *              version of acpi_write, used internally since the overhead of
 *              64-bit values is not needed.
 *
 ******************************************************************************/

acpi_status acpi_hw_write(u32 value, struct acpi_generic_address *reg)
{
	u64 address;
	acpi_status status;

	ACPI_FUNCTION_NAME(hw_write);

	/* Validate contents of the GAS register */

	status = acpi_hw_validate_register(reg, 32, &address);
	if (ACPI_FAILURE(status)) {
		return (status);
	}

	/*
	 * Two address spaces supported: Memory or IO. PCI_Config is
	 * not supported here because the GAS structure is insufficient
	 */
	if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
		status = acpi_os_write_memory((acpi_physical_address)
					      address, value, reg->bit_width);
	} else {		/* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */

		status = acpi_hw_write_port((acpi_io_address)
					    address, value, reg->bit_width);
	}

	ACPI_DEBUG_PRINT((ACPI_DB_IO,
			  "Wrote: %8.8X width %2d   to %8.8X%8.8X (%s)\n",
			  value, reg->bit_width, ACPI_FORMAT_UINT64(address),
			  acpi_ut_get_region_name(reg->space_id)));

	return (status);
}

246
#if (!ACPI_REDUCED_HARDWARE)
L
Linus Torvalds 已提交
247 248 249 250
/*******************************************************************************
 *
 * FUNCTION:    acpi_hw_clear_acpi_status
 *
251
 * PARAMETERS:  None
L
Linus Torvalds 已提交
252
 *
253
 * RETURN:      Status
L
Linus Torvalds 已提交
254 255 256 257
 *
 * DESCRIPTION: Clears all fixed and general purpose status bits
 *
 ******************************************************************************/
258

259
acpi_status acpi_hw_clear_acpi_status(void)
L
Linus Torvalds 已提交
260
{
L
Len Brown 已提交
261
	acpi_status status;
B
Bob Moore 已提交
262
	acpi_cpu_flags lock_flags = 0;
L
Linus Torvalds 已提交
263

B
Bob Moore 已提交
264
	ACPI_FUNCTION_TRACE(hw_clear_acpi_status);
L
Linus Torvalds 已提交
265

266
	ACPI_DEBUG_PRINT((ACPI_DB_IO, "About to write %04X to %8.8X%8.8X\n",
L
Len Brown 已提交
267
			  ACPI_BITMASK_ALL_FIXED_STATUS,
268
			  ACPI_FORMAT_UINT64(acpi_gbl_xpm1a_status.address)));
L
Linus Torvalds 已提交
269

B
Bob Moore 已提交
270
	lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
L
Linus Torvalds 已提交
271

272
	/* Clear the fixed events in PM1 A/B */
273

274
	status = acpi_hw_register_write(ACPI_REGISTER_PM1_STATUS,
L
Len Brown 已提交
275
					ACPI_BITMASK_ALL_FIXED_STATUS);
276 277 278 279 280

	acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags);

	if (ACPI_FAILURE(status))
		goto exit;
L
Linus Torvalds 已提交
281 282 283

	/* Clear the GPE Bits in all GPE registers in all GPE blocks */

284
	status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block, NULL);
L
Linus Torvalds 已提交
285

286
exit:
L
Len Brown 已提交
287
	return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
288 289 290 291
}

/*******************************************************************************
 *
292
 * FUNCTION:    acpi_hw_get_bit_register_info
L
Linus Torvalds 已提交
293 294 295
 *
 * PARAMETERS:  register_id         - Index of ACPI Register to access
 *
R
Robert Moore 已提交
296
 * RETURN:      The bitmask to be used when accessing the register
L
Linus Torvalds 已提交
297
 *
R
Robert Moore 已提交
298
 * DESCRIPTION: Map register_id into a register bitmask.
L
Linus Torvalds 已提交
299 300
 *
 ******************************************************************************/
301

L
Len Brown 已提交
302
struct acpi_bit_register_info *acpi_hw_get_bit_register_info(u32 register_id)
L
Linus Torvalds 已提交
303
{
B
Bob Moore 已提交
304
	ACPI_FUNCTION_ENTRY();
L
Linus Torvalds 已提交
305 306

	if (register_id > ACPI_BITREG_MAX) {
307
		ACPI_ERROR((AE_INFO, "Invalid BitRegister ID: 0x%X",
B
Bob Moore 已提交
308
			    register_id));
L
Linus Torvalds 已提交
309 310 311 312 313 314
		return (NULL);
	}

	return (&acpi_gbl_bit_register_info[register_id]);
}

315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337
/******************************************************************************
 *
 * FUNCTION:    acpi_hw_write_pm1_control
 *
 * PARAMETERS:  pm1a_control        - Value to be written to PM1A control
 *              pm1b_control        - Value to be written to PM1B control
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Write the PM1 A/B control registers. These registers are
 *              different than than the PM1 A/B status and enable registers
 *              in that different values can be written to the A/B registers.
 *              Most notably, the SLP_TYP bits can be different, as per the
 *              values returned from the _Sx predefined methods.
 *
 ******************************************************************************/

acpi_status acpi_hw_write_pm1_control(u32 pm1a_control, u32 pm1b_control)
{
	acpi_status status;

	ACPI_FUNCTION_TRACE(hw_write_pm1_control);

338 339
	status =
	    acpi_hw_write(pm1a_control, &acpi_gbl_FADT.xpm1a_control_block);
340 341 342 343 344 345
	if (ACPI_FAILURE(status)) {
		return_ACPI_STATUS(status);
	}

	if (acpi_gbl_FADT.xpm1b_control_block.address) {
		status =
346 347
		    acpi_hw_write(pm1b_control,
				  &acpi_gbl_FADT.xpm1b_control_block);
348 349 350 351
	}
	return_ACPI_STATUS(status);
}

L
Linus Torvalds 已提交
352 353 354 355
/******************************************************************************
 *
 * FUNCTION:    acpi_hw_register_read
 *
356
 * PARAMETERS:  register_id         - ACPI Register ID
R
Robert Moore 已提交
357
 *              return_value        - Where the register value is returned
L
Linus Torvalds 已提交
358 359 360
 *
 * RETURN:      Status and the value read.
 *
B
Bob Moore 已提交
361
 * DESCRIPTION: Read from the specified ACPI register
L
Linus Torvalds 已提交
362 363 364
 *
 ******************************************************************************/
acpi_status
365
acpi_hw_register_read(u32 register_id, u32 * return_value)
L
Linus Torvalds 已提交
366
{
367
	u32 value = 0;
L
Len Brown 已提交
368
	acpi_status status;
L
Linus Torvalds 已提交
369

B
Bob Moore 已提交
370
	ACPI_FUNCTION_TRACE(hw_register_read);
L
Linus Torvalds 已提交
371 372

	switch (register_id) {
373
	case ACPI_REGISTER_PM1_STATUS:	/* PM1 A/B: 16-bit access each */
L
Linus Torvalds 已提交
374

375 376 377
		status = acpi_hw_read_multiple(&value,
					       &acpi_gbl_xpm1a_status,
					       &acpi_gbl_xpm1b_status);
L
Linus Torvalds 已提交
378 379
		break;

380
	case ACPI_REGISTER_PM1_ENABLE:	/* PM1 A/B: 16-bit access each */
L
Linus Torvalds 已提交
381

382 383 384
		status = acpi_hw_read_multiple(&value,
					       &acpi_gbl_xpm1a_enable,
					       &acpi_gbl_xpm1b_enable);
L
Linus Torvalds 已提交
385 386
		break;

387
	case ACPI_REGISTER_PM1_CONTROL:	/* PM1 A/B: 16-bit access each */
L
Linus Torvalds 已提交
388

389 390 391 392 393
		status = acpi_hw_read_multiple(&value,
					       &acpi_gbl_FADT.
					       xpm1a_control_block,
					       &acpi_gbl_FADT.
					       xpm1b_control_block);
394 395 396 397 398 399 400

		/*
		 * Zero the write-only bits. From the ACPI specification, "Hardware
		 * Write-Only Bits": "Upon reads to registers with write-only bits,
		 * software masks out all write-only bits."
		 */
		value &= ~ACPI_PM1_CONTROL_WRITEONLY_BITS;
L
Linus Torvalds 已提交
401 402
		break;

L
Len Brown 已提交
403
	case ACPI_REGISTER_PM2_CONTROL:	/* 8-bit access */
L
Linus Torvalds 已提交
404

405 406
		status =
		    acpi_hw_read(&value, &acpi_gbl_FADT.xpm2_control_block);
L
Linus Torvalds 已提交
407 408
		break;

L
Len Brown 已提交
409
	case ACPI_REGISTER_PM_TIMER:	/* 32-bit access */
L
Linus Torvalds 已提交
410

411
		status = acpi_hw_read(&value, &acpi_gbl_FADT.xpm_timer_block);
L
Linus Torvalds 已提交
412 413
		break;

L
Len Brown 已提交
414
	case ACPI_REGISTER_SMI_COMMAND_BLOCK:	/* 8-bit access */
L
Linus Torvalds 已提交
415

416
		status =
B
Bob Moore 已提交
417
		    acpi_hw_read_port(acpi_gbl_FADT.smi_command, &value, 8);
L
Linus Torvalds 已提交
418 419 420
		break;

	default:
421
		ACPI_ERROR((AE_INFO, "Unknown Register ID: 0x%X", register_id));
L
Linus Torvalds 已提交
422 423 424 425
		status = AE_BAD_PARAMETER;
		break;
	}

L
Len Brown 已提交
426
	if (ACPI_SUCCESS(status)) {
427
		*return_value = value;
L
Linus Torvalds 已提交
428 429
	}

L
Len Brown 已提交
430
	return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
431 432 433 434 435 436
}

/******************************************************************************
 *
 * FUNCTION:    acpi_hw_register_write
 *
437
 * PARAMETERS:  register_id         - ACPI Register ID
L
Linus Torvalds 已提交
438 439 440 441
 *              Value               - The value to write
 *
 * RETURN:      Status
 *
B
Bob Moore 已提交
442 443 444 445 446 447 448 449 450 451 452 453 454 455
 * DESCRIPTION: Write to the specified ACPI register
 *
 * NOTE: In accordance with the ACPI specification, this function automatically
 * preserves the value of the following bits, meaning that these bits cannot be
 * changed via this interface:
 *
 * PM1_CONTROL[0] = SCI_EN
 * PM1_CONTROL[9]
 * PM1_STATUS[11]
 *
 * ACPI References:
 * 1) Hardware Ignored Bits: When software writes to a register with ignored
 *      bit fields, it preserves the ignored bit fields
 * 2) SCI_EN: OSPM always preserves this bit position
L
Linus Torvalds 已提交
456 457 458
 *
 ******************************************************************************/

459
acpi_status acpi_hw_register_write(u32 register_id, u32 value)
L
Linus Torvalds 已提交
460
{
L
Len Brown 已提交
461
	acpi_status status;
B
Bob Moore 已提交
462
	u32 read_value;
L
Linus Torvalds 已提交
463

B
Bob Moore 已提交
464
	ACPI_FUNCTION_TRACE(hw_register_write);
L
Linus Torvalds 已提交
465 466

	switch (register_id) {
467
	case ACPI_REGISTER_PM1_STATUS:	/* PM1 A/B: 16-bit access each */
468 469 470 471 472 473 474 475 476 477 478
		/*
		 * Handle the "ignored" bit in PM1 Status. According to the ACPI
		 * specification, ignored bits are to be preserved when writing.
		 * Normally, this would mean a read/modify/write sequence. However,
		 * preserving a bit in the status register is different. Writing a
		 * one clears the status, and writing a zero preserves the status.
		 * Therefore, we must always write zero to the ignored bit.
		 *
		 * This behavior is clarified in the ACPI 4.0 specification.
		 */
		value &= ~ACPI_PM1_STATUS_PRESERVED_BITS;
B
Bob Moore 已提交
479

480 481 482
		status = acpi_hw_write_multiple(value,
						&acpi_gbl_xpm1a_status,
						&acpi_gbl_xpm1b_status);
L
Linus Torvalds 已提交
483 484
		break;

485
	case ACPI_REGISTER_PM1_ENABLE:	/* PM1 A/B: 16-bit access */
L
Linus Torvalds 已提交
486

487 488 489
		status = acpi_hw_write_multiple(value,
						&acpi_gbl_xpm1a_enable,
						&acpi_gbl_xpm1b_enable);
L
Linus Torvalds 已提交
490 491
		break;

492
	case ACPI_REGISTER_PM1_CONTROL:	/* PM1 A/B: 16-bit access each */
L
Linus Torvalds 已提交
493

B
Bob Moore 已提交
494 495
		/*
		 * Perform a read first to preserve certain bits (per ACPI spec)
496
		 * Note: This includes SCI_EN, we never want to change this bit
B
Bob Moore 已提交
497
		 */
498 499 500 501 502
		status = acpi_hw_read_multiple(&read_value,
					       &acpi_gbl_FADT.
					       xpm1a_control_block,
					       &acpi_gbl_FADT.
					       xpm1b_control_block);
B
Bob Moore 已提交
503
		if (ACPI_FAILURE(status)) {
504
			goto exit;
B
Bob Moore 已提交
505 506 507 508 509 510 511 512 513
		}

		/* Insert the bits to be preserved */

		ACPI_INSERT_BITS(value, ACPI_PM1_CONTROL_PRESERVED_BITS,
				 read_value);

		/* Now we can write the data */

514 515 516 517 518
		status = acpi_hw_write_multiple(value,
						&acpi_gbl_FADT.
						xpm1a_control_block,
						&acpi_gbl_FADT.
						xpm1b_control_block);
L
Linus Torvalds 已提交
519 520
		break;

L
Len Brown 已提交
521
	case ACPI_REGISTER_PM2_CONTROL:	/* 8-bit access */
L
Linus Torvalds 已提交
522

523 524 525 526 527
		/*
		 * For control registers, all reserved bits must be preserved,
		 * as per the ACPI spec.
		 */
		status =
528 529
		    acpi_hw_read(&read_value,
				 &acpi_gbl_FADT.xpm2_control_block);
530 531 532 533 534 535 536 537 538
		if (ACPI_FAILURE(status)) {
			goto exit;
		}

		/* Insert the bits to be preserved */

		ACPI_INSERT_BITS(value, ACPI_PM2_CONTROL_PRESERVED_BITS,
				 read_value);

539 540
		status =
		    acpi_hw_write(value, &acpi_gbl_FADT.xpm2_control_block);
L
Linus Torvalds 已提交
541 542
		break;

L
Len Brown 已提交
543
	case ACPI_REGISTER_PM_TIMER:	/* 32-bit access */
L
Linus Torvalds 已提交
544

545
		status = acpi_hw_write(value, &acpi_gbl_FADT.xpm_timer_block);
L
Linus Torvalds 已提交
546 547
		break;

L
Len Brown 已提交
548
	case ACPI_REGISTER_SMI_COMMAND_BLOCK:	/* 8-bit access */
L
Linus Torvalds 已提交
549 550 551

		/* SMI_CMD is currently always in IO space */

552
		status =
B
Bob Moore 已提交
553
		    acpi_hw_write_port(acpi_gbl_FADT.smi_command, value, 8);
L
Linus Torvalds 已提交
554 555 556
		break;

	default:
557
		ACPI_ERROR((AE_INFO, "Unknown Register ID: 0x%X", register_id));
L
Linus Torvalds 已提交
558 559 560 561
		status = AE_BAD_PARAMETER;
		break;
	}

562
      exit:
L
Len Brown 已提交
563
	return_ACPI_STATUS(status);
L
Linus Torvalds 已提交
564
}
565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590

/******************************************************************************
 *
 * FUNCTION:    acpi_hw_read_multiple
 *
 * PARAMETERS:  Value               - Where the register value is returned
 *              register_a           - First ACPI register (required)
 *              register_b           - Second ACPI register (optional)
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Read from the specified two-part ACPI register (such as PM1 A/B)
 *
 ******************************************************************************/

static acpi_status
acpi_hw_read_multiple(u32 *value,
		      struct acpi_generic_address *register_a,
		      struct acpi_generic_address *register_b)
{
	u32 value_a = 0;
	u32 value_b = 0;
	acpi_status status;

	/* The first register is always required */

591
	status = acpi_hw_read(&value_a, register_a);
592 593 594 595 596 597 598
	if (ACPI_FAILURE(status)) {
		return (status);
	}

	/* Second register is optional */

	if (register_b->address) {
599
		status = acpi_hw_read(&value_b, register_b);
600 601 602 603 604
		if (ACPI_FAILURE(status)) {
			return (status);
		}
	}

605 606 607 608 609 610 611 612 613 614 615
	/*
	 * OR the two return values together. No shifting or masking is necessary,
	 * because of how the PM1 registers are defined in the ACPI specification:
	 *
	 * "Although the bits can be split between the two register blocks (each
	 * register block has a unique pointer within the FADT), the bit positions
	 * are maintained. The register block with unimplemented bits (that is,
	 * those implemented in the other register block) always returns zeros,
	 * and writes have no side effects"
	 */
	*value = (value_a | value_b);
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641
	return (AE_OK);
}

/******************************************************************************
 *
 * FUNCTION:    acpi_hw_write_multiple
 *
 * PARAMETERS:  Value               - The value to write
 *              register_a           - First ACPI register (required)
 *              register_b           - Second ACPI register (optional)
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Write to the specified two-part ACPI register (such as PM1 A/B)
 *
 ******************************************************************************/

static acpi_status
acpi_hw_write_multiple(u32 value,
		       struct acpi_generic_address *register_a,
		       struct acpi_generic_address *register_b)
{
	acpi_status status;

	/* The first register is always required */

642
	status = acpi_hw_write(value, register_a);
643 644 645 646
	if (ACPI_FAILURE(status)) {
		return (status);
	}

647 648 649 650 651 652 653 654 655 656 657 658
	/*
	 * Second register is optional
	 *
	 * No bit shifting or clearing is necessary, because of how the PM1
	 * registers are defined in the ACPI specification:
	 *
	 * "Although the bits can be split between the two register blocks (each
	 * register block has a unique pointer within the FADT), the bit positions
	 * are maintained. The register block with unimplemented bits (that is,
	 * those implemented in the other register block) always returns zeros,
	 * and writes have no side effects"
	 */
659
	if (register_b->address) {
660
		status = acpi_hw_write(value, register_b);
661 662 663 664
	}

	return (status);
}
665 666

#endif				/* !ACPI_REDUCED_HARDWARE */