1
2
3
4
5
6
7#include <common.h>
8#include <cpu_func.h>
9#include <log.h>
10#include <malloc.h>
11#include <memalign.h>
12#include "jobdesc.h"
13#include "desc.h"
14#include "jr.h"
15#include "fsl_hash.h"
16#include <hw_sha.h>
17#include <asm/cache.h>
18#include <linux/errno.h>
19
20#define CRYPTO_MAX_ALG_NAME 80
21#define SHA1_DIGEST_SIZE 20
22#define SHA256_DIGEST_SIZE 32
23
24struct caam_hash_template {
25 char name[CRYPTO_MAX_ALG_NAME];
26 unsigned int digestsize;
27 u32 alg_type;
28};
29
30enum caam_hash_algos {
31 SHA1 = 0,
32 SHA256
33};
34
35static struct caam_hash_template driver_hash[] = {
36 {
37 .name = "sha1",
38 .digestsize = SHA1_DIGEST_SIZE,
39 .alg_type = OP_ALG_ALGSEL_SHA1,
40 },
41 {
42 .name = "sha256",
43 .digestsize = SHA256_DIGEST_SIZE,
44 .alg_type = OP_ALG_ALGSEL_SHA256,
45 },
46};
47
48static enum caam_hash_algos get_hash_type(struct hash_algo *algo)
49{
50 if (!strcmp(algo->name, driver_hash[SHA1].name))
51 return SHA1;
52 else
53 return SHA256;
54}
55
56
57
58
59
60
61
62static int caam_hash_init(void **ctxp, enum caam_hash_algos caam_algo)
63{
64 *ctxp = calloc(1, sizeof(struct sha_ctx));
65 if (*ctxp == NULL) {
66 debug("Cannot allocate memory for context\n");
67 return -ENOMEM;
68 }
69 return 0;
70}
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85static int caam_hash_update(void *hash_ctx, const void *buf,
86 unsigned int size, int is_last,
87 enum caam_hash_algos caam_algo)
88{
89 uint32_t final;
90 phys_addr_t addr = virt_to_phys((void *)buf);
91 struct sha_ctx *ctx = hash_ctx;
92
93 if (ctx->sg_num >= MAX_SG_32) {
94 free(ctx);
95 return -EINVAL;
96 }
97
98#ifdef CONFIG_PHYS_64BIT
99 sec_out32(&ctx->sg_tbl[ctx->sg_num].addr_hi, (uint32_t)(addr >> 32));
100#else
101 sec_out32(&ctx->sg_tbl[ctx->sg_num].addr_hi, 0x0);
102#endif
103 sec_out32(&ctx->sg_tbl[ctx->sg_num].addr_lo, (uint32_t)addr);
104
105 sec_out32(&ctx->sg_tbl[ctx->sg_num].len_flag,
106 (size & SG_ENTRY_LENGTH_MASK));
107
108 ctx->sg_num++;
109
110 if (is_last) {
111 final = sec_in32(&ctx->sg_tbl[ctx->sg_num - 1].len_flag) |
112 SG_ENTRY_FINAL_BIT;
113 sec_out32(&ctx->sg_tbl[ctx->sg_num - 1].len_flag, final);
114 }
115
116 return 0;
117}
118
119
120
121
122
123
124
125
126
127
128
129
130
131static int caam_hash_finish(void *hash_ctx, void *dest_buf,
132 int size, enum caam_hash_algos caam_algo)
133{
134 uint32_t len = 0;
135 struct sha_ctx *ctx = hash_ctx;
136 int i = 0, ret = 0;
137
138 if (size < driver_hash[caam_algo].digestsize) {
139 free(ctx);
140 return -EINVAL;
141 }
142
143 for (i = 0; i < ctx->sg_num; i++)
144 len += (sec_in32(&ctx->sg_tbl[i].len_flag) &
145 SG_ENTRY_LENGTH_MASK);
146
147 inline_cnstr_jobdesc_hash(ctx->sha_desc, (uint8_t *)ctx->sg_tbl, len,
148 ctx->hash,
149 driver_hash[caam_algo].alg_type,
150 driver_hash[caam_algo].digestsize,
151 1);
152
153 ret = run_descriptor_jr(ctx->sha_desc);
154
155 if (ret)
156 debug("Error %x\n", ret);
157 else
158 memcpy(dest_buf, ctx->hash, sizeof(ctx->hash));
159
160 free(ctx);
161 return ret;
162}
163
164int caam_hash(const unsigned char *pbuf, unsigned int buf_len,
165 unsigned char *pout, enum caam_hash_algos algo)
166{
167 int ret = 0;
168 uint32_t *desc;
169 unsigned int size;
170
171 desc = malloc_cache_aligned(sizeof(int) * MAX_CAAM_DESCSIZE);
172 if (!desc) {
173 debug("Not enough memory for descriptor allocation\n");
174 return -ENOMEM;
175 }
176
177 if (!IS_ALIGNED((uintptr_t)pbuf, ARCH_DMA_MINALIGN) ||
178 !IS_ALIGNED((uintptr_t)pout, ARCH_DMA_MINALIGN)) {
179 puts("Error: Address arguments are not aligned\n");
180 return -EINVAL;
181 }
182
183 size = ALIGN(buf_len, ARCH_DMA_MINALIGN);
184 flush_dcache_range((unsigned long)pbuf, (unsigned long)pbuf + size);
185
186 inline_cnstr_jobdesc_hash(desc, pbuf, buf_len, pout,
187 driver_hash[algo].alg_type,
188 driver_hash[algo].digestsize,
189 0);
190
191 size = ALIGN(sizeof(int) * MAX_CAAM_DESCSIZE, ARCH_DMA_MINALIGN);
192 flush_dcache_range((unsigned long)desc, (unsigned long)desc + size);
193
194 ret = run_descriptor_jr(desc);
195
196 size = ALIGN(driver_hash[algo].digestsize, ARCH_DMA_MINALIGN);
197 invalidate_dcache_range((unsigned long)pout,
198 (unsigned long)pout + size);
199
200 free(desc);
201 return ret;
202}
203
204void hw_sha256(const unsigned char *pbuf, unsigned int buf_len,
205 unsigned char *pout, unsigned int chunk_size)
206{
207 if (caam_hash(pbuf, buf_len, pout, SHA256))
208 printf("CAAM was not setup properly or it is faulty\n");
209}
210
211void hw_sha1(const unsigned char *pbuf, unsigned int buf_len,
212 unsigned char *pout, unsigned int chunk_size)
213{
214 if (caam_hash(pbuf, buf_len, pout, SHA1))
215 printf("CAAM was not setup properly or it is faulty\n");
216}
217
218int hw_sha_init(struct hash_algo *algo, void **ctxp)
219{
220 return caam_hash_init(ctxp, get_hash_type(algo));
221}
222
223int hw_sha_update(struct hash_algo *algo, void *ctx, const void *buf,
224 unsigned int size, int is_last)
225{
226 return caam_hash_update(ctx, buf, size, is_last, get_hash_type(algo));
227}
228
229int hw_sha_finish(struct hash_algo *algo, void *ctx, void *dest_buf,
230 int size)
231{
232 return caam_hash_finish(ctx, dest_buf, size, get_hash_type(algo));
233}
234