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