devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Linux内核及驱动开发学习笔记（基于Exynos4412）

作者：知新_RL | 2024-05-16 07:51:43

赞

踩

Linux内核及驱动开发学习笔记（基于Exynos4412）

向内核添加新功能

静态加载法

即新功能源码与内核其它代码一起编译进uImage文件内

动态加载法

即新功能源码与内核其它源码不一起编译，而是独立编译成内核的插件（被称为内核模块）文件.ko

模块传参

module_param(name, type, perm); // 将指定的全局变量设置成模块参数

name：全局变量名
type：
    使用符号      实际类型                传参方式
    bool                bool                     insmod xxx.ko  变量名=0 或 1
    invbool           bool                     insmod xxx.ko  变量名=0 或 1
    charp             char *                   insmod xxx.ko  变量名="字符串内容"
    short              short                     insmod xxx.ko  变量名=数值
    int                    int                        insmod xxx.ko  变量名=数值
    long                long                      insmod xxx.ko  变量名=数值
    ushort         unsigned short         insmod xxx.ko  变量名=数值
    uint             unsigned int             insmod xxx.ko  变量名=数值
    ulong          unsigned long          insmod xxx.ko  变量名=数值
perm：给对应文件 /sys/module/name/parameters/变量名 指定操作权限
    #define S_IRWXU 00700
    #define S_IRUSR 00400
    #define S_IWUSR 00200
    #define S_IXUSR 00100
    #define S_IRWXG 00070
    #define S_IRGRP 00040
    #define S_IWGRP 00020
    #define S_IXGRP 00010
    #define S_IRWXO 00007
    #define S_IROTH 00004
    #define S_IWOTH 00002  //不要用 编译出错
    #define S_IXOTH 00001

module_param_array(name, type, &num, perm);

name、type、perm同module_param，type指数组中元素的类型
&num：存放数组大小变量的地址，可以填NULL（确保传参个数不越界）
传参方式 insmod xxx.ko  数组名=元素值0,元素值1,...元素值num-1  

示例代码

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3.  
  4. int gx = 10;
  5. char* gstr = "hello";
  6. int garr[5] = {1, 2, 3, 4, 5};
  7.  
  8. module_param(gx, int, 0664);
  9. module_param(gstr, charp, 0664);
  10. module_param_array(garr, int, NULL, 0664);
  11.  
  12.  
  13. int __init testparam_init(void)
  14. {
  15. 	int i = 0;
  16. 	printk("gx = %d\n", gx);
  17. 	printk("gstr = %s\n", gstr);
  18. 	
  19. 	for (i = 0; i < 5; i++) {
  20. 		printk("%d ", garr[i]);
  21. 	}
  22. 	printk("\n");
  23. 	return 0;
  24. }
  25.  
  26. void __exit testparam_exit(void)
  27. {
  28. 	printk("testparam will exit\n");
  29. }
  30.  
  31. MODULE_LICENSE("GPL");
  32.  
  33. module_init(testparam_init);
  34. module_exit(testparam_exit);

插ko：

  1. shrek@ubuntu16:~/share/mydrivercode$ sudo insmod ./testparam.ko
  2. shrek@ubuntu16:~/share/mydrivercode$ dmesg 
  3. [ 1167.269738] gx = 10
  4. [ 1167.269739] gstr = hello
  5. [ 1167.269739] 1 
  6. [ 1167.269739] 2 
  7. [ 1167.269740] 3 
  8. [ 1167.269740] 4 
  9. [ 1167.269740] 5 
  1. shrek@ubuntu16:~/share/mydrivercode$ sudo insmod ./testparam.ko gx=1000 gstr="hi" garr=5,6,7,8,9
  2. shrek@ubuntu16:~/share/mydrivercode$ sudo dmesg 
  3. [ 1145.753620] gx = 1000
  4. [ 1145.753621] gstr = hi
  5. [ 1145.753622] 5 
  6. [ 1145.753622] 6 
  7. [ 1145.753622] 7 
  8. [ 1145.753622] 8 
  9. [ 1145.753622] 9

模块依赖

既然内核模块的代码与其它内核代码共用统一的运行环境，也就是说模块只是存在形式上独立，运行上其实和内核其它源码是一个整体，它们隶属于同一个程序，因此一个模块或内核其它部分源码应该可以使用另一个模块的一些全局特性。

一个模块中这些可以被其它地方使用的名称被称为导出符号，所有导出符号被填在同一个表中这个表被称为符号表。

最常用的可导出全局特性为全局变量和函数

查看符号表的命令：nm
nm查看elf格式的可执行文件或目标文件中包含的符号表，用法：

nm  文件名  （可以通过man nm查看一些字母含义）

两个用于导出模块中符号名称的宏：

EXPORT_SYMBOL(函数名或全局变量名)
EXPORT_SYMBOL_GPL(函数名或全局变量名)   需要GPL许可证协议验证

使用导出符号的地方，需要对这些符号进行extern声明后才能使用这些符号

B模块使用了A模块导出的符号，此时称B模块依赖于A模块，则：

1. 编译次序：先编译模块A，再编译模块B，当两个模块源码在不同目录时，需要：i. 先编译导出符号的模块A ii. 拷贝A模块目录中的Module.symvers到B模块目录 iii. 编译使用符号的模块B。否则编译B模块时有符号未定义错误
2. 加载次序：先插入A模块，再插入B模块，否则B模块插入失败
3. 卸载次序：先卸载B模块，在卸载A模块，否则A模块卸载失败

补充说明：
内核符号表（直接当文本文件查看）

运行时可查看 /proc/kallsyms
编译后可查看 /boot/System.map

示例代码

moduleA.c：

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3.  
  4. int gx = 10;
  5. EXPORT_SYMBOL(gx);
  6.  
  7. int __init modulea_init(void)
  8. {
  9. 	printk("In moduleA init, gx = %d\n", gx);
  10. 	return 0;
  11. }
  12.  
  13. void __exit modulea_exit(void)
  14. {
  15. 	printk("modulea will exit\n");
  16. }
  17.  
  18. MODULE_LICENSE("GPL");
  19.  
  20. module_init(modulea_init);
  21. module_exit(modulea_exit);

moduleB.c：

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3.  
  4. extern int gx;
  5.  
  6. int __init moduleb_init(void)
  7. {
  8. 	printk("In moduleB init, gx = %d\n", gx);
  9. 	return 0;
  10. }
  11.  
  12. void __exit moduleb_exit(void)
  13. {
  14. 	printk("moduleb will exit\n");
  15. }
  16.  
  17. MODULE_LICENSE("GPL");
  18.  
  19. module_init(moduleb_init);
  20. module_exit(moduleb_exit);

Makefile（注意编译顺序）：

  1. ifeq ($(KERNELRELEASE),)
  2.  
  3. ifeq ($(ARCH),arm)
  4. KERNELDIR ?= /home/shrek/Linux_4412/kernel/linux-3.14
  5. ROOTFS ?= /opt/4412/rootfs
  6. else
  7. KERNELDIR ?= /lib/modules/$(shell uname -r)/build
  8. endif
  9. PWD := $(shell pwd)
  10.  
  11. modules:
  12. 	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
  13.  
  14. modules_install:
  15. 	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules INSTALL_MOD_PATH=$(ROOTFS) modules_install
  16.  
  17. clean:
  18. 	rm -rf  *.o  *.ko  .*.cmd  *.mod.*  modules.order  Module.symvers   .tmp_versions
  19.  
  20. else
  21. obj-m += moduleA.o
  22.  
  23. obj-m += moduleB.o
  24.  
  25. endif
  26.

插ko（注意插入顺序和卸载顺序）：

  1. shrek@ubuntu16:~/share/mydrivercode/twomodules$ sudo insmod ./moduleA.ko
  2. shrek@ubuntu16:~/share/mydrivercode/twomodules$ sudo insmod ./moduleB.ko
  3. shrek@ubuntu16:~/share/mydrivercode/twomodules$ sudo dmesg
  4. [ 8145.865709] In moduleA init, gx = 10
  5. [ 8147.510935] In moduleB init, gx = 10
  6. shrek@ubuntu16:~/share/mydrivercode/twomodules$ sudo rmmod moduleB
  7. shrek@ubuntu16:~/share/mydrivercode/twomodules$ sudo rmmod moduleA

内核空间和用户空间

为了彻底解决一个应用程序出错不影响系统和其它app的运行，操作系统给每个app一个独立的假想的地址空间，这个假想的地址空间被称为虚拟地址空间（也叫逻辑地址），操作系统也占用其中固定的一部分，32位Linux的虚拟地址空间大小为4G，并将其划分两部分：

1. 0~3G 用户空间 ：每个应用程序只能使用自己的这份虚拟地址空间

2. 3G~4G 内核空间：内核使用的虚拟地址空间，应用程序不能直接使用这份地址空间，但可以通过一些系统调用函数与其中的某些空间进行数据通信

实际内存操作时，需要将虚拟地址映射到实际内存的物理地址，然后才进行实际的内存读写

执行流

有开始有结束总体顺序执行的一段独立代码，又被称为代码上下文 

计算机系统中的执行流的分类：

任务流--任务上下文（都参与CPU时间片轮转，都有任务五状态：就绪态  运行态  睡眠态  僵死态  暂停态）
   1.  进程
   2.  线程
       内核线程：内核创建的线程
       应用线程：应用进程创建的线程

异常流--异常上下文
   1. 中断
   2. 其它异常

应用编程可能涉及到的执行流：

1. 进程
2. 线程     

内核编程可能涉及到的执行流：  

1. 应用程序自身代码运行在用户空间，处于用户态   -----------------  用户态app
2. 应用程序正在调用系统调用函数，运行在内核空间，处于内核态，即代码是内核代码但处于应用执行流（即属于一个应用进程或应用线程） -----------------  内核态app
3. 一直运行于内核空间，处于内核态，属于内核内的任务上下文 ----------------- 内核线程
4. 一直运行于内核空间，处于内核态，专门用来处理各种异常 ----------------- 异常上下文

模块编程与应用编程的比较

不同点内核模块应用程序
API来源不能使用任何库函数各种库函数均可以使用
运行空间内核空间用户空间
运行权限特权模式运行非特权模式运行
编译方式静态编译进内核镜像或编译特殊的ko文件elf格式的应用程序可执行文件
运行方式模块中的函数在需要时被动调用从main开始顺序执行
入口函数init_modulemain
退出方式cleanup_modulemain函数返回或调用exit
浮点支持一般不涉及浮点运算，因此printk不支持浮点数据支持浮点运算，printf可以打印浮点数据
并发考虑需要考虑多种执行流并发的竞态情况只需考虑多任务并行的竞态
程序出错可能会导致整个系统崩溃只会让自己崩溃

内核接口头文件查询

大部分API函数包含的头文件在include/linux目录下，因此：

1. 首先在 include/linux 查询指定函数：grep  名称  ./   -r   -n
2. 找不到则更大范围的 include 目录下查询，命令同上

字符设备驱动

linux的文件种类：

1. -：普通文件
2. d：目录文件
3. p：管道文件
4. s：本地socket文件
5. l：链接文件
6. c：字符设备
7. b：块设备

Linux内核按驱动程序实现模型框架的不同，将设备分为三类：

1. 字符设备：按字节流形式进行数据读写的设备，一般情况下按顺序访问，数据量不大，一般不设缓存
2. 块设备：按整块进行数据读写的设备，最小的块大小为512字节（一个扇区），块的大小必须是扇区的整数倍，Linux系统的块大小一般为4096字节，随机访问，设缓存以提高效率
3. 网络设备：针对网络数据收发的设备

设备号

内核中同类设备的区分

内核用设备号来区分同类里不同的设备，设备号是一个无符号32位整数，数据类型为dev_t，设备号分为两部分：

1. 主设备号：占高12位，用来表示驱动程序相同的一类设备
2. 次设备号：占低20位，用来表示被操作的哪个具体设备

应用程序打开一个设备文件时，通过设备号来查找定位内核中管理的设备。

MKDEV宏用来将主设备号和次设备号组合成32位完整的设备号，用法：

  1. dev_t devno;
  2. int major = 251; // 主设备号
  3. int minor = 2; // 次设备号
  4. devno = MKDEV(major,minor);

MAJOR宏用来从32位设备号中分离出主设备号，用法：

  1. dev_t devno = MKDEV(249,1);
  2. int major = MAJOR(devno);

MINOR宏用来从32位设备号中分离出次设备号，用法：

  1. dev_t devno = MKDEV(249,1);
  2. int minor = MINOR(devno);

如果已知一个设备的主次设备号，应用层指定好设备文件名，那么可以用mknod命令在/dev目录创建代表这个设备的文件，即此后应用程序对此文件的操作就是对其代表的设备操作，mknod用法如下：

  1. @ cd /dev
  2. @ mknod 设备文件名 设备种类(c为字符设备,b为块设备)  主设备号  次设备号    //ubuntu下需加sudo执行

在应用程序中如果要创建设备可以调用系统调用函数mknod，其原型如下：

int mknod(const char *pathname, mode_t mode, dev_t dev);

pathname：带路径的设备文件名，无路径默认为当前目录，一般都创建在/dev下
mode：文件权限 位或 S_IFCHR/S_IFBLK
dev：32位设备号
返回值：成功为0，失败-1

申请和注销设备号

字符驱动开发的第一步是通过模块的入口函数向内核添加本设备驱动的代码框架，主要完成：

1. 申请设备号
2. 定义、初始化、向内核添加代表本设备的结构体元素

int register_chrdev_region(dev_t from, unsigned count, const char *name)
功能：手动分配设备号，先验证设备号是否被占用，如果没有则申请占用该设备号
参数：
    from：自己指定的设备号
    count：申请的设备数量
    name：/proc/devices文件中与该设备对应的名字，方便用户层查询主设备号
返回值：
    成功为0，失败负数，绝对值为错误码


int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)
功能：动态分配设备号，查询内核里未被占用的设备号，如果找到则占用该设备号
参数：
    dev：分配设备号成功后用来存放分配到的设备号
    baseminior：起始的次设备号，一般为0
    count：申请的设备数量
    name：/proc/devices文件中与该设备对应的名字，方便用户层查询主次设备号
返回值：
    成功为0，失败负数，绝对值为错误码
 

分配成功后在/proc/devices 可以查看到申请到主设备号和对应的设备名，mknod时参数可以参考查到的此设备信息


void unregister_chrdev_region(dev_t from, unsigned count)
功能：释放设备号
参数：
    from：已成功分配的设备号将被释放
    count：申请成功的设备数量
 

释放后 /proc/devices 文件对应的记录消失

示例代码（申请和注销设备号）

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4.  
  5. int major = 11;
  6. int minor = 0;
  7. int mychar_num = 1;
  8.  
  9. int __init mychar_init(void)
  10. {
  11. 	int ret = 0;
  12. 	dev_t devno = MKDEV(major, minor);
  13.  
  14. 	ret = register_chrdev_region(devno, mychar_num, "mychar");
  15. 	if (ret) {
  16. 		ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
  17. 		if (ret) {
  18. 			printk("get devno faile\n");
  19. 			return -1;
  20. 		}
  21. 		major = MAJOR(devno);
  22. 	}
  23.  
  24. 	return 0;
  25. }
  26.  
  27. void __exit mychar_exit(void)
  28. {
  29. 	dev_t devno = MKDEV(major, minor);
  30. 	unregister_chrdev_region(devno, mychar_num);
  31. }
  32.  
  33.  
  34. MODULE_LICENSE("GPL");
  35.  
  36. module_init(mychar_init);
  37. module_exit(mychar_exit);

插ko之后可通过 /proc/devices 查看：

  1. shrek@ubuntu16:~/share/mydrivercode$ cat /proc/devices | grep mychar
  2.  11 mychar

注册字符设备

void cdev_init(struct cdev *cdev, const struct file_operations *fops)

cdev结构体

  1. struct cdev
  2. {
  3.     struct kobject kobj;//表示该类型实体是一种内核对象
  4.     struct module *owner;//填THIS_MODULE，表示该字符设备从属于哪个内核模块
  5.     const struct file_operations *ops;//指向空间存放着针对该设备的各种操作函数地址
  6.     struct list_head list;//链表指针域
  7.     dev_t dev;//设备号
  8.     unsigned int count;//设备数量
  9. };

1. 直接定义：定义结构体全局变量

2. 动态申请：struct  cdev * cdev_alloc()

file_operations结构体

  1. struct file_operations 
  2. {
  3.    struct module *owner;           //填THIS_MODULE，表示该结构体对象从属于哪个内核模块
  4.    int (*open) (struct inode *, struct file *);    //打开设备
  5.    int (*release) (struct inode *, struct file *);    //关闭设备
  6.    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);    //读设备
  7.    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);    //写设备
  8.    loff_t (*llseek) (struct file *, loff_t, int);        //定位
  9.    long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);//读写设备参数，读设备状态、控制设备
  10.    unsigned int (*poll) (struct file *, struct poll_table_struct *);    //POLL机制，实现多路复用的支持
  11.    int (*mmap) (struct file *, struct vm_area_struct *); //映射内核空间到用户层
  12.    int (*fasync) (int, struct file *, int); //信号驱动
  13.    //......
  14. };

一般定义一个struct file_operations类型的全局变量并用自己实现各种操作函数名对其进行初始化

int cdev_add(struct cdev *p, dev_t dev, unsigned int count)
功能：将指定字符设备添加到内核
参数：
    p：指向被添加的设备
    dev：设备号
    count：设备数量，一般填1

void cdev_del(struct cdev *p)
功能：从内核中移除一个字符设备
参数：
    p：指向被移除的字符设备

字符设备驱动开发步骤：

1.  如果设备有自己的一些控制数据，则定义一个包含struct cdev cdev成员的结构体struct mydev，其它成员根据设备需求，设备简单则直接用struct cdev
2.  定义一个struct mydev或struct cdev的全局变量来表示本设备；也可以定义一个struct mydev或struct cdev的全局指针（记得在init时动态分配）
3.  定义三个全局变量分别来表示主设备号、次设备号、设备数
4.  定义一个struct file_operations结构体变量，其owner成员置成THIS_MODULE
5.  module init函数流程：a. 申请设备号 b. 如果是全局设备指针则动态分配代表本设备的结构体元素 c. 初始化struct cdev成员 d. 设置struct cdev的owner成员为THIS_MODULE  e. 添加字符设备到内核
6.  module exit函数：a. 注销设备号 b. 从内核中移除struct cdev  c. 如果如果是全局设备指针则释放其指向空间
7.  编写各个操作函数并将函数名初始化给struct file_operations结构体变量

验证操作步骤：

1. 编写驱动代码mychar.c
2. make生成ko文件
3. insmod内核模块
4. 查阅字符设备用到的设备号（主设备号）：cat  /proc/devices  |  grep  申请设备号时用的名字
5. 创建设备文件（设备节点） ： mknod   /dev/???   c   上一步查询到的主设备号    代码中指定初始次设备号
6. 编写app验证驱动（testmychar_app.c）
7. 编译运行app，dmesg命令查看内核打印信息

示例代码（注册字符设备）

mychar.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/cdev.h>
  5.  
  6. int major = 11;
  7. int minor = 0;
  8. int mychar_num = 1;
  9.  
  10. struct cdev mydev;
  11.  
  12. int mychar_open(struct inode* pnode, struct file* pfile)
  13. {
  14. 	printk("mychar_open is called\n");
  15. 	return 0;
  16. }
  17.  
  18. int mychar_close(struct inode* pnode, struct file* pfile)
  19. {
  20. 	printk("mychar_close is called\n");
  21. 	return 0;
  22. }
  23.  
  24. struct file_operations myops = {
  25. 	.owner = THIS_MODULE,
  26. 	.open = mychar_open,
  27. 	.release = mychar_close,
  28. };
  29.  
  30. int __init mychar_init(void)
  31. {
  32. 	int ret = 0;
  33. 	dev_t devno = MKDEV(major, minor);
  34.  
  35. 	/* 申请设备号 */
  36. 	ret = register_chrdev_region(devno, mychar_num, "mychar");
  37. 	if (ret) {
  38. 		ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
  39. 		if (ret) {
  40. 			printk("get devno failed\n");
  41. 			return -1;
  42. 		}
  43. 		major = MAJOR(devno);
  44. 	}
  45.  
  46. 	/* 给struct cdev对象指定操作函数集 */
  47. 	cdev_init(&mydev, &myops);
  48.  
  49. 	/* 给struct cdev对象添加到内核对应的数据结构里 */
  50. 	mydev.owner = THIS_MODULE;
  51. 	cdev_add(&mydev, devno, mychar_num);
  52.  
  53. 	return 0;
  54. }
  55.  
  56. void __exit mychar_exit(void)
  57. {
  58. 	dev_t devno = MKDEV(major, minor);
  59. 	cdev_del(&mydev);
  60. 	unregister_chrdev_region(devno, mychar_num);
  61. }
  62.  
  63.  
  64. MODULE_LICENSE("GPL");
  65.  
  66. module_init(mychar_init);
  67. module_exit(mychar_exit);

test.c

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <unistd.h>
  5. #include <stdio.h>
  6.  
  7. int main(int argc, char* argv[])
  8. {
  9.     int fd = -1;
  10.  
  11.     if (argc < 2) {
  12.         printf("The argument is too few\n");
  13.         return 1;
  14.     }
  15.  
  16.     fd = open(argv[1], O_RDONLY);
  17.     if (fd < 0) {
  18.         printf("open %s failed\n", argv[1]);
  19.         return 2;
  20.     }
  21.  
  22.     close(fd);
  23.     fd = -1;
  24.     return 0;
  25. }

测试结果

  1. shrek@ubuntu16:~/share/mydrivercode$ sudo mknod /dev/mydev c 11 0
  2. shrek@ubuntu16:~/share/mydrivercode$ sudo insmod ./mychar.ko
  3. shrek@ubuntu16:~/share/mydrivercode$ ./a.out /dev/mydev 
  4. shrek@ubuntu16:~/share/mydrivercode$ dmesg 
  5. [11215.776355] mychar_open is called
  6. [11215.776358] mychar_close is called

