~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,3 +1,4 @@
	1	+// SPDX-License-Identifier: GPL-2.0-or-later
1	2	/*
2	3	* talitos - Freescale Integrated Security Engine (SEC) device driver
3	4	*
..	..	@@ -9,20 +10,6 @@
9	10	* Crypto algorithm registration code copied from hifn driver:
10	11	* 2007+ Copyright (c) Evgeniy Polyakov <johnpol@2ka.mipt.ru>
11	12	* All rights reserved.
12		- *
13		- * This program is free software; you can redistribute it and/or modify
14		- * it under the terms of the GNU General Public License as published by
15		- * the Free Software Foundation; either version 2 of the License, or
16		- * (at your option) any later version.
17		- *
18		- * This program is distributed in the hope that it will be useful,
19		- * but WITHOUT ANY WARRANTY; without even the implied warranty of
20		- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21		- * GNU General Public License for more details.
22		- *
23		- * You should have received a copy of the GNU General Public License
24		- * along with this program; if not, write to the Free Software
25		- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26	13	*/
27	14
28	15	#include <linux/kernel.h>
..	..	@@ -43,12 +30,12 @@
43	30
44	31	#include <crypto/algapi.h>
45	32	#include <crypto/aes.h>
46		-#include <crypto/des.h>
	33	+#include <crypto/internal/des.h>
47	34	#include <crypto/sha.h>
48	35	#include <crypto/md5.h>
49	36	#include <crypto/internal/aead.h>
50	37	#include <crypto/authenc.h>
51		-#include <crypto/skcipher.h>
	38	+#include <crypto/internal/skcipher.h>
52	39	#include <crypto/hash.h>
53	40	#include <crypto/internal/hash.h>
54	41	#include <crypto/scatterwalk.h>
..	..	@@ -278,11 +265,11 @@
278	265	* callback must check err and feedback in descriptor header
279	266	* for device processing status.
280	267	*/
281		-int talitos_submit(struct device dev, int ch, struct talitos_desc desc,
282		- void (callback)(struct device dev,
283		- struct talitos_desc *desc,
284		- void *context, int error),
285		- void *context)
	268	+static int talitos_submit(struct device dev, int ch, struct talitos_desc desc,
	269	+ void (callback)(struct device dev,
	270	+ struct talitos_desc *desc,
	271	+ void *context, int error),
	272	+ void *context)
286	273	{
287	274	struct talitos_private *priv = dev_get_drvdata(dev);
288	275	struct talitos_request *request;
..	..	@@ -332,7 +319,6 @@
332	319
333	320	return -EINPROGRESS;
334	321	}
335		-EXPORT_SYMBOL(talitos_submit);
336	322
337	323	static __be32 get_request_hdr(struct talitos_request *request, bool is_sec1)
338	324	{
..	..	@@ -820,10 +806,10 @@
820	806	struct talitos_private *priv = dev_get_drvdata(dev);
821	807	int err;
822	808
823		- priv->rng.name = dev_driver_string(dev),
824		- priv->rng.init = talitos_rng_init,
825		- priv->rng.data_present = talitos_rng_data_present,
826		- priv->rng.data_read = talitos_rng_data_read,
	809	+ priv->rng.name = dev_driver_string(dev);
	810	+ priv->rng.init = talitos_rng_init;
	811	+ priv->rng.data_present = talitos_rng_data_present;
	812	+ priv->rng.data_read = talitos_rng_data_read;
827	813	priv->rng.priv = (unsigned long)dev;
828	814
829	815	err = hwrng_register(&priv->rng);
..	..	@@ -928,9 +914,45 @@
928	914	return 0;
929	915
930	916	badkey:
931		- crypto_aead_set_flags(authenc, CRYPTO_TFM_RES_BAD_KEY_LEN);
932	917	memzero_explicit(&keys, sizeof(keys));
933	918	return -EINVAL;
	919	+}
	920	+
	921	+static int aead_des3_setkey(struct crypto_aead *authenc,
	922	+ const u8 *key, unsigned int keylen)
	923	+{
	924	+ struct talitos_ctx *ctx = crypto_aead_ctx(authenc);
	925	+ struct device *dev = ctx->dev;
	926	+ struct crypto_authenc_keys keys;
	927	+ int err;
	928	+
	929	+ err = crypto_authenc_extractkeys(&keys, key, keylen);
	930	+ if (unlikely(err))
	931	+ goto out;
	932	+
	933	+ err = -EINVAL;
	934	+ if (keys.authkeylen + keys.enckeylen > TALITOS_MAX_KEY_SIZE)
	935	+ goto out;
	936	+
	937	+ err = verify_aead_des3_key(authenc, keys.enckey, keys.enckeylen);
	938	+ if (err)
	939	+ goto out;
	940	+
	941	+ if (ctx->keylen)
	942	+ dma_unmap_single(dev, ctx->dma_key, ctx->keylen, DMA_TO_DEVICE);
	943	+
	944	+ memcpy(ctx->key, keys.authkey, keys.authkeylen);
	945	+ memcpy(&ctx->key[keys.authkeylen], keys.enckey, keys.enckeylen);
	946	+
	947	+ ctx->keylen = keys.authkeylen + keys.enckeylen;
	948	+ ctx->enckeylen = keys.enckeylen;
	949	+ ctx->authkeylen = keys.authkeylen;
	950	+ ctx->dma_key = dma_map_single(dev, ctx->key, ctx->keylen,
	951	+ DMA_TO_DEVICE);
	952	+
	953	+out:
	954	+ memzero_explicit(&keys, sizeof(keys));
	955	+ return err;
934	956	}
935	957
936	958	static void talitos_sg_unmap(struct device *dev,
..	..	@@ -1253,9 +1275,6 @@
1253	1275	is_ipsec_esp && !encrypt, 1);
1254	1276	tbl_off += ret;
1255	1277
1256		- /* ICV data */
1257		- edesc->icv_ool = !encrypt;
1258		-
1259	1278	if (!encrypt && is_ipsec_esp) {
1260	1279	struct talitos_ptr *tbl_ptr = &edesc->link_tbl[tbl_off];
1261	1280
..	..	@@ -1468,24 +1487,11 @@
1468	1487	return ipsec_esp(edesc, req, false, ipsec_esp_decrypt_swauth_done);
1469	1488	}
1470	1489
1471		-static int ablkcipher_setkey(struct crypto_ablkcipher *cipher,
	1490	+static int skcipher_setkey(struct crypto_skcipher *cipher,
1472	1491	const u8 *key, unsigned int keylen)
1473	1492	{
1474		- struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher);
	1493	+ struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher);
