linux驱动开发 - 10_阻塞和非阻塞 IO

news2024/11/17 9:51:19

文章目录

    • 1 阻塞和非阻塞 IO
      • 1.1 阻塞和非阻塞简介
      • 1.2 等待队列
        • 1、等待队列头
        • 2、等待队列项
        • 3、将队列项添加/移除等待队列头
        • 4、等待唤醒
        • 5、等待事件
      • 1.3 Linux驱动下的poll操作函数
    • 2 阻塞 IO 实验
      • 1、驱动程序编写
      • 2、编写测试 APP
      • 3、编译驱动程序和测试 APP
      • 4、运行测试
    • 3 阻塞 IO 实验
      • 1、驱动程序编写
      • 2、编写测试 APP
      • 3、编译驱动程序和测试 APP
      • 4、运行测试

1 阻塞和非阻塞 IO

1.1 阻塞和非阻塞简介

  • 当应用程序对设备驱动进行操作的时候，如果不能获取到设备资源，那么阻塞式 IO 就会将应用程序对应的线程挂起，直到设备资源可以获取为止。

  • 非阻塞 IO，应用程序对应的线程不会挂起，它要么一直轮询等待，直到设备资源可以使用，要么就直接放弃。

阻塞 IO 访问示意图，应用程序调用 read 函数从设备中读取数据，当设备不可用或数据未准备好的时候就会进入到休眠态。等设备可用的时候就会从休眠态唤醒，然后从设备中读取数据返回给应用程序。

在这里插入图片描述

非阻塞 IO 访问示意图，应用程序使用非阻塞访问方式从设备读取数据，当设备不可用或数据未准备好的时候会立即向内核返回一个错误码，表示数据读取失败。应用程序会再次重新读取数据，这样一直往复循环，直到数据读取成功。

在这里插入图片描述

应用程序可以使用如下所示示例代码来实现阻塞访问：

int fd;
int data = 0;
fd = open("/dev/xxx_dev", O_RDWR); /* 阻塞方式打开 */
ret = read(fd, &data, sizeof(data)); /* 读取数据 */

应用程序要采用非阻塞的方式来访问驱动设备文件:

int fd;
int data = 0;
fd = open("/dev/xxx_dev", O_RDWR | O_NONBLOCK); /* 非阻塞方式打开 */
ret = read(fd, &data, sizeof(data)); /* 读取数据 */

1.2 等待队列

1、等待队列头

阻塞访问最大的好处就是当设备文件不可操作的时候进程可以进入休眠态，这样可以将CPU 资源让出来。

Linux 内核提供了等待队列(wait queue)来实现阻塞进程的唤醒工作，在驱动中使用等待队列，必须创建并初始化一个等待队列头，等待队列头使用结构体wait_queue_head_t 表示， wait_queue_head_t 结构体定义在文件 include/linux/wait.h 中，结构体内容如下所示：

struct __wait_queue_head {
    spinlock_t lock;
    struct list_head task_list;
};
typedef struct __wait_queue_head wait_queue_head_t;
  • 定义好等待队列头以后需要初始化， 使用 init_waitqueue_head 函数初始化等待队列头，函数原型如下：
void init_waitqueue_head(wait_queue_head_t *q)
    
参数 q 就是要初始化的等待队列头。

也可以使用宏 DECLARE_WAIT_QUEUE_HEAD 来一次性完成等待队列头的定义的初始化。

2、等待队列项

等待队列头就是一个等待队列的头部，每个访问设备的进程都是一个队列项，**当设备不可用的时候就要将这些进程对应的等待队列项添加到等待队列里面。**结构体 wait_queue_t 表示等待队列项，结构体内容如下：

struct __wait_queue {
    unsigned int flags;
    void *private;
    wait_queue_func_t func;
    struct list_head task_list;
};
typedef struct __wait_queue wait_queue_t;

使用宏 DECLARE_WAITQUEUE 定义并初始化一个等待队列项，宏的内容如下：

DECLARE_WAITQUEUE(name, tsk)
    
name 就是等待队列项的名字， 
tsk 表示这个等待队列项属于哪个任务(进程)，一般设置为current，在Linux内核中current相当于一个全局变量，表示当前进程。因此宏DECLARE_WAITQUEUE 就是给当前正在运行的进程创建并初始化了一个等待队列项。

3、将队列项添加/移除等待队列头

当设备不可访问的时候就需要将进程对应的等待队列项添加到前面创建的等待队列头中，只有添加到等待队列头中以后进程才能进入休眠态。当设备可以访问以后再将进程对应的等待队列项从等待队列头中移除即可，等待队列项添加 API 函数如下：

void add_wait_queue(wait_queue_head_t *q,
					wait_queue_t *wait)

函数参数和返回值含义如下：
    q： 等待队列项要加入的等待队列头。
    wait：要加入的等待队列项。
返回值：无。

等待队列项移除 API 函数如下：

void remove_wait_queue(wait_queue_head_t *q,
						wait_queue_t *wait)
函数参数和返回值含义如下：
    q： 要删除的等待队列项所处的等待队列头。
    wait：要删除的等待队列项。
返回值：无

4、等待唤醒

当设备可以使用的时候就要唤醒进入休眠态的进程，唤醒可以使用如下两个函数：

