LINUX-DMA-子系统

已于 2024-04-03 09:19:21 修改
阅读量5k 收藏 61
点赞数 5
分类专栏： Linux 文章标签： linux
于 2022-04-10 16:09:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HT_77/article/details/124077109
版权

目录

1. DMA子系统概述

2. DMA子系统软件框架

2.1 DMA子系统内部实现

3. DMA 地址 

4. DMA类型

4.1.  Coherent DMA

4.1.1 Coherent DMA使用

4.2.  Streaming DMA

4.2.1. Streaming DMA使用

4.2.2. scatterlist streaming DMA

4.2.2. streaming DMA sync cache

5. DMA方向

6. DMA API

6.1. dma_alloc_coherent

6.2. dma_pool*

6.3 dma_set_mask*

6.4 dma_map_single

6.6 dma_map_sg

6.7 dma_map_page

6.8 dma_sync_single_for*

6.9 dma_request_chan

6.10 dmaengine_slave_config

2.11 dmaengine_prep_slave_sg

6.12 dmaengine_prep_dma_cyclic

6.13 dmaengine_prep_interleaved_dma

6.14 dmaengine_submit

6.15 dma_async_issue_pending

6.16 dmaengine_terminate*

6.17 dmaengine_pause

6.18 dmaengine_resume

6.19 dma_async_is_tx_complete

7. DMA engine usage

1. DMA子系统概述

DMA子系统为不同的DMA控制器提供统一的注册接口，为DMA使用者提供屏蔽DMA控制器实现细节的统一接口。

2. DMA子系统软件框架

DMA子系统由四大部分构成：

1. dmaengine： 实现DMA子系统的DMA设备注册，为DMA使用者提供屏蔽DMA控制器实现细节的统一接口。

2. virt-dma：为DMA子系统提供虚拟DMA channel的支持

3. of-dma：为DMA子系统提供DMA 设备树的支持

4. dma driver：为DMA控制器的实现

2.1 DMA子系统内部实现

 以全志平台为例。

DMA内部主要数据结构已经流出如上图所示。

3. DMA 地址 

              CPU                  CPU                  Bus
             Virtual              Physical             Address
             Address              Address               Space
              Space                Space

            +-------+             +------+             +------+
            |       |             |MMIO  |   Offset    |      |
            |       |  Virtual    |Space |   applied   |      |
          C +-------+ --------> B +------+ ----------> +------+ A
            |       |  mapping    |      |   by host   |      |
  +-----+   |       |             |      |   bridge    |      |   +--------+
  |     |   |       |             +------+             |      |   |        |
  | CPU |   |       |             | RAM  |             |      |   | Device |
  |     |   |       |             |      |             |      |   |        |
  +-----+   +-------+             +------+             +------+   +--------+
            |       |  Virtual    |Buffer|   Mapping   |      |
          X +-------+ --------> Y +------+ <---------- +------+ Z
            |       |  mapping    | RAM  |   by IOMMU
            |       |             |      |
            |       |             |      |
            +-------+             +------+

DMA中会涉及到几类型的地址：

1. 虚拟地址：内核通常使用的地址就是虚拟地址，大部分是由kmalloc、vmalloc以及类似的接口申请并返回。

2. 物理地址：DRAM空间的地址

3. 总线地址：系统mapping出来的地址空间

如上图中

A-->B-->C的过程表示设备寄存器的访问过程

X-->Y-->Z的过程表示DMA访问设备FIFO的过程

在某些系统（U-boot）DMA直接访问物理地址，但是在许多系统，是通过 IOMMU来实现物理地址的转换（Z-->Y）。

例如：通过提供虚拟地址X给dma_map_single()，dma_map_single()通过该IOMMU映射以及返回DMA 可以访问的总线地址Z，以及IOMMU映射Z到Y(系统RAM，例如DRAM空间地址)

Tips：

  1. 1）. 在Linux系统中虚拟地址通常存储在void *，物理地址通常存储在phys_addr_t或者resource_size_t。

    2）. 在某些平台上总线地址=物理地址，但通常不这么做，IOMMUs和主机网桥可以在物理地址和总线地址之间生成任意映射

    3）. 总线地址A通过内部桥转换为CPU物理地址B，Ioremap()实现物理地址B到虚拟地址C的映射，然后可以ioread32(C)来访问总线地址A

    4）.DMA地址应该使用dma_addr_t类型

