[qemu.git] / hw / acpi.c

/*
 * ACPI implementation
 *
 * Copyright (c) 2006 Fabrice Bellard
 *
 * 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
 * License along with this library; if not, see <http://www.gnu.org/licenses/>
 *
 * Contributions after 2012-01-13 are licensed under the terms of the
 * GNU GPL, version 2 or (at your option) any later version.
 */
#include "sysemu.h"
#include "hw.h"
#include "pc.h"
#include "acpi.h"

struct acpi_table_header {
    uint16_t _length;         /* our length, not actual part of the hdr */
                              /* XXX why we have 2 length fields here? */
    char sig[4];              /* ACPI signature (4 ASCII characters) */
    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 */
    char oem_id[6];           /* OEM identification */
    char oem_table_id[8];     /* OEM table identification */
    uint32_t oem_revision;    /* OEM revision number */
    char asl_compiler_id[4];  /* ASL compiler vendor ID */
    uint32_t asl_compiler_revision; /* ASL compiler revision number */
} QEMU_PACKED;

#define ACPI_TABLE_HDR_SIZE sizeof(struct acpi_table_header)
#define ACPI_TABLE_PFX_SIZE sizeof(uint16_t)  /* size of the extra prefix */

static const char dfl_hdr[ACPI_TABLE_HDR_SIZE] =
    "\0\0"                   /* fake _length (2) */
    "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) */
    ;

char *acpi_tables;
size_t acpi_tables_len;

static int acpi_checksum(const uint8_t *data, int len)
{
    int sum, i;
    sum = 0;
    for (i = 0; i < len; i++) {
        sum += data[i];
    }
    return (-sum) & 0xff;
}

/* like strncpy() but zero-fills the tail of destination */
static void strzcpy(char *dst, const char *src, size_t size)
{
    size_t len = strlen(src);
    if (len >= size) {
        len = size;
    } else {
      memset(dst + len, 0, size - len);
    }
    memcpy(dst, src, len);
}

