Linux驱动程序编写&&应用程序对她的调用

        Linux驱动程序的开发，我相信这是很多致力于嵌入式学习的骚年的终极梦想，不管是技术含量，还是薪金待遇，她都一一完美的体现了出来！当然，crk_13也一样！不过，越是诱人的东西往往也越是可望而不可即，或许大家都对驱动开发的难度之大，要求之高有所耳闻！以我个人的经历来看，编写驱动程序确实需要你对Linux的整个体系有一个全面的认识（包括系统编程、文件操作、硬件结构），不过，要想入个门、了解驱动程序开发的大致步骤，却也没有传说中的那么困难！

        首先，我们以一个最简单的驱动程序——永远不变的hello_world为例，了解一下linux驱动程序编写的一般步骤与规则。

        先简单的介绍下Linux驱动程序的基本结构：必须包含一下两个宏

        module_init(init_func);

        module_exit(exit_func);

        并实现init_func()、exit_func()函数，在模块被加载和移除的时候会分别被调用

        一个简单的hello_world驱动：

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
 
static int __init hello_init()
{
    printk("Hello, world!\n");
    return 0;
}
 
static void __exit hello_exit()
{
    printk("Goodbye, cruel world!\n");
}
 
module_init(hello_init);
module_exit(hello_exit);

        这就是一个最简单的驱动程序，编译之后，我们可以把生成的hello.ko文件拷到开发板上，分别执行如下命令：

        insmod hello.ko       #加载模块，会调用hello_init()#

        rmmod hello       #移除模块，会调用hello_exit()#

 

        下面，我将以一个S5PV210的led驱动程序为例，一步一步叫大家编写一个属于自己的驱动程序，并学会使用它：

        目的：将开发板上的led灯（以一个灯为例，其他的一样）作为一个设备，为其编写驱动程序，并调用！

        准备工作：①、硬件结构：led1(GPJ0_3)②、内核：kernel，可以在www.kernel.org下载

        一、编译好我们自己的内核

                以我自己的kernel.tar.gz为例:

                ①、tar -xvzf kernel.tar.gz        #将内核源码解压到当前目录#

                ②、cd ./kernel        #解压完后，进入kernel根目录#

                ③、cp ./arch/arm/configs/XXX_deconfig.config  .config        #从arch/arm/configs/目录下拷贝一个配置文件到kernel根目录，重命名为.config#

                ④、make zImage       #编译生成内核镜像文件(大约20分钟左右)#

                OK，一切顺利的话，我们就得到了一个我们自己编译好的内核zImage

        二、有了内核之后，我们就可以开始写我们的驱动程序了（如果上一步没有成功，并不是说我们不能写代码，只是我们的驱动程序是为内核服务的，我们必须为她指定一个内核，他才能编译过去）

                ①、首先我们需要为设备（也就是我们的led灯）分配设备号（包括这设备号、从设备号），我们一般采用动态分配法：

                        dev_t  led_device_num;

                        alloc_chrdev_region(&led_device_num, 0, 1, "led_dev");        #动态分配设备号#

                ②、有了设备号之后，我们就可以找到相应的设备，并对这个设备进行我们想要的操作了！永远不要忘记：在Linux的眼中，一切都是文件！对于文件来说，最常用的操作不外乎：open，read，write，seek，close等！因此，我们也应该提供类似的函数对设备进行操作，供应用程序使用，而不应该自己随便写个函数实现功能！

                在./include/linux/fs.h文件中定义了一个结构体——file_operations，这是一个非常重要的结构体，我们编写驱动程序的时候，无非是对这个结构体中定义的一些函数的实现。如：

                        static struct file_operations led_dev_fops =
                        {
                                .read = led_dev_read,
                                .write = led_dev_write,
                                .open = led_dev_open,
                                .owner = THIS_MODULE
                        };

                led_dev_read，led_dev_write，led_dev_open分别是对read，write，open函数指针的的初始化，以后，当应用程序对led设备（我们现在编写的）进行open、read、write操作时，就会分别调用“=”后面的函数，当然，我们会在后面实现这几个函数。

                可是，我们只是定义了一个结构体变量、并进行了初始化啊，设备怎么知道呢，内核又怎么把系统的函数与我们自己实现的函数联系起来呢？所以，我们还应该把这种函数对应关系告诉我们的设备：

                        static struct cdev led_dev;        #定义一个字符型设备变量#

                        cdev_init (&led_dev, &led_dev_fops);        #初始化该字符设备，主要是对函数指针的初始化#

                ③、字符设备最终是由内核调用的，前面的工作都还只是闭门造车，现在车造好了，该上路了，是不是需要得到交通部门的许可呢？同样，我们应该告诉内核，我们需要注册这样一个设备：

                        cdev_add (&led_dev, led_dev_num, 1);        #注册该设备#

                ④、完成上述步骤后，我们的初始化工作（即：获取设备号、注册设备）已经做好，接着我们就要编写我们自己的文件操作函数了，即：led_dev_open、led_dev_read、led_dev_write。

                ⑤、后续处理。做好这些之后，我们需要在卸载模块时，释放我们申请的设备号、并卸载该设备：

                        cdev_del (&led_dev);       #卸载设备#
                        unregister_chrdev_region(led_dev_num, 1);       #释放设备号#

附上一段我自己编写的代码：

