学习笔记 --- S3C2440 DMA操作原理

最新推荐文章于 2025-05-25 10:25:39 发布
最新推荐文章于 2025-05-25 10:25:39 发布
阅读量1.3k 收藏 5
点赞数
CC 4.0 BY-SA版权
分类专栏： LINUX学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wangshuchangfrank/article/details/22800809
本文介绍S3C2440处理器中DMA控制器的使用方法，包括通过DMA进行内存拷贝的驱动程序设计及利用DMA进行音频播放的技术细节。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >


DMA（Direct Memory Access，直接内存访问）是一种不经过CPU而直接从内存存取数据的数据交换模式。在需要进行大量数据交换的场合，用好DMA，可以大大提高系统的性能，因为DMA操作几乎不占用CPU资源。s3c2440提供了4个通道的DMA

每个DMA通道能处理下面四种情况的数据传输：
（1）源器件和目的器件都在系统总线 APB
（2）源器件在系统总线，目的器件在外设总线
（3）源器件在外设总线，目的器件在系统总线
（4）源器件和目的器件都在外设总线 AHB

下面的DMA驱动程序使用的是第四种，内存属于AHB总线上的，我们打算在内存中开辟两个连续空间，分别作为源和目的。我们用两个方法将源中的数据写到目的中，一种方法是让cpu去做，另外一种方法是让DMA去做：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/poll.h>
#include <linux/dma-mapping.h>

#define MEM_CPY_NO_DMA  0
#define MEM_CPY_DMA     1

#define BUF_SIZE  (512*1024)

#define DMA0_BASE_ADDR  0x4B000000
#define DMA1_BASE_ADDR  0x4B000040
#define DMA2_BASE_ADDR  0x4B000080
#define DMA3_BASE_ADDR  0x4B0000C0

struct s3c_dma_regs {
 unsigned long disrc;
 unsigned long disrcc;
 unsigned long didst;
 unsigned long didstc;
 unsigned long dcon;
 unsigned long dstat;
 unsigned long dcsrc;
 unsigned long dcdst;
 unsigned long dmasktrig;
};


static int major = 0;

static char *src;
static u32 src_phys;

static char *dst;
static u32 dst_phys;

static struct class *cls;

static volatile struct s3c_dma_regs *dma_regs;

static DECLARE_WAIT_QUEUE_HEAD(dma_waitq);
/* 中断事件标志, 中断服务程序将它置1，ioctl将它清0 */
static volatile int ev_dma = 0;

static int s3c_dma_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
 int i;

 memset(src, 0xAA, BUF_SIZE);
 memset(dst, 0x55, BUF_SIZE);
 
 switch (cmd)
 {
                //这是非DMA模式
  case MEM_CPY_NO_DMA :
  {
   for (i = 0; i < BUF_SIZE; i++)
    dst[i] = src[i];  //CPU直接将源拷贝到目的
   if (memcmp(src, dst, BUF_SIZE) == 0)
   {
    printk("MEM_CPY_NO_DMA OK\n");
   }
   else
   {
    printk("MEM_CPY_DMA ERROR\n");
   }
   break;
  }

                //这是DMA模式
  case MEM_CPY_DMA :
  {
   ev_dma = 0;
   
   /* 把源,目的,长度告诉DMA */
                        /* 关于下面寄存器的具体情况，我们在注释3里面来详细讲一下 */
   dma_regs->disrc      = src_phys;        /* 源的物理地址 */
   dma_regs->disrcc     = (0<<1) | (0<<0); /* 源位于AHB总线, 源地址递增 */
   dma_regs->didst      = dst_phys;        /* 目的的物理地址 */
   dma_regs->didstc     = (0<<2) | (0<<1) | (0<<0); /* 目的位于AHB总线, 目的地址递增 */
   dma_regs->dcon       = (1<<30)|(1<<29)|(0<<28)|(1<<27)|(0<<23)|(0<<20)|(BUF_SIZE<<0);  /* AHP总线同步，使能中断,全速传输（BIT27）,软件触发（BIT23）, */

   /* 启动DMA */
   dma_regs->dmasktrig  = (1<<1) | (1<<0);  //打开通道，软件启动

   /* 如何知道DMA什么时候完成? */
   /* 休眠 */
   wait_event_interruptible(dma_waitq, ev_dma);

   if (memcmp(src, dst, BUF_SIZE) == 0)
   {
    printk("MEM_CPY_DMA OK\n");
   }
   else
   {
    printk("MEM_CPY_DMA ERROR\n");
   }
   
   break;
  }
 }

 return 0;
}

