Linux驱动-中断实验

最新推荐文章于 2022-05-19 09:45:46 发布
最新推荐文章于 2022-05-19 09:45:46 发布
阅读量180 收藏
点赞数
分类专栏： linux驱动 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45761493/article/details/118894282
版权

**

驱动程序：

**

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.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/slab.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>

#include <linux/delay.h>
#include <linux/string.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/of_irq.h>

#define KEY_NUM     1
#define KEY0VALUE   0x01
#define KEY0INVA    0XFF
typedef struct irq_keydesc ysy;

/*key结构体*/
struct irq_keydesc{
    int gpio;       /*io编号*/
    int irqnum;     /*中断号*/
    unsigned char value;    /*键值*/
    char name[10];       /*名字*/
    irqreturn_t (*hander)(int , void *);
};
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;
};

struct imx6uirq_dev imx6uirq;
#define imx6uirq_count 1
#define imx6uirq_name "imx6uirq"

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


    return 0;
}

static int imx6uirq_release(struct inode *inode, struct file *filp)
{
    //struct imx6uirq_dev *dev = filp->private_data;

    return 0;
}
static ssize_t imx6uirq_write(struct file *filp, const char __user *buf,
			 size_t count, loff_t *ppos)
{

    return 0;
}
ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t count , loff_t *ppos)
{
    int ret = 0;
    unsigned int keyvalue;
    unsigned int releasekey;
    struct imx6uirq_dev *dev = filp->private_data;
    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;
        }
    } else {
        goto data_error;
    }
    atomic_set(&dev->releasekey, 0);
    return ret;
data_error:
    return -EINVAL;
    
}
static const struct file_operations imx6uirq_fops = {
    .owner = THIS_MODULE,
	.write = imx6uirq_write ,
	.open = imx6uirq_open,
    .read = imx6uirq_read,
	.release = imx6uirq_release,
};
static irqreturn_t key0_irq_hander(int irq, void *dev_id)
{   
    struct imx6uirq_dev *dev = dev_id;
    dev->timer.data = (unsigned long)dev_id;

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

#if 0
    value = gpio_get_value(dev->irqkey[0].gpio);
    if(value == 0) {
        printk("key0 is press!\r\n");
    } else if(value == 1) {
        printk("key0 is release!\r\n");
    }
#endif 
    return IRQ_HANDLED;
}
static void timer_function(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(&imx6uirq.keyvalue, dev->irqkey[0].value);
       // printk("key0 is press!\r\n");
    } else if(value == 1) {
        atomic_set(&imx6uirq.keyvalue, 0x80 | (dev->irqkey[0].value));
        atomic_set(&imx6uirq.releasekey, 1);

       // printk("key0 is release!\r\n");
    }

}
static int key_io_init(struct imx6uirq_dev *dev)
{
    int ret = 0;
    int i =0 ;
    /*按键初始化*/
    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-gpios", 0);
    }
    printk("gpio num = %d\r\n", dev->irqkey[0].gpio);
    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[i].irqnum = irq_of_parse_and_map(dev->irqkey[i].gpio, i);
        printk("irq num = %d\r\n", dev->irqkey[i].irqnum);
    }
    dev->irqkey[0].hander = key0_irq_hander;
    dev->irqkey[0].value = KEY0VALUE;
    /*按键中断初始化*/

    for(i=0; i<KEY_NUM; i++) {
        ret = request_irq(dev->irqkey[i].irqnum, dev->irqkey[i].hander, 
                        IRQ_TYPE_EDGE_RISING|IRQ_TYPE_EDGE_FALLING, dev->irqkey[i].name, &imx6uirq);
        
        if(ret) {
        printk("faile irq num = %d\r\n", dev->irqkey[i].irqnum);
        goto fail_irq_request;
      }
    }
    /*初始化定时器*/
    init_timer(&imx6uirq.timer);
    imx6uirq.timer.function = timer_function;


    return 0;
