drivers/compress/zlib/zlib_pmd.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Cavium Networks
   3  */
   4
   5 #include <rte_bus_vdev.h>
   6 #include <rte_common.h>
   7
   8 #include "zlib_pmd_private.h"
   9
  10 /** Parse comp xform and set private xform/stream parameters */
  11 int
  12 zlib_set_stream_parameters(const struct rte_comp_xform *xform,
  13                 struct zlib_stream *stream)
  14 {
  15         int strategy, level, wbits;
  16         z_stream *strm = &stream->strm;
  17
  18         /* allocate deflate state */
  19         strm->zalloc = Z_NULL;
  20         strm->zfree = Z_NULL;
  21         strm->opaque = Z_NULL;
  22
  23         switch (xform->type) {
  24         case RTE_COMP_COMPRESS:
  25                 /** Compression window bits */
  26                 switch (xform->compress.algo) {
  27                 case RTE_COMP_ALGO_DEFLATE:
  28                         wbits = -(xform->compress.window_size);
  29                         break;
  30                 default:
  31                         ZLIB_PMD_ERR("Compression algorithm not supported\n");
  32                         return -1;
  33                 }
  34                 /** Compression Level */
  35                 switch (xform->compress.level) {
  36                 case RTE_COMP_LEVEL_PMD_DEFAULT:
  37                         level = Z_DEFAULT_COMPRESSION;
  38                         break;
  39                 case RTE_COMP_LEVEL_NONE:
  40                         level = Z_NO_COMPRESSION;
  41                         break;
  42                 case RTE_COMP_LEVEL_MIN:
  43                         level = Z_BEST_SPEED;
  44                         break;
  45                 case RTE_COMP_LEVEL_MAX:
  46                         level = Z_BEST_COMPRESSION;
  47                         break;
  48                 default:
  49                         level = xform->compress.level;
  50                         if (level < RTE_COMP_LEVEL_MIN ||
  51                                         level > RTE_COMP_LEVEL_MAX) {
  52                                 ZLIB_PMD_ERR("Compression level %d "
  53                                                 "not supported\n",
  54                                                 level);
  55                                 return -1;
  56                         }
  57                         break;
  58                 }
  59                 /** Compression strategy */
  60                 switch (xform->compress.deflate.huffman) {
  61                 case RTE_COMP_HUFFMAN_DEFAULT:
  62                         strategy = Z_DEFAULT_STRATEGY;
  63                         break;
  64                 case RTE_COMP_HUFFMAN_FIXED:
  65                         strategy = Z_FIXED;
  66                         break;
  67                 case RTE_COMP_HUFFMAN_DYNAMIC:
  68                         strategy = Z_DEFAULT_STRATEGY;
  69                         break;
  70                 default:
  71                         ZLIB_PMD_ERR("Compression strategy not supported\n");
  72                         return -1;
  73                 }
  74                 if (deflateInit2(strm, level,
  75                                         Z_DEFLATED, wbits,
  76                                         DEF_MEM_LEVEL, strategy) != Z_OK) {
  77                         ZLIB_PMD_ERR("Deflate init failed\n");
  78                         return -1;
  79                 }
  80                 break;
  81
  82         case RTE_COMP_DECOMPRESS:
  83                 /** window bits */
  84                 switch (xform->decompress.algo) {
  85                 case RTE_COMP_ALGO_DEFLATE:
  86                         wbits = -(xform->decompress.window_size);
  87                         break;
  88                 default:
  89                         ZLIB_PMD_ERR("Compression algorithm not supported\n");
  90                         return -1;
  91                 }
  92
  93                 if (inflateInit2(strm, wbits) != Z_OK) {
  94                         ZLIB_PMD_ERR("Inflate init failed\n");
  95                         return -1;
  96                 }
  97                 break;
  98         default:
  99                 return -1;
 100         }
 101         return 0;
 102 }
 103
 104 static int
 105 zlib_create(const char *name,
 106                 struct rte_vdev_device *vdev,
 107                 struct rte_compressdev_pmd_init_params *init_params)
 108 {
 109         struct rte_compressdev *dev;
 110
 111         dev = rte_compressdev_pmd_create(name, &vdev->device,
 112                         sizeof(struct zlib_private), init_params);
 113         if (dev == NULL) {
 114                 ZLIB_PMD_ERR("driver %s: create failed", init_params->name);
 115                 return -ENODEV;
 116         }
 117
 118         dev->dev_ops = rte_zlib_pmd_ops;
 119
 120         return 0;
 121 }
 122
 123 static int
 124 zlib_probe(struct rte_vdev_device *vdev)
 125 {
 126         struct rte_compressdev_pmd_init_params init_params = {
 127                 "",
 128                 rte_socket_id()
 129         };
 130         const char *name;
 131         const char *input_args;
 132         int retval;
 133
 134         name = rte_vdev_device_name(vdev);
 135
 136         if (name == NULL)
 137                 return -EINVAL;
 138
 139         input_args = rte_vdev_device_args(vdev);
 140
 141         retval = rte_compressdev_pmd_parse_input_args(&init_params, input_args);
 142         if (retval < 0) {
 143                 ZLIB_PMD_LOG(ERR,
 144                         "Failed to parse initialisation arguments[%s]\n",
 145                         input_args);
 146                 return -EINVAL;
 147         }
 148
 149         return zlib_create(name, vdev, &init_params);
 150 }
 151
 152 static int
 153 zlib_remove(struct rte_vdev_device *vdev)
 154 {
 155         struct rte_compressdev *compressdev;
 156         const char *name;
 157
 158         name = rte_vdev_device_name(vdev);
 159         if (name == NULL)
 160                 return -EINVAL;
 161
 162         compressdev = rte_compressdev_pmd_get_named_dev(name);
 163         if (compressdev == NULL)
 164                 return -ENODEV;
 165
 166         return rte_compressdev_pmd_destroy(compressdev);
 167 }
 168
 169 static struct rte_vdev_driver zlib_pmd_drv = {
 170         .probe = zlib_probe,
 171         .remove = zlib_remove
 172 };
 173
 174 RTE_PMD_REGISTER_VDEV(COMPRESSDEV_NAME_ZLIB_PMD, zlib_pmd_drv);
 175 RTE_INIT(zlib_init_log);
 176
 177 static void
 178 zlib_init_log(void)
 179 {
 180         zlib_logtype_driver = rte_log_register("pmd.compress.zlib");
 181         if (zlib_logtype_driver >= 0)
 182                 rte_log_set_level(zlib_logtype_driver, RTE_LOG_INFO);
 183 }