Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b6147490 authored by Guennadi Liakhovetski's avatar Guennadi Liakhovetski Committed by Chris Ball
Browse files

mmc: tmio: split core functionality, DMA and MFD glue 



TMIO MMC chips contain an SD / SDIO IP core from Panasonic, similar to
the one, used in MN5774 and other MN57xx controllers. These IP cores are
included in many multifunction devices, in sh-mobile chips from Renesas,
in the latter case they can also use DMA. Some sh-mobile implementations
also have some other specialities, that MFD-based solutions don't have.
This makes supporting all these features in a monolithic driver inconveniet
and error-prone. This patch splits the driver into 3 parts: the core,
the MFD glue and the DMA support. In case of a modular build, two modules
will be built: mmc_tmio_core and mmc_tmio.

Signed-off-by: default avatarGuennadi Liakhovetski <g.liakhovetski@gmx.de>
Acked-by: default avatarPaul Mundt <lethal@linux-sh.org>
Signed-off-by: default avatarChris Ball <cjb@laptop.org>
parent 5f52c355

drivers/mmc/host/Kconfig

+4 −0
Original line number Original line Diff line number Diff line
@@ -439,9 +439,13 @@ config MMC_SDRICOH_CS 
	  To compile this driver as a module, choose M here: the

	  To compile this driver as a module, choose M here: the

	  module will be called sdricoh_cs.

	  module will be called sdricoh_cs.





config MMC_TMIO_CORE

	tristate



config MMC_TMIO

config MMC_TMIO

	tristate "Toshiba Mobile IO Controller (TMIO) MMC/SD function support"

	tristate "Toshiba Mobile IO Controller (TMIO) MMC/SD function support"

	depends on MFD_TMIO || MFD_ASIC3 || MFD_SH_MOBILE_SDHI

	depends on MFD_TMIO || MFD_ASIC3 || MFD_SH_MOBILE_SDHI

	select MMC_TMIO_CORE

	help

	help

	  This provides support for the SD/MMC cell found in TC6393XB,

	  This provides support for the SD/MMC cell found in TC6393XB,

	  T7L66XB and also HTC ASIC3

	  T7L66XB and also HTC ASIC3

drivers/mmc/host/Makefile

+3 −0
Original line number Original line Diff line number Diff line
@@ -29,6 +29,9 @@ endif 
obj-$(CONFIG_MMC_S3C)   	+= s3cmci.o

obj-$(CONFIG_MMC_S3C)   	+= s3cmci.o

obj-$(CONFIG_MMC_SDRICOH_CS)	+= sdricoh_cs.o

obj-$(CONFIG_MMC_SDRICOH_CS)	+= sdricoh_cs.o

obj-$(CONFIG_MMC_TMIO)		+= tmio_mmc.o

obj-$(CONFIG_MMC_TMIO)		+= tmio_mmc.o

obj-$(CONFIG_MMC_TMIO_CORE)	+= tmio_mmc_core.o

tmio_mmc_core-y			:= tmio_mmc_pio.o

tmio_mmc_core-$(CONFIG_TMIO_MMC_DMA)	+= tmio_mmc_dma.o

obj-$(CONFIG_MMC_CB710)	+= cb710-mmc.o

obj-$(CONFIG_MMC_CB710)	+= cb710-mmc.o

obj-$(CONFIG_MMC_VIA_SDMMC)	+= via-sdmmc.o

obj-$(CONFIG_MMC_VIA_SDMMC)	+= via-sdmmc.o

obj-$(CONFIG_SDH_BFIN)		+= bfin_sdh.o

obj-$(CONFIG_SDH_BFIN)		+= bfin_sdh.o

drivers/mmc/host/tmio_mmc.c

+18 −1285

File changed.

Preview size limit exceeded, changes collapsed.

drivers/mmc/host/tmio_mmc.h

0 → 100644
+145 −0
Original line number Original line Diff line number Diff line 
/*

 * linux/drivers/mmc/host/tmio_mmc.h

 *

 * Copyright (C) 2007 Ian Molton

 * Copyright (C) 2004 Ian Molton

 *

 * 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.

 *

 * Driver for the MMC / SD / SDIO cell found in:

 *

 * TC6393XB TC6391XB TC6387XB T7L66XB ASIC3

 */



