LKML Archive on lore.kernel.org
help / color / mirror / Atom feed
From: Chris Ball <cjb@laptop.org>
To: Will Newton <will.newton@gmail.com>
Cc: Linux Kernel list <linux-kernel@vger.kernel.org>,
	linux-mmc@vger.kernel.org, Matt Fleming <matt@console-pimps.org>
Subject: Re: [PATCH] dw_mmc: Add Synopsys DesignWare mmc host driver.
Date: Thu, 9 Dec 2010 06:47:51 +0000	[thread overview]
Message-ID: <20101209064751.GA21128@void.printf.net> (raw)
In-Reply-To: <AANLkTi=PpTi1_JO9Q=ph7w9Jim8iXMf9LbCfmEkWuo-h@mail.gmail.com>

Hi Will,

Thanks for the submission (and thanks for the review, Matt!).

Some more comments below, mainly stylistic, and at the bottom I've
attached an indentation and cleanup patch.  It's okay if there are
some changes in it that you'd rather not make.

On Wed, Dec 08, 2010 at 02:21:05PM +0000, Will Newton wrote:
> This adds the mmc host driver for the Synopsys DesignWare mmc
> host controller, found in a number of embedded SoC designs.
> 
> Signed-off-by: Will Newton <will.newton@imgtec.com>
> ---
>  drivers/mmc/host/Kconfig   |   15 +
>  drivers/mmc/host/Makefile  |    1 +
>  drivers/mmc/host/dw_mmc.c  | 1806 ++++++++++++++++++++++++++++++++++++++++++++
>  drivers/mmc/host/dw_mmc.h  |  153 ++++
>  include/linux/mmc/dw_mmc.h |  149 ++++
>  5 files changed, 2124 insertions(+), 0 deletions(-)
>  create mode 100644 drivers/mmc/host/dw_mmc.c
>  create mode 100644 drivers/mmc/host/dw_mmc.h
>  create mode 100644 include/linux/mmc/dw_mmc.h
> 
>  - patch v2: make changes based on review by Matt Fleming.
> 
> diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
> index f8fa9ef..c99d2c6 100644
> --- a/drivers/mmc/host/Kconfig
> +++ b/drivers/mmc/host/Kconfig
> @@ -469,6 +469,21 @@ config SDH_BFIN_MISSING_CMD_PULLUP_WORKAROUND
>  	help
>  	  If you say yes here SD-Cards may work on the EZkit.
> 
> +config MMC_DW
> +	tristate "Synopsys DesignWare Memory Card Interface"
> +	help
> +	  This selects support for the Synopsys DesignWare Mobile Storage IP
> +	  block, this provides host support for SD and MMC interfaces, in both
> +	  PIO and external DMA modes.
> +
> +config MMC_DW_IDMAC
> +	depends on MMC_DW
> +	bool "Internal DMAC interface"
> +	help
> +	  This selects support for the internal DMAC block within the Synopsys
> +	  Designware Mobile Storage IP block. This disables the external DMA
> +	  interface.
> +

Is there something we could depend on that would stop this driver being
presented to everyone, without being far too specific?  At the moment
we'd be making x86 desktop users say whether they have this IP, which
isn't good.  Are the architectures that use this IP already upstream?
Are they all ARM architectures, for instance?

>  config MMC_SH_MMCIF
>  	tristate "SuperH Internal MMCIF support"
>  	depends on MMC_BLOCK && (SUPERH || ARCH_SHMOBILE)
> diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
> index d91364d..a5d1cb2 100644
> --- a/drivers/mmc/host/Makefile
> +++ b/drivers/mmc/host/Makefile
> @@ -31,6 +31,7 @@ obj-$(CONFIG_MMC_TMIO)		+= tmio_mmc.o
>  obj-$(CONFIG_MMC_CB710)	+= cb710-mmc.o
>  obj-$(CONFIG_MMC_VIA_SDMMC)	+= via-sdmmc.o
>  obj-$(CONFIG_SDH_BFIN)		+= bfin_sdh.o
> +obj-$(CONFIG_MMC_DW)		+= dw_mmc.o
>  obj-$(CONFIG_MMC_SH_MMCIF)	+= sh_mmcif.o
>  obj-$(CONFIG_MMC_JZ4740)	+= jz4740_mmc.o
>  obj-$(CONFIG_MMC_USHC)		+= ushc.o
> diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c
> new file mode 100644
> index 0000000..7de6b42
> --- /dev/null
> +++ b/drivers/mmc/host/dw_mmc.c
> @@ -0,0 +1,1806 @@
> +/*
> + * Synopsys DesignWare Multimedia Card Interface driver
> + *  (Based on NXP driver for lpc 31xx)
> + *

Is the NXP driver publicly available?  If not, we can remove this line.
The driver looks like it's based on our atmel-mci.c to me.

It'd be nice if you kerneldoc'd your data structures in the same style as
atmel-mci does, and many of the locking comments in there apply directly
to this driver.

> + * Copyright (C) 2009 NXP Semiconductors
> + * Copyright (C) 2009, 2010 Imagination Technologies Ltd.

Hm, what's the relationship between NXP and Imagination here?  If
you're submitting a driver with NXP copyright, I think we should have
a Signed-off-by line from whomever owns the copyright/wrote that code.
If that's you, that's fine, but it's unclear to me.

> + *
> + * 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; either version 2 of the License, or
> + * (at your option) any later version.

My patch snips from here until the end of this comment, to align with the
rest of MMC.  One reason not to include the FSF address in every source
file is that it becomes wrong occasionally, like the address below.  :)

> + *
> + * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
> + *
> + */
> +
> +#include <linux/blkdev.h>
> +#include <linux/clk.h>
> +#include <linux/debugfs.h>
> +#include <linux/device.h>
> +#include <linux/dma-mapping.h>
> +#include <linux/err.h>
> +#include <linux/init.h>
> +#include <linux/interrupt.h>
> +#include <linux/ioport.h>
> +#include <linux/module.h>
> +#include <linux/platform_device.h>
> +#include <linux/scatterlist.h>
> +#include <linux/seq_file.h>
> +#include <linux/slab.h>
> +#include <linux/stat.h>
> +#include <linux/delay.h>
> +#include <linux/irq.h>
> +#include <linux/mmc/host.h>
> +#include <linux/mmc/mmc.h>
> +#include <linux/mmc/dw_mmc.h>
> +#include <linux/bitops.h>
> +
> +#include "dw_mmc.h"
> +
> +/* Common flag combinations */
> +#define DW_MCI_DATA_ERROR_FLAGS	(SDMMC_INT_DTO | SDMMC_INT_DCRC | \
> +				 SDMMC_INT_HTO | SDMMC_INT_SBE  | \
> +				 SDMMC_INT_EBE)
> +#define DW_MCI_CMD_ERROR_FLAGS	(SDMMC_INT_RTO | SDMMC_INT_RCRC | \
> +				 SDMMC_INT_RESP_ERR)
> +#define DW_MCI_ERROR_FLAGS	(DW_MCI_DATA_ERROR_FLAGS | \
> +				 DW_MCI_CMD_ERROR_FLAGS  | SDMMC_INT_HLE)
> +#define DW_MCI_SEND_STATUS	1
> +#define DW_MCI_RECV_STATUS	2
> +#define DW_MCI_DMA_THRESHOLD	16
> +
> +#ifdef CONFIG_MMC_DW_IDMAC
> +struct idmac_desc {
> +	u32		des0;	/* Control Descriptor */
> +#define IDMAC_DES0_DIC	BIT(1)
> +#define IDMAC_DES0_LD	BIT(2)
> +#define IDMAC_DES0_FD	BIT(3)
> +#define IDMAC_DES0_CH	BIT(4)
> +#define IDMAC_DES0_ER	BIT(5)
> +#define IDMAC_DES0_CES	BIT(30)
> +#define IDMAC_DES0_OWN	BIT(31)
> +
> +	u32		des1;	/* Buffer sizes */
> +#define IDMAC_SET_BUFFER1_SIZE(d, s) \
> +	((d)->des1 = ((d)->des1 & 0x03ffc000) | ((s) & 0x3fff))
> +
> +	u32		des2;	/* buffer 1 physical address */
> +
> +	u32		des3;	/* buffer 2 physical address */
> +};
> +#endif /* CONFIG_MMC_DW_IDMAC */
> +
> +struct dw_mci_slot {
> +	struct mmc_host		*mmc;
> +	struct dw_mci		*host;
> +
> +	u32			ctype;
> +
> +	struct mmc_request	*mrq;
> +	struct list_head	queue_node;
> +
> +	unsigned int		clock;
> +	unsigned long		flags;
> +#define DW_MMC_CARD_PRESENT	0
> +#define DW_MMC_CARD_NEED_INIT	1
> +	int			id;
> +	int			last_detect_state;
> +};
> +
> +#if defined(CONFIG_DEBUG_FS)
> +/*
> + * The debugfs stuff below is mostly optimized away when
> + * CONFIG_DEBUG_FS is not set.
> + */

Don't think this comment needs to be here.

