1 files changed, 47 insertions, 83 deletions

diff --git a/drivers/mmc/mmc_block.c b/drivers/mmc/mmc_block.c
index 587458b370b..db0e8ad439a 100644
--- a/drivers/mmc/mmc_block.c
+++ b/drivers/mmc/mmc_block.c
@@ -27,11 +27,12 @@
 #include <linux/hdreg.h>
 #include <linux/kdev_t.h>
 #include <linux/blkdev.h>
-#include <linux/devfs_fs_kernel.h>
 #include <linux/mutex.h>
 
 #include <linux/mmc/card.h>
+#include <linux/mmc/host.h>
 #include <linux/mmc/protocol.h>
+#include <linux/mmc/host.h>
 
 #include <asm/system.h>
 #include <asm/uaccess.h>
@@ -165,6 +166,7 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
         do {
                 struct mmc_blk_request brq;
                 struct mmc_command cmd;
+                u32 readcmd, writecmd;
 
                 memset(&brq, 0, sizeof(struct mmc_blk_request));
                 brq.mrq.cmd = &brq.cmd;
@@ -172,35 +174,39 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
 
                 brq.cmd.arg = req->sector << 9;
                 brq.cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
-                brq.data.timeout_ns = card->csd.tacc_ns * 10;
-                brq.data.timeout_clks = card->csd.tacc_clks * 10;
-                brq.data.blksz_bits = md->block_bits;
                 brq.data.blksz = 1 << md->block_bits;
                 brq.data.blocks = req->nr_sectors >> (md->block_bits - 9);
                 brq.stop.opcode = MMC_STOP_TRANSMISSION;
                 brq.stop.arg = 0;
                 brq.stop.flags = MMC_RSP_R1B | MMC_CMD_AC;
 
-                if (rq_data_dir(req) == READ) {
-                        brq.cmd.opcode = brq.data.blocks > 1 ? MMC_READ_MULTIPLE_BLOCK : MMC_READ_SINGLE_BLOCK;
-                        brq.data.flags |= MMC_DATA_READ;
-                } else {
-                        brq.cmd.opcode = MMC_WRITE_BLOCK;
-                        brq.data.flags |= MMC_DATA_WRITE;
-                        brq.data.blocks = 1;
+                mmc_set_data_timeout(&brq.data, card, rq_data_dir(req) != READ);
 
-                        /*
-                         * Scale up the timeout by the r2w factor
-                         */
-                        brq.data.timeout_ns <<= card->csd.r2w_factor;
-                        brq.data.timeout_clks <<= card->csd.r2w_factor;
-                }
+                /*
+                 * If the host doesn't support multiple block writes, force
+                 * block writes to single block.
+                 */
+                if (rq_data_dir(req) != READ &&
+                    !(card->host->caps & MMC_CAP_MULTIWRITE))
+                        brq.data.blocks = 1;
 
                 if (brq.data.blocks > 1) {
                         brq.data.flags |= MMC_DATA_MULTI;
                         brq.mrq.stop = &brq.stop;
+                        readcmd = MMC_READ_MULTIPLE_BLOCK;
+                        writecmd = MMC_WRITE_MULTIPLE_BLOCK;
                 } else {
                         brq.mrq.stop = NULL;
+                        readcmd = MMC_READ_SINGLE_BLOCK;
+                        writecmd = MMC_WRITE_BLOCK;
+                }
+
+                if (rq_data_dir(req) == READ) {
+                        brq.cmd.opcode = readcmd;
+                        brq.data.flags |= MMC_DATA_READ;
+                } else {
+                        brq.cmd.opcode = writecmd;
+                        brq.data.flags |= MMC_DATA_WRITE;
                 }
 
                 brq.data.sg = mq->sg;
@@ -225,27 +231,29 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
                         goto cmd_err;
                 }
 
