一、linux驱动开发-7.3-异步通知实验

最新推荐文章于 2023-11-28 11:37:22 发布
最新推荐文章于 2023-11-28 11:37:22 发布
阅读量504 收藏 1
点赞数
分类专栏： 嵌入式 linux驱动 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rrring/article/details/121619857
版权

一、前言

       前面无论是使用阻塞还是非阻塞的方式读取按键值，都是主动去读取的，最好的方式就是驱动程序能主动向应用程序发出通知，报告自己可以访问，然后应用程序再从驱动程序中读取或写入数据。

二、异步通知

2.1、简介

       异步通知的核心就是信号，信号类似于我们硬件上使用的“中断”，只不过信号是软件层次上的。算是在软件层次上对中断的一种模拟，驱动可以通过主动向应用程序发送信号的方式来报告自己可以访问了，应用程序获取到信号以后就可以从驱动设备中读取或者写入数据了。整个过程就相当于应用程序收到了驱动发送过来了的一个中断，然后应用程序去响应这个中断，在整个处理过程中应用程序并没有去查询驱动设备是否可以访问，一切都是由驱动设备自己告诉给应用程序的。linux定义的所有信号如下：

#define SIGHUP 1 /* 终端挂起或控制进程终止 */
#define SIGINT 2 /* 终端中断(Ctrl+C 组合键) */
#define SIGQUIT 3 /* 终端退出(Ctrl+\组合键) */
#define SIGILL 4 /* 非法指令 */
#define SIGTRAP 5 /* debug 使用，有断点指令产生  */
#define SIGABRT 6 /* 由 abort(3)发出的退出指令 */
#define SIGIOT 6 /* IOT 指令 */
#define SIGBUS 7 /* 总线错误 */
#define SIGFPE 8 /* 浮点运算错误 */
#define SIGKILL 9 /* 杀死、终止进程 */
#define SIGUSR1 10 /* 用户自定义信号 1 */
#define SIGSEGV 11 /* 段违例(无效的内存段) */
#define SIGUSR2 12 /* 用户自定义信号 2 */
#define SIGPIPE 13 /* 向非读管道写入数据 */
#define SIGALRM 14 /* 闹钟 */
#define SIGTERM 15 /* 软件终止 */
#define SIGSTKFLT 16 /* 栈异常 */
#define SIGCHLD 17 /* 子进程结束 */
#define SIGCONT 18 /* 进程继续 */
#define SIGSTOP 19 /* 停止进程的执行，只是暂停
#define SIGTSTP 20 /* 停止进程的运行(Ctrl+Z 组合键) */
#define SIGTTIN 21 /* 后台进程需要从终端读取数据  */
#define SIGTTOU 22 /* 后台进程需要向终端写数据 */
#define SIGURG 23 /* 有"紧急"数据 */
#define SIGXCPU 24 /* 超过 CPU 资源限制 */
#define SIGXFSZ 25 /* 文件大小超额 */
#define SIGVTALRM 26 /* 虚拟时钟信号 */
#define SIGPROF 27 /* 时钟信号描述 */
#define SIGWINCH 28 /* 窗口大小改变 */
#define SIGIO 29 /* 可以进行输入/输出操作 */
#define SIGPOLL SIGIO
/* #define SIGLOS 29 */
#define SIGPWR 30 /* 断点重启 */
#define SIGSYS 31 /* 非法的系统调用 */
#define SIGUNUSED 31 /* 未使用信号 */

       这些信号就相当于中断号，不同的中断号代表了不同的中断，不同的中断所做的处理不同，因此，驱动程序可以通过向应用程序发送不同的信号来实现不同的功能。如果要在应用程序中使用信号，那么就必须设置信号所使用的信号处理函数，在应用程序中使用 signal 函数来设置指定信号的处理函数：

/*
@
@signum：要设置处理函数的信号
@handler：信号的处理函数
@return：设置成功的话返回信号的前一个处理函数，设置失败的话返回SIG_ERR
*/
sighandler_t signal(int signum, sighandler_t handler)

       信号处理函数的原型如下：

typedef void (*sighandler_t)(int)

2.2、驱动中的信号处理

2.2.1、fasync_struct结构体

       在驱动中定义一个fasync_struct结构体指针变量，一般定义在设备结构体重，如下：

