[mirror_qemu.git] / tests / qtest / tpm-tis-util.c

/*
 * QTest testcase for TPM TIS: common test functions used for both
 * the ISA and SYSBUS devices
 *
 * Copyright (c) 2018 Red Hat, Inc.
 * Copyright (c) 2018 IBM Corporation
 *
 * Authors:
 *   Marc-André Lureau <marcandre.lureau@redhat.com>
 *   Stefan Berger <stefanb@linux.vnet.ibm.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 "qemu/osdep.h"
#include <glib/gstdio.h>

#include "hw/acpi/tpm.h"
#include "io/channel-socket.h"
#include "libqtest-single.h"
#include "qemu/module.h"
#include "tpm-emu.h"
#include "tpm-util.h"
#include "tpm-tis-util.h"

#define DEBUG_TIS_TEST 0

#define DPRINTF(fmt, ...) do { \
    if (DEBUG_TIS_TEST) { \
        printf(fmt, ## __VA_ARGS__); \
    } \
} while (0)

#define DPRINTF_ACCESS \
    DPRINTF("%s: %d: locty=%d l=%d access=0x%02x pending_request_flag=0x%x\n", \
            __func__, __LINE__, locty, l, access, pending_request_flag)

#define DPRINTF_STS \
    DPRINTF("%s: %d: sts = 0x%08x\n", __func__, __LINE__, sts)

static const uint8_t TPM_CMD[12] =
    "\x80\x01\x00\x00\x00\x0c\x00\x00\x01\x44\x00\x00";

void tpm_tis_test_check_localities(const void *data)
{
    uint8_t locty;
    uint8_t access;
    uint32_t ifaceid;
    uint32_t capability;
    uint32_t didvid;
    uint32_t rid;

    for (locty = 0; locty < TPM_TIS_NUM_LOCALITIES; locty++) {
        access = readb(TIS_REG(0, TPM_TIS_REG_ACCESS));
        g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                    TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

        capability = readl(TIS_REG(locty, TPM_TIS_REG_INTF_CAPABILITY));
        g_assert_cmpint(capability, ==, TPM_TIS_CAPABILITIES_SUPPORTED2_0);

        ifaceid = readl(TIS_REG(locty, TPM_TIS_REG_INTERFACE_ID));
        g_assert_cmpint(ifaceid, ==, TPM_TIS_IFACE_ID_SUPPORTED_FLAGS2_0);

        didvid = readl(TIS_REG(locty, TPM_TIS_REG_DID_VID));
        g_assert_cmpint(didvid, !=, 0);
        g_assert_cmpint(didvid, !=, 0xffffffff);

        rid = readl(TIS_REG(locty, TPM_TIS_REG_RID));
        g_assert_cmpint(rid, !=, 0);
        g_assert_cmpint(rid, !=, 0xffffffff);
    }
}

void tpm_tis_test_check_access_reg(const void *data)
{
    uint8_t locty;
    uint8_t access;

    /* do not test locality 4 (hw only) */
    for (locty = 0; locty < TPM_TIS_NUM_LOCALITIES - 1; locty++) {
        access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
        g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                    TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

        /* request use of locality */
        writeb(TIS_REG(locty, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE);

        access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
        g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                    TPM_TIS_ACCESS_ACTIVE_LOCALITY |
                                    TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

        /* release access */
        writeb(TIS_REG(locty, TPM_TIS_REG_ACCESS),
               TPM_TIS_ACCESS_ACTIVE_LOCALITY);
        access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
        g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                    TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
    }
}

/*
 * Test case for seizing access by a higher number locality
 */
