文章目录
本人学习完韦老师的视频，因此来复习巩固，写以笔记记之。
韦老师的课比较难，第一遍不知道在说什么，但是坚持看完一遍，再来复习，基本上就水到渠成了。
看完视频复习的同学观看最佳！
基于 IMX6ULL-PRO
参考视频 Linux快速入门到精通视频
参考资料：01_嵌入式Linux应用开发完全手册V5.1_IMX6ULL_Pro开发板.pdf
一、驱动程序基石
1-1 休眠与唤醒
当应用程序必须等待某个事件发生，比如必须等待按键被按下时， 可以使用休眠-唤醒机制
① APP调用read等函数试图读取数据，比如读取按键；
② APP进入内核态，也就是调用驱动中的对应函数，发现有数据则复制到用户空间并马上返回；
③ 如果APP在内核态，也就是在驱动程序中发现没有数据，则APP休眠；
④ 当有数据时，比如当按下按键时，驱动程序的中断服务程序被调用，它会记录数据、唤醒APP
⑤ APP继续运行它的内核态代码，也就是驱动程序中的函数，复制数据到用户空间并马上返回。
驱动框架
休眠，直到condition 为真；休眠期间是可被打断的，可以被信号打断
wait_event_interruptible(wq, condition)
唤醒wq队列中状态为“ TASK_INTERRUPTIBLE ”的线程，只唤醒其中的一个线程
wake_up_interruptible(wq)
要休眠的线程，放在wq 队列里，中断处理函数从wq队列里把它取出来唤
醒。
① 初始化wq队列
② 在驱动的read函数中，调用 wait_event_interruptible。它本身会判断
event是否为 FALSE ，如果为FASLE表示无数据，则休眠。
当从wait_event_interruptible 返回后，把数据复制回用户空间。
③ 在中断服务程序里：设置event 为TRUE，并调用wake_up_interruptible 唤醒线程。
1-2 POLL机制
使用休眠唤醒的方式等待某个事件发生时，有一个缺点：等待的时间可能
很久。我们可以加上一个超时时间，这时就可以使用poll机制。
① APP不知道驱动程序中是否有数据，可以先调用 poll函数查询一下， poll函数可以传入超时时间
② APP进入内核态，调用驱动程序的poll函数，有数据的话立刻返回；
③ 如果发现没有数据时就休眠一段时间
④ 当有数据时，比如当按下按键时，驱动程序的中断服务程序被调用，它会记录数据、唤醒APP
⑤ 当超时时间到了之后，内核也会唤醒APP
⑥ APP根据poll函数的返回值就可以知道是否有数据，如果有数据就调用
read得到数据。
drv_poll函数需要做的事
① 把当前线程挂入队列wq：poll_wait
②返回设备状态：drv_poll 要返回自己的当前状态：P OLLIN | POLLRDNORM) 或 POLLOUT | POLLWRNORM) 。
static unsigned int gpio_key_drv_poll(struct file *fp, poll_table * wait)
{
printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
poll_wait(fp, &gpio_key_wait, wait);
return is_key_buf_empty() ? 0 : POLLIN | POLLRDNORM;
}
button_test.c
int main(int argc, char **argv)
{
int fd;
int val;
struct pollfd fds[1];
int timeout_ms = 5000;
int ret;
/* 1. 判断参数 */
if (argc != 2)
{
printf("Usage: %s <dev>\n", argv[0]);
return -1;
}
/* 2. 打开文件 */
fd = open(argv[1], O_RDWR);
if (fd == -1)
{
printf("can not open file %s\n", argv[1]);
return -1;
}
fds[0].fd = fd;
fds[0].events = POLLIN;
while (1)
{
/* 3. 读文件 */
ret = poll(fds, 1, timeout_ms);
if((ret == 1) && (fds[0].revents & POLLIN)){
read(fd, &val, 4);
printf("get button : 0x%x\n", val);
}
else{
printf("timeout\n");
}
}
close(fd);
return 0;
}
1-3 异步通知
(1) 异步通知程序解析
异步通知流程如下：
① APP给SIGIO这个信号注册信号处理函数func，以后APP收到SIGIO信号时，这个函数会被自动调用。
② 把APP的PID(进程 ID)告诉驱动程序，这个调用不涉及驱动程序，在内核的文件系统层次记录PID。
filp->f_owner.pid = get_pid(pid);
③ 读取驱动程序文件Flag
④ 设置Flag里面的FASYNC位为1；当 FASYNC位发生变化时，会导致驱动程序的fasync被调用
⑤ 调用faync_helper ，它会根据 FAYSNC的值决定是否设置
button_async -->fa_file=filp(内含PID)；open文件时，会在内核文件系统中有一个struct file *filp结构体，filp->f_owner.pid里面含有之前设置的PID 。
⑥ APP做其他事；当按下按键，发生中断，驱动程序的中断服务程序被调用，里面调用kill_fasync 发信号
⑦ APP收到信号后，它的信号处理函数被自动调用，可以在里面调用
read函数读取按键。
驱动程序中提供对应的drv_fasync函数，并在FAYNC变化时，调用fasync_helper函数，使得button_fasync->fa_file = filp或者NULL
struct fasync_struct *button_fasync;
static int gpio_key_drv_fasync(int fd, struct file *file, int on)
{
if (fasync_helper(fd, file, on, &button_fasync) >= 0)
return 0;
else
return -EIO;
}
在GPIO中断服务程序中，若button_fasync->fa_file非空，则获得PID，并发信号给上层应用
kill_fasync(&button_fasync, SIGIO, POLL_IN);
上层应用程序
(2) 异步通知机制内核代码详解
上层应用执行fcntl函数，内核会调用fs/fcntl.c 的如下函数。
进入do_fcntl函数，flag标志对应函数的cmd
以下分别对三种flag进行代码演示
① 当flag是F_SETOWN时，内核do_fcntl中调用f_setown函数，最终将pid给filp
fcntl(fd, F_SETOWN, getpid());
② 当flag是F_GETFL时,获取文件的状态标志
flags = fcntl(fd, F_GETFL);
③ 当flag是F_SETFL时，设置文件支持异步通知功能
fcntl(fd, F_SETFL, flags | FASYNC);
启动了FASYNC 功能的话，驱动程序的 button_fasync 就被设置了，它指向的 fasync_struct 结构体里含有 filp里含有PID
static int gpio_key_drv_fasync(int fd, struct file *file, int on)
{
if (fasync_helper(fd, file, on, &button_fasync) >= 0)
return 0;
else
return -EIO;
}
从button_fasync 指针中，取出 fasync_struct 结构体，从这个结构体的 fa_file 中得到接收方的PID ，然后使用 send_sigio函数发送信号。根据 PID找到进程在内核的 task_struct结构体， 修改里面的某些成员表示收到了信号。
kill_fasync(&button_fasync, SIGIO, POLL_IN);
1-4 阻塞与非阻塞
所谓阻塞，就是等待某件事情发生。比如调用read读取按键时，如果没有按键数据则read函数不会返回，它会让线程休眠等待。
使用poll时，传入超时时间不为0(阻塞)；设置超时时间为0，没有数据立即返回(非阻塞)
如何设置阻塞与非阻塞呢？
① open时
int fd = open(“/dev/xxx”, O_RDWR | O_NONBLOCK); /* 非阻塞方式*/
int fd = open(“/dev/xxx”, O_RDWR ); /* 阻塞方式*/
② open后
int flags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, flags | O_NONBLOCK); /* 非阻塞方式*/
fcntl(fd, F_SETFL, flags & ~O_NONBLOCK); /* 阻塞方式*/
驱动程序中，当APP打开某个驱动时，在内核中会有一个struct file 结构体的f _flags对应打开文件时的标记位；可以设置f _flasgs 的O_NONBLOCK 位，表示非阻塞；也可以清除这个位表示阻塞。
/* 实现对应的open/read/write等函数，填入file_operations结构体*/
static ssize_t gpio_key_drv_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
{
//printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
int err;
int key;
if(is_key_buf_empty() && (file->f_flags & O_NONBLOCK))
return -EAGAIN;
else{
wait_event_interruptible(gpio_key_wait, !is_key_buf_empty());
key = get_key();
err = copy_to_user(buf, &key, 4);
return 4;
}
}
1-5 定时器
(1) 内核函数
所谓定时器，就是闹钟，时间到后你就要做某些事。有2个要素：时间、做事；换成程序员的话就是：超时时间、函数。
内核源码：include\linux\timer.h
1、设置定时器，主要是初始化timer_list结构体，设置其中的函数、参数。
setup_timer(timer, fn, data);
2、向内核添加定时器。 timer–>expires 表示超时时间。
当超时时间到达，内核就会调用这个函数：timer->function(timer -->data) 。
void add_timer(struct timer_list *timer)
3、修改定时器的超时时间
int mod_timer(struct timer_list *timer, unsigned long expires):
4、删除定时器
int del_timer(struct timer_list *timer)
(2) 定时器时间单位
这表示内核每秒中会发生100次系统滴答中断 (tick)，这是Linux系统的心跳。每发生一次tick中断，全局变量jiffies累加1。即：每个滴答是10ms。
CONFIG_HZ=100
按键触发中断，进入中断处理函数，若不断发生机械振动，会不断进入中断处理函数更新定时器超时时间，时间到后进入定时器处理函数，打印GPIO端口信息
probe函数设置定时器
static int gpio_key_probe(struct platform_device *pdev)
{
/* 设置定时器*/
setup_timer(&gpio_keys_100ask[i].key_timer, key_timer_expire, &gpio_keys_100ask[i]);
/*设置超时时间*/
gpio_keys_100ask[i].key_timer.expires = ~0;
add_timer(&gpio_keys_100ask[i].key_timer);
}
中断处理函数修改定时器超时时间
static irqreturn_t gpio_key_isr(int irq, void *dev_id)
{
struct gpio_key *gpio_key = dev_id;
printk("gpio_key_isr %d irq happened\n", gpio_key->gpio);
mod_timer(&gpio_key->key_timer, jiffies + HZ/50); //20ms HZ = 1s
return IRQ_HANDLED;
}
定时器处理函数中打印GPIO信息和唤醒线程
struct timer_list key_timer;
/*定时器处理函数*/
static void key_timer_expire(unsigned long data)
{
/*data ==> gpio*/
struct gpio_key *gpio_key = data;
int val;
int key;
val = gpiod_get_value(gpio_key->gpiod);
printk("key_timer_expire %d %d\n", gpio_key->gpio, val);
key = (gpio_key->gpio << 8) | val;
put_key(key);
wake_up_interruptible(&gpio_key_wait); /*唤醒线程*/
kill_fasync(&button_fasync, SIGIO, POLL_IN); /*发信号*/
}
1-6 中断下半部 tasklet
在上半部处理紧急的事情时，在处理过程中，中断是被禁止的；在下半部处理耗时的事情时，在处理过程中，中断是使能的。
内核源码：include\linux\interrupt.h
struct tasklet_struct
{
struct tasklet_struct *next;
unsigned long state;
atomic_t count;
void (*func)(unsigned long);
unsigned long data;
};
state用于表示 tasklet 的状态，一共有2位。
bit0 表示 TASKLET_STATE_SCHED
等于1时，表示已经执行了 tasklet_schedule把tasklet放入队列；
bit1 表示 TASKLET_STATE_RUN
等于1时，表示正在运行 tasklet 中的func函数；函数执行完后内核会把该位清0。
count表示该tasklet是否使能，0表示使能，非0表示被禁止。对于c ount非0的tasklet，里面的func函数不会被执行。
1、tasklet_init函数初始化tasklet结构体
extern void tasklet_init(struct tasklet_struct *t,
void (*func)(unsigned long), unsigned long data);
2、调度tasklet函数
static inline void tasklet_schedule(struct tasklet_struct *t);
tasklet放入链表，设置它的TASKLET_STATE_SCHED状态为1。
3、kill tasklet函数
extern void tasklet_kill(struct tasklet_struct *t);
如果一个tasklet 未被调度， tasklet_kill 会把它的TASKLET_STATE_SCHED 状态清0
如果一个 tasklet 已被调度， tasklet_kill 会等待它执行完华，再
把它的 TASKLET_STATE_SCHED 状态清0
首先在probe函数初始化tasklet结构体，中断函数中调度tasklet，最后在key_tasklet_func实现打印相应GPIO功能，remove函数中卸载
/*probe函数初始化tasklet*/
tasklet_init(&gpio_keys_100ask[i].tasklet, key_tasklet_func, &gpio_keys_100ask[i]);
static irqreturn_t gpio_key_isr(int irq, void *dev_id)
{
struct gpio_key *gpio_key = dev_id;
//printk("gpio_key_isr %d irq happened\n", gpio_key->gpio);
//上半部的函数来调度下半部
tasklet_schedule(&gpio_key->tasklet);
return IRQ_HANDLED;
}
static void key_tasklet_func(unsigned long data)
{
struct gpio_key *gpio_key = data;
int val;
int key;
val = gpiod_get_value(gpio_key->gpiod);
printk("key_tasklet_func key %d %d\n", gpio_key->gpio, val);
}
/*remove函数中卸载*/
tasklet_kill(&gpio_keys_100ask[i].tasklet);
tasklet 内部机制
内核源码：kernel\softirq.c
当发生硬件中断时，内核处理完硬件中断后，会处理软件中断。对于TASKLET_SOFTIRQ 软件中断，事先tasklet_schedule调度 tasklet时，其中的函数并不会立刻执行，而只是把
tasklet放入队列，再调用tasklet_action 函数。
当驱动程序调用tasklet_schedule时，会设置tasklet 的state为TASKLET_STATE_SCHED ，并把它放入某个链表。
1-7 工作队列
前面的定时器、下半部tasklet ，它们都是在中断上下文中执行，它们无法休眠。当要做的事情比较耗时，甚至可能需要休眠，那么可以使用工作队列。内核初始化工作队列就为它创建了内核线程。
内核源码：include\linux\workqueue.h
使用工作队列时，步骤如下：
1、构造一个work_struct结构体，里面有函数；
2、把work_struct 结构体放入工作队列，内核线程就会运行work中的函数。
调用schedule_work时，就会把work_struct 结构体放入队列中，并唤醒对应的内核线程。内核线程就会从队列里把work_struct 结构体取出来，执行里面的函数。
static inline bool schedule_work(struct work_struct *work)
{
return queue_work(system_wq, work);
}
/*probe函数初始化work*/
INIT_WORK(&gpio_keys_100ask[i].work, key_work_func);
/*中断处理函数*/
static irqreturn_t gpio_key_isr(int irq, void *dev_id)
{
struct gpio_key *gpio_key = dev_id;
//按下按键中断服务程序调用后，执行下面函数，放入队列，唤醒内核线程
//在合适的时候，当内核线程运行时，就会把work里的函数进行执行
schedule_work(&gpio_key->work);
return IRQ_HANDLED;
}
/*key_work_func函数*/
static void key_work_func(struct work_struct *work)
{
/*得到结构体gpio_key的地址*/
struct gpio_key *gpio_key = container_of(work, struct gpio_key, work);
int val;
val = gpiod_get_value(gpio_key->gpiod);
printk("key_work_func: the process is %s pid %d\n", current->comm, current->pid);
printk("key_work_func key %d %d\n", gpio_key->gpio, val);
}
1-8 中断的线程化处理
提供thread_fn函数，系统会为这个函数创建一个内核线程。发生中断时，系统会立刻调用 handler函数，然后唤醒某个内核线程，内核线程再来执行thread_fn函数。
request_threaded_irq(unsigned int irq, irq_handler_t handler,
irq_handler_t thread_fn,
unsigned long flags, const char *name, void *dev);
/*在probe函数注册一个中断处理函数*/
err = request_threaded_irq(gpio_keys_100ask[i].irq, gpio_key_isr, gpio_key_thread_func,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "100ask_gpio_key", &gpio_keys_100ask[i]);
/* gpio_key_isr中断处理handler函数 需要返回IRQ_WAKE_THREAD关键字*/
static irqreturn_t gpio_key_isr(int irq, void *dev_id)
{
struct gpio_key *gpio_key = dev_id;
//printk("gpio_key_isr %d irq happened\n", gpio_key->gpio);
return IRQ_WAKE_THREAD;
}
/*gpio_key_thread_func内核线程thread_fn函数 打印进程PID GPIO值*/
static irqreturn_t gpio_key_thread_func(int irq, void *data)
{
struct gpio_key *gpio_key = data;
int val;
int key;
val = gpiod_get_value(gpio_key->gpiod);
printk("gpio_key_thread_func: the process is %s pid %d\n", current->comm, current->pid);
printk("gpio_key_thread_func key %d %d\n", gpio_key->gpio, val);
return IRQ_HANDLED;
}
1-9 mmap
(1) 简介
- 应用程序不能直接读写驱动程序中的buffer ，需要在用户态buffer和内核态 buffer之间进行一次数据拷贝。内核态buffer拷贝给用户态buffer，应用程序读取用户态的buffer。
- 改进的方法就是让程序可以直接读写驱动程序中的buffer，这可以通过mmap实现，把内核的buffer映射到用户态，让APP在用户态直接读写。
- CPU 发出的地址是虚拟地址，它经过MMU内存管理单元映射到物理地址上，对于不同进程的同一个虚拟地址，MMU会把它们映射到不同的物理地址。
- 反过来，同一个物理地址也可以映射到不同的虚拟地址，即mmap函数，使得应用程序和驱动程序访问同一块内存的原理。
(2) 内存映射现象与数据结构
首先运行程序，会产生一个task_struct结构体，它包含了描述一个进程状态和属性的各种信息。
task_struct结构体中有struct mm_struct *mm成员变量，mm_struct结构体包含了进程的虚拟内存空间的描述和管理相关的信息。
mm_struct结构体中有struct vm_area_struct *mmap；pgd_t * pgd;其中pgd是页全局目录表 (Page Global Directory) 的指针，用于进行虚拟地址到物理地址的转换。mmap是指向虚拟内存区域链表的指针，用于描述进程的地址空间布局。
vm_area_struct结构体是链表结构。每个进程的地址空间被划分为多个 VMA，每个 VMA 描述了一块连续的虚拟内存区域。
Linux系统内核下的内存映射机制
是否使用cache和buffer的选择说明如下
(3) 驱动程序
驱动程序确定三件事：
1、确定物理地址
2、确定属性：是否使用 cache、 buffer
3、建立映射关系
应用程序./hello_drv_test
int main(int argc, char **argv)
{
int fd;
char *buf;
int len;
char str[1024];
/* 1. 打开文件 */
fd = open("/dev/hello", O_RDWR);
if (fd == -1)
{
printf("can not open file /dev/hello\n");
return -1;
}
/* 2. mmap
* MAP_SHARED : 多个APP都调用mmap映射同一块内存时, 对内存的修改大家都可以看到。
* 就是说多个APP、驱动程序实际上访问的都是同一块内存
* MAP_PRIVATE : 创建一个copy on write的私有映射。
* 当APP对该内存进行修改时，其他程序是看不到这些修改的。
* 就是当APP写内存时, 内核会先创建一个拷贝给这个APP,
* 这个拷贝是这个APP私有的, 其他APP、驱动无法访问。
*/
buf = mmap(NULL, 1024*8, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (buf == MAP_FAILED)
{
printf("can not mmap file /dev/hello\n");
return -1;
}
printf("mmap address = 0x%x\n", buf);
printf("buf origin data = %s\n", buf); /* old */
/* 3. write */
strcpy(buf, "new");
/* 4. read & compare */
/* 对于MAP_SHARED映射: str = "new"
* 对于MAP_PRIVATE映射: str = "old"
*/
read(fd, str, 1024);
if (strcmp(buf, str) == 0){
/* 对于MAP_SHARED映射，APP写的数据驱动可见
* APP和驱动访问的是同一个内存块
*/
printf("compare ok!\n");
}
else{
/* 对于MAP_PRIVATE映射，APP写数据时, 是写入原来内存块的"拷贝"
*/
printf("compare err!\n");
printf("str = %s!\n", str); /* old */
printf("buf = %s!\n", buf); /* new */
}
while (1){
sleep(10); /* cat /proc/pid/maps */
}
munmap(buf, 1024*8);
close(fd);
return 0;
}
驱动程序./hello_drv
/*入口函数hello_init()中分别8K虚拟地址空间*/
kernel_buf = kmalloc(bufsiz, GFP_KERNEL);
/*file_operations结构体内的hello_drv_mmap成员函数执行相应操作*/
static int hello_drv_mmap(struct file *file, struct vm_area_struct *vma)
{
/* 获得物理地址 */
unsigned long phy = virt_to_phys(kernel_buf);
/* 设置属性: cache, buffer */
vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
/* map */
if (remap_pfn_range(vma, vma->vm_start, phy >> PAGE_SHIFT,
vma->vm_end - vma->vm_start, vma->vm_page_prot)) {
printk("mmap remap_pfn_range failed\n");
return -ENOBUFS;
}
return 0;
}
mmap函数中，当使用MAP_SHARED参数，多个APP、驱动读、写时，操作的都是同一个内存块。
而当使用MAP_PRIVATE参数时，在没有发生写操作时，APP、驱动访问的都是同一块内存；当APP发起写操作时，就会触发“ copy on write”，即内核会先创建该内存块的拷贝， APP的写操作在这个新内存块上进行，这个新内存块是APP私有的，别的APP、驱动看不到。而此时read读的数据之前的内存。
MAP_PRIVATE映射是很有用的，Linux中多个 A PP 都会使用同一个动态库，在没有写操作之前大家都使用内存中唯一一份代码。当 A PP1发起写操作时，内核会为它复制一份代码，再执行写操作，APP1就有了专享的、私有的动态库，在里面做的修改只会影响到APP1 。其他程序仍然共享原先的、未修改的代码。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
