[mirror_qemu.git] / tests / acpi-test.c

/*
 * Boot order test cases.
 *
 * Copyright (c) 2013 Red Hat Inc.
 *
 * Authors:
 *  Michael S. Tsirkin <mst@redhat.com>,
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 */

#include <string.h>
#include <stdio.h>
#include <glib.h>
#include "qemu-common.h"
#include "libqtest.h"
#include "qemu/compiler.h"
#include "hw/i386/acpi-defs.h"

/* DSDT and SSDTs format */
typedef struct {
    AcpiTableHeader header;
    uint8_t *aml;
    int aml_len;
} AcpiSdtTable;

typedef struct {
    uint32_t rsdp_addr;
    AcpiRsdpDescriptor rsdp_table;
    AcpiRsdtDescriptorRev1 rsdt_table;
    AcpiFadtDescriptorRev1 fadt_table;
    uint32_t *rsdt_tables_addr;
    int rsdt_tables_nr;
    AcpiSdtTable dsdt_table;
    AcpiSdtTable *ssdt_tables;
} test_data;

#define LOW(x) ((x) & 0xff)
#define HIGH(x) ((x) >> 8)

#define SIGNATURE 0xdead
#define SIGNATURE_OFFSET 0x10
#define BOOT_SECTOR_ADDRESS 0x7c00

#define ACPI_READ_FIELD(field, addr)           \
    do {                                       \
        switch (sizeof(field)) {               \
        case 1:                                \
            field = readb(addr);               \
            break;                             \
        case 2:                                \
            field = le16_to_cpu(readw(addr));  \
            break;                             \
        case 4:                                \
            field = le32_to_cpu(readl(addr));  \
            break;                             \
        case 8:                                \
            field = le64_to_cpu(readq(addr));  \
            break;                             \
        default:                               \
            g_assert(false);                   \
        }                                      \
        addr += sizeof(field);                  \
    } while (0);

#define ACPI_READ_ARRAY_PTR(arr, length, addr)  \
    do {                                        \
        int idx;                                \
        for (idx = 0; idx < length; ++idx) {    \
            ACPI_READ_FIELD(arr[idx], addr);    \
        }                                       \
    } while (0);

#define ACPI_READ_ARRAY(arr, addr)                               \
    ACPI_READ_ARRAY_PTR(arr, sizeof(arr)/sizeof(arr[0]), addr)

#define ACPI_READ_TABLE_HEADER(table, addr)                      \
    do {                                                         \
        ACPI_READ_FIELD((table)->signature, addr);               \
        ACPI_READ_FIELD((table)->length, addr);                  \
        ACPI_READ_FIELD((table)->revision, addr);                \
        ACPI_READ_FIELD((table)->checksum, addr);                \
        ACPI_READ_ARRAY((table)->oem_id, addr);                  \
        ACPI_READ_ARRAY((table)->oem_table_id, addr);            \
        ACPI_READ_FIELD((table)->oem_revision, addr);            \
        ACPI_READ_ARRAY((table)->asl_compiler_id, addr);         \
        ACPI_READ_FIELD((table)->asl_compiler_revision, addr);   \
    } while (0);

/* Boot sector code: write SIGNATURE into memory,
 * then halt.
 */
static uint8_t boot_sector[0x200] = {
    /* 7c00: mov $0xdead,%ax */
    [0x00] = 0xb8,
    [0x01] = LOW(SIGNATURE),
    [0x02] = HIGH(SIGNATURE),
    /* 7c03:  mov %ax,0x7c10 */
    [0x03] = 0xa3,
    [0x04] = LOW(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET),
    [0x05] = HIGH(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET),
    /* 7c06: cli */
    [0x06] = 0xfa,
    /* 7c07: hlt */
    [0x07] = 0xf4,
    /* 7c08: jmp 0x7c07=0x7c0a-3 */
    [0x08] = 0xeb,
    [0x09] = LOW(-3),
    /* We mov 0xdead here: set value to make debugging easier */
    [SIGNATURE_OFFSET] = LOW(0xface),
    [SIGNATURE_OFFSET + 1] = HIGH(0xface),
    /* End of boot sector marker */
    [0x1FE] = 0x55,
    [0x1FF] = 0xAA,
};

