[linux-2.6-block.git] / drivers / crypto / rockchip / rk3288_crypto_ablkcipher.c

/*
 * Crypto acceleration support for Rockchip RK3288
 *
 * Copyright (c) 2015, Fuzhou Rockchip Electronics Co., Ltd
 *
 * Author: Zain Wang <zain.wang@rock-chips.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * Some ideas are from marvell-cesa.c and s5p-sss.c driver.
 */
#include "rk3288_crypto.h"

#define RK_CRYPTO_DEC			BIT(0)

static void rk_crypto_complete(struct crypto_async_request *base, int err)
{
	if (base->complete)
		base->complete(base, err);
}

static int rk_handle_req(struct rk_crypto_info *dev,
			 struct ablkcipher_request *req)
{
	if (!IS_ALIGNED(req->nbytes, dev->align_size))
		return -EINVAL;
	else
		return dev->enqueue(dev, &req->base);
}

static int rk_aes_setkey(struct crypto_ablkcipher *cipher,
			 const u8 *key, unsigned int keylen)
{
	struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher);
	struct rk_cipher_ctx *ctx = crypto_tfm_ctx(tfm);

	if (keylen != AES_KEYSIZE_128 && keylen != AES_KEYSIZE_192 &&
	    keylen != AES_KEYSIZE_256) {
		crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
		return -EINVAL;
	}
	ctx->keylen = keylen;
	memcpy_toio(ctx->dev->reg + RK_CRYPTO_AES_KEY_0, key, keylen);
	return 0;
}

static int rk_tdes_setkey(struct crypto_ablkcipher *cipher,
			  const u8 *key, unsigned int keylen)
{
	struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher);
	struct rk_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
	u32 tmp[DES_EXPKEY_WORDS];

	if (keylen != DES_KEY_SIZE && keylen != DES3_EDE_KEY_SIZE) {
		crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
		return -EINVAL;
	}

	if (keylen == DES_KEY_SIZE) {
		if (!des_ekey(tmp, key) &&
		    (tfm->crt_flags & CRYPTO_TFM_REQ_FORBID_WEAK_KEYS)) {
			tfm->crt_flags |= CRYPTO_TFM_RES_WEAK_KEY;
			return -EINVAL;
		}
	}

	ctx->keylen = keylen;
	memcpy_toio(ctx->dev->reg + RK_CRYPTO_TDES_KEY1_0, key, keylen);
	return 0;
}

static int rk_aes_ecb_encrypt(struct ablkcipher_request *req)
{
	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	struct rk_crypto_info *dev = ctx->dev;

	ctx->mode = RK_CRYPTO_AES_ECB_MODE;
	return rk_handle_req(dev, req);
}

static int rk_aes_ecb_decrypt(struct ablkcipher_request *req)
{
	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	struct rk_crypto_info *dev = ctx->dev;

	ctx->mode = RK_CRYPTO_AES_ECB_MODE | RK_CRYPTO_DEC;
	return rk_handle_req(dev, req);
}

static int rk_aes_cbc_encrypt(struct ablkcipher_request *req)
{
	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	struct rk_crypto_info *dev = ctx->dev;

	ctx->mode = RK_CRYPTO_AES_CBC_MODE;
	return rk_handle_req(dev, req);
}

static int rk_aes_cbc_decrypt(struct ablkcipher_request *req)
{
	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	struct rk_crypto_info *dev = ctx->dev;

	ctx->mode = RK_CRYPTO_AES_CBC_MODE | RK_CRYPTO_DEC;
	return rk_handle_req(dev, req);
}

static int rk_des_ecb_encrypt(struct ablkcipher_request *req)
{
	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	struct rk_crypto_info *dev = ctx->dev;

	ctx->mode = 0;
	return rk_handle_req(dev, req);
}

static int rk_des_ecb_decrypt(struct ablkcipher_request *req)
{
	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	struct rk_crypto_info *dev = ctx->dev;

	ctx->mode = RK_CRYPTO_DEC;
	return rk_handle_req(dev, req);
}

static int rk_des_cbc_encrypt(struct ablkcipher_request *req)
{
	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	struct rk_crypto_info *dev = ctx->dev;

	ctx->mode = RK_CRYPTO_TDES_CHAINMODE_CBC;
	return rk_handle_req(dev, req);
}

static int rk_des_cbc_decrypt(struct ablkcipher_request *req)
{
	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	struct rk_crypto_info *dev = ctx->dev;

	ctx->mode = RK_CRYPTO_TDES_CHAINMODE_CBC | RK_CRYPTO_DEC;
	return rk_handle_req(dev, req);
}

static int rk_des3_ede_ecb_encrypt(struct ablkcipher_request *req)
{
	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	struct rk_crypto_info *dev = ctx->dev;

	ctx->mode = RK_CRYPTO_TDES_SELECT;
	return rk_handle_req(dev, req);
}

static int rk_des3_ede_ecb_decrypt(struct ablkcipher_request *req)
{
	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	struct rk_crypto_info *dev = ctx->dev;

	ctx->mode = RK_CRYPTO_TDES_SELECT | RK_CRYPTO_DEC;
	return rk_handle_req(dev, req);
}

static int rk_des3_ede_cbc_encrypt(struct ablkcipher_request *req)
{
	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	struct rk_crypto_info *dev = ctx->dev;

	ctx->mode = RK_CRYPTO_TDES_SELECT | RK_CRYPTO_TDES_CHAINMODE_CBC;
	return rk_handle_req(dev, req);
}

static int rk_des3_ede_cbc_decrypt(struct ablkcipher_request *req)
{
	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	struct rk_crypto_info *dev = ctx->dev;

	ctx->mode = RK_CRYPTO_TDES_SELECT | RK_CRYPTO_TDES_CHAINMODE_CBC |
		    RK_CRYPTO_DEC;
	return rk_handle_req(dev, req);
}

