forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c 
 kernel/arch/sparc/crypto/des_glue.c
....@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
12 /* Glue code for DES encryption optimized for sparc64 crypto opcodes.
23  *
34  * Copyright (C) 2012 David S. Miller <davem@davemloft.net>
....@@ -11,7 +12,8 @@
1112 #include <linux/mm.h>
1213 #include <linux/types.h>
1314 #include <crypto/algapi.h>
14
-#include <crypto/des.h>
15
+#include <crypto/internal/des.h>
16
+#include <crypto/internal/skcipher.h>
1517 
1618 #include <asm/fpumacro.h>
1719 #include <asm/pstate.h>
....@@ -44,19 +46,15 @@
4446 		       unsigned int keylen)
4547 {
4648 	struct des_sparc64_ctx *dctx = crypto_tfm_ctx(tfm);
47
-	u32 *flags = &tfm->crt_flags;
48
-	u32 tmp[DES_EXPKEY_WORDS];
49
-	int ret;
49
+	int err;
5050 
5151 	/* Even though we have special instructions for key expansion,
52
-	 * we call des_ekey() so that we don't have to write our own
52
+	 * we call des_verify_key() so that we don't have to write our own
5353 	 * weak key detection code.
5454 	 */
55
-	ret = des_ekey(tmp, key);
56
-	if (unlikely(ret == 0) && (*flags & CRYPTO_TFM_REQ_WEAK_KEY)) {
57
-		*flags |= CRYPTO_TFM_RES_WEAK_KEY;
58
-		return -EINVAL;
59
-	}
55
+	err = crypto_des_verify_key(tfm, key);
56
+	if (err)
57
+		return err;
6058 
6159 	des_sparc64_key_expand((const u32 *) key, &dctx->encrypt_expkey[0]);
6260 	encrypt_to_decrypt(&dctx->decrypt_expkey[0], &dctx->encrypt_expkey[0]);
....@@ -64,10 +62,16 @@
6462 	return 0;
6563 }
6664 
65
+static int des_set_key_skcipher(struct crypto_skcipher *tfm, const u8 *key,
66
+				unsigned int keylen)
67
+{
68
+	return des_set_key(crypto_skcipher_tfm(tfm), key, keylen);
69
+}
70
+
6771 extern void des_sparc64_crypt(const u64 *key, const u64 *input,
6872 			      u64 *output);
6973 
70
-static void des_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
74
+static void sparc_des_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
7175 {
7276 	struct des_sparc64_ctx *ctx = crypto_tfm_ctx(tfm);
7377 	const u64 *K = ctx->encrypt_expkey;
....@@ -75,7 +79,7 @@
7579 	des_sparc64_crypt(K, (const u64 *) src, (u64 *) dst);
7680 }
7781 
78
-static void des_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
82
+static void sparc_des_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
7983 {
8084 	struct des_sparc64_ctx *ctx = crypto_tfm_ctx(tfm);
8185 	const u64 *K = ctx->decrypt_expkey;
....@@ -88,131 +92,104 @@
8892 extern void des_sparc64_ecb_crypt(const u64 *input, u64 *output,
8993 				  unsigned int len);
9094 
91
-#define DES_BLOCK_MASK	(~(DES_BLOCK_SIZE - 1))
92
-
93
-static int __ecb_crypt(struct blkcipher_desc *desc,
94
-		       struct scatterlist *dst, struct scatterlist *src,
95
-		       unsigned int nbytes, bool encrypt)
95
+static int __ecb_crypt(struct skcipher_request *req, bool encrypt)
9696 {
97
-	struct des_sparc64_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
98
-	struct blkcipher_walk walk;
97
+	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
98
+	const struct des_sparc64_ctx *ctx = crypto_skcipher_ctx(tfm);
99
+	struct skcipher_walk walk;
100
+	unsigned int nbytes;
99101 	int err;
100102 
101
-	blkcipher_walk_init(&walk, dst, src, nbytes);
102
-	err = blkcipher_walk_virt(desc, &walk);
103
-	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
103
+	err = skcipher_walk_virt(&walk, req, true);
104
+	if (err)
105
+		return err;
104106 
105107 	if (encrypt)
106108 		des_sparc64_load_keys(&ctx->encrypt_expkey[0]);
107109 	else
108110 		des_sparc64_load_keys(&ctx->decrypt_expkey[0]);
109
-	while ((nbytes = walk.nbytes)) {
110
-		unsigned int block_len = nbytes & DES_BLOCK_MASK;
111
-
112
-		if (likely(block_len)) {
113
-			des_sparc64_ecb_crypt((const u64 *)walk.src.virt.addr,
114
-					      (u64 *) walk.dst.virt.addr,
115
-					      block_len);
116
-		}
117
-		nbytes &= DES_BLOCK_SIZE - 1;
118
-		err = blkcipher_walk_done(desc, &walk, nbytes);
111
+	while ((nbytes = walk.nbytes) != 0) {
112
+		des_sparc64_ecb_crypt(walk.src.virt.addr, walk.dst.virt.addr,
113
+				      round_down(nbytes, DES_BLOCK_SIZE));
114
+		err = skcipher_walk_done(&walk, nbytes % DES_BLOCK_SIZE);
119115 	}
120116 	fprs_write(0);
121117 	return err;
122118 }
123119 
124
-static int ecb_encrypt(struct blkcipher_desc *desc,
125
-		       struct scatterlist *dst, struct scatterlist *src,
126
-		       unsigned int nbytes)
120
+static int ecb_encrypt(struct skcipher_request *req)
127121 {
128
-	return __ecb_crypt(desc, dst, src, nbytes, true);
122
+	return __ecb_crypt(req, true);
129123 }
130124 
131
-static int ecb_decrypt(struct blkcipher_desc *desc,
132
-		       struct scatterlist *dst, struct scatterlist *src,
133
-		       unsigned int nbytes)
125
+static int ecb_decrypt(struct skcipher_request *req)
134126 {
135
-	return __ecb_crypt(desc, dst, src, nbytes, false);
127
+	return __ecb_crypt(req, false);
136128 }
137129 
138130 extern void des_sparc64_cbc_encrypt(const u64 *input, u64 *output,
139131 				    unsigned int len, u64 *iv);
140132 
141
-static int cbc_encrypt(struct blkcipher_desc *desc,
142
-		       struct scatterlist *dst, struct scatterlist *src,
143
-		       unsigned int nbytes)
133
+extern void des_sparc64_cbc_decrypt(const u64 *input, u64 *output,
134
+				    unsigned int len, u64 *iv);
135
+
136
+static int __cbc_crypt(struct skcipher_request *req, bool encrypt)
144137 {
145
-	struct des_sparc64_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
146
-	struct blkcipher_walk walk;
138
+	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
139
+	const struct des_sparc64_ctx *ctx = crypto_skcipher_ctx(tfm);
140
+	struct skcipher_walk walk;
141
+	unsigned int nbytes;
147142 	int err;
148143 
149
-	blkcipher_walk_init(&walk, dst, src, nbytes);
150
-	err = blkcipher_walk_virt(desc, &walk);
151
-	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
144
+	err = skcipher_walk_virt(&walk, req, true);
145
+	if (err)
146
+		return err;
152147 
153
-	des_sparc64_load_keys(&ctx->encrypt_expkey[0]);
154
-	while ((nbytes = walk.nbytes)) {
155
-		unsigned int block_len = nbytes & DES_BLOCK_MASK;
156
-
157
-		if (likely(block_len)) {
158
-			des_sparc64_cbc_encrypt((const u64 *)walk.src.virt.addr,
159
-						(u64 *) walk.dst.virt.addr,
160
-						block_len, (u64 *) walk.iv);
161
-		}
162
-		nbytes &= DES_BLOCK_SIZE - 1;
163
-		err = blkcipher_walk_done(desc, &walk, nbytes);
148
+	if (encrypt)
149
+		des_sparc64_load_keys(&ctx->encrypt_expkey[0]);
150
+	else
151
+		des_sparc64_load_keys(&ctx->decrypt_expkey[0]);
152
+	while ((nbytes = walk.nbytes) != 0) {
153
+		if (encrypt)
154
+			des_sparc64_cbc_encrypt(walk.src.virt.addr,
155
+						walk.dst.virt.addr,
156
+						round_down(nbytes,
157
+							   DES_BLOCK_SIZE),
158
+						walk.iv);
159
+		else
160
+			des_sparc64_cbc_decrypt(walk.src.virt.addr,
161
+						walk.dst.virt.addr,
162
+						round_down(nbytes,
163
+							   DES_BLOCK_SIZE),
164
+						walk.iv);
165
+		err = skcipher_walk_done(&walk, nbytes % DES_BLOCK_SIZE);
164166 	}
165167 	fprs_write(0);
166168 	return err;
167169 }
168170 
169
-extern void des_sparc64_cbc_decrypt(const u64 *input, u64 *output,
170
-				    unsigned int len, u64 *iv);
171
-
172
-static int cbc_decrypt(struct blkcipher_desc *desc,
173
-		       struct scatterlist *dst, struct scatterlist *src,
174
-		       unsigned int nbytes)
171
+static int cbc_encrypt(struct skcipher_request *req)
175172 {
176
-	struct des_sparc64_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
177
-	struct blkcipher_walk walk;
178
-	int err;
173
+	return __cbc_crypt(req, true);
174
+}
179175 
180
-	blkcipher_walk_init(&walk, dst, src, nbytes);
181
-	err = blkcipher_walk_virt(desc, &walk);
182
-	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
183
-
184
-	des_sparc64_load_keys(&ctx->decrypt_expkey[0]);
185
-	while ((nbytes = walk.nbytes)) {
186
-		unsigned int block_len = nbytes & DES_BLOCK_MASK;
187
-
188
-		if (likely(block_len)) {
189
-			des_sparc64_cbc_decrypt((const u64 *)walk.src.virt.addr,
190
-						(u64 *) walk.dst.virt.addr,
191
-						block_len, (u64 *) walk.iv);
192
-		}
193
-		nbytes &= DES_BLOCK_SIZE - 1;
194
-		err = blkcipher_walk_done(desc, &walk, nbytes);
195
-	}
196
-	fprs_write(0);
197
-	return err;
176
+static int cbc_decrypt(struct skcipher_request *req)
177
+{
178
+	return __cbc_crypt(req, false);
198179 }
199180 
200181 static int des3_ede_set_key(struct crypto_tfm *tfm, const u8 *key,
201182 			    unsigned int keylen)
202183 {
203184 	struct des3_ede_sparc64_ctx *dctx = crypto_tfm_ctx(tfm);
204
-	const u32 *K = (const u32 *)key;
205
-	u32 *flags = &tfm->crt_flags;
206185 	u64 k1[DES_EXPKEY_WORDS / 2];
207186 	u64 k2[DES_EXPKEY_WORDS / 2];
208187 	u64 k3[DES_EXPKEY_WORDS / 2];
188
+	int err;
209189 
210
-	if (unlikely(!((K[0] ^ K[2]) | (K[1] ^ K[3])) ||
211
-		     !((K[2] ^ K[4]) | (K[3] ^ K[5]))) &&
212
-		     (*flags & CRYPTO_TFM_REQ_WEAK_KEY)) {
213
-		*flags |= CRYPTO_TFM_RES_WEAK_KEY;
214
-		return -EINVAL;
215
-	}
190
+	err = crypto_des3_ede_verify_key(tfm, key);
191
+	if (err)
192
+		return err;
216193 
217194 	des_sparc64_key_expand((const u32 *)key, k1);
218195 	key += DES_KEY_SIZE;
....@@ -234,10 +211,16 @@
234211 	return 0;
235212 }
236213 
214
+static int des3_ede_set_key_skcipher(struct crypto_skcipher *tfm, const u8 *key,
215
+				     unsigned int keylen)
216
+{
217
+	return des3_ede_set_key(crypto_skcipher_tfm(tfm), key, keylen);
218
+}
219
+
237220 extern void des3_ede_sparc64_crypt(const u64 *key, const u64 *input,
238221 				   u64 *output);
239222 
240
-static void des3_ede_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
223
+static void sparc_des3_ede_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
241224 {
242225 	struct des3_ede_sparc64_ctx *ctx = crypto_tfm_ctx(tfm);
243226 	const u64 *K = ctx->encrypt_expkey;
....@@ -245,7 +228,7 @@
245228 	des3_ede_sparc64_crypt(K, (const u64 *) src, (u64 *) dst);
246229 }
247230 
248
-static void des3_ede_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
231
+static void sparc_des3_ede_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
249232 {
250233 	struct des3_ede_sparc64_ctx *ctx = crypto_tfm_ctx(tfm);
251234 	const u64 *K = ctx->decrypt_expkey;
....@@ -258,241 +241,196 @@
258241 extern void des3_ede_sparc64_ecb_crypt(const u64 *expkey, const u64 *input,
259242 				       u64 *output, unsigned int len);
260243 
261
-static int __ecb3_crypt(struct blkcipher_desc *desc,
262
-			struct scatterlist *dst, struct scatterlist *src,
263
-			unsigned int nbytes, bool encrypt)
244
+static int __ecb3_crypt(struct skcipher_request *req, bool encrypt)
264245 {
265
-	struct des3_ede_sparc64_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
266
-	struct blkcipher_walk walk;
246
+	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
247
+	const struct des3_ede_sparc64_ctx *ctx = crypto_skcipher_ctx(tfm);
248
+	struct skcipher_walk walk;
267249 	const u64 *K;
250
+	unsigned int nbytes;
268251 	int err;
269252 
270
-	blkcipher_walk_init(&walk, dst, src, nbytes);
271
-	err = blkcipher_walk_virt(desc, &walk);
272
-	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
253
+	err = skcipher_walk_virt(&walk, req, true);
254
+	if (err)
255
+		return err;
273256 
274257 	if (encrypt)
275258 		K = &ctx->encrypt_expkey[0];
276259 	else
277260 		K = &ctx->decrypt_expkey[0];
278261 	des3_ede_sparc64_load_keys(K);
279
-	while ((nbytes = walk.nbytes)) {
280
-		unsigned int block_len = nbytes & DES_BLOCK_MASK;
281
-
282
-		if (likely(block_len)) {
283
-			const u64 *src64 = (const u64 *)walk.src.virt.addr;
284
-			des3_ede_sparc64_ecb_crypt(K, src64,
285
-						   (u64 *) walk.dst.virt.addr,
286
-						   block_len);
287
-		}
288
-		nbytes &= DES_BLOCK_SIZE - 1;
289
-		err = blkcipher_walk_done(desc, &walk, nbytes);
262
+	while ((nbytes = walk.nbytes) != 0) {
263
+		des3_ede_sparc64_ecb_crypt(K, walk.src.virt.addr,
264
+					   walk.dst.virt.addr,
265
+					   round_down(nbytes, DES_BLOCK_SIZE));
266
+		err = skcipher_walk_done(&walk, nbytes % DES_BLOCK_SIZE);
290267 	}
291268 	fprs_write(0);
292269 	return err;
293270 }
294271 
295
-static int ecb3_encrypt(struct blkcipher_desc *desc,
296
-		       struct scatterlist *dst, struct scatterlist *src,
297
-		       unsigned int nbytes)
272
+static int ecb3_encrypt(struct skcipher_request *req)
298273 {
299
-	return __ecb3_crypt(desc, dst, src, nbytes, true);
274
+	return __ecb3_crypt(req, true);
300275 }
301276 
302
-static int ecb3_decrypt(struct blkcipher_desc *desc,
303
-		       struct scatterlist *dst, struct scatterlist *src,
304
-		       unsigned int nbytes)
277
+static int ecb3_decrypt(struct skcipher_request *req)
305278 {
306
-	return __ecb3_crypt(desc, dst, src, nbytes, false);
279
+	return __ecb3_crypt(req, false);
307280 }
308281 
309282 extern void des3_ede_sparc64_cbc_encrypt(const u64 *expkey, const u64 *input,
310283 					 u64 *output, unsigned int len,
311284 					 u64 *iv);
312285 
313
-static int cbc3_encrypt(struct blkcipher_desc *desc,
314
-			struct scatterlist *dst, struct scatterlist *src,
315
-			unsigned int nbytes)
316
-{
317
-	struct des3_ede_sparc64_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
318
-	struct blkcipher_walk walk;
319
-	const u64 *K;
320
-	int err;
321
-
322
-	blkcipher_walk_init(&walk, dst, src, nbytes);
323
-	err = blkcipher_walk_virt(desc, &walk);
324
-	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
325
-
326
-	K = &ctx->encrypt_expkey[0];
327
-	des3_ede_sparc64_load_keys(K);
328
-	while ((nbytes = walk.nbytes)) {
329
-		unsigned int block_len = nbytes & DES_BLOCK_MASK;
330
-
331
-		if (likely(block_len)) {
332
-			const u64 *src64 = (const u64 *)walk.src.virt.addr;
333
-			des3_ede_sparc64_cbc_encrypt(K, src64,
334
-						     (u64 *) walk.dst.virt.addr,
335
-						     block_len,
336
-						     (u64 *) walk.iv);
337
-		}
338
-		nbytes &= DES_BLOCK_SIZE - 1;
339
-		err = blkcipher_walk_done(desc, &walk, nbytes);
340
-	}
341
-	fprs_write(0);
342
-	return err;
343
-}
344
-
345286 extern void des3_ede_sparc64_cbc_decrypt(const u64 *expkey, const u64 *input,
346287 					 u64 *output, unsigned int len,
347288 					 u64 *iv);
348289 
349
-static int cbc3_decrypt(struct blkcipher_desc *desc,
350
-			struct scatterlist *dst, struct scatterlist *src,
351
-			unsigned int nbytes)
290
+static int __cbc3_crypt(struct skcipher_request *req, bool encrypt)
352291 {
353
-	struct des3_ede_sparc64_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
354
-	struct blkcipher_walk walk;
292
+	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
293
+	const struct des3_ede_sparc64_ctx *ctx = crypto_skcipher_ctx(tfm);
294
+	struct skcipher_walk walk;
355295 	const u64 *K;
296
+	unsigned int nbytes;
356297 	int err;
357298 
358
-	blkcipher_walk_init(&walk, dst, src, nbytes);
359
-	err = blkcipher_walk_virt(desc, &walk);
360
-	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
299
+	err = skcipher_walk_virt(&walk, req, true);
300
+	if (err)
301
+		return err;
361302 
362
-	K = &ctx->decrypt_expkey[0];
303
+	if (encrypt)
304
+		K = &ctx->encrypt_expkey[0];
305
+	else
306
+		K = &ctx->decrypt_expkey[0];
363307 	des3_ede_sparc64_load_keys(K);
364
-	while ((nbytes = walk.nbytes)) {
365
-		unsigned int block_len = nbytes & DES_BLOCK_MASK;
366
-
367
-		if (likely(block_len)) {
368
-			const u64 *src64 = (const u64 *)walk.src.virt.addr;
369
-			des3_ede_sparc64_cbc_decrypt(K, src64,
370
-						     (u64 *) walk.dst.virt.addr,
371
-						     block_len,
372
-						     (u64 *) walk.iv);
373
-		}
374
-		nbytes &= DES_BLOCK_SIZE - 1;
375
-		err = blkcipher_walk_done(desc, &walk, nbytes);
308
+	while ((nbytes = walk.nbytes) != 0) {
309
+		if (encrypt)
310
+			des3_ede_sparc64_cbc_encrypt(K, walk.src.virt.addr,
311
+						     walk.dst.virt.addr,
312
+						     round_down(nbytes,
313
+								DES_BLOCK_SIZE),
314
+						     walk.iv);
315
+		else
316
+			des3_ede_sparc64_cbc_decrypt(K, walk.src.virt.addr,
317
+						     walk.dst.virt.addr,
318
+						     round_down(nbytes,
319
+								DES_BLOCK_SIZE),
320
+						     walk.iv);
321
+		err = skcipher_walk_done(&walk, nbytes % DES_BLOCK_SIZE);
376322 	}
377323 	fprs_write(0);
378324 	return err;
379325 }
380326 
381
-static struct crypto_alg algs[] = { {
382
-	.cra_name		= "des",
383
-	.cra_driver_name	= "des-sparc64",
384
-	.cra_priority		= SPARC_CR_OPCODE_PRIORITY,
385
-	.cra_flags		= CRYPTO_ALG_TYPE_CIPHER,
386
-	.cra_blocksize		= DES_BLOCK_SIZE,
387
-	.cra_ctxsize		= sizeof(struct des_sparc64_ctx),
388
-	.cra_alignmask		= 7,
389
-	.cra_module		= THIS_MODULE,
390
-	.cra_u	= {
391
-		.cipher	= {
392
-			.cia_min_keysize	= DES_KEY_SIZE,
393
-			.cia_max_keysize	= DES_KEY_SIZE,
394
-			.cia_setkey		= des_set_key,
395
-			.cia_encrypt		= des_encrypt,
396
-			.cia_decrypt		= des_decrypt
327
+static int cbc3_encrypt(struct skcipher_request *req)
328
+{
329
+	return __cbc3_crypt(req, true);
330
+}
331
+
332
+static int cbc3_decrypt(struct skcipher_request *req)
333
+{
334
+	return __cbc3_crypt(req, false);
335
+}
336
+
337
+static struct crypto_alg cipher_algs[] = {
338
+	{
339
+		.cra_name		= "des",
340
+		.cra_driver_name	= "des-sparc64",
341
+		.cra_priority		= SPARC_CR_OPCODE_PRIORITY,
342
+		.cra_flags		= CRYPTO_ALG_TYPE_CIPHER,
343
+		.cra_blocksize		= DES_BLOCK_SIZE,
344
+		.cra_ctxsize		= sizeof(struct des_sparc64_ctx),
345
+		.cra_alignmask		= 7,
346
+		.cra_module		= THIS_MODULE,
347
+		.cra_u	= {
348
+			.cipher	= {
349
+				.cia_min_keysize	= DES_KEY_SIZE,
350
+				.cia_max_keysize	= DES_KEY_SIZE,
351
+				.cia_setkey		= des_set_key,
352
+				.cia_encrypt		= sparc_des_encrypt,
353
+				.cia_decrypt		= sparc_des_decrypt
354
+			}
355
+		}
356
+	}, {
357
+		.cra_name		= "des3_ede",
358
+		.cra_driver_name	= "des3_ede-sparc64",
359
+		.cra_priority		= SPARC_CR_OPCODE_PRIORITY,
360
+		.cra_flags		= CRYPTO_ALG_TYPE_CIPHER,
361
+		.cra_blocksize		= DES3_EDE_BLOCK_SIZE,
362
+		.cra_ctxsize		= sizeof(struct des3_ede_sparc64_ctx),
363
+		.cra_alignmask		= 7,
364
+		.cra_module		= THIS_MODULE,
365
+		.cra_u	= {
366
+			.cipher	= {
367
+				.cia_min_keysize	= DES3_EDE_KEY_SIZE,
368
+				.cia_max_keysize	= DES3_EDE_KEY_SIZE,
369
+				.cia_setkey		= des3_ede_set_key,
370
+				.cia_encrypt		= sparc_des3_ede_encrypt,
371
+				.cia_decrypt		= sparc_des3_ede_decrypt
372
+			}
397373 		}
398374 	}
399
-}, {
400
-	.cra_name		= "ecb(des)",
401
-	.cra_driver_name	= "ecb-des-sparc64",
402
-	.cra_priority		= SPARC_CR_OPCODE_PRIORITY,
403
-	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,
404
-	.cra_blocksize		= DES_BLOCK_SIZE,
405
-	.cra_ctxsize		= sizeof(struct des_sparc64_ctx),
406
-	.cra_alignmask		= 7,
407
-	.cra_type		= &crypto_blkcipher_type,
408
-	.cra_module		= THIS_MODULE,
409
-	.cra_u = {
410
-		.blkcipher = {
411
-			.min_keysize	= DES_KEY_SIZE,
412
-			.max_keysize	= DES_KEY_SIZE,
413
-			.setkey		= des_set_key,
414
-			.encrypt	= ecb_encrypt,
415
-			.decrypt	= ecb_decrypt,
416
-		},
417
-	},
418
-}, {
419
-	.cra_name		= "cbc(des)",
420
-	.cra_driver_name	= "cbc-des-sparc64",
421
-	.cra_priority		= SPARC_CR_OPCODE_PRIORITY,
422
-	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,
423
-	.cra_blocksize		= DES_BLOCK_SIZE,
424
-	.cra_ctxsize		= sizeof(struct des_sparc64_ctx),
425
-	.cra_alignmask		= 7,
426
-	.cra_type		= &crypto_blkcipher_type,
427
-	.cra_module		= THIS_MODULE,
428
-	.cra_u = {
429
-		.blkcipher = {
430
-			.min_keysize	= DES_KEY_SIZE,
431
-			.max_keysize	= DES_KEY_SIZE,
432
-			.ivsize		= DES_BLOCK_SIZE,
433
-			.setkey		= des_set_key,
434
-			.encrypt	= cbc_encrypt,
435
-			.decrypt	= cbc_decrypt,
436
-		},
437
-	},
438
-}, {
439
-	.cra_name		= "des3_ede",
440
-	.cra_driver_name	= "des3_ede-sparc64",
441
-	.cra_priority		= SPARC_CR_OPCODE_PRIORITY,
442
-	.cra_flags		= CRYPTO_ALG_TYPE_CIPHER,
443
-	.cra_blocksize		= DES3_EDE_BLOCK_SIZE,
444
-	.cra_ctxsize		= sizeof(struct des3_ede_sparc64_ctx),
445
-	.cra_alignmask		= 7,
446
-	.cra_module		= THIS_MODULE,
447
-	.cra_u	= {
448
-		.cipher	= {
449
-			.cia_min_keysize	= DES3_EDE_KEY_SIZE,
450
-			.cia_max_keysize	= DES3_EDE_KEY_SIZE,
451
-			.cia_setkey		= des3_ede_set_key,
452
-			.cia_encrypt		= des3_ede_encrypt,
453
-			.cia_decrypt		= des3_ede_decrypt
454
-		}
375
+};
376
+
377
+static struct skcipher_alg skcipher_algs[] = {
378
+	{
379
+		.base.cra_name		= "ecb(des)",
380
+		.base.cra_driver_name	= "ecb-des-sparc64",
381
+		.base.cra_priority	= SPARC_CR_OPCODE_PRIORITY,
382
+		.base.cra_blocksize	= DES_BLOCK_SIZE,
383
+		.base.cra_ctxsize	= sizeof(struct des_sparc64_ctx),
384
+		.base.cra_alignmask	= 7,
385
+		.base.cra_module	= THIS_MODULE,
386
+		.min_keysize		= DES_KEY_SIZE,
387
+		.max_keysize		= DES_KEY_SIZE,
388
+		.setkey			= des_set_key_skcipher,
389
+		.encrypt		= ecb_encrypt,
390
+		.decrypt		= ecb_decrypt,
391
+	}, {
392
+		.base.cra_name		= "cbc(des)",
393
+		.base.cra_driver_name	= "cbc-des-sparc64",
394
+		.base.cra_priority	= SPARC_CR_OPCODE_PRIORITY,
395
+		.base.cra_blocksize	= DES_BLOCK_SIZE,
396
+		.base.cra_ctxsize	= sizeof(struct des_sparc64_ctx),
397
+		.base.cra_alignmask	= 7,
398
+		.base.cra_module	= THIS_MODULE,
399
+		.min_keysize		= DES_KEY_SIZE,
400
+		.max_keysize		= DES_KEY_SIZE,
401
+		.ivsize			= DES_BLOCK_SIZE,
402
+		.setkey			= des_set_key_skcipher,
403
+		.encrypt		= cbc_encrypt,
404
+		.decrypt		= cbc_decrypt,
405
+	}, {
406
+		.base.cra_name		= "ecb(des3_ede)",
407
+		.base.cra_driver_name	= "ecb-des3_ede-sparc64",
408
+		.base.cra_priority	= SPARC_CR_OPCODE_PRIORITY,
409
+		.base.cra_blocksize	= DES3_EDE_BLOCK_SIZE,
410
+		.base.cra_ctxsize	= sizeof(struct des3_ede_sparc64_ctx),
411
+		.base.cra_alignmask	= 7,
412
+		.base.cra_module	= THIS_MODULE,
413
+		.min_keysize		= DES3_EDE_KEY_SIZE,
414
+		.max_keysize		= DES3_EDE_KEY_SIZE,
415
+		.setkey			= des3_ede_set_key_skcipher,
416
+		.encrypt		= ecb3_encrypt,
417
+		.decrypt		= ecb3_decrypt,
418
+	}, {
419
+		.base.cra_name		= "cbc(des3_ede)",
420
+		.base.cra_driver_name	= "cbc-des3_ede-sparc64",
421
+		.base.cra_priority	= SPARC_CR_OPCODE_PRIORITY,
422
+		.base.cra_blocksize	= DES3_EDE_BLOCK_SIZE,
423
+		.base.cra_ctxsize	= sizeof(struct des3_ede_sparc64_ctx),
424
+		.base.cra_alignmask	= 7,
425
+		.base.cra_module	= THIS_MODULE,
426
+		.min_keysize		= DES3_EDE_KEY_SIZE,
427
+		.max_keysize		= DES3_EDE_KEY_SIZE,
428
+		.ivsize			= DES3_EDE_BLOCK_SIZE,
429
+		.setkey			= des3_ede_set_key_skcipher,
430
+		.encrypt		= cbc3_encrypt,
431
+		.decrypt		= cbc3_decrypt,
455432 	}
456
-}, {
457
-	.cra_name		= "ecb(des3_ede)",
458
-	.cra_driver_name	= "ecb-des3_ede-sparc64",
459
-	.cra_priority		= SPARC_CR_OPCODE_PRIORITY,
460
-	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,
461
-	.cra_blocksize		= DES3_EDE_BLOCK_SIZE,
462
-	.cra_ctxsize		= sizeof(struct des3_ede_sparc64_ctx),
463
-	.cra_alignmask		= 7,
464
-	.cra_type		= &crypto_blkcipher_type,
465
-	.cra_module		= THIS_MODULE,
466
-	.cra_u = {
467
-		.blkcipher = {
468
-			.min_keysize	= DES3_EDE_KEY_SIZE,
469
-			.max_keysize	= DES3_EDE_KEY_SIZE,
470
-			.setkey		= des3_ede_set_key,
471
-			.encrypt	= ecb3_encrypt,
472
-			.decrypt	= ecb3_decrypt,
473
-		},
474
-	},
475
-}, {
476
-	.cra_name		= "cbc(des3_ede)",
477
-	.cra_driver_name	= "cbc-des3_ede-sparc64",
478
-	.cra_priority		= SPARC_CR_OPCODE_PRIORITY,
479
-	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,
480
-	.cra_blocksize		= DES3_EDE_BLOCK_SIZE,
481
-	.cra_ctxsize		= sizeof(struct des3_ede_sparc64_ctx),
482
-	.cra_alignmask		= 7,
483
-	.cra_type		= &crypto_blkcipher_type,
484
-	.cra_module		= THIS_MODULE,
485
-	.cra_u = {
486
-		.blkcipher = {
487
-			.min_keysize	= DES3_EDE_KEY_SIZE,
488
-			.max_keysize	= DES3_EDE_KEY_SIZE,
489
-			.ivsize		= DES3_EDE_BLOCK_SIZE,
490
-			.setkey		= des3_ede_set_key,
491
-			.encrypt	= cbc3_encrypt,
492
-			.decrypt	= cbc3_decrypt,
493
-		},
494
-	},
495
-} };
433
+};
496434 
497435 static bool __init sparc64_has_des_opcode(void)
498436 {
....@@ -510,22 +448,27 @@
510448 
511449 static int __init des_sparc64_mod_init(void)
512450 {
513
-	int i;
451
+	int err;
514452 
515
-	for (i = 0; i < ARRAY_SIZE(algs); i++)
516
-		INIT_LIST_HEAD(&algs[i].cra_list);
517
-
518
-	if (sparc64_has_des_opcode()) {
519
-		pr_info("Using sparc64 des opcodes optimized DES implementation\n");
520
-		return crypto_register_algs(algs, ARRAY_SIZE(algs));
453
+	if (!sparc64_has_des_opcode()) {
454
+		pr_info("sparc64 des opcodes not available.\n");
455
+		return -ENODEV;
521456 	}
522
-	pr_info("sparc64 des opcodes not available.\n");
523
-	return -ENODEV;
457
+	pr_info("Using sparc64 des opcodes optimized DES implementation\n");
458
+	err = crypto_register_algs(cipher_algs, ARRAY_SIZE(cipher_algs));
459
+	if (err)
460
+		return err;
461
+	err = crypto_register_skciphers(skcipher_algs,
462
+					ARRAY_SIZE(skcipher_algs));
463
+	if (err)
464
+		crypto_unregister_algs(cipher_algs, ARRAY_SIZE(cipher_algs));
465
+	return err;
524466 }
525467 
526468 static void __exit des_sparc64_mod_fini(void)
527469 {
528
-	crypto_unregister_algs(algs, ARRAY_SIZE(algs));
470
+	crypto_unregister_algs(cipher_algs, ARRAY_SIZE(cipher_algs));
471
+	crypto_unregister_skciphers(skcipher_algs, ARRAY_SIZE(skcipher_algs));
529472 }
530473 
531474 module_init(des_sparc64_mod_init);