s3c 2410 DMA驱动源码分析1

2410下DMA驱动源码分析

Author:aaron

 

    关于2410下的DMA操作模式等信息的介绍请参考我的另外一篇文章<< S3C2410:DMA介紹>>, 这里

主要以kernel为2.6.22的源码来对2410DMA的驱动源码的做个分析.

首先我们由kconfig和makefile来获取DMA方面相关文件(即源码):

 Arch/arm/plat-s3c24xx/Dma.c

 Arch/arm/mach-s3c2410/Dma.c

 以上两个就是操作DMA的核心文件. 我们会逐个的来分析.

 

先看初始化函数, 哪些是初始化函数呢? 就是哪些通过module_init, core_initcall, arch_initcall等声明的函数.

首先在arch/arm/mach-s3c2410/s3c2410.c下有个初始化函数.

arch/arm/mach-s3c2410/s3c2410.c:

static int __init s3c2410_core_init(void)

{

       return sysdev_class_register(&s3c2410_sysclass);   //注册一个class 类

}

 

core_initcall(s3c2410_core_init);

我们以后会看到, 后面的DMA设备及DMA驱动都会注册到该类下面.

arch/arm/mach-s3c2410/s3c2410.c:

struct sysdev_class s3c2410_sysclass = {

       set_kset_name("s3c2410-core"),

};

很明显, 实际上该类并没有其他什么操作, 只是为了让DMA设备和驱动都注册到这个类下面, 以使对方可以互相找的到.

接着在arch/arm/plat-s3c24xx/Dma.c下也注册了一个类

arch/arm/plat-s3c24xx/Dma.c:

static int __init s3c24xx_dma_sysclass_init(void)

{

       int ret = sysdev_class_register(&dma_sysclass);    //注册的类

 

       if (ret != 0)

              printk(KERN_ERR "dma sysclass registration failed/n");

 

       return ret;

}

 

struct sysdev_class dma_sysclass = {

       set_kset_name("s3c24xx-dma"),

       .suspend = s3c2410_dma_suspend,   

       .resume          = s3c2410_dma_resume,

};

后面我们会看到这2个类是如何使用的. 其中的dma_sysclass还有suspend和resume的操作, 这些都是电源管理方面的东西,我们这里就不分析了.

接着看在arch/arm/mach-s3c2410/Dma.c下注册了DMA的驱动程序

arch/arm/mach-s3c2410/Dma.c:

#if defined(CONFIG_CPU_S3C2410)    /*我们以2410为例*/

static struct sysdev_driver s3c2410_dma_driver = {

       .add = s3c2410_dma_add, 

};

 

static int __init s3c2410_dma_drvinit(void)

{

    //注册驱动, 把s3c2410_dma_driver注册到s3c2410_sysclass类下

       return sysdev_driver_register(&s3c2410_sysclass, &s3c2410_dma_driver); 

}

 

arch_initcall(s3c2410_dma_drvinit);

#endif

可以看到这个函数就是把DMA的驱动程序注册到s3c2410_sysclass的类下面, 后面我们会看到DMA设备是如何找到整个驱动并调用驱动的add函数的.

Drivers/base/sys.c:

int sysdev_driver_register(struct sysdev_class * cls,

                        struct sysdev_driver * drv)

{

       down(&sysdev_drivers_lock);

       if (cls && kset_get(&cls->kset)) {

              list_add_tail(&drv->entry, &cls->drivers);  //把驱动注册到类下面的drivers list下

 

              /* If devices of this class already exist, tell the driver */

              if (drv->add) {  //如果驱动有add函数的话

                     struct sys_device *dev;

                     list_for_each_entry(dev, &cls->kset.list, kobj.entry)

                            drv->add(dev);   //为该类下的每个设备调用驱动的add函数.

              }

       } else

              list_add_tail(&drv->entry, &sysdev_drivers); //把驱动注册到类下面的drivers list下

       up(&sysdev_drivers_lock);

       return 0;

}

通过上面这个函数, 我们就看到了s3c2410_dma_driver是如何注册进s3c2410_sysclass类的, 即就是把s3c2410_dma_driver挂到s3c2410_sysclass下的drivers列表下.

接着我们来看DMA设备的注册了.

Arch/arm/mach-s3c2410/s3c2410.c:

int __init s3c2410_init(void)

