tpm.c 30.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9
/*
 * Copyright (C) 2004 IBM Corporation
 *
 * Authors:
 * Leendert van Doorn <leendert@watson.ibm.com>
 * Dave Safford <safford@watson.ibm.com>
 * Reiner Sailer <sailer@watson.ibm.com>
 * Kylene Hall <kjhall@us.ibm.com>
 *
K
Kent Yoder 已提交
10
 * Maintained by: <tpmdd-devel@lists.sourceforge.net>
L
Linus Torvalds 已提交
11 12 13 14 15 16 17 18 19 20 21
 *
 * Device driver for TCG/TCPA TPM (trusted platform module).
 * Specifications at www.trustedcomputinggroup.org	 
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, version 2 of the
 * License.
 * 
 * Note, the TPM chip is not interrupt driven (only polling)
 * and can have very long timeouts (minutes!). Hence the unusual
22
 * calls to msleep.
L
Linus Torvalds 已提交
23 24 25 26
 *
 */

#include <linux/poll.h>
27
#include <linux/slab.h>
28
#include <linux/mutex.h>
L
Linus Torvalds 已提交
29
#include <linux/spinlock.h>
30

L
Linus Torvalds 已提交
31 32
#include "tpm.h"

33 34
enum tpm_const {
	TPM_MINOR = 224,	/* officially assigned */
R
Rajiv Andrade 已提交
35
	TPM_BUFSIZE = 4096,
36 37
	TPM_NUM_DEVICES = 256,
};
L
Linus Torvalds 已提交
38

39 40 41 42 43 44 45 46 47 48 49
enum tpm_duration {
	TPM_SHORT = 0,
	TPM_MEDIUM = 1,
	TPM_LONG = 2,
	TPM_UNDEFINED,
};

#define TPM_MAX_ORDINAL 243
#define TPM_MAX_PROTECTED_ORDINAL 12
#define TPM_PROTECTED_ORDINAL_MASK 0xFF

50 51 52 53 54 55 56 57 58 59
/*
 * Bug workaround - some TPM's don't flush the most
 * recently changed pcr on suspend, so force the flush
 * with an extend to the selected _unused_ non-volatile pcr.
 */
static int tpm_suspend_pcr;
module_param_named(suspend_pcr, tpm_suspend_pcr, uint, 0644);
MODULE_PARM_DESC(suspend_pcr,
		 "PCR to use for dummy writes to faciltate flush on suspend.");

L
Linus Torvalds 已提交
60 61
static LIST_HEAD(tpm_chip_list);
static DEFINE_SPINLOCK(driver_lock);
K
Kylene Jo Hall 已提交
62
static DECLARE_BITMAP(dev_mask, TPM_NUM_DEVICES);
L
Linus Torvalds 已提交
63

64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
/*
 * Array with one entry per ordinal defining the maximum amount
 * of time the chip could take to return the result.  The ordinal
 * designation of short, medium or long is defined in a table in
 * TCG Specification TPM Main Part 2 TPM Structures Section 17. The
 * values of the SHORT, MEDIUM, and LONG durations are retrieved
 * from the chip during initialization with a call to tpm_get_timeouts.
 */
static const u8 tpm_protected_ordinal_duration[TPM_MAX_PROTECTED_ORDINAL] = {
	TPM_UNDEFINED,		/* 0 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,		/* 5 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_SHORT,		/* 10 */
	TPM_SHORT,
};

static const u8 tpm_ordinal_duration[TPM_MAX_ORDINAL] = {
	TPM_UNDEFINED,		/* 0 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,		/* 5 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_SHORT,		/* 10 */
	TPM_SHORT,
	TPM_MEDIUM,
	TPM_LONG,
	TPM_LONG,
	TPM_MEDIUM,		/* 15 */
	TPM_SHORT,
	TPM_SHORT,
	TPM_MEDIUM,
	TPM_LONG,
	TPM_SHORT,		/* 20 */
	TPM_SHORT,
	TPM_MEDIUM,
	TPM_MEDIUM,
	TPM_MEDIUM,
	TPM_SHORT,		/* 25 */
	TPM_SHORT,
	TPM_MEDIUM,
	TPM_SHORT,
	TPM_SHORT,
	TPM_MEDIUM,		/* 30 */
	TPM_LONG,
	TPM_MEDIUM,
	TPM_SHORT,
	TPM_SHORT,
	TPM_SHORT,		/* 35 */
	TPM_MEDIUM,
	TPM_MEDIUM,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_MEDIUM,		/* 40 */
	TPM_LONG,
	TPM_MEDIUM,
	TPM_SHORT,
	TPM_SHORT,
	TPM_SHORT,		/* 45 */
	TPM_SHORT,
	TPM_SHORT,
	TPM_SHORT,
	TPM_LONG,
	TPM_MEDIUM,		/* 50 */
	TPM_MEDIUM,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,		/* 55 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_MEDIUM,		/* 60 */
	TPM_MEDIUM,
	TPM_MEDIUM,
	TPM_SHORT,
	TPM_SHORT,
	TPM_MEDIUM,		/* 65 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_SHORT,		/* 70 */
	TPM_SHORT,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,		/* 75 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_LONG,		/* 80 */
	TPM_UNDEFINED,
	TPM_MEDIUM,
	TPM_LONG,
	TPM_SHORT,
	TPM_UNDEFINED,		/* 85 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_SHORT,		/* 90 */
	TPM_SHORT,
	TPM_SHORT,
	TPM_SHORT,
	TPM_SHORT,
	TPM_UNDEFINED,		/* 95 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_MEDIUM,		/* 100 */
	TPM_SHORT,
	TPM_SHORT,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,		/* 105 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_SHORT,		/* 110 */
	TPM_SHORT,
	TPM_SHORT,
	TPM_SHORT,
	TPM_SHORT,
	TPM_SHORT,		/* 115 */
	TPM_SHORT,
	TPM_SHORT,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_LONG,		/* 120 */
	TPM_LONG,
	TPM_MEDIUM,
	TPM_UNDEFINED,
	TPM_SHORT,
	TPM_SHORT,		/* 125 */
	TPM_SHORT,
	TPM_LONG,
	TPM_SHORT,
	TPM_SHORT,
	TPM_SHORT,		/* 130 */
	TPM_MEDIUM,
	TPM_UNDEFINED,
	TPM_SHORT,
	TPM_MEDIUM,
	TPM_UNDEFINED,		/* 135 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_SHORT,		/* 140 */
	TPM_SHORT,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,		/* 145 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_SHORT,		/* 150 */
	TPM_MEDIUM,
	TPM_MEDIUM,
	TPM_SHORT,
	TPM_SHORT,
	TPM_UNDEFINED,		/* 155 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_SHORT,		/* 160 */
	TPM_SHORT,
	TPM_SHORT,
	TPM_SHORT,
	TPM_UNDEFINED,
	TPM_UNDEFINED,		/* 165 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_LONG,		/* 170 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,		/* 175 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_MEDIUM,		/* 180 */
	TPM_SHORT,
	TPM_MEDIUM,
	TPM_MEDIUM,
	TPM_MEDIUM,
	TPM_MEDIUM,		/* 185 */
	TPM_SHORT,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,		/* 190 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,		/* 195 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_SHORT,		/* 200 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_SHORT,
	TPM_SHORT,		/* 205 */
	TPM_SHORT,
	TPM_SHORT,
	TPM_SHORT,
	TPM_SHORT,
	TPM_MEDIUM,		/* 210 */
	TPM_UNDEFINED,
	TPM_MEDIUM,
	TPM_MEDIUM,
	TPM_MEDIUM,
	TPM_UNDEFINED,		/* 215 */
	TPM_MEDIUM,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_SHORT,
	TPM_SHORT,		/* 220 */
	TPM_SHORT,
	TPM_SHORT,
	TPM_SHORT,
	TPM_SHORT,
	TPM_UNDEFINED,		/* 225 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_SHORT,		/* 230 */
	TPM_LONG,
	TPM_MEDIUM,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,		/* 235 */
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_UNDEFINED,
	TPM_SHORT,		/* 240 */
	TPM_UNDEFINED,
	TPM_MEDIUM,
};

