Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
crypto: qat - Remove dst_null support
Remove the unused dst_null support.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
+1
-259
-159
drivers/crypto/intel/qat/qat_common/qat_bl.c
-159
drivers/crypto/intel/qat/qat_common/qat_bl.c
···
251
251
extra_dst_buff, sz_extra_dst_buff,
252
252
sskip, dskip, flags);
253
253
}
254
-
255
-
static void qat_bl_sgl_unmap(struct adf_accel_dev *accel_dev,
256
-
struct qat_alg_buf_list *bl)
257
-
{
258
-
struct device *dev = &GET_DEV(accel_dev);
259
-
int n = bl->num_bufs;
260
-
int i;
261
-
262
-
for (i = 0; i < n; i++)
263
-
if (!dma_mapping_error(dev, bl->buffers[i].addr))
264
-
dma_unmap_single(dev, bl->buffers[i].addr,
265
-
bl->buffers[i].len, DMA_FROM_DEVICE);
266
-
}
267
-
268
-
static int qat_bl_sgl_map(struct adf_accel_dev *accel_dev,
269
-
struct scatterlist *sgl,
270
-
struct qat_alg_buf_list **bl)
271
-
{
272
-
struct device *dev = &GET_DEV(accel_dev);
273
-
struct qat_alg_buf_list *bufl;
274
-
int node = dev_to_node(dev);
275
-
struct scatterlist *sg;
276
-
int n, i, sg_nctr;
277
-
size_t sz;
278
-
279
-
n = sg_nents(sgl);
280
-
sz = struct_size(bufl, buffers, n);
281
-
bufl = kzalloc_node(sz, GFP_KERNEL, node);
282
-
if (unlikely(!bufl))
283
-
return -ENOMEM;
284
-
285
-
for (i = 0; i < n; i++)
286
-
bufl->buffers[i].addr = DMA_MAPPING_ERROR;
287
-
288
-
sg_nctr = 0;
289
-
for_each_sg(sgl, sg, n, i) {
290
-
int y = sg_nctr;
291
-
292
-
if (!sg->length)
293
-
continue;
294
-
295
-
bufl->buffers[y].addr = dma_map_single(dev, sg_virt(sg),
296
-
sg->length,
297
-
DMA_FROM_DEVICE);
298
-
bufl->buffers[y].len = sg->length;
299
-
if (unlikely(dma_mapping_error(dev, bufl->buffers[y].addr)))
300
-
goto err_map;
301
-
sg_nctr++;
302
-
}
303
-
bufl->num_bufs = sg_nctr;
304
-
bufl->num_mapped_bufs = sg_nctr;
305
-
306
-
*bl = bufl;
307
-
308
-
return 0;
309
-
310
-
err_map:
311
-
for (i = 0; i < n; i++)
312
-
if (!dma_mapping_error(dev, bufl->buffers[i].addr))
313
-
dma_unmap_single(dev, bufl->buffers[i].addr,
314
-
bufl->buffers[i].len,
315
-
DMA_FROM_DEVICE);
316
-
kfree(bufl);
317
-
*bl = NULL;
318
-
319
-
return -ENOMEM;
320
-
}
321
-
322
-
static void qat_bl_sgl_free_unmap(struct adf_accel_dev *accel_dev,
323
-
struct scatterlist *sgl,
324
-
struct qat_alg_buf_list *bl,
325
-
bool free_bl)
326
-
{
327
-
if (bl) {
328
-
qat_bl_sgl_unmap(accel_dev, bl);
329
-
330
-
if (free_bl)
331
-
kfree(bl);
332
-
}
333
-
if (sgl)
334
-
sgl_free(sgl);
335
-
}
336
-
337
-
static int qat_bl_sgl_alloc_map(struct adf_accel_dev *accel_dev,
338
-
struct scatterlist **sgl,
339
-
struct qat_alg_buf_list **bl,
340
-
unsigned int dlen,
341
-
gfp_t gfp)
342
-
{
343
-
struct scatterlist *dst;
344
-
int ret;
345
-
346
-
dst = sgl_alloc(dlen, gfp, NULL);
347
-
if (!dst) {
348
-
dev_err(&GET_DEV(accel_dev), "sg_alloc failed\n");
349
-
return -ENOMEM;
350
-
}
351
-
352
-
ret = qat_bl_sgl_map(accel_dev, dst, bl);
353
-
if (ret)
354
-
goto err;
355
-
356
-
*sgl = dst;
357
-
358
-
return 0;
359
-
360
-
err:
361
-
sgl_free(dst);
362
-
*sgl = NULL;
363
-
return ret;
364
-
}
365
-
366
-
int qat_bl_realloc_map_new_dst(struct adf_accel_dev *accel_dev,
367
-
struct scatterlist **sg,
368
-
unsigned int dlen,
369
-
struct qat_request_buffs *qat_bufs,
370
-
gfp_t gfp)
371
-
{
372
-
struct device *dev = &GET_DEV(accel_dev);
373
-
dma_addr_t new_blp = DMA_MAPPING_ERROR;
374
-
struct qat_alg_buf_list *new_bl;
375
-
struct scatterlist *new_sg;
376
-
size_t new_bl_size;
377
-
int ret;
378
-
379
-
ret = qat_bl_sgl_alloc_map(accel_dev, &new_sg, &new_bl, dlen, gfp);
380
-
if (ret)
381
-
return ret;
382
-
383
-
new_bl_size = struct_size(new_bl, buffers, new_bl->num_bufs);
384
-
385
-
/* Map new firmware SGL descriptor */
386
-
new_blp = dma_map_single(dev, new_bl, new_bl_size, DMA_TO_DEVICE);
387
-
if (unlikely(dma_mapping_error(dev, new_blp)))
388
-
goto err;
389
-
390
-
/* Unmap old firmware SGL descriptor */
391
-
dma_unmap_single(dev, qat_bufs->bloutp, qat_bufs->sz_out, DMA_TO_DEVICE);
392
-
393
-
/* Free and unmap old scatterlist */
394
-
qat_bl_sgl_free_unmap(accel_dev, *sg, qat_bufs->blout,
395
-
!qat_bufs->sgl_dst_valid);
396
-
397
-
qat_bufs->sgl_dst_valid = false;
398
-
qat_bufs->blout = new_bl;
399
-
qat_bufs->bloutp = new_blp;
400
-
qat_bufs->sz_out = new_bl_size;
401
-
402
-
*sg = new_sg;
403
-
404
-
return 0;
405
-
err:
406
-
qat_bl_sgl_free_unmap(accel_dev, new_sg, new_bl, true);
407
-
408
-
if (!dma_mapping_error(dev, new_blp))
409
-
dma_unmap_single(dev, new_blp, new_bl_size, DMA_TO_DEVICE);
410
-
411
-
return -ENOMEM;
412
-
}
-6
drivers/crypto/intel/qat/qat_common/qat_bl.h
-6
drivers/crypto/intel/qat/qat_common/qat_bl.h
+1
-84
drivers/crypto/intel/qat/qat_common/qat_comp_algs.c
+1
-84
drivers/crypto/intel/qat/qat_common/qat_comp_algs.c
···
29
29
int (*qat_comp_callback)(struct qat_compression_req *qat_req, void *resp);
30
30
};
31
31
32
-
struct qat_dst {
33
-
bool is_null;
34
-
int resubmitted;
35
-
};
36
-
37
32
struct qat_compression_req {
38
33
u8 req[QAT_COMP_REQ_SIZE];
39
34
struct qat_compression_ctx *qat_compression_ctx;
···
37
42
enum direction dir;
38
43
int actual_dlen;
39
44
struct qat_alg_req alg_req;
40
-
struct work_struct resubmit;
41
-
struct qat_dst dst;
42
45
};
43
46
44
47
static int qat_alg_send_dc_message(struct qat_compression_req *qat_req,
···
51
58
alg_req->backlog = &inst->backlog;
52
59
53
60
return qat_alg_send_message(alg_req);
54
-
}
55
-
56
-
static void qat_comp_resubmit(struct work_struct *work)
57
-
{
58
-
struct qat_compression_req *qat_req =
59
-
container_of(work, struct qat_compression_req, resubmit);
60
-
struct qat_compression_ctx *ctx = qat_req->qat_compression_ctx;
61
-
struct adf_accel_dev *accel_dev = ctx->inst->accel_dev;
62
-
struct qat_request_buffs *qat_bufs = &qat_req->buf;
63
-
struct qat_compression_instance *inst = ctx->inst;
64
-
struct acomp_req *areq = qat_req->acompress_req;
65
-
struct crypto_acomp *tfm = crypto_acomp_reqtfm(areq);
66
-
unsigned int dlen = CRYPTO_ACOMP_DST_MAX;
67
-
u8 *req = qat_req->req;
68
-
dma_addr_t dfbuf;
69
-
int ret;
70
-
71
-
areq->dlen = dlen;
72
-
73
-
dev_dbg(&GET_DEV(accel_dev), "[%s][%s] retry NULL dst request - dlen = %d\n",
74
-
crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm)),
75
-
qat_req->dir == COMPRESSION ? "comp" : "decomp", dlen);
76
-
77
-
ret = qat_bl_realloc_map_new_dst(accel_dev, &areq->dst, dlen, qat_bufs,
78
-
qat_algs_alloc_flags(&areq->base));
79
-
if (ret)
80
-
goto err;
81
-
82
-
qat_req->dst.resubmitted = true;
83
-
84
-
dfbuf = qat_req->buf.bloutp;
85
-
qat_comp_override_dst(req, dfbuf, dlen);
86
-
87
-
ret = qat_alg_send_dc_message(qat_req, inst, &areq->base);
88
-
if (ret != -ENOSPC)
89
-
return;
90
-
91
-
err:
92
-
qat_bl_free_bufl(accel_dev, qat_bufs);
93
-
acomp_request_complete(areq, ret);
94
61
}
95
62
96
63
static void qat_comp_generic_callback(struct qat_compression_req *qat_req,
···
83
130
areq->slen, areq->dlen, consumed, produced, cmp_err, xlt_err);
84
131
85
132
areq->dlen = 0;
86
-
87
-
if (qat_req->dir == DECOMPRESSION && qat_req->dst.is_null) {
88
-
if (cmp_err == ERR_CODE_OVERFLOW_ERROR) {
89
-
if (qat_req->dst.resubmitted) {
90
-
dev_dbg(&GET_DEV(accel_dev),
91
-
"Output does not fit destination buffer\n");
92
-
res = -EOVERFLOW;
93
-
goto end;
94
-
}
95
-
96
-
INIT_WORK(&qat_req->resubmit, qat_comp_resubmit);
97
-
adf_misc_wq_queue_work(&qat_req->resubmit);
98
-
return;
99
-
}
100
-
}
101
133
102
134
if (unlikely(status != ICP_QAT_FW_COMN_STATUS_FLAG_OK))
103
135
goto end;
···
183
245
if (!areq->src || !slen)
184
246
return -EINVAL;
185
247
186
-
if (areq->dst && !dlen)
248
+
if (!areq->dst || !dlen)
187
249
return -EINVAL;
188
-
189
-
qat_req->dst.is_null = false;
190
-
191
-
/* Handle acomp requests that require the allocation of a destination
192
-
* buffer. The size of the destination buffer is double the source
193
-
* buffer (rounded up to the size of a page) to fit the decompressed
194
-
* output or an expansion on the data for compression.
195
-
*/
196
-
if (!areq->dst) {
197
-
qat_req->dst.is_null = true;
198
-
199
-
dlen = round_up(2 * slen, PAGE_SIZE);
200
-
areq->dst = sgl_alloc(dlen, f, NULL);
201
-
if (!areq->dst)
202
-
return -ENOMEM;
203
-
204
-
dlen -= dhdr + dftr;
205
-
areq->dlen = dlen;
206
-
qat_req->dst.resubmitted = false;
207
-
}
208
250
209
251
if (dir == COMPRESSION) {
210
252
params.extra_dst_buff = inst->dc_data->ovf_buff_p;
···
247
329
.exit = qat_comp_alg_exit_tfm,
248
330
.compress = qat_comp_alg_compress,
249
331
.decompress = qat_comp_alg_decompress,
250
-
.dst_free = sgl_free,
251
332
.reqsize = sizeof(struct qat_compression_req),
252
333
}};
253
334
-10
drivers/crypto/intel/qat/qat_common/qat_comp_req.h
-10
drivers/crypto/intel/qat/qat_common/qat_comp_req.h
···
25
25
req_pars->out_buffer_sz = dlen;
26
26
}
27
27
28
-
static inline void qat_comp_override_dst(void *req, u64 dst, u32 dlen)
29
-
{
30
-
struct icp_qat_fw_comp_req *fw_req = req;
31
-
struct icp_qat_fw_comp_req_params *req_pars = &fw_req->comp_pars;
32
-
33
-
fw_req->comn_mid.dest_data_addr = dst;
34
-
fw_req->comn_mid.dst_length = dlen;
35
-
req_pars->out_buffer_sz = dlen;
36
-
}
37
-
38
28
static inline void qat_comp_create_compression_req(void *ctx, void *req,
39
29
u64 src, u32 slen,
40
30
u64 dst, u32 dlen,