{

       printk("S3C2410: Initialising architecture/n");

 

       return sysdev_register(&s3c2410_sysdev);   //注册设备了

}

 

static struct sys_device s3c2410_sysdev = {

       .cls         = &s3c2410_sysclass,

};

这个函数注册了一个系统设备, 我们看到, 其实这是个虚拟设备(其实根本就不是个设备), 它仅仅是为了要触发dma驱动的那个add函数, 所有的DMA设备会在那个时候才会真正的注册. 至于这个函数是怎么调用的问题, 就由读者自己去分析吧J, 不过我记得我有文章分析过的哦.

Drivers/base/sys.c:

int sysdev_register(struct sys_device * sysdev)

{

       int error;

       struct sysdev_class * cls = sysdev->cls;

 

       if (!cls)

              return -EINVAL;

 

       /* Make sure the kset is set */

       sysdev->kobj.kset = &cls->kset;

 

       /* But make sure we point to the right type for sysfs translation */

       sysdev->kobj.ktype = &ktype_sysdev;

       error = kobject_set_name(&sysdev->kobj, "%s%d",

                      kobject_name(&cls->kset.kobj), sysdev->id);

       if (error)

              return error;

 

       pr_debug("Registering sys device '%s'/n", kobject_name(&sysdev->kobj));

 

       /* Register the object */

       error = kobject_register(&sysdev->kobj);

 

       if (!error) {

              struct sysdev_driver * drv;

 

              down(&sysdev_drivers_lock);

              /* Generic notification is implicit, because it's that

               * code that should have called us.

               */

           //对于我们分析DMA来讲,更关心的是下面这段代码

              /* Notify global drivers */

              //调用所有全局的sysdev_drivers

list_for_each_entry(drv, &sysdev_drivers, entry) {

                     if (drv->add)

                            drv->add(sysdev);

              }

 

              /* Notify class auxillary drivers */

        //接着调用具体class下面的驱动

              list_for_each_entry(drv, &cls->drivers, entry) {

                     if (drv->add)

                            drv->add(sysdev);   //驱动的add函数.

              }

              up(&sysdev_drivers_lock);

       }

       return error;

}

我们可以看到s3c2410_sysdev的类就是s3c2410_sysclass, 所以这里找到的驱动就是前面我们注册进s3c2410_sysclass的dma驱动, 因此这里的add函数就是s3c2410_dma_add了.

Arch/arm/mach-s3c2410/dma.c:

static int s3c2410_dma_add(struct sys_device *sysdev)

{

       s3c2410_dma_init();   //DMA初始化

       s3c24xx_dma_order_set(&s3c2410_dma_order); 

       return s3c24xx_dma_init_map(&s3c2410_dma_sel);

}

真正的DMA方面的操作就从这个函数开始了. 我们一个个函数来看.

Arch/arm/plat-s3c24xx/dma.c:

int s3c2410_dma_init(void)

{

       return s3c24xx_dma_init(4, IRQ_DMA0, 0x40);

}

我们来看下参数, 第一个参数代表dma channel数(参考2410 data sheet), 第二个参数是dma的中断号, 第三个参数是每个channel对应的寄存器基地址与前一个channel的寄存器的基地址的偏移, 即如果第一个channel的第一个寄存器的地址是0x4b000000则第二个channel的第一个寄存器的地址是0x4b000040,

 接着看

Arch/arm/plat-s3c24xx/dma.c:

int __init s3c24xx_dma_init(unsigned int channels, unsigned int irq,

                         unsigned int stride)

