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 }