> +static int dw_mci_req_show(struct seq_file *s, void *v)
> +{
> +	struct dw_mci_slot *slot = s->private;
> +	struct mmc_request *mrq;
> +	struct mmc_command *cmd;
> +	struct mmc_command *stop;
> +	struct mmc_data	*data;
> +
> +	/* Make sure we get a consistent snapshot */
> +	spin_lock_bh(&slot->host->lock);
> +	mrq = slot->mrq;
> +
> +	if (mrq) {
> +		cmd = mrq->cmd;
> +		data = mrq->data;
> +		stop = mrq->stop;
> +
> +		if (cmd)
> +			seq_printf(s,
> +				"CMD%u(0x%x) flg %x rsp %x %x %x %x err %d\n",
> +				cmd->opcode, cmd->arg, cmd->flags,
> +				cmd->resp[0], cmd->resp[1], cmd->resp[2],
> +				cmd->resp[2], cmd->error);
> +		if (data)
> +			seq_printf(s, "DATA %u / %u * %u flg %x err %d\n",
> +				data->bytes_xfered, data->blocks,
> +				data->blksz, data->flags, data->error);
> +		if (stop)
> +			seq_printf(s,
> +				"CMD%u(0x%x) flg %x rsp %x %x %x %x err %d\n",
> +				stop->opcode, stop->arg, stop->flags,
> +				stop->resp[0], stop->resp[1], stop->resp[2],
> +				stop->resp[2], stop->error);
> +	}
> +
> +	spin_unlock_bh(&slot->host->lock);
> +
> +	return 0;
> +}
> +
> +static int dw_mci_req_open(struct inode *inode, struct file *file)
> +{
> +	return single_open(file, dw_mci_req_show, inode->i_private);
> +}
> +
> +static const struct file_operations dw_mci_req_fops = {
> +	.owner		= THIS_MODULE,
> +	.open		= dw_mci_req_open,
> +	.read		= seq_read,
> +	.llseek		= seq_lseek,
> +	.release	= single_release,
> +};
> +
> +static int dw_mci_regs_show(struct seq_file *s, void *v)
> +{
> +	seq_printf(s, "STATUS:\t0x%08x\n", SDMMC_STATUS);
> +	seq_printf(s, "RINTSTS:\t0x%08x\n", SDMMC_RINTSTS);
> +	seq_printf(s, "CMD:\t0x%08x\n", SDMMC_CMD);
> +	seq_printf(s, "CTRL:\t0x%08x\n", SDMMC_CTRL);
> +	seq_printf(s, "INTMASK:\t0x%08x\n", SDMMC_INTMASK);
> +	seq_printf(s, "CLKENA:\t0x%08x\n", SDMMC_CLKENA);
> +
> +	return 0;
> +}
> +
> +static int dw_mci_regs_open(struct inode *inode, struct file *file)
> +{
> +	return single_open(file, dw_mci_regs_show, inode->i_private);
> +}
> +
> +static const struct file_operations dw_mci_regs_fops = {
> +	.owner		= THIS_MODULE,
> +	.open		= dw_mci_regs_open,
> +	.read		= seq_read,
> +	.llseek		= seq_lseek,
> +	.release	= single_release,
> +};
> +
> +static void dw_mci_init_debugfs(struct dw_mci_slot *slot)
> +{
> +	struct mmc_host	*mmc = slot->mmc;
> +	struct dw_mci *host = slot->host;
> +	struct dentry *root;
> +	struct dentry *node;
> +
> +	root = mmc->debugfs_root;
> +	if (!root)
> +		return;
> +
> +	node = debugfs_create_file("regs", S_IRUSR, root, host,
> +			&dw_mci_regs_fops);
> +	if (!node)
> +		goto err;
> +
> +	node = debugfs_create_file("req", S_IRUSR, root, slot,
> +			&dw_mci_req_fops);
> +	if (!node)
> +		goto err;
> +
> +	node = debugfs_create_u32("state", S_IRUSR, root, (u32 *)&host->state);
> +	if (!node)
> +		goto err;
> +
> +	node = debugfs_create_x32("pending_events", S_IRUSR, root,
> +				     (u32 *)&host->pending_events);
> +	if (!node)
> +		goto err;
> +
> +	node = debugfs_create_x32("completed_events", S_IRUSR, root,
> +				     (u32 *)&host->completed_events);
> +	if (!node)
> +		goto err;
> +
> +	return;
> +
> +err:
> +	dev_err(&mmc->class_dev, "failed to initialize debugfs for slot\n");
> +}
> +#endif /* defined(CONFIG_DEBUG_FS) */
> +
> +static void dw_mci_set_timeout(struct dw_mci *host)
> +{
> +	mci_writel(host, TMOUT, 0xffffffff); /* timeout (maximum) */
> +}
> +
> +static u32 dw_mci_prepare_command(struct mmc_host *mmc,
> +				  struct mmc_command *cmd)
> +{
> +	struct mmc_data	*data;
> +	u32 cmdr;
> +	cmd->error = -EINPROGRESS;
> +
> +	cmdr = cmd->opcode;
> +
> +	if (cmdr == MMC_STOP_TRANSMISSION)
> +		cmdr |= SDMMC_CMD_STOP;
> +	else
> +		cmdr |= SDMMC_CMD_PRV_DAT_WAIT;
> +
> +	if (cmd->flags & MMC_RSP_PRESENT) {
> +		cmdr |= SDMMC_CMD_RESP_EXP;
> +		/* expect the respond, need to set this bit */

I think the comment's referring to the line above, so it should be
before it.  Also, s/respond/response/, and maybe it could be reworded.

> +		if (cmd->flags & MMC_RSP_136)
> +			cmdr |= SDMMC_CMD_RESP_LONG; /* expect long respond */
> +	}
> +
> +	if (cmd->flags & MMC_RSP_CRC)
> +		cmdr |= SDMMC_CMD_RESP_CRC;
> +
> +	data = cmd->data;
> +	if (data) {
> +		cmdr |= SDMMC_CMD_DAT_EXP;
> +		if (data->flags & MMC_DATA_STREAM)
> +			cmdr |= SDMMC_CMD_STRM_MODE; /*  set stream mode */

I think both of these comments can be removed as obvious.

> +		if (data->flags & MMC_DATA_WRITE)
> +			cmdr |= SDMMC_CMD_DAT_WR;
> +	}
> +
> +	return cmdr;
> +}
> +
> +static void dw_mci_start_command(struct dw_mci *host,
> +				 struct mmc_command *cmd, u32 cmd_flags)
> +{
> +	host->cmd = cmd;
> +	dev_vdbg(&host->pdev->dev,
> +			"start command: ARGR=0x%08x CMDR=0x%08x\n",
> +			cmd->arg, cmd_flags);
> +
> +	/* write to CMDARG register */
> +	mci_writel(host, CMDARG, cmd->arg);
> +	wmb();
> +
> +	/* write to CMD register */
> +	mci_writel(host, CMD, cmd_flags | SDMMC_CMD_START);

Again, these comments aren't very useful.  I do approve of comments in
general, honest, but they're supposed to say something that isn't
apparent by just looking at the code.

> +}
> +
> +static void send_stop_cmd(struct dw_mci *host, struct mmc_data *data)
> +{
> +	dw_mci_start_command(host, data->stop, host->stop_cmdr);
> +}
> +
> +/* DMA interface functions */
> +static void dw_mci_stop_dma(struct dw_mci *host)
> +{
> +	if (host->use_dma) {
> +		host->dma_ops->stop(host);
> +		host->dma_ops->cleanup(host);
> +
> +	} else {
> +		/* Data transfer was stopped by the interrupt handler */
> +		set_bit(EVENT_XFER_COMPLETE, &host->pending_events);
> +	}
> +}
> +
> +#ifdef CONFIG_MMC_DW_IDMAC
> +static void dw_mci_dma_cleanup(struct dw_mci *host)
> +{
> +	struct mmc_data *data = host->data;
> +
> +	if (data)
> +		dma_unmap_sg(&host->pdev->dev, data->sg, data->sg_len,
> +		     ((data->flags & MMC_DATA_WRITE)
> +		      ? DMA_TO_DEVICE : DMA_FROM_DEVICE));
> +}
> +
> +static void dw_mci_idmac_stop_dma(struct dw_mci *host)
> +{
> +	u32 temp;
> +
> +	/* Disable and reset the IDMAC interface */
> +	temp = mci_readl(host, CTRL);
> +	temp &= ~SDMMC_CTRL_USE_IDMAC;
> +	temp |= SDMMC_CTRL_DMA_RESET;
> +	mci_writel(host, CTRL, temp);
> +
> +	/* Stop the IDMAC running */
> +	temp = mci_readl(host, BMOD);
> +	temp &= ~SDMMC_IDMAC_ENABLE;
> +	mci_writel(host, BMOD, temp);
> +}
> +
> +static void dw_mci_idmac_complete_dma(struct dw_mci *host)
> +{
> +	struct mmc_data *data = host->data;
> +
> +	dev_vdbg(&host->pdev->dev, "DMA complete\n");
> +
> +	host->dma_ops->cleanup(host);
> +
> +	/*
> +	 * If the card was removed, data will be NULL. No point in trying to
> +	 * send the stop command or waiting for NBUSY in this case.
> +	 */
> +	if (data) {
> +		set_bit(EVENT_XFER_COMPLETE, &host->pending_events);
> +		tasklet_schedule(&host->tasklet);
> +	}
> +}
> +
> +static void dw_mci_translate_sglist(struct dw_mci *host,
> +				    struct mmc_data *data, unsigned int sg_len)
> +{
> +	int i;
> +	struct idmac_desc *desc = host->sg_cpu;
> +
> +	for (i = 0; i < sg_len; i++, desc++) {
> +		unsigned int length = sg_dma_len(&data->sg[i]);
> +		u32 mem_addr = sg_dma_address(&data->sg[i]);
> +
> +		/* Set the OWN bit and disable interrupts for this descriptor */
> +		desc->des0 = IDMAC_DES0_OWN | IDMAC_DES0_DIC | IDMAC_DES0_CH;
> +
> +		/* Buffer length */
> +		IDMAC_SET_BUFFER1_SIZE(desc, length);
> +
> +		/* Physical address to DMA to/from */
> +		desc->des2 = mem_addr;
> +	}
> +
> +	/* Set first descriptor */
> +	desc = host->sg_cpu;
> +	desc->des0 |= IDMAC_DES0_FD;
> +
> +	/* Set last descriptor */
> +	desc = host->sg_cpu + (i - 1) * sizeof(struct idmac_desc);
> +	desc->des0 &= ~(IDMAC_DES0_CH | IDMAC_DES0_DIC);
> +	desc->des0 |= IDMAC_DES0_LD;
> +
> +	wmb();
> +}
> +
> +static void dw_mci_idmac_start_dma(struct dw_mci *host, unsigned int sg_len)
> +{
> +	u32 temp;
> +
> +	dw_mci_translate_sglist(host, host->data, sg_len);
> +
> +	/* Select IDMAC interface */
> +	temp = mci_readl(host, CTRL);
> +	temp |= SDMMC_CTRL_USE_IDMAC;
> +	mci_writel(host, CTRL, temp);
> +
> +	wmb();
> +
> +	/* Enable the IDMAC */
> +	temp = mci_readl(host, BMOD);
> +	temp |= SDMMC_IDMAC_ENABLE;
> +	mci_writel(host, BMOD, temp);
> +
> +	/* Start it running */
> +	mci_writel(host, PLDMND, 1);
> +}
> +
> +static int dw_mci_idmac_init(struct dw_mci *host)
> +{
> +	struct idmac_desc *p;
> +	int i;
> +
> +	/* Number of descriptors in the ring buffer */
> +	host->ring_size = PAGE_SIZE / sizeof(struct idmac_desc);
> +
> +	/* Forward link the descriptor list */
> +	for (i = 0, p = host->sg_cpu; i < host->ring_size - 1; i++, p++)
> +		p->des3 = host->sg_dma + (sizeof(struct idmac_desc) * (i + 1));
> +
> +	/* Set the last descriptor as the end-of-ring descriptor */
> +	p->des3 = host->sg_dma;
> +	p->des0 = IDMAC_DES0_ER;
> +
> +	/* Mask out interrupts - get Tx & Rx complete only */
> +	mci_writel(host, IDINTEN, SDMMC_IDMAC_INT_NI | SDMMC_IDMAC_INT_RI |
> +			SDMMC_IDMAC_INT_TI);
> +
> +	/* Set the descriptor base address */
> +	mci_writel(host, DBADDR, host->sg_dma);
> +	return 0;
> +}
> +
> +static struct dw_mci_dma_ops dw_mci_idmac_ops = {
> +	.init = dw_mci_idmac_init,
> +	.start = dw_mci_idmac_start_dma,
> +	.stop = dw_mci_idmac_stop_dma,
> +	.complete = dw_mci_idmac_complete_dma,
> +	.cleanup = dw_mci_dma_cleanup,
> +};
> +#endif /* CONFIG_MMC_DW_IDMAC */
> +
> +static int dw_mci_submit_data_dma(struct dw_mci *host, struct mmc_data *data)
> +{
> +	struct scatterlist *sg;
> +	unsigned int i, direction, sg_len;
> +	u32 temp;
> +
> +	/* If we don't have a channel, we can't do DMA */
> +	if (!host->use_dma)
> +		return -ENODEV;
> +
> +	/*
> +	 * We don't do DMA on "complex" transfers, i.e. with
> +	 * non-word-aligned buffers or lengths. Also, we don't bother
> +	 * with all the DMA setup overhead for short transfers.
> +	 */
> +	if (data->blocks * data->blksz < DW_MCI_DMA_THRESHOLD)
> +		return -EINVAL;
> +	if (data->blksz & 3)
> +		return -EINVAL;
> +
> +	for_each_sg(data->sg, sg, data->sg_len, i) {
> +		if (sg->offset & 3 || sg->length & 3)
> +			return -EINVAL;
> +	}
> +
> +	if (data->flags & MMC_DATA_READ)
> +		direction = DMA_FROM_DEVICE;
> +	else
> +		direction = DMA_TO_DEVICE;
> +
> +	sg_len = dma_map_sg(&host->pdev->dev, data->sg, data->sg_len,
> +				   direction);
> +
> +	dev_vdbg(&host->pdev->dev,
> +		"sd sg_cpu: %#lx sg_dma: %#lx sg_len: %d\n",
> +		(unsigned long)host->sg_cpu, (unsigned long)host->sg_dma,
> +		 sg_len);
> +
> +	/* Enable the DMA interface */
> +	temp = mci_readl(host, CTRL);
> +	temp |= SDMMC_CTRL_DMA_ENABLE;
> +	mci_writel(host, CTRL, temp);
> +
> +	/* disable irq of RX & TX, let DMA handle it */
> +	temp = mci_readl(host, INTMASK);
> +	temp  &= ~(SDMMC_INT_RXDR | SDMMC_INT_TXDR);
> +	mci_writel(host, INTMASK, temp);
> +
> +	host->dma_ops->start(host, sg_len);
> +
> +	return 0;
> +}
> +
> +static void dw_mci_submit_data(struct dw_mci *host, struct mmc_data *data)
> +{
> +	u32 temp;
> +
> +	data->error = -EINPROGRESS;
> +
> +	WARN_ON(host->data);
> +	host->sg = NULL;
> +	host->data = data;
> +
> +	if (dw_mci_submit_data_dma(host, data)) {
> +		host->sg = data->sg;
> +		host->pio_offset = 0;
> +		if (data->flags & MMC_DATA_READ)
> +			host->dir_status = DW_MCI_RECV_STATUS;
> +		else
> +			host->dir_status = DW_MCI_SEND_STATUS;
> +
> +		temp = mci_readl(host, INTMASK);
> +		temp |= SDMMC_INT_TXDR | SDMMC_INT_RXDR;
> +		mci_writel(host, INTMASK, temp);
> +
> +		temp = mci_readl(host, CTRL);
> +		temp &= ~SDMMC_CTRL_DMA_ENABLE;
> +		mci_writel(host, CTRL, temp);
> +	}
> +}
> +
> +static void mci_send_cmd(struct dw_mci_slot *slot, u32 cmd, u32 arg)
> +{
> +	struct dw_mci *host = slot->host;
> +	unsigned long timeout = jiffies + msecs_to_jiffies(500);
> +	unsigned int cmd_status = 0;
> +
> +	mci_writel(host, CMDARG, arg);
> +	wmb();
> +	mci_writel(host, CMD, SDMMC_CMD_START | cmd);
> +
> +	while (time_before(jiffies, timeout)) {
> +		cmd_status = mci_readl(host, CMD);
> +		if (!(cmd_status & SDMMC_CMD_START))
> +			return;
> +	}
> +	dev_err(&slot->mmc->class_dev,
> +		"Timeout sending command (cmd %#x arg %#x status %#x)\n",
> +		cmd, arg, cmd_status);
> +}
> +
> +static void dw_mci_setup_bus(struct dw_mci_slot *slot)
> +{
> +	struct dw_mci *host = slot->host;
> +	u32 div;
> +
> +	if (slot->clock != host->current_speed) {
> +		if (host->bus_hz % slot->clock)
> +			/*
> +			 * move the + 1 after the dvide
> +			 * to prevent over-clocking the card.
> +			 */
> +			div = ((host->bus_hz / slot->clock) >> 1) + 1;
> +		else
> +			div = (host->bus_hz  / slot->clock) >> 1;
> +
> +		dev_info(&slot->mmc->class_dev,
> +			"Bus speed (slot %d) = %dHz (slot req %dHz, actual %dHZ"
> +			" div = %d)\n",
> +			slot->id, host->bus_hz, slot->clock,
> +			div ? ((host->bus_hz / div) >> 1) : host->bus_hz, div);
> +
> +		/* disable clock */
> +		mci_writel(host, CLKENA, 0);
> +		mci_writel(host, CLKSRC, 0);
> +
> +		/* inform CIU */
> +		mci_send_cmd(slot,
> +			SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT, 0);
> +
> +		/* set clock to desired speed */
> +		mci_writel(host, CLKDIV, div);
> +
> +		/* inform CIU */
> +		mci_send_cmd(slot,
> +			SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT, 0);
> +
> +		/* enable clock */
> +		mci_writel(host, CLKENA, SDMMC_CLKEN_ENABLE);
> +
> +		/* inform CIU */
> +		mci_send_cmd(slot,
> +			SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT, 0);
> +
> +		host->current_speed = slot->clock;
> +	}
> +
> +	/* Set the current slot bus width */
> +	mci_writel(host, CTYPE, slot->ctype);
> +}
> +
> +static void dw_mci_start_request(struct dw_mci *host,
> +				 struct dw_mci_slot *slot)
> +{
> +	struct mmc_request *mrq;
> +	struct mmc_command *cmd;
> +	struct mmc_data	*data;
> +	u32 cmdflags;
> +
> +	mrq = slot->mrq;
> +	/* no select the proper slot */
> +	if (host->pdata->select_slot)
> +		host->pdata->select_slot(slot->id);

Don't understand this comment.

> +
> +	/* Slot specific timing and width adjustment */
> +	dw_mci_setup_bus(slot);
> +
> +	host->cur_slot = slot;
> +	host->mrq = mrq;
> +
> +	host->pending_events = 0;
> +	host->completed_events = 0;
> +	host->data_status = 0;
> +
> +	data = mrq->data;
> +	if (data) {
> +		dw_mci_set_timeout(host);
> +		mci_writel(host, BYTCNT, data->blksz*data->blocks);
> +		mci_writel(host, BLKSIZ, data->blksz);
> +	}
> +
> +	cmd = mrq->cmd;
> +	cmdflags = dw_mci_prepare_command(slot->mmc, cmd);
> +
> +	/* this is the first command, lets send the initialization clock */

I think you mean:
	/* If this is the first command, send the initialization clock /*

> +	if (test_and_clear_bit(DW_MMC_CARD_NEED_INIT, &slot->flags))
> +		cmdflags |= SDMMC_CMD_INIT;
> +
> +	/* we may need to move this code to mci_start_command */

Has this question been resolved yet?

> +	if (data) {
> +		dw_mci_submit_data(host, data);
> +		wmb();
> +	}
> +
> +	dw_mci_start_command(host, cmd, cmdflags);
> +
> +	if (mrq->stop)
> +		host->stop_cmdr = dw_mci_prepare_command(slot->mmc, mrq->stop);
> +}
> +
> +static void dw_mci_queue_request(struct dw_mci *host, struct dw_mci_slot *slot,
> +				 struct mmc_request *mrq)
> +{
> +	dev_vdbg(&slot->mmc->class_dev, "queue request: state=%d\n",
> +			host->state);
> +
> +	spin_lock_bh(&host->lock);
> +	slot->mrq = mrq;
> +
> +	if (host->state == STATE_IDLE) {
> +		host->state = STATE_SENDING_CMD;
> +		dw_mci_start_request(host, slot);
> +	} else {
> +		list_add_tail(&slot->queue_node, &host->queue);
> +	}
> +
> +	spin_unlock_bh(&host->lock);
> +}
> +
> +static void dw_mci_request(struct mmc_host *mmc, struct mmc_request *mrq)
> +{
> +	struct dw_mci_slot *slot = mmc_priv(mmc);
> +	struct dw_mci *host = slot->host;
> +
> +	WARN_ON(slot->mrq);
> +
> +	if (!test_bit(DW_MMC_CARD_PRESENT, &slot->flags)) {
> +		mrq->cmd->error = -ENOMEDIUM;
> +		mmc_request_done(mmc, mrq);
> +		return;
> +	}
> +
> +	/* We don't support multiple blocks of weird lengths. */
> +	dw_mci_queue_request(host, slot, mrq);
> +}
> +
> +static void dw_mci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
> +{
> +	struct dw_mci_slot *slot = mmc_priv(mmc);
> +
> +	/* set default 1 bit mode */
> +	slot->ctype = SDMMC_CTYPE_1BIT;
> +
> +	switch (ios->bus_width) {
> +	case MMC_BUS_WIDTH_1:
> +		slot->ctype = SDMMC_CTYPE_1BIT;
> +		break;
> +	case MMC_BUS_WIDTH_4:
> +		slot->ctype = SDMMC_CTYPE_4BIT;
> +		break;
> +	}
> +
> +	if (ios->clock) {
> +		/*
> +		 * Use mirror of ios->clock to prevent race with mmc
> +		 * core ios update when finding the minimum.
> +		 */
> +		slot->clock = ios->clock;
> +	}
> +
> +	switch (ios->power_mode) {
> +	case MMC_POWER_UP:
> +		set_bit(DW_MMC_CARD_NEED_INIT, &slot->flags);
> +		break;
> +	default:
> +		break;
> +	}
> +}
> +
> +static int dw_mci_get_ro(struct mmc_host *mmc)
> +{
> +	int read_only;
> +	struct dw_mci_slot *slot = mmc_priv(mmc);
> +	struct dw_mci_board *brd = slot->host->pdata;
> +
> +	if (brd->get_ro != NULL) {

!= NULL isn't necessary here.

> +		read_only = brd->get_ro(slot->id);
> +	} else {
> +		/* Try on board write protect */
> +		read_only =
> +			mci_readl(slot->host, WRTPRT) & (1 << slot->id) ? 1 : 0;
> +	}
> +
> +	dev_dbg(&mmc->class_dev, "card is %s\n",
> +				read_only ? "read-only" : "read-write");
> +
> +	return read_only;
> +}
> +
> +static int dw_mci_get_cd(struct mmc_host *mmc)
> +{
> +	int present;
> +	struct dw_mci_slot *slot = mmc_priv(mmc);
> +	struct dw_mci_board *brd = slot->host->pdata;
> +
> +	if (brd->get_cd != NULL)

(Same.)

> +		present = !brd->get_cd(slot->id);
> +	else	/* try onboard card detect */
> +		present = (mci_readl(slot->host, CDETECT) & (1 << slot->id))
> +				== 0 ? 1 : 0;
> +
> +	dev_dbg(&mmc->class_dev, "card is %spresent\n", present ? "" : "not ");

I expanded this, since being able to grep for "not present" has some value.

> +
> +	return present;
> +}
> +
> +static const struct mmc_host_ops dw_mci_ops = {
> +	.request	= dw_mci_request,
> +	.set_ios	= dw_mci_set_ios,
> +	.get_ro		= dw_mci_get_ro,
> +	.get_cd		= dw_mci_get_cd,
> +};
> +
> +static void dw_mci_request_end(struct dw_mci *host, struct mmc_request *mrq)
> +	__releases(&host->lock)
> +	__acquires(&host->lock)
> +{
> +	struct dw_mci_slot *slot;
> +	struct mmc_host	*prev_mmc = host->cur_slot->mmc;
> +
> +	WARN_ON(host->cmd || host->data);
> +
> +	host->cur_slot->mrq = NULL;
> +	host->mrq = NULL;
> +	if (!list_empty(&host->queue)) {
> +		slot = list_entry(host->queue.next,
> +				struct dw_mci_slot, queue_node);
> +		list_del(&slot->queue_node);
> +		dev_vdbg(&host->pdev->dev, "list not empty: %s is next\n",
> +				mmc_hostname(slot->mmc));
> +		host->state = STATE_SENDING_CMD;
> +		dw_mci_start_request(host, slot);
> +	} else {
> +		dev_vdbg(&host->pdev->dev, "list empty\n");
> +		host->state = STATE_IDLE;
> +	}
> +
> +	spin_unlock(&host->lock);
> +	mmc_request_done(prev_mmc, mrq);
> +
> +	spin_lock(&host->lock);
> +}
> +
> +static void dw_mci_command_complete(struct dw_mci *host,
> +				    struct mmc_command *cmd)
> +{
> +	u32 status = host->cmd_status;
> +
> +	host->cmd_status = 0;
> +
> +	/* Read the response from the card (up to 16 bytes) */
> +	if (cmd->flags & MMC_RSP_PRESENT) {
> +		if (cmd->flags & MMC_RSP_136) {
> +			cmd->resp[3] = mci_readl(host, RESP0);
> +			cmd->resp[2] = mci_readl(host, RESP1);
> +			cmd->resp[1] = mci_readl(host, RESP2);
> +			cmd->resp[0] = mci_readl(host, RESP3);

It'd be nice to have a comment explaining why this is in reverse
order, yet if RSP_136 is set we use RESP0 instead of RESP3.

> +		} else {
> +			cmd->resp[0] = mci_readl(host, RESP0);
> +			cmd->resp[1] = 0;
> +			cmd->resp[2] = 0;
> +			cmd->resp[3] = 0;
> +		}
> +	}
> +
> +	if (status & SDMMC_INT_RTO)
> +		cmd->error = -ETIMEDOUT;
> +	else if ((cmd->flags & MMC_RSP_CRC) && (status & SDMMC_INT_RCRC))
> +		cmd->error = -EILSEQ;
> +	else if (status & SDMMC_INT_RESP_ERR)
> +		cmd->error = -EIO;
> +	else
> +		cmd->error = 0;
> +
> +	if (cmd->error) {
> +		/* newer ip versions need a delay between retries */
> +		if (host->quirks & DW_MCI_QUIRK_RETRY_DELAY)
> +			mdelay(20);
> +
> +		if (cmd->data) {
> +			host->data = NULL;
> +			dw_mci_stop_dma(host);
> +		}
> +	}
> +}
> +
> +static void dw_mci_tasklet_func(unsigned long priv)
> +{
> +	struct dw_mci *host = (struct dw_mci *)priv;
> +	struct mmc_data	*data;
> +	struct mmc_command *cmd;
> +	enum dw_mci_state state;
> +	enum dw_mci_state prev_state;
> +	u32 status;
> +
> +	spin_lock(&host->lock);
> +
> +	state = host->state;
> +	data = host->data;
> +
> +	do {
> +		prev_state = state;
> +
> +		switch (state) {
> +		case STATE_IDLE:
> +			break;
> +
> +		case STATE_SENDING_CMD:
> +			if (!test_and_clear_bit(EVENT_CMD_COMPLETE,
> +						&host->pending_events))
> +				break;
> +
> +			cmd = host->cmd;
> +			host->cmd = NULL;
> +			set_bit(EVENT_CMD_COMPLETE, &host->completed_events);
> +			dw_mci_command_complete(host, host->mrq->cmd);
> +			if (!host->mrq->data || cmd->error) {
> +				dw_mci_request_end(host, host->mrq);
> +				goto unlock;
> +			}
> +
> +			prev_state = state = STATE_SENDING_DATA;
> +			/* fall through */
> +
> +		case STATE_SENDING_DATA:
> +			if (test_and_clear_bit(EVENT_DATA_ERROR,
> +					       &host->pending_events)) {
> +				dw_mci_stop_dma(host);
> +				if (data->stop)
> +					send_stop_cmd(host, data);
> +				state = STATE_DATA_ERROR;
> +				break;
> +			}
> +
> +			if (!test_and_clear_bit(EVENT_XFER_COMPLETE,
> +						&host->pending_events))
> +				break;
> +
> +			set_bit(EVENT_XFER_COMPLETE, &host->completed_events);
> +			prev_state = state = STATE_DATA_BUSY;
> +			/* fall through */
> +
> +		case STATE_DATA_BUSY:
> +			if (!test_and_clear_bit(EVENT_DATA_COMPLETE,
> +						&host->pending_events))
> +				break;
> +
> +			host->data = NULL;
> +			set_bit(EVENT_DATA_COMPLETE, &host->completed_events);
> +			status = host->data_status;
> +
> +			if (unlikely(status & DW_MCI_DATA_ERROR_FLAGS)) {
> +				if (status & SDMMC_INT_DTO) {
> +					dev_err(&host->pdev->dev,
> +							"data timeout error\n");
> +					data->error = -ETIMEDOUT;
> +				} else if (status & SDMMC_INT_DCRC) {
> +					dev_err(&host->pdev->dev,
> +							"data CRC error\n");
> +					data->error = -EILSEQ;
> +				} else {
> +					dev_err(&host->pdev->dev,
> +						"data FIFO error "
> +						"(status=%08x)\n",
> +						status);
> +					data->error = -EIO;
> +				}
> +			} else {
> +				data->bytes_xfered = data->blocks * data->blksz;
> +				data->error = 0;
> +			}
> +
> +			if (!data->stop) {
> +				dw_mci_request_end(host, host->mrq);
> +				goto unlock;
> +			}
> +
> +			prev_state = state = STATE_SENDING_STOP;
> +			if (!data->error)
> +				send_stop_cmd(host, data);
> +			/* fall through */
> +
> +		case STATE_SENDING_STOP:
> +			if (!test_and_clear_bit(EVENT_CMD_COMPLETE,
> +						&host->pending_events))
> +				break;
> +
> +			host->cmd = NULL;
> +			dw_mci_command_complete(host, host->mrq->stop);
> +			dw_mci_request_end(host, host->mrq);
> +			goto unlock;
> +
> +		case STATE_DATA_ERROR:
> +			if (!test_and_clear_bit(EVENT_XFER_COMPLETE,
> +						&host->pending_events))
> +				break;
> +
> +			state = STATE_DATA_BUSY;
> +			break;
> +		}
> +	} while (state != prev_state);
> +
> +	host->state = state;
> +unlock:
> +	spin_unlock(&host->lock);
> +
> +}
> +
> +static void dw_mci_push_data16(struct dw_mci *host, void *buf, int cnt)
> +{
> +	u16 *pData = (u16 *)buf;

Changed to pdata.

> +
> +	WARN_ON(cnt % 2 != 0);
> +
> +	cnt = cnt >> 1;
> +	while (cnt > 0) {
> +		mci_writew(host, DATA, *pData++);
> +		cnt--;
> +	}
> +}
> +
> +static void dw_mci_pull_data16(struct dw_mci *host, void *buf, int cnt)
> +{
> +	u16 *pData = (u16 *)buf;
> +
> +	WARN_ON(cnt % 2 != 0);
> +
> +	cnt = cnt >> 1;
> +	while (cnt > 0) {
> +		*pData++ = mci_readw(host, DATA);
> +		cnt--;
> +	}
> +}
> +
> +static void dw_mci_push_data32(struct dw_mci *host, void *buf, int cnt)
> +{
> +	u32 *pData = (u32 *)buf;
> +
> +	WARN_ON(cnt % 4 != 0);
> +	WARN_ON((unsigned long)pData & 0x3);
> +
> +	cnt = cnt >> 2;
> +	while (cnt > 0) {
> +		mci_writel(host, DATA, *pData++);
> +		cnt--;
> +	}
> +}
> +
> +static void dw_mci_pull_data32(struct dw_mci *host, void *buf, int cnt)
> +{
> +	u32 *pData = (u32 *)buf;
> +
> +	WARN_ON(cnt % 4 != 0);
> +	WARN_ON((unsigned long)pData & 0x3);
> +
> +	cnt = cnt >> 2;
> +	while (cnt > 0) {
> +		*pData++ = mci_readl(host, DATA);
> +		cnt--;
> +	}
> +}
> +
> +static void dw_mci_push_data64(struct dw_mci *host, void *buf, int cnt)
> +{
> +	u64 *pData = (u64 *)buf;
> +
> +	WARN_ON(cnt % 8 != 0);
> +
> +	cnt = cnt >> 3;
> +	while (cnt > 0) {
> +		mci_writeq(host, DATA, *pData++);
> +		cnt--;
> +	}
> +}
> +
> +static void dw_mci_pull_data64(struct dw_mci *host, void *buf, int cnt)
> +{
> +	u64 *pData = (u64 *)buf;
> +
> +	WARN_ON(cnt % 8 != 0);
> +
> +	cnt = cnt >> 3;
> +	while (cnt > 0) {
> +		*pData++ = mci_readq(host, DATA);
> +		cnt--;
> +	}
> +}
> +
> +static void dw_mci_read_data_pio(struct dw_mci *host)
> +{
> +	struct scatterlist *sg = host->sg;
> +	void *buf = sg_virt(sg);
> +	unsigned int offset = host->pio_offset;
> +	struct mmc_data	*data = host->data;
> +	int shift = host->data_shift;
> +	u32 status;
> +	unsigned int nbytes = 0, len, old_len, count = 0;
> +
> +	do {
> +		len = SDMMC_GET_FCNT(mci_readl(host, STATUS)) << shift;
> +		if (count == 0)
> +			old_len = len;
> +
> +		if (likely(offset + len <= sg->length)) {

I agree with Matt, the unlikely/likely aren't necessary.

> +			host->pull_data(host, (void *)(buf + offset), len);
> +
> +			offset += len;
> +			nbytes += len;
> +
> +			if (offset == sg->length) {
> +				flush_dcache_page(sg_page(sg));
> +				host->sg = sg = sg_next(sg);
> +				if (!sg)
> +					goto done;
> +
> +				offset = 0;
> +				buf = sg_virt(sg);
> +			}
> +		} else {
> +			unsigned int remaining = sg->length - offset;
> +			host->pull_data(host,
> +				(void *)(buf + offset), remaining);
> +			nbytes += remaining;
> +
> +			flush_dcache_page(sg_page(sg));
> +			host->sg = sg = sg_next(sg);
> +			if (!sg)
> +				goto done;
> +
> +			offset = len - remaining;
> +			buf = sg_virt(sg);
> +			host->pull_data(host, buf, offset);
> +			nbytes += offset;
> +		}
> +
> +		status = mci_readl(host, MINTSTS);
> +		mci_writel(host, RINTSTS, SDMMC_INT_RXDR);
> +		if (status & DW_MCI_DATA_ERROR_FLAGS) {
> +			host->data_status = status;
> +			data->bytes_xfered += nbytes;
> +			smp_wmb();
> +
> +			set_bit(EVENT_DATA_ERROR, &host->pending_events);
> +
> +			tasklet_schedule(&host->tasklet);
> +			return;
> +		}
> +		count++;
> +	} while (status & SDMMC_INT_RXDR); /*if the RXDR is ready
> +						lets read again*/
> +	len = SDMMC_GET_FCNT(mci_readl(host, STATUS));
> +	host->pio_offset = offset;
> +	data->bytes_xfered += nbytes;
> +	return;
> +
> +done:
> +	data->bytes_xfered += nbytes;
> +	smp_wmb();
> +	set_bit(EVENT_XFER_COMPLETE, &host->pending_events);
> +}
> +
> +static void dw_mci_write_data_pio(struct dw_mci *host)
> +{
> +	struct scatterlist *sg = host->sg;
> +	void *buf = sg_virt(sg);
> +	unsigned int offset = host->pio_offset;
> +	struct mmc_data	*data = host->data;
> +	int shift = host->data_shift;
> +	u32 status;
> +	unsigned int nbytes = 0, len;
> +
> +	do {
> +		len = SDMMC_FIFO_SZ -
> +			(SDMMC_GET_FCNT(mci_readl(host, STATUS)) << shift);
> +		if (likely(offset + len <= sg->length)) {
> +			host->push_data(host, (void *)(buf + offset), len);
> +
> +			offset += len;
> +			nbytes += len;
> +			if (offset == sg->length) {
> +				host->sg = sg = sg_next(sg);
> +				if (!sg)
> +					goto done;
> +
> +				offset = 0;
> +				buf = sg_virt(sg);
> +			}
> +		} else {
> +			unsigned int remaining = sg->length - offset;
> +
> +			host->push_data(host,
> +				(void *)(buf + offset), remaining);
> +			nbytes += remaining;
> +
> +			host->sg = sg = sg_next(sg);
> +			if (!sg)
> +				goto done;
> +
> +			offset = len - remaining;
> +			buf = sg_virt(sg);
> +			host->push_data(host, (void *)buf, offset);
> +			nbytes += offset;
> +		}
> +
> +		status = mci_readl(host, MINTSTS);
> +		mci_writel(host, RINTSTS, SDMMC_INT_TXDR);
> +		if (status & DW_MCI_DATA_ERROR_FLAGS) {
> +			host->data_status = status;
> +			data->bytes_xfered += nbytes;
> +
> +			smp_wmb();
> +
> +			set_bit(EVENT_DATA_ERROR, &host->pending_events);
> +
> +			tasklet_schedule(&host->tasklet);
> +			return;
> +		}
> +	} while (status & SDMMC_INT_TXDR); /* if TXDR, lets write again */
> +
> +	host->pio_offset = offset;
> +	data->bytes_xfered += nbytes;
> +
> +	return;
> +
> +done:
> +	data->bytes_xfered += nbytes;
> +	smp_wmb();
> +	set_bit(EVENT_XFER_COMPLETE, &host->pending_events);
> +}
> +
> +static void dw_mci_cmd_interrupt(struct dw_mci *host, u32 status)
> +{
> +	if (!host->cmd_status)
> +		host->cmd_status = status;
> +
> +	smp_wmb();
> +
> +	set_bit(EVENT_CMD_COMPLETE, &host->pending_events);
> +	tasklet_schedule(&host->tasklet);
> +}
> +
> +static irqreturn_t dw_mci_interrupt(int irq, void *dev_id)
> +{
> +	struct dw_mci *host = dev_id;
> +	u32 status,  pending;
> +	unsigned int pass_count = 0;
> +
> +	do {
> +		status = mci_readl(host, RINTSTS);
> +		pending = mci_readl(host, MINTSTS);/* read only mask reg */
> +
> +		/*
> +		 * DTO fix - version 2.10a and below, and only if internal DMA
> +		 * is configured.
> +		 */
> +		if (host->quirks & DW_MCI_QUIRK_IDMAC_DTO) {
> +			if (!pending &&
> +			    ((mci_readl(host, STATUS) >> 17) & 0x1fff))
> +				pending |= SDMMC_INT_DATA_OVER;
> +		}
> +
> +		if (!pending)
> +			break;
> +
> +		if (pending & DW_MCI_CMD_ERROR_FLAGS) {
> +			mci_writel(host, RINTSTS, DW_MCI_CMD_ERROR_FLAGS);
> +			host->cmd_status = status;
> +			smp_wmb();
> +			set_bit(EVENT_CMD_COMPLETE, &host->pending_events);
> +			tasklet_schedule(&host->tasklet);
> +		}
> +
> +		if (pending & DW_MCI_DATA_ERROR_FLAGS) {
> +			/* if there is an error, lets report DATA_ERROR */

The "lets" were ungrammatical and didn't add much, so I removed them.

> +			mci_writel(host, RINTSTS, DW_MCI_DATA_ERROR_FLAGS);
> +			host->data_status = status;
> +			smp_wmb();
> +			set_bit(EVENT_DATA_ERROR, &host->pending_events);
> +			tasklet_schedule(&host->tasklet);
> +		}
> +
> +
> +		if (pending & SDMMC_INT_DATA_OVER) {
> +			mci_writel(host, RINTSTS, SDMMC_INT_DATA_OVER);
> +			if (!host->data_status)
> +				host->data_status = status;
> +			smp_wmb();
> +			if (host->dir_status == DW_MCI_RECV_STATUS) {
> +				if (host->sg != NULL)
> +					dw_mci_read_data_pio(host);
> +			}
> +			set_bit(EVENT_DATA_COMPLETE, &host->pending_events);
> +			tasklet_schedule(&host->tasklet);
> +		}
> +
> +		if (pending & SDMMC_INT_RXDR) {
> +			mci_writel(host, RINTSTS, SDMMC_INT_RXDR);
> +			if (host->sg)
> +				dw_mci_read_data_pio(host);
> +		}
> +
> +		if (pending & SDMMC_INT_TXDR) {
> +			mci_writel(host, RINTSTS, SDMMC_INT_TXDR);
> +			if (host->sg)
> +				dw_mci_write_data_pio(host);
> +		}
> +
> +		if (pending & SDMMC_INT_CMD_DONE) {
> +			mci_writel(host, RINTSTS, SDMMC_INT_CMD_DONE);
> +			dw_mci_cmd_interrupt(host, status);
> +		}
> +
> +		if (pending & SDMMC_INT_CD) {
> +			mci_writel(host, RINTSTS, SDMMC_INT_CD);
> +			tasklet_schedule(&host->card_tasklet);
> +		}
> +
> +	} while (pass_count++ < 5);
> +
> +#ifdef CONFIG_MMC_DW_IDMAC
> +	/* Handle DMA interrupts */
> +	pending = mci_readl(host, IDSTS);
> +	if (pending & (SDMMC_IDMAC_INT_TI | SDMMC_IDMAC_INT_RI)) {
> +		mci_writel(host, IDSTS, SDMMC_IDMAC_INT_TI |
> +				SDMMC_IDMAC_INT_RI);
> +		mci_writel(host, IDSTS, SDMMC_IDMAC_INT_NI);
> +		set_bit(EVENT_DATA_COMPLETE, &host->pending_events);
> +		host->dma_ops->complete(host);
> +	}
> +#endif
> +
> +	return IRQ_HANDLED;
> +}
> +
> +static void dw_mci_tasklet_card(unsigned long data)
> +{
> +	struct dw_mci *host = (struct dw_mci *)data;
> +	int i;
> +
> +	for (i = 0; i < host->num_slots; i++) {
> +		struct dw_mci_slot *slot = host->slot[i];
> +		struct mmc_host *mmc = slot->mmc;
> +		struct mmc_request *mrq;
> +		int present;
> +		u32 ctrl;
> +
> +		present = dw_mci_get_cd(mmc);
> +		while (present != slot->last_detect_state) {
> +			spin_lock(&host->lock);
> +
> +			dev_dbg(&slot->mmc->class_dev, "card %s\n",
> +					present ? "inserted" : "removed");
> +
> +			/* Card change detected */
> +			slot->last_detect_state = present;
> +
> +			/* Power up slot */
> +			if (present != 0) {
> +				if (host->pdata->setpower)
> +					host->pdata->setpower(slot->id,
> +						mmc->ocr_avail);
> +
> +				set_bit(DW_MMC_CARD_PRESENT, &slot->flags);
> +			}
> +
> +			/* Clean up queue if present */
> +			mrq = slot->mrq;
> +			if (mrq) {
> +				if (mrq == host->mrq) {
> +					host->data = NULL;
> +					host->cmd = NULL;
> +
> +					switch (host->state) {
> +					case STATE_IDLE:
> +						break;
> +					case STATE_SENDING_CMD:
> +						mrq->cmd->error = -ENOMEDIUM;
> +						if (!mrq->data)
> +							break;
> +						/* fall through */
> +					case STATE_SENDING_DATA:
> +						mrq->data->error = -ENOMEDIUM;
> +						dw_mci_stop_dma(host);
> +						break;
> +					case STATE_DATA_BUSY:
> +					case STATE_DATA_ERROR:
> +						if (mrq->data->error == -EINPROGRESS)
> +							mrq->data->error = -ENOMEDIUM;
> +						if (!mrq->stop)
> +							break;
> +						/* fall through */
> +					case STATE_SENDING_STOP:
> +						mrq->stop->error = -ENOMEDIUM;
> +						break;
> +					}
> +
> +					dw_mci_request_end(host, mrq);
> +				} else {
> +					list_del(&slot->queue_node);
> +					mrq->cmd->error = -ENOMEDIUM;
> +					if (mrq->data)
> +						mrq->data->error = -ENOMEDIUM;
> +					if (mrq->stop)
> +						mrq->stop->error = -ENOMEDIUM;
> +
> +					spin_unlock(&host->lock);
> +					mmc_request_done(slot->mmc, mrq);
> +					spin_lock(&host->lock);
> +				}
> +			}
> +
> +			/* Power down slot */
> +			if (present == 0) {
> +				if (host->pdata->setpower)
> +					host->pdata->setpower(slot->id, 0);
> +				clear_bit(DW_MMC_CARD_PRESENT, &slot->flags);
> +
> +				/*
> +				 * Clear down the FIFO - doing so generates a
> +				 * block interrupt, hence setting the
> +				 * scatter-gather pointer to NULL.
> +				 */
> +				host->sg = NULL;
> +
> +				ctrl = mci_readl(host, CTRL);
> +				ctrl |= SDMMC_CTRL_FIFO_RESET;
> +				mci_writel(host, CTRL, ctrl);
> +
> +#ifdef CONFIG_MMC_DW_IDMAC
> +				ctrl = mci_readl(host, BMOD);
> +				ctrl |= 0x01;	/* Software reset of DMA */
> +				mci_writel(host, BMOD, ctrl);
> +#endif
> +
> +			}
> +
> +			spin_unlock(&host->lock);
> +			present = dw_mci_get_cd(mmc);
> +		}
> +
> +		mmc_detect_change(slot->mmc,
> +			msecs_to_jiffies(host->pdata->detect_delay_ms));
> +	}
> +}
> +
> +static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
> +{
> +	struct mmc_host *mmc;
> +	struct dw_mci_slot *slot;
> +
> +	mmc = mmc_alloc_host(sizeof(struct dw_mci_slot), &host->pdev->dev);
> +	if (!mmc)
> +		return -ENOMEM;
> +
> +	slot = mmc_priv(mmc);
> +	slot->id = id;
> +	slot->mmc = mmc;
> +	slot->host = host;
> +
> +	mmc->ops = &dw_mci_ops;
> +	mmc->f_min = DIV_ROUND_UP(host->bus_hz, 510);
> +	mmc->f_max = host->bus_hz;
> +
> +	if (host->pdata->get_ocr)
> +		mmc->ocr_avail = host->pdata->get_ocr(id);
> +	else
> +		mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
> +
> +	/*
> +	 * Start with slot power disabled,
> +	 * will be enabled when card is detected
> +	 */
> +	if (host->pdata->setpower)
> +		host->pdata->setpower(id, 0);
> +
> +	mmc->caps = 0;
> +	if (host->pdata->get_bus_wd)
> +		if (host->pdata->get_bus_wd(slot->id) >= 4)
> +			mmc->caps |= MMC_CAP_4_BIT_DATA;
> +
> +	if (host->pdata->quirks & DW_MCI_QUIRK_HIGHSPEED)
> +		mmc->caps |= MMC_CAP_SD_HIGHSPEED;
> +
> +#ifdef CONFIG_MMC_DW_IDMAC
> +	mmc->max_segs = host->ring_size;
> +	mmc->max_blk_size = 65536;
> +	mmc->max_blk_count = host->ring_size;
> +	mmc->max_seg_size = 0x1000;
> +	mmc->max_req_size = mmc->max_seg_size * mmc->max_blk_count;
> +#else
> +	if (host->pdata->blk_settings) {
> +		mmc->max_segs = host->pdata->blk_settings->max_segs;
> +		mmc->max_blk_size = host->pdata->blk_settings->max_blk_size;
> +		mmc->max_blk_count = host->pdata->blk_settings->max_blk_count;
> +		mmc->max_req_size = host->pdata->blk_settings->max_req_size;
> +		mmc->max_seg_size = host->pdata->blk_settings->max_seg_size;
> +	} else {
> +		/*useful defaults*/
> +		mmc->max_segs = 64;
> +		mmc->max_blk_size = 65536; /* BLKSIZ is 16 bits */
> +		mmc->max_blk_count = 512;
> +		mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
> +		mmc->max_seg_size = mmc->max_req_size;
> +	}
> +#endif /* CONFIG_MMC_DW_IDMAC */
> +
> +	/* Assume card is present initially */
> +	if (dw_mci_get_cd(mmc))
> +		set_bit(DW_MMC_CARD_PRESENT, &slot->flags);
> +	else
> +		clear_bit(DW_MMC_CARD_PRESENT, &slot->flags);

Hm, does the code actually make that assumption?  Won't dw_mci_get_cd()
return an appropriate value, and have the present bit cleared if so?

> +
> +	host->slot[id] = slot;
> +	mmc_add_host(mmc);
> +
> +#if defined(CONFIG_DEBUG_FS)
> +	dw_mci_init_debugfs(slot);
> +#endif
> +
> +	/* Card initially undetected */
> +	slot->last_detect_state = 0;
> +
> +	return 0;
> +}
> +
> +static void dw_mci_cleanup_slot(struct dw_mci_slot *slot,
> +				unsigned int id)
> +{
> +	/* Shutdown detect IRQ */
> +	if (slot->host->pdata->exit)
> +		slot->host->pdata->exit(id);
> +
> +	/* Debugfs stuff is cleaned up by mmc core */
> +	mmc_remove_host(slot->mmc);
> +	slot->host->slot[id] = NULL;
> +	mmc_free_host(slot->mmc);
> +}
> +
> +static void dw_mci_init_dma(struct dw_mci *host)
> +{
> +	/* Alloc memory for sg translation */
> +	host->sg_cpu = dma_alloc_coherent(&host->pdev->dev, PAGE_SIZE,
> +			&host->sg_dma, GFP_KERNEL);
> +	if (!host->sg_cpu) {
> +		dev_err(&host->pdev->dev, "%s: could not alloc DMA memory\n",
> +				__func__);
> +		goto no_dma;
> +	}
> +
> +	/* Determine which DMA interface to use */
> +#ifdef CONFIG_MMC_DW_IDMAC
> +	host->dma_ops = &dw_mci_idmac_ops;
> +	dev_info(&host->pdev->dev, "Using internal DMA controller.\n");
> +#endif
> +
> +	if (!host->dma_ops)
> +		goto no_dma;
> +
> +	if (host->dma_ops->init) {
> +		if (host->dma_ops->init(host)) {
> +			dev_err(&host->pdev->dev, "%s: Unable to initialise "
> +					"DMA Controller.\n", __func__);
> +			goto no_dma;
> +		}
> +	} else {
> +		dev_err(&host->pdev->dev, "DMA initialisation not found.\n");
> +		goto no_dma;
> +	}
> +
> +	host->use_dma = 1;
> +	return;
> +
> +no_dma:
> +	dev_info(&host->pdev->dev, "Using PIO mode.\n");
> +	host->use_dma = 0;
> +	return;
> +}
> +
> +static bool mci_wait_reset(struct device *dev, struct dw_mci *host)
> +{
> +	unsigned long timeout = jiffies + msecs_to_jiffies(500);
> +	unsigned int ctrl;
> +
> +	mci_writel(host, CTRL, (SDMMC_CTRL_RESET |
> +			SDMMC_CTRL_FIFO_RESET | SDMMC_CTRL_DMA_RESET));
> +
> +	/* wait till resets clear */
> +	do {
> +		ctrl = mci_readl(host, CTRL);
> +		if (!(ctrl & (SDMMC_CTRL_RESET |
> +			      SDMMC_CTRL_FIFO_RESET | SDMMC_CTRL_DMA_RESET)))
> +			return true;
> +	} while (time_before(jiffies, timeout));
> +
> +	dev_err(dev, "Timeout resetting block (ctrl %#x)\n", ctrl);
> +
> +	return false;
> +}
> +
> +static int dw_mci_probe(struct platform_device *pdev)
> +{
> +	struct dw_mci *host;
> +	struct resource	*regs;
> +	struct dw_mci_board *pdata;
> +	int irq, ret, i, width;
> +	u32 fifo_size;
> +
> +	regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> +	if (!regs)
> +		return -ENXIO;
> +
> +	irq = platform_get_irq(pdev, 0);
> +	if (irq < 0)
> +		return irq;
> +
> +	host = kzalloc(sizeof(struct dw_mci), GFP_KERNEL);
> +	if (!host)
> +		return -ENOMEM;
> +
> +	host->pdev = pdev;
> +	host->pdata = pdata = pdev->dev.platform_data;
> +	if (!pdata) {
> +		dev_err(&pdev->dev, "Platform data missing\n");
> +		ret = -ENODEV;
> +		goto err_freehost;
> +	}
> +
> +	if (((pdata->num_slots > 1) && !(pdata->select_slot))
> +			|| !(pdata->init)) {
> +		dev_err(&pdev->dev, "Platform data wrong\n");
> +		ret = -ENODEV;
> +		goto err_freehost;
> +	}

"Platform data wrong" is pretty unhelpful -- perhaps you could have the
first test be (!pdata || !pdata->init), and then the second test can
explain that num_slots is > 1 without a slot selected.

> +
> +	if (!pdata->bus_hz) {
> +		dev_err(&pdev->dev,
> +			"Bus speed undefined in platform data!\n");
> +		ret = -ENODEV;
> +		goto err_freehost;
> +	}
> +
> +	host->bus_hz = pdata->bus_hz;
> +	host->quirks = pdata->quirks;
> +
> +	spin_lock_init(&host->lock);
> +	INIT_LIST_HEAD(&host->queue);
> +
> +	ret = -ENOMEM;
> +	host->regs = ioremap(regs->start, regs->end - regs->start + 1);
> +	if (!host->regs)
> +		goto err_freehost;
> +
> +	host->dma_ops = pdata->dma_ops;
> +	dw_mci_init_dma(host);
> +
> +	/*
> +	 * Get the host data width - this assumes that HCON has been set with
> +	 * the correct values.
> +	 */
> +	i = (mci_readl(host, HCON) >> 7) & 0x7;
> +	if (!i) {
> +		host->push_data = dw_mci_push_data16;
> +		host->pull_data = dw_mci_pull_data16;
> +		width = 16;
> +		host->data_shift = 1;
> +	} else if (i == 2) {
> +		host->push_data = dw_mci_push_data64;
> +		host->pull_data = dw_mci_pull_data64;
> +		width = 64;
> +		host->data_shift = 3;
> +	} else {
> +		/* Check for a reserved value, and warn if it is */
> +		WARN((i != 1),
> +			"HCON reports a reserved host data width!\n"
> +			"Defaulting to 32-bit access.\n");
> +		host->push_data = dw_mci_push_data32;
> +		host->pull_data = dw_mci_pull_data32;
> +		width = 32;
> +		host->data_shift = 2;
> +	}
> +
> +	/* reset all blocks */
> +	if (!mci_wait_reset(&pdev->dev, host)) {
> +		ret = -ENODEV;
> +		goto err_dmaunmap;
> +	}
> +
> +	 /* Clear the interrupts for the host controller */
> +	mci_writel(host, RINTSTS, 0xFFFFFFFF);
> +	mci_writel(host, INTMASK, 0); /* disable all mmc interrupt first */
> +
> +	/* Put in max timeout */
> +	mci_writel(host, TMOUT, 0xFFFFFFFF);
> +
> +	/*
> +	 * FIFO threshold settings  RxMark = fifo_size/2-1,
> +	 *                          Tx Mark =fifo_size/2 DMA Size = 8
> +	 */
> +	fifo_size = mci_readl(host, FIFOTH);
> +	fifo_size = (fifo_size >> 16) & 0x7ff;
> +	mci_writel(host, FIFOTH, ((0x2 << 28) | ((fifo_size/2 - 1) << 16) |
> +				((fifo_size/2) << 0)));
> +
> +	/* disable clock to CIU */
> +	mci_writel(host, CLKENA, 0);
> +	mci_writel(host, CLKSRC, 0);
> +
> +	tasklet_init(&host->tasklet, dw_mci_tasklet_func, (unsigned long)host);
> +	tasklet_init(&host->card_tasklet,
> +		dw_mci_tasklet_card, (unsigned long)host);
> +
> +	ret = request_irq(irq, dw_mci_interrupt, 0, "dw-mci", host);
> +	if (ret)
> +		goto err_dmaunmap;
> +
> +	platform_set_drvdata(pdev, host);
> +
> +	if (host->pdata->num_slots)
> +		host->num_slots = host->pdata->num_slots;
> +	else
> +		host->num_slots = ((mci_readl(host, HCON) >> 1) & 0x1F) + 1;
> +
> +	/* We need at least one slot to succeed ####pd####*/

What does ####pd#### mean?

> +	for (i = 0; i < host->num_slots; i++) {
> +		ret = dw_mci_init_slot(host, i);
> +		if (ret) {
> +			ret = -ENODEV;
> +			goto err_init_slot;
> +		}
> +	}
> +
> +	/*
> +	 * enable interrupt for command done, data over, data empty,
> +	 * receive ready and error such as transmit, receive timeout, crc error
> +	 */
> +	mci_writel(host, RINTSTS, 0xFFFFFFFF);
> +	mci_writel(host, INTMASK, SDMMC_INT_CMD_DONE | SDMMC_INT_DATA_OVER |
> +				SDMMC_INT_TXDR | SDMMC_INT_RXDR |
> +				DW_MCI_ERROR_FLAGS | SDMMC_INT_CD);
> +	mci_writel(host, CTRL, SDMMC_CTRL_INT_ENABLE); /*enable mci interrupt*/
> +
> +	dev_info(&pdev->dev, "DW MMC controller at irq %d, "
> +			"%d bit host data width\n",
> +			irq, width);
> +	if (host->quirks & DW_MCI_QUIRK_IDMAC_DTO)
> +		dev_info(&pdev->dev, "Internal DMAC interrupt fix enabled.\n");
> +
> +	return 0;
> +
> +err_init_slot:
> +	/* De-init any initialized slots */
> +	while (i > 0) {
> +		if (host->slot[i])
> +			dw_mci_cleanup_slot(host->slot[i], i);
> +		i--;
> +	}
> +	free_irq(irq, host);
> +
> +err_dmaunmap:
> +	if (host->use_dma && host->dma_ops->exit)
> +		host->dma_ops->exit(host);
> +	dma_free_coherent(&host->pdev->dev, PAGE_SIZE,
> +			host->sg_cpu, host->sg_dma);
> +	iounmap(host->regs);
> +
> +err_freehost:
> +	kfree(host);
> +	return ret;
> +}
> +
> +static int __exit dw_mci_remove(struct platform_device *pdev)
> +{
> +	struct dw_mci *host = platform_get_drvdata(pdev);
> +	int i;
> +
> +	mci_writel(host, RINTSTS, 0xFFFFFFFF);
> +	mci_writel(host, INTMASK, 0); /* disable all mmc interrupt first */
> +
> +	platform_set_drvdata(pdev, NULL);
> +
> +	for (i = 0; i < host->num_slots; i++) {
> +		dev_dbg(&pdev->dev, "remove slot %d\n", i);
> +		if (host->slot[i])
> +			dw_mci_cleanup_slot(host->slot[i], i);
> +	}
> +
> +	/* disable clock to CIU */
> +	mci_writel(host, CLKENA, 0);
> +	mci_writel(host, CLKSRC, 0);
> +
> +	free_irq(platform_get_irq(pdev, 0), host);
> +	dma_free_coherent(&pdev->dev, PAGE_SIZE, host->sg_cpu, host->sg_dma);
> +
> +	if (host->use_dma && host->dma_ops->exit)
> +		host->dma_ops->exit(host);
> +
> +	iounmap(host->regs);
> +
> +	kfree(host);
> +	return 0;
> +}
> +
> +#ifdef CONFIG_PM
> +/*
> + * TODO: we should probably disable the clock to the card in the suspend path.
> + */
> +static int dw_mci_suspend(struct platform_device *pdev, pm_message_t mesg)
> +{
> +	int i, ret;
> +	struct dw_mci *host = platform_get_drvdata(pdev);
> +
> +	for (i = 0; i < host->num_slots; i++) {
> +		struct dw_mci_slot *slot = host->slot[i];
> +		if (!slot)
> +			continue;
> +		ret = mmc_suspend_host(slot->mmc);
> +		if (ret < 0) {
> +			while (--i >= 0) {
> +				slot = host->slot[i];
> +				if (slot)
> +					mmc_resume_host(host->slot[i]->mmc);
> +			}
> +			return ret;
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +static int dw_mci_resume(struct platform_device *pdev)
> +{
> +	int i, ret;
> +	struct dw_mci *host = platform_get_drvdata(pdev);
> +
> +	for (i = 0; i < host->num_slots; i++) {
> +		struct dw_mci_slot *slot = host->slot[i];
> +		if (!slot)
> +			continue;
> +		ret = mmc_resume_host(host->slot[i]->mmc);
> +		if (ret < 0)
> +			return ret;
> +	}
> +
> +	return 0;
> +}
> +#else
> +#define dw_mci_suspend	NULL
> +#define dw_mci_resume	NULL
> +#endif /* CONFIG_PM */
> +
> +static struct platform_driver dw_mci_driver = {
> +	.remove		= __exit_p(dw_mci_remove),
> +	.suspend	= dw_mci_suspend,
> +	.resume		= dw_mci_resume,
> +	.driver		= {
> +		.name		= "dw_mmc",
> +	},
> +};
> +
> +static int __init dw_mci_init(void)
> +{
> +	return platform_driver_probe(&dw_mci_driver, dw_mci_probe);
> +}
> +
> +static void __exit dw_mci_exit(void)
> +{
> +	platform_driver_unregister(&dw_mci_driver);
> +}
> +
> +module_init(dw_mci_init);
> +module_exit(dw_mci_exit);
> +
> +MODULE_DESCRIPTION("DW Multimedia Card Interface driver");
> +MODULE_AUTHOR("NXP Semiconductor VietNam");
> +MODULE_AUTHOR("Imagination Technologies Ltd");
> +MODULE_LICENSE("GPL v2");
> diff --git a/drivers/mmc/host/dw_mmc.h b/drivers/mmc/host/dw_mmc.h
> new file mode 100644
> index 0000000..0ec6856
> --- /dev/null
> +++ b/drivers/mmc/host/dw_mmc.h
> @@ -0,0 +1,153 @@
> +/*
> + * Synopsys DesignWare Multimedia Card Interface driver
> + *  (Based on NXP driver for lpc 31xx)
> + *
> + * Copyright (C) 2009 NXP Semiconductors
> + * Copyright (C) 2009, 2010 Imagination Technologies Ltd.
> + *
> + * 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; either version 2 of the License, or
> + * (at your option) any later version.
> + */
> +
> +#ifndef _DW_MMC_H_
> +#define _DW_MMC_H_
> +
> +#define SDMMC_CTRL		0x000
> +#define SDMMC_PWREN		0x004
> +#define SDMMC_CLKDIV		0x008
> +#define SDMMC_CLKSRC		0x00c
> +#define SDMMC_CLKENA		0x010
> +#define SDMMC_TMOUT		0x014
> +#define SDMMC_CTYPE		0x018
> +#define SDMMC_BLKSIZ		0x01c
> +#define SDMMC_BYTCNT		0x020
> +#define SDMMC_INTMASK		0x024
> +#define SDMMC_CMDARG		0x028
> +#define SDMMC_CMD		0x02c
> +#define SDMMC_RESP0		0x030
> +#define SDMMC_RESP1		0x034
> +#define SDMMC_RESP2		0x038
> +#define SDMMC_RESP3		0x03c
> +#define SDMMC_MINTSTS		0x040
> +#define SDMMC_RINTSTS		0x044
> +#define SDMMC_STATUS		0x048
> +#define SDMMC_FIFOTH		0x04c
> +#define SDMMC_CDETECT		0x050
> +#define SDMMC_WRTPRT		0x054
> +#define SDMMC_GPIO		0x058
> +#define SDMMC_TCBCNT		0x05c
> +#define SDMMC_TBBCNT		0x060
> +#define SDMMC_DEBNCE		0x064
> +#define SDMMC_USRID		0x068
> +#define SDMMC_VERID		0x06c
> +#define SDMMC_HCON		0x070
> +#define SDMMC_BMOD		0x080
> +#define SDMMC_PLDMND		0x084
> +#define SDMMC_DBADDR		0x088
> +#define SDMMC_IDSTS		0x08c
> +#define SDMMC_IDINTEN		0x090
> +#define SDMMC_DSCADDR		0x094
> +#define SDMMC_BUFADDR		0x098
> +#define SDMMC_DATA		0x100
> +#define SDMMC_DATA_ADR		0x100
> +
> +/* shift bit field */
> +#define _SBF(f, v)		((v) << (f))
> +
> +/* Control register defines */
> +#define SDMMC_CTRL_USE_IDMAC		BIT(25)
> +#define SDMMC_CTRL_CEATA_INT_EN		BIT(11)
> +#define SDMMC_CTRL_SEND_AS_CCSD		BIT(10)
> +#define SDMMC_CTRL_SEND_CCSD		BIT(9)
> +#define SDMMC_CTRL_ABRT_READ_DATA	BIT(8)
> +#define SDMMC_CTRL_SEND_IRQ_RESP	BIT(7)
> +#define SDMMC_CTRL_READ_WAIT		BIT(6)
> +#define SDMMC_CTRL_DMA_ENABLE		BIT(5)
> +#define SDMMC_CTRL_INT_ENABLE		BIT(4)
> +#define SDMMC_CTRL_DMA_RESET		BIT(2)
> +#define SDMMC_CTRL_FIFO_RESET		BIT(1)
> +#define SDMMC_CTRL_RESET		BIT(0)
> +/* Clock Enable register defines */
> +#define SDMMC_CLKEN_LOW_PWR		BIT(16)
> +#define SDMMC_CLKEN_ENABLE		BIT(0)
> +/* time-out register defines */
> +#define SDMMC_TMOUT_DATA(n)		_SBF(8, (n))
> +#define SDMMC_TMOUT_DATA_MSK		0xFFFFFF00
> +#define SDMMC_TMOUT_RESP(n)		((n) & 0xFF)
> +#define SDMMC_TMOUT_RESP_MSK		0xFF
> +/* card-type register defines */
> +#define SDMMC_CTYPE_8BIT		BIT(16)
> +#define SDMMC_CTYPE_4BIT		BIT(0)
> +#define SDMMC_CTYPE_1BIT		0
> +/* Interrupt status & mask register defines */
> +#define SDMMC_INT_SDIO			BIT(16)
> +#define SDMMC_INT_EBE			BIT(15)
> +#define SDMMC_INT_ACD			BIT(14)
> +#define SDMMC_INT_SBE			BIT(13)
> +#define SDMMC_INT_HLE			BIT(12)
> +#define SDMMC_INT_FRUN			BIT(11)
> +#define SDMMC_INT_HTO			BIT(10)
> +#define SDMMC_INT_DTO			BIT(9)
> +#define SDMMC_INT_RTO			BIT(8)
> +#define SDMMC_INT_DCRC			BIT(7)
> +#define SDMMC_INT_RCRC			BIT(6)
> +#define SDMMC_INT_RXDR			BIT(5)
> +#define SDMMC_INT_TXDR			BIT(4)
> +#define SDMMC_INT_DATA_OVER		BIT(3)
> +#define SDMMC_INT_CMD_DONE		BIT(2)
> +#define SDMMC_INT_RESP_ERR		BIT(1)
> +#define SDMMC_INT_CD			BIT(0)
> +#define SDMMC_INT_ERROR			0xbfc2
> +/* Command register defines */
> +#define SDMMC_CMD_START			BIT(31)
> +#define SDMMC_CMD_CCS_EXP		BIT(23)
> +#define SDMMC_CMD_CEATA_RD		BIT(22)
> +#define SDMMC_CMD_UPD_CLK		BIT(21)
> +#define SDMMC_CMD_INIT			BIT(15)
> +#define SDMMC_CMD_STOP			BIT(14)
> +#define SDMMC_CMD_PRV_DAT_WAIT		BIT(13)
> +#define SDMMC_CMD_SEND_STOP		BIT(12)
> +#define SDMMC_CMD_STRM_MODE		BIT(11)
> +#define SDMMC_CMD_DAT_WR		BIT(10)
> +#define SDMMC_CMD_DAT_EXP		BIT(9)
> +#define SDMMC_CMD_RESP_CRC		BIT(8)
> +#define SDMMC_CMD_RESP_LONG		BIT(7)
> +#define SDMMC_CMD_RESP_EXP		BIT(6)
> +#define SDMMC_CMD_INDX(n)		((n) & 0x1F)
> +/* Status register defines */
> +#define SDMMC_GET_FCNT(x)		(((x)>>17) & 0x1FF)
> +#define SDMMC_FIFO_SZ			32
> +/* Internal DMAC interrupt defines */
> +#define SDMMC_IDMAC_INT_AI		BIT(9)
> +#define SDMMC_IDMAC_INT_NI		BIT(8)
> +#define SDMMC_IDMAC_INT_CES		BIT(5)
> +#define SDMMC_IDMAC_INT_DU		BIT(4)
> +#define SDMMC_IDMAC_INT_FBE		BIT(2)
> +#define SDMMC_IDMAC_INT_RI		BIT(1)
> +#define SDMMC_IDMAC_INT_TI		BIT(0)
> +/* Internal DMAC bus mode bits */
> +#define SDMMC_IDMAC_ENABLE		BIT(7)
> +#define SDMMC_IDMAC_FB			BIT(1)
> +#define SDMMC_IDMAC_SWRESET		BIT(0)
> +
> +/* Register access macros */
> +#define mci_readl(dev, reg)			\
> +	__raw_readl(dev->regs + SDMMC_##reg)
> +#define mci_writel(dev, reg, value)			\
> +	__raw_writel((value), dev->regs + SDMMC_##reg)
> +
> +/* 16-bit FIFO access macros */
> +#define mci_readw(dev, reg)			\
> +	__raw_readw(dev->regs + SDMMC_##reg)
> +#define mci_writew(dev, reg, value)			\
> +	__raw_writew((value), dev->regs + SDMMC_##reg)
> +
> +/* 64-bit FIFO access macros */
> +#define mci_readq(dev, reg)			\
> +	__raw_readq(dev->regs + SDMMC_##reg)
> +#define mci_writeq(dev, reg, value)			\
> +	__raw_writeq((value), dev->regs + SDMMC_##reg)
> +
> +#endif /* _DW_MMC_H_ */
> diff --git a/include/linux/mmc/dw_mmc.h b/include/linux/mmc/dw_mmc.h
> new file mode 100644
> index 0000000..a037b56
> --- /dev/null
> +++ b/include/linux/mmc/dw_mmc.h
> @@ -0,0 +1,149 @@
> +/*
> + * Synopsys DesignWare Multimedia Card Interface driver
> + *  (Based on NXP driver for lpc 31xx)
> + *
> + * Copyright (C) 2009 NXP Semiconductors
> + * Copyright (C) 2009, 2010 Imagination Technologies Ltd.
> + *
> + * 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; either version 2 of the License, or
> + * (at your option) any later version.
> + */
> +
> +#ifndef _LINUX_MMC_DW_MMC_H_
> +#define _LINUX_MMC_DW_MMC_H_
> +
> +#define MAX_MCI_SLOTS	2
> +
> +enum dw_mci_state {
> +	STATE_IDLE = 0,
> +	STATE_SENDING_CMD,
> +	STATE_SENDING_DATA,
> +	STATE_DATA_BUSY,
> +	STATE_SENDING_STOP,
> +	STATE_DATA_ERROR,
> +};
> +
> +enum {
> +	EVENT_CMD_COMPLETE = 0,
> +	EVENT_XFER_COMPLETE,
> +	EVENT_DATA_COMPLETE,
> +	EVENT_DATA_ERROR,
> +	EVENT_XFER_ERROR
> +};
> +
> +struct mmc_data;
> +
> +struct dw_mci {
> +	spinlock_t		lock;
> +	void __iomem		*regs;
> +
> +	struct scatterlist	*sg;
> +	unsigned int		pio_offset;
> +
> +	struct dw_mci_slot	*cur_slot;
> +	struct mmc_request	*mrq;
> +	struct mmc_command	*cmd;
> +	struct mmc_data		*data;
> +
> +	/* DMA interface members*/
> +	int			use_dma;
> +
> +	dma_addr_t		sg_dma;
> +	void			*sg_cpu;
> +	struct dw_mci_dma_ops	*dma_ops;
> +#ifdef CONFIG_MMC_DW_IDMAC
> +	unsigned int		ring_size;
> +#else
> +	struct dw_mci_dma_data	*dma_data;
> +#endif
> +	u32			cmd_status;
> +	u32			data_status;
> +	u32			stop_cmdr;
> +	u32			dir_status;
> +	struct tasklet_struct	tasklet;
> +	struct tasklet_struct	card_tasklet;
> +	unsigned long		pending_events;
> +	unsigned long		completed_events;
> +	enum dw_mci_state	state;
> +	struct list_head	queue;
> +
> +	u32			bus_hz;
> +	u32			current_speed;
> +	u32			num_slots;
> +	struct platform_device	*pdev;
> +	struct dw_mci_board	*pdata;
> +	struct dw_mci_slot	*slot[MAX_MCI_SLOTS];
> +
> +	/* FIFO push and pull */
> +	int			data_shift;
> +	void (*push_data)(struct dw_mci *host, void *buf, int cnt);
> +	void (*pull_data)(struct dw_mci *host, void *buf, int cnt);
> +
> +	/* Workaround flags */
> +	u32			quirks;
> +};
> +
> +/* DMA ops for Internal/External DMAC interface */
> +struct dw_mci_dma_ops {
> +	/* DMA Ops */
> +	int (*init)(struct dw_mci *host);
> +	void (*start)(struct dw_mci *host, unsigned int sg_len);
> +	void (*complete)(struct dw_mci *host);
> +	void (*stop)(struct dw_mci *host);
> +	void (*cleanup)(struct dw_mci *host);
> +	void (*exit)(struct dw_mci *host);
> +};
> +
> +/* IP Quirks/flags. */
> +/* No special quirks or flags to cater for */
> +#define DW_MCI_QUIRK_NONE		0
> +/* DTO fix for command transmission with IDMAC configured */
> +#define DW_MCI_QUIRK_IDMAC_DTO		1
> +/* delay needed between retries on some 2.11a implementations */
> +#define DW_MCI_QUIRK_RETRY_DELAY	2
> +/* High Speed Capable - Supports HS cards (upto 50MHz) */
> +#define DW_MCI_QUIRK_HIGHSPEED		4
> +
> +
> +struct dma_pdata;
> +
> +struct block_settings {
> +	unsigned short	max_segs;	/* see blk_queue_max_segments */
> +	unsigned int	max_blk_size;	/* maximum size of one mmc block */
> +	unsigned int	max_blk_count;	/* maximum number of blocks in one req*/
> +	unsigned int	max_req_size;	/* maximum number of bytes in one req*/
> +	unsigned int	max_seg_size;	/* see blk_queue_max_segment_size */
> +};
> +
> +/* Board platform data */
> +struct dw_mci_board {
> +	u32 num_slots;
> +
> +	u32 quirks; /* Workaround / Quirk flags */
> +	unsigned int bus_hz; /* Bus speed */
> +
> +	/* delay in mS before detecting cards after interrupt */
> +	u32 detect_delay_ms;
> +
> +	int (*init)(u32 slot_id, irq_handler_t , void *);
> +	int (*get_ro)(u32 slot_id);
> +	int (*get_cd)(u32 slot_id);
> +	int (*get_ocr)(u32 slot_id);
> +	int (*get_bus_wd)(u32 slot_id);
> +	/*
> +	 * Enable power to selected slot and set voltage to desired level.
> +	 * Voltage levels are specified using MMC_VDD_xxx defines defined
> +	 * in linux/mmc/host.h file.
> +	 */
> +	void (*setpower)(u32 slot_id, u32 volt);
> +	void (*exit)(u32 slot_id);
> +	void (*select_slot)(u32 slot_id);
> +
> +	struct dw_mci_dma_ops *dma_ops;
> +	struct dma_pdata *data;
> +	struct block_settings *blk_settings;
> +};
> +
> +#endif /* _LINUX_MMC_DW_MMC_H_ */


Cleanup patch:

diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c
index 7de6b42..9c5c33a 100644
--- a/drivers/mmc/host/dw_mmc.c
+++ b/drivers/mmc/host/dw_mmc.c
@@ -9,16 +9,6 @@
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
- *
- * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
  */
 
 #include <linux/blkdev.h>
@@ -119,20 +109,20 @@ static int dw_mci_req_show(struct seq_file *s, void *v)
 
 		if (cmd)
 			seq_printf(s,
-				"CMD%u(0x%x) flg %x rsp %x %x %x %x err %d\n",
-				cmd->opcode, cmd->arg, cmd->flags,
-				cmd->resp[0], cmd->resp[1], cmd->resp[2],
-				cmd->resp[2], cmd->error);
+				   "CMD%u(0x%x) flg %x rsp %x %x %x %x err %d\n",
+				   cmd->opcode, cmd->arg, cmd->flags,
+				   cmd->resp[0], cmd->resp[1], cmd->resp[2],
+				   cmd->resp[2], cmd->error);
 		if (data)
 			seq_printf(s, "DATA %u / %u * %u flg %x err %d\n",
-				data->bytes_xfered, data->blocks,
-				data->blksz, data->flags, data->error);
+				   data->bytes_xfered, data->blocks,
+				   data->blksz, data->flags, data->error);
 		if (stop)
 			seq_printf(s,
-				"CMD%u(0x%x) flg %x rsp %x %x %x %x err %d\n",
-				stop->opcode, stop->arg, stop->flags,
-				stop->resp[0], stop->resp[1], stop->resp[2],
-				stop->resp[2], stop->error);
+				   "CMD%u(0x%x) flg %x rsp %x %x %x %x err %d\n",
+				   stop->opcode, stop->arg, stop->flags,
+				   stop->resp[0], stop->resp[1], stop->resp[2],
+				   stop->resp[2], stop->error);
 	}
 
 	spin_unlock_bh(&slot->host->lock);
@@ -190,12 +180,11 @@ static void dw_mci_init_debugfs(struct dw_mci_slot *slot)
 		return;
 
 	node = debugfs_create_file("regs", S_IRUSR, root, host,
-			&dw_mci_regs_fops);
+				   &dw_mci_regs_fops);
 	if (!node)
 		goto err;
 
-	node = debugfs_create_file("req", S_IRUSR, root, slot,
-			&dw_mci_req_fops);
+	node = debugfs_create_file("req", S_IRUSR, root, slot, &dw_mci_req_fops);
 	if (!node)
 		goto err;
 
@@ -204,12 +193,12 @@ static void dw_mci_init_debugfs(struct dw_mci_slot *slot)
 		goto err;
 
 	node = debugfs_create_x32("pending_events", S_IRUSR, root,
-				     (u32 *)&host->pending_events);
+				  (u32 *)&host->pending_events);
 	if (!node)
 		goto err;
 
 	node = debugfs_create_x32("completed_events", S_IRUSR, root,
-				     (u32 *)&host->completed_events);
+				  (u32 *)&host->completed_events);
 	if (!node)
 		goto err;
 
@@ -225,8 +214,7 @@ static void dw_mci_set_timeout(struct dw_mci *host)
 	mci_writel(host, TMOUT, 0xffffffff); /* timeout (maximum) */
 }
 
-static u32 dw_mci_prepare_command(struct mmc_host *mmc,
-				  struct mmc_command *cmd)
+static u32 dw_mci_prepare_command(struct mmc_host *mmc, struct mmc_command *cmd)
 {
 	struct mmc_data	*data;
 	u32 cmdr;
@@ -243,7 +231,7 @@ static u32 dw_mci_prepare_command(struct mmc_host *mmc,
 		cmdr |= SDMMC_CMD_RESP_EXP;
 		/* expect the respond, need to set this bit */
 		if (cmd->flags & MMC_RSP_136)
-			cmdr |= SDMMC_CMD_RESP_LONG; /* expect long respond */
+			cmdr |= SDMMC_CMD_RESP_LONG;
 	}
 
 	if (cmd->flags & MMC_RSP_CRC)
@@ -253,7 +241,7 @@ static u32 dw_mci_prepare_command(struct mmc_host *mmc,
 	if (data) {
 		cmdr |= SDMMC_CMD_DAT_EXP;
 		if (data->flags & MMC_DATA_STREAM)
-			cmdr |= SDMMC_CMD_STRM_MODE; /*  set stream mode */
+			cmdr |= SDMMC_CMD_STRM_MODE;
 		if (data->flags & MMC_DATA_WRITE)
 			cmdr |= SDMMC_CMD_DAT_WR;
 	}
@@ -265,9 +253,8 @@ static void dw_mci_start_command(struct dw_mci *host,
 				 struct mmc_command *cmd, u32 cmd_flags)
 {
 	host->cmd = cmd;
-	dev_vdbg(&host->pdev->dev,
-			"start command: ARGR=0x%08x CMDR=0x%08x\n",
-			cmd->arg, cmd_flags);
+	dev_vdbg(&host->pdev->dev, "start command: ARGR=0x%08x CMDR=0x%08x\n",
+		 cmd->arg, cmd_flags);
 
 	/* write to CMDARG register */
 	mci_writel(host, CMDARG, cmd->arg);
@@ -288,7 +275,6 @@ static void dw_mci_stop_dma(struct dw_mci *host)
 	if (host->use_dma) {
 		host->dma_ops->stop(host);
 		host->dma_ops->cleanup(host);
-
 	} else {
 		/* Data transfer was stopped by the interrupt handler */
 		set_bit(EVENT_XFER_COMPLETE, &host->pending_events);
@@ -302,8 +288,8 @@ static void dw_mci_dma_cleanup(struct dw_mci *host)
 
 	if (data)
 		dma_unmap_sg(&host->pdev->dev, data->sg, data->sg_len,
-		     ((data->flags & MMC_DATA_WRITE)
-		      ? DMA_TO_DEVICE : DMA_FROM_DEVICE));
+			     ((data->flags & MMC_DATA_WRITE)
+			      ? DMA_TO_DEVICE : DMA_FROM_DEVICE));
 }
 
 static void dw_mci_idmac_stop_dma(struct dw_mci *host)
@@ -340,8 +326,8 @@ static void dw_mci_idmac_complete_dma(struct dw_mci *host)
 	}
 }
 
-static void dw_mci_translate_sglist(struct dw_mci *host,
-				    struct mmc_data *data, unsigned int sg_len)
+static void dw_mci_translate_sglist(struct dw_mci *host, struct mmc_data *data,
+				    unsigned int sg_len)
 {
 	int i;
 	struct idmac_desc *desc = host->sg_cpu;
@@ -412,7 +398,7 @@ static int dw_mci_idmac_init(struct dw_mci *host)
 
 	/* Mask out interrupts - get Tx & Rx complete only */
 	mci_writel(host, IDINTEN, SDMMC_IDMAC_INT_NI | SDMMC_IDMAC_INT_RI |
-			SDMMC_IDMAC_INT_TI);
+		   SDMMC_IDMAC_INT_TI);
 
 	/* Set the descriptor base address */
 	mci_writel(host, DBADDR, host->sg_dma);
@@ -458,12 +444,11 @@ static int dw_mci_submit_data_dma(struct dw_mci *host, struct mmc_data *data)
 	else
 		direction = DMA_TO_DEVICE;
 
-	sg_len = dma_map_sg(&host->pdev->dev, data->sg, data->sg_len,
-				   direction);
+	sg_len = dma_map_sg(&host->pdev->dev, data->sg, data->sg_len, direction);
 
 	dev_vdbg(&host->pdev->dev,
-		"sd sg_cpu: %#lx sg_dma: %#lx sg_len: %d\n",
-		(unsigned long)host->sg_cpu, (unsigned long)host->sg_dma,
+		 "sd sg_cpu: %#lx sg_dma: %#lx sg_len: %d\n",
+		 (unsigned long)host->sg_cpu, (unsigned long)host->sg_dma,
 		 sg_len);
 
 	/* Enable the DMA interface */
@@ -471,7 +456,7 @@ static int dw_mci_submit_data_dma(struct dw_mci *host, struct mmc_data *data)
 	temp |= SDMMC_CTRL_DMA_ENABLE;
 	mci_writel(host, CTRL, temp);
 
-	/* disable irq of RX & TX, let DMA handle it */
+	/* Disable RX/TX IRQs, let DMA handle it */
 	temp = mci_readl(host, INTMASK);
 	temp  &= ~(SDMMC_INT_RXDR | SDMMC_INT_TXDR);
 	mci_writel(host, INTMASK, temp);
@@ -537,18 +522,17 @@ static void dw_mci_setup_bus(struct dw_mci_slot *slot)
 	if (slot->clock != host->current_speed) {
 		if (host->bus_hz % slot->clock)
 			/*
-			 * move the + 1 after the dvide
-			 * to prevent over-clocking the card.
+			 * move the "+ 1" after the divide to prevent
+			 * over-clocking the card.
 			 */
 			div = ((host->bus_hz / slot->clock) >> 1) + 1;
 		else
 			div = (host->bus_hz  / slot->clock) >> 1;
 
 		dev_info(&slot->mmc->class_dev,
-			"Bus speed (slot %d) = %dHz (slot req %dHz, actual %dHZ"
-			" div = %d)\n",
-			slot->id, host->bus_hz, slot->clock,
-			div ? ((host->bus_hz / div) >> 1) : host->bus_hz, div);
+			 "Bus speed (slot %d) = %dHz (slot req %dHz, actual %dHZ"
+			 " div = %d)\n", slot->id, host->bus_hz, slot->clock,
+			 div ? ((host->bus_hz / div) >> 1) : host->bus_hz, div);
 
 		/* disable clock */
 		mci_writel(host, CLKENA, 0);
@@ -556,21 +540,21 @@ static void dw_mci_setup_bus(struct dw_mci_slot *slot)
 
 		/* inform CIU */
 		mci_send_cmd(slot,
-			SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT, 0);
+			     SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT, 0);
 
 		/* set clock to desired speed */
 		mci_writel(host, CLKDIV, div);
 
 		/* inform CIU */
 		mci_send_cmd(slot,
-			SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT, 0);
+			     SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT, 0);
 
 		/* enable clock */
 		mci_writel(host, CLKENA, SDMMC_CLKEN_ENABLE);
 
 		/* inform CIU */
 		mci_send_cmd(slot,
-			SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT, 0);
+			     SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT, 0);
 
 		host->current_speed = slot->clock;
 	}