两个操作函数中常用的结构体

内核中记录文件元信息的结构体

  1. struct inode
  2. {
  3.     //....
  4.     dev_t  i_rdev; // 设备号
  5.     struct cdev  *i_cdev; // 如果是字符设备才有此成员，指向对应设备驱动程序中的加入系统的struct cdev对象
  6.     //....
  7. }
  8. /*
  9.     1. 内核中每个该结构体对象对应着一个实际文件,一对一
  10.     2. open一个文件时如果内核中该文件对应的inode对象已存在则不再创建，不存在才创建
  11.     3. 内核中用此类型对象关联到对此文件的操作函数集（对设备而言就是关联到具体驱动代码）
  12. */

读写文件内容过程中用到的一些控制性数据组合而成的对象------文件操作引擎（文件操控器）

  1. struct file
  2. {
  3.     //...
  4.     mode_t f_mode; // 不同用户的操作权限，驱动一般不用
  5.     loff_t f_pos; // position 数据位置指示器，需要控制数据开始读写位置的设备有用
  6.     unsigned int f_flags; // open时的第二个参数flags存放在此，驱动中常用
  7.     struct file_operations *f_op; // open时从struct inode中i_cdev的对应成员获得地址，驱动开发中用来协助理解工作原理，内核中使用
  8.     void *private_data; // 本次打开文件的私有数据，驱动中常来在几个操作函数间传递共用数据
  9.     struct dentry *f_dentry; // 驱动中一般不用，除非需要访问对应文件的inode，用法flip->f_dentry->d_inode
  10.     int refcnt; // 引用计数，保存着该对象地址的位置个数，close时发现refcnt为0才会销毁该struct file对象
  11.     //...
  12. };
  13. /*
  14.     1. open函数被调用成功一次，则创建一个该对象，因此可以认为一个该类型的对象对应一次指定文件的操作
  15.     2. open同一个文件多次，每次open都会创建一个该类型的对象
  16.     3. 文件描述符数组中存放的地址指向该类型的对象
  17.     4. 每个文件描述符都对应一个struct file对象的地址
  18. */

常用操作函数说明

  1. int (*open) (struct inode *, struct file *);	//打开设备
  2. /*
  3. 	指向函数一般用来对设备进行硬件上的初始化，对于一些简单的设备该函数只需要return 0，对应open系统调用，是open系统调用函数实现过程中调用的函数,
  4. */
  5.  
  6. int (*release) (struct inode *, struct file *);	//关闭设备
  7. /*
  8. 	,指向函数一般用来对设备进行硬件上的关闭操作，对于一些简单的设备该函数只需要return 0，对应close系统调用，是close系统调用函数实现过程中调用的函数
  9. */
  10.  
  11. ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);	//读设备
  12. /*
  13. 	指向函数用来将设备产生的数据读到用户空间，对应read系统调用，是read系统调用函数实现过程中调用的函数
  14. */
  15.  
  16. ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);    //写设备
  17. /*
  18. 	指向函数用来将用户空间的数据写进设备，对应write系统调用，是write系统调用函数实现过程中调用的函数
  19. */
  20.  
  21. loff_t (*llseek) (struct file *, loff_t, int);		//数据操作位置的定位
  22. /*
  23. 	指向函数用来获取或设置设备数据的开始操作位置（位置指示器），对应lseek系统调用，是lseek系统调用函数实现过程中调用的函数
  24. */
  25.  
  26.  
  27. long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);//读写设备参数，读设备状态、控制设备
  28. /*
  29. 	指向函数用来获取、设置设备一些属性或设备的工作方式等非数据读写操作，对应ioctl系统调用，是ioctl系统调用函数实现过程中调用的函数
  30. */
  31.  
  32. unsigned int (*poll) (struct file *, struct poll_table_struct *);//POLL机制，实现对设备的多路复用方式的访问
  33. /*
  34. 	指向函数用来协助多路复用机制完成对本设备可读、可写数据的监控，对应select、poll、epoll_wait系统调用，是select、poll、epoll_wait系统调用函数实现过程中调用的函数
  35. */
  36.   
  37. int (*fasync) (int, struct file *, int); //信号驱动
  38. /*
  39. 	指向函数用来创建信号驱动机制的引擎，对应fcntl系统调用的FASYNC标记设置，是fcntl系统调用函数FASYNC标记设置过程中调用的函数
  40. */

读写操作实现

ssize_t xxx_read(struct file *filp, char __user *pbuf, size_t count, loff_t *ppos);
完成功能：读取设备产生的数据
参数：
    filp：指向open产生的struct file类型的对象，表示本次read对应的那次open
    pbuf：指向用户空间一块内存，用来保存读到的数据
    count：用户期望读取的字节数
    ppos：对于需要位置指示器控制的设备操作有用，用来指示读取的起始位置，读完后也需要变更位置指示器的指示位置
 返回值：
    本次成功读取的字节数，失败返回-1

内核空间拷贝到用户空间
put_user(x, ptr) // 宏
x：char、int类型的简单变量名

unsigned long copy_to_user (void __user * to, const void * from, unsigned long n)
成功为返回0，失败非0

ssize_t xxx_write (struct file *filp, const char __user *pbuf, size_t count, loff_t *ppos);  
完成功能：向设备写入数据
参数：
    filp：指向open产生的struct file类型的对象，表示本次write对应的那次open
    pbuf：指向用户空间一块内存，用来保存被写的数据
    count：用户期望写入的字节数
    ppos：对于需要位置指示器控制的设备操作有用，用来指示写入的起始位置，写完后也需要变更位置指示器的指示位置
 返回值：
    本次成功写入的字节数，失败返回-1

用户空间拷贝到内核空间
get_user(x, ptr) // 宏
x：char、int类型的简单变量名

unsigned long copy_from_user (void * to, const void __user * from, unsigned long n)
成功为返回0，失败非0

示例代码（读写操作）

mychar.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/cdev.h>
  5. #include <linux/uaccess.h>
  6.  
  7. #define BUF_LEN 100
  8.  
  9. int major = 11;
  10. int minor = 0;
  11. int mychar_num = 1;
  12.  
  13. struct cdev mydev;
  14.  
  15. char mydev_buf[BUF_LEN];
  16. int curlen = 0;
  17.  
  18. int mychar_open(struct inode* pnode, struct file* pfile)
  19. {
  20. 	printk("mychar_open is called\n");
  21. 	return 0;
  22. }
  23.  
  24. int mychar_close(struct inode* pnode, struct file* pfile)
  25. {
  26. 	printk("mychar_close is called\n");
  27. 	return 0;
  28. }
  29.  
  30. ssize_t mychar_read(struct file* pfile, char __user *puser, size_t count, loff_t* p_pos)
  31. {
  32. 	int size = 0;
  33. 	int ret = 0;
  34.  
  35. 	if (count > curlen) {
  36. 		size = curlen;
  37. 	} else {
  38. 		size = count;
  39. 	}
  40.  
  41. 	ret = copy_to_user(puser, mydev_buf, size);
  42. 	if (ret) {
  43. 		printk("copy_to_user failed\n");
  44. 		return -1;
  45. 	}
  46.  
  47. 	memcpy(mydev_buf, mydev_buf + size, curlen - size); // 将未读走的数据前移至buf头
  48.  
  49. 	curlen = curlen - size;
  50. 	return size;
  51. }
  52.  
  53. ssize_t mychar_write(struct file* pfile, const char __user *puser, size_t count, loff_t* p_pos)
  54. {
  55. 	int size = 0;
  56. 	int ret = 0;
  57.  
  58. 	if (count > BUF_LEN - curlen) {
  59. 		size = BUF_LEN - curlen;
  60. 	} else {
  61. 		size = count;
  62. 	}
  63.  
  64. 	ret = copy_from_user(mydev_buf + curlen, puser, size);
  65. 	if (ret) {
  66. 		printk("copy_from_user failed\n");
  67. 		return -1;
  68. 	}
  69.  
  70. 	curlen = curlen + size;
  71. 	return size;
  72. }
  73.  
  74. struct file_operations myops = {
  75. 	.owner = THIS_MODULE,
  76. 	.open = mychar_open,
  77. 	.release = mychar_close,
  78. 	.read = mychar_read,
  79. 	.write = mychar_write,
  80. };
  81.  
  82. int __init mychar_init(void)
  83. {
  84. 	int ret = 0;
  85. 	dev_t devno = MKDEV(major, minor);
  86.  
  87. 	/* 申请设备号 */
  88. 	ret = register_chrdev_region(devno, mychar_num, "mychar");
  89. 	if (ret) {
  90. 		ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
  91. 		if (ret) {
  92. 			printk("get devno failed\n");
  93. 			return -1;
  94. 		}
  95. 		major = MAJOR(devno);
  96. 	}
  97.  
  98. 	/* 给struct cdev对象指定操作函数集 */
  99. 	cdev_init(&mydev, &myops);
  100.  
  101. 	/* 给struct cdev对象添加到内核对应的数据结构里 */
  102. 	mydev.owner = THIS_MODULE;
  103. 	cdev_add(&mydev, devno, mychar_num);
  104.  
  105. 	return 0;
  106. }
  107.  
  108. void __exit mychar_exit(void)
  109. {
  110. 	dev_t devno = MKDEV(major, minor);
  111. 	cdev_del(&mydev);
  112. 	unregister_chrdev_region(devno, mychar_num);
  113. }
  114.  
  115.  
  116. MODULE_LICENSE("GPL");
  117.  
  118. module_init(mychar_init);
  119. module_exit(mychar_exit);

test.c

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <unistd.h>
  5. #include <stdio.h>
  6.  
  7. int main(int argc, char* argv[])
  8. {
  9.     int fd = -1;
  10.     char buf[8] = "";
  11.  
  12.     if (argc < 2) {
  13.         printf("The argument is too few\n");
  14.         return 1;
  15.     }
  16.  
  17.     fd = open(argv[1], O_RDWR);
  18.     if (fd < 0) {
  19.         printf("open %s failed\n", argv[1]);
  20.         return 2;
  21.     }
  22.  
  23.     write(fd, "hello", 6);
  24.     read(fd, buf, 8);
  25.     printf("buf = %s\n",buf);
  26.  
  27.     close(fd);
  28.     fd = -1;
  29.     return 0;
  30. }

测试结果

  1. shrek@ubuntu16:~/share/mydrivercode$ sudo mknod /dev/mydev c 11 0
  2. shrek@ubuntu16:~/share/mydrivercode$ sudo chmod a+w /dev/mydev
  3. shrek@ubuntu16:~/share/mydrivercode$ sudo insmod ./mychar.ko
  4. shrek@ubuntu16:~/share/mydrivercode$ ./a.out /dev/mydev 
  5. buf = hello

避免使用全局变量的写法

已知成员的地址获得所在结构体变量的地址：container_of(成员地址, 结构体类型名, 成员在结构体中的名称)

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/cdev.h>
  5. #include <linux/uaccess.h>
  6.  
  7. #define BUF_LEN 100
  8.  
  9. int major = 11;
  10. int minor = 0;
  11. int mychar_num = 1;
  12.  
  13. struct mychar_dev
  14. {
  15. 	struct cdev mydev;
  16.  
  17. 	char mydev_buf[BUF_LEN];
  18. 	int curlen;
  19. };
  20.  
  21. struct mychar_dev gmydev;
  22.  
  23. int mychar_open(struct inode* pnode, struct file* pfile)
  24. {
  25. 	pfile->private_data = (void *)(container_of(pnode->i_cdev, struct mychar_dev, mydev));
  26. 	printk("mychar_open is called\n");
  27. 	return 0;
  28. }
  29.  
  30. int mychar_close(struct inode* pnode, struct file* pfile)
  31. {
  32. 	printk("mychar_close is called\n");
  33. 	return 0;
  34. }
  35.  
  36. ssize_t mychar_read(struct file* pfile, char __user *puser, size_t count, loff_t* p_pos)
  37. {
  38. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  39. 	int size = 0;
  40. 	int ret = 0;
  41.  
  42. 	if (count > pmydev->curlen) {
  43. 		size = pmydev->curlen;
  44. 	} else {
  45. 		size = count;
  46. 	}
  47.  
  48. 	ret = copy_to_user(puser, pmydev->mydev_buf, size);
  49. 	if (ret) {
  50. 		printk("copy_to_user failed\n");
  51. 		return -1;
  52. 	}
  53.  
  54. 	memcpy(pmydev->mydev_buf, pmydev->mydev_buf + size, pmydev->curlen - size);
  55.  
  56. 	pmydev->curlen -= size;
  57. 	return size;
  58. }
  59.  
  60. ssize_t mychar_write(struct file* pfile, const char __user *puser, size_t count, loff_t* p_pos)
  61. {
  62. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  63. 	int size = 0;
  64. 	int ret = 0;
  65.  
  66. 	if (count > BUF_LEN - pmydev->curlen) {
  67. 		size = BUF_LEN - pmydev->curlen;
  68. 	} else {
  69. 		size = count;
  70. 	}
  71.  
  72. 	ret = copy_from_user(pmydev->mydev_buf + pmydev->curlen, puser, size);
  73. 	if (ret) {
  74. 		printk("copy_from_user failed\n");
  75. 		return -1;
  76. 	}
  77.  
  78. 	pmydev->curlen += size;
  79. 	return size;
  80. }
  81.  
  82. struct file_operations myops = {
  83. 	.owner = THIS_MODULE,
  84. 	.open = mychar_open,
  85. 	.release = mychar_close,
  86. 	.read = mychar_read,
  87. 	.write = mychar_write,
  88. };
  89.  
  90. int __init mychar_init(void)
  91. {
  92. 	int ret = 0;
  93. 	dev_t devno = MKDEV(major, minor);
  94.  
  95. 	/* 申请设备号 */
  96. 	ret = register_chrdev_region(devno, mychar_num, "mychar");
  97. 	if (ret) {
  98. 		ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
  99. 		if (ret) {
  100. 			printk("get devno faile\n");
  101. 			return -1;
  102. 		}
  103. 		major = MAJOR(devno);
  104. 	}
  105.  
  106. 	/* 给struct cdev对象指定操作函数集 */
  107. 	cdev_init(&gmydev.mydev, &myops);
  108.  
  109. 	/* 给struct cdev对象添加到内核对应的数据结构里 */
  110. 	gmydev.mydev.owner = THIS_MODULE;
  111. 	cdev_add(&gmydev.mydev, devno, mychar_num);
  112.  
  113. 	return 0;
  114. }
  115.  
  116. void __exit mychar_exit(void)
  117. {
  118. 	dev_t devno = MKDEV(major, minor);
  119. 	cdev_del(&gmydev.mydev);
  120. 	unregister_chrdev_region(devno, mychar_num);
  121. }
  122.  
  123.  
  124. MODULE_LICENSE("GPL");
  125.  
  126. module_init(mychar_init);
  127. module_exit(mychar_exit);

ioctl操作实现

long xxx_ioctl (struct file *filp, unsigned int cmd, unsigned long arg);
功能：对相应设备做指定的控制操作（各种属性的设置获取等等）
参数：
    filp：指向open产生的struct file类型的对象，表示本次ioctl对应的那次open
    cmd：用来表示做的是哪一个操作
    arg：和cmd配合用的参数
返回值：成功为0，失败-1

cmd组成

1. dir（direction），ioctl 命令访问模式（属性数据传输方向），占据 2 bit，可以为 _IOC_NONE、_IOC_READ、_IOC_WRITE、_IOC_READ | _IOC_WRITE，分别指示了四种访问模式：无数据、读数据、写数据、读写数据；
2. type（device type），设备类型，占据 8 bit，在一些文献中翻译为 “幻数” 或者 “魔数”，可以为任意 char 型字符，例如 
   ‘a’、’b’、’c’ 等等，其主要作用是使 ioctl 命令有唯一的设备标识；
3. nr（number），命令编号/序数，占据 8 bit，可以为任意 unsigned char 型数据，取值范围 0~255，如果定义了多个 ioctl 命令，通常从 0 开始编号递增；
4. size，涉及到 ioctl 函数 第三个参数 arg ，占据 13bit 或者 14bit（体系相关，arm 架构一般为 14 位），指定了 arg 的数据类型及长度，如果在驱动的 ioctl 实现中不检查，通常可以忽略该参数；

  1. #define _IOC(dir,type,nr,size) (((dir)<<_IOC_DIRSHIFT)| \
  2.                                ((type)<<_IOC_TYPESHIFT)| \
  3.                                ((nr)<<_IOC_NRSHIFT)| \
  4.                                ((size)<<_IOC_SIZESHIFT))
  5. /* used to create numbers */
  6.  
  7. // 定义不带参数的 ioctl 命令
  8. #define _IO(type,nr)   _IOC(_IOC_NONE,(type),(nr),0)
  9.  
  10. //定义带读参数的ioctl命令（copy_to_user） size为类型名
  11. #define _IOR(type,nr,size)  _IOC(_IOC_READ,(type),(nr),(_IOC_TYPECHECK(size)))
  12.  
  13. //定义带写参数的 ioctl 命令（copy_from_user） size为类型名
  14. #define _IOW(type,nr,size)  _IOC(_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
  15.  
  16. //定义带读写参数的 ioctl 命令 size为类型名
  17. #define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
  18.  
  19. /* used to decode ioctl numbers */
  20. #define _IOC_DIR(nr)        (((nr) >> _IOC_DIRSHIFT) & _IOC_DIRMASK)
  21. #define _IOC_TYPE(nr)       (((nr) >> _IOC_TYPESHIFT) & _IOC_TYPEMASK)
  22. #define _IOC_NR(nr)     (((nr) >> _IOC_NRSHIFT) & _IOC_NRMASK)
  23. #define _IOC_SIZE(nr)      (((nr) >> _IOC_SIZESHIFT) & _IOC_SIZEMASK)

示例代码（ioctl操作）

mychar.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/cdev.h>
  5. #include <linux/uaccess.h>
  6.  
  7. #include "mychar.h"
  8.  
  9. #define BUF_LEN 100
  10.  
  11. int major = 11;
  12. int minor = 0;
  13. int mychar_num = 1;
  14.  
  15. struct mychar_dev
  16. {
  17. 	struct cdev mydev;
  18.  
  19. 	char mydev_buf[BUF_LEN];
  20. 	int curlen;
  21. };
  22.  
  23. struct mychar_dev gmydev;
  24.  
  25. int mychar_open(struct inode* pnode, struct file* pfile)
  26. {
  27. 	pfile->private_data = (void *)(container_of(pnode->i_cdev, struct mychar_dev, mydev));
  28. 	printk("mychar_open is called\n");
  29. 	return 0;
  30. }
  31.  
  32. int mychar_close(struct inode* pnode, struct file* pfile)
  33. {
  34. 	printk("mychar_close is called\n");
  35. 	return 0;
  36. }
  37.  
  38. ssize_t mychar_read(struct file* pfile, char __user *puser, size_t count, loff_t* p_pos)
  39. {
  40. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  41. 	int size = 0;
  42. 	int ret = 0;
  43.  
  44. 	if (count > pmydev->curlen) {
  45. 		size = pmydev->curlen;
  46. 	} else {
  47. 		size = count;
  48. 	}
  49.  
  50. 	ret = copy_to_user(puser, pmydev->mydev_buf, size);
  51. 	if (ret) {
  52. 		printk("copy_to_user failed\n");
  53. 		return -1;
  54. 	}
  55.  
  56. 	memcpy(pmydev->mydev_buf, pmydev->mydev_buf + size, pmydev->curlen - size);
  57.  
  58. 	pmydev->curlen -= size;
  59. 	return size;
  60. }
  61.  
  62. ssize_t mychar_write(struct file* pfile, const char __user *puser, size_t count, loff_t* p_pos)
  63. {
  64. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  65. 	int size = 0;
  66. 	int ret = 0;
  67.  
  68. 	if (count > BUF_LEN - pmydev->curlen) {
  69. 		size = BUF_LEN - pmydev->curlen;
  70. 	} else {
  71. 		size = count;
  72. 	}
  73.  
  74. 	ret = copy_from_user(pmydev->mydev_buf + pmydev->curlen, puser, size);
  75. 	if (ret) {
  76. 		printk("copy_from_user failed\n");
  77. 		return -1;
  78. 	}
  79.  
  80. 	pmydev->curlen += size;
  81. 	return size;
  82. }
  83.  
  84. long mychar_ioctl(struct file* pfile, unsigned int cmd, unsigned long arg)
  85. {
  86. 	int __user *pret = (int*)arg;
  87. 	int maxlen = BUF_LEN;
  88. 	int ret = 0;
  89. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  90.  
  91. 	switch (cmd) {
  92. 		case MYCHAR_IOCTL_GET_MAXLEN:
  93. 			ret = copy_to_user(pret, &maxlen, sizeof(int));
  94. 			if (ret) {
  95. 				printk("copy_to_user MAXLEN failed\n");
  96. 				return -1;
  97. 			}
  98. 			break;
  99. 		case MYCHAR_IOCTL_GET_CURLEN:
  100. 			ret = copy_to_user(pret, &pmydev->curlen, sizeof(int));
  101. 			if (ret) {
  102. 				printk("copy_to_user CURLEN failed\n");
  103. 				return -1;
  104. 			}
  105. 			break;
  106. 		default:
  107. 			printk("The cmd is unknow\n");
  108. 			return -1;
  109. 	}
  110. 	return 0;
  111. }
  112.  
  113. struct file_operations myops = {
  114. 	.owner = THIS_MODULE,
  115. 	.open = mychar_open,
  116. 	.release = mychar_close,
  117. 	.read = mychar_read,
  118. 	.write = mychar_write,
  119. 	.unlocked_ioctl = mychar_ioctl,
  120. };
  121.  
  122. int __init mychar_init(void)
  123. {
  124. 	int ret = 0;
  125. 	dev_t devno = MKDEV(major, minor);
  126.  
  127. 	/* 申请设备号 */
  128. 	ret = register_chrdev_region(devno, mychar_num, "mychar");
  129. 	if (ret) {
  130. 		ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
  131. 		if (ret) {
  132. 			printk("get devno failed\n");
  133. 			return -1;
  134. 		}
  135. 		major = MAJOR(devno);
  136. 	}
  137.  
  138. 	/* 给struct cdev对象指定操作函数集 */
  139. 	cdev_init(&gmydev.mydev, &myops);
  140.  
  141. 	/* 给struct cdev对象添加到内核对应的数据结构里 */
  142. 	gmydev.mydev.owner = THIS_MODULE;
  143. 	cdev_add(&gmydev.mydev, devno, mychar_num);
  144.  
  145. 	return 0;
  146. }
  147.  
  148. void __exit mychar_exit(void)
  149. {
  150. 	dev_t devno = MKDEV(major, minor);
  151. 	cdev_del(&gmydev.mydev);
  152. 	unregister_chrdev_region(devno, mychar_num);
  153. }
  154.  
  155.  
  156. MODULE_LICENSE("GPL");
  157.  
  158. module_init(mychar_init);
  159. module_exit(mychar_exit);

