[MMC] Use a consistent naming to refer to mmc_request,

      mmc_blk_request and request structures to avoid confusion.

drivers/mmc/mmc.c

@@ -62,26 +62,25 @@ static const unsigned int tacc_mant[] = {
 /**
  *	mmc_request_done - finish processing an MMC command
  *	@host: MMC host which completed command
- *	@cmd: MMC command which completed
- *	@err: MMC error code
+ *	@mrq: MMC request which completed
  *
  *	MMC drivers should call this function when they have completed
  *	their processing of a command.  This should be called before the
  *	data part of the command has completed.
  */
-void mmc_request_done(struct mmc_host *host, struct mmc_request *req)
+void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
 {
-	struct mmc_command *cmd = req->cmd;
-	int err = req->cmd->error;
+	struct mmc_command *cmd = mrq->cmd;
+	int err = mrq->cmd->error;
 	DBG("MMC: req done (%02x): %d: %08x %08x %08x %08x\n", cmd->opcode,
 	    err, cmd->resp[0], cmd->resp[1], cmd->resp[2], cmd->resp[3]);
 
 	if (err && cmd->retries) {
 		cmd->retries--;
 		cmd->error = 0;
-		host->ops->request(host, req);
-	} else if (req->done) {
-		req->done(req);
+		host->ops->request(host, mrq);
+	} else if (mrq->done) {
+		mrq->done(mrq);
 	}
 }
 
@@ -90,49 +89,49 @@ EXPORT_SYMBOL(mmc_request_done);
 /**
  *	mmc_start_request - start a command on a host
  *	@host: MMC host to start command on
- *	@cmd: MMC command to start
+ *	@mrq: MMC request to start
  *
  *	Queue a command on the specified host.  We expect the
  *	caller to be holding the host lock with interrupts disabled.
  */
 void
-mmc_start_request(struct mmc_host *host, struct mmc_request *req)
+mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
 {
 	DBG("MMC: starting cmd %02x arg %08x flags %08x\n",
-	    req->cmd->opcode, req->cmd->arg, req->cmd->flags);
+	    mrq->cmd->opcode, mrq->cmd->arg, mrq->cmd->flags);
 
 	WARN_ON(host->card_busy == NULL);
 
-	req->cmd->error = 0;
-	req->cmd->req = req;
-	if (req->data) {
-		req->cmd->data = req->data;
-		req->data->error = 0;
-		req->data->req = req;
-		if (req->stop) {
-			req->data->stop = req->stop;
-			req->stop->error = 0;
-			req->stop->req = req;
+	mrq->cmd->error = 0;
+	mrq->cmd->mrq = mrq;
+	if (mrq->data) {
+		mrq->cmd->data = mrq->data;
+		mrq->data->error = 0;
+		mrq->data->mrq = mrq;
+		if (mrq->stop) {
+			mrq->data->stop = mrq->stop;
+			mrq->stop->error = 0;
+			mrq->stop->mrq = mrq;
 		}
 	}
-	host->ops->request(host, req);
+	host->ops->request(host, mrq);
 }
 
 EXPORT_SYMBOL(mmc_start_request);
 
-static void mmc_wait_done(struct mmc_request *req)
+static void mmc_wait_done(struct mmc_request *mrq)
 {
-	complete(req->done_data);
+	complete(mrq->done_data);
 }
 
-int mmc_wait_for_req(struct mmc_host *host, struct mmc_request *req)
+int mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)
 {
 	DECLARE_COMPLETION(complete);
 
-	req->done_data = &complete;
-	req->done = mmc_wait_done;
+	mrq->done_data = &complete;
+	mrq->done = mmc_wait_done;
 
-	mmc_start_request(host, req);
+	mmc_start_request(host, mrq);
 
 	wait_for_completion(&complete);
 
@@ -153,19 +152,19 @@ EXPORT_SYMBOL(mmc_wait_for_req);
  */
 int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)
 {
-	struct mmc_request req;
+	struct mmc_request mrq;
 
 	BUG_ON(host->card_busy == NULL);
 
-	memset(&req, 0, sizeof(struct mmc_request));
+	memset(&mrq, 0, sizeof(struct mmc_request));
 
 	memset(cmd->resp, 0, sizeof(cmd->resp));
 	cmd->retries = retries;
 
-	req.cmd = cmd;
+	mrq.cmd = cmd;
 	cmd->data = NULL;
 
-	mmc_wait_for_req(host, &req);
+	mmc_wait_for_req(host, &mrq);
 
 	return cmd->error;
 }

drivers/mmc/mmc_block.c

@@ -139,7 +139,7 @@ static struct block_device_operations mmc_bdops = {
 };
 
 struct mmc_blk_request {
-	struct mmc_request	req;
+	struct mmc_request	mrq;
 	struct mmc_command	cmd;
 	struct mmc_command	stop;
 	struct mmc_data		data;
@@ -173,58 +173,58 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
 		goto cmd_err;
 
 	do {
-		struct mmc_blk_request rq;
+		struct mmc_blk_request brq;
 		struct mmc_command cmd;
 
-		memset(&rq, 0, sizeof(struct mmc_blk_request));
-		rq.req.cmd = &rq.cmd;
-		rq.req.data = &rq.data;
-
-		rq.cmd.arg = req->sector << 9;
-		rq.cmd.flags = MMC_RSP_SHORT | MMC_RSP_CRC;
-		rq.data.rq = req;
-		rq.data.timeout_ns = card->csd.tacc_ns * 10;
-		rq.data.timeout_clks = card->csd.tacc_clks * 10;
-		rq.data.blksz_bits = md->block_bits;
-		rq.data.blocks = req->current_nr_sectors >> (md->block_bits - 9);
-		rq.stop.opcode = MMC_STOP_TRANSMISSION;
-		rq.stop.arg = 0;
-		rq.stop.flags = MMC_RSP_SHORT | MMC_RSP_CRC | MMC_RSP_BUSY;
+		memset(&brq, 0, sizeof(struct mmc_blk_request));
+		brq.mrq.cmd = &brq.cmd;
+		brq.mrq.data = &brq.data;
+
+		brq.cmd.arg = req->sector << 9;
+		brq.cmd.flags = MMC_RSP_SHORT | MMC_RSP_CRC;
+		brq.data.req = req;
+		brq.data.timeout_ns = card->csd.tacc_ns * 10;
+		brq.data.timeout_clks = card->csd.tacc_clks * 10;
+		brq.data.blksz_bits = md->block_bits;
+		brq.data.blocks = req->current_nr_sectors >> (md->block_bits - 9);
+		brq.stop.opcode = MMC_STOP_TRANSMISSION;
+		brq.stop.arg = 0;
+		brq.stop.flags = MMC_RSP_SHORT | MMC_RSP_CRC | MMC_RSP_BUSY;
 
 		if (rq_data_dir(req) == READ) {
-			rq.cmd.opcode = rq.data.blocks > 1 ? MMC_READ_MULTIPLE_BLOCK : MMC_READ_SINGLE_BLOCK;
-			rq.data.flags |= MMC_DATA_READ;
+			brq.cmd.opcode = brq.data.blocks > 1 ? MMC_READ_MULTIPLE_BLOCK : MMC_READ_SINGLE_BLOCK;
+			brq.data.flags |= MMC_DATA_READ;
 		} else {
-			rq.cmd.opcode = MMC_WRITE_BLOCK;
-			rq.cmd.flags |= MMC_RSP_BUSY;
-			rq.data.flags |= MMC_DATA_WRITE;
-			rq.data.blocks = 1;
+			brq.cmd.opcode = MMC_WRITE_BLOCK;
+			brq.cmd.flags |= MMC_RSP_BUSY;
+			brq.data.flags |= MMC_DATA_WRITE;
+			brq.data.blocks = 1;
 		}
-		rq.req.stop = rq.data.blocks > 1 ? &rq.stop : NULL;
+		brq.mrq.stop = brq.data.blocks > 1 ? &brq.stop : NULL;
 
-		mmc_wait_for_req(card->host, &rq.req);
-		if (rq.cmd.error) {
-			err = rq.cmd.error;
+		mmc_wait_for_req(card->host, &brq.mrq);
+		if (brq.cmd.error) {
+			err = brq.cmd.error;
 			printk(KERN_ERR "%s: error %d sending read/write command\n",
 			       req->rq_disk->disk_name, err);
 			goto cmd_err;
 		}
 
 		if (rq_data_dir(req) == READ) {
-			sz = rq.data.bytes_xfered;
+			sz = brq.data.bytes_xfered;
 		} else {
 			sz = 0;
 		}
 
-		if (rq.data.error) {
-			err = rq.data.error;
+		if (brq.data.error) {
+			err = brq.data.error;
 			printk(KERN_ERR "%s: error %d transferring data\n",
 			       req->rq_disk->disk_name, err);
 			goto cmd_err;
 		}
 
-		if (rq.stop.error) {
-			err = rq.stop.error;
+		if (brq.stop.error) {
+			err = brq.stop.error;
 			printk(KERN_ERR "%s: error %d sending stop command\n",
 			       req->rq_disk->disk_name, err);
 			goto cmd_err;
@@ -251,7 +251,7 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
 			goto cmd_err;
 #endif
 
-		sz = rq.data.bytes_xfered;
+		sz = brq.data.bytes_xfered;
 	} while (end_that_request_chunk(req, 1, sz));
 
 	mmc_card_release_host(card);

drivers/mmc/mmci.c

@@ -39,23 +39,23 @@
 static unsigned int fmax = 515633;
 
 static void
-mmci_request_end(struct mmci_host *host, struct mmc_request *req)
+mmci_request_end(struct mmci_host *host, struct mmc_request *mrq)
 {
 	writel(0, host->base + MMCICOMMAND);
-	host->req = NULL;
+	host->mrq = NULL;
 	host->cmd = NULL;
 	host->data = NULL;
 	host->buffer = NULL;
 
-	if (req->data)
-		req->data->bytes_xfered = host->data_xfered;
+	if (mrq->data)
+		mrq->data->bytes_xfered = host->data_xfered;
 
 	/*
 	 * Need to drop the host lock here; mmc_request_done may call
 	 * back into the driver...
 	 */
 	spin_unlock(&host->lock);
-	mmc_request_done(host->mmc, req);
+	mmc_request_done(host->mmc, mrq);
 	spin_lock(&host->lock);
 }
 
@@ -73,7 +73,7 @@ static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
 		datactrl |= MCI_DPSM_DIRECTION;
 
 	host->data = data;
-	host->buffer = data->rq->buffer;
+	host->buffer = data->req->buffer;
 	host->size = data->blocks << data->blksz_bits;
 	host->data_xfered = 0;
 
@@ -136,7 +136,7 @@ mmci_data_irq(struct mmci_host *host, struct mmc_data *data,
 	if (status & MCI_DATAEND) {
 		host->data = NULL;
 		if (!data->stop) {
-			mmci_request_end(host, data->req);
+			mmci_request_end(host, data->mrq);
 		} else /*if (readl(host->base + MMCIDATACNT) > 6)*/ {
 			mmci_start_command(host, data->stop, 0);
 		}
@@ -161,7 +161,7 @@ mmci_cmd_irq(struct mmci_host *host, struct mmc_command *cmd,
 	}
 
 	if (!cmd->data || cmd->error != MMC_ERR_NONE) {
-		mmci_request_end(host, cmd->req);
+		mmci_request_end(host, cmd->mrq);
 	} else if (!(cmd->data->flags & MMC_DATA_READ)) {
 		mmci_start_data(host, cmd->data);
 	}
@@ -262,20 +262,20 @@ static irqreturn_t mmci_irq(int irq, void *dev_id, struct pt_regs *regs)
 	return IRQ_RETVAL(ret);
 }
 
-static void mmci_request(struct mmc_host *mmc, struct mmc_request *req)
+static void mmci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 {
 	struct mmci_host *host = mmc_priv(mmc);
 
-	WARN_ON(host->req != NULL);
+	WARN_ON(host->mrq != NULL);
 
 	spin_lock_irq(&host->lock);
 
-	host->req = req;
+	host->mrq = mrq;
 
-	if (req->data && req->data->flags & MMC_DATA_READ)
-		mmci_start_data(host, req->data);
+	if (mrq->data && mrq->data->flags & MMC_DATA_READ)
+		mmci_start_data(host, mrq->data);
 
-	mmci_start_command(host, req->cmd, 0);
+	mmci_start_command(host, mrq->cmd, 0);
 
 	spin_unlock_irq(&host->lock);
 }

drivers/mmc/mmci.h

@@ -122,7 +122,7 @@ struct clk;
 
 struct mmci_host {
 	void			*base;
-	struct mmc_request	*req;
+	struct mmc_request	*mrq;
 	struct mmc_command	*cmd;
 	struct mmc_data		*data;
 	struct mmc_host		*mmc;

drivers/mmc/pxamci.c

@@ -21,6 +21,7 @@
 #include <linux/init.h>
 #include <linux/ioport.h>
 #include <linux/device.h>
+#include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/blkdev.h>
 #include <linux/dma-mapping.h>
@@ -52,7 +53,7 @@ struct pxamci_host {
 	unsigned int		imask;
 	unsigned int		power_mode;
 
-	struct mmc_request	*req;
+	struct mmc_request	*mrq;
 	struct mmc_command	*cmd;
 	struct mmc_data		*data;
 
@@ -148,7 +149,7 @@ static void pxamci_setup_data(struct pxamci_host *host, struct mmc_data *data)
 	dcmd |= DCMD_BURST32 | DCMD_WIDTH1;
 
 	host->dma_size = data->blocks << data->blksz_bits;
-	host->dma_buf = dma_map_single(mmc_dev(host->mmc), data->rq->buffer,
+	host->dma_buf = dma_map_single(mmc_dev(host->mmc), data->req->buffer,
 				       host->dma_size, host->dma_dir);
 
 	for (i = 0, size = host->dma_size, dma = host->dma_buf; size; i++) {
@@ -215,13 +216,13 @@ static void pxamci_start_cmd(struct pxamci_host *host, struct mmc_command *cmd,
 	pxamci_enable_irq(host, END_CMD_RES);
 }
 
-static void pxamci_finish_request(struct pxamci_host *host, struct mmc_request *req)
+static void pxamci_finish_request(struct pxamci_host *host, struct mmc_request *mrq)
 {
 	DBG("PXAMCI: request done\n");
-	host->req = NULL;
+	host->mrq = NULL;
 	host->cmd = NULL;
 	host->data = NULL;
-	mmc_request_done(host->mmc, req);
+	mmc_request_done(host->mmc, mrq);
 }
 
 static int pxamci_cmd_done(struct pxamci_host *host, unsigned int stat)
@@ -257,7 +258,7 @@ static int pxamci_cmd_done(struct pxamci_host *host, unsigned int stat)
 	if (host->data && cmd->error == MMC_ERR_NONE) {
 		pxamci_enable_irq(host, DATA_TRAN_DONE);
 	} else {
-		pxamci_finish_request(host, host->req);
+		pxamci_finish_request(host, host->mrq);
 	}
 
 	return 1;
@@ -290,11 +291,11 @@ static int pxamci_data_done(struct pxamci_host *host, unsigned int stat)
 	pxamci_disable_irq(host, DATA_TRAN_DONE);
 
 	host->data = NULL;
-	if (host->req->stop && data->error == MMC_ERR_NONE) {
+	if (host->mrq->stop && data->error == MMC_ERR_NONE) {
 		pxamci_stop_clock(host);
-		pxamci_start_cmd(host, host->req->stop, 0);
+		pxamci_start_cmd(host, host->mrq->stop, 0);
 	} else {
-		pxamci_finish_request(host, host->req);
+		pxamci_finish_request(host, host->mrq);
 	}
 
 	return 1;
@@ -324,33 +325,33 @@ static irqreturn_t pxamci_irq(int irq, void *devid, struct pt_regs *regs)
 	return IRQ_RETVAL(handled);
 }
 
-static void pxamci_request(struct mmc_host *mmc, struct mmc_request *req)
+static void pxamci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 {
 	struct pxamci_host *host = mmc_priv(mmc);
 	unsigned int cmdat;
 
-	WARN_ON(host->req != NULL);
+	WARN_ON(host->mrq != NULL);
 
-	host->req = req;
+	host->mrq = mrq;
 
 	pxamci_stop_clock(host);
 
 	cmdat = host->cmdat;
 	host->cmdat &= ~CMDAT_INIT;
 
-	if (req->data) {
-		pxamci_setup_data(host, req->data);
+	if (mrq->data) {
+		pxamci_setup_data(host, mrq->data);
 
 		cmdat &= ~CMDAT_BUSY;
 		cmdat |= CMDAT_DATAEN | CMDAT_DMAEN;
-		if (req->data->flags & MMC_DATA_WRITE)
+		if (mrq->data->flags & MMC_DATA_WRITE)
 			cmdat |= CMDAT_WRITE;
 
-		if (req->data->flags & MMC_DATA_STREAM)
+		if (mrq->data->flags & MMC_DATA_STREAM)
 			cmdat |= CMDAT_STREAM;
 	}
 
-	pxamci_start_cmd(host, req->cmd, cmdat);
+	pxamci_start_cmd(host, mrq->cmd, cmdat);
 }
 
 static void pxamci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)

include/linux/mmc/mmc.h

@@ -39,7 +39,7 @@ struct mmc_command {
 #define MMC_ERR_INVALID	5
 
 	struct mmc_data		*data;		/* data segment associated with cmd */
-	struct mmc_request	*req;		/* assoicated request */
+	struct mmc_request	*mrq;		/* assoicated request */
 };
 
 struct mmc_data {
@@ -47,7 +47,7 @@ struct mmc_data {
 	unsigned int		timeout_clks;	/* data timeout (in clocks) */
 	unsigned int		blksz_bits;	/* data block size */
 	unsigned int		blocks;		/* number of blocks */
-	struct request		*rq;		/* request structure */
+	struct request		*req;		/* request structure */
 	unsigned int		error;		/* data error */
 	unsigned int		flags;
 
@@ -58,7 +58,7 @@ struct mmc_data {
 	unsigned int		bytes_xfered;
 
 	struct mmc_command	*stop;		/* stop command */
-	struct mmc_request	*req;		/* assoicated request */
+	struct mmc_request	*mrq;		/* assoicated request */
 };
 
 struct mmc_request {