1 /*
2 * Copyright (c) 2001-2019, Arm Limited and Contributors. All rights reserved.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7 #include <stddef.h>
8 #include <stdint.h>
9 #include <string.h>
10 #include <stdbool.h>
11
12 #include "cc_otp_defs.h"
13 #include "cc_regs.h"
14 #include "dx_crys_kernel.h"
15 #include "cc_pal_types.h"
16
17 #include "test_proj_otp.h"
18 #include "test_proj_defs.h"
19 #include "test_proj_otp.h"
20
21 #include "test_pal_log.h"
22 #include "test_pal_time.h"
23
Test_ProjWriteOtpWord(uint32_t offsetInWords,uint32_t value)24 void Test_ProjWriteOtpWord(uint32_t offsetInWords, uint32_t value)
25 {
26 TEST_WRITE_OTP_BY_ENV(offsetInWords, value);
27 }
28
Test_ProjWriteOtpField(uint32_t offsetInWords,uint32_t sizeWords,uint32_t * buff)29 void Test_ProjWriteOtpField(uint32_t offsetInWords, uint32_t sizeWords, uint32_t *buff)
30 {
31 uint32_t i = 0;
32
33 for (i = 0; i < sizeWords; i++) {
34 Test_ProjWriteOtpWord(offsetInWords + i, buff[i]);
35 Test_PalDelay(1000);
36 }
37 }
38
Test_ProjReadOtpWord(uint32_t offsetInWords)39 uint32_t Test_ProjReadOtpWord(uint32_t offsetInWords)
40 {
41 uint32_t read_value = 0;
42
43 read_value = TEST_READ_OTP_BY_ENV(offsetInWords);
44
45 return read_value;
46 }
47
Test_ProjSetZeroBitsOtpBuff(uint32_t * otpBuf,uint32_t keyType,uint32_t value)48 uint32_t Test_ProjSetZeroBitsOtpBuff(uint32_t *otpBuf, uint32_t keyType, uint32_t value)
49 {
50 uint32_t hwWord;
51
52 switch (keyType) {
53 case TEST_KCP_KEY:
54 hwWord = otpBuf[CC_OTP_OEM_FLAG_OFFSET];
55 CC_REG_FLD_SET2(0, OTP_OEM_FLAG, KCP_ZERO_BITS, hwWord, value);
56 otpBuf[CC_OTP_OEM_FLAG_OFFSET] = hwWord;
57 break;
58 case TEST_KCE_KEY:
59 hwWord = otpBuf[CC_OTP_OEM_FLAG_OFFSET];
60 CC_REG_FLD_SET2(0, OTP_OEM_FLAG, KCE_ZERO_BITS, hwWord, value);
61 otpBuf[CC_OTP_OEM_FLAG_OFFSET] = hwWord;
62 break;
63 case TEST_KPICV_KEY:
64 hwWord = otpBuf[CC_OTP_MANUFACTURE_FLAG_OFFSET];
65 CC_REG_FLD_SET2(0, OTP_MANUFACTURE_FLAG, KPICV_ZERO_BITS, hwWord, value);
66 otpBuf[CC_OTP_MANUFACTURE_FLAG_OFFSET] = hwWord;
67 break;
68 case TEST_KCEICV_KEY:
69 hwWord = otpBuf[CC_OTP_MANUFACTURE_FLAG_OFFSET];
70 CC_REG_FLD_SET2(0, OTP_MANUFACTURE_FLAG, KCEICV_ZERO_BITS, hwWord, value);
71 otpBuf[CC_OTP_MANUFACTURE_FLAG_OFFSET] = hwWord;
72 break;
73 case TEST_HUK_KEY:
74 hwWord = otpBuf[CC_OTP_MANUFACTURE_FLAG_OFFSET];
75 CC_REG_FLD_SET2(0, OTP_MANUFACTURE_FLAG, HUK_ZERO_BITS, hwWord, value);
76 otpBuf[CC_OTP_MANUFACTURE_FLAG_OFFSET] = hwWord;
77 break;
78 default:
79 TEST_PRINTF_ERROR("ERROR: can't set zero bits for this type of key\n")
80 ;
81 return TEST_INVALID_PARAM_ERR;
82 }
83 return TEST_OK;
84 }
85
Test_ProjSetNotInUseOtpBuff(uint32_t * otpBuf,uint32_t keyType,uint32_t value)86 uint32_t Test_ProjSetNotInUseOtpBuff(uint32_t *otpBuf, uint32_t keyType, uint32_t value)
87 {
88 uint32_t hwWord;
89
90 switch (keyType) {
91 // TBD HBK
92 case TEST_KCP_KEY:
93 hwWord = otpBuf[CC_OTP_OEM_FLAG_OFFSET];
94 CC_REG_FLD_SET2(0, OTP_OEM_FLAG, KCP_NOT_IN_USE, hwWord, value);
95 otpBuf[CC_OTP_OEM_FLAG_OFFSET] = hwWord;
96 break;
97 case TEST_KCE_KEY:
98 hwWord = otpBuf[CC_OTP_OEM_FLAG_OFFSET];
99 CC_REG_FLD_SET2(0, OTP_OEM_FLAG, KCE_NOT_IN_USE, hwWord, value);
100 otpBuf[CC_OTP_OEM_FLAG_OFFSET] = hwWord;
101 break;
102 case TEST_KPICV_KEY:
103 hwWord = otpBuf[CC_OTP_MANUFACTURE_FLAG_OFFSET];
104 CC_REG_FLD_SET2(0, OTP_MANUFACTURE_FLAG, KPICV_NOT_IN_USE, hwWord, value);
105 otpBuf[CC_OTP_MANUFACTURE_FLAG_OFFSET] = hwWord;
106 break;
107 case TEST_KCEICV_KEY:
108 hwWord = otpBuf[CC_OTP_MANUFACTURE_FLAG_OFFSET];
109 CC_REG_FLD_SET2(0, OTP_MANUFACTURE_FLAG, KCEICV_NOT_IN_USE, hwWord, value);
110 otpBuf[CC_OTP_MANUFACTURE_FLAG_OFFSET] = hwWord;
111 break;
112 case TEST_HUK_KEY:
113 default:
114 TEST_PRINTF_ERROR("ERROR: can't set notInUse bit for this type of key\n")
115 ;
116 return TEST_INVALID_PARAM_ERR;
117
118 }
119 return TEST_OK;
120 }
121
Test_ProjSetKeyOtpBuff(uint32_t * otpBuf,uint32_t * keyBuff,uint32_t keyType)122 uint32_t Test_ProjSetKeyOtpBuff(uint32_t *otpBuf, uint32_t *keyBuff, uint32_t keyType)
123 {
124 uint32_t zeroCount = 0;
125 uint32_t keySizeInWords = 0;
126 uint32_t keyOffsetInOtp = 0;
127 uint32_t rc = TEST_OK;
128
129 switch (keyType) {
130 case TEST_HUK_KEY:
131 keySizeInWords = CC_OTP_HUK_SIZE_IN_WORDS;
132 keyOffsetInOtp = CC_OTP_HUK_OFFSET;
133 break;
134 case TEST_KCP_KEY:
135 keySizeInWords = CC_OTP_KCP_SIZE_IN_WORDS;
136 keyOffsetInOtp = CC_OTP_KCP_OFFSET;
137 break;
138 case TEST_KCE_KEY:
139 keySizeInWords = CC_OTP_KCE_SIZE_IN_WORDS;
140 keyOffsetInOtp = CC_OTP_KCE_OFFSET;
141 break;
142 case TEST_KPICV_KEY:
143 keySizeInWords = CC_OTP_KPICV_SIZE_IN_WORDS;
144 keyOffsetInOtp = CC_OTP_KPICV_OFFSET;
145 break;
146 case TEST_KCEICV_KEY:
147 keySizeInWords = CC_OTP_KCEICV_SIZE_IN_WORDS;
148 keyOffsetInOtp = CC_OTP_KCEICV_OFFSET;
149 break;
150 default:
151 TEST_PRINTF_ERROR("ERROR: key type is not supported %d\n", keyType);
152 return TEST_INVALID_PARAM_ERR;
153
154 }
155
156 if (keyBuff != NULL) {
157 memcpy((uint8_t *) (otpBuf + keyOffsetInOtp),
158 (uint8_t *) keyBuff,
159 keySizeInWords * sizeof(uint32_t));
160 }
161
162 TEST_CALC_BUFF_ZEROS((otpBuf + keyOffsetInOtp), keySizeInWords, zeroCount);
163
164 if (keyType != TEST_HUK_KEY) {
165 rc = Test_ProjSetNotInUseOtpBuff(otpBuf, keyType, 0);
166 }
167
168 rc = rc & Test_ProjSetZeroBitsOtpBuff(otpBuf, keyType, zeroCount);
169 return rc;
170 }
171
Test_ProjBurnOtpPlain(uint32_t * otpBuf,uint32_t nextLcs,OtpChipState_t chipIndication)172 uint32_t Test_ProjBurnOtpPlain(uint32_t *otpBuf, uint32_t nextLcs, OtpChipState_t chipIndication)
173 {
174
175 uint32_t error = 0;
176 uint32_t i = 0;
177
178 CC_UNUSED_PARAM(chipIndication);
179
180 /* Clean OTP */
181 for (i = 0; i < TEST_OTP_SIZE_IN_WORDS; i++) {
182 Test_ProjWriteOtpWord(i, 0);
183 Test_PalDelay(1000);
184 }
185 /* Perform SW reset to reach CM LCS */
186 Test_ProjPerformPowerOnReset();
187 Test_PalDelay(1000);
188
189 /* Copy new OTP buffer */
190 for (i = 0; i < TEST_OTP_SIZE_IN_WORDS; i++) {
191 TEST_PRINTF("writing Otp [0x%X] 0x%X", i, otpBuf[i]);
192 Test_ProjWriteOtpWord(i, otpBuf[i]);
193 Test_PalDelay(1000);
194 }
195
196 /* Perform SW reset after writing to OTP new values */
197 Test_ProjPerformPowerOnReset();
198
199 /* verify LCS */
200 error = Test_ProjCheckLcs(nextLcs);
201 if (error == 0) {
202 TEST_PRINTF(" OTP burn succeeded with new LCS = 0x%02x \n", nextLcs);
203 } else {
204 TEST_PRINTF_ERROR("Error: Failed to burn OTP!!\n");
205 }
206
207 return error;
208 }
209
Test_ProjBurnOtp(uint32_t * otpBuf,uint32_t nextLcs,OtpChipState_t chipIndication)210 uint32_t Test_ProjBurnOtp(uint32_t *otpBuf, uint32_t nextLcs, OtpChipState_t chipIndication)
211 {
212
213 uint32_t error = 0;
214 uint32_t i = 0;
215
216 if (nextLcs != TEST_PROJ_LCS_CM) {
217 for (i = TEST_HUK_KEY; i <= TEST_KCEICV_KEY; i++) {
218 /* rtl key is not a part of OTP image => skip it */
219 if (i == TEST_RTL_KEY) {
220 continue;
221 };
222 /* set the the key to OTP buffer*/
223 Test_ProjSetKeyOtpBuff(otpBuf, NULL, i);
224 }
225 }
226
227 error = Test_ProjBurnOtpPlain(otpBuf, nextLcs, chipIndication);
228
229 return error;
230 }
231
Test_ProjBurnCmOtp(OtpChipState_t chipIndication)232 uint32_t Test_ProjBurnCmOtp(OtpChipState_t chipIndication)
233 {
234
235 uint32_t error = 0;
236 uint32_t i = 0;
237
238 CC_UNUSED_PARAM(chipIndication);
239
240 /* Clean OTP */
241 for (i = 0; i < TEST_OTP_SIZE_IN_WORDS; i++) {
242 TEST_WRITE_OTP_BY_ENV(i, 0);
243 Test_PalDelay(1000);
244 }
245
246 /* Perform SW reset after writing to OTP new values */
247 Test_ProjPerformPowerOnReset();
248
249 /* verify LCS */
250 error = Test_ProjCheckLcs(TEST_PROJ_LCS_CM);
251 if (error == 0) {
252 TEST_PRINTF(" OTP burn succeeded with TEST_PROJ_LCS_DM\n");
253 } else {
254 TEST_PRINTF_ERROR("Error: Failed to burn OTP!!\n");
255 }
256
257 return error;
258 }
259
Test_ProjBurnDmOtp(uint32_t * otpBuf,OtpChipState_t chipIndication)260 uint32_t Test_ProjBurnDmOtp(uint32_t *otpBuf, OtpChipState_t chipIndication)
261 {
262
263 uint32_t error = 0;
264 uint32_t i = 0;
265
266 CC_UNUSED_PARAM(chipIndication);
267
268 /* Clean OTP */
269 for (i = 0; i < TEST_OTP_SIZE_IN_WORDS; i++) {
270 TEST_WRITE_OTP_BY_ENV(i, 0);
271 Test_PalDelay(1000);
272 }
273
274 /* Perform SW reset to reach CM LCS */
275 Test_ProjPerformPowerOnReset();
276 Test_PalDelay(1000);
277
278 /* Prepare OTP */
279 Test_ProjSetKeyOtpBuff(otpBuf, NULL, TEST_HUK_KEY);
280 Test_ProjSetKeyOtpBuff(otpBuf, NULL, TEST_KPICV_KEY);
281 Test_ProjSetKeyOtpBuff(otpBuf, NULL, TEST_KCEICV_KEY);
282
283 /* Copy new OTP buffer */
284 Test_ProjWriteOtpField(CC_OTP_HUK_OFFSET, CC_OTP_HUK_SIZE_IN_WORDS, &otpBuf[CC_OTP_HUK_OFFSET]);
285 Test_ProjWriteOtpField(CC_OTP_KPICV_OFFSET,
286 CC_OTP_KPICV_SIZE_IN_WORDS,
287 &otpBuf[CC_OTP_KPICV_OFFSET]);
288 Test_ProjWriteOtpField(CC_OTP_KCEICV_OFFSET,
289 CC_OTP_KCEICV_SIZE_IN_WORDS,
290 &otpBuf[CC_OTP_KCEICV_OFFSET]);
291 Test_ProjWriteOtpField(CC_OTP_MANUFACTURE_FLAG_OFFSET,
292 1,
293 &otpBuf[CC_OTP_MANUFACTURE_FLAG_OFFSET]);
294 Test_ProjWriteOtpField(CC_OTP_HBK0_OFFSET,
295 CC_OTP_HBK0_SIZE_IN_WORDS,
296 &otpBuf[CC_OTP_HBK0_OFFSET]);
297 Test_ProjWriteOtpField(CC_OTP_HBK0_MIN_VERSION_OFFSET,
298 CC_OTP_HBK0_MIN_VERSION_SIZE_IN_WORDS,
299 &otpBuf[CC_OTP_HBK0_MIN_VERSION_OFFSET]);
300 Test_ProjWriteOtpField(CC_OTP_ICV_GENERAL_PURPOSE_FLAG_OFFSET,
301 CC_OTP_ICV_GENERAL_PURPOSE_FLAG_SIZE_IN_WORDS,
302 &otpBuf[CC_OTP_ICV_GENERAL_PURPOSE_FLAG_OFFSET]);
303 Test_ProjWriteOtpField(CC_OTP_DCU_OFFSET, CC_OTP_DCU_SIZE_IN_WORDS, &otpBuf[CC_OTP_DCU_OFFSET]);
304
305 /* Perform SW reset after writing to OTP new values */
306 Test_ProjPerformPowerOnReset();
307
308 /* verify LCS */
309 error = Test_ProjCheckLcs(TEST_PROJ_LCS_DM);
310 if (error == 0) {
311 TEST_PRINTF(" OTP burn succeeded with TEST_PROJ_LCS_DM\n");
312 } else {
313 TEST_PRINTF_ERROR("Error: Failed to burn OTP!!\n");
314 }
315
316 return error;
317 }
318
Test_ProjSetKdrInOtpBuff(uint32_t * otp,uint8_t * kdrBuff)319 uint32_t Test_ProjSetKdrInOtpBuff(uint32_t *otp, uint8_t *kdrBuff)
320 {
321 int i = 0;
322 int zeroCount = 0;
323 int kdrZeroSize = ((0x1 << CC_OTP_MANUFACTURE_FLAG_HUK_ZERO_BITS_BIT_SIZE) - 1);
324 int kdrZeroMask = (kdrZeroSize << CC_OTP_MANUFACTURE_FLAG_HUK_ZERO_BITS_BIT_SHIFT);
325
326 if ((NULL == otp) || (NULL == kdrBuff)) {
327 TEST_PRINTF_ERROR(" ilegal params\n");
328 return TEST_INVALID_PARAM_ERR;
329 }
330 for (i = 0; i < CC_OTP_HUK_SIZE_IN_WORDS; i++) {
331 TEST_CONVERT_BYTE_ARR_TO_WORD(&kdrBuff[i * sizeof(uint32_t)], otp[CC_OTP_START_OFFSET+i])
332 }
333
334 TEST_CALC_BUFF_ZEROS(&otp[CC_OTP_START_OFFSET], CC_OTP_HUK_SIZE_IN_WORDS, zeroCount);
335 otp[CC_OTP_MANUFACTURE_FLAG_OFFSET] &= ~(kdrZeroMask);
336 otp[CC_OTP_MANUFACTURE_FLAG_OFFSET] |= (zeroCount)
337 << CC_OTP_MANUFACTURE_FLAG_HUK_ZERO_BITS_BIT_SHIFT;
338 return TEST_OK;
339
340 }
341
Test_ProjSetHbkInOtpBuff(uint32_t * otp,uint8_t * hbkBuff,OtpHbkTypes_t type,uint8_t isFullHbk)342 uint32_t Test_ProjSetHbkInOtpBuff(uint32_t *otp,
343 uint8_t *hbkBuff,
344 OtpHbkTypes_t type,
345 uint8_t isFullHbk)
346 {
347 uint32_t i = 0;
348 uint32_t zeroCount = 0;
349 uint32_t otpStartOffset =
350 (type == TEST_OTP_HBK1_TYPE) ? CC_OTP_HBK1_OFFSET : CC_OTP_HBK0_OFFSET;
351 uint32_t hbkStartOffset = (type == TEST_OTP_HBK1_TYPE) ? CC_OTP_HBK0_SIZE_IN_WORDS : 0;
352 uint32_t hbkWordSize;
353 uint32_t hwWord = 0;
354
355 if ((NULL == otp) || (NULL == hbkBuff)) {
356 TEST_PRINTF_ERROR("ilegal params\n");
357 return TEST_INVALID_PARAM_ERR;
358 }
359
360 TEST_PRINTF_ERROR("type %d\n", type);
361
362 if ((type == TEST_OTP_HBK0_TYPE) || (type == TEST_OTP_HBK1_TYPE)) {
363 hbkWordSize = CC_OTP_HBK0_SIZE_IN_WORDS;
364 } else if (type == TEST_OTP_HBK_256_TYPE) {
365 hbkWordSize = CC_OTP_HBK_SIZE_IN_WORDS;
366 } else {
367 TEST_PRINTF_ERROR("ilegal type %d\n", type);
368 return TEST_INVALID_PARAM_ERR;
369 }
370
371 /* clear OTP HBK value */
372 memset(&otp[otpStartOffset], 0, hbkWordSize * sizeof(uint32_t));
373
374 if (isFullHbk == 1) {
375 //clear ICV HBK zero count & clear HBK0 usage
376 otp[CC_OTP_MANUFACTURE_FLAG_OFFSET] &= ~(0x7F000000);
377 hwWord = otp[CC_OTP_MANUFACTURE_FLAG_OFFSET];
378 CC_REG_FLD_SET2(0, OTP_MANUFACTURE_FLAG, HBK0_NOT_IN_USE, hwWord, 1);
379 }
380
381 TEST_PRINTF_ERROR("writing hbk otpStartOffset %d, hbkWordSize %d\n",
382 otpStartOffset,
383 hbkWordSize);
384
385 for (i = 0; i < hbkWordSize; i++) {
386 TEST_CONVERT_BYTE_ARR_TO_WORD(&hbkBuff[(hbkStartOffset + i) * sizeof(uint32_t)],
387 otp[otpStartOffset + i]);
388 }
389
390 TEST_CALC_BUFF_ZEROS(&otp[otpStartOffset], hbkWordSize, zeroCount);
391
392 if (type == TEST_OTP_HBK0_TYPE) {
393 otp[CC_OTP_MANUFACTURE_FLAG_OFFSET] &= ~(0xFF000000);
394 otp[CC_OTP_MANUFACTURE_FLAG_OFFSET] |= (zeroCount)
395 << CC_OTP_MANUFACTURE_FLAG_HBK0_ZERO_BITS_BIT_SHIFT;
396 TEST_PRINTF_ERROR("zeros for HBK0 %d\n", zeroCount);
397 } else {
398 otp[CC_OTP_OEM_FLAG_OFFSET] &= ~(0xFF);
399 otp[CC_OTP_OEM_FLAG_OFFSET] |= (zeroCount) << CC_OTP_OEM_FLAG_HBK1_ZERO_BITS_BIT_SHIFT;
400 }
401
402 TEST_PRINTF_ERROR("otp[0x%lx] 0x%x, otp[0x%lx] 0x%x\n",
403 CC_OTP_OEM_FLAG_OFFSET,
404 otp[CC_OTP_OEM_FLAG_OFFSET],
405 CC_OTP_MANUFACTURE_FLAG_OFFSET,
406 otp[CC_OTP_MANUFACTURE_FLAG_OFFSET]);
407
408 return TEST_OK;
409 }
410
Test_ProjSetKpicvInOtpBuff(uint32_t * otpBuf,uint8_t * kpicvBuff)411 uint32_t Test_ProjSetKpicvInOtpBuff(uint32_t *otpBuf, uint8_t *kpicvBuff)
412 {
413 int zeroCount = 0;
414 uint32_t hwWord = 0;
415
416 if ((NULL == otpBuf) || (NULL == kpicvBuff)) {
417 TEST_PRINTF_ERROR(" ilegal params\n");
418 return TEST_INVALID_PARAM_ERR;
419 }
420 memcpy((uint8_t *) (otpBuf + CC_OTP_KPICV_OFFSET),
421 (uint8_t *) kpicvBuff,
422 CC_OTP_KPICV_SIZE_IN_WORDS * sizeof(uint32_t));
423
424 TEST_CALC_BUFF_ZEROS(&otpBuf[CC_OTP_KPICV_OFFSET], CC_OTP_KPICV_SIZE_IN_WORDS, zeroCount);
425 hwWord = otpBuf[CC_OTP_MANUFACTURE_FLAG_OFFSET];
426 CC_REG_FLD_SET2(0, OTP_MANUFACTURE_FLAG, KPICV_ZERO_BITS, hwWord, zeroCount);
427 CC_REG_FLD_SET2(0, OTP_MANUFACTURE_FLAG, KPICV_NOT_IN_USE, hwWord, 0);
428 otpBuf[CC_OTP_MANUFACTURE_FLAG_OFFSET] = hwWord;
429 return TEST_OK;
430 }
431
Test_ProjSetKceicvOtpBuff(uint32_t * otpBuf,uint8_t * kceicvBuff)432 uint32_t Test_ProjSetKceicvOtpBuff(uint32_t *otpBuf, uint8_t *kceicvBuff)
433 {
434 int zeroCount = 0;
435 uint32_t hwWord = 0;
436
437 if ((NULL == otpBuf) || (NULL == kceicvBuff)) {
438 TEST_PRINTF_ERROR(" ilegal params\n");
439 return TEST_INVALID_PARAM_ERR;
440 }
441 memcpy((uint8_t *) (otpBuf + CC_OTP_KCEICV_OFFSET),
442 (uint8_t *) kceicvBuff,
443 CC_OTP_KCEICV_SIZE_IN_WORDS * sizeof(uint32_t));
444
445 TEST_CALC_BUFF_ZEROS(&otpBuf[CC_OTP_KCEICV_OFFSET], CC_OTP_KCEICV_SIZE_IN_WORDS, zeroCount);
446 hwWord = otpBuf[CC_OTP_MANUFACTURE_FLAG_OFFSET];
447 CC_REG_FLD_SET2(0, OTP_MANUFACTURE_FLAG, KCEICV_ZERO_BITS, hwWord, zeroCount);
448 CC_REG_FLD_SET2(0, OTP_MANUFACTURE_FLAG, KCEICV_NOT_IN_USE, hwWord, 0);
449 otpBuf[CC_OTP_MANUFACTURE_FLAG_OFFSET] = hwWord;
450 return TEST_OK;
451 }
452
Test_ProjSetKcpOtpBuff(uint32_t * otpBuf,uint8_t * kcpBuff)453 uint32_t Test_ProjSetKcpOtpBuff(uint32_t *otpBuf, uint8_t *kcpBuff)
454 {
455 int zeroCount = 0;
456 uint32_t hwWord = 0;
457
458 if ((NULL == otpBuf) || (NULL == kcpBuff)) {
459 TEST_PRINTF_ERROR(" ilegal params\n");
460 return TEST_INVALID_PARAM_ERR;
461 }
462 memcpy((uint8_t *) (otpBuf + CC_OTP_KCP_OFFSET),
463 (uint8_t *) kcpBuff,
464 CC_OTP_KCP_SIZE_IN_WORDS * sizeof(uint32_t));
465
466 TEST_CALC_BUFF_ZEROS(&otpBuf[CC_OTP_KCP_OFFSET], CC_OTP_KCP_SIZE_IN_WORDS, zeroCount);
467 hwWord = otpBuf[CC_OTP_OEM_FLAG_OFFSET];
468 CC_REG_FLD_SET2(0, OTP_OEM_FLAG, KCP_ZERO_BITS, hwWord, zeroCount);
469 CC_REG_FLD_SET2(0, OTP_OEM_FLAG, KCP_NOT_IN_USE, hwWord, 0);
470 otpBuf[CC_OTP_OEM_FLAG_OFFSET] = hwWord;
471 return TEST_OK;
472 }
473
Test_ProjSetKceOtpBuff(uint32_t * otpBuf,uint8_t * kceBuff)474 uint32_t Test_ProjSetKceOtpBuff(uint32_t *otpBuf, uint8_t *kceBuff)
475 {
476 int zeroCount = 0;
477 uint32_t hwWord = 0;
478
479 if ((NULL == otpBuf) || (NULL == kceBuff)) {
480 TEST_PRINTF_ERROR(" ilegal params\n");
481 return TEST_INVALID_PARAM_ERR;
482 }
483 memcpy((uint8_t *) (otpBuf + CC_OTP_KCE_OFFSET),
484 (uint8_t *) kceBuff,
485 CC_OTP_KCE_SIZE_IN_WORDS * sizeof(uint32_t));
486
487 TEST_CALC_BUFF_ZEROS(&otpBuf[CC_OTP_KCE_OFFSET], CC_OTP_KCE_SIZE_IN_WORDS, zeroCount);
488 hwWord = otpBuf[CC_OTP_OEM_FLAG_OFFSET];
489 CC_REG_FLD_SET2(0, OTP_OEM_FLAG, KCE_ZERO_BITS, hwWord, zeroCount);
490 CC_REG_FLD_SET2(0, OTP_OEM_FLAG, KCE_NOT_IN_USE, hwWord, 0);
491 otpBuf[CC_OTP_OEM_FLAG_OFFSET] = hwWord;
492 return TEST_OK;
493 }
494
Test_ProjGetKeySizeInWordsOtp(uint32_t keyType,uint32_t * keySizeInWords)495 uint32_t Test_ProjGetKeySizeInWordsOtp(uint32_t keyType, uint32_t* keySizeInWords)
496 {
497 // TBD HBK??
498 switch (keyType) {
499 case TEST_HUK_KEY:
500 *keySizeInWords = CC_OTP_HUK_SIZE_IN_WORDS;
501 break;
502 case TEST_KCP_KEY:
503 *keySizeInWords = CC_OTP_KCP_SIZE_IN_WORDS;
504 break;
505 case TEST_KCE_KEY:
506 *keySizeInWords = CC_OTP_KCE_SIZE_IN_WORDS;
507 break;
508 case TEST_KPICV_KEY:
509 *keySizeInWords = CC_OTP_KPICV_SIZE_IN_WORDS;
510 break;
511 case TEST_KCEICV_KEY:
512 *keySizeInWords = CC_OTP_KCEICV_SIZE_IN_WORDS;
513 break;
514 default:
515 *keySizeInWords = 0;
516 TEST_PRINTF_ERROR("ERROR: key type %d is not supported\n", keyType)
517 ;
518 return TEST_INVALID_PARAM_ERR;
519
520 }
521 return 0;
522 }
523
524 /**
525 * This function gets hw key and its size from otp buffer to user buffer
526 *
527 */
Test_ProjGetKeyOtpBuff(uint32_t * otpBuf,uint32_t keyType,uint32_t * keySizeInWords,uint32_t * keyBuff)528 uint32_t Test_ProjGetKeyOtpBuff(uint32_t *otpBuf,
529 uint32_t keyType,
530 uint32_t *keySizeInWords,
531 uint32_t *keyBuff)
532 {
533 uint32_t keyOffsetInOtp = 0;
534 uint32_t rc = TEST_OK;
535
536 if ((NULL == otpBuf) || (NULL == keyBuff) || (NULL == keySizeInWords)) {
537 TEST_PRINTF_ERROR(" ilegal params\n");
538 return TEST_INVALID_PARAM_ERR;
539 }
540
541 // TBD HBK??
542 switch (keyType) {
543 case TEST_HUK_KEY:
544 *keySizeInWords = CC_OTP_HUK_SIZE_IN_WORDS;
545 keyOffsetInOtp = CC_OTP_HUK_OFFSET;
546 break;
547 case TEST_KCP_KEY:
548 *keySizeInWords = CC_OTP_KCP_SIZE_IN_WORDS;
549 keyOffsetInOtp = CC_OTP_KCP_OFFSET;
550 break;
551 case TEST_KCE_KEY:
552 *keySizeInWords = CC_OTP_KCE_SIZE_IN_WORDS;
553 keyOffsetInOtp = CC_OTP_KCE_OFFSET;
554 break;
555 case TEST_KPICV_KEY:
556 *keySizeInWords = CC_OTP_KPICV_SIZE_IN_WORDS;
557 keyOffsetInOtp = CC_OTP_KPICV_OFFSET;
558 break;
559 case TEST_KCEICV_KEY:
560 *keySizeInWords = CC_OTP_KCEICV_SIZE_IN_WORDS;
561 keyOffsetInOtp = CC_OTP_KCEICV_OFFSET;
562 break;
563 default:
564 *keySizeInWords = 0;
565 TEST_PRINTF_ERROR("ERROR: key type is not supported\n")
566 ;
567 return TEST_INVALID_PARAM_ERR;
568
569 }
570 memcpy((uint8_t *) keyBuff,
571 (uint8_t *) (otpBuf + keyOffsetInOtp),
572 (*keySizeInWords) * sizeof(uint32_t));
573
574 return rc;
575 }
576
Test_ProjSetSwVerInOtpBuff(uint32_t * otp,uint32_t offset,uint32_t max_size)577 uint32_t Test_ProjSetSwVerInOtpBuff(uint32_t *otp, uint32_t offset, uint32_t max_size)
578 {
579 uint32_t i;
580
581 for (i = 0; i < max_size; i++) {
582 if (otp[offset + i] < 0xFFFFFFFF) {
583 memset(&otp[offset + i + 1], 0x0, (max_size - i - 1) * sizeof(uint32_t));
584 break;
585 }
586 }
587
588 return TEST_OK;
589 }
590
591
