[mirror_ubuntu-focal-kernel.git] / drivers / crypto / bcm / util.c

/*
 * Copyright 2016 Broadcom
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2, as
 * published by the Free Software Foundation (the "GPL").
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License version 2 (GPLv2) for more details.
 *
 * You should have received a copy of the GNU General Public License
 * version 2 (GPLv2) along with this source code.
 */

#include <linux/debugfs.h>

#include "cipher.h"
#include "util.h"

/* offset of SPU_OFIFO_CTRL register */
#define SPU_OFIFO_CTRL      0x40
#define SPU_FIFO_WATERMARK  0x1FF

/**
 * spu_sg_at_offset() - Find the scatterlist entry at a given distance from the
 * start of a scatterlist.
 * @sg:         [in]  Start of a scatterlist
 * @skip:       [in]  Distance from the start of the scatterlist, in bytes
 * @sge:        [out] Scatterlist entry at skip bytes from start
 * @sge_offset: [out] Number of bytes from start of sge buffer to get to
 *                    requested distance.
 *
 * Return: 0 if entry found at requested distance
 *         < 0 otherwise
 */
int spu_sg_at_offset(struct scatterlist *sg, unsigned int skip,
		     struct scatterlist **sge, unsigned int *sge_offset)
{
	/* byte index from start of sg to the end of the previous entry */
	unsigned int index = 0;
	/* byte index from start of sg to the end of the current entry */
	unsigned int next_index;

	next_index = sg->length;
	while (next_index <= skip) {
		sg = sg_next(sg);
		index = next_index;
		if (!sg)
			return -EINVAL;
		next_index += sg->length;
	}

	*sge_offset = skip - index;
	*sge = sg;
	return 0;
}

/* Copy len bytes of sg data, starting at offset skip, to a dest buffer */
void sg_copy_part_to_buf(struct scatterlist *src, u8 *dest,
			 unsigned int len, unsigned int skip)
{
	size_t copied;
	unsigned int nents = sg_nents(src);

	copied = sg_pcopy_to_buffer(src, nents, dest, len, skip);
	if (copied != len) {
		flow_log("%s copied %u bytes of %u requested. ",
			 __func__, (u32)copied, len);
		flow_log("sg with %u entries and skip %u\n", nents, skip);
	}
}

/*
 * Copy data into a scatterlist starting at a specified offset in the
 * scatterlist. Specifically, copy len bytes of data in the buffer src
 * into the scatterlist dest, starting skip bytes into the scatterlist.
 */
void sg_copy_part_from_buf(struct scatterlist *dest, u8 *src,
			   unsigned int len, unsigned int skip)
{
	size_t copied;
	unsigned int nents = sg_nents(dest);

	copied = sg_pcopy_from_buffer(dest, nents, src, len, skip);
	if (copied != len) {
		flow_log("%s copied %u bytes of %u requested. ",
			 __func__, (u32)copied, len);
		flow_log("sg with %u entries and skip %u\n", nents, skip);
	}
}

/**
 * spu_sg_count() - Determine number of elements in scatterlist to provide a
 * specified number of bytes.
 * @sg_list:  scatterlist to examine
 * @skip:     index of starting point
 * @nbytes:   consider elements of scatterlist until reaching this number of
 *	      bytes
 *
 * Return: the number of sg entries contributing to nbytes of data
 */
int spu_sg_count(struct scatterlist *sg_list, unsigned int skip, int nbytes)
{
	struct scatterlist *sg;
	int sg_nents = 0;
	unsigned int offset;

	if (!sg_list)
		return 0;

	if (spu_sg_at_offset(sg_list, skip, &sg, &offset) < 0)
		return 0;

	while (sg && (nbytes > 0)) {
		sg_nents++;
		nbytes -= (sg->length - offset);
		offset = 0;
		sg = sg_next(sg);
	}
	return sg_nents;
}

/**
 * spu_msg_sg_add() - Copy scatterlist entries from one sg to another, up to a
 * given length.
 * @to_sg:       scatterlist to copy to
 * @from_sg:     scatterlist to copy from
 * @from_skip:   number of bytes to skip in from_sg. Non-zero when previous
 *		 request included part of the buffer in entry in from_sg.
 *		 Assumes from_skip < from_sg->length.
 * @from_nents   number of entries in from_sg
 * @length       number of bytes to copy. may reach this limit before exhausting
 *		 from_sg.
 *
 * Copies the entries themselves, not the data in the entries. Assumes to_sg has
 * enough entries. Does not limit the size of an individual buffer in to_sg.
 *
 * to_sg, from_sg, skip are all updated to end of copy
 *
 * Return: Number of bytes copied
 */
u32 spu_msg_sg_add(struct scatterlist **to_sg,
		   struct scatterlist **from_sg, u32 *from_skip,
		   u8 from_nents, u32 length)
{
	struct scatterlist *sg;	/* an entry in from_sg */
	struct scatterlist *to = *to_sg;
	struct scatterlist *from = *from_sg;
	u32 skip = *from_skip;
	u32 offset;
	int i;
	u32 entry_len = 0;
	u32 frag_len = 0;	/* length of entry added to to_sg */
	u32 copied = 0;		/* number of bytes copied so far */

	if (length == 0)
		return 0;

	for_each_sg(from, sg, from_nents, i) {
		/* number of bytes in this from entry not yet used */
		entry_len = sg->length - skip;
		frag_len = min(entry_len, length - copied);
		offset = sg->offset + skip;
		if (frag_len)
			sg_set_page(to++, sg_page(sg), frag_len, offset);
		copied += frag_len;
		if (copied == entry_len) {
			/* used up all of from entry */
			skip = 0;	/* start at beginning of next entry */
		}
		if (copied == length)
			break;
	}
	*to_sg = to;
	*from_sg = sg;
	if (frag_len < entry_len)
		*from_skip = skip + frag_len;
	else
		*from_skip = 0;

	return copied;
}

