Skip to content

L
linux
Commit e77c6276 authored by Russell King's avatar Russell King
Browse files
Options

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

      mmc_blk_request and request structures to avoid confusion.
parent fa4f257c
Hide whitespace changes
Inline Side-by-side
Showing with 99 additions and 99 deletions
drivers/mmc/mmc.c
View file @ e77c6276
......@@ -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
View file @ e77c6276
......@@ -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
View file @ e77c6276
......@@ -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
View file @ e77c6276
......@@ -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
View file @ e77c6276
......@@ -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
View file @ e77c6276
......@@ -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 {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7