2 * STMicroelectronics TPM ST33ZP24 I2C UBOOT driver
4 * Copyright (C) 2016, STMicroelectronics - All Rights Reserved
5 * Author(s): Christophe Ricard <christophe-h.ricard@st.com> for STMicroelectronics.
7 * Description: Device driver for ST33ZP24 I2C TPM TCG.
9 * This device driver implements the TPM interface as defined in
10 * the TCG TPM Interface Spec version 1.21, revision 1.0 and the
11 * STMicroelectronics Protocol Stack Specification version 1.2.0.
13 * SPDX-License-Identifier: GPL-2.0+
22 #include <linux/types.h>
23 #include <asm/unaligned.h>
26 #include "tpm_internal.h"
28 #define TPM_ACCESS 0x0
30 #define TPM_DATA_FIFO 0x24
34 #define TPM_DUMMY_BYTE 0xAA
35 #define TPM_ST33ZP24_I2C_SLAVE_ADDR 0x13
37 #define TPM_WRITE_DIRECTION 0x80
40 * st33zp24_i2c_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: Number of byte written successfully else an error code.
47 static int st33zp24_i2c_write8_reg(struct udevice
*dev
, u8 tpm_register
,
48 const u8
*tpm_data
, size_t tpm_size
)
50 struct tpm_chip_priv
*chip_priv
= dev_get_uclass_priv(dev
);
52 chip_priv
->buf
[0] = tpm_register
;
53 memcpy(chip_priv
->buf
+ 1, tpm_data
, tpm_size
);
55 return dm_i2c_write(dev
, 0, chip_priv
->buf
, tpm_size
+ 1);
59 * st33zp24_i2c_read8_reg
60 * Recv byte from the TIS register according to the ST33ZP24 I2C protocol.
61 * @param: tpm_register, the tpm tis register where the data should be read
62 * @param: tpm_data, the TPM response
63 * @param: tpm_size, tpm TPM response size to read.
64 * @return: Number of byte read successfully else an error code.
66 static int st33zp24_i2c_read8_reg(struct udevice
*dev
, u8 tpm_register
,
67 u8
*tpm_data
, size_t tpm_size
)
72 data
= TPM_DUMMY_BYTE
;
73 status
= st33zp24_i2c_write8_reg(dev
, tpm_register
, &data
, 1);
77 return dm_i2c_read(dev
, 0, tpm_data
, tpm_size
);
82 * Send byte to the TIS register according to the ST33ZP24 I2C protocol.
83 * @param: phy_id, the phy description
84 * @param: tpm_register, the tpm tis register where the data should be written
85 * @param: tpm_data, the tpm_data to write inside the tpm_register
86 * @param: tpm_size, the length of the data
87 * @return: number of byte written successfully: should be one if success.
89 static int st33zp24_i2c_write(struct udevice
*dev
, u8 tpm_register
,
90 const u8
*tpm_data
, size_t tpm_size
)
92 return st33zp24_i2c_write8_reg(dev
, tpm_register
| TPM_WRITE_DIRECTION
,
98 * Recv byte from the TIS register according to the ST33ZP24 I2C protocol.
99 * @param: phy_id, the phy description
100 * @param: tpm_register, the tpm tis register where the data should be read
101 * @param: tpm_data, the TPM response
102 * @param: tpm_size, tpm TPM response size to read.
103 * @return: number of byte read successfully: should be one if success.
105 static int st33zp24_i2c_read(struct udevice
*dev
, u8 tpm_register
,
106 u8
*tpm_data
, size_t tpm_size
)
108 return st33zp24_i2c_read8_reg(dev
, tpm_register
, tpm_data
, tpm_size
);
112 * st33zp24_i2c_release_locality release the active locality
113 * @param: chip, the tpm chip description.
115 static void st33zp24_i2c_release_locality(struct udevice
*dev
)
117 u8 data
= TPM_ACCESS_ACTIVE_LOCALITY
;
119 st33zp24_i2c_write(dev
, TPM_ACCESS
, &data
, 1);
123 * st33zp24_i2c_check_locality if the locality is active
124 * @param: chip, the tpm chip description
125 * @return: the active locality or -EACCES.
127 static int st33zp24_i2c_check_locality(struct udevice
*dev
)
129 struct tpm_chip
*chip
= dev_get_priv(dev
);
133 status
= st33zp24_i2c_read(dev
, TPM_ACCESS
, &data
, 1);
134 if (!status
&& (data
&
135 (TPM_ACCESS_ACTIVE_LOCALITY
| TPM_ACCESS_VALID
)) ==
136 (TPM_ACCESS_ACTIVE_LOCALITY
| TPM_ACCESS_VALID
))
137 return chip
->locality
;
143 * st33zp24_i2c_request_locality request the TPM locality
144 * @param: chip, the chip description
145 * @return: the active locality or negative value.
147 static int st33zp24_i2c_request_locality(struct udevice
*dev
)
149 struct tpm_chip
*chip
= dev_get_priv(dev
);
150 unsigned long start
, stop
;
154 if (st33zp24_i2c_check_locality(dev
) == chip
->locality
)
155 return chip
->locality
;
157 data
= TPM_ACCESS_REQUEST_USE
;
158 ret
= st33zp24_i2c_write(dev
, TPM_ACCESS
, &data
, 1);
162 /* wait for locality activated */
163 start
= get_timer(0);
164 stop
= chip
->timeout_a
;
166 if (st33zp24_i2c_check_locality(dev
) >= 0)
167 return chip
->locality
;
168 udelay(TPM_TIMEOUT_MS
* 1000);
169 } while (get_timer(start
) < stop
);
175 * st33zp24_i2c_status return the TPM_STS register
176 * @param: chip, the tpm chip description
177 * @return: the TPM_STS register value.
179 static u8
st33zp24_i2c_status(struct udevice
*dev
)
183 st33zp24_i2c_read(dev
, TPM_STS
, &data
, 1);
189 * st33zp24_i2c_get_burstcount return the burstcount address 0x19 0x1A
190 * @param: chip, the chip description
191 * return: the burstcount or -TPM_DRIVER_ERR in case of error.
193 static int st33zp24_i2c_get_burstcount(struct udevice
*dev
)
195 struct tpm_chip
*chip
= dev_get_priv(dev
);
196 unsigned long start
, stop
;
197 int burstcnt
, status
;
200 /* wait for burstcount */
201 start
= get_timer(0);
202 stop
= chip
->timeout_d
;
204 tpm_reg
= TPM_STS
+ 1;
205 status
= st33zp24_i2c_read(dev
, tpm_reg
, &temp
, 1);
209 tpm_reg
= TPM_STS
+ 2;
211 status
= st33zp24_i2c_read(dev
, tpm_reg
, &temp
, 1);
215 burstcnt
|= temp
<< 8;
218 udelay(TIS_SHORT_TIMEOUT_MS
* 1000);
219 } while (get_timer(start
) < stop
);
225 * st33zp24_i2c_cancel, cancel the current command execution or
226 * set STS to COMMAND READY.
227 * @param: chip, tpm_chip description.
229 static void st33zp24_i2c_cancel(struct udevice
*dev
)
233 data
= TPM_STS_COMMAND_READY
;
234 st33zp24_i2c_write(dev
, TPM_STS
, &data
, 1);
238 * st33zp24_i2c_wait_for_stat wait for a TPM_STS value
239 * @param: chip, the tpm chip description
240 * @param: mask, the value mask to wait
241 * @param: timeout, the timeout
243 * @return: the tpm status, 0 if success, -ETIME if timeout is reached.
245 static int st33zp24_i2c_wait_for_stat(struct udevice
*dev
, u8 mask
,
246 unsigned long timeout
, int *status
)
248 unsigned long start
, stop
;
250 /* Check current status */
251 *status
= st33zp24_i2c_status(dev
);
252 if ((*status
& mask
) == mask
)
255 start
= get_timer(0);
258 udelay(TPM_TIMEOUT_MS
* 1000);
259 *status
= st33zp24_i2c_status(dev
);
260 if ((*status
& mask
) == mask
)
262 } while (get_timer(start
) < stop
);
268 * st33zp24_i2c_recv_data receive data
269 * @param: chip, the tpm chip description
270 * @param: buf, the buffer where the data are received
271 * @param: count, the number of data to receive
272 * @return: the number of bytes read from TPM FIFO.
274 static int st33zp24_i2c_recv_data(struct udevice
*dev
, u8
*buf
, size_t count
)
276 struct tpm_chip
*chip
= dev_get_priv(dev
);
277 int size
= 0, burstcnt
, len
, ret
, status
;
279 while (size
< count
&&
280 st33zp24_i2c_wait_for_stat(dev
, TPM_STS_DATA_AVAIL
| TPM_STS_VALID
,
281 chip
->timeout_c
, &status
) == 0) {
282 burstcnt
= st33zp24_i2c_get_burstcount(dev
);
285 len
= min_t(int, burstcnt
, count
- size
);
286 ret
= st33zp24_i2c_read(dev
, TPM_DATA_FIFO
, buf
+ size
, len
);
297 * st33zp24_i2c_recv received TPM response through TPM phy.
298 * @param: chip, tpm_chip description.
299 * @param: buf, the buffer to store data.
300 * @param: count, the number of bytes that can received (sizeof buf).
301 * @return: Returns zero in case of success else -EIO.
303 static int st33zp24_i2c_recv(struct udevice
*dev
, u8
*buf
, size_t count
)
305 struct tpm_chip
*chip
= dev_get_priv(dev
);
311 if (count
< TPM_HEADER_SIZE
) {
316 size
= st33zp24_i2c_recv_data(dev
, buf
, TPM_HEADER_SIZE
);
317 if (size
< TPM_HEADER_SIZE
) {
318 debug("TPM error, unable to read header\n");
322 expected
= get_unaligned_be32(buf
+ 2);
323 if (expected
> count
) {
328 size
+= st33zp24_i2c_recv_data(dev
, &buf
[TPM_HEADER_SIZE
],
329 expected
- TPM_HEADER_SIZE
);
330 if (size
< expected
) {
331 debug("TPM error, unable to read remaining bytes of result\n");
337 st33zp24_i2c_cancel(dev
);
338 st33zp24_i2c_release_locality(dev
);
344 * st33zp24_i2c_send send TPM commands through TPM phy.
345 * @param: chip, tpm_chip description.
346 * @param: buf, the buffer to send.
347 * @param: len, the number of bytes to send.
348 * @return: Returns zero in case of success else the negative error code.
350 static int st33zp24_i2c_send(struct udevice
*dev
, const u8
*buf
, size_t len
)
352 struct tpm_chip
*chip
= dev_get_priv(dev
);
354 int burstcnt
, ret
, status
;
359 if (len
< TPM_HEADER_SIZE
)
362 ret
= st33zp24_i2c_request_locality(dev
);
366 tpm_stat
= st33zp24_i2c_status(dev
);
367 if ((tpm_stat
& TPM_STS_COMMAND_READY
) == 0) {
368 st33zp24_i2c_cancel(dev
);
369 if (st33zp24_i2c_wait_for_stat(dev
, TPM_STS_COMMAND_READY
,
370 chip
->timeout_b
, &status
) < 0) {
376 for (i
= 0; i
< len
- 1;) {
377 burstcnt
= st33zp24_i2c_get_burstcount(dev
);
381 size
= min_t(int, len
- i
- 1, burstcnt
);
382 ret
= st33zp24_i2c_write(dev
, TPM_DATA_FIFO
, buf
+ i
, size
);
389 tpm_stat
= st33zp24_i2c_status(dev
);
390 if ((tpm_stat
& TPM_STS_DATA_EXPECT
) == 0) {
395 ret
= st33zp24_i2c_write(dev
, TPM_DATA_FIFO
, buf
+ len
- 1, 1);
399 tpm_stat
= st33zp24_i2c_status(dev
);
400 if ((tpm_stat
& TPM_STS_DATA_EXPECT
) != 0) {
406 ret
= st33zp24_i2c_write(dev
, TPM_STS
, &data
, 1);
413 st33zp24_i2c_cancel(dev
);
414 st33zp24_i2c_release_locality(dev
);
419 static int st33zp24_i2c_cleanup(struct udevice
*dev
)
421 st33zp24_i2c_cancel(dev
);
423 * The TPM needs some time to clean up here,
424 * so we sleep rather than keeping the bus busy
427 st33zp24_i2c_release_locality(dev
);
432 static int st33zp24_i2c_init(struct udevice
*dev
)
434 struct tpm_chip
*chip
= dev_get_priv(dev
);
438 /* Default timeouts - these could move to the device tree */
439 chip
->timeout_a
= TIS_SHORT_TIMEOUT_MS
;
440 chip
->timeout_b
= TIS_LONG_TIMEOUT_MS
;
441 chip
->timeout_c
= TIS_SHORT_TIMEOUT_MS
;
442 chip
->timeout_d
= TIS_SHORT_TIMEOUT_MS
;
444 chip
->locality
= LOCALITY0
;
447 * A timeout query to TPM can be placed here.
448 * Standard timeout values are used so far
454 static int st33zp24_i2c_open(struct udevice
*dev
)
456 struct tpm_chip
*chip
= dev_get_priv(dev
);
459 debug("%s: start\n", __func__
);
463 rc
= st33zp24_i2c_init(dev
);
470 static int st33zp24_i2c_close(struct udevice
*dev
)
472 struct tpm_chip
*chip
= dev_get_priv(dev
);
475 st33zp24_i2c_release_locality(dev
);
483 static int st33zp24_i2c_get_desc(struct udevice
*dev
, char *buf
, int size
)
485 struct tpm_chip
*chip
= dev_get_priv(dev
);
490 return snprintf(buf
, size
, "1.2 TPM (%s, chip type %s device-id 0x%x)",
491 chip
->is_open
? "open" : "closed",
493 chip
->vend_dev
>> 16);
496 static const struct tpm_ops st33zp24_i2c_tpm_ops
= {
497 .open
= st33zp24_i2c_open
,
498 .close
= st33zp24_i2c_close
,
499 .recv
= st33zp24_i2c_recv
,
500 .send
= st33zp24_i2c_send
,
501 .cleanup
= st33zp24_i2c_cleanup
,
502 .get_desc
= st33zp24_i2c_get_desc
,
505 static int st33zp24_i2c_probe(struct udevice
*dev
)
507 struct tpm_chip
*chip
= dev_get_priv(dev
);
509 /* Default timeouts */
510 chip
->timeout_a
= TIS_SHORT_TIMEOUT_MS
;
511 chip
->timeout_b
= TIS_LONG_TIMEOUT_MS
;
512 chip
->timeout_c
= TIS_SHORT_TIMEOUT_MS
;
513 chip
->timeout_d
= TIS_SHORT_TIMEOUT_MS
;
515 chip
->locality
= LOCALITY0
;
517 i2c_set_chip_offset_len(dev
, 0);
519 debug("ST33ZP24 I2C TPM from STMicroelectronics found\n");
524 static int st33zp24_i2c_remove(struct udevice
*dev
)
526 st33zp24_i2c_release_locality(dev
);
531 static const struct udevice_id st33zp24_i2c_ids
[] = {
532 { .compatible
= "st,st33zp24-i2c" },
536 U_BOOT_DRIVER(st33zp24_i2c
) = {
537 .name
= "st33zp24-i2c",
539 .of_match
= of_match_ptr(st33zp24_i2c_ids
),
540 .probe
= st33zp24_i2c_probe
,
541 .remove
= st33zp24_i2c_remove
,
542 .ops
= &st33zp24_i2c_tpm_ops
,
543 .priv_auto_alloc_size
= sizeof(struct tpm_chip
),