[mirror_ubuntu-eoan-kernel.git] / drivers / crypto / nx / nx-aes-gcm.c

// SPDX-License-Identifier: GPL-2.0-only
/**
 * AES GCM routines supporting the Power 7+ Nest Accelerators driver
 *
 * Copyright (C) 2012 International Business Machines Inc.
 *
 * Author: Kent Yoder <yoder1@us.ibm.com>
 */

#include <crypto/internal/aead.h>
#include <crypto/aes.h>
#include <crypto/algapi.h>
#include <crypto/gcm.h>
#include <crypto/scatterwalk.h>
#include <linux/module.h>
#include <linux/types.h>
#include <asm/vio.h>

#include "nx_csbcpb.h"
#include "nx.h"


static int gcm_aes_nx_set_key(struct crypto_aead *tfm,
			      const u8           *in_key,
			      unsigned int        key_len)
{
	struct nx_crypto_ctx *nx_ctx = crypto_aead_ctx(tfm);
	struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
	struct nx_csbcpb *csbcpb_aead = nx_ctx->csbcpb_aead;

	nx_ctx_init(nx_ctx, HCOP_FC_AES);

	switch (key_len) {
	case AES_KEYSIZE_128:
		NX_CPB_SET_KEY_SIZE(csbcpb, NX_KS_AES_128);
		NX_CPB_SET_KEY_SIZE(csbcpb_aead, NX_KS_AES_128);
		nx_ctx->ap = &nx_ctx->props[NX_PROPS_AES_128];
		break;
	case AES_KEYSIZE_192:
		NX_CPB_SET_KEY_SIZE(csbcpb, NX_KS_AES_192);
		NX_CPB_SET_KEY_SIZE(csbcpb_aead, NX_KS_AES_192);
		nx_ctx->ap = &nx_ctx->props[NX_PROPS_AES_192];
		break;
	case AES_KEYSIZE_256:
		NX_CPB_SET_KEY_SIZE(csbcpb, NX_KS_AES_256);
		NX_CPB_SET_KEY_SIZE(csbcpb_aead, NX_KS_AES_256);
		nx_ctx->ap = &nx_ctx->props[NX_PROPS_AES_256];
		break;
	default:
		return -EINVAL;
	}

	csbcpb->cpb.hdr.mode = NX_MODE_AES_GCM;
	memcpy(csbcpb->cpb.aes_gcm.key, in_key, key_len);

	csbcpb_aead->cpb.hdr.mode = NX_MODE_AES_GCA;
	memcpy(csbcpb_aead->cpb.aes_gca.key, in_key, key_len);

	return 0;
}

static int gcm4106_aes_nx_set_key(struct crypto_aead *tfm,
				  const u8           *in_key,
				  unsigned int        key_len)
{
	struct nx_crypto_ctx *nx_ctx = crypto_aead_ctx(tfm);
	char *nonce = nx_ctx->priv.gcm.nonce;
	int rc;

	if (key_len < 4)
		return -EINVAL;

	key_len -= 4;

	rc = gcm_aes_nx_set_key(tfm, in_key, key_len);
	if (rc)
		goto out;

	memcpy(nonce, in_key + key_len, 4);
out:
	return rc;
}

