Commit eae3aace authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/stefanberger/tags/pull-tpm-2018-03-29-1' into staging 



Merge tpm 2018/03/29 v1

# gpg: Signature made Fri 30 Mar 2018 01:04:47 BST
# gpg:                using RSA key 75AD65802A0B4211
# gpg: Good signature from "Stefan Berger <stefanb@linux.vnet.ibm.com>"
# gpg: WARNING: This key is not certified with a trusted signature!
# gpg:          There is no indication that the signature belongs to the owner.
# Primary key fingerprint: B818 B9CA DF90 89C2 D5CE  C66B 75AD 6580 2A0B 4211

* remotes/stefanberger/tags/pull-tpm-2018-03-29-1:
  tests: Tests more flags of the CRB interface
  tpm: CRB: Enforce locality is requested before processing buffer
  tpm: CRB: Reset Granted flag when relinquishing locality
  tpm: CRB: set the Idle flag by default

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 4cd327de 4d0d1c07

hw/tpm/tpm_crb.c

+17 −1
Original line number Diff line number Diff line
@@ -76,6 +76,8 @@ enum crb_cancel { 
    CRB_CANCEL_INVOKE = BIT(0),

};



#define TPM_CRB_NO_LOCALITY 0xff



static uint64_t tpm_crb_mmio_read(void *opaque, hwaddr addr,

                                  unsigned size)