void add_to_ctr(u8 *ctr_pos, unsigned int increment)
{
	__be64 *high_be = (__be64 *)ctr_pos;
	__be64 *low_be = high_be + 1;
	u64 orig_low = __be64_to_cpu(*low_be);
	u64 new_low = orig_low + (u64)increment;

	*low_be = __cpu_to_be64(new_low);
	if (new_low < orig_low)
		/* there was a carry from the low 8 bytes */
		*high_be = __cpu_to_be64(__be64_to_cpu(*high_be) + 1);
}

struct sdesc {
	struct shash_desc shash;
	char ctx[];
};

/* do a synchronous decrypt operation */
int do_decrypt(char *alg_name,
	       void *key_ptr, unsigned int key_len,
	       void *iv_ptr, void *src_ptr, void *dst_ptr,
	       unsigned int block_len)
{
	struct scatterlist sg_in[1], sg_out[1];
	struct crypto_blkcipher *tfm =
	    crypto_alloc_blkcipher(alg_name, 0, CRYPTO_ALG_ASYNC);
	struct blkcipher_desc desc = {.tfm = tfm, .flags = 0 };
	int ret = 0;
	void *iv;
	int ivsize;

	flow_log("%s() name:%s block_len:%u\n", __func__, alg_name, block_len);

	if (IS_ERR(tfm))
		return PTR_ERR(tfm);

	crypto_blkcipher_setkey((void *)tfm, key_ptr, key_len);

	sg_init_table(sg_in, 1);
	sg_set_buf(sg_in, src_ptr, block_len);

	sg_init_table(sg_out, 1);
	sg_set_buf(sg_out, dst_ptr, block_len);

	iv = crypto_blkcipher_crt(tfm)->iv;
	ivsize = crypto_blkcipher_ivsize(tfm);
	memcpy(iv, iv_ptr, ivsize);

	ret = crypto_blkcipher_decrypt(&desc, sg_out, sg_in, block_len);
	crypto_free_blkcipher(tfm);

	if (ret < 0)
		pr_err("aes_decrypt failed %d\n", ret);

	return ret;
}

/**
 * do_shash() - Do a synchronous hash operation in software
 * @name:       The name of the hash algorithm
 * @result:     Buffer where digest is to be written
 * @data1:      First part of data to hash. May be NULL.
 * @data1_len:  Length of data1, in bytes
 * @data2:      Second part of data to hash. May be NULL.
 * @data2_len:  Length of data2, in bytes
 * @key:	Key (if keyed hash)
 * @key_len:	Length of key, in bytes (or 0 if non-keyed hash)
 *
 * Note that the crypto API will not select this driver's own transform because
 * this driver only registers asynchronous algos.
 *
 * Return: 0 if hash successfully stored in result
 *         < 0 otherwise
 */
int do_shash(unsigned char *name, unsigned char *result,
	     const u8 *data1, unsigned int data1_len,
	     const u8 *data2, unsigned int data2_len,
	     const u8 *key, unsigned int key_len)
{
	int rc;
	unsigned int size;
	struct crypto_shash *hash;
	struct sdesc *sdesc;

	hash = crypto_alloc_shash(name, 0, 0);
	if (IS_ERR(hash)) {
		rc = PTR_ERR(hash);
		pr_err("%s: Crypto %s allocation error %d\n", __func__, name, rc);
		return rc;
	}

	size = sizeof(struct shash_desc) + crypto_shash_descsize(hash);
	sdesc = kmalloc(size, GFP_KERNEL);
	if (!sdesc) {
		rc = -ENOMEM;
		goto do_shash_err;
	}
	sdesc->shash.tfm = hash;
	sdesc->shash.flags = 0x0;

	if (key_len > 0) {
		rc = crypto_shash_setkey(hash, key, key_len);
		if (rc) {
			pr_err("%s: Could not setkey %s shash\n", __func__, name);
			goto do_shash_err;
		}
	}

	rc = crypto_shash_init(&sdesc->shash);
	if (rc) {
		pr_err("%s: Could not init %s shash\n", __func__, name);
		goto do_shash_err;
	}
	rc = crypto_shash_update(&sdesc->shash, data1, data1_len);
	if (rc) {
		pr_err("%s: Could not update1\n", __func__);
		goto do_shash_err;
	}
	if (data2 && data2_len) {
		rc = crypto_shash_update(&sdesc->shash, data2, data2_len);
		if (rc) {
			pr_err("%s: Could not update2\n", __func__);
			goto do_shash_err;
		}
	}
	rc = crypto_shash_final(&sdesc->shash, result);
	if (rc)
		pr_err("%s: Could not generate %s hash\n", __func__, name);

do_shash_err:
	crypto_free_shash(hash);
	kfree(sdesc);

	return rc;
}

