uboot/drivers/tpm/tpm_tis_infineon.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (C) 2011 Infineon Technologies
   4 *
   5 * Authors:
   6 * Peter Huewe <huewe.external@infineon.com>
   7 *
   8 * Description:
   9 * Device driver for TCG/TCPA TPM (trusted platform module).
  10 * Specifications at www.trustedcomputinggroup.org
  11 *
  12 * This device driver implements the TPM interface as defined in
  13 * the TCG TPM Interface Spec version 1.2, revision 1.0 and the
  14 * Infineon I2C Protocol Stack Specification v0.20.
  15 *
  16 * It is based on the Linux kernel driver tpm.c from Leendert van
  17 * Dorn, Dave Safford, Reiner Sailer, and Kyleen Hall.
  18 *
  19 * Version: 2.1.1
  20 */
  21
  22#include <common.h>
  23#include <dm.h>
  24#include <fdtdec.h>
  25#include <i2c.h>
  26#include <tpm.h>
  27#include <linux/errno.h>
  28#include <linux/compiler.h>
  29#include <linux/types.h>
  30#include <linux/unaligned/be_byteshift.h>
  31
  32#include "tpm_tis.h"
  33#include "tpm_internal.h"
  34
  35enum i2c_chip_type {
  36        SLB9635,
  37        SLB9645,
  38        UNKNOWN,
  39};
  40
  41/* expected value for DIDVID register */
  42#define TPM_TIS_I2C_DID_VID_9635 0x000b15d1L
  43#define TPM_TIS_I2C_DID_VID_9645 0x001a15d1L
  44
  45static const char * const chip_name[] = {
  46        [SLB9635] = "slb9635tt",
  47        [SLB9645] = "slb9645tt",
  48        [UNKNOWN] = "unknown/fallback to slb9635",
  49};
  50
  51#define TPM_ACCESS(l)                   (0x0000 | ((l) << 4))
  52#define TPM_STS(l)                      (0x0001 | ((l) << 4))
  53#define TPM_DATA_FIFO(l)                (0x0005 | ((l) << 4))
  54#define TPM_DID_VID(l)                  (0x0006 | ((l) << 4))
  55
  56/*
  57 * tpm_tis_i2c_read() - read from TPM register
  58 * @addr: register address to read from
  59 * @buffer: provided by caller
  60 * @len: number of bytes to read
  61 *
  62 * Read len bytes from TPM register and put them into
  63 * buffer (little-endian format, i.e. first byte is put into buffer[0]).
  64 *
  65 * NOTE: TPM is big-endian for multi-byte values. Multi-byte
  66 * values have to be swapped.
  67 *
  68 * Return -EIO on error, 0 on success.
  69 */
  70static int tpm_tis_i2c_read(struct udevice *dev, u8 addr, u8 *buffer,
  71                            size_t len)
  72{
  73        struct tpm_chip *chip = dev_get_priv(dev);
  74        int rc;
  75        int count;
  76        uint32_t addrbuf = addr;
  77
  78        if ((chip->chip_type == SLB9635) || (chip->chip_type == UNKNOWN)) {
  79                /* slb9635 protocol should work in both cases */
  80                for (count = 0; count < MAX_COUNT; count++) {
  81                        rc = dm_i2c_write(dev, 0, (uchar *)&addrbuf, 1);
  82                        if (rc == 0)
  83                                break;  /* Success, break to skip sleep */
  84                        udelay(SLEEP_DURATION_US);
  85                }
  86                if (rc)
  87                        return rc;
  88
  89                /* After the TPM has successfully received the register address
  90                 * it needs some time, thus we're sleeping here again, before
  91                 * retrieving the data
  92                 */
  93                for (count = 0; count < MAX_COUNT; count++) {
  94                        udelay(SLEEP_DURATION_US);
  95                        rc = dm_i2c_read(dev, 0, buffer, len);
  96                        if (rc == 0)
  97                                break;  /* success, break to skip sleep */
  98                }
  99        } else {
 100                /*
 101                 * Use a combined read for newer chips.
 102                 * Unfortunately the smbus functions are not suitable due to
 103                 * the 32 byte limit of the smbus.
 104                 * Retries should usually not be needed, but are kept just to
 105                 * be safe on the safe side.
 106                 */
 107                for (count = 0; count < MAX_COUNT; count++) {
 108                        rc = dm_i2c_read(dev, addr, buffer, len);
 109                        if (rc == 0)
 110                                break;  /* break here to skip sleep */
 111                        udelay(SLEEP_DURATION_US);
 112                }
 113        }
 114
 115        /* Take care of 'guard time' */
 116        udelay(SLEEP_DURATION_US);
 117        if (rc)
 118                return rc;
 119
 120        return 0;
 121}
 122
 123static int tpm_tis_i2c_write_generic(struct udevice *dev, u8 addr,
 124                                     const u8 *buffer, size_t len,
 125                                     unsigned int sleep_time_us, u8 max_count)
 126{
 127        struct tpm_chip_priv *priv = dev_get_uclass_priv(dev);
 128        struct tpm_chip *chip = dev_get_priv(dev);
 129        int rc = 0;
 130        int count;
 131
 132        if (chip->chip_type == SLB9635) {
 133                /* Prepare send buffer to include the address */
 134                priv->buf[0] = addr;
 135                memcpy(&(priv->buf[1]), buffer, len);
 136                buffer = priv->buf;
 137                len++;
 138                addr = 0;
 139        }
 140
 141        for (count = 0; count < max_count; count++) {
 142                rc = dm_i2c_write(dev, addr, buffer, len);
 143                if (rc == 0)
 144                        break;  /* Success, break to skip sleep */
 145                udelay(sleep_time_us);
 146        }
 147
 148        /* take care of 'guard time' */
 149        udelay(sleep_time_us);
 150        if (rc)
 151                return rc;
 152
 153        return 0;
 154}
 155
 156/*
 157 * tpm_tis_i2c_write() - write to TPM register
 158 * @addr: register address to write to
 159 * @buffer: containing data to be written
 160 * @len: number of bytes to write
 161 *
 162 * Write len bytes from provided buffer to TPM register (little
 163 * endian format, i.e. buffer[0] is written as first byte).
 164 *
 165 * NOTE: TPM is big-endian for multi-byte values. Multi-byte
 166 * values have to be swapped.
 167 *
 168 * NOTE: use this function instead of the tpm_tis_i2c_write_generic function.
 169 *
 170 * Return -EIO on error, 0 on success
 171 */
 172static int tpm_tis_i2c_write(struct udevice *dev, u8 addr, const u8 *buffer,
 173                             size_t len)
 174{
 175        return tpm_tis_i2c_write_generic(dev, addr, buffer, len,
 176                                         SLEEP_DURATION_US, MAX_COUNT);
 177}
 178
 179/*
 180 * This function is needed especially for the cleanup situation after
 181 * sending TPM_READY
 182 */
 183static int tpm_tis_i2c_write_long(struct udevice *dev, u8 addr, u8 *buffer,
 184                                  size_t len)
 185{
 186        return tpm_tis_i2c_write_generic(dev, addr, buffer, len,
 187                                         SLEEP_DURATION_LONG_US,
 188                                         MAX_COUNT_LONG);
 189}
 190
 191static int tpm_tis_i2c_check_locality(struct udevice *dev, int loc)
 192{
 193        const u8 mask = TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID;
 194        struct tpm_chip *chip = dev_get_priv(dev);
 195        u8 buf;
 196        int rc;
 197
 198        rc = tpm_tis_i2c_read(dev, TPM_ACCESS(loc), &buf, 1);
 199        if (rc < 0)
 200                return rc;
 201
 202        if ((buf & mask) == mask) {
 203                chip->locality = loc;
 204                return loc;
 205        }
 206
 207        return -ENOENT;
 208}
 209
 210static void tpm_tis_i2c_release_locality(struct udevice *dev, int loc,
 211                                         int force)
 212{
 213        const u8 mask = TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID;
 214        u8 buf;
 215
 216        if (tpm_tis_i2c_read(dev, TPM_ACCESS(loc), &buf, 1) < 0)
 217                return;
 218
 219        if (force || (buf & mask) == mask) {
 220                buf = TPM_ACCESS_ACTIVE_LOCALITY;
 221                tpm_tis_i2c_write(dev, TPM_ACCESS(loc), &buf, 1);
 222        }
 223}
 224
 225static int tpm_tis_i2c_request_locality(struct udevice *dev, int loc)
 226{
 227        struct tpm_chip *chip = dev_get_priv(dev);
 228        unsigned long start, stop;
 229        u8 buf = TPM_ACCESS_REQUEST_USE;
 230        int rc;
 231
 232        rc = tpm_tis_i2c_check_locality(dev, loc);
 233        if (rc >= 0) {
 234                debug("%s: Already have locality\n", __func__);
 235                return loc;  /* We already have the locality */
 236        } else if (rc != -ENOENT) {
 237                debug("%s: Failed to get locality: %d\n", __func__, rc);
 238                return rc;
 239        }
 240
 241        rc = tpm_tis_i2c_write(dev, TPM_ACCESS(loc), &buf, 1);
 242        if (rc) {
 243                debug("%s: Failed to write to TPM: %d\n", __func__, rc);
 244                return rc;
 245        }
 246
 247        /* Wait for burstcount */
 248        start = get_timer(0);
 249        stop = chip->timeout_a;
 250        do {
 251                rc = tpm_tis_i2c_check_locality(dev, loc);
 252                if (rc >= 0) {
 253                        debug("%s: Have locality\n", __func__);
 254                        return loc;
 255                } else if (rc != -ENOENT) {
 256                        debug("%s: Failed to get locality: %d\n", __func__, rc);
 257                        return rc;
 258                }
 259                mdelay(TPM_TIMEOUT_MS);
 260        } while (get_timer(start) < stop);
 261        debug("%s: Timeout getting locality: %d\n", __func__, rc);
 262
 263        return rc;
 264}
 265
 266static u8 tpm_tis_i2c_status(struct udevice *dev)
 267{
 268        struct tpm_chip *chip = dev_get_priv(dev);
 269        /* NOTE: Since i2c read may fail, return 0 in this case --> time-out */
 270        u8 buf;
 271
 272        if (tpm_tis_i2c_read(dev, TPM_STS(chip->locality), &buf, 1) < 0)
 273                return 0;
 274        else
 275                return buf;
 276}
 277
 278static int tpm_tis_i2c_ready(struct udevice *dev)
 279{
 280        struct tpm_chip *chip = dev_get_priv(dev);
 281        int rc;
 282
 283        /* This causes the current command to be aborted */
 284        u8 buf = TPM_STS_COMMAND_READY;
 285
 286        debug("%s\n", __func__);
 287        rc = tpm_tis_i2c_write_long(dev, TPM_STS(chip->locality), &buf, 1);
 288        if (rc)
 289                debug("%s: rc=%d\n", __func__, rc);
 290
 291        return rc;
 292}
 293
 294static ssize_t tpm_tis_i2c_get_burstcount(struct udevice *dev)
 295{
 296        struct tpm_chip *chip = dev_get_priv(dev);
 297        unsigned long start, stop;
 298        ssize_t burstcnt;
 299        u8 addr, buf[3];
 300
 301        /* Wait for burstcount */
 302        /* XXX: Which timeout value? Spec has 2 answers (c & d) */
 303        start = get_timer(0);
 304        stop = chip->timeout_d;
 305        do {
 306                /* Note: STS is little endian */
 307                addr = TPM_STS(chip->locality) + 1;
 308                if (tpm_tis_i2c_read(dev, addr, buf, 3) < 0)
 309                        burstcnt = 0;
 310                else
 311                        burstcnt = (buf[2] << 16) + (buf[1] << 8) + buf[0];
 312
 313                if (burstcnt)
 314                        return burstcnt;
 315                mdelay(TPM_TIMEOUT_MS);
 316        } while (get_timer(start) < stop);
 317
 318        return -EBUSY;
 319}
 320
 321static int tpm_tis_i2c_wait_for_stat(struct udevice *dev, u8 mask,
 322                                     unsigned long timeout, int *status)
 323{
 324        unsigned long start, stop;
 325
 326        /* Check current status */
 327        *status = tpm_tis_i2c_status(dev);
 328        if ((*status & mask) == mask)
 329                return 0;
 330
 331        start = get_timer(0);
 332        stop = timeout;
 333        do {
 334                mdelay(TPM_TIMEOUT_MS);
 335                *status = tpm_tis_i2c_status(dev);
 336                if ((*status & mask) == mask)
 337                        return 0;
 338        } while (get_timer(start) < stop);
 339
 340        return -ETIMEDOUT;
 341}
 342
 343static int tpm_tis_i2c_recv_data(struct udevice *dev, u8 *buf, size_t count)
 344{
 345        struct tpm_chip *chip = dev_get_priv(dev);
 346        size_t size = 0;
 347        ssize_t burstcnt;
 348        int rc;
 349
 350        while (size < count) {
 351                burstcnt = tpm_tis_i2c_get_burstcount(dev);
 352
 353                /* burstcount < 0 -> tpm is busy */
 354                if (burstcnt < 0)
 355                        return burstcnt;
 356
 357                /* Limit received data to max left */
 358                if (burstcnt > (count - size))
 359                        burstcnt = count - size;
 360
 361                rc = tpm_tis_i2c_read(dev, TPM_DATA_FIFO(chip->locality),
 362                                      &(buf[size]), burstcnt);
 363                if (rc == 0)
 364                        size += burstcnt;
 365        }
 366
 367        return size;
 368}
 369
 370static int tpm_tis_i2c_recv(struct udevice *dev, u8 *buf, size_t count)
 371{
 372        struct tpm_chip *chip = dev_get_priv(dev);
 373        int size = 0;
 374        int status;
 375        unsigned int expected;
 376        int rc;
 377
 378        status = tpm_tis_i2c_status(dev);
 379        if (status == TPM_STS_COMMAND_READY)
 380                return -EINTR;
 381        if ((status & (TPM_STS_DATA_AVAIL | TPM_STS_VALID)) !=
 382            (TPM_STS_DATA_AVAIL | TPM_STS_VALID))
 383                return -EAGAIN;
 384
 385        debug("...got it;\n");
 386
 387        /* Read first 10 bytes, including tag, paramsize, and result */
 388        size = tpm_tis_i2c_recv_data(dev, buf, TPM_HEADER_SIZE);
 389        if (size < TPM_HEADER_SIZE) {
 390                debug("Unable to read header\n");
 391                return size < 0 ? size : -EIO;
 392        }
 393
 394        expected = get_unaligned_be32(buf + TPM_RSP_SIZE_BYTE);
 395        if ((size_t)expected > count || (size_t)expected < TPM_HEADER_SIZE) {
 396                debug("Error size=%x, expected=%x, count=%x\n", size, expected,
 397                      count);
 398                return -ENOSPC;
 399        }
 400
 401        size += tpm_tis_i2c_recv_data(dev, &buf[TPM_HEADER_SIZE],
 402                                      expected - TPM_HEADER_SIZE);
 403        if (size < expected) {
 404                debug("Unable to read remainder of result\n");
 405                return -ETIMEDOUT;
 406        }
 407
 408        rc = tpm_tis_i2c_wait_for_stat(dev, TPM_STS_VALID, chip->timeout_c,
 409                                       &status);
 410        if (rc)
 411                return rc;
 412        if (status & TPM_STS_DATA_AVAIL) {  /* Retry? */
 413                debug("Error left over data\n");
 414                return -EIO;
 415        }
 416
 417        return size;
 418}
 419
 420static int tpm_tis_i2c_send(struct udevice *dev, const u8 *buf, size_t len)
 421{
 422        struct tpm_chip *chip = dev_get_priv(dev);
 423        int rc, status;
 424        size_t burstcnt;
 425        size_t count = 0;
 426        int retry = 0;
 427        u8 sts = TPM_STS_GO;
 428
 429        debug("%s: len=%d\n", __func__, len);
 430        if (len > TPM_DEV_BUFSIZE)
 431                return -E2BIG;  /* Command is too long for our tpm, sorry */
 432
 433        if (tpm_tis_i2c_request_locality(dev, 0) < 0)
 434                return -EBUSY;
 435
 436        status = tpm_tis_i2c_status(dev);
 437        if ((status & TPM_STS_COMMAND_READY) == 0) {
 438                rc = tpm_tis_i2c_ready(dev);
 439                if (rc)
 440                        return rc;
 441                rc = tpm_tis_i2c_wait_for_stat(dev, TPM_STS_COMMAND_READY,
 442                                               chip->timeout_b, &status);
 443                if (rc)
 444                        return rc;
 445        }
 446
 447        burstcnt = tpm_tis_i2c_get_burstcount(dev);
 448
 449        /* burstcount < 0 -> tpm is busy */
 450        if (burstcnt < 0)
 451                return burstcnt;
 452
 453        while (count < len) {
 454                udelay(300);
 455                if (burstcnt > len - count)
 456                        burstcnt = len - count;
 457
 458#ifdef CONFIG_TPM_TIS_I2C_BURST_LIMITATION
 459                if (retry && burstcnt > CONFIG_TPM_TIS_I2C_BURST_LIMITATION_LEN)
 460                        burstcnt = CONFIG_TPM_TIS_I2C_BURST_LIMITATION_LEN;
 461#endif /* CONFIG_TPM_TIS_I2C_BURST_LIMITATION */
 462
 463                rc = tpm_tis_i2c_write(dev, TPM_DATA_FIFO(chip->locality),
 464                                       &(buf[count]), burstcnt);
 465                if (rc == 0)
 466                        count += burstcnt;
 467                else {
 468                        debug("%s: error\n", __func__);
 469                        if (retry++ > 10)
 470                                return -EIO;
 471                        rc = tpm_tis_i2c_wait_for_stat(dev, TPM_STS_VALID,
 472                                                       chip->timeout_c,
 473                                                       &status);
 474                        if (rc)
 475                                return rc;
 476
 477                        if ((status & TPM_STS_DATA_EXPECT) == 0)
 478                                return -EIO;
 479                }
 480        }
 481
 482        /* Go and do it */
 483        rc = tpm_tis_i2c_write(dev, TPM_STS(chip->locality), &sts, 1);
 484        if (rc < 0)
 485                return rc;
 486        debug("%s: done, rc=%d\n", __func__, rc);
 487
 488        return len;
 489}
 490
 491static int tpm_tis_i2c_cleanup(struct udevice *dev)
 492{
 493        struct tpm_chip *chip = dev_get_priv(dev);
 494
 495        tpm_tis_i2c_ready(dev);
 496        /*
 497         * The TPM needs some time to clean up here,
 498         * so we sleep rather than keeping the bus busy
 499         */
 500        mdelay(2);
 501        tpm_tis_i2c_release_locality(dev, chip->locality, 0);
 502
 503        return 0;
 504}
 505
 506static int tpm_tis_i2c_init(struct udevice *dev)
 507{
 508        struct tpm_chip *chip = dev_get_priv(dev);
 509        u32 vendor;
 510        u32 expected_did_vid;
 511        int rc;
 512
 513        chip->is_open = 1;
 514
 515        /* Default timeouts - these could move to the device tree */
 516        chip->timeout_a = TIS_SHORT_TIMEOUT_MS;
 517        chip->timeout_b = TIS_LONG_TIMEOUT_MS;
 518        chip->timeout_c = TIS_SHORT_TIMEOUT_MS;
 519        chip->timeout_d = TIS_SHORT_TIMEOUT_MS;
 520
 521        rc = tpm_tis_i2c_request_locality(dev, 0);
 522        if (rc < 0)
 523                return rc;
 524
 525        /* Read four bytes from DID_VID register */
 526        if (tpm_tis_i2c_read(dev, TPM_DID_VID(0), (uchar *)&vendor, 4) < 0) {
 527                tpm_tis_i2c_release_locality(dev, 0, 1);
 528                return -EIO;
 529        }
 530
 531        if (chip->chip_type == SLB9635) {
 532                vendor = be32_to_cpu(vendor);
 533                expected_did_vid = TPM_TIS_I2C_DID_VID_9635;
 534        } else {
 535                /* device id and byte order has changed for newer i2c tpms */
 536                expected_did_vid = TPM_TIS_I2C_DID_VID_9645;
 537        }
 538
 539        if (chip->chip_type != UNKNOWN && vendor != expected_did_vid) {
 540                pr_err("Vendor id did not match! ID was %08x\n", vendor);
 541                return -ENODEV;
 542        }
 543
 544        chip->vend_dev = vendor;
 545        debug("1.2 TPM (chip type %s device-id 0x%X)\n",
 546              chip_name[chip->chip_type], vendor >> 16);
 547
 548        /*
 549         * A timeout query to TPM can be placed here.
 550         * Standard timeout values are used so far
 551         */
 552
 553        return 0;
 554}
 555
 556static int tpm_tis_i2c_open(struct udevice *dev)
 557{
 558        struct tpm_chip *chip = dev_get_priv(dev);
 559        int rc;
 560
 561        debug("%s: start\n", __func__);
 562        if (chip->is_open)
 563                return -EBUSY;
 564        rc = tpm_tis_i2c_init(dev);
 565        if (rc < 0)
 566                chip->is_open = 0;
 567
 568        return rc;
 569}
 570
 571static int tpm_tis_i2c_close(struct udevice *dev)
 572{
 573        struct tpm_chip *chip = dev_get_priv(dev);
 574
 575        if (chip->is_open) {
 576                tpm_tis_i2c_release_locality(dev, chip->locality, 1);
 577                chip->is_open = 0;
 578                chip->vend_dev = 0;
 579        }
 580
 581        return 0;
 582}
 583
 584static int tpm_tis_get_desc(struct udevice *dev, char *buf, int size)
 585{
 586        struct tpm_chip *chip = dev_get_priv(dev);
 587
 588        if (size < 50)
 589                return -ENOSPC;
 590
 591        return snprintf(buf, size, "1.2 TPM (%s, chip type %s device-id 0x%x)",
 592                        chip->is_open ? "open" : "closed",
 593                        chip_name[chip->chip_type],
 594                        chip->vend_dev >> 16);
 595}
 596
 597static int tpm_tis_i2c_probe(struct udevice *dev)
 598{
 599        struct tpm_chip_priv *uc_priv = dev_get_uclass_priv(dev);
 600        struct tpm_chip *chip = dev_get_priv(dev);
 601
 602        chip->chip_type = dev_get_driver_data(dev);
 603
 604        /* TODO: These need to be checked and tuned */
 605        uc_priv->duration_ms[TPM_SHORT] = TIS_SHORT_TIMEOUT_MS;
 606        uc_priv->duration_ms[TPM_MEDIUM] = TIS_LONG_TIMEOUT_MS;
 607        uc_priv->duration_ms[TPM_LONG] = TIS_LONG_TIMEOUT_MS;
 608        uc_priv->retry_time_ms = TPM_TIMEOUT_MS;
 609
 610        return 0;
 611}
 612
 613static const struct tpm_ops tpm_tis_i2c_ops = {
 614        .open           = tpm_tis_i2c_open,
 615        .close          = tpm_tis_i2c_close,
 616        .get_desc       = tpm_tis_get_desc,
 617        .send           = tpm_tis_i2c_send,
 618        .recv           = tpm_tis_i2c_recv,
 619        .cleanup        = tpm_tis_i2c_cleanup,
 620};
 621
 622static const struct udevice_id tpm_tis_i2c_ids[] = {
 623        { .compatible = "infineon,slb9635tt", .data = SLB9635 },
 624        { .compatible = "infineon,slb9645tt", .data = SLB9645 },
 625        { }
 626};
 627
 628U_BOOT_DRIVER(tpm_tis_i2c) = {
 629        .name   = "tpm_tis_infineon",
 630        .id     = UCLASS_TPM,
 631        .of_match = tpm_tis_i2c_ids,
 632        .ops    = &tpm_tis_i2c_ops,
 633        .probe  = tpm_tis_i2c_probe,
 634        .priv_auto_alloc_size = sizeof(struct tpm_chip),
 635};
 636