static MAJOR number allocation in character device driver in linux

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/major.h>
#include <linux/capability.h>
#include <asm/uaccess.h>
#include <linux/cdev.h>


static ssize_t sample_char_read(struct file * file, char __user * buf,
                       size_t count, loff_t *ppos)
{
       printk("sample_char_read size(%ld)\n", count);
       return 0;
}

static ssize_t sample_char_write(struct file *filp, const char *buf,
                 size_t size, loff_t *offp)
{
       printk("sample_char_write size(%ld)\n", size);
       return size;

}

int sample_char_open(struct inode *inode, struct file *filp)
{
       printk("sample_char_open\n");
       return 0;
}

int sample_char_release(struct inode *inode, struct file *filp)
{

       printk("sample_char_release\n");
       return 0;
}

static struct file_operations sample_char_fops = {
       read:          sample_char_read,
       write:          sample_char_write,
       open:          sample_char_open,
       release:        sample_char_release,
};

#define sample_major_number 249
#define max_minors 1

static struct cdev char_cdev;
static dev_t dev;
int init_module(void)
{
 int ret = 0;

 dev = MKDEV(sample_major_number, 0);
        printk("\nLoading the sample char device driver\n");

        ret = register_chrdev_region(dev, max_minors, "sample_char");
        if (ret)
 {
  printk("register_chrdev_region Error\n");
                goto error;
 }
        cdev_init(&char_cdev, &sample_char_fops);
        ret = cdev_add(&char_cdev, dev, max_minors);
        if (ret) {
 printk("cdev_add Error\n");
        goto error_region;
        }
 return 0;

error_region:
        unregister_chrdev_region(dev, max_minors);
error:
        return ret;
}

void cleanup_module(void)
{
 cdev_del(&char_cdev);
        unregister_chrdev_region(dev, max_minors);
        printk("\nUnloading the sample char device driver\n");

}