/* Dump len bytes of a scatterlist starting at skip bytes into the sg */
void __dump_sg(struct scatterlist *sg, unsigned int skip, unsigned int len)
{
	u8 dbuf[16];
	unsigned int idx = skip;
	unsigned int num_out = 0;	/* number of bytes dumped so far */
	unsigned int count;

	if (packet_debug_logging) {
		while (num_out < len) {
			count = (len - num_out > 16) ? 16 : len - num_out;
			sg_copy_part_to_buf(sg, dbuf, count, idx);
			num_out += count;
			print_hex_dump(KERN_ALERT, "  sg: ", DUMP_PREFIX_NONE,
				       4, 1, dbuf, count, false);
			idx += 16;
		}
	}
	if (debug_logging_sleep)
		msleep(debug_logging_sleep);
}

/* Returns the name for a given cipher alg/mode */
char *spu_alg_name(enum spu_cipher_alg alg, enum spu_cipher_mode mode)
{
	switch (alg) {
	case CIPHER_ALG_RC4:
		return "rc4";
	case CIPHER_ALG_AES:
		switch (mode) {
		case CIPHER_MODE_CBC:
			return "cbc(aes)";
		case CIPHER_MODE_ECB:
			return "ecb(aes)";
		case CIPHER_MODE_OFB:
			return "ofb(aes)";
		case CIPHER_MODE_CFB:
			return "cfb(aes)";
		case CIPHER_MODE_CTR:
			return "ctr(aes)";
		case CIPHER_MODE_XTS:
			return "xts(aes)";
		case CIPHER_MODE_GCM:
			return "gcm(aes)";
		default:
			return "aes";
		}
		break;
	case CIPHER_ALG_DES:
		switch (mode) {
		case CIPHER_MODE_CBC:
			return "cbc(des)";
		case CIPHER_MODE_ECB:
			return "ecb(des)";
		case CIPHER_MODE_CTR:
			return "ctr(des)";
		default:
			return "des";
		}
		break;
	case CIPHER_ALG_3DES:
		switch (mode) {
		case CIPHER_MODE_CBC:
			return "cbc(des3_ede)";
		case CIPHER_MODE_ECB:
			return "ecb(des3_ede)";
		case CIPHER_MODE_CTR:
			return "ctr(des3_ede)";
		default:
			return "3des";
		}
		break;
	default:
		return "other";
	}
}

static ssize_t spu_debugfs_read(struct file *filp, char __user *ubuf,
				size_t count, loff_t *offp)
{
	struct device_private *ipriv;
	char *buf;
	ssize_t ret, out_offset, out_count;
	int i;
	u32 fifo_len;
	u32 spu_ofifo_ctrl;
	u32 alg;
	u32 mode;
	u32 op_cnt;

	out_count = 2048;

	buf = kmalloc(out_count, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	ipriv = filp->private_data;
	out_offset = 0;
	out_offset += snprintf(buf + out_offset, out_count - out_offset,
			       "Number of SPUs.........%u\n",
			       ipriv->spu.num_spu);
	out_offset += snprintf(buf + out_offset, out_count - out_offset,
			       "Current sessions.......%u\n",
			       atomic_read(&ipriv->session_count));
	out_offset += snprintf(buf + out_offset, out_count - out_offset,
			       "Session count..........%u\n",
			       atomic_read(&ipriv->stream_count));
	out_offset += snprintf(buf + out_offset, out_count - out_offset,
			       "Cipher setkey..........%u\n",
			       atomic_read(&ipriv->setkey_cnt[SPU_OP_CIPHER]));
	out_offset += snprintf(buf + out_offset, out_count - out_offset,
			       "Cipher Ops.............%u\n",
			       atomic_read(&ipriv->op_counts[SPU_OP_CIPHER]));
	for (alg = 0; alg < CIPHER_ALG_LAST; alg++) {
		for (mode = 0; mode < CIPHER_MODE_LAST; mode++) {
			op_cnt = atomic_read(&ipriv->cipher_cnt[alg][mode]);
			if (op_cnt) {
				out_offset += snprintf(buf + out_offset,
						       out_count - out_offset,
			       "  %-13s%11u\n",
			       spu_alg_name(alg, mode), op_cnt);
			}
		}
	}
	out_offset += snprintf(buf + out_offset, out_count - out_offset,
			       "Hash Ops...............%u\n",
			       atomic_read(&ipriv->op_counts[SPU_OP_HASH]));
	for (alg = 0; alg < HASH_ALG_LAST; alg++) {
		op_cnt = atomic_read(&ipriv->hash_cnt[alg]);
		if (op_cnt) {
			out_offset += snprintf(buf + out_offset,
					       out_count - out_offset,
		       "  %-13s%11u\n",
		       hash_alg_name[alg], op_cnt);
		}
	}
	out_offset += snprintf(buf + out_offset, out_count - out_offset,
			       "HMAC setkey............%u\n",
			       atomic_read(&ipriv->setkey_cnt[SPU_OP_HMAC]));
	out_offset += snprintf(buf + out_offset, out_count - out_offset,
			       "HMAC Ops...............%u\n",
			       atomic_read(&ipriv->op_counts[SPU_OP_HMAC]));
	for (alg = 0; alg < HASH_ALG_LAST; alg++) {
		op_cnt = atomic_read(&ipriv->hmac_cnt[alg]);
		if (op_cnt) {
			out_offset += snprintf(buf + out_offset,
					       out_count - out_offset,
		       "  %-13s%11u\n",
		       hash_alg_name[alg], op_cnt);
		}
	}
	out_offset += snprintf(buf + out_offset, out_count - out_offset,
			       "AEAD setkey............%u\n",
			       atomic_read(&ipriv->setkey_cnt[SPU_OP_AEAD]));

	out_offset += snprintf(buf + out_offset, out_count - out_offset,
			       "AEAD Ops...............%u\n",
			       atomic_read(&ipriv->op_counts[SPU_OP_AEAD]));
	for (alg = 0; alg < AEAD_TYPE_LAST; alg++) {
		op_cnt = atomic_read(&ipriv->aead_cnt[alg]);
		if (op_cnt) {
			out_offset += snprintf(buf + out_offset,
					       out_count - out_offset,
		       "  %-13s%11u\n",
		       aead_alg_name[alg], op_cnt);
		}
	}
	out_offset += snprintf(buf + out_offset, out_count - out_offset,
			       "Bytes of req data......%llu\n",
			       (u64)atomic64_read(&ipriv->bytes_out));
	out_offset += snprintf(buf + out_offset, out_count - out_offset,
			       "Bytes of resp data.....%llu\n",
			       (u64)atomic64_read(&ipriv->bytes_in));
	out_offset += snprintf(buf + out_offset, out_count - out_offset,
			       "Mailbox full...........%u\n",
			       atomic_read(&ipriv->mb_no_spc));
	out_offset += snprintf(buf + out_offset, out_count - out_offset,
			       "Mailbox send failures..%u\n",
			       atomic_read(&ipriv->mb_send_fail));
	out_offset += snprintf(buf + out_offset, out_count - out_offset,
			       "Check ICV errors.......%u\n",
			       atomic_read(&ipriv->bad_icv));
	if (ipriv->spu.spu_type == SPU_TYPE_SPUM)
		for (i = 0; i < ipriv->spu.num_spu; i++) {
			spu_ofifo_ctrl = ioread32(ipriv->spu.reg_vbase[i] +
						  SPU_OFIFO_CTRL);
			fifo_len = spu_ofifo_ctrl & SPU_FIFO_WATERMARK;
			out_offset += snprintf(buf + out_offset,
					       out_count - out_offset,
				       "SPU %d output FIFO high water.....%u\n",
				       i, fifo_len);
		}

	if (out_offset > out_count)
		out_offset = out_count;

	ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset);
	kfree(buf);
	return ret;
}

