bc85c96b553f637629c73dae5275374f869b11b3
[reactos.git] / reactos / drivers / bus / acpi / acpica / hardware / hwregs.c
1 /*******************************************************************************
2 *
3 * Module Name: hwregs - Read/write access functions for the various ACPI
4 * control and status registers.
5 *
6 ******************************************************************************/
7
8 /*
9 * Copyright (C) 2000 - 2016, Intel Corp.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions, and the following disclaimer,
17 * without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 * substantially similar to the "NO WARRANTY" disclaimer below
20 * ("Disclaimer") and any redistribution must be conditioned upon
21 * including a substantially similar Disclaimer requirement for further
22 * binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 * of any contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
30 *
31 * NO WARRANTY
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
43 */
44
45 #include "acpi.h"
46 #include "accommon.h"
47 #include "acevents.h"
48
49 #define _COMPONENT ACPI_HARDWARE
50 ACPI_MODULE_NAME ("hwregs")
51
52
53 #if (!ACPI_REDUCED_HARDWARE)
54
55 /* Local Prototypes */
56
57 static ACPI_STATUS
58 AcpiHwReadMultiple (
59 UINT32 *Value,
60 ACPI_GENERIC_ADDRESS *RegisterA,
61 ACPI_GENERIC_ADDRESS *RegisterB);
62
63 static ACPI_STATUS
64 AcpiHwWriteMultiple (
65 UINT32 Value,
66 ACPI_GENERIC_ADDRESS *RegisterA,
67 ACPI_GENERIC_ADDRESS *RegisterB);
68
69 #endif /* !ACPI_REDUCED_HARDWARE */
70
71
72 /******************************************************************************
73 *
74 * FUNCTION: AcpiHwValidateRegister
75 *
76 * PARAMETERS: Reg - GAS register structure
77 * MaxBitWidth - Max BitWidth supported (32 or 64)
78 * Address - Pointer to where the gas->address
79 * is returned
80 *
81 * RETURN: Status
82 *
83 * DESCRIPTION: Validate the contents of a GAS register. Checks the GAS
84 * pointer, Address, SpaceId, BitWidth, and BitOffset.
85 *
86 ******************************************************************************/
87
88 ACPI_STATUS
89 AcpiHwValidateRegister (
90 ACPI_GENERIC_ADDRESS *Reg,
91 UINT8 MaxBitWidth,
92 UINT64 *Address)
93 {
94
95 /* Must have a valid pointer to a GAS structure */
96
97 if (!Reg)
98 {
99 return (AE_BAD_PARAMETER);
100 }
101
102 /*
103 * Copy the target address. This handles possible alignment issues.
104 * Address must not be null. A null address also indicates an optional
105 * ACPI register that is not supported, so no error message.
106 */
107 ACPI_MOVE_64_TO_64 (Address, &Reg->Address);
108 if (!(*Address))
109 {
110 return (AE_BAD_ADDRESS);
111 }
112
113 /* Validate the SpaceID */
114
115 if ((Reg->SpaceId != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&
116 (Reg->SpaceId != ACPI_ADR_SPACE_SYSTEM_IO))
117 {
118 ACPI_ERROR ((AE_INFO,
119 "Unsupported address space: 0x%X", Reg->SpaceId));
120 return (AE_SUPPORT);
121 }
122
123 /* Validate the BitWidth */
124
125 if ((Reg->BitWidth != 8) &&
126 (Reg->BitWidth != 16) &&
127 (Reg->BitWidth != 32) &&
128 (Reg->BitWidth != MaxBitWidth))
129 {
130 ACPI_ERROR ((AE_INFO,
131 "Unsupported register bit width: 0x%X", Reg->BitWidth));
132 return (AE_SUPPORT);
133 }
134
135 /* Validate the BitOffset. Just a warning for now. */
136
137 if (Reg->BitOffset != 0)
138 {
139 ACPI_WARNING ((AE_INFO,
140 "Unsupported register bit offset: 0x%X", Reg->BitOffset));
141 }
142
143 return (AE_OK);
144 }
145
146
147 /******************************************************************************
148 *
149 * FUNCTION: AcpiHwRead
150 *
151 * PARAMETERS: Value - Where the value is returned
152 * Reg - GAS register structure
153 *
154 * RETURN: Status
155 *
156 * DESCRIPTION: Read from either memory or IO space. This is a 32-bit max
157 * version of AcpiRead, used internally since the overhead of
158 * 64-bit values is not needed.
159 *
160 * LIMITATIONS: <These limitations also apply to AcpiHwWrite>
161 * BitWidth must be exactly 8, 16, or 32.
162 * SpaceID must be SystemMemory or SystemIO.
163 * BitOffset and AccessWidth are currently ignored, as there has
164 * not been a need to implement these.
165 *
166 ******************************************************************************/
167
168 ACPI_STATUS
169 AcpiHwRead (
170 UINT32 *Value,
171 ACPI_GENERIC_ADDRESS *Reg)
172 {
173 UINT64 Address;
174 UINT64 Value64;
175 ACPI_STATUS Status;
176
177
178 ACPI_FUNCTION_NAME (HwRead);
179
180
181 /* Validate contents of the GAS register */
182
183 Status = AcpiHwValidateRegister (Reg, 32, &Address);
184 if (ACPI_FAILURE (Status))
185 {
186 return (Status);
187 }
188
189 /* Initialize entire 32-bit return value to zero */
190
191 *Value = 0;
192
193 /*
194 * Two address spaces supported: Memory or IO. PCI_Config is
195 * not supported here because the GAS structure is insufficient
196 */
197 if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
198 {
199 Status = AcpiOsReadMemory ((ACPI_PHYSICAL_ADDRESS)
200 Address, &Value64, Reg->BitWidth);
201
202 *Value = (UINT32) Value64;
203 }
204 else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
205 {
206 Status = AcpiHwReadPort ((ACPI_IO_ADDRESS)
207 Address, Value, Reg->BitWidth);
208 }
209
210 ACPI_DEBUG_PRINT ((ACPI_DB_IO,
211 "Read: %8.8X width %2d from %8.8X%8.8X (%s)\n",
212 *Value, Reg->BitWidth, ACPI_FORMAT_UINT64 (Address),
213 AcpiUtGetRegionName (Reg->SpaceId)));
214
215 return (Status);
216 }
217
218
219 /******************************************************************************
220 *
221 * FUNCTION: AcpiHwWrite
222 *
223 * PARAMETERS: Value - Value to be written
224 * Reg - GAS register structure
225 *
226 * RETURN: Status
227 *
228 * DESCRIPTION: Write to either memory or IO space. This is a 32-bit max
229 * version of AcpiWrite, used internally since the overhead of
230 * 64-bit values is not needed.
231 *
232 ******************************************************************************/
233
234 ACPI_STATUS
235 AcpiHwWrite (
236 UINT32 Value,
237 ACPI_GENERIC_ADDRESS *Reg)
238 {
239 UINT64 Address;
240 ACPI_STATUS Status;
241
242
243 ACPI_FUNCTION_NAME (HwWrite);
244
245
246 /* Validate contents of the GAS register */
247
248 Status = AcpiHwValidateRegister (Reg, 32, &Address);
249 if (ACPI_FAILURE (Status))
250 {
251 return (Status);
252 }
253
254 /*
255 * Two address spaces supported: Memory or IO. PCI_Config is
256 * not supported here because the GAS structure is insufficient
257 */
258 if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
259 {
260 Status = AcpiOsWriteMemory ((ACPI_PHYSICAL_ADDRESS)
261 Address, (UINT64) Value, Reg->BitWidth);
262 }
263 else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
264 {
265 Status = AcpiHwWritePort ((ACPI_IO_ADDRESS)
266 Address, Value, Reg->BitWidth);
267 }
268
269 ACPI_DEBUG_PRINT ((ACPI_DB_IO,
270 "Wrote: %8.8X width %2d to %8.8X%8.8X (%s)\n",
271 Value, Reg->BitWidth, ACPI_FORMAT_UINT64 (Address),
272 AcpiUtGetRegionName (Reg->SpaceId)));
273
274 return (Status);
275 }
276
277
278 #if (!ACPI_REDUCED_HARDWARE)
279 /*******************************************************************************
280 *
281 * FUNCTION: AcpiHwClearAcpiStatus
282 *
283 * PARAMETERS: None
284 *
285 * RETURN: Status
286 *
287 * DESCRIPTION: Clears all fixed and general purpose status bits
288 *
289 ******************************************************************************/
290
291 ACPI_STATUS
292 AcpiHwClearAcpiStatus (
293 void)
294 {
295 ACPI_STATUS Status;
296 ACPI_CPU_FLAGS LockFlags = 0;
297
298
299 ACPI_FUNCTION_TRACE (HwClearAcpiStatus);
300
301
302 ACPI_DEBUG_PRINT ((ACPI_DB_IO, "About to write %04X to %8.8X%8.8X\n",
303 ACPI_BITMASK_ALL_FIXED_STATUS,
304 ACPI_FORMAT_UINT64 (AcpiGbl_XPm1aStatus.Address)));
305
306 LockFlags = AcpiOsAcquireLock (AcpiGbl_HardwareLock);
307
308 /* Clear the fixed events in PM1 A/B */
309
310 Status = AcpiHwRegisterWrite (ACPI_REGISTER_PM1_STATUS,
311 ACPI_BITMASK_ALL_FIXED_STATUS);
312
313 AcpiOsReleaseLock (AcpiGbl_HardwareLock, LockFlags);
314
315 if (ACPI_FAILURE (Status))
316 {
317 goto Exit;
318 }
319
320 /* Clear the GPE Bits in all GPE registers in all GPE blocks */
321
322 Status = AcpiEvWalkGpeList (AcpiHwClearGpeBlock, NULL);
323
324 Exit:
325 return_ACPI_STATUS (Status);
326 }
327
328
329 /*******************************************************************************
330 *
331 * FUNCTION: AcpiHwGetBitRegisterInfo
332 *
333 * PARAMETERS: RegisterId - Index of ACPI Register to access
334 *
335 * RETURN: The bitmask to be used when accessing the register
336 *
337 * DESCRIPTION: Map RegisterId into a register bitmask.
338 *
339 ******************************************************************************/
340
341 ACPI_BIT_REGISTER_INFO *
342 AcpiHwGetBitRegisterInfo (
343 UINT32 RegisterId)
344 {
345 ACPI_FUNCTION_ENTRY ();
346
347
348 if (RegisterId > ACPI_BITREG_MAX)
349 {
350 ACPI_ERROR ((AE_INFO, "Invalid BitRegister ID: 0x%X", RegisterId));
351 return (NULL);
352 }
353
354 return (&AcpiGbl_BitRegisterInfo[RegisterId]);
355 }
356
357
358 /******************************************************************************
359 *
360 * FUNCTION: AcpiHwWritePm1Control
361 *
362 * PARAMETERS: Pm1aControl - Value to be written to PM1A control
363 * Pm1bControl - Value to be written to PM1B control
364 *
365 * RETURN: Status
366 *
367 * DESCRIPTION: Write the PM1 A/B control registers. These registers are
368 * different than than the PM1 A/B status and enable registers
369 * in that different values can be written to the A/B registers.
370 * Most notably, the SLP_TYP bits can be different, as per the
371 * values returned from the _Sx predefined methods.
372 *
373 ******************************************************************************/
374
375 ACPI_STATUS
376 AcpiHwWritePm1Control (
377 UINT32 Pm1aControl,
378 UINT32 Pm1bControl)
379 {
380 ACPI_STATUS Status;
381
382
383 ACPI_FUNCTION_TRACE (HwWritePm1Control);
384
385
386 Status = AcpiHwWrite (Pm1aControl, &AcpiGbl_FADT.XPm1aControlBlock);
387 if (ACPI_FAILURE (Status))
388 {
389 return_ACPI_STATUS (Status);
390 }
391
392 if (AcpiGbl_FADT.XPm1bControlBlock.Address)
393 {
394 Status = AcpiHwWrite (Pm1bControl, &AcpiGbl_FADT.XPm1bControlBlock);
395 }
396 return_ACPI_STATUS (Status);
397 }
398
399
400 /******************************************************************************
401 *
402 * FUNCTION: AcpiHwRegisterRead
403 *
404 * PARAMETERS: RegisterId - ACPI Register ID
405 * ReturnValue - Where the register value is returned
406 *
407 * RETURN: Status and the value read.
408 *
409 * DESCRIPTION: Read from the specified ACPI register
410 *
411 ******************************************************************************/
412
413 ACPI_STATUS
414 AcpiHwRegisterRead (
415 UINT32 RegisterId,
416 UINT32 *ReturnValue)
417 {
418 UINT32 Value = 0;
419 ACPI_STATUS Status;
420
421
422 ACPI_FUNCTION_TRACE (HwRegisterRead);
423
424
425 switch (RegisterId)
426 {
427 case ACPI_REGISTER_PM1_STATUS: /* PM1 A/B: 16-bit access each */
428
429 Status = AcpiHwReadMultiple (&Value,
430 &AcpiGbl_XPm1aStatus,
431 &AcpiGbl_XPm1bStatus);
432 break;
433
434 case ACPI_REGISTER_PM1_ENABLE: /* PM1 A/B: 16-bit access each */
435
436 Status = AcpiHwReadMultiple (&Value,
437 &AcpiGbl_XPm1aEnable,
438 &AcpiGbl_XPm1bEnable);
439 break;
440
441 case ACPI_REGISTER_PM1_CONTROL: /* PM1 A/B: 16-bit access each */
442
443 Status = AcpiHwReadMultiple (&Value,
444 &AcpiGbl_FADT.XPm1aControlBlock,
445 &AcpiGbl_FADT.XPm1bControlBlock);
446
447 /*
448 * Zero the write-only bits. From the ACPI specification, "Hardware
449 * Write-Only Bits": "Upon reads to registers with write-only bits,
450 * software masks out all write-only bits."
451 */
452 Value &= ~ACPI_PM1_CONTROL_WRITEONLY_BITS;
453 break;
454
455 case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
456
457 Status = AcpiHwRead (&Value, &AcpiGbl_FADT.XPm2ControlBlock);
458 break;
459
460 case ACPI_REGISTER_PM_TIMER: /* 32-bit access */
461
462 Status = AcpiHwRead (&Value, &AcpiGbl_FADT.XPmTimerBlock);
463 break;
464
465 case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */
466
467 Status = AcpiHwReadPort (AcpiGbl_FADT.SmiCommand, &Value, 8);
468 break;
469
470 default:
471
472 ACPI_ERROR ((AE_INFO, "Unknown Register ID: 0x%X",
473 RegisterId));
474 Status = AE_BAD_PARAMETER;
475 break;
476 }
477
478 if (ACPI_SUCCESS (Status))
479 {
480 *ReturnValue = Value;
481 }
482
483 return_ACPI_STATUS (Status);
484 }
485
486
487 /******************************************************************************
488 *
489 * FUNCTION: AcpiHwRegisterWrite
490 *
491 * PARAMETERS: RegisterId - ACPI Register ID
492 * Value - The value to write
493 *
494 * RETURN: Status
495 *
496 * DESCRIPTION: Write to the specified ACPI register
497 *
498 * NOTE: In accordance with the ACPI specification, this function automatically
499 * preserves the value of the following bits, meaning that these bits cannot be
500 * changed via this interface:
501 *
502 * PM1_CONTROL[0] = SCI_EN
503 * PM1_CONTROL[9]
504 * PM1_STATUS[11]
505 *
506 * ACPI References:
507 * 1) Hardware Ignored Bits: When software writes to a register with ignored
508 * bit fields, it preserves the ignored bit fields
509 * 2) SCI_EN: OSPM always preserves this bit position
510 *
511 ******************************************************************************/
512
513 ACPI_STATUS
514 AcpiHwRegisterWrite (
515 UINT32 RegisterId,
516 UINT32 Value)
517 {
518 ACPI_STATUS Status;
519 UINT32 ReadValue;
520
521
522 ACPI_FUNCTION_TRACE (HwRegisterWrite);
523
524
525 switch (RegisterId)
526 {
527 case ACPI_REGISTER_PM1_STATUS: /* PM1 A/B: 16-bit access each */
528 /*
529 * Handle the "ignored" bit in PM1 Status. According to the ACPI
530 * specification, ignored bits are to be preserved when writing.
531 * Normally, this would mean a read/modify/write sequence. However,
532 * preserving a bit in the status register is different. Writing a
533 * one clears the status, and writing a zero preserves the status.
534 * Therefore, we must always write zero to the ignored bit.
535 *
536 * This behavior is clarified in the ACPI 4.0 specification.
537 */
538 Value &= ~ACPI_PM1_STATUS_PRESERVED_BITS;
539
540 Status = AcpiHwWriteMultiple (Value,
541 &AcpiGbl_XPm1aStatus,
542 &AcpiGbl_XPm1bStatus);
543 break;
544
545 case ACPI_REGISTER_PM1_ENABLE: /* PM1 A/B: 16-bit access each */
546
547 Status = AcpiHwWriteMultiple (Value,
548 &AcpiGbl_XPm1aEnable,
549 &AcpiGbl_XPm1bEnable);
550 break;
551
552 case ACPI_REGISTER_PM1_CONTROL: /* PM1 A/B: 16-bit access each */
553 /*
554 * Perform a read first to preserve certain bits (per ACPI spec)
555 * Note: This includes SCI_EN, we never want to change this bit
556 */
557 Status = AcpiHwReadMultiple (&ReadValue,
558 &AcpiGbl_FADT.XPm1aControlBlock,
559 &AcpiGbl_FADT.XPm1bControlBlock);
560 if (ACPI_FAILURE (Status))
561 {
562 goto Exit;
563 }
564
565 /* Insert the bits to be preserved */
566
567 ACPI_INSERT_BITS (Value, ACPI_PM1_CONTROL_PRESERVED_BITS, ReadValue);
568
569 /* Now we can write the data */
570
571 Status = AcpiHwWriteMultiple (Value,
572 &AcpiGbl_FADT.XPm1aControlBlock,
573 &AcpiGbl_FADT.XPm1bControlBlock);
574 break;
575
576 case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
577 /*
578 * For control registers, all reserved bits must be preserved,
579 * as per the ACPI spec.
580 */
581 Status = AcpiHwRead (&ReadValue, &AcpiGbl_FADT.XPm2ControlBlock);
582 if (ACPI_FAILURE (Status))
583 {
584 goto Exit;
585 }
586
587 /* Insert the bits to be preserved */
588
589 ACPI_INSERT_BITS (Value, ACPI_PM2_CONTROL_PRESERVED_BITS, ReadValue);
590
591 Status = AcpiHwWrite (Value, &AcpiGbl_FADT.XPm2ControlBlock);
592 break;
593
594 case ACPI_REGISTER_PM_TIMER: /* 32-bit access */
595
596 Status = AcpiHwWrite (Value, &AcpiGbl_FADT.XPmTimerBlock);
597 break;
598
599 case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */
600
601 /* SMI_CMD is currently always in IO space */
602
603 Status = AcpiHwWritePort (AcpiGbl_FADT.SmiCommand, Value, 8);
604 break;
605
606 default:
607
608 ACPI_ERROR ((AE_INFO, "Unknown Register ID: 0x%X",
609 RegisterId));
610 Status = AE_BAD_PARAMETER;
611 break;
612 }
613
614 Exit:
615 return_ACPI_STATUS (Status);
616 }
617
618
619 /******************************************************************************
620 *
621 * FUNCTION: AcpiHwReadMultiple
622 *
623 * PARAMETERS: Value - Where the register value is returned
624 * RegisterA - First ACPI register (required)
625 * RegisterB - Second ACPI register (optional)
626 *
627 * RETURN: Status
628 *
629 * DESCRIPTION: Read from the specified two-part ACPI register (such as PM1 A/B)
630 *
631 ******************************************************************************/
632
633 static ACPI_STATUS
634 AcpiHwReadMultiple (
635 UINT32 *Value,
636 ACPI_GENERIC_ADDRESS *RegisterA,
637 ACPI_GENERIC_ADDRESS *RegisterB)
638 {
639 UINT32 ValueA = 0;
640 UINT32 ValueB = 0;
641 ACPI_STATUS Status;
642
643
644 /* The first register is always required */
645
646 Status = AcpiHwRead (&ValueA, RegisterA);
647 if (ACPI_FAILURE (Status))
648 {
649 return (Status);
650 }
651
652 /* Second register is optional */
653
654 if (RegisterB->Address)
655 {
656 Status = AcpiHwRead (&ValueB, RegisterB);
657 if (ACPI_FAILURE (Status))
658 {
659 return (Status);
660 }
661 }
662
663 /*
664 * OR the two return values together. No shifting or masking is necessary,
665 * because of how the PM1 registers are defined in the ACPI specification:
666 *
667 * "Although the bits can be split between the two register blocks (each
668 * register block has a unique pointer within the FADT), the bit positions
669 * are maintained. The register block with unimplemented bits (that is,
670 * those implemented in the other register block) always returns zeros,
671 * and writes have no side effects"
672 */
673 *Value = (ValueA | ValueB);
674 return (AE_OK);
675 }
676
677
678 /******************************************************************************
679 *
680 * FUNCTION: AcpiHwWriteMultiple
681 *
682 * PARAMETERS: Value - The value to write
683 * RegisterA - First ACPI register (required)
684 * RegisterB - Second ACPI register (optional)
685 *
686 * RETURN: Status
687 *
688 * DESCRIPTION: Write to the specified two-part ACPI register (such as PM1 A/B)
689 *
690 ******************************************************************************/
691
692 static ACPI_STATUS
693 AcpiHwWriteMultiple (
694 UINT32 Value,
695 ACPI_GENERIC_ADDRESS *RegisterA,
696 ACPI_GENERIC_ADDRESS *RegisterB)
697 {
698 ACPI_STATUS Status;
699
700
701 /* The first register is always required */
702
703 Status = AcpiHwWrite (Value, RegisterA);
704 if (ACPI_FAILURE (Status))
705 {
706 return (Status);
707 }
708
709 /*
710 * Second register is optional
711 *
712 * No bit shifting or clearing is necessary, because of how the PM1
713 * registers are defined in the ACPI specification:
714 *
715 * "Although the bits can be split between the two register blocks (each
716 * register block has a unique pointer within the FADT), the bit positions
717 * are maintained. The register block with unimplemented bits (that is,
718 * those implemented in the other register block) always returns zeros,
719 * and writes have no side effects"
720 */
721 if (RegisterB->Address)
722 {
723 Status = AcpiHwWrite (Value, RegisterB);
724 }
725
726 return (Status);
727 }
728
729 #endif /* !ACPI_REDUCED_HARDWARE */