39652a977c7402e7a339bf3ce45303420f44cf0c
[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  * 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 }