]> git.sur5r.net Git - u-boot/commitdiff
mmc: use the generic error number
authorJaehoon Chung <jh80.chung@samsung.com>
Tue, 19 Jul 2016 07:33:36 +0000 (16:33 +0900)
committerJaehoon Chung <jh80.chung@samsung.com>
Fri, 5 Aug 2016 02:21:25 +0000 (11:21 +0900)
Use the generic error number instead of specific error number.
If use the generic error number, it can debug more easier.

Signed-off-by: Jaehoon Chung <jh80.chung@samsung.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Reviewed-by: Minkyu Kang <mk7.kang@samsung.com>
21 files changed:
drivers/mmc/arm_pl180_mmci.c
drivers/mmc/bfin_sdh.c
drivers/mmc/davinci_mmc.c
drivers/mmc/dw_mmc.c
drivers/mmc/fsl_esdhc.c
drivers/mmc/ftsdc010_mci.c
drivers/mmc/gen_atmel_mci.c
drivers/mmc/mmc.c
drivers/mmc/mmc_spi.c
drivers/mmc/mvebu_mmc.c
drivers/mmc/mxcmmc.c
drivers/mmc/mxsmmc.c
drivers/mmc/omap_hsmmc.c
drivers/mmc/s3c_sdi.c
drivers/mmc/sdhci.c
drivers/mmc/sh_mmcif.c
drivers/mmc/sh_sdhi.c
drivers/mmc/sunxi_mmc.c
drivers/mmc/tegra_mmc.c
drivers/mmc/uniphier-sd.c
include/mmc.h

index 8f2694f14c0a7caa703511d6848d1c03138db649..e64ac3c9939728ca38ef60a4c1e66066b87ad3fd 100644 (file)
@@ -37,7 +37,7 @@ static int wait_for_command_end(struct mmc *dev, struct mmc_cmd *cmd)
        writel(statusmask, &host->base->status_clear);
        if (hoststatus & SDI_STA_CTIMEOUT) {
                debug("CMD%d time out\n", cmd->cmdidx);
-               return TIMEOUT;
+               return -ETIMEDOUT;
        } else if ((hoststatus & SDI_STA_CCRCFAIL) &&
                   (cmd->resp_type & MMC_RSP_CRC)) {
                printf("CMD%d CRC error\n", cmd->cmdidx);
index 9bdfbbca01175187ac717942e8144d09ebb82b10..0e493dae0ecf235de38fcf5cb2a8961253ec6365 100644 (file)
@@ -109,9 +109,9 @@ sdh_send_cmd(struct mmc *mmc, struct mmc_cmd *mmc_cmd)
        }
 
        if (status & CMD_TIME_OUT)
-               ret = TIMEOUT;
+               ret = -ETIMEDOUT;
        else if (status & CMD_CRC_FAIL && flags & MMC_RSP_CRC)
-               ret = COMM_ERR;
+               ret = -ECOMM;
        else
                ret = 0;
 
@@ -136,7 +136,7 @@ static int sdh_setup_data(struct mmc *mmc, struct mmc_data *data)
 
        /* Don't support write yet. */
        if (data->flags & MMC_DATA_WRITE)
-               return UNUSABLE_ERR;
+               return -EOPNOTSUPP;
 #ifndef RSI_BLKSZ
        data_ctl |= ((ffs(data->blocksize) - 1) << 4);
 #else
@@ -194,10 +194,10 @@ static int bfin_sdh_request(struct mmc *mmc, struct mmc_cmd *cmd,
 
                if (status & DAT_TIME_OUT) {
                        bfin_write_SDH_STATUS_CLR(DAT_TIMEOUT_STAT);
-                       ret |= TIMEOUT;
+                       ret = -ETIMEDOUT;
                } else if (status & (DAT_CRC_FAIL | RX_OVERRUN)) {
                        bfin_write_SDH_STATUS_CLR(DAT_CRC_FAIL_STAT | RX_OVERRUN_STAT);
-                       ret |= COMM_ERR;
+                       ret = -ECOMM;
                } else
                        bfin_write_SDH_STATUS_CLR(DAT_BLK_END_STAT | DAT_END_STAT);
 
index aae00e9dab3103d539482b7fdb8ab2ff6e27e0e1..b495c7564cb2f000c33c2c343b362b887a37782e 100644 (file)
@@ -9,6 +9,7 @@
 #include <config.h>
 #include <common.h>
 #include <command.h>
+#include <errno.h>
 #include <mmc.h>
 #include <part.h>
 #include <malloc.h>
@@ -66,7 +67,7 @@ dmmc_wait_fifo_status(volatile struct davinci_mmc_regs *regs, uint status)
                udelay(100);
 
        if (wdog == 0)
-               return COMM_ERR;
+               return -ECOMM;
 
        return 0;
 }
