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