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 unsigned acpi_table_len(void *current
)
312 struct acpi_table_header
*hdr
= current
- sizeof(hdr
->_length
);
317 void *acpi_table_hdr(void *h
)
319 struct acpi_table_header
*hdr
= h
;
323 uint8_t *acpi_table_first(void)
328 return acpi_table_hdr(acpi_tables
+ ACPI_TABLE_PFX_SIZE
);
331 uint8_t *acpi_table_next(uint8_t *current
)
333 uint8_t *next
= current
+ acpi_table_len(current
);
335 if (next
- acpi_tables
>= acpi_tables_len
) {
338 return acpi_table_hdr(next
);
342 int acpi_get_slic_oem(AcpiSlicOem
*oem
)
346 for (u
= acpi_table_first(); u
; u
= acpi_table_next(u
)) {
347 struct acpi_table_header
*hdr
= (void *)(u
- sizeof(hdr
->_length
));
349 if (memcmp(hdr
->sig
, "SLIC", 4) == 0) {
350 oem
->id
= hdr
->oem_id
;
351 oem
->table_id
= hdr
->oem_table_id
;
358 static void acpi_notify_wakeup(Notifier
*notifier
, void *data
)
360 ACPIREGS
*ar
= container_of(notifier
, ACPIREGS
, wakeup
);
361 WakeupReason
*reason
= data
;
364 case QEMU_WAKEUP_REASON_RTC
:
366 (ACPI_BITMASK_WAKE_STATUS
| ACPI_BITMASK_RT_CLOCK_STATUS
);
368 case QEMU_WAKEUP_REASON_PMTIMER
:
370 (ACPI_BITMASK_WAKE_STATUS
| ACPI_BITMASK_TIMER_STATUS
);
372 case QEMU_WAKEUP_REASON_OTHER
:
373 /* ACPI_BITMASK_WAKE_STATUS should be set on resume.
374 Pretend that resume was caused by power button */
376 (ACPI_BITMASK_WAKE_STATUS
| ACPI_BITMASK_POWER_BUTTON_STATUS
);
384 uint16_t acpi_pm1_evt_get_sts(ACPIREGS
*ar
)
386 /* Compare ns-clock, not PM timer ticks, because
387 acpi_pm_tmr_update function uses ns for setting the timer. */
388 int64_t d
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
389 if (d
>= muldiv64(ar
->tmr
.overflow_time
,
390 NANOSECONDS_PER_SECOND
, PM_TIMER_FREQUENCY
)) {
391 ar
->pm1
.evt
.sts
|= ACPI_BITMASK_TIMER_STATUS
;
393 return ar
->pm1
.evt
.sts
;
396 static void acpi_pm1_evt_write_sts(ACPIREGS
*ar
, uint16_t val
)
398 uint16_t pm1_sts
= acpi_pm1_evt_get_sts(ar
);
399 if (pm1_sts
& val
& ACPI_BITMASK_TIMER_STATUS
) {
400 /* if TMRSTS is reset, then compute the new overflow time */
401 acpi_pm_tmr_calc_overflow_time(ar
);
403 ar
->pm1
.evt
.sts
&= ~val
;
406 static void acpi_pm1_evt_write_en(ACPIREGS
*ar
, uint16_t val
)
408 ar
->pm1
.evt
.en
= val
;
409 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_RTC
,
410 val
& ACPI_BITMASK_RT_CLOCK_ENABLE
);
411 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_PMTIMER
,
412 val
& ACPI_BITMASK_TIMER_ENABLE
);
415 void acpi_pm1_evt_power_down(ACPIREGS
*ar
)
417 if (ar
->pm1
.evt
.en
& ACPI_BITMASK_POWER_BUTTON_ENABLE
) {
418 ar
->pm1
.evt
.sts
|= ACPI_BITMASK_POWER_BUTTON_STATUS
;
419 ar
->tmr
.update_sci(ar
);
423 void acpi_pm1_evt_reset(ACPIREGS
*ar
)
427 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_RTC
, 0);
428 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_PMTIMER
, 0);
431 static uint64_t acpi_pm_evt_read(void *opaque
, hwaddr addr
, unsigned width
)
433 ACPIREGS
*ar
= opaque
;
436 return acpi_pm1_evt_get_sts(ar
);
438 return ar
->pm1
.evt
.en
;
444 static void acpi_pm_evt_write(void *opaque
, hwaddr addr
, uint64_t val
,
447 ACPIREGS
*ar
= opaque
;
450 acpi_pm1_evt_write_sts(ar
, val
);
451 ar
->pm1
.evt
.update_sci(ar
);
454 acpi_pm1_evt_write_en(ar
, val
);
455 ar
->pm1
.evt
.update_sci(ar
);
460 static const MemoryRegionOps acpi_pm_evt_ops
= {
461 .read
= acpi_pm_evt_read
,
462 .write
= acpi_pm_evt_write
,
463 .valid
.min_access_size
= 2,
464 .valid
.max_access_size
= 2,
465 .endianness
= DEVICE_LITTLE_ENDIAN
,
468 void acpi_pm1_evt_init(ACPIREGS
*ar
, acpi_update_sci_fn update_sci
,
469 MemoryRegion
*parent
)
471 ar
->pm1
.evt
.update_sci
= update_sci
;
472 memory_region_init_io(&ar
->pm1
.evt
.io
, memory_region_owner(parent
),
473 &acpi_pm_evt_ops
, ar
, "acpi-evt", 4);
474 memory_region_add_subregion(parent
, 0, &ar
->pm1
.evt
.io
);
478 void acpi_pm_tmr_update(ACPIREGS
*ar
, bool enable
)
482 /* schedule a timer interruption if needed */
484 expire_time
= muldiv64(ar
->tmr
.overflow_time
, NANOSECONDS_PER_SECOND
,
486 timer_mod(ar
->tmr
.timer
, expire_time
);
488 timer_del(ar
->tmr
.timer
);
492 static inline int64_t acpi_pm_tmr_get_clock(void)
494 return muldiv64(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
), PM_TIMER_FREQUENCY
,
495 NANOSECONDS_PER_SECOND
);
498 void acpi_pm_tmr_calc_overflow_time(ACPIREGS
*ar
)
500 int64_t d
= acpi_pm_tmr_get_clock();
501 ar
->tmr
.overflow_time
= (d
+ 0x800000LL
) & ~0x7fffffLL
;
504 static uint32_t acpi_pm_tmr_get(ACPIREGS
*ar
)
506 uint32_t d
= acpi_pm_tmr_get_clock();
510 static void acpi_pm_tmr_timer(void *opaque
)
512 ACPIREGS
*ar
= opaque
;
514 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_PMTIMER
, NULL
);
515 ar
->tmr
.update_sci(ar
);
518 static uint64_t acpi_pm_tmr_read(void *opaque
, hwaddr addr
, unsigned width
)
520 return acpi_pm_tmr_get(opaque
);
523 static void acpi_pm_tmr_write(void *opaque
, hwaddr addr
, uint64_t val
,
529 static const MemoryRegionOps acpi_pm_tmr_ops
= {
530 .read
= acpi_pm_tmr_read
,
531 .write
= acpi_pm_tmr_write
,
532 .valid
.min_access_size
= 4,
533 .valid
.max_access_size
= 4,
534 .endianness
= DEVICE_LITTLE_ENDIAN
,
537 void acpi_pm_tmr_init(ACPIREGS
*ar
, acpi_update_sci_fn update_sci
,
538 MemoryRegion
*parent
)
540 ar
->tmr
.update_sci
= update_sci
;
541 ar
->tmr
.timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, acpi_pm_tmr_timer
, ar
);
542 memory_region_init_io(&ar
->tmr
.io
, memory_region_owner(parent
),
543 &acpi_pm_tmr_ops
, ar
, "acpi-tmr", 4);
544 memory_region_add_subregion(parent
, 8, &ar
->tmr
.io
);
547 void acpi_pm_tmr_reset(ACPIREGS
*ar
)
549 ar
->tmr
.overflow_time
= 0;
550 timer_del(ar
->tmr
.timer
);
554 static void acpi_pm1_cnt_write(ACPIREGS
*ar
, uint16_t val
)
556 ar
->pm1
.cnt
.cnt
= val
& ~(ACPI_BITMASK_SLEEP_ENABLE
);
558 if (val
& ACPI_BITMASK_SLEEP_ENABLE
) {
559 /* change suspend type */
560 uint16_t sus_typ
= (val
>> 10) & 7;
562 case 0: /* soft power off */
563 qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN
);
566 qemu_system_suspend_request();
569 if (sus_typ
== ar
->pm1
.cnt
.s4_val
) { /* S4 request */
570 qapi_event_send_suspend_disk();
571 qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN
);
578 void acpi_pm1_cnt_update(ACPIREGS
*ar
,
579 bool sci_enable
, bool sci_disable
)
581 /* ACPI specs 3.0, 4.7.2.5 */
583 ar
->pm1
.cnt
.cnt
|= ACPI_BITMASK_SCI_ENABLE
;
584 } else if (sci_disable
) {
585 ar
->pm1
.cnt
.cnt
&= ~ACPI_BITMASK_SCI_ENABLE
;
589 static uint64_t acpi_pm_cnt_read(void *opaque
, hwaddr addr
, unsigned width
)
591 ACPIREGS
*ar
= opaque
;
592 return ar
->pm1
.cnt
.cnt
;
595 static void acpi_pm_cnt_write(void *opaque
, hwaddr addr
, uint64_t val
,
598 acpi_pm1_cnt_write(opaque
, val
);
601 static const MemoryRegionOps acpi_pm_cnt_ops
= {
602 .read
= acpi_pm_cnt_read
,
603 .write
= acpi_pm_cnt_write
,
604 .valid
.min_access_size
= 2,
605 .valid
.max_access_size
= 2,
606 .endianness
= DEVICE_LITTLE_ENDIAN
,
609 void acpi_pm1_cnt_init(ACPIREGS
*ar
, MemoryRegion
*parent
,
610 bool disable_s3
, bool disable_s4
, uint8_t s4_val
)
614 ar
->pm1
.cnt
.s4_val
= s4_val
;
615 ar
->wakeup
.notify
= acpi_notify_wakeup
;
616 qemu_register_wakeup_notifier(&ar
->wakeup
);
619 * Register wake-up support in QMP query-current-machine API
621 qemu_register_wakeup_support();
623 memory_region_init_io(&ar
->pm1
.cnt
.io
, memory_region_owner(parent
),
624 &acpi_pm_cnt_ops
, ar
, "acpi-cnt", 2);
625 memory_region_add_subregion(parent
, 4, &ar
->pm1
.cnt
.io
);
627 fw_cfg
= fw_cfg_find();
629 uint8_t suspend
[6] = {128, 0, 0, 129, 128, 128};
630 suspend
[3] = 1 | ((!disable_s3
) << 7);
631 suspend
[4] = s4_val
| ((!disable_s4
) << 7);
633 fw_cfg_add_file(fw_cfg
, "etc/system-states", g_memdup(suspend
, 6), 6);
637 void acpi_pm1_cnt_reset(ACPIREGS
*ar
)
643 void acpi_gpe_init(ACPIREGS
*ar
, uint8_t len
)
646 /* Only first len / 2 bytes are ever used,
647 * but the caller in ich9.c migrates full len bytes.
648 * TODO: fix ich9.c and drop the extra allocation.
650 ar
->gpe
.sts
= g_malloc0(len
);
651 ar
->gpe
.en
= g_malloc0(len
);
654 void acpi_gpe_reset(ACPIREGS
*ar
)
656 memset(ar
->gpe
.sts
, 0, ar
->gpe
.len
/ 2);
657 memset(ar
->gpe
.en
, 0, ar
->gpe
.len
/ 2);
660 static uint8_t *acpi_gpe_ioport_get_ptr(ACPIREGS
*ar
, uint32_t addr
)
664 if (addr
< ar
->gpe
.len
/ 2) {
665 cur
= ar
->gpe
.sts
+ addr
;
666 } else if (addr
< ar
->gpe
.len
) {
667 cur
= ar
->gpe
.en
+ addr
- ar
->gpe
.len
/ 2;
675 void acpi_gpe_ioport_writeb(ACPIREGS
*ar
, uint32_t addr
, uint32_t val
)
679 cur
= acpi_gpe_ioport_get_ptr(ar
, addr
);
680 if (addr
< ar
->gpe
.len
/ 2) {
682 *cur
= (*cur
) & ~val
;
683 } else if (addr
< ar
->gpe
.len
) {
691 uint32_t acpi_gpe_ioport_readb(ACPIREGS
*ar
, uint32_t addr
)
696 cur
= acpi_gpe_ioport_get_ptr(ar
, addr
);
705 void acpi_send_gpe_event(ACPIREGS
*ar
, qemu_irq irq
,
706 AcpiEventStatusBits status
)
708 ar
->gpe
.sts
[0] |= status
;
709 acpi_update_sci(ar
, irq
);
712 void acpi_update_sci(ACPIREGS
*regs
, qemu_irq irq
)
714 int sci_level
, pm1a_sts
;
716 pm1a_sts
= acpi_pm1_evt_get_sts(regs
);
718 sci_level
= ((pm1a_sts
&
719 regs
->pm1
.evt
.en
& ACPI_BITMASK_PM1_COMMON_ENABLED
) != 0) ||
720 ((regs
->gpe
.sts
[0] & regs
->gpe
.en
[0]) != 0);
722 qemu_set_irq(irq
, sci_level
);
724 /* schedule a timer interruption if needed */
725 acpi_pm_tmr_update(regs
,
726 (regs
->pm1
.evt
.en
& ACPI_BITMASK_TIMER_ENABLE
) &&
727 !(pm1a_sts
& ACPI_BITMASK_TIMER_STATUS
));