static void rk_ablk_hw_init(struct rk_crypto_info *dev)
{
	struct ablkcipher_request *req =
		ablkcipher_request_cast(dev->async_req);
	struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(req);
	struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher);
	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(cipher);
	u32 ivsize, block, conf_reg = 0;

	block = crypto_tfm_alg_blocksize(tfm);
	ivsize = crypto_ablkcipher_ivsize(cipher);

	if (block == DES_BLOCK_SIZE) {
		ctx->mode |= RK_CRYPTO_TDES_FIFO_MODE |
			     RK_CRYPTO_TDES_BYTESWAP_KEY |
			     RK_CRYPTO_TDES_BYTESWAP_IV;
		CRYPTO_WRITE(dev, RK_CRYPTO_TDES_CTRL, ctx->mode);
		memcpy_toio(dev->reg + RK_CRYPTO_TDES_IV_0, req->info, ivsize);
		conf_reg = RK_CRYPTO_DESSEL;
	} else {
		ctx->mode |= RK_CRYPTO_AES_FIFO_MODE |
			     RK_CRYPTO_AES_KEY_CHANGE |
			     RK_CRYPTO_AES_BYTESWAP_KEY |
			     RK_CRYPTO_AES_BYTESWAP_IV;
		if (ctx->keylen == AES_KEYSIZE_192)
			ctx->mode |= RK_CRYPTO_AES_192BIT_key;
		else if (ctx->keylen == AES_KEYSIZE_256)
			ctx->mode |= RK_CRYPTO_AES_256BIT_key;
		CRYPTO_WRITE(dev, RK_CRYPTO_AES_CTRL, ctx->mode);
		memcpy_toio(dev->reg + RK_CRYPTO_AES_IV_0, req->info, ivsize);
	}
	conf_reg |= RK_CRYPTO_BYTESWAP_BTFIFO |
		    RK_CRYPTO_BYTESWAP_BRFIFO;
	CRYPTO_WRITE(dev, RK_CRYPTO_CONF, conf_reg);
	CRYPTO_WRITE(dev, RK_CRYPTO_INTENA,
		     RK_CRYPTO_BCDMA_ERR_ENA | RK_CRYPTO_BCDMA_DONE_ENA);
}

static void crypto_dma_start(struct rk_crypto_info *dev)
{
	CRYPTO_WRITE(dev, RK_CRYPTO_BRDMAS, dev->addr_in);
	CRYPTO_WRITE(dev, RK_CRYPTO_BRDMAL, dev->count / 4);
	CRYPTO_WRITE(dev, RK_CRYPTO_BTDMAS, dev->addr_out);
	CRYPTO_WRITE(dev, RK_CRYPTO_CTRL, RK_CRYPTO_BLOCK_START |
		     _SBF(RK_CRYPTO_BLOCK_START, 16));
}

static int rk_set_data_start(struct rk_crypto_info *dev)
{
	int err;
	struct ablkcipher_request *req =
		ablkcipher_request_cast(dev->async_req);
	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	u32 ivsize = crypto_ablkcipher_ivsize(tfm);
	u8 *src_last_blk = page_address(sg_page(dev->sg_src)) +
		dev->sg_src->offset + dev->sg_src->length - ivsize;

	/* store the iv that need to be updated in chain mode */
	if (ctx->mode & RK_CRYPTO_DEC)
		memcpy(ctx->iv, src_last_blk, ivsize);

	err = dev->load_data(dev, dev->sg_src, dev->sg_dst);
	if (!err)
		crypto_dma_start(dev);
	return err;
}

static int rk_ablk_start(struct rk_crypto_info *dev)
{
	struct ablkcipher_request *req =
		ablkcipher_request_cast(dev->async_req);
	unsigned long flags;
	int err = 0;

	dev->left_bytes = req->nbytes;
	dev->total = req->nbytes;
	dev->sg_src = req->src;
	dev->first = req->src;
	dev->src_nents = sg_nents(req->src);
	dev->sg_dst = req->dst;
	dev->dst_nents = sg_nents(req->dst);
	dev->aligned = 1;

	spin_lock_irqsave(&dev->lock, flags);
	rk_ablk_hw_init(dev);
	err = rk_set_data_start(dev);
	spin_unlock_irqrestore(&dev->lock, flags);
	return err;
}

static void rk_iv_copyback(struct rk_crypto_info *dev)
{
	struct ablkcipher_request *req =
		ablkcipher_request_cast(dev->async_req);
	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	u32 ivsize = crypto_ablkcipher_ivsize(tfm);

	if (ivsize == DES_BLOCK_SIZE)
		memcpy_fromio(req->info, dev->reg + RK_CRYPTO_TDES_IV_0,
			      ivsize);
	else if (ivsize == AES_BLOCK_SIZE)
		memcpy_fromio(req->info, dev->reg + RK_CRYPTO_AES_IV_0, ivsize);
}

static void rk_update_iv(struct rk_crypto_info *dev)
{
	struct ablkcipher_request *req =
		ablkcipher_request_cast(dev->async_req);
	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	u32 ivsize = crypto_ablkcipher_ivsize(tfm);
	u8 *new_iv = NULL;

	if (ctx->mode & RK_CRYPTO_DEC) {
		new_iv = ctx->iv;
	} else {
		new_iv = page_address(sg_page(dev->sg_dst)) +
			 dev->sg_dst->offset + dev->sg_dst->length - ivsize;
	}

	if (ivsize == DES_BLOCK_SIZE)
		memcpy_toio(dev->reg + RK_CRYPTO_TDES_IV_0, new_iv, ivsize);
	else if (ivsize == AES_BLOCK_SIZE)
		memcpy_toio(dev->reg + RK_CRYPTO_AES_IV_0, new_iv, ivsize);
}

/* return:
 *	true	some err was occurred
 *	fault	no err, continue
 */
