07_linux中断控制

裸机开发要点

• 通用中断控制器(GIC)
  • 中断类型、硬件中断号、分发器和cpu接口单元
• 中断向量表
  • 一级查表、二级查表
• 中断处理流程
  • 进入irq模式、保护现场、获取硬件中断编号、执行中断处理函数、还原现场

设备树构造

分为 gic中断控制器设备树节点 其他外设中断控制器节点 需要使用中断的设备节点

gic中断控制器设备树节点

gic中断控制器在设备树里面的节点
虽然有compatible属性 但没有对应驱动,因为中断不可少,linux启动一定会初始化,也就不用驱动来匹配了

intc: interrupt-controller@a01000 {
		compatible = "arm,cortex-a7-gic";
		#interrupt-cells = <3>;  //描述下一级中断信息所需要的单元个数
		interrupt-controller;  //表示该设备是一个中断控制器，外设可以连接在该中断控制器上
		reg = <0xa01000 0x1000>,  //指分发器寄存器地址
		      <0xa02000 0x100>;  //cpu接口单元寄存器地址
	};

其他外设中断控制器节点

有些外设和中断关系密切,这时把这个外设节点也作为一个中断控制器节点
这样可以用这个外设节点对某一个具体的中断进行管理

gpio5: gpio@20ac000 {
				compatible = "fsl,imx6ul-gpio", "fsl,imx35-gpio";
				reg = <0x20ac000 0x4000>;
				interrupts = <GIC_SPI 74 IRQ_TYPE_LEVEL_HIGH>, //负责管理的中断类型通过 interrupts属性说明,这里有三个,和gic#interrupt-cells = <3>; 有关
					     <GIC_SPI 75 IRQ_TYPE_LEVEL_HIGH>;
				clocks = <&clks IMX6UL_CLK_GPIO5>;
				gpio-controller;
				#gpio-cells = <2>;
				interrupt-controller; //说明gpio5节点作为中断控制器
				#interrupt-cells = <2>; //设置其他外设想使用这个中断的描述格式
				gpio-ranges = <&iomuxc 0 7 10>, <&iomuxc 10 5 2>;
			};
		
interrupts = <GIC_SPI 74 IRQ_TYPE_LEVEL_HIGH>, 
//负责管理的中断类型通过 interrupts属性说明,这里有三个,和gic#interrupt-cells = <3>; 有关
- GIC_SPI：中断类型，0 表示 SPI 中断，1 表示 PPI 中断
- 74：中断号，对于 SPI 中断来说中断号的范围为 0~987，对于 PPI 中断来说中断号的范围为 0~15
		74中断号对应gpio5低16位IO中断,75中断号对应高16位IO中断
- IRQ_TYPE_LEVEL_HIGH：中断类型，高电平触发

其他设备使用中断控制器节点

设置iomux

设置iomux 给这个gpio_5_1 设置为普通io 输入 用来检测信号

pinctrl_button: button{
				fsl,pins = <
					MX6UL_PAD_SNVS_TAMPER1__GPIO5_IO01      0x000110A1
				>;
			};

编写设备节点_button

想在button_interrupt节点使用 gpio5管理的中断类型

button_interrupt {
    compatible = "button_interrupt";
    pinctrl-names = "default";  //pinctrl子系统链接iomux节点进行io初始化
    pinctrl-0 = <&pinctrl_button>; //gpio子系统
    button_gpio = <&gpio5 1 GPIO_ACTIVE_LOW>;
    status = "okay";
    interrupt-parent = <&gpio5>;  //需要使用的具体中断控制器,但是gpio5有32个
    interrupts = <1 IRQ_TYPE_EDGE_RISING>;  //想使用的中断GPIO5-1 和如何触发中断
};

设备驱动构造

记录按了多少次

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>

#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>


#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <asm/mach/map.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/io.h>
#include <linux/device.h>
#include <linux/irq.h>
#include <linux/of_irq.h>

#include "interrupt.h"




