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/platform_device.h> 27 #include <linux/io.h> 28 #include <linux/tpm.h> 29 #include <linux/acpi.h> 30 #include <linux/cdev.h> 31 32 enum tpm_const { 33 TPM_MINOR = 224, /* officially assigned */ 34 TPM_BUFSIZE = 4096, 35 TPM_NUM_DEVICES = 256, 36 TPM_RETRY = 50, /* 5 seconds */ 37 }; 38 39 enum tpm_timeout { 40 TPM_TIMEOUT = 5, /* msecs */ 41 TPM_TIMEOUT_RETRY = 100 /* msecs */ 42 }; 43 44 /* TPM addresses */ 45 enum tpm_addr { 46 TPM_SUPERIO_ADDR = 0x2E, 47 TPM_ADDR = 0x4E, 48 }; 49 50 /* Indexes the duration array */ 51 enum tpm_duration { 52 TPM_SHORT = 0, 53 TPM_MEDIUM = 1, 54 TPM_LONG = 2, 55 TPM_UNDEFINED, 56 }; 57 58 #define TPM_WARN_RETRY 0x800 59 #define TPM_WARN_DOING_SELFTEST 0x802 60 #define TPM_ERR_DEACTIVATED 0x6 61 #define TPM_ERR_DISABLED 0x7 62 #define TPM_ERR_INVALID_POSTINIT 38 63 64 #define TPM_HEADER_SIZE 10 65 66 enum tpm2_const { 67 TPM2_PLATFORM_PCR = 24, 68 TPM2_PCR_SELECT_MIN = ((TPM2_PLATFORM_PCR + 7) / 8), 69 TPM2_TIMEOUT_A = 750, 70 TPM2_TIMEOUT_B = 2000, 71 TPM2_TIMEOUT_C = 200, 72 TPM2_TIMEOUT_D = 30, 73 TPM2_DURATION_SHORT = 20, 74 TPM2_DURATION_MEDIUM = 750, 75 TPM2_DURATION_LONG = 2000, 76 }; 77 78 enum tpm2_structures { 79 TPM2_ST_NO_SESSIONS = 0x8001, 80 TPM2_ST_SESSIONS = 0x8002, 81 }; 82 83 enum tpm2_return_codes { 84 TPM2_RC_INITIALIZE = 0x0100, 85 TPM2_RC_TESTING = 0x090A, 86 TPM2_RC_DISABLED = 0x0120, 87 }; 88 89 enum tpm2_algorithms { 90 TPM2_ALG_SHA1 = 0x0004, 91 }; 92 93 enum tpm2_command_codes { 94 TPM2_CC_FIRST = 0x011F, 95 TPM2_CC_SELF_TEST = 0x0143, 96 TPM2_CC_STARTUP = 0x0144, 97 TPM2_CC_SHUTDOWN = 0x0145, 98 TPM2_CC_GET_CAPABILITY = 0x017A, 99 TPM2_CC_GET_RANDOM = 0x017B, 100 TPM2_CC_PCR_READ = 0x017E, 101 TPM2_CC_PCR_EXTEND = 0x0182, 102 TPM2_CC_LAST = 0x018F, 103 }; 104 105 enum tpm2_permanent_handles { 106 TPM2_RS_PW = 0x40000009, 107 }; 108 109 enum tpm2_capabilities { 110 TPM2_CAP_TPM_PROPERTIES = 6, 111 }; 112 113 enum tpm2_startup_types { 114 TPM2_SU_CLEAR = 0x0000, 115 TPM2_SU_STATE = 0x0001, 116 }; 117 118 struct tpm_chip; 119 120 struct tpm_vendor_specific { 121 void __iomem *iobase; /* ioremapped address */ 122 unsigned long base; /* TPM base address */ 123 124 int irq; 125 int probed_irq; 126 127 int region_size; 128 int have_region; 129 130 struct list_head list; 131 int locality; 132 unsigned long timeout_a, timeout_b, timeout_c, timeout_d; /* jiffies */ 133 bool timeout_adjusted; 134 unsigned long duration[3]; /* jiffies */ 135 bool duration_adjusted; 136 void *priv; 137 138 wait_queue_head_t read_queue; 139 wait_queue_head_t int_queue; 140 141 u16 manufacturer_id; 142 }; 143 144 #define TPM_VPRIV(c) ((c)->vendor.priv) 145 146 #define TPM_VID_INTEL 0x8086 147 #define TPM_VID_WINBOND 0x1050 148 #define TPM_VID_STM 0x104A 149 150 #define TPM_PPI_VERSION_LEN 3 151 152 enum tpm_chip_flags { 153 TPM_CHIP_FLAG_REGISTERED = BIT(0), 154 TPM_CHIP_FLAG_PPI = BIT(1), 155 TPM_CHIP_FLAG_TPM2 = BIT(2), 156 }; 157 158 struct tpm_chip { 159 struct device *pdev; /* Device stuff */ 160 struct device dev; 161 struct cdev cdev; 162 163 const struct tpm_class_ops *ops; 164 unsigned int flags; 165 166 int dev_num; /* /dev/tpm# */ 167 char devname[7]; 168 unsigned long is_open; /* only one allowed */ 169 int time_expired; 170 171 struct mutex tpm_mutex; /* tpm is processing */ 172 173 struct tpm_vendor_specific vendor; 174 175 struct dentry **bios_dir; 176 177 #ifdef CONFIG_ACPI 178 acpi_handle acpi_dev_handle; 179 char ppi_version[TPM_PPI_VERSION_LEN + 1]; 180 #endif /* CONFIG_ACPI */ 181 182 struct list_head list; 183 }; 184 185 #define to_tpm_chip(n) container_of(n, struct tpm_chip, vendor) 186 187 static inline void tpm_chip_put(struct tpm_chip *chip) 188 { 189 module_put(chip->pdev->driver->owner); 190 } 191 192 static inline int tpm_read_index(int base, int index) 193 { 194 outb(index, base); 195 return inb(base+1) & 0xFF; 196 } 197 198 static inline void tpm_write_index(int base, int index, int value) 199 { 200 outb(index, base); 201 outb(value & 0xFF, base+1); 202 } 203 struct tpm_input_header { 204 __be16 tag; 205 __be32 length; 206 __be32 ordinal; 207 } __packed; 208 209 struct tpm_output_header { 210 __be16 tag; 211 __be32 length; 212 __be32 return_code; 213 } __packed; 214 215 #define TPM_TAG_RQU_COMMAND cpu_to_be16(193) 216 217 struct stclear_flags_t { 218 __be16 tag; 219 u8 deactivated; 220 u8 disableForceClear; 221 u8 physicalPresence; 222 u8 physicalPresenceLock; 223 u8 bGlobalLock; 224 } __packed; 225 226 struct tpm_version_t { 227 u8 Major; 228 u8 Minor; 229 u8 revMajor; 230 u8 revMinor; 231 } __packed; 232 233 struct tpm_version_1_2_t { 234 __be16 tag; 235 u8 Major; 236 u8 Minor; 237 u8 revMajor; 238 u8 revMinor; 239 } __packed; 240 241 struct timeout_t { 242 __be32 a; 243 __be32 b; 244 __be32 c; 245 __be32 d; 246 } __packed; 247 248 struct duration_t { 249 __be32 tpm_short; 250 __be32 tpm_medium; 251 __be32 tpm_long; 252 } __packed; 253 254 struct permanent_flags_t { 255 __be16 tag; 256 u8 disable; 257 u8 ownership; 258 u8 deactivated; 259 u8 readPubek; 260 u8 disableOwnerClear; 261 u8 allowMaintenance; 262 u8 physicalPresenceLifetimeLock; 263 u8 physicalPresenceHWEnable; 264 u8 physicalPresenceCMDEnable; 265 u8 CEKPUsed; 266 u8 TPMpost; 267 u8 TPMpostLock; 268 u8 FIPS; 269 u8 operator; 270 u8 enableRevokeEK; 271 u8 nvLocked; 272 u8 readSRKPub; 273 u8 tpmEstablished; 274 u8 maintenanceDone; 275 u8 disableFullDALogicInfo; 276 } __packed; 277 278 typedef union { 279 struct permanent_flags_t perm_flags; 280 struct stclear_flags_t stclear_flags; 281 bool owned; 282 __be32 num_pcrs; 283 struct tpm_version_t tpm_version; 284 struct tpm_version_1_2_t tpm_version_1_2; 285 __be32 manufacturer_id; 286 struct timeout_t timeout; 287 struct duration_t duration; 288 } cap_t; 289 290 enum tpm_capabilities { 291 TPM_CAP_FLAG = cpu_to_be32(4), 292 TPM_CAP_PROP = cpu_to_be32(5), 293 CAP_VERSION_1_1 = cpu_to_be32(0x06), 294 CAP_VERSION_1_2 = cpu_to_be32(0x1A) 295 }; 296 297 enum tpm_sub_capabilities { 298 TPM_CAP_PROP_PCR = cpu_to_be32(0x101), 299 TPM_CAP_PROP_MANUFACTURER = cpu_to_be32(0x103), 300 TPM_CAP_FLAG_PERM = cpu_to_be32(0x108), 301 TPM_CAP_FLAG_VOL = cpu_to_be32(0x109), 302 TPM_CAP_PROP_OWNER = cpu_to_be32(0x111), 303 TPM_CAP_PROP_TIS_TIMEOUT = cpu_to_be32(0x115), 304 TPM_CAP_PROP_TIS_DURATION = cpu_to_be32(0x120), 305 306 }; 307 308 struct tpm_getcap_params_in { 309 __be32 cap; 310 __be32 subcap_size; 311 __be32 subcap; 312 } __packed; 313 314 struct tpm_getcap_params_out { 315 __be32 cap_size; 316 cap_t cap; 317 } __packed; 318 319 struct tpm_readpubek_params_out { 320 u8 algorithm[4]; 321 u8 encscheme[2]; 322 u8 sigscheme[2]; 323 __be32 paramsize; 324 u8 parameters[12]; /*assuming RSA*/ 325 __be32 keysize; 326 u8 modulus[256]; 327 u8 checksum[20]; 328 } __packed; 329 330 typedef union { 331 struct tpm_input_header in; 332 struct tpm_output_header out; 333 } tpm_cmd_header; 334 335 struct tpm_pcrread_out { 336 u8 pcr_result[TPM_DIGEST_SIZE]; 337 } __packed; 338 339 struct tpm_pcrread_in { 340 __be32 pcr_idx; 341 } __packed; 342 343 struct tpm_pcrextend_in { 344 __be32 pcr_idx; 345 u8 hash[TPM_DIGEST_SIZE]; 346 } __packed; 347 348 /* 128 bytes is an arbitrary cap. This could be as large as TPM_BUFSIZE - 18 349 * bytes, but 128 is still a relatively large number of random bytes and 350 * anything much bigger causes users of struct tpm_cmd_t to start getting 351 * compiler warnings about stack frame size. */ 352 #define TPM_MAX_RNG_DATA 128 353 354 struct tpm_getrandom_out { 355 __be32 rng_data_len; 356 u8 rng_data[TPM_MAX_RNG_DATA]; 357 } __packed; 358 359 struct tpm_getrandom_in { 360 __be32 num_bytes; 361 } __packed; 362 363 struct tpm_startup_in { 364 __be16 startup_type; 365 } __packed; 366 367 typedef union { 368 struct tpm_getcap_params_out getcap_out; 369 struct tpm_readpubek_params_out readpubek_out; 370 u8 readpubek_out_buffer[sizeof(struct tpm_readpubek_params_out)]; 371 struct tpm_getcap_params_in getcap_in; 372 struct tpm_pcrread_in pcrread_in; 373 struct tpm_pcrread_out pcrread_out; 374 struct tpm_pcrextend_in pcrextend_in; 375 struct tpm_getrandom_in getrandom_in; 376 struct tpm_getrandom_out getrandom_out; 377 struct tpm_startup_in startup_in; 378 } tpm_cmd_params; 379 380 struct tpm_cmd_t { 381 tpm_cmd_header header; 382 tpm_cmd_params params; 383 } __packed; 384 385 extern struct class *tpm_class; 386 extern dev_t tpm_devt; 387 extern const struct file_operations tpm_fops; 388 389 ssize_t tpm_getcap(struct device *, __be32, cap_t *, const char *); 390 ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf, 391 size_t bufsiz); 392 ssize_t tpm_transmit_cmd(struct tpm_chip *chip, void *cmd, int len, 393 const char *desc); 394 extern int tpm_get_timeouts(struct tpm_chip *); 395 extern void tpm_gen_interrupt(struct tpm_chip *); 396 extern int tpm_do_selftest(struct tpm_chip *); 397 extern unsigned long tpm_calc_ordinal_duration(struct tpm_chip *, u32); 398 extern int tpm_pm_suspend(struct device *); 399 extern int tpm_pm_resume(struct device *); 400 extern int wait_for_tpm_stat(struct tpm_chip *, u8, unsigned long, 401 wait_queue_head_t *, bool); 402 403 struct tpm_chip *tpm_chip_find_get(int chip_num); 404 extern struct tpm_chip *tpmm_chip_alloc(struct device *dev, 405 const struct tpm_class_ops *ops); 406 extern int tpm_chip_register(struct tpm_chip *chip); 407 extern void tpm_chip_unregister(struct tpm_chip *chip); 408 409 int tpm_sysfs_add_device(struct tpm_chip *chip); 410 void tpm_sysfs_del_device(struct tpm_chip *chip); 411 412 int tpm_pcr_read_dev(struct tpm_chip *chip, int pcr_idx, u8 *res_buf); 413 414 #ifdef CONFIG_ACPI 415 extern int tpm_add_ppi(struct tpm_chip *chip); 416 extern void tpm_remove_ppi(struct tpm_chip *chip); 417 #else 418 static inline int tpm_add_ppi(struct tpm_chip *chip) 419 { 420 return 0; 421 } 422 423 static inline void tpm_remove_ppi(struct tpm_chip *chip) 424 { 425 } 426 #endif 427 428 int tpm2_pcr_read(struct tpm_chip *chip, int pcr_idx, u8 *res_buf); 429 int tpm2_pcr_extend(struct tpm_chip *chip, int pcr_idx, const u8 *hash); 430 int tpm2_get_random(struct tpm_chip *chip, u8 *out, size_t max); 431 ssize_t tpm2_get_tpm_pt(struct tpm_chip *chip, u32 property_id, 432 u32 *value, const char *desc); 433 434 extern int tpm2_startup(struct tpm_chip *chip, u16 startup_type); 435 extern void tpm2_shutdown(struct tpm_chip *chip, u16 shutdown_type); 436 extern unsigned long tpm2_calc_ordinal_duration(struct tpm_chip *, u32); 437 extern int tpm2_do_selftest(struct tpm_chip *chip); 438 extern int tpm2_gen_interrupt(struct tpm_chip *chip); 439 extern int tpm2_probe(struct tpm_chip *chip); 440