]> Git Repo - linux.git/blob - drivers/crypto/hisilicon/zip/zip_crypto.c
drm/v3d: Use v3d_perfmon_find()
[linux.git] / drivers / crypto / hisilicon / zip / zip_crypto.c
1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2019 HiSilicon Limited. */
3 #include <crypto/internal/acompress.h>
4 #include <linux/bitfield.h>
5 #include <linux/bitmap.h>
6 #include <linux/dma-mapping.h>
7 #include <linux/scatterlist.h>
8 #include "zip.h"
9
10 /* hisi_zip_sqe dw3 */
11 #define HZIP_BD_STATUS_M                        GENMASK(7, 0)
12 /* hisi_zip_sqe dw7 */
13 #define HZIP_IN_SGE_DATA_OFFSET_M               GENMASK(23, 0)
14 #define HZIP_SQE_TYPE_M                         GENMASK(31, 28)
15 /* hisi_zip_sqe dw8 */
16 #define HZIP_OUT_SGE_DATA_OFFSET_M              GENMASK(23, 0)
17 /* hisi_zip_sqe dw9 */
18 #define HZIP_REQ_TYPE_M                         GENMASK(7, 0)
19 #define HZIP_ALG_TYPE_DEFLATE                   0x01
20 #define HZIP_BUF_TYPE_M                         GENMASK(11, 8)
21 #define HZIP_SGL                                0x1
22
23 #define HZIP_ALG_PRIORITY                       300
24 #define HZIP_SGL_SGE_NR                         10
25
26 #define HZIP_ALG_DEFLATE                        GENMASK(5, 4)
27
28 static DEFINE_MUTEX(zip_algs_lock);
29 static unsigned int zip_available_devs;
30
31 enum hisi_zip_alg_type {
32         HZIP_ALG_TYPE_COMP = 0,
33         HZIP_ALG_TYPE_DECOMP = 1,
34 };
35
36 enum {
37         HZIP_QPC_COMP,
38         HZIP_QPC_DECOMP,
39         HZIP_CTX_Q_NUM
40 };
41
42 #define COMP_NAME_TO_TYPE(alg_name)                                     \
43         (!strcmp((alg_name), "deflate") ? HZIP_ALG_TYPE_DEFLATE : 0)
44
45 struct hisi_zip_req {
46         struct acomp_req *req;
47         struct hisi_acc_hw_sgl *hw_src;
48         struct hisi_acc_hw_sgl *hw_dst;
49         dma_addr_t dma_src;
50         dma_addr_t dma_dst;
51         u16 req_id;
52 };
53
54 struct hisi_zip_req_q {
55         struct hisi_zip_req *q;
56         unsigned long *req_bitmap;
57         rwlock_t req_lock;
58         u16 size;
59 };
60
61 struct hisi_zip_qp_ctx {
62         struct hisi_qp *qp;
63         struct hisi_zip_req_q req_q;
64         struct hisi_acc_sgl_pool *sgl_pool;
65         struct hisi_zip *zip_dev;
66         struct hisi_zip_ctx *ctx;
67 };
68
69 struct hisi_zip_sqe_ops {
70         u8 sqe_type;
71         void (*fill_addr)(struct hisi_zip_sqe *sqe, struct hisi_zip_req *req);
72         void (*fill_buf_size)(struct hisi_zip_sqe *sqe, struct hisi_zip_req *req);
73         void (*fill_buf_type)(struct hisi_zip_sqe *sqe, u8 buf_type);
74         void (*fill_req_type)(struct hisi_zip_sqe *sqe, u8 req_type);
75         void (*fill_tag)(struct hisi_zip_sqe *sqe, struct hisi_zip_req *req);
76         void (*fill_sqe_type)(struct hisi_zip_sqe *sqe, u8 sqe_type);
77         u32 (*get_tag)(struct hisi_zip_sqe *sqe);
78         u32 (*get_status)(struct hisi_zip_sqe *sqe);
79         u32 (*get_dstlen)(struct hisi_zip_sqe *sqe);
80 };
81
82 struct hisi_zip_ctx {
83         struct hisi_zip_qp_ctx qp_ctx[HZIP_CTX_Q_NUM];
84         const struct hisi_zip_sqe_ops *ops;
85 };
86
87 static int sgl_sge_nr_set(const char *val, const struct kernel_param *kp)
88 {
89         int ret;
90         u16 n;
91
92         if (!val)
93                 return -EINVAL;
94
95         ret = kstrtou16(val, 10, &n);
96         if (ret || n == 0 || n > HISI_ACC_SGL_SGE_NR_MAX)
97                 return -EINVAL;
98
99         return param_set_ushort(val, kp);
100 }
101
102 static const struct kernel_param_ops sgl_sge_nr_ops = {
103         .set = sgl_sge_nr_set,
104         .get = param_get_ushort,
105 };
106
107 static u16 sgl_sge_nr = HZIP_SGL_SGE_NR;
108 module_param_cb(sgl_sge_nr, &sgl_sge_nr_ops, &sgl_sge_nr, 0444);
109 MODULE_PARM_DESC(sgl_sge_nr, "Number of sge in sgl(1-255)");
110
111 static struct hisi_zip_req *hisi_zip_create_req(struct hisi_zip_qp_ctx *qp_ctx,
112                                                 struct acomp_req *req)
113 {
114         struct hisi_zip_req_q *req_q = &qp_ctx->req_q;
115         struct hisi_zip_req *q = req_q->q;
116         struct hisi_zip_req *req_cache;
117         int req_id;
118
119         write_lock(&req_q->req_lock);
120
121         req_id = find_first_zero_bit(req_q->req_bitmap, req_q->size);
122         if (req_id >= req_q->size) {
123                 write_unlock(&req_q->req_lock);
124                 dev_dbg(&qp_ctx->qp->qm->pdev->dev, "req cache is full!\n");
125                 return ERR_PTR(-EAGAIN);
126         }
127         set_bit(req_id, req_q->req_bitmap);
128
129         write_unlock(&req_q->req_lock);
130
131         req_cache = q + req_id;
132         req_cache->req_id = req_id;
133         req_cache->req = req;
134
135         return req_cache;
136 }
137
138 static void hisi_zip_remove_req(struct hisi_zip_qp_ctx *qp_ctx,
139                                 struct hisi_zip_req *req)
140 {
141         struct hisi_zip_req_q *req_q = &qp_ctx->req_q;
142
143         write_lock(&req_q->req_lock);
144         clear_bit(req->req_id, req_q->req_bitmap);
145         write_unlock(&req_q->req_lock);
146 }
147
148 static void hisi_zip_fill_addr(struct hisi_zip_sqe *sqe, struct hisi_zip_req *req)
149 {
150         sqe->source_addr_l = lower_32_bits(req->dma_src);
151         sqe->source_addr_h = upper_32_bits(req->dma_src);
152         sqe->dest_addr_l = lower_32_bits(req->dma_dst);
153         sqe->dest_addr_h = upper_32_bits(req->dma_dst);
154 }
155
156 static void hisi_zip_fill_buf_size(struct hisi_zip_sqe *sqe, struct hisi_zip_req *req)
157 {
158         struct acomp_req *a_req = req->req;
159
160         sqe->input_data_length = a_req->slen;
161         sqe->dest_avail_out = a_req->dlen;
162 }
163
164 static void hisi_zip_fill_buf_type(struct hisi_zip_sqe *sqe, u8 buf_type)
165 {
166         u32 val;
167
168         val = sqe->dw9 & ~HZIP_BUF_TYPE_M;
169         val |= FIELD_PREP(HZIP_BUF_TYPE_M, buf_type);
170         sqe->dw9 = val;
171 }
172
173 static void hisi_zip_fill_req_type(struct hisi_zip_sqe *sqe, u8 req_type)
174 {
175         u32 val;
176
177         val = sqe->dw9 & ~HZIP_REQ_TYPE_M;
178         val |= FIELD_PREP(HZIP_REQ_TYPE_M, req_type);
179         sqe->dw9 = val;
180 }
181
182 static void hisi_zip_fill_tag(struct hisi_zip_sqe *sqe, struct hisi_zip_req *req)
183 {
184         sqe->dw26 = req->req_id;
185 }
186
187 static void hisi_zip_fill_sqe_type(struct hisi_zip_sqe *sqe, u8 sqe_type)
188 {
189         u32 val;
190
191         val = sqe->dw7 & ~HZIP_SQE_TYPE_M;
192         val |= FIELD_PREP(HZIP_SQE_TYPE_M, sqe_type);
193         sqe->dw7 = val;
194 }
195
196 static void hisi_zip_fill_sqe(struct hisi_zip_ctx *ctx, struct hisi_zip_sqe *sqe,
197                               u8 req_type, struct hisi_zip_req *req)
198 {
199         const struct hisi_zip_sqe_ops *ops = ctx->ops;
200
201         memset(sqe, 0, sizeof(struct hisi_zip_sqe));
202
203         ops->fill_addr(sqe, req);
204         ops->fill_buf_size(sqe, req);
205         ops->fill_buf_type(sqe, HZIP_SGL);
206         ops->fill_req_type(sqe, req_type);
207         ops->fill_tag(sqe, req);
208         ops->fill_sqe_type(sqe, ops->sqe_type);
209 }
210
211 static int hisi_zip_do_work(struct hisi_zip_qp_ctx *qp_ctx,
212                             struct hisi_zip_req *req)
213 {
214         struct hisi_acc_sgl_pool *pool = qp_ctx->sgl_pool;
215         struct hisi_zip_dfx *dfx = &qp_ctx->zip_dev->dfx;
216         struct acomp_req *a_req = req->req;
217         struct hisi_qp *qp = qp_ctx->qp;
218         struct device *dev = &qp->qm->pdev->dev;
219         struct hisi_zip_sqe zip_sqe;
220         int ret;
221
222         if (unlikely(!a_req->src || !a_req->slen || !a_req->dst || !a_req->dlen))
223                 return -EINVAL;
224
225         req->hw_src = hisi_acc_sg_buf_map_to_hw_sgl(dev, a_req->src, pool,
226                                                     req->req_id << 1, &req->dma_src);
227         if (IS_ERR(req->hw_src)) {
228                 dev_err(dev, "failed to map the src buffer to hw sgl (%ld)!\n",
229                         PTR_ERR(req->hw_src));
230                 return PTR_ERR(req->hw_src);
231         }
232
233         req->hw_dst = hisi_acc_sg_buf_map_to_hw_sgl(dev, a_req->dst, pool,
234                                                     (req->req_id << 1) + 1,
235                                                     &req->dma_dst);
236         if (IS_ERR(req->hw_dst)) {
237                 ret = PTR_ERR(req->hw_dst);
238                 dev_err(dev, "failed to map the dst buffer to hw slg (%d)!\n",
239                         ret);
240                 goto err_unmap_input;
241         }
242
243         hisi_zip_fill_sqe(qp_ctx->ctx, &zip_sqe, qp->req_type, req);
244
245         /* send command to start a task */
246         atomic64_inc(&dfx->send_cnt);
247         ret = hisi_qp_send(qp, &zip_sqe);
248         if (unlikely(ret < 0)) {
249                 atomic64_inc(&dfx->send_busy_cnt);
250                 ret = -EAGAIN;
251                 dev_dbg_ratelimited(dev, "failed to send request!\n");
252                 goto err_unmap_output;
253         }
254
255         return -EINPROGRESS;
256
257 err_unmap_output:
258         hisi_acc_sg_buf_unmap(dev, a_req->dst, req->hw_dst);
259 err_unmap_input:
260         hisi_acc_sg_buf_unmap(dev, a_req->src, req->hw_src);
261         return ret;
262 }
263
264 static u32 hisi_zip_get_tag(struct hisi_zip_sqe *sqe)
265 {
266         return sqe->dw26;
267 }
268
269 static u32 hisi_zip_get_status(struct hisi_zip_sqe *sqe)
270 {
271         return sqe->dw3 & HZIP_BD_STATUS_M;
272 }
273
274 static u32 hisi_zip_get_dstlen(struct hisi_zip_sqe *sqe)
275 {
276         return sqe->produced;
277 }
278
279 static void hisi_zip_acomp_cb(struct hisi_qp *qp, void *data)
280 {
281         struct hisi_zip_qp_ctx *qp_ctx = qp->qp_ctx;
282         const struct hisi_zip_sqe_ops *ops = qp_ctx->ctx->ops;
283         struct hisi_zip_dfx *dfx = &qp_ctx->zip_dev->dfx;
284         struct hisi_zip_req_q *req_q = &qp_ctx->req_q;
285         struct device *dev = &qp->qm->pdev->dev;
286         struct hisi_zip_sqe *sqe = data;
287         u32 tag = ops->get_tag(sqe);
288         struct hisi_zip_req *req = req_q->q + tag;
289         struct acomp_req *acomp_req = req->req;
290         int err = 0;
291         u32 status;
292
293         atomic64_inc(&dfx->recv_cnt);
294         status = ops->get_status(sqe);
295         if (unlikely(status != 0 && status != HZIP_NC_ERR)) {
296                 dev_err(dev, "%scompress fail in qp%u: %u, output: %u\n",
297                         (qp->alg_type == 0) ? "" : "de", qp->qp_id, status,
298                         sqe->produced);
299                 atomic64_inc(&dfx->err_bd_cnt);
300                 err = -EIO;
301         }
302
303         hisi_acc_sg_buf_unmap(dev, acomp_req->src, req->hw_src);
304         hisi_acc_sg_buf_unmap(dev, acomp_req->dst, req->hw_dst);
305
306         acomp_req->dlen = ops->get_dstlen(sqe);
307
308         if (acomp_req->base.complete)
309                 acomp_request_complete(acomp_req, err);
310
311         hisi_zip_remove_req(qp_ctx, req);
312 }
313
314 static int hisi_zip_acompress(struct acomp_req *acomp_req)
315 {
316         struct hisi_zip_ctx *ctx = crypto_tfm_ctx(acomp_req->base.tfm);
317         struct hisi_zip_qp_ctx *qp_ctx = &ctx->qp_ctx[HZIP_QPC_COMP];
318         struct device *dev = &qp_ctx->qp->qm->pdev->dev;
319         struct hisi_zip_req *req;
320         int ret;
321
322         req = hisi_zip_create_req(qp_ctx, acomp_req);
323         if (IS_ERR(req))
324                 return PTR_ERR(req);
325
326         ret = hisi_zip_do_work(qp_ctx, req);
327         if (unlikely(ret != -EINPROGRESS)) {
328                 dev_info_ratelimited(dev, "failed to do compress (%d)!\n", ret);
329                 hisi_zip_remove_req(qp_ctx, req);
330         }
331
332         return ret;
333 }
334
335 static int hisi_zip_adecompress(struct acomp_req *acomp_req)
336 {
337         struct hisi_zip_ctx *ctx = crypto_tfm_ctx(acomp_req->base.tfm);
338         struct hisi_zip_qp_ctx *qp_ctx = &ctx->qp_ctx[HZIP_QPC_DECOMP];
339         struct device *dev = &qp_ctx->qp->qm->pdev->dev;
340         struct hisi_zip_req *req;
341         int ret;
342
343         req = hisi_zip_create_req(qp_ctx, acomp_req);
344         if (IS_ERR(req))
345                 return PTR_ERR(req);
346
347         ret = hisi_zip_do_work(qp_ctx, req);
348         if (unlikely(ret != -EINPROGRESS)) {
349                 dev_info_ratelimited(dev, "failed to do decompress (%d)!\n",
350                                      ret);
351                 hisi_zip_remove_req(qp_ctx, req);
352         }
353
354         return ret;
355 }
356
357 static int hisi_zip_start_qp(struct hisi_qp *qp, struct hisi_zip_qp_ctx *qp_ctx,
358                              int alg_type, int req_type)
359 {
360         struct device *dev = &qp->qm->pdev->dev;
361         int ret;
362
363         qp->req_type = req_type;
364         qp->alg_type = alg_type;
365         qp->qp_ctx = qp_ctx;
366
367         ret = hisi_qm_start_qp(qp, 0);
368         if (ret < 0) {
369                 dev_err(dev, "failed to start qp (%d)!\n", ret);
370                 return ret;
371         }
372
373         qp_ctx->qp = qp;
374
375         return 0;
376 }
377
378 static void hisi_zip_release_qp(struct hisi_zip_qp_ctx *qp_ctx)
379 {
380         hisi_qm_stop_qp(qp_ctx->qp);
381         hisi_qm_free_qps(&qp_ctx->qp, 1);
382 }
383
384 static const struct hisi_zip_sqe_ops hisi_zip_ops = {
385         .sqe_type               = 0x3,
386         .fill_addr              = hisi_zip_fill_addr,
387         .fill_buf_size          = hisi_zip_fill_buf_size,
388         .fill_buf_type          = hisi_zip_fill_buf_type,
389         .fill_req_type          = hisi_zip_fill_req_type,
390         .fill_tag               = hisi_zip_fill_tag,
391         .fill_sqe_type          = hisi_zip_fill_sqe_type,
392         .get_tag                = hisi_zip_get_tag,
393         .get_status             = hisi_zip_get_status,
394         .get_dstlen             = hisi_zip_get_dstlen,
395 };
396
397 static int hisi_zip_ctx_init(struct hisi_zip_ctx *hisi_zip_ctx, u8 req_type, int node)
398 {
399         struct hisi_qp *qps[HZIP_CTX_Q_NUM] = { NULL };
400         struct hisi_zip_qp_ctx *qp_ctx;
401         struct hisi_zip *hisi_zip;
402         int ret, i, j;
403
404         ret = zip_create_qps(qps, HZIP_CTX_Q_NUM, node);
405         if (ret) {
406                 pr_err("failed to create zip qps (%d)!\n", ret);
407                 return -ENODEV;
408         }
409
410         hisi_zip = container_of(qps[0]->qm, struct hisi_zip, qm);
411
412         for (i = 0; i < HZIP_CTX_Q_NUM; i++) {
413                 /* alg_type = 0 for compress, 1 for decompress in hw sqe */
414                 qp_ctx = &hisi_zip_ctx->qp_ctx[i];
415                 qp_ctx->ctx = hisi_zip_ctx;
416                 ret = hisi_zip_start_qp(qps[i], qp_ctx, i, req_type);
417                 if (ret) {
418                         for (j = i - 1; j >= 0; j--)
419                                 hisi_qm_stop_qp(hisi_zip_ctx->qp_ctx[j].qp);
420
421                         hisi_qm_free_qps(qps, HZIP_CTX_Q_NUM);
422                         return ret;
423                 }
424
425                 qp_ctx->zip_dev = hisi_zip;
426         }
427
428         hisi_zip_ctx->ops = &hisi_zip_ops;
429
430         return 0;
431 }
432
433 static void hisi_zip_ctx_exit(struct hisi_zip_ctx *hisi_zip_ctx)
434 {
435         int i;
436
437         for (i = 0; i < HZIP_CTX_Q_NUM; i++)
438                 hisi_zip_release_qp(&hisi_zip_ctx->qp_ctx[i]);
439 }
440
441 static int hisi_zip_create_req_q(struct hisi_zip_ctx *ctx)
442 {
443         u16 q_depth = ctx->qp_ctx[0].qp->sq_depth;
444         struct hisi_zip_req_q *req_q;
445         int i, ret;
446
447         for (i = 0; i < HZIP_CTX_Q_NUM; i++) {
448                 req_q = &ctx->qp_ctx[i].req_q;
449                 req_q->size = q_depth;
450
451                 req_q->req_bitmap = bitmap_zalloc(req_q->size, GFP_KERNEL);
452                 if (!req_q->req_bitmap) {
453                         ret = -ENOMEM;
454                         if (i == 0)
455                                 return ret;
456
457                         goto err_free_comp_q;
458                 }
459                 rwlock_init(&req_q->req_lock);
460
461                 req_q->q = kcalloc(req_q->size, sizeof(struct hisi_zip_req),
462                                    GFP_KERNEL);
463                 if (!req_q->q) {
464                         ret = -ENOMEM;
465                         if (i == 0)
466                                 goto err_free_comp_bitmap;
467                         else
468                                 goto err_free_decomp_bitmap;
469                 }
470         }
471
472         return 0;
473
474 err_free_decomp_bitmap:
475         bitmap_free(ctx->qp_ctx[HZIP_QPC_DECOMP].req_q.req_bitmap);
476 err_free_comp_q:
477         kfree(ctx->qp_ctx[HZIP_QPC_COMP].req_q.q);
478 err_free_comp_bitmap:
479         bitmap_free(ctx->qp_ctx[HZIP_QPC_COMP].req_q.req_bitmap);
480         return ret;
481 }
482
483 static void hisi_zip_release_req_q(struct hisi_zip_ctx *ctx)
484 {
485         int i;
486
487         for (i = 0; i < HZIP_CTX_Q_NUM; i++) {
488                 kfree(ctx->qp_ctx[i].req_q.q);
489                 bitmap_free(ctx->qp_ctx[i].req_q.req_bitmap);
490         }
491 }
492
493 static int hisi_zip_create_sgl_pool(struct hisi_zip_ctx *ctx)
494 {
495         u16 q_depth = ctx->qp_ctx[0].qp->sq_depth;
496         struct hisi_zip_qp_ctx *tmp;
497         struct device *dev;
498         int i;
499
500         for (i = 0; i < HZIP_CTX_Q_NUM; i++) {
501                 tmp = &ctx->qp_ctx[i];
502                 dev = &tmp->qp->qm->pdev->dev;
503                 tmp->sgl_pool = hisi_acc_create_sgl_pool(dev, q_depth << 1,
504                                                          sgl_sge_nr);
505                 if (IS_ERR(tmp->sgl_pool)) {
506                         if (i == 1)
507                                 goto err_free_sgl_pool0;
508                         return -ENOMEM;
509                 }
510         }
511
512         return 0;
513
514 err_free_sgl_pool0:
515         hisi_acc_free_sgl_pool(&ctx->qp_ctx[HZIP_QPC_COMP].qp->qm->pdev->dev,
516                                ctx->qp_ctx[HZIP_QPC_COMP].sgl_pool);
517         return -ENOMEM;
518 }
519
520 static void hisi_zip_release_sgl_pool(struct hisi_zip_ctx *ctx)
521 {
522         int i;
523
524         for (i = 0; i < HZIP_CTX_Q_NUM; i++)
525                 hisi_acc_free_sgl_pool(&ctx->qp_ctx[i].qp->qm->pdev->dev,
526                                        ctx->qp_ctx[i].sgl_pool);
527 }
528
529 static void hisi_zip_set_acomp_cb(struct hisi_zip_ctx *ctx,
530                                   void (*fn)(struct hisi_qp *, void *))
531 {
532         int i;
533
534         for (i = 0; i < HZIP_CTX_Q_NUM; i++)
535                 ctx->qp_ctx[i].qp->req_cb = fn;
536 }
537
538 static int hisi_zip_acomp_init(struct crypto_acomp *tfm)
539 {
540         const char *alg_name = crypto_tfm_alg_name(&tfm->base);
541         struct hisi_zip_ctx *ctx = crypto_tfm_ctx(&tfm->base);
542         struct device *dev;
543         int ret;
544
545         ret = hisi_zip_ctx_init(ctx, COMP_NAME_TO_TYPE(alg_name), tfm->base.node);
546         if (ret) {
547                 pr_err("failed to init ctx (%d)!\n", ret);
548                 return ret;
549         }
550
551         dev = &ctx->qp_ctx[0].qp->qm->pdev->dev;
552
553         ret = hisi_zip_create_req_q(ctx);
554         if (ret) {
555                 dev_err(dev, "failed to create request queue (%d)!\n", ret);
556                 goto err_ctx_exit;
557         }
558
559         ret = hisi_zip_create_sgl_pool(ctx);
560         if (ret) {
561                 dev_err(dev, "failed to create sgl pool (%d)!\n", ret);
562                 goto err_release_req_q;
563         }
564
565         hisi_zip_set_acomp_cb(ctx, hisi_zip_acomp_cb);
566
567         return 0;
568
569 err_release_req_q:
570         hisi_zip_release_req_q(ctx);
571 err_ctx_exit:
572         hisi_zip_ctx_exit(ctx);
573         return ret;
574 }
575
576 static void hisi_zip_acomp_exit(struct crypto_acomp *tfm)
577 {
578         struct hisi_zip_ctx *ctx = crypto_tfm_ctx(&tfm->base);
579
580         hisi_zip_set_acomp_cb(ctx, NULL);
581         hisi_zip_release_sgl_pool(ctx);
582         hisi_zip_release_req_q(ctx);
583         hisi_zip_ctx_exit(ctx);
584 }
585
586 static struct acomp_alg hisi_zip_acomp_deflate = {
587         .init                   = hisi_zip_acomp_init,
588         .exit                   = hisi_zip_acomp_exit,
589         .compress               = hisi_zip_acompress,
590         .decompress             = hisi_zip_adecompress,
591         .base                   = {
592                 .cra_name               = "deflate",
593                 .cra_driver_name        = "hisi-deflate-acomp",
594                 .cra_flags              = CRYPTO_ALG_ASYNC,
595                 .cra_module             = THIS_MODULE,
596                 .cra_priority           = HZIP_ALG_PRIORITY,
597                 .cra_ctxsize            = sizeof(struct hisi_zip_ctx),
598         }
599 };
600
601 static int hisi_zip_register_deflate(struct hisi_qm *qm)
602 {
603         int ret;
604
605         if (!hisi_zip_alg_support(qm, HZIP_ALG_DEFLATE))
606                 return 0;
607
608         ret = crypto_register_acomp(&hisi_zip_acomp_deflate);
609         if (ret)
610                 dev_err(&qm->pdev->dev, "failed to register to deflate (%d)!\n", ret);
611
612         return ret;
613 }
614
615 static void hisi_zip_unregister_deflate(struct hisi_qm *qm)
616 {
617         if (!hisi_zip_alg_support(qm, HZIP_ALG_DEFLATE))
618                 return;
619
620         crypto_unregister_acomp(&hisi_zip_acomp_deflate);
621 }
622
623 int hisi_zip_register_to_crypto(struct hisi_qm *qm)
624 {
625         int ret = 0;
626
627         mutex_lock(&zip_algs_lock);
628         if (zip_available_devs++)
629                 goto unlock;
630
631         ret = hisi_zip_register_deflate(qm);
632         if (ret)
633                 zip_available_devs--;
634
635 unlock:
636         mutex_unlock(&zip_algs_lock);
637         return ret;
638 }
639
640 void hisi_zip_unregister_from_crypto(struct hisi_qm *qm)
641 {
642         mutex_lock(&zip_algs_lock);
643         if (--zip_available_devs)
644                 goto unlock;
645
646         hisi_zip_unregister_deflate(qm);
647
648 unlock:
649         mutex_unlock(&zip_algs_lock);
650 }
This page took 0.066093 seconds and 4 git commands to generate.