@@ -80,7 +81,7 @@ static int dmmc_busy_wait(volatile struct davinci_mmc_regs *regs)
                udelay(10);
 
        if (wdog == 0)
-               return COMM_ERR;
+               return -ECOMM;
 
        return 0;
 }
@@ -99,7 +100,7 @@ static int dmmc_check_status(volatile struct davinci_mmc_regs *regs,
                        return 0;
                } else if (mmcstatus & st_error) {
                        if (mmcstatus & MMCST0_TOUTRS)
-                               return TIMEOUT;
+                               return -ETIMEDOUT;
                        printf("[ ST0 ERROR %x]\n", mmcstatus);
                        /*
                         * Ignore CRC errors as some MMC cards fail to
@@ -107,7 +108,7 @@ static int dmmc_check_status(volatile struct davinci_mmc_regs *regs,
                         */
                        if (mmcstatus & MMCST0_CRCRS)
                                return 0;
-                       return COMM_ERR;
+                       return -ECOMM;
                }
                udelay(10);
 
@@ -116,7 +117,7 @@ static int dmmc_check_status(volatile struct davinci_mmc_regs *regs,
 
        printf("Status %x Timeout ST0:%x ST1:%x\n", st_ready, mmcstatus,
                        get_val(&regs->mmcst1));
-       return COMM_ERR;
+       return -ECOMM;
 }
 
 /*
index 3ca9743ba06046b16af5ac932928b576f120f7a0..a6a5fc65790a18db6f52d6cdeb0b11bf7a0377fa 100644 (file)
@@ -158,7 +158,7 @@ static int dwmci_data_transfer(struct dwmci_host *host, struct mmc_data *data)
                if (get_timer(start) > timeout) {
                        debug("%s: Timeout waiting for data!\n",
                              __func__);
-                       ret = TIMEOUT;
+                       ret = -ETIMEDOUT;
                        break;
                }
        }
@@ -203,7 +203,7 @@ static int dwmci_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
        while (dwmci_readl(host, DWMCI_STATUS) & DWMCI_BUSY) {
                if (get_timer(start) > timeout) {
                        debug("%s: Timeout on data busy\n", __func__);
-                       return TIMEOUT;
+                       return -ETIMEDOUT;
                }
        }
 
@@ -269,7 +269,7 @@ static int dwmci_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
 
        if (i == retry) {
                debug("%s: Timeout.\n", __func__);
-               return TIMEOUT;
+               return -ETIMEDOUT;
        }
 
        if (mask & DWMCI_INTMSK_RTO) {
@@ -282,7 +282,7 @@ static int dwmci_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
                 * CMD8, please keep that in mind.
                 */
                debug("%s: Response Timeout.\n", __func__);
-               return TIMEOUT;
+               return -ETIMEDOUT;
        } else if (mask & DWMCI_INTMSK_RE) {
                debug("%s: Response Error.\n", __func__);
                return -EIO;
index 86c9a67a5ec5367fe38ecf02ca97ba0e125d808c..103b32e9cf76e90b5b957c8167575a619f5c60e7 100644 (file)
@@ -12,6 +12,7 @@
 #include <config.h>
 #include <common.h>
 #include <command.h>
+#include <errno.h>
 #include <hwconfig.h>
 #include <mmc.h>
 #include <part.h>
@@ -252,7 +253,7 @@ static int esdhc_setup_data(struct mmc *mmc, struct mmc_data *data)
                        if ((esdhc_read32(&regs->prsstat) &
                            PRSSTAT_WPSPL) == 0) {
                                printf("\nThe SD card is locked. Can not write to a locked card.\n\n");
-                               return TIMEOUT;
+                               return -ETIMEDOUT;
                        }
                }
 
@@ -410,12 +411,12 @@ esdhc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
        irqstat = esdhc_read32(&regs->irqstat);
 
        if (irqstat & CMD_ERR) {
-               err = COMM_ERR;
+               err = -ECOMM;
                goto out;
        }
 
        if (irqstat & IRQSTAT_CTOE) {
-               err = TIMEOUT;
+               err = -ETIMEDOUT;
                goto out;
        }
 
@@ -441,7 +442,7 @@ esdhc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
 
                if (timeout <= 0) {
                        printf("Timeout waiting for DAT0 to go high!\n");
-                       err = TIMEOUT;
+                       err = -ETIMEDOUT;
                        goto out;
                }
        }
@@ -470,12 +471,12 @@ esdhc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
                        irqstat = esdhc_read32(&regs->irqstat);
 
                        if (irqstat & IRQSTAT_DTOE) {
-                               err = TIMEOUT;
+                               err = -ETIMEDOUT;
                                goto out;
                        }
 
                        if (irqstat & DATA_ERR) {
-                               err = COMM_ERR;
+                               err = -ECOMM;
                                goto out;
                        }
                } while ((irqstat & DATA_COMPLETE) != DATA_COMPLETE);
