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 * 10 * Maintained by: <tpmdd-devel@lists.sourceforge.net> 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> 22 #include <linux/delay.h> 23 #include <linux/fs.h> 24 #include <linux/mutex.h> 25 #include <linux/sched.h> 26 #include <linux/miscdevice.h> 27 #include <linux/platform_device.h> 28 #include <linux/io.h> 29 #include <linux/tpm.h> 30 31 enum tpm_const { 32 TPM_MINOR = 224, /* officially assigned */ 33 TPM_BUFSIZE = 4096, 34 TPM_NUM_DEVICES = 256, 35 TPM_RETRY = 50, /* 5 seconds */ 36 }; 37 38 enum tpm_timeout { 39 TPM_TIMEOUT = 5, /* msecs */ 40 TPM_TIMEOUT_RETRY = 100 /* msecs */ 41 }; 42 43 /* TPM addresses */ 44 enum tpm_addr { 45 TPM_SUPERIO_ADDR = 0x2E, 46 TPM_ADDR = 0x4E, 47 }; 48 49 #define TPM_WARN_RETRY 0x800 50 #define TPM_WARN_DOING_SELFTEST 0x802 51 #define TPM_ERR_DEACTIVATED 0x6 52 #define TPM_ERR_DISABLED 0x7 53 #define TPM_ERR_INVALID_POSTINIT 38 54 55 #define TPM_HEADER_SIZE 10 56 extern ssize_t tpm_show_pubek(struct device *, struct device_attribute *attr, 57 char *); 58 extern ssize_t tpm_show_pcrs(struct device *, struct device_attribute *attr, 59 char *); 60 extern ssize_t tpm_show_caps(struct device *, struct device_attribute *attr, 61 char *); 62 extern ssize_t tpm_show_caps_1_2(struct device *, struct device_attribute *attr, 63 char *); 64 extern ssize_t tpm_store_cancel(struct device *, struct device_attribute *attr, 65 const char *, size_t); 66 extern ssize_t tpm_show_enabled(struct device *, struct device_attribute *attr, 67 char *); 68 extern ssize_t tpm_show_active(struct device *, struct device_attribute *attr, 69 char *); 70 extern ssize_t tpm_show_owned(struct device *, struct device_attribute *attr, 71 char *); 72 extern ssize_t tpm_show_temp_deactivated(struct device *, 73 struct device_attribute *attr, char *); 74 extern ssize_t tpm_show_durations(struct device *, 75 struct device_attribute *attr, char *); 76 extern ssize_t tpm_show_timeouts(struct device *, 77 struct device_attribute *attr, char *); 78 79 struct tpm_chip; 80 81 struct tpm_vendor_specific { 82 const u8 req_complete_mask; 83 const u8 req_complete_val; 84 bool (*req_canceled)(struct tpm_chip *chip, u8 status); 85 void __iomem *iobase; /* ioremapped address */ 86 unsigned long base; /* TPM base address */ 87 88 int irq; 89 int probed_irq; 90 91 int region_size; 92 int have_region; 93 94 int (*recv) (struct tpm_chip *, u8 *, size_t); 95 int (*send) (struct tpm_chip *, u8 *, size_t); 96 void (*cancel) (struct tpm_chip *); 97 u8 (*status) (struct tpm_chip *); 98 void (*release) (struct device *); 99 struct miscdevice miscdev; 100 struct attribute_group *attr_group; 101 struct list_head list; 102 int locality; 103 unsigned long timeout_a, timeout_b, timeout_c, timeout_d; /* jiffies */ 104 bool timeout_adjusted; 105 unsigned long duration[3]; /* jiffies */ 106 bool duration_adjusted; 107 void *priv; 108 109 wait_queue_head_t read_queue; 110 wait_queue_head_t int_queue; 111 112 u16 manufacturer_id; 113 }; 114 115 #define TPM_VPRIV(c) (c)->vendor.priv 116 117 #define TPM_VID_INTEL 0x8086 118 #define TPM_VID_WINBOND 0x1050 119 #define TPM_VID_STM 0x104A 120 121 struct tpm_chip { 122 struct device *dev; /* Device stuff */ 123 124 int dev_num; /* /dev/tpm# */ 125 unsigned long is_open; /* only one allowed */ 126 int time_expired; 127 128 /* Data passed to and from the tpm via the read/write calls */ 129 u8 *data_buffer; 130 atomic_t data_pending; 131 struct mutex buffer_mutex; 132 133 struct timer_list user_read_timer; /* user needs to claim result */ 134 struct work_struct work; 135 struct mutex tpm_mutex; /* tpm is processing */ 136 137 struct tpm_vendor_specific vendor; 138 139 struct dentry **bios_dir; 140 141 struct list_head list; 142 void (*release) (struct device *); 143 }; 144 145 #define to_tpm_chip(n) container_of(n, struct tpm_chip, vendor) 146 147 static inline void tpm_chip_put(struct tpm_chip *chip) 148 { 149 module_put(chip->dev->driver->owner); 150 } 151 152 static inline int tpm_read_index(int base, int index) 153 { 154 outb(index, base); 155 return inb(base+1) & 0xFF; 156 } 157 158 static inline void tpm_write_index(int base, int index, int value) 159 { 160 outb(index, base); 161 outb(value & 0xFF, base+1); 162 } 163 struct tpm_input_header { 164 __be16 tag; 165 __be32 length; 166 __be32 ordinal; 167 } __packed; 168 169 struct tpm_output_header { 170 __be16 tag; 171 __be32 length; 172 __be32 return_code; 173 } __packed; 174 175 struct stclear_flags_t { 176 __be16 tag; 177 u8 deactivated; 178 u8 disableForceClear; 179 u8 physicalPresence; 180 u8 physicalPresenceLock; 181 u8 bGlobalLock; 182 } __packed; 183 184 struct tpm_version_t { 185 u8 Major; 186 u8 Minor; 187 u8 revMajor; 188 u8 revMinor; 189 } __packed; 190 191 struct tpm_version_1_2_t { 192 __be16 tag; 193 u8 Major; 194 u8 Minor; 195 u8 revMajor; 196 u8 revMinor; 197 } __packed; 198 199 struct timeout_t { 200 __be32 a; 201 __be32 b; 202 __be32 c; 203 __be32 d; 204 } __packed; 205 206 struct duration_t { 207 __be32 tpm_short; 208 __be32 tpm_medium; 209 __be32 tpm_long; 210 } __packed; 211 212 struct permanent_flags_t { 213 __be16 tag; 214 u8 disable; 215 u8 ownership; 216 u8 deactivated; 217 u8 readPubek; 218 u8 disableOwnerClear; 219 u8 allowMaintenance; 220 u8 physicalPresenceLifetimeLock; 221 u8 physicalPresenceHWEnable; 222 u8 physicalPresenceCMDEnable; 223 u8 CEKPUsed; 224 u8 TPMpost; 225 u8 TPMpostLock; 226 u8 FIPS; 227 u8 operator; 228 u8 enableRevokeEK; 229 u8 nvLocked; 230 u8 readSRKPub; 231 u8 tpmEstablished; 232 u8 maintenanceDone; 233 u8 disableFullDALogicInfo; 234 } __packed; 235 236 typedef union { 237 struct permanent_flags_t perm_flags; 238 struct stclear_flags_t stclear_flags; 239 bool owned; 240 __be32 num_pcrs; 241 struct tpm_version_t tpm_version; 242 struct tpm_version_1_2_t tpm_version_1_2; 243 __be32 manufacturer_id; 244 struct timeout_t timeout; 245 struct duration_t duration; 246 } cap_t; 247 248 struct tpm_getcap_params_in { 249 __be32 cap; 250 __be32 subcap_size; 251 __be32 subcap; 252 } __packed; 253 254 struct tpm_getcap_params_out { 255 __be32 cap_size; 256 cap_t cap; 257 } __packed; 258 259 struct tpm_readpubek_params_out { 260 u8 algorithm[4]; 261 u8 encscheme[2]; 262 u8 sigscheme[2]; 263 __be32 paramsize; 264 u8 parameters[12]; /*assuming RSA*/ 265 __be32 keysize; 266 u8 modulus[256]; 267 u8 checksum[20]; 268 } __packed; 269 270 typedef union { 271 struct tpm_input_header in; 272 struct tpm_output_header out; 273 } tpm_cmd_header; 274 275 struct tpm_pcrread_out { 276 u8 pcr_result[TPM_DIGEST_SIZE]; 277 } __packed; 278 279 struct tpm_pcrread_in { 280 __be32 pcr_idx; 281 } __packed; 282 283 struct tpm_pcrextend_in { 284 __be32 pcr_idx; 285 u8 hash[TPM_DIGEST_SIZE]; 286 } __packed; 287 288 /* 128 bytes is an arbitrary cap. This could be as large as TPM_BUFSIZE - 18 289 * bytes, but 128 is still a relatively large number of random bytes and 290 * anything much bigger causes users of struct tpm_cmd_t to start getting 291 * compiler warnings about stack frame size. */ 292 #define TPM_MAX_RNG_DATA 128 293 294 struct tpm_getrandom_out { 295 __be32 rng_data_len; 296 u8 rng_data[TPM_MAX_RNG_DATA]; 297 } __packed; 298 299 struct tpm_getrandom_in { 300 __be32 num_bytes; 301 } __packed; 302 303 struct tpm_startup_in { 304 __be16 startup_type; 305 } __packed; 306 307 typedef union { 308 struct tpm_getcap_params_out getcap_out; 309 struct tpm_readpubek_params_out readpubek_out; 310 u8 readpubek_out_buffer[sizeof(struct tpm_readpubek_params_out)]; 311 struct tpm_getcap_params_in getcap_in; 312 struct tpm_pcrread_in pcrread_in; 313 struct tpm_pcrread_out pcrread_out; 314 struct tpm_pcrextend_in pcrextend_in; 315 struct tpm_getrandom_in getrandom_in; 316 struct tpm_getrandom_out getrandom_out; 317 struct tpm_startup_in startup_in; 318 } tpm_cmd_params; 319 320 struct tpm_cmd_t { 321 tpm_cmd_header header; 322 tpm_cmd_params params; 323 } __packed; 324 325 ssize_t tpm_getcap(struct device *, __be32, cap_t *, const char *); 326 327 extern int tpm_get_timeouts(struct tpm_chip *); 328 extern void tpm_gen_interrupt(struct tpm_chip *); 329 extern int tpm_do_selftest(struct tpm_chip *); 330 extern unsigned long tpm_calc_ordinal_duration(struct tpm_chip *, u32); 331 extern struct tpm_chip* tpm_register_hardware(struct device *, 332 const struct tpm_vendor_specific *); 333 extern int tpm_open(struct inode *, struct file *); 334 extern int tpm_release(struct inode *, struct file *); 335 extern void tpm_dev_release(struct device *dev); 336 extern void tpm_dev_vendor_release(struct tpm_chip *); 337 extern ssize_t tpm_write(struct file *, const char __user *, size_t, 338 loff_t *); 339 extern ssize_t tpm_read(struct file *, char __user *, size_t, loff_t *); 340 extern void tpm_remove_hardware(struct device *); 341 extern int tpm_pm_suspend(struct device *); 342 extern int tpm_pm_resume(struct device *); 343 extern int wait_for_tpm_stat(struct tpm_chip *, u8, unsigned long, 344 wait_queue_head_t *, bool); 345 346 #ifdef CONFIG_ACPI 347 extern int tpm_add_ppi(struct kobject *); 348 extern void tpm_remove_ppi(struct kobject *); 349 #else 350 static inline int tpm_add_ppi(struct kobject *parent) 351 { 352 return 0; 353 } 354 355 static inline void tpm_remove_ppi(struct kobject *parent) 356 { 357 } 358 #endif 359