fail_irq_request:
    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_count, imx6uirq_name);
    } else {
        ret = alloc_chrdev_region(&imx6uirq.devid, 0, imx6uirq_count, imx6uirq_name);
        imx6uirq.major = MAJOR(imx6uirq.devid);
        imx6uirq.minor = MINOR(imx6uirq.devid);
    }
    if(ret < 0) {
        goto fail_devid;
    }
    printk("major = %d,minor = %d\r\n",imx6uirq.major,imx6uirq.minor);

    imx6uirq.cdev.owner = THIS_MODULE;

    cdev_init(&imx6uirq.cdev, &imx6uirq_fops);
    ret = cdev_add(&imx6uirq.cdev, imx6uirq.devid,  imx6uirq_count);
    if(ret < 0) {
        goto fail_cdev;
    }

    imx6uirq.class = class_create (THIS_MODULE, imx6uirq_name);
    if (IS_ERR(imx6uirq.class)) {
		ret = PTR_ERR(imx6uirq.class);
		goto fail_class;
	}
    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;
	}
    ret =key_io_init(&imx6uirq);
    if(ret < 0) {
        goto fail_keyinit;
    }
    /*初始化原子变量*/
    atomic_set(&imx6uirq.keyvalue, KEY0INVA);
    atomic_set(&imx6uirq.releasekey, 0);
    return 0;
fail_keyinit:
fail_device:
    class_destroy(imx6uirq.class);
fail_class:
    cdev_del(&imx6uirq.cdev);
fail_cdev:
    unregister_chrdev_region(imx6uirq.devid, imx6uirq_count);
fail_devid:
    return ret;
}

static void __exit imx6uirq_exit(void)
{
    int i = 0;
    /*释放中断*/
    for(i=0; i<KEY_NUM; i++) {
        free_irq(imx6uirq.irqkey[i].irqnum, &imx6uirq);;
    }
    /*释放io*/
    for(i=0; i<KEY_NUM; i++) {
        gpio_free(imx6uirq.irqkey[i].gpio);
    }
    del_timer_sync(&imx6uirq.timer);
    device_destroy(imx6uirq.class, imx6uirq.devid);
    class_destroy(imx6uirq.class);
    cdev_del(&imx6uirq.cdev);
    unregister_chrdev_region(imx6uirq.devid, imx6uirq_count);
}

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

应用程序：

在这里插#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>



int main(int argc,char *argv[])
{
    int fd;
    int ret = 0;
    int   retvalue;
    char *filename;
    filename = argv[1];
    unsigned char datebuf[1];
    if(argc != 2)
    {
        printf("Error usage!\r\n");
        return -1;
    }
    fd=open(filename,O_RDWR);
    if(fd<0)
    {
        printf("file %s open fialed !\r\n",filename);
        return -1;
    }
    /*循环读取*/
    while(1) {
        ret = read(fd, &retvalue, sizeof(retvalue));
        if(ret < 0) {

        } else {
            if(retvalue) {
                 printf("KEY0 Press retvalue = %d\r\n",retvalue);
             }
        }
    }
    close(fd);
    return 0;
}

**

tasklet

**
tasklet 是利用软中断来实现的另外一种下半部机制，在软中断和 tasklet 之间.

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.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/slab.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>

#include <linux/delay.h>
#include <linux/string.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/of_irq.h>

#define KEY_NUM     1
#define KEY0VALUE   0x01
#define KEY0INVA    0XFF
/*key结构体*/
struct irq_keydesc{
    int gpio;       /*io编号*/
    int irqnum;     /*中断号*/
    unsigned char value;    /*键值*/
    char name[10];       /*名字*/
    irqreturn_t (*hander)(int , void *);
    struct tasklet_struct tasklet;

};

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

struct imx6uirq_dev imx6uirq;
#define imx6uirq_count 1
#define imx6uirq_name "imx6uirq"

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


    return 0;
}

static int imx6uirq_release(struct inode *inode, struct file *filp)
{
    //struct imx6uirq_dev *dev = filp->private_data;

    return 0;
}
static ssize_t imx6uirq_write(struct file *filp, const char __user *buf,
			 size_t count, loff_t *ppos)
{

    return 0;
}
ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t count , loff_t *ppos)
{
    int ret = 0;
    unsigned int keyvalue;
    unsigned int releasekey;
    struct imx6uirq_dev *dev = filp->private_data;
    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;
        }
    } else {
        goto data_error;
    }
    atomic_set(&dev->releasekey, 0);
    return ret;
data_error:
    return -EINVAL;
    
}

