Re: [RFC PATCH 2/2] MMC: SD/MMC Host Controller for Wondermedia WM8505/WM8650

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Mon, 2012-10-15 at 21:32 +0900, Girish K S wrote:
> On 15 October 2012 17:24, Tony Prisk <linux@xxxxxxxxxxxxxxx> wrote:
> > This patch adds support for the SD/MMC host controller found
> > on Wondermedia 8xxx series SoCs, currently supported under
> > arm/arch-vt8500.
> >
> > Signed-off-by: Tony Prisk <linux@xxxxxxxxxxxxxxx>
> > ---
> >  drivers/mmc/host/Kconfig     |   12 +
> >  drivers/mmc/host/Makefile    |    1 +
> >  drivers/mmc/host/wmt-sdmmc.c |  983 ++++++++++++++++++++++++++++++++++++++++++
> >  3 files changed, 996 insertions(+)
> >  create mode 100644 drivers/mmc/host/wmt-sdmmc.c
> >
> > diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
> > index 9bf10e7..7f4377b 100644
> > --- a/drivers/mmc/host/Kconfig
> > +++ b/drivers/mmc/host/Kconfig
> > @@ -621,3 +621,15 @@ config MMC_USHC
> >
> >           Note: These controllers only support SDIO cards and do not
> >           support MMC or SD memory cards.
> > +
> > +config MMC_WMT
> > +       tristate "Wondermedia SD/MMC Host Controller support"
> > +       depends on ARCH_VT8500
> > +       default y
> > +       help
> > +         This selects support for the SD/MMC Host Controller on
> > +         Wondermedia WM8505/WM8650 based SoCs.
> > +
> > +         To compile this driver as a module, choose M here: the
> > +         module will be called wmt-sdmmc.
> > +
> > diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
> > index 17ad0a7..9c91f1f 100644
> > --- a/drivers/mmc/host/Makefile
> > +++ b/drivers/mmc/host/Makefile
> > @@ -45,6 +45,7 @@ obj-$(CONFIG_MMC_SH_MMCIF)    += sh_mmcif.o
> >  obj-$(CONFIG_MMC_JZ4740)       += jz4740_mmc.o
> >  obj-$(CONFIG_MMC_VUB300)       += vub300.o
> >  obj-$(CONFIG_MMC_USHC)         += ushc.o
> > +obj-$(CONFIG_MMC_WMT)          += wmt-sdmmc.o
> >
> >  obj-$(CONFIG_MMC_SDHCI_PLTFM)          += sdhci-pltfm.o
> >  obj-$(CONFIG_MMC_SDHCI_CNS3XXX)                += sdhci-cns3xxx.o
> > diff --git a/drivers/mmc/host/wmt-sdmmc.c b/drivers/mmc/host/wmt-sdmmc.c
> > new file mode 100644
> > index 0000000..def1ec9
> > --- /dev/null
> > +++ b/drivers/mmc/host/wmt-sdmmc.c
> > @@ -0,0 +1,983 @@
> > +/*
> > + *  WM8505/WM8650 SD/MMC Host Controller
> > + *
> > + *  Copyright (C) 2010 Tony Prisk
> > + *  Copyright (C) 2008 WonderMedia Technologies, Inc.
> > + *
> > + *  This program is free software; you can redistribute it and/or modify
> > + *  it under the terms of the GNU General Public License version 2 as
> > + *  published by the Free Software Foundation
> > + */
> > +
> > +#include <linux/init.h>
> > +#include <linux/module.h>
> > +#include <linux/platform_device.h>
> > +#include <linux/ioport.h>
> > +#include <linux/errno.h>
> > +#include <linux/dma-mapping.h>
> > +#include <linux/delay.h>
> > +#include <linux/io.h>
> > +#include <linux/irq.h>
> > +#include <linux/clk.h>
> > +#include <linux/gpio.h>
> > +
> > +#include <linux/of.h>
> > +#include <linux/of_address.h>
> > +#include <linux/of_irq.h>
> > +
> > +#include <linux/mmc/host.h>
> > +#include <linux/mmc/mmc.h>
> > +#include <linux/mmc/sd.h>
> > +
> > +#include <asm/byteorder.h>
> > +
> > +
> > +#define DRIVER_NAME "wmt-sdhc"
> > +
> > +
> > +/* MMC/SD controller registers */
> > +#define SDMMC_CTLR                     0x00
> > +#define SDMMC_CMD                      0x01
> > +#define SDMMC_RSPTYPE                  0x02
> > +#define SDMMC_ARG                      0x04
> > +#define SDMMC_BUSMODE                  0x08
> > +#define SDMMC_BLKLEN                   0x0C
> > +#define SDMMC_BLKCNT                   0x0E
> > +#define SDMMC_RSP                      0x10
> > +#define SDMMC_CBCR                     0x20
> > +#define SDMMC_INTMASK0                 0x24
> > +#define SDMMC_INTMASK1                 0x25
> > +#define SDMMC_STS0                     0x28
> > +#define SDMMC_STS1                     0x29
> > +#define SDMMC_STS2                     0x2A
> > +#define SDMMC_STS3                     0x2B
> > +#define SDMMC_RSPTIMEOUT               0x2C
> > +#define SDMMC_CLK                      0x30    /* VT8500 only */
> > +#define SDMMC_EXTCTRL                  0x34
> > +#define SDMMC_SBLKLEN                  0x38
> > +#define SDMMC_DMATIMEOUT               0x3C
> > +
> > +
> > +/* SDMMC_CTLR bit fields */
> > +#define CTLR_CMD_START                 0x01
> > +#define CTLR_CMD_WRITE                 0x04
> > +#define CTLR_FIFO_RESET                        0x08
> > +
> > +/* SDMMC_BUSMODE bit fields */
> > +#define BM_SPI_MODE                    0x01
> > +#define BM_FOURBIT_MODE                        0x02
> > +#define BM_EIGHTBIT_MODE               0x04
> > +#define BM_SD_OFF                      0x10
> > +#define BM_SPI_CS                      0x20
> > +#define BM_SD_POWER                    0x40
> > +#define BM_SOFT_RESET                  0x80
> > +#define BM_ONEBIT_MASK                 0xFD
> > +
> > +/* SDMMC_BLKLEN bit fields */
> > +#define BLKL_CRCERR_ABORT              0x0800
> > +#define BLKL_CD_POL_HIGH               0x1000
> > +#define BLKL_GPI_CD                    0x2000
> > +#define BLKL_DATA3_CD                  0x4000
> > +#define BLKL_INT_ENABLE                        0x8000
> > +
> > +/* SDMMC_INTMASK0 bit fields */
> > +#define INT0_MBLK_TRAN_DONE_INT_EN     0x10
> > +#define INT0_BLK_TRAN_DONE_INT_EN      0x20
> > +#define INT0_CD_INT_EN                 0x40
> > +#define INT0_DI_INT_EN                 0x80
> > +
> > +/* SDMMC_INTMASK1 bit fields */
> > +#define INT1_CMD_RES_TRAN_DONE_INT_EN  0x02
> > +#define INT1_CMD_RES_TOUT_INT_EN       0x04
> > +#define INT1_MBLK_AUTO_STOP_INT_EN     0x08
> > +#define INT1_DATA_TOUT_INT_EN          0x10
> > +#define INT1_RESCRC_ERR_INT_EN         0x20
> > +#define INT1_RCRC_ERR_INT_EN           0x40
> > +#define INT1_WCRC_ERR_INT_EN           0x80
> > +
> > +/* SDMMC_STS0 bit fields */
> > +#define STS0_WRITE_PROTECT             0x02
> > +#define STS0_CD_DATA3                  0x04
> > +#define STS0_CD_GPI                    0x08
> > +#define STS0_MBLK_DONE                 0x10
> > +#define STS0_BLK_DONE                  0x20
> > +#define STS0_CARD_DETECT               0x40
> > +#define STS0_DEVICE_INS                        0x80
> > +
> > +/* SDMMC_STS1 bit fields */
> > +#define STS1_SDIO_INT                  0x01
> > +#define STS1_CMDRSP_DONE               0x02
> > +#define STS1_RSP_TIMEOUT               0x04
> > +#define STS1_AUTOSTOP_DONE             0x08
> > +#define STS1_DATA_TIMEOUT              0x10
> > +#define STS1_RSP_CRC_ERR               0x20
> > +#define STS1_RCRC_ERR                  0x40
> > +#define STS1_WCRC_ERR                  0x80
> > +
> > +/* SDMMC_STS2 bit fields */
> > +#define STS2_CMD_RES_BUSY              0x10
> > +#define STS2_DATARSP_BUSY              0x20
> > +#define STS2_DIS_FORCECLK              0x80
> > +
> > +
> > +/* MMC/SD DMA Controller Registers */
> > +#define SDDMA_GCR                      0x100
> > +#define SDDMA_IER                      0x104
> > +#define SDDMA_ISR                      0x108
> > +#define SDDMA_DESPR                    0x10C
> > +#define SDDMA_RBR                      0x110
> > +#define SDDMA_DAR                      0x114
> > +#define SDDMA_BAR                      0x118
> > +#define SDDMA_CPR                      0x11C
> > +#define SDDMA_CCR                      0x120
> > +
> > +
> > +/* SDDMA_GCR bit fields */
> > +#define DMA_GCR_DMA_EN                 0x00000001
> > +#define DMA_GCR_SOFT_RESET             0x00000100
> > +
> > +/* SDDMA_IER bit fields */
> > +#define DMA_IER_INT_EN                 0x00000001
> > +
> > +/* SDDMA_ISR bit fields */
> > +#define DMA_ISR_INT_STS                        0x00000001
> > +
> > +/* SDDMA_RBR bit fields */
> > +#define DMA_RBR_FORMAT                 0x40000000
> > +#define DMA_RBR_END                    0x80000000
> > +
> > +/* SDDMA_CCR bit fields */
> > +#define DMA_CCR_RUN                    0x00000080
> > +#define DMA_CCR_IF_TO_PERIPHERAL       0x00000000
> > +#define DMA_CCR_PERIPHERAL_TO_IF       0x00400000
> > +
> > +/* SDDMA_CCR event status */
> > +#define DMA_CCR_EVT_NO_STATUS          0x00000000
> > +#define DMA_CCR_EVT_UNDERRUN           0x00000001
> > +#define DMA_CCR_EVT_OVERRUN            0x00000002
> > +#define DMA_CCR_EVT_DESP_READ          0x00000003
> > +#define DMA_CCR_EVT_DATA_RW            0x00000004
> > +#define DMA_CCR_EVT_EARLY_END          0x00000005
> > +#define DMA_CCR_EVT_SUCCESS            0x0000000F
> > +
> > +#define PDMA_READ                      0x00
> > +#define PDMA_WRITE                     0x01
> > +
> > +#define WMT_SD_POWER_OFF               0
> > +#define WMT_SD_POWER_ON                        1
> > +
> > +struct wmt_dma_descriptor {
> > +       u32 flags;
> > +       u32 data_buffer_addr;
> > +       u32 branch_addr;
> > +       u32 reserved1;
> > +};
> > +
> > +struct wmt_mci_priv {
> > +       struct mmc_host *mmc;
> > +       void __iomem *sdmmc_base;
> > +
> > +       int irq_regular;
> > +       int irq_dma;
> > +
> > +       void *dma_desc_buffer;
> > +       dma_addr_t dma_desc_device_addr;
> > +
> > +       struct completion cmdcomp;
> > +       struct completion datacomp;
> > +
> > +       struct completion *comp_cmd;
> > +       struct completion *comp_dma;
> > +
> > +       struct mmc_request *req;
> > +       struct mmc_command *cmd;
> > +
> > +       struct clk *clk_sdmmc;
> > +
> > +       u8 power_inverted;
> > +       u8 cd_inverted;
> > +};
> > +
> > +static void wmt_set_sd_power(struct wmt_mci_priv *priv, int enable)
> > +{
> > +       u32 reg_tmp;
> > +       if (enable) {
> > +               if (priv->power_inverted) {
> > +                       reg_tmp = readb(priv->sdmmc_base + SDMMC_BUSMODE);
> > +                       writeb(reg_tmp | BM_SD_OFF,
> > +                               priv->sdmmc_base + SDMMC_BUSMODE);
> > +               } else {
> > +                       reg_tmp = readb(priv->sdmmc_base + SDMMC_BUSMODE);
> > +                       writeb(reg_tmp & (~BM_SD_OFF),
> > +                               priv->sdmmc_base + SDMMC_BUSMODE);
> > +               }
> > +       } else {
> > +               if (priv->power_inverted) {
> > +                       reg_tmp = readb(priv->sdmmc_base + SDMMC_BUSMODE);
> > +                       writeb(reg_tmp & (~BM_SD_OFF),
> > +                               priv->sdmmc_base + SDMMC_BUSMODE);
> > +               } else {
> > +                       reg_tmp = readb(priv->sdmmc_base + SDMMC_BUSMODE);
> > +                       writeb(reg_tmp | BM_SD_OFF,
> > +                               priv->sdmmc_base + SDMMC_BUSMODE);
> > +               }
> > +       }
> > +}
> > +
> > +static void wmt_mci_read_response(struct mmc_host *mmc)
> > +{
> > +       struct wmt_mci_priv *priv;
> > +       int idx1, idx2;
> > +       u8 tmp_resp;
> > +       u32 response;
> > +
> > +       priv = mmc_priv(mmc);
> > +
> > +       for (idx1 = 0; idx1 < 4; idx1++) {
> > +               response = 0;
> > +               for (idx2 = 0; idx2 < 4; idx2++) {
> > +                       if ((idx1 == 3) && (idx2 == 3))
> > +                               tmp_resp = readb(priv->sdmmc_base + SDMMC_RSP);
> > +                       else
> > +                               tmp_resp = readb(priv->sdmmc_base + SDMMC_RSP +
> > +                                       (idx1*4) + idx2 + 1);
> > +                       response |= (tmp_resp << (idx2 * 8));
> > +               }
> > +               priv->cmd->resp[idx1] = cpu_to_be32(response);
> > +       }
> > +}
> > +
> > +static void wmt_mci_start_command(struct wmt_mci_priv *priv)
> > +{
> > +       u32 reg_tmp;
> > +
> > +       reg_tmp = readb(priv->sdmmc_base + SDMMC_CTLR);
> > +       writeb(reg_tmp | CTLR_CMD_START, priv->sdmmc_base + SDMMC_CTLR);
> > +}
> > +
> > +static int wmt_mci_send_command(struct mmc_host *mmc, u8 command, u8 cmdtype,
> > +               u32 arg, u8 rsptype)
> > +{
> > +       struct wmt_mci_priv *priv;
> > +       u32 reg_tmp;
> > +
> > +       priv = mmc_priv(mmc);
> > +
> > +       /* write command, arg, resptype registers */
> > +       writeb(command, priv->sdmmc_base + SDMMC_CMD);
> > +       writel(arg, priv->sdmmc_base + SDMMC_ARG);
> > +       writeb(rsptype, priv->sdmmc_base + SDMMC_RSPTYPE);
> > +
> > +       /* reset response FIFO */
> > +       reg_tmp = readb(priv->sdmmc_base + SDMMC_CTLR);
> > +       writeb(reg_tmp | CTLR_FIFO_RESET, priv->sdmmc_base + SDMMC_CTLR);
> > +
> > +       /* ensure clock enabled - VT3465 */
> > +       wmt_set_sd_power(priv, WMT_SD_POWER_ON);
> > +
> > +       /* clear status bits */
> > +       writeb(0xFF, priv->sdmmc_base + SDMMC_STS0);
> > +       writeb(0xFF, priv->sdmmc_base + SDMMC_STS1);
> > +       writeb(0xFF, priv->sdmmc_base + SDMMC_STS2);
> > +       writeb(0xFF, priv->sdmmc_base + SDMMC_STS3);
> > +
> > +       /* set command type */
> > +       reg_tmp = readb(priv->sdmmc_base + SDMMC_CTLR);
> > +       writeb((reg_tmp & 0x0F) | (cmdtype << 4), priv->sdmmc_base +
> > +               SDMMC_CTLR);
> > +
> > +       return 0;
> > +}
> > +
> > +static void wmt_mci_disable_dma(struct wmt_mci_priv *priv)
> > +{
> > +       writel(DMA_ISR_INT_STS, priv->sdmmc_base + SDDMA_ISR);
> > +       writel(0, priv->sdmmc_base + SDDMA_IER);
> > +}
> > +
> > +static void wmt_complete_data_request(struct wmt_mci_priv *priv)
> > +{
> > +       struct mmc_request *req;
> > +       req = priv->req;
> > +
> > +       req->data->bytes_xfered = req->data->blksz * req->data->blocks;
> > +
> > +       /* unmap the DMA pages used for write data */
> > +       if (req->data->flags & MMC_DATA_WRITE)
> > +               dma_unmap_sg(mmc_dev(priv->mmc), req->data->sg,
> > +                       req->data->sg_len, DMA_TO_DEVICE);
> > +       else
> > +               dma_unmap_sg(mmc_dev(priv->mmc), req->data->sg,
> > +                       req->data->sg_len, DMA_FROM_DEVICE);
> > +
> > +       /* Check if the DMA ISR returned a data error */
> > +       if ((req->cmd->error) || (req->data->error))
> > +               mmc_request_done(priv->mmc, req);
> > +       else {
> > +               wmt_mci_read_response(priv->mmc);
> > +               if (!req->data->stop)
> > +                       /* single-block read/write requests end here*/
> > +                       mmc_request_done(priv->mmc, req);
> > +               else {
> > +                       /*
> > +                        * we change the priv->cmd variable so the response is
> > +                        * stored in the stop struct rather than the original
> > +                        * calling command struct
> > +                        */
> > +                       priv->comp_cmd = &priv->cmdcomp;
> > +                       init_completion(priv->comp_cmd);
> > +                       priv->cmd = req->data->stop;
> > +                       wmt_mci_send_command(priv->mmc, req->data->stop->opcode,
> > +                                               7, req->data->stop->arg, 9);
> > +                       wmt_mci_start_command(priv);
> > +               }
> > +       }
> > +}
> > +
> > +static irqreturn_t wmt_mci_dma_isr(int irq_num, void *data)
> > +{
> > +       struct mmc_host *mmc;
> > +       struct wmt_mci_priv *priv;
> > +
> > +       int status;
> > +
> > +       priv = (struct wmt_mci_priv *)data;
> > +       mmc = priv->mmc;
> > +
> > +       status = readl(priv->sdmmc_base + SDDMA_CCR) & 0x0F;
> > +
> > +       if (status != DMA_CCR_EVT_SUCCESS) {
> > +               pr_err("%s: DMA Error: Status = %d\n", __func__, status);
> > +               priv->req->data->error = -ETIMEDOUT;
> > +               complete(priv->comp_dma);
> > +               return IRQ_HANDLED;
> > +       }
> > +
> > +       priv->req->data->error = 0;
> > +
> > +       wmt_mci_disable_dma(priv);
> > +
> > +       complete(priv->comp_dma);
> > +
> > +       if (priv->comp_cmd)
> > +               if (completion_done(priv->comp_cmd))
> > +                       /*
> > +                        * if the command (regular) interrupt has already
> > +                        * completed, finish off the request otherwise we wait
> > +                        * for the command interrupt and finish from there.
> > +                        */
> > +                       wmt_complete_data_request(priv);
> > +
> > +       return IRQ_HANDLED;
> > +}
> > +
> > +static irqreturn_t wmt_mci_regular_isr(int irq_num, void *data)
> > +{
> > +       struct wmt_mci_priv *priv;
> > +       u32 status0;
> > +       u32 status1;
> > +       u32 status2;
> > +       u32 reg_tmp;
> > +       int cmd_done;
> > +
> > +       priv = (struct wmt_mci_priv *)data;
> > +       cmd_done = 0;
> > +       status0 = readb(priv->sdmmc_base + SDMMC_STS0);
> > +       status1 = readb(priv->sdmmc_base + SDMMC_STS1);
> > +       status2 = readb(priv->sdmmc_base + SDMMC_STS2);
> > +
> > +       /* Check for card insertion */
> > +       reg_tmp = readb(priv->sdmmc_base + SDMMC_INTMASK0);
> > +       if ((reg_tmp & INT0_DI_INT_EN) && (status0 & STS0_DEVICE_INS)) {
> > +               mmc_detect_change(priv->mmc, 0);
> > +               if (priv->cmd)
> > +                       priv->cmd->error = -ETIMEDOUT;
> > +               if (priv->comp_cmd)
> > +                       complete(priv->comp_cmd);
> > +               if (priv->comp_dma) {
> > +                       wmt_mci_disable_dma(priv);
> > +                       complete(priv->comp_dma);
> > +               }
> > +               writeb(STS0_DEVICE_INS, priv->sdmmc_base + SDMMC_STS0);
> > +               return IRQ_HANDLED;
> > +       }
> > +
> > +       if ((!priv->req->data) || ((priv->req->data->stop) &&
> > +                                       (priv->cmd == priv->req->data->stop))) {
> > +               /* handle non-data & stop_transmission requests */
> > +               if (status1 & STS1_CMDRSP_DONE) {
> > +                       priv->cmd->error = 0;
> > +                       cmd_done = 1;
> > +               } else
> > +               if ((status1 & STS1_RSP_TIMEOUT) ||
> > +                                       (status1 & STS1_DATA_TIMEOUT)) {
> > +                       priv->cmd->error = -ETIMEDOUT;
> > +                       cmd_done = 1;
> > +               }
> > +               if (cmd_done) {
> > +                       priv->comp_cmd = NULL;
> > +
> > +                       if (!priv->cmd->error)
> > +                               wmt_mci_read_response(priv->mmc);
> > +
> > +                       priv->cmd = NULL;
> > +
> > +                       mmc_request_done(priv->mmc, priv->req);
> > +               }
> > +       } else {
> > +               /* handle data requests */
> > +               if (status1 & STS1_CMDRSP_DONE) {
> > +                       if (priv->cmd)
> > +                               priv->cmd->error = 0;
> > +                       if (priv->comp_cmd)
> > +                               complete(priv->comp_cmd);
> > +               }
> > +
> > +               if ((status1 & STS1_RSP_TIMEOUT) ||
> > +                               (status1 & STS1_DATA_TIMEOUT)) {
> > +                       if (priv->cmd)
> > +                               priv->cmd->error = -ETIMEDOUT;
> > +                       if (priv->comp_cmd)
> > +                               complete(priv->comp_cmd);
> > +                       if (priv->comp_dma) {
> > +                               wmt_mci_disable_dma(priv);
> > +                               complete(priv->comp_dma);
> > +                       }
> > +               }
> > +
> > +               if (priv->comp_dma)
> > +                       /* if the dma interrupt has already completed, finish
> > +                        * off the request otherwise we wait for the DMA
> > +                        * interrupt and finish from there.
> > +                        */
> > +                       if (completion_done(priv->comp_dma))
> > +                               wmt_complete_data_request(priv);
> > +       }
> > +
> > +       writeb(status0, priv->sdmmc_base + SDMMC_STS0);
> > +       writeb(status1, priv->sdmmc_base + SDMMC_STS1);
> > +       writeb(status2, priv->sdmmc_base + SDMMC_STS2);
> > +
> > +       return IRQ_HANDLED;
> > +}
> > +
> > +static void wmt_reset_hardware(struct mmc_host *mmc)
> > +{
> > +       struct wmt_mci_priv *priv;
> > +       u32 reg_tmp;
> > +
> > +       priv = mmc_priv(mmc);
> > +
> > +       /* reset controller */
> > +       reg_tmp = readb(priv->sdmmc_base + SDMMC_BUSMODE);
> > +       writeb(reg_tmp | BM_SOFT_RESET, priv->sdmmc_base + SDMMC_BUSMODE);
> > +
> > +       /* reset response FIFO */
> > +       reg_tmp = readb(priv->sdmmc_base + SDMMC_CTLR);
> > +       writeb(reg_tmp | CTLR_FIFO_RESET, priv->sdmmc_base + SDMMC_CTLR);
> > +
> > +       /* enable GPI pin to detect card */
> > +       writew(BLKL_INT_ENABLE | BLKL_GPI_CD, priv->sdmmc_base + SDMMC_BLKLEN);
> > +
> > +       /* clear interrupt status */
> > +       writeb(0xFF, priv->sdmmc_base + SDMMC_STS0);
> > +       writeb(0xFF, priv->sdmmc_base + SDMMC_STS1);
> > +
> > +       /* setup interrupts */
> > +       writeb(INT0_CD_INT_EN | INT0_DI_INT_EN, priv->sdmmc_base +
> > +               SDMMC_INTMASK0);
> > +       writeb(INT1_DATA_TOUT_INT_EN | INT1_CMD_RES_TRAN_DONE_INT_EN |
> > +               INT1_CMD_RES_TOUT_INT_EN, priv->sdmmc_base + SDMMC_INTMASK1);
> > +
> > +       /* set the DMA timeout */
> > +       writew(8191, priv->sdmmc_base + SDMMC_DMATIMEOUT);
> > +
> > +       /* auto clock freezing enable */
> > +       reg_tmp = readb(priv->sdmmc_base + SDMMC_STS2);
> > +       writeb(reg_tmp | STS2_DIS_FORCECLK, priv->sdmmc_base + SDMMC_STS2);
> > +
> > +       /* set a default clock speed of 400Khz */
> > +       clk_set_rate(priv->clk_sdmmc, 400000);
> > +}
> > +
> > +static int wmt_dma_init(struct mmc_host *mmc)
> > +{
> > +       struct wmt_mci_priv *priv;
> > +
> > +       priv = mmc_priv(mmc);
> > +
> > +       writel(DMA_GCR_SOFT_RESET, priv->sdmmc_base + SDDMA_GCR);
> > +       writel(DMA_GCR_DMA_EN, priv->sdmmc_base + SDDMA_GCR);
> > +       if ((readl(priv->sdmmc_base + SDDMA_GCR) & DMA_GCR_DMA_EN) != 0)
> > +               return 0;
> > +       else
> > +               return 1;
> > +}
> > +
> > +static void wmt_dma_init_descriptor(struct wmt_dma_descriptor *desc,
> > +               u16 req_count, u32 buffer_addr, u32 branch_addr, int end)
> > +{
> > +       desc->flags = 0x40000000 | req_count;
> > +       if (end)
> > +               desc->flags |= 0x80000000;
> > +       desc->data_buffer_addr = buffer_addr;
> > +       desc->branch_addr = branch_addr;
> > +}
> > +
> > +static void wmt_dma_config(struct mmc_host *mmc, u32 descaddr, u8 dir)
> > +{
> > +       struct wmt_mci_priv *priv;
> > +       u32 reg_tmp;
> > +
> > +       priv = mmc_priv(mmc);
> > +
> > +       /* Enable DMA Interrupts */
> > +       writel(DMA_IER_INT_EN, priv->sdmmc_base + SDDMA_IER);
> > +
> > +       /* Write DMA Descriptor Pointer Register */
> > +       writel(descaddr, priv->sdmmc_base + SDDMA_DESPR);
> > +
> > +       writel(0x00, priv->sdmmc_base + SDDMA_CCR);
> > +
> > +       if (dir == PDMA_WRITE) {
> > +               reg_tmp = readl(priv->sdmmc_base + SDDMA_CCR);
> > +               writel(reg_tmp & DMA_CCR_IF_TO_PERIPHERAL, priv->sdmmc_base +
> > +                               SDDMA_CCR);
> > +       } else {
> > +               reg_tmp = readl(priv->sdmmc_base + SDDMA_CCR);
> > +               writel(reg_tmp | DMA_CCR_PERIPHERAL_TO_IF, priv->sdmmc_base +
> > +                               SDDMA_CCR);
> > +       }
> > +}
> > +
> > +static void wmt_dma_start(struct wmt_mci_priv *priv)
> > +{
> > +       u32 reg_tmp;
> > +
> > +       reg_tmp = readl(priv->sdmmc_base + SDDMA_CCR);
> > +       writel(reg_tmp | DMA_CCR_RUN, priv->sdmmc_base + SDDMA_CCR);
> > +}
> > +
> > +static void wmt_mci_request(struct mmc_host *mmc, struct mmc_request *req)
> > +{
> > +       struct wmt_mci_priv *priv;
> > +       struct wmt_dma_descriptor *desc;
> > +       u8 command;
> > +       u8 cmdtype;
> > +       u32 arg;
> > +       u8 rsptype;
> > +       u32 reg_tmp;
> > +
> > +       struct scatterlist *sg;
> > +       int i;
> > +       int sg_cnt;
> > +       int offset;
> > +       u32 dma_address;
> > +       int desc_cnt;
> > +
> > +       priv = mmc_priv(mmc);
> > +       priv->req = req;
> > +
> > +       /*
> > +        * Use the cmd variable to pass a pointer to the resp[] structure
> > +        * This is required on multi-block requests to pass the pointer to the
> > +        * stop command
> > +        */
> > +       priv->cmd = req->cmd;
> > +
> > +       command = req->cmd->opcode;
> > +       arg = req->cmd->arg;
> > +       rsptype = mmc_resp_type(req->cmd);
> > +       cmdtype = 0;
> > +
> > +       /* rsptype=7 only valid for SPI commands - should be =2 for SD */
> > +       if (rsptype == 7)
> > +               rsptype = 2;
> > +       /* rsptype=21 is R1B, convert for controller */
> > +       if (rsptype == 21)
> > +               rsptype = 9;
> > +
> > +       if (!req->data) {
> > +               wmt_mci_send_command(mmc, command, cmdtype, arg, rsptype);
> > +               wmt_mci_start_command(priv);
> > +               /* completion is now handled in the regular_isr() */
> > +       }
> > +       if (req->data) {
> > +               priv->comp_cmd = &priv->cmdcomp;
> > +               init_completion(priv->comp_cmd);
> > +
> > +               wmt_dma_init(mmc);
> > +
> > +               /* set controller data length */
> > +               reg_tmp = readw(priv->sdmmc_base + SDMMC_BLKLEN);
> > +               writew((reg_tmp & 0xF800) | (req->data->blksz - 1),
> > +                       priv->sdmmc_base + SDMMC_BLKLEN);
> > +
> > +               /* set controller block count */
> > +               writew(req->data->blocks, priv->sdmmc_base + SDMMC_BLKCNT);
> > +
> > +               desc = (struct wmt_dma_descriptor *)priv->dma_desc_buffer;
> > +
> > +               if (req->data->flags & MMC_DATA_WRITE) {
> > +                       sg_cnt = dma_map_sg(mmc_dev(mmc), req->data->sg,
> > +                                       req->data->sg_len, DMA_TO_DEVICE);
> > +                       cmdtype = 1;
> > +                       if (req->data->blocks > 1)
> > +                               cmdtype = 3;
> > +               } else {
> > +                       sg_cnt = dma_map_sg(mmc_dev(mmc), req->data->sg,
> > +                                       req->data->sg_len, DMA_FROM_DEVICE);
> > +                       cmdtype = 2;
> > +                       if (req->data->blocks > 1)
> > +                               cmdtype = 4;
> > +               }
> > +
> > +               dma_address = priv->dma_desc_device_addr + 16;
> > +               desc_cnt = 0;
> > +
> > +               for_each_sg(req->data->sg, sg, sg_cnt, i) {
> > +                       offset = 0;
> > +                       while (offset < sg_dma_len(sg)) {
> > +                               wmt_dma_init_descriptor(desc, req->data->blksz,
> > +                                       sg_dma_address(sg)+offset, dma_address,
> > +                                       0);
> > +                               desc++;
> > +                               desc_cnt++;
> > +                               offset += req->data->blksz;
> > +                               dma_address += 16;
> > +                               if (desc_cnt == req->data->blocks)
> > +                                       break;
> > +                       }
> > +               }
> > +               desc--;
> > +               desc->flags |= 0x80000000;
> > +
> > +               if (req->data->flags & MMC_DATA_WRITE)
> > +                       wmt_dma_config(mmc, priv->dma_desc_device_addr,
> > +                                       PDMA_WRITE);
> > +               else
> > +                       wmt_dma_config(mmc, priv->dma_desc_device_addr,
> > +                                       PDMA_READ);
> > +
> > +               wmt_mci_send_command(mmc, command, cmdtype, arg, rsptype);
> > +
> > +               priv->comp_dma = &priv->datacomp;
> > +               init_completion(priv->comp_dma);
> > +
> > +               wmt_dma_start(priv);
> > +               wmt_mci_start_command(priv);
> > +       }
> > +}
> > +
> > +static void wmt_mci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
> > +{
> > +       struct wmt_mci_priv *priv;
> > +       u32 reg_tmp;
> > +
> > +       priv = mmc_priv(mmc);
> > +
> > +       if (ios->power_mode == MMC_POWER_UP) {
> > +               wmt_reset_hardware(mmc);
> > +
> > +               wmt_set_sd_power(priv, WMT_SD_POWER_ON);
> > +       }
> > +       if (ios->power_mode == MMC_POWER_OFF) {
> > +               wmt_set_sd_power(priv, WMT_SD_POWER_OFF);
> > +       }
> > +
> > +       if (ios->clock != 0)
> > +               clk_set_rate(priv->clk_sdmmc, ios->clock);
> > +
> > +       switch (ios->bus_width) {
> > +       case MMC_BUS_WIDTH_8:
> > +               reg_tmp = readb(priv->sdmmc_base + SDMMC_EXTCTRL);
> > +               writeb(reg_tmp | 0x04, priv->sdmmc_base + SDMMC_EXTCTRL);
> > +               break;
> > +       case MMC_BUS_WIDTH_4:
> > +               reg_tmp = readb(priv->sdmmc_base + SDMMC_BUSMODE);
> > +               writeb(reg_tmp | BM_FOURBIT_MODE, priv->sdmmc_base +
> > +                       SDMMC_BUSMODE);
> > +
> > +               reg_tmp = readb(priv->sdmmc_base + SDMMC_EXTCTRL);
> > +               writeb(reg_tmp & 0xFB, priv->sdmmc_base + SDMMC_EXTCTRL);
> > +               break;
> > +       case MMC_BUS_WIDTH_1:
> > +               reg_tmp = readb(priv->sdmmc_base + SDMMC_BUSMODE);
> > +               writeb(reg_tmp & BM_ONEBIT_MASK, priv->sdmmc_base +
> > +                       SDMMC_BUSMODE);
> > +
> > +               reg_tmp = readb(priv->sdmmc_base + SDMMC_EXTCTRL);
> > +               writeb(reg_tmp & 0xFB, priv->sdmmc_base + SDMMC_EXTCTRL);
> > +               break;
> > +       }
> > +}
> > +
> > +static int wmt_mci_get_ro(struct mmc_host *mmc)
> > +{
> > +       struct wmt_mci_priv *priv = mmc_priv(mmc);
> > +
> > +       return !(readb(priv->sdmmc_base + SDMMC_STS0) & STS0_WRITE_PROTECT);
> > +}
> > +
> > +static int wmt_mci_get_cd(struct mmc_host *mmc)
> > +{
> > +       struct wmt_mci_priv *priv = mmc_priv(mmc);
> > +       u32 cd = (readb(priv->sdmmc_base + SDMMC_STS0) & STS0_CD_GPI) >> 3;
> > +
> > +       return !(cd ^ priv->cd_inverted);
> > +}
> > +
> > +static struct mmc_host_ops wmt_mci_ops = {
> > +       .request = wmt_mci_request,
> > +       .set_ios = wmt_mci_set_ios,
> > +       .get_ro = wmt_mci_get_ro,
> > +       .get_cd = wmt_mci_get_cd,
> > +};
> > +
> > +static int __devinit wmt_mci_probe(struct platform_device *pdev)
> > +{
> > +       struct mmc_host *mmc;
> > +       struct wmt_mci_priv *priv;
> > +       struct device_node *np = pdev->dev.of_node;
> > +       int ret;
> > +       int regular_irq, dma_irq;
> > +
> > +       if (!np) {
> > +               pr_err("%s: Missing SDMMC description in devicetree\n",
> > +                                                               __func__);
> > +               return -EFAULT;
> > +       }
> > +
> > +       regular_irq = irq_of_parse_and_map(np, 0);
> > +       dma_irq = irq_of_parse_and_map(np, 1);
> > +
> > +       if ((!regular_irq) | (!dma_irq)) {
> > +               pr_err("%s: Getting IRQs failed!\n", __func__);
> > +               ret = -ENXIO;
> > +               goto fail1;
> > +       }
> > +
> > +       mmc = mmc_alloc_host(sizeof(struct wmt_mci_priv), &pdev->dev);
> > +       if (!mmc) {
> > +               pr_err("%s: Failed to allocate mmc_host\n", __func__);
> > +               ret = -ENOMEM;
> > +               goto fail1;
> > +       }
> > +
> > +       mmc->ops = &wmt_mci_ops;
> > +       mmc->f_min = 390425;
> > +       mmc->f_max = 50000000;
> > +       mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
> > +       mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_MMC_HIGHSPEED |
> > +                       MMC_CAP_SD_HIGHSPEED;
> > +       mmc->max_seg_size = 65024;
> > +       mmc->max_segs = 128;
> > +       mmc->max_req_size = (16*512*mmc->max_segs);
> > +       mmc->max_blk_size = 2048;
> > +       mmc->max_blk_count = mmc->max_req_size / 512;
> Instead of hard coding the values in the driver probe. you can put
> them in the driver data for a specific controller. very useful if
> there are different variants of controller.

Given that this is a DT-only driver, it seemed unnecessary to add all
these properties to the binding since they are the same across the
entire platform at the moment (13 different controller versions at
least).

> > +
> > +       priv = mmc_priv(mmc);
> > +       priv->mmc = mmc;
> > +
> > +       priv->power_inverted = 0;
> > +       priv->cd_inverted = 0;
> if these values are platform specific. get them from DTS file

This sets the default, they are set from DTS in the next two statements
if the properties are present. Possibly these are unneeded if
mmc_alloc_host is kzalloc'd, but it seems to make it clearer what is
happening in this block of code.

> > +
> > +       if (of_get_property(np, "sdon-inverted", NULL))
> > +               priv->power_inverted = 1;
> > +       if (of_get_property(np, "cd-inverted", NULL))
> > +               priv->cd_inverted = 1;
> > +
> > +       priv->sdmmc_base = of_iomap(np, 0);
> > +       if (!priv->sdmmc_base) {
> > +               dev_err(&pdev->dev, "Failed to map IO space\n");
> > +               ret = -ENOMEM;
> > +               goto fail2;
> > +       }
> > +
> > +       priv->irq_regular = regular_irq;
> > +       priv->irq_dma = dma_irq;
> > +
> > +       ret = request_irq(regular_irq, wmt_mci_regular_isr, 0, "sdmmc", priv);
> > +       if (ret) {
> > +               pr_err("%s: Register regular IRQ fail\n", __func__);
> > +               goto fail3;
> > +       }
> > +
> > +       ret = request_irq(dma_irq, wmt_mci_dma_isr, 32, "sdmmc", priv);
> > +       if (ret) {
> > +               pr_err("%s: Register DMA IRQ fail\n", __func__);
> > +               goto fail4;
> > +       }
> > +
> > +       /* alloc some DMA buffers for descriptors/transfers */
> > +       priv->dma_desc_buffer = dma_alloc_coherent(&pdev->dev,
> > +               mmc->max_blk_count * 16, &priv->dma_desc_device_addr, 208);
> > +       if (!priv->dma_desc_buffer) {
> > +               pr_err("%s: DMA alloc fail\n", __func__);
> > +               ret = -EPERM;
> > +               goto fail5;
> > +       }
> > +
> > +       platform_set_drvdata(pdev, mmc);
> > +
> > +       priv->clk_sdmmc = of_clk_get(np, 0);
> > +       if (IS_ERR(priv->clk_sdmmc)) {
> > +               pr_err("%s: Error getting clock\n", __func__);
> > +               ret = PTR_ERR(priv->clk_sdmmc);
> > +               goto fail5;
> > +       }
> > +
> > +       clk_prepare_enable(priv->clk_sdmmc);
> > +
> > +       /* configure the controller to a known 'ready' state */
> > +       wmt_reset_hardware(mmc);
> > +
> > +       mmc_add_host(mmc);
> > +
> > +       pr_info("%s: WMT SDHC Controller initialized\n", __func__);
> > +
> > +       return 0;
> > +fail5:
> > +       free_irq(dma_irq, priv);
> > +fail4:
> > +       free_irq(regular_irq, priv);
> > +fail3:
> > +       iounmap(priv->sdmmc_base);
> > +fail2:
> > +       mmc_free_host(mmc);
> > +fail1:
> > +       return ret;
> > +}
> > +
> > +#ifdef CONFIG_PM
> > +static int wmt_mci_suspend(struct platform_device *pdev, pm_message_t state)
> > +{
> > +       u32 reg_tmp;
> > +       struct mmc_host *mmc;
> > +       struct wmt_mci_priv *priv;
> > +       int ret;
> > +
> > +       mmc = platform_get_drvdata(pdev);
> > +       if (!mmc)
> > +               return 0;
> > +
> > +       priv = mmc_priv(mmc);
> > +       ret = mmc_suspend_host(mmc);
> > +       if (!ret) {
> > +               reg_tmp = readb(priv->sdmmc_base + SDMMC_BUSMODE);
> > +               writeb(reg_tmp | BM_SOFT_RESET, priv->sdmmc_base +
> > +                       SDMMC_BUSMODE);
> > +
> > +               reg_tmp = readw(priv->sdmmc_base + SDMMC_BLKLEN);
> > +               writew(reg_tmp & 0x5FFF, priv->sdmmc_base + SDMMC_BLKLEN);
> > +
> > +               writeb(0xFF, priv->sdmmc_base + SDMMC_STS0);
> > +               writeb(0xFF, priv->sdmmc_base + SDMMC_STS1);
> > +       }
> > +       clk_disable(priv->clk_sdmmc);
> > +       return ret;
> > +}
> > +
> > +static int wmt_mci_resume(struct platform_device *pdev)
> > +{
> > +       u32 reg_tmp;
> > +       struct mmc_host *mmc;
> > +       struct wmt_mci_priv *priv;
> > +       int ret = 0;
> > +
> > +       mmc = platform_get_drvdata(pdev);
> > +       if (mmc) {
> > +               priv = mmc_priv(mmc);
> > +               clk_enable(priv->clk_sdmmc);
> > +
> > +               reg_tmp = readb(priv->sdmmc_base + SDMMC_BUSMODE);
> > +               writeb(reg_tmp | BM_SOFT_RESET, priv->sdmmc_base +
> > +                       SDMMC_BUSMODE);
> > +
> > +               reg_tmp = readw(priv->sdmmc_base + SDMMC_BLKLEN);
> > +               writew(reg_tmp | (BLKL_GPI_CD | BLKL_INT_ENABLE),
> > +                       priv->sdmmc_base + SDMMC_BLKLEN);
> > +
> > +               reg_tmp = readb(priv->sdmmc_base + SDMMC_INTMASK0);
> > +               writeb(reg_tmp | INT0_DI_INT_EN, priv->sdmmc_base +
> > +                       SDMMC_INTMASK0);
> > +
> > +               ret = mmc_resume_host(mmc);
> > +       }
> > +
> > +       return ret;
> > +}
> > +#else
> > +
> > +#define wmt_mci_suspend NULL
> > +#define wmt_mci_resume NULL
> > +
> > +#endif
> > +
> > +static int __devexit wmt_mci_remove(struct platform_device *pdev)
> > +{
> > +       struct mmc_host *mmc;
> > +       struct wmt_mci_priv *priv;
> > +       struct resource *res;
> > +       u32 reg_tmp;
> > +
> > +       mmc = platform_get_drvdata(pdev);
> > +       priv = mmc_priv(mmc);
> > +
> > +       /* reset SD controller */
> > +       reg_tmp = readb(priv->sdmmc_base + SDMMC_BUSMODE);
> > +       writel(reg_tmp | BM_SOFT_RESET, priv->sdmmc_base + SDMMC_BUSMODE);
> > +       reg_tmp = readw(priv->sdmmc_base + SDMMC_BLKLEN);
> > +       writew(reg_tmp & ~(0xA000), priv->sdmmc_base + SDMMC_BLKLEN);
> > +       writeb(0xFF, priv->sdmmc_base + SDMMC_STS0);
> > +       writeb(0xFF, priv->sdmmc_base + SDMMC_STS1);
> > +
> > +       /* release the dma buffers */
> > +       dma_free_coherent(&pdev->dev, priv->mmc->max_blk_count * 16,
> > +                       priv->dma_desc_buffer, priv->dma_desc_device_addr);
> > +
> > +       mmc_remove_host(mmc);
> > +
> > +       free_irq(priv->irq_regular, priv);
> > +       free_irq(priv->irq_dma, priv);
> > +
> > +       iounmap(priv->sdmmc_base);
> > +
> > +       clk_disable_unprepare(priv->clk_sdmmc);
> > +       clk_put(priv->clk_sdmmc);
> > +
> > +       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> > +       release_mem_region(res->start, res->end - res->start + 1);
> > +
> > +       mmc_free_host(mmc);
> > +
> > +       platform_set_drvdata(pdev, NULL);
> > +
> > +       pr_info("%s: WMT MCI device removed\n", __func__);
> > +
> > +       return 0;
> > +}
> > +
> > +static struct of_device_id wmt_mci_dt_ids[] = {
> > +       { .compatible = "wm,wm8505-sdhc" },
> > +       { /* Sentinel */ },
> > +};
> this above struct can be put in CONFIG_OF conditional compile

