7 files changed, 545 insertions, 124 deletions

diff --git a/drivers/mmc/mmc.c b/drivers/mmc/mmc.c
index 0a8165974ba7..ceae379a4d4c 100644
--- a/drivers/mmc/mmc.c
+++ b/drivers/mmc/mmc.c
@@ -2,6 +2,8 @@
  *  linux/drivers/mmc/mmc.c
  *
  *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
+ *  SD support Copyright (C) 2004 Ian Molton, All Rights Reserved.
+ *  SD support Copyright (C) 2005 Pierre Ossman, All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -16,6 +18,8 @@
 #include <linux/delay.h>
 #include <linux/pagemap.h>
 #include <linux/err.h>
+#include <asm/scatterlist.h>
+#include <linux/scatterlist.h>
 
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
@@ -172,7 +176,81 @@ int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries
 
 EXPORT_SYMBOL(mmc_wait_for_cmd);
 
+/**
+ *      mmc_wait_for_app_cmd - start an application command and wait for
+                               completion
+ *      @host: MMC host to start command
+ *      @rca: RCA to send MMC_APP_CMD to
+ *      @cmd: MMC command to start
+ *      @retries: maximum number of retries
+ *
+ *      Sends a MMC_APP_CMD, checks the card response, sends the command
+ *      in the parameter and waits for it to complete. Return any error
+ *      that occurred while the command was executing.  Do not attempt to
+ *      parse the response.
+ */
+int mmc_wait_for_app_cmd(struct mmc_host *host, unsigned int rca,
+        struct mmc_command *cmd, int retries)
+{
+        struct mmc_request mrq;
+        struct mmc_command appcmd;
+
+        int i, err;
+
+        BUG_ON(host->card_busy == NULL);
+        BUG_ON(retries < 0);
+
+        err = MMC_ERR_INVALID;
+
+        /*
+         * We have to resend MMC_APP_CMD for each attempt so
+         * we cannot use the retries field in mmc_command.
+         */
+        for (i = 0;i <= retries;i++) {
+                memset(&mrq, 0, sizeof(struct mmc_request));
+
+                appcmd.opcode = MMC_APP_CMD;
+                appcmd.arg = rca << 16;
+                appcmd.flags = MMC_RSP_R1;
+                appcmd.retries = 0;
+                memset(appcmd.resp, 0, sizeof(appcmd.resp));
+                appcmd.data = NULL;
+
+                mrq.cmd = &appcmd;
+                appcmd.data = NULL;
+
+                mmc_wait_for_req(host, &mrq);
+
+                if (appcmd.error) {
+                        err = appcmd.error;
+                        continue;
+                }
+
+                /* Check that card supported application commands */
+                if (!(appcmd.resp[0] & R1_APP_CMD))
+                        return MMC_ERR_FAILED;
+
+                memset(&mrq, 0, sizeof(struct mmc_request));
+
+                memset(cmd->resp, 0, sizeof(cmd->resp));
+                cmd->retries = 0;
+
+                mrq.cmd = cmd;
+                cmd->data = NULL;
 
+                mmc_wait_for_req(host, &mrq);
+
+                err = cmd->error;
+                if (cmd->error == MMC_ERR_NONE)
+                        break;
+        }
+
+        return err;
+}
+
+EXPORT_SYMBOL(mmc_wait_for_app_cmd);
+
+static int mmc_select_card(struct mmc_host *host, struct mmc_card *card);
 
 /**
  *      __mmc_claim_host - exclusively claim a host
@@ -206,16 +284,10 @@ int __mmc_claim_host(struct mmc_host *host, struct mmc_card *card)
         spin_unlock_irqrestore(&host->lock, flags);
         remove_wait_queue(&host->wq, &wait);
 
-        if (card != (void *)-1 && host->card_selected != card) {
-                struct mmc_command cmd;
-
-                host->card_selected = card;
-
-                cmd.opcode = MMC_SELECT_CARD;
-                cmd.arg = card->rca << 16;
-                cmd.flags = MMC_RSP_R1;
-
-                err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES);
+        if (card != (void *)-1) {
+                err = mmc_select_card(host, card);
+                if (err != MMC_ERR_NONE)
+                        return err;
         }
 
         return err;
@@ -245,6 +317,63 @@ void mmc_release_host(struct mmc_host *host)
 
 EXPORT_SYMBOL(mmc_release_host);
 
+static int mmc_select_card(struct mmc_host *host, struct mmc_card *card)
+{
+        int err;
+        struct mmc_command cmd;
+
+        BUG_ON(host->card_busy == NULL);
+
+        if (host->card_selected == card)
+                return MMC_ERR_NONE;
+
+        host->card_selected = card;
+
+        cmd.opcode = MMC_SELECT_CARD;
+        cmd.arg = card->rca << 16;
+        cmd.flags = MMC_RSP_R1;
+
+        err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES);
+        if (err != MMC_ERR_NONE)
+                return err;
+
+        /*
+         * Default bus width is 1 bit.
+         */
+        host->ios.bus_width = MMC_BUS_WIDTH_1;
+
+        /*
+         * We can only change the bus width of the selected
+         * card so therefore we have to put the handling
+         * here.
+         */
+        if (host->caps & MMC_CAP_4_BIT_DATA) {
+                /*
+                 * The card is in 1 bit mode by default so
+                 * we only need to change if it supports the
+                 * wider version.
+                 */
+                if (mmc_card_sd(card) &&
+                        (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
+                        struct mmc_command cmd;
+                        cmd.opcode = SD_APP_SET_BUS_WIDTH;
+                        cmd.arg = SD_BUS_WIDTH_4;
+                        cmd.flags = MMC_RSP_R1;
+
+                        err = mmc_wait_for_app_cmd(host, card->rca, &cmd,
+                                CMD_RETRIES);
+                        if (err != MMC_ERR_NONE)
+                                return err;
+
+                        host->ios.bus_width = MMC_BUS_WIDTH_4;
+                }
+        }
+
+        host->ops->set_ios(host, &host->ios);
+
+        return MMC_ERR_NONE;
+}
+
 /*
  * Ensure that no card is selected.
  */
