/*
* Mini-block driver.
*
* Este código está basado en el ejemplo de LWN.NET: http://lwn.net/Articles/31513/
*
* Copyright 2003 Eklektix, Inc.  Redistributable under the terms
* of the GNU GPL.
* 
* Actualizacion por parte de Edmundo Carmona <eantoranz@gmail.com>
*/
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/vmalloc.h>
#include <linux/slab.h>
#include <linux/genhd.h>
#include <linux/blkdev.h>
#include <linux/hdreg.h>


MODULE_LICENSE("Dual BSD/GPL");

/*
* Algunos valores que podrian haber
* sido parametrizables.
*/
#define KERNEL_SECTOR_SIZE 512
#define MAJOR_NUM 240 /* un major number libre, segun devices.txt */
#define MINIBD_MINORS 16 /* numero de particiones posibles */
#define N_SECTORS 1024 /* el numero de sectores de nuestro block device */
#define MINIBLOCK_SECTOR_SIZE 512 /* nuestro tammanyo de sector */

/*
* La cola de peticiones del mini-block.
*/
static struct request_queue *miniblock_queue;

/*
* Representacion interna de nuestro device.
*/
static struct miniblock_device {
        unsigned long size;
        spinlock_t lock;
        u8 *data;
        struct gendisk *gd;
};

static struct miniblock_device *Miniblock = NULL;

/*
* Manipulacion real en nuestro dispositivo de las I/O request.
*/
static void miniblock_transfer(struct miniblock_device *dev, struct request * req)
{
    unsigned long offset = blk_rq_pos(req) * MINIBLOCK_SECTOR_SIZE;
    unsigned long nbytes = blk_rq_cur_sectors(req) * MINIBLOCK_SECTOR_SIZE;
    printk(KERN_ERR "minibd: desplazamiento peticion: %d tama\%o: %d\n", offset, nbytes);

    if ((offset + nbytes) > dev->size) {
        printk (KERN_NOTICE "minibd: escritura por encima del final (%ld %ld)\n", offset, nbytes);
        return;
    }
    if (rq_data_dir(req))
        memcpy(dev->data + offset, req->buffer, nbytes);
    else
        memcpy(req->buffer, dev->data + offset, nbytes);
}

/*
* Manipulacion de las I/O request.
*/
static void miniblock_request(struct request_queue *q)
{
    struct request *req;

    while ((req = blk_fetch_request(q)) != NULL) {
        if (!req->cmd_type != REQ_TYPE_FS) {
            printk (KERN_NOTICE "Skip non-CMD request\n");
            __blk_end_request_all(req, 0);
            continue;
        }
        miniblock_transfer(Miniblock, req);
        __blk_end_request_all(req, 1);
    }

}

/*
* Ioctls perosonalizadas para nuestro device.
*/
int miniblock_ioctl (struct inode *inode, struct file *filp,
                unsigned int cmd, unsigned long arg)
{
        long size;
        struct hd_geometry geo;

        switch(cmd) {
            case HDIO_GETGEO:
                size = Miniblock->size*(MINIBLOCK_SECTOR_SIZE/KERNEL_SECTOR_SIZE);
                geo.cylinders = (size & ~0x3f) >> 6;
                geo.heads = 4;
                geo.sectors = 16;
                geo.start = 4;
                if (copy_to_user((void *) arg, &geo, sizeof(geo)))
                        return -EFAULT;
                return 0;
    }

    return -ENOTTY;
}

/*
* Operaciones asociadas a nuestro dispositivo.
*/
static struct block_device_operations miniblock_ops = {
    .owner          = THIS_MODULE,
    .ioctl          = miniblock_ioctl
};

/*
* Inicializacion del modulo.
*/
static int __init miniblock_init(void)
{
        static int ret;

        ret = register_blkdev(MAJOR_NUM, "minibd");
        if (ret < 0) {
                printk(KERN_WARNING "minibd: error en asignacion de major number\n");
                return -EBUSY;
        }

        printk(KERN_DEBUG "minibd: registrado con exito\n");

        Miniblock = kmalloc(sizeof(struct miniblock_device), GFP_KERNEL);
        if (Miniblock == NULL) {
                printk(KERN_WARNING "minidb: error asignando memoria con kmalloc\n");
                goto out_unregister;
        }

        /*
        * Inicializamos nuestro device.
        */
        memset(Miniblock, 0, sizeof(struct miniblock_device));
        Miniblock->size = N_SECTORS*MINIBLOCK_SECTOR_SIZE;
        Miniblock->data = vmalloc(Miniblock->size);
        if (Miniblock->data == NULL) {
                printk(KERN_WARNING "minidb: error asignando memoria con vmalloc\n");
                kfree(Miniblock);
                goto out_unregister;
        }
        spin_lock_init(&Miniblock->lock);

        /*
        * Creamos nuestra request queue asociada (una por block device).
        */
        miniblock_queue = blk_init_queue(miniblock_request, &Miniblock->lock);
        if (miniblock_queue == NULL) {
                printk(KERN_WARNING "minibd: error en blk_init_queue\n");
                goto out_free;
        }

        blk_queue_logical_block_size(miniblock_queue, MINIBLOCK_SECTOR_SIZE);

        /*
        * Rellenamos nuestra gendisk structure.
        */
        Miniblock->gd = alloc_disk(MINIBD_MINORS);
        if (!Miniblock->gd) {
                printk(KERN_WARNING "minibd: error en alloc_disk\n");
                goto out_free;
        }

        Miniblock->gd->major = MAJOR_NUM;
        Miniblock->gd->first_minor = 0;
        Miniblock->gd->fops = &miniblock_ops;
        Miniblock->gd->private_data = Miniblock;
        snprintf(Miniblock->gd->disk_name, 10, "%s", "minibd0");
        set_capacity(Miniblock->gd, N_SECTORS*(MINIBLOCK_SECTOR_SIZE/KERNEL_SECTOR_SIZE));
        Miniblock->gd->queue = miniblock_queue;

        add_disk(Miniblock->gd); // <- Here is where the registration takes place

        return 0;

out_free:
        vfree(Miniblock->data);
        kfree(Miniblock);
out_unregister:
        unregister_blkdev(MAJOR_NUM, "minibd");

        return -ENOMEM;
}

/*
* Descarga del modulo.
*/
static void __exit miniblock_exit(void)
{
        del_gendisk(Miniblock->gd);
        put_disk(Miniblock->gd);

        unregister_blkdev(MAJOR_NUM, "minibd");
        blk_cleanup_queue(miniblock_queue);

        vfree(Miniblock->data);
        kfree(Miniblock);

        printk(KERN_DEBUG "minibd: descargado con exito\n");
}

module_init(miniblock_init);
module_exit(miniblock_exit);