1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#include <linux/poll.h>
23#include <linux/slab.h>
24#include <linux/mutex.h>
25#include <linux/spinlock.h>
26#include <linux/freezer.h>
27#include <linux/tpm_eventlog.h>
28
29#include "tpm.h"
30
31
32
33
34
35
36static u32 tpm_suspend_pcr;
37module_param_named(suspend_pcr, tpm_suspend_pcr, uint, 0644);
38MODULE_PARM_DESC(suspend_pcr,
39 "PCR to use for dummy writes to facilitate flush on suspend.");
40
41
42
43
44
45
46
47
48
49
50
51unsigned long tpm_calc_ordinal_duration(struct tpm_chip *chip, u32 ordinal)
52{
53 if (chip->flags & TPM_CHIP_FLAG_TPM2)
54 return tpm2_calc_ordinal_duration(chip, ordinal);
55 else
56 return tpm1_calc_ordinal_duration(chip, ordinal);
57}
58EXPORT_SYMBOL_GPL(tpm_calc_ordinal_duration);
59
60static ssize_t tpm_try_transmit(struct tpm_chip *chip, void *buf, size_t bufsiz)
61{
62 struct tpm_header *header = buf;
63 int rc;
64 ssize_t len = 0;
65 u32 count, ordinal;
66 unsigned long stop;
67
68 if (bufsiz < TPM_HEADER_SIZE)
69 return -EINVAL;
70
71 if (bufsiz > TPM_BUFSIZE)
72 bufsiz = TPM_BUFSIZE;
73
74 count = be32_to_cpu(header->length);
75 ordinal = be32_to_cpu(header->ordinal);
76 if (count == 0)
77 return -ENODATA;
78 if (count > bufsiz) {
79 dev_err(&chip->dev,
80 "invalid count value %x %zx\n", count, bufsiz);
81 return -E2BIG;
82 }
83
84 rc = chip->ops->send(chip, buf, count);
85 if (rc < 0) {
86 if (rc != -EPIPE)
87 dev_err(&chip->dev,
88 "%s: send(): error %d\n", __func__, rc);
89 return rc;
90 }
91
92
93
94
95 if (rc > 0) {
96 dev_warn(&chip->dev,
97 "%s: send(): invalid value %d\n", __func__, rc);
98 rc = 0;
99 }
100
101 if (chip->flags & TPM_CHIP_FLAG_IRQ)
102 goto out_recv;
103
104 stop = jiffies + tpm_calc_ordinal_duration(chip, ordinal);
105 do {
106 u8 status = chip->ops->status(chip);
107 if ((status & chip->ops->req_complete_mask) ==
108 chip->ops->req_complete_val)
109 goto out_recv;
110
111 if (chip->ops->req_canceled(chip, status)) {
112 dev_err(&chip->dev, "Operation Canceled\n");
113 return -ECANCELED;
114 }
115
116 tpm_msleep(TPM_TIMEOUT_POLL);
117 rmb();
118 } while (time_before(jiffies, stop));
119
120 chip->ops->cancel(chip);
121 dev_err(&chip->dev, "Operation Timed out\n");
122 return -ETIME;
123
124out_recv:
125 len = chip->ops->recv(chip, buf, bufsiz);
126 if (len < 0) {
127 rc = len;
128 dev_err(&chip->dev, "tpm_transmit: tpm_recv: error %d\n", rc);
129 } else if (len < TPM_HEADER_SIZE || len != be32_to_cpu(header->length))
130 rc = -EFAULT;
131
132 return rc ? rc : len;
133}
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152ssize_t tpm_transmit(struct tpm_chip *chip, u8 *buf, size_t bufsiz)
153{
154 struct tpm_header *header = (struct tpm_header *)buf;
155
156 u8 save[TPM_HEADER_SIZE + 3*sizeof(u32)];
157 unsigned int delay_msec = TPM2_DURATION_SHORT;
158 u32 rc = 0;
159 ssize_t ret;
160 const size_t save_size = min(sizeof(save), bufsiz);
161
162 u32 cc = be32_to_cpu(header->return_code);
163
164
165
166
167
168
169 memcpy(save, buf, save_size);
170
171 for (;;) {
172 ret = tpm_try_transmit(chip, buf, bufsiz);
173 if (ret < 0)
174 break;
175 rc = be32_to_cpu(header->return_code);
176 if (rc != TPM2_RC_RETRY && rc != TPM2_RC_TESTING)
177 break;
178
179
180
181
182 if (rc == TPM2_RC_TESTING && cc == TPM2_CC_SELF_TEST)
183 break;
184
185 if (delay_msec > TPM2_DURATION_LONG) {
186 if (rc == TPM2_RC_RETRY)
187 dev_err(&chip->dev, "in retry loop\n");
188 else
189 dev_err(&chip->dev,
190 "self test is still running\n");
191 break;
192 }
193 tpm_msleep(delay_msec);
194 delay_msec *= 2;
195 memcpy(buf, save, save_size);
196 }
197 return ret;
198}
199
200
201
202
203
204
205
206
207
208
209
210
211
212ssize_t tpm_transmit_cmd(struct tpm_chip *chip, struct tpm_buf *buf,
213 size_t min_rsp_body_length, const char *desc)
214{
215 const struct tpm_header *header = (struct tpm_header *)buf->data;
216 int err;
217 ssize_t len;
218
219 len = tpm_transmit(chip, buf->data, PAGE_SIZE);
220 if (len < 0)
221 return len;
222
223 err = be32_to_cpu(header->return_code);
224 if (err != 0 && err != TPM_ERR_DISABLED && err != TPM_ERR_DEACTIVATED
225 && err != TPM2_RC_TESTING && desc)
226 dev_err(&chip->dev, "A TPM error (%d) occurred %s\n", err,
227 desc);
228 if (err)
229 return err;
230
231 if (len < min_rsp_body_length + TPM_HEADER_SIZE)
232 return -EFAULT;
233
234 return 0;
235}
236EXPORT_SYMBOL_GPL(tpm_transmit_cmd);
237
238int tpm_get_timeouts(struct tpm_chip *chip)
239{
240 if (chip->flags & TPM_CHIP_FLAG_HAVE_TIMEOUTS)
241 return 0;
242
243 if (chip->flags & TPM_CHIP_FLAG_TPM2)
244 return tpm2_get_timeouts(chip);
245 else
246 return tpm1_get_timeouts(chip);
247}
248EXPORT_SYMBOL_GPL(tpm_get_timeouts);
249
250
251
252
253
254
255
256
257
258
259int tpm_is_tpm2(struct tpm_chip *chip)
260{
261 int rc;
262
263 chip = tpm_find_get_ops(chip);
264 if (!chip)
265 return -ENODEV;
266
267 rc = (chip->flags & TPM_CHIP_FLAG_TPM2) != 0;
268
269 tpm_put_ops(chip);
270
271 return rc;
272}
273EXPORT_SYMBOL_GPL(tpm_is_tpm2);
274
275
276
277
278
279
280
281
282
283int tpm_pcr_read(struct tpm_chip *chip, u32 pcr_idx,
284 struct tpm_digest *digest)
285{
286 int rc;
287
288 chip = tpm_find_get_ops(chip);
289 if (!chip)
290 return -ENODEV;
291
292 if (chip->flags & TPM_CHIP_FLAG_TPM2)
293 rc = tpm2_pcr_read(chip, pcr_idx, digest, NULL);
294 else
295 rc = tpm1_pcr_read(chip, pcr_idx, digest->digest);
296
297 tpm_put_ops(chip);
298 return rc;
299}
300EXPORT_SYMBOL_GPL(tpm_pcr_read);
301
302
303
304
305
306
307
308
309
310
311
312
313int tpm_pcr_extend(struct tpm_chip *chip, u32 pcr_idx,
314 struct tpm_digest *digests)
315{
316 int rc;
317 int i;
318
319 chip = tpm_find_get_ops(chip);
320 if (!chip)
321 return -ENODEV;
322
323 for (i = 0; i < chip->nr_allocated_banks; i++)
324 if (digests[i].alg_id != chip->allocated_banks[i].alg_id)
325 return -EINVAL;
326
327 if (chip->flags & TPM_CHIP_FLAG_TPM2) {
328 rc = tpm2_pcr_extend(chip, pcr_idx, digests);
329 tpm_put_ops(chip);
330 return rc;
331 }
332
333 rc = tpm1_pcr_extend(chip, pcr_idx, digests[0].digest,
334 "attempting extend a PCR value");
335 tpm_put_ops(chip);
336 return rc;
337}
338EXPORT_SYMBOL_GPL(tpm_pcr_extend);
339
340
341
342
343
344
345
346
347
348int tpm_send(struct tpm_chip *chip, void *cmd, size_t buflen)
349{
350 struct tpm_buf buf;
351 int rc;
352
353 chip = tpm_find_get_ops(chip);
354 if (!chip)
355 return -ENODEV;
356
357 rc = tpm_buf_init(&buf, 0, 0);
358 if (rc)
359 goto out;
360
361 memcpy(buf.data, cmd, buflen);
362 rc = tpm_transmit_cmd(chip, &buf, 0, "attempting to a send a command");
363 tpm_buf_destroy(&buf);
364out:
365 tpm_put_ops(chip);
366 return rc;
367}
368EXPORT_SYMBOL_GPL(tpm_send);
369
370int tpm_auto_startup(struct tpm_chip *chip)
371{
372 int rc;
373
374 if (!(chip->ops->flags & TPM_OPS_AUTO_STARTUP))
375 return 0;
376
377 if (chip->flags & TPM_CHIP_FLAG_TPM2)
378 rc = tpm2_auto_startup(chip);
379 else
380 rc = tpm1_auto_startup(chip);
381
382 return rc;
383}
384
385
386
387
388
389int tpm_pm_suspend(struct device *dev)
390{
391 struct tpm_chip *chip = dev_get_drvdata(dev);
392 int rc = 0;
393
394 if (!chip)
395 return -ENODEV;
396
397 if (chip->flags & TPM_CHIP_FLAG_ALWAYS_POWERED)
398 return 0;
399
400 if (!tpm_chip_start(chip)) {
401 if (chip->flags & TPM_CHIP_FLAG_TPM2)
402 tpm2_shutdown(chip, TPM2_SU_STATE);
403 else
404 rc = tpm1_pm_suspend(chip, tpm_suspend_pcr);
405
406 tpm_chip_stop(chip);
407 }
408
409 return rc;
410}
411EXPORT_SYMBOL_GPL(tpm_pm_suspend);
412
413
414
415
416
417int tpm_pm_resume(struct device *dev)
418{
419 struct tpm_chip *chip = dev_get_drvdata(dev);
420
421 if (chip == NULL)
422 return -ENODEV;
423
424 return 0;
425}
426EXPORT_SYMBOL_GPL(tpm_pm_resume);
427
428
429
430
431
432
433
434
435
436int tpm_get_random(struct tpm_chip *chip, u8 *out, size_t max)
437{
438 int rc;
439
440 if (!out || max > TPM_MAX_RNG_DATA)
441 return -EINVAL;
442
443 chip = tpm_find_get_ops(chip);
444 if (!chip)
445 return -ENODEV;
446
447 if (chip->flags & TPM_CHIP_FLAG_TPM2)
448 rc = tpm2_get_random(chip, out, max);
449 else
450 rc = tpm1_get_random(chip, out, max);
451
452 tpm_put_ops(chip);
453 return rc;
454}
455EXPORT_SYMBOL_GPL(tpm_get_random);
456
457
458
459
460
461
462
463
464
465
466
467
468int tpm_seal_trusted(struct tpm_chip *chip, struct trusted_key_payload *payload,
469 struct trusted_key_options *options)
470{
471 int rc;
472
473 chip = tpm_find_get_ops(chip);
474 if (!chip || !(chip->flags & TPM_CHIP_FLAG_TPM2))
475 return -ENODEV;
476
477 rc = tpm2_seal_trusted(chip, payload, options);
478
479 tpm_put_ops(chip);
480 return rc;
481}
482EXPORT_SYMBOL_GPL(tpm_seal_trusted);
483
484
485
486
487
488
489
490
491
492
493
494
495int tpm_unseal_trusted(struct tpm_chip *chip,
496 struct trusted_key_payload *payload,
497 struct trusted_key_options *options)
498{
499 int rc;
500
501 chip = tpm_find_get_ops(chip);
502 if (!chip || !(chip->flags & TPM_CHIP_FLAG_TPM2))
503 return -ENODEV;
504
505 rc = tpm2_unseal_trusted(chip, payload, options);
506
507 tpm_put_ops(chip);
508
509 return rc;
510}
511EXPORT_SYMBOL_GPL(tpm_unseal_trusted);
512
513static int __init tpm_init(void)
514{
515 int rc;
516
517 tpm_class = class_create(THIS_MODULE, "tpm");
518 if (IS_ERR(tpm_class)) {
519 pr_err("couldn't create tpm class\n");
520 return PTR_ERR(tpm_class);
521 }
522
523 tpmrm_class = class_create(THIS_MODULE, "tpmrm");
524 if (IS_ERR(tpmrm_class)) {
525 pr_err("couldn't create tpmrm class\n");
526 rc = PTR_ERR(tpmrm_class);
527 goto out_destroy_tpm_class;
528 }
529
530 rc = alloc_chrdev_region(&tpm_devt, 0, 2*TPM_NUM_DEVICES, "tpm");
531 if (rc < 0) {
532 pr_err("tpm: failed to allocate char dev region\n");
533 goto out_destroy_tpmrm_class;
534 }
535
536 rc = tpm_dev_common_init();
537 if (rc) {
538 pr_err("tpm: failed to allocate char dev region\n");
539 goto out_unreg_chrdev;
540 }
541
542 return 0;
543
544out_unreg_chrdev:
545 unregister_chrdev_region(tpm_devt, 2 * TPM_NUM_DEVICES);
546out_destroy_tpmrm_class:
547 class_destroy(tpmrm_class);
548out_destroy_tpm_class:
549 class_destroy(tpm_class);
550
551 return rc;
552}
553
554static void __exit tpm_exit(void)
555{
556 idr_destroy(&dev_nums_idr);
557 class_destroy(tpm_class);
558 class_destroy(tpmrm_class);
559 unregister_chrdev_region(tpm_devt, 2*TPM_NUM_DEVICES);
560 tpm_dev_common_exit();
561}
562
563subsys_initcall(tpm_init);
564module_exit(tpm_exit);
565
566MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
567MODULE_DESCRIPTION("TPM Driver");
568MODULE_VERSION("2.0");
569MODULE_LICENSE("GPL");
570