#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/random.h>
#include <linux/delay.h>
#include <linux/genhd.h>

#define ENTINJ "entinj: "

static int entinj_open(struct inode *inode, struct file *file);
static ssize_t entinj_write(struct file *file, const char __user *buf, size_t count, loff_t *ofs);

#define GENDISK_RANDOM_SIZE 1024
struct gendisk entinj_disk;

static inline void my_rand_initialize_disk (struct gendisk *disk);
static inline void my_rand_destroy_disk (struct gendisk *disk);

static struct file_operations entinj_fops = {
        .owner          = THIS_MODULE,
        //.llseek         = no_llseek,
        //.read           = entinj_read,
        .write           = entinj_write,
        //.poll           = entinj_poll,
        //.ioctl          = entinj_ioctl,
        .open           = entinj_open,
        //.release        = entinj_release,
        //.fasync         = entinj_fasync,
};

static struct miscdevice entinj_dev = {
        .minor          = MISC_DYNAMIC_MINOR,
        .name           = "entinj",
        .fops           = &entinj_fops,
};


static int 
entinj_init(void)
{
        int rc;

        memset (&entinj_disk, 0, sizeof (entinj_disk));
        my_rand_initialize_disk (&entinj_disk);

        rc = misc_register (&entinj_dev);
        if (rc) {
                printk (KERN_WARNING ENTINJ "could not register device.\n");
                return rc;
        }

        printk(KERN_ALERT "Entropy injector loaded\n");
        return 0;
}

static void 
entinj_exit(void)
{
        misc_deregister (&entinj_dev);
        my_rand_destroy_disk (&entinj_disk);

        printk(KERN_ALERT "Entropy injector unloaded\n");
}

static int 
entinj_open(struct inode *inode, struct file *file)
{
        return 0;
}

static ssize_t 
entinj_write (struct file *file, const char __user *buf, 
                size_t count, loff_t *ofs)
{
        uint del = 0;

        if (count)
                del = *(unsigned char*)buf;
        if (del)
                udelay (del);

        printk ("adding randomness (udelay %u)\n", del);
        add_disk_randomness (&entinj_disk);
        return count>4 ? 4 : count;
}

static inline void 
my_rand_initialize_disk (struct gendisk *disk)
{
        void *state;

        if (! disk) 
                return;

        state = kmalloc (GENDISK_RANDOM_SIZE, GFP_USER);
        if (!state)
                return;

        memset (state, 0, GENDISK_RANDOM_SIZE);
        disk->random = state;
}

static inline void 
my_rand_destroy_disk (struct gendisk *disk)
{
        if (!disk || !disk->random)
                return;

        disk->random = NULL;
        kfree (disk->random);
}

module_init(entinj_init);
module_exit(entinj_exit);