Linux中断——嵌入式Linux驱动开发

参考正点原子I.MX6U嵌入式Linux驱动开发指南

一、简介

int request_irq(unsigned int irq,

                        irq_handler_t  handler,

                        unsigned long flags,

                        const char *name,

                        void *dev)

enum irqreturn {
    IRQ_NONE = (0 << 0),
    IRQ_HANDLED = (1 << 0),
    IRQ_WAKE_THREAD = (1 << 1),
};

typedef enum irqreturn irqreturn_t;

return IRQ_RETVAL(IRQ_HANDLED)

void enable_irq(unsigned int irq)

void disable_irq(unsigned int irq)

local_irq_enable()

local_irq_disable()

local_irq_save(flags)

local_irq_restore(flags)

二、上半部与下半部

struct softirq_action
{
    void (*action)(struct softirq_action *);
};

static struct softirq_action softirq_vec[NR_SOFTIRQS];

enum
{
 HI_SOFTIRQ=0, /* 高优先级软中断 */
 TIMER_SOFTIRQ, /* 定时器软中断 */
 NET_TX_SOFTIRQ, /* 网络数据发送软中断 */
 NET_RX_SOFTIRQ, /* 网络数据接收软中断 */
 BLOCK_SOFTIRQ, 
 BLOCK_IOPOLL_SOFTIRQ, 
 TASKLET_SOFTIRQ, /* tasklet 软中断 */
 SCHED_SOFTIRQ, /* 调度软中断 */
 HRTIMER_SOFTIRQ, /* 高精度定时器软中断 */
 RCU_SOFTIRQ, /* RCU 软中断 */
 NR_SOFTIRQS
};

void open_softirq(int nr, void (*action)(struct softirq_action *))

void raise_softirq(unsigned int nr)

void __init softirq_init(void)
{
    int cpu;

    for_each_possible_cpu(cpu)
    {
        per_cpu(tasklet_vec, cpu).tail =
            &per_cpu(tasklet_vec, cpu).head;
        per_cpu(tasklet_hi_vec, cpu).tail =
            &per_cpu(tasklet_hi_vec, cpu).head;
    }

    open_softirq(TASKLET_SOFTIRQ, tasklet_action);
    open_softirq(HI_SOFTIRQ, tasklet_hi_action);
}

struct tasklet_struct
{
    struct tasklet_struct *next; /* 下一个 tasklet */
    unsigned long state;         /* tasklet 状态 */
    atomic_t count;              /* 计数器，记录对 tasklet 的引用数 */
    void (*func)(unsigned long); /* tasklet 执行的函数 */
    unsigned long data;          /* 函数 func 的参数 */
};

void tasklet_init(struct tasklet_struct *t,

                        void (*func)(unsigned long),

                        unsigned long data);

void tasklet_schedule(struct tasklet_struct *t)

三、设备树中断节点

intc: interrupt-controller@00a01000 {
    compatible = "arm,cortex-a7-gic";
    #interrupt-cells = <3>;
    interrupt-controller;
    reg = <0x00a01000 0x1000>,
          <0x00a02000 0x100>;
};

gpio5 : gpio @020ac000{
    compatible = "fsl,imx6ul-gpio", "fsl,imx35-gpio";
    reg = <0x020ac000 0x4000>;
    interrupts = <GIC_SPI 74 IRQ_TYPE_LEVEL_HIGH>,
                 <GIC_SPI 75 IRQ_TYPE_LEVEL_HIGH>;
    gpio - controller;
    #gpio - cells = < 2>;
    interrupt - controller;
    #interrupt - cells = < 2>;
};

unsigned int irq_of_parse_and_map(struct device_node *dev,  int index)

int gpio_to_irq(unsigned int gpio)

 四、示例实验

4.1 设备树

key {
        #address-cells = <1>;
        #size-cells = <1>;
        compatible = "lyh-key";
        pinctrl-names = "default";
        pinctrl-0 = <&pinctrl_key>;
        led-gpio = <&gpio1 18 GPIO_ACTIVE_LOW>;
        interrupt-parent = <&gpio1>;
        interrupts = <18 IRQ_TYPE_EDGE_BOTH>; /* FALLING RISING */
        status = "okay";
    };

…………

pinctrl_key: keygrp {
            fsl,pins = <
                MX6UL_PAD_UART1_CTS_B__GPIO1_IO18    0xF080  /* KEY */
            >;
        };

4.2 中断驱动

#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>

