13 files changed, 55 insertions, 22 deletions

diff --git a/drivers/mmc/at91_mci.c b/drivers/mmc/at91_mci.c
index e28850dec9ed..2ce50f38e3c7 100644
--- a/drivers/mmc/at91_mci.c
+++ b/drivers/mmc/at91_mci.c
@@ -824,6 +824,7 @@ static int __init at91_mci_probe(struct platform_device *pdev)
         mmc->caps = MMC_CAP_BYTEBLOCK;
 
         mmc->max_blk_size = 4095;
+        mmc->max_blk_count = mmc->max_req_size;
 
         host = mmc_priv(mmc);
         host->mmc = mmc;
diff --git a/drivers/mmc/au1xmmc.c b/drivers/mmc/au1xmmc.c
index 74e6ac0c7f71..b834be261ab7 100644
--- a/drivers/mmc/au1xmmc.c
+++ b/drivers/mmc/au1xmmc.c
@@ -923,6 +923,7 @@ static int __devinit au1xmmc_probe(struct platform_device *pdev)
                 mmc->max_phys_segs = AU1XMMC_DESCRIPTOR_COUNT;
 
                 mmc->max_blk_size = 2048;
+                mmc->max_blk_count = 512;
 
                 mmc->ocr_avail = AU1XMMC_OCR;
 
diff --git a/drivers/mmc/imxmmc.c b/drivers/mmc/imxmmc.c
index 2107f8a8605e..b060d4bfba29 100644
--- a/drivers/mmc/imxmmc.c
+++ b/drivers/mmc/imxmmc.c
@@ -958,9 +958,10 @@ static int imxmci_probe(struct platform_device *pdev)
         /* MMC core transfer sizes tunable parameters */
         mmc->max_hw_segs = 64;
         mmc->max_phys_segs = 64;
-        mmc->max_sectors = 64;          /* default 1 << (PAGE_CACHE_SHIFT - 9) */
         mmc->max_seg_size = 64*512;     /* default PAGE_CACHE_SIZE */
+        mmc->max_req_size = 64*512;     /* default PAGE_CACHE_SIZE */
         mmc->max_blk_size = 2048;
+        mmc->max_blk_count = 65535;
 
         host = mmc_priv(mmc);
         host->mmc = mmc;
diff --git a/drivers/mmc/mmc.c b/drivers/mmc/mmc.c
index 9bda3fddad17..fb04bdd26c36 100644
--- a/drivers/mmc/mmc.c
+++ b/drivers/mmc/mmc.c
@@ -109,6 +109,9 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
         mrq->cmd->mrq = mrq;
         if (mrq->data) {
                 BUG_ON(mrq->data->blksz > host->max_blk_size);
+                BUG_ON(mrq->data->blocks > host->max_blk_count);
+                BUG_ON(mrq->data->blocks * mrq->data->blksz >
+                        host->max_req_size);
 
                 mrq->cmd->data = mrq->data;
                 mrq->data->error = 0;
@@ -1605,10 +1608,11 @@ struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
                  */
                 host->max_hw_segs = 1;
                 host->max_phys_segs = 1;
-                host->max_sectors = 1 << (PAGE_CACHE_SHIFT - 9);
                 host->max_seg_size = PAGE_CACHE_SIZE;
 
+                host->max_req_size = PAGE_CACHE_SIZE;
                 host->max_blk_size = 512;
+                host->max_blk_count = PAGE_CACHE_SIZE / 512;
         }
 
         return host;
diff --git a/drivers/mmc/mmc_block.c b/drivers/mmc/mmc_block.c
index 5a4eacac0bbe..19ccfed8a54f 100644
--- a/drivers/mmc/mmc_block.c
+++ b/drivers/mmc/mmc_block.c
@@ -242,10 +242,12 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
                         brq.cmd.arg <<= 9;
                 brq.cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
                 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;
+                brq.data.blocks = req->nr_sectors >> (md->block_bits - 9);
+                if (brq.data.blocks > card->host->max_blk_count)
+                        brq.data.blocks = card->host->max_blk_count;
 
                 mmc_set_data_timeout(&brq.data, card, rq_data_dir(req) != READ);
 