void tpm_tis_test_check_access_reg_seize(const void *data)
{
    int locty, l;
    uint8_t access;
    uint8_t pending_request_flag;

    /* do not test locality 4 (hw only) */
    for (locty = 0; locty < TPM_TIS_NUM_LOCALITIES - 1; locty++) {
        pending_request_flag = 0;

        access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
        g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                    TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

        /* request use of locality */
        writeb(TIS_REG(locty, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE);
        access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
        g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                    TPM_TIS_ACCESS_ACTIVE_LOCALITY |
                                    TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

        /* lower localities cannot seize access */
        for (l = 0; l < locty; l++) {
            /* lower locality is not active */
            access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
            DPRINTF_ACCESS;
            g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                        pending_request_flag |
                                        TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

            /* try to request use from 'l' */
            writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE);

            /*
             * requesting use from 'l' was not possible;
             * we must see REQUEST_USE and possibly PENDING_REQUEST
             */
            access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
            DPRINTF_ACCESS;
            g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                        TPM_TIS_ACCESS_REQUEST_USE |
                                        pending_request_flag |
                                        TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

            /*
             * locality 'locty' must be unchanged;
             * we must see PENDING_REQUEST
             */
            access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
            g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                        TPM_TIS_ACCESS_ACTIVE_LOCALITY |
                                        TPM_TIS_ACCESS_PENDING_REQUEST |
                                        TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

            /* try to seize from 'l' */
            writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_SEIZE);
            /* seize from 'l' was not possible */
            access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
            DPRINTF_ACCESS;
            g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                        TPM_TIS_ACCESS_REQUEST_USE |
                                        pending_request_flag |
                                        TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

            /* locality 'locty' must be unchanged */
            access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
            g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                        TPM_TIS_ACCESS_ACTIVE_LOCALITY |
                                        TPM_TIS_ACCESS_PENDING_REQUEST |
                                        TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

            /*
             * on the next loop we will have a PENDING_REQUEST flag
             * set for locality 'l'
             */
            pending_request_flag = TPM_TIS_ACCESS_PENDING_REQUEST;
        }

        /*
         * higher localities can 'seize' access but not 'request use';
         * note: this will activate first l+1, then l+2 etc.
         */
        for (l = locty + 1; l < TPM_TIS_NUM_LOCALITIES - 1; l++) {
            /* try to 'request use' from 'l' */
            writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE);

            /*
             * requesting use from 'l' was not possible; we should see
             * REQUEST_USE and may see PENDING_REQUEST
             */
            access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
            DPRINTF_ACCESS;
            g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                        TPM_TIS_ACCESS_REQUEST_USE |
                                        pending_request_flag |
                                        TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

            /*
             * locality 'l-1' must be unchanged; we should always
             * see PENDING_REQUEST from 'l' requesting access
             */
            access = readb(TIS_REG(l - 1, TPM_TIS_REG_ACCESS));
            DPRINTF_ACCESS;
            g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                        TPM_TIS_ACCESS_ACTIVE_LOCALITY |
                                        TPM_TIS_ACCESS_PENDING_REQUEST |
                                        TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

            /* try to seize from 'l' */
            writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_SEIZE);

            /* seize from 'l' was possible */
            access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
            DPRINTF_ACCESS;
            g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                        TPM_TIS_ACCESS_ACTIVE_LOCALITY |
                                        pending_request_flag |
                                        TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

            /* l - 1 should show that it has BEEN_SEIZED */
            access = readb(TIS_REG(l - 1, TPM_TIS_REG_ACCESS));
            DPRINTF_ACCESS;
            g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                        TPM_TIS_ACCESS_BEEN_SEIZED |
                                        pending_request_flag |
                                        TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

            /* clear the BEEN_SEIZED flag and make sure it's gone */
            writeb(TIS_REG(l - 1, TPM_TIS_REG_ACCESS),
                   TPM_TIS_ACCESS_BEEN_SEIZED);

            access = readb(TIS_REG(l - 1, TPM_TIS_REG_ACCESS));
            g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                        pending_request_flag |
                                        TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
        }

        /*
         * PENDING_REQUEST will not be set if locty = 0 since all localities
         * were active; in case of locty = 1, locality 0 will be active
         * but no PENDING_REQUEST anywhere
         */
        if (locty <= 1) {
            pending_request_flag = 0;
        }

        /* release access from l - 1; this activates locty - 1 */
        l--;

        access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
        DPRINTF_ACCESS;

        DPRINTF("%s: %d: relinquishing control on l = %d\n",
                __func__, __LINE__, l);
        writeb(TIS_REG(l, TPM_TIS_REG_ACCESS),
               TPM_TIS_ACCESS_ACTIVE_LOCALITY);

        access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
        DPRINTF_ACCESS;
        g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                    pending_request_flag |
                                    TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

        for (l = locty - 1; l >= 0; l--) {
            access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
            DPRINTF_ACCESS;
            g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                        TPM_TIS_ACCESS_ACTIVE_LOCALITY |
                                        pending_request_flag |
                                        TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

            /* release this locality */
            writeb(TIS_REG(l, TPM_TIS_REG_ACCESS),
                   TPM_TIS_ACCESS_ACTIVE_LOCALITY);

            if (l == 1) {
                pending_request_flag = 0;
            }
        }

        /* no locality may be active now */
        for (l = 0; l < TPM_TIS_NUM_LOCALITIES - 1; l++) {
            access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
            DPRINTF_ACCESS;
            g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                        TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
        }
    }
}

