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