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>

diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index 93fe2e5dd6162eb12e3e1bc63adee1cfc5483f9d..0da341acf32bb2b94933ef94182fd3559eb9d437 100644 (file)
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -154,7 +154,7 @@ static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
        cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 
        err = mmc_wait_for_cmd(card->host, &cmd, 0);
-       if ((err != MMC_ERR_NONE) || !(cmd.resp[0] & R1_APP_CMD))
+       if (err || !(cmd.resp[0] & R1_APP_CMD))
                return (u32)-1;
 
        memset(&cmd, 0, sizeof(struct mmc_command));
@@ -192,7 +192,7 @@ static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
 
        mmc_wait_for_req(card->host, &mrq);
 
-       if (cmd.error != MMC_ERR_NONE || data.error != MMC_ERR_NONE)
+       if (cmd.error || data.error)
                return (u32)-1;
 
        blocks = ntohl(blocks);

diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index bfd2ae5bd669fe2a61307995832f2fd2bcb0c4c2..63b67296e92d9224da6dfc9b95526cf007e3aace 100644 (file)
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -598,7 +598,7 @@ void mmc_rescan(struct work_struct *work)
                mmc_send_if_cond(host, host->ocr_avail);
 
                err = mmc_send_app_op_cond(host, 0, &ocr);
-               if (err == MMC_ERR_NONE) {
+               if (!err) {
                        if (mmc_attach_sd(host, ocr))
                                mmc_power_off(host);
                } else {
@@ -607,7 +607,7 @@ void mmc_rescan(struct work_struct *work)
                         * searching for MMC cards.
                         */
                        err = mmc_send_op_cond(host, 0, &ocr);
-                       if (err == MMC_ERR_NONE) {
+                       if (!err) {
                                if (mmc_attach_mmc(host, ocr))
                                        mmc_power_off(host);
                        } else {

diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index 21d7f48e1d4e67c33ff7f59a46955bc7e2e70df0..fe483d5af7445b45a2a8aa06a87e4959bfd59d16 100644 (file)
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -164,10 +164,10 @@ static int mmc_read_ext_csd(struct mmc_card *card)
 
        BUG_ON(!card);
 
-       err = MMC_ERR_FAILED;
+       err = -EIO;
 
        if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
-               return MMC_ERR_NONE;
+               return 0;
 
        /*
         * As the ext_csd is so large and mostly unused, we don't store the
@@ -178,11 +178,11 @@ static int mmc_read_ext_csd(struct mmc_card *card)
                printk(KERN_ERR "%s: could not allocate a buffer to "
                        "receive the ext_csd. mmc v4 cards will be "
                        "treated as v3.\n", mmc_hostname(card->host));
-               return MMC_ERR_FAILED;
+               return -ENOMEM;
        }
 
        err = mmc_send_ext_csd(card, ext_csd);
-       if (err != MMC_ERR_NONE) {
+       if (err) {
                /*
                 * High capacity cards should have this "magic" size
                 * stored in their CSD.
@@ -197,7 +197,7 @@ static int mmc_read_ext_csd(struct mmc_card *card)
                                "EXT_CSD, performance might "
                                "suffer.\n",
                                mmc_hostname(card->host));
-                       err = MMC_ERR_NONE;
+                       err = 0;
                }
                goto out;
        }
@@ -258,14 +258,14 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
 
        /* The extra bit indicates that we support high capacity */
        err = mmc_send_op_cond(host, ocr | (1 << 30), NULL);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto err;
 
        /*
         * Fetch CID from card.
         */
        err = mmc_all_send_cid(host, cid);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto err;
 
        if (oldcard) {
@@ -290,7 +290,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         * Set card RCA.
         */
        err = mmc_set_relative_addr(card);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto free_card;
 
        mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
@@ -300,7 +300,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                 * Fetch CSD from card.
                 */
                err = mmc_send_csd(card, card->raw_csd);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        goto free_card;
 
                err = mmc_decode_csd(card);
@@ -315,7 +315,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         * Select card, as all following commands rely on that.
         */
        err = mmc_select_card(card);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto free_card;
 
        if (!oldcard) {
@@ -323,7 +323,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                 * Fetch and process extened CSD.
                 */
                err = mmc_read_ext_csd(card);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        goto free_card;
        }
 
@@ -334,7 +334,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                (host->caps & MMC_CAP_MMC_HIGHSPEED)) {
                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                        EXT_CSD_HS_TIMING, 1);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        goto free_card;
 
                mmc_card_set_highspeed(card);
@@ -363,7 +363,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                (host->caps & MMC_CAP_4_BIT_DATA)) {
                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                        EXT_CSD_BUS_WIDTH, EXT_CSD_BUS_WIDTH_4);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        goto free_card;
 
                mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
@@ -372,14 +372,14 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
        if (!oldcard)
                host->card = card;
 
-       return MMC_ERR_NONE;
+       return 0;
 
 free_card:
        if (!oldcard)
                mmc_remove_card(card);
 err:
 
-       return MMC_ERR_FAILED;
+       return -EIO;
 }
 
 /*
@@ -413,7 +413,7 @@ static void mmc_detect(struct mmc_host *host)
 
        mmc_release_host(host);
 
-       if (err != MMC_ERR_NONE) {
+       if (err) {
                mmc_remove(host);
 
                mmc_claim_host(host);
@@ -502,7 +502,7 @@ static void mmc_resume(struct mmc_host *host)
        err = mmc_init_card(host, host->ocr, host->card);
        mmc_release_host(host);
 
-       if (err != MMC_ERR_NONE) {
+       if (err) {
                mmc_remove(host);
 
                mmc_claim_host(host);
@@ -565,7 +565,7 @@ int mmc_attach_mmc(struct mmc_host *host, u32 ocr)
         * Detect and init the card.
         */
        err = mmc_init_card(host, host->ocr, NULL);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto err;
 
        mmc_release_host(host);

diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c
index 913e75f008434179e45780ffb7e57ba7c6ff3d9e..15cd575effaaea177e9151b9b5ea9e85f48b2d47 100644 (file)
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -40,10 +40,10 @@ static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card)
        }
 
        err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 int mmc_select_card(struct mmc_card *card)