void wake_up(wait_queue_head_t *q)
void wake_up_interruptible(wait_queue_head_t *q)
    
参数 q 就是要唤醒的等待队列头，这两个函数会将这个等待队列头中的所有进程都唤醒。
wake_up 函数可以唤醒处于 TASK_INTERRUPTIBLE 和 TASK_UNINTERRUPTIBLE 状态的进程
wake_up_interruptible 函数只能唤醒处于 TASK_INTERRUPTIBLE 状态的进程。

5、等待事件

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

函数描述
wait_event(wq, condition)等待以 wq 为等待队列头的等待队列被唤醒，前 提是 condition 条件必须满足(为真)，否则一直阻 塞 。 此 函 数 会 将 进 程 设 置 为 TASK_UNINTERRUPTIBLE 状态
wait_event_timeout(wq, condition, timeout)功能和 wait_event 类似，但是此函数可以添加超 时时间，以 jiffies 为单位。此函数有返回值，如果返回 0 的话表示超时时间到，而且 condition 为假。为 1 的话表示 condition 为真，也就是条 件满足了
wait_event_interruptible(wq, condition)与 wait_event 函数类似，但是此函数将进程设置 为 TASK_INTERRUPTIBLE，就是可以被信号打 断。
wait_event_interruptible_timeout(wq, condition, timeout)与 wait_event_timeout 函数类似，此函数也将进 程设置为 TASK_INTERRUPTIBLE，可以被信号 打断。

1.3 Linux驱动下的poll操作函数

当应用程序调用 select 或 poll 函数来对驱动程序进行非阻塞访问的时候，驱动程序file_operations 操作集中的 poll 函数就会执行。

poll 函数原型如下所示：

unsigned int (*poll) (struct file *filp, struct poll_table_struct *wait)
    
函数参数和返回值含义如下：
filp： 要打开的设备文件(文件描述符)。
wait： 结构体 poll_table_struct 类型指针， 由应用程序传递进来的。一般将此参数传递给poll_wait 函数。

返回值:向应用程序返回设备或者资源状态，可以返回的资源状态如下：
POLLIN 有数据可以读取。
POLLPRI 有紧急的数据需要读取。
POLLOUT 可以写数据。
POLLERR 指定的文件描述符发生错误。
POLLHUP 指定的文件描述符挂起。
POLLNVAL 无效的请求。
POLLRDNORM 等同于 POLLIN，普通数据可读

在驱动程序的 poll 函数中调用 poll_wait 函数， poll_wait 函数不会引起阻塞，只是将应用程序添加到 poll_table 中， poll_wait 函数原型如下：

void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)

参数 wait_address 是要添加到 poll_table 中的等待队列头
参数 p 就是 poll_table，就是file_operations 中 poll 函数的 wait 参数。

2 阻塞 IO 实验

1、驱动程序编写

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/string.h>
#include <linux/irq.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#include <linux/wait.h>
#include <linux/ide.h>



#define IMX6UIRQ_CNT     1
#define IMX6UIRQ_NAME    "blockio"
#define KEY_NUM            1
#define KEY0VALUE          0X01
#define INVAKEY            0XFF


/* key结构体 */
struct irq_keydesc{
    int gpio;               /* io编号 */
    int irqnum;             /* 中断号 */
    unsigned char value;    /* 键值 */
    char name[10];          /* 名字 */
    irqreturn_t (*handler) (int, void *);  /* 中断处理函数 */
};


/* imx6uirq设备结构体 */
struct imx6uirq_dev{
    dev_t devid;
    int major;
    int minor;
    struct cdev cdev;
    struct class *class;
    struct device *device;
    struct device_node *nd;
    struct irq_keydesc irqkey[KEY_NUM];
    struct timer_list timer; 

    atomic_t keyvalue;
    atomic_t releasekey;

    wait_queue_head_t  r_wait; /* 读等待队列头 */
};

struct imx6uirq_dev imx6uirq; /* irq设备 */

static int imx6uirq_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &imx6uirq;
    return 0;
}


static ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    int ret = 0;
    unsigned char keyvalue;
    unsigned char releasekey;
    struct imx6uirq_dev *dev = filp->private_data;

#if 0
    /* 等待事件 */
    wait_event_interruptible(dev->r_wait, atomic_read(&dev->releasekey)); /* 等待按键有效 */
#endif

#if 0
    DECLARE_WAITQUEUE(wait, current);  /* 定义一个等待队列项 */
    if(atomic_read(&dev->releasekey) == 0) { /* 按键没按下 */
        add_wait_queue(&dev->r_wait, &wait); /* 将队列项添加到等待队列头 */
        __set_current_state(TASK_INTERRUPTIBLE);    /* 当前进程设置为可被打断的状态 */
        schedule();                     /* 切换 */

        /* 唤醒以后从这里运行 */
        if (signal_pending(current)) {      
			ret = -ERESTARTSYS;
			goto data_error;
		}

        __set_current_state(TASK_RUNNING);      /* 将当前任务设置为运行状态 */
	    remove_wait_queue(&dev->r_wait, &wait);    /* 将对应的队列项从等待队列头删除 */
    }