4. DMA类型

这里说的DMA类型是从DMA地址的角度出发的，分为两类：

1. Coherent(consistent) DMA（一致性DMA）

2. Streaming DMA（流式DMA）

4.1.  Coherent DMA

Coherent DMA在访问DDR的时候不经过cpu cache。

Coherent DMA确保设备和CPU可以并行访问数据，并在不进行任何显式软件刷新的情况下看到彼此进行的更新。

Tips: 

  1. 1). 通常在驱动初始化时候map，在卸载或者结束的时候unmap
  2. 2). 如果要确保设备按顺序看到你的配置可以使用内存屏障来保证内存排序：
  3. e.g.
  4.          
    desc->word0 = address;
wmb(); 
desc->word1 = DESC_VALID;

    3). 在某些平台上，驱动程序可能需要刷新CPU写缓冲区（跟CPU架构有关，ARM cortex_a53 没有write buffer, ARMv9有write buffer），其方式与刷新PCI桥中的写缓冲区的方式大致相同

  5. 4.1.1 Coherent DMA使用

  6. 1）. 如果申请和映射的Coherent DMA域大于PAGE_SIZE（e.g. 4KB）使用如下接口：

  7.  dma_alloc_coherent。

  8. e.g. 

  9. /*a. alloc coherent */
dma_addr_t dma_handle;
cpu_addr = dma_alloc_coherent(dev, size, &dma_handle, gfp); 

@cpu_addr：CPU角度访问的虚拟地址，按PAGE_SIZE对齐，意味着大于等于申请大小
@dma_handle: DMA角度访问的物理地址，按PAGE_SIZE对齐，意味着大于等于申请大小


/*b. free coherent*/
dma_free_coherent(dev, size, cpu_addr, dma_handle)；

    注意：

    1.         alloc出来的coherent dma域按PAGE_SIZE对齐。

    2. 2）. 如果申请和映射的Coherent DMA域小于PAGE_SIZE（e.g. 4KB）使用如下接口：

    3. /*dma pool*/
/*a.Create a dma_pool*/
struct dma_pool *pool = dma_pool_create(name, dev, size, align, boundary);  
@size：必须对齐2

/*b.Allocate memory from a DMA pool*/
cpu_addr = dma_pool_alloc(pool, flags, &dma_handle)
@ flag：GFP_KERNEL

/*c.Free memory*/
dma_pool_free(pool, cpu_addr, dma_handle);

/*Destroy a dma_pool*/
dma_pool_destroy(pool)
调用之前先释放所有在dma pool中申请的内存

  10. 4.2.  Streaming DMA

  11. Streaming DMA在访问DDR的时候经cpu 过cache。

  12. Streaming DMA流式DMA通常在某一次的传输中使用，使用之后取消。

  13. 4.2.1. Streaming DMA使用

有两类型的streaming DMA映射：single、scatterlist

1）. Single streaming DMA

不使用HIGHMEM：

/*a. map a single region*/
dma_handle = dma_map_single(dev, addr, size, direction)
@dma_handle：DMA操作的物理地址
@addr：需要map的虚拟地址

/*b. unmap, DMA传输结束调用*/
dma_unmap_single(dev, dma_handle, size, direction);

  1. 使用HIGHMEM：

  2. dma_handle = dma_map_page(dev, page, offset, size, direction);
@offset: offset within the given page (unit by Byte)



dma_unmap_page(dev, dma_handle, size, direction);

    4.2.2. scatterlist streaming DMA

  3. /*map*/
count = dma_map_sg(dev, sglist, nents, direction)

/*unmap*/
dma_unmap_sg(dev, sglist, nents, direction);
@nents：与传入dma_map_sg()的nents相同，而不是返回值count。

    4.2.2. streaming DMA sync cache

  4. 如果需要使用streaming DMA region多次，并且在这之间需要访问数据，为了确保CPU和device看到的都是一致的，且是最新的，应该按照如下弄：（DMA传输后，CPU看到的是最新的）

  5. 读：

    第一：首先调用dma_map_{single,sg}()

    第二：在每个DMA传输后dma_sync_single_for_cpu(dev, dma_handle, size, direction);

    或者dma_sync_sg_for_cpu(dev, sglist, nents, direction); 

  6. 如果需要让DMA在CPU访问数据后得到的是最新的数据，可以按如下操作：

    在CPU访问完数据后调用dma_sync_single_for_device(dev, dma_handle, size, direction);

    或者dma_sync_sg_for_device(dev, sglist, nents, direction);

  7. 5. DMA方向