@@ -99,13 +99,13 @@ int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 
        for (i = 100; i; i--) {
                err = mmc_wait_for_cmd(host, &cmd, 0);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        break;
 
                if (cmd.resp[0] & MMC_CARD_BUSY || ocr == 0)
                        break;
 
-               err = MMC_ERR_TIMEOUT;
+               err = -ETIMEDOUT;
 
                mmc_delay(10);
        }
@@ -131,12 +131,12 @@ int mmc_all_send_cid(struct mmc_host *host, u32 *cid)
        cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
 
        err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
        memcpy(cid, cmd.resp, sizeof(u32) * 4);
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 int mmc_set_relative_addr(struct mmc_card *card)
@@ -154,10 +154,10 @@ int mmc_set_relative_addr(struct mmc_card *card)
        cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 
        err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 int mmc_send_csd(struct mmc_card *card, u32 *csd)
@@ -176,12 +176,12 @@ int mmc_send_csd(struct mmc_card *card, u32 *csd)
        cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;
 
        err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
        memcpy(csd, cmd.resp, sizeof(u32) * 4);
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd)
@@ -218,12 +218,12 @@ int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd)
 
        mmc_wait_for_req(card->host, &mrq);
 
-       if (cmd.error != MMC_ERR_NONE)
+       if (cmd.error)
                return cmd.error;
-       if (data.error != MMC_ERR_NONE)
+       if (data.error)
                return data.error;
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value)
@@ -244,10 +244,10 @@ int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value)
        cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
 
        err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 int mmc_send_status(struct mmc_card *card, u32 *status)
@@ -265,12 +265,12 @@ int mmc_send_status(struct mmc_card *card, u32 *status)
        cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 
        err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
        if (status)
                *status = cmd.resp[0];
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 

diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
index 1edc62b1e5c65d4625daf17ee0d0429c34a95d1c..00895c99d9bb95d04e16f9013fe9de3611ba2303 100644 (file)
--- a/drivers/mmc/core/sd.c
+++ b/drivers/mmc/core/sd.c
@@ -193,30 +193,30 @@ static int mmc_read_switch(struct mmc_card *card)
        u8 *status;
 
        if (card->scr.sda_vsn < SCR_SPEC_VER_1)
-               return MMC_ERR_NONE;
+               return 0;
 
        if (!(card->csd.cmdclass & CCC_SWITCH)) {
                printk(KERN_WARNING "%s: card lacks mandatory switch "
                        "function, performance might suffer.\n",
                        mmc_hostname(card->host));
-               return MMC_ERR_NONE;
+               return 0;
        }
 
-       err = MMC_ERR_FAILED;
+       err = -EIO;
 
        status = kmalloc(64, GFP_KERNEL);
        if (!status) {
                printk(KERN_ERR "%s: could not allocate a buffer for "
                        "switch capabilities.\n", mmc_hostname(card->host));
-               return err;
+               return -ENOMEM;
        }
 
        err = mmc_sd_switch(card, 0, 0, 1, status);
-       if (err != MMC_ERR_NONE) {
+       if (err) {
                printk(KERN_WARNING "%s: problem reading switch "
                        "capabilities, performance might suffer.\n",
                        mmc_hostname(card->host));
-               err = MMC_ERR_NONE;
+               err = 0;
                goto out;
        }
 
@@ -238,28 +238,28 @@ static int mmc_switch_hs(struct mmc_card *card)
        u8 *status;
 
        if (card->scr.sda_vsn < SCR_SPEC_VER_1)
-               return MMC_ERR_NONE;
+               return 0;
 
        if (!(card->csd.cmdclass & CCC_SWITCH))
-               return MMC_ERR_NONE;
+               return 0;
 
        if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
-               return MMC_ERR_NONE;
+               return 0;
 
        if (card->sw_caps.hs_max_dtr == 0)
-               return MMC_ERR_NONE;
+               return 0;
 
-       err = MMC_ERR_FAILED;
+       err = -EIO;
 
        status = kmalloc(64, GFP_KERNEL);
        if (!status) {
                printk(KERN_ERR "%s: could not allocate a buffer for "
                        "switch capabilities.\n", mmc_hostname(card->host));
-               return err;
+               return -ENOMEM;
        }
 
        err = mmc_sd_switch(card, 1, 0, 1, status);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto out;
 
        if ((status[16] & 0xF) != 1) {
@@ -309,18 +309,18 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
         * block-addressed SDHC cards.
         */
        err = mmc_send_if_cond(host, ocr);
-       if (err == MMC_ERR_NONE)
+       if (!err)
                ocr |= 1 << 30;
 
        err = mmc_send_app_op_cond(host, ocr, NULL);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto err;
 
        /*
         * Fetch CID from card.
         */
        err = mmc_all_send_cid(host, cid);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto err;
 
        if (oldcard) {
@@ -344,7 +344,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
         * Set card RCA.
         */
        err = mmc_send_relative_addr(host, &card->rca);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto free_card;
 
        mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
@@ -354,7 +354,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
                 * Fetch CSD from card.
                 */
                err = mmc_send_csd(card, card->raw_csd);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        goto free_card;
 
                err = mmc_decode_csd(card);
@@ -368,7 +368,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
         * Select card, as all following commands rely on that.
         */
        err = mmc_select_card(card);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto free_card;
 
        if (!oldcard) {
@@ -376,7 +376,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
                 * Fetch SCR from card.
                 */
                err = mmc_app_send_scr(card, card->raw_scr);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        goto free_card;
 
                err = mmc_decode_scr(card);
@@ -387,7 +387,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
                 * Fetch switch information from card.
                 */
                err = mmc_read_switch(card);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        goto free_card;
        }
 
@@ -395,7 +395,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
         * Attempt to change to high-speed (if supported)
         */
        err = mmc_switch_hs(card);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto free_card;
 
        /*
@@ -418,7 +418,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
        if ((host->caps & MMC_CAP_4_BIT_DATA) &&
                (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
                err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        goto free_card;
 
                mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
@@ -442,14 +442,14 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
        if (!oldcard)
                host->card = card;
 
-       return MMC_ERR_NONE;
+       return 0;
 
 free_card:
        if (!oldcard)
                mmc_remove_card(card);
 err:
 
-       return MMC_ERR_FAILED;
+       return -EIO;
 }
 
 /*
@@ -483,7 +483,7 @@ static void mmc_sd_detect(struct mmc_host *host)
 
        mmc_release_host(host);
 
-       if (err != MMC_ERR_NONE) {
+       if (err) {
                mmc_sd_remove(host);
 
                mmc_claim_host(host);
@@ -574,7 +574,7 @@ static void mmc_sd_resume(struct mmc_host *host)
        err = mmc_sd_init_card(host, host->ocr, host->card);
        mmc_release_host(host);
 
-       if (err != MMC_ERR_NONE) {
+       if (err) {
                mmc_sd_remove(host);
 
                mmc_claim_host(host);
@@ -644,7 +644,7 @@ int mmc_attach_sd(struct mmc_host *host, u32 ocr)
         * Detect and init the card.
         */
        err = mmc_sd_init_card(host, host->ocr, NULL);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto err;
 
        mmc_release_host(host);

diff --git a/drivers/mmc/core/sd_ops.c b/drivers/mmc/core/sd_ops.c
index 342f340ebc2579d8c81dd231f526b140f87552d5..b4d43bd0feddf474a00cb8b6a017ab0ac9ca72f3 100644 (file)
--- a/drivers/mmc/core/sd_ops.c
+++ b/drivers/mmc/core/sd_ops.c
@@ -40,14 +40,14 @@ static int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)
        }
 
        err = mmc_wait_for_cmd(host, &cmd, 0);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
        /* Check that card supported application commands */
        if (!(cmd.resp[0] & R1_APP_CMD))
-               return MMC_ERR_FAILED;
+               return -EOPNOTSUPP;
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 /**
@@ -73,7 +73,7 @@ int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card,
        BUG_ON(!cmd);
        BUG_ON(retries < 0);
 
-       err = MMC_ERR_INVALID;
+       err = -EIO;
 
        /*
         * We have to resend MMC_APP_CMD for each attempt so
@@ -83,7 +83,7 @@ int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card,
                memset(&mrq, 0, sizeof(struct mmc_request));
 
                err = mmc_app_cmd(host, card);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        continue;
 
                memset(&mrq, 0, sizeof(struct mmc_request));
@@ -97,7 +97,7 @@ int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card,
                mmc_wait_for_req(host, &mrq);
 
                err = cmd->error;
-               if (cmd->error == MMC_ERR_NONE)
+               if (!cmd->error)
                        break;
        }
 
@@ -127,14 +127,14 @@ int mmc_app_set_bus_width(struct mmc_card *card, int width)
                cmd.arg = SD_BUS_WIDTH_4;
                break;
        default:
-               return MMC_ERR_INVALID;
+               return -EINVAL;
        }
 
        err = mmc_wait_for_app_cmd(card->host, card, &cmd, MMC_CMD_RETRIES);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
@@ -152,13 +152,13 @@ int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 
        for (i = 100; i; i--) {
                err = mmc_wait_for_app_cmd(host, NULL, &cmd, MMC_CMD_RETRIES);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        break;
 
                if (cmd.resp[0] & MMC_CARD_BUSY || ocr == 0)
                        break;
 
-               err = MMC_ERR_TIMEOUT;
+               err = -ETIMEDOUT;
 
                mmc_delay(10);
        }
@@ -185,13 +185,13 @@ int mmc_send_if_cond(struct mmc_host *host, u32 ocr)
        cmd.flags = MMC_RSP_R7 | MMC_CMD_BCR;
 
        err = mmc_wait_for_cmd(host, &cmd, 0);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
        if ((cmd.resp[0] & 0xFF) != test_pattern)
-               return MMC_ERR_FAILED;
+               return -EIO;
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)
@@ -209,12 +209,12 @@ int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)
        cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;
 
        err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
        *rca = cmd.resp[0] >> 16;
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
@@ -230,7 +230,7 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
        BUG_ON(!scr);
 
        err = mmc_app_cmd(card->host, card);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
        memset(&mrq, 0, sizeof(struct mmc_request));
@@ -256,15 +256,15 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
 
        mmc_wait_for_req(card->host, &mrq);
 
-       if (cmd.error != MMC_ERR_NONE)
+       if (cmd.error)
                return cmd.error;
-       if (data.error != MMC_ERR_NONE)
+       if (data.error)
                return data.error;
 
        scr[0] = ntohl(scr[0]);
        scr[1] = ntohl(scr[1]);
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 int mmc_sd_switch(struct mmc_card *card, int mode, int group,
@@ -306,11 +306,11 @@ int mmc_sd_switch(struct mmc_card *card, int mode, int group,
 
        mmc_wait_for_req(card->host, &mrq);
 
-       if (cmd.error != MMC_ERR_NONE)
+       if (cmd.error)
                return cmd.error;
-       if (data.error != MMC_ERR_NONE)
+       if (data.error)
                return data.error;
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 

diff --git a/drivers/mmc/host/at91_mci.c b/drivers/mmc/host/at91_mci.c
index 955ea60583b5f5c77438c0ea166d6be060f37dcd..810a433ce53234fc35a32c068b0496e122af7951 100644 (file)
--- 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 34c99d4ea0415885e3bff95df2f6cc60a8aa564f..49b0367e57c804008c3f70b07b02952f273d3958 100644 (file)
--- 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 54bfc9f255966329b6e01c290650f297e7859154..04458c34281240f7a6cb6775525a0588917a181f 100644 (file)
--- 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 be730c0a0352a6f942fb001ad8866b42ab84d666..d53e9a8bdaa23050f884004260bc59a0ed72215d 100644 (file)
--- 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 0cf97edc5f58f978437f49da8cb1323c3599bc41..60a67dfcda6a86a0d786c33799124981f19f49db 100644 (file)
--- 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 ff960334b337d814e72bd1fc5446d80aa4294ea0..b89e32d1e9b5cd9a5baf037660315db2bb8b747f 100644 (file)
--- 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 20a7d89e01bac08032fa874ecc081fc7a44a322d..479d6a265dd196e31c7d1cee0021f04686615805 100644 (file)
--- 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 8b736e9684477236604e54932f1cf788a90db858..b4a56e5e513269428e794447038dfb099364eab9 100644 (file)
--- 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 9bf2a877113bf0a55cf8bc21904158990c24ca39..44968c2279e128311689c3f5d5744fbf52a65de5 100644 (file)
--- 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);
 

diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
index 63a80ea611248fe2551243548fe3ebdd883851de..a2b79518f051cb796a486e332509fefb747d3521 100644 (file)
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -54,12 +54,19 @@ struct mmc_command {
        unsigned int            retries;        /* max number of retries */
        unsigned int            error;          /* command error */
 
-#define MMC_ERR_NONE   0
-#define MMC_ERR_TIMEOUT        1
-#define MMC_ERR_BADCRC 2
-#define MMC_ERR_FIFO   3
-#define MMC_ERR_FAILED 4
-#define MMC_ERR_INVALID        5
+/*
+ * Standard errno values are used for errors, but some have specific
+ * meaning in the MMC layer:
+ *
+ * ETIMEDOUT    Card took too long to respond
+ * EILSEQ       Basic format problem with the received or sent data
+ *              (e.g. CRC check failed, incorrect opcode in response
+ *              or bad end bit)
+ * EINVAL       Request cannot be performed because of restrictions
+ *              in hardware and/or the driver
+ * ENOMEDIUM    Host can determine that the slot is empty and is
+ *              actively failing requests
+ */
 
        struct mmc_data         *data;          /* data segment associated with cmd */
        struct mmc_request      *mrq;           /* associated request */