{

       struct s3c2410_dma_chan *cp;   //每个channel都由个s3c2410_dma_chan表示

       int channel;

       int ret;

 

       printk("S3C24XX DMA Driver, (c) 2003-2004,2006 Simtec Electronics/n");

 

       dma_channels = channels;   //保存channel的数量

 

    //把所有channel的所有寄存器地址由实地址转换成虚拟地址.

    //我们驱动中使用的都是虚拟地址.

       dma_base = ioremap(S3C24XX_PA_DMA, stride * channels); 

       if (dma_base == NULL) {

              printk(KERN_ERR "dma failed to remap register block/n");

              return -ENOMEM;

       }

    //创建一个高速缓冲对象, 具体可参考linux设备驱动程序III的第8章

       dma_kmem = kmem_cache_create("dma_desc",

                                 sizeof(struct s3c2410_dma_buf), 0,

                                 SLAB_HWCACHE_ALIGN,

                                 s3c2410_dma_cache_ctor, NULL);

 

       if (dma_kmem == NULL) {

              printk(KERN_ERR "dma failed to make kmem cache/n");

              ret = -ENOMEM;

              goto err;

       }

   

    //为每个channel初始化.

       for (channel = 0; channel < channels;  channel++) {

              cp = &s3c2410_chans[channel];   //全局变量保存每个channel的信息.

 

              memset(cp, 0, sizeof(struct s3c2410_dma_chan));

 

              /* dma channel irqs are in order.. */

              cp->number = channel;   //channel号

              cp->irq    = channel + irq;  //该channel的中断号

              cp->regs   = dma_base + (channel * stride);   //该channel的寄存器基地址

 

              /* point current stats somewhere */

              cp->stats  = &cp->stats_store;    //channel状态

              cp->stats_store.timeout_shortest = LONG_MAX;

 

              /* basic channel configuration */

 

              cp->load_timeout = 1<<18;

 

              printk("DMA channel %d at %p, irq %d/n",

                     cp->number, cp->regs, cp->irq);

       }

 

       return 0;

 

 err:

       kmem_cache_destroy(dma_kmem);

       iounmap(dma_base);

       dma_base = NULL;

       return ret;

}

这个函数就是对每个channel进行初始化, 并把每个channel的相关信息保存起来供以后的操作使用.

接着看下一个函数:

Arch/arm/plat-s3c24xx/dma.c:

int __init s3c24xx_dma_order_set(struct s3c24xx_dma_order *ord)

{

       struct s3c24xx_dma_order *nord = dma_order;   //dma_order是个全局指针

 

   //分配内存

       if (nord == NULL)

              nord = kmalloc(sizeof(struct s3c24xx_dma_order), GFP_KERNEL);

 

       if (nord == NULL) {

              printk(KERN_ERR "no memory to store dma channel order/n");

              return -ENOMEM;

       }

 

    //保存ord信息

       dma_order = nord;

       memcpy(nord, ord, sizeof(struct s3c24xx_dma_order));

       return 0;

}

这个函数主要是分配了一个内存用来保存order信息, 我们来看传进来的参数

Arch/arm/mach-s3c2410/dma.c:

static struct s3c24xx_dma_order __initdata s3c2410_dma_order = {

       .channels = {

              [DMACH_SDI]     = {

                     .list  = {

                            [0]   = 3 | DMA_CH_VALID,

                            [1]   = 2 | DMA_CH_VALID,

                            [2]   = 0 | DMA_CH_VALID,

                     },

              },

              [DMACH_I2S_IN]       = {

                     .list  = {

                            [0]   = 1 | DMA_CH_VALID,

                            [1]   = 2 | DMA_CH_VALID,

                     },

              },

       },

};

注意这个变量用__initdata定义了, 因此它只在初始化的时候存在, 所以我们有必要分配一块内存来保存它的信息. 这也是上面那个函数的作用, 那这个s3c2410_dma_order到底有什么作用呢, 我们看这个结构的解释

Include/asm-arm/plat-s3c24xx/dma.h::

/* struct s3c24xx_dma_order

 *

 * information provided by either the core or the board to give the

 * dma system a hint on how to allocate channels

*/

//注释说的很明确了吧, 就是用来指导系统如何分配dma channel,因为2410下的4个channel的源跟目的并不是所有的外设都可以使用的.

struct s3c24xx_dma_order {

       struct s3c24xx_dma_order_ch      channels[DMACH_MAX];

};

看完了s3c24xx_dma_order_set, 我们接着看s3c24xx_dma_init_map

Arch/arm/plat-s3c24xx/dma.c:

int __init s3c24xx_dma_init_map(struct s3c24xx_dma_selection *sel)

{

       struct s3c24xx_dma_map *nmap;

       size_t map_sz = sizeof(*nmap) * sel->map_size;

       int ptr;

 

       nmap = kmalloc(map_sz, GFP_KERNEL);  //分配内存

       if (nmap == NULL)

              return -ENOMEM;

 

       //保存信息

       memcpy(nmap, sel->map, map_sz);

       memcpy(&dma_sel, sel, sizeof(*sel));

 

       dma_sel.map = nmap;

 

    //检查是否正确

       for (ptr = 0; ptr < sel->map_size; ptr++)

              s3c24xx_dma_check_entry(nmap+ptr, ptr);

 

       return 0;

}

