]>
Commit | Line | Data |
---|---|---|
83d290c5 | 1 | // SPDX-License-Identifier: GPL-2.0+ |
e76cb927 SG |
2 | /* |
3 | * Copyright (c) 2015 Google, Inc | |
e76cb927 SG |
4 | */ |
5 | ||
6 | #include <common.h> | |
7 | #include <command.h> | |
9a3b4ceb | 8 | #include <cpu_func.h> |
d677bfe2 | 9 | #include <tpm-v1.h> |
abdc7b8a | 10 | #include "tpm-user-utils.h" |
e76cb927 SG |
11 | |
12 | /* Prints error and returns on failure */ | |
13 | #define TPM_CHECK(tpm_command) do { \ | |
14 | uint32_t result; \ | |
15 | \ | |
16 | result = (tpm_command); \ | |
17 | if (result != TPM_SUCCESS) { \ | |
18 | printf("TEST FAILED: line %d: " #tpm_command ": 0x%x\n", \ | |
19 | __LINE__, result); \ | |
20 | return result; \ | |
21 | } \ | |
22 | } while (0) | |
23 | ||
24 | #define INDEX0 0xda70 | |
25 | #define INDEX1 0xda71 | |
26 | #define INDEX2 0xda72 | |
27 | #define INDEX3 0xda73 | |
28 | #define INDEX_INITIALISED 0xda80 | |
29 | #define PHYS_PRESENCE 4 | |
30 | #define PRESENCE 8 | |
31 | ||
abdc7b8a | 32 | static uint32_t TlclStartupIfNeeded(struct udevice *dev) |
e76cb927 | 33 | { |
abdc7b8a | 34 | uint32_t result = tpm_startup(dev, TPM_ST_CLEAR); |
e76cb927 SG |
35 | |
36 | return result == TPM_INVALID_POSTINIT ? TPM_SUCCESS : result; | |
37 | } | |
38 | ||
abdc7b8a | 39 | static int test_timer(struct udevice *dev) |
e76cb927 SG |
40 | { |
41 | printf("get_timer(0) = %lu\n", get_timer(0)); | |
42 | return 0; | |
43 | } | |
44 | ||
abdc7b8a SG |
45 | static uint32_t tpm_get_flags(struct udevice *dev, uint8_t *disable, |
46 | uint8_t *deactivated, uint8_t *nvlocked) | |
e76cb927 SG |
47 | { |
48 | struct tpm_permanent_flags pflags; | |
49 | uint32_t result; | |
50 | ||
abdc7b8a | 51 | result = tpm_get_permanent_flags(dev, &pflags); |
e76cb927 SG |
52 | if (result) |
53 | return result; | |
54 | if (disable) | |
55 | *disable = pflags.disable; | |
56 | if (deactivated) | |
57 | *deactivated = pflags.deactivated; | |
58 | if (nvlocked) | |
59 | *nvlocked = pflags.nv_locked; | |
60 | debug("TPM: Got flags disable=%d, deactivated=%d, nvlocked=%d\n", | |
61 | pflags.disable, pflags.deactivated, pflags.nv_locked); | |
62 | ||
63 | return 0; | |
64 | } | |
65 | ||
abdc7b8a | 66 | static uint32_t tpm_nv_write_value_lock(struct udevice *dev, uint32_t index) |
e76cb927 SG |
67 | { |
68 | debug("TPM: Write lock 0x%x\n", index); | |
69 | ||
abdc7b8a | 70 | return tpm_nv_write_value(dev, index, NULL, 0); |
e76cb927 SG |
71 | } |
72 | ||
abdc7b8a | 73 | static int tpm_is_owned(struct udevice *dev) |
e76cb927 SG |
74 | { |
75 | uint8_t response[TPM_PUBEK_SIZE]; | |
76 | uint32_t result; | |
77 | ||
abdc7b8a | 78 | result = tpm_read_pubek(dev, response, sizeof(response)); |
e76cb927 SG |
79 | |
80 | return result != TPM_SUCCESS; | |
81 | } | |
82 | ||
abdc7b8a | 83 | static int test_early_extend(struct udevice *dev) |
e76cb927 SG |
84 | { |
85 | uint8_t value_in[20]; | |
86 | uint8_t value_out[20]; | |
87 | ||
88 | printf("Testing earlyextend ..."); | |
abdc7b8a SG |
89 | tpm_init(dev); |
90 | TPM_CHECK(tpm_startup(dev, TPM_ST_CLEAR)); | |
91 | TPM_CHECK(tpm_continue_self_test(dev)); | |
92 | TPM_CHECK(tpm_extend(dev, 1, value_in, value_out)); | |
e76cb927 SG |
93 | printf("done\n"); |
94 | return 0; | |
95 | } | |
96 | ||
abdc7b8a | 97 | static int test_early_nvram(struct udevice *dev) |
e76cb927 SG |
98 | { |
99 | uint32_t x; | |
100 | ||
101 | printf("Testing earlynvram ..."); | |
abdc7b8a SG |
102 | tpm_init(dev); |
103 | TPM_CHECK(tpm_startup(dev, TPM_ST_CLEAR)); | |
104 | TPM_CHECK(tpm_continue_self_test(dev)); | |
105 | TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE)); | |
106 | TPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x))); | |
e76cb927 SG |
107 | printf("done\n"); |
108 | return 0; | |
109 | } | |
110 | ||
abdc7b8a | 111 | static int test_early_nvram2(struct udevice *dev) |
e76cb927 SG |
112 | { |
113 | uint32_t x; | |
114 | ||
115 | printf("Testing earlynvram2 ..."); | |
abdc7b8a SG |
116 | tpm_init(dev); |
117 | TPM_CHECK(tpm_startup(dev, TPM_ST_CLEAR)); | |
118 | TPM_CHECK(tpm_continue_self_test(dev)); | |
119 | TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE)); | |
120 | TPM_CHECK(tpm_nv_write_value(dev, INDEX0, (uint8_t *)&x, sizeof(x))); | |
e76cb927 SG |
121 | printf("done\n"); |
122 | return 0; | |
123 | } | |
124 | ||
abdc7b8a | 125 | static int test_enable(struct udevice *dev) |
e76cb927 SG |
126 | { |
127 | uint8_t disable = 0, deactivated = 0; | |
128 | ||
129 | printf("Testing enable ...\n"); | |
abdc7b8a SG |
130 | tpm_init(dev); |
131 | TPM_CHECK(TlclStartupIfNeeded(dev)); | |
132 | TPM_CHECK(tpm_self_test_full(dev)); | |
133 | TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE)); | |
134 | TPM_CHECK(tpm_get_flags(dev, &disable, &deactivated, NULL)); | |
e76cb927 | 135 | printf("\tdisable is %d, deactivated is %d\n", disable, deactivated); |
abdc7b8a SG |
136 | TPM_CHECK(tpm_physical_enable(dev)); |
137 | TPM_CHECK(tpm_physical_set_deactivated(dev, 0)); | |
138 | TPM_CHECK(tpm_get_flags(dev, &disable, &deactivated, NULL)); | |
e76cb927 SG |
139 | printf("\tdisable is %d, deactivated is %d\n", disable, deactivated); |
140 | if (disable == 1 || deactivated == 1) | |
141 | printf("\tfailed to enable or activate\n"); | |
142 | printf("\tdone\n"); | |
143 | return 0; | |
144 | } | |
145 | ||
146 | #define reboot() do { \ | |
147 | printf("\trebooting...\n"); \ | |
148 | reset_cpu(0); \ | |
149 | } while (0) | |
150 | ||
abdc7b8a | 151 | static int test_fast_enable(struct udevice *dev) |
e76cb927 SG |
152 | { |
153 | uint8_t disable = 0, deactivated = 0; | |
154 | int i; | |
155 | ||
156 | printf("Testing fastenable ...\n"); | |
abdc7b8a SG |
157 | tpm_init(dev); |
158 | TPM_CHECK(TlclStartupIfNeeded(dev)); | |
159 | TPM_CHECK(tpm_self_test_full(dev)); | |
160 | TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE)); | |
161 | TPM_CHECK(tpm_get_flags(dev, &disable, &deactivated, NULL)); | |
e76cb927 SG |
162 | printf("\tdisable is %d, deactivated is %d\n", disable, deactivated); |
163 | for (i = 0; i < 2; i++) { | |
abdc7b8a SG |
164 | TPM_CHECK(tpm_force_clear(dev)); |
165 | TPM_CHECK(tpm_get_flags(dev, &disable, &deactivated, NULL)); | |
e76cb927 SG |
166 | printf("\tdisable is %d, deactivated is %d\n", disable, |
167 | deactivated); | |
168 | assert(disable == 1 && deactivated == 1); | |
abdc7b8a SG |
169 | TPM_CHECK(tpm_physical_enable(dev)); |
170 | TPM_CHECK(tpm_physical_set_deactivated(dev, 0)); | |
171 | TPM_CHECK(tpm_get_flags(dev, &disable, &deactivated, NULL)); | |
e76cb927 SG |
172 | printf("\tdisable is %d, deactivated is %d\n", disable, |
173 | deactivated); | |
174 | assert(disable == 0 && deactivated == 0); | |
175 | } | |
176 | printf("\tdone\n"); | |
177 | return 0; | |
178 | } | |
179 | ||
abdc7b8a | 180 | static int test_global_lock(struct udevice *dev) |
e76cb927 SG |
181 | { |
182 | uint32_t zero = 0; | |
183 | uint32_t result; | |
184 | uint32_t x; | |
185 | ||
186 | printf("Testing globallock ...\n"); | |
abdc7b8a SG |
187 | tpm_init(dev); |
188 | TPM_CHECK(TlclStartupIfNeeded(dev)); | |
189 | TPM_CHECK(tpm_self_test_full(dev)); | |
190 | TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE)); | |
191 | TPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x))); | |
192 | TPM_CHECK(tpm_nv_write_value(dev, INDEX0, (uint8_t *)&zero, | |
e76cb927 | 193 | sizeof(uint32_t))); |
abdc7b8a SG |
194 | TPM_CHECK(tpm_nv_read_value(dev, INDEX1, (uint8_t *)&x, sizeof(x))); |
195 | TPM_CHECK(tpm_nv_write_value(dev, INDEX1, (uint8_t *)&zero, | |
e76cb927 | 196 | sizeof(uint32_t))); |
abdc7b8a | 197 | TPM_CHECK(tpm_set_global_lock(dev)); |
e76cb927 SG |
198 | /* Verifies that write to index0 fails */ |
199 | x = 1; | |
abdc7b8a | 200 | result = tpm_nv_write_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)); |
e76cb927 | 201 | assert(result == TPM_AREA_LOCKED); |
abdc7b8a | 202 | TPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x))); |
e76cb927 SG |
203 | assert(x == 0); |
204 | /* Verifies that write to index1 is still possible */ | |
205 | x = 2; | |
abdc7b8a SG |
206 | TPM_CHECK(tpm_nv_write_value(dev, INDEX1, (uint8_t *)&x, sizeof(x))); |
207 | TPM_CHECK(tpm_nv_read_value(dev, INDEX1, (uint8_t *)&x, sizeof(x))); | |
e76cb927 SG |
208 | assert(x == 2); |
209 | /* Turns off PP */ | |
abdc7b8a | 210 | tpm_tsc_physical_presence(dev, PHYS_PRESENCE); |
e76cb927 SG |
211 | /* Verifies that write to index1 fails */ |
212 | x = 3; | |
abdc7b8a | 213 | result = tpm_nv_write_value(dev, INDEX1, (uint8_t *)&x, sizeof(x)); |
e76cb927 | 214 | assert(result == TPM_BAD_PRESENCE); |
abdc7b8a | 215 | TPM_CHECK(tpm_nv_read_value(dev, INDEX1, (uint8_t *)&x, sizeof(x))); |
e76cb927 SG |
216 | assert(x == 2); |
217 | printf("\tdone\n"); | |
218 | return 0; | |
219 | } | |
220 | ||
abdc7b8a | 221 | static int test_lock(struct udevice *dev) |
e76cb927 SG |
222 | { |
223 | printf("Testing lock ...\n"); | |
abdc7b8a SG |
224 | tpm_init(dev); |
225 | tpm_startup(dev, TPM_ST_CLEAR); | |
226 | tpm_self_test_full(dev); | |
227 | tpm_tsc_physical_presence(dev, PRESENCE); | |
228 | tpm_nv_write_value_lock(dev, INDEX0); | |
e76cb927 SG |
229 | printf("\tLocked 0x%x\n", INDEX0); |
230 | printf("\tdone\n"); | |
231 | return 0; | |
232 | } | |
233 | ||
abdc7b8a | 234 | static void initialise_spaces(struct udevice *dev) |
e76cb927 SG |
235 | { |
236 | uint32_t zero = 0; | |
237 | uint32_t perm = TPM_NV_PER_WRITE_STCLEAR | TPM_NV_PER_PPWRITE; | |
238 | ||
239 | printf("\tInitialising spaces\n"); | |
abdc7b8a SG |
240 | tpm_nv_set_locked(dev); /* useful only the first time */ |
241 | tpm_nv_define_space(dev, INDEX0, perm, 4); | |
242 | tpm_nv_write_value(dev, INDEX0, (uint8_t *)&zero, 4); | |
243 | tpm_nv_define_space(dev, INDEX1, perm, 4); | |
244 | tpm_nv_write_value(dev, INDEX1, (uint8_t *)&zero, 4); | |
245 | tpm_nv_define_space(dev, INDEX2, perm, 4); | |
246 | tpm_nv_write_value(dev, INDEX2, (uint8_t *)&zero, 4); | |
247 | tpm_nv_define_space(dev, INDEX3, perm, 4); | |
248 | tpm_nv_write_value(dev, INDEX3, (uint8_t *)&zero, 4); | |
e76cb927 SG |
249 | perm = TPM_NV_PER_READ_STCLEAR | TPM_NV_PER_WRITE_STCLEAR | |
250 | TPM_NV_PER_PPWRITE; | |
abdc7b8a | 251 | tpm_nv_define_space(dev, INDEX_INITIALISED, perm, 1); |
e76cb927 SG |
252 | } |
253 | ||
abdc7b8a | 254 | static int test_readonly(struct udevice *dev) |
e76cb927 SG |
255 | { |
256 | uint8_t c; | |
257 | uint32_t index_0, index_1, index_2, index_3; | |
258 | int read0, read1, read2, read3; | |
259 | ||
260 | printf("Testing readonly ...\n"); | |
abdc7b8a SG |
261 | tpm_init(dev); |
262 | tpm_startup(dev, TPM_ST_CLEAR); | |
263 | tpm_self_test_full(dev); | |
264 | tpm_tsc_physical_presence(dev, PRESENCE); | |
e76cb927 SG |
265 | /* |
266 | * Checks if initialisation has completed by trying to read-lock a | |
267 | * space that's created at the end of initialisation | |
268 | */ | |
abdc7b8a | 269 | if (tpm_nv_read_value(dev, INDEX_INITIALISED, &c, 0) == TPM_BADINDEX) { |
e76cb927 | 270 | /* The initialisation did not complete */ |
abdc7b8a | 271 | initialise_spaces(dev); |
e76cb927 SG |
272 | } |
273 | ||
274 | /* Checks if spaces are OK or messed up */ | |
abdc7b8a SG |
275 | read0 = tpm_nv_read_value(dev, INDEX0, (uint8_t *)&index_0, |
276 | sizeof(index_0)); | |
277 | read1 = tpm_nv_read_value(dev, INDEX1, (uint8_t *)&index_1, | |
278 | sizeof(index_1)); | |
279 | read2 = tpm_nv_read_value(dev, INDEX2, (uint8_t *)&index_2, | |
280 | sizeof(index_2)); | |
281 | read3 = tpm_nv_read_value(dev, INDEX3, (uint8_t *)&index_3, | |
282 | sizeof(index_3)); | |
e76cb927 SG |
283 | if (read0 || read1 || read2 || read3) { |
284 | printf("Invalid contents\n"); | |
285 | return 0; | |
286 | } | |
287 | ||
288 | /* | |
289 | * Writes space, and locks it. Then attempts to write again. | |
290 | * I really wish I could use the imperative. | |
291 | */ | |
292 | index_0 += 1; | |
abdc7b8a SG |
293 | if (tpm_nv_write_value(dev, INDEX0, (uint8_t *)&index_0, |
294 | sizeof(index_0) != | |
e76cb927 | 295 | TPM_SUCCESS)) { |
9b643e31 | 296 | pr_err("\tcould not write index 0\n"); |
e76cb927 | 297 | } |
abdc7b8a SG |
298 | tpm_nv_write_value_lock(dev, INDEX0); |
299 | if (tpm_nv_write_value(dev, INDEX0, (uint8_t *)&index_0, | |
300 | sizeof(index_0)) == | |
e76cb927 | 301 | TPM_SUCCESS) |
9b643e31 | 302 | pr_err("\tindex 0 is not locked\n"); |
e76cb927 SG |
303 | |
304 | printf("\tdone\n"); | |
305 | return 0; | |
306 | } | |
307 | ||
abdc7b8a | 308 | static int test_redefine_unowned(struct udevice *dev) |
e76cb927 SG |
309 | { |
310 | uint32_t perm; | |
311 | uint32_t result; | |
312 | uint32_t x; | |
313 | ||
314 | printf("Testing redefine_unowned ..."); | |
abdc7b8a SG |
315 | tpm_init(dev); |
316 | TPM_CHECK(TlclStartupIfNeeded(dev)); | |
317 | TPM_CHECK(tpm_self_test_full(dev)); | |
318 | TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE)); | |
319 | assert(!tpm_is_owned(dev)); | |
e76cb927 SG |
320 | |
321 | /* Ensures spaces exist. */ | |
abdc7b8a SG |
322 | TPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x))); |
323 | TPM_CHECK(tpm_nv_read_value(dev, INDEX1, (uint8_t *)&x, sizeof(x))); | |
e76cb927 SG |
324 | |
325 | /* Redefines spaces a couple of times. */ | |
326 | perm = TPM_NV_PER_PPWRITE | TPM_NV_PER_GLOBALLOCK; | |
abdc7b8a SG |
327 | TPM_CHECK(tpm_nv_define_space(dev, INDEX0, perm, 2 * sizeof(uint32_t))); |
328 | TPM_CHECK(tpm_nv_define_space(dev, INDEX0, perm, sizeof(uint32_t))); | |
e76cb927 | 329 | perm = TPM_NV_PER_PPWRITE; |
abdc7b8a SG |
330 | TPM_CHECK(tpm_nv_define_space(dev, INDEX1, perm, 2 * sizeof(uint32_t))); |
331 | TPM_CHECK(tpm_nv_define_space(dev, INDEX1, perm, sizeof(uint32_t))); | |
e76cb927 SG |
332 | |
333 | /* Sets the global lock */ | |
abdc7b8a | 334 | tpm_set_global_lock(dev); |
e76cb927 SG |
335 | |
336 | /* Verifies that index0 cannot be redefined */ | |
abdc7b8a | 337 | result = tpm_nv_define_space(dev, INDEX0, perm, sizeof(uint32_t)); |
e76cb927 SG |
338 | assert(result == TPM_AREA_LOCKED); |
339 | ||
340 | /* Checks that index1 can */ | |
abdc7b8a SG |
341 | TPM_CHECK(tpm_nv_define_space(dev, INDEX1, perm, 2 * sizeof(uint32_t))); |
342 | TPM_CHECK(tpm_nv_define_space(dev, INDEX1, perm, sizeof(uint32_t))); | |
e76cb927 SG |
343 | |
344 | /* Turns off PP */ | |
abdc7b8a | 345 | tpm_tsc_physical_presence(dev, PHYS_PRESENCE); |
e76cb927 SG |
346 | |
347 | /* Verifies that neither index0 nor index1 can be redefined */ | |
abdc7b8a | 348 | result = tpm_nv_define_space(dev, INDEX0, perm, sizeof(uint32_t)); |
e76cb927 | 349 | assert(result == TPM_BAD_PRESENCE); |
abdc7b8a | 350 | result = tpm_nv_define_space(dev, INDEX1, perm, sizeof(uint32_t)); |
e76cb927 SG |
351 | assert(result == TPM_BAD_PRESENCE); |
352 | ||
353 | printf("done\n"); | |
354 | return 0; | |
355 | } | |
356 | ||
357 | #define PERMPPGL (TPM_NV_PER_PPWRITE | TPM_NV_PER_GLOBALLOCK) | |
358 | #define PERMPP TPM_NV_PER_PPWRITE | |
359 | ||
abdc7b8a | 360 | static int test_space_perm(struct udevice *dev) |
e76cb927 SG |
361 | { |
362 | uint32_t perm; | |
363 | ||
364 | printf("Testing spaceperm ..."); | |
abdc7b8a SG |
365 | tpm_init(dev); |
366 | TPM_CHECK(TlclStartupIfNeeded(dev)); | |
367 | TPM_CHECK(tpm_continue_self_test(dev)); | |
368 | TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE)); | |
369 | TPM_CHECK(tpm_get_permissions(dev, INDEX0, &perm)); | |
e76cb927 | 370 | assert((perm & PERMPPGL) == PERMPPGL); |
abdc7b8a | 371 | TPM_CHECK(tpm_get_permissions(dev, INDEX1, &perm)); |
e76cb927 SG |
372 | assert((perm & PERMPP) == PERMPP); |
373 | printf("done\n"); | |
374 | return 0; | |
375 | } | |
376 | ||
abdc7b8a | 377 | static int test_startup(struct udevice *dev) |
e76cb927 SG |
378 | { |
379 | uint32_t result; | |
abdc7b8a | 380 | |
e76cb927 SG |
381 | printf("Testing startup ...\n"); |
382 | ||
abdc7b8a SG |
383 | tpm_init(dev); |
384 | result = tpm_startup(dev, TPM_ST_CLEAR); | |
e76cb927 SG |
385 | if (result != 0 && result != TPM_INVALID_POSTINIT) |
386 | printf("\ttpm startup failed with 0x%x\n", result); | |
abdc7b8a | 387 | result = tpm_get_flags(dev, NULL, NULL, NULL); |
e76cb927 SG |
388 | if (result != 0) |
389 | printf("\ttpm getflags failed with 0x%x\n", result); | |
390 | printf("\texecuting SelfTestFull\n"); | |
abdc7b8a SG |
391 | tpm_self_test_full(dev); |
392 | result = tpm_get_flags(dev, NULL, NULL, NULL); | |
e76cb927 SG |
393 | if (result != 0) |
394 | printf("\ttpm getflags failed with 0x%x\n", result); | |
395 | printf("\tdone\n"); | |
396 | return 0; | |
397 | } | |
398 | ||
399 | /* | |
400 | * Runs [op] and ensures it returns success and doesn't run longer than | |
401 | * [time_limit] in milliseconds. | |
402 | */ | |
403 | #define TTPM_CHECK(op, time_limit) do { \ | |
404 | ulong start, time; \ | |
405 | uint32_t __result; \ | |
406 | \ | |
407 | start = get_timer(0); \ | |
408 | __result = op; \ | |
409 | if (__result != TPM_SUCCESS) { \ | |
410 | printf("\t" #op ": error 0x%x\n", __result); \ | |
411 | return -1; \ | |
412 | } \ | |
413 | time = get_timer(start); \ | |
414 | printf("\t" #op ": %lu ms\n", time); \ | |
415 | if (time > (ulong)time_limit) { \ | |
416 | printf("\t" #op " exceeded " #time_limit " ms\n"); \ | |
417 | } \ | |
418 | } while (0) | |
419 | ||
420 | ||
abdc7b8a | 421 | static int test_timing(struct udevice *dev) |
e76cb927 | 422 | { |
e76cb927 | 423 | uint8_t in[20], out[20]; |
abdc7b8a | 424 | uint32_t x; |
e76cb927 SG |
425 | |
426 | printf("Testing timing ..."); | |
abdc7b8a SG |
427 | tpm_init(dev); |
428 | TTPM_CHECK(TlclStartupIfNeeded(dev), 50); | |
429 | TTPM_CHECK(tpm_continue_self_test(dev), 100); | |
430 | TTPM_CHECK(tpm_self_test_full(dev), 1000); | |
431 | TTPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE), 100); | |
432 | TTPM_CHECK(tpm_nv_write_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)), | |
433 | 100); | |
434 | TTPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)), | |
435 | 100); | |
436 | TTPM_CHECK(tpm_extend(dev, 0, in, out), 200); | |
437 | TTPM_CHECK(tpm_set_global_lock(dev), 50); | |
438 | TTPM_CHECK(tpm_tsc_physical_presence(dev, PHYS_PRESENCE), 100); | |
e76cb927 SG |
439 | printf("done\n"); |
440 | return 0; | |
441 | } | |
442 | ||
443 | #define TPM_MAX_NV_WRITES_NOOWNER 64 | |
444 | ||
abdc7b8a | 445 | static int test_write_limit(struct udevice *dev) |
e76cb927 | 446 | { |
e76cb927 | 447 | uint32_t result; |
abdc7b8a | 448 | int i; |
e76cb927 | 449 | |
abdc7b8a SG |
450 | printf("Testing writelimit ...\n"); |
451 | tpm_init(dev); | |
452 | TPM_CHECK(TlclStartupIfNeeded(dev)); | |
453 | TPM_CHECK(tpm_self_test_full(dev)); | |
454 | TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE)); | |
455 | TPM_CHECK(tpm_force_clear(dev)); | |
456 | TPM_CHECK(tpm_physical_enable(dev)); | |
457 | TPM_CHECK(tpm_physical_set_deactivated(dev, 0)); | |
e76cb927 SG |
458 | |
459 | for (i = 0; i < TPM_MAX_NV_WRITES_NOOWNER + 2; i++) { | |
460 | printf("\twriting %d\n", i); | |
abdc7b8a SG |
461 | result = tpm_nv_write_value(dev, INDEX0, (uint8_t *)&i, |
462 | sizeof(i)); | |
e76cb927 SG |
463 | switch (result) { |
464 | case TPM_SUCCESS: | |
465 | break; | |
466 | case TPM_MAXNVWRITES: | |
467 | assert(i >= TPM_MAX_NV_WRITES_NOOWNER); | |
468 | default: | |
9b643e31 | 469 | pr_err("\tunexpected error code %d (0x%x)\n", |
e76cb927 SG |
470 | result, result); |
471 | } | |
472 | } | |
473 | ||
474 | /* Reset write count */ | |
abdc7b8a SG |
475 | TPM_CHECK(tpm_force_clear(dev)); |
476 | TPM_CHECK(tpm_physical_enable(dev)); | |
477 | TPM_CHECK(tpm_physical_set_deactivated(dev, 0)); | |
e76cb927 SG |
478 | |
479 | /* Try writing again. */ | |
abdc7b8a | 480 | TPM_CHECK(tpm_nv_write_value(dev, INDEX0, (uint8_t *)&i, sizeof(i))); |
e76cb927 SG |
481 | printf("\tdone\n"); |
482 | return 0; | |
483 | } | |
484 | ||
485 | #define VOIDTEST(XFUNC) \ | |
486 | int do_test_##XFUNC(cmd_tbl_t *cmd_tbl, int flag, int argc, \ | |
487 | char * const argv[]) \ | |
488 | { \ | |
abdc7b8a SG |
489 | struct udevice *dev; \ |
490 | int ret; \ | |
491 | \ | |
492 | ret = get_tpm(&dev); \ | |
493 | if (ret) \ | |
494 | return ret; \ | |
495 | return test_##XFUNC(dev); \ | |
e76cb927 SG |
496 | } |
497 | ||
498 | #define VOIDENT(XNAME) \ | |
499 | U_BOOT_CMD_MKENT(XNAME, 0, 1, do_test_##XNAME, "", ""), | |
500 | ||
501 | VOIDTEST(early_extend) | |
502 | VOIDTEST(early_nvram) | |
503 | VOIDTEST(early_nvram2) | |
504 | VOIDTEST(enable) | |
505 | VOIDTEST(fast_enable) | |
506 | VOIDTEST(global_lock) | |
507 | VOIDTEST(lock) | |
508 | VOIDTEST(readonly) | |
509 | VOIDTEST(redefine_unowned) | |
510 | VOIDTEST(space_perm) | |
511 | VOIDTEST(startup) | |
512 | VOIDTEST(timing) | |
513 | VOIDTEST(write_limit) | |
514 | VOIDTEST(timer) | |
515 | ||
516 | static cmd_tbl_t cmd_cros_tpm_sub[] = { | |
517 | VOIDENT(early_extend) | |
518 | VOIDENT(early_nvram) | |
519 | VOIDENT(early_nvram2) | |
520 | VOIDENT(enable) | |
521 | VOIDENT(fast_enable) | |
522 | VOIDENT(global_lock) | |
523 | VOIDENT(lock) | |
524 | VOIDENT(readonly) | |
525 | VOIDENT(redefine_unowned) | |
526 | VOIDENT(space_perm) | |
527 | VOIDENT(startup) | |
528 | VOIDENT(timing) | |
529 | VOIDENT(write_limit) | |
530 | VOIDENT(timer) | |
531 | }; | |
532 | ||
533 | static int do_tpmtest(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) | |
534 | { | |
535 | cmd_tbl_t *c; | |
0427b9c5 | 536 | int i; |
e76cb927 SG |
537 | |
538 | printf("argc = %d, argv = ", argc); | |
e76cb927 | 539 | |
0427b9c5 SB |
540 | for (i = 0; i < argc; i++) |
541 | printf(" %s", argv[i]); | |
542 | ||
543 | printf("\n------\n"); | |
544 | ||
e76cb927 SG |
545 | argc--; |
546 | argv++; | |
547 | c = find_cmd_tbl(argv[0], cmd_cros_tpm_sub, | |
548 | ARRAY_SIZE(cmd_cros_tpm_sub)); | |
549 | return c ? c->cmd(cmdtp, flag, argc, argv) : cmd_usage(cmdtp); | |
550 | } | |
551 | ||
552 | U_BOOT_CMD(tpmtest, 2, 1, do_tpmtest, "TPM tests", | |
553 | "\n\tearly_extend\n" | |
554 | "\tearly_nvram\n" | |
555 | "\tearly_nvram2\n" | |
556 | "\tenable\n" | |
557 | "\tfast_enable\n" | |
558 | "\tglobal_lock\n" | |
559 | "\tlock\n" | |
560 | "\treadonly\n" | |
561 | "\tredefine_unowned\n" | |
562 | "\tspace_perm\n" | |
563 | "\tstartup\n" | |
564 | "\ttiming\n" | |
565 | "\twrite_limit\n"); |