1 /* 2 * Copyright (C) 2004 IBM Corporation 3 * Copyright (C) 2015 Intel Corporation 4 * 5 * Authors: 6 * Leendert van Doorn <leendert@watson.ibm.com> 7 * Dave Safford <safford@watson.ibm.com> 8 * Reiner Sailer <sailer@watson.ibm.com> 9 * Kylene Hall <kjhall@us.ibm.com> 10 * 11 * Maintained by: <tpmdd-devel@lists.sourceforge.net> 12 * 13 * Device driver for TCG/TCPA TPM (trusted platform module). 14 * Specifications at www.trustedcomputinggroup.org 15 * 16 * This program is free software; you can redistribute it and/or 17 * modify it under the terms of the GNU General Public License as 18 * published by the Free Software Foundation, version 2 of the 19 * License. 20 * 21 */ 22 23 #ifndef __TPM_H__ 24 #define __TPM_H__ 25 26 #include <linux/module.h> 27 #include <linux/delay.h> 28 #include <linux/fs.h> 29 #include <linux/mutex.h> 30 #include <linux/sched.h> 31 #include <linux/platform_device.h> 32 #include <linux/io.h> 33 #include <linux/tpm.h> 34 #include <linux/acpi.h> 35 #include <linux/cdev.h> 36 #include <linux/highmem.h> 37 #include <crypto/hash_info.h> 38 39 enum tpm_const { 40 TPM_MINOR = 224, /* officially assigned */ 41 TPM_BUFSIZE = 4096, 42 TPM_NUM_DEVICES = 65536, 43 TPM_RETRY = 50, /* 5 seconds */ 44 TPM_NUM_EVENT_LOG_FILES = 3, 45 }; 46 47 enum tpm_timeout { 48 TPM_TIMEOUT = 5, /* msecs */ 49 TPM_TIMEOUT_RETRY = 100 /* msecs */ 50 }; 51 52 /* TPM addresses */ 53 enum tpm_addr { 54 TPM_SUPERIO_ADDR = 0x2E, 55 TPM_ADDR = 0x4E, 56 }; 57 58 /* Indexes the duration array */ 59 enum tpm_duration { 60 TPM_SHORT = 0, 61 TPM_MEDIUM = 1, 62 TPM_LONG = 2, 63 TPM_UNDEFINED, 64 }; 65 66 #define TPM_WARN_RETRY 0x800 67 #define TPM_WARN_DOING_SELFTEST 0x802 68 #define TPM_ERR_DEACTIVATED 0x6 69 #define TPM_ERR_DISABLED 0x7 70 #define TPM_ERR_INVALID_POSTINIT 38 71 72 #define TPM_HEADER_SIZE 10 73 74 enum tpm2_const { 75 TPM2_PLATFORM_PCR = 24, 76 TPM2_PCR_SELECT_MIN = ((TPM2_PLATFORM_PCR + 7) / 8), 77 TPM2_TIMEOUT_A = 750, 78 TPM2_TIMEOUT_B = 2000, 79 TPM2_TIMEOUT_C = 200, 80 TPM2_TIMEOUT_D = 30, 81 TPM2_DURATION_SHORT = 20, 82 TPM2_DURATION_MEDIUM = 750, 83 TPM2_DURATION_LONG = 2000, 84 }; 85 86 enum tpm2_structures { 87 TPM2_ST_NO_SESSIONS = 0x8001, 88 TPM2_ST_SESSIONS = 0x8002, 89 }; 90 91 enum tpm2_return_codes { 92 TPM2_RC_HASH = 0x0083, /* RC_FMT1 */ 93 TPM2_RC_INITIALIZE = 0x0100, /* RC_VER1 */ 94 TPM2_RC_DISABLED = 0x0120, 95 TPM2_RC_TESTING = 0x090A, /* RC_WARN */ 96 }; 97 98 enum tpm2_algorithms { 99 TPM2_ALG_ERROR = 0x0000, 100 TPM2_ALG_SHA1 = 0x0004, 101 TPM2_ALG_KEYEDHASH = 0x0008, 102 TPM2_ALG_SHA256 = 0x000B, 103 TPM2_ALG_SHA384 = 0x000C, 104 TPM2_ALG_SHA512 = 0x000D, 105 TPM2_ALG_NULL = 0x0010, 106 TPM2_ALG_SM3_256 = 0x0012, 107 }; 108 109 enum tpm2_command_codes { 110 TPM2_CC_FIRST = 0x011F, 111 TPM2_CC_SELF_TEST = 0x0143, 112 TPM2_CC_STARTUP = 0x0144, 113 TPM2_CC_SHUTDOWN = 0x0145, 114 TPM2_CC_CREATE = 0x0153, 115 TPM2_CC_LOAD = 0x0157, 116 TPM2_CC_UNSEAL = 0x015E, 117 TPM2_CC_FLUSH_CONTEXT = 0x0165, 118 TPM2_CC_GET_CAPABILITY = 0x017A, 119 TPM2_CC_GET_RANDOM = 0x017B, 120 TPM2_CC_PCR_READ = 0x017E, 121 TPM2_CC_PCR_EXTEND = 0x0182, 122 TPM2_CC_LAST = 0x018F, 123 }; 124 125 enum tpm2_permanent_handles { 126 TPM2_RS_PW = 0x40000009, 127 }; 128 129 enum tpm2_capabilities { 130 TPM2_CAP_PCRS = 5, 131 TPM2_CAP_TPM_PROPERTIES = 6, 132 }; 133 134 enum tpm2_startup_types { 135 TPM2_SU_CLEAR = 0x0000, 136 TPM2_SU_STATE = 0x0001, 137 }; 138 139 #define TPM_VID_INTEL 0x8086 140 #define TPM_VID_WINBOND 0x1050 141 #define TPM_VID_STM 0x104A 142 143 #define TPM_PPI_VERSION_LEN 3 144 145 enum tpm_chip_flags { 146 TPM_CHIP_FLAG_TPM2 = BIT(1), 147 TPM_CHIP_FLAG_IRQ = BIT(2), 148 TPM_CHIP_FLAG_VIRTUAL = BIT(3), 149 TPM_CHIP_FLAG_HAVE_TIMEOUTS = BIT(4), 150 }; 151 152 struct tpm_bios_log { 153 void *bios_event_log; 154 void *bios_event_log_end; 155 }; 156 157 struct tpm_chip_seqops { 158 struct tpm_chip *chip; 159 const struct seq_operations *seqops; 160 }; 161 162 struct tpm_chip { 163 struct device dev; 164 struct cdev cdev; 165 166 /* A driver callback under ops cannot be run unless ops_sem is held 167 * (sometimes implicitly, eg for the sysfs code). ops becomes null 168 * when the driver is unregistered, see tpm_try_get_ops. 169 */ 170 struct rw_semaphore ops_sem; 171 const struct tpm_class_ops *ops; 172 173 struct tpm_bios_log log; 174 struct tpm_chip_seqops bin_log_seqops; 175 struct tpm_chip_seqops ascii_log_seqops; 176 177 unsigned int flags; 178 179 int dev_num; /* /dev/tpm# */ 180 unsigned long is_open; /* only one allowed */ 181 182 struct mutex tpm_mutex; /* tpm is processing */ 183 184 unsigned long timeout_a; /* jiffies */ 185 unsigned long timeout_b; /* jiffies */ 186 unsigned long timeout_c; /* jiffies */ 187 unsigned long timeout_d; /* jiffies */ 188 bool timeout_adjusted; 189 unsigned long duration[3]; /* jiffies */ 190 bool duration_adjusted; 191 192 struct dentry *bios_dir[TPM_NUM_EVENT_LOG_FILES]; 193 194 const struct attribute_group *groups[3]; 195 unsigned int groups_cnt; 196 197 u16 active_banks[7]; 198 #ifdef CONFIG_ACPI 199 acpi_handle acpi_dev_handle; 200 char ppi_version[TPM_PPI_VERSION_LEN + 1]; 201 #endif /* CONFIG_ACPI */ 202 }; 203 204 #define to_tpm_chip(d) container_of(d, struct tpm_chip, dev) 205 206 struct tpm_input_header { 207 __be16 tag; 208 __be32 length; 209 __be32 ordinal; 210 } __packed; 211 212 struct tpm_output_header { 213 __be16 tag; 214 __be32 length; 215 __be32 return_code; 216 } __packed; 217 218 #define TPM_TAG_RQU_COMMAND cpu_to_be16(193) 219 220 struct stclear_flags_t { 221 __be16 tag; 222 u8 deactivated; 223 u8 disableForceClear; 224 u8 physicalPresence; 225 u8 physicalPresenceLock; 226 u8 bGlobalLock; 227 } __packed; 228 229 struct tpm_version_t { 230 u8 Major; 231 u8 Minor; 232 u8 revMajor; 233 u8 revMinor; 234 } __packed; 235 236 struct tpm_version_1_2_t { 237 __be16 tag; 238 u8 Major; 239 u8 Minor; 240 u8 revMajor; 241 u8 revMinor; 242 } __packed; 243 244 struct timeout_t { 245 __be32 a; 246 __be32 b; 247 __be32 c; 248 __be32 d; 249 } __packed; 250 251 struct duration_t { 252 __be32 tpm_short; 253 __be32 tpm_medium; 254 __be32 tpm_long; 255 } __packed; 256 257 struct permanent_flags_t { 258 __be16 tag; 259 u8 disable; 260 u8 ownership; 261 u8 deactivated; 262 u8 readPubek; 263 u8 disableOwnerClear; 264 u8 allowMaintenance; 265 u8 physicalPresenceLifetimeLock; 266 u8 physicalPresenceHWEnable; 267 u8 physicalPresenceCMDEnable; 268 u8 CEKPUsed; 269 u8 TPMpost; 270 u8 TPMpostLock; 271 u8 FIPS; 272 u8 operator; 273 u8 enableRevokeEK; 274 u8 nvLocked; 275 u8 readSRKPub; 276 u8 tpmEstablished; 277 u8 maintenanceDone; 278 u8 disableFullDALogicInfo; 279 } __packed; 280 281 typedef union { 282 struct permanent_flags_t perm_flags; 283 struct stclear_flags_t stclear_flags; 284 __u8 owned; 285 __be32 num_pcrs; 286 struct tpm_version_t tpm_version; 287 struct tpm_version_1_2_t tpm_version_1_2; 288 __be32 manufacturer_id; 289 struct timeout_t timeout; 290 struct duration_t duration; 291 } cap_t; 292 293 enum tpm_capabilities { 294 TPM_CAP_FLAG = 4, 295 TPM_CAP_PROP = 5, 296 TPM_CAP_VERSION_1_1 = 0x06, 297 TPM_CAP_VERSION_1_2 = 0x1A, 298 }; 299 300 enum tpm_sub_capabilities { 301 TPM_CAP_PROP_PCR = 0x101, 302 TPM_CAP_PROP_MANUFACTURER = 0x103, 303 TPM_CAP_FLAG_PERM = 0x108, 304 TPM_CAP_FLAG_VOL = 0x109, 305 TPM_CAP_PROP_OWNER = 0x111, 306 TPM_CAP_PROP_TIS_TIMEOUT = 0x115, 307 TPM_CAP_PROP_TIS_DURATION = 0x120, 308 }; 309 310 struct tpm_getcap_params_in { 311 __be32 cap; 312 __be32 subcap_size; 313 __be32 subcap; 314 } __packed; 315 316 struct tpm_getcap_params_out { 317 __be32 cap_size; 318 cap_t cap; 319 } __packed; 320 321 struct tpm_readpubek_params_out { 322 u8 algorithm[4]; 323 u8 encscheme[2]; 324 u8 sigscheme[2]; 325 __be32 paramsize; 326 u8 parameters[12]; /*assuming RSA*/ 327 __be32 keysize; 328 u8 modulus[256]; 329 u8 checksum[20]; 330 } __packed; 331 332 typedef union { 333 struct tpm_input_header in; 334 struct tpm_output_header out; 335 } tpm_cmd_header; 336 337 struct tpm_pcrread_out { 338 u8 pcr_result[TPM_DIGEST_SIZE]; 339 } __packed; 340 341 struct tpm_pcrread_in { 342 __be32 pcr_idx; 343 } __packed; 344 345 struct tpm_pcrextend_in { 346 __be32 pcr_idx; 347 u8 hash[TPM_DIGEST_SIZE]; 348 } __packed; 349 350 /* 128 bytes is an arbitrary cap. This could be as large as TPM_BUFSIZE - 18 351 * bytes, but 128 is still a relatively large number of random bytes and 352 * anything much bigger causes users of struct tpm_cmd_t to start getting 353 * compiler warnings about stack frame size. */ 354 #define TPM_MAX_RNG_DATA 128 355 356 struct tpm_getrandom_out { 357 __be32 rng_data_len; 358 u8 rng_data[TPM_MAX_RNG_DATA]; 359 } __packed; 360 361 struct tpm_getrandom_in { 362 __be32 num_bytes; 363 } __packed; 364 365 struct tpm_startup_in { 366 __be16 startup_type; 367 } __packed; 368 369 typedef union { 370 struct tpm_getcap_params_out getcap_out; 371 struct tpm_readpubek_params_out readpubek_out; 372 u8 readpubek_out_buffer[sizeof(struct tpm_readpubek_params_out)]; 373 struct tpm_getcap_params_in getcap_in; 374 struct tpm_pcrread_in pcrread_in; 375 struct tpm_pcrread_out pcrread_out; 376 struct tpm_pcrextend_in pcrextend_in; 377 struct tpm_getrandom_in getrandom_in; 378 struct tpm_getrandom_out getrandom_out; 379 struct tpm_startup_in startup_in; 380 } tpm_cmd_params; 381 382 struct tpm_cmd_t { 383 tpm_cmd_header header; 384 tpm_cmd_params params; 385 } __packed; 386 387 struct tpm2_digest { 388 u16 alg_id; 389 u8 digest[SHA512_DIGEST_SIZE]; 390 } __packed; 391 392 /* A string buffer type for constructing TPM commands. This is based on the 393 * ideas of string buffer code in security/keys/trusted.h but is heap based 394 * in order to keep the stack usage minimal. 395 */ 396 397 enum tpm_buf_flags { 398 TPM_BUF_OVERFLOW = BIT(0), 399 }; 400 401 struct tpm_buf { 402 struct page *data_page; 403 unsigned int flags; 404 u8 *data; 405 }; 406 407 static inline int tpm_buf_init(struct tpm_buf *buf, u16 tag, u32 ordinal) 408 { 409 struct tpm_input_header *head; 410 411 buf->data_page = alloc_page(GFP_HIGHUSER); 412 if (!buf->data_page) 413 return -ENOMEM; 414 415 buf->flags = 0; 416 buf->data = kmap(buf->data_page); 417 418 head = (struct tpm_input_header *) buf->data; 419 420 head->tag = cpu_to_be16(tag); 421 head->length = cpu_to_be32(sizeof(*head)); 422 head->ordinal = cpu_to_be32(ordinal); 423 424 return 0; 425 } 426 427 static inline void tpm_buf_destroy(struct tpm_buf *buf) 428 { 429 kunmap(buf->data_page); 430 __free_page(buf->data_page); 431 } 432 433 static inline u32 tpm_buf_length(struct tpm_buf *buf) 434 { 435 struct tpm_input_header *head = (struct tpm_input_header *) buf->data; 436 437 return be32_to_cpu(head->length); 438 } 439 440 static inline u16 tpm_buf_tag(struct tpm_buf *buf) 441 { 442 struct tpm_input_header *head = (struct tpm_input_header *) buf->data; 443 444 return be16_to_cpu(head->tag); 445 } 446 447 static inline void tpm_buf_append(struct tpm_buf *buf, 448 const unsigned char *new_data, 449 unsigned int new_len) 450 { 451 struct tpm_input_header *head = (struct tpm_input_header *) buf->data; 452 u32 len = tpm_buf_length(buf); 453 454 /* Return silently if overflow has already happened. */ 455 if (buf->flags & TPM_BUF_OVERFLOW) 456 return; 457 458 if ((len + new_len) > PAGE_SIZE) { 459 WARN(1, "tpm_buf: overflow\n"); 460 buf->flags |= TPM_BUF_OVERFLOW; 461 return; 462 } 463 464 memcpy(&buf->data[len], new_data, new_len); 465 head->length = cpu_to_be32(len + new_len); 466 } 467 468 static inline void tpm_buf_append_u8(struct tpm_buf *buf, const u8 value) 469 { 470 tpm_buf_append(buf, &value, 1); 471 } 472 473 static inline void tpm_buf_append_u16(struct tpm_buf *buf, const u16 value) 474 { 475 __be16 value2 = cpu_to_be16(value); 476 477 tpm_buf_append(buf, (u8 *) &value2, 2); 478 } 479 480 static inline void tpm_buf_append_u32(struct tpm_buf *buf, const u32 value) 481 { 482 __be32 value2 = cpu_to_be32(value); 483 484 tpm_buf_append(buf, (u8 *) &value2, 4); 485 } 486 487 extern struct class *tpm_class; 488 extern dev_t tpm_devt; 489 extern const struct file_operations tpm_fops; 490 extern struct idr dev_nums_idr; 491 492 enum tpm_transmit_flags { 493 TPM_TRANSMIT_UNLOCKED = BIT(0), 494 }; 495 496 ssize_t tpm_transmit(struct tpm_chip *chip, const u8 *buf, size_t bufsiz, 497 unsigned int flags); 498 ssize_t tpm_transmit_cmd(struct tpm_chip *chip, const void *buf, size_t bufsiz, 499 size_t min_rsp_body_len, unsigned int flags, 500 const char *desc); 501 ssize_t tpm_getcap(struct tpm_chip *chip, u32 subcap_id, cap_t *cap, 502 const char *desc, size_t min_cap_length); 503 int tpm_get_timeouts(struct tpm_chip *); 504 int tpm1_auto_startup(struct tpm_chip *chip); 505 int tpm_do_selftest(struct tpm_chip *chip); 506 unsigned long tpm_calc_ordinal_duration(struct tpm_chip *chip, u32 ordinal); 507 int tpm_pm_suspend(struct device *dev); 508 int tpm_pm_resume(struct device *dev); 509 int wait_for_tpm_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout, 510 wait_queue_head_t *queue, bool check_cancel); 511 512 struct tpm_chip *tpm_chip_find_get(int chip_num); 513 __must_check int tpm_try_get_ops(struct tpm_chip *chip); 514 void tpm_put_ops(struct tpm_chip *chip); 515 516 struct tpm_chip *tpm_chip_alloc(struct device *dev, 517 const struct tpm_class_ops *ops); 518 struct tpm_chip *tpmm_chip_alloc(struct device *pdev, 519 const struct tpm_class_ops *ops); 520 int tpm_chip_register(struct tpm_chip *chip); 521 void tpm_chip_unregister(struct tpm_chip *chip); 522 523 void tpm_sysfs_add_device(struct tpm_chip *chip); 524 525 int tpm_pcr_read_dev(struct tpm_chip *chip, int pcr_idx, u8 *res_buf); 526 527 #ifdef CONFIG_ACPI 528 extern void tpm_add_ppi(struct tpm_chip *chip); 529 #else 530 static inline void tpm_add_ppi(struct tpm_chip *chip) 531 { 532 } 533 #endif 534 535 static inline inline u32 tpm2_rc_value(u32 rc) 536 { 537 return (rc & BIT(7)) ? rc & 0xff : rc; 538 } 539 540 int tpm2_pcr_read(struct tpm_chip *chip, int pcr_idx, u8 *res_buf); 541 int tpm2_pcr_extend(struct tpm_chip *chip, int pcr_idx, u32 count, 542 struct tpm2_digest *digests); 543 int tpm2_get_random(struct tpm_chip *chip, u8 *out, size_t max); 544 int tpm2_seal_trusted(struct tpm_chip *chip, 545 struct trusted_key_payload *payload, 546 struct trusted_key_options *options); 547 int tpm2_unseal_trusted(struct tpm_chip *chip, 548 struct trusted_key_payload *payload, 549 struct trusted_key_options *options); 550 ssize_t tpm2_get_tpm_pt(struct tpm_chip *chip, u32 property_id, 551 u32 *value, const char *desc); 552 553 int tpm2_auto_startup(struct tpm_chip *chip); 554 void tpm2_shutdown(struct tpm_chip *chip, u16 shutdown_type); 555 unsigned long tpm2_calc_ordinal_duration(struct tpm_chip *chip, u32 ordinal); 556 int tpm2_probe(struct tpm_chip *chip); 557 #endif 558