@@ -322,48 +451,69 @@ static void mmc_decode_cid(struct mmc_card *card)
 
         memset(&card->cid, 0, sizeof(struct mmc_cid));
 
-        /*
-         * The selection of the format here is guesswork based upon
-         * information people have sent to date.
-         */
-        switch (card->csd.mmca_vsn) {
-        case 0: /* MMC v1.? */
-        case 1: /* MMC v1.4 */
-                card->cid.manfid        = UNSTUFF_BITS(resp, 104, 24);
-                card->cid.prod_name[0]  = UNSTUFF_BITS(resp, 96, 8);
-                card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
-                card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
-                card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
-                card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
-                card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
-                card->cid.prod_name[6]  = UNSTUFF_BITS(resp, 48, 8);
-                card->cid.hwrev         = UNSTUFF_BITS(resp, 44, 4);
-                card->cid.fwrev         = UNSTUFF_BITS(resp, 40, 4);
-                card->cid.serial        = UNSTUFF_BITS(resp, 16, 24);
-                card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
-                card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
-                break;
-
-        case 2: /* MMC v2.x ? */
-        case 3: /* MMC v3.x ? */
-                card->cid.manfid        = UNSTUFF_BITS(resp, 120, 8);
-                card->cid.oemid         = UNSTUFF_BITS(resp, 104, 16);
-                card->cid.prod_name[0]  = UNSTUFF_BITS(resp, 96, 8);
-                card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
-                card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
-                card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
-                card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
-                card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
-                card->cid.serial        = UNSTUFF_BITS(resp, 16, 32);
-                card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
-                card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
-                break;
-
-        default:
-                printk("%s: card has unknown MMCA version %d\n",
-                        mmc_hostname(card->host), card->csd.mmca_vsn);
-                mmc_card_set_bad(card);
-                break;
+        if (mmc_card_sd(card)) {
+                /*
+                 * SD doesn't currently have a version field so we will
+                 * have to assume we can parse this.
+                 */
+                card->cid.manfid                = UNSTUFF_BITS(resp, 120, 8);
+                card->cid.oemid                 = UNSTUFF_BITS(resp, 104, 16);
+                card->cid.prod_name[0]          = UNSTUFF_BITS(resp, 96, 8);
+                card->cid.prod_name[1]          = UNSTUFF_BITS(resp, 88, 8);
+                card->cid.prod_name[2]          = UNSTUFF_BITS(resp, 80, 8);
+                card->cid.prod_name[3]          = UNSTUFF_BITS(resp, 72, 8);
+                card->cid.prod_name[4]          = UNSTUFF_BITS(resp, 64, 8);
+                card->cid.hwrev                 = UNSTUFF_BITS(resp, 60, 4);
+                card->cid.fwrev                 = UNSTUFF_BITS(resp, 56, 4);
+                card->cid.serial                = UNSTUFF_BITS(resp, 24, 32);
+                card->cid.year                  = UNSTUFF_BITS(resp, 12, 8);
+                card->cid.month                 = UNSTUFF_BITS(resp, 8, 4);
+
+                card->cid.year += 2000; /* SD cards year offset */
+        } else {
+                /*
+                 * The selection of the format here is based upon published
+                 * specs from sandisk and from what people have reported.
+                 */
+                switch (card->csd.mmca_vsn) {
+                case 0: /* MMC v1.0 - v1.2 */
+                case 1: /* MMC v1.4 */
+                        card->cid.manfid        = UNSTUFF_BITS(resp, 104, 24);
+                        card->cid.prod_name[0]  = UNSTUFF_BITS(resp, 96, 8);
+                        card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
+                        card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
+                        card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
+                        card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
+                        card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
+                        card->cid.prod_name[6]  = UNSTUFF_BITS(resp, 48, 8);
+                        card->cid.hwrev         = UNSTUFF_BITS(resp, 44, 4);
+                        card->cid.fwrev         = UNSTUFF_BITS(resp, 40, 4);
+                        card->cid.serial        = UNSTUFF_BITS(resp, 16, 24);
+                        card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
+                        card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
+                        break;
+
+                case 2: /* MMC v2.0 - v2.2 */
+                case 3: /* MMC v3.1 - v3.3 */
+                        card->cid.manfid        = UNSTUFF_BITS(resp, 120, 8);
+                        card->cid.oemid         = UNSTUFF_BITS(resp, 104, 16);
+                        card->cid.prod_name[0]  = UNSTUFF_BITS(resp, 96, 8);
+                        card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
+                        card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
+                        card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
+                        card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
+                        card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
+                        card->cid.serial        = UNSTUFF_BITS(resp, 16, 32);
+                        card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
+                        card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
+                        break;
+
+                default:
+                        printk("%s: card has unknown MMCA version %d\n",
+                                mmc_hostname(card->host), card->csd.mmca_vsn);
+                        mmc_card_set_bad(card);
+                        break;
+                }
         }
 }
 
