2 * Block driver for media (i.e., flash cards)
4 * Copyright 2002 Hewlett-Packard Company
5 * Copyright 2005-2008 Pierre Ossman
7 * Use consistent with the GNU GPL is permitted,
8 * provided that this copyright notice is
9 * preserved in its entirety in all copies and derived works.
11 * HEWLETT-PACKARD COMPANY MAKES NO WARRANTIES, EXPRESSED OR IMPLIED,
12 * AS TO THE USEFULNESS OR CORRECTNESS OF THIS CODE OR ITS
13 * FITNESS FOR ANY PARTICULAR PURPOSE.
15 * Many thanks to Alessandro Rubini and Jonathan Corbet!
17 * Author: Andrew Christian
20 #include <linux/moduleparam.h>
21 #include <linux/module.h>
22 #include <linux/init.h>
24 #include <linux/kernel.h>
26 #include <linux/slab.h>
27 #include <linux/errno.h>
28 #include <linux/hdreg.h>
29 #include <linux/kdev_t.h>
30 #include <linux/blkdev.h>
31 #include <linux/mutex.h>
32 #include <linux/scatterlist.h>
33 #include <linux/string_helpers.h>
34 #include <linux/delay.h>
35 #include <linux/capability.h>
36 #include <linux/compat.h>
38 #include <linux/mmc/ioctl.h>
39 #include <linux/mmc/card.h>
40 #include <linux/mmc/host.h>
41 #include <linux/mmc/mmc.h>
42 #include <linux/mmc/sd.h>
44 #include <asm/system.h>
45 #include <asm/uaccess.h>
49 MODULE_ALIAS("mmc:block");
50 #ifdef MODULE_PARAM_PREFIX
51 #undef MODULE_PARAM_PREFIX
53 #define MODULE_PARAM_PREFIX "mmcblk."
55 #define INAND_CMD38_ARG_EXT_CSD 113
56 #define INAND_CMD38_ARG_ERASE 0x00
57 #define INAND_CMD38_ARG_TRIM 0x01
58 #define INAND_CMD38_ARG_SECERASE 0x80
59 #define INAND_CMD38_ARG_SECTRIM1 0x81
60 #define INAND_CMD38_ARG_SECTRIM2 0x88
62 static DEFINE_MUTEX(block_mutex
);
65 * The defaults come from config options but can be overriden by module
68 static int perdev_minors
= CONFIG_MMC_BLOCK_MINORS
;
71 * We've only got one major, so number of mmcblk devices is
72 * limited to 256 / number of minors per device.
74 static int max_devices
;
76 /* 256 minors, so at most 256 separate devices */
77 static DECLARE_BITMAP(dev_use
, 256);
78 static DECLARE_BITMAP(name_use
, 256);
81 * There is one mmc_blk_data per slot.
86 struct mmc_queue queue
;
87 struct list_head part
;
90 #define MMC_BLK_CMD23 (1 << 0) /* Can do SET_BLOCK_COUNT for multiblock */
91 #define MMC_BLK_REL_WR (1 << 1) /* MMC Reliable write support */
94 unsigned int read_only
;
95 unsigned int part_type
;
96 unsigned int name_idx
;
99 * Only set in main mmc_blk_data associated
100 * with mmc_card with mmc_set_drvdata, and keeps
101 * track of the current selected device partition.
103 unsigned int part_curr
;
104 struct device_attribute force_ro
;
107 static DEFINE_MUTEX(open_lock
);
109 module_param(perdev_minors
, int, 0444);
110 MODULE_PARM_DESC(perdev_minors
, "Minors numbers to allocate per device");
112 static struct mmc_blk_data
*mmc_blk_get(struct gendisk
*disk
)
114 struct mmc_blk_data
*md
;
116 mutex_lock(&open_lock
);
117 md
= disk
->private_data
;
118 if (md
&& md
->usage
== 0)
122 mutex_unlock(&open_lock
);
127 static inline int mmc_get_devidx(struct gendisk
*disk
)
129 int devmaj
= MAJOR(disk_devt(disk
));
130 int devidx
= MINOR(disk_devt(disk
)) / perdev_minors
;
133 devidx
= disk
->first_minor
/ perdev_minors
;
137 static void mmc_blk_put(struct mmc_blk_data
*md
)
139 mutex_lock(&open_lock
);
141 if (md
->usage
== 0) {
142 int devidx
= mmc_get_devidx(md
->disk
);
143 blk_cleanup_queue(md
->queue
.queue
);
145 __clear_bit(devidx
, dev_use
);
150 mutex_unlock(&open_lock
);
153 static ssize_t
force_ro_show(struct device
*dev
, struct device_attribute
*attr
,
157 struct mmc_blk_data
*md
= mmc_blk_get(dev_to_disk(dev
));
159 ret
= snprintf(buf
, PAGE_SIZE
, "%d",
160 get_disk_ro(dev_to_disk(dev
)) ^
166 static ssize_t
force_ro_store(struct device
*dev
, struct device_attribute
*attr
,
167 const char *buf
, size_t count
)
171 struct mmc_blk_data
*md
= mmc_blk_get(dev_to_disk(dev
));
172 unsigned long set
= simple_strtoul(buf
, &end
, 0);
178 set_disk_ro(dev_to_disk(dev
), set
|| md
->read_only
);
185 static int mmc_blk_open(struct block_device
*bdev
, fmode_t mode
)
187 struct mmc_blk_data
*md
= mmc_blk_get(bdev
->bd_disk
);
190 mutex_lock(&block_mutex
);
193 check_disk_change(bdev
);
196 if ((mode
& FMODE_WRITE
) && md
->read_only
) {
201 mutex_unlock(&block_mutex
);
206 static int mmc_blk_release(struct gendisk
*disk
, fmode_t mode
)
208 struct mmc_blk_data
*md
= disk
->private_data
;
210 mutex_lock(&block_mutex
);
212 mutex_unlock(&block_mutex
);
217 mmc_blk_getgeo(struct block_device
*bdev
, struct hd_geometry
*geo
)
219 geo
->cylinders
= get_capacity(bdev
->bd_disk
) / (4 * 16);
225 struct mmc_blk_ioc_data
{
226 struct mmc_ioc_cmd ic
;
231 static struct mmc_blk_ioc_data
*mmc_blk_ioctl_copy_from_user(
232 struct mmc_ioc_cmd __user
*user
)
234 struct mmc_blk_ioc_data
*idata
;
237 idata
= kzalloc(sizeof(*idata
), GFP_KERNEL
);
243 if (copy_from_user(&idata
->ic
, user
, sizeof(idata
->ic
))) {
248 idata
->buf_bytes
= (u64
) idata
->ic
.blksz
* idata
->ic
.blocks
;
249 if (idata
->buf_bytes
> MMC_IOC_MAX_BYTES
) {
254 idata
->buf
= kzalloc(idata
->buf_bytes
, GFP_KERNEL
);
260 if (copy_from_user(idata
->buf
, (void __user
*)(unsigned long)
261 idata
->ic
.data_ptr
, idata
->buf_bytes
)) {
276 static int mmc_blk_ioctl_cmd(struct block_device
*bdev
,
277 struct mmc_ioc_cmd __user
*ic_ptr
)
279 struct mmc_blk_ioc_data
*idata
;
280 struct mmc_blk_data
*md
;
281 struct mmc_card
*card
;
282 struct mmc_command cmd
= {0};
283 struct mmc_data data
= {0};
284 struct mmc_request mrq
= {0};
285 struct scatterlist sg
;
289 * The caller must have CAP_SYS_RAWIO, and must be calling this on the
290 * whole block device, not on a partition. This prevents overspray
291 * between sibling partitions.
293 if ((!capable(CAP_SYS_RAWIO
)) || (bdev
!= bdev
->bd_contains
))
296 idata
= mmc_blk_ioctl_copy_from_user(ic_ptr
);
298 return PTR_ERR(idata
);
300 cmd
.opcode
= idata
->ic
.opcode
;
301 cmd
.arg
= idata
->ic
.arg
;
302 cmd
.flags
= idata
->ic
.flags
;
306 data
.blksz
= idata
->ic
.blksz
;
307 data
.blocks
= idata
->ic
.blocks
;
309 sg_init_one(data
.sg
, idata
->buf
, idata
->buf_bytes
);
311 if (idata
->ic
.write_flag
)
312 data
.flags
= MMC_DATA_WRITE
;
314 data
.flags
= MMC_DATA_READ
;
319 md
= mmc_blk_get(bdev
->bd_disk
);
325 card
= md
->queue
.card
;
331 mmc_claim_host(card
->host
);
333 if (idata
->ic
.is_acmd
) {
334 err
= mmc_app_cmd(card
->host
, card
);
339 /* data.flags must already be set before doing this. */
340 mmc_set_data_timeout(&data
, card
);
341 /* Allow overriding the timeout_ns for empirical tuning. */
342 if (idata
->ic
.data_timeout_ns
)
343 data
.timeout_ns
= idata
->ic
.data_timeout_ns
;
345 if ((cmd
.flags
& MMC_RSP_R1B
) == MMC_RSP_R1B
) {
347 * Pretend this is a data transfer and rely on the host driver
348 * to compute timeout. When all host drivers support
349 * cmd.cmd_timeout for R1B, this can be changed to:
352 * cmd.cmd_timeout = idata->ic.cmd_timeout_ms;
354 data
.timeout_ns
= idata
->ic
.cmd_timeout_ms
* 1000000;
357 mmc_wait_for_req(card
->host
, &mrq
);
360 dev_err(mmc_dev(card
->host
), "%s: cmd error %d\n",
361 __func__
, cmd
.error
);
366 dev_err(mmc_dev(card
->host
), "%s: data error %d\n",
367 __func__
, data
.error
);
373 * According to the SD specs, some commands require a delay after
374 * issuing the command.
376 if (idata
->ic
.postsleep_min_us
)
377 usleep_range(idata
->ic
.postsleep_min_us
, idata
->ic
.postsleep_max_us
);
379 if (copy_to_user(&(ic_ptr
->response
), cmd
.resp
, sizeof(cmd
.resp
))) {
384 if (!idata
->ic
.write_flag
) {
385 if (copy_to_user((void __user
*)(unsigned long) idata
->ic
.data_ptr
,
386 idata
->buf
, idata
->buf_bytes
)) {
393 mmc_release_host(card
->host
);
402 static int mmc_blk_ioctl(struct block_device
*bdev
, fmode_t mode
,
403 unsigned int cmd
, unsigned long arg
)
406 if (cmd
== MMC_IOC_CMD
)
407 ret
= mmc_blk_ioctl_cmd(bdev
, (struct mmc_ioc_cmd __user
*)arg
);
412 static int mmc_blk_compat_ioctl(struct block_device
*bdev
, fmode_t mode
,
413 unsigned int cmd
, unsigned long arg
)
415 return mmc_blk_ioctl(bdev
, mode
, cmd
, (unsigned long) compat_ptr(arg
));
419 static const struct block_device_operations mmc_bdops
= {
420 .open
= mmc_blk_open
,
421 .release
= mmc_blk_release
,
422 .getgeo
= mmc_blk_getgeo
,
423 .owner
= THIS_MODULE
,
424 .ioctl
= mmc_blk_ioctl
,
426 .compat_ioctl
= mmc_blk_compat_ioctl
,
430 struct mmc_blk_request
{
431 struct mmc_request mrq
;
432 struct mmc_command sbc
;
433 struct mmc_command cmd
;
434 struct mmc_command stop
;
435 struct mmc_data data
;
438 static inline int mmc_blk_part_switch(struct mmc_card
*card
,
439 struct mmc_blk_data
*md
)
442 struct mmc_blk_data
*main_md
= mmc_get_drvdata(card
);
443 if (main_md
->part_curr
== md
->part_type
)
446 if (mmc_card_mmc(card
)) {
447 card
->ext_csd
.part_config
&= ~EXT_CSD_PART_CONFIG_ACC_MASK
;
448 card
->ext_csd
.part_config
|= md
->part_type
;
450 ret
= mmc_switch(card
, EXT_CSD_CMD_SET_NORMAL
,
451 EXT_CSD_PART_CONFIG
, card
->ext_csd
.part_config
,
452 card
->ext_csd
.part_time
);
457 main_md
->part_curr
= md
->part_type
;
461 static u32
mmc_sd_num_wr_blocks(struct mmc_card
*card
)
467 struct mmc_request mrq
= {0};
468 struct mmc_command cmd
= {0};
469 struct mmc_data data
= {0};
470 unsigned int timeout_us
;
472 struct scatterlist sg
;
474 cmd
.opcode
= MMC_APP_CMD
;
475 cmd
.arg
= card
->rca
<< 16;
476 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_R1
| MMC_CMD_AC
;
478 err
= mmc_wait_for_cmd(card
->host
, &cmd
, 0);
481 if (!mmc_host_is_spi(card
->host
) && !(cmd
.resp
[0] & R1_APP_CMD
))
484 memset(&cmd
, 0, sizeof(struct mmc_command
));
486 cmd
.opcode
= SD_APP_SEND_NUM_WR_BLKS
;
488 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_R1
| MMC_CMD_ADTC
;
490 data
.timeout_ns
= card
->csd
.tacc_ns
* 100;
491 data
.timeout_clks
= card
->csd
.tacc_clks
* 100;
493 timeout_us
= data
.timeout_ns
/ 1000;
494 timeout_us
+= data
.timeout_clks
* 1000 /
495 (card
->host
->ios
.clock
/ 1000);
497 if (timeout_us
> 100000) {
498 data
.timeout_ns
= 100000000;
499 data
.timeout_clks
= 0;
504 data
.flags
= MMC_DATA_READ
;
511 blocks
= kmalloc(4, GFP_KERNEL
);
515 sg_init_one(&sg
, blocks
, 4);
517 mmc_wait_for_req(card
->host
, &mrq
);
519 result
= ntohl(*blocks
);
522 if (cmd
.error
|| data
.error
)
528 static int send_stop(struct mmc_card
*card
, u32
*status
)
530 struct mmc_command cmd
= {0};
533 cmd
.opcode
= MMC_STOP_TRANSMISSION
;
534 cmd
.flags
= MMC_RSP_SPI_R1B
| MMC_RSP_R1B
| MMC_CMD_AC
;
535 err
= mmc_wait_for_cmd(card
->host
, &cmd
, 5);
537 *status
= cmd
.resp
[0];
541 static int get_card_status(struct mmc_card
*card
, u32
*status
, int retries
)
543 struct mmc_command cmd
= {0};
546 cmd
.opcode
= MMC_SEND_STATUS
;
547 if (!mmc_host_is_spi(card
->host
))
548 cmd
.arg
= card
->rca
<< 16;
549 cmd
.flags
= MMC_RSP_SPI_R2
| MMC_RSP_R1
| MMC_CMD_AC
;
550 err
= mmc_wait_for_cmd(card
->host
, &cmd
, retries
);
552 *status
= cmd
.resp
[0];
558 #define ERR_CONTINUE 0
560 static int mmc_blk_cmd_error(struct request
*req
, const char *name
, int error
,
561 bool status_valid
, u32 status
)
565 /* response crc error, retry the r/w cmd */
566 pr_err("%s: %s sending %s command, card status %#x\n",
567 req
->rq_disk
->disk_name
, "response CRC error",
572 pr_err("%s: %s sending %s command, card status %#x\n",
573 req
->rq_disk
->disk_name
, "timed out", name
, status
);
575 /* If the status cmd initially failed, retry the r/w cmd */
580 * If it was a r/w cmd crc error, or illegal command
581 * (eg, issued in wrong state) then retry - we should
582 * have corrected the state problem above.
584 if (status
& (R1_COM_CRC_ERROR
| R1_ILLEGAL_COMMAND
))
587 /* Otherwise abort the command */
591 /* We don't understand the error code the driver gave us */
592 pr_err("%s: unknown error %d sending read/write command, card status %#x\n",
593 req
->rq_disk
->disk_name
, error
, status
);
599 * Initial r/w and stop cmd error recovery.
600 * We don't know whether the card received the r/w cmd or not, so try to
601 * restore things back to a sane state. Essentially, we do this as follows:
602 * - Obtain card status. If the first attempt to obtain card status fails,
603 * the status word will reflect the failed status cmd, not the failed
604 * r/w cmd. If we fail to obtain card status, it suggests we can no
605 * longer communicate with the card.
606 * - Check the card state. If the card received the cmd but there was a
607 * transient problem with the response, it might still be in a data transfer
608 * mode. Try to send it a stop command. If this fails, we can't recover.
609 * - If the r/w cmd failed due to a response CRC error, it was probably
610 * transient, so retry the cmd.
611 * - If the r/w cmd timed out, but we didn't get the r/w cmd status, retry.
612 * - If the r/w cmd timed out, and the r/w cmd failed due to CRC error or
613 * illegal cmd, retry.
614 * Otherwise we don't understand what happened, so abort.
616 static int mmc_blk_cmd_recovery(struct mmc_card
*card
, struct request
*req
,
617 struct mmc_blk_request
*brq
)
619 bool prev_cmd_status_valid
= true;
620 u32 status
, stop_status
= 0;
624 * Try to get card status which indicates both the card state
625 * and why there was no response. If the first attempt fails,
626 * we can't be sure the returned status is for the r/w command.
628 for (retry
= 2; retry
>= 0; retry
--) {
629 err
= get_card_status(card
, &status
, 0);
633 prev_cmd_status_valid
= false;
634 pr_err("%s: error %d sending status command, %sing\n",
635 req
->rq_disk
->disk_name
, err
, retry
? "retry" : "abort");
638 /* We couldn't get a response from the card. Give up. */
643 * Check the current card state. If it is in some data transfer
644 * mode, tell it to stop (and hopefully transition back to TRAN.)
646 if (R1_CURRENT_STATE(status
) == R1_STATE_DATA
||
647 R1_CURRENT_STATE(status
) == R1_STATE_RCV
) {
648 err
= send_stop(card
, &stop_status
);
650 pr_err("%s: error %d sending stop command\n",
651 req
->rq_disk
->disk_name
, err
);
654 * If the stop cmd also timed out, the card is probably
655 * not present, so abort. Other errors are bad news too.
661 /* Check for set block count errors */
663 return mmc_blk_cmd_error(req
, "SET_BLOCK_COUNT", brq
->sbc
.error
,
664 prev_cmd_status_valid
, status
);
666 /* Check for r/w command errors */
668 return mmc_blk_cmd_error(req
, "r/w cmd", brq
->cmd
.error
,
669 prev_cmd_status_valid
, status
);
671 /* Now for stop errors. These aren't fatal to the transfer. */
672 pr_err("%s: error %d sending stop command, original cmd response %#x, card status %#x\n",
673 req
->rq_disk
->disk_name
, brq
->stop
.error
,
674 brq
->cmd
.resp
[0], status
);
677 * Subsitute in our own stop status as this will give the error
678 * state which happened during the execution of the r/w command.
681 brq
->stop
.resp
[0] = stop_status
;
687 static int mmc_blk_issue_discard_rq(struct mmc_queue
*mq
, struct request
*req
)
689 struct mmc_blk_data
*md
= mq
->data
;
690 struct mmc_card
*card
= md
->queue
.card
;
691 unsigned int from
, nr
, arg
;
694 if (!mmc_can_erase(card
)) {
699 from
= blk_rq_pos(req
);
700 nr
= blk_rq_sectors(req
);
702 if (mmc_can_trim(card
))
707 if (card
->quirks
& MMC_QUIRK_INAND_CMD38
) {
708 err
= mmc_switch(card
, EXT_CSD_CMD_SET_NORMAL
,
709 INAND_CMD38_ARG_EXT_CSD
,
710 arg
== MMC_TRIM_ARG
?
711 INAND_CMD38_ARG_TRIM
:
712 INAND_CMD38_ARG_ERASE
,
717 err
= mmc_erase(card
, from
, nr
, arg
);
719 spin_lock_irq(&md
->lock
);
720 __blk_end_request(req
, err
, blk_rq_bytes(req
));
721 spin_unlock_irq(&md
->lock
);
726 static int mmc_blk_issue_secdiscard_rq(struct mmc_queue
*mq
,
729 struct mmc_blk_data
*md
= mq
->data
;
730 struct mmc_card
*card
= md
->queue
.card
;
731 unsigned int from
, nr
, arg
;
734 if (!mmc_can_secure_erase_trim(card
)) {
739 from
= blk_rq_pos(req
);
740 nr
= blk_rq_sectors(req
);
742 if (mmc_can_trim(card
) && !mmc_erase_group_aligned(card
, from
, nr
))
743 arg
= MMC_SECURE_TRIM1_ARG
;
745 arg
= MMC_SECURE_ERASE_ARG
;
747 if (card
->quirks
& MMC_QUIRK_INAND_CMD38
) {
748 err
= mmc_switch(card
, EXT_CSD_CMD_SET_NORMAL
,
749 INAND_CMD38_ARG_EXT_CSD
,
750 arg
== MMC_SECURE_TRIM1_ARG
?
751 INAND_CMD38_ARG_SECTRIM1
:
752 INAND_CMD38_ARG_SECERASE
,
757 err
= mmc_erase(card
, from
, nr
, arg
);
758 if (!err
&& arg
== MMC_SECURE_TRIM1_ARG
) {
759 if (card
->quirks
& MMC_QUIRK_INAND_CMD38
) {
760 err
= mmc_switch(card
, EXT_CSD_CMD_SET_NORMAL
,
761 INAND_CMD38_ARG_EXT_CSD
,
762 INAND_CMD38_ARG_SECTRIM2
,
767 err
= mmc_erase(card
, from
, nr
, MMC_SECURE_TRIM2_ARG
);
770 spin_lock_irq(&md
->lock
);
771 __blk_end_request(req
, err
, blk_rq_bytes(req
));
772 spin_unlock_irq(&md
->lock
);
777 static int mmc_blk_issue_flush(struct mmc_queue
*mq
, struct request
*req
)
779 struct mmc_blk_data
*md
= mq
->data
;
782 * No-op, only service this because we need REQ_FUA for reliable
785 spin_lock_irq(&md
->lock
);
786 __blk_end_request_all(req
, 0);
787 spin_unlock_irq(&md
->lock
);
793 * Reformat current write as a reliable write, supporting
794 * both legacy and the enhanced reliable write MMC cards.
795 * In each transfer we'll handle only as much as a single
796 * reliable write can handle, thus finish the request in
797 * partial completions.
799 static inline void mmc_apply_rel_rw(struct mmc_blk_request
*brq
,
800 struct mmc_card
*card
,
803 if (!(card
->ext_csd
.rel_param
& EXT_CSD_WR_REL_PARAM_EN
)) {
804 /* Legacy mode imposes restrictions on transfers. */
805 if (!IS_ALIGNED(brq
->cmd
.arg
, card
->ext_csd
.rel_sectors
))
806 brq
->data
.blocks
= 1;
808 if (brq
->data
.blocks
> card
->ext_csd
.rel_sectors
)
809 brq
->data
.blocks
= card
->ext_csd
.rel_sectors
;
810 else if (brq
->data
.blocks
< card
->ext_csd
.rel_sectors
)
811 brq
->data
.blocks
= 1;
815 static int mmc_blk_issue_rw_rq(struct mmc_queue
*mq
, struct request
*req
)
817 struct mmc_blk_data
*md
= mq
->data
;
818 struct mmc_card
*card
= md
->queue
.card
;
819 struct mmc_blk_request brq
;
820 int ret
= 1, disable_multi
= 0, retry
= 0;
823 * Reliable writes are used to implement Forced Unit Access and
824 * REQ_META accesses, and are supported only on MMCs.
826 bool do_rel_wr
= ((req
->cmd_flags
& REQ_FUA
) ||
827 (req
->cmd_flags
& REQ_META
)) &&
828 (rq_data_dir(req
) == WRITE
) &&
829 (md
->flags
& MMC_BLK_REL_WR
);
832 u32 readcmd
, writecmd
;
834 memset(&brq
, 0, sizeof(struct mmc_blk_request
));
835 brq
.mrq
.cmd
= &brq
.cmd
;
836 brq
.mrq
.data
= &brq
.data
;
838 brq
.cmd
.arg
= blk_rq_pos(req
);
839 if (!mmc_card_blockaddr(card
))
841 brq
.cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_R1
| MMC_CMD_ADTC
;
842 brq
.data
.blksz
= 512;
843 brq
.stop
.opcode
= MMC_STOP_TRANSMISSION
;
845 brq
.stop
.flags
= MMC_RSP_SPI_R1B
| MMC_RSP_R1B
| MMC_CMD_AC
;
846 brq
.data
.blocks
= blk_rq_sectors(req
);
849 * The block layer doesn't support all sector count
850 * restrictions, so we need to be prepared for too big
853 if (brq
.data
.blocks
> card
->host
->max_blk_count
)
854 brq
.data
.blocks
= card
->host
->max_blk_count
;
857 * After a read error, we redo the request one sector at a time
858 * in order to accurately determine which sectors can be read
861 if (disable_multi
&& brq
.data
.blocks
> 1)
864 if (brq
.data
.blocks
> 1 || do_rel_wr
) {
865 /* SPI multiblock writes terminate using a special
866 * token, not a STOP_TRANSMISSION request.
868 if (!mmc_host_is_spi(card
->host
) ||
869 rq_data_dir(req
) == READ
)
870 brq
.mrq
.stop
= &brq
.stop
;
871 readcmd
= MMC_READ_MULTIPLE_BLOCK
;
872 writecmd
= MMC_WRITE_MULTIPLE_BLOCK
;
875 readcmd
= MMC_READ_SINGLE_BLOCK
;
876 writecmd
= MMC_WRITE_BLOCK
;
878 if (rq_data_dir(req
) == READ
) {
879 brq
.cmd
.opcode
= readcmd
;
880 brq
.data
.flags
|= MMC_DATA_READ
;
882 brq
.cmd
.opcode
= writecmd
;
883 brq
.data
.flags
|= MMC_DATA_WRITE
;
887 mmc_apply_rel_rw(&brq
, card
, req
);
890 * Pre-defined multi-block transfers are preferable to
891 * open ended-ones (and necessary for reliable writes).
892 * However, it is not sufficient to just send CMD23,
893 * and avoid the final CMD12, as on an error condition
894 * CMD12 (stop) needs to be sent anyway. This, coupled
895 * with Auto-CMD23 enhancements provided by some
896 * hosts, means that the complexity of dealing
897 * with this is best left to the host. If CMD23 is
898 * supported by card and host, we'll fill sbc in and let
899 * the host deal with handling it correctly. This means
900 * that for hosts that don't expose MMC_CAP_CMD23, no
901 * change of behavior will be observed.
903 * N.B: Some MMC cards experience perf degradation.
904 * We'll avoid using CMD23-bounded multiblock writes for
905 * these, while retaining features like reliable writes.
908 if ((md
->flags
& MMC_BLK_CMD23
) &&
909 mmc_op_multi(brq
.cmd
.opcode
) &&
910 (do_rel_wr
|| !(card
->quirks
& MMC_QUIRK_BLK_NO_CMD23
))) {
911 brq
.sbc
.opcode
= MMC_SET_BLOCK_COUNT
;
912 brq
.sbc
.arg
= brq
.data
.blocks
|
913 (do_rel_wr
? (1 << 31) : 0);
914 brq
.sbc
.flags
= MMC_RSP_R1
| MMC_CMD_AC
;
915 brq
.mrq
.sbc
= &brq
.sbc
;
918 mmc_set_data_timeout(&brq
.data
, card
);
920 brq
.data
.sg
= mq
->sg
;
921 brq
.data
.sg_len
= mmc_queue_map_sg(mq
);
924 * Adjust the sg list so it is the same size as the
927 if (brq
.data
.blocks
!= blk_rq_sectors(req
)) {
928 int i
, data_size
= brq
.data
.blocks
<< 9;
929 struct scatterlist
*sg
;
931 for_each_sg(brq
.data
.sg
, sg
, brq
.data
.sg_len
, i
) {
932 data_size
-= sg
->length
;
933 if (data_size
<= 0) {
934 sg
->length
+= data_size
;
942 mmc_queue_bounce_pre(mq
);
944 mmc_wait_for_req(card
->host
, &brq
.mrq
);
946 mmc_queue_bounce_post(mq
);
949 * sbc.error indicates a problem with the set block count
950 * command. No data will have been transferred.
952 * cmd.error indicates a problem with the r/w command. No
953 * data will have been transferred.
955 * stop.error indicates a problem with the stop command. Data
956 * may have been transferred, or may still be transferring.
958 if (brq
.sbc
.error
|| brq
.cmd
.error
|| brq
.stop
.error
) {
959 switch (mmc_blk_cmd_recovery(card
, req
, &brq
)) {
970 if (!mmc_host_is_spi(card
->host
) && rq_data_dir(req
) != READ
) {
973 int err
= get_card_status(card
, &status
, 5);
975 printk(KERN_ERR
"%s: error %d requesting status\n",
976 req
->rq_disk
->disk_name
, err
);
980 * Some cards mishandle the status bits,
981 * so make sure to check both the busy
982 * indication and the card state.
984 } while (!(status
& R1_READY_FOR_DATA
) ||
985 (R1_CURRENT_STATE(status
) == R1_STATE_PRG
));
988 if (brq
.data
.error
) {
989 pr_err("%s: error %d transferring data, sector %u nr %u, cmd response %#x card status %#x\n",
990 req
->rq_disk
->disk_name
, brq
.data
.error
,
991 (unsigned)blk_rq_pos(req
),
992 (unsigned)blk_rq_sectors(req
),
993 brq
.cmd
.resp
[0], brq
.stop
.resp
[0]);
995 if (rq_data_dir(req
) == READ
) {
996 if (brq
.data
.blocks
> 1) {
997 /* Redo read one sector at a time */
998 pr_warning("%s: retrying using single block read\n",
999 req
->rq_disk
->disk_name
);
1005 * After an error, we redo I/O one sector at a
1006 * time, so we only reach here after trying to
1007 * read a single sector.
1009 spin_lock_irq(&md
->lock
);
1010 ret
= __blk_end_request(req
, -EIO
, brq
.data
.blksz
);
1011 spin_unlock_irq(&md
->lock
);
1019 * A block was successfully transferred.
1021 spin_lock_irq(&md
->lock
);
1022 ret
= __blk_end_request(req
, 0, brq
.data
.bytes_xfered
);
1023 spin_unlock_irq(&md
->lock
);
1030 * If this is an SD card and we're writing, we can first
1031 * mark the known good sectors as ok.
1033 * If the card is not SD, we can still ok written sectors
1034 * as reported by the controller (which might be less than
1035 * the real number of written sectors, but never more).
1037 if (mmc_card_sd(card
)) {
1040 blocks
= mmc_sd_num_wr_blocks(card
);
1041 if (blocks
!= (u32
)-1) {
1042 spin_lock_irq(&md
->lock
);
1043 ret
= __blk_end_request(req
, 0, blocks
<< 9);
1044 spin_unlock_irq(&md
->lock
);
1047 spin_lock_irq(&md
->lock
);
1048 ret
= __blk_end_request(req
, 0, brq
.data
.bytes_xfered
);
1049 spin_unlock_irq(&md
->lock
);
1053 spin_lock_irq(&md
->lock
);
1055 ret
= __blk_end_request(req
, -EIO
, blk_rq_cur_bytes(req
));
1056 spin_unlock_irq(&md
->lock
);
1061 static int mmc_blk_issue_rq(struct mmc_queue
*mq
, struct request
*req
)
1064 struct mmc_blk_data
*md
= mq
->data
;
1065 struct mmc_card
*card
= md
->queue
.card
;
1067 mmc_claim_host(card
->host
);
1068 ret
= mmc_blk_part_switch(card
, md
);
1074 if (req
->cmd_flags
& REQ_DISCARD
) {
1075 if (req
->cmd_flags
& REQ_SECURE
)
1076 ret
= mmc_blk_issue_secdiscard_rq(mq
, req
);
1078 ret
= mmc_blk_issue_discard_rq(mq
, req
);
1079 } else if (req
->cmd_flags
& REQ_FLUSH
) {
1080 ret
= mmc_blk_issue_flush(mq
, req
);
1082 ret
= mmc_blk_issue_rw_rq(mq
, req
);
1086 mmc_release_host(card
->host
);
1090 static inline int mmc_blk_readonly(struct mmc_card
*card
)
1092 return mmc_card_readonly(card
) ||
1093 !(card
->csd
.cmdclass
& CCC_BLOCK_WRITE
);
1096 static struct mmc_blk_data
*mmc_blk_alloc_req(struct mmc_card
*card
,
1097 struct device
*parent
,
1100 const char *subname
)
1102 struct mmc_blk_data
*md
;
1105 devidx
= find_first_zero_bit(dev_use
, max_devices
);
1106 if (devidx
>= max_devices
)
1107 return ERR_PTR(-ENOSPC
);
1108 __set_bit(devidx
, dev_use
);
1110 md
= kzalloc(sizeof(struct mmc_blk_data
), GFP_KERNEL
);
1117 * !subname implies we are creating main mmc_blk_data that will be
1118 * associated with mmc_card with mmc_set_drvdata. Due to device
1119 * partitions, devidx will not coincide with a per-physical card
1120 * index anymore so we keep track of a name index.
1123 md
->name_idx
= find_first_zero_bit(name_use
, max_devices
);
1124 __set_bit(md
->name_idx
, name_use
);
1127 md
->name_idx
= ((struct mmc_blk_data
*)
1128 dev_to_disk(parent
)->private_data
)->name_idx
;
1131 * Set the read-only status based on the supported commands
1132 * and the write protect switch.
1134 md
->read_only
= mmc_blk_readonly(card
);
1136 md
->disk
= alloc_disk(perdev_minors
);
1137 if (md
->disk
== NULL
) {
1142 spin_lock_init(&md
->lock
);
1143 INIT_LIST_HEAD(&md
->part
);
1146 ret
= mmc_init_queue(&md
->queue
, card
, &md
->lock
, subname
);
1150 md
->queue
.issue_fn
= mmc_blk_issue_rq
;
1151 md
->queue
.data
= md
;
1153 md
->disk
->major
= MMC_BLOCK_MAJOR
;
1154 md
->disk
->first_minor
= devidx
* perdev_minors
;
1155 md
->disk
->fops
= &mmc_bdops
;
1156 md
->disk
->private_data
= md
;
1157 md
->disk
->queue
= md
->queue
.queue
;
1158 md
->disk
->driverfs_dev
= parent
;
1159 set_disk_ro(md
->disk
, md
->read_only
|| default_ro
);
1162 * As discussed on lkml, GENHD_FL_REMOVABLE should:
1164 * - be set for removable media with permanent block devices
1165 * - be unset for removable block devices with permanent media
1167 * Since MMC block devices clearly fall under the second
1168 * case, we do not set GENHD_FL_REMOVABLE. Userspace
1169 * should use the block device creation/destruction hotplug
1170 * messages to tell when the card is present.
1173 snprintf(md
->disk
->disk_name
, sizeof(md
->disk
->disk_name
),
1174 "mmcblk%d%s", md
->name_idx
, subname
? subname
: "");
1176 blk_queue_logical_block_size(md
->queue
.queue
, 512);
1177 set_capacity(md
->disk
, size
);
1179 if (mmc_host_cmd23(card
->host
)) {
1180 if (mmc_card_mmc(card
) ||
1181 (mmc_card_sd(card
) &&
1182 card
->scr
.cmds
& SD_SCR_CMD23_SUPPORT
))
1183 md
->flags
|= MMC_BLK_CMD23
;
1186 if (mmc_card_mmc(card
) &&
1187 md
->flags
& MMC_BLK_CMD23
&&
1188 ((card
->ext_csd
.rel_param
& EXT_CSD_WR_REL_PARAM_EN
) ||
1189 card
->ext_csd
.rel_sectors
)) {
1190 md
->flags
|= MMC_BLK_REL_WR
;
1191 blk_queue_flush(md
->queue
.queue
, REQ_FLUSH
| REQ_FUA
);
1201 return ERR_PTR(ret
);
1204 static struct mmc_blk_data
*mmc_blk_alloc(struct mmc_card
*card
)
1207 struct mmc_blk_data
*md
;
1209 if (!mmc_card_sd(card
) && mmc_card_blockaddr(card
)) {
1211 * The EXT_CSD sector count is in number or 512 byte
1214 size
= card
->ext_csd
.sectors
;
1217 * The CSD capacity field is in units of read_blkbits.
1218 * set_capacity takes units of 512 bytes.
1220 size
= card
->csd
.capacity
<< (card
->csd
.read_blkbits
- 9);
1223 md
= mmc_blk_alloc_req(card
, &card
->dev
, size
, false, NULL
);
1227 static int mmc_blk_alloc_part(struct mmc_card
*card
,
1228 struct mmc_blk_data
*md
,
1229 unsigned int part_type
,
1232 const char *subname
)
1235 struct mmc_blk_data
*part_md
;
1237 part_md
= mmc_blk_alloc_req(card
, disk_to_dev(md
->disk
), size
, default_ro
,
1239 if (IS_ERR(part_md
))
1240 return PTR_ERR(part_md
);
1241 part_md
->part_type
= part_type
;
1242 list_add(&part_md
->part
, &md
->part
);
1244 string_get_size((u64
)get_capacity(part_md
->disk
) << 9, STRING_UNITS_2
,
1245 cap_str
, sizeof(cap_str
));
1246 printk(KERN_INFO
"%s: %s %s partition %u %s\n",
1247 part_md
->disk
->disk_name
, mmc_card_id(card
),
1248 mmc_card_name(card
), part_md
->part_type
, cap_str
);
1252 static int mmc_blk_alloc_parts(struct mmc_card
*card
, struct mmc_blk_data
*md
)
1256 if (!mmc_card_mmc(card
))
1259 if (card
->ext_csd
.boot_size
) {
1260 ret
= mmc_blk_alloc_part(card
, md
, EXT_CSD_PART_CONFIG_ACC_BOOT0
,
1261 card
->ext_csd
.boot_size
>> 9,
1266 ret
= mmc_blk_alloc_part(card
, md
, EXT_CSD_PART_CONFIG_ACC_BOOT1
,
1267 card
->ext_csd
.boot_size
>> 9,
1278 mmc_blk_set_blksize(struct mmc_blk_data
*md
, struct mmc_card
*card
)
1282 mmc_claim_host(card
->host
);
1283 err
= mmc_set_blocklen(card
, 512);
1284 mmc_release_host(card
->host
);
1287 printk(KERN_ERR
"%s: unable to set block size to 512: %d\n",
1288 md
->disk
->disk_name
, err
);
1295 static void mmc_blk_remove_req(struct mmc_blk_data
*md
)
1298 if (md
->disk
->flags
& GENHD_FL_UP
) {
1299 device_remove_file(disk_to_dev(md
->disk
), &md
->force_ro
);
1301 /* Stop new requests from getting into the queue */
1302 del_gendisk(md
->disk
);
1305 /* Then flush out any already in there */
1306 mmc_cleanup_queue(&md
->queue
);
1311 static void mmc_blk_remove_parts(struct mmc_card
*card
,
1312 struct mmc_blk_data
*md
)
1314 struct list_head
*pos
, *q
;
1315 struct mmc_blk_data
*part_md
;
1317 __clear_bit(md
->name_idx
, name_use
);
1318 list_for_each_safe(pos
, q
, &md
->part
) {
1319 part_md
= list_entry(pos
, struct mmc_blk_data
, part
);
1321 mmc_blk_remove_req(part_md
);
1325 static int mmc_add_disk(struct mmc_blk_data
*md
)
1330 md
->force_ro
.show
= force_ro_show
;
1331 md
->force_ro
.store
= force_ro_store
;
1332 sysfs_attr_init(&md
->force_ro
.attr
);
1333 md
->force_ro
.attr
.name
= "force_ro";
1334 md
->force_ro
.attr
.mode
= S_IRUGO
| S_IWUSR
;
1335 ret
= device_create_file(disk_to_dev(md
->disk
), &md
->force_ro
);
1337 del_gendisk(md
->disk
);
1342 static const struct mmc_fixup blk_fixups
[] =
1344 MMC_FIXUP("SEM02G", 0x2, 0x100, add_quirk
, MMC_QUIRK_INAND_CMD38
),
1345 MMC_FIXUP("SEM04G", 0x2, 0x100, add_quirk
, MMC_QUIRK_INAND_CMD38
),
1346 MMC_FIXUP("SEM08G", 0x2, 0x100, add_quirk
, MMC_QUIRK_INAND_CMD38
),
1347 MMC_FIXUP("SEM16G", 0x2, 0x100, add_quirk
, MMC_QUIRK_INAND_CMD38
),
1348 MMC_FIXUP("SEM32G", 0x2, 0x100, add_quirk
, MMC_QUIRK_INAND_CMD38
),
1351 * Some MMC cards experience performance degradation with CMD23
1352 * instead of CMD12-bounded multiblock transfers. For now we'll
1353 * black list what's bad...
1354 * - Certain Toshiba cards.
1356 * N.B. This doesn't affect SD cards.
1358 MMC_FIXUP("MMC08G", 0x11, CID_OEMID_ANY
, add_quirk_mmc
,
1359 MMC_QUIRK_BLK_NO_CMD23
),
1360 MMC_FIXUP("MMC16G", 0x11, CID_OEMID_ANY
, add_quirk_mmc
,
1361 MMC_QUIRK_BLK_NO_CMD23
),
1362 MMC_FIXUP("MMC32G", 0x11, CID_OEMID_ANY
, add_quirk_mmc
,
1363 MMC_QUIRK_BLK_NO_CMD23
),
1367 static int mmc_blk_probe(struct mmc_card
*card
)
1369 struct mmc_blk_data
*md
, *part_md
;
1374 * Check that the card supports the command class(es) we need.
1376 if (!(card
->csd
.cmdclass
& CCC_BLOCK_READ
))
1379 md
= mmc_blk_alloc(card
);
1383 err
= mmc_blk_set_blksize(md
, card
);
1387 string_get_size((u64
)get_capacity(md
->disk
) << 9, STRING_UNITS_2
,
1388 cap_str
, sizeof(cap_str
));
1389 printk(KERN_INFO
"%s: %s %s %s %s\n",
1390 md
->disk
->disk_name
, mmc_card_id(card
), mmc_card_name(card
),
1391 cap_str
, md
->read_only
? "(ro)" : "");
1393 if (mmc_blk_alloc_parts(card
, md
))
1396 mmc_set_drvdata(card
, md
);
1397 mmc_fixup_device(card
, blk_fixups
);
1399 if (mmc_add_disk(md
))
1402 list_for_each_entry(part_md
, &md
->part
, part
) {
1403 if (mmc_add_disk(part_md
))
1409 mmc_blk_remove_parts(card
, md
);
1410 mmc_blk_remove_req(md
);
1414 static void mmc_blk_remove(struct mmc_card
*card
)
1416 struct mmc_blk_data
*md
= mmc_get_drvdata(card
);
1418 mmc_blk_remove_parts(card
, md
);
1419 mmc_claim_host(card
->host
);
1420 mmc_blk_part_switch(card
, md
);
1421 mmc_release_host(card
->host
);
1422 mmc_blk_remove_req(md
);
1423 mmc_set_drvdata(card
, NULL
);
1427 static int mmc_blk_suspend(struct mmc_card
*card
, pm_message_t state
)
1429 struct mmc_blk_data
*part_md
;
1430 struct mmc_blk_data
*md
= mmc_get_drvdata(card
);
1433 mmc_queue_suspend(&md
->queue
);
1434 list_for_each_entry(part_md
, &md
->part
, part
) {
1435 mmc_queue_suspend(&part_md
->queue
);
1441 static int mmc_blk_resume(struct mmc_card
*card
)
1443 struct mmc_blk_data
*part_md
;
1444 struct mmc_blk_data
*md
= mmc_get_drvdata(card
);
1447 mmc_blk_set_blksize(md
, card
);
1450 * Resume involves the card going into idle state,
1451 * so current partition is always the main one.
1453 md
->part_curr
= md
->part_type
;
1454 mmc_queue_resume(&md
->queue
);
1455 list_for_each_entry(part_md
, &md
->part
, part
) {
1456 mmc_queue_resume(&part_md
->queue
);
1462 #define mmc_blk_suspend NULL
1463 #define mmc_blk_resume NULL
1466 static struct mmc_driver mmc_driver
= {
1470 .probe
= mmc_blk_probe
,
1471 .remove
= mmc_blk_remove
,
1472 .suspend
= mmc_blk_suspend
,
1473 .resume
= mmc_blk_resume
,
1476 static int __init
mmc_blk_init(void)
1480 if (perdev_minors
!= CONFIG_MMC_BLOCK_MINORS
)
1481 pr_info("mmcblk: using %d minors per device\n", perdev_minors
);
1483 max_devices
= 256 / perdev_minors
;
1485 res
= register_blkdev(MMC_BLOCK_MAJOR
, "mmc");
1489 res
= mmc_register_driver(&mmc_driver
);
1495 unregister_blkdev(MMC_BLOCK_MAJOR
, "mmc");
1500 static void __exit
mmc_blk_exit(void)
1502 mmc_unregister_driver(&mmc_driver
);
1503 unregister_blkdev(MMC_BLOCK_MAJOR
, "mmc");
1506 module_init(mmc_blk_init
);
1507 module_exit(mmc_blk_exit
);
1509 MODULE_LICENSE("GPL");
1510 MODULE_DESCRIPTION("Multimedia Card (MMC) block device driver");