static const char *disk = "tests/acpi-test-disk.raw";

static uint8_t acpi_checksum(const uint8_t *data, int len)
{
    int i;
    uint8_t sum = 0;

    for (i = 0; i < len; i++) {
        sum += data[i];
    }

    return sum;
}

static void test_acpi_rsdp_address(test_data *data)
{
    uint32_t off;

    /* OK, now find RSDP */
    for (off = 0xf0000; off < 0x100000; off += 0x10) {
        uint8_t sig[] = "RSD PTR ";
        int i;

        for (i = 0; i < sizeof sig - 1; ++i) {
            sig[i] = readb(off + i);
        }

        if (!memcmp(sig, "RSD PTR ", sizeof sig)) {
            break;
        }
    }

    g_assert_cmphex(off, <, 0x100000);
    data->rsdp_addr = off;
}

static void test_acpi_rsdp_table(test_data *data)
{
    AcpiRsdpDescriptor *rsdp_table = &data->rsdp_table;
    uint32_t addr = data->rsdp_addr;

    ACPI_READ_FIELD(rsdp_table->signature, addr);
    g_assert_cmphex(rsdp_table->signature, ==, ACPI_RSDP_SIGNATURE);

    ACPI_READ_FIELD(rsdp_table->checksum, addr);
    ACPI_READ_ARRAY(rsdp_table->oem_id, addr);
    ACPI_READ_FIELD(rsdp_table->revision, addr);
    ACPI_READ_FIELD(rsdp_table->rsdt_physical_address, addr);
    ACPI_READ_FIELD(rsdp_table->length, addr);

    /* rsdp checksum is not for the whole table, but for the first 20 bytes */
    g_assert(!acpi_checksum((uint8_t *)rsdp_table, 20));
}

static void test_acpi_rsdt_table(test_data *data)
{
    AcpiRsdtDescriptorRev1 *rsdt_table = &data->rsdt_table;
    uint32_t addr = data->rsdp_table.rsdt_physical_address;
    uint32_t *tables;
    int tables_nr;
    uint8_t checksum;

    /* read the header */
    ACPI_READ_TABLE_HEADER(rsdt_table, addr);
    g_assert_cmphex(rsdt_table->signature, ==, ACPI_RSDT_SIGNATURE);

    /* compute the table entries in rsdt */
    tables_nr = (rsdt_table->length - sizeof(AcpiRsdtDescriptorRev1)) /
                sizeof(uint32_t);
    g_assert_cmpint(tables_nr, >, 0);

    /* get the addresses of the tables pointed by rsdt */
    tables = g_new0(uint32_t, tables_nr);
    ACPI_READ_ARRAY_PTR(tables, tables_nr, addr);

    checksum = acpi_checksum((uint8_t *)rsdt_table, rsdt_table->length) +
               acpi_checksum((uint8_t *)tables, tables_nr * sizeof(uint32_t));
    g_assert(!checksum);

   /* SSDT tables after FADT */
    data->rsdt_tables_addr = tables;
    data->rsdt_tables_nr = tables_nr;
}

