drivers/tpm/tpm_tis_i2c.c

   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 <linux/compiler.h>
  27 #include <i2c.h>
  28 #include <tpm.h>
  29 #include <asm-generic/errno.h>
  30 #include <linux/types.h>
  31 #include <linux/unaligned/be_byteshift.h>
  32
  33 #include "tpm_tis_i2c.h"
  34
  35 DECLARE_GLOBAL_DATA_PTR;
  36
  37 static const char * const chip_name[] = {
  38         [SLB9635] = "slb9635tt",
  39         [SLB9645] = "slb9645tt",
  40         [UNKNOWN] = "unknown/fallback to slb9635",
  41 };
  42
  43 static struct tpm_chip g_chip;
  44
  45 /*
  46  * iic_tpm_read() - read from TPM register
  47  * @addr: register address to read from
  48  * @buffer: provided by caller
  49  * @len: number of bytes to read
  50  *
  51  * Read len bytes from TPM register and put them into
  52  * buffer (little-endian format, i.e. first byte is put into buffer[0]).
  53  *
  54  * NOTE: TPM is big-endian for multi-byte values. Multi-byte
  55  * values have to be swapped.
  56  *
  57  * Return -EIO on error, 0 on success.
  58  */
  59 static int iic_tpm_read(u8 addr, u8 *buffer, size_t len)
  60 {
  61         int rc;
  62         int count;
  63         uint32_t addrbuf = addr;
  64
  65         if ((g_chip.chip_type == SLB9635) || (g_chip.chip_type == UNKNOWN)) {
  66                 /* slb9635 protocol should work in both cases */
  67                 for (count = 0; count < MAX_COUNT; count++) {
  68                         rc = dm_i2c_write(g_chip.dev, 0, (uchar *)&addrbuf, 1);
  69                         if (rc == 0)
  70                                 break;  /* Success, break to skip sleep */
  71                         udelay(SLEEP_DURATION);
  72                 }
  73                 if (rc)
  74                         return -rc;
  75
  76                 /* After the TPM has successfully received the register address
  77                  * it needs some time, thus we're sleeping here again, before
  78                  * retrieving the data
  79                  */
  80                 for (count = 0; count < MAX_COUNT; count++) {
  81                         udelay(SLEEP_DURATION);
  82                         rc = dm_i2c_read(g_chip.dev, 0, buffer, len);
  83                         if (rc == 0)
  84                                 break;  /* success, break to skip sleep */
  85                 }
  86         } else {
  87                 /*
  88                  * Use a combined read for newer chips.
  89                  * Unfortunately the smbus functions are not suitable due to
  90                  * the 32 byte limit of the smbus.
  91                  * Retries should usually not be needed, but are kept just to
  92                  * be safe on the safe side.
  93                  */
  94                 for (count = 0; count < MAX_COUNT; count++) {
  95                         rc = dm_i2c_read(g_chip.dev, addr, buffer, len);
  96                         if (rc == 0)
  97                                 break;  /* break here to skip sleep */
  98                         udelay(SLEEP_DURATION);
  99                 }
 100         }
 101
 102         /* Take care of 'guard time' */
 103         udelay(SLEEP_DURATION);
 104         if (rc)
 105                 return -rc;
 106
 107         return 0;
 108 }
 109
 110 static int iic_tpm_write_generic(u8 addr, u8 *buffer, size_t len,
 111                 unsigned int sleep_time, u8 max_count)
 112 {
 113         int rc = 0;
 114         int count;
 115
 116         for (count = 0; count < max_count; count++) {
 117                 rc = dm_i2c_write(g_chip.dev, addr, buffer, len);
 118                 if (rc == 0)
 119                         break;  /* Success, break to skip sleep */
 120                 udelay(sleep_time);
 121         }
 122
 123         /* take care of 'guard time' */
 124         udelay(sleep_time);
 125         if (rc)
 126                 return -rc;
 127
 128         return 0;
 129 }
 130
 131 /*
 132  * iic_tpm_write() - write to TPM register
 133  * @addr: register address to write to
 134  * @buffer: containing data to be written
 135  * @len: number of bytes to write
 136  *
 137  * Write len bytes from provided buffer to TPM register (little
 138  * endian format, i.e. buffer[0] is written as first byte).
 139  *
 140  * NOTE: TPM is big-endian for multi-byte values. Multi-byte
 141  * values have to be swapped.
 142  *
 143  * NOTE: use this function instead of the iic_tpm_write_generic function.
 144  *
 145  * Return -EIO on error, 0 on success
 146  */
 147 static int iic_tpm_write(u8 addr, u8 *buffer, size_t len)
 148 {
 149         return iic_tpm_write_generic(addr, buffer, len, SLEEP_DURATION,
 150                         MAX_COUNT);
 151 }
 152
 153 /*
 154  * This function is needed especially for the cleanup situation after
 155  * sending TPM_READY
 156  */
 157 static int iic_tpm_write_long(u8 addr, u8 *buffer, size_t len)
 158 {
 159         return iic_tpm_write_generic(addr, buffer, len, SLEEP_DURATION_LONG,
 160                         MAX_COUNT_LONG);
 161 }
 162
 163 static int check_locality(struct tpm_chip *chip, int loc)
 164 {
 165         const u8 mask = TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID;
 166         u8 buf;
 167         int rc;
 168
 169         rc = iic_tpm_read(TPM_ACCESS(loc), &buf, 1);
 170         if (rc < 0)
 171                 return rc;
 172
 173         if ((buf & mask) == mask) {
 174                 chip->locality = loc;
 175                 return loc;
 176         }
 177
 178         return -1;
 179 }
 180
 181 static void release_locality(struct tpm_chip *chip, int loc, int force)
 182 {
 183         const u8 mask = TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID;
 184         u8 buf;
 185
 186         if (iic_tpm_read(TPM_ACCESS(loc), &buf, 1) < 0)
 187                 return;
 188
 189         if (force || (buf & mask) == mask) {
 190                 buf = TPM_ACCESS_ACTIVE_LOCALITY;
 191                 iic_tpm_write(TPM_ACCESS(loc), &buf, 1);
 192         }
 193 }
 194
 195 static int request_locality(struct tpm_chip *chip, int loc)
 196 {
 197         unsigned long start, stop;
 198         u8 buf = TPM_ACCESS_REQUEST_USE;
 199         int rc;
 200
 201         if (check_locality(chip, loc) >= 0)
 202                 return loc;  /* We already have the locality */
 203
 204         rc = iic_tpm_write(TPM_ACCESS(loc), &buf, 1);
 205         if (rc)
 206                 return rc;
 207
 208         /* Wait for burstcount */
 209         start = get_timer(0);
 210         stop = chip->timeout_a;
 211         do {
 212                 if (check_locality(chip, loc) >= 0)
 213                         return loc;
 214                 udelay(TPM_TIMEOUT * 1000);
 215         } while (get_timer(start) < stop);
 216
 217         return -1;
 218 }
 219
 220 static u8 tpm_tis_i2c_status(struct tpm_chip *chip)
 221 {
 222         /* NOTE: Since i2c read may fail, return 0 in this case --> time-out */
 223         u8 buf;
 224
 225         if (iic_tpm_read(TPM_STS(chip->locality), &buf, 1) < 0)
 226                 return 0;
 227         else
 228                 return buf;
 229 }
 230
 231 static void tpm_tis_i2c_ready(struct tpm_chip *chip)
 232 {
 233         int rc;
 234
 235         /* This causes the current command to be aborted */
 236         u8 buf = TPM_STS_COMMAND_READY;
 237
 238         debug("%s\n", __func__);
 239         rc = iic_tpm_write_long(TPM_STS(chip->locality), &buf, 1);
 240         if (rc)
 241                 debug("%s: rc=%d\n", __func__, rc);
 242 }
 243
 244 static ssize_t get_burstcount(struct tpm_chip *chip)
 245 {
 246         unsigned long start, stop;
 247         ssize_t burstcnt;
 248         u8 addr, buf[3];
 249
 250         /* Wait for burstcount */
 251         /* XXX: Which timeout value? Spec has 2 answers (c & d) */
 252         start = get_timer(0);
 253         stop = chip->timeout_d;
 254         do {
 255                 /* Note: STS is little endian */
 256                 addr = TPM_STS(chip->locality) + 1;
 257                 if (iic_tpm_read(addr, buf, 3) < 0)
 258                         burstcnt = 0;
 259                 else
 260                         burstcnt = (buf[2] << 16) + (buf[1] << 8) + buf[0];
 261
 262                 if (burstcnt)
 263                         return burstcnt;
 264                 udelay(TPM_TIMEOUT * 1000);
 265         } while (get_timer(start) < stop);
 266
 267         return -EBUSY;
 268 }
 269
 270 static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout,
 271                 int *status)
 272 {
 273         unsigned long start, stop;
 274
 275         /* Check current status */
 276         *status = tpm_tis_i2c_status(chip);
 277         if ((*status & mask) == mask)
 278                 return 0;
 279
 280         start = get_timer(0);
 281         stop = timeout;
 282         do {
 283                 udelay(TPM_TIMEOUT * 1000);
 284                 *status = tpm_tis_i2c_status(chip);
 285                 if ((*status & mask) == mask)
 286                         return 0;
 287         } while (get_timer(start) < stop);
 288
 289         return -ETIME;
 290 }
 291
 292 static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
 293 {
 294         size_t size = 0;
 295         ssize_t burstcnt;
 296         int rc;
 297
 298         while (size < count) {
 299                 burstcnt = get_burstcount(chip);
 300
 301                 /* burstcount < 0 -> tpm is busy */
 302                 if (burstcnt < 0)
 303                         return burstcnt;
 304
 305                 /* Limit received data to max left */
 306                 if (burstcnt > (count - size))
 307                         burstcnt = count - size;
 308
 309                 rc = iic_tpm_read(TPM_DATA_FIFO(chip->locality),
 310                                 &(buf[size]), burstcnt);
 311                 if (rc == 0)
 312                         size += burstcnt;
 313         }
 314
 315         return size;
 316 }
 317
 318 static int tpm_tis_i2c_recv(struct tpm_chip *chip, u8 *buf, size_t count)
 319 {
 320         int size = 0;
 321         int expected, status;
 322
 323         if (count < TPM_HEADER_SIZE) {
 324                 size = -EIO;
 325                 goto out;
 326         }
 327
 328         /* Read first 10 bytes, including tag, paramsize, and result */
 329         size = recv_data(chip, buf, TPM_HEADER_SIZE);
 330         if (size < TPM_HEADER_SIZE) {
 331                 error("Unable to read header\n");
 332                 goto out;
 333         }
 334
 335         expected = get_unaligned_be32(buf + TPM_RSP_SIZE_BYTE);
 336         if ((size_t)expected > count) {
 337                 error("Error size=%x, expected=%x, count=%x\n", size, expected,
 338                       count);
 339                 size = -EIO;
 340                 goto out;
 341         }
 342
 343         size += recv_data(chip, &buf[TPM_HEADER_SIZE],
 344                         expected - TPM_HEADER_SIZE);
 345         if (size < expected) {
 346                 error("Unable to read remainder of result\n");
 347                 size = -ETIME;
 348                 goto out;
 349         }
 350
 351         wait_for_stat(chip, TPM_STS_VALID, chip->timeout_c, &status);
 352         if (status & TPM_STS_DATA_AVAIL) {  /* Retry? */
 353                 error("Error left over data\n");
 354                 size = -EIO;
 355                 goto out;
 356         }
 357
 358 out:
 359         tpm_tis_i2c_ready(chip);
 360         /*
 361          * The TPM needs some time to clean up here,
 362          * so we sleep rather than keeping the bus busy
 363          */
 364         udelay(2000);
 365         release_locality(chip, chip->locality, 0);
 366
 367         return size;
 368 }
 369
 370 static int tpm_tis_i2c_send(struct tpm_chip *chip, u8 *buf, size_t len)
 371 {
 372         int rc, status;
 373         size_t burstcnt;
 374         size_t count = 0;
 375         int retry = 0;
 376         u8 sts = TPM_STS_GO;
 377
 378         debug("%s: len=%d\n", __func__, len);
 379         if (len > TPM_DEV_BUFSIZE)
 380                 return -E2BIG;  /* Command is too long for our tpm, sorry */
 381
 382         if (request_locality(chip, 0) < 0)
 383                 return -EBUSY;
 384
 385         status = tpm_tis_i2c_status(chip);
 386         if ((status & TPM_STS_COMMAND_READY) == 0) {
 387                 tpm_tis_i2c_ready(chip);
 388                 if (wait_for_stat(chip, TPM_STS_COMMAND_READY,
 389                                   chip->timeout_b, &status) < 0) {
 390                         rc = -ETIME;
 391                         goto out_err;
 392                 }
 393         }
 394
 395         burstcnt = get_burstcount(chip);
 396
 397         /* burstcount < 0 -> tpm is busy */
 398         if (burstcnt < 0)
 399                 return burstcnt;
 400
 401         while (count < len) {
 402                 udelay(300);
 403                 if (burstcnt > len - count)
 404                         burstcnt = len - count;
 405
 406 #ifdef CONFIG_TPM_TIS_I2C_BURST_LIMITATION
 407                 if (retry && burstcnt > CONFIG_TPM_TIS_I2C_BURST_LIMITATION)
 408                         burstcnt = CONFIG_TPM_TIS_I2C_BURST_LIMITATION;
 409 #endif /* CONFIG_TPM_TIS_I2C_BURST_LIMITATION */
 410
 411                 rc = iic_tpm_write(TPM_DATA_FIFO(chip->locality),
 412                                 &(buf[count]), burstcnt);
 413                 if (rc == 0)
 414                         count += burstcnt;
 415                 else {
 416                         debug("%s: error\n", __func__);
 417                         if (retry++ > 10) {
 418                                 rc = -EIO;
 419                                 goto out_err;
 420                         }
 421                         rc = wait_for_stat(chip, TPM_STS_VALID,
 422                                            chip->timeout_c, &status);
 423                         if (rc)
 424                                 goto out_err;
 425
 426                         if ((status & TPM_STS_DATA_EXPECT) == 0) {
 427                                 rc = -EIO;
 428                                 goto out_err;
 429                         }
 430                 }
 431         }
 432
 433         /* Go and do it */
 434         iic_tpm_write(TPM_STS(chip->locality), &sts, 1);
 435         debug("done\n");
 436
 437         return len;
 438
 439 out_err:
 440         debug("%s: out_err\n", __func__);
 441         tpm_tis_i2c_ready(chip);
 442         /*
 443          * The TPM needs some time to clean up here,
 444          * so we sleep rather than keeping the bus busy
 445          */
 446         udelay(2000);
 447         release_locality(chip, chip->locality, 0);
 448
 449         return rc;
 450 }
 451
 452 static enum i2c_chip_type tpm_tis_i2c_chip_type(void)
 453 {
 454 #if CONFIG_IS_ENABLED(OF_CONTROL)
 455         const void *blob = gd->fdt_blob;
 456
 457         if (fdtdec_next_compatible(blob, 0, COMPAT_INFINEON_SLB9645_TPM) >= 0)
 458                 return SLB9645;
 459
 460         if (fdtdec_next_compatible(blob, 0, COMPAT_INFINEON_SLB9635_TPM) >= 0)
 461                 return SLB9635;
 462 #endif
 463         return UNKNOWN;
 464 }
 465
 466 static int tpm_tis_i2c_init(struct udevice *dev)
 467 {
 468         struct tpm_chip *chip = &g_chip;
 469         u32 vendor;
 470         u32 expected_did_vid;
 471
 472         g_chip.dev = dev;
 473         g_chip.chip_type = tpm_tis_i2c_chip_type();
 474         chip->is_open = 1;
 475
 476         /* Disable interrupts (not supported) */
 477         chip->irq = 0;
 478
 479         /* Default timeouts */
 480         chip->timeout_a = TIS_SHORT_TIMEOUT;
 481         chip->timeout_b = TIS_LONG_TIMEOUT;
 482         chip->timeout_c = TIS_SHORT_TIMEOUT;
 483         chip->timeout_d = TIS_SHORT_TIMEOUT;
 484         chip->req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID;
 485         chip->req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID;
 486         chip->req_canceled = TPM_STS_COMMAND_READY;
 487
 488         if (request_locality(chip, 0) < 0)
 489                 return  -ENODEV;
 490
 491         /* Read four bytes from DID_VID register */
 492         if (iic_tpm_read(TPM_DID_VID(0), (uchar *)&vendor, 4) < 0) {
 493                 release_locality(chip, 0, 1);
 494                 return -EIO;
 495         }
 496
 497         if (g_chip.chip_type == SLB9635) {
 498                 vendor = be32_to_cpu(vendor);
 499                 expected_did_vid = TPM_TIS_I2C_DID_VID_9635;
 500         } else {
 501                 /* device id and byte order has changed for newer i2c tpms */
 502                 expected_did_vid = TPM_TIS_I2C_DID_VID_9645;
 503         }
 504
 505         if (g_chip.chip_type != UNKNOWN && vendor != expected_did_vid) {
 506                 error("Vendor id did not match! ID was %08x\n", vendor);
 507                 return -ENODEV;
 508         }
 509
 510         debug("1.2 TPM (chip type %s device-id 0x%X)\n",
 511               chip_name[g_chip.chip_type], vendor >> 16);
 512
 513         /*
 514          * A timeout query to TPM can be placed here.
 515          * Standard timeout values are used so far
 516          */
 517
 518         return 0;
 519 }
 520
 521 /* Returns max number of milliseconds to wait */
 522 static unsigned long tpm_calc_ordinal_duration(struct tpm_chip *chip,
 523                 u32 ordinal)
 524 {
 525         int duration_idx = TPM_UNDEFINED;
 526         int duration = 0;
 527
 528         if (ordinal < TPM_MAX_ORDINAL) {
 529                 duration_idx = tpm_ordinal_duration[ordinal];
 530         } else if ((ordinal & TPM_PROTECTED_ORDINAL_MASK) <
 531                         TPM_MAX_PROTECTED_ORDINAL) {
 532                 duration_idx = tpm_protected_ordinal_duration[
 533                                 ordinal & TPM_PROTECTED_ORDINAL_MASK];
 534         }
 535
 536         if (duration_idx != TPM_UNDEFINED)
 537                 duration = chip->duration[duration_idx];
 538
 539         if (duration <= 0)
 540                 return 2 * 60 * HZ; /* Two minutes timeout */
 541         else
 542                 return duration;
 543 }
 544
 545 static ssize_t tpm_transmit(const unsigned char *buf, size_t bufsiz)
 546 {
 547         int rc;
 548         u32 count, ordinal;
 549         unsigned long start, stop;
 550
 551         struct tpm_chip *chip = &g_chip;
 552
 553         /* switch endianess: big->little */
 554         count = get_unaligned_be32(buf + TPM_CMD_COUNT_BYTE);
 555         ordinal = get_unaligned_be32(buf + TPM_CMD_ORDINAL_BYTE);
 556
 557         if (count == 0) {
 558                 error("no data\n");
 559                 return -ENODATA;
 560         }
 561         if (count > bufsiz) {
 562                 error("invalid count value %x %zx\n", count, bufsiz);
 563                 return -E2BIG;
 564         }
 565
 566         debug("Calling send\n");
 567         rc = tpm_tis_i2c_send(chip, (u8 *)buf, count);
 568         debug("   ... done calling send\n");
 569         if (rc < 0) {
 570                 error("tpm_transmit: tpm_send: error %d\n", rc);
 571                 goto out;
 572         }
 573
 574         if (chip->irq)
 575                 goto out_recv;
 576
 577         start = get_timer(0);
 578         stop = tpm_calc_ordinal_duration(chip, ordinal);
 579         do {
 580                 debug("waiting for status... %ld %ld\n", start, stop);
 581                 u8 status = tpm_tis_i2c_status(chip);
 582                 if ((status & chip->req_complete_mask) ==
 583                     chip->req_complete_val) {
 584                         debug("...got it;\n");
 585                         goto out_recv;
 586                 }
 587
 588                 if (status == chip->req_canceled) {
 589                         error("Operation Canceled\n");
 590                         rc = -ECANCELED;
 591                         goto out;
 592                 }
 593                 udelay(TPM_TIMEOUT * 1000);
 594         } while (get_timer(start) < stop);
 595
 596         tpm_tis_i2c_ready(chip);
 597         error("Operation Timed out\n");
 598         rc = -ETIME;
 599         goto out;
 600
 601 out_recv:
 602         debug("out_recv: reading response...\n");
 603         rc = tpm_tis_i2c_recv(chip, (u8 *)buf, TPM_BUFSIZE);
 604         if (rc < 0)
 605                 error("tpm_transmit: tpm_recv: error %d\n", rc);
 606
 607 out:
 608         return rc;
 609 }
 610
 611 static int tpm_open_dev(struct udevice *dev)
 612 {
 613         int rc;
 614
 615         debug("%s: start\n", __func__);
 616         if (g_chip.is_open)
 617                 return -EBUSY;
 618         rc = tpm_tis_i2c_init(dev);
 619         if (rc < 0)
 620                 g_chip.is_open = 0;
 621         return rc;
 622 }
 623
 624 static void tpm_close(void)
 625 {
 626         if (g_chip.is_open) {
 627                 release_locality(&g_chip, g_chip.locality, 1);
 628                 g_chip.is_open = 0;
 629         }
 630 }
 631
 632 /**
 633  * Decode TPM configuration.
 634  *
 635  * @param dev   Returns a configuration of TPM device
 636  * @return 0 if ok, -1 on error
 637  */
 638 static int tpm_decode_config(struct tpm_chip *chip)
 639 {
 640         const void *blob = gd->fdt_blob;
 641         struct udevice *bus;
 642         int chip_addr;
 643         int parent;
 644         int node;
 645         int ret;
 646
 647         node = fdtdec_next_compatible(blob, 0, COMPAT_INFINEON_SLB9635_TPM);
 648         if (node < 0) {
 649                 node = fdtdec_next_compatible(blob, 0,
 650                                 COMPAT_INFINEON_SLB9645_TPM);
 651         }
 652         if (node < 0) {
 653                 debug("%s: Node not found\n", __func__);
 654                 return -1;
 655         }
 656         parent = fdt_parent_offset(blob, node);
 657         if (parent < 0) {
 658                 debug("%s: Cannot find node parent\n", __func__);
 659                 return -1;
 660         }
 661
 662         /*
 663          * TODO(sjg@chromium.org): Remove this when driver model supports
 664          * TPMs
 665          */
 666         ret = uclass_get_device_by_of_offset(UCLASS_I2C, parent, &bus);
 667         if (ret) {
 668                 debug("Cannot find bus for node '%s: ret=%d'\n",
 669                       fdt_get_name(blob, parent, NULL), ret);
 670                 return ret;
 671         }
 672
 673         chip_addr = fdtdec_get_int(blob, node, "reg", -1);
 674         if (chip_addr == -1) {
 675                 debug("Cannot find reg property for node '%s: ret=%d'\n",
 676                       fdt_get_name(blob, node, NULL), ret);
 677                 return ret;
 678         }
 679         /*
 680          * TODO(sjg@chromium.org): Older TPMs will need to use the older method
 681          * in iic_tpm_read() so the offset length needs to be 0 here.
 682          */
 683         ret = i2c_get_chip(bus, chip_addr, 1, &chip->dev);
 684         if (ret) {
 685                 debug("Cannot find device for node '%s: ret=%d'\n",
 686                       fdt_get_name(blob, node, NULL), ret);
 687                 return ret;
 688         }
 689
 690         return 0;
 691 }
 692
 693 int tis_init(void)
 694 {
 695         if (g_chip.inited)
 696                 return 0;
 697
 698         if (tpm_decode_config(&g_chip))
 699                 return -1;
 700
 701         debug("%s: done\n", __func__);
 702
 703         g_chip.inited = 1;
 704
 705         return 0;
 706 }
 707
 708 int tis_open(void)
 709 {
 710         int rc;
 711
 712         if (!g_chip.inited)
 713                 return -1;
 714
 715         rc = tpm_open_dev(g_chip.dev);
 716
 717         return rc;
 718 }
 719
 720 int tis_close(void)
 721 {
 722         if (!g_chip.inited)
 723                 return -1;
 724
 725         tpm_close();
 726
 727         return 0;
 728 }
 729
 730 int tis_sendrecv(const uint8_t *sendbuf, size_t sbuf_size,
 731                 uint8_t *recvbuf, size_t *rbuf_len)
 732 {
 733         int len;
 734         uint8_t buf[4096];
 735
 736         if (!g_chip.inited)
 737                 return -1;
 738
 739         if (sizeof(buf) < sbuf_size)
 740                 return -1;
 741
 742         memcpy(buf, sendbuf, sbuf_size);
 743
 744         len = tpm_transmit(buf, sbuf_size);
 745
 746         if (len < 10) {
 747                 *rbuf_len = 0;
 748                 return -1;
 749         }
 750
 751         memcpy(recvbuf, buf, len);
 752         *rbuf_len = len;
 753
 754         return 0;
 755 }