1 /******************************************************************************
3 * Module Name: hwxface - Public ACPICA hardware interfaces
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2013, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
44 #include <linux/export.h>
45 #include <acpi/acpi.h>
49 #define _COMPONENT ACPI_HARDWARE
50 ACPI_MODULE_NAME("hwxface")
52 /******************************************************************************
54 * FUNCTION: acpi_reset
60 * DESCRIPTION: Set reset register in memory or IO space. Note: Does not
61 * support reset register in PCI config space, this must be
64 ******************************************************************************/
65 acpi_status acpi_reset(void)
67 struct acpi_generic_address *reset_reg;
70 ACPI_FUNCTION_TRACE(acpi_reset);
72 reset_reg = &acpi_gbl_FADT.reset_register;
74 /* Check if the reset register is supported */
76 if (!(acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER) ||
77 !reset_reg->address) {
78 return_ACPI_STATUS(AE_NOT_EXIST);
81 if (reset_reg->space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
83 * For I/O space, write directly to the OSL. This bypasses the port
84 * validation mechanism, which may block a valid write to the reset
86 * Spec section 4.7.3.6 requires register width to be 8.
89 acpi_os_write_port((acpi_io_address) reset_reg->address,
90 acpi_gbl_FADT.reset_value, 8);
92 /* Write the reset value to the reset register */
94 status = acpi_hw_write(acpi_gbl_FADT.reset_value, reset_reg);
97 return_ACPI_STATUS(status);
100 ACPI_EXPORT_SYMBOL(acpi_reset)
102 /******************************************************************************
104 * FUNCTION: acpi_read
106 * PARAMETERS: value - Where the value is returned
107 * reg - GAS register structure
111 * DESCRIPTION: Read from either memory or IO space.
113 * LIMITATIONS: <These limitations also apply to acpi_write>
114 * bit_width must be exactly 8, 16, 32, or 64.
115 * space_ID must be system_memory or system_IO.
116 * bit_offset and access_width are currently ignored, as there has
117 * not been a need to implement these.
119 ******************************************************************************/
120 acpi_status acpi_read(u64 *return_value, struct acpi_generic_address *reg)
128 ACPI_FUNCTION_NAME(acpi_read);
131 return (AE_BAD_PARAMETER);
134 /* Validate contents of the GAS register. Allow 64-bit transfers */
136 status = acpi_hw_validate_register(reg, 64, &address);
137 if (ACPI_FAILURE(status)) {
142 * Two address spaces supported: Memory or I/O. PCI_Config is
143 * not supported here because the GAS structure is insufficient
145 if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
146 status = acpi_os_read_memory((acpi_physical_address)
147 address, return_value,
149 if (ACPI_FAILURE(status)) {
152 } else { /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
157 width = reg->bit_width;
159 width = 32; /* Break into two 32-bit transfers */
162 status = acpi_hw_read_port((acpi_io_address)
163 address, &value_lo, width);
164 if (ACPI_FAILURE(status)) {
168 if (reg->bit_width == 64) {
170 /* Read the top 32 bits */
172 status = acpi_hw_read_port((acpi_io_address)
173 (address + 4), &value_hi,
175 if (ACPI_FAILURE(status)) {
180 /* Set the return value only if status is AE_OK */
182 *return_value = (value_lo | ((u64)value_hi << 32));
185 ACPI_DEBUG_PRINT((ACPI_DB_IO,
186 "Read: %8.8X%8.8X width %2d from %8.8X%8.8X (%s)\n",
187 ACPI_FORMAT_UINT64(*return_value), reg->bit_width,
188 ACPI_FORMAT_UINT64(address),
189 acpi_ut_get_region_name(reg->space_id)));
194 ACPI_EXPORT_SYMBOL(acpi_read)
196 /******************************************************************************
198 * FUNCTION: acpi_write
200 * PARAMETERS: value - Value to be written
201 * reg - GAS register structure
205 * DESCRIPTION: Write to either memory or IO space.
207 ******************************************************************************/
208 acpi_status acpi_write(u64 value, struct acpi_generic_address *reg)
214 ACPI_FUNCTION_NAME(acpi_write);
216 /* Validate contents of the GAS register. Allow 64-bit transfers */
218 status = acpi_hw_validate_register(reg, 64, &address);
219 if (ACPI_FAILURE(status)) {
224 * Two address spaces supported: Memory or IO. PCI_Config is
225 * not supported here because the GAS structure is insufficient
227 if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
228 status = acpi_os_write_memory((acpi_physical_address)
229 address, value, reg->bit_width);
230 if (ACPI_FAILURE(status)) {
233 } else { /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
235 width = reg->bit_width;
237 width = 32; /* Break into two 32-bit transfers */
240 status = acpi_hw_write_port((acpi_io_address)
241 address, ACPI_LODWORD(value),
243 if (ACPI_FAILURE(status)) {
247 if (reg->bit_width == 64) {
248 status = acpi_hw_write_port((acpi_io_address)
250 ACPI_HIDWORD(value), 32);
251 if (ACPI_FAILURE(status)) {
257 ACPI_DEBUG_PRINT((ACPI_DB_IO,
258 "Wrote: %8.8X%8.8X width %2d to %8.8X%8.8X (%s)\n",
259 ACPI_FORMAT_UINT64(value), reg->bit_width,
260 ACPI_FORMAT_UINT64(address),
261 acpi_ut_get_region_name(reg->space_id)));
266 ACPI_EXPORT_SYMBOL(acpi_write)
268 #if (!ACPI_REDUCED_HARDWARE)
269 /*******************************************************************************
271 * FUNCTION: acpi_read_bit_register
273 * PARAMETERS: register_id - ID of ACPI Bit Register to access
274 * return_value - Value that was read from the register,
275 * normalized to bit position zero.
277 * RETURN: Status and the value read from the specified Register. Value
278 * returned is normalized to bit0 (is shifted all the way right)
280 * DESCRIPTION: ACPI bit_register read function. Does not acquire the HW lock.
282 * SUPPORTS: Bit fields in PM1 Status, PM1 Enable, PM1 Control, and
285 * Note: The hardware lock is not required when reading the ACPI bit registers
286 * since almost all of them are single bit and it does not matter that
287 * the parent hardware register can be split across two physical
288 * registers. The only multi-bit field is SLP_TYP in the PM1 control
289 * register, but this field does not cross an 8-bit boundary (nor does
290 * it make much sense to actually read this field.)
292 ******************************************************************************/
293 acpi_status acpi_read_bit_register(u32 register_id, u32 *return_value)
295 struct acpi_bit_register_info *bit_reg_info;
300 ACPI_FUNCTION_TRACE_U32(acpi_read_bit_register, register_id);
302 /* Get the info structure corresponding to the requested ACPI Register */
304 bit_reg_info = acpi_hw_get_bit_register_info(register_id);
306 return_ACPI_STATUS(AE_BAD_PARAMETER);
309 /* Read the entire parent register */
311 status = acpi_hw_register_read(bit_reg_info->parent_register,
313 if (ACPI_FAILURE(status)) {
314 return_ACPI_STATUS(status);
317 /* Normalize the value that was read, mask off other bits */
319 value = ((register_value & bit_reg_info->access_bit_mask)
320 >> bit_reg_info->bit_position);
322 ACPI_DEBUG_PRINT((ACPI_DB_IO,
323 "BitReg %X, ParentReg %X, Actual %8.8X, ReturnValue %8.8X\n",
324 register_id, bit_reg_info->parent_register,
325 register_value, value));
327 *return_value = value;
328 return_ACPI_STATUS(AE_OK);
331 ACPI_EXPORT_SYMBOL(acpi_read_bit_register)
333 /*******************************************************************************
335 * FUNCTION: acpi_write_bit_register
337 * PARAMETERS: register_id - ID of ACPI Bit Register to access
338 * value - Value to write to the register, in bit
339 * position zero. The bit is automatically
340 * shifted to the correct position.
344 * DESCRIPTION: ACPI Bit Register write function. Acquires the hardware lock
345 * since most operations require a read/modify/write sequence.
347 * SUPPORTS: Bit fields in PM1 Status, PM1 Enable, PM1 Control, and
350 * Note that at this level, the fact that there may be actually two
351 * hardware registers (A and B - and B may not exist) is abstracted.
353 ******************************************************************************/
354 acpi_status acpi_write_bit_register(u32 register_id, u32 value)
356 struct acpi_bit_register_info *bit_reg_info;
357 acpi_cpu_flags lock_flags;
359 acpi_status status = AE_OK;
361 ACPI_FUNCTION_TRACE_U32(acpi_write_bit_register, register_id);
363 /* Get the info structure corresponding to the requested ACPI Register */
365 bit_reg_info = acpi_hw_get_bit_register_info(register_id);
367 return_ACPI_STATUS(AE_BAD_PARAMETER);
370 lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
373 * At this point, we know that the parent register is one of the
374 * following: PM1 Status, PM1 Enable, PM1 Control, or PM2 Control
376 if (bit_reg_info->parent_register != ACPI_REGISTER_PM1_STATUS) {
378 * 1) Case for PM1 Enable, PM1 Control, and PM2 Control
380 * Perform a register read to preserve the bits that we are not
383 status = acpi_hw_register_read(bit_reg_info->parent_register,
385 if (ACPI_FAILURE(status)) {
386 goto unlock_and_exit;
390 * Insert the input bit into the value that was just read
391 * and write the register
393 ACPI_REGISTER_INSERT_VALUE(register_value,
394 bit_reg_info->bit_position,
395 bit_reg_info->access_bit_mask,
398 status = acpi_hw_register_write(bit_reg_info->parent_register,
402 * 2) Case for PM1 Status
404 * The Status register is different from the rest. Clear an event
405 * by writing 1, writing 0 has no effect. So, the only relevant
406 * information is the single bit we're interested in, all others
407 * should be written as 0 so they will be left unchanged.
409 register_value = ACPI_REGISTER_PREPARE_BITS(value,
415 /* No need to write the register if value is all zeros */
417 if (register_value) {
419 acpi_hw_register_write(ACPI_REGISTER_PM1_STATUS,
424 ACPI_DEBUG_PRINT((ACPI_DB_IO,
425 "BitReg %X, ParentReg %X, Value %8.8X, Actual %8.8X\n",
426 register_id, bit_reg_info->parent_register, value,
431 acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags);
432 return_ACPI_STATUS(status);
435 ACPI_EXPORT_SYMBOL(acpi_write_bit_register)
436 #endif /* !ACPI_REDUCED_HARDWARE */
437 /*******************************************************************************
439 * FUNCTION: acpi_get_sleep_type_data
441 * PARAMETERS: sleep_state - Numeric sleep state
442 * *sleep_type_a - Where SLP_TYPa is returned
443 * *sleep_type_b - Where SLP_TYPb is returned
447 * DESCRIPTION: Obtain the SLP_TYPa and SLP_TYPb values for the requested
448 * sleep state via the appropriate \_Sx object.
450 * The sleep state package returned from the corresponding \_Sx_ object
451 * must contain at least one integer.
454 * Added support for a package that contains two integers. This
455 * goes against the ACPI specification which defines this object as a
456 * package with one encoded DWORD integer. However, existing practice
457 * by many BIOS vendors is to return a package with 2 or more integer
458 * elements, at least one per sleep type (A/B).
461 * Therefore, we must be prepared to accept a package with either a
462 * single integer or multiple integers.
464 * The single integer DWORD format is as follows:
465 * BYTE 0 - Value for the PM1A SLP_TYP register
466 * BYTE 1 - Value for the PM1B SLP_TYP register
467 * BYTE 2-3 - Reserved
469 * The dual integer format is as follows:
470 * Integer 0 - Value for the PM1A SLP_TYP register
471 * Integer 1 - Value for the PM1A SLP_TYP register
473 ******************************************************************************/
475 acpi_get_sleep_type_data(u8 sleep_state, u8 *sleep_type_a, u8 *sleep_type_b)
478 struct acpi_evaluate_info *info;
479 union acpi_operand_object **elements;
481 ACPI_FUNCTION_TRACE(acpi_get_sleep_type_data);
483 /* Validate parameters */
485 if ((sleep_state > ACPI_S_STATES_MAX) || !sleep_type_a || !sleep_type_b) {
486 return_ACPI_STATUS(AE_BAD_PARAMETER);
489 /* Allocate the evaluation information block */
491 info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
493 return_ACPI_STATUS(AE_NO_MEMORY);
497 * Evaluate the \_Sx namespace object containing the register values
500 info->relative_pathname =
501 ACPI_CAST_PTR(char, acpi_gbl_sleep_state_names[sleep_state]);
502 status = acpi_ns_evaluate(info);
503 if (ACPI_FAILURE(status)) {
507 /* Must have a return object */
509 if (!info->return_object) {
510 ACPI_ERROR((AE_INFO, "No Sleep State object returned from [%s]",
511 info->relative_pathname));
512 status = AE_AML_NO_RETURN_VALUE;
516 /* Return object must be of type Package */
518 if (info->return_object->common.type != ACPI_TYPE_PACKAGE) {
520 "Sleep State return object is not a Package"));
521 status = AE_AML_OPERAND_TYPE;
526 * Any warnings about the package length or the object types have
527 * already been issued by the predefined name module -- there is no
528 * need to repeat them here.
530 elements = info->return_object->package.elements;
531 switch (info->return_object->package.count) {
534 status = AE_AML_PACKAGE_LIMIT;
539 if (elements[0]->common.type != ACPI_TYPE_INTEGER) {
540 status = AE_AML_OPERAND_TYPE;
544 /* A valid _Sx_ package with one integer */
546 *sleep_type_a = (u8)elements[0]->integer.value;
547 *sleep_type_b = (u8)(elements[0]->integer.value >> 8);
553 if ((elements[0]->common.type != ACPI_TYPE_INTEGER) ||
554 (elements[1]->common.type != ACPI_TYPE_INTEGER)) {
555 status = AE_AML_OPERAND_TYPE;
559 /* A valid _Sx_ package with two integers */
561 *sleep_type_a = (u8)elements[0]->integer.value;
562 *sleep_type_b = (u8)elements[1]->integer.value;
567 acpi_ut_remove_reference(info->return_object);
570 if (ACPI_FAILURE(status)) {
571 ACPI_EXCEPTION((AE_INFO, status,
572 "While evaluating Sleep State [%s]",
573 info->relative_pathname));
577 return_ACPI_STATUS(status);
580 ACPI_EXPORT_SYMBOL(acpi_get_sleep_type_data)