dect
/
linux-2.6
Archived
13
0
Fork 0
Code Releases Activity

crypto: crypto4xx - Switch to new style ahash 

This patch changes crypto4xx to use the new style ahash type.
In particular, we now use ahash_alg to define ahash algorithms
instead of crypto_alg.

This is achieved by introducing a union that encapsulates the
new type and the existing crypto_alg structure.  They're told
apart through a u32 field containing the type value.

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
This commit is contained in:
Herbert Xu 2009-07-14 20:21:46 +08:00
parent 0b535adfb1
commit 4dc10c0142
3 changed files with 77 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
drivers/crypto/amcc/crypto4xx_core.c
View File

@ -31,8 +31,6 @@
#include <asm/dcr.h> #include <asm/dcr.h>
#include <asm/dcr-regs.h> #include <asm/dcr-regs.h>
#include <asm/cacheflush.h> #include <asm/cacheflush.h>
#include <crypto/internal/hash.h>
#include <crypto/algapi.h>
#include <crypto/aes.h> #include <crypto/aes.h>
#include <crypto/sha.h> #include <crypto/sha.h>
#include "crypto4xx_reg_def.h" #include "crypto4xx_reg_def.h"
@ -998,11 +996,15 @@ static int crypto4xx_alg_init(struct crypto_tfm *tfm)
ctx->sa_out_dma_addr = 0; ctx->sa_out_dma_addr = 0;
ctx->sa_len = 0; ctx->sa_len = 0;
if (alg->cra_type == &crypto_ablkcipher_type) switch (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) {
default:
tfm->crt_ablkcipher.reqsize = sizeof(struct crypto4xx_ctx); tfm->crt_ablkcipher.reqsize = sizeof(struct crypto4xx_ctx);
else if (alg->cra_type == &crypto_ahash_type) break;
case CRYPTO_ALG_TYPE_AHASH:
crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm), crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
sizeof(struct crypto4xx_ctx)); sizeof(struct crypto4xx_ctx));
break;
}
return 0; return 0;
} }
@ -1016,7 +1018,8 @@ static void crypto4xx_alg_exit(struct crypto_tfm *tfm)
} }
int crypto4xx_register_alg(struct crypto4xx_device *sec_dev, int crypto4xx_register_alg(struct crypto4xx_device *sec_dev,
struct crypto_alg *crypto_alg, int array_size) struct crypto4xx_alg_common *crypto_alg,
int array_size)
{ {
struct crypto4xx_alg *alg; struct crypto4xx_alg *alg;
int i; int i;
@ -1028,13 +1031,18 @@ int crypto4xx_register_alg(struct crypto4xx_device *sec_dev,
return -ENOMEM; return -ENOMEM;
alg->alg = crypto_alg[i]; alg->alg = crypto_alg[i];
INIT_LIST_HEAD(&alg->alg.cra_list);
if (alg->alg.cra_init == NULL)
alg->alg.cra_init = crypto4xx_alg_init;
if (alg->alg.cra_exit == NULL)
alg->alg.cra_exit = crypto4xx_alg_exit;
alg->dev = sec_dev; alg->dev = sec_dev;
rc = crypto_register_alg(&alg->alg);
switch (alg->alg.type) {
case CRYPTO_ALG_TYPE_AHASH:
rc = crypto_register_ahash(&alg->alg.u.hash);
break;
default:
rc = crypto_register_alg(&alg->alg.u.cipher);
break;
}
if (rc) { if (rc) {
list_del(&alg->entry); list_del(&alg->entry);
kfree(alg); kfree(alg);
@ -1052,7 +1060,14 @@ static void crypto4xx_unregister_alg(struct crypto4xx_device *sec_dev)
list_for_each_entry_safe(alg, tmp, &sec_dev->alg_list, entry) { list_for_each_entry_safe(alg, tmp, &sec_dev->alg_list, entry) {
list_del(&alg->entry); list_del(&alg->entry);
crypto_unregister_alg(&alg->alg); switch (alg->alg.type) {
case CRYPTO_ALG_TYPE_AHASH:
crypto_unregister_ahash(&alg->alg.u.hash);
break;
default:
crypto_unregister_alg(&alg->alg.u.cipher);
}
kfree(alg); kfree(alg);
} }
} }
@ -1105,17 +1120,18 @@ static irqreturn_t crypto4xx_ce_interrupt_handler(int irq, void *data)
/** /**
* Supported Crypto Algorithms * Supported Crypto Algorithms
*/ */
struct crypto_alg crypto4xx_alg[] = { struct crypto4xx_alg_common crypto4xx_alg[] = {
/* Crypto AES modes */ /* Crypto AES modes */
{ { .type = CRYPTO_ALG_TYPE_ABLKCIPHER, .u.cipher = {
.cra_name = "cbc(aes)", .cra_name = "cbc(aes)",
.cra_driver_name = "cbc-aes-ppc4xx", .cra_driver_name = "cbc-aes-ppc4xx",
.cra_priority = CRYPTO4XX_CRYPTO_PRIORITY, .cra_priority = CRYPTO4XX_CRYPTO_PRIORITY,
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
.cra_blocksize = AES_BLOCK_SIZE, .cra_blocksize = AES_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct crypto4xx_ctx), .cra_ctxsize = sizeof(struct crypto4xx_ctx),
.cra_alignmask = 0,
.cra_type = &crypto_ablkcipher_type, .cra_type = &crypto_ablkcipher_type,
.cra_init = crypto4xx_alg_init,
.cra_exit = crypto4xx_alg_exit,
.cra_module = THIS_MODULE, .cra_module = THIS_MODULE,
.cra_u = { .cra_u = {
.ablkcipher = { .ablkcipher = {
@ -1127,29 +1143,26 @@ struct crypto_alg crypto4xx_alg[] = {
.decrypt = crypto4xx_decrypt, .decrypt = crypto4xx_decrypt,
} }
} }
}, }},
/* Hash SHA1 */ /* Hash SHA1 */
{ { .type = CRYPTO_ALG_TYPE_AHASH, .u.hash = {
.cra_name = "sha1", .init = crypto4xx_hash_init,
.cra_driver_name = "sha1-ppc4xx", .update = crypto4xx_hash_update,
.cra_priority = CRYPTO4XX_CRYPTO_PRIORITY, .final = crypto4xx_hash_final,
.cra_flags = CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC, .digest = crypto4xx_hash_digest,
.cra_blocksize = SHA1_BLOCK_SIZE, .halg.digestsize = SHA1_DIGEST_SIZE,
.cra_ctxsize = sizeof(struct crypto4xx_ctx), .halg.base = {
.cra_alignmask = 0, .cra_name = "sha1",
.cra_type = &crypto_ahash_type, .cra_driver_name = "sha1-ppc4xx",
.cra_init = crypto4xx_sha1_alg_init, .cra_priority = CRYPTO4XX_CRYPTO_PRIORITY,
.cra_module = THIS_MODULE, .cra_flags = CRYPTO_ALG_ASYNC,
.cra_u = { .cra_blocksize = SHA1_BLOCK_SIZE,
.ahash = { .cra_ctxsize = sizeof(struct crypto4xx_ctx),
.digestsize = SHA1_DIGEST_SIZE, .cra_init = crypto4xx_sha1_alg_init,
.init = crypto4xx_hash_init, .cra_exit = crypto4xx_alg_exit,
.update = crypto4xx_hash_update, .cra_module = THIS_MODULE,
.final = crypto4xx_hash_final,
.digest = crypto4xx_hash_digest,
}
} }
}, }},
}; };
/** /**

25
drivers/crypto/amcc/crypto4xx_core.h
View File

@ -22,6 +22,8 @@
#ifndef __CRYPTO4XX_CORE_H__ #ifndef __CRYPTO4XX_CORE_H__
#define __CRYPTO4XX_CORE_H__ #define __CRYPTO4XX_CORE_H__
#include <crypto/internal/hash.h>
#define PPC460SX_SDR0_SRST 0x201 #define PPC460SX_SDR0_SRST 0x201
#define PPC405EX_SDR0_SRST 0x200 #define PPC405EX_SDR0_SRST 0x200
#define PPC460EX_SDR0_SRST 0x201 #define PPC460EX_SDR0_SRST 0x201
@ -138,14 +140,31 @@ struct crypto4xx_req_ctx {
u16 sa_len; u16 sa_len;
}; };
struct crypto4xx_alg_common {
u32 type;
union {
struct crypto_alg cipher;
struct ahash_alg hash;
} u;
};
struct crypto4xx_alg { struct crypto4xx_alg {
struct list_head entry; struct list_head entry;
struct crypto_alg alg; struct crypto4xx_alg_common alg;
struct crypto4xx_device *dev; struct crypto4xx_device *dev;
}; };
#define crypto_alg_to_crypto4xx_alg(x) \ static inline struct crypto4xx_alg *crypto_alg_to_crypto4xx_alg(
container_of(x, struct crypto4xx_alg, alg) struct crypto_alg *x)
{
switch (x->cra_flags & CRYPTO_ALG_TYPE_MASK) {
case CRYPTO_ALG_TYPE_AHASH:
return container_of(__crypto_ahash_alg(x),
struct crypto4xx_alg, alg.u.hash);
}
return container_of(x, struct crypto4xx_alg, alg.u.cipher);
}
extern int crypto4xx_alloc_sa(struct crypto4xx_ctx *ctx, u32 size); extern int crypto4xx_alloc_sa(struct crypto4xx_ctx *ctx, u32 size);
extern void crypto4xx_free_sa(struct crypto4xx_ctx *ctx); extern void crypto4xx_free_sa(struct crypto4xx_ctx *ctx);

6
include/crypto/internal/hash.h
View File

@ -103,6 +103,12 @@ static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm)
return crypto_tfm_ctx(crypto_ahash_tfm(tfm)); return crypto_tfm_ctx(crypto_ahash_tfm(tfm));
} }
static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg)
{
return container_of(__crypto_hash_alg_common(alg), struct ahash_alg,
halg);
}
static inline struct old_ahash_alg *crypto_old_ahash_alg( static inline struct old_ahash_alg *crypto_old_ahash_alg(
struct crypto_ahash *tfm) struct crypto_ahash *tfm)
{ {