core.c 18.3 KB
Newer Older
bellard's avatar
bellard committed
1 2
/*
 * ACPI implementation
3
 *
bellard's avatar
bellard committed
4
 * Copyright (c) 2006 Fabrice Bellard
5
 *
bellard's avatar
bellard committed
6 7 8 9 10 11 12 13 14 15
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License version 2 as published by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * 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 19
 *
 * Contributions after 2012-01-13 are licensed under the terms of the
 * GNU GPL, version 2 or (at your option) any later version.
bellard's avatar
bellard committed
20
 */
21
#include "sysemu/sysemu.h"
22
#include "hw/hw.h"
Paolo Bonzini's avatar
Paolo Bonzini committed
23 24
#include "hw/i386/pc.h"
#include "hw/acpi/acpi.h"
25
#include "monitor/monitor.h"
26 27 28 29
#include "qemu/config-file.h"
#include "qapi/opts-visitor.h"
#include "qapi/dealloc-visitor.h"
#include "qapi-visit.h"
bellard's avatar
bellard committed
30

31 32
struct acpi_table_header {
    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 36 37
    uint32_t length;          /* Length of table, in bytes, including header */
    uint8_t revision;         /* ACPI Specification minor version # */
    uint8_t checksum;         /* To make sum of entire table == 0 */
38 39
    char oem_id[6];           /* OEM identification */
    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 46 47
#define ACPI_TABLE_HDR_SIZE sizeof(struct acpi_table_header)
#define ACPI_TABLE_PFX_SIZE sizeof(uint16_t)  /* size of the extra prefix */

48
static const char unsigned dfl_hdr[ACPI_TABLE_HDR_SIZE - ACPI_TABLE_PFX_SIZE] =
49 50 51 52 53
    "QEMU\0\0\0\0\1\0"       /* sig (4), len(4), revno (1), csum (1) */
    "QEMUQEQEMUQEMU\1\0\0\0" /* OEM id (6), table (8), revno (4) */
    "QEMU\1\0\0\0"           /* ASL compiler ID (4), version (4) */
    ;

54
char unsigned *acpi_tables;
55 56
size_t acpi_tables_len;

57 58 59 60 61 62 63 64 65 66 67 68 69 70
static QemuOptsList qemu_acpi_opts = {
    .name = "acpi",
    .implied_opt_name = "data",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_acpi_opts.head),
    .desc = { { 0 } } /* validated with OptsVisitor */
};

static void acpi_register_config(void)
{
    qemu_add_opts(&qemu_acpi_opts);
}

machine_init(acpi_register_config);

71 72 73 74
static int acpi_checksum(const uint8_t *data, int len)
{
    int sum, i;
    sum = 0;
75
    for (i = 0; i < len; i++) {
76
        sum += data[i];
77
    }
78 79 80
    return (-sum) & 0xff;
}

81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231

/* Install a copy of the ACPI table specified in @blob.
 *
 * If @has_header is set, @blob starts with the System Description Table Header
 * structure. Otherwise, "dfl_hdr" is prepended. In any case, each header field
 * is optionally overwritten from @hdrs.
 *
 * It is valid to call this function with
 * (@blob == NULL && bloblen == 0 && !has_header).
 *
 * @hdrs->file and @hdrs->data are ignored.
 *
 * SIZE_MAX is considered "infinity" in this function.
 *
 * The number of tables that can be installed is not limited, but the 16-bit
 * counter at the beginning of "acpi_tables" wraps around after UINT16_MAX.
 */
