~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,3 +1,4 @@
	1	+// SPDX-License-Identifier: GPL-2.0-only
1	2	/*
2	3	* Copyright (C) 2004 IBM Corporation
3	4	* Copyright (C) 2014 Intel Corporation
..	..	@@ -13,451 +14,66 @@
13	14	* Device driver for TCG/TCPA TPM (trusted platform module).
14	15	* Specifications at www.trustedcomputinggroup.org
15	16	*
16		- * This program is free software; you can redistribute it and/or
17		- * modify it under the terms of the GNU General Public License as
18		- * published by the Free Software Foundation, version 2 of the
19		- * License.
20		- *
21	17	* Note, the TPM chip is not interrupt driven (only polling)
22	18	* and can have very long timeouts (minutes!). Hence the unusual
23	19	* calls to msleep.
24		- *
25	20	*/
26	21
27	22	#include <linux/poll.h>
28	23	#include <linux/slab.h>
29	24	#include <linux/mutex.h>
30	25	#include <linux/spinlock.h>
	26	+#include <linux/suspend.h>
31	27	#include <linux/freezer.h>
32	28	#include <linux/tpm_eventlog.h>
33	29
34	30	#include "tpm.h"
35		-
36		-#define TPM_MAX_ORDINAL 243
37		-#define TSC_MAX_ORDINAL 12
38		-#define TPM_PROTECTED_COMMAND 0x00
39		-#define TPM_CONNECTION_COMMAND 0x40
40	31
41	32	/*
42	33	* Bug workaround - some TPM's don't flush the most
43	34	* recently changed pcr on suspend, so force the flush
44	35	* with an extend to the selected _unused_ non-volatile pcr.
45	36	*/
46		-static int tpm_suspend_pcr;
	37	+static u32 tpm_suspend_pcr;
47	38	module_param_named(suspend_pcr, tpm_suspend_pcr, uint, 0644);
48	39	MODULE_PARM_DESC(suspend_pcr,
49	40	"PCR to use for dummy writes to facilitate flush on suspend.");
50	41
51		-/*
52		- * Array with one entry per ordinal defining the maximum amount
53		- * of time the chip could take to return the result. The ordinal
54		- * designation of short, medium or long is defined in a table in
55		- * TCG Specification TPM Main Part 2 TPM Structures Section 17. The
56		- * values of the SHORT, MEDIUM, and LONG durations are retrieved
57		- * from the chip during initialization with a call to tpm_get_timeouts.
	42	+/**
	43	+ * tpm_calc_ordinal_duration() - calculate the maximum command duration
	44	+ * @chip: TPM chip to use.
	45	+ * @ordinal: TPM command ordinal.
	46	+ *
	47	+ * The function returns the maximum amount of time the chip could take
	48	+ * to return the result for a particular ordinal in jiffies.
	49	+ *
	50	+ * Return: A maximal duration time for an ordinal in jiffies.
58	51	*/
59		-static const u8 tpm_ordinal_duration[TPM_MAX_ORDINAL] = {
60		- TPM_UNDEFINED, /* 0 */
61		- TPM_UNDEFINED,
62		- TPM_UNDEFINED,
63		- TPM_UNDEFINED,
64		- TPM_UNDEFINED,
65		- TPM_UNDEFINED, /* 5 */
66		- TPM_UNDEFINED,
67		- TPM_UNDEFINED,
68		- TPM_UNDEFINED,
69		- TPM_UNDEFINED,
70		- TPM_SHORT, /* 10 */
71		- TPM_SHORT,
72		- TPM_MEDIUM,
73		- TPM_LONG,
74		- TPM_LONG,
75		- TPM_MEDIUM, /* 15 */
76		- TPM_SHORT,
77		- TPM_SHORT,
78		- TPM_MEDIUM,
79		- TPM_LONG,
80		- TPM_SHORT, /* 20 */
81		- TPM_SHORT,
82		- TPM_MEDIUM,
83		- TPM_MEDIUM,
84		- TPM_MEDIUM,
85		- TPM_SHORT, /* 25 */
86		- TPM_SHORT,
87		- TPM_MEDIUM,
88		- TPM_SHORT,
89		- TPM_SHORT,
90		- TPM_MEDIUM, /* 30 */
91		- TPM_LONG,
92		- TPM_MEDIUM,
93		- TPM_SHORT,
94		- TPM_SHORT,
95		- TPM_SHORT, /* 35 */
96		- TPM_MEDIUM,
97		- TPM_MEDIUM,
98		- TPM_UNDEFINED,
99		- TPM_UNDEFINED,
100		- TPM_MEDIUM, /* 40 */
101		- TPM_LONG,
102		- TPM_MEDIUM,
103		- TPM_SHORT,
104		- TPM_SHORT,
105		- TPM_SHORT, /* 45 */
106		- TPM_SHORT,
107		- TPM_SHORT,
108		- TPM_SHORT,
109		- TPM_LONG,
110		- TPM_MEDIUM, /* 50 */
111		- TPM_MEDIUM,
112		- TPM_UNDEFINED,
113		- TPM_UNDEFINED,
114		- TPM_UNDEFINED,
115		- TPM_UNDEFINED, /* 55 */
116		- TPM_UNDEFINED,
117		- TPM_UNDEFINED,
118		- TPM_UNDEFINED,
119		- TPM_UNDEFINED,
120		- TPM_MEDIUM, /* 60 */
121		- TPM_MEDIUM,
122		- TPM_MEDIUM,
123		- TPM_SHORT,
124		- TPM_SHORT,
125		- TPM_MEDIUM, /* 65 */
126		- TPM_UNDEFINED,
127		- TPM_UNDEFINED,
128		- TPM_UNDEFINED,
129		- TPM_UNDEFINED,
130		- TPM_SHORT, /* 70 */
131		- TPM_SHORT,
132		- TPM_UNDEFINED,
133		- TPM_UNDEFINED,
134		- TPM_UNDEFINED,
135		- TPM_UNDEFINED, /* 75 */
136		- TPM_UNDEFINED,
137		- TPM_UNDEFINED,
138		- TPM_UNDEFINED,
139		- TPM_UNDEFINED,
140		- TPM_LONG, /* 80 */
141		- TPM_UNDEFINED,
142		- TPM_MEDIUM,
143		- TPM_LONG,
144		- TPM_SHORT,
145		- TPM_UNDEFINED, /* 85 */
146		- TPM_UNDEFINED,
147		- TPM_UNDEFINED,
148		- TPM_UNDEFINED,
149		- TPM_UNDEFINED,
150		- TPM_SHORT, /* 90 */
151		- TPM_SHORT,
152		- TPM_SHORT,
153		- TPM_SHORT,
154		- TPM_SHORT,
155		- TPM_UNDEFINED, /* 95 */
156		- TPM_UNDEFINED,
157		- TPM_UNDEFINED,
158		- TPM_UNDEFINED,
159		- TPM_UNDEFINED,
160		- TPM_MEDIUM, /* 100 */
161		- TPM_SHORT,
162		- TPM_SHORT,
163		- TPM_UNDEFINED,
164		- TPM_UNDEFINED,
165		- TPM_UNDEFINED, /* 105 */
166		- TPM_UNDEFINED,
167		- TPM_UNDEFINED,
168		- TPM_UNDEFINED,
169		- TPM_UNDEFINED,
170		- TPM_SHORT, /* 110 */
171		- TPM_SHORT,
172		- TPM_SHORT,
173		- TPM_SHORT,
174		- TPM_SHORT,
175		- TPM_SHORT, /* 115 */
176		- TPM_SHORT,
177		- TPM_SHORT,
178		- TPM_UNDEFINED,
179		- TPM_UNDEFINED,
180		- TPM_LONG, /* 120 */
181		- TPM_LONG,
182		- TPM_MEDIUM,
183		- TPM_UNDEFINED,
184		- TPM_SHORT,
185		- TPM_SHORT, /* 125 */
186		- TPM_SHORT,
187		- TPM_LONG,
188		- TPM_SHORT,
189		- TPM_SHORT,
190		- TPM_SHORT, /* 130 */
191		- TPM_MEDIUM,
192		- TPM_UNDEFINED,
193		- TPM_SHORT,
194		- TPM_MEDIUM,
195		- TPM_UNDEFINED, /* 135 */
196		- TPM_UNDEFINED,
197		- TPM_UNDEFINED,
198		- TPM_UNDEFINED,
199		- TPM_UNDEFINED,
200		- TPM_SHORT, /* 140 */
201		- TPM_SHORT,
202		- TPM_UNDEFINED,
203		- TPM_UNDEFINED,
204		- TPM_UNDEFINED,
205		- TPM_UNDEFINED, /* 145 */
206		- TPM_UNDEFINED,
207		- TPM_UNDEFINED,
208		- TPM_UNDEFINED,
209		- TPM_UNDEFINED,
210		- TPM_SHORT, /* 150 */
211		- TPM_MEDIUM,
212		- TPM_MEDIUM,
213		- TPM_SHORT,
214		- TPM_SHORT,
215		- TPM_UNDEFINED, /* 155 */
216		- TPM_UNDEFINED,
217		- TPM_UNDEFINED,
218		- TPM_UNDEFINED,
219		- TPM_UNDEFINED,
220		- TPM_SHORT, /* 160 */
221		- TPM_SHORT,
222		- TPM_SHORT,
223		- TPM_SHORT,
224		- TPM_UNDEFINED,
225		- TPM_UNDEFINED, /* 165 */
226		- TPM_UNDEFINED,
227		- TPM_UNDEFINED,
228		- TPM_UNDEFINED,
229		- TPM_UNDEFINED,
230		- TPM_LONG, /* 170 */
231		- TPM_UNDEFINED,
232		- TPM_UNDEFINED,
233		- TPM_UNDEFINED,
234		- TPM_UNDEFINED,
235		- TPM_UNDEFINED, /* 175 */
236		- TPM_UNDEFINED,
237		- TPM_UNDEFINED,
238		- TPM_UNDEFINED,
239		- TPM_UNDEFINED,
240		- TPM_MEDIUM, /* 180 */
241		- TPM_SHORT,
242		- TPM_MEDIUM,
243		- TPM_MEDIUM,
244		- TPM_MEDIUM,
245		- TPM_MEDIUM, /* 185 */
246		- TPM_SHORT,
247		- TPM_UNDEFINED,
248		- TPM_UNDEFINED,
249		- TPM_UNDEFINED,
250		- TPM_UNDEFINED, /* 190 */
251		- TPM_UNDEFINED,
252		- TPM_UNDEFINED,
253		- TPM_UNDEFINED,
254		- TPM_UNDEFINED,
255		- TPM_UNDEFINED, /* 195 */
256		- TPM_UNDEFINED,
257		- TPM_UNDEFINED,
258		- TPM_UNDEFINED,
259		- TPM_UNDEFINED,
260		- TPM_SHORT, /* 200 */
261		- TPM_UNDEFINED,
262		- TPM_UNDEFINED,
263		- TPM_UNDEFINED,
264		- TPM_SHORT,
265		- TPM_SHORT, /* 205 */
266		- TPM_SHORT,
267		- TPM_SHORT,
268		- TPM_SHORT,
269		- TPM_SHORT,
270		- TPM_MEDIUM, /* 210 */
271		- TPM_UNDEFINED,
272		- TPM_MEDIUM,
273		- TPM_MEDIUM,
274		- TPM_MEDIUM,
275		- TPM_UNDEFINED, /* 215 */
276		- TPM_MEDIUM,
277		- TPM_UNDEFINED,
278		- TPM_UNDEFINED,
279		- TPM_SHORT,
280		- TPM_SHORT, /* 220 */
281		- TPM_SHORT,
282		- TPM_SHORT,
283		- TPM_SHORT,
284		- TPM_SHORT,
285		- TPM_UNDEFINED, /* 225 */
286		- TPM_UNDEFINED,
287		- TPM_UNDEFINED,
288		- TPM_UNDEFINED,
289		- TPM_UNDEFINED,
290		- TPM_SHORT, /* 230 */
291		- TPM_LONG,
292		- TPM_MEDIUM,
293		- TPM_UNDEFINED,
294		- TPM_UNDEFINED,
295		- TPM_UNDEFINED, /* 235 */
296		- TPM_UNDEFINED,
297		- TPM_UNDEFINED,
298		- TPM_UNDEFINED,
299		- TPM_UNDEFINED,
300		- TPM_SHORT, /* 240 */
301		- TPM_UNDEFINED,
302		- TPM_MEDIUM,
303		-};
304		-
305		-/*
306		- * Returns max number of jiffies to wait
307		- */
308		-unsigned long tpm_calc_ordinal_duration(struct tpm_chip *chip,
309		- u32 ordinal)
	52	+unsigned long tpm_calc_ordinal_duration(struct tpm_chip *chip, u32 ordinal)