@@ -579,8 +563,7 @@ static void dw_mci_setup_bus(struct dw_mci_slot *slot)
 	mci_writel(host, CTYPE, slot->ctype);
 }
 
-static void dw_mci_start_request(struct dw_mci *host,
-				 struct dw_mci_slot *slot)
+static void dw_mci_start_request(struct dw_mci *host, struct dw_mci_slot *slot)
 {
 	struct mmc_request *mrq;
 	struct mmc_command *cmd;
@@ -632,7 +615,7 @@ static void dw_mci_queue_request(struct dw_mci *host, struct dw_mci_slot *slot,
 				 struct mmc_request *mrq)
 {
 	dev_vdbg(&slot->mmc->class_dev, "queue request: state=%d\n",
-			host->state);
+		 host->state);
 
 	spin_lock_bh(&host->lock);
 	slot->mrq = mrq;
@@ -703,16 +686,15 @@ static int dw_mci_get_ro(struct mmc_host *mmc)
 	struct dw_mci_slot *slot = mmc_priv(mmc);
 	struct dw_mci_board *brd = slot->host->pdata;
 
-	if (brd->get_ro != NULL) {
+	/* Use platform get_ro function, else try on board write protect */
+	if (brd->get_ro)
 		read_only = brd->get_ro(slot->id);
-	} else {
-		/* Try on board write protect */
-		read_only =
+	else
+		read_only = 
 			mci_readl(slot->host, WRTPRT) & (1 << slot->id) ? 1 : 0;
-	}
 
 	dev_dbg(&mmc->class_dev, "card is %s\n",
-				read_only ? "read-only" : "read-write");
+		read_only ? "read-only" : "read-write");
 
 	return read_only;
 }