struct fasync_struct {
    spinlock_t fa_lock;
    int magic;
    int fa_fd;
    struct fasync_struct *fa_next;
    struct file *fa_file;
    struct rcu_head fa_rcu;
};

struct xxx_dev{
    struct device *dev;
    
    struct fasync_struct *async_queue;    //定义异步相关结构体
}

2.2.2、fasync函数

       如果要使用异步通知，需要在设备驱动中实现 file_operations 操作集中的 fasync 函数，此函数格式如下所示：

int (*fasync) (int fd, struct file *filp, int on)

       fasync 函数里面一般通过调用 fasync_helper 函数来初始化前面定义的fasync_struct 结构体指针，fasync_helper 函数原型如下

int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)

       当应用程序通过“fcntl(fd, F_SETFL, flags | FASYNC)”改变fasync 标记的时候，驱动程序 file_operations 操作集中的 fasync 函数就会执行。

示例如下：

struct xxx_dev {
    struct fasync_struct *async_queue; /* 异步相关结构体 */
};

static int xxx_fasync(int fd, struct file *filp, int on)
{
    struct xxx_dev *dev = (xxx_dev)filp->private_data;

    if (fasync_helper(fd, filp, on, &dev->async_queue) < 0)
        return -EIO;
    return 0;
}

static struct file_operations xxx_ops = {
    .fasync = xxx_fasync,
};

       在关闭驱动文件的时候需要在 file_operations 操作集中的 release 函数中释放fasync_struct，fasync_struct 的释放函数同样为 fasync_helper。

static int xxx_release(struct inode *inode, struct file *filp)
{
    return xxx_fasync(-1, filp, 0); /*  删除异步通知 */
}

static struct file_operations xxx_ops = {
    .release = xxx_release,
};

2.2.3、kill_fasync函数

       当设备可以访问的时候，驱动程序需要向应用程序发出信号，相当于产生“中断”。kill_fasync函数负责发送指定的信号，kill_fasync 函数原型如下所示：

/*
@fp：要操作的fasync_struct
@sig：要发送的信号
@band：可读时设置为POLL_IN，可写时设置为POLL_OUT
*/
void kill_fasync(struct fasync_struct **fp, int sig, int band)

2.3、应用程序对异步通知的处理

        包括以下三步：

2.3.1、注册信号处理函数

       应用程序根据驱动程序所使用的信号来设置信号的处理函数，应用程序使用 signal 函数来设置信号的处理函数。

2.3.2、将本应用程序的进程号告诉内核

       使用 fcntl(fd, F_SETOWN, getpid())将本应用程序的进程号告诉给内核

2.3.3、开启异步通知

       使用如下两行程序开启异步通知：

flags = fcntl(fd, F_GETFL); /* 获取当前的进程状态  */
fcntl(fd, F_SETFL, flags | FASYNC); /* 开启当前进程异步通知功能 */

       重点就是通过 fcntl 函数设置进程状态为 FASYNC，经过这一步，驱动程序中的 fasync 函数就会执行。

三、实验程序

3.1、驱动程序

#include <linux/types.h>

#include <linux/kernel.h>

#include <linux/delay.h>

#include <linux/ide.h>

#include <linux/init.h>

#include <linux/module.h>

#include <linux/errno.h>

#include <linux/gpio.h>

#include <linux/cdev.h>

#include <linux/device.h>

#include <linux/of.h>

#include <linux/of_address.h>

#include <linux/of_gpio.h>

#include <linux/semaphore.h>

#include <linux/timer.h>

#include <linux/of_irq.h>

#include <linux/irq.h>

#include <asm/mach/map.h>

#include <asm/uaccess.h>

#include <asm/io.h>

#include <linux/string.h>

#include <linux/wait.h>

#include <linux/poll.h>

#include <linux/fcntl.h>



#define IMX6UIRQ_CNT     	1     

#define IMX6UIRQ_NAME    	"asyncnoti"

#define KEY0VALUE			0X01

#define INVAKEY				0xFF 

#define KEY_NUM				1



struct irq_keydesc{

	int gpio;				//gpio编号

	unsigned int irqnum;	//中断号

	irqreturn_t (*irq_handler)(int, void*);		//中断处理函数

};



//设备结构体

struct imx6uirq_dev{

	dev_t devid;

	struct cdev cdev;

	struct class *class;

	struct device *device;

	int major;

	int minor;

	struct device_node *nd;		//设备节点