static int rk_ablk_rx(struct rk_crypto_info *dev)
{
	int err = 0;
	struct ablkcipher_request *req =
		ablkcipher_request_cast(dev->async_req);

	dev->unload_data(dev);
	if (!dev->aligned) {
		if (!sg_pcopy_from_buffer(req->dst, dev->dst_nents,
					  dev->addr_vir, dev->count,
					  dev->total - dev->left_bytes -
					  dev->count)) {
			err = -EINVAL;
			goto out_rx;
		}
	}
	if (dev->left_bytes) {
		rk_update_iv(dev);
		if (dev->aligned) {
			if (sg_is_last(dev->sg_src)) {
				dev_err(dev->dev, "[%s:%d] Lack of data\n",
					__func__, __LINE__);
				err = -ENOMEM;
				goto out_rx;
			}
			dev->sg_src = sg_next(dev->sg_src);
			dev->sg_dst = sg_next(dev->sg_dst);
		}
		err = rk_set_data_start(dev);
	} else {
		rk_iv_copyback(dev);
		/* here show the calculation is over without any err */
		dev->complete(dev->async_req, 0);
		tasklet_schedule(&dev->queue_task);
	}
out_rx:
	return err;
}

static int rk_ablk_cra_init(struct crypto_tfm *tfm)
{
	struct rk_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
	struct crypto_alg *alg = tfm->__crt_alg;
	struct rk_crypto_tmp *algt;

	algt = container_of(alg, struct rk_crypto_tmp, alg.crypto);

	ctx->dev = algt->dev;
	ctx->dev->align_size = crypto_tfm_alg_alignmask(tfm) + 1;
	ctx->dev->start = rk_ablk_start;
	ctx->dev->update = rk_ablk_rx;
	ctx->dev->complete = rk_crypto_complete;
	ctx->dev->addr_vir = (char *)__get_free_page(GFP_KERNEL);

	return ctx->dev->addr_vir ? ctx->dev->enable_clk(ctx->dev) : -ENOMEM;
}

static void rk_ablk_cra_exit(struct crypto_tfm *tfm)
{
	struct rk_cipher_ctx *ctx = crypto_tfm_ctx(tfm);

	free_page((unsigned long)ctx->dev->addr_vir);
	ctx->dev->disable_clk(ctx->dev);
}

struct rk_crypto_tmp rk_ecb_aes_alg = {
	.type = ALG_TYPE_CIPHER,
	.alg.crypto = {
		.cra_name		= "ecb(aes)",
		.cra_driver_name	= "ecb-aes-rk",
		.cra_priority		= 300,
		.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER |
					  CRYPTO_ALG_ASYNC,
		.cra_blocksize		= AES_BLOCK_SIZE,
		.cra_ctxsize		= sizeof(struct rk_cipher_ctx),
		.cra_alignmask		= 0x0f,
		.cra_type		= &crypto_ablkcipher_type,
		.cra_module		= THIS_MODULE,
		.cra_init		= rk_ablk_cra_init,
		.cra_exit		= rk_ablk_cra_exit,
		.cra_u.ablkcipher	= {
			.min_keysize	= AES_MIN_KEY_SIZE,
			.max_keysize	= AES_MAX_KEY_SIZE,
			.setkey		= rk_aes_setkey,
			.encrypt	= rk_aes_ecb_encrypt,
			.decrypt	= rk_aes_ecb_decrypt,
		}
	}
};

struct rk_crypto_tmp rk_cbc_aes_alg = {
	.type = ALG_TYPE_CIPHER,
	.alg.crypto = {
		.cra_name		= "cbc(aes)",
		.cra_driver_name	= "cbc-aes-rk",
		.cra_priority		= 300,
		.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER |
					  CRYPTO_ALG_ASYNC,
		.cra_blocksize		= AES_BLOCK_SIZE,
		.cra_ctxsize		= sizeof(struct rk_cipher_ctx),
		.cra_alignmask		= 0x0f,
		.cra_type		= &crypto_ablkcipher_type,
		.cra_module		= THIS_MODULE,
		.cra_init		= rk_ablk_cra_init,
		.cra_exit		= rk_ablk_cra_exit,
		.cra_u.ablkcipher	= {
			.min_keysize	= AES_MIN_KEY_SIZE,
			.max_keysize	= AES_MAX_KEY_SIZE,
			.ivsize		= AES_BLOCK_SIZE,
			.setkey		= rk_aes_setkey,
			.encrypt	= rk_aes_cbc_encrypt,
			.decrypt	= rk_aes_cbc_decrypt,
		}
	}
};

struct rk_crypto_tmp rk_ecb_des_alg = {
	.type = ALG_TYPE_CIPHER,
	.alg.crypto = {
		.cra_name		= "ecb(des)",
		.cra_driver_name	= "ecb-des-rk",
		.cra_priority		= 300,
		.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER |
					  CRYPTO_ALG_ASYNC,
		.cra_blocksize		= DES_BLOCK_SIZE,
		.cra_ctxsize		= sizeof(struct rk_cipher_ctx),
		.cra_alignmask		= 0x07,
		.cra_type		= &crypto_ablkcipher_type,
		.cra_module		= THIS_MODULE,
		.cra_init		= rk_ablk_cra_init,
		.cra_exit		= rk_ablk_cra_exit,
		.cra_u.ablkcipher	= {
			.min_keysize	= DES_KEY_SIZE,
			.max_keysize	= DES_KEY_SIZE,
			.setkey		= rk_tdes_setkey,
			.encrypt	= rk_des_ecb_encrypt,
			.decrypt	= rk_des_ecb_decrypt,
		}
	}
};

