linux驱动学习笔记 led的驱动程序与驱动测试程序

前言

正在学习linux的驱动编写与编译，使用的是韦东山老师的jz2440开发板，下面将对视频配套源码下的驱动代码（\JZ2440V3\drivers_and_test\leds）进行解析归纳。

先学习将要用到的知识点

• int main(int argc, char **argv)
• 互斥锁
• 设备类
• MKDEV()宏
• unlikely()
• IS_ERR 与 PTR_ERR
• cpu内存映射方式（Memory-mapped）
• copy_from_user
• 深入了解 file_operations
• 驱动程序的Makefile
• 内核源码树

main函数的参数解析

第一个参数，int型的argc，为整型，用来统计程序运行时发送给main函数的命令行参数的个数，在VS中默认值为1。
第二个参数，char*型的argv[]，为字符串数组，用来存放指向的字符串参数的指针数组，每一个元素指向一个参数。各成员含义如下：
argv[0]指向程序运行的全路径名
argv[1]指向在DOS命令行中执行程序名后的第一个字符串
argv[2]指向执行程序名后的第二个字符串
argv[3]指向执行程序名后的第三个字符串
argv[argc]为NULL

互斥锁的用法

//该宏声明一个信号量name并初始化他的值为1，即声明一个互斥锁
static DECLARE_MUTEX(leds_lock); 

/*
该函数用于获得信号量sem，他会导致睡眠，因此不能在中断上下文（包括IRQ上下文和softirq上下文）使用该函数。
该函数将把sem的值减1，如果信号量sem的值非负，就直接返回，否则调用者将被挂起，直到别的任务释放该信号量才能继续运行。
*/
down(&leds_lock);

/*
该函数释放信号量sem，即把sem的值加1，
如果sem的值为非正数，表明有任务等待该信号量，因此唤醒这些等待者。
*/
up(&leds_lock);

这篇博文有对互斥量有更详细的讲解https://blog.csdn.net/liuxd3000/article/details/17913363

设备类的用法

static struct class *leds_class;
static struct class_device	*leds_class_devs[4];

/* 
class_create用于创建一个名为name的class,
其owner参数一般为THIS_MODULE。
class_create内部调用了class_register 
*/
leds_class = class_create(THIS_MODULE, "leds");

/* 
class_destroy用于删除一个class,
实际上其内部只是简单调用了class_unregister(cls)来注销cls 
*/
class_destroy(leds_class);

/*
class_device_create用于创建一个class_device,
其名称最后两个参数决定(类似于printf的格式化字符串)
*/
leds_class_devs[0] = class_device_create(leds_class, NULL, MKDEV(LED_MAJOR, 0), NULL, "leds"); /* /dev/leds */		


/* class_devic解除注册函数 */
class_device_unregister(leds_class_devs[minor]);

有关class更详细的解说请阅读：
https://blog.csdn.net/fantasy330/article/details/8879769

MKDEV()宏

形式：MKDEV(int major,int minor) major为主设备号 minor为次设备号

宏定义：#define MKDEV(major,minor) (((major) << MINORBITS) | (minor))

成功执行返回dev_t类型的设备编号，dev_t类型是unsigned int 类型，32位，用于在驱动程序中定义设备编号，高12位为主设备号，低20位为次设备号

可以通过MAJOR和MINOR来获得主设备号和次设备号。

unlikely()

if(unlikely(IS_ERR(leds_class_devs[minor])))
   return PTR_ERR(leds_class_devs[minor]);

首先明确：
if (likely(value))等价于if (value)
if (unlikely(value))等价于if (value)

也就是说likely()和unlikely()从阅读和理解的角度是一样的。
这两个宏在内核中定义如下：
#define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)
这里的__built_expect()函数是gcc(version >= 2.96)的内建函数,提供给程序员使用的，目的是将"分支转移"的信息提供给编译器，这样编译器对代码进行优化，以减少指令跳转带来的性能下降。
__buildin_expect((x), 1)表示x的值为真的可能性更大.
__buildin_expect((x), 0)表示x的值为假的可能性更大.
也就是说，使用likely(),执行if后面的语句的机会更大，使用unlikely(),执行else后面的语句机会更大一些。

通过这种方式，编译器在编译过程中，会将可能性更大的代码紧跟着后面的代码，从而减少指令跳转带来的性能上的下降。

IS_ERR 与 PTR_ERR

/*
判断leds_class指针有无错误，如果有错误，返回PTR_ERR(leds_class)
*/
IS_ERR(leds_class)
PTR_ERR(leds_class)

有关IS_ERR与PTR_ERR可阅读：
https://blog.csdn.net/ce123_zhouwei/article/details/8450618

cpu内存映射方式

static unsigned long gpio_va;

