Subversion Repositories test_project

/* -*- linux-c -*-

 *

 * OpenCores MMC Controller driver

 *

 *

 * Command 51 and Command 2 hardcoded

 *

 *

 *

 * Copyright (C) 2009 ORSoC, All Rights Reserved.

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License as published

 * by the Free Software Foundation; version 2 of the License.

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License along

 * with this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 */

#include <linux/module.h>

#include <linux/init.h>

#include <linux/ioport.h>

#include <linux/platform_device.h>

#include <linux/delay.h>

#include <linux/interrupt.h>

#include <linux/err.h>

#include <linux/mmc/host.h>

#include <linux/dma-mapping.h>

#include <linux/scatterlist.h>

#include <linux/highmem.h>

#include <asm/board.h>

#include <asm/io.h>

#include <asm/irq.h>

#include <asm/mmc.h>

#include <asm/system.h>

#include <linux/mmc/card.h>

#include "mmc_ocores.h"

#define DRIVER_NAME "mmc-ocores"

#define NR_SG   1

struct ocores_host {

        struct mmc_host         *mmc;

        spinlock_t              lock;

        struct resource         *res;

        void __iomem            *base;

        unsigned int            cmdat;

        unsigned int            power_mode;

        struct ocores_platform_data *pdata;

        unsigned int            word_cnt;

        struct mmc_request      *mrq;

        struct mmc_command      *cmd;

        struct mmc_data         *data;

        int irq_cmd;

        int irq_dat;

        unsigned int flags;

        struct tasklet_struct finish_cmd;

        struct tasklet_struct finish_data;

        struct {

                unsigned int normal_int_status;

                unsigned int error_int_status;

                unsigned int data_int_status;

        } registers;

        int clock;

        /* DMA buffer used for transmitting */

        unsigned int* buffer;

        dma_addr_t physical_address;

        unsigned int total_length;

        unsigned int            dma_len;

        /* Latest in the scatterlist that has been enabled for transfer, but not freed */

        int in_use_index;

        /* Latest in the scatterlist that has been enabled for transfer */

        int transfer_index;

        int free_tx_bd;

        int free_rx_bd;

};

struct ocores_host *oc_host;

static void ocores_tasklet_finish_cmd(unsigned long param);

static void ocores_tasklet_finish_data(unsigned long param);

static inline void CMD_IRQ_ON(struct ocores_host *host, u32 mask)

{

        u32 val = readl(host->base  + SD_NOMAL_INT_SIGNAL_ENABLE);

        val |= mask;

        writel (val, host->base  + SD_NOMAL_INT_SIGNAL_ENABLE);

}

static inline void CMD_IRQ_OFF(struct ocores_host *host, u32 mask)

{

        u32 val = readl(host->base  + SD_NOMAL_INT_SIGNAL_ENABLE);

        val  &= ~mask;

        writel (val, host->base  + SD_NOMAL_INT_SIGNAL_ENABLE);

}

static inline void DAT_IRQ_ON(struct ocores_host *host, u32 mask)

{

        u32 val = readl(host->base  + SD_BD_ISER);

        val |= mask;

        writel (val, host->base  + SD_BD_ISER);

}

static inline void DAT_IRQ_OFF(struct ocores_host *host, u32 mask)

{

        u32 val = readl(host->base  + SD_BD_ISER);

        val  &= ~mask;

        writel (val, host->base  + SD_BD_ISER);

}

static void ocores_pre_dma_read(struct ocores_host *host)