1）. DMA_BIDIRECTIONAL

如果不清楚数据的方向就用DMA_BIDIRECTIONAL，需要具体的平台支持，会影响性能。

读写内存之前都要sync一下。

2）. DMA_TO_DEVICE

数据从内存写道设备，在软件最后一次操作内存之后，在DMA传给设备之前，必须sync一下。

3）. DMA_FROM_DEVICE

数据从设备读到内存，在软件读内存之前必须sync一下。

4）. DMA_NONE

用于DEBUG

Tips:

streaming 映射需要指定方向，consistent映射已经隐式地设置了方向为DMA_BIDIRECTIONAL

  1. 6. DMA API

  2. 6.1. dma_alloc_coherent

    一致性内存是指设备或处理器的写操作可以被处理器或设备立即读取而不必担心缓存效果的内存。不过，您可能需要确保在告知之前刷新处理器的写入缓冲区（ARM cortex-a53没有写入缓冲区,ARMv9 有）。

  3. void *dma_alloc_coherent(struct device *dev, size_t size,dma_addr_t *dma_handle, gfp_t flag)

    void *dma_zalloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle, gfp_t flag) // 类似dma_alloc_coherent().返回空间清零。

    Void dma_free_coherent(struct device *dev, size_t size, void *cpu_addr，dma_addr_t dma_handle) // 释放申请的coherent内存

  4. 6.2. dma_pool*

  5. /* 用于需要申请很多小（小于PAGE_SIZE的大小）coherent内存*/

    struct dma_pool *dma_pool_create(const char *name, struct device *dev, size_t size, size_t align, size_t alloc);

    @name：用于辨别这个dma pool

    @aling：2的倍数对齐

    /*从dma pool中申请coherent内存*/

    void *dma_pool_alloc(struct dma_pool *pool, gfp_t gfp_flags, dma_addr_t *dma_handle);// 返回CPU的地址

    @dma_handle：接收DMA地址

    void *dma_pool_zalloc(struct dma_pool *pool, gfp_t mem_flags，dma_addr_t *handle)//类似dma_pool_alloc()

    /*把alloc的内存交回给dma pool*/

    void dma_pool_free(struct dma_pool *pool, void *vaddr,dma_addr_t addr);

    /*释放dma pool*/

    void dma_pool_destroy(struct dma_pool *pool);

    6.3 dma_set_mask*

    Int dma_set_mask_and_coherent(struct device *dev, u64 mask) //检查并更新streaming & coherent DMA的地址位宽

    @0 return 表示成功

    Int dma_set_mask(struct device *dev, u64 mask)//检查并更新streaming  DMA的地址位宽

    @0 return 表示成功

    Int dma_set_coherent_mask(struct device *dev, u64 mask) // 检查并更新coherent DMA的地址位宽

    @0 return 表示成功

  6. if (dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32))) {
dev_warn(dev, "mydev: No suitable DMA available\n");
goto ignore_this_device;
}

/*有时候设置64位掩码可能失败，不是因为64位寻址不支持，而是因为内核觉得32位更有效。这个时候对于64位设备可以这么设置：*/

if (!dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64))) 
using_dac = 1;
consistent_using_dac = 1;
} else if (!dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32))) {
using_dac = 0;
consistent_using_dac = 0;
} else {
dev_warn(dev, "mydev: No suitable DMA available\n"); 
goto ignore_this_device;
}

    6.4 dma_map_single

    dma_addr_t dma_map_single(struct device *dev, void *cpu_addr, size_t size, enum dma_data_direction direction)

    void dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction)

    //用此接口必须保证虚拟地址在物理地址上也是连续的，例如kmalloc出来的虚拟地址

    @direction：

    DMA_NONE，

    DMA_TO_DEVICE，

    DMA_FROM_DEVICE，

    DMA_BIDIRECTIONAL

  7. struct device *dev = &my_dev->dev;
