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
), &hdrs
, NULL
, &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
), &hdrs
, NULL
,
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 static void acpi_notify_wakeup(Notifier
*notifier
, void *data
)
355 ACPIREGS
*ar
= container_of(notifier
, ACPIREGS
, wakeup
);
356 WakeupReason
*reason
= data
;
359 case QEMU_WAKEUP_REASON_RTC
:
361 (ACPI_BITMASK_WAKE_STATUS
| ACPI_BITMASK_RT_CLOCK_STATUS
);
363 case QEMU_WAKEUP_REASON_PMTIMER
:
365 (ACPI_BITMASK_WAKE_STATUS
| ACPI_BITMASK_TIMER_STATUS
);
367 case QEMU_WAKEUP_REASON_OTHER
:
368 /* ACPI_BITMASK_WAKE_STATUS should be set on resume.
369 Pretend that resume was caused by power button */
371 (ACPI_BITMASK_WAKE_STATUS
| ACPI_BITMASK_POWER_BUTTON_STATUS
);
379 uint16_t acpi_pm1_evt_get_sts(ACPIREGS
*ar
)
381 /* Compare ns-clock, not PM timer ticks, because
382 acpi_pm_tmr_update function uses ns for setting the timer. */
383 int64_t d
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
384 if (d
>= muldiv64(ar
->tmr
.overflow_time
,
385 get_ticks_per_sec(), PM_TIMER_FREQUENCY
)) {
386 ar
->pm1
.evt
.sts
|= ACPI_BITMASK_TIMER_STATUS
;
388 return ar
->pm1
.evt
.sts
;
391 static void acpi_pm1_evt_write_sts(ACPIREGS
*ar
, uint16_t val
)
393 uint16_t pm1_sts
= acpi_pm1_evt_get_sts(ar
);
394 if (pm1_sts
& val
& ACPI_BITMASK_TIMER_STATUS
) {
395 /* if TMRSTS is reset, then compute the new overflow time */
396 acpi_pm_tmr_calc_overflow_time(ar
);
398 ar
->pm1
.evt
.sts
&= ~val
;
401 static void acpi_pm1_evt_write_en(ACPIREGS
*ar
, uint16_t val
)
403 ar
->pm1
.evt
.en
= val
;
404 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_RTC
,
405 val
& ACPI_BITMASK_RT_CLOCK_ENABLE
);
406 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_PMTIMER
,
407 val
& ACPI_BITMASK_TIMER_ENABLE
);
410 void acpi_pm1_evt_power_down(ACPIREGS
*ar
)
412 if (ar
->pm1
.evt
.en
& ACPI_BITMASK_POWER_BUTTON_ENABLE
) {
413 ar
->pm1
.evt
.sts
|= ACPI_BITMASK_POWER_BUTTON_STATUS
;
414 ar
->tmr
.update_sci(ar
);
418 void acpi_pm1_evt_reset(ACPIREGS
*ar
)
422 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_RTC
, 0);
423 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_PMTIMER
, 0);
426 static uint64_t acpi_pm_evt_read(void *opaque
, hwaddr addr
, unsigned width
)
428 ACPIREGS
*ar
= opaque
;
431 return acpi_pm1_evt_get_sts(ar
);
433 return ar
->pm1
.evt
.en
;
439 static void acpi_pm_evt_write(void *opaque
, hwaddr addr
, uint64_t val
,
442 ACPIREGS
*ar
= opaque
;
445 acpi_pm1_evt_write_sts(ar
, val
);
446 ar
->pm1
.evt
.update_sci(ar
);
449 acpi_pm1_evt_write_en(ar
, val
);
450 ar
->pm1
.evt
.update_sci(ar
);
455 static const MemoryRegionOps acpi_pm_evt_ops
= {
456 .read
= acpi_pm_evt_read
,
457 .write
= acpi_pm_evt_write
,
458 .valid
.min_access_size
= 2,
459 .valid
.max_access_size
= 2,
460 .endianness
= DEVICE_LITTLE_ENDIAN
,
463 void acpi_pm1_evt_init(ACPIREGS
*ar
, acpi_update_sci_fn update_sci
,
464 MemoryRegion
*parent
)
466 ar
->pm1
.evt
.update_sci
= update_sci
;
467 memory_region_init_io(&ar
->pm1
.evt
.io
, memory_region_owner(parent
),
468 &acpi_pm_evt_ops
, ar
, "acpi-evt", 4);
469 memory_region_add_subregion(parent
, 0, &ar
->pm1
.evt
.io
);
473 void acpi_pm_tmr_update(ACPIREGS
*ar
, bool enable
)
477 /* schedule a timer interruption if needed */
479 expire_time
= muldiv64(ar
->tmr
.overflow_time
, get_ticks_per_sec(),
481 timer_mod(ar
->tmr
.timer
, expire_time
);
483 timer_del(ar
->tmr
.timer
);
487 void acpi_pm_tmr_calc_overflow_time(ACPIREGS
*ar
)
489 int64_t d
= acpi_pm_tmr_get_clock();
490 ar
->tmr
.overflow_time
= (d
+ 0x800000LL
) & ~0x7fffffLL
;
493 static uint32_t acpi_pm_tmr_get(ACPIREGS
*ar
)
495 uint32_t d
= acpi_pm_tmr_get_clock();
499 static void acpi_pm_tmr_timer(void *opaque
)
501 ACPIREGS
*ar
= opaque
;
502 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_PMTIMER
);
503 ar
->tmr
.update_sci(ar
);
506 static uint64_t acpi_pm_tmr_read(void *opaque
, hwaddr addr
, unsigned width
)
508 return acpi_pm_tmr_get(opaque
);
511 static void acpi_pm_tmr_write(void *opaque
, hwaddr addr
, uint64_t val
,
517 static const MemoryRegionOps acpi_pm_tmr_ops
= {
518 .read
= acpi_pm_tmr_read
,
519 .write
= acpi_pm_tmr_write
,
520 .valid
.min_access_size
= 4,
521 .valid
.max_access_size
= 4,
522 .endianness
= DEVICE_LITTLE_ENDIAN
,
525 void acpi_pm_tmr_init(ACPIREGS
*ar
, acpi_update_sci_fn update_sci
,
526 MemoryRegion
*parent
)
528 ar
->tmr
.update_sci
= update_sci
;
529 ar
->tmr
.timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, acpi_pm_tmr_timer
, ar
);
530 memory_region_init_io(&ar
->tmr
.io
, memory_region_owner(parent
),
531 &acpi_pm_tmr_ops
, ar
, "acpi-tmr", 4);
532 memory_region_clear_global_locking(&ar
->tmr
.io
);
533 memory_region_add_subregion(parent
, 8, &ar
->tmr
.io
);
536 void acpi_pm_tmr_reset(ACPIREGS
*ar
)
538 ar
->tmr
.overflow_time
= 0;
539 timer_del(ar
->tmr
.timer
);
543 static void acpi_pm1_cnt_write(ACPIREGS
*ar
, uint16_t val
)
545 ar
->pm1
.cnt
.cnt
= val
& ~(ACPI_BITMASK_SLEEP_ENABLE
);
547 if (val
& ACPI_BITMASK_SLEEP_ENABLE
) {
548 /* change suspend type */
549 uint16_t sus_typ
= (val
>> 10) & 7;
551 case 0: /* soft power off */
552 qemu_system_shutdown_request();
555 qemu_system_suspend_request();
558 if (sus_typ
== ar
->pm1
.cnt
.s4_val
) { /* S4 request */
559 qapi_event_send_suspend_disk(&error_abort
);
560 qemu_system_shutdown_request();
567 void acpi_pm1_cnt_update(ACPIREGS
*ar
,
568 bool sci_enable
, bool sci_disable
)
570 /* ACPI specs 3.0, 4.7.2.5 */
572 ar
->pm1
.cnt
.cnt
|= ACPI_BITMASK_SCI_ENABLE
;
573 } else if (sci_disable
) {
574 ar
->pm1
.cnt
.cnt
&= ~ACPI_BITMASK_SCI_ENABLE
;
578 static uint64_t acpi_pm_cnt_read(void *opaque
, hwaddr addr
, unsigned width
)
580 ACPIREGS
*ar
= opaque
;
581 return ar
->pm1
.cnt
.cnt
;
584 static void acpi_pm_cnt_write(void *opaque
, hwaddr addr
, uint64_t val
,
587 acpi_pm1_cnt_write(opaque
, val
);
590 static const MemoryRegionOps acpi_pm_cnt_ops
= {
591 .read
= acpi_pm_cnt_read
,
592 .write
= acpi_pm_cnt_write
,
593 .valid
.min_access_size
= 2,
594 .valid
.max_access_size
= 2,
595 .endianness
= DEVICE_LITTLE_ENDIAN
,
598 void acpi_pm1_cnt_init(ACPIREGS
*ar
, MemoryRegion
*parent
,
599 bool disable_s3
, bool disable_s4
, uint8_t s4_val
)
603 ar
->pm1
.cnt
.s4_val
= s4_val
;
604 ar
->wakeup
.notify
= acpi_notify_wakeup
;
605 qemu_register_wakeup_notifier(&ar
->wakeup
);
606 memory_region_init_io(&ar
->pm1
.cnt
.io
, memory_region_owner(parent
),
607 &acpi_pm_cnt_ops
, ar
, "acpi-cnt", 2);
608 memory_region_add_subregion(parent
, 4, &ar
->pm1
.cnt
.io
);
610 fw_cfg
= fw_cfg_find();
612 uint8_t suspend
[6] = {128, 0, 0, 129, 128, 128};
613 suspend
[3] = 1 | ((!disable_s3
) << 7);
614 suspend
[4] = s4_val
| ((!disable_s4
) << 7);
616 fw_cfg_add_file(fw_cfg
, "etc/system-states", g_memdup(suspend
, 6), 6);
620 void acpi_pm1_cnt_reset(ACPIREGS
*ar
)
626 void acpi_gpe_init(ACPIREGS
*ar
, uint8_t len
)
629 /* Only first len / 2 bytes are ever used,
630 * but the caller in ich9.c migrates full len bytes.
631 * TODO: fix ich9.c and drop the extra allocation.
633 ar
->gpe
.sts
= g_malloc0(len
);
634 ar
->gpe
.en
= g_malloc0(len
);
637 void acpi_gpe_reset(ACPIREGS
*ar
)
639 memset(ar
->gpe
.sts
, 0, ar
->gpe
.len
/ 2);
640 memset(ar
->gpe
.en
, 0, ar
->gpe
.len
/ 2);
643 static uint8_t *acpi_gpe_ioport_get_ptr(ACPIREGS
*ar
, uint32_t addr
)
647 if (addr
< ar
->gpe
.len
/ 2) {
648 cur
= ar
->gpe
.sts
+ addr
;
649 } else if (addr
< ar
->gpe
.len
) {
650 cur
= ar
->gpe
.en
+ addr
- ar
->gpe
.len
/ 2;
658 void acpi_gpe_ioport_writeb(ACPIREGS
*ar
, uint32_t addr
, uint32_t val
)
662 cur
= acpi_gpe_ioport_get_ptr(ar
, addr
);
663 if (addr
< ar
->gpe
.len
/ 2) {
665 *cur
= (*cur
) & ~val
;
666 } else if (addr
< ar
->gpe
.len
) {
674 uint32_t acpi_gpe_ioport_readb(ACPIREGS
*ar
, uint32_t addr
)
679 cur
= acpi_gpe_ioport_get_ptr(ar
, addr
);
688 void acpi_send_gpe_event(ACPIREGS
*ar
, qemu_irq irq
,
689 AcpiGPEStatusBits status
)
691 ar
->gpe
.sts
[0] |= status
;
692 acpi_update_sci(ar
, irq
);
695 void acpi_update_sci(ACPIREGS
*regs
, qemu_irq irq
)
697 int sci_level
, pm1a_sts
;
699 pm1a_sts
= acpi_pm1_evt_get_sts(regs
);
701 sci_level
= ((pm1a_sts
&
702 regs
->pm1
.evt
.en
& ACPI_BITMASK_PM1_COMMON_ENABLED
) != 0) ||
703 ((regs
->gpe
.sts
[0] & regs
->gpe
.en
[0]) != 0);
705 qemu_set_irq(irq
, sci_level
);
707 /* schedule a timer interruption if needed */
708 acpi_pm_tmr_update(regs
,
709 (regs
->pm1
.evt
.en
& ACPI_BITMASK_TIMER_ENABLE
) &&
710 !(pm1a_sts
& ACPI_BITMASK_TIMER_STATUS
));