#ifndef TMIO_MMC_H

#define TMIO_MMC_H



#include <linux/highmem.h>

#include <linux/pagemap.h>



/* Definitions for values the CTRL_STATUS register can take. */

#define TMIO_STAT_CMDRESPEND    0x00000001

#define TMIO_STAT_DATAEND       0x00000004

#define TMIO_STAT_CARD_REMOVE   0x00000008

#define TMIO_STAT_CARD_INSERT   0x00000010

#define TMIO_STAT_SIGSTATE      0x00000020

#define TMIO_STAT_WRPROTECT     0x00000080

#define TMIO_STAT_CARD_REMOVE_A 0x00000100

#define TMIO_STAT_CARD_INSERT_A 0x00000200

#define TMIO_STAT_SIGSTATE_A    0x00000400

#define TMIO_STAT_CMD_IDX_ERR   0x00010000

#define TMIO_STAT_CRCFAIL       0x00020000

#define TMIO_STAT_STOPBIT_ERR   0x00040000

#define TMIO_STAT_DATATIMEOUT   0x00080000

#define TMIO_STAT_RXOVERFLOW    0x00100000

#define TMIO_STAT_TXUNDERRUN    0x00200000

#define TMIO_STAT_CMDTIMEOUT    0x00400000

#define TMIO_STAT_RXRDY         0x01000000

#define TMIO_STAT_TXRQ          0x02000000

#define TMIO_STAT_ILL_FUNC      0x20000000

#define TMIO_STAT_CMD_BUSY      0x40000000

#define TMIO_STAT_ILL_ACCESS    0x80000000



/* Definitions for values the CTRL_SDIO_STATUS register can take. */

#define TMIO_SDIO_STAT_IOIRQ		0x0001

#define TMIO_SDIO_STAT_EXPUB52	0x4000

#define TMIO_SDIO_STAT_EXWT		0x8000

#define TMIO_SDIO_MASK_ALL		0xc007



/* Define some IRQ masks */

/* This is the mask used at reset by the chip */

#define TMIO_MASK_ALL           0x837f031d

#define TMIO_MASK_READOP  (TMIO_STAT_RXRDY | TMIO_STAT_DATAEND)

#define TMIO_MASK_WRITEOP (TMIO_STAT_TXRQ | TMIO_STAT_DATAEND)

#define TMIO_MASK_CMD     (TMIO_STAT_CMDRESPEND | TMIO_STAT_CMDTIMEOUT | \

		TMIO_STAT_CARD_REMOVE | TMIO_STAT_CARD_INSERT)

#define TMIO_MASK_IRQ     (TMIO_MASK_READOP | TMIO_MASK_WRITEOP | TMIO_MASK_CMD)



struct tmio_mmc_data;



struct tmio_mmc_host {

	void __iomem *ctl;

	unsigned long bus_shift;

	struct mmc_command      *cmd;

	struct mmc_request      *mrq;

	struct mmc_data         *data;

	struct mmc_host         *mmc;

	int                     irq;

	unsigned int		sdio_irq_enabled;



	/* Callbacks for clock / power control */

	void (*set_pwr)(struct platform_device *host, int state);

	void (*set_clk_div)(struct platform_device *host, int state);



	/* pio related stuff */

	struct scatterlist      *sg_ptr;

	struct scatterlist      *sg_orig;

	unsigned int            sg_len;

	unsigned int            sg_off;



	struct platform_device *pdev;

	struct tmio_mmc_data *pdata;



	/* DMA support */

	bool			force_pio;

	struct dma_chan		*chan_rx;

	struct dma_chan		*chan_tx;

	struct tasklet_struct	dma_complete;

	struct tasklet_struct	dma_issue;

	struct scatterlist	bounce_sg;

	u8			*bounce_buf;



	/* Track lost interrupts */

	struct delayed_work	delayed_reset_work;

	spinlock_t		lock;

	unsigned long		last_req_ts;

};



int tmio_mmc_host_probe(struct tmio_mmc_host **host,

			struct platform_device *pdev,

			struct tmio_mmc_data *pdata);

void tmio_mmc_host_remove(struct tmio_mmc_host *host);

