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;
  145.     }
  146.  
  147.     pmydev->data.code = KEY2;
  148.     pmydev->data.status = status;
  149.     pmydev->newflag = 1;
  150.  
  151.     spin_unlock(&pmydev->lock);
  152.     wake_up(&pmydev->rq);
  153.  
  154.     return IRQ_HANDLED;
  155. }
  156.  
  157. int __init key2_init(void)
  158. {
  159. 	int ret = 0;
  160. 	dev_t devno = MKDEV(major, minor);
  161.  
  162.     struct device_node *pnode = NULL;
  163.  
  164.     pnode = of_find_node_by_path("/mykey2_node"); // 设备树中的节点
  165.     if (NULL == pnode) {
  166.         printk("find node failed\n");
  167.         return -1;
  168.     }
  169.  
  170.     pgmydev = (struct key2_dev*)kmalloc(sizeof(struct key2_dev), GFP_KERNEL);
  171.     if (NULL == pgmydev) {
  172.         printk("kmalloc for struct key2_dev failed\n");
  173.         return -1;
  174.     }
  175.  
  176.     pgmydev->gpio = of_get_named_gpio(pnode, "key2-gpio", 0); // 得到GPIO的编号
  177.     pgmydev->irqno = irq_of_parse_and_map(pnode, 0); // 得到中断号
  178.  
  179. 	ret = register_chrdev_region(devno, key2_num, "key2");
  180. 	if (ret) {
  181. 		ret = alloc_chrdev_region(&devno, minor, key2_num, "key2");
  182. 		if (ret) {
  183.             kfree(pgmydev);
  184.             pgmydev = NULL;
  185. 			printk("get devno failed\n");
  186. 			return -1;
  187. 		}
  188. 		major = MAJOR(devno);
  189. 	}
  190.  
  191. 	cdev_init(&pgmydev->mydev, &myops);
  192.  
  193. 	pgmydev->mydev.owner = THIS_MODULE;
  194. 	cdev_add(&pgmydev->mydev, devno, key2_num);
  195.  
  196. 	init_waitqueue_head(&pgmydev->rq);
  197.  
  198. 	spin_lock_init(&pgmydev->lock);
  199.  
  200.     ret = request_irq(pgmydev->irqno, key2_irq_handle, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "key2", pgmydev); // 中断申请
  201.     if (ret) {
  202.         printk("request_irq failed\n");
  203.         cdev_del(&pgmydev->mydev);
  204.         kfree(pgmydev);
  205.         pgmydev = NULL;
  206.         unregister_chrdev_region(devno, key2_num);
  207.         return -1;
  208.     }
  209.  
  210. 	return 0;
  211. }
  212.  
  213. void __exit key2_exit(void)
  214. {
  215. 	dev_t devno = MKDEV(major, minor);
  216.     free_irq(pgmydev->irqno, pgmydev); // 释放中断
  217. 	cdev_del(&pgmydev->mydev);
  218. 	unregister_chrdev_region(devno, key2_num);
  219.  
  220. 	kfree(pgmydev);
  221. 	pgmydev = NULL;
  222. }
  223.  
  224.  
  225. MODULE_LICENSE("GPL");
  226.  
  227. module_init(key2_init);
  228. module_exit(key2_exit);

key.h

  1. #ifndef KEY_H
  2. #define KEY_H
  3.  
  4. enum KEYCODE
  5. {
  6. 	KEY2 = 1002,
  7. 	KEY3,
  8. 	KEY4,
  9. };
  10.  
  11. enum KEY_STATUS
  12. {
  13. 	KEY_DOWN = 0,
  14. 	KEY_UP,
  15. };
  16.  
  17. struct keyvalue
  18. {
  19. 	int code; // which KEY
  20. 	int status;
  21. };
  22.  
  23. #endif

testkey.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 "key.h"
  9.  
  10. int main(int argc, char *argv[])
  11. {
  12.     int fd = -1;
  13.     struct keyvalue keydata = {0};
  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_RDONLY);
  22.     if (fd < 0) {
  23.         printf("open %s failed\n", argv[1]);
  24.         return 3;
  25.     }
  26.  
  27.     while ((ret = read(fd, &keydata, sizeof(keydata))) == sizeof(keydata)) {
  28.         if (keydata.status == KEY_DOWN) {
  29.             printf("Key2 is down!\n");
  30.         } else {
  31.             printf("Key2 is up!\n");
  32.         }
  33.     }
  34.  
  35.     close(fd);
  36.     fd = -1;
  37.     return 0;
  38. }

测试结果

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

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

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

  1. [root@farsight]#insmod key.ko
  2. [root@farsight]#cat /proc/devices | grep key
  3.  11 key2
  4. [root@farsight]#mknod /dev/mykey c 11 0
  5. [root@farsight]#./testkey /dev/mykey 
  6. Key2 is down!
  7. Key2 is up!

当按下开发板的 key2 按键时，终端可以打印出相应信息

上半部与下半部

起源：

1. 中断处理程序执行时间过长引起的问题
2. 有些设备的中断处理程序必须要处理一些耗时操作

下半部机制之tasklet --- 基于软中断

结构体

  1. struct tasklet_struct
  2. {
  3. ​    struct tasklet_struct *next;
  4. ​    unsigned long state;
  5. ​    atomic_t count;
  6. ​    void (*func)(unsigned long);
  7. ​    unsigned long data;
  8. };

定义tasklet的中断底半部处理函数

void tasklet_func(unsigned long data);

初始化 tasklet

  1. DECLARE_TASKLET(name, func, data);
  2. /*
  3. 定义变量并初始化
  4. 参数：name:中断底半部tasklet的名称
  5.      Func:中断底半部处理函数的名字
  6.      data:给中断底半部处理函数传递的参数
  7. */
void tasklet_init(struct tasklet_struct *t,void (*func)(unsigned long), unsigned long data)

调度 tasklet

  1. void tasklet_schedule(struct tasklet_struct *t)
  2. //参数:t:tasklet的结构体

示例代码（tasklet）

