]>
Commit | Line | Data |
---|---|---|
b886d83c | 1 | // SPDX-License-Identifier: GPL-2.0-only |
1da177e4 LT |
2 | /* |
3 | * Copyright (C) 2004 IBM Corporation | |
afb5abc2 | 4 | * Copyright (C) 2014 Intel Corporation |
1da177e4 LT |
5 | * |
6 | * Authors: | |
7 | * Leendert van Doorn <leendert@watson.ibm.com> | |
8 | * Dave Safford <safford@watson.ibm.com> | |
9 | * Reiner Sailer <sailer@watson.ibm.com> | |
10 | * Kylene Hall <kjhall@us.ibm.com> | |
11 | * | |
8e81cc13 | 12 | * Maintained by: <tpmdd-devel@lists.sourceforge.net> |
1da177e4 LT |
13 | * |
14 | * Device driver for TCG/TCPA TPM (trusted platform module). | |
0a418269 | 15 | * Specifications at www.trustedcomputinggroup.org |
1da177e4 | 16 | * |
1da177e4 LT |
17 | * Note, the TPM chip is not interrupt driven (only polling) |
18 | * and can have very long timeouts (minutes!). Hence the unusual | |
700d8bdc | 19 | * calls to msleep. |
1da177e4 LT |
20 | */ |
21 | ||
1da177e4 | 22 | #include <linux/poll.h> |
5a0e3ad6 | 23 | #include <linux/slab.h> |
d081d470 | 24 | #include <linux/mutex.h> |
1da177e4 | 25 | #include <linux/spinlock.h> |
fd048866 | 26 | #include <linux/freezer.h> |
fd3ec366 | 27 | #include <linux/tpm_eventlog.h> |
d081d470 | 28 | |
1da177e4 | 29 | #include "tpm.h" |
1da177e4 | 30 | |
9b3056cc DT |
31 | /* |
32 | * Bug workaround - some TPM's don't flush the most | |
33 | * recently changed pcr on suspend, so force the flush | |
34 | * with an extend to the selected _unused_ non-volatile pcr. | |
35 | */ | |
95adc6b4 | 36 | static u32 tpm_suspend_pcr; |
9b3056cc DT |
37 | module_param_named(suspend_pcr, tpm_suspend_pcr, uint, 0644); |
38 | MODULE_PARM_DESC(suspend_pcr, | |
39f5712b | 39 | "PCR to use for dummy writes to facilitate flush on suspend."); |
9b3056cc | 40 | |
d856c00f TW |
41 | /** |
42 | * tpm_calc_ordinal_duration() - calculate the maximum command duration | |
43 | * @chip: TPM chip to use. | |
44 | * @ordinal: TPM command ordinal. | |
45 | * | |
46 | * The function returns the maximum amount of time the chip could take | |
47 | * to return the result for a particular ordinal in jiffies. | |
48 | * | |
49 | * Return: A maximal duration time for an ordinal in jiffies. | |
50 | */ | |
51 | unsigned 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 | } | |
58 | EXPORT_SYMBOL_GPL(tpm_calc_ordinal_duration); | |
59 | ||
47a6c28b | 60 | static ssize_t tpm_try_transmit(struct tpm_chip *chip, void *buf, size_t bufsiz) |
1da177e4 | 61 | { |
b34b77a9 | 62 | struct tpm_header *header = buf; |
745b361e JS |
63 | int rc; |
64 | ssize_t len = 0; | |
9e18ee19 | 65 | u32 count, ordinal; |
700d8bdc | 66 | unsigned long stop; |
1da177e4 | 67 | |
c3465a37 JS |
68 | if (bufsiz < TPM_HEADER_SIZE) |
69 | return -EINVAL; | |
ebfd7532 | 70 | |
6b07d30a PH |
71 | if (bufsiz > TPM_BUFSIZE) |
72 | bufsiz = TPM_BUFSIZE; | |
73 | ||
720b0711 JS |
74 | count = be32_to_cpu(header->length); |
75 | ordinal = be32_to_cpu(header->ordinal); | |
1da177e4 LT |
76 | if (count == 0) |
77 | return -ENODATA; | |
78 | if (count > bufsiz) { | |
8cfffc9d | 79 | dev_err(&chip->dev, |
0a418269 | 80 | "invalid count value %x %zx\n", count, bufsiz); |
1da177e4 LT |
81 | return -E2BIG; |
82 | } | |
83 | ||
62c09e12 | 84 | rc = chip->ops->send(chip, buf, count); |
0a418269 | 85 | if (rc < 0) { |
402149c6 SB |
86 | if (rc != -EPIPE) |
87 | dev_err(&chip->dev, | |
f5595f5b | 88 | "%s: send(): error %d\n", __func__, rc); |
29b47ce9 | 89 | return rc; |
1da177e4 LT |
90 | } |
91 | ||
f5595f5b JS |
92 | /* A sanity check. send() should just return zero on success e.g. |
93 | * not the command length. | |
94 | */ | |
95 | if (rc > 0) { | |
96 | dev_warn(&chip->dev, | |
97 | "%s: send(): invalid value %d\n", __func__, rc); | |
98 | rc = 0; | |
99 | } | |
100 | ||
570a3609 | 101 | if (chip->flags & TPM_CHIP_FLAG_IRQ) |
27084efe LD |
102 | goto out_recv; |
103 | ||
d856c00f | 104 | stop = jiffies + tpm_calc_ordinal_duration(chip, ordinal); |
1da177e4 | 105 | do { |
5f82e9f0 JG |
106 | u8 status = chip->ops->status(chip); |
107 | if ((status & chip->ops->req_complete_mask) == | |
108 | chip->ops->req_complete_val) | |
1da177e4 | 109 | goto out_recv; |
d9e5b6bf | 110 | |
5f82e9f0 | 111 | if (chip->ops->req_canceled(chip, status)) { |
8cfffc9d | 112 | dev_err(&chip->dev, "Operation Canceled\n"); |
29b47ce9 | 113 | return -ECANCELED; |
d9e5b6bf KH |
114 | } |
115 | ||
59f5a6b0 | 116 | tpm_msleep(TPM_TIMEOUT_POLL); |
1da177e4 | 117 | rmb(); |
700d8bdc | 118 | } while (time_before(jiffies, stop)); |
1da177e4 | 119 | |
5f82e9f0 | 120 | chip->ops->cancel(chip); |
8cfffc9d | 121 | dev_err(&chip->dev, "Operation Timed out\n"); |
29b47ce9 | 122 | return -ETIME; |
1da177e4 LT |
123 | |
124 | out_recv: | |
62c09e12 | 125 | len = chip->ops->recv(chip, buf, bufsiz); |
745b361e JS |
126 | if (len < 0) { |
127 | rc = len; | |
304ff672 JS |
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)) | |
a147918e | 130 | rc = -EFAULT; |
745b361e | 131 | |
745b361e | 132 | return rc ? rc : len; |
1da177e4 LT |
133 | } |
134 | ||
e2fb992d JB |
135 | /** |
136 | * tpm_transmit - Internal kernel interface to transmit TPM commands. | |
412eb585 | 137 | * @chip: a TPM chip to use |
412eb585 JS |
138 | * @buf: a TPM command buffer |
139 | * @bufsiz: length of the TPM command buffer | |
e2fb992d | 140 | * |
412eb585 JS |
141 | * A wrapper around tpm_try_transmit() that handles TPM2_RC_RETRY returns from |
142 | * the TPM and retransmits the command after a delay up to a maximum wait of | |
143 | * TPM2_DURATION_LONG. | |
e2fb992d | 144 | * |
412eb585 JS |
145 | * Note that TPM 1.x never returns TPM2_RC_RETRY so the retry logic is TPM 2.0 |
146 | * only. | |
e2fb992d JB |
147 | * |
148 | * Return: | |
412eb585 JS |
149 | * * The response length - OK |
150 | * * -errno - A system error | |
e2fb992d | 151 | */ |
47a6c28b | 152 | ssize_t tpm_transmit(struct tpm_chip *chip, u8 *buf, size_t bufsiz) |
e2fb992d | 153 | { |
b34b77a9 | 154 | struct tpm_header *header = (struct tpm_header *)buf; |
e2fb992d JB |
155 | /* space for header and handles */ |
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; | |
5faafbab | 160 | const size_t save_size = min(sizeof(save), bufsiz); |
2be8ffed JB |
161 | /* the command code is where the return code will be */ |
162 | u32 cc = be32_to_cpu(header->return_code); | |
e2fb992d JB |
163 | |
164 | /* | |
165 | * Subtlety here: if we have a space, the handles will be | |
166 | * transformed, so when we restore the header we also have to | |
167 | * restore the handles. | |
168 | */ | |
169 | memcpy(save, buf, save_size); | |
170 | ||
171 | for (;;) { | |
47a6c28b | 172 | ret = tpm_try_transmit(chip, buf, bufsiz); |
e2fb992d JB |
173 | if (ret < 0) |
174 | break; | |
175 | rc = be32_to_cpu(header->return_code); | |
2be8ffed JB |
176 | if (rc != TPM2_RC_RETRY && rc != TPM2_RC_TESTING) |
177 | break; | |
178 | /* | |
179 | * return immediately if self test returns test | |
180 | * still running to shorten boot time. | |
181 | */ | |
182 | if (rc == TPM2_RC_TESTING && cc == TPM2_CC_SELF_TEST) | |
e2fb992d | 183 | break; |
92980756 | 184 | |
e2fb992d | 185 | if (delay_msec > TPM2_DURATION_LONG) { |
2be8ffed JB |
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"); | |
e2fb992d JB |
191 | break; |
192 | } | |
193 | tpm_msleep(delay_msec); | |
92980756 | 194 | delay_msec *= 2; |
e2fb992d JB |
195 | memcpy(buf, save, save_size); |
196 | } | |
197 | return ret; | |
198 | } | |
412eb585 | 199 | |
f865c196 | 200 | /** |
65520d46 | 201 | * tpm_transmit_cmd - send a tpm command to the device |
412eb585 | 202 | * @chip: a TPM chip to use |
412eb585 JS |
203 | * @buf: a TPM command buffer |
204 | * @min_rsp_body_length: minimum expected length of response body | |
412eb585 | 205 | * @desc: command description used in the error message |
f865c196 WT |
206 | * |
207 | * Return: | |
412eb585 JS |
208 | * * 0 - OK |
209 | * * -errno - A system error | |
210 | * * TPM_RC - A TPM error | |
f865c196 | 211 | */ |
5faafbab | 212 | ssize_t tpm_transmit_cmd(struct tpm_chip *chip, struct tpm_buf *buf, |
47a6c28b | 213 | size_t min_rsp_body_length, const char *desc) |
beed53a1 | 214 | { |
b34b77a9 | 215 | const struct tpm_header *header = (struct tpm_header *)buf->data; |
beed53a1 | 216 | int err; |
c659af78 | 217 | ssize_t len; |
beed53a1 | 218 | |
47a6c28b | 219 | len = tpm_transmit(chip, buf->data, PAGE_SIZE); |
beed53a1 KJH |
220 | if (len < 0) |
221 | return len; | |
87155b73 JS |
222 | |
223 | err = be32_to_cpu(header->return_code); | |
0d6d0d62 | 224 | if (err != 0 && err != TPM_ERR_DISABLED && err != TPM_ERR_DEACTIVATED |
08a8112a | 225 | && err != TPM2_RC_TESTING && desc) |
8cfffc9d | 226 | dev_err(&chip->dev, "A TPM error (%d) occurred %s\n", err, |
71ed848f | 227 | desc); |
c659af78 SB |
228 | if (err) |
229 | return err; | |
230 | ||
231 | if (len < min_rsp_body_length + TPM_HEADER_SIZE) | |
232 | return -EFAULT; | |
b9e3238a | 233 | |
c659af78 | 234 | return 0; |
beed53a1 | 235 | } |
be4c9acf | 236 | EXPORT_SYMBOL_GPL(tpm_transmit_cmd); |
beed53a1 | 237 | |
2b30a90f | 238 | int tpm_get_timeouts(struct tpm_chip *chip) |
08e96e48 | 239 | { |
d1d253cf JG |
240 | if (chip->flags & TPM_CHIP_FLAG_HAVE_TIMEOUTS) |
241 | return 0; | |
242 | ||
70a3199a TW |
243 | if (chip->flags & TPM_CHIP_FLAG_TPM2) |
244 | return tpm2_get_timeouts(chip); | |
245 | else | |
246 | return tpm1_get_timeouts(chip); | |
08e96e48 KJH |
247 | } |
248 | EXPORT_SYMBOL_GPL(tpm_get_timeouts); | |
249 | ||
954650ef | 250 | /** |
aad887f6 JS |
251 | * tpm_is_tpm2 - do we a have a TPM2 chip? |
252 | * @chip: a &struct tpm_chip instance, %NULL for the default chip | |
954650ef | 253 | * |
aad887f6 JS |
254 | * Return: |
255 | * 1 if we have a TPM2 chip. | |
256 | * 0 if we don't have a TPM2 chip. | |
257 | * A negative number for system errors (errno). | |
954650ef | 258 | */ |
aad887f6 | 259 | int tpm_is_tpm2(struct tpm_chip *chip) |
954650ef | 260 | { |
954650ef JS |
261 | int rc; |
262 | ||
fc1d52b7 | 263 | chip = tpm_find_get_ops(chip); |
aad887f6 | 264 | if (!chip) |
954650ef JS |
265 | return -ENODEV; |
266 | ||
267 | rc = (chip->flags & TPM_CHIP_FLAG_TPM2) != 0; | |
268 | ||
4e26195f | 269 | tpm_put_ops(chip); |
954650ef JS |
270 | |
271 | return rc; | |
272 | } | |
273 | EXPORT_SYMBOL_GPL(tpm_is_tpm2); | |
274 | ||
659aaf2b | 275 | /** |
aad887f6 JS |
276 | * tpm_pcr_read - read a PCR value from SHA1 bank |
277 | * @chip: a &struct tpm_chip instance, %NULL for the default chip | |
278 | * @pcr_idx: the PCR to be retrieved | |
879b5892 | 279 | * @digest: the PCR bank and buffer current PCR value is written to |
659aaf2b | 280 | * |
aad887f6 | 281 | * Return: same as with tpm_transmit_cmd() |
659aaf2b | 282 | */ |
879b5892 RS |
283 | int tpm_pcr_read(struct tpm_chip *chip, u32 pcr_idx, |
284 | struct tpm_digest *digest) | |
659aaf2b | 285 | { |
659aaf2b RA |
286 | int rc; |
287 | ||
fc1d52b7 | 288 | chip = tpm_find_get_ops(chip); |
aad887f6 | 289 | if (!chip) |
659aaf2b | 290 | return -ENODEV; |
d4a31756 | 291 | |
7a1d7e6d | 292 | if (chip->flags & TPM_CHIP_FLAG_TPM2) |
879b5892 | 293 | rc = tpm2_pcr_read(chip, pcr_idx, digest, NULL); |
7a1d7e6d | 294 | else |
879b5892 | 295 | rc = tpm1_pcr_read(chip, pcr_idx, digest->digest); |
d4a31756 | 296 | |
4e26195f | 297 | tpm_put_ops(chip); |
659aaf2b RA |
298 | return rc; |
299 | } | |
300 | EXPORT_SYMBOL_GPL(tpm_pcr_read); | |
301 | ||
302 | /** | |
aad887f6 JS |
303 | * tpm_pcr_extend - extend a PCR value in SHA1 bank. |
304 | * @chip: a &struct tpm_chip instance, %NULL for the default chip | |
305 | * @pcr_idx: the PCR to be retrieved | |
0b6cf6b9 | 306 | * @digests: array of tpm_digest structures used to extend PCRs |
659aaf2b | 307 | * |
0b6cf6b9 RS |
308 | * Note: callers must pass a digest for every allocated PCR bank, in the same |
309 | * order of the banks in chip->allocated_banks. | |
aad887f6 JS |
310 | * |
311 | * Return: same as with tpm_transmit_cmd() | |
659aaf2b | 312 | */ |
0b6cf6b9 RS |
313 | int tpm_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, |
314 | struct tpm_digest *digests) | |
659aaf2b | 315 | { |
659aaf2b | 316 | int rc; |
c1f92b4b | 317 | int i; |
659aaf2b | 318 | |
fc1d52b7 | 319 | chip = tpm_find_get_ops(chip); |
aad887f6 | 320 | if (!chip) |
659aaf2b RA |
321 | return -ENODEV; |
322 | ||
0b6cf6b9 RS |
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; | |
c1f92b4b | 326 | |
0b6cf6b9 RS |
327 | if (chip->flags & TPM_CHIP_FLAG_TPM2) { |
328 | rc = tpm2_pcr_extend(chip, pcr_idx, digests); | |
4e26195f | 329 | tpm_put_ops(chip); |
7a1d7e6d JS |
330 | return rc; |
331 | } | |
332 | ||
0b6cf6b9 | 333 | rc = tpm1_pcr_extend(chip, pcr_idx, digests[0].digest, |
175d5b2a | 334 | "attempting extend a PCR value"); |
4e26195f | 335 | tpm_put_ops(chip); |
659aaf2b RA |
336 | return rc; |
337 | } | |
338 | EXPORT_SYMBOL_GPL(tpm_pcr_extend); | |
339 | ||
aad887f6 JS |
340 | /** |
341 | * tpm_send - send a TPM command | |
342 | * @chip: a &struct tpm_chip instance, %NULL for the default chip | |
343 | * @cmd: a TPM command buffer | |
344 | * @buflen: the length of the TPM command buffer | |
345 | * | |
346 | * Return: same as with tpm_transmit_cmd() | |
347 | */ | |
348 | int tpm_send(struct tpm_chip *chip, void *cmd, size_t buflen) | |
c749ba91 | 349 | { |
412eb585 | 350 | struct tpm_buf buf; |
c749ba91 MZ |
351 | int rc; |
352 | ||
fc1d52b7 | 353 | chip = tpm_find_get_ops(chip); |
aad887f6 | 354 | if (!chip) |
c749ba91 MZ |
355 | return -ENODEV; |
356 | ||
412eb585 JS |
357 | rc = tpm_buf_init(&buf, 0, 0); |
358 | if (rc) | |
359 | goto out; | |
360 | ||
361 | memcpy(buf.data, cmd, buflen); | |
47a6c28b | 362 | rc = tpm_transmit_cmd(chip, &buf, 0, "attempting to a send a command"); |
412eb585 JS |
363 | tpm_buf_destroy(&buf); |
364 | out: | |
4e26195f | 365 | tpm_put_ops(chip); |
c749ba91 MZ |
366 | return rc; |
367 | } | |
368 | EXPORT_SYMBOL_GPL(tpm_send); | |
369 | ||
b03c4370 TW |
370 | int 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 | ||
1da177e4 LT |
385 | /* |
386 | * We are about to suspend. Save the TPM state | |
387 | * so that it can be restored. | |
388 | */ | |
035e2ce8 | 389 | int tpm_pm_suspend(struct device *dev) |
1da177e4 | 390 | { |
ec03c50b | 391 | struct tpm_chip *chip = dev_get_drvdata(dev); |
c82a330c | 392 | int rc = 0; |
2490c681 | 393 | |
c82a330c | 394 | if (!chip) |
1da177e4 LT |
395 | return -ENODEV; |
396 | ||
b5d0ebc9 EBS |
397 | if (chip->flags & TPM_CHIP_FLAG_ALWAYS_POWERED) |
398 | return 0; | |
399 | ||
e891db1a JS |
400 | if (!tpm_chip_start(chip)) { |
401 | if (chip->flags & TPM_CHIP_FLAG_TPM2) | |
a3fbfae8 | 402 | tpm2_shutdown(chip, TPM2_SU_STATE); |
e891db1a JS |
403 | else |
404 | rc = tpm1_pm_suspend(chip, tpm_suspend_pcr); | |
405 | ||
406 | tpm_chip_stop(chip); | |
a3fbfae8 | 407 | } |
32d33b29 | 408 | |
225a9be2 | 409 | return rc; |
1da177e4 | 410 | } |
1da177e4 LT |
411 | EXPORT_SYMBOL_GPL(tpm_pm_suspend); |
412 | ||
413 | /* | |
414 | * Resume from a power safe. The BIOS already restored | |
415 | * the TPM state. | |
416 | */ | |
ce2c87d4 | 417 | int tpm_pm_resume(struct device *dev) |
1da177e4 | 418 | { |
ec03c50b | 419 | struct tpm_chip *chip = dev_get_drvdata(dev); |
1da177e4 LT |
420 | |
421 | if (chip == NULL) | |
422 | return -ENODEV; | |
423 | ||
1da177e4 LT |
424 | return 0; |
425 | } | |
1da177e4 LT |
426 | EXPORT_SYMBOL_GPL(tpm_pm_resume); |
427 | ||
41ab999c | 428 | /** |
aad887f6 JS |
429 | * tpm_get_random() - get random bytes from the TPM's RNG |
430 | * @chip: a &struct tpm_chip instance, %NULL for the default chip | |
431 | * @out: destination buffer for the random bytes | |
432 | * @max: the max number of bytes to write to @out | |
41ab999c | 433 | * |
7aee9c52 | 434 | * Return: number of random bytes read or a negative error value. |
41ab999c | 435 | */ |
aad887f6 | 436 | int tpm_get_random(struct tpm_chip *chip, u8 *out, size_t max) |
41ab999c | 437 | { |
433d390f | 438 | int rc; |
41ab999c | 439 | |
433d390f | 440 | if (!out || max > TPM_MAX_RNG_DATA) |
3e14d83e JS |
441 | return -EINVAL; |
442 | ||
fc1d52b7 | 443 | chip = tpm_find_get_ops(chip); |
aad887f6 | 444 | if (!chip) |
41ab999c KY |
445 | return -ENODEV; |
446 | ||
433d390f TW |
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); | |
41ab999c | 451 | |
4e26195f | 452 | tpm_put_ops(chip); |
433d390f | 453 | return rc; |
41ab999c KY |
454 | } |
455 | EXPORT_SYMBOL_GPL(tpm_get_random); | |
456 | ||
954650ef | 457 | /** |
aad887f6 JS |
458 | * tpm_seal_trusted() - seal a trusted key payload |
459 | * @chip: a &struct tpm_chip instance, %NULL for the default chip | |
460 | * @options: authentication values and other options | |
461 | * @payload: the key data in clear and encrypted form | |
462 | * | |
463 | * Note: only TPM 2.0 chip are supported. TPM 1.x implementation is located in | |
464 | * the keyring subsystem. | |
954650ef | 465 | * |
aad887f6 | 466 | * Return: same as with tpm_transmit_cmd() |
954650ef | 467 | */ |
aad887f6 | 468 | int tpm_seal_trusted(struct tpm_chip *chip, struct trusted_key_payload *payload, |
954650ef JS |
469 | struct trusted_key_options *options) |
470 | { | |
954650ef JS |
471 | int rc; |
472 | ||
fc1d52b7 | 473 | chip = tpm_find_get_ops(chip); |
aad887f6 | 474 | if (!chip || !(chip->flags & TPM_CHIP_FLAG_TPM2)) |
954650ef JS |
475 | return -ENODEV; |
476 | ||
477 | rc = tpm2_seal_trusted(chip, payload, options); | |
478 | ||
4e26195f | 479 | tpm_put_ops(chip); |
954650ef JS |
480 | return rc; |
481 | } | |
482 | EXPORT_SYMBOL_GPL(tpm_seal_trusted); | |
483 | ||
484 | /** | |
485 | * tpm_unseal_trusted() - unseal a trusted key | |
aad887f6 JS |
486 | * @chip: a &struct tpm_chip instance, %NULL for the default chip |
487 | * @options: authentication values and other options | |
488 | * @payload: the key data in clear and encrypted form | |
489 | * | |
490 | * Note: only TPM 2.0 chip are supported. TPM 1.x implementation is located in | |
491 | * the keyring subsystem. | |
954650ef | 492 | * |
aad887f6 | 493 | * Return: same as with tpm_transmit_cmd() |
954650ef | 494 | */ |
aad887f6 JS |
495 | int tpm_unseal_trusted(struct tpm_chip *chip, |
496 | struct trusted_key_payload *payload, | |
954650ef JS |
497 | struct trusted_key_options *options) |
498 | { | |
954650ef JS |
499 | int rc; |
500 | ||
fc1d52b7 | 501 | chip = tpm_find_get_ops(chip); |
aad887f6 | 502 | if (!chip || !(chip->flags & TPM_CHIP_FLAG_TPM2)) |
954650ef JS |
503 | return -ENODEV; |
504 | ||
505 | rc = tpm2_unseal_trusted(chip, payload, options); | |
506 | ||
4e26195f JG |
507 | tpm_put_ops(chip); |
508 | ||
954650ef JS |
509 | return rc; |
510 | } | |
511 | EXPORT_SYMBOL_GPL(tpm_unseal_trusted); | |
512 | ||
313d21ee JS |
513 | static 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 | ||
fdc915f7 JB |
523 | tpmrm_class = class_create(THIS_MODULE, "tpmrm"); |
524 | if (IS_ERR(tpmrm_class)) { | |
525 | pr_err("couldn't create tpmrm class\n"); | |
9e1b74a6 TS |
526 | rc = PTR_ERR(tpmrm_class); |
527 | goto out_destroy_tpm_class; | |
fdc915f7 JB |
528 | } |
529 | ||
530 | rc = alloc_chrdev_region(&tpm_devt, 0, 2*TPM_NUM_DEVICES, "tpm"); | |
313d21ee JS |
531 | if (rc < 0) { |
532 | pr_err("tpm: failed to allocate char dev region\n"); | |
9e1b74a6 TS |
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; | |
313d21ee JS |
540 | } |
541 | ||
542 | return 0; | |
9e1b74a6 TS |
543 | |
544 | out_unreg_chrdev: | |
545 | unregister_chrdev_region(tpm_devt, 2 * TPM_NUM_DEVICES); | |
546 | out_destroy_tpmrm_class: | |
547 | class_destroy(tpmrm_class); | |
548 | out_destroy_tpm_class: | |
549 | class_destroy(tpm_class); | |
550 | ||
551 | return rc; | |
313d21ee JS |
552 | } |
553 | ||
554 | static void __exit tpm_exit(void) | |
555 | { | |
15516788 | 556 | idr_destroy(&dev_nums_idr); |
313d21ee | 557 | class_destroy(tpm_class); |
fdc915f7 JB |
558 | class_destroy(tpmrm_class); |
559 | unregister_chrdev_region(tpm_devt, 2*TPM_NUM_DEVICES); | |
9e1b74a6 | 560 | tpm_dev_common_exit(); |
313d21ee JS |
561 | } |
562 | ||
563 | subsys_initcall(tpm_init); | |
564 | module_exit(tpm_exit); | |
565 | ||
1da177e4 LT |
566 | MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)"); |
567 | MODULE_DESCRIPTION("TPM Driver"); | |
568 | MODULE_VERSION("2.0"); | |
569 | MODULE_LICENSE("GPL"); |