{

        int i,j;

        int off_scal;

        struct scatterlist *sg;

        struct mmc_command *cmd;

        struct mmc_data *data;

        off_scal=512;

        if (host->mmc->card!= NULL){

                if (mmc_card_blockaddr(host->mmc->card))

                        off_scal=1;

                else

                        off_scal=512;

        }

        printk("pre dma read off %d\n", off_scal);

        cmd = host->cmd;

        if (!cmd) {

                pr_debug("no command\n");

                return;

        }

        data = cmd->data;

        if (!data) {

                pr_debug("no data\n");

                return;

        }

        /* Setup the next transfer */

        pr_debug("Using transfer index %d\n", host->transfer_index);

        sg = &data->sg[host->transfer_index++];

        printk("Using transfer index %d, sg offset %d\n", host->transfer_index,sg->offset);

        pr_debug("sg = %p\n", sg);

        printk("sg = %p\n", sg);

        host->dma_len = dma_map_sg(mmc_dev(host->mmc), sg, data->sg_len,  DMA_FROM_DEVICE);

        printk(KERN_ALERT "dma address = %d, sg_dma_len %d, length = %d, sg_dma_len %d\n", sg_dma_address(&data->sg[0]),  sg_dma_len(&data->sg[0]), sg->length, host->dma_len);

        for (i = 0; i < host->dma_len; i++) {

                unsigned int length = sg_dma_len(&data->sg[i]);

                if (length >= 512)

                        length /=512;

                else

                        length = 1;

                printk(KERN_ALERT "DMA LEN %d\n", length);

                //XXX:512 SD 1.0 card only.

                for (j = 0; j< length;j++) {

                        pr_debug("dma address = %d, length = %d\n", sg_dma_address(&data->sg[i]), sg->length);

                        printk(KERN_ALERT "dma address = %d, length = %d, sg_dma_len %d\n", (sg_dma_address(&data->sg[i])+512*j), length, host->dma_len);

                        writel((sg_dma_address(&data->sg[i])+512*j), host->base + BD_RX);

                        wmb();

                        writel(cmd->arg+off_scal*j, host->base + BD_RX);

                }

        }

        DAT_IRQ_ON (host,(TRE|FIFOE|MRC|TRS));

        pr_debug("pre dma read done\n");

}

static void ocores_pre_dma_write(struct ocores_host *host)

{

        int i,j;

        int off_scal;

        struct scatterlist *sg;

        struct mmc_command *cmd;

        struct mmc_data *data;

        off_scal=512;

        if (host->mmc->card!= NULL){

                if (mmc_card_blockaddr(host->mmc->card))

                        off_scal=1;

                else

                        off_scal=512;

        }

        printk("pre dma write off %d\n", off_scal);

        cmd = host->cmd;

        if (!cmd) {

                pr_debug("no command\n");

                return;

        }

        data = cmd->data;

        if (!data) {

                pr_debug("no data\n");

                return;

        }

        /* Setup the next transfer */

        pr_debug("Using transfer index %d\n", host->transfer_index);

        sg = &data->sg[host->transfer_index++];

        printk("Using transfer index %d, sg offset %d\n", host->transfer_index,sg->offset);

        pr_debug("sg = %p\n", sg);

        printk("sg = %p\n", sg);

        host->dma_len = dma_map_sg(mmc_dev(host->mmc), sg, data->sg_len,  DMA_TO_DEVICE);

        printk(KERN_ALERT "dma address = %d, sg_dma_len %d, length = %d, sg_dma_len %d\n", sg_dma_address(&data->sg[0]),  sg_dma_len(&data->sg[0]), sg->length, host->dma_len);

        for (i = 0; i < host->dma_len; i++) {

                unsigned int length = sg_dma_len(&data->sg[i]);

                if (length >= 512)

                        length /=512;

                else

                        length = 1;

                printk(KERN_ALERT "DMA LEN %d\n", length);

                //XXX:512 SD 1.0 card only.

                for (j = 0; j< length;j++) {

                        pr_debug("dma address = %d, length = %d\n", sg_dma_address(&data->sg[i]), sg->length);

                        printk(KERN_ALERT "dma address = %d, length = %d, sg_dma_len %d\n", (sg_dma_address(&data->sg[i])+512*j), length, host->dma_len);

                        writel((sg_dma_address(&data->sg[i])+512*j), host->base + BD_TX);

                        wmb();

                        writel(cmd->arg+off_scal*j, host->base + BD_TX);

                }

        }

        DAT_IRQ_ON (host,(TRE|FIFOE|MRC|TRS));

        pr_debug("pre dma read done\n");

}

static void ocores_start_cmd(struct ocores_host *host, struct mmc_command *cmd)