L
Linus Torvalds 已提交
333 334 335 336
static void user_reader_timeout(unsigned long ptr)
{
	struct tpm_chip *chip = (struct tpm_chip *) ptr;

K
Kylene Jo Hall 已提交
337 338 339
	schedule_work(&chip->work);
}

D
David Howells 已提交
340
static void timeout_work(struct work_struct *work)
K
Kylene Jo Hall 已提交
341
{
D
David Howells 已提交
342
	struct tpm_chip *chip = container_of(work, struct tpm_chip, work);
K
Kylene Jo Hall 已提交
343

344
	mutex_lock(&chip->buffer_mutex);
L
Linus Torvalds 已提交
345 346
	atomic_set(&chip->data_pending, 0);
	memset(chip->data_buffer, 0, TPM_BUFSIZE);
347
	mutex_unlock(&chip->buffer_mutex);
L
Linus Torvalds 已提交
348 349
}

350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
/*
 * Returns max number of jiffies to wait
 */
unsigned long tpm_calc_ordinal_duration(struct tpm_chip *chip,
					   u32 ordinal)
{
	int duration_idx = TPM_UNDEFINED;
	int duration = 0;

	if (ordinal < TPM_MAX_ORDINAL)
		duration_idx = tpm_ordinal_duration[ordinal];
	else if ((ordinal & TPM_PROTECTED_ORDINAL_MASK) <
		 TPM_MAX_PROTECTED_ORDINAL)
		duration_idx =
		    tpm_protected_ordinal_duration[ordinal &
						   TPM_PROTECTED_ORDINAL_MASK];

R
Rajiv Andrade 已提交
367
	if (duration_idx != TPM_UNDEFINED) {
368
		duration = chip->vendor.duration[duration_idx];
R
Rajiv Andrade 已提交
369 370 371 372 373
		/* if duration is 0, it's because chip->vendor.duration wasn't */
		/* filled yet, so we set the lowest timeout just to give enough */
		/* time for tpm_get_timeouts() to succeed */
		return (duration <= 0 ? HZ : duration);
	} else
374 375 376 377
		return 2 * 60 * HZ;
}
EXPORT_SYMBOL_GPL(tpm_calc_ordinal_duration);

L
Linus Torvalds 已提交
378 379 380 381 382 383
/*
 * Internal kernel interface to transmit TPM commands
 */
static ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
			    size_t bufsiz)
{
K
Kylene Hall 已提交
384
	ssize_t rc;
385
	u32 count, ordinal;
386
	unsigned long stop;
L
Linus Torvalds 已提交
387

388
	count = be32_to_cpu(*((__be32 *) (buf + 2)));
389
	ordinal = be32_to_cpu(*((__be32 *) (buf + 6)));
L
Linus Torvalds 已提交
390 391 392
	if (count == 0)
		return -ENODATA;
	if (count > bufsiz) {
393
		dev_err(chip->dev,
A
Al Viro 已提交
394
			"invalid count value %x %zx \n", count, bufsiz);
L
Linus Torvalds 已提交
395 396 397
		return -E2BIG;
	}

398
	mutex_lock(&chip->tpm_mutex);
L
Linus Torvalds 已提交
399

K
Kylene Jo Hall 已提交
400
	if ((rc = chip->vendor.send(chip, (u8 *) buf, count)) < 0) {
401
		dev_err(chip->dev,
K
Kylene Hall 已提交
402 403
			"tpm_transmit: tpm_send: error %zd\n", rc);
		goto out;
L
Linus Torvalds 已提交
404 405
	}

406 407 408
	if (chip->vendor.irq)
		goto out_recv;

409
	stop = jiffies + tpm_calc_ordinal_duration(chip, ordinal);
L
Linus Torvalds 已提交
410
	do {
K
Kylene Jo Hall 已提交
411 412 413
		u8 status = chip->vendor.status(chip);
		if ((status & chip->vendor.req_complete_mask) ==
		    chip->vendor.req_complete_val)
L
Linus Torvalds 已提交
414
			goto out_recv;
K
Kylene Hall 已提交
415

K
Kylene Jo Hall 已提交
416
		if ((status == chip->vendor.req_canceled)) {
417
			dev_err(chip->dev, "Operation Canceled\n");
K
Kylene Hall 已提交
418 419 420 421 422
			rc = -ECANCELED;
			goto out;
		}

		msleep(TPM_TIMEOUT);	/* CHECK */
L
Linus Torvalds 已提交
423
		rmb();
424
	} while (time_before(jiffies, stop));
L
Linus Torvalds 已提交
425

K
Kylene Jo Hall 已提交
426
	chip->vendor.cancel(chip);
427
	dev_err(chip->dev, "Operation Timed out\n");
K
Kylene Hall 已提交
428 429
	rc = -ETIME;
	goto out;
L
Linus Torvalds 已提交
430 431

out_recv:
K
Kylene Jo Hall 已提交
432
	rc = chip->vendor.recv(chip, (u8 *) buf, bufsiz);
K
Kylene Hall 已提交
433
	if (rc < 0)
434
		dev_err(chip->dev,
K
Kylene Hall 已提交
435 436
			"tpm_transmit: tpm_recv: error %zd\n", rc);
out:
437
	mutex_unlock(&chip->tpm_mutex);
K
Kylene Hall 已提交
438
	return rc;
L
Linus Torvalds 已提交
439 440 441
}