@@ -723,13 +705,17 @@ static int dw_mci_get_cd(struct mmc_host *mmc)
 	struct dw_mci_slot *slot = mmc_priv(mmc);
 	struct dw_mci_board *brd = slot->host->pdata;
 
-	if (brd->get_cd != NULL)
+	/* Use platform get_cd function, else try onboard card detect */
+	if (brd->get_cd)
 		present = !brd->get_cd(slot->id);
-	else	/* try onboard card detect */
+	else 
 		present = (mci_readl(slot->host, CDETECT) & (1 << slot->id))
-				== 0 ? 1 : 0;
+			== 0 ? 1 : 0;
 
-	dev_dbg(&mmc->class_dev, "card is %spresent\n", present ? "" : "not ");
+	if (present)
+		dev_dbg("card is present\n");
+	else
+		dev_dbg("card is not present\n");
 
 	return present;
 }
@@ -754,10 +740,10 @@ static void dw_mci_request_end(struct dw_mci *host, struct mmc_request *mrq)
 	host->mrq = NULL;
 	if (!list_empty(&host->queue)) {
 		slot = list_entry(host->queue.next,
-				struct dw_mci_slot, queue_node);
+				  struct dw_mci_slot, queue_node);
 		list_del(&slot->queue_node);
 		dev_vdbg(&host->pdev->dev, "list not empty: %s is next\n",
-				mmc_hostname(slot->mmc));
+			 mmc_hostname(slot->mmc));
 		host->state = STATE_SENDING_CMD;
 		dw_mci_start_request(host, slot);
 	} else {
@@ -767,12 +753,10 @@ static void dw_mci_request_end(struct dw_mci *host, struct mmc_request *mrq)
 
 	spin_unlock(&host->lock);
 	mmc_request_done(prev_mmc, mrq);
-
 	spin_lock(&host->lock);
 }
 
