1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (C) 2012,2013 Infineon Technologies |
4 | * |
5 | * Authors: |
6 | * Peter Huewe <peter.huewe@infineon.com> |
7 | * |
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 original tpm_tis device driver from Leendert van |
16 | * Dorn and Kyleen Hall. |
17 | */ |
18 | #include <linux/i2c.h> |
19 | #include <linux/module.h> |
20 | #include <linux/wait.h> |
21 | #include "tpm.h" |
22 | |
23 | #define TPM_I2C_INFINEON_BUFSIZE 1260 |
24 | |
25 | /* max. number of iterations after I2C NAK */ |
26 | #define MAX_COUNT 3 |
27 | |
28 | #define SLEEP_DURATION_LOW 55 |
29 | #define SLEEP_DURATION_HI 65 |
30 | |
31 | /* max. number of iterations after I2C NAK for 'long' commands |
32 | * we need this especially for sending TPM_READY, since the cleanup after the |
33 | * transtion to the ready state may take some time, but it is unpredictable |
34 | * how long it will take. |
35 | */ |
36 | #define MAX_COUNT_LONG 50 |
37 | |
38 | #define SLEEP_DURATION_LONG_LOW 200 |
39 | #define SLEEP_DURATION_LONG_HI 220 |
40 | |
41 | /* After sending TPM_READY to 'reset' the TPM we have to sleep even longer */ |
42 | #define SLEEP_DURATION_RESET_LOW 2400 |
43 | #define SLEEP_DURATION_RESET_HI 2600 |
44 | |
45 | /* we want to use usleep_range instead of msleep for the 5ms TPM_TIMEOUT */ |
46 | #define TPM_TIMEOUT_US_LOW (TPM_TIMEOUT * 1000) |
47 | #define TPM_TIMEOUT_US_HI (TPM_TIMEOUT_US_LOW + 2000) |
48 | |
49 | /* expected value for DIDVID register */ |
50 | #define TPM_TIS_I2C_DID_VID_9635 0xd1150b00L |
51 | #define TPM_TIS_I2C_DID_VID_9645 0x001a15d1L |
52 | |
53 | enum i2c_chip_type { |
54 | SLB9635, |
55 | SLB9645, |
56 | UNKNOWN, |
57 | }; |
58 | |
59 | struct tpm_inf_dev { |
60 | struct i2c_client *client; |
61 | int locality; |
62 | /* In addition to the data itself, the buffer must fit the 7-bit I2C |
63 | * address and the direction bit. |
64 | */ |
65 | u8 buf[TPM_I2C_INFINEON_BUFSIZE + 1]; |
66 | struct tpm_chip *chip; |
67 | enum i2c_chip_type chip_type; |
68 | unsigned int adapterlimit; |
69 | }; |
70 | |
71 | static struct tpm_inf_dev tpm_dev; |
72 | |
73 | /* |
74 | * iic_tpm_read() - read from TPM register |
75 | * @addr: register address to read from |
76 | * @buffer: provided by caller |
77 | * @len: number of bytes to read |
78 | * |
79 | * Read len bytes from TPM register and put them into |
80 | * buffer (little-endian format, i.e. first byte is put into buffer[0]). |
81 | * |
82 | * NOTE: TPM is big-endian for multi-byte values. Multi-byte |
83 | * values have to be swapped. |
84 | * |
85 | * NOTE: We can't unfortunately use the combined read/write functions |
86 | * provided by the i2c core as the TPM currently does not support the |
87 | * repeated start condition and due to it's special requirements. |
88 | * The i2c_smbus* functions do not work for this chip. |
89 | * |
90 | * Return -EIO on error, 0 on success. |
91 | */ |
92 | static int iic_tpm_read(u8 addr, u8 *buffer, size_t len) |
93 | { |
94 | |
95 | struct i2c_msg msg1 = { |
96 | .addr = tpm_dev.client->addr, |
97 | .len = 1, |
98 | .buf = &addr |
99 | }; |
100 | struct i2c_msg msg2 = { |
101 | .addr = tpm_dev.client->addr, |
102 | .flags = I2C_M_RD, |
103 | .len = len, |
104 | .buf = buffer |
105 | }; |
106 | struct i2c_msg msgs[] = {msg1, msg2}; |
107 | |
108 | int rc = 0; |
109 | int count; |
110 | unsigned int msglen = len; |
111 | |
112 | /* Lock the adapter for the duration of the whole sequence. */ |
113 | if (!tpm_dev.client->adapter->algo->master_xfer) |
114 | return -EOPNOTSUPP; |
115 | i2c_lock_bus(adapter: tpm_dev.client->adapter, I2C_LOCK_SEGMENT); |
116 | |
117 | if (tpm_dev.chip_type == SLB9645) { |
118 | /* use a combined read for newer chips |
119 | * unfortunately the smbus functions are not suitable due to |
120 | * the 32 byte limit of the smbus. |
121 | * retries should usually not be needed, but are kept just to |
122 | * be on the safe side. |
123 | */ |
124 | for (count = 0; count < MAX_COUNT; count++) { |
125 | rc = __i2c_transfer(adap: tpm_dev.client->adapter, msgs, num: 2); |
126 | if (rc > 0) |
127 | break; /* break here to skip sleep */ |
128 | usleep_range(SLEEP_DURATION_LOW, SLEEP_DURATION_HI); |
129 | } |
130 | } else { |
131 | /* Expect to send one command message and one data message, but |
132 | * support looping over each or both if necessary. |
133 | */ |
134 | while (len > 0) { |
135 | /* slb9635 protocol should work in all cases */ |
136 | for (count = 0; count < MAX_COUNT; count++) { |
137 | rc = __i2c_transfer(adap: tpm_dev.client->adapter, |
138 | msgs: &msg1, num: 1); |
139 | if (rc > 0) |
140 | break; /* break here to skip sleep */ |
141 | |
142 | usleep_range(SLEEP_DURATION_LOW, |
143 | SLEEP_DURATION_HI); |
144 | } |
145 | |
146 | if (rc <= 0) |
147 | goto out; |
148 | |
149 | /* After the TPM has successfully received the register |
150 | * address it needs some time, thus we're sleeping here |
151 | * again, before retrieving the data |
152 | */ |
153 | for (count = 0; count < MAX_COUNT; count++) { |
154 | if (tpm_dev.adapterlimit) { |
155 | msglen = min_t(unsigned int, |
156 | tpm_dev.adapterlimit, |
157 | len); |
158 | msg2.len = msglen; |
159 | } |
160 | usleep_range(SLEEP_DURATION_LOW, |
161 | SLEEP_DURATION_HI); |
162 | rc = __i2c_transfer(adap: tpm_dev.client->adapter, |
163 | msgs: &msg2, num: 1); |
164 | if (rc > 0) { |
165 | /* Since len is unsigned, make doubly |
166 | * sure we do not underflow it. |
167 | */ |
168 | if (msglen > len) |
169 | len = 0; |
170 | else |
171 | len -= msglen; |
172 | msg2.buf += msglen; |
173 | break; |
174 | } |
175 | /* If the I2C adapter rejected the request (e.g |
176 | * when the quirk read_max_len < len) fall back |
177 | * to a sane minimum value and try again. |
178 | */ |
179 | if (rc == -EOPNOTSUPP) |
180 | tpm_dev.adapterlimit = |
181 | I2C_SMBUS_BLOCK_MAX; |
182 | } |
183 | |
184 | if (rc <= 0) |
185 | goto out; |
186 | } |
187 | } |
188 | |
189 | out: |
190 | i2c_unlock_bus(adapter: tpm_dev.client->adapter, I2C_LOCK_SEGMENT); |
191 | /* take care of 'guard time' */ |
192 | usleep_range(SLEEP_DURATION_LOW, SLEEP_DURATION_HI); |
193 | |
194 | /* __i2c_transfer returns the number of successfully transferred |
195 | * messages. |
196 | * So rc should be greater than 0 here otherwise we have an error. |
197 | */ |
198 | if (rc <= 0) |
199 | return -EIO; |
200 | |
201 | return 0; |
202 | } |
203 | |
204 | static int iic_tpm_write_generic(u8 addr, u8 *buffer, size_t len, |
205 | unsigned int sleep_low, |
206 | unsigned int sleep_hi, u8 max_count) |
207 | { |
208 | int rc = -EIO; |
209 | int count; |
210 | |
211 | struct i2c_msg msg1 = { |
212 | .addr = tpm_dev.client->addr, |
213 | .len = len + 1, |
214 | .buf = tpm_dev.buf |
215 | }; |
216 | |
217 | if (len > TPM_I2C_INFINEON_BUFSIZE) |
218 | return -EINVAL; |
219 | |
220 | if (!tpm_dev.client->adapter->algo->master_xfer) |
221 | return -EOPNOTSUPP; |
222 | i2c_lock_bus(adapter: tpm_dev.client->adapter, I2C_LOCK_SEGMENT); |
223 | |
224 | /* prepend the 'register address' to the buffer */ |
225 | tpm_dev.buf[0] = addr; |
226 | memcpy(&(tpm_dev.buf[1]), buffer, len); |
227 | |
228 | /* |
229 | * NOTE: We have to use these special mechanisms here and unfortunately |
230 | * cannot rely on the standard behavior of i2c_transfer. |
231 | * Even for newer chips the smbus functions are not |
232 | * suitable due to the 32 byte limit of the smbus. |
233 | */ |
234 | for (count = 0; count < max_count; count++) { |
235 | rc = __i2c_transfer(adap: tpm_dev.client->adapter, msgs: &msg1, num: 1); |
236 | if (rc > 0) |
237 | break; |
238 | usleep_range(min: sleep_low, max: sleep_hi); |
239 | } |
240 | |
241 | i2c_unlock_bus(adapter: tpm_dev.client->adapter, I2C_LOCK_SEGMENT); |
242 | /* take care of 'guard time' */ |
243 | usleep_range(SLEEP_DURATION_LOW, SLEEP_DURATION_HI); |
244 | |
245 | /* __i2c_transfer returns the number of successfully transferred |
246 | * messages. |
247 | * So rc should be greater than 0 here otherwise we have an error. |
248 | */ |
249 | if (rc <= 0) |
250 | return -EIO; |
251 | |
252 | return 0; |
253 | } |
254 | |
255 | /* |
256 | * iic_tpm_write() - write to TPM register |
257 | * @addr: register address to write to |
258 | * @buffer: containing data to be written |
259 | * @len: number of bytes to write |
260 | * |
261 | * Write len bytes from provided buffer to TPM register (little |
262 | * endian format, i.e. buffer[0] is written as first byte). |
263 | * |
264 | * NOTE: TPM is big-endian for multi-byte values. Multi-byte |
265 | * values have to be swapped. |
266 | * |
267 | * NOTE: use this function instead of the iic_tpm_write_generic function. |
268 | * |
269 | * Return -EIO on error, 0 on success |
270 | */ |
271 | static int iic_tpm_write(u8 addr, u8 *buffer, size_t len) |
272 | { |
273 | return iic_tpm_write_generic(addr, buffer, len, SLEEP_DURATION_LOW, |
274 | SLEEP_DURATION_HI, MAX_COUNT); |
275 | } |
276 | |
277 | /* |
278 | * This function is needed especially for the cleanup situation after |
279 | * sending TPM_READY |
280 | * */ |
281 | static int iic_tpm_write_long(u8 addr, u8 *buffer, size_t len) |
282 | { |
283 | return iic_tpm_write_generic(addr, buffer, len, SLEEP_DURATION_LONG_LOW, |
284 | SLEEP_DURATION_LONG_HI, MAX_COUNT_LONG); |
285 | } |
286 | |
287 | enum tis_access { |
288 | TPM_ACCESS_VALID = 0x80, |
289 | TPM_ACCESS_ACTIVE_LOCALITY = 0x20, |
290 | TPM_ACCESS_REQUEST_PENDING = 0x04, |
291 | TPM_ACCESS_REQUEST_USE = 0x02, |
292 | }; |
293 | |
294 | enum tis_status { |
295 | TPM_STS_VALID = 0x80, |
296 | TPM_STS_COMMAND_READY = 0x40, |
297 | TPM_STS_GO = 0x20, |
298 | TPM_STS_DATA_AVAIL = 0x10, |
299 | TPM_STS_DATA_EXPECT = 0x08, |
300 | }; |
301 | |
302 | enum tis_defaults { |
303 | TIS_SHORT_TIMEOUT = 750, /* ms */ |
304 | TIS_LONG_TIMEOUT = 2000, /* 2 sec */ |
305 | }; |
306 | |
307 | #define TPM_ACCESS(l) (0x0000 | ((l) << 4)) |
308 | #define TPM_STS(l) (0x0001 | ((l) << 4)) |
309 | #define TPM_DATA_FIFO(l) (0x0005 | ((l) << 4)) |
310 | #define TPM_DID_VID(l) (0x0006 | ((l) << 4)) |
311 | |
312 | static bool check_locality(struct tpm_chip *chip, int loc) |
313 | { |
314 | u8 buf; |
315 | int rc; |
316 | |
317 | rc = iic_tpm_read(TPM_ACCESS(loc), buffer: &buf, len: 1); |
318 | if (rc < 0) |
319 | return false; |
320 | |
321 | if ((buf & (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) == |
322 | (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) { |
323 | tpm_dev.locality = loc; |
324 | return true; |
325 | } |
326 | |
327 | return false; |
328 | } |
329 | |
330 | /* implementation similar to tpm_tis */ |
331 | static void release_locality(struct tpm_chip *chip, int loc, int force) |
332 | { |
333 | u8 buf; |
334 | if (iic_tpm_read(TPM_ACCESS(loc), buffer: &buf, len: 1) < 0) |
335 | return; |
336 | |
337 | if (force || (buf & (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) == |
338 | (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) { |
339 | buf = TPM_ACCESS_ACTIVE_LOCALITY; |
340 | iic_tpm_write(TPM_ACCESS(loc), buffer: &buf, len: 1); |
341 | } |
342 | } |
343 | |
344 | static int request_locality(struct tpm_chip *chip, int loc) |
345 | { |
346 | unsigned long stop; |
347 | u8 buf = TPM_ACCESS_REQUEST_USE; |
348 | |
349 | if (check_locality(chip, loc)) |
350 | return loc; |
351 | |
352 | iic_tpm_write(TPM_ACCESS(loc), buffer: &buf, len: 1); |
353 | |
354 | /* wait for burstcount */ |
355 | stop = jiffies + chip->timeout_a; |
356 | do { |
357 | if (check_locality(chip, loc)) |
358 | return loc; |
359 | usleep_range(TPM_TIMEOUT_US_LOW, TPM_TIMEOUT_US_HI); |
360 | } while (time_before(jiffies, stop)); |
361 | |
362 | return -ETIME; |
363 | } |
364 | |
365 | static u8 tpm_tis_i2c_status(struct tpm_chip *chip) |
366 | { |
367 | /* NOTE: since I2C read may fail, return 0 in this case --> time-out */ |
368 | u8 buf = 0xFF; |
369 | u8 i = 0; |
370 | |
371 | do { |
372 | if (iic_tpm_read(TPM_STS(tpm_dev.locality), buffer: &buf, len: 1) < 0) |
373 | return 0; |
374 | |
375 | i++; |
376 | /* if locallity is set STS should not be 0xFF */ |
377 | } while ((buf == 0xFF) && i < 10); |
378 | |
379 | return buf; |
380 | } |
381 | |
382 | static void tpm_tis_i2c_ready(struct tpm_chip *chip) |
383 | { |
384 | /* this causes the current command to be aborted */ |
385 | u8 buf = TPM_STS_COMMAND_READY; |
386 | iic_tpm_write_long(TPM_STS(tpm_dev.locality), buffer: &buf, len: 1); |
387 | } |
388 | |
389 | static ssize_t get_burstcount(struct tpm_chip *chip) |
390 | { |
391 | unsigned long stop; |
392 | ssize_t burstcnt; |
393 | u8 buf[3]; |
394 | |
395 | /* wait for burstcount */ |
396 | /* which timeout value, spec has 2 answers (c & d) */ |
397 | stop = jiffies + chip->timeout_d; |
398 | do { |
399 | /* Note: STS is little endian */ |
400 | if (iic_tpm_read(TPM_STS(tpm_dev.locality)+1, buffer: buf, len: 3) < 0) |
401 | burstcnt = 0; |
402 | else |
403 | burstcnt = (buf[2] << 16) + (buf[1] << 8) + buf[0]; |
404 | |
405 | if (burstcnt) |
406 | return burstcnt; |
407 | |
408 | usleep_range(TPM_TIMEOUT_US_LOW, TPM_TIMEOUT_US_HI); |
409 | } while (time_before(jiffies, stop)); |
410 | return -EBUSY; |
411 | } |
412 | |
413 | static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout, |
414 | int *status) |
415 | { |
416 | unsigned long stop; |
417 | |
418 | /* check current status */ |
419 | *status = tpm_tis_i2c_status(chip); |
420 | if ((*status != 0xFF) && (*status & mask) == mask) |
421 | return 0; |
422 | |
423 | stop = jiffies + timeout; |
424 | do { |
425 | /* since we just checked the status, give the TPM some time */ |
426 | usleep_range(TPM_TIMEOUT_US_LOW, TPM_TIMEOUT_US_HI); |
427 | *status = tpm_tis_i2c_status(chip); |
428 | if ((*status & mask) == mask) |
429 | return 0; |
430 | |
431 | } while (time_before(jiffies, stop)); |
432 | |
433 | return -ETIME; |
434 | } |
435 | |
436 | static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count) |
437 | { |
438 | size_t size = 0; |
439 | ssize_t burstcnt; |
440 | u8 retries = 0; |
441 | int rc; |
442 | |
443 | while (size < count) { |
444 | burstcnt = get_burstcount(chip); |
445 | |
446 | /* burstcnt < 0 = TPM is busy */ |
447 | if (burstcnt < 0) |
448 | return burstcnt; |
449 | |
450 | /* limit received data to max. left */ |
451 | if (burstcnt > (count - size)) |
452 | burstcnt = count - size; |
453 | |
454 | rc = iic_tpm_read(TPM_DATA_FIFO(tpm_dev.locality), |
455 | buffer: &(buf[size]), len: burstcnt); |
456 | if (rc == 0) |
457 | size += burstcnt; |
458 | else if (rc < 0) |
459 | retries++; |
460 | |
461 | /* avoid endless loop in case of broken HW */ |
462 | if (retries > MAX_COUNT_LONG) |
463 | return -EIO; |
464 | } |
465 | return size; |
466 | } |
467 | |
468 | static int tpm_tis_i2c_recv(struct tpm_chip *chip, u8 *buf, size_t count) |
469 | { |
470 | int size = 0; |
471 | int status; |
472 | u32 expected; |
473 | |
474 | if (count < TPM_HEADER_SIZE) { |
475 | size = -EIO; |
476 | goto out; |
477 | } |
478 | |
479 | /* read first 10 bytes, including tag, paramsize, and result */ |
480 | size = recv_data(chip, buf, TPM_HEADER_SIZE); |
481 | if (size < TPM_HEADER_SIZE) { |
482 | dev_err(&chip->dev, "Unable to read header\n" ); |
483 | goto out; |
484 | } |
485 | |
486 | expected = be32_to_cpu(*(__be32 *)(buf + 2)); |
487 | if (((size_t) expected > count) || (expected < TPM_HEADER_SIZE)) { |
488 | size = -EIO; |
489 | goto out; |
490 | } |
491 | |
492 | size += recv_data(chip, buf: &buf[TPM_HEADER_SIZE], |
493 | count: expected - TPM_HEADER_SIZE); |
494 | if (size < expected) { |
495 | dev_err(&chip->dev, "Unable to read remainder of result\n" ); |
496 | size = -ETIME; |
497 | goto out; |
498 | } |
499 | |
500 | wait_for_stat(chip, mask: TPM_STS_VALID, timeout: chip->timeout_c, status: &status); |
501 | if (status & TPM_STS_DATA_AVAIL) { /* retry? */ |
502 | dev_err(&chip->dev, "Error left over data\n" ); |
503 | size = -EIO; |
504 | goto out; |
505 | } |
506 | |
507 | out: |
508 | tpm_tis_i2c_ready(chip); |
509 | /* The TPM needs some time to clean up here, |
510 | * so we sleep rather than keeping the bus busy |
511 | */ |
512 | usleep_range(SLEEP_DURATION_RESET_LOW, SLEEP_DURATION_RESET_HI); |
513 | release_locality(chip, loc: tpm_dev.locality, force: 0); |
514 | return size; |
515 | } |
516 | |
517 | static int tpm_tis_i2c_send(struct tpm_chip *chip, u8 *buf, size_t len) |
518 | { |
519 | int rc, status; |
520 | ssize_t burstcnt; |
521 | size_t count = 0; |
522 | u8 retries = 0; |
523 | u8 sts = TPM_STS_GO; |
524 | |
525 | if (len > TPM_I2C_INFINEON_BUFSIZE) |
526 | return -E2BIG; |
527 | |
528 | if (request_locality(chip, loc: 0) < 0) |
529 | return -EBUSY; |
530 | |
531 | status = tpm_tis_i2c_status(chip); |
532 | if ((status & TPM_STS_COMMAND_READY) == 0) { |
533 | tpm_tis_i2c_ready(chip); |
534 | if (wait_for_stat |
535 | (chip, mask: TPM_STS_COMMAND_READY, |
536 | timeout: chip->timeout_b, status: &status) < 0) { |
537 | rc = -ETIME; |
538 | goto out_err; |
539 | } |
540 | } |
541 | |
542 | while (count < len - 1) { |
543 | burstcnt = get_burstcount(chip); |
544 | |
545 | /* burstcnt < 0 = TPM is busy */ |
546 | if (burstcnt < 0) |
547 | return burstcnt; |
548 | |
549 | if (burstcnt > (len - 1 - count)) |
550 | burstcnt = len - 1 - count; |
551 | |
552 | rc = iic_tpm_write(TPM_DATA_FIFO(tpm_dev.locality), |
553 | buffer: &(buf[count]), len: burstcnt); |
554 | if (rc == 0) |
555 | count += burstcnt; |
556 | else if (rc < 0) |
557 | retries++; |
558 | |
559 | /* avoid endless loop in case of broken HW */ |
560 | if (retries > MAX_COUNT_LONG) { |
561 | rc = -EIO; |
562 | goto out_err; |
563 | } |
564 | |
565 | wait_for_stat(chip, mask: TPM_STS_VALID, |
566 | timeout: chip->timeout_c, status: &status); |
567 | |
568 | if ((status & TPM_STS_DATA_EXPECT) == 0) { |
569 | rc = -EIO; |
570 | goto out_err; |
571 | } |
572 | } |
573 | |
574 | /* write last byte */ |
575 | iic_tpm_write(TPM_DATA_FIFO(tpm_dev.locality), buffer: &(buf[count]), len: 1); |
576 | wait_for_stat(chip, mask: TPM_STS_VALID, timeout: chip->timeout_c, status: &status); |
577 | if ((status & TPM_STS_DATA_EXPECT) != 0) { |
578 | rc = -EIO; |
579 | goto out_err; |
580 | } |
581 | |
582 | /* go and do it */ |
583 | iic_tpm_write(TPM_STS(tpm_dev.locality), buffer: &sts, len: 1); |
584 | |
585 | return 0; |
586 | out_err: |
587 | tpm_tis_i2c_ready(chip); |
588 | /* The TPM needs some time to clean up here, |
589 | * so we sleep rather than keeping the bus busy |
590 | */ |
591 | usleep_range(SLEEP_DURATION_RESET_LOW, SLEEP_DURATION_RESET_HI); |
592 | release_locality(chip, loc: tpm_dev.locality, force: 0); |
593 | return rc; |
594 | } |
595 | |
596 | static bool tpm_tis_i2c_req_canceled(struct tpm_chip *chip, u8 status) |
597 | { |
598 | return (status == TPM_STS_COMMAND_READY); |
599 | } |
600 | |
601 | static const struct tpm_class_ops tpm_tis_i2c = { |
602 | .flags = TPM_OPS_AUTO_STARTUP, |
603 | .status = tpm_tis_i2c_status, |
604 | .recv = tpm_tis_i2c_recv, |
605 | .send = tpm_tis_i2c_send, |
606 | .cancel = tpm_tis_i2c_ready, |
607 | .req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID, |
608 | .req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID, |
609 | .req_canceled = tpm_tis_i2c_req_canceled, |
610 | }; |
611 | |
612 | static int tpm_tis_i2c_init(struct device *dev) |
613 | { |
614 | u32 vendor; |
615 | int rc = 0; |
616 | struct tpm_chip *chip; |
617 | |
618 | chip = tpmm_chip_alloc(pdev: dev, ops: &tpm_tis_i2c); |
619 | if (IS_ERR(ptr: chip)) |
620 | return PTR_ERR(ptr: chip); |
621 | |
622 | /* Default timeouts */ |
623 | chip->timeout_a = msecs_to_jiffies(m: TIS_SHORT_TIMEOUT); |
624 | chip->timeout_b = msecs_to_jiffies(m: TIS_LONG_TIMEOUT); |
625 | chip->timeout_c = msecs_to_jiffies(m: TIS_SHORT_TIMEOUT); |
626 | chip->timeout_d = msecs_to_jiffies(m: TIS_SHORT_TIMEOUT); |
627 | |
628 | if (request_locality(chip, loc: 0) != 0) { |
629 | dev_err(dev, "could not request locality\n" ); |
630 | rc = -ENODEV; |
631 | goto out_err; |
632 | } |
633 | |
634 | /* read four bytes from DID_VID register */ |
635 | if (iic_tpm_read(TPM_DID_VID(0), buffer: (u8 *)&vendor, len: 4) < 0) { |
636 | dev_err(dev, "could not read vendor id\n" ); |
637 | rc = -EIO; |
638 | goto out_release; |
639 | } |
640 | |
641 | if (vendor == TPM_TIS_I2C_DID_VID_9645) { |
642 | tpm_dev.chip_type = SLB9645; |
643 | } else if (vendor == TPM_TIS_I2C_DID_VID_9635) { |
644 | tpm_dev.chip_type = SLB9635; |
645 | } else { |
646 | dev_err(dev, "vendor id did not match! ID was %08x\n" , vendor); |
647 | rc = -ENODEV; |
648 | goto out_release; |
649 | } |
650 | |
651 | dev_info(dev, "1.2 TPM (device-id 0x%X)\n" , vendor >> 16); |
652 | |
653 | tpm_dev.chip = chip; |
654 | |
655 | return tpm_chip_register(chip); |
656 | out_release: |
657 | release_locality(chip, loc: tpm_dev.locality, force: 1); |
658 | tpm_dev.client = NULL; |
659 | out_err: |
660 | return rc; |
661 | } |
662 | |
663 | static const struct i2c_device_id tpm_tis_i2c_table[] = { |
664 | {"tpm_i2c_infineon" }, |
665 | {"slb9635tt" }, |
666 | {"slb9645tt" }, |
667 | {}, |
668 | }; |
669 | |
670 | MODULE_DEVICE_TABLE(i2c, tpm_tis_i2c_table); |
671 | |
672 | #ifdef CONFIG_OF |
673 | static const struct of_device_id tpm_tis_i2c_of_match[] = { |
674 | {.compatible = "infineon,tpm_i2c_infineon" }, |
675 | {.compatible = "infineon,slb9635tt" }, |
676 | {.compatible = "infineon,slb9645tt" }, |
677 | {}, |
678 | }; |
679 | MODULE_DEVICE_TABLE(of, tpm_tis_i2c_of_match); |
680 | #endif |
681 | |
682 | static SIMPLE_DEV_PM_OPS(tpm_tis_i2c_ops, tpm_pm_suspend, tpm_pm_resume); |
683 | |
684 | static int tpm_tis_i2c_probe(struct i2c_client *client) |
685 | { |
686 | int rc; |
687 | struct device *dev = &(client->dev); |
688 | |
689 | if (tpm_dev.client != NULL) { |
690 | dev_err(dev, "This driver only supports one client at a time\n" ); |
691 | return -EBUSY; /* We only support one client */ |
692 | } |
693 | |
694 | if (!i2c_check_functionality(adap: client->adapter, I2C_FUNC_I2C)) { |
695 | dev_err(dev, "no algorithms associated to the i2c bus\n" ); |
696 | return -ENODEV; |
697 | } |
698 | |
699 | tpm_dev.client = client; |
700 | rc = tpm_tis_i2c_init(dev: &client->dev); |
701 | if (rc != 0) { |
702 | tpm_dev.client = NULL; |
703 | rc = -ENODEV; |
704 | } |
705 | return rc; |
706 | } |
707 | |
708 | static void tpm_tis_i2c_remove(struct i2c_client *client) |
709 | { |
710 | struct tpm_chip *chip = tpm_dev.chip; |
711 | |
712 | tpm_chip_unregister(chip); |
713 | release_locality(chip, loc: tpm_dev.locality, force: 1); |
714 | tpm_dev.client = NULL; |
715 | } |
716 | |
717 | static struct i2c_driver tpm_tis_i2c_driver = { |
718 | .id_table = tpm_tis_i2c_table, |
719 | .probe = tpm_tis_i2c_probe, |
720 | .remove = tpm_tis_i2c_remove, |
721 | .driver = { |
722 | .name = "tpm_i2c_infineon" , |
723 | .pm = &tpm_tis_i2c_ops, |
724 | .of_match_table = of_match_ptr(tpm_tis_i2c_of_match), |
725 | }, |
726 | }; |
727 | |
728 | module_i2c_driver(tpm_tis_i2c_driver); |
729 | MODULE_AUTHOR("Peter Huewe <peter.huewe@infineon.com>" ); |
730 | MODULE_DESCRIPTION("TPM TIS I2C Infineon Driver" ); |
731 | MODULE_VERSION("2.2.0" ); |
732 | MODULE_LICENSE("GPL" ); |
733 | |