]>
Commit | Line | Data |
---|---|---|
f6267998 RC |
1 | /* |
2 | * Copyright (C) 2011 Infineon Technologies | |
3 | * | |
4 | * Authors: | |
5 | * Peter Huewe <huewe.external@infineon.com> | |
6 | * | |
7 | * Description: | |
8 | * Device driver for TCG/TCPA TPM (trusted platform module). | |
9 | * Specifications at www.trustedcomputinggroup.org | |
10 | * | |
11 | * This device driver implements the TPM interface as defined in | |
12 | * the TCG TPM Interface Spec version 1.2, revision 1.0 and the | |
13 | * Infineon I2C Protocol Stack Specification v0.20. | |
14 | * | |
15 | * It is based on the Linux kernel driver tpm.c from Leendert van | |
16 | * Dorn, Dave Safford, Reiner Sailer, and Kyleen Hall. | |
17 | * | |
18 | * Version: 2.1.1 | |
19 | * | |
07470d6f | 20 | * SPDX-License-Identifier: GPL-2.0 |
f6267998 RC |
21 | */ |
22 | ||
23 | #include <common.h> | |
f90acf1a | 24 | #include <dm.h> |
ec34fa5e | 25 | #include <fdtdec.h> |
f6267998 | 26 | #include <i2c.h> |
f255d31f | 27 | #include <tis.h> |
1b393db5 TWHT |
28 | #include <tpm.h> |
29 | #include <asm-generic/errno.h> | |
b697e0ff | 30 | #include <linux/compiler.h> |
f6267998 | 31 | #include <linux/types.h> |
1b393db5 | 32 | #include <linux/unaligned/be_byteshift.h> |
f6267998 | 33 | |
4cd7b783 | 34 | #include "tpm_tis_i2c.h" |
f255d31f | 35 | #include "tpm_internal.h" |
f6267998 | 36 | |
ec34fa5e VP |
37 | DECLARE_GLOBAL_DATA_PTR; |
38 | ||
ec34fa5e VP |
39 | static const char * const chip_name[] = { |
40 | [SLB9635] = "slb9635tt", | |
41 | [SLB9645] = "slb9645tt", | |
42 | [UNKNOWN] = "unknown/fallback to slb9635", | |
43 | }; | |
f6267998 | 44 | |
f6267998 | 45 | /* |
e56e20eb | 46 | * tpm_tis_i2c_read() - read from TPM register |
f6267998 RC |
47 | * @addr: register address to read from |
48 | * @buffer: provided by caller | |
49 | * @len: number of bytes to read | |
50 | * | |
51 | * Read len bytes from TPM register and put them into | |
52 | * buffer (little-endian format, i.e. first byte is put into buffer[0]). | |
53 | * | |
54 | * NOTE: TPM is big-endian for multi-byte values. Multi-byte | |
55 | * values have to be swapped. | |
56 | * | |
57 | * Return -EIO on error, 0 on success. | |
58 | */ | |
b697e0ff SG |
59 | static int tpm_tis_i2c_read(struct udevice *dev, u8 addr, u8 *buffer, |
60 | size_t len) | |
f6267998 | 61 | { |
b697e0ff | 62 | struct tpm_chip *chip = dev_get_priv(dev); |
f6267998 RC |
63 | int rc; |
64 | int count; | |
1b393db5 | 65 | uint32_t addrbuf = addr; |
f6267998 | 66 | |
b697e0ff | 67 | if ((chip->chip_type == SLB9635) || (chip->chip_type == UNKNOWN)) { |
ec34fa5e VP |
68 | /* slb9635 protocol should work in both cases */ |
69 | for (count = 0; count < MAX_COUNT; count++) { | |
b697e0ff | 70 | rc = dm_i2c_write(dev, 0, (uchar *)&addrbuf, 1); |
ec34fa5e | 71 | if (rc == 0) |
1b393db5 | 72 | break; /* Success, break to skip sleep */ |
42c8ec56 | 73 | udelay(SLEEP_DURATION_US); |
ec34fa5e | 74 | } |
ec34fa5e | 75 | if (rc) |
b697e0ff | 76 | return rc; |
ec34fa5e VP |
77 | |
78 | /* After the TPM has successfully received the register address | |
79 | * it needs some time, thus we're sleeping here again, before | |
80 | * retrieving the data | |
81 | */ | |
82 | for (count = 0; count < MAX_COUNT; count++) { | |
42c8ec56 | 83 | udelay(SLEEP_DURATION_US); |
b697e0ff | 84 | rc = dm_i2c_read(dev, 0, buffer, len); |
ec34fa5e VP |
85 | if (rc == 0) |
86 | break; /* success, break to skip sleep */ | |
87 | } | |
88 | } else { | |
1b393db5 TWHT |
89 | /* |
90 | * Use a combined read for newer chips. | |
91 | * Unfortunately the smbus functions are not suitable due to | |
ec34fa5e | 92 | * the 32 byte limit of the smbus. |
1b393db5 | 93 | * Retries should usually not be needed, but are kept just to |
ec34fa5e VP |
94 | * be safe on the safe side. |
95 | */ | |
96 | for (count = 0; count < MAX_COUNT; count++) { | |
b697e0ff | 97 | rc = dm_i2c_read(dev, addr, buffer, len); |
ec34fa5e VP |
98 | if (rc == 0) |
99 | break; /* break here to skip sleep */ | |
42c8ec56 | 100 | udelay(SLEEP_DURATION_US); |
ec34fa5e | 101 | } |
f6267998 RC |
102 | } |
103 | ||
1b393db5 | 104 | /* Take care of 'guard time' */ |
42c8ec56 | 105 | udelay(SLEEP_DURATION_US); |
f6267998 | 106 | if (rc) |
b697e0ff | 107 | return rc; |
f6267998 RC |
108 | |
109 | return 0; | |
110 | } | |
111 | ||
b697e0ff SG |
112 | static int tpm_tis_i2c_write_generic(struct udevice *dev, u8 addr, |
113 | const u8 *buffer, size_t len, | |
42c8ec56 | 114 | unsigned int sleep_time_us, u8 max_count) |
f6267998 | 115 | { |
b697e0ff SG |
116 | struct tpm_chip_priv *priv = dev_get_uclass_priv(dev); |
117 | struct tpm_chip *chip = dev_get_priv(dev); | |
f6267998 RC |
118 | int rc = 0; |
119 | int count; | |
120 | ||
b697e0ff SG |
121 | if (chip->chip_type == SLB9635) { |
122 | /* Prepare send buffer to include the address */ | |
123 | priv->buf[0] = addr; | |
124 | memcpy(&(priv->buf[1]), buffer, len); | |
125 | buffer = priv->buf; | |
126 | len++; | |
127 | addr = 0; | |
128 | } | |
129 | ||
f6267998 | 130 | for (count = 0; count < max_count; count++) { |
b697e0ff | 131 | rc = dm_i2c_write(dev, addr, buffer, len); |
f6267998 | 132 | if (rc == 0) |
1b393db5 | 133 | break; /* Success, break to skip sleep */ |
42c8ec56 | 134 | udelay(sleep_time_us); |
f6267998 RC |
135 | } |
136 | ||
ec34fa5e | 137 | /* take care of 'guard time' */ |
42c8ec56 | 138 | udelay(sleep_time_us); |
f6267998 | 139 | if (rc) |
b697e0ff | 140 | return rc; |
f6267998 RC |
141 | |
142 | return 0; | |
143 | } | |
144 | ||
145 | /* | |
e56e20eb | 146 | * tpm_tis_i2c_write() - write to TPM register |
f6267998 RC |
147 | * @addr: register address to write to |
148 | * @buffer: containing data to be written | |
149 | * @len: number of bytes to write | |
150 | * | |
151 | * Write len bytes from provided buffer to TPM register (little | |
152 | * endian format, i.e. buffer[0] is written as first byte). | |
153 | * | |
154 | * NOTE: TPM is big-endian for multi-byte values. Multi-byte | |
155 | * values have to be swapped. | |
156 | * | |
e56e20eb | 157 | * NOTE: use this function instead of the tpm_tis_i2c_write_generic function. |
f6267998 RC |
158 | * |
159 | * Return -EIO on error, 0 on success | |
160 | */ | |
b697e0ff SG |
161 | static int tpm_tis_i2c_write(struct udevice *dev, u8 addr, const u8 *buffer, |
162 | size_t len) | |
f6267998 | 163 | { |
b697e0ff SG |
164 | return tpm_tis_i2c_write_generic(dev, addr, buffer, len, |
165 | SLEEP_DURATION_US, MAX_COUNT); | |
f6267998 RC |
166 | } |
167 | ||
168 | /* | |
169 | * This function is needed especially for the cleanup situation after | |
170 | * sending TPM_READY | |
1b393db5 | 171 | */ |
b697e0ff SG |
172 | static int tpm_tis_i2c_write_long(struct udevice *dev, u8 addr, u8 *buffer, |
173 | size_t len) | |
f6267998 | 174 | { |
b697e0ff | 175 | return tpm_tis_i2c_write_generic(dev, addr, buffer, len, |
42c8ec56 SG |
176 | SLEEP_DURATION_LONG_US, |
177 | MAX_COUNT_LONG); | |
f6267998 RC |
178 | } |
179 | ||
b697e0ff | 180 | static int tpm_tis_i2c_check_locality(struct udevice *dev, int loc) |
f6267998 | 181 | { |
1b393db5 | 182 | const u8 mask = TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID; |
b697e0ff | 183 | struct tpm_chip *chip = dev_get_priv(dev); |
f6267998 RC |
184 | u8 buf; |
185 | int rc; | |
186 | ||
b697e0ff | 187 | rc = tpm_tis_i2c_read(dev, TPM_ACCESS(loc), &buf, 1); |
f6267998 RC |
188 | if (rc < 0) |
189 | return rc; | |
190 | ||
1b393db5 | 191 | if ((buf & mask) == mask) { |
7c73537e | 192 | chip->locality = loc; |
f6267998 RC |
193 | return loc; |
194 | } | |
195 | ||
b697e0ff | 196 | return -ENOENT; |
f6267998 RC |
197 | } |
198 | ||
b697e0ff | 199 | static void tpm_tis_i2c_release_locality(struct udevice *dev, int loc, |
e56e20eb | 200 | int force) |
f6267998 | 201 | { |
1b393db5 | 202 | const u8 mask = TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID; |
f6267998 | 203 | u8 buf; |
1b393db5 | 204 | |
b697e0ff | 205 | if (tpm_tis_i2c_read(dev, TPM_ACCESS(loc), &buf, 1) < 0) |
f6267998 RC |
206 | return; |
207 | ||
1b393db5 | 208 | if (force || (buf & mask) == mask) { |
f6267998 | 209 | buf = TPM_ACCESS_ACTIVE_LOCALITY; |
b697e0ff | 210 | tpm_tis_i2c_write(dev, TPM_ACCESS(loc), &buf, 1); |
f6267998 RC |
211 | } |
212 | } | |
213 | ||
b697e0ff | 214 | static int tpm_tis_i2c_request_locality(struct udevice *dev, int loc) |
f6267998 | 215 | { |
b697e0ff | 216 | struct tpm_chip *chip = dev_get_priv(dev); |
f6267998 RC |
217 | unsigned long start, stop; |
218 | u8 buf = TPM_ACCESS_REQUEST_USE; | |
f90acf1a | 219 | int rc; |
f6267998 | 220 | |
b697e0ff SG |
221 | rc = tpm_tis_i2c_check_locality(dev, loc); |
222 | if (rc >= 0) { | |
223 | debug("%s: Already have locality\n", __func__); | |
1b393db5 | 224 | return loc; /* We already have the locality */ |
b697e0ff SG |
225 | } else if (rc != -ENOENT) { |
226 | debug("%s: Failed to get locality: %d\n", __func__, rc); | |
227 | return rc; | |
228 | } | |
f6267998 | 229 | |
b697e0ff SG |
230 | rc = tpm_tis_i2c_write(dev, TPM_ACCESS(loc), &buf, 1); |
231 | if (rc) { | |
232 | debug("%s: Failed to write to TPM: %d\n", __func__, rc); | |
f90acf1a | 233 | return rc; |
b697e0ff | 234 | } |
f6267998 | 235 | |
1b393db5 | 236 | /* Wait for burstcount */ |
f6267998 | 237 | start = get_timer(0); |
7c73537e | 238 | stop = chip->timeout_a; |
f6267998 | 239 | do { |
b697e0ff SG |
240 | rc = tpm_tis_i2c_check_locality(dev, loc); |
241 | if (rc >= 0) { | |
242 | debug("%s: Have locality\n", __func__); | |
f6267998 | 243 | return loc; |
b697e0ff SG |
244 | } else if (rc != -ENOENT) { |
245 | debug("%s: Failed to get locality: %d\n", __func__, rc); | |
246 | return rc; | |
247 | } | |
42c8ec56 | 248 | mdelay(TPM_TIMEOUT_MS); |
f6267998 | 249 | } while (get_timer(start) < stop); |
b697e0ff | 250 | debug("%s: Timeout getting locality: %d\n", __func__, rc); |
f6267998 | 251 | |
b697e0ff | 252 | return rc; |
f6267998 RC |
253 | } |
254 | ||
b697e0ff | 255 | static u8 tpm_tis_i2c_status(struct udevice *dev) |
f6267998 | 256 | { |
b697e0ff | 257 | struct tpm_chip *chip = dev_get_priv(dev); |
1b393db5 | 258 | /* NOTE: Since i2c read may fail, return 0 in this case --> time-out */ |
f6267998 | 259 | u8 buf; |
1b393db5 | 260 | |
b697e0ff | 261 | if (tpm_tis_i2c_read(dev, TPM_STS(chip->locality), &buf, 1) < 0) |
f6267998 RC |
262 | return 0; |
263 | else | |
264 | return buf; | |
265 | } | |
266 | ||
b697e0ff | 267 | static int tpm_tis_i2c_ready(struct udevice *dev) |
f6267998 | 268 | { |
b697e0ff | 269 | struct tpm_chip *chip = dev_get_priv(dev); |
f90acf1a SG |
270 | int rc; |
271 | ||
1b393db5 | 272 | /* This causes the current command to be aborted */ |
f6267998 | 273 | u8 buf = TPM_STS_COMMAND_READY; |
1b393db5 | 274 | |
f90acf1a | 275 | debug("%s\n", __func__); |
b697e0ff | 276 | rc = tpm_tis_i2c_write_long(dev, TPM_STS(chip->locality), &buf, 1); |
f90acf1a SG |
277 | if (rc) |
278 | debug("%s: rc=%d\n", __func__, rc); | |
b697e0ff SG |
279 | |
280 | return rc; | |
f6267998 RC |
281 | } |
282 | ||
b697e0ff | 283 | static ssize_t tpm_tis_i2c_get_burstcount(struct udevice *dev) |
f6267998 | 284 | { |
b697e0ff | 285 | struct tpm_chip *chip = dev_get_priv(dev); |
f6267998 RC |
286 | unsigned long start, stop; |
287 | ssize_t burstcnt; | |
1b393db5 | 288 | u8 addr, buf[3]; |
f6267998 | 289 | |
1b393db5 TWHT |
290 | /* Wait for burstcount */ |
291 | /* XXX: Which timeout value? Spec has 2 answers (c & d) */ | |
f6267998 | 292 | start = get_timer(0); |
7c73537e | 293 | stop = chip->timeout_d; |
f6267998 RC |
294 | do { |
295 | /* Note: STS is little endian */ | |
7c73537e | 296 | addr = TPM_STS(chip->locality) + 1; |
b697e0ff | 297 | if (tpm_tis_i2c_read(dev, addr, buf, 3) < 0) |
f6267998 RC |
298 | burstcnt = 0; |
299 | else | |
300 | burstcnt = (buf[2] << 16) + (buf[1] << 8) + buf[0]; | |
301 | ||
302 | if (burstcnt) | |
303 | return burstcnt; | |
42c8ec56 | 304 | mdelay(TPM_TIMEOUT_MS); |
f6267998 RC |
305 | } while (get_timer(start) < stop); |
306 | ||
307 | return -EBUSY; | |
308 | } | |
309 | ||
b697e0ff | 310 | static int tpm_tis_i2c_wait_for_stat(struct udevice *dev, u8 mask, |
e56e20eb | 311 | unsigned long timeout, int *status) |
f6267998 RC |
312 | { |
313 | unsigned long start, stop; | |
314 | ||
1b393db5 | 315 | /* Check current status */ |
b697e0ff | 316 | *status = tpm_tis_i2c_status(dev); |
f6267998 RC |
317 | if ((*status & mask) == mask) |
318 | return 0; | |
319 | ||
320 | start = get_timer(0); | |
321 | stop = timeout; | |
322 | do { | |
42c8ec56 | 323 | mdelay(TPM_TIMEOUT_MS); |
b697e0ff | 324 | *status = tpm_tis_i2c_status(dev); |
f6267998 RC |
325 | if ((*status & mask) == mask) |
326 | return 0; | |
f6267998 RC |
327 | } while (get_timer(start) < stop); |
328 | ||
b697e0ff | 329 | return -ETIMEDOUT; |
f6267998 RC |
330 | } |
331 | ||
b697e0ff | 332 | static int tpm_tis_i2c_recv_data(struct udevice *dev, u8 *buf, size_t count) |
f6267998 | 333 | { |
b697e0ff | 334 | struct tpm_chip *chip = dev_get_priv(dev); |
f6267998 RC |
335 | size_t size = 0; |
336 | ssize_t burstcnt; | |
337 | int rc; | |
338 | ||
339 | while (size < count) { | |
b697e0ff | 340 | burstcnt = tpm_tis_i2c_get_burstcount(dev); |
f6267998 | 341 | |
1b393db5 | 342 | /* burstcount < 0 -> tpm is busy */ |
f6267998 RC |
343 | if (burstcnt < 0) |
344 | return burstcnt; | |
345 | ||
1b393db5 | 346 | /* Limit received data to max left */ |
f6267998 RC |
347 | if (burstcnt > (count - size)) |
348 | burstcnt = count - size; | |
349 | ||
b697e0ff SG |
350 | rc = tpm_tis_i2c_read(dev, TPM_DATA_FIFO(chip->locality), |
351 | &(buf[size]), burstcnt); | |
f6267998 RC |
352 | if (rc == 0) |
353 | size += burstcnt; | |
354 | } | |
355 | ||
356 | return size; | |
357 | } | |
358 | ||
b697e0ff | 359 | static int tpm_tis_i2c_recv(struct udevice *dev, u8 *buf, size_t count) |
f6267998 | 360 | { |
b697e0ff | 361 | struct tpm_chip *chip = dev_get_priv(dev); |
f6267998 RC |
362 | int size = 0; |
363 | int expected, status; | |
b697e0ff | 364 | int rc; |
f6267998 | 365 | |
b697e0ff SG |
366 | status = tpm_tis_i2c_status(dev); |
367 | if (status == TPM_STS_COMMAND_READY) | |
368 | return -EINTR; | |
369 | if ((status & (TPM_STS_DATA_AVAIL | TPM_STS_VALID)) != | |
370 | (TPM_STS_DATA_AVAIL | TPM_STS_VALID)) | |
371 | return -EAGAIN; | |
372 | ||
373 | debug("...got it;\n"); | |
f6267998 | 374 | |
1b393db5 | 375 | /* Read first 10 bytes, including tag, paramsize, and result */ |
b697e0ff | 376 | size = tpm_tis_i2c_recv_data(dev, buf, TPM_HEADER_SIZE); |
f6267998 | 377 | if (size < TPM_HEADER_SIZE) { |
b697e0ff SG |
378 | debug("Unable to read header\n"); |
379 | return size < 0 ? size : -EIO; | |
f6267998 RC |
380 | } |
381 | ||
382 | expected = get_unaligned_be32(buf + TPM_RSP_SIZE_BYTE); | |
383 | if ((size_t)expected > count) { | |
b697e0ff | 384 | debug("Error size=%x, expected=%x, count=%x\n", size, expected, |
f90acf1a | 385 | count); |
b697e0ff | 386 | return -ENOSPC; |
f6267998 RC |
387 | } |
388 | ||
b697e0ff | 389 | size += tpm_tis_i2c_recv_data(dev, &buf[TPM_HEADER_SIZE], |
e56e20eb | 390 | expected - TPM_HEADER_SIZE); |
f6267998 | 391 | if (size < expected) { |
b697e0ff SG |
392 | debug("Unable to read remainder of result\n"); |
393 | return -ETIMEDOUT; | |
f6267998 RC |
394 | } |
395 | ||
b697e0ff SG |
396 | rc = tpm_tis_i2c_wait_for_stat(dev, TPM_STS_VALID, chip->timeout_c, |
397 | &status); | |
398 | if (rc) | |
399 | return rc; | |
1b393db5 | 400 | if (status & TPM_STS_DATA_AVAIL) { /* Retry? */ |
b697e0ff SG |
401 | debug("Error left over data\n"); |
402 | return -EIO; | |
f6267998 RC |
403 | } |
404 | ||
f6267998 RC |
405 | return size; |
406 | } | |
407 | ||
b697e0ff | 408 | static int tpm_tis_i2c_send(struct udevice *dev, const u8 *buf, size_t len) |
f6267998 | 409 | { |
b697e0ff | 410 | struct tpm_chip *chip = dev_get_priv(dev); |
f6267998 | 411 | int rc, status; |
f90acf1a | 412 | size_t burstcnt; |
f6267998 | 413 | size_t count = 0; |
1b393db5 | 414 | int retry = 0; |
f6267998 RC |
415 | u8 sts = TPM_STS_GO; |
416 | ||
f90acf1a | 417 | debug("%s: len=%d\n", __func__, len); |
1b393db5 TWHT |
418 | if (len > TPM_DEV_BUFSIZE) |
419 | return -E2BIG; /* Command is too long for our tpm, sorry */ | |
f6267998 | 420 | |
b697e0ff | 421 | if (tpm_tis_i2c_request_locality(dev, 0) < 0) |
f6267998 RC |
422 | return -EBUSY; |
423 | ||
b697e0ff | 424 | status = tpm_tis_i2c_status(dev); |
f6267998 | 425 | if ((status & TPM_STS_COMMAND_READY) == 0) { |
b697e0ff SG |
426 | rc = tpm_tis_i2c_ready(dev); |
427 | if (rc) | |
428 | return rc; | |
429 | rc = tpm_tis_i2c_wait_for_stat(dev, TPM_STS_COMMAND_READY, | |
430 | chip->timeout_b, &status); | |
431 | if (rc) | |
432 | return rc; | |
f6267998 RC |
433 | } |
434 | ||
b697e0ff | 435 | burstcnt = tpm_tis_i2c_get_burstcount(dev); |
f6267998 | 436 | |
1b393db5 TWHT |
437 | /* burstcount < 0 -> tpm is busy */ |
438 | if (burstcnt < 0) | |
439 | return burstcnt; | |
f6267998 | 440 | |
f90acf1a SG |
441 | while (count < len) { |
442 | udelay(300); | |
443 | if (burstcnt > len - count) | |
444 | burstcnt = len - count; | |
f6267998 | 445 | |
1b393db5 | 446 | #ifdef CONFIG_TPM_TIS_I2C_BURST_LIMITATION |
b697e0ff SG |
447 | if (retry && burstcnt > CONFIG_TPM_TIS_I2C_BURST_LIMITATION_LEN) |
448 | burstcnt = CONFIG_TPM_TIS_I2C_BURST_LIMITATION_LEN; | |
1b393db5 | 449 | #endif /* CONFIG_TPM_TIS_I2C_BURST_LIMITATION */ |
f6267998 | 450 | |
b697e0ff SG |
451 | rc = tpm_tis_i2c_write(dev, TPM_DATA_FIFO(chip->locality), |
452 | &(buf[count]), burstcnt); | |
f6267998 RC |
453 | if (rc == 0) |
454 | count += burstcnt; | |
1b393db5 | 455 | else { |
f90acf1a | 456 | debug("%s: error\n", __func__); |
b697e0ff SG |
457 | if (retry++ > 10) |
458 | return -EIO; | |
459 | rc = tpm_tis_i2c_wait_for_stat(dev, TPM_STS_VALID, | |
e56e20eb SG |
460 | chip->timeout_c, |
461 | &status); | |
f90acf1a | 462 | if (rc) |
b697e0ff | 463 | return rc; |
1b393db5 | 464 | |
b697e0ff SG |
465 | if ((status & TPM_STS_DATA_EXPECT) == 0) |
466 | return -EIO; | |
f6267998 RC |
467 | } |
468 | } | |
469 | ||
1b393db5 | 470 | /* Go and do it */ |
b697e0ff SG |
471 | rc = tpm_tis_i2c_write(dev, TPM_STS(chip->locality), &sts, 1); |
472 | if (rc < 0) | |
473 | return rc; | |
474 | debug("%s: done, rc=%d\n", __func__, rc); | |
f6267998 RC |
475 | |
476 | return len; | |
b697e0ff SG |
477 | } |
478 | ||
479 | static int tpm_tis_i2c_cleanup(struct udevice *dev) | |
480 | { | |
481 | struct tpm_chip *chip = dev_get_priv(dev); | |
1b393db5 | 482 | |
b697e0ff | 483 | tpm_tis_i2c_ready(dev); |
1b393db5 TWHT |
484 | /* |
485 | * The TPM needs some time to clean up here, | |
f6267998 RC |
486 | * so we sleep rather than keeping the bus busy |
487 | */ | |
42c8ec56 | 488 | mdelay(2); |
b697e0ff | 489 | tpm_tis_i2c_release_locality(dev, chip->locality, 0); |
f6267998 | 490 | |
b697e0ff | 491 | return 0; |
ec34fa5e VP |
492 | } |
493 | ||
13932b09 | 494 | static int tpm_tis_i2c_init(struct udevice *dev) |
f6267998 | 495 | { |
b697e0ff | 496 | struct tpm_chip *chip = dev_get_priv(dev); |
f6267998 | 497 | u32 vendor; |
ec34fa5e | 498 | u32 expected_did_vid; |
b697e0ff | 499 | int rc; |
f6267998 | 500 | |
7c73537e | 501 | chip->is_open = 1; |
f6267998 | 502 | |
e56e20eb | 503 | /* Default timeouts - these could move to the device tree */ |
42c8ec56 SG |
504 | chip->timeout_a = TIS_SHORT_TIMEOUT_MS; |
505 | chip->timeout_b = TIS_LONG_TIMEOUT_MS; | |
506 | chip->timeout_c = TIS_SHORT_TIMEOUT_MS; | |
507 | chip->timeout_d = TIS_SHORT_TIMEOUT_MS; | |
f6267998 | 508 | |
b697e0ff SG |
509 | rc = tpm_tis_i2c_request_locality(dev, 0); |
510 | if (rc < 0) | |
511 | return rc; | |
f6267998 | 512 | |
1b393db5 | 513 | /* Read four bytes from DID_VID register */ |
b697e0ff SG |
514 | if (tpm_tis_i2c_read(dev, TPM_DID_VID(0), (uchar *)&vendor, 4) < 0) { |
515 | tpm_tis_i2c_release_locality(dev, 0, 1); | |
f90acf1a | 516 | return -EIO; |
f6267998 RC |
517 | } |
518 | ||
b697e0ff | 519 | if (chip->chip_type == SLB9635) { |
ec34fa5e VP |
520 | vendor = be32_to_cpu(vendor); |
521 | expected_did_vid = TPM_TIS_I2C_DID_VID_9635; | |
522 | } else { | |
523 | /* device id and byte order has changed for newer i2c tpms */ | |
524 | expected_did_vid = TPM_TIS_I2C_DID_VID_9645; | |
525 | } | |
f6267998 | 526 | |
b697e0ff | 527 | if (chip->chip_type != UNKNOWN && vendor != expected_did_vid) { |
1b393db5 | 528 | error("Vendor id did not match! ID was %08x\n", vendor); |
f90acf1a | 529 | return -ENODEV; |
f6267998 RC |
530 | } |
531 | ||
b697e0ff | 532 | chip->vend_dev = vendor; |
1b393db5 | 533 | debug("1.2 TPM (chip type %s device-id 0x%X)\n", |
b697e0ff | 534 | chip_name[chip->chip_type], vendor >> 16); |
f6267998 RC |
535 | |
536 | /* | |
537 | * A timeout query to TPM can be placed here. | |
538 | * Standard timeout values are used so far | |
539 | */ | |
540 | ||
541 | return 0; | |
f90acf1a SG |
542 | } |
543 | ||
b697e0ff | 544 | static int tpm_tis_i2c_open(struct udevice *dev) |
4cd7b783 | 545 | { |
b697e0ff | 546 | struct tpm_chip *chip = dev_get_priv(dev); |
4cd7b783 | 547 | int rc; |
4cd7b783 | 548 | |
b697e0ff SG |
549 | debug("%s: start\n", __func__); |
550 | if (chip->is_open) | |
551 | return -EBUSY; | |
552 | rc = tpm_tis_i2c_init(dev); | |
4cd7b783 | 553 | if (rc < 0) |
b697e0ff | 554 | chip->is_open = 0; |
4cd7b783 | 555 | |
4cd7b783 SG |
556 | return rc; |
557 | } | |
558 | ||
b697e0ff | 559 | static int tpm_tis_i2c_close(struct udevice *dev) |
4cd7b783 | 560 | { |
b697e0ff | 561 | struct tpm_chip *chip = dev_get_priv(dev); |
4cd7b783 | 562 | |
b697e0ff SG |
563 | if (chip->is_open) { |
564 | tpm_tis_i2c_release_locality(dev, chip->locality, 1); | |
565 | chip->is_open = 0; | |
566 | chip->vend_dev = 0; | |
4cd7b783 SG |
567 | } |
568 | ||
569 | return 0; | |
570 | } | |
571 | ||
b697e0ff | 572 | static int tpm_tis_get_desc(struct udevice *dev, char *buf, int size) |
4cd7b783 | 573 | { |
b697e0ff | 574 | struct tpm_chip *chip = dev_get_priv(dev); |
4cd7b783 | 575 | |
b697e0ff SG |
576 | if (size < 50) |
577 | return -ENOSPC; | |
4cd7b783 | 578 | |
b697e0ff SG |
579 | return snprintf(buf, size, "1.2 TPM (%s, chip type %s device-id 0x%x)", |
580 | chip->is_open ? "open" : "closed", | |
581 | chip_name[chip->chip_type], | |
582 | chip->vend_dev >> 16); | |
4cd7b783 SG |
583 | } |
584 | ||
b697e0ff | 585 | static int tpm_tis_i2c_probe(struct udevice *dev) |
4cd7b783 | 586 | { |
b697e0ff SG |
587 | struct tpm_chip_priv *uc_priv = dev_get_uclass_priv(dev); |
588 | struct tpm_chip *chip = dev_get_priv(dev); | |
4cd7b783 | 589 | |
b697e0ff | 590 | chip->chip_type = dev_get_driver_data(dev); |
4cd7b783 | 591 | |
b697e0ff SG |
592 | /* TODO: These need to be checked and tuned */ |
593 | uc_priv->duration_ms[TPM_SHORT] = TIS_SHORT_TIMEOUT_MS; | |
594 | uc_priv->duration_ms[TPM_MEDIUM] = TIS_LONG_TIMEOUT_MS; | |
595 | uc_priv->duration_ms[TPM_LONG] = TIS_LONG_TIMEOUT_MS; | |
596 | uc_priv->retry_time_ms = TPM_TIMEOUT_MS; | |
4cd7b783 SG |
597 | |
598 | return 0; | |
599 | } | |
600 | ||
b697e0ff SG |
601 | static const struct tpm_ops tpm_tis_i2c_ops = { |
602 | .open = tpm_tis_i2c_open, | |
603 | .close = tpm_tis_i2c_close, | |
604 | .get_desc = tpm_tis_get_desc, | |
605 | .send = tpm_tis_i2c_send, | |
606 | .recv = tpm_tis_i2c_recv, | |
607 | .cleanup = tpm_tis_i2c_cleanup, | |
608 | }; | |
4cd7b783 | 609 | |
b697e0ff SG |
610 | static const struct udevice_id tpm_tis_i2c_ids[] = { |
611 | { .compatible = "infineon,slb9635tt", .data = SLB9635 }, | |
612 | { .compatible = "infineon,slb9645tt", .data = SLB9645 }, | |
613 | { } | |
614 | }; | |
4cd7b783 | 615 | |
b697e0ff SG |
616 | U_BOOT_DRIVER(tpm_tis_i2c) = { |
617 | .name = "tpm_tis_i2c", | |
618 | .id = UCLASS_TPM, | |
619 | .of_match = tpm_tis_i2c_ids, | |
620 | .ops = &tpm_tis_i2c_ops, | |
621 | .probe = tpm_tis_i2c_probe, | |
622 | .priv_auto_alloc_size = sizeof(struct tpm_chip), | |
623 | }; |