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.
21 #include "qemu/osdep.h"
22 #include "sysemu/sysemu.h"
24 #include "hw/i386/pc.h"
25 #include "hw/acpi/acpi.h"
26 #include "hw/nvram/fw_cfg.h"
27 #include "qemu/config-file.h"
28 #include "qapi/opts-visitor.h"
29 #include "qapi/dealloc-visitor.h"
30 #include "qapi-visit.h"
31 #include "qapi-event.h"
33 struct acpi_table_header
{
34 uint16_t _length
; /* our length, not actual part of the hdr */
35 /* allows easier parsing for fw_cfg clients */
36 char sig
[4]; /* ACPI signature (4 ASCII characters) */
37 uint32_t length
; /* Length of table, in bytes, including header */
38 uint8_t revision
; /* ACPI Specification minor version # */
39 uint8_t checksum
; /* To make sum of entire table == 0 */
40 char oem_id
[6]; /* OEM identification */
41 char oem_table_id
[8]; /* OEM table identification */
42 uint32_t oem_revision
; /* OEM revision number */
43 char asl_compiler_id
[4]; /* ASL compiler vendor ID */
44 uint32_t asl_compiler_revision
; /* ASL compiler revision number */
47 #define ACPI_TABLE_HDR_SIZE sizeof(struct acpi_table_header)
48 #define ACPI_TABLE_PFX_SIZE sizeof(uint16_t) /* size of the extra prefix */
50 static const char unsigned dfl_hdr
[ACPI_TABLE_HDR_SIZE
- ACPI_TABLE_PFX_SIZE
] =
51 "QEMU\0\0\0\0\1\0" /* sig (4), len(4), revno (1), csum (1) */
52 "QEMUQEQEMUQEMU\1\0\0\0" /* OEM id (6), table (8), revno (4) */
53 "QEMU\1\0\0\0" /* ASL compiler ID (4), version (4) */
56 char unsigned *acpi_tables
;
57 size_t acpi_tables_len
;
59 static QemuOptsList qemu_acpi_opts
= {
61 .implied_opt_name
= "data",
62 .head
= QTAILQ_HEAD_INITIALIZER(qemu_acpi_opts
.head
),
63 .desc
= { { 0 } } /* validated with OptsVisitor */
66 static void acpi_register_config(void)
68 qemu_add_opts(&qemu_acpi_opts
);
71 machine_init(acpi_register_config
);
73 static int acpi_checksum(const uint8_t *data
, int len
)
77 for (i
= 0; i
< len
; i
++) {
84 /* Install a copy of the ACPI table specified in @blob.
86 * If @has_header is set, @blob starts with the System Description Table Header
87 * structure. Otherwise, "dfl_hdr" is prepended. In any case, each header field
88 * is optionally overwritten from @hdrs.
90 * It is valid to call this function with
91 * (@blob == NULL && bloblen == 0 && !has_header).
93 * @hdrs->file and @hdrs->data are ignored.
95 * SIZE_MAX is considered "infinity" in this function.
97 * The number of tables that can be installed is not limited, but the 16-bit
98 * counter at the beginning of "acpi_tables" wraps around after UINT16_MAX.
100 static void acpi_table_install(const char unsigned *blob
, size_t bloblen
,
102 const struct AcpiTableOptions
*hdrs
,
106 const char unsigned *hdr_src
;
107 size_t body_size
, acpi_payload_size
;
108 struct acpi_table_header
*ext_hdr
;
109 unsigned changed_fields
;
111 /* Calculate where the ACPI table body starts within the blob, plus where
112 * to copy the ACPI table header from.
115 /* _length | ACPI header in blob | blob body
116 * ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
117 * ACPI_TABLE_PFX_SIZE sizeof dfl_hdr body_size
120 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
121 * acpi_payload_size == bloblen
123 body_start
= sizeof dfl_hdr
;
125 if (bloblen
< body_start
) {
126 error_setg(errp
, "ACPI table claiming to have header is too "
127 "short, available: %zu, expected: %zu", bloblen
,
133 /* _length | ACPI header in template | blob body
134 * ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^
135 * ACPI_TABLE_PFX_SIZE sizeof dfl_hdr body_size
138 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
144 body_size
= bloblen
- body_start
;
145 acpi_payload_size
= sizeof dfl_hdr
+ body_size
;
147 if (acpi_payload_size
> UINT16_MAX
) {
148 error_setg(errp
, "ACPI table too big, requested: %zu, max: %u",
149 acpi_payload_size
, (unsigned)UINT16_MAX
);
153 /* We won't fail from here on. Initialize / extend the globals. */
154 if (acpi_tables
== NULL
) {
155 acpi_tables_len
= sizeof(uint16_t);
156 acpi_tables
= g_malloc0(acpi_tables_len
);
159 acpi_tables
= g_realloc(acpi_tables
, acpi_tables_len
+
160 ACPI_TABLE_PFX_SIZE
+
161 sizeof dfl_hdr
+ body_size
);
163 ext_hdr
= (struct acpi_table_header
*)(acpi_tables
+ acpi_tables_len
);
164 acpi_tables_len
+= ACPI_TABLE_PFX_SIZE
;
166 memcpy(acpi_tables
+ acpi_tables_len
, hdr_src
, sizeof dfl_hdr
);
167 acpi_tables_len
+= sizeof dfl_hdr
;
170 memcpy(acpi_tables
+ acpi_tables_len
, blob
+ body_start
, body_size
);
171 acpi_tables_len
+= body_size
;
174 /* increase number of tables */
175 stw_le_p(acpi_tables
, lduw_le_p(acpi_tables
) + 1u);
177 /* Update the header fields. The strings need not be NUL-terminated. */
179 ext_hdr
->_length
= cpu_to_le16(acpi_payload_size
);
182 strncpy(ext_hdr
->sig
, hdrs
->sig
, sizeof ext_hdr
->sig
);
186 if (has_header
&& le32_to_cpu(ext_hdr
->length
) != acpi_payload_size
) {
188 "warning: ACPI table has wrong length, header says "
189 "%" PRIu32
", actual size %zu bytes\n",
190 le32_to_cpu(ext_hdr
->length
), acpi_payload_size
);
192 ext_hdr
->length
= cpu_to_le32(acpi_payload_size
);
195 ext_hdr
->revision
= hdrs
->rev
;
199 ext_hdr
->checksum
= 0;
201 if (hdrs
->has_oem_id
) {
202 strncpy(ext_hdr
->oem_id
, hdrs
->oem_id
, sizeof ext_hdr
->oem_id
);
205 if (hdrs
->has_oem_table_id
) {
206 strncpy(ext_hdr
->oem_table_id
, hdrs
->oem_table_id
,
207 sizeof ext_hdr
->oem_table_id
);
210 if (hdrs
->has_oem_rev
) {
211 ext_hdr
->oem_revision
= cpu_to_le32(hdrs
->oem_rev
);
214 if (hdrs
->has_asl_compiler_id
) {
215 strncpy(ext_hdr
->asl_compiler_id
, hdrs
->asl_compiler_id
,
216 sizeof ext_hdr
->asl_compiler_id
);
219 if (hdrs
->has_asl_compiler_rev
) {
220 ext_hdr
->asl_compiler_revision
= cpu_to_le32(hdrs
->asl_compiler_rev
);
224 if (!has_header
&& changed_fields
== 0) {
225 fprintf(stderr
, "warning: ACPI table: no headers are specified\n");
228 /* recalculate checksum */
229 ext_hdr
->checksum
= acpi_checksum((const char unsigned *)ext_hdr
+
230 ACPI_TABLE_PFX_SIZE
, acpi_payload_size
);
233 void acpi_table_add(const QemuOpts
*opts
, Error
**errp
)
235 AcpiTableOptions
*hdrs
= NULL
;
237 char **pathnames
= NULL
;
240 char unsigned *blob
= NULL
;
245 ov
= opts_visitor_new(opts
);
246 visit_type_AcpiTableOptions(opts_get_visitor(ov
), NULL
, &hdrs
, &err
);
247 opts_visitor_cleanup(ov
);
253 if (hdrs
->has_file
== hdrs
->has_data
) {
254 error_setg(&err
, "'-acpitable' requires one of 'data' or 'file'");
258 pathnames
= g_strsplit(hdrs
->has_file
? hdrs
->file
: hdrs
->data
, ":", 0);
259 if (pathnames
== NULL
|| pathnames
[0] == NULL
) {
260 error_setg(&err
, "'-acpitable' requires at least one pathname");
264 /* now read in the data files, reallocating buffer as needed */
265 for (cur
= pathnames
; *cur
; ++cur
) {
266 int fd
= open(*cur
, O_RDONLY
| O_BINARY
);
269 error_setg(&err
, "can't open file %s: %s", *cur
, strerror(errno
));
274 char unsigned data
[8192];
277 r
= read(fd
, data
, sizeof data
);
281 blob
= g_realloc(blob
, bloblen
+ r
);
282 memcpy(blob
+ bloblen
, data
, r
);
284 } else if (errno
!= EINTR
) {
285 error_setg(&err
, "can't read file %s: %s",
286 *cur
, strerror(errno
));
295 acpi_table_install(blob
, bloblen
, hdrs
->has_file
, hdrs
, &err
);
299 g_strfreev(pathnames
);
302 QapiDeallocVisitor
*dv
;
304 dv
= qapi_dealloc_visitor_new();
305 visit_type_AcpiTableOptions(qapi_dealloc_get_visitor(dv
), NULL
, &hdrs
,
307 qapi_dealloc_visitor_cleanup(dv
);
310 error_propagate(errp
, err
);
313 static bool acpi_table_builtin
= false;
315 void acpi_table_add_builtin(const QemuOpts
*opts
, Error
**errp
)
317 acpi_table_builtin
= true;
318 acpi_table_add(opts
, errp
);
321 unsigned acpi_table_len(void *current
)
323 struct acpi_table_header
*hdr
= current
- sizeof(hdr
->_length
);
328 void *acpi_table_hdr(void *h
)
330 struct acpi_table_header
*hdr
= h
;
334 uint8_t *acpi_table_first(void)
336 if (acpi_table_builtin
|| !acpi_tables
) {
339 return acpi_table_hdr(acpi_tables
+ ACPI_TABLE_PFX_SIZE
);
342 uint8_t *acpi_table_next(uint8_t *current
)
344 uint8_t *next
= current
+ acpi_table_len(current
);
346 if (next
- acpi_tables
>= acpi_tables_len
) {
349 return acpi_table_hdr(next
);
353 int acpi_get_slic_oem(AcpiSlicOem
*oem
)
357 for (u
= acpi_table_first(); u
; u
= acpi_table_next(u
)) {
358 struct acpi_table_header
*hdr
= (void *)(u
- sizeof(hdr
->_length
));
360 if (memcmp(hdr
->sig
, "SLIC", 4) == 0) {
361 oem
->id
= hdr
->oem_id
;
362 oem
->table_id
= hdr
->oem_table_id
;
369 static void acpi_notify_wakeup(Notifier
*notifier
, void *data
)
371 ACPIREGS
*ar
= container_of(notifier
, ACPIREGS
, wakeup
);
372 WakeupReason
*reason
= data
;
375 case QEMU_WAKEUP_REASON_RTC
:
377 (ACPI_BITMASK_WAKE_STATUS
| ACPI_BITMASK_RT_CLOCK_STATUS
);
379 case QEMU_WAKEUP_REASON_PMTIMER
:
381 (ACPI_BITMASK_WAKE_STATUS
| ACPI_BITMASK_TIMER_STATUS
);
383 case QEMU_WAKEUP_REASON_OTHER
:
384 /* ACPI_BITMASK_WAKE_STATUS should be set on resume.
385 Pretend that resume was caused by power button */
387 (ACPI_BITMASK_WAKE_STATUS
| ACPI_BITMASK_POWER_BUTTON_STATUS
);
395 uint16_t acpi_pm1_evt_get_sts(ACPIREGS
*ar
)
397 /* Compare ns-clock, not PM timer ticks, because
398 acpi_pm_tmr_update function uses ns for setting the timer. */
399 int64_t d
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
400 if (d
>= muldiv64(ar
->tmr
.overflow_time
,
401 get_ticks_per_sec(), PM_TIMER_FREQUENCY
)) {
402 ar
->pm1
.evt
.sts
|= ACPI_BITMASK_TIMER_STATUS
;
404 return ar
->pm1
.evt
.sts
;
407 static void acpi_pm1_evt_write_sts(ACPIREGS
*ar
, uint16_t val
)
409 uint16_t pm1_sts
= acpi_pm1_evt_get_sts(ar
);
410 if (pm1_sts
& val
& ACPI_BITMASK_TIMER_STATUS
) {
411 /* if TMRSTS is reset, then compute the new overflow time */
412 acpi_pm_tmr_calc_overflow_time(ar
);
414 ar
->pm1
.evt
.sts
&= ~val
;
417 static void acpi_pm1_evt_write_en(ACPIREGS
*ar
, uint16_t val
)
419 ar
->pm1
.evt
.en
= val
;
420 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_RTC
,
421 val
& ACPI_BITMASK_RT_CLOCK_ENABLE
);
422 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_PMTIMER
,
423 val
& ACPI_BITMASK_TIMER_ENABLE
);
426 void acpi_pm1_evt_power_down(ACPIREGS
*ar
)
428 if (ar
->pm1
.evt
.en
& ACPI_BITMASK_POWER_BUTTON_ENABLE
) {
429 ar
->pm1
.evt
.sts
|= ACPI_BITMASK_POWER_BUTTON_STATUS
;
430 ar
->tmr
.update_sci(ar
);
434 void acpi_pm1_evt_reset(ACPIREGS
*ar
)
438 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_RTC
, 0);
439 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_PMTIMER
, 0);
442 static uint64_t acpi_pm_evt_read(void *opaque
, hwaddr addr
, unsigned width
)
444 ACPIREGS
*ar
= opaque
;
447 return acpi_pm1_evt_get_sts(ar
);
449 return ar
->pm1
.evt
.en
;
455 static void acpi_pm_evt_write(void *opaque
, hwaddr addr
, uint64_t val
,
458 ACPIREGS
*ar
= opaque
;
461 acpi_pm1_evt_write_sts(ar
, val
);
462 ar
->pm1
.evt
.update_sci(ar
);
465 acpi_pm1_evt_write_en(ar
, val
);
466 ar
->pm1
.evt
.update_sci(ar
);
471 static const MemoryRegionOps acpi_pm_evt_ops
= {
472 .read
= acpi_pm_evt_read
,
473 .write
= acpi_pm_evt_write
,
474 .valid
.min_access_size
= 2,
475 .valid
.max_access_size
= 2,
476 .endianness
= DEVICE_LITTLE_ENDIAN
,
479 void acpi_pm1_evt_init(ACPIREGS
*ar
, acpi_update_sci_fn update_sci
,
480 MemoryRegion
*parent
)
482 ar
->pm1
.evt
.update_sci
= update_sci
;
483 memory_region_init_io(&ar
->pm1
.evt
.io
, memory_region_owner(parent
),
484 &acpi_pm_evt_ops
, ar
, "acpi-evt", 4);
485 memory_region_add_subregion(parent
, 0, &ar
->pm1
.evt
.io
);
489 void acpi_pm_tmr_update(ACPIREGS
*ar
, bool enable
)
493 /* schedule a timer interruption if needed */
495 expire_time
= muldiv64(ar
->tmr
.overflow_time
, get_ticks_per_sec(),
497 timer_mod(ar
->tmr
.timer
, expire_time
);
499 timer_del(ar
->tmr
.timer
);
503 void acpi_pm_tmr_calc_overflow_time(ACPIREGS
*ar
)
505 int64_t d
= acpi_pm_tmr_get_clock();
506 ar
->tmr
.overflow_time
= (d
+ 0x800000LL
) & ~0x7fffffLL
;
509 static uint32_t acpi_pm_tmr_get(ACPIREGS
*ar
)
511 uint32_t d
= acpi_pm_tmr_get_clock();
515 static void acpi_pm_tmr_timer(void *opaque
)
517 ACPIREGS
*ar
= opaque
;
518 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_PMTIMER
);
519 ar
->tmr
.update_sci(ar
);
522 static uint64_t acpi_pm_tmr_read(void *opaque
, hwaddr addr
, unsigned width
)
524 return acpi_pm_tmr_get(opaque
);
527 static void acpi_pm_tmr_write(void *opaque
, hwaddr addr
, uint64_t val
,
533 static const MemoryRegionOps acpi_pm_tmr_ops
= {
534 .read
= acpi_pm_tmr_read
,
535 .write
= acpi_pm_tmr_write
,
536 .valid
.min_access_size
= 4,
537 .valid
.max_access_size
= 4,
538 .endianness
= DEVICE_LITTLE_ENDIAN
,
541 void acpi_pm_tmr_init(ACPIREGS
*ar
, acpi_update_sci_fn update_sci
,
542 MemoryRegion
*parent
)
544 ar
->tmr
.update_sci
= update_sci
;
545 ar
->tmr
.timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, acpi_pm_tmr_timer
, ar
);
546 memory_region_init_io(&ar
->tmr
.io
, memory_region_owner(parent
),
547 &acpi_pm_tmr_ops
, ar
, "acpi-tmr", 4);
548 memory_region_clear_global_locking(&ar
->tmr
.io
);
549 memory_region_add_subregion(parent
, 8, &ar
->tmr
.io
);
552 void acpi_pm_tmr_reset(ACPIREGS
*ar
)
554 ar
->tmr
.overflow_time
= 0;
555 timer_del(ar
->tmr
.timer
);
559 static void acpi_pm1_cnt_write(ACPIREGS
*ar
, uint16_t val
)
561 ar
->pm1
.cnt
.cnt
= val
& ~(ACPI_BITMASK_SLEEP_ENABLE
);
563 if (val
& ACPI_BITMASK_SLEEP_ENABLE
) {
564 /* change suspend type */
565 uint16_t sus_typ
= (val
>> 10) & 7;
567 case 0: /* soft power off */
568 qemu_system_shutdown_request();
571 qemu_system_suspend_request();
574 if (sus_typ
== ar
->pm1
.cnt
.s4_val
) { /* S4 request */
575 qapi_event_send_suspend_disk(&error_abort
);
576 qemu_system_shutdown_request();
583 void acpi_pm1_cnt_update(ACPIREGS
*ar
,
584 bool sci_enable
, bool sci_disable
)
586 /* ACPI specs 3.0, 4.7.2.5 */
588 ar
->pm1
.cnt
.cnt
|= ACPI_BITMASK_SCI_ENABLE
;
589 } else if (sci_disable
) {
590 ar
->pm1
.cnt
.cnt
&= ~ACPI_BITMASK_SCI_ENABLE
;
594 static uint64_t acpi_pm_cnt_read(void *opaque
, hwaddr addr
, unsigned width
)
596 ACPIREGS
*ar
= opaque
;
597 return ar
->pm1
.cnt
.cnt
;
600 static void acpi_pm_cnt_write(void *opaque
, hwaddr addr
, uint64_t val
,
603 acpi_pm1_cnt_write(opaque
, val
);
606 static const MemoryRegionOps acpi_pm_cnt_ops
= {
607 .read
= acpi_pm_cnt_read
,
608 .write
= acpi_pm_cnt_write
,
609 .valid
.min_access_size
= 2,
610 .valid
.max_access_size
= 2,
611 .endianness
= DEVICE_LITTLE_ENDIAN
,
614 void acpi_pm1_cnt_init(ACPIREGS
*ar
, MemoryRegion
*parent
,
615 bool disable_s3
, bool disable_s4
, uint8_t s4_val
)
619 ar
->pm1
.cnt
.s4_val
= s4_val
;
620 ar
->wakeup
.notify
= acpi_notify_wakeup
;
621 qemu_register_wakeup_notifier(&ar
->wakeup
);
622 memory_region_init_io(&ar
->pm1
.cnt
.io
, memory_region_owner(parent
),
623 &acpi_pm_cnt_ops
, ar
, "acpi-cnt", 2);
624 memory_region_add_subregion(parent
, 4, &ar
->pm1
.cnt
.io
);
626 fw_cfg
= fw_cfg_find();
628 uint8_t suspend
[6] = {128, 0, 0, 129, 128, 128};
629 suspend
[3] = 1 | ((!disable_s3
) << 7);
630 suspend
[4] = s4_val
| ((!disable_s4
) << 7);
632 fw_cfg_add_file(fw_cfg
, "etc/system-states", g_memdup(suspend
, 6), 6);
636 void acpi_pm1_cnt_reset(ACPIREGS
*ar
)
642 void acpi_gpe_init(ACPIREGS
*ar
, uint8_t len
)
645 /* Only first len / 2 bytes are ever used,
646 * but the caller in ich9.c migrates full len bytes.
647 * TODO: fix ich9.c and drop the extra allocation.
649 ar
->gpe
.sts
= g_malloc0(len
);
650 ar
->gpe
.en
= g_malloc0(len
);
653 void acpi_gpe_reset(ACPIREGS
*ar
)
655 memset(ar
->gpe
.sts
, 0, ar
->gpe
.len
/ 2);
656 memset(ar
->gpe
.en
, 0, ar
->gpe
.len
/ 2);
659 static uint8_t *acpi_gpe_ioport_get_ptr(ACPIREGS
*ar
, uint32_t addr
)
663 if (addr
< ar
->gpe
.len
/ 2) {
664 cur
= ar
->gpe
.sts
+ addr
;
665 } else if (addr
< ar
->gpe
.len
) {
666 cur
= ar
->gpe
.en
+ addr
- ar
->gpe
.len
/ 2;
674 void acpi_gpe_ioport_writeb(ACPIREGS
*ar
, uint32_t addr
, uint32_t val
)
678 cur
= acpi_gpe_ioport_get_ptr(ar
, addr
);
679 if (addr
< ar
->gpe
.len
/ 2) {
681 *cur
= (*cur
) & ~val
;
682 } else if (addr
< ar
->gpe
.len
) {
690 uint32_t acpi_gpe_ioport_readb(ACPIREGS
*ar
, uint32_t addr
)
695 cur
= acpi_gpe_ioport_get_ptr(ar
, addr
);
704 void acpi_send_gpe_event(ACPIREGS
*ar
, qemu_irq irq
,
705 AcpiGPEStatusBits status
)
707 ar
->gpe
.sts
[0] |= status
;
708 acpi_update_sci(ar
, irq
);
711 void acpi_update_sci(ACPIREGS
*regs
, qemu_irq irq
)
713 int sci_level
, pm1a_sts
;
715 pm1a_sts
= acpi_pm1_evt_get_sts(regs
);
717 sci_level
= ((pm1a_sts
&
718 regs
->pm1
.evt
.en
& ACPI_BITMASK_PM1_COMMON_ENABLED
) != 0) ||
719 ((regs
->gpe
.sts
[0] & regs
->gpe
.en
[0]) != 0);
721 qemu_set_irq(irq
, sci_level
);
723 /* schedule a timer interruption if needed */
724 acpi_pm_tmr_update(regs
,
725 (regs
->pm1
.evt
.en
& ACPI_BITMASK_TIMER_ENABLE
) &&
726 !(pm1a_sts
& ACPI_BITMASK_TIMER_STATUS
));