linux驱动开发3

Linux 阻塞和非阻塞 IO 实验
查看应用程序cpu使用率：输入命令行top即可。
当应用程序对设备驱动进行输入/输出操作的时候，如果不能获取到设备资源，那么阻塞式 IO 就会将应用程序对应的线程挂起，直到设备资源可以获取为止。对于非阻塞 IO，应用程序对应的线程不会挂起，它要么一直轮询等待，直到设备资源可以使用，要么就直接放弃。（便秘了就直接不去了，不便秘就一直等坑位。）

等待队列：
Linux 内核提供了等待队列(wait queue)来实现阻塞进程的唤醒工作，如果我们要在驱动中使用等待队列，必须创建并初始化一个等待队列头，等待队列头使用结构体wait_queue_head_t 表示
等待队列头就是一个等待队列的头部，每个访问设备的进程都是一个队列项，当设备不可用 的 时 候 就 要 将 这 些 进 程 对 应 的 等 待 队 列 项 添 加 到 等 待 队 列 里 面 。
当设备不可访问的时候就需要将进程对应的等待队列项添加到前面创建的等待队列头中，只有添加到等待队列头中以后进程才能进入休眠态。

			void add_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);

函数参数和返回值含义如下：wq_head：等待队列项要加入的等待队列头。
wq_entry：要加入的等待队列项。
同时也有等待队列项移除 API 函数：

void remove_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);

当设备可以使用的时候就要唤醒进入休眠态的进程：

void wake_up(wait_queue_head_t *q)
void wake_up_interruptible(wait_queue_head_t *q)

除了主动唤醒以外，也可以设置等待队列等待某个事件，当这个事件满足以后就自动唤醒等待队列中的进程。

非阻塞：
如果用户应用程序以非阻塞的方式访问设备，设备驱动程序就要提供非阻塞的处理方式，也就是轮询。poll、epoll 和 select 可以用于处理轮询，应用程序通过 select、epoll 或 poll函数来查询设备是否可以操作，如果可以操作的话就从设备读取或者向设备写入数据。当应用程序调用 select、epoll 或 poll 函数的时候设备驱动程序中的 poll 函数就会执行，因此需要在设备驱动程序中编写 poll 函数。
select函数：

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)

nfds：要操作的文件描述符个数。
readfds、writefds 和 exceptfds：这三个指针指向描述符集合，。readfds 用于监视指定描述符集的读变化，也就是监视这些文件是否可以读取，只要这些集合里面有一个文件可以读取那么 seclect 就会返回一个大于 0的值表示文件可以读取。如果没有文件可以读取，那么就会根据 timeout 参数来判断是否超时。可以将 readfs 设置为 NULL，表示不关心任何文件的读变化。writefds 和 readfs 类似，只是 writefs 用于监视这些文件是否可以进行写操作。exceptfds 用于监视这些文件的异常。
fd_set 变量宏定义：

void FD_ZERO(fd_set *set)//所有位都清零
void FD_SET(int fd, fd_set *set)//某个位置 1,也就是向 fd_set 添加一个文件描述符，参数 fd 就是要加入的文件描述符
void FD_CLR(int fd, fd_set *set)//某个位清零，也就是将一个文件描述符从 fd_set 中删除，参数 fd 就是要删除的文件描述符。
int FD_ISSET(int fd, fd_set *set)//测试 fd_set 的某个位是否置 1，也就是判断某个文件是否可以进行操作，参数 fd 就是要判断的文件描述符。

文件描述符理解：简称fd，当应用程序请求内核打开/新建一个文件时，内核会返回一个文件描述符用于对应这个打开/新建的文件，其fd本质上就是一个非负整数，读写文件也是需要使用这个文件描述符来指定待读写的文件的。
进程 + 文件描述符ID确认，因为内核为每个进程都有一份其所属的文件描述符表。应用程序进程拿到的文件描述符ID == 进程文件描述符表的索引，通过索引拿到文件指针，指向系统级文件描述符表的文件偏移量，再通过文件偏移量找到inode指针，最终对应到真实的文件
select 函数非阻塞读访问示例：

