This source file includes following definitions.
- octeon_sha512_store_hash
- octeon_sha512_read_hash
- octeon_sha512_transform
- octeon_sha512_init
- octeon_sha384_init
- __octeon_sha512_update
- octeon_sha512_update
- octeon_sha512_final
- octeon_sha384_final
- octeon_sha512_mod_init
- octeon_sha512_mod_fini
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 #include <linux/mm.h>
17 #include <crypto/sha.h>
18 #include <linux/init.h>
19 #include <linux/types.h>
20 #include <linux/module.h>
21 #include <asm/byteorder.h>
22 #include <asm/octeon/octeon.h>
23 #include <crypto/internal/hash.h>
24
25 #include "octeon-crypto.h"
26
27
28
29
30
31 static void octeon_sha512_store_hash(struct sha512_state *sctx)
32 {
33 write_octeon_64bit_hash_sha512(sctx->state[0], 0);
34 write_octeon_64bit_hash_sha512(sctx->state[1], 1);
35 write_octeon_64bit_hash_sha512(sctx->state[2], 2);
36 write_octeon_64bit_hash_sha512(sctx->state[3], 3);
37 write_octeon_64bit_hash_sha512(sctx->state[4], 4);
38 write_octeon_64bit_hash_sha512(sctx->state[5], 5);
39 write_octeon_64bit_hash_sha512(sctx->state[6], 6);
40 write_octeon_64bit_hash_sha512(sctx->state[7], 7);
41 }
42
43 static void octeon_sha512_read_hash(struct sha512_state *sctx)
44 {
45 sctx->state[0] = read_octeon_64bit_hash_sha512(0);
46 sctx->state[1] = read_octeon_64bit_hash_sha512(1);
47 sctx->state[2] = read_octeon_64bit_hash_sha512(2);
48 sctx->state[3] = read_octeon_64bit_hash_sha512(3);
49 sctx->state[4] = read_octeon_64bit_hash_sha512(4);
50 sctx->state[5] = read_octeon_64bit_hash_sha512(5);
51 sctx->state[6] = read_octeon_64bit_hash_sha512(6);
52 sctx->state[7] = read_octeon_64bit_hash_sha512(7);
53 }
54
55 static void octeon_sha512_transform(const void *_block)
56 {
57 const u64 *block = _block;
58
59 write_octeon_64bit_block_sha512(block[0], 0);
60 write_octeon_64bit_block_sha512(block[1], 1);
61 write_octeon_64bit_block_sha512(block[2], 2);
62 write_octeon_64bit_block_sha512(block[3], 3);
63 write_octeon_64bit_block_sha512(block[4], 4);
64 write_octeon_64bit_block_sha512(block[5], 5);
65 write_octeon_64bit_block_sha512(block[6], 6);
66 write_octeon_64bit_block_sha512(block[7], 7);
67 write_octeon_64bit_block_sha512(block[8], 8);
68 write_octeon_64bit_block_sha512(block[9], 9);
69 write_octeon_64bit_block_sha512(block[10], 10);
70 write_octeon_64bit_block_sha512(block[11], 11);
71 write_octeon_64bit_block_sha512(block[12], 12);
72 write_octeon_64bit_block_sha512(block[13], 13);
73 write_octeon_64bit_block_sha512(block[14], 14);
74 octeon_sha512_start(block[15]);
75 }
76
77 static int octeon_sha512_init(struct shash_desc *desc)
78 {
79 struct sha512_state *sctx = shash_desc_ctx(desc);
80
81 sctx->state[0] = SHA512_H0;
82 sctx->state[1] = SHA512_H1;
83 sctx->state[2] = SHA512_H2;
84 sctx->state[3] = SHA512_H3;
85 sctx->state[4] = SHA512_H4;
86 sctx->state[5] = SHA512_H5;
87 sctx->state[6] = SHA512_H6;
88 sctx->state[7] = SHA512_H7;
89 sctx->count[0] = sctx->count[1] = 0;
90
91 return 0;
92 }
93
94 static int octeon_sha384_init(struct shash_desc *desc)
95 {
96 struct sha512_state *sctx = shash_desc_ctx(desc);
97
98 sctx->state[0] = SHA384_H0;
99 sctx->state[1] = SHA384_H1;
100 sctx->state[2] = SHA384_H2;
101 sctx->state[3] = SHA384_H3;
102 sctx->state[4] = SHA384_H4;
103 sctx->state[5] = SHA384_H5;
104 sctx->state[6] = SHA384_H6;
105 sctx->state[7] = SHA384_H7;
106 sctx->count[0] = sctx->count[1] = 0;
107
108 return 0;
109 }
110
111 static void __octeon_sha512_update(struct sha512_state *sctx, const u8 *data,
112 unsigned int len)
113 {
114 unsigned int part_len;
115 unsigned int index;
116 unsigned int i;
117
118
119 index = sctx->count[0] % SHA512_BLOCK_SIZE;
120
121
122 if ((sctx->count[0] += len) < len)
123 sctx->count[1]++;
124
125 part_len = SHA512_BLOCK_SIZE - index;
126
127
128 if (len >= part_len) {
129 memcpy(&sctx->buf[index], data, part_len);
130 octeon_sha512_transform(sctx->buf);
131
132 for (i = part_len; i + SHA512_BLOCK_SIZE <= len;
133 i += SHA512_BLOCK_SIZE)
134 octeon_sha512_transform(&data[i]);
135
136 index = 0;
137 } else {
138 i = 0;
139 }
140
141
142 memcpy(&sctx->buf[index], &data[i], len - i);
143 }
144
145 static int octeon_sha512_update(struct shash_desc *desc, const u8 *data,
146 unsigned int len)
147 {
148 struct sha512_state *sctx = shash_desc_ctx(desc);
149 struct octeon_cop2_state state;
150 unsigned long flags;
151
152
153
154
155
156
157 if ((sctx->count[0] % SHA512_BLOCK_SIZE) + len < SHA512_BLOCK_SIZE)
158 return crypto_sha512_update(desc, data, len);
159
160 flags = octeon_crypto_enable(&state);
161 octeon_sha512_store_hash(sctx);
162
163 __octeon_sha512_update(sctx, data, len);
164
165 octeon_sha512_read_hash(sctx);
166 octeon_crypto_disable(&state, flags);
167
168 return 0;
169 }
170
171 static int octeon_sha512_final(struct shash_desc *desc, u8 *hash)
172 {
173 struct sha512_state *sctx = shash_desc_ctx(desc);
174 static u8 padding[128] = { 0x80, };
175 struct octeon_cop2_state state;
176 __be64 *dst = (__be64 *)hash;
177 unsigned int pad_len;
178 unsigned long flags;
179 unsigned int index;
180 __be64 bits[2];
181 int i;
182
183
184 bits[1] = cpu_to_be64(sctx->count[0] << 3);
185 bits[0] = cpu_to_be64(sctx->count[1] << 3 | sctx->count[0] >> 61);
186
187
188 index = sctx->count[0] & 0x7f;
189 pad_len = (index < 112) ? (112 - index) : ((128+112) - index);
190
191 flags = octeon_crypto_enable(&state);
192 octeon_sha512_store_hash(sctx);
193
194 __octeon_sha512_update(sctx, padding, pad_len);
195
196
197 __octeon_sha512_update(sctx, (const u8 *)bits, sizeof(bits));
198
199 octeon_sha512_read_hash(sctx);
200 octeon_crypto_disable(&state, flags);
201
202
203 for (i = 0; i < 8; i++)
204 dst[i] = cpu_to_be64(sctx->state[i]);
205
206
207 memset(sctx, 0, sizeof(struct sha512_state));
208
209 return 0;
210 }
211
212 static int octeon_sha384_final(struct shash_desc *desc, u8 *hash)
213 {
214 u8 D[64];
215
216 octeon_sha512_final(desc, D);
217
218 memcpy(hash, D, 48);
219 memzero_explicit(D, 64);
220
221 return 0;
222 }
223
224 static struct shash_alg octeon_sha512_algs[2] = { {
225 .digestsize = SHA512_DIGEST_SIZE,
226 .init = octeon_sha512_init,
227 .update = octeon_sha512_update,
228 .final = octeon_sha512_final,
229 .descsize = sizeof(struct sha512_state),
230 .base = {
231 .cra_name = "sha512",
232 .cra_driver_name= "octeon-sha512",
233 .cra_priority = OCTEON_CR_OPCODE_PRIORITY,
234 .cra_blocksize = SHA512_BLOCK_SIZE,
235 .cra_module = THIS_MODULE,
236 }
237 }, {
238 .digestsize = SHA384_DIGEST_SIZE,
239 .init = octeon_sha384_init,
240 .update = octeon_sha512_update,
241 .final = octeon_sha384_final,
242 .descsize = sizeof(struct sha512_state),
243 .base = {
244 .cra_name = "sha384",
245 .cra_driver_name= "octeon-sha384",
246 .cra_priority = OCTEON_CR_OPCODE_PRIORITY,
247 .cra_blocksize = SHA384_BLOCK_SIZE,
248 .cra_module = THIS_MODULE,
249 }
250 } };
251
252 static int __init octeon_sha512_mod_init(void)
253 {
254 if (!octeon_has_crypto())
255 return -ENOTSUPP;
256 return crypto_register_shashes(octeon_sha512_algs,
257 ARRAY_SIZE(octeon_sha512_algs));
258 }
259
260 static void __exit octeon_sha512_mod_fini(void)
261 {
262 crypto_unregister_shashes(octeon_sha512_algs,
263 ARRAY_SIZE(octeon_sha512_algs));
264 }
265
266 module_init(octeon_sha512_mod_init);
267 module_exit(octeon_sha512_mod_fini);
268
269 MODULE_LICENSE("GPL");
270 MODULE_DESCRIPTION("SHA-512 and SHA-384 Secure Hash Algorithms (OCTEON)");
271 MODULE_AUTHOR("Aaro Koskinen <aaro.koskinen@iki.fi>");