1 /* 2 * Cryptographic API for the 842 software compression algorithm. 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; either version 2 of the License, or 7 * (at your option) any later version. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * Copyright (C) IBM Corporation, 2011-2015 15 * 16 * Original Authors: Robert Jennings <rcj@linux.vnet.ibm.com> 17 * Seth Jennings <sjenning@linux.vnet.ibm.com> 18 * 19 * Rewrite: Dan Streetman <ddstreet@ieee.org> 20 * 21 * This is the software implementation of compression and decompression using 22 * the 842 format. This uses the software 842 library at lib/842/ which is 23 * only a reference implementation, and is very, very slow as compared to other 24 * software compressors. You probably do not want to use this software 25 * compression. If you have access to the PowerPC 842 compression hardware, you 26 * want to use the 842 hardware compression interface, which is at: 27 * drivers/crypto/nx/nx-842-crypto.c 28 */ 29 30 #include <linux/init.h> 31 #include <linux/module.h> 32 #include <linux/crypto.h> 33 #include <linux/sw842.h> 34 #include <crypto/internal/scompress.h> 35 36 struct crypto842_ctx { 37 void *wmem; /* working memory for compress */ 38 }; 39 40 static void *crypto842_alloc_ctx(struct crypto_scomp *tfm) 41 { 42 void *ctx; 43 44 ctx = kmalloc(SW842_MEM_COMPRESS, GFP_KERNEL); 45 if (!ctx) 46 return ERR_PTR(-ENOMEM); 47 48 return ctx; 49 } 50 51 static int crypto842_init(struct crypto_tfm *tfm) 52 { 53 struct crypto842_ctx *ctx = crypto_tfm_ctx(tfm); 54 55 ctx->wmem = crypto842_alloc_ctx(NULL); 56 if (IS_ERR(ctx->wmem)) 57 return -ENOMEM; 58 59 return 0; 60 } 61 62 static void crypto842_free_ctx(struct crypto_scomp *tfm, void *ctx) 63 { 64 kfree(ctx); 65 } 66 67 static void crypto842_exit(struct crypto_tfm *tfm) 68 { 69 struct crypto842_ctx *ctx = crypto_tfm_ctx(tfm); 70 71 crypto842_free_ctx(NULL, ctx->wmem); 72 } 73 74 static int crypto842_compress(struct crypto_tfm *tfm, 75 const u8 *src, unsigned int slen, 76 u8 *dst, unsigned int *dlen) 77 { 78 struct crypto842_ctx *ctx = crypto_tfm_ctx(tfm); 79 80 return sw842_compress(src, slen, dst, dlen, ctx->wmem); 81 } 82 83 static int crypto842_scompress(struct crypto_scomp *tfm, 84 const u8 *src, unsigned int slen, 85 u8 *dst, unsigned int *dlen, void *ctx) 86 { 87 return sw842_compress(src, slen, dst, dlen, ctx); 88 } 89 90 static int crypto842_decompress(struct crypto_tfm *tfm, 91 const u8 *src, unsigned int slen, 92 u8 *dst, unsigned int *dlen) 93 { 94 return sw842_decompress(src, slen, dst, dlen); 95 } 96 97 static int crypto842_sdecompress(struct crypto_scomp *tfm, 98 const u8 *src, unsigned int slen, 99 u8 *dst, unsigned int *dlen, void *ctx) 100 { 101 return sw842_decompress(src, slen, dst, dlen); 102 } 103 104 static struct crypto_alg alg = { 105 .cra_name = "842", 106 .cra_driver_name = "842-generic", 107 .cra_priority = 100, 108 .cra_flags = CRYPTO_ALG_TYPE_COMPRESS, 109 .cra_ctxsize = sizeof(struct crypto842_ctx), 110 .cra_module = THIS_MODULE, 111 .cra_init = crypto842_init, 112 .cra_exit = crypto842_exit, 113 .cra_u = { .compress = { 114 .coa_compress = crypto842_compress, 115 .coa_decompress = crypto842_decompress } } 116 }; 117 118 static struct scomp_alg scomp = { 119 .alloc_ctx = crypto842_alloc_ctx, 120 .free_ctx = crypto842_free_ctx, 121 .compress = crypto842_scompress, 122 .decompress = crypto842_sdecompress, 123 .base = { 124 .cra_name = "842", 125 .cra_driver_name = "842-scomp", 126 .cra_priority = 100, 127 .cra_module = THIS_MODULE, 128 } 129 }; 130 131 static int __init crypto842_mod_init(void) 132 { 133 int ret; 134 135 ret = crypto_register_alg(&alg); 136 if (ret) 137 return ret; 138 139 ret = crypto_register_scomp(&scomp); 140 if (ret) { 141 crypto_unregister_alg(&alg); 142 return ret; 143 } 144 145 return ret; 146 } 147 subsys_initcall(crypto842_mod_init); 148 149 static void __exit crypto842_mod_exit(void) 150 { 151 crypto_unregister_alg(&alg); 152 crypto_unregister_scomp(&scomp); 153 } 154 module_exit(crypto842_mod_exit); 155 156 MODULE_LICENSE("GPL"); 157 MODULE_DESCRIPTION("842 Software Compression Algorithm"); 158 MODULE_ALIAS_CRYPTO("842"); 159 MODULE_ALIAS_CRYPTO("842-generic"); 160 MODULE_AUTHOR("Dan Streetman <ddstreet@ieee.org>"); 161