arch/mips/alchemy/common/dma.c

127

static const struct dma_dev dma_dev_table_bank2[DMA_NUM_DEV_BANK2] = {

arch/mips/alchemy/common/dma.c

145

const struct dma_dev *dev;

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

165

struct dma_device *dma_dev = NULL;

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

226

dma_dev = lpbfifo.chan->device;

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

243

if (dma_dev->device_config(lpbfifo.chan, &dma_conf))

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

248

sg_dma_address(&sg) = dma_map_single(dma_dev->dev,

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

250

if (dma_mapping_error(dma_dev->dev, sg_dma_address(&sg)))

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

325

dma_unmap_single(dma_dev->dev, sg_dma_address(&sg),

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

481

struct dma_device *dma_dev = lpbfifo.chan->device;

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

489

dma_dev->device_terminate_all(lpbfifo.chan);

arch/s390/include/asm/cio.h

368

void *cio_gp_dma_zalloc(struct gen_pool *gp_dma, struct device *dma_dev,

arch/s390/include/asm/cio.h

370

void *__cio_gp_dma_zalloc(struct gen_pool *gp_dma, struct device *dma_dev,

arch/s390/include/asm/cio.h

373

void cio_gp_dma_destroy(struct gen_pool *gp_dma, struct device *dma_dev);

arch/s390/include/asm/cio.h

374

struct gen_pool *cio_gp_dma_create(struct device *dma_dev, int nr_pages);

block/blk-mq-dma.c

105

static bool blk_rq_dma_map_iova(struct request *req, struct device *dma_dev,

block/blk-mq-dma.c

121

error = dma_iova_link(dma_dev, state, vec->paddr, mapped,

block/blk-mq-dma.c

128

error = dma_iova_sync(dma_dev, state, 0, mapped);

block/blk-mq-dma.c

135

dma_iova_destroy(dma_dev, state, mapped, dir, attrs);

block/blk-mq-dma.c

164

static bool blk_dma_map_iter_start(struct request *req, struct device *dma_dev,

block/blk-mq-dma.c

181

switch (pci_p2pdma_state(&iter->p2pdma, dma_dev,

block/blk-mq-dma.c

197

if (blk_can_dma_map_iova(req, dma_dev) &&

block/blk-mq-dma.c

198

dma_iova_try_alloc(dma_dev, state, vec.paddr, total_len))

block/blk-mq-dma.c

199

return blk_rq_dma_map_iova(req, dma_dev, state, iter, &vec);

block/blk-mq-dma.c

201

return blk_dma_map_direct(req, dma_dev, iter, &vec);

block/blk-mq-dma.c

226

bool blk_rq_dma_map_iter_start(struct request *req, struct device *dma_dev,

block/blk-mq-dma.c

230

return blk_dma_map_iter_start(req, dma_dev, state, iter,

block/blk-mq-dma.c

252

bool blk_rq_dma_map_iter_next(struct request *req, struct device *dma_dev,

block/blk-mq-dma.c

262

return blk_dma_map_direct(req, dma_dev, iter, &vec);

block/blk-mq-dma.c

342

struct device *dma_dev, struct dma_iova_state *state,

block/blk-mq-dma.c

355

return blk_dma_map_iter_start(req, dma_dev, state, iter, len);

block/blk-mq-dma.c

379

struct device *dma_dev, struct blk_dma_iter *iter)

block/blk-mq-dma.c

388

return blk_dma_map_direct(req, dma_dev, iter, &vec);

block/blk-mq-dma.c

75

struct device *dma_dev)

block/blk-mq-dma.c

77

return !(req_phys_gap_mask(req) & dma_get_merge_boundary(dma_dev));

block/blk-mq-dma.c

87

static bool blk_dma_map_direct(struct request *req, struct device *dma_dev,

block/blk-mq-dma.c

95

iter->addr = dma_map_phys(dma_dev, vec->paddr, vec->len,

block/blk-mq-dma.c

97

if (dma_mapping_error(dma_dev, iter->addr)) {

drivers/acpi/scan.c

1545

struct device *dma_dev = dev;

drivers/acpi/scan.c

1554

adev = ACPI_COMPANION(dma_dev);

drivers/acpi/scan.c

1558

dma_dev = dma_dev->parent;

drivers/acpi/scan.c

1559

} while (dma_dev);

drivers/acpi/scan.c

1561

if (!dma_dev)

drivers/acpi/scan.c

1584

dev_dbg(dma_dev, "Invalid DMA regions configuration\n");

drivers/ata/pata_octeon_cf.c

845

struct platform_device *dma_dev;

drivers/ata/pata_octeon_cf.c

846

dma_dev = of_find_device_by_node(dma_node);

drivers/ata/pata_octeon_cf.c

847

if (dma_dev) {

drivers/ata/pata_octeon_cf.c

850

res_dma = platform_get_resource(dma_dev, IORESOURCE_MEM, 0);

drivers/ata/pata_octeon_cf.c

852

put_device(&dma_dev->dev);

drivers/ata/pata_octeon_cf.c

859

put_device(&dma_dev->dev);

drivers/ata/pata_octeon_cf.c

864

i = platform_get_irq(dma_dev, 0);

drivers/ata/pata_octeon_cf.c

869

put_device(&dma_dev->dev);

drivers/ata/sata_dwc_460ex.c

196

if (dws->dma_dev != chan->device->dev)

drivers/ata/sata_dwc_460ex.c

210

dws->dma_dev = dev;

drivers/bcma/main.c

250

core->dma_dev = bus->dev;

drivers/bcma/main.c

255

core->dma_dev = bus->dev;

drivers/bcma/main.c

258

core->dma_dev = &core->dev;

drivers/bus/fsl-mc/fsl-mc-bus.c

172

struct device *dma_dev = dev;

drivers/bus/fsl-mc/fsl-mc-bus.c

177

while (dev_is_fsl_mc(dma_dev))

drivers/bus/fsl-mc/fsl-mc-bus.c

178

dma_dev = dma_dev->parent;

drivers/bus/fsl-mc/fsl-mc-bus.c

180

if (dev_of_node(dma_dev))

drivers/bus/fsl-mc/fsl-mc-bus.c

181

ret = of_dma_configure_id(dev, dma_dev->of_node, 0, &input_id);

drivers/crypto/ccp/ccp-dev.h

391

struct dma_device dma_dev;

drivers/crypto/ccp/ccp-dev.h

473

struct device *dma_dev;

drivers/crypto/ccp/ccp-dmaengine.c

668

struct dma_device *dma_dev = &ccp->dma_dev;

drivers/crypto/ccp/ccp-dmaengine.c

714

dma_dev->dev = ccp->dev;

drivers/crypto/ccp/ccp-dmaengine.c

715

dma_dev->src_addr_widths = CCP_DMA_WIDTH(dma_get_mask(ccp->dev));

drivers/crypto/ccp/ccp-dmaengine.c

716

dma_dev->dst_addr_widths = CCP_DMA_WIDTH(dma_get_mask(ccp->dev));

drivers/crypto/ccp/ccp-dmaengine.c

717

dma_dev->directions = DMA_MEM_TO_MEM;

drivers/crypto/ccp/ccp-dmaengine.c

718

dma_dev->residue_granularity = DMA_RESIDUE_GRANULARITY_DESCRIPTOR;

drivers/crypto/ccp/ccp-dmaengine.c

719

dma_cap_set(DMA_MEMCPY, dma_dev->cap_mask);

drivers/crypto/ccp/ccp-dmaengine.c

720

dma_cap_set(DMA_INTERRUPT, dma_dev->cap_mask);

drivers/crypto/ccp/ccp-dmaengine.c

729

dma_cap_set(DMA_PRIVATE, dma_dev->cap_mask);

drivers/crypto/ccp/ccp-dmaengine.c

731

INIT_LIST_HEAD(&dma_dev->channels);

drivers/crypto/ccp/ccp-dmaengine.c

747

dma_chan->device = dma_dev;

drivers/crypto/ccp/ccp-dmaengine.c

750

list_add_tail(&dma_chan->device_node, &dma_dev->channels);

drivers/crypto/ccp/ccp-dmaengine.c

753

dma_dev->device_free_chan_resources = ccp_free_chan_resources;

drivers/crypto/ccp/ccp-dmaengine.c

754

dma_dev->device_prep_dma_memcpy = ccp_prep_dma_memcpy;

drivers/crypto/ccp/ccp-dmaengine.c

755

dma_dev->device_prep_dma_interrupt = ccp_prep_dma_interrupt;

drivers/crypto/ccp/ccp-dmaengine.c

756

dma_dev->device_issue_pending = ccp_issue_pending;

drivers/crypto/ccp/ccp-dmaengine.c

757

dma_dev->device_tx_status = ccp_tx_status;

drivers/crypto/ccp/ccp-dmaengine.c

758

dma_dev->device_pause = ccp_pause;

drivers/crypto/ccp/ccp-dmaengine.c

759

dma_dev->device_resume = ccp_resume;

drivers/crypto/ccp/ccp-dmaengine.c

760

dma_dev->device_terminate_all = ccp_terminate_all;

drivers/crypto/ccp/ccp-dmaengine.c

762

ret = dma_async_device_register(dma_dev);

drivers/crypto/ccp/ccp-dmaengine.c

780

struct dma_device *dma_dev = &ccp->dma_dev;

drivers/crypto/ccp/ccp-dmaengine.c

786

dma_async_device_unregister(dma_dev);

drivers/crypto/ccp/ccp-ops.c

68

dma_unmap_sg(wa->dma_dev, wa->dma_sg_head, wa->nents, wa->dma_dir);

drivers/crypto/ccp/ccp-ops.c

98

wa->dma_dev = dev;

drivers/dma/altera-msgdma.c

812

struct dma_device *dma_dev;

drivers/dma/altera-msgdma.c

860

dma_dev = &mdev->dmadev;

drivers/dma/altera-msgdma.c

863

dma_cap_zero(dma_dev->cap_mask);

drivers/dma/altera-msgdma.c

864

dma_cap_set(DMA_MEMCPY, dma_dev->cap_mask);

drivers/dma/altera-msgdma.c

865

dma_cap_set(DMA_SLAVE, dma_dev->cap_mask);

drivers/dma/altera-msgdma.c

867

dma_dev->src_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);

drivers/dma/altera-msgdma.c

868

dma_dev->dst_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);

drivers/dma/altera-msgdma.c

869

dma_dev->directions = BIT(DMA_MEM_TO_DEV) | BIT(DMA_DEV_TO_MEM) |

drivers/dma/altera-msgdma.c

871

dma_dev->residue_granularity = DMA_RESIDUE_GRANULARITY_DESCRIPTOR;

drivers/dma/altera-msgdma.c

874

INIT_LIST_HEAD(&dma_dev->channels);

drivers/dma/altera-msgdma.c

877

dma_dev->device_tx_status = dma_cookie_status;

drivers/dma/altera-msgdma.c

878

dma_dev->device_issue_pending = msgdma_issue_pending;

drivers/dma/altera-msgdma.c

879

dma_dev->dev = &pdev->dev;

drivers/dma/altera-msgdma.c

881

dma_dev->copy_align = DMAENGINE_ALIGN_4_BYTES;

drivers/dma/altera-msgdma.c

882

dma_dev->device_prep_dma_memcpy = msgdma_prep_memcpy;

drivers/dma/altera-msgdma.c

883

dma_dev->device_prep_slave_sg = msgdma_prep_slave_sg;

drivers/dma/altera-msgdma.c

884

dma_dev->device_config = msgdma_dma_config;

drivers/dma/altera-msgdma.c

886

dma_dev->device_alloc_chan_resources = msgdma_alloc_chan_resources;

drivers/dma/altera-msgdma.c

887

dma_dev->device_free_chan_resources = msgdma_free_chan_resources;

drivers/dma/altera-msgdma.c

889

mdev->dmachan.device = dma_dev;

drivers/dma/altera-msgdma.c

890

list_add_tail(&mdev->dmachan.device_node, &dma_dev->channels);

drivers/dma/altera-msgdma.c

901

ret = dma_async_device_register(dma_dev);

drivers/dma/altera-msgdma.c

906

of_dma_xlate_by_chan_id, dma_dev);

drivers/dma/amd/ptdma/ptdma-debugfs.c

113

debugfs_create_file("info", 0400, pt->dma_dev.dbg_dev_root, pt,

drivers/dma/amd/ptdma/ptdma-debugfs.c

116

debugfs_create_file("stats", 0400, pt->dma_dev.dbg_dev_root, pt,

drivers/dma/amd/ptdma/ptdma-debugfs.c

130

debugfs_create_dir(name, pt->dma_dev.dbg_dev_root);

drivers/dma/amd/ptdma/ptdma-debugfs.c

137

debugfs_create_dir("q", pt->dma_dev.dbg_dev_root);

drivers/dma/amd/ptdma/ptdma-dmaengine.c

564

struct dma_device *dma_dev = &pt->dma_dev;

drivers/dma/amd/ptdma/ptdma-dmaengine.c

596

dma_dev->dev = pt->dev;

drivers/dma/amd/ptdma/ptdma-dmaengine.c

597

dma_dev->src_addr_widths = DMA_SLAVE_BUSWIDTH_64_BYTES;

drivers/dma/amd/ptdma/ptdma-dmaengine.c

598

dma_dev->dst_addr_widths = DMA_SLAVE_BUSWIDTH_64_BYTES;

drivers/dma/amd/ptdma/ptdma-dmaengine.c

599

dma_dev->directions = DMA_MEM_TO_MEM;

drivers/dma/amd/ptdma/ptdma-dmaengine.c

600

dma_dev->residue_granularity = DMA_RESIDUE_GRANULARITY_DESCRIPTOR;

drivers/dma/amd/ptdma/ptdma-dmaengine.c

601

dma_cap_set(DMA_MEMCPY, dma_dev->cap_mask);

drivers/dma/amd/ptdma/ptdma-dmaengine.c

602

dma_cap_set(DMA_INTERRUPT, dma_dev->cap_mask);

drivers/dma/amd/ptdma/ptdma-dmaengine.c

608

dma_cap_set(DMA_PRIVATE, dma_dev->cap_mask);

drivers/dma/amd/ptdma/ptdma-dmaengine.c

610

INIT_LIST_HEAD(&dma_dev->channels);

drivers/dma/amd/ptdma/ptdma-dmaengine.c

613

dma_dev->device_free_chan_resources = pt_free_chan_resources;

drivers/dma/amd/ptdma/ptdma-dmaengine.c

614

dma_dev->device_prep_dma_memcpy = pt_prep_dma_memcpy;

drivers/dma/amd/ptdma/ptdma-dmaengine.c

615

dma_dev->device_prep_dma_interrupt = pt_prep_dma_interrupt;

drivers/dma/amd/ptdma/ptdma-dmaengine.c

616

dma_dev->device_issue_pending = pt_issue_pending;

drivers/dma/amd/ptdma/ptdma-dmaengine.c

617

dma_dev->device_tx_status = pt_tx_status;

drivers/dma/amd/ptdma/ptdma-dmaengine.c

618

dma_dev->device_pause = pt_pause;

drivers/dma/amd/ptdma/ptdma-dmaengine.c

619

dma_dev->device_resume = pt_resume;

drivers/dma/amd/ptdma/ptdma-dmaengine.c

620

dma_dev->device_terminate_all = pt_terminate_all;

drivers/dma/amd/ptdma/ptdma-dmaengine.c

621

dma_dev->device_synchronize = pt_synchronize;

drivers/dma/amd/ptdma/ptdma-dmaengine.c

630

vchan_init(&chan->vc, dma_dev);

drivers/dma/amd/ptdma/ptdma-dmaengine.c

636

vchan_init(&chan->vc, dma_dev);

drivers/dma/amd/ptdma/ptdma-dmaengine.c

639

ret = dma_async_device_register(dma_dev);

drivers/dma/amd/ptdma/ptdma-dmaengine.c

654

struct dma_device *dma_dev = &pt->dma_dev;

drivers/dma/amd/ptdma/ptdma-dmaengine.c

656

dma_async_device_unregister(dma_dev);

drivers/dma/amd/ptdma/ptdma.h

255

struct dma_device dma_dev;

drivers/dma/amd/qdma/qdma.c

1034

dma_async_device_unregister(&qdev->dma_dev);

drivers/dma/amd/qdma/qdma.c

1088

INIT_LIST_HEAD(&qdev->dma_dev.channels);

drivers/dma/amd/qdma/qdma.c

1100

dma_cap_set(DMA_SLAVE, qdev->dma_dev.cap_mask);

drivers/dma/amd/qdma/qdma.c

1101

dma_cap_set(DMA_PRIVATE, qdev->dma_dev.cap_mask);

drivers/dma/amd/qdma/qdma.c

1103

qdev->dma_dev.dev = &pdev->dev;

drivers/dma/amd/qdma/qdma.c

1104

qdev->dma_dev.filter.map = pdata->device_map;

drivers/dma/amd/qdma/qdma.c

1105

qdev->dma_dev.filter.mapcnt = qdev->chan_num * 2;

drivers/dma/amd/qdma/qdma.c

1106

qdev->dma_dev.filter.fn = qdma_filter_fn;

drivers/dma/amd/qdma/qdma.c

1107

qdev->dma_dev.device_alloc_chan_resources = qdma_alloc_queue_resources;

drivers/dma/amd/qdma/qdma.c

1108

qdev->dma_dev.device_free_chan_resources = qdma_free_queue_resources;

drivers/dma/amd/qdma/qdma.c

1109

qdev->dma_dev.device_prep_slave_sg = qdma_prep_device_sg;

drivers/dma/amd/qdma/qdma.c

1110

qdev->dma_dev.device_config = qdma_device_config;

drivers/dma/amd/qdma/qdma.c

1111

qdev->dma_dev.device_issue_pending = qdma_issue_pending;

drivers/dma/amd/qdma/qdma.c

1112

qdev->dma_dev.device_tx_status = dma_cookie_status;

drivers/dma/amd/qdma/qdma.c

1113

qdev->dma_dev.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);

drivers/dma/amd/qdma/qdma.c

1115

ret = dma_async_device_register(&qdev->dma_dev);

drivers/dma/amd/qdma/qdma.c

471

vchan_init(&q->vchan, &qdev->dma_dev);

drivers/dma/amd/qdma/qdma.c

551

dma_free_coherent(pdata->dma_dev, queue->ring_size * QDMA_MM_DESC_SIZE,

drivers/dma/amd/qdma/qdma.c

574

queue->desc_base = dma_alloc_coherent(pdata->dma_dev, size,

drivers/dma/amd/qdma/qdma.c

589

dma_free_coherent(pdata->dma_dev, size, queue->desc_base,

drivers/dma/amd/qdma/qdma.c

971

ring->base = dmam_alloc_coherent(pdata->dma_dev,

drivers/dma/amd/qdma/qdma.h

246

struct dma_device dma_dev;

drivers/dma/at_hdmac.c

1748

BUG_ON(!atslave->dma_dev || atslave->dma_dev != atdma->dma_device.dev);

drivers/dma/at_hdmac.c

1780

put_device(atslave->dma_dev);

drivers/dma/at_hdmac.c

1793

if (atslave->dma_dev == chan->device->dev) {

drivers/dma/at_hdmac.c

1852

atslave->dma_dev = &dmac_pdev->dev;

drivers/dma/at_hdmac.c

527

struct device *dma_dev;

drivers/dma/bcm-sba-raid.c

143

struct dma_device dma_dev;

drivers/dma/bcm-sba-raid.c

1546

struct dma_device *dma_dev = &sba->dma_dev;

drivers/dma/bcm-sba-raid.c

1549

sba->dma_chan.device = dma_dev;

drivers/dma/bcm-sba-raid.c

1553

dma_cap_zero(dma_dev->cap_mask);

drivers/dma/bcm-sba-raid.c

1554

dma_cap_set(DMA_INTERRUPT, dma_dev->cap_mask);

drivers/dma/bcm-sba-raid.c

1555

dma_cap_set(DMA_MEMCPY, dma_dev->cap_mask);

drivers/dma/bcm-sba-raid.c

1556

dma_cap_set(DMA_XOR, dma_dev->cap_mask);

drivers/dma/bcm-sba-raid.c

1557

dma_cap_set(DMA_PQ, dma_dev->cap_mask);

drivers/dma/bcm-sba-raid.c

1564

dma_dev->dev = sba->mbox_dev;

drivers/dma/bcm-sba-raid.c

1567

dma_dev->device_free_chan_resources = sba_free_chan_resources;

drivers/dma/bcm-sba-raid.c

1568

dma_dev->device_terminate_all = sba_device_terminate_all;

drivers/dma/bcm-sba-raid.c

1569

dma_dev->device_issue_pending = sba_issue_pending;

drivers/dma/bcm-sba-raid.c

1570

dma_dev->device_tx_status = sba_tx_status;

drivers/dma/bcm-sba-raid.c

1573

if (dma_has_cap(DMA_INTERRUPT, dma_dev->cap_mask))

drivers/dma/bcm-sba-raid.c

1574

dma_dev->device_prep_dma_interrupt = sba_prep_dma_interrupt;

drivers/dma/bcm-sba-raid.c

1577

if (dma_has_cap(DMA_MEMCPY, dma_dev->cap_mask))

drivers/dma/bcm-sba-raid.c

1578

dma_dev->device_prep_dma_memcpy = sba_prep_dma_memcpy;

drivers/dma/bcm-sba-raid.c

1581

if (dma_has_cap(DMA_XOR, dma_dev->cap_mask)) {

drivers/dma/bcm-sba-raid.c

1582

dma_dev->device_prep_dma_xor = sba_prep_dma_xor;

drivers/dma/bcm-sba-raid.c

1583

dma_dev->max_xor = sba->max_xor_srcs;

drivers/dma/bcm-sba-raid.c

1587

if (dma_has_cap(DMA_PQ, dma_dev->cap_mask)) {

drivers/dma/bcm-sba-raid.c

1588

dma_dev->device_prep_dma_pq = sba_prep_dma_pq;

drivers/dma/bcm-sba-raid.c

1589

dma_set_maxpq(dma_dev, sba->max_pq_srcs, 0);

drivers/dma/bcm-sba-raid.c

1593

INIT_LIST_HEAD(&dma_dev->channels);

drivers/dma/bcm-sba-raid.c

1594

list_add_tail(&sba->dma_chan.device_node, &dma_dev->channels);

drivers/dma/bcm-sba-raid.c

1597

ret = dma_async_device_register(dma_dev);

drivers/dma/bcm-sba-raid.c

1605

dma_has_cap(DMA_INTERRUPT, dma_dev->cap_mask) ? "interrupt " : "",

drivers/dma/bcm-sba-raid.c

1606

dma_has_cap(DMA_MEMCPY, dma_dev->cap_mask) ? "memcpy " : "",

drivers/dma/bcm-sba-raid.c

1607

dma_has_cap(DMA_XOR, dma_dev->cap_mask) ? "xor " : "",

drivers/dma/bcm-sba-raid.c

1608

dma_has_cap(DMA_PQ, dma_dev->cap_mask) ? "pq " : "");

drivers/dma/bcm-sba-raid.c

1743

dma_async_device_unregister(&sba->dma_dev);

drivers/dma/dma-axi-dmac.c

1016

dev_err(dmac->dma_dev.dev,

drivers/dma/dma-axi-dmac.c

1024

dev_err(dmac->dma_dev.dev,

drivers/dma/dma-axi-dmac.c

1071

struct dma_device *dma_dev;

drivers/dma/dma-axi-dmac.c

1110

dma_dev = &dmac->dma_dev;

drivers/dma/dma-axi-dmac.c

1111

dma_cap_set(DMA_SLAVE, dma_dev->cap_mask);

drivers/dma/dma-axi-dmac.c

1112

dma_cap_set(DMA_CYCLIC, dma_dev->cap_mask);

drivers/dma/dma-axi-dmac.c

1113

dma_cap_set(DMA_INTERLEAVE, dma_dev->cap_mask);

drivers/dma/dma-axi-dmac.c

1114

dma_dev->device_free_chan_resources = axi_dmac_free_chan_resources;

drivers/dma/dma-axi-dmac.c

1115

dma_dev->device_tx_status = dma_cookie_status;

drivers/dma/dma-axi-dmac.c

1116

dma_dev->device_issue_pending = axi_dmac_issue_pending;

drivers/dma/dma-axi-dmac.c

1117

dma_dev->device_prep_slave_sg = axi_dmac_prep_slave_sg;

drivers/dma/dma-axi-dmac.c

1118

dma_dev->device_prep_peripheral_dma_vec = axi_dmac_prep_peripheral_dma_vec;

drivers/dma/dma-axi-dmac.c

1119

dma_dev->device_prep_dma_cyclic = axi_dmac_prep_dma_cyclic;

drivers/dma/dma-axi-dmac.c

1120

dma_dev->device_prep_interleaved_dma = axi_dmac_prep_interleaved;

drivers/dma/dma-axi-dmac.c

1121

dma_dev->device_terminate_all = axi_dmac_terminate_all;

drivers/dma/dma-axi-dmac.c

1122

dma_dev->device_synchronize = axi_dmac_synchronize;

drivers/dma/dma-axi-dmac.c

1123

dma_dev->dev = &pdev->dev;

drivers/dma/dma-axi-dmac.c

1124

dma_dev->src_addr_widths = BIT(dmac->chan.src_width);

drivers/dma/dma-axi-dmac.c

1125

dma_dev->dst_addr_widths = BIT(dmac->chan.dest_width);

drivers/dma/dma-axi-dmac.c

1126

dma_dev->directions = BIT(dmac->chan.direction);

drivers/dma/dma-axi-dmac.c

1127

dma_dev->residue_granularity = DMA_RESIDUE_GRANULARITY_DESCRIPTOR;

drivers/dma/dma-axi-dmac.c

1128

dma_dev->max_sg_burst = 31; /* 31 SGs maximum in one burst */

drivers/dma/dma-axi-dmac.c

1129

INIT_LIST_HEAD(&dma_dev->channels);

drivers/dma/dma-axi-dmac.c

1132

vchan_init(&dmac->chan.vchan, dma_dev);

drivers/dma/dma-axi-dmac.c

1138

dma_dev->copy_align = (dmac->chan.address_align_mask + 1);

drivers/dma/dma-axi-dmac.c

1150

dev_err(dmac->dma_dev.dev,

drivers/dma/dma-axi-dmac.c

1156

ret = dmaenginem_async_device_register(dma_dev);

drivers/dma/dma-axi-dmac.c

1170

of_dma_xlate_by_chan_id, dma_dev);

drivers/dma/dma-axi-dmac.c

173

struct dma_device dma_dev;

drivers/dma/dma-axi-dmac.c

180

dma_dev);

drivers/dma/dma-axi-dmac.c

360

dev_dbg(dmac->dma_dev.dev,

drivers/dma/dma-axi-dmac.c

364

dev_warn(dmac->dma_dev.dev,

drivers/dma/dma-axi-dmac.c

537

struct device *dev = dmac->dma_dev.dev;

drivers/dma/dma-axi-dmac.c

576

struct device *dev = dmac->dma_dev.dev;

drivers/dma/dma-axi-dmac.c

992

struct device *dev = dmac->dma_dev.dev;

drivers/dma/dmaengine.c

106

struct dma_device *dma_dev = NULL;

drivers/dma/dmaengine.c

109

list_for_each_entry(dma_dev, &dma_device_list, global_node) {

drivers/dma/dmaengine.c

111

dma_dev->dev_id, dev_name(dma_dev->dev),

drivers/dma/dmaengine.c

112

dma_dev->chancnt);

drivers/dma/dmaengine.c

114

if (dma_dev->dbg_summary_show)

drivers/dma/dmaengine.c

115

dma_dev->dbg_summary_show(s, dma_dev);

drivers/dma/dmaengine.c

117

dmaengine_dbg_summary_show(s, dma_dev);

drivers/dma/dmaengine.c

119

if (!list_is_last(&dma_dev->global_node, &dma_device_list))

drivers/dma/dmaengine.c

138

static inline int dmaengine_debug_register(struct dma_device *dma_dev)

drivers/dma/dmaengine.c

143

static inline void dmaengine_debug_unregister(struct dma_device *dma_dev) { }

drivers/dma/dmaengine.c

232

ATTRIBUTE_GROUPS(dma_dev);

drivers/dma/dmaengine.c

71

static void dmaengine_debug_register(struct dma_device *dma_dev)

drivers/dma/dmaengine.c

73

dma_dev->dbg_dev_root = debugfs_create_dir(dev_name(dma_dev->dev),

drivers/dma/dmaengine.c

75

if (IS_ERR(dma_dev->dbg_dev_root))

drivers/dma/dmaengine.c

76

dma_dev->dbg_dev_root = NULL;

drivers/dma/dmaengine.c

79

static void dmaengine_debug_unregister(struct dma_device *dma_dev)

drivers/dma/dmaengine.c

81

debugfs_remove_recursive(dma_dev->dbg_dev_root);

drivers/dma/dmaengine.c

82

dma_dev->dbg_dev_root = NULL;

drivers/dma/dmaengine.c

86

struct dma_device *dma_dev)

drivers/dma/dmaengine.c

90

list_for_each_entry(chan, &dma_dev->channels, device_node) {

drivers/dma/dmaengine.h

189

dmaengine_get_debugfs_root(struct dma_device *dma_dev) {

drivers/dma/dmaengine.h

190

return dma_dev->dbg_dev_root;

drivers/dma/dmaengine.h

195

dmaengine_get_debugfs_root(struct dma_device *dma_dev)

drivers/dma/dmatest.c

1024

struct dma_device *dma_dev = chan->device;

drivers/dma/dmatest.c

1037

if (dma_has_cap(DMA_COMPLETION_NO_ORDER, dma_dev->cap_mask) &&

drivers/dma/dmatest.c

1043

if (dma_has_cap(DMA_MEMCPY, dma_dev->cap_mask)) {

drivers/dma/dmatest.c

1050

if (dma_has_cap(DMA_MEMSET, dma_dev->cap_mask)) {

drivers/dma/dmatest.c

1057

if (dma_has_cap(DMA_XOR, dma_dev->cap_mask)) {

drivers/dma/dmatest.c

1061

if (dma_has_cap(DMA_PQ, dma_dev->cap_mask)) {

drivers/dma/dmatest.c

582

struct device *dma_dev;

drivers/dma/dmatest.c

616

dma_dev = dmaengine_get_dma_device(chan);

drivers/dma/dmatest.c

749

um = dmaengine_get_unmap_data(dma_dev, src->cnt + dst->cnt,

drivers/dma/dmatest.c

764

um->addr[i] = dma_map_page(dma_dev, pg, pg_off,

drivers/dma/dmatest.c

767

ret = dma_mapping_error(dma_dev, um->addr[i]);

drivers/dma/dmatest.c

782

dsts[i] = dma_map_page(dma_dev, pg, pg_off, um->len,

drivers/dma/dmatest.c

784

ret = dma_mapping_error(dma_dev, dsts[i]);

drivers/dma/dw/acpi.c

15

.dma_dev = dma_spec->dev,

drivers/dma/dw/core.c

768

if (dws->dma_dev != chan->device->dev)

drivers/dma/dw/of.c

21

.dma_dev = dw->dma.dev,

drivers/dma/ep93xx_dma.c

1373

struct dma_device *dma_dev;

drivers/dma/ep93xx_dma.c

1388

dma_dev = &edma->dma_dev;

drivers/dma/ep93xx_dma.c

1390

INIT_LIST_HEAD(&dma_dev->channels);

drivers/dma/ep93xx_dma.c

1395

edmac->chan.device = dma_dev;

drivers/dma/ep93xx_dma.c

1427

&dma_dev->channels);

drivers/dma/ep93xx_dma.c

1449

dma_cap_mask_t mask = edma->dma_dev.cap_mask;

drivers/dma/ep93xx_dma.c

1480

dma_cap_mask_t mask = edma->dma_dev.cap_mask;

drivers/dma/ep93xx_dma.c

1505

struct dma_device *dma_dev;

drivers/dma/ep93xx_dma.c

1512

dma_dev = &edma->dma_dev;

drivers/dma/ep93xx_dma.c

1514

dma_cap_zero(dma_dev->cap_mask);

drivers/dma/ep93xx_dma.c

1515

dma_cap_set(DMA_SLAVE, dma_dev->cap_mask);

drivers/dma/ep93xx_dma.c

1516

dma_cap_set(DMA_CYCLIC, dma_dev->cap_mask);

drivers/dma/ep93xx_dma.c

1518

dma_dev->dev = &pdev->dev;

drivers/dma/ep93xx_dma.c

1519

dma_dev->device_alloc_chan_resources = ep93xx_dma_alloc_chan_resources;

drivers/dma/ep93xx_dma.c

1520

dma_dev->device_free_chan_resources = ep93xx_dma_free_chan_resources;

drivers/dma/ep93xx_dma.c

1521

dma_dev->device_prep_slave_sg = ep93xx_dma_prep_slave_sg;

drivers/dma/ep93xx_dma.c

1522

dma_dev->device_prep_dma_cyclic = ep93xx_dma_prep_dma_cyclic;

drivers/dma/ep93xx_dma.c

1523

dma_dev->device_config = ep93xx_dma_slave_config;

drivers/dma/ep93xx_dma.c

1524

dma_dev->device_synchronize = ep93xx_dma_synchronize;

drivers/dma/ep93xx_dma.c

1525

dma_dev->device_terminate_all = ep93xx_dma_terminate_all;

drivers/dma/ep93xx_dma.c

1526

dma_dev->device_issue_pending = ep93xx_dma_issue_pending;

drivers/dma/ep93xx_dma.c

1527

dma_dev->device_tx_status = ep93xx_dma_tx_status;

drivers/dma/ep93xx_dma.c

1529

dma_set_max_seg_size(dma_dev->dev, DMA_MAX_CHAN_BYTES);

drivers/dma/ep93xx_dma.c

1532

dma_cap_set(DMA_MEMCPY, dma_dev->cap_mask);

drivers/dma/ep93xx_dma.c

1533

dma_dev->device_prep_dma_memcpy = ep93xx_dma_prep_dma_memcpy;

drivers/dma/ep93xx_dma.c

1540

dma_cap_set(DMA_PRIVATE, dma_dev->cap_mask);

drivers/dma/ep93xx_dma.c

1549

ret = dma_async_device_register(dma_dev);

drivers/dma/ep93xx_dma.c

1563

dev_info(dma_dev->dev, "EP93xx M2%s DMA ready\n", edma->m2m ? "M" : "P");

drivers/dma/ep93xx_dma.c

1568

dma_async_device_unregister(dma_dev);

drivers/dma/ep93xx_dma.c

234

struct dma_device dma_dev;

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.c

641

INIT_LIST_HEAD(&dpaa2_qdma->dma_dev.channels);

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.c

647

vchan_init(&dpaa2_chan->vchan, &dpaa2_qdma->dma_dev);

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.c

729

dma_cap_set(DMA_PRIVATE, dpaa2_qdma->dma_dev.cap_mask);

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.c

730

dma_cap_set(DMA_SLAVE, dpaa2_qdma->dma_dev.cap_mask);

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.c

731

dma_cap_set(DMA_MEMCPY, dpaa2_qdma->dma_dev.cap_mask);

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.c

733

dpaa2_qdma->dma_dev.dev = dev;

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.c

734

dpaa2_qdma->dma_dev.device_alloc_chan_resources =

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.c

736

dpaa2_qdma->dma_dev.device_free_chan_resources =

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.c

738

dpaa2_qdma->dma_dev.device_tx_status = dma_cookie_status;

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.c

739

dpaa2_qdma->dma_dev.device_prep_dma_memcpy = dpaa2_qdma_prep_memcpy;

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.c

740

dpaa2_qdma->dma_dev.device_issue_pending = dpaa2_qdma_issue_pending;

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.c

742

err = dma_async_device_register(&dpaa2_qdma->dma_dev);

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.c

789

dma_async_device_unregister(&dpaa2_qdma->dma_dev);

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.h

101

struct dma_device dma_dev;

drivers/dma/fsl-edma-common.h

255

struct dma_device dma_dev;

drivers/dma/fsl-edma-main.c

265

list_for_each_entry_safe(chan, _chan, &fsl_edma->dma_dev.channels, device_node) {

drivers/dma/fsl-edma-main.c

309

list_for_each_entry_safe(chan, _chan, &fsl_edma->dma_dev.channels,

drivers/dma/fsl-edma-main.c

789

INIT_LIST_HEAD(&fsl_edma->dma_dev.channels);

drivers/dma/fsl-edma-main.c

824

vchan_init(&fsl_chan->vchan, &fsl_edma->dma_dev);

drivers/dma/fsl-edma-main.c

836

dma_cap_set(DMA_PRIVATE, fsl_edma->dma_dev.cap_mask);

drivers/dma/fsl-edma-main.c

837

dma_cap_set(DMA_SLAVE, fsl_edma->dma_dev.cap_mask);

drivers/dma/fsl-edma-main.c

838

dma_cap_set(DMA_CYCLIC, fsl_edma->dma_dev.cap_mask);

drivers/dma/fsl-edma-main.c

839

dma_cap_set(DMA_MEMCPY, fsl_edma->dma_dev.cap_mask);

drivers/dma/fsl-edma-main.c

841

fsl_edma->dma_dev.dev = &pdev->dev;

drivers/dma/fsl-edma-main.c

842

fsl_edma->dma_dev.device_alloc_chan_resources

drivers/dma/fsl-edma-main.c

844

fsl_edma->dma_dev.device_free_chan_resources

drivers/dma/fsl-edma-main.c

846

fsl_edma->dma_dev.device_tx_status = fsl_edma_tx_status;

drivers/dma/fsl-edma-main.c

847

fsl_edma->dma_dev.device_prep_slave_sg = fsl_edma_prep_slave_sg;

drivers/dma/fsl-edma-main.c

848

fsl_edma->dma_dev.device_prep_dma_cyclic = fsl_edma_prep_dma_cyclic;

drivers/dma/fsl-edma-main.c

849

fsl_edma->dma_dev.device_prep_dma_memcpy = fsl_edma_prep_memcpy;

drivers/dma/fsl-edma-main.c

850

fsl_edma->dma_dev.device_config = fsl_edma_slave_config;

drivers/dma/fsl-edma-main.c

851

fsl_edma->dma_dev.device_pause = fsl_edma_pause;

drivers/dma/fsl-edma-main.c

852

fsl_edma->dma_dev.device_resume = fsl_edma_resume;

drivers/dma/fsl-edma-main.c

853

fsl_edma->dma_dev.device_terminate_all = fsl_edma_terminate_all;

drivers/dma/fsl-edma-main.c

854

fsl_edma->dma_dev.device_synchronize = fsl_edma_synchronize;

drivers/dma/fsl-edma-main.c

855

fsl_edma->dma_dev.device_issue_pending = fsl_edma_issue_pending;

drivers/dma/fsl-edma-main.c

857

fsl_edma->dma_dev.src_addr_widths = FSL_EDMA_BUSWIDTHS;

drivers/dma/fsl-edma-main.c

858

fsl_edma->dma_dev.dst_addr_widths = FSL_EDMA_BUSWIDTHS;

drivers/dma/fsl-edma-main.c

861

fsl_edma->dma_dev.src_addr_widths |= BIT(DMA_SLAVE_BUSWIDTH_8_BYTES);

drivers/dma/fsl-edma-main.c

862

fsl_edma->dma_dev.dst_addr_widths |= BIT(DMA_SLAVE_BUSWIDTH_8_BYTES);

drivers/dma/fsl-edma-main.c

865

fsl_edma->dma_dev.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);

drivers/dma/fsl-edma-main.c

867

fsl_edma->dma_dev.directions |= BIT(DMA_DEV_TO_DEV);

drivers/dma/fsl-edma-main.c

869

fsl_edma->dma_dev.copy_align = drvdata->flags & FSL_EDMA_DRV_ALIGN_64BYTE ?

drivers/dma/fsl-edma-main.c

874

dma_set_max_seg_size(fsl_edma->dma_dev.dev,

drivers/dma/fsl-edma-main.c

877

fsl_edma->dma_dev.residue_granularity = DMA_RESIDUE_GRANULARITY_SEGMENT;

drivers/dma/fsl-edma-main.c

881

ret = dma_async_device_register(&fsl_edma->dma_dev);

drivers/dma/fsl-edma-main.c

894

dma_async_device_unregister(&fsl_edma->dma_dev);

drivers/dma/fsl-edma-main.c

912

dma_async_device_unregister(&fsl_edma->dma_dev);

drivers/dma/fsl-edma-main.c

913

fsl_edma_cleanup_vchan(&fsl_edma->dma_dev);

drivers/dma/fsl-qdma.c

1208

INIT_LIST_HEAD(&fsl_qdma->dma_dev.channels);

drivers/dma/fsl-qdma.c

1217

vchan_init(&fsl_chan->vchan, &fsl_qdma->dma_dev);

drivers/dma/fsl-qdma.c

1220

dma_cap_set(DMA_MEMCPY, fsl_qdma->dma_dev.cap_mask);

drivers/dma/fsl-qdma.c

1222

fsl_qdma->dma_dev.dev = &pdev->dev;

drivers/dma/fsl-qdma.c

1223

fsl_qdma->dma_dev.device_free_chan_resources =

drivers/dma/fsl-qdma.c

1225

fsl_qdma->dma_dev.device_alloc_chan_resources =

drivers/dma/fsl-qdma.c

1227

fsl_qdma->dma_dev.device_tx_status = dma_cookie_status;

drivers/dma/fsl-qdma.c

1228

fsl_qdma->dma_dev.device_prep_dma_memcpy = fsl_qdma_prep_memcpy;

drivers/dma/fsl-qdma.c

1229

fsl_qdma->dma_dev.device_issue_pending = fsl_qdma_issue_pending;

drivers/dma/fsl-qdma.c

1230

fsl_qdma->dma_dev.device_synchronize = fsl_qdma_synchronize;

drivers/dma/fsl-qdma.c

1231

fsl_qdma->dma_dev.device_terminate_all = fsl_qdma_terminate_all;

drivers/dma/fsl-qdma.c

1251

ret = dma_async_device_register(&fsl_qdma->dma_dev);

drivers/dma/fsl-qdma.c

1277

fsl_qdma_cleanup_vchan(&fsl_qdma->dma_dev);

drivers/dma/fsl-qdma.c

1279

dma_async_device_unregister(&fsl_qdma->dma_dev);

drivers/dma/fsl-qdma.c

217

struct dma_device dma_dev;

drivers/dma/fsl-qdma.c

726

dev_err(fsl_qdma->dma_dev.dev,

drivers/dma/fsl-qdma.c

758

dev_err(fsl_qdma->dma_dev.dev,

drivers/dma/fsl-qdma.c

776

dev_err(fsl_qdma->dma_dev.dev,

drivers/dma/fsl-qdma.c

794

dev_err(fsl_qdma->dma_dev.dev, "QDMA: status err!\n");

drivers/dma/fsl-qdma.c

883

dev_err(fsl_qdma->dma_dev.dev, "DMA halt failed!");

drivers/dma/fsl_raid.c

629

struct dma_device *dma_dev;

drivers/dma/fsl_raid.c

637

dma_dev = &re_priv->dma_dev;

drivers/dma/fsl_raid.c

683

chan->chan.device = dma_dev;

drivers/dma/fsl_raid.c

752

struct dma_device *dma_dev;

drivers/dma/fsl_raid.c

781

dma_dev = &re_priv->dma_dev;

drivers/dma/fsl_raid.c

782

dma_dev->dev = dev;

drivers/dma/fsl_raid.c

783

INIT_LIST_HEAD(&dma_dev->channels);

drivers/dma/fsl_raid.c

786

dma_dev->device_alloc_chan_resources = fsl_re_alloc_chan_resources;

drivers/dma/fsl_raid.c

787

dma_dev->device_tx_status = fsl_re_tx_status;

drivers/dma/fsl_raid.c

788

dma_dev->device_issue_pending = fsl_re_issue_pending;

drivers/dma/fsl_raid.c

790

dma_dev->max_xor = FSL_RE_MAX_XOR_SRCS;

drivers/dma/fsl_raid.c

791

dma_dev->device_prep_dma_xor = fsl_re_prep_dma_xor;

drivers/dma/fsl_raid.c

792

dma_cap_set(DMA_XOR, dma_dev->cap_mask);

drivers/dma/fsl_raid.c

794

dma_dev->max_pq = FSL_RE_MAX_PQ_SRCS;

drivers/dma/fsl_raid.c

795

dma_dev->device_prep_dma_pq = fsl_re_prep_dma_pq;

drivers/dma/fsl_raid.c

796

dma_cap_set(DMA_PQ, dma_dev->cap_mask);

drivers/dma/fsl_raid.c

798

dma_dev->device_prep_dma_memcpy = fsl_re_prep_dma_memcpy;

drivers/dma/fsl_raid.c

799

dma_cap_set(DMA_MEMCPY, dma_dev->cap_mask);

drivers/dma/fsl_raid.c

801

dma_dev->device_free_chan_resources = fsl_re_free_chan_resources;

drivers/dma/fsl_raid.c

842

dma_async_device_register(dma_dev);

drivers/dma/fsl_raid.c

872

dma_async_device_unregister(&re_priv->dma_dev);

drivers/dma/fsl_raid.h

258

struct dma_device dma_dev;

drivers/dma/hisi_dma.c

1024

dma_dev = &hdma_dev->dma_dev;

drivers/dma/hisi_dma.c

1025

ret = dmaenginem_async_device_register(dma_dev);

drivers/dma/hisi_dma.c

161

struct dma_device dma_dev;

drivers/dma/hisi_dma.c

712

vchan_init(&hdma_dev->chan[i].vc, &hdma_dev->dma_dev);

drivers/dma/hisi_dma.c

824

struct dma_device *dma_dev;

drivers/dma/hisi_dma.c

826

dma_dev = &hdma_dev->dma_dev;

drivers/dma/hisi_dma.c

827

dma_cap_set(DMA_MEMCPY, dma_dev->cap_mask);

drivers/dma/hisi_dma.c

828

dma_dev->device_free_chan_resources = hisi_dma_free_chan_resources;

drivers/dma/hisi_dma.c

829

dma_dev->device_prep_dma_memcpy = hisi_dma_prep_dma_memcpy;

drivers/dma/hisi_dma.c

830

dma_dev->device_tx_status = hisi_dma_tx_status;

drivers/dma/hisi_dma.c

831

dma_dev->device_issue_pending = hisi_dma_issue_pending;

drivers/dma/hisi_dma.c

832

dma_dev->device_terminate_all = hisi_dma_terminate_all;

drivers/dma/hisi_dma.c

833

dma_dev->device_synchronize = hisi_dma_synchronize;

drivers/dma/hisi_dma.c

834

dma_dev->directions = BIT(DMA_MEM_TO_MEM);

drivers/dma/hisi_dma.c

835

dma_dev->dev = &hdma_dev->pdev->dev;

drivers/dma/hisi_dma.c

836

INIT_LIST_HEAD(&dma_dev->channels);

drivers/dma/hisi_dma.c

906

hdma_dev->dma_dev.dbg_dev_root);

drivers/dma/hisi_dma.c

921

if (hdma_dev->dma_dev.dbg_dev_root == NULL)

drivers/dma/hisi_dma.c

939

hdma_dev->dma_dev.dbg_dev_root, regset);

drivers/dma/hisi_dma.c

955

struct dma_device *dma_dev;

drivers/dma/img-mdc-dma.c

1012

dma_async_device_unregister(&mdma->dma_dev);

drivers/dma/img-mdc-dma.c

1026

dma_async_device_unregister(&mdma->dma_dev);

drivers/dma/img-mdc-dma.c

1028

list_for_each_entry_safe(mchan, next, &mdma->dma_dev.channels,

drivers/dma/img-mdc-dma.c

133

struct dma_device dma_dev;

drivers/dma/img-mdc-dma.c

182

return mdma->dma_dev.dev;

drivers/dma/img-mdc-dma.c

816

list_for_each_entry(chan, &mdma->dma_dev.channels, device_node) {

drivers/dma/img-mdc-dma.c

912

dma_cap_zero(mdma->dma_dev.cap_mask);

drivers/dma/img-mdc-dma.c

913

dma_cap_set(DMA_SLAVE, mdma->dma_dev.cap_mask);

drivers/dma/img-mdc-dma.c

914

dma_cap_set(DMA_PRIVATE, mdma->dma_dev.cap_mask);

drivers/dma/img-mdc-dma.c

915

dma_cap_set(DMA_CYCLIC, mdma->dma_dev.cap_mask);

drivers/dma/img-mdc-dma.c

916

dma_cap_set(DMA_MEMCPY, mdma->dma_dev.cap_mask);

drivers/dma/img-mdc-dma.c

946

mdma->dma_dev.dev = &pdev->dev;

drivers/dma/img-mdc-dma.c

947

mdma->dma_dev.device_prep_slave_sg = mdc_prep_slave_sg;

drivers/dma/img-mdc-dma.c

948

mdma->dma_dev.device_prep_dma_cyclic = mdc_prep_dma_cyclic;

drivers/dma/img-mdc-dma.c

949

mdma->dma_dev.device_prep_dma_memcpy = mdc_prep_dma_memcpy;

drivers/dma/img-mdc-dma.c

950

mdma->dma_dev.device_alloc_chan_resources = mdc_alloc_chan_resources;

drivers/dma/img-mdc-dma.c

951

mdma->dma_dev.device_free_chan_resources = mdc_free_chan_resources;

drivers/dma/img-mdc-dma.c

952

mdma->dma_dev.device_tx_status = mdc_tx_status;

drivers/dma/img-mdc-dma.c

953

mdma->dma_dev.device_issue_pending = mdc_issue_pending;

drivers/dma/img-mdc-dma.c

954

mdma->dma_dev.device_terminate_all = mdc_terminate_all;

drivers/dma/img-mdc-dma.c

955

mdma->dma_dev.device_synchronize = mdc_synchronize;

drivers/dma/img-mdc-dma.c

956

mdma->dma_dev.device_config = mdc_slave_config;

drivers/dma/img-mdc-dma.c

958

mdma->dma_dev.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);

drivers/dma/img-mdc-dma.c

959

mdma->dma_dev.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;

drivers/dma/img-mdc-dma.c

961

mdma->dma_dev.src_addr_widths |= BIT(i);

drivers/dma/img-mdc-dma.c

962

mdma->dma_dev.dst_addr_widths |= BIT(i);

drivers/dma/img-mdc-dma.c

965

INIT_LIST_HEAD(&mdma->dma_dev.channels);

drivers/dma/img-mdc-dma.c

982

vchan_init(&mchan->vc, &mdma->dma_dev);

drivers/dma/img-mdc-dma.c

998

ret = dma_async_device_register(&mdma->dma_dev);

drivers/dma/ioat/dma.h

24

#define to_ioatdma_device(dev) container_of(dev, struct ioatdma_device, dma_dev)

drivers/dma/ioat/dma.h

71

struct dma_device dma_dev;

drivers/dma/ioat/init.c

1057

dma = &ioat_dma->dma_dev;

drivers/dma/ioat/init.c

1086

dma = &ioat_dma->dma_dev;

drivers/dma/ioat/init.c

1173

err = dma_async_device_register(&ioat_dma->dma_dev);

drivers/dma/ioat/init.c

1341

d->dma_dev.device_release = release_ioatdma;

drivers/dma/ioat/init.c

305

struct dma_device *dma = &ioat_dma->dma_dev;

drivers/dma/ioat/init.c

351

tx = ioat_dma->dma_dev.device_prep_dma_memcpy(dma_chan, dma_dest,

drivers/dma/ioat/init.c

496

struct dma_device *dma = &ioat_dma->dma_dev;

drivers/dma/ioat/init.c

540

struct dma_device *dma = &ioat_dma->dma_dev;

drivers/dma/ioat/init.c

557

struct dma_device *dma = &ioat_dma->dma_dev;

drivers/dma/ioat/init.c

758

struct dma_device *dma = &ioat_dma->dma_dev;

drivers/dma/ioat/init.c

790

struct dma_device *dma = &ioat_dma->dma_dev;

drivers/dma/ioat/sysfs.c

77

struct dma_device *dma = &ioat_dma->dma_dev;

drivers/dma/ioat/sysfs.c

98

struct dma_device *dma = &ioat_dma->dma_dev;

drivers/dma/lgm/lgm-dma.c

1410

vchan_init(&c->vchan, &d->dma_dev);

drivers/dma/lgm/lgm-dma.c

1431

vchan_init(&c->vchan, &d->dma_dev);

drivers/dma/lgm/lgm-dma.c

1562

struct dma_device *dma_dev;

drivers/dma/lgm/lgm-dma.c

1635

dma_dev = &d->dma_dev;

drivers/dma/lgm/lgm-dma.c

1637

dma_cap_zero(dma_dev->cap_mask);

drivers/dma/lgm/lgm-dma.c

1638

dma_cap_set(DMA_SLAVE, dma_dev->cap_mask);

drivers/dma/lgm/lgm-dma.c

1641

INIT_LIST_HEAD(&dma_dev->channels);

drivers/dma/lgm/lgm-dma.c

1659

dma_dev->dev = &pdev->dev;

drivers/dma/lgm/lgm-dma.c

1673

dma_dev->device_alloc_chan_resources = ldma_alloc_chan_resources;

drivers/dma/lgm/lgm-dma.c

1674

dma_dev->device_free_chan_resources = ldma_free_chan_resources;

drivers/dma/lgm/lgm-dma.c

1675

dma_dev->device_terminate_all = ldma_terminate_all;

drivers/dma/lgm/lgm-dma.c

1676

dma_dev->device_issue_pending = ldma_issue_pending;

drivers/dma/lgm/lgm-dma.c

1677

dma_dev->device_tx_status = ldma_tx_status;

drivers/dma/lgm/lgm-dma.c

1678

dma_dev->device_resume = ldma_resume_chan;

drivers/dma/lgm/lgm-dma.c

1679

dma_dev->device_pause = ldma_pause_chan;

drivers/dma/lgm/lgm-dma.c

1680

dma_dev->device_prep_slave_sg = ldma_prep_slave_sg;

drivers/dma/lgm/lgm-dma.c

1683

dma_dev->device_config = ldma_slave_config;

drivers/dma/lgm/lgm-dma.c

1684

dma_dev->device_synchronize = ldma_synchronize;

drivers/dma/lgm/lgm-dma.c

1685

dma_dev->src_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);

drivers/dma/lgm/lgm-dma.c

1686

dma_dev->dst_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);

drivers/dma/lgm/lgm-dma.c

1687

dma_dev->directions = BIT(DMA_MEM_TO_DEV) |

drivers/dma/lgm/lgm-dma.c

1689

dma_dev->residue_granularity =

drivers/dma/lgm/lgm-dma.c

1697

ret = dma_async_device_register(dma_dev);

drivers/dma/lgm/lgm-dma.c

1706

dma_async_device_unregister(dma_dev);

drivers/dma/lgm/lgm-dma.c

249

struct dma_device dma_dev;

drivers/dma/lgm/lgm-dma.c

295

static inline struct ldma_dev *to_ldma_dev(struct dma_device *dma_dev)

drivers/dma/lgm/lgm-dma.c

297

return container_of(dma_dev, struct ldma_dev, dma_dev);

drivers/dma/mcf-edma-main.c

192

INIT_LIST_HEAD(&mcf_edma->dma_dev.channels);

drivers/dma/mcf-edma-main.c

200

vchan_init(&mcf_chan->vchan, &mcf_edma->dma_dev);

drivers/dma/mcf-edma-main.c

213

dma_cap_set(DMA_PRIVATE, mcf_edma->dma_dev.cap_mask);

drivers/dma/mcf-edma-main.c

214

dma_cap_set(DMA_SLAVE, mcf_edma->dma_dev.cap_mask);

drivers/dma/mcf-edma-main.c

215

dma_cap_set(DMA_CYCLIC, mcf_edma->dma_dev.cap_mask);

drivers/dma/mcf-edma-main.c

217

mcf_edma->dma_dev.dev = &pdev->dev;

drivers/dma/mcf-edma-main.c

218

mcf_edma->dma_dev.device_alloc_chan_resources =

drivers/dma/mcf-edma-main.c

220

mcf_edma->dma_dev.device_free_chan_resources =

drivers/dma/mcf-edma-main.c

222

mcf_edma->dma_dev.device_config = fsl_edma_slave_config;

drivers/dma/mcf-edma-main.c

223

mcf_edma->dma_dev.device_prep_dma_cyclic =

drivers/dma/mcf-edma-main.c

225

mcf_edma->dma_dev.device_prep_slave_sg = fsl_edma_prep_slave_sg;

drivers/dma/mcf-edma-main.c

226

mcf_edma->dma_dev.device_tx_status = fsl_edma_tx_status;

drivers/dma/mcf-edma-main.c

227

mcf_edma->dma_dev.device_pause = fsl_edma_pause;

drivers/dma/mcf-edma-main.c

228

mcf_edma->dma_dev.device_resume = fsl_edma_resume;

drivers/dma/mcf-edma-main.c

229

mcf_edma->dma_dev.device_terminate_all = fsl_edma_terminate_all;

drivers/dma/mcf-edma-main.c

230

mcf_edma->dma_dev.device_issue_pending = fsl_edma_issue_pending;

drivers/dma/mcf-edma-main.c

232

mcf_edma->dma_dev.src_addr_widths = FSL_EDMA_BUSWIDTHS;

drivers/dma/mcf-edma-main.c

233

mcf_edma->dma_dev.dst_addr_widths = FSL_EDMA_BUSWIDTHS;

drivers/dma/mcf-edma-main.c

234

mcf_edma->dma_dev.directions =

drivers/dma/mcf-edma-main.c

237

mcf_edma->dma_dev.filter.fn = mcf_edma_filter_fn;

drivers/dma/mcf-edma-main.c

238

mcf_edma->dma_dev.filter.map = pdata->slave_map;

drivers/dma/mcf-edma-main.c

239

mcf_edma->dma_dev.filter.mapcnt = pdata->slavecnt;

drivers/dma/mcf-edma-main.c

243

ret = dma_async_device_register(&mcf_edma->dma_dev);

drivers/dma/mcf-edma-main.c

261

fsl_edma_cleanup_vchan(&mcf_edma->dma_dev);

drivers/dma/mcf-edma-main.c

262

dma_async_device_unregister(&mcf_edma->dma_dev);

drivers/dma/mv_xor.c

1040

struct dma_device *dma_dev;

drivers/dma/mv_xor.c

1053

dma_dev = &mv_chan->dmadev;

drivers/dma/mv_xor.c

1054

dma_dev->dev = &pdev->dev;

drivers/dma/mv_xor.c

1062

mv_chan->dummy_src_addr = dma_map_single(dma_dev->dev,

drivers/dma/mv_xor.c

1064

if (dma_mapping_error(dma_dev->dev, mv_chan->dummy_src_addr))

drivers/dma/mv_xor.c

1067

mv_chan->dummy_dst_addr = dma_map_single(dma_dev->dev,

drivers/dma/mv_xor.c

1069

if (dma_mapping_error(dma_dev->dev, mv_chan->dummy_dst_addr)) {

drivers/dma/mv_xor.c

1088

dma_dev->cap_mask = cap_mask;

drivers/dma/mv_xor.c

1090

INIT_LIST_HEAD(&dma_dev->channels);

drivers/dma/mv_xor.c

1093

dma_dev->device_alloc_chan_resources = mv_xor_alloc_chan_resources;

drivers/dma/mv_xor.c

1094

dma_dev->device_free_chan_resources = mv_xor_free_chan_resources;

drivers/dma/mv_xor.c

1095

dma_dev->device_tx_status = mv_xor_status;

drivers/dma/mv_xor.c

1096

dma_dev->device_issue_pending = mv_xor_issue_pending;

drivers/dma/mv_xor.c

1099

if (dma_has_cap(DMA_INTERRUPT, dma_dev->cap_mask))

drivers/dma/mv_xor.c

1100

dma_dev->device_prep_dma_interrupt = mv_xor_prep_dma_interrupt;

drivers/dma/mv_xor.c

1101

if (dma_has_cap(DMA_MEMCPY, dma_dev->cap_mask))

drivers/dma/mv_xor.c

1102

dma_dev->device_prep_dma_memcpy = mv_xor_prep_dma_memcpy;

drivers/dma/mv_xor.c

1103

if (dma_has_cap(DMA_XOR, dma_dev->cap_mask)) {

drivers/dma/mv_xor.c

1104

dma_dev->max_xor = 8;

drivers/dma/mv_xor.c

1105

dma_dev->device_prep_dma_xor = mv_xor_prep_dma_xor;

drivers/dma/mv_xor.c

1132

mv_chan->dmachan.device = dma_dev;

drivers/dma/mv_xor.c

1135

list_add_tail(&mv_chan->dmachan.device_node, &dma_dev->channels);

drivers/dma/mv_xor.c

1137

if (dma_has_cap(DMA_MEMCPY, dma_dev->cap_mask)) {

drivers/dma/mv_xor.c

1144

if (dma_has_cap(DMA_XOR, dma_dev->cap_mask)) {

drivers/dma/mv_xor.c

1153

dma_has_cap(DMA_XOR, dma_dev->cap_mask) ? "xor " : "",

drivers/dma/mv_xor.c

1154

dma_has_cap(DMA_MEMCPY, dma_dev->cap_mask) ? "cpy " : "",

drivers/dma/mv_xor.c

1155

dma_has_cap(DMA_INTERRUPT, dma_dev->cap_mask) ? "intr " : "");

drivers/dma/mv_xor.c

1157

ret = dma_async_device_register(dma_dev);

drivers/dma/mv_xor.c

1169

dma_unmap_single(dma_dev->dev, mv_chan->dummy_dst_addr,

drivers/dma/mv_xor.c

1172

dma_unmap_single(dma_dev->dev, mv_chan->dummy_src_addr,

drivers/dma/mv_xor_v2.c

718

struct dma_device *dma_dev;

drivers/dma/mv_xor_v2.c

811

dma_dev = &xor_dev->dmadev;

drivers/dma/mv_xor_v2.c

814

dma_cap_zero(dma_dev->cap_mask);

drivers/dma/mv_xor_v2.c

815

dma_cap_set(DMA_MEMCPY, dma_dev->cap_mask);

drivers/dma/mv_xor_v2.c

816

dma_cap_set(DMA_XOR, dma_dev->cap_mask);

drivers/dma/mv_xor_v2.c

817

dma_cap_set(DMA_INTERRUPT, dma_dev->cap_mask);

drivers/dma/mv_xor_v2.c

820

INIT_LIST_HEAD(&dma_dev->channels);

drivers/dma/mv_xor_v2.c

823

dma_dev->device_tx_status = dma_cookie_status;

drivers/dma/mv_xor_v2.c

824

dma_dev->device_issue_pending = mv_xor_v2_issue_pending;

drivers/dma/mv_xor_v2.c

825

dma_dev->dev = &pdev->dev;

drivers/dma/mv_xor_v2.c

827

dma_dev->device_prep_dma_memcpy = mv_xor_v2_prep_dma_memcpy;

drivers/dma/mv_xor_v2.c

828

dma_dev->device_prep_dma_interrupt = mv_xor_v2_prep_dma_interrupt;

drivers/dma/mv_xor_v2.c

829

dma_dev->max_xor = 8;

drivers/dma/mv_xor_v2.c

830

dma_dev->device_prep_dma_xor = mv_xor_v2_prep_dma_xor;

drivers/dma/mv_xor_v2.c

832

xor_dev->dmachan.device = dma_dev;

drivers/dma/mv_xor_v2.c

835

&dma_dev->channels);

drivers/dma/mv_xor_v2.c

841

ret = dma_async_device_register(dma_dev);

drivers/dma/nbpfaxi.c

1110

dchan = dma_get_any_slave_channel(&nbpf->dma_dev);

drivers/dma/nbpfaxi.c

1241

dev_warn(nbpf->dma_dev.dev, "DMA error IRQ %u\n", irq);

drivers/dma/nbpfaxi.c

1259

struct dma_device *dma_dev = &nbpf->dma_dev;

drivers/dma/nbpfaxi.c

1267

chan->dma_chan.device = dma_dev;

drivers/dma/nbpfaxi.c

1271

dev_dbg(dma_dev->dev, "%s(): channel %d: -> %p\n", __func__, n, chan->base);

drivers/dma/nbpfaxi.c

1276

ret = devm_request_irq(dma_dev->dev, chan->irq,

drivers/dma/nbpfaxi.c

1284

&dma_dev->channels);

drivers/dma/nbpfaxi.c

1308

struct dma_device *dma_dev;

drivers/dma/nbpfaxi.c

1329

dma_dev = &nbpf->dma_dev;

drivers/dma/nbpfaxi.c

1330

dma_dev->dev = dev;

drivers/dma/nbpfaxi.c

1404

INIT_LIST_HEAD(&dma_dev->channels);

drivers/dma/nbpfaxi.c

1413

dma_cap_set(DMA_MEMCPY, dma_dev->cap_mask);

drivers/dma/nbpfaxi.c

1414

dma_cap_set(DMA_SLAVE, dma_dev->cap_mask);

drivers/dma/nbpfaxi.c

1415

dma_cap_set(DMA_PRIVATE, dma_dev->cap_mask);

drivers/dma/nbpfaxi.c

1418

dma_dev->device_alloc_chan_resources

drivers/dma/nbpfaxi.c

1420

dma_dev->device_free_chan_resources = nbpf_free_chan_resources;

drivers/dma/nbpfaxi.c

1421

dma_dev->device_prep_dma_memcpy = nbpf_prep_memcpy;

drivers/dma/nbpfaxi.c

1422

dma_dev->device_tx_status = nbpf_tx_status;

drivers/dma/nbpfaxi.c

1423

dma_dev->device_issue_pending = nbpf_issue_pending;

drivers/dma/nbpfaxi.c

1434

dma_dev->device_prep_slave_sg = nbpf_prep_slave_sg;

drivers/dma/nbpfaxi.c

1435

dma_dev->device_config = nbpf_config;

drivers/dma/nbpfaxi.c

1436

dma_dev->device_pause = nbpf_pause;

drivers/dma/nbpfaxi.c

1437

dma_dev->device_terminate_all = nbpf_terminate_all;

drivers/dma/nbpfaxi.c

1439

dma_dev->src_addr_widths = NBPF_DMA_BUSWIDTHS;

drivers/dma/nbpfaxi.c

1440

dma_dev->dst_addr_widths = NBPF_DMA_BUSWIDTHS;

drivers/dma/nbpfaxi.c

1441

dma_dev->directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);

drivers/dma/nbpfaxi.c

1451

ret = dma_async_device_register(dma_dev);

drivers/dma/nbpfaxi.c

1462

dma_async_device_unregister(dma_dev);

drivers/dma/nbpfaxi.c

1485

dma_async_device_unregister(&nbpf->dma_dev);

drivers/dma/nbpfaxi.c

229

struct dma_device dma_dev;

drivers/dma/nbpfaxi.c

325

dev_dbg(nbpf->dma_dev.dev, "%s(0x%p + 0x%x) = 0x%x\n",

drivers/dma/nbpfaxi.c

334

dev_dbg(nbpf->dma_dev.dev, "%s(0x%p + 0x%x) = 0x%x\n",

drivers/dma/nbpfaxi.c

400

dev_dbg(chan->nbpf->dma_dev.dev, "%s(): next 0x%x, cur 0x%x\n", __func__,

drivers/dma/nbpfaxi.c

869

dev_dbg(chan->nbpf->dma_dev.dev, "%s(): force-free desc %p cookie %d\n",

drivers/dma/plx_dma.c

104

struct dma_device dma_dev;

drivers/dma/plx_dma.c

219

dev_err(plxdev->dma_dev.dev,

drivers/dma/plx_dma.c

413

plxdev->hw_ring = dma_alloc_coherent(plxdev->dma_dev.dev, ring_sz,

drivers/dma/plx_dma.c

446

dma_free_coherent(plxdev->dma_dev.dev, ring_sz, plxdev->hw_ring,

drivers/dma/plx_dma.c

482

dma_free_coherent(plxdev->dma_dev.dev, ring_sz, plxdev->hw_ring,

drivers/dma/plx_dma.c

487

static void plx_dma_release(struct dma_device *dma_dev)

drivers/dma/plx_dma.c

490

container_of(dma_dev, struct plx_dma_dev, dma_dev);

drivers/dma/plx_dma.c

492

put_device(dma_dev->dev);

drivers/dma/plx_dma.c

518

dma = &plxdev->dma_dev;

drivers/dma/plx_dma.c

610

dma_async_device_unregister(&plxdev->dma_dev);

drivers/dma/sf-pdma/sf-pdma.c

260

dev_err(chan->pdma->dma_dev.dev, "NULL desc.\n");

drivers/dma/sf-pdma/sf-pdma.c

456

INIT_LIST_HEAD(&pdma->dma_dev.channels);

drivers/dma/sf-pdma/sf-pdma.c

487

vchan_init(&chan->vchan, &pdma->dma_dev);

drivers/dma/sf-pdma/sf-pdma.c

542

pdma->dma_dev.dev = &pdev->dev;

drivers/dma/sf-pdma/sf-pdma.c

545

dma_cap_set(DMA_MEMCPY, pdma->dma_dev.cap_mask);

drivers/dma/sf-pdma/sf-pdma.c

546

pdma->dma_dev.copy_align = 2;

drivers/dma/sf-pdma/sf-pdma.c

547

pdma->dma_dev.src_addr_widths = widths;

drivers/dma/sf-pdma/sf-pdma.c

548

pdma->dma_dev.dst_addr_widths = widths;

drivers/dma/sf-pdma/sf-pdma.c

549

pdma->dma_dev.directions = BIT(DMA_MEM_TO_MEM);

drivers/dma/sf-pdma/sf-pdma.c

550

pdma->dma_dev.residue_granularity = DMA_RESIDUE_GRANULARITY_DESCRIPTOR;

drivers/dma/sf-pdma/sf-pdma.c

551

pdma->dma_dev.descriptor_reuse = true;

drivers/dma/sf-pdma/sf-pdma.c

554

pdma->dma_dev.device_alloc_chan_resources =

drivers/dma/sf-pdma/sf-pdma.c

556

pdma->dma_dev.device_free_chan_resources =

drivers/dma/sf-pdma/sf-pdma.c

558

pdma->dma_dev.device_tx_status = sf_pdma_tx_status;

drivers/dma/sf-pdma/sf-pdma.c

559

pdma->dma_dev.device_prep_dma_memcpy = sf_pdma_prep_dma_memcpy;

drivers/dma/sf-pdma/sf-pdma.c

560

pdma->dma_dev.device_config = sf_pdma_slave_config;

drivers/dma/sf-pdma/sf-pdma.c

561

pdma->dma_dev.device_terminate_all = sf_pdma_terminate_all;

drivers/dma/sf-pdma/sf-pdma.c

562

pdma->dma_dev.device_issue_pending = sf_pdma_issue_pending;

drivers/dma/sf-pdma/sf-pdma.c

571

ret = dma_async_device_register(&pdma->dma_dev);

drivers/dma/sf-pdma/sf-pdma.c

589

dma_async_device_unregister(&pdma->dma_dev);

drivers/dma/sf-pdma/sf-pdma.c

614

dma_async_device_unregister(&pdma->dma_dev);

drivers/dma/sf-pdma/sf-pdma.c

93

dev_err(chan->pdma->dma_dev.dev,

drivers/dma/sf-pdma/sf-pdma.h

113

struct dma_device dma_dev;

drivers/dma/sh/shdma-base.c

1019

INIT_LIST_HEAD(&dma_dev->channels);

drivers/dma/sh/shdma-base.c

1022

dma_dev->device_alloc_chan_resources

drivers/dma/sh/shdma-base.c

1024

dma_dev->device_free_chan_resources = shdma_free_chan_resources;

drivers/dma/sh/shdma-base.c

1025

dma_dev->device_prep_dma_memcpy = shdma_prep_memcpy;

drivers/dma/sh/shdma-base.c

1026

dma_dev->device_tx_status = shdma_tx_status;

drivers/dma/sh/shdma-base.c

1027

dma_dev->device_issue_pending = shdma_issue_pending;

drivers/dma/sh/shdma-base.c

1030

dma_dev->device_prep_slave_sg = shdma_prep_slave_sg;

drivers/dma/sh/shdma-base.c

1031

dma_dev->device_prep_dma_cyclic = shdma_prep_dma_cyclic;

drivers/dma/sh/shdma-base.c

1032

dma_dev->device_config = shdma_config;

drivers/dma/sh/shdma-base.c

1033

dma_dev->device_terminate_all = shdma_terminate_all;

drivers/dma/sh/shdma-base.c

1035

dma_dev->dev = dev;

drivers/dma/sh/shdma-base.c

319

dev_warn(sdev->dma_dev.dev, "invalid slave ID passed to dma_request_slave\n");

drivers/dma/sh/shdma-base.c

37

#define to_shdma_dev(d) container_of(d, struct shdma_dev, dma_dev)

drivers/dma/sh/shdma-base.c

965

schan->dma_chan.device = &sdev->dma_dev;

drivers/dma/sh/shdma-base.c

968

schan->dev = sdev->dma_dev.dev;

drivers/dma/sh/shdma-base.c

982

&sdev->dma_dev.channels);

drivers/dma/sh/shdma-base.c

996

struct dma_device *dma_dev = &sdev->dma_dev;

drivers/dma/sh/shdma.h

59

struct sh_dmae_device, shdma_dev.dma_dev)

drivers/dma/sh/shdmac.c

164

dev_warn(shdev->shdma_dev.dma_dev.dev, "Can't initialize DMAOR.\n");

drivers/dma/sh/shdmac.c

168

dev_warn(shdev->shdma_dev.dma_dev.dev,

drivers/dma/sh/shdmac.c

530

struct platform_device *pdev = to_platform_device(sdev->dma_dev.dev);

drivers/dma/sh/shdmac.c

535

sh_chan = devm_kzalloc(sdev->dma_dev.dev, sizeof(struct sh_dmae_chan),

drivers/dma/sh/shdmac.c

557

dev_err(sdev->dma_dev.dev,

drivers/dma/sh/shdmac.c

688

struct dma_device *dma_dev;

drivers/dma/sh/shdmac.c

727

dma_dev = &shdev->shdma_dev.dma_dev;

drivers/dma/sh/shdmac.c

738

dma_dev->src_addr_widths = widths;

drivers/dma/sh/shdmac.c

739

dma_dev->dst_addr_widths = widths;

drivers/dma/sh/shdmac.c

740

dma_dev->directions = BIT(DMA_MEM_TO_DEV) | BIT(DMA_DEV_TO_MEM);

drivers/dma/sh/shdmac.c

741

dma_dev->residue_granularity = DMA_RESIDUE_GRANULARITY_DESCRIPTOR;

drivers/dma/sh/shdmac.c

744

dma_cap_set(DMA_MEMCPY, dma_dev->cap_mask);

drivers/dma/sh/shdmac.c

746

dma_cap_set(DMA_SLAVE, dma_dev->cap_mask);

drivers/dma/sh/shdmac.c

749

dma_dev->copy_align = LOG2_DEFAULT_XFER_SIZE;

drivers/dma/sh/shdmac.c

866

err = dma_async_device_register(&shdev->shdma_dev.dma_dev);

drivers/dma/sh/shdmac.c

897

struct dma_device *dma_dev = &shdev->shdma_dev.dma_dev;

drivers/dma/sh/shdmac.c

899

dma_async_device_unregister(dma_dev);

drivers/dma/sprd-dma.c

1177

dma_cap_set(DMA_MEMCPY, sdev->dma_dev.cap_mask);

drivers/dma/sprd-dma.c

1179

INIT_LIST_HEAD(&sdev->dma_dev.channels);

drivers/dma/sprd-dma.c

1180

INIT_LIST_HEAD(&sdev->dma_dev.global_node);

drivers/dma/sprd-dma.c

1181

sdev->dma_dev.dev = &pdev->dev;

drivers/dma/sprd-dma.c

1182

sdev->dma_dev.device_alloc_chan_resources = sprd_dma_alloc_chan_resources;

drivers/dma/sprd-dma.c

1183

sdev->dma_dev.device_free_chan_resources = sprd_dma_free_chan_resources;

drivers/dma/sprd-dma.c

1184

sdev->dma_dev.device_tx_status = sprd_dma_tx_status;

drivers/dma/sprd-dma.c

1185

sdev->dma_dev.device_issue_pending = sprd_dma_issue_pending;

drivers/dma/sprd-dma.c

1186

sdev->dma_dev.device_prep_dma_memcpy = sprd_dma_prep_dma_memcpy;

drivers/dma/sprd-dma.c

1187

sdev->dma_dev.device_prep_slave_sg = sprd_dma_prep_slave_sg;

drivers/dma/sprd-dma.c

1188

sdev->dma_dev.device_config = sprd_dma_slave_config;

drivers/dma/sprd-dma.c

1189

sdev->dma_dev.device_pause = sprd_dma_pause;

drivers/dma/sprd-dma.c

1190

sdev->dma_dev.device_resume = sprd_dma_resume;

drivers/dma/sprd-dma.c

1191

sdev->dma_dev.device_terminate_all = sprd_dma_terminate_all;

drivers/dma/sprd-dma.c

1202

vchan_init(&dma_chn->vc, &sdev->dma_dev);

drivers/dma/sprd-dma.c

1217

ret = dma_async_device_register(&sdev->dma_dev);

drivers/dma/sprd-dma.c

1223

sprd_dma_info.dma_cap = sdev->dma_dev.cap_mask;

drivers/dma/sprd-dma.c

1233

dma_async_device_unregister(&sdev->dma_dev);

drivers/dma/sprd-dma.c

1253

list_for_each_entry_safe(c, cn, &sdev->dma_dev.channels,

drivers/dma/sprd-dma.c

1260

dma_async_device_unregister(&sdev->dma_dev);

drivers/dma/sprd-dma.c

1288

dev_err(sdev->dma_dev.dev, "enable dma failed\n");

drivers/dma/sprd-dma.c

209

struct dma_device dma_dev;

drivers/dma/sprd-dma.c

358

dev_warn(sdev->dma_dev.dev,

drivers/dma/sprd-dma.c

422

dev_warn(sdev->dma_dev.dev, "incorrect dma interrupt type\n");

drivers/dma/sprd-dma.c

481

dev_err(sdev->dma_dev.dev, "invalid channel mode setting %d\n",

drivers/dma/sprd-dma.c

762

dev_err(sdev->dma_dev.dev, "invalid source step\n");

drivers/dma/sprd-dma.c

778

dev_err(sdev->dma_dev.dev, "invalid destination step\n");

drivers/dma/sprd-dma.c

786

dev_err(sdev->dma_dev.dev, "invalid source datawidth\n");

drivers/dma/sprd-dma.c

792

dev_err(sdev->dma_dev.dev, "invalid destination datawidth\n");

drivers/dma/stm32/stm32-dma3.c

1638

dma_cap_mask_t mask = ddata->dma_dev.cap_mask;

drivers/dma/stm32/stm32-dma3.c

1736

struct dma_device *dma_dev;

drivers/dma/stm32/stm32-dma3.c

1746

dma_dev = &ddata->dma_dev;

drivers/dma/stm32/stm32-dma3.c

1766

INIT_LIST_HEAD(&dma_dev->channels);

drivers/dma/stm32/stm32-dma3.c

1768

dma_cap_set(DMA_SLAVE, dma_dev->cap_mask);

drivers/dma/stm32/stm32-dma3.c

1769

dma_cap_set(DMA_PRIVATE, dma_dev->cap_mask);

drivers/dma/stm32/stm32-dma3.c

1770

dma_cap_set(DMA_CYCLIC, dma_dev->cap_mask);

drivers/dma/stm32/stm32-dma3.c

1771

dma_cap_set(DMA_MEMCPY, dma_dev->cap_mask);

drivers/dma/stm32/stm32-dma3.c

1772

dma_dev->dev = &pdev->dev;

drivers/dma/stm32/stm32-dma3.c

1777

dma_dev->copy_align = DMAENGINE_ALIGN_8_BYTES;

drivers/dma/stm32/stm32-dma3.c

1778

dma_dev->src_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_1_BYTE) |

drivers/dma/stm32/stm32-dma3.c

1782

dma_dev->dst_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_1_BYTE) |

drivers/dma/stm32/stm32-dma3.c

1786

dma_dev->directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV) | BIT(DMA_MEM_TO_MEM);

drivers/dma/stm32/stm32-dma3.c

1788

dma_dev->descriptor_reuse = true;

drivers/dma/stm32/stm32-dma3.c

1789

dma_dev->max_sg_burst = STM32_DMA3_MAX_SEG_SIZE;

drivers/dma/stm32/stm32-dma3.c

1790

dma_dev->residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;

drivers/dma/stm32/stm32-dma3.c

1791

dma_dev->device_alloc_chan_resources = stm32_dma3_alloc_chan_resources;

drivers/dma/stm32/stm32-dma3.c

1792

dma_dev->device_free_chan_resources = stm32_dma3_free_chan_resources;

drivers/dma/stm32/stm32-dma3.c

1793

dma_dev->device_prep_dma_memcpy = stm32_dma3_prep_dma_memcpy;

drivers/dma/stm32/stm32-dma3.c

1794

dma_dev->device_prep_slave_sg = stm32_dma3_prep_slave_sg;

drivers/dma/stm32/stm32-dma3.c

1795

dma_dev->device_prep_dma_cyclic = stm32_dma3_prep_dma_cyclic;

drivers/dma/stm32/stm32-dma3.c

1796

dma_dev->device_caps = stm32_dma3_caps;

drivers/dma/stm32/stm32-dma3.c

1797

dma_dev->device_config = stm32_dma3_config;

drivers/dma/stm32/stm32-dma3.c

1798

dma_dev->device_pause = stm32_dma3_pause;

drivers/dma/stm32/stm32-dma3.c

1799

dma_dev->device_resume = stm32_dma3_resume;

drivers/dma/stm32/stm32-dma3.c

1800

dma_dev->device_terminate_all = stm32_dma3_terminate_all;

drivers/dma/stm32/stm32-dma3.c

1801

dma_dev->device_synchronize = stm32_dma3_synchronize;

drivers/dma/stm32/stm32-dma3.c

1802

dma_dev->device_tx_status = stm32_dma3_tx_status;

drivers/dma/stm32/stm32-dma3.c

1803

dma_dev->device_issue_pending = stm32_dma3_issue_pending;

drivers/dma/stm32/stm32-dma3.c

1867

ret = dmaenginem_async_device_register(dma_dev);

drivers/dma/stm32/stm32-dma3.c

1878

snprintf(name, sizeof(name), "dma%dchan%d", ddata->dma_dev.dev_id, chan->id);

drivers/dma/stm32/stm32-dma3.c

1881

vchan_init(&chan->vchan, dma_dev);

drivers/dma/stm32/stm32-dma3.c

1883

ret = dma_async_device_channel_register(&ddata->dma_dev, &chan->vchan.chan, name);

drivers/dma/stm32/stm32-dma3.c

1956

struct dma_device *dma_dev = &ddata->dma_dev;

drivers/dma/stm32/stm32-dma3.c

1964

list_for_each_entry(c, &dma_dev->channels, device_node) {

drivers/dma/stm32/stm32-dma3.c

1986

struct dma_device *dma_dev = &ddata->dma_dev;

drivers/dma/stm32/stm32-dma3.c

2002

list_for_each_entry(c, &dma_dev->channels, device_node) {

drivers/dma/stm32/stm32-dma3.c

306

struct dma_device dma_dev;

drivers/dma/stm32/stm32-dma3.c

318

return container_of(chan->vchan.chan.device, struct stm32_dma3_ddata, dma_dev);

drivers/dma/stm32/stm32-dma3.c

338

return ddata->dma_dev.dev;

drivers/dma/stm32/stm32-dma3.c

573

struct dma_device dma_device = ddata->dma_dev;

drivers/dma/tegra186-gpc-dma.c

1297

chan = dma_get_any_slave_channel(&tdma->dma_dev);

drivers/dma/tegra186-gpc-dma.c

1391

tdma->dma_dev.dev = &pdev->dev;

drivers/dma/tegra186-gpc-dma.c

1407

INIT_LIST_HEAD(&tdma->dma_dev.channels);

drivers/dma/tegra186-gpc-dma.c

1426

vchan_init(&tdc->vc, &tdma->dma_dev);

drivers/dma/tegra186-gpc-dma.c

1434

dma_cap_set(DMA_SLAVE, tdma->dma_dev.cap_mask);

drivers/dma/tegra186-gpc-dma.c

1435

dma_cap_set(DMA_PRIVATE, tdma->dma_dev.cap_mask);

drivers/dma/tegra186-gpc-dma.c

1436

dma_cap_set(DMA_MEMCPY, tdma->dma_dev.cap_mask);

drivers/dma/tegra186-gpc-dma.c

1437

dma_cap_set(DMA_MEMSET, tdma->dma_dev.cap_mask);

drivers/dma/tegra186-gpc-dma.c

1438

dma_cap_set(DMA_CYCLIC, tdma->dma_dev.cap_mask);

drivers/dma/tegra186-gpc-dma.c

1444

tdma->dma_dev.copy_align = 2;

drivers/dma/tegra186-gpc-dma.c

1445

tdma->dma_dev.fill_align = 2;

drivers/dma/tegra186-gpc-dma.c

1446

tdma->dma_dev.device_alloc_chan_resources =

drivers/dma/tegra186-gpc-dma.c

1448

tdma->dma_dev.device_free_chan_resources =

drivers/dma/tegra186-gpc-dma.c

1450

tdma->dma_dev.device_prep_slave_sg = tegra_dma_prep_slave_sg;

drivers/dma/tegra186-gpc-dma.c

1451

tdma->dma_dev.device_prep_dma_memcpy = tegra_dma_prep_dma_memcpy;

drivers/dma/tegra186-gpc-dma.c

1452

tdma->dma_dev.device_prep_dma_memset = tegra_dma_prep_dma_memset;

drivers/dma/tegra186-gpc-dma.c

1453

tdma->dma_dev.device_prep_dma_cyclic = tegra_dma_prep_dma_cyclic;

drivers/dma/tegra186-gpc-dma.c

1454

tdma->dma_dev.device_config = tegra_dma_slave_config;

drivers/dma/tegra186-gpc-dma.c

1455

tdma->dma_dev.device_terminate_all = tegra_dma_terminate_all;

drivers/dma/tegra186-gpc-dma.c

1456

tdma->dma_dev.device_tx_status = tegra_dma_tx_status;

drivers/dma/tegra186-gpc-dma.c

1457

tdma->dma_dev.device_issue_pending = tegra_dma_issue_pending;

drivers/dma/tegra186-gpc-dma.c

1458

tdma->dma_dev.device_pause = tegra_dma_device_pause;

drivers/dma/tegra186-gpc-dma.c

1459

tdma->dma_dev.device_resume = tegra_dma_device_resume;

drivers/dma/tegra186-gpc-dma.c

1460

tdma->dma_dev.device_synchronize = tegra_dma_chan_synchronize;

drivers/dma/tegra186-gpc-dma.c

1461

tdma->dma_dev.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;

drivers/dma/tegra186-gpc-dma.c

1463

ret = dma_async_device_register(&tdma->dma_dev);

drivers/dma/tegra186-gpc-dma.c

1476

dma_async_device_unregister(&tdma->dma_dev);

drivers/dma/tegra186-gpc-dma.c

1491

dma_async_device_unregister(&tdma->dma_dev);

drivers/dma/tegra186-gpc-dma.c

256

struct dma_device dma_dev;

drivers/dma/tegra20-apb-dma.c

1357

chan = dma_get_any_slave_channel(&tdma->dma_dev);

drivers/dma/tegra20-apb-dma.c

1481

INIT_LIST_HEAD(&tdma->dma_dev.channels);

drivers/dma/tegra20-apb-dma.c

1506

tdc->dma_chan.device = &tdma->dma_dev;

drivers/dma/tegra20-apb-dma.c

1509

&tdma->dma_dev.channels);

drivers/dma/tegra20-apb-dma.c

1524

dma_cap_set(DMA_SLAVE, tdma->dma_dev.cap_mask);

drivers/dma/tegra20-apb-dma.c

1525

dma_cap_set(DMA_PRIVATE, tdma->dma_dev.cap_mask);

drivers/dma/tegra20-apb-dma.c

1526

dma_cap_set(DMA_CYCLIC, tdma->dma_dev.cap_mask);

drivers/dma/tegra20-apb-dma.c

1529

tdma->dma_dev.dev = &pdev->dev;

drivers/dma/tegra20-apb-dma.c

1530

tdma->dma_dev.device_alloc_chan_resources =

drivers/dma/tegra20-apb-dma.c

1532

tdma->dma_dev.device_free_chan_resources =

drivers/dma/tegra20-apb-dma.c

1534

tdma->dma_dev.device_prep_slave_sg = tegra_dma_prep_slave_sg;

drivers/dma/tegra20-apb-dma.c

1535

tdma->dma_dev.device_prep_dma_cyclic = tegra_dma_prep_dma_cyclic;

drivers/dma/tegra20-apb-dma.c

1536

tdma->dma_dev.src_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_1_BYTE) |

drivers/dma/tegra20-apb-dma.c

1540

tdma->dma_dev.dst_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_1_BYTE) |

drivers/dma/tegra20-apb-dma.c

1544

tdma->dma_dev.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);

drivers/dma/tegra20-apb-dma.c

1545

tdma->dma_dev.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;

drivers/dma/tegra20-apb-dma.c

1546

tdma->dma_dev.device_config = tegra_dma_slave_config;

drivers/dma/tegra20-apb-dma.c

1547

tdma->dma_dev.device_terminate_all = tegra_dma_terminate_all;

drivers/dma/tegra20-apb-dma.c

1548

tdma->dma_dev.device_synchronize = tegra_dma_synchronize;

drivers/dma/tegra20-apb-dma.c

1549

tdma->dma_dev.device_tx_status = tegra_dma_tx_status;

drivers/dma/tegra20-apb-dma.c

1550

tdma->dma_dev.device_issue_pending = tegra_dma_issue_pending;

drivers/dma/tegra20-apb-dma.c

1552

ret = dma_async_device_register(&tdma->dma_dev);

drivers/dma/tegra20-apb-dma.c

1573

dma_async_device_unregister(&tdma->dma_dev);

drivers/dma/tegra20-apb-dma.c

1589

dma_async_device_unregister(&tdma->dma_dev);

drivers/dma/tegra20-apb-dma.c

211

struct dma_device dma_dev;

drivers/dma/tegra210-adma.c

1111

INIT_LIST_HEAD(&tdma->dma_dev.channels);

drivers/dma/tegra210-adma.c

1136

vchan_init(&tdc->vc, &tdma->dma_dev);

drivers/dma/tegra210-adma.c

1151

dma_cap_set(DMA_SLAVE, tdma->dma_dev.cap_mask);

drivers/dma/tegra210-adma.c

1152

dma_cap_set(DMA_PRIVATE, tdma->dma_dev.cap_mask);

drivers/dma/tegra210-adma.c

1153

dma_cap_set(DMA_CYCLIC, tdma->dma_dev.cap_mask);

drivers/dma/tegra210-adma.c

1155

tdma->dma_dev.dev = &pdev->dev;

drivers/dma/tegra210-adma.c

1156

tdma->dma_dev.device_alloc_chan_resources =

drivers/dma/tegra210-adma.c

1158

tdma->dma_dev.device_free_chan_resources =

drivers/dma/tegra210-adma.c

1160

tdma->dma_dev.device_issue_pending = tegra_adma_issue_pending;

drivers/dma/tegra210-adma.c

1161

tdma->dma_dev.device_prep_dma_cyclic = tegra_adma_prep_dma_cyclic;

drivers/dma/tegra210-adma.c

1162

tdma->dma_dev.device_config = tegra_adma_slave_config;

drivers/dma/tegra210-adma.c

1163

tdma->dma_dev.device_tx_status = tegra_adma_tx_status;

drivers/dma/tegra210-adma.c

1164

tdma->dma_dev.device_terminate_all = tegra_adma_terminate_all;

drivers/dma/tegra210-adma.c

1165

tdma->dma_dev.device_synchronize = tegra_adma_synchronize;

drivers/dma/tegra210-adma.c

1166

tdma->dma_dev.src_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);

drivers/dma/tegra210-adma.c

1167

tdma->dma_dev.dst_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);

drivers/dma/tegra210-adma.c

1168

tdma->dma_dev.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);

drivers/dma/tegra210-adma.c

1169

tdma->dma_dev.residue_granularity = DMA_RESIDUE_GRANULARITY_SEGMENT;

drivers/dma/tegra210-adma.c

1170

tdma->dma_dev.device_pause = tegra_adma_pause;

drivers/dma/tegra210-adma.c

1171

tdma->dma_dev.device_resume = tegra_adma_resume;

drivers/dma/tegra210-adma.c

1173

ret = dma_async_device_register(&tdma->dma_dev);

drivers/dma/tegra210-adma.c

1194

dma_async_device_unregister(&tdma->dma_dev);

drivers/dma/tegra210-adma.c

1212

dma_async_device_unregister(&tdma->dma_dev);

drivers/dma/tegra210-adma.c

187

struct dma_device dma_dev;

drivers/dma/tegra210-adma.c

829

chan = dma_get_any_slave_channel(&tdma->dma_dev);

drivers/dma/ti/k3-udma-glue.c

338

cfg->tx_cfg.dma_dev = k3_udma_glue_tx_get_dma_device(tx_chn);

drivers/dma/ti/k3-udma-glue.c

339

cfg->txcq_cfg.dma_dev = cfg->tx_cfg.dma_dev;

drivers/dma/ti/k3-udma-glue.c

777

flow_cfg->rx_cfg.dma_dev = k3_udma_glue_rx_get_dma_device(rx_chn);

drivers/dma/ti/k3-udma-glue.c

778

flow_cfg->rxfdq_cfg.dma_dev = flow_cfg->rx_cfg.dma_dev;

drivers/dma/ti/k3-udma.c

1649

ring_cfg.dma_dev = dmaengine_get_dma_device(&uc->vc.chan);

drivers/dma/ti/k3-udma.c

1717

ring_cfg.dma_dev = dmaengine_get_dma_device(&uc->vc.chan);

drivers/dma/ti/k3-udma.c

1814

ring_cfg.dma_dev = dmaengine_get_dma_device(&uc->vc.chan);

drivers/dma/ti/k3-udma.c

2192

uc->dma_dev = ud->dev;

drivers/dma/ti/k3-udma.c

2483

uc->dma_dev = dmaengine_get_dma_device(chan);

drivers/dma/ti/k3-udma.c

2676

uc->dma_dev = dmaengine_get_dma_device(chan);

drivers/dma/ti/k3-udma.c

2677

uc->hdesc_pool = dma_pool_create(uc->name, uc->dma_dev,

drivers/dma/ti/k3-udma.c

281

struct device *dma_dev;

drivers/dma/ti/k3-udma.c

5362

struct dma_device *dma_dev)

drivers/dma/ti/k3-udma.c

5366

list_for_each_entry(chan, &dma_dev->channels, device_node) {

drivers/dma/ti/k3-udma.c

547

dma_free_coherent(uc->dma_dev, d->hwdesc[0].cppi5_desc_size,

drivers/dma/ti/k3-udma.c

5659

struct dma_device *dma_dev = &ud->ddev;

drivers/dma/ti/k3-udma.c

5663

list_for_each_entry(chan, &dma_dev->channels, device_node) {

drivers/dma/ti/k3-udma.c

5681

struct dma_device *dma_dev = &ud->ddev;

drivers/dma/ti/k3-udma.c

5686

list_for_each_entry(chan, &dma_dev->channels, device_node) {

drivers/dma/xgene-dma.c

1486

struct dma_device *dma_dev)

drivers/dma/xgene-dma.c

1489

dma_cap_zero(dma_dev->cap_mask);

drivers/dma/xgene-dma.c

1504

dma_cap_set(DMA_PQ, dma_dev->cap_mask);

drivers/dma/xgene-dma.c

1505

dma_cap_set(DMA_XOR, dma_dev->cap_mask);

drivers/dma/xgene-dma.c

1508

dma_cap_set(DMA_XOR, dma_dev->cap_mask);

drivers/dma/xgene-dma.c

1512

dma_dev->dev = chan->dev;

drivers/dma/xgene-dma.c

1513

dma_dev->device_alloc_chan_resources = xgene_dma_alloc_chan_resources;

drivers/dma/xgene-dma.c

1514

dma_dev->device_free_chan_resources = xgene_dma_free_chan_resources;

drivers/dma/xgene-dma.c

1515

dma_dev->device_issue_pending = xgene_dma_issue_pending;

drivers/dma/xgene-dma.c

1516

dma_dev->device_tx_status = xgene_dma_tx_status;

drivers/dma/xgene-dma.c

1518

if (dma_has_cap(DMA_XOR, dma_dev->cap_mask)) {

drivers/dma/xgene-dma.c

1519

dma_dev->device_prep_dma_xor = xgene_dma_prep_xor;

drivers/dma/xgene-dma.c

1520

dma_dev->max_xor = XGENE_DMA_MAX_XOR_SRC;

drivers/dma/xgene-dma.c

1521

dma_dev->xor_align = DMAENGINE_ALIGN_64_BYTES;

drivers/dma/xgene-dma.c

1524

if (dma_has_cap(DMA_PQ, dma_dev->cap_mask)) {

drivers/dma/xgene-dma.c

1525

dma_dev->device_prep_dma_pq = xgene_dma_prep_pq;

drivers/dma/xgene-dma.c

1526

dma_dev->max_pq = XGENE_DMA_MAX_XOR_SRC;

drivers/dma/xgene-dma.c

1527

dma_dev->pq_align = DMAENGINE_ALIGN_64_BYTES;

drivers/dma/xgene-dma.c

1534

struct dma_device *dma_dev = &pdma->dma_dev[id];

drivers/dma/xgene-dma.c

1537

chan->dma_chan.device = dma_dev;

drivers/dma/xgene-dma.c

1550

xgene_dma_set_caps(chan, dma_dev);

drivers/dma/xgene-dma.c

1553

INIT_LIST_HEAD(&dma_dev->channels);

drivers/dma/xgene-dma.c

1554

list_add_tail(&chan->dma_chan.device_node, &dma_dev->channels);

drivers/dma/xgene-dma.c

1557

ret = dma_async_device_register(dma_dev);

drivers/dma/xgene-dma.c

1568

dma_has_cap(DMA_XOR, dma_dev->cap_mask) ? "XOR " : "",

drivers/dma/xgene-dma.c

1569

dma_has_cap(DMA_PQ, dma_dev->cap_mask) ? "PQ " : "");

drivers/dma/xgene-dma.c

1582

dma_async_device_unregister(&pdma->dma_dev[j]);

drivers/dma/xgene-dma.c

1598

dma_async_device_unregister(&pdma->dma_dev[i]);

drivers/dma/xgene-dma.c

311

struct dma_device dma_dev[XGENE_DMA_MAX_CHANNEL];

drivers/dma/xilinx/xdma.c

1187

dma_async_device_unregister(&xdev->dma_dev);

drivers/dma/xilinx/xdma.c

1241

INIT_LIST_HEAD(&xdev->dma_dev.channels);

drivers/dma/xilinx/xdma.c

1255

dma_cap_set(DMA_SLAVE, xdev->dma_dev.cap_mask);

drivers/dma/xilinx/xdma.c

1256

dma_cap_set(DMA_PRIVATE, xdev->dma_dev.cap_mask);

drivers/dma/xilinx/xdma.c

1257

dma_cap_set(DMA_CYCLIC, xdev->dma_dev.cap_mask);

drivers/dma/xilinx/xdma.c

1258

dma_cap_set(DMA_INTERLEAVE, xdev->dma_dev.cap_mask);

drivers/dma/xilinx/xdma.c

1259

dma_cap_set(DMA_REPEAT, xdev->dma_dev.cap_mask);

drivers/dma/xilinx/xdma.c

1260

dma_cap_set(DMA_LOAD_EOT, xdev->dma_dev.cap_mask);

drivers/dma/xilinx/xdma.c

1262

xdev->dma_dev.dev = &pdev->dev;

drivers/dma/xilinx/xdma.c

1263

xdev->dma_dev.residue_granularity = DMA_RESIDUE_GRANULARITY_SEGMENT;

drivers/dma/xilinx/xdma.c

1264

xdev->dma_dev.device_free_chan_resources = xdma_free_chan_resources;

drivers/dma/xilinx/xdma.c

1265

xdev->dma_dev.device_alloc_chan_resources = xdma_alloc_chan_resources;

drivers/dma/xilinx/xdma.c

1266

xdev->dma_dev.device_tx_status = xdma_tx_status;

drivers/dma/xilinx/xdma.c

1267

xdev->dma_dev.device_prep_slave_sg = xdma_prep_device_sg;

drivers/dma/xilinx/xdma.c

1268

xdev->dma_dev.device_config = xdma_device_config;

drivers/dma/xilinx/xdma.c

1269

xdev->dma_dev.device_issue_pending = xdma_issue_pending;

drivers/dma/xilinx/xdma.c

1270

xdev->dma_dev.device_terminate_all = xdma_terminate_all;

drivers/dma/xilinx/xdma.c

1271

xdev->dma_dev.device_synchronize = xdma_synchronize;

drivers/dma/xilinx/xdma.c

1272

xdev->dma_dev.filter.map = pdata->device_map;

drivers/dma/xilinx/xdma.c

1273

xdev->dma_dev.filter.mapcnt = pdata->device_map_cnt;

drivers/dma/xilinx/xdma.c

1274

xdev->dma_dev.filter.fn = xdma_filter_fn;

drivers/dma/xilinx/xdma.c

1275

xdev->dma_dev.device_prep_dma_cyclic = xdma_prep_dma_cyclic;

drivers/dma/xilinx/xdma.c

1276

xdev->dma_dev.device_prep_interleaved_dma = xdma_prep_interleaved_dma;

drivers/dma/xilinx/xdma.c

1278

ret = dma_async_device_register(&xdev->dma_dev);

drivers/dma/xilinx/xdma.c

128

struct dma_device dma_dev;

drivers/dma/xilinx/xdma.c

477

vchan_init(&xchan->vchan, &xdev->dma_dev);

drivers/dma/xilinx/xdma.c

812

struct device *dev = xdev->dma_dev.dev;

drivers/gpu/drm/drm_drv.c

513

void drm_dev_set_dma_dev(struct drm_device *dev, struct device *dma_dev)

drivers/gpu/drm/drm_drv.c

515

dma_dev = get_device(dma_dev);

drivers/gpu/drm/drm_drv.c

517

put_device(dev->dma_dev);

drivers/gpu/drm/drm_drv.c

518

dev->dma_dev = dma_dev;

drivers/gpu/drm/drm_drv.c

690

put_device(dev->dma_dev);

drivers/gpu/drm/drm_drv.c

691

dev->dma_dev = NULL;

drivers/gpu/drm/exynos/exynos_drm_dma.c

100

if (!priv->dma_dev) {

drivers/gpu/drm/exynos/exynos_drm_dma.c

101

priv->dma_dev = dev;

drivers/gpu/drm/exynos/exynos_drm_dma.c

116

mapping = iommu_get_domain_for_dev(priv->dma_dev);

drivers/gpu/drm/exynos/exynos_drm_dma.c

142

priv->dma_dev = NULL;

drivers/gpu/drm/exynos/exynos_drm_dma.c

48

if (get_dma_ops(priv->dma_dev) != get_dma_ops(subdrv_dev)) {

drivers/gpu/drm/exynos/exynos_drm_drv.h

201

struct device *dma_dev;

drivers/gpu/drm/exynos/exynos_drm_drv.h

215

return priv->dma_dev;

drivers/gpu/drm/gud/gud_drv.c

447

struct device *dma_dev;

drivers/gpu/drm/gud/gud_drv.c

490

dma_dev = usb_intf_get_dma_device(intf);

drivers/gpu/drm/gud/gud_drv.c

491

if (dma_dev) {

drivers/gpu/drm/gud/gud_drv.c

492

drm_dev_set_dma_dev(drm, dma_dev);

drivers/gpu/drm/gud/gud_drv.c

493

put_device(dma_dev);

drivers/gpu/drm/mediatek/mtk_crtc.c

1001

return mtk_crtc->dma_dev;

drivers/gpu/drm/mediatek/mtk_crtc.c

1114

mtk_crtc->dma_dev = mtk_ddp_comp_dma_dev_get(&priv->ddp_comp[path[0]]);

drivers/gpu/drm/mediatek/mtk_crtc.c

63

struct device *dma_dev;

drivers/gpu/drm/mediatek/mtk_drm_drv.c

465

struct device *dma_dev = NULL;

drivers/gpu/drm/mediatek/mtk_drm_drv.c

561

dma_dev = mtk_crtc_dma_dev_get(crtc);

drivers/gpu/drm/mediatek/mtk_drm_drv.c

562

if (!dma_dev) {

drivers/gpu/drm/mediatek/mtk_drm_drv.c

569

private->all_drm_private[i]->dma_dev = dma_dev;

drivers/gpu/drm/mediatek/mtk_drm_drv.c

575

dma_set_max_seg_size(dma_dev, UINT_MAX);

drivers/gpu/drm/mediatek/mtk_drm_drv.c

612

return drm_gem_prime_import_dev(dev, dma_buf, private->dma_dev);

drivers/gpu/drm/mediatek/mtk_drm_drv.h

57

struct device *dma_dev;

drivers/gpu/drm/mediatek/mtk_gem.c

122

dma_obj->vaddr = dma_alloc_wc(priv->dma_dev, obj->size,

drivers/gpu/drm/mediatek/mtk_gem.c

204

ret = dma_mmap_wc(priv->dma_dev, vma, dma_obj->vaddr,

drivers/gpu/drm/mediatek/mtk_gem.c

31

dma_free_wc(priv->dma_dev, dma_obj->base.size,

drivers/gpu/drm/mediatek/mtk_gem.c

57

ret = dma_get_sgtable(priv->dma_dev, sgt, dma_obj->vaddr,

drivers/gpu/drm/tegra/drm.c

1141

struct device *dma_dev = dev->dev.parent;

drivers/gpu/drm/tegra/drm.c

1156

if (host1x_drm_wants_iommu(dev) && device_iommu_mapped(dma_dev)) {

drivers/gpu/drm/tegra/drm.c

1157

tegra->domain = iommu_paging_domain_alloc(dma_dev);

drivers/gpu/drm/tiny/appletbdrm.c

736

struct device *dma_dev;

drivers/gpu/drm/tiny/appletbdrm.c

756

dma_dev = usb_intf_get_dma_device(intf);

drivers/gpu/drm/tiny/appletbdrm.c

757

if (dma_dev) {

drivers/gpu/drm/tiny/appletbdrm.c

758

drm_dev_set_dma_dev(drm, dma_dev);

drivers/gpu/drm/tiny/appletbdrm.c

759

put_device(dma_dev);

drivers/gpu/drm/tiny/gm12u320.c

631

struct device *dma_dev;

drivers/gpu/drm/tiny/gm12u320.c

647

dma_dev = usb_intf_get_dma_device(interface);

drivers/gpu/drm/tiny/gm12u320.c

648

if (dma_dev) {

drivers/gpu/drm/tiny/gm12u320.c

649

drm_dev_set_dma_dev(dev, dma_dev);

drivers/gpu/drm/tiny/gm12u320.c

650

put_device(dma_dev);

drivers/gpu/drm/udl/udl_main.c

336

struct device *dma_dev;

drivers/gpu/drm/udl/udl_main.c

340

dma_dev = usb_intf_get_dma_device(to_usb_interface(dev->dev));

drivers/gpu/drm/udl/udl_main.c

341

if (dma_dev) {

drivers/gpu/drm/udl/udl_main.c

342

drm_dev_set_dma_dev(dev, dma_dev);

drivers/gpu/drm/udl/udl_main.c

343

put_device(dma_dev);

drivers/i2c/busses/i2c-tegra.c

316

struct device *dma_dev;

drivers/i2c/busses/i2c-tegra.c

524

dma_free_coherent(i2c_dev->dma_dev, i2c_dev->dma_buf_size,

drivers/i2c/busses/i2c-tegra.c

571

i2c_dev->dma_dev = i2c_dev->dma_chan->device->dev;

drivers/i2c/busses/i2c-tegra.c

575

dma_buf = dma_alloc_coherent(i2c_dev->dma_dev, i2c_dev->dma_buf_size,

drivers/iio/industrialio-buffer.c

1640

struct device *dma_dev = iio_buffer_get_dma_dev(ib->indio_dev, buffer);

drivers/iio/industrialio-buffer.c

1647

if (priv->attach->dev == dma_dev

drivers/iio/industrialio-buffer.c

1665

struct device *dma_dev = iio_buffer_get_dma_dev(indio_dev, buffer);

drivers/iio/industrialio-buffer.c

1692

attach = dma_buf_attach(dmabuf, dma_dev);

drivers/iio/industrialio-buffer.c

1732

if (each->attach->dev == dma_dev

drivers/iio/industrialio-buffer.c

1771

struct device *dma_dev = iio_buffer_get_dma_dev(indio_dev, buffer);

drivers/iio/industrialio-buffer.c

1786

if (priv->attach->dev == dma_dev

drivers/infiniband/core/rw.c

493

struct device *dma_dev = dev->dma_device;

drivers/infiniband/core/rw.c

505

if (!dma_iova_try_alloc(dma_dev, &ctx->iova.state,

drivers/infiniband/core/rw.c

513

ret = dma_iova_link(dma_dev, &ctx->iova.state, bvec_phys(&bv),

drivers/infiniband/core/rw.c

523

ret = dma_iova_sync(dma_dev, &ctx->iova.state, 0, mapped_len);

drivers/infiniband/core/rw.c

555

dma_iova_destroy(dma_dev, &ctx->iova.state, mapped_len, dir, 0);

drivers/infiniband/hw/ionic/ionic_queue.c

32

q->ptr = dma_alloc_coherent(dma_dev, q->size, &q->dma, GFP_KERNEL);

drivers/infiniband/hw/ionic/ionic_queue.c

38

dma_free_coherent(dma_dev, q->size, q->ptr, q->dma);

drivers/infiniband/hw/ionic/ionic_queue.c

49

void ionic_queue_destroy(struct ionic_queue *q, struct device *dma_dev)

drivers/infiniband/hw/ionic/ionic_queue.c

51

dma_free_coherent(dma_dev, q->size, q->ptr, q->dma);

drivers/infiniband/hw/ionic/ionic_queue.c

8

int ionic_queue_init(struct ionic_queue *q, struct device *dma_dev,

drivers/infiniband/hw/ionic/ionic_queue.h

49

int ionic_queue_init(struct ionic_queue *q, struct device *dma_dev,

drivers/infiniband/hw/ionic/ionic_queue.h

59

void ionic_queue_destroy(struct ionic_queue *q, struct device *dma_dev);

drivers/infiniband/ulp/rtrs/rtrs.c

22

struct ib_device *dma_dev,

drivers/infiniband/ulp/rtrs/rtrs.c

39

iu->dma_addr = ib_dma_map_single(dma_dev, iu->buf, size, dir);

drivers/infiniband/ulp/rtrs/rtrs.c

40

if (ib_dma_mapping_error(dma_dev, iu->dma_addr)) {

drivers/infiniband/ulp/rtrs/rtrs.c

50

rtrs_iu_free(ius, dma_dev, i);

drivers/iommu/exynos-iommu.c

1102

handle = dma_map_single(dma_dev, pent, LV2TABLE_SIZE,

drivers/iommu/exynos-iommu.c

1104

if (dma_mapping_error(dma_dev, handle)) {

drivers/iommu/exynos-iommu.c

1190

dma_sync_single_for_cpu(dma_dev, pent_base,

drivers/iommu/exynos-iommu.c

1202

dma_sync_single_for_device(dma_dev, pent_base,

drivers/iommu/exynos-iommu.c

1351

dma_sync_single_for_cpu(dma_dev, virt_to_phys(ent),

drivers/iommu/exynos-iommu.c

1355

dma_sync_single_for_device(dma_dev, virt_to_phys(ent),

drivers/iommu/exynos-iommu.c

176

static struct device *dma_dev;

drivers/iommu/exynos-iommu.c

811

if (!dma_dev)

drivers/iommu/exynos-iommu.c

812

dma_dev = &pdev->dev;

drivers/iommu/exynos-iommu.c

886

dma_sync_single_for_cpu(dma_dev, virt_to_phys(ent), sizeof(*ent),

drivers/iommu/exynos-iommu.c

889

dma_sync_single_for_device(dma_dev, virt_to_phys(ent), sizeof(*ent),

drivers/iommu/exynos-iommu.c

900

BUG_ON(PG_ENT_SHIFT < 0 || !dma_dev);

drivers/iommu/exynos-iommu.c

918

handle = dma_map_single(dma_dev, domain->pgtable, LV1TABLE_SIZE,

drivers/iommu/exynos-iommu.c

922

if (dma_mapping_error(dma_dev, handle))

drivers/iommu/exynos-iommu.c

968

dma_unmap_single(dma_dev, virt_to_phys(domain->pgtable), LV1TABLE_SIZE,

drivers/iommu/exynos-iommu.c

975

dma_unmap_single(dma_dev, base, LV2TABLE_SIZE,

drivers/iommu/iommu-pages.c

146

int iommu_pages_start_incoherent(void *virt, struct device *dma_dev)

drivers/iommu/iommu-pages.c

155

iommu_pages_flush_incoherent(dma_dev, virt, 0,

drivers/iommu/iommu-pages.c

158

dma = dma_map_single(dma_dev, virt, ioptdesc_mem_size(iopt),

drivers/iommu/iommu-pages.c

160

if (dma_mapping_error(dma_dev, dma))

drivers/iommu/iommu-pages.c

169

dma_unmap_single(dma_dev, dma, ioptdesc_mem_size(iopt),

drivers/iommu/iommu-pages.c

190

struct device *dma_dev)

drivers/iommu/iommu-pages.c

200

folio_address(ioptdesc_folio(cur)), dma_dev);

drivers/iommu/iommu-pages.c

218

struct device *dma_dev)

drivers/iommu/iommu-pages.c

227

dma_unmap_single(dma_dev, virt_to_phys(folio_address(folio)),

drivers/iommu/iommu-pages.c

241

void iommu_pages_free_incoherent(void *virt, struct device *dma_dev)

drivers/iommu/iommu-pages.c

246

dma_unmap_single(dma_dev, virt_to_phys(virt),

drivers/iommu/iommu-pages.h

104

int iommu_pages_start_incoherent(void *virt, struct device *dma_dev);

drivers/iommu/iommu-pages.h

106

struct device *dma_dev);

drivers/iommu/iommu-pages.h

112

static inline void iommu_pages_flush_incoherent(struct device *dma_dev,

drivers/iommu/iommu-pages.h

120

struct device *dma_dev)

drivers/iommu/iommu-pages.h

128

struct device *dma_dev)

drivers/iommu/iommu-pages.h

136

static inline void iommu_pages_flush_incoherent(struct device *dma_dev,

drivers/iommu/iommu-pages.h

140

dma_sync_single_for_device(dma_dev, (uintptr_t)virt + offset, len,

drivers/iommu/iommu-pages.h

144

struct device *dma_dev);

drivers/iommu/iommu-pages.h

145

void iommu_pages_free_incoherent(void *virt, struct device *dma_dev);

drivers/iommu/rockchip-iommu.c

1082

rk_domain->dma_dev = iommu->dev;

drivers/iommu/rockchip-iommu.c

1083

rk_domain->dt_dma = dma_map_single(rk_domain->dma_dev, rk_domain->dt,

drivers/iommu/rockchip-iommu.c

1085

if (dma_mapping_error(rk_domain->dma_dev, rk_domain->dt_dma)) {

drivers/iommu/rockchip-iommu.c

1086

dev_err(rk_domain->dma_dev, "DMA map error for DT\n");

drivers/iommu/rockchip-iommu.c

1122

dma_unmap_single(rk_domain->dma_dev, pt_phys,

drivers/iommu/rockchip-iommu.c

1128

dma_unmap_single(rk_domain->dma_dev, rk_domain->dt_dma,

drivers/iommu/rockchip-iommu.c

135

dma_sync_single_for_device(dom->dma_dev, dma, size, DMA_TO_DEVICE);

drivers/iommu/rockchip-iommu.c

738

pt_dma = dma_map_single(rk_domain->dma_dev, page_table, SPAGE_SIZE, DMA_TO_DEVICE);

drivers/iommu/rockchip-iommu.c

739

if (dma_mapping_error(rk_domain->dma_dev, pt_dma)) {

drivers/iommu/rockchip-iommu.c

740

dev_err(rk_domain->dma_dev, "DMA mapping error while allocating page table\n");

drivers/iommu/rockchip-iommu.c

91

struct device *dma_dev;

drivers/mcb/mcb-core.c

234

dev->dma_dev = bus->carrier;

drivers/mtd/nand/raw/cadence-nand-controller.c

1876

struct dma_device *dma_dev;

drivers/mtd/nand/raw/cadence-nand-controller.c

1882

dma_dev = chan->device;

drivers/mtd/nand/raw/cadence-nand-controller.c

1884

buf_dma = dma_map_single(dma_dev->dev, buf, len, dir);

drivers/mtd/nand/raw/cadence-nand-controller.c

1885

if (dma_mapping_error(dma_dev->dev, buf_dma)) {

drivers/mtd/nand/raw/cadence-nand-controller.c

1917

dma_unmap_single(dma_dev->dev, buf_dma, len, dir);

drivers/mtd/nand/raw/cadence-nand-controller.c

1922

dma_unmap_single(dma_dev->dev, buf_dma, len, dir);

drivers/mtd/nand/raw/cadence-nand-controller.c

3129

struct dma_device *dma_dev;

drivers/mtd/nand/raw/cadence-nand-controller.c

3173

dma_dev = cdns_ctrl->dmac->device;

drivers/mtd/nand/raw/cadence-nand-controller.c

3174

cdns_ctrl->io.iova_dma = dma_map_resource(dma_dev->dev, cdns_ctrl->io.dma,

drivers/mtd/nand/raw/cadence-nand-controller.c

3178

ret = dma_mapping_error(dma_dev->dev, cdns_ctrl->io.iova_dma);

drivers/mtd/nand/raw/cadence-nand-controller.c

3207

dma_unmap_resource(dma_dev->dev, cdns_ctrl->io.iova_dma,

drivers/mtd/nand/raw/fsmc_nand.c

489

struct dma_device *dma_dev;

drivers/mtd/nand/raw/fsmc_nand.c

504

dma_dev = chan->device;

drivers/mtd/nand/raw/fsmc_nand.c

505

dma_addr = dma_map_single(dma_dev->dev, buffer, len, direction);

drivers/mtd/nand/raw/fsmc_nand.c

506

if (dma_mapping_error(dma_dev->dev, dma_addr))

drivers/mtd/nand/raw/fsmc_nand.c

517

tx = dma_dev->device_prep_dma_memcpy(chan, dma_dst, dma_src,

drivers/mtd/nand/raw/fsmc_nand.c

550

dma_unmap_single(dma_dev->dev, dma_addr, len, direction);

drivers/net/ethernet/broadcom/b44.c

1079

dma_unmap_single(bp->sdev->dma_dev, rp->mapping, RX_PKT_BUF_SZ,

drivers/net/ethernet/broadcom/b44.c

1091

dma_unmap_single(bp->sdev->dma_dev, rp->mapping, rp->skb->len,

drivers/net/ethernet/broadcom/b44.c

1114

dma_sync_single_for_device(bp->sdev->dma_dev, bp->rx_ring_dma,

drivers/net/ethernet/broadcom/b44.c

1118

dma_sync_single_for_device(bp->sdev->dma_dev, bp->tx_ring_dma,

drivers/net/ethernet/broadcom/b44.c

1139

dma_unmap_single(bp->sdev->dma_dev, bp->rx_ring_dma,

drivers/net/ethernet/broadcom/b44.c

1143

dma_free_coherent(bp->sdev->dma_dev, DMA_TABLE_BYTES,

drivers/net/ethernet/broadcom/b44.c

1150

dma_unmap_single(bp->sdev->dma_dev, bp->tx_ring_dma,

drivers/net/ethernet/broadcom/b44.c

1154

dma_free_coherent(bp->sdev->dma_dev, DMA_TABLE_BYTES,

drivers/net/ethernet/broadcom/b44.c

1180

bp->rx_ring = dma_alloc_coherent(bp->sdev->dma_dev, size,

drivers/net/ethernet/broadcom/b44.c

1193

rx_ring_dma = dma_map_single(bp->sdev->dma_dev, rx_ring,

drivers/net/ethernet/broadcom/b44.c

1197

if (dma_mapping_error(bp->sdev->dma_dev, rx_ring_dma) ||

drivers/net/ethernet/broadcom/b44.c

1208

bp->tx_ring = dma_alloc_coherent(bp->sdev->dma_dev, size,

drivers/net/ethernet/broadcom/b44.c

1221

tx_ring_dma = dma_map_single(bp->sdev->dma_dev, tx_ring,

drivers/net/ethernet/broadcom/b44.c

1225

if (dma_mapping_error(bp->sdev->dma_dev, tx_ring_dma) ||

drivers/net/ethernet/broadcom/b44.c

152

dma_sync_single_for_device(sdev->dma_dev, dma_base + offset,

drivers/net/ethernet/broadcom/b44.c

161

dma_sync_single_for_cpu(sdev->dma_dev, dma_base + offset,

drivers/net/ethernet/broadcom/b44.c

2376

err = dma_set_mask_and_coherent(sdev->dma_dev, DMA_BIT_MASK(30));

drivers/net/ethernet/broadcom/b44.c

607

dma_unmap_single(bp->sdev->dma_dev,

drivers/net/ethernet/broadcom/b44.c

652

mapping = dma_map_single(bp->sdev->dma_dev, skb->data,

drivers/net/ethernet/broadcom/b44.c

658

if (dma_mapping_error(bp->sdev->dma_dev, mapping) ||

drivers/net/ethernet/broadcom/b44.c

661

if (!dma_mapping_error(bp->sdev->dma_dev, mapping))

drivers/net/ethernet/broadcom/b44.c

662

dma_unmap_single(bp->sdev->dma_dev, mapping,

drivers/net/ethernet/broadcom/b44.c

668

mapping = dma_map_single(bp->sdev->dma_dev, skb->data,

drivers/net/ethernet/broadcom/b44.c

671

if (dma_mapping_error(bp->sdev->dma_dev, mapping) ||

drivers/net/ethernet/broadcom/b44.c

673

if (!dma_mapping_error(bp->sdev->dma_dev, mapping))

drivers/net/ethernet/broadcom/b44.c

674

dma_unmap_single(bp->sdev->dma_dev, mapping, RX_PKT_BUF_SZ,DMA_FROM_DEVICE);

drivers/net/ethernet/broadcom/b44.c

749

dma_sync_single_for_device(bp->sdev->dma_dev, dest_map->mapping,

drivers/net/ethernet/broadcom/b44.c

771

dma_sync_single_for_cpu(bp->sdev->dma_dev, map,

drivers/net/ethernet/broadcom/b44.c

805

dma_unmap_single(bp->sdev->dma_dev, map,

drivers/net/ethernet/broadcom/b44.c

966

mapping = dma_map_single(bp->sdev->dma_dev, skb->data, len, DMA_TO_DEVICE);

drivers/net/ethernet/broadcom/b44.c

967

if (dma_mapping_error(bp->sdev->dma_dev, mapping) || mapping + len > DMA_BIT_MASK(30)) {

drivers/net/ethernet/broadcom/b44.c

971

if (!dma_mapping_error(bp->sdev->dma_dev, mapping))

drivers/net/ethernet/broadcom/b44.c

972

dma_unmap_single(bp->sdev->dma_dev, mapping, len,

drivers/net/ethernet/broadcom/b44.c

979

mapping = dma_map_single(bp->sdev->dma_dev, bounce_skb->data,

drivers/net/ethernet/broadcom/b44.c

981

if (dma_mapping_error(bp->sdev->dma_dev, mapping) || mapping + len > DMA_BIT_MASK(30)) {

drivers/net/ethernet/broadcom/b44.c

982

if (!dma_mapping_error(bp->sdev->dma_dev, mapping))

drivers/net/ethernet/broadcom/b44.c

983

dma_unmap_single(bp->sdev->dma_dev, mapping,

drivers/net/ethernet/broadcom/bgmac-bcma.c

138

bgmac->dma_dev = core->dma_dev;

drivers/net/ethernet/broadcom/bgmac-platform.c

194

bgmac->dma_dev = &pdev->dev;

drivers/net/ethernet/broadcom/bgmac.c

135

struct device *dma_dev = bgmac->dma_dev;

drivers/net/ethernet/broadcom/bgmac.c

162

slot->dma_addr = dma_map_single(dma_dev, skb->data, skb_headlen(skb),

drivers/net/ethernet/broadcom/bgmac.c

164

if (unlikely(dma_mapping_error(dma_dev, slot->dma_addr)))

drivers/net/ethernet/broadcom/bgmac.c

180

slot->dma_addr = skb_frag_dma_map(dma_dev, frag, 0,

drivers/net/ethernet/broadcom/bgmac.c

182

if (unlikely(dma_mapping_error(dma_dev, slot->dma_addr)))

drivers/net/ethernet/broadcom/bgmac.c

211

dma_unmap_single(dma_dev, slot->dma_addr, skb_headlen(skb),

drivers/net/ethernet/broadcom/bgmac.c

220

dma_unmap_page(dma_dev, slot->dma_addr, len, DMA_TO_DEVICE);

drivers/net/ethernet/broadcom/bgmac.c

237

struct device *dma_dev = bgmac->dma_dev;

drivers/net/ethernet/broadcom/bgmac.c

262

dma_unmap_single(dma_dev, slot->dma_addr, len,

drivers/net/ethernet/broadcom/bgmac.c

265

dma_unmap_page(dma_dev, slot->dma_addr, len,

drivers/net/ethernet/broadcom/bgmac.c

336

struct device *dma_dev = bgmac->dma_dev;

drivers/net/ethernet/broadcom/bgmac.c

352

dma_addr = dma_map_single(dma_dev, buf + BGMAC_RX_BUF_OFFSET,

drivers/net/ethernet/broadcom/bgmac.c

354

if (dma_mapping_error(dma_dev, dma_addr)) {

drivers/net/ethernet/broadcom/bgmac.c

399

static void bgmac_dma_rx_poison_buf(struct device *dma_dev,

drivers/net/ethernet/broadcom/bgmac.c

404

dma_sync_single_for_cpu(dma_dev, slot->dma_addr, BGMAC_RX_BUF_SIZE,

drivers/net/ethernet/broadcom/bgmac.c

408

dma_sync_single_for_device(dma_dev, slot->dma_addr, BGMAC_RX_BUF_SIZE,

drivers/net/ethernet/broadcom/bgmac.c

425

struct device *dma_dev = bgmac->dma_dev;

drivers/net/ethernet/broadcom/bgmac.c

436

bgmac_dma_rx_poison_buf(dma_dev, slot);

drivers/net/ethernet/broadcom/bgmac.c

441

dma_unmap_single(dma_dev, dma_addr,

drivers/net/ethernet/broadcom/bgmac.c

528

struct device *dma_dev = bgmac->dma_dev;

drivers/net/ethernet/broadcom/bgmac.c

544

dma_unmap_single(dma_dev, slot->dma_addr,

drivers/net/ethernet/broadcom/bgmac.c

547

dma_unmap_page(dma_dev, slot->dma_addr,

drivers/net/ethernet/broadcom/bgmac.c

555

struct device *dma_dev = bgmac->dma_dev;

drivers/net/ethernet/broadcom/bgmac.c

564

dma_unmap_single(dma_dev, slot->dma_addr,

drivers/net/ethernet/broadcom/bgmac.c

576

struct device *dma_dev = bgmac->dma_dev;

drivers/net/ethernet/broadcom/bgmac.c

584

dma_free_coherent(dma_dev, size, ring->cpu_base,

drivers/net/ethernet/broadcom/bgmac.c

614

struct device *dma_dev = bgmac->dma_dev;

drivers/net/ethernet/broadcom/bgmac.c

637

ring->cpu_base = dma_alloc_coherent(dma_dev, size,

drivers/net/ethernet/broadcom/bgmac.c

662

ring->cpu_base = dma_alloc_coherent(dma_dev, size,

drivers/net/ethernet/broadcom/bgmac.h

454

struct device *dma_dev;

drivers/net/ethernet/freescale/enetc/enetc.h

220

struct device *dma_dev;

drivers/net/ethernet/freescale/enetc/enetc.h

576

data = dma_alloc_coherent(ring->dma_dev,

drivers/net/ethernet/freescale/enetc/enetc.h

580

dev_err(ring->dma_dev, "CBD alloc data memory failed!\n");

drivers/net/ethernet/freescale/enetc/enetc.h

599

dma_free_coherent(ring->dma_dev, size + ENETC_CBD_DATA_MEM_ALIGN,

drivers/net/ethernet/freescale/enetc/enetc_cbdr.c

108

dev_warn(ring->dma_dev, "CMD err %04x for cmd %04x\n",

drivers/net/ethernet/freescale/enetc/enetc_cbdr.c

233

dev_err(ring->dma_dev, "FS entry add failed (%d)!", err);

drivers/net/ethernet/freescale/enetc/enetc_cbdr.c

25

cbdr->dma_dev = dev;

drivers/net/ethernet/freescale/enetc/enetc_cbdr.c

269

dev_err(ring->dma_dev, "RSS cmd failed (%d)!", err);

drivers/net/ethernet/freescale/enetc/enetc_cbdr.c

56

dma_free_coherent(cbdr->dma_dev, size, cbdr->bd_base,

drivers/net/ethernet/freescale/enetc/enetc_cbdr.c

59

cbdr->dma_dev = NULL;

drivers/net/ethernet/fungible/funcore/fun_queue.c

19

void *fun_alloc_ring_mem(struct device *dma_dev, size_t depth,

drivers/net/ethernet/fungible/funcore/fun_queue.c

237

struct device *dma_dev = funq->fdev->dev;

drivers/net/ethernet/fungible/funcore/fun_queue.c

24

int dev_node = dev_to_node(dma_dev);

drivers/net/ethernet/fungible/funcore/fun_queue.c

251

dma_sync_single_for_cpu(dma_dev, rqinfo->dma + bufoff,

drivers/net/ethernet/fungible/funcore/fun_queue.c

272

dma_sync_single_for_cpu(dma_dev, rqinfo->dma, fragsize,

drivers/net/ethernet/fungible/funcore/fun_queue.c

36

set_dev_node(dma_dev, numa_node);

drivers/net/ethernet/fungible/funcore/fun_queue.c

37

va = dma_alloc_coherent(dma_dev, dma_sz, dma_addr, GFP_KERNEL);

drivers/net/ethernet/fungible/funcore/fun_queue.c

38

set_dev_node(dma_dev, dev_node);

drivers/net/ethernet/fungible/funcore/fun_queue.c

46

dma_free_coherent(dma_dev, dma_sz, va, *dma_addr);

drivers/net/ethernet/fungible/funcore/fun_queue.c

57

void fun_free_ring_mem(struct device *dma_dev, size_t depth, size_t hw_desc_sz,

drivers/net/ethernet/fungible/funcore/fun_queue.c

65

dma_free_coherent(dma_dev, sz, hw_va, dma_addr);

drivers/net/ethernet/fungible/funcore/fun_queue.h

142

void *fun_alloc_ring_mem(struct device *dma_dev, size_t depth,

drivers/net/ethernet/fungible/funcore/fun_queue.h

146

void fun_free_ring_mem(struct device *dma_dev, size_t depth, size_t hw_desc_sz,

drivers/net/ethernet/fungible/funeth/funeth_rx.c

110

rb->dma_addr = dma_map_page(q->dma_dev, p, 0, PAGE_SIZE,

drivers/net/ethernet/fungible/funeth/funeth_rx.c

112

if (unlikely(dma_mapping_error(q->dma_dev, rb->dma_addr))) {

drivers/net/ethernet/fungible/funeth/funeth_rx.c

130

dma_unmap_page(q->dma_dev, rb->dma_addr, PAGE_SIZE,

drivers/net/ethernet/fungible/funeth/funeth_rx.c

269

dma_sync_single_for_device(q->dma_dev, buf->dma_addr,

drivers/net/ethernet/fungible/funeth/funeth_rx.c

319

dma_sync_single_for_cpu(q->dma_dev,

drivers/net/ethernet/fungible/funeth/funeth_rx.c

58

dma_unmap_page_attrs(q->dma_dev, buf->dma_addr, PAGE_SIZE,

drivers/net/ethernet/fungible/funeth/funeth_rx.c

636

q->dma_dev = &fp->pdev->dev;

drivers/net/ethernet/fungible/funeth/funeth_rx.c

638

q->rqes = fun_alloc_ring_mem(q->dma_dev, nrqe, sizeof(*q->rqes),

drivers/net/ethernet/fungible/funeth/funeth_rx.c

644

q->cqes = fun_alloc_ring_mem(q->dma_dev, ncqe, FUNETH_CQE_SIZE, 0,

drivers/net/ethernet/fungible/funeth/funeth_rx.c

665

dma_free_coherent(q->dma_dev, ncqe * FUNETH_CQE_SIZE, q->cqes,

drivers/net/ethernet/fungible/funeth/funeth_rx.c

668

fun_free_ring_mem(q->dma_dev, nrqe, sizeof(*q->rqes), false, q->rqes,

drivers/net/ethernet/fungible/funeth/funeth_rx.c

683

fun_free_ring_mem(q->dma_dev, q->rq_mask + 1, sizeof(*q->rqes), false,

drivers/net/ethernet/fungible/funeth/funeth_rx.c

685

dma_free_coherent(q->dma_dev, (q->cq_mask + 1) * FUNETH_CQE_SIZE,

drivers/net/ethernet/fungible/funeth/funeth_rx.c

77

dma_sync_single_for_device(q->dma_dev, buf->dma_addr,

drivers/net/ethernet/fungible/funeth/funeth_rx.c

88

dma_unmap_page_attrs(q->dma_dev, buf->dma_addr, PAGE_SIZE,

drivers/net/ethernet/fungible/funeth/funeth_tx.c

165

if (unlikely(fun_map_pkt(q->dma_dev, shinfo, skb->data,

drivers/net/ethernet/fungible/funeth/funeth_tx.c

401

dma_unmap_single(q->dma_dev, be64_to_cpu(gle->sgl_data),

drivers/net/ethernet/fungible/funeth/funeth_tx.c

405

dma_unmap_page(q->dma_dev, be64_to_cpu(gle->sgl_data),

drivers/net/ethernet/fungible/funeth/funeth_tx.c

410

dma_unmap_page(q->dma_dev, be64_to_cpu(gle->sgl_data),

drivers/net/ethernet/fungible/funeth/funeth_tx.c

539

if (unlikely(fun_map_pkt(q->dma_dev, si, xdpf->data, xdpf->len, dma,

drivers/net/ethernet/fungible/funeth/funeth_tx.c

641

q->dma_dev = &fp->pdev->dev;

drivers/net/ethernet/fungible/funeth/funeth_tx.c

642

q->desc = fun_alloc_ring_mem(q->dma_dev, ndesc, FUNETH_SQE_SIZE,

drivers/net/ethernet/fungible/funeth/funeth_tx.c

669

fun_free_ring_mem(q->dma_dev, q->mask + 1, FUNETH_SQE_SIZE, true,

drivers/net/ethernet/fungible/funeth/funeth_txrx.h

111

struct device *dma_dev; /* device for DMA mappings */

drivers/net/ethernet/fungible/funeth/funeth_txrx.h

166

struct device *dma_dev; /* device for DMA mappings */

drivers/net/ethernet/marvell/prestera/prestera_rxtx.c

470

struct device *dma_dev = sdma->sw->dev->dev;

drivers/net/ethernet/marvell/prestera/prestera_rxtx.c

473

dma = dma_map_single(dma_dev, skb->data, skb->len, DMA_TO_DEVICE);

drivers/net/ethernet/marvell/prestera/prestera_rxtx.c

474

if (dma_mapping_error(dma_dev, dma))

drivers/net/ethernet/marvell/prestera/prestera_rxtx.c

486

struct device *dma_dev = sdma->sw->dev->dev;

drivers/net/ethernet/marvell/prestera/prestera_rxtx.c

488

dma_unmap_single(dma_dev, buf->buf_dma, buf->skb->len, DMA_TO_DEVICE);

drivers/net/ethernet/marvell/prestera/prestera_rxtx.c

725

struct device *dma_dev = sdma->sw->dev->dev;

drivers/net/ethernet/marvell/prestera/prestera_rxtx.c

750

dma_sync_single_for_device(dma_dev, buf->buf_dma, skb->len,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1283

dma_ring = dma_alloc_coherent(eth->dma_dev, size, dma_handle,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1296

dma_free_coherent(eth->dma_dev, size, dma_ring, dma_handle);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1323

dma_addr = dma_map_single(eth->dma_dev,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1327

if (unlikely(dma_mapping_error(eth->dma_dev, dma_addr)))

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1390

dma_unmap_single(eth->dma_dev,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1395

dma_unmap_page(eth->dma_dev,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1402

dma_unmap_page(eth->dma_dev,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1409

dma_unmap_page(eth->dma_dev,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1593

txd_info.addr = dma_map_single(eth->dma_dev, skb->data, txd_info.size,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1595

if (unlikely(dma_mapping_error(eth->dma_dev, txd_info.addr)))

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1635

txd_info.addr = skb_frag_dma_map(eth->dma_dev, frag,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1638

if (unlikely(dma_mapping_error(eth->dma_dev, txd_info.addr)))

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1879

.dev = eth->dma_dev,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1943

txd_info->addr = dma_map_single(eth->dma_dev, data,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1945

if (unlikely(dma_mapping_error(eth->dma_dev, txd_info->addr)))

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1954

dma_sync_single_for_device(eth->dma_dev, txd_info->addr,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2256

dma_sync_single_for_cpu(eth->dma_dev,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2297

dma_addr = dma_map_single(eth->dma_dev,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2300

if (unlikely(dma_mapping_error(eth->dma_dev,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2310

dma_unmap_single(eth->dma_dev, ((u64)trxd.rxd1 | addr64),

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2679

ring->dma_pdma = dma_alloc_coherent(eth->dma_dev, ring_size * sz,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2761

dma_free_coherent(eth->dma_dev,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2837

dma_addr = dma_map_single(eth->dma_dev,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2840

if (unlikely(dma_mapping_error(eth->dma_dev,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2920

dma_unmap_single(eth->dma_dev, ((u64)rxd->rxd1 | addr64),

drivers/net/ethernet/mediatek/mtk_eth_soc.c

4113

of_dma_is_coherent(eth->dma_dev->of_node) * dma_mask);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

4972

void mtk_eth_set_dma_device(struct mtk_eth *eth, struct device *dma_dev)

drivers/net/ethernet/mediatek/mtk_eth_soc.c

4991

eth->dma_dev = dma_dev;

drivers/net/ethernet/mediatek/mtk_eth_soc.c

5063

eth->dma_dev = &pdev->dev;

drivers/net/ethernet/mediatek/mtk_eth_soc.h

1294

struct device *dma_dev;

drivers/net/ethernet/mediatek/mtk_eth_soc.h

1516

void mtk_eth_set_dma_device(struct mtk_eth *eth, struct device *dma_dev);

drivers/net/ethernet/mediatek/mtk_wed.c

1158

hw->eth->dma_dev != hw->eth->dev)

drivers/net/ethernet/mediatek/mtk_wed.c

2433

if (hw->eth->dma_dev == hw->eth->dev &&

drivers/net/ethernet/sfc/falcon/tx.c

202

struct device *dma_dev = &efx->pci_dev->dev;

drivers/net/ethernet/sfc/falcon/tx.c

213

dma_addr = dma_map_single(dma_dev, skb->data, len, DMA_TO_DEVICE);

drivers/net/ethernet/sfc/falcon/tx.c

218

if (unlikely(dma_mapping_error(dma_dev, dma_addr)))

drivers/net/ethernet/sfc/falcon/tx.c

247

dma_addr = skb_frag_dma_map(dma_dev, fragment,

drivers/net/ethernet/sfc/falcon/tx.c

253

if (unlikely(dma_mapping_error(dma_dev, dma_addr)))

drivers/net/ethernet/sfc/falcon/tx.c

49

struct device *dma_dev = &tx_queue->efx->pci_dev->dev;

drivers/net/ethernet/sfc/falcon/tx.c

52

dma_unmap_single(dma_dev, unmap_addr, buffer->unmap_len,

drivers/net/ethernet/sfc/falcon/tx.c

55

dma_unmap_page(dma_dev, unmap_addr, buffer->unmap_len,

drivers/net/ethernet/sfc/siena/tx_common.c

127

struct device *dma_dev = &tx_queue->efx->pci_dev->dev;

drivers/net/ethernet/sfc/siena/tx_common.c

131

dma_unmap_single(dma_dev, unmap_addr, buffer->unmap_len,

drivers/net/ethernet/sfc/siena/tx_common.c

134

dma_unmap_page(dma_dev, unmap_addr, buffer->unmap_len,

drivers/net/ethernet/sfc/siena/tx_common.c

332

struct device *dma_dev = &efx->pci_dev->dev;

drivers/net/ethernet/sfc/siena/tx_common.c

343

dma_addr = dma_map_single(dma_dev, skb->data, len, DMA_TO_DEVICE);

drivers/net/ethernet/sfc/siena/tx_common.c

348

if (unlikely(dma_mapping_error(dma_dev, dma_addr)))

drivers/net/ethernet/sfc/siena/tx_common.c

391

dma_addr = skb_frag_dma_map(dma_dev, fragment, 0, len,

drivers/net/ethernet/sfc/siena/tx_common.c

397

if (unlikely(dma_mapping_error(dma_dev, dma_addr)))

drivers/net/ethernet/sfc/tx_common.c

164

struct device *dma_dev = &tx_queue->efx->pci_dev->dev;

drivers/net/ethernet/sfc/tx_common.c

168

dma_unmap_single(dma_dev, unmap_addr, buffer->unmap_len,

drivers/net/ethernet/sfc/tx_common.c

171

dma_unmap_page(dma_dev, unmap_addr, buffer->unmap_len,

drivers/net/ethernet/sfc/tx_common.c

372

struct device *dma_dev = &efx->pci_dev->dev;

drivers/net/ethernet/sfc/tx_common.c

383

dma_addr = dma_map_single(dma_dev, skb->data, len, DMA_TO_DEVICE);

drivers/net/ethernet/sfc/tx_common.c

388

if (unlikely(dma_mapping_error(dma_dev, dma_addr)))

drivers/net/ethernet/sfc/tx_common.c

431

dma_addr = skb_frag_dma_map(dma_dev, fragment, 0, len,

drivers/net/ethernet/sfc/tx_common.c

437

if (unlikely(dma_mapping_error(dma_dev, dma_addr)))

drivers/net/ethernet/sfc/tx_tso.c

173

struct device *dma_dev = &efx->pci_dev->dev;

drivers/net/ethernet/sfc/tx_tso.c

198

dma_addr = dma_map_single(dma_dev, skb->data,

drivers/net/ethernet/sfc/tx_tso.c

205

return unlikely(dma_mapping_error(dma_dev, dma_addr)) ? -ENOMEM : 0;

drivers/net/ethernet/sgi/ioc3-eth.c

1061

d1 = dma_map_single(ip->dma_dev, skb->data, s1, DMA_TO_DEVICE);

drivers/net/ethernet/sgi/ioc3-eth.c

1062

if (dma_mapping_error(ip->dma_dev, d1))

drivers/net/ethernet/sgi/ioc3-eth.c

1064

d2 = dma_map_single(ip->dma_dev, (void *)b2, s1, DMA_TO_DEVICE);

drivers/net/ethernet/sgi/ioc3-eth.c

1065

if (dma_mapping_error(ip->dma_dev, d2)) {

drivers/net/ethernet/sgi/ioc3-eth.c

1066

dma_unmap_single(ip->dma_dev, d1, len, DMA_TO_DEVICE);

drivers/net/ethernet/sgi/ioc3-eth.c

1077

d = dma_map_single(ip->dma_dev, skb->data, len, DMA_TO_DEVICE);

drivers/net/ethernet/sgi/ioc3-eth.c

1078

if (dma_mapping_error(ip->dma_dev, d))

drivers/net/ethernet/sgi/ioc3-eth.c

139

d = dma_map_single(ip->dma_dev, new_skb->data,

drivers/net/ethernet/sgi/ioc3-eth.c

142

if (dma_mapping_error(ip->dma_dev, d)) {

drivers/net/ethernet/sgi/ioc3-eth.c

405

dma_unmap_single(ip->dma_dev, rxr[rx_entry],

drivers/net/ethernet/sgi/ioc3-eth.c

620

dma_unmap_single(ip->dma_dev, be64_to_cpu(desc->p1),

drivers/net/ethernet/sgi/ioc3-eth.c

625

dma_unmap_single(ip->dma_dev, be64_to_cpu(desc->p2),

drivers/net/ethernet/sgi/ioc3-eth.c

659

dma_unmap_single(ip->dma_dev,

drivers/net/ethernet/sgi/ioc3-eth.c

82

struct device *dma_dev;

drivers/net/ethernet/sgi/ioc3-eth.c

853

ip->dma_dev = pdev->dev.parent;

drivers/net/ethernet/sgi/ioc3-eth.c

885

ip->rxr = dma_alloc_coherent(ip->dma_dev, RX_RING_SIZE, &ip->rxr_dma,

drivers/net/ethernet/sgi/ioc3-eth.c

894

ip->tx_ring = dma_alloc_coherent(ip->dma_dev, TX_RING_SIZE + SZ_16K - 1,

drivers/net/ethernet/sgi/ioc3-eth.c

955

dma_free_coherent(ip->dma_dev, RX_RING_SIZE, ip->rxr,

drivers/net/ethernet/sgi/ioc3-eth.c

958

dma_free_coherent(ip->dma_dev, TX_RING_SIZE + SZ_16K - 1, ip->tx_ring,

drivers/net/ethernet/sgi/ioc3-eth.c

970

dma_free_coherent(ip->dma_dev, RX_RING_SIZE, ip->rxr, ip->rxr_dma);

drivers/net/ethernet/sgi/ioc3-eth.c

971

dma_free_coherent(ip->dma_dev, TX_RING_SIZE + SZ_16K - 1, ip->tx_ring, ip->txr_dma);

drivers/net/ethernet/sun/sunhme.c

1169

dma_unmap_single(hp->dma_dev, dma_addr,

drivers/net/ethernet/sun/sunhme.c

1189

dma_unmap_single(hp->dma_dev, dma_addr,

drivers/net/ethernet/sun/sunhme.c

1194

dma_unmap_page(hp->dma_dev, dma_addr,

drivers/net/ethernet/sun/sunhme.c

1235

mapping = dma_map_single(hp->dma_dev, skb->data, RX_BUF_ALLOC_SIZE,

drivers/net/ethernet/sun/sunhme.c

1237

if (dma_mapping_error(hp->dma_dev, mapping)) {

drivers/net/ethernet/sun/sunhme.c

1733

dma_unmap_single(hp->dma_dev, dma_addr, dma_len, DMA_TO_DEVICE);

drivers/net/ethernet/sun/sunhme.c

1735

dma_unmap_page(hp->dma_dev, dma_addr, dma_len, DMA_TO_DEVICE);

drivers/net/ethernet/sun/sunhme.c

1805

mapping = dma_map_single(hp->dma_dev, new_skb->data,

drivers/net/ethernet/sun/sunhme.c

1808

if (unlikely(dma_mapping_error(hp->dma_dev, mapping))) {

drivers/net/ethernet/sun/sunhme.c

1814

dma_unmap_single(hp->dma_dev, dma_addr, RX_BUF_ALLOC_SIZE, DMA_FROM_DEVICE);

drivers/net/ethernet/sun/sunhme.c

1833

dma_sync_single_for_cpu(hp->dma_dev, dma_addr, len + 2, DMA_FROM_DEVICE);

drivers/net/ethernet/sun/sunhme.c

1835

dma_sync_single_for_device(hp->dma_dev, dma_addr, len + 2, DMA_FROM_DEVICE);

drivers/net/ethernet/sun/sunhme.c

1957

dma_unmap_single(hp->dma_dev, first_mapping, first_len, DMA_TO_DEVICE);

drivers/net/ethernet/sun/sunhme.c

1967

dma_unmap_page(hp->dma_dev, addr, len, DMA_TO_DEVICE);

drivers/net/ethernet/sun/sunhme.c

2005

mapping = dma_map_single(hp->dma_dev, skb->data, len, DMA_TO_DEVICE);

drivers/net/ethernet/sun/sunhme.c

2006

if (unlikely(dma_mapping_error(hp->dma_dev, mapping)))

drivers/net/ethernet/sun/sunhme.c

2021

first_mapping = dma_map_single(hp->dma_dev, skb->data, first_len,

drivers/net/ethernet/sun/sunhme.c

2023

if (unlikely(dma_mapping_error(hp->dma_dev, first_mapping)))

drivers/net/ethernet/sun/sunhme.c

2032

mapping = skb_frag_dma_map(hp->dma_dev, this_frag,

drivers/net/ethernet/sun/sunhme.c

2034

if (unlikely(dma_mapping_error(hp->dma_dev, mapping))) {

drivers/net/ethernet/sun/sunhme.c

2451

hp->happy_block = dmam_alloc_coherent(hp->dma_dev, PAGE_SIZE,

drivers/net/ethernet/sun/sunhme.c

2481

err = devm_register_netdev(hp->dma_dev, dev);

drivers/net/ethernet/sun/sunhme.c

2483

dev_err(hp->dma_dev, "Cannot register net device, aborting.\n");

drivers/net/ethernet/sun/sunhme.c

2522

hp->dma_dev = &op->dev;

drivers/net/ethernet/sun/sunhme.c

2665

hp->dma_dev = &pdev->dev;

drivers/net/ethernet/sun/sunhme.h

413

struct device *dma_dev;

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1114

dma_buf = dma_map_single(tx_chn->dma_dev, xdpf->data,

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1116

if (unlikely(dma_mapping_error(tx_chn->dma_dev, dma_buf))) {

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1162

dma_unmap_single(tx_chn->dma_dev, dma_buf, pkt_len, DMA_TO_DEVICE);

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1322

dma_unmap_single(rx_chn->dma_dev, buf_dma, buf_dma_len, DMA_FROM_DEVICE);

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1619

buf_dma = dma_map_single(tx_chn->dma_dev, skb->data, pkt_len,

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1621

if (unlikely(dma_mapping_error(tx_chn->dma_dev, buf_dma))) {

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1630

dma_unmap_single(tx_chn->dma_dev, buf_dma, pkt_len,

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1684

buf_dma = skb_frag_dma_map(tx_chn->dma_dev, frag, 0, frag_size,

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1686

if (unlikely(dma_mapping_error(tx_chn->dma_dev, buf_dma))) {

drivers/net/ethernet/ti/am65-cpsw-nuss.c

2297

tx_chn->dma_dev = k3_udma_glue_tx_get_dma_device(tx_chn->tx_chn);

drivers/net/ethernet/ti/am65-cpsw-nuss.c

2299

tx_chn->desc_pool = k3_cppi_desc_pool_create_name(tx_chn->dma_dev,

drivers/net/ethernet/ti/am65-cpsw-nuss.c

2408

rx_chn->dma_dev = k3_udma_glue_rx_get_dma_device(rx_chn->rx_chn);

drivers/net/ethernet/ti/am65-cpsw-nuss.c

2410

rx_chn->desc_pool = k3_cppi_desc_pool_create_name(rx_chn->dma_dev,

drivers/net/ethernet/ti/am65-cpsw-nuss.c

452

buf_dma = dma_map_single(rx_chn->dma_dev,

drivers/net/ethernet/ti/am65-cpsw-nuss.c

455

if (unlikely(dma_mapping_error(rx_chn->dma_dev, buf_dma))) {

drivers/net/ethernet/ti/am65-cpsw-nuss.c

789

dma_unmap_single(rx_chn->dma_dev, buf_dma, buf_dma_len, DMA_FROM_DEVICE);

drivers/net/ethernet/ti/am65-cpsw-nuss.c

807

dma_unmap_single(tx_chn->dma_dev, buf_dma, buf_dma_len, DMA_TO_DEVICE);

drivers/net/ethernet/ti/am65-cpsw-nuss.c

817

dma_unmap_page(tx_chn->dma_dev, buf_dma, buf_dma_len,

drivers/net/ethernet/ti/am65-cpsw-nuss.h

122

struct device *dma_dev;

drivers/net/ethernet/ti/am65-cpsw-nuss.h

79

struct device *dma_dev;

drivers/net/ethernet/ti/icssg/icssg_common.c

1203

buf_dma = dma_map_single(tx_chn->dma_dev, skb->data, pkt_len, DMA_TO_DEVICE);

drivers/net/ethernet/ti/icssg/icssg_common.c

1204

if (dma_mapping_error(tx_chn->dma_dev, buf_dma)) {

drivers/net/ethernet/ti/icssg/icssg_common.c

1213

dma_unmap_single(tx_chn->dma_dev, buf_dma, pkt_len, DMA_TO_DEVICE);

drivers/net/ethernet/ti/icssg/icssg_common.c

1271

buf_dma = skb_frag_dma_map(tx_chn->dma_dev, frag, 0, frag_size,

drivers/net/ethernet/ti/icssg/icssg_common.c

1273

if (dma_mapping_error(tx_chn->dma_dev, buf_dma)) {

drivers/net/ethernet/ti/icssg/icssg_common.c

185

dma_unmap_single(tx_chn->dma_dev, buf_dma, buf_dma_len,

drivers/net/ethernet/ti/icssg/icssg_common.c

196

dma_unmap_page(tx_chn->dma_dev, buf_dma, buf_dma_len,

drivers/net/ethernet/ti/icssg/icssg_common.c

436

tx_chn->dma_dev = k3_udma_glue_tx_get_dma_device(tx_chn->tx_chn);

drivers/net/ethernet/ti/icssg/icssg_common.c

438

k3_cppi_desc_pool_create_name(tx_chn->dma_dev,

drivers/net/ethernet/ti/icssg/icssg_common.c

469

struct device *dma_dev,

drivers/net/ethernet/ti/icssg/icssg_common.c

480

pp_params.dev = dma_dev;

drivers/net/ethernet/ti/icssg/icssg_common.c

531

rx_chn->dma_dev = k3_udma_glue_rx_get_dma_device(rx_chn->rx_chn);

drivers/net/ethernet/ti/icssg/icssg_common.c

532

rx_chn->desc_pool = k3_cppi_desc_pool_create_name(rx_chn->dma_dev,

drivers/net/ethernet/ti/icssg/icssg_common.c

543

pool = prueth_create_page_pool(emac, rx_chn->dma_dev, rx_chn->descs_num);

drivers/net/ethernet/ti/icssg/icssg_common.c

724

buf_dma = dma_map_single(tx_chn->dma_dev, xdpf->data, xdpf->len, DMA_TO_DEVICE);

drivers/net/ethernet/ti/icssg/icssg_common.c

725

if (dma_mapping_error(tx_chn->dma_dev, buf_dma)) {

drivers/net/ethernet/ti/icssg/icssg_prueth.c

1261

ret = xsk_pool_dma_map(pool, rx_chn->dma_dev, PRUETH_RX_DMA_ATTR);

drivers/net/ethernet/ti/icssg/icssg_prueth.h

120

struct device *dma_dev;

drivers/net/ethernet/ti/icssg/icssg_prueth.h

137

struct device *dma_dev;

drivers/net/ethernet/ti/icssg/icssg_prueth_sr1.c

101

buf_dma = dma_map_single(tx_chn->dma_dev, data, pkt_len, DMA_TO_DEVICE);

drivers/net/ethernet/ti/icssg/icssg_prueth_sr1.c

102

if (dma_mapping_error(tx_chn->dma_dev, buf_dma)) {

drivers/net/ethernet/ti/icssg/icssg_prueth_sr1.c

111

dma_unmap_single(tx_chn->dma_dev, buf_dma, pkt_len, DMA_TO_DEVICE);

drivers/net/ethernet/ti/icssg/icssg_prueth_sr1.c

306

dma_unmap_single(rx_chn->dma_dev, buf_dma, buf_dma_len, DMA_FROM_DEVICE);

drivers/net/ethernet/xilinx/xilinx_axienet_main.c

911

struct dma_device *dma_dev;

drivers/net/ethernet/xilinx/xilinx_axienet_main.c

918

dma_dev = lp->tx_chan->device;

drivers/net/ethernet/xilinx/xilinx_axienet_main.c

957

dma_tx_desc = dma_dev->device_prep_slave_sg(lp->tx_chan, skbuf_dma->sgl,

drivers/net/thunderbolt/main.c

1012

dma_sync_single_for_device(dma_dev,

drivers/net/thunderbolt/main.c

1087

dma_sync_single_for_device(dma_dev, frames[i]->frame.buffer_phy,

drivers/net/thunderbolt/main.c

340

struct device *dma_dev = tb_ring_dma_device(ring->ring);

drivers/net/thunderbolt/main.c

362

dma_unmap_page(dma_dev, tf->frame.buffer_phy, size,

drivers/net/thunderbolt/main.c

506

struct device *dma_dev = tb_ring_dma_device(ring->ring);

drivers/net/thunderbolt/main.c

524

dma_addr = dma_map_page(dma_dev, tf->page, 0,

drivers/net/thunderbolt/main.c

526

if (dma_mapping_error(dma_dev, dma_addr)) {

drivers/net/thunderbolt/main.c

552

struct device *dma_dev = tb_ring_dma_device(ring->ring);

drivers/net/thunderbolt/main.c

564

dma_sync_single_for_cpu(dma_dev, tf->frame.buffer_phy,

drivers/net/thunderbolt/main.c

586

struct device *dma_dev = tb_ring_dma_device(ring->ring);

drivers/net/thunderbolt/main.c

599

dma_addr = dma_map_page(dma_dev, tf->page, 0, TBNET_FRAME_SIZE,

drivers/net/thunderbolt/main.c

601

if (dma_mapping_error(dma_dev, dma_addr)) {

drivers/net/thunderbolt/main.c

807

struct device *dma_dev = tb_ring_dma_device(net->rx_ring.ring);

drivers/net/thunderbolt/main.c

833

dma_unmap_page(dma_dev, frame->buffer_phy,

drivers/net/thunderbolt/main.c

993

struct device *dma_dev = tb_ring_dma_device(net->tx_ring.ring);

drivers/net/virtio_net.c

5852

struct device *dma_dev;

drivers/net/virtio_net.c

5882

dma_dev = virtqueue_dma_dev(rq->vq);

drivers/net/virtio_net.c

5883

if (!dma_dev)

drivers/net/virtio_net.c

5899

err = xsk_pool_dma_map(pool, dma_dev, 0);

drivers/net/wireless/broadcom/b43/bus.c

104

dev->dma_dev = core->dma_dev;

drivers/net/wireless/broadcom/b43/bus.c

203

dev->dma_dev = sdev->dma_dev;

drivers/net/wireless/broadcom/b43/bus.h

40

struct device *dma_dev;

drivers/net/wireless/broadcom/b43/dma.c

1057

err = dma_set_mask_and_coherent(dev->dev->dma_dev, DMA_BIT_MASK(type));

drivers/net/wireless/broadcom/b43/dma.c

353

dmaaddr = dma_map_single(ring->dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43/dma.c

356

dmaaddr = dma_map_single(ring->dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43/dma.c

368

dma_unmap_single(ring->dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43/dma.c

371

dma_unmap_single(ring->dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43/dma.c

381

dma_sync_single_for_cpu(ring->dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43/dma.c

390

dma_sync_single_for_device(ring->dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43/dma.c

421

ring->descbase = dma_alloc_coherent(ring->dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43/dma.c

434

dma_free_coherent(ring->dev->dev->dma_dev, ring_mem_size,

drivers/net/wireless/broadcom/b43/dma.c

542

if (unlikely(dma_mapping_error(ring->dev->dev->dma_dev, addr)))

drivers/net/wireless/broadcom/b43/dma.c

897

dma_test = dma_map_single(dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43/dma.c

912

dma_test = dma_map_single(dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43/dma.c

926

dma_unmap_single(dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43legacy/dma.c

234

dmaaddr = dma_map_single(ring->dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43legacy/dma.c

238

dmaaddr = dma_map_single(ring->dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43legacy/dma.c

252

dma_unmap_single(ring->dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43legacy/dma.c

256

dma_unmap_single(ring->dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43legacy/dma.c

268

dma_sync_single_for_cpu(ring->dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43legacy/dma.c

279

dma_sync_single_for_device(ring->dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43legacy/dma.c

300

ring->descbase = dma_alloc_coherent(ring->dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43legacy/dma.c

311

dma_free_coherent(ring->dev->dev->dma_dev, B43legacy_DMA_RINGMEMSIZE,

drivers/net/wireless/broadcom/b43legacy/dma.c

395

if (unlikely(dma_mapping_error(ring->dev->dev->dma_dev, addr)))

drivers/net/wireless/broadcom/b43legacy/dma.c

634

dma_test = dma_map_single(dev->dev->dma_dev, ring->txhdr_cache,

drivers/net/wireless/broadcom/b43legacy/dma.c

648

dma_test = dma_map_single(dev->dev->dma_dev,

drivers/net/wireless/broadcom/b43legacy/dma.c

658

dma_unmap_single(dev->dev->dma_dev, dma_test,

drivers/net/wireless/broadcom/b43legacy/dma.c

761

err = dma_set_mask_and_coherent(dev->dev->dma_dev, DMA_BIT_MASK(type));

drivers/net/wireless/broadcom/brcm80211/brcmsmac/dma.c

589

di->dmadev = core->dma_dev;

drivers/net/wireless/mediatek/mt76/dma.c

135

dma_unmap_single(dev->dma_dev, t->dma_addr, dev->drv->txwi_size,

drivers/net/wireless/mediatek/mt76/dma.c

23

addr = dma_map_single(dev->dma_dev, txwi, dev->drv->txwi_size,

drivers/net/wireless/mediatek/mt76/dma.c

25

if (unlikely(dma_mapping_error(dev->dma_dev, addr))) {

drivers/net/wireless/mediatek/mt76/dma.c

382

dma_unmap_single(dev->dma_dev, e->dma_addr[0], e->dma_len[0],

drivers/net/wireless/mediatek/mt76/dma.c

386

dma_unmap_single(dev->dma_dev, e->dma_addr[1], e->dma_len[1],

drivers/net/wireless/mediatek/mt76/dma.c

466

dma_sync_single_for_cpu(dev->dma_dev, t->dma_addr,

drivers/net/wireless/mediatek/mt76/dma.c

525

dma_sync_single_for_cpu(dev->dma_dev, t->dma_addr,

drivers/net/wireless/mediatek/mt76/dma.c

537

dma_sync_single_for_cpu(dev->dma_dev, e->dma_addr[0],

drivers/net/wireless/mediatek/mt76/dma.c

616

addr = dma_map_single(dev->dma_dev, skb->data, skb->len,

drivers/net/wireless/mediatek/mt76/dma.c

618

if (unlikely(dma_mapping_error(dev->dma_dev, addr)))

drivers/net/wireless/mediatek/mt76/dma.c

673

addr = dma_map_single(dev->dma_dev, skb->data, len, DMA_TO_DEVICE);

drivers/net/wireless/mediatek/mt76/dma.c

674

if (unlikely(dma_mapping_error(dev->dma_dev, addr)))

drivers/net/wireless/mediatek/mt76/dma.c

686

addr = dma_map_single(dev->dma_dev, iter->data, iter->len,

drivers/net/wireless/mediatek/mt76/dma.c

688

if (unlikely(dma_mapping_error(dev->dma_dev, addr)))

drivers/net/wireless/mediatek/mt76/dma.c

701

dma_sync_single_for_cpu(dev->dma_dev, t->dma_addr, dev->drv->txwi_size,

drivers/net/wireless/mediatek/mt76/dma.c

704

dma_sync_single_for_device(dev->dma_dev, t->dma_addr, dev->drv->txwi_size,

drivers/net/wireless/mediatek/mt76/dma.c

717

dma_unmap_single(dev->dma_dev, tx_info.buf[n].addr,

drivers/net/wireless/mediatek/mt76/dma.c

821

q->desc = dmam_alloc_coherent(dev->dma_dev, q->ndesc * size,

drivers/net/wireless/mediatek/mt76/mac80211.c

621

.dev = dev->dma_dev,

drivers/net/wireless/mediatek/mt76/mac80211.c

683

dev->dma_dev = pdev;

drivers/net/wireless/mediatek/mt76/mt76.h

936

struct device *dma_dev;

drivers/net/wireless/mediatek/mt76/mt76_connac_mac.c

205

struct device *dev = is_connac_v1(mdev) ? mdev->dev : mdev->dma_dev;

drivers/net/wireless/mediatek/mt76/mt7915/mmio.c

728

dev->mt76.dma_dev = wed->dev;

drivers/net/wireless/mediatek/mt76/mt7996/init.c

1014

dmam_free_coherent(dev->mt76.dma_dev,

drivers/net/wireless/mediatek/mt76/mt7996/init.c

1024

dmam_free_coherent(dev->mt76.dma_dev,

drivers/net/wireless/mediatek/mt76/mt7996/init.c

1035

dmam_free_coherent(dev->mt76.dma_dev,

drivers/net/wireless/mediatek/mt76/mt7996/init.c

1042

dmam_free_coherent(dev->mt76.dma_dev,

drivers/net/wireless/mediatek/mt76/mt7996/init.c

1048

dmam_free_coherent(dev->mt76.dma_dev,

drivers/net/wireless/mediatek/mt76/mt7996/init.c

1056

dmam_free_coherent(dev->mt76.dma_dev,

drivers/net/wireless/mediatek/mt76/mt7996/init.c

907

ptr = dmam_alloc_coherent(dev->mt76.dma_dev,

drivers/net/wireless/mediatek/mt76/mt7996/init.c

921

ptr = dmam_alloc_coherent(dev->mt76.dma_dev,

drivers/net/wireless/mediatek/mt76/mt7996/init.c

950

ptr = dmam_alloc_coherent(dev->mt76.dma_dev,

drivers/net/wireless/mediatek/mt76/mt7996/init.c

965

ptr = dmam_alloc_coherent(dev->mt76.dma_dev,

drivers/net/wireless/mediatek/mt76/mt7996/init.c

974

ptr = dmam_alloc_coherent(dev->mt76.dma_dev,

drivers/net/wireless/mediatek/mt76/mt7996/init.c

984

ptr = dmam_alloc_coherent(dev->mt76.dma_dev,

drivers/net/wireless/mediatek/mt76/mt7996/mac.c

1113

dma_sync_single_for_cpu(mdev->dma_dev, tx_info->buf[1].addr,

drivers/net/wireless/mediatek/mt76/mt7996/mac.c

1127

dma_sync_single_for_device(mdev->dma_dev, tx_info->buf[1].addr,

drivers/net/wireless/mediatek/mt76/mt7996/mac.c

1948

dma_sync_single_for_cpu(mdev->dma_dev, p->dma_addr,

drivers/net/wireless/mediatek/mt76/mt7996/mac.c

1967

dma_sync_single_for_cpu(mdev->dma_dev, t->dma_addr,

drivers/net/wireless/mediatek/mt76/mt7996/mmio.c

619

dev->mt76.dma_dev = wed->dev;

drivers/net/wireless/mediatek/mt76/mt7996/npu.c

167

if (!dmam_alloc_coherent(dev->mt76.dma_dev,

drivers/net/wireless/mediatek/mt76/mt7996/npu.c

181

if (!dmam_alloc_coherent(dev->mt76.dma_dev,

drivers/net/wireless/mediatek/mt76/mt7996/npu.c

195

if (!dmam_alloc_coherent(dev->mt76.dma_dev, 256 * 1024,

drivers/net/wireless/mediatek/mt76/npu.c

455

dev->dma_dev = npu->dev;

drivers/net/wireless/mediatek/mt76/npu.c

52

dma_sync_single_for_cpu(dev->dma_dev, e->dma_addr[0],

drivers/net/wireless/mediatek/mt76/npu.c

83

dma_sync_single_for_cpu(dev->dma_dev, e->dma_addr[0],

drivers/ntb/test/ntb_perf.c

790

struct device *dma_dev;

drivers/ntb/test/ntb_perf.c

802

dma_dev = pthr->dma_chan->device->dev;

drivers/ntb/test/ntb_perf.c

812

unmap = dmaengine_get_unmap_data(dma_dev, 1, GFP_NOWAIT);

drivers/ntb/test/ntb_perf.c

817

unmap->addr[0] = dma_map_page(dma_dev, virt_to_page(src),

drivers/ntb/test/ntb_perf.c

819

if (dma_mapping_error(dma_dev, unmap->addr[0])) {

drivers/nvme/host/pci.c

875

struct device *dma_dev = nvmeq->dev->dev;

drivers/nvme/host/pci.c

879

dma_unmap_phys(dma_dev, le64_to_cpu(sge->addr), len, dir,

drivers/nvme/host/pci.c

885

dma_unmap_phys(dma_dev, le64_to_cpu(sg_list[i].addr),

drivers/nvme/host/pci.c

895

struct device *dma_dev = nvmeq->dev->dev;

drivers/nvme/host/pci.c

900

dma_unmap_page(dma_dev, iod->meta_dma,

drivers/nvme/host/pci.c

913

if (!blk_rq_dma_unmap(req, dma_dev, &iod->meta_dma_state,

drivers/nvme/host/pci.c

918

dma_unmap_phys(dma_dev, iod->meta_dma,

drivers/nvme/host/pci.c

932

struct device *dma_dev = nvmeq->dev->dev;

drivers/nvme/host/pci.c

938

dma_unmap_page(dma_dev, le64_to_cpu(iod->cmd.common.dptr.prp1),

drivers/nvme/host/pci.c

950

if (!blk_rq_dma_unmap(req, dma_dev, &iod->dma_state, iod->total_len,

drivers/nvme/host/pci.c

964

struct device *dma_dev,

drivers/nvme/host/pci.c

969

if (dma_use_iova(&iod->dma_state) || !dma_need_unmap(dma_dev))

drivers/nvme/host/pci.c

989

static bool nvme_pci_prp_iter_next(struct request *req, struct device *dma_dev,

drivers/nvme/host/pci.c

994

if (!blk_rq_dma_map_iter_next(req, dma_dev, iter))

drivers/nvme/host/pci.c

996

return nvme_pci_prp_save_mapping(req, dma_dev, iter);

drivers/nvme/target/pci-epf.c

367

struct device *dma_dev;

drivers/nvme/target/pci-epf.c

393

dma_dev = dmaengine_get_dma_device(chan);

drivers/nvme/target/pci-epf.c

394

dma_addr = dma_map_single(dma_dev, seg->buf, seg->length, dir);

drivers/nvme/target/pci-epf.c

395

ret = dma_mapping_error(dma_dev, dma_addr);

drivers/nvme/target/pci-epf.c

428

dma_unmap_single(dma_dev, dma_addr, seg->length, dir);

drivers/pci/endpoint/functions/pci-epf-mhi.c

313

struct device *dma_dev = epf_mhi->epf->epc->dev.parent;

drivers/pci/endpoint/functions/pci-epf-mhi.c

337

dst_addr = dma_map_single(dma_dev, buf_info->dev_addr, buf_info->size,

drivers/pci/endpoint/functions/pci-epf-mhi.c

339

ret = dma_mapping_error(dma_dev, dst_addr);

drivers/pci/endpoint/functions/pci-epf-mhi.c

373

dma_unmap_single(dma_dev, dst_addr, buf_info->size, DMA_FROM_DEVICE);

drivers/pci/endpoint/functions/pci-epf-mhi.c

384

struct device *dma_dev = epf_mhi->epf->epc->dev.parent;

drivers/pci/endpoint/functions/pci-epf-mhi.c

408

src_addr = dma_map_single(dma_dev, buf_info->dev_addr, buf_info->size,

drivers/pci/endpoint/functions/pci-epf-mhi.c

410

ret = dma_mapping_error(dma_dev, src_addr);

drivers/pci/endpoint/functions/pci-epf-mhi.c

444

dma_unmap_single(dma_dev, src_addr, buf_info->size, DMA_TO_DEVICE);

drivers/pci/endpoint/functions/pci-epf-mhi.c

454

struct device *dma_dev = epf_mhi->epf->epc->dev.parent;

drivers/pci/endpoint/functions/pci-epf-mhi.c

466

dma_unmap_single(dma_dev, itr->paddr, itr->size, itr->dir);

drivers/pci/endpoint/functions/pci-epf-mhi.c

489

struct device *dma_dev = epf_mhi->epf->epc->dev.parent;

drivers/pci/endpoint/functions/pci-epf-mhi.c

511

dst_addr = dma_map_single(dma_dev, buf_info->dev_addr, buf_info->size,

drivers/pci/endpoint/functions/pci-epf-mhi.c

513

ret = dma_mapping_error(dma_dev, dst_addr);

drivers/pci/endpoint/functions/pci-epf-mhi.c

557

dma_unmap_single(dma_dev, dst_addr, buf_info->size, DMA_FROM_DEVICE);

drivers/pci/endpoint/functions/pci-epf-mhi.c

568

struct device *dma_dev = epf_mhi->epf->epc->dev.parent;

drivers/pci/endpoint/functions/pci-epf-mhi.c

590

src_addr = dma_map_single(dma_dev, buf_info->dev_addr, buf_info->size,

drivers/pci/endpoint/functions/pci-epf-mhi.c

592

ret = dma_mapping_error(dma_dev, src_addr);

drivers/pci/endpoint/functions/pci-epf-mhi.c

636

dma_unmap_single(dma_dev, src_addr, buf_info->size, DMA_TO_DEVICE);

drivers/pci/endpoint/functions/pci-epf-mhi.c

662

struct device *dma_dev = epf_mhi->epf->epc->dev.parent;

drivers/pci/endpoint/functions/pci-epf-mhi.c

671

filter.dev = dma_dev;

drivers/pci/endpoint/functions/pci-epf-test.c

462

struct device *dma_dev = epf->epc->dev.parent;

drivers/pci/endpoint/functions/pci-epf-test.c

490

dst_phys_addr = dma_map_single(dma_dev, buf, map_size,

drivers/pci/endpoint/functions/pci-epf-test.c

492

if (dma_mapping_error(dma_dev, dst_phys_addr)) {

drivers/pci/endpoint/functions/pci-epf-test.c

507

dma_unmap_single(dma_dev, dst_phys_addr, map_size,

drivers/pci/endpoint/functions/pci-epf-test.c

559

struct device *dma_dev = epf->epc->dev.parent;

drivers/pci/endpoint/functions/pci-epf-test.c

588

src_phys_addr = dma_map_single(dma_dev, buf, map_size,

drivers/pci/endpoint/functions/pci-epf-test.c

590

if (dma_mapping_error(dma_dev, src_phys_addr)) {

drivers/pci/endpoint/functions/pci-epf-test.c

607

dma_unmap_single(dma_dev, src_phys_addr, map_size,

drivers/s390/cio/css.c

1066

struct gen_pool *cio_gp_dma_create(struct device *dma_dev, int nr_pages)

drivers/s390/cio/css.c

1077

cpu_addr = dma_alloc_coherent(dma_dev, PAGE_SIZE, &dma_addr,

drivers/s390/cio/css.c

1097

void cio_gp_dma_destroy(struct gen_pool *gp_dma, struct device *dma_dev)

drivers/s390/cio/css.c

1102

gen_pool_for_each_chunk(gp_dma, __gp_dma_free_dma, dma_dev);

drivers/s390/cio/css.c

1115

void *__cio_gp_dma_zalloc(struct gen_pool *gp_dma, struct device *dma_dev,

drivers/s390/cio/css.c

1127

addr = dma_alloc_coherent(dma_dev, chunk_size, &dma_addr, CIO_DMA_GFP);

drivers/s390/cio/css.c

1138

void *cio_gp_dma_zalloc(struct gen_pool *gp_dma, struct device *dma_dev,

drivers/s390/cio/css.c

1141

return __cio_gp_dma_zalloc(gp_dma, dma_dev, size, NULL);

drivers/scsi/aha1542.c

1021

acmd->data_buffer = dma_alloc_coherent(shost->dma_dev,

drivers/scsi/aha1542.c

1033

dma_free_coherent(shost->dma_dev, SECTOR_SIZE * AHA1542_MAX_SECTORS,

drivers/scsi/aha1542.c

843

struct device *dev = sh->dma_dev;

drivers/scsi/hosts.c

220

struct device *dma_dev)

drivers/scsi/hosts.c

250

if (!dma_dev)

drivers/scsi/hosts.c

251

dma_dev = shost->shost_gendev.parent;

drivers/scsi/hosts.c

253

shost->dma_dev = dma_dev;

drivers/scsi/hosts.c

255

if (dma_dev->dma_mask) {

drivers/scsi/hosts.c

257

dma_max_mapping_size(dma_dev) >> SECTOR_SHIFT);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

1231

vio_enable_interrupts(vscsi->dma_dev);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

1517

info = dma_alloc_coherent(&vscsi->dma_dev->dev, sizeof(*info), &token,

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

1596

dma_free_coherent(&vscsi->dma_dev->dev, sizeof(*info), info, token);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

1636

cap = dma_alloc_coherent(&vscsi->dma_dev->dev, olen, &token,

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

1648

strscpy_pad(cap->name, dev_name(&vscsi->dma_dev->dev),

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

1712

dma_free_coherent(&vscsi->dma_dev->dev, olen, cap, token);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

1939

rc = h_send_crq(vscsi->dma_dev->unit_address,

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

2589

struct vio_dev *vdev = vscsi->dma_dev;

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

261

vio_disable_interrupts(vscsi->dma_dev);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

2640

vdev = vscsi->dma_dev;

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

2948

vio_disable_interrupts(vscsi->dma_dev);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

2998

struct vio_dev *vdev = vscsi->dma_dev;

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3034

dma_unmap_single(&vscsi->dma_dev->dev, vscsi->cmd_q.crq_token,

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3336

vio_enable_interrupts(vscsi->dma_dev);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3400

vio_enable_interrupts(vscsi->dma_dev);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3434

vscsi->dma_dev = vdev;

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3589

dev_dbg(&vscsi->dev, "remove (%s)\n", dev_name(&vscsi->dma_dev->dev));

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3625

return sysfs_emit(buf, "%x\n", vscsi->dma_dev->unit_address);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

818

rc = vio_enable_interrupts(vscsi->dma_dev);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

890

vio_enable_interrupts(vscsi->dma_dev);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.h

295

struct vio_dev *dma_dev;

drivers/scsi/scsi_debug.c

454

dev_to_sdebug_host(shost->dma_dev)

drivers/scsi/scsi_lib.c

2021

struct device *dev = shost->dma_dev;

drivers/scsi/scsi_lib.c

2125

tag_set->numa_node = dev_to_node(shost->dma_dev);

drivers/scsi/scsi_lib_dma.c

28

struct device *dev = cmd->device->host->dma_dev;

drivers/scsi/scsi_lib_dma.c

46

struct device *dev = cmd->device->host->dma_dev;

drivers/scsi/scsi_transport_sas.c

230

struct device *dma_dev = shost->dma_dev;

drivers/scsi/scsi_transport_sas.c

242

if (dma_dev->dma_mask) {

drivers/scsi/scsi_transport_sas.c

244

dma_opt_mapping_size(dma_dev) >> SECTOR_SHIFT);

drivers/soc/ti/k3-ringacc.c

177

struct device *dma_dev;

drivers/soc/ti/k3-ringacc.c

615

dma_free_coherent(ring->dma_dev,

drivers/soc/ti/k3-ringacc.c

620

ring->dma_dev = NULL;

drivers/soc/ti/k3-ringacc.c

726

ring->dma_dev = cfg->dma_dev;

drivers/soc/ti/k3-ringacc.c

727

if (!ring->dma_dev) {

drivers/soc/ti/k3-ringacc.c

730

ring->dma_dev = ringacc->dev;

drivers/soc/ti/k3-ringacc.c

737

ring->ring_mem_virt = dma_alloc_coherent(ring->dma_dev,

drivers/soc/ti/k3-ringacc.c

771

dma_free_coherent(ring->dma_dev,

drivers/soc/ti/k3-ringacc.c

778

ring->dma_dev = NULL;

drivers/soc/ti/k3-ringacc.c

834

ring->dma_dev = cfg->dma_dev;

drivers/soc/ti/k3-ringacc.c

835

if (!ring->dma_dev)

drivers/soc/ti/k3-ringacc.c

836

ring->dma_dev = ringacc->dev;

drivers/soc/ti/k3-ringacc.c

839

ring->dma_dev = ringacc->dev;

drivers/soc/ti/k3-ringacc.c

851

ring->ring_mem_virt = dma_alloc_coherent(ring->dma_dev,

drivers/soc/ti/k3-ringacc.c

874

dma_free_coherent(ring->dma_dev,

drivers/soc/ti/k3-ringacc.c

880

ring->dma_dev = NULL;

drivers/spi/spi-dw-dma.c

115

struct pci_dev *dma_dev;

drivers/spi/spi-dw-dma.c

123

dma_dev = pci_get_device(PCI_VENDOR_ID_INTEL, 0x0827, NULL);

drivers/spi/spi-dw-dma.c

124

if (!dma_dev)

drivers/spi/spi-dw-dma.c

131

rx->dma_dev = &dma_dev->dev;

drivers/spi/spi-dw-dma.c

137

tx->dma_dev = &dma_dev->dev;

drivers/spi/spi-dw-dma.c

153

pci_dev_put(dma_dev);

drivers/spi/spi-dw-dma.c

164

pci_dev_put(dma_dev);

drivers/spi/spi-dw-dma.c

30

if (s->dma_dev != chan->device->dev)

drivers/spi/spi-pxa2xx-pci.c

100

struct pci_dev *dma_dev;

drivers/spi/spi-pxa2xx-pci.c

152

dma_dev = pci_get_slot(dev->bus, PCI_DEVFN(PCI_SLOT(dev->devfn), 0));

drivers/spi/spi-pxa2xx-pci.c

153

ret = devm_add_action_or_reset(&dev->dev, lpss_dma_put_device, dma_dev);

drivers/spi/spi-pxa2xx-pci.c

158

tx->dma_dev = &dma_dev->dev;

drivers/spi/spi-pxa2xx-pci.c

163

rx->dma_dev = &dma_dev->dev;

drivers/spi/spi-pxa2xx-pci.c

196

struct pci_dev *dma_dev;

drivers/spi/spi-pxa2xx-pci.c

228

dma_dev = pci_get_slot(dev->bus, PCI_DEVFN(21, 0));

drivers/spi/spi-pxa2xx-pci.c

229

ret = devm_add_action_or_reset(&dev->dev, lpss_dma_put_device, dma_dev);

drivers/spi/spi-pxa2xx-pci.c

234

tx->dma_dev = &dma_dev->dev;

drivers/spi/spi-pxa2xx-pci.c

237

rx->dma_dev = &dma_dev->dev;

drivers/spi/spi-pxa2xx-pci.c

84

if (dws->dma_dev != chan->device->dev)

drivers/spi/spi-pxa2xx-pci.c

91

static void lpss_dma_put_device(void *dma_dev)

drivers/spi/spi-pxa2xx-pci.c

93

pci_dev_put(dma_dev);

drivers/spi/spi-topcliff-pch.c

106

struct pci_dev *dma_dev;

drivers/spi/spi-topcliff-pch.c

811

(param->dma_dev == chan->device->dev)) {

drivers/spi/spi-topcliff-pch.c

823

struct pci_dev *dma_dev;

drivers/spi/spi-topcliff-pch.c

838

dma_dev = pci_get_slot(data->board_dat->pdev->bus,

drivers/spi/spi-topcliff-pch.c

843

param->dma_dev = &dma_dev->dev;

drivers/spi/spi-topcliff-pch.c

857

param->dma_dev = &dma_dev->dev;

drivers/spi/spi-topcliff-pch.c

871

dma->dma_dev = dma_dev;

drivers/spi/spi-topcliff-pch.c

874

pci_dev_put(dma_dev);

drivers/spi/spi-topcliff-pch.c

892

pci_dev_put(dma->dma_dev);

drivers/ssb/main.c

501

sdev->dma_dev = dev->parent;

drivers/ssb/main.c

517

sdev->dma_dev = dev;

drivers/thunderbolt/dma_test.c

235

struct device *dma_dev = tb_ring_dma_device(dt->rx_ring);

drivers/thunderbolt/dma_test.c

237

dma_unmap_single(dma_dev, tf->frame.buffer_phy, DMA_TEST_FRAME_SIZE,

drivers/thunderbolt/dma_test.c

263

struct device *dma_dev = tb_ring_dma_device(dt->rx_ring);

drivers/thunderbolt/dma_test.c

280

dma_addr = dma_map_single(dma_dev, tf->data, DMA_TEST_FRAME_SIZE,

drivers/thunderbolt/dma_test.c

282

if (dma_mapping_error(dma_dev, dma_addr)) {

drivers/thunderbolt/dma_test.c

304

struct device *dma_dev = tb_ring_dma_device(dt->tx_ring);

drivers/thunderbolt/dma_test.c

306

dma_unmap_single(dma_dev, tf->frame.buffer_phy, DMA_TEST_FRAME_SIZE,

drivers/thunderbolt/dma_test.c

314

struct device *dma_dev = tb_ring_dma_device(dt->tx_ring);

drivers/thunderbolt/dma_test.c

334

dma_addr = dma_map_single(dma_dev, tf->data, DMA_TEST_FRAME_SIZE,

drivers/thunderbolt/dma_test.c

336

if (dma_mapping_error(dma_dev, dma_addr)) {

drivers/tty/serial/8250/8250_lpss.c

120

struct pci_dev *dma_dev;

drivers/tty/serial/8250/8250_lpss.c

139

dma_dev = pci_get_slot(pdev->bus, PCI_DEVFN(PCI_SLOT(pdev->devfn), 0));

drivers/tty/serial/8250/8250_lpss.c

141

param->dma_dev = &dma_dev->dev;

drivers/tty/serial/8250/8250_lpss.c

161

put_device(param->dma_dev);

drivers/tty/serial/8250/8250_lpss.c

229

param->dma_dev = &pdev->dev;

drivers/tty/serial/8250/8250_lpss.c

242

if (!param->dma_dev)

drivers/tty/serial/8250/8250_lpss.c

269

if (dws->dma_dev != chan->device->dev)

drivers/tty/serial/8250/8250_lpss.c

282

if (!lpss->dma_param.dma_dev) {

drivers/tty/serial/8250/8250_mid.c

125

mid->dma_dev = pci_get_slot(pdev->bus, PCI_DEVFN(5, 0));

drivers/tty/serial/8250/8250_mid.c

133

pci_dev_put(mid->dma_dev);

drivers/tty/serial/8250/8250_mid.c

192

mid->dma_dev = pdev;

drivers/tty/serial/8250/8250_mid.c

200

if (!mid->dma_dev)

drivers/tty/serial/8250/8250_mid.c

246

if (s->dma_dev != chan->device->dev || s->chan_id != chan->chan_id)

drivers/tty/serial/8250/8250_mid.c

260

if (!mid->dma_dev)

drivers/tty/serial/8250/8250_mid.c

277

rx_param->dma_dev = &mid->dma_dev->dev;

drivers/tty/serial/8250/8250_mid.c

278

tx_param->dma_dev = &mid->dma_dev->dev;

drivers/tty/serial/8250/8250_mid.c

44

struct pci_dev *dma_dev;

drivers/tty/serial/8250/8250_mid.c

70

mid->dma_dev = pci_get_slot(pdev->bus,

drivers/tty/serial/8250/8250_mid.c

77

pci_dev_put(mid->dma_dev);

drivers/tty/serial/8250/8250_mid.c

89

chip = pci_get_drvdata(mid->dma_dev);

drivers/tty/serial/amba-pl011.c

600

struct dma_device *dma_dev = chan->device;

drivers/tty/serial/amba-pl011.c

629

dmatx->dma = dma_map_single(dma_dev->dev, dmatx->buf, count,

drivers/tty/serial/amba-pl011.c

631

if (dma_mapping_error(dma_dev->dev, dmatx->dma)) {

drivers/tty/serial/amba-pl011.c

640

dma_unmap_single(dma_dev->dev, dmatx->dma, dmatx->len, DMA_TO_DEVICE);

drivers/tty/serial/amba-pl011.c

658

dma_dev->device_issue_pending(chan);

drivers/tty/serial/pch_uart.c

658

if ((chan->chan_id == param->chan_id) && (param->dma_dev ==

drivers/tty/serial/pch_uart.c

671

struct pci_dev *dma_dev;

drivers/tty/serial/pch_uart.c

679

dma_dev = pci_get_slot(priv->pdev->bus,

drivers/tty/serial/pch_uart.c

684

param->dma_dev = &dma_dev->dev;

drivers/tty/serial/pch_uart.c

692

pci_dev_put(dma_dev);

drivers/tty/serial/pch_uart.c

699

param->dma_dev = &dma_dev->dev;

drivers/tty/serial/pch_uart.c

709

pci_dev_put(dma_dev);

drivers/tty/serial/pch_uart.c

718

pci_dev_put(dma_dev);

drivers/ufs/core/ufs_bsg.c

111

sg_cnt = dma_map_sg(hba->host->dma_dev, payload->sg_list, payload->sg_cnt, dir);

drivers/ufs/core/ufs_bsg.c

123

dma_unmap_sg(hba->host->dma_dev, payload->sg_list, payload->sg_cnt, dir);

drivers/usb/chipidea/udc.c

548

static int sglist_get_invalid_entry(struct device *dma_dev, u8 dir,

drivers/usb/chipidea/udc.c

564

if (dma_kmalloc_needs_bounce(dma_dev, s->length, dir))

drivers/usb/host/bcma-hcd.c

350

if (dma_set_mask_and_coherent(dev->dma_dev, DMA_BIT_MASK(32)))

drivers/usb/host/ssb-hcd.c

165

if (dma_set_mask_and_coherent(dev->dma_dev, DMA_BIT_MASK(32)))

drivers/usb/renesas_usbhs/mod_gadget.c

187

static int usbhsg_dma_map_ctrl(struct device *dma_dev, struct usbhs_pkt *pkt,

drivers/usb/renesas_usbhs/mod_gadget.c

202

ret = usb_gadget_map_request_by_dev(dma_dev, req, dir);

drivers/usb/renesas_usbhs/mod_gadget.c

208

usb_gadget_unmap_request_by_dev(dma_dev, req, dir);

drivers/usb/renesas_usbhs/mod_host.c

917

static int usbhsh_dma_map_ctrl(struct device *dma_dev, struct usbhs_pkt *pkt,

drivers/usb/renesas_usbhs/pipe.c

672

int (*dma_map_ctrl)(struct device *dma_dev,

drivers/usb/renesas_usbhs/pipe.h

41

int (*dma_map_ctrl)(struct device *dma_dev, struct usbhs_pkt *pkt,

drivers/usb/renesas_usbhs/pipe.h

79

int (*dma_map_ctrl)(struct device *dma_dev,

drivers/vdpa/alibaba/eni_vdpa.c

500

eni_vdpa->vdpa.vmap.dma_dev = &pdev->dev;

drivers/vdpa/ifcvf/ifcvf_main.c

717

adapter->vdpa.vmap.dma_dev = &pdev->dev;

drivers/vdpa/mlx5/core/mr.c

381

struct device *dma = mvdev->vdev.vmap.dma_dev;

drivers/vdpa/mlx5/core/mr.c

435

struct device *dma = mvdev->vdev.vmap.dma_dev;

drivers/vdpa/mlx5/net/mlx5_vnet.c

3413

map.dma_dev = &vdev->dev;

drivers/vdpa/mlx5/net/mlx5_vnet.c

3415

map.dma_dev = mvdev->vdev.vmap.dma_dev;

drivers/vdpa/mlx5/net/mlx5_vnet.c

3978

mvdev->vdev.vmap.dma_dev = &mdev->pdev->dev;

drivers/vdpa/octeon_ep/octep_vdpa_main.c

519

oct_vdpa->vdpa.vmap.dma_dev = &pdev->dev;

drivers/vdpa/pds/vdpa_dev.c

618

struct device *dma_dev;

drivers/vdpa/pds/vdpa_dev.c

646

dma_dev = &pdev->dev;

drivers/vdpa/pds/vdpa_dev.c

647

pdsv->vdpa_dev.vmap.dma_dev = dma_dev;

drivers/vdpa/solidrun/snet_main.c

1056

snet->vdpa.vmap.dma_dev = &pdev->dev;

drivers/vdpa/vdpa_sim/vdpa_sim.c

273

vdpasim->vdpa.vmap.dma_dev = dev;

drivers/vdpa/virtio_pci/vp_vdpa.c

524

vp_vdpa->vdpa.vmap.dma_dev = &pdev->dev;

drivers/vhost/vdpa.c

1324

struct device *dma_dev = map.dma_dev;

drivers/vhost/vdpa.c

1331

if (!device_iommu_capable(dma_dev, IOMMU_CAP_CACHE_COHERENCY)) {

drivers/vhost/vdpa.c

1337

v->domain = iommu_paging_domain_alloc(dma_dev);

drivers/vhost/vdpa.c

1344

ret = iommu_attach_device(v->domain, dma_dev);

drivers/vhost/vdpa.c

1360

struct device *dma_dev = map.dma_dev;

drivers/vhost/vdpa.c

1363

iommu_detach_device(v->domain, dma_dev);

drivers/virtio/virtio_ring.c

2995

return vq->map.dma_dev;

drivers/virtio/virtio_ring.c

3272

union virtio_map map = {.dma_dev = vdev->dev.parent};

drivers/virtio/virtio_ring.c

3413

union virtio_map map = {.dma_dev = vdev->dev.parent};

drivers/virtio/virtio_ring.c

3692

return dma_alloc_coherent(map.dma_dev, size,

drivers/virtio/virtio_ring.c

3714

dma_free_coherent(map.dma_dev, size, vaddr, map_handle);

drivers/virtio/virtio_ring.c

428

return vq->map.dma_dev;

drivers/virtio/virtio_vdpa.c

470

vdpa_get_map(vdpa).dma_dev;

drivers/xen/gntdev-common.h

35

struct device *dma_dev;

drivers/xen/gntdev-common.h

75

struct device *dma_dev;

drivers/xen/gntdev-dmabuf.c

458

args.dev = priv->dma_dev;

drivers/xen/gntdev-dmabuf.c

787

priv->dma_dev, op.fd,

drivers/xen/gntdev.c

111

args.dev = map->dma_dev;

drivers/xen/gntdev.c

182

add->dma_dev = priv->dma_dev;

drivers/xen/gntdev.c

184

args.dev = priv->dma_dev;

drivers/xen/gntdev.c

605

priv->dma_dev = gntdev_miscdev.this_device;

drivers/xen/gntdev.c

606

dma_coerce_mask_and_coherent(priv->dma_dev, DMA_BIT_MASK(64));

include/drm/drm_device.h

105

struct device *dma_dev;

include/drm/drm_device.h

380

void drm_dev_set_dma_dev(struct drm_device *dev, struct device *dma_dev);

include/drm/drm_device.h

394

if (dev->dma_dev)

include/drm/drm_device.h

395

return dev->dma_dev;

include/linux/bcma/bcma.h

272

struct device *dma_dev;

include/linux/blk-integrity.h

131

struct device *dma_dev, struct dma_iova_state *state,

include/linux/blk-integrity.h

137

struct device *dma_dev, struct blk_dma_iter *iter)

include/linux/blk-integrity.h

42

struct device *dma_dev, struct dma_iova_state *state,

include/linux/blk-integrity.h

45

struct device *dma_dev, struct blk_dma_iter *iter);

include/linux/blk-mq-dma.h

28

bool blk_rq_dma_map_iter_start(struct request *req, struct device *dma_dev,

include/linux/blk-mq-dma.h

30

bool blk_rq_dma_map_iter_next(struct request *req, struct device *dma_dev,

include/linux/blk-mq-dma.h

56

static inline bool blk_rq_dma_unmap(struct request *req, struct device *dma_dev,

include/linux/blk-mq-dma.h

69

dma_iova_destroy(dma_dev, state, mapped_len, rq_dma_dir(req),

include/linux/blk-mq-dma.h

74

return !dma_need_unmap(dma_dev);

include/linux/mcb.h

75

struct device *dma_dev;

include/linux/pch_dma.h

18

struct device *dma_dev;

include/linux/platform_data/amd_qdma.h

35

struct device *dma_dev;

include/linux/platform_data/dma-dw.h

33

struct device *dma_dev;

include/linux/platform_data/dma-hsu.h

14

struct device *dma_dev;

include/linux/shdma-base.h

107

struct dma_device dma_dev;

include/linux/shdma-base.h

114

i < (d)->dma_dev.chancnt; c = (d)->schan[++i])

include/linux/soc/ti/k3-ringacc.h

82

struct device *dma_dev;

include/linux/ssb/ssb.h

273

struct device *dev, *dma_dev;

include/linux/virtio.h

50

struct device *dma_dev;

include/scsi/scsi_host.h

750

struct device *dma_dev;

include/sound/dmaengine_pcm.h

153

struct device *dma_dev;

net/core/devmem.c

185

struct device *dma_dev,

net/core/devmem.c

198

if (!dma_dev) {

net/core/devmem.c

228

binding->attachment = dma_buf_attach(binding->dmabuf, dma_dev);

net/core/devmem.h

169

struct device *dma_dev,

net/core/devmem.h

88

struct device *dma_dev,

net/core/netdev-genl.c

1000

err = PTR_ERR(dma_dev);

net/core/netdev-genl.c

1004

binding = net_devmem_bind_dmabuf(netdev, dma_dev, DMA_FROM_DEVICE,

net/core/netdev-genl.c

1051

struct device *dma_dev;

net/core/netdev-genl.c

1098

dma_dev = netdev_queue_get_dma_dev(netdev, 0);

net/core/netdev-genl.c

1099

binding = net_devmem_bind_dmabuf(netdev, dma_dev, DMA_TO_DEVICE,

net/core/netdev-genl.c

915

struct device *dma_dev = NULL;

net/core/netdev-genl.c

922

if (dma_dev && rxq_dma_dev != dma_dev) {

net/core/netdev-genl.c

928

dma_dev = rxq_dma_dev;

net/core/netdev-genl.c

932

return dma_dev;

net/core/netdev-genl.c

942

struct device *dma_dev;

net/core/netdev-genl.c

998

dma_dev = netdev_nl_get_dma_dev(netdev, rxq_bitmap, info->extack);

net/core/netdev-genl.c

999

if (IS_ERR(dma_dev)) {

net/core/netdev_queues.c

18

struct device *dma_dev;

net/core/netdev_queues.c

21

dma_dev = queue_ops->ndo_queue_get_dma_dev(dev, idx);

net/core/netdev_queues.c

23

dma_dev = dev->dev.parent;

net/core/netdev_queues.c

25

return dma_dev && dma_dev->dma_mask ? dma_dev : NULL;

sound/pci/trident/trident.h

374

struct snd_dma_device dma_dev;

sound/soc/apple/mca.c

808

struct device *dma_dev = chan->device->dev;

sound/soc/apple/mca.c

821

hw.period_bytes_max = dma_get_max_seg_size(dma_dev);

sound/soc/samsung/dma.h

17

struct device *dma_dev);

sound/soc/samsung/dmaengine.c

19

struct device *dma_dev)

sound/soc/samsung/dmaengine.c

29

pcm_conf->dma_dev = dma_dev;

sound/soc/soc-generic-dmaengine-pcm.c

103

struct device *dma_dev = dmaengine_dma_dev(pcm, substream);

sound/soc/soc-generic-dmaengine-pcm.c

128

hw.period_bytes_max = dma_get_max_seg_size(dma_dev);

sound/soc/soc-generic-dmaengine-pcm.c

365

!(config->dma_dev && config->dma_dev->of_node)))

sound/soc/soc-generic-dmaengine-pcm.c

368

if (config->dma_dev) {

sound/soc/soc-generic-dmaengine-pcm.c

376

dev_name(config->dma_dev));

sound/soc/soc-generic-dmaengine-pcm.c

377

dev = config->dma_dev;

sound/soc/tegra/tegra_pcm.c

62

config->dma_dev = dev->parent;