mychar.h

  1. #ifndef MY_CHAR_H
  2. #define MY_CHAR_H
  3.  
  4. #include <asm/ioctl.h>
  5.  
  6. #define MY_CHAR_MAGIC 'k'
  7.  
  8. #define MYCHAR_IOCTL_GET_MAXLEN _IOR(MY_CHAR_MAGIC,1,int*)
  9. #define MYCHAR_IOCTL_GET_CURLEN _IOR(MY_CHAR_MAGIC,2,int*)
  10.  
  11.  
  12. #endif

test.c

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <unistd.h>
  5. #include <stdio.h>
  6. #include <sys/ioctl.h>
  7.  
  8. #include "mychar.h"
  9.  
  10. int main(int argc, char* argv[])
  11. {
  12.     int fd = -1;
  13.     char buf[8] = "";
  14.     int max = 0;
  15.     int cur = 0;
  16.  
  17.     if (argc < 2) {
  18.         printf("The argument is too few\n");
  19.         return 1;
  20.     }
  21.  
  22.     fd = open(argv[1], O_RDWR);
  23.     if (fd < 0) {
  24.         printf("open %s failed\n", argv[1]);
  25.         return 2;
  26.     }
  27.  
  28.     ioctl(fd, MYCHAR_IOCTL_GET_MAXLEN, &max);
  29.     printf("max len is %d\n", max);
  30.  
  31.     write(fd, "hello", 6);
  32.  
  33.     ioctl(fd, MYCHAR_IOCTL_GET_CURLEN, &cur);
  34. 	printf("cur len is %d\n",cur);
  35.  
  36.     read(fd, buf, 8);
  37.     printf("buf = %s\n",buf);
  38.  
  39.     close(fd);
  40.     fd = -1;
  41.     return 0;
  42. }

测试结果

  1. shrek@ubuntu16:~/share/mydrivercode$ sudo mknod /dev/mydev c 11 0
  2. shrek@ubuntu16:~/share/mydrivercode$ sudo insmod ./mychar.ko
  3. shrek@ubuntu16:~/share/mydrivercode$ ./a.out /dev/mydev 
  4. max len is 100
  5. cur len is 6
  6. buf = hello

printk

  1. //日志级别
  2. #define    KERN_EMERG    "<0>"    /* system is unusable            */
  3. #define    KERN_ALERT    "<1>"    /* action must be taken immediately    */
  4. #define    KERN_CRIT    "<2>"    /* critical conditions            */
  5. #define    KERN_ERR    "<3>"    /* error conditions            */
  6.  
  7. #define    KERN_WARNING    "<4>"    /* warning conditions            */
  8.  
  9. #define    KERN_NOTICE    "<5>"    /* normal but significant condition    */
  10. #define    KERN_INFO    "<6>"    /* informational            */
  11. #define    KERN_DEBUG    "<7>"    /* debug-level messages            */

用法：printk(KERN_INFO"....",....)
printk(KERN_INFO"Hello World"); =====> printk("<6>""Hello World") ====> printk("<6>Hello World")

指定 dmesg 打印的内容：dmesg --level=emerg,alert,crit,err,warn,notice,info,debug

自定义标签：

  1. #define HELLO_DEBUG
  2. #undef PDEBUG
  3. #ifdef HELLO_DEBUG
  4. #define PDEBUG(fmt, args...) printk(KERN_DEBUG fmt, ##args)
  5. #else
  6. #define PDEBUG(fmt, args...)
  7. #endif

阻塞和非阻塞

应用层：

方法一：open时由 O_NONBLOCK 指示read、write时是否阻塞

方法二：open以后可以由fcntl函数来改变是否阻塞：

  1. flags = fcntl(fd, F_GETFL, 0);
  2. flags |= O_NONBLOCK;
  3. fcntl(fd, F_SETFL, flags);

驱动层：

通过等待队列

  1. wait_queue_head_t //等待队列头数据类型
  2.  
  3. init_waitqueue_head(wait_queue_head_t *pwq) //初始化等待队列头
  4.     
  5. wait_event_interruptible(wq,condition)
  6. /*
  7. 功能：条件不成立则让任务进入浅度睡眠，直到条件成立醒来
  8.     wq:等待队列头
  9.     condition：C语言表达式
  10. 返回：正常唤醒返回0，信号唤醒返回非0（此时读写操作函数应返回-ERESTARTSYS）
  11. */
  12.         
  13. wait_event(wq,condition) //深度睡眠
  14.  
  15. wake_up_interruptible(wait_queue_head_t *pwq)
  16.         
  17. wake_up(wait_queue_head_t *pwq)
  18.     
  19.     
  20. /*
  21. 1. 读、写用不同的等待队列头rq、wq
  22. 2. 无数据可读、可写时调用wait_event_interruptible(rq、wq,条件)
  23. 3. 写入数据成功时唤醒rq，读出数据成功唤醒wq
  24. */

示例代码（阻塞和非阻塞）

mychar.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/cdev.h>
  5. #include <linux/wait.h>
  6. #include <linux/sched.h>
  7. #include <linux/uaccess.h>
  8.  
  9. #include "mychar.h"
  10.  
  11. #define BUF_LEN 100
  12.  
  13. int major = 11;
  14. int minor = 0;
  15. int mychar_num = 1;
  16.  
  17. struct mychar_dev
  18. {
  19. 	struct cdev mydev;
  20.  
  21. 	char mydev_buf[BUF_LEN];
  22. 	int curlen;
  23.  
  24. 	wait_queue_head_t rq;
  25. 	wait_queue_head_t wq;
  26. };
  27.  
  28. struct mychar_dev gmydev;
  29.  
  30. int mychar_open(struct inode* pnode, struct file* pfile)
  31. {
  32. 	pfile->private_data = (void *)(container_of(pnode->i_cdev, struct mychar_dev, mydev));
  33. 	printk("mychar_open is called\n");
  34. 	return 0;
  35. }
  36.  
  37. int mychar_close(struct inode* pnode, struct file* pfile)
  38. {
  39. 	printk("mychar_close is called\n");
  40. 	return 0;
  41. }
  42.  
  43. ssize_t mychar_read(struct file* pfile, char __user *puser, size_t count, loff_t* p_pos)
  44. {
  45. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  46. 	int size = 0;
  47. 	int ret = 0;
  48.  
  49. 	if (pmydev->curlen <= 0) {
  50. 		if (pfile->f_flags & O_NONBLOCK) {
  51. 			// 非阻塞
  52. 			printk("O_NONBLOCK No Data Read\n");
  53. 			return -1;
  54. 		} else {
  55. 			// 阻塞
  56. 			ret = wait_event_interruptible(pmydev->rq, pmydev->curlen > 0);
  57. 			if (ret) {
  58. 				printk("Wake up by signal\n");
  59. 				return -ERESTARTSYS;
  60. 			}
  61. 		}
  62. 	}
  63.  
  64. 	if (count > pmydev->curlen) {
  65. 		size = pmydev->curlen;
  66. 	} else {
  67. 		size = count;
  68. 	}
  69.  
  70. 	ret = copy_to_user(puser, pmydev->mydev_buf, size);
  71. 	if (ret) {
  72. 		printk("copy_to_user failed\n");
  73. 		return -1;
  74. 	}
  75.  
  76. 	memcpy(pmydev->mydev_buf, pmydev->mydev_buf + size, pmydev->curlen - size);
  77.  
  78. 	pmydev->curlen -= size;
  79.  
  80. 	wake_up_interruptible(&pmydev->wq);
  81.  
  82. 	return size;
  83. }
  84.  
  85. ssize_t mychar_write(struct file* pfile, const char __user *puser, size_t count, loff_t* p_pos)
  86. {
  87. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  88. 	int size = 0;
  89. 	int ret = 0;
  90.  
  91. 	if (pmydev->curlen >= BUF_LEN) {
  92. 		if (pfile->f_flags & O_NONBLOCK) {
  93. 			printk("O_NONBLOCK Can not write data\n");
  94. 			return -1;
  95. 		} else {
  96. 			ret = wait_event_interruptible(pmydev->wq, pmydev->curlen < BUF_LEN);
  97. 			if (ret) {
  98. 				printk("Wake up by signal\n");
  99. 				return -ERESTARTSYS;
  100. 			}
  101. 		}
  102. 	}
  103.  
  104. 	if (count > BUF_LEN - pmydev->curlen) {
  105. 		size = BUF_LEN - pmydev->curlen;
  106. 	} else {
  107. 		size = count;
  108. 	}
  109.  
  110. 	ret = copy_from_user(pmydev->mydev_buf + pmydev->curlen, puser, size);
  111. 	if (ret) {
  112. 		printk("copy_from_user failed\n");
  113. 		return -1;
  114. 	}
  115.  
  116. 	pmydev->curlen += size;
  117.  
  118. 	wake_up_interruptible(&pmydev->rq);
  119.  
  120. 	return size;
  121. }
  122.  
  123. long mychar_ioctl(struct file* pfile, unsigned int cmd, unsigned long arg)
  124. {
  125. 	int __user *pret = (int*)arg;
  126. 	int maxlen = BUF_LEN;
  127. 	int ret = 0;
  128. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  129.  
  130. 	switch (cmd) {
  131. 		case MYCHAR_IOCTL_GET_MAXLEN:
  132. 			ret = copy_to_user(pret, &maxlen, sizeof(int));
  133. 			if (ret) {
  134. 				printk("copy_to_user MAXLEN failed\n");
  135. 				return -1;
  136. 			}
  137. 			break;
  138. 		case MYCHAR_IOCTL_GET_CURLEN:
  139. 			ret = copy_to_user(pret, &pmydev->curlen, sizeof(int));
  140. 			if (ret) {
  141. 				printk("copy_to_user CURLEN failed\n");
  142. 				return -1;
  143. 			}
  144. 			break;
  145. 		default:
  146. 			printk("The cmd is unknow\n");
  147. 			return -1;
  148. 	}
  149. 	return 0;
  150. }
  151.  
  152. struct file_operations myops = {
  153. 	.owner = THIS_MODULE,
  154. 	.open = mychar_open,
  155. 	.release = mychar_close,
  156. 	.read = mychar_read,
  157. 	.write = mychar_write,
  158. 	.unlocked_ioctl = mychar_ioctl,
  159. };
  160.  
  161. int __init mychar_init(void)
  162. {
  163. 	int ret = 0;
  164. 	dev_t devno = MKDEV(major, minor);
  165.  
  166. 	/* 申请设备号 */
  167. 	ret = register_chrdev_region(devno, mychar_num, "mychar");
  168. 	if (ret) {
  169. 		ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
  170. 		if (ret) {
  171. 			printk("get devno failed\n");
  172. 			return -1;
  173. 		}
  174. 		major = MAJOR(devno);
  175. 	}
  176.  
  177. 	/* 给struct cdev对象指定操作函数集 */
  178. 	cdev_init(&gmydev.mydev, &myops);
  179.  
  180. 	/* 给struct cdev对象添加到内核对应的数据结构里 */
  181. 	gmydev.mydev.owner = THIS_MODULE;
  182. 	cdev_add(&gmydev.mydev, devno, mychar_num);
  183.  
  184. 	init_waitqueue_head(&gmydev.rq);
  185. 	init_waitqueue_head(&gmydev.wq);
  186. 	return 0;
  187. }
  188.  
  189. void __exit mychar_exit(void)
  190. {
  191. 	dev_t devno = MKDEV(major, minor);
  192. 	cdev_del(&gmydev.mydev);
  193. 	unregister_chrdev_region(devno, mychar_num);
  194. }
  195.  
  196.  
  197. MODULE_LICENSE("GPL");
  198.  
  199. module_init(mychar_init);
  200. module_exit(mychar_exit);

mychar.h同ioctl

test.c（测试非阻塞，如果测试阻塞则将 O_NONBLOCK 去掉即可）

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <unistd.h>
  5. #include <stdio.h>
  6. #include <sys/ioctl.h>
  7.  
  8. #include "mychar.h"
  9.  
  10. int main(int argc, char* argv[])
  11. {
  12.     int fd = -1;
  13.     char buf[8] = "";
  14.     int ret = 0;
  15.  
  16.     if (argc < 2) {
  17.         printf("The argument is too few\n");
  18.         return 1;
  19.     }
  20.  
  21.     fd = open(argv[1], O_RDWR | O_NONBLOCK);
  22.     if (fd < 0) {
  23.         printf("open %s failed\n", argv[1]);
  24.         return 2;
  25.     }
  26.  
  27.     ret = read(fd, buf, 8);
  28.     if (ret < 0) {
  29.         printf("read data failed\n");
  30.     } else {
  31.         printf("buf = %s\n",buf);
  32.     }
  33.  
  34.     close(fd);
  35.     fd = -1;
  36.     return 0;
  37. }

测试结果

非阻塞：

  1. shrek@ubuntu16:~/share/mydrivercode$ sudo mknod /dev/mydev c 11 0
  2. shrek@ubuntu16:~/share/mydrivercode$ sudo chmod a+w /dev/mydev
  3. shrek@ubuntu16:~/share/mydrivercode$ sudo insmod ./mychar.ko
  4. shrek@ubuntu16:~/share/mydrivercode$ ./a.out /dev/mydev 
  5. read data failed

阻塞：

执行测试代码一直阻塞，直至给设备写入数据结束阻塞

  1. shrek@ubuntu16:~/share/mydrivercode$ echo "hello" > /dev/mydev
  2. shrek@ubuntu16:~/share/mydrivercode$ ./a.out /dev/mydev 
  3. buf = hello

多路复用

应用层

select：位运算实现，监控的描述符数量有限（32位机1024，64位机2048），效率差
poll：链表实现，监控的描述符数量不限，效率差
epoll：效率最高，监控的描述符数量不限

select：

  1. int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
  2. /*	功能：监听多个描述符，阻塞等待有一个或者多个文件描述符，准备就绪。
  3. 		内核将没有准备就绪的文件描述符，从集合中清掉了。
  4. 	参数：  nfds			最大文件描述符数 ，加1
  5. 			readfds		读文件描述符集合
  6. 			writefds		写文件描述符集合
  7. 			exceptfds		其他异常的文件描述符集合
  8. 			timeout		超时时间（NULL）
  9. 	返回值：当timeout为NULL时返回0，成功:准备好的文件描述的个数  出错:-1 
  10. 		   当timeout不为NULL时，如超时设置为0，则select为非阻塞，超时设置 > 0，则无描述符可被操作的情况下阻塞指定长度的时间 
  11. */
  12. void FD_CLR(int fd, fd_set *set);
  13. //功能：将fd 从集合中清除掉
  14.  
  15. int  FD_ISSET(int fd, fd_set *set);
  16. //功能：判断fd 是否存在于集合中
  17.  
  18. void FD_SET(int fd, fd_set *set);
  19. //功能：将fd 添加到集合中
  20.  
  21. void FD_ZERO(fd_set *set);
  22. //功能：将集合清零
  23.  
  24. //使用模型:
  25.  
  26. while(1)
  27. {
  28.     /*得到最大的描述符maxfd*/
  29.     /*FD_ZERO清空描述符集合*/
  30. 	/*将被监控描述符加到相应集合rfds里  FD_SET*/
  31.     /*设置超时*/
  32.     ret = select(maxfd+1,&rfds,&wfds,NULL,NULL);
  33.     if(ret < 0)
  34.     {
  35.         if(errno == EINTR)//错误时信号引起的
  36.         {
  37.         	continue;   
  38.         }
  39.         else
  40.         {
  41.             break;
  42.         }
  43.     }
  44.     else if(ret == 0)
  45.     {//超时
  46.         //.....
  47.     }
  48.     else
  49.     { //> 0 ret为可被操作的描述符个数
  50.         if(FD_ISSET(fd1,&rfds))
  51.         {//读数据
  52.             //....
  53.         }
  54.         if(FD_ISSET(fd2,&rfds))
  55.         {//读数据
  56.             //....
  57.         }
  58.         ///.....
  59.         if(FD_ISSET(fd1,&wfds))
  60.         {//写数据
  61.             //....
  62.         }
  63.     }
  64. }

驱动层

  1. void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)；
  2. /*功能：将等待队列头添加至poll_table表中
  3.   参数：struct file :设备文件
  4.   Wait_queue_head_t :等待队列头
  5.   Poll_table :poll_table表
  6. */
  7.  
  8. /*该函数与select、poll、epoll_wait函数相对应，协助这些多路监控函数判断本设备是否有数据可读写*/
  9. unsigned int xxx_poll(struct file *filp, poll_table *wait) //函数名初始化给struct file_operations的成员.poll
  10. {
  11.     unsigned int mask = 0;
  12.     /*
  13.     	1. 将所有等待队列头加入poll_table表中
  14.     	2. 判断是否可读，如可读则mask |= POLLIN | POLLRDNORM;
  15.     	3. 判断是否可写，如可写则mask |= POLLOUT | POLLWRNORM;
  16.     */
  17.     
  18.     return mask;
  19. }

示例代码（select）