/*
#define ioremap(cookie,size)           __ioremap(cookie,size,0)
void __iomem * __ioremap(unsigned long phys_addr, size_t size, unsigned long flags);
phys_addr：要映射的起始的IO地址
size：要映射的空间的大小
flags：要映射的IO空间和权限有关的标志
该函数返回映射后的内核虚拟地址(3G-4G). 接着便可以通过读写该返回的内核虚拟地址去访问之这段I/O内存资源。
*/
gpio_va = ioremap(0x56000000, 0x100000);

/*
iounmap函数用于取消ioremap（）所做的映射，原型如下：
void iounmap(void * addr);
*/
iounmap(gpio_va);

参考文章：
https://www.cnblogs.com/kazuki/p/9341414.html

copy_from_user

copy_from_user和copy_to_user这两个函数相信做内核开发的人都非常熟悉，分别是将用户空间的数据拷贝到内核空间以及将内核空间中的数据拷贝到用户空间。这两个函数一般用于系统调用中，前者将用户空间参数拷贝到内核，后者将系统用的结果返回到用户空间。

参考自：
https://blog.csdn.net/liuhangtiant/article/details/85227125

深入了解 file_operations

以下内容参考自：
https://www.cnblogs.com/ganrui/p/4700895.html

__user

字串__user.这种注解是一种文档形式,注意,一个指针是一个不能被直接解引用的用户空间地址.对于正常的编译, __user没有效果,但是它可被外部检查软件使用来找出对用户空间地址的错误使用。

struct file

• struct file代表一个打开的文件，在执行file_operation中的open操作时被创建，这里需要注意的是与用户空间inode指针的区别，一个在内核，而file指针在用户空间，由c库来定义。

• struct file代表一个打开的文件，系统中的每个打开的文件在内核空间都有一个关联的struct file。它由内核在打开文件时创建，并传递给在文件上进行操作的任何函数。在文件的所有实例都关闭后，内核释放这个数据结构。在内核创建和驱动源码中，struct file的指针通常被命名为file或filp。

struct inode

• struct inode结构是用来在内核内部表示文件的.同一个文件可以被打开好多次,所以可以对应很多struct file,但是只对应一个struct inode
• struct inode包括很重要的二个成员：

dev_t       i_rdev   设备文件的设备号
struct cdev *i_cdev代表字符设备的数据结构

struct module *owner

它不是一个操作;它是一个指向拥有这个结构的模块的指针.这个成员用来在它的操作还在被使用时阻止模块被卸载.几乎所有时间中,它被简单初始化为THIS_MODULE

内核源码树

• 编写驱动程序时，需要内核源码树的支持。内核源码树时从内核源代码编译得到的。
• 注意：源码树内核的版本要和驱动程序运行的目标平台的内核版本一致

如何建立内核源码树，请阅读：
https://www.cnblogs.com/Daniel-G/p/3301985.html

从头开始写驱动代码

复制宏

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

定义设备名称与主设备号

#define DEVICE_NAME     "leds"  /* 加载模式后，执行”cat /proc/devices”命令看到的设备名称 */
#define LED_MAJOR       231     /* 主设备号 */

写出驱动框架

led驱动程序需要完成以下函数功能。

static int s3c24xx_leds_open(struct inode *inode, struct file *file)

static int s3c24xx_leds_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)

static ssize_t s3c24xx_leds_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)

static struct file_operations s3c24xx_leds_fops = {
    .owner  =   THIS_MODULE,    
    .open   =   s3c24xx_leds_open,     
	.read	=	s3c24xx_leds_read,	   
	.write	=	s3c24xx_leds_write,	   
};

static int __init s3c24xx_leds_init(void)

static void __exit s3c24xx_leds_exit(void)

module_init(s3c24xx_leds_init);
module_exit(s3c24xx_leds_exit);

首先完善注册函数

注册函数需要做的事：
1、映射内存
2、注册s3c24xx_leds_fops
3、创造设备类与设备

static unsigned long gpio_va;
static int __init s3c24xx_leds_init(void)
{
    //虚拟内存映射
	gpio_va = ioremap(0x56000000, 0x100000);
	if (!gpio_va) {
		return -EIO;
	}
	
	//注册s3c24xx_leds_fops 
    ret = register_chrdev(LED_MAJOR, DEVICE_NAME, &s3c24xx_leds_fops);
    if (ret < 0) {
      printk(DEVICE_NAME " can't register major number\n");
      return ret;
    }
    
    //创建leds类，如果返回的指针有问题就报错
	leds_class = class_create(THIS_MODULE, "leds");
	if (IS_ERR(leds_class))
		return PTR_ERR(leds_class);
		
    //创建设备
	leds_class_devs[0] = class_device_create(leds_class, NULL, MKDEV(LED_MAJOR, 0), NULL, "leds"); /* /dev/leds */
	
	for (minor = 1; minor < 4; minor++)  /* /dev/led1,2,3 */
	{
		leds_class_devs[minor] = class_device_create(leds_class, NULL, MKDEV(LED_MAJOR, minor), NULL, "led%d", minor);
		if (unlikely(IS_ERR(leds_class_devs[minor])))
			return PTR_ERR(leds_class_devs[minor]);
	}
        
    printk(DEVICE_NAME " initialized\n");
    return 0;
}