static int gcm4106_aes_nx_setauthsize(struct crypto_aead *tfm,
				      unsigned int authsize)
{
	switch (authsize) {
	case 8:
	case 12:
	case 16:
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static int nx_gca(struct nx_crypto_ctx  *nx_ctx,
		  struct aead_request   *req,
		  u8                    *out,
		  unsigned int assoclen)
{
	int rc;
	struct nx_csbcpb *csbcpb_aead = nx_ctx->csbcpb_aead;
	struct scatter_walk walk;
	struct nx_sg *nx_sg = nx_ctx->in_sg;
	unsigned int nbytes = assoclen;
	unsigned int processed = 0, to_process;
	unsigned int max_sg_len;

	if (nbytes <= AES_BLOCK_SIZE) {
		scatterwalk_start(&walk, req->src);
		scatterwalk_copychunks(out, &walk, nbytes, SCATTERWALK_FROM_SG);
		scatterwalk_done(&walk, SCATTERWALK_FROM_SG, 0);
		return 0;
	}

	NX_CPB_FDM(csbcpb_aead) &= ~NX_FDM_CONTINUATION;

	/* page_limit: number of sg entries that fit on one page */
	max_sg_len = min_t(u64, nx_driver.of.max_sg_len/sizeof(struct nx_sg),
			   nx_ctx->ap->sglen);
	max_sg_len = min_t(u64, max_sg_len,
			   nx_ctx->ap->databytelen/NX_PAGE_SIZE);

	do {
		/*
		 * to_process: the data chunk to process in this update.
		 * This value is bound by sg list limits.
		 */
		to_process = min_t(u64, nbytes - processed,
				   nx_ctx->ap->databytelen);
		to_process = min_t(u64, to_process,
				   NX_PAGE_SIZE * (max_sg_len - 1));

		nx_sg = nx_walk_and_build(nx_ctx->in_sg, max_sg_len,
					  req->src, processed, &to_process);

		if ((to_process + processed) < nbytes)
			NX_CPB_FDM(csbcpb_aead) |= NX_FDM_INTERMEDIATE;
		else
			NX_CPB_FDM(csbcpb_aead) &= ~NX_FDM_INTERMEDIATE;

		nx_ctx->op_aead.inlen = (nx_ctx->in_sg - nx_sg)
					* sizeof(struct nx_sg);

		rc = nx_hcall_sync(nx_ctx, &nx_ctx->op_aead,
				req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP);
		if (rc)
			return rc;

		memcpy(csbcpb_aead->cpb.aes_gca.in_pat,
				csbcpb_aead->cpb.aes_gca.out_pat,
				AES_BLOCK_SIZE);
		NX_CPB_FDM(csbcpb_aead) |= NX_FDM_CONTINUATION;

		atomic_inc(&(nx_ctx->stats->aes_ops));
		atomic64_add(assoclen, &(nx_ctx->stats->aes_bytes));

		processed += to_process;
	} while (processed < nbytes);

	memcpy(out, csbcpb_aead->cpb.aes_gca.out_pat, AES_BLOCK_SIZE);

	return rc;
}

static int gmac(struct aead_request *req, struct blkcipher_desc *desc,
		unsigned int assoclen)
{
	int rc;
	struct nx_crypto_ctx *nx_ctx =
		crypto_aead_ctx(crypto_aead_reqtfm(req));
	struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
	struct nx_sg *nx_sg;
	unsigned int nbytes = assoclen;
	unsigned int processed = 0, to_process;
	unsigned int max_sg_len;

	/* Set GMAC mode */
	csbcpb->cpb.hdr.mode = NX_MODE_AES_GMAC;

	NX_CPB_FDM(csbcpb) &= ~NX_FDM_CONTINUATION;

	/* page_limit: number of sg entries that fit on one page */
	max_sg_len = min_t(u64, nx_driver.of.max_sg_len/sizeof(struct nx_sg),
			   nx_ctx->ap->sglen);
	max_sg_len = min_t(u64, max_sg_len,
			   nx_ctx->ap->databytelen/NX_PAGE_SIZE);

	/* Copy IV */
	memcpy(csbcpb->cpb.aes_gcm.iv_or_cnt, desc->info, AES_BLOCK_SIZE);

	do {
		/*
		 * to_process: the data chunk to process in this update.
		 * This value is bound by sg list limits.
		 */
		to_process = min_t(u64, nbytes - processed,
				   nx_ctx->ap->databytelen);
		to_process = min_t(u64, to_process,
				   NX_PAGE_SIZE * (max_sg_len - 1));

		nx_sg = nx_walk_and_build(nx_ctx->in_sg, max_sg_len,
					  req->src, processed, &to_process);

		if ((to_process + processed) < nbytes)
			NX_CPB_FDM(csbcpb) |= NX_FDM_INTERMEDIATE;
		else
			NX_CPB_FDM(csbcpb) &= ~NX_FDM_INTERMEDIATE;

		nx_ctx->op.inlen = (nx_ctx->in_sg - nx_sg)
					* sizeof(struct nx_sg);

		csbcpb->cpb.aes_gcm.bit_length_data = 0;
		csbcpb->cpb.aes_gcm.bit_length_aad = 8 * nbytes;

		rc = nx_hcall_sync(nx_ctx, &nx_ctx->op,
				req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP);
		if (rc)
			goto out;

		memcpy(csbcpb->cpb.aes_gcm.in_pat_or_aad,
			csbcpb->cpb.aes_gcm.out_pat_or_mac, AES_BLOCK_SIZE);
		memcpy(csbcpb->cpb.aes_gcm.in_s0,
			csbcpb->cpb.aes_gcm.out_s0, AES_BLOCK_SIZE);

		NX_CPB_FDM(csbcpb) |= NX_FDM_CONTINUATION;

		atomic_inc(&(nx_ctx->stats->aes_ops));
		atomic64_add(assoclen, &(nx_ctx->stats->aes_bytes));

		processed += to_process;
	} while (processed < nbytes);

out:
	/* Restore GCM mode */
	csbcpb->cpb.hdr.mode = NX_MODE_AES_GCM;
	return rc;
}

static int gcm_empty(struct aead_request *req, struct blkcipher_desc *desc,
		     int enc)
{
	int rc;
	struct nx_crypto_ctx *nx_ctx =
		crypto_aead_ctx(crypto_aead_reqtfm(req));
	struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
	char out[AES_BLOCK_SIZE];
	struct nx_sg *in_sg, *out_sg;
	int len;

	/* For scenarios where the input message is zero length, AES CTR mode
	 * may be used. Set the source data to be a single block (16B) of all
	 * zeros, and set the input IV value to be the same as the GMAC IV
	 * value. - nx_wb 4.8.1.3 */

	/* Change to ECB mode */
	csbcpb->cpb.hdr.mode = NX_MODE_AES_ECB;
	memcpy(csbcpb->cpb.aes_ecb.key, csbcpb->cpb.aes_gcm.key,
			sizeof(csbcpb->cpb.aes_ecb.key));
	if (enc)
		NX_CPB_FDM(csbcpb) |= NX_FDM_ENDE_ENCRYPT;
	else
		NX_CPB_FDM(csbcpb) &= ~NX_FDM_ENDE_ENCRYPT;

	len = AES_BLOCK_SIZE;

	/* Encrypt the counter/IV */
	in_sg = nx_build_sg_list(nx_ctx->in_sg, (u8 *) desc->info,
				 &len, nx_ctx->ap->sglen);

	if (len != AES_BLOCK_SIZE)
		return -EINVAL;

	len = sizeof(out);
	out_sg = nx_build_sg_list(nx_ctx->out_sg, (u8 *) out, &len,
				  nx_ctx->ap->sglen);

	if (len != sizeof(out))
		return -EINVAL;

	nx_ctx->op.inlen = (nx_ctx->in_sg - in_sg) * sizeof(struct nx_sg);
	nx_ctx->op.outlen = (nx_ctx->out_sg - out_sg) * sizeof(struct nx_sg);

	rc = nx_hcall_sync(nx_ctx, &nx_ctx->op,
			   desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP);
	if (rc)
		goto out;
	atomic_inc(&(nx_ctx->stats->aes_ops));

	/* Copy out the auth tag */
	memcpy(csbcpb->cpb.aes_gcm.out_pat_or_mac, out,
			crypto_aead_authsize(crypto_aead_reqtfm(req)));
out:
	/* Restore XCBC mode */
	csbcpb->cpb.hdr.mode = NX_MODE_AES_GCM;

	/*
	 * ECB key uses the same region that GCM AAD and counter, so it's safe
	 * to just fill it with zeroes.
	 */
	memset(csbcpb->cpb.aes_ecb.key, 0, sizeof(csbcpb->cpb.aes_ecb.key));

	return rc;
}

static int gcm_aes_nx_crypt(struct aead_request *req, int enc,
			    unsigned int assoclen)
{
	struct nx_crypto_ctx *nx_ctx =
		crypto_aead_ctx(crypto_aead_reqtfm(req));
	struct nx_gcm_rctx *rctx = aead_request_ctx(req);
	struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
	struct blkcipher_desc desc;
	unsigned int nbytes = req->cryptlen;
	unsigned int processed = 0, to_process;
	unsigned long irq_flags;
	int rc = -EINVAL;

	spin_lock_irqsave(&nx_ctx->lock, irq_flags);

	desc.info = rctx->iv;
	/* initialize the counter */
	*(u32 *)(desc.info + NX_GCM_CTR_OFFSET) = 1;

	if (nbytes == 0) {
		if (assoclen == 0)
			rc = gcm_empty(req, &desc, enc);
		else
			rc = gmac(req, &desc, assoclen);
		if (rc)
			goto out;
		else
			goto mac;
	}

	/* Process associated data */
	csbcpb->cpb.aes_gcm.bit_length_aad = assoclen * 8;
	if (assoclen) {
		rc = nx_gca(nx_ctx, req, csbcpb->cpb.aes_gcm.in_pat_or_aad,
			    assoclen);
		if (rc)
			goto out;
	}

	/* Set flags for encryption */
	NX_CPB_FDM(csbcpb) &= ~NX_FDM_CONTINUATION;
	if (enc) {
		NX_CPB_FDM(csbcpb) |= NX_FDM_ENDE_ENCRYPT;
	} else {
		NX_CPB_FDM(csbcpb) &= ~NX_FDM_ENDE_ENCRYPT;
		nbytes -= crypto_aead_authsize(crypto_aead_reqtfm(req));
	}

	do {
		to_process = nbytes - processed;

		csbcpb->cpb.aes_gcm.bit_length_data = nbytes * 8;
		rc = nx_build_sg_lists(nx_ctx, &desc, req->dst,
				       req->src, &to_process,
				       processed + req->assoclen,
				       csbcpb->cpb.aes_gcm.iv_or_cnt);

		if (rc)
			goto out;

		if ((to_process + processed) < nbytes)
			NX_CPB_FDM(csbcpb) |= NX_FDM_INTERMEDIATE;
		else
			NX_CPB_FDM(csbcpb) &= ~NX_FDM_INTERMEDIATE;


		rc = nx_hcall_sync(nx_ctx, &nx_ctx->op,
				   req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP);
		if (rc)
			goto out;

		memcpy(desc.info, csbcpb->cpb.aes_gcm.out_cnt, AES_BLOCK_SIZE);
		memcpy(csbcpb->cpb.aes_gcm.in_pat_or_aad,
			csbcpb->cpb.aes_gcm.out_pat_or_mac, AES_BLOCK_SIZE);
		memcpy(csbcpb->cpb.aes_gcm.in_s0,
			csbcpb->cpb.aes_gcm.out_s0, AES_BLOCK_SIZE);

		NX_CPB_FDM(csbcpb) |= NX_FDM_CONTINUATION;

		atomic_inc(&(nx_ctx->stats->aes_ops));
		atomic64_add(csbcpb->csb.processed_byte_count,
			     &(nx_ctx->stats->aes_bytes));

		processed += to_process;
	} while (processed < nbytes);

mac:
	if (enc) {
		/* copy out the auth tag */
		scatterwalk_map_and_copy(
			csbcpb->cpb.aes_gcm.out_pat_or_mac,
			req->dst, req->assoclen + nbytes,
			crypto_aead_authsize(crypto_aead_reqtfm(req)),
			SCATTERWALK_TO_SG);
	} else {
		u8 *itag = nx_ctx->priv.gcm.iauth_tag;
		u8 *otag = csbcpb->cpb.aes_gcm.out_pat_or_mac;

		scatterwalk_map_and_copy(
			itag, req->src, req->assoclen + nbytes,
			crypto_aead_authsize(crypto_aead_reqtfm(req)),
			SCATTERWALK_FROM_SG);
		rc = crypto_memneq(itag, otag,
			    crypto_aead_authsize(crypto_aead_reqtfm(req))) ?
		     -EBADMSG : 0;
	}
out:
	spin_unlock_irqrestore(&nx_ctx->lock, irq_flags);
	return rc;
}

static int gcm_aes_nx_encrypt(struct aead_request *req)
{
	struct nx_gcm_rctx *rctx = aead_request_ctx(req);
	char *iv = rctx->iv;

	memcpy(iv, req->iv, GCM_AES_IV_SIZE);

	return gcm_aes_nx_crypt(req, 1, req->assoclen);
}

static int gcm_aes_nx_decrypt(struct aead_request *req)
{
	struct nx_gcm_rctx *rctx = aead_request_ctx(req);
	char *iv = rctx->iv;

	memcpy(iv, req->iv, GCM_AES_IV_SIZE);

	return gcm_aes_nx_crypt(req, 0, req->assoclen);
}

static int gcm4106_aes_nx_encrypt(struct aead_request *req)
{
	struct nx_crypto_ctx *nx_ctx =
		crypto_aead_ctx(crypto_aead_reqtfm(req));
	struct nx_gcm_rctx *rctx = aead_request_ctx(req);
	char *iv = rctx->iv;
	char *nonce = nx_ctx->priv.gcm.nonce;

	memcpy(iv, nonce, NX_GCM4106_NONCE_LEN);
	memcpy(iv + NX_GCM4106_NONCE_LEN, req->iv, 8);

	if (req->assoclen < 8)
		return -EINVAL;

	return gcm_aes_nx_crypt(req, 1, req->assoclen - 8);
}

static int gcm4106_aes_nx_decrypt(struct aead_request *req)
{
	struct nx_crypto_ctx *nx_ctx =
		crypto_aead_ctx(crypto_aead_reqtfm(req));
	struct nx_gcm_rctx *rctx = aead_request_ctx(req);
	char *iv = rctx->iv;
	char *nonce = nx_ctx->priv.gcm.nonce;

	memcpy(iv, nonce, NX_GCM4106_NONCE_LEN);
	memcpy(iv + NX_GCM4106_NONCE_LEN, req->iv, 8);

	if (req->assoclen < 8)
		return -EINVAL;

	return gcm_aes_nx_crypt(req, 0, req->assoclen - 8);
}

/* tell the block cipher walk routines that this is a stream cipher by
 * setting cra_blocksize to 1. Even using blkcipher_walk_virt_block
 * during encrypt/decrypt doesn't solve this problem, because it calls
 * blkcipher_walk_done under the covers, which doesn't use walk->blocksize,
 * but instead uses this tfm->blocksize. */
struct aead_alg nx_gcm_aes_alg = {
	.base = {
		.cra_name        = "gcm(aes)",
		.cra_driver_name = "gcm-aes-nx",
		.cra_priority    = 300,
		.cra_blocksize   = 1,
		.cra_ctxsize     = sizeof(struct nx_crypto_ctx),
		.cra_module      = THIS_MODULE,
	},
	.init        = nx_crypto_ctx_aes_gcm_init,
	.exit        = nx_crypto_ctx_aead_exit,
	.ivsize      = GCM_AES_IV_SIZE,
	.maxauthsize = AES_BLOCK_SIZE,
	.setkey      = gcm_aes_nx_set_key,
	.encrypt     = gcm_aes_nx_encrypt,
	.decrypt     = gcm_aes_nx_decrypt,
};

struct aead_alg nx_gcm4106_aes_alg = {
	.base = {
		.cra_name        = "rfc4106(gcm(aes))",
		.cra_driver_name = "rfc4106-gcm-aes-nx",
		.cra_priority    = 300,
		.cra_blocksize   = 1,
		.cra_ctxsize     = sizeof(struct nx_crypto_ctx),
		.cra_module      = THIS_MODULE,
	},
	.init        = nx_crypto_ctx_aes_gcm_init,
	.exit        = nx_crypto_ctx_aead_exit,
	.ivsize      = GCM_RFC4106_IV_SIZE,
	.maxauthsize = AES_BLOCK_SIZE,
	.setkey      = gcm4106_aes_nx_set_key,
	.setauthsize = gcm4106_aes_nx_setauthsize,
	.encrypt     = gcm4106_aes_nx_encrypt,
	.decrypt     = gcm4106_aes_nx_decrypt,
};
Commit	Line	Data
64d85cc9	1	// SPDX-License-Identifier: GPL-2.0-only
f2a15f1d KY	2	/**
	3	* AES GCM routines supporting the Power 7+ Nest Accelerators driver
	4	*
	5	* Copyright (C) 2012 International Business Machines Inc.
	6	*
f2a15f1d KY	7	* Author: Kent Yoder <yoder1@us.ibm.com>
	8	*/
	9
	10	#include <crypto/internal/aead.h>
	11	#include <crypto/aes.h>
cb8affb5	12	#include <crypto/algapi.h>
fdd0f3d8	13	#include <crypto/gcm.h>
f2a15f1d KY	14	#include <crypto/scatterwalk.h>
	15	#include <linux/module.h>
	16	#include <linux/types.h>
f2a15f1d KY	17	#include <asm/vio.h>
	18
	19	#include "nx_csbcpb.h"
	20	#include "nx.h"
	21
	22
	23	static int gcm_aes_nx_set_key(struct crypto_aead *tfm,
	24	const u8 *in_key,
	25	unsigned int key_len)
	26	{
c3d21949	27	struct nx_crypto_ctx *nx_ctx = crypto_aead_ctx(tfm);
f2a15f1d KY	28	struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
	29	struct nx_csbcpb *csbcpb_aead = nx_ctx->csbcpb_aead;
	30
	31	nx_ctx_init(nx_ctx, HCOP_FC_AES);
	32
	33	switch (key_len) {
	34	case AES_KEYSIZE_128:
	35	NX_CPB_SET_KEY_SIZE(csbcpb, NX_KS_AES_128);
	36	NX_CPB_SET_KEY_SIZE(csbcpb_aead, NX_KS_AES_128);
	37	nx_ctx->ap = &nx_ctx->props[NX_PROPS_AES_128];
	38	break;
	39	case AES_KEYSIZE_192:
	40	NX_CPB_SET_KEY_SIZE(csbcpb, NX_KS_AES_192);
	41	NX_CPB_SET_KEY_SIZE(csbcpb_aead, NX_KS_AES_192);
	42	nx_ctx->ap = &nx_ctx->props[NX_PROPS_AES_192];
	43	break;
	44	case AES_KEYSIZE_256:
	45	NX_CPB_SET_KEY_SIZE(csbcpb, NX_KS_AES_256);
	46	NX_CPB_SET_KEY_SIZE(csbcpb_aead, NX_KS_AES_256);
	47	nx_ctx->ap = &nx_ctx->props[NX_PROPS_AES_256];
	48	break;
	49	default:
	50	return -EINVAL;
	51	}
	52
	53	csbcpb->cpb.hdr.mode = NX_MODE_AES_GCM;
	54	memcpy(csbcpb->cpb.aes_gcm.key, in_key, key_len);
	55
	56	csbcpb_aead->cpb.hdr.mode = NX_MODE_AES_GCA;
	57	memcpy(csbcpb_aead->cpb.aes_gca.key, in_key, key_len);
	58
	59	return 0;
	60	}
	61
	62	static int gcm4106_aes_nx_set_key(struct crypto_aead *tfm,
	63	const u8 *in_key,
	64	unsigned int key_len)
	65	{
c3d21949	66	struct nx_crypto_ctx *nx_ctx = crypto_aead_ctx(tfm);
f2a15f1d KY	67	char *nonce = nx_ctx->priv.gcm.nonce;
	68	int rc;
	69
	70	if (key_len < 4)
	71	return -EINVAL;
	72
	73	key_len -= 4;
	74
	75	rc = gcm_aes_nx_set_key(tfm, in_key, key_len);
	76	if (rc)
	77	goto out;
	78
	79	memcpy(nonce, in_key + key_len, 4);
	80	out:
	81	return rc;
	82	}
	83
f2a15f1d KY	84	static int gcm4106_aes_nx_setauthsize(struct crypto_aead *tfm,
	85	unsigned int authsize)
	86	{
	87	switch (authsize) {
	88	case 8:
	89	case 12:
	90	case 16:
	91	break;
	92	default:
	93	return -EINVAL;
	94	}
	95
f2a15f1d KY	96	return 0;
	97	}
	98
	99	static int nx_gca(struct nx_crypto_ctx *nx_ctx,
	100	struct aead_request *req,
c3d21949 HX	101	u8 *out,
c3d21949 HX	102	unsigned int assoclen)
f2a15f1d	103	{
79980434	104	int rc;
f2a15f1d	105	struct nx_csbcpb *csbcpb_aead = nx_ctx->csbcpb_aead;
f2a15f1d KY	106	struct scatter_walk walk;
f2a15f1d KY	107	struct nx_sg *nx_sg = nx_ctx->in_sg;
c3d21949	108	unsigned int nbytes = assoclen;
79980434	109	unsigned int processed = 0, to_process;
e13a79ac	110	unsigned int max_sg_len;
f2a15f1d	111
79980434	112	if (nbytes <= AES_BLOCK_SIZE) {
201f28f0	113	scatterwalk_start(&walk, req->src);
79980434	114	scatterwalk_copychunks(out, &walk, nbytes, SCATTERWALK_FROM_SG);
f2a15f1d	115	scatterwalk_done(&walk, SCATTERWALK_FROM_SG, 0);
79980434	116	return 0;
f2a15f1d KY	117	}
f2a15f1d KY	118
79980434	119	NX_CPB_FDM(csbcpb_aead) &= ~NX_FDM_CONTINUATION;
f2a15f1d	120
79980434	121	/* page_limit: number of sg entries that fit on one page */
e13a79ac	122	max_sg_len = min_t(u64, nx_driver.of.max_sg_len/sizeof(struct nx_sg),
79980434	123	nx_ctx->ap->sglen);
e13a79ac LB	124	max_sg_len = min_t(u64, max_sg_len,
e13a79ac LB	125	nx_ctx->ap->databytelen/NX_PAGE_SIZE);
f2a15f1d	126
79980434 MC	127	do {
	128	/*
	129	* to_process: the data chunk to process in this update.
	130	* This value is bound by sg list limits.
	131	*/
	132	to_process = min_t(u64, nbytes - processed,
	133	nx_ctx->ap->databytelen);
	134	to_process = min_t(u64, to_process,
	135	NX_PAGE_SIZE * (max_sg_len - 1));
	136
e13a79ac	137	nx_sg = nx_walk_and_build(nx_ctx->in_sg, max_sg_len,
201f28f0	138	req->src, processed, &to_process);
e13a79ac	139
79980434 MC	140	if ((to_process + processed) < nbytes)
	141	NX_CPB_FDM(csbcpb_aead) \|= NX_FDM_INTERMEDIATE;
	142	else
	143	NX_CPB_FDM(csbcpb_aead) &= ~NX_FDM_INTERMEDIATE;
	144
79980434 MC	145	nx_ctx->op_aead.inlen = (nx_ctx->in_sg - nx_sg)
	146	* sizeof(struct nx_sg);
	147
	148	rc = nx_hcall_sync(nx_ctx, &nx_ctx->op_aead,
	149	req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP);
	150	if (rc)
	151	return rc;
	152
	153	memcpy(csbcpb_aead->cpb.aes_gca.in_pat,
	154	csbcpb_aead->cpb.aes_gca.out_pat,
	155	AES_BLOCK_SIZE);
	156	NX_CPB_FDM(csbcpb_aead) \|= NX_FDM_CONTINUATION;
	157
	158	atomic_inc(&(nx_ctx->stats->aes_ops));
c3d21949	159	atomic64_add(assoclen, &(nx_ctx->stats->aes_bytes));
79980434 MC	160
	161	processed += to_process;
	162	} while (processed < nbytes);
f2a15f1d KY	163
f2a15f1d KY	164	memcpy(out, csbcpb_aead->cpb.aes_gca.out_pat, AES_BLOCK_SIZE);
79980434 MC	165
	166	return rc;
	167	}
	168
c3d21949 HX	169	static int gmac(struct aead_request req, struct blkcipher_desc desc,
c3d21949 HX	170	unsigned int assoclen)
dec0ed6c MC	171	{
dec0ed6c MC	172	int rc;
c3d21949 HX	173	struct nx_crypto_ctx *nx_ctx =
c3d21949 HX	174	crypto_aead_ctx(crypto_aead_reqtfm(req));
dec0ed6c MC	175	struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
dec0ed6c MC	176	struct nx_sg *nx_sg;
c3d21949	177	unsigned int nbytes = assoclen;
dec0ed6c	178	unsigned int processed = 0, to_process;
e13a79ac	179	unsigned int max_sg_len;
dec0ed6c MC	180
	181	/* Set GMAC mode */
	182	csbcpb->cpb.hdr.mode = NX_MODE_AES_GMAC;
	183
	184	NX_CPB_FDM(csbcpb) &= ~NX_FDM_CONTINUATION;
	185
	186	/* page_limit: number of sg entries that fit on one page */
e13a79ac	187	max_sg_len = min_t(u64, nx_driver.of.max_sg_len/sizeof(struct nx_sg),
dec0ed6c	188	nx_ctx->ap->sglen);
e13a79ac LB	189	max_sg_len = min_t(u64, max_sg_len,
e13a79ac LB	190	nx_ctx->ap->databytelen/NX_PAGE_SIZE);
dec0ed6c MC	191
	192	/* Copy IV */
	193	memcpy(csbcpb->cpb.aes_gcm.iv_or_cnt, desc->info, AES_BLOCK_SIZE);
	194
	195	do {
	196	/*
	197	* to_process: the data chunk to process in this update.
	198	* This value is bound by sg list limits.
	199	*/
	200	to_process = min_t(u64, nbytes - processed,
	201	nx_ctx->ap->databytelen);
	202	to_process = min_t(u64, to_process,
	203	NX_PAGE_SIZE * (max_sg_len - 1));
	204
e13a79ac	205	nx_sg = nx_walk_and_build(nx_ctx->in_sg, max_sg_len,
201f28f0	206	req->src, processed, &to_process);
e13a79ac	207
dec0ed6c MC	208	if ((to_process + processed) < nbytes)
	209	NX_CPB_FDM(csbcpb) \|= NX_FDM_INTERMEDIATE;
	210	else
	211	NX_CPB_FDM(csbcpb) &= ~NX_FDM_INTERMEDIATE;
	212
dec0ed6c MC	213	nx_ctx->op.inlen = (nx_ctx->in_sg - nx_sg)
	214	* sizeof(struct nx_sg);
	215
	216	csbcpb->cpb.aes_gcm.bit_length_data = 0;
	217	csbcpb->cpb.aes_gcm.bit_length_aad = 8 * nbytes;
	218
	219	rc = nx_hcall_sync(nx_ctx, &nx_ctx->op,
	220	req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP);
	221	if (rc)
	222	goto out;
	223
	224	memcpy(csbcpb->cpb.aes_gcm.in_pat_or_aad,
	225	csbcpb->cpb.aes_gcm.out_pat_or_mac, AES_BLOCK_SIZE);
	226	memcpy(csbcpb->cpb.aes_gcm.in_s0,
	227	csbcpb->cpb.aes_gcm.out_s0, AES_BLOCK_SIZE);
	228
	229	NX_CPB_FDM(csbcpb) \|= NX_FDM_CONTINUATION;
	230
	231	atomic_inc(&(nx_ctx->stats->aes_ops));
c3d21949	232	atomic64_add(assoclen, &(nx_ctx->stats->aes_bytes));
dec0ed6c MC	233
	234	processed += to_process;
	235	} while (processed < nbytes);
	236
	237	out:
	238	/* Restore GCM mode */
	239	csbcpb->cpb.hdr.mode = NX_MODE_AES_GCM;
	240	return rc;
	241	}
	242
79980434 MC	243	static int gcm_empty(struct aead_request req, struct blkcipher_desc desc,
	244	int enc)
	245	{
	246	int rc;
c3d21949 HX	247	struct nx_crypto_ctx *nx_ctx =
c3d21949 HX	248	crypto_aead_ctx(crypto_aead_reqtfm(req));
79980434	249	struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
dec0ed6c MC	250	char out[AES_BLOCK_SIZE];
dec0ed6c MC	251	struct nx_sg in_sg, out_sg;
e13a79ac	252	int len;
79980434 MC	253
	254	/* For scenarios where the input message is zero length, AES CTR mode
	255	* may be used. Set the source data to be a single block (16B) of all
	256	* zeros, and set the input IV value to be the same as the GMAC IV
	257	* value. - nx_wb 4.8.1.3 */
79980434	258
dec0ed6c MC	259	/* Change to ECB mode */
	260	csbcpb->cpb.hdr.mode = NX_MODE_AES_ECB;
	261	memcpy(csbcpb->cpb.aes_ecb.key, csbcpb->cpb.aes_gcm.key,
	262	sizeof(csbcpb->cpb.aes_ecb.key));
79980434	263	if (enc)
dec0ed6c	264	NX_CPB_FDM(csbcpb) \|= NX_FDM_ENDE_ENCRYPT;
79980434	265	else
dec0ed6c MC	266	NX_CPB_FDM(csbcpb) &= ~NX_FDM_ENDE_ENCRYPT;
dec0ed6c MC	267
e13a79ac LB	268	len = AES_BLOCK_SIZE;
e13a79ac LB	269
dec0ed6c MC	270	/* Encrypt the counter/IV */
dec0ed6c MC	271	in_sg = nx_build_sg_list(nx_ctx->in_sg, (u8 *) desc->info,
e13a79ac LB	272	&len, nx_ctx->ap->sglen);
	273
	274	if (len != AES_BLOCK_SIZE)
	275	return -EINVAL;
	276
	277	len = sizeof(out);
	278	out_sg = nx_build_sg_list(nx_ctx->out_sg, (u8 *) out, &len,
dec0ed6c	279	nx_ctx->ap->sglen);
e13a79ac LB	280
	281	if (len != sizeof(out))
	282	return -EINVAL;
	283
dec0ed6c MC	284	nx_ctx->op.inlen = (nx_ctx->in_sg - in_sg) * sizeof(struct nx_sg);
dec0ed6c MC	285	nx_ctx->op.outlen = (nx_ctx->out_sg - out_sg) * sizeof(struct nx_sg);
79980434	286
dec0ed6c MC	287	rc = nx_hcall_sync(nx_ctx, &nx_ctx->op,
	288	desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP);
	289	if (rc)
	290	goto out;
	291	atomic_inc(&(nx_ctx->stats->aes_ops));
	292
	293	/* Copy out the auth tag */
	294	memcpy(csbcpb->cpb.aes_gcm.out_pat_or_mac, out,
	295	crypto_aead_authsize(crypto_aead_reqtfm(req)));
f2a15f1d	296	out:
dec0ed6c MC	297	/* Restore XCBC mode */
	298	csbcpb->cpb.hdr.mode = NX_MODE_AES_GCM;
	299
	300	/*
	301	* ECB key uses the same region that GCM AAD and counter, so it's safe
	302	* to just fill it with zeroes.
	303	*/
	304	memset(csbcpb->cpb.aes_ecb.key, 0, sizeof(csbcpb->cpb.aes_ecb.key));
	305
f2a15f1d KY	306	return rc;
	307	}
	308
c3d21949 HX	309	static int gcm_aes_nx_crypt(struct aead_request *req, int enc,
c3d21949 HX	310	unsigned int assoclen)
f2a15f1d	311	{
c3d21949 HX	312	struct nx_crypto_ctx *nx_ctx =
c3d21949 HX	313	crypto_aead_ctx(crypto_aead_reqtfm(req));
030f4e96	314	struct nx_gcm_rctx *rctx = aead_request_ctx(req);
f2a15f1d KY	315	struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
	316	struct blkcipher_desc desc;
	317	unsigned int nbytes = req->cryptlen;
79980434	318	unsigned int processed = 0, to_process;
c849163b	319	unsigned long irq_flags;
f2a15f1d KY	320	int rc = -EINVAL;
f2a15f1d KY	321
c849163b MC	322	spin_lock_irqsave(&nx_ctx->lock, irq_flags);
c849163b MC	323
030f4e96	324	desc.info = rctx->iv;
f2a15f1d KY	325	/* initialize the counter */
	326	(u32 )(desc.info + NX_GCM_CTR_OFFSET) = 1;
	327
f2a15f1d	328	if (nbytes == 0) {
c3d21949	329	if (assoclen == 0)
dec0ed6c MC	330	rc = gcm_empty(req, &desc, enc);
dec0ed6c MC	331	else
c3d21949	332	rc = gmac(req, &desc, assoclen);
dec0ed6c MC	333	if (rc)
	334	goto out;
	335	else
	336	goto mac;
f2a15f1d KY	337	}
f2a15f1d KY	338
79980434	339	/* Process associated data */
c3d21949 HX	340	csbcpb->cpb.aes_gcm.bit_length_aad = assoclen * 8;
	341	if (assoclen) {
	342	rc = nx_gca(nx_ctx, req, csbcpb->cpb.aes_gcm.in_pat_or_aad,
	343	assoclen);
f2a15f1d KY	344	if (rc)
	345	goto out;
	346	}
	347
79980434 MC	348	/* Set flags for encryption */
	349	NX_CPB_FDM(csbcpb) &= ~NX_FDM_CONTINUATION;
	350	if (enc) {
f2a15f1d	351	NX_CPB_FDM(csbcpb) \|= NX_FDM_ENDE_ENCRYPT;
79980434 MC	352	} else {
79980434 MC	353	NX_CPB_FDM(csbcpb) &= ~NX_FDM_ENDE_ENCRYPT;
1ad936e8	354	nbytes -= crypto_aead_authsize(crypto_aead_reqtfm(req));
79980434	355	}
f2a15f1d	356
79980434	357	do {
e13a79ac	358	to_process = nbytes - processed;
f2a15f1d	359
79980434	360	csbcpb->cpb.aes_gcm.bit_length_data = nbytes * 8;
79980434	361	rc = nx_build_sg_lists(nx_ctx, &desc, req->dst,
201f28f0 HX	362	req->src, &to_process,
201f28f0 HX	363	processed + req->assoclen,
79980434	364	csbcpb->cpb.aes_gcm.iv_or_cnt);
e13a79ac	365
79980434 MC	366	if (rc)
79980434 MC	367	goto out;
f2a15f1d	368
e13a79ac LB	369	if ((to_process + processed) < nbytes)
	370	NX_CPB_FDM(csbcpb) \|= NX_FDM_INTERMEDIATE;
	371	else
	372	NX_CPB_FDM(csbcpb) &= ~NX_FDM_INTERMEDIATE;
	373
	374
79980434 MC	375	rc = nx_hcall_sync(nx_ctx, &nx_ctx->op,
	376	req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP);
	377	if (rc)
	378	goto out;
	379
	380	memcpy(desc.info, csbcpb->cpb.aes_gcm.out_cnt, AES_BLOCK_SIZE);
	381	memcpy(csbcpb->cpb.aes_gcm.in_pat_or_aad,
	382	csbcpb->cpb.aes_gcm.out_pat_or_mac, AES_BLOCK_SIZE);
	383	memcpy(csbcpb->cpb.aes_gcm.in_s0,
	384	csbcpb->cpb.aes_gcm.out_s0, AES_BLOCK_SIZE);
	385
	386	NX_CPB_FDM(csbcpb) \|= NX_FDM_CONTINUATION;
	387
	388	atomic_inc(&(nx_ctx->stats->aes_ops));
	389	atomic64_add(csbcpb->csb.processed_byte_count,
	390	&(nx_ctx->stats->aes_bytes));
f2a15f1d	391
79980434 MC	392	processed += to_process;
79980434 MC	393	} while (processed < nbytes);
f2a15f1d	394
dec0ed6c	395	mac:
f2a15f1d KY	396	if (enc) {
f2a15f1d KY	397	/* copy out the auth tag */
201f28f0 HX	398	scatterwalk_map_and_copy(
	399	csbcpb->cpb.aes_gcm.out_pat_or_mac,
	400	req->dst, req->assoclen + nbytes,
	401	crypto_aead_authsize(crypto_aead_reqtfm(req)),
	402	SCATTERWALK_TO_SG);
b4eba0ca	403	} else {
f2a15f1d KY	404	u8 *itag = nx_ctx->priv.gcm.iauth_tag;
	405	u8 *otag = csbcpb->cpb.aes_gcm.out_pat_or_mac;
	406
201f28f0 HX	407	scatterwalk_map_and_copy(
	408	itag, req->src, req->assoclen + nbytes,
	409	crypto_aead_authsize(crypto_aead_reqtfm(req)),
	410	SCATTERWALK_FROM_SG);
cb8affb5	411	rc = crypto_memneq(itag, otag,
f2a15f1d KY	412	crypto_aead_authsize(crypto_aead_reqtfm(req))) ?
	413	-EBADMSG : 0;
	414	}
	415	out:
c849163b	416	spin_unlock_irqrestore(&nx_ctx->lock, irq_flags);
f2a15f1d KY	417	return rc;
	418	}
	419
	420	static int gcm_aes_nx_encrypt(struct aead_request *req)
	421	{
030f4e96 HX	422	struct nx_gcm_rctx *rctx = aead_request_ctx(req);
030f4e96 HX	423	char *iv = rctx->iv;
f2a15f1d	424
fdd0f3d8	425	memcpy(iv, req->iv, GCM_AES_IV_SIZE);
f2a15f1d	426
c3d21949	427	return gcm_aes_nx_crypt(req, 1, req->assoclen);
f2a15f1d KY	428	}
	429
	430	static int gcm_aes_nx_decrypt(struct aead_request *req)
	431	{
030f4e96 HX	432	struct nx_gcm_rctx *rctx = aead_request_ctx(req);
030f4e96 HX	433	char *iv = rctx->iv;
f2a15f1d	434
fdd0f3d8	435	memcpy(iv, req->iv, GCM_AES_IV_SIZE);
f2a15f1d	436
c3d21949	437	return gcm_aes_nx_crypt(req, 0, req->assoclen);
f2a15f1d KY	438	}
	439
	440	static int gcm4106_aes_nx_encrypt(struct aead_request *req)
	441	{
c3d21949 HX	442	struct nx_crypto_ctx *nx_ctx =
c3d21949 HX	443	crypto_aead_ctx(crypto_aead_reqtfm(req));
030f4e96 HX	444	struct nx_gcm_rctx *rctx = aead_request_ctx(req);
030f4e96 HX	445	char *iv = rctx->iv;
f2a15f1d KY	446	char *nonce = nx_ctx->priv.gcm.nonce;
	447
	448	memcpy(iv, nonce, NX_GCM4106_NONCE_LEN);
	449	memcpy(iv + NX_GCM4106_NONCE_LEN, req->iv, 8);
	450
c3d21949 HX	451	if (req->assoclen < 8)
	452	return -EINVAL;
	453
	454	return gcm_aes_nx_crypt(req, 1, req->assoclen - 8);
f2a15f1d KY	455	}
	456
	457	static int gcm4106_aes_nx_decrypt(struct aead_request *req)
	458	{
c3d21949 HX	459	struct nx_crypto_ctx *nx_ctx =
c3d21949 HX	460	crypto_aead_ctx(crypto_aead_reqtfm(req));
030f4e96 HX	461	struct nx_gcm_rctx *rctx = aead_request_ctx(req);
030f4e96 HX	462	char *iv = rctx->iv;
f2a15f1d KY	463	char *nonce = nx_ctx->priv.gcm.nonce;
	464
	465	memcpy(iv, nonce, NX_GCM4106_NONCE_LEN);
	466	memcpy(iv + NX_GCM4106_NONCE_LEN, req->iv, 8);
	467
c3d21949 HX	468	if (req->assoclen < 8)
	469	return -EINVAL;
	470
	471	return gcm_aes_nx_crypt(req, 0, req->assoclen - 8);
f2a15f1d KY	472	}
	473
	474	/* tell the block cipher walk routines that this is a stream cipher by
	475	* setting cra_blocksize to 1. Even using blkcipher_walk_virt_block
	476	* during encrypt/decrypt doesn't solve this problem, because it calls
	477	* blkcipher_walk_done under the covers, which doesn't use walk->blocksize,
	478	* but instead uses this tfm->blocksize. */
201f28f0 HX	479	struct aead_alg nx_gcm_aes_alg = {
	480	.base = {
	481	.cra_name = "gcm(aes)",
	482	.cra_driver_name = "gcm-aes-nx",
	483	.cra_priority = 300,
	484	.cra_blocksize = 1,
	485	.cra_ctxsize = sizeof(struct nx_crypto_ctx),
	486	.cra_module = THIS_MODULE,
	487	},
	488	.init = nx_crypto_ctx_aes_gcm_init,
	489	.exit = nx_crypto_ctx_aead_exit,
fdd0f3d8	490	.ivsize = GCM_AES_IV_SIZE,
201f28f0 HX	491	.maxauthsize = AES_BLOCK_SIZE,
	492	.setkey = gcm_aes_nx_set_key,
	493	.encrypt = gcm_aes_nx_encrypt,
	494	.decrypt = gcm_aes_nx_decrypt,
f2a15f1d KY	495	};
f2a15f1d KY	496
201f28f0 HX	497	struct aead_alg nx_gcm4106_aes_alg = {
	498	.base = {
	499	.cra_name = "rfc4106(gcm(aes))",
	500	.cra_driver_name = "rfc4106-gcm-aes-nx",
	501	.cra_priority = 300,
	502	.cra_blocksize = 1,
	503	.cra_ctxsize = sizeof(struct nx_crypto_ctx),
	504	.cra_module = THIS_MODULE,
	505	},
	506	.init = nx_crypto_ctx_aes_gcm_init,
	507	.exit = nx_crypto_ctx_aead_exit,
fdd0f3d8	508	.ivsize = GCM_RFC4106_IV_SIZE,
201f28f0 HX	509	.maxauthsize = AES_BLOCK_SIZE,
	510	.setkey = gcm4106_aes_nx_set_key,
	511	.setauthsize = gcm4106_aes_nx_setauthsize,
	512	.encrypt = gcm4106_aes_nx_encrypt,
	513	.decrypt = gcm4106_aes_nx_decrypt,
f2a15f1d	514	};