e04e8f547baf0694910c4bde1cd0ada9441df77d
[karo-tx-uboot.git] / 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  * tpm_tis_i2c_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 tpm_tis_i2c_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 tpm_tis_i2c_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  * tpm_tis_i2c_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 tpm_tis_i2c_write_generic function.
144  *
145  * Return -EIO on error, 0 on success
146  */
147 static int tpm_tis_i2c_write(u8 addr, u8 *buffer, size_t len)
148 {
149         return tpm_tis_i2c_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 tpm_tis_i2c_write_long(u8 addr, u8 *buffer, size_t len)
158 {
159         return tpm_tis_i2c_write_generic(addr, buffer, len, SLEEP_DURATION_LONG,
160                         MAX_COUNT_LONG);
161 }
162
163 static int tpm_tis_i2c_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 = tpm_tis_i2c_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 tpm_tis_i2c_release_locality(struct tpm_chip *chip, int loc,
182                                          int force)
183 {
184         const u8 mask = TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID;
185         u8 buf;
186
187         if (tpm_tis_i2c_read(TPM_ACCESS(loc), &buf, 1) < 0)
188                 return;
189
190         if (force || (buf & mask) == mask) {
191                 buf = TPM_ACCESS_ACTIVE_LOCALITY;
192                 tpm_tis_i2c_write(TPM_ACCESS(loc), &buf, 1);
193         }
194 }
195
196 static int tpm_tis_i2c_request_locality(struct tpm_chip *chip, int loc)
197 {
198         unsigned long start, stop;
199         u8 buf = TPM_ACCESS_REQUEST_USE;
200         int rc;
201
202         if (tpm_tis_i2c_check_locality(chip, loc) >= 0)
203                 return loc;  /* We already have the locality */
204
205         rc = tpm_tis_i2c_write(TPM_ACCESS(loc), &buf, 1);
206         if (rc)
207                 return rc;
208
209         /* Wait for burstcount */
210         start = get_timer(0);
211         stop = chip->timeout_a;
212         do {
213                 if (tpm_tis_i2c_check_locality(chip, loc) >= 0)
214                         return loc;
215                 udelay(TPM_TIMEOUT * 1000);
216         } while (get_timer(start) < stop);
217
218         return -1;
219 }
220
221 static u8 tpm_tis_i2c_status(struct tpm_chip *chip)
222 {
223         /* NOTE: Since i2c read may fail, return 0 in this case --> time-out */
224         u8 buf;
225
226         if (tpm_tis_i2c_read(TPM_STS(chip->locality), &buf, 1) < 0)
227                 return 0;
228         else
229                 return buf;
230 }
231
232 static void tpm_tis_i2c_ready(struct tpm_chip *chip)
233 {
234         int rc;
235
236         /* This causes the current command to be aborted */
237         u8 buf = TPM_STS_COMMAND_READY;
238
239         debug("%s\n", __func__);
240         rc = tpm_tis_i2c_write_long(TPM_STS(chip->locality), &buf, 1);
241         if (rc)
242                 debug("%s: rc=%d\n", __func__, rc);
243 }
244
245 static ssize_t tpm_tis_i2c_get_burstcount(struct tpm_chip *chip)
246 {
247         unsigned long start, stop;
248         ssize_t burstcnt;
249         u8 addr, buf[3];
250
251         /* Wait for burstcount */
252         /* XXX: Which timeout value? Spec has 2 answers (c & d) */
253         start = get_timer(0);
254         stop = chip->timeout_d;
255         do {
256                 /* Note: STS is little endian */
257                 addr = TPM_STS(chip->locality) + 1;
258                 if (tpm_tis_i2c_read(addr, buf, 3) < 0)
259                         burstcnt = 0;
260                 else
261                         burstcnt = (buf[2] << 16) + (buf[1] << 8) + buf[0];
262
263                 if (burstcnt)
264                         return burstcnt;
265                 udelay(TPM_TIMEOUT * 1000);
266         } while (get_timer(start) < stop);
267
268         return -EBUSY;
269 }
270
271 static int tpm_tis_i2c_wait_for_stat(struct tpm_chip *chip, u8 mask,
272                                      unsigned long timeout, int *status)
273 {
274         unsigned long start, stop;
275
276         /* Check current status */
277         *status = tpm_tis_i2c_status(chip);
278         if ((*status & mask) == mask)
279                 return 0;
280
281         start = get_timer(0);
282         stop = timeout;
283         do {
284                 udelay(TPM_TIMEOUT * 1000);
285                 *status = tpm_tis_i2c_status(chip);
286                 if ((*status & mask) == mask)
287                         return 0;
288         } while (get_timer(start) < stop);
289
290         return -ETIME;
291 }
292
293 static int tpm_tis_i2c_recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
294 {
295         size_t size = 0;
296         ssize_t burstcnt;
297         int rc;
298
299         while (size < count) {
300                 burstcnt = tpm_tis_i2c_get_burstcount(chip);
301
302                 /* burstcount < 0 -> tpm is busy */
303                 if (burstcnt < 0)
304                         return burstcnt;
305
306                 /* Limit received data to max left */
307                 if (burstcnt > (count - size))
308                         burstcnt = count - size;
309
310                 rc = tpm_tis_i2c_read(TPM_DATA_FIFO(chip->locality),
311                                 &(buf[size]), burstcnt);
312                 if (rc == 0)
313                         size += burstcnt;
314         }
315
316         return size;
317 }
318
319 static int tpm_tis_i2c_recv(struct tpm_chip *chip, u8 *buf, size_t count)
320 {
321         int size = 0;
322         int expected, status;
323
324         if (count < TPM_HEADER_SIZE) {
325                 size = -EIO;
326                 goto out;
327         }
328
329         /* Read first 10 bytes, including tag, paramsize, and result */
330         size = tpm_tis_i2c_recv_data(chip, buf, TPM_HEADER_SIZE);
331         if (size < TPM_HEADER_SIZE) {
332                 error("Unable to read header\n");
333                 goto out;
334         }
335
336         expected = get_unaligned_be32(buf + TPM_RSP_SIZE_BYTE);
337         if ((size_t)expected > count) {
338                 error("Error size=%x, expected=%x, count=%x\n", size, expected,
339                       count);
340                 size = -EIO;
341                 goto out;
342         }
343
344         size += tpm_tis_i2c_recv_data(chip, &buf[TPM_HEADER_SIZE],
345                                       expected - TPM_HEADER_SIZE);
346         if (size < expected) {
347                 error("Unable to read remainder of result\n");
348                 size = -ETIME;
349                 goto out;
350         }
351
352         tpm_tis_i2c_wait_for_stat(chip, TPM_STS_VALID, chip->timeout_c,
353                                   &status);
354         if (status & TPM_STS_DATA_AVAIL) {  /* Retry? */
355                 error("Error left over data\n");
356                 size = -EIO;
357                 goto out;
358         }
359
360 out:
361         tpm_tis_i2c_ready(chip);
362         /*
363          * The TPM needs some time to clean up here,
364          * so we sleep rather than keeping the bus busy
365          */
366         udelay(2000);
367         tpm_tis_i2c_release_locality(chip, chip->locality, 0);
368
369         return size;
370 }
371
372 static int tpm_tis_i2c_send(struct tpm_chip *chip, u8 *buf, size_t len)
373 {
374         int rc, status;
375         size_t burstcnt;
376         size_t count = 0;
377         int retry = 0;
378         u8 sts = TPM_STS_GO;
379
380         debug("%s: len=%d\n", __func__, len);
381         if (len > TPM_DEV_BUFSIZE)
382                 return -E2BIG;  /* Command is too long for our tpm, sorry */
383
384         if (tpm_tis_i2c_request_locality(chip, 0) < 0)
385                 return -EBUSY;
386
387         status = tpm_tis_i2c_status(chip);
388         if ((status & TPM_STS_COMMAND_READY) == 0) {
389                 tpm_tis_i2c_ready(chip);
390                 if (tpm_tis_i2c_wait_for_stat(chip, TPM_STS_COMMAND_READY,
391                                               chip->timeout_b, &status) < 0) {
392                         rc = -ETIME;
393                         goto out_err;
394                 }
395         }
396
397         burstcnt = tpm_tis_i2c_get_burstcount(chip);
398
399         /* burstcount < 0 -> tpm is busy */
400         if (burstcnt < 0)
401                 return burstcnt;
402
403         while (count < len) {
404                 udelay(300);
405                 if (burstcnt > len - count)
406                         burstcnt = len - count;
407
408 #ifdef CONFIG_TPM_TIS_I2C_BURST_LIMITATION
409                 if (retry && burstcnt > CONFIG_TPM_TIS_I2C_BURST_LIMITATION)
410                         burstcnt = CONFIG_TPM_TIS_I2C_BURST_LIMITATION;
411 #endif /* CONFIG_TPM_TIS_I2C_BURST_LIMITATION */
412
413                 rc = tpm_tis_i2c_write(TPM_DATA_FIFO(chip->locality),
414                                 &(buf[count]), burstcnt);
415                 if (rc == 0)
416                         count += burstcnt;
417                 else {
418                         debug("%s: error\n", __func__);
419                         if (retry++ > 10) {
420                                 rc = -EIO;
421                                 goto out_err;
422                         }
423                         rc = tpm_tis_i2c_wait_for_stat(chip, TPM_STS_VALID,
424                                                        chip->timeout_c,
425                                                        &status);
426                         if (rc)
427                                 goto out_err;
428
429                         if ((status & TPM_STS_DATA_EXPECT) == 0) {
430                                 rc = -EIO;
431                                 goto out_err;
432                         }
433                 }
434         }
435
436         /* Go and do it */
437         tpm_tis_i2c_write(TPM_STS(chip->locality), &sts, 1);
438         debug("done\n");
439
440         return len;
441
442 out_err:
443         debug("%s: out_err\n", __func__);
444         tpm_tis_i2c_ready(chip);
445         /*
446          * The TPM needs some time to clean up here,
447          * so we sleep rather than keeping the bus busy
448          */
449         udelay(2000);
450         tpm_tis_i2c_release_locality(chip, chip->locality, 0);
451
452         return rc;
453 }
454
455 static enum i2c_chip_type tpm_tis_i2c_chip_type(void)
456 {
457 #if CONFIG_IS_ENABLED(OF_CONTROL)
458         const void *blob = gd->fdt_blob;
459
460         if (fdtdec_next_compatible(blob, 0, COMPAT_INFINEON_SLB9645_TPM) >= 0)
461                 return SLB9645;
462
463         if (fdtdec_next_compatible(blob, 0, COMPAT_INFINEON_SLB9635_TPM) >= 0)
464                 return SLB9635;
465 #endif
466         return UNKNOWN;
467 }
468
469 static int tpm_tis_i2c_init(struct udevice *dev)
470 {
471         struct tpm_chip *chip = &g_chip;
472         u32 vendor;
473         u32 expected_did_vid;
474
475         g_chip.dev = dev;
476         g_chip.chip_type = tpm_tis_i2c_chip_type();
477         chip->is_open = 1;
478
479         /* Disable interrupts (not supported) */
480         chip->irq = 0;
481
482         /* Default timeouts - these could move to the device tree */
483         chip->timeout_a = TIS_SHORT_TIMEOUT;
484         chip->timeout_b = TIS_LONG_TIMEOUT;
485         chip->timeout_c = TIS_SHORT_TIMEOUT;
486         chip->timeout_d = TIS_SHORT_TIMEOUT;
487         chip->req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID;
488         chip->req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID;
489         chip->req_canceled = TPM_STS_COMMAND_READY;
490
491         if (tpm_tis_i2c_request_locality(chip, 0) < 0)
492                 return  -ENODEV;
493
494         /* Read four bytes from DID_VID register */
495         if (tpm_tis_i2c_read(TPM_DID_VID(0), (uchar *)&vendor, 4) < 0) {
496                 tpm_tis_i2c_release_locality(chip, 0, 1);
497                 return -EIO;
498         }
499
500         if (g_chip.chip_type == SLB9635) {
501                 vendor = be32_to_cpu(vendor);
502                 expected_did_vid = TPM_TIS_I2C_DID_VID_9635;
503         } else {
504                 /* device id and byte order has changed for newer i2c tpms */
505                 expected_did_vid = TPM_TIS_I2C_DID_VID_9645;
506         }
507
508         if (g_chip.chip_type != UNKNOWN && vendor != expected_did_vid) {
509                 error("Vendor id did not match! ID was %08x\n", vendor);
510                 return -ENODEV;
511         }
512
513         debug("1.2 TPM (chip type %s device-id 0x%X)\n",
514               chip_name[g_chip.chip_type], vendor >> 16);
515
516         /*
517          * A timeout query to TPM can be placed here.
518          * Standard timeout values are used so far
519          */
520
521         return 0;
522 }
523
524 /* Returns max number of milliseconds to wait */
525 static unsigned long tpm_tis_i2c_calc_ordinal_duration(struct tpm_chip *chip,
526                                                        u32 ordinal)
527 {
528         int duration_idx = TPM_UNDEFINED;
529         int duration = 0;
530
531         if (ordinal < TPM_MAX_ORDINAL) {
532                 duration_idx = tpm_ordinal_duration[ordinal];
533         } else if ((ordinal & TPM_PROTECTED_ORDINAL_MASK) <
534                         TPM_MAX_PROTECTED_ORDINAL) {
535                 duration_idx = tpm_protected_ordinal_duration[
536                                 ordinal & TPM_PROTECTED_ORDINAL_MASK];
537         }
538
539         if (duration_idx != TPM_UNDEFINED)
540                 duration = chip->duration[duration_idx];
541
542         if (duration <= 0)
543                 return 2 * 60 * HZ; /* Two minutes timeout */
544         else
545                 return duration;
546 }
547
548 static ssize_t tpm_tis_i2c_transmit(const unsigned char *buf, size_t bufsiz)
549 {
550         int rc;
551         u32 count, ordinal;
552         unsigned long start, stop;
553
554         struct tpm_chip *chip = &g_chip;
555
556         /* switch endianess: big->little */
557         count = get_unaligned_be32(buf + TPM_CMD_COUNT_BYTE);
558         ordinal = get_unaligned_be32(buf + TPM_CMD_ORDINAL_BYTE);
559
560         if (count == 0) {
561                 error("no data\n");
562                 return -ENODATA;
563         }
564         if (count > bufsiz) {
565                 error("invalid count value %x %zx\n", count, bufsiz);
566                 return -E2BIG;
567         }
568
569         debug("Calling send\n");
570         rc = tpm_tis_i2c_send(chip, (u8 *)buf, count);
571         debug("   ... done calling send\n");
572         if (rc < 0) {
573                 error("tpm_transmit: tpm_send: error %d\n", rc);
574                 goto out;
575         }
576
577         if (chip->irq)
578                 goto out_recv;
579
580         start = get_timer(0);
581         stop = tpm_tis_i2c_calc_ordinal_duration(chip, ordinal);
582         do {
583                 debug("waiting for status... %ld %ld\n", start, stop);
584                 u8 status = tpm_tis_i2c_status(chip);
585                 if ((status & chip->req_complete_mask) ==
586                     chip->req_complete_val) {
587                         debug("...got it;\n");
588                         goto out_recv;
589                 }
590
591                 if (status == chip->req_canceled) {
592                         error("Operation Canceled\n");
593                         rc = -ECANCELED;
594                         goto out;
595                 }
596                 udelay(TPM_TIMEOUT * 1000);
597         } while (get_timer(start) < stop);
598
599         tpm_tis_i2c_ready(chip);
600         error("Operation Timed out\n");
601         rc = -ETIME;
602         goto out;
603
604 out_recv:
605         debug("out_recv: reading response...\n");
606         rc = tpm_tis_i2c_recv(chip, (u8 *)buf, TPM_BUFSIZE);
607         if (rc < 0)
608                 error("tpm_transmit: tpm_recv: error %d\n", rc);
609
610 out:
611         return rc;
612 }
613
614 /**
615  * Decode TPM configuration.
616  *
617  * @param dev   Returns a configuration of TPM device
618  * @return 0 if ok, -1 on error
619  */
620 static int tpm_tis_i2c_decode_config(struct tpm_chip *chip)
621 {
622         const void *blob = gd->fdt_blob;
623         struct udevice *bus;
624         int chip_addr;
625         int parent;
626         int node;
627         int ret;
628
629         node = fdtdec_next_compatible(blob, 0, COMPAT_INFINEON_SLB9635_TPM);
630         if (node < 0) {
631                 node = fdtdec_next_compatible(blob, 0,
632                                 COMPAT_INFINEON_SLB9645_TPM);
633         }
634         if (node < 0) {
635                 debug("%s: Node not found\n", __func__);
636                 return -1;
637         }
638         parent = fdt_parent_offset(blob, node);
639         if (parent < 0) {
640                 debug("%s: Cannot find node parent\n", __func__);
641                 return -1;
642         }
643
644         /*
645          * TODO(sjg@chromium.org): Remove this when driver model supports
646          * TPMs
647          */
648         ret = uclass_get_device_by_of_offset(UCLASS_I2C, parent, &bus);
649         if (ret) {
650                 debug("Cannot find bus for node '%s: ret=%d'\n",
651                       fdt_get_name(blob, parent, NULL), ret);
652                 return ret;
653         }
654
655         chip_addr = fdtdec_get_int(blob, node, "reg", -1);
656         if (chip_addr == -1) {
657                 debug("Cannot find reg property for node '%s: ret=%d'\n",
658                       fdt_get_name(blob, node, NULL), ret);
659                 return ret;
660         }
661         /*
662          * TODO(sjg@chromium.org): Older TPMs will need to use the older method
663          * in tpm_tis_i2c_read() so the offset length needs to be 0 here.
664          */
665         ret = i2c_get_chip(bus, chip_addr, 1, &chip->dev);
666         if (ret) {
667                 debug("Cannot find device for node '%s: ret=%d'\n",
668                       fdt_get_name(blob, node, NULL), ret);
669                 return ret;
670         }
671
672         return 0;
673 }
674
675 int tis_init(void)
676 {
677         if (g_chip.inited)
678                 return 0;
679
680         if (tpm_tis_i2c_decode_config(&g_chip))
681                 return -1;
682
683         debug("%s: done\n", __func__);
684
685         g_chip.inited = 1;
686
687         return 0;
688 }
689
690 int tis_open(void)
691 {
692         int rc;
693
694         if (!g_chip.inited)
695                 return -1;
696
697         debug("%s: start\n", __func__);
698         if (g_chip.is_open)
699                 return -EBUSY;
700         rc = tpm_tis_i2c_init(g_chip.dev);
701         if (rc < 0)
702                 g_chip.is_open = 0;
703
704         return rc;
705 }
706
707 int tis_close(void)
708 {
709         if (!g_chip.inited)
710                 return -1;
711
712         if (g_chip.is_open) {
713                 tpm_tis_i2c_release_locality(&g_chip, g_chip.locality, 1);
714                 g_chip.is_open = 0;
715         }
716
717         return 0;
718 }
719
720 int tis_sendrecv(const uint8_t *sendbuf, size_t sbuf_size,
721                 uint8_t *recvbuf, size_t *rbuf_len)
722 {
723         int len;
724         uint8_t buf[4096];
725
726         if (!g_chip.inited)
727                 return -1;
728
729         if (sizeof(buf) < sbuf_size)
730                 return -1;
731
732         memcpy(buf, sendbuf, sbuf_size);
733
734         len = tpm_tis_i2c_transmit(buf, sbuf_size);
735
736         if (len < 10) {
737                 *rbuf_len = 0;
738                 return -1;
739         }
740
741         memcpy(recvbuf, buf, len);
742         *rbuf_len = len;
743
744         return 0;
745 }