Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0-or-later */
       2             : /*
       3             :  * Synchronous Compression operations
       4             :  *
       5             :  * Copyright 2015 LG Electronics Inc.
       6             :  * Copyright (c) 2016, Intel Corporation
       7             :  * Author: Giovanni Cabiddu <giovanni.cabiddu@intel.com>
       8             :  */
       9             : #ifndef _CRYPTO_SCOMP_INT_H
      10             : #define _CRYPTO_SCOMP_INT_H
      11             : #include <linux/crypto.h>
      12             : 
      13             : #define SCOMP_SCRATCH_SIZE      131072
      14             : 
      15             : struct crypto_scomp {
      16             :         struct crypto_tfm base;
      17             : };
      18             : 
      19             : /**
      20             :  * struct scomp_alg - synchronous compression algorithm
      21             :  *
      22             :  * @alloc_ctx:  Function allocates algorithm specific context
      23             :  * @free_ctx:   Function frees context allocated with alloc_ctx
      24             :  * @compress:   Function performs a compress operation
      25             :  * @decompress: Function performs a de-compress operation
      26             :  * @base:       Common crypto API algorithm data structure
      27             :  */
      28             : struct scomp_alg {
      29             :         void *(*alloc_ctx)(struct crypto_scomp *tfm);
      30             :         void (*free_ctx)(struct crypto_scomp *tfm, void *ctx);
      31             :         int (*compress)(struct crypto_scomp *tfm, const u8 *src,
      32             :                         unsigned int slen, u8 *dst, unsigned int *dlen,
      33             :                         void *ctx);
      34             :         int (*decompress)(struct crypto_scomp *tfm, const u8 *src,
      35             :                           unsigned int slen, u8 *dst, unsigned int *dlen,
      36             :                           void *ctx);
      37             :         struct crypto_alg base;
      38             : };
      39             : 
      40           0 : static inline struct scomp_alg *__crypto_scomp_alg(struct crypto_alg *alg)
      41             : {
      42           0 :         return container_of(alg, struct scomp_alg, base);
      43             : }
      44             : 
      45             : static inline struct crypto_scomp *__crypto_scomp_tfm(struct crypto_tfm *tfm)
      46             : {
      47             :         return container_of(tfm, struct crypto_scomp, base);
      48             : }
      49             : 
      50           0 : static inline struct crypto_tfm *crypto_scomp_tfm(struct crypto_scomp *tfm)
      51             : {
      52           0 :         return &tfm->base;
      53             : }
      54             : 
      55           0 : static inline void crypto_free_scomp(struct crypto_scomp *tfm)
      56             : {
      57           0 :         crypto_destroy_tfm(tfm, crypto_scomp_tfm(tfm));
      58             : }
      59             : 
      60           0 : static inline struct scomp_alg *crypto_scomp_alg(struct crypto_scomp *tfm)
      61             : {
      62           0 :         return __crypto_scomp_alg(crypto_scomp_tfm(tfm)->__crt_alg);
      63             : }
      64             : 
      65           0 : static inline void *crypto_scomp_alloc_ctx(struct crypto_scomp *tfm)
      66             : {
      67           0 :         return crypto_scomp_alg(tfm)->alloc_ctx(tfm);
      68             : }
      69             : 
      70           0 : static inline void crypto_scomp_free_ctx(struct crypto_scomp *tfm,
      71             :                                          void *ctx)
      72             : {
      73           0 :         return crypto_scomp_alg(tfm)->free_ctx(tfm, ctx);
      74             : }
      75             : 
      76           0 : static inline int crypto_scomp_compress(struct crypto_scomp *tfm,
      77             :                                         const u8 *src, unsigned int slen,
      78             :                                         u8 *dst, unsigned int *dlen, void *ctx)
      79             : {
      80           0 :         return crypto_scomp_alg(tfm)->compress(tfm, src, slen, dst, dlen, ctx);
      81             : }
      82             : 
      83           0 : static inline int crypto_scomp_decompress(struct crypto_scomp *tfm,
      84             :                                           const u8 *src, unsigned int slen,
      85             :                                           u8 *dst, unsigned int *dlen,
      86             :                                           void *ctx)
      87             : {
      88           0 :         return crypto_scomp_alg(tfm)->decompress(tfm, src, slen, dst, dlen,
      89             :                                                  ctx);
      90             : }
      91             : 
      92             : int crypto_init_scomp_ops_async(struct crypto_tfm *tfm);
      93             : struct acomp_req *crypto_acomp_scomp_alloc_ctx(struct acomp_req *req);
      94             : void crypto_acomp_scomp_free_ctx(struct acomp_req *req);
      95             : 
      96             : /**
      97             :  * crypto_register_scomp() -- Register synchronous compression algorithm
      98             :  *
      99             :  * Function registers an implementation of a synchronous
     100             :  * compression algorithm
     101             :  *
     102             :  * @alg:        algorithm definition
     103             :  *
     104             :  * Return: zero on success; error code in case of error
     105             :  */
     106             : int crypto_register_scomp(struct scomp_alg *alg);
     107             : 
     108             : /**
     109             :  * crypto_unregister_scomp() -- Unregister synchronous compression algorithm
     110             :  *
     111             :  * Function unregisters an implementation of a synchronous
     112             :  * compression algorithm
     113             :  *
     114             :  * @alg:        algorithm definition
     115             :  */
     116             : void crypto_unregister_scomp(struct scomp_alg *alg);
     117             : 
     118             : int crypto_register_scomps(struct scomp_alg *algs, int count);
     119             : void crypto_unregister_scomps(struct scomp_alg *algs, int count);
     120             : 
     121             : #endif