struct rk_crypto_tmp rk_cbc_des_alg = {
	.type = ALG_TYPE_CIPHER,
	.alg.crypto = {
		.cra_name		= "cbc(des)",
		.cra_driver_name	= "cbc-des-rk",
		.cra_priority		= 300,
		.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER |
					  CRYPTO_ALG_ASYNC,
		.cra_blocksize		= DES_BLOCK_SIZE,
		.cra_ctxsize		= sizeof(struct rk_cipher_ctx),
		.cra_alignmask		= 0x07,
		.cra_type		= &crypto_ablkcipher_type,
		.cra_module		= THIS_MODULE,
		.cra_init		= rk_ablk_cra_init,
		.cra_exit		= rk_ablk_cra_exit,
		.cra_u.ablkcipher	= {
			.min_keysize	= DES_KEY_SIZE,
			.max_keysize	= DES_KEY_SIZE,
			.ivsize		= DES_BLOCK_SIZE,
			.setkey		= rk_tdes_setkey,
			.encrypt	= rk_des_cbc_encrypt,
			.decrypt	= rk_des_cbc_decrypt,
		}
	}
};

struct rk_crypto_tmp rk_ecb_des3_ede_alg = {
	.type = ALG_TYPE_CIPHER,
	.alg.crypto = {
		.cra_name		= "ecb(des3_ede)",
		.cra_driver_name	= "ecb-des3-ede-rk",
		.cra_priority		= 300,
		.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER |
					  CRYPTO_ALG_ASYNC,
		.cra_blocksize		= DES_BLOCK_SIZE,
		.cra_ctxsize		= sizeof(struct rk_cipher_ctx),
		.cra_alignmask		= 0x07,
		.cra_type		= &crypto_ablkcipher_type,
		.cra_module		= THIS_MODULE,
		.cra_init		= rk_ablk_cra_init,
		.cra_exit		= rk_ablk_cra_exit,
		.cra_u.ablkcipher	= {
			.min_keysize	= DES3_EDE_KEY_SIZE,
			.max_keysize	= DES3_EDE_KEY_SIZE,
			.ivsize		= DES_BLOCK_SIZE,
			.setkey		= rk_tdes_setkey,
			.encrypt	= rk_des3_ede_ecb_encrypt,
			.decrypt	= rk_des3_ede_ecb_decrypt,
		}
	}
};

struct rk_crypto_tmp rk_cbc_des3_ede_alg = {
	.type = ALG_TYPE_CIPHER,
	.alg.crypto = {
		.cra_name		= "cbc(des3_ede)",
		.cra_driver_name	= "cbc-des3-ede-rk",
		.cra_priority		= 300,
		.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER |
					  CRYPTO_ALG_ASYNC,
		.cra_blocksize		= DES_BLOCK_SIZE,
		.cra_ctxsize		= sizeof(struct rk_cipher_ctx),
		.cra_alignmask		= 0x07,
		.cra_type		= &crypto_ablkcipher_type,
		.cra_module		= THIS_MODULE,
		.cra_init		= rk_ablk_cra_init,
		.cra_exit		= rk_ablk_cra_exit,
		.cra_u.ablkcipher	= {
			.min_keysize	= DES3_EDE_KEY_SIZE,
			.max_keysize	= DES3_EDE_KEY_SIZE,
			.ivsize		= DES_BLOCK_SIZE,
			.setkey		= rk_tdes_setkey,
			.encrypt	= rk_des3_ede_cbc_encrypt,
			.decrypt	= rk_des3_ede_cbc_decrypt,
		}
	}
};
Commit	Line	Data
433cd2c6 ZW	1	/*
	2	* Crypto acceleration support for Rockchip RK3288
	3	*
	4	* Copyright (c) 2015, Fuzhou Rockchip Electronics Co., Ltd
	5	*
	6	* Author: Zain Wang <zain.wang@rock-chips.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms and conditions of the GNU General Public License,
	10	* version 2, as published by the Free Software Foundation.
	11	*
	12	* Some ideas are from marvell-cesa.c and s5p-sss.c driver.
	13	*/
	14	#include "rk3288_crypto.h"
	15
	16	#define RK_CRYPTO_DEC BIT(0)
	17
