1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * STMicroelectronics TPM Linux driver for TPM ST33ZP24
4  * Copyright (C) 2009 - 2016 STMicroelectronics
5  */
6 
7 #include <linux/acpi.h>
8 #include <linux/module.h>
9 #include <linux/fs.h>
10 #include <linux/kernel.h>
11 #include <linux/delay.h>
12 #include <linux/wait.h>
13 #include <linux/freezer.h>
14 #include <linux/string.h>
15 #include <linux/interrupt.h>
16 #include <linux/gpio/consumer.h>
17 #include <linux/sched.h>
18 #include <linux/uaccess.h>
19 #include <linux/io.h>
20 #include <linux/slab.h>
21 
22 #include "../tpm.h"
23 #include "st33zp24.h"
24 
25 #define TPM_ACCESS			0x0
26 #define TPM_STS				0x18
27 #define TPM_DATA_FIFO			0x24
28 #define TPM_INTF_CAPABILITY		0x14
29 #define TPM_INT_STATUS			0x10
30 #define TPM_INT_ENABLE			0x08
31 
32 #define LOCALITY0			0
33 
34 enum st33zp24_access {
35 	TPM_ACCESS_VALID = 0x80,
36 	TPM_ACCESS_ACTIVE_LOCALITY = 0x20,
37 	TPM_ACCESS_REQUEST_PENDING = 0x04,
38 	TPM_ACCESS_REQUEST_USE = 0x02,
39 };
40 
41 enum st33zp24_status {
42 	TPM_STS_VALID = 0x80,
43 	TPM_STS_COMMAND_READY = 0x40,
44 	TPM_STS_GO = 0x20,
45 	TPM_STS_DATA_AVAIL = 0x10,
46 	TPM_STS_DATA_EXPECT = 0x08,
47 };
48 
49 enum st33zp24_int_flags {
50 	TPM_GLOBAL_INT_ENABLE = 0x80,
51 	TPM_INTF_CMD_READY_INT = 0x080,
52 	TPM_INTF_FIFO_AVALAIBLE_INT = 0x040,
53 	TPM_INTF_WAKE_UP_READY_INT = 0x020,
54 	TPM_INTF_LOCALITY_CHANGE_INT = 0x004,
55 	TPM_INTF_STS_VALID_INT = 0x002,
56 	TPM_INTF_DATA_AVAIL_INT = 0x001,
57 };
58 
59 enum tis_defaults {
60 	TIS_SHORT_TIMEOUT = 750,
61 	TIS_LONG_TIMEOUT = 2000,
62 };
63 
64 /*
65  * clear the pending interrupt.
66  */
67 static u8 clear_interruption(struct st33zp24_dev *tpm_dev)
68 {
69 	u8 interrupt;
70 
71 	tpm_dev->ops->recv(tpm_dev->phy_id, TPM_INT_STATUS, &interrupt, 1);
72 	tpm_dev->ops->send(tpm_dev->phy_id, TPM_INT_STATUS, &interrupt, 1);
73 	return interrupt;
74 }
75 
76 /*
77  * cancel the current command execution or set STS to COMMAND READY.
78  */
79 static void st33zp24_cancel(struct tpm_chip *chip)
80 {
81 	struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev);
82 	u8 data;
83 
84 	data = TPM_STS_COMMAND_READY;
85 	tpm_dev->ops->send(tpm_dev->phy_id, TPM_STS, &data, 1);
86 }
87 
88 /*
89  * return the TPM_STS register
90  */
91 static u8 st33zp24_status(struct tpm_chip *chip)
92 {
93 	struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev);
94 	u8 data;
95 
96 	tpm_dev->ops->recv(tpm_dev->phy_id, TPM_STS, &data, 1);
97 	return data;
98 }
99 
100 /*
101  * if the locality is active
102  */
103 static bool check_locality(struct tpm_chip *chip)
104 {
105 	struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev);
106 	u8 data;
107 	u8 status;
108 
109 	status = tpm_dev->ops->recv(tpm_dev->phy_id, TPM_ACCESS, &data, 1);
110 	if (status && (data &
111 		(TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) ==
112 		(TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID))
113 		return true;
114 
115 	return false;
116 }
117 
118 static int request_locality(struct tpm_chip *chip)
119 {
120 	struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev);
121 	unsigned long stop;
122 	long ret;
123 	u8 data;
124 
125 	if (check_locality(chip))
126 		return tpm_dev->locality;
127 
128 	data = TPM_ACCESS_REQUEST_USE;
129 	ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_ACCESS, &data, 1);
130 	if (ret < 0)
131 		return ret;
132 
133 	stop = jiffies + chip->timeout_a;
134 
135 	/* Request locality is usually effective after the request */
136 	do {
137 		if (check_locality(chip))
138 			return tpm_dev->locality;
139 		msleep(TPM_TIMEOUT);
140 	} while (time_before(jiffies, stop));
141 
142 	/* could not get locality */
143 	return -EACCES;
144 }
145 
146 static void release_locality(struct tpm_chip *chip)
147 {
148 	struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev);
149 	u8 data;
150 
151 	data = TPM_ACCESS_ACTIVE_LOCALITY;
152 
153 	tpm_dev->ops->send(tpm_dev->phy_id, TPM_ACCESS, &data, 1);
154 }
155 
156 /*
157  * get_burstcount return the burstcount value
158  */
159 static int get_burstcount(struct tpm_chip *chip)
160 {
161 	struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev);
162 	unsigned long stop;
163 	int burstcnt, status;
164 	u8 temp;
165 
166 	stop = jiffies + chip->timeout_d;
167 	do {
168 		status = tpm_dev->ops->recv(tpm_dev->phy_id, TPM_STS + 1,
169 					    &temp, 1);
170 		if (status < 0)
171 			return -EBUSY;
172 
173 		burstcnt = temp;
174 		status = tpm_dev->ops->recv(tpm_dev->phy_id, TPM_STS + 2,
175 					    &temp, 1);
176 		if (status < 0)
177 			return -EBUSY;
178 
179 		burstcnt |= temp << 8;
180 		if (burstcnt)
181 			return burstcnt;
182 		msleep(TPM_TIMEOUT);
183 	} while (time_before(jiffies, stop));
184 	return -EBUSY;
185 }
186 
187 static bool wait_for_tpm_stat_cond(struct tpm_chip *chip, u8 mask,
188 				bool check_cancel, bool *canceled)
189 {
190 	u8 status = chip->ops->status(chip);
191 
192 	*canceled = false;
193 	if ((status & mask) == mask)
194 		return true;
195 	if (check_cancel && chip->ops->req_canceled(chip, status)) {
196 		*canceled = true;
197 		return true;
198 	}
199 	return false;
200 }
201 
202 /*
203  * wait for a TPM_STS value
204  */
205 static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout,
206 			wait_queue_head_t *queue, bool check_cancel)
207 {
208 	struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev);
209 	unsigned long stop;
210 	int ret = 0;
211 	bool canceled = false;
212 	bool condition;
213 	u32 cur_intrs;
214 	u8 status;
215 
216 	/* check current status */
217 	status = st33zp24_status(chip);
218 	if ((status & mask) == mask)
219 		return 0;
220 
221 	stop = jiffies + timeout;
222 
223 	if (chip->flags & TPM_CHIP_FLAG_IRQ) {
224 		cur_intrs = tpm_dev->intrs;
225 		clear_interruption(tpm_dev);
226 		enable_irq(tpm_dev->irq);
227 
228 		do {
229 			if (ret == -ERESTARTSYS && freezing(current))
230 				clear_thread_flag(TIF_SIGPENDING);
231 
232 			timeout = stop - jiffies;
233 			if ((long) timeout <= 0)
234 				return -1;
235 
236 			ret = wait_event_interruptible_timeout(*queue,
237 						cur_intrs != tpm_dev->intrs,
238 						timeout);
239 			clear_interruption(tpm_dev);
240 			condition = wait_for_tpm_stat_cond(chip, mask,
241 						check_cancel, &canceled);
242 			if (ret >= 0 && condition) {
243 				if (canceled)
244 					return -ECANCELED;
245 				return 0;
246 			}
247 		} while (ret == -ERESTARTSYS && freezing(current));
248 
249 		disable_irq_nosync(tpm_dev->irq);
250 
251 	} else {
252 		do {
253 			msleep(TPM_TIMEOUT);
254 			status = chip->ops->status(chip);
255 			if ((status & mask) == mask)
256 				return 0;
257 		} while (time_before(jiffies, stop));
258 	}
259 
260 	return -ETIME;
261 }
262 
263 static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
264 {
265 	struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev);
266 	int size = 0, burstcnt, len, ret;
267 
268 	while (size < count &&
269 	       wait_for_stat(chip,
270 			     TPM_STS_DATA_AVAIL | TPM_STS_VALID,
271 			     chip->timeout_c,
272 			     &tpm_dev->read_queue, true) == 0) {
273 		burstcnt = get_burstcount(chip);
274 		if (burstcnt < 0)
275 			return burstcnt;
276 		len = min_t(int, burstcnt, count - size);
277 		ret = tpm_dev->ops->recv(tpm_dev->phy_id, TPM_DATA_FIFO,
278 					 buf + size, len);
279 		if (ret < 0)
280 			return ret;
281 
282 		size += len;
283 	}
284 	return size;
285 }
286 
287 static irqreturn_t tpm_ioserirq_handler(int irq, void *dev_id)
288 {
289 	struct tpm_chip *chip = dev_id;
290 	struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev);
291 
292 	tpm_dev->intrs++;
293 	wake_up_interruptible(&tpm_dev->read_queue);
294 	disable_irq_nosync(tpm_dev->irq);
295 
296 	return IRQ_HANDLED;
297 }
298 
299 /*
300  * send TPM commands through the I2C bus.
301  */
302 static int st33zp24_send(struct tpm_chip *chip, unsigned char *buf,
303 			 size_t len)
304 {
305 	struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev);
306 	u32 status, i, size, ordinal;
307 	int burstcnt = 0;
308 	int ret;
309 	u8 data;
310 
311 	if (len < TPM_HEADER_SIZE)
312 		return -EBUSY;
313 
314 	ret = request_locality(chip);
315 	if (ret < 0)
316 		return ret;
317 
318 	status = st33zp24_status(chip);
319 	if ((status & TPM_STS_COMMAND_READY) == 0) {
320 		st33zp24_cancel(chip);
321 		if (wait_for_stat
322 		    (chip, TPM_STS_COMMAND_READY, chip->timeout_b,
323 		     &tpm_dev->read_queue, false) < 0) {
324 			ret = -ETIME;
325 			goto out_err;
326 		}
327 	}
328 
329 	for (i = 0; i < len - 1;) {
330 		burstcnt = get_burstcount(chip);
331 		if (burstcnt < 0)
332 			return burstcnt;
333 		size = min_t(int, len - i - 1, burstcnt);
334 		ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_DATA_FIFO,
335 					 buf + i, size);
336 		if (ret < 0)
337 			goto out_err;
338 
339 		i += size;
340 	}
341 
342 	status = st33zp24_status(chip);
343 	if ((status & TPM_STS_DATA_EXPECT) == 0) {
344 		ret = -EIO;
345 		goto out_err;
346 	}
347 
348 	ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_DATA_FIFO,
349 				 buf + len - 1, 1);
350 	if (ret < 0)
351 		goto out_err;
352 
353 	status = st33zp24_status(chip);
354 	if ((status & TPM_STS_DATA_EXPECT) != 0) {
355 		ret = -EIO;
356 		goto out_err;
357 	}
358 
359 	data = TPM_STS_GO;
360 	ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_STS, &data, 1);
361 	if (ret < 0)
362 		goto out_err;
363 
364 	if (chip->flags & TPM_CHIP_FLAG_IRQ) {
365 		ordinal = be32_to_cpu(*((__be32 *) (buf + 6)));
366 
367 		ret = wait_for_stat(chip, TPM_STS_DATA_AVAIL | TPM_STS_VALID,
368 				tpm_calc_ordinal_duration(chip, ordinal),
369 				&tpm_dev->read_queue, false);
370 		if (ret < 0)
371 			goto out_err;
372 	}
373 
374 	return 0;
375 out_err:
376 	st33zp24_cancel(chip);
377 	release_locality(chip);
378 	return ret;
379 }
380 
381 static int st33zp24_recv(struct tpm_chip *chip, unsigned char *buf,
382 			    size_t count)
383 {
384 	int size = 0;
385 	u32 expected;
386 
387 	if (!chip)
388 		return -EBUSY;
389 
390 	if (count < TPM_HEADER_SIZE) {
391 		size = -EIO;
392 		goto out;
393 	}
394 
395 	size = recv_data(chip, buf, TPM_HEADER_SIZE);
396 	if (size < TPM_HEADER_SIZE) {
397 		dev_err(&chip->dev, "Unable to read header\n");
398 		goto out;
399 	}
400 
401 	expected = be32_to_cpu(*(__be32 *)(buf + 2));
402 	if (expected > count || expected < TPM_HEADER_SIZE) {
403 		size = -EIO;
404 		goto out;
405 	}
406 
407 	size += recv_data(chip, &buf[TPM_HEADER_SIZE],
408 			expected - TPM_HEADER_SIZE);
409 	if (size < expected) {
410 		dev_err(&chip->dev, "Unable to read remainder of result\n");
411 		size = -ETIME;
412 	}
413 
414 out:
415 	st33zp24_cancel(chip);
416 	release_locality(chip);
417 	return size;
418 }
419 
420 static bool st33zp24_req_canceled(struct tpm_chip *chip, u8 status)
421 {
422 	return (status == TPM_STS_COMMAND_READY);
423 }
424 
425 static const struct tpm_class_ops st33zp24_tpm = {
426 	.flags = TPM_OPS_AUTO_STARTUP,
427 	.send = st33zp24_send,
428 	.recv = st33zp24_recv,
429 	.cancel = st33zp24_cancel,
430 	.status = st33zp24_status,
431 	.req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
432 	.req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
433 	.req_canceled = st33zp24_req_canceled,
434 };
435 
436 static const struct acpi_gpio_params lpcpd_gpios = { 1, 0, false };
437 
438 static const struct acpi_gpio_mapping acpi_st33zp24_gpios[] = {
439 	{ "lpcpd-gpios", &lpcpd_gpios, 1 },
440 	{ },
441 };
442 
443 /*
444  * initialize the TPM device
445  */
446 int st33zp24_probe(void *phy_id, const struct st33zp24_phy_ops *ops,
447 		   struct device *dev, int irq)
448 {
449 	int ret;
450 	u8 intmask = 0;
451 	struct tpm_chip *chip;
452 	struct st33zp24_dev *tpm_dev;
453 
454 	chip = tpmm_chip_alloc(dev, &st33zp24_tpm);
455 	if (IS_ERR(chip))
456 		return PTR_ERR(chip);
457 
458 	tpm_dev = devm_kzalloc(dev, sizeof(struct st33zp24_dev),
459 			       GFP_KERNEL);
460 	if (!tpm_dev)
461 		return -ENOMEM;
462 
463 	tpm_dev->phy_id = phy_id;
464 	tpm_dev->ops = ops;
465 	dev_set_drvdata(&chip->dev, tpm_dev);
466 
467 	chip->timeout_a = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
468 	chip->timeout_b = msecs_to_jiffies(TIS_LONG_TIMEOUT);
469 	chip->timeout_c = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
470 	chip->timeout_d = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
471 
472 	tpm_dev->locality = LOCALITY0;
473 
474 	if (ACPI_COMPANION(dev)) {
475 		ret = devm_acpi_dev_add_driver_gpios(dev, acpi_st33zp24_gpios);
476 		if (ret)
477 			return ret;
478 	}
479 
480 	/*
481 	 * Get LPCPD GPIO. If lpcpd pin is not specified. This is not an
482 	 * issue as power management can be also managed by TPM specific
483 	 * commands.
484 	 */
485 	tpm_dev->io_lpcpd = devm_gpiod_get_optional(dev, "lpcpd",
486 						    GPIOD_OUT_HIGH);
487 	ret = PTR_ERR_OR_ZERO(tpm_dev->io_lpcpd);
488 	if (ret) {
489 		dev_err(dev, "failed to request lpcpd gpio: %d\n", ret);
490 		return ret;
491 	}
492 
493 	if (irq) {
494 		/* INTERRUPT Setup */
495 		init_waitqueue_head(&tpm_dev->read_queue);
496 		tpm_dev->intrs = 0;
497 
498 		if (request_locality(chip) != LOCALITY0) {
499 			ret = -ENODEV;
500 			goto _tpm_clean_answer;
501 		}
502 
503 		clear_interruption(tpm_dev);
504 		ret = devm_request_irq(dev, irq, tpm_ioserirq_handler,
505 				IRQF_TRIGGER_HIGH, "TPM SERIRQ management",
506 				chip);
507 		if (ret < 0) {
508 			dev_err(&chip->dev, "TPM SERIRQ signals %d not available\n",
509 				irq);
510 			goto _tpm_clean_answer;
511 		}
512 
513 		intmask |= TPM_INTF_CMD_READY_INT
514 			|  TPM_INTF_STS_VALID_INT
515 			|  TPM_INTF_DATA_AVAIL_INT;
516 
517 		ret = tpm_dev->ops->send(tpm_dev->phy_id, TPM_INT_ENABLE,
518 					 &intmask, 1);
519 		if (ret < 0)
520 			goto _tpm_clean_answer;
521 
522 		intmask = TPM_GLOBAL_INT_ENABLE;
523 		ret = tpm_dev->ops->send(tpm_dev->phy_id, (TPM_INT_ENABLE + 3),
524 					 &intmask, 1);
525 		if (ret < 0)
526 			goto _tpm_clean_answer;
527 
528 		tpm_dev->irq = irq;
529 		chip->flags |= TPM_CHIP_FLAG_IRQ;
530 
531 		disable_irq_nosync(tpm_dev->irq);
532 	}
533 
534 	return tpm_chip_register(chip);
535 _tpm_clean_answer:
536 	dev_info(&chip->dev, "TPM initialization fail\n");
537 	return ret;
538 }
539 EXPORT_SYMBOL(st33zp24_probe);
540 
541 void st33zp24_remove(struct tpm_chip *chip)
542 {
543 	tpm_chip_unregister(chip);
544 }
545 EXPORT_SYMBOL(st33zp24_remove);
546 
547 #ifdef CONFIG_PM_SLEEP
548 int st33zp24_pm_suspend(struct device *dev)
549 {
550 	struct tpm_chip *chip = dev_get_drvdata(dev);
551 	struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev);
552 
553 	int ret = 0;
554 
555 	if (tpm_dev->io_lpcpd)
556 		gpiod_set_value_cansleep(tpm_dev->io_lpcpd, 0);
557 	else
558 		ret = tpm_pm_suspend(dev);
559 
560 	return ret;
561 }
562 EXPORT_SYMBOL(st33zp24_pm_suspend);
563 
564 int st33zp24_pm_resume(struct device *dev)
565 {
566 	struct tpm_chip *chip = dev_get_drvdata(dev);
567 	struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev);
568 	int ret = 0;
569 
570 	if (tpm_dev->io_lpcpd) {
571 		gpiod_set_value_cansleep(tpm_dev->io_lpcpd, 1);
572 		ret = wait_for_stat(chip,
573 				TPM_STS_VALID, chip->timeout_b,
574 				&tpm_dev->read_queue, false);
575 	} else {
576 		ret = tpm_pm_resume(dev);
577 		if (!ret)
578 			tpm1_do_selftest(chip);
579 	}
580 	return ret;
581 }
582 EXPORT_SYMBOL(st33zp24_pm_resume);
583 #endif
584 
585 MODULE_AUTHOR("TPM support (TPMsupport@list.st.com)");
586 MODULE_DESCRIPTION("ST33ZP24 TPM 1.2 driver");
587 MODULE_VERSION("1.3.0");
588 MODULE_LICENSE("GPL");
589