#include <linux/module.h>                                                       
#include <linux/kernel.h>                                                       
#include <linux/init.h>                                                         
#include <linux/ioport.h>
#include <asm/io.h>
#include <asm/uaccess.h>

#include <linux/io.h>                            
#include <linux/gpio.h> 

#include <linux/cdev.h>
#include <linux/fs.h>

static dev_t led_dev_num;
static struct cdev led_dev;  
static int copen(struct inode *node, struct file *filep)
{
    printk ("led_dev is open!\n");        
    gpio_set_value(S5PV210_GPJ0(3), 0);    //gpj0_3输出低电平，led1亮
    return 0;
} 

static ssize_t cread (struct file *filep, char __user *buf, size_t count, loff_t *f_pos)
{        
    gpio_set_value(S5PV210_GPJ0(3), 1);    //gpj0_3输出高电平，led1灭
    printk ("led_dev is read!\n");
    return 0;
} 

static ssize_t cwrite (struct file *filep, const char __user *buf, size_t count, loff_t *f_pos)
{
    printk ("led_dev is write!\n");
    return 0;
} 

static struct file_operations led_dev_fops =
{
    .read  = cread,
    .write = cwrite,
    .open  = copen,
    .owner = THIS_MODULE
}; 

static int __init led_dev_init (void)
{
    int res;
    res = alloc_chrdev_region(&led_dev_num, 0, 1, "led_dev");    //动态分配设备号
    if (res < 0)
        return res;
  
    cdev_init (&led_dev, &led_dev_fops);    //设备初始化
    cdev_add (&led_dev, led_dev_num, 1);    //添加设备
 
    s3c_gpio_cfgpin (S5PV210_GPJ0(3), S3C_GPIO_OUTPUT);    //将gpj0_3端口配置为输出模式
    
    printk ("led_dev is init\n");
    return 0;
} 

static void __exit led_dev_exit (void)
{
    cdev_del (&led_dev);    //卸载设配
    unregister_chrdev_region(led_dev_num, 1);    //注销设备号
    printk ("led_dev is exit\n");
} 

module_init(led_dev_init);
module_exit(led_dev_exit);  

MODULE_LICENSE("Dual BSD/GPL");    //许可证，注意最好是遵循gpl协议，否则，在板子上加载模块的时候，可能会不成功！
MODULE_AUTHOR("crk_13");
MODULE_DESCRIPTION("This is my first driver");
MODULE_SUPPORTED_DEVICE("none");

         三、编译。程序编写好之后，我们需要编译led_dev.c，我这里提供一个Makefile文件，做一点小小的改动，然后make就行了！ 

# Comment/uncomment the following line to disable/enable debugging
#DEBUG = y

# Add your debugging flag (or not) to CFLAGS
ifeq ($(DEBUG),y)
  DEBFLAGS = -O -g # "-O" is needed to expand inlines
else
  DEBFLAGS = -O2
endif

#CFLAGS += $(DEBFLAGS) -I$(LDDINCDIR)

ifneq ($(KERNELRELEASE),)
# call from kernel build system
# 把obj-m后面的目标文件名改成你自己的源文件名
obj-m	:= led_dev.o

else
# 把路径改成你的内核的根目录路径
KERNELDIR ?= /home/yw/kernel
PWD       := $(shell pwd)

default:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) LDDINCDIR=$(PWD)/../include modules

endif



clean:
	rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions

depend .depend dep:
	$(CC) $(CFLAGS) -M *.c > .depend


ifeq (.depend,$(wildcard .depend))
include .depend
endif

        编译完成之后，可以看到，在当前目录下会生成一个led_dev.ko文件，我们可以在开发板上通过nfs挂载到宿主机，然后执行下面的一系列操作：
                ①、insmod led_dev.ko        #加载模块#
                ②、cat /proc/devices        #查看设备led_dev的主设备号（因为是动态分配的，一开始我们并不知道）#
                ③、mknod /dev/led_dev c 250 0        #创建设备节点，设备名可以随便起，比一定要是led_dev#
                ④、ls /dev/led_dev -l        #可以查看是否存在我们创建的节点，及主、从设备号#
                ⑤、cat /dev/led_dev        #执行该命令，相当于同时执行了open、read操作#
                ⑥、rmmod led_dev        #移除设备，在编写了应用程序调用的实验时，先不要执行这一步，在做完后面的执行应用程序之后，再移除，否则，又要返回①重做一遍！#

 

        四、应用程序的编写        其实应用程序相对来说格式比较灵活，无非就是想操作普通文件一样调用open，read。。。不多说了，看看代码吧！

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

int main(int argc, const char* argv[])    //执行的时候输入./main /dev/led_dev 10说明打开的是/dev/led_dev设备，10用于后面的延时10s
{
    char buf[20];
    int fd = open (argv[1], O_RDWR);    //调用led_dev_open函数，led1亮

    sleep(atoi(argv[2]));    //延时10s
    read (fd, buf, sizeof(buf));    //调用led_dev_read函数，led1灭

    close(fd);
    return 0;
}

        应用程序编写完成，开始编译，并执行：
        ①、arm-linux-gcc main.c -o main       #编译main.c，重命名为main，当然，为了方便，你完全可以写个Makefile#
        ②、./main /dev/led_dev 10        #执行main，打开/dev/led_dev设备，延时10s#
        可以看到现象：led1先亮10s，然后熄灭！我们的led驱动就做好啦！哈哈，当然，这只是一个模板，谈不上规范和实用，你完全可以把她改的更好哦！