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