1
2
3
4
5
6
7
8
9
10#include <crypto/internal/hash.h>
11#include <linux/init.h>
12#include <linux/module.h>
13#include <linux/mm.h>
14#include <linux/types.h>
15#include <crypto/sha1.h>
16#include <asm/byteorder.h>
17#include <asm/switch_to.h>
18#include <linux/hardirq.h>
19
20
21
22
23
24
25
26
27
28
29
30#define MAX_BYTES 2048
31
32extern void ppc_spe_sha1_transform(u32 *state, const u8 *src, u32 blocks);
33
34static void spe_begin(void)
35{
36
37 preempt_disable();
38 enable_kernel_spe();
39}
40
41static void spe_end(void)
42{
43 disable_kernel_spe();
44
45 preempt_enable();
46}
47
48static inline void ppc_sha1_clear_context(struct sha1_state *sctx)
49{
50 int count = sizeof(struct sha1_state) >> 2;
51 u32 *ptr = (u32 *)sctx;
52
53
54 BUILD_BUG_ON(sizeof(struct sha1_state) % 4);
55 do { *ptr++ = 0; } while (--count);
56}
57
58static int ppc_spe_sha1_init(struct shash_desc *desc)
59{
60 struct sha1_state *sctx = shash_desc_ctx(desc);
61
62 sctx->state[0] = SHA1_H0;
63 sctx->state[1] = SHA1_H1;
64 sctx->state[2] = SHA1_H2;
65 sctx->state[3] = SHA1_H3;
66 sctx->state[4] = SHA1_H4;
67 sctx->count = 0;
68
69 return 0;
70}
71
72static int ppc_spe_sha1_update(struct shash_desc *desc, const u8 *data,
73 unsigned int len)
74{
75 struct sha1_state *sctx = shash_desc_ctx(desc);
76 const unsigned int offset = sctx->count & 0x3f;
77 const unsigned int avail = 64 - offset;
78 unsigned int bytes;
79 const u8 *src = data;
80
81 if (avail > len) {
82 sctx->count += len;
83 memcpy((char *)sctx->buffer + offset, src, len);
84 return 0;
85 }
86
87 sctx->count += len;
88
89 if (offset) {
90 memcpy((char *)sctx->buffer + offset, src, avail);
91
92 spe_begin();
93 ppc_spe_sha1_transform(sctx->state, (const u8 *)sctx->buffer, 1);
94 spe_end();
95
96 len -= avail;
97 src += avail;
98 }
99
100 while (len > 63) {
101 bytes = (len > MAX_BYTES) ? MAX_BYTES : len;
102 bytes = bytes & ~0x3f;
103
104 spe_begin();
105 ppc_spe_sha1_transform(sctx->state, src, bytes >> 6);
106 spe_end();
107
108 src += bytes;
109 len -= bytes;
110 }
111
112 memcpy((char *)sctx->buffer, src, len);
113 return 0;
114}
115
116static int ppc_spe_sha1_final(struct shash_desc *desc, u8 *out)
117{
118 struct sha1_state *sctx = shash_desc_ctx(desc);
119 const unsigned int offset = sctx->count & 0x3f;
120 char *p = (char *)sctx->buffer + offset;
121 int padlen;
122 __be64 *pbits = (__be64 *)(((char *)&sctx->buffer) + 56);
123 __be32 *dst = (__be32 *)out;
124
125 padlen = 55 - offset;
126 *p++ = 0x80;
127
128 spe_begin();
129
130 if (padlen < 0) {
131 memset(p, 0x00, padlen + sizeof (u64));
132 ppc_spe_sha1_transform(sctx->state, sctx->buffer, 1);
133 p = (char *)sctx->buffer;
134 padlen = 56;
135 }
136
137 memset(p, 0, padlen);
138 *pbits = cpu_to_be64(sctx->count << 3);
139 ppc_spe_sha1_transform(sctx->state, sctx->buffer, 1);
140
141 spe_end();
142
143 dst[0] = cpu_to_be32(sctx->state[0]);
144 dst[1] = cpu_to_be32(sctx->state[1]);
145 dst[2] = cpu_to_be32(sctx->state[2]);
146 dst[3] = cpu_to_be32(sctx->state[3]);
147 dst[4] = cpu_to_be32(sctx->state[4]);
148
149 ppc_sha1_clear_context(sctx);
150 return 0;
151}
152
153static int ppc_spe_sha1_export(struct shash_desc *desc, void *out)
154{
155 struct sha1_state *sctx = shash_desc_ctx(desc);
156
157 memcpy(out, sctx, sizeof(*sctx));
158 return 0;
159}
160
161static int ppc_spe_sha1_import(struct shash_desc *desc, const void *in)
162{
163 struct sha1_state *sctx = shash_desc_ctx(desc);
164
165 memcpy(sctx, in, sizeof(*sctx));
166 return 0;
167}
168
169static struct shash_alg alg = {
170 .digestsize = SHA1_DIGEST_SIZE,
171 .init = ppc_spe_sha1_init,
172 .update = ppc_spe_sha1_update,
173 .final = ppc_spe_sha1_final,
174 .export = ppc_spe_sha1_export,
175 .import = ppc_spe_sha1_import,
176 .descsize = sizeof(struct sha1_state),
177 .statesize = sizeof(struct sha1_state),
178 .base = {
179 .cra_name = "sha1",
180 .cra_driver_name= "sha1-ppc-spe",
181 .cra_priority = 300,
182 .cra_blocksize = SHA1_BLOCK_SIZE,
183 .cra_module = THIS_MODULE,
184 }
185};
186
187static int __init ppc_spe_sha1_mod_init(void)
188{
189 return crypto_register_shash(&alg);
190}
191
192static void __exit ppc_spe_sha1_mod_fini(void)
193{
194 crypto_unregister_shash(&alg);
195}
196
197module_init(ppc_spe_sha1_mod_init);
198module_exit(ppc_spe_sha1_mod_fini);
199
200MODULE_LICENSE("GPL");
201MODULE_DESCRIPTION("SHA1 Secure Hash Algorithm, SPE optimized");
202
203MODULE_ALIAS_CRYPTO("sha1");
204MODULE_ALIAS_CRYPTO("sha1-ppc-spe");
205