4 * Copyright (c) 2006 Fabrice Bellard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License version 2 as published by the Free Software Foundation.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, see <http://www.gnu.org/licenses/>
18 * Contributions after 2012-01-13 are licensed under the terms of the
19 * GNU GPL, version 2 or (at your option) any later version.
22 #include "qemu/osdep.h"
23 #include "sysemu/sysemu.h"
25 #include "hw/acpi/acpi.h"
26 #include "hw/nvram/fw_cfg.h"
27 #include "qemu/config-file.h"
28 #include "qapi/error.h"
29 #include "qapi/opts-visitor.h"
30 #include "qapi/qapi-events-run-state.h"
31 #include "qapi/qapi-visit-misc.h"
32 #include "qemu/error-report.h"
33 #include "qemu/option.h"
35 struct acpi_table_header
{
36 uint16_t _length
; /* our length, not actual part of the hdr */
37 /* allows easier parsing for fw_cfg clients */
39 QEMU_NONSTRING
; /* ACPI signature (4 ASCII characters) */
40 uint32_t length
; /* Length of table, in bytes, including header */
41 uint8_t revision
; /* ACPI Specification minor version # */
42 uint8_t checksum
; /* To make sum of entire table == 0 */
44 QEMU_NONSTRING
; /* OEM identification */
46 QEMU_NONSTRING
; /* OEM table identification */
47 uint32_t oem_revision
; /* OEM revision number */
48 char asl_compiler_id
[4]
49 QEMU_NONSTRING
; /* ASL compiler vendor ID */
50 uint32_t asl_compiler_revision
; /* ASL compiler revision number */
53 #define ACPI_TABLE_HDR_SIZE sizeof(struct acpi_table_header)
54 #define ACPI_TABLE_PFX_SIZE sizeof(uint16_t) /* size of the extra prefix */
56 static const char unsigned dfl_hdr
[ACPI_TABLE_HDR_SIZE
- ACPI_TABLE_PFX_SIZE
] =
57 "QEMU\0\0\0\0\1\0" /* sig (4), len(4), revno (1), csum (1) */
58 "QEMUQEQEMUQEMU\1\0\0\0" /* OEM id (6), table (8), revno (4) */
59 "QEMU\1\0\0\0" /* ASL compiler ID (4), version (4) */
62 char unsigned *acpi_tables
;
63 size_t acpi_tables_len
;
65 static QemuOptsList qemu_acpi_opts
= {
67 .implied_opt_name
= "data",
68 .head
= QTAILQ_HEAD_INITIALIZER(qemu_acpi_opts
.head
),
69 .desc
= { { 0 } } /* validated with OptsVisitor */
72 static void acpi_register_config(void)
74 qemu_add_opts(&qemu_acpi_opts
);
77 opts_init(acpi_register_config
);
79 static int acpi_checksum(const uint8_t *data
, int len
)
83 for (i
= 0; i
< len
; i
++) {
90 /* Install a copy of the ACPI table specified in @blob.
92 * If @has_header is set, @blob starts with the System Description Table Header
93 * structure. Otherwise, "dfl_hdr" is prepended. In any case, each header field
94 * is optionally overwritten from @hdrs.
96 * It is valid to call this function with
97 * (@blob == NULL && bloblen == 0 && !has_header).
99 * @hdrs->file and @hdrs->data are ignored.
101 * SIZE_MAX is considered "infinity" in this function.
103 * The number of tables that can be installed is not limited, but the 16-bit
104 * counter at the beginning of "acpi_tables" wraps around after UINT16_MAX.
106 static void acpi_table_install(const char unsigned *blob
, size_t bloblen
,
108 const struct AcpiTableOptions
*hdrs
,
112 const char unsigned *hdr_src
;
113 size_t body_size
, acpi_payload_size
;
114 struct acpi_table_header
*ext_hdr
;
115 unsigned changed_fields
;
117 /* Calculate where the ACPI table body starts within the blob, plus where
118 * to copy the ACPI table header from.
121 /* _length | ACPI header in blob | blob body
122 * ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
123 * ACPI_TABLE_PFX_SIZE sizeof dfl_hdr body_size
126 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
127 * acpi_payload_size == bloblen
129 body_start
= sizeof dfl_hdr
;
131 if (bloblen
< body_start
) {
132 error_setg(errp
, "ACPI table claiming to have header is too "
133 "short, available: %zu, expected: %zu", bloblen
,
139 /* _length | ACPI header in template | blob body
140 * ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^
141 * ACPI_TABLE_PFX_SIZE sizeof dfl_hdr body_size
144 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
150 body_size
= bloblen
- body_start
;
151 acpi_payload_size
= sizeof dfl_hdr
+ body_size
;
153 if (acpi_payload_size
> UINT16_MAX
) {
154 error_setg(errp
, "ACPI table too big, requested: %zu, max: %u",
155 acpi_payload_size
, (unsigned)UINT16_MAX
);
159 /* We won't fail from here on. Initialize / extend the globals. */
160 if (acpi_tables
== NULL
) {
161 acpi_tables_len
= sizeof(uint16_t);
162 acpi_tables
= g_malloc0(acpi_tables_len
);
165 acpi_tables
= g_realloc(acpi_tables
, acpi_tables_len
+
166 ACPI_TABLE_PFX_SIZE
+
167 sizeof dfl_hdr
+ body_size
);
169 ext_hdr
= (struct acpi_table_header
*)(acpi_tables
+ acpi_tables_len
);
170 acpi_tables_len
+= ACPI_TABLE_PFX_SIZE
;
172 memcpy(acpi_tables
+ acpi_tables_len
, hdr_src
, sizeof dfl_hdr
);
173 acpi_tables_len
+= sizeof dfl_hdr
;
176 memcpy(acpi_tables
+ acpi_tables_len
, blob
+ body_start
, body_size
);
177 acpi_tables_len
+= body_size
;
180 /* increase number of tables */
181 stw_le_p(acpi_tables
, lduw_le_p(acpi_tables
) + 1u);
183 /* Update the header fields. The strings need not be NUL-terminated. */
185 ext_hdr
->_length
= cpu_to_le16(acpi_payload_size
);
188 strncpy(ext_hdr
->sig
, hdrs
->sig
, sizeof ext_hdr
->sig
);
192 if (has_header
&& le32_to_cpu(ext_hdr
->length
) != acpi_payload_size
) {
193 warn_report("ACPI table has wrong length, header says "
194 "%" PRIu32
", actual size %zu bytes",
195 le32_to_cpu(ext_hdr
->length
), acpi_payload_size
);
197 ext_hdr
->length
= cpu_to_le32(acpi_payload_size
);
200 ext_hdr
->revision
= hdrs
->rev
;
204 ext_hdr
->checksum
= 0;
206 if (hdrs
->has_oem_id
) {
207 strncpy(ext_hdr
->oem_id
, hdrs
->oem_id
, sizeof ext_hdr
->oem_id
);
210 if (hdrs
->has_oem_table_id
) {
211 strncpy(ext_hdr
->oem_table_id
, hdrs
->oem_table_id
,
212 sizeof ext_hdr
->oem_table_id
);
215 if (hdrs
->has_oem_rev
) {
216 ext_hdr
->oem_revision
= cpu_to_le32(hdrs
->oem_rev
);
219 if (hdrs
->has_asl_compiler_id
) {
220 strncpy(ext_hdr
->asl_compiler_id
, hdrs
->asl_compiler_id
,
221 sizeof ext_hdr
->asl_compiler_id
);
224 if (hdrs
->has_asl_compiler_rev
) {
225 ext_hdr
->asl_compiler_revision
= cpu_to_le32(hdrs
->asl_compiler_rev
);
229 if (!has_header
&& changed_fields
== 0) {
230 warn_report("ACPI table: no headers are specified");
233 /* recalculate checksum */
234 ext_hdr
->checksum
= acpi_checksum((const char unsigned *)ext_hdr
+
235 ACPI_TABLE_PFX_SIZE
, acpi_payload_size
);
238 void acpi_table_add(const QemuOpts
*opts
, Error
**errp
)
240 AcpiTableOptions
*hdrs
= NULL
;
242 char **pathnames
= NULL
;
245 char unsigned *blob
= NULL
;
250 v
= opts_visitor_new(opts
);
251 visit_type_AcpiTableOptions(v
, NULL
, &hdrs
, &err
);
258 if (hdrs
->has_file
== hdrs
->has_data
) {
259 error_setg(&err
, "'-acpitable' requires one of 'data' or 'file'");
263 pathnames
= g_strsplit(hdrs
->has_file
? hdrs
->file
: hdrs
->data
, ":", 0);
264 if (pathnames
== NULL
|| pathnames
[0] == NULL
) {
265 error_setg(&err
, "'-acpitable' requires at least one pathname");
269 /* now read in the data files, reallocating buffer as needed */
270 for (cur
= pathnames
; *cur
; ++cur
) {
271 int fd
= open(*cur
, O_RDONLY
| O_BINARY
);
274 error_setg(&err
, "can't open file %s: %s", *cur
, strerror(errno
));
279 char unsigned data
[8192];
282 r
= read(fd
, data
, sizeof data
);
286 blob
= g_realloc(blob
, bloblen
+ r
);
287 memcpy(blob
+ bloblen
, data
, r
);
289 } else if (errno
!= EINTR
) {
290 error_setg(&err
, "can't read file %s: %s",
291 *cur
, strerror(errno
));
300 acpi_table_install(blob
, bloblen
, hdrs
->has_file
, hdrs
, &err
);
304 g_strfreev(pathnames
);
305 qapi_free_AcpiTableOptions(hdrs
);
307 error_propagate(errp
, err
);
310 static bool acpi_table_builtin
= false;
312 void acpi_table_add_builtin(const QemuOpts
*opts
, Error
**errp
)
314 acpi_table_builtin
= true;
315 acpi_table_add(opts
, errp
);
318 unsigned acpi_table_len(void *current
)
320 struct acpi_table_header
*hdr
= current
- sizeof(hdr
->_length
);
325 void *acpi_table_hdr(void *h
)
327 struct acpi_table_header
*hdr
= h
;
331 uint8_t *acpi_table_first(void)
333 if (acpi_table_builtin
|| !acpi_tables
) {
336 return acpi_table_hdr(acpi_tables
+ ACPI_TABLE_PFX_SIZE
);
339 uint8_t *acpi_table_next(uint8_t *current
)
341 uint8_t *next
= current
+ acpi_table_len(current
);
343 if (next
- acpi_tables
>= acpi_tables_len
) {
346 return acpi_table_hdr(next
);
350 int acpi_get_slic_oem(AcpiSlicOem
*oem
)
354 for (u
= acpi_table_first(); u
; u
= acpi_table_next(u
)) {
355 struct acpi_table_header
*hdr
= (void *)(u
- sizeof(hdr
->_length
));
357 if (memcmp(hdr
->sig
, "SLIC", 4) == 0) {
358 oem
->id
= hdr
->oem_id
;
359 oem
->table_id
= hdr
->oem_table_id
;
366 static void acpi_notify_wakeup(Notifier
*notifier
, void *data
)
368 ACPIREGS
*ar
= container_of(notifier
, ACPIREGS
, wakeup
);
369 WakeupReason
*reason
= data
;
372 case QEMU_WAKEUP_REASON_RTC
:
374 (ACPI_BITMASK_WAKE_STATUS
| ACPI_BITMASK_RT_CLOCK_STATUS
);
376 case QEMU_WAKEUP_REASON_PMTIMER
:
378 (ACPI_BITMASK_WAKE_STATUS
| ACPI_BITMASK_TIMER_STATUS
);
380 case QEMU_WAKEUP_REASON_OTHER
:
381 /* ACPI_BITMASK_WAKE_STATUS should be set on resume.
382 Pretend that resume was caused by power button */
384 (ACPI_BITMASK_WAKE_STATUS
| ACPI_BITMASK_POWER_BUTTON_STATUS
);
392 uint16_t acpi_pm1_evt_get_sts(ACPIREGS
*ar
)
394 /* Compare ns-clock, not PM timer ticks, because
395 acpi_pm_tmr_update function uses ns for setting the timer. */
396 int64_t d
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
397 if (d
>= muldiv64(ar
->tmr
.overflow_time
,
398 NANOSECONDS_PER_SECOND
, PM_TIMER_FREQUENCY
)) {
399 ar
->pm1
.evt
.sts
|= ACPI_BITMASK_TIMER_STATUS
;
401 return ar
->pm1
.evt
.sts
;
404 static void acpi_pm1_evt_write_sts(ACPIREGS
*ar
, uint16_t val
)
406 uint16_t pm1_sts
= acpi_pm1_evt_get_sts(ar
);
407 if (pm1_sts
& val
& ACPI_BITMASK_TIMER_STATUS
) {
408 /* if TMRSTS is reset, then compute the new overflow time */
409 acpi_pm_tmr_calc_overflow_time(ar
);
411 ar
->pm1
.evt
.sts
&= ~val
;
414 static void acpi_pm1_evt_write_en(ACPIREGS
*ar
, uint16_t val
)
416 ar
->pm1
.evt
.en
= val
;
417 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_RTC
,
418 val
& ACPI_BITMASK_RT_CLOCK_ENABLE
);
419 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_PMTIMER
,
420 val
& ACPI_BITMASK_TIMER_ENABLE
);
423 void acpi_pm1_evt_power_down(ACPIREGS
*ar
)
425 if (ar
->pm1
.evt
.en
& ACPI_BITMASK_POWER_BUTTON_ENABLE
) {
426 ar
->pm1
.evt
.sts
|= ACPI_BITMASK_POWER_BUTTON_STATUS
;
427 ar
->tmr
.update_sci(ar
);
431 void acpi_pm1_evt_reset(ACPIREGS
*ar
)
435 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_RTC
, 0);
436 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_PMTIMER
, 0);
439 static uint64_t acpi_pm_evt_read(void *opaque
, hwaddr addr
, unsigned width
)
441 ACPIREGS
*ar
= opaque
;
444 return acpi_pm1_evt_get_sts(ar
);
446 return ar
->pm1
.evt
.en
;
452 static void acpi_pm_evt_write(void *opaque
, hwaddr addr
, uint64_t val
,
455 ACPIREGS
*ar
= opaque
;
458 acpi_pm1_evt_write_sts(ar
, val
);
459 ar
->pm1
.evt
.update_sci(ar
);
462 acpi_pm1_evt_write_en(ar
, val
);
463 ar
->pm1
.evt
.update_sci(ar
);
468 static const MemoryRegionOps acpi_pm_evt_ops
= {
469 .read
= acpi_pm_evt_read
,
470 .write
= acpi_pm_evt_write
,
471 .valid
.min_access_size
= 2,
472 .valid
.max_access_size
= 2,
473 .endianness
= DEVICE_LITTLE_ENDIAN
,
476 void acpi_pm1_evt_init(ACPIREGS
*ar
, acpi_update_sci_fn update_sci
,
477 MemoryRegion
*parent
)
479 ar
->pm1
.evt
.update_sci
= update_sci
;
480 memory_region_init_io(&ar
->pm1
.evt
.io
, memory_region_owner(parent
),
481 &acpi_pm_evt_ops
, ar
, "acpi-evt", 4);
482 memory_region_add_subregion(parent
, 0, &ar
->pm1
.evt
.io
);
486 void acpi_pm_tmr_update(ACPIREGS
*ar
, bool enable
)
490 /* schedule a timer interruption if needed */
492 expire_time
= muldiv64(ar
->tmr
.overflow_time
, NANOSECONDS_PER_SECOND
,
494 timer_mod(ar
->tmr
.timer
, expire_time
);
496 timer_del(ar
->tmr
.timer
);
500 static inline int64_t acpi_pm_tmr_get_clock(void)
502 return muldiv64(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
), PM_TIMER_FREQUENCY
,
503 NANOSECONDS_PER_SECOND
);
506 void acpi_pm_tmr_calc_overflow_time(ACPIREGS
*ar
)
508 int64_t d
= acpi_pm_tmr_get_clock();
509 ar
->tmr
.overflow_time
= (d
+ 0x800000LL
) & ~0x7fffffLL
;
512 static uint32_t acpi_pm_tmr_get(ACPIREGS
*ar
)
514 uint32_t d
= acpi_pm_tmr_get_clock();
518 static void acpi_pm_tmr_timer(void *opaque
)
520 ACPIREGS
*ar
= opaque
;
522 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_PMTIMER
, NULL
);
523 ar
->tmr
.update_sci(ar
);
526 static uint64_t acpi_pm_tmr_read(void *opaque
, hwaddr addr
, unsigned width
)
528 return acpi_pm_tmr_get(opaque
);
531 static void acpi_pm_tmr_write(void *opaque
, hwaddr addr
, uint64_t val
,
537 static const MemoryRegionOps acpi_pm_tmr_ops
= {
538 .read
= acpi_pm_tmr_read
,
539 .write
= acpi_pm_tmr_write
,
540 .valid
.min_access_size
= 4,
541 .valid
.max_access_size
= 4,
542 .endianness
= DEVICE_LITTLE_ENDIAN
,
545 void acpi_pm_tmr_init(ACPIREGS
*ar
, acpi_update_sci_fn update_sci
,
546 MemoryRegion
*parent
)
548 ar
->tmr
.update_sci
= update_sci
;
549 ar
->tmr
.timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, acpi_pm_tmr_timer
, ar
);
550 memory_region_init_io(&ar
->tmr
.io
, memory_region_owner(parent
),
551 &acpi_pm_tmr_ops
, ar
, "acpi-tmr", 4);
552 memory_region_add_subregion(parent
, 8, &ar
->tmr
.io
);
555 void acpi_pm_tmr_reset(ACPIREGS
*ar
)
557 ar
->tmr
.overflow_time
= 0;
558 timer_del(ar
->tmr
.timer
);
562 static void acpi_pm1_cnt_write(ACPIREGS
*ar
, uint16_t val
)
564 ar
->pm1
.cnt
.cnt
= val
& ~(ACPI_BITMASK_SLEEP_ENABLE
);
566 if (val
& ACPI_BITMASK_SLEEP_ENABLE
) {
567 /* change suspend type */
568 uint16_t sus_typ
= (val
>> 10) & 7;
570 case 0: /* soft power off */
571 qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN
);
574 qemu_system_suspend_request();
577 if (sus_typ
== ar
->pm1
.cnt
.s4_val
) { /* S4 request */
578 qapi_event_send_suspend_disk();
579 qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN
);
586 void acpi_pm1_cnt_update(ACPIREGS
*ar
,
587 bool sci_enable
, bool sci_disable
)
589 /* ACPI specs 3.0, 4.7.2.5 */
591 ar
->pm1
.cnt
.cnt
|= ACPI_BITMASK_SCI_ENABLE
;
592 } else if (sci_disable
) {
593 ar
->pm1
.cnt
.cnt
&= ~ACPI_BITMASK_SCI_ENABLE
;
597 static uint64_t acpi_pm_cnt_read(void *opaque
, hwaddr addr
, unsigned width
)
599 ACPIREGS
*ar
= opaque
;
600 return ar
->pm1
.cnt
.cnt
;
603 static void acpi_pm_cnt_write(void *opaque
, hwaddr addr
, uint64_t val
,
606 acpi_pm1_cnt_write(opaque
, val
);
609 static const MemoryRegionOps acpi_pm_cnt_ops
= {
610 .read
= acpi_pm_cnt_read
,
611 .write
= acpi_pm_cnt_write
,
612 .valid
.min_access_size
= 2,
613 .valid
.max_access_size
= 2,
614 .endianness
= DEVICE_LITTLE_ENDIAN
,
617 void acpi_pm1_cnt_init(ACPIREGS
*ar
, MemoryRegion
*parent
,
618 bool disable_s3
, bool disable_s4
, uint8_t s4_val
)
622 ar
->pm1
.cnt
.s4_val
= s4_val
;
623 ar
->wakeup
.notify
= acpi_notify_wakeup
;
624 qemu_register_wakeup_notifier(&ar
->wakeup
);
627 * Register wake-up support in QMP query-current-machine API
629 qemu_register_wakeup_support();
631 memory_region_init_io(&ar
->pm1
.cnt
.io
, memory_region_owner(parent
),
632 &acpi_pm_cnt_ops
, ar
, "acpi-cnt", 2);
633 memory_region_add_subregion(parent
, 4, &ar
->pm1
.cnt
.io
);
635 fw_cfg
= fw_cfg_find();
637 uint8_t suspend
[6] = {128, 0, 0, 129, 128, 128};
638 suspend
[3] = 1 | ((!disable_s3
) << 7);
639 suspend
[4] = s4_val
| ((!disable_s4
) << 7);
641 fw_cfg_add_file(fw_cfg
, "etc/system-states", g_memdup(suspend
, 6), 6);
645 void acpi_pm1_cnt_reset(ACPIREGS
*ar
)
651 void acpi_gpe_init(ACPIREGS
*ar
, uint8_t len
)
654 /* Only first len / 2 bytes are ever used,
655 * but the caller in ich9.c migrates full len bytes.
656 * TODO: fix ich9.c and drop the extra allocation.
658 ar
->gpe
.sts
= g_malloc0(len
);
659 ar
->gpe
.en
= g_malloc0(len
);
662 void acpi_gpe_reset(ACPIREGS
*ar
)
664 memset(ar
->gpe
.sts
, 0, ar
->gpe
.len
/ 2);
665 memset(ar
->gpe
.en
, 0, ar
->gpe
.len
/ 2);
668 static uint8_t *acpi_gpe_ioport_get_ptr(ACPIREGS
*ar
, uint32_t addr
)
672 if (addr
< ar
->gpe
.len
/ 2) {
673 cur
= ar
->gpe
.sts
+ addr
;
674 } else if (addr
< ar
->gpe
.len
) {
675 cur
= ar
->gpe
.en
+ addr
- ar
->gpe
.len
/ 2;
683 void acpi_gpe_ioport_writeb(ACPIREGS
*ar
, uint32_t addr
, uint32_t val
)
687 cur
= acpi_gpe_ioport_get_ptr(ar
, addr
);
688 if (addr
< ar
->gpe
.len
/ 2) {
690 *cur
= (*cur
) & ~val
;
691 } else if (addr
< ar
->gpe
.len
) {
699 uint32_t acpi_gpe_ioport_readb(ACPIREGS
*ar
, uint32_t addr
)
704 cur
= acpi_gpe_ioport_get_ptr(ar
, addr
);
713 void acpi_send_gpe_event(ACPIREGS
*ar
, qemu_irq irq
,
714 AcpiEventStatusBits status
)
716 ar
->gpe
.sts
[0] |= status
;
717 acpi_update_sci(ar
, irq
);
720 void acpi_update_sci(ACPIREGS
*regs
, qemu_irq irq
)
722 int sci_level
, pm1a_sts
;
724 pm1a_sts
= acpi_pm1_evt_get_sts(regs
);
726 sci_level
= ((pm1a_sts
&
727 regs
->pm1
.evt
.en
& ACPI_BITMASK_PM1_COMMON_ENABLED
) != 0) ||
728 ((regs
->gpe
.sts
[0] & regs
->gpe
.en
[0]) != 0);
730 qemu_set_irq(irq
, sci_level
);
732 /* schedule a timer interruption if needed */
733 acpi_pm_tmr_update(regs
,
734 (regs
->pm1
.evt
.en
& ACPI_BITMASK_TIMER_ENABLE
) &&
735 !(pm1a_sts
& ACPI_BITMASK_TIMER_STATUS
));