310	53	{
311		- int duration_idx = TPM_UNDEFINED;
312		- int duration = 0;
313		-
314		- /*
315		- * We only have a duration table for protected commands, where the upper
316		- * 16 bits are 0. For the few other ordinals the fallback will be used.
317		- */
318		- if (ordinal < TPM_MAX_ORDINAL)
319		- duration_idx = tpm_ordinal_duration[ordinal];
320		-
321		- if (duration_idx != TPM_UNDEFINED)
322		- duration = chip->duration[duration_idx];
323		- if (duration <= 0)
324		- return 2 * 60 * HZ;
	54	+ if (chip->flags & TPM_CHIP_FLAG_TPM2)
	55	+ return tpm2_calc_ordinal_duration(chip, ordinal);
325	56	else
326		- return duration;
	57	+ return tpm1_calc_ordinal_duration(chip, ordinal);
327	58	}
328	59	EXPORT_SYMBOL_GPL(tpm_calc_ordinal_duration);
329	60
330		-static int tpm_validate_command(struct tpm_chip *chip,
331		- struct tpm_space *space,
332		- const u8 *cmd,
333		- size_t len)
	61	+static ssize_t tpm_try_transmit(struct tpm_chip chip, void buf, size_t bufsiz)
334	62	{
335		- const struct tpm_input_header header = (const void )cmd;
336		- int i;
337		- u32 cc;
338		- u32 attrs;
339		- unsigned int nr_handles;
340		-
341		- if (len < TPM_HEADER_SIZE)
342		- return -EINVAL;
343		-
344		- if (!space)
345		- return 0;
346		-
347		- if (chip->flags & TPM_CHIP_FLAG_TPM2 && chip->nr_commands) {
348		- cc = be32_to_cpu(header->ordinal);
349		-
350		- i = tpm2_find_cc(chip, cc);
351		- if (i < 0) {
352		- dev_dbg(&chip->dev, "0x%04X is an invalid command\n",
353		- cc);
354		- return -EOPNOTSUPP;
355		- }
356		-
357		- attrs = chip->cc_attrs_tbl[i];
358		- nr_handles =
359		- 4 * ((attrs >> TPM2_CC_ATTR_CHANDLES) & GENMASK(2, 0));
360		- if (len < TPM_HEADER_SIZE + 4 * nr_handles)
361		- goto err_len;
362		- }
363		-
364		- return 0;
365		-err_len:
366		- dev_dbg(&chip->dev,
367		- "%s: insufficient command length %zu", __func__, len);
368		- return -EINVAL;
369		-}
370		-
371		-static int tpm_request_locality(struct tpm_chip *chip, unsigned int flags)
372		-{
373		- int rc;
374		-
375		- if (flags & TPM_TRANSMIT_NESTED)
376		- return 0;
377		-
378		- if (!chip->ops->request_locality)
379		- return 0;
380		-
381		- rc = chip->ops->request_locality(chip, 0);
382		- if (rc < 0)
383		- return rc;
384		-
385		- chip->locality = rc;
386		-
387		- return 0;
388		-}
389		-
390		-static void tpm_relinquish_locality(struct tpm_chip *chip, unsigned int flags)
391		-{
392		- int rc;
393		-
394		- if (flags & TPM_TRANSMIT_NESTED)
395		- return;
396		-
397		- if (!chip->ops->relinquish_locality)
398		- return;
399		-
400		- rc = chip->ops->relinquish_locality(chip, chip->locality);
401		- if (rc)
402		- dev_err(&chip->dev, "%s: : error %d\n", __func__, rc);
403		-
404		- chip->locality = -1;
405		-}
406		-
407		-static int tpm_cmd_ready(struct tpm_chip *chip, unsigned int flags)
408		-{
409		- if (flags & TPM_TRANSMIT_NESTED)
410		- return 0;
411		-
412		- if (!chip->ops->cmd_ready)
413		- return 0;
414		-
415		- return chip->ops->cmd_ready(chip);
416		-}
417		-
418		-static int tpm_go_idle(struct tpm_chip *chip, unsigned int flags)
419		-{
420		- if (flags & TPM_TRANSMIT_NESTED)
421		- return 0;
422		-
423		- if (!chip->ops->go_idle)
424		- return 0;
425		-
426		- return chip->ops->go_idle(chip);
427		-}
428		-
429		-static ssize_t tpm_try_transmit(struct tpm_chip *chip,
430		- struct tpm_space *space,
431		- u8 *buf, size_t bufsiz,
432		- unsigned int flags)
433		-{
434		- struct tpm_output_header header = (void )buf;
	63	+ struct tpm_header *header = buf;
435	64	int rc;
436	65	ssize_t len = 0;
437	66	u32 count, ordinal;
438	67	unsigned long stop;
439		- bool need_locality;
440	68
441		- rc = tpm_validate_command(chip, space, buf, bufsiz);
442		- if (rc == -EINVAL)
443		- return rc;
444		- /*
445		- * If the command is not implemented by the TPM, synthesize a
446		- * response with a TPM2_RC_COMMAND_CODE return for user-space.
447		- */
448		- if (rc == -EOPNOTSUPP) {
449		- header->length = cpu_to_be32(sizeof(*header));
450		- header->tag = cpu_to_be16(TPM2_ST_NO_SESSIONS);
451		- header->return_code = cpu_to_be32(TPM2_RC_COMMAND_CODE \|
452		- TSS2_RESMGR_TPM_RC_LAYER);
453		- return sizeof(*header);
454		- }
	69	+ if (bufsiz < TPM_HEADER_SIZE)
	70	+ return -EINVAL;
455	71
456	72	if (bufsiz > TPM_BUFSIZE)
457	73	bufsiz = TPM_BUFSIZE;
458	74
459		- count = be32_to_cpu(((__be32 ) (buf + 2)));
460		- ordinal = be32_to_cpu(((__be32 ) (buf + 6)));
	75	+ count = be32_to_cpu(header->length);
	76	+ ordinal = be32_to_cpu(header->ordinal);
461	77	if (count == 0)
462	78	return -ENODATA;
463	79	if (count > bufsiz) {
..	..	@@ -466,37 +82,12 @@
466	82	return -E2BIG;
467	83	}
468	84
469		- if (!(flags & TPM_TRANSMIT_UNLOCKED) && !(flags & TPM_TRANSMIT_NESTED))
470		- mutex_lock(&chip->tpm_mutex);
471		-
472		- if (chip->ops->clk_enable != NULL)
473		- chip->ops->clk_enable(chip, true);
474		-
475		- /* Store the decision as chip->locality will be changed. */
476		- need_locality = chip->locality == -1;
477		-
478		- if (need_locality) {
479		- rc = tpm_request_locality(chip, flags);
480		- if (rc < 0) {
481		- need_locality = false;
482		- goto out_locality;
483		- }
484		- }
485		-
486		- rc = tpm_cmd_ready(chip, flags);
487		- if (rc)
488		- goto out_locality;
489		-
490		- rc = tpm2_prepare_space(chip, space, ordinal, buf);
491		- if (rc)
492		- goto out;
493		-
494	85	rc = chip->ops->send(chip, buf, count);
495	86	if (rc < 0) {
496	87	if (rc != -EPIPE)
497	88	dev_err(&chip->dev,
498	89	"%s: send(): error %d\n", __func__, rc);
499		- goto out;
	90	+ return rc;
500	91	}
501	92
502	93	/* A sanity check. send() should just return zero on success e.g.
..	..	@@ -511,10 +102,7 @@
511	102	if (chip->flags & TPM_CHIP_FLAG_IRQ)
512	103	goto out_recv;
513	104
514		- if (chip->flags & TPM_CHIP_FLAG_TPM2)
515		- stop = jiffies + tpm2_calc_ordinal_duration(chip, ordinal);
516		- else
517		- stop = jiffies + tpm_calc_ordinal_duration(chip, ordinal);
	105	+ stop = jiffies + tpm_calc_ordinal_duration(chip, ordinal);
518	106	do {
519	107	u8 status = chip->ops->status(chip);
520	108	if ((status & chip->ops->req_complete_mask) ==
..	..	@@ -523,8 +111,7 @@
523	111
524	112	if (chip->ops->req_canceled(chip, status)) {
525	113	dev_err(&chip->dev, "Operation Canceled\n");
526		- rc = -ECANCELED;
527		- goto out;
	114	+ return -ECANCELED;
528	115	}
529	116
530	117	tpm_msleep(TPM_TIMEOUT_POLL);
..	..	@@ -533,77 +120,45 @@
533	120
534	121	chip->ops->cancel(chip);
535	122	dev_err(&chip->dev, "Operation Timed out\n");
536		- rc = -ETIME;
537		- goto out;
	123	+ return -ETIME;
538	124
539	125	out_recv:
540	126	len = chip->ops->recv(chip, buf, bufsiz);
541	127	if (len < 0) {
542	128	rc = len;
543		- dev_err(&chip->dev,
544		- "tpm_transmit: tpm_recv: error %d\n", rc);
545		- goto out;
546		- } else if (len < TPM_HEADER_SIZE) {
	129	+ dev_err(&chip->dev, "tpm_transmit: tpm_recv: error %d\n", rc);
	130	+ } else if (len < TPM_HEADER_SIZE \|\| len != be32_to_cpu(header->length))
547	131	rc = -EFAULT;
548		- goto out;
549		- }
550	132
551		- if (len != be32_to_cpu(header->length)) {
552		- rc = -EFAULT;
553		- goto out;
554		- }
555		-
556		- rc = tpm2_commit_space(chip, space, ordinal, buf, &len);
557		- if (rc)
558		- dev_err(&chip->dev, "tpm2_commit_space: error %d\n", rc);
559		-
560		-out:
561		- /* may fail but do not override previous error value in rc */
562		- tpm_go_idle(chip, flags);
563		-
564		-out_locality:
565		- if (need_locality)
566		- tpm_relinquish_locality(chip, flags);
567		-
568		- if (chip->ops->clk_enable != NULL)
569		- chip->ops->clk_enable(chip, false);
570		-
571		- if (!(flags & TPM_TRANSMIT_UNLOCKED) && !(flags & TPM_TRANSMIT_NESTED))
572		- mutex_unlock(&chip->tpm_mutex);
573	133	return rc ? rc : len;
574	134	}
575	135
576	136	/**
577	137	* tpm_transmit - Internal kernel interface to transmit TPM commands.
	138	+ * @chip: a TPM chip to use
	139	+ * @buf: a TPM command buffer
	140	+ * @bufsiz: length of the TPM command buffer
578	141	*
579		- * @chip: TPM chip to use
580		- * @space: tpm space
581		- * @buf: TPM command buffer
582		- * @bufsiz: length of the TPM command buffer
583		- * @flags: tpm transmit flags - bitmap
	142	+ * A wrapper around tpm_try_transmit() that handles TPM2_RC_RETRY returns from
	143	+ * the TPM and retransmits the command after a delay up to a maximum wait of
	144	+ * TPM2_DURATION_LONG.
584	145	*
585		- * A wrapper around tpm_try_transmit that handles TPM2_RC_RETRY
586		- * returns from the TPM and retransmits the command after a delay up
587		- * to a maximum wait of TPM2_DURATION_LONG.
588		- *
589		- * Note: TPM1 never returns TPM2_RC_RETRY so the retry logic is TPM2
590		- * only
	146	+ * Note that TPM 1.x never returns TPM2_RC_RETRY so the retry logic is TPM 2.0
	147	+ * only.
591	148	*
592	149	* Return:
593		- * the length of the return when the operation is successful.
594		- * A negative number for system errors (errno).
	150	+ * * The response length - OK
	151	+ * * -errno - A system error
595	152	*/
596		-ssize_t tpm_transmit(struct tpm_chip chip, struct tpm_space space,
597		- u8 *buf, size_t bufsiz, unsigned int flags)
	153	+ssize_t tpm_transmit(struct tpm_chip chip, u8 buf, size_t bufsiz)
