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

Commit a813f2a2 authored by Ludovic Barre's avatar Ludovic Barre Committed by Ulf Hansson
Browse files

mmc: mmci: introduce dma_priv pointer to mmci_host 



-Introduces dma_priv pointer to define specific
needs for each dma engine. This patch is needed to prepare
sdmmc variant with internal dma which not use dmaengine API.
-Moves next cookie to mmci host structure to share same cookie
management between all variants.

Signed-off-by: default avatarLudovic Barre <ludovic.barre@st.com>
Signed-off-by: default avatarUlf Hansson <ulf.hansson@linaro.org>
parent c3647fdc

drivers/mmc/host/mmci.c

+90 −54
Original line number Diff line number Diff line
@@ -386,6 +386,9 @@ void mmci_dma_setup(struct mmci_host *host) 
	if (host->ops->dma_setup(host))

		return;



	/* initialize pre request cookie */

	host->next_cookie = 1;



	host->use_dma = true;

}
@@ -447,31 +450,50 @@ static void mmci_init_sg(struct mmci_host *host, struct mmc_data *data) 
 * no custom DMA interfaces are supported.

 */

#ifdef CONFIG_DMA_ENGINE

struct mmci_dmae_next {

	struct dma_async_tx_descriptor *desc;

	struct dma_chan	*chan;

};



struct mmci_dmae_priv {

	struct dma_chan	*cur;

	struct dma_chan	*rx_channel;

	struct dma_chan	*tx_channel;

	struct dma_async_tx_descriptor	*desc_current;

	struct mmci_dmae_next next_data;

};



int mmci_dmae_setup(struct mmci_host *host)

