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

511

req = skcipher_request_cast(pd_uinfo->async_req);

drivers/crypto/amcc/crypto4xx_core.c

541

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

drivers/crypto/amcc/crypto4xx_core.c

606

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

drivers/crypto/amcc/crypto4xx_core.c

776

pd_uinfo->async_req = req;

drivers/crypto/amcc/crypto4xx_core.h

68

struct crypto_async_request *async_req; /* base crypto request

drivers/crypto/atmel-sha.c

1049

struct crypto_async_request *async_req, *backlog;

drivers/crypto/atmel-sha.c

1065

async_req = crypto_dequeue_request(&dd->queue);

drivers/crypto/atmel-sha.c

1066

if (async_req)

drivers/crypto/atmel-sha.c

1071

if (!async_req)

drivers/crypto/atmel-sha.c

1077

ctx = crypto_tfm_ctx(async_req->tfm);

drivers/crypto/atmel-sha.c

1079

dd->req = ahash_request_cast(async_req);

drivers/crypto/atmel-tdes.c

557

struct crypto_async_request *async_req, *backlog;

drivers/crypto/atmel-tdes.c

571

async_req = crypto_dequeue_request(&dd->queue);

drivers/crypto/atmel-tdes.c

572

if (async_req)

drivers/crypto/atmel-tdes.c

576

if (!async_req)

drivers/crypto/atmel-tdes.c

582

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

25

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

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

63

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

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

65

struct skcipher_request *req = skcipher_request_cast(async_req);

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

136

static int ccp_aes_rfc3686_complete(struct crypto_async_request *async_req,

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

139

struct skcipher_request *req = skcipher_request_cast(async_req);

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

145

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

45

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

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

47

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

503

struct crypto_async_request *async_req, *backlog;

drivers/crypto/img-hash.c

519

async_req = crypto_dequeue_request(&hdev->queue);

drivers/crypto/img-hash.c

520

if (async_req)

drivers/crypto/img-hash.c

525

if (!async_req)

drivers/crypto/img-hash.c

531

req = ahash_request_cast(async_req);

drivers/crypto/qce/aead.c

26

struct crypto_async_request *async_req = data;

drivers/crypto/qce/aead.c

27

struct aead_request *req = aead_request_cast(async_req);

drivers/crypto/qce/aead.c

29

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

drivers/crypto/qce/aead.c

403

qce_aead_async_req_handle(struct crypto_async_request *async_req)

drivers/crypto/qce/aead.c

405

struct aead_request *req = aead_request_cast(async_req);

drivers/crypto/qce/aead.c

408

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

drivers/crypto/qce/aead.c

467

qce_aead_done, async_req);

drivers/crypto/qce/aead.c

473

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

101

async_req = crypto_dequeue_request(&qce->queue);

drivers/crypto/qce/core.c

102

if (async_req)

drivers/crypto/qce/core.c

103

qce->req = async_req;

drivers/crypto/qce/core.c

106

if (!async_req)

drivers/crypto/qce/core.c

114

err = qce_handle_request(async_req);

drivers/crypto/qce/core.c

69

static int qce_handle_request(struct crypto_async_request *async_req)

drivers/crypto/qce/core.c

73

u32 type = crypto_tfm_alg_type(async_req->tfm);

drivers/crypto/qce/core.c

79

ret = ops->async_req_handle(async_req);

drivers/crypto/qce/core.c

89

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

113

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

drivers/crypto/qce/sha.c

119

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

drivers/crypto/qce/sha.c

39

struct crypto_async_request *async_req = data;

drivers/crypto/qce/sha.c

40

struct ahash_request *req = ahash_request_cast(async_req);

drivers/crypto/qce/sha.c

43

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

drivers/crypto/qce/sha.c

76

static int qce_ahash_async_req_handle(struct crypto_async_request *async_req)

drivers/crypto/qce/sha.c

78

struct ahash_request *req = ahash_request_cast(async_req);

drivers/crypto/qce/sha.c

80

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

drivers/crypto/qce/sha.c

81

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

drivers/crypto/qce/skcipher.c

147

qce_skcipher_done, async_req);

drivers/crypto/qce/skcipher.c

153

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

drivers/crypto/qce/skcipher.c

30

struct crypto_async_request *async_req = data;

drivers/crypto/qce/skcipher.c

31

struct skcipher_request *req = skcipher_request_cast(async_req);

drivers/crypto/qce/skcipher.c

65

qce_skcipher_async_req_handle(struct crypto_async_request *async_req)

drivers/crypto/qce/skcipher.c

67

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

1429

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

1409

struct nvme_tcp_request *async = &ctrl->async_req;

drivers/nvme/host/tcp.c

1417

struct nvme_tcp_request *async = &ctrl->async_req;

drivers/nvme/host/tcp.c

166

struct nvme_tcp_request async_req;

drivers/nvme/host/tcp.c

2042

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

drivers/nvme/host/tcp.c

2045

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

drivers/nvme/host/tcp.c

2628

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

drivers/nvme/host/tcp.c

2644

ctrl->async_req.state = NVME_TCP_SEND_CMD_PDU;

drivers/nvme/host/tcp.c

2645

ctrl->async_req.offset = 0;

drivers/nvme/host/tcp.c

2646

ctrl->async_req.curr_bio = NULL;

drivers/nvme/host/tcp.c

2647

ctrl->async_req.data_len = 0;

drivers/nvme/host/tcp.c

2648

init_llist_node(&ctrl->async_req.lentry);

drivers/nvme/host/tcp.c

2649

INIT_LIST_HEAD(&ctrl->async_req.entry);

drivers/nvme/host/tcp.c

2651

nvme_tcp_queue_request(&ctrl->async_req, true);

drivers/nvme/host/tcp.c

295

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