	atomic_t keyvalue;			//有效的按键值

	atomic_t releasekey;		//标记是否完成一次完整的按键

	struct timer_list timer;	//定时器

	struct irq_keydesc irq_keydesc[KEY_NUM];	//按键描述数组



	wait_queue_head_t r_wait;	//等待队列项头



	struct fasync_struct *async_queue;	//异步相关结构体

};



struct imx6uirq_dev imx6uirq;  



static int imx6uirq_open(struct inode *inode, struct file *file)

{

	file->private_data = &imx6uirq;

	return 0;

}



ssize_t imx6uirq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)

{

	unsigned char keyvalue = 0;

	unsigned char releasekey = 0;

	struct imx6uirq_dev *dev = file->private_data;



	int ret = 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 wait_error;

		}



		__set_current_state(TASK_RUNNING); /* 设置为运行状态 */

		//按键按下了，将等待队列项从等待队列头移除

		remove_wait_queue(&dev->r_wait, &wait);

	}



	keyvalue = atomic_read(&dev->keyvalue);

	releasekey = atomic_read(&dev->releasekey);

	

	if (releasekey)

	{

		copy_to_user(buf, &keyvalue, sizeof(keyvalue));

		atomic_set(&dev->releasekey, 0);	//清除按下标志位

	}

	else

	{

		return -EINVAL;

	}

	

	return 0;



wait_error:

	set_current_state(TASK_RUNNING); /*  设置任务为运行态 */

	remove_wait_queue(&dev->r_wait, &wait); /*  将等待队列移除 */

	return ret;

}



static imx6uirq_poll(struct file *filp, struct poll_table_struct *wait)

{

	unsigned char keyvalue = 0;

	unsigned char releasekey = 0;

	struct imx6uirq_dev *dev = filp->private_data;



	int ret = 0;



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



	if (atomic_read(&dev->releasekey) == 1)		//按键按下

	{

		ret = POLLIN | POLLRDNORM;

	}



	return ret;

}



static int imx6uirq_fasync(int fd, struct file *filp, int on)

{

	struct imx6uirq_dev *dev = filp->private_data;



	//初始化异步通知结构体

	if (fasync_helper(fd, filp, on, &dev->async_queue) < 0)

		return -EIO;



	return 0;

}



static int imx6uirq_release(struct inode *inode, struct file *filp)

{

	//删除异步通知

	return imx6uirq_fasync(-1, filp, 0);

}



static const struct file_operations imx6uirq_fops = {

	.owner = THIS_MODULE,

	.open  = imx6uirq_open,

	.read  = imx6uirq_read,

	.poll  = imx6uirq_poll,

	.fasync = imx6uirq_fasync,

	.release = imx6uirq_release,

};



//定时器回调函数

static void timer_function(unsigned long arg)

{

	int value;

	struct irq_keydesc *keydesc;

	struct imx6uirq_dev *dev = (struct imx6uirq_dev *)arg;

	keydesc = &dev->irq_keydesc[0];



	value = gpio_get_value(keydesc->gpio);

	if (value == 0)

		atomic_set(&dev->keyvalue, value);

	else {

		atomic_set(&dev->keyvalue, value);

		atomic_set(&dev->releasekey, 1);	//标记按键松开

	}



	if (atomic_read(&dev->releasekey))

	{

		kill_fasync(&dev->async_queue, SIGIO, POLL_IN);

	}



#if 0

	if (atomic_read(&dev->releasekey))

	{

		//按键按下，唤醒等待队列项中的进程

		wake_up_interruptible(&dev->r_wait);

	}

#endif

}



static irqreturn_t key0_irq_handler(int irq, void *dev_id)

{

	int value;

	struct imx6uirq_dev *dev = (struct imx6uirq_dev *)dev_id;



	dev->timer.data = (volatile long)dev_id;

	//启动定时器

	mod_timer(&dev->timer, jiffies + msecs_to_jiffies(10));



	return IRQ_HANDLED;

}



static int key_io_init(void)