#define TPM_DIGEST_SIZE 20
442 443 444 445
#define TPM_ERROR_SIZE 10
#define TPM_RET_CODE_IDX 6

enum tpm_capabilities {
446 447 448 449
	TPM_CAP_FLAG = cpu_to_be32(4),
	TPM_CAP_PROP = cpu_to_be32(5),
	CAP_VERSION_1_1 = cpu_to_be32(0x06),
	CAP_VERSION_1_2 = cpu_to_be32(0x1A)
450 451 452
};

enum tpm_sub_capabilities {
453 454 455 456 457 458 459
	TPM_CAP_PROP_PCR = cpu_to_be32(0x101),
	TPM_CAP_PROP_MANUFACTURER = cpu_to_be32(0x103),
	TPM_CAP_FLAG_PERM = cpu_to_be32(0x108),
	TPM_CAP_FLAG_VOL = cpu_to_be32(0x109),
	TPM_CAP_PROP_OWNER = cpu_to_be32(0x111),
	TPM_CAP_PROP_TIS_TIMEOUT = cpu_to_be32(0x115),
	TPM_CAP_PROP_TIS_DURATION = cpu_to_be32(0x120),
460

L
Linus Torvalds 已提交
461 462
};

463 464
static ssize_t transmit_cmd(struct tpm_chip *chip, struct tpm_cmd_t *cmd,
			    int len, const char *desc)
465 466 467
{
	int err;

468
	len = tpm_transmit(chip,(u8 *) cmd, len);
469 470 471
	if (len <  0)
		return len;
	if (len == TPM_ERROR_SIZE) {
472
		err = be32_to_cpu(cmd->header.out.return_code);
473 474 475 476 477 478
		dev_dbg(chip->dev, "A TPM error (%d) occurred %s\n", err, desc);
		return err;
	}
	return 0;
}

479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516
#define TPM_INTERNAL_RESULT_SIZE 200
#define TPM_TAG_RQU_COMMAND cpu_to_be16(193)
#define TPM_ORD_GET_CAP cpu_to_be32(101)

static const struct tpm_input_header tpm_getcap_header = {
	.tag = TPM_TAG_RQU_COMMAND,
	.length = cpu_to_be32(22),
	.ordinal = TPM_ORD_GET_CAP
};

ssize_t tpm_getcap(struct device *dev, __be32 subcap_id, cap_t *cap,
		   const char *desc)
{
	struct tpm_cmd_t tpm_cmd;
	int rc;
	struct tpm_chip *chip = dev_get_drvdata(dev);

	tpm_cmd.header.in = tpm_getcap_header;
	if (subcap_id == CAP_VERSION_1_1 || subcap_id == CAP_VERSION_1_2) {
		tpm_cmd.params.getcap_in.cap = subcap_id;
		/*subcap field not necessary */
		tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(0);
		tpm_cmd.header.in.length -= cpu_to_be32(sizeof(__be32));
	} else {
		if (subcap_id == TPM_CAP_FLAG_PERM ||
		    subcap_id == TPM_CAP_FLAG_VOL)
			tpm_cmd.params.getcap_in.cap = TPM_CAP_FLAG;
		else
			tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP;
		tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4);
		tpm_cmd.params.getcap_in.subcap = subcap_id;
	}
	rc = transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, desc);
	if (!rc)
		*cap = tpm_cmd.params.getcap_out.cap;
	return rc;
}

517 518
void tpm_gen_interrupt(struct tpm_chip *chip)
{
519
	struct	tpm_cmd_t tpm_cmd;
520 521
	ssize_t rc;

522 523 524 525
	tpm_cmd.header.in = tpm_getcap_header;
	tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP;
	tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4);
	tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_TIMEOUT;
526

527
	rc = transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE,
528 529 530 531 532 533
			"attempting to determine the timeouts");
}
EXPORT_SYMBOL_GPL(tpm_gen_interrupt);

void tpm_get_timeouts(struct tpm_chip *chip)
{
534 535 536
	struct tpm_cmd_t tpm_cmd;
	struct timeout_t *timeout_cap;
	struct duration_t *duration_cap;
537 538 539
	ssize_t rc;
	u32 timeout;

540 541 542 543
	tpm_cmd.header.in = tpm_getcap_header;
	tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP;
	tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4);
	tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_TIMEOUT;
544

545
	rc = transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE,
546 547 548 549
			"attempting to determine the timeouts");
	if (rc)
		goto duration;

550
	if (be32_to_cpu(tpm_cmd.header.out.length)
551 552 553
	    != 4 * sizeof(u32))
		goto duration;

554
	timeout_cap = &tpm_cmd.params.getcap_out.cap.timeout;
555
	/* Don't overwrite default if value is 0 */
556
	timeout = be32_to_cpu(timeout_cap->a);
557
	if (timeout)
558
		chip->vendor.timeout_a = usecs_to_jiffies(timeout);
559
	timeout = be32_to_cpu(timeout_cap->b);
560
	if (timeout)
561
		chip->vendor.timeout_b = usecs_to_jiffies(timeout);
562
	timeout = be32_to_cpu(timeout_cap->c);
563
	if (timeout)
564
		chip->vendor.timeout_c = usecs_to_jiffies(timeout);
565
	timeout = be32_to_cpu(timeout_cap->d);
566
	if (timeout)
567
		chip->vendor.timeout_d = usecs_to_jiffies(timeout);
568 569

duration:
570 571 572 573
	tpm_cmd.header.in = tpm_getcap_header;
	tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP;
	tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4);
	tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_DURATION;
574

575
	rc = transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE,
576 577 578 579
			"attempting to determine the durations");
	if (rc)
		return;

580 581 582
	if (be32_to_cpu(tpm_cmd.header.out.return_code) != 0 ||
	    be32_to_cpu(tpm_cmd.header.out.length)
	    != sizeof(tpm_cmd.header.out) + sizeof(u32) + 3 * sizeof(u32))
583
		return;
584

585
	duration_cap = &tpm_cmd.params.getcap_out.cap.duration;