index a620678e5f9e24654bf9a2399fc2d8373145a419..c02740f0efb07d3d4805f0b86b017a6fe375db80 100644 (file)
@@ -34,7 +34,7 @@ static inline int ftsdc010_send_cmd(struct mmc *mmc, struct mmc_cmd *mmc_cmd)
 {
        struct ftsdc010_chip *chip = mmc->priv;
        struct ftsdc010_mmc __iomem *regs = chip->regs;
-       int ret = TIMEOUT;
+       int ret = -ETIMEDOUT;
        uint32_t ts, st;
        uint32_t cmd   = FTSDC010_CMD_IDX(mmc_cmd->cmdidx);
        uint32_t arg   = mmc_cmd->cmdarg;
@@ -126,7 +126,7 @@ static void ftsdc010_clkset(struct mmc *mmc, uint32_t rate)
 
 static int ftsdc010_wait(struct ftsdc010_mmc __iomem *regs, uint32_t mask)
 {
-       int ret = TIMEOUT;
+       int ret = -ETIMEDOUT;
        uint32_t st, ts;
 
        for (ts = get_timer(0); get_timer(ts) < CFG_CMD_TIMEOUT; ) {
@@ -151,7 +151,7 @@ static int ftsdc010_wait(struct ftsdc010_mmc __iomem *regs, uint32_t mask)
 static int ftsdc010_request(struct mmc *mmc, struct mmc_cmd *cmd,
        struct mmc_data *data)
 {
-       int ret = UNUSABLE_ERR;
+       int ret = -EOPNOTSUPP;
        uint32_t len = 0;
        struct ftsdc010_chip *chip = mmc->priv;
        struct ftsdc010_mmc __iomem *regs = chip->regs;
@@ -279,7 +279,7 @@ static int ftsdc010_init(struct mmc *mmc)
        uint32_t ts;
 
        if (readl(&regs->status) & FTSDC010_STATUS_CARD_DETECT)
-               return NO_CARD_ERR;
+               return -ENOMEDIUM;
 
        if (readl(&regs->status) & FTSDC010_STATUS_WRITE_PROT) {
                printf("ftsdc010: write protected\n");
@@ -297,7 +297,7 @@ static int ftsdc010_init(struct mmc *mmc)
        }
        if (readl(&regs->cmd) & FTSDC010_CMD_SDC_RST) {
                printf("ftsdc010: reset failed\n");
-               return UNUSABLE_ERR;
+               return -EOPNOTSUPP;
        }
 
        /* 2. enter low speed mode (400k card detection) */
index 0474a15484348917c8834a554c5b5fe9188330c5..69770df44d811c649a4625471316fa220232067b 100644 (file)
@@ -213,7 +213,7 @@ mci_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
 
        if (!priv->initialized) {
                puts ("MCI not initialized!\n");
-               return COMM_ERR;
+               return -ECOMM;
        }
 
        /* Figure out the transfer arguments */
@@ -238,10 +238,10 @@ mci_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
 
        if ((status & error_flags) & MMCI_BIT(RTOE)) {
                dump_cmd(cmdr, cmd->cmdarg, status, "Command Time Out");
-               return TIMEOUT;
+               return -ETIMEDOUT;
        } else if (status & error_flags) {
                dump_cmd(cmdr, cmd->cmdarg, status, "Command Failed");
-               return COMM_ERR;
+               return -ECOMM;
        }
 
        /* Copy the response to the response buffer */
@@ -303,7 +303,7 @@ mci_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
                        if (status) {
                                dump_cmd(cmdr, cmd->cmdarg, status,
                                        "Data Transfer Failed");
-                               return COMM_ERR;
+                               return -ECOMM;
                        }
                }
 
@@ -315,7 +315,7 @@ mci_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
                        if (status & error_flags) {
                                dump_cmd(cmdr, cmd->cmdarg, status,
                                        "DTIP Wait Failed");
-                               return COMM_ERR;
+                               return -ECOMM;
                        }
                        i++;
                } while ((status & MMCI_BIT(DTIP)) && i < 10000);
index f8e5f7a6089667434d363b12000df19961d5e733..3daa74882265ef356453b0ba086f4bc3c2f519c7 100644 (file)
@@ -152,7 +152,7 @@ int mmc_send_status(struct mmc *mmc, int timeout)
                                printf("Status Error: 0x%08X\n",
                                        cmd.response[0]);
 #endif
-                               return COMM_ERR;
+                               return -ECOMM;
                        }
                } else if (--retries < 0)
                        return err;
