2 * ATMEL I2C TPM AT97SC3204T
4 * Copyright (C) 2012 V Lab Technologies
5 * Teddy Reed <teddy@prosauce.org>
6 * Copyright (C) 2013, Obsidian Research Corp.
7 * Jason Gunthorpe <jgunthorpe@obsidianresearch.com>
8 * Device driver for ATMEL I2C TPMs.
10 * Teddy Reed determined the basic I2C command flow, unlike other I2C TPM
11 * devices the raw TCG formatted TPM command data is written via I2C and then
12 * raw TCG formatted TPM command data is returned via I2C.
14 * TGC status/locality/etc functions seen in the LPC implementation do not
17 * This program is free software: you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License as published by
19 * the Free Software Foundation, either version 2 of the License, or
20 * (at your option) any later version.
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
27 * You should have received a copy of the GNU General Public License
28 * along with this program. If not, see http://www.gnu.org/licenses/>.
30 #include <linux/init.h>
31 #include <linux/module.h>
32 #include <linux/moduleparam.h>
33 #include <linux/slab.h>
34 #include <linux/i2c.h>
37 #define I2C_DRIVER_NAME "tpm_i2c_atmel"
39 #define TPM_I2C_SHORT_TIMEOUT 750 /* ms */
40 #define TPM_I2C_LONG_TIMEOUT 2000 /* 2 sec */
42 #define ATMEL_STS_OK 1
46 /* This is the amount we read on the first try. 25 was chosen to fit a
47 * fair number of read responses in the buffer so a 2nd retry can be
48 * avoided in small message cases. */
49 u8 buffer
[sizeof(struct tpm_output_header
) + 25];
52 static int i2c_atmel_send(struct tpm_chip
*chip
, u8
*buf
, size_t len
)
54 struct priv_data
*priv
= dev_get_drvdata(&chip
->dev
);
55 struct i2c_client
*client
= to_i2c_client(chip
->dev
.parent
);
63 status
= i2c_master_send(client
, buf
, len
);
66 "%s(buf=%*ph len=%0zx) -> sts=%d\n", __func__
,
67 (int)min_t(size_t, 64, len
), buf
, len
, status
);
71 static int i2c_atmel_recv(struct tpm_chip
*chip
, u8
*buf
, size_t count
)
73 struct priv_data
*priv
= dev_get_drvdata(&chip
->dev
);
74 struct i2c_client
*client
= to_i2c_client(chip
->dev
.parent
);
75 struct tpm_output_header
*hdr
=
76 (struct tpm_output_header
*)priv
->buffer
;
83 /* Get the message size from the message header, if we didn't get the
84 * whole message in read_status then we need to re-read the
86 expected_len
= be32_to_cpu(hdr
->length
);
87 if (expected_len
> count
)
90 if (priv
->len
>= expected_len
) {
92 "%s early(buf=%*ph count=%0zx) -> ret=%d\n", __func__
,
93 (int)min_t(size_t, 64, expected_len
), buf
, count
,
95 memcpy(buf
, priv
->buffer
, expected_len
);
99 rc
= i2c_master_recv(client
, buf
, expected_len
);
101 "%s reread(buf=%*ph count=%0zx) -> ret=%d\n", __func__
,
102 (int)min_t(size_t, 64, expected_len
), buf
, count
,
107 static void i2c_atmel_cancel(struct tpm_chip
*chip
)
109 dev_err(&chip
->dev
, "TPM operation cancellation was requested, but is not supported");
112 static u8
i2c_atmel_read_status(struct tpm_chip
*chip
)
114 struct priv_data
*priv
= dev_get_drvdata(&chip
->dev
);
115 struct i2c_client
*client
= to_i2c_client(chip
->dev
.parent
);
118 /* The TPM fails the I2C read until it is ready, so we do the entire
119 * transfer here and buffer it locally. This way the common code can
120 * properly handle the timeouts. */
122 memset(priv
->buffer
, 0, sizeof(priv
->buffer
));
125 /* Once the TPM has completed the command the command remains readable
126 * until another command is issued. */
127 rc
= i2c_master_recv(client
, priv
->buffer
, sizeof(priv
->buffer
));
129 "%s: sts=%d", __func__
, rc
);
138 static bool i2c_atmel_req_canceled(struct tpm_chip
*chip
, u8 status
)
143 static const struct tpm_class_ops i2c_atmel
= {
144 .flags
= TPM_OPS_AUTO_STARTUP
,
145 .status
= i2c_atmel_read_status
,
146 .recv
= i2c_atmel_recv
,
147 .send
= i2c_atmel_send
,
148 .cancel
= i2c_atmel_cancel
,
149 .req_complete_mask
= ATMEL_STS_OK
,
150 .req_complete_val
= ATMEL_STS_OK
,
151 .req_canceled
= i2c_atmel_req_canceled
,
154 static int i2c_atmel_probe(struct i2c_client
*client
,
155 const struct i2c_device_id
*id
)
157 struct tpm_chip
*chip
;
158 struct device
*dev
= &client
->dev
;
159 struct priv_data
*priv
;
161 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_I2C
))
164 chip
= tpmm_chip_alloc(dev
, &i2c_atmel
);
166 return PTR_ERR(chip
);
168 priv
= devm_kzalloc(dev
, sizeof(struct priv_data
), GFP_KERNEL
);
172 /* Default timeouts */
173 chip
->timeout_a
= msecs_to_jiffies(TPM_I2C_SHORT_TIMEOUT
);
174 chip
->timeout_b
= msecs_to_jiffies(TPM_I2C_LONG_TIMEOUT
);
175 chip
->timeout_c
= msecs_to_jiffies(TPM_I2C_SHORT_TIMEOUT
);
176 chip
->timeout_d
= msecs_to_jiffies(TPM_I2C_SHORT_TIMEOUT
);
178 dev_set_drvdata(&chip
->dev
, priv
);
180 /* There is no known way to probe for this device, and all version
181 * information seems to be read via TPM commands. Thus we rely on the
182 * TPM startup process in the common code to detect the device. */
184 return tpm_chip_register(chip
);
187 static int i2c_atmel_remove(struct i2c_client
*client
)
189 struct device
*dev
= &(client
->dev
);
190 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
191 tpm_chip_unregister(chip
);
195 static const struct i2c_device_id i2c_atmel_id
[] = {
196 {I2C_DRIVER_NAME
, 0},
199 MODULE_DEVICE_TABLE(i2c
, i2c_atmel_id
);
202 static const struct of_device_id i2c_atmel_of_match
[] = {
203 {.compatible
= "atmel,at97sc3204t"},
206 MODULE_DEVICE_TABLE(of
, i2c_atmel_of_match
);
209 static SIMPLE_DEV_PM_OPS(i2c_atmel_pm_ops
, tpm_pm_suspend
, tpm_pm_resume
);
211 static struct i2c_driver i2c_atmel_driver
= {
212 .id_table
= i2c_atmel_id
,
213 .probe
= i2c_atmel_probe
,
214 .remove
= i2c_atmel_remove
,
216 .name
= I2C_DRIVER_NAME
,
217 .pm
= &i2c_atmel_pm_ops
,
218 .of_match_table
= of_match_ptr(i2c_atmel_of_match
),
222 module_i2c_driver(i2c_atmel_driver
);
224 MODULE_AUTHOR("Jason Gunthorpe <jgunthorpe@obsidianresearch.com>");
225 MODULE_DESCRIPTION("Atmel TPM I2C Driver");
226 MODULE_LICENSE("GPL");