@@ -376,34 +526,86 @@ static void mmc_decode_csd(struct mmc_card *card)
         unsigned int e, m, csd_struct;
         u32 *resp = card->raw_csd;
 
-        /*
-         * We only understand CSD structure v1.1 and v2.
-         * v2 has extra information in bits 15, 11 and 10.
-         */
-        csd_struct = UNSTUFF_BITS(resp, 126, 2);
-        if (csd_struct != 1 && csd_struct != 2) {
-                printk("%s: unrecognised CSD structure version %d\n",
-                        mmc_hostname(card->host), csd_struct);
-                mmc_card_set_bad(card);
-                return;
+        if (mmc_card_sd(card)) {
+                csd_struct = UNSTUFF_BITS(resp, 126, 2);
+                if (csd_struct != 0) {
+                        printk("%s: unrecognised CSD structure version %d\n",
+                                mmc_hostname(card->host), csd_struct);
+                        mmc_card_set_bad(card);
+                        return;
+                }
+
+                m = UNSTUFF_BITS(resp, 115, 4);
+                e = UNSTUFF_BITS(resp, 112, 3);
+                csd->tacc_ns     = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
+                csd->tacc_clks   = UNSTUFF_BITS(resp, 104, 8) * 100;
+
+                m = UNSTUFF_BITS(resp, 99, 4);
+                e = UNSTUFF_BITS(resp, 96, 3);
+                csd->max_dtr      = tran_exp[e] * tran_mant[m];
+                csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
+
+                e = UNSTUFF_BITS(resp, 47, 3);
+                m = UNSTUFF_BITS(resp, 62, 12);
+                csd->capacity     = (1 + m) << (e + 2);
+
+                csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
+        } else {
+                /*
+                 * We only understand CSD structure v1.1 and v1.2.
+                 * v1.2 has extra information in bits 15, 11 and 10.
+                 */
+                csd_struct = UNSTUFF_BITS(resp, 126, 2);
+                if (csd_struct != 1 && csd_struct != 2) {
+                        printk("%s: unrecognised CSD structure version %d\n",
+                                mmc_hostname(card->host), csd_struct);
+                        mmc_card_set_bad(card);
+                        return;
+                }
+
+                csd->mmca_vsn    = UNSTUFF_BITS(resp, 122, 4);
+                m = UNSTUFF_BITS(resp, 115, 4);
+                e = UNSTUFF_BITS(resp, 112, 3);
+                csd->tacc_ns     = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
+                csd->tacc_clks   = UNSTUFF_BITS(resp, 104, 8) * 100;
+
+                m = UNSTUFF_BITS(resp, 99, 4);
+                e = UNSTUFF_BITS(resp, 96, 3);
+                csd->max_dtr      = tran_exp[e] * tran_mant[m];
+                csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
+
+                e = UNSTUFF_BITS(resp, 47, 3);
+                m = UNSTUFF_BITS(resp, 62, 12);
+                csd->capacity     = (1 + m) << (e + 2);
+
+                csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
         }
+}
 