/*------------------字符设备内容----------------------*/
#define DEV_NAME "button"
#define DEV_CNT (1)

static dev_t button_devno;		 //定义字符设备的设备号
static struct cdev button_chr_dev; //定义字符设备结构体chr_dev
struct class *class_button;		 //保存创建的类
struct device *device_button;		 // 保存创建的设备


struct device_node	*button_device_node = NULL;  //定义按键设备节点结构体
unsigned  button_GPIO_number = 0;  //保存button使用的GPIO引脚编号
u32  interrupt_number = 0;         // button 引脚中断编号
atomic_t   button_status = ATOMIC_INIT(0);  //定义整型原子变量，保存按键状态 ，设置初始值为0



static irqreturn_t button_irq_hander(int irq, void *dev_id)
{
	// printk_green("button on \n");
	/*按键状态加一*/
	atomic_inc(&button_status);
	return IRQ_HANDLED;
}

static int button_open(struct inode *inode, struct file *filp)
{
	int error = -1;
	
	
	/*添加初始化代码*/
	// printk_green("button_open");

	/*获取按键 设备树节点*/
	button_device_node = of_find_node_by_path("/button_interrupt");
	if(NULL == button_device_node)
	{
		printk("of_find_node_by_path error!");
		return -1;
	}

	/*获取按键使用的GPIO*/
	button_GPIO_number = of_get_named_gpio(button_device_node ,"button_gpio", 0);
	if(0 == button_GPIO_number)
	{
		printk("of_get_named_gpio error");
		return -1;
	}

	/*申请GPIO  , 记得释放*/
	error = gpio_request(button_GPIO_number, "button_gpio");
	if(error < 0)
	{
		printk("gpio_request error");
		gpio_free(button_GPIO_number);
		return -1;
	}

	error = gpio_direction_input(button_GPIO_number);//设置引脚为输入模式

	/*获取中断号*/
	interrupt_number = irq_of_parse_and_map(button_device_node, 0);//检测设备树里面的interrupts属性值,根据后面的索引号
							//比如这里为0,就是拿取第一个中断属性,interrupts = <1 IRQ_TYPE_EDGE_RISING>; 
	printk("\n irq_of_parse_and_map! =  %d \n",interrupt_number);


	/*申请中断, 记得释放*/
	//interrupt_number 对应的中断号
	//button_irq_hander 处理中断函数
	//IRQF_TRIGGER_RISING flag标志位 表明用什么样的方式触发
	//"button_interrupt" 中断名
	//device_button 中断使用的设备  devices_create(),这时候中断号和设备绑定在一起
	error = request_irq(interrupt_number,button_irq_hander,IRQF_TRIGGER_RISING,"button_interrupt",device_button);
	if(error != 0)
	{
		printk("request_irq error");
		free_irq(interrupt_number, device_button);
		return -1;
	}

	/*申请之后已经开启了，切记不要再次打开，否则运行时报错*/
	// // enable_irq(interrupt_number);

	return 0;

}

static int button_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	int error = -1;
	int button_countervc = 0;

	/*读取按键状态值*/
	button_countervc = atomic_read(&button_status);

	/*结果拷贝到用户空间*/
	error = copy_to_user(buf, &button_countervc, sizeof(button_countervc));
	if(error < 0)
	{
		printk("copy_to_user error");
		return -1;
	}

	/*清零按键状态值*/
	atomic_set(&button_status,0);
	return 0;
}

/*字符设备操作函数集，.release函数实现*/
static int button_release(struct inode *inode, struct file *filp)
{
	/*释放申请的引脚,和中断*/
	gpio_free(button_GPIO_number);
	free_irq(interrupt_number, device_button);
	return 0;
}



/*字符设备操作函数集*/
static struct file_operations button_chr_dev_fops = {
	.owner = THIS_MODULE,
	.open = button_open,
	.read = button_read,
	.release = button_release,
};

