projects / openwrt / staging / ldir.git / blob
? search:


4e1efc858b9731df9b28f0bef1e7ef40df3b7432
[openwrt/staging/ldir.git] /
1 From e640f4bcfa0088ff696bc5da6063a1ea8d782189 Mon Sep 17 00:00:00 2001
2 From: Iuliana Prodan <iuliana.prodan@nxp.com>
3 Date: Thu, 26 Sep 2019 15:26:29 +0300
4 Subject: [PATCH] crypto: caam - use mapped_{src,dst}_nents for descriptor
5 MIME-Version: 1.0
6 Content-Type: text/plain; charset=UTF-8
7 Content-Transfer-Encoding: 8bit
8
9 The mapped_{src,dst}_nents _returned_ from the dma_map_sg
10 call (which could be less than src/dst_nents) have to be
11 used to generate the job descriptors.
12
13 Signed-off-by: Iuliana Prodan <iuliana.prodan@nxp.com>
14 Reviewed-by: Horia Geantă <horia.geanta@nxp.com>
15 Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
16 (cherry picked from commit eff9771d51529acf7f6f58a60b2923b98da28f0e)
17 ---
18 drivers/crypto/caam/caampkc.c | 72 +++++++++++++++++++++++--------------------
19 drivers/crypto/caam/caampkc.h | 8 +++--
20 2 files changed, 45 insertions(+), 35 deletions(-)
21
22 --- a/drivers/crypto/caam/caampkc.c
23 +++ b/drivers/crypto/caam/caampkc.c
24 @@ -252,9 +252,9 @@ static struct rsa_edesc *rsa_edesc_alloc
25 gfp_t flags = (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) ?
26 GFP_KERNEL : GFP_ATOMIC;
27 int sg_flags = (flags == GFP_ATOMIC) ? SG_MITER_ATOMIC : 0;
28 - int sgc;
29 int sec4_sg_index, sec4_sg_len = 0, sec4_sg_bytes;
30 int src_nents, dst_nents;
31 + int mapped_src_nents, mapped_dst_nents;
32 unsigned int diff_size = 0;
33 int lzeros;
34
35 @@ -285,13 +285,27 @@ static struct rsa_edesc *rsa_edesc_alloc
36 req_ctx->fixup_src_len);
37 dst_nents = sg_nents_for_len(req->dst, req->dst_len);
38
39 - if (!diff_size && src_nents == 1)
40 + mapped_src_nents = dma_map_sg(dev, req_ctx->fixup_src, src_nents,
41 + DMA_TO_DEVICE);
42 + if (unlikely(!mapped_src_nents)) {
43 + dev_err(dev, "unable to map source\n");
44 + return ERR_PTR(-ENOMEM);
45 + }
46 + mapped_dst_nents = dma_map_sg(dev, req->dst, dst_nents,
47 + DMA_FROM_DEVICE);
48 + if (unlikely(!mapped_dst_nents)) {
49 + dev_err(dev, "unable to map destination\n");
50 + goto src_fail;
51 + }
52 +
53 + if (!diff_size && mapped_src_nents == 1)
54 sec4_sg_len = 0; /* no need for an input hw s/g table */
55 else
56 - sec4_sg_len = src_nents + !!diff_size;
57 + sec4_sg_len = mapped_src_nents + !!diff_size;
58 sec4_sg_index = sec4_sg_len;
59 - if (dst_nents > 1)
60 - sec4_sg_len += pad_sg_nents(dst_nents);
61 +
62 + if (mapped_dst_nents > 1)
63 + sec4_sg_len += pad_sg_nents(mapped_dst_nents);
64 else
65 sec4_sg_len = pad_sg_nents(sec4_sg_len);
66
67 @@ -301,19 +315,7 @@ static struct rsa_edesc *rsa_edesc_alloc
68 edesc = kzalloc(sizeof(*edesc) + desclen + sec4_sg_bytes,
69 GFP_DMA | flags);
70 if (!edesc)
71 - return ERR_PTR(-ENOMEM);
72 -
73 - sgc = dma_map_sg(dev, req_ctx->fixup_src, src_nents, DMA_TO_DEVICE);
74 - if (unlikely(!sgc)) {
75 - dev_err(dev, "unable to map source\n");
76 - goto src_fail;
77 - }
78 -
79 - sgc = dma_map_sg(dev, req->dst, dst_nents, DMA_FROM_DEVICE);
80 - if (unlikely(!sgc)) {
81 - dev_err(dev, "unable to map destination\n");
82 goto dst_fail;
83 - }
84
85 edesc->sec4_sg = (void *)edesc + sizeof(*edesc) + desclen;
86 if (diff_size)
87 @@ -324,7 +326,7 @@ static struct rsa_edesc *rsa_edesc_alloc
88 sg_to_sec4_sg_last(req_ctx->fixup_src, req_ctx->fixup_src_len,
89 edesc->sec4_sg + !!diff_size, 0);
90
91 - if (dst_nents > 1)
92 + if (mapped_dst_nents > 1)
93 sg_to_sec4_sg_last(req->dst, req->dst_len,
94 edesc->sec4_sg + sec4_sg_index, 0);
95
96 @@ -335,6 +337,9 @@ static struct rsa_edesc *rsa_edesc_alloc
97 if (!sec4_sg_bytes)
98 return edesc;
99
100 + edesc->mapped_src_nents = mapped_src_nents;
101 + edesc->mapped_dst_nents = mapped_dst_nents;
102 +
103 edesc->sec4_sg_dma = dma_map_single(dev, edesc->sec4_sg,
104 sec4_sg_bytes, DMA_TO_DEVICE);
105 if (dma_mapping_error(dev, edesc->sec4_sg_dma)) {
106 @@ -351,11 +356,11 @@ static struct rsa_edesc *rsa_edesc_alloc
107 return edesc;
108
109 sec4_sg_fail:
110 - dma_unmap_sg(dev, req->dst, dst_nents, DMA_FROM_DEVICE);
111 + kfree(edesc);
112 dst_fail:
113 - dma_unmap_sg(dev, req_ctx->fixup_src, src_nents, DMA_TO_DEVICE);
114 + dma_unmap_sg(dev, req->dst, dst_nents, DMA_FROM_DEVICE);
115 src_fail:
116 - kfree(edesc);
117 + dma_unmap_sg(dev, req_ctx->fixup_src, src_nents, DMA_TO_DEVICE);
118 return ERR_PTR(-ENOMEM);
119 }
120
121 @@ -383,15 +388,15 @@ static int set_rsa_pub_pdb(struct akciph
122 return -ENOMEM;
123 }
124
125 - if (edesc->src_nents > 1) {
126 + if (edesc->mapped_src_nents > 1) {
127 pdb->sgf |= RSA_PDB_SGF_F;
128 pdb->f_dma = edesc->sec4_sg_dma;
129 - sec4_sg_index += edesc->src_nents;
130 + sec4_sg_index += edesc->mapped_src_nents;
131 } else {
132 pdb->f_dma = sg_dma_address(req_ctx->fixup_src);
133 }
134
135 - if (edesc->dst_nents > 1) {
136 + if (edesc->mapped_dst_nents > 1) {
137 pdb->sgf |= RSA_PDB_SGF_G;
138 pdb->g_dma = edesc->sec4_sg_dma +
139 sec4_sg_index * sizeof(struct sec4_sg_entry);
140 @@ -428,17 +433,18 @@ static int set_rsa_priv_f1_pdb(struct ak
141 return -ENOMEM;
142 }
143
144 - if (edesc->src_nents > 1) {
145 + if (edesc->mapped_src_nents > 1) {
146 pdb->sgf |= RSA_PRIV_PDB_SGF_G;
147 pdb->g_dma = edesc->sec4_sg_dma;
148 - sec4_sg_index += edesc->src_nents;
149 + sec4_sg_index += edesc->mapped_src_nents;
150 +
151 } else {
152 struct caam_rsa_req_ctx *req_ctx = akcipher_request_ctx(req);
153
154 pdb->g_dma = sg_dma_address(req_ctx->fixup_src);
155 }
156
157 - if (edesc->dst_nents > 1) {
158 + if (edesc->mapped_dst_nents > 1) {
159 pdb->sgf |= RSA_PRIV_PDB_SGF_F;
160 pdb->f_dma = edesc->sec4_sg_dma +
161 sec4_sg_index * sizeof(struct sec4_sg_entry);
162 @@ -493,17 +499,17 @@ static int set_rsa_priv_f2_pdb(struct ak
163 goto unmap_tmp1;
164 }
165
166 - if (edesc->src_nents > 1) {
167 + if (edesc->mapped_src_nents > 1) {
168 pdb->sgf |= RSA_PRIV_PDB_SGF_G;
169 pdb->g_dma = edesc->sec4_sg_dma;
170 - sec4_sg_index += edesc->src_nents;
171 + sec4_sg_index += edesc->mapped_src_nents;
172 } else {
173 struct caam_rsa_req_ctx *req_ctx = akcipher_request_ctx(req);
174
175 pdb->g_dma = sg_dma_address(req_ctx->fixup_src);
176 }
177
178 - if (edesc->dst_nents > 1) {
179 + if (edesc->mapped_dst_nents > 1) {
180 pdb->sgf |= RSA_PRIV_PDB_SGF_F;
181 pdb->f_dma = edesc->sec4_sg_dma +
182 sec4_sg_index * sizeof(struct sec4_sg_entry);
183 @@ -582,17 +588,17 @@ static int set_rsa_priv_f3_pdb(struct ak
184 goto unmap_tmp1;
185 }
186
187 - if (edesc->src_nents > 1) {
188 + if (edesc->mapped_src_nents > 1) {
189 pdb->sgf |= RSA_PRIV_PDB_SGF_G;
190 pdb->g_dma = edesc->sec4_sg_dma;
191 - sec4_sg_index += edesc->src_nents;
192 + sec4_sg_index += edesc->mapped_src_nents;
193 } else {
194 struct caam_rsa_req_ctx *req_ctx = akcipher_request_ctx(req);
195
196 pdb->g_dma = sg_dma_address(req_ctx->fixup_src);
197 }
198
199 - if (edesc->dst_nents > 1) {
200 + if (edesc->mapped_dst_nents > 1) {
201 pdb->sgf |= RSA_PRIV_PDB_SGF_F;
202 pdb->f_dma = edesc->sec4_sg_dma +
203 sec4_sg_index * sizeof(struct sec4_sg_entry);
204 --- a/drivers/crypto/caam/caampkc.h
205 +++ b/drivers/crypto/caam/caampkc.h
206 @@ -112,8 +112,10 @@ struct caam_rsa_req_ctx {
207
208 /**
209 * rsa_edesc - s/w-extended rsa descriptor
210 - * @src_nents : number of segments in input scatterlist
211 - * @dst_nents : number of segments in output scatterlist
212 + * @src_nents : number of segments in input s/w scatterlist
213 + * @dst_nents : number of segments in output s/w scatterlist
214 + * @mapped_src_nents: number of segments in input h/w link table
215 + * @mapped_dst_nents: number of segments in output h/w link table
216 * @sec4_sg_bytes : length of h/w link table
217 * @sec4_sg_dma : dma address of h/w link table
218 * @sec4_sg : pointer to h/w link table
219 @@ -123,6 +125,8 @@ struct caam_rsa_req_ctx {
220 struct rsa_edesc {
221 int src_nents;
222 int dst_nents;
223 + int mapped_src_nents;
224 + int mapped_dst_nents;
225 int sec4_sg_bytes;
226 dma_addr_t sec4_sg_dma;
227 struct sec4_sg_entry *sec4_sg;
Kevin D-Bs staging tree