static struct file_operations dma_fops = {
 .owner  = THIS_MODULE,
 .ioctl  = s3c_dma_ioctl,
};

static irqreturn_t s3c_dma_irq(int irq, void *devid)
{
 /* 唤醒 */
 ev_dma = 1;
    wake_up_interruptible(&dma_waitq);   /* 唤醒休眠的进程 */
 return IRQ_HANDLED;
}

static int s3c_dma_init(void)
{
         /* 这里注册一个中断，当DMA数据传输完毕之后会发生此中断 */
 if (request_irq(IRQ_DMA3, s3c_dma_irq, 0, "s3c_dma", 1))
 {
  printk("can't request_irq for DMA\n");
  return -EBUSY;
 }
 
 /* 分配SRC, DST对应的缓冲区：之前我们知道在内核中开辟空间可以用kmalloc函数，这里却用了dma_alloc_writecombine，这是为什么呢？这是因为kmalloc开辟的空间其逻辑地址虽然是连续的，但是其实际的物理地址可能不是连续的。而DMA传输数据时，要求物理地址是连续的，dma_alloc_writecombine就满足这一点，这个函数的原型是：dma_alloc_writecombine(struct device *dev, size_t size, dma_addr_t *handle, gfp_t gfp)其中size代表开辟的空间的大小，handle代表开辟的空间的物理地址，返回值是开辟的空间的逻辑地址*/
 src = dma_alloc_writecombine(NULL, BUF_SIZE, &src_phys, GFP_KERNEL);//源
 if (NULL == src)
 {
  printk("can't alloc buffer for src\n");
  free_irq(IRQ_DMA3, 1);
  return -ENOMEM;
 }
 
 dst = dma_alloc_writecombine(NULL, BUF_SIZE, &dst_phys, GFP_KERNEL);//目的
 if (NULL == dst)
 {
  free_irq(IRQ_DMA3, 1);
  dma_free_writecombine(NULL, BUF_SIZE, src, src_phys);
  printk("can't alloc buffer for dst\n");
  return -ENOMEM;
 }

 major = register_chrdev(0, "s3c_dma", &dma_fops);//注册字符设备

 /* 为了自动创建设备节点 */
 cls = class_create(THIS_MODULE, "s3c_dma");
 class_device_create(cls, NULL, MKDEV(major, 0), NULL, "dma"); /* /dev/dma */

 dma_regs = ioremap(DMA3_BASE_ADDR, sizeof(struct s3c_dma_regs));//这边是将DMA控制寄存器映射到内核空间
  
 return 0;
}

static void s3c_dma_exit(void)
{
 iounmap(dma_regs);
 class_device_destroy(cls, MKDEV(major, 0));
 class_destroy(cls);
 unregister_chrdev(major, "s3c_dma");
 dma_free_writecombine(NULL, BUF_SIZE, src, src_phys);
 dma_free_writecombine(NULL, BUF_SIZE, dst, dst_phys); 
 free_irq(IRQ_DMA3, 1);
}

module_init(s3c_dma_init);
module_exit(s3c_dma_exit);

MODULE_LICENSE("GPL");

测试程序：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <string.h>

/* ./dma_test nodma
 * ./dma_test dma
 */
#define MEM_CPY_NO_DMA  0
#define MEM_CPY_DMA     1