598	154	{
599		- struct tpm_output_header header = (struct tpm_output_header )buf;
	155	+ struct tpm_header header = (struct tpm_header )buf;
600	156	/* space for header and handles */
601	157	u8 save[TPM_HEADER_SIZE + 3*sizeof(u32)];
602	158	unsigned int delay_msec = TPM2_DURATION_SHORT;
603	159	u32 rc = 0;
604	160	ssize_t ret;
605		- const size_t save_size = min(space ? sizeof(save) : TPM_HEADER_SIZE,
606		- bufsiz);
	161	+ const size_t save_size = min(sizeof(save), bufsiz);
607	162	/* the command code is where the return code will be */
608	163	u32 cc = be32_to_cpu(header->return_code);
609	164
..	..	@@ -615,7 +170,7 @@
615	170	memcpy(save, buf, save_size);
616	171
617	172	for (;;) {
618		- ret = tpm_try_transmit(chip, space, buf, bufsiz, flags);
	173	+ ret = tpm_try_transmit(chip, buf, bufsiz);
619	174	if (ret < 0)
620	175	break;
621	176	rc = be32_to_cpu(header->return_code);
..	..	@@ -642,39 +197,33 @@
642	197	}
643	198	return ret;
644	199	}
	200	+
645	201	/**
646	202	* tpm_transmit_cmd - send a tpm command to the device
647		- * The function extracts tpm out header return code
648		- *
649		- * @chip: TPM chip to use
650		- * @space: tpm space
651		- * @buf: TPM command buffer
652		- * @bufsiz: length of the buffer
653		- * @min_rsp_body_length: minimum expected length of response body
654		- * @flags: tpm transmit flags - bitmap
655		- * @desc: command description used in the error message
	203	+ * @chip: a TPM chip to use
	204	+ * @buf: a TPM command buffer
	205	+ * @min_rsp_body_length: minimum expected length of response body
	206	+ * @desc: command description used in the error message
656	207	*
657	208	* Return:
658		- * 0 when the operation is successful.
659		- * A negative number for system errors (errno).
660		- * A positive number for a TPM error.
	209	+ * * 0 - OK
	210	+ * * -errno - A system error
	211	+ * * TPM_RC - A TPM error
661	212	*/
662		-ssize_t tpm_transmit_cmd(struct tpm_chip chip, struct tpm_space space,
663		- void *buf, size_t bufsiz,
664		- size_t min_rsp_body_length, unsigned int flags,
665		- const char *desc)
	213	+ssize_t tpm_transmit_cmd(struct tpm_chip chip, struct tpm_buf buf,
	214	+ size_t min_rsp_body_length, const char *desc)