-static void dw_mci_command_complete(struct dw_mci *host,
-				    struct mmc_command *cmd)
+static void dw_mci_command_complete(struct dw_mci *host, struct mmc_command *cmd)
 {
 	u32 status = host->cmd_status;
 
@@ -879,14 +863,14 @@ static void dw_mci_tasklet_func(unsigned long priv)
 			set_bit(EVENT_DATA_COMPLETE, &host->completed_events);
 			status = host->data_status;
 
-			if (unlikely(status & DW_MCI_DATA_ERROR_FLAGS)) {
+			if (status & DW_MCI_DATA_ERROR_FLAGS)) {
 				if (status & SDMMC_INT_DTO) {
 					dev_err(&host->pdev->dev,
-							"data timeout error\n");
+						"data timeout error\n");
 					data->error = -ETIMEDOUT;
 				} else if (status & SDMMC_INT_DCRC) {
 					dev_err(&host->pdev->dev,
-							"data CRC error\n");
+						"data CRC error\n");
 					data->error = -EILSEQ;
 				} else {
 					dev_err(&host->pdev->dev,
@@ -938,80 +922,80 @@ unlock:
 
 static void dw_mci_push_data16(struct dw_mci *host, void *buf, int cnt)
 {
-	u16 *pData = (u16 *)buf;
+	u16 *pdata = (u16 *)buf;
 
 	WARN_ON(cnt % 2 != 0);
 
 	cnt = cnt >> 1;
 	while (cnt > 0) {
-		mci_writew(host, DATA, *pData++);
+		mci_writew(host, DATA, *pdata++);
 		cnt--;
 	}
 }
 
 static void dw_mci_pull_data16(struct dw_mci *host, void *buf, int cnt)
 {
-	u16 *pData = (u16 *)buf;
+	u16 *pdata = (u16 *)buf;
 
 	WARN_ON(cnt % 2 != 0);
 
 	cnt = cnt >> 1;
 	while (cnt > 0) {
-		*pData++ = mci_readw(host, DATA);
+		*pdata++ = mci_readw(host, DATA);
 		cnt--;
 	}
 }
 
 static void dw_mci_push_data32(struct dw_mci *host, void *buf, int cnt)
 {
-	u32 *pData = (u32 *)buf;
+	u32 *pdata = (u32 *)buf;
 
 	WARN_ON(cnt % 4 != 0);
-	WARN_ON((unsigned long)pData & 0x3);
+	WARN_ON((unsigned long)pdata & 0x3);
 
 	cnt = cnt >> 2;
 	while (cnt > 0) {
-		mci_writel(host, DATA, *pData++);
+		mci_writel(host, DATA, *pdata++);
 		cnt--;
 	}
 }
 
 static void dw_mci_pull_data32(struct dw_mci *host, void *buf, int cnt)
 {
-	u32 *pData = (u32 *)buf;
+	u32 *pdata = (u32 *)buf;
 
 	WARN_ON(cnt % 4 != 0);
-	WARN_ON((unsigned long)pData & 0x3);
+	WARN_ON((unsigned long)pdata & 0x3);
 
 	cnt = cnt >> 2;
 	while (cnt > 0) {
-		*pData++ = mci_readl(host, DATA);
+		*pdata++ = mci_readl(host, DATA);
 		cnt--;
 	}
 }
 
 static void dw_mci_push_data64(struct dw_mci *host, void *buf, int cnt)
 {
-	u64 *pData = (u64 *)buf;
+	u64 *pdata = (u64 *)buf;
 
 	WARN_ON(cnt % 8 != 0);
 
 	cnt = cnt >> 3;
 	while (cnt > 0) {
-		mci_writeq(host, DATA, *pData++);
+		mci_writeq(host, DATA, *pdata++);
 		cnt--;
 	}
 }
 
 static void dw_mci_pull_data64(struct dw_mci *host, void *buf, int cnt)
 {
-	u64 *pData = (u64 *)buf;
+	u64 *pdata = (u64 *)buf;
 
 	WARN_ON(cnt % 8 != 0);
 
 	cnt = cnt >> 3;
 	while (cnt > 0) {
-		*pData++ = mci_readq(host, DATA);
+		*pdata++ = mci_readq(host, DATA);
 		cnt--;
 	}
 }
@@ -1031,7 +1015,7 @@ static void dw_mci_read_data_pio(struct dw_mci *host)
 		if (count == 0)
 			old_len = len;
 
-		if (likely(offset + len <= sg->length)) {
+		if (offset + len <= sg->length)) {
 			host->pull_data(host, (void *)(buf + offset), len);
 
 			offset += len;
@@ -1049,7 +1033,7 @@ static void dw_mci_read_data_pio(struct dw_mci *host)
 		} else {
 			unsigned int remaining = sg->length - offset;
 			host->pull_data(host,
-				(void *)(buf + offset), remaining);
+					(void *)(buf + offset), remaining);
 			nbytes += remaining;
 
 			flush_dcache_page(sg_page(sg));
@@ -1076,8 +1060,7 @@ static void dw_mci_read_data_pio(struct dw_mci *host)
 			return;
 		}
 		count++;
-	} while (status & SDMMC_INT_RXDR); /*if the RXDR is ready
-						lets read again*/
+	} while (status & SDMMC_INT_RXDR); /* if the RXDR is ready, read again */
 	len = SDMMC_GET_FCNT(mci_readl(host, STATUS));
 	host->pio_offset = offset;
 	data->bytes_xfered += nbytes;
