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");