mychar.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/cdev.h>
  5. #include <linux/wait.h>
  6. #include <linux/sched.h>
  7. #include <linux/poll.h>
  8. #include <linux/uaccess.h>
  9.  
  10. #include "mychar.h"
  11.  
  12. #define BUF_LEN 100
  13.  
  14. int major = 11;
  15. int minor = 0;
  16. int mychar_num = 1;
  17.  
  18. struct mychar_dev
  19. {
  20. 	struct cdev mydev;
  21.  
  22. 	char mydev_buf[BUF_LEN];
  23. 	int curlen;
  24.  
  25. 	wait_queue_head_t rq;
  26. 	wait_queue_head_t wq;
  27. };
  28.  
  29. struct mychar_dev gmydev;
  30.  
  31. int mychar_open(struct inode* pnode, struct file* pfile)
  32. {
  33. 	pfile->private_data = (void *)(container_of(pnode->i_cdev, struct mychar_dev, mydev));
  34. 	printk("mychar_open is called\n");
  35. 	return 0;
  36. }
  37.  
  38. int mychar_close(struct inode* pnode, struct file* pfile)
  39. {
  40. 	printk("mychar_close is called\n");
  41. 	return 0;
  42. }
  43.  
  44. ssize_t mychar_read(struct file* pfile, char __user *puser, size_t count, loff_t* p_pos)
  45. {
  46. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  47. 	int size = 0;
  48. 	int ret = 0;
  49.  
  50. 	if (pmydev->curlen <= 0) {
  51. 		if (pfile->f_flags & O_NONBLOCK) {
  52. 			// 非阻塞
  53. 			printk("O_NONBLOCK No Data Read\n");
  54. 			return -1;
  55. 		} else {
  56. 			// 阻塞
  57. 			ret = wait_event_interruptible(pmydev->rq, pmydev->curlen > 0);
  58. 			if (ret) {
  59. 				printk("Wake up by signal\n");
  60. 				return -ERESTARTSYS;
  61. 			}
  62. 		}
  63. 	}
  64.  
  65. 	if (count > pmydev->curlen) {
  66. 		size = pmydev->curlen;
  67. 	} else {
  68. 		size = count;
  69. 	}
  70.  
  71. 	ret = copy_to_user(puser, pmydev->mydev_buf, size);
  72. 	if (ret) {
  73. 		printk("copy_to_user failed\n");
  74. 		return -1;
  75. 	}
  76.  
  77. 	memcpy(pmydev->mydev_buf, pmydev->mydev_buf + size, pmydev->curlen - size);
  78.  
  79. 	pmydev->curlen -= size;
  80.  
  81. 	wake_up_interruptible(&pmydev->wq);
  82.  
  83. 	return size;
  84. }
  85.  
  86. ssize_t mychar_write(struct file* pfile, const char __user *puser, size_t count, loff_t* p_pos)
  87. {
  88. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  89. 	int size = 0;
  90. 	int ret = 0;
  91.  
  92. 	if (pmydev->curlen >= BUF_LEN) {
  93. 		if (pfile->f_flags & O_NONBLOCK) {
  94. 			printk("O_NONBLOCK Can not write data\n");
  95. 			return -1;
  96. 		} else {
  97. 			ret = wait_event_interruptible(pmydev->wq, pmydev->curlen < BUF_LEN);
  98. 			if (ret) {
  99. 				printk("Wake up by signal\n");
  100. 				return -ERESTARTSYS;
  101. 			}
  102. 		}
  103. 	}
  104.  
  105. 	if (count > BUF_LEN - pmydev->curlen) {
  106. 		size = BUF_LEN - pmydev->curlen;
  107. 	} else {
  108. 		size = count;
  109. 	}
  110.  
  111. 	ret = copy_from_user(pmydev->mydev_buf + pmydev->curlen, puser, size);
  112. 	if (ret) {
  113. 		printk("copy_from_user failed\n");
  114. 		return -1;
  115. 	}
  116.  
  117. 	pmydev->curlen += size;
  118.  
  119. 	wake_up_interruptible(&pmydev->rq);
  120.  
  121. 	return size;
  122. }
  123.  
  124. long mychar_ioctl(struct file* pfile, unsigned int cmd, unsigned long arg)
  125. {
  126. 	int __user *pret = (int*)arg;
  127. 	int maxlen = BUF_LEN;
  128. 	int ret = 0;
  129. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  130.  
  131. 	switch (cmd) {
  132. 		case MYCHAR_IOCTL_GET_MAXLEN:
  133. 			ret = copy_to_user(pret, &maxlen, sizeof(int));
  134. 			if (ret) {
  135. 				printk("copy_to_user MAXLEN failed\n");
  136. 				return -1;
  137. 			}
  138. 			break;
  139. 		case MYCHAR_IOCTL_GET_CURLEN:
  140. 			ret = copy_to_user(pret, &pmydev->curlen, sizeof(int));
  141. 			if (ret) {
  142. 				printk("copy_to_user CURLEN failed\n");
  143. 				return -1;
  144. 			}
  145. 			break;
  146. 		default:
  147. 			printk("The cmd is unknow\n");
  148. 			return -1;
  149. 	}
  150. 	return 0;
  151. }
  152.  
  153. unsigned int mychar_poll(struct file* pfile, poll_table* ptb)
  154. {
  155. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  156. 	unsigned int mask = 0;
  157.  
  158. 	poll_wait(pfile, &pmydev->rq, ptb);
  159. 	poll_wait(pfile, &pmydev->wq, ptb);
  160.  
  161. 	if (pmydev->curlen > 0) {
  162. 		mask |= POLLIN | POLLRDNORM;
  163. 	}
  164.  
  165. 	if (pmydev->curlen < BUF_LEN) {
  166. 		mask |= POLLOUT | POLLWRNORM;
  167. 	}
  168.  
  169. 	return mask;
  170. }
  171.  
  172. struct file_operations myops = {
  173. 	.owner = THIS_MODULE,
  174. 	.open = mychar_open,
  175. 	.release = mychar_close,
  176. 	.read = mychar_read,
  177. 	.write = mychar_write,
  178. 	.unlocked_ioctl = mychar_ioctl,
  179. 	.poll = mychar_poll,
  180. };
  181.  
  182. int __init mychar_init(void)
  183. {
  184. 	int ret = 0;
  185. 	dev_t devno = MKDEV(major, minor);
  186.  
  187. 	/* 申请设备号 */
  188. 	ret = register_chrdev_region(devno, mychar_num, "mychar");
  189. 	if (ret) {
  190. 		ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
  191. 		if (ret) {
  192. 			printk("get devno failed\n");
  193. 			return -1;
  194. 		}
  195. 		major = MAJOR(devno);
  196. 	}
  197.  
  198. 	/* 给struct cdev对象指定操作函数集 */
  199. 	cdev_init(&gmydev.mydev, &myops);
  200.  
  201. 	/* 给struct cdev对象添加到内核对应的数据结构里 */
  202. 	gmydev.mydev.owner = THIS_MODULE;
  203. 	cdev_add(&gmydev.mydev, devno, mychar_num);
  204.  
  205. 	init_waitqueue_head(&gmydev.rq);
  206. 	init_waitqueue_head(&gmydev.wq);
  207. 	return 0;
  208. }
  209.  
  210. void __exit mychar_exit(void)
  211. {
  212. 	dev_t devno = MKDEV(major, minor);
  213. 	cdev_del(&gmydev.mydev);
  214. 	unregister_chrdev_region(devno, mychar_num);
  215. }
  216.  
  217.  
  218. MODULE_LICENSE("GPL");
  219.  
  220. module_init(mychar_init);
  221. module_exit(mychar_exit);

mychar.h同ioctl

test.c

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <unistd.h>
  5. #include <stdio.h>
  6. #include <sys/ioctl.h>
  7. #include <sys/select.h>
  8. #include <sys/time.h>
  9. #include <errno.h>
  10.  
  11. #include "mychar.h"
  12.  
  13. int main(int argc, char* argv[])
  14. {
  15.     int fd = -1;
  16.     char buf[8] = "";
  17.     int ret = 0;
  18.     fd_set rfds;
  19.  
  20.     if (argc < 2) {
  21.         printf("The argument is too few\n");
  22.         return 1;
  23.     }
  24.  
  25.     fd = open(argv[1], O_RDWR);
  26.     if (fd < 0) {
  27.         printf("open %s failed\n", argv[1]);
  28.         return 2;
  29.     }
  30.  
  31.     while (1) {
  32.         FD_ZERO(&rfds);
  33.         FD_SET(fd, &rfds);
  34.         ret = select(fd + 1, &rfds, NULL, NULL, NULL);
  35.         if (ret < 0) {
  36.             if (errno == EINTR) {
  37.                 continue;
  38.             } else {
  39.                 printf("select error\n");
  40.                 break;
  41.             }
  42.         }
  43.         if (FD_ISSET(fd, &rfds)) {
  44.             read(fd, buf, 8);
  45.             printf("buf = %s\n", buf);
  46.         }
  47.     }
  48.  
  49.     close(fd);
  50.     fd = -1;
  51.     return 0;
  52. }

测试结果

执行测试代码后一直等待是否有数据可读，有则读取数据

  1. shrek@ubuntu16:~/share/mydrivercode$ echo "hello" > /dev/mydev 
  2. shrek@ubuntu16:~/share/mydrivercode$ echo "hello" > /dev/mydev 
  3. shrek@ubuntu16:~/share/mydrivercode$ echo "hello" > /dev/mydev 
  4. shrek@ubuntu16:~/share/mydrivercode$ echo "hello" > /dev/mydev
  1. shrek@ubuntu16:~/share/mydrivercode$ ./a.out /dev/mydev 
  2. buf = hello
  3.  
  4. buf = hello
  5.  
  6. buf = hello
  7.  
  8. buf = hello

信号驱动

Tips

信号驱动存在丢失信号的风险

应用层：信号注册+fcntl

  1. signal(SIGIO, input_handler); //注册信号处理函数
  2.  
  3. fcntl(fd, F_SETOWN, getpid());//将描述符设置给对应进程，好由描述符获知PID
  4.  
  5. oflags = fcntl(fd, F_GETFL);
  6. fcntl(fd, F_SETFL, oflags | FASYNC);//将该设备的IO模式设置成信号驱动模式
  7.  
  8. void input_handler(int signum)//应用自己实现的信号处理函数，在此函数中完成读写
  9. {
  10.     //读数据
  11. }
  12.  
  13. //应用模板
  14. int main()
  15. {
  16. 	int fd = open("/dev/xxxx",O_RDONLY);
  17.  
  18. 	fcntl(fd, F_SETOWN, getpid());
  19.  
  20. 	oflags = fcntl(fd, F_GETFL);
  21. 	fcntl(fd, F_SETFL, oflags | FASYNC);
  22.  
  23. 	signal(SIGIO,xxxx_handler);
  24.  
  25. 	//......
  26. }
  27.     
  28. void xxxx_handle(int signo)
  29. {//读写数据
  30.     
  31. }

驱动层：实现fasync函数

  1. /*设备结构中添加如下成员*/
  2. struct fasync_struct *pasync_obj;
  3.  
  4. /*应用调用fcntl设置FASYNC时调用该函数产生异步通知结构对象，并将其地址设置到设备结构成员中*/
  5. static int hello_fasync(int fd, struct file *filp, int mode) //函数名初始化给struct file_operations的成员.fasync
  6. {
  7. 	struct hello_device *dev = filp->private_data; 
  8. 	return fasync_helper(fd, filp, mode, &dev->pasync_obj);
  9. }
  10.  
  11. /*写函数中有数据可读时向应用层发信号*/
  12. if (dev->pasync_obj)
  13.        kill_fasync(&dev->pasync_obj, SIGIO, POLL_IN);
  14.        
  15. /*release函数中释放异步通知结构对象*/
  16. if (dev->pasync_obj) 
  17. 	fasync_helper(-1, filp, 0, &dev->pasync_obj);
  18.  
  19. int fasync_helper(int fd, struct file *filp, int mode, struct fasync_struct **pp);
  20. /*
  21. 	功能：产生或释放异步通知结构对象
  22. 	参数：
  23. 	返回值：成功为>=0,失败负数
  24. */
  25.  
  26. void kill_fasync(struct fasync_struct **, int, int);
  27. /*	
  28. 	功能：发信号
  29. 	参数：
  30. 		struct fasync_struct ** 指向保存异步通知结构地址的指针
  31. 		int 	信号 SIGIO/SIGKILL/SIGCHLD/SIGCONT/SIGSTOP
  32. 		int 	读写信息POLLIN、POLLOUT
  33. */

示例代码（信号驱动）

mychar.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/cdev.h>
  5. #include <linux/wait.h>
  6. #include <linux/sched.h>
  7. #include <linux/poll.h>
  8. #include <linux/uaccess.h>
  9.  
  10. #include "mychar.h"
  11.  
  12. #define BUF_LEN 100
  13.  
  14. int major = 11;
  15. int minor = 0;
  16. int mychar_num = 1;
  17.  
  18. struct mychar_dev
  19. {
  20. 	struct cdev mydev;
  21.  
  22. 	char mydev_buf[BUF_LEN];
  23. 	int curlen;
  24.  
  25. 	wait_queue_head_t rq;
  26. 	wait_queue_head_t wq;
  27.  
  28. 	struct fasync_struct* pasync_obj;
  29. };
  30.  
  31. struct mychar_dev gmydev;
  32.  
  33. int mychar_open(struct inode* pnode, struct file* pfile)
  34. {
  35. 	pfile->private_data = (void *)(container_of(pnode->i_cdev, struct mychar_dev, mydev));
  36. 	return 0;
  37. }
  38.  
  39. int mychar_close(struct inode* pnode, struct file* pfile)
  40. {
  41. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  42. 	if (pmydev->pasync_obj != NULL) {
  43. 		fasync_helper(-1, pfile, 0, &pmydev->pasync_obj);
  44. 	}
  45. 	return 0;
  46. }
  47.  
  48. ssize_t mychar_read(struct file* pfile, char __user *puser, size_t count, loff_t* p_pos)
  49. {
  50. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  51. 	int size = 0;
  52. 	int ret = 0;
  53.  
  54. 	if (pmydev->curlen <= 0) {
  55. 		if (pfile->f_flags & O_NONBLOCK) {
  56. 			// 非阻塞
  57. 			printk("O_NONBLOCK No Data Read\n");
  58. 			return -1;
  59. 		} else {
  60. 			// 阻塞
  61. 			ret = wait_event_interruptible(pmydev->rq, pmydev->curlen > 0);
  62. 			if (ret) {
  63. 				printk("Wake up by signal\n");
  64. 				return -ERESTARTSYS;
  65. 			}
  66. 		}
  67. 	}
  68.  
  69. 	if (count > pmydev->curlen) {
  70. 		size = pmydev->curlen;
  71. 	} else {
  72. 		size = count;
  73. 	}
  74.  
  75. 	ret = copy_to_user(puser, pmydev->mydev_buf, size);
  76. 	if (ret) {
  77. 		printk("copy_to_user failed\n");
  78. 		return -1;
  79. 	}
  80.  
  81. 	memcpy(pmydev->mydev_buf, pmydev->mydev_buf + size, pmydev->curlen - size);
  82.  
  83. 	pmydev->curlen -= size;
  84.  
  85. 	wake_up_interruptible(&pmydev->wq);
  86.  
  87. 	return size;
  88. }
  89.  
  90. ssize_t mychar_write(struct file* pfile, const char __user *puser, size_t count, loff_t* p_pos)
  91. {
  92. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  93. 	int size = 0;
  94. 	int ret = 0;
  95.  
  96. 	if (pmydev->curlen >= BUF_LEN) {
  97. 		if (pfile->f_flags & O_NONBLOCK) {
  98. 			printk("O_NONBLOCK Can not write data\n");
  99. 			return -1;
  100. 		} else {
  101. 			ret = wait_event_interruptible(pmydev->wq, pmydev->curlen < BUF_LEN);
  102. 			if (ret) {
  103. 				printk("Wake up by signal\n");
  104. 				return -ERESTARTSYS;
  105. 			}
  106. 		}
  107. 	}
  108.  
  109. 	if (count > BUF_LEN - pmydev->curlen) {
  110. 		size = BUF_LEN - pmydev->curlen;
  111. 	} else {
  112. 		size = count;
  113. 	}
  114.  
  115. 	ret = copy_from_user(pmydev->mydev_buf + pmydev->curlen, puser, size);
  116. 	if (ret) {
  117. 		printk("copy_from_user failed\n");
  118. 		return -1;
  119. 	}
  120.  
  121. 	pmydev->curlen += size;
  122.  
  123. 	wake_up_interruptible(&pmydev->rq);
  124.  
  125. 	if (pmydev->pasync_obj != NULL) {
  126. 		kill_fasync(&pmydev->pasync_obj, SIGIO, POLL_IN);
  127. 	}
  128.  
  129. 	return size;
  130. }
  131.  
  132. long mychar_ioctl(struct file* pfile, unsigned int cmd, unsigned long arg)
  133. {
  134. 	int __user *pret = (int*)arg;
  135. 	int maxlen = BUF_LEN;
  136. 	int ret = 0;
  137. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  138.  
  139. 	switch (cmd) {
  140. 		case MYCHAR_IOCTL_GET_MAXLEN:
  141. 			ret = copy_to_user(pret, &maxlen, sizeof(int));
  142. 			if (ret) {
  143. 				printk("copy_to_user MAXLEN failed\n");
  144. 				return -1;
  145. 			}
  146. 			break;
  147. 		case MYCHAR_IOCTL_GET_CURLEN:
  148. 			ret = copy_to_user(pret, &pmydev->curlen, sizeof(int));
  149. 			if (ret) {
  150. 				printk("copy_to_user CURLEN failed\n");
  151. 				return -1;
  152. 			}
  153. 			break;
  154. 		default:
  155. 			printk("The cmd is unknow\n");
  156. 			return -1;
  157. 	}
  158. 	return 0;
  159. }
  160.  
  161. unsigned int mychar_poll(struct file* pfile, poll_table* ptb)
  162. {
  163. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  164. 	unsigned int mask = 0;
  165.  
  166. 	poll_wait(pfile, &pmydev->rq, ptb);
  167. 	poll_wait(pfile, &pmydev->wq, ptb);
  168.  
  169. 	if (pmydev->curlen > 0) {
  170. 		mask |= POLLIN | POLLRDNORM;
  171. 	}
  172.  
  173. 	if (pmydev->curlen < BUF_LEN) {
  174. 		mask |= POLLOUT | POLLWRNORM;
  175. 	}
  176.  
  177. 	return mask;
  178. }
  179.  
  180. int mychar_fasync(int fd, struct file* pfile, int mode) {
  181. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  182. 	return fasync_helper(fd, pfile, mode, &pmydev->pasync_obj);
  183. }
  184.  
  185. struct file_operations myops = {
  186. 	.owner = THIS_MODULE,
  187. 	.open = mychar_open,
  188. 	.release = mychar_close,
  189. 	.read = mychar_read,
  190. 	.write = mychar_write,
  191. 	.unlocked_ioctl = mychar_ioctl,
  192. 	.poll = mychar_poll,
  193. 	.fasync = mychar_fasync,
  194. };
  195.  
  196. int __init mychar_init(void)
  197. {
  198. 	int ret = 0;
  199. 	dev_t devno = MKDEV(major, minor);
  200.  
  201. 	/* 申请设备号 */
  202. 	ret = register_chrdev_region(devno, mychar_num, "mychar");
  203. 	if (ret) {
  204. 		ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
  205. 		if (ret) {
  206. 			printk("get devno failed\n");
  207. 			return -1;
  208. 		}
  209. 		major = MAJOR(devno);
  210. 	}
  211.  
  212. 	/* 给struct cdev对象指定操作函数集 */
  213. 	cdev_init(&gmydev.mydev, &myops);
  214.  
  215. 	/* 给struct cdev对象添加到内核对应的数据结构里 */
  216. 	gmydev.mydev.owner = THIS_MODULE;
  217. 	cdev_add(&gmydev.mydev, devno, mychar_num);
  218.  
  219. 	init_waitqueue_head(&gmydev.rq);
  220. 	init_waitqueue_head(&gmydev.wq);
  221. 	return 0;
  222. }
  223.  
  224. void __exit mychar_exit(void)
  225. {
  226. 	dev_t devno = MKDEV(major, minor);
  227. 	cdev_del(&gmydev.mydev);
  228. 	unregister_chrdev_region(devno, mychar_num);
  229. }
  230.  
  231.  
  232. MODULE_LICENSE("GPL");
  233.  
  234. module_init(mychar_init);
  235. module_exit(mychar_exit);

mychar.h同ioctl

test.c

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <unistd.h>
  5. #include <stdio.h>
  6. #include <sys/ioctl.h>
  7. #include <signal.h>
  8.  
  9. #include "mychar.h"
  10.  
  11. int fd = -1;
  12.  
  13. void sigio_handler(int signo);
  14.  
  15. int main(int argc, char* argv[])
  16. {
  17.     int flg = 0;
  18.  
  19.     if (argc < 2) {
  20.         printf("The argument is too few\n");
  21.         return 1;
  22.     }
  23.  
  24.     signal(SIGIO, sigio_handler);
  25.  
  26.     fd = open(argv[1], O_RDWR);
  27.     if (fd < 0) {
  28.         printf("open %s failed\n", argv[1]);
  29.         return 2;
  30.     }
  31.  
  32.     fcntl(fd, F_SETOWN, getpid());
  33.     flg = fcntl(fd, F_GETFL);
  34.     flg |= FASYNC;
  35.     fcntl(fd, F_SETFL, flg);
  36.  
  37.     while (1) {}
  38.  
  39.     close(fd);
  40.     fd = -1;
  41.     return 0;
  42. }
  43.  
  44. void sigio_handler(int signo)
  45. {
  46.     char buf[8] = "";
  47.     read(fd, buf, 8);
  48.     printf("buf = %s\n", buf);
  49. }

测试结果同多路复用

并发控制

上下文和并发场合

执行流：有开始有结束总体顺序执行的一段代码  又称上下文

应用编程：任务上下文
内核编程：

1. 任务上下文：五状态 可阻塞
   a. 应用进程或线程运行在用户空间
   b. 应用进程或线程运行在内核空间（通过调用syscall来间接使用内核空间）
   c. 内核线程始终在内核空间
2. 异常上下文：不可阻塞
   中断上下文

竞态：多任务并行执行时，如果在一个时刻同时操作同一个资源，会引起资源的错乱，这种错乱情形被称为竞态

共享资源：可能会被多个任务同时使用的资源

临界区：操作共享资源的代码段

为了解决竞态，需要提供一种控制机制，来避免在同一时刻使用共享资源，这种机制被称为并发控制机制

并发控制机制分类：

1. 原子操作类
2. 忙等待类
3. 阻塞类

通用并发控制机制的一般使用套路：

  1. /*互斥问题：*/
  2. 并发控制机制初始化为可用
  3. P操作
  4.  
  5. 临界区
  6.  
  7. V操作
  8.  
  9. /*同步问题：*/
  10. // 并发控制机制初始化为不可用
  11. // 先行方：
  12. ......
  13. V操作
  14.     
  15. // 后行方：
  16. P操作
  17. ......

中断屏蔽

一种同步机制的辅助手段

禁止本cpu中断                   使能本cpu中断
local_irq_disable();            local_irq_enable();            
local_irq_save(flags);        local_irq_restore(flags);    与cpu的中断位相关
local_bh_disable();            local_bh_enable();            与中断低半部有关，关闭、打开软中断

禁止中断
临界区    //临界区代码不能占用太长时间，需要很快完成
打开中断

适用场合：中断上下文与某任务共享资源时，或多个不同优先级的中断上下文间共享资源时

原子变量

原子变量：存取不可被打断的特殊整型变量
a.设置原子量的值
void atomic_set(atomic_t *v,int i);    // 设置原子量的值为i
atomic_t v = ATOMIC_INIT(0);        // 定义原子变量v并初始化为0

v = 10;//错误

b.获取原子量的值
atomic_read(atomic_t *v);               // 返回原子量的值

c.原子变量加减
void atomic_add(int i,atomic_t *v);  // 原子变量增加i
void atomic_sub(int i,atomic_t *v);  // 原子变量减少i

d.原子变量自增自减
void atomic_inc(atomic_t *v);         // 原子变量增加1
void atomic_dec(atomic_t *v);        // 原子变量减少1

e.操作并测试：运算后结果为0则返回真，否则返回假
int atomic_inc_and_test(atomic_t *v);
int atomic_dec_and_test(atomic_t *v);
int atomic_sub_and_test(int i,atomic_t *v);

原子位操作方法：
a.设置位
void set_bit(nr, void *addr);            // 设置addr的第nr位为1
b.清除位
void clear_bit(nr , void *addr);        // 清除addr的第nr位为0
c.改变位
void change_bit(nr , void *addr);    // 改变addr的第nr位为1
d.测试位
void test_bit(nr , void *addr);           // 测试addr的第nr位是否为1

适用场合：共享资源为单个整型变量的互斥场合

示例代码（原子变量，使设备文件同一时间只能打开一次）