{

	int ret;



	//通过节点名字查找节点

	imx6uirq.nd = of_find_node_by_name(NULL, "gpiokey");

	if (imx6uirq.nd == NULL)

	{

		printk("find %s fail\r\n", "gpiokey");

		return -EINVAL;

	}



	//通过节点获取GPIO编号

	imx6uirq.irq_keydesc[0].gpio = of_get_named_gpio(imx6uirq.nd, "key-gpio", 0);

	if (imx6uirq.irq_keydesc[0].gpio < 0)

	{

		printk("get %s fail\r\n", "key-gpio");

		return -EINVAL;

	}

	//初始化key-gpio

	ret = gpio_request(imx6uirq.irq_keydesc[0].gpio, "gpio_irq");

	if (ret != 0)

	{

		printk("request %s fail\r\n", "gpio_irq");

		return -EINVAL;

	}

	ret = gpio_direction_input(imx6uirq.irq_keydesc[0].gpio);

	if (ret < 0)

	{

		printk("set key status fail\r\n");

		return -EINVAL;

	}



	//通过节点获取中断号

	imx6uirq.irq_keydesc[0].irqnum = irq_of_parse_and_map(imx6uirq.nd, 0);

#if 0

	//通过GPIO编号获取中断号

	imx6uirq.irq_keydesc[0].irqnum = gpio_to_irq(imx6uirq.irq_keydesc[0].gpio);

#endif

	//设置中断处理函数

	imx6uirq.irq_keydesc[0].irq_handler = key0_irq_handler;

		

	//通过中断号申请中断

	ret = request_irq(imx6uirq.irq_keydesc[0].irqnum,	

				imx6uirq.irq_keydesc[0].irq_handler,

				IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING,

				IMX6UIRQ_NAME,

				&imx6uirq);	

	if (ret < 0)

	{

		printk("request irq fail\r\n");

		return -EINVAL;

	}



	//初始化定时器

	init_timer(&imx6uirq.timer);

	imx6uirq.timer.function = timer_function;

}



static int __init imx6uirq_init(void)

{

	int ret = 0;

	int val = 0;	



	//初始化等待队列头

	init_waitqueue_head(&imx6uirq.r_wait);



	//分配设备号

	if ( imx6uirq.major) {

		 imx6uirq.devid = MKDEV( imx6uirq.major, 0);

		register_chrdev_region( imx6uirq.devid,  IMX6UIRQ_CNT,  IMX6UIRQ_NAME);

	} else {

		alloc_chrdev_region(&imx6uirq.devid, 0,  IMX6UIRQ_CNT,  IMX6UIRQ_NAME);

		 imx6uirq.major = MAJOR(imx6uirq.devid);

		 imx6uirq.minor = MINOR(imx6uirq.devid);

	}



	//初始化cdev

	imx6uirq.cdev.owner = THIS_MODULE;

	cdev_init(&imx6uirq.cdev, &imx6uirq_fops);

	//添加cdev

	cdev_add(&imx6uirq.cdev, imx6uirq.devid,  IMX6UIRQ_CNT);

	//创建类

	imx6uirq.class = class_create(THIS_MODULE,  IMX6UIRQ_NAME);

	//创建设备

	imx6uirq.device = device_create(imx6uirq.class, NULL, imx6uirq.devid, NULL,  IMX6UIRQ_NAME);



	//按键gpio初始化

	key_io_init();

	

	return 0;

}



static void __exit imx6uirq_exit(void)

{

	//删除定时器

	del_timer_sync(&imx6uirq.timer);

	//释放中断

	free_irq(imx6uirq.irq_keydesc[0].irqnum, &imx6uirq);



	gpio_free(imx6uirq.irq_keydesc[0].gpio);



	//删除设备

	cdev_del(&imx6uirq.cdev);

	//注销设备号

	unregister_chrdev_region(imx6uirq.devid,  IMX6UIRQ_CNT);

	//删除设备的类

	device_destroy(imx6uirq.class,  imx6uirq.devid);

	//删除类

	class_destroy(imx6uirq.class);

		

	printk(" dev exit\n");

}



module_init( imx6uirq_init);

module_exit( imx6uirq_exit);



MODULE_LICENSE("GPL");

MODULE_AUTHOR("ZK");

3.2、应用程序

#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 "signal.h"

#define CLOSE_CMD		1
#define OPEN_CMD		2
#define SETPERIOD_CMD	3

static int fd = 0;