-        csd->mmca_vsn    = UNSTUFF_BITS(resp, 122, 4);
-        m = UNSTUFF_BITS(resp, 115, 4);
-        e = UNSTUFF_BITS(resp, 112, 3);
-        csd->tacc_ns     = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
-        csd->tacc_clks   = UNSTUFF_BITS(resp, 104, 8) * 100;
+/*
+ * Given a 64-bit response, decode to our card SCR structure.
+ */
+static void mmc_decode_scr(struct mmc_card *card)
+{
+        struct sd_scr *scr = &card->scr;
+        unsigned int scr_struct;
+        u32 resp[4];
+
+        BUG_ON(!mmc_card_sd(card));
 
-        m = UNSTUFF_BITS(resp, 99, 4);
-        e = UNSTUFF_BITS(resp, 96, 3);
-        csd->max_dtr      = tran_exp[e] * tran_mant[m];
-        csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
+        resp[3] = card->raw_scr[1];
+        resp[2] = card->raw_scr[0];
 
-        e = UNSTUFF_BITS(resp, 47, 3);
-        m = UNSTUFF_BITS(resp, 62, 12);
-        csd->capacity     = (1 + m) << (e + 2);
+        scr_struct = UNSTUFF_BITS(resp, 60, 4);
+        if (scr_struct != 0) {
+                printk("%s: unrecognised SCR structure version %d\n",
+                        mmc_hostname(card->host), scr_struct);
+                mmc_card_set_bad(card);
+                return;
+        }
 
-        csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
+        scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4);
+        scr->bus_widths = UNSTUFF_BITS(resp, 48, 4);
 }
 
 /*
@@ -487,6 +689,7 @@ static void mmc_power_up(struct mmc_host *host)
         host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
         host->ios.chip_select = MMC_CS_DONTCARE;
         host->ios.power_mode = MMC_POWER_UP;
+        host->ios.bus_width = MMC_BUS_WIDTH_1;
         host->ops->set_ios(host, &host->ios);
 
         mmc_delay(1);
@@ -505,6 +708,7 @@ static void mmc_power_off(struct mmc_host *host)
         host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
         host->ios.chip_select = MMC_CS_DONTCARE;
         host->ios.power_mode = MMC_POWER_OFF;
+        host->ios.bus_width = MMC_BUS_WIDTH_1;
         host->ops->set_ios(host, &host->ios);
 }
 
@@ -536,6 +740,34 @@ static int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
         return err;
 }
 
+static int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
+{
+        struct mmc_command cmd;
+        int i, err = 0;
+
+        cmd.opcode = SD_APP_OP_COND;
+        cmd.arg = ocr;
+        cmd.flags = MMC_RSP_R3;
+
+        for (i = 100; i; i--) {
+                err = mmc_wait_for_app_cmd(host, 0, &cmd, CMD_RETRIES);
+                if (err != MMC_ERR_NONE)
+                        break;
+
+                if (cmd.resp[0] & MMC_CARD_BUSY || ocr == 0)
+                        break;
+
+                err = MMC_ERR_TIMEOUT;
+
+                mmc_delay(10);
+        }
+
+        if (rocr)
+                *rocr = cmd.resp[0];
+
+        return err;
+}
+
 /*
  * Discover cards by requesting their CID.  If this command
  * times out, it is not an error; there are no further cards
@@ -579,13 +811,38 @@ static void mmc_discover_cards(struct mmc_host *host)
 
                 card->state &= ~MMC_STATE_DEAD;
 
-                cmd.opcode = MMC_SET_RELATIVE_ADDR;
-                cmd.arg = card->rca << 16;
-                cmd.flags = MMC_RSP_R1;
+                if (host->mode == MMC_MODE_SD) {
+                        mmc_card_set_sd(card);
 
-                err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES);
-                if (err != MMC_ERR_NONE)
-                        mmc_card_set_dead(card);
+                        cmd.opcode = SD_SEND_RELATIVE_ADDR;
+                        cmd.arg = 0;
+                        cmd.flags = MMC_RSP_R1;
+
+                        err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES);
+                        if (err != MMC_ERR_NONE)
+                                mmc_card_set_dead(card);
+                        else {
+                                card->rca = cmd.resp[0] >> 16;
+
+                                if (!host->ops->get_ro) {
+                                        printk(KERN_WARNING "%s: host does not "
+                                                "support reading read-only "
+                                                "switch. assuming write-enable.\n",
+                                                mmc_hostname(host));
+                                } else {
+                                        if (host->ops->get_ro(host))
+                                                mmc_card_set_readonly(card);
+                                }
+                        }
+                } else {
+                        cmd.opcode = MMC_SET_RELATIVE_ADDR;
+                        cmd.arg = card->rca << 16;
+                        cmd.flags = MMC_RSP_R1;
+
+                        err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES);
+                        if (err != MMC_ERR_NONE)
+                                mmc_card_set_dead(card);
+                }
         }
 }
 
@@ -617,6 +874,79 @@ static void mmc_read_csds(struct mmc_host *host)
         }
 }
 
+static void mmc_read_scrs(struct mmc_host *host)
+{
+        int err;
+        struct mmc_card *card;
+
+        struct mmc_request mrq;
+        struct mmc_command cmd;
+        struct mmc_data data;
+
+        struct scatterlist sg;
+
+        list_for_each_entry(card, &host->cards, node) {
+                if (card->state & (MMC_STATE_DEAD|MMC_STATE_PRESENT))
+                        continue;
+                if (!mmc_card_sd(card))
+                        continue;
+
+                err = mmc_select_card(host, card);
+                if (err != MMC_ERR_NONE) {
+                        mmc_card_set_dead(card);
+                        continue;
+                }
+
+                memset(&cmd, 0, sizeof(struct mmc_command));
+
+                cmd.opcode = MMC_APP_CMD;
+                cmd.arg = card->rca << 16;
+                cmd.flags = MMC_RSP_R1;
+
+                err = mmc_wait_for_cmd(host, &cmd, 0);
+                if ((err != MMC_ERR_NONE) || !(cmd.resp[0] & R1_APP_CMD)) {
+                        mmc_card_set_dead(card);
+                        continue;
+                }
+
+                memset(&cmd, 0, sizeof(struct mmc_command));
+
+                cmd.opcode = SD_APP_SEND_SCR;
+                cmd.arg = 0;
+                cmd.flags = MMC_RSP_R1;
+
+                memset(&data, 0, sizeof(struct mmc_data));
+
+                data.timeout_ns = card->csd.tacc_ns * 10;
+                data.timeout_clks = card->csd.tacc_clks * 10;
+                data.blksz_bits = 3;
+                data.blocks = 1;
+                data.flags = MMC_DATA_READ;
+                data.sg = &sg;
+                data.sg_len = 1;
+
+                memset(&mrq, 0, sizeof(struct mmc_request));
+
+                mrq.cmd = &cmd;
+                mrq.data = &data;
+
+                sg_init_one(&sg, (u8*)card->raw_scr, 8);
+
+                err = mmc_wait_for_req(host, &mrq);
+                if (err != MMC_ERR_NONE) {
+                        mmc_card_set_dead(card);
+                        continue;
+                }
+
+                card->raw_scr[0] = ntohl(card->raw_scr[0]);
+                card->raw_scr[1] = ntohl(card->raw_scr[1]);
+
+                mmc_decode_scr(card);
+        }
+
+        mmc_deselect_cards(host);
+}
+
 static unsigned int mmc_calculate_clock(struct mmc_host *host)
 {
         struct mmc_card *card;
@@ -669,12 +999,24 @@ static void mmc_setup(struct mmc_host *host)
                 int err;
                 u32 ocr;
 
+                host->mode = MMC_MODE_SD;
+
                 mmc_power_up(host);
                 mmc_idle_cards(host);
 
-                err = mmc_send_op_cond(host, 0, &ocr);
-                if (err != MMC_ERR_NONE)
-                        return;
+                err = mmc_send_app_op_cond(host, 0, &ocr);
+
+                /*
+                 * If we fail to detect any SD cards then try
+                 * searching for MMC cards.
+                 */
+                if (err != MMC_ERR_NONE) {
+                        host->mode = MMC_MODE_MMC;
+
+                        err = mmc_send_op_cond(host, 0, &ocr);
+                        if (err != MMC_ERR_NONE)
+                                return;
+                }
 
                 host->ocr = mmc_select_voltage(host, ocr);
 