static const struct file_operations spu_debugfs_stats = {
	.owner = THIS_MODULE,
	.open = simple_open,
	.read = spu_debugfs_read,
};

/*
 * Create the debug FS directories. If the top-level directory has not yet
 * been created, create it now. Create a stats file in this directory for
 * a SPU.
 */
void spu_setup_debugfs(void)
{
	if (!debugfs_initialized())
		return;

	if (!iproc_priv.debugfs_dir)
		iproc_priv.debugfs_dir = debugfs_create_dir(KBUILD_MODNAME,
							    NULL);

	if (!iproc_priv.debugfs_stats)
		/* Create file with permissions S_IRUSR */
		debugfs_create_file("stats", 0400, iproc_priv.debugfs_dir,
				    &iproc_priv, &spu_debugfs_stats);
}

void spu_free_debugfs(void)
{
	debugfs_remove_recursive(iproc_priv.debugfs_dir);
	iproc_priv.debugfs_dir = NULL;
}

/**
 * format_value_ccm() - Format a value into a buffer, using a specified number
 *			of bytes (i.e. maybe writing value X into a 4 byte
 *			buffer, or maybe into a 12 byte buffer), as per the
 *			SPU CCM spec.
 *
 * @val:		value to write (up to max of unsigned int)
 * @buf:		(pointer to) buffer to write the value
 * @len:		number of bytes to use (0 to 255)
 *
 */