这个函数和s3c24xx_dma_order_set的作用一样, 也是先分配一块内存然后在保存信息. 我们来看参数:

Arch/arm/mach-s3c2410/dma.c:

static struct s3c24xx_dma_selection __initdata s3c2410_dma_sel = {

       .select            = s3c2410_dma_select,

       .dcon_mask    = 7 << 24,

       .map              = s3c2410_dma_mappings,

       .map_size       = ARRAY_SIZE(s3c2410_dma_mappings),

};

呵呵也是用__initdata定义的, 难怪要重新分配内存并保存起来, 那这些是什么信息呢, 我们看到主要就是个map, 我们接着来看这个map中到底存了些什么东西.

Arch/arm/mach-s3c2410/dma.c:

static struct s3c24xx_dma_map __initdata s3c2410_dma_mappings[] = {

       [DMACH_XD0] = {

              .name            = "xdreq0",

              .channels[0]   = S3C2410_DCON_CH0_XDREQ0 | DMA_CH_VALID,

       },

       [DMACH_XD1] = {

              .name            = "xdreq1",

              .channels[1]   = S3C2410_DCON_CH1_XDREQ1 | DMA_CH_VALID,

       },

       [DMACH_SDI] = {

              .name            = "sdi",

              .channels[0]   = S3C2410_DCON_CH0_SDI | DMA_CH_VALID,

              .channels[2]   = S3C2410_DCON_CH2_SDI | DMA_CH_VALID,

              .channels[3]   = S3C2410_DCON_CH3_SDI | DMA_CH_VALID,

              .hw_addr.to    = S3C2410_PA_IIS + S3C2410_IISFIFO,

              .hw_addr.from       = S3C2410_PA_IIS + S3C2410_IISFIFO,

       },

       [DMACH_SPI0] = {

              .name            = "spi0",

              .channels[1]   = S3C2410_DCON_CH1_SPI | DMA_CH_VALID,

              .hw_addr.to    = S3C2410_PA_SPI + S3C2410_SPTDAT,

              .hw_addr.from       = S3C2410_PA_SPI + S3C2410_SPRDAT,

       },

       [DMACH_SPI1] = {

              .name            = "spi1",

              .channels[3]   = S3C2410_DCON_CH3_SPI | DMA_CH_VALID,

              .hw_addr.to    = S3C2410_PA_SPI + 0x20 + S3C2410_SPTDAT,

              .hw_addr.from       = S3C2410_PA_SPI + 0x20 + S3C2410_SPRDAT,

       },

       [DMACH_UART0] = {

              .name            = "uart0",

              .channels[0]   = S3C2410_DCON_CH0_UART0 | DMA_CH_VALID,

              .hw_addr.to    = S3C2410_PA_UART0 + S3C2410_UTXH,

              .hw_addr.from       = S3C2410_PA_UART0 + S3C2410_URXH,

       },

       [DMACH_UART1] = {

              .name            = "uart1",

              .channels[1]   = S3C2410_DCON_CH1_UART1 | DMA_CH_VALID,

              .hw_addr.to    = S3C2410_PA_UART1 + S3C2410_UTXH,

              .hw_addr.from       = S3C2410_PA_UART1 + S3C2410_URXH,

       },

         [DMACH_UART2] = {

              .name            = "uart2",

              .channels[3]   = S3C2410_DCON_CH3_UART2 | DMA_CH_VALID,

              .hw_addr.to    = S3C2410_PA_UART2 + S3C2410_UTXH,

              .hw_addr.from       = S3C2410_PA_UART2 + S3C2410_URXH,

       },

       [DMACH_TIMER] = {

              .name            = "timer",

              .channels[0]   = S3C2410_DCON_CH0_TIMER | DMA_CH_VALID,

              .channels[2]   = S3C2410_DCON_CH2_TIMER | DMA_CH_VALID,

              .channels[3]   = S3C2410_DCON_CH3_TIMER | DMA_CH_VALID,

       },

