drivers/char/tpm/tpm.c

   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  * Note, the TPM chip is not interrupt driven (only polling)
  21  * and can have very long timeouts (minutes!). Hence the unusual
  22  * calls to msleep.
  23  *
  24  */
  25
  26 #include <linux/sched.h>
  27 #include <linux/poll.h>
  28 #include <linux/spinlock.h>
  29 #include "tpm.h"
  30
  31 enum tpm_const {
  32         TPM_MINOR = 224,        /* officially assigned */
  33         TPM_BUFSIZE = 2048,
  34         TPM_NUM_DEVICES = 256,
  35         TPM_NUM_MASK_ENTRIES = TPM_NUM_DEVICES / (8 * sizeof(int))
  36 };
  37
  38   /* PCI configuration addresses */
  39 enum tpm_pci_config_addr {
  40         PCI_GEN_PMCON_1 = 0xA0,
  41         PCI_GEN1_DEC = 0xE4,
  42         PCI_LPC_EN = 0xE6,
  43         PCI_GEN2_DEC = 0xEC
  44 };
  45
  46 enum tpm_config {
  47         TPM_LOCK_REG = 0x0D,
  48         TPM_INTERUPT_REG = 0x0A,
  49         TPM_BASE_ADDR_LO = 0x08,
  50         TPM_BASE_ADDR_HI = 0x09,
  51         TPM_UNLOCK_VALUE = 0x55,
  52         TPM_LOCK_VALUE = 0xAA,
  53         TPM_DISABLE_INTERUPT_VALUE = 0x00
  54 };
  55
  56
  57 static LIST_HEAD(tpm_chip_list);
  58 static DEFINE_SPINLOCK(driver_lock);
  59 static int dev_mask[TPM_NUM_MASK_ENTRIES];
  60
  61 static void user_reader_timeout(unsigned long ptr)
  62 {
  63         struct tpm_chip *chip = (struct tpm_chip *) ptr;
  64
  65         down(&chip->buffer_mutex);
  66         atomic_set(&chip->data_pending, 0);
  67         memset(chip->data_buffer, 0, TPM_BUFSIZE);
  68         up(&chip->buffer_mutex);
  69 }
  70
  71 /*
  72  * Initialize the LPC bus and enable the TPM ports
  73  */
  74 int tpm_lpc_bus_init(struct pci_dev *pci_dev, u16 base)
  75 {
  76         u32 lpcenable, tmp;
  77         int is_lpcm = 0;
  78
  79         switch (pci_dev->vendor) {
  80         case PCI_VENDOR_ID_INTEL:
  81                 switch (pci_dev->device) {
  82                 case PCI_DEVICE_ID_INTEL_82801CA_12:
  83                 case PCI_DEVICE_ID_INTEL_82801DB_12:
  84                         is_lpcm = 1;
  85                         break;
  86                 }
  87                 /* init ICH (enable LPC) */
  88                 pci_read_config_dword(pci_dev, PCI_GEN1_DEC, &lpcenable);
  89                 lpcenable |= 0x20000000;
  90                 pci_write_config_dword(pci_dev, PCI_GEN1_DEC, lpcenable);
  91
  92                 if (is_lpcm) {
  93                         pci_read_config_dword(pci_dev, PCI_GEN1_DEC,
  94                                               &lpcenable);
  95                         if ((lpcenable & 0x20000000) == 0) {
  96                                 dev_err(&pci_dev->dev,
  97                                         "cannot enable LPC\n");
  98                                 return -ENODEV;
  99                         }
 100                 }
 101
 102                 /* initialize TPM registers */
 103                 pci_read_config_dword(pci_dev, PCI_GEN2_DEC, &tmp);
 104
 105                 if (!is_lpcm)
 106                         tmp = (tmp & 0xFFFF0000) | (base & 0xFFF0);
 107                 else
 108                         tmp =
 109                             (tmp & 0xFFFF0000) | (base & 0xFFF0) |
 110                             0x00000001;
 111
 112                 pci_write_config_dword(pci_dev, PCI_GEN2_DEC, tmp);
 113
 114                 if (is_lpcm) {
 115                         pci_read_config_dword(pci_dev, PCI_GEN_PMCON_1,
 116                                               &tmp);
 117                         tmp |= 0x00000004;      /* enable CLKRUN */
 118                         pci_write_config_dword(pci_dev, PCI_GEN_PMCON_1,
 119                                                tmp);
 120                 }
 121                 break;
 122         case PCI_VENDOR_ID_AMD:
 123                 /* nothing yet */
 124                 break;
 125         }
 126
 127         tpm_write_index(TPM_LOCK_REG, TPM_UNLOCK_VALUE);
 128         tpm_write_index(TPM_INTERUPT_REG, TPM_DISABLE_INTERUPT_VALUE);
 129         tpm_write_index(TPM_BASE_ADDR_LO, base);
 130         tpm_write_index(TPM_BASE_ADDR_HI, (base & 0xFF00) >> 8);
 131         tpm_write_index(TPM_LOCK_REG, TPM_LOCK_VALUE);
 132
 133         return 0;
 134 }
 135
 136 EXPORT_SYMBOL_GPL(tpm_lpc_bus_init);
 137
 138 /*
 139  * Internal kernel interface to transmit TPM commands
 140  */
 141 static ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
 142                             size_t bufsiz)
 143 {
 144         ssize_t rc;
 145         u32 count;
 146         unsigned long stop;
 147
 148         count = be32_to_cpu(*((__be32 *) (buf + 2)));
 149
 150         if (count == 0)
 151                 return -ENODATA;
 152         if (count > bufsiz) {
 153                 dev_err(&chip->pci_dev->dev,
 154                         "invalid count value %x %zx \n", count, bufsiz);
 155                 return -E2BIG;
 156         }
 157
 158         down(&chip->tpm_mutex);
 159
 160         if ((rc = chip->vendor->send(chip, (u8 *) buf, count)) < 0) {
 161                 dev_err(&chip->pci_dev->dev,
 162                         "tpm_transmit: tpm_send: error %zd\n", rc);
 163                 goto out;
 164         }
 165
 166         stop = jiffies + 2 * 60 * HZ;
 167         do {
 168                 u8 status = inb(chip->vendor->base + 1);
 169                 if ((status & chip->vendor->req_complete_mask) ==
 170                     chip->vendor->req_complete_val) {
 171                         goto out_recv;
 172                 }
 173
 174                 if ((status == chip->vendor->req_canceled)) {
 175                         dev_err(&chip->pci_dev->dev, "Operation Canceled\n");
 176                         rc = -ECANCELED;
 177                         goto out;
 178                 }
 179
 180                 msleep(TPM_TIMEOUT);    /* CHECK */
 181                 rmb();
 182         } while (time_before(jiffies, stop));
 183
 184
 185         chip->vendor->cancel(chip);
 186         dev_err(&chip->pci_dev->dev, "Operation Timed out\n");
 187         rc = -ETIME;
 188         goto out;
 189
 190 out_recv:
 191         rc = chip->vendor->recv(chip, (u8 *) buf, bufsiz);
 192         if (rc < 0)
 193                 dev_err(&chip->pci_dev->dev,
 194                         "tpm_transmit: tpm_recv: error %zd\n", rc);
 195 out:
 196         up(&chip->tpm_mutex);
 197         return rc;
 198 }
 199
 200 #define TPM_DIGEST_SIZE 20
 201 #define CAP_PCR_RESULT_SIZE 18
 202 static const u8 cap_pcr[] = {
 203         0, 193,                 /* TPM_TAG_RQU_COMMAND */
 204         0, 0, 0, 22,            /* length */
 205         0, 0, 0, 101,           /* TPM_ORD_GetCapability */
 206         0, 0, 0, 5,
 207         0, 0, 0, 4,
 208         0, 0, 1, 1
 209 };
 210
 211 #define READ_PCR_RESULT_SIZE 30
 212 static const u8 pcrread[] = {
 213         0, 193,                 /* TPM_TAG_RQU_COMMAND */
 214         0, 0, 0, 14,            /* length */
 215         0, 0, 0, 21,            /* TPM_ORD_PcrRead */
 216         0, 0, 0, 0              /* PCR index */
 217 };
 218
 219 ssize_t tpm_show_pcrs(struct device *dev, struct device_attribute *attr,
 220                       char *buf)
 221 {
 222         u8 data[READ_PCR_RESULT_SIZE];
 223         ssize_t len;
 224         int i, j, num_pcrs;
 225         __be32 index;
 226         char *str = buf;
 227
 228         struct tpm_chip *chip =
 229             pci_get_drvdata(to_pci_dev(dev));
 230         if (chip == NULL)
 231                 return -ENODEV;
 232
 233         memcpy(data, cap_pcr, sizeof(cap_pcr));
 234         if ((len = tpm_transmit(chip, data, sizeof(data)))
 235             < CAP_PCR_RESULT_SIZE)
 236                 return len;
 237
 238         num_pcrs = be32_to_cpu(*((__be32 *) (data + 14)));
 239
 240         for (i = 0; i < num_pcrs; i++) {
 241                 memcpy(data, pcrread, sizeof(pcrread));
 242                 index = cpu_to_be32(i);
 243                 memcpy(data + 10, &index, 4);
 244                 if ((len = tpm_transmit(chip, data, sizeof(data)))
 245                     < READ_PCR_RESULT_SIZE)
 246                         return len;
 247                 str += sprintf(str, "PCR-%02d: ", i);
 248                 for (j = 0; j < TPM_DIGEST_SIZE; j++)
 249                         str += sprintf(str, "%02X ", *(data + 10 + j));
 250                 str += sprintf(str, "\n");
 251         }
 252         return str - buf;
 253 }
 254
 255 EXPORT_SYMBOL_GPL(tpm_show_pcrs);
 256
 257 #define  READ_PUBEK_RESULT_SIZE 314
 258 static const u8 readpubek[] = {
 259         0, 193,                 /* TPM_TAG_RQU_COMMAND */
 260         0, 0, 0, 30,            /* length */
 261         0, 0, 0, 124,           /* TPM_ORD_ReadPubek */
 262 };
 263
 264 ssize_t tpm_show_pubek(struct device *dev, struct device_attribute *attr,
 265                        char *buf)
 266 {
 267         u8 *data;
 268         ssize_t len;
 269         int i, rc;
 270         char *str = buf;
 271
 272         struct tpm_chip *chip =
 273             pci_get_drvdata(to_pci_dev(dev));
 274         if (chip == NULL)
 275                 return -ENODEV;
 276
 277         data = kmalloc(READ_PUBEK_RESULT_SIZE, GFP_KERNEL);
 278         if (!data)
 279                 return -ENOMEM;
 280
 281         memcpy(data, readpubek, sizeof(readpubek));
 282         memset(data + sizeof(readpubek), 0, 20);        /* zero nonce */
 283
 284         if ((len = tpm_transmit(chip, data, READ_PUBEK_RESULT_SIZE)) <
 285             READ_PUBEK_RESULT_SIZE) {
 286                 rc = len;
 287                 goto out;
 288         }
 289
 290         /*
 291            ignore header 10 bytes
 292            algorithm 32 bits (1 == RSA )
 293            encscheme 16 bits
 294            sigscheme 16 bits
 295            parameters (RSA 12->bytes: keybit, #primes, expbit)
 296            keylenbytes 32 bits
 297            256 byte modulus
 298            ignore checksum 20 bytes
 299          */
 300
 301         str +=
 302             sprintf(str,
 303                     "Algorithm: %02X %02X %02X %02X\nEncscheme: %02X %02X\n"
 304                     "Sigscheme: %02X %02X\nParameters: %02X %02X %02X %02X"
 305                     " %02X %02X %02X %02X %02X %02X %02X %02X\n"
 306                     "Modulus length: %d\nModulus: \n",
 307                     data[10], data[11], data[12], data[13], data[14],
 308                     data[15], data[16], data[17], data[22], data[23],
 309                     data[24], data[25], data[26], data[27], data[28],
 310                     data[29], data[30], data[31], data[32], data[33],
 311                     be32_to_cpu(*((__be32 *) (data + 32))));
 312
 313         for (i = 0; i < 256; i++) {
 314                 str += sprintf(str, "%02X ", data[i + 39]);
 315                 if ((i + 1) % 16 == 0)
 316                         str += sprintf(str, "\n");
 317         }
 318         rc = str - buf;
 319 out:
 320         kfree(data);
 321         return rc;
 322 }
 323
 324 EXPORT_SYMBOL_GPL(tpm_show_pubek);
 325
 326 #define CAP_VER_RESULT_SIZE 18
 327 static const u8 cap_version[] = {
 328         0, 193,                 /* TPM_TAG_RQU_COMMAND */
 329         0, 0, 0, 18,            /* length */
 330         0, 0, 0, 101,           /* TPM_ORD_GetCapability */
 331         0, 0, 0, 6,
 332         0, 0, 0, 0
 333 };
 334
 335 #define CAP_MANUFACTURER_RESULT_SIZE 18
 336 static const u8 cap_manufacturer[] = {
 337         0, 193,                 /* TPM_TAG_RQU_COMMAND */
 338         0, 0, 0, 22,            /* length */
 339         0, 0, 0, 101,           /* TPM_ORD_GetCapability */
 340         0, 0, 0, 5,
 341         0, 0, 0, 4,
 342         0, 0, 1, 3
 343 };
 344
 345 ssize_t tpm_show_caps(struct device *dev, struct device_attribute *attr,
 346                       char *buf)
 347 {
 348         u8 data[sizeof(cap_manufacturer)];
 349         ssize_t len;
 350         char *str = buf;
 351
 352         struct tpm_chip *chip =
 353             pci_get_drvdata(to_pci_dev(dev));
 354         if (chip == NULL)
 355                 return -ENODEV;
 356
 357         memcpy(data, cap_manufacturer, sizeof(cap_manufacturer));
 358
 359         if ((len = tpm_transmit(chip, data, sizeof(data))) <
 360             CAP_MANUFACTURER_RESULT_SIZE)
 361                 return len;
 362
 363         str += sprintf(str, "Manufacturer: 0x%x\n",
 364                        be32_to_cpu(*((__be32 *) (data + 14))));
 365
 366         memcpy(data, cap_version, sizeof(cap_version));
 367
 368         if ((len = tpm_transmit(chip, data, sizeof(data))) <
 369             CAP_VER_RESULT_SIZE)
 370                 return len;
 371
 372         str +=
 373             sprintf(str, "TCG version: %d.%d\nFirmware version: %d.%d\n",
 374                     (int) data[14], (int) data[15], (int) data[16],
 375                     (int) data[17]);
 376
 377         return str - buf;
 378 }
 379 EXPORT_SYMBOL_GPL(tpm_show_caps);
 380
 381 ssize_t tpm_store_cancel(struct device *dev, struct device_attribute *attr,
 382                         const char *buf, size_t count)
 383 {
 384         struct tpm_chip *chip = dev_get_drvdata(dev);
 385         if (chip == NULL)
 386                 return 0;
 387
 388         chip->vendor->cancel(chip);
 389         return count;
 390 }
 391 EXPORT_SYMBOL_GPL(tpm_store_cancel);
 392
 393
 394 /*
 395  * Device file system interface to the TPM
 396  */
 397 int tpm_open(struct inode *inode, struct file *file)
 398 {
 399         int rc = 0, minor = iminor(inode);
 400         struct tpm_chip *chip = NULL, *pos;
 401
 402         spin_lock(&driver_lock);
 403
 404         list_for_each_entry(pos, &tpm_chip_list, list) {
 405                 if (pos->vendor->miscdev.minor == minor) {
 406                         chip = pos;
 407                         break;
 408                 }
 409         }
 410
 411         if (chip == NULL) {
 412                 rc = -ENODEV;
 413                 goto err_out;
 414         }
 415
 416         if (chip->num_opens) {
 417                 dev_dbg(&chip->pci_dev->dev,
 418                         "Another process owns this TPM\n");
 419                 rc = -EBUSY;
 420                 goto err_out;
 421         }
 422
 423         chip->num_opens++;
 424         pci_dev_get(chip->pci_dev);
 425
 426         spin_unlock(&driver_lock);
 427
 428         chip->data_buffer = kmalloc(TPM_BUFSIZE * sizeof(u8), GFP_KERNEL);
 429         if (chip->data_buffer == NULL) {
 430                 chip->num_opens--;
 431                 pci_dev_put(chip->pci_dev);
 432                 return -ENOMEM;
 433         }
 434
 435         atomic_set(&chip->data_pending, 0);
 436
 437         file->private_data = chip;
 438         return 0;
 439
 440 err_out:
 441         spin_unlock(&driver_lock);
 442         return rc;
 443 }
 444
 445 EXPORT_SYMBOL_GPL(tpm_open);
 446
 447 int tpm_release(struct inode *inode, struct file *file)
 448 {
 449         struct tpm_chip *chip = file->private_data;
 450
 451         spin_lock(&driver_lock);
 452         file->private_data = NULL;
 453         chip->num_opens--;
 454         del_singleshot_timer_sync(&chip->user_read_timer);
 455         atomic_set(&chip->data_pending, 0);
 456         pci_dev_put(chip->pci_dev);
 457         kfree(chip->data_buffer);
 458         spin_unlock(&driver_lock);
 459         return 0;
 460 }
 461
 462 EXPORT_SYMBOL_GPL(tpm_release);
 463
 464 ssize_t tpm_write(struct file * file, const char __user * buf,
 465                   size_t size, loff_t * off)
 466 {
 467         struct tpm_chip *chip = file->private_data;
 468         int in_size = size, out_size;
 469
 470         /* cannot perform a write until the read has cleared
 471            either via tpm_read or a user_read_timer timeout */
 472         while (atomic_read(&chip->data_pending) != 0)
 473                 msleep(TPM_TIMEOUT);
 474
 475         down(&chip->buffer_mutex);
 476
 477         if (in_size > TPM_BUFSIZE)
 478                 in_size = TPM_BUFSIZE;
 479
 480         if (copy_from_user
 481             (chip->data_buffer, (void __user *) buf, in_size)) {
 482                 up(&chip->buffer_mutex);
 483                 return -EFAULT;
 484         }
 485
 486         /* atomic tpm command send and result receive */
 487         out_size = tpm_transmit(chip, chip->data_buffer, TPM_BUFSIZE);
 488
 489         atomic_set(&chip->data_pending, out_size);
 490         up(&chip->buffer_mutex);
 491
 492         /* Set a timeout by which the reader must come claim the result */
 493         mod_timer(&chip->user_read_timer, jiffies + (60 * HZ));
 494
 495         return in_size;
 496 }
 497
 498 EXPORT_SYMBOL_GPL(tpm_write);
 499
 500 ssize_t tpm_read(struct file * file, char __user * buf,
 501                  size_t size, loff_t * off)
 502 {
 503         struct tpm_chip *chip = file->private_data;
 504         int ret_size;
 505
 506         del_singleshot_timer_sync(&chip->user_read_timer);
 507         ret_size = atomic_read(&chip->data_pending);
 508         atomic_set(&chip->data_pending, 0);
 509         if (ret_size > 0) {     /* relay data */
 510                 if (size < ret_size)
 511                         ret_size = size;
 512
 513                 down(&chip->buffer_mutex);
 514                 if (copy_to_user
 515                     ((void __user *) buf, chip->data_buffer, ret_size))
 516                         ret_size = -EFAULT;
 517                 up(&chip->buffer_mutex);
 518         }
 519
 520         return ret_size;
 521 }
 522
 523 EXPORT_SYMBOL_GPL(tpm_read);
 524
 525 void __devexit tpm_remove(struct pci_dev *pci_dev)
 526 {
 527         struct tpm_chip *chip = pci_get_drvdata(pci_dev);
 528
 529         if (chip == NULL) {
 530                 dev_err(&pci_dev->dev, "No device data found\n");
 531                 return;
 532         }
 533
 534         spin_lock(&driver_lock);
 535
 536         list_del(&chip->list);
 537
 538         spin_unlock(&driver_lock);
 539
 540         pci_set_drvdata(pci_dev, NULL);
 541         misc_deregister(&chip->vendor->miscdev);
 542
 543         sysfs_remove_group(&pci_dev->dev.kobj, chip->vendor->attr_group);
 544
 545         pci_disable_device(pci_dev);
 546
 547         dev_mask[chip->dev_num / TPM_NUM_MASK_ENTRIES ] &= !(1 << (chip->dev_num % TPM_NUM_MASK_ENTRIES));
 548
 549         kfree(chip);
 550
 551         pci_dev_put(pci_dev);
 552 }
 553
 554 EXPORT_SYMBOL_GPL(tpm_remove);
 555
 556 static u8 savestate[] = {
 557         0, 193,                 /* TPM_TAG_RQU_COMMAND */
 558         0, 0, 0, 10,            /* blob length (in bytes) */
 559         0, 0, 0, 152            /* TPM_ORD_SaveState */
 560 };
 561
 562 /*
 563  * We are about to suspend. Save the TPM state
 564  * so that it can be restored.
 565  */
 566 int tpm_pm_suspend(struct pci_dev *pci_dev, pm_message_t pm_state)
 567 {
 568         struct tpm_chip *chip = pci_get_drvdata(pci_dev);
 569         if (chip == NULL)
 570                 return -ENODEV;
 571
 572         tpm_transmit(chip, savestate, sizeof(savestate));
 573         return 0;
 574 }
 575
 576 EXPORT_SYMBOL_GPL(tpm_pm_suspend);
 577
 578 /*
 579  * Resume from a power safe. The BIOS already restored
 580  * the TPM state.
 581  */
 582 int tpm_pm_resume(struct pci_dev *pci_dev)
 583 {
 584         struct tpm_chip *chip = pci_get_drvdata(pci_dev);
 585
 586         if (chip == NULL)
 587                 return -ENODEV;
 588
 589         spin_lock(&driver_lock);
 590         tpm_lpc_bus_init(pci_dev, chip->vendor->base);
 591         spin_unlock(&driver_lock);
 592
 593         return 0;
 594 }
 595
 596 EXPORT_SYMBOL_GPL(tpm_pm_resume);
 597
 598 /*
 599  * Called from tpm_<specific>.c probe function only for devices
 600  * the driver has determined it should claim.  Prior to calling
 601  * this function the specific probe function has called pci_enable_device
 602  * upon errant exit from this function specific probe function should call
 603  * pci_disable_device
 604  */
 605 int tpm_register_hardware(struct pci_dev *pci_dev,
 606                           struct tpm_vendor_specific *entry)
 607 {
 608         char devname[7];
 609         struct tpm_chip *chip;
 610         int i, j;
 611
 612         /* Driver specific per-device data */
 613         chip = kmalloc(sizeof(*chip), GFP_KERNEL);
 614         if (chip == NULL)
 615                 return -ENOMEM;
 616
 617         memset(chip, 0, sizeof(struct tpm_chip));
 618
 619         init_MUTEX(&chip->buffer_mutex);
 620         init_MUTEX(&chip->tpm_mutex);
 621         INIT_LIST_HEAD(&chip->list);
 622
 623         init_timer(&chip->user_read_timer);
 624         chip->user_read_timer.function = user_reader_timeout;
 625         chip->user_read_timer.data = (unsigned long) chip;
 626
 627         chip->vendor = entry;
 628
 629         chip->dev_num = -1;
 630
 631         for (i = 0; i < TPM_NUM_MASK_ENTRIES; i++)
 632                 for (j = 0; j < 8 * sizeof(int); j++)
 633                         if ((dev_mask[i] & (1 << j)) == 0) {
 634                                 chip->dev_num =
 635                                     i * TPM_NUM_MASK_ENTRIES + j;
 636                                 dev_mask[i] |= 1 << j;
 637                                 goto dev_num_search_complete;
 638                         }
 639
 640 dev_num_search_complete:
 641         if (chip->dev_num < 0) {
 642                 dev_err(&pci_dev->dev,
 643                         "No available tpm device numbers\n");
 644                 kfree(chip);
 645                 return -ENODEV;
 646         } else if (chip->dev_num == 0)
 647                 chip->vendor->miscdev.minor = TPM_MINOR;
 648         else
 649                 chip->vendor->miscdev.minor = MISC_DYNAMIC_MINOR;
 650
 651         snprintf(devname, sizeof(devname), "%s%d", "tpm", chip->dev_num);
 652         chip->vendor->miscdev.name = devname;
 653
 654         chip->vendor->miscdev.dev = &(pci_dev->dev);
 655         chip->pci_dev = pci_dev_get(pci_dev);
 656
 657         if (misc_register(&chip->vendor->miscdev)) {
 658                 dev_err(&chip->pci_dev->dev,
 659                         "unable to misc_register %s, minor %d\n",
 660                         chip->vendor->miscdev.name,
 661                         chip->vendor->miscdev.minor);
 662                 pci_dev_put(pci_dev);
 663                 kfree(chip);
 664                 dev_mask[i] &= !(1 << j);
 665                 return -ENODEV;
 666         }
 667
 668         spin_lock(&driver_lock);
 669
 670         pci_set_drvdata(pci_dev, chip);
 671
 672         list_add(&chip->list, &tpm_chip_list);
 673
 674         spin_unlock(&driver_lock);
 675
 676         sysfs_create_group(&pci_dev->dev.kobj, chip->vendor->attr_group);
 677
 678         return 0;
 679 }
 680
 681 EXPORT_SYMBOL_GPL(tpm_register_hardware);
 682
 683 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
 684 MODULE_DESCRIPTION("TPM Driver");
 685 MODULE_VERSION("2.0");
 686 MODULE_LICENSE("GPL");