/* XXX fixme: this function uses obsolete argument parsing interface */
int acpi_table_add(const char *t)
{
    char buf[1024], *p, *f;
    unsigned long val;
    size_t len, start, allen;
    bool has_header;
    int changed;
    int r;
    struct acpi_table_header hdr;

    r = 0;
    r |= get_param_value(buf, sizeof(buf), "data", t) ? 1 : 0;
    r |= get_param_value(buf, sizeof(buf), "file", t) ? 2 : 0;
    switch (r) {
    case 0:
        buf[0] = '\0';
        /* fallthrough for default behavior */
    case 1:
        has_header = false;
        break;
    case 2:
        has_header = true;
        break;
    default:
        fprintf(stderr, "acpitable: both data and file are specified\n");
        return -1;
    }

    if (!acpi_tables) {
        allen = sizeof(uint16_t);
        acpi_tables = g_malloc0(allen);
    } else {
        allen = acpi_tables_len;
    }

    start = allen;
    acpi_tables = g_realloc(acpi_tables, start + ACPI_TABLE_HDR_SIZE);
    allen += has_header ? ACPI_TABLE_PFX_SIZE : ACPI_TABLE_HDR_SIZE;

    /* now read in the data files, reallocating buffer as needed */

    for (f = strtok(buf, ":"); f; f = strtok(NULL, ":")) {
        int fd = open(f, O_RDONLY);

        if (fd < 0) {
            fprintf(stderr, "can't open file %s: %s\n", f, strerror(errno));
            return -1;
        }

        for (;;) {
            char data[8192];
            r = read(fd, data, sizeof(data));
            if (r == 0) {
                break;
            } else if (r > 0) {
                acpi_tables = g_realloc(acpi_tables, allen + r);
                memcpy(acpi_tables + allen, data, r);
                allen += r;
            } else if (errno != EINTR) {
                fprintf(stderr, "can't read file %s: %s\n",
                        f, strerror(errno));
                close(fd);
                return -1;
            }
        }

        close(fd);
    }

    /* now fill in the header fields */

    f = acpi_tables + start;   /* start of the table */
    changed = 0;

    /* copy the header to temp place to align the fields */
    memcpy(&hdr, has_header ? f : dfl_hdr, ACPI_TABLE_HDR_SIZE);

    /* length of the table minus our prefix */
    len = allen - start - ACPI_TABLE_PFX_SIZE;

    hdr._length = cpu_to_le16(len);

    if (get_param_value(buf, sizeof(buf), "sig", t)) {
        strzcpy(hdr.sig, buf, sizeof(hdr.sig));
        ++changed;
    }

    /* length of the table including header, in bytes */
    if (has_header) {
        /* check if actual length is correct */
        val = le32_to_cpu(hdr.length);
        if (val != len) {
            fprintf(stderr,
                "warning: acpitable has wrong length,"
                " header says %lu, actual size %zu bytes\n",
                val, len);
            ++changed;
        }
    }
    /* we may avoid putting length here if has_header is true */
    hdr.length = cpu_to_le32(len);

    if (get_param_value(buf, sizeof(buf), "rev", t)) {
        val = strtoul(buf, &p, 0);
        if (val > 255 || *p) {
            fprintf(stderr, "acpitable: \"rev=%s\" is invalid\n", buf);
            return -1;
        }
        hdr.revision = (uint8_t)val;
        ++changed;
    }

    if (get_param_value(buf, sizeof(buf), "oem_id", t)) {
        strzcpy(hdr.oem_id, buf, sizeof(hdr.oem_id));
        ++changed;
    }

    if (get_param_value(buf, sizeof(buf), "oem_table_id", t)) {
        strzcpy(hdr.oem_table_id, buf, sizeof(hdr.oem_table_id));
        ++changed;
    }

    if (get_param_value(buf, sizeof(buf), "oem_rev", t)) {
        val = strtol(buf, &p, 0);
        if (*p) {
            fprintf(stderr, "acpitable: \"oem_rev=%s\" is invalid\n", buf);
            return -1;
        }
        hdr.oem_revision = cpu_to_le32(val);
        ++changed;
    }

    if (get_param_value(buf, sizeof(buf), "asl_compiler_id", t)) {
        strzcpy(hdr.asl_compiler_id, buf, sizeof(hdr.asl_compiler_id));
        ++changed;
    }

    if (get_param_value(buf, sizeof(buf), "asl_compiler_rev", t)) {
        val = strtol(buf, &p, 0);
        if (*p) {
            fprintf(stderr, "acpitable: \"%s=%s\" is invalid\n",
                    "asl_compiler_rev", buf);
            return -1;
        }
        hdr.asl_compiler_revision = cpu_to_le32(val);
        ++changed;
    }

    if (!has_header && !changed) {
        fprintf(stderr, "warning: acpitable: no table headers are specified\n");
    }


    /* now calculate checksum of the table, complete with the header */
    /* we may as well leave checksum intact if has_header is true */
    /* alternatively there may be a way to set cksum to a given value */
    hdr.checksum = 0;    /* for checksum calculation */

    /* put header back */
    memcpy(f, &hdr, sizeof(hdr));

    if (changed || !has_header || 1) {
        ((struct acpi_table_header *)f)->checksum =
            acpi_checksum((uint8_t *)f + ACPI_TABLE_PFX_SIZE, len);
    }

    /* increase number of tables */
    (*(uint16_t *)acpi_tables) =
        cpu_to_le32(le32_to_cpu(*(uint16_t *)acpi_tables) + 1);

    acpi_tables_len = allen;
    return 0;

}

/* ACPI PM1a EVT */
uint16_t acpi_pm1_evt_get_sts(ACPIPM1EVT *pm1, int64_t overflow_time)
{
    int64_t d = acpi_pm_tmr_get_clock();
    if (d >= overflow_time) {
        pm1->sts |= ACPI_BITMASK_TIMER_STATUS;
    }
    return pm1->sts;
}

