mmc: remove custom error codes

Convert the MMC layer to use standard error codes and not its own,
incompatible values.

Signed-off-by: Pierre Ossman <drzeus@drzeus.cx>

9 files changed, 100 insertions, 106 deletions

diff --git a/drivers/mmc/host/at91_mci.c b/drivers/mmc/host/at91_mci.c
index 955ea60583b5..810a433ce532 100644
--- a/drivers/mmc/host/at91_mci.c
+++ b/drivers/mmc/host/at91_mci.c
@@ -577,24 +577,22 @@ static void at91_mci_completed_command(struct at91mci_host *host)
                         AT91_MCI_RENDE | AT91_MCI_RTOE | AT91_MCI_DCRCE |
                         AT91_MCI_DTOE | AT91_MCI_OVRE | AT91_MCI_UNRE)) {
                 if ((status & AT91_MCI_RCRCE) && !(mmc_resp_type(cmd) & MMC_RSP_CRC)) {
-                        cmd->error = MMC_ERR_NONE;
+                        cmd->error = 0;
                 }
                 else {
                         if (status & (AT91_MCI_RTOE | AT91_MCI_DTOE))
-                                cmd->error = MMC_ERR_TIMEOUT;
+                                cmd->error = -ETIMEDOUT;
                         else if (status & (AT91_MCI_RCRCE | AT91_MCI_DCRCE))
-                                cmd->error = MMC_ERR_BADCRC;
-                        else if (status & (AT91_MCI_OVRE | AT91_MCI_UNRE))
-                                cmd->error = MMC_ERR_FIFO;
+                                cmd->error = -EILSEQ;
                         else
-                                cmd->error = MMC_ERR_FAILED;
+                                cmd->error = -EIO;
 
                         pr_debug("Error detected and set to %d (cmd = %d, retries = %d)\n",
                                  cmd->error, cmd->opcode, cmd->retries);
                 }
         }
         else
-                cmd->error = MMC_ERR_NONE;
+                cmd->error = 0;
 
         at91_mci_process_next(host);
 }
diff --git a/drivers/mmc/host/au1xmmc.c b/drivers/mmc/host/au1xmmc.c
index 34c99d4ea041..49b0367e57c8 100644
--- a/drivers/mmc/host/au1xmmc.c
+++ b/drivers/mmc/host/au1xmmc.c
@@ -208,7 +208,7 @@ static int au1xmmc_send_command(struct au1xmmc_host *host, int wait,
         default:
                 printk(KERN_INFO "au1xmmc: unhandled response type %02x\n",
                         mmc_resp_type(cmd));
-                return MMC_ERR_INVALID;
+                return -EINVAL;
         }
 
         if (flags & MMC_DATA_READ) {
@@ -253,7 +253,7 @@ static int au1xmmc_send_command(struct au1xmmc_host *host, int wait,
                 IRQ_ON(host, SD_CONFIG_CR);
         }
 
-        return MMC_ERR_NONE;
+        return 0;
 }
 
 static void au1xmmc_data_complete(struct au1xmmc_host *host, u32 status)
@@ -278,7 +278,7 @@ static void au1xmmc_data_complete(struct au1xmmc_host *host, u32 status)
         while((host->flags & HOST_F_XMIT) && (status & SD_STATUS_DB))
                 status = au_readl(HOST_STATUS(host));
 
-        data->error = MMC_ERR_NONE;
+        data->error = 0;
         dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len, host->dma.dir);
 
         /* Process any errors */
@@ -288,14 +288,14 @@ static void au1xmmc_data_complete(struct au1xmmc_host *host, u32 status)
                 crc |= ((status & 0x07) == 0x02) ? 0 : 1;
 
         if (crc)
-                data->error = MMC_ERR_BADCRC;
+                data->error = -EILSEQ;
 
         /* Clear the CRC bits */
         au_writel(SD_STATUS_WC | SD_STATUS_RC, HOST_STATUS(host));
 
         data->bytes_xfered = 0;
 