/*
*驱动初始化函数
*/
static int __init button_driver_init(void)
{
	int error = -1;

	/*采用动态分配的方式，获取设备编号，次设备号为0，*/
	error = alloc_chrdev_region(&button_devno, 0, DEV_CNT, DEV_NAME);
	if (error < 0)
	{
		printk("fail to alloc button_devno\n");
		goto alloc_err;
	}

	/*关联字符设备结构体cdev与文件操作结构体file_operations*/
	button_chr_dev.owner = THIS_MODULE;
	cdev_init(&button_chr_dev, &button_chr_dev_fops);

	/*添加设备至cdev_map散列表中*/ 
	error = cdev_add(&button_chr_dev, button_devno, DEV_CNT);
	if (error < 0) 
	{
		printk("fail to add cdev\n");
		goto add_err;
	}

	class_button = class_create(THIS_MODULE, DEV_NAME);                         //创建类
	device_button = device_create(class_button, NULL, button_devno, NULL, DEV_NAME);//创建设备 DEV_NAME 指定设备名，

	return 0;

add_err:
	unregister_chrdev_region(button_devno, DEV_CNT);    // 添加设备失败时，需要注销设备号
	printk("\n error! \n");
	
alloc_err:
	return -1;
}



/*
*驱动注销函数
*/
static void __exit button_driver_exit(void)
{
	pr_info("button_driver_exit\n");
	/*删除设备*/
	device_destroy(class_button, button_devno);		   //清除设备
	class_destroy(class_button);					   //清除类
	cdev_del(&button_chr_dev);					       //清除设备号
	unregister_chrdev_region(button_devno, DEV_CNT);   //取消注册字符设备
}



module_init(button_driver_init);
module_exit(button_driver_exit);

MODULE_LICENSE("GPL");

各种驱动中使用中断的函数

request_irq()函数

申请中断

include/linux/interrupt.h

static inline int __must_check
request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
	    const char *name, void *dev)

参数：

• irq：要申请的中断号
• handler：中断处理函数
• flags：中断标志
• name：中断名字
• dev：传递给中断处理函数的第二个参数
  • device结构体变量，区分不同设备共用同一中断

返回值：

• 成功：0

• 失败：负数

irq_handler_t

typedef irqreturn_t (*irq_handler_t)(int, void *);

irqreturn_t

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

typedef enum irqreturn irqreturn_t;

• IRQ_NONE：不是本驱动程序的中断，不处理
• IRQ_HANDLED：正常处理
• IRQ_WAKE_THREAD：使用中断下半部处理

flags

include/linux/interrupt.h

#define IRQF_SHARED		0x00000080
#define IRQF_ONESHOT		0x00002000
#define IRQF_TRIGGER_NONE	0x00000000
#define IRQF_TRIGGER_RISING	0x00000001
#define IRQF_TRIGGER_FALLING	0x00000002
#define IRQF_TRIGGER_HIGH	0x00000004
#define IRQF_TRIGGER_LOW	0x00000008

free_irq()函数

释放中断

include/linux/interrupt.h

const void *free_irq(unsigned int irq, void *dev_id)

参数：

• irq：要释放的中断号

• dev：传递给中断处理函数的第二个参数

返回值：

​ 无

enable_irq()函数

使能中断

kernel/irq/manage.c

void enable_irq(unsigned int irq)

参数：

• irq：要使能的中断号

返回值：

​ 无

disable_irq()函数

禁止中断，等待中断执行完毕

kernel/irq/manage.c

void disable_irq(unsigned int irq)

参数：

• irq：要禁止的中断号

返回值：

​ 无

disable_irq_nosync()函数

禁止中断，不等待中断执行完

kernel/irq/manage.c

void disable_irq_nosync(unsigned int irq)

参数：

• irq：要禁止的中断号

返回值：

​ 无

local_irq_disable()宏

include/linux/irqflags.h

禁止处理器中断

#define local_irq_disable()	do { raw_local_irq_disable(); } while (0)

local_irq_enable()宏

include/linux/irqflags.h

开处理器中断

#define local_irq_enable()	do { raw_local_irq_enable(); } while (0)