{

        unsigned int cmd_arg, cmd_command=0;

        struct mmc_data *data = cmd->data;

        //WARN_ON(host->cmd != NULL);

        host->cmd = cmd;

        //XXX:opcode == 51 not supported by hardware, hack here     

        if (data && ( cmd->opcode != 51)) {

                if ( data->blksz & 0x3 ) {

                        pr_debug("Unsupported block size\n");

                        cmd->error = -EINVAL;

                        mmc_request_done(host->mmc, host->mrq);

                        return;

                }

                data->bytes_xfered = 0;

                host->transfer_index = 0;

                host->in_use_index = 0;

                if (data->flags & MMC_DATA_READ){  //Handle a read

                        printk(KERN_ALERT "%s: Data read\n", __FUNCTION__);

                        host->buffer = NULL;

                        host->total_length = 0;

                        ocores_pre_dma_read(host); //Set up BD

                }

                else if (data->flags & MMC_DATA_WRITE){ //Handle write

                        printk(KERN_ALERT "%s: Data write\n", __FUNCTION__);    //cmdr |= AT91_MCI_TRCMD_START;

                        /*host->buffer = dma_alloc_coherent(NULL,

                                        host->total_length,

                                        &host->physical_address, GFP_KERNEL); */

                        host->total_length = 0;

                        ocores_pre_dma_write(host); //Set up BD

                }

                if (data->flags & MMC_DATA_STREAM)

                        printk(KERN_ALERT "%s: MMC_DATA_STREAM\n", __FUNCTION__);

                if (data->blocks > 1)

                        printk(KERN_ALERT "%s: data->blocks %d  > 1 \n", __FUNCTION__, data->blocks);

                        /*

                        host->total_length = block_length * blocks;

                        host->buffer = dma_alloc_coherent(NULL,

                                        host->total_length,

                                        &host->physical_address, GFP_KERNEL);

                        at91_mci_sg_to_dma(host, data);

                        pr_debug("Transmitting %d bytes\n", host->total_length);

                        at91_mci_write(host, ATMEL_PDC_TPR, host->physical_address);

                        at91_mci_write(host, ATMEL_PDC_TCR, host->total_length / 4);

                        ier = AT91_MCI_CMDRDY; */

        }

        else{

                        //Set up command

                cmd_arg = cmd->arg;

                cmd_command |= cmd->opcode << 8;

                cmd_command |= host->word_cnt << 6;

                if ( mmc_resp_type(cmd) == MMC_RSP_CRC  )

                        cmd_command |= CRCE;

                if ( mmc_resp_type(cmd) == MMC_RSP_OPCODE  )

                        cmd_command |= CICE;

                switch (mmc_resp_type(cmd)) {

                case MMC_RSP_NONE:

                        cmd_command |= MMCOC_RSP_NONE;

                        break;

                case MMC_RSP_R1:

                        cmd_command |= MMCOC_RSP_48;

                        break;

                case MMC_RSP_R1B:

                        cmd_command |= MMCOC_RSP_48;

                        break;

                case MMC_RSP_R2:

                        cmd_command |= MMCOC_RSP_136;

                        break;

                case MMC_RSP_R3:

                        cmd_command |= MMCOC_RSP_48;

                        break;

                default:

                        printk(KERN_INFO "mmc_ocores: unhandled response type %02x\n",

                               mmc_resp_type(cmd));

                }

                 //Send Command

                CMD_IRQ_ON (host,(ECC|EEI));

                writel(cmd_command, host->base + SD_COMMAND);

                wmb();

                writel(cmd_arg, host->base + SD_ARG);

                printk(KERN_ALERT "%s: cmd_arg = %08x\n", __FUNCTION__, cmd_arg);

                printk(KERN_ALERT "%s: cmd_command   = %08x\n", __FUNCTION__, cmd_command);

        }

        oc_host=host;

}

static void ocores_process_next(struct ocores_host *host)

{

        host->word_cnt=0;

        if (!(host->flags & FL_SENT_COMMAND)) {

                host->flags |= FL_SENT_COMMAND;

                ocores_start_cmd(host, host->mrq->cmd);

        }

        else if ((!(host->flags & FL_SENT_STOP)) && host->mrq->stop) {

                host->flags |= FL_SENT_STOP;

                ocores_start_cmd(host, host->mrq->stop);

        }

}

static void ocores_request(struct mmc_host *mmc, struct mmc_request *mrq)

{

        struct ocores_host *host = mmc_priv(mmc);

        //unsigned int cmdr, mr;

        printk(KERN_ALERT "%s: mrq->cmd->opcode = %08x\n", __FUNCTION__, mrq->cmd->opcode);

        printk(KERN_ALERT "%s: mrq->cmd->arg    = %08x\n", __FUNCTION__, mrq->cmd->arg);

        //WARN_ON(host->mrq != NULL);

        host->mrq = mrq;

        host->flags = 0;

        ocores_process_next(host);

        printk(KERN_ALERT "%s: exit\n", __FUNCTION__);

}

static int ocores_get_ro(struct mmc_host *mmc)

{

        /* struct ocores_host *host = mmc_priv(mmc); */

        printk(KERN_ALERT "%s: enter\n", __FUNCTION__);

        /* /\* Host doesn't support read only detection so assume writeable *\/ */

        return 0;

}