{
@@ -95,10 +97,19 @@ static uint64_t tpm_crb_mmio_read(void *opaque, hwaddr addr, 
    return val;

}



static uint8_t tpm_crb_get_active_locty(CRBState *s)

{

    if (!ARRAY_FIELD_EX32(s->regs, CRB_LOC_STATE, locAssigned)) {

        return TPM_CRB_NO_LOCALITY;

    }

    return ARRAY_FIELD_EX32(s->regs, CRB_LOC_STATE, activeLocality);

}



static void tpm_crb_mmio_write(void *opaque, hwaddr addr,

                               uint64_t val, unsigned size)

{

    CRBState *s = CRB(opaque);

    uint8_t locty =  addr >> 12;



    trace_tpm_crb_mmio_write(addr, size, val);
@@ -123,7 +134,8 @@ static void tpm_crb_mmio_write(void *opaque, hwaddr addr, 
        break;

    case A_CRB_CTRL_START:

        if (val == CRB_START_INVOKE &&

            !(s->regs[R_CRB_CTRL_START] & CRB_START_INVOKE)) {

            !(s->regs[R_CRB_CTRL_START] & CRB_START_INVOKE) &&

            tpm_crb_get_active_locty(s) == locty) {

            void *mem = memory_region_get_ram_ptr(&s->cmdmem);



            s->regs[R_CRB_CTRL_START] |= CRB_START_INVOKE;
@@ -145,6 +157,8 @@ static void tpm_crb_mmio_write(void *opaque, hwaddr addr, 
        case CRB_LOC_CTRL_RELINQUISH:

            ARRAY_FIELD_DP32(s->regs, CRB_LOC_STATE,

                             locAssigned, 0);

            ARRAY_FIELD_DP32(s->regs, CRB_LOC_STS,

                             Granted, 0);

            break;

        case CRB_LOC_CTRL_REQUEST_ACCESS:

            ARRAY_FIELD_DP32(s->regs, CRB_LOC_STS,
@@ -220,6 +234,8 @@ static void tpm_crb_reset(void *dev) 


    ARRAY_FIELD_DP32(s->regs, CRB_LOC_STATE,

                     tpmRegValidSts, 1);

    ARRAY_FIELD_DP32(s->regs, CRB_CTRL_STS,

                     tpmIdle, 1);

    ARRAY_FIELD_DP32(s->regs, CRB_INTF_ID,

                     InterfaceType, CRB_INTF_TYPE_CRB_ACTIVE);

    ARRAY_FIELD_DP32(s->regs, CRB_INTF_ID,

tests/tpm-crb-test.c

+72 −2
Original line number Diff line number Diff line
@@ -28,6 +28,10 @@ static void tpm_crb_test(const void *data) 
    uint64_t caddr = readq(TPM_CRB_ADDR_BASE + A_CRB_CTRL_CMD_LADDR);

    uint32_t rsize = readl(TPM_CRB_ADDR_BASE + A_CRB_CTRL_RSP_SIZE);

    uint64_t raddr = readq(TPM_CRB_ADDR_BASE + A_CRB_CTRL_RSP_ADDR);

    uint8_t locstate = readb(TPM_CRB_ADDR_BASE + A_CRB_LOC_STATE);

    uint32_t locctrl = readl(TPM_CRB_ADDR_BASE + A_CRB_LOC_CTRL);

    uint32_t locsts = readl(TPM_CRB_ADDR_BASE + A_CRB_LOC_STS);

    uint32_t sts = readl(TPM_CRB_ADDR_BASE + A_CRB_CTRL_STS);



    g_assert_cmpint(FIELD_EX32(intfid, CRB_INTF_ID, InterfaceType), ==, 1);

    g_assert_cmpint(FIELD_EX32(intfid, CRB_INTF_ID, InterfaceVersion), ==, 1);
@@ -45,9 +49,47 @@ static void tpm_crb_test(const void *data) 
    g_assert_cmpint(caddr, >, TPM_CRB_ADDR_BASE);

    g_assert_cmpint(raddr, >, TPM_CRB_ADDR_BASE);



    g_assert_cmpint(FIELD_EX32(locstate, CRB_LOC_STATE, tpmEstablished), ==, 1);

    g_assert_cmpint(FIELD_EX32(locstate, CRB_LOC_STATE, locAssigned), ==, 0);

    g_assert_cmpint(FIELD_EX32(locstate, CRB_LOC_STATE, activeLocality), ==, 0);

    g_assert_cmpint(FIELD_EX32(locstate, CRB_LOC_STATE, reserved), ==, 0);

    g_assert_cmpint(FIELD_EX32(locstate, CRB_LOC_STATE, tpmRegValidSts), ==, 1);



    g_assert_cmpint(locctrl, ==, 0);



    g_assert_cmpint(FIELD_EX32(locsts, CRB_LOC_STS, Granted), ==, 0);

    g_assert_cmpint(FIELD_EX32(locsts, CRB_LOC_STS, beenSeized), ==, 0);



    g_assert_cmpint(FIELD_EX32(sts, CRB_CTRL_STS, tpmIdle), ==, 1);

    g_assert_cmpint(FIELD_EX32(sts, CRB_CTRL_STS, tpmSts), ==, 0);



    /* request access to locality 0 */

    writeb(TPM_CRB_ADDR_BASE + A_CRB_LOC_CTRL, 1);



    /* granted bit must be set now */

    locsts = readl(TPM_CRB_ADDR_BASE + A_CRB_LOC_STS);

    g_assert_cmpint(FIELD_EX32(locsts, CRB_LOC_STS, Granted), ==, 1);

    g_assert_cmpint(FIELD_EX32(locsts, CRB_LOC_STS, beenSeized), ==, 0);



    /* we must have an assigned locality */

    locstate = readb(TPM_CRB_ADDR_BASE + A_CRB_LOC_STATE);

    g_assert_cmpint(FIELD_EX32(locstate, CRB_LOC_STATE, tpmEstablished), ==, 1);

    g_assert_cmpint(FIELD_EX32(locstate, CRB_LOC_STATE, locAssigned), ==, 1);

    g_assert_cmpint(FIELD_EX32(locstate, CRB_LOC_STATE, activeLocality), ==, 0);

    g_assert_cmpint(FIELD_EX32(locstate, CRB_LOC_STATE, reserved), ==, 0);

    g_assert_cmpint(FIELD_EX32(locstate, CRB_LOC_STATE, tpmRegValidSts), ==, 1);



    /* set into ready state */

    writel(TPM_CRB_ADDR_BASE + A_CRB_CTRL_REQ, 1);



    /* TPM must not be in the idle state */

    sts = readl(TPM_CRB_ADDR_BASE + A_CRB_CTRL_STS);

    g_assert_cmpint(FIELD_EX32(sts, CRB_CTRL_STS, tpmIdle), ==, 0);

    g_assert_cmpint(FIELD_EX32(sts, CRB_CTRL_STS, tpmSts), ==, 0);



    memwrite(caddr, TPM_CMD, sizeof(TPM_CMD));



    uint32_t sts, start = 1;

    uint32_t start = 1;

    uint64_t end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;

    writel(TPM_CRB_ADDR_BASE + A_CRB_CTRL_START, start);

    do {
@@ -58,12 +100,40 @@ static void tpm_crb_test(const void *data) 
    } while (g_get_monotonic_time() < end_time);

    start = readl(TPM_CRB_ADDR_BASE + A_CRB_CTRL_START);

    g_assert_cmpint(start & 1, ==, 0);



    /* TPM must still not be in the idle state */

    sts = readl(TPM_CRB_ADDR_BASE + A_CRB_CTRL_STS);

    g_assert_cmpint(sts & 1, ==, 0);

    g_assert_cmpint(FIELD_EX32(sts, CRB_CTRL_STS, tpmIdle), ==, 0);

    g_assert_cmpint(FIELD_EX32(sts, CRB_CTRL_STS, tpmSts), ==, 0);



    struct tpm_hdr tpm_msg;

    memread(raddr, &tpm_msg, sizeof(tpm_msg));

    g_assert_cmpmem(&tpm_msg, sizeof(tpm_msg), s->tpm_msg, sizeof(*s->tpm_msg));



    /* set TPM into idle state */

    writel(TPM_CRB_ADDR_BASE + A_CRB_CTRL_REQ, 2);



    /* idle state must be indicated now */

    sts = readl(TPM_CRB_ADDR_BASE + A_CRB_CTRL_STS);

    g_assert_cmpint(FIELD_EX32(sts, CRB_CTRL_STS, tpmIdle), ==, 1);

    g_assert_cmpint(FIELD_EX32(sts, CRB_CTRL_STS, tpmSts), ==, 0);



    /* relinquish locality */

    writel(TPM_CRB_ADDR_BASE + A_CRB_LOC_CTRL, 2);



    /* Granted flag must be cleared */

    sts = readl(TPM_CRB_ADDR_BASE + A_CRB_LOC_STS);

    g_assert_cmpint(FIELD_EX32(sts, CRB_LOC_STS, Granted), ==, 0);

    g_assert_cmpint(FIELD_EX32(sts, CRB_LOC_STS, beenSeized), ==, 0);



    /* no locality may be assigned */

    locstate = readb(TPM_CRB_ADDR_BASE + A_CRB_LOC_STATE);

    g_assert_cmpint(FIELD_EX32(locstate, CRB_LOC_STATE, tpmEstablished), ==, 1);

    g_assert_cmpint(FIELD_EX32(locstate, CRB_LOC_STATE, locAssigned), ==, 0);

    g_assert_cmpint(FIELD_EX32(locstate, CRB_LOC_STATE, activeLocality), ==, 0);

    g_assert_cmpint(FIELD_EX32(locstate, CRB_LOC_STATE, reserved), ==, 0);

    g_assert_cmpint(FIELD_EX32(locstate, CRB_LOC_STATE, tpmRegValidSts), ==, 1);



}



int main(int argc, char **argv)