hwregs.c 13.9 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9

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

/*
Len Brown's avatar
Len Brown committed
10
 * Copyright (C) 2000 - 2008, Intel Corp.
Linus Torvalds's avatar
Linus Torvalds committed
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>
Len Brown's avatar
Len Brown committed
47 48 49
#include "accommon.h"
#include "acnamesp.h"
#include "acevents.h"
Linus Torvalds's avatar
Linus Torvalds committed
50 51

#define _COMPONENT          ACPI_HARDWARE
Len Brown's avatar
Len Brown committed
52
ACPI_MODULE_NAME("hwregs")
Linus Torvalds's avatar
Linus Torvalds committed
53

54 55 56 57 58 59 60 61 62 63 64
/* 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);

Linus Torvalds's avatar
Linus Torvalds committed
65 66 67 68
/*******************************************************************************
 *
 * FUNCTION:    acpi_hw_clear_acpi_status
 *
69
 * PARAMETERS:  None
Linus Torvalds's avatar
Linus Torvalds committed
70
 *
71
 * RETURN:      Status
Linus Torvalds's avatar
Linus Torvalds committed
72 73 74 75
 *
 * DESCRIPTION: Clears all fixed and general purpose status bits
 *
 ******************************************************************************/
76

77
acpi_status acpi_hw_clear_acpi_status(void)
Linus Torvalds's avatar
Linus Torvalds committed
78
{
Len Brown's avatar
Len Brown committed
79
	acpi_status status;
Bob Moore's avatar
Bob Moore committed
80
	acpi_cpu_flags lock_flags = 0;
Linus Torvalds's avatar
Linus Torvalds committed
81

Bob Moore's avatar
Bob Moore committed
82
	ACPI_FUNCTION_TRACE(hw_clear_acpi_status);
Linus Torvalds's avatar
Linus Torvalds committed
83

84
	ACPI_DEBUG_PRINT((ACPI_DB_IO, "About to write %04X to %0llX\n",
Len Brown's avatar
Len Brown committed
85
			  ACPI_BITMASK_ALL_FIXED_STATUS,
86
			  acpi_gbl_xpm1a_status.address));
Linus Torvalds's avatar
Linus Torvalds committed
87

Bob Moore's avatar
Bob Moore committed
88
	lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
Linus Torvalds's avatar
Linus Torvalds committed
89

90
	/* Clear the fixed events in PM1 A/B */
91

92
	status = acpi_hw_register_write(ACPI_REGISTER_PM1_STATUS,
Len Brown's avatar
Len Brown committed
93 94
					ACPI_BITMASK_ALL_FIXED_STATUS);
	if (ACPI_FAILURE(status)) {
Linus Torvalds's avatar
Linus Torvalds committed
95 96 97 98 99
		goto unlock_and_exit;
	}

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

100
	status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
101

Len Brown's avatar
Len Brown committed
102
      unlock_and_exit:
Bob Moore's avatar
Bob Moore committed
103
	acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags);
Len Brown's avatar
Len Brown committed
104
	return_ACPI_STATUS(status);
Linus Torvalds's avatar
Linus Torvalds committed
105 106 107 108 109 110 111 112
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_hw_get_register_bit_mask
 *
 * PARAMETERS:  register_id         - Index of ACPI Register to access
 *
113
 * RETURN:      The bitmask to be used when accessing the register
Linus Torvalds's avatar
Linus Torvalds committed
114
 *
115
 * DESCRIPTION: Map register_id into a register bitmask.
Linus Torvalds's avatar
Linus Torvalds committed
116 117
 *
 ******************************************************************************/
118

