crypto/crypto_engine.c

104

async_req = crypto_dequeue_request(&engine->queue);

crypto/crypto_engine.c

105

if (!async_req)

crypto/crypto_engine.c

114

engine->cur_req = async_req;

crypto/crypto_engine.c

121

alg = container_of(async_req->tfm->__crt_alg,

crypto/crypto_engine.c

124

ret = op->do_one_request(engine, async_req);

crypto/crypto_engine.c

146

crypto_enqueue_request_head(&engine->queue, async_req);

crypto/crypto_engine.c

155

crypto_request_complete(async_req, ret);

crypto/crypto_engine.c

73

struct crypto_async_request *async_req, *backlog;

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-hash.c

457

int sun8i_ce_hash_run(struct crypto_engine *engine, void *async_req)

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-hash.c

459

struct ahash_request *areq = ahash_request_cast(async_req);

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-hash.c

482

crypto_finalize_hash_request(engine, async_req, err);

drivers/crypto/amcc/crypto4xx_core.c

513

req = skcipher_request_cast(pd_uinfo->async_req);

drivers/crypto/amcc/crypto4xx_core.c

543

struct aead_request *aead_req = container_of(pd_uinfo->async_req,

drivers/crypto/amcc/crypto4xx_core.c

608

switch (crypto_tfm_alg_type(pd_uinfo->async_req->tfm)) {

drivers/crypto/amcc/crypto4xx_core.c

778

pd_uinfo->async_req = req;

drivers/crypto/amcc/crypto4xx_core.h

70

struct crypto_async_request *async_req; /* base crypto request

drivers/crypto/atmel-sha.c

1057

struct crypto_async_request *async_req, *backlog;

drivers/crypto/atmel-sha.c

1073

async_req = crypto_dequeue_request(&dd->queue);

drivers/crypto/atmel-sha.c

1074

if (async_req)

drivers/crypto/atmel-sha.c

1079

if (!async_req)

drivers/crypto/atmel-sha.c

1085

ctx = crypto_tfm_ctx(async_req->tfm);

drivers/crypto/atmel-sha.c

1087

dd->req = ahash_request_cast(async_req);

drivers/crypto/atmel-tdes.c

558

struct crypto_async_request *async_req, *backlog;

drivers/crypto/atmel-tdes.c

572

async_req = crypto_dequeue_request(&dd->queue);

drivers/crypto/atmel-tdes.c

573

if (async_req)

drivers/crypto/atmel-tdes.c

577

if (!async_req)

drivers/crypto/atmel-tdes.c

583

req = skcipher_request_cast(async_req);

drivers/crypto/ccp/ccp-crypto-aes-cmac.c

23

static int ccp_aes_cmac_complete(struct crypto_async_request *async_req,

drivers/crypto/ccp/ccp-crypto-aes-cmac.c

26

struct ahash_request *req = ahash_request_cast(async_req);

drivers/crypto/ccp/ccp-crypto-aes-galois.c

24

static int ccp_aes_gcm_complete(struct crypto_async_request *async_req, int ret)

drivers/crypto/ccp/ccp-crypto-aes-xts.c

62

static int ccp_aes_xts_complete(struct crypto_async_request *async_req, int ret)

drivers/crypto/ccp/ccp-crypto-aes-xts.c

64

struct skcipher_request *req = skcipher_request_cast(async_req);

drivers/crypto/ccp/ccp-crypto-aes.c

133

static int ccp_aes_rfc3686_complete(struct crypto_async_request *async_req,

drivers/crypto/ccp/ccp-crypto-aes.c

136

struct skcipher_request *req = skcipher_request_cast(async_req);

drivers/crypto/ccp/ccp-crypto-aes.c

142

return ccp_aes_complete(async_req, ret);

drivers/crypto/ccp/ccp-crypto-aes.c

23

static int ccp_aes_complete(struct crypto_async_request *async_req, int ret)

drivers/crypto/ccp/ccp-crypto-aes.c

25

struct skcipher_request *req = skcipher_request_cast(async_req);

drivers/crypto/ccp/ccp-crypto-des3.c

22

static int ccp_des3_complete(struct crypto_async_request *async_req, int ret)

drivers/crypto/ccp/ccp-crypto-des3.c

24

struct skcipher_request *req = skcipher_request_cast(async_req);

drivers/crypto/ccp/ccp-crypto-rsa.c

44

static int ccp_rsa_complete(struct crypto_async_request *async_req, int ret)

drivers/crypto/ccp/ccp-crypto-rsa.c

46

struct akcipher_request *req = akcipher_request_cast(async_req);

drivers/crypto/ccp/ccp-crypto-sha.c

27

static int ccp_sha_complete(struct crypto_async_request *async_req, int ret)

drivers/crypto/ccp/ccp-crypto-sha.c

29

struct ahash_request *req = ahash_request_cast(async_req);

drivers/crypto/hifn_795x.c

1897

struct crypto_async_request *async_req;

drivers/crypto/hifn_795x.c

1913

while ((async_req = crypto_dequeue_request(&dev->queue))) {

drivers/crypto/hifn_795x.c

1914

req = skcipher_request_cast(async_req);

drivers/crypto/hifn_795x.c

2024

struct crypto_async_request *async_req, *backlog;

drivers/crypto/hifn_795x.c

2032

async_req = crypto_dequeue_request(&dev->queue);

drivers/crypto/hifn_795x.c

2035

if (!async_req)

drivers/crypto/hifn_795x.c

2041

req = skcipher_request_cast(async_req);

drivers/crypto/img-hash.c

504

struct crypto_async_request *async_req, *backlog;

drivers/crypto/img-hash.c

520

async_req = crypto_dequeue_request(&hdev->queue);

drivers/crypto/img-hash.c

521

if (async_req)

drivers/crypto/img-hash.c

526

if (!async_req)

drivers/crypto/img-hash.c

532

req = ahash_request_cast(async_req);

drivers/crypto/qce/aead.c

25

struct crypto_async_request *async_req = data;

drivers/crypto/qce/aead.c

26

struct aead_request *req = aead_request_cast(async_req);

drivers/crypto/qce/aead.c

28

struct qce_aead_ctx *ctx = crypto_tfm_ctx(async_req->tfm);

drivers/crypto/qce/aead.c

408

qce_aead_async_req_handle(struct crypto_async_request *async_req)

drivers/crypto/qce/aead.c

410

struct aead_request *req = aead_request_cast(async_req);

drivers/crypto/qce/aead.c

413

struct qce_aead_ctx *ctx = crypto_tfm_ctx(async_req->tfm);

drivers/crypto/qce/aead.c

472

qce_aead_done, async_req);

drivers/crypto/qce/aead.c

478

ret = qce_start(async_req, tmpl->crypto_alg_type);

drivers/crypto/qce/common.c

147

static int qce_setup_regs_ahash(struct crypto_async_request *async_req)

drivers/crypto/qce/common.c

149

struct ahash_request *req = ahash_request_cast(async_req);

drivers/crypto/qce/common.c

150

struct crypto_ahash *ahash = __crypto_ahash_cast(async_req->tfm);

drivers/crypto/qce/common.c

152

struct qce_alg_template *tmpl = to_ahash_tmpl(async_req->tfm);

drivers/crypto/qce/common.c

155

unsigned int blocksize = crypto_tfm_alg_blocksize(async_req->tfm);

drivers/crypto/qce/common.c

314

static int qce_setup_regs_skcipher(struct crypto_async_request *async_req)

drivers/crypto/qce/common.c

316

struct skcipher_request *req = skcipher_request_cast(async_req);

drivers/crypto/qce/common.c

318

struct qce_cipher_ctx *ctx = crypto_tfm_ctx(async_req->tfm);

drivers/crypto/qce/common.c

420

static int qce_setup_regs_aead(struct crypto_async_request *async_req)

drivers/crypto/qce/common.c

422

struct aead_request *req = aead_request_cast(async_req);

drivers/crypto/qce/common.c

424

struct qce_aead_ctx *ctx = crypto_tfm_ctx(async_req->tfm);

drivers/crypto/qce/common.c

544

int qce_start(struct crypto_async_request *async_req, u32 type)

drivers/crypto/qce/common.c

549

return qce_setup_regs_skcipher(async_req);

drivers/crypto/qce/common.c

553

return qce_setup_regs_ahash(async_req);

drivers/crypto/qce/common.c

557

return qce_setup_regs_aead(async_req);

drivers/crypto/qce/common.h

102

int qce_start(struct crypto_async_request *async_req, u32 type);

drivers/crypto/qce/core.c

102

async_req = crypto_dequeue_request(&qce->queue);

drivers/crypto/qce/core.c

103

if (async_req)

drivers/crypto/qce/core.c

104

qce->req = async_req;

drivers/crypto/qce/core.c

107

if (!async_req)

drivers/crypto/qce/core.c

115

err = qce_handle_request(async_req);

drivers/crypto/qce/core.c

70

static int qce_handle_request(struct crypto_async_request *async_req)

drivers/crypto/qce/core.c

74

u32 type = crypto_tfm_alg_type(async_req->tfm);

drivers/crypto/qce/core.c

80

ret = ops->async_req_handle(async_req);

drivers/crypto/qce/core.c

90

struct crypto_async_request *async_req, *backlog;

drivers/crypto/qce/core.h

61

int (*async_req_handle)(struct crypto_async_request *async_req);

drivers/crypto/qce/sha.c

112

&rctx->result_sg, 1, qce_ahash_done, async_req);

drivers/crypto/qce/sha.c

118

ret = qce_start(async_req, tmpl->crypto_alg_type);

drivers/crypto/qce/sha.c

38

struct crypto_async_request *async_req = data;

drivers/crypto/qce/sha.c

39

struct ahash_request *req = ahash_request_cast(async_req);

drivers/crypto/qce/sha.c

42

struct qce_alg_template *tmpl = to_ahash_tmpl(async_req->tfm);

drivers/crypto/qce/sha.c

75

static int qce_ahash_async_req_handle(struct crypto_async_request *async_req)

drivers/crypto/qce/sha.c

77

struct ahash_request *req = ahash_request_cast(async_req);

drivers/crypto/qce/sha.c

79

struct qce_sha_ctx *ctx = crypto_tfm_ctx(async_req->tfm);

drivers/crypto/qce/sha.c

80

struct qce_alg_template *tmpl = to_ahash_tmpl(async_req->tfm);

drivers/crypto/qce/skcipher.c

146

qce_skcipher_done, async_req);

drivers/crypto/qce/skcipher.c

152

ret = qce_start(async_req, tmpl->crypto_alg_type);

drivers/crypto/qce/skcipher.c

29

struct crypto_async_request *async_req = data;

drivers/crypto/qce/skcipher.c

30

struct skcipher_request *req = skcipher_request_cast(async_req);

drivers/crypto/qce/skcipher.c

64

qce_skcipher_async_req_handle(struct crypto_async_request *async_req)

drivers/crypto/qce/skcipher.c

66

struct skcipher_request *req = skcipher_request_cast(async_req);

drivers/crypto/rockchip/rk3288_crypto_skcipher.c

299

static int rk_cipher_run(struct crypto_engine *engine, void *async_req)

drivers/crypto/rockchip/rk3288_crypto_skcipher.c

301

struct skcipher_request *areq = container_of(async_req, struct skcipher_request, base);

drivers/crypto/s5p-sss.c

1352

struct crypto_async_request *async_req, *backlog;

drivers/crypto/s5p-sss.c

1368

async_req = crypto_dequeue_request(&dd->hash_queue);

drivers/crypto/s5p-sss.c

1369

if (async_req)

drivers/crypto/s5p-sss.c

1374

if (!async_req)

drivers/crypto/s5p-sss.c

1380

req = ahash_request_cast(async_req);

drivers/crypto/s5p-sss.c

1953

struct crypto_async_request *async_req, *backlog;

drivers/crypto/s5p-sss.c

1959

async_req = crypto_dequeue_request(&dev->queue);

drivers/crypto/s5p-sss.c

1961

if (!async_req) {

drivers/crypto/s5p-sss.c

1971

dev->req = skcipher_request_cast(async_req);

drivers/crypto/sahara.c

1001

err = sahara_aes_process(skcipher_request_cast(async_req));

drivers/crypto/sahara.c

988

struct crypto_async_request *async_req = areq;

drivers/crypto/sahara.c

991

if (crypto_tfm_alg_type(async_req->tfm) == CRYPTO_ALG_TYPE_AHASH) {

drivers/crypto/sahara.c

992

struct ahash_request *req = ahash_request_cast(async_req);

drivers/crypto/sahara.c

999

struct skcipher_request *req = skcipher_request_cast(async_req);

drivers/md/dm-crypt.c

1464

static void kcryptd_async_done(void *async_req, int error);

drivers/net/usb/rtl8150.c

175

struct async_req *req = (struct async_req *)urb->context;

drivers/net/usb/rtl8150.c

188

struct async_req *req;

drivers/net/usb/rtl8150.c

190

req = kmalloc_obj(struct async_req, GFP_ATOMIC);

drivers/nvme/host/tcp.c

1416

struct nvme_tcp_request *async = &ctrl->async_req;

drivers/nvme/host/tcp.c

1424

struct nvme_tcp_request *async = &ctrl->async_req;

drivers/nvme/host/tcp.c

199

struct nvme_tcp_request async_req;

drivers/nvme/host/tcp.c

2021

if (to_tcp_ctrl(ctrl)->async_req.pdu) {

drivers/nvme/host/tcp.c

2024

to_tcp_ctrl(ctrl)->async_req.pdu = NULL;

drivers/nvme/host/tcp.c

2605

struct nvme_tcp_cmd_pdu *pdu = ctrl->async_req.pdu;

drivers/nvme/host/tcp.c

2621

ctrl->async_req.state = NVME_TCP_SEND_CMD_PDU;

drivers/nvme/host/tcp.c

2622

ctrl->async_req.offset = 0;

drivers/nvme/host/tcp.c

2623

ctrl->async_req.curr_bio = NULL;

drivers/nvme/host/tcp.c

2624

ctrl->async_req.data_len = 0;

drivers/nvme/host/tcp.c

2625

init_llist_node(&ctrl->async_req.lentry);

drivers/nvme/host/tcp.c

2626

INIT_LIST_HEAD(&ctrl->async_req.entry);

drivers/nvme/host/tcp.c

2628

nvme_tcp_queue_request(&ctrl->async_req, true);

drivers/nvme/host/tcp.c

295

return req == &req->queue->ctrl->async_req;