@@ -168,7 +168,7 @@ int mmc_send_status(struct mmc *mmc, int timeout)
 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
                printf("Timeout waiting card ready\n");
 #endif
-               return TIMEOUT;
+               return -ETIMEDOUT;
        }
 
        return 0;
@@ -344,7 +344,7 @@ static int sd_send_op_cond(struct mmc *mmc)
                        break;
 
                if (timeout-- <= 0)
-                       return UNUSABLE_ERR;
+                       return -EOPNOTSUPP;
 
                udelay(1000);
        }
@@ -430,7 +430,7 @@ static int mmc_complete_op_cond(struct mmc *mmc)
                        if (mmc->ocr & OCR_BUSY)
                                break;
                        if (get_timer(start) > timeout)
-                               return UNUSABLE_ERR;
+                               return -EOPNOTSUPP;
                        udelay(100);
                }
        }
@@ -1429,7 +1429,7 @@ static int mmc_startup(struct mmc *mmc)
                                   &test_csd[EXT_CSD_SEC_CNT], 4) == 0)
                                break;
                        else
-                               err = SWITCH_ERR;
+                               err = -EBADMSG;
                }
 
                if (err)
@@ -1499,7 +1499,7 @@ static int mmc_send_if_cond(struct mmc *mmc)
                return err;
 
        if ((cmd.response[0] & 0xff) != 0xaa)
-               return UNUSABLE_ERR;
+               return -EOPNOTSUPP;
        else
                mmc->version = SD_VERSION_2;
 
@@ -1526,7 +1526,7 @@ int mmc_start_init(struct mmc *mmc)
 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
                printf("MMC: no card present\n");
 #endif
-               return NO_CARD_ERR;
+               return -ENOMEDIUM;
        }
 
        if (mmc->has_init)
@@ -1565,14 +1565,14 @@ int mmc_start_init(struct mmc *mmc)
        err = sd_send_op_cond(mmc);
 
        /* If the command timed out, we check for an MMC card */
-       if (err == TIMEOUT) {
+       if (err == -ETIMEDOUT) {
                err = mmc_send_op_cond(mmc);
 
                if (err) {
 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
                        printf("Card did not respond to voltage select!\n");
 #endif
-                       return UNUSABLE_ERR;
+                       return -EOPNOTSUPP;
                }
        }
 
index 7547e1aef88c1bdee9937471e8e217a4b87793c7..25101179f65cb0e25632b526b74ad8f08cbbc46a 100644 (file)
@@ -5,6 +5,7 @@
  * Licensed under the GPL-2 or later.
  */
 #include <common.h>
+#include <errno.h>
 #include <malloc.h>
 #include <part.h>
 #include <mmc.h>
@@ -182,13 +183,13 @@ static int mmc_spi_request(struct mmc *mmc, struct mmc_cmd *cmd,
        spi_cs_activate(spi);
        r1 = mmc_spi_sendcmd(mmc, cmd->cmdidx, cmd->cmdarg);
        if (r1 == 0xff) { /* no response */
-               ret = NO_CARD_ERR;
+               ret = -ENOMEDIUM;
                goto done;
        } else if (r1 & R1_SPI_COM_CRC) {
-               ret = COMM_ERR;
+               ret = -ECOMM;
                goto done;
        } else if (r1 & ~R1_SPI_IDLE) { /* other errors */
-               ret = TIMEOUT;
+               ret = -ETIMEDOUT;
                goto done;
        } else if (cmd->resp_type == MMC_RSP_R2) {
                r1 = mmc_spi_readdata(mmc, cmd->response, 1, 16);
@@ -225,9 +226,9 @@ static int mmc_spi_request(struct mmc *mmc, struct mmc_cmd *cmd,
                                data->blocks, data->blocksize,
                                (cmd->cmdidx == MMC_CMD_WRITE_MULTIPLE_BLOCK));
                if (r1 & R1_SPI_COM_CRC)
-                       ret = COMM_ERR;
+                       ret = -ECOMM;
                else if (r1) /* other errors */
-                       ret = TIMEOUT;
+                       ret = -ETIMEDOUT;
        }
 done:
        spi_cs_deactivate(spi);
index 056aef5bef07c54e8ac8759dcaf17869a0ebc7ad..a2792ac4ecb76c4c7757ba4bc45e6b242a5b1619 100644 (file)
@@ -9,6 +9,7 @@
  */
 
 #include <common.h>
+#include <errno.h>
 #include <malloc.h>
 #include <part.h>
 #include <mmc.h>
@@ -172,15 +173,15 @@ static int mvebu_mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
                            (SDIO_ERR_CMD_TIMEOUT | SDIO_ERR_DATA_TIMEOUT)) {
                                debug("%s: command READ timed out\n",
                                      DRIVER_NAME);
-                               return TIMEOUT;
+                               return -ETIMEDOUT;
                        }
                        debug("%s: command READ error\n", DRIVER_NAME);
-                       return COMM_ERR;
+                       return -ECOMM;
                }
 
                if ((get_timer(0) - start) > TIMEOUT_DELAY) {
                        debug("%s: command timed out\n", DRIVER_NAME);
-                       return TIMEOUT;
+                       return -ETIMEDOUT;
                }
        }
 