openonce.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/cdev.h>
  5. #include <linux/wait.h>
  6. #include <linux/sched.h>
  7. #include <linux/poll.h>
  8. #include <linux/uaccess.h>
  9. #include <asm/atomic.h>
  10.  
  11. int major = 11;
  12. int minor = 0;
  13. int openonce_num = 1;
  14.  
  15. struct openonce_dev
  16. {
  17. 	struct cdev mydev;
  18.  
  19.     atomic_t openflag;
  20. };
  21.  
  22. struct openonce_dev gmydev;
  23.  
  24. int openonce_open(struct inode* pnode, struct file* pfile)
  25. {
  26. 	struct openonce_dev* pmydev = NULL;
  27.     pfile->private_data = (void *)(container_of(pnode->i_cdev, struct openonce_dev, mydev));
  28. 	pmydev = (struct openonce_dev*)pfile->private_data;
  29.  
  30.     if (atomic_dec_and_test(&pmydev->openflag)) {
  31.         return 0;
  32.     } else {
  33.         atomic_inc(&pmydev->openflag);
  34.         printk("The device is opened already\n");
  35.         return -1;
  36.     }
  37.     
  38.     return 0;
  39. }
  40.  
  41. int openonce_close(struct inode* pnode, struct file* pfile)
  42. {
  43. 	struct openonce_dev *pmydev = (struct openonce_dev *)pfile->private_data;
  44. 	atomic_set(&pmydev->openflag, 1);
  45. 	return 0;
  46. }
  47.  
  48. struct file_operations myops = {
  49. 	.owner = THIS_MODULE,
  50. 	.open = openonce_open,
  51. 	.release = openonce_close,
  52. };
  53.  
  54. int __init openonce_init(void)
  55. {
  56. 	int ret = 0;
  57. 	dev_t devno = MKDEV(major, minor);
  58.  
  59. 	/* 申请设备号 */
  60. 	ret = register_chrdev_region(devno, openonce_num, "openonce");
  61. 	if (ret) {
  62. 		ret = alloc_chrdev_region(&devno, minor, openonce_num, "openonce");
  63. 		if (ret) {
  64. 			printk("get devno failed\n");
  65. 			return -1;
  66. 		}
  67. 		major = MAJOR(devno);
  68. 	}
  69.  
  70. 	/* 给struct cdev对象指定操作函数集 */
  71. 	cdev_init(&gmydev.mydev, &myops);
  72.  
  73. 	/* 给struct cdev对象添加到内核对应的数据结构里 */
  74. 	gmydev.mydev.owner = THIS_MODULE;
  75. 	cdev_add(&gmydev.mydev, devno, openonce_num);
  76.  
  77. 	atomic_set(&gmydev.openflag, 1);
  78. 	return 0;
  79. }
  80.  
  81. void __exit openonce_exit(void)
  82. {
  83. 	dev_t devno = MKDEV(major, minor);
  84. 	cdev_del(&gmydev.mydev);
  85. 	unregister_chrdev_region(devno, openonce_num);
  86. }
  87.  
  88.  
  89. MODULE_LICENSE("GPL");
  90.  
  91. module_init(openonce_init);
  92. module_exit(openonce_exit);

test.c

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <unistd.h>
  5. #include <stdio.h>
  6. #include <sys/ioctl.h>
  7.  
  8. int main(int argc, char* argv[])
  9. {
  10.     int fd = -1;
  11.  
  12.     if (argc < 2) {
  13.         printf("The argument is too few\n");
  14.         return 1;
  15.     }
  16.  
  17.     fd = open(argv[1], O_RDONLY);
  18.     if (fd < 0) {
  19.         printf("open %s failed\n", argv[1]);
  20.         return 2;
  21.     }
  22.  
  23.     while (1) {}
  24.  
  25.     close(fd);
  26.     fd = -1;
  27.     return 0;
  28. }

测试结果

第一次打开设备文件成功，第二次打开设备文件失败

自旋锁：基于忙等待的并发控制机制

a.定义自旋锁
spinlock_t  lock;

b.初始化自旋锁
spin_lock_init(spinlock_t *);

c.获得自旋锁
spin_lock(spinlock_t *);    //成功获得自旋锁立即返回，否则自旋在那里直到该自旋锁的保持者释放

spin_trylock(spinlock_t *);    //成功获得自旋锁立即返回真，否则返回假，而不是像上一个那样"在原地打转”

d.释放自旋锁
spin_unlock(spinlock_t *);

  1. #include <linux/spinlock.h>
  2. 定义spinlock_t类型的变量lock
  3. spin_lock_init(&lock)后才能正常使用spinlock
  4.  
  5.  
  6. spin_lock(&lock);
  7. 临界区
  8. spin_unlock(&lock);

适用场合：

1. 异常上下文之间或异常上下文与任务上下文之间共享资源时
2. 任务上下文之间且临界区执行时间很短时
3. 互斥问题

示例代码（自旋锁）

openonce.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/cdev.h>
  5. #include <linux/wait.h>
  6. #include <linux/sched.h>
  7. #include <linux/poll.h>
  8. #include <linux/uaccess.h>
  9. #include <asm/atomic.h>
  10.  
  11. int major = 11;
  12. int minor = 0;
  13. int openonce_num = 1;
  14.  
  15. struct openonce_dev
  16. {
  17. 	struct cdev mydev;
  18.  
  19.     int openflag;
  20. 	spinlock_t lock;
  21. };
  22.  
  23. struct openonce_dev gmydev;
  24.  
  25. int openonce_open(struct inode* pnode, struct file* pfile)
  26. {
  27. 	struct openonce_dev* pmydev = NULL;
  28.     pfile->private_data = (void *)(container_of(pnode->i_cdev, struct openonce_dev, mydev));
  29. 	pmydev = (struct openonce_dev*)pfile->private_data;
  30.  
  31. 	spin_lock(&pmydev->lock);
  32.     if (pmydev->openflag) {
  33.         pmydev->openflag = 0;
  34. 		spin_unlock(&pmydev->lock);
  35. 		return 0;
  36.     } else {
  37.         spin_unlock(&pmydev->lock);
  38.         printk("The device is opened already\n");
  39.         return -1;
  40.     }
  41. }
  42.  
  43. int openonce_close(struct inode* pnode, struct file* pfile)
  44. {
  45. 	struct openonce_dev *pmydev = (struct openonce_dev *)pfile->private_data;
  46. 	spin_lock(&pmydev->lock);
  47. 	pmydev->openflag = 1;
  48. 	spin_unlock(&pmydev->lock);
  49. 	return 0;
  50. }
  51.  
  52. struct file_operations myops = {
  53. 	.owner = THIS_MODULE,
  54. 	.open = openonce_open,
  55. 	.release = openonce_close,
  56. };
  57.  
  58. int __init openonce_init(void)
  59. {
  60. 	int ret = 0;
  61. 	dev_t devno = MKDEV(major, minor);
  62.  
  63. 	/* 申请设备号 */
  64. 	ret = register_chrdev_region(devno, openonce_num, "openonce");
  65. 	if (ret) {
  66. 		ret = alloc_chrdev_region(&devno, minor, openonce_num, "openonce");
  67. 		if (ret) {
  68. 			printk("get devno failed\n");
  69. 			return -1;
  70. 		}
  71. 		major = MAJOR(devno);
  72. 	}
  73.  
  74. 	/* 给struct cdev对象指定操作函数集 */
  75. 	cdev_init(&gmydev.mydev, &myops);
  76.  
  77. 	/* 给struct cdev对象添加到内核对应的数据结构里 */
  78. 	gmydev.mydev.owner = THIS_MODULE;
  79. 	cdev_add(&gmydev.mydev, devno, openonce_num);
  80.  
  81. 	gmydev.openflag = 1;
  82.  
  83. 	spin_lock_init(&gmydev.lock);
  84. 	return 0;
  85. }
  86.  
  87. void __exit openonce_exit(void)
  88. {
  89. 	dev_t devno = MKDEV(major, minor);
  90. 	cdev_del(&gmydev.mydev);
  91. 	unregister_chrdev_region(devno, openonce_num);
  92. }
  93.  
  94.  
  95. MODULE_LICENSE("GPL");
  96.  
  97. module_init(openonce_init);
  98. module_exit(openonce_exit);

test.c

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <unistd.h>
  5. #include <stdio.h>
  6. #include <sys/ioctl.h>
  7.  
  8. int main(int argc, char* argv[])
  9. {
  10.     int fd = -1;
  11.  
  12.     if (argc < 2) {
  13.         printf("The argument is too few\n");
  14.         return 1;
  15.     }
  16.  
  17.     fd = open(argv[1], O_RDONLY);
  18.     if (fd < 0) {
  19.         printf("open %s failed\n", argv[1]);
  20.         return 2;
  21.     }
  22.  
  23.     while (1) {}
  24.  
  25.     close(fd);
  26.     fd = -1;
  27.     return 0;
  28. }

测试结果

第一次打开设备文件成功，第二次打开设备文件失败

信号量：基于阻塞的并发控制机制

a.定义信号量
struct semaphore sem;

b.初始化信号量
void sema_init(struct semaphore *sem, int val);

c.获得信号量P
int down(struct semaphore *sem);//深度睡眠

int down_interruptible(struct semaphore *sem);//浅度睡眠

d.释放信号量V
void up(struct semaphore *sem);


#include <linux/semaphore.h>
 

适用场合：任务上下文之间且临界区执行时间较长时的互斥或同步问题

示例代码（信号量）

mychar.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/cdev.h>
  5. #include <linux/wait.h>
  6. #include <linux/sched.h>
  7. #include <linux/poll.h>
  8. #include <linux/uaccess.h>
  9.  
  10. #include "mychar.h"
  11.  
  12. #define BUF_LEN 100
  13.  
  14. int major = 11;
  15. int minor = 0;
  16. int mychar_num = 1;
  17.  
  18. struct mychar_dev
  19. {
  20. 	struct cdev mydev;
  21.  
  22. 	char mydev_buf[BUF_LEN];
  23. 	int curlen;
  24. 	struct semaphore sem;
  25.  
  26. 	wait_queue_head_t rq;
  27. 	wait_queue_head_t wq;
  28.  
  29. 	struct fasync_struct* pasync_obj;
  30. };
  31.  
  32. struct mychar_dev gmydev;
  33.  
  34. int mychar_open(struct inode* pnode, struct file* pfile)
  35. {
  36. 	pfile->private_data = (void *)(container_of(pnode->i_cdev, struct mychar_dev, mydev));
  37. 	return 0;
  38. }
  39.  
  40. int mychar_close(struct inode* pnode, struct file* pfile)
  41. {
  42. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  43. 	if (pmydev->pasync_obj != NULL) {
  44. 		fasync_helper(-1, pfile, 0, &pmydev->pasync_obj);
  45. 	}
  46. 	return 0;
  47. }
  48.  
  49. ssize_t mychar_read(struct file* pfile, char __user *puser, size_t count, loff_t* p_pos)
  50. {
  51. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  52. 	int size = 0;
  53. 	int ret = 0;
  54.  
  55. 	down(&pmydev->sem);
  56. 	if (pmydev->curlen <= 0) {
  57. 		if (pfile->f_flags & O_NONBLOCK) {
  58. 			// 非阻塞
  59. 			up(&pmydev->sem);
  60. 			printk("O_NONBLOCK No Data Read\n");
  61. 			return -1;
  62. 		} else {
  63. 			// 阻塞
  64. 			up(&pmydev->sem);
  65. 			ret = wait_event_interruptible(pmydev->rq, pmydev->curlen > 0);
  66. 			if (ret) {
  67. 				printk("Wake up by signal\n");
  68. 				return -ERESTARTSYS;
  69. 			}
  70. 			down(&pmydev->sem);
  71. 		}
  72. 	}
  73.  
  74. 	if (count > pmydev->curlen) {
  75. 		size = pmydev->curlen;
  76. 	} else {
  77. 		size = count;
  78. 	}
  79.  
  80. 	ret = copy_to_user(puser, pmydev->mydev_buf, size);
  81. 	if (ret) {
  82. 		up(&pmydev->sem);
  83. 		printk("copy_to_user failed\n");
  84. 		return -1;
  85. 	}
  86.  
  87. 	memcpy(pmydev->mydev_buf, pmydev->mydev_buf + size, pmydev->curlen - size);
  88.  
  89. 	pmydev->curlen -= size;
  90.  
  91. 	up(&pmydev->sem);
  92. 	wake_up_interruptible(&pmydev->wq);
  93.  
  94. 	return size;
  95. }
  96.  
  97. ssize_t mychar_write(struct file* pfile, const char __user *puser, size_t count, loff_t* p_pos)
  98. {
  99. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  100. 	int size = 0;
  101. 	int ret = 0;
  102.  
  103. 	down(&pmydev->sem);
  104. 	if (pmydev->curlen >= BUF_LEN) {
  105. 		if (pfile->f_flags & O_NONBLOCK) {
  106. 			up(&pmydev->sem);
  107. 			printk("O_NONBLOCK Can not write data\n");
  108. 			return -1;
  109. 		} else {
  110. 			up(&pmydev->sem);
  111. 			ret = wait_event_interruptible(pmydev->wq, pmydev->curlen < BUF_LEN);
  112. 			if (ret) {
  113. 				printk("Wake up by signal\n");
  114. 				return -ERESTARTSYS;
  115. 			}
  116. 			down(&pmydev->sem);
  117. 		}
  118. 	}
  119.  
  120. 	if (count > BUF_LEN - pmydev->curlen) {
  121. 		size = BUF_LEN - pmydev->curlen;
  122. 	} else {
  123. 		size = count;
  124. 	}
  125.  
  126. 	ret = copy_from_user(pmydev->mydev_buf + pmydev->curlen, puser, size);
  127. 	if (ret) {
  128. 		up(&pmydev->sem);
  129. 		printk("copy_from_user failed\n");
  130. 		return -1;
  131. 	}
  132.  
  133. 	pmydev->curlen += size;
  134.  
  135. 	up(&pmydev->sem);
  136.  
  137. 	wake_up_interruptible(&pmydev->rq);
  138.  
  139. 	if (pmydev->pasync_obj != NULL) {
  140. 		kill_fasync(&pmydev->pasync_obj, SIGIO, POLL_IN);
  141. 	}
  142.  
  143. 	return size;
  144. }
  145.  
  146. long mychar_ioctl(struct file* pfile, unsigned int cmd, unsigned long arg)
  147. {
  148. 	int __user *pret = (int*)arg;
  149. 	int maxlen = BUF_LEN;
  150. 	int ret = 0;
  151. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  152.  
  153. 	switch (cmd) {
  154. 		case MYCHAR_IOCTL_GET_MAXLEN:
  155. 			ret = copy_to_user(pret, &maxlen, sizeof(int));
  156. 			if (ret) {
  157. 				printk("copy_to_user MAXLEN failed\n");
  158. 				return -1;
  159. 			}
  160. 			break;
  161. 		case MYCHAR_IOCTL_GET_CURLEN:
  162. 			down(&pmydev->sem);
  163. 			ret = copy_to_user(pret, &pmydev->curlen, sizeof(int));
  164. 			up(&pmydev->sem);
  165. 			if (ret) {
  166. 				printk("copy_to_user CURLEN failed\n");
  167. 				return -1;
  168. 			}
  169. 			break;
  170. 		default:
  171. 			printk("The cmd is unknow\n");
  172. 			return -1;
  173. 	}
  174. 	return 0;
  175. }
  176.  
  177. unsigned int mychar_poll(struct file* pfile, poll_table* ptb)
  178. {
  179. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  180. 	unsigned int mask = 0;
  181.  
  182. 	poll_wait(pfile, &pmydev->rq, ptb);
  183. 	poll_wait(pfile, &pmydev->wq, ptb);
  184.  
  185. 	down(&pmydev->sem);
  186. 	if (pmydev->curlen > 0) {
  187. 		mask |= POLLIN | POLLRDNORM;
  188. 	}
  189.  
  190. 	if (pmydev->curlen < BUF_LEN) {
  191. 		mask |= POLLOUT | POLLWRNORM;
  192. 	}
  193. 	up(&pmydev->sem);
  194.  
  195. 	return mask;
  196. }
  197.  
  198. int mychar_fasync(int fd, struct file* pfile, int mode) {
  199. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  200. 	return fasync_helper(fd, pfile, mode, &pmydev->pasync_obj);
  201. }
  202.  
  203. struct file_operations myops = {
  204. 	.owner = THIS_MODULE,
  205. 	.open = mychar_open,
  206. 	.release = mychar_close,
  207. 	.read = mychar_read,
  208. 	.write = mychar_write,
  209. 	.unlocked_ioctl = mychar_ioctl,
  210. 	.poll = mychar_poll,
  211. 	.fasync = mychar_fasync,
  212. };
  213.  
  214. int __init mychar_init(void)
  215. {
  216. 	int ret = 0;
  217. 	dev_t devno = MKDEV(major, minor);
  218.  
  219. 	/* 申请设备号 */
  220. 	ret = register_chrdev_region(devno, mychar_num, "mychar");
  221. 	if (ret) {
  222. 		ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
  223. 		if (ret) {
  224. 			printk("get devno failed\n");
  225. 			return -1;
  226. 		}
  227. 		major = MAJOR(devno);
  228. 	}
  229.  
  230. 	/* 给struct cdev对象指定操作函数集 */
  231. 	cdev_init(&gmydev.mydev, &myops);
  232.  
  233. 	/* 给struct cdev对象添加到内核对应的数据结构里 */
  234. 	gmydev.mydev.owner = THIS_MODULE;
  235. 	cdev_add(&gmydev.mydev, devno, mychar_num);
  236.  
  237. 	init_waitqueue_head(&gmydev.rq);
  238. 	init_waitqueue_head(&gmydev.wq);
  239.  
  240. 	sema_init(&gmydev.sem, 1);
  241. 	return 0;
  242. }
  243.  
  244. void __exit mychar_exit(void)
  245. {
  246. 	dev_t devno = MKDEV(major, minor);
  247. 	cdev_del(&gmydev.mydev);
  248. 	unregister_chrdev_region(devno, mychar_num);
  249. }
  250.  
  251.  
  252. MODULE_LICENSE("GPL");
  253.  
  254. module_init(mychar_init);
  255. module_exit(mychar_exit);

互斥锁：基于阻塞的互斥机制

a.初始化
struct mutex  my_mutex;
mutex_init(&my_mutex);

b.获取互斥体
void  mutex_lock(struct mutex *lock);

c.释放互斥体
void mutex_unlock(struct mutex *lock);

1. 定义对应类型的变量
2. 初始化对应变量

P/加锁
临界区
V/解锁


#include <linux/mutex.h>
 

适用场合：任务上下文之间且临界区执行时间较长时的互斥问题

示例代码（互斥锁）

