Lines Matching refs:req
303 struct skcipher_request *req =
356 sg_copy_part_to_buf(req->dst, rctx->msg_buf.iv_ctr,
372 sg_copy_part_to_buf(req->src, rctx->msg_buf.iv_ctr,
458 err = mailbox_send_message(mssg, req->base.flags, rctx->chan_idx);
474 struct skcipher_request *req = skcipher_request_cast(areq);
495 dump_sg(req->dst, rctx->total_received, payload_len);
564 * @hash_carry_len: Number of bytes of data carried over from previous req
656 struct ahash_request *req = ahash_request_cast(areq);
657 struct crypto_ahash *ahash = crypto_ahash_reqtfm(req);
662 /* number of bytes still to be hashed in this req */
747 sg_copy_part_to_buf(req->src, dest, new_len,
783 /* if you sent a prebuf then that wasn't from this req->src */
879 err = mailbox_send_message(mssg, req->base.flags, rctx->chan_idx);
889 * @req: The HMAC request from the crypto API
896 static int spu_hmac_outer_hash(struct ahash_request *req,
899 struct crypto_ahash *ahash = crypto_ahash_reqtfm(req);
906 rc = do_shash("md5", req->result, ctx->opad, blocksize,
907 req->result, ctx->digestsize, NULL, 0);
910 rc = do_shash("sha1", req->result, ctx->opad, blocksize,
911 req->result, ctx->digestsize, NULL, 0);
914 rc = do_shash("sha224", req->result, ctx->opad, blocksize,
915 req->result, ctx->digestsize, NULL, 0);
918 rc = do_shash("sha256", req->result, ctx->opad, blocksize,
919 req->result, ctx->digestsize, NULL, 0);
922 rc = do_shash("sha384", req->result, ctx->opad, blocksize,
923 req->result, ctx->digestsize, NULL, 0);
926 rc = do_shash("sha512", req->result, ctx->opad, blocksize,
927 req->result, ctx->digestsize, NULL, 0);
947 struct ahash_request *req = ahash_request_cast(areq);
951 memcpy(req->result, rctx->msg_buf.digest, ctx->digestsize);
958 __swab32s((u32 *)req->result);
959 __swab32s(((u32 *)req->result) + 1);
960 __swab32s(((u32 *)req->result) + 2);
961 __swab32s(((u32 *)req->result) + 3);
962 __swab32s(((u32 *)req->result) + 4);
966 flow_dump(" digest ", req->result, ctx->digestsize);
970 err = spu_hmac_outer_hash(req, ctx);
973 flow_dump(" hmac: ", req->result, ctx->digestsize);
997 struct ahash_request *req = ahash_request_cast(areq);
998 struct crypto_ahash *ahash = crypto_ahash_reqtfm(req);
1021 * @req: Crypto API request
1042 struct aead_request *req,
1092 * Don't write directly to req->dst, because SPU may pad the
1262 struct aead_request *req = container_of(areq,
1319 aead_parms.assoc_size = req->assoclen;
1392 spu->spu_ccm_update_iv(digestsize, &cipher_parms, req->assoclen,
1420 sg_copy_part_to_buf(req->src, rctx->msg_buf.digest, digestsize,
1421 req->assoclen + rctx->total_sent -
1494 err = spu_aead_rx_sg_create(mssg, req, rctx, rx_frag_num,
1517 err = mailbox_send_message(mssg, req->base.flags, rctx->chan_idx);
1532 struct aead_request *req = container_of(areq,
1546 if (req->assoclen)
1548 req->assoclen);
1555 result_len = req->cryptlen;
1557 icv_offset = req->assoclen + rctx->total_sent;
1560 sg_copy_part_from_buf(req->dst, rctx->msg_buf.digest,
1566 dump_sg(req->dst, req->assoclen, result_len);
1705 * @req: Crypto API request
1712 static int skcipher_enqueue(struct skcipher_request *req, bool encrypt)
1714 struct iproc_reqctx_s *rctx = skcipher_request_ctx(req);
1716 crypto_skcipher_ctx(crypto_skcipher_reqtfm(req));
1721 rctx->gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
1723 rctx->parent = &req->base;
1726 rctx->total_todo = req->cryptlen;
1733 rctx->src_sg = req->src;
1736 rctx->dst_sg = req->dst;
1747 crypto_skcipher_ivsize(crypto_skcipher_reqtfm(req));
1748 memcpy(rctx->msg_buf.iv_ctr, req->iv, rctx->iv_ctr_len);
1889 static int skcipher_encrypt(struct skcipher_request *req)
1891 flow_log("skcipher_encrypt() nbytes:%u\n", req->cryptlen);
1893 return skcipher_enqueue(req, true);
1896 static int skcipher_decrypt(struct skcipher_request *req)
1898 flow_log("skcipher_decrypt() nbytes:%u\n", req->cryptlen);
1899 return skcipher_enqueue(req, false);
1902 static int ahash_enqueue(struct ahash_request *req)
1904 struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
1905 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
1910 flow_log("ahash_enqueue() nbytes:%u\n", req->nbytes);
1912 rctx->gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
1914 rctx->parent = &req->base;
1920 rctx->src_sg = req->src;
1933 err = do_shash((unsigned char *)alg_name, req->result,
1958 static int __ahash_init(struct ahash_request *req)
1961 struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
1962 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2016 static int ahash_init(struct ahash_request *req)
2018 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2038 gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
2062 ret = __ahash_init(req);
2075 static int __ahash_update(struct ahash_request *req)
2077 struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
2079 flow_log("ahash_update() nbytes:%u\n", req->nbytes);
2081 if (!req->nbytes)
2083 rctx->total_todo += req->nbytes;
2086 return ahash_enqueue(req);
2089 static int ahash_update(struct ahash_request *req)
2091 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2104 if (req->src)
2105 nents = sg_nents(req->src);
2109 /* Copy data from req scatterlist to tmp buffer */
2110 gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
2112 tmpbuf = kmalloc(req->nbytes, gfp);
2116 if (sg_copy_to_buffer(req->src, nents, tmpbuf, req->nbytes) !=
2117 req->nbytes) {
2123 ret = crypto_shash_update(ctx->shash, tmpbuf, req->nbytes);
2127 ret = __ahash_update(req);
2133 static int __ahash_final(struct ahash_request *req)
2135 struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
2137 flow_log("ahash_final() nbytes:%u\n", req->nbytes);
2141 return ahash_enqueue(req);
2144 static int ahash_final(struct ahash_request *req)
2146 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2156 ret = crypto_shash_final(ctx->shash, req->result);
2164 ret = __ahash_final(req);
2170 static int __ahash_finup(struct ahash_request *req)
2172 struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
2174 flow_log("ahash_finup() nbytes:%u\n", req->nbytes);
2176 rctx->total_todo += req->nbytes;
2180 return ahash_enqueue(req);
2183 static int ahash_finup(struct ahash_request *req)
2185 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2198 if (req->src) {
2199 nents = sg_nents(req->src);
2205 /* Copy data from req scatterlist to tmp buffer */
2206 gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
2208 tmpbuf = kmalloc(req->nbytes, gfp);
2214 if (sg_copy_to_buffer(req->src, nents, tmpbuf, req->nbytes) !=
2215 req->nbytes) {
2221 ret = crypto_shash_finup(ctx->shash, tmpbuf, req->nbytes,
2222 req->result);
2225 return __ahash_finup(req);
2237 static int ahash_digest(struct ahash_request *req)
2241 flow_log("ahash_digest() nbytes:%u\n", req->nbytes);
2244 err = __ahash_init(req);
2246 err = __ahash_finup(req);
2285 static int ahash_export(struct ahash_request *req, void *out)
2287 const struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
2300 static int ahash_import(struct ahash_request *req, const void *in)
2302 struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
2416 static int ahash_hmac_init(struct ahash_request *req)
2418 struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
2419 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2427 ahash_init(req);
2442 static int ahash_hmac_update(struct ahash_request *req)
2444 flow_log("ahash_hmac_update() nbytes:%u\n", req->nbytes);
2446 if (!req->nbytes)
2449 return ahash_update(req);
2452 static int ahash_hmac_final(struct ahash_request *req)
2454 flow_log("ahash_hmac_final() nbytes:%u\n", req->nbytes);
2456 return ahash_final(req);
2459 static int ahash_hmac_finup(struct ahash_request *req)
2461 flow_log("ahash_hmac_finupl() nbytes:%u\n", req->nbytes);
2463 return ahash_finup(req);
2466 static int ahash_hmac_digest(struct ahash_request *req)
2468 struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
2469 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2474 flow_log("ahash_hmac_digest() nbytes:%u\n", req->nbytes);
2477 __ahash_init(req);
2499 return __ahash_finup(req);
2504 static int aead_need_fallback(struct aead_request *req)
2506 struct iproc_reqctx_s *rctx = aead_request_ctx(req);
2508 struct crypto_aead *aead = crypto_aead_reqtfm(req);
2518 (req->assoclen == 0)) {
2519 if ((rctx->is_encrypt && (req->cryptlen == 0)) ||
2520 (!rctx->is_encrypt && (req->cryptlen == ctx->digestsize))) {
2521 flow_log("AES GCM/CCM needs fallback for 0 len req\n");
2542 (req->assoclen == 0)) {
2555 req->assoclen != 16 && req->assoclen != 20) {
2561 payload_len = req->cryptlen;
2563 payload_len += req->assoclen;
2573 static int aead_do_fallback(struct aead_request *req, bool is_encrypt)
2575 struct crypto_aead *aead = crypto_aead_reqtfm(req);
2577 struct iproc_reqctx_s *rctx = aead_request_ctx(req);
2586 subreq = &rctx->req;
2588 aead_request_set_callback(subreq, aead_request_flags(req),
2589 req->base.complete, req->base.data);
2590 aead_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,
2591 req->iv);
2592 aead_request_set_ad(subreq, req->assoclen);
2594 return is_encrypt ? crypto_aead_encrypt(req) :
2595 crypto_aead_decrypt(req);
2598 static int aead_enqueue(struct aead_request *req, bool is_encrypt)
2600 struct iproc_reqctx_s *rctx = aead_request_ctx(req);
2601 struct crypto_aead *aead = crypto_aead_reqtfm(req);
2607 if (req->assoclen > MAX_ASSOC_SIZE) {
2610 __func__, req->assoclen, MAX_ASSOC_SIZE);
2614 rctx->gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
2616 rctx->parent = &req->base;
2619 rctx->total_todo = req->cryptlen;
2628 rctx->assoc = req->src;
2635 if (spu_sg_at_offset(req->src, req->assoclen, &rctx->src_sg,
2644 if (req->dst == req->src) {
2649 * Expect req->dst to have room for assoc data followed by
2653 if (spu_sg_at_offset(req->dst, req->assoclen, &rctx->dst_sg,
2668 crypto_aead_ivsize(crypto_aead_reqtfm(req));
2677 flow_log(" src sg: %p\n", req->src);
2680 flow_log(" assoc: %p, assoclen %u\n", rctx->assoc, req->assoclen);
2681 flow_log(" dst sg: %p\n", req->dst);
2685 flow_dump(" iv: ", req->iv, rctx->iv_ctr_len);
2694 if (unlikely(aead_need_fallback(req)))
2695 return aead_do_fallback(req, is_encrypt);
2706 req->iv,
3003 static int aead_encrypt(struct aead_request *req)
3005 flow_log("%s() cryptlen:%u %08x\n", __func__, req->cryptlen,
3006 req->cryptlen);
3007 dump_sg(req->src, 0, req->cryptlen + req->assoclen);
3008 flow_log(" assoc_len:%u\n", req->assoclen);
3010 return aead_enqueue(req, true);
3013 static int aead_decrypt(struct aead_request *req)
3015 flow_log("%s() cryptlen:%u\n", __func__, req->cryptlen);
3016 dump_sg(req->src, 0, req->cryptlen + req->assoclen);
3017 flow_log(" assoc_len:%u\n", req->assoclen);
3019 return aead_enqueue(req, false);