static void acpi_table_install(const char unsigned *blob, size_t bloblen,
                               bool has_header,
                               const struct AcpiTableOptions *hdrs,
                               Error **errp)
{
    size_t body_start;
    const char unsigned *hdr_src;
    size_t body_size, acpi_payload_size;
    struct acpi_table_header *ext_hdr;
    unsigned changed_fields;

    /* Calculate where the ACPI table body starts within the blob, plus where
     * to copy the ACPI table header from.
     */
    if (has_header) {
        /*   _length             | ACPI header in blob | blob body
         *   ^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^
         *   ACPI_TABLE_PFX_SIZE     sizeof dfl_hdr      body_size
         *                           == body_start
         *
         *                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         *                           acpi_payload_size == bloblen
         */
        body_start = sizeof dfl_hdr;

        if (bloblen < body_start) {
            error_setg(errp, "ACPI table claiming to have header is too "
                       "short, available: %zu, expected: %zu", bloblen,
                       body_start);
            return;
        }
        hdr_src = blob;
    } else {
        /*   _length             | ACPI header in template | blob body
         *   ^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^
         *   ACPI_TABLE_PFX_SIZE       sizeof dfl_hdr        body_size
         *                                                   == bloblen
         *
         *                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         *                                  acpi_payload_size
         */
        body_start = 0;
        hdr_src = dfl_hdr;
    }
    body_size = bloblen - body_start;
    acpi_payload_size = sizeof dfl_hdr + body_size;

    if (acpi_payload_size > UINT16_MAX) {
        error_setg(errp, "ACPI table too big, requested: %zu, max: %u",
                   acpi_payload_size, (unsigned)UINT16_MAX);
        return;
    }

    /* We won't fail from here on. Initialize / extend the globals. */
    if (acpi_tables == NULL) {
        acpi_tables_len = sizeof(uint16_t);
        acpi_tables = g_malloc0(acpi_tables_len);
    }

    acpi_tables = g_realloc(acpi_tables, acpi_tables_len +
                                         ACPI_TABLE_PFX_SIZE +
                                         sizeof dfl_hdr + body_size);

    ext_hdr = (struct acpi_table_header *)(acpi_tables + acpi_tables_len);
    acpi_tables_len += ACPI_TABLE_PFX_SIZE;

    memcpy(acpi_tables + acpi_tables_len, hdr_src, sizeof dfl_hdr);
    acpi_tables_len += sizeof dfl_hdr;

    if (blob != NULL) {
        memcpy(acpi_tables + acpi_tables_len, blob + body_start, body_size);
        acpi_tables_len += body_size;
    }

    /* increase number of tables */
    cpu_to_le16wu((uint16_t *)acpi_tables,
                  le16_to_cpupu((uint16_t *)acpi_tables) + 1u);

    /* Update the header fields. The strings need not be NUL-terminated. */
    changed_fields = 0;
    ext_hdr->_length = cpu_to_le16(acpi_payload_size);

    if (hdrs->has_sig) {
        strncpy(ext_hdr->sig, hdrs->sig, sizeof ext_hdr->sig);
        ++changed_fields;
    }

    if (has_header && le32_to_cpu(ext_hdr->length) != acpi_payload_size) {
        fprintf(stderr,
                "warning: ACPI table has wrong length, header says "
                "%" PRIu32 ", actual size %zu bytes\n",
                le32_to_cpu(ext_hdr->length), acpi_payload_size);
    }
    ext_hdr->length = cpu_to_le32(acpi_payload_size);

    if (hdrs->has_rev) {
        ext_hdr->revision = hdrs->rev;
        ++changed_fields;
    }

    ext_hdr->checksum = 0;

    if (hdrs->has_oem_id) {
        strncpy(ext_hdr->oem_id, hdrs->oem_id, sizeof ext_hdr->oem_id);
        ++changed_fields;
    }
    if (hdrs->has_oem_table_id) {
        strncpy(ext_hdr->oem_table_id, hdrs->oem_table_id,
                sizeof ext_hdr->oem_table_id);
        ++changed_fields;
    }
    if (hdrs->has_oem_rev) {
        ext_hdr->oem_revision = cpu_to_le32(hdrs->oem_rev);
        ++changed_fields;
    }
    if (hdrs->has_asl_compiler_id) {
        strncpy(ext_hdr->asl_compiler_id, hdrs->asl_compiler_id,
                sizeof ext_hdr->asl_compiler_id);
        ++changed_fields;
    }
    if (hdrs->has_asl_compiler_rev) {
        ext_hdr->asl_compiler_revision = cpu_to_le32(hdrs->asl_compiler_rev);
        ++changed_fields;
    }

    if (!has_header && changed_fields == 0) {
        fprintf(stderr, "warning: ACPI table: no headers are specified\n");
    }

    /* recalculate checksum */
    ext_hdr->checksum = acpi_checksum((const char unsigned *)ext_hdr +
                                      ACPI_TABLE_PFX_SIZE, acpi_payload_size);
}

