1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /*
28 * TPM 1.2 Driver for the TPMs that follow TIS v1.2
29 */
30
31 #include <sys/devops.h> /* used by dev_ops */
32 #include <sys/conf.h> /* used by dev_ops,cb_ops */
33 #include <sys/modctl.h> /* for _init,_info,_fini,mod_* */
34 #include <sys/ddi.h> /* used by all entry points */
35 #include <sys/sunddi.h> /* used by all entry points */
36 #include <sys/cmn_err.h> /* used for debug outputs */
37 #include <sys/types.h> /* used by prop_op, ddi_prop_op */
38
39 #include <sys/file.h> /* used by open, close */
40 #include <sys/errno.h> /* used by open,close,read,write */
41 #include <sys/open.h> /* used by open,close,read,write */
42 #include <sys/cred.h> /* used by open,close,read */
43 #include <sys/uio.h> /* used by read */
44 #include <sys/stat.h> /* defines S_IFCHR */
45
46 #include <sys/byteorder.h> /* for ntohs, ntohl, htons, htonl */
47
48 #ifdef sun4v
49 #include <sys/hypervisor_api.h>
50 #include <sys/hsvc.h>
51 #endif
52
53 #include <tss/platform.h> /* from SUNWtss */
54 #include <tss/tpm.h> /* from SUNWtss */
55
56 #include "tpm_tis.h"
57 #include "tpm_ddi.h"
58 #include "tpm_duration.h"
59
60 #define TPM_HEADER_SIZE 10
61 typedef enum {
62 TPM_TAG_OFFSET = 0,
63 TPM_PARAMSIZE_OFFSET = 2,
64 TPM_RETURN_OFFSET = 6,
65 TPM_COMMAND_CODE_OFFSET = 6,
66 } TPM_HEADER_OFFSET_T;
67
68 /*
69 * This is to address some TPMs that does not report the correct duration
70 * and timeouts. In our experience with the production TPMs, we encountered
71 * time errors such as GetCapability command from TPM reporting the timeout
72 * and durations in milliseconds rather than microseconds. Some other TPMs
73 * report the value 0's
74 *
75 * Short Duration is based on section 11.3.4 of TIS speciciation, that
76 * TPM_GetCapability (short duration) commands should not be longer than 750ms
77 * and that section 11.3.7 states that TPM_ContinueSelfTest (medium duration)
78 * should not be longer than 1 second.
79 */
80 #define DEFAULT_SHORT_DURATION 750000
81 #define DEFAULT_MEDIUM_DURATION 1000000
82 #define DEFAULT_LONG_DURATION 300000000
83 #define DEFAULT_TIMEOUT_A 750000
84 #define DEFAULT_TIMEOUT_B 2000000
85 #define DEFAULT_TIMEOUT_C 750000
86 #define DEFAULT_TIMEOUT_D 750000
87
88 /*
89 * In order to test the 'millisecond bug', we test if DURATIONS and TIMEOUTS
90 * are unreasonably low...such as 10 milliseconds (TPM isn't that fast).
91 * and 400 milliseconds for long duration
92 */
93 #define TEN_MILLISECONDS 10000 /* 10 milliseconds */
94 #define FOUR_HUNDRED_MILLISECONDS 400000 /* 4 hundred milliseconds */
95
96 #define DEFAULT_LOCALITY 0
97 /*
98 * TPM input/output buffer offsets
99 */
100
101 typedef enum {
102 TPM_CAP_RESPSIZE_OFFSET = 10,
103 TPM_CAP_RESP_OFFSET = 14,
104 } TPM_CAP_RET_OFFSET_T;
105
106 typedef enum {
107 TPM_CAP_TIMEOUT_A_OFFSET = 14,
108 TPM_CAP_TIMEOUT_B_OFFSET = 18,
109 TPM_CAP_TIMEOUT_C_OFFSET = 22,
110 TPM_CAP_TIMEOUT_D_OFFSET = 26,
111 } TPM_CAP_TIMEOUT_OFFSET_T;
112
113 typedef enum {
114 TPM_CAP_DUR_SHORT_OFFSET = 14,
115 TPM_CAP_DUR_MEDIUM_OFFSET = 18,
116 TPM_CAP_DUR_LONG_OFFSET = 22,
117 } TPM_CAP_DURATION_OFFSET_T;
118
119 #define TPM_CAP_VERSION_INFO_OFFSET 14
120 #define TPM_CAP_VERSION_INFO_SIZE 15
121
122 /*
123 * Internal TPM command functions
124 */
125 static int itpm_command(tpm_state_t *tpm, uint8_t *buf, size_t bufsiz);
126 static int tpm_get_timeouts(tpm_state_t *tpm);
127 static int tpm_get_duration(tpm_state_t *tpm);
128 static int tpm_get_version(tpm_state_t *tpm);
129 static int tpm_continue_selftest(tpm_state_t *tpm);
130
131 /*
132 * Internal TIS related functions
133 */
134 static int tpm_wait_for_stat(tpm_state_t *, uint8_t, clock_t);
135 static clock_t tpm_get_ordinal_duration(tpm_state_t *, uint8_t);
136 static int tis_check_active_locality(tpm_state_t *, char);
137 static int tis_request_locality(tpm_state_t *, char);
138 static void tis_release_locality(tpm_state_t *, char, int);
139 static int tis_init(tpm_state_t *);
140 static uint8_t tis_get_status(tpm_state_t *);
141 static int tis_send_data(tpm_state_t *, uint8_t *, size_t);
142 static int tis_recv_data(tpm_state_t *, uint8_t *, size_t);
143
144 /* Auxilliary */
145 static int receive_data(tpm_state_t *, uint8_t *, size_t);
146 static inline int tpm_io_lock(tpm_state_t *);
147 static inline void tpm_unlock(tpm_state_t *);
148 static void tpm_cleanup(dev_info_t *, tpm_state_t *);
149
150 /*
151 * Sun DDI/DDK entry points
152 */
153
154 /* Declaration of autoconfig functions */
155 static int tpm_attach(dev_info_t *, ddi_attach_cmd_t);
156 static int tpm_detach(dev_info_t *, ddi_detach_cmd_t);
157 static int tpm_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
158 static int tpm_quiesce(dev_info_t *);
159 /* End of autoconfig functions */
160
161 /* Declaration of driver entry point functions */
162 static int tpm_open(dev_t *, int, int, cred_t *);
163 static int tpm_close(dev_t, int, int, cred_t *);
164 static int tpm_read(dev_t, struct uio *, cred_t *);
165 static int tpm_write(dev_t, struct uio *, cred_t *);
166 /* End of driver entry point functions */
167
168 /* cb_ops structure */
169 static struct cb_ops tpm_cb_ops = {
170 tpm_open,
171 tpm_close,
172 nodev, /* no strategy - nodev returns ENXIO */
173 nodev, /* no print */
174 nodev, /* no dump */
175 tpm_read,
176 tpm_write,
177 nodev, /* no ioctl */
178 nodev, /* no devmap */
179 nodev, /* no mmap */
180 nodev, /* no segmap */
181 nochpoll, /* returns ENXIO for non-pollable devices */
182 ddi_prop_op,
183 NULL, /* streamtab struc */
184 D_MP, /* compatibility flags */
185 CB_REV, /* cb_ops revision number */
186 nodev, /* no aread */
187 nodev /* no awrite */
188 };
189
190 /* dev_ops structure */
191 static struct dev_ops tpm_dev_ops = {
192 DEVO_REV,
193 0, /* reference count */
194 tpm_getinfo,
195 nulldev, /* no identify - nulldev returns 0 */
196 nulldev,
197 tpm_attach,
198 tpm_detach,
199 nodev, /* no reset - nodev returns ENXIO */
200 &tpm_cb_ops,
201 (struct bus_ops *)NULL,
202 nodev, /* no power */
203 tpm_quiesce
204 };
205
206 /* modldrv structure */
207 static struct modldrv modldrv = {
208 &mod_driverops, /* Type: This is a driver */
209 "TPM 1.2 driver", /* Name of the module. */
210 &tpm_dev_ops
211 };
212
213 /* modlinkage structure */
214 static struct modlinkage tpm_ml = {
215 MODREV_1,
216 &modldrv,
217 NULL
218 };
219
220
221 #ifdef KCF_TPM_RNG_PROVIDER
222
223 #define IDENT_TPMRNG "TPM Random Number Generator"
224
225 #include <sys/crypto/common.h>
226 #include <sys/crypto/impl.h>
227 #include <sys/crypto/spi.h>
228 /*
229 * CSPI information (entry points, provider info, etc.)
230 */
231 static void tpmrng_provider_status(crypto_provider_handle_t, uint_t *);
232
233 static crypto_control_ops_t tpmrng_control_ops = {
234 tpmrng_provider_status
235 };
236
237 static int tpmrng_seed_random(crypto_provider_handle_t, crypto_session_id_t,
238 uchar_t *, size_t, uint_t, uint32_t, crypto_req_handle_t);
239
240 static int tpmrng_generate_random(crypto_provider_handle_t,
241 crypto_session_id_t, uchar_t *, size_t, crypto_req_handle_t);
242
243 static crypto_random_number_ops_t tpmrng_random_number_ops = {
244 tpmrng_seed_random,
245 tpmrng_generate_random
246 };
247
248 static int tpmrng_ext_info(crypto_provider_handle_t,
249 crypto_provider_ext_info_t *,
250 crypto_req_handle_t);
251
252 static crypto_provider_management_ops_t tpmrng_extinfo_op = {
253 tpmrng_ext_info,
254 NULL,
255 NULL,
256 NULL
257 };
258
259 static int tpmrng_register(tpm_state_t *);
260 static int tpmrng_unregister(tpm_state_t *);
261
262 static crypto_ops_t tpmrng_crypto_ops = {
263 &tpmrng_control_ops,
264 NULL,
265 NULL,
266 NULL,
267 NULL,
268 NULL,
269 NULL,
270 NULL,
271 &tpmrng_random_number_ops,
272 NULL,
273 NULL,
274 NULL,
275 &tpmrng_extinfo_op,
276 NULL,
277 NULL
278 };
279
280 static crypto_provider_info_t tpmrng_prov_info = {
281 CRYPTO_SPI_VERSION_2,
282 "TPM Random Number Provider",
283 CRYPTO_HW_PROVIDER,
284 NULL,
285 NULL,
286 &tpmrng_crypto_ops,
287 0,
288 NULL,
289 0,
290 NULL
291 };
292 #endif /* KCF_TPM_RNG_PROVIDER */
293
294 static void *statep = NULL;
295
296 /*
297 * Inline code to get exclusive lock on the TPM device and to make sure
298 * the device is not suspended. This grabs the primary TPM mutex (pm_mutex)
299 * and then checks the suspend status. If suspended, it will wait until
300 * the device is "resumed" before releasing the pm_mutex and continuing.
301 */
302 #define TPM_EXCLUSIVE_LOCK(tpm) { \
303 mutex_enter(&tpm->pm_mutex); \
304 while (tpm->suspended) \
305 cv_wait(&tpm->suspend_cv, &tpm->pm_mutex); \
306 mutex_exit(&tpm->pm_mutex); }
307
308 /*
309 * TPM accessor functions
310 */
311 #ifdef sun4v
312
313 extern uint64_t
314 hcall_tpm_get(uint64_t, uint64_t, uint64_t, uint64_t *);
315
316 extern uint64_t
317 hcall_tpm_put(uint64_t, uint64_t, uint64_t, uint64_t);
318
319 static inline uint8_t
320 tpm_get8(tpm_state_t *tpm, unsigned long offset)
321 {
322 uint64_t value;
323
324 ASSERT(tpm != NULL);
325 (void) hcall_tpm_get(tpm->locality, offset, sizeof (uint8_t), &value);
326 return ((uint8_t)value);
327 }
328
329 static inline uint32_t
330 tpm_get32(tpm_state_t *tpm, unsigned long offset)
331 {
332 uint64_t value;
333
334 ASSERT(tpm != NULL);
335 (void) hcall_tpm_get(tpm->locality, offset, sizeof (uint32_t), &value);
336 return ((uint32_t)value);
337 }
338
339 static inline void
340 tpm_put8(tpm_state_t *tpm, unsigned long offset, uint8_t value)
341 {
342 ASSERT(tpm != NULL);
343 (void) hcall_tpm_put(tpm->locality, offset, sizeof (uint8_t), value);
344 }
345
346 #else
347
348 static inline uint8_t
349 tpm_get8(tpm_state_t *tpm, unsigned long offset)
350 {
351 ASSERT(tpm != NULL);
352
353 return (ddi_get8(tpm->handle,
354 (uint8_t *)(TPM_LOCALITY_OFFSET(tpm->locality) |
355 (uintptr_t)tpm->addr + offset)));
356 }
357
358 static inline uint32_t
359 tpm_get32(tpm_state_t *tpm, unsigned long offset)
360 {
361 ASSERT(tpm != NULL);
362 return (ddi_get32(tpm->handle,
363 (uint32_t *)(TPM_LOCALITY_OFFSET(tpm->locality) |
364 (uintptr_t)tpm->addr + offset)));
365 }
366
367 static inline void
368 tpm_put8(tpm_state_t *tpm, unsigned long offset, uint8_t value)
369 {
370 ASSERT(tpm != NULL);
371 ddi_put8(tpm->handle,
372 (uint8_t *)(TPM_LOCALITY_OFFSET(tpm->locality) |
373 (uintptr_t)tpm->addr + offset), value);
374 }
375
376 #endif /* sun4v */
377
378 /*
379 * TPM commands to get the TPM's properties, e.g.,timeout
380 */
381 /*ARGSUSED*/
382 static int
383 tpm_quiesce(dev_info_t *dip)
384 {
385 return (DDI_SUCCESS);
386 }
387
388 static uint32_t
389 load32(uchar_t *ptr, uint32_t offset)
390 {
391 uint32_t val;
392 bcopy(ptr + offset, &val, sizeof (uint32_t));
393
394 return (ntohl(val));
395 }
396
397 /*
398 * Get the actual timeouts supported by the TPM by issuing TPM_GetCapability
399 * with the subcommand TPM_CAP_PROP_TIS_TIMEOUT
400 * TPM_GetCapability (TPM Main Part 3 Rev. 94, pg.38)
401 */
402 static int
403 tpm_get_timeouts(tpm_state_t *tpm)
404 {
405 int ret;
406 uint32_t timeout; /* in milliseconds */
407 uint32_t len;
408
409 /* The buffer size (30) needs room for 4 timeout values (uint32_t) */
410 uint8_t buf[30] = {
411 0, 193, /* TPM_TAG_RQU_COMMAND */
412 0, 0, 0, 22, /* paramsize in bytes */
413 0, 0, 0, 101, /* TPM_ORD_GetCapability */
414 0, 0, 0, 5, /* TPM_CAP_Prop */
415 0, 0, 0, 4, /* SUB_CAP size in bytes */
416 0, 0, 1, 21 /* TPM_CAP_PROP_TIS_TIMEOUT(0x115) */
417 };
418 char *myname = "tpm_get_timeout";
419
420 ASSERT(tpm != NULL);
421
422 ret = itpm_command(tpm, buf, sizeof (buf));
423 if (ret != DDI_SUCCESS) {
424 #ifdef DEBUG
425 cmn_err(CE_WARN, "!%s: itpm_command failed", myname);
426 #endif
427 return (DDI_FAILURE);
428 }
429
430 /*
431 * Get the length of the returned buffer
432 * Make sure that there are 4 timeout values returned
433 * length of the capability response is stored in data[10-13]
434 * Also the TPM is in network byte order
435 */
436 len = load32(buf, TPM_CAP_RESPSIZE_OFFSET);
437 if (len != 4 * sizeof (uint32_t)) {
438 #ifdef DEBUG
439 cmn_err(CE_WARN, "!%s: capability response size should be %d"
440 "instead len = %d",
441 myname, (int)(4 * sizeof (uint32_t)), (int)len);
442 #endif
443 return (DDI_FAILURE);
444 }
445
446 /* Get the four timeout's: a,b,c,d (they are 4 bytes long each) */
447 timeout = load32(buf, TPM_CAP_TIMEOUT_A_OFFSET);
448 if (timeout == 0) {
449 timeout = DEFAULT_TIMEOUT_A;
450 } else if (timeout < TEN_MILLISECONDS) {
451 /* timeout is in millisecond range (should be microseconds) */
452 timeout *= 1000;
453 }
454 tpm->timeout_a = drv_usectohz(timeout);
455
456 timeout = load32(buf, TPM_CAP_TIMEOUT_B_OFFSET);
457 if (timeout == 0) {
458 timeout = DEFAULT_TIMEOUT_B;
459 } else if (timeout < TEN_MILLISECONDS) {
460 /* timeout is in millisecond range (should be microseconds) */
461 timeout *= 1000;
462 }
463 tpm->timeout_b = drv_usectohz(timeout);
464
465 timeout = load32(buf, TPM_CAP_TIMEOUT_C_OFFSET);
466 if (timeout == 0) {
467 timeout = DEFAULT_TIMEOUT_C;
468 } else if (timeout < TEN_MILLISECONDS) {
469 /* timeout is in millisecond range (should be microseconds) */
470 timeout *= 1000;
471 }
472 tpm->timeout_c = drv_usectohz(timeout);
473
474 timeout = load32(buf, TPM_CAP_TIMEOUT_D_OFFSET);
475 if (timeout == 0) {
476 timeout = DEFAULT_TIMEOUT_D;
477 } else if (timeout < TEN_MILLISECONDS) {
478 /* timeout is in millisecond range (should be microseconds) */
479 timeout *= 1000;
480 }
481 tpm->timeout_d = drv_usectohz(timeout);
482
483 return (DDI_SUCCESS);
484 }
485
486 /*
487 * Get the actual timeouts supported by the TPM by issuing TPM_GetCapability
488 * with the subcommand TPM_CAP_PROP_TIS_DURATION
489 * TPM_GetCapability (TPM Main Part 3 Rev. 94, pg.38)
490 */
491 static int
492 tpm_get_duration(tpm_state_t *tpm) {
493 int ret;
494 uint32_t duration;
495 uint32_t len;
496 uint8_t buf[30] = {
497 0, 193, /* TPM_TAG_RQU_COMMAND */
498 0, 0, 0, 22, /* paramsize in bytes */
499 0, 0, 0, 101, /* TPM_ORD_GetCapability */
500 0, 0, 0, 5, /* TPM_CAP_Prop */
501 0, 0, 0, 4, /* SUB_CAP size in bytes */
502 0, 0, 1, 32 /* TPM_CAP_PROP_TIS_DURATION(0x120) */
503 };
504 char *myname = "tpm_get_duration";
505
506 ASSERT(tpm != NULL);
507
508 ret = itpm_command(tpm, buf, sizeof (buf));
509 if (ret != DDI_SUCCESS) {
510 #ifdef DEBUG
511 cmn_err(CE_WARN, "!%s: itpm_command failed with ret code: 0x%x",
512 myname, ret);
513 #endif
514 return (DDI_FAILURE);
515 }
516
517 /*
518 * Get the length of the returned buffer
519 * Make sure that there are 3 duration values (S,M,L: in that order)
520 * length of the capability response is stored in data[10-13]
521 * Also the TPM is in network byte order
522 */
523 len = load32(buf, TPM_CAP_RESPSIZE_OFFSET);
524 if (len != 3 * sizeof (uint32_t)) {
525 #ifdef DEBUG
526 cmn_err(CE_WARN, "!%s: capability response should be %d, "
527 "instead, it's %d",
528 myname, (int)(3 * sizeof (uint32_t)), (int)len);
529 #endif
530 return (DDI_FAILURE);
531 }
532
533 duration = load32(buf, TPM_CAP_DUR_SHORT_OFFSET);
534 if (duration == 0) {
535 duration = DEFAULT_SHORT_DURATION;
536 } else if (duration < TEN_MILLISECONDS) {
537 duration *= 1000;
538 }
539 tpm->duration[TPM_SHORT] = drv_usectohz(duration);
540
541 duration = load32(buf, TPM_CAP_DUR_MEDIUM_OFFSET);
542 if (duration == 0) {
543 duration = DEFAULT_MEDIUM_DURATION;
544 } else if (duration < TEN_MILLISECONDS) {
545 duration *= 1000;
546 }
547 tpm->duration[TPM_MEDIUM] = drv_usectohz(duration);
548
549 duration = load32(buf, TPM_CAP_DUR_LONG_OFFSET);
550 if (duration == 0) {
551 duration = DEFAULT_LONG_DURATION;
552 } else if (duration < FOUR_HUNDRED_MILLISECONDS) {
553 duration *= 1000;
554 }
555 tpm->duration[TPM_LONG] = drv_usectohz(duration);
556
557 /* Just make the undefined duration be the same as the LONG */
558 tpm->duration[TPM_UNDEFINED] = tpm->duration[TPM_LONG];
559
560 return (DDI_SUCCESS);
561 }
562
563 /*
564 * Get the actual timeouts supported by the TPM by issuing TPM_GetCapability
565 * with the subcommand TPM_CAP_PROP_TIS_DURATION
566 * TPM_GetCapability (TPM Main Part 3 Rev. 94, pg.38)
567 */
568 static int
569 tpm_get_version(tpm_state_t *tpm) {
570 int ret;
571 uint32_t len;
572 char vendorId[5];
573 /* If this buf is too small, the "vendor specific" data won't fit */
574 uint8_t buf[64] = {
575 0, 193, /* TPM_TAG_RQU_COMMAND */
576 0, 0, 0, 18, /* paramsize in bytes */
577 0, 0, 0, 101, /* TPM_ORD_GetCapability */
578 0, 0, 0, 0x1A, /* TPM_CAP_VERSION_VAL */
579 0, 0, 0, 0, /* SUB_CAP size in bytes */
580 };
581 char *myname = "tpm_get_version";
582
583 ASSERT(tpm != NULL);
584
585 ret = itpm_command(tpm, buf, sizeof (buf));
586 if (ret != DDI_SUCCESS) {
587 #ifdef DEBUG
588 cmn_err(CE_WARN, "!%s: itpm_command failed with ret code: 0x%x",
589 myname, ret);
590 #endif
591 return (DDI_FAILURE);
592 }
593
594 /*
595 * Get the length of the returned buffer.
596 */
597 len = load32(buf, TPM_CAP_RESPSIZE_OFFSET);
598 if (len < TPM_CAP_VERSION_INFO_SIZE) {
599 #ifdef DEBUG
600 cmn_err(CE_WARN, "!%s: capability response should be greater"
601 " than %d, instead, it's %d",
602 myname, TPM_CAP_VERSION_INFO_SIZE, len);
603 #endif
604 return (DDI_FAILURE);
605 }
606
607 bcopy(buf + TPM_CAP_VERSION_INFO_OFFSET, &tpm->vers_info,
608 TPM_CAP_VERSION_INFO_SIZE);
609
610 bcopy(tpm->vers_info.tpmVendorID, vendorId,
611 sizeof (tpm->vers_info.tpmVendorID));
612 vendorId[4] = '\0';
613
614 cmn_err(CE_NOTE, "!TPM found: Ver %d.%d, Rev %d.%d, "
615 "SpecLevel %d, errataRev %d, VendorId '%s'",
616 tpm->vers_info.version.major, /* Version */
617 tpm->vers_info.version.minor,
618 tpm->vers_info.version.revMajor, /* Revision */
619 tpm->vers_info.version.revMinor,
620 (int)ntohs(tpm->vers_info.specLevel),
621 tpm->vers_info.errataRev,
622 vendorId);
623
624 /*
625 * This driver only supports TPM Version 1.2
626 */
627 if (tpm->vers_info.version.major != 1 &&
628 tpm->vers_info.version.minor != 2) {
629 cmn_err(CE_WARN, "!%s: Unsupported TPM version (%d.%d)",
630 myname,
631 tpm->vers_info.version.major, /* Version */
632 tpm->vers_info.version.minor);
633 return (DDI_FAILURE);
634 }
635
636 return (DDI_SUCCESS);
637 }
638
639 /*
640 * To prevent the TPM from complaining that certain functions are not tested
641 * we run this command when the driver attaches.
642 * For details see Section 4.2 of TPM Main Part 3 Command Specification
643 */
644 static int
645 tpm_continue_selftest(tpm_state_t *tpm) {
646 int ret;
647 uint8_t buf[10] = {
648 0, 193, /* TPM_TAG_RQU COMMAND */
649 0, 0, 0, 10, /* paramsize in bytes */
650 0, 0, 0, 83 /* TPM_ORD_ContinueSelfTest */
651 };
652 char *myname = "tpm_continue_selftest";
653
654 /* Need a longer timeout */
655 ret = itpm_command(tpm, buf, sizeof (buf));
656 if (ret != DDI_SUCCESS) {
657 #ifdef DEBUG
658 cmn_err(CE_WARN, "!%s: itpm_command failed", myname);
659 #endif
660 return (DDI_FAILURE);
661 }
662
663 return (DDI_SUCCESS);
664 }
665 /*
666 * Auxilary Functions
667 */
668
669 /*
670 * Find out how long we should wait for the TPM command to complete a command
671 */
672 static clock_t
673 tpm_get_ordinal_duration(tpm_state_t *tpm, uint8_t ordinal)
674 {
675 uint8_t index;
676 char *myname = "tpm_get_ordinal_duration";
677
678 ASSERT(tpm != NULL);
679
680 /* Default and failure case for IFX */
681 /* Is it a TSC_ORDINAL? */
682 if (ordinal & TSC_ORDINAL_MASK) {
683 if (ordinal > TSC_ORDINAL_MAX) {
684 #ifdef DEBUG
685 cmn_err(CE_WARN,
686 "!%s: tsc ordinal: %d exceeds MAX: %d",
687 myname, ordinal, TSC_ORDINAL_MAX);
688 #endif
689 return (0);
690 }
691 index = tsc_ords_duration[ordinal];
692 } else {
693 if (ordinal > TPM_ORDINAL_MAX) {
694 #ifdef DEBUG
695 cmn_err(CE_WARN,
696 "!%s: ordinal %d exceeds MAX: %d",
697 myname, ordinal, TPM_ORDINAL_MAX);
698 #endif
699 return (0);
700 }
701 index = tpm_ords_duration[ordinal];
702 }
703
704 if (index > TPM_DURATION_MAX_IDX) {
705 #ifdef DEBUG
706 cmn_err(CE_WARN, "!%s: duration index '%d' is out of bounds",
707 myname, index);
708 #endif
709 return (0);
710 }
711 return (tpm->duration[index]);
712 }
713
714 /*
715 * Internal TPM Transmit Function:
716 * Calls implementation specific sendto and receive
717 * The code assumes that the buffer is in network byte order
718 */
719 static int
720 itpm_command(tpm_state_t *tpm, uint8_t *buf, size_t bufsiz)
721 {
722 int ret;
723 uint32_t count;
724 char *myname = "itpm_command";
725
726 ASSERT(tpm != NULL && buf != NULL);
727
728 /* The byte order is network byte order so convert it */
729 count = load32(buf, TPM_PARAMSIZE_OFFSET);
730
731 if (count == 0 || (count > bufsiz)) {
732 #ifdef DEBUG
733 cmn_err(CE_WARN, "!%s: invalid byte count value "
734 "(%d > bufsiz %d)", myname, (int)count, (int)bufsiz);
735 #endif
736 return (DDI_FAILURE);
737 }
738
739 /* Send the command */
740 ret = tis_send_data(tpm, buf, count);
741 if (ret != DDI_SUCCESS) {
742 #ifdef DEBUG
743 cmn_err(CE_WARN, "!%s: tis_send_data failed with error %x",
744 myname, ret);
745 #endif
746 return (DDI_FAILURE);
747 }
748
749 /*
750 * Now receive the data from the tpm
751 * Should at least receive "the common" 10 bytes (TPM_HEADER_SIZE)
752 */
753 ret = tis_recv_data(tpm, buf, bufsiz);
754 if (ret < TPM_HEADER_SIZE) {
755 #ifdef DEBUG
756 cmn_err(CE_WARN, "!%s: tis_recv_data failed", myname);
757 #endif
758 return (DDI_FAILURE);
759 }
760
761 /* Check the return code */
762 ret = load32(buf, TPM_RETURN_OFFSET);
763 if (ret != TPM_SUCCESS) {
764 if (ret == TPM_E_DEACTIVATED)
765 cmn_err(CE_WARN, "!%s: TPM is deactivated", myname);
766 else if (ret == TPM_E_DISABLED)
767 cmn_err(CE_WARN, "!%s: TPM is disabled", myname);
768 else
769 cmn_err(CE_WARN, "!%s: TPM error code 0x%0x",
770 myname, ret);
771 return (DDI_FAILURE);
772 }
773
774 return (DDI_SUCCESS);
775 }
776
777 /*
778 * Whenever the driver wants to write to the DATA_IO register, it must need
779 * to figure out the burstcount. This is the amount of bytes it can write
780 * before having to wait for long LPC bus cycle
781 *
782 * Returns: 0 if error, burst count if sucess
783 */
784 static uint16_t
785 tpm_get_burstcount(tpm_state_t *tpm) {
786 clock_t stop;
787 uint16_t burstcnt;
788
789 ASSERT(tpm != NULL);
790
791 /*
792 * Spec says timeout should be TIMEOUT_D
793 * burst count is TPM_STS bits 8..23
794 */
795 stop = ddi_get_lbolt() + tpm->timeout_d;
796 do {
797 /*
798 * burstcnt is stored as a little endian value
799 * 'ntohs' doesn't work since the value is not word-aligned
800 */
801 burstcnt = tpm_get8(tpm, TPM_STS + 1);
802 burstcnt += tpm_get8(tpm, TPM_STS + 2) << 8;
803
804 if (burstcnt)
805 return (burstcnt);
806
807 delay(tpm->timeout_poll);
808 } while (ddi_get_lbolt() < stop);
809
810 return (0);
811 }
812
813 /*
814 * Writing 1 to TPM_STS_CMD_READY bit in TPM_STS will do the following:
815 * 1. The TPM will clears IO buffers if any
816 * 2. The TPM will enters either Idle or Ready state within TIMEOUT_B
817 * (checked in the calling function)
818 */
819 static void
820 tpm_set_ready(tpm_state_t *tpm) {
821 tpm_put8(tpm, TPM_STS, TPM_STS_CMD_READY);
822 }
823
824 static int
825 receive_data(tpm_state_t *tpm, uint8_t *buf, size_t bufsiz) {
826 int size = 0;
827 int retried = 0;
828 uint8_t stsbits;
829
830 /* A number of consecutive bytes that can be written to TPM */
831 uint16_t burstcnt;
832
833 ASSERT(tpm != NULL && buf != NULL);
834 retry:
835 while (size < bufsiz &&
836 (tpm_wait_for_stat(tpm,
837 (TPM_STS_DATA_AVAIL|TPM_STS_VALID),
838 tpm->timeout_c) == DDI_SUCCESS)) {
839 /*
840 * Burstcount should be available within TIMEOUT_D
841 * after STS is set to valid
842 * burstcount is dynamic, so have to get it each time
843 */
844 burstcnt = tpm_get_burstcount(tpm);
845 for (; burstcnt > 0 && size < bufsiz; burstcnt--) {
846 buf[size++] = tpm_get8(tpm, TPM_DATA_FIFO);
847 }
848 }
849 stsbits = tis_get_status(tpm);
850 /* check to see if we need to retry (just once) */
851 if (size < bufsiz && !(stsbits & TPM_STS_DATA_AVAIL) && retried == 0) {
852 /* issue responseRetry (TIS 1.2 pg 54) */
853 tpm_put8(tpm, TPM_STS, TPM_STS_RESPONSE_RETRY);
854 /* update the retry counter so we only retry once */
855 retried++;
856 /* reset the size to 0 and reread the entire response */
857 size = 0;
858 goto retry;
859 }
860 return (size);
861 }
862
863 /* Receive the data from the TPM */
864 static int
865 tis_recv_data(tpm_state_t *tpm, uint8_t *buf, size_t bufsiz) {
866 int ret;
867 int size = 0;
868 uint32_t expected, status;
869 uint32_t cmdresult;
870 char *myname = "tis_recv_data";
871
872 ASSERT(tpm != NULL && buf != NULL);
873
874 if (bufsiz < TPM_HEADER_SIZE) {
875 /* There should be at least tag, paramsize, return code */
876 #ifdef DEBUG
877 cmn_err(CE_WARN, "!%s: received data should contain at least "
878 "the header which is %d bytes long",
879 myname, TPM_HEADER_SIZE);
880 #endif
881 goto OUT;
882 }
883
884 /* Read tag(2 bytes), paramsize(4), and result(4) */
885 size = receive_data(tpm, buf, TPM_HEADER_SIZE);
886 if (size < TPM_HEADER_SIZE) {
887 #ifdef DEBUG
888 cmn_err(CE_WARN, "!%s: recv TPM_HEADER failed, size = %d",
889 myname, size);
890 #endif
891 goto OUT;
892 }
893
894 cmdresult = load32(buf, TPM_RETURN_OFFSET);
895
896 /* Get 'paramsize'(4 bytes)--it includes tag and paramsize */
897 expected = load32(buf, TPM_PARAMSIZE_OFFSET);
898 if (expected > bufsiz) {
899 #ifdef DEBUG
900 cmn_err(CE_WARN, "!%s: paramSize is bigger "
901 "than the requested size: paramSize=%d bufsiz=%d result=%d",
902 myname, (int)expected, (int)bufsiz, cmdresult);
903 #endif
904 goto OUT;
905 }
906
907 /* Read in the rest of the data from the TPM */
908 size += receive_data(tpm, (uint8_t *)&buf[TPM_HEADER_SIZE],
909 expected - TPM_HEADER_SIZE);
910 if (size < expected) {
911 #ifdef DEBUG
912 cmn_err(CE_WARN, "!%s: received data length (%d) "
913 "is less than expected (%d)", myname, size, expected);
914 #endif
915 goto OUT;
916 }
917
918 /* The TPM MUST set the state to stsValid within TIMEOUT_C */
919 ret = tpm_wait_for_stat(tpm, TPM_STS_VALID, tpm->timeout_c);
920
921 status = tis_get_status(tpm);
922 if (ret != DDI_SUCCESS) {
923 #ifdef DEBUG
924 cmn_err(CE_WARN, "!%s: TPM didn't set stsValid after its I/O: "
925 "status = 0x%08X", myname, status);
926 #endif
927 goto OUT;
928 }
929
930 /* There is still more data? */
931 if (status & TPM_STS_DATA_AVAIL) {
932 #ifdef DEBUG
933 cmn_err(CE_WARN, "!%s: TPM_STS_DATA_AVAIL is set:0x%08X",
934 myname, status);
935 #endif
936 goto OUT;
937 }
938
939 /*
940 * Release the control of the TPM after we are done with it
941 * it...so others can also get a chance to send data
942 */
943 tis_release_locality(tpm, tpm->locality, 0);
944
945 OUT:
946 tpm_set_ready(tpm);
947 tis_release_locality(tpm, tpm->locality, 0);
948 return (size);
949 }
950
951 /*
952 * Send the data (TPM commands) to the Data IO register
953 */
954 static int
955 tis_send_data(tpm_state_t *tpm, uint8_t *buf, size_t bufsiz) {
956 int ret;
957 uint8_t status;
958 uint16_t burstcnt;
959 uint32_t ordinal;
960 size_t count = 0;
961 char *myname = "tis_send_data";
962
963 ASSERT(tpm != NULL && buf != NULL);
964
965 if (bufsiz == 0) {
966 #ifdef DEBUG
967 cmn_err(CE_WARN, "!%s: bufsiz arg is zero", myname);
968 #endif
969 return (DDI_FAILURE);
970 }
971
972 /* Put the TPM in ready state */
973 status = tis_get_status(tpm);
974
975 if (!(status & TPM_STS_CMD_READY)) {
976 tpm_set_ready(tpm);
977 ret = tpm_wait_for_stat(tpm, TPM_STS_CMD_READY, tpm->timeout_b);
978 if (ret != DDI_SUCCESS) {
979 #ifdef DEBUG
980 cmn_err(CE_WARN, "!%s: could not put the TPM "
981 "in the command ready state:"
982 "tpm_wait_for_stat returned error",
983 myname);
984 #endif
985 goto FAIL;
986 }
987 }
988
989 /*
990 * Now we are ready to send command
991 * TPM's burstcount dictates how many bytes we can write at a time
992 * Burstcount is dynamic if INTF_CAPABILITY for static burstcount is
993 * not set.
994 */
995 while (count < bufsiz - 1) {
996 burstcnt = tpm_get_burstcount(tpm);
997 if (burstcnt == 0) {
998 #ifdef DEBUG
999 cmn_err(CE_WARN, "!%s: tpm_get_burstcnt returned error",
1000 myname);
1001 #endif
1002 ret = DDI_FAILURE;
1003 goto FAIL;
1004 }
1005
1006 for (; burstcnt > 0 && count < bufsiz - 1; burstcnt--) {
1007 tpm_put8(tpm, TPM_DATA_FIFO, buf[count]);
1008 count++;
1009 }
1010 /* Wait for TPM to indicate that it is ready for more data */
1011 ret = tpm_wait_for_stat(tpm,
1012 (TPM_STS_VALID | TPM_STS_DATA_EXPECT), tpm->timeout_c);
1013 if (ret != DDI_SUCCESS) {
1014 #ifdef DEBUG
1015 cmn_err(CE_WARN, "!%s: TPM didn't enter STS_VALID "
1016 "state", myname);
1017 #endif
1018 goto FAIL;
1019 }
1020 }
1021 /* We can't exit the loop above unless we wrote bufsiz-1 bytes */
1022
1023 /* Write last byte */
1024 tpm_put8(tpm, TPM_DATA_FIFO, buf[count]);
1025 count++;
1026
1027 /* Wait for the TPM to enter Valid State */
1028 ret = tpm_wait_for_stat(tpm, TPM_STS_VALID, tpm->timeout_c);
1029 if (ret == DDI_FAILURE) {
1030 #ifdef DEBUG
1031 cmn_err(CE_WARN, "!%s: tpm didn't enter STS_VALID state",
1032 myname);
1033 #endif
1034 goto FAIL;
1035 }
1036
1037 status = tis_get_status(tpm);
1038 /* The TPM should NOT be expecing more data at this point */
1039 if ((status & TPM_STS_DATA_EXPECT) != 0) {
1040 #ifdef DEBUG
1041 cmn_err(CE_WARN, "!%s: DATA_EXPECT should not be set after "
1042 "writing the last byte: status=0x%08X", myname, status);
1043 #endif
1044 ret = DDI_FAILURE;
1045 goto FAIL;
1046 }
1047
1048 /*
1049 * Final step: Writing TPM_STS_GO to TPM_STS
1050 * register will actually send the command.
1051 */
1052 tpm_put8(tpm, TPM_STS, TPM_STS_GO);
1053
1054 /* Ordinal/Command_code is located in buf[6..9] */
1055 ordinal = load32(buf, TPM_COMMAND_CODE_OFFSET);
1056
1057 ret = tpm_wait_for_stat(tpm, TPM_STS_DATA_AVAIL | TPM_STS_VALID,
1058 tpm_get_ordinal_duration(tpm, ordinal));
1059 if (ret == DDI_FAILURE) {
1060 #ifdef DEBUG
1061 status = tis_get_status(tpm);
1062 if (!(status & TPM_STS_DATA_AVAIL) ||
1063 !(status & TPM_STS_VALID)) {
1064 cmn_err(CE_WARN, "!%s: TPM not ready or valid "
1065 "(ordinal = %d timeout = %ld status = 0x%0x)",
1066 myname, ordinal,
1067 tpm_get_ordinal_duration(tpm, ordinal),
1068 status);
1069 } else {
1070 cmn_err(CE_WARN, "!%s: tpm_wait_for_stat "
1071 "(DATA_AVAIL | VALID) failed status = 0x%0X",
1072 myname, status);
1073 }
1074 #endif
1075 goto FAIL;
1076 }
1077 return (DDI_SUCCESS);
1078
1079 FAIL:
1080 tpm_set_ready(tpm);
1081 tis_release_locality(tpm, tpm->locality, 0);
1082 return (ret);
1083 }
1084
1085 /*
1086 * Clear XrequestUse and Xactivelocality, where X is the current locality
1087 */
1088 static void
1089 tis_release_locality(tpm_state_t *tpm, char locality, int force) {
1090 ASSERT(tpm != NULL && locality >= 0 && locality < 5);
1091
1092 if (force ||
1093 (tpm_get8(tpm, TPM_ACCESS) &
1094 (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) ==
1095 (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) {
1096 /*
1097 * Writing 1 to active locality bit in TPM_ACCESS
1098 * register reliquishes the control of the locality
1099 */
1100 tpm_put8(tpm, TPM_ACCESS, TPM_ACCESS_ACTIVE_LOCALITY);
1101 }
1102 }
1103
1104 /*
1105 * Checks whether the given locality is active
1106 * Use TPM_ACCESS register and the masks TPM_ACCESS_VALID,TPM_ACTIVE_LOCALITY
1107 */
1108 static int
1109 tis_check_active_locality(tpm_state_t *tpm, char locality) {
1110 uint8_t access_bits;
1111 uint8_t old_locality;
1112
1113 ASSERT(tpm != NULL && locality >= 0 && locality < 5);
1114
1115 old_locality = tpm->locality;
1116 tpm->locality = locality;
1117
1118 /* Just check to see if the requested locality works */
1119 access_bits = tpm_get8(tpm, TPM_ACCESS);
1120 access_bits &= (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID);
1121
1122 /* this was just a check, not a request to switch */
1123 tpm->locality = old_locality;
1124
1125 if (access_bits == (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) {
1126 return (DDI_SUCCESS);
1127 } else {
1128 return (DDI_FAILURE);
1129 }
1130 }
1131
1132 /* Request the TPM to be in the given locality */
1133 static int
1134 tis_request_locality(tpm_state_t *tpm, char locality) {
1135 clock_t timeout;
1136 int ret;
1137 char *myname = "tis_request_locality";
1138
1139 ASSERT(tpm != NULL && locality >= 0 && locality < 5);
1140
1141 ret = tis_check_active_locality(tpm, locality);
1142
1143 if (ret == DDI_SUCCESS) {
1144 /* Locality is already active */
1145 tpm->locality = locality;
1146 return (DDI_SUCCESS);
1147 }
1148
1149 tpm_put8(tpm, TPM_ACCESS, TPM_ACCESS_REQUEST_USE);
1150 timeout = ddi_get_lbolt() + tpm->timeout_a;
1151
1152 /* Using polling */
1153 while (tis_check_active_locality(tpm, locality)
1154 != DDI_SUCCESS) {
1155 if (ddi_get_lbolt() >= timeout) {
1156 #ifdef DEBUG
1157 cmn_err(CE_WARN, "!%s: (interrupt-disabled) "
1158 "tis_request_locality timed out (timeout_a = %ld)",
1159 myname, tpm->timeout_a);
1160 #endif
1161 return (DDI_FAILURE);
1162 }
1163 delay(tpm->timeout_poll);
1164 }
1165
1166 tpm->locality = locality;
1167 return (DDI_SUCCESS);
1168 }
1169
1170 /* Read the status register */
1171 static uint8_t
1172 tis_get_status(tpm_state_t *tpm) {
1173 return (tpm_get8(tpm, TPM_STS));
1174 }
1175
1176 static int
1177 tpm_wait_for_stat(tpm_state_t *tpm, uint8_t mask, clock_t timeout) {
1178 char *myname = "tpm_wait_for_stat";
1179 clock_t absolute_timeout = ddi_get_lbolt() + timeout;
1180
1181 /* Using polling */
1182 while ((tis_get_status(tpm) & mask) != mask) {
1183 if (ddi_get_lbolt() >= absolute_timeout) {
1184 /* Timeout reached */
1185 #ifdef DEBUG
1186 cmn_err(CE_WARN, "!%s: using "
1187 "polling - reached timeout (%ld usecs)",
1188 myname, drv_hztousec(timeout));
1189 #endif
1190 return (DDI_FAILURE);
1191 }
1192 delay(tpm->timeout_poll);
1193 }
1194 return (DDI_SUCCESS);
1195 }
1196
1197 /*
1198 * Initialize TPM device
1199 * 1. Find out supported interrupt capabilities
1200 * 2. Set up interrupt handler if supported (some BIOSes don't support
1201 * interrupts for TPMS, in which case we set up polling)
1202 * 3. Determine timeouts and commands duration
1203 */
1204 static int
1205 tis_init(tpm_state_t *tpm) {
1206 uint32_t intf_caps;
1207 int ret;
1208 char *myname = "tis_init";
1209
1210 /*
1211 * Temporarily set up timeouts before we get the real timeouts
1212 * by issuing TPM_CAP commands (but to issue TPM_CAP commands,
1213 * you need TIMEOUTs defined...chicken and egg problem here.
1214 * TPM timeouts: Convert the milliseconds to clock cycles
1215 */
1216 tpm->timeout_a = drv_usectohz(TIS_TIMEOUT_A);
1217 tpm->timeout_b = drv_usectohz(TIS_TIMEOUT_B);
1218 tpm->timeout_c = drv_usectohz(TIS_TIMEOUT_C);
1219 tpm->timeout_d = drv_usectohz(TIS_TIMEOUT_D);
1220 /*
1221 * Do the same with the duration (real duration will be filled out
1222 * when we call TPM_GetCapability to get the duration values from
1223 * the TPM itself).
1224 */
1225 tpm->duration[TPM_SHORT] = drv_usectohz(TPM_DEFAULT_DURATION);
1226 tpm->duration[TPM_MEDIUM] = drv_usectohz(TPM_DEFAULT_DURATION);
1227 tpm->duration[TPM_LONG] = drv_usectohz(TPM_DEFAULT_DURATION);
1228 tpm->duration[TPM_UNDEFINED] = drv_usectohz(TPM_DEFAULT_DURATION);
1229
1230 /* Find out supported capabilities */
1231 intf_caps = tpm_get32(tpm, TPM_INTF_CAP);
1232
1233 /* Upper 3 bytes should always return 0 */
1234 if (intf_caps & 0x7FFFFF00) {
1235 cmn_err(CE_WARN, "!%s: bad intf_caps value 0x%0X",
1236 myname, intf_caps);
1237 return (DDI_FAILURE);
1238 }
1239
1240 /* These two interrupts are mandatory */
1241 if (!(intf_caps & TPM_INTF_INT_LOCALITY_CHANGE_INT)) {
1242 cmn_err(CE_WARN,
1243 "!%s: Mandatory capability Locality Change Int "
1244 "not supported", myname);
1245 return (DDI_FAILURE);
1246 }
1247 if (!(intf_caps & TPM_INTF_INT_DATA_AVAIL_INT)) {
1248 cmn_err(CE_WARN, "!%s: Mandatory capability Data Available Int "
1249 "not supported.", myname);
1250 return (DDI_FAILURE);
1251 }
1252
1253 /*
1254 * Before we start writing anything to TPM's registers,
1255 * make sure we are in locality 0
1256 */
1257 ret = tis_request_locality(tpm, DEFAULT_LOCALITY);
1258 if (ret != DDI_SUCCESS) {
1259 cmn_err(CE_WARN, "!%s: Unable to request locality %d", myname,
1260 DEFAULT_LOCALITY);
1261 return (DDI_FAILURE);
1262 } /* Now we can refer to the locality as tpm->locality */
1263
1264 tpm->timeout_poll = drv_usectohz(TPM_POLLING_TIMEOUT);
1265 tpm->intr_enabled = 0;
1266
1267 /* Get the real timeouts from the TPM */
1268 ret = tpm_get_timeouts(tpm);
1269 if (ret != DDI_SUCCESS) {
1270 cmn_err(CE_WARN, "!%s: tpm_get_timeouts error", myname);
1271 return (DDI_FAILURE);
1272 }
1273
1274 ret = tpm_get_duration(tpm);
1275 if (ret != DDI_SUCCESS) {
1276 cmn_err(CE_WARN, "!%s: tpm_get_duration error", myname);
1277 return (DDI_FAILURE);
1278 }
1279
1280 /* This gets the TPM version information */
1281 ret = tpm_get_version(tpm);
1282 if (ret != DDI_SUCCESS) {
1283 cmn_err(CE_WARN, "!%s: tpm_get_version error", myname);
1284 return (DDI_FAILURE);
1285 }
1286
1287 /*
1288 * Unless the TPM completes the test of its commands,
1289 * it can return an error when the untested commands are called
1290 */
1291 ret = tpm_continue_selftest(tpm);
1292 if (ret != DDI_SUCCESS) {
1293 cmn_err(CE_WARN, "!%s: tpm_continue_selftest error", myname);
1294 return (DDI_FAILURE);
1295 }
1296 return (DDI_SUCCESS);
1297 }
1298
1299 /*
1300 * Module Entry points
1301 */
1302 int
1303 _init(void)
1304 {
1305 int ret;
1306
1307 ret = ddi_soft_state_init(&statep, sizeof (tpm_state_t), 1);
1308 if (ret) {
1309 #ifdef DEBUG
1310 cmn_err(CE_WARN, "!ddi_soft_state_init failed: %d", ret);
1311 #endif
1312 return (ret);
1313 }
1314 ret = mod_install(&tpm_ml);
1315 if (ret != 0) {
1316 #ifdef DEBUG
1317 cmn_err(CE_WARN, "!_init: mod_install returned non-zero");
1318 #endif
1319 ddi_soft_state_fini(&statep);
1320 return (ret);
1321 }
1322
1323 return (ret);
1324 }
1325
1326 int
1327 _info(struct modinfo *modinfop)
1328 {
1329 int ret;
1330 ret = mod_info(&tpm_ml, modinfop);
1331 #ifdef DEBUG
1332 if (ret == 0)
1333 cmn_err(CE_WARN, "!mod_info failed: %d", ret);
1334 #endif
1335
1336 return (ret);
1337 }
1338
1339 int
1340 _fini()
1341 {
1342 int ret;
1343
1344 ret = mod_remove(&tpm_ml);
1345 if (ret != 0)
1346 return (ret);
1347
1348 ddi_soft_state_fini(&statep);
1349
1350 return (ret);
1351 }
1352 /* End of driver configuration functions */
1353
1354 static int
1355 tpm_resume(tpm_state_t *tpm)
1356 {
1357 mutex_enter(&tpm->pm_mutex);
1358 if (!tpm->suspended) {
1359 mutex_exit(&tpm->pm_mutex);
1360 return (DDI_FAILURE);
1361 }
1362 tpm->suspended = 0;
1363 cv_broadcast(&tpm->suspend_cv);
1364 mutex_exit(&tpm->pm_mutex);
1365
1366 return (DDI_SUCCESS);
1367 }
1368
1369 #ifdef sun4v
1370 static uint64_t hsvc_tpm_minor = 0;
1371 static hsvc_info_t hsvc_tpm = {
1372 HSVC_REV_1, NULL, HSVC_GROUP_TPM, 1, 0, NULL
1373 };
1374 #endif
1375
1376 /*
1377 * Sun DDI/DDK entry points
1378 */
1379 static int
1380 tpm_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
1381 {
1382 int ret;
1383 int instance;
1384 #ifndef sun4v
1385 int idx, nregs;
1386 #endif
1387 char *myname = "tpm_attach";
1388 tpm_state_t *tpm = NULL;
1389
1390 ASSERT(dip != NULL);
1391
1392 instance = ddi_get_instance(dip);
1393 if (instance < 0)
1394 return (DDI_FAILURE);
1395
1396 /* Nothing out of ordinary here */
1397 switch (cmd) {
1398 case DDI_ATTACH:
1399 if (ddi_soft_state_zalloc(statep, instance) == DDI_SUCCESS) {
1400 tpm = ddi_get_soft_state(statep, instance);
1401 if (tpm == NULL) {
1402 #ifdef DEBUG
1403 cmn_err(CE_WARN,
1404 "!%s: cannot get state information.",
1405 myname);
1406 #endif
1407 return (DDI_FAILURE);
1408 }
1409 tpm->dip = dip;
1410 } else {
1411 #ifdef DEBUG
1412 cmn_err(CE_WARN,
1413 "!%s: cannot allocate state information.",
1414 myname);
1415 #endif
1416 return (DDI_FAILURE);
1417 }
1418 break;
1419 case DDI_RESUME:
1420 tpm = ddi_get_soft_state(statep, instance);
1421 if (tpm == NULL) {
1422 #ifdef DEBUG
1423 cmn_err(CE_WARN, "!%s: cannot get state information.",
1424 myname);
1425 #endif
1426 return (DDI_FAILURE);
1427 }
1428 return (tpm_resume(tpm));
1429 default:
1430 #ifdef DEBUG
1431 cmn_err(CE_WARN, "!%s: cmd %d is not implemented", myname, cmd);
1432 #endif
1433 ret = DDI_FAILURE;
1434 goto FAIL;
1435 }
1436
1437 /* Zeroize the flag, which is used to keep track of what is allocated */
1438 tpm->flags = 0;
1439
1440 #ifdef sun4v
1441 ret = hsvc_register(&hsvc_tpm, &hsvc_tpm_minor);
1442 if (ret != 0) {
1443 cmn_err(CE_WARN, "!%s: failed to register with "
1444 "hypervisor: 0x%0x", myname, ret);
1445 goto FAIL;
1446 }
1447 tpm->flags |= TPM_HSVC_REGISTERED;
1448 #else
1449 tpm->accattr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
1450 tpm->accattr.devacc_attr_endian_flags = DDI_NEVERSWAP_ACC;
1451 tpm->accattr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;
1452
1453 idx = 0;
1454 ret = ddi_dev_nregs(tpm->dip, &nregs);
1455 if (ret != DDI_SUCCESS)
1456 goto FAIL;
1457
1458 /*
1459 * TPM vendors put the TPM registers in different
1460 * slots in their register lists. They are not always
1461 * the 1st set of registers, for instance.
1462 * Loop until we find the set that matches the expected
1463 * register size (0x5000).
1464 */
1465 for (idx = 0; idx < nregs; idx++) {
1466 off_t regsize;
1467
1468 if ((ret = ddi_dev_regsize(tpm->dip, idx, ®size)) !=
1469 DDI_SUCCESS)
1470 goto FAIL;
1471 /* The TIS spec says the TPM registers must be 0x5000 bytes */
1472 if (regsize == 0x5000)
1473 break;
1474 }
1475 if (idx == nregs) {
1476 ret = DDI_FAILURE;
1477 goto FAIL;
1478 }
1479
1480 ret = ddi_regs_map_setup(tpm->dip, idx, (caddr_t *)&tpm->addr,
1481 (offset_t)0, (offset_t)0x5000,
1482 &tpm->accattr, &tpm->handle);
1483
1484 if (ret != DDI_SUCCESS) {
1485 goto FAIL;
1486 }
1487 tpm->flags |= TPM_DIDREGSMAP;
1488 #endif
1489 /* Enable TPM device according to the TIS specification */
1490 ret = tis_init(tpm);
1491 if (ret != DDI_SUCCESS) {
1492 #ifdef DEBUG
1493 cmn_err(CE_WARN, "!%s: tis_init() failed with error %d",
1494 myname, ret);
1495 #endif
1496
1497 /* We need to clean up the ddi_regs_map_setup call */
1498 if (tpm->flags & TPM_DIDREGSMAP) {
1499 ddi_regs_map_free(&tpm->handle);
1500 tpm->handle = NULL;
1501 tpm->flags &= ~TPM_DIDREGSMAP;
1502 }
1503 goto FAIL;
1504 }
1505
1506 /* Initialize the inter-process lock */
1507 mutex_init(&tpm->dev_lock, NULL, MUTEX_DRIVER, NULL);
1508 mutex_init(&tpm->pm_mutex, NULL, MUTEX_DRIVER, NULL);
1509 cv_init(&tpm->suspend_cv, NULL, CV_DRIVER, NULL);
1510
1511 /* Set the suspend/resume property */
1512 (void) ddi_prop_update_string(DDI_DEV_T_NONE, dip,
1513 "pm-hardware-state", "needs-suspend-resume");
1514
1515 mutex_enter(&tpm->pm_mutex);
1516 tpm->suspended = 0;
1517 mutex_exit(&tpm->pm_mutex);
1518
1519 tpm->flags |= TPM_DID_MUTEX;
1520
1521 /* Initialize the buffer and the lock associated with it */
1522 tpm->bufsize = TPM_IO_BUF_SIZE;
1523 tpm->iobuf = kmem_zalloc((sizeof (uint8_t))*(tpm->bufsize), KM_SLEEP);
1524 tpm->flags |= TPM_DID_IO_ALLOC;
1525
1526 mutex_init(&tpm->iobuf_lock, NULL, MUTEX_DRIVER, NULL);
1527 tpm->flags |= TPM_DID_IO_MUTEX;
1528
1529 cv_init(&tpm->iobuf_cv, NULL, CV_DRIVER, NULL);
1530 tpm->flags |= TPM_DID_IO_CV;
1531
1532 /* Create minor node */
1533 ret = ddi_create_minor_node(dip, "tpm", S_IFCHR, ddi_get_instance(dip),
1534 DDI_PSEUDO, 0);
1535 if (ret != DDI_SUCCESS) {
1536 #ifdef DEBUG
1537 cmn_err(CE_WARN, "!%s: ddi_create_minor_node failed", myname);
1538 #endif
1539 goto FAIL;
1540 }
1541 tpm->flags |= TPM_DIDMINOR;
1542
1543 #ifdef KCF_TPM_RNG_PROVIDER
1544 /* register RNG with kcf */
1545 if (tpmrng_register(tpm) != DDI_SUCCESS)
1546 cmn_err(CE_WARN, "!%s: tpm RNG failed to register with kcf",
1547 myname);
1548 #endif
1549
1550 return (DDI_SUCCESS);
1551 FAIL:
1552 if (tpm != NULL) {
1553 tpm_cleanup(dip, tpm);
1554 ddi_soft_state_free(statep, instance);
1555 tpm = NULL;
1556 }
1557
1558 return (DDI_FAILURE);
1559 }
1560
1561 /*
1562 * Called by tpm_detach and tpm_attach (only on failure)
1563 * Free up the resources that are allocated
1564 */
1565 static void
1566 tpm_cleanup(dev_info_t *dip, tpm_state_t *tpm)
1567 {
1568 if (tpm == NULL)
1569 return;
1570
1571 #ifdef KCF_TPM_RNG_PROVIDER
1572 (void) tpmrng_unregister(tpm);
1573 #endif
1574
1575 #ifdef sun4v
1576 if (tpm->flags & TPM_HSVC_REGISTERED) {
1577 (void) hsvc_unregister(&hsvc_tpm);
1578 tpm->flags &= ~(TPM_HSVC_REGISTERED);
1579 }
1580 #endif
1581 if (tpm->flags & TPM_DID_MUTEX) {
1582 mutex_destroy(&tpm->dev_lock);
1583 mutex_destroy(&tpm->pm_mutex);
1584 cv_destroy(&tpm->suspend_cv);
1585 tpm->flags &= ~(TPM_DID_MUTEX);
1586 }
1587 if (tpm->flags & TPM_DID_IO_ALLOC) {
1588 ASSERT(tpm->iobuf != NULL);
1589 kmem_free(tpm->iobuf, (sizeof (uint8_t))*(tpm->bufsize));
1590 tpm->flags &= ~(TPM_DID_IO_ALLOC);
1591 }
1592 if (tpm->flags & TPM_DID_IO_MUTEX) {
1593 mutex_destroy(&tpm->iobuf_lock);
1594 tpm->flags &= ~(TPM_DID_IO_MUTEX);
1595 }
1596 if (tpm->flags & TPM_DID_IO_CV) {
1597 cv_destroy(&tpm->iobuf_cv);
1598 tpm->flags &= ~(TPM_DID_IO_CV);
1599 }
1600 if (tpm->flags & TPM_DIDREGSMAP) {
1601 /* Free the mapped addresses */
1602 if (tpm->handle != NULL)
1603 ddi_regs_map_free(&tpm->handle);
1604 tpm->flags &= ~(TPM_DIDREGSMAP);
1605 }
1606 if (tpm->flags & TPM_DIDMINOR) {
1607 /* Remove minor node */
1608 ddi_remove_minor_node(dip, NULL);
1609 tpm->flags &= ~(TPM_DIDMINOR);
1610 }
1611 }
1612
1613 static int
1614 tpm_suspend(tpm_state_t *tpm)
1615 {
1616 if (tpm == NULL)
1617 return (DDI_FAILURE);
1618 mutex_enter(&tpm->pm_mutex);
1619 if (tpm->suspended) {
1620 mutex_exit(&tpm->pm_mutex);
1621 return (DDI_SUCCESS);
1622 }
1623 tpm->suspended = 1;
1624 mutex_exit(&tpm->pm_mutex);
1625
1626 return (DDI_SUCCESS);
1627 }
1628
1629 static int
1630 tpm_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
1631 {
1632 char *myname = "tpm_detach";
1633 int instance;
1634 tpm_state_t *tpm;
1635
1636 ASSERT(dip != NULL);
1637
1638 instance = ddi_get_instance(dip);
1639 if (instance < 0)
1640 return (DDI_FAILURE);
1641
1642 if ((tpm = ddi_get_soft_state(statep, instance)) == NULL) {
1643 #ifdef DEBUG
1644 cmn_err(CE_WARN, "!%s: stored pointer to tpm state is NULL",
1645 myname);
1646 #endif
1647 return (ENXIO);
1648 }
1649
1650 switch (cmd) {
1651 case DDI_DETACH:
1652 /* Body is after the switch stmt */
1653 break;
1654 case DDI_SUSPEND:
1655 return (tpm_suspend(tpm));
1656 default:
1657 #ifdef DEBUG
1658 cmn_err(CE_WARN, "!%s: case %d not implemented", myname, cmd);
1659 #endif
1660 return (DDI_FAILURE);
1661 }
1662
1663 /* Since we are freeing tpm structure, we need to gain the lock */
1664 tpm_cleanup(dip, tpm);
1665
1666 /* Free the soft state */
1667 ddi_soft_state_free(statep, instance);
1668 tpm = NULL;
1669
1670 return (DDI_SUCCESS);
1671 }
1672
1673 /*ARGSUSED*/
1674 static int
1675 tpm_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
1676 {
1677 char *myname = "tpm_getinfo";
1678 int instance;
1679 tpm_state_t *tpm;
1680
1681 instance = ddi_get_instance(dip);
1682 if ((tpm = ddi_get_soft_state(statep, instance)) == NULL) {
1683 #ifdef DEBUG
1684 cmn_err(CE_WARN, "!%s: stored pointer to tpm state is NULL",
1685 myname);
1686 #endif
1687 return (DDI_FAILURE);
1688 }
1689
1690 switch (cmd) {
1691 case DDI_INFO_DEVT2DEVINFO:
1692 *resultp = tpm->dip;
1693 break;
1694 case DDI_INFO_DEVT2INSTANCE:
1695 *resultp = 0;
1696 break;
1697 default:
1698 #ifdef DEBUG
1699 cmn_err(CE_WARN, "!%s: cmd %d is not implemented", myname, cmd);
1700 #endif
1701 return (DDI_FAILURE);
1702 }
1703 return (DDI_SUCCESS);
1704 }
1705
1706 /*
1707 * Driver entry points
1708 */
1709
1710 /*ARGSUSED*/
1711 static int
1712 tpm_open(dev_t *devp, int flag, int otyp, cred_t *cred)
1713 {
1714 char *myname = "tpm_open";
1715 int instance;
1716 tpm_state_t *tpm;
1717
1718 ASSERT(devp != NULL);
1719
1720 instance = getminor(*devp);
1721 if ((tpm = ddi_get_soft_state(statep, instance)) == NULL) {
1722 #ifdef DEBUG
1723 cmn_err(CE_WARN, "!%s: stored pointer to tpm state is NULL",
1724 myname);
1725 #endif
1726 return (ENXIO);
1727 }
1728 if (otyp != OTYP_CHR) {
1729 #ifdef DEBUG
1730 cmn_err(CE_WARN, "!%s: otyp(%d) != OTYP_CHR(%d)",
1731 myname, otyp, OTYP_CHR);
1732 #endif
1733 return (EINVAL);
1734 }
1735 TPM_EXCLUSIVE_LOCK(tpm);
1736
1737 mutex_enter(&tpm->dev_lock);
1738 if (tpm->dev_held) {
1739 #ifdef DEBUG
1740 cmn_err(CE_WARN, "!%s: the device is already being used",
1741 myname);
1742 #endif
1743 mutex_exit(&tpm->dev_lock);
1744 return (EBUSY);
1745 }
1746
1747 /* The device is free so mark it busy */
1748 tpm->dev_held = 1;
1749 mutex_exit(&tpm->dev_lock);
1750
1751 return (0);
1752 }
1753
1754 /*ARGSUSED*/
1755 static int
1756 tpm_close(dev_t dev, int flag, int otyp, cred_t *cred)
1757 {
1758 char *myname = "tpm_close";
1759 int instance;
1760 tpm_state_t *tpm;
1761
1762 instance = getminor(dev);
1763 if ((tpm = ddi_get_soft_state(statep, instance)) == NULL) {
1764 #ifdef DEBUG
1765 cmn_err(CE_WARN, "!%s: stored pointer to tpm state is NULL",
1766 myname);
1767 #endif
1768 return (ENXIO);
1769 }
1770 if (otyp != OTYP_CHR) {
1771 #ifdef DEBUG
1772 cmn_err(CE_WARN, "!%s: otyp(%d) != OTYP_CHR(%d)",
1773 myname, otyp, OTYP_CHR);
1774 #endif
1775 return (EINVAL);
1776 }
1777 TPM_EXCLUSIVE_LOCK(tpm);
1778
1779 ASSERT(tpm->dev_held);
1780
1781 mutex_enter(&tpm->dev_lock);
1782 ASSERT(mutex_owned(&tpm->dev_lock));
1783 tpm->dev_held = 0;
1784 mutex_exit(&tpm->dev_lock);
1785
1786 return (0);
1787 }
1788
1789 /*ARGSUSED*/
1790 static int
1791 tpm_read(dev_t dev, struct uio *uiop, cred_t *credp)
1792 {
1793 int ret;
1794 uint32_t size;
1795 char *myname = "tpm_read";
1796 int instance;
1797 tpm_state_t *tpm;
1798
1799 instance = getminor(dev);
1800 if ((tpm = ddi_get_soft_state(statep, instance)) == NULL) {
1801 #ifdef DEBUG
1802 cmn_err(CE_WARN, "!%s: stored pointer to tpm state is NULL",
1803 myname);
1804 #endif
1805 return (ENXIO);
1806 }
1807 if (uiop == NULL) {
1808 #ifdef DEBUG
1809 cmn_err(CE_WARN, "!%s: passed in uiop is NULL", myname);
1810 #endif
1811 return (EFAULT);
1812 }
1813
1814 TPM_EXCLUSIVE_LOCK(tpm);
1815
1816 /* Receive the data after requiring the lock */
1817 ret = tpm_io_lock(tpm);
1818
1819 /* Timeout reached */
1820 if (ret)
1821 return (ret);
1822
1823 if (uiop->uio_resid > tpm->bufsize) {
1824 #ifdef DEBUG
1825 cmn_err(CE_WARN, "!%s: read_in data is bigger "
1826 "than tpm->bufsize:read in:%d, bufsiz:%d",
1827 myname, (int)uiop->uio_resid, (int)tpm->bufsize);
1828 #endif
1829 ret = EIO;
1830 goto OUT;
1831 }
1832
1833 ret = tis_recv_data(tpm, tpm->iobuf, tpm->bufsize);
1834 if (ret < TPM_HEADER_SIZE) {
1835 #ifdef DEBUG
1836 cmn_err(CE_WARN, "!%s: tis_recv_data returned error", myname);
1837 #endif
1838 ret = EIO;
1839 goto OUT;
1840 }
1841
1842 size = load32(tpm->iobuf, 2);
1843 if (ret != size) {
1844 #ifdef DEBUG
1845 cmn_err(CE_WARN, "!%s: tis_recv_data:"
1846 "expected size=%d, actually read=%d",
1847 myname, size, ret);
1848 #endif
1849 ret = EIO;
1850 goto OUT;
1851 }
1852
1853 /* Send the buffer from the kernel to the userspace */
1854 ret = uiomove(tpm->iobuf, size, UIO_READ, uiop);
1855 if (ret) {
1856 #ifdef DEBUG
1857 cmn_err(CE_WARN, "!%s: uiomove returned error", myname);
1858 #endif
1859 goto OUT;
1860 }
1861
1862 /* Zeroize the buffer... */
1863 bzero(tpm->iobuf, tpm->bufsize);
1864 ret = DDI_SUCCESS;
1865 OUT:
1866 /* We are done now: wake up the waiting threads */
1867 tpm_unlock(tpm);
1868
1869 return (ret);
1870 }
1871
1872 /*ARGSUSED*/
1873 static int
1874 tpm_write(dev_t dev, struct uio *uiop, cred_t *credp)
1875 {
1876 int ret;
1877 size_t len;
1878 uint32_t size;
1879 char *myname = "tpm_write";
1880 int instance;
1881 tpm_state_t *tpm;
1882
1883 instance = getminor(dev);
1884 if ((tpm = ddi_get_soft_state(statep, instance)) == NULL) {
1885 #ifdef DEBUG
1886 cmn_err(CE_WARN, "!%s: stored pointer to tpm state is NULL",
1887 myname);
1888 #endif
1889 return (ENXIO);
1890 }
1891
1892 if (uiop == NULL) {
1893 #ifdef DEBUG
1894 cmn_err(CE_WARN, "!%s: passed in uiop is NULL", myname);
1895 #endif
1896 return (EFAULT);
1897 }
1898
1899 TPM_EXCLUSIVE_LOCK(tpm);
1900
1901 len = uiop->uio_resid;
1902 if (len == 0) {
1903 #ifdef DEBUG
1904 cmn_err(CE_WARN, "!%s: requested read of len 0", myname);
1905 #endif
1906 return (0);
1907 }
1908
1909 /* Get the lock for using iobuf */
1910 ret = tpm_io_lock(tpm);
1911 /* Timeout Reached */
1912 if (ret)
1913 return (ret);
1914
1915 /* Copy the header and parse the structure to find out the size... */
1916 ret = uiomove(tpm->iobuf, TPM_HEADER_SIZE, UIO_WRITE, uiop);
1917 if (ret) {
1918 #ifdef DEBUG
1919 cmn_err(CE_WARN, "!%s: uiomove returned error"
1920 "while getting the the header",
1921 myname);
1922 #endif
1923 goto OUT;
1924 }
1925
1926 /* Get the buffersize from the command buffer structure */
1927 size = load32(tpm->iobuf, TPM_PARAMSIZE_OFFSET);
1928
1929 /* Copy the command to the contiguous buffer */
1930 if (size > tpm->bufsize) {
1931 #ifdef DEBUG
1932 cmn_err(CE_WARN, "!%s: size %d is greater than "
1933 "the tpm input buffer size %d",
1934 myname, (int)size, (int)tpm->bufsize);
1935 #endif
1936 ret = ENXIO;
1937 goto OUT;
1938 }
1939
1940 /* Copy the buffer from the userspace to kernel */
1941 ret = uiomove(tpm->iobuf+TPM_HEADER_SIZE, size-TPM_HEADER_SIZE,
1942 UIO_WRITE, uiop);
1943
1944 if (ret) {
1945 #ifdef DEBUG
1946 cmn_err(CE_WARN, "!%s: uiomove returned error"
1947 "while getting the rest of the command", myname);
1948 #endif
1949 goto OUT;
1950 }
1951
1952 /* Send the command */
1953 ret = tis_send_data(tpm, tpm->iobuf, size);
1954 if (ret != DDI_SUCCESS) {
1955 #ifdef DEBUG
1956 cmn_err(CE_WARN, "!%s: tis_send_data returned error", myname);
1957 #endif
1958 ret = EFAULT;
1959 goto OUT;
1960 }
1961
1962 /* Zeroize the buffer... */
1963 bzero(tpm->iobuf, tpm->bufsize);
1964 ret = DDI_SUCCESS;
1965 OUT:
1966 tpm_unlock(tpm);
1967 return (ret);
1968 }
1969
1970 /*
1971 * This is to deal with the contentions for the iobuf
1972 */
1973 static inline int
1974 tpm_io_lock(tpm_state_t *tpm)
1975 {
1976 int ret;
1977 clock_t timeout;
1978
1979 mutex_enter(&tpm->iobuf_lock);
1980 ASSERT(mutex_owned(&tpm->iobuf_lock));
1981
1982 timeout = ddi_get_lbolt() + drv_usectohz(TPM_IO_TIMEOUT);
1983
1984 /* Wait until the iobuf becomes free with the timeout */
1985 while (tpm->iobuf_inuse) {
1986 ret = cv_timedwait(&tpm->iobuf_cv, &tpm->iobuf_lock, timeout);
1987 if (ret <= 0) {
1988 /* Timeout reached */
1989 mutex_exit(&tpm->iobuf_lock);
1990 #ifdef DEBUG
1991 cmn_err(CE_WARN, "!tpm_io_lock:iorequest timed out");
1992 #endif
1993 return (ETIME);
1994 }
1995 }
1996 tpm->iobuf_inuse = 1;
1997 mutex_exit(&tpm->iobuf_lock);
1998 return (0);
1999 }
2000
2001 /*
2002 * This is to deal with the contentions for the iobuf
2003 */
2004 static inline void
2005 tpm_unlock(tpm_state_t *tpm)
2006 {
2007 /* Wake up the waiting threads */
2008 mutex_enter(&tpm->iobuf_lock);
2009 ASSERT(tpm->iobuf_inuse == 1 && mutex_owned(&tpm->iobuf_lock));
2010 tpm->iobuf_inuse = 0;
2011 cv_broadcast(&tpm->iobuf_cv);
2012 mutex_exit(&tpm->iobuf_lock);
2013 }
2014
2015 #ifdef KCF_TPM_RNG_PROVIDER
2016 /*
2017 * Random number generator entry points
2018 */
2019 static void
2020 strncpy_spacepad(uchar_t *s1, char *s2, int n)
2021 {
2022 int s2len = strlen(s2);
2023 (void) strncpy((char *)s1, s2, n);
2024 if (s2len < n)
2025 (void) memset(s1 + s2len, ' ', n - s2len);
2026 }
2027
2028 /*ARGSUSED*/
2029 static int
2030 tpmrng_ext_info(crypto_provider_handle_t prov,
2031 crypto_provider_ext_info_t *ext_info,
2032 crypto_req_handle_t cfreq)
2033 {
2034 tpm_state_t *tpm = (tpm_state_t *)prov;
2035 char buf[64];
2036
2037 if (tpm == NULL)
2038 return (DDI_FAILURE);
2039
2040 strncpy_spacepad(ext_info->ei_manufacturerID,
2041 (char *)tpm->vers_info.tpmVendorID,
2042 sizeof (ext_info->ei_manufacturerID));
2043
2044 strncpy_spacepad(ext_info->ei_model, "0",
2045 sizeof (ext_info->ei_model));
2046 strncpy_spacepad(ext_info->ei_serial_number, "0",
2047 sizeof (ext_info->ei_serial_number));
2048
2049 ext_info->ei_flags = CRYPTO_EXTF_RNG | CRYPTO_EXTF_SO_PIN_LOCKED;
2050 ext_info->ei_max_session_count = CRYPTO_EFFECTIVELY_INFINITE;
2051 ext_info->ei_max_pin_len = 0;
2052 ext_info->ei_min_pin_len = 0;
2053 ext_info->ei_total_public_memory = CRYPTO_UNAVAILABLE_INFO;
2054 ext_info->ei_free_public_memory = CRYPTO_UNAVAILABLE_INFO;
2055 ext_info->ei_total_private_memory = CRYPTO_UNAVAILABLE_INFO;
2056 ext_info->ei_free_public_memory = CRYPTO_UNAVAILABLE_INFO;
2057 ext_info->ei_time[0] = 0;
2058
2059 ext_info->ei_hardware_version.cv_major = tpm->vers_info.version.major;
2060 ext_info->ei_hardware_version.cv_minor = tpm->vers_info.version.minor;
2061 ext_info->ei_firmware_version.cv_major =
2062 tpm->vers_info.version.revMajor;
2063 ext_info->ei_firmware_version.cv_minor =
2064 tpm->vers_info.version.revMinor;
2065
2066 (void) snprintf(buf, sizeof (buf), "tpmrng TPM RNG");
2067
2068 strncpy_spacepad(ext_info->ei_label, buf,
2069 sizeof (ext_info->ei_label));
2070 #undef BUFSZ
2071 return (CRYPTO_SUCCESS);
2072
2073 }
2074
2075 static int
2076 tpmrng_register(tpm_state_t *tpm)
2077 {
2078 int ret;
2079 char ID[64];
2080 crypto_mech_name_t *rngmech;
2081
2082 ASSERT(tpm != NULL);
2083
2084 (void) snprintf(ID, sizeof (ID), "tpmrng %s", IDENT_TPMRNG);
2085
2086 tpmrng_prov_info.pi_provider_description = ID;
2087 tpmrng_prov_info.pi_provider_dev.pd_hw = tpm->dip;
2088 tpmrng_prov_info.pi_provider_handle = tpm;
2089
2090 ret = crypto_register_provider(&tpmrng_prov_info, &tpm->n_prov);
2091 if (ret != CRYPTO_SUCCESS) {
2092 tpm->n_prov = NULL;
2093 return (DDI_FAILURE);
2094 }
2095
2096 crypto_provider_notification(tpm->n_prov, CRYPTO_PROVIDER_READY);
2097
2098 rngmech = kmem_zalloc(strlen("random") + 1, KM_SLEEP);
2099 (void) memcpy(rngmech, "random", 6);
2100 ret = crypto_load_dev_disabled("tpm", ddi_get_instance(tpm->dip),
2101 1, rngmech);
2102 #ifdef DEBUG
2103 if (ret != CRYPTO_SUCCESS)
2104 cmn_err(CE_WARN, "!crypto_load_dev_disabled failed (%d)", ret);
2105 #endif
2106 return (DDI_SUCCESS);
2107 }
2108
2109 static int
2110 tpmrng_unregister(tpm_state_t *tpm)
2111 {
2112 int ret;
2113 ASSERT(tpm != NULL);
2114 if (tpm->n_prov) {
2115 ret = crypto_unregister_provider(tpm->n_prov);
2116 tpm->n_prov = NULL;
2117 if (ret != CRYPTO_SUCCESS)
2118 return (DDI_FAILURE);
2119 }
2120 return (DDI_SUCCESS);
2121 }
2122
2123 /*ARGSUSED*/
2124 static void
2125 tpmrng_provider_status(crypto_provider_handle_t provider, uint_t *status)
2126 {
2127 *status = CRYPTO_PROVIDER_READY;
2128 }
2129
2130 /*ARGSUSED*/
2131 static int
2132 tpmrng_seed_random(crypto_provider_handle_t provider, crypto_session_id_t sid,
2133 uchar_t *buf, size_t len, uint_t entropy_est, uint32_t flags,
2134 crypto_req_handle_t req)
2135 {
2136 int ret;
2137 tpm_state_t *tpm;
2138 uint32_t len32;
2139 /* Max length of seed is 256 bytes, add 14 for header. */
2140 uint8_t cmdbuf[270] = {
2141 0, 193, /* TPM_TAG_RQU COMMAND */
2142 0, 0, 0, 0x0A, /* paramsize in bytes */
2143 0, 0, 0, TPM_ORD_StirRandom,
2144 0, 0, 0, 0 /* number of input bytes (< 256) */
2145 };
2146 uint32_t buflen;
2147
2148 if (len == 0 || len > 255 || buf == NULL)
2149 return (CRYPTO_ARGUMENTS_BAD);
2150
2151 tpm = (tpm_state_t *)provider;
2152 if (tpm == NULL)
2153 return (CRYPTO_INVALID_CONTEXT);
2154
2155 /* Acquire lock for exclusive use of TPM */
2156 TPM_EXCLUSIVE_LOCK(tpm);
2157
2158 ret = tpm_io_lock(tpm);
2159 /* Timeout reached */
2160 if (ret)
2161 return (CRYPTO_BUSY);
2162
2163 /* TPM only handles 32 bit length, so truncate if too big. */
2164 len32 = (uint32_t)len;
2165 buflen = len32 + 14;
2166
2167 /* The length must be in network order */
2168 buflen = htonl(buflen);
2169 bcopy(&buflen, cmdbuf + 2, sizeof (uint32_t));
2170
2171 /* Convert it back */
2172 buflen = ntohl(buflen);
2173
2174 /* length must be in network order */
2175 len32 = htonl(len32);
2176 bcopy(&len32, cmdbuf + 10, sizeof (uint32_t));
2177
2178 /* convert it back */
2179 len32 = ntohl(len32);
2180
2181 bcopy(buf, cmdbuf + 14, len32);
2182
2183 ret = itpm_command(tpm, cmdbuf, buflen);
2184 tpm_unlock(tpm);
2185
2186 if (ret != DDI_SUCCESS) {
2187 #ifdef DEBUG
2188 cmn_err(CE_WARN, "!tpmrng_seed_random failed");
2189 #endif
2190 return (CRYPTO_FAILED);
2191 }
2192
2193 return (CRYPTO_SUCCESS);
2194 }
2195
2196 /* ARGSUSED */
2197 static int
2198 tpmrng_generate_random(crypto_provider_handle_t provider,
2199 crypto_session_id_t sid, uchar_t *buf, size_t len, crypto_req_handle_t req)
2200 {
2201 int ret;
2202 tpm_state_t *tpm;
2203 uint8_t hdr[14] = {
2204 0, 193, /* TPM_TAG_RQU COMMAND */
2205 0, 0, 0, 14, /* paramsize in bytes */
2206 0, 0, 0, TPM_ORD_GetRandom,
2207 0, 0, 0, 0
2208 };
2209 uint8_t *cmdbuf = NULL;
2210 uint32_t len32 = (uint32_t)len;
2211 uint32_t buflen = len32 + sizeof (hdr);
2212
2213 if (len == 0 || buf == NULL)
2214 return (CRYPTO_ARGUMENTS_BAD);
2215
2216 tpm = (tpm_state_t *)provider;
2217 if (tpm == NULL)
2218 return (CRYPTO_INVALID_CONTEXT);
2219
2220 TPM_EXCLUSIVE_LOCK(tpm);
2221
2222 ret = tpm_io_lock(tpm);
2223 /* Timeout reached */
2224 if (ret)
2225 return (CRYPTO_BUSY);
2226
2227 cmdbuf = kmem_zalloc(buflen, KM_SLEEP);
2228 bcopy(hdr, cmdbuf, sizeof (hdr));
2229
2230 /* Length is written in network byte order */
2231 len32 = htonl(len32);
2232 bcopy(&len32, cmdbuf + 10, sizeof (uint32_t));
2233
2234 ret = itpm_command(tpm, cmdbuf, buflen);
2235 if (ret != DDI_SUCCESS) {
2236 #ifdef DEBUG
2237 cmn_err(CE_WARN, "!tpmrng_generate_random failed");
2238 #endif
2239 kmem_free(cmdbuf, buflen);
2240 tpm_unlock(tpm);
2241 return (CRYPTO_FAILED);
2242 }
2243
2244 /* Find out how many bytes were really returned */
2245 len32 = load32(cmdbuf, 10);
2246
2247 /* Copy the random bytes back to the callers buffer */
2248 bcopy(cmdbuf + 14, buf, len32);
2249
2250 kmem_free(cmdbuf, buflen);
2251 tpm_unlock(tpm);
2252
2253 return (CRYPTO_SUCCESS);
2254 }
2255 #endif /* KCF_TPM_RNG_PROVIDER */