ARM: defconfigs: Enable Tegra profiler
[linux-2.6.git] / crypto / crc32c.c
1 /*
2  * Cryptographic API.
3  *
4  * CRC32C chksum
5  *
6  *@Article{castagnoli-crc,
7  * author =       { Guy Castagnoli and Stefan Braeuer and Martin Herrman},
8  * title =        {{Optimization of Cyclic Redundancy-Check Codes with 24
9  *                 and 32 Parity Bits}},
10  * journal =      IEEE Transactions on Communication,
11  * year =         {1993},
12  * volume =       {41},
13  * number =       {6},
14  * pages =        {},
15  * month =        {June},
16  *}
17  * Used by the iSCSI driver, possibly others, and derived from the
18  * the iscsi-crc.c module of the linux-iscsi driver at
19  * http://linux-iscsi.sourceforge.net.
20  *
21  * Following the example of lib/crc32, this function is intended to be
22  * flexible and useful for all users.  Modules that currently have their
23  * own crc32c, but hopefully may be able to use this one are:
24  *  net/sctp (please add all your doco to here if you change to
25  *            use this one!)
26  *  <endoflist>
27  *
28  * Copyright (c) 2004 Cisco Systems, Inc.
29  * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
30  *
31  * This program is free software; you can redistribute it and/or modify it
32  * under the terms of the GNU General Public License as published by the Free
33  * Software Foundation; either version 2 of the License, or (at your option)
34  * any later version.
35  *
36  */
37
38 #include <crypto/internal/hash.h>
39 #include <linux/init.h>
40 #include <linux/module.h>
41 #include <linux/string.h>
42 #include <linux/kernel.h>
43 #include <linux/crc32.h>
44
45 #define CHKSUM_BLOCK_SIZE       1
46 #define CHKSUM_DIGEST_SIZE      4
47
48 struct chksum_ctx {
49         u32 key;
50 };
51
52 struct chksum_desc_ctx {
53         u32 crc;
54 };
55
56 /*
57  * Steps through buffer one byte at at time, calculates reflected
58  * crc using table.
59  */
60
61 static int chksum_init(struct shash_desc *desc)
62 {
63         struct chksum_ctx *mctx = crypto_shash_ctx(desc->tfm);
64         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
65
66         ctx->crc = mctx->key;
67
68         return 0;
69 }
70
71 /*
72  * Setting the seed allows arbitrary accumulators and flexible XOR policy
73  * If your algorithm starts with ~0, then XOR with ~0 before you set
74  * the seed.
75  */
76 static int chksum_setkey(struct crypto_shash *tfm, const u8 *key,
77                          unsigned int keylen)
78 {
79         struct chksum_ctx *mctx = crypto_shash_ctx(tfm);
80
81         if (keylen != sizeof(mctx->key)) {
82                 crypto_shash_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
83                 return -EINVAL;
84         }
85         mctx->key = le32_to_cpu(*(__le32 *)key);
86         return 0;
87 }
88
89 static int chksum_update(struct shash_desc *desc, const u8 *data,
90                          unsigned int length)
91 {
92         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
93
94         ctx->crc = __crc32c_le(ctx->crc, data, length);
95         return 0;
96 }
97
98 static int chksum_final(struct shash_desc *desc, u8 *out)
99 {
100         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
101
102         *(__le32 *)out = ~cpu_to_le32p(&ctx->crc);
103         return 0;
104 }
105
106 static int __chksum_finup(u32 *crcp, const u8 *data, unsigned int len, u8 *out)
107 {
108         *(__le32 *)out = ~cpu_to_le32(__crc32c_le(*crcp, data, len));
109         return 0;
110 }
111
112 static int chksum_finup(struct shash_desc *desc, const u8 *data,
113                         unsigned int len, u8 *out)
114 {
115         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
116
117         return __chksum_finup(&ctx->crc, data, len, out);
118 }
119
120 static int chksum_digest(struct shash_desc *desc, const u8 *data,
121                          unsigned int length, u8 *out)
122 {
123         struct chksum_ctx *mctx = crypto_shash_ctx(desc->tfm);
124
125         return __chksum_finup(&mctx->key, data, length, out);
126 }
127
128 static int crc32c_cra_init(struct crypto_tfm *tfm)
129 {
130         struct chksum_ctx *mctx = crypto_tfm_ctx(tfm);
131
132         mctx->key = ~0;
133         return 0;
134 }
135
136 static struct shash_alg alg = {
137         .digestsize             =       CHKSUM_DIGEST_SIZE,
138         .setkey                 =       chksum_setkey,
139         .init           =       chksum_init,
140         .update         =       chksum_update,
141         .final          =       chksum_final,
142         .finup          =       chksum_finup,
143         .digest         =       chksum_digest,
144         .descsize               =       sizeof(struct chksum_desc_ctx),
145         .base                   =       {
146                 .cra_name               =       "crc32c",
147                 .cra_driver_name        =       "crc32c-generic",
148                 .cra_priority           =       100,
149                 .cra_blocksize          =       CHKSUM_BLOCK_SIZE,
150                 .cra_alignmask          =       3,
151                 .cra_ctxsize            =       sizeof(struct chksum_ctx),
152                 .cra_module             =       THIS_MODULE,
153                 .cra_init               =       crc32c_cra_init,
154         }
155 };
156
157 static int __init crc32c_mod_init(void)
158 {
159         return crypto_register_shash(&alg);
160 }
161
162 static void __exit crc32c_mod_fini(void)
163 {
164         crypto_unregister_shash(&alg);
165 }
166
167 module_init(crc32c_mod_init);
168 module_exit(crc32c_mod_fini);
169
170 MODULE_AUTHOR("Clay Haapala <chaapala@cisco.com>");
171 MODULE_DESCRIPTION("CRC32c (Castagnoli) calculations wrapper for lib/crc32c");
172 MODULE_LICENSE("GPL");