static void test_acpi_fadt_table(test_data *data)
{
    AcpiFadtDescriptorRev1 *fadt_table = &data->fadt_table;
    uint32_t addr;

    /* FADT table comes first */
    addr = data->rsdt_tables_addr[0];
    ACPI_READ_TABLE_HEADER(fadt_table, addr);

    ACPI_READ_FIELD(fadt_table->firmware_ctrl, addr);
    ACPI_READ_FIELD(fadt_table->dsdt, addr);
    ACPI_READ_FIELD(fadt_table->model, addr);
    ACPI_READ_FIELD(fadt_table->reserved1, addr);
    ACPI_READ_FIELD(fadt_table->sci_int, addr);
    ACPI_READ_FIELD(fadt_table->smi_cmd, addr);
    ACPI_READ_FIELD(fadt_table->acpi_enable, addr);
    ACPI_READ_FIELD(fadt_table->acpi_disable, addr);
    ACPI_READ_FIELD(fadt_table->S4bios_req, addr);
    ACPI_READ_FIELD(fadt_table->reserved2, addr);
    ACPI_READ_FIELD(fadt_table->pm1a_evt_blk, addr);
    ACPI_READ_FIELD(fadt_table->pm1b_evt_blk, addr);
    ACPI_READ_FIELD(fadt_table->pm1a_cnt_blk, addr);
    ACPI_READ_FIELD(fadt_table->pm1b_cnt_blk, addr);
    ACPI_READ_FIELD(fadt_table->pm2_cnt_blk, addr);
    ACPI_READ_FIELD(fadt_table->pm_tmr_blk, addr);
    ACPI_READ_FIELD(fadt_table->gpe0_blk, addr);
    ACPI_READ_FIELD(fadt_table->gpe1_blk, addr);
    ACPI_READ_FIELD(fadt_table->pm1_evt_len, addr);
    ACPI_READ_FIELD(fadt_table->pm1_cnt_len, addr);
    ACPI_READ_FIELD(fadt_table->pm2_cnt_len, addr);
    ACPI_READ_FIELD(fadt_table->pm_tmr_len, addr);
    ACPI_READ_FIELD(fadt_table->gpe0_blk_len, addr);
    ACPI_READ_FIELD(fadt_table->gpe1_blk_len, addr);
    ACPI_READ_FIELD(fadt_table->gpe1_base, addr);
    ACPI_READ_FIELD(fadt_table->reserved3, addr);
    ACPI_READ_FIELD(fadt_table->plvl2_lat, addr);
    ACPI_READ_FIELD(fadt_table->plvl3_lat, addr);
    ACPI_READ_FIELD(fadt_table->flush_size, addr);
    ACPI_READ_FIELD(fadt_table->flush_stride, addr);
    ACPI_READ_FIELD(fadt_table->duty_offset, addr);
    ACPI_READ_FIELD(fadt_table->duty_width, addr);
    ACPI_READ_FIELD(fadt_table->day_alrm, addr);
    ACPI_READ_FIELD(fadt_table->mon_alrm, addr);
    ACPI_READ_FIELD(fadt_table->century, addr);
    ACPI_READ_FIELD(fadt_table->reserved4, addr);
    ACPI_READ_FIELD(fadt_table->reserved4a, addr);
    ACPI_READ_FIELD(fadt_table->reserved4b, addr);
    ACPI_READ_FIELD(fadt_table->flags, addr);

    g_assert_cmphex(fadt_table->signature, ==, ACPI_FACP_SIGNATURE);
    g_assert(!acpi_checksum((uint8_t *)fadt_table, fadt_table->length));
}

static void test_dst_table(AcpiSdtTable *sdt_table, uint32_t addr)
{
    uint8_t checksum;

    ACPI_READ_TABLE_HEADER(&sdt_table->header, addr);

    sdt_table->aml_len = sdt_table->header.length - sizeof(AcpiTableHeader);
    sdt_table->aml = g_malloc0(sdt_table->aml_len);
    ACPI_READ_ARRAY_PTR(sdt_table->aml, sdt_table->aml_len, addr);

    checksum = acpi_checksum((uint8_t *)sdt_table, sizeof(AcpiTableHeader)) +
               acpi_checksum(sdt_table->aml, sdt_table->aml_len);
    g_assert(!checksum);
}

static void test_acpi_dsdt_table(test_data *data)
{
    AcpiSdtTable *dsdt_table = &data->dsdt_table;
    uint32_t addr = data->fadt_table.dsdt;

    test_dst_table(dsdt_table, addr);
    g_assert_cmphex(dsdt_table->header.signature, ==, ACPI_DSDT_SIGNATURE);
}