586
	chip->vendor.duration[TPM_SHORT] =
587
	    usecs_to_jiffies(be32_to_cpu(duration_cap->tpm_short));
588 589 590 591 592 593 594
	/* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above
	 * value wrong and apparently reports msecs rather than usecs. So we
	 * fix up the resulting too-small TPM_SHORT value to make things work.
	 */
	if (chip->vendor.duration[TPM_SHORT] < (HZ/100))
		chip->vendor.duration[TPM_SHORT] = HZ;

595
	chip->vendor.duration[TPM_MEDIUM] =
596
	    usecs_to_jiffies(be32_to_cpu(duration_cap->tpm_medium));
597
	chip->vendor.duration[TPM_LONG] =
598
	    usecs_to_jiffies(be32_to_cpu(duration_cap->tpm_long));
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616
}
EXPORT_SYMBOL_GPL(tpm_get_timeouts);

void tpm_continue_selftest(struct tpm_chip *chip)
{
	u8 data[] = {
		0, 193,			/* TPM_TAG_RQU_COMMAND */
		0, 0, 0, 10,		/* length */
		0, 0, 0, 83,		/* TPM_ORD_GetCapability */
	};

	tpm_transmit(chip, data, sizeof(data));
}
EXPORT_SYMBOL_GPL(tpm_continue_selftest);

ssize_t tpm_show_enabled(struct device * dev, struct device_attribute * attr,
			char *buf)
{
617
	cap_t cap;
618 619
	ssize_t rc;

620 621 622
	rc = tpm_getcap(dev, TPM_CAP_FLAG_PERM, &cap,
			 "attempting to determine the permanent enabled state");
	if (rc)
623
		return 0;
624

625
	rc = sprintf(buf, "%d\n", !cap.perm_flags.disable);
626
	return rc;
627 628 629 630 631 632
}
EXPORT_SYMBOL_GPL(tpm_show_enabled);

ssize_t tpm_show_active(struct device * dev, struct device_attribute * attr,
			char *buf)
{
633
	cap_t cap;
634 635
	ssize_t rc;

636 637 638
	rc = tpm_getcap(dev, TPM_CAP_FLAG_PERM, &cap,
			 "attempting to determine the permanent active state");
	if (rc)
639
		return 0;
640

641
	rc = sprintf(buf, "%d\n", !cap.perm_flags.deactivated);
642
	return rc;
643 644 645 646 647 648
}
EXPORT_SYMBOL_GPL(tpm_show_active);

ssize_t tpm_show_owned(struct device * dev, struct device_attribute * attr,
			char *buf)
{
649
	cap_t cap;
650 651
	ssize_t rc;

652 653 654
	rc = tpm_getcap(dev, TPM_CAP_PROP_OWNER, &cap,
			 "attempting to determine the owner state");
	if (rc)
655
		return 0;
656

657
	rc = sprintf(buf, "%d\n", cap.owned);
658
	return rc;
659 660 661 662 663 664
}
EXPORT_SYMBOL_GPL(tpm_show_owned);

ssize_t tpm_show_temp_deactivated(struct device * dev,
				struct device_attribute * attr, char *buf)
{
665
	cap_t cap;
666 667
	ssize_t rc;

668 669 670
	rc = tpm_getcap(dev, TPM_CAP_FLAG_VOL, &cap,
			 "attempting to determine the temporary state");
	if (rc)
671
		return 0;
672

673
	rc = sprintf(buf, "%d\n", cap.stclear_flags.deactivated);
674
	return rc;
675 676 677
}
EXPORT_SYMBOL_GPL(tpm_show_temp_deactivated);

R
Rajiv Andrade 已提交
678 679 680 681 682
/*
 * tpm_chip_find_get - return tpm_chip for given chip number
 */
static struct tpm_chip *tpm_chip_find_get(int chip_num)
{
R
Rajiv Andrade 已提交
683
	struct tpm_chip *pos, *chip = NULL;
R
Rajiv Andrade 已提交
684 685 686 687 688 689

	rcu_read_lock();
	list_for_each_entry_rcu(pos, &tpm_chip_list, list) {
		if (chip_num != TPM_ANY_NUM && chip_num != pos->dev_num)
			continue;

R
Rajiv Andrade 已提交
690 691
		if (try_module_get(pos->dev->driver->owner)) {
			chip = pos;
R
Rajiv Andrade 已提交
692
			break;
R
Rajiv Andrade 已提交
693
		}
R
Rajiv Andrade 已提交
694 695
	}
	rcu_read_unlock();
R
Rajiv Andrade 已提交
696
	return chip;
R
Rajiv Andrade 已提交
697 698 699 700 701 702 703 704
}

#define TPM_ORDINAL_PCRREAD cpu_to_be32(21)
#define READ_PCR_RESULT_SIZE 30
static struct tpm_input_header pcrread_header = {
	.tag = TPM_TAG_RQU_COMMAND,
	.length = cpu_to_be32(14),
	.ordinal = TPM_ORDINAL_PCRREAD
L
Linus Torvalds 已提交
705 706
};

R
Rajiv Andrade 已提交
707 708 709 710 711 712 713
int __tpm_pcr_read(struct tpm_chip *chip, int pcr_idx, u8 *res_buf)
{
	int rc;
	struct tpm_cmd_t cmd;

	cmd.header.in = pcrread_header;
	cmd.params.pcrread_in.pcr_idx = cpu_to_be32(pcr_idx);
R
Rajiv Andrade 已提交
714
	rc = transmit_cmd(chip, &cmd, READ_PCR_RESULT_SIZE,
R
Rajiv Andrade 已提交
715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742
			  "attempting to read a pcr value");

	if (rc == 0)
		memcpy(res_buf, cmd.params.pcrread_out.pcr_result,
		       TPM_DIGEST_SIZE);
	return rc;
}

/**
 * tpm_pcr_read - read a pcr value
 * @chip_num: 	tpm idx # or ANY
 * @pcr_idx:	pcr idx to retrieve
 * @res_buf: 	TPM_PCR value
 * 		size of res_buf is 20 bytes (or NULL if you don't care)
 *
 * The TPM driver should be built-in, but for whatever reason it
 * isn't, protect against the chip disappearing, by incrementing
 * the module usage count.
 */
