linux/drivers/char/tpm/tpm_i2c_infineon.c
<<
>>
Prefs
   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
  61enum i2c_chip_type {
  62        SLB9635,
  63        SLB9645,
  64        UNKNOWN,
  65};
  66
  67/* Structure to store I2C TPM specific stuff */
  68struct 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
  75static 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 */
  96static 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
 158out:
 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
 173static 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 */
 240static 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 * */
 250static 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
 256enum 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
 263enum 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
 271enum 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
 281static 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 */
 300static 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
 313static 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
 334static 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
 351static 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
 358static 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
 382static 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
 405static 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
 437static 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
 475out:
 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
 485static 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;
 554out_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
 564static bool tpm_tis_i2c_req_canceled(struct tpm_chip *chip, u8 status)
 565{
 566        return (status == TPM_STS_COMMAND_READY);
 567}
 568
 569static 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
 578static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL);
 579static DEVICE_ATTR(pcrs, S_IRUGO, tpm_show_pcrs, NULL);
 580static DEVICE_ATTR(enabled, S_IRUGO, tpm_show_enabled, NULL);
 581static DEVICE_ATTR(active, S_IRUGO, tpm_show_active, NULL);
 582static DEVICE_ATTR(owned, S_IRUGO, tpm_show_owned, NULL);
 583static DEVICE_ATTR(temp_deactivated, S_IRUGO, tpm_show_temp_deactivated, NULL);
 584static DEVICE_ATTR(caps, S_IRUGO, tpm_show_caps, NULL);
 585static DEVICE_ATTR(cancel, S_IWUSR | S_IWGRP, NULL, tpm_store_cancel);
 586static DEVICE_ATTR(durations, S_IRUGO, tpm_show_durations, NULL);
 587static DEVICE_ATTR(timeouts, S_IRUGO, tpm_show_timeouts, NULL);
 588
 589static 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
 603static struct attribute_group tis_attr_grp = {
 604        .attrs = tis_attrs
 605};
 606
 607static 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
 619static 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
 674out_release:
 675        release_locality(chip, chip->vendor.locality, 1);
 676
 677out_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;
 688out_err:
 689        return rc;
 690}
 691
 692static const struct i2c_device_id tpm_tis_i2c_table[] = {
 693        {"tpm_i2c_infineon", 0},
 694        {"slb9635tt", 0},
 695        {"slb9645tt", 1},
 696        {},
 697};
 698
 699MODULE_DEVICE_TABLE(i2c, tpm_tis_i2c_table);
 700
 701#ifdef CONFIG_OF
 702static 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};
 723MODULE_DEVICE_TABLE(of, tpm_tis_i2c_of_match);
 724#endif
 725
 726static SIMPLE_DEV_PM_OPS(tpm_tis_i2c_ops, tpm_pm_suspend, tpm_pm_resume);
 727
 728static 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
 753static 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
 772static 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
 784module_i2c_driver(tpm_tis_i2c_driver);
 785MODULE_AUTHOR("Peter Huewe <peter.huewe@infineon.com>");
 786MODULE_DESCRIPTION("TPM TIS I2C Infineon Driver");
 787MODULE_VERSION("2.2.0");
 788MODULE_LICENSE("GPL");
 789