232
void acpi_table_add(const QemuOpts *opts, Error **errp)
233
{
234
    AcpiTableOptions *hdrs = NULL;
235
    Error *err = NULL;
236 237
    char **pathnames = NULL;
    char **cur;
238 239
    size_t bloblen = 0;
    char unsigned *blob = NULL;
240

241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
    {
        OptsVisitor *ov;

        ov = opts_visitor_new(opts);
        visit_type_AcpiTableOptions(opts_get_visitor(ov), &hdrs, NULL, &err);
        opts_visitor_cleanup(ov);
    }

    if (err) {
        goto out;
    }
    if (hdrs->has_file == hdrs->has_data) {
        error_setg(&err, "'-acpitable' requires one of 'data' or 'file'");
        goto out;
    }

    pathnames = g_strsplit(hdrs->has_file ? hdrs->file : hdrs->data, ":", 0);
    if (pathnames == NULL || pathnames[0] == NULL) {
        error_setg(&err, "'-acpitable' requires at least one pathname");
260
        goto out;
261 262 263
    }

    /* now read in the data files, reallocating buffer as needed */
264 265
    for (cur = pathnames; *cur; ++cur) {
        int fd = open(*cur, O_RDONLY | O_BINARY);
266 267

        if (fd < 0) {
268
            error_setg(&err, "can't open file %s: %s", *cur, strerror(errno));
269
            goto out;
270 271 272
        }

        for (;;) {
273
            char unsigned data[8192];
274 275 276
            ssize_t r;

            r = read(fd, data, sizeof data);
277 278 279
            if (r == 0) {
                break;
            } else if (r > 0) {
280 281 282
                blob = g_realloc(blob, bloblen + r);
                memcpy(blob + bloblen, data, r);
                bloblen += r;
283
            } else if (errno != EINTR) {
284
                error_setg(&err, "can't read file %s: %s",
285
                           *cur, strerror(errno));
286
                close(fd);
287
                goto out;
288 289 290 291 292 293
            }
        }

        close(fd);
    }

294
    acpi_table_install(blob, bloblen, hdrs->has_file, hdrs, &err);
295

296
out:
297
    g_free(blob);
298 299 300 301 302 303 304 305 306 307 308
    g_strfreev(pathnames);

    if (hdrs != NULL) {
        QapiDeallocVisitor *dv;

        dv = qapi_dealloc_visitor_new();
        visit_type_AcpiTableOptions(qapi_dealloc_get_visitor(dv), &hdrs, NULL,
                                    NULL);
        qapi_dealloc_visitor_cleanup(dv);
    }

309
    error_propagate(errp, err);
310
}
311

312 313 314 315 316 317
static void acpi_notify_wakeup(Notifier *notifier, void *data)
{
    ACPIREGS *ar = container_of(notifier, ACPIREGS, wakeup);
    WakeupReason *reason = data;

    switch (*reason) {
318 319 320 321
    case QEMU_WAKEUP_REASON_RTC:
        ar->pm1.evt.sts |=
            (ACPI_BITMASK_WAKE_STATUS | ACPI_BITMASK_RT_CLOCK_STATUS);
        break;
322 323 324 325
    case QEMU_WAKEUP_REASON_PMTIMER:
        ar->pm1.evt.sts |=
            (ACPI_BITMASK_WAKE_STATUS | ACPI_BITMASK_TIMER_STATUS);
        break;
326 327 328 329 330 331 332 333 334 335
    case QEMU_WAKEUP_REASON_OTHER:
    default:
        /* ACPI_BITMASK_WAKE_STATUS should be set on resume.
           Pretend that resume was caused by power button */
        ar->pm1.evt.sts |=
            (ACPI_BITMASK_WAKE_STATUS | ACPI_BITMASK_POWER_BUTTON_STATUS);
        break;
    }
}

336
/* ACPI PM1a EVT */
337
uint16_t acpi_pm1_evt_get_sts(ACPIREGS *ar)
338 339
{
    int64_t d = acpi_pm_tmr_get_clock();
340
    if (d >= ar->tmr.overflow_time) {
Gerd Hoffmann's avatar
Gerd Hoffmann committed
341
        ar->pm1.evt.sts |= ACPI_BITMASK_TIMER_STATUS;
342
    }
Gerd Hoffmann's avatar
Gerd Hoffmann committed
343
    return ar->pm1.evt.sts;
344 345
}

Gerd Hoffmann's avatar
Gerd Hoffmann committed
346
static void acpi_pm1_evt_write_sts(ACPIREGS *ar, uint16_t val)
347
{
348
    uint16_t pm1_sts = acpi_pm1_evt_get_sts(ar);
349 350
    if (pm1_sts & val & ACPI_BITMASK_TIMER_STATUS) {
        /* if TMRSTS is reset, then compute the new overflow time */
Gerd Hoffmann's avatar
Gerd Hoffmann committed
351
        acpi_pm_tmr_calc_overflow_time(ar);
352
    }
Gerd Hoffmann's avatar
Gerd Hoffmann committed
353
    ar->pm1.evt.sts &= ~val;
354 355
}