666	215	{
667		- const struct tpm_output_header *header = buf;
	216	+ const struct tpm_header header = (struct tpm_header )buf->data;
668	217	int err;
669	218	ssize_t len;
670	219
671		- len = tpm_transmit(chip, space, buf, bufsiz, flags);
	220	+ len = tpm_transmit(chip, buf->data, PAGE_SIZE);
672	221	if (len < 0)
673	222	return len;
674	223
675	224	err = be32_to_cpu(header->return_code);
676	225	if (err != 0 && err != TPM_ERR_DISABLED && err != TPM_ERR_DEACTIVATED
677		- && desc)
	226	+ && err != TPM2_RC_TESTING && desc)
678	227	dev_err(&chip->dev, "A TPM error (%d) occurred %s\n", err,
679	228	desc);
680	229	if (err)
..	..	@@ -687,276 +236,17 @@
687	236	}
688	237	EXPORT_SYMBOL_GPL(tpm_transmit_cmd);
689	238
690		-#define TPM_ORD_STARTUP 153
691		-#define TPM_ST_CLEAR 1
692		-
693		-/**
694		- * tpm_startup - turn on the TPM
695		- * @chip: TPM chip to use
696		- *
697		- * Normally the firmware should start the TPM. This function is provided as a
698		- * workaround if this does not happen. A legal case for this could be for
699		- * example when a TPM emulator is used.
700		- *
701		- * Return: same as tpm_transmit_cmd()
702		- */
703		-int tpm_startup(struct tpm_chip *chip)
704		-{
705		- struct tpm_buf buf;
706		- int rc;
707		-
708		- dev_info(&chip->dev, "starting up the TPM manually\n");
709		-
710		- if (chip->flags & TPM_CHIP_FLAG_TPM2) {
711		- rc = tpm_buf_init(&buf, TPM2_ST_NO_SESSIONS, TPM2_CC_STARTUP);
712		- if (rc < 0)
713		- return rc;
714		-
715		- tpm_buf_append_u16(&buf, TPM2_SU_CLEAR);
716		- } else {
717		- rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_STARTUP);
718		- if (rc < 0)
719		- return rc;
720		-
721		- tpm_buf_append_u16(&buf, TPM_ST_CLEAR);
722		- }
723		-
724		- rc = tpm_transmit_cmd(chip, NULL, buf.data, PAGE_SIZE, 0, 0,
725		- "attempting to start the TPM");
726		-
727		- tpm_buf_destroy(&buf);
728		- return rc;
729		-}
730		-
731		-#define TPM_DIGEST_SIZE 20
732		-#define TPM_RET_CODE_IDX 6
733		-#define TPM_INTERNAL_RESULT_SIZE 200
734		-#define TPM_ORD_GET_CAP 101
735		-#define TPM_ORD_GET_RANDOM 70
736		-
737		-static const struct tpm_input_header tpm_getcap_header = {
738		- .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND),
739		- .length = cpu_to_be32(22),
740		- .ordinal = cpu_to_be32(TPM_ORD_GET_CAP)
741		-};
742		-
743		-ssize_t tpm_getcap(struct tpm_chip chip, u32 subcap_id, cap_t cap,
744		- const char *desc, size_t min_cap_length)
745		-{
746		- struct tpm_buf buf;
747		- int rc;
748		-
749		- rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_GET_CAP);
750		- if (rc)
751		- return rc;
752		-
753		- if (subcap_id == TPM_CAP_VERSION_1_1 \|\|
754		- subcap_id == TPM_CAP_VERSION_1_2) {
755		- tpm_buf_append_u32(&buf, subcap_id);
756		- tpm_buf_append_u32(&buf, 0);
757		- } else {
758		- if (subcap_id == TPM_CAP_FLAG_PERM \|\|
759		- subcap_id == TPM_CAP_FLAG_VOL)
760		- tpm_buf_append_u32(&buf, TPM_CAP_FLAG);
761		- else
762		- tpm_buf_append_u32(&buf, TPM_CAP_PROP);
763		-
764		- tpm_buf_append_u32(&buf, 4);
765		- tpm_buf_append_u32(&buf, subcap_id);
766		- }
767		- rc = tpm_transmit_cmd(chip, NULL, buf.data, PAGE_SIZE,
768		- min_cap_length, 0, desc);
769		- if (!rc)
770		- cap = (cap_t *)&buf.data[TPM_HEADER_SIZE + 4];
771		-
772		- tpm_buf_destroy(&buf);
773		- return rc;
774		-}
775		-EXPORT_SYMBOL_GPL(tpm_getcap);
776		-
777	239	int tpm_get_timeouts(struct tpm_chip *chip)
778	240	{
779		- cap_t cap;
780		- unsigned long timeout_old[4], timeout_chip[4], timeout_eff[4];
781		- ssize_t rc;
782		-
783	241	if (chip->flags & TPM_CHIP_FLAG_HAVE_TIMEOUTS)
784	242	return 0;
785	243
786		- if (chip->flags & TPM_CHIP_FLAG_TPM2) {
787		- /* Fixed timeouts for TPM2 */
788		- chip->timeout_a = msecs_to_jiffies(TPM2_TIMEOUT_A);
789		- chip->timeout_b = msecs_to_jiffies(TPM2_TIMEOUT_B);
790		- chip->timeout_c = msecs_to_jiffies(TPM2_TIMEOUT_C);
791		- chip->timeout_d = msecs_to_jiffies(TPM2_TIMEOUT_D);
792		- chip->duration[TPM_SHORT] =
793		- msecs_to_jiffies(TPM2_DURATION_SHORT);
794		- chip->duration[TPM_MEDIUM] =
795		- msecs_to_jiffies(TPM2_DURATION_MEDIUM);
796		- chip->duration[TPM_LONG] =
797		- msecs_to_jiffies(TPM2_DURATION_LONG);
798		- chip->duration[TPM_LONG_LONG] =
799		- msecs_to_jiffies(TPM2_DURATION_LONG_LONG);
800		-
801		- chip->flags \|= TPM_CHIP_FLAG_HAVE_TIMEOUTS;
802		- return 0;
803		- }
804		-
805		- rc = tpm_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &cap, NULL,
806		- sizeof(cap.timeout));
807		- if (rc == TPM_ERR_INVALID_POSTINIT) {
808		- if (tpm_startup(chip))
809		- return rc;
810		-
811		- rc = tpm_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &cap,
812		- "attempting to determine the timeouts",
813		- sizeof(cap.timeout));
814		- }
815		-
816		- if (rc) {
817		- dev_err(&chip->dev,
818		- "A TPM error (%zd) occurred attempting to determine the timeouts\n",
819		- rc);
820		- return rc;
821		- }
822		-
823		- timeout_old[0] = jiffies_to_usecs(chip->timeout_a);
824		- timeout_old[1] = jiffies_to_usecs(chip->timeout_b);
825		- timeout_old[2] = jiffies_to_usecs(chip->timeout_c);
826		- timeout_old[3] = jiffies_to_usecs(chip->timeout_d);
827		- timeout_chip[0] = be32_to_cpu(cap.timeout.a);
828		- timeout_chip[1] = be32_to_cpu(cap.timeout.b);
829		- timeout_chip[2] = be32_to_cpu(cap.timeout.c);
830		- timeout_chip[3] = be32_to_cpu(cap.timeout.d);
831		- memcpy(timeout_eff, timeout_chip, sizeof(timeout_eff));
832		-
833		- /*
834		- * Provide ability for vendor overrides of timeout values in case
835		- * of misreporting.
836		- */
837		- if (chip->ops->update_timeouts != NULL)
838		- chip->timeout_adjusted =
839		- chip->ops->update_timeouts(chip, timeout_eff);
840		-
841		- if (!chip->timeout_adjusted) {
842		- /* Restore default if chip reported 0 */
843		- int i;
844		-
845		- for (i = 0; i < ARRAY_SIZE(timeout_eff); i++) {
846		- if (timeout_eff[i])
847		- continue;
848		-
849		- timeout_eff[i] = timeout_old[i];
850		- chip->timeout_adjusted = true;
851		- }
852		-
853		- if (timeout_eff[0] != 0 && timeout_eff[0] < 1000) {
854		- /* timeouts in msec rather usec */
855		- for (i = 0; i != ARRAY_SIZE(timeout_eff); i++)
856		- timeout_eff[i] *= 1000;
857		- chip->timeout_adjusted = true;
858		- }
859		- }
860		-
861		- /* Report adjusted timeouts */
862		- if (chip->timeout_adjusted) {
863		- dev_info(&chip->dev,
864		- HW_ERR "Adjusting reported timeouts: A %lu->%luus B %lu->%luus C %lu->%luus D %lu->%luus\n",
865		- timeout_chip[0], timeout_eff[0],
866		- timeout_chip[1], timeout_eff[1],
867		- timeout_chip[2], timeout_eff[2],
868		- timeout_chip[3], timeout_eff[3]);
869		- }
870		-
871		- chip->timeout_a = usecs_to_jiffies(timeout_eff[0]);
872		- chip->timeout_b = usecs_to_jiffies(timeout_eff[1]);
873		- chip->timeout_c = usecs_to_jiffies(timeout_eff[2]);
874		- chip->timeout_d = usecs_to_jiffies(timeout_eff[3]);
875		-
876		- rc = tpm_getcap(chip, TPM_CAP_PROP_TIS_DURATION, &cap,
877		- "attempting to determine the durations",
878		- sizeof(cap.duration));
879		- if (rc)
880		- return rc;
881		-
882		- chip->duration[TPM_SHORT] =
883		- usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_short));
884		- chip->duration[TPM_MEDIUM] =
885		- usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_medium));
886		- chip->duration[TPM_LONG] =
887		- usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_long));
888		- chip->duration[TPM_LONG_LONG] = 0; /* not used under 1.2 */
889		-
890		- /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above
891		- * value wrong and apparently reports msecs rather than usecs. So we
892		- * fix up the resulting too-small TPM_SHORT value to make things work.
893		- * We also scale the TPM_MEDIUM and -_LONG values by 1000.
894		- */
895		- if (chip->duration[TPM_SHORT] < (HZ / 100)) {
896		- chip->duration[TPM_SHORT] = HZ;
897		- chip->duration[TPM_MEDIUM] *= 1000;
898		- chip->duration[TPM_LONG] *= 1000;
899		- chip->duration_adjusted = true;
900		- dev_info(&chip->dev, "Adjusting TPM timeout parameters.");
901		- }
902		-
903		- chip->flags \|= TPM_CHIP_FLAG_HAVE_TIMEOUTS;
904		- return 0;
	244	+ if (chip->flags & TPM_CHIP_FLAG_TPM2)
	245	+ return tpm2_get_timeouts(chip);
	246	+ else
	247	+ return tpm1_get_timeouts(chip);
