arch/arm/mm/dma-mapping.c

1279

__iommu_remove_mapping(dev, sg_dma_address(s), sg_dma_len(s));

arch/arm/mm/dma-mapping.c

1304

if (sg_dma_len(s))

arch/arm/mm/dma-mapping.c

1306

sg_dma_len(s));

arch/mips/jazz/jazzdma.c

562

sg_dma_len(sg) = sg->length;

arch/powerpc/platforms/512x/mpc512x_lpbfifo.c

255

sg_dma_len(&sg) = lpbfifo.req->size;

drivers/accel/habanalabs/common/habanalabs.h

3705

return ((((*dma_addr) & (PAGE_SIZE - 1)) + sg_dma_len(sg)) +

drivers/accel/habanalabs/common/memory.c

1529

sg_dma_len(sg) = chunk_size;

drivers/accel/habanalabs/common/memory.c

1687

i, sg_dma_address(sg), sg_dma_len(sg));

drivers/accel/habanalabs/common/memory.c

1693

if (!sg_dma_len(sg))

drivers/accel/habanalabs/common/memory.c

1696

dma_unmap_resource(dev, sg_dma_address(sg), sg_dma_len(sg), dir,

drivers/accel/habanalabs/common/memory.c

1780

sg_dma_len(sg), dir,

drivers/accel/habanalabs/gaudi/gaudi.c

4866

len = sg_dma_len(sg);

drivers/accel/habanalabs/gaudi/gaudi.c

4874

len_next = sg_dma_len(sg_next_iter);

drivers/accel/habanalabs/gaudi/gaudi.c

5197

len = sg_dma_len(sg);

drivers/accel/habanalabs/gaudi/gaudi.c

5205

len_next = sg_dma_len(sg_next_iter);

drivers/accel/habanalabs/goya/goya.c

3296

len = sg_dma_len(sg);

drivers/accel/habanalabs/goya/goya.c

3304

len_next = sg_dma_len(sg_next_iter);

drivers/accel/habanalabs/goya/goya.c

3814

len = sg_dma_len(sg);

drivers/accel/habanalabs/goya/goya.c

3822

len_next = sg_dma_len(sg_next_iter);

drivers/accel/ivpu/ivpu_mmu_context.c

461

size_t size = sg_dma_len(sg) + sg->offset;

drivers/accel/ivpu/ivpu_mmu_context.c

530

size_t size = sg_dma_len(sg) + sg->offset;

drivers/accel/qaic/qaic_control.c

539

dma_len = sg_dma_len(sg);

drivers/accel/qaic/qaic_data.c

192

len = sg_dma_len(sg);

drivers/accel/qaic/qaic_data.c

232

sg_dma_len(sg) -= offf;

drivers/accel/qaic/qaic_data.c

233

sg_set_page(sg, sg_page(sgn), sg_dma_len(sg), offf);

drivers/accel/qaic/qaic_data.c

238

sg_dma_len(sg) = offl - offf;

drivers/accel/qaic/qaic_data.c

320

slice->reqs[i].len = cpu_to_le32((u32)sg_dma_len(sg));

drivers/accel/qaic/qaic_data.c

351

dev_addr += sg_dma_len(sg);

drivers/ata/acard-ahci.c

193

u32 sg_len = sg_dma_len(sg);

drivers/ata/libahci.c

1667

u32 sg_len = sg_dma_len(sg);

drivers/ata/libata-sff.c

2507

sg_len = sg_dma_len(sg);

drivers/ata/libata-sff.c

2557

sg_len = sg_dma_len(sg);

drivers/ata/pata_arasan_cf.c

439

sglen = sg_dma_len(sg);

drivers/ata/pata_macio.c

553

sg_len = sg_dma_len(sg);

drivers/ata/pata_mpc52xx.c

461

u32 cur_len = sg_dma_len(sg);

drivers/ata/pata_octeon_cf.c

574

mio_boot_dma_cfg.s.size = sg_dma_len(sg) / 2 - 1;

drivers/ata/pdc_adma.c

274

len = sg_dma_len(sg) >> 3;

drivers/ata/sata_fsl.c

457

u32 sg_len = sg_dma_len(sg);

drivers/ata/sata_inic162x.c

472

prd->len = cpu_to_le16(sg_dma_len(sg));

drivers/ata/sata_mv.c

1760

u32 sg_len = sg_dma_len(sg);

drivers/ata/sata_nv.c

1308

aprd->len = cpu_to_le32(((u32)sg_dma_len(sg))); /* len in bytes */

drivers/ata/sata_nv.c

1981

sg_len = sg_dma_len(sg);

drivers/ata/sata_promise.c

589

sg_len = sg_dma_len(sg);

drivers/ata/sata_qstor.c

252

len = sg_dma_len(sg);

drivers/ata/sata_rcar.c

516

sg_len = sg_dma_len(sg);

drivers/ata/sata_sil.c

306

u32 sg_len = sg_dma_len(sg);

drivers/ata/sata_sil24.c

777

sge->cnt = cpu_to_le32(sg_dma_len(sg));

drivers/ata/sata_sx4.c

436

buf[idx++] = cpu_to_le32(sg_dma_len(sg));

drivers/ata/sata_sx4.c

437

total_len += sg_dma_len(sg);

drivers/block/mtip32xx/mtip32xx.c

1458

dma_len = sg_dma_len(sg);

drivers/char/agp/intel-gtt.c

895

len = sg_dma_len(sg) >> PAGE_SHIFT;

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

245

todo = min(len, sg_dma_len(sg));

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

260

todo = min(len, sg_dma_len(sg));

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

371

todo = min(len, sg_dma_len(sg));

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-cipher.c

161

todo = min(len, sg_dma_len(sg));

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-cipher.c

257

if (sg_dma_len(sg) == 0)

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-cipher.c

260

todo = min(len, sg_dma_len(sg));

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-cipher.c

279

if (sg_dma_len(sg) == 0)

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-cipher.c

282

todo = min(len, sg_dma_len(sg));

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

544

if (sg_dma_len(sg) == 0) {

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

548

todo = min(len, sg_dma_len(sg));

drivers/crypto/amlogic/amlogic-gxl-cipher.c

212

todo = min(len, sg_dma_len(src_sg));

drivers/crypto/aspeed/aspeed-hace-crypto.c

273

u32 len = sg_dma_len(s);

drivers/crypto/aspeed/aspeed-hace-crypto.c

304

u32 len = sg_dma_len(s);

drivers/crypto/aspeed/aspeed-hace-hash.c

255

u32 len = sg_dma_len(s);

drivers/crypto/atmel-sha.c

655

sg_dma_len(&sg[0]) = length1;

drivers/crypto/atmel-sha.c

657

sg_dma_len(&sg[1]) = length2;

drivers/crypto/atmel-sha.c

663

sg_dma_len(&sg[0]) = length1;

drivers/crypto/atmel-tdes.c

422

sg_dma_len(&sg[0]) = length;

drivers/crypto/atmel-tdes.c

426

sg_dma_len(&sg[1]) = length;

drivers/crypto/atmel-tdes.c

466

if (sg_dma_len(dd->in_sg) != sg_dma_len(dd->out_sg))

drivers/crypto/atmel-tdes.c

472

count = min_t(size_t, dd->total, sg_dma_len(dd->in_sg));

drivers/crypto/atmel-tdes.c

473

count = min_t(size_t, count, sg_dma_len(dd->out_sg));

drivers/crypto/caam/sg_sw_qm.h

63

ent_len = min_t(int, sg_dma_len(sg), len);

drivers/crypto/caam/sg_sw_qm2.h

34

ent_len = min_t(int, sg_dma_len(sg), len);

drivers/crypto/caam/sg_sw_sec4.h

54

ent_len = min_t(int, sg_dma_len(sg), len);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

131

sgcomp[i].len[j] = cpu_to_be16(sg_dma_len(sg));

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

171

sr->in.total_bytes += sg_dma_len(sg);

drivers/crypto/ccp/ccp-dmaengine.c

384

src_len = sg_dma_len(src_sg);

drivers/crypto/ccp/ccp-dmaengine.c

387

dst_len = sg_dma_len(dst_sg);

drivers/crypto/ccp/ccp-dmaengine.c

400

src_len = sg_dma_len(src_sg);

drivers/crypto/ccp/ccp-dmaengine.c

414

dst_len = sg_dma_len(dst_sg);

drivers/crypto/ccp/ccp-dmaengine.c

493

sg_dma_len(&dst_sg) = len;

drivers/crypto/ccp/ccp-dmaengine.c

497

sg_dma_len(&src_sg) = len;

drivers/crypto/ccp/ccp-ops.c

117

if (wa->sg_used == sg_dma_len(wa->dma_sg)) {

drivers/crypto/ccp/ccp-ops.c

2060

(sg_dma_len(dst.sg_wa.sg) < sg_dma_len(src.sg_wa.sg))) {

drivers/crypto/ccp/ccp-ops.c

2073

op.src.u.dma.length = sg_dma_len(src.sg_wa.sg);

drivers/crypto/ccp/ccp-ops.c

2086

dst.sg_wa.sg_used += sg_dma_len(src.sg_wa.sg);

drivers/crypto/ccp/ccp-ops.c

2087

if (dst.sg_wa.sg_used == sg_dma_len(dst.sg_wa.sg)) {

drivers/crypto/ccp/ccp-ops.c

322

nbytes = min(sg_dma_len(sg_wa->dma_sg) - sg_wa->sg_used,

drivers/crypto/ccp/ccp-ops.c

354

sg_src_len = sg_dma_len(src->sg_wa.dma_sg) - src->sg_wa.sg_used;

drivers/crypto/ccp/ccp-ops.c

358

sg_dst_len = sg_dma_len(dst->sg_wa.dma_sg) - dst->sg_wa.sg_used;

drivers/crypto/ccree/cc_buffer_mgr.c

1355

sg_virt(src), &sg_dma_address(src), sg_dma_len(src));

drivers/crypto/ccree/cc_buffer_mgr.c

1364

sg_dma_len(areq_ctx->buff_sg));

drivers/crypto/ccree/cc_buffer_mgr.c

166

(sgl_data_len > sg_dma_len(curr_sgl) - sgl_offset) ?

drivers/crypto/ccree/cc_buffer_mgr.c

167

sg_dma_len(curr_sgl) - sgl_offset :

drivers/crypto/chelsio/chcr_algo.c

142

if (sg_dma_len(sg) <= skip) {

drivers/crypto/chelsio/chcr_algo.c

143

skip -= sg_dma_len(sg);

drivers/crypto/chelsio/chcr_algo.c

153

less = min(reqlen, sg_dma_len(sg) - skip_len);

drivers/crypto/chelsio/chcr_algo.c

406

if (sg_dma_len(sg) <= skip) {

drivers/crypto/chelsio/chcr_algo.c

407

skip -= sg_dma_len(sg);

drivers/crypto/chelsio/chcr_algo.c

417

len = min_t(u32, left_size, sg_dma_len(sg) - skip_len);

drivers/crypto/chelsio/chcr_algo.c

431

walk->last_sg_len = min_t(u32, left_size, sg_dma_len(sg) -

drivers/crypto/chelsio/chcr_algo.c

433

left_size -= min_t(u32, left_size, sg_dma_len(sg) - skip_len);

drivers/crypto/chelsio/chcr_algo.c

490

if (sg_dma_len(sg) <= skip) {

drivers/crypto/chelsio/chcr_algo.c

491

skip -= sg_dma_len(sg);

drivers/crypto/chelsio/chcr_algo.c

501

small = min_t(unsigned int, sg_dma_len(sg) - skip_len, len);

drivers/crypto/chelsio/chcr_algo.c

510

if (sg_dma_len(sg) == skip_len) {

drivers/crypto/chelsio/chcr_algo.c

517

small = min(sg_dma_len(sg) - skip_len, len);

drivers/crypto/chelsio/chcr_algo.c

530

if (sg_dma_len(sg) == skip_len) {

drivers/crypto/chelsio/chcr_algo.c

588

if (sg_dma_len(src) == srcskip) {

drivers/crypto/chelsio/chcr_algo.c

593

sless = min_t(unsigned int, sg_dma_len(src) - soffset - srcskip,

drivers/crypto/chelsio/chcr_algo.c

598

if (sg_dma_len(src) == (soffset + srcskip)) {

drivers/crypto/chelsio/chcr_algo.c

618

if (sg_dma_len(src) == srcskip) {

drivers/crypto/chelsio/chcr_algo.c

622

if (sg_dma_len(dst) == dstskip) {

drivers/crypto/chelsio/chcr_algo.c

629

sless = min_t(unsigned int, sg_dma_len(src) - srcskip - soffset,

drivers/crypto/chelsio/chcr_algo.c

638

less = min_t(unsigned int, sg_dma_len(dst) - offset -

drivers/crypto/chelsio/chcr_algo.c

642

if ((offset + dstskip) == sg_dma_len(dst)) {

drivers/crypto/chelsio/chcr_algo.c

650

if ((soffset + srcskip) == sg_dma_len(src)) {

drivers/crypto/gemini/sl3516-ce-cipher.c

183

if (sg_dma_len(sg) == 0)

drivers/crypto/gemini/sl3516-ce-cipher.c

186

todo = min(len, sg_dma_len(sg));

drivers/crypto/gemini/sl3516-ce-cipher.c

205

if (sg_dma_len(sg) == 0)

drivers/crypto/gemini/sl3516-ce-cipher.c

208

todo = min(len, sg_dma_len(sg));

drivers/crypto/gemini/sl3516-ce-cipher.c

59

if ((sg_dma_len(sg) % 16) != 0) {

drivers/crypto/gemini/sl3516-ce-cipher.c

75

if ((sg_dma_len(sg) % 16) != 0) {

drivers/crypto/hisilicon/sec/sec_algs.c

211

sgl_current->sge_entries[sge_index].len = sg_dma_len(sg);

drivers/crypto/hisilicon/sec/sec_algs.c

212

sgl_current->data_bytes_in_sgl += sg_dma_len(sg);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1062

hw_sge->len = cpu_to_le32(sg_dma_len(sgl));

drivers/crypto/hisilicon/sgl.c

176

hw_sge->len = cpu_to_le32(sg_dma_len(sgl));

drivers/crypto/inside-secure/eip93/eip93-common.c

387

unsigned int remainin = sg_dma_len(sgsrc);

drivers/crypto/inside-secure/eip93/eip93-common.c

388

unsigned int remainout = sg_dma_len(sgdst);

drivers/crypto/inside-secure/eip93/eip93-common.c

412

remainin = sg_dma_len(sgsrc);

drivers/crypto/inside-secure/eip93/eip93-common.c

423

remainout = sg_dma_len(sgdst);

drivers/crypto/inside-secure/safexcel_cipher.c

796

int len = sg_dma_len(sg);

drivers/crypto/inside-secure/safexcel_cipher.c

834

u32 len = sg_dma_len(sg);

drivers/crypto/inside-secure/safexcel_hash.c

429

int sglen = sg_dma_len(sg);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1243

req->src, req->slen, sg_dma_len(req->src));

drivers/crypto/intel/iaa/iaa_crypto_main.c

1257

req->dst, req->dlen, sg_dma_len(req->dst));

drivers/crypto/intel/iaa/iaa_crypto_main.c

1521

req->src, req->slen, sg_dma_len(req->src));

drivers/crypto/intel/iaa/iaa_crypto_main.c

1534

req->dst, req->dlen, sg_dma_len(req->dst));

drivers/crypto/intel/iaa/iaa_crypto_main.c

1619

req->src, req->slen, sg_dma_len(req->src));

drivers/crypto/intel/iaa/iaa_crypto_main.c

1632

req->dst, req->dlen, sg_dma_len(req->dst));

drivers/crypto/intel/keembay/keembay-ocs-hcu-core.c

322

sg_dma_len(rctx->sg) - rctx->sg_data_offset);

drivers/crypto/intel/keembay/ocs-aes.c

1442

while (data_offset >= sg_dma_len(sg)) {

drivers/crypto/intel/keembay/ocs-aes.c

1443

data_offset -= sg_dma_len(sg);

drivers/crypto/intel/keembay/ocs-aes.c

1459

tmp += sg_dma_len(sg_tmp);

drivers/crypto/intel/keembay/ocs-aes.c

1477

ll[i].src_len = min(sg_dma_len(sg) - data_offset, data_size);

drivers/crypto/marvell/cesa/cesa.h

813

sg_dma_len(sgiter->sg) - sgiter->offset);

drivers/crypto/marvell/cesa/tdma.c

24

if (sgiter->offset == sg_dma_len(sgiter->sg)) {

drivers/crypto/mxs-dcp.c

356

len = sg_dma_len(src);

drivers/crypto/qce/sha.c

253

if (len + sg_dma_len(sg) > nbytes)

drivers/crypto/qce/sha.c

255

len += sg_dma_len(sg);

drivers/crypto/rockchip/rk3288_crypto_ahash.c

230

CRYPTO_WRITE(dev, RK_CRYPTO_HRDMAL, sg_dma_len(sg) / 4);

drivers/crypto/rockchip/rk3288_crypto_skcipher.c

375

todo = min(sg_dma_len(sgs), len);

drivers/crypto/s5p-sss.c

435

SSS_WRITE(dev, FCBRDMAL, sg_dma_len(sg));

drivers/crypto/s5p-sss.c

442

SSS_WRITE(dev, FCBTDMAL, sg_dma_len(sg));

drivers/crypto/s5p-sss.c

613

SSS_WRITE(dev, FCHRDMAL, sg_dma_len(sg)); /* DMA starts */

drivers/crypto/starfive/jh7110-aes.c

451

in_save = sg_dma_len(src);

drivers/crypto/starfive/jh7110-aes.c

452

out_save = sg_dma_len(dst);

drivers/crypto/starfive/jh7110-aes.c

457

sg_dma_len(src) = ALIGN(len, AES_BLOCK_SIZE);

drivers/crypto/starfive/jh7110-aes.c

458

sg_dma_len(dst) = ALIGN(len, AES_BLOCK_SIZE);

drivers/crypto/starfive/jh7110-aes.c

489

sg_dma_len(src) = in_save;

drivers/crypto/starfive/jh7110-aes.c

490

sg_dma_len(dst) = out_save;

drivers/crypto/starfive/jh7110-aes.c

517

len = min(sg_dma_len(stsg), remain);

drivers/crypto/starfive/jh7110-aes.c

536

len = min(sg_dma_len(stsg), sg_dma_len(dtsg));

drivers/crypto/starfive/jh7110-aes.c

549

if (sg_dma_len(stsg) - len) {

drivers/crypto/starfive/jh7110-aes.c

552

} else if (sg_dma_len(dtsg) - len) {

drivers/crypto/starfive/jh7110-aes.c

680

sg_dma_len(rctx->in_sg) - cryp->total_in,

drivers/crypto/starfive/jh7110-hash.c

136

writel(sg_dma_len(sg), cryp->base + STARFIVE_DMA_IN_LEN_OFFSET);

drivers/crypto/starfive/jh7110-hash.c

137

sg_dma_len(sg) = ALIGN(sg_dma_len(sg), sizeof(u32));

drivers/crypto/talitos.c

1104

unsigned int len = sg_dma_len(sg);

drivers/dma-buf/dma-buf-mapping.c

202

sg_dma_len(sgl), dir, DMA_ATTR_MMIO);

drivers/dma-buf/dma-buf-mapping.c

240

sg_dma_len(sgl), dir, DMA_ATTR_MMIO);

drivers/dma-buf/dma-buf-mapping.c

28

sg_dma_len(sgl) = len;

drivers/dma-buf/dma-buf.c

1221

len = sg_dma_len(sg);

drivers/dma-buf/dma-buf.c

883

sg_dma_len(to_sg) = sg_dma_len(from_sg);

drivers/dma/altera-msgdma.c

414

avail = sg_dma_len(sgl);

drivers/dma/altera-msgdma.c

425

dma_src = sg_dma_address(sgl) + sg_dma_len(sgl) - avail;

drivers/dma/altera-msgdma.c

430

dma_dst = sg_dma_address(sgl) + sg_dma_len(sgl) - avail;

drivers/dma/altera-msgdma.c

449

avail = sg_dma_len(sgl);

drivers/dma/amba-pl08x.c

2054

__func__, sg_dma_len(sgl), plchan->name);

drivers/dma/amba-pl08x.c

2063

sg_dma_len(sg));

drivers/dma/amd/qdma/qdma.c

680

rest = sg_dma_len(sg) - vdesc->sg_off;

drivers/dma/at_hdmac.c

1201

size_t len = sg_dma_len(sg);

drivers/dma/at_hdmac.c

1311

len = sg_dma_len(sg);

drivers/dma/at_hdmac.c

1360

len = sg_dma_len(sg);

drivers/dma/at_xdmac.c

1395

__func__, &sg_dma_address(sg), sg_dma_len(sg),

drivers/dma/at_xdmac.c

1399

sg_dma_len(sg),

drivers/dma/at_xdmac.c

1412

(sg_dma_address(psg) + sg_dma_len(psg));

drivers/dma/at_xdmac.c

1435

(sg_dma_len(ppsg) == sg_dma_len(psg))) {

drivers/dma/at_xdmac.c

1498

sg_dma_len(psg) == sg_dma_len(sg)) {

drivers/dma/at_xdmac.c

1526

len += sg_dma_len(sg);

drivers/dma/at_xdmac.c

795

len = sg_dma_len(sg);

drivers/dma/bcm2835-dma.c

381

for (addr = sg_dma_address(sgent), len = sg_dma_len(sgent);

drivers/dma/dma-axi-dmac.c

689

!axi_dmac_check_len(chan, sg_dma_len(sg))) {

drivers/dma/dma-axi-dmac.c

695

sg_dma_len(sg), dsg);

drivers/dma/dma-jz4780.c

379

sg_dma_len(&sgl[i]),

drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c

864

len = sg_dma_len(sgl);

drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c

881

len = sg_dma_len(sg);

drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c

882

num_segments = DIV_ROUND_UP(sg_dma_len(sg), axi_block_len);

drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c

883

segment_len = DIV_ROUND_UP(sg_dma_len(sg), num_segments);

drivers/dma/dw-edma/dw-edma-core.c

466

burst->sz = sg_dma_len(sg);

drivers/dma/dw-edma/dw-edma-core.c

478

src_addr += sg_dma_len(sg);

drivers/dma/dw-edma/dw-edma-core.c

495

dst_addr += sg_dma_len(sg);

drivers/dma/dw/core.c

660

len = sg_dma_len(sg);

drivers/dma/dw/core.c

710

len = sg_dma_len(sg);

drivers/dma/ep93xx_dma.c

1110

size_t len = sg_dma_len(sg);

drivers/dma/fsl-edma-common.c

743

if (sg_dma_len(sg) % nbytes) {

drivers/dma/fsl-edma-common.c

751

if (!(sg_dma_len(sg) % (j * width))) {

drivers/dma/fsl-edma-common.c

760

iter = sg_dma_len(sg) / nbytes;

drivers/dma/hsu/hsu.c

285

desc->sg[i].len = sg_dma_len(sg);

drivers/dma/hsu/hsu.c

287

desc->length += sg_dma_len(sg);

drivers/dma/idma64.c

326

hw->len = sg_dma_len(sg);

drivers/dma/img-mdc-dma.c

475

size_t buf_len = sg_dma_len(sg);

drivers/dma/imx-dma.c

266

now = min_t(size_t, d->len, sg_dma_len(sg));

drivers/dma/imx-dma.c

810

dma_length += sg_dma_len(sg);

drivers/dma/imx-dma.c

817

if (sg_dma_len(sgl) & 3 || sgl->dma_address & 3)

drivers/dma/imx-dma.c

821

if (sg_dma_len(sgl) & 1 || sgl->dma_address & 1)

drivers/dma/imx-dma.c

879

sg_dma_len(&imxdmac->sg_list[i]) = period_len;

drivers/dma/imx-sdma.c

1665

count = sg_dma_len(sg);

drivers/dma/k3dma.c

555

avail = sg_dma_len(sg);

drivers/dma/lgm/lgm-dma.c

1187

avail = sg_dma_len(sg);

drivers/dma/loongson1-apb-dma.c

246

size_t buf_len = sg_dma_len(sg);

drivers/dma/loongson1-apb-dma.c

347

sg_dma_len(&sgl[i]) = period_len;

drivers/dma/loongson2-apb-dma.c

358

ldma_sg->len = sg_dma_len(sg);

drivers/dma/mediatek/mtk-uart-apdma.c

358

d->avail_len = sg_dma_len(sgl);

drivers/dma/milbeaut-hdmac.c

123

len = sg_dma_len(sg);

drivers/dma/milbeaut-hdmac.c

372

txstate->residue += sg_dma_len(&md->sgl[i]);

drivers/dma/mmp_pdma.c

704

avail = sg_dma_len(sgl);

drivers/dma/moxart-dma.c

315

d->sg[i].len = sg_dma_len(sgent);

drivers/dma/mpc512x_dma.c

765

tcd->nbytes = sg_dma_len(sg);

drivers/dma/mpc512x_dma.c

773

len = sg_dma_len(sg);

drivers/dma/mxs-dma.c

535

if (sg_dma_len(sg) > MAX_XFER_BYTES) {

drivers/dma/mxs-dma.c

537

sg_dma_len(sg), MAX_XFER_BYTES);

drivers/dma/mxs-dma.c

545

ccw->xfer_bytes = sg_dma_len(sg);

drivers/dma/nbpfaxi.c

1015

sg_dma_len(&dst_sg) = len;

drivers/dma/nbpfaxi.c

1016

sg_dma_len(&src_sg) = len;

drivers/dma/nbpfaxi.c

980

sg_dma_len(mem_sg),

drivers/dma/nbpfaxi.c

986

data_len += sg_dma_len(mem_sg);

drivers/dma/owl-dma.c

940

len = sg_dma_len(sg);

drivers/dma/pch_dma.c

598

desc->regs.size = sg_dma_len(sg);

drivers/dma/pl330.c

2883

sg_dma_len(sg));

drivers/dma/pl330.c

2888

sg_dma_len(sg));

drivers/dma/pl330.c

2894

desc->bytes_requested = sg_dma_len(sg);

drivers/dma/pxa_dma.c

987

avail = sg_dma_len(sg);

drivers/dma/qcom/bam_dma.c

682

unsigned int remainder = sg_dma_len(sg);

drivers/dma/qcom/gpi.c

1686

tre->dword[2] = u32_encode_bits(sg_dma_len(sgl), TRE_DMA_LEN);

drivers/dma/qcom/gpi.c

1764

len = sg_dma_len(sgl);

drivers/dma/qcom/gpi.c

1856

gpi_desc->len = sg_dma_len(sgl);

drivers/dma/qcom/qcom_adm.c

236

u32 remainder = sg_dma_len(sg);

drivers/dma/qcom/qcom_adm.c

303

u32 remainder = sg_dma_len(sg);

drivers/dma/qcom/qcom_adm.c

395

box_count += DIV_ROUND_UP(sg_dma_len(sg) / burst,

drivers/dma/qcom/qcom_adm.c

397

if (sg_dma_len(sg) % burst)

drivers/dma/qcom/qcom_adm.c

430

async_desc->length += sg_dma_len(sg);

drivers/dma/sa11x0-dma.c

564

unsigned len = sg_dma_len(sgent);

drivers/dma/sh/rcar-dmac.c

1140

sg_dma_len(&sgl) = len;

drivers/dma/sh/rcar-dmac.c

1207

if (rchan->mid_rid < 0 || !sg_len || !sg_dma_len(sgl)) {

drivers/dma/sh/rcar-dmac.c

1269

sg_dma_len(&sgl[i]) = period_len;

drivers/dma/sh/rcar-dmac.c

966

unsigned int len = sg_dma_len(sg);

drivers/dma/sh/rz-dmac.c

377

lmdesc->tb = sg_dma_len(sg);

drivers/dma/sh/rz-dmac.c

541

dma_length += sg_dma_len(sg);

drivers/dma/sh/shdma-base.c

602

size_t len = sg_dma_len(sg);

drivers/dma/sh/shdma-base.c

667

sg_dma_len(&sg) = len;

drivers/dma/sh/shdma-base.c

755

sg_dma_len(&sgl[i]) = period_len;

drivers/dma/sh/usb-dmac.c

439

desc->sg[i].size = sg_dma_len(sg);

drivers/dma/sprd-dma.c

996

len = sg_dma_len(sg);

drivers/dma/st_fdma.c

546

hw_node->nbytes = sg_dma_len(sg);

drivers/dma/st_fdma.c

547

hw_node->generic.length = sg_dma_len(sg);

drivers/dma/ste_dma40.c

1052

ret = d40_size_2_dmalen(sg_dma_len(sg),

drivers/dma/ste_dma40.c

2504

sg_dma_len(&dst_sg) = size;

drivers/dma/ste_dma40.c

2505

sg_dma_len(&src_sg) = size;

drivers/dma/ste_dma40.c

2538

sg_dma_len(&sg[i]) = period_len;

drivers/dma/ste_dma40_ll.c

287

unsigned int len = sg_dma_len(current_sg);

drivers/dma/ste_dma40_ll.c

290

total_size += sg_dma_len(current_sg);

drivers/dma/ste_dma40_ll.c

436

unsigned int len = sg_dma_len(current_sg);

drivers/dma/ste_dma40_ll.c

439

total_size += sg_dma_len(current_sg);

drivers/dma/stm32/stm32-dma.c

1123

sg_dma_len(sg),

drivers/dma/stm32/stm32-dma.c

1128

desc->sg_req[i].len = sg_dma_len(sg);

drivers/dma/stm32/stm32-dma.c

1143

desc->sg_req[i].chan_reg.dma_sm1ar += sg_dma_len(sg);

drivers/dma/stm32/stm32-dma3.c

1315

count += stm32_dma3_get_ll_count(chan, sg_dma_len(sg), prevent_refactor);

drivers/dma/stm32/stm32-dma3.c

1327

len = sg_dma_len(sg);

drivers/dma/stm32/stm32-mdma.c

738

m2m_hw_period = sg_dma_len(sgl);

drivers/dma/stm32/stm32-mdma.c

741

if (sg_dma_len(sg) > STM32_MDMA_MAX_BLOCK_LEN) {

drivers/dma/stm32/stm32-mdma.c

753

sg_dma_len(sg));

drivers/dma/stm32/stm32-mdma.c

763

sg_dma_len(sg));

drivers/dma/stm32/stm32-mdma.c

772

dst_addr, sg_dma_len(sg), ctcr, ctbr,

drivers/dma/sun4i-dma.c

950

sg_dma_len(sg),

drivers/dma/sun4i-dma.c

954

sg_dma_len(sg),

drivers/dma/sun6i-dma.c

748

v_lli->len = sg_dma_len(sg);

drivers/dma/sun6i-dma.c

763

sg_dma_len(sg), flags);

drivers/dma/sun6i-dma.c

777

sg_dma_len(sg), flags);

drivers/dma/tegra186-gpc-dma.c

1086

len = sg_dma_len(sg);

drivers/dma/tegra20-apb-dma.c

1105

len = sg_dma_len(sg);

drivers/dma/ti/cppi41.c

610

len = sg_dma_len(sg);

drivers/dma/ti/edma.c

1079

sg_dma_len(sg), direction);

drivers/dma/ti/edma.c

1086

edesc->residue += sg_dma_len(sg);

drivers/dma/ti/k3-udma.c

2899

if (sg_dma_len(sgent) < SZ_64K)

drivers/dma/ti/k3-udma.c

2922

num_tr = udma_get_tr_counters(sg_dma_len(sgent), __ffs(sg_addr),

drivers/dma/ti/k3-udma.c

2926

sg_dma_len(sgent));

drivers/dma/ti/k3-udma.c

2957

d->residue += sg_dma_len(sgent);

drivers/dma/ti/k3-udma.c

3021

sg_len = sg_dma_len(sgent);

drivers/dma/ti/k3-udma.c

3057

sg_len = sg_dma_len(sgent);

drivers/dma/ti/k3-udma.c

3265

size_t sg_len = sg_dma_len(sgent);

drivers/dma/ti/omap-dma.c

1107

osg->fn = sg_dma_len(sgent) / frame_bytes;

drivers/dma/timb_dma.c

148

if (sg_dma_len(sg) > USHRT_MAX) {

drivers/dma/timb_dma.c

154

if (sg_dma_len(sg) % sizeof(u32)) {

drivers/dma/timb_dma.c

156

sg_dma_len(sg));

drivers/dma/timb_dma.c

168

dma_desc[3] = (sg_dma_len(sg) >> 8) & 0xff;

drivers/dma/timb_dma.c

169

dma_desc[2] = (sg_dma_len(sg) >> 0) & 0xff;

drivers/dma/txx9dmac.c

848

desc->hwdesc.CNTR = sg_dma_len(sg);

drivers/dma/txx9dmac.c

857

desc->hwdesc32.CNTR = sg_dma_len(sg);

drivers/dma/uniphier-mdmac.c

128

chunk_size = sg_dma_len(sg);

drivers/dma/uniphier-mdmac.c

320

txstate->residue += sg_dma_len(&md->sgl[i]);

drivers/dma/uniphier-xdmac.c

363

sg_dma_len(sg) / xd->nodes[i].burst_size;

drivers/dma/uniphier-xdmac.c

373

if (sg_dma_len(sg) % xd->nodes[i].burst_size) {

drivers/dma/uniphier-xdmac.c

375

"Unaligned transfer size: %d", sg_dma_len(sg));

drivers/dma/xilinx/xdma.c

633

desc_num += xdma_fill_descs(sw_desc, *src, *dst, sg_dma_len(sg), desc_num);

drivers/dma/xilinx/xdma.c

634

dev_addr += sg_dma_len(sg);

drivers/dma/xilinx/xilinx_dma.c

2345

while (sg_used < sg_dma_len(sg)) {

drivers/dma/xilinx/xilinx_dma.c

2357

copy = xilinx_dma_calc_copysize(chan, sg_dma_len(sg),

drivers/dma/xilinx/xilinx_dma.c

2555

while (sg_used < sg_dma_len(sg)) {

drivers/dma/xilinx/xilinx_dma.c

2567

copy = min_t(size_t, sg_dma_len(sg) - sg_used,

drivers/firewire/sbp2.c

1406

cpu_to_be32(COMMAND_ORB_DATA_SIZE(sg_dma_len(sg)));

drivers/firewire/sbp2.c

1411

orb->page_table[i].high = cpu_to_be32(sg_dma_len(sg) << 16);

drivers/fpga/zynq-fpga.c

173

len = sg_dma_len(priv->cur_sg);

drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c

1133

sg_dma_len(sg) = cur.size;

drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c

1143

dma_unmap_resource(dev, sg_dma_address(sg), sg_dma_len(sg),

drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c

726

sg_dma_len(sg) = size;

drivers/gpu/drm/armada/armada_gem.c

436

sg_dma_len(sgt->sgl) = dobj->obj.size;

drivers/gpu/drm/armada/armada_gem.c

555

if (sg_dma_len(dobj->sgt->sgl) < dobj->obj.size) {

drivers/gpu/drm/drm_prime.c

894

unsigned int len = sg_dma_len(sg);

drivers/gpu/drm/etnaviv/etnaviv_mmu.c

284

if (iova < 0x80000000 - sg_dma_len(sgt->sgl)) {

drivers/gpu/drm/etnaviv/etnaviv_mmu.c

76

unsigned int da_len = sg_dma_len(sg);

drivers/gpu/drm/i915/gem/i915_gem_pages.c

796

*len = sg_dma_len(sg) - (offset << PAGE_SHIFT);

drivers/gpu/drm/i915/gem/i915_gem_phys.c

63

sg_dma_len(sg) = obj->base.size;

drivers/gpu/drm/i915/gem/i915_gem_stolen.c

665

sg_dma_len(sg) = size;

drivers/gpu/drm/i915/gem/i915_gem_stolen.c

682

sg_dma_len(pages->sgl),

drivers/gpu/drm/i915/gem/i915_gem_stolen.c

698

sg_dma_len(pages->sgl),

drivers/gpu/drm/i915/gem/selftests/huge_pages.c

245

sg_dma_len(sg) = len;

drivers/gpu/drm/i915/gem/selftests/huge_pages.c

290

sg_dma_len(sg) = obj->base.size;

drivers/gpu/drm/i915/gt/gen6_ppgtt.c

128

GEM_BUG_ON(sg_dma_len(iter.sg) < I915_GTT_PAGE_SIZE);

drivers/gpu/drm/i915/gt/gen6_ppgtt.c

134

if (!iter.sg || sg_dma_len(iter.sg) == 0)

drivers/gpu/drm/i915/gt/gen6_ppgtt.c

138

iter.max = iter.dma + sg_dma_len(iter.sg);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

469

GEM_BUG_ON(sg_dma_len(iter->sg) < I915_GTT_PAGE_SIZE);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

475

if (!iter->sg || sg_dma_len(iter->sg) == 0) {

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

481

iter->max = iter->dma + sg_dma_len(iter->sg);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

510

unsigned int rem = sg_dma_len(iter->sg);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

594

rem = sg_dma_len(iter->sg);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

608

} while (iter->sg && sg_dma_len(iter->sg));

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

618

unsigned int rem = sg_dma_len(iter->sg);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

661

GEM_BUG_ON(sg_dma_len(iter->sg) < page_size);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

672

rem = sg_dma_len(iter->sg);

drivers/gpu/drm/i915/gt/gen8_ppgtt.c

732

} while (iter->sg && sg_dma_len(iter->sg));

drivers/gpu/drm/i915/gt/intel_gtt.h

702

return (struct sgt_dma){ sg, addr, addr + sg_dma_len(sg) };

drivers/gpu/drm/i915/gt/intel_migrate.c

1068

if (err || !it.sg || !sg_dma_len(it.sg))

drivers/gpu/drm/i915/gt/intel_migrate.c

331

return (struct sgt_dma){ sg, addr, addr + sg_dma_len(sg) };

drivers/gpu/drm/i915/gt/intel_migrate.c

460

if (!it->sg || sg_dma_len(it->sg) == 0)

drivers/gpu/drm/i915/gt/intel_migrate.c

464

it->max = it->dma + sg_dma_len(it->sg);

drivers/gpu/drm/i915/gt/intel_migrate.c

632

while (sg && sg_dma_len(sg)) {

drivers/gpu/drm/i915/gt/intel_migrate.c

633

len += sg_dma_len(sg);

drivers/gpu/drm/i915/gt/intel_migrate.c

662

GEM_BUG_ON(!it->sg || !sg_dma_len(it->sg));

drivers/gpu/drm/i915/gt/intel_migrate.c

673

it->max = it->dma + sg_dma_len(it->sg);

drivers/gpu/drm/i915/gt/intel_migrate.c

896

WARN_ON(it_src.sg && sg_dma_len(it_src.sg));

drivers/gpu/drm/i915/gt/intel_migrate.c

898

WARN_ON(it_dst.sg && sg_dma_len(it_dst.sg));

drivers/gpu/drm/i915/gt/intel_migrate.c

902

if (WARN_ON(!it_src.sg || !sg_dma_len(it_src.sg) ||

drivers/gpu/drm/i915/gt/intel_migrate.c

903

!it_dst.sg || !sg_dma_len(it_dst.sg) ||

drivers/gpu/drm/i915/gt/intel_migrate.c

905

!sg_dma_len(it_ccs.sg))))) {

drivers/gpu/drm/i915/gt/selftest_migrate.c

211

if (err || !it.sg || !sg_dma_len(it.sg))

drivers/gpu/drm/i915/gvt/dmabuf.c

91

sg_dma_len(sg) = PAGE_SIZE;

drivers/gpu/drm/i915/i915_scatterlist.c

128

sg_dma_len(sg) = 0;

drivers/gpu/drm/i915/i915_scatterlist.c

135

sg_dma_len(sg) += len;

drivers/gpu/drm/i915/i915_scatterlist.c

218

sg_dma_len(sg) = 0;

drivers/gpu/drm/i915/i915_scatterlist.c

225

sg_dma_len(sg) += len;

drivers/gpu/drm/i915/i915_scatterlist.c

31

sg_dma_len(new_sg) = sg_dma_len(sg);

drivers/gpu/drm/i915/i915_scatterlist.h

131

while (sg && sg_dma_len(sg)) {

drivers/gpu/drm/i915/i915_scatterlist.h

133

GEM_BUG_ON(!IS_ALIGNED(sg_dma_len(sg), PAGE_SIZE));

drivers/gpu/drm/i915/i915_scatterlist.h

134

page_sizes |= sg_dma_len(sg);

drivers/gpu/drm/i915/i915_scatterlist.h

34

if (dma && s.sgp && sg_dma_len(s.sgp) == 0) {

drivers/gpu/drm/i915/i915_scatterlist.h

40

s.max += sg_dma_len(s.sgp);

drivers/gpu/drm/i915/i915_scatterlist.h

57

return sg_dma_len(sg) >> PAGE_SHIFT;

drivers/gpu/drm/i915/i915_vma.c

1011

sg_dma_len(sg) = left;

drivers/gpu/drm/i915/i915_vma.c

1074

sg_dma_len(sg) = count * I915_GTT_PAGE_SIZE;

drivers/gpu/drm/i915/i915_vma.c

1117

sg_dma_len(sg) = length;

drivers/gpu/drm/i915/i915_vma.c

1154

len = min(sg_dma_len(iter) - (offset << PAGE_SHIFT),

drivers/gpu/drm/i915/i915_vma.c

1159

sg_dma_len(sg) = len;

drivers/gpu/drm/i915/i915_vma.c

992

sg_dma_len(sg) = I915_GTT_PAGE_SIZE;

drivers/gpu/drm/i915/selftests/i915_gem_gtt.c

89

sg_dma_len(sg) = len;

drivers/gpu/drm/i915/selftests/i915_vma.c

395

if (sg_dma_len(sg) != PAGE_SIZE) {

drivers/gpu/drm/i915/selftests/i915_vma.c

397

sg_dma_len(sg), PAGE_SIZE,

drivers/gpu/drm/i915/selftests/i915_vma.c

422

if (sg_dma_len(sg) != left) {

drivers/gpu/drm/i915/selftests/i915_vma.c

424

sg_dma_len(sg), left, x, y);

drivers/gpu/drm/i915/selftests/i915_vma.c

470

left = sg_dma_len(sg);

drivers/gpu/drm/i915/selftests/i915_vma.c

478

sg_dma_len(sg), PAGE_SIZE,

drivers/gpu/drm/i915/selftests/i915_vma.c

515

if (sg_dma_len(sg) != left) {

drivers/gpu/drm/i915/selftests/i915_vma.c

517

sg_dma_len(sg), left,

drivers/gpu/drm/i915/selftests/intel_memory_region.c

150

addr = sg_dma_address(sg) + sg_dma_len(sg);

drivers/gpu/drm/imagination/pvr_gem.c

415

u32 new_offset = accumulated_offset + sg_dma_len(sgl);

drivers/gpu/drm/imagination/pvr_mmu.c

2518

const unsigned int dma_len = sg_dma_len(sgl);

drivers/gpu/drm/imagination/pvr_mmu.c

2603

const size_t sgl_len = sg_dma_len(sgl);

drivers/gpu/drm/nouveau/nvkm/core/firmware.c

153

return sgl ? sg_dma_len(sgl) : 0;

drivers/gpu/drm/nouveau/nvkm/core/firmware.c

208

dma_free_noncoherent(fw->device->dev, sg_dma_len(&fw->mem.sgl),

drivers/gpu/drm/nouveau/nvkm/core/firmware.c

253

sg_dma_len(&fw->mem.sgl) = len;

drivers/gpu/drm/nouveau/nvkm/falcon/fw.c

106

sg_dma_len(&fw->fw.mem.sgl),

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/fbsr.c

93

for (int i = 0; i < sg_dma_len(sgl) / GSP_PAGE_SIZE; i++)

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1563

u64 size = sg_dma_len(map->sgl);

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.h

359

sg_dma_address(MAP->sgl), sg_dma_len(MAP->sgl), \

drivers/gpu/drm/omapdrm/omap_gem.c

1026

sg_dma_len(sg) = len;

drivers/gpu/drm/omapdrm/omap_gem.c

1034

sg_dma_len(sg) = PAGE_SIZE;

drivers/gpu/drm/panfrost/panfrost_gem.c

586

size_t len = sg_dma_len(sgl);

drivers/gpu/drm/panfrost/panfrost_mmu.c

428

size_t len = sg_dma_len(sgl);

drivers/gpu/drm/panthor/panthor_gem.c

564

size_t len = sg_dma_len(sgl);

drivers/gpu/drm/panthor/panthor_mmu.c

944

size_t len = sg_dma_len(sgl);

drivers/gpu/drm/tegra/gem.c

35

if (!sg_dma_len(s))

drivers/gpu/drm/tegra/gem.c

39

next = sg_dma_address(s) + sg_dma_len(s);

drivers/gpu/drm/ttm/ttm_resource.c

733

iter_io->cache.end += sg_dma_len(iter_io->cache.sg) >>

drivers/gpu/drm/v3d/v3d_mmu.c

96

unsigned int len = sg_dma_len(sgl);

drivers/gpu/drm/virtio/virtgpu_object.c

189

(*ents)[si].length = cpu_to_le32(sg_dma_len(sg));

drivers/gpu/drm/virtio/virtgpu_prime.c

176

(*ents)[i].length = cpu_to_le32(sg_dma_len(sl));

drivers/gpu/drm/virtio/virtgpu_vram.c

109

sg_dma_len(sgt->sgl) = vram->vram_node.size;

drivers/gpu/drm/virtio/virtgpu_vram.c

124

sg_dma_len(sgt->sgl), dir,

drivers/gpu/drm/xe/xe_res_cursor.h

156

while (start >= sg_dma_len(sgl)) {

drivers/gpu/drm/xe/xe_res_cursor.h

157

start -= sg_dma_len(sgl);

drivers/gpu/drm/xe/xe_res_cursor.h

163

cur->size = sg_dma_len(sgl) - start;

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

414

sg_dma_len(sg) = size;

drivers/hid/intel-thc-hid/intel-thc/intel-thc-dma.c

199

prd_tbl->entries[j].len = sg_dma_len(sg);

drivers/hid/intel-thc-hid/intel-thc/intel-thc-dma.c

900

if (sg_dma_address(sg) == 0 || sg_dma_len(sg) == 0) {

drivers/hid/intel-thc-hid/intel-thc/intel-thc-dma.c

908

if (len_left < sg_dma_len(sg)) {

drivers/hid/intel-thc-hid/intel-thc/intel-thc-dma.c

914

prd_tbl->entries[i].len = sg_dma_len(sg);

drivers/hid/intel-thc-hid/intel-thc/intel-thc-dma.c

917

len_left -= sg_dma_len(sg);

drivers/hsi/controllers/omap_ssi_core.c

208

msg->actual_len = sg_dma_len(msg->sgt.sgl);

drivers/i2c/busses/i2c-at91-master.c

227

sg_dma_len(sg) = part1_len;

drivers/i2c/busses/i2c-at91-master.c

234

sg_dma_len(sg) = part2_len;

drivers/i2c/busses/i2c-at91-master.c

247

sg_dma_len(&dma->sg[0]) = dev->buf_len;

drivers/i2c/busses/i2c-at91-master.c

367

sg_dma_len(&dma->sg[0]) = buf_len;

drivers/i2c/busses/i2c-rcar.c

457

sg_dma_len(&priv->sg), priv->dma_direction);

drivers/i2c/busses/i2c-rcar.c

474

priv->pos += sg_dma_len(&priv->sg);

drivers/i2c/busses/i2c-rcar.c

518

sg_dma_len(&priv->sg) = len;

drivers/i2c/busses/i2c-sh_mobile.c

535

sg_dma_len(&pd->sg) = pd->msg->len;

drivers/iio/buffer/industrialio-buffer-dmaengine.c

96

vecs[i].len = min(sg_dma_len(sgl), len_total);

drivers/infiniband/core/device.c

2913

sg_dma_len(s) = s->length;

drivers/infiniband/core/rw.c

321

sge->length = sg_dma_len(sg) - offset;

drivers/infiniband/core/rw.c

353

ctx->single.sge.length = sg_dma_len(sg) - offset;

drivers/infiniband/core/rw.c

594

u32 len = sg_dma_len(sg);

drivers/infiniband/core/umem.c

141

curr_len += sg_dma_len(sg);

drivers/infiniband/core/umem.c

142

va += sg_dma_len(sg) - pgoff;

drivers/infiniband/core/umem_dmabuf.c

103

sg_dma_len(umem_dmabuf->last_sg) +=

drivers/infiniband/core/umem_dmabuf.c

43

if (start < cur + sg_dma_len(sg) && cur < end)

drivers/infiniband/core/umem_dmabuf.c

45

if (cur <= start && start < cur + sg_dma_len(sg)) {

drivers/infiniband/core/umem_dmabuf.c

51

sg_dma_len(sg) -= offset;

drivers/infiniband/core/umem_dmabuf.c

54

if (cur < end && end <= cur + sg_dma_len(sg)) {

drivers/infiniband/core/umem_dmabuf.c

55

unsigned long trim = cur + sg_dma_len(sg) - end;

drivers/infiniband/core/umem_dmabuf.c

59

sg_dma_len(sg) -= trim;

drivers/infiniband/core/umem_dmabuf.c

62

cur += sg_dma_len(sg);

drivers/infiniband/core/umem_dmabuf.c

97

sg_dma_len(umem_dmabuf->first_sg) +=

drivers/infiniband/core/verbs.c

2816

if (unlikely(sg_nents <= 0 || sg_offset > sg_dma_len(&sgl[0])))

drivers/infiniband/core/verbs.c

2825

unsigned int dma_len = sg_dma_len(sg) - sg_offset;

drivers/infiniband/core/verbs.c

3183

sg_dma_len(biter->__sg) - biter->__sg_advance <= delta) {

drivers/infiniband/core/verbs.c

3184

delta -= sg_dma_len(biter->__sg) - biter->__sg_advance;

drivers/infiniband/hw/mlx5/mr.c

2687

mr->data_length = sg_dma_len(data_sg) - sg_offset;

drivers/infiniband/hw/mlx5/mr.c

2696

mr->meta_length = sg_dma_len(meta_sg) - sg_offset;

drivers/infiniband/hw/mlx5/mr.c

2727

klms[i].bcount = cpu_to_be32(sg_dma_len(sg) - sg_offset);

drivers/infiniband/hw/mlx5/mr.c

2729

mr->ibmr.length += sg_dma_len(sg) - sg_offset;

drivers/infiniband/hw/mlx5/mr.c

2748

klms[i + j].bcount = cpu_to_be32(sg_dma_len(sg) -

drivers/infiniband/hw/mlx5/mr.c

2751

mr->ibmr.length += sg_dma_len(sg) - sg_offset;

drivers/infiniband/hw/mthca/mthca_memfree.c

133

sg_dma_len(mem) = PAGE_SIZE << order;

drivers/infiniband/hw/mthca/mthca_memfree.c

300

if (sg_dma_len(&chunk->mem[i]) > dma_offset)

drivers/infiniband/hw/mthca/mthca_memfree.c

303

dma_offset -= sg_dma_len(&chunk->mem[i]);

drivers/infiniband/hw/mthca/mthca_memfree.h

135

return sg_dma_len(&iter->chunk->mem[iter->page_idx]);

drivers/infiniband/sw/siw/siw_verbs.c

1503

if (sg_dma_len(slp) == 0) {

drivers/infiniband/sw/siw/siw_verbs.c

1509

pble->size = sg_dma_len(slp);

drivers/infiniband/sw/siw/siw_verbs.c

1516

pble->size += sg_dma_len(slp);

drivers/infiniband/sw/siw/siw_verbs.c

1521

pble->size = sg_dma_len(slp);

drivers/infiniband/sw/siw/siw_verbs.c

1524

pbl_size += sg_dma_len(slp);

drivers/infiniband/ulp/iser/iser_memory.c

139

reg->sge.length = sg_dma_len(&sg[0]);

drivers/infiniband/ulp/rtrs/rtrs-clt.c

1042

sge[i].length = sg_dma_len(sg);

drivers/infiniband/ulp/rtrs/rtrs-srv.c

658

unsigned int dma_len = sg_dma_len(s);

drivers/infiniband/ulp/srp/ib_srp.c

1446

sg_dma_len(state->sg) - sg_offset,

drivers/infiniband/ulp/srp/ib_srp.c

1537

srp_map_desc(state, sg_dma_address(sg), sg_dma_len(sg),

drivers/infiniband/ulp/srp/ib_srp.c

1676

sge[i].length = sg_dma_len(sg);

drivers/infiniband/ulp/srp/ib_srp.c

1699

buf->len = cpu_to_be32(sg_dma_len(scat));

drivers/iommu/dma-iommu.c

1273

unsigned int s_length = sg_dma_len(s);

drivers/iommu/dma-iommu.c

1277

sg_dma_len(s) = 0;

drivers/iommu/dma-iommu.c

1285

sg_dma_len(cur) = s_length;

drivers/iommu/dma-iommu.c

1316

sg_dma_len(cur) = cur_len;

drivers/iommu/dma-iommu.c

1340

if (sg_dma_len(s))

drivers/iommu/dma-iommu.c

1341

s->length = sg_dma_len(s);

drivers/iommu/dma-iommu.c

1344

sg_dma_len(s) = 0;

drivers/iommu/dma-iommu.c

1356

sg_dma_len(s), dir, attrs);

drivers/iommu/dma-iommu.c

1372

sg_dma_len(s) = s->length;

drivers/iommu/dma-iommu.c

1445

sg_dma_len(s) = sg->length;

drivers/iommu/dma-iommu.c

1454

sg_dma_len(s) = s_length;

drivers/iommu/dma-iommu.c

1536

if (sg_dma_len(tmp) == 0)

drivers/iommu/dma-iommu.c

1550

if (sg_dma_len(tmp) == 0)

drivers/iommu/dma-iommu.c

1553

end = sg_dma_address(tmp) + sg_dma_len(tmp);

drivers/mailbox/bcm-flexrm-mailbox.c

658

if (sg_dma_len(src_sg) & 0xf)

drivers/mailbox/bcm-flexrm-mailbox.c

660

sg_dma_len(src_sg));

drivers/mailbox/bcm-flexrm-mailbox.c

663

sg_dma_len(src_sg)/16);

drivers/mailbox/bcm-flexrm-mailbox.c

668

dst_target = sg_dma_len(src_sg);

drivers/mailbox/bcm-flexrm-mailbox.c

674

if (sg_dma_len(dst_sg) & 0xf)

drivers/mailbox/bcm-flexrm-mailbox.c

676

sg_dma_len(dst_sg));

drivers/mailbox/bcm-flexrm-mailbox.c

679

sg_dma_len(dst_sg)/16);

drivers/mailbox/bcm-flexrm-mailbox.c

684

if (sg_dma_len(dst_sg) < dst_target)

drivers/mailbox/bcm-flexrm-mailbox.c

685

dst_target -= sg_dma_len(dst_sg);

drivers/mailbox/bcm-pdc-mailbox.c

745

bufcnt = sg_dma_len(sg);

drivers/mailbox/bcm-pdc-mailbox.c

903

bufcnt = sg_dma_len(sg);

drivers/media/common/videobuf2/videobuf2-dma-contig.c

63

expected += sg_dma_len(s);

drivers/media/common/videobuf2/videobuf2-dma-contig.c

64

size += sg_dma_len(s);

drivers/media/pci/bt8xx/bttv-risc.c

176

while (yoffset && yoffset >= sg_dma_len(ysg)) {

drivers/media/pci/bt8xx/bttv-risc.c

177

yoffset -= sg_dma_len(ysg);

drivers/media/pci/bt8xx/bttv-risc.c

183

if (yoffset + ylen > sg_dma_len(ysg))

drivers/media/pci/bt8xx/bttv-risc.c

184

ylen = sg_dma_len(ysg) - yoffset;

drivers/media/pci/bt8xx/bttv-risc.c

186

while (uoffset && uoffset >= sg_dma_len(usg)) {

drivers/media/pci/bt8xx/bttv-risc.c

187

uoffset -= sg_dma_len(usg);

drivers/media/pci/bt8xx/bttv-risc.c

190

while (voffset && voffset >= sg_dma_len(vsg)) {

drivers/media/pci/bt8xx/bttv-risc.c

191

voffset -= sg_dma_len(vsg);

drivers/media/pci/bt8xx/bttv-risc.c

195

if (uoffset + (ylen>>hshift) > sg_dma_len(usg))

drivers/media/pci/bt8xx/bttv-risc.c

196

ylen = (sg_dma_len(usg) - uoffset) << hshift;

drivers/media/pci/bt8xx/bttv-risc.c

197

if (voffset + (ylen>>hshift) > sg_dma_len(vsg))

drivers/media/pci/bt8xx/bttv-risc.c

198

ylen = (sg_dma_len(vsg) - voffset) << hshift;

drivers/media/pci/bt8xx/bttv-risc.c

73

while (offset && offset >= sg_dma_len(sg)) {

drivers/media/pci/bt8xx/bttv-risc.c

74

offset -= sg_dma_len(sg);

drivers/media/pci/bt8xx/bttv-risc.c

77

if (bpl <= sg_dma_len(sg)-offset) {

drivers/media/pci/bt8xx/bttv-risc.c

87

(sg_dma_len(sg)-offset));

drivers/media/pci/bt8xx/bttv-risc.c

89

todo -= (sg_dma_len(sg)-offset);

drivers/media/pci/bt8xx/bttv-risc.c

92

while (todo > sg_dma_len(sg)) {

drivers/media/pci/bt8xx/bttv-risc.c

94

sg_dma_len(sg));

drivers/media/pci/bt8xx/bttv-risc.c

96

todo -= sg_dma_len(sg);

drivers/media/pci/cobalt/cobalt-omnitek.c

193

bytes = min(sg_dma_len(scatter_list) - offset,

drivers/media/pci/cobalt/cobalt-omnitek.c

236

bytes = min(sg_dma_len(scatter_list) - offset,

drivers/media/pci/cobalt/cobalt-omnitek.c

241

if (sg_dma_len(scatter_list) == offset) {

drivers/media/pci/cx23885/cx23885-core.c

1153

while (offset && offset >= sg_dma_len(sg)) {

drivers/media/pci/cx23885/cx23885-core.c

1154

offset -= sg_dma_len(sg);

drivers/media/pci/cx23885/cx23885-core.c

1163

if (bpl <= sg_dma_len(sg)-offset) {

drivers/media/pci/cx23885/cx23885-core.c

1173

(sg_dma_len(sg)-offset));

drivers/media/pci/cx23885/cx23885-core.c

1176

todo -= (sg_dma_len(sg)-offset);

drivers/media/pci/cx23885/cx23885-core.c

1179

while (todo > sg_dma_len(sg)) {

drivers/media/pci/cx23885/cx23885-core.c

1181

sg_dma_len(sg));

drivers/media/pci/cx23885/cx23885-core.c

1184

todo -= sg_dma_len(sg);

drivers/media/pci/cx25821/cx25821-core.c

1010

while (offset && offset >= sg_dma_len(sg)) {

drivers/media/pci/cx25821/cx25821-core.c

1011

offset -= sg_dma_len(sg);

drivers/media/pci/cx25821/cx25821-core.c

1014

if (bpl <= sg_dma_len(sg) - offset) {

drivers/media/pci/cx25821/cx25821-core.c

1025

(sg_dma_len(sg) - offset));

drivers/media/pci/cx25821/cx25821-core.c

1028

todo -= (sg_dma_len(sg) - offset);

drivers/media/pci/cx25821/cx25821-core.c

1031

while (todo > sg_dma_len(sg)) {

drivers/media/pci/cx25821/cx25821-core.c

1033

sg_dma_len(sg));

drivers/media/pci/cx25821/cx25821-core.c

1036

todo -= sg_dma_len(sg);

drivers/media/pci/cx25821/cx25821-core.c

1115

while (offset && offset >= sg_dma_len(sg)) {

drivers/media/pci/cx25821/cx25821-core.c

1116

offset -= sg_dma_len(sg);

drivers/media/pci/cx25821/cx25821-core.c

1125

if (bpl <= sg_dma_len(sg) - offset) {

drivers/media/pci/cx25821/cx25821-core.c

1136

(sg_dma_len(sg) - offset));

drivers/media/pci/cx25821/cx25821-core.c

1139

todo -= (sg_dma_len(sg) - offset);

drivers/media/pci/cx25821/cx25821-core.c

1142

while (todo > sg_dma_len(sg)) {

drivers/media/pci/cx25821/cx25821-core.c

1144

sg_dma_len(sg));

drivers/media/pci/cx25821/cx25821-core.c

1147

todo -= sg_dma_len(sg);

drivers/media/pci/cx88/cx88-core.c

108

(sg_dma_len(sg) - offset));

drivers/media/pci/cx88/cx88-core.c

110

todo -= (sg_dma_len(sg) - offset);

drivers/media/pci/cx88/cx88-core.c

113

while (todo > sg_dma_len(sg)) {

drivers/media/pci/cx88/cx88-core.c

115

sg_dma_len(sg));

drivers/media/pci/cx88/cx88-core.c

117

todo -= sg_dma_len(sg);

drivers/media/pci/cx88/cx88-core.c

90

while (offset && offset >= sg_dma_len(sg)) {

drivers/media/pci/cx88/cx88-core.c

91

offset -= sg_dma_len(sg);

drivers/media/pci/cx88/cx88-core.c

98

if (bpl <= sg_dma_len(sg) - offset) {

drivers/media/pci/intel/ipu6/ipu6-dma.c

356

&sg_dma_address(sg), sg_dma_len(sg));

drivers/media/pci/intel/ipu6/ipu6-dma.c

395

npages += PFN_UP(sg_dma_len(sg));

drivers/media/pci/intel/ipu6/ipu6-dma.c

415

i, &iova_pa, &sg_dma_address(sg), sg_dma_len(sg));

drivers/media/pci/intel/ipu6/ipu6-dma.c

419

PAGE_ALIGN(sg_dma_len(sg)));

drivers/media/pci/intel/ipu6/ipu6-dma.c

425

iova_addr += PFN_UP(sg_dma_len(sg));

drivers/media/pci/ivtv/ivtv-udma.c

68

dma->SGarray[i].size = cpu_to_le32(sg_dma_len(sg));

drivers/media/pci/ivtv/ivtv-udma.c

71

buffer_offset += sg_dma_len(sg);

drivers/media/pci/ivtv/ivtv-udma.c

73

split -= sg_dma_len(sg);

drivers/media/pci/saa7134/saa7134-core.c

243

for (p = 0; p * 4096 < sg_dma_len(list); p++, ptr++)

drivers/media/pci/solo6x10/solo6x10-v4l2-enc.c

330

len = sg_dma_len(sg);

drivers/media/pci/tw68/tw68-risc.c

57

while (offset && offset >= sg_dma_len(sg)) {

drivers/media/pci/tw68/tw68-risc.c

58

offset -= sg_dma_len(sg);

drivers/media/pci/tw68/tw68-risc.c

61

if (bpl <= sg_dma_len(sg) - offset) {

drivers/media/pci/tw68/tw68-risc.c

76

done = (sg_dma_len(sg) - offset);

drivers/media/pci/tw68/tw68-risc.c

84

while (todo > sg_dma_len(sg)) {

drivers/media/pci/tw68/tw68-risc.c

87

sg_dma_len(sg));

drivers/media/pci/tw68/tw68-risc.c

89

todo -= sg_dma_len(sg);

drivers/media/pci/tw68/tw68-risc.c

91

done += sg_dma_len(sg);

drivers/media/pci/tw686x/tw686x-video.c

199

len = sg_dma_len(sg);

drivers/media/platform/marvell/mcam-core.c

1247

desc->segment_len = sg_dma_len(sg);

drivers/media/platform/st/stm32/stm32-dcmi.c

562

sg_dma_len(sg) = bytes;

drivers/memstick/host/jmb38x_ms.c

424

data_len = sg_dma_len(&host->req->sg);

drivers/memstick/host/r592.c

296

if (sg_count != 1 || sg_dma_len(&dev->req->sg) < R592_LFIFO_SIZE) {

drivers/memstick/host/tifm_ms.c

286

data_len = sg_dma_len(&host->req->sg);

drivers/message/fusion/mptsas.c

2307

flagsLength |= (sg_dma_len(job->request_payload.sg_list) - 4);

drivers/message/fusion/mptsas.c

2323

flagsLength |= sg_dma_len(job->reply_payload.sg_list) + 4;

drivers/message/fusion/mptscsih.c

236

thisxfer = sg_dma_len(sg);

drivers/message/fusion/mptscsih.c

264

thisxfer = sg_dma_len(sg);

drivers/misc/cardreader/rtsx_pcr.c

470

len = sg_dma_len(sg);

drivers/misc/fastrpc.c

823

map->size += sg_dma_len(sgl);

drivers/misc/mei/bus.c

983

sg_len = min_t(unsigned int, sg_dma_len(sg), PAGE_SIZE);

drivers/misc/mei/bus.c

992

sg_len = min_t(unsigned int, sg_dma_len(sg), PAGE_SIZE);

drivers/mmc/host/alcor.c

136

if (!sg_dma_len(host->sg)) {

drivers/mmc/host/atmel-mci.c

889

buf_size = sg_dma_len(host->sg);

drivers/mmc/host/atmel-mci.c

905

atmci_writel(host, counter_reg, sg_dma_len(host->sg) / 4);

drivers/mmc/host/atmel-mci.c

906

host->data_size -= sg_dma_len(host->sg);

drivers/mmc/host/au1xmmc.c

453

sg_len = sg_dma_len(&data->sg[host->pio.index]) - host->pio.offset;

drivers/mmc/host/cavium.c

533

(sg_dma_len(&data->sg[0]) / 8) - 1);

drivers/mmc/host/cavium.c

541

(rw) ? "W" : "R", sg_dma_len(&data->sg[0]), count);

drivers/mmc/host/cavium.c

591

sg_dma_len(sg) / 8 - 1);

drivers/mmc/host/cavium.c

598

(rw) ? "W" : "R", sg_dma_len(sg), i, count);

drivers/mmc/host/cqhci-core.c

527

len = sg_dma_len(sg);

drivers/mmc/host/davinci_mmc.c

461

if (sg_dma_len(data->sg + i) & mask) {

drivers/mmc/host/dw_mmc.c

590

unsigned int length = sg_dma_len(&data->sg[i]);

drivers/mmc/host/dw_mmc.c

662

unsigned int length = sg_dma_len(&data->sg[i]);

drivers/mmc/host/litex_mmc.c

309

*len = sg_dma_len(data->sg);

drivers/mmc/host/loongson2-mmc.c

632

for (j = 0; j < (sg_dma_len(&sg[i]) / 4); j++)

drivers/mmc/host/loongson2-mmc.c

765

for (j = 0; j < (sg_dma_len(&sg[i]) / 4); j++)

drivers/mmc/host/loongson2-mmc.c

805

pdes[i].len = sg_dma_len(&sg[i]) / 4;

drivers/mmc/host/meson-gx-mmc.c

723

unsigned int len = sg_dma_len(sg);

drivers/mmc/host/mmci_stm32_sdmmc.c

252

desc[i].idmasize = sg_dma_len(sg);

drivers/mmc/host/mtk-sd.c

805

dma_len = sg_dma_len(sg);

drivers/mmc/host/sdhci.c

776

len = sg_dma_len(sg);

drivers/mmc/host/sunplus-mmc.c

446

dma_size = sg_dma_len(sg) / data->blksz - 1;

drivers/mmc/host/tifm_sd.c

279

dma_len = sg_dma_len(&r_data->sg[host->sg_pos]) - host->block_pos;

drivers/mmc/host/tifm_sd.c

285

dma_len = sg_dma_len(&r_data->sg[host->sg_pos]);

drivers/mmc/host/usdhi6rol0.c

1724

sg_dma_len(sg), sg->offset);

drivers/mmc/host/usdhi6rol0.c

363

if (WARN(sg_dma_len(sg) % data->blksz,

drivers/mmc/host/usdhi6rol0.c

365

sg_dma_len(sg), data->blksz))

drivers/mmc/host/usdhi6rol0.c

418

if (!force && sg_dma_len(sg) + sg->offset >

drivers/mmc/host/usdhi6rol0.c

464

total = host->sg->offset + sg_dma_len(host->sg);

drivers/mmc/host/usdhi6rol0.c

495

if (WARN(next && sg_dma_len(next) % data->blksz,

drivers/mmc/host/usdhi6rol0.c

497

sg_dma_len(next), data->blksz))

drivers/mmc/host/via-sdmmc.c

498

via_set_ddma(host, sg_dma_address(data->sg), sg_dma_len(data->sg),

drivers/mmc/host/wmt-sdmmc.c

637

while (offset < sg_dma_len(sg)) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c

909

sg_dma_len(sg) = nfc->dma_ecc_len;

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c

959

dpaa2_sg_set_len(&sgt[i], sg_dma_len(crt_scl));

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

2262

sg_dma_len(sgt->sgl + i));

drivers/net/ethernet/intel/ixgbe/ixgbe_fcoe.c

208

len = sg_dma_len(sg);

drivers/net/ethernet/mellanox/mlx4/icm.c

346

len = sg_dma_len(&chunk->sg[i]);

drivers/net/ethernet/mellanox/mlx4/icm.h

138

return sg_dma_len(&iter->chunk->sg[iter->page_idx]);

drivers/net/ethernet/micrel/ks8842.c

433

sg_dma_len(&ctl->sg) = skb->len + sizeof(u32);

drivers/net/ethernet/micrel/ks8842.c

444

sg_dma_address(&ctl->sg), 0, sg_dma_len(&ctl->sg),

drivers/net/ethernet/micrel/ks8842.c

448

if (sg_dma_len(&ctl->sg) % 4)

drivers/net/ethernet/micrel/ks8842.c

449

sg_dma_len(&ctl->sg) += 4 - sg_dma_len(&ctl->sg) % 4;

drivers/net/ethernet/micrel/ks8842.c

560

sg_dma_len(sg) = DMA_BUFFER_SIZE;

drivers/net/ethernet/xilinx/xilinx_axienet_main.c

1489

sg_dma_len(skbuf_dma->sgl) = lp->max_frm_size;

drivers/net/ipa/gsi_trans.c

432

sg_dma_len(sg) = size;

drivers/net/ipa/gsi_trans.c

571

u32 len = sg_dma_len(sg);

drivers/net/virtio_net.c

582

sg_dma_len(sg) = len;

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/tx.c

1836

offset + len <= sg_offset + sg_dma_len(sg))

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/tx.c

1839

sg_offset += sg_dma_len(sg);

drivers/nvme/host/apple.c

420

sg_dma_len(sg));

drivers/nvme/host/apple.c

432

int dma_len = sg_dma_len(sg);

drivers/nvme/host/apple.c

452

dma_len = sg_dma_len(sg);

drivers/nvme/host/apple.c

502

dma_len = sg_dma_len(sg);

drivers/nvme/host/rdma.c

1276

sge->length = sg_dma_len(sgl);

drivers/nvme/host/rdma.c

1296

put_unaligned_le24(sg_dma_len(req->data_sgl.sg_table.sgl), sg->length);

drivers/nvme/target/fc.c

2276

tlen + sg_dma_len(sg) < NVMET_FC_MAX_SEQ_LENGTH) {

drivers/nvme/target/fc.c

2278

tlen += sg_dma_len(sg);

drivers/nvme/target/fc.c

2283

tlen += min_t(u32, sg_dma_len(sg), remaininglen);

drivers/parisc/ccio-dma.c

1004

while (nents && sg_dma_len(sglist)) {

drivers/parisc/ccio-dma.c

1007

ioc->usg_pages += sg_dma_len(sglist) >> PAGE_SHIFT;

drivers/parisc/ccio-dma.c

1010

sg_dma_len(sglist), direction, 0);

drivers/parisc/ccio-dma.c

927

sg_dma_len(sglist) = sglist->length;

drivers/parisc/ccio-dma.c

967

current_len += sg_dma_len(sglist + i);

drivers/parisc/iommu-helpers.h

125

sg_dma_len(startsg) = 0;

drivers/parisc/iommu-helpers.h

142

sg_dma_len(startsg) = 0;

drivers/parisc/iommu-helpers.h

171

sg_dma_len(contig_sg) = dma_len;

drivers/parisc/iommu-helpers.h

47

BUG_ON(pdirp && (dma_len != sg_dma_len(dma_sg)));

drivers/parisc/iommu-helpers.h

51

dma_len = sg_dma_len(startsg);

drivers/parisc/iommu-helpers.h

52

sg_dma_len(startsg) = 0;

drivers/parisc/iommu-helpers.h

71

sg_dma_len(dma_sg) += startsg->length;

drivers/parisc/sba_iommu.c

1060

while (nents && sg_dma_len(sglist)) {

drivers/parisc/sba_iommu.c

1062

sba_unmap_phys(dev, sg_dma_address(sglist), sg_dma_len(sglist),

drivers/parisc/sba_iommu.c

1065

ioc->usg_pages += ((sg_dma_address(sglist) & ~IOVP_MASK) + sg_dma_len(sglist) + IOVP_SIZE - 1) >> PAGE_SHIFT;

drivers/parisc/sba_iommu.c

284

sg_dma_len(startsg),

drivers/parisc/sba_iommu.c

965

sg_dma_len(sglist) = sglist->length;

drivers/platform/raspberrypi/vchiq-interface/vchiq_core.c

1642

unsigned int len = sg_dma_len(sg);

drivers/rapidio/devices/tsi721_dma.c

459

(unsigned long long)sg_dma_address(sg), sg_dma_len(sg));

drivers/rapidio/devices/tsi721_dma.c

461

if (sg_dma_len(sg) > TSI721_BDMA_MAX_BCOUNT) {

drivers/rapidio/devices/tsi721_dma.c

473

bcount + sg_dma_len(sg) <= TSI721_BDMA_MAX_BCOUNT) {

drivers/rapidio/devices/tsi721_dma.c

475

bcount += sg_dma_len(sg);

drivers/rapidio/devices/tsi721_dma.c

506

bcount = sg_dma_len(sg);

drivers/rapidio/devices/tsi721_dma.c

523

rio_addr += sg_dma_len(sg);

drivers/rapidio/devices/tsi721_dma.c

524

next_addr += sg_dma_len(sg);

drivers/scsi/3w-9xxx.c

1860

command_packet->sg_list[i].length = cpu_to_le32(sg_dma_len(sg));

drivers/scsi/3w-sas.c

343

command_packet->sg_list[i].length = TW_CPU_TO_SGL(sg_dma_len(sg));

drivers/scsi/3w-xxxx.c

1761

command_packet->byte8.io.sgl[i].length = sg_dma_len(sg);

drivers/scsi/53c700.c

1884

count = sg_dma_len(sg);

drivers/scsi/BusLogic.c

2948

ccb->sglist[i].segbytes = sg_dma_len(sg);

drivers/scsi/a100u2w.c

876

sgent->length = cpu_to_le32((u32) sg_dma_len(sg));

drivers/scsi/aacraid/aachba.c

3812

psg->sg[i].count = cpu_to_le32(sg_dma_len(sg));

drivers/scsi/aacraid/aachba.c

3813

byte_count += sg_dma_len(sg);

drivers/scsi/aacraid/aachba.c

3851

int count = sg_dma_len(sg);

drivers/scsi/aacraid/aachba.c

3896

int count = sg_dma_len(sg);

drivers/scsi/aacraid/aachba.c

3937

int count = sg_dma_len(sg);

drivers/scsi/aacraid/aachba.c

4063

int count = sg_dma_len(sg);

drivers/scsi/advansys.c

7513

cpu_to_le32(sg_dma_len(slp));

drivers/scsi/advansys.c

7515

DIV_ROUND_UP(sg_dma_len(slp), 512));

drivers/scsi/advansys.c

7615

cpu_to_le32(sg_dma_len(slp));

drivers/scsi/advansys.c

7617

DIV_ROUND_UP(sg_dma_len(slp), 512));

drivers/scsi/aha1740.c

415

cptr[i].datalen = sg_dma_len (sg);

drivers/scsi/aic7xxx/aic79xx_osm.c

1631

len = sg_dma_len(cur_seg);

drivers/scsi/aic7xxx/aic7xxx_osm.c

1527

len = sg_dma_len(cur_seg);

drivers/scsi/aic94xx/aic94xx_task.c

106

sg_arr[i].size = cpu_to_le32((u32)sg_dma_len(sc));

drivers/scsi/aic94xx/aic94xx_task.c

432

cpu_to_le32((u32)sg_dma_len(&task->smp_task.smp_req)-4);

drivers/scsi/aic94xx/aic94xx_task.c

437

cpu_to_le32((u32)sg_dma_len(&task->smp_task.smp_resp)-4);

drivers/scsi/aic94xx/aic94xx_task.c

86

sg->size = cpu_to_le32((u32)sg_dma_len(sc));

drivers/scsi/aic94xx/aic94xx_task.c

94

sg_arr[i].size = cpu_to_le32((u32)sg_dma_len(sc));

drivers/scsi/arcmsr/arcmsr_hba.c

1868

length = cpu_to_le32(sg_dma_len(sg));

drivers/scsi/atp870u.c

887

l=sg_dma_len(sgpnt);

drivers/scsi/be2iscsi/be_main.c

2109

sg_len = sg_dma_len(sg);

drivers/scsi/be2iscsi/be_main.c

2124

sg_len = sg_dma_len(sg);

drivers/scsi/be2iscsi/be_main.c

2169

sg_len = sg_dma_len(sg);

drivers/scsi/be2iscsi/be_main.c

2204

sg_len = sg_dma_len(sg);

drivers/scsi/be2iscsi/be_main.c

2216

sg_len = sg_dma_len(sg);

drivers/scsi/be2iscsi/be_main.c

2257

sg_len = sg_dma_len(sg);

drivers/scsi/bfa/bfa_fcpim.c

2435

pgdlen = sg_dma_len(sg);

drivers/scsi/bfa/bfa_fcpim.c

2447

sgpge->sg_len = sg_dma_len(sg);

drivers/scsi/bnx2fc/bnx2fc_io.c

1672

sg_len = sg_dma_len(sg);

drivers/scsi/bnx2i/bnx2i_iscsi.c

160

sg_len = sg_dma_len(sg);

drivers/scsi/csiostor/csio_scsi.c

308

sgl->len0 = cpu_to_be32(sg_dma_len(sgel));

drivers/scsi/csiostor/csio_scsi.c

316

sg_dma_len(sgel));

drivers/scsi/csiostor/csio_scsi.c

322

sg_dma_len(sgel));

drivers/scsi/csiostor/csio_scsi.c

571

sg_len = sg_dma_len(sgel);

drivers/scsi/cxgbi/libcxgbi.c

1168

len = sg_dma_len(sg);

drivers/scsi/cxgbi/libcxgbi.c

1180

len = sg_dma_len(sg);

drivers/scsi/cxgbi/libcxgbi.c

1202

len = sg_dma_len(sg);

drivers/scsi/elx/efct/efct_lio.c

450

sgl[cnt].len = sg_dma_len(sg);

drivers/scsi/elx/efct/efct_lio.c

502

if (ocp->transferred_len + sg_dma_len(sg) >= cmd->data_length)

drivers/scsi/elx/efct/efct_lio.c

505

sgl[cnt].len = sg_dma_len(sg);

drivers/scsi/esas2r/esas2r_main.c

780

len = sg_dma_len(sgc->cur_sgel);

drivers/scsi/esas2r/esas2r_main.c

795

len = sg_dma_len(sgc->cur_sgel);

drivers/scsi/esp_scsi.c

1650

if (spriv->cur_residue == sg_dma_len(spriv->cur_sg)) {

drivers/scsi/esp_scsi.c

391

total += sg_dma_len(s);

drivers/scsi/esp_scsi.c

396

total += sg_dma_len(s);

drivers/scsi/esp_scsi.c

398

spriv->cur_residue = sg_dma_len(sg);

drivers/scsi/esp_scsi.c

415

(sg_dma_len(p->cur_sg) -

drivers/scsi/esp_scsi.c

455

p->cur_residue = sg_dma_len(p->cur_sg);

drivers/scsi/fnic/fnic_scsi.c

382

desc->len = cpu_to_le32(sg_dma_len(sg));

drivers/scsi/hisi_sas/hisi_sas_main.c

353

req_len = sg_dma_len(&task->smp_task.smp_req);

drivers/scsi/hisi_sas/hisi_sas_v1_hw.c

904

entry->data_len = cpu_to_le32(sg_dma_len(sg));

drivers/scsi/hisi_sas/hisi_sas_v1_hw.c

927

req_len = sg_dma_len(sg_req);

drivers/scsi/hisi_sas/hisi_sas_v2_hw.c

1686

entry->data_len = cpu_to_le32(sg_dma_len(sg));

drivers/scsi/hisi_sas/hisi_sas_v2_hw.c

1710

req_len = sg_dma_len(&task->smp_task.smp_req);

drivers/scsi/hisi_sas/hisi_sas_v3_hw.c

1204

entry->data_len = cpu_to_le32(sg_dma_len(sg));

drivers/scsi/hisi_sas/hisi_sas_v3_hw.c

1231

entry->data_len = cpu_to_le32(sg_dma_len(sg));

drivers/scsi/hisi_sas/hisi_sas_v3_hw.c

1447

req_len = sg_dma_len(sg_req);

drivers/scsi/hpsa.c

4549

unsigned int len = sg_dma_len(sg);

drivers/scsi/hpsa.c

4767

len = sg_dma_len(sg);

drivers/scsi/hpsa.c

4954

len = sg_dma_len(sg);

drivers/scsi/hptiop.c

866

psg[idx].size = cpu_to_le32(sg_dma_len(sg));

drivers/scsi/ibmvscsi/ibmvfc.c

1619

md[i].len = cpu_to_be32(sg_dma_len(sg));

drivers/scsi/ibmvscsi/ibmvfc.c

2291

mad->iu.cmd.len = cpu_to_be32(sg_dma_len(job->request_payload.sg_list));

drivers/scsi/ibmvscsi/ibmvfc.c

2293

mad->iu.rsp.len = cpu_to_be32(sg_dma_len(job->reply_payload.sg_list));

drivers/scsi/ibmvscsi/ibmvscsi.c

663

descr->len = cpu_to_be32(sg_dma_len(sg));

drivers/scsi/ibmvscsi/ibmvscsi.c

665

total_length += sg_dma_len(sg);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3227

server_len = sg_dma_len(sgp);

drivers/scsi/ibmvscsi_tgt/libsrp.c

230

sg_dma_len(&dummy) = be32_to_cpu(id->table_desc.len);

drivers/scsi/initio.c

2588

sg->len = cpu_to_le32((u32)sg_dma_len(sglist));

drivers/scsi/initio.c

2589

total_len += sg_dma_len(sglist);

drivers/scsi/ipr.c

3885

ioadl64[i].data_len = cpu_to_be32(sg_dma_len(sg));

drivers/scsi/ipr.c

3918

cpu_to_be32(IPR_IOADL_FLAGS_WRITE | sg_dma_len(sg));

drivers/scsi/ipr.c

5653

ioadl64[i].data_len = cpu_to_be32(sg_dma_len(sg));

drivers/scsi/ipr.c

5714

cpu_to_be32(ioadl_flags | sg_dma_len(sg));

drivers/scsi/ips.c

2657

sg_dma_len(sg)) < 0)

drivers/scsi/ips.c

3160

sg_dma_len(sg));

drivers/scsi/ips.c

3168

sg_dma_len(sg)) < 0)

drivers/scsi/isci/request.c

107

e->length = sg_dma_len(sg);

drivers/scsi/isci/request.c

1422

copy_len = min_t(int, total_len, sg_dma_len(sg));

drivers/scsi/libsas/sas_ata.c

197

xfer += sg_dma_len(sg);

drivers/scsi/lpfc/lpfc_nvme.c

1437

dma_len = sg_dma_len(data_sg);

drivers/scsi/lpfc/lpfc_nvmet.c

2800

wqe->fcp_tsend.bde.tus.f.bdeSize = sg_dma_len(sgel);

drivers/scsi/lpfc/lpfc_nvmet.c

3011

cnt = sg_dma_len(sgel);

drivers/scsi/lpfc/lpfc_scsi.c

1625

bpl->tus.f.bdeSize = sg_dma_len(sgde);

drivers/scsi/lpfc/lpfc_scsi.c

1784

protgroup_len = sg_dma_len(sgpe) - protgroup_offset;

drivers/scsi/lpfc/lpfc_scsi.c

1831

remainder = sg_dma_len(sgde) - split_offset;

drivers/scsi/lpfc/lpfc_scsi.c

2033

dma_len = sg_dma_len(sgde);

drivers/scsi/lpfc/lpfc_scsi.c

2245

protgroup_len = sg_dma_len(sgpe) - protgroup_offset;

drivers/scsi/lpfc/lpfc_scsi.c

2322

remainder = sg_dma_len(sgde) - split_offset;

drivers/scsi/lpfc/lpfc_scsi.c

2733

data_len = sg_dma_len(sgde);

drivers/scsi/lpfc/lpfc_scsi.c

2740

len = sg_dma_len(sgpe);

drivers/scsi/lpfc/lpfc_scsi.c

2805

data_len = sg_dma_len(sgde);

drivers/scsi/lpfc/lpfc_scsi.c

2815

len = sg_dma_len(sgpe);

drivers/scsi/lpfc/lpfc_scsi.c

3159

dma_len = sg_dma_len(sgel);

drivers/scsi/lpfc/lpfc_scsi.c

873

data_bde->tus.f.bdeSize = sg_dma_len(sgel);

drivers/scsi/lpfc/lpfc_scsi.c

879

bpl->tus.f.bdeSize = sg_dma_len(sgel);

drivers/scsi/lpfc/lpfc_scsi.c

993

numblks = sg_dma_len(sgpe) /

drivers/scsi/mac53c94.c

378

dma_len = sg_dma_len(scl);

drivers/scsi/megaraid.c

1736

*len = sg_dma_len(sg);

drivers/scsi/megaraid.c

1743

*len += scb->sgl64[idx].length = sg_dma_len(sg);

drivers/scsi/megaraid.c

1746

*len += scb->sgl[idx].length = sg_dma_len(sg);

drivers/scsi/megaraid/megaraid_mbox.c

1362

ccb->sgl64[i].length = sg_dma_len(sgl);

drivers/scsi/megaraid/megaraid_sas_base.c

1273

mfi_sgl->sge32[i].length = cpu_to_le32(sg_dma_len(os_sgl));

drivers/scsi/megaraid/megaraid_sas_base.c

1302

mfi_sgl->sge64[i].length = cpu_to_le32(sg_dma_len(os_sgl));

drivers/scsi/megaraid/megaraid_sas_base.c

1331

cpu_to_le32(sg_dma_len(os_sgl));

drivers/scsi/megaraid/megaraid_sas_fusion.c

2127

if (sg_dma_len(sg_scmd) < (data_length - (mr_nvme_pg_size * 4)))

drivers/scsi/megaraid/megaraid_sas_fusion.c

2201

sge_len = sg_dma_len(sg_scmd);

drivers/scsi/megaraid/megaraid_sas_fusion.c

2217

sge_len = sg_dma_len(sg_scmd);

drivers/scsi/megaraid/megaraid_sas_fusion.c

2252

sge_len = sg_dma_len(sg_scmd);

drivers/scsi/megaraid/megaraid_sas_fusion.c

2289

sgl_ptr->Length = cpu_to_le32(sg_dma_len(os_sgl));

drivers/scsi/mesh.c

1278

u32 dma_len = sg_dma_len(scl);

drivers/scsi/mpi3mr/mpi3mr_os.c

3783

sg_dma_len(sg_scmd), sg_dma_address(sg_scmd));

drivers/scsi/mpi3mr/mpi3mr_os.c

3813

simple_sgl_flags_last, sg_dma_len(sg_scmd),

drivers/scsi/mpi3mr/mpi3mr_os.c

3817

sg_dma_len(sg_scmd), sg_dma_address(sg_scmd));

drivers/scsi/mpi3mr/mpi3mr_transport.c

3215

*dma_len = sg_dma_len(buf->sg_list);

drivers/scsi/mpt3sas/mpt3sas_base.c

2518

sge_len = sg_dma_len(sg_scmd);

drivers/scsi/mpt3sas/mpt3sas_base.c

2534

sge_len = sg_dma_len(sg_scmd);

drivers/scsi/mpt3sas/mpt3sas_base.c

2569

sge_len = sg_dma_len(sg_scmd);

drivers/scsi/mpt3sas/mpt3sas_base.c

2763

sgl_flags_last_element | sg_dma_len(sg_scmd),

drivers/scsi/mpt3sas/mpt3sas_base.c

2767

sg_dma_len(sg_scmd), sg_dma_address(sg_scmd));

drivers/scsi/mpt3sas/mpt3sas_base.c

2804

sg_dma_len(sg_scmd),

drivers/scsi/mpt3sas/mpt3sas_base.c

2808

sg_dma_len(sg_scmd),

drivers/scsi/mpt3sas/mpt3sas_base.c

2830

sg_dma_len(sg_scmd), sg_dma_address(sg_scmd));

drivers/scsi/mpt3sas/mpt3sas_base.c

2833

sg_dma_len(sg_scmd), sg_dma_address(sg_scmd));

drivers/scsi/mpt3sas/mpt3sas_base.c

2907

sg_dma_len(sg_scmd), sg_dma_address(sg_scmd));

drivers/scsi/mpt3sas/mpt3sas_base.c

2939

sg_dma_len(sg_scmd), sg_dma_address(sg_scmd));

drivers/scsi/mpt3sas/mpt3sas_base.c

2960

simple_sgl_flags_last, 0, sg_dma_len(sg_scmd),

drivers/scsi/mpt3sas/mpt3sas_base.c

2964

sg_dma_len(sg_scmd), sg_dma_address(sg_scmd));

drivers/scsi/mpt3sas/mpt3sas_transport.c

2020

*dma_len = sg_dma_len(buf->sg_list);

drivers/scsi/mvsas/mv_64xx.c

558

buf_prd->len = cpu_to_le32(sg_dma_len(sg));

drivers/scsi/mvsas/mv_94xx.c

792

im_len.len = sg_dma_len(sg);

drivers/scsi/mvsas/mv_sas.c

1605

sg_dma_len(sg_resp));

drivers/scsi/mvsas/mv_sas.c

315

req_len = sg_dma_len(sg_req);

drivers/scsi/mvumi.c

213

sgd_setsz(mhba, m_sg, cpu_to_le32(sg_dma_len(sg)));

drivers/scsi/myrb.c

1321

if (sg_dma_len(sgl) > USHRT_MAX) {

drivers/scsi/myrb.c

1322

dcdb->xfer_len_lo = sg_dma_len(sgl) & 0xffff;

drivers/scsi/myrb.c

1323

dcdb->xfer_len_hi4 = sg_dma_len(sgl) >> 16;

drivers/scsi/myrb.c

1325

dcdb->xfer_len_lo = sg_dma_len(sgl);

drivers/scsi/myrb.c

1594

hw_sgl->sge_count = (u32)sg_dma_len(sgl);

drivers/scsi/myrs.c

1722

hw_sge->sge[0].sge_count = (u64)sg_dma_len(sgl);

drivers/scsi/myrs.c

1765

hw_sgl->sge_count = (u64)sg_dma_len(sgl);

drivers/scsi/ncr53c8xx.c

7494

unsigned int len = sg_dma_len(sg);

drivers/scsi/nsp32.c

886

sgt[i].len = cpu_to_le32(sg_dma_len(sg));

drivers/scsi/pm8001/pm8001_hwi.c

3897

buf_prd->im_len.len = cpu_to_le32(sg_dma_len(sg));

drivers/scsi/pm8001/pm8001_hwi.c

3935

req_len = sg_dma_len(sg_req);

drivers/scsi/pm8001/pm8001_hwi.c

3943

resp_len = sg_dma_len(sg_resp);

drivers/scsi/pm8001/pm8001_hwi.c

3955

cpu_to_le32((u32)sg_dma_len(&task->smp_task.smp_req)-4);

drivers/scsi/pm8001/pm8001_hwi.c

3959

cpu_to_le32((u32)sg_dma_len(&task->smp_task.smp_resp)-4);

drivers/scsi/pm8001/pm80xx_hwi.c

4191

req_len = sg_dma_len(sg_req);

drivers/scsi/pm8001/pm80xx_hwi.c

4199

resp_len = sg_dma_len(sg_resp);

drivers/scsi/pm8001/pm80xx_hwi.c

4234

cpu_to_le32((u32)sg_dma_len(&task->smp_task.smp_req)-8);

drivers/scsi/pm8001/pm80xx_hwi.c

4239

cpu_to_le32((u32)sg_dma_len

drivers/scsi/pm8001/pm80xx_hwi.c

4246

cpu_to_le32((u32)sg_dma_len(&task->smp_task.smp_req)-4);

drivers/scsi/pm8001/pm80xx_hwi.c

4252

((u32)sg_dma_len(&task->smp_task.smp_resp)-4);

drivers/scsi/pmcraid.c

3222

ioadl[i].data_len = cpu_to_le32(sg_dma_len(sglist));

drivers/scsi/qedf/qedf_io.c

492

sg_len = (u32)sg_dma_len(sg);

drivers/scsi/qedi/qedi_fw.c

1801

if ((sg_count == 1) && (sg_dma_len(sg) <= MAX_SGLEN_FOR_CACHESGL)) {

drivers/scsi/qedi/qedi_fw.c

1802

sg_len = sg_dma_len(sg);

drivers/scsi/qedi/qedi_fw.c

1817

sg_len = sg_dma_len(sg);

drivers/scsi/qla1280.c

2868

*dword_ptr++ = cpu_to_le32(sg_dma_len(s));

drivers/scsi/qla1280.c

2872

cpu_to_le32(sg_dma_len(s)));

drivers/scsi/qla1280.c

2925

cpu_to_le32(sg_dma_len(s));

drivers/scsi/qla1280.c

2929

cpu_to_le32(sg_dma_len(s)));

drivers/scsi/qla1280.c

3122

*dword_ptr++ = cpu_to_le32(sg_dma_len(s));

drivers/scsi/qla1280.c

3125

(sg_dma_len(s)));

drivers/scsi/qla1280.c

3169

cpu_to_le32(sg_dma_len(s));

drivers/scsi/qla1280.c

3174

cpu_to_le32(sg_dma_len(s)));

drivers/scsi/qla2xxx/qla_dsd.h

15

put_unaligned_le32(sg_dma_len(sg), &(*dsd)->length);

drivers/scsi/qla2xxx/qla_dsd.h

28

put_unaligned_le32(sg_dma_len(sg), &(*dsd)->length);

drivers/scsi/qla2xxx/qla_edif.c

3139

cur_dsd->length = cpu_to_le32(sg_dma_len(sg));

drivers/scsi/qla2xxx/qla_iocb.c

1111

u32 sglen = sg_dma_len(sg);

drivers/scsi/qla2xxx/qla_iocb.c

3208

els_iocb->tx_len = cpu_to_le32(sg_dma_len

drivers/scsi/qla2xxx/qla_iocb.c

3213

els_iocb->rx_len = cpu_to_le32(sg_dma_len

drivers/scsi/qla2xxx/qla_iocb.c

807

sg_len = sg_dma_len(sg);

drivers/scsi/qla2xxx/qla_iocb.c

932

if (tot_prot_dma_len == sg_dma_len(sg_prot)) {

drivers/scsi/qla2xxx/qla_isr.c

3106

num_ent = sg_dma_len(sg) / 8;

drivers/scsi/qla4xxx/ql4_iocb.c

187

cur_dsd->count = cpu_to_le32(sg_dma_len(sg));

drivers/scsi/qlogicpti.c

923

ds[i].d_count = sg_dma_len(s);

drivers/scsi/qlogicpti.c

947

ds[i].d_count = sg_dma_len(s);

drivers/scsi/smartpqi/smartpqi_init.c

5359

unsigned int length = sg_dma_len(sg);

drivers/scsi/snic/snic_scsi.c

168

sgd->len = cpu_to_le32(sg_dma_len(sg));

drivers/scsi/stex.c

447

table[i].count = cpu_to_le32((u32)sg_dma_len(sg));

drivers/scsi/stex.c

479

table[i].count = cpu_to_le32((u32)sg_dma_len(sg));

drivers/scsi/storvsc_drv.c

1841

sg_dma_len(sg)) - hvpfn;

drivers/scsi/sym53c8xx_2/sym_glue.c

260

unsigned int len = sg_dma_len(sg);

drivers/scsi/vmw_pvscsi.c

338

sge[i].length = sg_dma_len(sg);

drivers/scsi/wd719x.c

265

scb->sg_list[i].length = cpu_to_le32(sg_dma_len(sg));

drivers/spi/atmel-quadspi.c

825

len = sg_dma_len(sg);

drivers/spi/atmel-quadspi.c

850

len = sg_dma_len(sg);

drivers/spi/spi-amlogic-spisg.c

234

FIELD_PREP(LINK_ADDR_LEN, sg_dma_len(sg));

drivers/spi/spi-bcm2835.c

498

bs->tx_prologue = sg_dma_len(&tfr->tx_sg.sgl[0]) & 3;

drivers/spi/spi-bcm2835.c

501

bs->rx_prologue = sg_dma_len(&tfr->rx_sg.sgl[0]) & 3;

drivers/spi/spi-bcm2835.c

509

!(sg_dma_len(&tfr->tx_sg.sgl[0]) & ~3);

drivers/spi/spi-bcm2835.c

535

sg_dma_len(&tfr->rx_sg.sgl[0]) -= bs->rx_prologue;

drivers/spi/spi-bcm2835.c

558

sg_dma_len(&tfr->tx_sg.sgl[0]) -= bs->tx_prologue;

drivers/spi/spi-bcm2835.c

560

sg_dma_len(&tfr->tx_sg.sgl[0]) = 0;

drivers/spi/spi-bcm2835.c

562

sg_dma_len(&tfr->tx_sg.sgl[1]) -= 4;

drivers/spi/spi-bcm2835.c

583

sg_dma_len(&tfr->rx_sg.sgl[0]) += bs->rx_prologue;

drivers/spi/spi-bcm2835.c

591

sg_dma_len(&tfr->tx_sg.sgl[0]) += bs->tx_prologue;

drivers/spi/spi-bcm2835.c

593

sg_dma_len(&tfr->tx_sg.sgl[0]) = bs->tx_prologue - 4;

drivers/spi/spi-bcm2835.c

595

sg_dma_len(&tfr->tx_sg.sgl[1]) += 4;

drivers/spi/spi-dw-dma.c

585

tx_len = sg_dma_len(tx_sg);

drivers/spi/spi-dw-dma.c

592

rx_len = sg_dma_len(rx_sg);

drivers/spi/spi-dw-dma.c

597

sg_dma_len(&tx_tmp) = len;

drivers/spi/spi-dw-dma.c

598

sg_dma_len(&rx_tmp) = len;

drivers/spi/spi-geni-qcom.c

867

sg_dma_len(xfer->rx_sg.sgl));

drivers/spi/spi-geni-qcom.c

870

sg_dma_len(xfer->tx_sg.sgl));

drivers/spi/spi-mt65xx.c

724

mdata->tx_sgl_len = sg_dma_len(mdata->tx_sgl);

drivers/spi/spi-mt65xx.c

728

mdata->rx_sgl_len = sg_dma_len(mdata->rx_sgl);

drivers/spi/spi-mt65xx.c

852

mdata->tx_sgl_len = sg_dma_len(mdata->tx_sgl);

drivers/spi/spi-mt65xx.c

859

mdata->rx_sgl_len = sg_dma_len(mdata->rx_sgl);

drivers/spi/spi-pci1xxxx.c

569

p->tx_sgl_len = sg_dma_len(p->tx_sgl);

drivers/spi/spi-pci1xxxx.c

670

p->tx_sgl_len = sg_dma_len(p->tx_sgl);

drivers/spi/spi-pci1xxxx.c

685

p->rx_sgl_len = sg_dma_len(p->rx_sgl);

drivers/spi/spi-pic32-sqi.c

305

rdesc->xfer_len = sg_dma_len(sg);

drivers/spi/spi-pl022.c

724

sg_dma_len(sg),

drivers/spi/spi-pl022.c

734

sg_dma_len(sg),

drivers/spi/spi-qcom-qspi.c

360

dma_len_sg = sg_dma_len(sgt->sgl + i);

drivers/spi/spi-qcom-qspi.c

380

dma_len_sg = sg_dma_len(sgt->sgl + i);

drivers/spi/spi-qup.c

456

unsigned int len = sg_dma_len(sg);

drivers/spi/spi-stm32.c

1552

if (sg_dma_len(spi_s) > sram_period)

drivers/spi/spi-stm32.c

1553

nents += DIV_ROUND_UP(sg_dma_len(spi_s), sram_period);

drivers/spi/spi-stm32.c

1563

spi_s_len = sg_dma_len(spi_s);

drivers/spi/spi-stm32.c

1568

sg_dma_len(s) = bytes;

drivers/spi/spi-stm32.c

1574

spi_s_len = sg_dma_len(spi_s);

drivers/spi/spi-stm32.c

1600

spi_s_len = sg_dma_len(spi_s);

drivers/spi/spi-stm32.c

1605

sg_dma_len(s) = bytes;

drivers/spi/spi-stm32.c

1611

spi_s_len = sg_dma_len(spi_s);

drivers/spi/spi-ti-qspi.c

515

len = sg_dma_len(sg);

drivers/spi/spi-topcliff-pch.c

1004

sg_dma_len(sg) = size;

drivers/spi/spi-topcliff-pch.c

1010

sg_dma_len(sg) = size;

drivers/spi/spi-topcliff-pch.c

1060

sg_dma_len(sg) = size + head;

drivers/spi/spi-topcliff-pch.c

1066

sg_dma_len(sg) = rem;

drivers/spi/spi-topcliff-pch.c

1072

sg_dma_len(sg) = size;

drivers/spi/spi-topcliff-pch.c

998

sg_dma_len(sg) = rem;

drivers/staging/media/ipu7/ipu7-dma.c

356

&sg_dma_address(sg), sg_dma_len(sg));

drivers/staging/media/ipu7/ipu7-dma.c

395

npages += PFN_UP(sg_dma_len(sg));

drivers/staging/media/ipu7/ipu7-dma.c

433

i, &iova_pa, &sg_dma_address(sg), sg_dma_len(sg));

drivers/staging/media/ipu7/ipu7-dma.c

437

PAGE_ALIGN(sg_dma_len(sg)));

drivers/staging/media/ipu7/ipu7-dma.c

443

iova_addr += PFN_UP(sg_dma_len(sg));

drivers/target/iscsi/cxgbit/cxgbit_ddp.c

23

len = sg_dma_len(sg);

drivers/target/iscsi/cxgbit/cxgbit_ddp.c

35

len = sg_dma_len(sg);

drivers/tty/serial/8250/8250_dma.c

123

dma->tx_size += sg_dma_len(sg);

drivers/tty/serial/8250/8250_omap.c

1194

dma->tx_size = sg_dma_len(&sg);

drivers/tty/serial/atmel_serial.c

964

sg_dma_len(sg) = part1_len;

drivers/tty/serial/atmel_serial.c

972

sg_dma_len(sg) = part2_len;

drivers/tty/serial/imx.c

1223

rx_ring->head = sg_dma_len(sgl) - state.residue;

drivers/tty/serial/imx.c

1226

bd_size = sg_dma_len(sgl) / sport->rx_periods;

drivers/tty/serial/imx.c

1229

if (rx_ring->head <= sg_dma_len(sgl) &&

drivers/tty/serial/imx.c

1259

WARN_ON(rx_ring->head > sg_dma_len(sgl));

drivers/tty/serial/imx.c

1288

sg_dma_len(sgl), sg_dma_len(sgl) / sport->rx_periods,

drivers/tty/serial/msm_serial.c

258

mapped = sg_dma_len(&dma->tx_sg);

drivers/tty/serial/msm_serial.c

437

if (sg_dma_len(&dma->tx_sg))

drivers/tty/serial/msm_serial.c

465

if (!sg_dma_len(&dma->tx_sg))

drivers/tty/serial/msm_serial.c

481

count = sg_dma_len(&dma->tx_sg) - state.residue;

drivers/tty/serial/pch_uart.c

744

uart_xmit_advance(port, sg_dma_len(sg));

drivers/tty/serial/pch_uart.c

785

sg_dma_len(sg) = priv->trigger_level;

drivers/tty/serial/pch_uart.c

788

sg_dma_len(sg), offset_in_page(priv->rx_buf_virt));

drivers/tty/serial/pch_uart.c

944

sg_dma_len(sg) = rem;

drivers/tty/serial/pch_uart.c

946

sg_dma_len(sg) = size;

drivers/tty/serial/sh-sci.c

1753

read = sg_dma_len(&s->sg_rx[active]) - state.residue;

drivers/tty/serial/sh-sci.c

1875

sg_dma_len(sg) = s->buf_len_rx;

drivers/ufs/core/ufshcd.c

2697

const unsigned int len = sg_dma_len(sg);

drivers/usb/cdns3/cdns3-gadget.c

1241

length = sg_dma_len(s);

drivers/usb/cdns3/cdns3-gadget.c

459

if (length <= sg_dma_len(s)) {

drivers/usb/cdns3/cdnsp-ring.c

1733

len = sg_dma_len(sg);

drivers/usb/cdns3/cdnsp-ring.c

1891

block_len = sg_dma_len(sg);

drivers/usb/cdns3/cdnsp-ring.c

2015

block_len = sg_dma_len(sg);

drivers/usb/cdns3/cdnsp-ring.c

2246

block_len = sg_dma_len(sg);

drivers/usb/cdns3/cdnsp-ring.c

2340

block_len = sg_dma_len(sg);

drivers/usb/chipidea/udc.c

471

unsigned int rest = sg_dma_len(s);

drivers/usb/chipidea/udc.c

496

token = le32_to_cpu(node->ptr->token) + (sg_dma_len(s) << __ffs(TD_TOTAL_BYTES));

drivers/usb/chipidea/udc.c

526

if (node && (node->td_remaining_size >= sg_dma_len(s))) {

drivers/usb/chipidea/udc.c

528

node->td_remaining_size -= sg_dma_len(s);

drivers/usb/chipidea/udc.c

652

sg_copy_from_buffer(dst, nents, buf, sg_dma_len(src));

drivers/usb/chipidea/udc.c

705

sg_dma_len(sg) = min(sg_dma_len(sg), bounced_size);

drivers/usb/dwc2/gadget.c

890

sg_dma_address(sg) + sg->offset, sg_dma_len(sg),

drivers/usb/dwc3/gadget.c

1494

length -= sg_dma_len(s);

drivers/usb/dwc3/gadget.c

1502

trb_length = min_t(unsigned int, length, sg_dma_len(s));

drivers/usb/dwc3/gadget.c

1531

sg_dma_len(sg_next(s)) >= length)) {

drivers/usb/fotg210/fotg210-hcd.c

2580

this_sg_len = min_t(int, sg_dma_len(sg), len);

drivers/usb/fotg210/fotg210-hcd.c

2624

this_sg_len = min_t(int, sg_dma_len(sg), len);

drivers/usb/gadget/udc/cdns2/cdns2-gadget.c

423

len = sg_dma_len(sg);

drivers/usb/gadget/udc/cdns2/cdns2-gadget.c

531

block_length = sg_dma_len(sg);

drivers/usb/gadget/udc/cdns2/cdns2-gadget.c

602

block_length = sg_dma_len(sg);

drivers/usb/gadget/udc/cdns2/cdns2-gadget.c

630

length = sg_dma_len(sg);

drivers/usb/gadget/udc/cdns2/cdns2-gadget.c

681

length = sg_dma_len(sg);

drivers/usb/host/ehci-q.c

633

this_sg_len = min_t(int, sg_dma_len(sg), len);

drivers/usb/host/ehci-q.c

677

this_sg_len = min_t(int, sg_dma_len(sg), len);

drivers/usb/host/ohci-hcd.c

129

this_sg_len = min_t(int, sg_dma_len(sg), len);

drivers/usb/host/ohci-q.c

627

this_sg_len = min_t(int, sg_dma_len(sg), data_len);

drivers/usb/host/ohci-q.c

675

this_sg_len = min_t(int, sg_dma_len(sg),

drivers/usb/host/uhci-q.c

953

this_sg_len = min_t(int, sg_dma_len(sg), len);

drivers/usb/host/uhci-q.c

996

this_sg_len = min_t(int, sg_dma_len(sg), len);

drivers/usb/host/xhci-ring.c

3399

len = sg_dma_len(sg);

drivers/usb/host/xhci-ring.c

3639

block_len = sg_dma_len(sg);

drivers/usb/host/xhci-ring.c

3744

block_len = sg_dma_len(sg);

drivers/usb/musb/ux500_dma.c

97

sg_dma_len(&sg) = len;

drivers/vdpa/mlx5/core/mr.c

45

for (dma_addr = sg_dma_address(sg), dma_len = sg_dma_len(sg);

drivers/vfio/pci/pds/cmds.c

235

sge->len = cpu_to_le32(sg_dma_len(sg));

drivers/vfio/pci/pds/dirty.c

428

sg_elem->len = cpu_to_le32(sg_dma_len(sg));

drivers/video/fbdev/via/via-core.c

261

descr->seg_size = sg_dma_len(sgentry) >> 4;

drivers/video/fbdev/via/via-core.c

266

offset += sg_dma_len(sgentry);

drivers/virtio/virtio_ring.c

452

*len = sg_dma_len(sg);

drivers/xen/grant-dma-ops.c

249

xen_grant_dma_unmap_phys(dev, s->dma_address, sg_dma_len(s), dir,

drivers/xen/grant-dma-ops.c

269

sg_dma_len(s) = s->length;

drivers/xen/grant-dma-ops.c

276

sg_dma_len(sg) = 0;

drivers/xen/swiotlb-xen.c

355

xen_swiotlb_unmap_phys(hwdev, sg->dma_address, sg_dma_len(sg),

drivers/xen/swiotlb-xen.c

374

sg_dma_len(sg) = sg->length;

drivers/xen/swiotlb-xen.c

380

sg_dma_len(sgl) = 0;

fs/smb/server/transport_rdma.c

1581

sge->length = sg_dma_len(&sg[j]);

include/linux/dmaengine.h

984

sg_dma_len(&sg) = len;

include/trace/events/dma.h

315

sg_dma_len(sg);

include/trace/events/dma.h

462

sg_dma_len(sg);

io_uring/zcrx.c

160

total_size += sg_dma_len(sg);

io_uring/zcrx.c

80

unsigned long sg_len = sg_dma_len(sg);

kernel/dma/debug.c

1208

end = start + sg_dma_len(sg) - 1;

kernel/dma/debug.c

1342

entry->size = sg_dma_len(s);

kernel/dma/debug.c

1389

.size = sg_dma_len(s),

kernel/dma/debug.c

1522

.size = sg_dma_len(s),

kernel/dma/debug.c

1553

.size = sg_dma_len(s),

kernel/dma/direct.c

449

sg_dma_len(sg), dir, attrs);

kernel/dma/direct.c

481

sg_dma_len(sg) = sg->length;

kernel/dma/direct.c

488

sg_dma_len(sg) = sg->length;

kernel/dma/mapping.c

786

sg_dma_len(sgt->sgl) = sgt->sgl->length;

lib/kfifo.c

322

sg_dma_len(sgl) = len;

lib/scatterlist.c

765

return PAGE_ALIGN(sg->offset + sg_dma_len(sg)) >> PAGE_SHIFT;

lib/scatterlist.c

88

nents += DIV_ROUND_UP(sg_dma_len(sg), len);

lib/sg_split.c

112

sg_dma_len(out_sg) = sg_dma_len(in_sg);

lib/sg_split.c

115

sg_dma_len(out_sg) -= split->skip_sg0;

lib/sg_split.c

119

sg_dma_len(--out_sg) = split->length_last_sg;

lib/sg_split.c

36

sglen = mapped ? sg_dma_len(sg) : sg->length;

lib/sg_split.c

93

sg_dma_len(out_sg) = 0;

net/core/devmem.c

267

size_t len = sg_dma_len(sg);

net/rds/ib.h

327

unsigned int sg_dma_len,

net/rds/ib.h

333

for_each_sg(sglist, sg, sg_dma_len, i) {

net/rds/ib.h

335

sg_dma_len(sg), direction);

net/rds/ib.h

342

unsigned int sg_dma_len,

net/rds/ib.h

348

for_each_sg(sglist, sg, sg_dma_len, i) {

net/rds/ib.h

350

sg_dma_len(sg), direction);

net/rds/ib_frmr.c

134

ret = ib_map_mr_sg_zbva(frmr->mr, ibmr->sg, ibmr->sg_dma_len,

net/rds/ib_frmr.c

136

if (unlikely(ret != ibmr->sg_dma_len)) {

net/rds/ib_frmr.c

209

ibmr->sg_dma_len = 0;

net/rds/ib_frmr.c

211

WARN_ON(ibmr->sg_dma_len);

net/rds/ib_frmr.c

212

ibmr->sg_dma_len = ib_dma_map_sg(dev, ibmr->sg, ibmr->sg_len,

net/rds/ib_frmr.c

214

if (unlikely(!ibmr->sg_dma_len)) {

net/rds/ib_frmr.c

224

for (i = 0; i < ibmr->sg_dma_len; ++i) {

net/rds/ib_frmr.c

225

unsigned int dma_len = sg_dma_len(&ibmr->sg[i]);

net/rds/ib_frmr.c

237

if (i < ibmr->sg_dma_len - 1)

net/rds/ib_frmr.c

266

ibmr->sg_dma_len = 0;

net/rds/ib_frmr.c

371

if (ibmr->sg_dma_len) {

net/rds/ib_mr.h

79

int sg_dma_len;

net/rds/ib_rdma.c

225

ibmr->sg_dma_len, DMA_BIDIRECTIONAL);

net/rds/ib_rdma.c

229

ibmr->sg_dma_len, DMA_BIDIRECTIONAL);

net/rds/ib_rdma.c

238

if (ibmr->sg_dma_len) {

net/rds/ib_rdma.c

242

ibmr->sg_dma_len = 0;

net/rds/ib_recv.c

352

sge->length = sg_dma_len(&recv->r_frag->f_sg);

net/rds/ib_send.c

678

sg_dma_len(scat) - rm->data.op_dmaoff);

net/rds/ib_send.c

688

if (rm->data.op_dmaoff == sg_dma_len(scat)) {

net/rds/ib_send.c

847

send->s_sge[0].length = sg_dma_len(op->op_sg);

net/rds/ib_send.c

970

len = sg_dma_len(scat);

net/rds/rdma.c

772

sg_dma_len(sg) = sg->length;

net/smc/smc_ib.c

751

if (!sg_dma_len(sg))

net/smc/smc_ib.c

778

if (!sg_dma_len(sg))

net/smc/smc_ib.c

782

sg_dma_len(sg),

net/smc/smc_ib.c

801

if (!sg_dma_len(sg))

net/smc/smc_ib.c

805

sg_dma_len(sg),

rust/helpers/scatterlist.c

12

return sg_dma_len(sg);

sound/soc/fsl/fsl_asrc_m2m.c

165

sg_dma_len(&sg[i]) = max_period_size;

sound/soc/fsl/fsl_asrc_m2m.c

168

sg_dma_len(&sg[i]) = buf_len - i * max_period_size;

sound/soc/renesas/siu_pcm.c

118

sg_dma_len(&sg) = size;

sound/soc/renesas/siu_pcm.c

168

sg_dma_len(&sg) = size;

sound/soc/sprd/sprd-pcm-compress.c

216

sg_dma_len(sgt) = dma->trans_len;

sound/soc/sprd/sprd-pcm-dma.c

254

sg_dma_len(sgt) = sg_len;