@@ -232,7 +233,7 @@ static int mvebu_mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
 
        if (mvebu_mmc_read(SDIO_ERR_INTR_STATUS) &
                (SDIO_ERR_CMD_TIMEOUT | SDIO_ERR_DATA_TIMEOUT))
-               return TIMEOUT;
+               return -ETIMEDOUT;
 
        return 0;
 }
index 561b2045986f5858bcc1f90b0398831dfa32f079..8038f904524adbbeb2ec85202818e12ebebbb26a 100644 (file)
@@ -211,11 +211,11 @@ static int mxcmci_finish_data(struct mxcmci_host *host, unsigned int stat)
                } else if (stat & STATUS_CRC_WRITE_ERR) {
                        u32 err_code = (stat >> 9) & 0x3;
                        if (err_code == 2) /* No CRC response */
-                               data_error = TIMEOUT;
+                               data_error = -ETIMEDOUT;
                        else
                                data_error = -EILSEQ;
                } else if (stat & STATUS_TIME_OUT_READ) {
-                       data_error = TIMEOUT;
+                       data_error = -ETIMEDOUT;
                } else {
                        data_error = -EIO;
                }
@@ -238,7 +238,7 @@ static int mxcmci_read_response(struct mxcmci_host *host, unsigned int stat)
 
        if (stat & STATUS_TIME_OUT_RESP) {
                printf("CMD TIMEOUT\n");
-               return TIMEOUT;
+               return -ETIMEDOUT;
        } else if (stat & STATUS_RESP_CRC_ERR && cmd->resp_type & MMC_RSP_CRC) {
                printf("cmd crc error\n");
                return -EILSEQ;
index 9fa87d57173f685984528070bf2fd762caf3bb46..40f3eaaa864a54baf785865004e86ff5c49b7dad 100644 (file)
@@ -84,7 +84,7 @@ static int mxsmmc_send_cmd_pio(struct mxsmmc_priv *priv, struct mmc_data *data)
                }
        }
 
-       return timeout ? 0 : COMM_ERR;
+       return timeout ? 0 : -ECOMM;
 }
 
 static int mxsmmc_send_cmd_dma(struct mxsmmc_priv *priv, struct mmc_data *data)
@@ -120,7 +120,7 @@ static int mxsmmc_send_cmd_dma(struct mxsmmc_priv *priv, struct mmc_data *data)
        mxs_dma_desc_append(dmach, priv->desc);
        if (mxs_dma_go(dmach)) {
                bounce_buffer_stop(&bbstate);
-               return COMM_ERR;
+               return -ECOMM;
        }
 
        bounce_buffer_stop(&bbstate);
@@ -158,13 +158,13 @@ mxsmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
 
        if (!timeout) {
                printf("MMC%d: Bus busy timeout!\n", mmc->block_dev.devnum);
-               return TIMEOUT;
+               return -ETIMEDOUT;
        }
 
        /* See if card is present */
        if (!mxsmmc_cd(priv)) {
                printf("MMC%d: No card detected!\n", mmc->block_dev.devnum);
-               return NO_CARD_ERR;
+               return -ENOMEDIUM;
        }
 
        /* Start building CTRL0 contents */
@@ -203,7 +203,7 @@ mxsmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
                        priv->mmc_is_wp(mmc->block_dev.devnum)) {
                        printf("MMC%d: Can not write a locked card!\n",
                                mmc->block_dev.devnum);
-                       return UNUSABLE_ERR;
+                       return -EOPNOTSUPP;
                }
 
                ctrl0 |= SSP_CTRL0_DATA_XFER;
@@ -244,21 +244,21 @@ mxsmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
        if (!timeout) {
                printf("MMC%d: Command %d busy\n",
                        mmc->block_dev.devnum, cmd->cmdidx);
-               return TIMEOUT;
+               return -ETIMEDOUT;
        }
 
        /* Check command timeout */
        if (reg & SSP_STATUS_RESP_TIMEOUT) {
                printf("MMC%d: Command %d timeout (status 0x%08x)\n",
                        mmc->block_dev.devnum, cmd->cmdidx, reg);
-               return TIMEOUT;
+               return -ETIMEDOUT;
        }
 
        /* Check command errors */
        if (reg & (SSP_STATUS_RESP_CRC_ERR | SSP_STATUS_RESP_ERR)) {
                printf("MMC%d: Command %d error (status 0x%08x)!\n",
                        mmc->block_dev.devnum, cmd->cmdidx, reg);
-               return COMM_ERR;
+               return -ECOMM;
        }
 
        /* Copy response to response buffer */