void print_usage(char *name)
{
 printf("Usage:\n");
 printf("%s <nodma | dma>\n", name);
}


int main(int argc, char **argv)
{
 int fd;
 
  if (argc != 2)
 {
  print_usage(argv[0]);
  return -1;
 }

 fd = open("/dev/dma", O_RDWR);
 if (fd < 0)
 {
  printf("can't open /dev/dma\n");
  return -1;
 }

 if (strcmp(argv[1], "nodma") == 0)
 {
  while (1)
  {
   ioctl(fd, MEM_CPY_NO_DMA);
  }
 }
 else if (strcmp(argv[1], "dma") == 0)
 {
  while (1)
  {
   ioctl(fd, MEM_CPY_DMA);
  }
 }
 else
 {
  print_usage(argv[0]);
  return -1;
 }
 return 0;  
}
测试方法：

# insmod dma.ko      //加载驱动
# cat /proc/interrupts //查看中断
           CPU0
 30:      52318         s3c  S3C2410 Timer Tick
 33:          0         s3c  s3c-mci
 34:          0         s3c  I2SSDI
 35:          0         s3c  I2SSDO
 36:          0         s3c  s3c_dma
 37:         12         s3c  s3c-mci
 42:          0         s3c  ohci_hcd:usb1
 43:          0         s3c  s3c2440-i2c
 51:       2725     s3c-ext  eth0
 60:          0     s3c-ext  s3c-mci
 70:         97   s3c-uart0  s3c2440-uart
 71:        100   s3c-uart0  s3c2440-uart
 83:          0           -  s3c2410-wdt
Err:          0

# ls /dev/dma     //查看设备
/dev/dma

# ./dmatest       //如此就会打印用法
Usage:
./dmatest <nodma | dma>

# ./dmatest dma     //以DMA方式拷贝，CPU可以做其他事情
MEM_CPY_DMA OK
MEM_CPY_DMA OK
MEM_CPY_DMA OK
MEM_CPY_DMA OK
MEM_CPY_DMA OK
MEM_CPY_DMA OK
MEM_CPY_DMA OK

# ./dmatest nodma     //CPU拷贝，各种竞争CPU

MEM_CPY_NO_DMA

MEM_CPY_NO_DMA

MEM_CPY_NO_DMA


————————————————————————————————————————————————————————————————————————————

熟悉了DMA与寄存器配置后， 下面来看下裸奔S3C2440的时候如何使用DMA来播放音频:

转自：http://blog.youkuaiyun.com/zhaocj/article/details/5583935

下面我们就用DMA的方式来实现音频的播放。由于是用DMA的方式，因此在播放的过程中不占用系统资源，我们可以很容易的实现声音的各种操作而丝毫不影响播放的效果，如音量的提高和降低、静音、暂停等。在这里，还需要强调一点，利用DMA传输数据，一次最多可以传输的字节大小为：DSZ×TSZ×TC，DSZ表示的是数据大小（字节、半字还是字，即是1、2还是4），TSZ表示的是传输大小（单元传输还是突发传输，即1还是4），TC表示传输计数值（即寄存器DCONn的低20位存放的数据），因此如果需要传输的字节大小超出了这三个参数乘积的大小，则还要进一步处理，在我们给出的程序中，我们就考虑了这方面的问题。下面就是具体的程序，其中我们是利用UART来实现音频信号的播出、停止、暂停、静音、音量的提高和降低的。

……   ……
//一段纯音频数据数组
unsigned char music[] = {
0xF9, 0xFF, 0xF5, 0xFF, 0xF8, 0xFF, 0xF8, 0xFF, 0xF6, 0xFF, 0xFF, 0xFF, 0xF5, 0xFF, 0xF9, 0xFF,
0xF6, 0xFF, 0xF6, 0xFF, 0xFA, 0xFF, 0xFD, 0xFF, 0xFA, 0xFF, 0xFA, 0xFF, 0xF7, 0xFF, 0xF6, 0xFF,
……   ……
}；
 
