drivers/char/tpm/tpm_i2c_stm_st33.c

   1 /*
   2  * STMicroelectronics TPM I2C Linux driver for TPM ST33ZP24
   3  * Copyright (C) 2009, 2010  STMicroelectronics
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * STMicroelectronics version 1.2.0, Copyright (C) 2010
  20  * STMicroelectronics comes with ABSOLUTELY NO WARRANTY.
  21  * This is free software, and you are welcome to redistribute it
  22  * under certain conditions.
  23  *
  24  * @Author: Christophe RICARD tpmsupport@st.com
  25  *
  26  * @File: tpm_stm_st33_i2c.c
  27  *
  28  * @Synopsis:
  29  *      09/15/2010:     First shot driver tpm_tis driver for
  30                          lpc is used as model.
  31  */
  32
  33 #include <linux/pci.h>
  34 #include <linux/module.h>
  35 #include <linux/platform_device.h>
  36 #include <linux/i2c.h>
  37 #include <linux/fs.h>
  38 #include <linux/miscdevice.h>
  39 #include <linux/kernel.h>
  40 #include <linux/delay.h>
  41 #include <linux/init.h>
  42 #include <linux/wait.h>
  43 #include <linux/string.h>
  44 #include <linux/interrupt.h>
  45 #include <linux/spinlock.h>
  46 #include <linux/sysfs.h>
  47 #include <linux/gpio.h>
  48 #include <linux/sched.h>
  49 #include <linux/uaccess.h>
  50 #include <linux/io.h>
  51 #include <linux/slab.h>
  52
  53 #include "tpm.h"
  54 #include "tpm_i2c_stm_st33.h"
  55
  56 enum stm33zp24_access {
  57         TPM_ACCESS_VALID = 0x80,
  58         TPM_ACCESS_ACTIVE_LOCALITY = 0x20,
  59         TPM_ACCESS_REQUEST_PENDING = 0x04,
  60         TPM_ACCESS_REQUEST_USE = 0x02,
  61 };
  62
  63 enum stm33zp24_status {
  64         TPM_STS_VALID = 0x80,
  65         TPM_STS_COMMAND_READY = 0x40,
  66         TPM_STS_GO = 0x20,
  67         TPM_STS_DATA_AVAIL = 0x10,
  68         TPM_STS_DATA_EXPECT = 0x08,
  69 };
  70
  71 enum stm33zp24_int_flags {
  72         TPM_GLOBAL_INT_ENABLE = 0x80,
  73         TPM_INTF_CMD_READY_INT = 0x080,
  74         TPM_INTF_FIFO_AVALAIBLE_INT = 0x040,
  75         TPM_INTF_WAKE_UP_READY_INT = 0x020,
  76         TPM_INTF_LOCALITY_CHANGE_INT = 0x004,
  77         TPM_INTF_STS_VALID_INT = 0x002,
  78         TPM_INTF_DATA_AVAIL_INT = 0x001,
  79 };
  80
  81 enum tis_defaults {
  82         TIS_SHORT_TIMEOUT = 750,
  83         TIS_LONG_TIMEOUT = 2000,
  84 };
  85
  86 /*
  87  * write8_reg
  88  * Send byte to the TIS register according to the ST33ZP24 I2C protocol.
  89  * @param: tpm_register, the tpm tis register where the data should be written
  90  * @param: tpm_data, the tpm_data to write inside the tpm_register
  91  * @param: tpm_size, The length of the data
  92  * @return: Returns negative errno, or else the number of bytes written.
  93  */
  94 static int write8_reg(struct i2c_client *client, u8 tpm_register,
  95                       u8 *tpm_data, u16 tpm_size)
  96 {
  97         struct st33zp24_platform_data *pin_infos;
  98
  99         pin_infos = client->dev.platform_data;
 100
 101         pin_infos->tpm_i2c_buffer[0][0] = tpm_register;
 102         memcpy(&pin_infos->tpm_i2c_buffer[0][1], tpm_data, tpm_size);
 103         return i2c_master_send(client, pin_infos->tpm_i2c_buffer[0],
 104                                 tpm_size + 1);
 105 } /* write8_reg() */
 106
 107 /*
 108  * read8_reg
 109  * Recv byte from the TIS register according to the ST33ZP24 I2C protocol.
 110  * @param: tpm_register, the tpm tis register where the data should be read
 111  * @param: tpm_data, the TPM response
 112  * @param: tpm_size, tpm TPM response size to read.
 113  * @return: number of byte read successfully: should be one if success.
 114  */
 115 static int read8_reg(struct i2c_client *client, u8 tpm_register,
 116                     u8 *tpm_data, int tpm_size)
 117 {
 118         u8 status = 0;
 119         u8 data;
 120
 121         data = TPM_DUMMY_BYTE;
 122         status = write8_reg(client, tpm_register, &data, 1);
 123         if (status == 2)
 124                 status = i2c_master_recv(client, tpm_data, tpm_size);
 125         return status;
 126 } /* read8_reg() */
 127
 128 /*
 129  * I2C_WRITE_DATA
 130  * Send byte to the TIS register according to the ST33ZP24 I2C protocol.
 131  * @param: client, the chip description
 132  * @param: tpm_register, the tpm tis register where the data should be written
 133  * @param: tpm_data, the tpm_data to write inside the tpm_register
 134  * @param: tpm_size, The length of the data
 135  * @return: number of byte written successfully: should be one if success.
 136  */
 137 #define I2C_WRITE_DATA(client, tpm_register, tpm_data, tpm_size) \
 138         (write8_reg(client, tpm_register | \
 139         TPM_WRITE_DIRECTION, tpm_data, tpm_size))
 140
 141 /*
 142  * I2C_READ_DATA
 143  * Recv byte from the TIS register according to the ST33ZP24 I2C protocol.
 144  * @param: tpm, the chip description
 145  * @param: tpm_register, the tpm tis register where the data should be read
 146  * @param: tpm_data, the TPM response
 147  * @param: tpm_size, tpm TPM response size to read.
 148  * @return: number of byte read successfully: should be one if success.
 149  */
 150 #define I2C_READ_DATA(client, tpm_register, tpm_data, tpm_size) \
 151         (read8_reg(client, tpm_register, tpm_data, tpm_size))
 152
 153 /*
 154  * clear_interruption
 155  * clear the TPM interrupt register.
 156  * @param: tpm, the chip description
 157  */
 158 static void clear_interruption(struct i2c_client *client)
 159 {
 160         u8 interrupt;
 161         I2C_READ_DATA(client, TPM_INT_STATUS, &interrupt, 1);
 162         I2C_WRITE_DATA(client, TPM_INT_STATUS, &interrupt, 1);
 163         I2C_READ_DATA(client, TPM_INT_STATUS, &interrupt, 1);
 164 } /* clear_interruption() */
 165
 166 /*
 167  * _wait_for_interrupt_serirq_timeout
 168  * @param: tpm, the chip description
 169  * @param: timeout, the timeout of the interrupt
 170  * @return: the status of the interruption.
 171  */
 172 static long _wait_for_interrupt_serirq_timeout(struct tpm_chip *chip,
 173                                                 unsigned long timeout)
 174 {
 175         long status;
 176         struct i2c_client *client;
 177         struct st33zp24_platform_data *pin_infos;
 178
 179         client = (struct i2c_client *)TPM_VPRIV(chip);
 180         pin_infos = client->dev.platform_data;
 181
 182         status = wait_for_completion_interruptible_timeout(
 183                                         &pin_infos->irq_detection,
 184                                                 timeout);
 185         if (status > 0)
 186                 enable_irq(gpio_to_irq(pin_infos->io_serirq));
 187         gpio_direction_input(pin_infos->io_serirq);
 188
 189         return status;
 190 } /* wait_for_interrupt_serirq_timeout() */
 191
 192 static int wait_for_serirq_timeout(struct tpm_chip *chip, bool condition,
 193                                  unsigned long timeout)
 194 {
 195         int status = 2;
 196         struct i2c_client *client;
 197
 198         client = (struct i2c_client *)TPM_VPRIV(chip);
 199
 200         status = _wait_for_interrupt_serirq_timeout(chip, timeout);
 201         if (!status) {
 202                 status = -EBUSY;
 203         } else {
 204                 clear_interruption(client);
 205                 if (condition)
 206                         status = 1;
 207         }
 208         return status;
 209 }
 210
 211 /*
 212  * tpm_stm_i2c_cancel, cancel is not implemented.
 213  * @param: chip, the tpm_chip description as specified in driver/char/tpm/tpm.h
 214  */
 215 static void tpm_stm_i2c_cancel(struct tpm_chip *chip)
 216 {
 217         struct i2c_client *client;
 218         u8 data;
 219
 220         client = (struct i2c_client *)TPM_VPRIV(chip);
 221
 222         data = TPM_STS_COMMAND_READY;
 223         I2C_WRITE_DATA(client, TPM_STS, &data, 1);
 224         if (chip->vendor.irq)
 225                 wait_for_serirq_timeout(chip, 1, chip->vendor.timeout_a);
 226 }       /* tpm_stm_i2c_cancel() */
 227
 228 /*
 229  * tpm_stm_spi_status return the TPM_STS register
 230  * @param: chip, the tpm chip description
 231  * @return: the TPM_STS register value.
 232  */
 233 static u8 tpm_stm_i2c_status(struct tpm_chip *chip)
 234 {
 235         struct i2c_client *client;
 236         u8 data;
 237         client = (struct i2c_client *)TPM_VPRIV(chip);
 238
 239         I2C_READ_DATA(client, TPM_STS, &data, 1);
 240         return data;
 241 }                               /* tpm_stm_i2c_status() */
 242
 243
 244 /*
 245  * check_locality if the locality is active
 246  * @param: chip, the tpm chip description
 247  * @return: the active locality or -EACCESS.
 248  */
 249 static int check_locality(struct tpm_chip *chip)
 250 {
 251         struct i2c_client *client;
 252         u8 data;
 253         u8 status;
 254
 255         client = (struct i2c_client *)TPM_VPRIV(chip);
 256
 257         status = I2C_READ_DATA(client, TPM_ACCESS, &data, 1);
 258         if (status && (data &
 259                 (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) ==
 260                 (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID))
 261                 return chip->vendor.locality;
 262
 263         return -EACCES;
 264
 265 } /* check_locality() */
 266
 267 /*
 268  * request_locality request the TPM locality
 269  * @param: chip, the chip description
 270  * @return: the active locality or EACCESS.
 271  */
 272 static int request_locality(struct tpm_chip *chip)
 273 {
 274         unsigned long stop;
 275         long rc;
 276         struct i2c_client *client;
 277         u8 data;
 278
 279         client = (struct i2c_client *)TPM_VPRIV(chip);
 280
 281         if (check_locality(chip) == chip->vendor.locality)
 282                 return chip->vendor.locality;
 283
 284         data = TPM_ACCESS_REQUEST_USE;
 285         rc = I2C_WRITE_DATA(client, TPM_ACCESS, &data, 1);
 286         if (rc < 0)
 287                 goto end;
 288
 289         if (chip->vendor.irq) {
 290                 rc = wait_for_serirq_timeout(chip, (check_locality
 291                                                        (chip) >= 0),
 292                                                       chip->vendor.timeout_a);
 293                 if (rc > 0)
 294                         return chip->vendor.locality;
 295         } else {
 296                 stop = jiffies + chip->vendor.timeout_a;
 297                 do {
 298                         if (check_locality(chip) >= 0)
 299                                 return chip->vendor.locality;
 300                         msleep(TPM_TIMEOUT);
 301                 } while (time_before(jiffies, stop));
 302         }
 303         rc = -EACCES;
 304 end:
 305         return rc;
 306 } /* request_locality() */
 307
 308 /*
 309  * release_locality release the active locality
 310  * @param: chip, the tpm chip description.
 311  */
 312 static void release_locality(struct tpm_chip *chip)
 313 {
 314         struct i2c_client *client;
 315         u8 data;
 316
 317         client = (struct i2c_client *)TPM_VPRIV(chip);
 318         data = TPM_ACCESS_ACTIVE_LOCALITY;
 319
 320         I2C_WRITE_DATA(client, TPM_ACCESS, &data, 1);
 321 }
 322
 323 /*
 324  * get_burstcount return the burstcount address 0x19 0x1A
 325  * @param: chip, the chip description
 326  * return: the burstcount.
 327  */
 328 static int get_burstcount(struct tpm_chip *chip)
 329 {
 330         unsigned long stop;
 331         int burstcnt, status;
 332         u8 tpm_reg, temp;
 333
 334         struct i2c_client *client = (struct i2c_client *)TPM_VPRIV(chip);
 335
 336         stop = jiffies + chip->vendor.timeout_d;
 337         do {
 338                 tpm_reg = TPM_STS + 1;
 339                 status = I2C_READ_DATA(client, tpm_reg, &temp, 1);
 340                 if (status < 0)
 341                         goto end;
 342
 343                 tpm_reg = tpm_reg + 1;
 344                 burstcnt = temp;
 345                 status = I2C_READ_DATA(client, tpm_reg, &temp, 1);
 346                 if (status < 0)
 347                         goto end;
 348
 349                 burstcnt |= temp << 8;
 350                 if (burstcnt)
 351                         return burstcnt;
 352                 msleep(TPM_TIMEOUT);
 353         } while (time_before(jiffies, stop));
 354
 355 end:
 356         return -EBUSY;
 357 } /* get_burstcount() */
 358
 359 /*
 360  * wait_for_stat wait for a TPM_STS value
 361  * @param: chip, the tpm chip description
 362  * @param: mask, the value mask to wait
 363  * @param: timeout, the timeout
 364  * @param: queue, the wait queue.
 365  * @return: the tpm status, 0 if success, -ETIME if timeout is reached.
 366  */
 367 static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout,
 368                          wait_queue_head_t *queue)
 369 {
 370         unsigned long stop;
 371         long rc;
 372         u8 status;
 373
 374          if (chip->vendor.irq) {
 375                 rc = wait_for_serirq_timeout(chip, ((tpm_stm_i2c_status
 376                                                         (chip) & mask) ==
 377                                                        mask), timeout);
 378                 if (rc > 0)
 379                         return 0;
 380         } else {
 381                 stop = jiffies + timeout;
 382                 do {
 383                         msleep(TPM_TIMEOUT);
 384                         status = tpm_stm_i2c_status(chip);
 385                         if ((status & mask) == mask)
 386                                 return 0;
 387                 } while (time_before(jiffies, stop));
 388         }
 389         return -ETIME;
 390 } /* wait_for_stat() */
 391
 392 /*
 393  * recv_data receive data
 394  * @param: chip, the tpm chip description
 395  * @param: buf, the buffer where the data are received
 396  * @param: count, the number of data to receive
 397  * @return: the number of bytes read from TPM FIFO.
 398  */
 399 static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
 400 {
 401         int size = 0, burstcnt, len;
 402         struct i2c_client *client;
 403
 404         client = (struct i2c_client *)TPM_VPRIV(chip);
 405
 406         while (size < count &&
 407                wait_for_stat(chip,
 408                              TPM_STS_DATA_AVAIL | TPM_STS_VALID,
 409                              chip->vendor.timeout_c,
 410                              &chip->vendor.read_queue)
 411                == 0) {
 412                 burstcnt = get_burstcount(chip);
 413                 len = min_t(int, burstcnt, count - size);
 414                 I2C_READ_DATA(client, TPM_DATA_FIFO, buf + size, len);
 415                 size += len;
 416         }
 417         return size;
 418 }
 419
 420 /*
 421  * tpm_ioserirq_handler the serirq irq handler
 422  * @param: irq, the tpm chip description
 423  * @param: dev_id, the description of the chip
 424  * @return: the status of the handler.
 425  */
 426 static irqreturn_t tpm_ioserirq_handler(int irq, void *dev_id)
 427 {
 428         struct tpm_chip *chip = dev_id;
 429         struct i2c_client *client;
 430         struct st33zp24_platform_data *pin_infos;
 431
 432         disable_irq_nosync(irq);
 433
 434         client = (struct i2c_client *)TPM_VPRIV(chip);
 435         pin_infos = client->dev.platform_data;
 436
 437         complete(&pin_infos->irq_detection);
 438         return IRQ_HANDLED;
 439 } /* tpm_ioserirq_handler() */
 440
 441
 442 /*
 443  * tpm_stm_i2c_send send TPM commands through the I2C bus.
 444  *
 445  * @param: chip, the tpm_chip description as specified in driver/char/tpm/tpm.h
 446  * @param: buf, the buffer to send.
 447  * @param: count, the number of bytes to send.
 448  * @return: In case of success the number of bytes sent.
 449  *                      In other case, a < 0 value describing the issue.
 450  */
 451 static int tpm_stm_i2c_send(struct tpm_chip *chip, unsigned char *buf,
 452                             size_t len)
 453 {
 454         u32 status, burstcnt = 0, i, size;
 455         int ret;
 456         u8 data;
 457         struct i2c_client *client;
 458
 459         if (chip == NULL)
 460                 return -EBUSY;
 461         if (len < TPM_HEADER_SIZE)
 462                 return -EBUSY;
 463
 464         client = (struct i2c_client *)TPM_VPRIV(chip);
 465
 466         client->flags = 0;
 467
 468         ret = request_locality(chip);
 469         if (ret < 0)
 470                 return ret;
 471
 472         status = tpm_stm_i2c_status(chip);
 473         if ((status & TPM_STS_COMMAND_READY) == 0) {
 474                 tpm_stm_i2c_cancel(chip);
 475                 if (wait_for_stat
 476                     (chip, TPM_STS_COMMAND_READY, chip->vendor.timeout_b,
 477                      &chip->vendor.int_queue) < 0) {
 478                         ret = -ETIME;
 479                         goto out_err;
 480                 }
 481         }
 482
 483         for (i = 0; i < len - 1;) {
 484                 burstcnt = get_burstcount(chip);
 485                 size = min_t(int, len - i - 1, burstcnt);
 486                 ret = I2C_WRITE_DATA(client, TPM_DATA_FIFO, buf, size);
 487                 if (ret < 0)
 488                         goto out_err;
 489
 490                 i += size;
 491         }
 492
 493         status = tpm_stm_i2c_status(chip);
 494         if ((status & TPM_STS_DATA_EXPECT) == 0) {
 495                 ret = -EIO;
 496                 goto out_err;
 497         }
 498
 499         ret = I2C_WRITE_DATA(client, TPM_DATA_FIFO, buf + len - 1, 1);
 500         if (ret < 0)
 501                 goto out_err;
 502
 503         status = tpm_stm_i2c_status(chip);
 504         if ((status & TPM_STS_DATA_EXPECT) != 0) {
 505                 ret = -EIO;
 506                 goto out_err;
 507         }
 508
 509         data = TPM_STS_GO;
 510         I2C_WRITE_DATA(client, TPM_STS, &data, 1);
 511
 512         return len;
 513 out_err:
 514         tpm_stm_i2c_cancel(chip);
 515         release_locality(chip);
 516         return ret;
 517 }
 518
 519 /*
 520  * tpm_stm_i2c_recv received TPM response through the I2C bus.
 521  * @param: chip, the tpm_chip description as specified in driver/char/tpm/tpm.h.
 522  * @param: buf, the buffer to store datas.
 523  * @param: count, the number of bytes to send.
 524  * @return: In case of success the number of bytes received.
 525  *              In other case, a < 0 value describing the issue.
 526  */
 527 static int tpm_stm_i2c_recv(struct tpm_chip *chip, unsigned char *buf,
 528                             size_t count)
 529 {
 530         int size = 0;
 531         int expected;
 532
 533         if (chip == NULL)
 534                 return -EBUSY;
 535
 536         if (count < TPM_HEADER_SIZE) {
 537                 size = -EIO;
 538                 goto out;
 539         }
 540
 541         size = recv_data(chip, buf, TPM_HEADER_SIZE);
 542         if (size < TPM_HEADER_SIZE) {
 543                 dev_err(chip->dev, "Unable to read header\n");
 544                 goto out;
 545         }
 546
 547         expected = be32_to_cpu(*(__be32 *)(buf + 2));
 548         if (expected > count) {
 549                 size = -EIO;
 550                 goto out;
 551         }
 552
 553         size += recv_data(chip, &buf[TPM_HEADER_SIZE],
 554                                         expected - TPM_HEADER_SIZE);
 555         if (size < expected) {
 556                 dev_err(chip->dev, "Unable to read remainder of result\n");
 557                 size = -ETIME;
 558                 goto out;
 559         }
 560
 561 out:
 562         chip->vendor.cancel(chip);
 563         release_locality(chip);
 564         return size;
 565 }
 566
 567 static bool tpm_st33_i2c_req_canceled(struct tpm_chip *chip, u8 status)
 568 {
 569         return (status == TPM_STS_COMMAND_READY);
 570 }
 571
 572 static const struct file_operations tpm_st33_i2c_fops = {
 573         .owner = THIS_MODULE,
 574         .llseek = no_llseek,
 575         .read = tpm_read,
 576         .write = tpm_write,
 577         .open = tpm_open,
 578         .release = tpm_release,
 579 };
 580
 581 static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL);
 582 static DEVICE_ATTR(pcrs, S_IRUGO, tpm_show_pcrs, NULL);
 583 static DEVICE_ATTR(enabled, S_IRUGO, tpm_show_enabled, NULL);
 584 static DEVICE_ATTR(active, S_IRUGO, tpm_show_active, NULL);
 585 static DEVICE_ATTR(owned, S_IRUGO, tpm_show_owned, NULL);
 586 static DEVICE_ATTR(temp_deactivated, S_IRUGO, tpm_show_temp_deactivated, NULL);
 587 static DEVICE_ATTR(caps, S_IRUGO, tpm_show_caps_1_2, NULL);
 588 static DEVICE_ATTR(cancel, S_IWUSR | S_IWGRP, NULL, tpm_store_cancel);
 589
 590 static struct attribute *stm_tpm_attrs[] = {
 591         &dev_attr_pubek.attr,
 592         &dev_attr_pcrs.attr,
 593         &dev_attr_enabled.attr,
 594         &dev_attr_active.attr,
 595         &dev_attr_owned.attr,
 596         &dev_attr_temp_deactivated.attr,
 597         &dev_attr_caps.attr,
 598         &dev_attr_cancel.attr, NULL,
 599 };
 600
 601 static struct attribute_group stm_tpm_attr_grp = {
 602         .attrs = stm_tpm_attrs
 603 };
 604
 605 static struct tpm_vendor_specific st_i2c_tpm = {
 606         .send = tpm_stm_i2c_send,
 607         .recv = tpm_stm_i2c_recv,
 608         .cancel = tpm_stm_i2c_cancel,
 609         .status = tpm_stm_i2c_status,
 610         .req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
 611         .req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
 612         .req_canceled = tpm_st33_i2c_req_canceled,
 613         .attr_group = &stm_tpm_attr_grp,
 614         .miscdev = {.fops = &tpm_st33_i2c_fops,},
 615 };
 616
 617 static int interrupts;
 618 module_param(interrupts, int, 0444);
 619 MODULE_PARM_DESC(interrupts, "Enable interrupts");
 620
 621 static int power_mgt = 1;
 622 module_param(power_mgt, int, 0444);
 623 MODULE_PARM_DESC(power_mgt, "Power Management");
 624
 625 /*
 626  * tpm_st33_i2c_probe initialize the TPM device
 627  * @param: client, the i2c_client drescription (TPM I2C description).
 628  * @param: id, the i2c_device_id struct.
 629  * @return: 0 in case of success.
 630  *       -1 in other case.
 631  */
 632 static int
 633 tpm_st33_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
 634 {
 635         int err;
 636         u8 intmask;
 637         struct tpm_chip *chip;
 638         struct st33zp24_platform_data *platform_data;
 639
 640         if (client == NULL) {
 641                 pr_info("%s: i2c client is NULL. Device not accessible.\n",
 642                         __func__);
 643                 err = -ENODEV;
 644                 goto end;
 645         }
 646
 647         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 648                 dev_info(&client->dev, "client not i2c capable\n");
 649                 err = -ENODEV;
 650                 goto end;
 651         }
 652
 653         chip = tpm_register_hardware(&client->dev, &st_i2c_tpm);
 654         if (!chip) {
 655                 dev_info(&client->dev, "fail chip\n");
 656                 err = -ENODEV;
 657                 goto end;
 658         }
 659
 660         platform_data = client->dev.platform_data;
 661
 662         if (!platform_data) {
 663                 dev_info(&client->dev, "chip not available\n");
 664                 err = -ENODEV;
 665                 goto _tpm_clean_answer;
 666         }
 667
 668         platform_data->tpm_i2c_buffer[0] =
 669             kmalloc(TPM_BUFSIZE * sizeof(u8), GFP_KERNEL);
 670         if (platform_data->tpm_i2c_buffer[0] == NULL) {
 671                 err = -ENOMEM;
 672                 goto _tpm_clean_answer;
 673         }
 674         platform_data->tpm_i2c_buffer[1] =
 675             kmalloc(TPM_BUFSIZE * sizeof(u8), GFP_KERNEL);
 676         if (platform_data->tpm_i2c_buffer[1] == NULL) {
 677                 err = -ENOMEM;
 678                 goto _tpm_clean_response1;
 679         }
 680
 681         TPM_VPRIV(chip) = client;
 682
 683         chip->vendor.timeout_a = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
 684         chip->vendor.timeout_b = msecs_to_jiffies(TIS_LONG_TIMEOUT);
 685         chip->vendor.timeout_c = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
 686         chip->vendor.timeout_d = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
 687
 688         chip->vendor.locality = LOCALITY0;
 689
 690         if (power_mgt) {
 691                 err = gpio_request(platform_data->io_lpcpd, "TPM IO_LPCPD");
 692                 if (err)
 693                         goto _gpio_init1;
 694                 gpio_set_value(platform_data->io_lpcpd, 1);
 695         }
 696
 697         if (interrupts) {
 698                 init_completion(&platform_data->irq_detection);
 699                 if (request_locality(chip) != LOCALITY0) {
 700                         err = -ENODEV;
 701                         goto _tpm_clean_response2;
 702                 }
 703                 err = gpio_request(platform_data->io_serirq, "TPM IO_SERIRQ");
 704                 if (err)
 705                         goto _gpio_init2;
 706
 707                 clear_interruption(client);
 708                 err = request_irq(gpio_to_irq(platform_data->io_serirq),
 709                                 &tpm_ioserirq_handler,
 710                                 IRQF_TRIGGER_HIGH,
 711                                 "TPM SERIRQ management", chip);
 712                 if (err < 0) {
 713                         dev_err(chip->dev , "TPM SERIRQ signals %d not available\n",
 714                                 gpio_to_irq(platform_data->io_serirq));
 715                         goto _irq_set;
 716                 }
 717
 718                 err = I2C_READ_DATA(client, TPM_INT_ENABLE, &intmask, 1);
 719                 if (err < 0)
 720                         goto _irq_set;
 721
 722                 intmask |= TPM_INTF_CMD_READY_INT
 723                         |  TPM_INTF_FIFO_AVALAIBLE_INT
 724                         |  TPM_INTF_WAKE_UP_READY_INT
 725                         |  TPM_INTF_LOCALITY_CHANGE_INT
 726                         |  TPM_INTF_STS_VALID_INT
 727                         |  TPM_INTF_DATA_AVAIL_INT;
 728
 729                 err = I2C_WRITE_DATA(client, TPM_INT_ENABLE, &intmask, 1);
 730                 if (err < 0)
 731                         goto _irq_set;
 732
 733                 intmask = TPM_GLOBAL_INT_ENABLE;
 734                 err = I2C_WRITE_DATA(client, (TPM_INT_ENABLE + 3), &intmask, 1);
 735                 if (err < 0)
 736                         goto _irq_set;
 737
 738                 err = I2C_READ_DATA(client, TPM_INT_STATUS, &intmask, 1);
 739                 if (err < 0)
 740                         goto _irq_set;
 741
 742                 chip->vendor.irq = interrupts;
 743
 744                 tpm_gen_interrupt(chip);
 745         }
 746
 747         tpm_get_timeouts(chip);
 748
 749         i2c_set_clientdata(client, chip);
 750
 751         dev_info(chip->dev, "TPM I2C Initialized\n");
 752         return 0;
 753 _irq_set:
 754         free_irq(gpio_to_irq(platform_data->io_serirq), (void *)chip);
 755 _gpio_init2:
 756         if (interrupts)
 757                 gpio_free(platform_data->io_serirq);
 758 _gpio_init1:
 759         if (power_mgt)
 760                 gpio_free(platform_data->io_lpcpd);
 761 _tpm_clean_response2:
 762         kzfree(platform_data->tpm_i2c_buffer[1]);
 763         platform_data->tpm_i2c_buffer[1] = NULL;
 764 _tpm_clean_response1:
 765         kzfree(platform_data->tpm_i2c_buffer[0]);
 766         platform_data->tpm_i2c_buffer[0] = NULL;
 767 _tpm_clean_answer:
 768         tpm_remove_hardware(chip->dev);
 769 end:
 770         pr_info("TPM I2C initialisation fail\n");
 771         return err;
 772 }
 773
 774 /*
 775  * tpm_st33_i2c_remove remove the TPM device
 776  * @param: client, the i2c_client drescription (TPM I2C description).
 777                 clear_bit(0, &chip->is_open);
 778  * @return: 0 in case of success.
 779  */
 780 static int tpm_st33_i2c_remove(struct i2c_client *client)
 781 {
 782         struct tpm_chip *chip = (struct tpm_chip *)i2c_get_clientdata(client);
 783         struct st33zp24_platform_data *pin_infos =
 784                 ((struct i2c_client *)TPM_VPRIV(chip))->dev.platform_data;
 785
 786         if (pin_infos != NULL) {
 787                 free_irq(pin_infos->io_serirq, chip);
 788
 789                 gpio_free(pin_infos->io_serirq);
 790                 gpio_free(pin_infos->io_lpcpd);
 791
 792                 tpm_remove_hardware(chip->dev);
 793
 794                 if (pin_infos->tpm_i2c_buffer[1] != NULL) {
 795                         kzfree(pin_infos->tpm_i2c_buffer[1]);
 796                         pin_infos->tpm_i2c_buffer[1] = NULL;
 797                 }
 798                 if (pin_infos->tpm_i2c_buffer[0] != NULL) {
 799                         kzfree(pin_infos->tpm_i2c_buffer[0]);
 800                         pin_infos->tpm_i2c_buffer[0] = NULL;
 801                 }
 802         }
 803
 804         return 0;
 805 }
 806
 807 #ifdef CONFIG_PM_SLEEP
 808 /*
 809  * tpm_st33_i2c_pm_suspend suspend the TPM device
 810  * Added: Work around when suspend and no tpm application is running, suspend
 811  * may fail because chip->data_buffer is not set (only set in tpm_open in Linux
 812  * TPM core)
 813  * @param: client, the i2c_client drescription (TPM I2C description).
 814  * @param: mesg, the power management message.
 815  * @return: 0 in case of success.
 816  */
 817 static int tpm_st33_i2c_pm_suspend(struct device *dev)
 818 {
 819         struct tpm_chip *chip = dev_get_drvdata(dev);
 820         struct st33zp24_platform_data *pin_infos = dev->platform_data;
 821         int ret = 0;
 822
 823         if (power_mgt) {
 824                 gpio_set_value(pin_infos->io_lpcpd, 0);
 825         } else {
 826                 if (chip->data_buffer == NULL)
 827                         chip->data_buffer = pin_infos->tpm_i2c_buffer[0];
 828                 ret = tpm_pm_suspend(dev);
 829         }
 830         return ret;
 831 }                               /* tpm_st33_i2c_suspend() */
 832
 833 /*
 834  * tpm_st33_i2c_pm_resume resume the TPM device
 835  * @param: client, the i2c_client drescription (TPM I2C description).
 836  * @return: 0 in case of success.
 837  */
 838 static int tpm_st33_i2c_pm_resume(struct device *dev)
 839 {
 840         struct tpm_chip *chip = dev_get_drvdata(dev);
 841         struct st33zp24_platform_data *pin_infos = dev->platform_data;
 842
 843         int ret = 0;
 844
 845         if (power_mgt) {
 846                 gpio_set_value(pin_infos->io_lpcpd, 1);
 847                 ret = wait_for_serirq_timeout(chip,
 848                                           (chip->vendor.status(chip) &
 849                                           TPM_STS_VALID) == TPM_STS_VALID,
 850                                           chip->vendor.timeout_b);
 851         } else {
 852                 if (chip->data_buffer == NULL)
 853                         chip->data_buffer = pin_infos->tpm_i2c_buffer[0];
 854                 ret = tpm_pm_resume(dev);
 855                 if (!ret)
 856                         tpm_do_selftest(chip);
 857         }
 858         return ret;
 859 }                               /* tpm_st33_i2c_pm_resume() */
 860 #endif
 861
 862 static const struct i2c_device_id tpm_st33_i2c_id[] = {
 863         {TPM_ST33_I2C, 0},
 864         {}
 865 };
 866 MODULE_DEVICE_TABLE(i2c, tpm_st33_i2c_id);
 867 static SIMPLE_DEV_PM_OPS(tpm_st33_i2c_ops, tpm_st33_i2c_pm_suspend,
 868         tpm_st33_i2c_pm_resume);
 869 static struct i2c_driver tpm_st33_i2c_driver = {
 870         .driver = {
 871                    .owner = THIS_MODULE,
 872                    .name = TPM_ST33_I2C,
 873                    .pm = &tpm_st33_i2c_ops,
 874                    },
 875         .probe = tpm_st33_i2c_probe,
 876         .remove = tpm_st33_i2c_remove,
 877         .id_table = tpm_st33_i2c_id
 878 };
 879
 880 module_i2c_driver(tpm_st33_i2c_driver);
 881
 882 MODULE_AUTHOR("Christophe Ricard (tpmsupport@st.com)");
 883 MODULE_DESCRIPTION("STM TPM I2C ST33 Driver");
 884 MODULE_VERSION("1.2.0");
 885 MODULE_LICENSE("GPL");