key_tasklet.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;
  28.     int irqno;
  29.  
  30.     struct keyvalue data;
  31.     int newflag;
  32.     spinlock_t lock;
  33.  
  34. 	wait_queue_head_t rq;
  35.     
  36.     struct tasklet_struct tsk;
  37. };
  38.  
  39. struct key2_dev *pgmydev = NULL;
  40.  
  41. int key2_open(struct inode* pnode, struct file* pfile)
  42. {
  43. 	pfile->private_data = (void *)(container_of(pnode->i_cdev, struct key2_dev, mydev));
  44. 	return 0;
  45. }
  46.  
  47. int key2_close(struct inode* pnode, struct file* pfile)
  48. {
  49. 	return 0;
  50. }
  51.  
  52. ssize_t key2_read(struct file* pfile, char __user *puser, size_t count, loff_t* p_pos)
  53. {
  54. 	struct key2_dev *pmydev = (struct key2_dev *)pfile->private_data;
  55. 	int size = 0;
  56. 	int ret = 0;
  57.  
  58.     if (count < sizeof(struct keyvalue)) {
  59.         printk("expect read size is invalid\n");
  60.         return -1;
  61.     }
  62.  
  63. 	spin_lock(&pmydev->lock);
  64. 	if (!pmydev->newflag) {
  65.         if (pfile->f_flags & O_NONBLOCK) {
  66.             // 非阻塞
  67.             spin_unlock(&pmydev->lock);
  68.             printk("O_NONBLOCK No Data Read\n");
  69.             return -1;
  70.         } else {
  71.             // 阻塞
  72.             spin_unlock(&pmydev->lock);
  73.             ret = wait_event_interruptible(pmydev->rq, pmydev->newflag == 1);
  74.             if (ret) {
  75.                 printk("Wake up by signal\n");
  76. 				return -ERESTARTSYS;
  77.             }
  78.             spin_lock(&pmydev->lock);
  79.         }
  80.     }
  81.  
  82. 	if (count > sizeof(struct keyvalue)) {
  83. 		size = sizeof(struct keyvalue);
  84. 	} else {
  85. 		size = count;
  86. 	}
  87.  
  88. 	ret = copy_to_user(puser, &pmydev->data, size);
  89. 	if (ret) {
  90. 		spin_unlock(&pmydev->lock);
  91. 		printk("copy_to_user failed\n");
  92. 		return -1;
  93. 	}
  94.  
  95. 	pmydev->newflag = 0;
  96.  
  97.     spin_unlock(&pmydev->lock);
  98.  
  99. 	return size;
  100. }
  101.  
  102. unsigned int key2_poll(struct file* pfile, poll_table* ptb)
  103. {
  104. 	struct key2_dev *pmydev = (struct key2_dev *)pfile->private_data;
  105. 	unsigned int mask = 0;
  106.  
  107. 	poll_wait(pfile, &pmydev->rq, ptb);
  108.  
  109. 	spin_lock(&pmydev->lock);
  110. 	if (pmydev->newflag) {
  111. 		mask |= POLLIN | POLLRDNORM;
  112. 	}
  113. 	spin_unlock(&pmydev->lock);
  114.  
  115. 	return mask;
  116. }
  117.  
  118. struct file_operations myops = {
  119. 	.owner = THIS_MODULE,
  120. 	.open = key2_open,
  121. 	.release = key2_close,
  122. 	.read = key2_read,
  123. 	.poll = key2_poll,
  124. };
  125.  
  126. irqreturn_t key2_irq_handle(int no, void *arg)
  127. {
  128.     struct key2_dev *pmydev = (struct key2_dev*)arg;
  129.     
  130.     tasklet_schedule(&pmydev->tsk);
  131.  
  132.     return IRQ_HANDLED;
  133. }
  134.  
  135. void bottom_irq_func(unsigned long arg)
  136. {
  137.     struct key2_dev *pmydev = (struct key2_dev*)arg;
  138.     int status1 = 0;
  139.     int status2 = 0;
  140.     int status = 0;
  141.  
  142.     status1 = gpio_get_value(pmydev->gpio);
  143.     mdelay(1);
  144.     status2 = gpio_get_value(pmydev->gpio);
  145.  
  146.     if (status1 != status2) {
  147.         return;
  148.     }
  149.  
  150.     status = status1;
  151.  
  152.     spin_lock(&pmydev->lock);
  153.     if (status == pmydev->data.status) {
  154.         spin_unlock(&pmydev->lock);
  155.         return;
  156.     }
  157.  
  158.     pmydev->data.code = KEY2;
  159.     pmydev->data.status = status;
  160.     pmydev->newflag = 1;
  161.  
  162.     spin_unlock(&pmydev->lock);
  163.     wake_up(&pmydev->rq);
  164.  
  165.     return;
  166. }
  167.  
  168. int __init key2_init(void)
  169. {
  170. 	int ret = 0;
  171. 	dev_t devno = MKDEV(major, minor);
  172.  
  173.     struct device_node *pnode = NULL;
  174.  
  175.     pnode = of_find_node_by_path("/mykey2_node");
  176.     if (NULL == pnode) {
  177.         printk("find node failed\n");
  178.         return -1;
  179.     }
  180.  
  181.     pgmydev = (struct key2_dev*)kmalloc(sizeof(struct key2_dev), GFP_KERNEL);
  182.     if (NULL == pgmydev) {
  183.         printk("kmalloc for struct key2_dev failed\n");
  184.         return -1;
  185.     }
  186.  
  187.     pgmydev->gpio = of_get_named_gpio(pnode, "key2-gpio", 0);
  188.     pgmydev->irqno = irq_of_parse_and_map(pnode, 0);
  189.  
  190. 	/* 申请设备号 */
  191. 	ret = register_chrdev_region(devno, key2_num, "key2");
  192. 	if (ret) {
  193. 		ret = alloc_chrdev_region(&devno, minor, key2_num, "key2");
  194. 		if (ret) {
  195.             kfree(pgmydev);
  196.             pgmydev = NULL;
  197. 			printk("get devno failed\n");
  198. 			return -1;
  199. 		}
  200. 		major = MAJOR(devno);
  201. 	}
  202.  
  203. 	/* 给struct cdev对象指定操作函数集 */
  204. 	cdev_init(&pgmydev->mydev, &myops);
  205.  
  206. 	/* 给struct cdev对象添加到内核对应的数据结构里 */
  207. 	pgmydev->mydev.owner = THIS_MODULE;
  208. 	cdev_add(&pgmydev->mydev, devno, key2_num);
  209.  
  210. 	init_waitqueue_head(&pgmydev->rq);
  211.  
  212. 	spin_lock_init(&pgmydev->lock);
  213.  
  214.     tasklet_init(&pgmydev->tsk, bottom_irq_func, (unsigned long)pgmydev);
  215.  
  216.     ret = request_irq(pgmydev->irqno, key2_irq_handle, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "key2", pgmydev);
  217.     if (ret) {
  218.         printk("request_irq failed\n");
  219.         cdev_del(&pgmydev->mydev);
  220.         kfree(pgmydev);
  221.         pgmydev = NULL;
  222.         unregister_chrdev_region(devno, key2_num);
  223.         return -1;
  224.     }
  225.  
  226. 	return 0;
  227. }
  228.  
  229. void __exit key2_exit(void)
  230. {
  231. 	dev_t devno = MKDEV(major, minor);
  232.     free_irq(pgmydev->irqno, pgmydev);
  233. 	cdev_del(&pgmydev->mydev);
  234. 	unregister_chrdev_region(devno, key2_num);
  235.  
  236. 	kfree(pgmydev);
  237. 	pgmydev = NULL;
  238. }
  239.  
  240.  
  241. MODULE_LICENSE("GPL");
  242.  
  243. module_init(key2_init);
  244. module_exit(key2_exit);

下半部机制之workqueue  --- 基于内核线程

结构体

  1. typedef void (*work_func_t)(struct work_struct  *work)
  2.  
  3. struct work_struct {
  4. ​        atomic_long_t data;
  5. ​        struct list_head entry;
  6. ​        work_func_t func;
  7.  
  8. \#ifdef CONFIG_LOCKDEP
  9. ​            struct lockdep_map lockdep_map;
  10. \#endif
  11. };

定义工作队列底半部处理函数

void work_queue_func(struct work_struct *work);

初始化工作队列

struct work_struct work_queue;

初始化：绑定工作队列及工作队列的底半部处理函数

INIT_WORK(struct work_struct * pwork, _func);

参数：pwork：工作队列

           func：工作队列的底半部处理函数

工作队列的调度函数

bool schedule_work(struct work_struct *work);

示例代码（workqueue）