void acpi_pm1_evt_write_sts(ACPIPM1EVT *pm1, ACPIPMTimer *tmr, uint16_t val)
{
    uint16_t pm1_sts = acpi_pm1_evt_get_sts(pm1, tmr->overflow_time);
    if (pm1_sts & val & ACPI_BITMASK_TIMER_STATUS) {
        /* if TMRSTS is reset, then compute the new overflow time */
        acpi_pm_tmr_calc_overflow_time(tmr);
    }
    pm1->sts &= ~val;
}

void acpi_pm1_evt_power_down(ACPIPM1EVT *pm1, ACPIPMTimer *tmr)
{
    if (!pm1) {
        qemu_system_shutdown_request();
    } else if (pm1->en & ACPI_BITMASK_POWER_BUTTON_ENABLE) {
        pm1->sts |= ACPI_BITMASK_POWER_BUTTON_STATUS;
        tmr->update_sci(tmr);
    }
}

void acpi_pm1_evt_reset(ACPIPM1EVT *pm1)
{
    pm1->sts = 0;
    pm1->en = 0;
}

/* ACPI PM_TMR */
void acpi_pm_tmr_update(ACPIPMTimer *tmr, bool enable)
{
    int64_t expire_time;

    /* schedule a timer interruption if needed */
    if (enable) {
        expire_time = muldiv64(tmr->overflow_time, get_ticks_per_sec(),
                               PM_TIMER_FREQUENCY);
        qemu_mod_timer(tmr->timer, expire_time);
    } else {
        qemu_del_timer(tmr->timer);
    }
}

void acpi_pm_tmr_calc_overflow_time(ACPIPMTimer *tmr)
{
    int64_t d = acpi_pm_tmr_get_clock();
    tmr->overflow_time = (d + 0x800000LL) & ~0x7fffffLL;
}

uint32_t acpi_pm_tmr_get(ACPIPMTimer *tmr)
{
    uint32_t d = acpi_pm_tmr_get_clock();
    return d & 0xffffff;
}

static void acpi_pm_tmr_timer(void *opaque)
{
    ACPIPMTimer *tmr = opaque;
    tmr->update_sci(tmr);
}

void acpi_pm_tmr_init(ACPIPMTimer *tmr, acpi_update_sci_fn update_sci)
{
    tmr->update_sci = update_sci;
    tmr->timer = qemu_new_timer_ns(vm_clock, acpi_pm_tmr_timer, tmr);
}

void acpi_pm_tmr_reset(ACPIPMTimer *tmr)
{
    tmr->overflow_time = 0;
    qemu_del_timer(tmr->timer);
}

/* ACPI PM1aCNT */
void acpi_pm1_cnt_init(ACPIPM1CNT *pm1_cnt, qemu_irq cmos_s3)
{
    pm1_cnt->cmos_s3 = cmos_s3;
}

void acpi_pm1_cnt_write(ACPIPM1EVT *pm1a, ACPIPM1CNT *pm1_cnt, uint16_t val)
{
    pm1_cnt->cnt = val & ~(ACPI_BITMASK_SLEEP_ENABLE);

    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:
            /* ACPI_BITMASK_WAKE_STATUS should be set on resume.
               Pretend that resume was caused by power button */
            pm1a->sts |=
                (ACPI_BITMASK_WAKE_STATUS | ACPI_BITMASK_POWER_BUTTON_STATUS);
            qemu_system_reset_request();
            qemu_irq_raise(pm1_cnt->cmos_s3);
        default:
            break;
        }
    }
}

void acpi_pm1_cnt_update(ACPIPM1CNT *pm1_cnt,
                         bool sci_enable, bool sci_disable)
{
    /* ACPI specs 3.0, 4.7.2.5 */
    if (sci_enable) {
        pm1_cnt->cnt |= ACPI_BITMASK_SCI_ENABLE;
    } else if (sci_disable) {
        pm1_cnt->cnt &= ~ACPI_BITMASK_SCI_ENABLE;
    }
}

void acpi_pm1_cnt_reset(ACPIPM1CNT *pm1_cnt)
{
    pm1_cnt->cnt = 0;
    if (pm1_cnt->cmos_s3) {
        qemu_irq_lower(pm1_cnt->cmos_s3);
    }
}