@@ -714,7 +1056,10 @@ static void mmc_setup(struct mmc_host *host)
          * all get the idea that they should be ready for CMD2.
          * (My SanDisk card seems to need this.)
          */
-        mmc_send_op_cond(host, host->ocr, NULL);
+        if (host->mode == MMC_MODE_SD)
+                mmc_send_app_op_cond(host, host->ocr, NULL);
+        else
+                mmc_send_op_cond(host, host->ocr, NULL);
 
         mmc_discover_cards(host);
 
@@ -725,19 +1070,26 @@ static void mmc_setup(struct mmc_host *host)
         host->ops->set_ios(host, &host->ios);
 
         mmc_read_csds(host);
+
+        if (host->mode == MMC_MODE_SD)
+                mmc_read_scrs(host);
 }
 
 
 /**
  *      mmc_detect_change - process change of state on a MMC socket
  *      @host: host which changed state.
+ *      @delay: optional delay to wait before detection (jiffies)
  *
  *      All we know is that card(s) have been inserted or removed
  *      from the socket(s).  We don't know which socket or cards.
  */
-void mmc_detect_change(struct mmc_host *host)
+void mmc_detect_change(struct mmc_host *host, unsigned long delay)
 {
-        schedule_work(&host->detect);
+        if (delay)
+                schedule_delayed_work(&host->detect, delay);
+        else
+                schedule_work(&host->detect);
 }
 
 EXPORT_SYMBOL(mmc_detect_change);