@@ -1102,7 +1085,7 @@ static void dw_mci_write_data_pio(struct dw_mci *host)
 	do {
 		len = SDMMC_FIFO_SZ -
 			(SDMMC_GET_FCNT(mci_readl(host, STATUS)) << shift);
-		if (likely(offset + len <= sg->length)) {
+		if (offset + len <= sg->length)) {
 			host->push_data(host, (void *)(buf + offset), len);
 
 			offset += len;
@@ -1119,7 +1102,7 @@ static void dw_mci_write_data_pio(struct dw_mci *host)
 			unsigned int remaining = sg->length - offset;
 
 			host->push_data(host,
-				(void *)(buf + offset), remaining);
+					(void *)(buf + offset), remaining);
 			nbytes += remaining;
 
 			host->sg = sg = sg_next(sg);
@@ -1145,7 +1128,7 @@ static void dw_mci_write_data_pio(struct dw_mci *host)
 			tasklet_schedule(&host->tasklet);
 			return;
 		}
-	} while (status & SDMMC_INT_TXDR); /* if TXDR, lets write again */
+	} while (status & SDMMC_INT_TXDR); /* if TXDR, write again */
 
 	host->pio_offset = offset;
 	data->bytes_xfered += nbytes;
@@ -1172,12 +1155,12 @@ static void dw_mci_cmd_interrupt(struct dw_mci *host, u32 status)
 static irqreturn_t dw_mci_interrupt(int irq, void *dev_id)
 {
 	struct dw_mci *host = dev_id;
-	u32 status,  pending;
+	u32 status, pending;
 	unsigned int pass_count = 0;
 
 	do {
 		status = mci_readl(host, RINTSTS);
-		pending = mci_readl(host, MINTSTS);/* read only mask reg */
+		pending = mci_readl(host, MINTSTS); /* read-only mask reg */
 
 		/*
 		 * DTO fix - version 2.10a and below, and only if internal DMA
@@ -1201,7 +1184,7 @@ static irqreturn_t dw_mci_interrupt(int irq, void *dev_id)
 		}
 
 		if (pending & DW_MCI_DATA_ERROR_FLAGS) {
-			/* if there is an error, lets report DATA_ERROR */
+			/* if there is an error, report DATA_ERROR */
 			mci_writel(host, RINTSTS, DW_MCI_DATA_ERROR_FLAGS);
 			host->data_status = status;
 			smp_wmb();
@@ -1209,7 +1192,6 @@ static irqreturn_t dw_mci_interrupt(int irq, void *dev_id)
 			tasklet_schedule(&host->tasklet);
 		}
 
-
 		if (pending & SDMMC_INT_DATA_OVER) {
 			mci_writel(host, RINTSTS, SDMMC_INT_DATA_OVER);
 			if (!host->data_status)
@@ -1251,8 +1233,7 @@ static irqreturn_t dw_mci_interrupt(int irq, void *dev_id)
 	/* Handle DMA interrupts */
 	pending = mci_readl(host, IDSTS);
 	if (pending & (SDMMC_IDMAC_INT_TI | SDMMC_IDMAC_INT_RI)) {
-		mci_writel(host, IDSTS, SDMMC_IDMAC_INT_TI |
-				SDMMC_IDMAC_INT_RI);
+		mci_writel(host, IDSTS, SDMMC_IDMAC_INT_TI | SDMMC_IDMAC_INT_RI);
 		mci_writel(host, IDSTS, SDMMC_IDMAC_INT_NI);
 		set_bit(EVENT_DATA_COMPLETE, &host->pending_events);
 		host->dma_ops->complete(host);
@@ -1279,7 +1260,7 @@ static void dw_mci_tasklet_card(unsigned long data)
 			spin_lock(&host->lock);
 
 			dev_dbg(&slot->mmc->class_dev, "card %s\n",
-					present ? "inserted" : "removed");
+				present ? "inserted" : "removed");
 
 			/* Card change detected */
 			slot->last_detect_state = present;
@@ -1288,7 +1269,7 @@ static void dw_mci_tasklet_card(unsigned long data)
 			if (present != 0) {
 				if (host->pdata->setpower)
 					host->pdata->setpower(slot->id,
-						mmc->ocr_avail);
+							      mmc->ocr_avail);
 
 				set_bit(DW_MMC_CARD_PRESENT, &slot->flags);
 			}
@@ -1358,10 +1339,9 @@ static void dw_mci_tasklet_card(unsigned long data)
 
 #ifdef CONFIG_MMC_DW_IDMAC
 				ctrl = mci_readl(host, BMOD);
-				ctrl |= 0x01;	/* Software reset of DMA */
+				ctrl |= 0x01; /* Software reset of DMA */
 				mci_writel(host, BMOD, ctrl);
 #endif
-
 			}
 
 			spin_unlock(&host->lock);
