1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * SEC Descriptor Construction Library
4 * Basic job descriptor construction
5 *
6 * Copyright 2014 Freescale Semiconductor, Inc.
7 *
8 */
9
10 #include <common.h>
11 #include <cpu_func.h>
12 #include <fsl_sec.h>
13 #include "desc_constr.h"
14 #include "jobdesc.h"
15 #include "rsa_caam.h"
16 #include <asm/cache.h>
17
18 #if defined(CONFIG_MX6) || defined(CONFIG_MX7)
19 /*!
20 * Secure memory run command
21 *
22 * @param sec_mem_cmd Secure memory command register
23 * @return cmd_status Secure memory command status register
24 */
secmem_set_cmd(uint32_t sec_mem_cmd)25 uint32_t secmem_set_cmd(uint32_t sec_mem_cmd)
26 {
27 uint32_t temp_reg;
28
29 ccsr_sec_t *sec = (void *)CONFIG_SYS_FSL_SEC_ADDR;
30 uint32_t sm_vid = SM_VERSION(sec_in32(&sec->smvid));
31 uint32_t jr_id = 0;
32
33 sec_out32(CAAM_SMCJR(sm_vid, jr_id), sec_mem_cmd);
34
35 do {
36 temp_reg = sec_in32(CAAM_SMCSJR(sm_vid, jr_id));
37 } while (temp_reg & CMD_COMPLETE);
38
39 return temp_reg;
40 }
41
42 /*!
43 * CAAM page allocation:
44 * Allocates a partition from secure memory, with the id
45 * equal to partition_num. This will de-allocate the page
46 * if it is already allocated. The partition will have
47 * full access permissions. The permissions are set before,
48 * running a job descriptor. A memory page of secure RAM
49 * is allocated for the partition.
50 *
51 * @param page Number of the page to allocate.
52 * @param partition Number of the partition to allocate.
53 * @return 0 on success, ERROR_IN_PAGE_ALLOC otherwise
54 */
caam_page_alloc(uint8_t page_num,uint8_t partition_num)55 int caam_page_alloc(uint8_t page_num, uint8_t partition_num)
56 {
57 uint32_t temp_reg;
58
59 ccsr_sec_t *sec = (void *)CONFIG_SYS_FSL_SEC_ADDR;
60 uint32_t sm_vid = SM_VERSION(sec_in32(&sec->smvid));
61 uint32_t jr_id = 0;
62
63 /*
64 * De-Allocate partition_num if already allocated to ARM core
65 */
66 if (sec_in32(CAAM_SMPO_0) & PARTITION_OWNER(partition_num)) {
67 temp_reg = secmem_set_cmd(PARTITION(partition_num) |
68 CMD_PART_DEALLOC);
69 if (temp_reg & SMCSJR_AERR) {
70 printf("Error: De-allocation status 0x%X\n", temp_reg);
71 return ERROR_IN_PAGE_ALLOC;
72 }
73 }
74
75 /* set the access rights to allow full access */
76 sec_out32(CAAM_SMAG1JR(sm_vid, jr_id, partition_num), 0xF);
77 sec_out32(CAAM_SMAG2JR(sm_vid, jr_id, partition_num), 0xF);
78 sec_out32(CAAM_SMAPJR(sm_vid, jr_id, partition_num), 0xFF);
79
80 /* Now need to allocate partition_num of secure RAM. */
81 /* De-Allocate page_num by starting with a page inquiry command */
82 temp_reg = secmem_set_cmd(PAGE(page_num) | CMD_INQUIRY);
83
84 /* if the page is owned, de-allocate it */
85 if ((temp_reg & SMCSJR_PO) == PAGE_OWNED) {
86 temp_reg = secmem_set_cmd(PAGE(page_num) | CMD_PAGE_DEALLOC);
87 if (temp_reg & SMCSJR_AERR) {
88 printf("Error: Allocation status 0x%X\n", temp_reg);
89 return ERROR_IN_PAGE_ALLOC;
90 }
91 }
92
93 /* Allocate page_num to partition_num */
94 temp_reg = secmem_set_cmd(PAGE(page_num) | PARTITION(partition_num)
95 | CMD_PAGE_ALLOC);
96 if (temp_reg & SMCSJR_AERR) {
97 printf("Error: Allocation status 0x%X\n", temp_reg);
98 return ERROR_IN_PAGE_ALLOC;
99 }
100 /* page inquiry command to ensure that the page was allocated */
101 temp_reg = secmem_set_cmd(PAGE(page_num) | CMD_INQUIRY);
102
103 /* if the page is not owned => problem */
104 if ((temp_reg & SMCSJR_PO) != PAGE_OWNED) {
105 printf("Allocation of page %u in partition %u failed 0x%X\n",
106 page_num, partition_num, temp_reg);
107
108 return ERROR_IN_PAGE_ALLOC;
109 }
110
111 return 0;
112 }
113
inline_cnstr_jobdesc_blob_dek(uint32_t * desc,const uint8_t * plain_txt,uint8_t * dek_blob,uint32_t in_sz)114 int inline_cnstr_jobdesc_blob_dek(uint32_t *desc, const uint8_t *plain_txt,
115 uint8_t *dek_blob, uint32_t in_sz)
116 {
117 ccsr_sec_t *sec = (void *)CONFIG_SYS_FSL_SEC_ADDR;
118 uint32_t sm_vid = SM_VERSION(sec_in32(&sec->smvid));
119 uint32_t jr_id = 0;
120
121 uint32_t ret = 0;
122 u32 aad_w1, aad_w2;
123 /* output blob will have 32 bytes key blob in beginning and
124 * 16 byte HMAC identifier at end of data blob */
125 uint32_t out_sz = in_sz + KEY_BLOB_SIZE + MAC_SIZE;
126 /* Setting HDR for blob */
127 uint8_t wrapped_key_hdr[8] = {HDR_TAG, 0x00, WRP_HDR_SIZE + out_sz,
128 HDR_PAR, HAB_MOD, HAB_ALG, in_sz, HAB_FLG};
129
130 /* initialize the blob array */
131 memset(dek_blob, 0, out_sz + 8);
132 /* Copy the header into the DEK blob buffer */
133 memcpy(dek_blob, wrapped_key_hdr, sizeof(wrapped_key_hdr));
134
135 /* allocating secure memory */
136 ret = caam_page_alloc(PAGE_1, PARTITION_1);
137 if (ret)
138 return ret;
139
140 /* Write DEK to secure memory */
141 memcpy((uint32_t *)SEC_MEM_PAGE1, (uint32_t *)plain_txt, in_sz);
142
143 unsigned long start = (unsigned long)SEC_MEM_PAGE1 &
144 ~(ARCH_DMA_MINALIGN - 1);
145 unsigned long end = ALIGN(start + 0x1000, ARCH_DMA_MINALIGN);
146 flush_dcache_range(start, end);
147
148 /* Now configure the access rights of the partition */
149 sec_out32(CAAM_SMAG1JR(sm_vid, jr_id, PARTITION_1), KS_G1);
150 sec_out32(CAAM_SMAG2JR(sm_vid, jr_id, PARTITION_1), 0);
151 sec_out32(CAAM_SMAPJR(sm_vid, jr_id, PARTITION_1), PERM);
152
153 /* construct aad for AES */
154 aad_w1 = (in_sz << OP_ALG_ALGSEL_SHIFT) | KEY_AES_SRC | LD_CCM_MODE;
155 aad_w2 = 0x0;
156
157 init_job_desc(desc, 0);
158
159 append_cmd(desc, CMD_LOAD | CLASS_2 | KEY_IMM | KEY_ENC |
160 (0x0c << LDST_OFFSET_SHIFT) | 0x08);
161
162 append_u32(desc, aad_w1);
163
164 append_u32(desc, aad_w2);
165
166 append_cmd_ptr(desc, (dma_addr_t)SEC_MEM_PAGE1, in_sz, CMD_SEQ_IN_PTR);
167
168 append_cmd_ptr(desc, (dma_addr_t)dek_blob + 8, out_sz, CMD_SEQ_OUT_PTR);
169
170 append_operation(desc, OP_TYPE_ENCAP_PROTOCOL | OP_PCLID_BLOB |
171 OP_PCLID_SECMEM);
172
173 return ret;
174 }
175 #endif
176
inline_cnstr_jobdesc_hash(uint32_t * desc,const uint8_t * msg,uint32_t msgsz,uint8_t * digest,u32 alg_type,uint32_t alg_size,int sg_tbl)177 void inline_cnstr_jobdesc_hash(uint32_t *desc,
178 const uint8_t *msg, uint32_t msgsz, uint8_t *digest,
179 u32 alg_type, uint32_t alg_size, int sg_tbl)
180 {
181 /* SHA 256 , output is of length 32 words */
182 uint32_t storelen = alg_size;
183 u32 options;
184 dma_addr_t dma_addr_in, dma_addr_out;
185
186 dma_addr_in = virt_to_phys((void *)msg);
187 dma_addr_out = virt_to_phys((void *)digest);
188
189 init_job_desc(desc, 0);
190 append_operation(desc, OP_TYPE_CLASS2_ALG |
191 OP_ALG_AAI_HASH | OP_ALG_AS_INITFINAL |
192 OP_ALG_ENCRYPT | OP_ALG_ICV_OFF | alg_type);
193
194 options = LDST_CLASS_2_CCB | FIFOLD_TYPE_MSG | FIFOLD_TYPE_LAST2;
195 if (sg_tbl)
196 options |= FIFOLDST_SGF;
197 if (msgsz > 0xffff) {
198 options |= FIFOLDST_EXT;
199 append_fifo_load(desc, dma_addr_in, 0, options);
200 append_cmd(desc, msgsz);
201 } else {
202 append_fifo_load(desc, dma_addr_in, msgsz, options);
203 }
204
205 append_store(desc, dma_addr_out, storelen,
206 LDST_CLASS_2_CCB | LDST_SRCDST_BYTE_CONTEXT);
207 }
208 #ifndef CONFIG_SPL_BUILD
inline_cnstr_jobdesc_blob_encap(uint32_t * desc,uint8_t * key_idnfr,uint8_t * plain_txt,uint8_t * enc_blob,uint32_t in_sz)209 void inline_cnstr_jobdesc_blob_encap(uint32_t *desc, uint8_t *key_idnfr,
210 uint8_t *plain_txt, uint8_t *enc_blob,
211 uint32_t in_sz)
212 {
213 dma_addr_t dma_addr_key_idnfr, dma_addr_in, dma_addr_out;
214 uint32_t key_sz = KEY_IDNFR_SZ_BYTES;
215 /* output blob will have 32 bytes key blob in beginning and
216 * 16 byte HMAC identifier at end of data blob */
217 uint32_t out_sz = in_sz + KEY_BLOB_SIZE + MAC_SIZE;
218
219 dma_addr_key_idnfr = virt_to_phys((void *)key_idnfr);
220 dma_addr_in = virt_to_phys((void *)plain_txt);
221 dma_addr_out = virt_to_phys((void *)enc_blob);
222
223 init_job_desc(desc, 0);
224
225 append_key(desc, dma_addr_key_idnfr, key_sz, CLASS_2);
226
227 append_seq_in_ptr(desc, dma_addr_in, in_sz, 0);
228
229 append_seq_out_ptr(desc, dma_addr_out, out_sz, 0);
230
231 append_operation(desc, OP_TYPE_ENCAP_PROTOCOL | OP_PCLID_BLOB);
232 }
233
inline_cnstr_jobdesc_blob_decap(uint32_t * desc,uint8_t * key_idnfr,uint8_t * enc_blob,uint8_t * plain_txt,uint32_t out_sz)234 void inline_cnstr_jobdesc_blob_decap(uint32_t *desc, uint8_t *key_idnfr,
235 uint8_t *enc_blob, uint8_t *plain_txt,
236 uint32_t out_sz)
237 {
238 dma_addr_t dma_addr_key_idnfr, dma_addr_in, dma_addr_out;
239 uint32_t key_sz = KEY_IDNFR_SZ_BYTES;
240 uint32_t in_sz = out_sz + KEY_BLOB_SIZE + MAC_SIZE;
241
242 dma_addr_key_idnfr = virt_to_phys((void *)key_idnfr);
243 dma_addr_in = virt_to_phys((void *)enc_blob);
244 dma_addr_out = virt_to_phys((void *)plain_txt);
245
246 init_job_desc(desc, 0);
247
248 append_key(desc, dma_addr_key_idnfr, key_sz, CLASS_2);
249
250 append_seq_in_ptr(desc, dma_addr_in, in_sz, 0);
251
252 append_seq_out_ptr(desc, dma_addr_out, out_sz, 0);
253
254 append_operation(desc, OP_TYPE_DECAP_PROTOCOL | OP_PCLID_BLOB);
255 }
256 #endif
257 /*
258 * Descriptor to instantiate RNG State Handle 0 in normal mode and
259 * load the JDKEK, TDKEK and TDSK registers
260 */
inline_cnstr_jobdesc_rng_instantiation(u32 * desc,int handle,int do_sk)261 void inline_cnstr_jobdesc_rng_instantiation(u32 *desc, int handle, int do_sk)
262 {
263 u32 *jump_cmd;
264
265 init_job_desc(desc, 0);
266
267 /* INIT RNG in non-test mode */
268 append_operation(desc, OP_TYPE_CLASS1_ALG | OP_ALG_ALGSEL_RNG |
269 (handle << OP_ALG_AAI_SHIFT) | OP_ALG_AS_INIT |
270 OP_ALG_PR_ON);
271
272 /* For SH0, Secure Keys must be generated as well */
273 if (!handle && do_sk) {
274 /* wait for done */
275 jump_cmd = append_jump(desc, JUMP_CLASS_CLASS1);
276 set_jump_tgt_here(desc, jump_cmd);
277
278 /*
279 * load 1 to clear written reg:
280 * resets the done interrupt and returns the RNG to idle.
281 */
282 append_load_imm_u32(desc, 1, LDST_SRCDST_WORD_CLRW);
283
284 /* generate secure keys (non-test) */
285 append_operation(desc, OP_TYPE_CLASS1_ALG | OP_ALG_ALGSEL_RNG |
286 OP_ALG_RNG4_SK);
287 }
288 }
289
290 /* Descriptor for deinstantiation of the RNG block. */
inline_cnstr_jobdesc_rng_deinstantiation(u32 * desc,int handle)291 void inline_cnstr_jobdesc_rng_deinstantiation(u32 *desc, int handle)
292 {
293 init_job_desc(desc, 0);
294
295 append_operation(desc, OP_TYPE_CLASS1_ALG | OP_ALG_ALGSEL_RNG |
296 (handle << OP_ALG_AAI_SHIFT) | OP_ALG_AS_INITFINAL);
297 }
298
inline_cnstr_jobdesc_rng(u32 * desc,void * data_out,u32 size)299 void inline_cnstr_jobdesc_rng(u32 *desc, void *data_out, u32 size)
300 {
301 dma_addr_t dma_data_out = virt_to_phys(data_out);
302
303 init_job_desc(desc, 0);
304 append_operation(desc, OP_ALG_ALGSEL_RNG | OP_TYPE_CLASS1_ALG |
305 OP_ALG_PR_ON);
306 append_fifo_store(desc, dma_data_out, size, FIFOST_TYPE_RNGSTORE);
307 }
308
309 /* Change key size to bytes form bits in calling function*/
inline_cnstr_jobdesc_pkha_rsaexp(uint32_t * desc,struct pk_in_params * pkin,uint8_t * out,uint32_t out_siz)310 void inline_cnstr_jobdesc_pkha_rsaexp(uint32_t *desc,
311 struct pk_in_params *pkin, uint8_t *out,
312 uint32_t out_siz)
313 {
314 dma_addr_t dma_addr_e, dma_addr_a, dma_addr_n, dma_addr_out;
315
316 dma_addr_e = virt_to_phys((void *)pkin->e);
317 dma_addr_a = virt_to_phys((void *)pkin->a);
318 dma_addr_n = virt_to_phys((void *)pkin->n);
319 dma_addr_out = virt_to_phys((void *)out);
320
321 init_job_desc(desc, 0);
322 append_key(desc, dma_addr_e, pkin->e_siz, KEY_DEST_PKHA_E | CLASS_1);
323
324 append_fifo_load(desc, dma_addr_a,
325 pkin->a_siz, LDST_CLASS_1_CCB | FIFOLD_TYPE_PK_A);
326
327 append_fifo_load(desc, dma_addr_n,
328 pkin->n_siz, LDST_CLASS_1_CCB | FIFOLD_TYPE_PK_N);
329
330 append_operation(desc, OP_TYPE_PK | OP_ALG_PK | OP_ALG_PKMODE_MOD_EXPO);
331
332 append_fifo_store(desc, dma_addr_out, out_siz,
333 LDST_CLASS_1_CCB | FIFOST_TYPE_PKHA_B);
334 }
335