@@ -841,7 +1193,7 @@ int mmc_add_host(struct mmc_host *host)
         ret = mmc_add_host_sysfs(host);
         if (ret == 0) {
                 mmc_power_off(host);
-                mmc_detect_change(host);
+                mmc_detect_change(host, 0);
         }
 
         return ret;
@@ -911,7 +1263,7 @@ EXPORT_SYMBOL(mmc_suspend_host);
  */
 int mmc_resume_host(struct mmc_host *host)
 {
-        mmc_detect_change(host);
+        mmc_detect_change(host, 0);
 
         return 0;
 }
diff --git a/drivers/mmc/mmc_block.c b/drivers/mmc/mmc_block.c
index d4eee99c2bf6..fa83f15fdf16 100644
--- a/drivers/mmc/mmc_block.c
+++ b/drivers/mmc/mmc_block.c
@@ -95,6 +95,10 @@ static int mmc_blk_open(struct inode *inode, struct file *filp)
                 if (md->usage == 2)
                         check_disk_change(inode->i_bdev);
                 ret = 0;
+
+                if ((filp->f_mode & FMODE_WRITE) &&
+                        mmc_card_readonly(md->queue.card))
+                        ret = -EROFS;
         }
 
         return ret;
@@ -403,9 +407,10 @@ static int mmc_blk_probe(struct mmc_card *card)
         if (err)
                 goto out;
 
-        printk(KERN_INFO "%s: %s %s %dKiB\n",
+        printk(KERN_INFO "%s: %s %s %dKiB %s\n",
                 md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
-                (card->csd.capacity << card->csd.read_blkbits) / 1024);
+                (card->csd.capacity << card->csd.read_blkbits) / 1024,
+                mmc_card_readonly(card)?"(ro)":"");
 
         mmc_set_drvdata(card, md);
         add_disk(md->disk);
diff --git a/drivers/mmc/mmc_sysfs.c b/drivers/mmc/mmc_sysfs.c
index ad8949810fc5..3f4a66ca9555 100644
--- a/drivers/mmc/mmc_sysfs.c
+++ b/drivers/mmc/mmc_sysfs.c
@@ -34,6 +34,7 @@ MMC_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
         card->raw_cid[2], card->raw_cid[3]);
 MMC_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
         card->raw_csd[2], card->raw_csd[3]);
+MMC_ATTR(scr, "%08x%08x\n", card->raw_scr[0], card->raw_scr[1]);
 MMC_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
 MMC_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
 MMC_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
@@ -57,6 +58,8 @@ static struct device_attribute mmc_dev_attrs[] = {
         __ATTR_NULL
 };
 
+static struct device_attribute mmc_dev_attr_scr = MMC_ATTR_RO(scr);
+
 
 static void mmc_release_card(struct device *dev)
 {
@@ -207,10 +210,20 @@ void mmc_init_card(struct mmc_card *card, struct mmc_host *host)
  */
 int mmc_register_card(struct mmc_card *card)
 {
+        int ret;
+
         snprintf(card->dev.bus_id, sizeof(card->dev.bus_id),
                  "%s:%04x", mmc_hostname(card->host), card->rca);
 
-        return device_add(&card->dev);
+        ret = device_add(&card->dev);
+        if (ret == 0) {
+                if (mmc_card_sd(card)) {
+                        ret = device_create_file(&card->dev, &mmc_dev_attr_scr);
+                        if (ret)
+                                device_del(&card->dev);
+                }
+        }
+        return ret;
 }
 
 /*
@@ -219,8 +232,12 @@ int mmc_register_card(struct mmc_card *card)
  */
 void mmc_remove_card(struct mmc_card *card)
 {
-        if (mmc_card_present(card))
+        if (mmc_card_present(card)) {
+                if (mmc_card_sd(card))
+                        device_remove_file(&card->dev, &mmc_dev_attr_scr);
+
                 device_del(&card->dev);
+        }
 
         put_device(&card->dev);
 }
diff --git a/drivers/mmc/mmci.c b/drivers/mmc/mmci.c
index 716c4ef4faf6..91c74843dc0d 100644
--- a/drivers/mmc/mmci.c
+++ b/drivers/mmc/mmci.c
@@ -442,7 +442,7 @@ static void mmci_check_status(unsigned long data)
 
         status = host->plat->status(mmc_dev(host->mmc));
         if (status ^ host->oldstat)
-                mmc_detect_change(host->mmc);
+                mmc_detect_change(host->mmc, 0);
 
         host->oldstat = status;
         mod_timer(&host->timer, jiffies + HZ);
diff --git a/drivers/mmc/pxamci.c b/drivers/mmc/pxamci.c
index b78beb1b0159..b53af57074e3 100644
--- a/drivers/mmc/pxamci.c
+++ b/drivers/mmc/pxamci.c
@@ -362,6 +362,16 @@ static void pxamci_request(struct mmc_host *mmc, struct mmc_request *mrq)
         pxamci_start_cmd(host, mrq->cmd, cmdat);
 }
 