key_workqueue.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;
  28.     int irqno;
  29.  
  30.     struct keyvalue data;
  31.     int newflag;
  32.     spinlock_t lock;
  33.  
  34. 	wait_queue_head_t rq;
  35.     
  36.     struct work_struct wk;
  37. };
  38.  
  39. struct key2_dev *pgmydev = NULL;
  40.  
  41. int key2_open(struct inode* pnode, struct file* pfile)
  42. {
  43. 	pfile->private_data = (void *)(container_of(pnode->i_cdev, struct key2_dev, mydev));
  44. 	return 0;
  45. }
  46.  
  47. int key2_close(struct inode* pnode, struct file* pfile)
  48. {
  49. 	return 0;
  50. }
  51.  
  52. ssize_t key2_read(struct file* pfile, char __user *puser, size_t count, loff_t* p_pos)
  53. {
  54. 	struct key2_dev *pmydev = (struct key2_dev *)pfile->private_data;
  55. 	int size = 0;
  56. 	int ret = 0;
  57.  
  58.     if (count < sizeof(struct keyvalue)) {
  59.         printk("expect read size is invalid\n");
  60.         return -1;
  61.     }
  62.  
  63. 	spin_lock(&pmydev->lock);
  64. 	if (!pmydev->newflag) {
  65.         if (pfile->f_flags & O_NONBLOCK) {
  66.             // 非阻塞
  67.             spin_unlock(&pmydev->lock);
  68.             printk("O_NONBLOCK No Data Read\n");
  69.             return -1;
  70.         } else {
  71.             // 阻塞
  72.             spin_unlock(&pmydev->lock);
  73.             ret = wait_event_interruptible(pmydev->rq, pmydev->newflag == 1);
  74.             if (ret) {
  75.                 printk("Wake up by signal\n");
  76. 				return -ERESTARTSYS;
  77.             }
  78.             spin_lock(&pmydev->lock);
  79.         }
  80.     }
  81.  
  82. 	if (count > sizeof(struct keyvalue)) {
  83. 		size = sizeof(struct keyvalue);
  84. 	} else {
  85. 		size = count;
  86. 	}
  87.  
  88. 	ret = copy_to_user(puser, &pmydev->data, size);
  89. 	if (ret) {
  90. 		spin_unlock(&pmydev->lock);
  91. 		printk("copy_to_user failed\n");
  92. 		return -1;
  93. 	}
  94.  
  95. 	pmydev->newflag = 0;
  96.  
  97.     spin_unlock(&pmydev->lock);
  98.  
  99. 	return size;
  100. }
  101.  
  102. unsigned int key2_poll(struct file* pfile, poll_table* ptb)
  103. {
  104. 	struct key2_dev *pmydev = (struct key2_dev *)pfile->private_data;
  105. 	unsigned int mask = 0;
  106.  
  107. 	poll_wait(pfile, &pmydev->rq, ptb);
  108.  
  109. 	spin_lock(&pmydev->lock);
  110. 	if (pmydev->newflag) {
  111. 		mask |= POLLIN | POLLRDNORM;
  112. 	}
  113. 	spin_unlock(&pmydev->lock);
  114.  
  115. 	return mask;
  116. }
  117.  
  118. struct file_operations myops = {
  119. 	.owner = THIS_MODULE,
  120. 	.open = key2_open,
  121. 	.release = key2_close,
  122. 	.read = key2_read,
  123. 	.poll = key2_poll,
  124. };
  125.  
  126. irqreturn_t key2_irq_handle(int no, void *arg)
  127. {
  128.     struct key2_dev *pmydev = (struct key2_dev*)arg;
  129.     
  130.     schedule_work(&pmydev->wk);
  131.  
  132.     return IRQ_HANDLED;
  133. }
  134.  
  135. void bottom_irq_func(struct work_struct *pwk)
  136. {
  137.     struct key2_dev *pmydev = container_of(pwk, struct key2_dev, wk);
  138.     int status1 = 0;
  139.     int status2 = 0;
  140.     int status = 0;
  141.  
  142.     status1 = gpio_get_value(pmydev->gpio);
  143.     mdelay(1);
  144.     status2 = gpio_get_value(pmydev->gpio);
  145.  
  146.     if (status1 != status2) {
  147.         return;
  148.     }
  149.  
  150.     status = status1;
  151.  
  152.     spin_lock(&pmydev->lock);
  153.     if (status == pmydev->data.status) {
  154.         spin_unlock(&pmydev->lock);
  155.         return;
  156.     }
  157.  
  158.     pmydev->data.code = KEY2;
  159.     pmydev->data.status = status;
  160.     pmydev->newflag = 1;
  161.  
  162.     spin_unlock(&pmydev->lock);
  163.     wake_up(&pmydev->rq);
  164.  
  165.     return;
  166. }
  167.  
  168. int __init key2_init(void)
  169. {
  170. 	int ret = 0;
  171. 	dev_t devno = MKDEV(major, minor);
  172.  
  173.     struct device_node *pnode = NULL;
  174.  
  175.     pnode = of_find_node_by_path("/mykey2_node");
  176.     if (NULL == pnode) {
  177.         printk("find node failed\n");
  178.         return -1;
  179.     }
  180.  
  181.     pgmydev = (struct key2_dev*)kmalloc(sizeof(struct key2_dev), GFP_KERNEL);
  182.     if (NULL == pgmydev) {
  183.         printk("kmalloc for struct key2_dev failed\n");
  184.         return -1;
  185.     }
  186.  
  187.     pgmydev->gpio = of_get_named_gpio(pnode, "key2-gpio", 0);
  188.     pgmydev->irqno = irq_of_parse_and_map(pnode, 0);
  189.  
  190. 	/* 申请设备号 */
  191. 	ret = register_chrdev_region(devno, key2_num, "key2");
  192. 	if (ret) {
  193. 		ret = alloc_chrdev_region(&devno, minor, key2_num, "key2");
  194. 		if (ret) {
  195.             kfree(pgmydev);
  196.             pgmydev = NULL;
  197. 			printk("get devno failed\n");
  198. 			return -1;
  199. 		}
  200. 		major = MAJOR(devno);
  201. 	}
  202.  
  203. 	/* 给struct cdev对象指定操作函数集 */
  204. 	cdev_init(&pgmydev->mydev, &myops);
  205.  
  206. 	/* 给struct cdev对象添加到内核对应的数据结构里 */
  207. 	pgmydev->mydev.owner = THIS_MODULE;
  208. 	cdev_add(&pgmydev->mydev, devno, key2_num);
  209.  
  210. 	init_waitqueue_head(&pgmydev->rq);
  211.  
  212. 	spin_lock_init(&pgmydev->lock);
  213.  
  214.     INIT_WORK(&pgmydev->wk, bottom_irq_func);
  215.  
  216.     ret = request_irq(pgmydev->irqno, key2_irq_handle, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "key2", pgmydev);
  217.     if (ret) {
  218.         printk("request_irq failed\n");
  219.         cdev_del(&pgmydev->mydev);
  220.         kfree(pgmydev);
  221.         pgmydev = NULL;
  222.         unregister_chrdev_region(devno, key2_num);
  223.         return -1;
  224.     }
  225.  
  226. 	return 0;
  227. }
  228.  
  229. void __exit key2_exit(void)
  230. {
  231. 	dev_t devno = MKDEV(major, minor);
  232.     free_irq(pgmydev->irqno, pgmydev);
  233. 	cdev_del(&pgmydev->mydev);
  234. 	unregister_chrdev_region(devno, key2_num);
  235.  
  236. 	kfree(pgmydev);
  237. 	pgmydev = NULL;
  238. }
  239.  
  240.  
  241. MODULE_LICENSE("GPL");
  242.  
  243. module_init(key2_init);
  244. module_exit(key2_exit);

下半部机制比较

任务机制
​    workqueue  ----- 内核线程  能睡眠  运行时间无限制

异常机制  -------  不能睡眠  下半部执行时间不宜太长（ < 1s)
​    软中断  ----- 接口不方便
​    tasklet  ----- 无具体延后时间要求时
​    定时器  ----- 有具体延后时间要求时

设备模型

起源

仅devfs，导致开发不方便以及一些功能难以支持：

  1. 热插拔
  2. 不支持一些针对所有设备的统一操作（如电源管理）
  3. 不能自动mknod
  4. 用户查看不了设备信息
  5. 设备信息硬编码，导致驱动代码通用性差，即没有分离设备和驱动

新方案

uevent机制：sysfs + uevent + udevd（上层app）

sysfs: 一种用内存模拟的文件系统，系统启动时mount到/sys目录

sysfs用途：（类似于windows的设备管理器）

1. 建立系统中总线、驱动、设备三者之间的桥梁
2. 向用户空间展示内核中各种设备的拓扑图
3. 提供给用户空间对设备获取信息和操作的接口，部分取代ioctl功能

sysfs在内核中的组成要素在用户空间/sys下的显示
内核对象（kobject）目录
对象属性（attribute）文件
对象关系（relationship）链接（Symbolic Link）

四个基本结构

类型所包含的内容内核数据结构对应/sys项
设备(Devices)设备是此模型中最基本的类型，以设备本身的连接按层次组织struct device/sys/devices/?/?/…/
驱动(Drivers)在一个系统中安装多个相同设备，只需要一份驱动程序的支持struct device_driver/sys/bus/pci/drivers/?/
总线(Bus)在整个总线级别对此总线上连接的所有设备进行管理struct bus_type/sys/bus/?/
类别(Classes)这是按照功能进行分类组织的设备层次树；如 USB 接口和 PS/2 接口的鼠标都是输入设备，都会出现在/sys/class/input/下struct class/sys/class/?/

目录组织结构：

