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
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>
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.
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.
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/>.
24 * Nuvoton contact information: APC.Support@nuvoton.com
25 *****************************************************************************/
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>
37 /* I2C interface offsets */
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 /* TPM command header size */
44 #define TPM_HEADER_SIZE 10
47 * I2C bus device maximum buffer size w/o counting I2C address or command
48 * i.e. max size required for I2C write is 34 = addr, command, 32 bytes data
50 #define TPM_I2C_MAX_BUF_SIZE 32
51 #define TPM_I2C_RETRY_COUNT 32
52 #define TPM_I2C_BUS_DELAY 1000 /* usec */
53 #define TPM_I2C_RETRY_DELAY_SHORT (2 * 1000) /* usec */
54 #define TPM_I2C_RETRY_DELAY_LONG (10 * 1000) /* usec */
55 #define TPM_I2C_DELAY_RANGE 300 /* usec */
57 #define OF_IS_TPM2 ((void *)1)
63 wait_queue_head_t read_queue;
66 static s32 i2c_nuvoton_read_buf(struct i2c_client *client, u8 offset, u8 size,
71 status = i2c_smbus_read_i2c_block_data(client, offset, size, data);
73 "%s(offset=%u size=%u data=%*ph) -> sts=%d\n", __func__,
74 offset, size, (int)size, data, status);
78 static s32 i2c_nuvoton_write_buf(struct i2c_client *client, u8 offset, u8 size,
83 status = i2c_smbus_write_i2c_block_data(client, offset, size, data);
85 "%s(offset=%u size=%u data=%*ph) -> sts=%d\n", __func__,
86 offset, size, (int)size, data, status);
90 #define TPM_STS_VALID 0x80
91 #define TPM_STS_COMMAND_READY 0x40
92 #define TPM_STS_GO 0x20
93 #define TPM_STS_DATA_AVAIL 0x10
94 #define TPM_STS_EXPECT 0x08
95 #define TPM_STS_RESPONSE_RETRY 0x02
96 #define TPM_STS_ERR_VAL 0x07 /* bit2...bit0 reads always 0 */
98 #define TPM_I2C_SHORT_TIMEOUT 750 /* ms */
99 #define TPM_I2C_LONG_TIMEOUT 2000 /* 2 sec */
101 /* read TPM_STS register */
102 static u8 i2c_nuvoton_read_status(struct tpm_chip *chip)
104 struct i2c_client *client = to_i2c_client(chip->dev.parent);
108 status = i2c_nuvoton_read_buf(client, TPM_STS, 1, &data);
110 dev_err(&chip->dev, "%s() error return %d\n", __func__,
112 data = TPM_STS_ERR_VAL;
118 /* write byte to TPM_STS register */
119 static s32 i2c_nuvoton_write_status(struct i2c_client *client, u8 data)
124 /* this causes the current command to be aborted */
125 for (i = 0, status = -1; i < TPM_I2C_RETRY_COUNT && status < 0; i++) {
126 status = i2c_nuvoton_write_buf(client, TPM_STS, 1, &data);
128 usleep_range(TPM_I2C_BUS_DELAY, TPM_I2C_BUS_DELAY
129 + TPM_I2C_DELAY_RANGE);
134 /* write commandReady to TPM_STS register */
135 static void i2c_nuvoton_ready(struct tpm_chip *chip)
137 struct i2c_client *client = to_i2c_client(chip->dev.parent);
140 /* this causes the current command to be aborted */
141 status = i2c_nuvoton_write_status(client, TPM_STS_COMMAND_READY);
144 "%s() fail to write TPM_STS.commandReady\n", __func__);
147 /* read burstCount field from TPM_STS register
148 * return -1 on fail to read */
149 static int i2c_nuvoton_get_burstcount(struct i2c_client *client,
150 struct tpm_chip *chip)
152 unsigned long stop = jiffies + chip->timeout_d;
154 int burst_count = -1;
157 /* wait for burstcount to be non-zero */
159 /* in I2C burstCount is 1 byte */
160 status = i2c_nuvoton_read_buf(client, TPM_BURST_COUNT, 1,
162 if (status > 0 && data > 0) {
163 burst_count = min_t(u8, TPM_I2C_MAX_BUF_SIZE, data);
166 usleep_range(TPM_I2C_BUS_DELAY, TPM_I2C_BUS_DELAY
167 + TPM_I2C_DELAY_RANGE);
168 } while (time_before(jiffies, stop));
174 * WPCT301/NPCT501/NPCT6XX SINT# supports only dataAvail
175 * any call to this function which is not waiting for dataAvail will
176 * set queue to NULL to avoid waiting for interrupt
178 static bool i2c_nuvoton_check_status(struct tpm_chip *chip, u8 mask, u8 value)
180 u8 status = i2c_nuvoton_read_status(chip);
181 return (status != TPM_STS_ERR_VAL) && ((status & mask) == value);
184 static int i2c_nuvoton_wait_for_stat(struct tpm_chip *chip, u8 mask, u8 value,
185 u32 timeout, wait_queue_head_t *queue)
187 if ((chip->flags & TPM_CHIP_FLAG_IRQ) && queue) {
189 struct priv_data *priv = dev_get_drvdata(&chip->dev);
190 unsigned int cur_intrs = priv->intrs;
192 enable_irq(priv->irq);
193 rc = wait_event_interruptible_timeout(*queue,
194 cur_intrs != priv->intrs,
198 /* At this point we know that the SINT pin is asserted, so we
199 * do not need to do i2c_nuvoton_check_status */
201 unsigned long ten_msec, stop;
204 /* check current status */
205 status_valid = i2c_nuvoton_check_status(chip, mask, value);
209 /* use polling to wait for the event */
210 ten_msec = jiffies + usecs_to_jiffies(TPM_I2C_RETRY_DELAY_LONG);
211 stop = jiffies + timeout;
213 if (time_before(jiffies, ten_msec))
214 usleep_range(TPM_I2C_RETRY_DELAY_SHORT,
215 TPM_I2C_RETRY_DELAY_SHORT
216 + TPM_I2C_DELAY_RANGE);
218 usleep_range(TPM_I2C_RETRY_DELAY_LONG,
219 TPM_I2C_RETRY_DELAY_LONG
220 + TPM_I2C_DELAY_RANGE);
221 status_valid = i2c_nuvoton_check_status(chip, mask,
225 } while (time_before(jiffies, stop));
227 dev_err(&chip->dev, "%s(%02x, %02x) -> timeout\n", __func__, mask,
232 /* wait for dataAvail field to be set in the TPM_STS register */
233 static int i2c_nuvoton_wait_for_data_avail(struct tpm_chip *chip, u32 timeout,
234 wait_queue_head_t *queue)
236 return i2c_nuvoton_wait_for_stat(chip,
237 TPM_STS_DATA_AVAIL | TPM_STS_VALID,
238 TPM_STS_DATA_AVAIL | TPM_STS_VALID,
242 /* Read @count bytes into @buf from TPM_RD_FIFO register */
243 static int i2c_nuvoton_recv_data(struct i2c_client *client,
244 struct tpm_chip *chip, u8 *buf, size_t count)
246 struct priv_data *priv = dev_get_drvdata(&chip->dev);
248 int burst_count, bytes2read, size = 0;
250 while (size < count &&
251 i2c_nuvoton_wait_for_data_avail(chip,
253 &priv->read_queue) == 0) {
254 burst_count = i2c_nuvoton_get_burstcount(client, chip);
255 if (burst_count < 0) {
257 "%s() fail to read burstCount=%d\n", __func__,
261 bytes2read = min_t(size_t, burst_count, count - size);
262 rc = i2c_nuvoton_read_buf(client, TPM_DATA_FIFO_R,
263 bytes2read, &buf[size]);
266 "%s() fail on i2c_nuvoton_read_buf()=%d\n",
270 dev_dbg(&chip->dev, "%s(%d):", __func__, bytes2read);
277 /* Read TPM command results */
278 static int i2c_nuvoton_recv(struct tpm_chip *chip, u8 *buf, size_t count)
280 struct priv_data *priv = dev_get_drvdata(&chip->dev);
281 struct device *dev = chip->dev.parent;
282 struct i2c_client *client = to_i2c_client(dev);
284 int expected, status, burst_count, retries, size = 0;
286 if (count < TPM_HEADER_SIZE) {
287 i2c_nuvoton_ready(chip); /* return to idle */
288 dev_err(dev, "%s() count < header size\n", __func__);
291 for (retries = 0; retries < TPM_RETRY; retries++) {
293 /* if this is not the first trial, set responseRetry */
294 i2c_nuvoton_write_status(client,
295 TPM_STS_RESPONSE_RETRY);
298 * read first available (> 10 bytes), including:
299 * tag, paramsize, and result
301 status = i2c_nuvoton_wait_for_data_avail(
302 chip, chip->timeout_c, &priv->read_queue);
304 dev_err(dev, "%s() timeout on dataAvail\n", __func__);
308 burst_count = i2c_nuvoton_get_burstcount(client, chip);
309 if (burst_count < 0) {
310 dev_err(dev, "%s() fail to get burstCount\n", __func__);
314 size = i2c_nuvoton_recv_data(client, chip, buf,
316 if (size < TPM_HEADER_SIZE) {
317 dev_err(dev, "%s() fail to read header\n", __func__);
322 * convert number of expected bytes field from big endian 32 bit
325 expected = be32_to_cpu(*(__be32 *) (buf + 2));
326 if (expected > count) {
327 dev_err(dev, "%s() expected > count\n", __func__);
331 rc = i2c_nuvoton_recv_data(client, chip, &buf[size],
334 if (rc < 0 || size < expected) {
335 dev_err(dev, "%s() fail to read remainder of result\n",
340 if (i2c_nuvoton_wait_for_stat(
341 chip, TPM_STS_VALID | TPM_STS_DATA_AVAIL,
342 TPM_STS_VALID, chip->timeout_c,
344 dev_err(dev, "%s() error left over data\n", __func__);
350 i2c_nuvoton_ready(chip);
351 dev_dbg(&chip->dev, "%s() -> %d\n", __func__, size);
358 * If interrupts are used (signaled by an irq set in the vendor structure)
359 * tpm.c can skip polling for the data to be available as the interrupt is
362 static int i2c_nuvoton_send(struct tpm_chip *chip, u8 *buf, size_t len)
364 struct priv_data *priv = dev_get_drvdata(&chip->dev);
365 struct device *dev = chip->dev.parent;
366 struct i2c_client *client = to_i2c_client(dev);
369 int burst_count, bytes2write, retries, rc = -EIO;
371 for (retries = 0; retries < TPM_RETRY; retries++) {
372 i2c_nuvoton_ready(chip);
373 if (i2c_nuvoton_wait_for_stat(chip, TPM_STS_COMMAND_READY,
374 TPM_STS_COMMAND_READY,
375 chip->timeout_b, NULL)) {
376 dev_err(dev, "%s() timeout on commandReady\n",
382 while (count < len - 1) {
383 burst_count = i2c_nuvoton_get_burstcount(client,
385 if (burst_count < 0) {
386 dev_err(dev, "%s() fail get burstCount\n",
391 bytes2write = min_t(size_t, burst_count,
393 rc = i2c_nuvoton_write_buf(client, TPM_DATA_FIFO_W,
394 bytes2write, &buf[count]);
396 dev_err(dev, "%s() fail i2cWriteBuf\n",
400 dev_dbg(dev, "%s(%d):", __func__, bytes2write);
401 count += bytes2write;
402 rc = i2c_nuvoton_wait_for_stat(chip,
410 dev_err(dev, "%s() timeout on Expect\n",
419 /* write last byte */
420 rc = i2c_nuvoton_write_buf(client, TPM_DATA_FIFO_W, 1,
423 dev_err(dev, "%s() fail to write last byte\n",
428 dev_dbg(dev, "%s(last): %02x", __func__, buf[count]);
429 rc = i2c_nuvoton_wait_for_stat(chip,
430 TPM_STS_VALID | TPM_STS_EXPECT,
432 chip->timeout_c, NULL);
434 dev_err(dev, "%s() timeout on Expect to clear\n",
442 /* retries == TPM_RETRY */
443 i2c_nuvoton_ready(chip);
446 /* execute the TPM command */
447 rc = i2c_nuvoton_write_status(client, TPM_STS_GO);
449 dev_err(dev, "%s() fail to write Go\n", __func__);
450 i2c_nuvoton_ready(chip);
453 ordinal = be32_to_cpu(*((__be32 *) (buf + 6)));
454 rc = i2c_nuvoton_wait_for_data_avail(chip,
455 tpm_calc_ordinal_duration(chip,
459 dev_err(dev, "%s() timeout command duration\n", __func__);
460 i2c_nuvoton_ready(chip);
464 dev_dbg(dev, "%s() -> %zd\n", __func__, len);
468 static bool i2c_nuvoton_req_canceled(struct tpm_chip *chip, u8 status)
470 return (status == TPM_STS_COMMAND_READY);
473 static const struct tpm_class_ops tpm_i2c = {
474 .flags = TPM_OPS_AUTO_STARTUP,
475 .status = i2c_nuvoton_read_status,
476 .recv = i2c_nuvoton_recv,
477 .send = i2c_nuvoton_send,
478 .cancel = i2c_nuvoton_ready,
479 .req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
480 .req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
481 .req_canceled = i2c_nuvoton_req_canceled,
484 /* The only purpose for the handler is to signal to any waiting threads that
485 * the interrupt is currently being asserted. The driver does not do any
486 * processing triggered by interrupts, and the chip provides no way to mask at
487 * the source (plus that would be slow over I2C). Run the IRQ as a one-shot,
488 * this means it cannot be shared. */
489 static irqreturn_t i2c_nuvoton_int_handler(int dummy, void *dev_id)
491 struct tpm_chip *chip = dev_id;
492 struct priv_data *priv = dev_get_drvdata(&chip->dev);
495 wake_up(&priv->read_queue);
496 disable_irq_nosync(priv->irq);
500 static int get_vid(struct i2c_client *client, u32 *res)
502 static const u8 vid_did_rid_value[] = { 0x50, 0x10, 0xfe };
506 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
508 rc = i2c_nuvoton_read_buf(client, TPM_VID_DID_RID, 4, (u8 *)&temp);
512 /* check WPCT301 values - ignore RID */
513 if (memcmp(&temp, vid_did_rid_value, sizeof(vid_did_rid_value))) {
515 * f/w rev 2.81 has an issue where the VID_DID_RID is not
516 * reporting the right value. so give it another chance at
517 * offset 0x20 (FIFO_W).
519 rc = i2c_nuvoton_read_buf(client, TPM_DATA_FIFO_W, 4,
524 /* check WPCT301 values - ignore RID */
525 if (memcmp(&temp, vid_did_rid_value,
526 sizeof(vid_did_rid_value)))
534 static int i2c_nuvoton_probe(struct i2c_client *client,
535 const struct i2c_device_id *id)
538 struct tpm_chip *chip;
539 struct device *dev = &client->dev;
540 struct priv_data *priv;
543 rc = get_vid(client, &vid);
547 dev_info(dev, "VID: %04X DID: %02X RID: %02X\n", (u16) vid,
548 (u8) (vid >> 16), (u8) (vid >> 24));
550 chip = tpmm_chip_alloc(dev, &tpm_i2c);
552 return PTR_ERR(chip);
554 priv = devm_kzalloc(dev, sizeof(struct priv_data), GFP_KERNEL);
559 const struct of_device_id *of_id;
561 of_id = of_match_device(dev->driver->of_match_table, dev);
562 if (of_id && of_id->data == OF_IS_TPM2)
563 chip->flags |= TPM_CHIP_FLAG_TPM2;
565 if (id->driver_data == I2C_IS_TPM2)
566 chip->flags |= TPM_CHIP_FLAG_TPM2;
568 init_waitqueue_head(&priv->read_queue);
570 /* Default timeouts */
571 chip->timeout_a = msecs_to_jiffies(TPM_I2C_SHORT_TIMEOUT);
572 chip->timeout_b = msecs_to_jiffies(TPM_I2C_LONG_TIMEOUT);
573 chip->timeout_c = msecs_to_jiffies(TPM_I2C_SHORT_TIMEOUT);
574 chip->timeout_d = msecs_to_jiffies(TPM_I2C_SHORT_TIMEOUT);
576 dev_set_drvdata(&chip->dev, priv);
579 * I2C intfcaps (interrupt capabilitieis) in the chip are hard coded to:
580 * TPM_INTF_INT_LEVEL_LOW | TPM_INTF_DATA_AVAIL_INT
581 * The IRQ should be set in the i2c_board_info (which is done
582 * automatically in of_i2c_register_devices, for device tree users */
583 priv->irq = client->irq;
585 dev_dbg(dev, "%s() priv->irq\n", __func__);
586 rc = devm_request_irq(dev, client->irq,
587 i2c_nuvoton_int_handler,
589 dev_name(&chip->dev),
592 dev_err(dev, "%s() Unable to request irq: %d for use\n",
593 __func__, priv->irq);
596 chip->flags |= TPM_CHIP_FLAG_IRQ;
597 /* Clear any pending interrupt */
598 i2c_nuvoton_ready(chip);
599 /* - wait for TPM_STS==0xA0 (stsValid, commandReady) */
600 rc = i2c_nuvoton_wait_for_stat(chip,
601 TPM_STS_COMMAND_READY,
602 TPM_STS_COMMAND_READY,
607 * TIS is in ready state
608 * write dummy byte to enter reception state
609 * TPM_DATA_FIFO_W <- rc (0)
611 rc = i2c_nuvoton_write_buf(client,
616 /* TPM_STS <- 0x40 (commandReady) */
617 i2c_nuvoton_ready(chip);
620 * timeout_b reached - command was
621 * aborted. TIS should now be in idle state -
622 * only TPM_STS_VALID should be set
624 if (i2c_nuvoton_read_status(chip) !=
631 return tpm_chip_register(chip);
634 static int i2c_nuvoton_remove(struct i2c_client *client)
636 struct tpm_chip *chip = i2c_get_clientdata(client);
638 tpm_chip_unregister(chip);
642 static const struct i2c_device_id i2c_nuvoton_id[] = {
644 {"tpm2_i2c_nuvoton", .driver_data = I2C_IS_TPM2},
647 MODULE_DEVICE_TABLE(i2c, i2c_nuvoton_id);
650 static const struct of_device_id i2c_nuvoton_of_match[] = {
651 {.compatible = "nuvoton,npct501"},
652 {.compatible = "winbond,wpct301"},
653 {.compatible = "nuvoton,npct601", .data = OF_IS_TPM2},
656 MODULE_DEVICE_TABLE(of, i2c_nuvoton_of_match);
659 static SIMPLE_DEV_PM_OPS(i2c_nuvoton_pm_ops, tpm_pm_suspend, tpm_pm_resume);
661 static struct i2c_driver i2c_nuvoton_driver = {
662 .id_table = i2c_nuvoton_id,
663 .probe = i2c_nuvoton_probe,
664 .remove = i2c_nuvoton_remove,
666 .name = "tpm_i2c_nuvoton",
667 .pm = &i2c_nuvoton_pm_ops,
668 .of_match_table = of_match_ptr(i2c_nuvoton_of_match),
672 module_i2c_driver(i2c_nuvoton_driver);
674 MODULE_AUTHOR("Dan Morav (dan.morav@nuvoton.com)");
675 MODULE_DESCRIPTION("Nuvoton TPM I2C Driver");
676 MODULE_LICENSE("GPL");