2 * Copyright (C) 2004 IBM Corporation
5 * Leendert van Doorn <leendert@watson.ibm.com>
6 * Dave Safford <safford@watson.ibm.com>
7 * Reiner Sailer <sailer@watson.ibm.com>
8 * Kylene Hall <kjhall@us.ibm.com>
10 * Maintained by: <tpmdd_devel@lists.sourceforge.net>
12 * Device driver for TCG/TCPA TPM (trusted platform module).
13 * Specifications at www.trustedcomputinggroup.org
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License as
17 * published by the Free Software Foundation, version 2 of the
20 * Note, the TPM chip is not interrupt driven (only polling)
21 * and can have very long timeouts (minutes!). Hence the unusual
26 #include <linux/sched.h>
27 #include <linux/poll.h>
28 #include <linux/spinlock.h>
32 TPM_MINOR = 224, /* officially assigned */
34 TPM_NUM_DEVICES = 256,
35 TPM_NUM_MASK_ENTRIES = TPM_NUM_DEVICES / (8 * sizeof(int))
38 static LIST_HEAD(tpm_chip_list);
39 static DEFINE_SPINLOCK(driver_lock);
40 static int dev_mask[TPM_NUM_MASK_ENTRIES];
42 static void user_reader_timeout(unsigned long ptr)
44 struct tpm_chip *chip = (struct tpm_chip *) ptr;
46 schedule_work(&chip->work);
49 static void timeout_work(void *ptr)
51 struct tpm_chip *chip = ptr;
53 down(&chip->buffer_mutex);
54 atomic_set(&chip->data_pending, 0);
55 memset(chip->data_buffer, 0, TPM_BUFSIZE);
56 up(&chip->buffer_mutex);
60 * Internal kernel interface to transmit TPM commands
62 static ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
69 count = be32_to_cpu(*((__be32 *) (buf + 2)));
75 "invalid count value %x %zx \n", count, bufsiz);
79 down(&chip->tpm_mutex);
81 if ((rc = chip->vendor->send(chip, (u8 *) buf, count)) < 0) {
83 "tpm_transmit: tpm_send: error %zd\n", rc);
87 stop = jiffies + 2 * 60 * HZ;
89 u8 status = chip->vendor->status(chip);
90 if ((status & chip->vendor->req_complete_mask) ==
91 chip->vendor->req_complete_val) {
95 if ((status == chip->vendor->req_canceled)) {
96 dev_err(chip->dev, "Operation Canceled\n");
101 msleep(TPM_TIMEOUT); /* CHECK */
103 } while (time_before(jiffies, stop));
106 chip->vendor->cancel(chip);
107 dev_err(chip->dev, "Operation Timed out\n");
112 rc = chip->vendor->recv(chip, (u8 *) buf, bufsiz);
115 "tpm_transmit: tpm_recv: error %zd\n", rc);
117 up(&chip->tpm_mutex);
121 #define TPM_DIGEST_SIZE 20
122 #define TPM_ERROR_SIZE 10
123 #define TPM_RET_CODE_IDX 6
124 #define TPM_GET_CAP_RET_SIZE_IDX 10
125 #define TPM_GET_CAP_RET_UINT32_1_IDX 14
126 #define TPM_GET_CAP_RET_UINT32_2_IDX 18
127 #define TPM_GET_CAP_RET_UINT32_3_IDX 22
128 #define TPM_GET_CAP_RET_UINT32_4_IDX 26
130 #define TPM_CAP_IDX 13
131 #define TPM_CAP_SUBCAP_IDX 21
133 enum tpm_capabilities {
137 enum tpm_sub_capabilities {
138 TPM_CAP_PROP_PCR = 0x1,
139 TPM_CAP_PROP_MANUFACTURER = 0x3,
143 * This is a semi generic GetCapability command for use
144 * with the capability type TPM_CAP_PROP or TPM_CAP_FLAG
145 * and their associated sub_capabilities.
148 static const u8 tpm_cap[] = {
149 0, 193, /* TPM_TAG_RQU_COMMAND */
150 0, 0, 0, 22, /* length */
151 0, 0, 0, 101, /* TPM_ORD_GetCapability */
152 0, 0, 0, 0, /* TPM_CAP_<TYPE> */
153 0, 0, 0, 4, /* TPM_CAP_SUB_<TYPE> size */
154 0, 0, 1, 0 /* TPM_CAP_SUB_<TYPE> */
157 static ssize_t transmit_cmd(struct tpm_chip *chip, u8 *data, int len,
162 len = tpm_transmit(chip, data, len);
165 if (len == TPM_ERROR_SIZE) {
166 err = be32_to_cpu(*((__be32 *) (data + TPM_RET_CODE_IDX)));
167 dev_dbg(chip->dev, "A TPM error (%d) occurred %s\n", err, desc);
173 static const u8 pcrread[] = {
174 0, 193, /* TPM_TAG_RQU_COMMAND */
175 0, 0, 0, 14, /* length */
176 0, 0, 0, 21, /* TPM_ORD_PcrRead */
177 0, 0, 0, 0 /* PCR index */
180 ssize_t tpm_show_pcrs(struct device *dev, struct device_attribute *attr,
189 struct tpm_chip *chip = dev_get_drvdata(dev);
193 memcpy(data, tpm_cap, sizeof(tpm_cap));
194 data[TPM_CAP_IDX] = TPM_CAP_PROP;
195 data[TPM_CAP_SUBCAP_IDX] = TPM_CAP_PROP_PCR;
197 rc = transmit_cmd(chip, data, sizeof(data),
198 "attempting to determine the number of PCRS");
202 num_pcrs = be32_to_cpu(*((__be32 *) (data + 14)));
203 for (i = 0; i < num_pcrs; i++) {
204 memcpy(data, pcrread, sizeof(pcrread));
205 index = cpu_to_be32(i);
206 memcpy(data + 10, &index, 4);
207 rc = transmit_cmd(chip, data, sizeof(data),
208 "attempting to read a PCR");
211 str += sprintf(str, "PCR-%02d: ", i);
212 for (j = 0; j < TPM_DIGEST_SIZE; j++)
213 str += sprintf(str, "%02X ", *(data + 10 + j));
214 str += sprintf(str, "\n");
219 EXPORT_SYMBOL_GPL(tpm_show_pcrs);
221 #define READ_PUBEK_RESULT_SIZE 314
222 static const u8 readpubek[] = {
223 0, 193, /* TPM_TAG_RQU_COMMAND */
224 0, 0, 0, 30, /* length */
225 0, 0, 0, 124, /* TPM_ORD_ReadPubek */
228 ssize_t tpm_show_pubek(struct device *dev, struct device_attribute *attr,
236 struct tpm_chip *chip = dev_get_drvdata(dev);
240 data = kzalloc(READ_PUBEK_RESULT_SIZE, GFP_KERNEL);
244 memcpy(data, readpubek, sizeof(readpubek));
246 err = transmit_cmd(chip, data, READ_PUBEK_RESULT_SIZE,
247 "attempting to read the PUBEK");
252 ignore header 10 bytes
253 algorithm 32 bits (1 == RSA )
256 parameters (RSA 12->bytes: keybit, #primes, expbit)
259 ignore checksum 20 bytes
264 "Algorithm: %02X %02X %02X %02X\nEncscheme: %02X %02X\n"
265 "Sigscheme: %02X %02X\nParameters: %02X %02X %02X %02X"
266 " %02X %02X %02X %02X %02X %02X %02X %02X\n"
267 "Modulus length: %d\nModulus: \n",
268 data[10], data[11], data[12], data[13], data[14],
269 data[15], data[16], data[17], data[22], data[23],
270 data[24], data[25], data[26], data[27], data[28],
271 data[29], data[30], data[31], data[32], data[33],
272 be32_to_cpu(*((__be32 *) (data + 34))));
274 for (i = 0; i < 256; i++) {
275 str += sprintf(str, "%02X ", data[i + 38]);
276 if ((i + 1) % 16 == 0)
277 str += sprintf(str, "\n");
284 EXPORT_SYMBOL_GPL(tpm_show_pubek);
286 #define CAP_VERSION_1_1 6
287 #define CAP_VERSION_IDX 13
288 static const u8 cap_version[] = {
289 0, 193, /* TPM_TAG_RQU_COMMAND */
290 0, 0, 0, 18, /* length */
291 0, 0, 0, 101, /* TPM_ORD_GetCapability */
296 ssize_t tpm_show_caps(struct device *dev, struct device_attribute *attr,
303 struct tpm_chip *chip = dev_get_drvdata(dev);
307 memcpy(data, tpm_cap, sizeof(tpm_cap));
308 data[TPM_CAP_IDX] = TPM_CAP_PROP;
309 data[TPM_CAP_SUBCAP_IDX] = TPM_CAP_PROP_MANUFACTURER;
311 rc = transmit_cmd(chip, data, sizeof(data),
312 "attempting to determine the manufacturer");
316 str += sprintf(str, "Manufacturer: 0x%x\n",
317 be32_to_cpu(*((__be32 *) (data + TPM_GET_CAP_RET_UINT32_1_IDX))));
319 memcpy(data, cap_version, sizeof(cap_version));
320 data[CAP_VERSION_IDX] = CAP_VERSION_1_1;
321 rc = transmit_cmd(chip, data, sizeof(data),
322 "attempting to determine the 1.1 version");
327 "TCG version: %d.%d\nFirmware version: %d.%d\n",
328 (int) data[14], (int) data[15], (int) data[16],
334 EXPORT_SYMBOL_GPL(tpm_show_caps);
336 ssize_t tpm_store_cancel(struct device *dev, struct device_attribute *attr,
337 const char *buf, size_t count)
339 struct tpm_chip *chip = dev_get_drvdata(dev);
343 chip->vendor->cancel(chip);
346 EXPORT_SYMBOL_GPL(tpm_store_cancel);
349 * Device file system interface to the TPM
351 int tpm_open(struct inode *inode, struct file *file)
353 int rc = 0, minor = iminor(inode);
354 struct tpm_chip *chip = NULL, *pos;
356 spin_lock(&driver_lock);
358 list_for_each_entry(pos, &tpm_chip_list, list) {
359 if (pos->vendor->miscdev.minor == minor) {
370 if (chip->num_opens) {
371 dev_dbg(chip->dev, "Another process owns this TPM\n");
377 get_device(chip->dev);
379 spin_unlock(&driver_lock);
381 chip->data_buffer = kmalloc(TPM_BUFSIZE * sizeof(u8), GFP_KERNEL);
382 if (chip->data_buffer == NULL) {
384 put_device(chip->dev);
388 atomic_set(&chip->data_pending, 0);
390 file->private_data = chip;
394 spin_unlock(&driver_lock);
397 EXPORT_SYMBOL_GPL(tpm_open);
399 int tpm_release(struct inode *inode, struct file *file)
401 struct tpm_chip *chip = file->private_data;
403 spin_lock(&driver_lock);
404 file->private_data = NULL;
406 del_singleshot_timer_sync(&chip->user_read_timer);
407 flush_scheduled_work();
408 atomic_set(&chip->data_pending, 0);
409 put_device(chip->dev);
410 kfree(chip->data_buffer);
411 spin_unlock(&driver_lock);
414 EXPORT_SYMBOL_GPL(tpm_release);
416 ssize_t tpm_write(struct file *file, const char __user *buf,
417 size_t size, loff_t *off)
419 struct tpm_chip *chip = file->private_data;
420 int in_size = size, out_size;
422 /* cannot perform a write until the read has cleared
423 either via tpm_read or a user_read_timer timeout */
424 while (atomic_read(&chip->data_pending) != 0)
427 down(&chip->buffer_mutex);
429 if (in_size > TPM_BUFSIZE)
430 in_size = TPM_BUFSIZE;
433 (chip->data_buffer, (void __user *) buf, in_size)) {
434 up(&chip->buffer_mutex);
438 /* atomic tpm command send and result receive */
439 out_size = tpm_transmit(chip, chip->data_buffer, TPM_BUFSIZE);
441 atomic_set(&chip->data_pending, out_size);
442 up(&chip->buffer_mutex);
444 /* Set a timeout by which the reader must come claim the result */
445 mod_timer(&chip->user_read_timer, jiffies + (60 * HZ));
449 EXPORT_SYMBOL_GPL(tpm_write);
451 ssize_t tpm_read(struct file *file, char __user *buf,
452 size_t size, loff_t *off)
454 struct tpm_chip *chip = file->private_data;
457 del_singleshot_timer_sync(&chip->user_read_timer);
458 flush_scheduled_work();
459 ret_size = atomic_read(&chip->data_pending);
460 atomic_set(&chip->data_pending, 0);
461 if (ret_size > 0) { /* relay data */
465 down(&chip->buffer_mutex);
466 if (copy_to_user(buf, chip->data_buffer, ret_size))
468 up(&chip->buffer_mutex);
473 EXPORT_SYMBOL_GPL(tpm_read);
475 void tpm_remove_hardware(struct device *dev)
477 struct tpm_chip *chip = dev_get_drvdata(dev);
480 dev_err(dev, "No device data found\n");
484 spin_lock(&driver_lock);
486 list_del(&chip->list);
488 spin_unlock(&driver_lock);
490 dev_set_drvdata(dev, NULL);
491 misc_deregister(&chip->vendor->miscdev);
492 kfree(chip->vendor->miscdev.name);
494 sysfs_remove_group(&dev->kobj, chip->vendor->attr_group);
495 tpm_bios_log_teardown(chip->bios_dir);
497 dev_mask[chip->dev_num / TPM_NUM_MASK_ENTRIES ] &=
498 ~(1 << (chip->dev_num % TPM_NUM_MASK_ENTRIES));
504 EXPORT_SYMBOL_GPL(tpm_remove_hardware);
506 static u8 savestate[] = {
507 0, 193, /* TPM_TAG_RQU_COMMAND */
508 0, 0, 0, 10, /* blob length (in bytes) */
509 0, 0, 0, 152 /* TPM_ORD_SaveState */
513 * We are about to suspend. Save the TPM state
514 * so that it can be restored.
516 int tpm_pm_suspend(struct device *dev, pm_message_t pm_state)
518 struct tpm_chip *chip = dev_get_drvdata(dev);
522 tpm_transmit(chip, savestate, sizeof(savestate));
525 EXPORT_SYMBOL_GPL(tpm_pm_suspend);
528 * Resume from a power safe. The BIOS already restored
531 int tpm_pm_resume(struct device *dev)
533 struct tpm_chip *chip = dev_get_drvdata(dev);
540 EXPORT_SYMBOL_GPL(tpm_pm_resume);
543 * Called from tpm_<specific>.c probe function only for devices
544 * the driver has determined it should claim. Prior to calling
545 * this function the specific probe function has called pci_enable_device
546 * upon errant exit from this function specific probe function should call
549 int tpm_register_hardware(struct device *dev, struct tpm_vendor_specific *entry)
551 #define DEVNAME_SIZE 7
554 struct tpm_chip *chip;
557 /* Driver specific per-device data */
558 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
562 init_MUTEX(&chip->buffer_mutex);
563 init_MUTEX(&chip->tpm_mutex);
564 INIT_LIST_HEAD(&chip->list);
566 INIT_WORK(&chip->work, timeout_work, chip);
568 init_timer(&chip->user_read_timer);
569 chip->user_read_timer.function = user_reader_timeout;
570 chip->user_read_timer.data = (unsigned long) chip;
572 chip->vendor = entry;
576 for (i = 0; i < TPM_NUM_MASK_ENTRIES; i++)
577 for (j = 0; j < 8 * sizeof(int); j++)
578 if ((dev_mask[i] & (1 << j)) == 0) {
580 i * TPM_NUM_MASK_ENTRIES + j;
581 dev_mask[i] |= 1 << j;
582 goto dev_num_search_complete;
585 dev_num_search_complete:
586 if (chip->dev_num < 0) {
587 dev_err(dev, "No available tpm device numbers\n");
590 } else if (chip->dev_num == 0)
591 chip->vendor->miscdev.minor = TPM_MINOR;
593 chip->vendor->miscdev.minor = MISC_DYNAMIC_MINOR;
595 devname = kmalloc(DEVNAME_SIZE, GFP_KERNEL);
596 scnprintf(devname, DEVNAME_SIZE, "%s%d", "tpm", chip->dev_num);
597 chip->vendor->miscdev.name = devname;
599 chip->vendor->miscdev.dev = dev;
600 chip->dev = get_device(dev);
602 if (misc_register(&chip->vendor->miscdev)) {
604 "unable to misc_register %s, minor %d\n",
605 chip->vendor->miscdev.name,
606 chip->vendor->miscdev.minor);
609 dev_mask[i] &= !(1 << j);
613 spin_lock(&driver_lock);
615 dev_set_drvdata(dev, chip);
617 list_add(&chip->list, &tpm_chip_list);
619 spin_unlock(&driver_lock);
621 sysfs_create_group(&dev->kobj, chip->vendor->attr_group);
623 chip->bios_dir = tpm_bios_log_setup(devname);
627 EXPORT_SYMBOL_GPL(tpm_register_hardware);
629 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
630 MODULE_DESCRIPTION("TPM Driver");
631 MODULE_VERSION("2.0");
632 MODULE_LICENSE("GPL");