static void ocores_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)

{

        struct ocores_host *host = mmc_priv(mmc);

        int clk_div, cmd_timeout;

        /* struct ocores_host *host = mmc_priv(mmc); */

        printk(KERN_ALERT "%s: clock = 0x%08x\n", __FUNCTION__, ios->clock);

        printk(KERN_ALERT "%s: vdd = 0x%04x\n", __FUNCTION__, ios->vdd);

        printk(KERN_ALERT "%s: bus_mode = 0x%02x\n", __FUNCTION__, ios->bus_mode);

        printk(KERN_ALERT "%s: power_mode = 0x%02x\n", __FUNCTION__, ios->power_mode);

        printk(KERN_ALERT "%s: bus_width = 0x%02x\n", __FUNCTION__, ios->bus_width);

        printk(KERN_ALERT "%s: timing = 0x%02x\n", __FUNCTION__, ios->timing);

        //Set clock divider and timeout registers

        printk(KERN_ALERT "%s: host->base = %p\n", __FUNCTION__, host->base);

        if (ios->clock == 0) {

                //ocores_mci_write (host, SD_SOFTWARE_RST, SD_DISABLE);

        }

        else if (ios->clock != host->clock)

        {

                host->clock = ios->clock;

                writel(SD_DISABLE, host->base + SD_SOFTWARE_RST);

                clk_div = ((SYS_CLK / ios->clock)-2 )/ 2;

                cmd_timeout = ((SYS_CLK/ios->clock) * 512);

                printk(KERN_ALERT " clk_div = 0x%02x\n", clk_div);

                printk(KERN_ALERT " cmd_timeout = 0x%02x\n", cmd_timeout);

                writel (clk_div, host->base  + SD_CLOCK_DIVIDER);

                writel (cmd_timeout, host->base  + SD_TIMEOUT);

                writel(SD_ENABLE, host->base + SD_SOFTWARE_RST);

        }

}

static irqreturn_t ocores_irq_cmd(int irq, void *devid)

{

         struct ocores_host *host = (struct ocores_host *) devid;

         disable_irq(host->irq_cmd);

                //printk(KERN_ALERT "%s: IRQ START***** Normal In  = %08x\n", __FUNCTION__, readl(host->base + SD_NORMAL_INT_STATUS));

         host->registers.normal_int_status  = readl(host->base + SD_NORMAL_INT_STATUS);

         rmb();

         host->registers.error_int_status  = readl(host->base + SD_ERROR_INT_STATUS);

         writel(0,host->base + SD_NORMAL_INT_STATUS);

         writel(0,host->base + SD_ERROR_INT_STATUS);

         //printk(KERN_ALERT "%s: IRQ END***** Error In  = %08x\n", __FUNCTION__, readl(host->base + SD_ERROR_INT_STATUS));

         tasklet_schedule(&host->finish_cmd);

         CMD_IRQ_OFF (host,(ECC|EEI));

         enable_irq(host->irq_cmd);

         return IRQ_HANDLED;

}

static irqreturn_t ocores_irq_dat(int irq, void *devid)

{

         struct ocores_host *host = (struct ocores_host *) devid;

         disable_irq(host->irq_dat);

         printk(KERN_ALERT "%s: DAT IRQ START***** Normal In  = %08x\n", __FUNCTION__, readl(host->base + SD_BD_ISR));

         host->registers.data_int_status  = readl(host->base + SD_BD_ISR);

         writel(0,host->base + SD_BD_ISR);

         tasklet_schedule(&host->finish_data);

         enable_irq(host->irq_dat);

         return IRQ_HANDLED;

}

static const struct mmc_host_ops ocores_ops = {

        .request                = ocores_request,

        .get_ro                 = ocores_get_ro,

        .set_ios                = ocores_set_ios,

        /* .enable_sdio_irq     = ocores_enable_sdio_irq, */

};

static int ocores_probe(struct platform_device *pdev)