+static int pxamci_get_ro(struct mmc_host *mmc)
+{
+        struct pxamci_host *host = mmc_priv(mmc);
+
+        if (host->pdata && host->pdata->get_ro)
+                return host->pdata->get_ro(mmc->dev);
+        /* Host doesn't support read only detection so assume writeable */
+        return 0;
+}
+
 static void pxamci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
         struct pxamci_host *host = mmc_priv(mmc);
@@ -401,6 +411,7 @@ static void pxamci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 
 static struct mmc_host_ops pxamci_ops = {
         .request        = pxamci_request,
+        .get_ro         = pxamci_get_ro,
         .set_ios        = pxamci_set_ios,
 };
 
@@ -412,7 +423,9 @@ static void pxamci_dma_irq(int dma, void *devid, struct pt_regs *regs)
 
 static irqreturn_t pxamci_detect_irq(int irq, void *devid, struct pt_regs *regs)
 {
-        mmc_detect_change(devid);
+        struct pxamci_host *host = mmc_priv(devid);
+
+        mmc_detect_change(devid, host->pdata->detect_delay);
         return IRQ_HANDLED;
 }
 
diff --git a/drivers/mmc/wbsd.c b/drivers/mmc/wbsd.c
index 08ae22aed9e8..e11e55dc8924 100644
--- a/drivers/mmc/wbsd.c
+++ b/drivers/mmc/wbsd.c
@@ -720,11 +720,28 @@ static void wbsd_prepare_data(struct wbsd_host* host, struct mmc_data* data)
          * calculate CRC.
          *
          * Space for CRC must be included in the size.
+         * Two bytes are needed for each data line.
          */
-        blksize = (1 << data->blksz_bits) + 2;
+        if (host->bus_width == MMC_BUS_WIDTH_1)
+        {
+                blksize = (1 << data->blksz_bits) + 2;
+
+                wbsd_write_index(host, WBSD_IDX_PBSMSB, (blksize >> 4) & 0xF0);
+                wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
+        }
+        else if (host->bus_width == MMC_BUS_WIDTH_4)
+        {
+                blksize = (1 << data->blksz_bits) + 2 * 4;
         
-        wbsd_write_index(host, WBSD_IDX_PBSMSB, (blksize >> 4) & 0xF0);
-        wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
+                wbsd_write_index(host, WBSD_IDX_PBSMSB, ((blksize >> 4) & 0xF0)
+                        | WBSD_DATA_WIDTH);
+                wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
+        }
+        else
+        {
+                data->error = MMC_ERR_INVALID;
+                return;
+        }
 
         /*
          * Clear the FIFO. This is needed even for DMA
@@ -960,9 +977,9 @@ static void wbsd_set_ios(struct mmc_host* mmc, struct mmc_ios* ios)
         struct wbsd_host* host = mmc_priv(mmc);
         u8 clk, setup, pwr;
         
-        DBGF("clock %uHz busmode %u powermode %u cs %u Vdd %u\n",
-                ios->clock, ios->bus_mode, ios->power_mode, ios->chip_select,
-                ios->vdd);
+        DBGF("clock %uHz busmode %u powermode %u cs %u Vdd %u width %u\n",
+             ios->clock, ios->bus_mode, ios->power_mode, ios->chip_select,
+             ios->vdd, ios->bus_width);
 
         spin_lock_bh(&host->lock);
 
@@ -1010,6 +1027,7 @@ static void wbsd_set_ios(struct mmc_host* mmc, struct mmc_ios* ios)
         setup = wbsd_read_index(host, WBSD_IDX_SETUP);
         if (ios->chip_select == MMC_CS_HIGH)
         {
+                BUG_ON(ios->bus_width != MMC_BUS_WIDTH_1);
                 setup |= WBSD_DAT3_H;
                 host->flags |= WBSD_FIGNORE_DETECT;
         }
@@ -1025,12 +1043,41 @@ static void wbsd_set_ios(struct mmc_host* mmc, struct mmc_ios* ios)
         }
         wbsd_write_index(host, WBSD_IDX_SETUP, setup);
         
+        /*
+         * Store bus width for later. Will be used when
+         * setting up the data transfer.
+         */
+        host->bus_width = ios->bus_width;
+
+        spin_unlock_bh(&host->lock);
+}
+
+static int wbsd_get_ro(struct mmc_host* mmc)
+{
+        struct wbsd_host* host = mmc_priv(mmc);
+        u8 csr;
+
+        spin_lock_bh(&host->lock);
+
+        csr = inb(host->base + WBSD_CSR);
+        csr |= WBSD_MSLED;
+        outb(csr, host->base + WBSD_CSR);
+
+        mdelay(1);
+
+        csr = inb(host->base + WBSD_CSR);
+        csr &= ~WBSD_MSLED;
+        outb(csr, host->base + WBSD_CSR);
+
         spin_unlock_bh(&host->lock);
+
+        return csr & WBSD_WRPT;
 }
 
 static struct mmc_host_ops wbsd_ops = {
         .request        = wbsd_request,
         .set_ios        = wbsd_set_ios,
+        .get_ro         = wbsd_get_ro,
 };
 
 /*****************************************************************************\
@@ -1065,20 +1112,6 @@ static void wbsd_reset_ignore(unsigned long data)
 }
 
 /*
- * Helper function for card detection
- */
-static void wbsd_detect_card(unsigned long data)
-{
-        struct wbsd_host *host = (struct wbsd_host*)data;
-        
-        BUG_ON(host == NULL);
-        
-        DBG("Executing card detection\n");
-        
-        mmc_detect_change(host->mmc);   
-}
-
-/*
  * Tasklets
  */
 