int result;
int remainder;
char flag;
char cmd;
char play_state;
 
void __irq uartISR(void)
{
       char ch;
       rSUBSRCPND |= 0x1;
       rSRCPND |= 0x1<<28;
       rINTPND |= 0x1<<28;
       ch=rURXH0;
      
       switch(ch)
       {
              case 0x55:             //播放
                     cmd = 1;
                     break;
              case 0x1:               //静音
                     cmd = 0x11;
                     break;
              case 0x2:               //音量提高
                     cmd = 0x12;
                     break;
              case 0x3:               //音量降低
                     cmd = 0x13;
                     break;
              case 0x66:             //停止
                     cmd = 0x2;
                     break;
              case 0x77:             //暂停
                     cmd = 0x3;
                     break;
       }           
       rUTXH0=ch;
}
 
//放音子程序
void playsound(unsigned char *buffer,int length)
{    
       //用于计算音频数据的长度是否超过DMA所能传输的字节数范围
       //这里音频数据的通道位数为16位，因此需要length除以2
       remainder = (length>>1) & 0xfffff;            //余数
       result = (length>>1) / 0x100000;                //商
      
       play_state = 1;                     //置播放标志
 
       rGPBDAT = rGPBDAT & ~(L3M|L3C|L3D) |(L3M|L3C);
 
       //配置1341，详细讲解请看上一篇文章
       WriteL3(0x14 + 2,1);    
       WriteL3(0x60,0);         
      
       WriteL3(0x14 + 2,1);    
       WriteL3(0x10,0);  
      
       WriteL3(0x14 + 2,1);    
       WriteL3(0xc1,0);   
      
       //配置IIS
       rIISPSR  = 3<<5|3;
       rIISCON  = (1<<5)|(0<<4)|(0<<3)|(1<<2)|(1<<1);    //发送IIS的DMA使能
       rIISMOD  = (0<<9)|(0<<8)|(2<<6)|(0<<5)|(0<<4)|(1<<3)|(1<<2)|(1<<0);     
       rIISFCON = (1<<15)|(1<<13); //发送FIFO为DMA
      
       //配置DMA
       rDISRC2 = (U32)buffer;                     //DMA的源基址为音频数据数组的首地址
       rDISRCC2 = (0<<1)|(0<<0);        //AHB，源地址递增
       rDIDST2 = (U32)IISFIFO;          //DMA的目的基址为IIS的FIFO
       rDIDSTC2 = (0<<2)| (1<<1)|(1<<0);          //当传输计数值为0时中断，APB，目的地址不变
       if (result == 0)                     //所传输的字节数没有超出DMA的最大传输范围
       {
              flag = 0;                //清标志，表示没有超出范围，进入DMA中断后结束DMA操作
              //握手模式，PCLK同步，传输计数中断，单元传输，单步服务模式，IISSDO，
              //硬件请求模式，非自动重载，半字，
              rDCON2 = (1<<31) | (0<<30) | (1<<29) | (0<<28) | (0<<27) | (0<<24) | (1<<23) | (1<<22) | (1<<20) | (remainder);
      
       }
       else                       //所传输的字节数超出了DMA的最大传输范围
       {
              flag = 1;                //置标志，表示超出范围
              rDCON2 = (1<<31) | (0<<30) | (1<<29) | (0<<28) | (0<<27) | (0<<24) | (1<<23) | (1<<22) | (1<<20) | (0xfffff);
       }
       rDMASKTRIG2=(0<<2)|(1<<1)|0;      //不停止DMA，DMA通道开启，非软件触发 
      
       //启动IIS  
       rIISCON |= 0x1;
}
 
 
void __irq DMA_end(void)
{
       rSRCPND |= 0x1<<19;
       rINTPND |= 0x1<<19;
      
       if (flag == 0)                //DMA传输完毕
       {
       rIISCON = 0x0;            //关闭IIS
	rIISFCON = 0x0;          //清IIS的FIFO
              rDMASKTRIG2=1<<2;               //停止DMA
              play_state = 0;                     //清播放标志
}
else                       //DMA没有传输完毕，继续传输
{
       result --;         //商递减
       rDISRC2 += 0x200000;               //DMA源基址递增。因为传输的数据是半字，所以这里递增0x200000
       if (result == 0 )             //只剩下余数部分需要传输
              {
              rDCON2=(rDCON2&(~0xfffff))|(remainder);            //需要重新设置传输计数值
                     flag=0;           //清标志
       }
              rDMASKTRIG2=(0<<2)|(1<<1)|0;      //需要重新设置DMA通道的开启
}
}
 
