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