-        if (data->error == MMC_ERR_NONE) {
+        if (!data->error) {
                 if (host->flags & HOST_F_DMA) {
                         u32 chan = DMA_CHANNEL(host);
 
@@ -475,7 +475,7 @@ static void au1xmmc_cmd_complete(struct au1xmmc_host *host, u32 status)
                 return;
 
         cmd = mrq->cmd;
-        cmd->error = MMC_ERR_NONE;
+        cmd->error = 0;
 
         if (cmd->flags & MMC_RSP_PRESENT) {
                 if (cmd->flags & MMC_RSP_136) {
@@ -512,11 +512,11 @@ static void au1xmmc_cmd_complete(struct au1xmmc_host *host, u32 status)
         /* Figure out errors */
 
         if (status & (SD_STATUS_SC | SD_STATUS_WC | SD_STATUS_RC))
-                cmd->error = MMC_ERR_BADCRC;
+                cmd->error = -EILSEQ;
 
         trans = host->flags & (HOST_F_XMIT | HOST_F_RECV);
 
-        if (!trans || cmd->error != MMC_ERR_NONE) {
+        if (!trans || cmd->error) {
 
                 IRQ_OFF(host, SD_CONFIG_TH | SD_CONFIG_RA|SD_CONFIG_RF);
                 tasklet_schedule(&host->finish_task);
@@ -589,7 +589,7 @@ au1xmmc_prepare_data(struct au1xmmc_host *host, struct mmc_data *data)
                                    data->sg_len, host->dma.dir);
 
         if (host->dma.len == 0)
-                return MMC_ERR_TIMEOUT;
+                return -ETIMEDOUT;
 
         au_writel(data->blksz - 1, HOST_BLKSIZE(host));
 
@@ -640,11 +640,11 @@ au1xmmc_prepare_data(struct au1xmmc_host *host, struct mmc_data *data)
                         //IRQ_ON(host, SD_CONFIG_RA|SD_CONFIG_RF);
         }
 
-        return MMC_ERR_NONE;
+        return 0;
 
  dataerr:
         dma_unmap_sg(mmc_dev(host->mmc),data->sg,data->sg_len,host->dma.dir);
-        return MMC_ERR_TIMEOUT;
+        return -ETIMEDOUT;
 }
 
 /* static void au1xmmc_request
@@ -656,7 +656,7 @@ static void au1xmmc_request(struct mmc_host* mmc, struct mmc_request* mrq)
 
         struct au1xmmc_host *host = mmc_priv(mmc);
         unsigned int flags = 0;
-        int ret = MMC_ERR_NONE;
+        int ret = 0;
 
         WARN_ON(irqs_disabled());
         WARN_ON(host->status != HOST_S_IDLE);
@@ -672,10 +672,10 @@ static void au1xmmc_request(struct mmc_host* mmc, struct mmc_request* mrq)
                 ret = au1xmmc_prepare_data(host, mrq->data);
         }
 
-        if (ret == MMC_ERR_NONE)
+        if (!ret)
                 ret = au1xmmc_send_command(host, 0, mrq->cmd, flags);
 
-        if (ret != MMC_ERR_NONE) {
+        if (ret) {
                 mrq->cmd->error = ret;
                 au1xmmc_finish_request(host);
         }
@@ -764,10 +764,10 @@ static irqreturn_t au1xmmc_irq(int irq, void *dev_id)
 
                 if (host->mrq && (status & STATUS_TIMEOUT)) {
                         if (status & SD_STATUS_RAT)
-                                host->mrq->cmd->error = MMC_ERR_TIMEOUT;
+                                host->mrq->cmd->error = -ETIMEDOUT;
 
                         else if (status & SD_STATUS_DT)
-                                host->mrq->data->error = MMC_ERR_TIMEOUT;
+                                host->mrq->data->error = -ETIMEDOUT;
 
                         /* In PIO mode, interrupts might still be enabled */
                         IRQ_OFF(host, SD_CONFIG_NE | SD_CONFIG_TH);
diff --git a/drivers/mmc/host/imxmmc.c b/drivers/mmc/host/imxmmc.c
index 54bfc9f25596..04458c342812 100644
--- a/drivers/mmc/host/imxmmc.c
+++ b/drivers/mmc/host/imxmmc.c
@@ -428,11 +428,11 @@ static int imxmci_finish_data(struct imxmci_host *host, unsigned int stat)
         if ( stat & STATUS_ERR_MASK ) {
                 dev_dbg(mmc_dev(host->mmc), "request failed. status: 0x%08x\n",stat);
                 if(stat & (STATUS_CRC_READ_ERR | STATUS_CRC_WRITE_ERR))
-                        data->error = MMC_ERR_BADCRC;
+                        data->error = -EILSEQ;
                 else if(stat & STATUS_TIME_OUT_READ)
-                        data->error = MMC_ERR_TIMEOUT;
+                        data->error = -ETIMEDOUT;
                 else
-                        data->error = MMC_ERR_FAILED;
+                        data->error = -EIO;
         } else {
                 data->bytes_xfered = host->dma_size;
         }
@@ -458,10 +458,10 @@ static int imxmci_cmd_done(struct imxmci_host *host, unsigned int stat)
 
         if (stat & STATUS_TIME_OUT_RESP) {
                 dev_dbg(mmc_dev(host->mmc), "CMD TIMEOUT\n");
-                cmd->error = MMC_ERR_TIMEOUT;
+                cmd->error = -ETIMEDOUT;
         } else if (stat & STATUS_RESP_CRC_ERR && cmd->flags & MMC_RSP_CRC) {
                 dev_dbg(mmc_dev(host->mmc), "cmd crc error\n");
-                cmd->error = MMC_ERR_BADCRC;
+                cmd->error = -EILSEQ;
         }
 
         if(cmd->flags & MMC_RSP_PRESENT) {
@@ -482,7 +482,7 @@ static int imxmci_cmd_done(struct imxmci_host *host, unsigned int stat)
         dev_dbg(mmc_dev(host->mmc), "RESP 0x%08x, 0x%08x, 0x%08x, 0x%08x, error %d\n",
                 cmd->resp[0], cmd->resp[1], cmd->resp[2], cmd->resp[3], cmd->error);
 
-        if (data && (cmd->error == MMC_ERR_NONE) && !(stat & STATUS_ERR_MASK)) {
+        if (data && !cmd->error && !(stat & STATUS_ERR_MASK)) {
                 if (host->req->data->flags & MMC_DATA_WRITE) {
 
                         /* Wait for FIFO to be empty before starting DMA write */
@@ -491,7 +491,7 @@ static int imxmci_cmd_done(struct imxmci_host *host, unsigned int stat)
                         if(imxmci_busy_wait_for_status(host, &stat,
                                 STATUS_APPL_BUFF_FE,
                                 40, "imxmci_cmd_done DMA WR") < 0) {
-                                cmd->error = MMC_ERR_FIFO;
+                                cmd->error = -EIO;
                                 imxmci_finish_data(host, stat);
                                 if(host->req)
                                         imxmci_finish_request(host, host->req);
diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index be730c0a0352..d53e9a8bdaa2 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -154,11 +154,11 @@ mmci_data_irq(struct mmci_host *host, struct mmc_data *data,
         }
         if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_TXUNDERRUN|MCI_RXOVERRUN)) {
                 if (status & MCI_DATACRCFAIL)
-                        data->error = MMC_ERR_BADCRC;
+                        data->error = -EILSEQ;
                 else if (status & MCI_DATATIMEOUT)
-                        data->error = MMC_ERR_TIMEOUT;
+                        data->error = -ETIMEDOUT;
                 else if (status & (MCI_TXUNDERRUN|MCI_RXOVERRUN))
-                        data->error = MMC_ERR_FIFO;
+                        data->error = -EIO;
                 status |= MCI_DATAEND;
 
                 /*
@@ -193,12 +193,12 @@ mmci_cmd_irq(struct mmci_host *host, struct mmc_command *cmd,
         cmd->resp[3] = readl(base + MMCIRESPONSE3);
 
         if (status & MCI_CMDTIMEOUT) {
-                cmd->error = MMC_ERR_TIMEOUT;
+                cmd->error = -ETIMEDOUT;
         } else if (status & MCI_CMDCRCFAIL && cmd->flags & MMC_RSP_CRC) {
-                cmd->error = MMC_ERR_BADCRC;
+                cmd->error = -EILSEQ;
         }
 
-        if (!cmd->data || cmd->error != MMC_ERR_NONE) {
+        if (!cmd->data || cmd->error) {
                 if (host->data)
                         mmci_stop_data(host);
                 mmci_request_end(host, cmd->mrq);
diff --git a/drivers/mmc/host/omap.c b/drivers/mmc/host/omap.c
index 0cf97edc5f58..60a67dfcda6a 100644
--- a/drivers/mmc/host/omap.c
+++ b/drivers/mmc/host/omap.c
@@ -263,7 +263,7 @@ mmc_omap_xfer_done(struct mmc_omap_host *host, struct mmc_data *data)
                 enum dma_data_direction dma_data_dir;
 
                 BUG_ON(host->dma_ch < 0);
-                if (data->error != MMC_ERR_NONE)
+                if (data->error)
                         omap_stop_dma(host->dma_ch);
                 /* Release DMA channel lazily */
                 mod_timer(&host->dma_timer, jiffies + HZ);
@@ -368,7 +368,7 @@ mmc_omap_cmd_done(struct mmc_omap_host *host, struct mmc_command *cmd)
                 }
         }
 
-        if (host->data == NULL || cmd->error != MMC_ERR_NONE) {
+        if (host->data == NULL || cmd->error) {
                 host->mrq = NULL;
                 clk_disable(host->fclk);
                 mmc_request_done(host->mmc, cmd->mrq);
@@ -475,14 +475,14 @@ static irqreturn_t mmc_omap_irq(int irq, void *dev_id)
                 if (status & OMAP_MMC_STAT_DATA_TOUT) {
                         dev_dbg(mmc_dev(host->mmc), "data timeout\n");
                         if (host->data) {
-                                host->data->error |= MMC_ERR_TIMEOUT;
+                                host->data->error = -ETIMEDOUT;
                                 transfer_error = 1;
                         }
                 }
 
                 if (status & OMAP_MMC_STAT_DATA_CRC) {
                         if (host->data) {
-                                host->data->error |= MMC_ERR_BADCRC;
+                                host->data->error = -EILSEQ;
                                 dev_dbg(mmc_dev(host->mmc),
                                          "data CRC error, bytes left %d\n",
                                         host->total_bytes_left);
@@ -504,7 +504,7 @@ static irqreturn_t mmc_omap_irq(int irq, void *dev_id)
                                         dev_err(mmc_dev(host->mmc),
                                                 "command timeout, CMD %d\n",
                                                 host->cmd->opcode);
-                                host->cmd->error = MMC_ERR_TIMEOUT;
+                                host->cmd->error = -ETIMEDOUT;
                                 end_command = 1;
                         }
                 }
@@ -514,7 +514,7 @@ static irqreturn_t mmc_omap_irq(int irq, void *dev_id)
                                 dev_err(mmc_dev(host->mmc),
                                         "command CRC error (CMD%d, arg 0x%08x)\n",
                                         host->cmd->opcode, host->cmd->arg);
-                                host->cmd->error = MMC_ERR_BADCRC;
+                                host->cmd->error = -EILSEQ;
                                 end_command = 1;
                         } else
                                 dev_err(mmc_dev(host->mmc),
diff --git a/drivers/mmc/host/pxamci.c b/drivers/mmc/host/pxamci.c
index ff960334b337..b89e32d1e9b5 100644
--- a/drivers/mmc/host/pxamci.c
+++ b/drivers/mmc/host/pxamci.c
@@ -226,7 +226,7 @@ static int pxamci_cmd_done(struct pxamci_host *host, unsigned int stat)
         }
 
         if (stat & STAT_TIME_OUT_RESPONSE) {
-                cmd->error = MMC_ERR_TIMEOUT;
+                cmd->error = -ETIMEDOUT;
         } else if (stat & STAT_RES_CRC_ERR && cmd->flags & MMC_RSP_CRC) {
 #ifdef CONFIG_PXA27x
                 /*
@@ -239,11 +239,11 @@ static int pxamci_cmd_done(struct pxamci_host *host, unsigned int stat)
                         pr_debug("ignoring CRC from command %d - *risky*\n", cmd->opcode);
                 } else
 #endif
-                cmd->error = MMC_ERR_BADCRC;
+                cmd->error = -EILSEQ;
         }
 
         pxamci_disable_irq(host, END_CMD_RES);
-        if (host->data && cmd->error == MMC_ERR_NONE) {
+        if (host->data && !cmd->error) {
                 pxamci_enable_irq(host, DATA_TRAN_DONE);
         } else {
                 pxamci_finish_request(host, host->mrq);
@@ -264,9 +264,9 @@ static int pxamci_data_done(struct pxamci_host *host, unsigned int stat)
                      host->dma_dir);
 
         if (stat & STAT_READ_TIME_OUT)
-                data->error = MMC_ERR_TIMEOUT;
+                data->error = -ETIMEDOUT;
         else if (stat & (STAT_CRC_READ_ERROR|STAT_CRC_WRITE_ERROR))
-                data->error = MMC_ERR_BADCRC;
+                data->error = -EILSEQ;
 
         /*
          * There appears to be a hardware design bug here.  There seems to
@@ -274,7 +274,7 @@ static int pxamci_data_done(struct pxamci_host *host, unsigned int stat)
          * This means that if there was an error on any block, we mark all
          * data blocks as being in error.
          */
-        if (data->error == MMC_ERR_NONE)
+        if (!data->error)
                 data->bytes_xfered = data->blocks * data->blksz;
         else
                 data->bytes_xfered = 0;
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 20a7d89e01ba..479d6a265dd1 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -481,16 +481,16 @@ static void sdhci_finish_data(struct sdhci_host *host)
          * Controller doesn't count down when in single block mode.
          */
         if (data->blocks == 1)
-                blocks = (data->error == MMC_ERR_NONE) ? 0 : 1;
+                blocks = (data->error == 0) ? 0 : 1;
         else
                 blocks = readw(host->ioaddr + SDHCI_BLOCK_COUNT);
         data->bytes_xfered = data->blksz * (data->blocks - blocks);
 
-        if ((data->error == MMC_ERR_NONE) && blocks) {
+        if (!data->error && blocks) {
                 printk(KERN_ERR "%s: Controller signalled completion even "
                         "though there were blocks left.\n",
                         mmc_hostname(host->mmc));
-                data->error = MMC_ERR_FAILED;
+                data->error = -EIO;
         }
 
         if (data->stop) {
@@ -498,7 +498,7 @@ static void sdhci_finish_data(struct sdhci_host *host)
                  * The controller needs a reset of internal state machines
                  * upon error conditions.
                  */
-                if (data->error != MMC_ERR_NONE) {
+                if (data->error) {
                         sdhci_reset(host, SDHCI_RESET_CMD);
                         sdhci_reset(host, SDHCI_RESET_DATA);
                 }
@@ -533,7 +533,7 @@ static void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
                         printk(KERN_ERR "%s: Controller never released "
                                 "inhibit bit(s).\n", mmc_hostname(host->mmc));
                         sdhci_dumpregs(host);
-                        cmd->error = MMC_ERR_FAILED;
+                        cmd->error = -EIO;
                         tasklet_schedule(&host->finish_tasklet);
                         return;
                 }
@@ -554,7 +554,7 @@ static void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
         if ((cmd->flags & MMC_RSP_136) && (cmd->flags & MMC_RSP_BUSY)) {
                 printk(KERN_ERR "%s: Unsupported response type!\n",
                         mmc_hostname(host->mmc));
-                cmd->error = MMC_ERR_INVALID;
+                cmd->error = -EINVAL;
                 tasklet_schedule(&host->finish_tasklet);
                 return;
         }
@@ -601,7 +601,7 @@ static void sdhci_finish_command(struct sdhci_host *host)
                 }
         }
 
-        host->cmd->error = MMC_ERR_NONE;
+        host->cmd->error = 0;
 
         if (host->data && host->data_early)
                 sdhci_finish_data(host);
@@ -722,7 +722,7 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
         host->mrq = mrq;
 
         if (!(readl(host->ioaddr + SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT)) {
-                host->mrq->cmd->error = MMC_ERR_TIMEOUT;
+                host->mrq->cmd->error = -ENOMEDIUM;
                 tasklet_schedule(&host->finish_tasklet);
         } else
                 sdhci_send_command(host, mrq->cmd);
@@ -831,7 +831,7 @@ static void sdhci_tasklet_card(unsigned long param)
                         sdhci_reset(host, SDHCI_RESET_CMD);
                         sdhci_reset(host, SDHCI_RESET_DATA);
 
-                        host->mrq->cmd->error = MMC_ERR_FAILED;
+                        host->mrq->cmd->error = -ENOMEDIUM;
                         tasklet_schedule(&host->finish_tasklet);
                 }
         }
@@ -859,9 +859,9 @@ static void sdhci_tasklet_finish(unsigned long param)
          * The controller needs a reset of internal state machines
          * upon error conditions.
          */
-        if ((mrq->cmd->error != MMC_ERR_NONE) ||
-                (mrq->data && ((mrq->data->error != MMC_ERR_NONE) ||
-                (mrq->data->stop && (mrq->data->stop->error != MMC_ERR_NONE))))) {
+        if (mrq->cmd->error ||
+                (mrq->data && (mrq->data->error ||
+                (mrq->data->stop && mrq->data->stop->error)))) {
 
                 /* Some controllers need this kick or reset won't work here */
                 if (host->chip->quirks & SDHCI_QUIRK_CLOCK_BEFORE_RESET) {
@@ -906,13 +906,13 @@ static void sdhci_timeout_timer(unsigned long data)
                 sdhci_dumpregs(host);
 
                 if (host->data) {
-                        host->data->error = MMC_ERR_TIMEOUT;
+                        host->data->error = -ETIMEDOUT;
                         sdhci_finish_data(host);
                 } else {
                         if (host->cmd)
-                                host->cmd->error = MMC_ERR_TIMEOUT;
+                                host->cmd->error = -ETIMEDOUT;
                         else
-                                host->mrq->cmd->error = MMC_ERR_TIMEOUT;
+                                host->mrq->cmd->error = -ETIMEDOUT;
 
                         tasklet_schedule(&host->finish_tasklet);
                 }
@@ -941,13 +941,12 @@ static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask)
         }
 
         if (intmask & SDHCI_INT_TIMEOUT)
-                host->cmd->error = MMC_ERR_TIMEOUT;
-        else if (intmask & SDHCI_INT_CRC)
-                host->cmd->error = MMC_ERR_BADCRC;
-        else if (intmask & (SDHCI_INT_END_BIT | SDHCI_INT_INDEX))
-                host->cmd->error = MMC_ERR_FAILED;
+                host->cmd->error = -ETIMEDOUT;
+        else if (intmask & (SDHCI_INT_CRC | SDHCI_INT_END_BIT |
+                        SDHCI_INT_INDEX))
+                host->cmd->error = -EILSEQ;
 
-        if (host->cmd->error != MMC_ERR_NONE)
+        if (host->cmd->error)
                 tasklet_schedule(&host->finish_tasklet);
         else if (intmask & SDHCI_INT_RESPONSE)
                 sdhci_finish_command(host);
@@ -974,13 +973,11 @@ static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
         }
 
         if (intmask & SDHCI_INT_DATA_TIMEOUT)
-                host->data->error = MMC_ERR_TIMEOUT;
-        else if (intmask & SDHCI_INT_DATA_CRC)
-                host->data->error = MMC_ERR_BADCRC;
-        else if (intmask & SDHCI_INT_DATA_END_BIT)
-                host->data->error = MMC_ERR_FAILED;
+                host->data->error = -ETIMEDOUT;
+        else if (intmask & (SDHCI_INT_DATA_CRC | SDHCI_INT_DATA_END_BIT))
+                host->data->error = -EILSEQ;
 
-        if (host->data->error != MMC_ERR_NONE)
+        if (host->data->error)
                 sdhci_finish_data(host);
         else {
                 if (intmask & (SDHCI_INT_DATA_AVAIL | SDHCI_INT_SPACE_AVAIL))
diff --git a/drivers/mmc/host/tifm_sd.c b/drivers/mmc/host/tifm_sd.c
index 8b736e968447..b4a56e5e5132 100644
--- a/drivers/mmc/host/tifm_sd.c
+++ b/drivers/mmc/host/tifm_sd.c
@@ -404,14 +404,14 @@ static void tifm_sd_check_status(struct tifm_sd *host)
         struct tifm_dev *sock = host->dev;
         struct mmc_command *cmd = host->req->cmd;
 
-        if (cmd->error != MMC_ERR_NONE)
+        if (cmd->error)
                 goto finish_request;
 
         if (!(host->cmd_flags & CMD_READY))
                 return;
 
         if (cmd->data) {
-                if (cmd->data->error != MMC_ERR_NONE) {
+                if (cmd->data->error) {
                         if ((host->cmd_flags & SCMD_ACTIVE)
                             && !(host->cmd_flags & SCMD_READY))
                                 return;
@@ -504,7 +504,7 @@ static void tifm_sd_card_event(struct tifm_dev *sock)
 {
         struct tifm_sd *host;
         unsigned int host_status = 0;
-        int cmd_error = MMC_ERR_NONE;
+        int cmd_error = 0;
         struct mmc_command *cmd = NULL;
         unsigned long flags;
 
@@ -521,15 +521,15 @@ static void tifm_sd_card_event(struct tifm_dev *sock)
                         writel(host_status & TIFM_MMCSD_ERRMASK,
                                sock->addr + SOCK_MMCSD_STATUS);
                         if (host_status & TIFM_MMCSD_CTO)
-                                cmd_error = MMC_ERR_TIMEOUT;
+                                cmd_error = -ETIMEDOUT;
                         else if (host_status & TIFM_MMCSD_CCRC)
-                                cmd_error = MMC_ERR_BADCRC;
+                                cmd_error = -EILSEQ;
 
                         if (cmd->data) {
                                 if (host_status & TIFM_MMCSD_DTO)
-                                        cmd->data->error = MMC_ERR_TIMEOUT;
+                                        cmd->data->error = -ETIMEDOUT;
                                 else if (host_status & TIFM_MMCSD_DCRC)
-                                        cmd->data->error = MMC_ERR_BADCRC;
+                                        cmd->data->error = -EILSEQ;
                         }
 
                         writel(TIFM_FIFO_INT_SETALL,
@@ -722,7 +722,7 @@ static void tifm_sd_request(struct mmc_host *mmc, struct mmc_request *mrq)
         return;
 
 err_out:
-        mrq->cmd->error = MMC_ERR_TIMEOUT;
+        mrq->cmd->error = -ETIMEDOUT;
         mmc_request_done(mmc, mrq);
 }
 
@@ -1012,9 +1012,9 @@ static void tifm_sd_remove(struct tifm_dev *sock)
                 writel(TIFM_FIFO_INT_SETALL,
                        sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
                 writel(0, sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET);
-                host->req->cmd->error = MMC_ERR_TIMEOUT;
+                host->req->cmd->error = -ENOMEDIUM;
                 if (host->req->stop)
-                        host->req->stop->error = MMC_ERR_TIMEOUT;
+                        host->req->stop->error = -ENOMEDIUM;
                 tasklet_schedule(&host->finish_tasklet);
         }
         spin_unlock_irqrestore(&sock->lock, flags);
diff --git a/drivers/mmc/host/wbsd.c b/drivers/mmc/host/wbsd.c
index 9bf2a877113b..44968c2279e1 100644
--- a/drivers/mmc/host/wbsd.c
+++ b/drivers/mmc/host/wbsd.c
@@ -317,7 +317,7 @@ static inline void wbsd_get_short_reply(struct wbsd_host *host,
          * Correct response type?
          */
         if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_SHORT) {
-                cmd->error = MMC_ERR_INVALID;
+                cmd->error = -EILSEQ;
                 return;
         }
 
@@ -337,7 +337,7 @@ static inline void wbsd_get_long_reply(struct wbsd_host *host,
          * Correct response type?
          */
         if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_LONG) {
-                cmd->error = MMC_ERR_INVALID;
+                cmd->error = -EILSEQ;
                 return;
         }
 
@@ -372,7 +372,7 @@ static void wbsd_send_command(struct wbsd_host *host, struct mmc_command *cmd)
         for (i = 3; i >= 0; i--)
                 outb((cmd->arg >> (i * 8)) & 0xff, host->base + WBSD_CMDR);
 
-        cmd->error = MMC_ERR_NONE;
+        cmd->error = 0;
 
         /*
          * Wait for the request to complete.
@@ -392,13 +392,13 @@ static void wbsd_send_command(struct wbsd_host *host, struct mmc_command *cmd)
 
                 /* Card removed? */
                 if (isr & WBSD_INT_CARD)
-                        cmd->error = MMC_ERR_TIMEOUT;
+                        cmd->error = -ENOMEDIUM;
                 /* Timeout? */
                 else if (isr & WBSD_INT_TIMEOUT)
-                        cmd->error = MMC_ERR_TIMEOUT;
+                        cmd->error = -ETIMEDOUT;
                 /* CRC? */
                 else if ((cmd->flags & MMC_RSP_CRC) && (isr & WBSD_INT_CRC))
-                        cmd->error = MMC_ERR_BADCRC;
+                        cmd->error = -EILSEQ;
                 /* All ok */
                 else {
                         if (cmd->flags & MMC_RSP_136)
@@ -585,7 +585,7 @@ static void wbsd_prepare_data(struct wbsd_host *host, struct mmc_data *data)
                         ((blksize >> 4) & 0xF0) | WBSD_DATA_WIDTH);
                 wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
         } else {
-                data->error = MMC_ERR_INVALID;
+                data->error = -EINVAL;
                 return;
         }
 
@@ -607,7 +607,7 @@ static void wbsd_prepare_data(struct wbsd_host *host, struct mmc_data *data)
                  */
                 BUG_ON(size > 0x10000);
                 if (size > 0x10000) {
-                        data->error = MMC_ERR_INVALID;
+                        data->error = -EINVAL;
                         return;
                 }
 
@@ -669,7 +669,7 @@ static void wbsd_prepare_data(struct wbsd_host *host, struct mmc_data *data)
                 }
         }
 
-        data->error = MMC_ERR_NONE;
+        data->error = 0;
 }
 
 static void wbsd_finish_data(struct wbsd_host *host, struct mmc_data *data)
@@ -724,8 +724,8 @@ static void wbsd_finish_data(struct wbsd_host *host, struct mmc_data *data)
                                 "%d bytes left.\n",
                                 mmc_hostname(host->mmc), count);
 
-                        if (data->error == MMC_ERR_NONE)
-                                data->error = MMC_ERR_FAILED;
+                        if (!data->error)
+                                data->error = -EIO;
                 } else {
                         /*
                          * Transfer data from DMA buffer to
@@ -735,7 +735,7 @@ static void wbsd_finish_data(struct wbsd_host *host, struct mmc_data *data)
                                 wbsd_dma_to_sg(host, data);
                 }
 
-                if (data->error != MMC_ERR_NONE) {
+                if (data->error) {
                         if (data->bytes_xfered)
                                 data->bytes_xfered -= data->blksz;
                 }
@@ -767,11 +767,10 @@ static void wbsd_request(struct mmc_host *mmc, struct mmc_request *mrq)
         host->mrq = mrq;
 
         /*
-         * If there is no card in the slot then
-         * timeout immediatly.
+         * Check that there is actually a card in the slot.
          */
         if (!(host->flags & WBSD_FCARD_PRESENT)) {
-                cmd->error = MMC_ERR_TIMEOUT;
+                cmd->error = -ENOMEDIUM;
                 goto done;
         }
 
@@ -807,7 +806,7 @@ static void wbsd_request(struct mmc_host *mmc, struct mmc_request *mrq)
                                 "supported by this controller.\n",
                                 mmc_hostname(host->mmc), cmd->opcode);
 #endif
-                        cmd->error = MMC_ERR_INVALID;
+                        cmd->error = -EINVAL;
 
                         goto done;
                 };
@@ -819,7 +818,7 @@ static void wbsd_request(struct mmc_host *mmc, struct mmc_request *mrq)
         if (cmd->data) {
                 wbsd_prepare_data(host, cmd->data);
 
-                if (cmd->data->error != MMC_ERR_NONE)
+                if (cmd->data->error)
                         goto done;
         }
 
@@ -830,7 +829,7 @@ static void wbsd_request(struct mmc_host *mmc, struct mmc_request *mrq)
          * will be finished after the data has
          * transfered.
          */
-        if (cmd->data && (cmd->error == MMC_ERR_NONE)) {
+        if (cmd->data && !cmd->error) {
                 /*
                  * Dirty fix for hardware bug.
                  */
@@ -1033,7 +1032,7 @@ static void wbsd_tasklet_card(unsigned long param)
                                 mmc_hostname(host->mmc));
                         wbsd_reset(host);
 
-                        host->mrq->cmd->error = MMC_ERR_FAILED;
+                        host->mrq->cmd->error = -ENOMEDIUM;
                         tasklet_schedule(&host->finish_tasklet);
                 }
 
@@ -1097,7 +1096,7 @@ static void wbsd_tasklet_crc(unsigned long param)
 
         DBGF("CRC error\n");
 
-        data->error = MMC_ERR_BADCRC;
+        data->error = -EILSEQ;
 
         tasklet_schedule(&host->finish_tasklet);
 
@@ -1121,7 +1120,7 @@ static void wbsd_tasklet_timeout(unsigned long param)
 
         DBGF("Timeout\n");
 
-        data->error = MMC_ERR_TIMEOUT;
+        data->error = -ETIMEDOUT;
 
         tasklet_schedule(&host->finish_tasklet);