int tpm_pcr_read(u32 chip_num, int pcr_idx, u8 *res_buf)
{
	struct tpm_chip *chip;
	int rc;

	chip = tpm_chip_find_get(chip_num);
	if (chip == NULL)
		return -ENODEV;
	rc = __tpm_pcr_read(chip, pcr_idx, res_buf);
M
Mimi Zohar 已提交
743
	tpm_chip_put(chip);
R
Rajiv Andrade 已提交
744 745 746 747 748 749 750 751 752 753 754 755 756 757 758
	return rc;
}
EXPORT_SYMBOL_GPL(tpm_pcr_read);

/**
 * tpm_pcr_extend - extend pcr value with hash
 * @chip_num: 	tpm idx # or AN&
 * @pcr_idx:	pcr idx to extend
 * @hash: 	hash value used to extend pcr value
 *
 * The TPM driver should be built-in, but for whatever reason it
 * isn't, protect against the chip disappearing, by incrementing
 * the module usage count.
 */
#define TPM_ORD_PCR_EXTEND cpu_to_be32(20)
759
#define EXTEND_PCR_RESULT_SIZE 34
R
Rajiv Andrade 已提交
760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778
static struct tpm_input_header pcrextend_header = {
	.tag = TPM_TAG_RQU_COMMAND,
	.length = cpu_to_be32(34),
	.ordinal = TPM_ORD_PCR_EXTEND
};

int tpm_pcr_extend(u32 chip_num, int pcr_idx, const u8 *hash)
{
	struct tpm_cmd_t cmd;
	int rc;
	struct tpm_chip *chip;

	chip = tpm_chip_find_get(chip_num);
	if (chip == NULL)
		return -ENODEV;

	cmd.header.in = pcrextend_header;
	cmd.params.pcrextend_in.pcr_idx = cpu_to_be32(pcr_idx);
	memcpy(cmd.params.pcrextend_in.hash, hash, TPM_DIGEST_SIZE);
779
	rc = transmit_cmd(chip, &cmd, EXTEND_PCR_RESULT_SIZE,
R
Rajiv Andrade 已提交
780 781
			  "attempting extend a PCR value");

M
Mimi Zohar 已提交
782
	tpm_chip_put(chip);
R
Rajiv Andrade 已提交
783 784 785 786
	return rc;
}
EXPORT_SYMBOL_GPL(tpm_pcr_extend);

M
Mimi Zohar 已提交
787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
int tpm_send(u32 chip_num, void *cmd, size_t buflen)
{
	struct tpm_chip *chip;
	int rc;

	chip = tpm_chip_find_get(chip_num);
	if (chip == NULL)
		return -ENODEV;

	rc = transmit_cmd(chip, cmd, buflen, "attempting tpm_cmd");

	tpm_chip_put(chip);
	return rc;
}
EXPORT_SYMBOL_GPL(tpm_send);

803 804
ssize_t tpm_show_pcrs(struct device *dev, struct device_attribute *attr,
		      char *buf)
L
Linus Torvalds 已提交
805
{
806
	cap_t cap;
R
Rajiv Andrade 已提交
807
	u8 digest[TPM_DIGEST_SIZE];
808
	ssize_t rc;
809
	int i, j, num_pcrs;
L
Linus Torvalds 已提交
810
	char *str = buf;
811
	struct tpm_chip *chip = dev_get_drvdata(dev);
L
Linus Torvalds 已提交
812

813
	rc = tpm_getcap(dev, TPM_CAP_PROP_PCR, &cap,
814
			"attempting to determine the number of PCRS");
815
	if (rc)
K
Kylene Hall 已提交
816
		return 0;
L
Linus Torvalds 已提交
817

818
	num_pcrs = be32_to_cpu(cap.num_pcrs);
L
Linus Torvalds 已提交
819
	for (i = 0; i < num_pcrs; i++) {
R
Rajiv Andrade 已提交
820
		rc = __tpm_pcr_read(chip, i, digest);
821
		if (rc)
822
			break;
L
Linus Torvalds 已提交
823 824
		str += sprintf(str, "PCR-%02d: ", i);
		for (j = 0; j < TPM_DIGEST_SIZE; j++)
R
Rajiv Andrade 已提交
825
			str += sprintf(str, "%02X ", digest[j]);
L
Linus Torvalds 已提交
826 827 828 829
		str += sprintf(str, "\n");
	}
	return str - buf;
}
830
EXPORT_SYMBOL_GPL(tpm_show_pcrs);
L
Linus Torvalds 已提交
831 832

#define  READ_PUBEK_RESULT_SIZE 314
833 834 835 836 837
#define TPM_ORD_READPUBEK cpu_to_be32(124)
struct tpm_input_header tpm_readpubek_header = {
	.tag = TPM_TAG_RQU_COMMAND,
	.length = cpu_to_be32(30),
	.ordinal = TPM_ORD_READPUBEK
L
Linus Torvalds 已提交
838 839
};

840 841
ssize_t tpm_show_pubek(struct device *dev, struct device_attribute *attr,
		       char *buf)
L
Linus Torvalds 已提交
842
{
K
Kylene Hall 已提交
843
	u8 *data;
844
	struct tpm_cmd_t tpm_cmd;
845
	ssize_t err;
846
	int i, rc;
L
Linus Torvalds 已提交
847 848
	char *str = buf;

849
	struct tpm_chip *chip = dev_get_drvdata(dev);
L
Linus Torvalds 已提交
850

851 852
	tpm_cmd.header.in = tpm_readpubek_header;
	err = transmit_cmd(chip, &tpm_cmd, READ_PUBEK_RESULT_SIZE,
853 854
			"attempting to read the PUBEK");
	if (err)
855
		goto out;
L
Linus Torvalds 已提交
856 857 858 859 860 861 862 863 864 865 866

	/* 
	   ignore header 10 bytes
	   algorithm 32 bits (1 == RSA )
	   encscheme 16 bits
	   sigscheme 16 bits
	   parameters (RSA 12->bytes: keybit, #primes, expbit)  
	   keylenbytes 32 bits
	   256 byte modulus
	   ignore checksum 20 bytes
	 */
867
	data = tpm_cmd.params.readpubek_out_buffer;
L
Linus Torvalds 已提交
868 869 870 871 872 873 874 875 876 877
	str +=
	    sprintf(str,
		    "Algorithm: %02X %02X %02X %02X\nEncscheme: %02X %02X\n"
		    "Sigscheme: %02X %02X\nParameters: %02X %02X %02X %02X"
		    " %02X %02X %02X %02X %02X %02X %02X %02X\n"
		    "Modulus length: %d\nModulus: \n",
		    data[10], data[11], data[12], data[13], data[14],
		    data[15], data[16], data[17], data[22], data[23],
		    data[24], data[25], data[26], data[27], data[28],
		    data[29], data[30], data[31], data[32], data[33],
K
Kylene Jo Hall 已提交
878
		    be32_to_cpu(*((__be32 *) (data + 34))));
L
Linus Torvalds 已提交
879 880

	for (i = 0; i < 256; i++) {
K
Kylene Jo Hall 已提交
881
		str += sprintf(str, "%02X ", data[i + 38]);
L
Linus Torvalds 已提交
882 883 884
		if ((i + 1) % 16 == 0)
			str += sprintf(str, "\n");
	}
885
out:
886
	rc = str - buf;
K
Kylene Hall 已提交
887
	return rc;
L
Linus Torvalds 已提交
888
}
889
EXPORT_SYMBOL_GPL(tpm_show_pubek);
L
Linus Torvalds 已提交
890 891


