drivers/char/tpm/tpm_i2c_nuvoton.c

   1  /******************************************************************************
   2  * Nuvoton TPM I2C Device Driver Interface for WPCT301/NPCT501/NPCT6XX,
   3  * based on the TCG TPM Interface Spec version 1.2.
   4  * Specifications at www.trustedcomputinggroup.org
   5  *
   6  * Copyright (C) 2011, Nuvoton Technology Corporation.
   7  *  Dan Morav <dan.morav@nuvoton.com>
   8  * Copyright (C) 2013, Obsidian Research Corp.
   9  *  Jason Gunthorpe <jgunthorpe@obsidianresearch.com>
  10  *
  11  * This program is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation, either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program.  If not, see http://www.gnu.org/licenses/>.
  23  *
  24  * Nuvoton contact information: APC.Support@nuvoton.com
  25  *****************************************************************************/
  26
  27 #include <linux/init.h>
  28 #include <linux/module.h>
  29 #include <linux/moduleparam.h>
  30 #include <linux/slab.h>
  31 #include <linux/interrupt.h>
  32 #include <linux/wait.h>
  33 #include <linux/i2c.h>
  34 #include <linux/of_device.h>
  35 #include "tpm.h"
  36
  37 /* I2C interface offsets */
  38 #define TPM_STS                 0x00
  39 #define TPM_BURST_COUNT         0x01
  40 #define TPM_DATA_FIFO_W         0x20
  41 #define TPM_DATA_FIFO_R         0x40
  42 #define TPM_VID_DID_RID         0x60
  43 #define TPM_I2C_RETRIES         5
  44 /*
  45  * I2C bus device maximum buffer size w/o counting I2C address or command
  46  * i.e. max size required for I2C write is 34 = addr, command, 32 bytes data
  47  */
  48 #define TPM_I2C_MAX_BUF_SIZE           32
  49 #define TPM_I2C_RETRY_COUNT            32
  50 #define TPM_I2C_BUS_DELAY              1000             /* usec */
  51 #define TPM_I2C_RETRY_DELAY_SHORT      (2 * 1000)       /* usec */
  52 #define TPM_I2C_RETRY_DELAY_LONG       (10 * 1000)      /* usec */
  53 #define TPM_I2C_DELAY_RANGE            300              /* usec */
  54
  55 #define OF_IS_TPM2 ((void *)1)
  56 #define I2C_IS_TPM2 1
  57
  58 struct priv_data {
  59         int irq;
  60         unsigned int intrs;
  61         wait_queue_head_t read_queue;
  62 };
  63
  64 static s32 i2c_nuvoton_read_buf(struct i2c_client *client, u8 offset, u8 size,
  65                                 u8 *data)
  66 {
  67         s32 status;
  68
  69         status = i2c_smbus_read_i2c_block_data(client, offset, size, data);
  70         dev_dbg(&client->dev,
  71                 "%s(offset=%u size=%u data=%*ph) -> sts=%d\n", __func__,
  72                 offset, size, (int)size, data, status);
  73         return status;
  74 }
  75
  76 static s32 i2c_nuvoton_write_buf(struct i2c_client *client, u8 offset, u8 size,
  77                                  u8 *data)
  78 {
  79         s32 status;
  80
  81         status = i2c_smbus_write_i2c_block_data(client, offset, size, data);
  82         dev_dbg(&client->dev,
  83                 "%s(offset=%u size=%u data=%*ph) -> sts=%d\n", __func__,
  84                 offset, size, (int)size, data, status);
  85         return status;
  86 }
  87
  88 #define TPM_STS_VALID          0x80
  89 #define TPM_STS_COMMAND_READY  0x40
  90 #define TPM_STS_GO             0x20
  91 #define TPM_STS_DATA_AVAIL     0x10
  92 #define TPM_STS_EXPECT         0x08
  93 #define TPM_STS_RESPONSE_RETRY 0x02
  94 #define TPM_STS_ERR_VAL        0x07    /* bit2...bit0 reads always 0 */
  95
  96 #define TPM_I2C_SHORT_TIMEOUT  750     /* ms */
  97 #define TPM_I2C_LONG_TIMEOUT   2000    /* 2 sec */
  98
  99 /* read TPM_STS register */
 100 static u8 i2c_nuvoton_read_status(struct tpm_chip *chip)
 101 {
 102         struct i2c_client *client = to_i2c_client(chip->dev.parent);
 103         s32 status;
 104         u8 data;
 105
 106         status = i2c_nuvoton_read_buf(client, TPM_STS, 1, &data);
 107         if (status <= 0) {
 108                 dev_err(&chip->dev, "%s() error return %d\n", __func__,
 109                         status);
 110                 data = TPM_STS_ERR_VAL;
 111         }
 112
 113         return data;
 114 }
 115
 116 /* write byte to TPM_STS register */
 117 static s32 i2c_nuvoton_write_status(struct i2c_client *client, u8 data)
 118 {
 119         s32 status;
 120         int i;
 121
 122         /* this causes the current command to be aborted */
 123         for (i = 0, status = -1; i < TPM_I2C_RETRY_COUNT && status < 0; i++) {
 124                 status = i2c_nuvoton_write_buf(client, TPM_STS, 1, &data);
 125                 if (status < 0)
 126                         usleep_range(TPM_I2C_BUS_DELAY, TPM_I2C_BUS_DELAY
 127                                      + TPM_I2C_DELAY_RANGE);
 128         }
 129         return status;
 130 }
 131
 132 /* write commandReady to TPM_STS register */
 133 static void i2c_nuvoton_ready(struct tpm_chip *chip)
 134 {
 135         struct i2c_client *client = to_i2c_client(chip->dev.parent);
 136         s32 status;
 137
 138         /* this causes the current command to be aborted */
 139         status = i2c_nuvoton_write_status(client, TPM_STS_COMMAND_READY);
 140         if (status < 0)
 141                 dev_err(&chip->dev,
 142                         "%s() fail to write TPM_STS.commandReady\n", __func__);
 143 }
 144
 145 /* read burstCount field from TPM_STS register
 146  * return -1 on fail to read */
 147 static int i2c_nuvoton_get_burstcount(struct i2c_client *client,
 148                                       struct tpm_chip *chip)
 149 {
 150         unsigned long stop = jiffies + chip->timeout_d;
 151         s32 status;
 152         int burst_count = -1;
 153         u8 data;
 154
 155         /* wait for burstcount to be non-zero */
 156         do {
 157                 /* in I2C burstCount is 1 byte */
 158                 status = i2c_nuvoton_read_buf(client, TPM_BURST_COUNT, 1,
 159                                               &data);
 160                 if (status > 0 && data > 0) {
 161                         burst_count = min_t(u8, TPM_I2C_MAX_BUF_SIZE, data);
 162                         break;
 163                 }
 164                 usleep_range(TPM_I2C_BUS_DELAY, TPM_I2C_BUS_DELAY
 165                              + TPM_I2C_DELAY_RANGE);
 166         } while (time_before(jiffies, stop));
 167
 168         return burst_count;
 169 }
 170
 171 /*
 172  * WPCT301/NPCT501/NPCT6XX SINT# supports only dataAvail
 173  * any call to this function which is not waiting for dataAvail will
 174  * set queue to NULL to avoid waiting for interrupt
 175  */
 176 static bool i2c_nuvoton_check_status(struct tpm_chip *chip, u8 mask, u8 value)
 177 {
 178         u8 status = i2c_nuvoton_read_status(chip);
 179         return (status != TPM_STS_ERR_VAL) && ((status & mask) == value);
 180 }
 181
 182 static int i2c_nuvoton_wait_for_stat(struct tpm_chip *chip, u8 mask, u8 value,
 183                                      u32 timeout, wait_queue_head_t *queue)
 184 {
 185         if ((chip->flags & TPM_CHIP_FLAG_IRQ) && queue) {
 186                 s32 rc;
 187                 struct priv_data *priv = dev_get_drvdata(&chip->dev);
 188                 unsigned int cur_intrs = priv->intrs;
 189
 190                 enable_irq(priv->irq);
 191                 rc = wait_event_interruptible_timeout(*queue,
 192                                                       cur_intrs != priv->intrs,
 193                                                       timeout);
 194                 if (rc > 0)
 195                         return 0;
 196                 /* At this point we know that the SINT pin is asserted, so we
 197                  * do not need to do i2c_nuvoton_check_status */
 198         } else {
 199                 unsigned long ten_msec, stop;
 200                 bool status_valid;
 201
 202                 /* check current status */
 203                 status_valid = i2c_nuvoton_check_status(chip, mask, value);
 204                 if (status_valid)
 205                         return 0;
 206
 207                 /* use polling to wait for the event */
 208                 ten_msec = jiffies + usecs_to_jiffies(TPM_I2C_RETRY_DELAY_LONG);
 209                 stop = jiffies + timeout;
 210                 do {
 211                         if (time_before(jiffies, ten_msec))
 212                                 usleep_range(TPM_I2C_RETRY_DELAY_SHORT,
 213                                              TPM_I2C_RETRY_DELAY_SHORT
 214                                              + TPM_I2C_DELAY_RANGE);
 215                         else
 216                                 usleep_range(TPM_I2C_RETRY_DELAY_LONG,
 217                                              TPM_I2C_RETRY_DELAY_LONG
 218                                              + TPM_I2C_DELAY_RANGE);
 219                         status_valid = i2c_nuvoton_check_status(chip, mask,
 220                                                                 value);
 221                         if (status_valid)
 222                                 return 0;
 223                 } while (time_before(jiffies, stop));
 224         }
 225         dev_err(&chip->dev, "%s(%02x, %02x) -> timeout\n", __func__, mask,
 226                 value);
 227         return -ETIMEDOUT;
 228 }
 229
 230 /* wait for dataAvail field to be set in the TPM_STS register */
 231 static int i2c_nuvoton_wait_for_data_avail(struct tpm_chip *chip, u32 timeout,
 232                                            wait_queue_head_t *queue)
 233 {
 234         return i2c_nuvoton_wait_for_stat(chip,
 235                                          TPM_STS_DATA_AVAIL | TPM_STS_VALID,
 236                                          TPM_STS_DATA_AVAIL | TPM_STS_VALID,
 237                                          timeout, queue);
 238 }
 239
 240 /* Read @count bytes into @buf from TPM_RD_FIFO register */
 241 static int i2c_nuvoton_recv_data(struct i2c_client *client,
 242                                  struct tpm_chip *chip, u8 *buf, size_t count)
 243 {
 244         struct priv_data *priv = dev_get_drvdata(&chip->dev);
 245         s32 rc;
 246         int burst_count, bytes2read, size = 0;
 247
 248         while (size < count &&
 249                i2c_nuvoton_wait_for_data_avail(chip,
 250                                                chip->timeout_c,
 251                                                &priv->read_queue) == 0) {
 252                 burst_count = i2c_nuvoton_get_burstcount(client, chip);
 253                 if (burst_count < 0) {
 254                         dev_err(&chip->dev,
 255                                 "%s() fail to read burstCount=%d\n", __func__,
 256                                 burst_count);
 257                         return -EIO;
 258                 }
 259                 bytes2read = min_t(size_t, burst_count, count - size);
 260                 rc = i2c_nuvoton_read_buf(client, TPM_DATA_FIFO_R,
 261                                           bytes2read, &buf[size]);
 262                 if (rc < 0) {
 263                         dev_err(&chip->dev,
 264                                 "%s() fail on i2c_nuvoton_read_buf()=%d\n",
 265                                 __func__, rc);
 266                         return -EIO;
 267                 }
 268                 dev_dbg(&chip->dev, "%s(%d):", __func__, bytes2read);
 269                 size += bytes2read;
 270         }
 271
 272         return size;
 273 }
 274
 275 /* Read TPM command results */
 276 static int i2c_nuvoton_recv(struct tpm_chip *chip, u8 *buf, size_t count)
 277 {
 278         struct priv_data *priv = dev_get_drvdata(&chip->dev);
 279         struct device *dev = chip->dev.parent;
 280         struct i2c_client *client = to_i2c_client(dev);
 281         s32 rc;
 282         int status;
 283         int burst_count;
 284         int retries;
 285         int size = 0;
 286         u32 expected;
 287
 288         if (count < TPM_HEADER_SIZE) {
 289                 i2c_nuvoton_ready(chip);    /* return to idle */
 290                 dev_err(dev, "%s() count < header size\n", __func__);
 291                 return -EIO;
 292         }
 293         for (retries = 0; retries < TPM_I2C_RETRIES; retries++) {
 294                 if (retries > 0) {
 295                         /* if this is not the first trial, set responseRetry */
 296                         i2c_nuvoton_write_status(client,
 297                                                  TPM_STS_RESPONSE_RETRY);
 298                 }
 299                 /*
 300                  * read first available (> 10 bytes), including:
 301                  * tag, paramsize, and result
 302                  */
 303                 status = i2c_nuvoton_wait_for_data_avail(
 304                         chip, chip->timeout_c, &priv->read_queue);
 305                 if (status != 0) {
 306                         dev_err(dev, "%s() timeout on dataAvail\n", __func__);
 307                         size = -ETIMEDOUT;
 308                         continue;
 309                 }
 310                 burst_count = i2c_nuvoton_get_burstcount(client, chip);
 311                 if (burst_count < 0) {
 312                         dev_err(dev, "%s() fail to get burstCount\n", __func__);
 313                         size = -EIO;
 314                         continue;
 315                 }
 316                 size = i2c_nuvoton_recv_data(client, chip, buf,
 317                                              burst_count);
 318                 if (size < TPM_HEADER_SIZE) {
 319                         dev_err(dev, "%s() fail to read header\n", __func__);
 320                         size = -EIO;
 321                         continue;
 322                 }
 323                 /*
 324                  * convert number of expected bytes field from big endian 32 bit
 325                  * to machine native
 326                  */
 327                 expected = be32_to_cpu(*(__be32 *) (buf + 2));
 328                 if (expected > count || expected < size) {
 329                         dev_err(dev, "%s() expected > count\n", __func__);
 330                         size = -EIO;
 331                         continue;
 332                 }
 333                 rc = i2c_nuvoton_recv_data(client, chip, &buf[size],
 334                                            expected - size);
 335                 size += rc;
 336                 if (rc < 0 || size < expected) {
 337                         dev_err(dev, "%s() fail to read remainder of result\n",
 338                                 __func__);
 339                         size = -EIO;
 340                         continue;
 341                 }
 342                 if (i2c_nuvoton_wait_for_stat(
 343                             chip, TPM_STS_VALID | TPM_STS_DATA_AVAIL,
 344                             TPM_STS_VALID, chip->timeout_c,
 345                             NULL)) {
 346                         dev_err(dev, "%s() error left over data\n", __func__);
 347                         size = -ETIMEDOUT;
 348                         continue;
 349                 }
 350                 break;
 351         }
 352         i2c_nuvoton_ready(chip);
 353         dev_dbg(&chip->dev, "%s() -> %d\n", __func__, size);
 354         return size;
 355 }
 356
 357 /*
 358  * Send TPM command.
 359  *
 360  * If interrupts are used (signaled by an irq set in the vendor structure)
 361  * tpm.c can skip polling for the data to be available as the interrupt is
 362  * waited for here
 363  */
 364 static int i2c_nuvoton_send(struct tpm_chip *chip, u8 *buf, size_t len)
 365 {
 366         struct priv_data *priv = dev_get_drvdata(&chip->dev);
 367         struct device *dev = chip->dev.parent;
 368         struct i2c_client *client = to_i2c_client(dev);
 369         u32 ordinal;
 370         unsigned long duration;
 371         size_t count = 0;
 372         int burst_count, bytes2write, retries, rc = -EIO;
 373
 374         for (retries = 0; retries < TPM_RETRY; retries++) {
 375                 i2c_nuvoton_ready(chip);
 376                 if (i2c_nuvoton_wait_for_stat(chip, TPM_STS_COMMAND_READY,
 377                                               TPM_STS_COMMAND_READY,
 378                                               chip->timeout_b, NULL)) {
 379                         dev_err(dev, "%s() timeout on commandReady\n",
 380                                 __func__);
 381                         rc = -EIO;
 382                         continue;
 383                 }
 384                 rc = 0;
 385                 while (count < len - 1) {
 386                         burst_count = i2c_nuvoton_get_burstcount(client,
 387                                                                  chip);
 388                         if (burst_count < 0) {
 389                                 dev_err(dev, "%s() fail get burstCount\n",
 390                                         __func__);
 391                                 rc = -EIO;
 392                                 break;
 393                         }
 394                         bytes2write = min_t(size_t, burst_count,
 395                                             len - 1 - count);
 396                         rc = i2c_nuvoton_write_buf(client, TPM_DATA_FIFO_W,
 397                                                    bytes2write, &buf[count]);
 398                         if (rc < 0) {
 399                                 dev_err(dev, "%s() fail i2cWriteBuf\n",
 400                                         __func__);
 401                                 break;
 402                         }
 403                         dev_dbg(dev, "%s(%d):", __func__, bytes2write);
 404                         count += bytes2write;
 405                         rc = i2c_nuvoton_wait_for_stat(chip,
 406                                                        TPM_STS_VALID |
 407                                                        TPM_STS_EXPECT,
 408                                                        TPM_STS_VALID |
 409                                                        TPM_STS_EXPECT,
 410                                                        chip->timeout_c,
 411                                                        NULL);
 412                         if (rc < 0) {
 413                                 dev_err(dev, "%s() timeout on Expect\n",
 414                                         __func__);
 415                                 rc = -ETIMEDOUT;
 416                                 break;
 417                         }
 418                 }
 419                 if (rc < 0)
 420                         continue;
 421
 422                 /* write last byte */
 423                 rc = i2c_nuvoton_write_buf(client, TPM_DATA_FIFO_W, 1,
 424                                            &buf[count]);
 425                 if (rc < 0) {
 426                         dev_err(dev, "%s() fail to write last byte\n",
 427                                 __func__);
 428                         rc = -EIO;
 429                         continue;
 430                 }
 431                 dev_dbg(dev, "%s(last): %02x", __func__, buf[count]);
 432                 rc = i2c_nuvoton_wait_for_stat(chip,
 433                                                TPM_STS_VALID | TPM_STS_EXPECT,
 434                                                TPM_STS_VALID,
 435                                                chip->timeout_c, NULL);
 436                 if (rc) {
 437                         dev_err(dev, "%s() timeout on Expect to clear\n",
 438                                 __func__);
 439                         rc = -ETIMEDOUT;
 440                         continue;
 441                 }
 442                 break;
 443         }
 444         if (rc < 0) {
 445                 /* retries == TPM_RETRY */
 446                 i2c_nuvoton_ready(chip);
 447                 return rc;
 448         }
 449         /* execute the TPM command */
 450         rc = i2c_nuvoton_write_status(client, TPM_STS_GO);
 451         if (rc < 0) {
 452                 dev_err(dev, "%s() fail to write Go\n", __func__);
 453                 i2c_nuvoton_ready(chip);
 454                 return rc;
 455         }
 456         ordinal = be32_to_cpu(*((__be32 *) (buf + 6)));
 457         if (chip->flags & TPM_CHIP_FLAG_TPM2)
 458                 duration = tpm2_calc_ordinal_duration(chip, ordinal);
 459         else
 460                 duration = tpm_calc_ordinal_duration(chip, ordinal);
 461
 462         rc = i2c_nuvoton_wait_for_data_avail(chip, duration, &priv->read_queue);
 463         if (rc) {
 464                 dev_err(dev, "%s() timeout command duration\n", __func__);
 465                 i2c_nuvoton_ready(chip);
 466                 return rc;
 467         }
 468
 469         dev_dbg(dev, "%s() -> %zd\n", __func__, len);
 470         return 0;
 471 }
 472
 473 static bool i2c_nuvoton_req_canceled(struct tpm_chip *chip, u8 status)
 474 {
 475         return (status == TPM_STS_COMMAND_READY);
 476 }
 477
 478 static const struct tpm_class_ops tpm_i2c = {
 479         .flags = TPM_OPS_AUTO_STARTUP,
 480         .status = i2c_nuvoton_read_status,
 481         .recv = i2c_nuvoton_recv,
 482         .send = i2c_nuvoton_send,
 483         .cancel = i2c_nuvoton_ready,
 484         .req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
 485         .req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
 486         .req_canceled = i2c_nuvoton_req_canceled,
 487 };
 488
 489 /* The only purpose for the handler is to signal to any waiting threads that
 490  * the interrupt is currently being asserted. The driver does not do any
 491  * processing triggered by interrupts, and the chip provides no way to mask at
 492  * the source (plus that would be slow over I2C). Run the IRQ as a one-shot,
 493  * this means it cannot be shared. */
 494 static irqreturn_t i2c_nuvoton_int_handler(int dummy, void *dev_id)
 495 {
 496         struct tpm_chip *chip = dev_id;
 497         struct priv_data *priv = dev_get_drvdata(&chip->dev);
 498
 499         priv->intrs++;
 500         wake_up(&priv->read_queue);
 501         disable_irq_nosync(priv->irq);
 502         return IRQ_HANDLED;
 503 }
 504
 505 static int get_vid(struct i2c_client *client, u32 *res)
 506 {
 507         static const u8 vid_did_rid_value[] = { 0x50, 0x10, 0xfe };
 508         u32 temp;
 509         s32 rc;
 510
 511         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 512                 return -ENODEV;
 513         rc = i2c_nuvoton_read_buf(client, TPM_VID_DID_RID, 4, (u8 *)&temp);
 514         if (rc < 0)
 515                 return rc;
 516
 517         /* check WPCT301 values - ignore RID */
 518         if (memcmp(&temp, vid_did_rid_value, sizeof(vid_did_rid_value))) {
 519                 /*
 520                  * f/w rev 2.81 has an issue where the VID_DID_RID is not
 521                  * reporting the right value. so give it another chance at
 522                  * offset 0x20 (FIFO_W).
 523                  */
 524                 rc = i2c_nuvoton_read_buf(client, TPM_DATA_FIFO_W, 4,
 525                                           (u8 *) (&temp));
 526                 if (rc < 0)
 527                         return rc;
 528
 529                 /* check WPCT301 values - ignore RID */
 530                 if (memcmp(&temp, vid_did_rid_value,
 531                            sizeof(vid_did_rid_value)))
 532                         return -ENODEV;
 533         }
 534
 535         *res = temp;
 536         return 0;
 537 }
 538
 539 static int i2c_nuvoton_probe(struct i2c_client *client,
 540                              const struct i2c_device_id *id)
 541 {
 542         int rc;
 543         struct tpm_chip *chip;
 544         struct device *dev = &client->dev;
 545         struct priv_data *priv;
 546         u32 vid = 0;
 547
 548         rc = get_vid(client, &vid);
 549         if (rc)
 550                 return rc;
 551
 552         dev_info(dev, "VID: %04X DID: %02X RID: %02X\n", (u16) vid,
 553                  (u8) (vid >> 16), (u8) (vid >> 24));
 554
 555         chip = tpmm_chip_alloc(dev, &tpm_i2c);
 556         if (IS_ERR(chip))
 557                 return PTR_ERR(chip);
 558
 559         priv = devm_kzalloc(dev, sizeof(struct priv_data), GFP_KERNEL);
 560         if (!priv)
 561                 return -ENOMEM;
 562
 563         if (dev->of_node) {
 564                 const struct of_device_id *of_id;
 565
 566                 of_id = of_match_device(dev->driver->of_match_table, dev);
 567                 if (of_id && of_id->data == OF_IS_TPM2)
 568                         chip->flags |= TPM_CHIP_FLAG_TPM2;
 569         } else
 570                 if (id->driver_data == I2C_IS_TPM2)
 571                         chip->flags |= TPM_CHIP_FLAG_TPM2;
 572
 573         init_waitqueue_head(&priv->read_queue);
 574
 575         /* Default timeouts */
 576         chip->timeout_a = msecs_to_jiffies(TPM_I2C_SHORT_TIMEOUT);
 577         chip->timeout_b = msecs_to_jiffies(TPM_I2C_LONG_TIMEOUT);
 578         chip->timeout_c = msecs_to_jiffies(TPM_I2C_SHORT_TIMEOUT);
 579         chip->timeout_d = msecs_to_jiffies(TPM_I2C_SHORT_TIMEOUT);
 580
 581         dev_set_drvdata(&chip->dev, priv);
 582
 583         /*
 584          * I2C intfcaps (interrupt capabilitieis) in the chip are hard coded to:
 585          *   TPM_INTF_INT_LEVEL_LOW | TPM_INTF_DATA_AVAIL_INT
 586          * The IRQ should be set in the i2c_board_info (which is done
 587          * automatically in of_i2c_register_devices, for device tree users */
 588         priv->irq = client->irq;
 589         if (client->irq) {
 590                 dev_dbg(dev, "%s() priv->irq\n", __func__);
 591                 rc = devm_request_irq(dev, client->irq,
 592                                       i2c_nuvoton_int_handler,
 593                                       IRQF_TRIGGER_LOW,
 594                                       dev_name(&chip->dev),
 595                                       chip);
 596                 if (rc) {
 597                         dev_err(dev, "%s() Unable to request irq: %d for use\n",
 598                                 __func__, priv->irq);
 599                         priv->irq = 0;
 600                 } else {
 601                         chip->flags |= TPM_CHIP_FLAG_IRQ;
 602                         /* Clear any pending interrupt */
 603                         i2c_nuvoton_ready(chip);
 604                         /* - wait for TPM_STS==0xA0 (stsValid, commandReady) */
 605                         rc = i2c_nuvoton_wait_for_stat(chip,
 606                                                        TPM_STS_COMMAND_READY,
 607                                                        TPM_STS_COMMAND_READY,
 608                                                        chip->timeout_b,
 609                                                        NULL);
 610                         if (rc == 0) {
 611                                 /*
 612                                  * TIS is in ready state
 613                                  * write dummy byte to enter reception state
 614                                  * TPM_DATA_FIFO_W <- rc (0)
 615                                  */
 616                                 rc = i2c_nuvoton_write_buf(client,
 617                                                            TPM_DATA_FIFO_W,
 618                                                            1, (u8 *) (&rc));
 619                                 if (rc < 0)
 620                                         return rc;
 621                                 /* TPM_STS <- 0x40 (commandReady) */
 622                                 i2c_nuvoton_ready(chip);
 623                         } else {
 624                                 /*
 625                                  * timeout_b reached - command was
 626                                  * aborted. TIS should now be in idle state -
 627                                  * only TPM_STS_VALID should be set
 628                                  */
 629                                 if (i2c_nuvoton_read_status(chip) !=
 630                                     TPM_STS_VALID)
 631                                         return -EIO;
 632                         }
 633                 }
 634         }
 635
 636         return tpm_chip_register(chip);
 637 }
 638
 639 static int i2c_nuvoton_remove(struct i2c_client *client)
 640 {
 641         struct tpm_chip *chip = i2c_get_clientdata(client);
 642
 643         tpm_chip_unregister(chip);
 644         return 0;
 645 }
 646
 647 static const struct i2c_device_id i2c_nuvoton_id[] = {
 648         {"tpm_i2c_nuvoton"},
 649         {"tpm2_i2c_nuvoton", .driver_data = I2C_IS_TPM2},
 650         {}
 651 };
 652 MODULE_DEVICE_TABLE(i2c, i2c_nuvoton_id);
 653
 654 #ifdef CONFIG_OF
 655 static const struct of_device_id i2c_nuvoton_of_match[] = {
 656         {.compatible = "nuvoton,npct501"},
 657         {.compatible = "winbond,wpct301"},
 658         {.compatible = "nuvoton,npct601", .data = OF_IS_TPM2},
 659         {},
 660 };
 661 MODULE_DEVICE_TABLE(of, i2c_nuvoton_of_match);
 662 #endif
 663
 664 static SIMPLE_DEV_PM_OPS(i2c_nuvoton_pm_ops, tpm_pm_suspend, tpm_pm_resume);
 665
 666 static struct i2c_driver i2c_nuvoton_driver = {
 667         .id_table = i2c_nuvoton_id,
 668         .probe = i2c_nuvoton_probe,
 669         .remove = i2c_nuvoton_remove,
 670         .driver = {
 671                 .name = "tpm_i2c_nuvoton",
 672                 .pm = &i2c_nuvoton_pm_ops,
 673                 .of_match_table = of_match_ptr(i2c_nuvoton_of_match),
 674         },
 675 };
 676
 677 module_i2c_driver(i2c_nuvoton_driver);
 678
 679 MODULE_AUTHOR("Dan Morav (dan.morav@nuvoton.com)");
 680 MODULE_DESCRIPTION("Nuvoton TPM I2C Driver");
 681 MODULE_LICENSE("GPL");