/* ACPI GPE */
void acpi_gpe_init(ACPIGPE *gpe, uint8_t len)
{
    gpe->len = len;
    gpe->sts = g_malloc0(len / 2);
    gpe->en = g_malloc0(len / 2);
}

void acpi_gpe_blk(ACPIGPE *gpe, uint32_t blk)
{
    gpe->blk = blk;
}

void acpi_gpe_reset(ACPIGPE *gpe)
{
    memset(gpe->sts, 0, gpe->len / 2);
    memset(gpe->en, 0, gpe->len / 2);
}

static uint8_t *acpi_gpe_ioport_get_ptr(ACPIGPE *gpe, uint32_t addr)
{
    uint8_t *cur = NULL;

    if (addr < gpe->len / 2) {
        cur = gpe->sts + addr;
    } else if (addr < gpe->len) {
        cur = gpe->en + addr - gpe->len / 2;
    } else {
        abort();
    }

    return cur;
}

void acpi_gpe_ioport_writeb(ACPIGPE *gpe, uint32_t addr, uint32_t val)
{
    uint8_t *cur;

    addr -= gpe->blk;
    cur = acpi_gpe_ioport_get_ptr(gpe, addr);
    if (addr < gpe->len / 2) {
        /* GPE_STS */
        *cur = (*cur) & ~val;
    } else if (addr < gpe->len) {
        /* GPE_EN */
        *cur = val;
    } else {
        abort();
    }
}

uint32_t acpi_gpe_ioport_readb(ACPIGPE *gpe, uint32_t addr)
{
    uint8_t *cur;
    uint32_t val;

    addr -= gpe->blk;
    cur = acpi_gpe_ioport_get_ptr(gpe, addr);
    val = 0;
    if (cur != NULL) {
        val = *cur;
    }

    return val;
}
Commit	Line	Data
6515b203 FB	1	/*
6515b203 FB	2	* ACPI implementation
5fafdf24	3	*
6515b203	4	* Copyright (c) 2006 Fabrice Bellard
5fafdf24	5	*
6515b203 FB	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
8167ee88	16	* License along with this library; if not, see <http://www.gnu.org/licenses/>
6b620ca3 PB	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.
6515b203	20	*/
04dc308f	21	#include "sysemu.h"
87ecb68b PB	22	#include "hw.h"
87ecb68b PB	23	#include "pc.h"
990b150e	24	#include "acpi.h"
6515b203	25
104bf02e MT	26	struct acpi_table_header {
	27	uint16_t _length; /* our length, not actual part of the hdr */
	28	/* XXX why we have 2 length fields here? */
	29	char sig[4]; /* ACPI signature (4 ASCII characters) */
8a92ea2f AL	30	uint32_t length; /* Length of table, in bytes, including header */
	31	uint8_t revision; /* ACPI Specification minor version # */
	32	uint8_t checksum; /* To make sum of entire table == 0 */
104bf02e MT	33	char oem_id[6]; /* OEM identification */
104bf02e MT	34	char oem_table_id[8]; /* OEM table identification */
8a92ea2f	35	uint32_t oem_revision; /* OEM revision number */
104bf02e	36	char asl_compiler_id[4]; /* ASL compiler vendor ID */
8a92ea2f	37	uint32_t asl_compiler_revision; /* ASL compiler revision number */
541dc0d4	38	} QEMU_PACKED;
8a92ea2f	39
104bf02e MT	40	#define ACPI_TABLE_HDR_SIZE sizeof(struct acpi_table_header)
	41	#define ACPI_TABLE_PFX_SIZE sizeof(uint16_t) /* size of the extra prefix */
	42
	43	static const char dfl_hdr[ACPI_TABLE_HDR_SIZE] =
	44	"\0\0" /* fake _length (2) */
	45	"QEMU\0\0\0\0\1\0" /* sig (4), len(4), revno (1), csum (1) */
	46	"QEMUQEQEMUQEMU\1\0\0\0" /* OEM id (6), table (8), revno (4) */
	47	"QEMU\1\0\0\0" /* ASL compiler ID (4), version (4) */
	48	;
	49