再完成卸载函数

static void __exit s3c24xx_leds_exit(void)
{
	int minor;
    /* 卸载驱动程序 */
    unregister_chrdev(LED_MAJOR, DEVICE_NAME);
    //删除设备
	for (minor = 0; minor < 4; minor++)
	{
		class_device_unregister(leds_class_devs[minor]);
	}
	//删除设备类
	class_destroy(leds_class);
	//取消内存映射
    iounmap(gpio_va);
}

完善open函数

• 确定open的inode来判断子设备号
• 根据子设备号来配置初始化引脚，并点亮对应led

static int s3c24xx_leds_open(struct inode *inode, struct file *file)
{
    //获取子设备号
	int minor = MINOR(inode->i_rdev); //MINOR(inode->i_cdev);
 
    //根据子设备号配置引脚，并点亮对应led
	switch(minor)
	{
        case 0: /* /dev/leds */
        {
            // 配置3引脚为输出
            //s3c2410_gpio_cfgpin(S3C2410_GPF4, S3C2410_GPF4_OUTP);
            GPFCON &= ~(0x3<<(4*2));
            GPFCON |= (1<<(4*2));
            
            //s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
            GPFCON &= ~(0x3<<(5*2));
            GPFCON |= (1<<(5*2));

            //s3c2410_gpio_cfgpin(S3C2410_GPF6, S3C2410_GPF6_OUTP);
            GPFCON &= ~(0x3<<(6*2));
            GPFCON |= (1<<(6*2));

            // 都输出0
            //s3c2410_gpio_setpin(S3C2410_GPF4, 0);
            GPFDAT &= ~(1<<4);
            
            //s3c2410_gpio_setpin(S3C2410_GPF5, 0);
            GPFDAT &= ~(1<<5);
            //s3c2410_gpio_setpin(S3C2410_GPF6, 0);
            GPFDAT &= ~(1<<6);

            down(&leds_lock);
            leds_status = 0x0;
            up(&leds_lock);
                
            break;
        }

        case 1: /* /dev/led1 */
        {
            s3c2410_gpio_cfgpin(S3C2410_GPF4, S3C2410_GPF4_OUTP);
            s3c2410_gpio_setpin(S3C2410_GPF4, 0);
            
            down(&leds_lock);
            leds_status &= ~(1<<0);
            up(&leds_lock);
            
            break;
        }

        case 2: /* /dev/led2 */
        {
            s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
            s3c2410_gpio_setpin(S3C2410_GPF5, 0);
            leds_status &= ~(1<<1);
            break;
        }

        case 3: /* /dev/led3 */
        {
            s3c2410_gpio_cfgpin(S3C2410_GPF6, S3C2410_GPF6_OUTP);
            s3c2410_gpio_setpin(S3C2410_GPF6, 0);

            down(&leds_lock);
            leds_status &= ~(1<<2);
            up(&leds_lock);
            
            break;
        }
        
	}
	
    return 0;
}

完善read函数

• 根据filp确定子设备号
• 根据子设备号来高速用户程序对应led灯的运行状态
• 使用copy_to_user来向用户空间传递数据

static int s3c24xx_leds_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)
{
	int minor = MINOR(filp->f_dentry->d_inode->i_rdev);
    char val;

    switch (minor)
    {
        case 0: /* /dev/leds */
        {
            
            copy_to_user(buff, (const void *)&leds_status, 1);                    
            break;
        }

        case 1: /* /dev/led1 */
        {
            down(&leds_lock);
            val = leds_status & 0x1;
            up(&leds_lock);
            copy_to_user(buff, (const void *)&val, 1);
            break;
        }

        case 2: /* /dev/led2 */
        {
            down(&leds_lock);
            val = (leds_status>>1) & 0x1;
            up(&leds_lock);
            copy_to_user(buff, (const void *)&val, 1);
            break;
        }

        case 3: /* /dev/led3 */
        {
            down(&leds_lock);
            val = (leds_status>>2) & 0x1;
            up(&leds_lock);
            copy_to_user(buff, (const void *)&val, 1);
            break;
        }
        
    }

    return 1;
}

完善write函数

• 根据file来确定子设备号
• 根据const char __user *buf来确定写入的数据
• 使用copy_from_user来从用户空间获取数据