@@ -298,7 +298,7 @@ mxsmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
                SSP_STATUS_FIFO_OVRFLW | SSP_STATUS_FIFO_UNDRFLW)) {
                printf("MMC%d: Data error with command %d (status 0x%08x)!\n",
                        mmc->block_dev.devnum, cmd->cmdidx, reg);
-               return COMM_ERR;
+               return -ECOMM;
        }
 
        return 0;
index d007b562936bb184e25301e4edceccf65924009b..e80ac3d7220cdc32719257f96f205a7f397d65ea 100644 (file)
@@ -231,7 +231,7 @@ static int omap_hsmmc_init_setup(struct mmc *mmc)
        while ((readl(&mmc_base->sysstatus) & RESETDONE) == 0) {
                if (get_timer(0) - start > MAX_RETRY_MS) {
                        printf("%s: timedout waiting for cc2!\n", __func__);
-                       return TIMEOUT;
+                       return -ETIMEDOUT;
                }
        }
        writel(readl(&mmc_base->sysctl) | SOFTRESETALL, &mmc_base->sysctl);
@@ -240,7 +240,7 @@ static int omap_hsmmc_init_setup(struct mmc *mmc)
                if (get_timer(0) - start > MAX_RETRY_MS) {
                        printf("%s: timedout waiting for softresetall!\n",
                                __func__);
-                       return TIMEOUT;
+                       return -ETIMEDOUT;
                }
        }
        writel(DTW_1_BITMODE | SDBP_PWROFF | SDVS_3V0, &mmc_base->hctl);
@@ -262,7 +262,7 @@ static int omap_hsmmc_init_setup(struct mmc *mmc)
        while ((readl(&mmc_base->sysctl) & ICS_MASK) == ICS_NOTREADY) {
                if (get_timer(0) - start > MAX_RETRY_MS) {
                        printf("%s: timedout waiting for ics!\n", __func__);
-                       return TIMEOUT;
+                       return -ETIMEDOUT;
                }
        }
        writel(readl(&mmc_base->sysctl) | CEN_ENABLE, &mmc_base->sysctl);
@@ -337,7 +337,7 @@ static int omap_hsmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
                if (get_timer(0) - start > MAX_RETRY_MS) {
                        printf("%s: timedout waiting on cmd inhibit to clear\n",
                                        __func__);
-                       return TIMEOUT;
+                       return -ETIMEDOUT;
                }
        }
        writel(0xFFFFFFFF, &mmc_base->stat);