@@ -1397,8 +1377,8 @@ static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
 		mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
 
 	/*
-	 * Start with slot power disabled,
-	 * will be enabled when card is detected
+	 * Start with slot power disabled, it will be enabled when
+	 * a card is detected.
 	 */
 	if (host->pdata->setpower)
 		host->pdata->setpower(id, 0);
@@ -1425,7 +1405,7 @@ static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
 		mmc->max_req_size = host->pdata->blk_settings->max_req_size;
 		mmc->max_seg_size = host->pdata->blk_settings->max_seg_size;
 	} else {
-		/*useful defaults*/
+		/* Useful defaults, if platform data is unset. */
 		mmc->max_segs = 64;
 		mmc->max_blk_size = 65536; /* BLKSIZ is 16 bits */
 		mmc->max_blk_count = 512;
@@ -1453,8 +1433,7 @@ static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
 	return 0;
 }
 
-static void dw_mci_cleanup_slot(struct dw_mci_slot *slot,
-				unsigned int id)
+static void dw_mci_cleanup_slot(struct dw_mci_slot *slot, unsigned int id)
 {
 	/* Shutdown detect IRQ */
 	if (slot->host->pdata->exit)
@@ -1470,10 +1449,10 @@ static void dw_mci_init_dma(struct dw_mci *host)
 {
 	/* Alloc memory for sg translation */
 	host->sg_cpu = dma_alloc_coherent(&host->pdev->dev, PAGE_SIZE,
-			&host->sg_dma, GFP_KERNEL);
+					  &host->sg_dma, GFP_KERNEL);
 	if (!host->sg_cpu) {
 		dev_err(&host->pdev->dev, "%s: could not alloc DMA memory\n",
-				__func__);
+			__func__);
 		goto no_dma;
 	}
 