/sys下的子目录所包含的内容
/sys/devices这是内核对系统中所有设备的分层次表达模型，也是/sys文件系统管理设备的最重要的目录结构；
/sys/dev这个目录下维护一个按字符设备和块设备的主次号码(major:minor)链接到真实的设备(/sys/devices下)的符号链接文件；
/sys/bus这是内核设备按总线类型分层放置的目录结构， devices 中的所有设备都是连接于某种总线之下，在这里的每一种具体总线之下可以找到每一个具体设备的符号链接，它也是构成 Linux 统一设备模型的一部分；
/sys/class这是按照设备功能分类的设备模型，如系统所有输入设备都会出现在/sys/class/input 之下，而不论它们是以何种总线连接到系统。它也是构成 Linux 统一设备模型的一部分；
/sys/kernel这里是内核所有可调整参数的位置，目前只有 uevent_helper, kexec_loaded, mm, 和新式的slab 分配器等几项较新的设计在使用它，其它内核可调整参数仍然位于sysctl(/proc/sys/kernel) 接口中；
/sys/module这里有系统中所有模块的信息，不论这些模块是以内联(inlined)方式编译到内核映像文件(vmlinuz)中还是编译为外部模块(ko文件)，都可能会出现在/sys/module 中
/sys/power这里是系统中电源选项，这个目录下有几个属性文件可以用于控制整个机器的电源状态，如可以向其中写入控制命令让机器关机、重启等。

uevent

代码中自动mknod

  1. struct class *class_create(struct module *owner, const char *name);
  2. /*
  3.  * 功能：在/sys/class生成一个目录,目录名由name指定
  4.  * 参数：
  5.     struct module *owner - THIS_MODULE
  6.     const char *name - 目录名
  7.  * 返回值  成功：class指针   失败：NULL
  8. */
  9. /*
  10. 辅助接口：可以定义一个struct class 的指针变量cls来接受返回值，然后通过IS_ERR(cls)判断是否失败；
  11. IS_ERR(cls);成功----------------->0
  12. IS_ERR(cls);失败----------------->非0
  13. PTR_ERR(cls);来获得失败的返回错误码；
  14. */
  1. void class_destroy(struct class *cls)
  2. /*
  3. * 功能：删除class_create生成目录
  4. * 参数：
  5.      struct class *cls - class指针
  6. * 返回值
  7. */
  1. struct device *device_create(struct class *class, struct device *parent,
  2.                  dev_t devt, void *drvdata, const char *fmt, ...)
  3. /*
  4.  * 功能：在/sys/class目录下class_create生成目录再生成一个子目录与该设备相对应，发uevent让应用程序udevd创建设备文件
  5.  * 参数：
  6.      struct class *class - class指针
  7.      struct device *parent - 父对象，一般NULL
  8.      dev_t devt - 设备号
  9.      void *drvdata - 驱动私有数据，一般NULL
  10.      const char *fmt - 字符串的格式
  11.       ... - 不定参数
  12.  * 返回值
  13.      成功：device指针
  14.      失败：NULL
  15.  */
  1. void device_destroy(struct class *class, dev_t devt)
  2. /*
  3.  * 功能：删除device_create生成目录
  4.  * 参数：
  5.      struct class *class - class指针
  6.      dev_t devt - 设备号
  7.  * 返回值
  8. */

示例代码（自动mknod，修改先前读写操作的代码）

mknod.c

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

test.c

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

测试结果

  1. shrek@ubuntu16:~/share/mydrivercode$ sudo insmod ./mknod.ko
  2. shrek@ubuntu16:~/share/mydrivercode$ ls /dev/automknod -l
  3. crw------- 1 root root 11, 0 Dec  6 21:07 /dev/automknod
  4. shrek@ubuntu16:~/share/mydrivercode$ sudo chmod 777 /dev/automknod 
  5. shrek@ubuntu16:~/share/mydrivercode$ ./a.out  /dev/automknod 
  6. buf = hello

平台总线式驱动开发

总线、设备、驱动

硬编码式的驱动开发带来的问题：

1. 垃圾代码太多
2. 结构不清晰
3. 一些统一设备功能难以支持
4. 开发效率低下

初期解决思路：设备和驱动分离

​    struct device 来表示一个具体设备，主要提供具体设备相关的资源（如寄存器地址、GPIO、中断等等）

​    struct device_driver 来表示一个设备驱动，一个驱动可以支持多个操作逻辑相同的设备

​    带来的问题-------怎样将二者进行关联（匹配）？

​    硬件上同一总线上的设备遵循一致的时序通信，在其基础上增加管理设备和驱动的软件功能

​    于是引入总线（bus），各种总线的核心框架由内核来实现，通信时序一般由SOC供应商支持

​    内核中用 struct bus_type 来表示一种总线，总线可以是实际存在的总线，也可以是虚拟总线：

1. 实际总线：提供时序通信方式 + 管理设备和驱动
2. 虚拟总线：仅用来管理设备和驱动（最核心的作用之一就是完成设备和驱动的匹配）

理解方式：

设备：提供硬件资源——男方

驱动：提供驱动代码——女方

总线：匹配设备和驱动——婚介所

升级思路：根据设备树，在系统启动时自动产生每个节点对应的设备

初期方案，各种device需要编码方式注册进内核中的设备管理结构中，为了进一步减少这样的编码，引进设备树

基本数据类型

  1. struct device 
  2. {
  3.     struct bus_type *bus;                // 总线类型
  4.     dev_t devt;                          // 设备号
  5.     struct device_driver *driver;        // 设备驱动
  6.     struct device_node  *of_node;        // 设备树中的节点，重要
  7.     void (*release)(struct device *dev); // 删除设备，重要
  8.     //.......
  9. };
  1. struct device_driver 
  2. {
  3.     const char *name;                          // 驱动名称，匹配device用，重要
  4.     struct bus_type *bus;                      // 总线类型
  5.     struct module *owner;                      // 模块THIS_MODULE 
  6.     const struct of_device_id *of_match_table; // 用于设备树匹配 of_match_ptr(某struct of_device_id对象地址) 重要
  7.     //......
  8. };
  1. struct of_device_id
  2. {
  3.     char name[32];        // 设备名
  4.     char type[32];        // 设备类型
  5.     char compatible[128]; // 用于device和driver的match，重点
  6. };
  7. // 用到结构体数组，一般不指定大小，初始化时最后加{}表示数组结束

platform总线驱动

platform是一种虚拟总线，主要用来管理那些不需要时序通信的设备

基本结构图：

核心数据类型之platform_device

  1. struct platform_device 
  2. {
  3.     const char *name;                          // 匹配用的名字
  4.     int id;                                    // 设备id,用于在该总线上同名的设备进行编号，如果只有一个设备，则为-1
  5.     struct device dev;                         // 设备模块必须包含该结构体
  6.     struct resource *resource;                 // 资源结构体 指向资源数组
  7.     u32 num_resources;                         // 资源的数量 资源数组的元素个数
  8.     const struct platform_device_id *id_entry; // 设备id
  9. };
  1. struct platform_device_id
  2. {
  3.     char name[20];              // 匹配用名称
  4.     kernel_ulong_t driver_data; // 需要向驱动传输的其它数据
  5. };
  1. struct resource 
  2. {
  3.     resource_size_t start;  // 资源起始位置   
  4.     resource_size_t end;    // 资源结束位置
  5.     const char *name;      
  6.     unsigned long flags;    // 区分资源是什么类型的
  7. };
  8.  
  9. #define IORESOURCE_MEM        0x00000200
  10. #define IORESOURCE_IRQ        0x00000400 
  11. /*
  12. flags 指资源类型，我们常用的是 IORESOURCE_MEM、IORESOURCE_IRQ  这两种。start 和 end 的含义会随着 flags而变更，如
  14. a -- flags为IORESOURCE_MEM 时，start 、end 分别表示该platform_device占据的内存的开始地址和结束值；注意不同MEM的地址值不能重叠
  16. b -- flags为 IORESOURCE_IRQ   时，start 、end 分别表示该platform_device使用的中断号的开始地址和结束值
  17. */
  1. /**
  2.  * 注册：把指定设备添加到内核中平台总线的设备列表，等待匹配,匹配成功则回调驱动中probe；
  3.  */
  4. int platform_device_register(struct platform_device *);
  5.  
  6. /**
  7.  * 注销：把指定设备从设备列表中删除，如果驱动已匹配则回调驱动方法和设备信息中的release；
  8.  */
  9. void platform_device_unregister(struct platform_device *);
  1. struct resource *platform_get_resource(struct platform_device *dev,unsigned int type, unsigned int num);
  2. /*
  3.     功能：获取设备资源
  4.     参数：dev:平台驱动
  5.         type:获取的资源类型
  6.         num:对应类型资源的序号（如第0个MEM、第2个IRQ等，不是数组下标）
  7.     返回值：成功：资源结构体首地址,失败:NULL
  8. */