#endif

    DECLARE_WAITQUEUE(wait, current);  /* 定义一个等待队列项 */
    add_wait_queue(&dev->r_wait, &wait); /* 将队列项添加到等待队列头 */
    __set_current_state(TASK_INTERRUPTIBLE);    /* 当前进程设置为可被打断的状态 */
    schedule();                     /* 切换 */

    /* 唤醒以后从这里运行 */
    if (signal_pending(current)) {      
		ret = -ERESTARTSYS;
		goto data_error;
	}

    keyvalue = atomic_read(&dev->keyvalue);
    releasekey = atomic_read(&dev->releasekey);

    if(releasekey) {        /* 有效按键 */
        if(keyvalue & 0x80) {
            keyvalue &= ~0x80;
            ret = copy_to_user(buf, &keyvalue, sizeof(keyvalue));
        } else {
            goto data_error;
        }
        atomic_set(&dev->releasekey, 0); /* 按下标志清零 */
    } else {
        goto data_error;
    }

data_error:
    __set_current_state(TASK_RUNNING);      /* 将当前任务设置为运行状态 */
	remove_wait_queue(&dev->r_wait, &wait);    /* 将对应的队列项从等待队列头删除 */
    return ret;
}

/* 操作集 */
static const struct file_operations imx6uirq_fops = {
    .owner		=	THIS_MODULE,
	.open		=	imx6uirq_open,
    .read       =   imx6uirq_read,
};

/* 按键中断处理函数 */
static irqreturn_t key0_handler(int irq, void *dev_id)
{
    struct imx6uirq_dev *dev = dev_id;

    dev->timer.data = (volatile long)dev_id;
    mod_timer(&dev->timer, jiffies + msecs_to_jiffies(20)); /* 20ms定时 */

	return IRQ_HANDLED;
}

/* 定时器处理函数 */
static void timer_func(unsigned long arg) {
    int value = 0;
    struct imx6uirq_dev *dev = (struct imx6uirq_dev*)arg;

    value = gpio_get_value(dev->irqkey[0].gpio);
    if(value == 0)   {          /* 按下 */
        atomic_set(&dev->keyvalue, dev->irqkey[0].value);
    } else if(value == 1) {     /* 释放 */
        atomic_set(&dev->keyvalue, 0X80 | (dev->irqkey[0].value));
        atomic_set(&dev->releasekey, 1);  /* 完成的按键过程 */
    }

    /* 唤醒进程 */
    if(atomic_read(&dev->releasekey)) {
         wake_up(&dev->r_wait);
    }

}


/* 按键初始化 */
static int keyio_init(struct imx6uirq_dev *dev)
{
    int ret  = 0;
    int i = 0;

    /* 1,按键初始化 */
    dev->nd = of_find_node_by_path("/key");
    if(dev->nd == NULL) {
        ret = -EINVAL;
        goto fail_nd;
    }

    for(i = 0; i < KEY_NUM; i++) {
        dev->irqkey[i].gpio = of_get_named_gpio(dev->nd, "key-gpio", i);
    }
    for(i = 0; i < KEY_NUM; i++) {
        memset(dev->irqkey[i].name, 0, sizeof(dev->irqkey[i].name));
        sprintf(dev->irqkey[i].name, "KEY%d", i);
        gpio_request(dev->irqkey[i].gpio, dev->irqkey[i].name);
        gpio_direction_input(dev->irqkey[i].gpio);

        dev->irqkey[i].irqnum = gpio_to_irq(dev->irqkey[i].gpio); /* 获取中断号 */
#if 0
        dev->irqkey[i].irqnum = irq_of_parse_and_map(dev->nd, i);
#endif

    }

    dev->irqkey[0].handler = key0_handler;
    dev->irqkey[0].value  = KEY0VALUE;

    /* 2,按键中断初始化 */
    for(i = 0; i < KEY_NUM; i++) {
        ret = request_irq(dev->irqkey[i].irqnum, dev->irqkey[i].handler, 
                         IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, 
                         dev->irqkey[i].name, &imx6uirq);
        if(ret) {
            printk("irq %d request failed!\r\n", dev->irqkey[i].irqnum);
            goto fail_irq;
        }
    }

    /* 3、初始化定时器 */
    init_timer(&imx6uirq.timer);
    imx6uirq.timer.function = timer_func;
    return 0;

fail_irq:
    for(i = 0; i < KEY_NUM; i++) {
        gpio_free(dev->irqkey[i].gpio);
    }
fail_nd:
    return ret;
}