5a7801f6	18	static void rk_crypto_complete(struct crypto_async_request *base, int err)
433cd2c6	19	{
5a7801f6 ZW	20	if (base->complete)
5a7801f6 ZW	21	base->complete(base, err);
433cd2c6 ZW	22	}
	23
	24	static int rk_handle_req(struct rk_crypto_info *dev,
	25	struct ablkcipher_request *req)
	26	{
433cd2c6 ZW	27	if (!IS_ALIGNED(req->nbytes, dev->align_size))
433cd2c6 ZW	28	return -EINVAL;
5a7801f6 ZW	29	else
5a7801f6 ZW	30	return dev->enqueue(dev, &req->base);
433cd2c6 ZW	31	}
	32
	33	static int rk_aes_setkey(struct crypto_ablkcipher *cipher,
	34	const u8 *key, unsigned int keylen)
	35	{
	36	struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher);
	37	struct rk_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
	38
	39	if (keylen != AES_KEYSIZE_128 && keylen != AES_KEYSIZE_192 &&
	40	keylen != AES_KEYSIZE_256) {
	41	crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
	42	return -EINVAL;
	43	}
	44	ctx->keylen = keylen;
	45	memcpy_toio(ctx->dev->reg + RK_CRYPTO_AES_KEY_0, key, keylen);
	46	return 0;
	47	}
	48
	49	static int rk_tdes_setkey(struct crypto_ablkcipher *cipher,
	50	const u8 *key, unsigned int keylen)
	51	{
	52	struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher);
	53	struct rk_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
	54	u32 tmp[DES_EXPKEY_WORDS];
	55
	56	if (keylen != DES_KEY_SIZE && keylen != DES3_EDE_KEY_SIZE) {
	57	crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
	58	return -EINVAL;
	59	}
	60
	61	if (keylen == DES_KEY_SIZE) {
	62	if (!des_ekey(tmp, key) &&
231baecd	63	(tfm->crt_flags & CRYPTO_TFM_REQ_FORBID_WEAK_KEYS)) {
433cd2c6 ZW	64	tfm->crt_flags \|= CRYPTO_TFM_RES_WEAK_KEY;
	65	return -EINVAL;
	66	}
	67	}
	68
	69	ctx->keylen = keylen;
	70	memcpy_toio(ctx->dev->reg + RK_CRYPTO_TDES_KEY1_0, key, keylen);
	71	return 0;
	72	}
	73
	74	static int rk_aes_ecb_encrypt(struct ablkcipher_request *req)
	75	{
	76	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	77	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	78	struct rk_crypto_info *dev = ctx->dev;
	79
5a7801f6	80	ctx->mode = RK_CRYPTO_AES_ECB_MODE;
433cd2c6 ZW	81	return rk_handle_req(dev, req);
	82	}
	83
	84	static int rk_aes_ecb_decrypt(struct ablkcipher_request *req)
	85	{
	86	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	87	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	88	struct rk_crypto_info *dev = ctx->dev;
	89
5a7801f6	90	ctx->mode = RK_CRYPTO_AES_ECB_MODE \| RK_CRYPTO_DEC;
433cd2c6 ZW	91	return rk_handle_req(dev, req);
	92	}
	93
	94	static int rk_aes_cbc_encrypt(struct ablkcipher_request *req)
	95	{
	96	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	97	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	98	struct rk_crypto_info *dev = ctx->dev;
	99
5a7801f6	100	ctx->mode = RK_CRYPTO_AES_CBC_MODE;
433cd2c6 ZW	101	return rk_handle_req(dev, req);
	102	}
	103
	104	static int rk_aes_cbc_decrypt(struct ablkcipher_request *req)
	105	{
	106	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	107	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	108	struct rk_crypto_info *dev = ctx->dev;
	109
5a7801f6	110	ctx->mode = RK_CRYPTO_AES_CBC_MODE \| RK_CRYPTO_DEC;
433cd2c6 ZW	111	return rk_handle_req(dev, req);
	112	}
	113
	114	static int rk_des_ecb_encrypt(struct ablkcipher_request *req)
	115	{
	116	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	117	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	118	struct rk_crypto_info *dev = ctx->dev;
	119
5a7801f6	120	ctx->mode = 0;
433cd2c6 ZW	121	return rk_handle_req(dev, req);
	122	}
	123
	124	static int rk_des_ecb_decrypt(struct ablkcipher_request *req)
	125	{
	126	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	127	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	128	struct rk_crypto_info *dev = ctx->dev;
	129
5a7801f6	130	ctx->mode = RK_CRYPTO_DEC;
433cd2c6 ZW	131	return rk_handle_req(dev, req);
	132	}
	133
	134	static int rk_des_cbc_encrypt(struct ablkcipher_request *req)
	135	{
	136	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	137	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	138	struct rk_crypto_info *dev = ctx->dev;
	139
5a7801f6	140	ctx->mode = RK_CRYPTO_TDES_CHAINMODE_CBC;
433cd2c6 ZW	141	return rk_handle_req(dev, req);
	142	}
	143
	144	static int rk_des_cbc_decrypt(struct ablkcipher_request *req)
	145	{
	146	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	147	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	148	struct rk_crypto_info *dev = ctx->dev;
	149
5a7801f6	150	ctx->mode = RK_CRYPTO_TDES_CHAINMODE_CBC \| RK_CRYPTO_DEC;
433cd2c6 ZW	151	return rk_handle_req(dev, req);
	152	}
	153
	154	static int rk_des3_ede_ecb_encrypt(struct ablkcipher_request *req)
	155	{
	156	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	157	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	158	struct rk_crypto_info *dev = ctx->dev;
	159
5a7801f6	160	ctx->mode = RK_CRYPTO_TDES_SELECT;
433cd2c6 ZW	161	return rk_handle_req(dev, req);
	162	}
	163
	164	static int rk_des3_ede_ecb_decrypt(struct ablkcipher_request *req)
	165	{
	166	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	167	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	168	struct rk_crypto_info *dev = ctx->dev;
	169
5a7801f6	170	ctx->mode = RK_CRYPTO_TDES_SELECT \| RK_CRYPTO_DEC;
433cd2c6 ZW	171	return rk_handle_req(dev, req);
	172	}
	173
	174	static int rk_des3_ede_cbc_encrypt(struct ablkcipher_request *req)
	175	{
	176	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	177	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	178	struct rk_crypto_info *dev = ctx->dev;
	179
5a7801f6	180	ctx->mode = RK_CRYPTO_TDES_SELECT \| RK_CRYPTO_TDES_CHAINMODE_CBC;
433cd2c6 ZW	181	return rk_handle_req(dev, req);
	182	}
	183
	184	static int rk_des3_ede_cbc_decrypt(struct ablkcipher_request *req)
	185	{
	186	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	187	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	188	struct rk_crypto_info *dev = ctx->dev;
	189
5a7801f6	190	ctx->mode = RK_CRYPTO_TDES_SELECT \| RK_CRYPTO_TDES_CHAINMODE_CBC \|
433cd2c6 ZW	191	RK_CRYPTO_DEC;
	192	return rk_handle_req(dev, req);
	193	}
	194
	195	static void rk_ablk_hw_init(struct rk_crypto_info *dev)
	196	{
5a7801f6 ZW	197	struct ablkcipher_request *req =
	198	ablkcipher_request_cast(dev->async_req);
	199	struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(req);
433cd2c6 ZW	200	struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher);
	201	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(cipher);
	202	u32 ivsize, block, conf_reg = 0;
	203
	204	block = crypto_tfm_alg_blocksize(tfm);
	205	ivsize = crypto_ablkcipher_ivsize(cipher);
	206
	207	if (block == DES_BLOCK_SIZE) {
5a7801f6	208	ctx->mode \|= RK_CRYPTO_TDES_FIFO_MODE \|
433cd2c6 ZW	209	RK_CRYPTO_TDES_BYTESWAP_KEY \|
433cd2c6 ZW	210	RK_CRYPTO_TDES_BYTESWAP_IV;
5a7801f6 ZW	211	CRYPTO_WRITE(dev, RK_CRYPTO_TDES_CTRL, ctx->mode);
5a7801f6 ZW	212	memcpy_toio(dev->reg + RK_CRYPTO_TDES_IV_0, req->info, ivsize);
433cd2c6 ZW	213	conf_reg = RK_CRYPTO_DESSEL;
433cd2c6 ZW	214	} else {
5a7801f6	215	ctx->mode \|= RK_CRYPTO_AES_FIFO_MODE \|
433cd2c6 ZW	216	RK_CRYPTO_AES_KEY_CHANGE \|
	217	RK_CRYPTO_AES_BYTESWAP_KEY \|
	218	RK_CRYPTO_AES_BYTESWAP_IV;
	219	if (ctx->keylen == AES_KEYSIZE_192)
5a7801f6	220	ctx->mode \|= RK_CRYPTO_AES_192BIT_key;
433cd2c6	221	else if (ctx->keylen == AES_KEYSIZE_256)
5a7801f6 ZW	222	ctx->mode \|= RK_CRYPTO_AES_256BIT_key;
	223	CRYPTO_WRITE(dev, RK_CRYPTO_AES_CTRL, ctx->mode);
	224	memcpy_toio(dev->reg + RK_CRYPTO_AES_IV_0, req->info, ivsize);
433cd2c6 ZW	225	}
	226	conf_reg \|= RK_CRYPTO_BYTESWAP_BTFIFO \|
	227	RK_CRYPTO_BYTESWAP_BRFIFO;
	228	CRYPTO_WRITE(dev, RK_CRYPTO_CONF, conf_reg);
	229	CRYPTO_WRITE(dev, RK_CRYPTO_INTENA,
	230	RK_CRYPTO_BCDMA_ERR_ENA \| RK_CRYPTO_BCDMA_DONE_ENA);
	231	}
	232
	233	static void crypto_dma_start(struct rk_crypto_info *dev)
	234	{
	235	CRYPTO_WRITE(dev, RK_CRYPTO_BRDMAS, dev->addr_in);
	236	CRYPTO_WRITE(dev, RK_CRYPTO_BRDMAL, dev->count / 4);
	237	CRYPTO_WRITE(dev, RK_CRYPTO_BTDMAS, dev->addr_out);
	238	CRYPTO_WRITE(dev, RK_CRYPTO_CTRL, RK_CRYPTO_BLOCK_START \|
	239	_SBF(RK_CRYPTO_BLOCK_START, 16));
	240	}
	241
	242	static int rk_set_data_start(struct rk_crypto_info *dev)
	243	{
	244	int err;
c1c214ad ZZ	245	struct ablkcipher_request *req =
	246	ablkcipher_request_cast(dev->async_req);
	247	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	248	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	249	u32 ivsize = crypto_ablkcipher_ivsize(tfm);
	250	u8 *src_last_blk = page_address(sg_page(dev->sg_src)) +
	251	dev->sg_src->offset + dev->sg_src->length - ivsize;
	252
	253	/* store the iv that need to be updated in chain mode */
	254	if (ctx->mode & RK_CRYPTO_DEC)
	255	memcpy(ctx->iv, src_last_blk, ivsize);
433cd2c6 ZW	256
	257	err = dev->load_data(dev, dev->sg_src, dev->sg_dst);
	258	if (!err)
	259	crypto_dma_start(dev);
	260	return err;
	261	}
	262
	263	static int rk_ablk_start(struct rk_crypto_info *dev)
	264	{
5a7801f6 ZW	265	struct ablkcipher_request *req =
5a7801f6 ZW	266	ablkcipher_request_cast(dev->async_req);
ac7c8e6b	267	unsigned long flags;
5a7801f6 ZW	268	int err = 0;
	269
	270	dev->left_bytes = req->nbytes;
	271	dev->total = req->nbytes;
	272	dev->sg_src = req->src;
	273	dev->first = req->src;
4359669a	274	dev->src_nents = sg_nents(req->src);
5a7801f6	275	dev->sg_dst = req->dst;
4359669a	276	dev->dst_nents = sg_nents(req->dst);
5a7801f6	277	dev->aligned = 1;
433cd2c6	278
ac7c8e6b	279	spin_lock_irqsave(&dev->lock, flags);
433cd2c6 ZW	280	rk_ablk_hw_init(dev);
433cd2c6 ZW	281	err = rk_set_data_start(dev);
ac7c8e6b	282	spin_unlock_irqrestore(&dev->lock, flags);
433cd2c6 ZW	283	return err;
	284	}
	285
	286	static void rk_iv_copyback(struct rk_crypto_info *dev)
	287	{
5a7801f6 ZW	288	struct ablkcipher_request *req =
	289	ablkcipher_request_cast(dev->async_req);
	290	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
433cd2c6 ZW	291	u32 ivsize = crypto_ablkcipher_ivsize(tfm);
	292
	293	if (ivsize == DES_BLOCK_SIZE)
5a7801f6 ZW	294	memcpy_fromio(req->info, dev->reg + RK_CRYPTO_TDES_IV_0,
5a7801f6 ZW	295	ivsize);
433cd2c6	296	else if (ivsize == AES_BLOCK_SIZE)
5a7801f6	297	memcpy_fromio(req->info, dev->reg + RK_CRYPTO_AES_IV_0, ivsize);
433cd2c6 ZW	298	}
433cd2c6 ZW	299
c1c214ad ZZ	300	static void rk_update_iv(struct rk_crypto_info *dev)
	301	{
	302	struct ablkcipher_request *req =
	303	ablkcipher_request_cast(dev->async_req);
	304	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
	305	struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
	306	u32 ivsize = crypto_ablkcipher_ivsize(tfm);
	307	u8 *new_iv = NULL;
	308
	309	if (ctx->mode & RK_CRYPTO_DEC) {
	310	new_iv = ctx->iv;
	311	} else {
	312	new_iv = page_address(sg_page(dev->sg_dst)) +
	313	dev->sg_dst->offset + dev->sg_dst->length - ivsize;
	314	}
	315
	316	if (ivsize == DES_BLOCK_SIZE)
	317	memcpy_toio(dev->reg + RK_CRYPTO_TDES_IV_0, new_iv, ivsize);
	318	else if (ivsize == AES_BLOCK_SIZE)
	319	memcpy_toio(dev->reg + RK_CRYPTO_AES_IV_0, new_iv, ivsize);
	320	}
	321
