?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.18.10
[linux/fpc-iii.git] / drivers / char / tpm / tpm-interface.c
blob3a3a7a548a85a9b850f47ad2560009d172f92236
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 #include <linux/tpm_eventlog.h>
33
34 #include "tpm.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 facilitate 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 static int tpm_validate_command(struct tpm_chip *chip,
331 struct tpm_space *space,
332 const u8 *cmd,
333 size_t len)
334 {
335 const struct tpm_input_header *header = (const void *)cmd;
336 int i;
337 u32 cc;
338 u32 attrs;
339 unsigned int nr_handles;
340
341 if (len < TPM_HEADER_SIZE)
342 return -EINVAL;
343
344 if (!space)
345 return 0;
346
347 if (chip->flags & TPM_CHIP_FLAG_TPM2 && chip->nr_commands) {
348 cc = be32_to_cpu(header->ordinal);
349
350 i = tpm2_find_cc(chip, cc);
351 if (i < 0) {
352 dev_dbg(&chip->dev, "0x%04X is an invalid command\n",
353 cc);
354 return -EOPNOTSUPP;
355 }
356
357 attrs = chip->cc_attrs_tbl[i];
358 nr_handles =
359 4 * ((attrs >> TPM2_CC_ATTR_CHANDLES) & GENMASK(2, 0));
360 if (len < TPM_HEADER_SIZE + 4 * nr_handles)
361 goto err_len;
362 }
363
364 return 0;
365 err_len:
366 dev_dbg(&chip->dev,
367 "%s: insufficient command length %zu", __func__, len);
368 return -EINVAL;
369 }
370
371 static int tpm_request_locality(struct tpm_chip *chip, unsigned int flags)
372 {
373 int rc;
374
375 if (flags & TPM_TRANSMIT_RAW)
376 return 0;
377
378 if (!chip->ops->request_locality)
379 return 0;
380
381 rc = chip->ops->request_locality(chip, 0);
382 if (rc < 0)
383 return rc;
384
385 chip->locality = rc;
386
387 return 0;
388 }
389
390 static void tpm_relinquish_locality(struct tpm_chip *chip, unsigned int flags)
391 {
392 int rc;
393
394 if (flags & TPM_TRANSMIT_RAW)
395 return;
396
397 if (!chip->ops->relinquish_locality)
398 return;
399
400 rc = chip->ops->relinquish_locality(chip, chip->locality);
401 if (rc)
402 dev_err(&chip->dev, "%s: : error %d\n", __func__, rc);
403
404 chip->locality = -1;
405 }
406
407 static int tpm_cmd_ready(struct tpm_chip *chip, unsigned int flags)
408 {
409 if (flags & TPM_TRANSMIT_RAW)
410 return 0;
411
412 if (!chip->ops->cmd_ready)
413 return 0;
414
415 return chip->ops->cmd_ready(chip);
416 }
417
418 static int tpm_go_idle(struct tpm_chip *chip, unsigned int flags)
419 {
420 if (flags & TPM_TRANSMIT_RAW)
421 return 0;
422
423 if (!chip->ops->go_idle)
424 return 0;
425
426 return chip->ops->go_idle(chip);
427 }
428
429 static ssize_t tpm_try_transmit(struct tpm_chip *chip,
430 struct tpm_space *space,
431 u8 *buf, size_t bufsiz,
432 unsigned int flags)
433 {
434 struct tpm_output_header *header = (void *)buf;
435 int rc;
436 ssize_t len = 0;
437 u32 count, ordinal;
438 unsigned long stop;
439 bool need_locality;
440
441 rc = tpm_validate_command(chip, space, buf, bufsiz);
442 if (rc == -EINVAL)
443 return rc;
444 /*
445 * If the command is not implemented by the TPM, synthesize a
446 * response with a TPM2_RC_COMMAND_CODE return for user-space.
447 */
448 if (rc == -EOPNOTSUPP) {
449 header->length = cpu_to_be32(sizeof(*header));
450 header->tag = cpu_to_be16(TPM2_ST_NO_SESSIONS);
451 header->return_code = cpu_to_be32(TPM2_RC_COMMAND_CODE |
452 TSS2_RESMGR_TPM_RC_LAYER);
453 return sizeof(*header);
454 }
455
456 if (bufsiz > TPM_BUFSIZE)
457 bufsiz = TPM_BUFSIZE;
458
459 count = be32_to_cpu(*((__be32 *) (buf + 2)));
460 ordinal = be32_to_cpu(*((__be32 *) (buf + 6)));
461 if (count == 0)
462 return -ENODATA;
463 if (count > bufsiz) {
464 dev_err(&chip->dev,
465 "invalid count value %x %zx\n", count, bufsiz);
466 return -E2BIG;
467 }
468
469 if (!(flags & TPM_TRANSMIT_UNLOCKED))
470 mutex_lock(&chip->tpm_mutex);
471
472
473 if (chip->ops->clk_enable != NULL)
474 chip->ops->clk_enable(chip, true);
475
476 /* Store the decision as chip->locality will be changed. */
477 need_locality = chip->locality == -1;
478
479 if (need_locality) {
480 rc = tpm_request_locality(chip, flags);
481 if (rc < 0)
482 goto out_no_locality;
483 }
484
485 rc = tpm_cmd_ready(chip, flags);
486 if (rc)
487 goto out;
488
489 rc = tpm2_prepare_space(chip, space, ordinal, buf);
490 if (rc)
491 goto out;
492
493 rc = chip->ops->send(chip, buf, count);
494 if (rc < 0) {
495 if (rc != -EPIPE)
496 dev_err(&chip->dev,
497 "%s: tpm_send: error %d\n", __func__, rc);
498 goto out;
499 }
500
501 if (chip->flags & TPM_CHIP_FLAG_IRQ)
502 goto out_recv;
503
504 if (chip->flags & TPM_CHIP_FLAG_TPM2)
505 stop = jiffies + tpm2_calc_ordinal_duration(chip, ordinal);
506 else
507 stop = jiffies + tpm_calc_ordinal_duration(chip, ordinal);
508 do {
509 u8 status = chip->ops->status(chip);
510 if ((status & chip->ops->req_complete_mask) ==
511 chip->ops->req_complete_val)
512 goto out_recv;
513
514 if (chip->ops->req_canceled(chip, status)) {
515 dev_err(&chip->dev, "Operation Canceled\n");
516 rc = -ECANCELED;
517 goto out;
518 }
519
520 tpm_msleep(TPM_TIMEOUT_POLL);
521 rmb();
522 } while (time_before(jiffies, stop));
523
524 chip->ops->cancel(chip);
525 dev_err(&chip->dev, "Operation Timed out\n");
526 rc = -ETIME;
527 goto out;
528
529 out_recv:
530 len = chip->ops->recv(chip, buf, bufsiz);
531 if (len < 0) {
532 rc = len;
533 dev_err(&chip->dev,
534 "tpm_transmit: tpm_recv: error %d\n", rc);
535 goto out;
536 } else if (len < TPM_HEADER_SIZE) {
537 rc = -EFAULT;
538 goto out;
539 }
540
541 if (len != be32_to_cpu(header->length)) {
542 rc = -EFAULT;
543 goto out;
544 }
545
546 rc = tpm2_commit_space(chip, space, ordinal, buf, &len);
547 if (rc)
548 dev_err(&chip->dev, "tpm2_commit_space: error %d\n", rc);
549
550 out:
551 rc = tpm_go_idle(chip, flags);
552 if (rc)
553 goto out;
554
555 if (need_locality)
556 tpm_relinquish_locality(chip, flags);
557
558 out_no_locality:
559 if (chip->ops->clk_enable != NULL)
560 chip->ops->clk_enable(chip, false);
561
562 if (!(flags & TPM_TRANSMIT_UNLOCKED))
563 mutex_unlock(&chip->tpm_mutex);
564 return rc ? rc : len;
565 }
566
567 /**
568 * tpm_transmit - Internal kernel interface to transmit TPM commands.
569 *
570 * @chip: TPM chip to use
571 * @space: tpm space
572 * @buf: TPM command buffer
573 * @bufsiz: length of the TPM command buffer
574 * @flags: tpm transmit flags - bitmap
575 *
576 * A wrapper around tpm_try_transmit that handles TPM2_RC_RETRY
577 * returns from the TPM and retransmits the command after a delay up
578 * to a maximum wait of TPM2_DURATION_LONG.
579 *
580 * Note: TPM1 never returns TPM2_RC_RETRY so the retry logic is TPM2
581 * only
582 *
583 * Return:
584 * the length of the return when the operation is successful.
585 * A negative number for system errors (errno).
586 */
587 ssize_t tpm_transmit(struct tpm_chip *chip, struct tpm_space *space,
588 u8 *buf, size_t bufsiz, unsigned int flags)
589 {
590 struct tpm_output_header *header = (struct tpm_output_header *)buf;
591 /* space for header and handles */
592 u8 save[TPM_HEADER_SIZE + 3*sizeof(u32)];
593 unsigned int delay_msec = TPM2_DURATION_SHORT;
594 u32 rc = 0;
595 ssize_t ret;
596 const size_t save_size = min(space ? sizeof(save) : TPM_HEADER_SIZE,
597 bufsiz);
598 /* the command code is where the return code will be */
599 u32 cc = be32_to_cpu(header->return_code);
600
601 /*
602 * Subtlety here: if we have a space, the handles will be
603 * transformed, so when we restore the header we also have to
604 * restore the handles.
605 */
606 memcpy(save, buf, save_size);
607
608 for (;;) {
609 ret = tpm_try_transmit(chip, space, buf, bufsiz, flags);
610 if (ret < 0)
611 break;
612 rc = be32_to_cpu(header->return_code);
613 if (rc != TPM2_RC_RETRY && rc != TPM2_RC_TESTING)
614 break;
615 /*
616 * return immediately if self test returns test
617 * still running to shorten boot time.
618 */
619 if (rc == TPM2_RC_TESTING && cc == TPM2_CC_SELF_TEST)
620 break;
621
622 if (delay_msec > TPM2_DURATION_LONG) {
623 if (rc == TPM2_RC_RETRY)
624 dev_err(&chip->dev, "in retry loop\n");
625 else
626 dev_err(&chip->dev,
627 "self test is still running\n");
628 break;
629 }
630 tpm_msleep(delay_msec);
631 delay_msec *= 2;
632 memcpy(buf, save, save_size);
633 }
634 return ret;
635 }
636 /**
637 * tpm_transmit_cmd - send a tpm command to the device
638 * The function extracts tpm out header return code
639 *
640 * @chip: TPM chip to use
641 * @space: tpm space
642 * @buf: TPM command buffer
643 * @bufsiz: length of the buffer
644 * @min_rsp_body_length: minimum expected length of response body
645 * @flags: tpm transmit flags - bitmap
646 * @desc: command description used in the error message
647 *
648 * Return:
649 * 0 when the operation is successful.
650 * A negative number for system errors (errno).
651 * A positive number for a TPM error.
652 */
653 ssize_t tpm_transmit_cmd(struct tpm_chip *chip, struct tpm_space *space,
654 void *buf, size_t bufsiz,
655 size_t min_rsp_body_length, unsigned int flags,
656 const char *desc)
657 {
658 const struct tpm_output_header *header = buf;
659 int err;
660 ssize_t len;
661
662 len = tpm_transmit(chip, space, buf, bufsiz, flags);
663 if (len < 0)
664 return len;
665
666 err = be32_to_cpu(header->return_code);
667 if (err != 0 && desc)
668 dev_err(&chip->dev, "A TPM error (%d) occurred %s\n", err,
669 desc);
670 if (err)
671 return err;
672
673 if (len < min_rsp_body_length + TPM_HEADER_SIZE)
674 return -EFAULT;
675
676 return 0;
677 }
678 EXPORT_SYMBOL_GPL(tpm_transmit_cmd);
679
680 #define TPM_ORD_STARTUP 153
681 #define TPM_ST_CLEAR 1
682
683 /**
684 * tpm_startup - turn on the TPM
685 * @chip: TPM chip to use
686 *
687 * Normally the firmware should start the TPM. This function is provided as a
688 * workaround if this does not happen. A legal case for this could be for
689 * example when a TPM emulator is used.
690 *
691 * Return: same as tpm_transmit_cmd()
692 */
693 int tpm_startup(struct tpm_chip *chip)
694 {
695 struct tpm_buf buf;
696 int rc;
697
698 dev_info(&chip->dev, "starting up the TPM manually\n");
699
700 if (chip->flags & TPM_CHIP_FLAG_TPM2) {
701 rc = tpm_buf_init(&buf, TPM2_ST_NO_SESSIONS, TPM2_CC_STARTUP);
702 if (rc < 0)
703 return rc;
704
705 tpm_buf_append_u16(&buf, TPM2_SU_CLEAR);
706 } else {
707 rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_STARTUP);
708 if (rc < 0)
709 return rc;
710
711 tpm_buf_append_u16(&buf, TPM_ST_CLEAR);
712 }
713
714 rc = tpm_transmit_cmd(chip, NULL, buf.data, PAGE_SIZE, 0, 0,
715 "attempting to start the TPM");
716
717 tpm_buf_destroy(&buf);
718 return rc;
719 }
720
721 #define TPM_DIGEST_SIZE 20
722 #define TPM_RET_CODE_IDX 6
723 #define TPM_INTERNAL_RESULT_SIZE 200
724 #define TPM_ORD_GET_CAP 101
725 #define TPM_ORD_GET_RANDOM 70
726
727 static const struct tpm_input_header tpm_getcap_header = {
728 .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND),
729 .length = cpu_to_be32(22),
730 .ordinal = cpu_to_be32(TPM_ORD_GET_CAP)
731 };
732
733 ssize_t tpm_getcap(struct tpm_chip *chip, u32 subcap_id, cap_t *cap,
734 const char *desc, size_t min_cap_length)
735 {
736 struct tpm_buf buf;
737 int rc;
738
739 rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_GET_CAP);
740 if (rc)
741 return rc;
742
743 if (subcap_id == TPM_CAP_VERSION_1_1 ||
744 subcap_id == TPM_CAP_VERSION_1_2) {
745 tpm_buf_append_u32(&buf, subcap_id);
746 tpm_buf_append_u32(&buf, 0);
747 } else {
748 if (subcap_id == TPM_CAP_FLAG_PERM ||
749 subcap_id == TPM_CAP_FLAG_VOL)
750 tpm_buf_append_u32(&buf, TPM_CAP_FLAG);
751 else
752 tpm_buf_append_u32(&buf, TPM_CAP_PROP);
753
754 tpm_buf_append_u32(&buf, 4);
755 tpm_buf_append_u32(&buf, subcap_id);
756 }
757 rc = tpm_transmit_cmd(chip, NULL, buf.data, PAGE_SIZE,
758 min_cap_length, 0, desc);
759 if (!rc)
760 *cap = *(cap_t *)&buf.data[TPM_HEADER_SIZE + 4];
761
762 tpm_buf_destroy(&buf);
763 return rc;
764 }
765 EXPORT_SYMBOL_GPL(tpm_getcap);
766
767 int tpm_get_timeouts(struct tpm_chip *chip)
768 {
769 cap_t cap;
770 unsigned long timeout_old[4], timeout_chip[4], timeout_eff[4];
771 ssize_t rc;
772
773 if (chip->flags & TPM_CHIP_FLAG_HAVE_TIMEOUTS)
774 return 0;
775
776 if (chip->flags & TPM_CHIP_FLAG_TPM2) {
777 /* Fixed timeouts for TPM2 */
778 chip->timeout_a = msecs_to_jiffies(TPM2_TIMEOUT_A);
779 chip->timeout_b = msecs_to_jiffies(TPM2_TIMEOUT_B);
780 chip->timeout_c = msecs_to_jiffies(TPM2_TIMEOUT_C);
781 chip->timeout_d = msecs_to_jiffies(TPM2_TIMEOUT_D);
782 chip->duration[TPM_SHORT] =
783 msecs_to_jiffies(TPM2_DURATION_SHORT);
784 chip->duration[TPM_MEDIUM] =
785 msecs_to_jiffies(TPM2_DURATION_MEDIUM);
786 chip->duration[TPM_LONG] =
787 msecs_to_jiffies(TPM2_DURATION_LONG);
788 chip->duration[TPM_LONG_LONG] =
789 msecs_to_jiffies(TPM2_DURATION_LONG_LONG);
790
791 chip->flags |= TPM_CHIP_FLAG_HAVE_TIMEOUTS;
792 return 0;
793 }
794
795 rc = tpm_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &cap, NULL,
796 sizeof(cap.timeout));
797 if (rc == TPM_ERR_INVALID_POSTINIT) {
798 if (tpm_startup(chip))
799 return rc;
800
801 rc = tpm_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &cap,
802 "attempting to determine the timeouts",
803 sizeof(cap.timeout));
804 }
805
806 if (rc) {
807 dev_err(&chip->dev,
808 "A TPM error (%zd) occurred attempting to determine the timeouts\n",
809 rc);
810 return rc;
811 }
812
813 timeout_old[0] = jiffies_to_usecs(chip->timeout_a);
814 timeout_old[1] = jiffies_to_usecs(chip->timeout_b);
815 timeout_old[2] = jiffies_to_usecs(chip->timeout_c);
816 timeout_old[3] = jiffies_to_usecs(chip->timeout_d);
817 timeout_chip[0] = be32_to_cpu(cap.timeout.a);
818 timeout_chip[1] = be32_to_cpu(cap.timeout.b);
819 timeout_chip[2] = be32_to_cpu(cap.timeout.c);
820 timeout_chip[3] = be32_to_cpu(cap.timeout.d);
821 memcpy(timeout_eff, timeout_chip, sizeof(timeout_eff));
822
823 /*
824 * Provide ability for vendor overrides of timeout values in case
825 * of misreporting.
826 */
827 if (chip->ops->update_timeouts != NULL)
828 chip->timeout_adjusted =
829 chip->ops->update_timeouts(chip, timeout_eff);
830
831 if (!chip->timeout_adjusted) {
832 /* Restore default if chip reported 0 */
833 int i;
834
835 for (i = 0; i < ARRAY_SIZE(timeout_eff); i++) {
836 if (timeout_eff[i])
837 continue;
838
839 timeout_eff[i] = timeout_old[i];
840 chip->timeout_adjusted = true;
841 }
842
843 if (timeout_eff[0] != 0 && timeout_eff[0] < 1000) {
844 /* timeouts in msec rather usec */
845 for (i = 0; i != ARRAY_SIZE(timeout_eff); i++)
846 timeout_eff[i] *= 1000;
847 chip->timeout_adjusted = true;
848 }
849 }
850
851 /* Report adjusted timeouts */
852 if (chip->timeout_adjusted) {
853 dev_info(&chip->dev,
854 HW_ERR "Adjusting reported timeouts: A %lu->%luus B %lu->%luus C %lu->%luus D %lu->%luus\n",
855 timeout_chip[0], timeout_eff[0],
856 timeout_chip[1], timeout_eff[1],
857 timeout_chip[2], timeout_eff[2],
858 timeout_chip[3], timeout_eff[3]);
859 }
860
861 chip->timeout_a = usecs_to_jiffies(timeout_eff[0]);
862 chip->timeout_b = usecs_to_jiffies(timeout_eff[1]);
863 chip->timeout_c = usecs_to_jiffies(timeout_eff[2]);
864 chip->timeout_d = usecs_to_jiffies(timeout_eff[3]);
865
866 rc = tpm_getcap(chip, TPM_CAP_PROP_TIS_DURATION, &cap,
867 "attempting to determine the durations",
868 sizeof(cap.duration));
869 if (rc)
870 return rc;
871
872 chip->duration[TPM_SHORT] =
873 usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_short));
874 chip->duration[TPM_MEDIUM] =
875 usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_medium));
876 chip->duration[TPM_LONG] =
877 usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_long));
878 chip->duration[TPM_LONG_LONG] = 0; /* not used under 1.2 */
879
880 /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above
881 * value wrong and apparently reports msecs rather than usecs. So we
882 * fix up the resulting too-small TPM_SHORT value to make things work.
883 * We also scale the TPM_MEDIUM and -_LONG values by 1000.
884 */
885 if (chip->duration[TPM_SHORT] < (HZ / 100)) {
886 chip->duration[TPM_SHORT] = HZ;
887 chip->duration[TPM_MEDIUM] *= 1000;
888 chip->duration[TPM_LONG] *= 1000;
889 chip->duration_adjusted = true;
890 dev_info(&chip->dev, "Adjusting TPM timeout parameters.");
891 }
892
893 chip->flags |= TPM_CHIP_FLAG_HAVE_TIMEOUTS;
894 return 0;
895 }
896 EXPORT_SYMBOL_GPL(tpm_get_timeouts);
897
898 #define TPM_ORD_CONTINUE_SELFTEST 83
899 #define CONTINUE_SELFTEST_RESULT_SIZE 10
900
901 static const struct tpm_input_header continue_selftest_header = {
902 .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND),
903 .length = cpu_to_be32(10),
904 .ordinal = cpu_to_be32(TPM_ORD_CONTINUE_SELFTEST),
905 };
906
907 /**
908 * tpm_continue_selftest -- run TPM's selftest
909 * @chip: TPM chip to use
910 *
911 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
912 * a TPM error code.
913 */
914 static int tpm_continue_selftest(struct tpm_chip *chip)
915 {
916 int rc;
917 struct tpm_cmd_t cmd;
918
919 cmd.header.in = continue_selftest_header;
920 rc = tpm_transmit_cmd(chip, NULL, &cmd, CONTINUE_SELFTEST_RESULT_SIZE,
921 0, 0, "continue selftest");
922 return rc;
923 }
924
925 #define TPM_ORDINAL_PCRREAD 21
926 #define READ_PCR_RESULT_SIZE 30
927 #define READ_PCR_RESULT_BODY_SIZE 20
928 static const struct tpm_input_header pcrread_header = {
929 .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND),
930 .length = cpu_to_be32(14),
931 .ordinal = cpu_to_be32(TPM_ORDINAL_PCRREAD)
932 };
933
934 int tpm_pcr_read_dev(struct tpm_chip *chip, int pcr_idx, u8 *res_buf)
935 {
936 int rc;
937 struct tpm_cmd_t cmd;
938
939 cmd.header.in = pcrread_header;
940 cmd.params.pcrread_in.pcr_idx = cpu_to_be32(pcr_idx);
941 rc = tpm_transmit_cmd(chip, NULL, &cmd, READ_PCR_RESULT_SIZE,
942 READ_PCR_RESULT_BODY_SIZE, 0,
943 "attempting to read a pcr value");
944
945 if (rc == 0)
946 memcpy(res_buf, cmd.params.pcrread_out.pcr_result,
947 TPM_DIGEST_SIZE);
948 return rc;
949 }
950
951 /**
952 * tpm_is_tpm2 - do we a have a TPM2 chip?
953 * @chip: a &struct tpm_chip instance, %NULL for the default chip
954 *
955 * Return:
956 * 1 if we have a TPM2 chip.
957 * 0 if we don't have a TPM2 chip.
958 * A negative number for system errors (errno).
959 */
960 int tpm_is_tpm2(struct tpm_chip *chip)
961 {
962 int rc;
963
964 chip = tpm_chip_find_get(chip);
965 if (!chip)
966 return -ENODEV;
967
968 rc = (chip->flags & TPM_CHIP_FLAG_TPM2) != 0;
969
970 tpm_put_ops(chip);
971
972 return rc;
973 }
974 EXPORT_SYMBOL_GPL(tpm_is_tpm2);
975
976 /**
977 * tpm_pcr_read - read a PCR value from SHA1 bank
978 * @chip: a &struct tpm_chip instance, %NULL for the default chip
979 * @pcr_idx: the PCR to be retrieved
980 * @res_buf: the value of the PCR
981 *
982 * Return: same as with tpm_transmit_cmd()
983 */
984 int tpm_pcr_read(struct tpm_chip *chip, int pcr_idx, u8 *res_buf)
985 {
986 int rc;
987
988 chip = tpm_chip_find_get(chip);
989 if (!chip)
990 return -ENODEV;
991 if (chip->flags & TPM_CHIP_FLAG_TPM2)
992 rc = tpm2_pcr_read(chip, pcr_idx, res_buf);
993 else
994 rc = tpm_pcr_read_dev(chip, pcr_idx, res_buf);
995 tpm_put_ops(chip);
996 return rc;
997 }
998 EXPORT_SYMBOL_GPL(tpm_pcr_read);
999
1000 #define TPM_ORD_PCR_EXTEND 20
1001 #define EXTEND_PCR_RESULT_SIZE 34
1002 #define EXTEND_PCR_RESULT_BODY_SIZE 20
1003 static const struct tpm_input_header pcrextend_header = {
1004 .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND),
1005 .length = cpu_to_be32(34),
1006 .ordinal = cpu_to_be32(TPM_ORD_PCR_EXTEND)
1007 };
1008
1009 static int tpm1_pcr_extend(struct tpm_chip *chip, int pcr_idx, const u8 *hash,
1010 char *log_msg)
1011 {
1012 struct tpm_buf buf;
1013 int rc;
1014
1015 rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_PCR_EXTEND);
1016 if (rc)
1017 return rc;
1018
1019 tpm_buf_append_u32(&buf, pcr_idx);
1020 tpm_buf_append(&buf, hash, TPM_DIGEST_SIZE);
1021
1022 rc = tpm_transmit_cmd(chip, NULL, buf.data, EXTEND_PCR_RESULT_SIZE,
1023 EXTEND_PCR_RESULT_BODY_SIZE, 0, log_msg);
1024 tpm_buf_destroy(&buf);
1025 return rc;
1026 }
1027
1028 /**
1029 * tpm_pcr_extend - extend a PCR value in SHA1 bank.
1030 * @chip: a &struct tpm_chip instance, %NULL for the default chip
1031 * @pcr_idx: the PCR to be retrieved
1032 * @hash: the hash value used to extend the PCR value
1033 *
1034 * Note: with TPM 2.0 extends also those banks with a known digest size to the
1035 * cryto subsystem in order to prevent malicious use of those PCR banks. In the
1036 * future we should dynamically determine digest sizes.
1037 *
1038 * Return: same as with tpm_transmit_cmd()
1039 */
1040 int tpm_pcr_extend(struct tpm_chip *chip, int pcr_idx, const u8 *hash)
1041 {
1042 int rc;
1043 struct tpm2_digest digest_list[ARRAY_SIZE(chip->active_banks)];
1044 u32 count = 0;
1045 int i;
1046
1047 chip = tpm_chip_find_get(chip);
1048 if (!chip)
1049 return -ENODEV;
1050
1051 if (chip->flags & TPM_CHIP_FLAG_TPM2) {
1052 memset(digest_list, 0, sizeof(digest_list));
1053
1054 for (i = 0; i < ARRAY_SIZE(chip->active_banks) &&
1055 chip->active_banks[i] != TPM2_ALG_ERROR; i++) {
1056 digest_list[i].alg_id = chip->active_banks[i];
1057 memcpy(digest_list[i].digest, hash, TPM_DIGEST_SIZE);
1058 count++;
1059 }
1060
1061 rc = tpm2_pcr_extend(chip, pcr_idx, count, digest_list);
1062 tpm_put_ops(chip);
1063 return rc;
1064 }
1065
1066 rc = tpm1_pcr_extend(chip, pcr_idx, hash,
1067 "attempting extend a PCR value");
1068 tpm_put_ops(chip);
1069 return rc;
1070 }
1071 EXPORT_SYMBOL_GPL(tpm_pcr_extend);
1072
1073 /**
1074 * tpm_do_selftest - have the TPM continue its selftest and wait until it
1075 * can receive further commands
1076 * @chip: TPM chip to use
1077 *
1078 * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
1079 * a TPM error code.
1080 */
1081 int tpm_do_selftest(struct tpm_chip *chip)
1082 {
1083 int rc;
1084 unsigned int loops;
1085 unsigned int delay_msec = 100;
1086 unsigned long duration;
1087 u8 dummy[TPM_DIGEST_SIZE];
1088
1089 duration = tpm_calc_ordinal_duration(chip, TPM_ORD_CONTINUE_SELFTEST);
1090
1091 loops = jiffies_to_msecs(duration) / delay_msec;
1092
1093 rc = tpm_continue_selftest(chip);
1094 if (rc == TPM_ERR_INVALID_POSTINIT) {
1095 chip->flags |= TPM_CHIP_FLAG_ALWAYS_POWERED;
1096 dev_info(&chip->dev, "TPM not ready (%d)\n", rc);
1097 }
1098 /* This may fail if there was no TPM driver during a suspend/resume
1099 * cycle; some may return 10 (BAD_ORDINAL), others 28 (FAILEDSELFTEST)
1100 */
1101 if (rc)
1102 return rc;
1103
1104 do {
1105 /* Attempt to read a PCR value */
1106 rc = tpm_pcr_read_dev(chip, 0, dummy);
1107
1108 /* Some buggy TPMs will not respond to tpm_tis_ready() for
1109 * around 300ms while the self test is ongoing, keep trying
1110 * until the self test duration expires. */
1111 if (rc == -ETIME) {
1112 dev_info(
1113 &chip->dev, HW_ERR
1114 "TPM command timed out during continue self test");
1115 tpm_msleep(delay_msec);
1116 continue;
1117 }
1118
1119 if (rc == TPM_ERR_DISABLED || rc == TPM_ERR_DEACTIVATED) {
1120 dev_info(&chip->dev,
1121 "TPM is disabled/deactivated (0x%X)\n", rc);
1122 /* TPM is disabled and/or deactivated; driver can
1123 * proceed and TPM does handle commands for
1124 * suspend/resume correctly
1125 */
1126 return 0;
1127 }
1128 if (rc != TPM_WARN_DOING_SELFTEST)
1129 return rc;
1130 tpm_msleep(delay_msec);
1131 } while (--loops > 0);
1132
1133 return rc;
1134 }
1135 EXPORT_SYMBOL_GPL(tpm_do_selftest);
1136
1137 /**
1138 * tpm1_auto_startup - Perform the standard automatic TPM initialization
1139 * sequence
1140 * @chip: TPM chip to use
1141 *
1142 * Returns 0 on success, < 0 in case of fatal error.
1143 */
1144 int tpm1_auto_startup(struct tpm_chip *chip)
1145 {
1146 int rc;
1147
1148 rc = tpm_get_timeouts(chip);
1149 if (rc)
1150 goto out;
1151 rc = tpm_do_selftest(chip);
1152 if (rc) {
1153 dev_err(&chip->dev, "TPM self test failed\n");
1154 goto out;
1155 }
1156
1157 return rc;
1158 out:
1159 if (rc > 0)
1160 rc = -ENODEV;
1161 return rc;
1162 }
1163
1164 /**
1165 * tpm_send - send a TPM command
1166 * @chip: a &struct tpm_chip instance, %NULL for the default chip
1167 * @cmd: a TPM command buffer
1168 * @buflen: the length of the TPM command buffer
1169 *
1170 * Return: same as with tpm_transmit_cmd()
1171 */
1172 int tpm_send(struct tpm_chip *chip, void *cmd, size_t buflen)
1173 {
1174 int rc;
1175
1176 chip = tpm_chip_find_get(chip);
1177 if (!chip)
1178 return -ENODEV;
1179
1180 rc = tpm_transmit_cmd(chip, NULL, cmd, buflen, 0, 0,
1181 "attempting to a send a command");
1182 tpm_put_ops(chip);
1183 return rc;
1184 }
1185 EXPORT_SYMBOL_GPL(tpm_send);
1186
1187 #define TPM_ORD_SAVESTATE 152
1188 #define SAVESTATE_RESULT_SIZE 10
1189
1190 static const struct tpm_input_header savestate_header = {
1191 .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND),
1192 .length = cpu_to_be32(10),
1193 .ordinal = cpu_to_be32(TPM_ORD_SAVESTATE)
1194 };
1195
1196 /*
1197 * We are about to suspend. Save the TPM state
1198 * so that it can be restored.
1199 */
1200 int tpm_pm_suspend(struct device *dev)
1201 {
1202 struct tpm_chip *chip = dev_get_drvdata(dev);
1203 struct tpm_cmd_t cmd;
1204 int rc, try;
1205
1206 u8 dummy_hash[TPM_DIGEST_SIZE] = { 0 };
1207
1208 if (chip == NULL)
1209 return -ENODEV;
1210
1211 if (chip->flags & TPM_CHIP_FLAG_ALWAYS_POWERED)
1212 return 0;
1213
1214 if (chip->flags & TPM_CHIP_FLAG_TPM2) {
1215 tpm2_shutdown(chip, TPM2_SU_STATE);
1216 return 0;
1217 }
1218
1219 /* for buggy tpm, flush pcrs with extend to selected dummy */
1220 if (tpm_suspend_pcr)
1221 rc = tpm1_pcr_extend(chip, tpm_suspend_pcr, dummy_hash,
1222 "extending dummy pcr before suspend");
1223
1224 /* now do the actual savestate */
1225 for (try = 0; try < TPM_RETRY; try++) {
1226 cmd.header.in = savestate_header;
1227 rc = tpm_transmit_cmd(chip, NULL, &cmd, SAVESTATE_RESULT_SIZE,
1228 0, 0, NULL);
1229
1230 /*
1231 * If the TPM indicates that it is too busy to respond to
1232 * this command then retry before giving up. It can take
1233 * several seconds for this TPM to be ready.
1234 *
1235 * This can happen if the TPM has already been sent the
1236 * SaveState command before the driver has loaded. TCG 1.2
1237 * specification states that any communication after SaveState
1238 * may cause the TPM to invalidate previously saved state.
1239 */
1240 if (rc != TPM_WARN_RETRY)
1241 break;
1242 tpm_msleep(TPM_TIMEOUT_RETRY);
1243 }
1244
1245 if (rc)
1246 dev_err(&chip->dev,
1247 "Error (%d) sending savestate before suspend\n", rc);
1248 else if (try > 0)
1249 dev_warn(&chip->dev, "TPM savestate took %dms\n",
1250 try * TPM_TIMEOUT_RETRY);
1251
1252 return rc;
1253 }
1254 EXPORT_SYMBOL_GPL(tpm_pm_suspend);
1255
1256 /*
1257 * Resume from a power safe. The BIOS already restored
1258 * the TPM state.
1259 */
1260 int tpm_pm_resume(struct device *dev)
1261 {
1262 struct tpm_chip *chip = dev_get_drvdata(dev);
1263
1264 if (chip == NULL)
1265 return -ENODEV;
1266
1267 return 0;
1268 }
1269 EXPORT_SYMBOL_GPL(tpm_pm_resume);
1270
1271 #define TPM_GETRANDOM_RESULT_SIZE 18
1272 static const struct tpm_input_header tpm_getrandom_header = {
1273 .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND),
1274 .length = cpu_to_be32(14),
1275 .ordinal = cpu_to_be32(TPM_ORD_GET_RANDOM)
1276 };
1277
1278 /**
1279 * tpm_get_random() - get random bytes from the TPM's RNG
1280 * @chip: a &struct tpm_chip instance, %NULL for the default chip
1281 * @out: destination buffer for the random bytes
1282 * @max: the max number of bytes to write to @out
1283 *
1284 * Return: same as with tpm_transmit_cmd()
1285 */
1286 int tpm_get_random(struct tpm_chip *chip, u8 *out, size_t max)
1287 {
1288 struct tpm_cmd_t tpm_cmd;
1289 u32 recd, num_bytes = min_t(u32, max, TPM_MAX_RNG_DATA), rlength;
1290 int err, total = 0, retries = 5;
1291 u8 *dest = out;
1292
1293 if (!out || !num_bytes || max > TPM_MAX_RNG_DATA)
1294 return -EINVAL;
1295
1296 chip = tpm_chip_find_get(chip);
1297 if (!chip)
1298 return -ENODEV;
1299
1300 if (chip->flags & TPM_CHIP_FLAG_TPM2) {
1301 err = tpm2_get_random(chip, out, max);
1302 tpm_put_ops(chip);
1303 return err;
1304 }
1305
1306 do {
1307 tpm_cmd.header.in = tpm_getrandom_header;
1308 tpm_cmd.params.getrandom_in.num_bytes = cpu_to_be32(num_bytes);
1309
1310 err = tpm_transmit_cmd(chip, NULL, &tpm_cmd,
1311 TPM_GETRANDOM_RESULT_SIZE + num_bytes,
1312 offsetof(struct tpm_getrandom_out,
1313 rng_data),
1314 0, "attempting get random");
1315 if (err)
1316 break;
1317
1318 recd = be32_to_cpu(tpm_cmd.params.getrandom_out.rng_data_len);
1319 if (recd > num_bytes) {
1320 total = -EFAULT;
1321 break;
1322 }
1323
1324 rlength = be32_to_cpu(tpm_cmd.header.out.length);
1325 if (rlength < offsetof(struct tpm_getrandom_out, rng_data) +
1326 recd) {
1327 total = -EFAULT;
1328 break;
1329 }
1330 memcpy(dest, tpm_cmd.params.getrandom_out.rng_data, recd);
1331
1332 dest += recd;
1333 total += recd;
1334 num_bytes -= recd;
1335 } while (retries-- && total < max);
1336
1337 tpm_put_ops(chip);
1338 return total ? total : -EIO;
1339 }
1340 EXPORT_SYMBOL_GPL(tpm_get_random);
1341
1342 /**
1343 * tpm_seal_trusted() - seal a trusted key payload
1344 * @chip: a &struct tpm_chip instance, %NULL for the default chip
1345 * @options: authentication values and other options
1346 * @payload: the key data in clear and encrypted form
1347 *
1348 * Note: only TPM 2.0 chip are supported. TPM 1.x implementation is located in
1349 * the keyring subsystem.
1350 *
1351 * Return: same as with tpm_transmit_cmd()
1352 */
1353 int tpm_seal_trusted(struct tpm_chip *chip, struct trusted_key_payload *payload,
1354 struct trusted_key_options *options)
1355 {
1356 int rc;
1357
1358 chip = tpm_chip_find_get(chip);
1359 if (!chip || !(chip->flags & TPM_CHIP_FLAG_TPM2))
1360 return -ENODEV;
1361
1362 rc = tpm2_seal_trusted(chip, payload, options);
1363
1364 tpm_put_ops(chip);
1365 return rc;
1366 }
1367 EXPORT_SYMBOL_GPL(tpm_seal_trusted);
1368
1369 /**
1370 * tpm_unseal_trusted() - unseal a trusted key
1371 * @chip: a &struct tpm_chip instance, %NULL for the default chip
1372 * @options: authentication values and other options
1373 * @payload: the key data in clear and encrypted form
1374 *
1375 * Note: only TPM 2.0 chip are supported. TPM 1.x implementation is located in
1376 * the keyring subsystem.
1377 *
1378 * Return: same as with tpm_transmit_cmd()
1379 */
1380 int tpm_unseal_trusted(struct tpm_chip *chip,
1381 struct trusted_key_payload *payload,
1382 struct trusted_key_options *options)
1383 {
1384 int rc;
1385
1386 chip = tpm_chip_find_get(chip);
1387 if (!chip || !(chip->flags & TPM_CHIP_FLAG_TPM2))
1388 return -ENODEV;
1389
1390 rc = tpm2_unseal_trusted(chip, payload, options);
1391
1392 tpm_put_ops(chip);
1393
1394 return rc;
1395 }
1396 EXPORT_SYMBOL_GPL(tpm_unseal_trusted);
1397
1398 static int __init tpm_init(void)
1399 {
1400 int rc;
1401
1402 tpm_class = class_create(THIS_MODULE, "tpm");
1403 if (IS_ERR(tpm_class)) {
1404 pr_err("couldn't create tpm class\n");
1405 return PTR_ERR(tpm_class);
1406 }
1407
1408 tpmrm_class = class_create(THIS_MODULE, "tpmrm");
1409 if (IS_ERR(tpmrm_class)) {
1410 pr_err("couldn't create tpmrm class\n");
1411 class_destroy(tpm_class);
1412 return PTR_ERR(tpmrm_class);
1413 }
1414
1415 rc = alloc_chrdev_region(&tpm_devt, 0, 2*TPM_NUM_DEVICES, "tpm");
1416 if (rc < 0) {
1417 pr_err("tpm: failed to allocate char dev region\n");
1418 class_destroy(tpmrm_class);
1419 class_destroy(tpm_class);
1420 return rc;
1421 }
1422
1423 return 0;
1424 }
1425
1426 static void __exit tpm_exit(void)
1427 {
1428 idr_destroy(&dev_nums_idr);
1429 class_destroy(tpm_class);
1430 class_destroy(tpmrm_class);
1431 unregister_chrdev_region(tpm_devt, 2*TPM_NUM_DEVICES);
1432 }
1433
1434 subsys_initcall(tpm_init);
1435 module_exit(tpm_exit);
1436
1437 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
1438 MODULE_DESCRIPTION("TPM Driver");
1439 MODULE_VERSION("2.0");
1440 MODULE_LICENSE("GPL");
Linux with added FPC-III support