1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright 2020 Google Inc.
4 *
5 * Based on Infineon TPM driver by Peter Huewe.
6 *
7 * cr50 is a firmware for H1 secure modules that requires special
8 * handling for the I2C interface.
9 *
10 * - Use an interrupt for transaction status instead of hardcoded delays.
11 * - Must use write+wait+read read protocol.
12 * - All 4 bytes of status register must be read/written at once.
13 * - Burst count max is 63 bytes, and burst count behaves slightly differently
14 * than other I2C TPMs.
15 * - When reading from FIFO the full burstcnt must be read instead of just
16 * reading header and determining the remainder.
17 */
18
19 #include <linux/acpi.h>
20 #include <linux/completion.h>
21 #include <linux/i2c.h>
22 #include <linux/interrupt.h>
23 #include <linux/module.h>
24 #include <linux/pm.h>
25 #include <linux/slab.h>
26 #include <linux/wait.h>
27
28 #include "tpm_tis_core.h"
29
30 #define TPM_CR50_MAX_BUFSIZE 64
31 #define TPM_CR50_TIMEOUT_SHORT_MS 2 /* Short timeout during transactions */
32 #define TPM_CR50_TIMEOUT_NOIRQ_MS 20 /* Timeout for TPM ready without IRQ */
33 #define TPM_CR50_I2C_DID_VID 0x00281ae0L /* Device and vendor ID reg value */
34 #define TPM_TI50_I2C_DID_VID 0x504a6666L /* Device and vendor ID reg value */
35 #define TPM_CR50_I2C_MAX_RETRIES 3 /* Max retries due to I2C errors */
36 #define TPM_CR50_I2C_RETRY_DELAY_LO 55 /* Min usecs between retries on I2C */
37 #define TPM_CR50_I2C_RETRY_DELAY_HI 65 /* Max usecs between retries on I2C */
38
39 #define TPM_I2C_ACCESS(l) (0x0000 | ((l) << 4))
40 #define TPM_I2C_STS(l) (0x0001 | ((l) << 4))
41 #define TPM_I2C_DATA_FIFO(l) (0x0005 | ((l) << 4))
42 #define TPM_I2C_DID_VID(l) (0x0006 | ((l) << 4))
43
44 /**
45 * struct tpm_i2c_cr50_priv_data - Driver private data.
46 * @irq: Irq number used for this chip.
47 * If irq <= 0, then a fixed timeout is used instead of waiting for irq.
48 * @tpm_ready: Struct used by irq handler to signal R/W readiness.
49 * @buf: Buffer used for i2c writes, with i2c address prepended to content.
50 *
51 * Private driver struct used by kernel threads and interrupt context.
52 */
53 struct tpm_i2c_cr50_priv_data {
54 int irq;
55 struct completion tpm_ready;
56 u8 buf[TPM_CR50_MAX_BUFSIZE];
57 };
58
59 /**
60 * tpm_cr50_i2c_int_handler() - cr50 interrupt handler.
61 * @dummy: Unused parameter.
62 * @tpm_info: TPM chip information.
63 *
64 * The cr50 interrupt handler signals waiting threads that the
65 * interrupt has been asserted. It does not do any interrupt triggered
66 * processing but is instead used to avoid fixed delays.
67 *
68 * Return:
69 * IRQ_HANDLED signifies irq was handled by this device.
70 */
tpm_cr50_i2c_int_handler(int dummy,void * tpm_info)71 static irqreturn_t tpm_cr50_i2c_int_handler(int dummy, void *tpm_info)
72 {
73 struct tpm_chip *chip = tpm_info;
74 struct tpm_i2c_cr50_priv_data *priv = dev_get_drvdata(&chip->dev);
75
76 complete(&priv->tpm_ready);
77
78 return IRQ_HANDLED;
79 }
80
81 /**
82 * tpm_cr50_i2c_wait_tpm_ready() - Wait for tpm to signal ready.
83 * @chip: A TPM chip.
84 *
85 * Wait for completion interrupt if available, otherwise use a fixed
86 * delay for the TPM to be ready.
87 *
88 * Return:
89 * - 0: Success.
90 * - -errno: A POSIX error code.
91 */
tpm_cr50_i2c_wait_tpm_ready(struct tpm_chip * chip)92 static int tpm_cr50_i2c_wait_tpm_ready(struct tpm_chip *chip)
93 {
94 struct tpm_i2c_cr50_priv_data *priv = dev_get_drvdata(&chip->dev);
95
96 /* Use a safe fixed delay if interrupt is not supported */
97 if (priv->irq <= 0) {
98 msleep(TPM_CR50_TIMEOUT_NOIRQ_MS);
99 return 0;
100 }
101
102 /* Wait for interrupt to indicate TPM is ready to respond */
103 if (!wait_for_completion_timeout(&priv->tpm_ready, chip->timeout_a)) {
104 dev_warn(&chip->dev, "Timeout waiting for TPM ready\n");
105 return -ETIMEDOUT;
106 }
107
108 return 0;
109 }
110
111 /**
112 * tpm_cr50_i2c_enable_tpm_irq() - Enable TPM irq.
113 * @chip: A TPM chip.
114 */
tpm_cr50_i2c_enable_tpm_irq(struct tpm_chip * chip)115 static void tpm_cr50_i2c_enable_tpm_irq(struct tpm_chip *chip)
116 {
117 struct tpm_i2c_cr50_priv_data *priv = dev_get_drvdata(&chip->dev);
118
119 if (priv->irq > 0) {
120 reinit_completion(&priv->tpm_ready);
121 enable_irq(priv->irq);
122 }
123 }
124
125 /**
126 * tpm_cr50_i2c_disable_tpm_irq() - Disable TPM irq.
127 * @chip: A TPM chip.
128 */
tpm_cr50_i2c_disable_tpm_irq(struct tpm_chip * chip)129 static void tpm_cr50_i2c_disable_tpm_irq(struct tpm_chip *chip)
130 {
131 struct tpm_i2c_cr50_priv_data *priv = dev_get_drvdata(&chip->dev);
132
133 if (priv->irq > 0)
134 disable_irq(priv->irq);
135 }
136
137 /**
138 * tpm_cr50_i2c_transfer_message() - Transfer a message over i2c.
139 * @dev: Device information.
140 * @adapter: I2C adapter.
141 * @msg: Message to transfer.
142 *
143 * Call unlocked i2c transfer routine with the provided parameters and
144 * retry in case of bus errors.
145 *
146 * Return:
147 * - 0: Success.
148 * - -errno: A POSIX error code.
149 */
tpm_cr50_i2c_transfer_message(struct device * dev,struct i2c_adapter * adapter,struct i2c_msg * msg)150 static int tpm_cr50_i2c_transfer_message(struct device *dev,
151 struct i2c_adapter *adapter,
152 struct i2c_msg *msg)
153 {
154 unsigned int try;
155 int rc;
156
157 for (try = 0; try < TPM_CR50_I2C_MAX_RETRIES; try++) {
158 rc = __i2c_transfer(adapter, msg, 1);
159 if (rc == 1)
160 return 0; /* Successfully transferred the message */
161 if (try)
162 dev_warn(dev, "i2c transfer failed (attempt %d/%d): %d\n",
163 try + 1, TPM_CR50_I2C_MAX_RETRIES, rc);
164 usleep_range(TPM_CR50_I2C_RETRY_DELAY_LO, TPM_CR50_I2C_RETRY_DELAY_HI);
165 }
166
167 /* No i2c message transferred */
168 return -EIO;
169 }
170
171 /**
172 * tpm_cr50_i2c_read() - Read from TPM register.
173 * @chip: A TPM chip.
174 * @addr: Register address to read from.
175 * @buffer: Read destination, provided by caller.
176 * @len: Number of bytes to read.
177 *
178 * Sends the register address byte to the TPM, then waits until TPM
179 * is ready via interrupt signal or timeout expiration, then 'len'
180 * bytes are read from TPM response into the provided 'buffer'.
181 *
182 * Return:
183 * - 0: Success.
184 * - -errno: A POSIX error code.
185 */
tpm_cr50_i2c_read(struct tpm_chip * chip,u8 addr,u8 * buffer,size_t len)186 static int tpm_cr50_i2c_read(struct tpm_chip *chip, u8 addr, u8 *buffer, size_t len)
187 {
188 struct i2c_client *client = to_i2c_client(chip->dev.parent);
189 struct i2c_msg msg_reg_addr = {
190 .addr = client->addr,
191 .len = 1,
192 .buf = &addr
193 };
194 struct i2c_msg msg_response = {
195 .addr = client->addr,
196 .flags = I2C_M_RD,
197 .len = len,
198 .buf = buffer
199 };
200 int rc;
201
202 i2c_lock_bus(client->adapter, I2C_LOCK_SEGMENT);
203
204 /* Prepare for completion interrupt */
205 tpm_cr50_i2c_enable_tpm_irq(chip);
206
207 /* Send the register address byte to the TPM */
208 rc = tpm_cr50_i2c_transfer_message(&chip->dev, client->adapter, &msg_reg_addr);
209 if (rc < 0)
210 goto out;
211
212 /* Wait for TPM to be ready with response data */
213 rc = tpm_cr50_i2c_wait_tpm_ready(chip);
214 if (rc < 0)
215 goto out;
216
217 /* Read response data from the TPM */
218 rc = tpm_cr50_i2c_transfer_message(&chip->dev, client->adapter, &msg_response);
219
220 out:
221 tpm_cr50_i2c_disable_tpm_irq(chip);
222 i2c_unlock_bus(client->adapter, I2C_LOCK_SEGMENT);
223
224 if (rc < 0)
225 return rc;
226
227 return 0;
228 }
229
230 /**
231 * tpm_cr50_i2c_write()- Write to TPM register.
232 * @chip: A TPM chip.
233 * @addr: Register address to write to.
234 * @buffer: Data to write.
235 * @len: Number of bytes to write.
236 *
237 * The provided address is prepended to the data in 'buffer', the
238 * combined address+data is sent to the TPM, then wait for TPM to
239 * indicate it is done writing.
240 *
241 * Return:
242 * - 0: Success.
243 * - -errno: A POSIX error code.
244 */
tpm_cr50_i2c_write(struct tpm_chip * chip,u8 addr,u8 * buffer,size_t len)245 static int tpm_cr50_i2c_write(struct tpm_chip *chip, u8 addr, u8 *buffer,
246 size_t len)
247 {
248 struct tpm_i2c_cr50_priv_data *priv = dev_get_drvdata(&chip->dev);
249 struct i2c_client *client = to_i2c_client(chip->dev.parent);
250 struct i2c_msg msg = {
251 .addr = client->addr,
252 .len = len + 1,
253 .buf = priv->buf
254 };
255 int rc;
256
257 if (len > TPM_CR50_MAX_BUFSIZE - 1)
258 return -EINVAL;
259
260 /* Prepend the 'register address' to the buffer */
261 priv->buf[0] = addr;
262 memcpy(priv->buf + 1, buffer, len);
263
264 i2c_lock_bus(client->adapter, I2C_LOCK_SEGMENT);
265
266 /* Prepare for completion interrupt */
267 tpm_cr50_i2c_enable_tpm_irq(chip);
268
269 /* Send write request buffer with address */
270 rc = tpm_cr50_i2c_transfer_message(&chip->dev, client->adapter, &msg);
271 if (rc < 0)
272 goto out;
273
274 /* Wait for TPM to be ready, ignore timeout */
275 tpm_cr50_i2c_wait_tpm_ready(chip);
276
277 out:
278 tpm_cr50_i2c_disable_tpm_irq(chip);
279 i2c_unlock_bus(client->adapter, I2C_LOCK_SEGMENT);
280
281 if (rc < 0)
282 return rc;
283
284 return 0;
285 }
286
287 /**
288 * tpm_cr50_check_locality() - Verify TPM locality 0 is active.
289 * @chip: A TPM chip.
290 *
291 * Return:
292 * - 0: Success.
293 * - -errno: A POSIX error code.
294 */
tpm_cr50_check_locality(struct tpm_chip * chip)295 static int tpm_cr50_check_locality(struct tpm_chip *chip)
296 {
297 u8 mask = TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY;
298 u8 buf;
299 int rc;
300
301 rc = tpm_cr50_i2c_read(chip, TPM_I2C_ACCESS(0), &buf, sizeof(buf));
302 if (rc < 0)
303 return rc;
304
305 if ((buf & mask) == mask)
306 return 0;
307
308 return -EIO;
309 }
310
311 /**
312 * tpm_cr50_release_locality() - Release TPM locality.
313 * @chip: A TPM chip.
314 * @force: Flag to force release if set.
315 */
tpm_cr50_release_locality(struct tpm_chip * chip,bool force)316 static void tpm_cr50_release_locality(struct tpm_chip *chip, bool force)
317 {
318 u8 mask = TPM_ACCESS_VALID | TPM_ACCESS_REQUEST_PENDING;
319 u8 addr = TPM_I2C_ACCESS(0);
320 u8 buf;
321
322 if (tpm_cr50_i2c_read(chip, addr, &buf, sizeof(buf)) < 0)
323 return;
324
325 if (force || (buf & mask) == mask) {
326 buf = TPM_ACCESS_ACTIVE_LOCALITY;
327 tpm_cr50_i2c_write(chip, addr, &buf, sizeof(buf));
328 }
329 }
330
331 /**
332 * tpm_cr50_request_locality() - Request TPM locality 0.
333 * @chip: A TPM chip.
334 *
335 * Return:
336 * - 0: Success.
337 * - -errno: A POSIX error code.
338 */
tpm_cr50_request_locality(struct tpm_chip * chip)339 static int tpm_cr50_request_locality(struct tpm_chip *chip)
340 {
341 u8 buf = TPM_ACCESS_REQUEST_USE;
342 unsigned long stop;
343 int rc;
344
345 if (!tpm_cr50_check_locality(chip))
346 return 0;
347
348 rc = tpm_cr50_i2c_write(chip, TPM_I2C_ACCESS(0), &buf, sizeof(buf));
349 if (rc < 0)
350 return rc;
351
352 stop = jiffies + chip->timeout_a;
353 do {
354 if (!tpm_cr50_check_locality(chip))
355 return 0;
356
357 msleep(TPM_CR50_TIMEOUT_SHORT_MS);
358 } while (time_before(jiffies, stop));
359
360 return -ETIMEDOUT;
361 }
362
363 /**
364 * tpm_cr50_i2c_tis_status() - Read cr50 tis status.
365 * @chip: A TPM chip.
366 *
367 * cr50 requires all 4 bytes of status register to be read.
368 *
369 * Return:
370 * TPM status byte.
371 */
tpm_cr50_i2c_tis_status(struct tpm_chip * chip)372 static u8 tpm_cr50_i2c_tis_status(struct tpm_chip *chip)
373 {
374 u8 buf[4];
375
376 if (tpm_cr50_i2c_read(chip, TPM_I2C_STS(0), buf, sizeof(buf)) < 0)
377 return 0;
378
379 return buf[0];
380 }
381
382 /**
383 * tpm_cr50_i2c_tis_set_ready() - Set status register to ready.
384 * @chip: A TPM chip.
385 *
386 * cr50 requires all 4 bytes of status register to be written.
387 */
tpm_cr50_i2c_tis_set_ready(struct tpm_chip * chip)388 static void tpm_cr50_i2c_tis_set_ready(struct tpm_chip *chip)
389 {
390 u8 buf[4] = { TPM_STS_COMMAND_READY };
391
392 tpm_cr50_i2c_write(chip, TPM_I2C_STS(0), buf, sizeof(buf));
393 msleep(TPM_CR50_TIMEOUT_SHORT_MS);
394 }
395
396 /**
397 * tpm_cr50_i2c_get_burst_and_status() - Get burst count and status.
398 * @chip: A TPM chip.
399 * @mask: Status mask.
400 * @burst: Return value for burst.
401 * @status: Return value for status.
402 *
403 * cr50 uses bytes 3:2 of status register for burst count and
404 * all 4 bytes must be read.
405 *
406 * Return:
407 * - 0: Success.
408 * - -errno: A POSIX error code.
409 */
tpm_cr50_i2c_get_burst_and_status(struct tpm_chip * chip,u8 mask,size_t * burst,u32 * status)410 static int tpm_cr50_i2c_get_burst_and_status(struct tpm_chip *chip, u8 mask,
411 size_t *burst, u32 *status)
412 {
413 unsigned long stop;
414 u8 buf[4];
415
416 *status = 0;
417
418 /* wait for burstcount */
419 stop = jiffies + chip->timeout_b;
420
421 do {
422 if (tpm_cr50_i2c_read(chip, TPM_I2C_STS(0), buf, sizeof(buf)) < 0) {
423 msleep(TPM_CR50_TIMEOUT_SHORT_MS);
424 continue;
425 }
426
427 *status = *buf;
428 *burst = le16_to_cpup((__le16 *)(buf + 1));
429
430 if ((*status & mask) == mask &&
431 *burst > 0 && *burst <= TPM_CR50_MAX_BUFSIZE - 1)
432 return 0;
433
434 msleep(TPM_CR50_TIMEOUT_SHORT_MS);
435 } while (time_before(jiffies, stop));
436
437 dev_err(&chip->dev, "Timeout reading burst and status\n");
438 return -ETIMEDOUT;
439 }
440
441 /**
442 * tpm_cr50_i2c_tis_recv() - TPM reception callback.
443 * @chip: A TPM chip.
444 * @buf: Reception buffer.
445 * @buf_len: Buffer length to read.
446 *
447 * Return:
448 * - >= 0: Number of read bytes.
449 * - -errno: A POSIX error code.
450 */
tpm_cr50_i2c_tis_recv(struct tpm_chip * chip,u8 * buf,size_t buf_len)451 static int tpm_cr50_i2c_tis_recv(struct tpm_chip *chip, u8 *buf, size_t buf_len)
452 {
453
454 u8 mask = TPM_STS_VALID | TPM_STS_DATA_AVAIL;
455 size_t burstcnt, cur, len, expected;
456 u8 addr = TPM_I2C_DATA_FIFO(0);
457 u32 status;
458 int rc;
459
460 if (buf_len < TPM_HEADER_SIZE)
461 return -EINVAL;
462
463 rc = tpm_cr50_i2c_get_burst_and_status(chip, mask, &burstcnt, &status);
464 if (rc < 0)
465 goto out_err;
466
467 if (burstcnt > buf_len || burstcnt < TPM_HEADER_SIZE) {
468 dev_err(&chip->dev,
469 "Unexpected burstcnt: %zu (max=%zu, min=%d)\n",
470 burstcnt, buf_len, TPM_HEADER_SIZE);
471 rc = -EIO;
472 goto out_err;
473 }
474
475 /* Read first chunk of burstcnt bytes */
476 rc = tpm_cr50_i2c_read(chip, addr, buf, burstcnt);
477 if (rc < 0) {
478 dev_err(&chip->dev, "Read of first chunk failed\n");
479 goto out_err;
480 }
481
482 /* Determine expected data in the return buffer */
483 expected = be32_to_cpup((__be32 *)(buf + 2));
484 if (expected > buf_len) {
485 dev_err(&chip->dev, "Buffer too small to receive i2c data\n");
486 rc = -E2BIG;
487 goto out_err;
488 }
489
490 /* Now read the rest of the data */
491 cur = burstcnt;
492 while (cur < expected) {
493 /* Read updated burst count and check status */
494 rc = tpm_cr50_i2c_get_burst_and_status(chip, mask, &burstcnt, &status);
495 if (rc < 0)
496 goto out_err;
497
498 len = min_t(size_t, burstcnt, expected - cur);
499 rc = tpm_cr50_i2c_read(chip, addr, buf + cur, len);
500 if (rc < 0) {
501 dev_err(&chip->dev, "Read failed\n");
502 goto out_err;
503 }
504
505 cur += len;
506 }
507
508 /* Ensure TPM is done reading data */
509 rc = tpm_cr50_i2c_get_burst_and_status(chip, TPM_STS_VALID, &burstcnt, &status);
510 if (rc < 0)
511 goto out_err;
512 if (status & TPM_STS_DATA_AVAIL) {
513 dev_err(&chip->dev, "Data still available\n");
514 rc = -EIO;
515 goto out_err;
516 }
517
518 tpm_cr50_release_locality(chip, false);
519 return cur;
520
521 out_err:
522 /* Abort current transaction if still pending */
523 if (tpm_cr50_i2c_tis_status(chip) & TPM_STS_COMMAND_READY)
524 tpm_cr50_i2c_tis_set_ready(chip);
525
526 tpm_cr50_release_locality(chip, false);
527 return rc;
528 }
529
530 /**
531 * tpm_cr50_i2c_tis_send() - TPM transmission callback.
532 * @chip: A TPM chip.
533 * @buf: Buffer to send.
534 * @len: Buffer length.
535 *
536 * Return:
537 * - 0: Success.
538 * - -errno: A POSIX error code.
539 */
tpm_cr50_i2c_tis_send(struct tpm_chip * chip,u8 * buf,size_t len)540 static int tpm_cr50_i2c_tis_send(struct tpm_chip *chip, u8 *buf, size_t len)
541 {
542 size_t burstcnt, limit, sent = 0;
543 u8 tpm_go[4] = { TPM_STS_GO };
544 unsigned long stop;
545 u32 status;
546 int rc;
547
548 rc = tpm_cr50_request_locality(chip);
549 if (rc < 0)
550 return rc;
551
552 /* Wait until TPM is ready for a command */
553 stop = jiffies + chip->timeout_b;
554 while (!(tpm_cr50_i2c_tis_status(chip) & TPM_STS_COMMAND_READY)) {
555 if (time_after(jiffies, stop)) {
556 rc = -ETIMEDOUT;
557 goto out_err;
558 }
559
560 tpm_cr50_i2c_tis_set_ready(chip);
561 }
562
563 while (len > 0) {
564 u8 mask = TPM_STS_VALID;
565
566 /* Wait for data if this is not the first chunk */
567 if (sent > 0)
568 mask |= TPM_STS_DATA_EXPECT;
569
570 /* Read burst count and check status */
571 rc = tpm_cr50_i2c_get_burst_and_status(chip, mask, &burstcnt, &status);
572 if (rc < 0)
573 goto out_err;
574
575 /*
576 * Use burstcnt - 1 to account for the address byte
577 * that is inserted by tpm_cr50_i2c_write()
578 */
579 limit = min_t(size_t, burstcnt - 1, len);
580 rc = tpm_cr50_i2c_write(chip, TPM_I2C_DATA_FIFO(0), &buf[sent], limit);
581 if (rc < 0) {
582 dev_err(&chip->dev, "Write failed\n");
583 goto out_err;
584 }
585
586 sent += limit;
587 len -= limit;
588 }
589
590 /* Ensure TPM is not expecting more data */
591 rc = tpm_cr50_i2c_get_burst_and_status(chip, TPM_STS_VALID, &burstcnt, &status);
592 if (rc < 0)
593 goto out_err;
594 if (status & TPM_STS_DATA_EXPECT) {
595 dev_err(&chip->dev, "Data still expected\n");
596 rc = -EIO;
597 goto out_err;
598 }
599
600 /* Start the TPM command */
601 rc = tpm_cr50_i2c_write(chip, TPM_I2C_STS(0), tpm_go,
602 sizeof(tpm_go));
603 if (rc < 0) {
604 dev_err(&chip->dev, "Start command failed\n");
605 goto out_err;
606 }
607 return 0;
608
609 out_err:
610 /* Abort current transaction if still pending */
611 if (tpm_cr50_i2c_tis_status(chip) & TPM_STS_COMMAND_READY)
612 tpm_cr50_i2c_tis_set_ready(chip);
613
614 tpm_cr50_release_locality(chip, false);
615 return rc;
616 }
617
618 /**
619 * tpm_cr50_i2c_req_canceled() - Callback to notify a request cancel.
620 * @chip: A TPM chip.
621 * @status: Status given by the cancel callback.
622 *
623 * Return:
624 * True if command is ready, False otherwise.
625 */
tpm_cr50_i2c_req_canceled(struct tpm_chip * chip,u8 status)626 static bool tpm_cr50_i2c_req_canceled(struct tpm_chip *chip, u8 status)
627 {
628 return status == TPM_STS_COMMAND_READY;
629 }
630
tpm_cr50_i2c_is_firmware_power_managed(struct device * dev)631 static bool tpm_cr50_i2c_is_firmware_power_managed(struct device *dev)
632 {
633 u8 val;
634 int ret;
635
636 /* This flag should default true when the device property is not present */
637 ret = device_property_read_u8(dev, "firmware-power-managed", &val);
638 if (ret)
639 return true;
640
641 return val;
642 }
643
644 static const struct tpm_class_ops cr50_i2c = {
645 .flags = TPM_OPS_AUTO_STARTUP,
646 .status = &tpm_cr50_i2c_tis_status,
647 .recv = &tpm_cr50_i2c_tis_recv,
648 .send = &tpm_cr50_i2c_tis_send,
649 .cancel = &tpm_cr50_i2c_tis_set_ready,
650 .req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
651 .req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
652 .req_canceled = &tpm_cr50_i2c_req_canceled,
653 };
654
655 #ifdef CONFIG_ACPI
656 static const struct acpi_device_id cr50_i2c_acpi_id[] = {
657 { "GOOG0005", 0 },
658 {}
659 };
660 MODULE_DEVICE_TABLE(acpi, cr50_i2c_acpi_id);
661 #endif
662
663 #ifdef CONFIG_OF
664 static const struct of_device_id of_cr50_i2c_match[] = {
665 { .compatible = "google,cr50", },
666 {}
667 };
668 MODULE_DEVICE_TABLE(of, of_cr50_i2c_match);
669 #endif
670
671 /**
672 * tpm_cr50_i2c_probe() - Driver probe function.
673 * @client: I2C client information.
674 *
675 * Return:
676 * - 0: Success.
677 * - -errno: A POSIX error code.
678 */
tpm_cr50_i2c_probe(struct i2c_client * client)679 static int tpm_cr50_i2c_probe(struct i2c_client *client)
680 {
681 struct tpm_i2c_cr50_priv_data *priv;
682 struct device *dev = &client->dev;
683 struct tpm_chip *chip;
684 u32 vendor;
685 u8 buf[4];
686 int rc;
687
688 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
689 return -ENODEV;
690
691 chip = tpmm_chip_alloc(dev, &cr50_i2c);
692 if (IS_ERR(chip))
693 return PTR_ERR(chip);
694
695 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
696 if (!priv)
697 return -ENOMEM;
698
699 /* cr50 is a TPM 2.0 chip */
700 chip->flags |= TPM_CHIP_FLAG_TPM2;
701 if (tpm_cr50_i2c_is_firmware_power_managed(dev))
702 chip->flags |= TPM_CHIP_FLAG_FIRMWARE_POWER_MANAGED;
703
704 /* Default timeouts */
705 chip->timeout_a = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
706 chip->timeout_b = msecs_to_jiffies(TIS_LONG_TIMEOUT);
707 chip->timeout_c = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
708 chip->timeout_d = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
709
710 dev_set_drvdata(&chip->dev, priv);
711 init_completion(&priv->tpm_ready);
712
713 if (client->irq > 0) {
714 rc = devm_request_irq(dev, client->irq, tpm_cr50_i2c_int_handler,
715 IRQF_TRIGGER_FALLING | IRQF_ONESHOT |
716 IRQF_NO_AUTOEN,
717 dev->driver->name, chip);
718 if (rc < 0) {
719 dev_err(dev, "Failed to probe IRQ %d\n", client->irq);
720 return rc;
721 }
722
723 priv->irq = client->irq;
724 } else {
725 dev_warn(dev, "No IRQ, will use %ums delay for TPM ready\n",
726 TPM_CR50_TIMEOUT_NOIRQ_MS);
727 }
728
729 rc = tpm_cr50_request_locality(chip);
730 if (rc < 0) {
731 dev_err(dev, "Could not request locality\n");
732 return rc;
733 }
734
735 /* Read four bytes from DID_VID register */
736 rc = tpm_cr50_i2c_read(chip, TPM_I2C_DID_VID(0), buf, sizeof(buf));
737 if (rc < 0) {
738 dev_err(dev, "Could not read vendor id\n");
739 tpm_cr50_release_locality(chip, true);
740 return rc;
741 }
742
743 vendor = le32_to_cpup((__le32 *)buf);
744 if (vendor != TPM_CR50_I2C_DID_VID && vendor != TPM_TI50_I2C_DID_VID) {
745 dev_err(dev, "Vendor ID did not match! ID was %08x\n", vendor);
746 tpm_cr50_release_locality(chip, true);
747 return -ENODEV;
748 }
749
750 dev_info(dev, "%s TPM 2.0 (i2c 0x%02x irq %d id 0x%x)\n",
751 vendor == TPM_TI50_I2C_DID_VID ? "ti50" : "cr50",
752 client->addr, client->irq, vendor >> 16);
753 return tpm_chip_register(chip);
754 }
755
756 /**
757 * tpm_cr50_i2c_remove() - Driver remove function.
758 * @client: I2C client information.
759 *
760 * Return:
761 * - 0: Success.
762 * - -errno: A POSIX error code.
763 */
tpm_cr50_i2c_remove(struct i2c_client * client)764 static void tpm_cr50_i2c_remove(struct i2c_client *client)
765 {
766 struct tpm_chip *chip = i2c_get_clientdata(client);
767 struct device *dev = &client->dev;
768
769 if (!chip) {
770 dev_crit(dev, "Could not get client data at remove, memory corruption ahead\n");
771 return;
772 }
773
774 tpm_chip_unregister(chip);
775 tpm_cr50_release_locality(chip, true);
776 }
777
778 static SIMPLE_DEV_PM_OPS(cr50_i2c_pm, tpm_pm_suspend, tpm_pm_resume);
779
780 static struct i2c_driver cr50_i2c_driver = {
781 .probe = tpm_cr50_i2c_probe,
782 .remove = tpm_cr50_i2c_remove,
783 .driver = {
784 .name = "cr50_i2c",
785 .pm = &cr50_i2c_pm,
786 .acpi_match_table = ACPI_PTR(cr50_i2c_acpi_id),
787 .of_match_table = of_match_ptr(of_cr50_i2c_match),
788 },
789 };
790
791 module_i2c_driver(cr50_i2c_driver);
792
793 MODULE_DESCRIPTION("cr50 TPM I2C Driver");
794 MODULE_LICENSE("GPL");
795