1475	1494	struct device *dev = ctx->dev;
1476		- u32 tmp[DES_EXPKEY_WORDS];
1477		-
1478		- if (keylen > TALITOS_MAX_KEY_SIZE) {
1479		- crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
1480		- return -EINVAL;
1481		- }
1482		-
1483		- if (unlikely(crypto_ablkcipher_get_flags(cipher) &
1484		- CRYPTO_TFM_REQ_WEAK_KEY) &&
1485		- !des_ekey(tmp, key)) {
1486		- crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_WEAK_KEY);
1487		- return -EINVAL;
1488		- }
1489	1495
1490	1496	if (ctx->keylen)
1491	1497	dma_unmap_single(dev, ctx->dma_key, ctx->keylen, DMA_TO_DEVICE);
..	..	@@ -1498,25 +1504,37 @@
1498	1504	return 0;
1499	1505	}
1500	1506
1501		-static int ablkcipher_aes_setkey(struct crypto_ablkcipher *cipher,
	1507	+static int skcipher_des_setkey(struct crypto_skcipher *cipher,
	1508	+ const u8 *key, unsigned int keylen)
	1509	+{
	1510	+ return verify_skcipher_des_key(cipher, key) ?:
	1511	+ skcipher_setkey(cipher, key, keylen);
	1512	+}
	1513	+
	1514	+static int skcipher_des3_setkey(struct crypto_skcipher *cipher,
	1515	+ const u8 *key, unsigned int keylen)
	1516	+{
	1517	+ return verify_skcipher_des3_key(cipher, key) ?:
	1518	+ skcipher_setkey(cipher, key, keylen);
	1519	+}
	1520	+
	1521	+static int skcipher_aes_setkey(struct crypto_skcipher *cipher,
1502	1522	const u8 *key, unsigned int keylen)
1503	1523	{
1504	1524	if (keylen == AES_KEYSIZE_128 \|\| keylen == AES_KEYSIZE_192 \|\|
1505	1525	keylen == AES_KEYSIZE_256)
1506		- return ablkcipher_setkey(cipher, key, keylen);
1507		-
1508		- crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
	1526	+ return skcipher_setkey(cipher, key, keylen);
1509	1527
1510	1528	return -EINVAL;
1511	1529	}
1512	1530
1513	1531	static void common_nonsnoop_unmap(struct device *dev,
1514	1532	struct talitos_edesc *edesc,
1515		- struct ablkcipher_request *areq)
	1533	+ struct skcipher_request *areq)
1516	1534	{
1517	1535	unmap_single_talitos_ptr(dev, &edesc->desc.ptr[5], DMA_FROM_DEVICE);
1518	1536
1519		- talitos_sg_unmap(dev, edesc, areq->src, areq->dst, areq->nbytes, 0);
	1537	+ talitos_sg_unmap(dev, edesc, areq->src, areq->dst, areq->cryptlen, 0);
1520	1538	unmap_single_talitos_ptr(dev, &edesc->desc.ptr[1], DMA_TO_DEVICE);
1521	1539
1522	1540	if (edesc->dma_len)
..	..	@@ -1524,20 +1542,20 @@
1524	1542	DMA_BIDIRECTIONAL);
1525	1543	}
1526	1544
1527		-static void ablkcipher_done(struct device *dev,
	1545	+static void skcipher_done(struct device *dev,
1528	1546	struct talitos_desc desc, void context,
1529	1547	int err)
1530	1548	{
1531		- struct ablkcipher_request *areq = context;
1532		- struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq);
1533		- struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher);
1534		- unsigned int ivsize = crypto_ablkcipher_ivsize(cipher);
	1549	+ struct skcipher_request *areq = context;
	1550	+ struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq);
	1551	+ struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher);
	1552	+ unsigned int ivsize = crypto_skcipher_ivsize(cipher);
1535	1553	struct talitos_edesc *edesc;
1536	1554
1537	1555	edesc = container_of(desc, struct talitos_edesc, desc);
1538	1556
1539	1557	common_nonsnoop_unmap(dev, edesc, areq);
1540		- memcpy(areq->info, ctx->iv, ivsize);
	1558	+ memcpy(areq->iv, ctx->iv, ivsize);
1541	1559
1542	1560	kfree(edesc);
1543	1561
..	..	@@ -1545,17 +1563,17 @@
1545	1563	}
1546	1564
1547	1565	static int common_nonsnoop(struct talitos_edesc *edesc,
1548		- struct ablkcipher_request *areq,
	1566	+ struct skcipher_request *areq,
1549	1567	void (callback) (struct device dev,
1550	1568	struct talitos_desc *desc,
1551	1569	void *context, int error))
1552	1570	{
1553		- struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq);
1554		- struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher);
	1571	+ struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq);
	1572	+ struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher);
1555	1573	struct device *dev = ctx->dev;
1556	1574	struct talitos_desc *desc = &edesc->desc;
1557		- unsigned int cryptlen = areq->nbytes;
1558		- unsigned int ivsize = crypto_ablkcipher_ivsize(cipher);
	1575	+ unsigned int cryptlen = areq->cryptlen;
	1576	+ unsigned int ivsize = crypto_skcipher_ivsize(cipher);
1559	1577	int sg_count, ret;
1560	1578	bool sync_needed = false;
1561	1579	struct talitos_private *priv = dev_get_drvdata(dev);
..	..	@@ -1617,65 +1635,65 @@
1617	1635	return ret;
1618	1636	}
1619	1637
1620		-static struct talitos_edesc ablkcipher_edesc_alloc(struct ablkcipher_request
	1638	+static struct talitos_edesc skcipher_edesc_alloc(struct skcipher_request
1621	1639	areq, bool encrypt)
1622	1640	{
1623		- struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq);
1624		- struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher);
1625		- unsigned int ivsize = crypto_ablkcipher_ivsize(cipher);
	1641	+ struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq);
	1642	+ struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher);
	1643	+ unsigned int ivsize = crypto_skcipher_ivsize(cipher);
1626	1644
1627	1645	return talitos_edesc_alloc(ctx->dev, areq->src, areq->dst,
1628		- areq->info, 0, areq->nbytes, 0, ivsize, 0,
	1646	+ areq->iv, 0, areq->cryptlen, 0, ivsize, 0,
1629	1647	areq->base.flags, encrypt);
1630	1648	}
1631	1649
1632		-static int ablkcipher_encrypt(struct ablkcipher_request *areq)
	1650	+static int skcipher_encrypt(struct skcipher_request *areq)
1633	1651	{
1634		- struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq);
1635		- struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher);
	1652	+ struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq);
	1653	+ struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher);
1636	1654	struct talitos_edesc *edesc;
1637	1655	unsigned int blocksize =
1638		- crypto_tfm_alg_blocksize(crypto_ablkcipher_tfm(cipher));
	1656	+ crypto_tfm_alg_blocksize(crypto_skcipher_tfm(cipher));
1639	1657
1640		- if (!areq->nbytes)
	1658	+ if (!areq->cryptlen)
1641	1659	return 0;
1642	1660
1643		- if (areq->nbytes % blocksize)
	1661	+ if (areq->cryptlen % blocksize)
1644	1662	return -EINVAL;
1645	1663
1646	1664	/* allocate extended descriptor */
1647		- edesc = ablkcipher_edesc_alloc(areq, true);
	1665	+ edesc = skcipher_edesc_alloc(areq, true);