diff --git a/drivers/mmc/mmc_queue.c b/drivers/mmc/mmc_queue.c
index 3e35a43819fb..c27e42645cdb 100644
--- a/drivers/mmc/mmc_queue.c
+++ b/drivers/mmc/mmc_queue.c
@@ -147,7 +147,7 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock
 
         blk_queue_prep_rq(mq->queue, mmc_prep_request);
         blk_queue_bounce_limit(mq->queue, limit);
-        blk_queue_max_sectors(mq->queue, host->max_sectors);
+        blk_queue_max_sectors(mq->queue, host->max_req_size / 512);
         blk_queue_max_phys_segments(mq->queue, host->max_phys_segs);
         blk_queue_max_hw_segments(mq->queue, host->max_hw_segs);
         blk_queue_max_segment_size(mq->queue, host->max_seg_size);
diff --git a/drivers/mmc/mmci.c b/drivers/mmc/mmci.c
index 5d48e0081894..5941dd951e82 100644
--- a/drivers/mmc/mmci.c
+++ b/drivers/mmc/mmci.c
@@ -524,21 +524,25 @@ static int mmci_probe(struct amba_device *dev, void *id)
         /*
          * Since we only have a 16-bit data length register, we must
          * ensure that we don't exceed 2^16-1 bytes in a single request.
-         * Choose 64 (512-byte) sectors as the limit.
          */
-        mmc->max_sectors = 64;
+        mmc->max_req_size = 65535;
 
         /*
          * Set the maximum segment size.  Since we aren't doing DMA
          * (yet) we are only limited by the data length register.
          */
-        mmc->max_seg_size = mmc->max_sectors << 9;
+        mmc->max_seg_size = mmc->max_req_size;
 
         /*
          * Block size can be up to 2048 bytes, but must be a power of two.
          */
         mmc->max_blk_size = 2048;
 
+        /*
+         * No limit on the number of blocks transferred.
+         */
+        mmc->max_blk_count = mmc->max_req_size;
+
         spin_lock_init(&host->lock);
 
         writel(0, host->base + MMCIMASK0);
diff --git a/drivers/mmc/omap.c b/drivers/mmc/omap.c
index fa69a0dc5969..1e96a2f65022 100644
--- a/drivers/mmc/omap.c
+++ b/drivers/mmc/omap.c
@@ -1100,8 +1100,9 @@ static int __init mmc_omap_probe(struct platform_device *pdev)
         mmc->max_phys_segs = 32;
         mmc->max_hw_segs = 32;
         mmc->max_blk_size = 2048;       /* BLEN is 11 bits (+1) */