arch-vt8500 is USE_OF only.

> > +
> > +static struct platform_driver wmt_mci_driver = {
> > +       .probe = wmt_mci_probe,
> > +       .remove = wmt_mci_remove,
> __devexit_p for removal is missing

Will fix.

> > +       .suspend = wmt_mci_suspend,
> > +       .resume = wmt_mci_resume,
> why cant we put suspend and resume in driver structure? Also macros
> are available to define simple dev ops.

Could do. How do I get the private data set in the platform_device when
called from driver context??

> > +       .driver = {
> > +               .name = DRIVER_NAME,
> > +               .owner = THIS_MODULE,
> > +               .of_match_table = wmt_mci_dt_ids,
> use of_match_ptr(wmt_mci_dt_ids), so that in non-dt case it is assigned null.

There are no non-dt cases. This arch is DT only, and this driver
wouldn't be any use on other arch's.

> > +       },
> > +};
> > +
> > +module_platform_driver(wmt_mci_driver);
> > +
> > +MODULE_DESCRIPTION("Wondermedia MMC/SD Driver");
> > +MODULE_AUTHOR("Tony Prisk");
> > +MODULE_LICENSE("GPL");
> > +MODULE_DEVICE_TABLE(of, wmt_mci_dt_ids);
> > --
> > 1.7.9.5
> >
> > --
> > To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
> > the body of a message to majordomo@xxxxxxxxxxxxxxx
> > More majordomo info at  http://vger.kernel.org/majordomo-info.html

Regards
Tony P

--
To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html


[Index of Archives]     [Linux USB Devel]     [Linux Media]     [Video for Linux]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]

  Powered by Linux