Linux 外部中断例子

Linux 外部中断例子代码：

#include <linux/kernel.h> 
#include <linux/module.h> 
#include <linux/cdev.h> 
#include <linux/fs.h> 
#include <linux/device.h> 
#include <linux/syscalls.h>
#include <linux/interrupt.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/of_platform.h>
#include <linux/uaccess.h> 
#include <linux/string.h>

#include <mach/gpio.h>
#include <mach/irqs.h>

#define GPIO_TO_PIN(bank, gpio) (32 * (bank) + (gpio))

struct fpga_key_dev 
{ 
    struct cdev cdev; 
    dev_t devno; 
    char test[20];
    struct class *fpga_key_class;
 struct fasync_struct *async_queue;

int message_cdev_open;
}; 

irqreturn_t irq_handler(int irqno, void *dev_id)

{
 printk("fpga key down\n");

return IRQ_HANDLED;
}

static int fpga_key_open(struct inode *node, struct file *fd) 
{ 
 struct fpga_key_dev *dev;
 
 printk("fpga_key_open()++\n"); 

printk("node->i_cdev = %x\n", (unsigned int)node->i_cdev);
 dev = container_of(node->i_cdev, struct fpga_key_dev, cdev);
 printk("dev->cdev = %x\n", (unsigned int)&dev->cdev);
 printk("dev = %x\n", (unsigned int)dev);
 
 if (!dev->message_cdev_open) {
  dev->message_cdev_open = 1;
  fd->private_data = dev;
 }
 else{
  return -EFAULT;
 }
 
 printk("test[20] = %s\n",dev->test);
 
    printk("fpga_key_open()--\n"); 
 
    return 0; 
} 
 
static ssize_t fpga_key_write(struct file *fd, const char __user *buf, size_t len, loff_t *ptr) 
{ 
    char temp_buffer [20]; 
    int print_size = 0; 
 struct fpga_key_dev *dev = fd->private_data;
     
    printk("fpga_key_wirte()++\n"); 
    if(len > 20) 
        print_size = 20; 
    else 
        print_size = len; 
    printk("print_size = %d; len = %d\n", print_size, len); 
    if(copy_from_user(temp_buffer, buf, print_size)) 
        return -EFAULT; 

if (dev->async_queue)
  kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
 
    printk("writing data:%s", temp_buffer); 
     
    printk("fpga_key_wirte()--\n"); 
 
    return print_size; 
} 
static ssize_t fpga_key_read(struct file *fd, char __user *buf, size_t len, loff_t *ptr) 
{ 
      char *temp_buffer = "Hello fpga_key_read !\n"; 
      int print_size = 0; 
       
    printk("fpga_key_read()++\n"); 
     
    if(len > strnlen(temp_buffer,20)) 
        print_size = strnlen(temp_buffer,20); 
    else 
        print_size = len; 
    printk("print_size = %d; len = %d\n", print_size, len); 
    if(copy_to_user(buf, temp_buffer, print_size)) 
        return -EFAULT; 
    printk("%s", temp_buffer); 
    printk("fpga_key_read()--\n"); 
 
    return print_size; 
} 

static int fpga_key_fasync(int fd, struct file *filp, int mode)
{
 struct fpga_key_dev  *dev = filp->private_data;

printk("fpga_key_fasync()++\n");
 
 fasync_helper(fd, filp, mode, &dev->async_queue);

printk("fpga_key_fasync()--\n");
 
 return 0;
}

static int fpga_key_release(struct inode *node, struct file *fd) 
{ 
 struct fpga_key_dev *dev = fd->private_data;
 
 printk("fpga_key_release()++\n");

dev->message_cdev_open = 0;
 fpga_key_fasync(-1, fd, 0);
 
    printk("fpga_key_release()--\n"); 
    return 0; 
}

struct file_operations meassage_operatons = 
{ 
    .owner = THIS_MODULE, 
    .open = fpga_key_open, 
    .write = fpga_key_write,
    .read = fpga_key_read,
    .fasync = fpga_key_fasync,
    .release = fpga_key_release, 
}; 
 
struct fpga_key_dev fpga_key_dev; 
static int __init fpga_key_init(void) 
{ 
    struct fpga_key_dev * dev; 
 char * temp_char = "hello world\n";
 int ret = 0;
 int inter = 0;
 
    printk("fpga_key_to_app_init(void)++\n"); 
 
    dev = &fpga_key_dev; 
 strcpy(dev->test, temp_char);;