mychar.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/cdev.h>
  5. #include <linux/wait.h>
  6. #include <linux/sched.h>
  7. #include <linux/poll.h>
  8. #include <linux/uaccess.h>
  9.  
  10. #include "mychar.h"
  11.  
  12. #define BUF_LEN 100
  13.  
  14. int major = 11;
  15. int minor = 0;
  16. int mychar_num = 1;
  17.  
  18. struct mychar_dev
  19. {
  20. 	struct cdev mydev;
  21.  
  22. 	char mydev_buf[BUF_LEN];
  23. 	int curlen;
  24. 	struct mutex lock;
  25.  
  26. 	wait_queue_head_t rq;
  27. 	wait_queue_head_t wq;
  28.  
  29. 	struct fasync_struct* pasync_obj;
  30. };
  31.  
  32. struct mychar_dev gmydev;
  33.  
  34. int mychar_open(struct inode* pnode, struct file* pfile)
  35. {
  36. 	pfile->private_data = (void *)(container_of(pnode->i_cdev, struct mychar_dev, mydev));
  37. 	return 0;
  38. }
  39.  
  40. int mychar_close(struct inode* pnode, struct file* pfile)
  41. {
  42. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  43. 	if (pmydev->pasync_obj != NULL) {
  44. 		fasync_helper(-1, pfile, 0, &pmydev->pasync_obj);
  45. 	}
  46. 	return 0;
  47. }
  48.  
  49. ssize_t mychar_read(struct file* pfile, char __user *puser, size_t count, loff_t* p_pos)
  50. {
  51. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  52. 	int size = 0;
  53. 	int ret = 0;
  54.  
  55. 	mutex_lock(&pmydev->lock);
  56. 	if (pmydev->curlen <= 0) {
  57. 		if (pfile->f_flags & O_NONBLOCK) {
  58. 			// 非阻塞
  59. 			mutex_unlock(&pmydev->lock);
  60. 			printk("O_NONBLOCK No Data Read\n");
  61. 			return -1;
  62. 		} else {
  63. 			// 阻塞
  64. 			mutex_unlock(&pmydev->lock);
  65. 			ret = wait_event_interruptible(pmydev->rq, pmydev->curlen > 0);
  66. 			if (ret) {
  67. 				printk("Wake up by signal\n");
  68. 				return -ERESTARTSYS;
  69. 			}
  70. 			mutex_lock(&pmydev->lock);
  71. 		}
  72. 	}
  73.  
  74. 	if (count > pmydev->curlen) {
  75. 		size = pmydev->curlen;
  76. 	} else {
  77. 		size = count;
  78. 	}
  79.  
  80. 	ret = copy_to_user(puser, pmydev->mydev_buf, size);
  81. 	if (ret) {
  82. 		mutex_unlock(&pmydev->lock);
  83. 		printk("copy_to_user failed\n");
  84. 		return -1;
  85. 	}
  86.  
  87. 	memcpy(pmydev->mydev_buf, pmydev->mydev_buf + size, pmydev->curlen - size);
  88.  
  89. 	pmydev->curlen -= size;
  90.  
  91. 	mutex_unlock(&pmydev->lock);
  92. 	wake_up_interruptible(&pmydev->wq);
  93.  
  94. 	return size;
  95. }
  96.  
  97. ssize_t mychar_write(struct file* pfile, const char __user *puser, size_t count, loff_t* p_pos)
  98. {
  99. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  100. 	int size = 0;
  101. 	int ret = 0;
  102.  
  103. 	mutex_lock(&pmydev->lock);
  104. 	if (pmydev->curlen >= BUF_LEN) {
  105. 		if (pfile->f_flags & O_NONBLOCK) {
  106. 			mutex_unlock(&pmydev->lock);
  107. 			printk("O_NONBLOCK Can not write data\n");
  108. 			return -1;
  109. 		} else {
  110. 			mutex_unlock(&pmydev->lock);
  111. 			ret = wait_event_interruptible(pmydev->wq, pmydev->curlen < BUF_LEN);
  112. 			if (ret) {
  113. 				printk("Wake up by signal\n");
  114. 				return -ERESTARTSYS;
  115. 			}
  116. 			mutex_lock(&pmydev->lock);
  117. 		}
  118. 	}
  119.  
  120. 	if (count > BUF_LEN - pmydev->curlen) {
  121. 		size = BUF_LEN - pmydev->curlen;
  122. 	} else {
  123. 		size = count;
  124. 	}
  125.  
  126. 	ret = copy_from_user(pmydev->mydev_buf + pmydev->curlen, puser, size);
  127. 	if (ret) {
  128. 		mutex_unlock(&pmydev->lock);
  129. 		printk("copy_from_user failed\n");
  130. 		return -1;
  131. 	}
  132.  
  133. 	pmydev->curlen += size;
  134.  
  135. 	mutex_unlock(&pmydev->lock);
  136.  
  137. 	wake_up_interruptible(&pmydev->rq);
  138.  
  139. 	if (pmydev->pasync_obj != NULL) {
  140. 		kill_fasync(&pmydev->pasync_obj, SIGIO, POLL_IN);
  141. 	}
  142.  
  143. 	return size;
  144. }
  145.  
  146. long mychar_ioctl(struct file* pfile, unsigned int cmd, unsigned long arg)
  147. {
  148. 	int __user *pret = (int*)arg;
  149. 	int maxlen = BUF_LEN;
  150. 	int ret = 0;
  151. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  152.  
  153. 	switch (cmd) {
  154. 		case MYCHAR_IOCTL_GET_MAXLEN:
  155. 			ret = copy_to_user(pret, &maxlen, sizeof(int));
  156. 			if (ret) {
  157. 				printk("copy_to_user MAXLEN failed\n");
  158. 				return -1;
  159. 			}
  160. 			break;
  161. 		case MYCHAR_IOCTL_GET_CURLEN:
  162. 			mutex_lock(&pmydev->lock);
  163. 			ret = copy_to_user(pret, &pmydev->curlen, sizeof(int));
  164. 			mutex_unlock(&pmydev->lock);
  165. 			if (ret) {
  166. 				printk("copy_to_user CURLEN failed\n");
  167. 				return -1;
  168. 			}
  169. 			break;
  170. 		default:
  171. 			printk("The cmd is unknow\n");
  172. 			return -1;
  173. 	}
  174. 	return 0;
  175. }
  176.  
  177. unsigned int mychar_poll(struct file* pfile, poll_table* ptb)
  178. {
  179. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  180. 	unsigned int mask = 0;
  181.  
  182. 	poll_wait(pfile, &pmydev->rq, ptb);
  183. 	poll_wait(pfile, &pmydev->wq, ptb);
  184.  
  185. 	mutex_lock(&pmydev->lock);
  186. 	if (pmydev->curlen > 0) {
  187. 		mask |= POLLIN | POLLRDNORM;
  188. 	}
  189.  
  190. 	if (pmydev->curlen < BUF_LEN) {
  191. 		mask |= POLLOUT | POLLWRNORM;
  192. 	}
  193. 	mutex_unlock(&pmydev->lock);
  194.  
  195. 	return mask;
  196. }
  197.  
  198. int mychar_fasync(int fd, struct file* pfile, int mode) {
  199. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  200. 	return fasync_helper(fd, pfile, mode, &pmydev->pasync_obj);
  201. }
  202.  
  203. struct file_operations myops = {
  204. 	.owner = THIS_MODULE,
  205. 	.open = mychar_open,
  206. 	.release = mychar_close,
  207. 	.read = mychar_read,
  208. 	.write = mychar_write,
  209. 	.unlocked_ioctl = mychar_ioctl,
  210. 	.poll = mychar_poll,
  211. 	.fasync = mychar_fasync,
  212. };
  213.  
  214. int __init mychar_init(void)
  215. {
  216. 	int ret = 0;
  217. 	dev_t devno = MKDEV(major, minor);
  218.  
  219. 	/* 申请设备号 */
  220. 	ret = register_chrdev_region(devno, mychar_num, "mychar");
  221. 	if (ret) {
  222. 		ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
  223. 		if (ret) {
  224. 			printk("get devno failed\n");
  225. 			return -1;
  226. 		}
  227. 		major = MAJOR(devno);
  228. 	}
  229.  
  230. 	/* 给struct cdev对象指定操作函数集 */
  231. 	cdev_init(&gmydev.mydev, &myops);
  232.  
  233. 	/* 给struct cdev对象添加到内核对应的数据结构里 */
  234. 	gmydev.mydev.owner = THIS_MODULE;
  235. 	cdev_add(&gmydev.mydev, devno, mychar_num);
  236.  
  237. 	init_waitqueue_head(&gmydev.rq);
  238. 	init_waitqueue_head(&gmydev.wq);
  239.  
  240. 	mutex_init(&gmydev.lock);
  241. 	return 0;
  242. }
  243.  
  244. void __exit mychar_exit(void)
  245. {
  246. 	dev_t devno = MKDEV(major, minor);
  247. 	cdev_del(&gmydev.mydev);
  248. 	unregister_chrdev_region(devno, mychar_num);
  249. }
  250.  
  251.  
  252. MODULE_LICENSE("GPL");
  253.  
  254. module_init(mychar_init);
  255. module_exit(mychar_exit);

选择并发控制机制的原则

1. 不允许睡眠的上下文需要采用忙等待类，可以睡眠的上下文可以采用阻塞类。在异常上下文中访问的竞争资源一定采用忙等待类。
2. 临界区操作较长的应用建议采用阻塞类，临界区很短的操作建议采用忙等待类。
3. 中断屏蔽仅在有与中断上下文共享资源时使用。
4. 共享资源仅是一个简单整型量时用原子变量

内核定时器

时钟中断

硬件有一个时钟装置，该装置每隔一定时间发出一个时钟中断（称为一次时钟嘀嗒-tick），对应的中断处理程序就将全局变量jiffies_64加1

jiffies_64   是一个全局64位整型, jiffies全局变量为其低32位的全局变量，程序中一般用jiffies

HZ：可配置的宏，表示1秒钟产生的时钟中断次数，一般设为100或200

延时机制

1. 短延迟：忙等待

  1. 1. void ndelay(unsigned long nsecs)
  2. 2. void udelay(unsigned long usecs)
  3. 3. void mdelay(unsigned long msecs)

2. 长延迟：忙等待

   使用jiffies比较宏来实现

  1. time_after(a,b)    //a > b
  2. time_before(a,b)   //a < b
  3.    
  4. // 延迟100个jiffies
  5. unsigned long delay = jiffies + 100;
  6. while(time_before(jiffies,delay))
  7. {
  8.     ;
  9. }
  10.    
  11. // 延迟2s
  12. unsigned long delay = jiffies + 2*HZ;
  13. while(time_before(jiffies,delay))
  14. {
  15.     ;
  16. }

3. 睡眠延迟----阻塞类

  1. void msleep(unsigned int msecs);
  2. unsigned long msleep_interruptible(unsigned int msecs);

延时机制的选择原则：

1. 异常上下文中只能采用忙等待类
2. 任务上下文短延迟采用忙等待类，长延迟采用阻塞类

定时器

（1）定义定时器结构体

  1. struct timer_list 
  2. {
  3.     struct list_head entry;
  4.     unsigned long expires;  // 期望的时间值 jiffies + x * HZ
  5.     void (*function)(unsigned long); // 时间到达后，执行的回调函数，软中断异常上下文
  6.     unsigned long data;
  7. };

（2）初始化定时器 

init_timer(struct timer_list *)

（3）增加定时器 ------ 定时器开始计时

void add_timer(struct timer_list *timer);

（4）删除定时器 -------定时器停止工作

int del_timer(struct timer_list * timer);

（5）修改定时器 

 int mod_timer(struct timer_list *timer, unsigned long expires);

参考代码模板

  1. 定义struct timer_list tl类型的变量
  2.  
  3. init_timer(...);//模块入口函数
  4.  
  5. //模块入口函数或open或希望定时器开始工作的地方
  6. tl.expires = jiffies + n * HZ //n秒
  7. tl.function = xxx_func;
  8. tl.data = ...;
  9.  
  10. add_timer(....);
  11.  
  12.  
  13. //不想让定时器继续工作时
  14. del_timer(....);
  15.  
  16. void xxx_func(unsigned long arg)
  17. {
  18.     ......
  19.     mod_timer(....);//如需要定时器继续隔指定时间再次调用本函数
  20. }

内核内存管理

内核内存管理框架

内核将物理内存等分成N块4KB，称之为一页，每页都用一个struct page来表示，采用伙伴关系算法维护

内核地址空间划分图：

3G~3G+896M：低端内存，直接映射  虚拟地址 = 3G + 物理地址
细分为：ZONE_DMA、ZONE_NORMAL
分配方式：
        1. kmalloc:小内存分配，slab算法
        2. get_free_page：整页分配，2的n次方页，n最大为10

大于3G+896M：高端内存
细分为：vmalloc区、持久映射区、固定映射区
分配方式：vmalloc：虚拟地址连续，物理地址不连续

内核中常用动态分配

kmalloc

函数原型：

  1. void *kmalloc(size_t size, gfp_t flags);
  2. void *kzalloc(size_t size, gfp_t flags); // 分配内存同时置零

kmalloc() 申请的内存位于直接映射区域，而且在物理上也是连续的，它们与真实的物理地址只有一个固定的偏移，因为存在较简单的转换关系，所以对申请的内存大小有限制，不能超过128KB。 
　　 
较常用的 flags（分配内存的方法）：

GFP_ATOMIC —— 分配内存的过程是一个原子过程，分配内存的过程不会被（高优先级进程或中断）打断；
GFP_KERNEL —— 正常分配内存；
GFP_DMA —— 给 DMA 控制器分配内存，需要使用该标志（DMA要求分配虚拟地址和物理地址连续）。

flags 的参考用法： 
　|– 进程上下文，可以睡眠　　　　 　GFP_KERNEL 
　|– 异常上下文，不可以睡眠　　　 　GFP_ATOMIC 
　|　　|– 中断处理程序　　　　　 　   GFP_ATOMIC 
　|　　|– 软中断　　　　　　　　　   GFP_ATOMIC 
　|　　|– Tasklet　　　　　　　　   　GFP_ATOMIC 
　|– 用于DMA的内存，可以睡眠　　　GFP_DMA | GFP_KERNEL 
　|– 用于DMA的内存，不可以睡眠　　GFP_DMA |GFP_ATOMIC 
　　 
对应的内存释放函数为：

void kfree(const void *objp);

vmalloc

void *vmalloc(unsigned long size);

vmalloc() 函数则会在虚拟内存空间给出一块连续的内存区，但这片连续的虚拟内存在物理内存中并不一定连续。由于 vmalloc() 没有保证申请到的是连续的物理内存，因此对申请的内存大小没有限制，如果需要申请较大的内存空间就需要用此函数了。

对应的内存释放函数为：

void vfree(const void *addr);

注意：vmalloc() 和 vfree() 可以睡眠，因此不能从异常上下文调用。

kmalloc & vmalloc 的比较

kmalloc()、kzalloc()、vmalloc() 的共同特点是：

1. 用于申请内核空间的内存；
2. 内存以字节为单位进行分配；
3. 所分配的内存虚拟地址上连续；

kmalloc()、kzalloc()、vmalloc() 的区别是：

1. kzalloc 是强制清零的 kmalloc 操作；（以下描述不区分 kmalloc 和 kzalloc）
2. kmalloc 分配的内存大小有限制（128KB），而 vmalloc 没有限制；
3. kmalloc 可以保证分配的内存物理地址是连续的，但是 vmalloc 不能保证；
4. kmalloc 分配内存的过程可以是原子过程（使用 GFP_ATOMIC），而 vmalloc 分配内存时则可能产生阻塞；
5. kmalloc 分配内存的开销小，因此 kmalloc 比 vmalloc 要快；

一般情况下，内存只有在要被 DMA 访问的时候才需要物理上连续，但为了性能上的考虑，内核中一般使用 kmalloc()，而只有在需要获得大块内存时才使用 vmalloc()。

分配选择原则：

1. 小内存（< 128k）用kmalloc，大内存用vmalloc或get_free_page
2. 如果需要比较大的内存，并且要求使用效率较高时用get_free_page，否则用vmalloc

示例代码（互斥锁的代码中设备结构体改用指针并用kmalloc分配内存）

mychar.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/cdev.h>
  5. #include <linux/wait.h>
  6. #include <linux/sched.h>
  7. #include <linux/poll.h>
  8. #include <linux/mm.h>
  9. #include <linux/slab.h>
  10. #include <asm/uaccess.h>
  11.  
  12. #include "mychar.h"
  13.  
  14. #define BUF_LEN 100
  15.  
  16. int major = 11;
  17. int minor = 0;
  18. int mychar_num = 1;
  19.  
  20. struct mychar_dev
  21. {
  22. 	struct cdev mydev;
  23.  
  24. 	char mydev_buf[BUF_LEN];
  25. 	int curlen;
  26. 	struct mutex lock;
  27.  
  28. 	wait_queue_head_t rq;
  29. 	wait_queue_head_t wq;
  30.  
  31. 	struct fasync_struct* pasync_obj;
  32. };
  33.  
  34. struct mychar_dev *pgmydev = NULL;
  35.  
  36. int mychar_open(struct inode* pnode, struct file* pfile)
  37. {
  38. 	pfile->private_data = (void *)(container_of(pnode->i_cdev, struct mychar_dev, mydev));
  39. 	return 0;
  40. }
  41.  
  42. int mychar_close(struct inode* pnode, struct file* pfile)
  43. {
  44. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  45. 	if (pmydev->pasync_obj != NULL) {
  46. 		fasync_helper(-1, pfile, 0, &pmydev->pasync_obj);
  47. 	}
  48. 	return 0;
  49. }
  50.  
  51. ssize_t mychar_read(struct file* pfile, char __user *puser, size_t count, loff_t* p_pos)
  52. {
  53. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  54. 	int size = 0;
  55. 	int ret = 0;
  56.  
  57. 	mutex_lock(&pmydev->lock);
  58. 	if (pmydev->curlen <= 0) {
  59. 		if (pfile->f_flags & O_NONBLOCK) {
  60. 			// 非阻塞
  61. 			mutex_unlock(&pmydev->lock);
  62. 			printk("O_NONBLOCK No Data Read\n");
  63. 			return -1;
  64. 		} else {
  65. 			// 阻塞
  66. 			mutex_unlock(&pmydev->lock);
  67. 			ret = wait_event_interruptible(pmydev->rq, pmydev->curlen > 0);
  68. 			if (ret) {
  69. 				printk("Wake up by signal\n");
  70. 				return -ERESTARTSYS;
  71. 			}
  72. 			mutex_lock(&pmydev->lock);
  73. 		}
  74. 	}
  75.  
  76. 	if (count > pmydev->curlen) {
  77. 		size = pmydev->curlen;
  78. 	} else {
  79. 		size = count;
  80. 	}
  81.  
  82. 	ret = copy_to_user(puser, pmydev->mydev_buf, size);
  83. 	if (ret) {
  84. 		mutex_unlock(&pmydev->lock);
  85. 		printk("copy_to_user failed\n");
  86. 		return -1;
  87. 	}
  88.  
  89. 	memcpy(pmydev->mydev_buf, pmydev->mydev_buf + size, pmydev->curlen - size);
  90.  
  91. 	pmydev->curlen -= size;
  92.  
  93. 	mutex_unlock(&pmydev->lock);
  94. 	wake_up_interruptible(&pmydev->wq);
  95.  
  96. 	return size;
  97. }
  98.  
  99. ssize_t mychar_write(struct file* pfile, const char __user *puser, size_t count, loff_t* p_pos)
  100. {
  101. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  102. 	int size = 0;
  103. 	int ret = 0;
  104.  
  105. 	mutex_lock(&pmydev->lock);
  106. 	if (pmydev->curlen >= BUF_LEN) {
  107. 		if (pfile->f_flags & O_NONBLOCK) {
  108. 			mutex_unlock(&pmydev->lock);
  109. 			printk("O_NONBLOCK Can not write data\n");
  110. 			return -1;
  111. 		} else {
  112. 			mutex_unlock(&pmydev->lock);
  113. 			ret = wait_event_interruptible(pmydev->wq, pmydev->curlen < BUF_LEN);
  114. 			if (ret) {
  115. 				printk("Wake up by signal\n");
  116. 				return -ERESTARTSYS;
  117. 			}
  118. 			mutex_lock(&pmydev->lock);
  119. 		}
  120. 	}
  121.  
  122. 	if (count > BUF_LEN - pmydev->curlen) {
  123. 		size = BUF_LEN - pmydev->curlen;
  124. 	} else {
  125. 		size = count;
  126. 	}
  127.  
  128. 	ret = copy_from_user(pmydev->mydev_buf + pmydev->curlen, puser, size);
  129. 	if (ret) {
  130. 		mutex_unlock(&pmydev->lock);
  131. 		printk("copy_from_user failed\n");
  132. 		return -1;
  133. 	}
  134.  
  135. 	pmydev->curlen += size;
  136.  
  137. 	mutex_unlock(&pmydev->lock);
  138.  
  139. 	wake_up_interruptible(&pmydev->rq);
  140.  
  141. 	if (pmydev->pasync_obj != NULL) {
  142. 		kill_fasync(&pmydev->pasync_obj, SIGIO, POLL_IN);
  143. 	}
  144.  
  145. 	return size;
  146. }
  147.  
  148. long mychar_ioctl(struct file* pfile, unsigned int cmd, unsigned long arg)
  149. {
  150. 	int __user *pret = (int*)arg;
  151. 	int maxlen = BUF_LEN;
  152. 	int ret = 0;
  153. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  154.  
  155. 	switch (cmd) {
  156. 		case MYCHAR_IOCTL_GET_MAXLEN:
  157. 			ret = copy_to_user(pret, &maxlen, sizeof(int));
  158. 			if (ret) {
  159. 				printk("copy_to_user MAXLEN failed\n");
  160. 				return -1;
  161. 			}
  162. 			break;
  163. 		case MYCHAR_IOCTL_GET_CURLEN:
  164. 			mutex_lock(&pmydev->lock);
  165. 			ret = copy_to_user(pret, &pmydev->curlen, sizeof(int));
  166. 			mutex_unlock(&pmydev->lock);
  167. 			if (ret) {
  168. 				printk("copy_to_user CURLEN failed\n");
  169. 				return -1;
  170. 			}
  171. 			break;
  172. 		default:
  173. 			printk("The cmd is unknow\n");
  174. 			return -1;
  175. 	}
  176. 	return 0;
  177. }
  178.  
  179. unsigned int mychar_poll(struct file* pfile, poll_table* ptb)
  180. {
  181. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  182. 	unsigned int mask = 0;
  183.  
  184. 	poll_wait(pfile, &pmydev->rq, ptb);
  185. 	poll_wait(pfile, &pmydev->wq, ptb);
  186.  
  187. 	mutex_lock(&pmydev->lock);
  188. 	if (pmydev->curlen > 0) {
  189. 		mask |= POLLIN | POLLRDNORM;
  190. 	}
  191.  
  192. 	if (pmydev->curlen < BUF_LEN) {
  193. 		mask |= POLLOUT | POLLWRNORM;
  194. 	}
  195. 	mutex_unlock(&pmydev->lock);
  196.  
  197. 	return mask;
  198. }
  199.  
  200. int mychar_fasync(int fd, struct file* pfile, int mode) {
  201. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  202. 	return fasync_helper(fd, pfile, mode, &pmydev->pasync_obj);
  203. }
  204.  
  205. struct file_operations myops = {
  206. 	.owner = THIS_MODULE,
  207. 	.open = mychar_open,
  208. 	.release = mychar_close,
  209. 	.read = mychar_read,
  210. 	.write = mychar_write,
  211. 	.unlocked_ioctl = mychar_ioctl,
  212. 	.poll = mychar_poll,
  213. 	.fasync = mychar_fasync,
  214. };
  215.  
  216. int __init mychar_init(void)
  217. {
  218. 	int ret = 0;
  219. 	dev_t devno = MKDEV(major, minor);
  220.  
  221. 	/* 申请设备号 */
  222. 	ret = register_chrdev_region(devno, mychar_num, "mychar");
  223. 	if (ret) {
  224. 		ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
  225. 		if (ret) {
  226. 			printk("get devno failed\n");
  227. 			return -1;
  228. 		}
  229. 		major = MAJOR(devno);
  230. 	}
  231.  
  232. 	pgmydev = (struct mychar_dev*)kmalloc(sizeof(struct mychar_dev), GFP_KERNEL);
  233. 	if (NULL == pgmydev) {
  234. 		unregister_chrdev_region(devno, mychar_num);
  235. 		printk("kmalloc for struct mychar_dev failed\n");
  236. 		return -1;
  237. 	}
  238.  
  239. 	/* 给struct cdev对象指定操作函数集 */
  240. 	cdev_init(&pgmydev->mydev, &myops);
  241.  
  242. 	/* 给struct cdev对象添加到内核对应的数据结构里 */
  243. 	pgmydev->mydev.owner = THIS_MODULE;
  244. 	cdev_add(&pgmydev->mydev, devno, mychar_num);
  245.  
  246. 	init_waitqueue_head(&pgmydev->rq);
  247. 	init_waitqueue_head(&pgmydev->wq);
  248.  
  249. 	mutex_init(&pgmydev->lock);
  250. 	return 0;
  251. }
  252.  
  253. void __exit mychar_exit(void)
  254. {
  255. 	dev_t devno = MKDEV(major, minor);
  256. 	cdev_del(&pgmydev->mydev);
  257. 	unregister_chrdev_region(devno, mychar_num);
  258.  
  259. 	kfree(pgmydev);
  260. 	pgmydev = NULL;
  261. }
  262.  
  263.  
  264. MODULE_LICENSE("GPL");
  265.  
  266. module_init(mychar_init);
  267. module_exit(mychar_exit);