/* 驱动入口函数 */
static int __init imx6uirq_init(void)
{

    int ret = 0;

    /* 注册字符设备驱动 */
    imx6uirq.major = 0;
    if(imx6uirq.major) { /* 给定主设备号 */
        imx6uirq.devid = MKDEV(imx6uirq.major, 0);
        ret = register_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT, IMX6UIRQ_NAME);
    } else {            /* 没给定设备号 */
        ret = alloc_chrdev_region(&imx6uirq.devid, 0, IMX6UIRQ_CNT, IMX6UIRQ_NAME);
        imx6uirq.major = MAJOR(imx6uirq.devid);
        imx6uirq.minor = MINOR(imx6uirq.devid);
    }
    if(ret < 0) {
        goto fail_devid;
    }
    printk("imx6uirq major = %d, minor = %d\r\n", imx6uirq.major, imx6uirq.minor);

    /* 2,初始化cdev */
    imx6uirq.cdev.owner = THIS_MODULE;
    cdev_init(&imx6uirq.cdev, &imx6uirq_fops);

    /* 3,添加cdev */
    ret = cdev_add(&imx6uirq.cdev, imx6uirq.devid, IMX6UIRQ_CNT);
    if (ret)
		goto fail_cdevadd;

    /* 4、创建类 */
    imx6uirq.class = class_create(THIS_MODULE, IMX6UIRQ_NAME);
    if(IS_ERR(imx6uirq.class)) {
        ret = PTR_ERR(imx6uirq.class);
        goto fail_class;
    }

    /* 5,创建设备  */
    imx6uirq.device = device_create(imx6uirq.class, NULL, imx6uirq.devid, NULL, IMX6UIRQ_NAME);
    if(IS_ERR(imx6uirq.device)) {
        ret = PTR_ERR(imx6uirq.device);
        goto fail_device;
    }

    /* 初始化IO */
    ret = keyio_init(&imx6uirq);
    if(ret < 0) {
        goto fail_keyinit;
    }


    /* 初始化原子变量 */
    atomic_set(&imx6uirq.keyvalue, INVAKEY);
    atomic_set(&imx6uirq.releasekey, 0);

    /* 等待队列头 */
    init_waitqueue_head(&imx6uirq.r_wait);
    return 0;

fail_keyinit:
fail_device:
    class_destroy(imx6uirq.class);
fail_class:
    cdev_del(&imx6uirq.cdev);
fail_cdevadd:
    unregister_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT);
fail_devid:
    return ret;

}

/* 驱动出口函数 */
static void __exit imx6uirq_exit(void)
{
    int i = 0;
    /*1、释放中断 */
    for(i = 0; i < KEY_NUM; i++) {
        free_irq(imx6uirq.irqkey[i].irqnum, &imx6uirq);
    }
    /* 2,释放IO */
    for(i = 0; i < KEY_NUM; i++) {
        gpio_free(imx6uirq.irqkey[i].gpio);
    }

    /* 3,删除定时器 */
    del_timer_sync(&imx6uirq.timer);

    /* 注销字符设备驱动 */
    cdev_del(&imx6uirq.cdev);
    unregister_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT);

    device_destroy(imx6uirq.class, imx6uirq.devid);
    class_destroy(imx6uirq.class);

}

module_init(imx6uirq_init);
module_exit(imx6uirq_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("kaka");

2、编写测试 APP

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
/*
 *argc:应用程序参数个数
 *argv[]:具体的参数内容，字符串形式 
 *./imx6uirqAPP  <filename>  
 * ./imx6uirqAPP /dev/mx6uirq
 */


int main(int argc, char *argv[])
{
    int fd, ret;
    char *filename;
    unsigned char data;

    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", filename);
        return -1;
    }

    /* 循环读取 */
    while(1) {
        ret = read(fd, &data, sizeof(data));
        if(ret < 0) {

        } else {
            if(data)
                printf("key value = %#x\r\n", data);
        }

    }

    close(fd);

    return 0;
}

3、编译驱动程序和测试 APP

①、编译驱动程序

KERNELDIR := /home/kaka/linux/IMX6ULL/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek
CURRENT_PATH := $(shell pwd)

obj-m := blockio.o 

build: kernel_modules

kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

输入如下命令编译出驱动模块文件：

make -j32

编译成功以后就会生成一个名为“blockio .ko ”的驱动模块文件。

②、编译测试 APP

arm-linux-gnueabihf-gcc blockioApp.c -o blockioApp

4、运行测试

将编译出来的blockio.ko 和 blockioApp 这两个文件拷贝到rootfs/lib/modules/4.1.15目录中 ，输入如下命令加载 blockio.ko 驱动模块：

depmod //第一次加载驱动的时候需要运行此命令
modprobe blockio.ko //加载驱动

驱动加载成功以后使用如下命令打开 blockioApp 这个测试 APP，并且以后台模式运行：

./blockioApp /dev/blockio &

按下开发板上的 KEY0 按键

lib/modules/4.1.15 # ./blockioApp /dev/blockio &
/lib/modules/4.1.15 # key value = 0x1
key value = 0x1
key value = 0x1
key value = 0x1
key value = 0x1

3 阻塞 IO 实验

1、驱动程序编写

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/string.h>
#include <linux/irq.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#include <linux/wait.h>
#include <linux/ide.h>
#include <linux/poll.h>


#define IMX6UIRQ_CNT     1
#define IMX6UIRQ_NAME    "noblockio"
#define KEY_NUM            1
#define KEY0VALUE          0X01
#define INVAKEY            0XFF


/* key结构体 */
struct irq_keydesc{
    int gpio;               /* io编号 */
    int irqnum;             /* 中断号 */
    unsigned char value;    /* 键值 */
    char name[10];          /* 名字 */
    irqreturn_t (*handler) (int, void *);  /* 中断处理函数 */
};


/* imx6uirq设备结构体 */
struct imx6uirq_dev{
    dev_t devid;
    int major;
    int minor;
    struct cdev cdev;
    struct class *class;
    struct device *device;
    struct device_node *nd;
    struct irq_keydesc irqkey[KEY_NUM];
    struct timer_list timer; 