核心数据类型之platform_driver

  1. struct platform_driver 
  2. {
  3.     int (*probe)(struct platform_device *); // 设备和驱动匹配成功之后调用该函数
  4.     int (*remove)(struct platform_device *); // 设备卸载了调用该函数
  5.     
  6.     void (*shutdown)(struct platform_device *);
  7.     int (*suspend)(struct platform_device *, pm_message_t state);
  8.     int (*resume)(struct platform_device *);
  9.     struct device_driver driver; // 内核里所有的驱动必须包含该结构体
  10.     const struct platform_device_id *id_table; // 能够支持的设备八字数组，用到结构体数组，一般不指定大小，初始化时最后加{}表示数组结束
  11. };
  1. int platform_driver_register(struct platform_driver*pdrv);
  2. /*
  3.     功能：注册平台设备驱动
  4.     参数：pdrv:平台设备驱动结构体
  5.     返回值：成功：0
  6.     失败：错误码
  7. */
  8. void platform_driver_unregister(struct platform_driver*pdrv);

platform的三种匹配方式

2.1 名称匹配（如图中的name）：一个驱动只对应一个设备 ----- 优先级最低

2.2 id匹配（如图中的platform_device_id结构体）：一个驱动可以对应多个设备 ----- 优先级次低

     device模块中，id的name成员必须与struct platform_device中的name成员内容一致

     因此device模块中，struct platform_device中的name成员必须指定

     driver模块中，struct platform_driver成员driver的name成员必须指定，但与device模块中name可以不相同

2.3 设备树匹配：内核启动时根据设备树自动产生的设备 ----- 优先级最高

     使用compatible属性进行匹配，注意设备树中compatible属性值不要包含空白字符

     id_table可不设置，但struct platform_driver成员driver的name成员必须设置

名称匹配

基础框架

  1. /* platform device框架 */
  2. #include <linux/module.h> 
  3. #include <linux/kernel.h>
  4. #include <linux/init.h>
  5. #include <linux/platform_device.h>
  6.  
  7. // 定义资源数组
  8.  
  9. static void device_release(struct device *dev)
  10. {
  11. 	printk("platform: device release\n");
  12. }
  13.  
  14. struct platform_device test_device = {
  15. 	.id = -1,
  16. 	.name = "test_device", // 必须初始化
  17. 	.dev.release = device_release, 
  18. };
  19.  
  20. static int __init platform_device_init(void)
  21. {
  22. 	platform_device_register(&test_device);
  23. 	return 0;
  24. }
  25.  
  26. static void __exit platform_device_exit(void)
  27. {
  28. 	platform_device_unregister(&test_device);
  29. }
  30.  
  31. module_init(platform_device_init);
  32. module_exit(platform_device_exit);
  33. MODULE_LICENSE("Dual BSD/GPL");

  1. /* platform driver框架 */
  2. #include <linux/module.h> 
  3. #include <linux/kernel.h>
  4. #include <linux/init.h>
  5. #include <linux/platform_device.h>
  6.  
  7. static int driver_probe(struct platform_device *dev)
  8. {
  9. 	printk("platform: match ok!\n");
  10. 	return 0;
  11. }
  12.  
  13. static int driver_remove(struct platform_device *dev)
  14. {
  15. 	printk("platform: driver remove\n");
  16. 	return 0;
  17. }
  18.  
  19. struct platform_driver test_driver = {
  20. 	.probe = driver_probe,
  21. 	.remove = driver_remove,
  22. 	.driver = {
  23. 		.name = "test_device", // 必须初始化
  24. 	},
  25. };
  26.  
  27. static int __init platform_driver_init(void)
  28. {
  29. 	platform_driver_register(&test_driver);
  30. 	return 0;
  31. }
  32.  
  33. static void __exit platform_driver_exit(void)
  34. {
  35. 	platform_driver_unregister(&test_driver);
  36. }
  37.  
  38. module_init(platform_driver_init);
  39. module_exit(platform_driver_exit);
  40. MODULE_LICENSE("Dual BSD/GPL");

示例代码（名称匹配）

hello_device.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/platform_device.h>
  4.  
  5. void hello_device_release(struct device *pdev)
  6. {
  7.     printk("hello_device_release is called\n");
  8. }
  9.  
  10. struct resource hello_device_res [] =
  11. {
  12. 	[0] = {.start = 0x1000, .end=0x1003, .name="reg1", .flags = IORESOURCE_MEM},
  13. 	[1] = {.start = 0x2000, .end=0x2003, .name="reg2", .flags = IORESOURCE_MEM},
  14. 	[2] = {.start = 10, .end=10, .name="irq1", .flags = IORESOURCE_IRQ},
  15. 	[3] = {.start = 0x3000, .end=0x3003, .name="reg3", .flags = IORESOURCE_MEM},
  16. 	[4] = {.start = 100, .end=100, .name="irq2", .flags = IORESOURCE_IRQ},
  17. 	[5] = {.start = 62, .end=62, .name="irq3", .flags = IORESOURCE_IRQ},
  18. };
  19.  
  20. struct platform_device hello_device = {
  21.     .name = "hello", // 匹配依据
  22.     .dev.release = hello_device_release,
  23.     .resource = hello_device_res,
  24.     .num_resources = ARRAY_SIZE(hello_device_res),
  25. };
  26.  
  27. int __init hello_device_init(void)
  28. {
  29.     platform_device_register(&hello_device);
  30.     return 0;
  31. }
  32.  
  33. void __exit hello_device_exit(void)
  34. {
  35.     platform_device_unregister(&hello_device);
  36. }
  37.  
  38. MODULE_LICENSE("GPL");
  39. module_init(hello_device_init);
  40. module_exit(hello_device_exit);

hello_driver.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/platform_device.h>
  4.  
  5. int hello_driver_probe(struct platform_device *p_pltdev)
  6. {
  7.     struct resource *pres = NULL;
  8.  
  9.     printk("hello_driver_probe is called\n");
  10.  
  11.     pres = platform_get_resource(p_pltdev, IORESOURCE_MEM, 2);
  12.     printk("res.start = 0x%x\n",(unsigned int)pres->start);
  13.  
  14.     pres = platform_get_resource(p_pltdev, IORESOURCE_IRQ, 1);
  15. 	printk("res.start = %d\n", (int)pres->start);
  16. 	return 0;
  17. }
  18.  
  19. int hello_driver_remove(struct platform_device *p_pltdev)
  20. {
  21.     printk("hello_driver_remove is called\n");
  22.     return 0;
  23. }
  24.  
  25. struct platform_driver hello_driver = {
  26.     .driver.name = "hello", // 匹配依据
  27.     .probe = hello_driver_probe,
  28.     .remove = hello_driver_remove,
  29. };
  30.  
  31. int __init hello_driver_init(void)
  32. {
  33.     platform_driver_register(&hello_driver);
  34.     return 0;
  35. }
  36.  
  37. void __exit hello_driver_exit(void)
  38. {
  39.     platform_driver_unregister(&hello_driver);
  40. }
  41.  
  42. MODULE_LICENSE("GPL");
  43. module_init(hello_driver_init);
  44. module_exit(hello_driver_exit);

测试结果

