1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * OMAP Crypto driver common support routines.
4 *
5 * Copyright (c) 2017 Texas Instruments Incorporated
6 *   Tero Kristo <t-kristo@ti.com>
7 */
8
9#include <linux/module.h>
10#include <linux/kernel.h>
11#include <linux/scatterlist.h>
12#include <crypto/scatterwalk.h>
13
14#include "omap-crypto.h"
15
16static int omap_crypto_copy_sg_lists(int total, int bs,
17				     struct scatterlist **sg,
18				     struct scatterlist *new_sg, u16 flags)
19{
20	int n = sg_nents(*sg);
21	struct scatterlist *tmp;
22
23	if (!(flags & OMAP_CRYPTO_FORCE_SINGLE_ENTRY)) {
24		new_sg = kmalloc_array(n, sizeof(*sg), GFP_KERNEL);
25		if (!new_sg)
26			return -ENOMEM;
27
28		sg_init_table(new_sg, n);
29	}
30
31	tmp = new_sg;
32
33	while (*sg && total) {
34		int len = (*sg)->length;
35
36		if (total < len)
37			len = total;
38
39		if (len > 0) {
40			total -= len;
41			sg_set_page(tmp, sg_page(*sg), len, (*sg)->offset);
42			if (total <= 0)
43				sg_mark_end(tmp);
44			tmp = sg_next(tmp);
45		}
46
47		*sg = sg_next(*sg);
48	}
49
50	*sg = new_sg;
51
52	return 0;
53}
54
55static int omap_crypto_copy_sgs(int total, int bs, struct scatterlist **sg,
56				struct scatterlist *new_sg, u16 flags)
57{
58	void *buf;
59	int pages;
60	int new_len;
61
62	new_len = ALIGN(total, bs);
63	pages = get_order(new_len);
64
65	buf = (void *)__get_free_pages(GFP_ATOMIC, pages);
66	if (!buf) {
67		pr_err("%s: Couldn't allocate pages for unaligned cases.\n",
68		       __func__);
69		return -ENOMEM;
70	}
71
72	if (flags & OMAP_CRYPTO_COPY_DATA) {
73		scatterwalk_map_and_copy(buf, *sg, 0, total, 0);
74		if (flags & OMAP_CRYPTO_ZERO_BUF)
75			memset(buf + total, 0, new_len - total);
76	}
77
78	if (!(flags & OMAP_CRYPTO_FORCE_SINGLE_ENTRY))
79		sg_init_table(new_sg, 1);
80
81	sg_set_buf(new_sg, buf, new_len);
82
83	*sg = new_sg;
84
85	return 0;
86}
87
88static int omap_crypto_check_sg(struct scatterlist *sg, int total, int bs,
89				u16 flags)
90{
91	int len = 0;
92	int num_sg = 0;
93
94	if (!IS_ALIGNED(total, bs))
95		return OMAP_CRYPTO_NOT_ALIGNED;
96
97	while (sg) {
98		num_sg++;
99
100		if (!IS_ALIGNED(sg->offset, 4))
101			return OMAP_CRYPTO_NOT_ALIGNED;
102		if (!IS_ALIGNED(sg->length, bs))
103			return OMAP_CRYPTO_NOT_ALIGNED;
104#ifdef CONFIG_ZONE_DMA
105		if (page_zonenum(sg_page(sg)) != ZONE_DMA)
106			return OMAP_CRYPTO_NOT_ALIGNED;
107#endif
108
109		len += sg->length;
110		sg = sg_next(sg);
111
112		if (len >= total)
113			break;
114	}
115
116	if ((flags & OMAP_CRYPTO_FORCE_SINGLE_ENTRY) && num_sg > 1)
117		return OMAP_CRYPTO_NOT_ALIGNED;
118
119	if (len != total)
120		return OMAP_CRYPTO_BAD_DATA_LENGTH;
121
122	return 0;
123}
124
125int omap_crypto_align_sg(struct scatterlist **sg, int total, int bs,
126			 struct scatterlist *new_sg, u16 flags,
127			 u8 flags_shift, unsigned long *dd_flags)
128{
129	int ret;
130
131	*dd_flags &= ~(OMAP_CRYPTO_COPY_MASK << flags_shift);
132
133	if (flags & OMAP_CRYPTO_FORCE_COPY)
134		ret = OMAP_CRYPTO_NOT_ALIGNED;
135	else
136		ret = omap_crypto_check_sg(*sg, total, bs, flags);
137
138	if (ret == OMAP_CRYPTO_NOT_ALIGNED) {
139		ret = omap_crypto_copy_sgs(total, bs, sg, new_sg, flags);
140		if (ret)
141			return ret;
142		*dd_flags |= OMAP_CRYPTO_DATA_COPIED << flags_shift;
143	} else if (ret == OMAP_CRYPTO_BAD_DATA_LENGTH) {
144		ret = omap_crypto_copy_sg_lists(total, bs, sg, new_sg, flags);
145		if (ret)
146			return ret;
147		if (!(flags & OMAP_CRYPTO_FORCE_SINGLE_ENTRY))
148			*dd_flags |= OMAP_CRYPTO_SG_COPIED << flags_shift;
149	} else if (flags & OMAP_CRYPTO_FORCE_SINGLE_ENTRY) {
150		sg_set_buf(new_sg, sg_virt(*sg), (*sg)->length);
151	}
152
153	return 0;
154}
155EXPORT_SYMBOL_GPL(omap_crypto_align_sg);
156
157static void omap_crypto_copy_data(struct scatterlist *src,
158				  struct scatterlist *dst,
159				  int offset, int len)
160{
161	int amt;
162	void *srcb, *dstb;
163	int srco = 0, dsto = offset;
164
165	while (src && dst && len) {
166		if (srco >= src->length) {
167			srco -= src->length;
168			src = sg_next(src);
169			continue;
170		}
171
172		if (dsto >= dst->length) {
173			dsto -= dst->length;
174			dst = sg_next(dst);
175			continue;
176		}
177
178		amt = min(src->length - srco, dst->length - dsto);
179		amt = min(len, amt);
180
181		srcb = kmap_atomic(sg_page(src)) + srco + src->offset;
182		dstb = kmap_atomic(sg_page(dst)) + dsto + dst->offset;
183
184		memcpy(dstb, srcb, amt);
185
186		flush_dcache_page(sg_page(dst));
187
188		kunmap_atomic(srcb);
189		kunmap_atomic(dstb);
190
191		srco += amt;
192		dsto += amt;
193		len -= amt;
194	}
195}
196
197void omap_crypto_cleanup(struct scatterlist *sg, struct scatterlist *orig,
198			 int offset, int len, u8 flags_shift,
199			 unsigned long flags)
200{
201	void *buf;
202	int pages;
203
204	flags >>= flags_shift;
205	flags &= OMAP_CRYPTO_COPY_MASK;
206
207	if (!flags)
208		return;
209
210	buf = sg_virt(sg);
211	pages = get_order(len);
212
213	if (orig && (flags & OMAP_CRYPTO_DATA_COPIED))
214		omap_crypto_copy_data(sg, orig, offset, len);
215
216	if (flags & OMAP_CRYPTO_DATA_COPIED)
217		free_pages((unsigned long)buf, pages);
218	else if (flags & OMAP_CRYPTO_SG_COPIED)
219		kfree(sg);
220}
221EXPORT_SYMBOL_GPL(omap_crypto_cleanup);
222
223MODULE_DESCRIPTION("OMAP crypto support library.");
224MODULE_LICENSE("GPL v2");
225MODULE_AUTHOR("Tero Kristo <t-kristo@ti.com>");
226