1648	1666	if (IS_ERR(edesc))
1649	1667	return PTR_ERR(edesc);
1650	1668
1651	1669	/* set encrypt */
1652	1670	edesc->desc.hdr = ctx->desc_hdr_template \| DESC_HDR_MODE0_ENCRYPT;
1653	1671
1654		- return common_nonsnoop(edesc, areq, ablkcipher_done);
	1672	+ return common_nonsnoop(edesc, areq, skcipher_done);
1655	1673	}
1656	1674
1657		-static int ablkcipher_decrypt(struct ablkcipher_request *areq)
	1675	+static int skcipher_decrypt(struct skcipher_request *areq)
1658	1676	{
1659		- struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq);
1660		- struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher);
	1677	+ struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq);
	1678	+ struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher);
1661	1679	struct talitos_edesc *edesc;
1662	1680	unsigned int blocksize =
1663		- crypto_tfm_alg_blocksize(crypto_ablkcipher_tfm(cipher));
	1681	+ crypto_tfm_alg_blocksize(crypto_skcipher_tfm(cipher));
1664	1682
1665		- if (!areq->nbytes)
	1683	+ if (!areq->cryptlen)
1666	1684	return 0;
1667	1685
1668		- if (areq->nbytes % blocksize)
	1686	+ if (areq->cryptlen % blocksize)
1669	1687	return -EINVAL;
1670	1688
1671	1689	/* allocate extended descriptor */
1672		- edesc = ablkcipher_edesc_alloc(areq, false);
	1690	+ edesc = skcipher_edesc_alloc(areq, false);
1673	1691	if (IS_ERR(edesc))
1674	1692	return PTR_ERR(edesc);
1675	1693
1676	1694	edesc->desc.hdr = ctx->desc_hdr_template \| DESC_HDR_DIR_INBOUND;
1677	1695
1678		- return common_nonsnoop(edesc, areq, ablkcipher_done);
	1696	+ return common_nonsnoop(edesc, areq, skcipher_done);
1679	1697	}
1680	1698
1681	1699	static void common_nonsnoop_hash_unmap(struct device *dev,
..	..	@@ -1683,6 +1701,7 @@
1683	1701	struct ahash_request *areq)
1684	1702	{
1685	1703	struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq);
	1704	+ struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq);
1686	1705	struct talitos_private *priv = dev_get_drvdata(dev);
1687	1706	bool is_sec1 = has_ftr_sec1(priv);
1688	1707	struct talitos_desc *desc = &edesc->desc;
..	..	@@ -1693,6 +1712,9 @@
1693	1712	if (desc->next_desc &&
1694	1713	desc->ptr[5].ptr != desc2->ptr[5].ptr)
1695	1714	unmap_single_talitos_ptr(dev, &desc2->ptr[5], DMA_FROM_DEVICE);
	1715	+ if (req_ctx->last)
	1716	+ memcpy(areq->result, req_ctx->hw_context,
	1717	+ crypto_ahash_digestsize(tfm));
1696	1718
1697	1719	if (req_ctx->psrc)
1698	1720	talitos_sg_unmap(dev, edesc, req_ctx->psrc, NULL, 0, 0);
..	..	@@ -1824,7 +1846,7 @@
1824	1846	if (req_ctx->last)
1825	1847	map_single_talitos_ptr(dev, &desc->ptr[5],
1826	1848	crypto_ahash_digestsize(tfm),
1827		- areq->result, DMA_FROM_DEVICE);
	1849	+ req_ctx->hw_context, DMA_FROM_DEVICE);
1828	1850	else
1829	1851	map_single_talitos_ptr_nosync(dev, &desc->ptr[5],
1830	1852	req_ctx->hw_context_size,
..	..	@@ -2209,10 +2231,8 @@
2209	2231	/* Must get the hash of the long key */
2210	2232	ret = keyhash(tfm, key, keylen, hash);
2211	2233
2212		- if (ret) {
2213		- crypto_ahash_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
	2234	+ if (ret)
2214	2235	return -EINVAL;
2215		- }
2216	2236
2217	2237	keysize = digestsize;
2218	2238	memcpy(ctx->key, hash, digestsize);
..	..	@@ -2232,7 +2252,7 @@
2232	2252	u32 type;
2233	2253	u32 priority;
2234	2254	union {
2235		- struct crypto_alg crypto;
	2255	+ struct skcipher_alg skcipher;
2236	2256	struct ahash_alg hash;
2237	2257	struct aead_alg aead;
2238	2258	} alg;
..	..	@@ -2248,7 +2268,8 @@
2248	2268	.cra_driver_name = "authenc-hmac-sha1-"
2249	2269	"cbc-aes-talitos",
2250	2270	.cra_blocksize = AES_BLOCK_SIZE,
2251		- .cra_flags = CRYPTO_ALG_ASYNC,
	2271	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2272	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2252	2273	},
2253	2274	.ivsize = AES_BLOCK_SIZE,
2254	2275	.maxauthsize = SHA1_DIGEST_SIZE,
..	..	@@ -2269,7 +2290,8 @@
2269	2290	.cra_driver_name = "authenc-hmac-sha1-"
2270	2291	"cbc-aes-talitos-hsna",
2271	2292	.cra_blocksize = AES_BLOCK_SIZE,
2272		- .cra_flags = CRYPTO_ALG_ASYNC,
	2293	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2294	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2273	2295	},
2274	2296	.ivsize = AES_BLOCK_SIZE,
2275	2297	.maxauthsize = SHA1_DIGEST_SIZE,
..	..	@@ -2290,10 +2312,12 @@
2290	2312	.cra_driver_name = "authenc-hmac-sha1-"
2291	2313	"cbc-3des-talitos",
2292	2314	.cra_blocksize = DES3_EDE_BLOCK_SIZE,
2293		- .cra_flags = CRYPTO_ALG_ASYNC,
	2315	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2316	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2294	2317	},
2295	2318	.ivsize = DES3_EDE_BLOCK_SIZE,
2296	2319	.maxauthsize = SHA1_DIGEST_SIZE,
	2320	+ .setkey = aead_des3_setkey,
2297	2321	},
2298	2322	.desc_hdr_template = DESC_HDR_TYPE_IPSEC_ESP \|
2299	2323	DESC_HDR_SEL0_DEU \|
..	..	@@ -2313,10 +2337,12 @@
2313	2337	.cra_driver_name = "authenc-hmac-sha1-"
2314	2338	"cbc-3des-talitos-hsna",
2315	2339	.cra_blocksize = DES3_EDE_BLOCK_SIZE,
2316		- .cra_flags = CRYPTO_ALG_ASYNC,
	2340	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2341	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2317	2342	},
2318	2343	.ivsize = DES3_EDE_BLOCK_SIZE,
2319	2344	.maxauthsize = SHA1_DIGEST_SIZE,
	2345	+ .setkey = aead_des3_setkey,