void tmio_mmc_do_data_irq(struct tmio_mmc_host *host);



void tmio_mmc_enable_mmc_irqs(struct tmio_mmc_host *host, u32 i);

void tmio_mmc_disable_mmc_irqs(struct tmio_mmc_host *host, u32 i);



static inline char *tmio_mmc_kmap_atomic(struct scatterlist *sg,

					 unsigned long *flags)

{

	local_irq_save(*flags);

	return kmap_atomic(sg_page(sg), KM_BIO_SRC_IRQ) + sg->offset;

}



static inline void tmio_mmc_kunmap_atomic(struct scatterlist *sg,

					  unsigned long *flags, void *virt)

{

	kunmap_atomic(virt - sg->offset, KM_BIO_SRC_IRQ);

	local_irq_restore(*flags);

}



#ifdef CONFIG_TMIO_MMC_DMA

void tmio_mmc_start_dma(struct tmio_mmc_host *host, struct mmc_data *data);

void tmio_mmc_request_dma(struct tmio_mmc_host *host, struct tmio_mmc_data *pdata);

void tmio_mmc_release_dma(struct tmio_mmc_host *host);

#else

static inline void tmio_mmc_start_dma(struct tmio_mmc_host *host,

			       struct mmc_data *data)

{

}



static inline void tmio_mmc_request_dma(struct tmio_mmc_host *host,

				 struct tmio_mmc_data *pdata)

{

	host->chan_tx = NULL;

	host->chan_rx = NULL;

}



static inline void tmio_mmc_release_dma(struct tmio_mmc_host *host)

{

}

#endif



#endif

drivers/mmc/host/tmio_mmc_dma.c

0 → 100644
+316 −0
Original line number Original line Diff line number Diff line 
/*

 * linux/drivers/mmc/tmio_mmc_dma.c

 *

 * Copyright (C) 2010-2011 Guennadi Liakhovetski

 *

 * 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.

 *

 * DMA function for TMIO MMC implementations

 */



#include <linux/device.h>

#include <linux/dmaengine.h>

#include <linux/mfd/tmio.h>

#include <linux/mmc/host.h>

#include <linux/pagemap.h>

#include <linux/scatterlist.h>



#include "tmio_mmc.h"



#define TMIO_MMC_MIN_DMA_LEN 8



static void tmio_mmc_enable_dma(struct tmio_mmc_host *host, bool enable)

{

#if defined(CONFIG_SUPERH) || defined(CONFIG_ARCH_SHMOBILE)

	/* Switch DMA mode on or off - SuperH specific? */

	writew(enable ? 2 : 0, host->ctl + (0xd8 << host->bus_shift));

#endif

}



static void tmio_mmc_start_dma_rx(struct tmio_mmc_host *host)

{

	struct scatterlist *sg = host->sg_ptr, *sg_tmp;

	struct dma_async_tx_descriptor *desc = NULL;

	struct dma_chan *chan = host->chan_rx;

	struct tmio_mmc_data *pdata = host->pdata;

	dma_cookie_t cookie;

	int ret, i;

	bool aligned = true, multiple = true;

	unsigned int align = (1 << pdata->dma->alignment_shift) - 1;



	for_each_sg(sg, sg_tmp, host->sg_len, i) {

		if (sg_tmp->offset & align)

			aligned = false;

		if (sg_tmp->length & align) {

			multiple = false;

			break;

		}

	}



	if ((!aligned && (host->sg_len > 1 || sg->length > PAGE_CACHE_SIZE ||

			  (align & PAGE_MASK))) || !multiple) {

		ret = -EINVAL;

		goto pio;

	}



	if (sg->length < TMIO_MMC_MIN_DMA_LEN) {

		host->force_pio = true;

		return;

	}



	tmio_mmc_disable_mmc_irqs(host, TMIO_STAT_RXRDY);



	/* The only sg element can be unaligned, use our bounce buffer then */

	if (!aligned) {

		sg_init_one(&host->bounce_sg, host->bounce_buf, sg->length);

		host->sg_ptr = &host->bounce_sg;

		sg = host->sg_ptr;

	}



	ret = dma_map_sg(chan->device->dev, sg, host->sg_len, DMA_FROM_DEVICE);

	if (ret > 0)

		desc = chan->device->device_prep_slave_sg(chan, sg, ret,

			DMA_FROM_DEVICE, DMA_CTRL_ACK);



	if (desc) {

		cookie = dmaengine_submit(desc);

		if (cookie < 0) {

			desc = NULL;

			ret = cookie;

		}

	}

	dev_dbg(&host->pdev->dev, "%s(): mapped %d -> %d, cookie %d, rq %p\n",

		__func__, host->sg_len, ret, cookie, host->mrq);



pio:

	if (!desc) {

		/* DMA failed, fall back to PIO */

		if (ret >= 0)

			ret = -EIO;

		host->chan_rx = NULL;

		dma_release_channel(chan);

		/* Free the Tx channel too */

		chan = host->chan_tx;

		if (chan) {

			host->chan_tx = NULL;

			dma_release_channel(chan);

		}

		dev_warn(&host->pdev->dev,

			 "DMA failed: %d, falling back to PIO\n", ret);

		tmio_mmc_enable_dma(host, false);

	}



	dev_dbg(&host->pdev->dev, "%s(): desc %p, cookie %d, sg[%d]\n", __func__,

		desc, cookie, host->sg_len);

}



