Blame view
drivers/crypto/padlock-sha.c
15.9 KB
6c8332751 [CRYPTO] padlock:... |
1 2 3 4 5 6 7 8 9 10 11 12 13 |
/* * Cryptographic API. * * Support for VIA PadLock hardware crypto engine. * * Copyright (c) 2006 Michal Ludvig <michal@logix.cz> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * */ |
7d0246082 crypto: padlock -... |
14 |
#include <crypto/internal/hash.h> |
214930887 crypto: padlock -... |
15 |
#include <crypto/padlock.h> |
5265eeb2b [CRYPTO] sha: Add... |
16 |
#include <crypto/sha.h> |
6010439f4 [CRYPTO] padlock:... |
17 |
#include <linux/err.h> |
6c8332751 [CRYPTO] padlock:... |
18 19 20 |
#include <linux/module.h> #include <linux/init.h> #include <linux/errno.h> |
6c8332751 [CRYPTO] padlock:... |
21 22 23 |
#include <linux/interrupt.h> #include <linux/kernel.h> #include <linux/scatterlist.h> |
e49140120 crypto: padlock -... |
24 |
#include <asm/i387.h> |
4c6ab3ee4 crypto: padlock-s... |
25 |
|
bbbee4679 crypto: padlock -... |
26 27 |
struct padlock_sha_desc { struct shash_desc fallback; |
6c8332751 [CRYPTO] padlock:... |
28 |
}; |
bbbee4679 crypto: padlock -... |
29 30 31 |
struct padlock_sha_ctx { struct crypto_shash *fallback; }; |
6c8332751 [CRYPTO] padlock:... |
32 |
|
bbbee4679 crypto: padlock -... |
33 |
static int padlock_sha_init(struct shash_desc *desc) |
6c8332751 [CRYPTO] padlock:... |
34 |
{ |
bbbee4679 crypto: padlock -... |
35 36 |
struct padlock_sha_desc *dctx = shash_desc_ctx(desc); struct padlock_sha_ctx *ctx = crypto_shash_ctx(desc->tfm); |
6c8332751 [CRYPTO] padlock:... |
37 |
|
bbbee4679 crypto: padlock -... |
38 39 40 |
dctx->fallback.tfm = ctx->fallback; dctx->fallback.flags = desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP; return crypto_shash_init(&dctx->fallback); |
6c8332751 [CRYPTO] padlock:... |
41 |
} |
bbbee4679 crypto: padlock -... |
42 43 |
static int padlock_sha_update(struct shash_desc *desc, const u8 *data, unsigned int length) |
6c8332751 [CRYPTO] padlock:... |
44 |
{ |
bbbee4679 crypto: padlock -... |
45 |
struct padlock_sha_desc *dctx = shash_desc_ctx(desc); |
6c8332751 [CRYPTO] padlock:... |
46 |
|
bbbee4679 crypto: padlock -... |
47 48 |
dctx->fallback.flags = desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP; return crypto_shash_update(&dctx->fallback, data, length); |
6c8332751 [CRYPTO] padlock:... |
49 |
} |
a8d7ac279 crypto: padlock-s... |
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 |
static int padlock_sha_export(struct shash_desc *desc, void *out) { struct padlock_sha_desc *dctx = shash_desc_ctx(desc); return crypto_shash_export(&dctx->fallback, out); } static int padlock_sha_import(struct shash_desc *desc, const void *in) { struct padlock_sha_desc *dctx = shash_desc_ctx(desc); struct padlock_sha_ctx *ctx = crypto_shash_ctx(desc->tfm); dctx->fallback.tfm = ctx->fallback; dctx->fallback.flags = desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP; return crypto_shash_import(&dctx->fallback, in); } |
6c8332751 [CRYPTO] padlock:... |
66 67 68 69 70 71 |
static inline void padlock_output_block(uint32_t *src, uint32_t *dst, size_t count) { while (count--) *dst++ = swab32(*src++); } |
bbbee4679 crypto: padlock -... |
72 73 |
static int padlock_sha1_finup(struct shash_desc *desc, const u8 *in, unsigned int count, u8 *out) |
6c8332751 [CRYPTO] padlock:... |
74 75 76 77 |
{ /* We can't store directly to *out as it may be unaligned. */ /* BTW Don't reduce the buffer size below 128 Bytes! * PadLock microcode needs it that big. */ |
4c6ab3ee4 crypto: padlock-s... |
78 79 80 |
char buf[128 + PADLOCK_ALIGNMENT - STACK_ALIGN] __attribute__ ((aligned(STACK_ALIGN))); char *result = PTR_ALIGN(&buf[0], PADLOCK_ALIGNMENT); |
bbbee4679 crypto: padlock -... |
81 82 83 84 |
struct padlock_sha_desc *dctx = shash_desc_ctx(desc); struct sha1_state state; unsigned int space; unsigned int leftover; |
e49140120 crypto: padlock -... |
85 |
int ts_state; |
bbbee4679 crypto: padlock -... |
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 |
int err; dctx->fallback.flags = desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP; err = crypto_shash_export(&dctx->fallback, &state); if (err) goto out; if (state.count + count > ULONG_MAX) return crypto_shash_finup(&dctx->fallback, in, count, out); leftover = ((state.count - 1) & (SHA1_BLOCK_SIZE - 1)) + 1; space = SHA1_BLOCK_SIZE - leftover; if (space) { if (count > space) { err = crypto_shash_update(&dctx->fallback, in, space) ?: crypto_shash_export(&dctx->fallback, &state); if (err) goto out; count -= space; in += space; } else { memcpy(state.buffer + leftover, in, count); in = state.buffer; count += leftover; |
e9b25f16c crypto: padlock -... |
110 |
state.count &= ~(SHA1_BLOCK_SIZE - 1); |
bbbee4679 crypto: padlock -... |
111 112 113 114 |
} } memcpy(result, &state.state, SHA1_DIGEST_SIZE); |
6c8332751 [CRYPTO] padlock:... |
115 |
|
e49140120 crypto: padlock -... |
116 117 |
/* prevent taking the spurious DNA fault with padlock. */ ts_state = irq_ts_save(); |
6c8332751 [CRYPTO] padlock:... |
118 |
asm volatile (".byte 0xf3,0x0f,0xa6,0xc8" /* rep xsha1 */ |
bbbee4679 crypto: padlock -... |
119 |
: \ |
faae89088 crypto: padlock -... |
120 121 |
: "c"((unsigned long)state.count + count), \ "a"((unsigned long)state.count), \ |
bbbee4679 crypto: padlock -... |
122 |
"S"(in), "D"(result)); |
e49140120 crypto: padlock -... |
123 |
irq_ts_restore(ts_state); |
6c8332751 [CRYPTO] padlock:... |
124 125 |
padlock_output_block((uint32_t *)result, (uint32_t *)out, 5); |
bbbee4679 crypto: padlock -... |
126 127 128 |
out: return err; |
6c8332751 [CRYPTO] padlock:... |
129 |
} |
bbbee4679 crypto: padlock -... |
130 131 132 133 134 135 136 137 138 |
static int padlock_sha1_final(struct shash_desc *desc, u8 *out) { u8 buf[4]; return padlock_sha1_finup(desc, buf, 0, out); } static int padlock_sha256_finup(struct shash_desc *desc, const u8 *in, unsigned int count, u8 *out) |
6c8332751 [CRYPTO] padlock:... |
139 140 141 142 |
{ /* We can't store directly to *out as it may be unaligned. */ /* BTW Don't reduce the buffer size below 128 Bytes! * PadLock microcode needs it that big. */ |
4c6ab3ee4 crypto: padlock-s... |
143 144 145 |
char buf[128 + PADLOCK_ALIGNMENT - STACK_ALIGN] __attribute__ ((aligned(STACK_ALIGN))); char *result = PTR_ALIGN(&buf[0], PADLOCK_ALIGNMENT); |
bbbee4679 crypto: padlock -... |
146 147 148 149 |
struct padlock_sha_desc *dctx = shash_desc_ctx(desc); struct sha256_state state; unsigned int space; unsigned int leftover; |
e49140120 crypto: padlock -... |
150 |
int ts_state; |
bbbee4679 crypto: padlock -... |
151 |
int err; |
6c8332751 [CRYPTO] padlock:... |
152 |
|
bbbee4679 crypto: padlock -... |
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 |
dctx->fallback.flags = desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP; err = crypto_shash_export(&dctx->fallback, &state); if (err) goto out; if (state.count + count > ULONG_MAX) return crypto_shash_finup(&dctx->fallback, in, count, out); leftover = ((state.count - 1) & (SHA256_BLOCK_SIZE - 1)) + 1; space = SHA256_BLOCK_SIZE - leftover; if (space) { if (count > space) { err = crypto_shash_update(&dctx->fallback, in, space) ?: crypto_shash_export(&dctx->fallback, &state); if (err) goto out; count -= space; in += space; } else { memcpy(state.buf + leftover, in, count); in = state.buf; count += leftover; |
e9b25f16c crypto: padlock -... |
175 |
state.count &= ~(SHA1_BLOCK_SIZE - 1); |
bbbee4679 crypto: padlock -... |
176 177 178 179 |
} } memcpy(result, &state.state, SHA256_DIGEST_SIZE); |
6c8332751 [CRYPTO] padlock:... |
180 |
|
e49140120 crypto: padlock -... |
181 182 |
/* prevent taking the spurious DNA fault with padlock. */ ts_state = irq_ts_save(); |
6c8332751 [CRYPTO] padlock:... |
183 |
asm volatile (".byte 0xf3,0x0f,0xa6,0xd0" /* rep xsha256 */ |
bbbee4679 crypto: padlock -... |
184 |
: \ |
faae89088 crypto: padlock -... |
185 186 |
: "c"((unsigned long)state.count + count), \ "a"((unsigned long)state.count), \ |
bbbee4679 crypto: padlock -... |
187 |
"S"(in), "D"(result)); |
e49140120 crypto: padlock -... |
188 |
irq_ts_restore(ts_state); |
6c8332751 [CRYPTO] padlock:... |
189 190 |
padlock_output_block((uint32_t *)result, (uint32_t *)out, 8); |
bbbee4679 crypto: padlock -... |
191 192 193 |
out: return err; |
6c8332751 [CRYPTO] padlock:... |
194 |
} |
bbbee4679 crypto: padlock -... |
195 |
static int padlock_sha256_final(struct shash_desc *desc, u8 *out) |
6c8332751 [CRYPTO] padlock:... |
196 |
{ |
bbbee4679 crypto: padlock -... |
197 |
u8 buf[4]; |
6c8332751 [CRYPTO] padlock:... |
198 |
|
bbbee4679 crypto: padlock -... |
199 |
return padlock_sha256_finup(desc, buf, 0, out); |
6c8332751 [CRYPTO] padlock:... |
200 |
} |
6010439f4 [CRYPTO] padlock:... |
201 |
static int padlock_cra_init(struct crypto_tfm *tfm) |
6c8332751 [CRYPTO] padlock:... |
202 |
{ |
bbbee4679 crypto: padlock -... |
203 |
struct crypto_shash *hash = __crypto_shash_cast(tfm); |
6010439f4 [CRYPTO] padlock:... |
204 |
const char *fallback_driver_name = tfm->__crt_alg->cra_name; |
bbbee4679 crypto: padlock -... |
205 |
struct padlock_sha_ctx *ctx = crypto_tfm_ctx(tfm); |
7d0246082 crypto: padlock -... |
206 207 |
struct crypto_shash *fallback_tfm; int err = -ENOMEM; |
6010439f4 [CRYPTO] padlock:... |
208 |
|
6c8332751 [CRYPTO] padlock:... |
209 |
/* Allocate a fallback and abort if it failed. */ |
7d0246082 crypto: padlock -... |
210 211 |
fallback_tfm = crypto_alloc_shash(fallback_driver_name, 0, CRYPTO_ALG_NEED_FALLBACK); |
6010439f4 [CRYPTO] padlock:... |
212 |
if (IS_ERR(fallback_tfm)) { |
6c8332751 [CRYPTO] padlock:... |
213 214 215 |
printk(KERN_WARNING PFX "Fallback driver '%s' could not be loaded! ", fallback_driver_name); |
7d0246082 crypto: padlock -... |
216 |
err = PTR_ERR(fallback_tfm); |
bbbee4679 crypto: padlock -... |
217 |
goto out; |
6c8332751 [CRYPTO] padlock:... |
218 |
} |
bbbee4679 crypto: padlock -... |
219 220 |
ctx->fallback = fallback_tfm; hash->descsize += crypto_shash_descsize(fallback_tfm); |
6c8332751 [CRYPTO] padlock:... |
221 |
return 0; |
7d0246082 crypto: padlock -... |
222 |
|
7d0246082 crypto: padlock -... |
223 224 |
out: return err; |
6c8332751 [CRYPTO] padlock:... |
225 |
} |
6c8332751 [CRYPTO] padlock:... |
226 227 |
static void padlock_cra_exit(struct crypto_tfm *tfm) { |
bbbee4679 crypto: padlock -... |
228 |
struct padlock_sha_ctx *ctx = crypto_tfm_ctx(tfm); |
7d0246082 crypto: padlock -... |
229 |
|
bbbee4679 crypto: padlock -... |
230 |
crypto_free_shash(ctx->fallback); |
6c8332751 [CRYPTO] padlock:... |
231 |
} |
bbbee4679 crypto: padlock -... |
232 233 234 235 236 237 |
static struct shash_alg sha1_alg = { .digestsize = SHA1_DIGEST_SIZE, .init = padlock_sha_init, .update = padlock_sha_update, .finup = padlock_sha1_finup, .final = padlock_sha1_final, |
a8d7ac279 crypto: padlock-s... |
238 239 |
.export = padlock_sha_export, .import = padlock_sha_import, |
bbbee4679 crypto: padlock -... |
240 |
.descsize = sizeof(struct padlock_sha_desc), |
a8d7ac279 crypto: padlock-s... |
241 |
.statesize = sizeof(struct sha1_state), |
bbbee4679 crypto: padlock -... |
242 243 244 245 246 247 248 249 250 251 252 |
.base = { .cra_name = "sha1", .cra_driver_name = "sha1-padlock", .cra_priority = PADLOCK_CRA_PRIORITY, .cra_flags = CRYPTO_ALG_TYPE_SHASH | CRYPTO_ALG_NEED_FALLBACK, .cra_blocksize = SHA1_BLOCK_SIZE, .cra_ctxsize = sizeof(struct padlock_sha_ctx), .cra_module = THIS_MODULE, .cra_init = padlock_cra_init, .cra_exit = padlock_cra_exit, |
6c8332751 [CRYPTO] padlock:... |
253 254 |
} }; |
bbbee4679 crypto: padlock -... |
255 256 257 258 259 260 |
static struct shash_alg sha256_alg = { .digestsize = SHA256_DIGEST_SIZE, .init = padlock_sha_init, .update = padlock_sha_update, .finup = padlock_sha256_finup, .final = padlock_sha256_final, |
a8d7ac279 crypto: padlock-s... |
261 262 |
.export = padlock_sha_export, .import = padlock_sha_import, |
bbbee4679 crypto: padlock -... |
263 |
.descsize = sizeof(struct padlock_sha_desc), |
a8d7ac279 crypto: padlock-s... |
264 |
.statesize = sizeof(struct sha256_state), |
bbbee4679 crypto: padlock -... |
265 266 267 268 269 270 271 272 273 274 275 |
.base = { .cra_name = "sha256", .cra_driver_name = "sha256-padlock", .cra_priority = PADLOCK_CRA_PRIORITY, .cra_flags = CRYPTO_ALG_TYPE_SHASH | CRYPTO_ALG_NEED_FALLBACK, .cra_blocksize = SHA256_BLOCK_SIZE, .cra_ctxsize = sizeof(struct padlock_sha_ctx), .cra_module = THIS_MODULE, .cra_init = padlock_cra_init, .cra_exit = padlock_cra_exit, |
6c8332751 [CRYPTO] padlock:... |
276 277 |
} }; |
0475add3c crypto: padlock -... |
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 |
/* Add two shash_alg instance for hardware-implemented * * multiple-parts hash supported by VIA Nano Processor.*/ static int padlock_sha1_init_nano(struct shash_desc *desc) { struct sha1_state *sctx = shash_desc_ctx(desc); *sctx = (struct sha1_state){ .state = { SHA1_H0, SHA1_H1, SHA1_H2, SHA1_H3, SHA1_H4 }, }; return 0; } static int padlock_sha1_update_nano(struct shash_desc *desc, const u8 *data, unsigned int len) { struct sha1_state *sctx = shash_desc_ctx(desc); unsigned int partial, done; const u8 *src; /*The PHE require the out buffer must 128 bytes and 16-bytes aligned*/ u8 buf[128 + PADLOCK_ALIGNMENT - STACK_ALIGN] __attribute__ ((aligned(STACK_ALIGN))); u8 *dst = PTR_ALIGN(&buf[0], PADLOCK_ALIGNMENT); int ts_state; partial = sctx->count & 0x3f; sctx->count += len; done = 0; src = data; memcpy(dst, (u8 *)(sctx->state), SHA1_DIGEST_SIZE); if ((partial + len) >= SHA1_BLOCK_SIZE) { /* Append the bytes in state's buffer to a block to handle */ if (partial) { done = -partial; memcpy(sctx->buffer + partial, data, done + SHA1_BLOCK_SIZE); src = sctx->buffer; ts_state = irq_ts_save(); asm volatile (".byte 0xf3,0x0f,0xa6,0xc8" : "+S"(src), "+D"(dst) \ : "a"((long)-1), "c"((unsigned long)1)); irq_ts_restore(ts_state); done += SHA1_BLOCK_SIZE; src = data + done; } /* Process the left bytes from the input data */ if (len - done >= SHA1_BLOCK_SIZE) { ts_state = irq_ts_save(); asm volatile (".byte 0xf3,0x0f,0xa6,0xc8" : "+S"(src), "+D"(dst) : "a"((long)-1), "c"((unsigned long)((len - done) / SHA1_BLOCK_SIZE))); irq_ts_restore(ts_state); done += ((len - done) - (len - done) % SHA1_BLOCK_SIZE); src = data + done; } partial = 0; } memcpy((u8 *)(sctx->state), dst, SHA1_DIGEST_SIZE); memcpy(sctx->buffer + partial, src, len - done); return 0; } static int padlock_sha1_final_nano(struct shash_desc *desc, u8 *out) { struct sha1_state *state = (struct sha1_state *)shash_desc_ctx(desc); unsigned int partial, padlen; __be64 bits; static const u8 padding[64] = { 0x80, }; bits = cpu_to_be64(state->count << 3); /* Pad out to 56 mod 64 */ partial = state->count & 0x3f; padlen = (partial < 56) ? (56 - partial) : ((64+56) - partial); padlock_sha1_update_nano(desc, padding, padlen); /* Append length field bytes */ padlock_sha1_update_nano(desc, (const u8 *)&bits, sizeof(bits)); /* Swap to output */ padlock_output_block((uint32_t *)(state->state), (uint32_t *)out, 5); return 0; } static int padlock_sha256_init_nano(struct shash_desc *desc) { struct sha256_state *sctx = shash_desc_ctx(desc); *sctx = (struct sha256_state){ .state = { SHA256_H0, SHA256_H1, SHA256_H2, SHA256_H3, \ SHA256_H4, SHA256_H5, SHA256_H6, SHA256_H7}, }; return 0; } static int padlock_sha256_update_nano(struct shash_desc *desc, const u8 *data, unsigned int len) { struct sha256_state *sctx = shash_desc_ctx(desc); unsigned int partial, done; const u8 *src; /*The PHE require the out buffer must 128 bytes and 16-bytes aligned*/ u8 buf[128 + PADLOCK_ALIGNMENT - STACK_ALIGN] __attribute__ ((aligned(STACK_ALIGN))); u8 *dst = PTR_ALIGN(&buf[0], PADLOCK_ALIGNMENT); int ts_state; partial = sctx->count & 0x3f; sctx->count += len; done = 0; src = data; memcpy(dst, (u8 *)(sctx->state), SHA256_DIGEST_SIZE); if ((partial + len) >= SHA256_BLOCK_SIZE) { /* Append the bytes in state's buffer to a block to handle */ if (partial) { done = -partial; memcpy(sctx->buf + partial, data, done + SHA256_BLOCK_SIZE); src = sctx->buf; ts_state = irq_ts_save(); asm volatile (".byte 0xf3,0x0f,0xa6,0xd0" : "+S"(src), "+D"(dst) : "a"((long)-1), "c"((unsigned long)1)); irq_ts_restore(ts_state); done += SHA256_BLOCK_SIZE; src = data + done; } /* Process the left bytes from input data*/ if (len - done >= SHA256_BLOCK_SIZE) { ts_state = irq_ts_save(); asm volatile (".byte 0xf3,0x0f,0xa6,0xd0" : "+S"(src), "+D"(dst) : "a"((long)-1), "c"((unsigned long)((len - done) / 64))); irq_ts_restore(ts_state); done += ((len - done) - (len - done) % 64); src = data + done; } partial = 0; } memcpy((u8 *)(sctx->state), dst, SHA256_DIGEST_SIZE); memcpy(sctx->buf + partial, src, len - done); return 0; } static int padlock_sha256_final_nano(struct shash_desc *desc, u8 *out) { struct sha256_state *state = (struct sha256_state *)shash_desc_ctx(desc); unsigned int partial, padlen; __be64 bits; static const u8 padding[64] = { 0x80, }; bits = cpu_to_be64(state->count << 3); /* Pad out to 56 mod 64 */ partial = state->count & 0x3f; padlen = (partial < 56) ? (56 - partial) : ((64+56) - partial); padlock_sha256_update_nano(desc, padding, padlen); /* Append length field bytes */ padlock_sha256_update_nano(desc, (const u8 *)&bits, sizeof(bits)); /* Swap to output */ padlock_output_block((uint32_t *)(state->state), (uint32_t *)out, 8); return 0; } static int padlock_sha_export_nano(struct shash_desc *desc, void *out) { int statesize = crypto_shash_statesize(desc->tfm); void *sctx = shash_desc_ctx(desc); memcpy(out, sctx, statesize); return 0; } static int padlock_sha_import_nano(struct shash_desc *desc, const void *in) { int statesize = crypto_shash_statesize(desc->tfm); void *sctx = shash_desc_ctx(desc); memcpy(sctx, in, statesize); return 0; } static struct shash_alg sha1_alg_nano = { .digestsize = SHA1_DIGEST_SIZE, .init = padlock_sha1_init_nano, .update = padlock_sha1_update_nano, .final = padlock_sha1_final_nano, .export = padlock_sha_export_nano, .import = padlock_sha_import_nano, .descsize = sizeof(struct sha1_state), .statesize = sizeof(struct sha1_state), .base = { .cra_name = "sha1", .cra_driver_name = "sha1-padlock-nano", .cra_priority = PADLOCK_CRA_PRIORITY, .cra_flags = CRYPTO_ALG_TYPE_SHASH, .cra_blocksize = SHA1_BLOCK_SIZE, .cra_module = THIS_MODULE, } }; static struct shash_alg sha256_alg_nano = { .digestsize = SHA256_DIGEST_SIZE, .init = padlock_sha256_init_nano, .update = padlock_sha256_update_nano, .final = padlock_sha256_final_nano, .export = padlock_sha_export_nano, .import = padlock_sha_import_nano, .descsize = sizeof(struct sha256_state), .statesize = sizeof(struct sha256_state), .base = { .cra_name = "sha256", .cra_driver_name = "sha256-padlock-nano", .cra_priority = PADLOCK_CRA_PRIORITY, .cra_flags = CRYPTO_ALG_TYPE_SHASH, .cra_blocksize = SHA256_BLOCK_SIZE, .cra_module = THIS_MODULE, } }; |
6c8332751 [CRYPTO] padlock:... |
515 516 517 |
static int __init padlock_init(void) { int rc = -ENODEV; |
0475add3c crypto: padlock -... |
518 519 520 |
struct cpuinfo_x86 *c = &cpu_data(0); struct shash_alg *sha1; struct shash_alg *sha256; |
6c8332751 [CRYPTO] padlock:... |
521 522 |
if (!cpu_has_phe) { |
b43e726b3 crypto: padlock -... |
523 524 |
printk(KERN_NOTICE PFX "VIA PadLock Hash Engine not detected. "); |
6c8332751 [CRYPTO] padlock:... |
525 526 527 528 |
return -ENODEV; } if (!cpu_has_phe_enabled) { |
b43e726b3 crypto: padlock -... |
529 530 |
printk(KERN_NOTICE PFX "VIA PadLock detected, but not enabled. Hmm, strange... "); |
6c8332751 [CRYPTO] padlock:... |
531 532 |
return -ENODEV; } |
0475add3c crypto: padlock -... |
533 534 535 536 537 538 539 540 541 542 543 |
/* Register the newly added algorithm module if on * * VIA Nano processor, or else just do as before */ if (c->x86_model < 0x0f) { sha1 = &sha1_alg; sha256 = &sha256_alg; } else { sha1 = &sha1_alg_nano; sha256 = &sha256_alg_nano; } rc = crypto_register_shash(sha1); |
6c8332751 [CRYPTO] padlock:... |
544 545 |
if (rc) goto out; |
0475add3c crypto: padlock -... |
546 |
rc = crypto_register_shash(sha256); |
6c8332751 [CRYPTO] padlock:... |
547 548 549 550 551 552 553 554 555 |
if (rc) goto out_unreg1; printk(KERN_NOTICE PFX "Using VIA PadLock ACE for SHA1/SHA256 algorithms. "); return 0; out_unreg1: |
0475add3c crypto: padlock -... |
556 |
crypto_unregister_shash(sha1); |
6c8332751 [CRYPTO] padlock:... |
557 558 559 560 561 562 563 564 |
out: printk(KERN_ERR PFX "VIA PadLock SHA1/SHA256 initialization failed. "); return rc; } static void __exit padlock_fini(void) { |
0475add3c crypto: padlock -... |
565 566 567 568 569 570 571 572 573 |
struct cpuinfo_x86 *c = &cpu_data(0); if (c->x86_model >= 0x0f) { crypto_unregister_shash(&sha1_alg_nano); crypto_unregister_shash(&sha256_alg_nano); } else { crypto_unregister_shash(&sha1_alg); crypto_unregister_shash(&sha256_alg); } |
6c8332751 [CRYPTO] padlock:... |
574 575 576 577 578 579 580 581 |
} module_init(padlock_init); module_exit(padlock_fini); MODULE_DESCRIPTION("VIA PadLock SHA1/SHA256 algorithms support."); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Michal Ludvig"); |
a760a6656 crypto: api - Fix... |
582 583 |
MODULE_ALIAS("sha1-all"); MODULE_ALIAS("sha256-all"); |
6c8332751 [CRYPTO] padlock:... |
584 585 |
MODULE_ALIAS("sha1-padlock"); MODULE_ALIAS("sha256-padlock"); |