sg_len            195 drivers/ata/acard-ahci.c 		u32 sg_len = sg_dma_len(sg);
sg_len            204 drivers/ata/acard-ahci.c 		acard_sg[si].size = cpu_to_le32(sg_len);
sg_len           1606 drivers/ata/libahci.c 		u32 sg_len = sg_dma_len(sg);
sg_len           1610 drivers/ata/libahci.c 		ahci_sg[si].flags_size = cpu_to_le32(sg_len - 1);
sg_len           2585 drivers/ata/libata-sff.c 		u32 sg_len, len;
sg_len           2592 drivers/ata/libata-sff.c 		sg_len = sg_dma_len(sg);
sg_len           2594 drivers/ata/libata-sff.c 		while (sg_len) {
sg_len           2596 drivers/ata/libata-sff.c 			len = sg_len;
sg_len           2597 drivers/ata/libata-sff.c 			if ((offset + sg_len) > 0x10000)
sg_len           2605 drivers/ata/libata-sff.c 			sg_len -= len;
sg_len           2636 drivers/ata/libata-sff.c 		u32 sg_len, len, blen;
sg_len           2643 drivers/ata/libata-sff.c 		sg_len = sg_dma_len(sg);
sg_len           2645 drivers/ata/libata-sff.c 		while (sg_len) {
sg_len           2647 drivers/ata/libata-sff.c 			len = sg_len;
sg_len           2648 drivers/ata/libata-sff.c 			if ((offset + sg_len) > 0x10000)
sg_len           2665 drivers/ata/libata-sff.c 			sg_len -= len;
sg_len            532 drivers/ata/pata_macio.c 		u32 addr, sg_len, len;
sg_len            539 drivers/ata/pata_macio.c 		sg_len = sg_dma_len(sg);
sg_len            541 drivers/ata/pata_macio.c 		while (sg_len) {
sg_len            545 drivers/ata/pata_macio.c 			len = (sg_len < MAX_DBDMA_SEG) ? sg_len : MAX_DBDMA_SEG;
sg_len            553 drivers/ata/pata_macio.c 			sg_len -= len;
sg_len            457 drivers/ata/sata_fsl.c 		u32 sg_len = sg_dma_len(sg);
sg_len            460 drivers/ata/sata_fsl.c 			(unsigned long long)sg_addr, sg_len);
sg_len            466 drivers/ata/sata_fsl.c 		if (unlikely(sg_len & 0x03))
sg_len            468 drivers/ata/sata_fsl.c 				     sg_len);
sg_len            480 drivers/ata/sata_fsl.c 		ttl_dwords += sg_len;
sg_len            482 drivers/ata/sata_fsl.c 		prd->ddc_and_ext = cpu_to_le32(data_snoop | (sg_len & ~0x03));
sg_len            490 drivers/ata/sata_fsl.c 			indirect_ext_segment_sz += sg_len;
sg_len           1795 drivers/ata/sata_mv.c 		u32 sg_len = sg_dma_len(sg);
sg_len           1797 drivers/ata/sata_mv.c 		while (sg_len) {
sg_len           1799 drivers/ata/sata_mv.c 			u32 len = sg_len;
sg_len           1809 drivers/ata/sata_mv.c 			sg_len -= len;
sg_len           1979 drivers/ata/sata_nv.c 		u32 sg_len, len;
sg_len           1982 drivers/ata/sata_nv.c 		sg_len = sg_dma_len(sg);
sg_len           1984 drivers/ata/sata_nv.c 		while (sg_len) {
sg_len           1986 drivers/ata/sata_nv.c 			len = sg_len;
sg_len           1987 drivers/ata/sata_nv.c 			if ((offset + sg_len) > 0x10000)
sg_len           1994 drivers/ata/sata_nv.c 			sg_len -= len;
sg_len            588 drivers/ata/sata_promise.c 		u32 sg_len;
sg_len            595 drivers/ata/sata_promise.c 		sg_len = sg_dma_len(sg);
sg_len            597 drivers/ata/sata_promise.c 		while (sg_len) {
sg_len            599 drivers/ata/sata_promise.c 			len = sg_len;
sg_len            600 drivers/ata/sata_promise.c 			if ((offset + sg_len) > 0x10000)
sg_len            608 drivers/ata/sata_promise.c 			sg_len -= len;
sg_len            535 drivers/ata/sata_rcar.c 		u32 addr, sg_len;
sg_len            542 drivers/ata/sata_rcar.c 		sg_len = sg_dma_len(sg);
sg_len            545 drivers/ata/sata_rcar.c 		prd[si].flags_len = cpu_to_le32(sg_len);
sg_len            546 drivers/ata/sata_rcar.c 		VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", si, addr, sg_len);
sg_len            306 drivers/ata/sata_sil.c 		u32 sg_len = sg_dma_len(sg);
sg_len            309 drivers/ata/sata_sil.c 		prd->flags_len = cpu_to_le32(sg_len);
sg_len            310 drivers/ata/sata_sil.c 		VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", si, addr, sg_len);
sg_len            178 drivers/crypto/atmel-aes.c 	unsigned int		sg_len;
sg_len            729 drivers/crypto/atmel-aes.c 		dd->src.sg_len = dma_map_sg(dd->dev, dd->src.sg, dd->src.nents,
sg_len            731 drivers/crypto/atmel-aes.c 		dd->dst.sg_len = dd->src.sg_len;
sg_len            732 drivers/crypto/atmel-aes.c 		if (!dd->src.sg_len)
sg_len            735 drivers/crypto/atmel-aes.c 		dd->src.sg_len = dma_map_sg(dd->dev, dd->src.sg, dd->src.nents,
sg_len            737 drivers/crypto/atmel-aes.c 		if (!dd->src.sg_len)
sg_len            740 drivers/crypto/atmel-aes.c 		dd->dst.sg_len = dma_map_sg(dd->dev, dd->dst.sg, dd->dst.nents,
sg_len            742 drivers/crypto/atmel-aes.c 		if (!dd->dst.sg_len) {
sg_len            818 drivers/crypto/atmel-aes.c 	desc = dmaengine_prep_slave_sg(dma->chan, dma->sg, dma->sg_len, dir,
sg_len           1518 drivers/crypto/atmel-sha.c 	unsigned int sg_len;
sg_len           1528 drivers/crypto/atmel-sha.c 	sg_len = dma_map_sg(dd->dev, dma->sg, dma->nents, DMA_TO_DEVICE);
sg_len           1529 drivers/crypto/atmel-sha.c 	if (!sg_len) {
sg_len           1540 drivers/crypto/atmel-sha.c 	desc = dmaengine_prep_slave_sg(chan, dma->sg, sg_len, DMA_MEM_TO_DEV,
sg_len            253 drivers/crypto/ccp/ccp-ops.c 			 struct scatterlist *sg, u64 sg_len,
sg_len            261 drivers/crypto/ccp/ccp-ops.c 	ret = ccp_init_sg_workarea(&data->sg_wa, cmd_q->ccp->dev, sg, sg_len,
sg_len           1510 drivers/crypto/chelsio/chcr_algo.c 				param->sg_len) <= SGE_MAX_WR_LEN;
sg_len           1511 drivers/crypto/chelsio/chcr_algo.c 	nents = sg_nents_xlen(req_ctx->hctx_wr.srcsg, param->sg_len,
sg_len           1515 drivers/crypto/chelsio/chcr_algo.c 				param->sg_len, 16) : (sgl_len(nents) * 8);
sg_len           1525 drivers/crypto/chelsio/chcr_algo.c 	chcr_req->sec_cpl.pldlen = htonl(param->bfr_len + param->sg_len);
sg_len           1571 drivers/crypto/chelsio/chcr_algo.c 				(param->sg_len + param->bfr_len) : 0);
sg_len           1630 drivers/crypto/chelsio/chcr_algo.c 	params.sg_len = chcr_hash_ent_in_wr(req->src, !!req_ctx->reqlen,
sg_len           1632 drivers/crypto/chelsio/chcr_algo.c 	if (params.sg_len > req->nbytes)
sg_len           1633 drivers/crypto/chelsio/chcr_algo.c 		params.sg_len = req->nbytes;
sg_len           1634 drivers/crypto/chelsio/chcr_algo.c 	params.sg_len = rounddown(params.sg_len + req_ctx->reqlen, bs) -
sg_len           1644 drivers/crypto/chelsio/chcr_algo.c 	req_ctx->data_len += params.sg_len + params.bfr_len;
sg_len           1651 drivers/crypto/chelsio/chcr_algo.c 	req_ctx->hctx_wr.processed += params.sg_len;
sg_len           1703 drivers/crypto/chelsio/chcr_algo.c 	params.sg_len = 0;
sg_len           1716 drivers/crypto/chelsio/chcr_algo.c 	req_ctx->data_len += params.bfr_len + params.sg_len;
sg_len           1787 drivers/crypto/chelsio/chcr_algo.c 	params.sg_len = chcr_hash_ent_in_wr(req->src, !!req_ctx->reqlen,
sg_len           1789 drivers/crypto/chelsio/chcr_algo.c 	if (params.sg_len < req->nbytes) {
sg_len           1796 drivers/crypto/chelsio/chcr_algo.c 		params.sg_len = rounddown(params.sg_len + req_ctx->reqlen, bs)
sg_len           1803 drivers/crypto/chelsio/chcr_algo.c 		params.sg_len = req->nbytes;
sg_len           1806 drivers/crypto/chelsio/chcr_algo.c 				params.sg_len;
sg_len           1809 drivers/crypto/chelsio/chcr_algo.c 	req_ctx->data_len += params.bfr_len + params.sg_len;
sg_len           1825 drivers/crypto/chelsio/chcr_algo.c 	req_ctx->hctx_wr.processed += params.sg_len;
sg_len           1880 drivers/crypto/chelsio/chcr_algo.c 	params.sg_len = chcr_hash_ent_in_wr(req->src, !!req_ctx->reqlen,
sg_len           1882 drivers/crypto/chelsio/chcr_algo.c 	if (params.sg_len < req->nbytes) {
sg_len           1890 drivers/crypto/chelsio/chcr_algo.c 		params.sg_len = rounddown(params.sg_len, bs);
sg_len           1893 drivers/crypto/chelsio/chcr_algo.c 		params.sg_len = req->nbytes;
sg_len           1903 drivers/crypto/chelsio/chcr_algo.c 	req_ctx->data_len += params.bfr_len + params.sg_len;
sg_len           1916 drivers/crypto/chelsio/chcr_algo.c 	req_ctx->hctx_wr.processed += params.sg_len;
sg_len           1949 drivers/crypto/chelsio/chcr_algo.c 	params.sg_len = chcr_hash_ent_in_wr(hctx_wr->srcsg, 0,
sg_len           1952 drivers/crypto/chelsio/chcr_algo.c 	if ((params.sg_len + hctx_wr->processed) > req->nbytes)
sg_len           1953 drivers/crypto/chelsio/chcr_algo.c 		params.sg_len = req->nbytes - hctx_wr->processed;
sg_len           1955 drivers/crypto/chelsio/chcr_algo.c 	    ((params.sg_len + hctx_wr->processed) < req->nbytes)) {
sg_len           1962 drivers/crypto/chelsio/chcr_algo.c 		params.sg_len = rounddown(params.sg_len, bs);
sg_len           1969 drivers/crypto/chelsio/chcr_algo.c 		params.scmd1 = reqctx->data_len + params.sg_len;
sg_len           1972 drivers/crypto/chelsio/chcr_algo.c 	reqctx->data_len += params.sg_len;
sg_len           1978 drivers/crypto/chelsio/chcr_algo.c 	hctx_wr->processed += params.sg_len;
sg_len           2638 drivers/crypto/chelsio/chcr_algo.c 				   param->sg_len, 0);
sg_len           2645 drivers/crypto/chelsio/chcr_algo.c 				  param->sg_len, reqctx->hctx_wr.src_ofst);
sg_len            283 drivers/crypto/chelsio/chcr_algo.h 	unsigned int sg_len;
sg_len            282 drivers/crypto/mediatek/mtk-aes.c 	u32 slen = aes->src.sg_len, dlen = aes->dst.sg_len;
sg_len            384 drivers/crypto/mediatek/mtk-aes.c 		aes->src.sg_len = dma_map_sg(cryp->dev, aes->src.sg,
sg_len            387 drivers/crypto/mediatek/mtk-aes.c 		aes->dst.sg_len = aes->src.sg_len;
sg_len            388 drivers/crypto/mediatek/mtk-aes.c 		if (unlikely(!aes->src.sg_len))
sg_len            391 drivers/crypto/mediatek/mtk-aes.c 		aes->src.sg_len = dma_map_sg(cryp->dev, aes->src.sg,
sg_len            393 drivers/crypto/mediatek/mtk-aes.c 		if (unlikely(!aes->src.sg_len))
sg_len            396 drivers/crypto/mediatek/mtk-aes.c 		aes->dst.sg_len = dma_map_sg(cryp->dev, aes->dst.sg,
sg_len            398 drivers/crypto/mediatek/mtk-aes.c 		if (unlikely(!aes->dst.sg_len)) {
sg_len            115 drivers/crypto/mediatek/mtk-platform.h 	u32 sg_len;
sg_len             83 drivers/crypto/nx/nx.c 	unsigned int sg_len = 0;
sg_len            108 drivers/crypto/nx/nx.c 	for (sg = sg_head; sg_len < *len; sg++) {
sg_len            117 drivers/crypto/nx/nx.c 		sg_len += sg->len;
sg_len            120 drivers/crypto/nx/nx.c 				is_vmalloc_addr(start_addr + sg_len)) {
sg_len            122 drivers/crypto/nx/nx.c 						start_addr + sg_len));
sg_len            123 drivers/crypto/nx/nx.c 			end_addr = sg_addr + *len - sg_len;
sg_len            133 drivers/crypto/nx/nx.c 	*len = sg_len;
sg_len            155 drivers/crypto/omap-sham.c 	int			sg_len;
sg_len            542 drivers/crypto/omap-sham.c 	sg_miter_start(&mi, ctx->sg, ctx->sg_len,
sg_len            593 drivers/crypto/omap-sham.c 	if (!dma_map_sg(dd->dev, ctx->sg, ctx->sg_len, DMA_TO_DEVICE)) {
sg_len            610 drivers/crypto/omap-sham.c 	tx = dmaengine_prep_slave_sg(dd->dma_lch, ctx->sg, ctx->sg_len,
sg_len            658 drivers/crypto/omap-sham.c 	ctx->sg_len = 0;
sg_len            663 drivers/crypto/omap-sham.c 		ctx->sg_len++;
sg_len            684 drivers/crypto/omap-sham.c 			ctx->sg_len++;
sg_len            723 drivers/crypto/omap-sham.c 	ctx->sg_len = 1;
sg_len            802 drivers/crypto/omap-sham.c 	rctx->sg_len = n;
sg_len            872 drivers/crypto/omap-sham.c 		rctx->sg_len++;
sg_len            880 drivers/crypto/omap-sham.c 		rctx->sg_len = 1;
sg_len            914 drivers/crypto/omap-sham.c 	dma_unmap_sg(dd->dev, ctx->sg, ctx->sg_len, DMA_TO_DEVICE);
sg_len            364 drivers/crypto/s5p-sss.c 	unsigned int		sg_len;
sg_len            989 drivers/crypto/s5p-sss.c 	cnt = dma_map_sg(dd->dev, ctx->sg, ctx->sg_len, DMA_TO_DEVICE);
sg_len           1048 drivers/crypto/s5p-sss.c 	ctx->sg_len = 1;
sg_len           1090 drivers/crypto/s5p-sss.c 	ctx->sg_len = 0;
sg_len           1095 drivers/crypto/s5p-sss.c 		ctx->sg_len++;
sg_len           1115 drivers/crypto/s5p-sss.c 		ctx->sg_len++;
sg_len           1190 drivers/crypto/s5p-sss.c 		ctx->sg_len = n;
sg_len           1195 drivers/crypto/s5p-sss.c 		ctx->sg_len++;
sg_len           1198 drivers/crypto/s5p-sss.c 		ctx->sg_len = n;
sg_len           1283 drivers/crypto/s5p-sss.c 		ctx->sg_len = 1;
sg_len           1303 drivers/crypto/s5p-sss.c 	dma_unmap_sg(dd->dev, ctx->sg, ctx->sg_len, DMA_TO_DEVICE);
sg_len            314 drivers/crypto/ux500/hash/hash_alg.h 	int			sg_len;
sg_len            155 drivers/crypto/ux500/hash/hash_core.c 	ctx->device->dma.sg_len = dma_map_sg(channel->device->dev,
sg_len            159 drivers/crypto/ux500/hash/hash_core.c 	if (!ctx->device->dma.sg_len) {
sg_len            168 drivers/crypto/ux500/hash/hash_core.c 			ctx->device->dma.sg, ctx->device->dma.sg_len,
sg_len            192 drivers/crypto/ux500/hash/hash_core.c 		     ctx->device->dma.sg_len, DMA_TO_DEVICE);
sg_len            386 drivers/dma/altera-msgdma.c 		     unsigned int sg_len, enum dma_transfer_direction dir,
sg_len            401 drivers/dma/altera-msgdma.c 	for_each_sg(sgl, sg, sg_len, i)
sg_len            442 drivers/dma/altera-msgdma.c 			if (sg_len == 0)
sg_len            447 drivers/dma/altera-msgdma.c 			sg_len--;
sg_len           2051 drivers/dma/amba-pl08x.c 		unsigned int sg_len, enum dma_transfer_direction direction,
sg_len           2068 drivers/dma/amba-pl08x.c 	for_each_sg(sgl, sg, sg_len, tmp) {
sg_len            980 drivers/dma/at_hdmac.c 		       unsigned int sg_len, int value,
sg_len            993 drivers/dma/at_hdmac.c 		 value, sg_len, flags);
sg_len            995 drivers/dma/at_hdmac.c 	if (unlikely(!sgl || !sg_len)) {
sg_len           1009 drivers/dma/at_hdmac.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len           1065 drivers/dma/at_hdmac.c 		unsigned int sg_len, enum dma_transfer_direction direction,
sg_len           1083 drivers/dma/at_hdmac.c 			sg_len,
sg_len           1087 drivers/dma/at_hdmac.c 	if (unlikely(!atslave || !sg_len)) {
sg_len           1105 drivers/dma/at_hdmac.c 		for_each_sg(sgl, sg, sg_len, i) {
sg_len           1146 drivers/dma/at_hdmac.c 		for_each_sg(sgl, sg, sg_len, i) {
sg_len            634 drivers/dma/at_xdmac.c 		       unsigned int sg_len, enum dma_transfer_direction direction,
sg_len            654 drivers/dma/at_xdmac.c 		 __func__, sg_len,
sg_len            665 drivers/dma/at_xdmac.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len           1229 drivers/dma/at_xdmac.c 			    unsigned int sg_len, int value,
sg_len           1243 drivers/dma/at_xdmac.c 		__func__, sg_len, value, flags);
sg_len           1246 drivers/dma/at_xdmac.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len           1350 drivers/dma/at_xdmac.c 		if ((i == (sg_len - 1)) &&
sg_len            268 drivers/dma/bcm2835-dma.c 	unsigned int sg_len)
sg_len            275 drivers/dma/bcm2835-dma.c 	for_each_sg(sgl, sgent, sg_len, i)
sg_len            390 drivers/dma/bcm2835-dma.c 	unsigned int sg_len)
sg_len            399 drivers/dma/bcm2835-dma.c 	for_each_sg(sgl, sgent, sg_len, i) {
sg_len            644 drivers/dma/bcm2835-dma.c 	struct scatterlist *sgl, unsigned int sg_len,
sg_len            677 drivers/dma/bcm2835-dma.c 	frames = bcm2835_dma_count_frames_for_sg(c, sgl, sg_len);
sg_len            689 drivers/dma/bcm2835-dma.c 					  sgl, sg_len);
sg_len           1272 drivers/dma/coh901318.c 	unsigned int sg_len;
sg_len           1535 drivers/dma/coh901318.c 		desc->sg_len = 0;
sg_len           2269 drivers/dma/coh901318.c 			unsigned int sg_len, enum dma_transfer_direction direction,
sg_len           2295 drivers/dma/coh901318.c 		 __func__, sg_len, direction);
sg_len           2335 drivers/dma/coh901318.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len           2360 drivers/dma/coh901318.c 	ret = coh901318_lli_fill_sg(&cohc->base->pool, lli, sgl, sg_len,
sg_len            528 drivers/dma/dma-axi-dmac.c 	unsigned int sg_len, enum dma_transfer_direction direction,
sg_len            542 drivers/dma/dma-axi-dmac.c 	for_each_sg(sgl, sg, sg_len, i)
sg_len            551 drivers/dma/dma-axi-dmac.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            354 drivers/dma/dma-jz4780.c 	struct dma_chan *chan, struct scatterlist *sgl, unsigned int sg_len,
sg_len            364 drivers/dma/dma-jz4780.c 	desc = jz4780_dma_desc_alloc(jzchan, sg_len, DMA_SLAVE);
sg_len            368 drivers/dma/dma-jz4780.c 	for (i = 0; i < sg_len; i++) {
sg_len            380 drivers/dma/dma-jz4780.c 		if (i != (sg_len - 1) &&
sg_len            623 drivers/dma/dw/core.c 		unsigned int sg_len, enum dma_transfer_direction direction,
sg_len            644 drivers/dma/dw/core.c 	if (unlikely(!is_slave_direction(direction) || !sg_len))
sg_len            663 drivers/dma/dw/core.c 		for_each_sg(sgl, sg, sg_len, i) {
sg_len            713 drivers/dma/dw/core.c 		for_each_sg(sgl, sg, sg_len, i) {
sg_len           1034 drivers/dma/ep93xx_dma.c 			 unsigned int sg_len, enum dma_transfer_direction dir,
sg_len           1057 drivers/dma/ep93xx_dma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            415 drivers/dma/fsl-edma-common.c 		int sg_len)
sg_len            420 drivers/dma/fsl-edma-common.c 	fsl_desc = kzalloc(struct_size(fsl_desc, tcd, sg_len), GFP_NOWAIT);
sg_len            425 drivers/dma/fsl-edma-common.c 	fsl_desc->n_tcds = sg_len;
sg_len            426 drivers/dma/fsl-edma-common.c 	for (i = 0; i < sg_len; i++) {
sg_len            450 drivers/dma/fsl-edma-common.c 	int sg_len, i;
sg_len            460 drivers/dma/fsl-edma-common.c 	sg_len = buf_len / period_len;
sg_len            461 drivers/dma/fsl-edma-common.c 	fsl_desc = fsl_edma_alloc_desc(fsl_chan, sg_len);
sg_len            482 drivers/dma/fsl-edma-common.c 	for (i = 0; i < sg_len; i++) {
sg_len            487 drivers/dma/fsl-edma-common.c 		last_sg = fsl_desc->tcd[(i + 1) % sg_len].ptcd;
sg_len            513 drivers/dma/fsl-edma-common.c 		unsigned int sg_len, enum dma_transfer_direction direction,
sg_len            529 drivers/dma/fsl-edma-common.c 	fsl_desc = fsl_edma_alloc_desc(fsl_chan, sg_len);
sg_len            547 drivers/dma/fsl-edma-common.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            549 drivers/dma/fsl-edma-common.c 		last_sg = fsl_desc->tcd[(i + 1) % sg_len].ptcd;
sg_len            564 drivers/dma/fsl-edma-common.c 		if (i < sg_len - 1) {
sg_len            240 drivers/dma/fsl-edma-common.h 		unsigned int sg_len, enum dma_transfer_direction direction,
sg_len            260 drivers/dma/hsu/hsu.c 		unsigned int sg_len, enum dma_transfer_direction direction,
sg_len            268 drivers/dma/hsu/hsu.c 	desc = hsu_dma_alloc_desc(sg_len);
sg_len            272 drivers/dma/hsu/hsu.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            279 drivers/dma/hsu/hsu.c 	desc->nents = sg_len;
sg_len            294 drivers/dma/idma64.c 		unsigned int sg_len, enum dma_transfer_direction direction,
sg_len            302 drivers/dma/idma64.c 	desc = idma64_alloc_desc(sg_len);
sg_len            306 drivers/dma/idma64.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            321 drivers/dma/idma64.c 	desc->ndesc = sg_len;
sg_len            449 drivers/dma/img-mdc-dma.c 	unsigned int sg_len, enum dma_transfer_direction dir,
sg_len            474 drivers/dma/img-mdc-dma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            817 drivers/dma/imx-dma.c 		unsigned int sg_len, enum dma_transfer_direction direction,
sg_len            831 drivers/dma/imx-dma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            852 drivers/dma/imx-dma.c 	desc->sgcount = sg_len;
sg_len           1442 drivers/dma/imx-sdma.c 		unsigned int sg_len, enum dma_transfer_direction direction,
sg_len           1454 drivers/dma/imx-sdma.c 	desc = sdma_transfer_init(sdmac, direction, sg_len);
sg_len           1459 drivers/dma/imx-sdma.c 			sg_len, channel);
sg_len           1461 drivers/dma/imx-sdma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len           1501 drivers/dma/imx-sdma.c 		if (i + 1 == sg_len) {
sg_len           1319 drivers/dma/ipu/ipu_idmac.c 				for_each_sg(desc->sg, sg, desc->sg_len, k) {
sg_len           1334 drivers/dma/ipu/ipu_idmac.c 		struct scatterlist *sgl, unsigned int sg_len,
sg_len           1362 drivers/dma/ipu/ipu_idmac.c 		desc->sg_len	= sg_len;
sg_len            527 drivers/dma/mmp_pdma.c 		       unsigned int sg_len, enum dma_transfer_direction dir,
sg_len            537 drivers/dma/mmp_pdma.c 	if ((sgl == NULL) || (sg_len == 0))
sg_len            544 drivers/dma/mmp_pdma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            271 drivers/dma/moxart-dma.c 	unsigned int sg_len, enum dma_transfer_direction dir,
sg_len            312 drivers/dma/moxart-dma.c 	d = kzalloc(struct_size(d, sg, sg_len), GFP_ATOMIC);
sg_len            320 drivers/dma/moxart-dma.c 	for_each_sg(sgl, sgent, sg_len, i) {
sg_len            325 drivers/dma/moxart-dma.c 	d->sglen = sg_len;
sg_len            685 drivers/dma/mpc512x_dma.c 		unsigned int sg_len, enum dma_transfer_direction direction,
sg_len            700 drivers/dma/mpc512x_dma.c 	if (sg_len != 1)
sg_len            706 drivers/dma/mpc512x_dma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            496 drivers/dma/mxs-dma.c 		unsigned int sg_len, enum dma_transfer_direction direction,
sg_len            510 drivers/dma/mxs-dma.c 	if (sg_len + idx > NUM_CCW) {
sg_len            513 drivers/dma/mxs-dma.c 				sg_len, NUM_CCW);
sg_len            539 drivers/dma/mxs-dma.c 		for (j = 0; j < sg_len;)
sg_len            549 drivers/dma/mxs-dma.c 		ccw->bits |= BF_CCW(sg_len, PIO_NUM);
sg_len            554 drivers/dma/mxs-dma.c 		for_each_sg(sgl, sg, sg_len, i) {
sg_len            575 drivers/dma/mxs-dma.c 			if (i + 1 == sg_len) {
sg_len           1007 drivers/dma/nbpfaxi.c 	struct dma_chan *dchan, struct scatterlist *sgl, unsigned int sg_len,
sg_len           1020 drivers/dma/nbpfaxi.c 		return nbpf_prep_sg(chan, sgl, &slave_sg, sg_len,
sg_len           1025 drivers/dma/nbpfaxi.c 		return nbpf_prep_sg(chan, &slave_sg, sgl, sg_len,
sg_len            877 drivers/dma/owl-dma.c 				       unsigned int sg_len,
sg_len            897 drivers/dma/owl-dma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            567 drivers/dma/pch_dma.c 			struct scatterlist *sgl, unsigned int sg_len,
sg_len            580 drivers/dma/pch_dma.c 	if (unlikely(!sg_len)) {
sg_len            595 drivers/dma/pch_dma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len           2830 drivers/dma/pl330.c 		unsigned int sg_len, enum dma_transfer_direction direction,
sg_len           2838 drivers/dma/pl330.c 	if (unlikely(!pch || !sgl || !sg_len))
sg_len           2848 drivers/dma/pl330.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            972 drivers/dma/pxa_dma.c 		   unsigned int sg_len, enum dma_transfer_direction dir,
sg_len            983 drivers/dma/pxa_dma.c 	if ((sgl == NULL) || (sg_len == 0))
sg_len            990 drivers/dma/pxa_dma.c 	for_each_sg(sgl, sg, sg_len, i)
sg_len            996 drivers/dma/pxa_dma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            607 drivers/dma/qcom/bam_dma.c 	struct scatterlist *sgl, unsigned int sg_len,
sg_len            626 drivers/dma/qcom/bam_dma.c 	for_each_sg(sgl, sg, sg_len, i)
sg_len            648 drivers/dma/qcom/bam_dma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            887 drivers/dma/s3c24xx-dma.c 	unsigned sg_len;
sg_len            948 drivers/dma/s3c24xx-dma.c 	sg_len = size / period;
sg_len            950 drivers/dma/s3c24xx-dma.c 	for (i = 0; i < sg_len; i++) {
sg_len            960 drivers/dma/s3c24xx-dma.c 		if (i == sg_len - 1)
sg_len            976 drivers/dma/s3c24xx-dma.c 		unsigned int sg_len, enum dma_transfer_direction direction,
sg_len           1042 drivers/dma/s3c24xx-dma.c 	for_each_sg(sgl, sg, sg_len, tmp) {
sg_len            895 drivers/dma/sh/rcar-dmac.c 		       unsigned int sg_len, dma_addr_t dev_addr,
sg_len            930 drivers/dma/sh/rcar-dmac.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len           1167 drivers/dma/sh/rcar-dmac.c 			unsigned int sg_len, enum dma_transfer_direction dir,
sg_len           1173 drivers/dma/sh/rcar-dmac.c 	if (rchan->mid_rid < 0 || !sg_len || !sg_dma_len(sgl)) {
sg_len           1176 drivers/dma/sh/rcar-dmac.c 			 __func__, sg_len, rchan->mid_rid);
sg_len           1183 drivers/dma/sh/rcar-dmac.c 	return rcar_dmac_chan_prep_sg(rchan, sgl, sg_len, rchan->map.addr,
sg_len           1197 drivers/dma/sh/rcar-dmac.c 	unsigned int sg_len;
sg_len           1211 drivers/dma/sh/rcar-dmac.c 	sg_len = buf_len / period_len;
sg_len           1212 drivers/dma/sh/rcar-dmac.c 	if (sg_len > RCAR_DMAC_MAX_SG_LEN) {
sg_len           1215 drivers/dma/sh/rcar-dmac.c 			rchan->index, sg_len, RCAR_DMAC_MAX_SG_LEN);
sg_len           1223 drivers/dma/sh/rcar-dmac.c 	sgl = kcalloc(sg_len, sizeof(*sgl), GFP_NOWAIT);
sg_len           1227 drivers/dma/sh/rcar-dmac.c 	sg_init_table(sgl, sg_len);
sg_len           1229 drivers/dma/sh/rcar-dmac.c 	for (i = 0; i < sg_len; ++i) {
sg_len           1238 drivers/dma/sh/rcar-dmac.c 	desc = rcar_dmac_chan_prep_sg(rchan, sgl, sg_len, rchan->map.addr,
sg_len            561 drivers/dma/sh/shdma-base.c 	struct scatterlist *sgl, unsigned int sg_len, dma_addr_t *addr,
sg_len            571 drivers/dma/sh/shdma-base.c 	for_each_sg(sgl, sg, sg_len, i)
sg_len            588 drivers/dma/sh/shdma-base.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            662 drivers/dma/sh/shdma-base.c 	struct dma_chan *chan, struct scatterlist *sgl, unsigned int sg_len,
sg_len            677 drivers/dma/sh/shdma-base.c 	if (slave_id < 0 || !sg_len) {
sg_len            679 drivers/dma/sh/shdma-base.c 			 __func__, sg_len, slave_id);
sg_len            685 drivers/dma/sh/shdma-base.c 	return shdma_prep_sg(schan, sgl, sg_len, &slave_addr,
sg_len            700 drivers/dma/sh/shdma-base.c 	unsigned int sg_len = buf_len / period_len;
sg_len            711 drivers/dma/sh/shdma-base.c 	if (sg_len > SHDMA_MAX_SG_LEN) {
sg_len            713 drivers/dma/sh/shdma-base.c 				sg_len, SHDMA_MAX_SG_LEN);
sg_len            731 drivers/dma/sh/shdma-base.c 	sgl = kcalloc(sg_len, sizeof(*sgl), GFP_KERNEL);
sg_len            735 drivers/dma/sh/shdma-base.c 	sg_init_table(sgl, sg_len);
sg_len            737 drivers/dma/sh/shdma-base.c 	for (i = 0; i < sg_len; i++) {
sg_len            746 drivers/dma/sh/shdma-base.c 	desc = shdma_prep_sg(schan, sgl, sg_len, &slave_addr,
sg_len             55 drivers/dma/sh/usb-dmac.c 	unsigned int sg_len;
sg_len            263 drivers/dma/sh/usb-dmac.c static int usb_dmac_desc_alloc(struct usb_dmac_chan *chan, unsigned int sg_len,
sg_len            269 drivers/dma/sh/usb-dmac.c 	desc = kzalloc(struct_size(desc, sg, sg_len), gfp);
sg_len            273 drivers/dma/sh/usb-dmac.c 	desc->sg_allocated_len = sg_len;
sg_len            299 drivers/dma/sh/usb-dmac.c 					       unsigned int sg_len, gfp_t gfp)
sg_len            307 drivers/dma/sh/usb-dmac.c 		if (sg_len <= desc->sg_allocated_len) {
sg_len            316 drivers/dma/sh/usb-dmac.c 	if (!usb_dmac_desc_alloc(chan, sg_len, gfp)) {
sg_len            417 drivers/dma/sh/usb-dmac.c 		       unsigned int sg_len, enum dma_transfer_direction dir,
sg_len            425 drivers/dma/sh/usb-dmac.c 	if (!sg_len) {
sg_len            427 drivers/dma/sh/usb-dmac.c 			 "%s: bad parameter: len=%d\n", __func__, sg_len);
sg_len            431 drivers/dma/sh/usb-dmac.c 	desc = usb_dmac_desc_get(uchan, sg_len, GFP_NOWAIT);
sg_len            436 drivers/dma/sh/usb-dmac.c 	desc->sg_len = sg_len;
sg_len            437 drivers/dma/sh/usb-dmac.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            519 drivers/dma/sh/usb-dmac.c 	for (i = desc->sg_index + 1; i < desc->sg_len; i++)
sg_len            583 drivers/dma/sh/usb-dmac.c 	if (++desc->sg_index < desc->sg_len) {
sg_len            237 drivers/dma/st_fdma.c 					       int sg_len)
sg_len            242 drivers/dma/st_fdma.c 	fdesc = kzalloc(struct_size(fdesc, node, sg_len), GFP_NOWAIT);
sg_len            247 drivers/dma/st_fdma.c 	fdesc->n_nodes = sg_len;
sg_len            248 drivers/dma/st_fdma.c 	for (i = 0; i < sg_len; i++) {
sg_len            453 drivers/dma/st_fdma.c 	int sg_len, i;
sg_len            473 drivers/dma/st_fdma.c 	sg_len = len / period_len;
sg_len            474 drivers/dma/st_fdma.c 	fdesc = st_fdma_alloc_desc(fchan, sg_len);
sg_len            482 drivers/dma/st_fdma.c 	for (i = 0; i < sg_len; i++) {
sg_len            485 drivers/dma/st_fdma.c 		hw_node->next = fdesc->node[(i + 1) % sg_len].pdesc;
sg_len            507 drivers/dma/st_fdma.c 		unsigned int sg_len, enum dma_transfer_direction direction,
sg_len            516 drivers/dma/st_fdma.c 	fchan = st_fdma_prep_common(chan, sg_len, direction);
sg_len            523 drivers/dma/st_fdma.c 	fdesc = st_fdma_alloc_desc(fchan, sg_len);
sg_len            531 drivers/dma/st_fdma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            534 drivers/dma/st_fdma.c 		hw_node->next = fdesc->node[(i + 1) % sg_len].pdesc;
sg_len           1020 drivers/dma/ste_dma40.c static int d40_sg_2_dmalen(struct scatterlist *sgl, int sg_len,
sg_len           1028 drivers/dma/ste_dma40.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len           2112 drivers/dma/ste_dma40.c 		unsigned int sg_len, dma_addr_t src_dev_addr,
sg_len           2120 drivers/dma/ste_dma40.c 	ret = d40_log_sg_to_lli(sg_src, sg_len,
sg_len           2127 drivers/dma/ste_dma40.c 	ret = d40_log_sg_to_lli(sg_dst, sg_len,
sg_len           2140 drivers/dma/ste_dma40.c 		unsigned int sg_len, dma_addr_t src_dev_addr,
sg_len           2152 drivers/dma/ste_dma40.c 	ret = d40_phy_sg_to_lli(sg_src, sg_len, src_dev_addr,
sg_len           2158 drivers/dma/ste_dma40.c 	ret = d40_phy_sg_to_lli(sg_dst, sg_len, dst_dev_addr,
sg_len           2172 drivers/dma/ste_dma40.c 	      unsigned int sg_len, unsigned long dma_flags)
sg_len           2183 drivers/dma/ste_dma40.c 	desc->lli_len = d40_sg_2_dmalen(sg, sg_len, cfg->src_info.data_width,
sg_len           2210 drivers/dma/ste_dma40.c 	    struct scatterlist *sg_dst, unsigned int sg_len,
sg_len           2229 drivers/dma/ste_dma40.c 	desc = d40_prep_desc(chan, sg_src, sg_len, dma_flags);
sg_len           2233 drivers/dma/ste_dma40.c 	if (sg_next(&sg_src[sg_len - 1]) == sg_src)
sg_len           2245 drivers/dma/ste_dma40.c 				      sg_len, src_dev_addr, dst_dev_addr);
sg_len           2248 drivers/dma/ste_dma40.c 				      sg_len, src_dev_addr, dst_dev_addr);
sg_len           2499 drivers/dma/ste_dma40.c 		  unsigned int sg_len, enum dma_transfer_direction direction,
sg_len           2505 drivers/dma/ste_dma40.c 	return d40_prep_sg(chan, sgl, sgl, sg_len, direction, dma_flags);
sg_len            266 drivers/dma/ste_dma40_ll.c 		      int sg_len,
sg_len            284 drivers/dma/ste_dma40_ll.c 	for_each_sg(sg, current_sg, sg_len, i) {
sg_len            291 drivers/dma/ste_dma40_ll.c 		if (i == sg_len - 1)
sg_len            418 drivers/dma/ste_dma40_ll.c 		      int sg_len,
sg_len            433 drivers/dma/ste_dma40_ll.c 	for_each_sg(sg, current_sg, sg_len, i) {
sg_len            442 drivers/dma/ste_dma40_ll.h 		      int sg_len,
sg_len            454 drivers/dma/ste_dma40_ll.h 		      int sg_len,
sg_len            830 drivers/dma/stm32-dma.c 	u32 sg_len, enum dma_transfer_direction direction,
sg_len            845 drivers/dma/stm32-dma.c 	if (sg_len < 1) {
sg_len            846 drivers/dma/stm32-dma.c 		dev_err(chan2dev(chan), "Invalid segment length %d\n", sg_len);
sg_len            850 drivers/dma/stm32-dma.c 	desc = kzalloc(struct_size(desc, sg_req, sg_len), GFP_NOWAIT);
sg_len            860 drivers/dma/stm32-dma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            883 drivers/dma/stm32-dma.c 	desc->num_sgs = sg_len;
sg_len            728 drivers/dma/stm32-mdma.c 				 struct scatterlist *sgl, u32 sg_len,
sg_len            738 drivers/dma/stm32-mdma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            767 drivers/dma/stm32-mdma.c 					i == sg_len - 1, i == 0, false);
sg_len            773 drivers/dma/stm32-mdma.c 	if (sg_len > 1)
sg_len            782 drivers/dma/stm32-mdma.c 			 u32 sg_len, enum dma_transfer_direction direction,
sg_len            800 drivers/dma/stm32-mdma.c 	desc = stm32_mdma_alloc_desc(chan, sg_len);
sg_len            804 drivers/dma/stm32-mdma.c 	ret = stm32_mdma_setup_xfer(chan, desc, sgl, sg_len, direction);
sg_len            768 drivers/dma/sun4i-dma.c 			unsigned int sg_len, enum dma_transfer_direction dir,
sg_len            814 drivers/dma/sun4i-dma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            684 drivers/dma/sun6i-dma.c 		unsigned int sg_len, enum dma_transfer_direction dir,
sg_len            710 drivers/dma/sun6i-dma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len           1001 drivers/dma/tegra20-apb-dma.c 	struct dma_chan *dc, struct scatterlist *sgl, unsigned int sg_len,
sg_len           1019 drivers/dma/tegra20-apb-dma.c 	if (sg_len < 1) {
sg_len           1020 drivers/dma/tegra20-apb-dma.c 		dev_err(tdc2dev(tdc), "Invalid segment length %d\n", sg_len);
sg_len           1064 drivers/dma/tegra20-apb-dma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            585 drivers/dma/ti/cppi41.c 	struct dma_chan *chan, struct scatterlist *sgl, unsigned sg_len,
sg_len            607 drivers/dma/ti/cppi41.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            210 drivers/dma/ti/edma.c 	u32				sg_len;
sg_len            784 drivers/dma/ti/edma.c 	edesc->sg_len = 0;
sg_len            790 drivers/dma/ti/edma.c 		edesc->sg_len += edesc->pset[j].len;
sg_len           1055 drivers/dma/ti/edma.c 	unsigned int sg_len, enum dma_transfer_direction direction,
sg_len           1067 drivers/dma/ti/edma.c 	if (unlikely(!echan || !sgl || !sg_len))
sg_len           1088 drivers/dma/ti/edma.c 	edesc = kzalloc(struct_size(edesc, pset, sg_len), GFP_ATOMIC);
sg_len           1092 drivers/dma/ti/edma.c 	edesc->pset_nr = sg_len;
sg_len           1098 drivers/dma/ti/edma.c 	nslots = min_t(unsigned, MAX_NR_SG, sg_len);
sg_len           1114 drivers/dma/ti/edma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len           1132 drivers/dma/ti/edma.c 		if (i == sg_len - 1)
sg_len           1449 drivers/dma/ti/edma.c 			edesc->residue -= edesc->sg_len;
sg_len            490 drivers/dma/timb_dma.c 	struct scatterlist *sgl, unsigned int sg_len,
sg_len            501 drivers/dma/timb_dma.c 	if (!sgl || !sg_len) {
sg_len            521 drivers/dma/timb_dma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            529 drivers/dma/timb_dma.c 			i == (sg_len - 1));
sg_len            804 drivers/dma/txx9dmac.c 		unsigned int sg_len, enum dma_transfer_direction direction,
sg_len            822 drivers/dma/txx9dmac.c 	if (unlikely(!sg_len))
sg_len            827 drivers/dma/txx9dmac.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len             54 drivers/dma/uniphier-mdmac.c 	unsigned int sg_len;
sg_len            209 drivers/dma/uniphier-mdmac.c 	if (md->sg_cur >= md->sg_len) {
sg_len            231 drivers/dma/uniphier-mdmac.c 			     unsigned int sg_len,
sg_len            246 drivers/dma/uniphier-mdmac.c 	md->sg_len = sg_len;
sg_len            319 drivers/dma/uniphier-mdmac.c 		for (i = md->sg_cur; i < md->sg_len; i++)
sg_len           1776 drivers/dma/xilinx/xilinx_dma.c 	struct dma_chan *dchan, struct scatterlist *sgl, unsigned int sg_len,
sg_len           1801 drivers/dma/xilinx/xilinx_dma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            161 drivers/i2c/busses/i2c-at91-master.c 	unsigned int sg_len = 1;
sg_len            183 drivers/i2c/busses/i2c-at91-master.c 		sg_len = 0;
sg_len            187 drivers/i2c/busses/i2c-at91-master.c 			sg = &dma->sg[sg_len++];
sg_len            194 drivers/i2c/busses/i2c-at91-master.c 			sg = &dma->sg[sg_len++];
sg_len            212 drivers/i2c/busses/i2c-at91-master.c 	txdesc = dmaengine_prep_slave_sg(chan_tx, dma->sg, sg_len,
sg_len            679 drivers/media/platform/pxa_camera.c 	int				sg_len[3];
sg_len           1365 drivers/media/platform/pxa_camera.c 		buf->sg_len[i] = 0;
sg_len           1395 drivers/media/platform/pxa_camera.c 		       buf->plane_sizes, buf->sg, buf->sg_len, GFP_KERNEL);
sg_len           1403 drivers/media/platform/pxa_camera.c 					   buf->sg[i], buf->sg_len[i]);
sg_len            524 drivers/mmc/core/block.c 		data.sg_len = 1;
sg_len            935 drivers/mmc/core/block.c 	data.sg_len = 1;
sg_len           1384 drivers/mmc/core/block.c 	brq->data.sg_len = mmc_queue_map_sg(mq, mqrq);
sg_len           1394 drivers/mmc/core/block.c 		for_each_sg(brq->data.sg, sg, brq->data.sg_len, i) {
sg_len           1402 drivers/mmc/core/block.c 		brq->data.sg_len = i;
sg_len            318 drivers/mmc/core/core.c 		for_each_sg(mrq->data->sg, sg, mrq->data->sg_len, i)
sg_len            273 drivers/mmc/core/mmc_ops.c 	data.sg_len = 1;
sg_len            653 drivers/mmc/core/mmc_ops.c 	data.sg_len = 1;
sg_len            760 drivers/mmc/core/mmc_ops.c 	data.sg_len = 1;
sg_len             82 drivers/mmc/core/mmc_test.c 	unsigned int sg_len;
sg_len            161 drivers/mmc/core/mmc_test.c 	unsigned int *sg_len;
sg_len            209 drivers/mmc/core/mmc_test.c 	struct mmc_request *mrq, struct scatterlist *sg, unsigned sg_len,
sg_len            241 drivers/mmc/core/mmc_test.c 	mrq->data->sg_len = sg_len;
sg_len            410 drivers/mmc/core/mmc_test.c 			   unsigned int *sg_len, int min_sg_len)
sg_len            420 drivers/mmc/core/mmc_test.c 	*sg_len = 0;
sg_len            439 drivers/mmc/core/mmc_test.c 			*sg_len += 1;
sg_len            463 drivers/mmc/core/mmc_test.c 				       unsigned int *sg_len)
sg_len            472 drivers/mmc/core/mmc_test.c 	*sg_len = 0;
sg_len            494 drivers/mmc/core/mmc_test.c 			*sg_len += 1;
sg_len            601 drivers/mmc/core/mmc_test.c 			 test->area.sg_len);
sg_len            839 drivers/mmc/core/mmc_test.c 				      struct scatterlist *sg, unsigned sg_len,
sg_len            860 drivers/mmc/core/mmc_test.c 		mmc_test_prepare_mrq(test, mrq, sg, sg_len, dev_addr, blocks,
sg_len            884 drivers/mmc/core/mmc_test.c 	struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
sg_len            896 drivers/mmc/core/mmc_test.c 	mmc_test_prepare_mrq(test, &mrq, sg, sg_len, dev_addr,
sg_len            941 drivers/mmc/core/mmc_test.c 	struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
sg_len            954 drivers/mmc/core/mmc_test.c 	sg_copy_from_buffer(sg, sg_len, test->scratch, BUFFER_SIZE);
sg_len            961 drivers/mmc/core/mmc_test.c 	ret = mmc_test_simple_transfer(test, sg, sg_len, dev_addr,
sg_len           1001 drivers/mmc/core/mmc_test.c 		sg_copy_to_buffer(sg, sg_len, test->scratch, BUFFER_SIZE);
sg_len           1409 drivers/mmc/core/mmc_test.c 				       &t->sg_len);
sg_len           1412 drivers/mmc/core/mmc_test.c 				      t->max_seg_sz, &t->sg_len, min_sg_len);
sg_len           1428 drivers/mmc/core/mmc_test.c 	return mmc_test_simple_transfer(test, t->sg, t->sg_len, dev_addr,
sg_len           1468 drivers/mmc/core/mmc_test.c 		ret = mmc_test_nonblock_transfer(test, t->sg, t->sg_len,
sg_len           2150 drivers/mmc/core/mmc_test.c 					   rw->sg_len[i]);
sg_len           2238 drivers/mmc/core/mmc_test.c 	unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6,
sg_len           2241 drivers/mmc/core/mmc_test.c 		.sg_len = sg_len,
sg_len           2243 drivers/mmc/core/mmc_test.c 		.len = ARRAY_SIZE(sg_len),
sg_len           2257 drivers/mmc/core/mmc_test.c 	unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6,
sg_len           2260 drivers/mmc/core/mmc_test.c 		.sg_len = sg_len,
sg_len           2262 drivers/mmc/core/mmc_test.c 		.len = ARRAY_SIZE(sg_len),
sg_len           2276 drivers/mmc/core/mmc_test.c 	unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6,
sg_len           2279 drivers/mmc/core/mmc_test.c 		.sg_len = sg_len,
sg_len           2281 drivers/mmc/core/mmc_test.c 		.len = ARRAY_SIZE(sg_len),
sg_len           2295 drivers/mmc/core/mmc_test.c 	unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6,
sg_len           2298 drivers/mmc/core/mmc_test.c 		.sg_len = sg_len,
sg_len           2300 drivers/mmc/core/mmc_test.c 		.len = ARRAY_SIZE(sg_len),
sg_len           2369 drivers/mmc/core/mmc_test.c 	mmc_test_prepare_mrq(test, mrq, t->sg, t->sg_len, dev_addr, t->blocks,
sg_len            162 drivers/mmc/core/queue.c static struct scatterlist *mmc_alloc_sg(int sg_len, gfp_t gfp)
sg_len            166 drivers/mmc/core/queue.c 	sg = kmalloc_array(sg_len, sizeof(*sg), gfp);
sg_len            168 drivers/mmc/core/queue.c 		sg_init_table(sg, sg_len);
sg_len            243 drivers/mmc/core/sd_ops.c 	data.sg_len = 1;
sg_len            290 drivers/mmc/core/sd_ops.c 	data.sg_len = 1;
sg_len            331 drivers/mmc/core/sd_ops.c 	data.sg_len = 1;
sg_len            157 drivers/mmc/core/sdio_ops.c 		data.sg_len = nents;
sg_len            159 drivers/mmc/core/sdio_ops.c 		for_each_sg(data.sg, sg_ptr, data.sg_len, i) {
sg_len            166 drivers/mmc/core/sdio_ops.c 		data.sg_len = 1;
sg_len            235 drivers/mmc/host/alcor.c 	sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags);
sg_len            782 drivers/mmc/host/alcor.c 	unsigned int i, sg_len;
sg_len            808 drivers/mmc/host/alcor.c 	for_each_sg(data->sg, sg, data->sg_len, i) {
sg_len            817 drivers/mmc/host/alcor.c 	sg_len = dma_map_sg(host->dev, data->sg, data->sg_len,
sg_len            819 drivers/mmc/host/alcor.c 	if (sg_len)
sg_len            822 drivers/mmc/host/alcor.c 	data->sg_count = sg_len;
sg_len            838 drivers/mmc/host/alcor.c 			     data->sg_len,
sg_len            121 drivers/mmc/host/android-goldfish.c 	unsigned int		sg_len;
sg_len            221 drivers/mmc/host/android-goldfish.c 			     host->sg_len, dma_data_dir);
sg_len            225 drivers/mmc/host/android-goldfish.c 	host->sg_len = 0;
sg_len            359 drivers/mmc/host/android-goldfish.c 	unsigned sg_len;
sg_len            379 drivers/mmc/host/android-goldfish.c 	sg_len = (data->blocks == 1) ? 1 : data->sg_len;
sg_len            383 drivers/mmc/host/android-goldfish.c 	host->sg_len = dma_map_sg(mmc_dev(mmc_from_priv(host)), data->sg,
sg_len            384 drivers/mmc/host/android-goldfish.c 				  sg_len, dma_data_dir);
sg_len            308 drivers/mmc/host/atmel-mci.c 	unsigned int		sg_len;
sg_len            900 drivers/mmc/host/atmel-mci.c 				data->sg, data->sg_len,
sg_len            921 drivers/mmc/host/atmel-mci.c 		sg_copy_from_buffer(host->data->sg, host->data->sg_len,
sg_len            938 drivers/mmc/host/atmel-mci.c 				data->sg, data->sg_len,
sg_len           1003 drivers/mmc/host/atmel-mci.c 	host->sg_len = data->sg_len;
sg_len           1063 drivers/mmc/host/atmel-mci.c 	dma_map_sg(&host->pdev->dev, data->sg, data->sg_len,
sg_len           1068 drivers/mmc/host/atmel-mci.c 		sg_copy_to_buffer(host->data->sg, host->data->sg_len,
sg_len           1111 drivers/mmc/host/atmel-mci.c 	for_each_sg(data->sg, sg, data->sg_len, i) {
sg_len           1139 drivers/mmc/host/atmel-mci.c 			data->sg_len, mmc_get_dma_dir(data));
sg_len           1154 drivers/mmc/host/atmel-mci.c 	dma_unmap_sg(chan->device->dev, data->sg, data->sg_len,
sg_len           1943 drivers/mmc/host/atmel-mci.c 				host->sg_len--;
sg_len           1944 drivers/mmc/host/atmel-mci.c 				if (!sg || !host->sg_len)
sg_len           1957 drivers/mmc/host/atmel-mci.c 			host->sg_len--;
sg_len           1958 drivers/mmc/host/atmel-mci.c 			if (!sg || !host->sg_len)
sg_len           2008 drivers/mmc/host/atmel-mci.c 				host->sg_len--;
sg_len           2009 drivers/mmc/host/atmel-mci.c 				if (!sg || !host->sg_len)
sg_len           2022 drivers/mmc/host/atmel-mci.c 			host->sg_len--;
sg_len           2023 drivers/mmc/host/atmel-mci.c 			if (!sg || !host->sg_len) {
sg_len            352 drivers/mmc/host/au1xmmc.c 	dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len, host->dma.dir);
sg_len            395 drivers/mmc/host/au1xmmc.c 	int sg_len, max, count;
sg_len            410 drivers/mmc/host/au1xmmc.c 	sg_len = data->sg[host->pio.index].length - host->pio.offset;
sg_len            413 drivers/mmc/host/au1xmmc.c 	max = (sg_len > host->pio.len) ? host->pio.len : sg_len;
sg_len            433 drivers/mmc/host/au1xmmc.c 	if (count == sg_len) {
sg_len            451 drivers/mmc/host/au1xmmc.c 	int max, count, sg_len = 0;
sg_len            468 drivers/mmc/host/au1xmmc.c 		sg_len = sg_dma_len(&data->sg[host->pio.index]) - host->pio.offset;
sg_len            471 drivers/mmc/host/au1xmmc.c 		if (sg_len < max)
sg_len            472 drivers/mmc/host/au1xmmc.c 			max = sg_len;
sg_len            512 drivers/mmc/host/au1xmmc.c 	if (sg_len && count == sg_len) {
sg_len            633 drivers/mmc/host/au1xmmc.c 				   data->sg_len, host->dma.dir);
sg_len            649 drivers/mmc/host/au1xmmc.c 			int sg_len = sg->length;
sg_len            651 drivers/mmc/host/au1xmmc.c 			int len = (datalen > sg_len) ? sg_len : datalen;
sg_len            684 drivers/mmc/host/au1xmmc.c 	dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
sg_len            455 drivers/mmc/host/bcm2835.c 	int sg_len, dir_data, dir_slave;
sg_len            484 drivers/mmc/host/bcm2835.c 		for_each_sg(data->sg, sg, data->sg_len, i) {
sg_len            501 drivers/mmc/host/bcm2835.c 	sg_len = dma_map_sg(dma_chan->device->dev, data->sg, data->sg_len,
sg_len            503 drivers/mmc/host/bcm2835.c 	if (!sg_len)
sg_len            506 drivers/mmc/host/bcm2835.c 	desc = dmaengine_prep_slave_sg(dma_chan, data->sg, sg_len, dir_slave,
sg_len            510 drivers/mmc/host/bcm2835.c 		dma_unmap_sg(dma_chan->device->dev, data->sg, sg_len, dir_data);
sg_len            566 drivers/mmc/host/bcm2835.c 		sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags);
sg_len           1064 drivers/mmc/host/bcm2835.c 			     data->sg, data->sg_len,
sg_len            377 drivers/mmc/host/cavium.c 	dma_unmap_sg(host->dev, data->sg, data->sg_len, get_dma_dir(data));
sg_len            397 drivers/mmc/host/cavium.c 	dma_unmap_sg(host->dev, data->sg, data->sg_len, get_dma_dir(data));
sg_len            403 drivers/mmc/host/cavium.c 	if (host->use_sg && data->sg_len > 1)
sg_len            522 drivers/mmc/host/cavium.c 	count = dma_map_sg(host->dev, data->sg, data->sg_len,
sg_len            559 drivers/mmc/host/cavium.c 	count = dma_map_sg(host->dev, data->sg, data->sg_len,
sg_len            612 drivers/mmc/host/cavium.c 	dma_unmap_sg(host->dev, data->sg, data->sg_len, get_dma_dir(data));
sg_len            620 drivers/mmc/host/cavium.c 	if (host->use_sg && data->sg_len > 1)
sg_len            658 drivers/mmc/host/cavium.c 	if (!mrq->data || !mrq->data->sg || !mrq->data->sg_len ||
sg_len            711 drivers/mmc/host/cavium.c 	sg_miter_start(&host->smi, mrq->data->sg, mrq->data->sg_len,
sg_len            724 drivers/mmc/host/cavium.c 	sg_miter_start(smi, mrq->data->sg, mrq->data->sg_len, SG_MITER_FROM_SG);
sg_len            274 drivers/mmc/host/cb710-mmc.c 	sg_miter_start(&miter, data->sg, data->sg_len, SG_MITER_TO_SG);
sg_len            318 drivers/mmc/host/cb710-mmc.c 	sg_miter_start(&miter, data->sg, data->sg_len, SG_MITER_FROM_SG);
sg_len            432 drivers/mmc/host/cqhci.c 			      data->sg_len,
sg_len            436 drivers/mmc/host/cqhci.c 		pr_err("%s: sg-len: %d\n", __func__, data->sg_len);
sg_len            547 drivers/mmc/host/cqhci.c 		dma_unmap_sg(mmc_dev(host), data->sg, data->sg_len,
sg_len            200 drivers/mmc/host/davinci_mmc.c 	unsigned int		sg_len;
sg_len            420 drivers/mmc/host/davinci_mmc.c 				host->sg_len,
sg_len            442 drivers/mmc/host/davinci_mmc.c 				host->sg_len,
sg_len            467 drivers/mmc/host/davinci_mmc.c 	host->sg_len = dma_map_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
sg_len            471 drivers/mmc/host/davinci_mmc.c 	for (i = 0; i < host->sg_len; i++) {
sg_len            474 drivers/mmc/host/davinci_mmc.c 				     data->sg, data->sg_len,
sg_len            579 drivers/mmc/host/davinci_mmc.c 		host->sg_len = data->sg_len;
sg_len            786 drivers/mmc/host/davinci_mmc.c 		dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
sg_len            438 drivers/mmc/host/dw_mmc.c 			     data->sg_len,
sg_len            481 drivers/mmc/host/dw_mmc.c 				    data->sg_len,
sg_len            576 drivers/mmc/host/dw_mmc.c 					 unsigned int sg_len)
sg_len            585 drivers/mmc/host/dw_mmc.c 	for (i = 0; i < sg_len; i++) {
sg_len            648 drivers/mmc/host/dw_mmc.c 					 unsigned int sg_len)
sg_len            657 drivers/mmc/host/dw_mmc.c 	for (i = 0; i < sg_len; i++) {
sg_len            719 drivers/mmc/host/dw_mmc.c static int dw_mci_idmac_start_dma(struct dw_mci *host, unsigned int sg_len)
sg_len            725 drivers/mmc/host/dw_mmc.c 		ret = dw_mci_prepare_desc64(host, host->data, sg_len);
sg_len            727 drivers/mmc/host/dw_mmc.c 		ret = dw_mci_prepare_desc32(host, host->data, sg_len);
sg_len            773 drivers/mmc/host/dw_mmc.c 					    unsigned int sg_len)
sg_len            779 drivers/mmc/host/dw_mmc.c 	u32 sg_elems = host->data->sg_len;
sg_len            807 drivers/mmc/host/dw_mmc.c 				       sg_len, cfg.direction,
sg_len            873 drivers/mmc/host/dw_mmc.c 	unsigned int i, sg_len;
sg_len            876 drivers/mmc/host/dw_mmc.c 		return data->sg_len;
sg_len            889 drivers/mmc/host/dw_mmc.c 	for_each_sg(data->sg, sg, data->sg_len, i) {
sg_len            894 drivers/mmc/host/dw_mmc.c 	sg_len = dma_map_sg(host->dev,
sg_len            896 drivers/mmc/host/dw_mmc.c 			    data->sg_len,
sg_len            898 drivers/mmc/host/dw_mmc.c 	if (sg_len == 0)
sg_len            903 drivers/mmc/host/dw_mmc.c 	return sg_len;
sg_len            936 drivers/mmc/host/dw_mmc.c 			     data->sg_len,
sg_len           1077 drivers/mmc/host/dw_mmc.c 	int sg_len;
sg_len           1086 drivers/mmc/host/dw_mmc.c 	sg_len = dw_mci_pre_dma_transfer(host, data, COOKIE_MAPPED);
sg_len           1087 drivers/mmc/host/dw_mmc.c 	if (sg_len < 0) {
sg_len           1089 drivers/mmc/host/dw_mmc.c 		return sg_len;
sg_len           1099 drivers/mmc/host/dw_mmc.c 			 sg_len);
sg_len           1121 drivers/mmc/host/dw_mmc.c 	if (host->dma_ops->start(host, sg_len)) {
sg_len           1158 drivers/mmc/host/dw_mmc.c 		sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags);
sg_len            239 drivers/mmc/host/dw_mmc.h 	int (*start)(struct dw_mci *host, unsigned int sg_len);
sg_len            242 drivers/mmc/host/jz4740_mmc.c 	dma_unmap_sg(chan->device->dev, data->sg, data->sg_len, dir);
sg_len            262 drivers/mmc/host/jz4740_mmc.c 			data->sg_len,
sg_len            705 drivers/mmc/host/jz4740_mmc.c 	sg_miter_start(&host->miter, data->sg, data->sg_len, direction);
sg_len            250 drivers/mmc/host/meson-gx-mmc.c 	for_each_sg(data->sg, sg, data->sg_len, i)
sg_len            286 drivers/mmc/host/meson-gx-mmc.c 	data->sg_count = dma_map_sg(mmc_dev(mmc), data->sg, data->sg_len,
sg_len            298 drivers/mmc/host/meson-gx-mmc.c 		dma_unmap_sg(mmc_dev(mmc), data->sg, data->sg_len,
sg_len            783 drivers/mmc/host/meson-gx-mmc.c 			sg_copy_to_buffer(data->sg, data->sg_len,
sg_len            953 drivers/mmc/host/meson-gx-mmc.c 		sg_copy_from_buffer(data->sg, data->sg_len,
sg_len            324 drivers/mmc/host/meson-mx-sdio.c 	dma_len = dma_map_sg(mmc_dev(mmc), data->sg, data->sg_len,
sg_len            451 drivers/mmc/host/meson-mx-sdio.c 				cmd->data->sg_len,
sg_len            894 drivers/mmc/host/mmc_spi.c 	for_each_sg(data->sg, sg, data->sg_len, n_sg) {
sg_len            516 drivers/mmc/host/mmci.c 		 data->sg_len, data->blksz, data->blocks, data->flags);
sg_len            600 drivers/mmc/host/mmci.c 	sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags);
sg_len            721 drivers/mmc/host/mmci.c 	dma_unmap_sg(chan->device->dev, data->sg, data->sg_len,
sg_len            826 drivers/mmc/host/mmci.c 	nr_sg = dma_map_sg(device->dev, data->sg, data->sg_len,
sg_len            846 drivers/mmc/host/mmci.c 	dma_unmap_sg(device->dev, data->sg, data->sg_len,
sg_len             38 drivers/mmc/host/mmci_stm32_sdmmc.c 	for_each_sg(data->sg, sg, data->sg_len - 1, i) {
sg_len             65 drivers/mmc/host/mmci_stm32_sdmmc.c 			    data->sg_len,
sg_len             89 drivers/mmc/host/mmci_stm32_sdmmc.c 	dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
sg_len            132 drivers/mmc/host/mmci_stm32_sdmmc.c 	if (!host->variant->dma_lli || data->sg_len == 1) {
sg_len            140 drivers/mmc/host/mmci_stm32_sdmmc.c 	for_each_sg(data->sg, sg, data->sg_len, i) {
sg_len            149 drivers/mmc/host/mmci_stm32_sdmmc.c 	desc[data->sg_len - 1].idmalar &= ~MMCI_STM32_ULA;
sg_len            155 drivers/mmc/host/moxart-mmc.c 	host->num_sg = data->sg_len;
sg_len            276 drivers/mmc/host/moxart-mmc.c 			 data->sg_len, mmc_get_dma_dir(data));
sg_len            301 drivers/mmc/host/moxart-mmc.c 		     data->sg, data->sg_len,
sg_len            683 drivers/mmc/host/mtk-sd.c 		data->sg_count = dma_map_sg(host->dev, data->sg, data->sg_len,
sg_len            696 drivers/mmc/host/mtk-sd.c 		dma_unmap_sg(host->dev, data->sg, data->sg_len,
sg_len            127 drivers/mmc/host/mvsdio.c 					    data->sg, data->sg_len,
sg_len            289 drivers/mmc/host/mxcmmc.c 	for_each_sg(data->sg, sg, data->sg_len, i)
sg_len            315 drivers/mmc/host/mxcmmc.c 	for_each_sg(data->sg, sg, data->sg_len, i) {
sg_len            333 drivers/mmc/host/mxcmmc.c 				     data->sg_len,  host->dma_dir);
sg_len            334 drivers/mmc/host/mxcmmc.c 	if (nents != data->sg_len)
sg_len            338 drivers/mmc/host/mxcmmc.c 		data->sg, data->sg_len, slave_dirn,
sg_len            342 drivers/mmc/host/mxcmmc.c 		dma_unmap_sg(host->dma->device->dev, data->sg, data->sg_len,
sg_len            452 drivers/mmc/host/mxcmmc.c 		dma_unmap_sg(host->dma->device->dev, data->sg, data->sg_len,
sg_len            613 drivers/mmc/host/mxcmmc.c 		for_each_sg(data->sg, sg, data->sg_len, i) {
sg_len            620 drivers/mmc/host/mxcmmc.c 		for_each_sg(data->sg, sg, data->sg_len, i) {
sg_len            148 drivers/mmc/host/mxs-mmc.c 			     data->sg_len, ssp->dma_dir);
sg_len            221 drivers/mmc/host/mxs-mmc.c 	unsigned int sg_len;
sg_len            226 drivers/mmc/host/mxs-mmc.c 			   data->sg_len, ssp->dma_dir);
sg_len            228 drivers/mmc/host/mxs-mmc.c 		sg_len = data->sg_len;
sg_len            232 drivers/mmc/host/mxs-mmc.c 		sg_len = SSP_PIO_NUM;
sg_len            236 drivers/mmc/host/mxs-mmc.c 				sgl, sg_len, ssp->slave_dirn, flags);
sg_len            243 drivers/mmc/host/mxs-mmc.c 				     data->sg_len, ssp->dma_dir);
sg_len            350 drivers/mmc/host/mxs-mmc.c 	unsigned int sg_len = data->sg_len;
sg_len            395 drivers/mmc/host/mxs-mmc.c 	for_each_sg(sgl, sg, sg_len, i)
sg_len            146 drivers/mmc/host/omap.c 	unsigned int		sg_len;
sg_len            424 drivers/mmc/host/omap.c 	dma_unmap_sg(dev, data->sg, host->sg_len, dma_data_dir);
sg_len            448 drivers/mmc/host/omap.c 	host->sg_len = 0;
sg_len            505 drivers/mmc/host/omap.c 	host->sg_len = 0;
sg_len            670 drivers/mmc/host/omap.c 		BUG_ON(host->sg_idx == host->sg_len);
sg_len            949 drivers/mmc/host/omap.c 	unsigned sg_len;
sg_len            970 drivers/mmc/host/omap.c 	sg_len = (data->blocks == 1) ? 1 : data->sg_len;
sg_len            973 drivers/mmc/host/omap.c 	for_each_sg(data->sg, sg, sg_len, i) {
sg_len           1034 drivers/mmc/host/omap.c 		host->sg_len = dma_map_sg(c->device->dev, data->sg, sg_len,
sg_len           1036 drivers/mmc/host/omap.c 		if (host->sg_len == 0)
sg_len           1039 drivers/mmc/host/omap.c 		tx = dmaengine_prep_slave_sg(c, data->sg, host->sg_len,
sg_len           1060 drivers/mmc/host/omap.c 	host->sg_len = sg_len;
sg_len            925 drivers/mmc/host/omap_hsmmc.c 			host->data->sg, host->data->sg_len,
sg_len           1182 drivers/mmc/host/omap_hsmmc.c 			     data->sg, data->sg_len,
sg_len           1215 drivers/mmc/host/omap_hsmmc.c 		dma_len = dma_map_sg(chan->device->dev, data->sg, data->sg_len,
sg_len           1256 drivers/mmc/host/omap_hsmmc.c 	for (i = 0; i < data->sg_len; i++) {
sg_len           1281 drivers/mmc/host/omap_hsmmc.c 	tx = dmaengine_prep_slave_sg(chan, data->sg, data->sg_len,
sg_len           1401 drivers/mmc/host/omap_hsmmc.c 		dma_unmap_sg(c->device->dev, data->sg, data->sg_len,
sg_len            206 drivers/mmc/host/pxamci.c 	host->dma_len = dma_map_sg(chan->device->dev, data->sg, data->sg_len,
sg_len            343 drivers/mmc/host/pxamci.c 		     data->sg, data->sg_len, host->dma_dir);
sg_len            185 drivers/mmc/host/renesas_sdhi_internal_dmac.c 	if (!dma_map_sg(&host->pdev->dev, sg, host->sg_len,
sg_len            215 drivers/mmc/host/renesas_sdhi_internal_dmac.c 	dma_unmap_sg(&host->pdev->dev, sg, host->sg_len, mmc_get_dma_dir(data));
sg_len            248 drivers/mmc/host/renesas_sdhi_internal_dmac.c 	dma_unmap_sg(&host->pdev->dev, host->sg_ptr, host->sg_len, dir);
sg_len            135 drivers/mmc/host/renesas_sdhi_sys_dmac.c 			     host->sg_ptr, host->sg_len,
sg_len            139 drivers/mmc/host/renesas_sdhi_sys_dmac.c 			     host->sg_ptr, host->sg_len,
sg_len            163 drivers/mmc/host/renesas_sdhi_sys_dmac.c 	for_each_sg(sg, sg_tmp, host->sg_len, i) {
sg_len            172 drivers/mmc/host/renesas_sdhi_sys_dmac.c 	if ((!aligned && (host->sg_len > 1 || sg->length > PAGE_SIZE ||
sg_len            188 drivers/mmc/host/renesas_sdhi_sys_dmac.c 	ret = dma_map_sg(chan->device->dev, sg, host->sg_len, DMA_FROM_DEVICE);
sg_len            235 drivers/mmc/host/renesas_sdhi_sys_dmac.c 	for_each_sg(sg, sg_tmp, host->sg_len, i) {
sg_len            244 drivers/mmc/host/renesas_sdhi_sys_dmac.c 	if ((!aligned && (host->sg_len > 1 || sg->length > PAGE_SIZE ||
sg_len            265 drivers/mmc/host/renesas_sdhi_sys_dmac.c 	ret = dma_map_sg(chan->device->dev, sg, host->sg_len, DMA_TO_DEVICE);
sg_len            163 drivers/mmc/host/rtsx_pci_sdmmc.c 		count = rtsx_pci_dma_map_sg(pcr, data->sg, data->sg_len, read);
sg_len            205 drivers/mmc/host/rtsx_pci_sdmmc.c 	rtsx_pci_dma_unmap_sg(pcr, data->sg, data->sg_len, read);
sg_len            594 drivers/mmc/host/rtsx_pci_sdmmc.c 		sg_copy_from_buffer(data->sg, data->sg_len, buf, data->blksz);
sg_len            596 drivers/mmc/host/rtsx_pci_sdmmc.c 		sg_copy_to_buffer(data->sg, data->sg_len, buf, data->blksz);
sg_len            522 drivers/mmc/host/rtsx_usb_sdmmc.c 			data->sg_len,  NULL, 10000);
sg_len            568 drivers/mmc/host/rtsx_usb_sdmmc.c 		sg_copy_from_buffer(data->sg, data->sg_len, buf, data->blksz);
sg_len            570 drivers/mmc/host/rtsx_usb_sdmmc.c 		sg_copy_to_buffer(data->sg, data->sg_len, buf, data->blksz);
sg_len            328 drivers/mmc/host/s3cmci.c 	if (host->pio_sgptr >= host->mrq->data->sg_len) {
sg_len            330 drivers/mmc/host/s3cmci.c 		      host->pio_sgptr, host->mrq->data->sg_len);
sg_len            341 drivers/mmc/host/s3cmci.c 	    host->pio_sgptr, host->mrq->data->sg_len);
sg_len           1091 drivers/mmc/host/s3cmci.c 	dma_map_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
sg_len           1095 drivers/mmc/host/s3cmci.c 	desc = dmaengine_prep_slave_sg(host->dma, data->sg, data->sg_len,
sg_len           1108 drivers/mmc/host/s3cmci.c 	dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
sg_len            624 drivers/mmc/host/sdhci.c 			sg_copy_to_buffer(data->sg, data->sg_len,
sg_len            638 drivers/mmc/host/sdhci.c 				      data->sg, data->sg_len,
sg_len            799 drivers/mmc/host/sdhci.c 					    data->sg_len, DMA_FROM_DEVICE);
sg_len           1077 drivers/mmc/host/sdhci.c 			for_each_sg(data->sg, sg, data->sg_len, i) {
sg_len           1122 drivers/mmc/host/sdhci.c 		sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags);
sg_len           2542 drivers/mmc/host/sdhci.c 		dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
sg_len           2679 drivers/mmc/host/sdhci.c 						data->sg_len,
sg_len           2693 drivers/mmc/host/sdhci.c 					     data->sg_len,
sg_len            298 drivers/mmc/host/sdricoh_cs.c 			data->sg_len, data->sg->length);
sg_len            297 drivers/mmc/host/sh_mmcif.c 	ret = dma_map_sg(chan->device->dev, sg, data->sg_len,
sg_len            313 drivers/mmc/host/sh_mmcif.c 		__func__, data->sg_len, ret, cookie);
sg_len            334 drivers/mmc/host/sh_mmcif.c 		desc, cookie, data->sg_len);
sg_len            347 drivers/mmc/host/sh_mmcif.c 	ret = dma_map_sg(chan->device->dev, sg, data->sg_len,
sg_len            363 drivers/mmc/host/sh_mmcif.c 		__func__, data->sg_len, ret, cookie);
sg_len            609 drivers/mmc/host/sh_mmcif.c 		if (++host->sg_idx < data->sg_len)
sg_len            615 drivers/mmc/host/sh_mmcif.c 	return host->sg_idx != data->sg_len;
sg_len            658 drivers/mmc/host/sh_mmcif.c 	if (!data->sg_len || !data->sg->length)
sg_len            738 drivers/mmc/host/sh_mmcif.c 	if (!data->sg_len || !data->sg->length)
sg_len           1135 drivers/mmc/host/sh_mmcif.c 			     data->sg, data->sg_len,
sg_len           1139 drivers/mmc/host/sh_mmcif.c 			     data->sg, data->sg_len,
sg_len            364 drivers/mmc/host/sunxi-mmc.c 	for (i = 0; i < data->sg_len; i++) {
sg_len            399 drivers/mmc/host/sunxi-mmc.c 	dma_len = dma_map_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
sg_len            406 drivers/mmc/host/sunxi-mmc.c 	for_each_sg(data->sg, sg, data->sg_len, i) {
sg_len            550 drivers/mmc/host/sunxi-mmc.c 		dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
sg_len           1072 drivers/mmc/host/sunxi-mmc.c 			dma_unmap_sg(mmc_dev(mmc), data->sg, data->sg_len,
sg_len            102 drivers/mmc/host/tifm_sd.c 	int                   sg_len;
sg_len            171 drivers/mmc/host/tifm_sd.c 	if (host->sg_pos == host->sg_len)
sg_len            178 drivers/mmc/host/tifm_sd.c 			if (host->sg_pos == host->sg_len) {
sg_len            234 drivers/mmc/host/tifm_sd.c 			if (host->sg_pos == host->sg_len)
sg_len            267 drivers/mmc/host/tifm_sd.c 	if (host->sg_pos == host->sg_len)
sg_len            275 drivers/mmc/host/tifm_sd.c 		if (host->sg_pos == host->sg_len)
sg_len            283 drivers/mmc/host/tifm_sd.c 		if (host->sg_pos == host->sg_len)
sg_len            663 drivers/mmc/host/tifm_sd.c 			host->sg_len = r_data->sg_len;
sg_len            677 drivers/mmc/host/tifm_sd.c 			host->sg_len = tifm_map_sg(sock, r_data->sg,
sg_len            678 drivers/mmc/host/tifm_sd.c 						   r_data->sg_len,
sg_len            683 drivers/mmc/host/tifm_sd.c 			if (host->sg_len < 1) {
sg_len            764 drivers/mmc/host/tifm_sd.c 			tifm_unmap_sg(sock, r_data->sg, r_data->sg_len,
sg_len            137 drivers/mmc/host/tmio_mmc.h 	unsigned int            sg_len;
sg_len            116 drivers/mmc/host/tmio_mmc_core.c 	host->sg_len = data->sg_len;
sg_len            126 drivers/mmc/host/tmio_mmc_core.c 	return --host->sg_len;
sg_len            488 drivers/mmc/host/toshsd.c 	sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags);
sg_len            101 drivers/mmc/host/uniphier-sd.c 	dma_unmap_sg(mmc_dev(host->mmc), host->sg_ptr, host->sg_len,
sg_len            130 drivers/mmc/host/uniphier-sd.c 	int sg_len;
sg_len            143 drivers/mmc/host/uniphier-sd.c 	sg_len = dma_map_sg(mmc_dev(host->mmc), host->sg_ptr, host->sg_len,
sg_len            145 drivers/mmc/host/uniphier-sd.c 	if (sg_len == 0)
sg_len            148 drivers/mmc/host/uniphier-sd.c 	desc = dmaengine_prep_slave_sg(priv->chan, host->sg_ptr, sg_len,
sg_len            165 drivers/mmc/host/uniphier-sd.c 	dma_unmap_sg(mmc_dev(host->mmc), host->sg_ptr, host->sg_len,
sg_len            253 drivers/mmc/host/uniphier-sd.c 	int sg_len;
sg_len            258 drivers/mmc/host/uniphier-sd.c 	if (WARN_ON(host->sg_len != 1))
sg_len            272 drivers/mmc/host/uniphier-sd.c 	sg_len = dma_map_sg(mmc_dev(host->mmc), sg, 1, priv->dma_dir);
sg_len            273 drivers/mmc/host/uniphier-sd.c 	if (sg_len == 0)
sg_len            320 drivers/mmc/host/usdhi6rol0.c 		__func__, host->mrq->cmd->opcode, data->sg_len,
sg_len            357 drivers/mmc/host/usdhi6rol0.c 	struct scatterlist *sg = data->sg_len > 1 ? host->sg : data->sg;
sg_len            401 drivers/mmc/host/usdhi6rol0.c 		struct scatterlist *sg = data->sg_len > 1 ?
sg_len            543 drivers/mmc/host/usdhi6rol0.c 			     data->sg_len, DMA_FROM_DEVICE);
sg_len            546 drivers/mmc/host/usdhi6rol0.c 			     data->sg_len, DMA_TO_DEVICE);
sg_len            586 drivers/mmc/host/usdhi6rol0.c 	ret = dma_map_sg(chan->device->dev, sg, data->sg_len, data_dir);
sg_len            600 drivers/mmc/host/usdhi6rol0.c 		__func__, data->sg_len, ret, cookie, desc);
sg_len            630 drivers/mmc/host/usdhi6rol0.c 		__func__, data->sg_len, data->blocks, data->blksz);
sg_len            906 drivers/mmc/host/usdhi6rol0.c 		 data ? data->blksz : 0, data ? data->sg_len : 0))
sg_len           1047 drivers/mmc/host/usdhi6rol0.c 				"Bad SG of %u: %ux%u @ %u\n", data->sg_len,
sg_len           1061 drivers/mmc/host/usdhi6rol0.c 			data->sg_len, use_dma ? "DMA" : "PIO",
sg_len           1709 drivers/mmc/host/usdhi6rol0.c 			host->offset, data->blocks, data->blksz, data->sg_len,
sg_len            490 drivers/mmc/host/via-sdmmc.c 	count = dma_map_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
sg_len            634 drivers/mmc/host/via-sdmmc.c 	dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
sg_len           1444 drivers/mmc/host/vub300.c 				     data->sg_len, 0, GFP_KERNEL);
sg_len           1488 drivers/mmc/host/vub300.c 				sg_copy_from_buffer(data->sg, data->sg_len, buf,
sg_len           1513 drivers/mmc/host/vub300.c 		sg_copy_to_buffer(data->sg, data->sg_len,
sg_len           1537 drivers/mmc/host/vub300.c 			sg_copy_to_buffer(data->sg, data->sg_len, buf,
sg_len           1559 drivers/mmc/host/vub300.c 		sg_copy_to_buffer(data->sg, data->sg_len, buf, sizeof(buf));
sg_len           1562 drivers/mmc/host/vub300.c 				     data->sg_len, 0, GFP_KERNEL);
sg_len            241 drivers/mmc/host/wbsd.c 	host->num_sg = data->sg_len;
sg_len            276 drivers/mmc/host/wbsd.c 	for (i = 0; i < data->sg_len; i++)
sg_len            278 drivers/mmc/host/wbsd.c 	sg_copy_to_buffer(data->sg, data->sg_len, host->dma_buffer, len);
sg_len            286 drivers/mmc/host/wbsd.c 	for (i = 0; i < data->sg_len; i++)
sg_len            288 drivers/mmc/host/wbsd.c 	sg_copy_from_buffer(data->sg, data->sg_len, host->dma_buffer, len);
sg_len            304 drivers/mmc/host/wmt-sdmmc.c 			     req->data->sg_len, DMA_TO_DEVICE);
sg_len            307 drivers/mmc/host/wmt-sdmmc.c 			     req->data->sg_len, DMA_FROM_DEVICE);
sg_len            621 drivers/mmc/host/wmt-sdmmc.c 					    req->data->sg_len, DMA_TO_DEVICE);
sg_len            627 drivers/mmc/host/wmt-sdmmc.c 					    req->data->sg_len, DMA_FROM_DEVICE);
sg_len            257 drivers/net/wireless/ath/ath6kl/sdio.c 	data->sg_len = scat_req->scat_entries;
sg_len            342 drivers/net/wireless/broadcom/brcm80211/brcmfmac/bcmsdh.c 	md->sg_len = sg_cnt;
sg_len            623 drivers/rapidio/devices/rio_mport_cdev.c 	tx_data.sg_len = nents;
sg_len            684 drivers/rapidio/devices/tsi721.h 	unsigned int			sg_len;
sg_len            453 drivers/rapidio/devices/tsi721_dma.c 	for_each_sg(desc->sg, sg, desc->sg_len, i) {
sg_len            456 drivers/rapidio/devices/tsi721_dma.c 			bdma_chan->id, i, desc->sg_len,
sg_len            489 drivers/rapidio/devices/tsi721_dma.c 			desc->sg_len -= i;
sg_len            519 drivers/rapidio/devices/tsi721_dma.c 			desc->sg_len = 0;
sg_len            662 drivers/rapidio/devices/tsi721_dma.c 		if (desc->sg_len == 0) {
sg_len            825 drivers/rapidio/devices/tsi721_dma.c 			struct scatterlist *sgl, unsigned int sg_len,
sg_len            835 drivers/rapidio/devices/tsi721_dma.c 	if (!sgl || !sg_len) {
sg_len            876 drivers/rapidio/devices/tsi721_dma.c 		desc->sg_len	= sg_len;
sg_len           1897 drivers/rapidio/rio.c 	return dmaengine_prep_rio_sg(dchan, data->sg, data->sg_len,
sg_len            646 drivers/scsi/a100u2w.c 	scb->sg_len = cpu_to_le32(0);
sg_len            861 drivers/scsi/a100u2w.c 	scb->sg_len = cpu_to_le32(0);
sg_len            873 drivers/scsi/a100u2w.c 		scb->sg_len = cpu_to_le32((u32) (count_sg * 8));
sg_len            880 drivers/scsi/a100u2w.c 		scb->sg_len = cpu_to_le32(0);
sg_len            154 drivers/scsi/a100u2w.h 	u32 sg_len;		/*10 SG list # * 8              */
sg_len           2078 drivers/scsi/be2iscsi/be_main.c 	unsigned int sg_len, index;
sg_len           2093 drivers/scsi/be2iscsi/be_main.c 			sg_len = sg_dma_len(sg);
sg_len           2103 drivers/scsi/be2iscsi/be_main.c 				      sg_len);
sg_len           2104 drivers/scsi/be2iscsi/be_main.c 			sge_len = sg_len;
sg_len           2108 drivers/scsi/be2iscsi/be_main.c 			sg_len = sg_dma_len(sg);
sg_len           2118 drivers/scsi/be2iscsi/be_main.c 				      sg_len);
sg_len           2153 drivers/scsi/be2iscsi/be_main.c 		sg_len = sg_dma_len(sg);
sg_len           2159 drivers/scsi/be2iscsi/be_main.c 		AMAP_SET_BITS(struct amap_iscsi_sge, len, psgl, sg_len);
sg_len           2162 drivers/scsi/be2iscsi/be_main.c 		offset += sg_len;
sg_len           2173 drivers/scsi/be2iscsi/be_main.c 	unsigned int sg_len, index;
sg_len           2188 drivers/scsi/be2iscsi/be_main.c 			sg_len = sg_dma_len(sg);
sg_len           2195 drivers/scsi/be2iscsi/be_main.c 							sg_len);
sg_len           2196 drivers/scsi/be2iscsi/be_main.c 			sge_len = sg_len;
sg_len           2200 drivers/scsi/be2iscsi/be_main.c 			sg_len = sg_dma_len(sg);
sg_len           2207 drivers/scsi/be2iscsi/be_main.c 							sg_len);
sg_len           2241 drivers/scsi/be2iscsi/be_main.c 		sg_len = sg_dma_len(sg);
sg_len           2247 drivers/scsi/be2iscsi/be_main.c 		AMAP_SET_BITS(struct amap_iscsi_sge, len, psgl, sg_len);
sg_len           2250 drivers/scsi/be2iscsi/be_main.c 		offset += sg_len;
sg_len           2493 drivers/scsi/bfa/bfa_fcpim.c 			sge->sg_len = pgdlen;
sg_len           2504 drivers/scsi/bfa/bfa_fcpim.c 			sgpge->sg_len = sg_dma_len(sg);
sg_len           2505 drivers/scsi/bfa/bfa_fcpim.c 			pgcumsz += sgpge->sg_len;
sg_len           2523 drivers/scsi/bfa/bfa_fcpim.c 				sgpge->sg_len = pgcumsz;
sg_len           2529 drivers/scsi/bfa/bfa_fcpim.c 				sgpge->sg_len = pgcumsz;
sg_len           2543 drivers/scsi/bfa/bfa_fcpim.c 	sge->sg_len = pgdlen;
sg_len             57 drivers/scsi/bfa/bfa_ioc.h 	u32	sg_len;
sg_len           3199 drivers/scsi/bfa/bfad_bsg.c 	return sge->sg_len;
sg_len           3221 drivers/scsi/bfa/bfad_bsg.c 	return sge->sg_len;
sg_len           3271 drivers/scsi/bfa/bfad_bsg.c 	sg_table->sg_len = buf_info->size;
sg_len            119 drivers/scsi/bfa/bfi.h 			sg_len:28;
sg_len            121 drivers/scsi/bfa/bfi.h 	u32	sg_len:28,
sg_len             19 drivers/scsi/bnx2fc/bnx2fc_io.c static int bnx2fc_split_bd(struct bnx2fc_cmd *io_req, u64 addr, int sg_len,
sg_len           1619 drivers/scsi/bnx2fc/bnx2fc_io.c static int bnx2fc_split_bd(struct bnx2fc_cmd *io_req, u64 addr, int sg_len,
sg_len           1626 drivers/scsi/bnx2fc/bnx2fc_io.c 	while (sg_len) {
sg_len           1627 drivers/scsi/bnx2fc/bnx2fc_io.c 		if (sg_len >= BNX2FC_BD_SPLIT_SZ)
sg_len           1630 drivers/scsi/bnx2fc/bnx2fc_io.c 			frag_size = sg_len;
sg_len           1638 drivers/scsi/bnx2fc/bnx2fc_io.c 		sg_len -= frag_size;
sg_len           1655 drivers/scsi/bnx2fc/bnx2fc_io.c 	unsigned int sg_len;
sg_len           1667 drivers/scsi/bnx2fc/bnx2fc_io.c 		sg_len = sg_dma_len(sg);
sg_len           1669 drivers/scsi/bnx2fc/bnx2fc_io.c 		if (sg_len > BNX2FC_MAX_BD_LEN) {
sg_len           1670 drivers/scsi/bnx2fc/bnx2fc_io.c 			sg_frags = bnx2fc_split_bd(io_req, addr, sg_len,
sg_len           1677 drivers/scsi/bnx2fc/bnx2fc_io.c 			bd[bd_count].buf_len = (u16)sg_len;
sg_len           1681 drivers/scsi/bnx2fc/bnx2fc_io.c 		byte_count += sg_len;
sg_len            151 drivers/scsi/bnx2i/bnx2i_iscsi.c 	int sg_len;
sg_len            160 drivers/scsi/bnx2i/bnx2i_iscsi.c 		sg_len = sg_dma_len(sg);
sg_len            164 drivers/scsi/bnx2i/bnx2i_iscsi.c 		bd[bd_count].buffer_length = sg_len;
sg_len            169 drivers/scsi/bnx2i/bnx2i_iscsi.c 		byte_count += sg_len;
sg_len            566 drivers/scsi/csiostor/csio_scsi.c 	uint32_t sg_len = 0;
sg_len            571 drivers/scsi/csiostor/csio_scsi.c 		sg_len	= sg_dma_len(sgel);
sg_len            578 drivers/scsi/csiostor/csio_scsi.c 				 sg_addr, sg_len);
sg_len            584 drivers/scsi/csiostor/csio_scsi.c 			((buf_off + sg_len) & (ddp_pagesz - 1))) {
sg_len            587 drivers/scsi/csiostor/csio_scsi.c 				 "(%llx:%d)\n", sg_addr, sg_len);
sg_len           2078 drivers/scsi/gdth.c                     cmdp->u.cache64.sg_lst[i].sg_len = sg_dma_len(sl);
sg_len           2087 drivers/scsi/gdth.c                     cmdp->u.cache.sg_lst[i].sg_len = sg_dma_len(sl);
sg_len           2105 drivers/scsi/gdth.c                cmdp->u.cache64.sg_lst[0].sg_len));
sg_len           2114 drivers/scsi/gdth.c                cmdp->u.cache.sg_lst[0].sg_len));
sg_len           2237 drivers/scsi/gdth.c                     cmdp->u.raw64.sg_lst[i].sg_len = sg_dma_len(sl);
sg_len           2246 drivers/scsi/gdth.c                     cmdp->u.raw.sg_lst[i].sg_len = sg_dma_len(sl);
sg_len           2262 drivers/scsi/gdth.c                    cmdp->u.raw64.sg_lst[0].sg_len));
sg_len           2270 drivers/scsi/gdth.c                    cmdp->u.raw.sg_lst[0].sg_len));
sg_len           3563 drivers/scsi/gdth.c 			gen->command.u.cache64.sg_lst[0].sg_len = gen->data_len;
sg_len           3564 drivers/scsi/gdth.c 			gen->command.u.cache64.sg_lst[1].sg_len = 0;
sg_len           3574 drivers/scsi/gdth.c 			gen->command.u.cache.sg_lst[0].sg_len = gen->data_len;
sg_len           3575 drivers/scsi/gdth.c 			gen->command.u.cache.sg_lst[1].sg_len = 0;
sg_len           3605 drivers/scsi/gdth.c 			gen->command.u.raw64.sg_lst[0].sg_len = gen->data_len;
sg_len           3606 drivers/scsi/gdth.c 			gen->command.u.raw64.sg_lst[1].sg_len = 0;
sg_len           3618 drivers/scsi/gdth.c 			gen->command.u.raw.sg_lst[0].sg_len = gen->data_len;
sg_len           3619 drivers/scsi/gdth.c 			gen->command.u.raw.sg_lst[1].sg_len = 0;
sg_len             35 drivers/scsi/gdth_ioctl.h     u32     sg_len;                         /* length */
sg_len             41 drivers/scsi/gdth_ioctl.h     u32     sg_len;                         /* length */
sg_len            442 drivers/scsi/hisi_sas/hisi_sas.h 	__le32 sg_len;
sg_len            908 drivers/scsi/hisi_sas/hisi_sas_v1_hw.c 	hdr->sg_len = cpu_to_le32(n_elem << CMD_HDR_DATA_SGL_LEN_OFF);
sg_len           1688 drivers/scsi/hisi_sas/hisi_sas_v2_hw.c 	hdr->sg_len = cpu_to_le32(n_elem << CMD_HDR_DATA_SGL_LEN_OFF);
sg_len           1069 drivers/scsi/hisi_sas/hisi_sas_v3_hw.c 	hdr->sg_len |= cpu_to_le32(n_elem << CMD_HDR_DATA_SGL_LEN_OFF);
sg_len           1097 drivers/scsi/hisi_sas/hisi_sas_v3_hw.c 	hdr->sg_len |= cpu_to_le32(n_elem << CMD_HDR_DIF_SGL_LEN_OFF);
sg_len           1813 drivers/scsi/ips.c 	++scb->sg_len;
sg_len           1851 drivers/scsi/ips.c 	scb->sg_len = 0;
sg_len           1920 drivers/scsi/ips.c 	scb->sg_len = 0;
sg_len           2677 drivers/scsi/ips.c                         scb->sg_len = 0;
sg_len           3552 drivers/scsi/ips.c 			if (!scb->sg_len) {
sg_len           3573 drivers/scsi/ips.c 			scb->cmd.basic_io.sg_count = scb->sg_len;
sg_len           3598 drivers/scsi/ips.c 			if (!scb->sg_len) {
sg_len           3619 drivers/scsi/ips.c 			scb->cmd.basic_io.sg_count = scb->sg_len;
sg_len           3734 drivers/scsi/ips.c 			if (!scb->sg_len) {
sg_len           3767 drivers/scsi/ips.c 			tapeDCDB->sg_count = scb->sg_len;
sg_len           3774 drivers/scsi/ips.c 			if (!scb->sg_len) {
sg_len           3806 drivers/scsi/ips.c 			scb->dcdb.sg_count = scb->sg_len;
sg_len           1079 drivers/scsi/ips.h    uint32_t          sg_len;
sg_len           1105 drivers/scsi/ips.h    uint32_t          sg_len;
sg_len            489 drivers/scsi/qedf/qedf_io.c 	u32 sg_len;
sg_len            503 drivers/scsi/qedf/qedf_io.c 		sg_len = (u32)sg_dma_len(sg);
sg_len            505 drivers/scsi/qedf/qedf_io.c 		end_addr = (u64)(addr + sg_len);
sg_len            513 drivers/scsi/qedf/qedf_io.c 		    (i != (sg_count - 1)) && sg_len < QEDF_PAGE_SIZE)
sg_len            518 drivers/scsi/qedf/qedf_io.c 		bd[bd_count].sge_len = cpu_to_le32(sg_len);
sg_len            521 drivers/scsi/qedf/qedf_io.c 		byte_count += sg_len;
sg_len           1805 drivers/scsi/qedi/qedi_fw.c static int qedi_split_bd(struct qedi_cmd *cmd, u64 addr, int sg_len,
sg_len           1813 drivers/scsi/qedi/qedi_fw.c 	while (sg_len) {
sg_len           1818 drivers/scsi/qedi/qedi_fw.c 			frag_size = (sg_len > QEDI_BD_SPLIT_SZ) ? 0 :
sg_len           1819 drivers/scsi/qedi/qedi_fw.c 				    (sg_len % QEDI_BD_SPLIT_SZ);
sg_len           1833 drivers/scsi/qedi/qedi_fw.c 		sg_len -= frag_size;
sg_len           1846 drivers/scsi/qedi/qedi_fw.c 	int sg_len;
sg_len           1862 drivers/scsi/qedi/qedi_fw.c 		sg_len = sg_dma_len(sg);
sg_len           1867 drivers/scsi/qedi/qedi_fw.c 		bd[bd_count].sge_len = (u16)sg_len;
sg_len           1871 drivers/scsi/qedi/qedi_fw.c 			  sg_count, addr, sg_len);
sg_len           1877 drivers/scsi/qedi/qedi_fw.c 		sg_len = sg_dma_len(sg);
sg_len           1879 drivers/scsi/qedi/qedi_fw.c 		end_addr = (addr + sg_len);
sg_len           1906 drivers/scsi/qedi/qedi_fw.c 			  i, sg_len);
sg_len           1908 drivers/scsi/qedi/qedi_fw.c 		if (sg_len > QEDI_BD_SPLIT_SZ) {
sg_len           1909 drivers/scsi/qedi/qedi_fw.c 			sg_frags = qedi_split_bd(cmd, addr, sg_len, bd_count);
sg_len           1914 drivers/scsi/qedi/qedi_fw.c 			bd[bd_count].sge_len = sg_len;
sg_len           1916 drivers/scsi/qedi/qedi_fw.c 		byte_count += sg_len;
sg_len            849 drivers/scsi/qla2xxx/qla_iocb.c 	uint32_t cumulative_partial, sg_len;
sg_len            859 drivers/scsi/qla2xxx/qla_iocb.c 	sg_len = sg_dma_len(sg);
sg_len            863 drivers/scsi/qla2xxx/qla_iocb.c 	if ((cumulative_partial + (sg_len - sgx->bytes_consumed)) >= blk_sz) {
sg_len            869 drivers/scsi/qla2xxx/qla_iocb.c 		sgx->dma_len = sg_len - sgx->bytes_consumed;
sg_len            876 drivers/scsi/qla2xxx/qla_iocb.c 	if (sg_len == sgx->bytes_consumed) {
sg_len           2860 drivers/scsi/scsi_lib.c 	size_t sg_len = 0, len_complete = 0;
sg_len           2867 drivers/scsi/scsi_lib.c 		len_complete = sg_len; /* Complete sg-entries */
sg_len           2868 drivers/scsi/scsi_lib.c 		sg_len += sg->length;
sg_len           2869 drivers/scsi/scsi_lib.c 		if (sg_len > *offset)
sg_len           2876 drivers/scsi/scsi_lib.c 		       __func__, sg_len, *offset, sg_count);
sg_len           2889 drivers/scsi/scsi_lib.c 	sg_len = PAGE_SIZE - *offset;
sg_len           2890 drivers/scsi/scsi_lib.c 	if (*len > sg_len)
sg_len           2891 drivers/scsi/scsi_lib.c 		*len = sg_len;
sg_len            263 drivers/staging/greybus/sdio.c 	unsigned int sg_len = data->sg_len;
sg_len            282 drivers/staging/greybus/sdio.c 	copied = sg_pcopy_to_buffer(sg, sg_len, &request->data[0], len, skip);
sg_len            317 drivers/staging/greybus/sdio.c 	unsigned int sg_len = data->sg_len;
sg_len            351 drivers/staging/greybus/sdio.c 	copied = sg_pcopy_from_buffer(sg, sg_len, &response->data[0], len,
sg_len            515 drivers/staging/ralink-gdma/ralink-gdma.c 		unsigned int sg_len, enum dma_transfer_direction direction,
sg_len            523 drivers/staging/ralink-gdma/ralink-gdma.c 	desc = kzalloc(struct_size(desc, sg, sg_len), GFP_ATOMIC);
sg_len            530 drivers/staging/ralink-gdma/ralink-gdma.c 	for_each_sg(sgl, sg, sg_len, i) {
sg_len            550 drivers/staging/ralink-gdma/ralink-gdma.c 	desc->num_sgs = sg_len;
sg_len            934 drivers/tty/serial/atmel_serial.c 	unsigned int tx_len, part1_len, part2_len, sg_len;
sg_len            966 drivers/tty/serial/atmel_serial.c 		sg_len = 0;
sg_len            969 drivers/tty/serial/atmel_serial.c 			sg = &sgl[sg_len++];
sg_len            977 drivers/tty/serial/atmel_serial.c 			sg = &sgl[sg_len++];
sg_len            990 drivers/tty/serial/atmel_serial.c 					       sg_len,
sg_len           3593 fs/cifs/smb2ops.c 	unsigned int sg_len;
sg_len           3600 fs/cifs/smb2ops.c 	sg_len = 1;
sg_len           3602 fs/cifs/smb2ops.c 		sg_len += rqst[i].rq_nvec + rqst[i].rq_npages;
sg_len           3604 fs/cifs/smb2ops.c 	sg = kmalloc_array(sg_len, sizeof(struct scatterlist), GFP_KERNEL);
sg_len           3608 fs/cifs/smb2ops.c 	sg_init_table(sg, sg_len);
sg_len            147 include/linux/dma/ipu-dma.h 	unsigned int			sg_len;	/* tx-descriptor. */
sg_len            781 include/linux/dmaengine.h 		unsigned int sg_len, enum dma_transfer_direction direction,
sg_len            838 include/linux/dmaengine.h 	struct dma_chan *chan, struct scatterlist *sgl,	unsigned int sg_len,
sg_len            844 include/linux/dmaengine.h 	return chan->device->device_prep_slave_sg(chan, sgl, sg_len,
sg_len            851 include/linux/dmaengine.h 	struct dma_chan *chan, struct scatterlist *sgl,	unsigned int sg_len,
sg_len            858 include/linux/dmaengine.h 	return chan->device->device_prep_slave_sg(chan, sgl, sg_len,
sg_len            140 include/linux/mmc/core.h 	unsigned int		sg_len;		/* size of scatter list */
sg_len            509 include/linux/rio.h 	unsigned int		sg_len;	/* size of scatter list */
sg_len            182 net/rds/ib_fmr.c 	ibmr->sg_len = nents;
sg_len            244 net/rds/ib_fmr.c 		*unpinned += ibmr->sg_len;
sg_len            114 net/rds/ib_frmr.c 	atomic_add(ibmr->sg_len, &pool->free_pinned);
sg_len            134 net/rds/ib_frmr.c 	ret = ib_map_mr_sg_zbva(frmr->mr, ibmr->sg, ibmr->sg_len,
sg_len            136 net/rds/ib_frmr.c 	if (unlikely(ret != ibmr->sg_len))
sg_len            190 net/rds/ib_frmr.c 			   struct scatterlist *sg, unsigned int sg_len)
sg_len            204 net/rds/ib_frmr.c 	ibmr->sg_len = sg_len;
sg_len            208 net/rds/ib_frmr.c 	ibmr->sg_dma_len = ib_dma_map_sg(dev, ibmr->sg, ibmr->sg_len,
sg_len            260 net/rds/ib_frmr.c 	ib_dma_unmap_sg(rds_ibdev->dev, ibmr->sg, ibmr->sg_len,
sg_len            379 net/rds/ib_frmr.c 		*unpinned += ibmr->sg_len;
sg_len             81 net/rds/ib_mr.h 	unsigned int			sg_len;
sg_len            234 net/rds/ib_rdma.c 				ibmr->sg, ibmr->sg_len,
sg_len            240 net/rds/ib_rdma.c 	if (ibmr->sg_len) {
sg_len            243 net/rds/ib_rdma.c 		for (i = 0; i < ibmr->sg_len; ++i) {
sg_len            255 net/rds/ib_rdma.c 		ibmr->sg_len = 0;
sg_len            261 net/rds/ib_rdma.c 	unsigned int pinned = ibmr->sg_len;
sg_len            483 net/rds/ib_rdma.c 	rdsdebug("RDS/IB: free_mr nents %u\n", ibmr->sg_len);
sg_len            491 net/rds/ib_rdma.c 	atomic_add(ibmr->sg_len, &pool->free_pinned);
sg_len            263 sound/soc/sprd/sprd-pcm-dma.c 			u32 sg_len = period / channels;
sg_len            265 sound/soc/sprd/sprd-pcm-dma.c 			sg_dma_len(sgt) = sg_len;
sg_len            267 sound/soc/sprd/sprd-pcm-dma.c 				i * dma_private->dma_addr_offset + sg_len * j;