void sigio_handler(int num)
{
    int ret;
    unsigned int keyvalue = 0;
    ret = read(fd, &keyvalue, sizeof(keyvalue));
    if (ret < 0)
    {
        printf("read err\r\n");
    }
    else
    {
        printf("get signal, keyvalue is %d\r\n", keyvalue);
    }
    
}

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

    if (argc != 2)
    {
        printf("Usage:\n");
        printf("\n");
        return -1;
    }
    filename = argv[1];
    fd = open(filename, O_RDWR);  
    if (fd < 0)
    {
        printf("open file %s fail\n", filename);
        return -1;
    }

    //注册信号处理函数
    signal(SIGIO, sigio_handler);
    //将本应用程序的进程号告诉给内核
    fcntl(fd, F_SETOWN, getpid());
    //开启异步通知
    flags = fcntl(fd, F_GETFL);
    fcntl(fd, F_SETFL, flags|FASYNC);

    while (1)
    {
        sleep(1);
    }

    close(fd);
    return ret;
}

rrring
关注
专栏目录
驱动开发面试复习
qq_24093081的博客
03-03 1184
多个程序同时访问一个共享资源产生的问题就叫做竞争。竞争产生的根本原因就是 Linux 系统的并发访问竞争产生的原因如下所示：（1）多线程的并发访问（2）中断程序的并发访问（3）抢占式并发访问所谓并发，就是通过算法将 CPU 资源合理地分配给多个任务，当一个任务执行 I/O 操作时，CPU 可以转而执行其它的任务，等到 I/O 操作完成以后，或者新的任务遇到 I/O 操作时，CPU 再回到原来的任务继续执行。
linux 异步通知实例
c4679281314的博客
04-19 218
//////////////////////////////////////////////////////////////////////////////// linux驱动的异步通知(kill_fasync,fasync) ---- 驱动程序向应用程序发送信号 //////////////////////////////////////////////////////////////////////////////// /////////////////////////////////.
Linux设备驱动--异步通知
欲盖弥彰1314
03-24 1667
Linux的异步通知是使用信号实现的。 信号：是在软甲层上对中断机制的一种模拟。设备就绪，驱动会主动通知应用程序 Linux中的信号： —— 《linux设备驱动开发详解》 异步通知相关数据结构 struct fasync_struct { spinlock_t fa_lock; int magic; int fa_fd; struct fasync_struct *fa_next;
字符设备驱动程序之异步通知
weixin_43772611的博客
12-05 631
文章目录前言一、过程二、代码1.key_drv.c2.测试程序结果 前言 应用程序主动去read ①查询：耗资源 ②：中断：read()一直在读，不会退出 ③：poll机制：指定起始时间 本驱动程序是再改进一下，驱动程序 提醒 应用 目标：按下按键时：驱动程序通知应用 一、过程 ①应用程序：注册信号处理函数 ②谁发：驱动程序 ③发给谁：->app ->app要告诉给驱动PID号 ④怎么发？ kill_fasync 二、代码 1.key_drv.c 代码如下（示例）： #include ..
自旋锁实验
weixin_44708624的博客
01-06 104
1.驱动代码 #include <linux/types.h> #include <linux/module.h> #include <linux/kernel.h> #include <linux/delay.h> #include <linux/init.h> #include <linux/fs.h> #include...
Linux 内核定时器实验
m0_51144400的博客
03-18 209
本实验通过应用程序设置定时器的周期，将LED进行周期性的亮灭。
java linux 设备驱动_《Linux设备驱动开发详解：基于最新的Linux4.0内核
weixin_31517893的博客
02-13 274
图书目录：赞誉推荐序一推荐序二前言第1章 Linux设备驱动概述及开发环境构建1.1 设备驱动的作用1.2 无操作系统时的设备驱动1.3 有操作系统时的设备驱动1.4 Linux设备驱动1.4.1 设备的分类及特点1.4.2 Linux设备驱动与整个软硬件系统的关系1.4.3 Linux设备驱动的重点、难点1.5 Linux设备驱动的开发环境构建1.5.1 PC上的Linux环境1.5.2 QEM...
docker-compose搭建php7.4(swoole+swoole-loader+dg)+mysql5.7环境
最新发布
04-27
Docker是一种开源的应用容器引擎，它允许开发者打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的Linux或Windows机器上，也可以实现虚拟化。Docker容器完全隔离，互不影响，同时又可以共享主机...
最简单的字符设备框架（需要功能可以添加）
qq_43737424的博客
07-27 192
/* * 代码框架： * 此版本下没有各步骤的出错处理，不规范。 * char_dev_led.c */ #include <linux/types.h> #include <linux/kernel.h> #include <linux/delay.h> #include <linux/ide.h> #include <linux/init.h> #include <linux/module.h> #include <l.
嵌入式系统原理与应用 第六章 字符设备
goal_achieving的博客
11-28 67
include/linux/fs.h 中有个叫做 file_operations。驱动中最基本的一类设备驱动，字符设备就是一个一个字节，按照字节流。，LCD等等都是字符设备，这些设备的驱动就叫做字符设备驱动。进行读写操作的设备，读写数据是分先后顺序的。
嵌入式Linux开发26——Linux 中断（万字总结）
贾贾的博客
09-07 4786
文章目录Linux中断简介：1. Linux 中断 API 函数1.1 中断号1.2 request_irq 函数1.3 free_irq 函数1.4 中断处理函数1.5 中断使能与禁止函数2.上半部与下半部2.1 软中断   不管是裸机实验还是 Linux 下的驱动实验，中断都是频繁使用的功能，在裸机中使用中断我们需要做一大堆的工作，比如配置寄存器，使能 IRQ 等等。 Linux 内核提供了完善的中断框架，我们只需要申请中断，然后注册中断处理函数即可，使用非常方便，不需要一系列复杂的寄存器配置。 Li
内核定时器
weixin_44708624的博客
01-07 256
1.驱动代码 #include <linux/types.h> #include <linux/module.h> #include <linux/kernel.h> #include <linux/delay.h> #include <linux/init.h> #include <linux/fs.h> #include...
Linux 块设备驱动实验
m0_51144400的博客
05-03 427
本实验利用内存模拟出2MB大小的存储空间，利用块设备驱动程序对该存储空间进行读写操作。
一、linux驱动开发-7.2-阻塞IO实验
rrring的博客
11-21 394
一、前言 上一节在应用程序中通过read不断读取按键状态，这样就会占用很高的CPU使用率，用top指令查看下： 现在换种方法，当按键没被按下的时候休眠，当有按键事件发生的时候才运行，并打印按键值，这样就可以降低CPU利用率。 ...
[学习分享]嵌入式linux字符驱动详解（四）设备树及设备树下驱动的编写
weymin
05-04 667
Linux从3.x版本开始支持设备树，关于设备树的由来以及设备树语法等可以查阅网上资料，有详细的描述，这里只简单地修改一下设备树内容，让内核访问设备树，然后驱动程序从设备树中获取描述信息进行驱动程序的编写。上一篇文章中，我们是通过直接在驱动程序中写死寄存器的地址来实现led的驱动，如果更换一个开发板，使用的GPIO引脚不同，那么这个驱动程序又将无法使用。本篇将介绍把这么硬件描述信息放到设备树中，通...
linux驱动开发5 按键中断实验（定时器和中断）
internetv的博客
08-24 782
led：IO的输出 ；key：IO的输入 法二：使用定时器消抖和按键中断 学习过 UCOS 或 FreeRTOS 的同学应该知道，UCOS 或 FreeRTOS 是需要一个硬件定时器 提供系统时钟，一般使用 Systick 作为系统时钟源。 Linux 内核中有大量的函数需要时间管理，比如周期性的调度程序、延时程序、对于我们驱动编写者来说最常用的定时器。硬件定时器提供时钟源，时钟源的频率可以设置，设置好以后就周期性的产生定时中断，系统使用定时中断来计时。中断周期性产生的频率就是系统频
基本的字符设备驱动框架
weixin_56755662的博客
03-25 630
#include <linux/types.h> #include <linux/kernel.h> #include <linux/delay.h> #include <linux/ide.h> #include <linux/init.h> #include <linux/module.h> #include <linux/errno.h> #include <linux/gpio.h> #include &
【吃灰板子捡起来】LED驱动开发实验
Polarisxuan的博客
04-09 367
LED驱动开发实验
fatal error: asm/mach-types.h: No such file or directory
guoggn的专栏
01-11 5307
fatal error: asm/mach-types.h: No such file or directory #include asm/mach-types.h> 改为： #include asm/types.h>
gcc-7.3 rpm包下载
07-30
gcc-7.3是GNU软件开发工具链中的一个版本，用于编译C和C++程序。在Linux系统中，我们可以通过下载和安装相关的rpm包来获得gcc-7.3。 首先，我们可以访问GNU官方网站（https://gcc.gnu.org/）来获得gcc-7.3的相关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值