linux外部中断程序,Linux 外部中断例子

Linux 外部中断例子代码：

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

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

alloc_chrdev_region(&dev->devno, 0, 1, "fpga_key_to_app");

cdev_init(&dev->cdev, &meassage_operatons);

cdev_add(&dev->cdev, dev->devno, 1);

dev->fpga_key_class = class_create(THIS_MODULE, "fpga_key_class");

if(IS_ERR(dev->fpga_key_class)) {

printk("Err: failed in creating class./n");

goto fail1;

}

device_create(dev->fpga_key_class, NULL, dev->devno, NULL, "fpga_key");

//init irq

ret = gpio_request(GPIO_TO_PIN(1, 27), "fpga_key_inter");

if(ret){

printk("gpio_request() failed !\n");

goto fail1;

}

ret = gpio_direction_input(GPIO_TO_PIN(1, 27));

if(ret){

printk("gpio_direction_input() failed !\n");

goto fail2;

}

inter = gpio_to_irq(GPIO_TO_PIN(1, 27));

if(inter < 0){

printk("gpio_to_irq() failed !\n");

ret = inter;

goto fail2;

}

printk("inter = %d", inter);

ret = request_irq(inter,

irq_handler,

IRQF_TRIGGER_FALLING | IRQF_SHARED,

"fpga_key_inter",

&dev->devno);

if(ret){

printk("request_irq() failed ! %d\n", ret);

goto fail2;

}

printk("fpga_key_to_app_init(void)--\n");

return 0;

fail2:

gpio_free(GPIO_TO_PIN(1, 27));

fail1:

device_destroy(dev->fpga_key_class, dev->devno);

class_destroy(dev->fpga_key_class);

cdev_del(&dev->cdev);

unregister_chrdev_region(dev->devno, 1);

return ret;

}

static void __exit fpga_key_exit(void)

{

struct fpga_key_dev *dev = &fpga_key_dev;

printk("fpga_key_to_app_exit(void)++\n");

free_irq(AM33XX_IRQ_GPIO1_1, NULL);

gpio_free(GPIO_TO_PIN(1, 27));

device_destroy(dev->fpga_key_class, dev->devno);

class_destroy(dev->fpga_key_class);

cdev_del(&dev->cdev);

unregister_chrdev_region(dev->devno, 1);

printk("fpga_key_to_app_exit(void)--\n");

}

module_init(fpga_key_init);

module_exit(fpga_key_exit);

MODULE_LICENSE("GPL");

MODULE_AUTHOR("Driver Monkey");

MODULE_DESCRIPTION("Test fpga_key to App");