Merge branch 'master' of git://git.denx.de/u-boot-nand-flash
[platform/kernel/u-boot.git] / drivers / tpm / tpm.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  * It is based on the Linux kernel driver tpm.c from Leendert van
12  * Dorn, Dave Safford, Reiner Sailer, and Kyleen Hall.
13  *
14  * Version: 2.1.1
15  *
16  * See file CREDITS for list of people who contributed to this
17  * project.
18  *
19  * This program is free software; you can redistribute it and/or
20  * modify it under the terms of the GNU General Public License as
21  * published by the Free Software Foundation, version 2 of the
22  * License.
23  *
24  * This program is distributed in the hope that it will be useful,
25  * but WITHOUT ANY WARRANTY; without even the implied warranty of
26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
27  * GNU General Public License for more details.
28  *
29  * You should have received a copy of the GNU General Public License
30  * along with this program; if not, write to the Free Software
31  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
32  * MA 02111-1307 USA
33  */
34
35 #include <config.h>
36 #include <common.h>
37 #include <compiler.h>
38 #include <fdtdec.h>
39 #include <i2c.h>
40 #include <tpm.h>
41 #include <asm-generic/errno.h>
42 #include <linux/types.h>
43 #include <linux/unaligned/be_byteshift.h>
44
45 #include "tpm_private.h"
46
47 DECLARE_GLOBAL_DATA_PTR;
48
49 /* TPM configuration */
50 struct tpm {
51         int i2c_bus;
52         int slave_addr;
53         char inited;
54         int old_bus;
55 } tpm;
56
57 /* Global structure for tpm chip data */
58 static struct tpm_chip g_chip;
59
60 enum tpm_duration {
61         TPM_SHORT = 0,
62         TPM_MEDIUM = 1,
63         TPM_LONG = 2,
64         TPM_UNDEFINED,
65 };
66
67 /* Extended error numbers from linux (see errno.h) */
68 #define ECANCELED       125     /* Operation Canceled */
69
70 /* Timer frequency. Corresponds to msec timer resolution*/
71 #define HZ              1000
72
73 #define TPM_MAX_ORDINAL                 243
74 #define TPM_MAX_PROTECTED_ORDINAL       12
75 #define TPM_PROTECTED_ORDINAL_MASK      0xFF
76
77 #define TPM_CMD_COUNT_BYTE      2
78 #define TPM_CMD_ORDINAL_BYTE    6
79
80 /*
81  * Array with one entry per ordinal defining the maximum amount
82  * of time the chip could take to return the result.  The ordinal
83  * designation of short, medium or long is defined in a table in
84  * TCG Specification TPM Main Part 2 TPM Structures Section 17. The
85  * values of the SHORT, MEDIUM, and LONG durations are retrieved
86  * from the chip during initialization with a call to tpm_get_timeouts.
87  */
88 static const u8 tpm_protected_ordinal_duration[TPM_MAX_PROTECTED_ORDINAL] = {
89         TPM_UNDEFINED,          /* 0 */
90         TPM_UNDEFINED,
91         TPM_UNDEFINED,
92         TPM_UNDEFINED,
93         TPM_UNDEFINED,
94         TPM_UNDEFINED,          /* 5 */
95         TPM_UNDEFINED,
96         TPM_UNDEFINED,
97         TPM_UNDEFINED,
98         TPM_UNDEFINED,
99         TPM_SHORT,              /* 10 */
100         TPM_SHORT,
101 };
102
103 static const u8 tpm_ordinal_duration[TPM_MAX_ORDINAL] = {
104         TPM_UNDEFINED,          /* 0 */
105         TPM_UNDEFINED,
106         TPM_UNDEFINED,
107         TPM_UNDEFINED,
108         TPM_UNDEFINED,
109         TPM_UNDEFINED,          /* 5 */
110         TPM_UNDEFINED,
111         TPM_UNDEFINED,
112         TPM_UNDEFINED,
113         TPM_UNDEFINED,
114         TPM_SHORT,              /* 10 */
115         TPM_SHORT,
116         TPM_MEDIUM,
117         TPM_LONG,
118         TPM_LONG,
119         TPM_MEDIUM,             /* 15 */
120         TPM_SHORT,
121         TPM_SHORT,
122         TPM_MEDIUM,
123         TPM_LONG,
124         TPM_SHORT,              /* 20 */
125         TPM_SHORT,
126         TPM_MEDIUM,
127         TPM_MEDIUM,
128         TPM_MEDIUM,
129         TPM_SHORT,              /* 25 */
130         TPM_SHORT,
131         TPM_MEDIUM,
132         TPM_SHORT,
133         TPM_SHORT,
134         TPM_MEDIUM,             /* 30 */
135         TPM_LONG,
136         TPM_MEDIUM,
137         TPM_SHORT,
138         TPM_SHORT,
139         TPM_SHORT,              /* 35 */
140         TPM_MEDIUM,
141         TPM_MEDIUM,
142         TPM_UNDEFINED,
143         TPM_UNDEFINED,
144         TPM_MEDIUM,             /* 40 */
145         TPM_LONG,
146         TPM_MEDIUM,
147         TPM_SHORT,
148         TPM_SHORT,
149         TPM_SHORT,              /* 45 */
150         TPM_SHORT,
151         TPM_SHORT,
152         TPM_SHORT,
153         TPM_LONG,
154         TPM_MEDIUM,             /* 50 */
155         TPM_MEDIUM,
156         TPM_UNDEFINED,
157         TPM_UNDEFINED,
158         TPM_UNDEFINED,
159         TPM_UNDEFINED,          /* 55 */
160         TPM_UNDEFINED,
161         TPM_UNDEFINED,
162         TPM_UNDEFINED,
163         TPM_UNDEFINED,
164         TPM_MEDIUM,             /* 60 */
165         TPM_MEDIUM,
166         TPM_MEDIUM,
167         TPM_SHORT,
168         TPM_SHORT,
169         TPM_MEDIUM,             /* 65 */
170         TPM_UNDEFINED,
171         TPM_UNDEFINED,
172         TPM_UNDEFINED,
173         TPM_UNDEFINED,
174         TPM_SHORT,              /* 70 */
175         TPM_SHORT,
176         TPM_UNDEFINED,
177         TPM_UNDEFINED,
178         TPM_UNDEFINED,
179         TPM_UNDEFINED,          /* 75 */
180         TPM_UNDEFINED,
181         TPM_UNDEFINED,
182         TPM_UNDEFINED,
183         TPM_UNDEFINED,
184         TPM_LONG,               /* 80 */
185         TPM_UNDEFINED,
186         TPM_MEDIUM,
187         TPM_LONG,
188         TPM_SHORT,
189         TPM_UNDEFINED,          /* 85 */
190         TPM_UNDEFINED,
191         TPM_UNDEFINED,
192         TPM_UNDEFINED,
193         TPM_UNDEFINED,
194         TPM_SHORT,              /* 90 */
195         TPM_SHORT,
196         TPM_SHORT,
197         TPM_SHORT,
198         TPM_SHORT,
199         TPM_UNDEFINED,          /* 95 */
200         TPM_UNDEFINED,
201         TPM_UNDEFINED,
202         TPM_UNDEFINED,
203         TPM_UNDEFINED,
204         TPM_MEDIUM,             /* 100 */
205         TPM_SHORT,
206         TPM_SHORT,
207         TPM_UNDEFINED,
208         TPM_UNDEFINED,
209         TPM_UNDEFINED,          /* 105 */
210         TPM_UNDEFINED,
211         TPM_UNDEFINED,
212         TPM_UNDEFINED,
213         TPM_UNDEFINED,
214         TPM_SHORT,              /* 110 */
215         TPM_SHORT,
216         TPM_SHORT,
217         TPM_SHORT,
218         TPM_SHORT,
219         TPM_SHORT,              /* 115 */
220         TPM_SHORT,
221         TPM_SHORT,
222         TPM_UNDEFINED,
223         TPM_UNDEFINED,
224         TPM_LONG,               /* 120 */
225         TPM_LONG,
226         TPM_MEDIUM,
227         TPM_UNDEFINED,
228         TPM_SHORT,
229         TPM_SHORT,              /* 125 */
230         TPM_SHORT,
231         TPM_LONG,
232         TPM_SHORT,
233         TPM_SHORT,
234         TPM_SHORT,              /* 130 */
235         TPM_MEDIUM,
236         TPM_UNDEFINED,
237         TPM_SHORT,
238         TPM_MEDIUM,
239         TPM_UNDEFINED,          /* 135 */
240         TPM_UNDEFINED,
241         TPM_UNDEFINED,
242         TPM_UNDEFINED,
243         TPM_UNDEFINED,
244         TPM_SHORT,              /* 140 */
245         TPM_SHORT,
246         TPM_UNDEFINED,
247         TPM_UNDEFINED,
248         TPM_UNDEFINED,
249         TPM_UNDEFINED,          /* 145 */
250         TPM_UNDEFINED,
251         TPM_UNDEFINED,
252         TPM_UNDEFINED,
253         TPM_UNDEFINED,
254         TPM_SHORT,              /* 150 */
255         TPM_MEDIUM,
256         TPM_MEDIUM,
257         TPM_SHORT,
258         TPM_SHORT,
259         TPM_UNDEFINED,          /* 155 */
260         TPM_UNDEFINED,
261         TPM_UNDEFINED,
262         TPM_UNDEFINED,
263         TPM_UNDEFINED,
264         TPM_SHORT,              /* 160 */
265         TPM_SHORT,
266         TPM_SHORT,
267         TPM_SHORT,
268         TPM_UNDEFINED,
269         TPM_UNDEFINED,          /* 165 */
270         TPM_UNDEFINED,
271         TPM_UNDEFINED,
272         TPM_UNDEFINED,
273         TPM_UNDEFINED,
274         TPM_LONG,               /* 170 */
275         TPM_UNDEFINED,
276         TPM_UNDEFINED,
277         TPM_UNDEFINED,
278         TPM_UNDEFINED,
279         TPM_UNDEFINED,          /* 175 */
280         TPM_UNDEFINED,
281         TPM_UNDEFINED,
282         TPM_UNDEFINED,
283         TPM_UNDEFINED,
284         TPM_MEDIUM,             /* 180 */
285         TPM_SHORT,
286         TPM_MEDIUM,
287         TPM_MEDIUM,
288         TPM_MEDIUM,
289         TPM_MEDIUM,             /* 185 */
290         TPM_SHORT,
291         TPM_UNDEFINED,
292         TPM_UNDEFINED,
293         TPM_UNDEFINED,
294         TPM_UNDEFINED,          /* 190 */
295         TPM_UNDEFINED,
296         TPM_UNDEFINED,
297         TPM_UNDEFINED,
298         TPM_UNDEFINED,
299         TPM_UNDEFINED,          /* 195 */
300         TPM_UNDEFINED,
301         TPM_UNDEFINED,
302         TPM_UNDEFINED,
303         TPM_UNDEFINED,
304         TPM_SHORT,              /* 200 */
305         TPM_UNDEFINED,
306         TPM_UNDEFINED,
307         TPM_UNDEFINED,
308         TPM_SHORT,
309         TPM_SHORT,              /* 205 */
310         TPM_SHORT,
311         TPM_SHORT,
312         TPM_SHORT,
313         TPM_SHORT,
314         TPM_MEDIUM,             /* 210 */
315         TPM_UNDEFINED,
316         TPM_MEDIUM,
317         TPM_MEDIUM,
318         TPM_MEDIUM,
319         TPM_UNDEFINED,          /* 215 */
320         TPM_MEDIUM,
321         TPM_UNDEFINED,
322         TPM_UNDEFINED,
323         TPM_SHORT,
324         TPM_SHORT,              /* 220 */
325         TPM_SHORT,
326         TPM_SHORT,
327         TPM_SHORT,
328         TPM_SHORT,
329         TPM_UNDEFINED,          /* 225 */
330         TPM_UNDEFINED,
331         TPM_UNDEFINED,
332         TPM_UNDEFINED,
333         TPM_UNDEFINED,
334         TPM_SHORT,              /* 230 */
335         TPM_LONG,
336         TPM_MEDIUM,
337         TPM_UNDEFINED,
338         TPM_UNDEFINED,
339         TPM_UNDEFINED,          /* 235 */
340         TPM_UNDEFINED,
341         TPM_UNDEFINED,
342         TPM_UNDEFINED,
343         TPM_UNDEFINED,
344         TPM_SHORT,              /* 240 */
345         TPM_UNDEFINED,
346         TPM_MEDIUM,
347 };
348
349 /* Returns max number of milliseconds to wait */
350 static unsigned long tpm_calc_ordinal_duration(struct tpm_chip *chip,
351                 u32 ordinal)
352 {
353         int duration_idx = TPM_UNDEFINED;
354         int duration = 0;
355
356         if (ordinal < TPM_MAX_ORDINAL) {
357                 duration_idx = tpm_ordinal_duration[ordinal];
358         } else if ((ordinal & TPM_PROTECTED_ORDINAL_MASK) <
359                         TPM_MAX_PROTECTED_ORDINAL) {
360                 duration_idx = tpm_protected_ordinal_duration[
361                                 ordinal & TPM_PROTECTED_ORDINAL_MASK];
362         }
363
364         if (duration_idx != TPM_UNDEFINED)
365                 duration = chip->vendor.duration[duration_idx];
366
367         if (duration <= 0)
368                 return 2 * 60 * HZ; /* Two minutes timeout */
369         else
370                 return duration;
371 }
372
373 static ssize_t tpm_transmit(const unsigned char *buf, size_t bufsiz)
374 {
375         ssize_t rc;
376         u32 count, ordinal;
377         unsigned long start, stop;
378
379         struct tpm_chip *chip = &g_chip;
380
381         /* switch endianess: big->little */
382         count = get_unaligned_be32(buf + TPM_CMD_COUNT_BYTE);
383         ordinal = get_unaligned_be32(buf + TPM_CMD_ORDINAL_BYTE);
384
385         if (count == 0) {
386                 error("no data\n");
387                 return -ENODATA;
388         }
389         if (count > bufsiz) {
390                 error("invalid count value %x %zx\n", count, bufsiz);
391                 return -E2BIG;
392         }
393
394         rc = chip->vendor.send(chip, (u8 *)buf, count);
395         if (rc < 0) {
396                 error("tpm_transmit: tpm_send: error %zd\n", rc);
397                 goto out;
398         }
399
400         if (chip->vendor.irq)
401                 goto out_recv;
402
403         start = get_timer(0);
404         stop = tpm_calc_ordinal_duration(chip, ordinal);
405         do {
406                 debug("waiting for status...\n");
407                 u8 status = chip->vendor.status(chip);
408                 if ((status & chip->vendor.req_complete_mask) ==
409                     chip->vendor.req_complete_val) {
410                         debug("...got it;\n");
411                         goto out_recv;
412                 }
413
414                 if ((status == chip->vendor.req_canceled)) {
415                         error("Operation Canceled\n");
416                         rc = -ECANCELED;
417                         goto out;
418                 }
419                 udelay(TPM_TIMEOUT * 1000);
420         } while (get_timer(start) < stop);
421
422         chip->vendor.cancel(chip);
423         error("Operation Timed out\n");
424         rc = -ETIME;
425         goto out;
426
427 out_recv:
428         debug("out_recv: reading response...\n");
429         rc = chip->vendor.recv(chip, (u8 *)buf, TPM_BUFSIZE);
430         if (rc < 0)
431                 error("tpm_transmit: tpm_recv: error %zd\n", rc);
432
433 out:
434         return rc;
435 }
436
437 static int tpm_open(uint32_t dev_addr)
438 {
439         int rc;
440         if (g_chip.is_open)
441                 return -EBUSY;
442         rc = tpm_vendor_init(dev_addr);
443         if (rc < 0)
444                 g_chip.is_open = 0;
445         return rc;
446 }
447
448 static void tpm_close(void)
449 {
450         if (g_chip.is_open) {
451                 tpm_vendor_cleanup(&g_chip);
452                 g_chip.is_open = 0;
453         }
454 }
455
456 static int tpm_select(void)
457 {
458         int ret;
459
460         tpm.old_bus = i2c_get_bus_num();
461         if (tpm.old_bus != tpm.i2c_bus) {
462                 ret = i2c_set_bus_num(tpm.i2c_bus);
463                 if (ret) {
464                         debug("%s: Fail to set i2c bus %d\n", __func__,
465                               tpm.i2c_bus);
466                         return -1;
467                 }
468         }
469         return 0;
470 }
471
472 static int tpm_deselect(void)
473 {
474         int ret;
475
476         if (tpm.old_bus != i2c_get_bus_num()) {
477                 ret = i2c_set_bus_num(tpm.old_bus);
478                 if (ret) {
479                         debug("%s: Fail to restore i2c bus %d\n",
480                               __func__, tpm.old_bus);
481                         return -1;
482                 }
483         }
484         tpm.old_bus = -1;
485         return 0;
486 }
487
488 /**
489  * Decode TPM configuration.
490  *
491  * @param dev   Returns a configuration of TPM device
492  * @return 0 if ok, -1 on error
493  */
494 static int tpm_decode_config(struct tpm *dev)
495 {
496 #ifdef CONFIG_OF_CONTROL
497         const void *blob = gd->fdt_blob;
498         int node, parent;
499         int i2c_bus;
500
501         node = fdtdec_next_compatible(blob, 0, COMPAT_INFINEON_SLB9635_TPM);
502         if (node < 0) {
503                 node = fdtdec_next_compatible(blob, 0,
504                                 COMPAT_INFINEON_SLB9645_TPM);
505         }
506         if (node < 0) {
507                 debug("%s: Node not found\n", __func__);
508                 return -1;
509         }
510         parent = fdt_parent_offset(blob, node);
511         if (parent < 0) {
512                 debug("%s: Cannot find node parent\n", __func__);
513                 return -1;
514         }
515         i2c_bus = i2c_get_bus_num_fdt(parent);
516         if (i2c_bus < 0)
517                 return -1;
518         dev->i2c_bus = i2c_bus;
519         dev->slave_addr = fdtdec_get_addr(blob, node, "reg");
520 #else
521         dev->i2c_bus = CONFIG_TPM_TIS_I2C_BUS_NUMBER;
522         dev->slave_addr = CONFIG_TPM_TIS_I2C_SLAVE_ADDRESS;
523 #endif
524         return 0;
525 }
526
527 struct tpm_chip *tpm_register_hardware(const struct tpm_vendor_specific *entry)
528 {
529         struct tpm_chip *chip;
530
531         /* Driver specific per-device data */
532         chip = &g_chip;
533         memcpy(&chip->vendor, entry, sizeof(struct tpm_vendor_specific));
534         chip->is_open = 1;
535
536         return chip;
537 }
538
539 int tis_init(void)
540 {
541         if (tpm.inited)
542                 return 0;
543
544         if (tpm_decode_config(&tpm))
545                 return -1;
546
547         if (tpm_select())
548                 return -1;
549
550         /*
551          * Probe TPM twice; the first probing might fail because TPM is asleep,
552          * and the probing can wake up TPM.
553          */
554         if (i2c_probe(tpm.slave_addr) && i2c_probe(tpm.slave_addr)) {
555                 debug("%s: fail to probe i2c addr 0x%x\n", __func__,
556                       tpm.slave_addr);
557                 return -1;
558         }
559
560         tpm_deselect();
561
562         tpm.inited = 1;
563
564         return 0;
565 }
566
567 int tis_open(void)
568 {
569         int rc;
570
571         if (!tpm.inited)
572                 return -1;
573
574         if (tpm_select())
575                 return -1;
576
577         rc = tpm_open(tpm.slave_addr);
578
579         tpm_deselect();
580
581         return rc;
582 }
583
584 int tis_close(void)
585 {
586         if (!tpm.inited)
587                 return -1;
588
589         if (tpm_select())
590                 return -1;
591
592         tpm_close();
593
594         tpm_deselect();
595
596         return 0;
597 }
598
599 int tis_sendrecv(const uint8_t *sendbuf, size_t sbuf_size,
600                 uint8_t *recvbuf, size_t *rbuf_len)
601 {
602         int len;
603         uint8_t buf[4096];
604
605         if (!tpm.inited)
606                 return -1;
607
608         if (sizeof(buf) < sbuf_size)
609                 return -1;
610
611         memcpy(buf, sendbuf, sbuf_size);
612
613         if (tpm_select())
614                 return -1;
615
616         len = tpm_transmit(buf, sbuf_size);
617
618         tpm_deselect();
619
620         if (len < 10) {
621                 *rbuf_len = 0;
622                 return -1;
623         }
624
625         memcpy(recvbuf, buf, len);
626         *rbuf_len = len;
627
628         return 0;
629 }