    atomic_t keyvalue;
    atomic_t releasekey;

    wait_queue_head_t  r_wait; /* 读等待队列头 */
};

struct imx6uirq_dev imx6uirq; /* irq设备 */

static int imx6uirq_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &imx6uirq;
    return 0;
}


static ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    int ret = 0;
    unsigned char keyvalue;
    unsigned char releasekey;
    struct imx6uirq_dev *dev = filp->private_data;

    if(filp->f_flags & O_NONBLOCK)  {   /* 非阻塞 */
        if(atomic_read(&dev->releasekey) == 0) {
            return -EAGAIN;
        }
    } else                              /* 阻塞 */
    {
        /* 等待事件 */
        wait_event_interruptible(dev->r_wait, atomic_read(&dev->releasekey)); /* 等待按键有效 */
    }
 
    keyvalue = atomic_read(&dev->keyvalue);
    releasekey = atomic_read(&dev->releasekey);

    if(releasekey) {        /* 有效按键 */
        if(keyvalue & 0x80) {
            keyvalue &= ~0x80;
            ret = copy_to_user(buf, &keyvalue, sizeof(keyvalue));
        } else {
            goto data_error;
        }
        atomic_set(&dev->releasekey, 0); /* 按下标志清零 */
    } else {
        goto data_error;
    }

data_error:
    return ret;
}

static unsigned int imx6uirq_poll(struct file *filp, struct poll_table_struct * wait)
{
    int mask  = 0;
    struct imx6uirq_dev *dev = filp->private_data;

    poll_wait(filp, &dev->r_wait, wait);

    /* 是否可读 */
	if (atomic_read(&dev->releasekey)) {  /* 按键按下，可读 */
		mask = POLLIN | POLLRDNORM;  /* 返回POLLIN*/
	}

    return mask;
}

/* 操作集 */
static const struct file_operations imx6uirq_fops = {
    .owner		=	THIS_MODULE,
	.open		=	imx6uirq_open,
    .read       =   imx6uirq_read,
    .poll       =   imx6uirq_poll,
};

/* 按键中断处理函数 */
static irqreturn_t key0_handler(int irq, void *dev_id)
{
    struct imx6uirq_dev *dev = dev_id;

    dev->timer.data = (volatile long)dev_id;
    mod_timer(&dev->timer, jiffies + msecs_to_jiffies(20)); /* 20ms定时 */

	return IRQ_HANDLED;
}

/* 定时器处理函数 */
static void timer_func(unsigned long arg) {
    int value = 0;
    struct imx6uirq_dev *dev = (struct imx6uirq_dev*)arg;

    value = gpio_get_value(dev->irqkey[0].gpio);
    if(value == 0)   {          /* 按下 */
        atomic_set(&dev->keyvalue, dev->irqkey[0].value);
    } else if(value == 1) {     /* 释放 */
        atomic_set(&dev->keyvalue, 0X80 | (dev->irqkey[0].value));
        atomic_set(&dev->releasekey, 1);  /* 完成的按键过程 */
    }

    /* 唤醒进程 */
    if(atomic_read(&dev->releasekey)) {
         wake_up(&dev->r_wait);
    }

}


/* 按键初始化 */
static int keyio_init(struct imx6uirq_dev *dev)
{
    int ret  = 0;
    int i = 0;

    /* 1,按键初始化 */
    dev->nd = of_find_node_by_path("/key");
    if(dev->nd == NULL) {
        ret = -EINVAL;
        goto fail_nd;
    }

    for(i = 0; i < KEY_NUM; i++) {
        dev->irqkey[i].gpio = of_get_named_gpio(dev->nd, "key-gpio", i);
    }
    for(i = 0; i < KEY_NUM; i++) {
        memset(dev->irqkey[i].name, 0, sizeof(dev->irqkey[i].name));
        sprintf(dev->irqkey[i].name, "KEY%d", i);
        gpio_request(dev->irqkey[i].gpio, dev->irqkey[i].name);
        gpio_direction_input(dev->irqkey[i].gpio);

        dev->irqkey[i].irqnum = gpio_to_irq(dev->irqkey[i].gpio); /* 获取中断号 */

    }

    dev->irqkey[0].handler = key0_handler;
    dev->irqkey[0].value  = KEY0VALUE;

    /* 2,按键中断初始化 */
    for(i = 0; i < KEY_NUM; i++) {
        ret = request_irq(dev->irqkey[i].irqnum, dev->irqkey[i].handler, 
                         IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, 
                         dev->irqkey[i].name, &imx6uirq);
        if(ret) {
            printk("irq %d request failed!\r\n", dev->irqkey[i].irqnum);
            goto fail_irq;
        }
    }

    /* 3、初始化定时器 */
    init_timer(&imx6uirq.timer);
    imx6uirq.timer.function = timer_func;
    return 0;

fail_irq:
    for(i = 0; i < KEY_NUM; i++) {
        gpio_free(dev->irqkey[i].gpio);
    }
fail_nd:
    return ret;
}