void main(void)
2 {
3 int ret, fd; /* 要监视的文件描述符 */
4 fd_set readfds; /* 读操作文件描述符集 */
5 struct timeval timeout; /* 超时结构体 */
6 
7 fd = open("dev_xxx", O_RDWR | O_NONBLOCK); /* 非阻塞式访问 */
8 
9 FD_ZERO(&readfds); /* 清除 readfds */
10 FD_SET(fd, &readfds); /* 将 fd 添加到 readfds 里面 */
11
12 /* 构造超时时间 */
13 timeout.tv_sec = 0;
14 timeout.tv_usec = 500000; /* 500ms */
ret = select(fd + 1, &readfds, NULL, NULL, &timeout);
17 switch (ret) {
18 case 0: /* 超时 */
19 printf("timeout!\r\n");
20 break;
21 case -1: /* 错误 */
22 printf("error!\r\n");
23 break;
24 default: /* 可以读取数据 */
25 if(FD_ISSET(fd, &readfds)) { /* 判断是否为 fd 文件描述符 */
26 /* 使用 read 函数读取数据 */
27 }
28 break;
29 }
30 }

poll 函数
在单个线程中，select 函数能够监视的文件描述符数量有最大的限制，一般为 1024，可以修改内核将监视的文件描述符数量改大，但是这样会降低效率！这个时候就可以使用 poll函数，poll 函数本质上和 select 没有太大的差别，但是 poll 函数没有最大文件描述符限制。

int poll(struct pollfd *fds, nfds_t nfds, int timeout)

fds：要监视的文件描述符集合以及要监视的事件,为一个数组，数组元素都是结构体pollfd 类型的,其中包括文件描述符和监视事件

int fd; /* 要监视的文件描述符 */
 struct pollfd fds;
fds.fd = fd;
 fds.events = POLLIN; /* 监视数据是否可以读取 */
 ret = poll(&fds, 1, 500);
POLLIN 有数据可以读取。
POLLPRI 有紧急的数据需要读取。
POLLOUT 可以写数据。
POLLERR 指定的文件描述符发生错误。
POLLHUP 指定的文件描述符挂起。
POLLNVAL 无效的请求。
POLLRDNORM 等同于 POLLIN

nfds：poll 函数要监视的文件描述符数量。timeout：超时时间，单位为 ms。
具体代码如下：

void main(void)
2 {
3 int ret;
4 int fd; /* 要监视的文件描述符 */
5 struct pollfd fds;
6
7 fd = open(filename, O_RDWR | O_NONBLOCK); /* 非阻塞式访问 */
8
9 /* 构造结构体 */
10 fds.fd = fd;
11 fds.events = POLLIN; /* 监视数据是否可以读取 */
12 
13 ret = poll(&fds, 1, 500); /* 轮询文件是否可操作，超时 500ms */
14 if (ret) { /* 数据有效 */
15 ......
16 /* 读取数据 */
17 ......
18 } else if (ret == 0) { /* 超时 */
19 ......
20 } else if (ret < 0) { /* 错误 */
21 ......
22 }
23 }

epoll 函数：
传统的 selcet 和 poll 函数都会随着所监听的 fd 数量的增加，出现效率低下的问题，而且 poll 函数每次必须遍历所有的描述符来检查就绪的描述符，这个过程很浪费时间。
应用程序需要先使用 epoll_create 函数创建一个 epoll 句柄，int epoll_create(int size)，size：从 Linux2.6.8 开始此参数已经没有意义了，随便填写一个大于 0 的值就可以。
epoll 句柄创建成功以后使用 epoll_ctl 函数向其中添加要监视的文件描述符以及监视的事件

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)

epfd：要操作的 epoll 句柄，op：表示要对 epfd(epoll 句柄)进行的操作，可以设置为：

