include/crypto/internal/scompress.h

   1 /*
   2  * Synchronous Compression operations
   3  *
   4  * Copyright 2015 LG Electronics Inc.
   5  * Copyright (c) 2016, Intel Corporation
   6  * Author: Giovanni Cabiddu <giovanni.cabiddu@intel.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the Free
  10  * Software Foundation; either version 2 of the License, or (at your option)
  11  * any later version.
  12  *
  13  */
  14 #ifndef _CRYPTO_SCOMP_INT_H
  15 #define _CRYPTO_SCOMP_INT_H
  16 #include <linux/crypto.h>
  17
  18 #define SCOMP_SCRATCH_SIZE      131072
  19
  20 struct crypto_scomp {
  21         struct crypto_tfm base;
  22 };
  23
  24 /**
  25  * struct scomp_alg - synchronous compression algorithm
  26  *
  27  * @alloc_ctx:  Function allocates algorithm specific context
  28  * @free_ctx:   Function frees context allocated with alloc_ctx
  29  * @compress:   Function performs a compress operation
  30  * @decompress: Function performs a de-compress operation
  31  * @init:       Initialize the cryptographic transformation object.
  32  *              This function is used to initialize the cryptographic
  33  *              transformation object. This function is called only once at
  34  *              the instantiation time, right after the transformation context
  35  *              was allocated. In case the cryptographic hardware has some
  36  *              special requirements which need to be handled by software, this
  37  *              function shall check for the precise requirement of the
  38  *              transformation and put any software fallbacks in place.
  39  * @exit:       Deinitialize the cryptographic transformation object. This is a
  40  *              counterpart to @init, used to remove various changes set in
  41  *              @init.
  42  * @base:       Common crypto API algorithm data structure
  43  */
  44 struct scomp_alg {
  45         void *(*alloc_ctx)(struct crypto_scomp *tfm);
  46         void (*free_ctx)(struct crypto_scomp *tfm, void *ctx);
  47         int (*compress)(struct crypto_scomp *tfm, const u8 *src,
  48                         unsigned int slen, u8 *dst, unsigned int *dlen,
  49                         void *ctx);
  50         int (*decompress)(struct crypto_scomp *tfm, const u8 *src,
  51                           unsigned int slen, u8 *dst, unsigned int *dlen,
  52                           void *ctx);
  53         struct crypto_alg base;
  54 };
  55
  56 static inline struct scomp_alg *__crypto_scomp_alg(struct crypto_alg *alg)
  57 {
  58         return container_of(alg, struct scomp_alg, base);
  59 }
  60
  61 static inline struct crypto_scomp *__crypto_scomp_tfm(struct crypto_tfm *tfm)
  62 {
  63         return container_of(tfm, struct crypto_scomp, base);
  64 }
  65
  66 static inline struct crypto_tfm *crypto_scomp_tfm(struct crypto_scomp *tfm)
  67 {
  68         return &tfm->base;
  69 }
  70
  71 static inline void crypto_free_scomp(struct crypto_scomp *tfm)
  72 {
  73         crypto_destroy_tfm(tfm, crypto_scomp_tfm(tfm));
  74 }
  75
  76 static inline struct scomp_alg *crypto_scomp_alg(struct crypto_scomp *tfm)
  77 {
  78         return __crypto_scomp_alg(crypto_scomp_tfm(tfm)->__crt_alg);
  79 }
  80
  81 static inline void *crypto_scomp_alloc_ctx(struct crypto_scomp *tfm)
  82 {
  83         return crypto_scomp_alg(tfm)->alloc_ctx(tfm);
  84 }
  85
  86 static inline void crypto_scomp_free_ctx(struct crypto_scomp *tfm,
  87                                          void *ctx)
  88 {
  89         return crypto_scomp_alg(tfm)->free_ctx(tfm, ctx);
  90 }
  91
  92 static inline int crypto_scomp_compress(struct crypto_scomp *tfm,
  93                                         const u8 *src, unsigned int slen,
  94                                         u8 *dst, unsigned int *dlen, void *ctx)
  95 {
  96         return crypto_scomp_alg(tfm)->compress(tfm, src, slen, dst, dlen, ctx);
  97 }
  98
  99 static inline int crypto_scomp_decompress(struct crypto_scomp *tfm,
 100                                           const u8 *src, unsigned int slen,
 101                                           u8 *dst, unsigned int *dlen,
 102                                           void *ctx)
 103 {
 104         return crypto_scomp_alg(tfm)->decompress(tfm, src, slen, dst, dlen,
 105                                                  ctx);
 106 }
 107
 108 int crypto_init_scomp_ops_async(struct crypto_tfm *tfm);
 109 struct acomp_req *crypto_acomp_scomp_alloc_ctx(struct acomp_req *req);
 110 void crypto_acomp_scomp_free_ctx(struct acomp_req *req);
 111
 112 /**
 113  * crypto_register_scomp() -- Register synchronous compression algorithm
 114  *
 115  * Function registers an implementation of a synchronous
 116  * compression algorithm
 117  *
 118  * @alg:        algorithm definition
 119  *
 120  * Return: zero on success; error code in case of error
 121  */
 122 int crypto_register_scomp(struct scomp_alg *alg);
 123
 124 /**
 125  * crypto_unregister_scomp() -- Unregister synchronous compression algorithm
 126  *
 127  * Function unregisters an implementation of a synchronous
 128  * compression algorithm
 129  *
 130  * @alg:        algorithm definition
 131  *
 132  * Return: zero on success; error code in case of error
 133  */
 134 int crypto_unregister_scomp(struct scomp_alg *alg);
 135
 136 int crypto_register_scomps(struct scomp_alg *algs, int count);
 137 void crypto_unregister_scomps(struct scomp_alg *algs, int count);
 138
 139 #endif