Subversion Repositories sata_controller_core

/*

 * sata-drv.c

 *

 * Linux block device driver for Ashwin Mendon's SATA controller.

 *

 * Author: Bin Huang  <bin.arthur@gmail.com>

 *

 * 2012 (c) Reconfigurable Computing System Lab at University of North

 * Carolina at Charlotte. This file is licensed under

 * the terms of the GNU General Public License version 2. This program

 * is licensed "as is" without any warranty of any kind, whether express

 * or implied. The code originally comes from the book "Linux Device

 * Drivers" by Alessandro Rubini and Jonathan Corbet, published

 * by O'Reilly & Associates.

 */

#include <linux/module.h>

#include <linux/moduleparam.h>

#include <linux/init.h>

#include <linux/sched.h>

#include <linux/kernel.h>       /* printk() */

#include <linux/slab.h>         /* kmalloc() */

#include <linux/fs.h>           /* everything... */

#include <linux/errno.h>        /* error codes */

#include <linux/types.h>        /* size_t */

#include <linux/fcntl.h>        /* O_ACCMODE */

#include <linux/hdreg.h>        /* HDIO_GETGEO */

#include <linux/kdev_t.h>

#include <linux/vmalloc.h>

#include <linux/genhd.h>

#include <linux/blkdev.h>

#include <linux/buffer_head.h>  /* invalidate_bdev */

#include <linux/bio.h>

#include <linux/delay.h>        /* udelay() */

#include "sata_drv.h"

MODULE_LICENSE("Dual BSD/GPL");

static int sata_major = 0;

module_param(sata_major, int, 0);

static int hardsect_size = HARDSECT_SIZE;

module_param(hardsect_size, int, 0);

static int nsectors = N_SECTORS;        /* How big the drive is */

module_param(nsectors, int, 0);

static int ndevices = 1;

module_param(ndevices, int, 0);

/*

 * The different "request modes" we can use.

 */

enum {

        RM_SIMPLE  = 0,  /* The extra-simple request function */

        RM_FULL    = 1, /* The full-blown version */

        RM_NOQUEUE = 2, /* Use make_request */

};

static int request_mode = RM_NOQUEUE;

module_param(request_mode, int, 0);

static struct sata_dev *Devices = NULL;

void read_sectors(struct sata_dev *dev, int sector_addr, int sector_count, unsigned int dma_phy_addr);

void write_sectors(struct sata_dev *dev, int sector_addr, int sector_count, unsigned int dma_phy_addr);

void read_sectors(struct sata_dev *dev, int sector_addr, int sector_count, unsigned int dma_phy_addr)

{

        // DDR Read Space Start Address 

        dev->scp->npi_wr_addr_reg = dma_phy_addr;

        // Clear SATA Control Register 

        dev->scp->ctrl_reg = REG_CLEAR;

        // Input Sector Address, Count and Command to Sata Core

        dev->scp->sector_addr_reg = sector_addr;

        dev->scp->sector_count_reg = sector_count;

        dev->scp->cmd_reg = (READ_CMD);

        // Trigger SATA Core

        dev->scp->ctrl_reg = (NEW_CMD);

        // Wait for Command Completion 

        while ((dev->scp->status_reg & SATA_CORE_DONE) != SATA_CORE_DONE);

        //Time to Read Sectors from Disk 

#ifdef CONFIG_RCS_SATA_DEBUG

        printk("Number of clock cycles to complete this read: %d\n",dev->scp->sector_timer_reg);

#endif

        while ((dev->scp->status_reg & NPI_DONE) != NPI_DONE);

}

void write_sectors(struct sata_dev *dev, int sector_addr, int sector_count, unsigned int dma_phy_addr)

{

        // DDR Write Space Start Address 

        dev->scp->npi_rd_addr_reg = dma_phy_addr;

        // Clear SATA Control Register 

        dev->scp->ctrl_reg = REG_CLEAR;

        // Input Sector Address, Count, DATA and Command to Sata Core

        dev->scp->sector_addr_reg = sector_addr;

        dev->scp->sector_count_reg = sector_count;

        //scp->wr_data_reg     = write_data;

        dev->scp->cmd_reg = (WRITE_CMD);

        // Trigger SATA Core

        dev->scp->ctrl_reg = (NEW_CMD);

        // Wait for Command Completion 

        while ((dev->scp->status_reg & SATA_CORE_DONE) != SATA_CORE_DONE);

        //Time to Write Sectors from Disk 

#ifdef CONFIG_RCS_SATA_DEBUG

        printk("Number of clock cycles to complete this write: %d\n",dev->scp->sector_timer_reg);

#endif

}

/*

 * Handle an I/O request.

 */

static void sata_transfer(struct sata_dev *dev, unsigned long sector,

                unsigned long nsect, char *buffer, int write)

