Lines Matching refs:req
70 static inline u64 safexcel_queued_len(struct safexcel_ahash_req *req)
72 return req->len - req->processed;
109 struct safexcel_ahash_req *req,
123 if (unlikely(req->digest == CONTEXT_CONTROL_DIGEST_XCM)) {
124 if (req->xcbcmac)
127 memcpy(ctx->base.ctxr->data, req->state, req->state_sz);
129 if (!req->finish && req->xcbcmac)
134 CONTEXT_CONTROL_SIZE(req->state_sz /
140 CONTEXT_CONTROL_SIZE(req->state_sz /
143 } else if (!req->processed) {
145 if (req->finish)
146 cdesc->control_data.control0 |= req->digest |
152 cdesc->control_data.control0 |= req->digest |
162 memcpy(ctx->base.ctxr->data, req->state, req->state_sz);
164 if (req->finish) {
166 if ((req->digest == CONTEXT_CONTROL_DIGEST_PRECOMPUTED) ||
167 req->hmac_zlen || (req->processed != req->block_sz)) {
168 count = req->processed / EIP197_COUNTER_BLOCK_SIZE;
182 if ((req->digest == CONTEXT_CONTROL_DIGEST_PRECOMPUTED) ||
184 req->hmac_zlen ||
186 (req->processed != req->block_sz)) {
189 CONTEXT_CONTROL_SIZE((req->state_sz >> 2) + 1) |
193 if (req->hmac_zlen)
198 ctx->base.ctxr->data[req->state_sz >> 2] =
200 req->digest = CONTEXT_CONTROL_DIGEST_PRECOMPUTED;
203 req->hmac_zlen = false;
206 memcpy(ctx->base.ctxr->data + (req->state_sz >> 2),
207 &ctx->base.opad, req->state_sz);
211 CONTEXT_CONTROL_SIZE(req->state_sz >> 1) |
217 CONTEXT_CONTROL_SIZE(req->state_sz >> 2) |
315 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
325 queued = safexcel_queued_len(req);
331 if (!req->finish && !req->last_req) {
344 req->cache_next, extra,
358 if (unlikely(req->xcbcmac && req->processed > AES_BLOCK_SIZE)) {
371 req->cache + cache_len,
375 memset(req->cache + cache_len + skip, 0, extra);
378 req->cache[cache_len + skip] = 0x80;
381 u32 *cache = (void *)req->cache;
394 crypto_xor(req->cache, (const u8 *)req->state, AES_BLOCK_SIZE);
400 req->cache_dma = dma_map_single(priv->dev, req->cache,
402 if (dma_mapping_error(priv->dev, req->cache_dma))
405 req->cache_sz = cache_len;
408 req->cache_dma, cache_len,
423 req->nents = dma_map_sg(priv->dev, areq->src,
427 if (!req->nents) {
432 for_each_sg(areq->src, sg, req->nents, i) {
467 safexcel_context_control(ctx, req, first_cdesc);
470 safexcel_hash_token(first_cdesc, len, req->digest_sz, ctx->cbcmac);
472 req->result_dma = dma_map_single(priv->dev, req->state, req->digest_sz,
474 if (dma_mapping_error(priv->dev, req->result_dma)) {
480 rdesc = safexcel_add_rdesc(priv, ring, 1, 1, req->result_dma,
481 req->digest_sz);
489 req->processed += len - extra;
496 dma_unmap_single(priv->dev, req->result_dma, req->digest_sz,
499 if (req->nents) {
500 dma_unmap_sg(priv->dev, areq->src, req->nents, DMA_TO_DEVICE);
501 req->nents = 0;
507 if (req->cache_dma) {
508 dma_unmap_single(priv->dev, req->cache_dma, req->cache_sz,
510 req->cache_dma = 0;
511 req->cache_sz = 0;
572 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
575 BUG_ON(!(priv->flags & EIP197_TRC_CACHE) && req->needs_inv);
577 if (req->needs_inv) {
578 req->needs_inv = false;
611 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
614 if (req->needs_inv)
626 EIP197_REQUEST_ON_STACK(req, ahash, EIP197_AHASH_REQ_SIZE);
627 struct safexcel_ahash_req *rctx = ahash_request_ctx_dma(req);
632 memset(req, 0, EIP197_AHASH_REQ_SIZE);
636 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
639 ahash_request_set_tfm(req, __crypto_ahash_cast(tfm));
640 ctx = crypto_tfm_ctx(req->base.tfm);
645 crypto_enqueue_request(&priv->ring[ring].queue, &req->base);
666 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
670 * tot sz handled by update() - last req sz - tot sz handled by send()
672 cache_len = safexcel_queued_len(req);
680 req->cache + cache_len,
692 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
696 req->needs_inv = false;
701 ((req->not_first && !req->xcbcmac) ||
703 memcmp(ctx->base.ctxr->data, req->state, req->state_sz) ||
705 (req->finish && req->hmac &&
706 memcmp(ctx->base.ctxr->data + (req->state_sz>>2),
707 &ctx->base.opad, req->state_sz))))
718 req->needs_inv = true;
728 req->not_first = true;
744 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
755 req->len += areq->nbytes;
761 if ((ret && !req->finish) || req->last_req)
769 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
772 req->finish = true;
774 if (unlikely(!req->len && !areq->nbytes)) {
804 } else if (unlikely(req->digest == CONTEXT_CONTROL_DIGEST_XCM &&
806 req->len == sizeof(u32) && !areq->nbytes)) {
810 } else if (unlikely(ctx->cbcmac && req->len == AES_BLOCK_SIZE &&
815 } else if (unlikely(req->xcbcmac && req->len == AES_BLOCK_SIZE &&
829 } else if (unlikely(req->hmac &&
830 (req->len == req->block_sz) &&
840 memset(req->cache, 0, req->block_sz);
842 req->cache[0] = 0x80;
844 if (req->len_is_le) {
846 req->cache[req->block_sz-8] = (req->block_sz << 3) &
848 req->cache[req->block_sz-7] = (req->block_sz >> 5);
851 req->cache[req->block_sz-2] = (req->block_sz >> 5);
852 req->cache[req->block_sz-1] = (req->block_sz << 3) &
856 req->len += req->block_sz; /* plus 1 hash block */
859 req->hmac_zlen = true;
862 req->digest = CONTEXT_CONTROL_DIGEST_HMAC;
863 } else if (req->hmac) {
865 req->digest = CONTEXT_CONTROL_DIGEST_HMAC;
873 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
875 req->finish = true;
883 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
886 export->len = req->len;
887 export->processed = req->processed;
889 export->digest = req->digest;
891 memcpy(export->state, req->state, req->state_sz);
892 memcpy(export->cache, req->cache, HASH_CACHE_SIZE);
899 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
907 req->len = export->len;
908 req->processed = export->processed;
910 req->digest = export->digest;
912 memcpy(req->cache, export->cache, HASH_CACHE_SIZE);
913 memcpy(req->state, export->state, req->state_sz);
938 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
940 memset(req, 0, sizeof(*req));
943 req->digest = CONTEXT_CONTROL_DIGEST_PRECOMPUTED;
944 req->state_sz = SHA1_DIGEST_SIZE;
945 req->digest_sz = SHA1_DIGEST_SIZE;
946 req->block_sz = SHA1_BLOCK_SIZE;
1015 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
1017 memset(req, 0, sizeof(*req));
1020 memcpy(req->state, &ctx->base.ipad, SHA1_DIGEST_SIZE);
1022 req->len = SHA1_BLOCK_SIZE;
1023 req->processed = SHA1_BLOCK_SIZE;
1026 req->digest = CONTEXT_CONTROL_DIGEST_PRECOMPUTED;
1027 req->state_sz = SHA1_DIGEST_SIZE;
1028 req->digest_sz = SHA1_DIGEST_SIZE;
1029 req->block_sz = SHA1_BLOCK_SIZE;
1030 req->hmac = true;
1092 struct safexcel_ahash_req *req;
1106 req = ahash_request_ctx_dma(areq);
1107 req->hmac = true;
1108 req->last_req = true;
1241 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
1243 memset(req, 0, sizeof(*req));
1246 req->digest = CONTEXT_CONTROL_DIGEST_PRECOMPUTED;
1247 req->state_sz = SHA256_DIGEST_SIZE;
1248 req->digest_sz = SHA256_DIGEST_SIZE;
1249 req->block_sz = SHA256_BLOCK_SIZE;
1298 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
1300 memset(req, 0, sizeof(*req));
1303 req->digest = CONTEXT_CONTROL_DIGEST_PRECOMPUTED;
1304 req->state_sz = SHA256_DIGEST_SIZE;
1305 req->digest_sz = SHA256_DIGEST_SIZE;
1306 req->block_sz = SHA256_BLOCK_SIZE;
1362 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
1364 memset(req, 0, sizeof(*req));
1367 memcpy(req->state, &ctx->base.ipad, SHA256_DIGEST_SIZE);
1369 req->len = SHA256_BLOCK_SIZE;
1370 req->processed = SHA256_BLOCK_SIZE;
1373 req->digest = CONTEXT_CONTROL_DIGEST_PRECOMPUTED;
1374 req->state_sz = SHA256_DIGEST_SIZE;
1375 req->digest_sz = SHA256_DIGEST_SIZE;
1376 req->block_sz = SHA256_BLOCK_SIZE;
1377 req->hmac = true;
1434 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
1436 memset(req, 0, sizeof(*req));
1439 memcpy(req->state, &ctx->base.ipad, SHA256_DIGEST_SIZE);
1441 req->len = SHA256_BLOCK_SIZE;
1442 req->processed = SHA256_BLOCK_SIZE;
1445 req->digest = CONTEXT_CONTROL_DIGEST_PRECOMPUTED;
1446 req->state_sz = SHA256_DIGEST_SIZE;
1447 req->digest_sz = SHA256_DIGEST_SIZE;
1448 req->block_sz = SHA256_BLOCK_SIZE;
1449 req->hmac = true;
1499 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
1501 memset(req, 0, sizeof(*req));
1504 req->digest = CONTEXT_CONTROL_DIGEST_PRECOMPUTED;
1505 req->state_sz = SHA512_DIGEST_SIZE;
1506 req->digest_sz = SHA512_DIGEST_SIZE;
1507 req->block_sz = SHA512_BLOCK_SIZE;
1556 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
1558 memset(req, 0, sizeof(*req));
1561 req->digest = CONTEXT_CONTROL_DIGEST_PRECOMPUTED;
1562 req->state_sz = SHA512_DIGEST_SIZE;
1563 req->digest_sz = SHA512_DIGEST_SIZE;
1564 req->block_sz = SHA512_BLOCK_SIZE;
1620 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
1622 memset(req, 0, sizeof(*req));
1625 memcpy(req->state, &ctx->base.ipad, SHA512_DIGEST_SIZE);
1627 req->len = SHA512_BLOCK_SIZE;
1628 req->processed = SHA512_BLOCK_SIZE;
1631 req->digest = CONTEXT_CONTROL_DIGEST_PRECOMPUTED;
1632 req->state_sz = SHA512_DIGEST_SIZE;
1633 req->digest_sz = SHA512_DIGEST_SIZE;
1634 req->block_sz = SHA512_BLOCK_SIZE;
1635 req->hmac = true;
1692 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
1694 memset(req, 0, sizeof(*req));
1697 memcpy(req->state, &ctx->base.ipad, SHA512_DIGEST_SIZE);
1699 req->len = SHA512_BLOCK_SIZE;
1700 req->processed = SHA512_BLOCK_SIZE;
1703 req->digest = CONTEXT_CONTROL_DIGEST_PRECOMPUTED;
1704 req->state_sz = SHA512_DIGEST_SIZE;
1705 req->digest_sz = SHA512_DIGEST_SIZE;
1706 req->block_sz = SHA512_BLOCK_SIZE;
1707 req->hmac = true;
1757 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
1759 memset(req, 0, sizeof(*req));
1762 req->digest = CONTEXT_CONTROL_DIGEST_PRECOMPUTED;
1763 req->state_sz = MD5_DIGEST_SIZE;
1764 req->digest_sz = MD5_DIGEST_SIZE;
1765 req->block_sz = MD5_HMAC_BLOCK_SIZE;
1814 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
1816 memset(req, 0, sizeof(*req));
1819 memcpy(req->state, &ctx->base.ipad, MD5_DIGEST_SIZE);
1821 req->len = MD5_HMAC_BLOCK_SIZE;
1822 req->processed = MD5_HMAC_BLOCK_SIZE;
1825 req->digest = CONTEXT_CONTROL_DIGEST_PRECOMPUTED;
1826 req->state_sz = MD5_DIGEST_SIZE;
1827 req->digest_sz = MD5_DIGEST_SIZE;
1828 req->block_sz = MD5_HMAC_BLOCK_SIZE;
1829 req->len_is_le = true; /* MD5 is little endian! ... */
1830 req->hmac = true;
1897 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
1899 memset(req, 0, sizeof(*req));
1902 req->state[0] = cpu_to_le32(~ctx->base.ipad.word[0]);
1904 req->len = sizeof(u32);
1905 req->processed = sizeof(u32);
1908 req->digest = CONTEXT_CONTROL_DIGEST_XCM;
1909 req->state_sz = sizeof(u32);
1910 req->digest_sz = sizeof(u32);
1911 req->block_sz = sizeof(u32);
1969 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
1971 memset(req, 0, sizeof(*req));
1974 memcpy(req->state, &ctx->base.ipad, ctx->key_sz);
1976 req->len = AES_BLOCK_SIZE;
1977 req->processed = AES_BLOCK_SIZE;
1979 req->digest = CONTEXT_CONTROL_DIGEST_XCM;
1980 req->state_sz = ctx->key_sz;
1981 req->digest_sz = AES_BLOCK_SIZE;
1982 req->block_sz = AES_BLOCK_SIZE;
1983 req->xcbcmac = true;
2229 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
2231 memset(req, 0, sizeof(*req));
2234 req->digest = CONTEXT_CONTROL_DIGEST_PRECOMPUTED;
2235 req->state_sz = SM3_DIGEST_SIZE;
2236 req->digest_sz = SM3_DIGEST_SIZE;
2237 req->block_sz = SM3_BLOCK_SIZE;
2293 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
2295 memset(req, 0, sizeof(*req));
2298 memcpy(req->state, &ctx->base.ipad, SM3_DIGEST_SIZE);
2300 req->len = SM3_BLOCK_SIZE;
2301 req->processed = SM3_BLOCK_SIZE;
2304 req->digest = CONTEXT_CONTROL_DIGEST_PRECOMPUTED;
2305 req->state_sz = SM3_DIGEST_SIZE;
2306 req->digest_sz = SM3_DIGEST_SIZE;
2307 req->block_sz = SM3_BLOCK_SIZE;
2308 req->hmac = true;
2359 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
2361 memset(req, 0, sizeof(*req));
2364 req->digest = CONTEXT_CONTROL_DIGEST_INITIAL;
2365 req->state_sz = SHA3_224_DIGEST_SIZE;
2366 req->digest_sz = SHA3_224_DIGEST_SIZE;
2367 req->block_sz = SHA3_224_BLOCK_SIZE;
2373 static int safexcel_sha3_fbcheck(struct ahash_request *req)
2375 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2377 struct ahash_request *subreq = ahash_request_ctx_dma(req);
2382 ahash_request_set_callback(subreq, req->base.flags,
2383 req->base.complete, req->base.data);
2384 ahash_request_set_crypt(subreq, req->src, req->result,
2385 req->nbytes);
2410 static int safexcel_sha3_update(struct ahash_request *req)
2412 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2414 struct ahash_request *subreq = ahash_request_ctx_dma(req);
2417 return safexcel_sha3_fbcheck(req) ?: crypto_ahash_update(subreq);
2420 static int safexcel_sha3_final(struct ahash_request *req)
2422 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2424 struct ahash_request *subreq = ahash_request_ctx_dma(req);
2427 return safexcel_sha3_fbcheck(req) ?: crypto_ahash_final(subreq);
2430 static int safexcel_sha3_finup(struct ahash_request *req)
2432 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2434 struct ahash_request *subreq = ahash_request_ctx_dma(req);
2436 ctx->do_fallback |= !req->nbytes;
2439 return safexcel_sha3_fbcheck(req) ?:
2442 return safexcel_ahash_finup(req);
2445 static int safexcel_sha3_digest_fallback(struct ahash_request *req)
2447 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2449 struct ahash_request *subreq = ahash_request_ctx_dma(req);
2453 return safexcel_sha3_fbcheck(req) ?: crypto_ahash_finup(subreq);
2456 static int safexcel_sha3_224_digest(struct ahash_request *req)
2458 if (req->nbytes)
2459 return safexcel_sha3_224_init(req) ?: safexcel_ahash_finup(req);
2462 return safexcel_sha3_digest_fallback(req);
2465 static int safexcel_sha3_export(struct ahash_request *req, void *out)
2467 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2469 struct ahash_request *subreq = ahash_request_ctx_dma(req);
2472 return safexcel_sha3_fbcheck(req) ?: crypto_ahash_export(subreq, out);
2475 static int safexcel_sha3_import(struct ahash_request *req, const void *in)
2477 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
2479 struct ahash_request *subreq = ahash_request_ctx_dma(req);
2482 return safexcel_sha3_fbcheck(req) ?: crypto_ahash_import(subreq, in);
2483 // return safexcel_ahash_import(req, in);
2553 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
2555 memset(req, 0, sizeof(*req));
2558 req->digest = CONTEXT_CONTROL_DIGEST_INITIAL;
2559 req->state_sz = SHA3_256_DIGEST_SIZE;
2560 req->digest_sz = SHA3_256_DIGEST_SIZE;
2561 req->block_sz = SHA3_256_BLOCK_SIZE;
2567 static int safexcel_sha3_256_digest(struct ahash_request *req)
2569 if (req->nbytes)
2570 return safexcel_sha3_256_init(req) ?: safexcel_ahash_finup(req);
2573 return safexcel_sha3_digest_fallback(req);
2611 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
2613 memset(req, 0, sizeof(*req));
2616 req->digest = CONTEXT_CONTROL_DIGEST_INITIAL;
2617 req->state_sz = SHA3_384_DIGEST_SIZE;
2618 req->digest_sz = SHA3_384_DIGEST_SIZE;
2619 req->block_sz = SHA3_384_BLOCK_SIZE;
2625 static int safexcel_sha3_384_digest(struct ahash_request *req)
2627 if (req->nbytes)
2628 return safexcel_sha3_384_init(req) ?: safexcel_ahash_finup(req);
2631 return safexcel_sha3_digest_fallback(req);
2669 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
2671 memset(req, 0, sizeof(*req));
2674 req->digest = CONTEXT_CONTROL_DIGEST_INITIAL;
2675 req->state_sz = SHA3_512_DIGEST_SIZE;
2676 req->digest_sz = SHA3_512_DIGEST_SIZE;
2677 req->block_sz = SHA3_512_BLOCK_SIZE;
2683 static int safexcel_sha3_512_digest(struct ahash_request *req)
2685 if (req->nbytes)
2686 return safexcel_sha3_512_init(req) ?: safexcel_ahash_finup(req);
2689 return safexcel_sha3_digest_fallback(req);
2819 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
2821 memset(req, 0, sizeof(*req));
2824 memcpy(req->state, &ctx->base.ipad, SHA3_224_BLOCK_SIZE / 2);
2826 req->len = SHA3_224_BLOCK_SIZE;
2827 req->processed = SHA3_224_BLOCK_SIZE;
2829 req->digest = CONTEXT_CONTROL_DIGEST_HMAC;
2830 req->state_sz = SHA3_224_BLOCK_SIZE / 2;
2831 req->digest_sz = SHA3_224_DIGEST_SIZE;
2832 req->block_sz = SHA3_224_BLOCK_SIZE;
2833 req->hmac = true;
2839 static int safexcel_hmac_sha3_224_digest(struct ahash_request *req)
2841 if (req->nbytes)
2842 return safexcel_hmac_sha3_224_init(req) ?:
2843 safexcel_ahash_finup(req);
2846 return safexcel_sha3_digest_fallback(req);
2890 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
2892 memset(req, 0, sizeof(*req));
2895 memcpy(req->state, &ctx->base.ipad, SHA3_256_BLOCK_SIZE / 2);
2897 req->len = SHA3_256_BLOCK_SIZE;
2898 req->processed = SHA3_256_BLOCK_SIZE;
2900 req->digest = CONTEXT_CONTROL_DIGEST_HMAC;
2901 req->state_sz = SHA3_256_BLOCK_SIZE / 2;
2902 req->digest_sz = SHA3_256_DIGEST_SIZE;
2903 req->block_sz = SHA3_256_BLOCK_SIZE;
2904 req->hmac = true;
2910 static int safexcel_hmac_sha3_256_digest(struct ahash_request *req)
2912 if (req->nbytes)
2913 return safexcel_hmac_sha3_256_init(req) ?:
2914 safexcel_ahash_finup(req);
2917 return safexcel_sha3_digest_fallback(req);
2961 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
2963 memset(req, 0, sizeof(*req));
2966 memcpy(req->state, &ctx->base.ipad, SHA3_384_BLOCK_SIZE / 2);
2968 req->len = SHA3_384_BLOCK_SIZE;
2969 req->processed = SHA3_384_BLOCK_SIZE;
2971 req->digest = CONTEXT_CONTROL_DIGEST_HMAC;
2972 req->state_sz = SHA3_384_BLOCK_SIZE / 2;
2973 req->digest_sz = SHA3_384_DIGEST_SIZE;
2974 req->block_sz = SHA3_384_BLOCK_SIZE;
2975 req->hmac = true;
2981 static int safexcel_hmac_sha3_384_digest(struct ahash_request *req)
2983 if (req->nbytes)
2984 return safexcel_hmac_sha3_384_init(req) ?:
2985 safexcel_ahash_finup(req);
2988 return safexcel_sha3_digest_fallback(req);
3032 struct safexcel_ahash_req *req = ahash_request_ctx_dma(areq);
3034 memset(req, 0, sizeof(*req));
3037 memcpy(req->state, &ctx->base.ipad, SHA3_512_BLOCK_SIZE / 2);
3039 req->len = SHA3_512_BLOCK_SIZE;
3040 req->processed = SHA3_512_BLOCK_SIZE;
3042 req->digest = CONTEXT_CONTROL_DIGEST_HMAC;
3043 req->state_sz = SHA3_512_BLOCK_SIZE / 2;
3044 req->digest_sz = SHA3_512_DIGEST_SIZE;
3045 req->block_sz = SHA3_512_BLOCK_SIZE;
3046 req->hmac = true;
3052 static int safexcel_hmac_sha3_512_digest(struct ahash_request *req)
3054 if (req->nbytes)
3055 return safexcel_hmac_sha3_512_init(req) ?:
3056 safexcel_ahash_finup(req);
3059 return safexcel_sha3_digest_fallback(req);