一，概念
IO是Input stream输入/Output stream输出的缩写，对于驱动程序来说的IO就是用户程序对设备资源的访问和操作。在IO 操作中几种状态分别是阻塞，非阻塞、同步和异步。
1， 阻塞就是指某个操作如果不满足执行的条件，它会一直处于等徃状态直至条件满足。
2，非阻塞是指某个操作如果不满足执行的条件，它会等待并返回未执行的结果。
3，同步指多个操作同时收发时，返些操作需要排队逐个执行。
4，异步指多个操作同时发生时，返些操作可以一起执行。
对于驱动来说IO操作一般可以理解为对外设的读写。一个完整的IO操作有两个阶段： 第一阶段：查看外设数据是否就绪； 第二阶段：数据就绪，读写外设数据。
阻塞 IO、非阻塞 IO： 当应用程序发出了IO请求。如果目标外设或数据没有准备好，对于阻塞 IO 来说，就会在 read 方法一直等待，直到数据准备好才会返回。而非阻塞 IO 会直接返回数据未准备好，应用程序再去处理NG的情况，重新读取或是其它。可见阻塞IO和非阻塞IO体现在IO操作的第一阶段。
同步 IO、异步 IO： 同步IO和异步IO实际上是针对应用程序和内核的交互来说的，应用程序发出 IO请求后， 如果数据没有就绪，需要应用程序不断的去轮询，直到准备就绪再执行第二阶段。对于异步 IO， 应用程序发出IO请求以后，第一阶段和第二阶段全都交由内核完成，驱动程序也属于内核的一部分。
二，阻塞IO:阻塞IO实际上是同步阻塞IO。
linux 的阻塞式访问中，应用程序调用read()函数从设备中获取数据时，如果设备或者数据没有准备好，就会迕入休眠让出CPU资源，准备好时就会唤醒并返回数据给应用程序。内核提供了等徃队列机制来实现返里的休眠唤醒工作。?
1，等待待队列也就是进程组成的队列，linux 在系统执行会根据不同的状态把进程分成不同的队列，等待队列就是其中之一。 在驱动中使用等待队列步骤：
?2，阻塞IO驱动
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/ide.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/cdev.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/device.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/of_irq.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/io.h>
/* 设备节点名称 */
#define DEVICE_NAME "bio_led"
/* 设备号个数 */
#define DEVID_COUNT 1
/* 驱动个数 */
#define DRIVE_COUNT 1
/* 主设备号 */
#define MAJOR_U
/* 次设备号 */
#define MINOR_U 0
/* 把驱动代码中会用到的数据打包进设备结构体 */
struct alinx_char_dev
{
/** 字符设备框架 **/
dev_t devid; //设备号
struct cdev cdev; //字符设备
struct class *class; //类
struct device *device; //设备
struct device_node *nd; //设备树的设备节点
/** gpio **/
int alinx_key_gpio; //gpio号
/** 并发处理 **/
atomic_t key_sts; //记录按键状态, 为1时被按下
/** 中断 **/
unsigned int irq; //中断号
/** 定时器 **/
struct timer_list timer; //定时器
/** 等待队列 **/
wait_queue_head_t wait_q_h; //等待队列头
};
/* 声明设备结构体 */
static struct alinx_char_dev alinx_char =
{
.cdev =
{
.owner = THIS_MODULE,
},
};
/** 回掉 **/
/* 中断服务函数 */
static irqreturn_t key_handler(int irq, void *dev)
{
/* 按键按下或抬起时会进入中断 */
/* 开启50毫秒的定时器用作防抖动 */
mod_timer(&alinx_char.timer, jiffies + msecs_to_jiffies(50));
return IRQ_RETVAL(IRQ_HANDLED);
}
/* 定时器服务函数 */
void timer_function(struct timer_list *timer)
{
/* value用于获取按键值 */
unsigned char value;
/* 获取按键值 */
value = gpio_get_value(alinx_char.alinx_key_gpio);
if(value == 0)
{
/* 按键按下, 状态置1 */
atomic_set(&alinx_char.key_sts, 1);
/** 等待队列 **/
/* 唤醒进程 */
wake_up_interruptible(&alinx_char.wait_q_h);
}
else
{
/* 按键抬起 */
}
}
/** 系统调用实现 **/
/* open函数实现, 对应到Linux系统调用函数的open函数 */
static int char_drv_open(struct inode *inode_p, struct file *file_p)
{
printk("gpio_test module open\n");
return 0;
}
/* read函数实现, 对应到Linux系统调用函数的write函数 */
static ssize_t char_drv_read(struct file *file_p, char __user *buf, size_t len, loff_t *loff_t_p)
{
unsigned int keysts = 0;
int ret;
/* 读取key的状态 */
keysts = atomic_read(&alinx_char.key_sts);
/* 判断当前按键状态 */
if(!keysts)
{
/* 按键未被按下(数据未准备好) */
/* 以当前进程创建并初始化为队列项 */
DECLARE_WAITQUEUE(queue_mem, current);
/* 把当前进程的队列项添加到队列头 */
add_wait_queue(&alinx_char.wait_q_h, &queue_mem);
/* 设置当前进成为可被信号打断的状态 */
__set_current_state(TASK_INTERRUPTIBLE);
/* 切换进程, 是当前进程休眠 */
schedule();
/* 被唤醒, 修改当前进程状态为RUNNING */
set_current_state(TASK_RUNNING);
/* 把当前进程的队列项从队列头中删除 */
remove_wait_queue(&alinx_char.wait_q_h, &queue_mem);
/* 判断是否是被信号唤醒 */
if(signal_pending(current))
{
/* 如果是直接返回错误 */
return -ERESTARTSYS;
}
else
{
/* 被按键唤醒 */
}
}
else
{
/* 按键被按下(数据准备好了) */
}
/* 读取key的状态 */
keysts = atomic_read(&alinx_char.key_sts);
/* 返回按键状态值 */
ret = copy_to_user(buf, &keysts, sizeof(keysts));
/* 清除按键状态 */
atomic_set(&alinx_char.key_sts, 0);
return 0;
}
/* release函数实现, 对应到Linux系统调用函数的close函数 */
static int char_drv_release(struct inode *inode_p, struct file *file_p)
{
printk("gpio_test module release\n");
return 0;
}
/* file_operations结构体声明, 是上面open、write实现函数与系统调用函数对应的关键 */
static struct file_operations ax_char_fops =
{
.owner = THIS_MODULE,
.open = char_drv_open,
.read = char_drv_read,
.release = char_drv_release,
};
/* 模块加载时会调用的函数 */
static int __init char_drv_init(void)
{
/* 用于接受返回值 */
u32 ret = 0;
/** 并发处理 **/
/* 初始化原子变量 */
atomic_set(&alinx_char.key_sts, 0);
/** gpio框架 **/
/* 获取设备节点 */
alinx_char.nd = of_find_node_by_path("/alinxkey");
if(alinx_char.nd == NULL)
{
printk("alinx_char node not find\r\n");
return -EINVAL;
}
else
{
printk("alinx_char node find\r\n");
}
/* 获取节点中gpio标号 */
alinx_char.alinx_key_gpio = of_get_named_gpio(alinx_char.nd, "alinxkey-gpios", 0);
if(alinx_char.alinx_key_gpio < 0)
{
printk("can not get alinxkey-gpios");
return -EINVAL;
}
printk("alinxkey-gpio num = %d\r\n", alinx_char.alinx_key_gpio);
/* 申请gpio标号对应的引脚 */
ret = gpio_request(alinx_char.alinx_key_gpio, "alinxkey");
if(ret != 0)
{
printk("can not request gpio\r\n");
return -EINVAL;
}
/* 把这个io设置为输入 */
ret = gpio_direction_input(alinx_char.alinx_key_gpio);
if(ret < 0)
{
printk("can not set gpio\r\n");
return -EINVAL;
}
/** 中断 **/
/* 获取中断号 */
alinx_char.irq = gpio_to_irq(alinx_char.alinx_key_gpio);
/* 申请中断 */
ret = request_irq(alinx_char.irq,
key_handler,
IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
"alinxkey",
NULL);
if(ret < 0)
{
printk("irq %d request failed\r\n", alinx_char.irq);
return -EFAULT;
}
/** 定时器 **/
timer_setup(&alinx_char.timer, timer_function, NULL);
/** 等待队列 **/
init_waitqueue_head(&alinx_char.wait_q_h);
/** 字符设备框架 **/
/* 注册设备号 */
alloc_chrdev_region(&alinx_char.devid, MINOR_U, DEVID_COUNT, DEVICE_NAME);
/* 初始化字符设备结构体 */
cdev_init(&alinx_char.cdev, &ax_char_fops);
/* 注册字符设备 */
cdev_add(&alinx_char.cdev, alinx_char.devid, DRIVE_COUNT);
/* 创建类 */
alinx_char.class = class_create(THIS_MODULE, DEVICE_NAME);
if(IS_ERR(alinx_char.class))
{
return PTR_ERR(alinx_char.class);
}
/* 创建设备节点 */
alinx_char.device = device_create(alinx_char.class, NULL,
alinx_char.devid, NULL, DEVICE_NAME);
if (IS_ERR(alinx_char.device))
{
return PTR_ERR(alinx_char.device);
}
return 0;
}
/* 卸载模块 */
static void __exit char_drv_exit(void)
{
/** gpio **/
/* 释放gpio */
gpio_free(alinx_char.alinx_key_gpio);
/** 中断 **/
/* 释放中断 */
free_irq(alinx_char.irq, NULL);
/** 定时器 **/
/* 删除定时器 */
del_timer_sync(&alinx_char.timer);
/** 字符设备框架 **/
/* 注销字符设备 */
cdev_del(&alinx_char.cdev);
/* 注销设备号 */
unregister_chrdev_region(alinx_char.devid, DEVID_COUNT);
/* 删除设备节点 */
device_destroy(alinx_char.class, alinx_char.devid);
/* 删除类 */
class_destroy(alinx_char.class);
printk("timer_led_dev_exit_ok\n");
}
/* 标记加载、卸载函数 */
module_init(char_drv_init);
module_exit(char_drv_exit);
/* 驱动描述信息 */
MODULE_AUTHOR("subomb");
MODULE_ALIAS("alinx char");
MODULE_DESCRIPTION("BIO LED driver");
MODULE_VERSION("v1.0");
MODULE_LICENSE("GPL"); 3，测试
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
int main(int argc, char *argv[])
{
int fd, fd_l ,ret;
char *filename, led_value = 0;
unsigned int key_value;
if(argc != 2)
{
printf("Error Usage\r\n");
return -1;
}
filename = argv[1];
fd = open(filename, O_RDWR);
if(fd < 0)
{
printf("file %s open failed\r\n", argv[1]);
return -1;
}
while(1)
{
ret = read(fd, &key_value, sizeof(key_value));
if(ret < 0)
{
printf("read failed\r\n");
break;
}
if(1 == key_value)
{
printf("ps_key1 press\r\n");
led_value = !led_value;
fd_l = open("/dev/gpio_leds", O_RDWR);
if(fd_l < 0)
{
printf("file /dev/gpio_leds open failed\r\n");
break;
}
ret = write(fd_l, &led_value, sizeof(led_value));
if(ret < 0)
{
printf("write failed\r\n");
break;
}
ret = close(fd_l);
if(ret < 0)
{
printf("file /dev/gpio_leds close failed\r\n");
break;
}
}
}
ret = close(fd);
if(ret < 0)
{
printf("file %s close failed\r\n", argv[1]);
return -1;
}
return 0;
}?三，非阻塞IO：非阻塞 IO(NIO)，也就是同步非阻塞 IO。
IO操作的两个阶段先查询再读写，而非阻塞IO在查询阶段的处理和阻塞 IO不同。应用程序需要迕行 IO 操 作前，先发起查询，驱劢程序根据数据情况返回查询结果，如果返回查询结果NG，应用程序就不执行读写操作了。如果应用程序非要读写的话，就继续去查询，直到驱动程序返回数据准备完成，才会做下一步的读写操作。
非阻塞IO的处理方式是轮询。linux 中提供了应用程序的轮询机制和相应的驱动程序系统调用。
1，应用程序中的三种轮询方法：select、poll、epoll?
（1）select
struct timeval
{
long tv_sec; /*秒 */
long tv_usec; /*微秒 */
}
返个参数的值有三种情况
1，如果传入NULL，不传入时间结构，
就是一个阻塞凼数，直到某个文件描述符収生发化才会返回。
2，如果把秒和微妙都设为 0，就是一个非阻塞凼数，会立刻返回，
文件无发化返回0，有发化返回正值。
3，如果值大于0，则意为超时时间， select若在timeout时间内没有检测到文件描述符发化，
则会直接返回0，有发化直接回正值。
?使用举例：
#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include "poll.h"
#include "sys/select.h"
#include "sys/time.h"
#include "linux/ioctl.h"
int main(int argc, char *argv[])
{
/* ret获取返回值, fd获取文件句柄 */
int ret, fd, fd_l;
/* 定义一个监视文件读变化的描述符合集 */
fd_set readfds;
/* 定义一个超时时间结构体 */
struct timeval timeout;
char *filename, led_value = 0;
unsigned int key_value;
if(argc != 2)
{
printf("Error Usage\r\n");
return -1;
}
filename = argv[1];
/* 获取文件句柄, O_NONBLOCK表示非阻塞访问 */
fd = open(filename, O_RDWR | O_NONBLOCK);
if(fd < 0)
{
printf("can not open file %s\r\n", filename);
return -1;
}
while(1)
{
/* 初始化描述符合集 */
FD_ZERO(&readfds);
/* 把文件句柄fd指向的文件添加到描述符 */
FD_SET(fd, &readfds);
/* 超时时间初始化为1.5秒 */
timeout.tv_sec = 1;
timeout.tv_usec = 500000;
/* 调用select, 注意第一个参数为fd+1 */
ret = select(fd + 1, &readfds, NULL, NULL, &timeout);
switch (ret)
{
case 0:
{
/* 超时 */
break;
}
case -1:
{
/* 出错 */
break;
}
default:
{
/* 监视的文件可操作 */
/* 判断可操作的文件是不是文件句柄fd指向的文件 */
if(FD_ISSET(fd, &readfds))
{
/* 操作文件 */
ret = read(fd, &key_value, sizeof(key_value));
if(ret < 0)
{
printf("read failed\r\n");
break;
}
printf("key_value = %d\r\n", key_value);
if(1 == key_value)
{
printf("ps_key1 press\r\n");
led_value = !led_value;
fd_l = open("/dev/gpio_leds", O_RDWR);
if(fd_l < 0)
{
printf("file /dev/gpio_leds open failed\r\n");
break;
}
ret = write(fd_l, &led_value, sizeof(led_value));
if(ret < 0)
{
printf("write failed\r\n");
break;
}
ret = close(fd_l);
if(ret < 0)
{
printf("file /dev/gpio_leds close failed\r\n");
break;
}
}
}
break;
}
}
}
close(fd);
return ret;
}
（2）poll：原型int poll (struct pollfd *fds, unsigned int nfds, int timeout);
poll 本质上和sellect 没有区别，poll它的最大连接数没有限制。参数说明：
nfds：poll 监规的文件句柄数量，也就是fds的数组长度。
imeout：超时时间，单位为毫秒。
?fds：struct pollfd 结构体是文件句柄和事件的组合，定义：
struct pollfd
{
int fd;
//fd 是文件句柄，events 是对于这个文件需要监规的事件类型，
revents 是内核返回的事件类型。事件类型有：
POLLIN //有数据可诺
POLLPRI //有紧急数据可诺
POLLOUT //数据可冐
POLLERR //挃定文件描述符収生错诨
POLLHUP //挃定文件描述符挂起
POLLNVAL //无效请求
POLLRDNORM //有数据可诺
short events;
short revents;
};（3），epoll：可以理解为 event poll，设计用于大并发时的IO查询，常用于网络编程。
2，驱动程序中的poll函数:
应用程序中调用 select、poll、epoll 时，系统调用就会执行驱动程序中file_operations的poll函数。也就是需要实现的驱动函数，函数原型：
unsigned int (*poll) (struct file *filp, struct poll_table_struct *wait)；
返回值和struct pollfd结构体中事件相同。
filp：应用程序传递过来的值，应用程序 open 以后获得的目标文件句柄。
wait：应用程序传递过来的值，代表应用程序线程。我们需要在poll函数中调用poll_wait将应用程序添线程wait添加到poll_table等待队列中，poll_wait函数原型如下：
void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)；
3，驱动程序
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/ide.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/cdev.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/device.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/of_irq.h>
#include <linux/irq.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <asm/uaccess.h>
#include <asm/io.h>
/* 设备节点名称 */
#define DEVICE_NAME "nio_led"
/* 设备号个数 */
#define DEVID_COUNT 1
/* 驱动个数 */
#define DRIVE_COUNT 1
/* 主设备号 */
#define MAJOR_U
/* 次设备号 */
#define MINOR_U 0
/* 把驱动代码中会用到的数据打包进设备结构体 */
struct alinx_char_dev
{
/** 字符设备框架 **/
dev_t devid; //设备号
struct cdev cdev; //字符设备
struct class *class; //类
struct device *device; //设备
struct device_node *nd; //设备树的设备节点
/** gpio **/
int alinx_key_gpio; //gpio号
/** 并发处理 **/
atomic_t key_sts; //记录按键状态, 为1时被按下
/** 中断 **/
unsigned int irq; //中断号
/** 定时器 **/
struct timer_list timer; //定时器
/** 等待队列 **/
wait_queue_head_t wait_q_h; //等待队列头
};
/* 声明设备结构体 */
static struct alinx_char_dev alinx_char =
{
.cdev =
{
.owner = THIS_MODULE,
},
};
/** 回掉 **/
/* 中断服务函数 */
static irqreturn_t key_handler(int irq, void *dev)
{
/* 按键按下或抬起时会进入中断 */
/* 开启50毫秒的定时器用作防抖动 */
mod_timer(&alinx_char.timer, jiffies + msecs_to_jiffies(50));
return IRQ_RETVAL(IRQ_HANDLED);
}
/* 定时器服务函数 */
void timer_function(struct timer_list *timer)
{
/* value用于获取按键值 */
unsigned char value;
/* 获取按键值 */
value = gpio_get_value(alinx_char.alinx_key_gpio);
if(value == 0)
{
/* 按键按下, 状态置1 */
atomic_set(&alinx_char.key_sts, 1);
/** 等待队列 **/
/* 唤醒进程 */
wake_up_interruptible(&alinx_char.wait_q_h);
}
else
{
/* 按键抬起 */
}
}
/** 系统调用实现 **/
/* open函数实现, 对应到Linux系统调用函数的open函数 */
static int char_drv_open(struct inode *inode_p, struct file *file_p)
{
printk("gpio_test module open\n");
return 0;
}
/* read函数实现, 对应到Linux系统调用函数的write函数 */
static ssize_t char_drv_read(struct file *file_p, char __user *buf, size_t len, loff_t *loff_t_p)
{
unsigned int keysts = 0;
int ret;
/* 读取key的状态 */
keysts = atomic_read(&alinx_char.key_sts);
/* 判断文件打开方式 */
if(file_p->f_flags & O_NONBLOCK)
{
/* 如果是非阻塞访问, 说明以满足读取条件 */
}
/* 判断当前按键状态 */
else if(!keysts)
{
/* 按键未被按下(数据未准备好) */
/* 以当前进程创建并初始化为队列项 */
DECLARE_WAITQUEUE(queue_mem, current);
/* 把当前进程的队列项添加到队列头 */
add_wait_queue(&alinx_char.wait_q_h, &queue_mem);
/* 设置当前进成为可被信号打断的状态 */
__set_current_state(TASK_INTERRUPTIBLE);
/* 切换进程, 是当前进程休眠 */
schedule();
/* 被唤醒, 修改当前进程状态为RUNNING */
set_current_state(TASK_RUNNING);
/* 把当前进程的队列项从队列头中删除 */
remove_wait_queue(&alinx_char.wait_q_h, &queue_mem);
/* 判断是否是被信号唤醒 */
if(signal_pending(current))
{
/* 如果是直接返回错误 */
return -ERESTARTSYS;
}
else
{
/* 被按键唤醒 */
}
}
else
{
/* 按键被按下(数据准备好了) */
}
/* 读取key的状态 */
keysts = atomic_read(&alinx_char.key_sts);
/* 返回按键状态值 */
ret = copy_to_user(buf, &keysts, sizeof(keysts));
/* 清除按键状态 */
atomic_set(&alinx_char.key_sts, 0);
return 0;
}
/* poll函数实现 */
unsigned int char_drv_poll(struct file *filp, struct poll_table_struct *wait)
{
unsigned int ret = 0;
/* 将应用程序添添加到等待队列中 */
poll_wait(filp, &alinx_char.wait_q_h, wait);
/* 判断key的状态 */
if(atomic_read(&alinx_char.key_sts))
{
/* key准备好了, 返回数据可读 */
ret = POLLIN;
}
else
{
}
return ret;
}
/* release函数实现, 对应到Linux系统调用函数的close函数 */
static int char_drv_release(struct inode *inode_p, struct file *file_p)
{
printk("gpio_test module release\n");
return 0;
}
/* file_operations结构体声明, 是上面open、write实现函数与系统调用函数对应的关键 */
static struct file_operations ax_char_fops =
{
.owner = THIS_MODULE,
.open = char_drv_open,
.read = char_drv_read,
.poll = char_drv_poll,
.release = char_drv_release,
};
/* 模块加载时会调用的函数 */
static int __init char_drv_init(void)
{
/* 用于接受返回值 */
u32 ret = 0;
/** 并发处理 **/
/* 初始化原子变量 */
atomic_set(&alinx_char.key_sts, 0);
/** gpio框架 **/
/* 获取设备节点 */
alinx_char.nd = of_find_node_by_path("/alinxkey");
if(alinx_char.nd == NULL)
{
printk("alinx_char node not find\r\n");
return -EINVAL;
}
else
{
printk("alinx_char node find\r\n");
}
/* 获取节点中gpio标号 */
alinx_char.alinx_key_gpio = of_get_named_gpio(alinx_char.nd, "alinxkey-gpios", 0);
if(alinx_char.alinx_key_gpio < 0)
{
printk("can not get alinxkey-gpios");
return -EINVAL;
}
printk("alinxkey-gpio num = %d\r\n", alinx_char.alinx_key_gpio);
/* 申请gpio标号对应的引脚 */
ret = gpio_request(alinx_char.alinx_key_gpio, "alinxkey");
if(ret != 0)
{
printk("can not request gpio\r\n");
return -EINVAL;
}
/* 把这个io设置为输入 */
ret = gpio_direction_input(alinx_char.alinx_key_gpio);
if(ret < 0)
{
printk("can not set gpio\r\n");
return -EINVAL;
}
/** 中断 **/
/* 获取中断号 */
alinx_char.irq = gpio_to_irq(alinx_char.alinx_key_gpio);
/* 申请中断 */
ret = request_irq(alinx_char.irq,key_handler,
IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
"alinxkey", NULL);
if(ret < 0)
{
printk("irq %d request failed\r\n", alinx_char.irq);
return -EFAULT;
}
/** 定时器 **/
timer_setup(&alinx_char.timer, timer_function, NULL);
/** 等待队列 **/
init_waitqueue_head(&alinx_char.wait_q_h);
/** 字符设备框架 **/
/* 注册设备号 */
alloc_chrdev_region(&alinx_char.devid, MINOR_U, DEVID_COUNT, DEVICE_NAME);
/* 初始化字符设备结构体 */
cdev_init(&alinx_char.cdev, &ax_char_fops);
/* 注册字符设备 */
cdev_add(&alinx_char.cdev, alinx_char.devid, DRIVE_COUNT);
/* 创建类 */
alinx_char.class = class_create(THIS_MODULE, DEVICE_NAME);
if(IS_ERR(alinx_char.class))
{
return PTR_ERR(alinx_char.class);
}
/* 创建设备节点 */
alinx_char.device = device_create(alinx_char.class, NULL,
alinx_char.devid, NULL, DEVICE_NAME);
if (IS_ERR(alinx_char.device))
{
return PTR_ERR(alinx_char.device);
}
return 0;
}
/* 卸载模块 */
static void __exit char_drv_exit(void)
{
/** gpio **/
/* 释放gpio */
gpio_free(alinx_char.alinx_key_gpio);
/** 中断 **/
/* 释放中断 */
free_irq(alinx_char.irq, NULL);
/** 定时器 **/
/* 删除定时器 */
del_timer_sync(&alinx_char.timer);
/** 字符设备框架 **/
/* 注销字符设备 */
cdev_del(&alinx_char.cdev);
/* 注销设备号 */
unregister_chrdev_region(alinx_char.devid, DEVID_COUNT);
/* 删除设备节点 */
device_destroy(alinx_char.class, alinx_char.devid);
/* 删除类 */
class_destroy(alinx_char.class);
printk("timer_led_dev_exit_ok\n");
}
/* 标记加载、卸载函数 */
module_init(char_drv_init);
module_exit(char_drv_exit);
/* 驱动描述信息 */
MODULE_AUTHOR("subomb");
MODULE_ALIAS("alinx char");
MODULE_DESCRIPTION("NIO LED driver");
MODULE_VERSION("v1.0");
MODULE_LICENSE("GPL"); 