Gerd Hoffmann's avatar
Gerd Hoffmann committed
356
static void acpi_pm1_evt_write_en(ACPIREGS *ar, uint16_t val)
357 358
{
    ar->pm1.evt.en = val;
359 360
    qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_RTC,
                              val & ACPI_BITMASK_RT_CLOCK_ENABLE);
361 362
    qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_PMTIMER,
                              val & ACPI_BITMASK_TIMER_ENABLE);
363 364
}

Gerd Hoffmann's avatar
Gerd Hoffmann committed
365
void acpi_pm1_evt_power_down(ACPIREGS *ar)
366
{
Gerd Hoffmann's avatar
Gerd Hoffmann committed
367 368 369
    if (ar->pm1.evt.en & ACPI_BITMASK_POWER_BUTTON_ENABLE) {
        ar->pm1.evt.sts |= ACPI_BITMASK_POWER_BUTTON_STATUS;
        ar->tmr.update_sci(ar);
370 371 372
    }
}

Gerd Hoffmann's avatar
Gerd Hoffmann committed
373
void acpi_pm1_evt_reset(ACPIREGS *ar)
374
{
Gerd Hoffmann's avatar
Gerd Hoffmann committed
375 376
    ar->pm1.evt.sts = 0;
    ar->pm1.evt.en = 0;
377
    qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_RTC, 0);
378
    qemu_system_wakeup_enable(QEMU_WAKEUP_REASON_PMTIMER, 0);
379 380
}

Gerd Hoffmann's avatar
Gerd Hoffmann committed
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421
static uint64_t acpi_pm_evt_read(void *opaque, hwaddr addr, unsigned width)
{
    ACPIREGS *ar = opaque;
    switch (addr) {
    case 0:
        return acpi_pm1_evt_get_sts(ar);
    case 2:
        return ar->pm1.evt.en;
    default:
        return 0;
    }
}

static void acpi_pm_evt_write(void *opaque, hwaddr addr, uint64_t val,
                              unsigned width)
{
    ACPIREGS *ar = opaque;
    switch (addr) {
    case 0:
        acpi_pm1_evt_write_sts(ar, val);
        ar->pm1.evt.update_sci(ar);
        break;
    case 2:
        acpi_pm1_evt_write_en(ar, val);
        ar->pm1.evt.update_sci(ar);
        break;
    }
}

static const MemoryRegionOps acpi_pm_evt_ops = {
    .read = acpi_pm_evt_read,
    .write = acpi_pm_evt_write,
    .valid.min_access_size = 2,
    .valid.max_access_size = 2,
    .endianness = DEVICE_LITTLE_ENDIAN,
};

void acpi_pm1_evt_init(ACPIREGS *ar, acpi_update_sci_fn update_sci,
                       MemoryRegion *parent)
{
    ar->pm1.evt.update_sci = update_sci;
422 423
    memory_region_init_io(&ar->pm1.evt.io, memory_region_owner(parent),
                          &acpi_pm_evt_ops, ar, "acpi-evt", 4);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
424 425 426
    memory_region_add_subregion(parent, 0, &ar->pm1.evt.io);
}

427
/* ACPI PM_TMR */
Gerd Hoffmann's avatar
Gerd Hoffmann committed
428
void acpi_pm_tmr_update(ACPIREGS *ar, bool enable)
429 430 431 432 433
{
    int64_t expire_time;

    /* schedule a timer interruption if needed */
    if (enable) {
Gerd Hoffmann's avatar
Gerd Hoffmann committed
434
        expire_time = muldiv64(ar->tmr.overflow_time, get_ticks_per_sec(),
435
                               PM_TIMER_FREQUENCY);
436
        timer_mod(ar->tmr.timer, expire_time);
437
    } else {
438
        timer_del(ar->tmr.timer);
439 440 441
    }
}

Gerd Hoffmann's avatar
Gerd Hoffmann committed
442
void acpi_pm_tmr_calc_overflow_time(ACPIREGS *ar)
443 444
{
    int64_t d = acpi_pm_tmr_get_clock();
Gerd Hoffmann's avatar
Gerd Hoffmann committed
445
    ar->tmr.overflow_time = (d + 0x800000LL) & ~0x7fffffLL;
446 447
}

