Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2004 IBM Corporation |
| 3 | * |
| 4 | * Authors: |
| 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> |
| 9 | * |
Kent Yoder | 8e81cc1 | 2007-08-22 14:01:04 -0700 | [diff] [blame] | 10 | * Maintained by: <tpmdd-devel@lists.sourceforge.net> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | * |
| 12 | * Device driver for TCG/TCPA TPM (trusted platform module). |
| 13 | * Specifications at www.trustedcomputinggroup.org |
| 14 | * |
| 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 |
| 18 | * License. |
| 19 | * |
| 20 | */ |
| 21 | #include <linux/module.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | #include <linux/delay.h> |
| 23 | #include <linux/fs.h> |
Matthias Kaehlcke | d081d47 | 2007-05-08 00:32:02 -0700 | [diff] [blame] | 24 | #include <linux/mutex.h> |
Al Viro | 914e263 | 2006-10-18 13:55:46 -0400 | [diff] [blame] | 25 | #include <linux/sched.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | #include <linux/miscdevice.h> |
Al Viro | bbc5b21 | 2005-11-01 15:14:05 +0000 | [diff] [blame] | 27 | #include <linux/platform_device.h> |
Andrew Morton | 276ad0c | 2006-03-25 03:07:35 -0800 | [diff] [blame] | 28 | #include <linux/io.h> |
Rajiv Andrade | 659aaf2 | 2009-02-02 15:23:44 -0200 | [diff] [blame] | 29 | #include <linux/tpm.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 30 | |
Kylene Hall | 3122a88 | 2005-06-23 22:01:48 -0700 | [diff] [blame] | 31 | enum tpm_timeout { |
| 32 | TPM_TIMEOUT = 5, /* msecs */ |
| 33 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | |
| 35 | /* TPM addresses */ |
Kylene Hall | 3122a88 | 2005-06-23 22:01:48 -0700 | [diff] [blame] | 36 | enum tpm_addr { |
Kylene Jo Hall | daacdfa | 2005-06-25 14:55:39 -0700 | [diff] [blame] | 37 | TPM_SUPERIO_ADDR = 0x2E, |
Kylene Hall | 3122a88 | 2005-06-23 22:01:48 -0700 | [diff] [blame] | 38 | TPM_ADDR = 0x4E, |
Kylene Hall | 3122a88 | 2005-06-23 22:01:48 -0700 | [diff] [blame] | 39 | }; |
| 40 | |
Kylene Hall | 6659ca2 | 2005-06-23 22:02:00 -0700 | [diff] [blame] | 41 | extern ssize_t tpm_show_pubek(struct device *, struct device_attribute *attr, |
| 42 | char *); |
| 43 | extern ssize_t tpm_show_pcrs(struct device *, struct device_attribute *attr, |
| 44 | char *); |
| 45 | extern ssize_t tpm_show_caps(struct device *, struct device_attribute *attr, |
| 46 | char *); |
Kylene Jo Hall | 08e96e4 | 2006-04-22 02:37:50 -0700 | [diff] [blame] | 47 | extern ssize_t tpm_show_caps_1_2(struct device *, struct device_attribute *attr, |
| 48 | char *); |
Kylene Hall | 6659ca2 | 2005-06-23 22:02:00 -0700 | [diff] [blame] | 49 | extern ssize_t tpm_store_cancel(struct device *, struct device_attribute *attr, |
| 50 | const char *, size_t); |
Kylene Jo Hall | 08e96e4 | 2006-04-22 02:37:50 -0700 | [diff] [blame] | 51 | extern ssize_t tpm_show_enabled(struct device *, struct device_attribute *attr, |
| 52 | char *); |
| 53 | extern ssize_t tpm_show_active(struct device *, struct device_attribute *attr, |
| 54 | char *); |
| 55 | extern ssize_t tpm_show_owned(struct device *, struct device_attribute *attr, |
| 56 | char *); |
| 57 | extern ssize_t tpm_show_temp_deactivated(struct device *, |
| 58 | struct device_attribute *attr, char *); |
Stefan Berger | 04ab229 | 2011-03-30 12:13:25 -0400 | [diff] [blame] | 59 | extern ssize_t tpm_show_durations(struct device *, |
| 60 | struct device_attribute *attr, char *); |
Stefan Berger | 6259210 | 2011-03-30 12:13:28 -0400 | [diff] [blame] | 61 | extern ssize_t tpm_show_timeouts(struct device *, |
| 62 | struct device_attribute *attr, char *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | |
| 64 | struct tpm_chip; |
| 65 | |
| 66 | struct tpm_vendor_specific { |
Kylene Jo Hall | e0dd03c | 2006-04-22 02:37:26 -0700 | [diff] [blame] | 67 | const u8 req_complete_mask; |
| 68 | const u8 req_complete_val; |
| 69 | const u8 req_canceled; |
Kylene Jo Hall | ad5ea3c | 2005-11-13 16:07:41 -0800 | [diff] [blame] | 70 | void __iomem *iobase; /* ioremapped address */ |
| 71 | unsigned long base; /* TPM base address */ |
| 72 | |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 73 | int irq; |
Stefan Berger | a7b6682 | 2011-03-30 12:13:32 -0400 | [diff] [blame^] | 74 | int probed_irq; |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 75 | |
Kylene Jo Hall | ad5ea3c | 2005-11-13 16:07:41 -0800 | [diff] [blame] | 76 | int region_size; |
| 77 | int have_region; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 78 | |
| 79 | int (*recv) (struct tpm_chip *, u8 *, size_t); |
| 80 | int (*send) (struct tpm_chip *, u8 *, size_t); |
| 81 | void (*cancel) (struct tpm_chip *); |
Kylene Jo Hall | b4ed3e3 | 2005-10-30 15:03:23 -0800 | [diff] [blame] | 82 | u8 (*status) (struct tpm_chip *); |
Richard MUSIL | 5bd91f1 | 2008-02-06 01:37:02 -0800 | [diff] [blame] | 83 | void (*release) (struct device *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 84 | struct miscdevice miscdev; |
Kylene Hall | 6659ca2 | 2005-06-23 22:02:00 -0700 | [diff] [blame] | 85 | struct attribute_group *attr_group; |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 86 | struct list_head list; |
| 87 | int locality; |
Kylene Jo Hall | 36b2002 | 2006-04-22 02:38:19 -0700 | [diff] [blame] | 88 | unsigned long timeout_a, timeout_b, timeout_c, timeout_d; /* jiffies */ |
Stefan Berger | 6259210 | 2011-03-30 12:13:28 -0400 | [diff] [blame] | 89 | bool timeout_adjusted; |
Kylene Jo Hall | 36b2002 | 2006-04-22 02:38:19 -0700 | [diff] [blame] | 90 | unsigned long duration[3]; /* jiffies */ |
Stefan Berger | 04ab229 | 2011-03-30 12:13:25 -0400 | [diff] [blame] | 91 | bool duration_adjusted; |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 92 | |
| 93 | wait_queue_head_t read_queue; |
| 94 | wait_queue_head_t int_queue; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | }; |
| 96 | |
| 97 | struct tpm_chip { |
Kylene Jo Hall | e659a3f | 2005-10-30 15:03:24 -0800 | [diff] [blame] | 98 | struct device *dev; /* Device stuff */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 99 | |
| 100 | int dev_num; /* /dev/tpm# */ |
Rajiv Andrade | dc36d32 | 2008-10-11 09:04:02 +1100 | [diff] [blame] | 101 | unsigned long is_open; /* only one allowed */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | int time_expired; |
| 103 | |
| 104 | /* Data passed to and from the tpm via the read/write calls */ |
| 105 | u8 *data_buffer; |
| 106 | atomic_t data_pending; |
Matthias Kaehlcke | d081d47 | 2007-05-08 00:32:02 -0700 | [diff] [blame] | 107 | struct mutex buffer_mutex; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 108 | |
| 109 | struct timer_list user_read_timer; /* user needs to claim result */ |
Kylene Jo Hall | 09e12f9 | 2005-11-13 16:07:43 -0800 | [diff] [blame] | 110 | struct work_struct work; |
Matthias Kaehlcke | d081d47 | 2007-05-08 00:32:02 -0700 | [diff] [blame] | 111 | struct mutex tpm_mutex; /* tpm is processing */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | |
Kylene Jo Hall | 90dda52 | 2006-04-22 02:37:15 -0700 | [diff] [blame] | 113 | struct tpm_vendor_specific vendor; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 115 | struct dentry **bios_dir; |
| 116 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | struct list_head list; |
Richard MUSIL | 5bd91f1 | 2008-02-06 01:37:02 -0800 | [diff] [blame] | 118 | void (*release) (struct device *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | }; |
| 120 | |
Leendert van Doorn | 27084ef | 2006-04-22 02:38:03 -0700 | [diff] [blame] | 121 | #define to_tpm_chip(n) container_of(n, struct tpm_chip, vendor) |
| 122 | |
Mimi Zohar | a0e3934 | 2010-11-23 17:50:32 -0500 | [diff] [blame] | 123 | static inline void tpm_chip_put(struct tpm_chip *chip) |
| 124 | { |
| 125 | module_put(chip->dev->driver->owner); |
| 126 | } |
| 127 | |
Kylene Jo Hall | daacdfa | 2005-06-25 14:55:39 -0700 | [diff] [blame] | 128 | static inline int tpm_read_index(int base, int index) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 129 | { |
Kylene Jo Hall | daacdfa | 2005-06-25 14:55:39 -0700 | [diff] [blame] | 130 | outb(index, base); |
| 131 | return inb(base+1) & 0xFF; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | } |
| 133 | |
Kylene Jo Hall | daacdfa | 2005-06-25 14:55:39 -0700 | [diff] [blame] | 134 | static inline void tpm_write_index(int base, int index, int value) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 135 | { |
Kylene Jo Hall | daacdfa | 2005-06-25 14:55:39 -0700 | [diff] [blame] | 136 | outb(index, base); |
| 137 | outb(value & 0xFF, base+1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | } |
Rajiv Andrade | 0883743 | 2009-02-02 15:23:43 -0200 | [diff] [blame] | 139 | struct tpm_input_header { |
| 140 | __be16 tag; |
| 141 | __be32 length; |
| 142 | __be32 ordinal; |
| 143 | }__attribute__((packed)); |
| 144 | |
| 145 | struct tpm_output_header { |
| 146 | __be16 tag; |
| 147 | __be32 length; |
| 148 | __be32 return_code; |
| 149 | }__attribute__((packed)); |
| 150 | |
| 151 | struct stclear_flags_t { |
| 152 | __be16 tag; |
| 153 | u8 deactivated; |
| 154 | u8 disableForceClear; |
| 155 | u8 physicalPresence; |
| 156 | u8 physicalPresenceLock; |
| 157 | u8 bGlobalLock; |
| 158 | }__attribute__((packed)); |
| 159 | |
| 160 | struct tpm_version_t { |
| 161 | u8 Major; |
| 162 | u8 Minor; |
| 163 | u8 revMajor; |
| 164 | u8 revMinor; |
| 165 | }__attribute__((packed)); |
| 166 | |
| 167 | struct tpm_version_1_2_t { |
| 168 | __be16 tag; |
| 169 | u8 Major; |
| 170 | u8 Minor; |
| 171 | u8 revMajor; |
| 172 | u8 revMinor; |
| 173 | }__attribute__((packed)); |
| 174 | |
| 175 | struct timeout_t { |
| 176 | __be32 a; |
| 177 | __be32 b; |
| 178 | __be32 c; |
| 179 | __be32 d; |
| 180 | }__attribute__((packed)); |
| 181 | |
| 182 | struct duration_t { |
| 183 | __be32 tpm_short; |
| 184 | __be32 tpm_medium; |
| 185 | __be32 tpm_long; |
| 186 | }__attribute__((packed)); |
| 187 | |
| 188 | struct permanent_flags_t { |
| 189 | __be16 tag; |
| 190 | u8 disable; |
| 191 | u8 ownership; |
| 192 | u8 deactivated; |
| 193 | u8 readPubek; |
| 194 | u8 disableOwnerClear; |
| 195 | u8 allowMaintenance; |
| 196 | u8 physicalPresenceLifetimeLock; |
| 197 | u8 physicalPresenceHWEnable; |
| 198 | u8 physicalPresenceCMDEnable; |
| 199 | u8 CEKPUsed; |
| 200 | u8 TPMpost; |
| 201 | u8 TPMpostLock; |
| 202 | u8 FIPS; |
| 203 | u8 operator; |
| 204 | u8 enableRevokeEK; |
| 205 | u8 nvLocked; |
| 206 | u8 readSRKPub; |
| 207 | u8 tpmEstablished; |
| 208 | u8 maintenanceDone; |
| 209 | u8 disableFullDALogicInfo; |
| 210 | }__attribute__((packed)); |
| 211 | |
| 212 | typedef union { |
| 213 | struct permanent_flags_t perm_flags; |
| 214 | struct stclear_flags_t stclear_flags; |
| 215 | bool owned; |
| 216 | __be32 num_pcrs; |
| 217 | struct tpm_version_t tpm_version; |
| 218 | struct tpm_version_1_2_t tpm_version_1_2; |
| 219 | __be32 manufacturer_id; |
| 220 | struct timeout_t timeout; |
| 221 | struct duration_t duration; |
| 222 | } cap_t; |
| 223 | |
| 224 | struct tpm_getcap_params_in { |
| 225 | __be32 cap; |
| 226 | __be32 subcap_size; |
| 227 | __be32 subcap; |
| 228 | }__attribute__((packed)); |
| 229 | |
| 230 | struct tpm_getcap_params_out { |
| 231 | __be32 cap_size; |
| 232 | cap_t cap; |
| 233 | }__attribute__((packed)); |
| 234 | |
| 235 | struct tpm_readpubek_params_out { |
| 236 | u8 algorithm[4]; |
| 237 | u8 encscheme[2]; |
| 238 | u8 sigscheme[2]; |
Rajiv Andrade | 02a077c | 2010-06-14 13:58:22 -0300 | [diff] [blame] | 239 | __be32 paramsize; |
Rajiv Andrade | 0883743 | 2009-02-02 15:23:43 -0200 | [diff] [blame] | 240 | u8 parameters[12]; /*assuming RSA*/ |
| 241 | __be32 keysize; |
| 242 | u8 modulus[256]; |
| 243 | u8 checksum[20]; |
| 244 | }__attribute__((packed)); |
| 245 | |
| 246 | typedef union { |
| 247 | struct tpm_input_header in; |
| 248 | struct tpm_output_header out; |
| 249 | } tpm_cmd_header; |
| 250 | |
Rajiv Andrade | 659aaf2 | 2009-02-02 15:23:44 -0200 | [diff] [blame] | 251 | #define TPM_DIGEST_SIZE 20 |
| 252 | struct tpm_pcrread_out { |
| 253 | u8 pcr_result[TPM_DIGEST_SIZE]; |
| 254 | }__attribute__((packed)); |
| 255 | |
| 256 | struct tpm_pcrread_in { |
| 257 | __be32 pcr_idx; |
| 258 | }__attribute__((packed)); |
| 259 | |
| 260 | struct tpm_pcrextend_in { |
| 261 | __be32 pcr_idx; |
| 262 | u8 hash[TPM_DIGEST_SIZE]; |
| 263 | }__attribute__((packed)); |
| 264 | |
Rajiv Andrade | 0883743 | 2009-02-02 15:23:43 -0200 | [diff] [blame] | 265 | typedef union { |
| 266 | struct tpm_getcap_params_out getcap_out; |
| 267 | struct tpm_readpubek_params_out readpubek_out; |
| 268 | u8 readpubek_out_buffer[sizeof(struct tpm_readpubek_params_out)]; |
| 269 | struct tpm_getcap_params_in getcap_in; |
Rajiv Andrade | 659aaf2 | 2009-02-02 15:23:44 -0200 | [diff] [blame] | 270 | struct tpm_pcrread_in pcrread_in; |
| 271 | struct tpm_pcrread_out pcrread_out; |
| 272 | struct tpm_pcrextend_in pcrextend_in; |
Rajiv Andrade | 0883743 | 2009-02-02 15:23:43 -0200 | [diff] [blame] | 273 | } tpm_cmd_params; |
| 274 | |
| 275 | struct tpm_cmd_t { |
| 276 | tpm_cmd_header header; |
| 277 | tpm_cmd_params params; |
| 278 | }__attribute__((packed)); |
| 279 | |
| 280 | ssize_t tpm_getcap(struct device *, __be32, cap_t *, const char *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 281 | |
Kylene Jo Hall | 08e96e4 | 2006-04-22 02:37:50 -0700 | [diff] [blame] | 282 | extern void tpm_get_timeouts(struct tpm_chip *); |
| 283 | extern void tpm_gen_interrupt(struct tpm_chip *); |
| 284 | extern void tpm_continue_selftest(struct tpm_chip *); |
Kylene Jo Hall | 9e18ee1 | 2006-04-22 02:37:38 -0700 | [diff] [blame] | 285 | extern unsigned long tpm_calc_ordinal_duration(struct tpm_chip *, u32); |
Kylene Jo Hall | e0dd03c | 2006-04-22 02:37:26 -0700 | [diff] [blame] | 286 | extern struct tpm_chip* tpm_register_hardware(struct device *, |
| 287 | const struct tpm_vendor_specific *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 288 | extern int tpm_open(struct inode *, struct file *); |
| 289 | extern int tpm_release(struct inode *, struct file *); |
Rajiv Andrade | 253115b | 2008-10-11 09:04:39 +1100 | [diff] [blame] | 290 | extern void tpm_dev_vendor_release(struct tpm_chip *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | extern ssize_t tpm_write(struct file *, const char __user *, size_t, |
| 292 | loff_t *); |
| 293 | extern ssize_t tpm_read(struct file *, char __user *, size_t, loff_t *); |
Kylene Jo Hall | e659a3f | 2005-10-30 15:03:24 -0800 | [diff] [blame] | 294 | extern void tpm_remove_hardware(struct device *); |
Kylene Jo Hall | ce2c87d | 2005-10-30 15:03:25 -0800 | [diff] [blame] | 295 | extern int tpm_pm_suspend(struct device *, pm_message_t); |
| 296 | extern int tpm_pm_resume(struct device *); |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 297 | |
| 298 | #ifdef CONFIG_ACPI |
| 299 | extern struct dentry ** tpm_bios_log_setup(char *); |
| 300 | extern void tpm_bios_log_teardown(struct dentry **); |
| 301 | #else |
Daniel Walker | bb53a76 | 2006-05-15 09:44:27 -0700 | [diff] [blame] | 302 | static inline struct dentry ** tpm_bios_log_setup(char *name) |
Kylene Jo Hall | 55a82ab | 2006-01-08 01:03:15 -0800 | [diff] [blame] | 303 | { |
| 304 | return NULL; |
| 305 | } |
| 306 | static inline void tpm_bios_log_teardown(struct dentry **dir) |
| 307 | { |
| 308 | } |
| 309 | #endif |