@@ -1122,14 +1155,16 @@ static void wbsd_tasklet_card(unsigned long param)
                         DBG("Card inserted\n");
                         host->flags |= WBSD_FCARD_PRESENT;
                         
+                        spin_unlock(&host->lock);
+
                         /*
                          * Delay card detection to allow electrical connections
                          * to stabilise.
                          */
-                        mod_timer(&host->detect_timer, jiffies + HZ/2);
+                        mmc_detect_change(host->mmc, msecs_to_jiffies(500));
                 }
-                
-                spin_unlock(&host->lock);
+                else
+                        spin_unlock(&host->lock);
         }
         else if (host->flags & WBSD_FCARD_PRESENT)
         {
@@ -1151,7 +1186,7 @@ static void wbsd_tasklet_card(unsigned long param)
                  */
                 spin_unlock(&host->lock);
 
-                mmc_detect_change(host->mmc);
+                mmc_detect_change(host->mmc, 0);
         }
         else
                 spin_unlock(&host->lock);
@@ -1355,16 +1390,13 @@ static int __devinit wbsd_alloc_mmc(struct device* dev)
         mmc->f_min = 375000;
         mmc->f_max = 24000000;
         mmc->ocr_avail = MMC_VDD_32_33|MMC_VDD_33_34;
+        mmc->caps = MMC_CAP_4_BIT_DATA;
         
         spin_lock_init(&host->lock);
         
         /*
          * Set up timers
          */
-        init_timer(&host->detect_timer);
-        host->detect_timer.data = (unsigned long)host;
-        host->detect_timer.function = wbsd_detect_card;
-
         init_timer(&host->ignore_timer);
         host->ignore_timer.data = (unsigned long)host;
         host->ignore_timer.function = wbsd_reset_ignore;
@@ -1406,7 +1438,6 @@ static void __devexit wbsd_free_mmc(struct device* dev)
         BUG_ON(host == NULL);
         
         del_timer_sync(&host->ignore_timer);
-        del_timer_sync(&host->detect_timer);
         
         mmc_free_host(mmc);
         
diff --git a/drivers/mmc/wbsd.h b/drivers/mmc/wbsd.h
index 8af43549f5d5..9005b5241b3c 100644
--- a/drivers/mmc/wbsd.h
+++ b/drivers/mmc/wbsd.h
@@ -106,6 +106,8 @@
 #define WBSD_CLK_16M            0x02
 #define WBSD_CLK_24M            0x03
 
+#define WBSD_DATA_WIDTH         0x01
+
 #define WBSD_DAT3_H             0x08
 #define WBSD_FIFO_RESET         0x04
 #define WBSD_SOFT_RESET         0x02
@@ -164,6 +166,7 @@ struct wbsd_host
         int                     firsterr;       /* See fifo functions */
         
         u8                      clk;            /* Current clock speed */
+        unsigned char           bus_width;      /* Current bus width */
         
         int                     config;         /* Config port */
         u8                      unlock_code;    /* Code to unlock config */