448
static uint32_t acpi_pm_tmr_get(ACPIREGS *ar)
449
{
450
    uint32_t d = acpi_pm_tmr_get_clock();
451 452 453 454 455
    return d & 0xffffff;
}

static void acpi_pm_tmr_timer(void *opaque)
{
Gerd Hoffmann's avatar
Gerd Hoffmann committed
456
    ACPIREGS *ar = opaque;
457
    qemu_system_wakeup_request(QEMU_WAKEUP_REASON_PMTIMER);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
458
    ar->tmr.update_sci(ar);
459 460
}

461 462 463 464 465
static uint64_t acpi_pm_tmr_read(void *opaque, hwaddr addr, unsigned width)
{
    return acpi_pm_tmr_get(opaque);
}

466 467 468 469 470 471
static void acpi_pm_tmr_write(void *opaque, hwaddr addr, uint64_t val,
                              unsigned width)
{
    /* nothing */
}

472 473
static const MemoryRegionOps acpi_pm_tmr_ops = {
    .read = acpi_pm_tmr_read,
474
    .write = acpi_pm_tmr_write,
475 476 477 478 479 480 481
    .valid.min_access_size = 4,
    .valid.max_access_size = 4,
    .endianness = DEVICE_LITTLE_ENDIAN,
};

void acpi_pm_tmr_init(ACPIREGS *ar, acpi_update_sci_fn update_sci,
                      MemoryRegion *parent)
482
{
Gerd Hoffmann's avatar
Gerd Hoffmann committed
483
    ar->tmr.update_sci = update_sci;
484
    ar->tmr.timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, acpi_pm_tmr_timer, ar);
485 486
    memory_region_init_io(&ar->tmr.io, memory_region_owner(parent),
                          &acpi_pm_tmr_ops, ar, "acpi-tmr", 4);
487
    memory_region_add_subregion(parent, 8, &ar->tmr.io);
488 489
}

Gerd Hoffmann's avatar
Gerd Hoffmann committed
490
void acpi_pm_tmr_reset(ACPIREGS *ar)
491
{
Gerd Hoffmann's avatar
Gerd Hoffmann committed
492
    ar->tmr.overflow_time = 0;
493
    timer_del(ar->tmr.timer);
494
}
495 496

/* ACPI PM1aCNT */
Gerd Hoffmann's avatar
Gerd Hoffmann committed
497
static void acpi_pm1_cnt_write(ACPIREGS *ar, uint16_t val)
498
{
Gerd Hoffmann's avatar
Gerd Hoffmann committed
499
    ar->pm1.cnt.cnt = val & ~(ACPI_BITMASK_SLEEP_ENABLE);
500 501 502 503 504 505 506 507 508

    if (val & ACPI_BITMASK_SLEEP_ENABLE) {
        /* change suspend type */
        uint16_t sus_typ = (val >> 10) & 7;
        switch(sus_typ) {
        case 0: /* soft power off */
            qemu_system_shutdown_request();
            break;
        case 1:
509 510
            qemu_system_suspend_request();
            break;
511
        default:
Gerd Hoffmann's avatar
Gerd Hoffmann committed
512
            if (sus_typ == ar->pm1.cnt.s4_val) { /* S4 request */
Luiz Capitulino's avatar
Luiz Capitulino committed
513
                monitor_protocol_event(QEVENT_SUSPEND_DISK, NULL);
514 515
                qemu_system_shutdown_request();
            }
516 517 518 519 520
            break;
        }
    }
}

Gerd Hoffmann's avatar
Gerd Hoffmann committed
521
void acpi_pm1_cnt_update(ACPIREGS *ar,
522 523 524 525
                         bool sci_enable, bool sci_disable)
{
    /* ACPI specs 3.0, 4.7.2.5 */
    if (sci_enable) {
Gerd Hoffmann's avatar
Gerd Hoffmann committed
526
        ar->pm1.cnt.cnt |= ACPI_BITMASK_SCI_ENABLE;
527
    } else if (sci_disable) {
Gerd Hoffmann's avatar
Gerd Hoffmann committed
528
        ar->pm1.cnt.cnt &= ~ACPI_BITMASK_SCI_ENABLE;
529 530 531
    }
}

