This source file includes following definitions.
- octeon_sha256_store_hash
- octeon_sha256_read_hash
- octeon_sha256_transform
- octeon_sha224_init
- octeon_sha256_init
- __octeon_sha256_update
- octeon_sha256_update
- octeon_sha256_final
- octeon_sha224_final
- octeon_sha256_export
- octeon_sha256_import
- octeon_sha256_mod_init
- octeon_sha256_mod_fini
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 #include <linux/mm.h>
18 #include <crypto/sha.h>
19 #include <linux/init.h>
20 #include <linux/types.h>
21 #include <linux/module.h>
22 #include <asm/byteorder.h>
23 #include <asm/octeon/octeon.h>
24 #include <crypto/internal/hash.h>
25
26 #include "octeon-crypto.h"
27
28
29
30
31
32 static void octeon_sha256_store_hash(struct sha256_state *sctx)
33 {
34 u64 *hash = (u64 *)sctx->state;
35
36 write_octeon_64bit_hash_dword(hash[0], 0);
37 write_octeon_64bit_hash_dword(hash[1], 1);
38 write_octeon_64bit_hash_dword(hash[2], 2);
39 write_octeon_64bit_hash_dword(hash[3], 3);
40 }
41
42 static void octeon_sha256_read_hash(struct sha256_state *sctx)
43 {
44 u64 *hash = (u64 *)sctx->state;
45
46 hash[0] = read_octeon_64bit_hash_dword(0);
47 hash[1] = read_octeon_64bit_hash_dword(1);
48 hash[2] = read_octeon_64bit_hash_dword(2);
49 hash[3] = read_octeon_64bit_hash_dword(3);
50 }
51
52 static void octeon_sha256_transform(const void *_block)
53 {
54 const u64 *block = _block;
55
56 write_octeon_64bit_block_dword(block[0], 0);
57 write_octeon_64bit_block_dword(block[1], 1);
58 write_octeon_64bit_block_dword(block[2], 2);
59 write_octeon_64bit_block_dword(block[3], 3);
60 write_octeon_64bit_block_dword(block[4], 4);
61 write_octeon_64bit_block_dword(block[5], 5);
62 write_octeon_64bit_block_dword(block[6], 6);
63 octeon_sha256_start(block[7]);
64 }
65
66 static int octeon_sha224_init(struct shash_desc *desc)
67 {
68 struct sha256_state *sctx = shash_desc_ctx(desc);
69
70 sctx->state[0] = SHA224_H0;
71 sctx->state[1] = SHA224_H1;
72 sctx->state[2] = SHA224_H2;
73 sctx->state[3] = SHA224_H3;
74 sctx->state[4] = SHA224_H4;
75 sctx->state[5] = SHA224_H5;
76 sctx->state[6] = SHA224_H6;
77 sctx->state[7] = SHA224_H7;
78 sctx->count = 0;
79
80 return 0;
81 }
82
83 static int octeon_sha256_init(struct shash_desc *desc)
84 {
85 struct sha256_state *sctx = shash_desc_ctx(desc);
86
87 sctx->state[0] = SHA256_H0;
88 sctx->state[1] = SHA256_H1;
89 sctx->state[2] = SHA256_H2;
90 sctx->state[3] = SHA256_H3;
91 sctx->state[4] = SHA256_H4;
92 sctx->state[5] = SHA256_H5;
93 sctx->state[6] = SHA256_H6;
94 sctx->state[7] = SHA256_H7;
95 sctx->count = 0;
96
97 return 0;
98 }
99
100 static void __octeon_sha256_update(struct sha256_state *sctx, const u8 *data,
101 unsigned int len)
102 {
103 unsigned int partial;
104 unsigned int done;
105 const u8 *src;
106
107 partial = sctx->count % SHA256_BLOCK_SIZE;
108 sctx->count += len;
109 done = 0;
110 src = data;
111
112 if ((partial + len) >= SHA256_BLOCK_SIZE) {
113 if (partial) {
114 done = -partial;
115 memcpy(sctx->buf + partial, data,
116 done + SHA256_BLOCK_SIZE);
117 src = sctx->buf;
118 }
119
120 do {
121 octeon_sha256_transform(src);
122 done += SHA256_BLOCK_SIZE;
123 src = data + done;
124 } while (done + SHA256_BLOCK_SIZE <= len);
125
126 partial = 0;
127 }
128 memcpy(sctx->buf + partial, src, len - done);
129 }
130
131 static int octeon_sha256_update(struct shash_desc *desc, const u8 *data,
132 unsigned int len)
133 {
134 struct sha256_state *sctx = shash_desc_ctx(desc);
135 struct octeon_cop2_state state;
136 unsigned long flags;
137
138
139
140
141
142
143 if ((sctx->count % SHA256_BLOCK_SIZE) + len < SHA256_BLOCK_SIZE)
144 return crypto_sha256_update(desc, data, len);
145
146 flags = octeon_crypto_enable(&state);
147 octeon_sha256_store_hash(sctx);
148
149 __octeon_sha256_update(sctx, data, len);
150
151 octeon_sha256_read_hash(sctx);
152 octeon_crypto_disable(&state, flags);
153
154 return 0;
155 }
156
157 static int octeon_sha256_final(struct shash_desc *desc, u8 *out)
158 {
159 struct sha256_state *sctx = shash_desc_ctx(desc);
160 static const u8 padding[64] = { 0x80, };
161 struct octeon_cop2_state state;
162 __be32 *dst = (__be32 *)out;
163 unsigned int pad_len;
164 unsigned long flags;
165 unsigned int index;
166 __be64 bits;
167 int i;
168
169
170 bits = cpu_to_be64(sctx->count << 3);
171
172
173 index = sctx->count & 0x3f;
174 pad_len = (index < 56) ? (56 - index) : ((64+56) - index);
175
176 flags = octeon_crypto_enable(&state);
177 octeon_sha256_store_hash(sctx);
178
179 __octeon_sha256_update(sctx, padding, pad_len);
180
181
182 __octeon_sha256_update(sctx, (const u8 *)&bits, sizeof(bits));
183
184 octeon_sha256_read_hash(sctx);
185 octeon_crypto_disable(&state, flags);
186
187
188 for (i = 0; i < 8; i++)
189 dst[i] = cpu_to_be32(sctx->state[i]);
190
191
192 memset(sctx, 0, sizeof(*sctx));
193
194 return 0;
195 }
196
197 static int octeon_sha224_final(struct shash_desc *desc, u8 *hash)
198 {
199 u8 D[SHA256_DIGEST_SIZE];
200
201 octeon_sha256_final(desc, D);
202
203 memcpy(hash, D, SHA224_DIGEST_SIZE);
204 memzero_explicit(D, SHA256_DIGEST_SIZE);
205
206 return 0;
207 }
208
209 static int octeon_sha256_export(struct shash_desc *desc, void *out)
210 {
211 struct sha256_state *sctx = shash_desc_ctx(desc);
212
213 memcpy(out, sctx, sizeof(*sctx));
214 return 0;
215 }
216
217 static int octeon_sha256_import(struct shash_desc *desc, const void *in)
218 {
219 struct sha256_state *sctx = shash_desc_ctx(desc);
220
221 memcpy(sctx, in, sizeof(*sctx));
222 return 0;
223 }
224
225 static struct shash_alg octeon_sha256_algs[2] = { {
226 .digestsize = SHA256_DIGEST_SIZE,
227 .init = octeon_sha256_init,
228 .update = octeon_sha256_update,
229 .final = octeon_sha256_final,
230 .export = octeon_sha256_export,
231 .import = octeon_sha256_import,
232 .descsize = sizeof(struct sha256_state),
233 .statesize = sizeof(struct sha256_state),
234 .base = {
235 .cra_name = "sha256",
236 .cra_driver_name= "octeon-sha256",
237 .cra_priority = OCTEON_CR_OPCODE_PRIORITY,
238 .cra_blocksize = SHA256_BLOCK_SIZE,
239 .cra_module = THIS_MODULE,
240 }
241 }, {
242 .digestsize = SHA224_DIGEST_SIZE,
243 .init = octeon_sha224_init,
244 .update = octeon_sha256_update,
245 .final = octeon_sha224_final,
246 .descsize = sizeof(struct sha256_state),
247 .base = {
248 .cra_name = "sha224",
249 .cra_driver_name= "octeon-sha224",
250 .cra_blocksize = SHA224_BLOCK_SIZE,
251 .cra_module = THIS_MODULE,
252 }
253 } };
254
255 static int __init octeon_sha256_mod_init(void)
256 {
257 if (!octeon_has_crypto())
258 return -ENOTSUPP;
259 return crypto_register_shashes(octeon_sha256_algs,
260 ARRAY_SIZE(octeon_sha256_algs));
261 }
262
263 static void __exit octeon_sha256_mod_fini(void)
264 {
265 crypto_unregister_shashes(octeon_sha256_algs,
266 ARRAY_SIZE(octeon_sha256_algs));
267 }
268
269 module_init(octeon_sha256_mod_init);
270 module_exit(octeon_sha256_mod_fini);
271
272 MODULE_LICENSE("GPL");
273 MODULE_DESCRIPTION("SHA-224 and SHA-256 Secure Hash Algorithm (OCTEON)");
274 MODULE_AUTHOR("Aaro Koskinen <aaro.koskinen@iki.fi>");