433cd2c6 ZW	322	/* return:
	323	* true some err was occurred
	324	* fault no err, continue
	325	*/
	326	static int rk_ablk_rx(struct rk_crypto_info *dev)
	327	{
	328	int err = 0;
5a7801f6 ZW	329	struct ablkcipher_request *req =
5a7801f6 ZW	330	ablkcipher_request_cast(dev->async_req);
433cd2c6 ZW	331
	332	dev->unload_data(dev);
	333	if (!dev->aligned) {
4359669a	334	if (!sg_pcopy_from_buffer(req->dst, dev->dst_nents,
433cd2c6 ZW	335	dev->addr_vir, dev->count,
	336	dev->total - dev->left_bytes -
	337	dev->count)) {
	338	err = -EINVAL;
	339	goto out_rx;
	340	}
	341	}
	342	if (dev->left_bytes) {
c1c214ad	343	rk_update_iv(dev);
433cd2c6 ZW	344	if (dev->aligned) {
	345	if (sg_is_last(dev->sg_src)) {
	346	dev_err(dev->dev, "[%s:%d] Lack of data\n",
	347	__func__, __LINE__);
	348	err = -ENOMEM;
	349	goto out_rx;
	350	}
	351	dev->sg_src = sg_next(dev->sg_src);
	352	dev->sg_dst = sg_next(dev->sg_dst);
	353	}
	354	err = rk_set_data_start(dev);
	355	} else {
	356	rk_iv_copyback(dev);
	357	/* here show the calculation is over without any err */
5a7801f6 ZW	358	dev->complete(dev->async_req, 0);
5a7801f6 ZW	359	tasklet_schedule(&dev->queue_task);
433cd2c6 ZW	360	}
	361	out_rx:
	362	return err;
	363	}
	364
	365	static int rk_ablk_cra_init(struct crypto_tfm *tfm)
	366	{
	367	struct rk_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
	368	struct crypto_alg *alg = tfm->__crt_alg;
	369	struct rk_crypto_tmp *algt;
	370
bfd927ff	371	algt = container_of(alg, struct rk_crypto_tmp, alg.crypto);
433cd2c6 ZW	372
	373	ctx->dev = algt->dev;
	374	ctx->dev->align_size = crypto_tfm_alg_alignmask(tfm) + 1;
	375	ctx->dev->start = rk_ablk_start;
	376	ctx->dev->update = rk_ablk_rx;
	377	ctx->dev->complete = rk_crypto_complete;
	378	ctx->dev->addr_vir = (char *)__get_free_page(GFP_KERNEL);
	379
	380	return ctx->dev->addr_vir ? ctx->dev->enable_clk(ctx->dev) : -ENOMEM;
	381	}
	382
	383	static void rk_ablk_cra_exit(struct crypto_tfm *tfm)
	384	{
	385	struct rk_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
	386
	387	free_page((unsigned long)ctx->dev->addr_vir);
	388	ctx->dev->disable_clk(ctx->dev);
	389	}
	390
	391	struct rk_crypto_tmp rk_ecb_aes_alg = {
bfd927ff ZW	392	.type = ALG_TYPE_CIPHER,
bfd927ff ZW	393	.alg.crypto = {
433cd2c6 ZW	394	.cra_name = "ecb(aes)",
	395	.cra_driver_name = "ecb-aes-rk",
	396	.cra_priority = 300,
	397	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \|
	398	CRYPTO_ALG_ASYNC,
	399	.cra_blocksize = AES_BLOCK_SIZE,
	400	.cra_ctxsize = sizeof(struct rk_cipher_ctx),
	401	.cra_alignmask = 0x0f,
	402	.cra_type = &crypto_ablkcipher_type,
	403	.cra_module = THIS_MODULE,
	404	.cra_init = rk_ablk_cra_init,
	405	.cra_exit = rk_ablk_cra_exit,
	406	.cra_u.ablkcipher = {
	407	.min_keysize = AES_MIN_KEY_SIZE,
	408	.max_keysize = AES_MAX_KEY_SIZE,
	409	.setkey = rk_aes_setkey,
	410	.encrypt = rk_aes_ecb_encrypt,
	411	.decrypt = rk_aes_ecb_decrypt,
	412	}
	413	}
	414	};
	415
	416	struct rk_crypto_tmp rk_cbc_aes_alg = {
bfd927ff ZW	417	.type = ALG_TYPE_CIPHER,
bfd927ff ZW	418	.alg.crypto = {
433cd2c6 ZW	419	.cra_name = "cbc(aes)",
	420	.cra_driver_name = "cbc-aes-rk",
	421	.cra_priority = 300,
	422	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \|
	423	CRYPTO_ALG_ASYNC,
	424	.cra_blocksize = AES_BLOCK_SIZE,
	425	.cra_ctxsize = sizeof(struct rk_cipher_ctx),
	426	.cra_alignmask = 0x0f,
	427	.cra_type = &crypto_ablkcipher_type,
	428	.cra_module = THIS_MODULE,
	429	.cra_init = rk_ablk_cra_init,
	430	.cra_exit = rk_ablk_cra_exit,
	431	.cra_u.ablkcipher = {
	432	.min_keysize = AES_MIN_KEY_SIZE,
	433	.max_keysize = AES_MAX_KEY_SIZE,
	434	.ivsize = AES_BLOCK_SIZE,
	435	.setkey = rk_aes_setkey,
	436	.encrypt = rk_aes_cbc_encrypt,
	437	.decrypt = rk_aes_cbc_decrypt,
	438	}
	439	}
	440	};
	441
	442	struct rk_crypto_tmp rk_ecb_des_alg = {
bfd927ff ZW	443	.type = ALG_TYPE_CIPHER,
bfd927ff ZW	444	.alg.crypto = {
433cd2c6 ZW	445	.cra_name = "ecb(des)",
	446	.cra_driver_name = "ecb-des-rk",
	447	.cra_priority = 300,
	448	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \|
	449	CRYPTO_ALG_ASYNC,
	450	.cra_blocksize = DES_BLOCK_SIZE,
	451	.cra_ctxsize = sizeof(struct rk_cipher_ctx),
	452	.cra_alignmask = 0x07,
	453	.cra_type = &crypto_ablkcipher_type,
	454	.cra_module = THIS_MODULE,
	455	.cra_init = rk_ablk_cra_init,
	456	.cra_exit = rk_ablk_cra_exit,
	457	.cra_u.ablkcipher = {
	458	.min_keysize = DES_KEY_SIZE,
	459	.max_keysize = DES_KEY_SIZE,
	460	.setkey = rk_tdes_setkey,
	461	.encrypt = rk_des_ecb_encrypt,
	462	.decrypt = rk_des_ecb_decrypt,
	463	}
	464	}
	465	};
	466
	467	struct rk_crypto_tmp rk_cbc_des_alg = {
bfd927ff ZW	468	.type = ALG_TYPE_CIPHER,
bfd927ff ZW	469	.alg.crypto = {
433cd2c6 ZW	470	.cra_name = "cbc(des)",
	471	.cra_driver_name = "cbc-des-rk",
	472	.cra_priority = 300,
	473	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \|
	474	CRYPTO_ALG_ASYNC,
	475	.cra_blocksize = DES_BLOCK_SIZE,
	476	.cra_ctxsize = sizeof(struct rk_cipher_ctx),
	477	.cra_alignmask = 0x07,
	478	.cra_type = &crypto_ablkcipher_type,
	479	.cra_module = THIS_MODULE,
	480	.cra_init = rk_ablk_cra_init,
	481	.cra_exit = rk_ablk_cra_exit,
	482	.cra_u.ablkcipher = {
	483	.min_keysize = DES_KEY_SIZE,
	484	.max_keysize = DES_KEY_SIZE,
	485	.ivsize = DES_BLOCK_SIZE,
	486	.setkey = rk_tdes_setkey,
	487	.encrypt = rk_des_cbc_encrypt,
	488	.decrypt = rk_des_cbc_decrypt,
	489	}
	490	}
	491	};
	492
	493	struct rk_crypto_tmp rk_ecb_des3_ede_alg = {
bfd927ff ZW	494	.type = ALG_TYPE_CIPHER,
bfd927ff ZW	495	.alg.crypto = {
433cd2c6 ZW	496	.cra_name = "ecb(des3_ede)",
	497	.cra_driver_name = "ecb-des3-ede-rk",
	498	.cra_priority = 300,
	499	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \|
	500	CRYPTO_ALG_ASYNC,
	501	.cra_blocksize = DES_BLOCK_SIZE,
	502	.cra_ctxsize = sizeof(struct rk_cipher_ctx),
	503	.cra_alignmask = 0x07,
	504	.cra_type = &crypto_ablkcipher_type,
	505	.cra_module = THIS_MODULE,
	506	.cra_init = rk_ablk_cra_init,
	507	.cra_exit = rk_ablk_cra_exit,
	508	.cra_u.ablkcipher = {
	509	.min_keysize = DES3_EDE_KEY_SIZE,
	510	.max_keysize = DES3_EDE_KEY_SIZE,
	511	.ivsize = DES_BLOCK_SIZE,
	512	.setkey = rk_tdes_setkey,
	513	.encrypt = rk_des3_ede_ecb_encrypt,
	514	.decrypt = rk_des3_ede_ecb_decrypt,
	515	}
	516	}
	517	};
	518
	519	struct rk_crypto_tmp rk_cbc_des3_ede_alg = {
bfd927ff ZW	520	.type = ALG_TYPE_CIPHER,
bfd927ff ZW	521	.alg.crypto = {
433cd2c6 ZW	522	.cra_name = "cbc(des3_ede)",
	523	.cra_driver_name = "cbc-des3-ede-rk",
	524	.cra_priority = 300,
	525	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \|
	526	CRYPTO_ALG_ASYNC,
	527	.cra_blocksize = DES_BLOCK_SIZE,
	528	.cra_ctxsize = sizeof(struct rk_cipher_ctx),
	529	.cra_alignmask = 0x07,
	530	.cra_type = &crypto_ablkcipher_type,
	531	.cra_module = THIS_MODULE,
	532	.cra_init = rk_ablk_cra_init,
	533	.cra_exit = rk_ablk_cra_exit,
	534	.cra_u.ablkcipher = {
	535	.min_keysize = DES3_EDE_KEY_SIZE,
	536	.max_keysize = DES3_EDE_KEY_SIZE,
	537	.ivsize = DES_BLOCK_SIZE,
	538	.setkey = rk_tdes_setkey,
	539	.encrypt = rk_des3_ede_cbc_encrypt,
	540	.decrypt = rk_des3_ede_cbc_decrypt,
	541	}
	542	}
	543	};