@@ -1488,12 +1467,12 @@ static void dw_mci_init_dma(struct dw_mci *host)
 
 	if (host->dma_ops->init) {
 		if (host->dma_ops->init(host)) {
-			dev_err(&host->pdev->dev, "%s: Unable to initialise "
-					"DMA Controller.\n", __func__);
+			dev_err(&host->pdev->dev, "%s: Unable to initialize "
+				"DMA Controller.\n", __func__);
 			goto no_dma;
 		}
 	} else {
-		dev_err(&host->pdev->dev, "DMA initialisation not found.\n");
+		dev_err(&host->pdev->dev, "DMA initialization not found.\n");
 		goto no_dma;
 	}
 
@@ -1512,13 +1491,13 @@ static bool mci_wait_reset(struct device *dev, struct dw_mci *host)
 	unsigned int ctrl;
 
 	mci_writel(host, CTRL, (SDMMC_CTRL_RESET |
-			SDMMC_CTRL_FIFO_RESET | SDMMC_CTRL_DMA_RESET));
+				SDMMC_CTRL_FIFO_RESET | SDMMC_CTRL_DMA_RESET));
 
-	/* wait till resets clear */
+	/* Wait until the reset bits clear */
 	do {
 		ctrl = mci_readl(host, CTRL);
-		if (!(ctrl & (SDMMC_CTRL_RESET |
-			      SDMMC_CTRL_FIFO_RESET | SDMMC_CTRL_DMA_RESET)))
+		if (!(ctrl & (SDMMC_CTRL_RESET | SDMMC_CTRL_FIFO_RESET | 
+			      SDMMC_CTRL_DMA_RESET)))
 			return true;
 	} while (time_before(jiffies, timeout));
 
@@ -1556,15 +1535,14 @@ static int dw_mci_probe(struct platform_device *pdev)
 	}
 
 	if (((pdata->num_slots > 1) && !(pdata->select_slot))
-			|| !(pdata->init)) {
+	    || !(pdata->init)) {
 		dev_err(&pdev->dev, "Platform data wrong\n");
 		ret = -ENODEV;
 		goto err_freehost;
 	}
 
 	if (!pdata->bus_hz) {
-		dev_err(&pdev->dev,
-			"Bus speed undefined in platform data!\n");
+		dev_err(&pdev->dev, "Bus speed undefined in platform data!\n");
 		ret = -ENODEV;
 		goto err_freehost;
 	}
@@ -1601,21 +1579,21 @@ static int dw_mci_probe(struct platform_device *pdev)
 	} else {
 		/* Check for a reserved value, and warn if it is */
 		WARN((i != 1),
-			"HCON reports a reserved host data width!\n"
-			"Defaulting to 32-bit access.\n");
+		     "HCON reports a reserved host data width!\n"
+		     "Defaulting to 32-bit access.\n");
 		host->push_data = dw_mci_push_data32;
 		host->pull_data = dw_mci_pull_data32;
 		width = 32;
 		host->data_shift = 2;
 	}
 
-	/* reset all blocks */
+	/* Reset all blocks */
 	if (!mci_wait_reset(&pdev->dev, host)) {
 		ret = -ENODEV;
 		goto err_dmaunmap;
 	}
 
-	 /* Clear the interrupts for the host controller */
+	/* Clear the interrupts for the host controller */
 	mci_writel(host, RINTSTS, 0xFFFFFFFF);
 	mci_writel(host, INTMASK, 0); /* disable all mmc interrupt first */
 
@@ -1623,13 +1601,13 @@ static int dw_mci_probe(struct platform_device *pdev)
 	mci_writel(host, TMOUT, 0xFFFFFFFF);
 
 	/*
-	 * FIFO threshold settings  RxMark = fifo_size/2-1,
-	 *                          Tx Mark =fifo_size/2 DMA Size = 8
+	 * FIFO threshold settings  RxMark  = fifo_size/2 - 1,
+	 *                          Tx Mark = fifo_size/2 DMA Size = 8
 	 */
 	fifo_size = mci_readl(host, FIFOTH);
 	fifo_size = (fifo_size >> 16) & 0x7ff;
 	mci_writel(host, FIFOTH, ((0x2 << 28) | ((fifo_size/2 - 1) << 16) |
-				((fifo_size/2) << 0)));
+				  ((fifo_size/2) << 0)));
 
 	/* disable clock to CIU */
 	mci_writel(host, CLKENA, 0);
@@ -1637,7 +1615,7 @@ static int dw_mci_probe(struct platform_device *pdev)
 
 	tasklet_init(&host->tasklet, dw_mci_tasklet_func, (unsigned long)host);
 	tasklet_init(&host->card_tasklet,
-		dw_mci_tasklet_card, (unsigned long)host);
+		     dw_mci_tasklet_card, (unsigned long)host);
 
 	ret = request_irq(irq, dw_mci_interrupt, 0, "dw-mci", host);
 	if (ret)
@@ -1660,18 +1638,17 @@ static int dw_mci_probe(struct platform_device *pdev)
 	}
 
 	/*
-	 * enable interrupt for command done, data over, data empty,
-	 * receive ready and error such as transmit, receive timeout, crc error
+	 * Enable interrupts for command done, data over, data empty, card det,
+	 * receive ready, and errors such as transmit, receive timeout, crc error
 	 */
 	mci_writel(host, RINTSTS, 0xFFFFFFFF);
 	mci_writel(host, INTMASK, SDMMC_INT_CMD_DONE | SDMMC_INT_DATA_OVER |
-				SDMMC_INT_TXDR | SDMMC_INT_RXDR |
-				DW_MCI_ERROR_FLAGS | SDMMC_INT_CD);
-	mci_writel(host, CTRL, SDMMC_CTRL_INT_ENABLE); /*enable mci interrupt*/
+				  SDMMC_INT_TXDR | SDMMC_INT_RXDR | 
+		   		  DW_MCI_ERROR_FLAGS | SDMMC_INT_CD);
+	mci_writel(host, CTRL, SDMMC_CTRL_INT_ENABLE); /* Enable mci interrupt */
 
 	dev_info(&pdev->dev, "DW MMC controller at irq %d, "
-			"%d bit host data width\n",
-			irq, width);
+		 "%d bit host data width\n", irq, width);
 	if (host->quirks & DW_MCI_QUIRK_IDMAC_DTO)
 		dev_info(&pdev->dev, "Internal DMAC interrupt fix enabled.\n");
 
@@ -1690,7 +1667,7 @@ err_dmaunmap:
 	if (host->use_dma && host->dma_ops->exit)
 		host->dma_ops->exit(host);
 	dma_free_coherent(&host->pdev->dev, PAGE_SIZE,
-			host->sg_cpu, host->sg_dma);
+			  host->sg_cpu, host->sg_dma);
 	iounmap(host->regs);
 
 err_freehost:


-- 
Chris Ball   <cjb@laptop.org>   <http://printf.net/>
One Laptop Per Child

  parent reply	other threads:[~2010-12-09  6:47 UTC|newest]

Thread overview: 29+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2010-12-06 15:53 [RESEND PATCH] " Will Newton
2010-12-08 11:55 ` Matt Fleming
2010-12-08 13:14   ` Will Newton
2010-12-08 14:21     ` [PATCH] " Will Newton
2010-12-08 16:07       ` Matt Fleming
2010-12-09  6:47       ` Chris Ball [this message]
2010-12-09 12:11         ` Will Newton
2010-12-09 16:01           ` Chris Ball
2010-12-09 17:24             ` Will Newton
     [not found]               ` <20101211192320.GA24430@void.printf.net>
2010-12-12  8:41                 ` Russell King - ARM Linux
2010-12-12 11:15                   ` Russell King - ARM Linux
2010-12-12 10:57                 ` Will Newton
2010-12-12 13:52                   ` Chris Ball
2010-12-12 14:03                     ` Will Newton
2010-12-12 14:11                       ` Russell King - ARM Linux
2010-12-12 14:31                         ` Will Newton
2010-12-12 14:47                           ` Russell King - ARM Linux
2010-12-12 15:17                             ` Will Newton
2010-12-16 17:04                 ` [PATCH v4] " Will Newton
2011-01-02  6:20                   ` Chris Ball
2011-01-18  7:54                   ` Jaehoon Chung
2011-01-18 10:21                     ` Will Newton
2011-02-08  6:38                       ` Jaehoon Chung
2011-02-08 10:29                         ` Will Newton
2011-02-08 10:49                           ` Jaehoon Chung
2011-02-08 12:06                             ` Will Newton
2010-12-09 17:35             ` [PATCH] " Chris Ball
2010-12-09 17:46               ` Will Newton
  -- strict thread matches above, loose matches on Subject: below --
2010-11-29 17:35 Will Newton

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20101209064751.GA21128@void.printf.net \
    --to=cjb@laptop.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-mmc@vger.kernel.org \
    --cc=matt@console-pimps.org \
    --cc=will.newton@gmail.com \
    --subject='Re: [PATCH] dw_mmc: Add Synopsys DesignWare mmc host driver.' \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).