mirror of
https://github.com/torvalds/linux.git
synced 2024-11-10 22:21:40 +00:00
crypto: sahara - add support for SHA1/256
Add support for the MDHA unit in the SAHARA core. The MDHA can generate hash digests for MD5 and SHA1 in version 3 and additionally SHA224 and SHA256 in version 4. Add the SHA1 and SHA256 algorithms to the driver. The implementation was tested with the in-kernel testmgr and a userspace testprogram using AF_ALG with+without upto 128 pthreads on each AES and SHA256 on i.MX53. Signed-off-by: Steffen Trumtrar <s.trumtrar@pengutronix.de> Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
This commit is contained in:
Steffen Trumtrar
Herbert Xu
parent
c0c3c89ae3
commit
5a2bb93f59
@ -3,6 +3,7 @@
|
||||
*
|
||||
* Support for SAHARA cryptographic accelerator.
|
||||
*
|
||||
* Copyright (c) 2014 Steffen Trumtrar <s.trumtrar@pengutronix.de>
|
||||
* Copyright (c) 2013 Vista Silicon S.L.
|
||||
* Author: Javier Martin <javier.martin@vista-silicon.com>
|
||||
*
|
||||
@ -15,6 +16,10 @@
|
||||
|
||||
#include <crypto/algapi.h>
|
||||
#include <crypto/aes.h>
|
||||
#include <crypto/hash.h>
|
||||
#include <crypto/internal/hash.h>
|
||||
#include <crypto/scatterwalk.h>
|
||||
#include <crypto/sha.h>
|
||||
|
||||
#include <linux/clk.h>
|
||||
#include <linux/crypto.h>
|
||||
@ -29,6 +34,9 @@
|
||||
#include <linux/of_device.h>
|
||||
#include <linux/platform_device.h>
|
||||
|
||||
#define SHA_BUFFER_LEN PAGE_SIZE
|
||||
#define SAHARA_MAX_SHA_BLOCK_SIZE SHA256_BLOCK_SIZE
|
||||
|
||||
#define SAHARA_NAME "sahara"
|
||||
#define SAHARA_VERSION_3 3
|
||||
#define SAHARA_VERSION_4 4
|
||||
@ -53,6 +61,23 @@
|
||||
#define SAHARA_HDR_CHA_MDHA (2 << 28)
|
||||
#define SAHARA_HDR_PARITY_BIT (1 << 31)
|
||||
|
||||
#define SAHARA_HDR_MDHA_SET_MODE_MD_KEY 0x20880000
|
||||
#define SAHARA_HDR_MDHA_SET_MODE_HASH 0x208D0000
|
||||
#define SAHARA_HDR_MDHA_HASH 0xA0850000
|
||||
#define SAHARA_HDR_MDHA_STORE_DIGEST 0x20820000
|
||||
#define SAHARA_HDR_MDHA_ALG_SHA1 0
|
||||
#define SAHARA_HDR_MDHA_ALG_MD5 1
|
||||
#define SAHARA_HDR_MDHA_ALG_SHA256 2
|
||||
#define SAHARA_HDR_MDHA_ALG_SHA224 3
|
||||
#define SAHARA_HDR_MDHA_PDATA (1 << 2)
|
||||
#define SAHARA_HDR_MDHA_HMAC (1 << 3)
|
||||
#define SAHARA_HDR_MDHA_INIT (1 << 5)
|
||||
#define SAHARA_HDR_MDHA_IPAD (1 << 6)
|
||||
#define SAHARA_HDR_MDHA_OPAD (1 << 7)
|
||||
#define SAHARA_HDR_MDHA_SWAP (1 << 8)
|
||||
#define SAHARA_HDR_MDHA_MAC_FULL (1 << 9)
|
||||
#define SAHARA_HDR_MDHA_SSL (1 << 10)
|
||||
|
||||
/* SAHARA can only process one request at a time */
|
||||
#define SAHARA_QUEUE_LENGTH 1
|
||||
|
||||
@ -121,15 +146,58 @@ struct sahara_hw_link {
|
||||
|
||||
struct sahara_ctx {
|
||||
unsigned long flags;
|
||||
|
||||
/* AES-specific context */
|
||||
int keylen;
|
||||
u8 key[AES_KEYSIZE_128];
|
||||
struct crypto_ablkcipher *fallback;
|
||||
|
||||
/* SHA-specific context */
|
||||
struct crypto_shash *shash_fallback;
|
||||
};
|
||||
|
||||
struct sahara_aes_reqctx {
|
||||
unsigned long mode;
|
||||
};
|
||||
|
||||
/*
|
||||
* struct sahara_sha_reqctx - private data per request
|
||||
* @buf: holds data for requests smaller than block_size
|
||||
* @rembuf: used to prepare one block_size-aligned request
|
||||
* @context: hw-specific context for request. Digest is extracted from this
|
||||
* @mode: specifies what type of hw-descriptor needs to be built
|
||||
* @digest_size: length of digest for this request
|
||||
* @context_size: length of hw-context for this request.
|
||||
* Always digest_size + 4
|
||||
* @buf_cnt: number of bytes saved in buf
|
||||
* @sg_in_idx: number of hw links
|
||||
* @in_sg: scatterlist for input data
|
||||
* @in_sg_chain: scatterlists for chained input data
|
||||
* @in_sg_chained: specifies if chained scatterlists are used or not
|
||||
* @total: total number of bytes for transfer
|
||||
* @last: is this the last block
|
||||
* @first: is this the first block
|
||||
* @active: inside a transfer
|
||||
*/
|
||||
struct sahara_sha_reqctx {
|
||||
u8 buf[SAHARA_MAX_SHA_BLOCK_SIZE];
|
||||
u8 rembuf[SAHARA_MAX_SHA_BLOCK_SIZE];
|
||||
u8 context[SHA256_DIGEST_SIZE + 4];
|
||||
struct mutex mutex;
|
||||
unsigned int mode;
|
||||
unsigned int digest_size;
|
||||
unsigned int context_size;
|
||||
unsigned int buf_cnt;
|
||||
unsigned int sg_in_idx;
|
||||
struct scatterlist *in_sg;
|
||||
struct scatterlist in_sg_chain[2];
|
||||
bool in_sg_chained;
|
||||
size_t total;
|
||||
unsigned int last;
|
||||
unsigned int first;
|
||||
unsigned int active;
|
||||
};
|
||||
|
||||
struct sahara_dev {
|
||||
struct device *device;
|
||||
unsigned int version;
|
||||
@ -154,6 +222,9 @@ struct sahara_dev {
|
||||
u8 *iv_base;
|
||||
dma_addr_t iv_phys_base;
|
||||
|
||||
u8 *context_base;
|
||||
dma_addr_t context_phys_base;
|
||||
|
||||
struct sahara_hw_link *hw_link[SAHARA_MAX_HW_LINK];
|
||||
dma_addr_t hw_phys_link[SAHARA_MAX_HW_LINK];
|
||||
|
||||
@ -707,6 +778,316 @@ static void sahara_aes_cra_exit(struct crypto_tfm *tfm)
|
||||
ctx->fallback = NULL;
|
||||
}
|
||||
|
||||
static u32 sahara_sha_init_hdr(struct sahara_dev *dev,
|
||||
struct sahara_sha_reqctx *rctx)
|
||||
{
|
||||
u32 hdr = 0;
|
||||
|
||||
hdr = rctx->mode;
|
||||
|
||||
if (rctx->first) {
|
||||
hdr |= SAHARA_HDR_MDHA_SET_MODE_HASH;
|
||||
hdr |= SAHARA_HDR_MDHA_INIT;
|
||||
} else {
|
||||
hdr |= SAHARA_HDR_MDHA_SET_MODE_MD_KEY;
|
||||
}
|
||||
|
||||
if (rctx->last)
|
||||
hdr |= SAHARA_HDR_MDHA_PDATA;
|
||||
|
||||
if (hweight_long(hdr) % 2 == 0)
|
||||
hdr |= SAHARA_HDR_PARITY_BIT;
|
||||
|
||||
return hdr;
|
||||
}
|
||||
|
||||
static int sahara_sha_hw_links_create(struct sahara_dev *dev,
|
||||
struct sahara_sha_reqctx *rctx,
|
||||
int start)
|
||||
{
|
||||
struct scatterlist *sg;
|
||||
unsigned int i;
|
||||
int ret;
|
||||
|
||||
dev->in_sg = rctx->in_sg;
|
||||
|
||||
dev->nb_in_sg = sahara_sg_length(dev->in_sg, rctx->total);
|
||||
if ((dev->nb_in_sg) > SAHARA_MAX_HW_LINK) {
|
||||
dev_err(dev->device, "not enough hw links (%d)\n",
|
||||
dev->nb_in_sg + dev->nb_out_sg);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (rctx->in_sg_chained) {
|
||||
i = start;
|
||||
sg = dev->in_sg;
|
||||
while (sg) {
|
||||
ret = dma_map_sg(dev->device, sg, 1,
|
||||
DMA_TO_DEVICE);
|
||||
if (!ret)
|
||||
return -EFAULT;
|
||||
|
||||
dev->hw_link[i]->len = sg->length;
|
||||
dev->hw_link[i]->p = sg->dma_address;
|
||||
dev->hw_link[i]->next = dev->hw_phys_link[i + 1];
|
||||
sg = sg_next(sg);
|
||||
i += 1;
|
||||
}
|
||||
dev->hw_link[i-1]->next = 0;
|
||||
} else {
|
||||
sg = dev->in_sg;
|
||||
ret = dma_map_sg(dev->device, dev->in_sg, dev->nb_in_sg,
|
||||
DMA_TO_DEVICE);
|
||||
if (!ret)
|
||||
return -EFAULT;
|
||||
|
||||
for (i = start; i < dev->nb_in_sg + start; i++) {
|
||||
dev->hw_link[i]->len = sg->length;
|
||||
dev->hw_link[i]->p = sg->dma_address;
|
||||
if (i == (dev->nb_in_sg + start - 1)) {
|
||||
dev->hw_link[i]->next = 0;
|
||||
} else {
|
||||
dev->hw_link[i]->next = dev->hw_phys_link[i + 1];
|
||||
sg = sg_next(sg);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
static int sahara_sha_hw_data_descriptor_create(struct sahara_dev *dev,
|
||||
struct sahara_sha_reqctx *rctx,
|
||||
struct ahash_request *req,
|
||||
int index)
|
||||
{
|
||||
unsigned result_len;
|
||||
int i = index;
|
||||
|
||||
if (rctx->first)
|
||||
/* Create initial descriptor: #8*/
|
||||
dev->hw_desc[index]->hdr = sahara_sha_init_hdr(dev, rctx);
|
||||
else
|
||||
/* Create hash descriptor: #10. Must follow #6. */
|
||||
dev->hw_desc[index]->hdr = SAHARA_HDR_MDHA_HASH;
|
||||
|
||||
dev->hw_desc[index]->len1 = rctx->total;
|
||||
if (dev->hw_desc[index]->len1 == 0) {
|
||||
/* if len1 is 0, p1 must be 0, too */
|
||||
dev->hw_desc[index]->p1 = 0;
|
||||
rctx->sg_in_idx = 0;
|
||||
} else {
|
||||
/* Create input links */
|
||||
dev->hw_desc[index]->p1 = dev->hw_phys_link[index];
|
||||
i = sahara_sha_hw_links_create(dev, rctx, index);
|
||||
|
||||
rctx->sg_in_idx = index;
|
||||
if (i < 0)
|
||||
return i;
|
||||
}
|
||||
|
||||
dev->hw_desc[index]->p2 = dev->hw_phys_link[i];
|
||||
|
||||
/* Save the context for the next operation */
|
||||
result_len = rctx->context_size;
|
||||
dev->hw_link[i]->p = dev->context_phys_base;
|
||||
|
||||
dev->hw_link[i]->len = result_len;
|
||||
dev->hw_desc[index]->len2 = result_len;
|
||||
|
||||
dev->hw_link[i]->next = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Load descriptor aka #6
|
||||
*
|
||||
* To load a previously saved context back to the MDHA unit
|
||||
*
|
||||
* p1: Saved Context
|
||||
* p2: NULL
|
||||
*
|
||||
*/
|
||||
static int sahara_sha_hw_context_descriptor_create(struct sahara_dev *dev,
|
||||
struct sahara_sha_reqctx *rctx,
|
||||
struct ahash_request *req,
|
||||
int index)
|
||||
{
|
||||
dev->hw_desc[index]->hdr = sahara_sha_init_hdr(dev, rctx);
|
||||
|
||||
dev->hw_desc[index]->len1 = rctx->context_size;
|
||||
dev->hw_desc[index]->p1 = dev->hw_phys_link[index];
|
||||
dev->hw_desc[index]->len2 = 0;
|
||||
dev->hw_desc[index]->p2 = 0;
|
||||
|
||||
dev->hw_link[index]->len = rctx->context_size;
|
||||
dev->hw_link[index]->p = dev->context_phys_base;
|
||||
dev->hw_link[index]->next = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sahara_walk_and_recalc(struct scatterlist *sg, unsigned int nbytes)
|
||||
{
|
||||
if (!sg || !sg->length)
|
||||
return nbytes;
|
||||
|
||||
while (nbytes && sg) {
|
||||
if (nbytes <= sg->length) {
|
||||
sg->length = nbytes;
|
||||
sg_mark_end(sg);
|
||||
break;
|
||||
}
|
||||
nbytes -= sg->length;
|
||||
sg = scatterwalk_sg_next(sg);
|
||||
}
|
||||
|
||||
return nbytes;
|
||||
}
|
||||
|
||||
static int sahara_sha_prepare_request(struct ahash_request *req)
|
||||
{
|
||||
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
|
||||
struct sahara_sha_reqctx *rctx = ahash_request_ctx(req);
|
||||
unsigned int hash_later;
|
||||
unsigned int block_size;
|
||||
unsigned int len;
|
||||
|
||||
block_size = crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm));
|
||||
|
||||
/* append bytes from previous operation */
|
||||
len = rctx->buf_cnt + req->nbytes;
|
||||
|
||||
/* only the last transfer can be padded in hardware */
|
||||
if (!rctx->last && (len < block_size)) {
|
||||
/* to few data, save for next operation */
|
||||
scatterwalk_map_and_copy(rctx->buf + rctx->buf_cnt, req->src,
|
||||
0, req->nbytes, 0);
|
||||
rctx->buf_cnt += req->nbytes;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* add data from previous operation first */
|
||||
if (rctx->buf_cnt)
|
||||
memcpy(rctx->rembuf, rctx->buf, rctx->buf_cnt);
|
||||
|
||||
/* data must always be a multiple of block_size */
|
||||
hash_later = rctx->last ? 0 : len & (block_size - 1);
|
||||
if (hash_later) {
|
||||
unsigned int offset = req->nbytes - hash_later;
|
||||
/* Save remaining bytes for later use */
|
||||
scatterwalk_map_and_copy(rctx->buf, req->src, offset,
|
||||
hash_later, 0);
|
||||
}
|
||||
|
||||
/* nbytes should now be multiple of blocksize */
|
||||
req->nbytes = req->nbytes - hash_later;
|
||||
|
||||
sahara_walk_and_recalc(req->src, req->nbytes);
|
||||
|
||||
/* have data from previous operation and current */
|
||||
if (rctx->buf_cnt && req->nbytes) {
|
||||
sg_init_table(rctx->in_sg_chain, 2);
|
||||
sg_set_buf(rctx->in_sg_chain, rctx->rembuf, rctx->buf_cnt);
|
||||
|
||||
scatterwalk_sg_chain(rctx->in_sg_chain, 2, req->src);
|
||||
|
||||
rctx->total = req->nbytes + rctx->buf_cnt;
|
||||
rctx->in_sg = rctx->in_sg_chain;
|
||||
|
||||
rctx->in_sg_chained = true;
|
||||
req->src = rctx->in_sg_chain;
|
||||
/* only data from previous operation */
|
||||
} else if (rctx->buf_cnt) {
|
||||
if (req->src)
|
||||
rctx->in_sg = req->src;
|
||||
else
|
||||
rctx->in_sg = rctx->in_sg_chain;
|
||||
/* buf was copied into rembuf above */
|
||||
sg_init_one(rctx->in_sg, rctx->rembuf, rctx->buf_cnt);
|
||||
rctx->total = rctx->buf_cnt;
|
||||
rctx->in_sg_chained = false;
|
||||
/* no data from previous operation */
|
||||
} else {
|
||||
rctx->in_sg = req->src;
|
||||
rctx->total = req->nbytes;
|
||||
req->src = rctx->in_sg;
|
||||
rctx->in_sg_chained = false;
|
||||
}
|
||||
|
||||
/* on next call, we only have the remaining data in the buffer */
|
||||
rctx->buf_cnt = hash_later;
|
||||
|
||||
return -EINPROGRESS;
|
||||
}
|
||||
|
||||
static void sahara_sha_unmap_sg(struct sahara_dev *dev,
|
||||
struct sahara_sha_reqctx *rctx)
|
||||
{
|
||||
struct scatterlist *sg;
|
||||
|
||||
if (rctx->in_sg_chained) {
|
||||
sg = dev->in_sg;
|
||||
while (sg) {
|
||||
dma_unmap_sg(dev->device, sg, 1, DMA_TO_DEVICE);
|
||||
sg = sg_next(sg);
|
||||
}
|
||||
} else {
|
||||
dma_unmap_sg(dev->device, dev->in_sg, dev->nb_in_sg,
|
||||
DMA_TO_DEVICE);
|
||||
}
|
||||
}
|
||||
|
||||
static int sahara_sha_process(struct ahash_request *req)
|
||||
{
|
||||
struct sahara_dev *dev = dev_ptr;
|
||||
struct sahara_sha_reqctx *rctx = ahash_request_ctx(req);
|
||||
int ret = -EINPROGRESS;
|
||||
|
||||
ret = sahara_sha_prepare_request(req);
|
||||
if (!ret)
|
||||
return ret;
|
||||
|
||||
if (rctx->first) {
|
||||
sahara_sha_hw_data_descriptor_create(dev, rctx, req, 0);
|
||||
dev->hw_desc[0]->next = 0;
|
||||
rctx->first = 0;
|
||||
} else {
|
||||
memcpy(dev->context_base, rctx->context, rctx->context_size);
|
||||
|
||||
sahara_sha_hw_context_descriptor_create(dev, rctx, req, 0);
|
||||
dev->hw_desc[0]->next = dev->hw_phys_desc[1];
|
||||
sahara_sha_hw_data_descriptor_create(dev, rctx, req, 1);
|
||||
dev->hw_desc[1]->next = 0;
|
||||
}
|
||||
|
||||
sahara_dump_descriptors(dev);
|
||||
sahara_dump_links(dev);
|
||||
|
||||
reinit_completion(&dev->dma_completion);
|
||||
|
||||
sahara_write(dev, dev->hw_phys_desc[0], SAHARA_REG_DAR);
|
||||
|
||||
ret = wait_for_completion_timeout(&dev->dma_completion,
|
||||
msecs_to_jiffies(SAHARA_TIMEOUT_MS));
|
||||
if (!ret) {
|
||||
dev_err(dev->device, "SHA timeout\n");
|
||||
return -ETIMEDOUT;
|
||||
}
|
||||
|
||||
if (rctx->sg_in_idx)
|
||||
sahara_sha_unmap_sg(dev, rctx);
|
||||
|
||||
memcpy(rctx->context, dev->context_base, rctx->context_size);
|
||||
|
||||
if (req->result)
|
||||
memcpy(req->result, rctx->context, rctx->digest_size);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sahara_queue_manage(void *data)
|
||||
{
|
||||
struct sahara_dev *dev = (struct sahara_dev *)data;
|
||||
@ -721,10 +1102,18 @@ static int sahara_queue_manage(void *data)
|
||||
mutex_unlock(&dev->queue_mutex);
|
||||
|
||||
if (async_req) {
|
||||
struct ablkcipher_request *req =
|
||||
ablkcipher_request_cast(async_req);
|
||||
if (crypto_tfm_alg_type(async_req->tfm) ==
|
||||
CRYPTO_ALG_TYPE_AHASH) {
|
||||
struct ahash_request *req =
|
||||
ahash_request_cast(async_req);
|
||||
|
||||
ret = sahara_aes_process(req);
|
||||
ret = sahara_sha_process(req);
|
||||
} else {
|
||||
struct ablkcipher_request *req =
|
||||
ablkcipher_request_cast(async_req);
|
||||
|
||||
ret = sahara_aes_process(req);
|
||||
}
|
||||
|
||||
async_req->complete(async_req, ret);
|
||||
|
||||
@ -737,6 +1126,136 @@ static int sahara_queue_manage(void *data)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sahara_sha_enqueue(struct ahash_request *req, int last)
|
||||
{
|
||||
struct sahara_sha_reqctx *rctx = ahash_request_ctx(req);
|
||||
struct sahara_dev *dev = dev_ptr;
|
||||
int ret;
|
||||
|
||||
if (!req->nbytes && !last)
|
||||
return 0;
|
||||
|
||||
mutex_lock(&rctx->mutex);
|
||||
rctx->last = last;
|
||||
|
||||
if (!rctx->active) {
|
||||
rctx->active = 1;
|
||||
rctx->first = 1;
|
||||
}
|
||||
|
||||
mutex_lock(&dev->queue_mutex);
|
||||
ret = crypto_enqueue_request(&dev->queue, &req->base);
|
||||
mutex_unlock(&dev->queue_mutex);
|
||||
|
||||
wake_up_process(dev->kthread);
|
||||
mutex_unlock(&rctx->mutex);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int sahara_sha_init(struct ahash_request *req)
|
||||
{
|
||||
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
|
||||
struct sahara_sha_reqctx *rctx = ahash_request_ctx(req);
|
||||
|
||||
memset(rctx, 0, sizeof(*rctx));
|
||||
|
||||
switch (crypto_ahash_digestsize(tfm)) {
|
||||
case SHA1_DIGEST_SIZE:
|
||||
rctx->mode |= SAHARA_HDR_MDHA_ALG_SHA1;
|
||||
rctx->digest_size = SHA1_DIGEST_SIZE;
|
||||
break;
|
||||
case SHA256_DIGEST_SIZE:
|
||||
rctx->mode |= SAHARA_HDR_MDHA_ALG_SHA256;
|
||||
rctx->digest_size = SHA256_DIGEST_SIZE;
|
||||
break;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
rctx->context_size = rctx->digest_size + 4;
|
||||
rctx->active = 0;
|
||||
|
||||
mutex_init(&rctx->mutex);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sahara_sha_update(struct ahash_request *req)
|
||||
{
|
||||
return sahara_sha_enqueue(req, 0);
|
||||
}
|
||||
|
||||
static int sahara_sha_final(struct ahash_request *req)
|
||||
{
|
||||
req->nbytes = 0;
|
||||
return sahara_sha_enqueue(req, 1);
|
||||
}
|
||||
|
||||
static int sahara_sha_finup(struct ahash_request *req)
|
||||
{
|
||||
return sahara_sha_enqueue(req, 1);
|
||||
}
|
||||
|
||||
static int sahara_sha_digest(struct ahash_request *req)
|
||||
{
|
||||
sahara_sha_init(req);
|
||||
|
||||
return sahara_sha_finup(req);
|
||||
}
|
||||
|
||||
static int sahara_sha_export(struct ahash_request *req, void *out)
|
||||
{
|
||||
struct crypto_ahash *ahash = crypto_ahash_reqtfm(req);
|
||||
struct sahara_ctx *ctx = crypto_ahash_ctx(ahash);
|
||||
struct sahara_sha_reqctx *rctx = ahash_request_ctx(req);
|
||||
|
||||
memcpy(out, ctx, sizeof(struct sahara_ctx));
|
||||
memcpy(out + sizeof(struct sahara_sha_reqctx), rctx,
|
||||
sizeof(struct sahara_sha_reqctx));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sahara_sha_import(struct ahash_request *req, const void *in)
|
||||
{
|
||||
struct crypto_ahash *ahash = crypto_ahash_reqtfm(req);
|
||||
struct sahara_ctx *ctx = crypto_ahash_ctx(ahash);
|
||||
struct sahara_sha_reqctx *rctx = ahash_request_ctx(req);
|
||||
|
||||
memcpy(ctx, in, sizeof(struct sahara_ctx));
|
||||
memcpy(rctx, in + sizeof(struct sahara_sha_reqctx),
|
||||
sizeof(struct sahara_sha_reqctx));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sahara_sha_cra_init(struct crypto_tfm *tfm)
|
||||
{
|
||||
const char *name = crypto_tfm_alg_name(tfm);
|
||||
struct sahara_ctx *ctx = crypto_tfm_ctx(tfm);
|
||||
|
||||
ctx->shash_fallback = crypto_alloc_shash(name, 0,
|
||||
CRYPTO_ALG_NEED_FALLBACK);
|
||||
if (IS_ERR(ctx->shash_fallback)) {
|
||||
pr_err("Error allocating fallback algo %s\n", name);
|
||||
return PTR_ERR(ctx->shash_fallback);
|
||||
}
|
||||
crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
|
||||
sizeof(struct sahara_sha_reqctx) +
|
||||
SHA_BUFFER_LEN + SHA256_BLOCK_SIZE);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void sahara_sha_cra_exit(struct crypto_tfm *tfm)
|
||||
{
|
||||
struct sahara_ctx *ctx = crypto_tfm_ctx(tfm);
|
||||
|
||||
crypto_free_shash(ctx->shash_fallback);
|
||||
ctx->shash_fallback = NULL;
|
||||
}
|
||||
|
||||
static struct crypto_alg aes_algs[] = {
|
||||
{
|
||||
.cra_name = "ecb(aes)",
|
||||
@ -782,6 +1301,60 @@ static struct crypto_alg aes_algs[] = {
|
||||
}
|
||||
};
|
||||
|
||||
static struct ahash_alg sha_v3_algs[] = {
|
||||
{
|
||||
.init = sahara_sha_init,
|
||||
.update = sahara_sha_update,
|
||||
.final = sahara_sha_final,
|
||||
.finup = sahara_sha_finup,
|
||||
.digest = sahara_sha_digest,
|
||||
.export = sahara_sha_export,
|
||||
.import = sahara_sha_import,
|
||||
.halg.digestsize = SHA1_DIGEST_SIZE,
|
||||
.halg.base = {
|
||||
.cra_name = "sha1",
|
||||
.cra_driver_name = "sahara-sha1",
|
||||
.cra_priority = 300,
|
||||
.cra_flags = CRYPTO_ALG_TYPE_AHASH |
|
||||
CRYPTO_ALG_ASYNC |
|
||||
CRYPTO_ALG_NEED_FALLBACK,
|
||||
.cra_blocksize = SHA1_BLOCK_SIZE,
|
||||
.cra_ctxsize = sizeof(struct sahara_ctx),
|
||||
.cra_alignmask = 0,
|
||||
.cra_module = THIS_MODULE,
|
||||
.cra_init = sahara_sha_cra_init,
|
||||
.cra_exit = sahara_sha_cra_exit,
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
static struct ahash_alg sha_v4_algs[] = {
|
||||
{
|
||||
.init = sahara_sha_init,
|
||||
.update = sahara_sha_update,
|
||||
.final = sahara_sha_final,
|
||||
.finup = sahara_sha_finup,
|
||||
.digest = sahara_sha_digest,
|
||||
.export = sahara_sha_export,
|
||||
.import = sahara_sha_import,
|
||||
.halg.digestsize = SHA256_DIGEST_SIZE,
|
||||
.halg.base = {
|
||||
.cra_name = "sha256",
|
||||
.cra_driver_name = "sahara-sha256",
|
||||
.cra_priority = 300,
|
||||
.cra_flags = CRYPTO_ALG_TYPE_AHASH |
|
||||
CRYPTO_ALG_ASYNC |
|
||||
CRYPTO_ALG_NEED_FALLBACK,
|
||||
.cra_blocksize = SHA256_BLOCK_SIZE,
|
||||
.cra_ctxsize = sizeof(struct sahara_ctx),
|
||||
.cra_alignmask = 0,
|
||||
.cra_module = THIS_MODULE,
|
||||
.cra_init = sahara_sha_cra_init,
|
||||
.cra_exit = sahara_sha_cra_exit,
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
static irqreturn_t sahara_irq_handler(int irq, void *data)
|
||||
{
|
||||
struct sahara_dev *dev = (struct sahara_dev *)data;
|
||||
@ -810,7 +1383,8 @@ static irqreturn_t sahara_irq_handler(int irq, void *data)
|
||||
|
||||
static int sahara_register_algs(struct sahara_dev *dev)
|
||||
{
|
||||
int err, i, j;
|
||||
int err;
|
||||
unsigned int i, j, k, l;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(aes_algs); i++) {
|
||||
INIT_LIST_HEAD(&aes_algs[i].cra_list);
|
||||
@ -819,8 +1393,29 @@ static int sahara_register_algs(struct sahara_dev *dev)
|
||||
goto err_aes_algs;
|
||||
}
|
||||
|
||||
for (k = 0; k < ARRAY_SIZE(sha_v3_algs); k++) {
|
||||
err = crypto_register_ahash(&sha_v3_algs[k]);
|
||||
if (err)
|
||||
goto err_sha_v3_algs;
|
||||
}
|
||||
|
||||
if (dev->version > SAHARA_VERSION_3)
|
||||
for (l = 0; l < ARRAY_SIZE(sha_v4_algs); l++) {
|
||||
err = crypto_register_ahash(&sha_v4_algs[l]);
|
||||
if (err)
|
||||
goto err_sha_v4_algs;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
err_sha_v4_algs:
|
||||
for (j = 0; j < l; j++)
|
||||
crypto_unregister_ahash(&sha_v4_algs[j]);
|
||||
|
||||
err_sha_v3_algs:
|
||||
for (j = 0; j < k; j++)
|
||||
crypto_unregister_ahash(&sha_v4_algs[j]);
|
||||
|
||||
err_aes_algs:
|
||||
for (j = 0; j < i; j++)
|
||||
crypto_unregister_alg(&aes_algs[j]);
|
||||
@ -830,10 +1425,17 @@ err_aes_algs:
|
||||
|
||||
static void sahara_unregister_algs(struct sahara_dev *dev)
|
||||
{
|
||||
int i;
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(aes_algs); i++)
|
||||
crypto_unregister_alg(&aes_algs[i]);
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(sha_v4_algs); i++)
|
||||
crypto_unregister_ahash(&sha_v3_algs[i]);
|
||||
|
||||
if (dev->version > SAHARA_VERSION_3)
|
||||
for (i = 0; i < ARRAY_SIZE(sha_v4_algs); i++)
|
||||
crypto_unregister_ahash(&sha_v4_algs[i]);
|
||||
}
|
||||
|
||||
static struct platform_device_id sahara_platform_ids[] = {
|
||||
@ -923,6 +1525,16 @@ static int sahara_probe(struct platform_device *pdev)
|
||||
dev->iv_base = dev->key_base + AES_KEYSIZE_128;
|
||||
dev->iv_phys_base = dev->key_phys_base + AES_KEYSIZE_128;
|
||||
|
||||
/* Allocate space for context: largest digest + message length field */
|
||||
dev->context_base = dma_alloc_coherent(&pdev->dev,
|
||||
SHA256_DIGEST_SIZE + 4,
|
||||
&dev->context_phys_base, GFP_KERNEL);
|
||||
if (!dev->context_base) {
|
||||
dev_err(&pdev->dev, "Could not allocate memory for MDHA context\n");
|
||||
err = -ENOMEM;
|
||||
goto err_key;
|
||||
}
|
||||
|
||||
/* Allocate space for HW links */
|
||||
dev->hw_link[0] = dma_alloc_coherent(&pdev->dev,
|
||||
SAHARA_MAX_HW_LINK * sizeof(struct sahara_hw_link),
|
||||
@ -1002,6 +1614,9 @@ err_link:
|
||||
dma_free_coherent(&pdev->dev,
|
||||
2 * AES_KEYSIZE_128,
|
||||
dev->key_base, dev->key_phys_base);
|
||||
dma_free_coherent(&pdev->dev,
|
||||
SHA256_DIGEST_SIZE,
|
||||
dev->context_base, dev->context_phys_base);
|
||||
err_key:
|
||||
dma_free_coherent(&pdev->dev,
|
||||
SAHARA_MAX_HW_DESC * sizeof(struct sahara_hw_desc),
|
||||
@ -1051,4 +1666,5 @@ module_platform_driver(sahara_driver);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_AUTHOR("Javier Martin <javier.martin@vista-silicon.com>");
|
||||
MODULE_AUTHOR("Steffen Trumtrar <s.trumtrar@pengutronix.de>");
|
||||
MODULE_DESCRIPTION("SAHARA2 HW crypto accelerator");
|
||||
|
||||
Loading…
Reference in New Issue
Block a user