Gerd Hoffmann's avatar
Gerd Hoffmann committed
532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
static uint64_t acpi_pm_cnt_read(void *opaque, hwaddr addr, unsigned width)
{
    ACPIREGS *ar = opaque;
    return ar->pm1.cnt.cnt;
}

static void acpi_pm_cnt_write(void *opaque, hwaddr addr, uint64_t val,
                              unsigned width)
{
    acpi_pm1_cnt_write(opaque, val);
}

static const MemoryRegionOps acpi_pm_cnt_ops = {
    .read = acpi_pm_cnt_read,
    .write = acpi_pm_cnt_write,
    .valid.min_access_size = 2,
    .valid.max_access_size = 2,
    .endianness = DEVICE_LITTLE_ENDIAN,
};

552
void acpi_pm1_cnt_init(ACPIREGS *ar, MemoryRegion *parent, uint8_t s4_val)
Gerd Hoffmann's avatar
Gerd Hoffmann committed
553
{
554
    ar->pm1.cnt.s4_val = s4_val;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
555 556
    ar->wakeup.notify = acpi_notify_wakeup;
    qemu_register_wakeup_notifier(&ar->wakeup);
557 558
    memory_region_init_io(&ar->pm1.cnt.io, memory_region_owner(parent),
                          &acpi_pm_cnt_ops, ar, "acpi-cnt", 2);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
559 560 561
    memory_region_add_subregion(parent, 4, &ar->pm1.cnt.io);
}

Gerd Hoffmann's avatar
Gerd Hoffmann committed
562
void acpi_pm1_cnt_reset(ACPIREGS *ar)
563
{
Gerd Hoffmann's avatar
Gerd Hoffmann committed
564
    ar->pm1.cnt.cnt = 0;
565
}
566 567

/* ACPI GPE */
Gerd Hoffmann's avatar
Gerd Hoffmann committed
568
void acpi_gpe_init(ACPIREGS *ar, uint8_t len)
569
{
Gerd Hoffmann's avatar
Gerd Hoffmann committed
570 571 572
    ar->gpe.len = len;
    ar->gpe.sts = g_malloc0(len / 2);
    ar->gpe.en = g_malloc0(len / 2);
573 574
}

Gerd Hoffmann's avatar
Gerd Hoffmann committed
575
void acpi_gpe_reset(ACPIREGS *ar)
576
{
Gerd Hoffmann's avatar
Gerd Hoffmann committed
577 578
    memset(ar->gpe.sts, 0, ar->gpe.len / 2);
    memset(ar->gpe.en, 0, ar->gpe.len / 2);
579 580
}

Gerd Hoffmann's avatar
Gerd Hoffmann committed
581
static uint8_t *acpi_gpe_ioport_get_ptr(ACPIREGS *ar, uint32_t addr)
582 583 584
{
    uint8_t *cur = NULL;

Gerd Hoffmann's avatar
Gerd Hoffmann committed
585 586 587 588
    if (addr < ar->gpe.len / 2) {
        cur = ar->gpe.sts + addr;
    } else if (addr < ar->gpe.len) {
        cur = ar->gpe.en + addr - ar->gpe.len / 2;
589 590 591 592 593 594 595
    } else {
        abort();
    }

    return cur;
}

Gerd Hoffmann's avatar
Gerd Hoffmann committed
596
void acpi_gpe_ioport_writeb(ACPIREGS *ar, uint32_t addr, uint32_t val)
597 598 599
{
    uint8_t *cur;

Gerd Hoffmann's avatar
Gerd Hoffmann committed
600 601
    cur = acpi_gpe_ioport_get_ptr(ar, addr);
    if (addr < ar->gpe.len / 2) {
602 603
        /* GPE_STS */
        *cur = (*cur) & ~val;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
604
    } else if (addr < ar->gpe.len) {
605 606 607 608 609 610 611
        /* GPE_EN */
        *cur = val;
    } else {
        abort();
    }
}

Gerd Hoffmann's avatar
Gerd Hoffmann committed
612
uint32_t acpi_gpe_ioport_readb(ACPIREGS *ar, uint32_t addr)
613 614 615 616
{
    uint8_t *cur;
    uint32_t val;

Gerd Hoffmann's avatar
Gerd Hoffmann committed
617
    cur = acpi_gpe_ioport_get_ptr(ar, addr);
618 619 620 621 622 623 624
    val = 0;
    if (cur != NULL) {
        val = *cur;
    }

    return val;
}