2320	2346	},
2321	2347	.desc_hdr_template = DESC_HDR_TYPE_HMAC_SNOOP_NO_AFEU \|
2322	2348	DESC_HDR_SEL0_DEU \|
..	..	@@ -2334,7 +2360,8 @@
2334	2360	.cra_driver_name = "authenc-hmac-sha224-"
2335	2361	"cbc-aes-talitos",
2336	2362	.cra_blocksize = AES_BLOCK_SIZE,
2337		- .cra_flags = CRYPTO_ALG_ASYNC,
	2363	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2364	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2338	2365	},
2339	2366	.ivsize = AES_BLOCK_SIZE,
2340	2367	.maxauthsize = SHA224_DIGEST_SIZE,
..	..	@@ -2355,7 +2382,8 @@
2355	2382	.cra_driver_name = "authenc-hmac-sha224-"
2356	2383	"cbc-aes-talitos-hsna",
2357	2384	.cra_blocksize = AES_BLOCK_SIZE,
2358		- .cra_flags = CRYPTO_ALG_ASYNC,
	2385	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2386	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2359	2387	},
2360	2388	.ivsize = AES_BLOCK_SIZE,
2361	2389	.maxauthsize = SHA224_DIGEST_SIZE,
..	..	@@ -2376,10 +2404,12 @@
2376	2404	.cra_driver_name = "authenc-hmac-sha224-"
2377	2405	"cbc-3des-talitos",
2378	2406	.cra_blocksize = DES3_EDE_BLOCK_SIZE,
2379		- .cra_flags = CRYPTO_ALG_ASYNC,
	2407	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2408	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2380	2409	},
2381	2410	.ivsize = DES3_EDE_BLOCK_SIZE,
2382	2411	.maxauthsize = SHA224_DIGEST_SIZE,
	2412	+ .setkey = aead_des3_setkey,
2383	2413	},
2384	2414	.desc_hdr_template = DESC_HDR_TYPE_IPSEC_ESP \|
2385	2415	DESC_HDR_SEL0_DEU \|
..	..	@@ -2399,10 +2429,12 @@
2399	2429	.cra_driver_name = "authenc-hmac-sha224-"
2400	2430	"cbc-3des-talitos-hsna",
2401	2431	.cra_blocksize = DES3_EDE_BLOCK_SIZE,
2402		- .cra_flags = CRYPTO_ALG_ASYNC,
	2432	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2433	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2403	2434	},
2404	2435	.ivsize = DES3_EDE_BLOCK_SIZE,
2405	2436	.maxauthsize = SHA224_DIGEST_SIZE,
	2437	+ .setkey = aead_des3_setkey,
2406	2438	},
2407	2439	.desc_hdr_template = DESC_HDR_TYPE_HMAC_SNOOP_NO_AFEU \|
2408	2440	DESC_HDR_SEL0_DEU \|
..	..	@@ -2420,7 +2452,8 @@
2420	2452	.cra_driver_name = "authenc-hmac-sha256-"
2421	2453	"cbc-aes-talitos",
2422	2454	.cra_blocksize = AES_BLOCK_SIZE,
2423		- .cra_flags = CRYPTO_ALG_ASYNC,
	2455	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2456	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2424	2457	},
2425	2458	.ivsize = AES_BLOCK_SIZE,
2426	2459	.maxauthsize = SHA256_DIGEST_SIZE,
..	..	@@ -2441,7 +2474,8 @@
2441	2474	.cra_driver_name = "authenc-hmac-sha256-"
2442	2475	"cbc-aes-talitos-hsna",
2443	2476	.cra_blocksize = AES_BLOCK_SIZE,
2444		- .cra_flags = CRYPTO_ALG_ASYNC,
	2477	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2478	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2445	2479	},
2446	2480	.ivsize = AES_BLOCK_SIZE,
2447	2481	.maxauthsize = SHA256_DIGEST_SIZE,
..	..	@@ -2462,10 +2496,12 @@
2462	2496	.cra_driver_name = "authenc-hmac-sha256-"
2463	2497	"cbc-3des-talitos",
2464	2498	.cra_blocksize = DES3_EDE_BLOCK_SIZE,
2465		- .cra_flags = CRYPTO_ALG_ASYNC,
	2499	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2500	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2466	2501	},
2467	2502	.ivsize = DES3_EDE_BLOCK_SIZE,
2468	2503	.maxauthsize = SHA256_DIGEST_SIZE,
	2504	+ .setkey = aead_des3_setkey,
2469	2505	},
2470	2506	.desc_hdr_template = DESC_HDR_TYPE_IPSEC_ESP \|
2471	2507	DESC_HDR_SEL0_DEU \|
..	..	@@ -2485,10 +2521,12 @@
2485	2521	.cra_driver_name = "authenc-hmac-sha256-"
2486	2522	"cbc-3des-talitos-hsna",
2487	2523	.cra_blocksize = DES3_EDE_BLOCK_SIZE,
2488		- .cra_flags = CRYPTO_ALG_ASYNC,
	2524	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2525	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2489	2526	},
2490	2527	.ivsize = DES3_EDE_BLOCK_SIZE,
2491	2528	.maxauthsize = SHA256_DIGEST_SIZE,
	2529	+ .setkey = aead_des3_setkey,
2492	2530	},
2493	2531	.desc_hdr_template = DESC_HDR_TYPE_HMAC_SNOOP_NO_AFEU \|
2494	2532	DESC_HDR_SEL0_DEU \|
..	..	@@ -2506,7 +2544,8 @@
2506	2544	.cra_driver_name = "authenc-hmac-sha384-"
2507	2545	"cbc-aes-talitos",
2508	2546	.cra_blocksize = AES_BLOCK_SIZE,
2509		- .cra_flags = CRYPTO_ALG_ASYNC,
	2547	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2548	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2510	2549	},
2511	2550	.ivsize = AES_BLOCK_SIZE,
2512	2551	.maxauthsize = SHA384_DIGEST_SIZE,
..	..	@@ -2527,10 +2566,12 @@
2527	2566	.cra_driver_name = "authenc-hmac-sha384-"
2528	2567	"cbc-3des-talitos",
2529	2568	.cra_blocksize = DES3_EDE_BLOCK_SIZE,
2530		- .cra_flags = CRYPTO_ALG_ASYNC,
	2569	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2570	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2531	2571	},
2532	2572	.ivsize = DES3_EDE_BLOCK_SIZE,
2533	2573	.maxauthsize = SHA384_DIGEST_SIZE,
	2574	+ .setkey = aead_des3_setkey,
2534	2575	},
2535	2576	.desc_hdr_template = DESC_HDR_TYPE_IPSEC_ESP \|
2536	2577	DESC_HDR_SEL0_DEU \|
..	..	@@ -2548,7 +2589,8 @@
2548	2589	.cra_driver_name = "authenc-hmac-sha512-"
2549	2590	"cbc-aes-talitos",
2550	2591	.cra_blocksize = AES_BLOCK_SIZE,
2551		- .cra_flags = CRYPTO_ALG_ASYNC,
	2592	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2593	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2552	2594	},