{

        struct mmc_host *mmc;

        struct ocores_host *host = NULL;

        struct resource *r;

        int ret;

        printk(KERN_ALERT "%s: enter\n", __FUNCTION__);

        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);

        printk(KERN_ALERT "%s: resource %x, %x\n", __FUNCTION__, r->start, r->end);

        r = request_mem_region(r->start, r->end - r->start, DRIVER_NAME);

        if (!r) {

                return -EBUSY;

        }

        mmc = mmc_alloc_host(sizeof(struct ocores_host), &pdev->dev);

        if (!mmc) {

                ret = -ENOMEM;

                goto out;

        }

        mmc->ops = &ocores_ops;

        mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;

        mmc->caps = MMC_CAP_4_BIT_DATA;

        mmc->f_min = 700000;  //SYS_CLK  60; 0.7 Mhz

        mmc->f_max = 4166666;  //SYS_CLK;   4.166 666 mhz

        mmc->max_blk_count =  8;//8; //XXX: 8

        mmc->max_hw_segs = 1;

        mmc->max_blk_size = MMCOC_MAX_BLOCK_SIZE;

        //mmc->max_seg_size = mmc->max_blk_count * mmc->max_blk_size;

        mmc->max_seg_size = PAGE_SIZE;

        mmc->max_req_size = mmc->max_seg_size;

        mmc->max_phys_segs = 1; //BD size

        host = mmc_priv(mmc);

         /*XXX:  */

        host->clock = 0;

        host->mmc = mmc;

        host->cmdat = 0;

        host->registers.normal_int_status =0;

        printk("Free FBD \n");

        host->free_tx_bd=0;

        host->free_rx_bd=0;

        printk("Free EBD \n");

        tasklet_init(&host->finish_cmd, ocores_tasklet_finish_cmd,

                     (unsigned long) host);

        tasklet_init(&host->finish_data, ocores_tasklet_finish_data,

                     (unsigned long) host);

        spin_lock_init(&host->lock);

        host->res = r;

        host->base = ioremap(r->start, r->end - r->start +1);

        /* host->base = (void *)r->start; */

        if (!host->base) {

                ret = -ENOMEM;

                goto out;

        }

        host->free_tx_bd=readl( host->base + BD_STATUS );

        host->free_tx_bd=host->free_tx_bd & 0x00ff;

        printk("Free TX BD = %d\n", host->free_tx_bd);

        host->free_rx_bd=readl( host->base + BD_STATUS );

        host->free_rx_bd=(host->free_rx_bd & 0xff00)>>8;

        printk("Free TX BD = %d\n", host->free_rx_bd);

        host->pdata = pdev->dev.platform_data;

        mmc->ocr_avail = host->pdata->ocr_mask;

        host->irq_cmd = platform_get_irq_byname(pdev, "cmd_irq");

        ret = request_irq(host->irq_cmd, ocores_irq_cmd, IRQF_DISABLED, DRIVER_NAME, host);

        printk(KERN_ALERT "%s: IRQ dat resource  %x\n", __FUNCTION__, host->irq_cmd );

        printk(KERN_ALERT "%s: RET cmd irq %x\n", __FUNCTION__, ret);

        if (ret)

                goto out;

        disable_irq(host->irq_cmd);

        host->irq_dat = platform_get_irq_byname(pdev, "dat_irq");

        ret = request_irq(host->irq_dat, ocores_irq_dat, IRQF_DISABLED, DRIVER_NAME, host);

        printk(KERN_ALERT "%s: IRQ dat resource  %x\n", __FUNCTION__, host->irq_dat );

        printk(KERN_ALERT "%s: RET Dat irq  %x\n", __FUNCTION__, ret);

        if (ret)

                goto out;

        disable_irq(host->irq_dat);

        enable_irq(host->irq_cmd);

        enable_irq(host->irq_dat);

        printk(KERN_ALERT "%s: host->base = %p\n", __FUNCTION__, host->base);

        printk(KERN_ALERT "%s: SD_BLOCK = %08x\n", __FUNCTION__, readl(host->base + SD_BLOCK));

        printk(KERN_ALERT "%s: host->pdata->ocr_mask = %08x\n", __FUNCTION__, host->pdata->ocr_mask);

        oc_host=host;

        mmc_add_host(mmc);

        printk(KERN_ALERT "%s: exit\n", __FUNCTION__);

        return 0;

 out:

        printk(KERN_ALERT "%s: ERROR REQUESTINING RESOURCES\n", __FUNCTION__);

        if (mmc) {

                mmc_free_host(mmc);

        }

        release_resource(r);

        return ret;

}

static void ocores_tasklet_finish_cmd(unsigned long param)

{

        struct ocores_host *host = (struct ocores_host *) param;

        struct mmc_data *data;

        struct scatterlist *sg;

        data = host->cmd->data;

        sg = &data->sg[0];

        printk(KERN_ALERT " CMD TASKLET RUNNS************\n");