@@ -346,7 +346,7 @@ static int omap_hsmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
                if (get_timer(0) - start > MAX_RETRY_MS) {
                        printf("%s: timedout waiting for STAT (%x) to clear\n",
                                __func__, readl(&mmc_base->stat));
-                       return TIMEOUT;
+                       return -ETIMEDOUT;
                }
        }
        /*
@@ -410,13 +410,13 @@ static int omap_hsmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
                mmc_stat = readl(&mmc_base->stat);
                if (get_timer(0) - start > MAX_RETRY_MS) {
                        printf("%s : timeout: No status update\n", __func__);
-                       return TIMEOUT;
+                       return -ETIMEDOUT;
                }
        } while (!mmc_stat);
 
        if ((mmc_stat & IE_CTO) != 0) {
                mmc_reset_controller_fsm(mmc_base, SYSCTL_SRC);
-               return TIMEOUT;
+               return -ETIMEDOUT;
        } else if ((mmc_stat & ERRI_MASK) != 0)
                return -1;
 
@@ -464,7 +464,7 @@ static int mmc_read_data(struct hsmmc *mmc_base, char *buf, unsigned int size)
                        if (get_timer(0) - start > MAX_RETRY_MS) {
                                printf("%s: timedout waiting for status!\n",
                                                __func__);
-                               return TIMEOUT;
+                               return -ETIMEDOUT;
                        }
                } while (mmc_stat == 0);
 
@@ -519,7 +519,7 @@ static int mmc_write_data(struct hsmmc *mmc_base, const char *buf,
                        if (get_timer(0) - start > MAX_RETRY_MS) {
                                printf("%s: timedout waiting for status!\n",
                                                __func__);
-                               return TIMEOUT;
+                               return -ETIMEDOUT;
                        }
                } while (mmc_stat == 0);
 
index 02d1138a5fd1a92537c2dcbe6ae7d62d9687be98..1b8358a7bc1d87b5fee917710f95ad77d11bab72 100644 (file)
@@ -133,7 +133,7 @@ s3cmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
 
        if (!timeout) {
                puts("S3C SDI: Command timed out!\n");
-               ret = TIMEOUT;
+               ret = -ETIMEDOUT;
                goto error;
        }
 
@@ -196,7 +196,7 @@ s3cmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
 
        if (!timeout) {
                puts("S3C SDI: Command timed out!\n");
-               ret = TIMEOUT;
+               ret = -ETIMEDOUT;
                goto error;
        }
 
index d584b0b5947c89f549081c85e9904e48d03e9232..1d6d2fde0d8489dba3490f4e1714b4b65631cb89 100644 (file)
@@ -170,7 +170,7 @@ static int sdhci_send_command(struct mmc *mmc, struct mmc_cmd *cmd,
                                       cmd_timeout);
                        } else {
                                puts("timeout.\n");
-                               return COMM_ERR;
+                               return -ECOMM;
                        }
                }
                time++;
@@ -260,7 +260,7 @@ static int sdhci_send_command(struct mmc *mmc, struct mmc_cmd *cmd,
                        } else {
                                printf("%s: Timeout for status update!\n",
                                       __func__);
-                               return TIMEOUT;
+                               return -ETIMEDOUT;
                        }
                }
        } while ((stat & mask) != mask);
@@ -289,9 +289,9 @@ static int sdhci_send_command(struct mmc *mmc, struct mmc_cmd *cmd,
        sdhci_reset(host, SDHCI_RESET_CMD);
        sdhci_reset(host, SDHCI_RESET_DATA);
        if (stat & SDHCI_INT_TIMEOUT)
-               return TIMEOUT;
+               return -ETIMEDOUT;
        else
-               return COMM_ERR;
+               return -ECOMM;
 }
 
 static int sdhci_set_clock(struct mmc *mmc, unsigned int clock)
index 001bf185a72a4dde4f7a469df36cb01220c8172a..bc4b3448119a1e6d3b4f0d7f5b5a68bb7f7e7237 100644 (file)
@@ -168,7 +168,7 @@ static int sh_mmcif_error_manage(struct sh_mmcif_host *host)
        if (state2 & STS2_CRC_ERR)
                ret = -EILSEQ;
        else if (state2 & STS2_TIMEOUT_ERR)
-               ret = TIMEOUT;
+               ret = -ETIMEDOUT;
        else
                ret = -EILSEQ;
        return ret;
@@ -483,7 +483,7 @@ static int sh_mmcif_start_cmd(struct sh_mmcif_host *host,
                case MMC_CMD_ALL_SEND_CID:
                case MMC_CMD_SELECT_CARD:
                case MMC_CMD_APP_CMD:
-                       ret = TIMEOUT;
+                       ret = -ETIMEDOUT;
                        break;
                default:
                        printf(DRIVER_NAME": Cmd(d'%d) err\n", cmd->cmdidx);
@@ -520,14 +520,14 @@ static int sh_mmcif_request(struct mmc *mmc, struct mmc_cmd *cmd,
 
        switch (cmd->cmdidx) {
        case MMC_CMD_APP_CMD:
-               return TIMEOUT;
+               return -ETIMEDOUT;
        case MMC_CMD_SEND_EXT_CSD: /* = SD_SEND_IF_COND (8) */
                if (data)
                        /* ext_csd */
                        break;
                else
                        /* send_if_cond cmd (not support) */
-                       return TIMEOUT;
+                       return -ETIMEDOUT;
        default:
                break;
        }