Len Brown's avatar
Len Brown committed
119
struct acpi_bit_register_info *acpi_hw_get_bit_register_info(u32 register_id)
Linus Torvalds's avatar
Linus Torvalds committed
120
{
Bob Moore's avatar
Bob Moore committed
121
	ACPI_FUNCTION_ENTRY();
Linus Torvalds's avatar
Linus Torvalds committed
122 123

	if (register_id > ACPI_BITREG_MAX) {
Bob Moore's avatar
Bob Moore committed
124
		ACPI_ERROR((AE_INFO, "Invalid BitRegister ID: %X",
Bob Moore's avatar
Bob Moore committed
125
			    register_id));
Linus Torvalds's avatar
Linus Torvalds committed
126 127 128 129 130 131
		return (NULL);
	}

	return (&acpi_gbl_bit_register_info[register_id]);
}

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
/******************************************************************************
 *
 * 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);

	status = acpi_write(pm1a_control, &acpi_gbl_FADT.xpm1a_control_block);
	if (ACPI_FAILURE(status)) {
		return_ACPI_STATUS(status);
	}

	if (acpi_gbl_FADT.xpm1b_control_block.address) {
		status =
		    acpi_write(pm1b_control,
			       &acpi_gbl_FADT.xpm1b_control_block);
	}
	return_ACPI_STATUS(status);
}

Linus Torvalds's avatar
Linus Torvalds committed
168 169 170 171
/******************************************************************************
 *
 * FUNCTION:    acpi_hw_register_read
 *
172
 * PARAMETERS:  register_id         - ACPI Register ID
173
 *              return_value        - Where the register value is returned
Linus Torvalds's avatar
Linus Torvalds committed
174 175 176
 *
 * RETURN:      Status and the value read.
 *
Bob Moore's avatar
Bob Moore committed
177
 * DESCRIPTION: Read from the specified ACPI register
Linus Torvalds's avatar
Linus Torvalds committed
178 179 180
 *
 ******************************************************************************/
acpi_status
181
acpi_hw_register_read(u32 register_id, u32 * return_value)
Linus Torvalds's avatar
Linus Torvalds committed
182
{
183
	u32 value = 0;
Len Brown's avatar
Len Brown committed
184
	acpi_status status;
Linus Torvalds's avatar
Linus Torvalds committed
185

Bob Moore's avatar
Bob Moore committed
186
	ACPI_FUNCTION_TRACE(hw_register_read);
Linus Torvalds's avatar
Linus Torvalds committed
187 188

	switch (register_id) {
189
	case ACPI_REGISTER_PM1_STATUS:	/* PM1 A/B: 16-bit access each */
Linus Torvalds's avatar
Linus Torvalds committed
190

191 192 193
		status = acpi_hw_read_multiple(&value,
					       &acpi_gbl_xpm1a_status,
					       &acpi_gbl_xpm1b_status);
Linus Torvalds's avatar
Linus Torvalds committed
194 195
		break;

196
	case ACPI_REGISTER_PM1_ENABLE:	/* PM1 A/B: 16-bit access each */
Linus Torvalds's avatar
Linus Torvalds committed
197

198 199 200
		status = acpi_hw_read_multiple(&value,
					       &acpi_gbl_xpm1a_enable,
					       &acpi_gbl_xpm1b_enable);
Linus Torvalds's avatar
Linus Torvalds committed
201 202
		break;

203
	case ACPI_REGISTER_PM1_CONTROL:	/* PM1 A/B: 16-bit access each */
Linus Torvalds's avatar
Linus Torvalds committed
204

205 206 207 208 209
		status = acpi_hw_read_multiple(&value,
					       &acpi_gbl_FADT.
					       xpm1a_control_block,
					       &acpi_gbl_FADT.
					       xpm1b_control_block);
Linus Torvalds's avatar
Linus Torvalds committed
210 211
		break;

Len Brown's avatar
Len Brown committed
212
	case ACPI_REGISTER_PM2_CONTROL:	/* 8-bit access */
Linus Torvalds's avatar
Linus Torvalds committed
213

214
		status = acpi_read(&value, &acpi_gbl_FADT.xpm2_control_block);
Linus Torvalds's avatar
Linus Torvalds committed
215 216
		break;

Len Brown's avatar
Len Brown committed
217
	case ACPI_REGISTER_PM_TIMER:	/* 32-bit access */
Linus Torvalds's avatar
Linus Torvalds committed
218

219
		status = acpi_read(&value, &acpi_gbl_FADT.xpm_timer_block);
Linus Torvalds's avatar
Linus Torvalds committed
220 221
		break;

Len Brown's avatar
Len Brown committed
222
	case ACPI_REGISTER_SMI_COMMAND_BLOCK:	/* 8-bit access */
Linus Torvalds's avatar
Linus Torvalds committed
223

224
		status =
Bob Moore's avatar
Bob Moore committed
225
		    acpi_hw_read_port(acpi_gbl_FADT.smi_command, &value, 8);
Linus Torvalds's avatar
Linus Torvalds committed
226 227 228
		break;

	default:
Bob Moore's avatar
Bob Moore committed
229
		ACPI_ERROR((AE_INFO, "Unknown Register ID: %X", register_id));
Linus Torvalds's avatar
Linus Torvalds committed
230 231 232 233
		status = AE_BAD_PARAMETER;
		break;
	}

Len Brown's avatar
Len Brown committed
234
	if (ACPI_SUCCESS(status)) {
235
		*return_value = value;
Linus Torvalds's avatar
Linus Torvalds committed
236 237
	}

Len Brown's avatar
Len Brown committed
238
	return_ACPI_STATUS(status);
Linus Torvalds's avatar
Linus Torvalds committed
239 240 241 242 243 244
}