{

        unsigned long offset = sector*KERNEL_SECTOR_SIZE;

        unsigned long nbytes = nsect*KERNEL_SECTOR_SIZE;

        if ((offset + nbytes) > dev->size) {

                printk (KERN_INFO "Beyond-end write (%ld %ld)\n", offset, nbytes);

                return;

        }

        if (write){

#ifdef CONFIG_RCS_SATA_DEBUG

                printk (KERN_INFO "Write request to: \n");

                printk (KERN_INFO "sector = %lu, nsect = %lu, buf_phy_addr = 0x%08lx ... \n ", sector, nsect, virt_to_phys(buffer));

#endif

                write_sectors(dev, sector, nsect, virt_to_phys(buffer));

#ifdef CONFIG_RCS_SATA_DEBUG

                printk (KERN_INFO "Write done.\n");

#endif

        }

        else{

#ifdef CONFIG_RCS_SATA_DEBUG

                printk (KERN_INFO "Read request to: \n");

                printk (KERN_INFO "sector = %lu, nsect = %lu, buf_phy_addr = 0x%08lx ... \n", sector, nsect, virt_to_phys(buffer));

#endif

                read_sectors(dev, sector, nsect, virt_to_phys(buffer));

#ifdef CONFIG_RCS_SATA_DEBUG

                printk (KERN_INFO "Read done\n");

#endif

        }

}

static void sata_request(struct request_queue *q)

{

        struct request *req;

        req = blk_fetch_request(q);

        while (req != NULL) {

                struct sata_dev *dev = req->rq_disk->private_data;

                if (req == NULL || (req->cmd_type != REQ_TYPE_FS)) {

                        printk (KERN_NOTICE "Skip non-CMD request\n");

                        __blk_end_request_all(req, -EIO);

                        continue;

                }

                sata_transfer(dev, blk_rq_pos(req), blk_rq_cur_sectors(req),

                                req->buffer, rq_data_dir(req));

                if ( ! __blk_end_request_cur(req, 0) ) {

                        req = blk_fetch_request(q);

                }

        }

}

/*

 * Transfer a single BIO.

 */

static int sata_xfer_bio(struct sata_dev *dev, struct bio *bio)

{

        int i;

        struct bio_vec *bvec;

        sector_t sector = bio->bi_sector;

        void *mem;

        // Do each segment independently. 

        bio_for_each_segment(bvec, bio, i) {

                char *buffer = __bio_kmap_atomic(bio, i, KM_USER0);

                mem = kmap(bvec->bv_page);

                kunmap(bvec->bv_page);

                sata_transfer(dev, sector, bio_cur_bytes(bio) >> SECTOR_SHIFT,

                                buffer, bio_data_dir(bio) == WRITE);

                sector += bio_cur_bytes(bio) >> SECTOR_SHIFT;

                __bio_kunmap_atomic(bio, KM_USER0);

        }

        return 0; // Always "succeed" 

}

/*

 * The direct make request version.

 */

static int sata_make_request(struct request_queue *q, struct bio *bio)

{

        struct sata_dev *dev = q->queuedata;

        int status;

        status = sata_xfer_bio(dev, bio);

        bio_endio(bio, status);

        return 0;

}

/*

 * Open and close.

 */

static int sata_open(struct block_device *bdev, fmode_t mode)

{

        struct sata_dev *dev = bdev->bd_disk->private_data;

        unsigned long flags;

        spin_lock_irqsave(&dev->lock, flags);

        dev->users++;

        spin_unlock_irqrestore(&dev->lock, flags);

        check_disk_change(bdev);

        return 0;

}

static int sata_release(struct gendisk *disk, fmode_t mode)

{

        struct sata_dev *dev = disk->private_data;

        spin_lock(&dev->lock);

        dev->users--;

        spin_unlock(&dev->lock);

        return 0;

}

/*

 * The HDIO_GETGEO ioctl is handled in blkdev_ioctl.

 */

int sata_getgeo (struct block_device *bdev, struct hd_geometry *geo)

{

        long size;

        struct sata_dev *dev = bdev->bd_disk->private_data;

        printk(KERN_INFO "SATA block device driver command : HDIO_GETGEO .\n");

        size = dev->size*(hardsect_size/KERNEL_SECTOR_SIZE);

        geo->cylinders = (size & ~0x3f) >> 6;

        geo->heads = 4;

        geo->sectors = 16;

        geo->start = 0;

        return 0;

}

/*

 * The device operations structure.

 */

static struct block_device_operations sata_ops =

{

        .owner           = THIS_MODULE,

        .open            = sata_open,

        .release         = sata_release,

        .getgeo          = sata_getgeo

};

/*

 * Set up our internal device.

 */

static int setup_device(struct sata_dev *dev, int which)