/***************************************************************
Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
文件名 : keyirq.c
作者  : lyh
版本   : V1.0
描述   : LED驱动文件。
其他   : 无
日志   : 初版V1.0 2024/4/14 lyh创建
***************************************************************/
#define KEY_CNT 1 /* 设备号个数 */
#define KEY_NAME "key" /* 名字 */
#define KEY0VALUE 0X01 /* KEY0 按键值 */
#define INVAKEY 0XFF /* 无效的按键值 */
#define KEY_NUM 1 /* 按键数量 */

/* 中断 IO 描述结构体 */
struct irq_keydesc {
int gpio; /* gpio */
int irqnum; /* 中断号 */
unsigned char value; /* 按键对应的键值 */
char name[10]; /* 名字 */
irqreturn_t (*handler)(int, void *); /* 中断服务函数 */
};

/* key设备结构体 */
struct key_dev{
dev_t devid;/* 设备号  */
struct cdev cdev;/* cdev */
struct class *class;/* 类 */
struct device *device;/* 设备  */
int major;/* 主设备号  */
int minor;/* 次设备号   */
struct device_node *nd; /* 设备节点 */
struct timer_list timer;
atomic_t key_value;
atomic_t releasekey;
struct irq_keydesc irqkeydesc[KEY_NUM];/* 按键描述数组 */
unsigned char curkeynum; /* 当前的按键号 */
};

struct key_dev key;/* key设备 */

/* @description : 中断服务函数，开启定时器，延时 10ms，
 * 定时器用于按键消抖。
 * @param - irq : 中断号
 * @param - dev_id : 设备结构。
 * @return : 中断执行结果
 */
static irqreturn_t key0_handler(int irq, void *dev_id)
{
struct key_dev *dev = (struct key_dev *)dev_id;

dev->curkeynum = 0;
dev->timer.data = (unsigned long)dev;
mod_timer(&dev->timer, jiffies + msecs_to_jiffies(10));
return IRQ_RETVAL(IRQ_HANDLED);
}

void timer_func(unsigned long arg)
{
struct key_dev *dev = (struct key_dev *)arg;
unsigned char value;
int num = dev->curkeynum;
struct irq_keydesc *keydesc = &dev->irqkeydesc[num];

value = gpio_get_value(keydesc->gpio);
if(value == 0){//按下按键
atomic_set(&dev->key_value, keydesc->value);
} else {//松开按键
atomic_set(&dev->key_value, 0x80 | keydesc->value);
atomic_set(&dev->releasekey, 1);
}
return;
}

/*
 * @description: 打开设备
 * @param - inode : 传递给驱动的inode
 * @param - filp : 设备文件，file结构体有个叫做private_data的成员变量
 *   一般在open的时候将private_data指向设备结构体。
 * @return : 0 成功;其他 失败
 */
static int key_open(struct inode *inode, struct file *filp)
{
filp->private_data = &key; /* 设置私有数据 */
return 0;
}

/*
 * @description: 从设备读取数据 
 * @param - filp : 要打开的设备文件(文件描述符)
 * @param - buf : 返回给用户空间的数据缓冲区
 * @param - cnt : 要读取的数据长度
 * @param - offt : 相对于文件首地址的偏移
 * @return : 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t key_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
int ret = 0;
unsigned char keyvalue = 0;
unsigned char releasekey = 0;
struct key_dev *dev = (struct key_dev *)filp->private_data;

keyvalue = atomic_read(&dev->key_value);
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;
}
return 0;

data_error:
return -EINVAL;
}

/*
 * @description: 向设备写数据 
 * @param - filp : 设备文件，表示打开的文件描述符
 * @param - buf : 要写给设备写入的数据
 * @param - cnt : 要写入的数据长度
 * @param - offt : 相对于文件首地址的偏移
 * @return : 写入的字节数，如果为负值，表示写入失败
 */
static ssize_t key_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{


return 0;
}

/*
 * @description: 关闭/释放设备
 * @param - filp : 要关闭的设备文件(文件描述符)
 * @return : 0 成功;其他 失败
 */
static int key_release(struct inode *inode, struct file *filp)
{
return 0;
}

/* 设备操作函数 */
static struct file_operations key_fops = {
.owner = THIS_MODULE,
.open = key_open,
.read = key_read,
.write = key_write,
.release = key_release,
};