IO访问：访问外设控制器的寄存器

两种方式：

1. IO端口：X86上用IO指令访问
2. IO内存：外设寄存器在SOC芯片手册上都有相应物理地址

IO内存访问接口：

  1. static inline void __iomem *ioremap(unsigned long offset, unsigned long size)
  2. /*
  3. 功能：实现IO管脚的映射
  4. 参数：offset:该管脚的偏移地址
  5. 	 Size:该管脚映射空间的大小
  6. 返回值：成功返回映射的虚拟地址,失败NULL
  7. */
  8.  
  9. static inline void iounmap(volatile void __iomem *addr)
  10. /*
  11. 功能：解除io管脚的映射
  12. 参数：addr:io管脚映射的地址
  13. */
  14.  
  15. unsigned readb(void *addr); // 1字节   或ioread8(void *addr)
  16. unsigned readw(void *addr); // 2字节   或ioread16(void *addr)
  17. unsigned readl(void *addr); // 4字节   或ioread32(void *addr)
  18. /*
  19. 功能：读取寄存器的值
  20. 参数：addr  地址
  21. 返回值：读到的数据
  22. */
  23.  
  24. void writeb(unsigned value, void *addr); // 1字节   或iowrite8(u8 value, void *addr)
  25. void writew(unsigned value, void *addr); // 2字节  或iowrite16(u16 value, void *addr)
  26. void writel(unsigned value, void *addr); // 4字节  或iowrite32(u32 value, void *addr)
  27. /*
  28.  功能：向指定的寄存器中，写入数据。
  29.  参数：value：待写入寄存器中的数据
  30. 	  Address：寄存器的虚拟地址
  31. */

LED驱动

原理图

SOC芯片手册

GPX2_7 led2  GPX2CON----0x11000C40---28~31-----0001      GPX2DAT----0x11000C44-----7

GPX1_0 led3  GPX1CON----0x11000C20---    0~3-----0001      GPX1DAT----0x11000C24-----0

GPF3_4 led4  GPF3CON----0x114001E0--- 16~19-----0001      GPF3DAT----0x114001E4-----4

GPF3_5 led5  GPF3CON----0x114001E0--- 20~23-----0001      GPF3DAT----0x114001E4-----5

编写驱动步骤

a. 设计设备数据类型

b. 考虑需要支持的函数

c. 模块入口：ioremap + 设置成输出

d. 模块出口：iounmap

e. 编写关灯函数和开灯函数，实现ioctl

示例代码（LED驱动）

leddrv.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/cdev.h>
  5. #include <linux/wait.h>
  6. #include <linux/sched.h>
  7. #include <linux/poll.h>
  8. #include <linux/slab.h>
  9. #include <linux/mm.h>
  10. #include <linux/io.h>
  11. #include <asm/uaccess.h>
  12. #include <asm/atomic.h>
  13.  
  14. #include "leddrv.h"
  15.  
  16. #define GPX1CON 0x11000C20
  17. #define GPX1DAT 0x11000C24
  18.  
  19. #define GPX2CON 0x11000C40
  20. #define GPX2DAT 0x11000C44
  21.  
  22. #define GPF3CON 0x114001E0
  23. #define GPF3DAT 0x114001E4
  24.  
  25. int major = 11;
  26. int minor = 0;
  27. int myled_num = 1;
  28.  
  29. struct myled_dev
  30. {
  31.     struct cdev mydev;
  32.  
  33.     volatile unsigned long *pled2_con;
  34.     volatile unsigned long *pled2_dat;
  35.  
  36.     volatile unsigned long *pled3_con;
  37. 	volatile unsigned long *pled3_dat;
  38.  
  39. 	volatile unsigned long *pled4_con;
  40. 	volatile unsigned long *pled4_dat;
  41.  
  42. 	volatile unsigned long *pled5_con;
  43. 	volatile unsigned long *pled5_dat;
  44. };
  45.  
  46. struct myled_dev *pgmydev = NULL;
  47.  
  48. int myled_open(struct inode *pnode, struct file *pfile)
  49. {
  50.     pfile->private_data =(void*)(container_of(pnode->i_cdev,struct myled_dev,mydev));
  51.     return 0;
  52. }
  53.  
  54. int myled_close(struct inode *pnode, struct file *pfile)
  55. {
  56.     return 0;
  57. }
  58.  
  59. void led_on(struct myled_dev *pmydev, int ledno)
  60. {
  61.     switch (ledno) {
  62.         case 2:
  63.             writel(readl(pmydev->pled2_dat) | (0x1 << 7), pmydev->pled2_dat);
  64.             break;
  65.         case 3:
  66.             writel(readl(pmydev->pled3_dat) | (0x1 << 0), pmydev->pled3_dat);
  67. 			break;
  68. 		case 4:
  69. 			writel(readl(pmydev->pled4_dat) | (0x1 << 4), pmydev->pled4_dat);
  70. 			break;
  71. 		case 5:
  72. 			writel(readl(pmydev->pled5_dat) | (0x1 << 5), pmydev->pled5_dat);
  73. 			break;
  74.     }
  75. }
  76.  
  77. void led_off(struct myled_dev *pmydev, int ledno)
  78. {
  79.     switch (ledno) {
  80.         case 2:
  81. 			writel(readl(pmydev->pled2_dat) & (~(0x1 << 7)), pmydev->pled2_dat);
  82. 			break;
  83. 		case 3:
  84. 			writel(readl(pmydev->pled3_dat) & (~(0x1 << 0)), pmydev->pled3_dat);
  85. 			break;
  86. 		case 4:
  87. 			writel(readl(pmydev->pled4_dat) & (~(0x1 << 4)), pmydev->pled4_dat);
  88. 			break;
  89. 		case 5:
  90. 			writel(readl(pmydev->pled5_dat) & (~(0x1 << 5)), pmydev->pled5_dat);
  91. 			break;
  92.     }
  93. }
  94.  
  95. long myled_ioctl(struct file *pfile, unsigned int cmd, unsigned long arg)
  96. {
  97.     struct myled_dev *pmydev = (struct myled_dev*)pfile->private_data;
  98.  
  99.     if (arg < 2 || arg > 5) {
  100.         return -1;
  101.     }
  102.  
  103.     switch (cmd) {
  104.         case MY_LED_ON:
  105.             led_on(pmydev, arg);
  106.             break;
  107.         case MY_LED_OFF:
  108.             led_off(pmydev, arg);
  109.             break;
  110.         default:
  111.             return -1;
  112.     }
  113.  
  114.     return 0;
  115. }
  116.  
  117. struct file_operations myops = {
  118.     .owner = THIS_MODULE,
  119.     .open = myled_open,
  120.     .release = myled_close,
  121.     .unlocked_ioctl = myled_ioctl,
  122. };
  123.  
  124. void ioremap_ledreg(struct myled_dev *pmydev)
  125. {
  126.     pmydev->pled2_con = ioremap(GPX2CON, 4);
  127.     pmydev->pled2_dat = ioremap(GPX2DAT, 4);
  128.  
  129.     pmydev->pled3_con = ioremap(GPX1CON, 4);
  130. 	pmydev->pled3_dat = ioremap(GPX1DAT, 4);
  131. 	
  132. 	pmydev->pled4_con = ioremap(GPF3CON, 4);
  133. 	pmydev->pled4_dat = ioremap(GPF3DAT, 4);
  134. 	
  135. 	pmydev->pled5_con = pmydev->pled4_con;
  136. 	pmydev->pled5_dat = pmydev->pled4_dat;
  137. }
  138.  
  139. void iounmap_ledreg(struct myled_dev *pmydev)
  140. {
  141.     iounmap(pmydev->pled2_con);
  142.     iounmap(pmydev->pled2_dat);
  143.     pmydev->pled2_con = NULL;
  144.     pmydev->pled2_dat = NULL;
  145.  
  146.     iounmap(pmydev->pled3_con);
  147. 	iounmap(pmydev->pled3_dat);
  148. 	pmydev->pled3_con = NULL;
  149. 	pmydev->pled3_dat = NULL;
  150. 	
  151. 	iounmap(pmydev->pled4_con);
  152. 	iounmap(pmydev->pled4_dat);
  153. 	pmydev->pled4_con = NULL;
  154. 	pmydev->pled4_dat = NULL;
  155. 	
  156. 	pmydev->pled5_con = NULL;
  157. 	pmydev->pled5_dat = NULL;
  158. }
  159.  
  160. void set_output_ledconreg(struct myled_dev *pmydev)
  161. {
  162.     writel((readl(pmydev->pled2_con) & (~(0xF << 28))) | (0x1 << 28), pmydev->pled2_con);
  163. 	writel((readl(pmydev->pled3_con) & (~(0xF <<  0))) | (0x1 <<  0), pmydev->pled3_con);
  164. 	writel((readl(pmydev->pled4_con) & (~(0xF << 16))) | (0x1 << 16), pmydev->pled4_con);
  165. 	writel((readl(pmydev->pled5_con) & (~(0xF << 20))) | (0x1 << 20), pmydev->pled5_con);
  166.  
  167. 	writel(readl(pmydev->pled2_dat) & (~(0x1 << 7)), pmydev->pled2_dat);
  168. 	writel(readl(pmydev->pled3_dat) & (~(0x1 << 0)), pmydev->pled3_dat);
  169. 	writel(readl(pmydev->pled4_dat) & (~(0x1 << 4)), pmydev->pled4_dat);
  170. 	writel(readl(pmydev->pled5_dat) & (~(0x1 << 5)), pmydev->pled5_dat);
  171. }
  172.  
  173. int __init myled_init(void)
  174. {
  175. 	int ret = 0;
  176. 	dev_t devno = MKDEV(major, minor);
  177.  
  178. 	/* 申请设备号 */
  179. 	ret = register_chrdev_region(devno, myled_num, "myled");
  180. 	if (ret) {
  181. 		ret = alloc_chrdev_region(&devno, minor, myled_num, "myled");
  182. 		if (ret) {
  183. 			printk("get devno failed\n");
  184. 			return -1;
  185. 		}
  186. 		major = MAJOR(devno);
  187. 	}
  188.  
  189.     pgmydev = (struct myled_dev*)kmalloc(sizeof(struct myled_dev), GFP_KERNEL);
  190.     if (NULL == pgmydev) {
  191.         unregister_chrdev_region(devno, myled_num);
  192.         printk("kmalloc failed\n");
  193.         return -1;
  194.     }
  195.     memset(pgmydev, 0, sizeof(struct myled_dev));
  196.  
  197. 	/* 给struct cdev对象指定操作函数集 */
  198. 	cdev_init(&pgmydev->mydev, &myops);
  199.  
  200. 	/* 给struct cdev对象添加到内核对应的数据结构里 */
  201. 	pgmydev->mydev.owner = THIS_MODULE;
  202. 	cdev_add(&pgmydev->mydev, devno, myled_num);
  203.  
  204. 	/* ioremap */
  205. 	ioremap_ledreg(pgmydev);
  206.  
  207. 	/* con-register set output */
  208.     set_output_ledconreg(pgmydev);
  209.  
  210. 	return 0;
  211. }
  212.  
  213. void __exit myled_exit(void)
  214. {
  215. 	dev_t devno = MKDEV(major, minor);
  216.  
  217. 	/* iounmap */
  218.     iounmap_ledreg(pgmydev);
  219.  
  220. 	cdev_del(&pgmydev->mydev);
  221. 	unregister_chrdev_region(devno, myled_num);
  222.  
  223.     kfree(pgmydev);
  224.     pgmydev = NULL;
  225. }
  226.  
  227.  
  228. MODULE_LICENSE("GPL");
  229.  
  230. module_init(myled_init);
  231. module_exit(myled_exit);

leddrv.h

  1. #ifndef LED_DRIVER_H
  2. #define LED_DRIVER_H
  3.  
  4. #define LED_DEV_MAGIC 'g'
  5.  
  6. #define MY_LED_OFF _IO(LED_DEV_MAGIC, 0)
  7. #define MY_LED_ON  _IO(LED_DEV_MAGIC, 1)
  8.  
  9. #endif

testled.c

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <sys/ioctl.h>
  5. #include <unistd.h>
  6. #include <stdio.h>
  7.  
  8. #include "leddrv.h"
  9.  
  10. int main(int argc, char *argv[])
  11. {
  12.     int fd = -1;
  13.     int onoff = 0;
  14.     int no = 0;
  15.  
  16.     if (argc < 4) {
  17.         printf("The argument is too few\n");
  18.         return 1;
  19.     }
  20.  
  21.     sscanf(argv[2], "%d", &onoff);
  22.     sscanf(argv[3], "%d", &no);
  23.  
  24.     if (no < 2 || no > 5) {
  25.         printf("led-no is invalid\n");
  26.         return 2;
  27.     }
  28.  
  29.     fd = open(argv[1], O_RDONLY);
  30.     if (fd < 0) {
  31.         printf("open %s failed\n", argv[1]);
  32.         return 3;
  33.     }
  34.  
  35.     if (onoff) {
  36.         ioctl(fd, MY_LED_ON, no);
  37.     } else {
  38.         ioctl(fd, MY_LED_OFF, no);
  39.     }
  40.  
  41.     close(fd);
  42.     fd = -1;
  43.     return 0;
  44. }

测试结果

ubuntu上将 leddrv.c 编译成 arm 架构的 ko 文件，将 testled.c 编译成 arm 架构的可执行文件，再将这两个文件拷贝到挂载的根文件系统目录下

  1. shrek@ubuntu16:~/share/mydrivercode$ make ARCH=arm
  2. shrek@ubuntu16:~/share/mydrivercode$ arm-none-linux-gnueabi-gcc ./testled.c -o testled
  3. shrek@ubuntu16:~/share/mydrivercode$ cp leddrv.ko /opt/4412/rootfs/
  4. shrek@ubuntu16:~/share/mydrivercode$ cp testled /opt/4412/rootfs/

开发板上挂载好根文件系统，执行如下命令

  1. [root@farsight]#insmod leddrv.ko
  2. [root@farsight]#cat /proc/devices | grep led
  3.  11 myled
  4. [root@farsight]#mknod /dev/leddev c 11 0
  5. [root@farsight]#./testled /dev/leddev 1 2
  6. [root@farsight]#./testled /dev/leddev 1 3
  7. [root@farsight]#./testled /dev/leddev 1 4
  8. [root@farsight]#./testled /dev/leddev 1 5
  9. [root@farsight]#./testled /dev/leddev 0 5
  10. [root@farsight]#./testled /dev/leddev 0 4
  11. [root@farsight]#./testled /dev/leddev 0 3
  12. [root@farsight]#./testled /dev/leddev 0 2

看到开发板上的LED灯可以控制亮灭

设备树

起源

减少垃圾代码
减轻驱动开发工作量
驱动代码和设备信息分离
参考Open Firmware设计
用来记录硬件平台中各种硬件设备的属性信息

基本组成

两种源文件：

1. xxxxx.dts dts是device tree source的缩写
2. xxxxx.dtsi dtsi是device tree source include的缩写，意味着这样源文件用于被dts文件包含用

基本语法

dts文件主体内容由多个节点组成
每个节点可以包含0或多个子节点，形成树状关系
每个dts文件都有一个根节点，其它节点都是它的子孙
根节点一般来描述整个开发板硬件平台，其它节点用来表示具体设备、总线的属性信息
各个节点可以有多个属性，每个属性用key-value键值对来表示

节点语法：

  1. [label:] node-name[@unit-address] {    
  2. 	[properties definitions];    
  3. 	[child nodes];
  4. };
  5.  
  6. []表示可选项
  7. label：可选项，节点别名，为了缩短节点访问路径，后续节点中可以使用  &label 来表示引用指定节点
  8. node-name：节点名
  9. unit-address：可选项，设备地址，一般填写该设备寄存器组或内存块的首地址
  10. properties definitions：可选项，属性定义
  11. child nodes：可选项，子节点

属性语法：

  1. [label:] property-name = value;
  2. [label:] property-name;
  3.  
  4. 属性可以无值
  5. 有值的属性，可以有三种取值：
  6. 1. arrays of cells(1个或多个32位数据, 64位数据使用2个32位数据表示，空格分隔),用尖括号表示(< >)
  7. 2. string(字符串), 用双引号表示(" ")
  8. 3. bytestring(1个或多个字节，空格分隔),用方括号表示([])
  9. 4. 用,分隔的多值

特殊节点

根节点

根节点表示整块开发板的信息

  1. #address-cells   // 在子节点的reg属性中, 使用多少个u32整数来描述地址(address)
  2. #size-cells      // 在子节点的reg属性中, 使用多少个u32整数来描述大小(size)
  3. compatible       // 定义一系列的字符串, 用来指定内核中哪个machine_desc可以支持本设备，即描述其兼容哪些平台                         
  4. model            // 比如有2款板子配置基本一致, 它们的compatible是一样的，那么就通过model来分辨这2款板子

/memory

所有设备树文件的必需节点，它定义了系统物理内存的 layout

  1. device_type = "memory";
  2. reg             //用来指定内存的地址、大小

/chosen

传递内核启动时使用的参数parameter

bootargs  //字符串，内核启动参数, 跟u-boot中设置的bootargs作用一样

/cpus  多核CPU支持

/cpus节点下有1个或多个cpu子节点，cpu子节点中用reg属性用来标明自己是哪一个cpu

所以 /cpus 中有以下2个属性:

  1. #address-cells   // 在它的子节点的reg属性中, 使用多少个u32整数来描述地址(address)
  2. #size-cells      // 在它的子节点的reg属性中, 使用多少个u32整数来描述大小(size) 必须设置为0

常用属性

phandle

数字形式的节点标识，在后续节点中属性值性质表示某节点时，可以引用对应节点

如：

  1. pic@10000000 {    
  2. 	phandle = <1>;    
  3. 	interrupt-controller;
  4. };
  5. another-device-node {    
  6. 	interrupt-parent = <1>;   // 使用phandle值为1来引用上述节点
  7. };

地址  ---  重要

reg属性：表示内存区域region，语法：

reg = <address1 length1 [address2 length2] [address3 length3]>;

#address-cells：reg属性中, 使用多少个u32整数来描述地址(address)，语法：

#address-cells = <数字>;

#size-cells：reg属性中, 使用多少个u32整数来描述大小(size)，语法：

#size-cells = <数字>;

compatible  ---  重要

驱动和设备（设备节点）的匹配依据，compatible（兼容性）的值可以有不止一个字符串以满足不同的需求，语法：

compatible = "字符串1","字符串2",...;

中断  ---  重要

a. 中断控制器节点用的属性：

interrupt-controller 一个无值空属性用来声明这个node接收中断信号,表示该节点是一个中断控制器

#interrupt-cells 这是中断控制器节点的属性，用来标识这个控制器需要几个单位做中断描述符

b. 中断源设备节点用的属性：

interrupt-parent：标识此设备节点属于哪一个中断控制器，如果没有设置这个属性，会自动依附父节点的，语法：

interrupt-parent = <引用某中断控制器节点>

interrupts 一个中断标识符列表，表示每一个中断输出信号，语法：

  1. interrupts = <中断号 触发方式>
  2.  
  3. 1 low-to-high 上升沿触发
  4. 2 high-to-low 下降沿触发
  5. 4 high level  高电平触发
  6. 8 low level   低电平触发

gpio  ---  重要

gpio也是最常见的IO口，常用的属性有：

a. 对于GPIO控制器：

gpio-controller，无值空属性，用来说明该节点描述的是一个gpio控制器

#gpio-cells，用来表示要用几个cell描述一个 GPIO引脚

b. 对于GPIO使用者节点：

gpio使用节点的属性

  1. xxx-gpio = <&引用GPIO控制器 GPIO标号 工作模式>
  2. 工作模式：
  3. 1 低电平有效 GPIO_ACTIVE_HIGH
  4. 0 高电平有效 GPIO_ACTIVE_LOW

属性设置套路

一般来说，每一种设备的节点属性设置都会有一些套路，比如可以设置哪些属性？属性值怎么设置？那怎么知道这些套路呢，有两种思路：

1. 抄类似的dts，比如我们自己项目的平台是4412，那么就可以抄exynos4412-tiny4412.dts、exynos4412-smdk4412.dts这类相近的dts
2. 查询内核中的文档，比如Documentation/devicetree/bindings/i2c/i2c-imx.txt就描述了imx平台的i2c属性设置方法；Documentation/devicetree/bindings/fb就描述了lcd、lvds这类属性设置方法

常用接口

struct device_node  对应设备树中的一个节点
struct property 对应节点中一个属性

of_find_node_by_path

  1. /*
  2. include/of.h
  3. of_find_node_by_path - 通过路径查找指定节点
  4. @path - 带全路径的节点名，也可以是节点的别名
  5. 成功：得到节点的首地址；失败：NULL
  6. */
  7. struct device_node * of_find_node_by_path(const char *path);

of_find_property

  1. /*
  2. include/of.h
  3. of_find_property - 提取指定属性的值
  4. @np - 设备节点指针
  5. @name - 属性名称
  6. @lenp - 属性值的字节数
  7. 成功：属性值的首地址；失败：NULL
  8. */
  9. struct property *of_find_property(const struct device_node *np, const char *name, int *lenp);

