2 * STMicroelectronics TPM I2C Linux driver for TPM ST33ZP24
3 * Copyright (C) 2009, 2010 STMicroelectronics
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.
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.
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.
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.
24 * @Author: Christophe RICARD tpmsupport@st.com
26 * @File: tpm_stm_st33_i2c.c
29 * 09/15/2010: First shot driver tpm_tis driver for
33 #include <linux/pci.h>
34 #include <linux/module.h>
35 #include <linux/platform_device.h>
36 #include <linux/i2c.h>
38 #include <linux/miscdevice.h>
39 #include <linux/module.h>
40 #include <linux/kernel.h>
41 #include <linux/delay.h>
42 #include <linux/init.h>
43 #include <linux/wait.h>
44 #include <linux/string.h>
45 #include <linux/interrupt.h>
46 #include <linux/spinlock.h>
47 #include <linux/sysfs.h>
48 #include <linux/gpio.h>
49 #include <linux/sched.h>
50 #include <linux/uaccess.h>
52 #include <linux/slab.h>
53 #include <linux/sched.h>
56 #include "tpm_i2c_stm_st33.h"
58 enum stm33zp24_access {
59 TPM_ACCESS_VALID = 0x80,
60 TPM_ACCESS_ACTIVE_LOCALITY = 0x20,
61 TPM_ACCESS_REQUEST_PENDING = 0x04,
62 TPM_ACCESS_REQUEST_USE = 0x02,
65 enum stm33zp24_status {
67 TPM_STS_COMMAND_READY = 0x40,
69 TPM_STS_DATA_AVAIL = 0x10,
70 TPM_STS_DATA_EXPECT = 0x08,
73 enum stm33zp24_int_flags {
74 TPM_GLOBAL_INT_ENABLE = 0x80,
75 TPM_INTF_CMD_READY_INT = 0x080,
76 TPM_INTF_FIFO_AVALAIBLE_INT = 0x040,
77 TPM_INTF_WAKE_UP_READY_INT = 0x020,
78 TPM_INTF_LOCALITY_CHANGE_INT = 0x004,
79 TPM_INTF_STS_VALID_INT = 0x002,
80 TPM_INTF_DATA_AVAIL_INT = 0x001,
84 TIS_SHORT_TIMEOUT = 750,
85 TIS_LONG_TIMEOUT = 2000,
90 * Send byte to the TIS register according to the ST33ZP24 I2C protocol.
91 * @param: tpm_register, the tpm tis register where the data should be written
92 * @param: tpm_data, the tpm_data to write inside the tpm_register
93 * @param: tpm_size, The length of the data
94 * @return: Returns negative errno, or else the number of bytes written.
96 static int write8_reg(struct i2c_client *client, u8 tpm_register,
97 u8 *tpm_data, u16 tpm_size)
99 struct st33zp24_platform_data *pin_infos;
101 pin_infos = client->dev.platform_data;
103 pin_infos->tpm_i2c_buffer[0][0] = tpm_register;
104 memcpy(&pin_infos->tpm_i2c_buffer[0][1], tpm_data, tpm_size);
105 return i2c_master_send(client, pin_infos->tpm_i2c_buffer[0],
111 * Recv byte from the TIS register according to the ST33ZP24 I2C protocol.
112 * @param: tpm_register, the tpm tis register where the data should be read
113 * @param: tpm_data, the TPM response
114 * @param: tpm_size, tpm TPM response size to read.
115 * @return: number of byte read successfully: should be one if success.
117 static int read8_reg(struct i2c_client *client, u8 tpm_register,
118 u8 *tpm_data, int tpm_size)
123 data = TPM_DUMMY_BYTE;
124 status = write8_reg(client, tpm_register, &data, 1);
126 status = i2c_master_recv(client, tpm_data, tpm_size);
132 * Send byte to the TIS register according to the ST33ZP24 I2C protocol.
133 * @param: client, the chip description
134 * @param: tpm_register, the tpm tis register where the data should be written
135 * @param: tpm_data, the tpm_data to write inside the tpm_register
136 * @param: tpm_size, The length of the data
137 * @return: number of byte written successfully: should be one if success.
139 #define I2C_WRITE_DATA(client, tpm_register, tpm_data, tpm_size) \
140 (write8_reg(client, tpm_register | \
141 TPM_WRITE_DIRECTION, tpm_data, tpm_size))
145 * Recv byte from the TIS register according to the ST33ZP24 I2C protocol.
146 * @param: tpm, the chip description
147 * @param: tpm_register, the tpm tis register where the data should be read
148 * @param: tpm_data, the TPM response
149 * @param: tpm_size, tpm TPM response size to read.
150 * @return: number of byte read successfully: should be one if success.
152 #define I2C_READ_DATA(client, tpm_register, tpm_data, tpm_size) \
153 (read8_reg(client, tpm_register, tpm_data, tpm_size))
157 * clear the TPM interrupt register.
158 * @param: tpm, the chip description
160 static void clear_interruption(struct i2c_client *client)
163 I2C_READ_DATA(client, TPM_INT_STATUS, &interrupt, 1);
164 I2C_WRITE_DATA(client, TPM_INT_STATUS, &interrupt, 1);
165 I2C_READ_DATA(client, TPM_INT_STATUS, &interrupt, 1);
166 } /* clear_interruption() */
169 * _wait_for_interrupt_serirq_timeout
170 * @param: tpm, the chip description
171 * @param: timeout, the timeout of the interrupt
172 * @return: the status of the interruption.
174 static long _wait_for_interrupt_serirq_timeout(struct tpm_chip *chip,
175 unsigned long timeout)
178 struct i2c_client *client;
179 struct st33zp24_platform_data *pin_infos;
181 client = (struct i2c_client *) TPM_VPRIV(chip);
182 pin_infos = client->dev.platform_data;
184 status = wait_for_completion_interruptible_timeout(
185 &pin_infos->irq_detection,
188 enable_irq(gpio_to_irq(pin_infos->io_serirq));
189 gpio_direction_input(pin_infos->io_serirq);
192 } /* wait_for_interrupt_serirq_timeout() */
194 static int wait_for_serirq_timeout(struct tpm_chip *chip, bool condition,
195 unsigned long timeout)
198 struct i2c_client *client;
200 client = (struct i2c_client *) TPM_VPRIV(chip);
202 status = _wait_for_interrupt_serirq_timeout(chip, timeout);
206 clear_interruption(client);
214 * tpm_stm_i2c_cancel, cancel is not implemented.
215 * @param: chip, the tpm_chip description as specified in driver/char/tpm/tpm.h
217 static void tpm_stm_i2c_cancel(struct tpm_chip *chip)
219 struct i2c_client *client;
222 client = (struct i2c_client *) TPM_VPRIV(chip);
224 data = TPM_STS_COMMAND_READY;
225 I2C_WRITE_DATA(client, TPM_STS, &data, 1);
226 if (chip->vendor.irq)
227 wait_for_serirq_timeout(chip, 1, chip->vendor.timeout_a);
228 } /* tpm_stm_i2c_cancel() */
231 * tpm_stm_spi_status return the TPM_STS register
232 * @param: chip, the tpm chip description
233 * @return: the TPM_STS register value.
235 static u8 tpm_stm_i2c_status(struct tpm_chip *chip)
237 struct i2c_client *client;
239 client = (struct i2c_client *) TPM_VPRIV(chip);
241 I2C_READ_DATA(client, TPM_STS, &data, 1);
243 } /* tpm_stm_i2c_status() */
247 * check_locality if the locality is active
248 * @param: chip, the tpm chip description
249 * @return: the active locality or -EACCESS.
251 static int check_locality(struct tpm_chip *chip)
253 struct i2c_client *client;
257 client = (struct i2c_client *) TPM_VPRIV(chip);
259 status = I2C_READ_DATA(client, TPM_ACCESS, &data, 1);
260 if (status && (data &
261 (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) ==
262 (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID))
263 return chip->vendor.locality;
267 } /* check_locality() */
270 * request_locality request the TPM locality
271 * @param: chip, the chip description
272 * @return: the active locality or EACCESS.
274 static int request_locality(struct tpm_chip *chip)
278 struct i2c_client *client;
281 client = (struct i2c_client *) TPM_VPRIV(chip);
283 if (check_locality(chip) == chip->vendor.locality)
284 return chip->vendor.locality;
286 data = TPM_ACCESS_REQUEST_USE;
287 rc = I2C_WRITE_DATA(client, TPM_ACCESS, &data, 1);
291 if (chip->vendor.irq) {
292 rc = wait_for_serirq_timeout(chip, (check_locality
294 chip->vendor.timeout_a);
296 return chip->vendor.locality;
298 stop = jiffies + chip->vendor.timeout_a;
300 if (check_locality(chip) >= 0)
301 return chip->vendor.locality;
303 } while (time_before(jiffies, stop));
308 } /* request_locality() */
311 * release_locality release the active locality
312 * @param: chip, the tpm chip description.
314 static void release_locality(struct tpm_chip *chip)
316 struct i2c_client *client;
319 client = (struct i2c_client *) TPM_VPRIV(chip);
320 data = TPM_ACCESS_ACTIVE_LOCALITY;
322 I2C_WRITE_DATA(client, TPM_ACCESS, &data, 1);
326 * get_burstcount return the burstcount address 0x19 0x1A
327 * @param: chip, the chip description
328 * return: the burstcount.
330 static int get_burstcount(struct tpm_chip *chip)
333 int burstcnt, status;
336 struct i2c_client *client = (struct i2c_client *) TPM_VPRIV(chip);
338 stop = jiffies + chip->vendor.timeout_d;
340 tpm_reg = TPM_STS + 1;
341 status = I2C_READ_DATA(client, tpm_reg, &temp, 1);
345 tpm_reg = tpm_reg + 1;
347 status = I2C_READ_DATA(client, tpm_reg, &temp, 1);
351 burstcnt |= temp << 8;
355 } while (time_before(jiffies, stop));
359 } /* get_burstcount() */
362 * wait_for_stat wait for a TPM_STS value
363 * @param: chip, the tpm chip description
364 * @param: mask, the value mask to wait
365 * @param: timeout, the timeout
366 * @param: queue, the wait queue.
367 * @return: the tpm status, 0 if success, -ETIME if timeout is reached.
369 static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout,
370 wait_queue_head_t *queue)
376 if (chip->vendor.irq) {
377 rc = wait_for_serirq_timeout(chip, ((tpm_stm_i2c_status
383 stop = jiffies + timeout;
386 status = tpm_stm_i2c_status(chip);
387 if ((status & mask) == mask)
389 } while (time_before(jiffies, stop));
392 } /* wait_for_stat() */
395 * recv_data receive data
396 * @param: chip, the tpm chip description
397 * @param: buf, the buffer where the data are received
398 * @param: count, the number of data to receive
399 * @return: the number of bytes read from TPM FIFO.
401 static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
403 int size = 0, burstcnt, len;
404 struct i2c_client *client;
406 client = (struct i2c_client *) TPM_VPRIV(chip);
408 while (size < count &&
410 TPM_STS_DATA_AVAIL | TPM_STS_VALID,
411 chip->vendor.timeout_c,
412 &chip->vendor.read_queue)
414 burstcnt = get_burstcount(chip);
415 len = min_t(int, burstcnt, count - size);
416 I2C_READ_DATA(client, TPM_DATA_FIFO, buf + size, len);
423 * tpm_ioserirq_handler the serirq irq handler
424 * @param: irq, the tpm chip description
425 * @param: dev_id, the description of the chip
426 * @return: the status of the handler.
428 static irqreturn_t tpm_ioserirq_handler(int irq, void *dev_id)
430 struct tpm_chip *chip = dev_id;
431 struct i2c_client *client;
432 struct st33zp24_platform_data *pin_infos;
434 disable_irq_nosync(irq);
436 client = (struct i2c_client *) TPM_VPRIV(chip);
437 pin_infos = client->dev.platform_data;
439 complete(&pin_infos->irq_detection);
441 } /* tpm_ioserirq_handler() */
445 * tpm_stm_i2c_send send TPM commands through the I2C bus.
447 * @param: chip, the tpm_chip description as specified in driver/char/tpm/tpm.h
448 * @param: buf, the buffer to send.
449 * @param: count, the number of bytes to send.
450 * @return: In case of success the number of bytes sent.
451 * In other case, a < 0 value describing the issue.
453 static int tpm_stm_i2c_send(struct tpm_chip *chip, unsigned char *buf,
457 burstcnt = 0, i, size;
460 struct i2c_client *client;
464 if (len < TPM_HEADER_SIZE)
467 client = (struct i2c_client *)TPM_VPRIV(chip);
471 ret = request_locality(chip);
475 status = tpm_stm_i2c_status(chip);
476 if ((status & TPM_STS_COMMAND_READY) == 0) {
477 tpm_stm_i2c_cancel(chip);
479 (chip, TPM_STS_COMMAND_READY, chip->vendor.timeout_b,
480 &chip->vendor.int_queue) < 0) {
486 for (i = 0 ; i < len - 1 ;) {
487 burstcnt = get_burstcount(chip);
488 size = min_t(int, len - i - 1, burstcnt);
489 ret = I2C_WRITE_DATA(client, TPM_DATA_FIFO, buf, size);
496 status = tpm_stm_i2c_status(chip);
497 if ((status & TPM_STS_DATA_EXPECT) == 0) {
502 ret = I2C_WRITE_DATA(client, TPM_DATA_FIFO, buf + len - 1, 1);
506 status = tpm_stm_i2c_status(chip);
507 if ((status & TPM_STS_DATA_EXPECT) != 0) {
513 I2C_WRITE_DATA(client, TPM_STS, &data, 1);
517 tpm_stm_i2c_cancel(chip);
518 release_locality(chip);
523 * tpm_stm_i2c_recv received TPM response through the I2C bus.
524 * @param: chip, the tpm_chip description as specified in driver/char/tpm/tpm.h.
525 * @param: buf, the buffer to store datas.
526 * @param: count, the number of bytes to send.
527 * @return: In case of success the number of bytes received.
528 * In other case, a < 0 value describing the issue.
530 static int tpm_stm_i2c_recv(struct tpm_chip *chip, unsigned char *buf,
539 if (count < TPM_HEADER_SIZE) {
544 size = recv_data(chip, buf, TPM_HEADER_SIZE);
545 if (size < TPM_HEADER_SIZE) {
546 dev_err(chip->dev, "Unable to read header\n");
550 expected = be32_to_cpu(*(__be32 *) (buf + 2));
551 if (expected > count) {
556 size += recv_data(chip, &buf[TPM_HEADER_SIZE],
557 expected - TPM_HEADER_SIZE);
558 if (size < expected) {
559 dev_err(chip->dev, "Unable to read remainder of result\n");
565 chip->vendor.cancel(chip);
566 release_locality(chip);
570 static bool tpm_st33_i2c_req_canceled(struct tpm_chip *chip, u8 status)
572 return (status == TPM_STS_COMMAND_READY);
575 static const struct file_operations tpm_st33_i2c_fops = {
576 .owner = THIS_MODULE,
581 .release = tpm_release,
584 static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL);
585 static DEVICE_ATTR(pcrs, S_IRUGO, tpm_show_pcrs, NULL);
586 static DEVICE_ATTR(enabled, S_IRUGO, tpm_show_enabled, NULL);
587 static DEVICE_ATTR(active, S_IRUGO, tpm_show_active, NULL);
588 static DEVICE_ATTR(owned, S_IRUGO, tpm_show_owned, NULL);
589 static DEVICE_ATTR(temp_deactivated, S_IRUGO, tpm_show_temp_deactivated, NULL);
590 static DEVICE_ATTR(caps, S_IRUGO, tpm_show_caps_1_2, NULL);
591 static DEVICE_ATTR(cancel, S_IWUSR | S_IWGRP, NULL, tpm_store_cancel);
593 static struct attribute *stm_tpm_attrs[] = {
594 &dev_attr_pubek.attr,
596 &dev_attr_enabled.attr,
597 &dev_attr_active.attr,
598 &dev_attr_owned.attr,
599 &dev_attr_temp_deactivated.attr,
601 &dev_attr_cancel.attr, NULL,
604 static struct attribute_group stm_tpm_attr_grp = {
605 .attrs = stm_tpm_attrs
608 static struct tpm_vendor_specific st_i2c_tpm = {
609 .send = tpm_stm_i2c_send,
610 .recv = tpm_stm_i2c_recv,
611 .cancel = tpm_stm_i2c_cancel,
612 .status = tpm_stm_i2c_status,
613 .req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
614 .req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
615 .req_canceled = tpm_st33_i2c_req_canceled,
616 .attr_group = &stm_tpm_attr_grp,
617 .miscdev = {.fops = &tpm_st33_i2c_fops,},
620 static int interrupts ;
621 module_param(interrupts, int, 0444);
622 MODULE_PARM_DESC(interrupts, "Enable interrupts");
624 static int power_mgt = 1;
625 module_param(power_mgt, int, 0444);
626 MODULE_PARM_DESC(power_mgt, "Power Management");
629 * tpm_st33_i2c_probe initialize the TPM device
630 * @param: client, the i2c_client drescription (TPM I2C description).
631 * @param: id, the i2c_device_id struct.
632 * @return: 0 in case of success.
636 tpm_st33_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
640 struct tpm_chip *chip;
641 struct st33zp24_platform_data *platform_data;
643 if (client == NULL) {
644 pr_info("%s: i2c client is NULL. Device not accessible.\n",
650 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
651 dev_info(&client->dev, "client not i2c capable\n");
656 chip = tpm_register_hardware(&client->dev, &st_i2c_tpm);
658 dev_info(&client->dev, "fail chip\n");
663 platform_data = client->dev.platform_data;
665 if (!platform_data) {
666 dev_info(&client->dev, "chip not available\n");
668 goto _tpm_clean_answer;
671 platform_data->tpm_i2c_buffer[0] =
672 kmalloc(TPM_BUFSIZE * sizeof(u8), GFP_KERNEL);
673 if (platform_data->tpm_i2c_buffer[0] == NULL) {
675 goto _tpm_clean_answer;
677 platform_data->tpm_i2c_buffer[1] =
678 kmalloc(TPM_BUFSIZE * sizeof(u8), GFP_KERNEL);
679 if (platform_data->tpm_i2c_buffer[1] == NULL) {
681 goto _tpm_clean_response1;
684 TPM_VPRIV(chip) = client;
686 chip->vendor.timeout_a = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
687 chip->vendor.timeout_b = msecs_to_jiffies(TIS_LONG_TIMEOUT);
688 chip->vendor.timeout_c = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
689 chip->vendor.timeout_d = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
691 chip->vendor.locality = LOCALITY0;
694 err = gpio_request(platform_data->io_lpcpd, "TPM IO_LPCPD");
697 gpio_set_value(platform_data->io_lpcpd, 1);
701 init_completion(&platform_data->irq_detection);
702 if (request_locality(chip) != LOCALITY0) {
704 goto _tpm_clean_response2;
706 err = gpio_request(platform_data->io_serirq, "TPM IO_SERIRQ");
710 clear_interruption(client);
711 err = request_irq(gpio_to_irq(platform_data->io_serirq),
712 &tpm_ioserirq_handler,
714 "TPM SERIRQ management", chip);
716 dev_err(chip->dev , "TPM SERIRQ signals %d not available\n",
717 gpio_to_irq(platform_data->io_serirq));
721 err = I2C_READ_DATA(client, TPM_INT_ENABLE, &intmask, 1);
725 intmask |= TPM_INTF_CMD_READY_INT
726 | TPM_INTF_FIFO_AVALAIBLE_INT
727 | TPM_INTF_WAKE_UP_READY_INT
728 | TPM_INTF_LOCALITY_CHANGE_INT
729 | TPM_INTF_STS_VALID_INT
730 | TPM_INTF_DATA_AVAIL_INT;
732 err = I2C_WRITE_DATA(client, TPM_INT_ENABLE, &intmask, 1);
736 intmask = TPM_GLOBAL_INT_ENABLE;
737 err = I2C_WRITE_DATA(client, (TPM_INT_ENABLE + 3), &intmask, 1);
741 err = I2C_READ_DATA(client, TPM_INT_STATUS, &intmask, 1);
745 chip->vendor.irq = interrupts;
747 tpm_gen_interrupt(chip);
750 tpm_get_timeouts(chip);
752 i2c_set_clientdata(client, chip);
754 dev_info(chip->dev, "TPM I2C Initialized\n");
757 free_irq(gpio_to_irq(platform_data->io_serirq), (void *) chip);
760 gpio_free(platform_data->io_serirq);
763 gpio_free(platform_data->io_lpcpd);
764 _tpm_clean_response2:
765 kzfree(platform_data->tpm_i2c_buffer[1]);
766 platform_data->tpm_i2c_buffer[1] = NULL;
767 _tpm_clean_response1:
768 kzfree(platform_data->tpm_i2c_buffer[0]);
769 platform_data->tpm_i2c_buffer[0] = NULL;
771 tpm_remove_hardware(chip->dev);
773 pr_info("TPM I2C initialisation fail\n");
778 * tpm_st33_i2c_remove remove the TPM device
779 * @param: client, the i2c_client drescription (TPM I2C description).
780 clear_bit(0, &chip->is_open);
781 * @return: 0 in case of success.
783 static int tpm_st33_i2c_remove(struct i2c_client *client)
785 struct tpm_chip *chip = (struct tpm_chip *)i2c_get_clientdata(client);
786 struct st33zp24_platform_data *pin_infos =
787 ((struct i2c_client *) TPM_VPRIV(chip))->dev.platform_data;
789 if (pin_infos != NULL) {
790 free_irq(pin_infos->io_serirq, chip);
792 gpio_free(pin_infos->io_serirq);
793 gpio_free(pin_infos->io_lpcpd);
795 tpm_remove_hardware(chip->dev);
797 if (pin_infos->tpm_i2c_buffer[1] != NULL) {
798 kzfree(pin_infos->tpm_i2c_buffer[1]);
799 pin_infos->tpm_i2c_buffer[1] = NULL;
801 if (pin_infos->tpm_i2c_buffer[0] != NULL) {
802 kzfree(pin_infos->tpm_i2c_buffer[0]);
803 pin_infos->tpm_i2c_buffer[0] = NULL;
810 #ifdef CONFIG_PM_SLEEP
812 * tpm_st33_i2c_pm_suspend suspend the TPM device
813 * Added: Work around when suspend and no tpm application is running, suspend
814 * may fail because chip->data_buffer is not set (only set in tpm_open in Linux
816 * @param: client, the i2c_client drescription (TPM I2C description).
817 * @param: mesg, the power management message.
818 * @return: 0 in case of success.
820 static int tpm_st33_i2c_pm_suspend(struct device *dev)
822 struct tpm_chip *chip = dev_get_drvdata(dev);
823 struct st33zp24_platform_data *pin_infos = dev->platform_data;
827 gpio_set_value(pin_infos->io_lpcpd, 0);
829 if (chip->data_buffer == NULL)
830 chip->data_buffer = pin_infos->tpm_i2c_buffer[0];
831 ret = tpm_pm_suspend(dev);
834 } /* tpm_st33_i2c_suspend() */
837 * tpm_st33_i2c_pm_resume resume the TPM device
838 * @param: client, the i2c_client drescription (TPM I2C description).
839 * @return: 0 in case of success.
841 static int tpm_st33_i2c_pm_resume(struct device *dev)
843 struct tpm_chip *chip = dev_get_drvdata(dev);
844 struct st33zp24_platform_data *pin_infos = dev->platform_data;
849 gpio_set_value(pin_infos->io_lpcpd, 1);
850 ret = wait_for_serirq_timeout(chip,
851 (chip->vendor.status(chip) &
852 TPM_STS_VALID) == TPM_STS_VALID,
853 chip->vendor.timeout_b);
855 if (chip->data_buffer == NULL)
856 chip->data_buffer = pin_infos->tpm_i2c_buffer[0];
857 ret = tpm_pm_resume(dev);
859 tpm_do_selftest(chip);
862 } /* tpm_st33_i2c_pm_resume() */
865 static const struct i2c_device_id tpm_st33_i2c_id[] = {
869 MODULE_DEVICE_TABLE(i2c, tpm_st33_i2c_id);
870 static SIMPLE_DEV_PM_OPS(tpm_st33_i2c_ops, tpm_st33_i2c_pm_suspend, tpm_st33_i2c_pm_resume);
871 static struct i2c_driver tpm_st33_i2c_driver = {
873 .owner = THIS_MODULE,
874 .name = TPM_ST33_I2C,
875 .pm = &tpm_st33_i2c_ops,
877 .probe = tpm_st33_i2c_probe,
878 .remove = tpm_st33_i2c_remove,
879 .id_table = tpm_st33_i2c_id
882 module_i2c_driver(tpm_st33_i2c_driver);
884 MODULE_AUTHOR("Christophe Ricard (tpmsupport@st.com)");
885 MODULE_DESCRIPTION("STM TPM I2C ST33 Driver");
886 MODULE_VERSION("1.2.0");
887 MODULE_LICENSE("GPL");