-                do {
-                        int err;
-
-                        cmd.opcode = MMC_SEND_STATUS;
-                        cmd.arg = card->rca << 16;
-                        cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
-                        err = mmc_wait_for_cmd(card->host, &cmd, 5);
-                        if (err) {
-                                printk(KERN_ERR "%s: error %d requesting status\n",
-                                       req->rq_disk->disk_name, err);
-                                goto cmd_err;
-                        }
-                } while (!(cmd.resp[0] & R1_READY_FOR_DATA));
+                if (rq_data_dir(req) != READ) {
+                        do {
+                                int err;
+
+                                cmd.opcode = MMC_SEND_STATUS;
+                                cmd.arg = card->rca << 16;
+                                cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
+                                err = mmc_wait_for_cmd(card->host, &cmd, 5);
+                                if (err) {
+                                        printk(KERN_ERR "%s: error %d requesting status\n",
+                                               req->rq_disk->disk_name, err);
+                                        goto cmd_err;
+                                }
+                        } while (!(cmd.resp[0] & R1_READY_FOR_DATA));
 
 #if 0
-                if (cmd.resp[0] & ~0x00000900)
-                        printk(KERN_ERR "%s: status = %08x\n",
-                               req->rq_disk->disk_name, cmd.resp[0]);
-                if (mmc_decode_status(cmd.resp))
-                        goto cmd_err;
+                        if (cmd.resp[0] & ~0x00000900)
+                                printk(KERN_ERR "%s: status = %08x\n",
+                                       req->rq_disk->disk_name, cmd.resp[0]);
+                        if (mmc_decode_status(cmd.resp))
+                                goto cmd_err;
 #endif
+                }
 
                 /*
                  * A block was successfully transferred.
@@ -325,52 +333,11 @@ static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
         md->read_only = mmc_blk_readonly(card);
 
         /*
-         * Figure out a workable block size.  MMC cards have:
-         *  - two block sizes, one for read and one for write.
-         *  - may support partial reads and/or writes
-         *    (allows block sizes smaller than specified)
-         */
-        md->block_bits = card->csd.read_blkbits;
-        if (card->csd.write_blkbits != card->csd.read_blkbits) {
-                if (card->csd.write_blkbits < card->csd.read_blkbits &&
-                    card->csd.read_partial) {
-                        /*
-                         * write block size is smaller than read block
-                         * size, but we support partial reads, so choose
-                         * the smaller write block size.
-                         */
-                        md->block_bits = card->csd.write_blkbits;
-                } else if (card->csd.write_blkbits > card->csd.read_blkbits &&
-                           card->csd.write_partial) {
-                        /*
-                         * read block size is smaller than write block
-                         * size, but we support partial writes.  Use read
-                         * block size.
-                         */
-                } else {
-                        /*
-                         * We don't support this configuration for writes.
-                         */
-                        printk(KERN_ERR "%s: unable to select block size for "
-                                "writing (rb%u wb%u rp%u wp%u)\n",
-                                mmc_card_id(card),
-                                1 << card->csd.read_blkbits,
-                                1 << card->csd.write_blkbits,
-                                card->csd.read_partial,
-                                card->csd.write_partial);
-                        md->read_only = 1;
-                }
-        }
-
-        /*
-         * Refuse to allow block sizes smaller than 512 bytes.
+         * Both SD and MMC specifications state (although a bit
+         * unclearly in the MMC case) that a block size of 512
+         * bytes must always be supported by the card.
          */
-        if (md->block_bits < 9) {
-                printk(KERN_ERR "%s: unable to support block size %u\n",
-                        mmc_card_id(card), 1 << md->block_bits);
-                ret = -EINVAL;
-                goto err_kfree;
-        }
+        md->block_bits = 9;
 
         md->disk = alloc_disk(1 << MMC_SHIFT);
         if (md->disk == NULL) {
@@ -409,7 +376,6 @@ static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
          */
 
         sprintf(md->disk->disk_name, "mmcblk%d", devidx);
-        sprintf(md->disk->devfs_name, "mmc/blk%d", devidx);
 
         blk_queue_hardsect_size(md->queue.queue, 1 << md->block_bits);
 
@@ -555,7 +521,6 @@ static int __init mmc_blk_init(void)
         if (major == 0)
                 major = res;
 
-        devfs_mk_dir("mmc");
         return mmc_register_driver(&mmc_driver);
 
  out:
@@ -565,7 +530,6 @@ static int __init mmc_blk_init(void)
 static void __exit mmc_blk_exit(void)
 {
         mmc_unregister_driver(&mmc_driver);
-        devfs_remove("mmc");
         unregister_blkdev(major, "mmc");
 }