8a92ea2f AL	50	char *acpi_tables;
	51	size_t acpi_tables_len;
	52
	53	static int acpi_checksum(const uint8_t *data, int len)
	54	{
	55	int sum, i;
	56	sum = 0;
104bf02e	57	for (i = 0; i < len; i++) {
8a92ea2f	58	sum += data[i];
104bf02e	59	}
8a92ea2f AL	60	return (-sum) & 0xff;
	61	}
	62
104bf02e MT	63	/* like strncpy() but zero-fills the tail of destination */
	64	static void strzcpy(char dst, const char src, size_t size)
	65	{
	66	size_t len = strlen(src);
	67	if (len >= size) {
	68	len = size;
	69	} else {
	70	memset(dst + len, 0, size - len);
	71	}
	72	memcpy(dst, src, len);
	73	}
	74
	75	/* XXX fixme: this function uses obsolete argument parsing interface */
8a92ea2f AL	76	int acpi_table_add(const char *t)
8a92ea2f AL	77	{
8a92ea2f	78	char buf[1024], p, f;
8a92ea2f	79	unsigned long val;
104bf02e MT	80	size_t len, start, allen;
	81	bool has_header;
	82	int changed;
	83	int r;
	84	struct acpi_table_header hdr;
8a92ea2f	85
104bf02e MT	86	r = 0;
	87	r \|= get_param_value(buf, sizeof(buf), "data", t) ? 1 : 0;
	88	r \|= get_param_value(buf, sizeof(buf), "file", t) ? 2 : 0;
	89	switch (r) {
	90	case 0:
	91	buf[0] = '\0';
	92	/* fallthrough for default behavior */
	93	case 1:
	94	has_header = false;
	95	break;
	96	case 2:
	97	has_header = true;
	98	break;
	99	default:
	100	fprintf(stderr, "acpitable: both data and file are specified\n");
	101	return -1;
	102	}
	103
	104	if (!acpi_tables) {
	105	allen = sizeof(uint16_t);
7267c094	106	acpi_tables = g_malloc0(allen);
8a92ea2f	107	} else {
104bf02e MT	108	allen = acpi_tables_len;
	109	}
	110
	111	start = allen;
7267c094	112	acpi_tables = g_realloc(acpi_tables, start + ACPI_TABLE_HDR_SIZE);
104bf02e MT	113	allen += has_header ? ACPI_TABLE_PFX_SIZE : ACPI_TABLE_HDR_SIZE;
	114
	115	/* now read in the data files, reallocating buffer as needed */
	116
	117	for (f = strtok(buf, ":"); f; f = strtok(NULL, ":")) {
	118	int fd = open(f, O_RDONLY);
	119
	120	if (fd < 0) {
	121	fprintf(stderr, "can't open file %s: %s\n", f, strerror(errno));
	122	return -1;
	123	}
	124
	125	for (;;) {
	126	char data[8192];
	127	r = read(fd, data, sizeof(data));
	128	if (r == 0) {
	129	break;
	130	} else if (r > 0) {
7267c094	131	acpi_tables = g_realloc(acpi_tables, allen + r);
104bf02e MT	132	memcpy(acpi_tables + allen, data, r);
	133	allen += r;
	134	} else if (errno != EINTR) {
	135	fprintf(stderr, "can't read file %s: %s\n",
	136	f, strerror(errno));
	137	close(fd);
	138	return -1;
	139	}
	140	}
	141
	142	close(fd);
	143	}
	144
	145	/* now fill in the header fields */
	146
	147	f = acpi_tables + start; /* start of the table */
	148	changed = 0;
	149
	150	/* copy the header to temp place to align the fields */
	151	memcpy(&hdr, has_header ? f : dfl_hdr, ACPI_TABLE_HDR_SIZE);
	152
	153	/* length of the table minus our prefix */
	154	len = allen - start - ACPI_TABLE_PFX_SIZE;
	155
	156	hdr._length = cpu_to_le16(len);
	157
	158	if (get_param_value(buf, sizeof(buf), "sig", t)) {
	159	strzcpy(hdr.sig, buf, sizeof(hdr.sig));
	160	++changed;
	161	}
	162
	163	/* length of the table including header, in bytes */
	164	if (has_header) {
	165	/* check if actual length is correct */
	166	val = le32_to_cpu(hdr.length);
	167	if (val != len) {
	168	fprintf(stderr,
	169	"warning: acpitable has wrong length,"
	170	" header says %lu, actual size %zu bytes\n",
	171	val, len);
	172	++changed;
	173	}
8a92ea2f	174	}
104bf02e MT	175	/* we may avoid putting length here if has_header is true */
	176	hdr.length = cpu_to_le32(len);
	177
8a92ea2f	178	if (get_param_value(buf, sizeof(buf), "rev", t)) {
104bf02e MT	179	val = strtoul(buf, &p, 0);
	180	if (val > 255 \|\| *p) {
	181	fprintf(stderr, "acpitable: \"rev=%s\" is invalid\n", buf);
	182	return -1;
	183	}
	184	hdr.revision = (uint8_t)val;
	185	++changed;
8a92ea2f	186	}
8a92ea2f AL	187
8a92ea2f AL	188	if (get_param_value(buf, sizeof(buf), "oem_id", t)) {
104bf02e MT	189	strzcpy(hdr.oem_id, buf, sizeof(hdr.oem_id));
104bf02e MT	190	++changed;
8a92ea2f AL	191	}
	192
	193	if (get_param_value(buf, sizeof(buf), "oem_table_id", t)) {
104bf02e MT	194	strzcpy(hdr.oem_table_id, buf, sizeof(hdr.oem_table_id));
104bf02e MT	195	++changed;
8a92ea2f AL	196	}
	197
	198	if (get_param_value(buf, sizeof(buf), "oem_rev", t)) {
104bf02e MT	199	val = strtol(buf, &p, 0);
	200	if (*p) {
	201	fprintf(stderr, "acpitable: \"oem_rev=%s\" is invalid\n", buf);
	202	return -1;
	203	}
	204	hdr.oem_revision = cpu_to_le32(val);
	205	++changed;
8a92ea2f	206	}
8a92ea2f AL	207
8a92ea2f AL	208	if (get_param_value(buf, sizeof(buf), "asl_compiler_id", t)) {
104bf02e MT	209	strzcpy(hdr.asl_compiler_id, buf, sizeof(hdr.asl_compiler_id));
104bf02e MT	210	++changed;
8a92ea2f AL	211	}
	212
	213	if (get_param_value(buf, sizeof(buf), "asl_compiler_rev", t)) {
104bf02e MT	214	val = strtol(buf, &p, 0);
	215	if (*p) {
	216	fprintf(stderr, "acpitable: \"%s=%s\" is invalid\n",
	217	"asl_compiler_rev", buf);
	218	return -1;
	219	}
	220	hdr.asl_compiler_revision = cpu_to_le32(val);
	221	++changed;
8a92ea2f AL	222	}
8a92ea2f AL	223
104bf02e MT	224	if (!has_header && !changed) {
104bf02e MT	225	fprintf(stderr, "warning: acpitable: no table headers are specified\n");
8a92ea2f AL	226	}
8a92ea2f AL	227
8a92ea2f	228
104bf02e MT	229	/* now calculate checksum of the table, complete with the header */
	230	/* we may as well leave checksum intact if has_header is true */
	231	/* alternatively there may be a way to set cksum to a given value */
	232	hdr.checksum = 0; /* for checksum calculation */
8a92ea2f	233
104bf02e MT	234	/* put header back */
	235	memcpy(f, &hdr, sizeof(hdr));
	236
	237	if (changed \|\| !has_header \|\| 1) {
	238	((struct acpi_table_header *)f)->checksum =
	239	acpi_checksum((uint8_t *)f + ACPI_TABLE_PFX_SIZE, len);
d729bb9a	240	}
8a92ea2f	241
8a92ea2f	242	/* increase number of tables */
104bf02e MT	243	((uint16_t )acpi_tables) =
	244	cpu_to_le32(le32_to_cpu((uint16_t )acpi_tables) + 1);
	245
	246	acpi_tables_len = allen;
8a92ea2f	247	return 0;
104bf02e	248
8a92ea2f	249	}
a54d41a8	250
04dc308f IY	251	/* ACPI PM1a EVT */
	252	uint16_t acpi_pm1_evt_get_sts(ACPIPM1EVT *pm1, int64_t overflow_time)
	253	{
	254	int64_t d = acpi_pm_tmr_get_clock();
	255	if (d >= overflow_time) {
	256	pm1->sts \|= ACPI_BITMASK_TIMER_STATUS;
	257	}
	258	return pm1->sts;
	259	}
	260
	261	void acpi_pm1_evt_write_sts(ACPIPM1EVT pm1, ACPIPMTimer tmr, uint16_t val)
	262	{
	263	uint16_t pm1_sts = acpi_pm1_evt_get_sts(pm1, tmr->overflow_time);
	264	if (pm1_sts & val & ACPI_BITMASK_TIMER_STATUS) {
	265	/* if TMRSTS is reset, then compute the new overflow time */
	266	acpi_pm_tmr_calc_overflow_time(tmr);
	267	}
	268	pm1->sts &= ~val;
	269	}
	270
	271	void acpi_pm1_evt_power_down(ACPIPM1EVT pm1, ACPIPMTimer tmr)
	272	{
	273	if (!pm1) {
	274	qemu_system_shutdown_request();
	275	} else if (pm1->en & ACPI_BITMASK_POWER_BUTTON_ENABLE) {
	276	pm1->sts \|= ACPI_BITMASK_POWER_BUTTON_STATUS;
	277	tmr->update_sci(tmr);
	278	}
	279	}
	280
	281	void acpi_pm1_evt_reset(ACPIPM1EVT *pm1)
	282	{
	283	pm1->sts = 0;
	284	pm1->en = 0;
	285	}
	286