/* 驱动入口函数 */
static int __init imx6uirq_init(void)
{

    int ret = 0;

    /* 注册字符设备驱动 */
    imx6uirq.major = 0;
    if(imx6uirq.major) { /* 给定主设备号 */
        imx6uirq.devid = MKDEV(imx6uirq.major, 0);
        ret = register_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT, IMX6UIRQ_NAME);
    } else {            /* 没给定设备号 */
        ret = alloc_chrdev_region(&imx6uirq.devid, 0, IMX6UIRQ_CNT, IMX6UIRQ_NAME);
        imx6uirq.major = MAJOR(imx6uirq.devid);
        imx6uirq.minor = MINOR(imx6uirq.devid);
    }
    if(ret < 0) {
        goto fail_devid;
    }
    printk("imx6uirq major = %d, minor = %d\r\n", imx6uirq.major, imx6uirq.minor);

    /* 2,初始化cdev */
    imx6uirq.cdev.owner = THIS_MODULE;
    cdev_init(&imx6uirq.cdev, &imx6uirq_fops);

    /* 3,添加cdev */
    ret = cdev_add(&imx6uirq.cdev, imx6uirq.devid, IMX6UIRQ_CNT);
    if (ret)
		goto fail_cdevadd;

    /* 4、创建类 */
    imx6uirq.class = class_create(THIS_MODULE, IMX6UIRQ_NAME);
    if(IS_ERR(imx6uirq.class)) {
        ret = PTR_ERR(imx6uirq.class);
        goto fail_class;
    }

    /* 5,创建设备  */
    imx6uirq.device = device_create(imx6uirq.class, NULL, imx6uirq.devid, NULL, IMX6UIRQ_NAME);
    if(IS_ERR(imx6uirq.device)) {
        ret = PTR_ERR(imx6uirq.device);
        goto fail_device;
    }

    /* 初始化IO */
    ret = keyio_init(&imx6uirq);
    if(ret < 0) {
        goto fail_keyinit;
    }


    /* 初始化原子变量 */
    atomic_set(&imx6uirq.keyvalue, INVAKEY);
    atomic_set(&imx6uirq.releasekey, 0);

    /* 等待队列头 */
    init_waitqueue_head(&imx6uirq.r_wait);
    return 0;

fail_keyinit:
fail_device:
    class_destroy(imx6uirq.class);
fail_class:
    cdev_del(&imx6uirq.cdev);
fail_cdevadd:
    unregister_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT);
fail_devid:
    return ret;

}

/* 驱动出口函数 */
static void __exit imx6uirq_exit(void)
{
    int i = 0;
    /*1、释放中断 */
    for(i = 0; i < KEY_NUM; i++) {
        free_irq(imx6uirq.irqkey[i].irqnum, &imx6uirq);
    }
    /* 2,释放IO */
    for(i = 0; i < KEY_NUM; i++) {
        gpio_free(imx6uirq.irqkey[i].gpio);
    }

    /* 3,删除定时器 */
    del_timer_sync(&imx6uirq.timer);

    /* 注销字符设备驱动 */
    cdev_del(&imx6uirq.cdev);
    unregister_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT);

    device_destroy(imx6uirq.class, imx6uirq.devid);
    class_destroy(imx6uirq.class);

}