/******************************************************************************
 *
 * FUNCTION:    acpi_hw_register_write
 *
245
 * PARAMETERS:  register_id         - ACPI Register ID
Linus Torvalds's avatar
Linus Torvalds committed
246 247 248 249
 *              Value               - The value to write
 *
 * RETURN:      Status
 *
Bob Moore's avatar
Bob Moore committed
250 251 252 253 254 255 256 257 258 259 260 261 262 263
 * 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
Linus Torvalds's avatar
Linus Torvalds committed
264 265 266
 *
 ******************************************************************************/

267
acpi_status acpi_hw_register_write(u32 register_id, u32 value)
Linus Torvalds's avatar
Linus Torvalds committed
268
{
Len Brown's avatar
Len Brown committed
269
	acpi_status status;
Bob Moore's avatar
Bob Moore committed
270
	u32 read_value;
Linus Torvalds's avatar
Linus Torvalds committed
271

Bob Moore's avatar
Bob Moore committed
272
	ACPI_FUNCTION_TRACE(hw_register_write);
Linus Torvalds's avatar
Linus Torvalds committed
273 274

	switch (register_id) {
275
	case ACPI_REGISTER_PM1_STATUS:	/* PM1 A/B: 16-bit access each */
276 277 278 279 280 281 282 283 284 285 286
		/*
		 * 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;
Bob Moore's avatar
Bob Moore committed
287

288 289 290
		status = acpi_hw_write_multiple(value,
						&acpi_gbl_xpm1a_status,
						&acpi_gbl_xpm1b_status);
Linus Torvalds's avatar
Linus Torvalds committed
291 292
		break;

293
	case ACPI_REGISTER_PM1_ENABLE:	/* PM1 A/B: 16-bit access */
Linus Torvalds's avatar
Linus Torvalds committed
294

295 296 297
		status = acpi_hw_write_multiple(value,
						&acpi_gbl_xpm1a_enable,
						&acpi_gbl_xpm1b_enable);
Linus Torvalds's avatar
Linus Torvalds committed
298 299
		break;

300
	case ACPI_REGISTER_PM1_CONTROL:	/* PM1 A/B: 16-bit access each */
Linus Torvalds's avatar
Linus Torvalds committed
301

Bob Moore's avatar
Bob Moore committed
302 303
		/*
		 * Perform a read first to preserve certain bits (per ACPI spec)
304
		 * Note: This includes SCI_EN, we never want to change this bit
Bob Moore's avatar
Bob Moore committed
305
		 */
306 307 308 309 310
		status = acpi_hw_read_multiple(&read_value,
					       &acpi_gbl_FADT.
					       xpm1a_control_block,
					       &acpi_gbl_FADT.
					       xpm1b_control_block);
Bob Moore's avatar
Bob Moore committed
311
		if (ACPI_FAILURE(status)) {
312
			goto exit;
Bob Moore's avatar
Bob Moore committed
313 314 315 316 317 318 319 320 321
		}

		/* Insert the bits to be preserved */

		ACPI_INSERT_BITS(value, ACPI_PM1_CONTROL_PRESERVED_BITS,
				 read_value);

		/* Now we can write the data */

322 323 324 325 326
		status = acpi_hw_write_multiple(value,
						&acpi_gbl_FADT.
						xpm1a_control_block,
						&acpi_gbl_FADT.
						xpm1b_control_block);
Linus Torvalds's avatar
Linus Torvalds committed
327 328
		break;

Len Brown's avatar
Len Brown committed
329
	case ACPI_REGISTER_PM2_CONTROL:	/* 8-bit access */
Linus Torvalds's avatar
Linus Torvalds committed
330

331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
		/*
		 * For control registers, all reserved bits must be preserved,
		 * as per the ACPI spec.
		 */
		status =
		    acpi_read(&read_value, &acpi_gbl_FADT.xpm2_control_block);
		if (ACPI_FAILURE(status)) {
			goto exit;
		}

		/* Insert the bits to be preserved */

		ACPI_INSERT_BITS(value, ACPI_PM2_CONTROL_PRESERVED_BITS,
				 read_value);

346
		status = acpi_write(value, &acpi_gbl_FADT.xpm2_control_block);
Linus Torvalds's avatar
Linus Torvalds committed
347 348
		break;

Len Brown's avatar
Len Brown committed
349
	case ACPI_REGISTER_PM_TIMER:	/* 32-bit access */
Linus Torvalds's avatar
Linus Torvalds committed
350

351
		status = acpi_write(value, &acpi_gbl_FADT.xpm_timer_block);
Linus Torvalds's avatar
Linus Torvalds committed
352 353
		break;

Len Brown's avatar
Len Brown committed
354
	case ACPI_REGISTER_SMI_COMMAND_BLOCK:	/* 8-bit access */
Linus Torvalds's avatar
Linus Torvalds committed
355 356 357

		/* SMI_CMD is currently always in IO space */

358
		status =
Bob Moore's avatar
Bob Moore committed
359
		    acpi_hw_write_port(acpi_gbl_FADT.smi_command, value, 8);
Linus Torvalds's avatar
Linus Torvalds committed
360 361 362
		break;

	default:
363
		ACPI_ERROR((AE_INFO, "Unknown Register ID: %X", register_id));
Linus Torvalds's avatar
Linus Torvalds committed
364 365 366 367
		status = AE_BAD_PARAMETER;
		break;
	}

368
      exit:
Len Brown's avatar
Len Brown committed
369
	return_ACPI_STATUS(status);
Linus Torvalds's avatar
Linus Torvalds committed
370
}
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410

/******************************************************************************
 *
 * 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 */

	status = acpi_read(&value_a, register_a);
	if (ACPI_FAILURE(status)) {
		return (status);
	}

	/* Second register is optional */

	if (register_b->address) {
		status = acpi_read(&value_b, register_b);
		if (ACPI_FAILURE(status)) {
			return (status);
		}
	}

411 412 413 414 415 416 417 418 419 420 421
	/*
	 * 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);
422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452
	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 */

	status = acpi_write(value, register_a);
	if (ACPI_FAILURE(status)) {
		return (status);
	}

453 454 455 456 457 458 459 460 461 462 463 464
	/*
	 * 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"
	 */
465
	if (register_b->address) {
466
		status = acpi_write(value, register_b);
467 468 469 470
	}

	return (status);
}