892 893
ssize_t tpm_show_caps(struct device *dev, struct device_attribute *attr,
		      char *buf)
L
Linus Torvalds 已提交
894
{
895
	cap_t cap;
896
	ssize_t rc;
L
Linus Torvalds 已提交
897 898
	char *str = buf;

899
	rc = tpm_getcap(dev, TPM_CAP_PROP_MANUFACTURER, &cap,
900
			"attempting to determine the manufacturer");
901
	if (rc)
902
		return 0;
L
Linus Torvalds 已提交
903
	str += sprintf(str, "Manufacturer: 0x%x\n",
904
		       be32_to_cpu(cap.manufacturer_id));
L
Linus Torvalds 已提交
905

906 907
	rc = tpm_getcap(dev, CAP_VERSION_1_1, &cap,
		        "attempting to determine the 1.1 version");
908
	if (rc)
909
		return 0;
910 911
	str += sprintf(str,
		       "TCG version: %d.%d\nFirmware version: %d.%d\n",
912 913
		       cap.tpm_version.Major, cap.tpm_version.Minor,
		       cap.tpm_version.revMajor, cap.tpm_version.revMinor);
L
Linus Torvalds 已提交
914 915
	return str - buf;
}
916 917
EXPORT_SYMBOL_GPL(tpm_show_caps);

918 919 920
ssize_t tpm_show_caps_1_2(struct device * dev,
			  struct device_attribute * attr, char *buf)
{
921 922
	cap_t cap;
	ssize_t rc;
923 924
	char *str = buf;

925 926 927
	rc = tpm_getcap(dev, TPM_CAP_PROP_MANUFACTURER, &cap,
			"attempting to determine the manufacturer");
	if (rc)
928 929
		return 0;
	str += sprintf(str, "Manufacturer: 0x%x\n",
930 931 932 933 934
		       be32_to_cpu(cap.manufacturer_id));
	rc = tpm_getcap(dev, CAP_VERSION_1_2, &cap,
			 "attempting to determine the 1.2 version");
	if (rc)
		return 0;
935 936
	str += sprintf(str,
		       "TCG version: %d.%d\nFirmware version: %d.%d\n",
937 938 939
		       cap.tpm_version_1_2.Major, cap.tpm_version_1_2.Minor,
		       cap.tpm_version_1_2.revMajor,
		       cap.tpm_version_1_2.revMinor);
940 941 942 943
	return str - buf;
}
EXPORT_SYMBOL_GPL(tpm_show_caps_1_2);

944 945 946 947 948 949 950 951 952 953 954 955
ssize_t tpm_show_timeouts(struct device *dev, struct device_attribute *attr,
			  char *buf)
{
	struct tpm_chip *chip = dev_get_drvdata(dev);

	return sprintf(buf, "%d %d %d\n",
	               jiffies_to_usecs(chip->vendor.duration[TPM_SHORT]),
	               jiffies_to_usecs(chip->vendor.duration[TPM_MEDIUM]),
	               jiffies_to_usecs(chip->vendor.duration[TPM_LONG]));
}
EXPORT_SYMBOL_GPL(tpm_show_timeouts);

956 957 958 959 960 961 962
ssize_t tpm_store_cancel(struct device *dev, struct device_attribute *attr,
			const char *buf, size_t count)
{
	struct tpm_chip *chip = dev_get_drvdata(dev);
	if (chip == NULL)
		return 0;

K
Kylene Jo Hall 已提交
963
	chip->vendor.cancel(chip);
964 965 966
	return count;
}
EXPORT_SYMBOL_GPL(tpm_store_cancel);
L
Linus Torvalds 已提交
967 968 969

/*
 * Device file system interface to the TPM
970 971 972 973
 *
 * It's assured that the chip will be opened just once,
 * by the check of is_open variable, which is protected
 * by driver_lock.
L
Linus Torvalds 已提交
974 975 976
 */
int tpm_open(struct inode *inode, struct file *file)
{
977
	int minor = iminor(inode);
L
Linus Torvalds 已提交
978 979
	struct tpm_chip *chip = NULL, *pos;

980 981
	rcu_read_lock();
	list_for_each_entry_rcu(pos, &tpm_chip_list, list) {
K
Kylene Jo Hall 已提交
982
		if (pos->vendor.miscdev.minor == minor) {
L
Linus Torvalds 已提交
983
			chip = pos;
984
			get_device(chip->dev);
L
Linus Torvalds 已提交
985 986 987
			break;
		}
	}
988
	rcu_read_unlock();
L
Linus Torvalds 已提交
989

990 991
	if (!chip)
		return -ENODEV;
L
Linus Torvalds 已提交
992

993
	if (test_and_set_bit(0, &chip->is_open)) {
A
Andrew Morton 已提交
994
		dev_dbg(chip->dev, "Another process owns this TPM\n");
995 996
		put_device(chip->dev);
		return -EBUSY;
L
Linus Torvalds 已提交
997 998 999 1000
	}

	chip->data_buffer = kmalloc(TPM_BUFSIZE * sizeof(u8), GFP_KERNEL);
	if (chip->data_buffer == NULL) {
1001
		clear_bit(0, &chip->is_open);
1002
		put_device(chip->dev);
L
Linus Torvalds 已提交
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
		return -ENOMEM;
	}

	atomic_set(&chip->data_pending, 0);

	file->private_data = chip;
	return 0;
}
EXPORT_SYMBOL_GPL(tpm_open);

1013 1014 1015
/*
 * Called on file close
 */