905	248	}
906	249	EXPORT_SYMBOL_GPL(tpm_get_timeouts);
907		-
908		-#define TPM_ORD_CONTINUE_SELFTEST 83
909		-#define CONTINUE_SELFTEST_RESULT_SIZE 10
910		-
911		-static const struct tpm_input_header continue_selftest_header = {
912		- .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND),
913		- .length = cpu_to_be32(10),
914		- .ordinal = cpu_to_be32(TPM_ORD_CONTINUE_SELFTEST),
915		-};
916		-
917		-/**
918		- * tpm_continue_selftest -- run TPM's selftest
919		- * @chip: TPM chip to use
920		- *
921		- * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
922		- * a TPM error code.
923		- */
924		-static int tpm_continue_selftest(struct tpm_chip *chip)
925		-{
926		- int rc;
927		- struct tpm_cmd_t cmd;
928		-
929		- cmd.header.in = continue_selftest_header;
930		- rc = tpm_transmit_cmd(chip, NULL, &cmd, CONTINUE_SELFTEST_RESULT_SIZE,
931		- 0, 0, "continue selftest");
932		- return rc;
933		-}
934		-
935		-#define TPM_ORDINAL_PCRREAD 21
936		-#define READ_PCR_RESULT_SIZE 30
937		-#define READ_PCR_RESULT_BODY_SIZE 20
938		-static const struct tpm_input_header pcrread_header = {
939		- .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND),
940		- .length = cpu_to_be32(14),
941		- .ordinal = cpu_to_be32(TPM_ORDINAL_PCRREAD)
942		-};
943		-
944		-int tpm_pcr_read_dev(struct tpm_chip chip, int pcr_idx, u8 res_buf)
945		-{
946		- int rc;
947		- struct tpm_cmd_t cmd;
948		-
949		- cmd.header.in = pcrread_header;
950		- cmd.params.pcrread_in.pcr_idx = cpu_to_be32(pcr_idx);
951		- rc = tpm_transmit_cmd(chip, NULL, &cmd, READ_PCR_RESULT_SIZE,
952		- READ_PCR_RESULT_BODY_SIZE, 0,
953		- "attempting to read a pcr value");
954		-
955		- if (rc == 0)
956		- memcpy(res_buf, cmd.params.pcrread_out.pcr_result,
957		- TPM_DIGEST_SIZE);
958		- return rc;
959		-}
960	250
961	251	/**
962	252	* tpm_is_tpm2 - do we a have a TPM2 chip?
..	..	@@ -987,189 +277,70 @@
987	277	* tpm_pcr_read - read a PCR value from SHA1 bank
988	278	* @chip: a &struct tpm_chip instance, %NULL for the default chip
989	279	* @pcr_idx: the PCR to be retrieved
990		- * @res_buf: the value of the PCR
	280	+ * @digest: the PCR bank and buffer current PCR value is written to
991	281	*
992	282	* Return: same as with tpm_transmit_cmd()
993	283	*/
994		-int tpm_pcr_read(struct tpm_chip chip, int pcr_idx, u8 res_buf)
	284	+int tpm_pcr_read(struct tpm_chip *chip, u32 pcr_idx,
	285	+ struct tpm_digest *digest)
