Linux char driver Boilerplate

char_driver.c

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/slab.h>

MODULE_AUTHOR("Fabian Stiehle");
MODULE_DESCRIPTION("");
MODULE_LICENSE("GPL");

#define MODULENAME "char_driver"

static dev_t device_number;
static struct cdev *driver_object;
static struct class *device_class;

static int driver_open(struct inode *device, struct file *instance)
{
	return 0;
}

static int driver_close(struct inode *device, struct file *instance) 
{
	return 0;
}

ssize_t driver_read(struct file *instance, char __user *user, size_t count, loff_t *offset)
{
	return 0;
}

ssize_t driver_write(struct file *instance, const char __user *buffer,
	size_t max_bytes_to_write, loff_t *offset)
{
	return 0;
}

static struct file_operations fops = {
	.owner = THIS_MODULE,
	.read = driver_read,
	.write = driver_write,
	.open = driver_open,
	.release = driver_close
};

static int __init ModInit(void)
{
	printk(KERN_DEBUG ""MODULENAME": Init module...\n");
	printk(KERN_DEBUG ""MODULENAME": alloc_chrdev_region\n");
    if(alloc_chrdev_region(&device_number, 0, 1, MODULENAME) < 0)
    {
    	printk(KERN_ERR ""MODULENAME": alloc_chrdev_region failed\n");
    	return -EIO;
    }
    
    /* Anmeldeobject reservieren */
    printk(KERN_DEBUG ""MODULENAME": cdev_alloc\n");
    driver_object = cdev_alloc();
    if (driver_object == NULL)
    {	
    	printk(KERN_ERR ""MODULENAME": cdev_alloc failed\n");
    	goto free_device_number;
    }
    driver_object->owner = THIS_MODULE;
    driver_object->ops = &fops;
    
    printk(KERN_DEBUG ""MODULENAME": cdev_add\n");
    if (cdev_add(driver_object, device_number, 1))
    {
    	printk(KERN_ERR ""MODULENAME": cdev_add failed\n");
    	goto free_cdev;
    }
    
    /* Eintrag im Sysfs */
	printk(KERN_DEBUG ""MODULENAME": class_create\n");
	device_class = class_create(THIS_MODULE, MODULENAME);
	if (IS_ERR(device_class))
	{	
		printk(KERN_ERR ""MODULENAME": class_create failed\n");
		goto free_cdev;
	}	
    
    /* Create device */   
	device_create(device_class, NULL, device_number, NULL, MODULENAME);
    return 0;

free_cdev:
	kobject_put(&driver_object->kobj);
free_device_number:
	unregister_chrdev_region(device_number, 1);
	return -EIO;
}

static void __exit ModExit(void)
{
    printk(KERN_DEBUG ""MODULENAME": exit driver...\n");
    device_destroy(device_class, device_number);
    class_destroy(device_class);
    cdev_del(driver_object);
    unregister_chrdev_region(device_number, 1);
    return;
}

module_init(ModInit);
module_exit(ModExit);