-        mmc->max_sectors = 256; /* NBLK max 11-bits, OMAP also limited by DMA */
-        mmc->max_seg_size = mmc->max_sectors * 512;
+        mmc->max_blk_count = 2048;      /* NBLK is 11 bits (+1) */
+        mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
+        mmc->max_seg_size = mmc->max_req_size;
 
         if (host->power_pin >= 0) {
                 if ((ret = omap_request_gpio(host->power_pin)) != 0) {
diff --git a/drivers/mmc/pxamci.c b/drivers/mmc/pxamci.c
index 9fc9aed1a5ef..9774fc68b61a 100644
--- a/drivers/mmc/pxamci.c
+++ b/drivers/mmc/pxamci.c
@@ -455,6 +455,11 @@ static int pxamci_probe(struct platform_device *pdev)
          */
         mmc->max_blk_size = 1023;
 
+        /*
+         * Block count register is 16 bits.
+         */
+        mmc->max_blk_count = 65535;
+
         host = mmc_priv(mmc);
         host->mmc = mmc;
         host->dma = -1;
diff --git a/drivers/mmc/sdhci.c b/drivers/mmc/sdhci.c
index 155aafe69bf4..99f1db92295b 100644
--- a/drivers/mmc/sdhci.c
+++ b/drivers/mmc/sdhci.c
@@ -1333,15 +1333,15 @@ static int __devinit sdhci_probe_slot(struct pci_dev *pdev, int slot)
 
         /*
          * Maximum number of sectors in one transfer. Limited by DMA boundary
-         * size (512KiB), which means (512 KiB/512=) 1024 entries.
+         * size (512KiB).
          */
-        mmc->max_sectors = 1024;
+        mmc->max_req_size = 524288;
 
         /*
          * Maximum segment size. Could be one segment with the maximum number
-         * of sectors.
+         * of bytes.
          */
-        mmc->max_seg_size = mmc->max_sectors * 512;
+        mmc->max_seg_size = mmc->max_req_size;
 
         /*
          * Maximum block size. This varies from controller to controller and
@@ -1357,6 +1357,11 @@ static int __devinit sdhci_probe_slot(struct pci_dev *pdev, int slot)
         mmc->max_blk_size = 512 << mmc->max_blk_size;
 
         /*
+         * Maximum block count.
+         */
+        mmc->max_blk_count = 65535;
+
+        /*
          * Init tasklets.
          */
         tasklet_init(&host->card_tasklet,
diff --git a/drivers/mmc/tifm_sd.c b/drivers/mmc/tifm_sd.c
index bdfad15371b8..7e607b75f4bc 100644
--- a/drivers/mmc/tifm_sd.c
+++ b/drivers/mmc/tifm_sd.c
@@ -885,10 +885,13 @@ static int tifm_sd_probe(struct tifm_dev *sock)
         mmc->f_max = 24000000;
         mmc->max_hw_segs = 1;
         mmc->max_phys_segs = 1;
-        mmc->max_sectors = 127;
-        //2k maximum hw block length
-        mmc->max_seg_size = mmc->max_sectors << 11;
+        // limited by DMA counter - it's safer to stick with
+        // block counter has 11 bits though
+        mmc->max_blk_count = 256;
+        // 2k maximum hw block length
         mmc->max_blk_size = 2048;
+        mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
+        mmc->max_seg_size = mmc->max_req_size;
         sock->signal_irq = tifm_sd_signal_irq;
         rc = tifm_sd_initialize_host(host);
 
diff --git a/drivers/mmc/wbsd.c b/drivers/mmc/wbsd.c
index 5711beecb4e8..cf16e44c0301 100644
--- a/drivers/mmc/wbsd.c
+++ b/drivers/mmc/wbsd.c
@@ -1343,16 +1343,15 @@ static int __devinit wbsd_alloc_mmc(struct device *dev)
         mmc->max_phys_segs = 128;
 
         /*
-         * Maximum number of sectors in one transfer. Also limited by 64kB
-         * buffer.
+         * Maximum request size. Also limited by 64KiB buffer.
          */
-        mmc->max_sectors = 128;
+        mmc->max_req_size = 65536;
 
         /*
          * Maximum segment size. Could be one segment with the maximum number
-         * of segments.
+         * of bytes.
          */
-        mmc->max_seg_size = mmc->max_sectors * 512;
+        mmc->max_seg_size = mmc->max_req_size;
 
         /*
          * Maximum block size. We have 12 bits (= 4095) but have to subtract
@@ -1360,6 +1359,12 @@ static int __devinit wbsd_alloc_mmc(struct device *dev)
          */
         mmc->max_blk_size = 4087;
 
+        /*
+         * Maximum block count. There is no real limit so the maximum
+         * request size will be the only restriction.
+         */
+        mmc->max_blk_count = mmc->max_req_size;
+
         dev_set_drvdata(dev, mmc);
 
         return 0;
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index 2da0c918a8cc..913e5752569f 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -92,9 +92,10 @@ struct mmc_host {
         unsigned int            max_seg_size;   /* see blk_queue_max_segment_size */
         unsigned short          max_hw_segs;    /* see blk_queue_max_hw_segments */
         unsigned short          max_phys_segs;  /* see blk_queue_max_phys_segments */
-        unsigned short          max_sectors;    /* see blk_queue_max_sectors */
         unsigned short          unused;
+        unsigned int            max_req_size;   /* maximum number of bytes in one req */
         unsigned int            max_blk_size;   /* maximum size of one mmc block */
+        unsigned int            max_blk_count;  /* maximum number of blocks in one req */
 
         /* private data */
         struct mmc_ios          ios;            /* current io bus settings */