void format_value_ccm(unsigned int val, u8 *buf, u8 len)
{
	int i;

	/* First clear full output buffer */
	memset(buf, 0, len);

	/* Then, starting from right side, fill in with data */
	for (i = 0; i < len; i++) {
		buf[len - i - 1] = (val >> (8 * i)) & 0xff;
		if (i >= 3)
			break;  /* Only handle up to 32 bits of 'val' */
	}
}
Commit	Line	Data
9d12ba86 RR	1	/*
	2	* Copyright 2016 Broadcom
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License, version 2, as
	6	* published by the Free Software Foundation (the "GPL").
	7	*
	8	* This program is distributed in the hope that it will be useful, but
	9	* WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	11	* General Public License version 2 (GPLv2) for more details.
	12	*
	13	* You should have received a copy of the GNU General Public License
	14	* version 2 (GPLv2) along with this source code.
	15	*/
	16
	17	#include <linux/debugfs.h>
	18
	19	#include "cipher.h"
	20	#include "util.h"
	21
	22	/* offset of SPU_OFIFO_CTRL register */
	23	#define SPU_OFIFO_CTRL 0x40
	24	#define SPU_FIFO_WATERMARK 0x1FF
	25
	26	/**
	27	* spu_sg_at_offset() - Find the scatterlist entry at a given distance from the
	28	* start of a scatterlist.
	29	* @sg: [in] Start of a scatterlist
	30	* @skip: [in] Distance from the start of the scatterlist, in bytes
	31	* @sge: [out] Scatterlist entry at skip bytes from start
	32	* @sge_offset: [out] Number of bytes from start of sge buffer to get to
	33	* requested distance.
	34	*
	35	* Return: 0 if entry found at requested distance
	36	* < 0 otherwise
	37	*/
	38	int spu_sg_at_offset(struct scatterlist *sg, unsigned int skip,
	39	struct scatterlist *sge, unsigned int sge_offset)
	40	{
	41	/* byte index from start of sg to the end of the previous entry */
	42	unsigned int index = 0;
	43	/* byte index from start of sg to the end of the current entry */
	44	unsigned int next_index;
	45
	46	next_index = sg->length;
	47	while (next_index <= skip) {
	48	sg = sg_next(sg);
	49	index = next_index;
	50	if (!sg)
	51	return -EINVAL;
	52	next_index += sg->length;
	53	}
	54
	55	*sge_offset = skip - index;
	56	*sge = sg;
	57	return 0;
	58	}
	59
	60	/* Copy len bytes of sg data, starting at offset skip, to a dest buffer */
	61	void sg_copy_part_to_buf(struct scatterlist src, u8 dest,
	62	unsigned int len, unsigned int skip)
	63	{
	64	size_t copied;
65	unsigned int nents = sg_nents(src);
66
67	copied = sg_pcopy_to_buffer(src, nents, dest, len, skip);
68	if (copied != len) {
69	flow_log("%s copied %u bytes of %u requested. ",
70	__func__, (u32)copied, len);
71	flow_log("sg with %u entries and skip %u\n", nents, skip);
72	}
73	}
74
75	/*
76	* Copy data into a scatterlist starting at a specified offset in the
77	* scatterlist. Specifically, copy len bytes of data in the buffer src
78	* into the scatterlist dest, starting skip bytes into the scatterlist.
79	*/
80	void sg_copy_part_from_buf(struct scatterlist dest, u8 src,
81	unsigned int len, unsigned int skip)
82	{
83	size_t copied;
84	unsigned int nents = sg_nents(dest);
85
86	copied = sg_pcopy_from_buffer(dest, nents, src, len, skip);
87	if (copied != len) {
88	flow_log("%s copied %u bytes of %u requested. ",
89	__func__, (u32)copied, len);
90	flow_log("sg with %u entries and skip %u\n", nents, skip);
91	}
92	}
93
94	/**
95	* spu_sg_count() - Determine number of elements in scatterlist to provide a
96	* specified number of bytes.
97	* @sg_list: scatterlist to examine
98	* @skip: index of starting point
99	* @nbytes: consider elements of scatterlist until reaching this number of
100	* bytes
101	*
102	* Return: the number of sg entries contributing to nbytes of data
103	*/
104	int spu_sg_count(struct scatterlist *sg_list, unsigned int skip, int nbytes)
105	{
106	struct scatterlist *sg;
107	int sg_nents = 0;
108	unsigned int offset;
109
110	if (!sg_list)
111	return 0;
112
113	if (spu_sg_at_offset(sg_list, skip, &sg, &offset) < 0)
114	return 0;
115
116	while (sg && (nbytes > 0)) {
117	sg_nents++;
118	nbytes -= (sg->length - offset);
119	offset = 0;
120	sg = sg_next(sg);
121	}
122	return sg_nents;
123	}
124
125	/**
126	* spu_msg_sg_add() - Copy scatterlist entries from one sg to another, up to a
127	* given length.
128	* @to_sg: scatterlist to copy to
129	* @from_sg: scatterlist to copy from
130	* @from_skip: number of bytes to skip in from_sg. Non-zero when previous
131	* request included part of the buffer in entry in from_sg.
132	* Assumes from_skip < from_sg->length.
133	* @from_nents number of entries in from_sg
134	* @length number of bytes to copy. may reach this limit before exhausting
135	* from_sg.
136	*
137	* Copies the entries themselves, not the data in the entries. Assumes to_sg has
138	* enough entries. Does not limit the size of an individual buffer in to_sg.
139	*
140	* to_sg, from_sg, skip are all updated to end of copy
141	*
142	* Return: Number of bytes copied
143	*/
144	u32 spu_msg_sg_add(struct scatterlist **to_sg,
145	struct scatterlist *from_sg, u32 from_skip,
146	u8 from_nents, u32 length)
147	{
148	struct scatterlist sg; / an entry in from_sg */
149	struct scatterlist to = to_sg;
150	struct scatterlist from = from_sg;
151	u32 skip = *from_skip;
152	u32 offset;
153	int i;
154	u32 entry_len = 0;
155	u32 frag_len = 0; /* length of entry added to to_sg */
156	u32 copied = 0; /* number of bytes copied so far */
157
158	if (length == 0)
159	return 0;
160
161	for_each_sg(from, sg, from_nents, i) {
162	/* number of bytes in this from entry not yet used */
163	entry_len = sg->length - skip;
164	frag_len = min(entry_len, length - copied);
165	offset = sg->offset + skip;
166	if (frag_len)
167	sg_set_page(to++, sg_page(sg), frag_len, offset);
168	copied += frag_len;
169	if (copied == entry_len) {
170	/* used up all of from entry */
171	skip = 0; /* start at beginning of next entry */
172	}
173	if (copied == length)
174	break;
175	}
176	*to_sg = to;
177	*from_sg = sg;
178	if (frag_len < entry_len)
179	*from_skip = skip + frag_len;
180	else
181	*from_skip = 0;
182
183	return copied;
184	}
185
186	void add_to_ctr(u8 *ctr_pos, unsigned int increment)
187	{
188	__be64 high_be = (__be64 )ctr_pos;
189	__be64 *low_be = high_be + 1;
190	u64 orig_low = __be64_to_cpu(*low_be);
191	u64 new_low = orig_low + (u64)increment;
192
193	*low_be = __cpu_to_be64(new_low);
194	if (new_low < orig_low)
195	/* there was a carry from the low 8 bytes */
196	high_be = __cpu_to_be64(__be64_to_cpu(high_be) + 1);
197	}
198
199	struct sdesc {
200	struct shash_desc shash;
201	char ctx[];
202	};
203
204	/* do a synchronous decrypt operation */
205	int do_decrypt(char *alg_name,
206	void *key_ptr, unsigned int key_len,
207	void iv_ptr, void src_ptr, void *dst_ptr,
208	unsigned int block_len)
209	{
210	struct scatterlist sg_in[1], sg_out[1];
211	struct crypto_blkcipher *tfm =
212	crypto_alloc_blkcipher(alg_name, 0, CRYPTO_ALG_ASYNC);
213	struct blkcipher_desc desc = {.tfm = tfm, .flags = 0 };
214	int ret = 0;
215	void *iv;
216	int ivsize;
217
218	flow_log("%s() name:%s block_len:%u\n", __func__, alg_name, block_len);
219
220	if (IS_ERR(tfm))
221	return PTR_ERR(tfm);
222
223	crypto_blkcipher_setkey((void *)tfm, key_ptr, key_len);
224
225	sg_init_table(sg_in, 1);
226	sg_set_buf(sg_in, src_ptr, block_len);
227
228	sg_init_table(sg_out, 1);
229	sg_set_buf(sg_out, dst_ptr, block_len);
230
231	iv = crypto_blkcipher_crt(tfm)->iv;
232	ivsize = crypto_blkcipher_ivsize(tfm);
233	memcpy(iv, iv_ptr, ivsize);
234
235	ret = crypto_blkcipher_decrypt(&desc, sg_out, sg_in, block_len);
236	crypto_free_blkcipher(tfm);
237
238	if (ret < 0)
239	pr_err("aes_decrypt failed %d\n", ret);
240
241	return ret;
242	}
243
244	/**
245	* do_shash() - Do a synchronous hash operation in software
246	* @name: The name of the hash algorithm
247	* @result: Buffer where digest is to be written
248	* @data1: First part of data to hash. May be NULL.
249	* @data1_len: Length of data1, in bytes
250	* @data2: Second part of data to hash. May be NULL.
251	* @data2_len: Length of data2, in bytes
252	* @key: Key (if keyed hash)
253	* @key_len: Length of key, in bytes (or 0 if non-keyed hash)
254	*
255	* Note that the crypto API will not select this driver's own transform because
256	* this driver only registers asynchronous algos.
257	*
258	* Return: 0 if hash successfully stored in result
259	* < 0 otherwise
260	*/
261	int do_shash(unsigned char name, unsigned char result,
262	const u8 *data1, unsigned int data1_len,
263	const u8 *data2, unsigned int data2_len,
264	const u8 *key, unsigned int key_len)
265	{
266	int rc;
267	unsigned int size;
268	struct crypto_shash *hash;
269	struct sdesc *sdesc;
270
271	hash = crypto_alloc_shash(name, 0, 0);
272	if (IS_ERR(hash)) {
273	rc = PTR_ERR(hash);
924c9e36	274	pr_err("%s: Crypto %s allocation error %d\n", __func__, name, rc);
9d12ba86 RR	275	return rc;
	276	}
	277
	278	size = sizeof(struct shash_desc) + crypto_shash_descsize(hash);
	279	sdesc = kmalloc(size, GFP_KERNEL);
	280	if (!sdesc) {
	281	rc = -ENOMEM;
9d12ba86 RR	282	goto do_shash_err;
	283	}
	284	sdesc->shash.tfm = hash;
	285	sdesc->shash.flags = 0x0;
	286
	287	if (key_len > 0) {
	288	rc = crypto_shash_setkey(hash, key, key_len);
	289	if (rc) {
924c9e36	290	pr_err("%s: Could not setkey %s shash\n", __func__, name);
9d12ba86 RR	291	goto do_shash_err;
	292	}
	293	}
	294
	295	rc = crypto_shash_init(&sdesc->shash);
	296	if (rc) {
924c9e36	297	pr_err("%s: Could not init %s shash\n", __func__, name);
9d12ba86 RR	298	goto do_shash_err;
	299	}
	300	rc = crypto_shash_update(&sdesc->shash, data1, data1_len);
	301	if (rc) {
924c9e36	302	pr_err("%s: Could not update1\n", __func__);
9d12ba86 RR	303	goto do_shash_err;
	304	}
	305	if (data2 && data2_len) {
	306	rc = crypto_shash_update(&sdesc->shash, data2, data2_len);
	307	if (rc) {
924c9e36	308	pr_err("%s: Could not update2\n", __func__);
9d12ba86 RR	309	goto do_shash_err;
	310	}
	311	}
	312	rc = crypto_shash_final(&sdesc->shash, result);
	313	if (rc)
924c9e36	314	pr_err("%s: Could not generate %s hash\n", __func__, name);
9d12ba86 RR	315
	316	do_shash_err:
	317	crypto_free_shash(hash);
	318	kfree(sdesc);
	319
	320	return rc;
	321	}
	322
	323	/* Dump len bytes of a scatterlist starting at skip bytes into the sg */
	324	void __dump_sg(struct scatterlist *sg, unsigned int skip, unsigned int len)
	325	{
	326	u8 dbuf[16];
	327	unsigned int idx = skip;
	328	unsigned int num_out = 0; /* number of bytes dumped so far */
	329	unsigned int count;
	330
	331	if (packet_debug_logging) {
	332	while (num_out < len) {
	333	count = (len - num_out > 16) ? 16 : len - num_out;
	334	sg_copy_part_to_buf(sg, dbuf, count, idx);
	335	num_out += count;
	336	print_hex_dump(KERN_ALERT, " sg: ", DUMP_PREFIX_NONE,
	337	4, 1, dbuf, count, false);
	338	idx += 16;
	339	}
	340	}
	341	if (debug_logging_sleep)
	342	msleep(debug_logging_sleep);
	343	}
	344
	345	/* Returns the name for a given cipher alg/mode */
	346	char *spu_alg_name(enum spu_cipher_alg alg, enum spu_cipher_mode mode)
	347	{
	348	switch (alg) {
	349	case CIPHER_ALG_RC4:
	350	return "rc4";
	351	case CIPHER_ALG_AES:
	352	switch (mode) {
	353	case CIPHER_MODE_CBC:
	354	return "cbc(aes)";
	355	case CIPHER_MODE_ECB:
	356	return "ecb(aes)";
	357	case CIPHER_MODE_OFB:
	358	return "ofb(aes)";
	359	case CIPHER_MODE_CFB:
	360	return "cfb(aes)";
	361	case CIPHER_MODE_CTR:
	362	return "ctr(aes)";
	363	case CIPHER_MODE_XTS:
	364	return "xts(aes)";
	365	case CIPHER_MODE_GCM:
	366	return "gcm(aes)";
	367	default:
	368	return "aes";
	369	}
	370	break;
	371	case CIPHER_ALG_DES:
	372	switch (mode) {
	373	case CIPHER_MODE_CBC:
	374	return "cbc(des)";
	375	case CIPHER_MODE_ECB:
	376	return "ecb(des)";
	377	case CIPHER_MODE_CTR:
	378	return "ctr(des)";
379	default:
380	return "des";
381	}
382	break;
383	case CIPHER_ALG_3DES:
384	switch (mode) {
385	case CIPHER_MODE_CBC:
386	return "cbc(des3_ede)";
387	case CIPHER_MODE_ECB:
388	return "ecb(des3_ede)";
389	case CIPHER_MODE_CTR:
390	return "ctr(des3_ede)";
391	default:
392	return "3des";
393	}
394	break;
395	default:
396	return "other";
397	}
398	}
399
400	static ssize_t spu_debugfs_read(struct file filp, char __user ubuf,
401	size_t count, loff_t *offp)
402	{
403	struct device_private *ipriv;
404	char *buf;
405	ssize_t ret, out_offset, out_count;
406	int i;
407	u32 fifo_len;
408	u32 spu_ofifo_ctrl;
409	u32 alg;
410	u32 mode;
411	u32 op_cnt;
412
413	out_count = 2048;
414
415	buf = kmalloc(out_count, GFP_KERNEL);
416	if (!buf)
417	return -ENOMEM;
418
419	ipriv = filp->private_data;
420	out_offset = 0;
421	out_offset += snprintf(buf + out_offset, out_count - out_offset,
422	"Number of SPUs.........%u\n",
423	ipriv->spu.num_spu);
424	out_offset += snprintf(buf + out_offset, out_count - out_offset,
425	"Current sessions.......%u\n",
426	atomic_read(&ipriv->session_count));
427	out_offset += snprintf(buf + out_offset, out_count - out_offset,
428	"Session count..........%u\n",
429	atomic_read(&ipriv->stream_count));
430	out_offset += snprintf(buf + out_offset, out_count - out_offset,
431	"Cipher setkey..........%u\n",
432	atomic_read(&ipriv->setkey_cnt[SPU_OP_CIPHER]));
433	out_offset += snprintf(buf + out_offset, out_count - out_offset,
434	"Cipher Ops.............%u\n",
435	atomic_read(&ipriv->op_counts[SPU_OP_CIPHER]));
436	for (alg = 0; alg < CIPHER_ALG_LAST; alg++) {
437	for (mode = 0; mode < CIPHER_MODE_LAST; mode++) {
438	op_cnt = atomic_read(&ipriv->cipher_cnt[alg][mode]);
439	if (op_cnt) {
440	out_offset += snprintf(buf + out_offset,
441	out_count - out_offset,
442	" %-13s%11u\n",
443	spu_alg_name(alg, mode), op_cnt);
444	}
445	}
446	}
447	out_offset += snprintf(buf + out_offset, out_count - out_offset,
448	"Hash Ops...............%u\n",
449	atomic_read(&ipriv->op_counts[SPU_OP_HASH]));
450	for (alg = 0; alg < HASH_ALG_LAST; alg++) {
451	op_cnt = atomic_read(&ipriv->hash_cnt[alg]);
452	if (op_cnt) {
453	out_offset += snprintf(buf + out_offset,
454	out_count - out_offset,
455	" %-13s%11u\n",
456	hash_alg_name[alg], op_cnt);
457	}
458	}
459	out_offset += snprintf(buf + out_offset, out_count - out_offset,
460	"HMAC setkey............%u\n",
461	atomic_read(&ipriv->setkey_cnt[SPU_OP_HMAC]));
462	out_offset += snprintf(buf + out_offset, out_count - out_offset,
463	"HMAC Ops...............%u\n",
464	atomic_read(&ipriv->op_counts[SPU_OP_HMAC]));
465	for (alg = 0; alg < HASH_ALG_LAST; alg++) {
466	op_cnt = atomic_read(&ipriv->hmac_cnt[alg]);
467	if (op_cnt) {
468	out_offset += snprintf(buf + out_offset,
469	out_count - out_offset,
470	" %-13s%11u\n",
471	hash_alg_name[alg], op_cnt);
472	}
473	}
474	out_offset += snprintf(buf + out_offset, out_count - out_offset,
475	"AEAD setkey............%u\n",
476	atomic_read(&ipriv->setkey_cnt[SPU_OP_AEAD]));
477
478	out_offset += snprintf(buf + out_offset, out_count - out_offset,
479	"AEAD Ops...............%u\n",
480	atomic_read(&ipriv->op_counts[SPU_OP_AEAD]));
481	for (alg = 0; alg < AEAD_TYPE_LAST; alg++) {
482	op_cnt = atomic_read(&ipriv->aead_cnt[alg]);
483	if (op_cnt) {
484	out_offset += snprintf(buf + out_offset,
485	out_count - out_offset,
486	" %-13s%11u\n",
487	aead_alg_name[alg], op_cnt);
488	}
489	}
490	out_offset += snprintf(buf + out_offset, out_count - out_offset,
491	"Bytes of req data......%llu\n",
492	(u64)atomic64_read(&ipriv->bytes_out));
493	out_offset += snprintf(buf + out_offset, out_count - out_offset,
494	"Bytes of resp data.....%llu\n",
495	(u64)atomic64_read(&ipriv->bytes_in));
496	out_offset += snprintf(buf + out_offset, out_count - out_offset,
497	"Mailbox full...........%u\n",
498	atomic_read(&ipriv->mb_no_spc));
499	out_offset += snprintf(buf + out_offset, out_count - out_offset,
500	"Mailbox send failures..%u\n",
501	atomic_read(&ipriv->mb_send_fail));
502	out_offset += snprintf(buf + out_offset, out_count - out_offset,
503	"Check ICV errors.......%u\n",
504	atomic_read(&ipriv->bad_icv));
505	if (ipriv->spu.spu_type == SPU_TYPE_SPUM)
506	for (i = 0; i < ipriv->spu.num_spu; i++) {
507	spu_ofifo_ctrl = ioread32(ipriv->spu.reg_vbase[i] +
508	SPU_OFIFO_CTRL);
509	fifo_len = spu_ofifo_ctrl & SPU_FIFO_WATERMARK;
510	out_offset += snprintf(buf + out_offset,
511	out_count - out_offset,
512	"SPU %d output FIFO high water.....%u\n",
513	i, fifo_len);
514	}
515
516	if (out_offset > out_count)
517	out_offset = out_count;
518
519	ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset);
520	kfree(buf);
521	return ret;
522	}
523
524	static const struct file_operations spu_debugfs_stats = {
525	.owner = THIS_MODULE,
526	.open = simple_open,
527	.read = spu_debugfs_read,
528	};
529
530	/*
531	* Create the debug FS directories. If the top-level directory has not yet
532	* been created, create it now. Create a stats file in this directory for
533	* a SPU.
534	*/
535	void spu_setup_debugfs(void)
536	{
537	if (!debugfs_initialized())
538	return;
539
540	if (!iproc_priv.debugfs_dir)
541	iproc_priv.debugfs_dir = debugfs_create_dir(KBUILD_MODNAME,
542	NULL);
543
544	if (!iproc_priv.debugfs_stats)
545	/* Create file with permissions S_IRUSR */
546	debugfs_create_file("stats", 0400, iproc_priv.debugfs_dir,
547	&iproc_priv, &spu_debugfs_stats);
548	}
549
550	void spu_free_debugfs(void)
551	{
552	debugfs_remove_recursive(iproc_priv.debugfs_dir);
553	iproc_priv.debugfs_dir = NULL;
554	}
555
556	/**
557	* format_value_ccm() - Format a value into a buffer, using a specified number
558	* of bytes (i.e. maybe writing value X into a 4 byte
559	* buffer, or maybe into a 12 byte buffer), as per the
560	* SPU CCM spec.
561	*
562	* @val: value to write (up to max of unsigned int)
563	* @buf: (pointer to) buffer to write the value
564	* @len: number of bytes to use (0 to 255)
565	*
566	*/
567	void format_value_ccm(unsigned int val, u8 *buf, u8 len)
568	{
569	int i;
570
571	/* First clear full output buffer */
572	memset(buf, 0, len);
573
574	/* Then, starting from right side, fill in with data */
575	for (i = 0; i < len; i++) {
576	buf[len - i - 1] = (val >> (8 * i)) & 0xff;
577	if (i >= 3)
578	break; /* Only handle up to 32 bits of 'val' */
579	}
580	}