index 30e538cc1617219af6969aa3b240ba32b8cd408b..be6aeb1684f64414a7a9ac05304d3aa6fcd5dd2b 100644 (file)
@@ -232,7 +232,7 @@ static int sh_sdhi_error_manage(struct sh_sdhi_host *host)
        e_state2 = sh_sdhi_readw(host, SDHI_ERR_STS2);
        if (e_state2 & ERR_STS2_SYS_ERROR) {
                if (e_state2 & ERR_STS2_RES_STOP_TIMEOUT)
-                       ret = TIMEOUT;
+                       ret = -ETIMEDOUT;
                else
                        ret = -EILSEQ;
                debug("%s: ERR_STS2 = %04x\n",
@@ -246,7 +246,7 @@ static int sh_sdhi_error_manage(struct sh_sdhi_host *host)
        if (e_state1 & ERR_STS1_CRC_ERROR || e_state1 & ERR_STS1_CMD_ERROR)
                ret = -EILSEQ;
        else
-               ret = TIMEOUT;
+               ret = -ETIMEDOUT;
 
        debug("%s: ERR_STS1 = %04x\n",
              DRIVER_NAME, sh_sdhi_readw(host, SDHI_ERR_STS1));
@@ -566,7 +566,7 @@ static int sh_sdhi_start_cmd(struct sh_sdhi_host *host,
                case MMC_CMD_SELECT_CARD:
                case SD_CMD_SEND_IF_COND:
                case MMC_CMD_APP_CMD:
-                       ret = TIMEOUT;
+                       ret = -ETIMEDOUT;
                        break;
                default:
                        debug(DRIVER_NAME": Cmd(d'%d) err\n", opc);
index 5d8abdc8974cf8bde3924138c983a4b7cfe379bf..6953accce1234fe8c4bba78551e9f9e203473316 100644 (file)
@@ -304,7 +304,7 @@ static int mmc_rint_wait(struct mmc *mmc, unsigned int timeout_msecs,
                    (status & SUNXI_MMC_RINT_INTERRUPT_ERROR_BIT)) {
                        debug("%s timeout %x\n", what,
                              status & SUNXI_MMC_RINT_INTERRUPT_ERROR_BIT);
-                       return TIMEOUT;
+                       return -ETIMEDOUT;
                }
                udelay(1000);
        } while (!(status & done_bit));
@@ -375,7 +375,7 @@ static int sunxi_mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
                if (ret) {
                        error = readl(&mmchost->reg->rint) & \
                                SUNXI_MMC_RINT_INTERRUPT_ERROR_BIT;
-                       error = TIMEOUT;
+                       error = -ETIMEDOUT;
                        goto out;
                }
        }
@@ -402,7 +402,7 @@ static int sunxi_mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
                        status = readl(&mmchost->reg->status);
                        if (!timeout_msecs--) {
                                debug("busy timeout\n");
-                               error = TIMEOUT;
+                               error = -ETIMEDOUT;
                                goto out;
                        }
                        udelay(1000);
index c9d9432e5e87edc2149a264ef3b9df092032e179..023ba3c643d57c4d8b2c43f41e17f7c077375442 100644 (file)
@@ -9,6 +9,7 @@
 
 #include <bouncebuf.h>
 #include <common.h>
+#include <errno.h>
 #include <asm/gpio.h>
 #include <asm/io.h>
 #ifndef CONFIG_TEGRA186
@@ -216,14 +217,14 @@ static int mmc_send_cmd_bounced(struct mmc *mmc, struct mmc_cmd *cmd,
        if (i == retry) {
                printf("%s: waiting for status update\n", __func__);
                writel(mask, &host->reg->norintsts);
-               return TIMEOUT;
+               return -ETIMEDOUT;
        }
 
        if (mask & TEGRA_MMC_NORINTSTS_CMD_TIMEOUT) {
                /* Timeout Error */
                debug("timeout: %08x cmd %d\n", mask, cmd->cmdidx);
                writel(mask, &host->reg->norintsts);
-               return TIMEOUT;
+               return -ETIMEDOUT;
        } else if (mask & TEGRA_MMC_NORINTSTS_ERR_INTERRUPT) {
                /* Error Interrupt */
                debug("error: %08x cmd %d\n", mask, cmd->cmdidx);
@@ -257,7 +258,7 @@ static int mmc_send_cmd_bounced(struct mmc *mmc, struct mmc_cmd *cmd,
                        if (i == retry) {
                                printf("%s: card is still busy\n", __func__);
                                writel(mask, &host->reg->norintsts);
-                               return TIMEOUT;
+                               return -ETIMEDOUT;
                        }
 
                        cmd->response[0] = readl(&host->reg->rspreg0);
index 02df809bcfd5bfbe8db614bcd4d346c13335fd0a..2a4837840a9d95fa93e078a01d4587e073e1c8f0 100644 (file)
@@ -162,7 +162,7 @@ static int uniphier_sd_check_error(struct uniphier_sd_priv *priv)
                 * display error log since this might be a part of sequence to
                 * distinguish between SD and MMC.
                 */
-               return TIMEOUT;
+               return -ETIMEDOUT;
        }
 
        if (info2 & UNIPHIER_SD_INFO2_ERR_TO) {
index dd47f34e9de09c6b516c1baadfbf57f645606925..aa6d5d1d4ff459bdbddbc5a713ece00de3163e95 100644 (file)
 #define MMC_DATA_READ          1
 #define MMC_DATA_WRITE         2
 
-#define NO_CARD_ERR            -16 /* No SD/MMC card inserted */
-#define UNUSABLE_ERR           -17 /* Unusable Card */
-#define COMM_ERR               -18 /* Communications Error */
-#define TIMEOUT                        -19
-#define SWITCH_ERR             -20 /* Card reports failure to switch mode */
-
 #define MMC_CMD_GO_IDLE_STATE          0
 #define MMC_CMD_SEND_OP_COND           1
 #define MMC_CMD_ALL_SEND_CID           2