a54d41a8 IY	287	/* ACPI PM_TMR */
	288	void acpi_pm_tmr_update(ACPIPMTimer *tmr, bool enable)
	289	{
	290	int64_t expire_time;
	291
	292	/* schedule a timer interruption if needed */
	293	if (enable) {
	294	expire_time = muldiv64(tmr->overflow_time, get_ticks_per_sec(),
	295	PM_TIMER_FREQUENCY);
	296	qemu_mod_timer(tmr->timer, expire_time);
	297	} else {
	298	qemu_del_timer(tmr->timer);
	299	}
	300	}
	301
	302	void acpi_pm_tmr_calc_overflow_time(ACPIPMTimer *tmr)
	303	{
	304	int64_t d = acpi_pm_tmr_get_clock();
	305	tmr->overflow_time = (d + 0x800000LL) & ~0x7fffffLL;
	306	}
	307
	308	uint32_t acpi_pm_tmr_get(ACPIPMTimer *tmr)
	309	{
3a93113a	310	uint32_t d = acpi_pm_tmr_get_clock();
a54d41a8 IY	311	return d & 0xffffff;
	312	}
	313
	314	static void acpi_pm_tmr_timer(void *opaque)
	315	{
	316	ACPIPMTimer *tmr = opaque;
	317	tmr->update_sci(tmr);
	318	}
	319
	320	void acpi_pm_tmr_init(ACPIPMTimer *tmr, acpi_update_sci_fn update_sci)
	321	{
	322	tmr->update_sci = update_sci;
	323	tmr->timer = qemu_new_timer_ns(vm_clock, acpi_pm_tmr_timer, tmr);
	324	}
	325
	326	void acpi_pm_tmr_reset(ACPIPMTimer *tmr)
	327	{
	328	tmr->overflow_time = 0;
	329	qemu_del_timer(tmr->timer);
	330	}