L
Linus Torvalds 已提交
1016 1017 1018 1019
int tpm_release(struct inode *inode, struct file *file)
{
	struct tpm_chip *chip = file->private_data;

1020
	del_singleshot_timer_sync(&chip->user_read_timer);
T
Tejun Heo 已提交
1021
	flush_work_sync(&chip->work);
K
Kylene Hall 已提交
1022
	file->private_data = NULL;
L
Linus Torvalds 已提交
1023
	atomic_set(&chip->data_pending, 0);
1024
	kfree(chip->data_buffer);
1025
	clear_bit(0, &chip->is_open);
1026
	put_device(chip->dev);
L
Linus Torvalds 已提交
1027 1028 1029 1030
	return 0;
}
EXPORT_SYMBOL_GPL(tpm_release);

A
Andrew Morton 已提交
1031
ssize_t tpm_write(struct file *file, const char __user *buf,
K
Kylene Jo Hall 已提交
1032
		  size_t size, loff_t *off)
L
Linus Torvalds 已提交
1033 1034
{
	struct tpm_chip *chip = file->private_data;
1035
	size_t in_size = size, out_size;
L
Linus Torvalds 已提交
1036 1037 1038

	/* cannot perform a write until the read has cleared
	   either via tpm_read or a user_read_timer timeout */
1039 1040
	while (atomic_read(&chip->data_pending) != 0)
		msleep(TPM_TIMEOUT);
L
Linus Torvalds 已提交
1041

1042
	mutex_lock(&chip->buffer_mutex);
L
Linus Torvalds 已提交
1043 1044 1045 1046 1047 1048

	if (in_size > TPM_BUFSIZE)
		in_size = TPM_BUFSIZE;

	if (copy_from_user
	    (chip->data_buffer, (void __user *) buf, in_size)) {
1049
		mutex_unlock(&chip->buffer_mutex);
L
Linus Torvalds 已提交
1050 1051 1052 1053 1054 1055 1056
		return -EFAULT;
	}

	/* atomic tpm command send and result receive */
	out_size = tpm_transmit(chip, chip->data_buffer, TPM_BUFSIZE);

	atomic_set(&chip->data_pending, out_size);
1057
	mutex_unlock(&chip->buffer_mutex);
L
Linus Torvalds 已提交
1058 1059

	/* Set a timeout by which the reader must come claim the result */
1060
	mod_timer(&chip->user_read_timer, jiffies + (60 * HZ));
L
Linus Torvalds 已提交
1061 1062 1063 1064 1065

	return in_size;
}
EXPORT_SYMBOL_GPL(tpm_write);

K
Kylene Jo Hall 已提交
1066 1067
ssize_t tpm_read(struct file *file, char __user *buf,
		 size_t size, loff_t *off)
L
Linus Torvalds 已提交
1068 1069
{
	struct tpm_chip *chip = file->private_data;
1070
	ssize_t ret_size;
L
Linus Torvalds 已提交
1071

1072
	del_singleshot_timer_sync(&chip->user_read_timer);
T
Tejun Heo 已提交
1073
	flush_work_sync(&chip->work);
1074 1075 1076 1077 1078
	ret_size = atomic_read(&chip->data_pending);
	atomic_set(&chip->data_pending, 0);
	if (ret_size > 0) {	/* relay data */
		if (size < ret_size)
			ret_size = size;
L
Linus Torvalds 已提交
1079

1080
		mutex_lock(&chip->buffer_mutex);
1081
		if (copy_to_user(buf, chip->data_buffer, ret_size))
1082
			ret_size = -EFAULT;
1083
		mutex_unlock(&chip->buffer_mutex);
L
Linus Torvalds 已提交
1084 1085 1086 1087 1088 1089
	}

	return ret_size;
}
EXPORT_SYMBOL_GPL(tpm_read);

1090
void tpm_remove_hardware(struct device *dev)
L
Linus Torvalds 已提交
1091
{
1092
	struct tpm_chip *chip = dev_get_drvdata(dev);
L
Linus Torvalds 已提交
1093 1094

	if (chip == NULL) {
1095
		dev_err(dev, "No device data found\n");
L
Linus Torvalds 已提交
1096 1097 1098 1099
		return;
	}

	spin_lock(&driver_lock);
1100
	list_del_rcu(&chip->list);
L
Linus Torvalds 已提交
1101
	spin_unlock(&driver_lock);
1102
	synchronize_rcu();
L
Linus Torvalds 已提交
1103

K
Kylene Jo Hall 已提交
1104 1105
	misc_deregister(&chip->vendor.miscdev);
	sysfs_remove_group(&dev->kobj, chip->vendor.attr_group);
1106
	tpm_bios_log_teardown(chip->bios_dir);
L
Linus Torvalds 已提交
1107

1108 1109
	/* write it this way to be explicit (chip->dev == dev) */
	put_device(chip->dev);
L
Linus Torvalds 已提交
1110
}
1111
EXPORT_SYMBOL_GPL(tpm_remove_hardware);
L
Linus Torvalds 已提交
1112

1113 1114 1115 1116 1117 1118 1119 1120 1121
#define TPM_ORD_SAVESTATE cpu_to_be32(152)
#define SAVESTATE_RESULT_SIZE 10

static struct tpm_input_header savestate_header = {
	.tag = TPM_TAG_RQU_COMMAND,
	.length = cpu_to_be32(10),
	.ordinal = TPM_ORD_SAVESTATE
};

L
Linus Torvalds 已提交
1122 1123 1124 1125
/*
 * We are about to suspend. Save the TPM state
 * so that it can be restored.
 */
1126
int tpm_pm_suspend(struct device *dev, pm_message_t pm_state)
L
Linus Torvalds 已提交
1127
{
1128
	struct tpm_chip *chip = dev_get_drvdata(dev);
1129 1130 1131 1132
	struct tpm_cmd_t cmd;
	int rc;

	u8 dummy_hash[TPM_DIGEST_SIZE] = { 0 };
1133

L
Linus Torvalds 已提交
1134 1135 1136
	if (chip == NULL)
		return -ENODEV;

1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151
	/* for buggy tpm, flush pcrs with extend to selected dummy */
	if (tpm_suspend_pcr) {
		cmd.header.in = pcrextend_header;
		cmd.params.pcrextend_in.pcr_idx = cpu_to_be32(tpm_suspend_pcr);
		memcpy(cmd.params.pcrextend_in.hash, dummy_hash,
		       TPM_DIGEST_SIZE);
		rc = transmit_cmd(chip, &cmd, EXTEND_PCR_RESULT_SIZE,
				  "extending dummy pcr before suspend");
	}

	/* now do the actual savestate */
	cmd.header.in = savestate_header;
	rc = transmit_cmd(chip, &cmd, SAVESTATE_RESULT_SIZE,
			  "sending savestate before suspend");
	return rc;
L
Linus Torvalds 已提交
1152 1153 1154 1155 1156 1157 1158
}
EXPORT_SYMBOL_GPL(tpm_pm_suspend);

