2 /*******************************************************************************
4 * Module Name: hwregs - Read/write access functions for the various ACPI
5 * control and status registers.
7 ******************************************************************************/
10 * Copyright (C) 2000 - 2004, R. Byron Moore
11 * All rights reserved.
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
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.
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.
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.
47 #include <acpi/acpi.h>
48 #include <acpi/acnamesp.h>
49 #include <acpi/acevents.h>
51 #define _COMPONENT ACPI_HARDWARE
52 ACPI_MODULE_NAME ("hwregs")
55 /*******************************************************************************
57 * FUNCTION: acpi_hw_clear_acpi_status
59 * PARAMETERS: Flags - Lock the hardware or not
63 * DESCRIPTION: Clears all fixed and general purpose status bits
65 ******************************************************************************/
68 acpi_hw_clear_acpi_status (
74 ACPI_FUNCTION_TRACE ("hw_clear_acpi_status");
77 ACPI_DEBUG_PRINT ((ACPI_DB_IO, "About to write %04X to %04X\n",
78 ACPI_BITMASK_ALL_FIXED_STATUS,
79 (u16) acpi_gbl_FADT->xpm1a_evt_blk.address));
81 if (flags & ACPI_MTX_LOCK) {
82 status = acpi_ut_acquire_mutex (ACPI_MTX_HARDWARE);
83 if (ACPI_FAILURE (status)) {
84 return_ACPI_STATUS (status);
88 status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK, ACPI_REGISTER_PM1_STATUS,
89 ACPI_BITMASK_ALL_FIXED_STATUS);
90 if (ACPI_FAILURE (status)) {
94 /* Clear the fixed events */
96 if (acpi_gbl_FADT->xpm1b_evt_blk.address) {
97 status = acpi_hw_low_level_write (16, ACPI_BITMASK_ALL_FIXED_STATUS,
98 &acpi_gbl_FADT->xpm1b_evt_blk);
99 if (ACPI_FAILURE (status)) {
100 goto unlock_and_exit;
104 /* Clear the GPE Bits in all GPE registers in all GPE blocks */
106 status = acpi_ev_walk_gpe_list (acpi_hw_clear_gpe_block);
109 if (flags & ACPI_MTX_LOCK) {
110 (void) acpi_ut_release_mutex (ACPI_MTX_HARDWARE);
112 return_ACPI_STATUS (status);
116 /*******************************************************************************
118 * FUNCTION: acpi_get_sleep_type_data
120 * PARAMETERS: sleep_state - Numeric sleep state
121 * *sleep_type_a - Where SLP_TYPa is returned
122 * *sleep_type_b - Where SLP_TYPb is returned
124 * RETURN: Status - ACPI status
126 * DESCRIPTION: Obtain the SLP_TYPa and SLP_TYPb values for the requested sleep
129 ******************************************************************************/
132 acpi_get_sleep_type_data (
137 acpi_status status = AE_OK;
138 union acpi_operand_object *obj_desc;
141 ACPI_FUNCTION_TRACE ("acpi_get_sleep_type_data");
145 * Validate parameters
147 if ((sleep_state > ACPI_S_STATES_MAX) ||
148 !sleep_type_a || !sleep_type_b) {
149 return_ACPI_STATUS (AE_BAD_PARAMETER);
153 * Evaluate the namespace object containing the values for this state
155 status = acpi_ns_evaluate_by_name ((char *) acpi_gbl_sleep_state_names[sleep_state],
157 if (ACPI_FAILURE (status)) {
158 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%s while evaluating sleep_state [%s]\n",
159 acpi_format_exception (status), acpi_gbl_sleep_state_names[sleep_state]));
161 return_ACPI_STATUS (status);
164 /* Must have a return object */
167 ACPI_REPORT_ERROR (("Missing Sleep State object\n"));
168 status = AE_NOT_EXIST;
171 /* It must be of type Package */
173 else if (ACPI_GET_OBJECT_TYPE (obj_desc) != ACPI_TYPE_PACKAGE) {
174 ACPI_REPORT_ERROR (("Sleep State object not a Package\n"));
175 status = AE_AML_OPERAND_TYPE;
178 /* The package must have at least two elements */
180 else if (obj_desc->package.count < 2) {
181 ACPI_REPORT_ERROR (("Sleep State package does not have at least two elements\n"));
182 status = AE_AML_NO_OPERAND;
185 /* The first two elements must both be of type Integer */
187 else if ((ACPI_GET_OBJECT_TYPE (obj_desc->package.elements[0]) != ACPI_TYPE_INTEGER) ||
188 (ACPI_GET_OBJECT_TYPE (obj_desc->package.elements[1]) != ACPI_TYPE_INTEGER)) {
189 ACPI_REPORT_ERROR (("Sleep State package elements are not both Integers (%s, %s)\n",
190 acpi_ut_get_object_type_name (obj_desc->package.elements[0]),
191 acpi_ut_get_object_type_name (obj_desc->package.elements[1])));
192 status = AE_AML_OPERAND_TYPE;
196 * Valid _Sx_ package size, type, and value
198 *sleep_type_a = (u8) (obj_desc->package.elements[0])->integer.value;
199 *sleep_type_b = (u8) (obj_desc->package.elements[1])->integer.value;
202 if (ACPI_FAILURE (status)) {
203 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "While evaluating sleep_state [%s], bad Sleep object %p type %s\n",
204 acpi_gbl_sleep_state_names[sleep_state], obj_desc, acpi_ut_get_object_type_name (obj_desc)));
207 acpi_ut_remove_reference (obj_desc);
208 return_ACPI_STATUS (status);
212 /*******************************************************************************
214 * FUNCTION: acpi_hw_get_register_bit_mask
216 * PARAMETERS: register_id - Index of ACPI Register to access
218 * RETURN: The bit mask to be used when accessing the register
220 * DESCRIPTION: Map register_id into a register bit mask.
222 ******************************************************************************/
224 struct acpi_bit_register_info *
225 acpi_hw_get_bit_register_info (
228 ACPI_FUNCTION_NAME ("hw_get_bit_register_info");
231 if (register_id > ACPI_BITREG_MAX) {
232 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Invalid bit_register ID: %X\n", register_id));
236 return (&acpi_gbl_bit_register_info[register_id]);
240 /*******************************************************************************
242 * FUNCTION: acpi_get_register
244 * PARAMETERS: register_id - ID of ACPI bit_register to access
245 * return_value - Value that was read from the register
246 * Flags - Lock the hardware or not
248 * RETURN: Value is read from specified Register. Value returned is
249 * normalized to bit0 (is shifted all the way right)
251 * DESCRIPTION: ACPI bit_register read function.
253 ******************************************************************************/
261 u32 register_value = 0;
262 struct acpi_bit_register_info *bit_reg_info;
266 ACPI_FUNCTION_TRACE ("acpi_get_register");
269 /* Get the info structure corresponding to the requested ACPI Register */
271 bit_reg_info = acpi_hw_get_bit_register_info (register_id);
273 return_ACPI_STATUS (AE_BAD_PARAMETER);
276 if (flags & ACPI_MTX_LOCK) {
277 status = acpi_ut_acquire_mutex (ACPI_MTX_HARDWARE);
278 if (ACPI_FAILURE (status)) {
279 return_ACPI_STATUS (status);
283 status = acpi_hw_register_read (ACPI_MTX_DO_NOT_LOCK,
284 bit_reg_info->parent_register, ®ister_value);
286 if (flags & ACPI_MTX_LOCK) {
287 (void) acpi_ut_release_mutex (ACPI_MTX_HARDWARE);
290 if (ACPI_SUCCESS (status)) {
291 /* Normalize the value that was read */
293 register_value = ((register_value & bit_reg_info->access_bit_mask)
294 >> bit_reg_info->bit_position);
296 *return_value = register_value;
298 ACPI_DEBUG_PRINT ((ACPI_DB_IO, "Read value %8.8X register %X\n",
299 register_value, bit_reg_info->parent_register));
302 return_ACPI_STATUS (status);
306 /*******************************************************************************
308 * FUNCTION: acpi_set_register
310 * PARAMETERS: register_id - ID of ACPI bit_register to access
311 * Value - (only used on write) value to write to the
312 * Register, NOT pre-normalized to the bit pos.
313 * Flags - Lock the hardware or not
317 * DESCRIPTION: ACPI Bit Register write function.
319 ******************************************************************************/
327 u32 register_value = 0;
328 struct acpi_bit_register_info *bit_reg_info;
332 ACPI_FUNCTION_TRACE_U32 ("acpi_set_register", register_id);
335 /* Get the info structure corresponding to the requested ACPI Register */
337 bit_reg_info = acpi_hw_get_bit_register_info (register_id);
339 ACPI_REPORT_ERROR (("Bad ACPI HW register_id: %X\n", register_id));
340 return_ACPI_STATUS (AE_BAD_PARAMETER);
343 if (flags & ACPI_MTX_LOCK) {
344 status = acpi_ut_acquire_mutex (ACPI_MTX_HARDWARE);
345 if (ACPI_FAILURE (status)) {
346 return_ACPI_STATUS (status);
350 /* Always do a register read first so we can insert the new bits */
352 status = acpi_hw_register_read (ACPI_MTX_DO_NOT_LOCK,
353 bit_reg_info->parent_register, ®ister_value);
354 if (ACPI_FAILURE (status)) {
355 goto unlock_and_exit;
359 * Decode the Register ID
360 * Register ID = [Register block ID] | [bit ID]
362 * Check bit ID to fine locate Register offset.
363 * Check Mask to determine Register offset, and then read-write.
365 switch (bit_reg_info->parent_register) {
366 case ACPI_REGISTER_PM1_STATUS:
369 * Status Registers are different from the rest. Clear by
370 * writing 1, and writing 0 has no effect. So, the only relevant
371 * information is the single bit we're interested in, all others should
372 * be written as 0 so they will be left unchanged.
374 value = ACPI_REGISTER_PREPARE_BITS (value,
375 bit_reg_info->bit_position, bit_reg_info->access_bit_mask);
377 status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK,
378 ACPI_REGISTER_PM1_STATUS, (u16) value);
384 case ACPI_REGISTER_PM1_ENABLE:
386 ACPI_REGISTER_INSERT_VALUE (register_value, bit_reg_info->bit_position,
387 bit_reg_info->access_bit_mask, value);
389 status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK,
390 ACPI_REGISTER_PM1_ENABLE, (u16) register_value);
394 case ACPI_REGISTER_PM1_CONTROL:
397 * Write the PM1 Control register.
398 * Note that at this level, the fact that there are actually TWO
399 * registers (A and B - and B may not exist) is abstracted.
401 ACPI_DEBUG_PRINT ((ACPI_DB_IO, "PM1 control: Read %X\n", register_value));
403 ACPI_REGISTER_INSERT_VALUE (register_value, bit_reg_info->bit_position,
404 bit_reg_info->access_bit_mask, value);
406 status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK,
407 ACPI_REGISTER_PM1_CONTROL, (u16) register_value);
411 case ACPI_REGISTER_PM2_CONTROL:
413 status = acpi_hw_register_read (ACPI_MTX_DO_NOT_LOCK,
414 ACPI_REGISTER_PM2_CONTROL, ®ister_value);
415 if (ACPI_FAILURE (status)) {
416 goto unlock_and_exit;
419 ACPI_DEBUG_PRINT ((ACPI_DB_IO, "PM2 control: Read %X from %8.8X%8.8X\n",
421 ACPI_FORMAT_UINT64 (acpi_gbl_FADT->xpm2_cnt_blk.address)));
423 ACPI_REGISTER_INSERT_VALUE (register_value, bit_reg_info->bit_position,
424 bit_reg_info->access_bit_mask, value);
426 ACPI_DEBUG_PRINT ((ACPI_DB_IO, "About to write %4.4X to %8.8X%8.8X\n",
428 ACPI_FORMAT_UINT64 (acpi_gbl_FADT->xpm2_cnt_blk.address)));
430 status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK,
431 ACPI_REGISTER_PM2_CONTROL, (u8) (register_value));
442 if (flags & ACPI_MTX_LOCK) {
443 (void) acpi_ut_release_mutex (ACPI_MTX_HARDWARE);
446 /* Normalize the value that was read */
448 ACPI_DEBUG_EXEC (register_value = ((register_value & bit_reg_info->access_bit_mask) >> bit_reg_info->bit_position));
450 ACPI_DEBUG_PRINT ((ACPI_DB_IO, "Set bits: %8.8X actual %8.8X register %X\n",
451 value, register_value, bit_reg_info->parent_register));
452 return_ACPI_STATUS (status);
456 /******************************************************************************
458 * FUNCTION: acpi_hw_register_read
460 * PARAMETERS: use_lock - Mutex hw access.
461 * register_id - register_iD + Offset.
463 * RETURN: Value read or written.
465 * DESCRIPTION: Acpi register read function. Registers are read at the
468 ******************************************************************************/
471 acpi_hw_register_read (
481 ACPI_FUNCTION_TRACE ("hw_register_read");
484 if (ACPI_MTX_LOCK == use_lock) {
485 status = acpi_ut_acquire_mutex (ACPI_MTX_HARDWARE);
486 if (ACPI_FAILURE (status)) {
487 return_ACPI_STATUS (status);
491 switch (register_id) {
492 case ACPI_REGISTER_PM1_STATUS: /* 16-bit access */
494 status = acpi_hw_low_level_read (16, &value1, &acpi_gbl_FADT->xpm1a_evt_blk);
495 if (ACPI_FAILURE (status)) {
496 goto unlock_and_exit;
499 /* PM1B is optional */
501 status = acpi_hw_low_level_read (16, &value2, &acpi_gbl_FADT->xpm1b_evt_blk);
506 case ACPI_REGISTER_PM1_ENABLE: /* 16-bit access */
508 status = acpi_hw_low_level_read (16, &value1, &acpi_gbl_xpm1a_enable);
509 if (ACPI_FAILURE (status)) {
510 goto unlock_and_exit;
513 /* PM1B is optional */
515 status = acpi_hw_low_level_read (16, &value2, &acpi_gbl_xpm1b_enable);
520 case ACPI_REGISTER_PM1_CONTROL: /* 16-bit access */
522 status = acpi_hw_low_level_read (16, &value1, &acpi_gbl_FADT->xpm1a_cnt_blk);
523 if (ACPI_FAILURE (status)) {
524 goto unlock_and_exit;
527 status = acpi_hw_low_level_read (16, &value2, &acpi_gbl_FADT->xpm1b_cnt_blk);
532 case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
534 status = acpi_hw_low_level_read (8, &value1, &acpi_gbl_FADT->xpm2_cnt_blk);
538 case ACPI_REGISTER_PM_TIMER: /* 32-bit access */
540 status = acpi_hw_low_level_read (32, &value1, &acpi_gbl_FADT->xpm_tmr_blk);
543 case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */
545 status = acpi_os_read_port (acpi_gbl_FADT->smi_cmd, &value1, 8);
549 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown Register ID: %X\n", register_id));
550 status = AE_BAD_PARAMETER;
555 if (ACPI_MTX_LOCK == use_lock) {
556 (void) acpi_ut_release_mutex (ACPI_MTX_HARDWARE);
559 if (ACPI_SUCCESS (status)) {
560 *return_value = value1;
563 return_ACPI_STATUS (status);
567 /******************************************************************************
569 * FUNCTION: acpi_hw_register_write
571 * PARAMETERS: use_lock - Mutex hw access.
572 * register_id - register_iD + Offset.
574 * RETURN: Value read or written.
576 * DESCRIPTION: Acpi register Write function. Registers are written at the
579 ******************************************************************************/
582 acpi_hw_register_write (
590 ACPI_FUNCTION_TRACE ("hw_register_write");
593 if (ACPI_MTX_LOCK == use_lock) {
594 status = acpi_ut_acquire_mutex (ACPI_MTX_HARDWARE);
595 if (ACPI_FAILURE (status)) {
596 return_ACPI_STATUS (status);
600 switch (register_id) {
601 case ACPI_REGISTER_PM1_STATUS: /* 16-bit access */
603 status = acpi_hw_low_level_write (16, value, &acpi_gbl_FADT->xpm1a_evt_blk);
604 if (ACPI_FAILURE (status)) {
605 goto unlock_and_exit;
608 /* PM1B is optional */
610 status = acpi_hw_low_level_write (16, value, &acpi_gbl_FADT->xpm1b_evt_blk);
614 case ACPI_REGISTER_PM1_ENABLE: /* 16-bit access*/
616 status = acpi_hw_low_level_write (16, value, &acpi_gbl_xpm1a_enable);
617 if (ACPI_FAILURE (status)) {
618 goto unlock_and_exit;
621 /* PM1B is optional */
623 status = acpi_hw_low_level_write (16, value, &acpi_gbl_xpm1b_enable);
627 case ACPI_REGISTER_PM1_CONTROL: /* 16-bit access */
629 status = acpi_hw_low_level_write (16, value, &acpi_gbl_FADT->xpm1a_cnt_blk);
630 if (ACPI_FAILURE (status)) {
631 goto unlock_and_exit;
634 status = acpi_hw_low_level_write (16, value, &acpi_gbl_FADT->xpm1b_cnt_blk);
638 case ACPI_REGISTER_PM1A_CONTROL: /* 16-bit access */
640 status = acpi_hw_low_level_write (16, value, &acpi_gbl_FADT->xpm1a_cnt_blk);
644 case ACPI_REGISTER_PM1B_CONTROL: /* 16-bit access */
646 status = acpi_hw_low_level_write (16, value, &acpi_gbl_FADT->xpm1b_cnt_blk);
650 case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
652 status = acpi_hw_low_level_write (8, value, &acpi_gbl_FADT->xpm2_cnt_blk);
656 case ACPI_REGISTER_PM_TIMER: /* 32-bit access */
658 status = acpi_hw_low_level_write (32, value, &acpi_gbl_FADT->xpm_tmr_blk);
662 case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */
664 /* SMI_CMD is currently always in IO space */
666 status = acpi_os_write_port (acpi_gbl_FADT->smi_cmd, value, 8);
671 status = AE_BAD_PARAMETER;
676 if (ACPI_MTX_LOCK == use_lock) {
677 (void) acpi_ut_release_mutex (ACPI_MTX_HARDWARE);
680 return_ACPI_STATUS (status);
684 /******************************************************************************
686 * FUNCTION: acpi_hw_low_level_read
688 * PARAMETERS: Width - 8, 16, or 32
689 * Value - Where the value is returned
690 * Register - GAS register structure
694 * DESCRIPTION: Read from either memory, IO, or PCI config space.
696 ******************************************************************************/
699 acpi_hw_low_level_read (
702 struct acpi_generic_address *reg)
704 struct acpi_pci_id pci_id;
709 ACPI_FUNCTION_NAME ("hw_low_level_read");
713 * Must have a valid pointer to a GAS structure, and
714 * a non-zero address within. However, don't return an error
715 * because the PM1A/B code must not fail if B isn't present.
724 * Three address spaces supported:
725 * Memory, IO, or PCI_Config.
727 switch (reg->address_space_id) {
728 case ACPI_ADR_SPACE_SYSTEM_MEMORY:
730 status = acpi_os_read_memory (
731 (acpi_physical_address) reg->address,
736 case ACPI_ADR_SPACE_SYSTEM_IO:
738 status = acpi_os_read_port ((acpi_io_address) reg->address,
743 case ACPI_ADR_SPACE_PCI_CONFIG:
747 pci_id.device = ACPI_PCI_DEVICE (reg->address);
748 pci_id.function = ACPI_PCI_FUNCTION (reg->address);
749 pci_register = (u16) ACPI_PCI_REGISTER (reg->address);
751 status = acpi_os_read_pci_configuration (&pci_id, pci_register,
757 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
758 "Unsupported address space: %X\n", reg->address_space_id));
759 return (AE_BAD_PARAMETER);
762 ACPI_DEBUG_PRINT ((ACPI_DB_IO, "Read: %8.8X width %2d from %8.8X%8.8X (%s)\n",
764 ACPI_FORMAT_UINT64 (reg->address),
765 acpi_ut_get_region_name (reg->address_space_id)));
771 /******************************************************************************
773 * FUNCTION: acpi_hw_low_level_write
775 * PARAMETERS: Width - 8, 16, or 32
776 * Value - To be written
777 * Register - GAS register structure
781 * DESCRIPTION: Write to either memory, IO, or PCI config space.
783 ******************************************************************************/
786 acpi_hw_low_level_write (
789 struct acpi_generic_address *reg)
791 struct acpi_pci_id pci_id;
796 ACPI_FUNCTION_NAME ("hw_low_level_write");
800 * Must have a valid pointer to a GAS structure, and
801 * a non-zero address within. However, don't return an error
802 * because the PM1A/B code must not fail if B isn't present.
810 * Three address spaces supported:
811 * Memory, IO, or PCI_Config.
813 switch (reg->address_space_id) {
814 case ACPI_ADR_SPACE_SYSTEM_MEMORY:
816 status = acpi_os_write_memory (
817 (acpi_physical_address) reg->address,
822 case ACPI_ADR_SPACE_SYSTEM_IO:
824 status = acpi_os_write_port ((acpi_io_address) reg->address,
829 case ACPI_ADR_SPACE_PCI_CONFIG:
833 pci_id.device = ACPI_PCI_DEVICE (reg->address);
834 pci_id.function = ACPI_PCI_FUNCTION (reg->address);
835 pci_register = (u16) ACPI_PCI_REGISTER (reg->address);
837 status = acpi_os_write_pci_configuration (&pci_id, pci_register,
838 (acpi_integer) value, width);
843 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
844 "Unsupported address space: %X\n", reg->address_space_id));
845 return (AE_BAD_PARAMETER);
848 ACPI_DEBUG_PRINT ((ACPI_DB_IO, "Wrote: %8.8X width %2d to %8.8X%8.8X (%s)\n",
850 ACPI_FORMAT_UINT64 (reg->address),
851 acpi_ut_get_region_name (reg->address_space_id)));