{

        int retval = 0;

        int try_setup_link = 0;

        /*

         * Initialize data structure.

         */

        memset (dev, 0, sizeof (struct sata_dev));

        dev->size = nsectors*hardsect_size;

        /*

         * Remap I/O for SATA controller.

         */

        if( !request_mem_region(SATA_CFG_BASE, SATA_CFG_REMAP_SIZE, DRIVER_NAME)){

                printk(KERN_ERR "Request for SATA configuration memory region failed!\n");

                dev->scp = 0;

                retval = -1;

                goto fail;

        }

        else {

                dev->scp = (SATA_core_t *) ioremap_nocache(SATA_CFG_BASE, SATA_CFG_REMAP_SIZE);

                if (dev->scp == 0) {

                        printk(KERN_ERR

                               "%s: Couldn't ioremap memory at 0x%08X\n",

                               DRIVER_NAME, SATA_CFG_BASE);

                        iounmap(dev->scp);

                        retval = -EFAULT;

                        goto fail;

                }

                else {

#ifdef CONFIG_RCS_SATA_DEBUG

                        printk(KERN_INFO "Remap Returned Virtual Address: %x\n",(unsigned int)dev->scp);

#endif

                }

        }

        dev->scp->ctrl_reg = REG_CLEAR;

        dev->scp->cmd_reg  = REG_CLEAR;

        while ((dev->scp->status_reg & SATA_LINK_READY) != SATA_LINK_READY)

        {

                dev->scp->ctrl_reg = SW_RESET;

                dev->scp->ctrl_reg = REG_CLEAR;

                try_setup_link++;

                udelay(100000);

                //It is very disk specific. For the OCZ SSD, it takes a few resets for the link 

                //to come up but on the Micron SSD or on the Western Digital HD, it comes up 

                //after the first reset. 

                if (try_setup_link == 100) {

#ifdef CONFIG_RCS_SATA_DEBUG

                        printk(KERN_INFO "SATA Link is not ready yet.\n");

#endif

                        retval = -ENODEV;

                        goto fail;

                }

        }

        spin_lock_init(&dev->lock);

        /*

         * The I/O queue, depending on whether we are using our own

         * make_request function or not.

         */

        switch (request_mode) {

            case RM_NOQUEUE:

                dev->queue = blk_alloc_queue(GFP_KERNEL);

                if (dev->queue == NULL)

                        goto fail;

                blk_queue_make_request(dev->queue, sata_make_request);

                break;

            case RM_SIMPLE:

                dev->queue = blk_init_queue(sata_request, &dev->lock);

                if (dev->queue == NULL)

                {

                        retval = -ENODEV;

                        goto fail;

                }

                break;

            default:

                printk(KERN_NOTICE "Bad request mode %d, using simple\n", request_mode);

        }

        blk_queue_logical_block_size(dev->queue, hardsect_size);

        dev->queue->queuedata = dev;

        /*

         * And the gendisk structure.

         */

        dev->gd = alloc_disk(SATA_MINORS);

        if (! dev->gd) {

                printk (KERN_INFO "alloc_disk failure\n");

                retval = -ENODEV;

                goto fail;

        }

        printk (KERN_INFO "alloc_disk success\n");

        dev->gd->major = sata_major;

        dev->gd->first_minor = which*SATA_MINORS;

        dev->gd->fops = &sata_ops;

        dev->gd->queue = dev->queue;

        dev->gd->private_data = dev;

        snprintf (dev->gd->disk_name, 32, "sata%c", which + 'a');

        set_capacity(dev->gd, nsectors*(hardsect_size/KERNEL_SECTOR_SIZE));

        add_disk(dev->gd);

        return 0;               /* success */

fail:

        printk(KERN_INFO "Fail to setup SATA block device.\n");

        printk("SATA controller status: 0x%08x\n", dev->scp->status_reg);

        return retval;

}

static int __init sata_init(void)

{

        int i;

        int retval = 0;

        /*

         * Get registered.

         */

        printk(KERN_INFO "Block device driver for sata controller\n");

        sata_major = register_blkdev(sata_major, "sata");

        if (sata_major <= 0) {

                printk(KERN_WARNING "sata: unable to get major number\n");

                return -EBUSY;

        }

        /*

         * Allocate the device array, and initialize each one.

         */

        Devices = kmalloc(ndevices*sizeof (struct sata_dev), GFP_KERNEL);

        if (Devices == NULL)

                goto out_unregister;

        for (i = 0; i < ndevices; i++){

                retval = setup_device(Devices + i, i);

        }

        return retval;

  out_unregister:

        unregister_blkdev(sata_major, "sata");

        return -ENOMEM;

}

static void sata_exit(void)

{

        int i;

        for (i = 0; i < ndevices; i++) {

                struct sata_dev *dev = Devices + i;

                if (dev->gd) {

                        del_gendisk(dev->gd);

                        put_disk(dev->gd);

                }

                if (dev->queue) {

                        if (request_mode == RM_NOQUEUE)

                                blk_put_queue(dev->queue);

                        else

                                blk_cleanup_queue(dev->queue);

                }

        }

        unregister_blkdev(sata_major, "sata");

        kfree(Devices);

}

module_init(sata_init);

module_exit(sata_exit);