韦东山嵌入式Liunx入门驱动开发五

一、驱动程序基石

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);

文章来源地址https://www.toymoban.com/news/detail-837296.html

/*在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

• 应用程序不能直接读写驱动程序中的buffer ，需要在用户态buffer和内核态 buffer之间进行一次数据拷贝。
• 改进的方法就是让程序可以直接读写驱动程序中的buffer，这可以通过mmap实现，把内核的buffer映射到用户态，让APP在用户态直接读写。
• CPU 发出的地址是虚拟地址，它经过MMU内存管理单元映射到物理地址上，对于不同进程的同一个虚拟地址，MMU会把它们映射到不同的物理地址。

到了这里，关于韦东山嵌入式Liunx入门驱动开发五的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！