{

	const char *rxname, *txname;

	struct mmci_dmae_priv *dmae;



	host->dma_rx_channel = dma_request_slave_channel(mmc_dev(host->mmc), "rx");

	host->dma_tx_channel = dma_request_slave_channel(mmc_dev(host->mmc), "tx");

	dmae = devm_kzalloc(mmc_dev(host->mmc), sizeof(*dmae), GFP_KERNEL);

	if (!dmae)

		return -ENOMEM;



	/* initialize pre request cookie */

	host->next_data.cookie = 1;

	host->dma_priv = dmae;



	dmae->rx_channel = dma_request_slave_channel(mmc_dev(host->mmc),

						     "rx");

	dmae->tx_channel = dma_request_slave_channel(mmc_dev(host->mmc),

						     "tx");



	/*

	 * If only an RX channel is specified, the driver will

	 * attempt to use it bidirectionally, however if it is

	 * is specified but cannot be located, DMA will be disabled.

	 */

	if (host->dma_rx_channel && !host->dma_tx_channel)

		host->dma_tx_channel = host->dma_rx_channel;

	if (dmae->rx_channel && !dmae->tx_channel)

		dmae->tx_channel = dmae->rx_channel;



	if (host->dma_rx_channel)

		rxname = dma_chan_name(host->dma_rx_channel);

	if (dmae->rx_channel)

		rxname = dma_chan_name(dmae->rx_channel);

	else

		rxname = "none";



	if (host->dma_tx_channel)

		txname = dma_chan_name(host->dma_tx_channel);

	if (dmae->tx_channel)

		txname = dma_chan_name(dmae->tx_channel);

	else

		txname = "none";
@@ -482,22 +504,22 @@ int mmci_dmae_setup(struct mmci_host *host) 
	 * Limit the maximum segment size in any SG entry according to

	 * the parameters of the DMA engine device.

	 */

	if (host->dma_tx_channel) {

		struct device *dev = host->dma_tx_channel->device->dev;

	if (dmae->tx_channel) {

		struct device *dev = dmae->tx_channel->device->dev;

		unsigned int max_seg_size = dma_get_max_seg_size(dev);



		if (max_seg_size < host->mmc->max_seg_size)

			host->mmc->max_seg_size = max_seg_size;

	}

	if (host->dma_rx_channel) {

		struct device *dev = host->dma_rx_channel->device->dev;

	if (dmae->rx_channel) {

		struct device *dev = dmae->rx_channel->device->dev;

		unsigned int max_seg_size = dma_get_max_seg_size(dev);



		if (max_seg_size < host->mmc->max_seg_size)

			host->mmc->max_seg_size = max_seg_size;

	}



	if (!host->dma_tx_channel && !host->dma_rx_channel) {

	if (!dmae->tx_channel || !dmae->rx_channel) {

		mmci_dmae_release(host);

		return -EINVAL;

	}
@@ -511,21 +533,24 @@ int mmci_dmae_setup(struct mmci_host *host) 
 */

void mmci_dmae_release(struct mmci_host *host)

{

	if (host->dma_rx_channel)

		dma_release_channel(host->dma_rx_channel);

	if (host->dma_tx_channel)

		dma_release_channel(host->dma_tx_channel);

	host->dma_rx_channel = host->dma_tx_channel = NULL;

	struct mmci_dmae_priv *dmae = host->dma_priv;



	if (dmae->rx_channel)

		dma_release_channel(dmae->rx_channel);

	if (dmae->tx_channel)

		dma_release_channel(dmae->tx_channel);

	dmae->rx_channel = dmae->tx_channel = NULL;

}



static void mmci_dma_unmap(struct mmci_host *host, struct mmc_data *data)

{

	struct mmci_dmae_priv *dmae = host->dma_priv;

	struct dma_chan *chan;



	if (data->flags & MMC_DATA_READ)

		chan = host->dma_rx_channel;

		chan = dmae->rx_channel;

	else

		chan = host->dma_tx_channel;

		chan = dmae->tx_channel;



	dma_unmap_sg(chan->device->dev, data->sg, data->sg_len,

		     mmc_get_dma_dir(data));
@@ -533,14 +558,16 @@ static void mmci_dma_unmap(struct mmci_host *host, struct mmc_data *data) 


static void mmci_dma_data_error(struct mmci_host *host)

{

	struct mmci_dmae_priv *dmae = host->dma_priv;



	if (!host->use_dma || !dma_inprogress(host))

		return;



	dev_err(mmc_dev(host->mmc), "error during DMA transfer!\n");

	dmaengine_terminate_all(host->dma_current);

	dmaengine_terminate_all(dmae->cur);

	host->dma_in_progress = false;

	host->dma_current = NULL;

	host->dma_desc_current = NULL;

	dmae->cur = NULL;

	dmae->desc_current = NULL;

	host->data->host_cookie = 0;



	mmci_dma_unmap(host, host->data);
@@ -548,6 +575,7 @@ static void mmci_dma_data_error(struct mmci_host *host) 


static void mmci_dma_finalize(struct mmci_host *host, struct mmc_data *data)

{

	struct mmci_dmae_priv *dmae = host->dma_priv;

	u32 status;

	int i;
@@ -586,8 +614,8 @@ static void mmci_dma_finalize(struct mmci_host *host, struct mmc_data *data) 
	}



	host->dma_in_progress = false;

	host->dma_current = NULL;

	host->dma_desc_current = NULL;

	dmae->cur = NULL;

	dmae->desc_current = NULL;

}



/* prepares DMA channel and DMA descriptor, returns non-zero on failure */
@@ -595,6 +623,7 @@ static int __mmci_dma_prep_data(struct mmci_host *host, struct mmc_data *data, 
				struct dma_chan **dma_chan,

				struct dma_async_tx_descriptor **dma_desc)

{

	struct mmci_dmae_priv *dmae = host->dma_priv;

	struct variant_data *variant = host->variant;

	struct dma_slave_config conf = {

		.src_addr = host->phybase + MMCIFIFO,
@@ -613,10 +642,10 @@ static int __mmci_dma_prep_data(struct mmci_host *host, struct mmc_data *data, 


	if (data->flags & MMC_DATA_READ) {

		conf.direction = DMA_DEV_TO_MEM;

		chan = host->dma_rx_channel;

		chan = dmae->rx_channel;

	} else {

		conf.direction = DMA_MEM_TO_DEV;

		chan = host->dma_tx_channel;

		chan = dmae->tx_channel;

	}



	/* If there's no DMA channel, fall back to PIO */
@@ -656,25 +685,30 @@ static int __mmci_dma_prep_data(struct mmci_host *host, struct mmc_data *data, 
static inline int mmci_dma_prep_data(struct mmci_host *host,

				     struct mmc_data *data)

{

	struct mmci_dmae_priv *dmae = host->dma_priv;



	/* Check if next job is already prepared. */

	if (host->dma_current && host->dma_desc_current)

	if (dmae->cur && dmae->desc_current)

		return 0;



	/* No job were prepared thus do it now. */

	return __mmci_dma_prep_data(host, data, &host->dma_current,

				    &host->dma_desc_current);

	return __mmci_dma_prep_data(host, data, &dmae->cur,

				    &dmae->desc_current);

}



static inline int mmci_dma_prep_next(struct mmci_host *host,

				     struct mmc_data *data)

{

	struct mmci_host_next *nd = &host->next_data;

	return __mmci_dma_prep_data(host, data, &nd->dma_chan, &nd->dma_desc);

	struct mmci_dmae_priv *dmae = host->dma_priv;

	struct mmci_dmae_next *nd = &dmae->next_data;



	return __mmci_dma_prep_data(host, data, &nd->chan, &nd->desc);

}



static int mmci_dma_start_data(struct mmci_host *host, unsigned int datactrl)

{

	int ret;

	struct mmci_dmae_priv *dmae = host->dma_priv;

	struct mmc_data *data = host->data;



	if (!host->use_dma)
@@ -689,8 +723,8 @@ static int mmci_dma_start_data(struct mmci_host *host, unsigned int datactrl) 
		 "Submit MMCI DMA job, sglen %d blksz %04x blks %04x flags %08x\n",

		 data->sg_len, data->blksz, data->blocks, data->flags);

	host->dma_in_progress = true;

	dmaengine_submit(host->dma_desc_current);

	dma_async_issue_pending(host->dma_current);

	dmaengine_submit(dmae->desc_current);

	dma_async_issue_pending(dmae->cur);



	if (host->variant->qcom_dml)

		dml_start_xfer(host, data);
@@ -712,25 +746,25 @@ static int mmci_dma_start_data(struct mmci_host *host, unsigned int datactrl) 


static void mmci_get_next_data(struct mmci_host *host, struct mmc_data *data)

{

	struct mmci_host_next *next = &host->next_data;

	struct mmci_dmae_priv *dmae = host->dma_priv;

	struct mmci_dmae_next *next = &dmae->next_data;



	if (!host->use_dma)

		return;



	WARN_ON(data->host_cookie && data->host_cookie != next->cookie);

	WARN_ON(!data->host_cookie && (next->dma_desc || next->dma_chan));

	WARN_ON(data->host_cookie && data->host_cookie != host->next_cookie);

	WARN_ON(!data->host_cookie && (next->desc || next->chan));



	host->dma_desc_current = next->dma_desc;

	host->dma_current = next->dma_chan;

	next->dma_desc = NULL;

	next->dma_chan = NULL;

	dmae->desc_current = next->desc;

	dmae->cur = next->chan;

	next->desc = NULL;

	next->chan = NULL;

}



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

{

	struct mmci_host *host = mmc_priv(mmc);

	struct mmc_data *data = mrq->data;

	struct mmci_host_next *nd = &host->next_data;



	if (!host->use_dma || !data)

		return;
@@ -741,13 +775,15 @@ static void mmci_pre_request(struct mmc_host *mmc, struct mmc_request *mrq) 
		return;



	if (!mmci_dma_prep_next(host, data))

		data->host_cookie = ++nd->cookie < 0 ? 1 : nd->cookie;

		data->host_cookie = ++host->next_cookie < 0 ?

			1 : host->next_cookie;

}



static void mmci_post_request(struct mmc_host *mmc, struct mmc_request *mrq,

			      int err)

{

	struct mmci_host *host = mmc_priv(mmc);

	struct mmci_dmae_priv *dmae = host->dma_priv;

	struct mmc_data *data = mrq->data;



	if (!host->use_dma || !data || !data->host_cookie)
@@ -756,24 +792,24 @@ static void mmci_post_request(struct mmc_host *mmc, struct mmc_request *mrq, 
	mmci_dma_unmap(host, data);



	if (err) {

		struct mmci_host_next *next = &host->next_data;

		struct mmci_dmae_next *next = &dmae->next_data;

		struct dma_chan *chan;

		if (data->flags & MMC_DATA_READ)

			chan = host->dma_rx_channel;

			chan = dmae->rx_channel;

		else

			chan = host->dma_tx_channel;

			chan = dmae->tx_channel;

		dmaengine_terminate_all(chan);



		if (host->dma_desc_current == next->dma_desc)

			host->dma_desc_current = NULL;

		if (dmae->desc_current == next->desc)

			dmae->desc_current = NULL;



		if (host->dma_current == next->dma_chan) {

		if (dmae->cur == next->chan) {

			host->dma_in_progress = false;

			host->dma_current = NULL;

			dmae->cur = NULL;

		}



		next->dma_desc = NULL;

		next->dma_chan = NULL;

		next->desc = NULL;

		next->chan = NULL;

		data->host_cookie = 0;

	}

}

drivers/mmc/host/mmci.h

+4 −15
Original line number Diff line number Diff line
@@ -277,12 +277,6 @@ struct mmci_host_ops { 
	void (*dma_release)(struct mmci_host *host);

};



struct mmci_host_next {

	struct dma_async_tx_descriptor	*dma_desc;

	struct dma_chan			*dma_chan;

	s32				cookie;

};



struct mmci_host {

	phys_addr_t		phybase;

	void __iomem		*base;
@@ -325,19 +319,14 @@ struct mmci_host { 
	int (*get_rx_fifocnt)(struct mmci_host *h, u32 status, int remain);



	u8			use_dma:1;

#ifdef CONFIG_DMA_ENGINE

	/* DMA stuff */

	struct dma_chan		*dma_current;

	struct dma_chan		*dma_rx_channel;

	struct dma_chan		*dma_tx_channel;

	struct dma_async_tx_descriptor	*dma_desc_current;

	struct mmci_host_next	next_data;

	u8			dma_in_progress:1;

	void			*dma_priv;



#define dma_inprogress(host)	((host)->dma_in_progress)

#endif

	s32			next_cookie;

};



#define dma_inprogress(host)	((host)->dma_in_progress)



int mmci_dmae_setup(struct mmci_host *host);

void mmci_dmae_release(struct mmci_host *host);