drivers/char/tpm/tpm_i2c_infineon.c

   1 /*
   2  * Copyright (C) 2012,2013 Infineon Technologies
   3  *
   4  * Authors:
   5  * Peter Huewe <peter.huewe@infineon.com>
   6  *
   7  * Device driver for TCG/TCPA TPM (trusted platform module).
   8  * Specifications at www.trustedcomputinggroup.org
   9  *
  10  * This device driver implements the TPM interface as defined in
  11  * the TCG TPM Interface Spec version 1.2, revision 1.0 and the
  12  * Infineon I2C Protocol Stack Specification v0.20.
  13  *
  14  * It is based on the original tpm_tis device driver from Leendert van
  15  * Dorn and Kyleen Hall.
  16  *
  17  * This program is free software; you can redistribute it and/or
  18  * modify it under the terms of the GNU General Public License as
  19  * published by the Free Software Foundation, version 2 of the
  20  * License.
  21  *
  22  *
  23  */
  24 #include <linux/init.h>
  25 #include <linux/i2c.h>
  26 #include <linux/module.h>
  27 #include <linux/wait.h>
  28 #include "tpm.h"
  29
  30 /* max. buffer size supported by our TPM */
  31 #define TPM_BUFSIZE 1260
  32
  33 /* max. number of iterations after I2C NAK */
  34 #define MAX_COUNT 3
  35
  36 #define SLEEP_DURATION_LOW 55
  37 #define SLEEP_DURATION_HI 65
  38
  39 /* max. number of iterations after I2C NAK for 'long' commands
  40  * we need this especially for sending TPM_READY, since the cleanup after the
  41  * transtion to the ready state may take some time, but it is unpredictable
  42  * how long it will take.
  43  */
  44 #define MAX_COUNT_LONG 50
  45
  46 #define SLEEP_DURATION_LONG_LOW 200
  47 #define SLEEP_DURATION_LONG_HI 220
  48
  49 /* After sending TPM_READY to 'reset' the TPM we have to sleep even longer */
  50 #define SLEEP_DURATION_RESET_LOW 2400
  51 #define SLEEP_DURATION_RESET_HI 2600
  52
  53 /* we want to use usleep_range instead of msleep for the 5ms TPM_TIMEOUT */
  54 #define TPM_TIMEOUT_US_LOW (TPM_TIMEOUT * 1000)
  55 #define TPM_TIMEOUT_US_HI  (TPM_TIMEOUT_US_LOW + 2000)
  56
  57 /* expected value for DIDVID register */
  58 #define TPM_TIS_I2C_DID_VID_9635 0xd1150b00L
  59 #define TPM_TIS_I2C_DID_VID_9645 0x001a15d1L
  60
  61 enum i2c_chip_type {
  62         SLB9635,
  63         SLB9645,
  64         UNKNOWN,
  65 };
  66
  67 /* Structure to store I2C TPM specific stuff */
  68 struct tpm_inf_dev {
  69         struct i2c_client *client;
  70         u8 buf[TPM_BUFSIZE + sizeof(u8)]; /* max. buffer size + addr */
  71         struct tpm_chip *chip;
  72         enum i2c_chip_type chip_type;
  73 };
  74
  75 static struct tpm_inf_dev tpm_dev;
  76
  77 /*
  78  * iic_tpm_read() - read from TPM register
  79  * @addr: register address to read from
  80  * @buffer: provided by caller
  81  * @len: number of bytes to read
  82  *
  83  * Read len bytes from TPM register and put them into
  84  * buffer (little-endian format, i.e. first byte is put into buffer[0]).
  85  *
  86  * NOTE: TPM is big-endian for multi-byte values. Multi-byte
  87  * values have to be swapped.
  88  *
  89  * NOTE: We can't unfortunately use the combined read/write functions
  90  * provided by the i2c core as the TPM currently does not support the
  91  * repeated start condition and due to it's special requirements.
  92  * The i2c_smbus* functions do not work for this chip.
  93  *
  94  * Return -EIO on error, 0 on success.
  95  */
  96 static int iic_tpm_read(u8 addr, u8 *buffer, size_t len)
  97 {
  98
  99         struct i2c_msg msg1 = {
 100                 .addr = tpm_dev.client->addr,
 101                 .len = 1,
 102                 .buf = &addr
 103         };
 104         struct i2c_msg msg2 = {
 105                 .addr = tpm_dev.client->addr,
 106                 .flags = I2C_M_RD,
 107                 .len = len,
 108                 .buf = buffer
 109         };
 110         struct i2c_msg msgs[] = {msg1, msg2};
 111
 112         int rc = 0;
 113         int count;
 114
 115         /* Lock the adapter for the duration of the whole sequence. */
 116         if (!tpm_dev.client->adapter->algo->master_xfer)
 117                 return -EOPNOTSUPP;
 118         i2c_lock_adapter(tpm_dev.client->adapter);
 119
 120         if (tpm_dev.chip_type == SLB9645) {
 121                 /* use a combined read for newer chips
 122                  * unfortunately the smbus functions are not suitable due to
 123                  * the 32 byte limit of the smbus.
 124                  * retries should usually not be needed, but are kept just to
 125                  * be on the safe side.
 126                  */
 127                 for (count = 0; count < MAX_COUNT; count++) {
 128                         rc = __i2c_transfer(tpm_dev.client->adapter, msgs, 2);
 129                         if (rc > 0)
 130                                 break;  /* break here to skip sleep */
 131                         usleep_range(SLEEP_DURATION_LOW, SLEEP_DURATION_HI);
 132                 }
 133         } else {
 134                 /* slb9635 protocol should work in all cases */
 135                 for (count = 0; count < MAX_COUNT; count++) {
 136                         rc = __i2c_transfer(tpm_dev.client->adapter, &msg1, 1);
 137                         if (rc > 0)
 138                                 break;  /* break here to skip sleep */
 139
 140                         usleep_range(SLEEP_DURATION_LOW, SLEEP_DURATION_HI);
 141                 }
 142
 143                 if (rc <= 0)
 144                         goto out;
 145
 146                 /* After the TPM has successfully received the register address
 147                  * it needs some time, thus we're sleeping here again, before
 148                  * retrieving the data
 149                  */
 150                 for (count = 0; count < MAX_COUNT; count++) {
 151                         usleep_range(SLEEP_DURATION_LOW, SLEEP_DURATION_HI);
 152                         rc = __i2c_transfer(tpm_dev.client->adapter, &msg2, 1);
 153                         if (rc > 0)
 154                                 break;
 155                 }
 156         }
 157
 158 out:
 159         i2c_unlock_adapter(tpm_dev.client->adapter);
 160         /* take care of 'guard time' */
 161         usleep_range(SLEEP_DURATION_LOW, SLEEP_DURATION_HI);
 162
 163         /* __i2c_transfer returns the number of successfully transferred
 164          * messages.
 165          * So rc should be greater than 0 here otherwise we have an error.
 166          */
 167         if (rc <= 0)
 168                 return -EIO;
 169
 170         return 0;
 171 }
 172
 173 static int iic_tpm_write_generic(u8 addr, u8 *buffer, size_t len,
 174                                  unsigned int sleep_low,
 175                                  unsigned int sleep_hi, u8 max_count)
 176 {
 177         int rc = -EIO;
 178         int count;
 179
 180         struct i2c_msg msg1 = {
 181                 .addr = tpm_dev.client->addr,
 182                 .len = len + 1,
 183                 .buf = tpm_dev.buf
 184         };
 185
 186         if (len > TPM_BUFSIZE)
 187                 return -EINVAL;
 188
 189         if (!tpm_dev.client->adapter->algo->master_xfer)
 190                 return -EOPNOTSUPP;
 191         i2c_lock_adapter(tpm_dev.client->adapter);
 192
 193         /* prepend the 'register address' to the buffer */
 194         tpm_dev.buf[0] = addr;
 195         memcpy(&(tpm_dev.buf[1]), buffer, len);
 196
 197         /*
 198          * NOTE: We have to use these special mechanisms here and unfortunately
 199          * cannot rely on the standard behavior of i2c_transfer.
 200          * Even for newer chips the smbus functions are not
 201          * suitable due to the 32 byte limit of the smbus.
 202          */
 203         for (count = 0; count < max_count; count++) {
 204                 rc = __i2c_transfer(tpm_dev.client->adapter, &msg1, 1);
 205                 if (rc > 0)
 206                         break;
 207                 usleep_range(sleep_low, sleep_hi);
 208         }
 209
 210         i2c_unlock_adapter(tpm_dev.client->adapter);
 211         /* take care of 'guard time' */
 212         usleep_range(SLEEP_DURATION_LOW, SLEEP_DURATION_HI);
 213
 214         /* __i2c_transfer returns the number of successfully transferred
 215          * messages.
 216          * So rc should be greater than 0 here otherwise we have an error.
 217          */
 218         if (rc <= 0)
 219                 return -EIO;
 220
 221         return 0;
 222 }
 223
 224 /*
 225  * iic_tpm_write() - write to TPM register
 226  * @addr: register address to write to
 227  * @buffer: containing data to be written
 228  * @len: number of bytes to write
 229  *
 230  * Write len bytes from provided buffer to TPM register (little
 231  * endian format, i.e. buffer[0] is written as first byte).
 232  *
 233  * NOTE: TPM is big-endian for multi-byte values. Multi-byte
 234  * values have to be swapped.
 235  *
 236  * NOTE: use this function instead of the iic_tpm_write_generic function.
 237  *
 238  * Return -EIO on error, 0 on success
 239  */
 240 static int iic_tpm_write(u8 addr, u8 *buffer, size_t len)
 241 {
 242         return iic_tpm_write_generic(addr, buffer, len, SLEEP_DURATION_LOW,
 243                                      SLEEP_DURATION_HI, MAX_COUNT);
 244 }
 245
 246 /*
 247  * This function is needed especially for the cleanup situation after
 248  * sending TPM_READY
 249  * */
 250 static int iic_tpm_write_long(u8 addr, u8 *buffer, size_t len)
 251 {
 252         return iic_tpm_write_generic(addr, buffer, len, SLEEP_DURATION_LONG_LOW,
 253                                      SLEEP_DURATION_LONG_HI, MAX_COUNT_LONG);
 254 }
 255
 256 enum tis_access {
 257         TPM_ACCESS_VALID = 0x80,
 258         TPM_ACCESS_ACTIVE_LOCALITY = 0x20,
 259         TPM_ACCESS_REQUEST_PENDING = 0x04,
 260         TPM_ACCESS_REQUEST_USE = 0x02,
 261 };
 262
 263 enum tis_status {
 264         TPM_STS_VALID = 0x80,
 265         TPM_STS_COMMAND_READY = 0x40,
 266         TPM_STS_GO = 0x20,
 267         TPM_STS_DATA_AVAIL = 0x10,
 268         TPM_STS_DATA_EXPECT = 0x08,
 269 };
 270
 271 enum tis_defaults {
 272         TIS_SHORT_TIMEOUT = 750,        /* ms */
 273         TIS_LONG_TIMEOUT = 2000,        /* 2 sec */
 274 };
 275
 276 #define TPM_ACCESS(l)                   (0x0000 | ((l) << 4))
 277 #define TPM_STS(l)                      (0x0001 | ((l) << 4))
 278 #define TPM_DATA_FIFO(l)                (0x0005 | ((l) << 4))
 279 #define TPM_DID_VID(l)                  (0x0006 | ((l) << 4))
 280
 281 static int check_locality(struct tpm_chip *chip, int loc)
 282 {
 283         u8 buf;
 284         int rc;
 285
 286         rc = iic_tpm_read(TPM_ACCESS(loc), &buf, 1);
 287         if (rc < 0)
 288                 return rc;
 289
 290         if ((buf & (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) ==
 291             (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) {
 292                 chip->vendor.locality = loc;
 293                 return loc;
 294         }
 295
 296         return -EIO;
 297 }
 298
 299 /* implementation similar to tpm_tis */
 300 static void release_locality(struct tpm_chip *chip, int loc, int force)
 301 {
 302         u8 buf;
 303         if (iic_tpm_read(TPM_ACCESS(loc), &buf, 1) < 0)
 304                 return;
 305
 306         if (force || (buf & (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) ==
 307             (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) {
 308                 buf = TPM_ACCESS_ACTIVE_LOCALITY;
 309                 iic_tpm_write(TPM_ACCESS(loc), &buf, 1);
 310         }
 311 }
 312
 313 static int request_locality(struct tpm_chip *chip, int loc)
 314 {
 315         unsigned long stop;
 316         u8 buf = TPM_ACCESS_REQUEST_USE;
 317
 318         if (check_locality(chip, loc) >= 0)
 319                 return loc;
 320
 321         iic_tpm_write(TPM_ACCESS(loc), &buf, 1);
 322
 323         /* wait for burstcount */
 324         stop = jiffies + chip->vendor.timeout_a;
 325         do {
 326                 if (check_locality(chip, loc) >= 0)
 327                         return loc;
 328                 usleep_range(TPM_TIMEOUT_US_LOW, TPM_TIMEOUT_US_HI);
 329         } while (time_before(jiffies, stop));
 330
 331         return -ETIME;
 332 }
 333
 334 static u8 tpm_tis_i2c_status(struct tpm_chip *chip)
 335 {
 336         /* NOTE: since I2C read may fail, return 0 in this case --> time-out */
 337         u8 buf = 0xFF;
 338         u8 i = 0;
 339
 340         do {
 341                 if (iic_tpm_read(TPM_STS(chip->vendor.locality), &buf, 1) < 0)
 342                         return 0;
 343
 344                 i++;
 345         /* if locallity is set STS should not be 0xFF */
 346         } while ((buf == 0xFF) && i < 10);
 347
 348         return buf;
 349 }
 350
 351 static void tpm_tis_i2c_ready(struct tpm_chip *chip)
 352 {
 353         /* this causes the current command to be aborted */
 354         u8 buf = TPM_STS_COMMAND_READY;
 355         iic_tpm_write_long(TPM_STS(chip->vendor.locality), &buf, 1);
 356 }
 357
 358 static ssize_t get_burstcount(struct tpm_chip *chip)
 359 {
 360         unsigned long stop;
 361         ssize_t burstcnt;
 362         u8 buf[3];
 363
 364         /* wait for burstcount */
 365         /* which timeout value, spec has 2 answers (c & d) */
 366         stop = jiffies + chip->vendor.timeout_d;
 367         do {
 368                 /* Note: STS is little endian */
 369                 if (iic_tpm_read(TPM_STS(chip->vendor.locality)+1, buf, 3) < 0)
 370                         burstcnt = 0;
 371                 else
 372                         burstcnt = (buf[2] << 16) + (buf[1] << 8) + buf[0];
 373
 374                 if (burstcnt)
 375                         return burstcnt;
 376
 377                 usleep_range(TPM_TIMEOUT_US_LOW, TPM_TIMEOUT_US_HI);
 378         } while (time_before(jiffies, stop));
 379         return -EBUSY;
 380 }
 381
 382 static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout,
 383                          int *status)
 384 {
 385         unsigned long stop;
 386
 387         /* check current status */
 388         *status = tpm_tis_i2c_status(chip);
 389         if ((*status != 0xFF) && (*status & mask) == mask)
 390                 return 0;
 391
 392         stop = jiffies + timeout;
 393         do {
 394                 /* since we just checked the status, give the TPM some time */
 395                 usleep_range(TPM_TIMEOUT_US_LOW, TPM_TIMEOUT_US_HI);
 396                 *status = tpm_tis_i2c_status(chip);
 397                 if ((*status & mask) == mask)
 398                         return 0;
 399
 400         } while (time_before(jiffies, stop));
 401
 402         return -ETIME;
 403 }
 404
 405 static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
 406 {
 407         size_t size = 0;
 408         ssize_t burstcnt;
 409         u8 retries = 0;
 410         int rc;
 411
 412         while (size < count) {
 413                 burstcnt = get_burstcount(chip);
 414
 415                 /* burstcnt < 0 = TPM is busy */
 416                 if (burstcnt < 0)
 417                         return burstcnt;
 418
 419                 /* limit received data to max. left */
 420                 if (burstcnt > (count - size))
 421                         burstcnt = count - size;
 422
 423                 rc = iic_tpm_read(TPM_DATA_FIFO(chip->vendor.locality),
 424                                   &(buf[size]), burstcnt);
 425                 if (rc == 0)
 426                         size += burstcnt;
 427                 else if (rc < 0)
 428                         retries++;
 429
 430                 /* avoid endless loop in case of broken HW */
 431                 if (retries > MAX_COUNT_LONG)
 432                         return -EIO;
 433         }
 434         return size;
 435 }
 436
 437 static int tpm_tis_i2c_recv(struct tpm_chip *chip, u8 *buf, size_t count)
 438 {
 439         int size = 0;
 440         int expected, status;
 441
 442         if (count < TPM_HEADER_SIZE) {
 443                 size = -EIO;
 444                 goto out;
 445         }
 446
 447         /* read first 10 bytes, including tag, paramsize, and result */
 448         size = recv_data(chip, buf, TPM_HEADER_SIZE);
 449         if (size < TPM_HEADER_SIZE) {
 450                 dev_err(chip->dev, "Unable to read header\n");
 451                 goto out;
 452         }
 453
 454         expected = be32_to_cpu(*(__be32 *)(buf + 2));
 455         if ((size_t) expected > count) {
 456                 size = -EIO;
 457                 goto out;
 458         }
 459
 460         size += recv_data(chip, &buf[TPM_HEADER_SIZE],
 461                           expected - TPM_HEADER_SIZE);
 462         if (size < expected) {
 463                 dev_err(chip->dev, "Unable to read remainder of result\n");
 464                 size = -ETIME;
 465                 goto out;
 466         }
 467
 468         wait_for_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c, &status);
 469         if (status & TPM_STS_DATA_AVAIL) {      /* retry? */
 470                 dev_err(chip->dev, "Error left over data\n");
 471                 size = -EIO;
 472                 goto out;
 473         }
 474
 475 out:
 476         tpm_tis_i2c_ready(chip);
 477         /* The TPM needs some time to clean up here,
 478          * so we sleep rather than keeping the bus busy
 479          */
 480         usleep_range(SLEEP_DURATION_RESET_LOW, SLEEP_DURATION_RESET_HI);
 481         release_locality(chip, chip->vendor.locality, 0);
 482         return size;
 483 }
 484
 485 static int tpm_tis_i2c_send(struct tpm_chip *chip, u8 *buf, size_t len)
 486 {
 487         int rc, status;
 488         ssize_t burstcnt;
 489         size_t count = 0;
 490         u8 retries = 0;
 491         u8 sts = TPM_STS_GO;
 492
 493         if (len > TPM_BUFSIZE)
 494                 return -E2BIG;  /* command is too long for our tpm, sorry */
 495
 496         if (request_locality(chip, 0) < 0)
 497                 return -EBUSY;
 498
 499         status = tpm_tis_i2c_status(chip);
 500         if ((status & TPM_STS_COMMAND_READY) == 0) {
 501                 tpm_tis_i2c_ready(chip);
 502                 if (wait_for_stat
 503                     (chip, TPM_STS_COMMAND_READY,
 504                      chip->vendor.timeout_b, &status) < 0) {
 505                         rc = -ETIME;
 506                         goto out_err;
 507                 }
 508         }
 509
 510         while (count < len - 1) {
 511                 burstcnt = get_burstcount(chip);
 512
 513                 /* burstcnt < 0 = TPM is busy */
 514                 if (burstcnt < 0)
 515                         return burstcnt;
 516
 517                 if (burstcnt > (len - 1 - count))
 518                         burstcnt = len - 1 - count;
 519
 520                 rc = iic_tpm_write(TPM_DATA_FIFO(chip->vendor.locality),
 521                                    &(buf[count]), burstcnt);
 522                 if (rc == 0)
 523                         count += burstcnt;
 524                 else if (rc < 0)
 525                         retries++;
 526
 527                 /* avoid endless loop in case of broken HW */
 528                 if (retries > MAX_COUNT_LONG) {
 529                         rc = -EIO;
 530                         goto out_err;
 531                 }
 532
 533                 wait_for_stat(chip, TPM_STS_VALID,
 534                               chip->vendor.timeout_c, &status);
 535
 536                 if ((status & TPM_STS_DATA_EXPECT) == 0) {
 537                         rc = -EIO;
 538                         goto out_err;
 539                 }
 540         }
 541
 542         /* write last byte */
 543         iic_tpm_write(TPM_DATA_FIFO(chip->vendor.locality), &(buf[count]), 1);
 544         wait_for_stat(chip, TPM_STS_VALID, chip->vendor.timeout_c, &status);
 545         if ((status & TPM_STS_DATA_EXPECT) != 0) {
 546                 rc = -EIO;
 547                 goto out_err;
 548         }
 549
 550         /* go and do it */
 551         iic_tpm_write(TPM_STS(chip->vendor.locality), &sts, 1);
 552
 553         return len;
 554 out_err:
 555         tpm_tis_i2c_ready(chip);
 556         /* The TPM needs some time to clean up here,
 557          * so we sleep rather than keeping the bus busy
 558          */
 559         usleep_range(SLEEP_DURATION_RESET_LOW, SLEEP_DURATION_RESET_HI);
 560         release_locality(chip, chip->vendor.locality, 0);
 561         return rc;
 562 }
 563
 564 static bool tpm_tis_i2c_req_canceled(struct tpm_chip *chip, u8 status)
 565 {
 566         return (status == TPM_STS_COMMAND_READY);
 567 }
 568
 569 static const struct file_operations tis_ops = {
 570         .owner = THIS_MODULE,
 571         .llseek = no_llseek,
 572         .open = tpm_open,
 573         .read = tpm_read,
 574         .write = tpm_write,
 575         .release = tpm_release,
 576 };
 577
 578 static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL);
 579 static DEVICE_ATTR(pcrs, S_IRUGO, tpm_show_pcrs, NULL);
 580 static DEVICE_ATTR(enabled, S_IRUGO, tpm_show_enabled, NULL);
 581 static DEVICE_ATTR(active, S_IRUGO, tpm_show_active, NULL);
 582 static DEVICE_ATTR(owned, S_IRUGO, tpm_show_owned, NULL);
 583 static DEVICE_ATTR(temp_deactivated, S_IRUGO, tpm_show_temp_deactivated, NULL);
 584 static DEVICE_ATTR(caps, S_IRUGO, tpm_show_caps, NULL);
 585 static DEVICE_ATTR(cancel, S_IWUSR | S_IWGRP, NULL, tpm_store_cancel);
 586 static DEVICE_ATTR(durations, S_IRUGO, tpm_show_durations, NULL);
 587 static DEVICE_ATTR(timeouts, S_IRUGO, tpm_show_timeouts, NULL);
 588
 589 static struct attribute *tis_attrs[] = {
 590         &dev_attr_pubek.attr,
 591         &dev_attr_pcrs.attr,
 592         &dev_attr_enabled.attr,
 593         &dev_attr_active.attr,
 594         &dev_attr_owned.attr,
 595         &dev_attr_temp_deactivated.attr,
 596         &dev_attr_caps.attr,
 597         &dev_attr_cancel.attr,
 598         &dev_attr_durations.attr,
 599         &dev_attr_timeouts.attr,
 600         NULL,
 601 };
 602
 603 static struct attribute_group tis_attr_grp = {
 604         .attrs = tis_attrs
 605 };
 606
 607 static struct tpm_vendor_specific tpm_tis_i2c = {
 608         .status = tpm_tis_i2c_status,
 609         .recv = tpm_tis_i2c_recv,
 610         .send = tpm_tis_i2c_send,
 611         .cancel = tpm_tis_i2c_ready,
 612         .req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
 613         .req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
 614         .req_canceled = tpm_tis_i2c_req_canceled,
 615         .attr_group = &tis_attr_grp,
 616         .miscdev.fops = &tis_ops,
 617 };
 618
 619 static int tpm_tis_i2c_init(struct device *dev)
 620 {
 621         u32 vendor;
 622         int rc = 0;
 623         struct tpm_chip *chip;
 624
 625         chip = tpm_register_hardware(dev, &tpm_tis_i2c);
 626         if (!chip) {
 627                 dev_err(dev, "could not register hardware\n");
 628                 rc = -ENODEV;
 629                 goto out_err;
 630         }
 631
 632         /* Disable interrupts */
 633         chip->vendor.irq = 0;
 634
 635         /* Default timeouts */
 636         chip->vendor.timeout_a = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
 637         chip->vendor.timeout_b = msecs_to_jiffies(TIS_LONG_TIMEOUT);
 638         chip->vendor.timeout_c = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
 639         chip->vendor.timeout_d = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
 640
 641         if (request_locality(chip, 0) != 0) {
 642                 dev_err(dev, "could not request locality\n");
 643                 rc = -ENODEV;
 644                 goto out_vendor;
 645         }
 646
 647         /* read four bytes from DID_VID register */
 648         if (iic_tpm_read(TPM_DID_VID(0), (u8 *)&vendor, 4) < 0) {
 649                 dev_err(dev, "could not read vendor id\n");
 650                 rc = -EIO;
 651                 goto out_release;
 652         }
 653
 654         if (vendor == TPM_TIS_I2C_DID_VID_9645) {
 655                 tpm_dev.chip_type = SLB9645;
 656         } else if (vendor == TPM_TIS_I2C_DID_VID_9635) {
 657                 tpm_dev.chip_type = SLB9635;
 658         } else {
 659                 dev_err(dev, "vendor id did not match! ID was %08x\n", vendor);
 660                 rc = -ENODEV;
 661                 goto out_release;
 662         }
 663
 664         dev_info(dev, "1.2 TPM (device-id 0x%X)\n", vendor >> 16);
 665
 666         INIT_LIST_HEAD(&chip->vendor.list);
 667         tpm_dev.chip = chip;
 668
 669         tpm_get_timeouts(chip);
 670         tpm_do_selftest(chip);
 671
 672         return 0;
 673
 674 out_release:
 675         release_locality(chip, chip->vendor.locality, 1);
 676
 677 out_vendor:
 678         /* close file handles */
 679         tpm_dev_vendor_release(chip);
 680
 681         /* remove hardware */
 682         tpm_remove_hardware(chip->dev);
 683
 684         /* reset these pointers, otherwise we oops */
 685         chip->dev->release = NULL;
 686         chip->release = NULL;
 687         tpm_dev.client = NULL;
 688 out_err:
 689         return rc;
 690 }
 691
 692 static const struct i2c_device_id tpm_tis_i2c_table[] = {
 693         {"tpm_i2c_infineon", 0},
 694         {"slb9635tt", 0},
 695         {"slb9645tt", 1},
 696         {},
 697 };
 698
 699 MODULE_DEVICE_TABLE(i2c, tpm_tis_i2c_table);
 700
 701 #ifdef CONFIG_OF
 702 static const struct of_device_id tpm_tis_i2c_of_match[] = {
 703         {
 704                 .name = "tpm_i2c_infineon",
 705                 .type = "tpm",
 706                 .compatible = "infineon,tpm_i2c_infineon",
 707                 .data = (void *)0
 708         },
 709         {
 710                 .name = "slb9635tt",
 711                 .type = "tpm",
 712                 .compatible = "infineon,slb9635tt",
 713                 .data = (void *)0
 714         },
 715         {
 716                 .name = "slb9645tt",
 717                 .type = "tpm",
 718                 .compatible = "infineon,slb9645tt",
 719                 .data = (void *)1
 720         },
 721         {},
 722 };
 723 MODULE_DEVICE_TABLE(of, tpm_tis_i2c_of_match);
 724 #endif
 725
 726 static SIMPLE_DEV_PM_OPS(tpm_tis_i2c_ops, tpm_pm_suspend, tpm_pm_resume);
 727
 728 static int tpm_tis_i2c_probe(struct i2c_client *client,
 729                              const struct i2c_device_id *id)
 730 {
 731         int rc;
 732         struct device *dev = &(client->dev);
 733
 734         if (tpm_dev.client != NULL) {
 735                 dev_err(dev, "This driver only supports one client at a time\n");
 736                 return -EBUSY;  /* We only support one client */
 737         }
 738
 739         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 740                 dev_err(dev, "no algorithms associated to the i2c bus\n");
 741                 return -ENODEV;
 742         }
 743
 744         tpm_dev.client = client;
 745         rc = tpm_tis_i2c_init(&client->dev);
 746         if (rc != 0) {
 747                 tpm_dev.client = NULL;
 748                 rc = -ENODEV;
 749         }
 750         return rc;
 751 }
 752
 753 static int tpm_tis_i2c_remove(struct i2c_client *client)
 754 {
 755         struct tpm_chip *chip = tpm_dev.chip;
 756         release_locality(chip, chip->vendor.locality, 1);
 757
 758         /* close file handles */
 759         tpm_dev_vendor_release(chip);
 760
 761         /* remove hardware */
 762         tpm_remove_hardware(chip->dev);
 763
 764         /* reset these pointers, otherwise we oops */
 765         chip->dev->release = NULL;
 766         chip->release = NULL;
 767         tpm_dev.client = NULL;
 768
 769         return 0;
 770 }
 771
 772 static struct i2c_driver tpm_tis_i2c_driver = {
 773         .id_table = tpm_tis_i2c_table,
 774         .probe = tpm_tis_i2c_probe,
 775         .remove = tpm_tis_i2c_remove,
 776         .driver = {
 777                    .name = "tpm_i2c_infineon",
 778                    .owner = THIS_MODULE,
 779                    .pm = &tpm_tis_i2c_ops,
 780                    .of_match_table = of_match_ptr(tpm_tis_i2c_of_match),
 781                    },
 782 };
 783
 784 module_i2c_driver(tpm_tis_i2c_driver);
 785 MODULE_AUTHOR("Peter Huewe <peter.huewe@infineon.com>");
 786 MODULE_DESCRIPTION("TPM TIS I2C Infineon Driver");
 787 MODULE_VERSION("2.2.0");
 788 MODULE_LICENSE("GPL");