eaba51c5 IY	331
	332	/* ACPI PM1aCNT */
	333	void acpi_pm1_cnt_init(ACPIPM1CNT *pm1_cnt, qemu_irq cmos_s3)
	334	{
	335	pm1_cnt->cmos_s3 = cmos_s3;
	336	}
	337
	338	void acpi_pm1_cnt_write(ACPIPM1EVT pm1a, ACPIPM1CNT pm1_cnt, uint16_t val)
	339	{
	340	pm1_cnt->cnt = val & ~(ACPI_BITMASK_SLEEP_ENABLE);
	341
	342	if (val & ACPI_BITMASK_SLEEP_ENABLE) {
	343	/* change suspend type */
	344	uint16_t sus_typ = (val >> 10) & 7;
	345	switch(sus_typ) {
	346	case 0: /* soft power off */
	347	qemu_system_shutdown_request();
	348	break;
	349	case 1:
	350	/* ACPI_BITMASK_WAKE_STATUS should be set on resume.
	351	Pretend that resume was caused by power button */
	352	pm1a->sts \|=
	353	(ACPI_BITMASK_WAKE_STATUS \| ACPI_BITMASK_POWER_BUTTON_STATUS);
	354	qemu_system_reset_request();
	355	qemu_irq_raise(pm1_cnt->cmos_s3);
	356	default:
	357	break;
	358	}
	359	}
	360	}
	361
	362	void acpi_pm1_cnt_update(ACPIPM1CNT *pm1_cnt,
	363	bool sci_enable, bool sci_disable)
	364	{
	365	/* ACPI specs 3.0, 4.7.2.5 */
	366	if (sci_enable) {
	367	pm1_cnt->cnt \|= ACPI_BITMASK_SCI_ENABLE;
	368	} else if (sci_disable) {
	369	pm1_cnt->cnt &= ~ACPI_BITMASK_SCI_ENABLE;
	370	}
	371	}
	372
	373	void acpi_pm1_cnt_reset(ACPIPM1CNT *pm1_cnt)
	374	{
	375	pm1_cnt->cnt = 0;
	376	if (pm1_cnt->cmos_s3) {
	377	qemu_irq_lower(pm1_cnt->cmos_s3);
	378	}
	379	}