void Main(void)
{
      
       char mute;
       char volume;
 
	……   ……
    
    rSRCPND = (0x1<<19)|(0x1<<28);
    rSUBSRCPND = 0x1;
    rINTPND = (0x1<<19)|(0x1<<28);
       rINTSUBMSK = ~(0x1);
       rINTMSK = ~((0x1<<19)|(0x1<<28));               //开启DMA2中断屏蔽
       pISR_UART0 = (U32)uartISR;
       pISR_DMA2=(U32)DMA_end;
 
	result=0;
       remainder=0;
	flag=0;
	cmd=0;
       play_state =0;
      
       while(1)
       {
              switch(cmd)
              {
                     case 0x1:                      //播放
                            if (play_state==0)
                            {    
                                   volume = 0;           //音量清零
                                   mute=0xa0;           //初始化静音
                                   playsound(music,sizeof(music));
                            }
                            else
                            {
                                   while(!(rUTRSTAT0 & 0x2));
                                   rUTXH0=0xff;
                            }
                            cmd = 0;
                            break;
                     case 0x2:                      //停止
                            if (play_state==1)
                            {
                                   rIISCON = 0x0;            //停止IIS
                                   rIISFCON = 0x0;          //清IIS的FIFO
                                   rDMASKTRIG2=1<<2;        //终止DMA2
                                   flag = 0;
                            play_state = 0;
                            }
                            else
                            {
                                   while(!(rUTRSTAT0 & 0x2));
                                   rUTXH0=0xff;
                            }
                            cmd = 0;
                            break;                         
                     case 0x3:               //暂停，
                            if(play_state == 1)
                            {    
                                   rIISCON ^= 0x1;          //异或，
                            }
                            else
                            {
                                   while(!(rUTRSTAT0 & 0x2));
                                   rUTXH0=0xff;
                            }
                            cmd = 0;
                            break;                         
                     case 0x11:              //静音
                            if (play_state==1)
                            {
                                   mute ^= 0x4;
                                   WriteL3(0x14 + 0,1);     //DATA0 (000101xx+00)
                                   WriteL3(mute,0);          //10,1,00,x,00:x,静音
                            }
                            else
                            {
                                   while(!(rUTRSTAT0 & 0x2));
                                   rUTXH0=0xff;
                            }
                            cmd = 0;
                            break;                         
                     case 0x12:                    //音量递增
                            if (play_state==1)
                            {
                                   if(volume>0)
                                   {
                                          volume --;
                                          WriteL3(0x14 + 0,1);            //DATA0 (000101xx+00)
                                          WriteL3(volume,0);              //音量提高
                                   }
                            }
                            else
                            {
                                   while(!(rUTRSTAT0 & 0x2));
                                   rUTXH0=0xff;
                            }
                            cmd = 0;
                            break;                         
                     case 0x13:             //音量递减
                            if (play_state==1)
                            {
                                   if(volume<61)
                                   {
                                          volume++;
                                          WriteL3(0x14 + 0,1);            //DATA0 (000101xx+00)
                                          WriteL3(volume,0);              //音量降低
                                   }
                            }
                            else
                            {
                                   while(!(rUTRSTAT0 & 0x2)) ;
                                   rUTXH0=0xff;
                            }
                            cmd = 0;
                            break;
              }           
}
}


