tests/qtest/tpm-tis-util.c

   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 }