?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.8-rc8
[linux/fpc-iii.git] / drivers / char / tpm / tpm-interface.c
blob1abe2d7a2610708cc9f1101b83f248b6d3f058c0
1 /*
2 * Copyright (C) 2004 IBM Corporation
3 * Copyright (C) 2014 Intel Corporation
4 *
5 * Authors:
6 * Leendert van Doorn <leendert@watson.ibm.com>
7 * Dave Safford <safford@watson.ibm.com>
8 * Reiner Sailer <sailer@watson.ibm.com>
9 * Kylene Hall <kjhall@us.ibm.com>
10 *
11 * Maintained by: <tpmdd-devel@lists.sourceforge.net>
12 *
13 * Device driver for TCG/TCPA TPM (trusted platform module).
14 * Specifications at www.trustedcomputinggroup.org
15 *
16 * This program is free software; you can redistribute it and/or
17 * modify it under the terms of the GNU General Public License as
18 * published by the Free Software Foundation, version 2 of the
19 * License.
20 *
21 * Note, the TPM chip is not interrupt driven (only polling)
22 * and can have very long timeouts (minutes!). Hence the unusual
23 * calls to msleep.
24 *
25 */
26
27 #include <linux/poll.h>
28 #include <linux/slab.h>
29 #include <linux/mutex.h>
30 #include <linux/spinlock.h>
31 #include <linux/freezer.h>
32
33 #include "tpm.h"
34 #include "tpm_eventlog.h"
35
36 #define TPM_MAX_ORDINAL 243
37 #define TSC_MAX_ORDINAL 12
38 #define TPM_PROTECTED_COMMAND 0x00
39 #define TPM_CONNECTION_COMMAND 0x40
40
41 /*
42 * Bug workaround - some TPM's don't flush the most
43 * recently changed pcr on suspend, so force the flush
44 * with an extend to the selected _unused_ non-volatile pcr.
45 */
46 static int tpm_suspend_pcr;
47 module_param_named(suspend_pcr, tpm_suspend_pcr, uint, 0644);
48 MODULE_PARM_DESC(suspend_pcr,
49 "PCR to use for dummy writes to faciltate flush on suspend.");
50
51 /*
52 * Array with one entry per ordinal defining the maximum amount
53 * of time the chip could take to return the result. The ordinal
54 * designation of short, medium or long is defined in a table in
55 * TCG Specification TPM Main Part 2 TPM Structures Section 17. The
56 * values of the SHORT, MEDIUM, and LONG durations are retrieved
57 * from the chip during initialization with a call to tpm_get_timeouts.
58 */
59 static const u8 tpm_ordinal_duration[TPM_MAX_ORDINAL] = {
60 TPM_UNDEFINED, /* 0 */
61 TPM_UNDEFINED,
62 TPM_UNDEFINED,
63 TPM_UNDEFINED,
64 TPM_UNDEFINED,
65 TPM_UNDEFINED, /* 5 */
66 TPM_UNDEFINED,
67 TPM_UNDEFINED,
68 TPM_UNDEFINED,
69 TPM_UNDEFINED,
70 TPM_SHORT, /* 10 */
71 TPM_SHORT,
72 TPM_MEDIUM,
73 TPM_LONG,
74 TPM_LONG,
75 TPM_MEDIUM, /* 15 */
76 TPM_SHORT,
77 TPM_SHORT,
78 TPM_MEDIUM,
79 TPM_LONG,
80 TPM_SHORT, /* 20 */
81 TPM_SHORT,
82 TPM_MEDIUM,
83 TPM_MEDIUM,
84 TPM_MEDIUM,
85 TPM_SHORT, /* 25 */
86 TPM_SHORT,
87 TPM_MEDIUM,
88 TPM_SHORT,
89 TPM_SHORT,
90 TPM_MEDIUM, /* 30 */
91 TPM_LONG,
92 TPM_MEDIUM,
93 TPM_SHORT,
94 TPM_SHORT,
95 TPM_SHORT, /* 35 */
96 TPM_MEDIUM,
97 TPM_MEDIUM,
98 TPM_UNDEFINED,
99 TPM_UNDEFINED,
100 TPM_MEDIUM, /* 40 */
101 TPM_LONG,
102 TPM_MEDIUM,
103 TPM_SHORT,
104 TPM_SHORT,
105 TPM_SHORT, /* 45 */
106 TPM_SHORT,
107 TPM_SHORT,
108 TPM_SHORT,
109 TPM_LONG,
110 TPM_MEDIUM, /* 50 */
111 TPM_MEDIUM,
112 TPM_UNDEFINED,
113 TPM_UNDEFINED,
114 TPM_UNDEFINED,
115 TPM_UNDEFINED, /* 55 */
116 TPM_UNDEFINED,
117 TPM_UNDEFINED,
118 TPM_UNDEFINED,
119 TPM_UNDEFINED,
120 TPM_MEDIUM, /* 60 */
121 TPM_MEDIUM,
122 TPM_MEDIUM,
123 TPM_SHORT,
124 TPM_SHORT,
125 TPM_MEDIUM, /* 65 */
126 TPM_UNDEFINED,
127 TPM_UNDEFINED,
128 TPM_UNDEFINED,
129 TPM_UNDEFINED,
130 TPM_SHORT, /* 70 */
131 TPM_SHORT,
132 TPM_UNDEFINED,
133 TPM_UNDEFINED,
134 TPM_UNDEFINED,
135 TPM_UNDEFINED, /* 75 */
136 TPM_UNDEFINED,
137 TPM_UNDEFINED,
138 TPM_UNDEFINED,
139 TPM_UNDEFINED,
140 TPM_LONG, /* 80 */
141 TPM_UNDEFINED,
142 TPM_MEDIUM,
143 TPM_LONG,
144 TPM_SHORT,
145 TPM_UNDEFINED, /* 85 */
146 TPM_UNDEFINED,
147 TPM_UNDEFINED,
148 TPM_UNDEFINED,
149 TPM_UNDEFINED,
150 TPM_SHORT, /* 90 */
151 TPM_SHORT,
152 TPM_SHORT,
153 TPM_SHORT,
154 TPM_SHORT,
155 TPM_UNDEFINED, /* 95 */
156 TPM_UNDEFINED,
157 TPM_UNDEFINED,
158 TPM_UNDEFINED,
159 TPM_UNDEFINED,
160 TPM_MEDIUM, /* 100 */
161 TPM_SHORT,
162 TPM_SHORT,
163 TPM_UNDEFINED,
164 TPM_UNDEFINED,
165 TPM_UNDEFINED, /* 105 */
166 TPM_UNDEFINED,
167 TPM_UNDEFINED,
168 TPM_UNDEFINED,
169 TPM_UNDEFINED,
170 TPM_SHORT, /* 110 */
171 TPM_SHORT,
172 TPM_SHORT,
173 TPM_SHORT,
174 TPM_SHORT,
175 TPM_SHORT, /* 115 */
176 TPM_SHORT,
177 TPM_SHORT,
178 TPM_UNDEFINED,
179 TPM_UNDEFINED,
180 TPM_LONG, /* 120 */
181 TPM_LONG,
182 TPM_MEDIUM,
183 TPM_UNDEFINED,
184 TPM_SHORT,
185 TPM_SHORT, /* 125 */
186 TPM_SHORT,
187 TPM_LONG,
188 TPM_SHORT,
189 TPM_SHORT,
190 TPM_SHORT, /* 130 */
191 TPM_MEDIUM,
192 TPM_UNDEFINED,
193 TPM_SHORT,
194 TPM_MEDIUM,
195 TPM_UNDEFINED, /* 135 */
196 TPM_UNDEFINED,
197 TPM_UNDEFINED,
198 TPM_UNDEFINED,
199 TPM_UNDEFINED,
200 TPM_SHORT, /* 140 */
201 TPM_SHORT,
202 TPM_UNDEFINED,
203 TPM_UNDEFINED,
204 TPM_UNDEFINED,
205 TPM_UNDEFINED, /* 145 */
206 TPM_UNDEFINED,
207 TPM_UNDEFINED,
208 TPM_UNDEFINED,
209 TPM_UNDEFINED,
210 TPM_SHORT, /* 150 */
211 TPM_MEDIUM,
212 TPM_MEDIUM,
213 TPM_SHORT,
214 TPM_SHORT,
215 TPM_UNDEFINED, /* 155 */
216 TPM_UNDEFINED,
217 TPM_UNDEFINED,
218 TPM_UNDEFINED,
219 TPM_UNDEFINED,
220 TPM_SHORT, /* 160 */
221 TPM_SHORT,
222 TPM_SHORT,
223 TPM_SHORT,
224 TPM_UNDEFINED,
225 TPM_UNDEFINED, /* 165 */
226 TPM_UNDEFINED,
227 TPM_UNDEFINED,
228 TPM_UNDEFINED,
229 TPM_UNDEFINED,
230 TPM_LONG, /* 170 */
231 TPM_UNDEFINED,
232 TPM_UNDEFINED,
233 TPM_UNDEFINED,
234 TPM_UNDEFINED,
235 TPM_UNDEFINED, /* 175 */
236 TPM_UNDEFINED,
237 TPM_UNDEFINED,
238 TPM_UNDEFINED,
239 TPM_UNDEFINED,
240 TPM_MEDIUM, /* 180 */
241 TPM_SHORT,
242 TPM_MEDIUM,
243 TPM_MEDIUM,
244 TPM_MEDIUM,
245 TPM_MEDIUM, /* 185 */
246 TPM_SHORT,
247 TPM_UNDEFINED,
248 TPM_UNDEFINED,
249 TPM_UNDEFINED,
250 TPM_UNDEFINED, /* 190 */
251 TPM_UNDEFINED,
252 TPM_UNDEFINED,
253 TPM_UNDEFINED,
254 TPM_UNDEFINED,
255 TPM_UNDEFINED, /* 195 */
256 TPM_UNDEFINED,
257 TPM_UNDEFINED,
258 TPM_UNDEFINED,
259 TPM_UNDEFINED,
260 TPM_SHORT, /* 200 */
261 TPM_UNDEFINED,
262 TPM_UNDEFINED,
263 TPM_UNDEFINED,
264 TPM_SHORT,
265 TPM_SHORT, /* 205 */
266 TPM_SHORT,
267 TPM_SHORT,
268 TPM_SHORT,
269 TPM_SHORT,
270 TPM_MEDIUM, /* 210 */
271 TPM_UNDEFINED,
272 TPM_MEDIUM,
273 TPM_MEDIUM,
274 TPM_MEDIUM,
275 TPM_UNDEFINED, /* 215 */
276 TPM_MEDIUM,
277 TPM_UNDEFINED,
278 TPM_UNDEFINED,
279 TPM_SHORT,
280 TPM_SHORT, /* 220 */
281 TPM_SHORT,
282 TPM_SHORT,
283 TPM_SHORT,
284 TPM_SHORT,
285 TPM_UNDEFINED, /* 225 */
286 TPM_UNDEFINED,
287 TPM_UNDEFINED,
288 TPM_UNDEFINED,
289 TPM_UNDEFINED,
290 TPM_SHORT, /* 230 */
291 TPM_LONG,
292 TPM_MEDIUM,
293 TPM_UNDEFINED,
294 TPM_UNDEFINED,
295 TPM_UNDEFINED, /* 235 */
296 TPM_UNDEFINED,
297 TPM_UNDEFINED,
298 TPM_UNDEFINED,
299 TPM_UNDEFINED,
300 TPM_SHORT, /* 240 */
301 TPM_UNDEFINED,
302 TPM_MEDIUM,
303 };
304
305 /*
306 * Returns max number of jiffies to wait
307 */
308 unsigned long tpm_calc_ordinal_duration(struct tpm_chip *chip,
309 u32 ordinal)
310 {
311 int duration_idx = TPM_UNDEFINED;
312 int duration = 0;
313
314 /*
315 * We only have a duration table for protected commands, where the upper
316 * 16 bits are 0. For the few other ordinals the fallback will be used.
317 */
318 if (ordinal < TPM_MAX_ORDINAL)
319 duration_idx = tpm_ordinal_duration[ordinal];
320
321 if (duration_idx != TPM_UNDEFINED)
322 duration = chip->duration[duration_idx];
323 if (duration <= 0)
324 return 2 * 60 * HZ;
325 else
326 return duration;
327 }
328 EXPORT_SYMBOL_GPL(tpm_calc_ordinal_duration);
329
330 /*
331 * Internal kernel interface to transmit TPM commands
332 */
333 ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
334 size_t bufsiz)
335 {
336 ssize_t rc;
337 u32 count, ordinal;
338 unsigned long stop;
339
340 if (bufsiz > TPM_BUFSIZE)
341 bufsiz = TPM_BUFSIZE;
342
343 count = be32_to_cpu(*((__be32 *) (buf + 2)));
344 ordinal = be32_to_cpu(*((__be32 *) (buf + 6)));
345 if (count == 0)
346 return -ENODATA;
347 if (count > bufsiz) {
348 dev_err(&chip->dev,
349 "invalid count value %x %zx\n", count, bufsiz);
350 return -E2BIG;
351 }
352
353 mutex_lock(&chip->tpm_mutex);
354
355 rc = chip->ops->send(chip, (u8 *) buf, count);
356 if (rc < 0) {
357 dev_err(&chip->dev,
358 "tpm_transmit: tpm_send: error %zd\n", rc);
359 goto out;
360 }
361
362 if (chip->flags & TPM_CHIP_FLAG_IRQ)
363 goto out_recv;
364
365 if (chip->flags & TPM_CHIP_FLAG_TPM2)
366 stop = jiffies + tpm2_calc_ordinal_duration(chip, ordinal);
367 else
368 stop = jiffies + tpm_calc_ordinal_duration(chip, ordinal);
369 do {
370 u8 status = chip->ops->status(chip);
371 if ((status & chip->ops->req_complete_mask) ==
372 chip->ops->req_complete_val)
373 goto out_recv;
374
375 if (chip->ops->req_canceled(chip, status)) {
376 dev_err(&chip->dev, "Operation Canceled\n");
377 rc = -ECANCELED;
378 goto out;
379 }
380
381 msleep(TPM_TIMEOUT); /* CHECK */
382 rmb();
383 } while (time_before(jiffies, stop));
384
385 chip->ops->cancel(chip);
386 dev_err(&chip->dev, "Operation Timed out\n");
387 rc = -ETIME;
388 goto out;
389
390 out_recv:
391 rc = chip->ops->recv(chip, (u8 *) buf, bufsiz);
392 if (rc < 0)
393 dev_err(&chip->dev,
394 "tpm_transmit: tpm_recv: error %zd\n", rc);
395 out:
396 mutex_unlock(&chip->tpm_mutex);
397 return rc;
398 }
399
400 #define TPM_DIGEST_SIZE 20
401 #define TPM_RET_CODE_IDX 6
402
403 ssize_t tpm_transmit_cmd(struct tpm_chip *chip, void *cmd,
404 int len, const char *desc)
405 {
406 struct tpm_output_header *header;
407 int err;
408
409 len = tpm_transmit(chip, (u8 *) cmd, len);
410 if (len < 0)
411 return len;
412 else if (len < TPM_HEADER_SIZE)
413 return -EFAULT;
414
415 header = cmd;
416
417 err = be32_to_cpu(header->return_code);
418 if (err != 0 && desc)
419 dev_err(&chip->dev, "A TPM error (%d) occurred %s\n", err,
420 desc);
421
422 return err;
423 }
424
425 #define TPM_INTERNAL_RESULT_SIZE 200
426 #define TPM_ORD_GET_CAP cpu_to_be32(101)
427 #define TPM_ORD_GET_RANDOM cpu_to_be32(70)
428
429 static const struct tpm_input_header tpm_getcap_header = {
430 .tag = TPM_TAG_RQU_COMMAND,
431 .length = cpu_to_be32(22),
432 .ordinal = TPM_ORD_GET_CAP
433 };
434
435 ssize_t tpm_getcap(struct tpm_chip *chip, __be32 subcap_id, cap_t *cap,
436 const char *desc)
437 {
438 struct tpm_cmd_t tpm_cmd;
439 int rc;
440
441 tpm_cmd.header.in = tpm_getcap_header;
442 if (subcap_id == CAP_VERSION_1_1 || subcap_id == CAP_VERSION_1_2) {
443 tpm_cmd.params.getcap_in.cap = subcap_id;
444 /*subcap field not necessary */
445 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(0);
446 tpm_cmd.header.in.length -= cpu_to_be32(sizeof(__be32));
447 } else {
448 if (subcap_id == TPM_CAP_FLAG_PERM ||
449 subcap_id == TPM_CAP_FLAG_VOL)
450 tpm_cmd.params.getcap_in.cap = TPM_CAP_FLAG;
451 else
452 tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP;
453 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4);
454 tpm_cmd.params.getcap_in.subcap = subcap_id;
455 }
456 rc = tpm_transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, desc);
457 if (!rc)
458 *cap = tpm_cmd.params.getcap_out.cap;
459 return rc;
460 }
461
462 void tpm_gen_interrupt(struct tpm_chip *chip)
463 {
464 struct tpm_cmd_t tpm_cmd;
465 ssize_t rc;
466
467 tpm_cmd.header.in = tpm_getcap_header;
468 tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP;
469 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4);
470 tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_TIMEOUT;
471
472 rc = tpm_transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE,
473 "attempting to determine the timeouts");
474 }
475 EXPORT_SYMBOL_GPL(tpm_gen_interrupt);
476
477 #define TPM_ORD_STARTUP cpu_to_be32(153)
478 #define TPM_ST_CLEAR cpu_to_be16(1)
479 #define TPM_ST_STATE cpu_to_be16(2)
480 #define TPM_ST_DEACTIVATED cpu_to_be16(3)
481 static const struct tpm_input_header tpm_startup_header = {
482 .tag = TPM_TAG_RQU_COMMAND,
483 .length = cpu_to_be32(12),
484 .ordinal = TPM_ORD_STARTUP
485 };
486
487 static int tpm_startup(struct tpm_chip *chip, __be16 startup_type)
488 {
489 struct tpm_cmd_t start_cmd;
490 start_cmd.header.in = tpm_startup_header;
491
492 start_cmd.params.startup_in.startup_type = startup_type;
493 return tpm_transmit_cmd(chip, &start_cmd, TPM_INTERNAL_RESULT_SIZE,
494 "attempting to start the TPM");
495 }
496
497 int tpm_get_timeouts(struct tpm_chip *chip)
498 {
499 struct tpm_cmd_t tpm_cmd;
500 unsigned long new_timeout[4];
501 unsigned long old_timeout[4];
502 struct duration_t *duration_cap;
503 ssize_t rc;
504
505 if (chip->flags & TPM_CHIP_FLAG_TPM2) {
506 /* Fixed timeouts for TPM2 */
507 chip->timeout_a = msecs_to_jiffies(TPM2_TIMEOUT_A);
508 chip->timeout_b = msecs_to_jiffies(TPM2_TIMEOUT_B);
509 chip->timeout_c = msecs_to_jiffies(TPM2_TIMEOUT_C);
510 chip->timeout_d = msecs_to_jiffies(TPM2_TIMEOUT_D);
511 chip->duration[TPM_SHORT] =
512 msecs_to_jiffies(TPM2_DURATION_SHORT);
513 chip->duration[TPM_MEDIUM] =
514 msecs_to_jiffies(TPM2_DURATION_MEDIUM);
515 chip->duration[TPM_LONG] =
516 msecs_to_jiffies(TPM2_DURATION_LONG);
517 return 0;
518 }
519
520 tpm_cmd.header.in = tpm_getcap_header;
521 tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP;
522 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4);
523 tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_TIMEOUT;
524 rc = tpm_transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, NULL);
525
526 if (rc == TPM_ERR_INVALID_POSTINIT) {
527 /* The TPM is not started, we are the first to talk to it.
528 Execute a startup command. */
529 dev_info(&chip->dev, "Issuing TPM_STARTUP");
530 if (tpm_startup(chip, TPM_ST_CLEAR))
531 return rc;
532
533 tpm_cmd.header.in = tpm_getcap_header;
534 tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP;
535 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4);
536 tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_TIMEOUT;
537 rc = tpm_transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE,
538 NULL);
539 }
540 if (rc) {
541 dev_err(&chip->dev,
542 "A TPM error (%zd) occurred attempting to determine the timeouts\n",
543 rc);
544 goto duration;
545 }
546
547 if (be32_to_cpu(tpm_cmd.header.out.return_code) != 0 ||
548 be32_to_cpu(tpm_cmd.header.out.length)
549 != sizeof(tpm_cmd.header.out) + sizeof(u32) + 4 * sizeof(u32))
550 return -EINVAL;
551
552 old_timeout[0] = be32_to_cpu(tpm_cmd.params.getcap_out.cap.timeout.a);
553 old_timeout[1] = be32_to_cpu(tpm_cmd.params.getcap_out.cap.timeout.b);
554 old_timeout[2] = be32_to_cpu(tpm_cmd.params.getcap_out.cap.timeout.c);
555 old_timeout[3] = be32_to_cpu(tpm_cmd.params.getcap_out.cap.timeout.d);
556 memcpy(new_timeout, old_timeout, sizeof(new_timeout));
557
558 /*
559 * Provide ability for vendor overrides of timeout values in case
560 * of misreporting.
561 */
562 if (chip->ops->update_timeouts != NULL)
563 chip->timeout_adjusted =
564 chip->ops->update_timeouts(chip, new_timeout);
565
566 if (!chip->timeout_adjusted) {
567 /* Don't overwrite default if value is 0 */
568 if (new_timeout[0] != 0 && new_timeout[0] < 1000) {
569 int i;
570
571 /* timeouts in msec rather usec */
572 for (i = 0; i != ARRAY_SIZE(new_timeout); i++)
573 new_timeout[i] *= 1000;
574 chip->timeout_adjusted = true;
575 }
576 }
577
578 /* Report adjusted timeouts */
579 if (chip->timeout_adjusted) {
580 dev_info(&chip->dev,
581 HW_ERR "Adjusting reported timeouts: A %lu->%luus B %lu->%luus C %lu->%luus D %lu->%luus\n",
582 old_timeout[0], new_timeout[0],
583 old_timeout[1], new_timeout[1],
584 old_timeout[2], new_timeout[2],
585 old_timeout[3], new_timeout[3]);
586 }
587
588 chip->timeout_a = usecs_to_jiffies(new_timeout[0]);
589 chip->timeout_b = usecs_to_jiffies(new_timeout[1]);
590 chip->timeout_c = usecs_to_jiffies(new_timeout[2]);
591 chip->timeout_d = usecs_to_jiffies(new_timeout[3]);
592
593 duration:
594 tpm_cmd.header.in = tpm_getcap_header;
595 tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP;
596 tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4);
597 tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_DURATION;
598
599 rc = tpm_transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE,
600 "attempting to determine the durations");
601 if (rc)
602 return rc;
603
604 if (be32_to_cpu(tpm_cmd.header.out.return_code) != 0 ||
605 be32_to_cpu(tpm_cmd.header.out.length)
606 != sizeof(tpm_cmd.header.out) + sizeof(u32) + 3 * sizeof(u32))
607 return -EINVAL;
608
609 duration_cap = &tpm_cmd.params.getcap_out.cap.duration;
610 chip->duration[TPM_SHORT] =
611 usecs_to_jiffies(be32_to_cpu(duration_cap->tpm_short));
612 chip->duration[TPM_MEDIUM] =
613 usecs_to_jiffies(be32_to_cpu(duration_cap->tpm_medium));
614 chip->duration[TPM_LONG] =
615 usecs_to_jiffies(be32_to_cpu(duration_cap->tpm_long));
616
617 /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above
618 * value wrong and apparently reports msecs rather than usecs. So we
619 * fix up the resulting too-small TPM_SHORT value to make things work.
620 * We also scale the TPM_MEDIUM and -_LONG values by 1000.
621 */
622 if (chip->duration[TPM_SHORT] < (HZ / 100)) {
623 chip->duration[TPM_SHORT] = HZ;
624 chip->duration[TPM_MEDIUM] *= 1000;
625 chip->duration[TPM_LONG] *= 1000;
626 chip->duration_adjusted = true;
627 dev_info(&chip->dev, "Adjusting TPM timeout parameters.");
628 }
629 return 0;
630 }
631 EXPORT_SYMBOL_GPL(tpm_get_timeouts);
632
633 #define TPM_ORD_CONTINUE_SELFTEST 83
634 #define CONTINUE_SELFTEST_RESULT_SIZE 10
635
636 static struct tpm_input_header continue_selftest_header = {
637 .tag = TPM_TAG_RQU_COMMAND,
638 .length = cpu_to_be32(10),
639 .ordinal = cpu_to_be32(TPM_ORD_CONTINUE_SELFTEST),
640 };
641
642 /**
643 * tpm_continue_selftest -- run TPM's selftest
644 * @chip: TPM chip to use
645 *
646 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
647 * a TPM error code.
648 */
649 static int tpm_continue_selftest(struct tpm_chip *chip)
650 {
651 int rc;
652 struct tpm_cmd_t cmd;
653
654 cmd.header.in = continue_selftest_header;
655 rc = tpm_transmit_cmd(chip, &cmd, CONTINUE_SELFTEST_RESULT_SIZE,
656 "continue selftest");
657 return rc;
658 }
659
660 #define TPM_ORDINAL_PCRREAD cpu_to_be32(21)
661 #define READ_PCR_RESULT_SIZE 30
662 static struct tpm_input_header pcrread_header = {
663 .tag = TPM_TAG_RQU_COMMAND,
664 .length = cpu_to_be32(14),
665 .ordinal = TPM_ORDINAL_PCRREAD
666 };
667
668 int tpm_pcr_read_dev(struct tpm_chip *chip, int pcr_idx, u8 *res_buf)
669 {
670 int rc;
671 struct tpm_cmd_t cmd;
672
673 cmd.header.in = pcrread_header;
674 cmd.params.pcrread_in.pcr_idx = cpu_to_be32(pcr_idx);
675 rc = tpm_transmit_cmd(chip, &cmd, READ_PCR_RESULT_SIZE,
676 "attempting to read a pcr value");
677
678 if (rc == 0)
679 memcpy(res_buf, cmd.params.pcrread_out.pcr_result,
680 TPM_DIGEST_SIZE);
681 return rc;
682 }
683
684 /**
685 * tpm_is_tpm2 - is the chip a TPM2 chip?
686 * @chip_num: tpm idx # or ANY
687 *
688 * Returns < 0 on error, and 1 or 0 on success depending whether the chip
689 * is a TPM2 chip.
690 */
691 int tpm_is_tpm2(u32 chip_num)
692 {
693 struct tpm_chip *chip;
694 int rc;
695
696 chip = tpm_chip_find_get(chip_num);
697 if (chip == NULL)
698 return -ENODEV;
699
700 rc = (chip->flags & TPM_CHIP_FLAG_TPM2) != 0;
701
702 tpm_put_ops(chip);
703
704 return rc;
705 }
706 EXPORT_SYMBOL_GPL(tpm_is_tpm2);
707
708 /**
709 * tpm_pcr_read - read a pcr value
710 * @chip_num: tpm idx # or ANY
711 * @pcr_idx: pcr idx to retrieve
712 * @res_buf: TPM_PCR value
713 * size of res_buf is 20 bytes (or NULL if you don't care)
714 *
715 * The TPM driver should be built-in, but for whatever reason it
716 * isn't, protect against the chip disappearing, by incrementing
717 * the module usage count.
718 */
719 int tpm_pcr_read(u32 chip_num, int pcr_idx, u8 *res_buf)
720 {
721 struct tpm_chip *chip;
722 int rc;
723
724 chip = tpm_chip_find_get(chip_num);
725 if (chip == NULL)
726 return -ENODEV;
727 if (chip->flags & TPM_CHIP_FLAG_TPM2)
728 rc = tpm2_pcr_read(chip, pcr_idx, res_buf);
729 else
730 rc = tpm_pcr_read_dev(chip, pcr_idx, res_buf);
731 tpm_put_ops(chip);
732 return rc;
733 }
734 EXPORT_SYMBOL_GPL(tpm_pcr_read);
735
736 /**
737 * tpm_pcr_extend - extend pcr value with hash
738 * @chip_num: tpm idx # or AN&
739 * @pcr_idx: pcr idx to extend
740 * @hash: hash value used to extend pcr value
741 *
742 * The TPM driver should be built-in, but for whatever reason it
743 * isn't, protect against the chip disappearing, by incrementing
744 * the module usage count.
745 */
746 #define TPM_ORD_PCR_EXTEND cpu_to_be32(20)
747 #define EXTEND_PCR_RESULT_SIZE 34
748 static struct tpm_input_header pcrextend_header = {
749 .tag = TPM_TAG_RQU_COMMAND,
750 .length = cpu_to_be32(34),
751 .ordinal = TPM_ORD_PCR_EXTEND
752 };
753
754 int tpm_pcr_extend(u32 chip_num, int pcr_idx, const u8 *hash)
755 {
756 struct tpm_cmd_t cmd;
757 int rc;
758 struct tpm_chip *chip;
759
760 chip = tpm_chip_find_get(chip_num);
761 if (chip == NULL)
762 return -ENODEV;
763
764 if (chip->flags & TPM_CHIP_FLAG_TPM2) {
765 rc = tpm2_pcr_extend(chip, pcr_idx, hash);
766 tpm_put_ops(chip);
767 return rc;
768 }
769
770 cmd.header.in = pcrextend_header;
771 cmd.params.pcrextend_in.pcr_idx = cpu_to_be32(pcr_idx);
772 memcpy(cmd.params.pcrextend_in.hash, hash, TPM_DIGEST_SIZE);
773 rc = tpm_transmit_cmd(chip, &cmd, EXTEND_PCR_RESULT_SIZE,
774 "attempting extend a PCR value");
775
776 tpm_put_ops(chip);
777 return rc;
778 }
779 EXPORT_SYMBOL_GPL(tpm_pcr_extend);
780
781 /**
782 * tpm_do_selftest - have the TPM continue its selftest and wait until it
783 * can receive further commands
784 * @chip: TPM chip to use
785 *
786 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
787 * a TPM error code.
788 */
789 int tpm_do_selftest(struct tpm_chip *chip)
790 {
791 int rc;
792 unsigned int loops;
793 unsigned int delay_msec = 100;
794 unsigned long duration;
795 struct tpm_cmd_t cmd;
796
797 duration = tpm_calc_ordinal_duration(chip, TPM_ORD_CONTINUE_SELFTEST);
798
799 loops = jiffies_to_msecs(duration) / delay_msec;
800
801 rc = tpm_continue_selftest(chip);
802 /* This may fail if there was no TPM driver during a suspend/resume
803 * cycle; some may return 10 (BAD_ORDINAL), others 28 (FAILEDSELFTEST)
804 */
805 if (rc)
806 return rc;
807
808 do {
809 /* Attempt to read a PCR value */
810 cmd.header.in = pcrread_header;
811 cmd.params.pcrread_in.pcr_idx = cpu_to_be32(0);
812 rc = tpm_transmit(chip, (u8 *) &cmd, READ_PCR_RESULT_SIZE);
813 /* Some buggy TPMs will not respond to tpm_tis_ready() for
814 * around 300ms while the self test is ongoing, keep trying
815 * until the self test duration expires. */
816 if (rc == -ETIME) {
817 dev_info(
818 &chip->dev, HW_ERR
819 "TPM command timed out during continue self test");
820 msleep(delay_msec);
821 continue;
822 }
823
824 if (rc < TPM_HEADER_SIZE)
825 return -EFAULT;
826
827 rc = be32_to_cpu(cmd.header.out.return_code);
828 if (rc == TPM_ERR_DISABLED || rc == TPM_ERR_DEACTIVATED) {
829 dev_info(&chip->dev,
830 "TPM is disabled/deactivated (0x%X)\n", rc);
831 /* TPM is disabled and/or deactivated; driver can
832 * proceed and TPM does handle commands for
833 * suspend/resume correctly
834 */
835 return 0;
836 }
837 if (rc != TPM_WARN_DOING_SELFTEST)
838 return rc;
839 msleep(delay_msec);
840 } while (--loops > 0);
841
842 return rc;
843 }
844 EXPORT_SYMBOL_GPL(tpm_do_selftest);
845
846 /**
847 * tpm1_auto_startup - Perform the standard automatic TPM initialization
848 * sequence
849 * @chip: TPM chip to use
850 *
851 * Returns 0 on success, < 0 in case of fatal error.
852 */
853 int tpm1_auto_startup(struct tpm_chip *chip)
854 {
855 int rc;
856
857 rc = tpm_get_timeouts(chip);
858 if (rc)
859 goto out;
860 rc = tpm_do_selftest(chip);
861 if (rc) {
862 dev_err(&chip->dev, "TPM self test failed\n");
863 goto out;
864 }
865
866 return rc;
867 out:
868 if (rc > 0)
869 rc = -ENODEV;
870 return rc;
871 }
872
873 int tpm_send(u32 chip_num, void *cmd, size_t buflen)
874 {
875 struct tpm_chip *chip;
876 int rc;
877
878 chip = tpm_chip_find_get(chip_num);
879 if (chip == NULL)
880 return -ENODEV;
881
882 rc = tpm_transmit_cmd(chip, cmd, buflen, "attempting tpm_cmd");
883
884 tpm_put_ops(chip);
885 return rc;
886 }
887 EXPORT_SYMBOL_GPL(tpm_send);
888
889 static bool wait_for_tpm_stat_cond(struct tpm_chip *chip, u8 mask,
890 bool check_cancel, bool *canceled)
891 {
892 u8 status = chip->ops->status(chip);
893
894 *canceled = false;
895 if ((status & mask) == mask)
896 return true;
897 if (check_cancel && chip->ops->req_canceled(chip, status)) {
898 *canceled = true;
899 return true;
900 }
901 return false;
902 }
903
904 int wait_for_tpm_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout,
905 wait_queue_head_t *queue, bool check_cancel)
906 {
907 unsigned long stop;
908 long rc;
909 u8 status;
910 bool canceled = false;
911
912 /* check current status */
913 status = chip->ops->status(chip);
914 if ((status & mask) == mask)
915 return 0;
916
917 stop = jiffies + timeout;
918
919 if (chip->flags & TPM_CHIP_FLAG_IRQ) {
920 again:
921 timeout = stop - jiffies;
922 if ((long)timeout <= 0)
923 return -ETIME;
924 rc = wait_event_interruptible_timeout(*queue,
925 wait_for_tpm_stat_cond(chip, mask, check_cancel,
926 &canceled),
927 timeout);
928 if (rc > 0) {
929 if (canceled)
930 return -ECANCELED;
931 return 0;
932 }
933 if (rc == -ERESTARTSYS && freezing(current)) {
934 clear_thread_flag(TIF_SIGPENDING);
935 goto again;
936 }
937 } else {
938 do {
939 msleep(TPM_TIMEOUT);
940 status = chip->ops->status(chip);
941 if ((status & mask) == mask)
942 return 0;
943 } while (time_before(jiffies, stop));
944 }
945 return -ETIME;
946 }
947 EXPORT_SYMBOL_GPL(wait_for_tpm_stat);
948
949 #define TPM_ORD_SAVESTATE cpu_to_be32(152)
950 #define SAVESTATE_RESULT_SIZE 10
951
952 static struct tpm_input_header savestate_header = {
953 .tag = TPM_TAG_RQU_COMMAND,
954 .length = cpu_to_be32(10),
955 .ordinal = TPM_ORD_SAVESTATE
956 };
957
958 /*
959 * We are about to suspend. Save the TPM state
960 * so that it can be restored.
961 */
962 int tpm_pm_suspend(struct device *dev)
963 {
964 struct tpm_chip *chip = dev_get_drvdata(dev);
965 struct tpm_cmd_t cmd;
966 int rc, try;
967
968 u8 dummy_hash[TPM_DIGEST_SIZE] = { 0 };
969
970 if (chip == NULL)
971 return -ENODEV;
972
973 if (chip->flags & TPM_CHIP_FLAG_TPM2) {
974 tpm2_shutdown(chip, TPM2_SU_STATE);
975 return 0;
976 }
977
978 /* for buggy tpm, flush pcrs with extend to selected dummy */
979 if (tpm_suspend_pcr) {
980 cmd.header.in = pcrextend_header;
981 cmd.params.pcrextend_in.pcr_idx = cpu_to_be32(tpm_suspend_pcr);
982 memcpy(cmd.params.pcrextend_in.hash, dummy_hash,
983 TPM_DIGEST_SIZE);
984 rc = tpm_transmit_cmd(chip, &cmd, EXTEND_PCR_RESULT_SIZE,
985 "extending dummy pcr before suspend");
986 }
987
988 /* now do the actual savestate */
989 for (try = 0; try < TPM_RETRY; try++) {
990 cmd.header.in = savestate_header;
991 rc = tpm_transmit_cmd(chip, &cmd, SAVESTATE_RESULT_SIZE, NULL);
992
993 /*
994 * If the TPM indicates that it is too busy to respond to
995 * this command then retry before giving up. It can take
996 * several seconds for this TPM to be ready.
997 *
998 * This can happen if the TPM has already been sent the
999 * SaveState command before the driver has loaded. TCG 1.2
1000 * specification states that any communication after SaveState
1001 * may cause the TPM to invalidate previously saved state.
1002 */
1003 if (rc != TPM_WARN_RETRY)
1004 break;
1005 msleep(TPM_TIMEOUT_RETRY);
1006 }
1007
1008 if (rc)
1009 dev_err(&chip->dev,
1010 "Error (%d) sending savestate before suspend\n", rc);
1011 else if (try > 0)
1012 dev_warn(&chip->dev, "TPM savestate took %dms\n",
1013 try * TPM_TIMEOUT_RETRY);
1014
1015 return rc;
1016 }
1017 EXPORT_SYMBOL_GPL(tpm_pm_suspend);
1018
1019 /*
1020 * Resume from a power safe. The BIOS already restored
1021 * the TPM state.
1022 */
1023 int tpm_pm_resume(struct device *dev)
1024 {
1025 struct tpm_chip *chip = dev_get_drvdata(dev);
1026
1027 if (chip == NULL)
1028 return -ENODEV;
1029
1030 return 0;
1031 }
1032 EXPORT_SYMBOL_GPL(tpm_pm_resume);
1033
1034 #define TPM_GETRANDOM_RESULT_SIZE 18
1035 static struct tpm_input_header tpm_getrandom_header = {
1036 .tag = TPM_TAG_RQU_COMMAND,
1037 .length = cpu_to_be32(14),
1038 .ordinal = TPM_ORD_GET_RANDOM
1039 };
1040
1041 /**
1042 * tpm_get_random() - Get random bytes from the tpm's RNG
1043 * @chip_num: A specific chip number for the request or TPM_ANY_NUM
1044 * @out: destination buffer for the random bytes
1045 * @max: the max number of bytes to write to @out
1046 *
1047 * Returns < 0 on error and the number of bytes read on success
1048 */
1049 int tpm_get_random(u32 chip_num, u8 *out, size_t max)
1050 {
1051 struct tpm_chip *chip;
1052 struct tpm_cmd_t tpm_cmd;
1053 u32 recd, num_bytes = min_t(u32, max, TPM_MAX_RNG_DATA);
1054 int err, total = 0, retries = 5;
1055 u8 *dest = out;
1056
1057 if (!out || !num_bytes || max > TPM_MAX_RNG_DATA)
1058 return -EINVAL;
1059
1060 chip = tpm_chip_find_get(chip_num);
1061 if (chip == NULL)
1062 return -ENODEV;
1063
1064 if (chip->flags & TPM_CHIP_FLAG_TPM2) {
1065 err = tpm2_get_random(chip, out, max);
1066 tpm_put_ops(chip);
1067 return err;
1068 }
1069
1070 do {
1071 tpm_cmd.header.in = tpm_getrandom_header;
1072 tpm_cmd.params.getrandom_in.num_bytes = cpu_to_be32(num_bytes);
1073
1074 err = tpm_transmit_cmd(chip, &tpm_cmd,
1075 TPM_GETRANDOM_RESULT_SIZE + num_bytes,
1076 "attempting get random");
1077 if (err)
1078 break;
1079
1080 recd = be32_to_cpu(tpm_cmd.params.getrandom_out.rng_data_len);
1081 memcpy(dest, tpm_cmd.params.getrandom_out.rng_data, recd);
1082
1083 dest += recd;
1084 total += recd;
1085 num_bytes -= recd;
1086 } while (retries-- && total < max);
1087
1088 tpm_put_ops(chip);
1089 return total ? total : -EIO;
1090 }
1091 EXPORT_SYMBOL_GPL(tpm_get_random);
1092
1093 /**
1094 * tpm_seal_trusted() - seal a trusted key
1095 * @chip_num: A specific chip number for the request or TPM_ANY_NUM
1096 * @options: authentication values and other options
1097 * @payload: the key data in clear and encrypted form
1098 *
1099 * Returns < 0 on error and 0 on success. At the moment, only TPM 2.0 chips
1100 * are supported.
1101 */
1102 int tpm_seal_trusted(u32 chip_num, struct trusted_key_payload *payload,
1103 struct trusted_key_options *options)
1104 {
1105 struct tpm_chip *chip;
1106 int rc;
1107
1108 chip = tpm_chip_find_get(chip_num);
1109 if (chip == NULL || !(chip->flags & TPM_CHIP_FLAG_TPM2))
1110 return -ENODEV;
1111
1112 rc = tpm2_seal_trusted(chip, payload, options);
1113
1114 tpm_put_ops(chip);
1115 return rc;
1116 }
1117 EXPORT_SYMBOL_GPL(tpm_seal_trusted);
1118
1119 /**
1120 * tpm_unseal_trusted() - unseal a trusted key
1121 * @chip_num: A specific chip number for the request or TPM_ANY_NUM
1122 * @options: authentication values and other options
1123 * @payload: the key data in clear and encrypted form
1124 *
1125 * Returns < 0 on error and 0 on success. At the moment, only TPM 2.0 chips
1126 * are supported.
1127 */
1128 int tpm_unseal_trusted(u32 chip_num, struct trusted_key_payload *payload,
1129 struct trusted_key_options *options)
1130 {
1131 struct tpm_chip *chip;
1132 int rc;
1133
1134 chip = tpm_chip_find_get(chip_num);
1135 if (chip == NULL || !(chip->flags & TPM_CHIP_FLAG_TPM2))
1136 return -ENODEV;
1137
1138 rc = tpm2_unseal_trusted(chip, payload, options);
1139
1140 tpm_put_ops(chip);
1141
1142 return rc;
1143 }
1144 EXPORT_SYMBOL_GPL(tpm_unseal_trusted);
1145
1146 static int __init tpm_init(void)
1147 {
1148 int rc;
1149
1150 tpm_class = class_create(THIS_MODULE, "tpm");
1151 if (IS_ERR(tpm_class)) {
1152 pr_err("couldn't create tpm class\n");
1153 return PTR_ERR(tpm_class);
1154 }
1155
1156 rc = alloc_chrdev_region(&tpm_devt, 0, TPM_NUM_DEVICES, "tpm");
1157 if (rc < 0) {
1158 pr_err("tpm: failed to allocate char dev region\n");
1159 class_destroy(tpm_class);
1160 return rc;
1161 }
1162
1163 return 0;
1164 }
1165
1166 static void __exit tpm_exit(void)
1167 {
1168 idr_destroy(&dev_nums_idr);
1169 class_destroy(tpm_class);
1170 unregister_chrdev_region(tpm_devt, TPM_NUM_DEVICES);
1171 }
1172
1173 subsys_initcall(tpm_init);
1174 module_exit(tpm_exit);
1175
1176 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
1177 MODULE_DESCRIPTION("TPM Driver");
1178 MODULE_VERSION("2.0");
1179 MODULE_LICENSE("GPL");
Linux with added FPC-III support