1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (C) 2012-2020 IBM Corporation |
4 | * |
5 | * Author: Ashley Lai <ashleydlai@gmail.com> |
6 | * |
7 | * Maintained by: <tpmdd-devel@lists.sourceforge.net> |
8 | * |
9 | * Device driver for TCG/TCPA TPM (trusted platform module). |
10 | * Specifications at www.trustedcomputinggroup.org |
11 | */ |
12 | |
13 | #include <linux/dma-mapping.h> |
14 | #include <linux/dmapool.h> |
15 | #include <linux/slab.h> |
16 | #include <asm/vio.h> |
17 | #include <asm/irq.h> |
18 | #include <linux/types.h> |
19 | #include <linux/list.h> |
20 | #include <linux/spinlock.h> |
21 | #include <linux/interrupt.h> |
22 | #include <linux/wait.h> |
23 | #include <asm/prom.h> |
24 | |
25 | #include "tpm.h" |
26 | #include "tpm_ibmvtpm.h" |
27 | |
28 | static const char tpm_ibmvtpm_driver_name[] = "tpm_ibmvtpm" ; |
29 | |
30 | static const struct vio_device_id tpm_ibmvtpm_device_table[] = { |
31 | { "IBM,vtpm" , "IBM,vtpm" }, |
32 | { "IBM,vtpm" , "IBM,vtpm20" }, |
33 | { "" , "" } |
34 | }; |
35 | MODULE_DEVICE_TABLE(vio, tpm_ibmvtpm_device_table); |
36 | |
37 | /** |
38 | * ibmvtpm_send_crq_word() - Send a CRQ request |
39 | * @vdev: vio device struct |
40 | * @w1: pre-constructed first word of tpm crq (second word is reserved) |
41 | * |
42 | * Return: |
43 | * 0 - Success |
44 | * Non-zero - Failure |
45 | */ |
46 | static int ibmvtpm_send_crq_word(struct vio_dev *vdev, u64 w1) |
47 | { |
48 | return plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, w1, 0); |
49 | } |
50 | |
51 | /** |
52 | * ibmvtpm_send_crq() - Send a CRQ request |
53 | * |
54 | * @vdev: vio device struct |
55 | * @valid: Valid field |
56 | * @msg: Type field |
57 | * @len: Length field |
58 | * @data: Data field |
59 | * |
60 | * The ibmvtpm crq is defined as follows: |
61 | * |
62 | * Byte | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
63 | * ----------------------------------------------------------------------- |
64 | * Word0 | Valid | Type | Length | Data |
65 | * ----------------------------------------------------------------------- |
66 | * Word1 | Reserved |
67 | * ----------------------------------------------------------------------- |
68 | * |
69 | * Which matches the following structure (on bigendian host): |
70 | * |
71 | * struct ibmvtpm_crq { |
72 | * u8 valid; |
73 | * u8 msg; |
74 | * __be16 len; |
75 | * __be32 data; |
76 | * __be64 reserved; |
77 | * } __attribute__((packed, aligned(8))); |
78 | * |
79 | * However, the value is passed in a register so just compute the numeric value |
80 | * to load into the register avoiding byteswap altogether. Endian only affects |
81 | * memory loads and stores - registers are internally represented the same. |
82 | * |
83 | * Return: |
84 | * 0 (H_SUCCESS) - Success |
85 | * Non-zero - Failure |
86 | */ |
87 | static int ibmvtpm_send_crq(struct vio_dev *vdev, |
88 | u8 valid, u8 msg, u16 len, u32 data) |
89 | { |
90 | u64 w1 = ((u64)valid << 56) | ((u64)msg << 48) | ((u64)len << 32) | |
91 | (u64)data; |
92 | return ibmvtpm_send_crq_word(vdev, w1); |
93 | } |
94 | |
95 | /** |
96 | * tpm_ibmvtpm_recv - Receive data after send |
97 | * |
98 | * @chip: tpm chip struct |
99 | * @buf: buffer to read |
100 | * @count: size of buffer |
101 | * |
102 | * Return: |
103 | * Number of bytes read |
104 | */ |
105 | static int tpm_ibmvtpm_recv(struct tpm_chip *chip, u8 *buf, size_t count) |
106 | { |
107 | struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(dev: &chip->dev); |
108 | u16 len; |
109 | |
110 | if (!ibmvtpm->rtce_buf) { |
111 | dev_err(ibmvtpm->dev, "ibmvtpm device is not ready\n" ); |
112 | return 0; |
113 | } |
114 | |
115 | len = ibmvtpm->res_len; |
116 | |
117 | if (count < len) { |
118 | dev_err(ibmvtpm->dev, |
119 | "Invalid size in recv: count=%zd, crq_size=%d\n" , |
120 | count, len); |
121 | return -EIO; |
122 | } |
123 | |
124 | spin_lock(lock: &ibmvtpm->rtce_lock); |
125 | memcpy((void *)buf, (void *)ibmvtpm->rtce_buf, len); |
126 | memset(ibmvtpm->rtce_buf, 0, len); |
127 | ibmvtpm->res_len = 0; |
128 | spin_unlock(lock: &ibmvtpm->rtce_lock); |
129 | return len; |
130 | } |
131 | |
132 | /** |
133 | * ibmvtpm_crq_send_init - Send a CRQ initialize message |
134 | * @ibmvtpm: vtpm device struct |
135 | * |
136 | * Return: |
137 | * 0 on success. |
138 | * Non-zero on failure. |
139 | */ |
140 | static int ibmvtpm_crq_send_init(struct ibmvtpm_dev *ibmvtpm) |
141 | { |
142 | int rc; |
143 | |
144 | rc = ibmvtpm_send_crq_word(vdev: ibmvtpm->vdev, INIT_CRQ_CMD); |
145 | if (rc != H_SUCCESS) |
146 | dev_err(ibmvtpm->dev, |
147 | "%s failed rc=%d\n" , __func__, rc); |
148 | |
149 | return rc; |
150 | } |
151 | |
152 | /** |
153 | * tpm_ibmvtpm_resume - Resume from suspend |
154 | * |
155 | * @dev: device struct |
156 | * |
157 | * Return: Always 0. |
158 | */ |
159 | static int tpm_ibmvtpm_resume(struct device *dev) |
160 | { |
161 | struct tpm_chip *chip = dev_get_drvdata(dev); |
162 | struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(dev: &chip->dev); |
163 | int rc = 0; |
164 | |
165 | do { |
166 | if (rc) |
167 | msleep(100); |
168 | rc = plpar_hcall_norets(H_ENABLE_CRQ, |
169 | ibmvtpm->vdev->unit_address); |
170 | } while (rc == H_IN_PROGRESS || rc == H_BUSY || H_IS_LONG_BUSY(rc)); |
171 | |
172 | if (rc) { |
173 | dev_err(dev, "Error enabling ibmvtpm rc=%d\n" , rc); |
174 | return rc; |
175 | } |
176 | |
177 | rc = vio_enable_interrupts(ibmvtpm->vdev); |
178 | if (rc) { |
179 | dev_err(dev, "Error vio_enable_interrupts rc=%d\n" , rc); |
180 | return rc; |
181 | } |
182 | |
183 | rc = ibmvtpm_crq_send_init(ibmvtpm); |
184 | if (rc) |
185 | dev_err(dev, "Error send_init rc=%d\n" , rc); |
186 | |
187 | return rc; |
188 | } |
189 | |
190 | /** |
191 | * tpm_ibmvtpm_send() - Send a TPM command |
192 | * @chip: tpm chip struct |
193 | * @buf: buffer contains data to send |
194 | * @count: size of buffer |
195 | * |
196 | * Return: |
197 | * 0 on success, |
198 | * -errno on error |
199 | */ |
200 | static int tpm_ibmvtpm_send(struct tpm_chip *chip, u8 *buf, size_t count) |
201 | { |
202 | struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(dev: &chip->dev); |
203 | bool retry = true; |
204 | int rc, sig; |
205 | |
206 | if (!ibmvtpm->rtce_buf) { |
207 | dev_err(ibmvtpm->dev, "ibmvtpm device is not ready\n" ); |
208 | return 0; |
209 | } |
210 | |
211 | if (count > ibmvtpm->rtce_size) { |
212 | dev_err(ibmvtpm->dev, |
213 | "Invalid size in send: count=%zd, rtce_size=%d\n" , |
214 | count, ibmvtpm->rtce_size); |
215 | return -EIO; |
216 | } |
217 | |
218 | if (ibmvtpm->tpm_processing_cmd) { |
219 | dev_info(ibmvtpm->dev, |
220 | "Need to wait for TPM to finish\n" ); |
221 | /* wait for previous command to finish */ |
222 | sig = wait_event_interruptible(ibmvtpm->wq, !ibmvtpm->tpm_processing_cmd); |
223 | if (sig) |
224 | return -EINTR; |
225 | } |
226 | |
227 | spin_lock(lock: &ibmvtpm->rtce_lock); |
228 | ibmvtpm->res_len = 0; |
229 | memcpy((void *)ibmvtpm->rtce_buf, (void *)buf, count); |
230 | |
231 | /* |
232 | * set the processing flag before the Hcall, since we may get the |
233 | * result (interrupt) before even being able to check rc. |
234 | */ |
235 | ibmvtpm->tpm_processing_cmd = 1; |
236 | |
237 | again: |
238 | rc = ibmvtpm_send_crq(vdev: ibmvtpm->vdev, |
239 | IBMVTPM_VALID_CMD, VTPM_TPM_COMMAND, |
240 | len: count, data: ibmvtpm->rtce_dma_handle); |
241 | if (rc != H_SUCCESS) { |
242 | /* |
243 | * H_CLOSED can be returned after LPM resume. Call |
244 | * tpm_ibmvtpm_resume() to re-enable the CRQ then retry |
245 | * ibmvtpm_send_crq() once before failing. |
246 | */ |
247 | if (rc == H_CLOSED && retry) { |
248 | tpm_ibmvtpm_resume(dev: ibmvtpm->dev); |
249 | retry = false; |
250 | goto again; |
251 | } |
252 | dev_err(ibmvtpm->dev, "tpm_ibmvtpm_send failed rc=%d\n" , rc); |
253 | ibmvtpm->tpm_processing_cmd = 0; |
254 | } |
255 | |
256 | spin_unlock(lock: &ibmvtpm->rtce_lock); |
257 | return 0; |
258 | } |
259 | |
260 | static void tpm_ibmvtpm_cancel(struct tpm_chip *chip) |
261 | { |
262 | return; |
263 | } |
264 | |
265 | static u8 tpm_ibmvtpm_status(struct tpm_chip *chip) |
266 | { |
267 | struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(dev: &chip->dev); |
268 | |
269 | return ibmvtpm->tpm_processing_cmd; |
270 | } |
271 | |
272 | /** |
273 | * ibmvtpm_crq_get_rtce_size - Send a CRQ request to get rtce size |
274 | * |
275 | * @ibmvtpm: vtpm device struct |
276 | * |
277 | * Return: |
278 | * 0 on success. |
279 | * Non-zero on failure. |
280 | */ |
281 | static int ibmvtpm_crq_get_rtce_size(struct ibmvtpm_dev *ibmvtpm) |
282 | { |
283 | int rc; |
284 | |
285 | rc = ibmvtpm_send_crq(vdev: ibmvtpm->vdev, |
286 | IBMVTPM_VALID_CMD, VTPM_GET_RTCE_BUFFER_SIZE, len: 0, data: 0); |
287 | if (rc != H_SUCCESS) |
288 | dev_err(ibmvtpm->dev, |
289 | "ibmvtpm_crq_get_rtce_size failed rc=%d\n" , rc); |
290 | |
291 | return rc; |
292 | } |
293 | |
294 | /** |
295 | * ibmvtpm_crq_get_version - Send a CRQ request to get vtpm version |
296 | * - Note that this is vtpm version and not tpm version |
297 | * |
298 | * @ibmvtpm: vtpm device struct |
299 | * |
300 | * Return: |
301 | * 0 on success. |
302 | * Non-zero on failure. |
303 | */ |
304 | static int ibmvtpm_crq_get_version(struct ibmvtpm_dev *ibmvtpm) |
305 | { |
306 | int rc; |
307 | |
308 | rc = ibmvtpm_send_crq(vdev: ibmvtpm->vdev, |
309 | IBMVTPM_VALID_CMD, VTPM_GET_VERSION, len: 0, data: 0); |
310 | if (rc != H_SUCCESS) |
311 | dev_err(ibmvtpm->dev, |
312 | "ibmvtpm_crq_get_version failed rc=%d\n" , rc); |
313 | |
314 | return rc; |
315 | } |
316 | |
317 | /** |
318 | * ibmvtpm_crq_send_init_complete - Send a CRQ initialize complete message |
319 | * @ibmvtpm: vtpm device struct |
320 | * |
321 | * Return: |
322 | * 0 on success. |
323 | * Non-zero on failure. |
324 | */ |
325 | static int ibmvtpm_crq_send_init_complete(struct ibmvtpm_dev *ibmvtpm) |
326 | { |
327 | int rc; |
328 | |
329 | rc = ibmvtpm_send_crq_word(vdev: ibmvtpm->vdev, INIT_CRQ_COMP_CMD); |
330 | if (rc != H_SUCCESS) |
331 | dev_err(ibmvtpm->dev, |
332 | "ibmvtpm_crq_send_init_complete failed rc=%d\n" , rc); |
333 | |
334 | return rc; |
335 | } |
336 | |
337 | /** |
338 | * tpm_ibmvtpm_remove - ibm vtpm remove entry point |
339 | * @vdev: vio device struct |
340 | * |
341 | * Return: Always 0. |
342 | */ |
343 | static void tpm_ibmvtpm_remove(struct vio_dev *vdev) |
344 | { |
345 | struct tpm_chip *chip = dev_get_drvdata(dev: &vdev->dev); |
346 | struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(dev: &chip->dev); |
347 | int rc = 0; |
348 | |
349 | tpm_chip_unregister(chip); |
350 | |
351 | free_irq(vdev->irq, ibmvtpm); |
352 | |
353 | do { |
354 | if (rc) |
355 | msleep(100); |
356 | rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address); |
357 | } while (rc == H_BUSY || H_IS_LONG_BUSY(rc)); |
358 | |
359 | dma_unmap_single(ibmvtpm->dev, ibmvtpm->crq_dma_handle, |
360 | CRQ_RES_BUF_SIZE, DMA_BIDIRECTIONAL); |
361 | free_page((unsigned long)ibmvtpm->crq_queue.crq_addr); |
362 | |
363 | if (ibmvtpm->rtce_buf) { |
364 | dma_unmap_single(ibmvtpm->dev, ibmvtpm->rtce_dma_handle, |
365 | ibmvtpm->rtce_size, DMA_BIDIRECTIONAL); |
366 | kfree(objp: ibmvtpm->rtce_buf); |
367 | } |
368 | |
369 | kfree(objp: ibmvtpm); |
370 | /* For tpm_ibmvtpm_get_desired_dma */ |
371 | dev_set_drvdata(dev: &vdev->dev, NULL); |
372 | } |
373 | |
374 | /** |
375 | * tpm_ibmvtpm_get_desired_dma - Get DMA size needed by this driver |
376 | * @vdev: vio device struct |
377 | * |
378 | * Return: |
379 | * Number of bytes the driver needs to DMA map. |
380 | */ |
381 | static unsigned long tpm_ibmvtpm_get_desired_dma(struct vio_dev *vdev) |
382 | { |
383 | struct tpm_chip *chip = dev_get_drvdata(dev: &vdev->dev); |
384 | struct ibmvtpm_dev *ibmvtpm; |
385 | |
386 | /* |
387 | * ibmvtpm initializes at probe time, so the data we are |
388 | * asking for may not be set yet. Estimate that 4K required |
389 | * for TCE-mapped buffer in addition to CRQ. |
390 | */ |
391 | if (chip) |
392 | ibmvtpm = dev_get_drvdata(dev: &chip->dev); |
393 | else |
394 | return CRQ_RES_BUF_SIZE + PAGE_SIZE; |
395 | |
396 | return CRQ_RES_BUF_SIZE + ibmvtpm->rtce_size; |
397 | } |
398 | |
399 | /** |
400 | * tpm_ibmvtpm_suspend - Suspend |
401 | * @dev: device struct |
402 | * |
403 | * Return: Always 0. |
404 | */ |
405 | static int tpm_ibmvtpm_suspend(struct device *dev) |
406 | { |
407 | struct tpm_chip *chip = dev_get_drvdata(dev); |
408 | struct ibmvtpm_dev *ibmvtpm = dev_get_drvdata(dev: &chip->dev); |
409 | int rc = 0; |
410 | |
411 | rc = ibmvtpm_send_crq(vdev: ibmvtpm->vdev, |
412 | IBMVTPM_VALID_CMD, VTPM_PREPARE_TO_SUSPEND, len: 0, data: 0); |
413 | if (rc != H_SUCCESS) |
414 | dev_err(ibmvtpm->dev, |
415 | "tpm_ibmvtpm_suspend failed rc=%d\n" , rc); |
416 | |
417 | return rc; |
418 | } |
419 | |
420 | /** |
421 | * ibmvtpm_reset_crq - Reset CRQ |
422 | * |
423 | * @ibmvtpm: ibm vtpm struct |
424 | * |
425 | * Return: |
426 | * 0 on success. |
427 | * Non-zero on failure. |
428 | */ |
429 | static int ibmvtpm_reset_crq(struct ibmvtpm_dev *ibmvtpm) |
430 | { |
431 | int rc = 0; |
432 | |
433 | do { |
434 | if (rc) |
435 | msleep(100); |
436 | rc = plpar_hcall_norets(H_FREE_CRQ, |
437 | ibmvtpm->vdev->unit_address); |
438 | } while (rc == H_BUSY || H_IS_LONG_BUSY(rc)); |
439 | |
440 | memset(ibmvtpm->crq_queue.crq_addr, 0, CRQ_RES_BUF_SIZE); |
441 | ibmvtpm->crq_queue.index = 0; |
442 | |
443 | return plpar_hcall_norets(H_REG_CRQ, ibmvtpm->vdev->unit_address, |
444 | ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE); |
445 | } |
446 | |
447 | static bool tpm_ibmvtpm_req_canceled(struct tpm_chip *chip, u8 status) |
448 | { |
449 | return (status == 0); |
450 | } |
451 | |
452 | static const struct tpm_class_ops tpm_ibmvtpm = { |
453 | .recv = tpm_ibmvtpm_recv, |
454 | .send = tpm_ibmvtpm_send, |
455 | .cancel = tpm_ibmvtpm_cancel, |
456 | .status = tpm_ibmvtpm_status, |
457 | .req_complete_mask = 1, |
458 | .req_complete_val = 0, |
459 | .req_canceled = tpm_ibmvtpm_req_canceled, |
460 | }; |
461 | |
462 | static const struct dev_pm_ops tpm_ibmvtpm_pm_ops = { |
463 | .suspend = tpm_ibmvtpm_suspend, |
464 | .resume = tpm_ibmvtpm_resume, |
465 | }; |
466 | |
467 | /** |
468 | * ibmvtpm_crq_get_next - Get next responded crq |
469 | * |
470 | * @ibmvtpm: vtpm device struct |
471 | * |
472 | * Return: vtpm crq pointer or NULL. |
473 | */ |
474 | static struct ibmvtpm_crq *ibmvtpm_crq_get_next(struct ibmvtpm_dev *ibmvtpm) |
475 | { |
476 | struct ibmvtpm_crq_queue *crq_q = &ibmvtpm->crq_queue; |
477 | struct ibmvtpm_crq *crq = &crq_q->crq_addr[crq_q->index]; |
478 | |
479 | if (crq->valid & VTPM_MSG_RES) { |
480 | if (++crq_q->index == crq_q->num_entry) |
481 | crq_q->index = 0; |
482 | smp_rmb(); |
483 | } else |
484 | crq = NULL; |
485 | return crq; |
486 | } |
487 | |
488 | /** |
489 | * ibmvtpm_crq_process - Process responded crq |
490 | * |
491 | * @crq: crq to be processed |
492 | * @ibmvtpm: vtpm device struct |
493 | * |
494 | */ |
495 | static void ibmvtpm_crq_process(struct ibmvtpm_crq *crq, |
496 | struct ibmvtpm_dev *ibmvtpm) |
497 | { |
498 | int rc = 0; |
499 | |
500 | switch (crq->valid) { |
501 | case VALID_INIT_CRQ: |
502 | switch (crq->msg) { |
503 | case INIT_CRQ_RES: |
504 | dev_info(ibmvtpm->dev, "CRQ initialized\n" ); |
505 | rc = ibmvtpm_crq_send_init_complete(ibmvtpm); |
506 | if (rc) |
507 | dev_err(ibmvtpm->dev, "Unable to send CRQ init complete rc=%d\n" , rc); |
508 | return; |
509 | case INIT_CRQ_COMP_RES: |
510 | dev_info(ibmvtpm->dev, |
511 | "CRQ initialization completed\n" ); |
512 | return; |
513 | default: |
514 | dev_err(ibmvtpm->dev, "Unknown crq message type: %d\n" , crq->msg); |
515 | return; |
516 | } |
517 | case IBMVTPM_VALID_CMD: |
518 | switch (crq->msg) { |
519 | case VTPM_GET_RTCE_BUFFER_SIZE_RES: |
520 | if (be16_to_cpu(crq->len) <= 0) { |
521 | dev_err(ibmvtpm->dev, "Invalid rtce size\n" ); |
522 | return; |
523 | } |
524 | ibmvtpm->rtce_size = be16_to_cpu(crq->len); |
525 | ibmvtpm->rtce_buf = kmalloc(size: ibmvtpm->rtce_size, |
526 | GFP_ATOMIC); |
527 | if (!ibmvtpm->rtce_buf) { |
528 | dev_err(ibmvtpm->dev, "Failed to allocate memory for rtce buffer\n" ); |
529 | return; |
530 | } |
531 | |
532 | ibmvtpm->rtce_dma_handle = dma_map_single(ibmvtpm->dev, |
533 | ibmvtpm->rtce_buf, ibmvtpm->rtce_size, |
534 | DMA_BIDIRECTIONAL); |
535 | |
536 | if (dma_mapping_error(dev: ibmvtpm->dev, |
537 | dma_addr: ibmvtpm->rtce_dma_handle)) { |
538 | kfree(objp: ibmvtpm->rtce_buf); |
539 | ibmvtpm->rtce_buf = NULL; |
540 | dev_err(ibmvtpm->dev, "Failed to dma map rtce buffer\n" ); |
541 | } |
542 | |
543 | return; |
544 | case VTPM_GET_VERSION_RES: |
545 | ibmvtpm->vtpm_version = be32_to_cpu(crq->data); |
546 | return; |
547 | case VTPM_TPM_COMMAND_RES: |
548 | /* len of the data in rtce buffer */ |
549 | ibmvtpm->res_len = be16_to_cpu(crq->len); |
550 | ibmvtpm->tpm_processing_cmd = 0; |
551 | wake_up_interruptible(&ibmvtpm->wq); |
552 | return; |
553 | default: |
554 | return; |
555 | } |
556 | } |
557 | return; |
558 | } |
559 | |
560 | /** |
561 | * ibmvtpm_interrupt - Interrupt handler |
562 | * |
563 | * @irq: irq number to handle |
564 | * @vtpm_instance: vtpm that received interrupt |
565 | * |
566 | * Returns: |
567 | * IRQ_HANDLED |
568 | **/ |
569 | static irqreturn_t ibmvtpm_interrupt(int irq, void *vtpm_instance) |
570 | { |
571 | struct ibmvtpm_dev *ibmvtpm = (struct ibmvtpm_dev *) vtpm_instance; |
572 | struct ibmvtpm_crq *crq; |
573 | |
574 | /* while loop is needed for initial setup (get version and |
575 | * get rtce_size). There should be only one tpm request at any |
576 | * given time. |
577 | */ |
578 | while ((crq = ibmvtpm_crq_get_next(ibmvtpm)) != NULL) { |
579 | ibmvtpm_crq_process(crq, ibmvtpm); |
580 | wake_up_interruptible(&ibmvtpm->crq_queue.wq); |
581 | crq->valid = 0; |
582 | smp_wmb(); |
583 | } |
584 | |
585 | return IRQ_HANDLED; |
586 | } |
587 | |
588 | /** |
589 | * tpm_ibmvtpm_probe - ibm vtpm initialize entry point |
590 | * |
591 | * @vio_dev: vio device struct |
592 | * @id: vio device id struct |
593 | * |
594 | * Return: |
595 | * 0 on success. |
596 | * Non-zero on failure. |
597 | */ |
598 | static int tpm_ibmvtpm_probe(struct vio_dev *vio_dev, |
599 | const struct vio_device_id *id) |
600 | { |
601 | struct ibmvtpm_dev *ibmvtpm; |
602 | struct device *dev = &vio_dev->dev; |
603 | struct ibmvtpm_crq_queue *crq_q; |
604 | struct tpm_chip *chip; |
605 | int rc = -ENOMEM, rc1; |
606 | |
607 | chip = tpmm_chip_alloc(pdev: dev, ops: &tpm_ibmvtpm); |
608 | if (IS_ERR(ptr: chip)) |
609 | return PTR_ERR(ptr: chip); |
610 | |
611 | ibmvtpm = kzalloc(size: sizeof(struct ibmvtpm_dev), GFP_KERNEL); |
612 | if (!ibmvtpm) { |
613 | dev_err(dev, "kzalloc for ibmvtpm failed\n" ); |
614 | goto cleanup; |
615 | } |
616 | |
617 | ibmvtpm->dev = dev; |
618 | ibmvtpm->vdev = vio_dev; |
619 | |
620 | crq_q = &ibmvtpm->crq_queue; |
621 | crq_q->crq_addr = (struct ibmvtpm_crq *)get_zeroed_page(GFP_KERNEL); |
622 | if (!crq_q->crq_addr) { |
623 | dev_err(dev, "Unable to allocate memory for crq_addr\n" ); |
624 | goto cleanup; |
625 | } |
626 | |
627 | crq_q->num_entry = CRQ_RES_BUF_SIZE / sizeof(*crq_q->crq_addr); |
628 | init_waitqueue_head(&crq_q->wq); |
629 | ibmvtpm->crq_dma_handle = dma_map_single(dev, crq_q->crq_addr, |
630 | CRQ_RES_BUF_SIZE, |
631 | DMA_BIDIRECTIONAL); |
632 | |
633 | if (dma_mapping_error(dev, dma_addr: ibmvtpm->crq_dma_handle)) { |
634 | dev_err(dev, "dma mapping failed\n" ); |
635 | goto cleanup; |
636 | } |
637 | |
638 | rc = plpar_hcall_norets(H_REG_CRQ, vio_dev->unit_address, |
639 | ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE); |
640 | if (rc == H_RESOURCE) |
641 | rc = ibmvtpm_reset_crq(ibmvtpm); |
642 | |
643 | if (rc) { |
644 | dev_err(dev, "Unable to register CRQ rc=%d\n" , rc); |
645 | goto reg_crq_cleanup; |
646 | } |
647 | |
648 | rc = request_irq(irq: vio_dev->irq, handler: ibmvtpm_interrupt, flags: 0, |
649 | name: tpm_ibmvtpm_driver_name, dev: ibmvtpm); |
650 | if (rc) { |
651 | dev_err(dev, "Error %d register irq 0x%x\n" , rc, vio_dev->irq); |
652 | goto init_irq_cleanup; |
653 | } |
654 | |
655 | rc = vio_enable_interrupts(vio_dev); |
656 | if (rc) { |
657 | dev_err(dev, "Error %d enabling interrupts\n" , rc); |
658 | goto init_irq_cleanup; |
659 | } |
660 | |
661 | init_waitqueue_head(&ibmvtpm->wq); |
662 | |
663 | crq_q->index = 0; |
664 | |
665 | dev_set_drvdata(dev: &chip->dev, data: ibmvtpm); |
666 | |
667 | spin_lock_init(&ibmvtpm->rtce_lock); |
668 | |
669 | rc = ibmvtpm_crq_send_init(ibmvtpm); |
670 | if (rc) |
671 | goto init_irq_cleanup; |
672 | |
673 | rc = ibmvtpm_crq_get_version(ibmvtpm); |
674 | if (rc) |
675 | goto init_irq_cleanup; |
676 | |
677 | rc = ibmvtpm_crq_get_rtce_size(ibmvtpm); |
678 | if (rc) |
679 | goto init_irq_cleanup; |
680 | |
681 | if (!wait_event_timeout(ibmvtpm->crq_queue.wq, |
682 | ibmvtpm->rtce_buf != NULL, |
683 | HZ)) { |
684 | rc = -ENODEV; |
685 | dev_err(dev, "CRQ response timed out\n" ); |
686 | goto init_irq_cleanup; |
687 | } |
688 | |
689 | |
690 | if (!strcmp(id->compat, "IBM,vtpm20" )) |
691 | chip->flags |= TPM_CHIP_FLAG_TPM2; |
692 | |
693 | rc = tpm_get_timeouts(chip); |
694 | if (rc) |
695 | goto init_irq_cleanup; |
696 | |
697 | if (chip->flags & TPM_CHIP_FLAG_TPM2) { |
698 | rc = tpm2_get_cc_attrs_tbl(chip); |
699 | if (rc) |
700 | goto init_irq_cleanup; |
701 | } |
702 | |
703 | return tpm_chip_register(chip); |
704 | init_irq_cleanup: |
705 | do { |
706 | rc1 = plpar_hcall_norets(H_FREE_CRQ, vio_dev->unit_address); |
707 | } while (rc1 == H_BUSY || H_IS_LONG_BUSY(rc1)); |
708 | reg_crq_cleanup: |
709 | dma_unmap_single(dev, ibmvtpm->crq_dma_handle, CRQ_RES_BUF_SIZE, |
710 | DMA_BIDIRECTIONAL); |
711 | cleanup: |
712 | if (ibmvtpm) { |
713 | if (crq_q->crq_addr) |
714 | free_page((unsigned long)crq_q->crq_addr); |
715 | kfree(objp: ibmvtpm); |
716 | } |
717 | |
718 | return rc; |
719 | } |
720 | |
721 | static struct vio_driver ibmvtpm_driver = { |
722 | .id_table = tpm_ibmvtpm_device_table, |
723 | .probe = tpm_ibmvtpm_probe, |
724 | .remove = tpm_ibmvtpm_remove, |
725 | .get_desired_dma = tpm_ibmvtpm_get_desired_dma, |
726 | .name = tpm_ibmvtpm_driver_name, |
727 | .pm = &tpm_ibmvtpm_pm_ops, |
728 | }; |
729 | |
730 | /** |
731 | * ibmvtpm_module_init - Initialize ibm vtpm module. |
732 | * |
733 | * |
734 | * Return: |
735 | * 0 on success. |
736 | * Non-zero on failure. |
737 | */ |
738 | static int __init ibmvtpm_module_init(void) |
739 | { |
740 | return vio_register_driver(&ibmvtpm_driver); |
741 | } |
742 | |
743 | /** |
744 | * ibmvtpm_module_exit - Tear down ibm vtpm module. |
745 | */ |
746 | static void __exit ibmvtpm_module_exit(void) |
747 | { |
748 | vio_unregister_driver(&ibmvtpm_driver); |
749 | } |
750 | |
751 | module_init(ibmvtpm_module_init); |
752 | module_exit(ibmvtpm_module_exit); |
753 | |
754 | MODULE_AUTHOR("adlai@us.ibm.com" ); |
755 | MODULE_DESCRIPTION("IBM vTPM Driver" ); |
756 | MODULE_VERSION("1.0" ); |
757 | MODULE_LICENSE("GPL" ); |
758 | |