History

tpm/tpm_i2c_stm_st33: Split tpm_i2c_tpm_st33 in 2 layers (core + phy)

tpm_i2c_stm_st33 is a TIS 1.2 TPM with a core interface which can be used by different phy such as i2c or spi. The core part is called st33zp24 which is also the main part reference. include/linux/platform_data/tpm_stm_st33.h is renamed consequently. The driver is also split into an i2c phy in charge of sending/receiving data as well as managing platform data or dts configuration.

Christophe Ricard committed 11 years ago

Commit bf38b871 parent fe7d3689 files · +1036 −942Browse files

Unified · Split

9 files
  1. drivers/char/tpm/Kconfig +1 −10
  2. drivers/char/tpm/Makefile +1 −1
  3. drivers/char/tpm/st33zp24/Kconfig +20 −0
  4. drivers/char/tpm/st33zp24/Makefile +9 −0
  5. drivers/char/tpm/st33zp24/i2c.c +278 −0
  6. drivers/char/tpm/st33zp24/st33zp24.c +688 −0
  7. drivers/char/tpm/st33zp24/st33zp24.h +34 −0
  8. drivers/char/tpm/tpm_i2c_stm_st33.c +0 −915
  9. include/linux/platform_data/st33zp24.h +5 −16
drivers/char/tpm/Kconfig+1−10
@@ -100,16 +100,6 @@ config TCG_IBMVTPM · 99 unmodified lines
100100 will be accessible from within Linux. To compile this driver
101101 as a module, choose M here; the module will be called tpm_ibmvtpm.
102102
103−config TCG_TIS_I2C_ST33
104− tristate "TPM Interface Specification 1.2 Interface (I2C - STMicroelectronics)"
105− depends on I2C
106− depends on GPIOLIB
107− ---help---
108− If you have a TPM security chip from STMicroelectronics working with
109− an I2C bus say Yes and it will be accessible from within Linux.
110− To compile this driver as a module, choose M here; the module will be
111− called tpm_i2c_stm_st33.
112−
113103 config TCG_XEN
114104 tristate "XEN TPM Interface"
115105 depends on TCG_TPM && XEN
@@ -131,4 +121,5 @@ config TCG_CRB · 15 unmodified lines
131121 from within Linux. To compile this driver as a module, choose
132122 M here; the module will be called tpm_crb.
133123
124+source "drivers/char/tpm/st33zp24/Kconfig"
134125 endif # TCG_TPM
drivers/char/tpm/Makefile+1−1
@@ -20,6 +20,6 @@ obj-$(CONFIG_TCG_NSC) += tpm_nsc.o · 19 unmodified lines
2020 obj-$(CONFIG_TCG_ATMEL) += tpm_atmel.o
2121 obj-$(CONFIG_TCG_INFINEON) += tpm_infineon.o
2222 obj-$(CONFIG_TCG_IBMVTPM) += tpm_ibmvtpm.o
23−obj-$(CONFIG_TCG_TIS_I2C_ST33) += tpm_i2c_stm_st33.o
23+obj-$(CONFIG_TCG_TIS_ST33ZP24) += st33zp24/
2424 obj-$(CONFIG_TCG_XEN) += xen-tpmfront.o
2525 obj-$(CONFIG_TCG_CRB) += tpm_crb.o
drivers/char/tpm/st33zp24/Kconfig+20−0
@@ -0,0 +1,20 @@
1+config TCG_TIS_ST33ZP24
2+ tristate "STMicroelectronics TPM Interface Specification 1.2 Interface"
3+ depends on GPIOLIB
4+ ---help---
5+ STMicroelectronics ST33ZP24 core driver. It implements the core
6+ TPM1.2 logic and hooks into the TPM kernel APIs. Physical layers will
7+ register against it.
8+
9+ To compile this driver as a module, choose m here. The module will be called
10+ tpm_st33zp24.
11+
12+config TCG_TIS_ST33ZP24_I2C
13+ tristate "TPM 1.2 ST33ZP24 I2C support"
14+ depends on TCG_TIS_ST33ZP24
15+ depends on I2C
16+ ---help---
17+ This module adds support for the STMicroelectronics TPM security chip
18+ ST33ZP24 with i2c interface.
19+ To compile this driver as a module, choose M here; the module will be
20+ called tpm_st33zp24_i2c.
drivers/char/tpm/st33zp24/Makefile+9−0
@@ -0,0 +1,9 @@
1+#
2+# Makefile for ST33ZP24 TPM 1.2 driver
3+#
4+
5+tpm_st33zp24-objs = st33zp24.o
6+obj-$(CONFIG_TCG_TIS_ST33ZP24) += tpm_st33zp24.o
7+
8+tpm_st33zp24_i2c-objs = i2c.o
9+obj-$(CONFIG_TCG_TIS_ST33ZP24_I2C) += tpm_st33zp24_i2c.o
drivers/char/tpm/st33zp24/i2c.c+278−0
@@ -0,0 +1,278 @@
1+/*
2+ * STMicroelectronics TPM I2C Linux driver for TPM ST33ZP24
3+ * Copyright (C) 2009 - 2015 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
16+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
17+ */
18+
19+#include <linux/module.h>
20+#include <linux/i2c.h>
21+#include <linux/gpio.h>
22+#include <linux/of_irq.h>
23+#include <linux/of_gpio.h>
24+#include <linux/tpm.h>
25+#include <linux/platform_data/st33zp24.h>
26+
27+#include "st33zp24.h"
28+
29+#define TPM_DUMMY_BYTE 0xAA
30+#define TPM_WRITE_DIRECTION 0x80
31+#define TPM_BUFSIZE 2048
32+
33+struct st33zp24_i2c_phy {
34+ struct i2c_client *client;
35+ u8 buf[TPM_BUFSIZE + 1];
36+ int io_lpcpd;
37+};
38+
39+/*
40+ * write8_reg
41+ * Send byte to the TIS register according to the ST33ZP24 I2C protocol.
42+ * @param: tpm_register, the tpm tis register where the data should be written
43+ * @param: tpm_data, the tpm_data to write inside the tpm_register
44+ * @param: tpm_size, The length of the data
45+ * @return: Returns negative errno, or else the number of bytes written.
46+ */
47+static int write8_reg(void *phy_id, u8 tpm_register, u8 *tpm_data, int tpm_size)
48+{
49+ struct st33zp24_i2c_phy *phy = phy_id;
50+
51+ phy->buf[0] = tpm_register;
52+ memcpy(phy->buf + 1, tpm_data, tpm_size);
53+ return i2c_master_send(phy->client, phy->buf, tpm_size + 1);
54+} /* write8_reg() */
55+
56+/*
57+ * read8_reg
58+ * Recv byte from the TIS register according to the ST33ZP24 I2C protocol.
59+ * @param: tpm_register, the tpm tis register where the data should be read
60+ * @param: tpm_data, the TPM response
61+ * @param: tpm_size, tpm TPM response size to read.
62+ * @return: number of byte read successfully: should be one if success.
63+ */
64+static int read8_reg(void *phy_id, u8 tpm_register, u8 *tpm_data, int tpm_size)
65+{
66+ struct st33zp24_i2c_phy *phy = phy_id;
67+ u8 status = 0;
68+ u8 data;
69+
70+ data = TPM_DUMMY_BYTE;
71+ status = write8_reg(phy, tpm_register, &data, 1);
72+ if (status == 2)
73+ status = i2c_master_recv(phy->client, tpm_data, tpm_size);
74+ return status;
75+} /* read8_reg() */
76+
77+/*
78+ * st33zp24_i2c_send
79+ * Send byte to the TIS register according to the ST33ZP24 I2C protocol.
80+ * @param: phy_id, the phy description
81+ * @param: tpm_register, the tpm tis register where the data should be written
82+ * @param: tpm_data, the tpm_data to write inside the tpm_register
83+ * @param: tpm_size, the length of the data
84+ * @return: number of byte written successfully: should be one if success.
85+ */
86+static int st33zp24_i2c_send(void *phy_id, u8 tpm_register, u8 *tpm_data,
87+ int tpm_size)
88+{
89+ return write8_reg(phy_id, tpm_register | TPM_WRITE_DIRECTION, tpm_data,
90+ tpm_size);
91+}
92+
93+/*
94+ * st33zp24_i2c_recv
95+ * Recv byte from the TIS register according to the ST33ZP24 I2C protocol.
96+ * @param: phy_id, the phy description
97+ * @param: tpm_register, the tpm tis register where the data should be read
98+ * @param: tpm_data, the TPM response
99+ * @param: tpm_size, tpm TPM response size to read.
100+ * @return: number of byte read successfully: should be one if success.
101+ */
102+static int st33zp24_i2c_recv(void *phy_id, u8 tpm_register, u8 *tpm_data,
103+ int tpm_size)
104+{
105+ return read8_reg(phy_id, tpm_register, tpm_data, tpm_size);
106+}
107+
108+static const struct st33zp24_phy_ops i2c_phy_ops = {
109+ .send = st33zp24_i2c_send,
110+ .recv = st33zp24_i2c_recv,
111+};
112+
113+#ifdef CONFIG_OF
114+static int st33zp24_i2c_of_request_resources(struct st33zp24_i2c_phy *phy)
115+{
116+ struct device_node *pp;
117+ struct i2c_client *client = phy->client;
118+ int gpio;
119+ int ret;
120+
121+ pp = client->dev.of_node;
122+ if (!pp) {
123+ dev_err(&client->dev, "No platform data\n");
124+ return -ENODEV;
125+ }
126+
127+ /* Get GPIO from device tree */
128+ gpio = of_get_named_gpio(pp, "lpcpd-gpios", 0);
129+ if (gpio < 0) {
130+ dev_err(&client->dev,
131+ "Failed to retrieve lpcpd-gpios from dts.\n");
132+ phy->io_lpcpd = -1;
133+ /*
134+ * lpcpd pin is not specified. This is not an issue as
135+ * power management can be also managed by TPM specific
136+ * commands. So leave with a success status code.
137+ */
138+ return 0;
139+ }
140+ /* GPIO request and configuration */
141+ ret = devm_gpio_request_one(&client->dev, gpio,
142+ GPIOF_OUT_INIT_HIGH, "TPM IO LPCPD");
143+ if (ret) {
144+ dev_err(&client->dev, "Failed to request lpcpd pin\n");
145+ return -ENODEV;
146+ }
147+ phy->io_lpcpd = gpio;
148+
149+ return 0;
150+}
151+#else
152+static int st33zp24_i2c_of_request_resources(struct st33zp24_i2c_phy *phy)
153+{
154+ return -ENODEV;
155+}
156+#endif
157+
158+static int st33zp24_i2c_request_resources(struct i2c_client *client,
159+ struct st33zp24_i2c_phy *phy)
160+{
161+ struct st33zp24_platform_data *pdata;
162+ int ret;
163+
164+ pdata = client->dev.platform_data;
165+ if (!pdata) {
166+ dev_err(&client->dev, "No platform data\n");
167+ return -ENODEV;
168+ }
169+
170+ /* store for late use */
171+ phy->io_lpcpd = pdata->io_lpcpd;
172+
173+ if (gpio_is_valid(pdata->io_lpcpd)) {
174+ ret = devm_gpio_request_one(&client->dev,
175+ pdata->io_lpcpd, GPIOF_OUT_INIT_HIGH,
176+ "TPM IO_LPCPD");
177+ if (ret) {
178+ dev_err(&client->dev, "Failed to request lpcpd pin\n");
179+ return ret;
180+ }
181+ }
182+
183+ return 0;
184+}
185+
186+/*
187+ * st33zp24_i2c_probe initialize the TPM device
188+ * @param: client, the i2c_client drescription (TPM I2C description).
189+ * @param: id, the i2c_device_id struct.
190+ * @return: 0 in case of success.
191+ * -1 in other case.
192+ */
193+static int st33zp24_i2c_probe(struct i2c_client *client,
194+ const struct i2c_device_id *id)
195+{
196+ int ret;
197+ struct st33zp24_platform_data *pdata;
198+ struct st33zp24_i2c_phy *phy;
199+
200+ if (!client) {
201+ pr_info("%s: i2c client is NULL. Device not accessible.\n",
202+ __func__);
203+ return -ENODEV;
204+ }
205+
206+ if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
207+ dev_info(&client->dev, "client not i2c capable\n");
208+ return -ENODEV;
209+ }
210+
211+ phy = devm_kzalloc(&client->dev, sizeof(struct st33zp24_i2c_phy),
212+ GFP_KERNEL);
213+ if (!phy)
214+ return -ENOMEM;
215+
216+ phy->client = client;
217+ pdata = client->dev.platform_data;
218+ if (!pdata && client->dev.of_node) {
219+ ret = st33zp24_i2c_of_request_resources(phy);
220+ if (ret)
221+ return ret;
222+ } else if (pdata) {
223+ ret = st33zp24_i2c_request_resources(client, phy);
224+ if (ret)
225+ return ret;
226+ }
227+
228+ return st33zp24_probe(phy, &i2c_phy_ops, &client->dev, client->irq,
229+ phy->io_lpcpd);
230+}
231+
232+/*
233+ * st33zp24_i2c_remove remove the TPM device
234+ * @param: client, the i2c_client description (TPM I2C description).
235+ * @return: 0 in case of success.
236+ */
237+static int st33zp24_i2c_remove(struct i2c_client *client)
238+{
239+ struct tpm_chip *chip = i2c_get_clientdata(client);
240+
241+ return st33zp24_remove(chip);
242+}
243+
244+static const struct i2c_device_id st33zp24_i2c_id[] = {
245+ {TPM_ST33_I2C, 0},
246+ {}
247+};
248+MODULE_DEVICE_TABLE(i2c, st33zp24_i2c_id);
249+
250+#ifdef CONFIG_OF
251+static const struct of_device_id of_st33zp24_i2c_match[] = {
252+ { .compatible = "st,st33zp24-i2c", },
253+ {}
254+};
255+MODULE_DEVICE_TABLE(of, of_st33zp24_i2c_match);
256+#endif
257+
258+static SIMPLE_DEV_PM_OPS(st33zp24_i2c_ops, st33zp24_pm_suspend,
259+ st33zp24_pm_resume);
260+
261+static struct i2c_driver st33zp24_i2c_driver = {
262+ .driver = {
263+ .owner = THIS_MODULE,
264+ .name = TPM_ST33_I2C,
265+ .pm = &st33zp24_i2c_ops,
266+ .of_match_table = of_match_ptr(of_st33zp24_i2c_match),
267+ },
268+ .probe = st33zp24_i2c_probe,
269+ .remove = st33zp24_i2c_remove,
270+ .id_table = st33zp24_i2c_id
271+};
272+
273+module_i2c_driver(st33zp24_i2c_driver);
274+
275+MODULE_AUTHOR("TPM support (TPMsupport@list.st.com)");
276+MODULE_DESCRIPTION("STM TPM 1.2 I2C ST33 Driver");
277+MODULE_VERSION("1.3.0");
278+MODULE_LICENSE("GPL");
drivers/char/tpm/st33zp24/st33zp24.c+688−0
@@ -0,0 +1,688 @@
1+/*
2+ * STMicroelectronics TPM Linux driver for TPM ST33ZP24
3+ * Copyright (C) 2009 - 2015 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
16+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
17+ */
18+
19+#include <linux/module.h>
20+#include <linux/fs.h>
21+#include <linux/miscdevice.h>
22+#include <linux/kernel.h>
23+#include <linux/delay.h>
24+#include <linux/wait.h>
25+#include <linux/freezer.h>
26+#include <linux/string.h>
27+#include <linux/interrupt.h>
28+#include <linux/gpio.h>
29+#include <linux/sched.h>
30+#include <linux/uaccess.h>
31+#include <linux/io.h>
32+#include <linux/slab.h>
33+
34+#include "../tpm.h"
35+#include "st33zp24.h"
36+
37+#define TPM_ACCESS 0x0
38+#define TPM_STS 0x18
39+#define TPM_DATA_FIFO 0x24
40+#define TPM_INTF_CAPABILITY 0x14
41+#define TPM_INT_STATUS 0x10
42+#define TPM_INT_ENABLE 0x08
43+
44+#define LOCALITY0 0
45+
46+enum st33zp24_access {
47+ TPM_ACCESS_VALID = 0x80,
48+ TPM_ACCESS_ACTIVE_LOCALITY = 0x20,
49+ TPM_ACCESS_REQUEST_PENDING = 0x04,
50+ TPM_ACCESS_REQUEST_USE = 0x02,
51+};
52+
53+enum st33zp24_status {
54+ TPM_STS_VALID = 0x80,
55+ TPM_STS_COMMAND_READY = 0x40,
56+ TPM_STS_GO = 0x20,
57+ TPM_STS_DATA_AVAIL = 0x10,
58+ TPM_STS_DATA_EXPECT = 0x08,
59+};
60+
61+enum st33zp24_int_flags {
62+ TPM_GLOBAL_INT_ENABLE = 0x80,
63+ TPM_INTF_CMD_READY_INT = 0x080,
64+ TPM_INTF_FIFO_AVALAIBLE_INT = 0x040,
65+ TPM_INTF_WAKE_UP_READY_INT = 0x020,
66+ TPM_INTF_LOCALITY_CHANGE_INT = 0x004,
67+ TPM_INTF_STS_VALID_INT = 0x002,
68+ TPM_INTF_DATA_AVAIL_INT = 0x001,
69+};
70+
71+enum tis_defaults {
72+ TIS_SHORT_TIMEOUT = 750,
73+ TIS_LONG_TIMEOUT = 2000,
74+};
75+
76+struct st33zp24_dev {
77+ struct tpm_chip *chip;
78+ void *phy_id;
79+ const struct st33zp24_phy_ops *ops;
80+ u32 intrs;
81+ int io_lpcpd;
82+};
83+
84+/*
85+ * clear_interruption clear the pending interrupt.
86+ * @param: tpm_dev, the tpm device device.
87+ * @return: the interrupt status value.
88+ */
89+static u8 clear_interruption(struct st33zp24_dev *tpm_dev)
90+{
91+ u8 interrupt;
92+
93+ tpm_dev->ops->recv(tpm_dev->phy_id, TPM_INT_STATUS, &interrupt, 1);
94+ tpm_dev->ops->send(tpm_dev->phy_id, TPM_INT_STATUS, &interrupt, 1);
95+ return interrupt;
96+} /* clear_interruption() */
97+
98+/*
99+ * st33zp24_cancel, cancel the current command execution or
100+ * set STS to COMMAND READY.
101+ * @param: chip, the tpm_chip description as specified in driver/char/tpm/tpm.h
102+ */
103+static void st33zp24_cancel(struct tpm_chip *chip)
104+{
105+ struct st33zp24_dev *tpm_dev;
106+ u8 data;
107+
108+ tpm_dev = (struct st33zp24_dev *)TPM_VPRIV(chip);
109+
110+ data = TPM_STS_COMMAND_READY;
111+ tpm_dev->ops->send(tpm_dev->phy_id, TPM_STS, &data, 1);
112+} /* st33zp24_cancel() */
113+
114+/*
115+ * st33zp24_status return the TPM_STS register
116+ * @param: chip, the tpm chip description
117+ * @return: the TPM_STS register value.
118+ */
119+static u8 st33zp24_status(struct tpm_chip *chip)
120+{
121+ struct st33zp24_dev *tpm_dev;
122+ u8 data;
123+
124+ tpm_dev = (struct st33zp24_dev *)TPM_VPRIV(chip);
125+
126+ tpm_dev->ops->recv(tpm_dev->phy_id, TPM_STS, &data, 1);
127+ return data;
128+} /* st33zp24_status() */
129+
130+/*
131+ * check_locality if the locality is active
132+ * @param: chip, the tpm chip description
133+ * @return: the active locality or -EACCESS.
134+ */
135+static int check_locality(struct tpm_chip *chip)
136+{
137+ struct st33zp24_dev *tpm_dev;
138+ u8 data;
139+ u8 status;
140+
141+ tpm_dev = (struct st33zp24_dev *)TPM_VPRIV(chip);
142+
143+ status = tpm_dev->ops->recv(tpm_dev->phy_id, TPM_ACCESS, &data, 1);
144+ if (status && (data &
145+ (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) ==
146+ (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID))
147+ return chip->vendor.locality;
148+
149+ return -EACCES;
150+} /* check_locality() */
151+
152+/*
153+ * request_locality request the TPM locality
154+ * @param: chip, the chip description
155+ * @return: the active locality or negative value.
156+ */
157+static int request_locality(struct tpm_chip *chip)
158+{
159+ unsigned long stop;
160+ long ret;
161+ struct st33zp24_dev *tpm_dev;
162+ u8 data;
163+
164+ if (check_locality(chip) == chip->vendor.locality)
165+ return chip->vendor.locality;
166+
167+ tpm_dev = (struct st33zp24_dev *)TPM_VPRIV(chip);
168+
169+ data = TPM_ACCESS_REQUEST_USE;
170+ ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_ACCESS, &data, 1);
171+ if (ret < 0)
172+ return ret;
173+
174+ stop = jiffies + chip->vendor.timeout_a;
175+
176+ /* Request locality is usually effective after the request */
177+ do {
178+ if (check_locality(chip) >= 0)
179+ return chip->vendor.locality;
180+ msleep(TPM_TIMEOUT);
181+ } while (time_before(jiffies, stop));
182+
183+ /* could not get locality */
184+ return -EACCES;
185+} /* request_locality() */
186+
187+/*
188+ * release_locality release the active locality
189+ * @param: chip, the tpm chip description.
190+ */
191+static void release_locality(struct tpm_chip *chip)
192+{
193+ struct st33zp24_dev *tpm_dev;
194+ u8 data;
195+
196+ tpm_dev = (struct st33zp24_dev *)TPM_VPRIV(chip);
197+ data = TPM_ACCESS_ACTIVE_LOCALITY;
198+
199+ tpm_dev->ops->send(tpm_dev->phy_id, TPM_ACCESS, &data, 1);
200+}
201+
202+/*
203+ * get_burstcount return the burstcount value
204+ * @param: chip, the chip description
205+ * return: the burstcount or negative value.
206+ */
207+static int get_burstcount(struct tpm_chip *chip)
208+{
209+ unsigned long stop;
210+ int burstcnt, status;
211+ u8 tpm_reg, temp;
212+ struct st33zp24_dev *tpm_dev;
213+
214+ tpm_dev = (struct st33zp24_dev *)TPM_VPRIV(chip);
215+
216+ stop = jiffies + chip->vendor.timeout_d;
217+ do {
218+ tpm_reg = TPM_STS + 1;
219+ status = tpm_dev->ops->recv(tpm_dev->phy_id, tpm_reg, &temp, 1);
220+ if (status < 0)
221+ return -EBUSY;
222+
223+ tpm_reg = TPM_STS + 2;
224+ burstcnt = temp;
225+ status = tpm_dev->ops->recv(tpm_dev->phy_id, tpm_reg, &temp, 1);
226+ if (status < 0)
227+ return -EBUSY;
228+
229+ burstcnt |= temp << 8;
230+ if (burstcnt)
231+ return burstcnt;
232+ msleep(TPM_TIMEOUT);
233+ } while (time_before(jiffies, stop));
234+ return -EBUSY;
235+} /* get_burstcount() */
236+
237+
238+/*
239+ * wait_for_tpm_stat_cond
240+ * @param: chip, chip description
241+ * @param: mask, expected mask value
242+ * @param: check_cancel, does the command expected to be canceled ?
243+ * @param: canceled, did we received a cancel request ?
244+ * @return: true if status == mask or if the command is canceled.
245+ * false in other cases.
246+ */
247+static bool wait_for_tpm_stat_cond(struct tpm_chip *chip, u8 mask,
248+ bool check_cancel, bool *canceled)
249+{
250+ u8 status = chip->ops->status(chip);
251+
252+ *canceled = false;
253+ if ((status & mask) == mask)
254+ return true;
255+ if (check_cancel && chip->ops->req_canceled(chip, status)) {
256+ *canceled = true;
257+ return true;
258+ }
259+ return false;
260+}
261+
262+/*
263+ * wait_for_stat wait for a TPM_STS value
264+ * @param: chip, the tpm chip description
265+ * @param: mask, the value mask to wait
266+ * @param: timeout, the timeout
267+ * @param: queue, the wait queue.
268+ * @param: check_cancel, does the command can be cancelled ?
269+ * @return: the tpm status, 0 if success, -ETIME if timeout is reached.
270+ */
271+static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout,
272+ wait_queue_head_t *queue, bool check_cancel)
273+{
274+ unsigned long stop;
275+ int ret = 0;
276+ bool canceled = false;
277+ bool condition;
278+ u32 cur_intrs;
279+ u8 status;
280+ struct st33zp24_dev *tpm_dev;
281+
282+ tpm_dev = (struct st33zp24_dev *)TPM_VPRIV(chip);
283+
284+ /* check current status */
285+ status = st33zp24_status(chip);
286+ if ((status & mask) == mask)
287+ return 0;
288+
289+ stop = jiffies + timeout;
290+
291+ if (chip->vendor.irq) {
292+ cur_intrs = tpm_dev->intrs;
293+ clear_interruption(tpm_dev);
294+ enable_irq(chip->vendor.irq);
295+
296+ do {
297+ if (ret == -ERESTARTSYS && freezing(current))
298+ clear_thread_flag(TIF_SIGPENDING);
299+
300+ timeout = stop - jiffies;
301+ if ((long) timeout <= 0)
302+ return -1;
303+
304+ ret = wait_event_interruptible_timeout(*queue,
305+ cur_intrs != tpm_dev->intrs,
306+ timeout);
307+ clear_interruption(tpm_dev);
308+ condition = wait_for_tpm_stat_cond(chip, mask,
309+ check_cancel, &canceled);
310+ if (ret >= 0 && condition) {
311+ if (canceled)
312+ return -ECANCELED;
313+ return 0;
314+ }
315+ } while (ret == -ERESTARTSYS && freezing(current));
316+
317+ disable_irq_nosync(chip->vendor.irq);
318+
319+ } else {
320+ do {
321+ msleep(TPM_TIMEOUT);
322+ status = chip->ops->status(chip);
323+ if ((status & mask) == mask)
324+ return 0;
325+ } while (time_before(jiffies, stop));
326+ }
327+
328+ return -ETIME;
329+} /* wait_for_stat() */
330+
331+/*
332+ * recv_data receive data
333+ * @param: chip, the tpm chip description
334+ * @param: buf, the buffer where the data are received
335+ * @param: count, the number of data to receive
336+ * @return: the number of bytes read from TPM FIFO.
337+ */
338+static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
339+{
340+ int size = 0, burstcnt, len, ret;
341+ struct st33zp24_dev *tpm_dev;
342+
343+ tpm_dev = (struct st33zp24_dev *)TPM_VPRIV(chip);
344+
345+ while (size < count &&
346+ wait_for_stat(chip,
347+ TPM_STS_DATA_AVAIL | TPM_STS_VALID,
348+ chip->vendor.timeout_c,
349+ &chip->vendor.read_queue, true) == 0) {
350+ burstcnt = get_burstcount(chip);
351+ if (burstcnt < 0)
352+ return burstcnt;
353+ len = min_t(int, burstcnt, count - size);
354+ ret = tpm_dev->ops->recv(tpm_dev->phy_id, TPM_DATA_FIFO,
355+ buf + size, len);
356+ if (ret < 0)
357+ return ret;
358+
359+ size += len;
360+ }
361+ return size;
362+}
363+
364+/*
365+ * tpm_ioserirq_handler the serirq irq handler
366+ * @param: irq, the tpm chip description
367+ * @param: dev_id, the description of the chip
368+ * @return: the status of the handler.
369+ */
370+static irqreturn_t tpm_ioserirq_handler(int irq, void *dev_id)
371+{
372+ struct tpm_chip *chip = dev_id;
373+ struct st33zp24_dev *tpm_dev;
374+
375+ tpm_dev = (struct st33zp24_dev *)TPM_VPRIV(chip);
376+
377+ tpm_dev->intrs++;
378+ wake_up_interruptible(&chip->vendor.read_queue);
379+ disable_irq_nosync(chip->vendor.irq);
380+
381+ return IRQ_HANDLED;
382+} /* tpm_ioserirq_handler() */
383+
384+/*
385+ * st33zp24_send send TPM commands through the I2C bus.
386+ *
387+ * @param: chip, the tpm_chip description as specified in driver/char/tpm/tpm.h
388+ * @param: buf, the buffer to send.
389+ * @param: count, the number of bytes to send.
390+ * @return: In case of success the number of bytes sent.
391+ * In other case, a < 0 value describing the issue.
392+ */
393+static int st33zp24_send(struct tpm_chip *chip, unsigned char *buf,
394+ size_t len)
395+{
396+ u32 status, i, size;
397+ int burstcnt = 0;
398+ int ret;
399+ u8 data;
400+ struct st33zp24_dev *tpm_dev;
401+
402+ if (!chip)
403+ return -EBUSY;
404+ if (len < TPM_HEADER_SIZE)
405+ return -EBUSY;
406+
407+ tpm_dev = (struct st33zp24_dev *)TPM_VPRIV(chip);
408+
409+ ret = request_locality(chip);
410+ if (ret < 0)
411+ return ret;
412+
413+ status = st33zp24_status(chip);
414+ if ((status & TPM_STS_COMMAND_READY) == 0) {
415+ st33zp24_cancel(chip);
416+ if (wait_for_stat
417+ (chip, TPM_STS_COMMAND_READY, chip->vendor.timeout_b,
418+ &chip->vendor.read_queue, false) < 0) {
419+ ret = -ETIME;
420+ goto out_err;
421+ }
422+ }
423+
424+ for (i = 0; i < len - 1;) {
425+ burstcnt = get_burstcount(chip);
426+ if (burstcnt < 0)
427+ return burstcnt;
428+ size = min_t(int, len - i - 1, burstcnt);
429+ ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_DATA_FIFO,
430+ buf + i, size);
431+ if (ret < 0)
432+ goto out_err;
433+
434+ i += size;
435+ }
436+
437+ status = st33zp24_status(chip);
438+ if ((status & TPM_STS_DATA_EXPECT) == 0) {
439+ ret = -EIO;
440+ goto out_err;
441+ }
442+
443+ ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_DATA_FIFO,
444+ buf + len - 1, 1);
445+ if (ret < 0)
446+ goto out_err;
447+
448+ status = st33zp24_status(chip);
449+ if ((status & TPM_STS_DATA_EXPECT) != 0) {
450+ ret = -EIO;
451+ goto out_err;
452+ }
453+
454+ data = TPM_STS_GO;
455+ ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_STS, &data, 1);
456+ if (ret < 0)
457+ goto out_err;
458+
459+ return len;
460+out_err:
461+ st33zp24_cancel(chip);
462+ release_locality(chip);
463+ return ret;
464+}
465+
466+/*
467+ * st33zp24_recv received TPM response through TPM phy.
468+ * @param: chip, the tpm_chip description as specified in driver/char/tpm/tpm.h.
469+ * @param: buf, the buffer to store datas.
470+ * @param: count, the number of bytes to send.
471+ * @return: In case of success the number of bytes received.
472+ * In other case, a < 0 value describing the issue.
473+ */
474+static int st33zp24_recv(struct tpm_chip *chip, unsigned char *buf,
475+ size_t count)
476+{
477+ int size = 0;
478+ int expected;
479+
480+ if (!chip)
481+ return -EBUSY;
482+
483+ if (count < TPM_HEADER_SIZE) {
484+ size = -EIO;
485+ goto out;
486+ }
487+
488+ size = recv_data(chip, buf, TPM_HEADER_SIZE);
489+ if (size < TPM_HEADER_SIZE) {
490+ dev_err(&chip->dev, "Unable to read header\n");
491+ goto out;
492+ }
493+
494+ expected = be32_to_cpu(*(__be32 *)(buf + 2));
495+ if (expected > count) {
496+ size = -EIO;
497+ goto out;
498+ }
499+
500+ size += recv_data(chip, &buf[TPM_HEADER_SIZE],
501+ expected - TPM_HEADER_SIZE);
502+ if (size < expected) {
503+ dev_err(&chip->dev, "Unable to read remainder of result\n");
504+ size = -ETIME;
505+ }
506+
507+out:
508+ st33zp24_cancel(chip);
509+ release_locality(chip);
510+ return size;
511+}
512+
513+/*
514+ * st33zp24_req_canceled
515+ * @param: chip, the tpm_chip description as specified in driver/char/tpm/tpm.h.
516+ * @param: status, the TPM status.
517+ * @return: Does TPM ready to compute a new command ? true.
518+ */
519+static bool st33zp24_req_canceled(struct tpm_chip *chip, u8 status)
520+{
521+ return (status == TPM_STS_COMMAND_READY);
522+}
523+
524+static const struct tpm_class_ops st33zp24_tpm = {
525+ .send = st33zp24_send,
526+ .recv = st33zp24_recv,
527+ .cancel = st33zp24_cancel,
528+ .status = st33zp24_status,
529+ .req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
530+ .req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
531+ .req_canceled = st33zp24_req_canceled,
532+};
533+
534+/*
535+ * st33zp24_probe initialize the TPM device
536+ * @param: client, the i2c_client drescription (TPM I2C description).
537+ * @param: id, the i2c_device_id struct.
538+ * @return: 0 in case of success.
539+ * -1 in other case.
540+ */
541+int st33zp24_probe(void *phy_id, const struct st33zp24_phy_ops *ops,
542+ struct device *dev, int irq, int io_lpcpd)
543+{
544+ int ret;
545+ u8 intmask = 0;
546+ struct tpm_chip *chip;
547+ struct st33zp24_dev *tpm_dev;
548+
549+ chip = tpmm_chip_alloc(dev, &st33zp24_tpm);
550+ if (IS_ERR(chip))
551+ return PTR_ERR(chip);
552+
553+ tpm_dev = devm_kzalloc(dev, sizeof(struct st33zp24_dev),
554+ GFP_KERNEL);
555+ if (!tpm_dev)
556+ return -ENOMEM;
557+
558+ TPM_VPRIV(chip) = tpm_dev;
559+ tpm_dev->phy_id = phy_id;
560+ tpm_dev->ops = ops;
561+
562+ chip->vendor.timeout_a = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
563+ chip->vendor.timeout_b = msecs_to_jiffies(TIS_LONG_TIMEOUT);
564+ chip->vendor.timeout_c = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
565+ chip->vendor.timeout_d = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
566+
567+ chip->vendor.locality = LOCALITY0;
568+
569+ if (irq) {
570+ /* INTERRUPT Setup */
571+ init_waitqueue_head(&chip->vendor.read_queue);
572+ tpm_dev->intrs = 0;
573+
574+ if (request_locality(chip) != LOCALITY0) {
575+ ret = -ENODEV;
576+ goto _tpm_clean_answer;
577+ }
578+
579+ clear_interruption(tpm_dev);
580+ ret = devm_request_irq(dev, irq, tpm_ioserirq_handler,
581+ IRQF_TRIGGER_HIGH, "TPM SERIRQ management",
582+ chip);
583+ if (ret < 0) {
584+ dev_err(&chip->dev, "TPM SERIRQ signals %d not available\n",
585+ irq);
586+ goto _tpm_clean_answer;
587+ }
588+
589+ intmask |= TPM_INTF_CMD_READY_INT
590+ | TPM_INTF_STS_VALID_INT
591+ | TPM_INTF_DATA_AVAIL_INT;
592+
593+ ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_INT_ENABLE,
594+ &intmask, 1);
595+ if (ret < 0)
596+ goto _tpm_clean_answer;
597+
598+ intmask = TPM_GLOBAL_INT_ENABLE;
599+ ret = tpm_dev->ops->send(tpm_dev->phy_id, (TPM_INT_ENABLE + 3),
600+ &intmask, 1);
601+ if (ret < 0)
602+ goto _tpm_clean_answer;
603+
604+ chip->vendor.irq = irq;
605+
606+ disable_irq_nosync(chip->vendor.irq);
607+
608+ tpm_gen_interrupt(chip);
609+ }
610+
611+ tpm_get_timeouts(chip);
612+ tpm_do_selftest(chip);
613+
614+ return tpm_chip_register(chip);
615+_tpm_clean_answer:
616+ dev_info(&chip->dev, "TPM initialization fail\n");
617+ return ret;
618+}
619+EXPORT_SYMBOL(st33zp24_probe);
620+
621+/*
622+ * st33zp24_remove remove the TPM device
623+ * @param: tpm_data, the tpm phy.
624+ * @return: 0 in case of success.
625+ */
626+int st33zp24_remove(struct tpm_chip *chip)
627+{
628+ tpm_chip_unregister(chip);
629+ return 0;
630+}
631+EXPORT_SYMBOL(st33zp24_remove);
632+
633+#ifdef CONFIG_PM_SLEEP
634+/*
635+ * st33zp24_pm_suspend suspend the TPM device
636+ * @param: tpm_data, the tpm phy.
637+ * @param: mesg, the power management message.
638+ * @return: 0 in case of success.
639+ */
640+int st33zp24_pm_suspend(struct device *dev)
641+{
642+ struct tpm_chip *chip = dev_get_drvdata(dev);
643+ struct st33zp24_dev *tpm_dev;
644+ int ret = 0;
645+
646+ tpm_dev = (struct st33zp24_dev *)TPM_VPRIV(chip);
647+
648+ if (gpio_is_valid(tpm_dev->io_lpcpd))
649+ gpio_set_value(tpm_dev->io_lpcpd, 0);
650+ else
651+ ret = tpm_pm_suspend(dev);
652+
653+ return ret;
654+} /* st33zp24_pm_suspend() */
655+EXPORT_SYMBOL(st33zp24_pm_suspend);
656+
657+/*
658+ * st33zp24_pm_resume resume the TPM device
659+ * @param: tpm_data, the tpm phy.
660+ * @return: 0 in case of success.
661+ */
662+int st33zp24_pm_resume(struct device *dev)
663+{
664+ struct tpm_chip *chip = dev_get_drvdata(dev);
665+ struct st33zp24_dev *tpm_dev;
666+ int ret = 0;
667+
668+ tpm_dev = (struct st33zp24_dev *)TPM_VPRIV(chip);
669+
670+ if (gpio_is_valid(tpm_dev->io_lpcpd)) {
671+ gpio_set_value(tpm_dev->io_lpcpd, 1);
672+ ret = wait_for_stat(chip,
673+ TPM_STS_VALID, chip->vendor.timeout_b,
674+ &chip->vendor.read_queue, false);
675+ } else {
676+ ret = tpm_pm_resume(dev);
677+ if (!ret)
678+ tpm_do_selftest(chip);
679+ }
680+ return ret;
681+} /* st33zp24_pm_resume() */
682+EXPORT_SYMBOL(st33zp24_pm_resume);
683+#endif
684+
685+MODULE_AUTHOR("TPM support (TPMsupport@list.st.com)");
686+MODULE_DESCRIPTION("ST33ZP24 TPM 1.2 driver");
687+MODULE_VERSION("1.3.0");
688+MODULE_LICENSE("GPL");
drivers/char/tpm/st33zp24/st33zp24.h+34−0
@@ -0,0 +1,34 @@
1+/*
2+ * STMicroelectronics TPM Linux driver for TPM ST33ZP24
3+ * Copyright (C) 2009 - 2015 STMicroelectronics
4+ *
5+ * This program is free software; you can redistribute it and/or modify it
6+ * under the terms and conditions of the GNU General Public License,
7+ * version 2, as published by the Free Software Foundation.
8+ *
9+ * This program is distributed in the hope that it will be useful,
10+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
11+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12+ * GNU General Public License for more details.
13+ *
14+ * You should have received a copy of the GNU General Public License
15+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
16+ */
17+
18+#ifndef __LOCAL_ST33ZP24_H__
19+#define __LOCAL_ST33ZP24_H__
20+
21+struct st33zp24_phy_ops {
22+ int (*send)(void *phy_id, u8 tpm_register, u8 *tpm_data, int tpm_size);
23+ int (*recv)(void *phy_id, u8 tpm_register, u8 *tpm_data, int tpm_size);
24+};
25+
26+#ifdef CONFIG_PM_SLEEP
27+int st33zp24_pm_suspend(struct device *dev);
28+int st33zp24_pm_resume(struct device *dev);
29+#endif
30+
31+int st33zp24_probe(void *phy_id, const struct st33zp24_phy_ops *ops,
32+ struct device *dev, int irq, int io_lpcpd);
33+int st33zp24_remove(struct tpm_chip *chip);
34+#endif /* __LOCAL_ST33ZP24_H__ */
drivers/char/tpm/tpm_i2c_stm_st33.c+0−915
@@ -1,915 +0,0 @@
1−/*
2− * STMicroelectronics TPM I2C Linux driver for TPM ST33ZP24
3− * Copyright (C) 2009, 2010, 2014 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
16− * along with this program; if not, see <http://www.gnu.org/licenses/>.
17− *
18− * STMicroelectronics version 1.2.1, Copyright (C) 2014
19− * STMicroelectronics comes with ABSOLUTELY NO WARRANTY.
20− * This is free software, and you are welcome to redistribute it
21− * under certain conditions.
22− *
23− * @Author: Christophe RICARD tpmsupport@st.com
24− *
25− * @File: tpm_stm_st33_i2c.c
26− *
27− * @Synopsis:
28− * 09/15/2010: First shot driver tpm_tis driver for
29− * lpc is used as model.
30− */
31−
32−#include <linux/pci.h>
33−#include <linux/module.h>
34−#include <linux/platform_device.h>
35−#include <linux/i2c.h>
36−#include <linux/fs.h>
37−#include <linux/miscdevice.h>
38−#include <linux/kernel.h>
39−#include <linux/delay.h>
40−#include <linux/wait.h>
41−#include <linux/freezer.h>
42−#include <linux/string.h>
43−#include <linux/interrupt.h>
44−#include <linux/sysfs.h>
45−#include <linux/gpio.h>
46−#include <linux/sched.h>
47−#include <linux/uaccess.h>
48−#include <linux/io.h>
49−#include <linux/slab.h>
50−#include <linux/of_irq.h>
51−#include <linux/of_gpio.h>
52−
53−#include <linux/platform_data/tpm_stm_st33.h>
54−#include "tpm.h"
55−
56−#define TPM_ACCESS 0x0
57−#define TPM_STS 0x18
58−#define TPM_HASH_END 0x20
59−#define TPM_DATA_FIFO 0x24
60−#define TPM_HASH_DATA 0x24
61−#define TPM_HASH_START 0x28
62−#define TPM_INTF_CAPABILITY 0x14
63−#define TPM_INT_STATUS 0x10
64−#define TPM_INT_ENABLE 0x08
65−
66−#define TPM_DUMMY_BYTE 0xAA
67−#define TPM_WRITE_DIRECTION 0x80
68−#define TPM_HEADER_SIZE 10
69−#define TPM_BUFSIZE 2048
70−
71−#define LOCALITY0 0
72−
73−
74−enum stm33zp24_access {
75− TPM_ACCESS_VALID = 0x80,
76− TPM_ACCESS_ACTIVE_LOCALITY = 0x20,
77− TPM_ACCESS_REQUEST_PENDING = 0x04,
78− TPM_ACCESS_REQUEST_USE = 0x02,
79−};
80−
81−enum stm33zp24_status {
82− TPM_STS_VALID = 0x80,
83− TPM_STS_COMMAND_READY = 0x40,
84− TPM_STS_GO = 0x20,
85− TPM_STS_DATA_AVAIL = 0x10,
86− TPM_STS_DATA_EXPECT = 0x08,
87−};
88−
89−enum stm33zp24_int_flags {
90− TPM_GLOBAL_INT_ENABLE = 0x80,
91− TPM_INTF_CMD_READY_INT = 0x080,
92− TPM_INTF_FIFO_AVALAIBLE_INT = 0x040,
93− TPM_INTF_WAKE_UP_READY_INT = 0x020,
94− TPM_INTF_LOCALITY_CHANGE_INT = 0x004,
95− TPM_INTF_STS_VALID_INT = 0x002,
96− TPM_INTF_DATA_AVAIL_INT = 0x001,
97−};
98−
99−enum tis_defaults {
100− TIS_SHORT_TIMEOUT = 750,
101− TIS_LONG_TIMEOUT = 2000,
102−};
103−
104−struct tpm_stm_dev {
105− struct i2c_client *client;
106− struct tpm_chip *chip;
107− u8 buf[TPM_BUFSIZE + 1];
108− u32 intrs;
109− int io_lpcpd;
110−};
111−
112−/*
113− * write8_reg
114− * Send byte to the TIS register according to the ST33ZP24 I2C protocol.
115− * @param: tpm_register, the tpm tis register where the data should be written
116− * @param: tpm_data, the tpm_data to write inside the tpm_register
117− * @param: tpm_size, The length of the data
118− * @return: Returns negative errno, or else the number of bytes written.
119− */
120−static int write8_reg(struct tpm_stm_dev *tpm_dev, u8 tpm_register,
121− u8 *tpm_data, u16 tpm_size)
122−{
123− tpm_dev->buf[0] = tpm_register;
124− memcpy(tpm_dev->buf + 1, tpm_data, tpm_size);
125− return i2c_master_send(tpm_dev->client, tpm_dev->buf, tpm_size + 1);
126−} /* write8_reg() */
127−
128−/*
129− * read8_reg
130− * Recv byte from the TIS register according to the ST33ZP24 I2C protocol.
131− * @param: tpm_register, the tpm tis register where the data should be read
132− * @param: tpm_data, the TPM response
133− * @param: tpm_size, tpm TPM response size to read.
134− * @return: number of byte read successfully: should be one if success.
135− */
136−static int read8_reg(struct tpm_stm_dev *tpm_dev, u8 tpm_register,
137− u8 *tpm_data, int tpm_size)
138−{
139− u8 status = 0;
140− u8 data;
141−
142− data = TPM_DUMMY_BYTE;
143− status = write8_reg(tpm_dev, tpm_register, &data, 1);
144− if (status == 2)
145− status = i2c_master_recv(tpm_dev->client, tpm_data, tpm_size);
146− return status;
147−} /* read8_reg() */
148−
149−/*
150− * I2C_WRITE_DATA
151− * Send byte to the TIS register according to the ST33ZP24 I2C protocol.
152− * @param: tpm_dev, the chip description
153− * @param: tpm_register, the tpm tis register where the data should be written
154− * @param: tpm_data, the tpm_data to write inside the tpm_register
155− * @param: tpm_size, The length of the data
156− * @return: number of byte written successfully: should be one if success.
157− */
158−#define I2C_WRITE_DATA(tpm_dev, tpm_register, tpm_data, tpm_size) \
159− (write8_reg(tpm_dev, tpm_register | \
160− TPM_WRITE_DIRECTION, tpm_data, tpm_size))
161−
162−/*
163− * I2C_READ_DATA
164− * Recv byte from the TIS register according to the ST33ZP24 I2C protocol.
165− * @param: tpm_dev, the chip description
166− * @param: tpm_register, the tpm tis register where the data should be read
167− * @param: tpm_data, the TPM response
168− * @param: tpm_size, tpm TPM response size to read.
169− * @return: number of byte read successfully: should be one if success.
170− */
171−#define I2C_READ_DATA(tpm_dev, tpm_register, tpm_data, tpm_size) \
172− (read8_reg(tpm_dev, tpm_register, tpm_data, tpm_size))
173−
174−/*
175− * clear_interruption
176− * clear the TPM interrupt register.
177− * @param: tpm, the chip description
178− * @return: the TPM_INT_STATUS value
179− */
180−static u8 clear_interruption(struct tpm_stm_dev *tpm_dev)
181−{
182− u8 interrupt;
183−
184− I2C_READ_DATA(tpm_dev, TPM_INT_STATUS, &interrupt, 1);
185− I2C_WRITE_DATA(tpm_dev, TPM_INT_STATUS, &interrupt, 1);
186− return interrupt;
187−} /* clear_interruption() */
188−
189−/*
190− * tpm_stm_i2c_cancel, cancel is not implemented.
191− * @param: chip, the tpm_chip description as specified in driver/char/tpm/tpm.h
192− */
193−static void tpm_stm_i2c_cancel(struct tpm_chip *chip)
194−{
195− struct tpm_stm_dev *tpm_dev;
196− u8 data;
197−
198− tpm_dev = (struct tpm_stm_dev *)TPM_VPRIV(chip);
199−
200− data = TPM_STS_COMMAND_READY;
201− I2C_WRITE_DATA(tpm_dev, TPM_STS, &data, 1);
202−} /* tpm_stm_i2c_cancel() */
203−
204−/*
205− * tpm_stm_spi_status return the TPM_STS register
206− * @param: chip, the tpm chip description
207− * @return: the TPM_STS register value.
208− */
209−static u8 tpm_stm_i2c_status(struct tpm_chip *chip)
210−{
211− struct tpm_stm_dev *tpm_dev;
212− u8 data;
213−
214− tpm_dev = (struct tpm_stm_dev *)TPM_VPRIV(chip);
215−
216− I2C_READ_DATA(tpm_dev, TPM_STS, &data, 1);
217− return data;
218−} /* tpm_stm_i2c_status() */
219−
220−
221−/*
222− * check_locality if the locality is active
223− * @param: chip, the tpm chip description
224− * @return: the active locality or -EACCESS.
225− */
226−static int check_locality(struct tpm_chip *chip)
227−{
228− struct tpm_stm_dev *tpm_dev;
229− u8 data;
230− u8 status;
231−
232− tpm_dev = (struct tpm_stm_dev *)TPM_VPRIV(chip);
233−
234− status = I2C_READ_DATA(tpm_dev, TPM_ACCESS, &data, 1);
235− if (status && (data &
236− (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) ==
237− (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID))
238− return chip->vendor.locality;
239−
240− return -EACCES;
241−} /* check_locality() */
242−
243−/*
244− * request_locality request the TPM locality
245− * @param: chip, the chip description
246− * @return: the active locality or EACCESS.
247− */
248−static int request_locality(struct tpm_chip *chip)
249−{
250− unsigned long stop;
251− long ret;
252− struct tpm_stm_dev *tpm_dev;
253− u8 data;
254−
255− if (check_locality(chip) == chip->vendor.locality)
256− return chip->vendor.locality;
257−
258− tpm_dev = (struct tpm_stm_dev *)TPM_VPRIV(chip);
259−
260− data = TPM_ACCESS_REQUEST_USE;
261− ret = I2C_WRITE_DATA(tpm_dev, TPM_ACCESS, &data, 1);
262− if (ret < 0)
263− goto end;
264−
265− stop = jiffies + chip->vendor.timeout_a;
266−
267− /* Request locality is usually effective after the request */
268− do {
269− if (check_locality(chip) >= 0)
270− return chip->vendor.locality;
271− msleep(TPM_TIMEOUT);
272− } while (time_before(jiffies, stop));
273− ret = -EACCES;
274−end:
275− return ret;
276−} /* request_locality() */
277−
278−/*
279− * release_locality release the active locality
280− * @param: chip, the tpm chip description.
281− */
282−static void release_locality(struct tpm_chip *chip)
283−{
284− struct tpm_stm_dev *tpm_dev;
285− u8 data;
286−
287− tpm_dev = (struct tpm_stm_dev *)TPM_VPRIV(chip);
288− data = TPM_ACCESS_ACTIVE_LOCALITY;
289−
290− I2C_WRITE_DATA(tpm_dev, TPM_ACCESS, &data, 1);
291−}
292−
293−/*
294− * get_burstcount return the burstcount address 0x19 0x1A
295− * @param: chip, the chip description
296− * return: the burstcount.
297− */
298−static int get_burstcount(struct tpm_chip *chip)
299−{
300− unsigned long stop;
301− int burstcnt, status;
302− u8 tpm_reg, temp;
303− struct tpm_stm_dev *tpm_dev;
304−
305− tpm_dev = (struct tpm_stm_dev *)TPM_VPRIV(chip);
306−
307− stop = jiffies + chip->vendor.timeout_d;
308− do {
309− tpm_reg = TPM_STS + 1;
310− status = I2C_READ_DATA(tpm_dev, tpm_reg, &temp, 1);
311− if (status < 0)
312− goto end;
313−
314− tpm_reg = tpm_reg + 1;
315− burstcnt = temp;
316− status = I2C_READ_DATA(tpm_dev, tpm_reg, &temp, 1);
317− if (status < 0)
318− goto end;
319−
320− burstcnt |= temp << 8;
321− if (burstcnt)
322− return burstcnt;
323− msleep(TPM_TIMEOUT);
324− } while (time_before(jiffies, stop));
325−
326−end:
327− return -EBUSY;
328−} /* get_burstcount() */
329−
330−static bool wait_for_tpm_stat_cond(struct tpm_chip *chip, u8 mask,
331− bool check_cancel, bool *canceled)
332−{
333− u8 status = chip->ops->status(chip);
334−
335− *canceled = false;
336− if ((status & mask) == mask)
337− return true;
338− if (check_cancel && chip->ops->req_canceled(chip, status)) {
339− *canceled = true;
340− return true;
341− }
342− return false;
343−}
344−
345−/*
346− * interrupt_to_status
347− * @param: irq_mask, the irq mask value to wait
348− * @return: the corresponding tpm_sts value
349− */
350−static u8 interrupt_to_status(u8 irq_mask)
351−{
352− u8 status = 0;
353−
354− if ((irq_mask & TPM_INTF_STS_VALID_INT) == TPM_INTF_STS_VALID_INT)
355− status |= TPM_STS_VALID;
356− if ((irq_mask & TPM_INTF_DATA_AVAIL_INT) == TPM_INTF_DATA_AVAIL_INT)
357− status |= TPM_STS_DATA_AVAIL;
358− if ((irq_mask & TPM_INTF_CMD_READY_INT) == TPM_INTF_CMD_READY_INT)
359− status |= TPM_STS_COMMAND_READY;
360−
361− return status;
362−} /* status_to_interrupt() */
363−
364−/*
365− * wait_for_stat wait for a TPM_STS value
366− * @param: chip, the tpm chip description
367− * @param: mask, the value mask to wait
368− * @param: timeout, the timeout
369− * @param: queue, the wait queue.
370− * @param: check_cancel, does the command can be cancelled ?
371− * @return: the tpm status, 0 if success, -ETIME if timeout is reached.
372− */
373−static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout,
374− wait_queue_head_t *queue, bool check_cancel)
375−{
376− unsigned long stop;
377− int ret;
378− bool canceled = false;
379− bool condition;
380− u32 cur_intrs;
381− u8 interrupt, status;
382− struct tpm_stm_dev *tpm_dev;
383−
384− tpm_dev = (struct tpm_stm_dev *)TPM_VPRIV(chip);
385−
386− /* check current status */
387− status = tpm_stm_i2c_status(chip);
388− if ((status & mask) == mask)
389− return 0;
390−
391− stop = jiffies + timeout;
392−
393− if (chip->vendor.irq) {
394− cur_intrs = tpm_dev->intrs;
395− interrupt = clear_interruption(tpm_dev);
396− enable_irq(chip->vendor.irq);
397−
398−again:
399− timeout = stop - jiffies;
400− if ((long) timeout <= 0)
401− return -1;
402−
403− ret = wait_event_interruptible_timeout(*queue,
404− cur_intrs != tpm_dev->intrs, timeout);
405−
406− interrupt |= clear_interruption(tpm_dev);
407− status = interrupt_to_status(interrupt);
408− condition = wait_for_tpm_stat_cond(chip, mask,
409− check_cancel, &canceled);
410−
411− if (ret >= 0 && condition) {
412− if (canceled)
413− return -ECANCELED;
414− return 0;
415− }
416− if (ret == -ERESTARTSYS && freezing(current)) {
417− clear_thread_flag(TIF_SIGPENDING);
418− goto again;
419− }
420− disable_irq_nosync(chip->vendor.irq);
421−
422− } else {
423− do {
424− msleep(TPM_TIMEOUT);
425− status = chip->ops->status(chip);
426− if ((status & mask) == mask)
427− return 0;
428− } while (time_before(jiffies, stop));
429− }
430−
431− return -ETIME;
432−} /* wait_for_stat() */
433−
434−/*
435− * recv_data receive data
436− * @param: chip, the tpm chip description
437− * @param: buf, the buffer where the data are received
438− * @param: count, the number of data to receive
439− * @return: the number of bytes read from TPM FIFO.
440− */
441−static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
442−{
443− int size = 0, burstcnt, len, ret;
444− struct tpm_stm_dev *tpm_dev;
445−
446− tpm_dev = (struct tpm_stm_dev *)TPM_VPRIV(chip);
447−
448− while (size < count &&
449− wait_for_stat(chip,
450− TPM_STS_DATA_AVAIL | TPM_STS_VALID,
451− chip->vendor.timeout_c,
452− &chip->vendor.read_queue, true) == 0) {
453− burstcnt = get_burstcount(chip);
454− if (burstcnt < 0)
455− return burstcnt;
456− len = min_t(int, burstcnt, count - size);
457− ret = I2C_READ_DATA(tpm_dev, TPM_DATA_FIFO, buf + size, len);
458− if (ret < 0)
459− return ret;
460−
461− size += len;
462− }
463− return size;
464−}
465−
466−/*
467− * tpm_ioserirq_handler the serirq irq handler
468− * @param: irq, the tpm chip description
469− * @param: dev_id, the description of the chip
470− * @return: the status of the handler.
471− */
472−static irqreturn_t tpm_ioserirq_handler(int irq, void *dev_id)
473−{
474− struct tpm_chip *chip = dev_id;
475− struct tpm_stm_dev *tpm_dev;
476−
477− tpm_dev = (struct tpm_stm_dev *)TPM_VPRIV(chip);
478−
479− tpm_dev->intrs++;
480− wake_up_interruptible(&chip->vendor.read_queue);
481− disable_irq_nosync(chip->vendor.irq);
482−
483− return IRQ_HANDLED;
484−} /* tpm_ioserirq_handler() */
485−
486−
487−/*
488− * tpm_stm_i2c_send send TPM commands through the I2C bus.
489− *
490− * @param: chip, the tpm_chip description as specified in driver/char/tpm/tpm.h
491− * @param: buf, the buffer to send.
492− * @param: count, the number of bytes to send.
493− * @return: In case of success the number of bytes sent.
494− * In other case, a < 0 value describing the issue.
495− */
496−static int tpm_stm_i2c_send(struct tpm_chip *chip, unsigned char *buf,
497− size_t len)
498−{
499− u32 status, i, size;
500− int burstcnt = 0;
501− int ret;
502− u8 data;
503− struct i2c_client *client;
504− struct tpm_stm_dev *tpm_dev;
505−
506− if (!chip)
507− return -EBUSY;
508− if (len < TPM_HEADER_SIZE)
509− return -EBUSY;
510−
511− tpm_dev = (struct tpm_stm_dev *)TPM_VPRIV(chip);
512− client = tpm_dev->client;
513−
514− client->flags = 0;
515−
516− ret = request_locality(chip);
517− if (ret < 0)
518− return ret;
519−
520− status = tpm_stm_i2c_status(chip);
521− if ((status & TPM_STS_COMMAND_READY) == 0) {
522− tpm_stm_i2c_cancel(chip);
523− if (wait_for_stat
524− (chip, TPM_STS_COMMAND_READY, chip->vendor.timeout_b,
525− &chip->vendor.read_queue, false) < 0) {
526− ret = -ETIME;
527− goto out_err;
528− }
529− }
530−
531− for (i = 0; i < len - 1;) {
532− burstcnt = get_burstcount(chip);
533− if (burstcnt < 0)
534− return burstcnt;
535− size = min_t(int, len - i - 1, burstcnt);
536− ret = I2C_WRITE_DATA(tpm_dev, TPM_DATA_FIFO, buf + i, size);
537− if (ret < 0)
538− goto out_err;
539−
540− i += size;
541− }
542−
543− status = tpm_stm_i2c_status(chip);
544− if ((status & TPM_STS_DATA_EXPECT) == 0) {
545− ret = -EIO;
546− goto out_err;
547− }
548−
549− ret = I2C_WRITE_DATA(tpm_dev, TPM_DATA_FIFO, buf + len - 1, 1);
550− if (ret < 0)
551− goto out_err;
552−
553− status = tpm_stm_i2c_status(chip);
554− if ((status & TPM_STS_DATA_EXPECT) != 0) {
555− ret = -EIO;
556− goto out_err;
557− }
558−
559− data = TPM_STS_GO;
560− I2C_WRITE_DATA(tpm_dev, TPM_STS, &data, 1);
561−
562− return len;
563−out_err:
564− tpm_stm_i2c_cancel(chip);
565− release_locality(chip);
566− return ret;
567−}
568−
569−/*
570− * tpm_stm_i2c_recv received TPM response through the I2C bus.
571− * @param: chip, the tpm_chip description as specified in driver/char/tpm/tpm.h.
572− * @param: buf, the buffer to store datas.
573− * @param: count, the number of bytes to send.
574− * @return: In case of success the number of bytes received.
575− * In other case, a < 0 value describing the issue.
576− */
577−static int tpm_stm_i2c_recv(struct tpm_chip *chip, unsigned char *buf,
578− size_t count)
579−{
580− int size = 0;
581− int expected;
582−
583− if (!chip)
584− return -EBUSY;
585−
586− if (count < TPM_HEADER_SIZE) {
587− size = -EIO;
588− goto out;
589− }
590−
591− size = recv_data(chip, buf, TPM_HEADER_SIZE);
592− if (size < TPM_HEADER_SIZE) {
593− dev_err(chip->pdev, "Unable to read header\n");
594− goto out;
595− }
596−
597− expected = be32_to_cpu(*(__be32 *)(buf + 2));
598− if (expected > count) {
599− size = -EIO;
600− goto out;
601− }
602−
603− size += recv_data(chip, &buf[TPM_HEADER_SIZE],
604− expected - TPM_HEADER_SIZE);
605− if (size < expected) {
606− dev_err(chip->pdev, "Unable to read remainder of result\n");
607− size = -ETIME;
608− goto out;
609− }
610−
611−out:
612− chip->ops->cancel(chip);
613− release_locality(chip);
614− return size;
615−}
616−
617−static bool tpm_stm_i2c_req_canceled(struct tpm_chip *chip, u8 status)
618−{
619− return (status == TPM_STS_COMMAND_READY);
620−}
621−
622−static const struct tpm_class_ops st_i2c_tpm = {
623− .send = tpm_stm_i2c_send,
624− .recv = tpm_stm_i2c_recv,
625− .cancel = tpm_stm_i2c_cancel,
626− .status = tpm_stm_i2c_status,
627− .req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
628− .req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
629− .req_canceled = tpm_stm_i2c_req_canceled,
630−};
631−
632−#ifdef CONFIG_OF
633−static int tpm_stm_i2c_of_request_resources(struct tpm_chip *chip)
634−{
635− struct device_node *pp;
636− struct tpm_stm_dev *tpm_dev = (struct tpm_stm_dev *)TPM_VPRIV(chip);
637− struct i2c_client *client = tpm_dev->client;
638− int gpio;
639− int ret;
640−
641− pp = client->dev.of_node;
642− if (!pp) {
643− dev_err(chip->pdev, "No platform data\n");
644− return -ENODEV;
645− }
646−
647− /* Get GPIO from device tree */
648− gpio = of_get_named_gpio(pp, "lpcpd-gpios", 0);
649− if (gpio < 0) {
650− dev_err(chip->pdev, "Failed to retrieve lpcpd-gpios from dts.\n");
651− tpm_dev->io_lpcpd = -1;
652− /*
653− * lpcpd pin is not specified. This is not an issue as
654− * power management can be also managed by TPM specific
655− * commands. So leave with a success status code.
656− */
657− return 0;
658− }
659− /* GPIO request and configuration */
660− ret = devm_gpio_request_one(&client->dev, gpio,
661− GPIOF_OUT_INIT_HIGH, "TPM IO LPCPD");
662− if (ret) {
663− dev_err(chip->pdev, "Failed to request lpcpd pin\n");
664− return -ENODEV;
665− }
666− tpm_dev->io_lpcpd = gpio;
667−
668− return 0;
669−}
670−#else
671−static int tpm_stm_i2c_of_request_resources(struct tpm_chip *chip)
672−{
673− return -ENODEV;
674−}
675−#endif
676−
677−static int tpm_stm_i2c_request_resources(struct i2c_client *client,
678− struct tpm_chip *chip)
679−{
680− struct st33zp24_platform_data *pdata;
681− struct tpm_stm_dev *tpm_dev = (struct tpm_stm_dev *)TPM_VPRIV(chip);
682− int ret;
683−
684− pdata = client->dev.platform_data;
685− if (!pdata) {
686− dev_err(chip->pdev, "No platform data\n");
687− return -ENODEV;
688− }
689−
690− /* store for late use */
691− tpm_dev->io_lpcpd = pdata->io_lpcpd;
692−
693− if (gpio_is_valid(pdata->io_lpcpd)) {
694− ret = devm_gpio_request_one(&client->dev,
695− pdata->io_lpcpd, GPIOF_OUT_INIT_HIGH,
696− "TPM IO_LPCPD");
697− if (ret) {
698− dev_err(chip->pdev, "%s : reset gpio_request failed\n",
699− __FILE__);
700− return ret;
701− }
702− }
703−
704− return 0;
705−}
706−
707−/*
708− * tpm_stm_i2c_probe initialize the TPM device
709− * @param: client, the i2c_client drescription (TPM I2C description).
710− * @param: id, the i2c_device_id struct.
711− * @return: 0 in case of success.
712− * -1 in other case.
713− */
714−static int
715−tpm_stm_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
716−{
717− int ret;
718− u8 intmask = 0;
719− struct tpm_chip *chip;
720− struct st33zp24_platform_data *platform_data;
721− struct tpm_stm_dev *tpm_dev;
722−
723− if (!client) {
724− pr_info("%s: i2c client is NULL. Device not accessible.\n",
725− __func__);
726− return -ENODEV;
727− }
728−
729− if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
730− dev_info(&client->dev, "client not i2c capable\n");
731− return -ENODEV;
732− }
733−
734− tpm_dev = devm_kzalloc(&client->dev, sizeof(struct tpm_stm_dev),
735− GFP_KERNEL);
736− if (!tpm_dev)
737− return -ENOMEM;
738−
739− chip = tpmm_chip_alloc(&client->dev, &st_i2c_tpm);
740− if (IS_ERR(chip))
741− return PTR_ERR(chip);
742−
743− TPM_VPRIV(chip) = tpm_dev;
744− tpm_dev->client = client;
745−
746− platform_data = client->dev.platform_data;
747− if (!platform_data && client->dev.of_node) {
748− ret = tpm_stm_i2c_of_request_resources(chip);
749− if (ret)
750− goto _tpm_clean_answer;
751− } else if (platform_data) {
752− ret = tpm_stm_i2c_request_resources(client, chip);
753− if (ret)
754− goto _tpm_clean_answer;
755− }
756−
757− chip->vendor.timeout_a = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
758− chip->vendor.timeout_b = msecs_to_jiffies(TIS_LONG_TIMEOUT);
759− chip->vendor.timeout_c = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
760− chip->vendor.timeout_d = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
761−
762− chip->vendor.locality = LOCALITY0;
763−
764− if (client->irq) {
765− /* INTERRUPT Setup */
766− init_waitqueue_head(&chip->vendor.read_queue);
767− tpm_dev->intrs = 0;
768−
769− if (request_locality(chip) != LOCALITY0) {
770− ret = -ENODEV;
771− goto _tpm_clean_answer;
772− }
773−
774− clear_interruption(tpm_dev);
775− ret = devm_request_irq(&client->dev, client->irq,
776− tpm_ioserirq_handler,
777− IRQF_TRIGGER_HIGH,
778− "TPM SERIRQ management", chip);
779− if (ret < 0) {
780− dev_err(chip->pdev, "TPM SERIRQ signals %d not available\n",
781− client->irq);
782− goto _tpm_clean_answer;
783− }
784−
785− intmask |= TPM_INTF_CMD_READY_INT
786− | TPM_INTF_STS_VALID_INT
787− | TPM_INTF_DATA_AVAIL_INT;
788−
789− ret = I2C_WRITE_DATA(tpm_dev, TPM_INT_ENABLE, &intmask, 1);
790− if (ret < 0)
791− goto _tpm_clean_answer;
792−
793− intmask = TPM_GLOBAL_INT_ENABLE;
794− ret = I2C_WRITE_DATA(tpm_dev, (TPM_INT_ENABLE + 3),
795− &intmask, 1);
796− if (ret < 0)
797− goto _tpm_clean_answer;
798−
799− chip->vendor.irq = client->irq;
800−
801− disable_irq_nosync(chip->vendor.irq);
802−
803− tpm_gen_interrupt(chip);
804− }
805−
806− tpm_get_timeouts(chip);
807− tpm_do_selftest(chip);
808−
809− return tpm_chip_register(chip);
810−_tpm_clean_answer:
811− dev_info(chip->pdev, "TPM I2C initialisation fail\n");
812− return ret;
813−}
814−
815−/*
816− * tpm_stm_i2c_remove remove the TPM device
817− * @param: client, the i2c_client description (TPM I2C description).
818− * @return: 0 in case of success.
819− */
820−static int tpm_stm_i2c_remove(struct i2c_client *client)
821−{
822− struct tpm_chip *chip =
823− (struct tpm_chip *) i2c_get_clientdata(client);
824−
825− if (chip)
826− tpm_chip_unregister(chip);
827−
828− return 0;
829−}
830−
831−#ifdef CONFIG_PM_SLEEP
832−/*
833− * tpm_stm_i2c_pm_suspend suspend the TPM device
834− * @param: client, the i2c_client drescription (TPM I2C description).
835− * @param: mesg, the power management message.
836− * @return: 0 in case of success.
837− */
838−static int tpm_stm_i2c_pm_suspend(struct device *dev)
839−{
840− struct tpm_chip *chip = dev_get_drvdata(dev);
841− struct tpm_stm_dev *tpm_dev;
842− int ret = 0;
843−
844− tpm_dev = (struct tpm_stm_dev *)TPM_VPRIV(chip);
845−
846− if (gpio_is_valid(tpm_dev->io_lpcpd))
847− gpio_set_value(tpm_dev->io_lpcpd, 0);
848− else
849− ret = tpm_pm_suspend(dev);
850−
851− return ret;
852−} /* tpm_stm_i2c_suspend() */
853−
854−/*
855− * tpm_stm_i2c_pm_resume resume the TPM device
856− * @param: client, the i2c_client drescription (TPM I2C description).
857− * @return: 0 in case of success.
858− */
859−static int tpm_stm_i2c_pm_resume(struct device *dev)
860−{
861− struct tpm_chip *chip = dev_get_drvdata(dev);
862− struct tpm_stm_dev *tpm_dev;
863− int ret = 0;
864−
865− tpm_dev = (struct tpm_stm_dev *)TPM_VPRIV(chip);
866−
867− if (gpio_is_valid(tpm_dev->io_lpcpd)) {
868− gpio_set_value(tpm_dev->io_lpcpd, 1);
869− ret = wait_for_stat(chip,
870− TPM_STS_VALID, chip->vendor.timeout_b,
871− &chip->vendor.read_queue, false);
872− } else {
873− ret = tpm_pm_resume(dev);
874− if (!ret)
875− tpm_do_selftest(chip);
876− }
877− return ret;
878−} /* tpm_stm_i2c_pm_resume() */
879−#endif
880−
881−static const struct i2c_device_id tpm_stm_i2c_id[] = {
882− {TPM_ST33_I2C, 0},
883− {}
884−};
885−MODULE_DEVICE_TABLE(i2c, tpm_stm_i2c_id);
886−
887−#ifdef CONFIG_OF
888−static const struct of_device_id of_st33zp24_i2c_match[] = {
889− { .compatible = "st,st33zp24-i2c", },
890− {}
891−};
892−MODULE_DEVICE_TABLE(of, of_st33zp24_i2c_match);
893−#endif
894−
895−static SIMPLE_DEV_PM_OPS(tpm_stm_i2c_ops, tpm_stm_i2c_pm_suspend,
896− tpm_stm_i2c_pm_resume);
897−
898−static struct i2c_driver tpm_stm_i2c_driver = {
899− .driver = {
900− .owner = THIS_MODULE,
901− .name = TPM_ST33_I2C,
902− .pm = &tpm_stm_i2c_ops,
903− .of_match_table = of_match_ptr(of_st33zp24_i2c_match),
904− },
905− .probe = tpm_stm_i2c_probe,
906− .remove = tpm_stm_i2c_remove,
907− .id_table = tpm_stm_i2c_id
908−};
909−
910−module_i2c_driver(tpm_stm_i2c_driver);
911−
912−MODULE_AUTHOR("Christophe Ricard (tpmsupport@st.com)");
913−MODULE_DESCRIPTION("STM TPM I2C ST33 Driver");
914−MODULE_VERSION("1.2.1");
915−MODULE_LICENSE("GPL");
include/linux/platform_data/st33zp24.hrenamed from include/linux/platform_data/tpm_stm_st33.h+5−16
@@ -1,6 +1,6 @@
11 /*
2− * STMicroelectronics TPM I2C Linux driver for TPM ST33ZP24
3− * Copyright (C) 2009, 2010 STMicroelectronics
2+ * STMicroelectronics TPM Linux driver for TPM 1.2 ST33ZP24
3+ * Copyright (C) 2009 - 2015 STMicroelectronics
44 *
55 * This program is free software; you can redistribute it and/or modify
66 * it under the terms of the GNU General Public License as published by
@@ -14,20 +14,9 @@ · 7 unmodified lines
1414 *
1515 * You should have received a copy of the GNU General Public License
1616 * along with this program; if not, see <http://www.gnu.org/licenses/>.
17− *
18− * STMicroelectronics version 1.2.0, Copyright (C) 2010
19− * STMicroelectronics comes with ABSOLUTELY NO WARRANTY.
20− * This is free software, and you are welcome to redistribute it
21− * under certain conditions.
22− *
23− * @Author: Christophe RICARD tpmsupport@st.com
24− *
25− * @File: stm_st33_tpm.h
26− *
27− * @Date: 09/15/2010
2817 */
29−#ifndef __STM_ST33_TPM_H__
30−#define __STM_ST33_TPM_H__
18+#ifndef __ST33ZP24_H__
19+#define __ST33ZP24_H__
3120
3221 #define TPM_ST33_I2C "st33zp24-i2c"
3322 #define TPM_ST33_SPI "st33zp24-spi"
@@ -36,4 +25,4 @@ struct st33zp24_platform_data { · 2 unmodified lines
3625 int io_lpcpd;
3726 };
3827
39−#endif /* __STM_ST33_TPM_H__ */
28+#endif /* __ST33ZP24_H__ */

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t