leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6

Browse Source 
* git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6:
  crypto: crypto4xx - Fix build breakage
  n2_crypto: Plumb fallback ahash requests properly.
  n2_crypto: Fix MAU kmem_cache name.
  n2_crypto: Fix build after of_device/of_platform_driver changes.
This commit is contained in:
Linus Torvalds 2010-06-03 15:42:21 -07:00
commit 95619be590
1 changed files with 66 additions and 59 deletions

121
drivers/crypto/n2_core.c
View File

@ -251,16 +251,10 @@ static void n2_base_ctx_init(struct n2_base_ctx *ctx)
struct n2_hash_ctx { struct n2_hash_ctx {
struct n2_base_ctx base; struct n2_base_ctx base;
struct crypto_ahash *fallback; struct crypto_ahash *fallback_tfm;
};
/* These next three members must match the layout created by struct n2_hash_req_ctx {
* crypto_init_shash_ops_async. This allows us to properly
* plumb requests we can't do in hardware down to the fallback
* operation, providing all of the data structures and layouts
* expected by those paths.
*/
struct ahash_request fallback_req;
struct shash_desc fallback_desc;
union { union {
struct md5_state md5; struct md5_state md5;
struct sha1_state sha1; struct sha1_state sha1;
@ -269,56 +263,62 @@ struct n2_hash_ctx {
unsigned char hash_key[64]; unsigned char hash_key[64];
unsigned char keyed_zero_hash[32]; unsigned char keyed_zero_hash[32];
struct ahash_request fallback_req;
}; };
static int n2_hash_async_init(struct ahash_request *req) static int n2_hash_async_init(struct ahash_request *req)
{ {
struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm); struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm);
ctx->fallback_req.base.tfm = crypto_ahash_tfm(ctx->fallback); ahash_request_set_tfm(&rctx->fallback_req, ctx->fallback_tfm);
ctx->fallback_req.base.flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP; rctx->fallback_req.base.flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP;
return crypto_ahash_init(&ctx->fallback_req); return crypto_ahash_init(&rctx->fallback_req);
} }
static int n2_hash_async_update(struct ahash_request *req) static int n2_hash_async_update(struct ahash_request *req)
{ {
struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm); struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm);
ctx->fallback_req.base.tfm = crypto_ahash_tfm(ctx->fallback); ahash_request_set_tfm(&rctx->fallback_req, ctx->fallback_tfm);
ctx->fallback_req.base.flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP; rctx->fallback_req.base.flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP;
ctx->fallback_req.nbytes = req->nbytes; rctx->fallback_req.nbytes = req->nbytes;
ctx->fallback_req.src = req->src; rctx->fallback_req.src = req->src;
return crypto_ahash_update(&ctx->fallback_req); return crypto_ahash_update(&rctx->fallback_req);
} }
static int n2_hash_async_final(struct ahash_request *req) static int n2_hash_async_final(struct ahash_request *req)
{ {
struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm); struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm);
ctx->fallback_req.base.tfm = crypto_ahash_tfm(ctx->fallback); ahash_request_set_tfm(&rctx->fallback_req, ctx->fallback_tfm);
ctx->fallback_req.base.flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP; rctx->fallback_req.base.flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP;
ctx->fallback_req.result = req->result; rctx->fallback_req.result = req->result;
return crypto_ahash_final(&ctx->fallback_req); return crypto_ahash_final(&rctx->fallback_req);
} }
static int n2_hash_async_finup(struct ahash_request *req) static int n2_hash_async_finup(struct ahash_request *req)
{ {
struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm); struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm);
ctx->fallback_req.base.tfm = crypto_ahash_tfm(ctx->fallback); ahash_request_set_tfm(&rctx->fallback_req, ctx->fallback_tfm);
ctx->fallback_req.base.flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP; rctx->fallback_req.base.flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP;
ctx->fallback_req.nbytes = req->nbytes; rctx->fallback_req.nbytes = req->nbytes;
ctx->fallback_req.src = req->src; rctx->fallback_req.src = req->src;
ctx->fallback_req.result = req->result; rctx->fallback_req.result = req->result;
return crypto_ahash_finup(&ctx->fallback_req); return crypto_ahash_finup(&rctx->fallback_req);
} }
static int n2_hash_cra_init(struct crypto_tfm *tfm) static int n2_hash_cra_init(struct crypto_tfm *tfm)
@ -338,7 +338,10 @@ static int n2_hash_cra_init(struct crypto_tfm *tfm)
goto out; goto out;
} }
ctx->fallback = fallback_tfm; crypto_ahash_set_reqsize(ahash, (sizeof(struct n2_hash_req_ctx) +
crypto_ahash_reqsize(fallback_tfm)));
ctx->fallback_tfm = fallback_tfm;
return 0; return 0;
out: out:
@ -350,7 +353,7 @@ static void n2_hash_cra_exit(struct crypto_tfm *tfm)
struct crypto_ahash *ahash = __crypto_ahash_cast(tfm); struct crypto_ahash *ahash = __crypto_ahash_cast(tfm);
struct n2_hash_ctx *ctx = crypto_ahash_ctx(ahash); struct n2_hash_ctx *ctx = crypto_ahash_ctx(ahash);
crypto_free_ahash(ctx->fallback); crypto_free_ahash(ctx->fallback_tfm);
} }
static unsigned long wait_for_tail(struct spu_queue *qp) static unsigned long wait_for_tail(struct spu_queue *qp)
@ -399,14 +402,16 @@ static int n2_hash_async_digest(struct ahash_request *req,
* exceed 2^16. * exceed 2^16.
*/ */
if (unlikely(req->nbytes > (1 << 16))) { if (unlikely(req->nbytes > (1 << 16))) {
ctx->fallback_req.base.tfm = crypto_ahash_tfm(ctx->fallback); struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
ctx->fallback_req.base.flags =
req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP;
ctx->fallback_req.nbytes = req->nbytes;
ctx->fallback_req.src = req->src;
ctx->fallback_req.result = req->result;
return crypto_ahash_digest(&ctx->fallback_req); ahash_request_set_tfm(&rctx->fallback_req, ctx->fallback_tfm);
rctx->fallback_req.base.flags =
req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP;
rctx->fallback_req.nbytes = req->nbytes;
rctx->fallback_req.src = req->src;
rctx->fallback_req.result = req->result;
return crypto_ahash_digest(&rctx->fallback_req);
} }
n2_base_ctx_init(&ctx->base); n2_base_ctx_init(&ctx->base);
@ -472,9 +477,8 @@ out:
static int n2_md5_async_digest(struct ahash_request *req) static int n2_md5_async_digest(struct ahash_request *req)
{ {
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm); struct md5_state *m = &rctx->u.md5;
struct md5_state *m = &ctx->u.md5;
if (unlikely(req->nbytes == 0)) { if (unlikely(req->nbytes == 0)) {
static const char md5_zero[MD5_DIGEST_SIZE] = { static const char md5_zero[MD5_DIGEST_SIZE] = {
@ -497,9 +501,8 @@ static int n2_md5_async_digest(struct ahash_request *req)
static int n2_sha1_async_digest(struct ahash_request *req) static int n2_sha1_async_digest(struct ahash_request *req)
{ {
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm); struct sha1_state *s = &rctx->u.sha1;
struct sha1_state *s = &ctx->u.sha1;
if (unlikely(req->nbytes == 0)) { if (unlikely(req->nbytes == 0)) {
static const char sha1_zero[SHA1_DIGEST_SIZE] = { static const char sha1_zero[SHA1_DIGEST_SIZE] = {
@ -524,9 +527,8 @@ static int n2_sha1_async_digest(struct ahash_request *req)
static int n2_sha256_async_digest(struct ahash_request *req) static int n2_sha256_async_digest(struct ahash_request *req)
{ {
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm); struct sha256_state *s = &rctx->u.sha256;
struct sha256_state *s = &ctx->u.sha256;
if (req->nbytes == 0) { if (req->nbytes == 0) {
static const char sha256_zero[SHA256_DIGEST_SIZE] = { static const char sha256_zero[SHA256_DIGEST_SIZE] = {
@ -555,9 +557,8 @@ static int n2_sha256_async_digest(struct ahash_request *req)
static int n2_sha224_async_digest(struct ahash_request *req) static int n2_sha224_async_digest(struct ahash_request *req)
{ {
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm); struct sha256_state *s = &rctx->u.sha256;
struct sha256_state *s = &ctx->u.sha256;
if (req->nbytes == 0) { if (req->nbytes == 0) {
static const char sha224_zero[SHA224_DIGEST_SIZE] = { static const char sha224_zero[SHA224_DIGEST_SIZE] = {
@ -1398,7 +1399,7 @@ static int find_devino_index(struct of_device *dev, struct spu_mdesc_info *ip,
intr = ip->ino_table[i].intr; intr = ip->ino_table[i].intr;
dev_intrs = of_get_property(dev->node, "interrupts", NULL); dev_intrs = of_get_property(dev->dev.of_node, "interrupts", NULL);
if (!dev_intrs) if (!dev_intrs)
return -ENODEV; return -ENODEV;
@ -1449,7 +1450,7 @@ static int queue_cache_init(void)
{ {
if (!queue_cache[HV_NCS_QTYPE_MAU - 1]) if (!queue_cache[HV_NCS_QTYPE_MAU - 1])
queue_cache[HV_NCS_QTYPE_MAU - 1] = queue_cache[HV_NCS_QTYPE_MAU - 1] =
kmem_cache_create("cwq_queue", kmem_cache_create("mau_queue",
(MAU_NUM_ENTRIES * (MAU_NUM_ENTRIES *
MAU_ENTRY_SIZE), MAU_ENTRY_SIZE),
MAU_ENTRY_SIZE, 0, NULL); MAU_ENTRY_SIZE, 0, NULL);
@ -1574,7 +1575,7 @@ static int spu_mdesc_walk_arcs(struct mdesc_handle *mdesc,
id = mdesc_get_property(mdesc, tgt, "id", NULL); id = mdesc_get_property(mdesc, tgt, "id", NULL);
if (table[*id] != NULL) { if (table[*id] != NULL) {
dev_err(&dev->dev, "%s: SPU cpu slot already set.\n", dev_err(&dev->dev, "%s: SPU cpu slot already set.\n",
dev->node->full_name); dev->dev.of_node->full_name);
return -EINVAL; return -EINVAL;
} }
cpu_set(*id, p->sharing); cpu_set(*id, p->sharing);
@ -1595,7 +1596,7 @@ static int handle_exec_unit(struct spu_mdesc_info *ip, struct list_head *list,
p = kzalloc(sizeof(struct spu_queue), GFP_KERNEL); p = kzalloc(sizeof(struct spu_queue), GFP_KERNEL);
if (!p) { if (!p) {
dev_err(&dev->dev, "%s: Could not allocate SPU queue.\n", dev_err(&dev->dev, "%s: Could not allocate SPU queue.\n",
dev->node->full_name); dev->dev.of_node->full_name);
return -ENOMEM; return -ENOMEM;
} }
@ -1684,7 +1685,7 @@ static int __devinit grab_mdesc_irq_props(struct mdesc_handle *mdesc,
const unsigned int *reg; const unsigned int *reg;
u64 node; u64 node;
reg = of_get_property(dev->node, "reg", NULL); reg = of_get_property(dev->dev.of_node, "reg", NULL);
if (!reg) if (!reg)
return -ENODEV; return -ENODEV;
@ -1836,7 +1837,7 @@ static int __devinit n2_crypto_probe(struct of_device *dev,
n2_spu_driver_version(); n2_spu_driver_version();
full_name = dev->node->full_name; full_name = dev->dev.of_node->full_name;
pr_info("Found N2CP at %s\n", full_name); pr_info("Found N2CP at %s\n", full_name);
np = alloc_n2cp(); np = alloc_n2cp();
@ -1948,7 +1949,7 @@ static int __devinit n2_mau_probe(struct of_device *dev,
n2_spu_driver_version(); n2_spu_driver_version();
full_name = dev->node->full_name; full_name = dev->dev.of_node->full_name;
pr_info("Found NCP at %s\n", full_name); pr_info("Found NCP at %s\n", full_name);
mp = alloc_ncp(); mp = alloc_ncp();
@ -2034,8 +2035,11 @@ static struct of_device_id n2_crypto_match[] = {
MODULE_DEVICE_TABLE(of, n2_crypto_match); MODULE_DEVICE_TABLE(of, n2_crypto_match);
static struct of_platform_driver n2_crypto_driver = { static struct of_platform_driver n2_crypto_driver = {
.driver = {
.name = "n2cp", .name = "n2cp",
.match_table = n2_crypto_match, .owner = THIS_MODULE,
.of_match_table = n2_crypto_match,
},
.probe = n2_crypto_probe, .probe = n2_crypto_probe,
.remove = __devexit_p(n2_crypto_remove), .remove = __devexit_p(n2_crypto_remove),
}; };
@ -2055,8 +2059,11 @@ static struct of_device_id n2_mau_match[] = {
MODULE_DEVICE_TABLE(of, n2_mau_match); MODULE_DEVICE_TABLE(of, n2_mau_match);
static struct of_platform_driver n2_mau_driver = { static struct of_platform_driver n2_mau_driver = {
.driver = {
.name = "ncp", .name = "ncp",
.match_table = n2_mau_match, .owner = THIS_MODULE,
.of_match_table = n2_mau_match,
},
.probe = n2_mau_probe, .probe = n2_mau_probe,
.remove = __devexit_p(n2_mau_remove), .remove = __devexit_p(n2_mau_remove),
}; };