dma_addr_t dma_handle;
void *addr = buffer->ptr;
size_t size = buffer->len;
dma_handle = dma_map_single(dev, addr, size, direction);
if (dma_mapping_error(dev, dma_handle)) {
goto map_error_handling;
}
/*调用dma_mapping_error()来检查dma_map_single()是否失败，但是并不是所有的DMA实现都支持dma_mapping_error()*/

    6.6 dma_map_sg

    int i, count = dma_map_sg(dev, sglist, nents, direction);
struct scatterlist *sg;
for_each_sg(sglist, sg, count, i) {
hw_address[i] = sg_dma_address(sg);
hw_len[i] = sg_dma_len(sg);
}
@nents：sglist 的entries个数
... 
dma_unmap_sg(dev, sglist, nents, direction);
@nents：与传入dma_map_sg()的nents相同，而不是返回值count。

    6.7 dma_map_page

    dma_addr_t  dma_map_page(struct device *dev, struct page *page, unsigned long offset, size_t size,enum dma_data_direction direction)

    void dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size, enum dma_data_direction direction)

    int dma_get_cache_alignment(void)

    //返回处理器缓存对齐。这是映射内存或进行部分刷新时必须遵守的绝对最小对齐*和*宽度

    void dma_cache_sync(struct device *dev, void *vaddr, size_t size, enum dma_data_direction direction)

    /sync部分内存，且这个内存是由dma_alloc_noncoherent()申请的。

    struct device *dev = &my_dev->dev;