static ssize_t s3c24xx_leds_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)
{
    //int minor = MINOR(inode->i_rdev); //MINOR(inode->i_cdev);
	int minor = MINOR(file->f_dentry->d_inode->i_rdev);
    char val;

    copy_from_user(&val, buf, 1);

    switch (minor)
    {
        case 0: /* /dev/leds */
        {            
            s3c2410_gpio_setpin(S3C2410_GPF4, (val & 0x1));
            s3c2410_gpio_setpin(S3C2410_GPF5, (val & 0x1));
            s3c2410_gpio_setpin(S3C2410_GPF6, (val & 0x1));
            down(&leds_lock);
            leds_status = val;
            up(&leds_lock);
            break;
        }

        case 1: /* /dev/led1 */
        {
            s3c2410_gpio_setpin(S3C2410_GPF4, val);

            if (val == 0)
            {
                down(&leds_lock);
                leds_status &= ~(1<<0);
                up(&leds_lock);
            }
            else
            {
                down(&leds_lock);
                leds_status |= (1<<0);                
                up(&leds_lock);
            }
            break;
        }

        case 2: /* /dev/led2 */
        {
            s3c2410_gpio_setpin(S3C2410_GPF5, val);
            if (val == 0)
            {
                down(&leds_lock);
                leds_status &= ~(1<<1);
                up(&leds_lock);
            }
            else
            {
                down(&leds_lock);
                leds_status |= (1<<1);                
                up(&leds_lock);
            }
            break;
        }

        case 3: /* /dev/led3 */
        {
            s3c2410_gpio_setpin(S3C2410_GPF6, val);
            if (val == 0)
            {
                down(&leds_lock);
                leds_status &= ~(1<<2);
                up(&leds_lock);
            }
            else
            {
                down(&leds_lock);
                leds_status |= (1<<2);                
                up(&leds_lock);
            }
            break;
        }
        
    }

    return 1;
}

最后放上与这个驱动有关的信息

/* 描述驱动程序的一些信息，不是必须的 */
MODULE_AUTHOR("http://www.100ask.net");
MODULE_VERSION("0.1.0");
MODULE_DESCRIPTION("S3C2410/S3C2440 LED Driver");
MODULE_LICENSE("GPL");

驱动测试程序

• 由于驱动程序已经直接创建好了设备文件，所以我们可以直接使用shell使用这些设备文件。
• 用户的open函数会根据要打开的设备文件返回一个fd，write或者read函数根据这个fd来判断主设备号，和子设备号，从而调用不同的驱动程序运行。

贴上宏

#include 
#include 
#include 
#include 

打印使用帮助子函数

void print_usage(char *file)
{
    printf("Usage:\n");
    printf("%s  \n",file);
    printf("eg. \n");
    printf("%s /dev/leds on\n", file);
    printf("%s /dev/leds off\n", file);
    printf("%s /dev/led1 on\n", file);
    printf("%s /dev/led1 off\n", file);
}

main函数

• argv[0]指向程序运行的全路径名
  argv[1]指向在DOS命令行中执行程序名后的第一个字符串
  argv[2]指向执行程序名后的第二个字符串
  argv[3]指向执行程序名后的第三个字符串
  argv[argc]为NULL

int main(int argc, char **argv)
{
    int fd;
    char* filename;
    char val;
    
    //如果传入参数不为3个打印使用帮助并返回
    if (argc != 3)
    {
        print_usage(argv[0]);
        return 0;
    }
    
    //确定文件路径
    filename = argv[1];

    //会创建一个file，然后调用驱动程序的open函数
    fd = open(filename, O_RDWR);
    if (fd < 0)
    {
        printf("error, can't open %s\n", filename);
        return 0;
    }

    //如果是on，则亮灯，否则灭灯
    if (!strcmp("on", argv[2]))
    {
        // 亮灯
        val = 0;
        write(fd, &val, 1);
    }
    else if (!strcmp("off", argv[2]))
    {
        // 灭灯
        val = 1;
        write(fd, &val, 1);
    }
    else
    {
        print_usage(argv[0]);
        return 0;
    }
    
    
    return 0;
}

Makefile解析

• 其中/work/system/linux-2.6.22.6是交叉编译环境下内核源码树的目录，需要根据实际情况进行修改
• 交叉编译环境安装好内核源码后，将KERN_DIR设置为内核源码目录
• 将驱动程序源码与Makefile放在一起，执行make，就可以生成.ko文件（obj-m指定依赖文件?）

KERN_DIR = /work/system/linux-2.6.22.6

all:
	make -C $(KERN_DIR) M=`pwd` modules 

clean:
	make -C $(KERN_DIR) M=`pwd` modules clean
	rm -rf modules.order

obj-m	+= myleds.o