插入两个ko之后匹配成功调用 driver 的 probe 函数
rmmod driver 会调用 driver 的 remove 函数
rmmod device 会调用 device 的 release 函数

  1. shrek@ubuntu16:~/share/mydrivercode/platform$ sudo dmesg -C
  2. shrek@ubuntu16:~/share/mydrivercode/platform$ sudo insmod ./hello_driver.ko
  3. shrek@ubuntu16:~/share/mydrivercode/platform$ sudo insmod ./hello_device.ko
  4. shrek@ubuntu16:~/share/mydrivercode/platform$ dmesg
  5. [ 3477.288502] hello_driver_probe is called
  6. [ 3477.288504] res.start = 0x3000
  7. [ 3477.288504] res.start = 100
  8.  
  9. shrek@ubuntu16:~/share/mydrivercode/platform$ sudo rmmod hello_driver 
  10. shrek@ubuntu16:~/share/mydrivercode/platform$ dmesg
  11. [ 3477.288502] hello_driver_probe is called
  12. [ 3477.288504] res.start = 0x3000
  13. [ 3477.288504] res.start = 100
  14. [ 3514.642304] hello_driver_remove is called
  15.  
  16. shrek@ubuntu16:~/share/mydrivercode/platform$ sudo rmmod hello_device 
  17. shrek@ubuntu16:~/share/mydrivercode/platform$ dmesg
  18. [ 3477.288502] hello_driver_probe is called
  19. [ 3477.288504] res.start = 0x3000
  20. [ 3477.288504] res.start = 100
  21. [ 3514.642304] hello_driver_remove is called
  22. [ 3526.339599] hello_device_release is called

示例代码（名称匹配之LED驱动）

leds_device.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/platform_device.h>
  4.  
  5. #define GPX1CON 0x11000C20
  6. #define GPX1DAT 0x11000C24
  7.  
  8. #define GPX2CON 0x11000C40
  9. #define GPX2DAT 0x11000C44
  10.  
  11. #define GPF3CON 0x114001E0
  12. #define GPF3DAT 0x114001E4
  13.  
  14. void leds_device_release(struct device *pdev)
  15. {
  16.     printk("leds_device_release is called\n");
  17. }
  18.  
  19. struct resource leds_device_res [] =
  20. {
  21. 	[0] = {.start = GPX1CON, .end=GPX1CON + 3, .name="GPX1CON", .flags = IORESOURCE_MEM},
  22. 	[1] = {.start = GPX1DAT, .end=GPX1DAT + 3, .name="GPX1DAT", .flags = IORESOURCE_MEM},
  23.  
  24. 	[2] = {.start = GPX2CON, .end=GPX2CON + 3, .name="GPX2CON", .flags = IORESOURCE_MEM},
  25. 	[3] = {.start = GPX2DAT, .end=GPX2DAT + 3, .name="GPX2DAT", .flags = IORESOURCE_MEM},
  26. 	
  27. 	[4] = {.start = GPF3CON, .end=GPF3CON + 3, .name="GPF3CON", .flags = IORESOURCE_MEM},
  28. 	[5] = {.start = GPF3DAT, .end=GPF3DAT + 3, .name="GPF3DAT", .flags = IORESOURCE_MEM},
  29. };
  30.  
  31. struct platform_device leds_device = {
  32.     .name = "leds", // 匹配依据
  33.     .dev.release = leds_device_release,
  34.     .resource = leds_device_res,
  35.     .num_resources = ARRAY_SIZE(leds_device_res),
  36. };
  37.  
  38. int __init leds_device_init(void)
  39. {
  40.     platform_device_register(&leds_device);
  41.     return 0;
  42. }
  43.  
  44. void __exit leds_device_exit(void)
  45. {
  46.     platform_device_unregister(&leds_device);
  47. }
  48.  
  49. MODULE_LICENSE("GPL");
  50. module_init(leds_device_init);
  51. module_exit(leds_device_exit);

leds_driver.c

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

测试结果

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

ID匹配

Tips

1.  device 模块中，id 的 name 成员必须与 struct platform_device 中的 name 成员内容一致，因此 device 模块中，struct platform_device 中的 name 成员必须指定
2.  driver 模块中，struct platform_driver 成员 driver 的 name 成员必须指定，但与 device 模块中name可以不相同

基础框架

  1. /* platform device框架 */
  2. #include <linux/module.h> 
  3. #include <linux/kernel.h>
  4. #include <linux/init.h>
  5. #include <linux/platform_device.h>
  6.  
  7. // 定义资源数组
  8.  
  9. static void device_release(struct device *dev)
  10. {
  11. 	printk("platform: device release\n");
  12. }
  13.  
  14. struct platform_device_id test_id = {
  15.     .name = "test_device",
  16. };
  17.  
  18. struct platform_device test_device = {
  19. 	.name = "test_device", // 必须初始化
  20. 	.dev.release = device_release, 
  21.     .id_entry = &test_id,
  22. };
  23.  
  24. static int __init platform_device_init(void)
  25. {
  26. 	platform_device_register(&test_device);
  27. 	return 0;
  28. }
  29.  
  30. static void __exit platform_device_exit(void)
  31. {
  32. 	platform_device_unregister(&test_device);
  33. }
  34.  
  35. module_init(platform_device_init);
  36. module_exit(platform_device_exit);
  37. MODULE_LICENSE("Dual BSD/GPL");
  1. /* platform driver框架 */
  2. #include <linux/module.h> 
  3. #include <linux/kernel.h>
  4. #include <linux/init.h>
  5. #include <linux/platform_device.h>
  6.  
  7. static int driver_probe(struct platform_device *dev)
  8. {
  9. 	printk("platform: match ok!\n");
  10. 	return 0;
  11. }
  12.  
  13. static int driver_remove(struct platform_device *dev)
  14. {
  15. 	printk("platform: driver remove\n");
  16. 	return 0;
  17. }
  18.  
  19. struct platform_device_id testdrv_ids[] = 
  20. {
  21. 	[0] = {.name = "test_device"},
  22.     [1] = {.name = "abcxyz"},
  23.     [2] = {}, // means ending
  24. };
  25.  
  26. struct platform_driver test_driver = {
  27. 	.probe = driver_probe,
  28. 	.remove = driver_remove,
  29. 	.driver = {
  30. 		.name = "xxxxx", // 必须初始化
  31. 	},
  32.     .id_table = testdrv_ids,
  33. };
  34.  
  35. static int __init platform_driver_init(void)
  36. {
  37. 	platform_driver_register(&test_driver);
  38. 	return 0;
  39. }
  40.  
  41. static void __exit platform_driver_exit(void)
  42. {
  43. 	platform_driver_unregister(&test_driver);
  44. }
  45.  
  46. module_init(platform_driver_init);
  47. module_exit(platform_driver_exit);
  48. MODULE_LICENSE("Dual BSD/GPL");

用到结构体数组，一般不指定大小，初始化时最后加{}表示数组结束

设备中增加资源，驱动中访问资源

示例代码（ID匹配）

hello_device.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/platform_device.h>
  4.  
  5. void hello_device_release(struct device *pdev)
  6. {
  7.     printk("hello_device_release is called\n");
  8. }
  9.  
  10. struct resource hello_device_res [] =
  11. {
  12. 	[0] = {.start = 0x1000, .end=0x1003, .name="reg1", .flags = IORESOURCE_MEM},
  13. 	[1] = {.start = 0x2000, .end=0x2003, .name="reg2", .flags = IORESOURCE_MEM},
  14. 	[2] = {.start = 10, .end=10, .name="irq1", .flags = IORESOURCE_IRQ},
  15. 	[3] = {.start = 0x3000, .end=0x3003, .name="reg3", .flags = IORESOURCE_MEM},
  16. 	[4] = {.start = 100, .end=100, .name="irq2", .flags = IORESOURCE_IRQ},
  17. 	[5] = {.start = 62, .end=62, .name="irq3", .flags = IORESOURCE_IRQ},
  18. };
  19.  
  20. struct platform_device_id hello_id = {
  21.     .name = "hello",
  22. };
  23.  
  24. struct platform_device hello_device = {
  25.     .name = "hello",
  26.     .dev.release = hello_device_release,
  27.     .resource = hello_device_res,
  28.     .num_resources = ARRAY_SIZE(hello_device_res),
  29.  
  30.     .id_entry = &hello_id, // 匹配依据
  31. };
  32.  
  33. int __init hello_device_init(void)
  34. {
  35.     platform_device_register(&hello_device);
  36.     return 0;
  37. }
  38.  
  39. void __exit hello_device_exit(void)
  40. {
  41.     platform_device_unregister(&hello_device);
  42. }
  43.  
  44. MODULE_LICENSE("GPL");
  45. module_init(hello_device_init);
  46. module_exit(hello_device_exit);