2553	2595	.ivsize = AES_BLOCK_SIZE,
2554	2596	.maxauthsize = SHA512_DIGEST_SIZE,
..	..	@@ -2569,10 +2611,12 @@
2569	2611	.cra_driver_name = "authenc-hmac-sha512-"
2570	2612	"cbc-3des-talitos",
2571	2613	.cra_blocksize = DES3_EDE_BLOCK_SIZE,
2572		- .cra_flags = CRYPTO_ALG_ASYNC,
	2614	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2615	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2573	2616	},
2574	2617	.ivsize = DES3_EDE_BLOCK_SIZE,
2575	2618	.maxauthsize = SHA512_DIGEST_SIZE,
	2619	+ .setkey = aead_des3_setkey,
2576	2620	},
2577	2621	.desc_hdr_template = DESC_HDR_TYPE_IPSEC_ESP \|
2578	2622	DESC_HDR_SEL0_DEU \|
..	..	@@ -2590,7 +2634,8 @@
2590	2634	.cra_driver_name = "authenc-hmac-md5-"
2591	2635	"cbc-aes-talitos",
2592	2636	.cra_blocksize = AES_BLOCK_SIZE,
2593		- .cra_flags = CRYPTO_ALG_ASYNC,
	2637	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2638	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2594	2639	},
2595	2640	.ivsize = AES_BLOCK_SIZE,
2596	2641	.maxauthsize = MD5_DIGEST_SIZE,
..	..	@@ -2611,7 +2656,8 @@
2611	2656	.cra_driver_name = "authenc-hmac-md5-"
2612	2657	"cbc-aes-talitos-hsna",
2613	2658	.cra_blocksize = AES_BLOCK_SIZE,
2614		- .cra_flags = CRYPTO_ALG_ASYNC,
	2659	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2660	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2615	2661	},
2616	2662	.ivsize = AES_BLOCK_SIZE,
2617	2663	.maxauthsize = MD5_DIGEST_SIZE,
..	..	@@ -2631,10 +2677,12 @@
2631	2677	.cra_driver_name = "authenc-hmac-md5-"
2632	2678	"cbc-3des-talitos",
2633	2679	.cra_blocksize = DES3_EDE_BLOCK_SIZE,
2634		- .cra_flags = CRYPTO_ALG_ASYNC,
	2680	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2681	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2635	2682	},
2636	2683	.ivsize = DES3_EDE_BLOCK_SIZE,
2637	2684	.maxauthsize = MD5_DIGEST_SIZE,
	2685	+ .setkey = aead_des3_setkey,
2638	2686	},
2639	2687	.desc_hdr_template = DESC_HDR_TYPE_IPSEC_ESP \|
2640	2688	DESC_HDR_SEL0_DEU \|
..	..	@@ -2653,10 +2701,12 @@
2653	2701	.cra_driver_name = "authenc-hmac-md5-"
2654	2702	"cbc-3des-talitos-hsna",
2655	2703	.cra_blocksize = DES3_EDE_BLOCK_SIZE,
2656		- .cra_flags = CRYPTO_ALG_ASYNC,
	2704	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2705	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2657	2706	},
2658	2707	.ivsize = DES3_EDE_BLOCK_SIZE,
2659	2708	.maxauthsize = MD5_DIGEST_SIZE,
	2709	+ .setkey = aead_des3_setkey,