module_init(imx6uirq_init);
module_exit(imx6uirq_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("kaka");

2、编写测试 APP

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <poll.h>

/*
 *argc:应用程序参数个数
 *argv[]:具体的参数内容，字符串形式 
 *./imx6uirqAPP  <filename>  
 * ./imx6uirqAPP /dev/mx6uirq
 */


int main(int argc, char *argv[])
{
    //fd_set readfds;

    struct pollfd fds;

    int fd, ret;
    char *filename;
    unsigned char data;

    if(argc != 2) {
        printf("Error Usage!\r\n");
        return -1;
    }

    filename = argv[1];

    fd = open(filename, O_RDWR | O_NONBLOCK);   /* 非阻塞打开 */
    if(fd < 0) {
        printf("file %s open failed!\r\n", filename);
        return -1;
    }

#if 0
    /* 循环读取 */
    while(1) {
        FD_ZERO(&readfds);
        FD_SET(fd, &readfds);

        timeout.tv_sec = 1;
        timeout.tv_usec = 0; /* 1S */

        ret = select(fd + 1, &readfds, NULL, NULL, &timeout);
        switch(ret) {
            case 0: /* 超时 */
                printf("select timeout!\r\n");
                break;
            case -1: /* 错误 */
                break;
            default: /* 可以读取数据 */
                if(FD_ISSET(fd, &readfds)) {
                    ret = read(fd, &data, sizeof(data));
                    if(ret < 0) {

                    } else {
                    if(data)
                        printf("key value = %#x\r\n", data);
                    }
                }
            break;
        }
    }
#endif

    /* 循环读取 */
    while(1) {

        fds.fd = fd;
        fds.events = POLLIN;

        ret = poll(&fds, 1, 500); /* 超时500ms */
        if(ret == 0)  {     /* 超时 */

        } else if( ret < 0) { /* 错误 */

        } else {            /* 可以读取 */
            if(fds.revents | POLLIN) {  /* 可读取 */
                ret = read(fd, &data, sizeof(data));
                if(ret < 0) {

                 } else {
                if(data)
                     printf("key value = %#x\r\n", data);
                 }
            }
        }
    }

    close(fd);

    return 0;
}

3、编译驱动程序和测试 APP

①、编译驱动程序

KERNELDIR := /home/kaka/linux/IMX6ULL/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek
CURRENT_PATH := $(shell pwd)

obj-m := noblockio.o 

build: kernel_modules

kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

输入如下命令编译出驱动模块文件：

make -j32

编译成功以后就会生成一个名为“noblockio.ko ”的驱动模块文件。

②、编译测试 APP

arm-linux-gnueabihf-gcc noblockioApp.c -o noblockioApp

4、运行测试

将编译出来的blockio.ko 和 blockioApp 这两个文件拷贝到rootfs/lib/modules/4.1.15目录中 ，输入如下命令加载noblockio.ko 驱动模块：

depmod //第一次加载驱动的时候需要运行此命令
modprobe noblockio.ko //加载驱动

驱动加载成功以后使用如下命令打开noblockioApp 这个测试 APP，并且以后台模式运行：

./noblockioApp /dev/noblockio &

按下开发板上的 KEY0 按键

lib/modules/4.1.15 # ./noblockioApp /dev/noblockio &
/lib/modules/4.1.15 # key value = 0x1
key value = 0x1
key value = 0x1
key value = 0x1
key value = 0x1

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/486266.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

elform 动态 rules

elform 动态 rules

一.使用v-for渲染时 前端由于某些需求场景需要&#xff0c;部分表单的渲染是通过 v-for循环渲染显示&#xff0c;此时如何实现表单验证呢&#xff1f;如下&#xff0c;点击第一行的号可以动态的增加更多行表单&#xff0c;不同于单一固定的表单行[参见下文一般情况下]&#xf…
阅读更多...
book-riscv-rev1.pdf 翻译（自用）第一章 操作系统接口

book-riscv-rev1.pdf 翻译（自用）第一章 操作系统接口

Job of operating system: 操作系统使得多个程序分享一台计算机&#xff0c;提供一系列仅靠硬件无法支持的服务。 管理与抽象低级别硬件&#xff08;如&#xff1a;文件处理程序不需要关注使用哪种硬盘&#xff09;使得多个程序分享硬件&#xff08;programs that can run at…
阅读更多...
【代码练习】旋转矩阵题解思路记录分析

【代码练习】旋转矩阵题解思路记录分析

题目 给你一幅由 N N 矩阵表示的图像&#xff0c;其中每个像素的大小为 4 字节。请你设计一种算法&#xff0c;将图像旋转 90 度。 不占用额外内存空间能否做到&#xff1f; 示例 1: 给定 matrix [ [1,2,3], [4,5,6], [7,8,9] ], 原地旋转输入矩阵&#xff0c;使其变为: [ [7…
阅读更多...
【C语言】学习

【C语言】学习

文章目录 前言1. warm up1.1 输出helloworld1.2 示例1.3 C语言程序结构 前言 以后要学习操作系统深度学习了&#xff0c;所以C语言就不可缺少了。 1. warm up 1.1 输出helloworld #include<stdio.h> void main() {printf("Hello World!!"); }std 标准 io输…
阅读更多...
JS案例分析-某国际音x-tt-params参数分析

JS案例分析-某国际音x-tt-params参数分析

今天我们要分析的网站是&#xff1a;https://www.tiktok.com/selenagomez?langen&#xff0c;参数名字叫x-tt-params。 先来抓个包 这个接口是用户视频列表url&#xff0c;参数叫x-tt-params&#xff0c;该接口中还有其他参数像msToken&#xff0c;X-Bogus&#xff0c; _sig…
阅读更多...
Cartesi 2023 年 4 月回顾

Cartesi 2023 年 4 月回顾

查看你不想错过的更新 2023年5月1日&#xff0c;感谢Cartesi生态系统中所有了不起的构建者&#xff01; 在一个激动人心的旅程之后&#xff0c;我们的首届全球线上黑客马拉松正式结束了&#xff01;有超过200名注册建造者参加&#xff0c;见证了所有参与者展示的巨大才华和奉献…
阅读更多...
【Android】串口通信的理论与使用教程

【Android】串口通信的理论与使用教程

Android系统诞生这十几年以来&#xff0c;Android开发工程师岗位经历了由盛转衰的过程&#xff0c;目前纯UI的Android APP已经鲜有公司愿意花费巨资去开发&#xff0c;Android APP开发的业务也仅剩游戏、物联网&#xff08;Internet of Things&#xff0c;简称IoT&#xff09;等…
阅读更多...
springcloud：新一代分布式定时任务框架——PowerJob

springcloud：新一代分布式定时任务框架——PowerJob

0. 引言 之前我们讲解过主流的分布式定时任务框架xxl-job&#xff0c;随着技术的迭代更新&#xff0c;更多的定时任务框架也开始出现&#xff0c;今天我们来看一看新一代的定时任务框架PowerJob 1. PowerJob简介 PowerJob是基于java开发的企业级的分布式任务调度平台&#x…
阅读更多...
Java设计原则之单一职责原则、开闭原则、里氏代换原则

Java设计原则之单一职责原则、开闭原则、里氏代换原则

文章目录 面向对象设计原则概述 单一职责原则 开闭原则 里氏代换原则 面向对象设计原则概述 软件的可维护性&#xff08;Maintainability&#xff09;和可复用性&#xff08;Reusability&#xff09;是两个非常重要的用于衡量软件质量的属性&#xff0c;软件的可维护性是指软…
阅读更多...
Ubuntu常用命令总结

Ubuntu常用命令总结

目录 1&#xff09;安装包命令及下载包命令 2&#xff09;阅读协议内容 3&#xff09;执行sh文件&#xff1a; 4&#xff09;创建虚拟环境 5&#xff09;激活虚拟环境 6&#xff09;虚拟环境中安装包 7&#xff09;安装上传代码工具 8&#xff09;代码上传 9&#xff09…
阅读更多...
传输控制协议（TCP)知识点总结

