Модуль символьного устройства

#define DEVICE_NAME "chardev"   /* Dev name as it appears in /proc/devices   */
#define BUF_LEN 80              /* Max length of the message from the device */
 
static int __init blablamod_init(void);
static void __exit blablamod_exit(void);
 
static int device_open(struct inode *, struct file *);
static int device_release(struct inode *, struct file *);
static ssize_t device_read(struct file *, char *, size_t, loff_t *);
static ssize_t device_write(struct file *, const char *, size_t, loff_t *);
 
MODULE_LICENSE("GPL");

#include <linux/init.h>
#include <linux/module.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
 
#include "blablamod.h"
 
static struct gpio in;
static int irq_num;
static int buf=0;
static int Major;           /* Major number assigned to our device driver */
static int Device_Open = 0; /* Is device open?  
                             * Used to prevent multiple access to device */
static char msg[BUF_LEN];   /* The msg the device will give when asked */
static char *msg_Ptr;
 
static struct file_operations fops = {
    .read = device_read,
    .write = device_write,
    .open = device_open,
    .release = device_release
};
 
 
static irqreturn_t gpio_isr(int irq, void *data)
{
 
    buf=buf++;
    return IRQ_HANDLED;
}
 
static int __init blablamod_init(void)
{
    
    Major = register_chrdev(0, DEVICE_NAME, &fops);
 
    if (Major < 0) {
      printk(KERN_ALERT "Registering char device failed with %d\n", Major);
      return Major;
    }
    printk(KERN_INFO "I was assigned major number %d. To talk to\n", Major);
    printk(KERN_INFO "the driver, create a dev file with\n");
    printk(KERN_INFO "'mknod /dev/%s c %d 0'.\n", DEVICE_NAME, Major);
    printk(KERN_INFO "Try various minor numbers. Try to cat and echo to\n");
    printk(KERN_INFO "the device file.\n");
    printk(KERN_INFO "Remove the device file and module when done.\n");
        
    int ret;
    in.gpio = 26;
    in.flags = GPIOF_IN;
    in.label = "In Gpio";
  
    ret = gpio_request(in.gpio,in.label);
    if (ret)
    {
        printk(KERN_ALERT "In Gpio request failed");
        return -2;
    }
 
    ret = gpio_to_irq(in.gpio);
    if (ret < 0)
    {
        printk(KERN_ERR "Unable to request IRQ: %d\n", ret);
        return -3;
    }
    irq_num = ret;
    printk(KERN_INFO "Successfully requested IRQ#%d.\n", irq_num);
    ret = request_irq(irq_num,gpio_isr,IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING , "gpio_irq", NULL);
    if (ret)
    {
        printk(KERN_ERR "Unable to request irq\n");
        return -4;
    }
 
 
    printk(KERN_NOTICE "Blablamod loaded\n");
    return 0;
}
 
static void __exit blablamod_exit(void)
{
    free_irq(irq_num,NULL);
    gpio_free(in.gpio);
    unregister_chrdev(Major, DEVICE_NAME);
    printk(KERN_NOTICE "BlablaModule unloaded!\n" ); 
   
}
 
module_init(blablamod_init);
module_exit(blablamod_exit);
 
 
static int device_open(struct inode *inode, struct file *file)
{
    static int counter = 0;
 
    if (Device_Open)
        return -EBUSY;
 
    
    sprintf(msg, "I already told you %d times Hello world!\n");
    msg_Ptr = msg;
    try_module_get(THIS_MODULE);
 
    return 0;
}
 
/* 
 * Called when a process closes the device file.
 */
static int device_release(struct inode *inode, struct file *file)
{
    Device_Open--;      /* We're now ready for our next caller */
 
    /* 
     * Decrement the usage count, or else once you opened the file, you'll
     * never get get rid of the module. 
     */
    module_put(THIS_MODULE);
 
    return 0;
}
 
/* 
 * Called when a process, which already opened the dev file, attempts to
 * read from it.
 */
static ssize_t device_read(struct file *filp,   /* see include/linux/fs.h   */
               char *buffer,    /* buffer to fill with data */
               size_t length,   /* length of the buffer     */
               loff_t * offset)
{
    /*
     * Number of bytes actually written to the buffer */
    sprintf(msg, buf);
    /* 
     * Most read functions return the number of bytes put into the buffer
     */
    return 0;
}
 
/*  
 * Called when a process writes to dev file: echo "hi" > /dev/hello 
 */
static ssize_t device_write(struct file *filp, const char *buff, size_t len, loff_t * off)
{
    printk(KERN_ALERT "Sorry, this operation isn't supported.\n");
    return -EINVAL;
}