2660	2710	},
2661	2711	.desc_hdr_template = DESC_HDR_TYPE_HMAC_SNOOP_NO_AFEU \|
2662	2712	DESC_HDR_SEL0_DEU \|
..	..	@@ -2667,120 +2717,125 @@
2667	2717	DESC_HDR_MODE1_MDEU_PAD \|
2668	2718	DESC_HDR_MODE1_MDEU_MD5_HMAC,
2669	2719	},
2670		- /* ABLKCIPHER algorithms. */
2671		- { .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
2672		- .alg.crypto = {
2673		- .cra_name = "ecb(aes)",
2674		- .cra_driver_name = "ecb-aes-talitos",
2675		- .cra_blocksize = AES_BLOCK_SIZE,
2676		- .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \|
2677		- CRYPTO_ALG_ASYNC,
2678		- .cra_ablkcipher = {
2679		- .min_keysize = AES_MIN_KEY_SIZE,
2680		- .max_keysize = AES_MAX_KEY_SIZE,
2681		- }
	2720	+ /* SKCIPHER algorithms. */
	2721	+ { .type = CRYPTO_ALG_TYPE_SKCIPHER,
	2722	+ .alg.skcipher = {
	2723	+ .base.cra_name = "ecb(aes)",
	2724	+ .base.cra_driver_name = "ecb-aes-talitos",
	2725	+ .base.cra_blocksize = AES_BLOCK_SIZE,
	2726	+ .base.cra_flags = CRYPTO_ALG_ASYNC \|
	2727	+ CRYPTO_ALG_ALLOCATES_MEMORY,
	2728	+ .min_keysize = AES_MIN_KEY_SIZE,
	2729	+ .max_keysize = AES_MAX_KEY_SIZE,
	2730	+ .setkey = skcipher_aes_setkey,
2682	2731	},
2683	2732	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
2684	2733	DESC_HDR_SEL0_AESU,
2685	2734	},
2686		- { .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
2687		- .alg.crypto = {
2688		- .cra_name = "cbc(aes)",
2689		- .cra_driver_name = "cbc-aes-talitos",
2690		- .cra_blocksize = AES_BLOCK_SIZE,
2691		- .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \|
2692		- CRYPTO_ALG_ASYNC,
2693		- .cra_ablkcipher = {
2694		- .min_keysize = AES_MIN_KEY_SIZE,
2695		- .max_keysize = AES_MAX_KEY_SIZE,
2696		- .ivsize = AES_BLOCK_SIZE,
2697		- .setkey = ablkcipher_aes_setkey,
2698		- }
	2735	+ { .type = CRYPTO_ALG_TYPE_SKCIPHER,
	2736	+ .alg.skcipher = {
	2737	+ .base.cra_name = "cbc(aes)",
	2738	+ .base.cra_driver_name = "cbc-aes-talitos",
	2739	+ .base.cra_blocksize = AES_BLOCK_SIZE,
	2740	+ .base.cra_flags = CRYPTO_ALG_ASYNC \|
	2741	+ CRYPTO_ALG_ALLOCATES_MEMORY,
	2742	+ .min_keysize = AES_MIN_KEY_SIZE,
	2743	+ .max_keysize = AES_MAX_KEY_SIZE,
	2744	+ .ivsize = AES_BLOCK_SIZE,
	2745	+ .setkey = skcipher_aes_setkey,
2699	2746	},
2700	2747	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
2701	2748	DESC_HDR_SEL0_AESU \|
2702	2749	DESC_HDR_MODE0_AESU_CBC,
2703	2750	},
2704		- { .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
2705		- .alg.crypto = {
2706		- .cra_name = "ctr(aes)",
2707		- .cra_driver_name = "ctr-aes-talitos",
2708		- .cra_blocksize = 1,
2709		- .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \|
2710		- CRYPTO_ALG_ASYNC,
2711		- .cra_ablkcipher = {
2712		- .min_keysize = AES_MIN_KEY_SIZE,
2713		- .max_keysize = AES_MAX_KEY_SIZE,
2714		- .ivsize = AES_BLOCK_SIZE,
2715		- .setkey = ablkcipher_aes_setkey,
2716		- }
	2751	+ { .type = CRYPTO_ALG_TYPE_SKCIPHER,
	2752	+ .alg.skcipher = {
	2753	+ .base.cra_name = "ctr(aes)",
	2754	+ .base.cra_driver_name = "ctr-aes-talitos",
	2755	+ .base.cra_blocksize = 1,
	2756	+ .base.cra_flags = CRYPTO_ALG_ASYNC \|
	2757	+ CRYPTO_ALG_ALLOCATES_MEMORY,
	2758	+ .min_keysize = AES_MIN_KEY_SIZE,
	2759	+ .max_keysize = AES_MAX_KEY_SIZE,
	2760	+ .ivsize = AES_BLOCK_SIZE,
	2761	+ .setkey = skcipher_aes_setkey,
2717	2762	},
2718	2763	.desc_hdr_template = DESC_HDR_TYPE_AESU_CTR_NONSNOOP \|
2719	2764	DESC_HDR_SEL0_AESU \|
2720	2765	DESC_HDR_MODE0_AESU_CTR,
2721	2766	},
2722		- { .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
2723		- .alg.crypto = {
2724		- .cra_name = "ecb(des)",
2725		- .cra_driver_name = "ecb-des-talitos",
2726		- .cra_blocksize = DES_BLOCK_SIZE,
2727		- .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \|
2728		- CRYPTO_ALG_ASYNC,
2729		- .cra_ablkcipher = {
2730		- .min_keysize = DES_KEY_SIZE,
2731		- .max_keysize = DES_KEY_SIZE,
2732		- .ivsize = DES_BLOCK_SIZE,
2733		- }
	2767	+ { .type = CRYPTO_ALG_TYPE_SKCIPHER,
	2768	+ .alg.skcipher = {
	2769	+ .base.cra_name = "ctr(aes)",
	2770	+ .base.cra_driver_name = "ctr-aes-talitos",
	2771	+ .base.cra_blocksize = 1,
	2772	+ .base.cra_flags = CRYPTO_ALG_ASYNC \|
	2773	+ CRYPTO_ALG_ALLOCATES_MEMORY,
	2774	+ .min_keysize = AES_MIN_KEY_SIZE,
	2775	+ .max_keysize = AES_MAX_KEY_SIZE,
	2776	+ .ivsize = AES_BLOCK_SIZE,
	2777	+ .setkey = skcipher_aes_setkey,
	2778	+ },
	2779	+ .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
	2780	+ DESC_HDR_SEL0_AESU \|
	2781	+ DESC_HDR_MODE0_AESU_CTR,
	2782	+ },
	2783	+ { .type = CRYPTO_ALG_TYPE_SKCIPHER,
	2784	+ .alg.skcipher = {
	2785	+ .base.cra_name = "ecb(des)",
	2786	+ .base.cra_driver_name = "ecb-des-talitos",
	2787	+ .base.cra_blocksize = DES_BLOCK_SIZE,
	2788	+ .base.cra_flags = CRYPTO_ALG_ASYNC \|
	2789	+ CRYPTO_ALG_ALLOCATES_MEMORY,
	2790	+ .min_keysize = DES_KEY_SIZE,
	2791	+ .max_keysize = DES_KEY_SIZE,
	2792	+ .setkey = skcipher_des_setkey,
2734	2793	},
2735	2794	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
2736	2795	DESC_HDR_SEL0_DEU,
2737	2796	},
2738		- { .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
2739		- .alg.crypto = {
2740		- .cra_name = "cbc(des)",
2741		- .cra_driver_name = "cbc-des-talitos",
2742		- .cra_blocksize = DES_BLOCK_SIZE,
2743		- .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \|
2744		- CRYPTO_ALG_ASYNC,
2745		- .cra_ablkcipher = {
2746		- .min_keysize = DES_KEY_SIZE,
2747		- .max_keysize = DES_KEY_SIZE,
2748		- .ivsize = DES_BLOCK_SIZE,
2749		- }
	2797	+ { .type = CRYPTO_ALG_TYPE_SKCIPHER,
	2798	+ .alg.skcipher = {
	2799	+ .base.cra_name = "cbc(des)",
	2800	+ .base.cra_driver_name = "cbc-des-talitos",
	2801	+ .base.cra_blocksize = DES_BLOCK_SIZE,
	2802	+ .base.cra_flags = CRYPTO_ALG_ASYNC \|
	2803	+ CRYPTO_ALG_ALLOCATES_MEMORY,
	2804	+ .min_keysize = DES_KEY_SIZE,
	2805	+ .max_keysize = DES_KEY_SIZE,
	2806	+ .ivsize = DES_BLOCK_SIZE,
	2807	+ .setkey = skcipher_des_setkey,
2750	2808	},
2751	2809	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
2752	2810	DESC_HDR_SEL0_DEU \|
2753	2811	DESC_HDR_MODE0_DEU_CBC,
2754	2812	},
2755		- { .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
2756		- .alg.crypto = {
2757		- .cra_name = "ecb(des3_ede)",
2758		- .cra_driver_name = "ecb-3des-talitos",
2759		- .cra_blocksize = DES3_EDE_BLOCK_SIZE,
2760		- .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \|
2761		- CRYPTO_ALG_ASYNC,
2762		- .cra_ablkcipher = {
2763		- .min_keysize = DES3_EDE_KEY_SIZE,
2764		- .max_keysize = DES3_EDE_KEY_SIZE,
2765		- .ivsize = DES3_EDE_BLOCK_SIZE,
2766		- }
	2813	+ { .type = CRYPTO_ALG_TYPE_SKCIPHER,
	2814	+ .alg.skcipher = {
	2815	+ .base.cra_name = "ecb(des3_ede)",
	2816	+ .base.cra_driver_name = "ecb-3des-talitos",
	2817	+ .base.cra_blocksize = DES3_EDE_BLOCK_SIZE,
	2818	+ .base.cra_flags = CRYPTO_ALG_ASYNC \|
	2819	+ CRYPTO_ALG_ALLOCATES_MEMORY,
	2820	+ .min_keysize = DES3_EDE_KEY_SIZE,
	2821	+ .max_keysize = DES3_EDE_KEY_SIZE,
	2822	+ .setkey = skcipher_des3_setkey,
2767	2823	},
2768	2824	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
2769	2825	DESC_HDR_SEL0_DEU \|
2770	2826	DESC_HDR_MODE0_DEU_3DES,
2771	2827	},
2772		- { .type = CRYPTO_ALG_TYPE_ABLKCIPHER,
2773		- .alg.crypto = {
2774		- .cra_name = "cbc(des3_ede)",
2775		- .cra_driver_name = "cbc-3des-talitos",
2776		- .cra_blocksize = DES3_EDE_BLOCK_SIZE,
2777		- .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \|
2778		- CRYPTO_ALG_ASYNC,
2779		- .cra_ablkcipher = {
2780		- .min_keysize = DES3_EDE_KEY_SIZE,
2781		- .max_keysize = DES3_EDE_KEY_SIZE,
2782		- .ivsize = DES3_EDE_BLOCK_SIZE,
2783		- }
	2828	+ { .type = CRYPTO_ALG_TYPE_SKCIPHER,
	2829	+ .alg.skcipher = {
	2830	+ .base.cra_name = "cbc(des3_ede)",
	2831	+ .base.cra_driver_name = "cbc-3des-talitos",
	2832	+ .base.cra_blocksize = DES3_EDE_BLOCK_SIZE,
	2833	+ .base.cra_flags = CRYPTO_ALG_ASYNC \|
	2834	+ CRYPTO_ALG_ALLOCATES_MEMORY,
	2835	+ .min_keysize = DES3_EDE_KEY_SIZE,
	2836	+ .max_keysize = DES3_EDE_KEY_SIZE,
	2837	+ .ivsize = DES3_EDE_BLOCK_SIZE,
	2838	+ .setkey = skcipher_des3_setkey,
2784	2839	},
2785	2840	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
2786	2841	DESC_HDR_SEL0_DEU \|
..	..	@@ -2796,7 +2851,8 @@
2796	2851	.cra_name = "md5",
2797	2852	.cra_driver_name = "md5-talitos",
2798	2853	.cra_blocksize = MD5_HMAC_BLOCK_SIZE,
2799		- .cra_flags = CRYPTO_ALG_ASYNC,
	2854	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2855	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2800	2856	}
2801	2857	},
2802	2858	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
..	..	@@ -2811,7 +2867,8 @@
2811	2867	.cra_name = "sha1",
2812	2868	.cra_driver_name = "sha1-talitos",
2813	2869	.cra_blocksize = SHA1_BLOCK_SIZE,
2814		- .cra_flags = CRYPTO_ALG_ASYNC,
	2870	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2871	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2815	2872	}
2816	2873	},
2817	2874	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
..	..	@@ -2826,7 +2883,8 @@
2826	2883	.cra_name = "sha224",
2827	2884	.cra_driver_name = "sha224-talitos",
2828	2885	.cra_blocksize = SHA224_BLOCK_SIZE,
2829		- .cra_flags = CRYPTO_ALG_ASYNC,
	2886	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2887	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2830	2888	}
2831	2889	},
2832	2890	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
..	..	@@ -2841,7 +2899,8 @@
2841	2899	.cra_name = "sha256",
2842	2900	.cra_driver_name = "sha256-talitos",
2843	2901	.cra_blocksize = SHA256_BLOCK_SIZE,
2844		- .cra_flags = CRYPTO_ALG_ASYNC,
	2902	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2903	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2845	2904	}
2846	2905	},
2847	2906	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
..	..	@@ -2856,7 +2915,8 @@
2856	2915	.cra_name = "sha384",
2857	2916	.cra_driver_name = "sha384-talitos",
2858	2917	.cra_blocksize = SHA384_BLOCK_SIZE,
2859		- .cra_flags = CRYPTO_ALG_ASYNC,
	2918	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2919	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2860	2920	}
2861	2921	},
2862	2922	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
..	..	@@ -2871,7 +2931,8 @@
2871	2931	.cra_name = "sha512",
2872	2932	.cra_driver_name = "sha512-talitos",
2873	2933	.cra_blocksize = SHA512_BLOCK_SIZE,
2874		- .cra_flags = CRYPTO_ALG_ASYNC,
	2934	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2935	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2875	2936	}
2876	2937	},
2877	2938	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
..	..	@@ -2886,7 +2947,8 @@
2886	2947	.cra_name = "hmac(md5)",
2887	2948	.cra_driver_name = "hmac-md5-talitos",
2888	2949	.cra_blocksize = MD5_HMAC_BLOCK_SIZE,
2889		- .cra_flags = CRYPTO_ALG_ASYNC,
	2950	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2951	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2890	2952	}
2891	2953	},
2892	2954	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
..	..	@@ -2901,7 +2963,8 @@
2901	2963	.cra_name = "hmac(sha1)",
2902	2964	.cra_driver_name = "hmac-sha1-talitos",
2903	2965	.cra_blocksize = SHA1_BLOCK_SIZE,
2904		- .cra_flags = CRYPTO_ALG_ASYNC,
	2966	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2967	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2905	2968	}
