1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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
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
61
62
63
64
65
66
67
68
69
70
71
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
83 for (count = 0; count < MAX_COUNT; count++) {
84 rc = dm_i2c_write(dev, 0, (uchar *)&addrbuf, 1);
85 if (rc == 0)
86 break;
87 udelay(SLEEP_DURATION_US);
88 }
89 if (rc)
90 return rc;
91
92
93
94
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;
101 }
102 } else {
103
104
105
106
107
108
109
110 for (count = 0; count < MAX_COUNT; count++) {
111 rc = dm_i2c_read(dev, addr, buffer, len);
112 if (rc == 0)
113 break;
114 udelay(SLEEP_DURATION_US);
115 }
116 }
117
118
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
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;
148 udelay(sleep_time_us);
149 }
150
151
152 udelay(sleep_time_us);
153 if (rc)
154 return rc;
155
156 return 0;
157}
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
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
184
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;
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
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
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
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
305
306 start = get_timer(0);
307 stop = chip->timeout_d;
308 do {
309
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
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
357 if (burstcnt < 0)
358 return burstcnt;
359
360
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
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) {
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;
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
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
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
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
500
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
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
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
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
552
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
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