static const struct file_operations imx6uirq_fops = {
    .owner = THIS_MODULE,
	.write = imx6uirq_write ,
	.open = imx6uirq_open,
    .read = imx6uirq_read,
	.release = imx6uirq_release,
};
static irqreturn_t key0_irq_hander(int irq, void *dev_id)
{   
    struct imx6uirq_dev *dev = dev_id;
    tasklet_schedule(&dev->irqkey[0].tasklet);
#if 0
    dev->timer.data = (unsigned long)dev_id;

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

    value = gpio_get_value(dev->irqkey[0].gpio);
    if(value == 0) {
        printk("key0 is press!\r\n");
    } else if(value == 1) {
        printk("key0 is release!\r\n");
    }
#endif 
    return IRQ_HANDLED;
}
static void key_tasklet_func(unsigned long data) 
{
    struct imx6uirq_dev *dev = (struct imx6uirq_dev *)data;
    dev->timer.data = (unsigned long)data;
    mod_timer(&dev->timer, jiffies + msecs_to_jiffies(15));

}
static void timer_function(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(&imx6uirq.keyvalue, dev->irqkey[0].value);
       // printk("key0 is press!\r\n");
    } else if(value == 1) {
        atomic_set(&imx6uirq.keyvalue, 0x80 | (dev->irqkey[0].value));
        atomic_set(&imx6uirq.releasekey, 1);

       // printk("key0 is release!\r\n");
    }

}
static int key_io_init(struct imx6uirq_dev *dev)
{
    int ret = 0;
    int i =0 ;
    /*按键初始化*/
    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-gpios", 0);
    }
    printk("gpio num = %d\r\n", dev->irqkey[0].gpio);
    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[i].irqnum = irq_of_parse_and_map(dev->irqkey[i].gpio, i);
        printk("irq num = %d\r\n", dev->irqkey[i].irqnum);
    }
    dev->irqkey[0].hander = key0_irq_hander;
    dev->irqkey[0].value = KEY0VALUE;
    //dev->irqkey[0].tasklet = key_tasklet_func;
    /*按键中断初始化*/

    for(i=0; i<KEY_NUM; i++) {
        ret = request_irq(dev->irqkey[i].irqnum, dev->irqkey[i].hander, 
                        IRQ_TYPE_EDGE_RISING|IRQ_TYPE_EDGE_FALLING, dev->irqkey[i].name, &imx6uirq);
        
        if(ret) {
        printk("faile irq num = %d\r\n", dev->irqkey[i].irqnum);
        goto fail_irq_request;
      }
      tasklet_init(&dev->irqkey[0].tasklet, key_tasklet_func, (unsigned long)dev);
    }
    /*初始化定时器*/
    init_timer(&imx6uirq.timer);
    imx6uirq.timer.function = timer_function;


    return 0;
fail_irq_request:
    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_count, imx6uirq_name);
    } else {
        ret = alloc_chrdev_region(&imx6uirq.devid, 0, imx6uirq_count, imx6uirq_name);
        imx6uirq.major = MAJOR(imx6uirq.devid);
        imx6uirq.minor = MINOR(imx6uirq.devid);
    }
    if(ret < 0) {
        goto fail_devid;
    }
    printk("major = %d,minor = %d\r\n",imx6uirq.major,imx6uirq.minor);

    imx6uirq.cdev.owner = THIS_MODULE;

    cdev_init(&imx6uirq.cdev, &imx6uirq_fops);
    ret = cdev_add(&imx6uirq.cdev, imx6uirq.devid,  imx6uirq_count);
    if(ret < 0) {
        goto fail_cdev;
    }

    imx6uirq.class = class_create (THIS_MODULE, imx6uirq_name);
    if (IS_ERR(imx6uirq.class)) {
		ret = PTR_ERR(imx6uirq.class);
		goto fail_class;
	}
    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;
	}
    ret =key_io_init(&imx6uirq);
    if(ret < 0) {
        goto fail_keyinit;
    }
    /*初始化原子变量*/
    atomic_set(&imx6uirq.keyvalue, KEY0INVA);
    atomic_set(&imx6uirq.releasekey, 0);
    return 0;
fail_keyinit:
fail_device:
    class_destroy(imx6uirq.class);
fail_class:
    cdev_del(&imx6uirq.cdev);
fail_cdev:
    unregister_chrdev_region(imx6uirq.devid, imx6uirq_count);
fail_devid:
    return ret;
}