传输控制协议（TCP)知识点总结

文章目录 传输控制协议&#xff08;TCP)知识点总结介绍数据包格式TCP连接的建立和关闭三次握手四次挥手一张图展示这些过程 其他知识 传输控制协议&#xff08;TCP)知识点总结 维基百科: 传输控制协议&#xff08;TCP&#xff09;是Internet协议套件中的主要协议之一。它起源于…
阅读更多...
五种最危险的新兴网络攻击技术

五种最危险的新兴网络攻击技术

SANS研究所的网络专家揭示了包括网络罪犯和民族国家行为者在内的网络攻击者正在使用的五种最危险的新兴网络攻击技术。在旧金山举行的RSA网络安全会议上&#xff0c;由SANS研究所的几位分析师组成的讨论组讨论了新兴的网络攻击战术、技术和程序&#xff0c;并提供了如何为企业做…
阅读更多...
使用GLSL来实现实时滤镜的效果

使用GLSL来实现实时滤镜的效果

1. 先来明确几个概念 1.1 OpenGL OpenGL 全称为 Open Graphics Library&#xff08;开放图形库&#xff09;。 是用于渲染 2D 或 3D 图像的跨语言跨平台的应用程序编程接口&#xff0c;用于CPU控制GPU做图像渲染&#xff0c;是一套API。 提供设计人员一个共同的硬件驱动标准…
阅读更多...
虚函数、静态绑定和动态绑定

虚函数、静态绑定和动态绑定

静态绑定 class Base { public:Base(int data) :ma(data) {}void show() { cout << "Base::show()" << endl; }void show(int) { cout << "Base::show(int)" << endl; }protected:int ma; };class Derive : public Base { public…
阅读更多...
Go | 一分钟掌握Go | 10 - 反射

Go | 一分钟掌握Go | 10 - 反射

作者&#xff1a;Mars酱 声明&#xff1a;本文章由Mars酱编写&#xff0c;部分内容来源于网络&#xff0c;如有疑问请联系本人。 转载&#xff1a;欢迎转载&#xff0c;转载前先请联系我&#xff01; 前言 反射你以为只在Java中有吗&#xff1f;Go也有反射机制&#xff0c;很多…
阅读更多...
【JavaEE】应用层自定义协议及UDP协议

【JavaEE】应用层自定义协议及UDP协议

博主简介&#xff1a;想进大厂的打工人博主主页&#xff1a;xyk:所属专栏: JavaEE初阶 本篇文章将为大家介绍应用层中UDP协议~~ 在应用层这里&#xff0c;虽然存在一些现有的协议&#xff08;HTTP&#xff09;&#xff0c;但是也有很多情况&#xff0c;需要程序猿自定制协议&a…
阅读更多...
OJ 功能介绍 使用手册

OJ 功能介绍 使用手册

目录 服务器配置 OJ界面展示 用户管理 一、批量导入&#xff08;从方便管理角度建议以 学生姓名 作为 用户名 &#xff09; 二、批量生成临时用户 后期修改成需要的用户名和密码 &#xff08;学生登录后修改密码&#xff09; 三、用户自行注册&#xff08;填写邮箱获取验证码…
阅读更多...
Nmap入门到高级【第九章】

Nmap入门到高级【第九章】

预计更新Nmap基础知识 1.1 Nmap简介和历史 1.2 Nmap安装和使用方法 1.3 Nmap扫描技术和扫描选项 Nmap扫描技术 2.1 端口扫描技术 2.2 操作系统检测技术 2.3 服务和应用程序检测技术 2.4 漏洞检测技术 Nmap扫描选项 3.1 扫描类型选项 3.2 过滤器选项 3.3 探测选项 3.4 输出选项…
阅读更多...
【致敬未来的攻城狮计划】— 连续打卡第二十天：RA2E1_UART —— 串口通信例程

【致敬未来的攻城狮计划】— 连续打卡第二十天：RA2E1_UART —— 串口通信例程

系列文章目录 1.连续打卡第一天&#xff1a;提前对CPK_RA2E1是瑞萨RA系列开发板的初体验&#xff0c;了解一下 2.开发环境的选择和调试&#xff08;从零开始&#xff0c;加油&#xff09; 3.欲速则不达&#xff0c;今天是对RA2E1 基础知识的补充学习。 4.e2 studio 使用教程 5.…
阅读更多...
Docker consul服务注册与发现

Docker consul服务注册与发现

目录 一、服务注册与发现 1、什么是服务注册与发现 2、什么是consul 3、consul提供的一些关键特性 4、容器更新与发现 二、基于nginx与consul构建自动发现即高可用的Docker服务架构 consul服务器部署 1、建立consul 2、查看集群信息 3、通过http获取集群信息 regist…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023