hello_driver.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/platform_device.h>
  4.  
  5. int hello_driver_probe(struct platform_device *p_pltdev)
  6. {
  7.     struct resource *pres = NULL;
  8.  
  9.     printk("hello_driver_probe is called\n");
  10.  
  11.     pres = platform_get_resource(p_pltdev, IORESOURCE_MEM, 2);
  12.     printk("res.start = 0x%x\n",(unsigned int)pres->start);
  13.  
  14.     pres = platform_get_resource(p_pltdev, IORESOURCE_IRQ, 1);
  15. 	printk("res.start = %d\n", (int)pres->start);
  16. 	return 0;
  17. }
  18.  
  19. int hello_driver_remove(struct platform_device *p_pltdev)
  20. {
  21.     printk("hello_driver_remove is called\n");
  22.     return 0;
  23. }
  24.  
  25. struct platform_device_id hellodrv_ids[] = {
  26.     [0] = {.name = "hello"},
  27.     [1] = {.name = "xyz"},
  28.     [2] = {}
  29. };
  30.  
  31. struct platform_driver hello_driver = {
  32.     .driver.name = "abc", // 与device的name不同使之不能名字匹配
  33.     .probe = hello_driver_probe,
  34.     .remove = hello_driver_remove,
  35.  
  36.     .id_table = hellodrv_ids, // 匹配依据
  37. };
  38.  
  39. int __init hello_driver_init(void)
  40. {
  41.     platform_driver_register(&hello_driver);
  42.     return 0;
  43. }
  44.  
  45. void __exit hello_driver_exit(void)
  46. {
  47.     platform_driver_unregister(&hello_driver);
  48. }
  49.  
  50. MODULE_LICENSE("GPL");
  51. module_init(hello_driver_init);
  52. module_exit(hello_driver_exit);

测试结果

  1. shrek@ubuntu16:~/share/mydrivercode/platform/hello_id$ sudo insmod ./hello_device.ko
  2. shrek@ubuntu16:~/share/mydrivercode/platform/hello_id$ sudo insmod ./hello_driver.ko
  3. shrek@ubuntu16:~/share/mydrivercode/platform/hello_id$ dmesg 
  4. [  722.320042] hello_driver_probe is called
  5. [  722.320043] res.start = 0x3000
  6. [  722.320043] res.start = 100

设备树匹配

Tips

1. 无需编写 device 模块，只需编写 driver 模块
2. 使用 compatible 属性进行匹配，注意设备树中 compatible 属性值不要包含空白字符
3. id_table 可不设置，但 struct platform_driver 成员 driver 的 name 成员必须设置

  1. /* platform driver框架 */
  2. #include <linux/module.h> 
  3. #include <linux/kernel.h>
  4. #include <linux/init.h>
  5. #include <linux/platform_device.h>
  6.  
  7. static int driver_probe(struct platform_device *dev)
  8. {
  9. 	printk("platform: match ok!\n");
  10. 	return 0;
  11. }
  12.  
  13. static int driver_remove(struct platform_device *dev)
  14. {
  15. 	printk("platform: driver remove\n");
  16. 	return 0;
  17. }
  18.  
  19. struct platform_device_id testdrv_ids[] = 
  20. {
  21. 	[0] = {.name = "test_device"},
  22.     [1] = {.name = "abcxyz"},
  23.     [2] = {}, // means ending
  24. };
  25.  
  26. struct of_device_id test_of_ids[] = 
  27. {
  28. 	[0] = {.compatible = "xyz,abc"},
  29.     [1] = {.compatible = "qwe,opq"},
  30.     [2] = {},
  31. };
  32.  
  33. struct platform_driver test_driver = {
  34. 	.probe = driver_probe,
  35. 	.remove = driver_remove,
  36. 	.driver = {
  37. 		.name = "xxxxx", // 必须初始化
  38.         .of_match_table = test_of_ids,
  39. 	},
  40. };
  41.  
  42. static int __init platform_driver_init(void)
  43. {
  44. 	platform_driver_register(&test_driver);
  45. 	return 0;
  46. }
  47.  
  48. static void __exit platform_driver_exit(void)
  49. {
  50. 	platform_driver_unregister(&test_driver);
  51. }
  52.  
  53. module_init(platform_driver_init);
  54. module_exit(platform_driver_exit);
  55. MODULE_LICENSE("Dual BSD/GPL");

示例代码（设备树匹配之LED驱动）

设备树添加节点

  1. 4412-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. };

leddrv_dt.c

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

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_dt.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_dt.ko /opt/4412/rootfs/
  4. shrek@ubuntu16:~/share/mydrivercode$ cp testled /opt/4412/rootfs/

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

  1. [root@farsight]#insmod leddrv_dt.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灯可以控制亮灭

一个编写驱动用的宏

  1. struct platform_driver xxx = {  
  2.     ...
  3. };
  4. module_platform_driver(xxx);
  5.  
  6. //最终展开后就是如下形式：
  7. static int __init xxx_init(void)
  8. {
  9.         return platform_driver_register(&xxx);
  10. }
  11. module_init(xxx_init);
  12.  
  13. static void __exit xxx_init(void)
  14. {
  15.         return platform_driver_unregister(&xxx);
  16. }
  17. module_exit(xxx_exit)

I2C总线式驱动开发

Linux内核对I2C总线的支持

I2C设备驱动：即挂接在I2C总线上的二级外设的驱动，也称客户（client）驱动，实现对二级外设的各种操作，二级外设的几乎所有操作全部依赖于对其自身内部寄存器的读写，对这些二级外设寄存器的读写又依赖于I2C总线的发送和接收

I2C总线驱动：即对I2C总线自身控制器的驱动，一般SOC芯片都会提供多个I2C总线控制器，每个I2C总线控制器提供一组I2C总线（SDA一根+SCL一根），每一组被称为一个I2C通道，Linux内核里将I2C总线控制器叫做适配器（adapter），适配器驱动主要工作就是提供通过本组I2C总线与二级外设进行数据传输的接口，每个二级外设驱动里必须能够获得其对应的adapter对象才能实现数据传输

I2C核心：承上启下，为I2C设备驱动和I2C总线驱动开发提供接口，为I2C设备驱动层提供管理多个i2c_driver、i2c_client对象的数据结构，为I2C总线驱动层提供多个i2c_algorithm、i2c_adapter对象的数据结构

四大核心对象之间的关系图