static void __exit imx6uirq_exit(void)
{
    int i = 0;
    /*释放中断*/
    for(i=0; i<KEY_NUM; i++) {
        free_irq(imx6uirq.irqkey[i].irqnum, &imx6uirq);;
    }
    /*释放io*/
    for(i=0; i<KEY_NUM; i++) {
        gpio_free(imx6uirq.irqkey[i].gpio);
    }
    del_timer_sync(&imx6uirq.timer);
    device_destroy(imx6uirq.class, imx6uirq.devid);
    class_destroy(imx6uirq.class);
    cdev_del(&imx6uirq.cdev);
    unregister_chrdev_region(imx6uirq.devid, imx6uirq_count);
}

module_init(imx6uirq_init);
module_exit(imx6uirq_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("YSY");
听枫要靠谱
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux驱动按键中断实验：按键中断功能的实现
wojiaxiaohuang2014的博客
03-04 720
Linux驱动按键中断实验：按键中断功能的实现
测试用的中断驱动程序
arunboy的博客
11-30 440
中断驱动程序
Linux内核驱动—中断和时间管理
Half-up的博客
05-19 866
中断进入过程 本章采用的目标板子是三星的Exynos4412 使用的是4核的Cortex-A9,对应的中断控制器被称为GIC,相比于一般的中断控制器而言，其最主要的特点在于可以将一个特定的中断分发给一个特定的ARM核。但这并不是我们关注的重点，在后面的分析中，应该主要知道当中断发生后要如何调用驱动中的中断处理函数，以及在这个过程中所涉及的重要数据结构。整个过程中涉及较多的和体系结构相关的内容，主要体现在中断处理的前期阶段； 为了更方便读者理解这部分内容，在下面的讨论中会重新改写这部分代码。汇编阶段的主要相关
Linux驱动之中断实验(基于设备树编程)
fengweibo112的博客
11-07 1970
概述 Linux内核提供了完善的中断框架，我们只需要申请中断，然后注册中断处理函数即可，使用非常方便，不需要像单片机那样进行复杂的寄存器配置。 #基础知识 （一） 中断号 每个中断都有一个中断号，通过中断号区分不同的中断。中断号可以在芯片datasheet中查找到，比如GPIO的中断号，一般会在GPIO章节或者interrupt章节会有介绍， 搜索” Interrupt Sources”，或许你就...
linux设备驱动-按键中断实验笔记
时光左an的博客
03-03 899
一、开发环境 1、内核：Linux 2.6.22.6； 2、JZ2440 3、ubuntu 9.10 二、实验笔记 1、命令 insmod 加载模块 rmmod 卸载模块 ps 显示所有进程 ls -l /proc/791/fd /proc/$pid/fd 目录下存放了$pid进程中所有打开的fd lsmod 显示加载的模块
zynq linux驱动之PL-PS中断【转】
weixin_33918357的博客
11-13 340
转自：https://blog.csdn.net/h244259402/article/details/83993524 PC：Windows 10 虚拟机：ubuntu 16.04 vivado：2017.04 的的PetaLinux：2017.04 开发板：黑金AX7010 根文件系统：debian8 ---------------------------------------...
linux-adc-key驱动.rar
07-02
2. **Linux驱动模型**：熟悉Linux内核驱动模型，包括字符设备驱动和中断处理机制。 3. **设备树配置**：掌握设备树的语法和结构，理解如何通过设备树描述硬件资源，如I/O端口、中断号、内存区域等。 4. **Linux...
zyqn的linux驱动11-硬件中断
01-31
通过这样的实验，开发者可以更好地理解硬件中断的运作方式，以及如何在Linux驱动中有效地利用它们。此外，这也涉及到中断同步问题，例如中断处理程序与用户空间程序之间的数据交互，以及中断嵌套等问题，这些都是...
Linux增加字符设备驱动实验
05-11
在Linux系统中，字符设备驱动是操作系统与硬件设备交互的核心组件之一。...在实际项目中，字符设备驱动可能涉及中断处理、DMA传输、同步原语等更高级的概念，但这个"Hello World"实验是一个很好的起点。
iTOP-4412 Linux 驱动实验手册_V1.0
02-14
Exynos 4412是一款强大的四核ARM Cortex-A9处理器，广泛应用于各种智能设备和开发平台，其Linux驱动开发对于理解和优化系统性能至关重要。 在Linux系统中，驱动程序是连接硬件和操作系统之间的桥梁，它们负责处理...
linux 驱动开发linux 驱动开发
最新发布
11-16
Linux驱动开发是操作系统内核与硬件设备之间的重要桥梁，它使得操作系统能够有效地管理和控制硬件资源。在Linux系统中，驱动程序扮演着至关重要的角色，它们是操作系统与硬件设备交互的接口，负责处理设备的初始化、...
一、linux驱动开发-6.1-中断
rrring的博客
11-21 388
一、中断简介 内核提供了完善的中断框架，只需要申请中断，然后注册中断处理函数即可。 1.1、中断API 1.1.1、中断号 每个中断都有一个中断号，通过中断号即可区分不同的中断。 1.1.2、request_irq 用于申请中断，可能会导致睡眠，因此不能在中断上下文或者其他禁止睡眠的代码中使用，次函数会激活（使能）中断，因此不需要手动去使能中断 。 /* @Decription：申请中断 @irq：要申请的中断号 @handler：中断处理函数 @...
Linux驱动开发之按键中断实验【完整教程】
weixin_57037095的博客
03-22 3356
Linux驱动开发之按键中断实验【附有完整代码】
Linux内核中断和异常分析(下)
weixin_34327761的博客
04-23 139
这节，我们继续上，中(以前的日志有)篇目进行分析，结合一个真实的驱动案例来描述linux内核中驱动的中断机制，首先我们先了解一下linux内核中提供的中断接口。 这个接口我们需要包含一个头文件:#include <linux/interrupt.h> 在中断接口中，最重要的是以下的接口函数: 1、这个是请求中断函数 i...
linux下的msleep()，mdelay函数解析
qq_45761493的博客
04-11 4271
sleep()函数： static inline void ssleep(unsigned int seconds) { msleep(seconds * 1000); } msleep函数： void msleep(unsigned int msecs) { unsigned long timeout = msecs_to_jiffies(msecs) + 1; while (timeout) timeout = schedule_timeout_uninterruptible(t
.ko文件的编译生成
qq_45761493的博客
10-14 3654
1 KERNELDIR := /home/ysy/linux/IMX6ULL/linux/linux-imxrel_imx_4.1.15_2.1.0_ga_alientek 2 CURRENT_PATH := $(shell pwd) 3 obj-m := chrdevbase.o 4 5 build: kernel_modules 6 7 kernel_modules: 8 $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules 9 clean: 10 .
platform_get_resource
qq_45761493的博客
04-16 2422
platform_get_resource 这个函数跟设备树没什么关系，但是设备树中的节点被转换为platform_device后，设备树中的reg属性、interrupts属性也会被转换为“resource”。这时，你可以使用这个函数取出这些资源。一 个 节 点 能 被 转 换 为 platform_device ， 如 果 它 的 设 备 树 里 指 定 了 中 断 属 性 ， 那 么 可 以 从platform_device 中获得“中断资源”，函数如下，可以使用下列...
linux下的gpiod_get和gpiod_get_index
qq_45761493的博客
04-16 2088
#define __gpiod_get(dev, con_id, flags, ...) __gpiod_get(dev, con_id, flags) #define gpiod_get(varargs...) __gpiod_get(varargs, GPIOD_ASIS) #define __gpiod_get_index(dev, con_id, index, flags, ...) \ __gpiod_get_index(dev, con_id, index, flags) #define g
Linux 多点电容触摸屏实验（1）
qq_45761493的博客
09-10 1237
1.多点电容触摸简介 ATK-7016 这款屏幕其实是由 TFT LCD+触摸屏组合起来的。底下是 LCD 面板，上面是触摸面板，将两个封装到一起就成了带有触摸屏的 LCD 屏幕。电容触摸屏也是需要一个驱动 IC的，驱动 IC 一般会提供一个 I2C 接口给主控制器，主控制器可以通过 I2C 接口来读取驱动 IC里面的触摸坐标数据。ATK-7016、ATK-7084 这两款屏幕使用的触摸控制 IC 是 FT5426，ATK- 4342 使用的驱动 IC 是 GT9147。这...
GEC210-IOT Linux驱动开发实验手册：从入门到实践
"GEC210-IOT Linux驱动开发实验手册V2.0，由广州粤嵌通信科技股份有限公司提供，是一本针对GEC210嵌入式物联网平台的Linux驱动开发指南，涵盖了从基础的内核模块开发到更复杂的硬件控制实验。" 《GEC210-IOT Linux...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值