static void tmio_mmc_start_dma_tx(struct tmio_mmc_host *host)

{

	struct scatterlist *sg = host->sg_ptr, *sg_tmp;

	struct dma_async_tx_descriptor *desc = NULL;

	struct dma_chan *chan = host->chan_tx;

	struct tmio_mmc_data *pdata = host->pdata;

	dma_cookie_t cookie;

	int ret, i;

	bool aligned = true, multiple = true;

	unsigned int align = (1 << pdata->dma->alignment_shift) - 1;



	for_each_sg(sg, sg_tmp, host->sg_len, i) {

		if (sg_tmp->offset & align)

			aligned = false;

		if (sg_tmp->length & align) {

			multiple = false;

			break;

		}

	}



	if ((!aligned && (host->sg_len > 1 || sg->length > PAGE_CACHE_SIZE ||

			  (align & PAGE_MASK))) || !multiple) {

		ret = -EINVAL;

		goto pio;

	}



	if (sg->length < TMIO_MMC_MIN_DMA_LEN) {

		host->force_pio = true;

		return;

	}



	tmio_mmc_disable_mmc_irqs(host, TMIO_STAT_TXRQ);



	/* The only sg element can be unaligned, use our bounce buffer then */

	if (!aligned) {

		unsigned long flags;

		void *sg_vaddr = tmio_mmc_kmap_atomic(sg, &flags);

		sg_init_one(&host->bounce_sg, host->bounce_buf, sg->length);

		memcpy(host->bounce_buf, sg_vaddr, host->bounce_sg.length);

		tmio_mmc_kunmap_atomic(sg, &flags, sg_vaddr);

		host->sg_ptr = &host->bounce_sg;

		sg = host->sg_ptr;

	}



	ret = dma_map_sg(chan->device->dev, sg, host->sg_len, DMA_TO_DEVICE);

	if (ret > 0)

		desc = chan->device->device_prep_slave_sg(chan, sg, ret,

			DMA_TO_DEVICE, DMA_CTRL_ACK);



	if (desc) {

		cookie = dmaengine_submit(desc);

		if (cookie < 0) {

			desc = NULL;

			ret = cookie;

		}

	}

	dev_dbg(&host->pdev->dev, "%s(): mapped %d -> %d, cookie %d, rq %p\n",

		__func__, host->sg_len, ret, cookie, host->mrq);



pio:

	if (!desc) {

		/* DMA failed, fall back to PIO */

		if (ret >= 0)

			ret = -EIO;

		host->chan_tx = NULL;

		dma_release_channel(chan);

		/* Free the Rx channel too */

		chan = host->chan_rx;

		if (chan) {

			host->chan_rx = NULL;

			dma_release_channel(chan);

		}

		dev_warn(&host->pdev->dev,

			 "DMA failed: %d, falling back to PIO\n", ret);

		tmio_mmc_enable_dma(host, false);

	}



	dev_dbg(&host->pdev->dev, "%s(): desc %p, cookie %d\n", __func__,

		desc, cookie);

}



