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/i2c.h>
  25 #include <linux/module.h>
  26 #include <linux/wait.h>
  27 #include "tpm.h"
  28
  29 /* max. buffer size supported by our TPM */
  30 #define TPM_BUFSIZE 1260
  31
  32 /* max. number of iterations after I2C NAK */
  33 #define MAX_COUNT 3
  34
  35 #define SLEEP_DURATION_LOW 55
  36 #define SLEEP_DURATION_HI 65
  37
  38 /* max. number of iterations after I2C NAK for 'long' commands
  39  * we need this especially for sending TPM_READY, since the cleanup after the
  40  * transtion to the ready state may take some time, but it is unpredictable
  41  * how long it will take.
  42  */
  43 #define MAX_COUNT_LONG 50
  44
  45 #define SLEEP_DURATION_LONG_LOW 200
  46 #define SLEEP_DURATION_LONG_HI 220
  47
  48 /* After sending TPM_READY to 'reset' the TPM we have to sleep even longer */
  49 #define SLEEP_DURATION_RESET_LOW 2400
  50 #define SLEEP_DURATION_RESET_HI 2600
  51
  52 /* we want to use usleep_range instead of msleep for the 5ms TPM_TIMEOUT */
  53 #define TPM_TIMEOUT_US_LOW (TPM_TIMEOUT * 1000)
  54 #define TPM_TIMEOUT_US_HI  (TPM_TIMEOUT_US_LOW + 2000)
  55
  56 /* expected value for DIDVID register */
  57 #define TPM_TIS_I2C_DID_VID_9635 0xd1150b00L
  58 #define TPM_TIS_I2C_DID_VID_9645 0x001a15d1L
  59
  60 enum i2c_chip_type {
  61         SLB9635,
  62         SLB9645,
  63         UNKNOWN,
  64 };
  65
  66 /* Structure to store I2C TPM specific stuff */
  67 struct tpm_inf_dev {
  68         struct i2c_client *client;
  69         int locality;
  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_bus(tpm_dev.client->adapter, I2C_LOCK_SEGMENT);
 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_bus(tpm_dev.client->adapter, I2C_LOCK_SEGMENT);
 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_bus(tpm_dev.client->adapter, I2C_LOCK_SEGMENT);
 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_bus(tpm_dev.client->adapter, I2C_LOCK_SEGMENT);
 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                 tpm_dev.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->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(tpm_dev.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(tpm_dev.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->timeout_d;
 367         do {
 368                 /* Note: STS is little endian */
 369                 if (iic_tpm_read(TPM_STS(tpm_dev.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(tpm_dev.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 status;
 441         u32 expected;
 442
 443         if (count < TPM_HEADER_SIZE) {
 444                 size = -EIO;
 445                 goto out;
 446         }
 447
 448         /* read first 10 bytes, including tag, paramsize, and result */
 449         size = recv_data(chip, buf, TPM_HEADER_SIZE);
 450         if (size < TPM_HEADER_SIZE) {
 451                 dev_err(&chip->dev, "Unable to read header\n");
 452                 goto out;
 453         }
 454
 455         expected = be32_to_cpu(*(__be32 *)(buf + 2));
 456         if (((size_t) expected > count) || (expected < TPM_HEADER_SIZE)) {
 457                 size = -EIO;
 458                 goto out;
 459         }
 460
 461         size += recv_data(chip, &buf[TPM_HEADER_SIZE],
 462                           expected - TPM_HEADER_SIZE);
 463         if (size < expected) {
 464                 dev_err(&chip->dev, "Unable to read remainder of result\n");
 465                 size = -ETIME;
 466                 goto out;
 467         }
 468
 469         wait_for_stat(chip, TPM_STS_VALID, chip->timeout_c, &status);
 470         if (status & TPM_STS_DATA_AVAIL) {      /* retry? */
 471                 dev_err(&chip->dev, "Error left over data\n");
 472                 size = -EIO;
 473                 goto out;
 474         }
 475
 476 out:
 477         tpm_tis_i2c_ready(chip);
 478         /* The TPM needs some time to clean up here,
 479          * so we sleep rather than keeping the bus busy
 480          */
 481         usleep_range(SLEEP_DURATION_RESET_LOW, SLEEP_DURATION_RESET_HI);
 482         release_locality(chip, tpm_dev.locality, 0);
 483         return size;
 484 }
 485
 486 static int tpm_tis_i2c_send(struct tpm_chip *chip, u8 *buf, size_t len)
 487 {
 488         int rc, status;
 489         ssize_t burstcnt;
 490         size_t count = 0;
 491         u8 retries = 0;
 492         u8 sts = TPM_STS_GO;
 493
 494         if (len > TPM_BUFSIZE)
 495                 return -E2BIG;  /* command is too long for our tpm, sorry */
 496
 497         if (request_locality(chip, 0) < 0)
 498                 return -EBUSY;
 499
 500         status = tpm_tis_i2c_status(chip);
 501         if ((status & TPM_STS_COMMAND_READY) == 0) {
 502                 tpm_tis_i2c_ready(chip);
 503                 if (wait_for_stat
 504                     (chip, TPM_STS_COMMAND_READY,
 505                      chip->timeout_b, &status) < 0) {
 506                         rc = -ETIME;
 507                         goto out_err;
 508                 }
 509         }
 510
 511         while (count < len - 1) {
 512                 burstcnt = get_burstcount(chip);
 513
 514                 /* burstcnt < 0 = TPM is busy */
 515                 if (burstcnt < 0)
 516                         return burstcnt;
 517
 518                 if (burstcnt > (len - 1 - count))
 519                         burstcnt = len - 1 - count;
 520
 521                 rc = iic_tpm_write(TPM_DATA_FIFO(tpm_dev.locality),
 522                                    &(buf[count]), burstcnt);
 523                 if (rc == 0)
 524                         count += burstcnt;
 525                 else if (rc < 0)
 526                         retries++;
 527
 528                 /* avoid endless loop in case of broken HW */
 529                 if (retries > MAX_COUNT_LONG) {
 530                         rc = -EIO;
 531                         goto out_err;
 532                 }
 533
 534                 wait_for_stat(chip, TPM_STS_VALID,
 535                               chip->timeout_c, &status);
 536
 537                 if ((status & TPM_STS_DATA_EXPECT) == 0) {
 538                         rc = -EIO;
 539                         goto out_err;
 540                 }
 541         }
 542
 543         /* write last byte */
 544         iic_tpm_write(TPM_DATA_FIFO(tpm_dev.locality), &(buf[count]), 1);
 545         wait_for_stat(chip, TPM_STS_VALID, chip->timeout_c, &status);
 546         if ((status & TPM_STS_DATA_EXPECT) != 0) {
 547                 rc = -EIO;
 548                 goto out_err;
 549         }
 550
 551         /* go and do it */
 552         iic_tpm_write(TPM_STS(tpm_dev.locality), &sts, 1);
 553
 554         return len;
 555 out_err:
 556         tpm_tis_i2c_ready(chip);
 557         /* The TPM needs some time to clean up here,
 558          * so we sleep rather than keeping the bus busy
 559          */
 560         usleep_range(SLEEP_DURATION_RESET_LOW, SLEEP_DURATION_RESET_HI);
 561         release_locality(chip, tpm_dev.locality, 0);
 562         return rc;
 563 }
 564
 565 static bool tpm_tis_i2c_req_canceled(struct tpm_chip *chip, u8 status)
 566 {
 567         return (status == TPM_STS_COMMAND_READY);
 568 }
 569
 570 static const struct tpm_class_ops tpm_tis_i2c = {
 571         .flags = TPM_OPS_AUTO_STARTUP,
 572         .status = tpm_tis_i2c_status,
 573         .recv = tpm_tis_i2c_recv,
 574         .send = tpm_tis_i2c_send,
 575         .cancel = tpm_tis_i2c_ready,
 576         .req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
 577         .req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
 578         .req_canceled = tpm_tis_i2c_req_canceled,
 579 };
 580
 581 static int tpm_tis_i2c_init(struct device *dev)
 582 {
 583         u32 vendor;
 584         int rc = 0;
 585         struct tpm_chip *chip;
 586
 587         chip = tpmm_chip_alloc(dev, &tpm_tis_i2c);
 588         if (IS_ERR(chip))
 589                 return PTR_ERR(chip);
 590
 591         /* Default timeouts */
 592         chip->timeout_a = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
 593         chip->timeout_b = msecs_to_jiffies(TIS_LONG_TIMEOUT);
 594         chip->timeout_c = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
 595         chip->timeout_d = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
 596
 597         if (request_locality(chip, 0) != 0) {
 598                 dev_err(dev, "could not request locality\n");
 599                 rc = -ENODEV;
 600                 goto out_err;
 601         }
 602
 603         /* read four bytes from DID_VID register */
 604         if (iic_tpm_read(TPM_DID_VID(0), (u8 *)&vendor, 4) < 0) {
 605                 dev_err(dev, "could not read vendor id\n");
 606                 rc = -EIO;
 607                 goto out_release;
 608         }
 609
 610         if (vendor == TPM_TIS_I2C_DID_VID_9645) {
 611                 tpm_dev.chip_type = SLB9645;
 612         } else if (vendor == TPM_TIS_I2C_DID_VID_9635) {
 613                 tpm_dev.chip_type = SLB9635;
 614         } else {
 615                 dev_err(dev, "vendor id did not match! ID was %08x\n", vendor);
 616                 rc = -ENODEV;
 617                 goto out_release;
 618         }
 619
 620         dev_info(dev, "1.2 TPM (device-id 0x%X)\n", vendor >> 16);
 621
 622         tpm_dev.chip = chip;
 623
 624         return tpm_chip_register(chip);
 625 out_release:
 626         release_locality(chip, tpm_dev.locality, 1);
 627         tpm_dev.client = NULL;
 628 out_err:
 629         return rc;
 630 }
 631
 632 static const struct i2c_device_id tpm_tis_i2c_table[] = {
 633         {"tpm_i2c_infineon", 0},
 634         {"slb9635tt", 0},
 635         {"slb9645tt", 1},
 636         {},
 637 };
 638
 639 MODULE_DEVICE_TABLE(i2c, tpm_tis_i2c_table);
 640
 641 #ifdef CONFIG_OF
 642 static const struct of_device_id tpm_tis_i2c_of_match[] = {
 643         {
 644                 .name = "tpm_i2c_infineon",
 645                 .type = "tpm",
 646                 .compatible = "infineon,tpm_i2c_infineon",
 647                 .data = (void *)0
 648         },
 649         {
 650                 .name = "slb9635tt",
 651                 .type = "tpm",
 652                 .compatible = "infineon,slb9635tt",
 653                 .data = (void *)0
 654         },
 655         {
 656                 .name = "slb9645tt",
 657                 .type = "tpm",
 658                 .compatible = "infineon,slb9645tt",
 659                 .data = (void *)1
 660         },
 661         {},
 662 };
 663 MODULE_DEVICE_TABLE(of, tpm_tis_i2c_of_match);
 664 #endif
 665
 666 static SIMPLE_DEV_PM_OPS(tpm_tis_i2c_ops, tpm_pm_suspend, tpm_pm_resume);
 667
 668 static int tpm_tis_i2c_probe(struct i2c_client *client,
 669                              const struct i2c_device_id *id)
 670 {
 671         int rc;
 672         struct device *dev = &(client->dev);
 673
 674         if (tpm_dev.client != NULL) {
 675                 dev_err(dev, "This driver only supports one client at a time\n");
 676                 return -EBUSY;  /* We only support one client */
 677         }
 678
 679         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 680                 dev_err(dev, "no algorithms associated to the i2c bus\n");
 681                 return -ENODEV;
 682         }
 683
 684         tpm_dev.client = client;
 685         rc = tpm_tis_i2c_init(&client->dev);
 686         if (rc != 0) {
 687                 tpm_dev.client = NULL;
 688                 rc = -ENODEV;
 689         }
 690         return rc;
 691 }
 692
 693 static int tpm_tis_i2c_remove(struct i2c_client *client)
 694 {
 695         struct tpm_chip *chip = tpm_dev.chip;
 696
 697         tpm_chip_unregister(chip);
 698         release_locality(chip, tpm_dev.locality, 1);
 699         tpm_dev.client = NULL;
 700
 701         return 0;
 702 }
 703
 704 static struct i2c_driver tpm_tis_i2c_driver = {
 705         .id_table = tpm_tis_i2c_table,
 706         .probe = tpm_tis_i2c_probe,
 707         .remove = tpm_tis_i2c_remove,
 708         .driver = {
 709                    .name = "tpm_i2c_infineon",
 710                    .pm = &tpm_tis_i2c_ops,
 711                    .of_match_table = of_match_ptr(tpm_tis_i2c_of_match),
 712                    },
 713 };
 714
 715 module_i2c_driver(tpm_tis_i2c_driver);
 716 MODULE_AUTHOR("Peter Huewe <peter.huewe@infineon.com>");
 717 MODULE_DESCRIPTION("TPM TIS I2C Infineon Driver");
 718 MODULE_VERSION("2.2.0");
 719 MODULE_LICENSE("GPL");