Lines Matching defs:req
304 struct skcipher_request *req =
357 sg_copy_part_to_buf(req->dst, rctx->msg_buf.iv_ctr,
373 sg_copy_part_to_buf(req->src, rctx->msg_buf.iv_ctr,
459 err = mailbox_send_message(mssg, req->base.flags, rctx->chan_idx);
475 struct skcipher_request *req = skcipher_request_cast(areq);
496 dump_sg(req->dst, rctx->total_received, payload_len);
565 * @hash_carry_len: Number of bytes of data carried over from previous req
657 struct ahash_request *req = ahash_request_cast(areq);
658 struct crypto_ahash *ahash = crypto_ahash_reqtfm(req);
663 /* number of bytes still to be hashed in this req */
748 sg_copy_part_to_buf(req->src, dest, new_len,
784 /* if you sent a prebuf then that wasn't from this req->src */
880 err = mailbox_send_message(mssg, req->base.flags, rctx->chan_idx);
890 * @req: The HMAC request from the crypto API
897 static int spu_hmac_outer_hash(struct ahash_request *req,
900 struct crypto_ahash *ahash = crypto_ahash_reqtfm(req);
907 rc = do_shash("md5", req->result, ctx->opad, blocksize,
908 req->result, ctx->digestsize, NULL, 0);
911 rc = do_shash("sha1", req->result, ctx->opad, blocksize,
912 req->result, ctx->digestsize, NULL, 0);
915 rc = do_shash("sha224", req->result, ctx->opad, blocksize,
916 req->result, ctx->digestsize, NULL, 0);
919 rc = do_shash("sha256", req->result, ctx->opad, blocksize,
920 req->result, ctx->digestsize, NULL, 0);
923 rc = do_shash("sha384", req->result, ctx->opad, blocksize,
924 req->result, ctx->digestsize, NULL, 0);
927 rc = do_shash("sha512", req->result, ctx->opad, blocksize,
928 req->result, ctx->digestsize, NULL, 0);
948 struct ahash_request *req = ahash_request_cast(areq);
952 memcpy(req->result, rctx->msg_buf.digest, ctx->digestsize);
959 __swab32s((u32 *)req->result);
960 __swab32s(((u32 *)req->result) + 1);
961 __swab32s(((u32 *)req->result) + 2);
962 __swab32s(((u32 *)req->result) + 3);
963 __swab32s(((u32 *)req->result) + 4);
967 flow_dump(" digest ", req->result, ctx->digestsize);
971 err = spu_hmac_outer_hash(req, ctx);
974 flow_dump(" hmac: ", req->result, ctx->digestsize);
998 struct ahash_request *req = ahash_request_cast(areq);
999 struct crypto_ahash *ahash = crypto_ahash_reqtfm(req);
1022 * @req: Crypto API request
1043 struct aead_request *req,
1093 * Don't write directly to req->dst, because SPU may pad the
1263 struct aead_request *req = container_of(areq,
1320 aead_parms.assoc_size = req->assoclen;
1393 spu->spu_ccm_update_iv(digestsize, &cipher_parms, req->assoclen,
1421 sg_copy_part_to_buf(req->src, rctx->msg_buf.digest, digestsize,
1422 req->assoclen + rctx->total_sent -
1495 err = spu_aead_rx_sg_create(mssg, req, rctx, rx_frag_num,
1518 err = mailbox_send_message(mssg, req->base.flags, rctx->chan_idx);
1533 struct aead_request *req = container_of(areq,
1547 if (req->assoclen)
1549 req->assoclen);
1556 result_len = req->cryptlen;
1558 icv_offset = req->assoclen + rctx->total_sent;
1561 sg_copy_part_from_buf(req->dst, rctx->msg_buf.digest,
1567 dump_sg(req->dst, req->assoclen, result_len);
1706 * @req: Crypto API request
1713 static int skcipher_enqueue(struct skcipher_request *req, bool encrypt)
1715 struct iproc_reqctx_s *rctx = skcipher_request_ctx(req);
1717 crypto_skcipher_ctx(crypto_skcipher_reqtfm(req));
1722 rctx->gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
1724 rctx->parent = &req->base;
1727 rctx->total_todo = req->cryptlen;
1734 rctx->src_sg = req->src;
1737 rctx->dst_sg = req->dst;
1748 crypto_skcipher_ivsize(crypto_skcipher_reqtfm(req));
1749 memcpy(rctx->msg_buf.iv_ctr, req->iv, rctx->iv_ctr_len);
1890 static int skcipher_encrypt(struct skcipher_request *req)
1892 flow_log("skcipher_encrypt() nbytes:%u\n", req->cryptlen);
1894 return skcipher_enqueue(req, true);
1897 static int skcipher_decrypt(struct skcipher_request *req)
1899 flow_log("skcipher_decrypt() nbytes:%u\n", req->cryptlen);
1900 return skcipher_enqueue(req, false);
1903 static int ahash_enqueue(struct ahash_request *req)
1905 struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
1906 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
1911 flow_log("ahash_enqueue() nbytes:%u\n", req->nbytes);
1913 rctx->gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
1915 rctx->parent = &req->base;
1921 rctx->src_sg = req->src;
1934 err = do_shash((unsigned char *)alg_name, req->result,
1959 static int __ahash_init(struct ahash_request *req)
1962 struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
1963 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2017 static int ahash_init(struct ahash_request *req)
2019 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2039 gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
2063 ret = __ahash_init(req);
2076 static int __ahash_update(struct ahash_request *req)
2078 struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
2080 flow_log("ahash_update() nbytes:%u\n", req->nbytes);
2082 if (!req->nbytes)
2084 rctx->total_todo += req->nbytes;
2087 return ahash_enqueue(req);
2090 static int ahash_update(struct ahash_request *req)
2092 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2105 if (req->src)
2106 nents = sg_nents(req->src);
2110 /* Copy data from req scatterlist to tmp buffer */
2111 gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
2113 tmpbuf = kmalloc(req->nbytes, gfp);
2117 if (sg_copy_to_buffer(req->src, nents, tmpbuf, req->nbytes) !=
2118 req->nbytes) {
2124 ret = crypto_shash_update(ctx->shash, tmpbuf, req->nbytes);
2128 ret = __ahash_update(req);
2134 static int __ahash_final(struct ahash_request *req)
2136 struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
2138 flow_log("ahash_final() nbytes:%u\n", req->nbytes);
2142 return ahash_enqueue(req);
2145 static int ahash_final(struct ahash_request *req)
2147 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2157 ret = crypto_shash_final(ctx->shash, req->result);
2165 ret = __ahash_final(req);
2171 static int __ahash_finup(struct ahash_request *req)
2173 struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
2175 flow_log("ahash_finup() nbytes:%u\n", req->nbytes);
2177 rctx->total_todo += req->nbytes;
2181 return ahash_enqueue(req);
2184 static int ahash_finup(struct ahash_request *req)
2186 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2199 if (req->src) {
2200 nents = sg_nents(req->src);
2206 /* Copy data from req scatterlist to tmp buffer */
2207 gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
2209 tmpbuf = kmalloc(req->nbytes, gfp);
2215 if (sg_copy_to_buffer(req->src, nents, tmpbuf, req->nbytes) !=
2216 req->nbytes) {
2222 ret = crypto_shash_finup(ctx->shash, tmpbuf, req->nbytes,
2223 req->result);
2226 return __ahash_finup(req);
2238 static int ahash_digest(struct ahash_request *req)
2242 flow_log("ahash_digest() nbytes:%u\n", req->nbytes);
2245 err = __ahash_init(req);
2247 err = __ahash_finup(req);
2286 static int ahash_export(struct ahash_request *req, void *out)
2288 const struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
2301 static int ahash_import(struct ahash_request *req, const void *in)
2303 struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
2417 static int ahash_hmac_init(struct ahash_request *req)
2420 struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
2421 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2429 ret = ahash_init(req);
2446 static int ahash_hmac_update(struct ahash_request *req)
2448 flow_log("ahash_hmac_update() nbytes:%u\n", req->nbytes);
2450 if (!req->nbytes)
2453 return ahash_update(req);
2456 static int ahash_hmac_final(struct ahash_request *req)
2458 flow_log("ahash_hmac_final() nbytes:%u\n", req->nbytes);
2460 return ahash_final(req);
2463 static int ahash_hmac_finup(struct ahash_request *req)
2465 flow_log("ahash_hmac_finupl() nbytes:%u\n", req->nbytes);
2467 return ahash_finup(req);
2470 static int ahash_hmac_digest(struct ahash_request *req)
2472 struct iproc_reqctx_s *rctx = ahash_request_ctx(req);
2473 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2478 flow_log("ahash_hmac_digest() nbytes:%u\n", req->nbytes);
2481 __ahash_init(req);
2503 return __ahash_finup(req);
2508 static int aead_need_fallback(struct aead_request *req)
2510 struct iproc_reqctx_s *rctx = aead_request_ctx(req);
2512 struct crypto_aead *aead = crypto_aead_reqtfm(req);
2522 (req->assoclen == 0)) {
2523 if ((rctx->is_encrypt && (req->cryptlen == 0)) ||
2524 (!rctx->is_encrypt && (req->cryptlen == ctx->digestsize))) {
2525 flow_log("AES GCM/CCM needs fallback for 0 len req\n");
2546 (req->assoclen == 0)) {
2559 req->assoclen != 16 && req->assoclen != 20) {
2565 payload_len = req->cryptlen;
2567 payload_len += req->assoclen;
2577 static int aead_do_fallback(struct aead_request *req, bool is_encrypt)
2579 struct crypto_aead *aead = crypto_aead_reqtfm(req);
2581 struct iproc_reqctx_s *rctx = aead_request_ctx(req);
2590 subreq = &rctx->req;
2592 aead_request_set_callback(subreq, aead_request_flags(req),
2593 req->base.complete, req->base.data);
2594 aead_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,
2595 req->iv);
2596 aead_request_set_ad(subreq, req->assoclen);
2598 return is_encrypt ? crypto_aead_encrypt(req) :
2599 crypto_aead_decrypt(req);
2602 static int aead_enqueue(struct aead_request *req, bool is_encrypt)
2604 struct iproc_reqctx_s *rctx = aead_request_ctx(req);
2605 struct crypto_aead *aead = crypto_aead_reqtfm(req);
2611 if (req->assoclen > MAX_ASSOC_SIZE) {
2614 __func__, req->assoclen, MAX_ASSOC_SIZE);
2618 rctx->gfp = (req->base.flags & (CRYPTO_TFM_REQ_MAY_BACKLOG |
2620 rctx->parent = &req->base;
2623 rctx->total_todo = req->cryptlen;
2632 rctx->assoc = req->src;
2639 if (spu_sg_at_offset(req->src, req->assoclen, &rctx->src_sg,
2648 if (req->dst == req->src) {
2653 * Expect req->dst to have room for assoc data followed by
2657 if (spu_sg_at_offset(req->dst, req->assoclen, &rctx->dst_sg,
2672 crypto_aead_ivsize(crypto_aead_reqtfm(req));
2681 flow_log(" src sg: %p\n", req->src);
2684 flow_log(" assoc: %p, assoclen %u\n", rctx->assoc, req->assoclen);
2685 flow_log(" dst sg: %p\n", req->dst);
2689 flow_dump(" iv: ", req->iv, rctx->iv_ctr_len);
2698 if (unlikely(aead_need_fallback(req)))
2699 return aead_do_fallback(req, is_encrypt);
2710 req->iv,
3007 static int aead_encrypt(struct aead_request *req)
3009 flow_log("%s() cryptlen:%u %08x\n", __func__, req->cryptlen,
3010 req->cryptlen);
3011 dump_sg(req->src, 0, req->cryptlen + req->assoclen);
3012 flow_log(" assoc_len:%u\n", req->assoclen);
3014 return aead_enqueue(req, true);
3017 static int aead_decrypt(struct aead_request *req)
3019 flow_log("%s() cryptlen:%u\n", __func__, req->cryptlen);
3020 dump_sg(req->src, 0, req->cryptlen + req->assoclen);
3021 flow_log(" assoc_len:%u\n", req->assoclen);
3023 return aead_enqueue(req, false);