/*
 * Test case for getting access when higher number locality relinquishes access
 */
void tpm_tis_test_check_access_reg_release(const void *data)
{
    int locty, l;
    uint8_t access;
    uint8_t pending_request_flag;

    /* do not test locality 4 (hw only) */
    for (locty = TPM_TIS_NUM_LOCALITIES - 2; locty >= 0; locty--) {
        pending_request_flag = 0;

        access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
        g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                    TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

        /* request use of locality */
        writeb(TIS_REG(locty, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE);
        access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
        g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                    TPM_TIS_ACCESS_ACTIVE_LOCALITY |
                                    TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

        /* request use of all other localities */
        for (l = 0; l < TPM_TIS_NUM_LOCALITIES - 1; l++) {
            if (l == locty) {
                continue;
            }
            /*
             * request use of locality 'l' -- we MUST see REQUEST USE and
             * may see PENDING_REQUEST
             */
            writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE);
            access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
            DPRINTF_ACCESS;
            g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                        TPM_TIS_ACCESS_REQUEST_USE |
                                        pending_request_flag |
                                        TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
            pending_request_flag = TPM_TIS_ACCESS_PENDING_REQUEST;
        }
        /* release locality 'locty' */
        writeb(TIS_REG(locty, TPM_TIS_REG_ACCESS),
               TPM_TIS_ACCESS_ACTIVE_LOCALITY);
        /*
         * highest locality should now be active; release it and make sure the
         * next higest locality is active afterwards
         */
        for (l = TPM_TIS_NUM_LOCALITIES - 2; l >= 0; l--) {
            if (l == locty) {
                continue;
            }
            /* 'l' should be active now */
            access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
            DPRINTF_ACCESS;
            g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                        TPM_TIS_ACCESS_ACTIVE_LOCALITY |
                                        pending_request_flag |
                                        TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
            /* 'l' relinquishes access */
            writeb(TIS_REG(l, TPM_TIS_REG_ACCESS),
                   TPM_TIS_ACCESS_ACTIVE_LOCALITY);
            access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
            DPRINTF_ACCESS;
            if (l == 1 || (locty <= 1 && l == 2)) {
                pending_request_flag = 0;
            }
            g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                        pending_request_flag |
                                        TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
        }
    }
}

/*
 * Test case for transmitting packets
 */