dma_addr_t dma_handle;
struct page *page = buffer->page;
unsigned long offset = buffer->offset;
size_t size = buffer->len;
dma_handle = dma_map_page(dev, page, offset, size, direction);
if (dma_mapping_error(dev, dma_handle)) {
/*
* reduce current DMA mapping usage,
* delay and try again later or
* reset driver. 
*/
goto map_error_handling;
}
...
dma_unmap_page(dev, dma_handle, size, direction);

    6.8 dma_sync_single_for*

    void dma_sync_single_for_cpu(dev, dma_handle, size, direction)// 在DMA把数据从device搬到DDR后，在cpu 访问DDR之前调用，目的是为了让cpu看到最新的数据

    void dma_sync_single_for_device(dev, dma_handle, size, direction)// 在DMA把数据从DDR搬到device之前调用，目的是为了让device看到最新的数据

    my_card_setup_receive_buffer(struct my_card *cp, char *buffer, int len)
{
dma_addr_t mapping;
mapping = dma_map_single(cp->dev, buffer, len, DMA_FROM_DEVICE);
if (dma_mapping_error(cp->dev, mapping)) {
/*
* reduce current DMA mapping usage,
* delay and try again later or
* reset driver.
*/

goto map_error_handling;
}
cp->rx_buf = buffer;
cp->rx_len = len;
cp->rx_dma = mapping;
give_rx_buf_to_card(cp); 

}
...
my_card_interrupt_handler(int irq, void *devid, struct pt_regs *regs)
{
struct my_card *cp = devid;
...
if (read_card_status(cp) == RX_BUF_TRANSFERRED) {
struct my_card_header *hp;
/* Examine the header to see if we wish 
* to accept the data.  But synchronize
* the DMA transfer with the CPU first
* so that we see updated contents. 
*/
dma_sync_single_for_cpu(&cp->dev, cp->rx_dma, cp->rx_len,DMA_FROM_DEVICE); 
/* Now it is safe to examine the buffer. */
hp = (struct my_card_header *) cp->rx_buf;
if (header_is_ok(hp)) { 
dma_unmap_single(&cp->dev, cp->rx_dma, cp->rx_len, DMA_FROM_DEVICE); 
pass_to_upper_layers(cp->rx_buf);
make_and_setup_new_rx_buf(cp);
}  else {
/* CPU should not write to
* DMA_FROM_DEVICE-mapped area,
* so dma_sync_single_for_device() is
* not needed here. It would be required
* for DMA_BIDIRECTIONAL mapping if
* the memory was modified. 
*/
give_rx_buf_to_card(cp);
}

}

    6.9 dma_request_chan

    查找并返回与该设备关联的名为name的DMA通道，这种关联是通过设备树来实现的。

    通过该接口申请的channel直到使用dma_release_channel()释放为止都是独占该通道的。

    struct dma_chan *dma_request_chan(struct device *dev, const char *name)

    6.10 dmaengine_slave_config

    传递指定的信息给DMA驱动，这些信息大部分已经集成在struct dma_slave_config中。

    如果需要传递更多的信息（DMA控制器需要更多的信息），可以将struct dma_slave_config内嵌到控制器的指定结构体中，这种就可以传递更多参数了。

    int dmaengine_slave_config(struct dma_chan *chan, struct dma_slave_config *config)

    2.11 dmaengine_prep_slave_sg

    散列表的形式传输数据，在调用dmaengine_prep_slave_sg()之前需要使用散列表的映射，并且必须在DMA操作完成之前不能释放。如果需要同步，请调用dma_sync_*_for_*()。

    struct dma_async_tx_descriptor *dmaengine_prep_slave_sg(

    struct dma_chan *chan, struct scatterlist *sgl,

    unsigned int sg_len, enum dma_data_direction direction,

    unsigned long flags);

    nr_sg = dma_map_sg(chan->device->dev, sgl, sg_len);
if (nr_sg == 0)
/* error */
desc = dmaengine_prep_slave_sg(chan, sgl, nr_sg, direction, flags);

注意：
一旦获取到描述符desc ，就必须尽快submit，因为有些DMA engine会在获取desc后持有spinlock。

    6.12 dmaengine_prep_dma_cyclic

    循环模式传输数据

    struct dma_async_tx_descriptor *dmaengine_prep_dma_cyclic(

    struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len,

    size_t period_len, enum dma_data_direction direction);

    6.13 dmaengine_prep_interleaved_dma

    交叉模式传输数据

    struct dma_async_tx_descriptor *dmaengine_prep_interleaved_dma(

    struct dma_chan *chan, struct dma_interleaved_template *xt,

    unsigned long flags);

  8. 6.14 dmaengine_submit

    把描述符添加到挂起的队列中来。

    dma_cookie_t dmaengine_submit(struct dma_async_tx_descriptor *desc)

    6.15 dma_async_issue_pending

    激活挂起队列中的事务，一旦一个事务完成，队列中的下一个事务就开启，如果设置了回调，还会调用回调通知完成。

    void dma_async_issue_pending(struct dma_chan *chan)

  9. 6.16 dmaengine_terminate*

    终止传输，会丢失还未传输的数据

    int dmaengine_terminate_sync(struct dma_chan *chan)
    int dmaengine_terminate_async(struct dma_chan *chan)
    int dmaengine_terminate_all(struct dma_chan *chan) /* DEPRECATED */

    6.17 dmaengine_pause

  10. 暂停channel传输，不会导致丢失数据

    int dmaengine_pause(struct dma_chan *chan)

    6.18 dmaengine_resume

    唤醒当前暂停的DMA通道

    int dmaengine_resume(struct dma_chan *chan)

    6.19 dma_async_is_tx_complete

    检查channel的状态，例如传输是否完成。

    enum dma_status dma_async_is_tx_complete(struct dma_chan *chan,

    dma_cookie_t cookie, dma_cookie_t *last, dma_cookie_t *used)

    6.20 dmaengine_synchronize

    Synchronize the termination of the DMA channel to the current context.

    该函数应该在调用dmaengine_terminate_async()后使用，这个函数将等待传输完成并且调用回调完成。

    void dmaengine_synchronize(struct dma_chan *chan)

    7. DMA engine usage

  11. The slave DMA usage consists of following steps:
    1.Allocate a DMA slave channel
    2.Set slave and controller specific parameters
    3.Get a descriptor for transaction
    4.Submit the transaction
    5.Issue pending requests and wait for callback notification

1.Allocate a DMA slave channel

struct dma_chan *dma_request_chan(struct device *dev, const char *name)

查找并返回与该设备关联的名为name的DMA通道，这种关联是通过设备树来实现的。

通过该接口申请的channel直到使用dma_release_channel()释放为止都是独占该通道的。

2.Set slave and controller specific parameters

int dmaengine_slave_config(struct dma_chan *chan, struct dma_slave_config *config)

传递指定的信息给DMA驱动，这些信息大部分已经集成在struct dma_slave_config中。

如果需要传递更多的信息（DMA控制器需要更多的信息），可以将struct dma_slave_config内嵌到控制器的指定结构体中，这种就可以传递更多参数了。

3.Get a descriptor for transaction

DMA Engine支持多种从机传输模式。

1）. single传输

struct dma_async_tx_descriptor *dmaengine_prep_slave_single(

struct dma_chan *chan, dma_addr_t buf, size_t len, enum dma_transfer_direction dir, unsigned long flags)

2）. scatterlist传输

struct dma_async_tx_descriptor *dmaengine_prep_slave_sg(

struct dma_chan *chan, struct scatterlist *sgl,

unsigned int sg_len, enum dma_data_direction direction,

unsigned long flags);

如果使用散列表的形式，在调用dmaengine_prep_slave_sg()之前需要使用散列表的映射，并且必须在DMA操作完成之前不能释放。如果需要同步，请调用dma_sync_*_for_*()。通常的操作如下：

nr_sg = dma_map_sg(chan->device->dev, sgl, sg_len);

if (nr_sg == 0)

/* error */

desc = dmaengine_prep_slave_sg(chan, sgl, nr_sg, direction, flags);

注意：

一旦获取到描述符desc ，就必须尽快submit，因为有些DMA engine会在获取desc后持有spinlock。

3）. dma_cyclic传输

struct dma_async_tx_descriptor *dmaengine_prep_dma_cyclic(

struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len,

size_t period_len, enum dma_data_direction direction);

4）. interleaved_dma传输

struct dma_async_tx_descriptor *dmaengine_prep_interleaved_dma(

struct dma_chan *chan, struct dma_interleaved_template *xt,

unsigned long flags);

4. Submit the transaction

一旦desc一获取以及回调信息添加了，就必须将它到达DMA engine驱动队列中来。

dma_cookie_t dmaengine_submit(struct dma_async_tx_descriptor *desc)

dmaengine_submit()不会开启一个DMA的操作，它仅仅是把它添加到挂起的队列中来。

5. Issue pending DMA requests and wait for callback notification

void dma_async_issue_pending(struct dma_chan *chan);

通过dma_async_issue_pending()来激活挂起队列中的事务，一旦一个事务完成，队列中的下一个事务就开启，如果设置了回调，还会调用回调通知完成。

ZHIK
关注
  • 5
    点赞
  • 踩
  • 61
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux DMA子系统（1）：DMA Engine体系结构
MisakiMe1的博客
09-21 2161
DMA（direct memory access），即不经过CPU，直接访问内存。因为不管是memory和memory之间还是memory和设备之间进行数据搬运，对CPU来说都是枯燥乏味的，且非常浪费CPU的时间，造成CPU无法及时处理一些实时的事件。因此，为了解放CPU，可以让CPU在搬运数据的这段时间可以去做更有意义的事情，工程师们就设计出来一种专门用来搬运数据的器件，即DMA控制器，让它来协助CPU进行数据搬运工作，下图是DMA的硬件示意图。
Linux DMA子系统（3）：DMA设备驱动（consumer）
MisakiMe1的博客
09-22 2543
上文从DMA控制器驱动的角度去分析了DMA Engine，即从provider的角度，本文将从需要使用DMA传输的设备驱动的角度，即consumer的角度去分析DMA Engine，看看DMA Engine为client driver提供了哪些功能和API。
Linux之DMA详解_linux dma(1)
2401_83621603的博客
04-26 817
目前DMA控制器都是可编程的大规模集成芯片，是内存储器和外部设备之间进行高速数据传输时的硬件控制电路，是一种实现直接数据传送的专用处理器。一个DMA控制器，实际闪是采用DMA方式的外围设备和系统总线之间的接口电路，这个接口电路是在中断接口的基础上再加上DMA机构组成。习惯上将DMA方式的接口电路称为DMA控制器（也就是DMA控制器其实就一个硬件接口电路）。内存地址计数器：用于存放内存中要交换的数据的地址字计数器：用于记录传送数据块的长度数据缓冲寄存器：用于暂存每次传送的数据DMA请求标志。
Linux 网络子系统中DMA机制的实现_linuxdma使用
最新发布
2401_85013800的博客
05-15 972
在I/O准备阶段，程序轮询方式的CPU一直在查询等待，而中断方式的CPU可以继续执行现行程序，但是当I/O准备就绪，设备向CPU发出中断请求，CPU响应以实现数据的传输，这个过程会占用CPU一段时间，而且这段时间比使用程序轮询方式的CPU传输数据的时间还要长，因为CPU除了传输数据还要做一些准备工作，如把CPU寄存器中的数据都转移到栈中。总之，在同样的时间内，DMA方式下CPU执行现行程序的时间最长，即CPU的效率最高。的作用是申请一块DMA可使用的内存，它的返回值是这块内存的虚拟地址，赋值给。
Linux DMA 简介
JiMoKuangXiangQu的专栏
07-14 2326
Linux DMA
Linux驱动开发基础之DMA
ZZZZZ1113的博客
06-10 2587
本文对于DMA在Linux驱动中的相关运用进行了简单的介绍，并且也提到了一些DMA的相关概念以函数。对于DMA的传输过程进行了详细的介绍，并通过相关的代码进行了实现。下文所使用的硬件设备是基于ARM Cortex-A9处理器的Exynos-tiny4412开发板所实现的，所使用的内核版本为Linux-3.5提示：以下是本篇文章正文内容，下面案例可供参考。
dma_alloc_coherent的2种内存分配方式
kunkliu的博客
04-01 779
rmem_dma_ops.device_init() = rmem_dma_device_init 将reserved-memory内存一致性建页表（memremap(MEMREMAP_WC))并绑定到dev->dma_mem中。dma_alloc_coherent(dev, GFP_ATOMIC) = pci_alloc_consistent 从预留的cma_pool分配，不可被中断。of_reserved_mem_device_init （要求reserved内存shared-dma-pool）
Linux驱动开发---内存与I/O
tpmamba的博客
12-02 471
内存与I/O MMU 功能 1.1 虚拟地址和物理地址的映射； 1.2 内存访问的权限保护； 1.3 Cache缓存控制。 相关概念 2.1 TLB：转化旁路缓存。缓存虚拟地址与物理地址的转换关系，也称“快表”。 2.2 TTW：转化表漫游。在TLB中没有所需的虚拟地址与物理地址的转换关系时，会去主存储器转换表中获取相应关系，并缓存到TLB中。 2.3 DTLB/ITLB：数据TLB/指令TLB。 2.4 C：高速缓存。 2.5 B：缓冲。 CPU数据访问流程 Linux内存管理 内存空间
没有IOMMU的DMA操作
Peter的专栏
03-28 2219
我们知道DMA通常需要访问连续的物理内存，除非设备支持iommu，当设备不支持iommu的话可以用以下方式：在内核启动时为设备保留内存将MMU内嵌到设备中，如GPU这里GPU MMU的方式...
linux dma 应用层接口,linux DMA接口知识点详解
weixin_34642354的博客
05-14 1347
1.两种DMA映射类型1.1. 一致性DMA映射(Consistent DMA mappings )主要用于映射长时间使用的区域。CPU和DMA controller不需要考虑cache的影响。这里的consistent实际上是coherent的概念，不能保证consistent，也就是说需要memory barrier来保证memory order。1.2 流式DMA映射(streaming D...
LINUX网络子系统中DMA机制的实现-转
llxx1234的博客
07-13 160
linux DMA机制
linux DMA子系统.pdf
07-24
DMA是Direct Memory Access的缩写，顾名思义，就是绕开CPU直接访问memory的意思。在计算机中，相比CPU，memory和外设的速度是非常慢的，因而在memory和memory（或者memory和设备）之间搬运数据，非常浪费CPU的时间，...
PCIe-DMA多通道/高性能/超低延时/超低抖动视频采集显示，V4L2驱动
04-20
基于PCI ExpressIntegrated Block，Multi-Channel PCIe QDMA Subsystem实现了使用DMA地址队列的独立...对于多路视频采集与显示子系统，在上位机可以使用标准的Linux V4L2视频驱动，实现多路视频信号的采集和显示工作。
vmtools-linux.iso
03-16
DMA setup: [ 确定 ] Guest operating system daemon: [ 确定 ] The configuration of VMware Tools 5.5.1 build-19175 for Linux for this running kernel completed successfully. You must restart your X ...
Linux-ALSA声卡驱动原理分析-设备打开过程和数据流程
12-31
5. **数据写入流程图**数据写入流程始于应用程序调用write()函数，将音频数据送入ALSA的PCM子系统。PCM子系统会将数据分块（frames）并放入内部缓冲区。当缓冲区有足够的空间时，驱动程序会将数据写入硬件的DMA...
Linux下PCI设备流式DMA驱动开发.pdf
09-06
* 设备文件的访问通过 I/O 子系统向内核中的其他部分提供统一的标准设备接口，包含在 include/linux/fs.h 中的数据结构 file_operations。 * 设备驱动程序可以看成是 Linux 内核与外部设备之间的接口。 * PCI 驱动...
linux下的DMA详解！
m0_74282605的博客
07-24 688
当一个外设在 DMA 通道 0，1，2，3 上 请求使用总线，从属 DMA 控制器就发送 HLDREQ，但这个信号是发往 主 DMA 控制 器上而不是 CPU 上的。应该懂得，尽管 CPU 在 DMA 需要的时候，总是把总线释放给 DMA，这个动作在应用程序和操作系统里面是不可见的，只是当 DMA 是活动的时候，CPU 执行指令的时间会有一点点的差别。因此，处理器会不时的探测外围设备的状态，探测 DMA 芯片中的寄存器，或者，当 DMA 传输结束的时候，从外围设备接收中断信号以确定 情况。
Linux设备驱动开发--- DMA
qq_41683305的博客
05-24 4137
文章目录1 设置DMA映射缓存一致性和DMADMA映射一致映射流式DMA映射2 完成的概念3 DMA引擎API分配DMA从通道设置从设备和控制器指定参数 DMA是计算机系统的一项功能，它允许设备在没有CPU的干预的情况下访问系统主存储器RAM，使CPU完成其他任务。 DMA控制器是负责DMA管理的外设，在现代处理器和微控制器中都能发现它。DMA功能用于执行内存读写和写入操作而不占用CPU周期。当需要传输数据块时，处理器向DMA控制器提供源地址和目标地址以及总字节数。然后，DMA控制器会自动将数据从源传输到目
嵌入式Linux系统中DMA子系统实现
嵌入式技术开发
03-18 105
以散列表的形式传输数据，在调用dmaengine_prep_slave_sg()之前需要使用散列表的映射，并且必须在DMA操作完成之前不能释放。是DMA子系统的核心，为DMA Device Driver提供DMA设备注册的API，为DMA调用者（Device Driver）提供屏蔽DMA设备实现细节的统一接口API；有些CPU会设计通用DMA设备给各外设使用，例如嵌入式CPU的一些低速外设，自身没有设计DMA，为了数据传输的高效，则需要借用通用DMA设备。
Linux 内核的 DMA 子系统， DMA 的工作原理和相关 API
06-07
Linux 内核的 DMA 子系统是一种提供直接内存访问（Direct Memory Access，DMA）功能的机制，可以实现设备之间的数据传输，减少 CPU 的负担，提高系统性能。DMA 子系统包括了 DMA 控制器、DMA 缓冲区管理、中断处理等多个部分，其中比较重要的 API 包括以下几个： 1. dma_alloc_coherent()：分配 DMA 缓冲区的 API，用于分配一段连续的物理内存，用于 DMA 数据传输。 2. dma_map_single() 和 dma_unmap_single()：将一个单独的 DMA 缓冲区映射到物理地址空间，并在 DMA 操作完成后释放映射。 3. dma_sync_single_for_cpu() 和 dma_sync_single_for_device()：同步 DMA 缓冲区和物理地址空间之间的数据，以确保数据的正确性和一致性。 4. dmaengine_submit() 和 dma_async_issue_pending()：提交 DMA 操作请求，启动 DMA 数据传输。 5. dmaengine_terminate_all()：停止所有正在进行的 DMA 操作。 DMA 的工作原理是通过 DMA 控制器实现的。控制器可以直接访问系统总线，将数据从设备中读取到 DMA 缓冲区中，或者从 DMA 缓冲区中将数据传输到设备中。在进行 DMA 操作时，需要设置 DMA 控制器的寄存器，包括源地址、目的地址、传输长度等信息。DMA 控制器会负责处理数据传输的过程，传输完成后会产生中断信号通知 CPU。 需要注意的是，Linux 内核的 DMA 子系统需要硬件支持，即需要设备具有 DMA 控制器接口。如果设备没有 DMA 控制器接口，也可以通过 CPU 进行数据传输，但效率会降低。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值