qapi event: convert SUSPEND_DISK
[qemu.git] / hw / acpi / core.c
1 /*
2 * ACPI implementation
3 *
4 * Copyright (c) 2006 Fabrice Bellard
5 *
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.
9 *
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.
14 *
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/>
17 *
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.
20 */
21 #include "sysemu/sysemu.h"
22 #include "hw/hw.h"
23 #include "hw/i386/pc.h"
24 #include "hw/acpi/acpi.h"
25 #include "qemu/config-file.h"
26 #include "qapi/opts-visitor.h"
27 #include "qapi/dealloc-visitor.h"
28 #include "qapi-visit.h"
29 #include "qapi-event.h"
30
31 struct acpi_table_header {
32 uint16_t _length; /* our length, not actual part of the hdr */
33 /* allows easier parsing for fw_cfg clients */
34 char sig[4]; /* ACPI signature (4 ASCII characters) */
35 uint32_t length; /* Length of table, in bytes, including header */
36 uint8_t revision; /* ACPI Specification minor version # */
37 uint8_t checksum; /* To make sum of entire table == 0 */
38 char oem_id[6]; /* OEM identification */
39 char oem_table_id[8]; /* OEM table identification */
40 uint32_t oem_revision; /* OEM revision number */
41 char asl_compiler_id[4]; /* ASL compiler vendor ID */
42 uint32_t asl_compiler_revision; /* ASL compiler revision number */
43 } QEMU_PACKED;
44
45 #define ACPI_TABLE_HDR_SIZE sizeof(struct acpi_table_header)
46 #define ACPI_TABLE_PFX_SIZE sizeof(uint16_t) /* size of the extra prefix */
47
48 static const char unsigned dfl_hdr[ACPI_TABLE_HDR_SIZE - ACPI_TABLE_PFX_SIZE] =
49 "QEMU\0\0\0\0\1\0" /* sig (4), len(4), revno (1), csum (1) */
50 "QEMUQEQEMUQEMU\1\0\0\0" /* OEM id (6), table (8), revno (4) */
51 "QEMU\1\0\0\0" /* ASL compiler ID (4), version (4) */
52 ;
53
54 char unsigned *acpi_tables;
55 size_t acpi_tables_len;
56
57 static QemuOptsList qemu_acpi_opts = {
58 .name = "acpi",
59 .implied_opt_name = "data",
60 .head = QTAILQ_HEAD_INITIALIZER(qemu_acpi_opts.head),
61 .desc = { { 0 } } /* validated with OptsVisitor */
62 };
63
64 static void acpi_register_config(void)
65 {
66 qemu_add_opts(&qemu_acpi_opts);
67 }
68
69 machine_init(acpi_register_config);
70
71 static int acpi_checksum(const uint8_t *data, int len)
72 {
73 int sum, i;
74 sum = 0;
75 for (i = 0; i < len; i++) {
76 sum += data[i];
77 }
78 return (-sum) & 0xff;
79 }
80
81
82 /* Install a copy of the ACPI table specified in @blob.
83 *
84 * If @has_header is set, @blob starts with the System Description Table Header
85 * structure. Otherwise, "dfl_hdr" is prepended. In any case, each header field
86 * is optionally overwritten from @hdrs.
87 *
88 * It is valid to call this function with
89 * (@blob == NULL && bloblen == 0 && !has_header).
90 *
91 * @hdrs->file and @hdrs->data are ignored.
92 *
93 * SIZE_MAX is considered "infinity" in this function.
94 *
95 * The number of tables that can be installed is not limited, but the 16-bit
96 * counter at the beginning of "acpi_tables" wraps around after UINT16_MAX.
97 */
98 static void acpi_table_install(const char unsigned *blob, size_t bloblen,
99 bool has_header,
100 const struct AcpiTableOptions *hdrs,
101 Error **errp)
102 {
103 size_t body_start;
104 const char unsigned *hdr_src;
105 size_t body_size, acpi_payload_size;
106 struct acpi_table_header *ext_hdr;
107 unsigned changed_fields;
108
109 /* Calculate where the ACPI table body starts within the blob, plus where
110 * to copy the ACPI table header from.
111 */
112 if (has_header) {
113 /* _length | ACPI header in blob | blob body
114 * ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
115 * ACPI_TABLE_PFX_SIZE sizeof dfl_hdr body_size
116 * == body_start
117 *
118 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
119 * acpi_payload_size == bloblen
120 */
121 body_start = sizeof dfl_hdr;
122
123 if (bloblen < body_start) {
124 error_setg(errp, "ACPI table claiming to have header is too "
125 "short, available: %zu, expected: %zu", bloblen,
126 body_start);
127 return;
128 }
129 hdr_src = blob;
130 } else {
131 /* _length | ACPI header in template | blob body
132 * ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^
133 * ACPI_TABLE_PFX_SIZE sizeof dfl_hdr body_size
134 * == bloblen
135 *
136 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
137 * acpi_payload_size
138 */
139 body_start = 0;
140 hdr_src = dfl_hdr;
141 }
142 body_size = bloblen - body_start;
143 acpi_payload_size = sizeof dfl_hdr + body_size;
144
145 if (acpi_payload_size > UINT16_MAX) {
146 error_setg(errp, "ACPI table too big, requested: %zu, max: %u",
147 acpi_payload_size, (unsigned)UINT16_MAX);
148 return;
149 }
150
151 /* We won't fail from here on. Initialize / extend the globals. */
152 if (acpi_tables == NULL) {
153 acpi_tables_len = sizeof(uint16_t);
154 acpi_tables = g_malloc0(acpi_tables_len);
155 }
156
157 acpi_tables = g_realloc(acpi_tables, acpi_tables_len +
158 ACPI_TABLE_PFX_SIZE +
159 sizeof dfl_hdr + body_size);
160
161 ext_hdr = (struct acpi_table_header *)(acpi_tables + acpi_tables_len);
162 acpi_tables_len += ACPI_TABLE_PFX_SIZE;
163
164 memcpy(acpi_tables + acpi_tables_len, hdr_src, sizeof dfl_hdr);
165 acpi_tables_len += sizeof dfl_hdr;
166
167 if (blob != NULL) {
168 memcpy(acpi_tables + acpi_tables_len, blob + body_start, body_size);
169 acpi_tables_len += body_size;
170 }
171
172 /* increase number of tables */
173 stw_le_p(acpi_tables, lduw_le_p(acpi_tables) + 1u);
174
175 /* Update the header fields. The strings need not be NUL-terminated. */
176 changed_fields = 0;
177 ext_hdr->_length = cpu_to_le16(acpi_payload_size);
178
179 if (hdrs->has_sig) {
180 strncpy(ext_hdr->sig, hdrs->sig, sizeof ext_hdr->sig);
181 ++changed_fields;
182 }
183
184 if (has_header && le32_to_cpu(ext_hdr->length) != acpi_payload_size) {
185 fprintf(stderr,
186 "warning: ACPI table has wrong length, header says "
187 "%" PRIu32 ", actual size %zu bytes\n",
188 le32_to_cpu(ext_hdr->length), acpi_payload_size);
189 }
190 ext_hdr->length = cpu_to_le32(acpi_payload_size);
191
192 if (hdrs->has_rev) {
193 ext_hdr->revision = hdrs->rev;
194 ++changed_fields;
195 }
196
197 ext_hdr->checksum = 0;
198
199 if (hdrs->has_oem_id) {
200 strncpy(ext_hdr->oem_id, hdrs->oem_id, sizeof ext_hdr->oem_id);
201 ++changed_fields;
202 }
203 if (hdrs->has_oem_table_id) {
204 strncpy(ext_hdr->oem_table_id, hdrs->oem_table_id,
205 sizeof ext_hdr->oem_table_id);
206 ++changed_fields;
207 }
208 if (hdrs->has_oem_rev) {
209 ext_hdr->oem_revision = cpu_to_le32(hdrs->oem_rev);
210 ++changed_fields;
211 }
212 if (hdrs->has_asl_compiler_id) {
213 strncpy(ext_hdr->asl_compiler_id, hdrs->asl_compiler_id,
214 sizeof ext_hdr->asl_compiler_id);
215 ++changed_fields;
216 }
217 if (hdrs->has_asl_compiler_rev) {
218 ext_hdr->asl_compiler_revision = cpu_to_le32(hdrs->asl_compiler_rev);
219 ++changed_fields;
220 }
221
222 if (!has_header && changed_fields == 0) {
223 fprintf(stderr, "warning: ACPI table: no headers are specified\n");
224 }
225
226 /* recalculate checksum */
227 ext_hdr->checksum = acpi_checksum((const char unsigned *)ext_hdr +
228 ACPI_TABLE_PFX_SIZE, acpi_payload_size);
229 }
230
231 void acpi_table_add(const QemuOpts *opts, Error **errp)
232 {
233 AcpiTableOptions *hdrs = NULL;
234 Error *err = NULL;
235 char **pathnames = NULL;
236 char **cur;
237 size_t bloblen = 0;
238 char unsigned *blob = NULL;
239
240 {
241 OptsVisitor *ov;
242
243 ov = opts_visitor_new(opts);
244 visit_type_AcpiTableOptions(opts_get_visitor(ov), &hdrs, NULL, &err);
245 opts_visitor_cleanup(ov);
246 }
247
248 if (err) {
249 goto out;
250 }
251 if (hdrs->has_file == hdrs->has_data) {
252 error_setg(&err, "'-acpitable' requires one of 'data' or 'file'");
253 goto out;
254 }
255
256 pathnames = g_strsplit(hdrs->has_file ? hdrs->file : hdrs->data, ":", 0);
257 if (pathnames == NULL || pathnames[0] == NULL) {
258 error_setg(&err, "'-acpitable' requires at least one pathname");
259 goto out;
260 }
261
262 /* now read in the data files, reallocating buffer as needed */
263 for (cur = pathnames; *cur; ++cur) {
264 int fd = open(*cur, O_RDONLY | O_BINARY);
265
266 if (fd < 0) {
267 error_setg(&err, "can't open file %s: %s", *cur, strerror(errno));
268 goto out;
269 }
270
271 for (;;) {
272 char unsigned data[8192];
273 ssize_t r;
274
275 r = read(fd, data, sizeof data);
276 if (r == 0) {
277 break;
278 } else if (r > 0) {
279 blob = g_realloc(blob, bloblen + r);
280 memcpy(blob + bloblen, data, r);
281 bloblen += r;
282 } else if (errno != EINTR) {
283 error_setg(&err, "can't read file %s: %s",
284 *cur, strerror(errno));
285 close(fd);
286 goto out;
287 }
288 }
289
290 close(fd);
291 }
292
293 acpi_table_install(blob, bloblen, hdrs->has_file, hdrs, &err);
294
295 out:
296 g_free(blob);
297 g_strfreev(pathnames);
298
299 if (hdrs != NULL) {
300 QapiDeallocVisitor *dv;
301
302 dv = qapi_dealloc_visitor_new();
303 visit_type_AcpiTableOptions(qapi_dealloc_get_visitor(dv), &hdrs, NULL,
304 NULL);
305 qapi_dealloc_visitor_cleanup(dv);
306 }
307
308 error_propagate(errp, err);
309 }
310
311 static bool acpi_table_builtin = false;
312
313 void acpi_table_add_builtin(const QemuOpts *opts, Error **errp)
314 {
315 acpi_table_builtin = true;
316 acpi_table_add(opts, errp);
317 }
318
319 unsigned acpi_table_len(void *current)
320 {
321 struct acpi_table_header *hdr = current - sizeof(hdr->_length);
322 return hdr->_length;
323 }
324
325 static
326 void *acpi_table_hdr(void *h)
327 {
328 struct acpi_table_header *hdr = h;
329 return &hdr->sig;
330 }
331
332 uint8_t *acpi_table_first(void)
333 {
334 if (acpi_table_builtin || !acpi_tables) {
335 return NULL;
336 }
337 return acpi_table_hdr(acpi_tables + ACPI_TABLE_PFX_SIZE);
338 }
339
340 uint8_t *acpi_table_next(uint8_t *current)
341 {
342 uint8_t *next = current + acpi_table_len(current);
343
344 if (next - acpi_tables >= acpi_tables_len) {
345 return NULL;
346 } else {
347 return acpi_table_hdr(next);
348 }
349 }
350
351 static void acpi_notify_wakeup(Notifier *notifier, void *data)
352 {
353 ACPIREGS *ar = container_of(notifier, ACPIREGS, wakeup);
354 WakeupReason *reason = data;
355
356 switch (*reason) {
357 case QEMU_WAKEUP_REASON_RTC:
358 ar->pm1.evt.sts |=
359 (ACPI_BITMASK_WAKE_STATUS | ACPI_BITMASK_RT_CLOCK_STATUS);
360 break;
361 case QEMU_WAKEUP_REASON_PMTIMER:
362 ar->pm1.evt.sts |=
363 (ACPI_BITMASK_WAKE_STATUS | ACPI_BITMASK_TIMER_STATUS);
364 break;
365 case QEMU_WAKEUP_REASON_OTHER:
366 /* ACPI_BITMASK_WAKE_STATUS should be set on resume.
367 Pretend that resume was caused by power button */
368 ar->pm1.evt.sts |=
369 (ACPI_BITMASK_WAKE_STATUS | ACPI_BITMASK_POWER_BUTTON_STATUS);
370 break;
371 default:
372 break;
373 }
374 }
375
376 /* ACPI PM1a EVT */
377 uint16_t acpi_pm1_evt_get_sts(ACPIREGS *ar)
378 {
379 int64_t d = acpi_pm_tmr_get_clock();
380 if (d >= ar->tmr.overflow_time) {
381 ar->pm1.evt.sts |= ACPI_BITMASK_TIMER_STATUS;
382 }
383 return ar->pm1.evt.sts;
384 }
385
386 static void acpi_pm1_evt_write_sts(ACPIREGS *ar, uint16_t val)
387 {
388 uint16_t pm1_sts = acpi_pm1_evt_get_sts(ar);
389 if (pm1_sts & val & ACPI_BITMASK_TIMER_STATUS) {
390 /* if TMRSTS is reset, then compute the new overflow time */
391 acpi_pm_tmr_calc_overflow_time(ar);
392 }
393 ar->pm1.evt.sts &= ~val;
394 }
395
396 static void acpi_pm1_evt_write_en(ACPIREGS *ar, uint16_t val)
397 {
398 ar->pm1.evt.en = val;
399 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_RTC,
400 val & ACPI_BITMASK_RT_CLOCK_ENABLE);
401 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_PMTIMER,
402 val & ACPI_BITMASK_TIMER_ENABLE);
403 }
404
405 void acpi_pm1_evt_power_down(ACPIREGS *ar)
406 {
407 if (ar->pm1.evt.en & ACPI_BITMASK_POWER_BUTTON_ENABLE) {
408 ar->pm1.evt.sts |= ACPI_BITMASK_POWER_BUTTON_STATUS;
409 ar->tmr.update_sci(ar);
410 }
411 }
412
413 void acpi_pm1_evt_reset(ACPIREGS *ar)
414 {
415 ar->pm1.evt.sts = 0;
416 ar->pm1.evt.en = 0;
417 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_RTC, 0);
418 qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_PMTIMER, 0);
419 }
420
421 static uint64_t acpi_pm_evt_read(void *opaque, hwaddr addr, unsigned width)
422 {
423 ACPIREGS *ar = opaque;
424 switch (addr) {
425 case 0:
426 return acpi_pm1_evt_get_sts(ar);
427 case 2:
428 return ar->pm1.evt.en;
429 default:
430 return 0;
431 }
432 }
433
434 static void acpi_pm_evt_write(void *opaque, hwaddr addr, uint64_t val,
435 unsigned width)
436 {
437 ACPIREGS *ar = opaque;
438 switch (addr) {
439 case 0:
440 acpi_pm1_evt_write_sts(ar, val);
441 ar->pm1.evt.update_sci(ar);
442 break;
443 case 2:
444 acpi_pm1_evt_write_en(ar, val);
445 ar->pm1.evt.update_sci(ar);
446 break;
447 }
448 }
449
450 static const MemoryRegionOps acpi_pm_evt_ops = {
451 .read = acpi_pm_evt_read,
452 .write = acpi_pm_evt_write,
453 .valid.min_access_size = 2,
454 .valid.max_access_size = 2,
455 .endianness = DEVICE_LITTLE_ENDIAN,
456 };
457
458 void acpi_pm1_evt_init(ACPIREGS *ar, acpi_update_sci_fn update_sci,
459 MemoryRegion *parent)
460 {
461 ar->pm1.evt.update_sci = update_sci;
462 memory_region_init_io(&ar->pm1.evt.io, memory_region_owner(parent),
463 &acpi_pm_evt_ops, ar, "acpi-evt", 4);
464 memory_region_add_subregion(parent, 0, &ar->pm1.evt.io);
465 }
466
467 /* ACPI PM_TMR */
468 void acpi_pm_tmr_update(ACPIREGS *ar, bool enable)
469 {
470 int64_t expire_time;
471
472 /* schedule a timer interruption if needed */
473 if (enable) {
474 expire_time = muldiv64(ar->tmr.overflow_time, get_ticks_per_sec(),
475 PM_TIMER_FREQUENCY);
476 timer_mod(ar->tmr.timer, expire_time);
477 } else {
478 timer_del(ar->tmr.timer);
479 }
480 }
481
482 void acpi_pm_tmr_calc_overflow_time(ACPIREGS *ar)
483 {
484 int64_t d = acpi_pm_tmr_get_clock();
485 ar->tmr.overflow_time = (d + 0x800000LL) & ~0x7fffffLL;
486 }
487
488 static uint32_t acpi_pm_tmr_get(ACPIREGS *ar)
489 {
490 uint32_t d = acpi_pm_tmr_get_clock();
491 return d & 0xffffff;
492 }
493
494 static void acpi_pm_tmr_timer(void *opaque)
495 {
496 ACPIREGS *ar = opaque;
497 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_PMTIMER);
498 ar->tmr.update_sci(ar);
499 }
500
501 static uint64_t acpi_pm_tmr_read(void *opaque, hwaddr addr, unsigned width)
502 {
503 return acpi_pm_tmr_get(opaque);
504 }
505
506 static void acpi_pm_tmr_write(void *opaque, hwaddr addr, uint64_t val,
507 unsigned width)
508 {
509 /* nothing */
510 }
511
512 static const MemoryRegionOps acpi_pm_tmr_ops = {
513 .read = acpi_pm_tmr_read,
514 .write = acpi_pm_tmr_write,
515 .valid.min_access_size = 4,
516 .valid.max_access_size = 4,
517 .endianness = DEVICE_LITTLE_ENDIAN,
518 };
519
520 void acpi_pm_tmr_init(ACPIREGS *ar, acpi_update_sci_fn update_sci,
521 MemoryRegion *parent)
522 {
523 ar->tmr.update_sci = update_sci;
524 ar->tmr.timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, acpi_pm_tmr_timer, ar);
525 memory_region_init_io(&ar->tmr.io, memory_region_owner(parent),
526 &acpi_pm_tmr_ops, ar, "acpi-tmr", 4);
527 memory_region_add_subregion(parent, 8, &ar->tmr.io);
528 }
529
530 void acpi_pm_tmr_reset(ACPIREGS *ar)
531 {
532 ar->tmr.overflow_time = 0;
533 timer_del(ar->tmr.timer);
534 }
535
536 /* ACPI PM1aCNT */
537 static void acpi_pm1_cnt_write(ACPIREGS *ar, uint16_t val)
538 {
539 ar->pm1.cnt.cnt = val & ~(ACPI_BITMASK_SLEEP_ENABLE);
540
541 if (val & ACPI_BITMASK_SLEEP_ENABLE) {
542 /* change suspend type */
543 uint16_t sus_typ = (val >> 10) & 7;
544 switch(sus_typ) {
545 case 0: /* soft power off */
546 qemu_system_shutdown_request();
547 break;
548 case 1:
549 qemu_system_suspend_request();
550 break;
551 default:
552 if (sus_typ == ar->pm1.cnt.s4_val) { /* S4 request */
553 qapi_event_send_suspend_disk(&error_abort);
554 qemu_system_shutdown_request();
555 }
556 break;
557 }
558 }
559 }
560
561 void acpi_pm1_cnt_update(ACPIREGS *ar,
562 bool sci_enable, bool sci_disable)
563 {
564 /* ACPI specs 3.0, 4.7.2.5 */
565 if (sci_enable) {
566 ar->pm1.cnt.cnt |= ACPI_BITMASK_SCI_ENABLE;
567 } else if (sci_disable) {
568 ar->pm1.cnt.cnt &= ~ACPI_BITMASK_SCI_ENABLE;
569 }
570 }
571
572 static uint64_t acpi_pm_cnt_read(void *opaque, hwaddr addr, unsigned width)
573 {
574 ACPIREGS *ar = opaque;
575 return ar->pm1.cnt.cnt;
576 }
577
578 static void acpi_pm_cnt_write(void *opaque, hwaddr addr, uint64_t val,
579 unsigned width)
580 {
581 acpi_pm1_cnt_write(opaque, val);
582 }
583
584 static const MemoryRegionOps acpi_pm_cnt_ops = {
585 .read = acpi_pm_cnt_read,
586 .write = acpi_pm_cnt_write,
587 .valid.min_access_size = 2,
588 .valid.max_access_size = 2,
589 .endianness = DEVICE_LITTLE_ENDIAN,
590 };
591
592 void acpi_pm1_cnt_init(ACPIREGS *ar, MemoryRegion *parent, uint8_t s4_val)
593 {
594 ar->pm1.cnt.s4_val = s4_val;
595 ar->wakeup.notify = acpi_notify_wakeup;
596 qemu_register_wakeup_notifier(&ar->wakeup);
597 memory_region_init_io(&ar->pm1.cnt.io, memory_region_owner(parent),
598 &acpi_pm_cnt_ops, ar, "acpi-cnt", 2);
599 memory_region_add_subregion(parent, 4, &ar->pm1.cnt.io);
600 }
601
602 void acpi_pm1_cnt_reset(ACPIREGS *ar)
603 {
604 ar->pm1.cnt.cnt = 0;
605 }
606
607 /* ACPI GPE */
608 void acpi_gpe_init(ACPIREGS *ar, uint8_t len)
609 {
610 ar->gpe.len = len;
611 ar->gpe.sts = g_malloc0(len / 2);
612 ar->gpe.en = g_malloc0(len / 2);
613 }
614
615 void acpi_gpe_reset(ACPIREGS *ar)
616 {
617 memset(ar->gpe.sts, 0, ar->gpe.len / 2);
618 memset(ar->gpe.en, 0, ar->gpe.len / 2);
619 }
620
621 static uint8_t *acpi_gpe_ioport_get_ptr(ACPIREGS *ar, uint32_t addr)
622 {
623 uint8_t *cur = NULL;
624
625 if (addr < ar->gpe.len / 2) {
626 cur = ar->gpe.sts + addr;
627 } else if (addr < ar->gpe.len) {
628 cur = ar->gpe.en + addr - ar->gpe.len / 2;
629 } else {
630 abort();
631 }
632
633 return cur;
634 }
635
636 void acpi_gpe_ioport_writeb(ACPIREGS *ar, uint32_t addr, uint32_t val)
637 {
638 uint8_t *cur;
639
640 cur = acpi_gpe_ioport_get_ptr(ar, addr);
641 if (addr < ar->gpe.len / 2) {
642 /* GPE_STS */
643 *cur = (*cur) & ~val;
644 } else if (addr < ar->gpe.len) {
645 /* GPE_EN */
646 *cur = val;
647 } else {
648 abort();
649 }
650 }
651
652 uint32_t acpi_gpe_ioport_readb(ACPIREGS *ar, uint32_t addr)
653 {
654 uint8_t *cur;
655 uint32_t val;
656
657 cur = acpi_gpe_ioport_get_ptr(ar, addr);
658 val = 0;
659 if (cur != NULL) {
660 val = *cur;
661 }
662
663 return val;
664 }
665
666 void acpi_update_sci(ACPIREGS *regs, qemu_irq irq)
667 {
668 int sci_level, pm1a_sts;
669
670 pm1a_sts = acpi_pm1_evt_get_sts(regs);
671
672 sci_level = ((pm1a_sts &
673 regs->pm1.evt.en & ACPI_BITMASK_PM1_COMMON_ENABLED) != 0) ||
674 ((regs->gpe.sts[0] & regs->gpe.en[0]) != 0);
675
676 qemu_set_irq(irq, sci_level);
677
678 /* schedule a timer interruption if needed */
679 acpi_pm_tmr_update(regs,
680 (regs->pm1.evt.en & ACPI_BITMASK_TIMER_ENABLE) &&
681 !(pm1a_sts & ACPI_BITMASK_TIMER_STATUS));
682 }