/*
 * Resume from a power safe. The BIOS already restored
 * the TPM state.
 */
1159
int tpm_pm_resume(struct device *dev)
L
Linus Torvalds 已提交
1160
{
1161
	struct tpm_chip *chip = dev_get_drvdata(dev);
L
Linus Torvalds 已提交
1162 1163 1164 1165 1166 1167 1168 1169

	if (chip == NULL)
		return -ENODEV;

	return 0;
}
EXPORT_SYMBOL_GPL(tpm_pm_resume);

1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182
/* In case vendor provided release function, call it too.*/

void tpm_dev_vendor_release(struct tpm_chip *chip)
{
	if (chip->vendor.release)
		chip->vendor.release(chip->dev);

	clear_bit(chip->dev_num, dev_mask);
	kfree(chip->vendor.miscdev.name);
}
EXPORT_SYMBOL_GPL(tpm_dev_vendor_release);


1183 1184 1185 1186
/*
 * Once all references to platform device are down to 0,
 * release all allocated structures.
 */
1187
void tpm_dev_release(struct device *dev)
1188 1189 1190
{
	struct tpm_chip *chip = dev_get_drvdata(dev);

1191
	tpm_dev_vendor_release(chip);
1192

1193
	chip->release(dev);
1194 1195
	kfree(chip);
}
1196
EXPORT_SYMBOL_GPL(tpm_dev_release);
1197

L
Linus Torvalds 已提交
1198 1199 1200 1201 1202 1203 1204
/*
 * Called from tpm_<specific>.c probe function only for devices 
 * the driver has determined it should claim.  Prior to calling
 * this function the specific probe function has called pci_enable_device
 * upon errant exit from this function specific probe function should call
 * pci_disable_device
 */
1205 1206
struct tpm_chip *tpm_register_hardware(struct device *dev,
					const struct tpm_vendor_specific *entry)
L
Linus Torvalds 已提交
1207
{
1208 1209 1210
#define DEVNAME_SIZE 7

	char *devname;
L
Linus Torvalds 已提交
1211 1212 1213
	struct tpm_chip *chip;

	/* Driver specific per-device data */
A
Andrew Morton 已提交
1214
	chip = kzalloc(sizeof(*chip), GFP_KERNEL);
P
Parag Warudkar 已提交
1215 1216
	devname = kmalloc(DEVNAME_SIZE, GFP_KERNEL);

1217 1218
	if (chip == NULL || devname == NULL)
		goto out_free;
L
Linus Torvalds 已提交
1219

1220 1221
	mutex_init(&chip->buffer_mutex);
	mutex_init(&chip->tpm_mutex);
L
Linus Torvalds 已提交
1222 1223
	INIT_LIST_HEAD(&chip->list);

D
David Howells 已提交
1224
	INIT_WORK(&chip->work, timeout_work);
K
Kylene Jo Hall 已提交
1225

J
Jiri Slaby 已提交
1226 1227
	setup_timer(&chip->user_read_timer, user_reader_timeout,
			(unsigned long)chip);
1228

K
Kylene Jo Hall 已提交
1229
	memcpy(&chip->vendor, entry, sizeof(struct tpm_vendor_specific));
L
Linus Torvalds 已提交
1230

K
Kylene Jo Hall 已提交
1231
	chip->dev_num = find_first_zero_bit(dev_mask, TPM_NUM_DEVICES);
L
Linus Torvalds 已提交
1232

K
Kylene Jo Hall 已提交
1233
	if (chip->dev_num >= TPM_NUM_DEVICES) {
A
Andrew Morton 已提交
1234
		dev_err(dev, "No available tpm device numbers\n");
1235
		goto out_free;
L
Linus Torvalds 已提交
1236
	} else if (chip->dev_num == 0)
K
Kylene Jo Hall 已提交
1237
		chip->vendor.miscdev.minor = TPM_MINOR;
L
Linus Torvalds 已提交
1238
	else
K
Kylene Jo Hall 已提交
1239
		chip->vendor.miscdev.minor = MISC_DYNAMIC_MINOR;
L
Linus Torvalds 已提交
1240

K
Kylene Jo Hall 已提交
1241 1242
	set_bit(chip->dev_num, dev_mask);

1243
	scnprintf(devname, DEVNAME_SIZE, "%s%d", "tpm", chip->dev_num);
K
Kylene Jo Hall 已提交
1244
	chip->vendor.miscdev.name = devname;
L
Linus Torvalds 已提交
1245

1246
	chip->vendor.miscdev.parent = dev;
1247
	chip->dev = get_device(dev);
1248 1249 1250
	chip->release = dev->release;
	dev->release = tpm_dev_release;
	dev_set_drvdata(dev, chip);
L
Linus Torvalds 已提交
1251

K
Kylene Jo Hall 已提交
1252
	if (misc_register(&chip->vendor.miscdev)) {
1253
		dev_err(chip->dev,
L
Linus Torvalds 已提交
1254
			"unable to misc_register %s, minor %d\n",
K
Kylene Jo Hall 已提交
1255 1256
			chip->vendor.miscdev.name,
			chip->vendor.miscdev.minor);
1257
		put_device(chip->dev);
1258
		return NULL;
L
Linus Torvalds 已提交
1259 1260
	}

J
Jeff Garzik 已提交
1261
	if (sysfs_create_group(&dev->kobj, chip->vendor.attr_group)) {
1262
		misc_deregister(&chip->vendor.miscdev);
1263
		put_device(chip->dev);
1264

J
Jeff Garzik 已提交
1265 1266
		return NULL;
	}
L
Linus Torvalds 已提交
1267

1268 1269
	chip->bios_dir = tpm_bios_log_setup(devname);

1270 1271 1272 1273 1274
	/* Make chip available */
	spin_lock(&driver_lock);
	list_add_rcu(&chip->list, &tpm_chip_list);
	spin_unlock(&driver_lock);

1275
	return chip;
1276 1277 1278 1279 1280

out_free:
	kfree(chip);
	kfree(devname);
	return NULL;
L
Linus Torvalds 已提交
1281 1282 1283 1284 1285 1286 1287
}
EXPORT_SYMBOL_GPL(tpm_register_hardware);

MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
MODULE_DESCRIPTION("TPM Driver");
MODULE_VERSION("2.0");
MODULE_LICENSE("GPL");