       [DMACH_I2S_IN] = {

              .name            = "i2s-sdi",

              .channels[1]   = S3C2410_DCON_CH1_I2SSDI | DMA_CH_VALID,

              .channels[2]   = S3C2410_DCON_CH2_I2SSDI | DMA_CH_VALID,

              .hw_addr.from       = S3C2410_PA_IIS + S3C2410_IISFIFO,

       },

       [DMACH_I2S_OUT] = {

              .name            = "i2s-sdo",

              .channels[2]   = S3C2410_DCON_CH2_I2SSDO | DMA_CH_VALID,

              .hw_addr.to    = S3C2410_PA_IIS + S3C2410_IISFIFO,

       },

       [DMACH_USB_EP1] = {

              .name            = "usb-ep1",

              .channels[0]   = S3C2410_DCON_CH0_USBEP1 | DMA_CH_VALID,

       },

       [DMACH_USB_EP2] = {

              .name            = "usb-ep2",

              .channels[1]   = S3C2410_DCON_CH1_USBEP2 | DMA_CH_VALID,

       },

       [DMACH_USB_EP3] = {

              .name            = "usb-ep3",

              .channels[2]   = S3C2410_DCON_CH2_USBEP3 | DMA_CH_VALID,

       },

       [DMACH_USB_EP4] = {

              .name            = "usb-ep4",

              .channels[3]   =S3C2410_DCON_CH3_USBEP4 | DMA_CH_VALID,

       },

};

一大堆东西, 我们还是来看这个结构的注释吧

Include/asm-arm/plat-s3c24xx/dma.h:

/* struct s3c24xx_dma_map

 *

 * this holds the mapping information for the channel selected

 * to be connected to the specified device

*/

//保存了一些被选择使用的channel和规定的设备间的一些map信息.具体到了使用的时候就会明白了

struct s3c24xx_dma_map {

       const char             *name;

       struct s3c24xx_dma_addr  hw_addr;

 

       unsigned long        channels[S3C2410_DMA_CHANNELS];

};

Ok, 这样就把s3c2410_dma_add函数分析完了, 到这里把每个channel的各种信息包括各channel的寄存器地址, 中断号, 跟设备的关系等信息都保存好了,  但是虽然每个channel都初始化好了, 但是还记得吗, 到目前为址, 我们仅仅是向系统注册了一个虚拟的设备, 真真的DMA设备还没注册进系统呢,  因此接下来就是要注册DMA设备了, 在哪呢?

Arch/arm/plat-s3c24xx/dma.c:

static int __init s3c24xx_dma_sysdev_register(void)

{

       struct s3c2410_dma_chan *cp = s3c2410_chans;  //这个全局变量里已经保存了channel信息哦

       int channel, ret;

 

    //对每个channel操作

       for (channel = 0; channel < dma_channels; cp++, channel++) {

              cp->dev.cls = &dma_sysclass;  //指定class为dma_sysclass

              cp->dev.id  = channel;  //channel号

              ret = sysdev_register(&cp->dev);  //注册设备

 

              if (ret) {

                     printk(KERN_ERR "error registering dev for dma %d/n",

                            channel);

                    return ret;

              }

       }

 

       return 0;

}

 

late_initcall(s3c24xx_dma_sysdev_register);  //注意这行, 它会在初始化完毕后被调用,

这个函数把所有的channel注册到dma_sysclass类下, 我们前面看到注册设备时会调用该类的add函数, 还好这里的dma_sysclass类没有add函数, 我们可以轻松下了.

Ok, 到这里DMA设备算是全部准备好了, 可以随时被请求使用了, 到这里我们总结一下:

Arch/arm/mach-s3c2410/dma.c 下的代码主要是跟具体板子相关的代码, 而真正核心的代码都在

Arch/arm/plat-s3c24xx/dma.c下, 因此如果我们有块跟2410类似的板子的话, 主要实现的就是

Arch/arm/mach-s3c2410/dma.c 这个文件了,

同时我们也不难推测, 使用DMA的函数应该都在Arch/arm/plat-s3c24xx/dma.c下. 没错, 说的更具体些就是这个文件下被EXPORT_SYMBOL出来的函数都是提供给外部使用的, 也就是其他部分使用DMA的接口. 知道了这些我们接着来分析这些被EXPORT_SYMBOL的函数吧.

http://blog.csdn.net/aaronychen/article/details/4056156