i2c二级外设驱动开发涉及到核心结构体及其相关接口函数

  1. struct i2c_board_info {
  2.     char        type[I2C_NAME_SIZE];
  3.     unsigned short  flags;
  4.     unsigned short  addr;
  5.     void        *platform_data;
  6.     struct dev_archdata *archdata;
  7.     struct device_node *of_node;
  8.     int     irq;
  9. };
  10. /*用来协助创建i2c_client对象
  11. 重要成员
  12. type：用来初始化i2c_client结构中的name成员
  13. flags：用来初始化i2c_client结构中的flags成员
  14. addr：用来初始化i2c_client结构中的addr成员
  15. platform_data：用来初始化i2c_client结构中的.dev.platform_data成员
  16. archdata：用来初始化i2c_client结构中的.dev.archdata成员
  17. irq:用来初始化i2c_client结构中的irq成员
  19. 关键就是记住该结构和i2c_client结构成员的对应关系。在i2c子系统不直接创建i2c_client结构，只是提供struct i2c_board_info结构信息，让子系统动态创建，并且注册。
  20. */
  1. struct i2c_client {
  2.     unsigned short flags;
  3.     unsigned short addr;
  4.     char name[I2C_NAME_SIZE];
  5.     struct i2c_adapter *adapter;
  6.     struct i2c_driver *driver;
  7.     struct device dev;
  8.     int irq;
  9.     struct list_head detected;
  10. };
  11. /*重要成员：
  12. flags:地址长度，如是10位还是7位地址，默认是7位地址。如果是10位地址器件，则设置为I2C_CLIENT_TEN
  13. addr：具体I2C器件如(at24c02)，设备地址,低7位
  14. name:设备名，用于和i2c_driver层匹配使用的，可以和平台模型中的平台设备层platform_driver中的name作用是一样的。
  15. adapter:本设备所绑定的适配器结构(CPU有很多I2C适配器，类似单片机有串口1、串口2等等，在linux中每个适配器都用一个结构描述)
  16. driver：指向匹配的i2c_driver结构，不需要自己填充，匹配上后内核会完成这个赋值操作
  17. dev:内嵌的设备模型，可以使用其中的platform_data成员传递给任何数据给i2c_driver使用。
  18. irq：设备需要使用到中断时，把中断编号传递给i2c_driver进行注册中断，如果没有就不需要填充。(有的I2C器件有中断引脚编号，与CPU相连)
  19. */
  20.  
  21. /* 获得/释放 i2c_adapter 路径：i2c-core.c linux-3.5\drivers\i2c */
  22. /*功能：通过i2c总线编号获得内核中的i2c_adapter结构地址，然后用户可以使用这个结构地址就可以给i2c_client结构使用，从而实现i2c_client进行总线绑定，从而增加适配器引用计数。
  23. 返回值：
  24. NULL：没有找到指定总线编号适配器结构
  25. 非NULL：指定nr的适配器结构内存地址*/
  26. struct i2c_adapter *i2c_get_adapter(int nr);
  27.  
  28.  
  29. /*减少引用计数：当使用·i2c_get_adapter·后，需要使用该函数减少引用计数。（如果你的适配器驱动不需要卸载，可以不使用）*/
  30. void i2c_put_adapter(struct i2c_adapter *adap);
  31.  
  32. /*
  33. 功能：根据参数adap，info，addr，addr_list动态创建i2c_client并且进行注册
  34. 参数：
  35. adap：i2c_client所依附的适配器结构地址
  36. info：i2c_client基本信息
  37. addt_list: i2c_client的地址(地址定义形式是固定的，一般是定义一个数组，数组必须以I2C_CLIENT_END结束，示例：unsigned short ft5x0x_i2c[]={0x38,I2C_CLIENT_END};
  38. probe:回调函数指针，当创建好i2c_client后，会调用该函数，一般没有什么特殊需求传递NULL。
  39. 返回值：
  40. 非NULL:创建成功，返回创建好的i2c_client结构地址
  41. NULL：创建失败
  42. */
  43. struct i2c_client * i2c_new_probed_device
  44. (
  45.  struct i2c_adapter *adap,
  46.  struct i2c_board_info *info,
  47.  unsigned short const *addr_list,
  48.  int (*probe)(struct i2c_adapter *, unsigned short addr)
  49. );
  50. /*示例：
  51. struct i2c_adapter *ad;
  52. struct i2c_board_info info={""};
  54. unsigned short addr_list[]={0x38,0x39,I2C_CLIENT_END};
  56. //假设设备挂在i2c-2总线上
  57. ad=i2c_get_adapter(2);
  59. //自己填充board_info 
  60. strcpy(inf.type,"xxxxx");
  61. info.flags=0;
  62. //动态创建i2c_client并且注册
  63. i2c_new_probed_device(ad,&info,addr_list,NULL);
  65. i2c_put_adapter(ad);
  66. */
  67.  
  68. /*注销*/
  69. void i2c_unregister_device(struct i2c_client *pclt)
  70.  
  71.  
  72.  struct i2c_client * i2c_new_device
  73.  (
  74.      struct i2c_adapter *padap,
  75.      struct i2c_board_info const *pinfo
  76.  );
  77. /*示例：
  78. struct i2c_adapter *ad;
  79. struct i2c_board_info info={
  80. 	I2C_BOARD_INFO(name,二级外设地址)
  81. };
  82. //假设设备挂在i2c-2总线上
  83. ad=i2c_get_adapter(2);
  85. //动态创建i2c_client并且注册
  86. i2c_new_device(ad,&info);
  88. i2c_put_adapter(ad);
  89. */
  1. struct i2c_driver {
  2.     unsigned int class;
  3.  
  4.     /* Standard driver model interfaces */
  5.     int (*probe)(struct i2c_client *, const struct i2c_device_id *);
  6.     int (*remove)(struct i2c_client *);
  7.  
  8.     /* driver model interfaces that don't relate to enumeration  */
  9.     void (*shutdown)(struct i2c_client *);
  10.     int (*suspend)(struct i2c_client *, pm_message_t mesg);
  11.     int (*resume)(struct i2c_client *);
  12. 	void (*alert)(struct i2c_client *, unsigned int data);
  13.  
  14.     /* a ioctl like command that can be used to perform specific functions
  15.      * with the device.
  16.      */
  17.     int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
  18.  
  19.     struct device_driver driver;
  20.     const struct i2c_device_id *id_table;
  21.  
  22.     /* Device detection callback for automatic device creation */
  23.     int (*detect)(struct i2c_client *, struct i2c_board_info *);
  24.     const unsigned short *address_list;
  25.     struct list_head clients;
  26. };
  27. /*重要成员：
  28. probe：在i2c_client与i2c_driver匹配后执行该函数
  29. remove：在取消i2c_client与i2c_driver匹配绑定后后执行该函数
  30. driver：这个成员类型在平台设备驱动层中也有，而且使用其中的name成员来实现平台设备匹配，但是i2c子系统中不使用其中的name进行匹配，这也是i2c设备驱动模型和平台设备模型匹配方法的一点区别
  31. id_table:用来实现i2c_client与i2c_driver匹配绑定，当i2c_client中的name成员和i2c_driver中id_table中name成员相同的时候，就匹配上了。
  33. 补充：i2c_client与i2c_driver匹配问题
  34. - i2c_client中的name成员和i2c_driver中id_table中name成员相同的时候
  35. - i2c_client指定的信息在物理上真实存放对应的硬件，并且工作是正常的才会绑定上，并执行其中的probe接口函数这第二点要求和平台模型匹配有区别，平台模型不要求设备层指定信息在物理上真实存在就能匹配
  36. */
  37.  
  38. /*功能：向内核注册一个i2c_driver对象
  39. 返回值：0成功，负数 失败*/
  40. #define i2c_add_driver(driver)     i2c_register_driver(THIS_MODULE, driver)
  41. int i2c_register_driver(struct module *owner, struct i2c_driver *driver);
  42.  
  43. /*功能：从内核注销一个i2c_driver对象
  44. 返回值：无 */
  45. void i2c_del_driver(struct i2c_driver *driver);
  1. struct i2c_msg {
  2.     __u16 addr; /* slave address            */
  3.     __u16 flags;
  4. #define I2C_M_TEN       0x0010  /* this is a ten bit chip address */
  5. #define I2C_M_RD        0x0001  /* read data, from slave to master */
  6.     __u16 len;      /* msg length               */
  7.     __u8 *buf;      /* pointer to msg data          */
  8. };
  9. /* 重要成员：
  10. addr:要读写的二级外设地址
  11. flags：表示地址的长度，读写功能。如果是10位地址必须设置I2C_M_TEN，如果是读操作必须设置有I2C_M_RD······，可以使用或运算合成。
  12. buf：要读写的数据指针。写操作：数据源 读操作：指定存放数据的缓存区
  13. len：读写数据的数据长度
  14. */
  15.  
  16. /*i2c收发一体化函数,收还是发由参数msgs的成员flags决定*/
  17. int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
  18. /*
  19. 功能：根据msgs进行手法控制
  20. 参数：
  21. adap：使用哪一个适配器发送信息，一般是取i2c_client结构中的adapter指针作为参数
  22. msgs：具体发送消息指针，一般情况下是一个数组
  23. num:表示前一个参数msgs数组有多少个消息要发送的
  24. 返回值：
  25. 负数：失败
  26. > 0 表示成功发送i2c_msg数量
  27. */
  28.  
  29. /*I2C读取数据函数*/
  30. int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
  31. /*功能：实现标准的I2C读时序，数据可以是N个数据，这个函数调用时候默认已经包含发送从机地址+读方向这一环节了
  32. 参数：
  33. client：设备结构
  34. buf：读取数据存放缓冲区
  35. count：读取数据大小 不大于64k
  36. 返回值：
  37. 失败：负数
  38. 成功：成功读取的字节数
  39. */
  40.     
  41. /*I2C发送数据函数*/
  42. int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
  43. /*功能：实现标准的I2C写时序，数据可以是N个数据，这个函数调用时候默认已经包含发送从机地址+写方向这一环节了
  44. 参数：
  45. client：设备结构地址
  46. buf：发送数据存放缓冲区
  47. count：发送数据大小 不大于64k
  48. 返回值：
  49. 失败：负数
  50. 成功：成功发送的字节数
  51. */

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/577601
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号