995	286	{
996	287	int rc;
997	288
998	289	chip = tpm_find_get_ops(chip);
999	290	if (!chip)
1000	291	return -ENODEV;
	292	+
1001	293	if (chip->flags & TPM_CHIP_FLAG_TPM2)
1002		- rc = tpm2_pcr_read(chip, pcr_idx, res_buf);
	294	+ rc = tpm2_pcr_read(chip, pcr_idx, digest, NULL);
1003	295	else
1004		- rc = tpm_pcr_read_dev(chip, pcr_idx, res_buf);
	296	+ rc = tpm1_pcr_read(chip, pcr_idx, digest->digest);
	297	+
1005	298	tpm_put_ops(chip);
1006	299	return rc;
1007	300	}
1008	301	EXPORT_SYMBOL_GPL(tpm_pcr_read);
1009	302
1010		-#define TPM_ORD_PCR_EXTEND 20
1011		-#define EXTEND_PCR_RESULT_SIZE 34
1012		-#define EXTEND_PCR_RESULT_BODY_SIZE 20
1013		-static const struct tpm_input_header pcrextend_header = {
1014		- .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND),
1015		- .length = cpu_to_be32(34),
1016		- .ordinal = cpu_to_be32(TPM_ORD_PCR_EXTEND)
1017		-};
1018		-
1019		-static int tpm1_pcr_extend(struct tpm_chip chip, int pcr_idx, const u8 hash,
1020		- char *log_msg)
1021		-{
1022		- struct tpm_buf buf;
1023		- int rc;
1024		-
1025		- rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_PCR_EXTEND);
1026		- if (rc)
1027		- return rc;
1028		-
1029		- tpm_buf_append_u32(&buf, pcr_idx);
1030		- tpm_buf_append(&buf, hash, TPM_DIGEST_SIZE);
1031		-
1032		- rc = tpm_transmit_cmd(chip, NULL, buf.data, EXTEND_PCR_RESULT_SIZE,
1033		- EXTEND_PCR_RESULT_BODY_SIZE, 0, log_msg);
1034		- tpm_buf_destroy(&buf);
1035		- return rc;
1036		-}
1037		-
1038	303	/**
1039	304	* tpm_pcr_extend - extend a PCR value in SHA1 bank.
1040	305	* @chip: a &struct tpm_chip instance, %NULL for the default chip
1041	306	* @pcr_idx: the PCR to be retrieved
1042		- * @hash: the hash value used to extend the PCR value
	307	+ * @digests: array of tpm_digest structures used to extend PCRs
1043	308	*
1044		- * Note: with TPM 2.0 extends also those banks with a known digest size to the
1045		- * cryto subsystem in order to prevent malicious use of those PCR banks. In the
1046		- * future we should dynamically determine digest sizes.
	309	+ * Note: callers must pass a digest for every allocated PCR bank, in the same
	310	+ * order of the banks in chip->allocated_banks.
1047	311	*
1048	312	* Return: same as with tpm_transmit_cmd()
1049	313	*/
1050		-int tpm_pcr_extend(struct tpm_chip chip, int pcr_idx, const u8 hash)
	314	+int tpm_pcr_extend(struct tpm_chip *chip, u32 pcr_idx,
	315	+ struct tpm_digest *digests)