void tmio_mmc_start_dma(struct tmio_mmc_host *host,

			       struct mmc_data *data)

{

	if (data->flags & MMC_DATA_READ) {

		if (host->chan_rx)

			tmio_mmc_start_dma_rx(host);

	} else {

		if (host->chan_tx)

			tmio_mmc_start_dma_tx(host);

	}

}



static void tmio_mmc_issue_tasklet_fn(unsigned long priv)

{

	struct tmio_mmc_host *host = (struct tmio_mmc_host *)priv;

	struct dma_chan *chan = NULL;



	spin_lock_irq(&host->lock);



	if (host && host->data) {

		if (host->data->flags & MMC_DATA_READ)

			chan = host->chan_rx;

		else

			chan = host->chan_tx;

	}



	spin_unlock_irq(&host->lock);



	tmio_mmc_enable_mmc_irqs(host, TMIO_STAT_DATAEND);



	if (chan)

		dma_async_issue_pending(chan);

}



static void tmio_mmc_tasklet_fn(unsigned long arg)

{

	struct tmio_mmc_host *host = (struct tmio_mmc_host *)arg;



	spin_lock_irq(&host->lock);



	if (!host->data)

		goto out;



	if (host->data->flags & MMC_DATA_READ)

		dma_unmap_sg(host->chan_rx->device->dev,

			     host->sg_ptr, host->sg_len,

			     DMA_FROM_DEVICE);

	else

		dma_unmap_sg(host->chan_tx->device->dev,

			     host->sg_ptr, host->sg_len,

			     DMA_TO_DEVICE);



	tmio_mmc_do_data_irq(host);

out:

	spin_unlock_irq(&host->lock);

}



/* It might be necessary to make filter MFD specific */

static bool tmio_mmc_filter(struct dma_chan *chan, void *arg)

{

	dev_dbg(chan->device->dev, "%s: slave data %p\n", __func__, arg);

	chan->private = arg;

	return true;

}



void tmio_mmc_request_dma(struct tmio_mmc_host *host, struct tmio_mmc_data *pdata)

{

	/* We can only either use DMA for both Tx and Rx or not use it at all */

	if (pdata->dma) {

		dma_cap_mask_t mask;



		dma_cap_zero(mask);

		dma_cap_set(DMA_SLAVE, mask);



		host->chan_tx = dma_request_channel(mask, tmio_mmc_filter,

						    pdata->dma->chan_priv_tx);

		dev_dbg(&host->pdev->dev, "%s: TX: got channel %p\n", __func__,

			host->chan_tx);



		if (!host->chan_tx)

			return;



		host->chan_rx = dma_request_channel(mask, tmio_mmc_filter,

						    pdata->dma->chan_priv_rx);

		dev_dbg(&host->pdev->dev, "%s: RX: got channel %p\n", __func__,

			host->chan_rx);



		if (!host->chan_rx)

			goto ereqrx;



		host->bounce_buf = (u8 *)__get_free_page(GFP_KERNEL | GFP_DMA);

		if (!host->bounce_buf)

			goto ebouncebuf;



		tasklet_init(&host->dma_complete, tmio_mmc_tasklet_fn, (unsigned long)host);

		tasklet_init(&host->dma_issue, tmio_mmc_issue_tasklet_fn, (unsigned long)host);



		tmio_mmc_enable_dma(host, true);



		return;

ebouncebuf:

		dma_release_channel(host->chan_rx);

		host->chan_rx = NULL;

ereqrx:

		dma_release_channel(host->chan_tx);

		host->chan_tx = NULL;

		return;

	}

}



void tmio_mmc_release_dma(struct tmio_mmc_host *host)

{

	if (host->chan_tx) {

		struct dma_chan *chan = host->chan_tx;

		host->chan_tx = NULL;

		dma_release_channel(chan);

	}

	if (host->chan_rx) {

		struct dma_chan *chan = host->chan_rx;

		host->chan_rx = NULL;

		dma_release_channel(chan);

	}

	if (host->bounce_buf) {

		free_pages((unsigned long)host->bounce_buf, 0);

		host->bounce_buf = NULL;

	}

}