static int keyio_init(void)
{
int ret;
int i;
/* 找到设备节点 */
key.nd = of_find_node_by_path("/key");
if(key.nd == NULL) {
printk("key node cant not found!\r\n");
return -EINVAL;
} else {
printk("key node has been found!\r\n");
}

/* 获取设备树中的 gpio 编号 */
for(i = 0; i < KEY_NUM; i++){
key.irqkeydesc[i].gpio = of_get_named_gpio(key.nd, "key-gpio", i);
if(key.irqkeydesc[i].gpio < 0){
printk("can't get key-gpio %d", i);
return -EINVAL;
}
}

/* gpio 初始化，申请中断号 */
for(i = 0; i < KEY_NUM; i++){
memset(key.irqkeydesc[i].name, 0, sizeof(key.irqkeydesc[i].name));
sprintf(key.irqkeydesc[i].name, "key%d", i);
gpio_request(key.irqkeydesc[i].gpio, key.irqkeydesc[i].name);
ret = gpio_direction_input(key.irqkeydesc[i].gpio);
if(ret < 0) {
printk("can't set gpio %d direction!\r\n", i);
return -EINVAL;
}

key.irqkeydesc[i].irqnum = gpio_to_irq(key.irqkeydesc[i].gpio);
#if 0
key.irqkeydesc[i].irqnum = irq_of_parse_and_map(key.nd, i);
#endif
printk("key%d:gpio=%d, irqnum=%d\r\n", i, key.irqkeydesc[i].gpio, 
key.irqkeydesc[i].irqnum);
}
/* 申请中断 */
key.irqkeydesc[0].handler = key0_handler;
key.irqkeydesc[0].value = KEY0VALUE;
for (i = 0; i < KEY_NUM; i++){
ret = request_irq(key.irqkeydesc[i].irqnum,
  key.irqkeydesc[i].handler,
  IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
  key.irqkeydesc[i].name, 
  &key);
if (ret < 0){
printk("irq %d request failed!\r\n", key.irqkeydesc[i].irqnum);
return -EFAULT;
}
}

 /* 创建定时器 */
init_timer(&key.timer);
key.timer.function = timer_func;

return 0;
}

/*
 * @description: 驱动出口函数
 * @param : 无
 * @return : 无
 */
static int __init keyirq_init(void)
{

/* 注册字符设备驱动 */
/* 1、创建设备号 */
if (key.major) {/*  定义了设备号 */
key.devid = MKDEV(key.major, 0);
register_chrdev_region(key.devid, KEY_CNT, KEY_NAME);
} else {/* 没有定义设备号 */
alloc_chrdev_region(&key.devid, 0, KEY_CNT, KEY_NAME);/* 申请设备号 */
key.major = MAJOR(key.devid);/* 获取分配号的主设备号 */
key.minor = MINOR(key.devid);/* 获取分配号的次设备号 */
}
printk("key major=%d,minor=%d\r\n",key.major, key.minor);

/* 2、初始化cdev */
key.cdev.owner = THIS_MODULE;
cdev_init(&key.cdev, &key_fops);

/* 3、添加一个cdev */
cdev_add(&key.cdev, key.devid, KEY_CNT);

/* 4、创建类 */
key.class = class_create(THIS_MODULE, KEY_NAME);
if (IS_ERR(key.class)) {
return PTR_ERR(key.class);
}

/* 5、创建设备 */
key.device = device_create(key.class, NULL, key.devid, NULL, KEY_NAME);
if (IS_ERR(key.device)) {
return PTR_ERR(key.device);
}

/* 5、初始化按键 */
atomic_set(&key.key_value, INVAKEY);
atomic_set(&key.releasekey, 0);

keyio_init();

return 0;
}

/*
 * @description: 驱动出口函数
 * @param : 无
 * @return : 无
 */
static void __exit keyirq_exit(void)
{
unsigned int i = 0;
/* 删除定时器 */
del_timer_sync(&key.timer); 

/* 释放中断 */
for (i = 0; i < KEY_NUM; i++) {
free_irq(key.irqkeydesc[i].irqnum, &key);
gpio_free(key.irqkeydesc[i].gpio);
}

/* 注销字符设备驱动 */
cdev_del(&key.cdev);/*  删除cdev */
unregister_chrdev_region(key.devid, KEY_CNT); /* 注销设备号 */

device_destroy(key.class, key.devid);
class_destroy(key.class);
}

module_init(keyirq_init);
module_exit(keyirq_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("lyh");

4.3 测试应用

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include "linux/ioctl.h"

int main(int argc, char *argv[])
{
    int fd;
    int ret = 0;
    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("Can't open file %s\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 ret;
}

 

原文地址：https://blog.csdn.net/2301_76655007/article/details/137748489

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！