EPOLL_CTL_ADD 向 epfd 添加文件参数 fd 表示的描述符。
EPOLL_CTL_MOD 修改参数 fd 的 event 事件。
EPOLL_CTL_DEL 从 epfd 中删除 fd 描述符。

fd：要监视的文件描述符。
event：要监视的事件类型，为 epoll_event 结构体类型指针。
结构体 epoll_event 的 events 成员变量表示要监视的事件，可选的事件如下所示：

EPOLLIN 有数据可以读取。
EPOLLOUT 可以写数据。
EPOLLPRI 有紧急的数据需要读取。
EPOLLERR 指定的文件描述符发生错误。
EPOLLHUP 指定的文件描述符挂起。
EPOLLET 设置 epoll 为边沿触发，默认触发模式为水平触发。
EPOLLONESHOT 一次性的监视，当监视完成以后还需要再次监视某个 fd，那么就需要将 fd 重新添加
到 epoll 里面。

一切都设置好以后应用程序就可以通过 epoll_wait 函数来等待事件的发生，类似 select函数。

int epoll_wait(int epfd, 
struct epoll_event *events,
int maxevents, 
int timeout)

epfd：要等待的 epoll。
events：指向 epoll_event 结构体的数组，当有事件发生的时候 Linux 内核会填写 events，调用者可以根据 events 判断发生了哪些事件。
maxevents：events 数组大小，必须大于 0。
timeout：超时时间，单位为 ms。
阻塞和非阻塞代码看正点的文档。
异步通知实验
在前面使用阻塞或者非阻塞的方式来读取驱动中按键值都是应用程序主动读取的，对于非阻塞方式来说还需要应用程序通过 poll 函数不断的轮询。最好的方式就是驱动程序能主动向应用程序发出通知，报告自己可以访问，然后应用程序在从驱动程序中读取或写入数据，类似于我们在 SDK 例程中讲解的中断。
驱动可以通过主动向应用程序发送信号的方式来报告自己可以访问了，应用程序获取到信号以后就可以从驱动设备中读取或者写入数据了。整个过程就相当于应用程序收到了驱动发送过来了的一个中断，然后应用程序去响应这个中断，在整个处理过程中应用程序并没有去查询驱动设备是否可以访问，一切都是由驱动设备自己告诉给应用程序的。
阻塞、非阻塞、异步通知，这三种是针对不同的场合提出来的不同的解决方法，前两种需要应用程序序主动的去查询设备的使用情况，其中阻塞虽然后续进入了休眠，但是第一次的时候还是需要应用程序主动查询设备的使用情况。
异步通知：
待后续补充：
lcd驱动学习：
2K 就是 25601440 个像素点，4K 是38402160 个像素点。很明显，在 LCD 尺寸不变的情况下，分辨率越高越清晰。同样的，分辨率不变的情况下，LCD 尺寸越小越清晰。比如我们常用的 24 寸显示器基本都是 1080P 的，而我们现在使用的 5 寸的手机基本也是 1080P 的，但是手机显示细腻程度就要比 24 寸的显示器要好很多！
lcd扫描显示：黑边：打像素点是按照z运动，当显示完一行以后会发出 HSYNC 信号，此时电子枪就会关闭，然后迅速的移动到屏幕的左边，当 HSYNC 信号结束以后就可以显示新的一行数据了，电子枪就会重新打开。在 HSYNC 信号结束到电子枪重新打开之间会插入一段延时，这样就产生了黑边。
一帧需要的时间：
显示一帧所需要的时间就是：VSPW+VBP+LINE+VFP 个行时间，最终的计算公式：
T = (VSPW+VBP+LINE+VFP) * (HSPW + HBP + HOZVAL + HFP)
vspw是VSYNC 信号宽度及其持续时间，line则是有效信号的持续时间，vbp和vep是上下黑边的持续时间，左侧V代表垂直方向右侧的H则是水平方向（hbp和hfp是左右黑边）。
像素时钟就是 RGB LCD 的时钟信号，以 ATK7016 这款屏幕为例，显示一帧图像所需要的时钟数就是：
= (VSPW+VBP+LINE+VFP) * (HSPW + HBP + HOZVAL + HFP)
= (3 + 20 + 600 + 12) * (20 + 140 + 1024 + 160)
= 635 * 1344
= 853440。
显示一帧图像需要 853440 个时钟数，那么显示 60 帧就是：853440 * 60 = 51206400≈51.2M，所以像素时钟就是 51.2MHz。
显存：
如果采用 RGB8888 格式的话一个像素需要 3 个字节的内存来存放像素据，那么 800480 分辨率就需要 8004803=1152000Byte≈1.1MB 内存。但是 RGB LCD 内部是没有内存的，所以就需要在开发板上的 DDR3 中分出一段内存作为 RGB LCD屏幕的显存，我们如果要在屏幕上显示什么图像的话直接操作这部分显存即可。
FrameBuffer 驱动框架
帧缓冲（framebuffer）是 Linux 为显示设备提供的一个接口，把显存抽象后的一种设备，他允许上层应用程序在图形模式下直接对显示缓冲区进行读写操作。所以在 Linux 系统中，凡是显示设备都被称为 FrameBuffer 设备（帧缓冲设备），所以 LCD 自然而言就是 FrameBuffer设备。
FrameBuffer 设备对应的设备文件为/dev/fb，