of_get_named_gpio

  1. /*
  2.  * include/of_gpio.h
  3.  * of_get_named_gpio - 从设备树中提取gpio口
  4.  * @np - 设备节点指针
  5.  * @propname - 属性名
  6.  * @index - gpio口引脚标号 
  7.  * 成功：得到GPIO口编号；失败：负数，绝对值是错误码
  8.  */
  9. int of_get_named_gpio(struct device_node *np, const char *propname, int index);

irq_of_parse_and_map

  1. /*
  2. 	功能：获得设备树中的中断号并进行映射
  3. 	参数：node：设备节点
  4. 		 index:序号
  5. 	返回值：成功：中断号	失败：错误码
  6. */
  7. unsigned int irq_of_parse_and_map(struct device_node *node, int index)；

读属性值

  1. /*
  2. of_property_read_string - 提取字符串（属性值）
  3. @np - 设备节点指针
  4. @propname - 属性名称
  5. @out_string - 输出参数，指向字符串（属性值）
  6. 成功：0；失败：负数，绝对值是错误码
  7. */
  8. int of_property_read_string(struct device_node *np, const char *propname, const char **out_string);

读数值

  1. int of_property_read_u8(const struct device_node *np,const char *propname,u8 *out_value)
  2.  
  3. int of_property_read_u16(const struct device_node *np,const char *propname,u16 *out_value)
  4.  
  5. int of_property_read_u32(const struct device_node *np,const char *propname,u32 *out_value)

判断属性是否存在

int of_property_read_bool(const struct device_node *np,const char *propname)

读数组

int of_property_read_u32_array(const struct device_node *np,const char *propname,u32 *out_value,size_t sz)

GPIO接口

向内核申请GPIO

int gpio_request(unsigned gpio,const char *label) 

功能：其实就是让内核检查一下该GPIO引脚是否被其它设备占用，如果没有占用则返回0并用label做一下标记，表示被本设备占用，否则返回负数

void gpio_free(unsigned gpio)

功能：去除本设备对该GPIO的占用标记，表示本设备向内核归还对该GPIO引脚的使用权，此后其它设备可占用该GPIO引脚

设置GPIO方向

  1. int gpio_direction_input(unsigned gpio)
  2.  
  3. int gpio_direction_output(unsigned gpio,int value)

读写GPIO数据

  1. int gpio_get_value(unsigned gpio)
  2.  
  3. int gpio_set_value(unsigned gpio,int value)

LED驱动设备树版

1. 在设备树源文件的根节点下添加本设备的节点（该节点中包含本设备用到的资源信息）

   ..../linux3.14/arch/arm/boot/dts/exynos4412-fs4412.dts

  1. fs4412-leds {
  2.     compatible = "4412,led2-5";
  3.     led2-gpio = <&gpx2 7 0>;
  4.     led3-gpio = <&gpx1 0 0>;
  5.     led4-gpio = <&gpf3 4 0>;
  6.     led5-gpio = <&gpf3 5 0>;
  7. };

 2. 在linux内核源码的顶层目录下执行：make dtbs  （生成对应的dtb文件）

 3. cp   ?????.dtb   /tftpboot

 4. 编写驱动代码：

    a. 通过本设备在设备树中的路径找到对应节点（struct device_node类型的地址值）

    b. 调用 of_get_named_gpio 函数得到某个GPIO的编号

    c. struct leddev结构体中记录所有用到的GPIO编号

    d. 使用某个GPIO引脚前需先通过gpio_request函数向内核申请占用该引脚，不用该引脚时可通过gpio_free归还给内核

    e. 通过gpio_direction_input和gpio_direction_output函数来设置某个GPIO的作用

    f. 通过gpio_get_value函数可以获取某个GPIO引脚的当前电平

    g. 通过gpio_set_value函数可以改变某个GPIO引脚的电平

示例代码（LED驱动，设备树版）

leddrv.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/gpio.h>
  5. #include <linux/of_gpio.h>
  6. #include <linux/cdev.h>
  7. #include <linux/wait.h>
  8. #include <linux/sched.h>
  9. #include <linux/poll.h>
  10. #include <linux/slab.h>
  11. #include <linux/mm.h>
  12. #include <linux/io.h>
  13. #include <asm/uaccess.h>
  14. #include <asm/atomic.h>
  15.  
  16. #include "leddrv.h"
  17.  
  18. int major = 11;
  19. int minor = 0;
  20. int myled_num = 1;
  21.  
  22. struct myled_dev
  23. {
  24.     struct cdev mydev;
  25.  
  26.     unsigned int led2gpio;
  27. 	unsigned int led3gpio;
  28. 	unsigned int led4gpio;
  29. 	unsigned int led5gpio;
  30. };
  31.  
  32. struct myled_dev *pgmydev = NULL;
  33.  
  34. int myled_open(struct inode *pnode, struct file *pfile)
  35. {
  36.     pfile->private_data =(void*)(container_of(pnode->i_cdev,struct myled_dev,mydev));
  37.     return 0;
  38. }
  39.  
  40. int myled_close(struct inode *pnode, struct file *pfile)
  41. {
  42.     return 0;
  43. }
  44.  
  45. void led_on(struct myled_dev *pmydev, int ledno)
  46. {
  47.     switch (ledno) {
  48.         case 2:
  49.             gpio_set_value(pmydev->led2gpio, 1);
  50.             break;
  51.         case 3:
  52.             gpio_set_value(pmydev->led3gpio, 1);
  53. 			break;
  54. 		case 4:
  55. 			gpio_set_value(pmydev->led4gpio, 1);
  56. 			break;
  57. 		case 5:
  58. 			gpio_set_value(pmydev->led5gpio, 1);
  59. 			break;
  60.     }
  61. }
  62.  
  63. void led_off(struct myled_dev *pmydev, int ledno)
  64. {
  65.     switch (ledno) {
  66.         case 2:
  67. 			gpio_set_value(pmydev->led2gpio, 0);
  68. 			break;
  69. 		case 3:
  70. 			gpio_set_value(pmydev->led3gpio, 0);
  71. 			break;
  72. 		case 4:
  73. 			gpio_set_value(pmydev->led4gpio, 0);
  74. 			break;
  75. 		case 5:
  76. 			gpio_set_value(pmydev->led5gpio, 0);
  77. 			break;
  78.     }
  79. }
  80.  
  81. long myled_ioctl(struct file *pfile, unsigned int cmd, unsigned long arg)
  82. {
  83.     struct myled_dev *pmydev = (struct myled_dev*)pfile->private_data;
  84.  
  85.     if (arg < 2 || arg > 5) {
  86.         return -1;
  87.     }
  88.  
  89.     switch (cmd) {
  90.         case MY_LED_ON:
  91.             led_on(pmydev, arg);
  92.             break;
  93.         case MY_LED_OFF:
  94.             led_off(pmydev, arg);
  95.             break;
  96.         default:
  97.             return -1;
  98.     }
  99.  
  100.     return 0;
  101. }
  102.  
  103. struct file_operations myops = {
  104.     .owner = THIS_MODULE,
  105.     .open = myled_open,
  106.     .release = myled_close,
  107.     .unlocked_ioctl = myled_ioctl,
  108. };
  109.  
  110. void request_leds_gpio(struct myled_dev *pmydev, struct device_node *pnode) // 申请占用设备
  111. {
  112. 	pmydev->led2gpio = of_get_named_gpio(pnode, "led2-gpio", 0);
  113. 	gpio_request(pmydev->led2gpio, "led2");
  114.  
  115. 	pmydev->led3gpio = of_get_named_gpio(pnode, "led3-gpio", 0);
  116. 	gpio_request(pmydev->led3gpio, "led3");
  117.  
  118. 	pmydev->led4gpio = of_get_named_gpio(pnode, "led4-gpio", 0);
  119. 	gpio_request(pmydev->led4gpio, "led4");
  120.  
  121. 	pmydev->led5gpio = of_get_named_gpio(pnode, "led5-gpio", 0);
  122. 	gpio_request(pmydev->led5gpio, "led5");
  123.  
  124. }
  125.  
  126. void set_leds_gpio_output(struct myled_dev *pmydev) // 配置成输出
  127. {
  128. 	gpio_direction_output(pmydev->led2gpio, 0);
  129. 	gpio_direction_output(pmydev->led3gpio, 0);
  130. 	gpio_direction_output(pmydev->led4gpio, 0);
  131. 	gpio_direction_output(pmydev->led5gpio, 0);
  132. }
  133.  
  134. void free_leds_gpio(struct myled_dev *pmydev) // free设备
  135. {
  136. 	gpio_free(pmydev->led2gpio);
  137. 	gpio_free(pmydev->led3gpio);
  138. 	gpio_free(pmydev->led4gpio);
  139. 	gpio_free(pmydev->led5gpio);
  140. }
  141.  
  142. int __init myled_init(void)
  143. {
  144. 	int ret = 0;
  145. 	dev_t devno = MKDEV(major, minor);
  146. 	struct device_node *pnode = NULL;
  147.  
  148. 	pnode = of_find_node_by_path("/fs4412-leds"); // 设备树中的节点名
  149. 	if (NULL == pnode) {
  150. 		printk("find node by path failed\n");
  151. 		return -1;
  152. 	}
  153.  
  154. 	ret = register_chrdev_region(devno, myled_num, "myled");
  155. 	if (ret) {
  156. 		ret = alloc_chrdev_region(&devno, minor, myled_num, "myled");
  157. 		if (ret) {
  158. 			printk("get devno failed\n");
  159. 			return -1;
  160. 		}
  161. 		major = MAJOR(devno);
  162. 	}
  163.  
  164.     pgmydev = (struct myled_dev*)kmalloc(sizeof(struct myled_dev), GFP_KERNEL);
  165.     if (NULL == pgmydev) {
  166.         unregister_chrdev_region(devno, myled_num);
  167.         printk("kmalloc failed\n");
  168.         return -1;
  169.     }
  170.     memset(pgmydev, 0, sizeof(struct myled_dev));
  171.  
  172. 	cdev_init(&pgmydev->mydev, &myops);
  173.  
  174. 	pgmydev->mydev.owner = THIS_MODULE;
  175. 	cdev_add(&pgmydev->mydev, devno, myled_num);
  176.  
  177. 	/* ioremap */
  178. 	request_leds_gpio(pgmydev, pnode);
  179.  
  180. 	/* con-register set output */
  181.     set_leds_gpio_output(pgmydev);
  182.  
  183. 	return 0;
  184. }
  185.  
  186. void __exit myled_exit(void)
  187. {
  188. 	dev_t devno = MKDEV(major, minor);
  189.  
  190.     /* iounmap */
  191. 	free_leds_gpio(pgmydev);
  192.  
  193. 	cdev_del(&pgmydev->mydev);
  194. 	unregister_chrdev_region(devno, myled_num);
  195.  
  196.     kfree(pgmydev);
  197.     pgmydev = NULL;
  198. }
  199.  
  200.  
  201. MODULE_LICENSE("GPL");
  202.  
  203. module_init(myled_init);
  204. module_exit(myled_exit);

leddrv.h

  1. #ifndef LED_DRIVER_H
  2. #define LED_DRIVER_H
  3.  
  4. #define LED_DEV_MAGIC 'g'
  5.  
  6. #define MY_LED_OFF _IO(LED_DEV_MAGIC, 0)
  7. #define MY_LED_ON  _IO(LED_DEV_MAGIC, 1)
  8.  
  9. #endif

testled.c

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <sys/ioctl.h>
  5. #include <unistd.h>
  6. #include <stdio.h>
  7.  
  8. #include "leddrv.h"
  9.  
  10. int main(int argc, char *argv[])
  11. {
  12.     int fd = -1;
  13.     int onoff = 0;
  14.     int no = 0;
  15.  
  16.     if (argc < 4) {
  17.         printf("The argument is too few\n");
  18.         return 1;
  19.     }
  20.  
  21.     sscanf(argv[2], "%d", &onoff);
  22.     sscanf(argv[3], "%d", &no);
  23.  
  24.     if (no < 2 || no > 5) {
  25.         printf("led-no is invalid\n");
  26.         return 2;
  27.     }
  28.  
  29.     fd = open(argv[1], O_RDONLY);
  30.     if (fd < 0) {
  31.         printf("open %s failed\n", argv[1]);
  32.         return 3;
  33.     }
  34.  
  35.     if (onoff) {
  36.         ioctl(fd, MY_LED_ON, no);
  37.     } else {
  38.         ioctl(fd, MY_LED_OFF, no);
  39.     }
  40.  
  41.     close(fd);
  42.     fd = -1;
  43.     return 0;
  44. }

测试结果

ubuntu上将 leddrv.c 编译成 arm 架构的 ko 文件，将 testled.c 编译成 arm 架构的可执行文件，再将这两个文件拷贝到挂载的根文件系统目录下

  1. shrek@ubuntu16:~/share/mydrivercode$ make ARCH=arm
  2. shrek@ubuntu16:~/share/mydrivercode$ arm-none-linux-gnueabi-gcc ./testled.c -o testled
  3. shrek@ubuntu16:~/share/mydrivercode$ cp leddrv.ko /opt/4412/rootfs/
  4. shrek@ubuntu16:~/share/mydrivercode$ cp testled /opt/4412/rootfs/

开发板上挂载好根文件系统，执行如下命令

  1. [root@farsight]#insmod leddrv.ko
  2. [root@farsight]#cat /proc/devices | grep led
  3.  11 myled
  4. [root@farsight]#mknod /dev/leddev c 11 0
  5. [root@farsight]#./testled /dev/leddev 1 2
  6. [root@farsight]#./testled /dev/leddev 1 3
  7. [root@farsight]#./testled /dev/leddev 1 4
  8. [root@farsight]#./testled /dev/leddev 1 5
  9. [root@farsight]#./testled /dev/leddev 0 5
  10. [root@farsight]#./testled /dev/leddev 0 4
  11. [root@farsight]#./testled /dev/leddev 0 3
  12. [root@farsight]#./testled /dev/leddev 0 2

看到开发板上的LED灯可以控制亮灭

中断处理

什么是中断

一种硬件上的通知机制，用来通知CPU发生了某种需要立即处理的事件

分为：

1. 内部中断  CPU执行程序的过程中，发生的一些硬件出错、运算出错事件（如分母为0、溢出等等），不可屏蔽
2. 外部中断  外设发生某种情况，通过一个引脚的高、低电平变化来通知CPU （如外设产生了数据、某种处理完毕等等）

中断处理原理

任何一种中断产生，CPU都会暂停当前执行的程序，跳转到内存固定位置执行一段程序，该程序被称为总的中断服务程序，在该程序中区分中断源，然后进一步调用该中断源对应的处理函数。

中断源对应的处理函数被称为分中断处理程序，一般每一个分中断处理程序对应一个外设产生的中断

写驱动时，如果外设有中断，则需要编写一个函数（分中断处理程序）来处理这种中断

中断接口

中断申请 

  1. int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,const char *name, void *dev)
  2. /*
  3. 参数：
  4.     irq：所申请的中断号
  5.     handler：该中断号对应的中断处理函数
  6.     flags：中断触发方式或处理方式 
  7.         触发方式：IRQF_TRIGGER_NONE         //无触发
  8.                   IRQF_TRIGGER_RISING      //上升沿触发
  9.                   IRQF_TRIGGER_FALLING     //下降沿触发
  10.                   IRQF_TRIGGER_HIGH        //高电平触发
  11.                   IRQF_TRIGGER_LOW         //低电平触发
  12.         处理方式：
  13.                   IRQF_DISABLED            //用于快速中断，处理中屏蔽所有中断
  14.                   IRQF_SHARED              //共享中断
  15.         name：中断名 /proc/interrupts
  16.         dev：传递给中断例程的参数，共享中断时用于区分那个设备，一般为对应设备的结构体地址，无共享中断时写NULL
  17. 返回值：成功：0 失败：错误码
  18. */

中断释放

  1. void free_irq(unsigned int irq, void *dev_id)；
  2. /*
  3. 功能：释放中断号
  4. 参数：
  5.     irq：设备号
  6.     dev_id：共享中断时用于区分那个设备一般强转成设备号，无共享中断时写NULL
  7. */

中断处理函数原型

  1. typedef irqreturn_t (*irq_handler_t)(int, void *);
  2. /*
  3. 参数：
  4.     int：中断号
  5.     void*:对应的申请中断时的dev_id
  6. 返回值：
  7.     typedef enum irqreturn irqreturn_t;    //中断返回值类型
  8.     enum irqreturn {
  9.         IRQ_NONE    = (0 << 0),
  10.         IRQ_HANDLED    = (1 << 0),
  11.         IRQ_WAKE_THREAD    = (1 << 1),
  12.     };
  13.     返回IRQ_HANDLED表示处理完了,返回IRQ_NONE在共享中断表示不处理
  14. */

按键驱动

exynos4412-fs4412.dts中增加节点

  1. mykey2_node {
  2.     compatible = "mykey2,key2";
  3.     key2-gpio = <&gpx1 1 0>;
  4.     interrupt-parent = <&gpx1>;
  5.     interrupts = <1 3>;
  6. };

示例代码（按键驱动）

key.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/gpio.h>
  5. #include <linux/interrupt.h>
  6. #include <linux/of_gpio.h>
  7. #include <linux/of_irq.h>
  8. #include <linux/cdev.h>
  9. #include <linux/wait.h>
  10. #include <linux/sched.h>
  11. #include <linux/poll.h>
  12. #include <linux/mm.h>
  13. #include <linux/delay.h>
  14. #include <linux/slab.h>
  15. #include <asm/uaccess.h>
  16.  
  17. #include "key.h"
  18.  
  19. int major = 11;
  20. int minor = 0;
  21. int key2_num = 1;
  22.  
  23. struct key2_dev
  24. {
  25. 	struct cdev mydev;
  26.  
  27. 	int gpio; // GPIO号
  28.     int irqno; // 中断号
  29.  
  30.     struct keyvalue data; // 按键产生的数据
  31.     int newflag; // 按键产生标志
  32.     spinlock_t lock;
  33.  
  34. 	wait_queue_head_t rq;
  35. };
  36.  
  37. struct key2_dev *pgmydev = NULL;
  38.  
  39. int key2_open(struct inode* pnode, struct file* pfile)
  40. {
  41. 	pfile->private_data = (void *)(container_of(pnode->i_cdev, struct key2_dev, mydev));
  42. 	return 0;
  43. }
  44.  
  45. int key2_close(struct inode* pnode, struct file* pfile)
  46. {
  47. 	return 0;
  48. }
  49.  
  50. ssize_t key2_read(struct file* pfile, char __user *puser, size_t count, loff_t* p_pos)
  51. {
  52. 	struct key2_dev *pmydev = (struct key2_dev *)pfile->private_data;
  53. 	int size = 0;
  54. 	int ret = 0;
  55.  
  56.     if (count < sizeof(struct keyvalue)) {
  57.         printk("expect read size is invalid\n");
  58.         return -1;
  59.     }
  60.  
  61. 	spin_lock(&pmydev->lock);
  62. 	if (!pmydev->newflag) {
  63.         if (pfile->f_flags & O_NONBLOCK) {
  64.             // 非阻塞
  65.             spin_unlock(&pmydev->lock);
  66.             printk("O_NONBLOCK No Data Read\n");
  67.             return -1;
  68.         } else {
  69.             // 阻塞
  70.             spin_unlock(&pmydev->lock);
  71.             ret = wait_event_interruptible(pmydev->rq, pmydev->newflag == 1);
  72.             if (ret) {
  73.                 printk("Wake up by signal\n");
  74. 				return -ERESTARTSYS;
  75.             }
  76.             spin_lock(&pmydev->lock);
  77.         }
  78.     }
  79.  
  80. 	if (count > sizeof(struct keyvalue)) {
  81. 		size = sizeof(struct keyvalue);
  82. 	} else {
  83. 		size = count;
  84. 	}
  85.  
  86. 	ret = copy_to_user(puser, &pmydev->data, size);
  87. 	if (ret) {
  88. 		spin_unlock(&pmydev->lock);
  89. 		printk("copy_to_user failed\n");
  90. 		return -1;
  91. 	}
  92.  
  93. 	pmydev->newflag = 0;
  94.  
  95.     spin_unlock(&pmydev->lock);
  96.  
  97. 	return size;
  98. }
  99.  
  100. unsigned int key2_poll(struct file* pfile, poll_table* ptb)
  101. {
  102. 	struct key2_dev *pmydev = (struct key2_dev *)pfile->private_data;
  103. 	unsigned int mask = 0;
  104.  
  105. 	poll_wait(pfile, &pmydev->rq, ptb);
  106.  
  107. 	spin_lock(&pmydev->lock);
  108. 	if (pmydev->newflag) {
  109. 		mask |= POLLIN | POLLRDNORM;
  110. 	}
  111. 	spin_unlock(&pmydev->lock);
  112.  
  113. 	return mask;
  114. }
  115.  
  116. struct file_operations myops = {
  117. 	.owner = THIS_MODULE,
  118. 	.open = key2_open,
  119. 	.release = key2_close,
  120. 	.read = key2_read,
  121. 	.poll = key2_poll,
  122. };
  123.  
  124. irqreturn_t key2_irq_handle(int no, void *arg)
  125. {
  126.     struct key2_dev *pmydev = (struct key2_dev*)arg;
  127.     int status1 = 0;
  128.     int status2 = 0;
  129.     int status = 0;
  130.  
  131.     status1 = gpio_get_value(pmydev->gpio);
  132.     mdelay(1);
  133.     status2 = gpio_get_value(pmydev->gpio);
  134.  
  135.     if (status1 != status2) {
  136.         return IRQ_NONE;
  137.     }
  138.  
  139.     status = status1;
  140.  
  141.     spin_lock(&pmydev->lock);
  142.     if (status == pmydev->data.status) {
  143.         spin_unlock(&pmydev->lock);
  144.         return IRQ_NONE;