ESP32学习笔记 -- ESP32-S3 使用外部 PSRAM
EmbedIoT Studio
05-07 6977
ESP32-S3是乐鑫科技推出的一款专为物联网而生的SOC芯片，该芯片同时支持WIFI和BLE蓝牙功能，集成了高性能的Xtensa 32位LX7双核处理器，最高主频可达240MHz。
ESP32学习笔记09-ADC多通道采集 dma方式传输
Car12
04-14 3202
本实例代码连续采集3个通道的数据。
2440的DMA驱动
qq_56926420的博客
03-07 318
1.kmalloc 分配的虚拟地址连续，物理地址一定连续 2.想用DMA必须分配连续的内存 3. kmalloc特殊之处在于它分配的内存是物理上连续的,这对于要进行DMA的设备十分重要. 而用vmalloc分配的内存只是线性地址连续,物理地址不一定连续,不能直接用于DMA。 定义源src 目的dst 源物理地址src_phys 目的物理地址dst_phys 大小定义宏 4.在驱动的入口函数分配缓冲区（注意不能用vmalloc分配出来物理地址不一定连续 ） 第一个源表示在系统总线上还是外
S3C2440-DMA
编程开发资料库
01-15 139
哈尔滨理工大学软件工程专业08-7李万鹏原创作品，转载请标明出处 http://blog.youkuaiyun.com/woshixingaaa/archive/2011/01/15/6142721.aspx S3c2440A 支持位于系统总线和外设总线之间的4 个通道的控制器。每个DMA 控制器通道无限制地执行系统总线上的设备或外设总线上的设备之间数据搬移。换句话说，就是每个通道都操作一下四种情况：...
32.Linux-2440下的DMA驱动(详解)
weixin_34332905的博客
11-22 250
DMA(Direct Memory Access) 即直接存储器访问， DMA 传输方式无需 CPU 直接控制传输，通过硬件为 RAM 、I/O 设备开辟一条直接传送数据的通路，能使 CPU 的效率大为提高。   学了这么多驱动，不难推出DMA的编写套路: 1)注册DMA中断,分配缓冲区 2)注册字符设备,并提供文件操作集合fops   -&gt; 2.1)file_op...
mini2440 简单的dma工作原理实验
皓首不倦 不负少年
07-17 707
以驱动方式测试dma的工作原理，用户层程序不停调用ioctl触发驱动里面完成的dma操作，把内存
s3c2440的DMA应用
pengrui18的专栏
06-14 486
DMA（Direct Memory Access，直接内存访问）是一种不经过CPU而直接从内存存取数据的数据交换模式。在需要进行大量数据交换的场合，用好DMA，可以大大提高系统的性能，因为DMA操作几乎不占用CPU资源。 s3c2440提供了4个通道的DMA，它们不仅可以实现内存之间的数据交换，还可以实现内存与外设，以及外设与外设之间的数据交换。要用好s3c2440的DMA，关键是...
ESP32-S3 学习笔记（2）-屏幕驱动和lvgl移植
最新发布
qq_26048279的博客
05-25 1102
本文介绍了ESP32驱动ST7789屏幕并移植LVGL图形库的全过程。首先通过SPI协议实现了ST7789驱动，包括引脚配置、初始化流程和刷新机制。然后将LVGL移植到ESP32平台，重点解决了显示缓存分配、坐标校准等关键问题。文中详细说明了硬件接口配置、显存管理方法，并提供了屏幕坐标校准函数来解决显示偏移问题。最后指出实际应用中需要注意的细节问题，为开发者提供了完整的嵌入式GUI开发解决方案。
s3c2440时钟学习（韦东山老师课程学习笔记）
hamlet_zy的博客
11-22 582
S3C2440时钟体系(韦东山学习笔记) 1、  S3C2440可以外接晶振，然后通过内部电路产生时钟源 ； 也可以直接使用外部提供的时钟源，它通过引脚的设置来选择。 2、三种时钟：FCLK用于cpu核、HCLK用于AHB总线上的设备、PCLK用于APB总线上的设备。      其中AHB（Advanced High Performance Bus）总线：用于接高性能模块，例如CPU
【STM32学习笔记--时钟系统】
weixin_45383564的博客
02-22 495
文件名：stm32f407xx.h HAL库 #943行开始 其他同理，查看该文件 /*!< Peripheral mstemory map */ #define APB1PERIPH_BASE PERIPH_BASE #define APB2PERIPH_BASE (PERIPH_BASE + 0x00010000UL) #define AHB1PERIPH_BASE (PERIPH_BASE + 0x00020000UL) #define AHB2PERI
ADS下的s3c2440 DMA调试程序
11-04
ADS下的s3c2440 DMA调试程序，实际调试过，很好用。
S3C2440裸奔---DMA源代码
05-17
首先需要搭建一个可以编译代码的环境。从一开始我就不想用ADS（安装完ADS后会产生一个CodeWarrior for ARM Developer Suite的工具，可以编译和调试代码），虽然它是个很好的工具，但是它却隐藏了很多的细节，不利于新手去深度学习。所以我还是希望从Makefile入手，一步一步弄懂所有的细节。 第一步：需要先搭建一个Linux环境，我是安装在虚拟机上面的。安装好Linux后，再从网上下载arm-linux-gcc，一般解压后之后就可以直接使用了，但需要先设置好环境参数。 第二步：编写代码，然后在Linux系统上进行编译。代码在后面会给出。 第三步：需要把编译好的bin文件烧写到板子上。这个需要使用J-Link烧录器，还需要安装“Setup_JLinkARM_V408k.exe”软件，特别是一些参数的设置非常重要。
一般的，在s3c2440中，要想进行dma…
shangyaowei的专栏
12-19 400
2010年3月28日 linux内核机制 2010-03-28 14:36:24 阅读125 评论0  字号：大中小 订阅  s3c2440的dma操作的一般步骤  一： int s3c2410_dma_request(unsigned int channel,             struct s3c2410_dma_client *client,             void
S3C2440 Mini 2440 DMA方式实现Uart（串口）通信
08-05 2544
搞了好久，终于完成了DMA方式实现串口通信。使用DMA不是很难，主要是DCONn的配置比较麻烦以及几种模式的理解。 DMA service mode：single service＆Whole service。前一模式下，一次DMA请求完成一项原子操作，并且transfer count的值减1。后一模式下，一次DMA请求完成一批原子操作，直到transfer count等于0表示完成一次整
S3C2440 - DMA传输（以字符传输为例）
潇涵的技术笔记
12-20 2274
一、使用DMA的优点及DMA支持的请求源 1、DMA优点是其进行数据传输时不需要CPU的干涉，可以大大提高CPU的工作效率。 2、DMA在大容量数据传输中非常重要，比如图像数据传输，SD卡数据传输，USB数据传输等。 3、S3C2440有四个DMA，每个DMA支持的工作方式基本相同，但支持的DMA请求源可能略有不同。如下为四个DMA通道分别支持的DMA请求源： Ch0:
s3c2440的dma操作的一般步骤
03-29 544
s3c2440的dma操作的一般步骤  一般的，在s3c2440中，要想进行dma传输，需要一下七个步骤：一：int s3c2410_dma_request(unsigned int channel,            struct s3c2410_dma_client *client,          
mini2440裸机DMA（1）
dfl448866的专栏
04-22 340
第8章 直接存储器存取DMA 在DMA章接种一共有四个通道的DMA源，而每一种源由包括9个寄存器。则我们只需要配置好久个寄存器就可以操作好DMA了。 这里主要以通道0位讲解 第一个寄存器 DISRC pDMA->DISRC=srcAddr; //设置源地址 第二个 寄存器DISRCC pDMA->DISRCC=...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值