static int mybeep_probe(struct platform_device *pdev)
111 {
112 struct miscdevice *mdev;
113 int ret;
dev_info(&pdev->dev, "BEEP device and driver matched successfully!\n");
116
117 /* 初始化 BEEP */
118 ret = mybeep_init(pdev);
119 if (ret)
120 return ret;
121
122 /* 初始化 beep_data 变量 */
123 mdev = &beep_dev.mdev;
124 mdev->name = "zynq-beep"; // 设备名
125 mdev->minor = MISC_DYNAMIC_MINOR; // 动态分配次设备号
126 mdev->fops = &mybeep_fops; // 绑定 file_operations 结构体
127
128 /* 向 linux 系统 misc 驱动框架核心层注册一个 beep 设备 */
129 return misc_register(mdev);
}
149 /* 匹配列表 */
150 static const struct of_device_id beep_of_match[] = {
151 { .compatible = "alientek,beeper" },
152 { /* Sentinel */ }
153 };
154
155 /* platform 驱动结构体 */
156 static struct platform_driver mybeep_driver = {
157 .driver = {
158 .name = "zynq-beep", // 驱动名字，用于和设备匹配
159 .of_match_table = beep_of_match, // 设备树匹配表，用于和设备树中定义的设备匹配
160 },
161 .probe = mybeep_probe, // probe 函数
162 .remove = mybeep_remove, // remove 函数
163 };
164.name匹配probe里面的设备号名字，beep_of_match里面匹配设备树上的compatble

iic：


写：

读：

类似串口，写：设备地址，写入的寄存器地址，写入值。读：设备地址，读取寄存器地址，设备地址，设备发过来的读取数值。
232/485驱动开发：
NXP 官方已经编写好了，我们真正要做的就是在设备树中添加所要使用的串口节点信
息。当系统启动以后串口驱动和设备匹配成功，相应的串口就会被驱动起来，生成
/dev/ttymxcX(X=0….n)文件。流程如下：
每个串口驱动都需要定义一个 uart_driver，加载驱动的时候通过 uart_register_driver 函数向
系统注册这个 uart_driver，同时也需要包含注销驱动操作。uart_port 表示一个具体的 port，uart_port 定义在 include/linux/serial_core.h 文件，其中最重要的就是成员ops，因为linux系统中收发数据最终使用的是ops中的函数，ops 是 uart_ops类型的结构体指针变量。UART 驱动编写人员需要实现 uart_ops，因为 uart_ops 是最底层的 UART 驱动接口，是实实在在的和 UART 寄存器打交道的。