ZYNQ XC7Z020的PL PS中断驱动程序编写测试（linux4.14版本下）

/include/ "system-conf.dtsi"
/ {
	irq: irq@0{
		compatible = "plpsirq";
		interrupt-parent = <&intc>;
		interrupts = <0 54 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 <linux/fcntl.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/sched/signal.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/mm.h>
/***************************************************************
***************************************************************/

#define PLPS_CNT		1				/* 设备号长度 	*/
#define PLPS_NAME		"plpsirq"	/* 设备名字 	*/

/* 中断描述结构体 */
struct irq_plpsdesc {
	int irqnum;								/* 中断号     */
	char name[10];							/* 名字 */
	irqreturn_t (*handler)(int, void *);	/* 中断服务函数 */
};
/* leddev设备结构体 */
struct plpsirqdev_dev{
	dev_t devid;				/* 设备号	*/
	struct cdev cdev;			/* cdev		*/
	struct class *class;		/* 类 		*/
	struct device *device;		/* 设备		*/
	int major;					/* 主设备号	*/	
	int irq;
	struct device_node *node;	/* plps设备节点 */
	struct irq_plpsdesc irq_plpsdesc;	/* 按键描述数组 */
	struct fasync_struct *async_queue;		/* 异步相关结构体 */
	wait_queue_head_t w_wait;				/* 读等待队列头 */
};
struct plpsirqdev_dev plpsirq; 		/* plps设备 */
/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int plpsirq_open(struct inode *inode, struct file *filp)
{
	filp->private_data = &plpsirq; /* 设置私有数据  */
	return 0;
}

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

	DECLARE_WAITQUEUE(wait, current);	/* 定义一个等待队列 */

	test = kzalloc(1024, GFP_KERNEL);
	if (filp->f_flags & O_NONBLOCK)	{ /* 非阻塞访问 */
			return -EAGAIN;
	} else {	
		printk("KER11");						/* 阻塞访问 */
			add_wait_queue(&plpsirq.w_wait, &wait);	/* 将等待队列添加到等待队列头 */
			__set_current_state(TASK_INTERRUPTIBLE);/* 设置任务状态 */
			schedule();							/* 进行一次任务切换 */
			printk("KER22");
			if(signal_pending(current))	{			/* 判断是否为信号引起的唤醒 */
			printk("KE44");
				set_current_state(TASK_RUNNING);		/* 设置任务为运行态 */
				remove_wait_queue(&plpsirq.w_wait, &wait);	/* 将等待队列移除 */
			test = ioremap(0x40000000, 10);
			err=copy_to_user(buf, test, cnt);
			printk("cnt = %d\n", cnt);
			return cnt; 

	//		ret = -ERESTARTSYS;
	//		goto wait_error;
		}
			set_current_state(TASK_RUNNING);		/* 设置任务为运行态 */
			remove_wait_queue(&plpsirq.w_wait, &wait);	/* 将等待队列移除 */
		printk("KER33");
		test = ioremap(0x40000000, 10);
		err=copy_to_user(buf, test, cnt);
		printk("cnt = %d\n", cnt);
		return cnt;
	}
wait_error:
	set_current_state(TASK_RUNNING);		/* 设置任务为运行态 */
	remove_wait_queue(&plpsirq.w_wait, &wait);	/* 将等待队列移除 */
	return ret;
}
/* @description		: 中断服务函数，开启定时器，延时10ms，
 *				  	  定时器用于按键消抖。
 * @param - irq 	: 中断号
 * @param - dev_id	: 设备结构。
 * @return 			: 中断执行结果
 */
static irqreturn_t plps_handler(int irq, void *dev_id)
{
	struct plpsirqdev_dev *dev = (struct plpsirqdev_dev *)dev_id;
	printk("irq = %d\n", irq);
	kill_fasync (&dev->async_queue, SIGIO, POLL_IN);
	wake_up_interruptible(&dev->w_wait);
	return IRQ_RETVAL(IRQ_HANDLED);
}

/*
 * @description     : fasync函数，用于处理异步通知
 * @param - fd		: 文件描述符
 * @param - filp    : 要打开的设备文件(文件描述符)
 * @param - on      : 模式
 * @return          : 负数表示函数执行失败
 */
static int plpsirq_fasync(int fd, struct file *filp, int on)
{
	struct plpsirqdev_dev *dev = (struct plpsirqdev_dev *)filp->private_data;
	return fasync_helper(fd, filp, on, &dev->async_queue);
}

/*
 * @description     : release函数，应用程序调用close关闭驱动文件的时候会执行
 * @param - inode	: inode节点
 * @param - filp    : 要打开的设备文件(文件描述符)
 * @return          : 负数表示函数执行失败
 */
static int plpsirq_release(struct inode *inode, struct file *filp)
{
	return plpsirq_fasync(-1, filp, 0);
}
/*mmap系统调用函数 */
static int plpsirq_mmap(struct file *file, struct vm_area_struct *vma)
{
    vma->vm_flags |= VM_IO;//表示对设备IO空间的映射
    vma->vm_flags |= (VM_DONTEXPAND | VM_DONTDUMP);//标志该内存区不能被换出，在设备驱动中虚拟页和物理页的关系应该是长期的，应该保留起来，不能随便被别的虚拟页换出
  	vma->vm_page_prot =pgprot_noncached(vma->vm_page_prot);
    if(remap_pfn_range(vma,//虚拟内存区域，即设备地址将要映射到这里
                       vma->vm_start,//虚拟空间的起始地址
                       vma->vm_pgoff,//与物理内存对应的页帧号，物理地址右移12位
                       vma->vm_end - vma->vm_start,//映射区域大小，一般是页大小的整数倍
                       vma->vm_page_prot))//保护属性，
    {
        return -EAGAIN;
    }
    return 0;
}
/* 设备操作函数 */
static struct file_operations plpsirq_fops = {
	.owner = THIS_MODULE,
	.open = plpsirq_open,
	.read = plpsirq_read,
	.fasync = plpsirq_fasync,
	.release = plpsirq_release,
	.mmap = plpsirq_mmap,
};

/*
 * @description		: flatform驱动的probe函数，当驱动与
 * 					  设备匹配以后此函数就会执行
 * @param - dev 	: platform设备
 * @return 			: 0，成功;其他负值,失败
 */
static int plpsirq_probe(struct platform_device *dev)
{	
	int ret = 0;
	struct device_node *node;
	unsigned int irqnumplps[3];
	strcpy(plpsirq.irq_plpsdesc.name, "plpszd"); /*给数组赋字符串*/
	printk("plps driver and device was matched!\r\n");
	/* 1、设置设备号 */
/*	if (plpsirq.major) {
		plpsirq.devid = MKDEV(plpsirq.major, 0);
		register_chrdev_region(plpsirq.devid, PLPS_CNT, PLPS_NAME);
	} else {
		alloc_chrdev_region(&plpsirq.devid, 0, PLPS_CNT, PLPS_NAME);
		plpsirq.major = (plpsirq.devid);
	}
	*/
	/* 2、注册设备      */
/*	cdev_init(&plpsirq.cdev, &plpsirq_fops);
	cdev_add(&plpsirq.cdev, plpsirq.devid, PLPS_CNT);
*/
	plpsirq.major = register_chrdev(0, PLPS_NAME, &plpsirq_fops);  /* /dev/gpio_key */
	/* 3、创建类      */
	plpsirq.class = class_create(THIS_MODULE, PLPS_NAME);
	if (IS_ERR(plpsirq.class)) {
		return PTR_ERR(plpsirq.class);
	}
	/* 4、创建设备 */
	plpsirq.device = device_create(plpsirq.class, NULL,  MKDEV(plpsirq.major, 0), NULL, PLPS_NAME);
	if (IS_ERR(plpsirq.device)) {
		return PTR_ERR(plpsirq.device);
	}
	/* 5、初始化IO */	
	plpsirq.irq = platform_get_irq(dev,0);
	printk("num %d !\r\n", plpsirq.irq);
	plpsirq.irq_plpsdesc.handler = plps_handler;
	ret = devm_request_irq(plpsirq.device, plpsirq.irq, plpsirq.irq_plpsdesc.handler,
		                 IRQF_TRIGGER_RISING, plpsirq.irq_plpsdesc.name, &plpsirq);
	if(ret < 0){
			printk("irq %d request failed!\r\n", 86);
			return -EFAULT;
		}
	init_waitqueue_head(&plpsirq.w_wait);
	return 0;
}
/*
 * @description		: platform驱动的remove函数，移除platform驱动的时候此函数会执行
 * @param - dev 	: platform设备
 * @return 			: 0，成功;其他负值,失败
 */
static int plpsirq_remove(struct platform_device *dev)
{
	device_destroy(plpsirq.class, plpsirq.devid);
	class_destroy(plpsirq.class);
	cdev_del(&plpsirq.cdev);				/*  删除cdev */
	unregister_chrdev_region(plpsirq.devid, PLPS_CNT); /* 注销设备号 */
	return 0;
}
/* 匹配列表 */
static const struct of_device_id plpsirq_of_match[] = {
	{ .compatible = "plpsirq" },
	{ /* Sentinel */ }
};
/* platform驱动结构体 */
static struct platform_driver plpsirq_driver = {
	.driver		= {
		.name	= "plpsirq",			/* 驱动名字，用于和设备匹配 */
		.of_match_table	= plpsirq_of_match, /* 设备树匹配表 		 */
	},
	.probe		= plpsirq_probe,
	.remove		= plpsirq_remove,
};		
/*
 * @description	: 驱动模块加载函数
 * @param 		: 无
 * @return 		: 无
 */
static int __init plpsirq_init(void)
{
	return platform_driver_register(&plpsirq_driver);
}
/*
 * @description	: 驱动模块卸载函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit plpsirq_exit(void)
{
	platform_driver_unregister(&plpsirq_driver);
}

module_init(plpsirq_init);
module_exit(plpsirq_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("zd");

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include <sys/mman.h>
#include <signal.h>
#include <fcntl.h>
/***************************************************************
***************************************************************/
unsigned char *buf = NULL;
unsigned int count = 0;
void my_signal_fun(int signum)
{
	printf("irq app printf!\n");
	*buf=0x1 + count;
	*(buf+1)=0x2 + count;
	*(buf+2)=0x3 + count;
	*(buf+3)=0x4 + count;
	*(buf+4)=0x5 + count;
	for(int i=0;i<10;i++)
	{
	    printf("write = %d\n", *(buf+i));;
	}
	count++;
}

int main(int argc, char **argv)
{
	int fd;
	int len;
	char str[2048];
	
	unsigned char key_val;
	int ret;
	int Oflags;
	signal(SIGIO, my_signal_fun);
	fd = open("/dev/plpsirq", O_RDWR);
	if (fd < 0)
	{
		printf("can't open!\n");
	}
	fcntl(fd, F_SETOWN, getpid());
	Oflags = fcntl(fd, F_GETFL);
	fcntl(fd, F_SETFL, Oflags | FASYNC);
	buf =  mmap(NULL, 1024*8, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0x40000000);
	*buf=0x1;
	if (buf == MAP_FAILED)
	{
		printf("can not mmap file /dev/hello\n");
		return -1;
	}
	read(fd, str, 10);
	for(int i=0;i<10;i++)
	{
		printf("read = %d\n", str[i]);;
	}	
	munmap(buf, 1024*8);
	close(fd);
	return 0;
}

irq = 62
KER22
KE44
cnt = 10
irq app printf!
write = 2
write = 3
write = 4
write = 5
write = 6
write = 0
write = 0
write = 0
write = 0
write = 0
read = 1
read = 2
read = 3
read = 4
read = 5
read = 0
read = 0
read = 0
read = 0
read = 0