1051	316	{
1052	317	int rc;
1053		- struct tpm2_digest digest_list[ARRAY_SIZE(chip->active_banks)];
1054		- u32 count = 0;
1055	318	int i;
1056	319
1057	320	chip = tpm_find_get_ops(chip);
1058	321	if (!chip)
1059	322	return -ENODEV;
1060	323
1061		- if (chip->flags & TPM_CHIP_FLAG_TPM2) {
1062		- memset(digest_list, 0, sizeof(digest_list));
1063		-
1064		- for (i = 0; i < ARRAY_SIZE(chip->active_banks) &&
1065		- chip->active_banks[i] != TPM2_ALG_ERROR; i++) {
1066		- digest_list[i].alg_id = chip->active_banks[i];
1067		- memcpy(digest_list[i].digest, hash, TPM_DIGEST_SIZE);
1068		- count++;
	324	+ for (i = 0; i < chip->nr_allocated_banks; i++) {
	325	+ if (digests[i].alg_id != chip->allocated_banks[i].alg_id) {
	326	+ rc = -EINVAL;
	327	+ goto out;
1069	328	}
1070		-
1071		- rc = tpm2_pcr_extend(chip, pcr_idx, count, digest_list);
1072		- tpm_put_ops(chip);
1073		- return rc;
1074	329	}
1075	330
1076		- rc = tpm1_pcr_extend(chip, pcr_idx, hash,
	331	+ if (chip->flags & TPM_CHIP_FLAG_TPM2) {
	332	+ rc = tpm2_pcr_extend(chip, pcr_idx, digests);
	333	+ goto out;
	334	+ }
	335	+
	336	+ rc = tpm1_pcr_extend(chip, pcr_idx, digests[0].digest,
1077	337	"attempting extend a PCR value");
	338	+
	339	+out:
1078	340	tpm_put_ops(chip);
1079	341	return rc;
1080	342	}
1081	343	EXPORT_SYMBOL_GPL(tpm_pcr_extend);
1082		-
1083		-/**
1084		- * tpm_do_selftest - have the TPM continue its selftest and wait until it
1085		- * can receive further commands
1086		- * @chip: TPM chip to use
1087		- *
1088		- * Returns 0 on success, < 0 in case of fatal error or a value > 0 representing
1089		- * a TPM error code.
1090		- */
1091		-int tpm_do_selftest(struct tpm_chip *chip)
1092		-{
1093		- int rc;
1094		- unsigned int loops;
1095		- unsigned int delay_msec = 100;
1096		- unsigned long duration;
1097		- u8 dummy[TPM_DIGEST_SIZE];
1098		-
1099		- duration = tpm_calc_ordinal_duration(chip, TPM_ORD_CONTINUE_SELFTEST);
1100		-
1101		- loops = jiffies_to_msecs(duration) / delay_msec;
1102		-
1103		- rc = tpm_continue_selftest(chip);
1104		- if (rc == TPM_ERR_INVALID_POSTINIT) {
1105		- chip->flags \|= TPM_CHIP_FLAG_ALWAYS_POWERED;
1106		- dev_info(&chip->dev, "TPM not ready (%d)\n", rc);
1107		- }
1108		- /* This may fail if there was no TPM driver during a suspend/resume
1109		- * cycle; some may return 10 (BAD_ORDINAL), others 28 (FAILEDSELFTEST)
1110		- */
1111		- if (rc)
1112		- return rc;
1113		-
1114		- do {
1115		- /* Attempt to read a PCR value */
1116		- rc = tpm_pcr_read_dev(chip, 0, dummy);
1117		-
1118		- /* Some buggy TPMs will not respond to tpm_tis_ready() for
1119		- * around 300ms while the self test is ongoing, keep trying
1120		- * until the self test duration expires. */
1121		- if (rc == -ETIME) {
1122		- dev_info(
1123		- &chip->dev, HW_ERR
1124		- "TPM command timed out during continue self test");
1125		- tpm_msleep(delay_msec);
1126		- continue;
1127		- }
1128		-
1129		- if (rc == TPM_ERR_DISABLED \|\| rc == TPM_ERR_DEACTIVATED) {
1130		- dev_info(&chip->dev,
1131		- "TPM is disabled/deactivated (0x%X)\n", rc);
1132		- /* TPM is disabled and/or deactivated; driver can
1133		- * proceed and TPM does handle commands for
1134		- * suspend/resume correctly
1135		- */
1136		- return 0;
1137		- }
1138		- if (rc != TPM_WARN_DOING_SELFTEST)
1139		- return rc;
1140		- tpm_msleep(delay_msec);
1141		- } while (--loops > 0);
1142		-
1143		- return rc;
1144		-}
1145		-EXPORT_SYMBOL_GPL(tpm_do_selftest);
1146		-
1147		-/**
1148		- * tpm1_auto_startup - Perform the standard automatic TPM initialization
1149		- * sequence
1150		- * @chip: TPM chip to use
1151		- *
1152		- * Returns 0 on success, < 0 in case of fatal error.
1153		- */
1154		-int tpm1_auto_startup(struct tpm_chip *chip)
1155		-{
1156		- int rc;
1157		-
1158		- rc = tpm_get_timeouts(chip);
1159		- if (rc)
1160		- goto out;
1161		- rc = tpm_do_selftest(chip);
1162		- if (rc) {
1163		- dev_err(&chip->dev, "TPM self test failed\n");
1164		- goto out;
1165		- }
1166		-
1167		- return rc;
1168		-out:
1169		- if (rc > 0)
1170		- rc = -ENODEV;
1171		- return rc;
1172		-}
1173	344
1174	345	/**
1175	346	* tpm_send - send a TPM command
..	..	@@ -1181,27 +352,35 @@
1181	352	*/
1182	353	int tpm_send(struct tpm_chip chip, void cmd, size_t buflen)
1183	354	{
	355	+ struct tpm_buf buf;
1184	356	int rc;
1185	357
1186	358	chip = tpm_find_get_ops(chip);
1187	359	if (!chip)
1188	360	return -ENODEV;
1189	361
1190		- rc = tpm_transmit_cmd(chip, NULL, cmd, buflen, 0, 0,
1191		- "attempting to a send a command");
	362	+ buf.data = cmd;
	363	+ rc = tpm_transmit_cmd(chip, &buf, 0, "attempting to a send a command");
	364	+
1192	365	tpm_put_ops(chip);
1193	366	return rc;
1194	367	}
1195	368	EXPORT_SYMBOL_GPL(tpm_send);
1196	369
1197		-#define TPM_ORD_SAVESTATE 152
1198		-#define SAVESTATE_RESULT_SIZE 10
	370	+int tpm_auto_startup(struct tpm_chip *chip)
	371	+{
	372	+ int rc;
1199	373
1200		-static const struct tpm_input_header savestate_header = {
1201		- .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND),
1202		- .length = cpu_to_be32(10),
1203		- .ordinal = cpu_to_be32(TPM_ORD_SAVESTATE)
1204		-};
	374	+ if (!(chip->ops->flags & TPM_OPS_AUTO_STARTUP))
	375	+ return 0;
	376	+
	377	+ if (chip->flags & TPM_CHIP_FLAG_TPM2)
	378	+ rc = tpm2_auto_startup(chip);
	379	+ else
	380	+ rc = tpm1_auto_startup(chip);
	381	+
	382	+ return rc;
	383	+}
1205	384
1206	385	/*
1207	386	* We are about to suspend. Save the TPM state
..	..	@@ -1210,55 +389,29 @@
1210	389	int tpm_pm_suspend(struct device *dev)
1211	390	{
1212	391	struct tpm_chip *chip = dev_get_drvdata(dev);
1213		- struct tpm_cmd_t cmd;
1214		- int rc, try;
	392	+ int rc = 0;
1215	393
1216		- u8 dummy_hash[TPM_DIGEST_SIZE] = { 0 };
1217		-
1218		- if (chip == NULL)
	394	+ if (!chip)
1219	395	return -ENODEV;
1220	396
1221	397	if (chip->flags & TPM_CHIP_FLAG_ALWAYS_POWERED)
1222		- return 0;
	398	+ goto suspended;
1223	399
1224		- if (chip->flags & TPM_CHIP_FLAG_TPM2) {
1225		- tpm2_shutdown(chip, TPM2_SU_STATE);
1226		- return 0;
	400	+ if ((chip->flags & TPM_CHIP_FLAG_FIRMWARE_POWER_MANAGED) &&
	401	+ !pm_suspend_via_firmware())
	402	+ goto suspended;
	403	+
	404	+ rc = tpm_try_get_ops(chip);
	405	+ if (!rc) {
	406	+ if (chip->flags & TPM_CHIP_FLAG_TPM2)
	407	+ tpm2_shutdown(chip, TPM2_SU_STATE);
	408	+ else
	409	+ rc = tpm1_pm_suspend(chip, tpm_suspend_pcr);
	410	+
	411	+ tpm_put_ops(chip);
1227	412	}
1228	413
1229		- /* for buggy tpm, flush pcrs with extend to selected dummy */
1230		- if (tpm_suspend_pcr)
1231		- rc = tpm1_pcr_extend(chip, tpm_suspend_pcr, dummy_hash,
1232		- "extending dummy pcr before suspend");
1233		-
1234		- /* now do the actual savestate */
1235		- for (try = 0; try < TPM_RETRY; try++) {
1236		- cmd.header.in = savestate_header;
1237		- rc = tpm_transmit_cmd(chip, NULL, &cmd, SAVESTATE_RESULT_SIZE,
1238		- 0, 0, NULL);
1239		-
1240		- /*
1241		- * If the TPM indicates that it is too busy to respond to
1242		- * this command then retry before giving up. It can take
1243		- * several seconds for this TPM to be ready.
1244		- *
1245		- * This can happen if the TPM has already been sent the
1246		- * SaveState command before the driver has loaded. TCG 1.2
1247		- * specification states that any communication after SaveState
1248		- * may cause the TPM to invalidate previously saved state.
1249		- */
1250		- if (rc != TPM_WARN_RETRY)
1251		- break;
1252		- tpm_msleep(TPM_TIMEOUT_RETRY);
1253		- }
1254		-
1255		- if (rc)
1256		- dev_err(&chip->dev,
1257		- "Error (%d) sending savestate before suspend\n", rc);
1258		- else if (try > 0)
1259		- dev_warn(&chip->dev, "TPM savestate took %dms\n",
1260		- try * TPM_TIMEOUT_RETRY);
1261		-
	414	+suspended:
1262	415	return rc;
1263	416	}
1264	417	EXPORT_SYMBOL_GPL(tpm_pm_suspend);
..	..	@@ -1278,133 +431,34 @@
1278	431	}
1279	432	EXPORT_SYMBOL_GPL(tpm_pm_resume);
1280	433
1281		-#define TPM_GETRANDOM_RESULT_SIZE 18
1282		-static const struct tpm_input_header tpm_getrandom_header = {
1283		- .tag = cpu_to_be16(TPM_TAG_RQU_COMMAND),
1284		- .length = cpu_to_be32(14),
1285		- .ordinal = cpu_to_be32(TPM_ORD_GET_RANDOM)
1286		-};
1287		-
1288	434	/**
1289	435	* tpm_get_random() - get random bytes from the TPM's RNG
1290	436	* @chip: a &struct tpm_chip instance, %NULL for the default chip
1291	437	* @out: destination buffer for the random bytes
1292	438	* @max: the max number of bytes to write to @out
1293	439	*
1294		- * Return: same as with tpm_transmit_cmd()
	440	+ * Return: number of random bytes read or a negative error value.
1295	441	*/
1296	442	int tpm_get_random(struct tpm_chip chip, u8 out, size_t max)
1297	443	{
1298		- struct tpm_cmd_t tpm_cmd;
1299		- u32 recd, num_bytes = min_t(u32, max, TPM_MAX_RNG_DATA), rlength;
1300		- int err, total = 0, retries = 5;
1301		- u8 *dest = out;
	444	+ int rc;
1302	445
1303		- if (!out \|\| !num_bytes \|\| max > TPM_MAX_RNG_DATA)
	446	+ if (!out \|\| max > TPM_MAX_RNG_DATA)
1304	447	return -EINVAL;
1305	448
1306	449	chip = tpm_find_get_ops(chip);
1307	450	if (!chip)
1308	451	return -ENODEV;
1309	452
1310		- if (chip->flags & TPM_CHIP_FLAG_TPM2) {
1311		- err = tpm2_get_random(chip, out, max);
1312		- tpm_put_ops(chip);
1313		- return err;
1314		- }
1315		-
1316		- do {
1317		- tpm_cmd.header.in = tpm_getrandom_header;
1318		- tpm_cmd.params.getrandom_in.num_bytes = cpu_to_be32(num_bytes);
1319		-
1320		- err = tpm_transmit_cmd(chip, NULL, &tpm_cmd,
1321		- TPM_GETRANDOM_RESULT_SIZE + num_bytes,
1322		- offsetof(struct tpm_getrandom_out,
1323		- rng_data),
1324		- 0, "attempting get random");
1325		- if (err)
1326		- break;
1327		-
1328		- recd = be32_to_cpu(tpm_cmd.params.getrandom_out.rng_data_len);
1329		- if (recd > num_bytes) {
1330		- total = -EFAULT;
1331		- break;
1332		- }
1333		-
1334		- rlength = be32_to_cpu(tpm_cmd.header.out.length);
1335		- if (rlength < TPM_HEADER_SIZE +
1336		- offsetof(struct tpm_getrandom_out, rng_data) +
1337		- recd) {
1338		- total = -EFAULT;
1339		- break;
1340		- }
1341		- memcpy(dest, tpm_cmd.params.getrandom_out.rng_data, recd);
1342		-
1343		- dest += recd;
1344		- total += recd;
1345		- num_bytes -= recd;
1346		- } while (retries-- && total < max);
	453	+ if (chip->flags & TPM_CHIP_FLAG_TPM2)
	454	+ rc = tpm2_get_random(chip, out, max);
	455	+ else
	456	+ rc = tpm1_get_random(chip, out, max);
1347	457
1348	458	tpm_put_ops(chip);
1349		- return total ? total : -EIO;
	459	+ return rc;
1350	460	}
1351	461	EXPORT_SYMBOL_GPL(tpm_get_random);
1352		-
1353		-/**
1354		- * tpm_seal_trusted() - seal a trusted key payload
1355		- * @chip: a &struct tpm_chip instance, %NULL for the default chip
1356		- * @options: authentication values and other options
1357		- * @payload: the key data in clear and encrypted form
1358		- *
1359		- * Note: only TPM 2.0 chip are supported. TPM 1.x implementation is located in
1360		- * the keyring subsystem.
1361		- *
1362		- * Return: same as with tpm_transmit_cmd()
1363		- */
1364		-int tpm_seal_trusted(struct tpm_chip chip, struct trusted_key_payload payload,
1365		- struct trusted_key_options *options)
1366		-{
1367		- int rc;
1368		-
1369		- chip = tpm_find_get_ops(chip);
1370		- if (!chip \|\| !(chip->flags & TPM_CHIP_FLAG_TPM2))
1371		- return -ENODEV;
1372		-
1373		- rc = tpm2_seal_trusted(chip, payload, options);
1374		-
1375		- tpm_put_ops(chip);
1376		- return rc;
1377		-}
1378		-EXPORT_SYMBOL_GPL(tpm_seal_trusted);
1379		-
1380		-/**
1381		- * tpm_unseal_trusted() - unseal a trusted key
1382		- * @chip: a &struct tpm_chip instance, %NULL for the default chip
1383		- * @options: authentication values and other options
1384		- * @payload: the key data in clear and encrypted form
1385		- *
1386		- * Note: only TPM 2.0 chip are supported. TPM 1.x implementation is located in
1387		- * the keyring subsystem.
1388		- *
1389		- * Return: same as with tpm_transmit_cmd()
1390		- */
1391		-int tpm_unseal_trusted(struct tpm_chip *chip,
1392		- struct trusted_key_payload *payload,
1393		- struct trusted_key_options *options)
1394		-{
1395		- int rc;
1396		-
1397		- chip = tpm_find_get_ops(chip);
1398		- if (!chip \|\| !(chip->flags & TPM_CHIP_FLAG_TPM2))
1399		- return -ENODEV;
1400		-
1401		- rc = tpm2_unseal_trusted(chip, payload, options);
1402		-
1403		- tpm_put_ops(chip);
1404		-
1405		- return rc;
1406		-}
1407		-EXPORT_SYMBOL_GPL(tpm_unseal_trusted);
1408	462
1409	463	static int __init tpm_init(void)
1410	464	{
..	..	@@ -1419,19 +473,32 @@
1419	473	tpmrm_class = class_create(THIS_MODULE, "tpmrm");
1420	474	if (IS_ERR(tpmrm_class)) {
1421	475	pr_err("couldn't create tpmrm class\n");
1422		- class_destroy(tpm_class);
1423		- return PTR_ERR(tpmrm_class);
	476	+ rc = PTR_ERR(tpmrm_class);
	477	+ goto out_destroy_tpm_class;
1424	478	}
1425	479
1426	480	rc = alloc_chrdev_region(&tpm_devt, 0, 2*TPM_NUM_DEVICES, "tpm");
1427	481	if (rc < 0) {
1428	482	pr_err("tpm: failed to allocate char dev region\n");
1429		- class_destroy(tpmrm_class);
1430		- class_destroy(tpm_class);
1431		- return rc;
	483	+ goto out_destroy_tpmrm_class;
	484	+ }
	485	+
	486	+ rc = tpm_dev_common_init();
	487	+ if (rc) {
	488	+ pr_err("tpm: failed to allocate char dev region\n");
	489	+ goto out_unreg_chrdev;
1432	490	}
1433	491
1434	492	return 0;
	493	+
	494	+out_unreg_chrdev:
	495	+ unregister_chrdev_region(tpm_devt, 2 * TPM_NUM_DEVICES);
	496	+out_destroy_tpmrm_class:
	497	+ class_destroy(tpmrm_class);
	498	+out_destroy_tpm_class:
	499	+ class_destroy(tpm_class);
	500	+
	501	+ return rc;
1435	502	}
1436	503
1437	504	static void __exit tpm_exit(void)
..	..	@@ -1440,6 +507,7 @@
1440	507	class_destroy(tpm_class);
1441	508	class_destroy(tpmrm_class);
1442	509	unregister_chrdev_region(tpm_devt, 2*TPM_NUM_DEVICES);
	510	+ tpm_dev_common_exit();
1443	511	}
1444	512
1445	513	subsys_initcall(tpm_init);