23910d3f IY	380
	381	/* ACPI GPE */
	382	void acpi_gpe_init(ACPIGPE *gpe, uint8_t len)
	383	{
	384	gpe->len = len;
7267c094 AL	385	gpe->sts = g_malloc0(len / 2);
7267c094 AL	386	gpe->en = g_malloc0(len / 2);
23910d3f IY	387	}
	388
	389	void acpi_gpe_blk(ACPIGPE *gpe, uint32_t blk)
	390	{
	391	gpe->blk = blk;
	392	}
	393
	394	void acpi_gpe_reset(ACPIGPE *gpe)
	395	{
	396	memset(gpe->sts, 0, gpe->len / 2);
	397	memset(gpe->en, 0, gpe->len / 2);
	398	}
	399
	400	static uint8_t acpi_gpe_ioport_get_ptr(ACPIGPE gpe, uint32_t addr)
	401	{
	402	uint8_t *cur = NULL;
	403
	404	if (addr < gpe->len / 2) {
	405	cur = gpe->sts + addr;
	406	} else if (addr < gpe->len) {
54f8e61d	407	cur = gpe->en + addr - gpe->len / 2;
23910d3f IY	408	} else {
	409	abort();
	410	}
	411
	412	return cur;
	413	}
	414
	415	void acpi_gpe_ioport_writeb(ACPIGPE *gpe, uint32_t addr, uint32_t val)
	416	{
	417	uint8_t *cur;
	418
	419	addr -= gpe->blk;
	420	cur = acpi_gpe_ioport_get_ptr(gpe, addr);
	421	if (addr < gpe->len / 2) {
	422	/* GPE_STS */
	423	cur = (cur) & ~val;
	424	} else if (addr < gpe->len) {
	425	/* GPE_EN */
	426	*cur = val;
	427	} else {
	428	abort();
	429	}
	430	}
	431
	432	uint32_t acpi_gpe_ioport_readb(ACPIGPE *gpe, uint32_t addr)
	433	{
	434	uint8_t *cur;
	435	uint32_t val;
	436
	437	addr -= gpe->blk;
	438	cur = acpi_gpe_ioport_get_ptr(gpe, addr);
	439	val = 0;
	440	if (cur != NULL) {
	441	val = *cur;
	442	}
	443
	444	return val;
	445	}