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  */
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  */
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  */
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  */
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  */
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  */
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  * cobined 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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
626 static bool tpm_cr50_i2c_req_canceled(struct tpm_chip *chip, u8 status)
627 {
628 	return status == TPM_STS_COMMAND_READY;
629 }
630 
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  * @id:		I2C device id.
675  *
676  * Return:
677  * - 0:		Success.
678  * - -errno:	A POSIX error code.
679  */
680 static int tpm_cr50_i2c_probe(struct i2c_client *client)
681 {
682 	struct tpm_i2c_cr50_priv_data *priv;
683 	struct device *dev = &client->dev;
684 	struct tpm_chip *chip;
685 	u32 vendor;
686 	u8 buf[4];
687 	int rc;
688 
689 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
690 		return -ENODEV;
691 
692 	chip = tpmm_chip_alloc(dev, &cr50_i2c);
693 	if (IS_ERR(chip))
694 		return PTR_ERR(chip);
695 
696 	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
697 	if (!priv)
698 		return -ENOMEM;
699 
700 	/* cr50 is a TPM 2.0 chip */
701 	chip->flags |= TPM_CHIP_FLAG_TPM2;
702 	if (tpm_cr50_i2c_is_firmware_power_managed(dev))
703 		chip->flags |= TPM_CHIP_FLAG_FIRMWARE_POWER_MANAGED;
704 
705 	/* Default timeouts */
706 	chip->timeout_a = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
707 	chip->timeout_b = msecs_to_jiffies(TIS_LONG_TIMEOUT);
708 	chip->timeout_c = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
709 	chip->timeout_d = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
710 
711 	dev_set_drvdata(&chip->dev, priv);
712 	init_completion(&priv->tpm_ready);
713 
714 	if (client->irq > 0) {
715 		rc = devm_request_irq(dev, client->irq, tpm_cr50_i2c_int_handler,
716 				      IRQF_TRIGGER_FALLING | IRQF_ONESHOT |
717 				      IRQF_NO_AUTOEN,
718 				      dev->driver->name, chip);
719 		if (rc < 0) {
720 			dev_err(dev, "Failed to probe IRQ %d\n", client->irq);
721 			return rc;
722 		}
723 
724 		priv->irq = client->irq;
725 	} else {
726 		dev_warn(dev, "No IRQ, will use %ums delay for TPM ready\n",
727 			 TPM_CR50_TIMEOUT_NOIRQ_MS);
728 	}
729 
730 	rc = tpm_cr50_request_locality(chip);
731 	if (rc < 0) {
732 		dev_err(dev, "Could not request locality\n");
733 		return rc;
734 	}
735 
736 	/* Read four bytes from DID_VID register */
737 	rc = tpm_cr50_i2c_read(chip, TPM_I2C_DID_VID(0), buf, sizeof(buf));
738 	if (rc < 0) {
739 		dev_err(dev, "Could not read vendor id\n");
740 		tpm_cr50_release_locality(chip, true);
741 		return rc;
742 	}
743 
744 	vendor = le32_to_cpup((__le32 *)buf);
745 	if (vendor != TPM_CR50_I2C_DID_VID && vendor != TPM_TI50_I2C_DID_VID) {
746 		dev_err(dev, "Vendor ID did not match! ID was %08x\n", vendor);
747 		tpm_cr50_release_locality(chip, true);
748 		return -ENODEV;
749 	}
750 
751 	dev_info(dev, "%s TPM 2.0 (i2c 0x%02x irq %d id 0x%x)\n",
752 		 vendor == TPM_TI50_I2C_DID_VID ? "ti50" : "cr50",
753 		 client->addr, client->irq, vendor >> 16);
754 	return tpm_chip_register(chip);
755 }
756 
757 /**
758  * tpm_cr50_i2c_remove() - Driver remove function.
759  * @client: I2C client information.
760  *
761  * Return:
762  * - 0:		Success.
763  * - -errno:	A POSIX error code.
764  */
765 static void tpm_cr50_i2c_remove(struct i2c_client *client)
766 {
767 	struct tpm_chip *chip = i2c_get_clientdata(client);
768 	struct device *dev = &client->dev;
769 
770 	if (!chip) {
771 		dev_crit(dev, "Could not get client data at remove, memory corruption ahead\n");
772 		return;
773 	}
774 
775 	tpm_chip_unregister(chip);
776 	tpm_cr50_release_locality(chip, true);
777 }
778 
779 static SIMPLE_DEV_PM_OPS(cr50_i2c_pm, tpm_pm_suspend, tpm_pm_resume);
780 
781 static struct i2c_driver cr50_i2c_driver = {
782 	.probe = tpm_cr50_i2c_probe,
783 	.remove = tpm_cr50_i2c_remove,
784 	.driver = {
785 		.name = "cr50_i2c",
786 		.pm = &cr50_i2c_pm,
787 		.acpi_match_table = ACPI_PTR(cr50_i2c_acpi_id),
788 		.of_match_table = of_match_ptr(of_cr50_i2c_match),
789 	},
790 };
791 
792 module_i2c_driver(cr50_i2c_driver);
793 
794 MODULE_DESCRIPTION("cr50 TPM I2C Driver");
795 MODULE_LICENSE("GPL");
796