2906	2969	},
2907	2970	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
..	..	@@ -2916,7 +2979,8 @@
2916	2979	.cra_name = "hmac(sha224)",
2917	2980	.cra_driver_name = "hmac-sha224-talitos",
2918	2981	.cra_blocksize = SHA224_BLOCK_SIZE,
2919		- .cra_flags = CRYPTO_ALG_ASYNC,
	2982	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2983	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2920	2984	}
2921	2985	},
2922	2986	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
..	..	@@ -2931,7 +2995,8 @@
2931	2995	.cra_name = "hmac(sha256)",
2932	2996	.cra_driver_name = "hmac-sha256-talitos",
2933	2997	.cra_blocksize = SHA256_BLOCK_SIZE,
2934		- .cra_flags = CRYPTO_ALG_ASYNC,
	2998	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	2999	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2935	3000	}
2936	3001	},
2937	3002	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
..	..	@@ -2946,7 +3011,8 @@
2946	3011	.cra_name = "hmac(sha384)",
2947	3012	.cra_driver_name = "hmac-sha384-talitos",
2948	3013	.cra_blocksize = SHA384_BLOCK_SIZE,
2949		- .cra_flags = CRYPTO_ALG_ASYNC,
	3014	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	3015	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2950	3016	}
2951	3017	},
2952	3018	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
..	..	@@ -2961,7 +3027,8 @@
2961	3027	.cra_name = "hmac(sha512)",
2962	3028	.cra_driver_name = "hmac-sha512-talitos",
2963	3029	.cra_blocksize = SHA512_BLOCK_SIZE,
2964		- .cra_flags = CRYPTO_ALG_ASYNC,
	3030	+ .cra_flags = CRYPTO_ALG_ASYNC \|
	3031	+ CRYPTO_ALG_ALLOCATES_MEMORY,