static void test_acpi_ssdt_tables(test_data *data)
{
    AcpiSdtTable *ssdt_tables;
    int ssdt_tables_nr = data->rsdt_tables_nr - 1; /* fadt is first */
    int i;

    ssdt_tables = g_new0(AcpiSdtTable, ssdt_tables_nr);
    for (i = 0; i < ssdt_tables_nr; i++) {
        AcpiSdtTable *ssdt_table = &ssdt_tables[i];
        uint32_t addr = data->rsdt_tables_addr[i + 1]; /* fadt is first */

        test_dst_table(ssdt_table, addr);
    }
    data->ssdt_tables = ssdt_tables;
}

static void test_acpi_one(const char *params)
{
    char *args;
    uint8_t signature_low;
    uint8_t signature_high;
    uint16_t signature;
    int i;
    test_data data;

    memset(&data, 0, sizeof(data));
    args = g_strdup_printf("-net none -display none %s %s",
                           params ? params : "", disk);
    qtest_start(args);

   /* Wait at most 1 minute */
#define TEST_DELAY (1 * G_USEC_PER_SEC / 10)
#define TEST_CYCLES MAX((60 * G_USEC_PER_SEC / TEST_DELAY), 1)

    /* Poll until code has run and modified memory.  Once it has we know BIOS
     * initialization is done.  TODO: check that IP reached the halt
     * instruction.
     */
    for (i = 0; i < TEST_CYCLES; ++i) {
        signature_low = readb(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET);
        signature_high = readb(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET + 1);
        signature = (signature_high << 8) | signature_low;
        if (signature == SIGNATURE) {
            break;
        }
        g_usleep(TEST_DELAY);
    }
    g_assert_cmphex(signature, ==, SIGNATURE);

    test_acpi_rsdp_address(&data);
    test_acpi_rsdp_table(&data);
    test_acpi_rsdt_table(&data);
    test_acpi_fadt_table(&data);
    test_acpi_dsdt_table(&data);
    test_acpi_ssdt_tables(&data);

    g_free(data.rsdt_tables_addr);
    for (i = 0; i < (data.rsdt_tables_nr - 1); ++i) {
        g_free(data.ssdt_tables[i].aml);
    }
    g_free(data.ssdt_tables);
    g_free(data.dsdt_table.aml);

    qtest_quit(global_qtest);
    g_free(args);
}

static void test_acpi_tcg(void)
{
    /* Supplying -machine accel argument overrides the default (qtest).
     * This is to make guest actually run.
     */
    test_acpi_one("-machine accel=tcg");
}

int main(int argc, char *argv[])
{
    const char *arch = qtest_get_arch();
    FILE *f = fopen(disk, "w");
    fwrite(boot_sector, 1, sizeof boot_sector, f);
    fclose(f);

    g_test_init(&argc, &argv, NULL);

    if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
        qtest_add_func("acpi/tcg", test_acpi_tcg);
    }
    return g_test_run();
}
Commit	Line	Data
ad6423a7 MT	1	/*
	2	* Boot order test cases.
	3	*
	4	* Copyright (c) 2013 Red Hat Inc.
	5	*
	6	* Authors:
	7	* Michael S. Tsirkin <mst@redhat.com>,
	8	*
	9	* This work is licensed under the terms of the GNU GPL, version 2 or later.
	10	* See the COPYING file in the top-level directory.
	11	*/
	12
	13	#include <string.h>
	14	#include <stdio.h>
	15	#include <glib.h>
53333801	16	#include "qemu-common.h"
ad6423a7	17	#include "libqtest.h"
53333801 MA	18	#include "qemu/compiler.h"
53333801 MA	19	#include "hw/i386/acpi-defs.h"
ad6423a7	20
53333801	21	/* DSDT and SSDTs format */
ad6423a7	22	typedef struct {
53333801 MA	23	AcpiTableHeader header;
	24	uint8_t *aml;
	25	int aml_len;
	26	} AcpiSdtTable;
	27
	28	typedef struct {
	29	uint32_t rsdp_addr;
	30	AcpiRsdpDescriptor rsdp_table;
	31	AcpiRsdtDescriptorRev1 rsdt_table;
	32	AcpiFadtDescriptorRev1 fadt_table;
	33	uint32_t *rsdt_tables_addr;
	34	int rsdt_tables_nr;
	35	AcpiSdtTable dsdt_table;
	36	AcpiSdtTable *ssdt_tables;
	37	} test_data;
ad6423a7 MT	38
	39	#define LOW(x) ((x) & 0xff)
	40	#define HIGH(x) ((x) >> 8)
	41
	42	#define SIGNATURE 0xdead
	43	#define SIGNATURE_OFFSET 0x10
	44	#define BOOT_SECTOR_ADDRESS 0x7c00
	45
53333801 MA	46	#define ACPI_READ_FIELD(field, addr) \
	47	do { \
	48	switch (sizeof(field)) { \
	49	case 1: \
	50	field = readb(addr); \
	51	break; \
	52	case 2: \
	53	field = le16_to_cpu(readw(addr)); \
	54	break; \
	55	case 4: \
	56	field = le32_to_cpu(readl(addr)); \
	57	break; \
	58	case 8: \
	59	field = le64_to_cpu(readq(addr)); \
	60	break; \
	61	default: \
	62	g_assert(false); \
	63	} \
	64	addr += sizeof(field); \
	65	} while (0);
	66
	67	#define ACPI_READ_ARRAY_PTR(arr, length, addr) \
	68	do { \
	69	int idx; \
	70	for (idx = 0; idx < length; ++idx) { \
	71	ACPI_READ_FIELD(arr[idx], addr); \
	72	} \
	73	} while (0);
	74
	75	#define ACPI_READ_ARRAY(arr, addr) \
	76	ACPI_READ_ARRAY_PTR(arr, sizeof(arr)/sizeof(arr[0]), addr)
	77
	78	#define ACPI_READ_TABLE_HEADER(table, addr) \
	79	do { \
	80	ACPI_READ_FIELD((table)->signature, addr); \
	81	ACPI_READ_FIELD((table)->length, addr); \
	82	ACPI_READ_FIELD((table)->revision, addr); \
	83	ACPI_READ_FIELD((table)->checksum, addr); \
	84	ACPI_READ_ARRAY((table)->oem_id, addr); \
	85	ACPI_READ_ARRAY((table)->oem_table_id, addr); \
	86	ACPI_READ_FIELD((table)->oem_revision, addr); \
	87	ACPI_READ_ARRAY((table)->asl_compiler_id, addr); \
	88	ACPI_READ_FIELD((table)->asl_compiler_revision, addr); \
	89	} while (0);
	90
ad6423a7 MT	91	/* Boot sector code: write SIGNATURE into memory,
	92	* then halt.
	93	*/
	94	static uint8_t boot_sector[0x200] = {
	95	/* 7c00: mov $0xdead,%ax */
	96	[0x00] = 0xb8,
	97	[0x01] = LOW(SIGNATURE),
	98	[0x02] = HIGH(SIGNATURE),
	99	/* 7c03: mov %ax,0x7c10 */
	100	[0x03] = 0xa3,
	101	[0x04] = LOW(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET),
	102	[0x05] = HIGH(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET),
	103	/* 7c06: cli */
	104	[0x06] = 0xfa,
	105	/* 7c07: hlt */
	106	[0x07] = 0xf4,
	107	/* 7c08: jmp 0x7c07=0x7c0a-3 */
	108	[0x08] = 0xeb,
	109	[0x09] = LOW(-3),
	110	/* We mov 0xdead here: set value to make debugging easier */
	111	[SIGNATURE_OFFSET] = LOW(0xface),
	112	[SIGNATURE_OFFSET + 1] = HIGH(0xface),
	113	/* End of boot sector marker */
	114	[0x1FE] = 0x55,
	115	[0x1FF] = 0xAA,
	116	};
	117
	118	static const char *disk = "tests/acpi-test-disk.raw";
	119
53333801 MA	120	static uint8_t acpi_checksum(const uint8_t *data, int len)
	121	{
	122	int i;
	123	uint8_t sum = 0;
	124
	125	for (i = 0; i < len; i++) {
	126	sum += data[i];
	127	}
	128
	129	return sum;
	130	}
	131
	132	static void test_acpi_rsdp_address(test_data *data)
	133	{
	134	uint32_t off;
	135
	136	/* OK, now find RSDP */
	137	for (off = 0xf0000; off < 0x100000; off += 0x10) {
	138	uint8_t sig[] = "RSD PTR ";
	139	int i;
	140
	141	for (i = 0; i < sizeof sig - 1; ++i) {
	142	sig[i] = readb(off + i);
	143	}
	144
	145	if (!memcmp(sig, "RSD PTR ", sizeof sig)) {
	146	break;
	147	}
	148	}
	149
	150	g_assert_cmphex(off, <, 0x100000);
	151	data->rsdp_addr = off;
	152	}
	153
	154	static void test_acpi_rsdp_table(test_data *data)
	155	{
	156	AcpiRsdpDescriptor *rsdp_table = &data->rsdp_table;
	157	uint32_t addr = data->rsdp_addr;
	158
	159	ACPI_READ_FIELD(rsdp_table->signature, addr);
	160	g_assert_cmphex(rsdp_table->signature, ==, ACPI_RSDP_SIGNATURE);
	161
	162	ACPI_READ_FIELD(rsdp_table->checksum, addr);
	163	ACPI_READ_ARRAY(rsdp_table->oem_id, addr);
	164	ACPI_READ_FIELD(rsdp_table->revision, addr);
	165	ACPI_READ_FIELD(rsdp_table->rsdt_physical_address, addr);
	166	ACPI_READ_FIELD(rsdp_table->length, addr);
	167
	168	/* rsdp checksum is not for the whole table, but for the first 20 bytes */
	169	g_assert(!acpi_checksum((uint8_t *)rsdp_table, 20));
	170	}
	171
	172	static void test_acpi_rsdt_table(test_data *data)
	173	{
	174	AcpiRsdtDescriptorRev1 *rsdt_table = &data->rsdt_table;
	175	uint32_t addr = data->rsdp_table.rsdt_physical_address;
	176	uint32_t *tables;
	177	int tables_nr;
	178	uint8_t checksum;
	179
	180	/* read the header */
	181	ACPI_READ_TABLE_HEADER(rsdt_table, addr);
	182	g_assert_cmphex(rsdt_table->signature, ==, ACPI_RSDT_SIGNATURE);
	183
184	/* compute the table entries in rsdt */
185	tables_nr = (rsdt_table->length - sizeof(AcpiRsdtDescriptorRev1)) /
186	sizeof(uint32_t);
187	g_assert_cmpint(tables_nr, >, 0);
188
189	/* get the addresses of the tables pointed by rsdt */
190	tables = g_new0(uint32_t, tables_nr);
191	ACPI_READ_ARRAY_PTR(tables, tables_nr, addr);
192
193	checksum = acpi_checksum((uint8_t *)rsdt_table, rsdt_table->length) +
194	acpi_checksum((uint8_t )tables, tables_nr sizeof(uint32_t));
195	g_assert(!checksum);
196
197	/* SSDT tables after FADT */
198	data->rsdt_tables_addr = tables;
199	data->rsdt_tables_nr = tables_nr;
200	}
201
202	static void test_acpi_fadt_table(test_data *data)
203	{
204	AcpiFadtDescriptorRev1 *fadt_table = &data->fadt_table;
205	uint32_t addr;
206
207	/* FADT table comes first */
208	addr = data->rsdt_tables_addr[0];
209	ACPI_READ_TABLE_HEADER(fadt_table, addr);
210
211	ACPI_READ_FIELD(fadt_table->firmware_ctrl, addr);
212	ACPI_READ_FIELD(fadt_table->dsdt, addr);
213	ACPI_READ_FIELD(fadt_table->model, addr);
214	ACPI_READ_FIELD(fadt_table->reserved1, addr);
215	ACPI_READ_FIELD(fadt_table->sci_int, addr);
216	ACPI_READ_FIELD(fadt_table->smi_cmd, addr);
217	ACPI_READ_FIELD(fadt_table->acpi_enable, addr);
218	ACPI_READ_FIELD(fadt_table->acpi_disable, addr);
219	ACPI_READ_FIELD(fadt_table->S4bios_req, addr);
220	ACPI_READ_FIELD(fadt_table->reserved2, addr);
221	ACPI_READ_FIELD(fadt_table->pm1a_evt_blk, addr);
222	ACPI_READ_FIELD(fadt_table->pm1b_evt_blk, addr);
223	ACPI_READ_FIELD(fadt_table->pm1a_cnt_blk, addr);
224	ACPI_READ_FIELD(fadt_table->pm1b_cnt_blk, addr);
225	ACPI_READ_FIELD(fadt_table->pm2_cnt_blk, addr);
226	ACPI_READ_FIELD(fadt_table->pm_tmr_blk, addr);
227	ACPI_READ_FIELD(fadt_table->gpe0_blk, addr);
228	ACPI_READ_FIELD(fadt_table->gpe1_blk, addr);
229	ACPI_READ_FIELD(fadt_table->pm1_evt_len, addr);
230	ACPI_READ_FIELD(fadt_table->pm1_cnt_len, addr);
231	ACPI_READ_FIELD(fadt_table->pm2_cnt_len, addr);
232	ACPI_READ_FIELD(fadt_table->pm_tmr_len, addr);
233	ACPI_READ_FIELD(fadt_table->gpe0_blk_len, addr);
234	ACPI_READ_FIELD(fadt_table->gpe1_blk_len, addr);
235	ACPI_READ_FIELD(fadt_table->gpe1_base, addr);
236	ACPI_READ_FIELD(fadt_table->reserved3, addr);
237	ACPI_READ_FIELD(fadt_table->plvl2_lat, addr);
238	ACPI_READ_FIELD(fadt_table->plvl3_lat, addr);
239	ACPI_READ_FIELD(fadt_table->flush_size, addr);
240	ACPI_READ_FIELD(fadt_table->flush_stride, addr);
241	ACPI_READ_FIELD(fadt_table->duty_offset, addr);
242	ACPI_READ_FIELD(fadt_table->duty_width, addr);
243	ACPI_READ_FIELD(fadt_table->day_alrm, addr);
244	ACPI_READ_FIELD(fadt_table->mon_alrm, addr);
245	ACPI_READ_FIELD(fadt_table->century, addr);
246	ACPI_READ_FIELD(fadt_table->reserved4, addr);
247	ACPI_READ_FIELD(fadt_table->reserved4a, addr);
248	ACPI_READ_FIELD(fadt_table->reserved4b, addr);
249	ACPI_READ_FIELD(fadt_table->flags, addr);
250
251	g_assert_cmphex(fadt_table->signature, ==, ACPI_FACP_SIGNATURE);
252	g_assert(!acpi_checksum((uint8_t *)fadt_table, fadt_table->length));
253	}
254
255	static void test_dst_table(AcpiSdtTable *sdt_table, uint32_t addr)
256	{
257	uint8_t checksum;
258
259	ACPI_READ_TABLE_HEADER(&sdt_table->header, addr);
260
261	sdt_table->aml_len = sdt_table->header.length - sizeof(AcpiTableHeader);
262	sdt_table->aml = g_malloc0(sdt_table->aml_len);
263	ACPI_READ_ARRAY_PTR(sdt_table->aml, sdt_table->aml_len, addr);
264
265	checksum = acpi_checksum((uint8_t *)sdt_table, sizeof(AcpiTableHeader)) +
266	acpi_checksum(sdt_table->aml, sdt_table->aml_len);
267	g_assert(!checksum);
268	}
269
270	static void test_acpi_dsdt_table(test_data *data)
271	{
272	AcpiSdtTable *dsdt_table = &data->dsdt_table;
273	uint32_t addr = data->fadt_table.dsdt;
274
275	test_dst_table(dsdt_table, addr);
276	g_assert_cmphex(dsdt_table->header.signature, ==, ACPI_DSDT_SIGNATURE);
277	}
278
279	static void test_acpi_ssdt_tables(test_data *data)
280	{
281	AcpiSdtTable *ssdt_tables;
282	int ssdt_tables_nr = data->rsdt_tables_nr - 1; /* fadt is first */
283	int i;
284
285	ssdt_tables = g_new0(AcpiSdtTable, ssdt_tables_nr);
286	for (i = 0; i < ssdt_tables_nr; i++) {
287	AcpiSdtTable *ssdt_table = &ssdt_tables[i];
288	uint32_t addr = data->rsdt_tables_addr[i + 1]; /* fadt is first */
289
290	test_dst_table(ssdt_table, addr);
291	}
292	data->ssdt_tables = ssdt_tables;
293	}
294
ad6423a7 MT	295	static void test_acpi_one(const char *params)
	296	{
	297	char *args;
	298	uint8_t signature_low;
	299	uint8_t signature_high;
	300	uint16_t signature;
	301	int i;
53333801	302	test_data data;
ad6423a7	303
53333801	304	memset(&data, 0, sizeof(data));
ad6423a7 MT	305	args = g_strdup_printf("-net none -display none %s %s",
	306	params ? params : "", disk);
	307	qtest_start(args);
	308
	309	/* Wait at most 1 minute */
	310	#define TEST_DELAY (1 * G_USEC_PER_SEC / 10)
	311	#define TEST_CYCLES MAX((60 * G_USEC_PER_SEC / TEST_DELAY), 1)
	312
	313	/* Poll until code has run and modified memory. Once it has we know BIOS
	314	* initialization is done. TODO: check that IP reached the halt
	315	* instruction.
	316	*/
	317	for (i = 0; i < TEST_CYCLES; ++i) {
	318	signature_low = readb(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET);
	319	signature_high = readb(BOOT_SECTOR_ADDRESS + SIGNATURE_OFFSET + 1);
	320	signature = (signature_high << 8) \| signature_low;
	321	if (signature == SIGNATURE) {
	322	break;
	323	}
	324	g_usleep(TEST_DELAY);
	325	}
	326	g_assert_cmphex(signature, ==, SIGNATURE);
	327
53333801 MA	328	test_acpi_rsdp_address(&data);
	329	test_acpi_rsdp_table(&data);
	330	test_acpi_rsdt_table(&data);
	331	test_acpi_fadt_table(&data);
	332	test_acpi_dsdt_table(&data);
	333	test_acpi_ssdt_tables(&data);
ad6423a7	334
53333801 MA	335	g_free(data.rsdt_tables_addr);
	336	for (i = 0; i < (data.rsdt_tables_nr - 1); ++i) {
	337	g_free(data.ssdt_tables[i].aml);
ad6423a7	338	}
53333801 MA	339	g_free(data.ssdt_tables);
53333801 MA	340	g_free(data.dsdt_table.aml);
ad6423a7 MT	341
	342	qtest_quit(global_qtest);
	343	g_free(args);
	344	}
	345
	346	static void test_acpi_tcg(void)
	347	{
	348	/* Supplying -machine accel argument overrides the default (qtest).
	349	* This is to make guest actually run.
	350	*/
	351	test_acpi_one("-machine accel=tcg");
	352	}
	353
	354	int main(int argc, char *argv[])
	355	{
	356	const char *arch = qtest_get_arch();
	357	FILE *f = fopen(disk, "w");
	358	fwrite(boot_sector, 1, sizeof boot_sector, f);
	359	fclose(f);
	360
	361	g_test_init(&argc, &argv, NULL);
	362
	363	if (strcmp(arch, "i386") == 0 \|\| strcmp(arch, "x86_64") == 0) {
	364	qtest_add_func("acpi/tcg", test_acpi_tcg);
	365	}
	366	return g_test_run();
	367	}