void tpm_tis_test_check_transmit(const void *data)
{
    const TestState *s = data;
    uint8_t access;
    uint32_t sts;
    uint16_t bcount;
    size_t i;

    /* request use of locality 0 */
    writeb(TIS_REG(0, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE);
    access = readb(TIS_REG(0, TPM_TIS_REG_ACCESS));
    g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS |
                                TPM_TIS_ACCESS_ACTIVE_LOCALITY |
                                TPM_TIS_ACCESS_TPM_ESTABLISHMENT);

    sts = readl(TIS_REG(0, TPM_TIS_REG_STS));
    DPRINTF_STS;

    g_assert_cmpint(sts & 0xff, ==, 0);
    g_assert_cmpint(sts & TPM_TIS_STS_TPM_FAMILY_MASK, ==,
                    TPM_TIS_STS_TPM_FAMILY2_0);

    bcount = (sts >> 8) & 0xffff;
    g_assert_cmpint(bcount, >=, 128);

    writel(TIS_REG(0, TPM_TIS_REG_STS), TPM_TIS_STS_COMMAND_READY);
    sts = readl(TIS_REG(0, TPM_TIS_REG_STS));
    DPRINTF_STS;
    g_assert_cmpint(sts & 0xff, ==, TPM_TIS_STS_COMMAND_READY);

    /* transmit command */
    for (i = 0; i < sizeof(TPM_CMD); i++) {
        writeb(TIS_REG(0, TPM_TIS_REG_DATA_FIFO), TPM_CMD[i]);
        sts = readl(TIS_REG(0, TPM_TIS_REG_STS));
        DPRINTF_STS;
        if (i < sizeof(TPM_CMD) - 1) {
            g_assert_cmpint(sts & 0xff, ==,
                            TPM_TIS_STS_EXPECT | TPM_TIS_STS_VALID);
        } else {
            g_assert_cmpint(sts & 0xff, ==, TPM_TIS_STS_VALID);
        }
        g_assert_cmpint((sts >> 8) & 0xffff, ==, --bcount);
    }
    /* start processing */
    writeb(TIS_REG(0, TPM_TIS_REG_STS), TPM_TIS_STS_TPM_GO);

    uint64_t end_time = g_get_monotonic_time() + 50 * G_TIME_SPAN_SECOND;
    do {
        sts = readl(TIS_REG(0, TPM_TIS_REG_STS));
        if ((sts & TPM_TIS_STS_DATA_AVAILABLE) != 0) {
            break;
        }
    } while (g_get_monotonic_time() < end_time);

    sts = readl(TIS_REG(0, TPM_TIS_REG_STS));
    DPRINTF_STS;
    g_assert_cmpint(sts & 0xff, == ,
                    TPM_TIS_STS_VALID | TPM_TIS_STS_DATA_AVAILABLE);
    bcount = (sts >> 8) & 0xffff;

    /* read response */
    uint8_t tpm_msg[sizeof(struct tpm_hdr)];
    g_assert_cmpint(sizeof(tpm_msg), ==, bcount);

    for (i = 0; i < sizeof(tpm_msg); i++) {
        tpm_msg[i] = readb(TIS_REG(0, TPM_TIS_REG_DATA_FIFO));
        sts = readl(TIS_REG(0, TPM_TIS_REG_STS));
        DPRINTF_STS;
        if (sts & TPM_TIS_STS_DATA_AVAILABLE) {
            g_assert_cmpint((sts >> 8) & 0xffff, ==, --bcount);
        }
    }
    g_assert_cmpmem(tpm_msg, sizeof(tpm_msg), s->tpm_msg, sizeof(*s->tpm_msg));

    /* relinquish use of locality 0 */
    writeb(TIS_REG(0, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_ACTIVE_LOCALITY);
    access = readb(TIS_REG(0, TPM_TIS_REG_ACCESS));
}
Commit	Line	Data
5166c326 EA	1	/*
	2	* QTest testcase for TPM TIS: common test functions used for both
	3	* the ISA and SYSBUS devices
	4	*
	5	* Copyright (c) 2018 Red Hat, Inc.
	6	* Copyright (c) 2018 IBM Corporation
	7	*
	8	* Authors:
	9	* Marc-André Lureau <marcandre.lureau@redhat.com>
	10	* Stefan Berger <stefanb@linux.vnet.ibm.com>
	11	*
	12	* This work is licensed under the terms of the GNU GPL, version 2 or later.
	13	* See the COPYING file in the top-level directory.
	14	*/
	15
	16	#include "qemu/osdep.h"
	17	#include <glib/gstdio.h>
	18
	19	#include "hw/acpi/tpm.h"
	20	#include "io/channel-socket.h"
	21	#include "libqtest-single.h"
	22	#include "qemu/module.h"
	23	#include "tpm-emu.h"
	24	#include "tpm-util.h"
	25	#include "tpm-tis-util.h"
	26
	27	#define DEBUG_TIS_TEST 0
	28
	29	#define DPRINTF(fmt, ...) do { \
	30	if (DEBUG_TIS_TEST) { \
	31	printf(fmt, ## __VA_ARGS__); \
	32	} \
	33	} while (0)
	34
	35	#define DPRINTF_ACCESS \
	36	DPRINTF("%s: %d: locty=%d l=%d access=0x%02x pending_request_flag=0x%x\n", \
	37	__func__, __LINE__, locty, l, access, pending_request_flag)
	38
	39	#define DPRINTF_STS \
	40	DPRINTF("%s: %d: sts = 0x%08x\n", __func__, __LINE__, sts)
	41
	42	static const uint8_t TPM_CMD[12] =
	43	"\x80\x01\x00\x00\x00\x0c\x00\x00\x01\x44\x00\x00";
	44
	45	void tpm_tis_test_check_localities(const void *data)
	46	{
	47	uint8_t locty;
	48	uint8_t access;
	49	uint32_t ifaceid;
	50	uint32_t capability;
	51	uint32_t didvid;
	52	uint32_t rid;
	53
	54	for (locty = 0; locty < TPM_TIS_NUM_LOCALITIES; locty++) {
	55	access = readb(TIS_REG(0, TPM_TIS_REG_ACCESS));
	56	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
	57	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
	58
	59	capability = readl(TIS_REG(locty, TPM_TIS_REG_INTF_CAPABILITY));
	60	g_assert_cmpint(capability, ==, TPM_TIS_CAPABILITIES_SUPPORTED2_0);
	61
	62	ifaceid = readl(TIS_REG(locty, TPM_TIS_REG_INTERFACE_ID));
	63	g_assert_cmpint(ifaceid, ==, TPM_TIS_IFACE_ID_SUPPORTED_FLAGS2_0);
	64
65	didvid = readl(TIS_REG(locty, TPM_TIS_REG_DID_VID));
66	g_assert_cmpint(didvid, !=, 0);
67	g_assert_cmpint(didvid, !=, 0xffffffff);
68
69	rid = readl(TIS_REG(locty, TPM_TIS_REG_RID));
70	g_assert_cmpint(rid, !=, 0);
71	g_assert_cmpint(rid, !=, 0xffffffff);
72	}
73	}
74
75	void tpm_tis_test_check_access_reg(const void *data)
76	{
77	uint8_t locty;
78	uint8_t access;
79
80	/* do not test locality 4 (hw only) */
81	for (locty = 0; locty < TPM_TIS_NUM_LOCALITIES - 1; locty++) {
82	access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
83	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
84	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
85
86	/* request use of locality */
87	writeb(TIS_REG(locty, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE);
88
89	access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
90	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
91	TPM_TIS_ACCESS_ACTIVE_LOCALITY \|
92	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
93
94	/* release access */
95	writeb(TIS_REG(locty, TPM_TIS_REG_ACCESS),
96	TPM_TIS_ACCESS_ACTIVE_LOCALITY);
97	access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
98	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
99	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
100	}
101	}
102
103	/*
104	* Test case for seizing access by a higher number locality
105	*/
106	void tpm_tis_test_check_access_reg_seize(const void *data)
107	{
108	int locty, l;
109	uint8_t access;
110	uint8_t pending_request_flag;
111
112	/* do not test locality 4 (hw only) */
113	for (locty = 0; locty < TPM_TIS_NUM_LOCALITIES - 1; locty++) {
114	pending_request_flag = 0;
115
116	access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
117	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
118	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
119
120	/* request use of locality */
121	writeb(TIS_REG(locty, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE);
122	access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
123	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
124	TPM_TIS_ACCESS_ACTIVE_LOCALITY \|
125	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
126
127	/* lower localities cannot seize access */
128	for (l = 0; l < locty; l++) {
129	/* lower locality is not active */
130	access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
131	DPRINTF_ACCESS;
132	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
133	pending_request_flag \|
134	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
135
136	/* try to request use from 'l' */
137	writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE);
138
139	/*
140	* requesting use from 'l' was not possible;
141	* we must see REQUEST_USE and possibly PENDING_REQUEST
142	*/
143	access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
144	DPRINTF_ACCESS;
145	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
146	TPM_TIS_ACCESS_REQUEST_USE \|
147	pending_request_flag \|
148	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
149
150	/*
151	* locality 'locty' must be unchanged;
152	* we must see PENDING_REQUEST
153	*/
154	access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
155	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
156	TPM_TIS_ACCESS_ACTIVE_LOCALITY \|
157	TPM_TIS_ACCESS_PENDING_REQUEST \|
158	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
159
160	/* try to seize from 'l' */
161	writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_SEIZE);
162	/* seize from 'l' was not possible */
163	access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
164	DPRINTF_ACCESS;
165	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
166	TPM_TIS_ACCESS_REQUEST_USE \|
167	pending_request_flag \|
168	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
169
170	/* locality 'locty' must be unchanged */
171	access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
172	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
173	TPM_TIS_ACCESS_ACTIVE_LOCALITY \|
174	TPM_TIS_ACCESS_PENDING_REQUEST \|
175	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
176
177	/*
178	* on the next loop we will have a PENDING_REQUEST flag
179	* set for locality 'l'
180	*/
181	pending_request_flag = TPM_TIS_ACCESS_PENDING_REQUEST;
182	}
183
184	/*
185	* higher localities can 'seize' access but not 'request use';
186	* note: this will activate first l+1, then l+2 etc.
187	*/
188	for (l = locty + 1; l < TPM_TIS_NUM_LOCALITIES - 1; l++) {
189	/* try to 'request use' from 'l' */
190	writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE);
191
192	/*
193	* requesting use from 'l' was not possible; we should see
194	* REQUEST_USE and may see PENDING_REQUEST
195	*/
196	access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
197	DPRINTF_ACCESS;
198	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
199	TPM_TIS_ACCESS_REQUEST_USE \|
200	pending_request_flag \|
201	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
202
203	/*
204	* locality 'l-1' must be unchanged; we should always
205	* see PENDING_REQUEST from 'l' requesting access
206	*/
207	access = readb(TIS_REG(l - 1, TPM_TIS_REG_ACCESS));
208	DPRINTF_ACCESS;
209	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
210	TPM_TIS_ACCESS_ACTIVE_LOCALITY \|
211	TPM_TIS_ACCESS_PENDING_REQUEST \|
212	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
213
214	/* try to seize from 'l' */
215	writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_SEIZE);
216
217	/* seize from 'l' was possible */
218	access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
219	DPRINTF_ACCESS;
220	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
221	TPM_TIS_ACCESS_ACTIVE_LOCALITY \|
222	pending_request_flag \|
223	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
224
225	/* l - 1 should show that it has BEEN_SEIZED */
226	access = readb(TIS_REG(l - 1, TPM_TIS_REG_ACCESS));
227	DPRINTF_ACCESS;
228	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
229	TPM_TIS_ACCESS_BEEN_SEIZED \|
230	pending_request_flag \|
231	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
232
233	/* clear the BEEN_SEIZED flag and make sure it's gone */
234	writeb(TIS_REG(l - 1, TPM_TIS_REG_ACCESS),
235	TPM_TIS_ACCESS_BEEN_SEIZED);
236
237	access = readb(TIS_REG(l - 1, TPM_TIS_REG_ACCESS));
238	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
239	pending_request_flag \|
240	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
241	}
242
243	/*
244	* PENDING_REQUEST will not be set if locty = 0 since all localities
245	* were active; in case of locty = 1, locality 0 will be active
246	* but no PENDING_REQUEST anywhere
247	*/
248	if (locty <= 1) {
249	pending_request_flag = 0;
250	}
251
252	/* release access from l - 1; this activates locty - 1 */
253	l--;
254
255	access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
256	DPRINTF_ACCESS;
257
258	DPRINTF("%s: %d: relinquishing control on l = %d\n",
259	__func__, __LINE__, l);
260	writeb(TIS_REG(l, TPM_TIS_REG_ACCESS),
261	TPM_TIS_ACCESS_ACTIVE_LOCALITY);
262
263	access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
264	DPRINTF_ACCESS;
265	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
266	pending_request_flag \|
267	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
268
269	for (l = locty - 1; l >= 0; l--) {
270	access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
271	DPRINTF_ACCESS;
272	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
273	TPM_TIS_ACCESS_ACTIVE_LOCALITY \|
274	pending_request_flag \|
275	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
276
277	/* release this locality */
278	writeb(TIS_REG(l, TPM_TIS_REG_ACCESS),
279	TPM_TIS_ACCESS_ACTIVE_LOCALITY);
280
281	if (l == 1) {
282	pending_request_flag = 0;
283	}
284	}
285
286	/* no locality may be active now */
287	for (l = 0; l < TPM_TIS_NUM_LOCALITIES - 1; l++) {
288	access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
289	DPRINTF_ACCESS;
290	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
291	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
292	}
293	}
294	}
295
296	/*
297	* Test case for getting access when higher number locality relinquishes access
298	*/
299	void tpm_tis_test_check_access_reg_release(const void *data)
300	{
301	int locty, l;
302	uint8_t access;
303	uint8_t pending_request_flag;
304
305	/* do not test locality 4 (hw only) */
306	for (locty = TPM_TIS_NUM_LOCALITIES - 2; locty >= 0; locty--) {
307	pending_request_flag = 0;
308
309	access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
310	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
311	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
312
313	/* request use of locality */
314	writeb(TIS_REG(locty, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE);
315	access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS));
316	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
317	TPM_TIS_ACCESS_ACTIVE_LOCALITY \|
318	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
319
320	/* request use of all other localities */
321	for (l = 0; l < TPM_TIS_NUM_LOCALITIES - 1; l++) {
322	if (l == locty) {
323	continue;
324	}
325	/*
326	* request use of locality 'l' -- we MUST see REQUEST USE and
327	* may see PENDING_REQUEST
328	*/
329	writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE);
330	access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
331	DPRINTF_ACCESS;
332	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
333	TPM_TIS_ACCESS_REQUEST_USE \|
334	pending_request_flag \|
335	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
336	pending_request_flag = TPM_TIS_ACCESS_PENDING_REQUEST;
337	}
338	/* release locality 'locty' */
339	writeb(TIS_REG(locty, TPM_TIS_REG_ACCESS),
340	TPM_TIS_ACCESS_ACTIVE_LOCALITY);
341	/*
342	* highest locality should now be active; release it and make sure the
343	* next higest locality is active afterwards
344	*/
345	for (l = TPM_TIS_NUM_LOCALITIES - 2; l >= 0; l--) {
346	if (l == locty) {
347	continue;
348	}
349	/* 'l' should be active now */
350	access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
351	DPRINTF_ACCESS;
352	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
353	TPM_TIS_ACCESS_ACTIVE_LOCALITY \|
354	pending_request_flag \|
355	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
356	/* 'l' relinquishes access */
357	writeb(TIS_REG(l, TPM_TIS_REG_ACCESS),
358	TPM_TIS_ACCESS_ACTIVE_LOCALITY);
359	access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS));
360	DPRINTF_ACCESS;
361	if (l == 1 \|\| (locty <= 1 && l == 2)) {
362	pending_request_flag = 0;
363	}
364	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
365	pending_request_flag \|
366	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
367	}
368	}
369	}
370
371	/*
372	* Test case for transmitting packets
373	*/
374	void tpm_tis_test_check_transmit(const void *data)
375	{
376	const TestState *s = data;
377	uint8_t access;
378	uint32_t sts;
379	uint16_t bcount;
380	size_t i;
381
382	/* request use of locality 0 */
383	writeb(TIS_REG(0, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE);
384	access = readb(TIS_REG(0, TPM_TIS_REG_ACCESS));
385	g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS \|
386	TPM_TIS_ACCESS_ACTIVE_LOCALITY \|
387	TPM_TIS_ACCESS_TPM_ESTABLISHMENT);
388
389	sts = readl(TIS_REG(0, TPM_TIS_REG_STS));
390	DPRINTF_STS;
391
392	g_assert_cmpint(sts & 0xff, ==, 0);
393	g_assert_cmpint(sts & TPM_TIS_STS_TPM_FAMILY_MASK, ==,
394	TPM_TIS_STS_TPM_FAMILY2_0);
395
396	bcount = (sts >> 8) & 0xffff;
397	g_assert_cmpint(bcount, >=, 128);
398
399	writel(TIS_REG(0, TPM_TIS_REG_STS), TPM_TIS_STS_COMMAND_READY);
400	sts = readl(TIS_REG(0, TPM_TIS_REG_STS));
401	DPRINTF_STS;
402	g_assert_cmpint(sts & 0xff, ==, TPM_TIS_STS_COMMAND_READY);
403
404	/* transmit command */
405	for (i = 0; i < sizeof(TPM_CMD); i++) {
406	writeb(TIS_REG(0, TPM_TIS_REG_DATA_FIFO), TPM_CMD[i]);
407	sts = readl(TIS_REG(0, TPM_TIS_REG_STS));
408	DPRINTF_STS;
409	if (i < sizeof(TPM_CMD) - 1) {
410	g_assert_cmpint(sts & 0xff, ==,
411	TPM_TIS_STS_EXPECT \| TPM_TIS_STS_VALID);
412	} else {
413	g_assert_cmpint(sts & 0xff, ==, TPM_TIS_STS_VALID);
414	}
415	g_assert_cmpint((sts >> 8) & 0xffff, ==, --bcount);
416	}
417	/* start processing */
418	writeb(TIS_REG(0, TPM_TIS_REG_STS), TPM_TIS_STS_TPM_GO);
419
420	uint64_t end_time = g_get_monotonic_time() + 50 * G_TIME_SPAN_SECOND;
421	do {
422	sts = readl(TIS_REG(0, TPM_TIS_REG_STS));
423	if ((sts & TPM_TIS_STS_DATA_AVAILABLE) != 0) {
424	break;
425	}
426	} while (g_get_monotonic_time() < end_time);
427
428	sts = readl(TIS_REG(0, TPM_TIS_REG_STS));
429	DPRINTF_STS;
430	g_assert_cmpint(sts & 0xff, == ,
431	TPM_TIS_STS_VALID \| TPM_TIS_STS_DATA_AVAILABLE);
432	bcount = (sts >> 8) & 0xffff;
433
434	/* read response */
435	uint8_t tpm_msg[sizeof(struct tpm_hdr)];
436	g_assert_cmpint(sizeof(tpm_msg), ==, bcount);
437
438	for (i = 0; i < sizeof(tpm_msg); i++) {
439	tpm_msg[i] = readb(TIS_REG(0, TPM_TIS_REG_DATA_FIFO));
440	sts = readl(TIS_REG(0, TPM_TIS_REG_STS));
441	DPRINTF_STS;
442	if (sts & TPM_TIS_STS_DATA_AVAILABLE) {
443	g_assert_cmpint((sts >> 8) & 0xffff, ==, --bcount);
444	}
445	}
446	g_assert_cmpmem(tpm_msg, sizeof(tpm_msg), s->tpm_msg, sizeof(*s->tpm_msg));
447
448	/* relinquish use of locality 0 */
449	writeb(TIS_REG(0, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_ACTIVE_LOCALITY);
450	access = readb(TIS_REG(0, TPM_TIS_REG_ACCESS));
451	}