2965	3032	}
2966	3033	},
2967	3034	.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU \|
..	..	@@ -2998,23 +3065,6 @@
2998	3065	return 0;
2999	3066	}
3000	3067
3001		-static int talitos_cra_init(struct crypto_tfm *tfm)
3002		-{
3003		- struct crypto_alg *alg = tfm->__crt_alg;
3004		- struct talitos_crypto_alg *talitos_alg;
3005		- struct talitos_ctx *ctx = crypto_tfm_ctx(tfm);
3006		-
3007		- if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_AHASH)
3008		- talitos_alg = container_of(__crypto_ahash_alg(alg),
3009		- struct talitos_crypto_alg,
3010		- algt.alg.hash);
3011		- else
3012		- talitos_alg = container_of(alg, struct talitos_crypto_alg,
3013		- algt.alg.crypto);
3014		-
3015		- return talitos_init_common(ctx, talitos_alg);
3016		-}
3017		-
3018	3068	static int talitos_cra_init_aead(struct crypto_aead *tfm)
3019	3069	{
3020	3070	struct aead_alg *alg = crypto_aead_alg(tfm);
..	..	@@ -3027,17 +3077,33 @@
3027	3077	return talitos_init_common(ctx, talitos_alg);
3028	3078	}
3029	3079
	3080	+static int talitos_cra_init_skcipher(struct crypto_skcipher *tfm)
	3081	+{
	3082	+ struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
	3083	+ struct talitos_crypto_alg *talitos_alg;
	3084	+ struct talitos_ctx *ctx = crypto_skcipher_ctx(tfm);
	3085	+
	3086	+ talitos_alg = container_of(alg, struct talitos_crypto_alg,
	3087	+ algt.alg.skcipher);
	3088	+
	3089	+ return talitos_init_common(ctx, talitos_alg);
	3090	+}
	3091	+
3030	3092	static int talitos_cra_init_ahash(struct crypto_tfm *tfm)
3031	3093	{
	3094	+ struct crypto_alg *alg = tfm->__crt_alg;
	3095	+ struct talitos_crypto_alg *talitos_alg;
3032	3096	struct talitos_ctx *ctx = crypto_tfm_ctx(tfm);
3033	3097
3034		- talitos_cra_init(tfm);
	3098	+ talitos_alg = container_of(__crypto_ahash_alg(alg),
	3099	+ struct talitos_crypto_alg,
	3100	+ algt.alg.hash);
3035	3101
3036	3102	ctx->keylen = 0;
3037	3103	crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
3038	3104	sizeof(struct talitos_ahash_req_ctx));
3039	3105
3040		- return 0;
	3106	+ return talitos_init_common(ctx, talitos_alg);
3041	3107	}
3042	3108
3043	3109	static void talitos_cra_exit(struct crypto_tfm *tfm)
..	..	@@ -3078,7 +3144,8 @@
3078	3144
3079	3145	list_for_each_entry_safe(t_alg, n, &priv->alg_list, entry) {
3080	3146	switch (t_alg->algt.type) {
3081		- case CRYPTO_ALG_TYPE_ABLKCIPHER:
	3147	+ case CRYPTO_ALG_TYPE_SKCIPHER:
	3148	+ crypto_unregister_skcipher(&t_alg->algt.alg.skcipher);
3082	3149	break;
3083	3150	case CRYPTO_ALG_TYPE_AEAD:
3084	3151	crypto_unregister_aead(&t_alg->algt.alg.aead);
..	..	@@ -3122,21 +3189,27 @@
3122	3189	t_alg->algt = *template;
3123	3190
3124	3191	switch (t_alg->algt.type) {
3125		- case CRYPTO_ALG_TYPE_ABLKCIPHER:
3126		- alg = &t_alg->algt.alg.crypto;
3127		- alg->cra_init = talitos_cra_init;
	3192	+ case CRYPTO_ALG_TYPE_SKCIPHER:
	3193	+ alg = &t_alg->algt.alg.skcipher.base;
3128	3194	alg->cra_exit = talitos_cra_exit;
3129		- alg->cra_type = &crypto_ablkcipher_type;
3130		- alg->cra_ablkcipher.setkey = ablkcipher_setkey;
3131		- alg->cra_ablkcipher.encrypt = ablkcipher_encrypt;
3132		- alg->cra_ablkcipher.decrypt = ablkcipher_decrypt;
3133		- alg->cra_ablkcipher.geniv = "eseqiv";
	3195	+ t_alg->algt.alg.skcipher.init = talitos_cra_init_skcipher;
	3196	+ t_alg->algt.alg.skcipher.setkey =
	3197	+ t_alg->algt.alg.skcipher.setkey ?: skcipher_setkey;
	3198	+ t_alg->algt.alg.skcipher.encrypt = skcipher_encrypt;
	3199	+ t_alg->algt.alg.skcipher.decrypt = skcipher_decrypt;
	3200	+ if (!strcmp(alg->cra_name, "ctr(aes)") && !has_ftr_sec1(priv) &&
	3201	+ DESC_TYPE(t_alg->algt.desc_hdr_template) !=
	3202	+ DESC_TYPE(DESC_HDR_TYPE_AESU_CTR_NONSNOOP)) {
	3203	+ devm_kfree(dev, t_alg);
	3204	+ return ERR_PTR(-ENOTSUPP);
	3205	+ }
3134	3206	break;
3135	3207	case CRYPTO_ALG_TYPE_AEAD:
3136	3208	alg = &t_alg->algt.alg.aead.base;
3137	3209	alg->cra_exit = talitos_cra_exit;
3138	3210	t_alg->algt.alg.aead.init = talitos_cra_init_aead;
3139		- t_alg->algt.alg.aead.setkey = aead_setkey;
	3211	+ t_alg->algt.alg.aead.setkey = t_alg->algt.alg.aead.setkey ?:
	3212	+ aead_setkey;
3140	3213	t_alg->algt.alg.aead.encrypt = aead_encrypt;
3141	3214	t_alg->algt.alg.aead.decrypt = aead_decrypt;
3142	3215	if (!(priv->features & TALITOS_FTR_SHA224_HWINIT) &&
..	..	@@ -3336,7 +3409,7 @@
3336	3409	if (err)
3337	3410	goto err_out;
3338	3411
3339		- if (of_device_is_compatible(np, "fsl,sec1.0")) {
	3412	+ if (has_ftr_sec1(priv)) {
3340	3413	if (priv->num_channels == 1)
3341	3414	tasklet_init(&priv->done_task[0], talitos1_done_ch0,
3342	3415	(unsigned long)dev);
..	..	@@ -3426,10 +3499,10 @@
3426	3499	}
3427	3500
3428	3501	switch (t_alg->algt.type) {
3429		- case CRYPTO_ALG_TYPE_ABLKCIPHER:
3430		- err = crypto_register_alg(
3431		- &t_alg->algt.alg.crypto);
3432		- alg = &t_alg->algt.alg.crypto;
	3502	+ case CRYPTO_ALG_TYPE_SKCIPHER:
	3503	+ err = crypto_register_skcipher(
	3504	+ &t_alg->algt.alg.skcipher);
	3505	+ alg = &t_alg->algt.alg.skcipher.base;
3433	3506	break;
3434	3507
3435	3508	case CRYPTO_ALG_TYPE_AEAD: