2 * Copyright 2014 Freescale Semiconductor, Inc.
4 * SPDX-License-Identifier: GPL-2.0+
16 #include <linux/errno.h>
18 #define CRYPTO_MAX_ALG_NAME 80
19 #define SHA1_DIGEST_SIZE 20
20 #define SHA256_DIGEST_SIZE 32
22 struct caam_hash_template {
23 char name[CRYPTO_MAX_ALG_NAME];
24 unsigned int digestsize;
28 enum caam_hash_algos {
33 static struct caam_hash_template driver_hash[] = {
36 .digestsize = SHA1_DIGEST_SIZE,
37 .alg_type = OP_ALG_ALGSEL_SHA1,
41 .digestsize = SHA256_DIGEST_SIZE,
42 .alg_type = OP_ALG_ALGSEL_SHA256,
46 static enum caam_hash_algos get_hash_type(struct hash_algo *algo)
48 if (!strcmp(algo->name, driver_hash[SHA1].name))
54 /* Create the context for progressive hashing using h/w acceleration.
56 * @ctxp: Pointer to the pointer of the context for hashing
57 * @caam_algo: Enum for SHA1 or SHA256
58 * @return 0 if ok, -ENOMEM on error
60 static int caam_hash_init(void **ctxp, enum caam_hash_algos caam_algo)
62 *ctxp = calloc(1, sizeof(struct sha_ctx));
64 debug("Cannot allocate memory for context\n");
71 * Update sg table for progressive hashing using h/w acceleration
73 * The context is freed by this function if an error occurs.
74 * We support at most 32 Scatter/Gather Entries.
76 * @hash_ctx: Pointer to the context for hashing
77 * @buf: Pointer to the buffer being hashed
78 * @size: Size of the buffer being hashed
79 * @is_last: 1 if this is the last update; 0 otherwise
80 * @caam_algo: Enum for SHA1 or SHA256
81 * @return 0 if ok, -EINVAL on error
83 static int caam_hash_update(void *hash_ctx, const void *buf,
84 unsigned int size, int is_last,
85 enum caam_hash_algos caam_algo)
88 phys_addr_t addr = virt_to_phys((void *)buf);
89 struct sha_ctx *ctx = hash_ctx;
91 if (ctx->sg_num >= MAX_SG_32) {
96 #ifdef CONFIG_PHYS_64BIT
97 sec_out32(&ctx->sg_tbl[ctx->sg_num].addr_hi, (uint32_t)(addr >> 32));
99 sec_out32(&ctx->sg_tbl[ctx->sg_num].addr_hi, 0x0);
101 sec_out32(&ctx->sg_tbl[ctx->sg_num].addr_lo, (uint32_t)addr);
103 sec_out32(&ctx->sg_tbl[ctx->sg_num].len_flag,
104 (size & SG_ENTRY_LENGTH_MASK));
109 final = sec_in32(&ctx->sg_tbl[ctx->sg_num - 1].len_flag) |
111 sec_out32(&ctx->sg_tbl[ctx->sg_num - 1].len_flag, final);
118 * Perform progressive hashing on the given buffer and copy hash at
121 * The context is freed after completion of hash operation.
123 * @hash_ctx: Pointer to the context for hashing
124 * @dest_buf: Pointer to the destination buffer where hash is to be copied
125 * @size: Size of the buffer being hashed
126 * @caam_algo: Enum for SHA1 or SHA256
127 * @return 0 if ok, -EINVAL on error
129 static int caam_hash_finish(void *hash_ctx, void *dest_buf,
130 int size, enum caam_hash_algos caam_algo)
133 struct sha_ctx *ctx = hash_ctx;
136 if (size < driver_hash[caam_algo].digestsize) {
141 for (i = 0; i < ctx->sg_num; i++)
142 len += (sec_in32(&ctx->sg_tbl[i].len_flag) &
143 SG_ENTRY_LENGTH_MASK);
145 inline_cnstr_jobdesc_hash(ctx->sha_desc, (uint8_t *)ctx->sg_tbl, len,
147 driver_hash[caam_algo].alg_type,
148 driver_hash[caam_algo].digestsize,
151 ret = run_descriptor_jr(ctx->sha_desc);
154 debug("Error %x\n", ret);
156 memcpy(dest_buf, ctx->hash, sizeof(ctx->hash));
162 int caam_hash(const unsigned char *pbuf, unsigned int buf_len,
163 unsigned char *pout, enum caam_hash_algos algo)
169 desc = malloc_cache_aligned(sizeof(int) * MAX_CAAM_DESCSIZE);
171 debug("Not enough memory for descriptor allocation\n");
175 if (!IS_ALIGNED((uintptr_t)pbuf, ARCH_DMA_MINALIGN) ||
176 !IS_ALIGNED((uintptr_t)pout, ARCH_DMA_MINALIGN)) {
177 puts("Error: Address arguments are not aligned\n");
181 size = ALIGN(buf_len, ARCH_DMA_MINALIGN);
182 flush_dcache_range((unsigned long)pbuf, (unsigned long)pbuf + size);
184 inline_cnstr_jobdesc_hash(desc, pbuf, buf_len, pout,
185 driver_hash[algo].alg_type,
186 driver_hash[algo].digestsize,
189 size = ALIGN(sizeof(int) * MAX_CAAM_DESCSIZE, ARCH_DMA_MINALIGN);
190 flush_dcache_range((unsigned long)desc, (unsigned long)desc + size);
192 ret = run_descriptor_jr(desc);
194 size = ALIGN(driver_hash[algo].digestsize, ARCH_DMA_MINALIGN);
195 invalidate_dcache_range((unsigned long)pout,
196 (unsigned long)pout + size);
202 void hw_sha256(const unsigned char *pbuf, unsigned int buf_len,
203 unsigned char *pout, unsigned int chunk_size)
205 if (caam_hash(pbuf, buf_len, pout, SHA256))
206 printf("CAAM was not setup properly or it is faulty\n");
209 void hw_sha1(const unsigned char *pbuf, unsigned int buf_len,
210 unsigned char *pout, unsigned int chunk_size)
212 if (caam_hash(pbuf, buf_len, pout, SHA1))
213 printf("CAAM was not setup properly or it is faulty\n");
216 int hw_sha_init(struct hash_algo *algo, void **ctxp)
218 return caam_hash_init(ctxp, get_hash_type(algo));
221 int hw_sha_update(struct hash_algo *algo, void *ctx, const void *buf,
222 unsigned int size, int is_last)
224 return caam_hash_update(ctx, buf, size, is_last, get_hash_type(algo));
227 int hw_sha_finish(struct hash_algo *algo, void *ctx, void *dest_buf,
230 return caam_hash_finish(ctx, dest_buf, size, get_hash_type(algo));