block.c revision 53d8f97462b0bbb51150f4d6bc2fd45336a008b9
1/* 2 * Block driver for media (i.e., flash cards) 3 * 4 * Copyright 2002 Hewlett-Packard Company 5 * Copyright 2005-2008 Pierre Ossman 6 * 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. 10 * 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. 14 * 15 * Many thanks to Alessandro Rubini and Jonathan Corbet! 16 * 17 * Author: Andrew Christian 18 * 28 May 2002 19 */ 20#include <linux/moduleparam.h> 21#include <linux/module.h> 22#include <linux/init.h> 23 24#include <linux/kernel.h> 25#include <linux/fs.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> 37 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> 43 44#include <asm/uaccess.h> 45 46#include "queue.h" 47 48MODULE_ALIAS("mmc:block"); 49#ifdef MODULE_PARAM_PREFIX 50#undef MODULE_PARAM_PREFIX 51#endif 52#define MODULE_PARAM_PREFIX "mmcblk." 53 54#define INAND_CMD38_ARG_EXT_CSD 113 55#define INAND_CMD38_ARG_ERASE 0x00 56#define INAND_CMD38_ARG_TRIM 0x01 57#define INAND_CMD38_ARG_SECERASE 0x80 58#define INAND_CMD38_ARG_SECTRIM1 0x81 59#define INAND_CMD38_ARG_SECTRIM2 0x88 60#define MMC_BLK_TIMEOUT_MS (10 * 60 * 1000) /* 10 minute timeout */ 61 62static DEFINE_MUTEX(block_mutex); 63 64/* 65 * The defaults come from config options but can be overriden by module 66 * or bootarg options. 67 */ 68static int perdev_minors = CONFIG_MMC_BLOCK_MINORS; 69 70/* 71 * We've only got one major, so number of mmcblk devices is 72 * limited to 256 / number of minors per device. 73 */ 74static int max_devices; 75 76/* 256 minors, so at most 256 separate devices */ 77static DECLARE_BITMAP(dev_use, 256); 78static DECLARE_BITMAP(name_use, 256); 79 80/* 81 * There is one mmc_blk_data per slot. 82 */ 83struct mmc_blk_data { 84 spinlock_t lock; 85 struct gendisk *disk; 86 struct mmc_queue queue; 87 struct list_head part; 88 89 unsigned int flags; 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 */ 92 93 unsigned int usage; 94 unsigned int read_only; 95 unsigned int part_type; 96 unsigned int name_idx; 97 unsigned int reset_done; 98#define MMC_BLK_READ BIT(0) 99#define MMC_BLK_WRITE BIT(1) 100#define MMC_BLK_DISCARD BIT(2) 101#define MMC_BLK_SECDISCARD BIT(3) 102 103 /* 104 * Only set in main mmc_blk_data associated 105 * with mmc_card with mmc_set_drvdata, and keeps 106 * track of the current selected device partition. 107 */ 108 unsigned int part_curr; 109 struct device_attribute force_ro; 110 struct device_attribute power_ro_lock; 111 int area_type; 112}; 113 114static DEFINE_MUTEX(open_lock); 115 116enum mmc_blk_status { 117 MMC_BLK_SUCCESS = 0, 118 MMC_BLK_PARTIAL, 119 MMC_BLK_CMD_ERR, 120 MMC_BLK_RETRY, 121 MMC_BLK_ABORT, 122 MMC_BLK_DATA_ERR, 123 MMC_BLK_ECC_ERR, 124 MMC_BLK_NOMEDIUM, 125}; 126 127module_param(perdev_minors, int, 0444); 128MODULE_PARM_DESC(perdev_minors, "Minors numbers to allocate per device"); 129 130static struct mmc_blk_data *mmc_blk_get(struct gendisk *disk) 131{ 132 struct mmc_blk_data *md; 133 134 mutex_lock(&open_lock); 135 md = disk->private_data; 136 if (md && md->usage == 0) 137 md = NULL; 138 if (md) 139 md->usage++; 140 mutex_unlock(&open_lock); 141 142 return md; 143} 144 145static inline int mmc_get_devidx(struct gendisk *disk) 146{ 147 int devmaj = MAJOR(disk_devt(disk)); 148 int devidx = MINOR(disk_devt(disk)) / perdev_minors; 149 150 if (!devmaj) 151 devidx = disk->first_minor / perdev_minors; 152 return devidx; 153} 154 155static void mmc_blk_put(struct mmc_blk_data *md) 156{ 157 mutex_lock(&open_lock); 158 md->usage--; 159 if (md->usage == 0) { 160 int devidx = mmc_get_devidx(md->disk); 161 blk_cleanup_queue(md->queue.queue); 162 163 __clear_bit(devidx, dev_use); 164 165 put_disk(md->disk); 166 kfree(md); 167 } 168 mutex_unlock(&open_lock); 169} 170 171static ssize_t power_ro_lock_show(struct device *dev, 172 struct device_attribute *attr, char *buf) 173{ 174 int ret; 175 struct mmc_blk_data *md = mmc_blk_get(dev_to_disk(dev)); 176 struct mmc_card *card = md->queue.card; 177 int locked = 0; 178 179 if (card->ext_csd.boot_ro_lock & EXT_CSD_BOOT_WP_B_PERM_WP_EN) 180 locked = 2; 181 else if (card->ext_csd.boot_ro_lock & EXT_CSD_BOOT_WP_B_PWR_WP_EN) 182 locked = 1; 183 184 ret = snprintf(buf, PAGE_SIZE, "%d\n", locked); 185 186 return ret; 187} 188 189static ssize_t power_ro_lock_store(struct device *dev, 190 struct device_attribute *attr, const char *buf, size_t count) 191{ 192 int ret; 193 struct mmc_blk_data *md, *part_md; 194 struct mmc_card *card; 195 unsigned long set; 196 197 if (kstrtoul(buf, 0, &set)) 198 return -EINVAL; 199 200 if (set != 1) 201 return count; 202 203 md = mmc_blk_get(dev_to_disk(dev)); 204 card = md->queue.card; 205 206 mmc_claim_host(card->host); 207 208 ret = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BOOT_WP, 209 card->ext_csd.boot_ro_lock | 210 EXT_CSD_BOOT_WP_B_PWR_WP_EN, 211 card->ext_csd.part_time); 212 if (ret) 213 pr_err("%s: Locking boot partition ro until next power on failed: %d\n", md->disk->disk_name, ret); 214 else 215 card->ext_csd.boot_ro_lock |= EXT_CSD_BOOT_WP_B_PWR_WP_EN; 216 217 mmc_release_host(card->host); 218 219 if (!ret) { 220 pr_info("%s: Locking boot partition ro until next power on\n", 221 md->disk->disk_name); 222 set_disk_ro(md->disk, 1); 223 224 list_for_each_entry(part_md, &md->part, part) 225 if (part_md->area_type == MMC_BLK_DATA_AREA_BOOT) { 226 pr_info("%s: Locking boot partition ro until next power on\n", part_md->disk->disk_name); 227 set_disk_ro(part_md->disk, 1); 228 } 229 } 230 231 mmc_blk_put(md); 232 return count; 233} 234 235static ssize_t force_ro_show(struct device *dev, struct device_attribute *attr, 236 char *buf) 237{ 238 int ret; 239 struct mmc_blk_data *md = mmc_blk_get(dev_to_disk(dev)); 240 241 ret = snprintf(buf, PAGE_SIZE, "%d", 242 get_disk_ro(dev_to_disk(dev)) ^ 243 md->read_only); 244 mmc_blk_put(md); 245 return ret; 246} 247 248static ssize_t force_ro_store(struct device *dev, struct device_attribute *attr, 249 const char *buf, size_t count) 250{ 251 int ret; 252 char *end; 253 struct mmc_blk_data *md = mmc_blk_get(dev_to_disk(dev)); 254 unsigned long set = simple_strtoul(buf, &end, 0); 255 if (end == buf) { 256 ret = -EINVAL; 257 goto out; 258 } 259 260 set_disk_ro(dev_to_disk(dev), set || md->read_only); 261 ret = count; 262out: 263 mmc_blk_put(md); 264 return ret; 265} 266 267static int mmc_blk_open(struct block_device *bdev, fmode_t mode) 268{ 269 struct mmc_blk_data *md = mmc_blk_get(bdev->bd_disk); 270 int ret = -ENXIO; 271 272 mutex_lock(&block_mutex); 273 if (md) { 274 if (md->usage == 2) 275 check_disk_change(bdev); 276 ret = 0; 277 278 if ((mode & FMODE_WRITE) && md->read_only) { 279 mmc_blk_put(md); 280 ret = -EROFS; 281 } 282 } 283 mutex_unlock(&block_mutex); 284 285 return ret; 286} 287 288static int mmc_blk_release(struct gendisk *disk, fmode_t mode) 289{ 290 struct mmc_blk_data *md = disk->private_data; 291 292 mutex_lock(&block_mutex); 293 mmc_blk_put(md); 294 mutex_unlock(&block_mutex); 295 return 0; 296} 297 298static int 299mmc_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo) 300{ 301 geo->cylinders = get_capacity(bdev->bd_disk) / (4 * 16); 302 geo->heads = 4; 303 geo->sectors = 16; 304 return 0; 305} 306 307struct mmc_blk_ioc_data { 308 struct mmc_ioc_cmd ic; 309 unsigned char *buf; 310 u64 buf_bytes; 311}; 312 313static struct mmc_blk_ioc_data *mmc_blk_ioctl_copy_from_user( 314 struct mmc_ioc_cmd __user *user) 315{ 316 struct mmc_blk_ioc_data *idata; 317 int err; 318 319 idata = kzalloc(sizeof(*idata), GFP_KERNEL); 320 if (!idata) { 321 err = -ENOMEM; 322 goto out; 323 } 324 325 if (copy_from_user(&idata->ic, user, sizeof(idata->ic))) { 326 err = -EFAULT; 327 goto idata_err; 328 } 329 330 idata->buf_bytes = (u64) idata->ic.blksz * idata->ic.blocks; 331 if (idata->buf_bytes > MMC_IOC_MAX_BYTES) { 332 err = -EOVERFLOW; 333 goto idata_err; 334 } 335 336 if (!idata->buf_bytes) 337 return idata; 338 339 idata->buf = kzalloc(idata->buf_bytes, GFP_KERNEL); 340 if (!idata->buf) { 341 err = -ENOMEM; 342 goto idata_err; 343 } 344 345 if (copy_from_user(idata->buf, (void __user *)(unsigned long) 346 idata->ic.data_ptr, idata->buf_bytes)) { 347 err = -EFAULT; 348 goto copy_err; 349 } 350 351 return idata; 352 353copy_err: 354 kfree(idata->buf); 355idata_err: 356 kfree(idata); 357out: 358 return ERR_PTR(err); 359} 360 361static int mmc_blk_ioctl_cmd(struct block_device *bdev, 362 struct mmc_ioc_cmd __user *ic_ptr) 363{ 364 struct mmc_blk_ioc_data *idata; 365 struct mmc_blk_data *md; 366 struct mmc_card *card; 367 struct mmc_command cmd = {0}; 368 struct mmc_data data = {0}; 369 struct mmc_request mrq = {NULL}; 370 struct scatterlist sg; 371 int err; 372 373 /* 374 * The caller must have CAP_SYS_RAWIO, and must be calling this on the 375 * whole block device, not on a partition. This prevents overspray 376 * between sibling partitions. 377 */ 378 if ((!capable(CAP_SYS_RAWIO)) || (bdev != bdev->bd_contains)) 379 return -EPERM; 380 381 idata = mmc_blk_ioctl_copy_from_user(ic_ptr); 382 if (IS_ERR(idata)) 383 return PTR_ERR(idata); 384 385 md = mmc_blk_get(bdev->bd_disk); 386 if (!md) { 387 err = -EINVAL; 388 goto cmd_err; 389 } 390 391 card = md->queue.card; 392 if (IS_ERR(card)) { 393 err = PTR_ERR(card); 394 goto cmd_done; 395 } 396 397 cmd.opcode = idata->ic.opcode; 398 cmd.arg = idata->ic.arg; 399 cmd.flags = idata->ic.flags; 400 401 if (idata->buf_bytes) { 402 data.sg = &sg; 403 data.sg_len = 1; 404 data.blksz = idata->ic.blksz; 405 data.blocks = idata->ic.blocks; 406 407 sg_init_one(data.sg, idata->buf, idata->buf_bytes); 408 409 if (idata->ic.write_flag) 410 data.flags = MMC_DATA_WRITE; 411 else 412 data.flags = MMC_DATA_READ; 413 414 /* data.flags must already be set before doing this. */ 415 mmc_set_data_timeout(&data, card); 416 417 /* Allow overriding the timeout_ns for empirical tuning. */ 418 if (idata->ic.data_timeout_ns) 419 data.timeout_ns = idata->ic.data_timeout_ns; 420 421 if ((cmd.flags & MMC_RSP_R1B) == MMC_RSP_R1B) { 422 /* 423 * Pretend this is a data transfer and rely on the 424 * host driver to compute timeout. When all host 425 * drivers support cmd.cmd_timeout for R1B, this 426 * can be changed to: 427 * 428 * mrq.data = NULL; 429 * cmd.cmd_timeout = idata->ic.cmd_timeout_ms; 430 */ 431 data.timeout_ns = idata->ic.cmd_timeout_ms * 1000000; 432 } 433 434 mrq.data = &data; 435 } 436 437 mrq.cmd = &cmd; 438 439 mmc_claim_host(card->host); 440 441 if (idata->ic.is_acmd) { 442 err = mmc_app_cmd(card->host, card); 443 if (err) 444 goto cmd_rel_host; 445 } 446 447 mmc_wait_for_req(card->host, &mrq); 448 449 if (cmd.error) { 450 dev_err(mmc_dev(card->host), "%s: cmd error %d\n", 451 __func__, cmd.error); 452 err = cmd.error; 453 goto cmd_rel_host; 454 } 455 if (data.error) { 456 dev_err(mmc_dev(card->host), "%s: data error %d\n", 457 __func__, data.error); 458 err = data.error; 459 goto cmd_rel_host; 460 } 461 462 /* 463 * According to the SD specs, some commands require a delay after 464 * issuing the command. 465 */ 466 if (idata->ic.postsleep_min_us) 467 usleep_range(idata->ic.postsleep_min_us, idata->ic.postsleep_max_us); 468 469 if (copy_to_user(&(ic_ptr->response), cmd.resp, sizeof(cmd.resp))) { 470 err = -EFAULT; 471 goto cmd_rel_host; 472 } 473 474 if (!idata->ic.write_flag) { 475 if (copy_to_user((void __user *)(unsigned long) idata->ic.data_ptr, 476 idata->buf, idata->buf_bytes)) { 477 err = -EFAULT; 478 goto cmd_rel_host; 479 } 480 } 481 482cmd_rel_host: 483 mmc_release_host(card->host); 484 485cmd_done: 486 mmc_blk_put(md); 487cmd_err: 488 kfree(idata->buf); 489 kfree(idata); 490 return err; 491} 492 493static int mmc_blk_ioctl(struct block_device *bdev, fmode_t mode, 494 unsigned int cmd, unsigned long arg) 495{ 496 int ret = -EINVAL; 497 if (cmd == MMC_IOC_CMD) 498 ret = mmc_blk_ioctl_cmd(bdev, (struct mmc_ioc_cmd __user *)arg); 499 return ret; 500} 501 502#ifdef CONFIG_COMPAT 503static int mmc_blk_compat_ioctl(struct block_device *bdev, fmode_t mode, 504 unsigned int cmd, unsigned long arg) 505{ 506 return mmc_blk_ioctl(bdev, mode, cmd, (unsigned long) compat_ptr(arg)); 507} 508#endif 509 510static const struct block_device_operations mmc_bdops = { 511 .open = mmc_blk_open, 512 .release = mmc_blk_release, 513 .getgeo = mmc_blk_getgeo, 514 .owner = THIS_MODULE, 515 .ioctl = mmc_blk_ioctl, 516#ifdef CONFIG_COMPAT 517 .compat_ioctl = mmc_blk_compat_ioctl, 518#endif 519}; 520 521static inline int mmc_blk_part_switch(struct mmc_card *card, 522 struct mmc_blk_data *md) 523{ 524 int ret; 525 struct mmc_blk_data *main_md = mmc_get_drvdata(card); 526 527 if (main_md->part_curr == md->part_type) 528 return 0; 529 530 if (mmc_card_mmc(card)) { 531 u8 part_config = card->ext_csd.part_config; 532 533 part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK; 534 part_config |= md->part_type; 535 536 ret = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 537 EXT_CSD_PART_CONFIG, part_config, 538 card->ext_csd.part_time); 539 if (ret) 540 return ret; 541 542 card->ext_csd.part_config = part_config; 543 } 544 545 main_md->part_curr = md->part_type; 546 return 0; 547} 548 549static u32 mmc_sd_num_wr_blocks(struct mmc_card *card) 550{ 551 int err; 552 u32 result; 553 __be32 *blocks; 554 555 struct mmc_request mrq = {NULL}; 556 struct mmc_command cmd = {0}; 557 struct mmc_data data = {0}; 558 559 struct scatterlist sg; 560 561 cmd.opcode = MMC_APP_CMD; 562 cmd.arg = card->rca << 16; 563 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 564 565 err = mmc_wait_for_cmd(card->host, &cmd, 0); 566 if (err) 567 return (u32)-1; 568 if (!mmc_host_is_spi(card->host) && !(cmd.resp[0] & R1_APP_CMD)) 569 return (u32)-1; 570 571 memset(&cmd, 0, sizeof(struct mmc_command)); 572 573 cmd.opcode = SD_APP_SEND_NUM_WR_BLKS; 574 cmd.arg = 0; 575 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; 576 577 data.blksz = 4; 578 data.blocks = 1; 579 data.flags = MMC_DATA_READ; 580 data.sg = &sg; 581 data.sg_len = 1; 582 mmc_set_data_timeout(&data, card); 583 584 mrq.cmd = &cmd; 585 mrq.data = &data; 586 587 blocks = kmalloc(4, GFP_KERNEL); 588 if (!blocks) 589 return (u32)-1; 590 591 sg_init_one(&sg, blocks, 4); 592 593 mmc_wait_for_req(card->host, &mrq); 594 595 result = ntohl(*blocks); 596 kfree(blocks); 597 598 if (cmd.error || data.error) 599 result = (u32)-1; 600 601 return result; 602} 603 604static int send_stop(struct mmc_card *card, u32 *status) 605{ 606 struct mmc_command cmd = {0}; 607 int err; 608 609 cmd.opcode = MMC_STOP_TRANSMISSION; 610 cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC; 611 err = mmc_wait_for_cmd(card->host, &cmd, 5); 612 if (err == 0) 613 *status = cmd.resp[0]; 614 return err; 615} 616 617static int get_card_status(struct mmc_card *card, u32 *status, int retries) 618{ 619 struct mmc_command cmd = {0}; 620 int err; 621 622 cmd.opcode = MMC_SEND_STATUS; 623 if (!mmc_host_is_spi(card->host)) 624 cmd.arg = card->rca << 16; 625 cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC; 626 err = mmc_wait_for_cmd(card->host, &cmd, retries); 627 if (err == 0) 628 *status = cmd.resp[0]; 629 return err; 630} 631 632#define ERR_NOMEDIUM 3 633#define ERR_RETRY 2 634#define ERR_ABORT 1 635#define ERR_CONTINUE 0 636 637static int mmc_blk_cmd_error(struct request *req, const char *name, int error, 638 bool status_valid, u32 status) 639{ 640 switch (error) { 641 case -EILSEQ: 642 /* response crc error, retry the r/w cmd */ 643 pr_err("%s: %s sending %s command, card status %#x\n", 644 req->rq_disk->disk_name, "response CRC error", 645 name, status); 646 return ERR_RETRY; 647 648 case -ETIMEDOUT: 649 pr_err("%s: %s sending %s command, card status %#x\n", 650 req->rq_disk->disk_name, "timed out", name, status); 651 652 /* If the status cmd initially failed, retry the r/w cmd */ 653 if (!status_valid) 654 return ERR_RETRY; 655 656 /* 657 * If it was a r/w cmd crc error, or illegal command 658 * (eg, issued in wrong state) then retry - we should 659 * have corrected the state problem above. 660 */ 661 if (status & (R1_COM_CRC_ERROR | R1_ILLEGAL_COMMAND)) 662 return ERR_RETRY; 663 664 /* Otherwise abort the command */ 665 return ERR_ABORT; 666 667 default: 668 /* We don't understand the error code the driver gave us */ 669 pr_err("%s: unknown error %d sending read/write command, card status %#x\n", 670 req->rq_disk->disk_name, error, status); 671 return ERR_ABORT; 672 } 673} 674 675/* 676 * Initial r/w and stop cmd error recovery. 677 * We don't know whether the card received the r/w cmd or not, so try to 678 * restore things back to a sane state. Essentially, we do this as follows: 679 * - Obtain card status. If the first attempt to obtain card status fails, 680 * the status word will reflect the failed status cmd, not the failed 681 * r/w cmd. If we fail to obtain card status, it suggests we can no 682 * longer communicate with the card. 683 * - Check the card state. If the card received the cmd but there was a 684 * transient problem with the response, it might still be in a data transfer 685 * mode. Try to send it a stop command. If this fails, we can't recover. 686 * - If the r/w cmd failed due to a response CRC error, it was probably 687 * transient, so retry the cmd. 688 * - If the r/w cmd timed out, but we didn't get the r/w cmd status, retry. 689 * - If the r/w cmd timed out, and the r/w cmd failed due to CRC error or 690 * illegal cmd, retry. 691 * Otherwise we don't understand what happened, so abort. 692 */ 693static int mmc_blk_cmd_recovery(struct mmc_card *card, struct request *req, 694 struct mmc_blk_request *brq, int *ecc_err) 695{ 696 bool prev_cmd_status_valid = true; 697 u32 status, stop_status = 0; 698 int err, retry; 699 700 if (mmc_card_removed(card)) 701 return ERR_NOMEDIUM; 702 703 /* 704 * Try to get card status which indicates both the card state 705 * and why there was no response. If the first attempt fails, 706 * we can't be sure the returned status is for the r/w command. 707 */ 708 for (retry = 2; retry >= 0; retry--) { 709 err = get_card_status(card, &status, 0); 710 if (!err) 711 break; 712 713 prev_cmd_status_valid = false; 714 pr_err("%s: error %d sending status command, %sing\n", 715 req->rq_disk->disk_name, err, retry ? "retry" : "abort"); 716 } 717 718 /* We couldn't get a response from the card. Give up. */ 719 if (err) { 720 /* Check if the card is removed */ 721 if (mmc_detect_card_removed(card->host)) 722 return ERR_NOMEDIUM; 723 return ERR_ABORT; 724 } 725 726 /* Flag ECC errors */ 727 if ((status & R1_CARD_ECC_FAILED) || 728 (brq->stop.resp[0] & R1_CARD_ECC_FAILED) || 729 (brq->cmd.resp[0] & R1_CARD_ECC_FAILED)) 730 *ecc_err = 1; 731 732 /* 733 * Check the current card state. If it is in some data transfer 734 * mode, tell it to stop (and hopefully transition back to TRAN.) 735 */ 736 if (R1_CURRENT_STATE(status) == R1_STATE_DATA || 737 R1_CURRENT_STATE(status) == R1_STATE_RCV) { 738 err = send_stop(card, &stop_status); 739 if (err) 740 pr_err("%s: error %d sending stop command\n", 741 req->rq_disk->disk_name, err); 742 743 /* 744 * If the stop cmd also timed out, the card is probably 745 * not present, so abort. Other errors are bad news too. 746 */ 747 if (err) 748 return ERR_ABORT; 749 if (stop_status & R1_CARD_ECC_FAILED) 750 *ecc_err = 1; 751 } 752 753 /* Check for set block count errors */ 754 if (brq->sbc.error) 755 return mmc_blk_cmd_error(req, "SET_BLOCK_COUNT", brq->sbc.error, 756 prev_cmd_status_valid, status); 757 758 /* Check for r/w command errors */ 759 if (brq->cmd.error) 760 return mmc_blk_cmd_error(req, "r/w cmd", brq->cmd.error, 761 prev_cmd_status_valid, status); 762 763 /* Data errors */ 764 if (!brq->stop.error) 765 return ERR_CONTINUE; 766 767 /* Now for stop errors. These aren't fatal to the transfer. */ 768 pr_err("%s: error %d sending stop command, original cmd response %#x, card status %#x\n", 769 req->rq_disk->disk_name, brq->stop.error, 770 brq->cmd.resp[0], status); 771 772 /* 773 * Subsitute in our own stop status as this will give the error 774 * state which happened during the execution of the r/w command. 775 */ 776 if (stop_status) { 777 brq->stop.resp[0] = stop_status; 778 brq->stop.error = 0; 779 } 780 return ERR_CONTINUE; 781} 782 783static int mmc_blk_reset(struct mmc_blk_data *md, struct mmc_host *host, 784 int type) 785{ 786 int err; 787 788 if (md->reset_done & type) 789 return -EEXIST; 790 791 md->reset_done |= type; 792 err = mmc_hw_reset(host); 793 /* Ensure we switch back to the correct partition */ 794 if (err != -EOPNOTSUPP) { 795 struct mmc_blk_data *main_md = mmc_get_drvdata(host->card); 796 int part_err; 797 798 main_md->part_curr = main_md->part_type; 799 part_err = mmc_blk_part_switch(host->card, md); 800 if (part_err) { 801 /* 802 * We have failed to get back into the correct 803 * partition, so we need to abort the whole request. 804 */ 805 return -ENODEV; 806 } 807 } 808 return err; 809} 810 811static inline void mmc_blk_reset_success(struct mmc_blk_data *md, int type) 812{ 813 md->reset_done &= ~type; 814} 815 816static int mmc_blk_issue_discard_rq(struct mmc_queue *mq, struct request *req) 817{ 818 struct mmc_blk_data *md = mq->data; 819 struct mmc_card *card = md->queue.card; 820 unsigned int from, nr, arg; 821 int err = 0, type = MMC_BLK_DISCARD; 822 823 if (!mmc_can_erase(card)) { 824 err = -EOPNOTSUPP; 825 goto out; 826 } 827 828 from = blk_rq_pos(req); 829 nr = blk_rq_sectors(req); 830 831 if (mmc_can_discard(card)) 832 arg = MMC_DISCARD_ARG; 833 else if (mmc_can_trim(card)) 834 arg = MMC_TRIM_ARG; 835 else 836 arg = MMC_ERASE_ARG; 837retry: 838 if (card->quirks & MMC_QUIRK_INAND_CMD38) { 839 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 840 INAND_CMD38_ARG_EXT_CSD, 841 arg == MMC_TRIM_ARG ? 842 INAND_CMD38_ARG_TRIM : 843 INAND_CMD38_ARG_ERASE, 844 0); 845 if (err) 846 goto out; 847 } 848 err = mmc_erase(card, from, nr, arg); 849out: 850 if (err == -EIO && !mmc_blk_reset(md, card->host, type)) 851 goto retry; 852 if (!err) 853 mmc_blk_reset_success(md, type); 854 blk_end_request(req, err, blk_rq_bytes(req)); 855 856 return err ? 0 : 1; 857} 858 859static int mmc_blk_issue_secdiscard_rq(struct mmc_queue *mq, 860 struct request *req) 861{ 862 struct mmc_blk_data *md = mq->data; 863 struct mmc_card *card = md->queue.card; 864 unsigned int from, nr, arg, trim_arg, erase_arg; 865 int err = 0, type = MMC_BLK_SECDISCARD; 866 867 if (!(mmc_can_secure_erase_trim(card) || mmc_can_sanitize(card))) { 868 err = -EOPNOTSUPP; 869 goto out; 870 } 871 872 from = blk_rq_pos(req); 873 nr = blk_rq_sectors(req); 874 875 /* The sanitize operation is supported at v4.5 only */ 876 if (mmc_can_sanitize(card)) { 877 erase_arg = MMC_ERASE_ARG; 878 trim_arg = MMC_TRIM_ARG; 879 } else { 880 erase_arg = MMC_SECURE_ERASE_ARG; 881 trim_arg = MMC_SECURE_TRIM1_ARG; 882 } 883 884 if (mmc_erase_group_aligned(card, from, nr)) 885 arg = erase_arg; 886 else if (mmc_can_trim(card)) 887 arg = trim_arg; 888 else { 889 err = -EINVAL; 890 goto out; 891 } 892retry: 893 if (card->quirks & MMC_QUIRK_INAND_CMD38) { 894 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 895 INAND_CMD38_ARG_EXT_CSD, 896 arg == MMC_SECURE_TRIM1_ARG ? 897 INAND_CMD38_ARG_SECTRIM1 : 898 INAND_CMD38_ARG_SECERASE, 899 0); 900 if (err) 901 goto out_retry; 902 } 903 904 err = mmc_erase(card, from, nr, arg); 905 if (err == -EIO) 906 goto out_retry; 907 if (err) 908 goto out; 909 910 if (arg == MMC_SECURE_TRIM1_ARG) { 911 if (card->quirks & MMC_QUIRK_INAND_CMD38) { 912 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 913 INAND_CMD38_ARG_EXT_CSD, 914 INAND_CMD38_ARG_SECTRIM2, 915 0); 916 if (err) 917 goto out_retry; 918 } 919 920 err = mmc_erase(card, from, nr, MMC_SECURE_TRIM2_ARG); 921 if (err == -EIO) 922 goto out_retry; 923 if (err) 924 goto out; 925 } 926 927 if (mmc_can_sanitize(card)) 928 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 929 EXT_CSD_SANITIZE_START, 1, 0); 930out_retry: 931 if (err && !mmc_blk_reset(md, card->host, type)) 932 goto retry; 933 if (!err) 934 mmc_blk_reset_success(md, type); 935out: 936 blk_end_request(req, err, blk_rq_bytes(req)); 937 938 return err ? 0 : 1; 939} 940 941static int mmc_blk_issue_flush(struct mmc_queue *mq, struct request *req) 942{ 943 struct mmc_blk_data *md = mq->data; 944 struct mmc_card *card = md->queue.card; 945 int ret = 0; 946 947 ret = mmc_flush_cache(card); 948 if (ret) 949 ret = -EIO; 950 951 blk_end_request_all(req, ret); 952 953 return ret ? 0 : 1; 954} 955 956/* 957 * Reformat current write as a reliable write, supporting 958 * both legacy and the enhanced reliable write MMC cards. 959 * In each transfer we'll handle only as much as a single 960 * reliable write can handle, thus finish the request in 961 * partial completions. 962 */ 963static inline void mmc_apply_rel_rw(struct mmc_blk_request *brq, 964 struct mmc_card *card, 965 struct request *req) 966{ 967 if (!(card->ext_csd.rel_param & EXT_CSD_WR_REL_PARAM_EN)) { 968 /* Legacy mode imposes restrictions on transfers. */ 969 if (!IS_ALIGNED(brq->cmd.arg, card->ext_csd.rel_sectors)) 970 brq->data.blocks = 1; 971 972 if (brq->data.blocks > card->ext_csd.rel_sectors) 973 brq->data.blocks = card->ext_csd.rel_sectors; 974 else if (brq->data.blocks < card->ext_csd.rel_sectors) 975 brq->data.blocks = 1; 976 } 977} 978 979#define CMD_ERRORS \ 980 (R1_OUT_OF_RANGE | /* Command argument out of range */ \ 981 R1_ADDRESS_ERROR | /* Misaligned address */ \ 982 R1_BLOCK_LEN_ERROR | /* Transferred block length incorrect */\ 983 R1_WP_VIOLATION | /* Tried to write to protected block */ \ 984 R1_CC_ERROR | /* Card controller error */ \ 985 R1_ERROR) /* General/unknown error */ 986 987static int mmc_blk_err_check(struct mmc_card *card, 988 struct mmc_async_req *areq) 989{ 990 struct mmc_queue_req *mq_mrq = container_of(areq, struct mmc_queue_req, 991 mmc_active); 992 struct mmc_blk_request *brq = &mq_mrq->brq; 993 struct request *req = mq_mrq->req; 994 int ecc_err = 0; 995 996 /* 997 * sbc.error indicates a problem with the set block count 998 * command. No data will have been transferred. 999 * 1000 * cmd.error indicates a problem with the r/w command. No 1001 * data will have been transferred. 1002 * 1003 * stop.error indicates a problem with the stop command. Data 1004 * may have been transferred, or may still be transferring. 1005 */ 1006 if (brq->sbc.error || brq->cmd.error || brq->stop.error || 1007 brq->data.error) { 1008 switch (mmc_blk_cmd_recovery(card, req, brq, &ecc_err)) { 1009 case ERR_RETRY: 1010 return MMC_BLK_RETRY; 1011 case ERR_ABORT: 1012 return MMC_BLK_ABORT; 1013 case ERR_NOMEDIUM: 1014 return MMC_BLK_NOMEDIUM; 1015 case ERR_CONTINUE: 1016 break; 1017 } 1018 } 1019 1020 /* 1021 * Check for errors relating to the execution of the 1022 * initial command - such as address errors. No data 1023 * has been transferred. 1024 */ 1025 if (brq->cmd.resp[0] & CMD_ERRORS) { 1026 pr_err("%s: r/w command failed, status = %#x\n", 1027 req->rq_disk->disk_name, brq->cmd.resp[0]); 1028 return MMC_BLK_ABORT; 1029 } 1030 1031 /* 1032 * Everything else is either success, or a data error of some 1033 * kind. If it was a write, we may have transitioned to 1034 * program mode, which we have to wait for it to complete. 1035 */ 1036 if (!mmc_host_is_spi(card->host) && rq_data_dir(req) != READ) { 1037 u32 status; 1038 unsigned long timeout; 1039 1040 timeout = jiffies + msecs_to_jiffies(MMC_BLK_TIMEOUT_MS); 1041 do { 1042 int err = get_card_status(card, &status, 5); 1043 if (err) { 1044 pr_err("%s: error %d requesting status\n", 1045 req->rq_disk->disk_name, err); 1046 return MMC_BLK_CMD_ERR; 1047 } 1048 1049 /* Timeout if the device never becomes ready for data 1050 * and never leaves the program state. 1051 */ 1052 if (time_after(jiffies, timeout)) { 1053 pr_err("%s: Card stuck in programming state!"\ 1054 " %s %s\n", mmc_hostname(card->host), 1055 req->rq_disk->disk_name, __func__); 1056 1057 return MMC_BLK_CMD_ERR; 1058 } 1059 /* 1060 * Some cards mishandle the status bits, 1061 * so make sure to check both the busy 1062 * indication and the card state. 1063 */ 1064 } while (!(status & R1_READY_FOR_DATA) || 1065 (R1_CURRENT_STATE(status) == R1_STATE_PRG)); 1066 } 1067 1068 if (brq->data.error) { 1069 pr_err("%s: error %d transferring data, sector %u, nr %u, cmd response %#x, card status %#x\n", 1070 req->rq_disk->disk_name, brq->data.error, 1071 (unsigned)blk_rq_pos(req), 1072 (unsigned)blk_rq_sectors(req), 1073 brq->cmd.resp[0], brq->stop.resp[0]); 1074 1075 if (rq_data_dir(req) == READ) { 1076 if (ecc_err) 1077 return MMC_BLK_ECC_ERR; 1078 return MMC_BLK_DATA_ERR; 1079 } else { 1080 return MMC_BLK_CMD_ERR; 1081 } 1082 } 1083 1084 if (!brq->data.bytes_xfered) 1085 return MMC_BLK_RETRY; 1086 1087 if (blk_rq_bytes(req) != brq->data.bytes_xfered) 1088 return MMC_BLK_PARTIAL; 1089 1090 return MMC_BLK_SUCCESS; 1091} 1092 1093static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq, 1094 struct mmc_card *card, 1095 int disable_multi, 1096 struct mmc_queue *mq) 1097{ 1098 u32 readcmd, writecmd; 1099 struct mmc_blk_request *brq = &mqrq->brq; 1100 struct request *req = mqrq->req; 1101 struct mmc_blk_data *md = mq->data; 1102 bool do_data_tag; 1103 1104 /* 1105 * Reliable writes are used to implement Forced Unit Access and 1106 * REQ_META accesses, and are supported only on MMCs. 1107 * 1108 * XXX: this really needs a good explanation of why REQ_META 1109 * is treated special. 1110 */ 1111 bool do_rel_wr = ((req->cmd_flags & REQ_FUA) || 1112 (req->cmd_flags & REQ_META)) && 1113 (rq_data_dir(req) == WRITE) && 1114 (md->flags & MMC_BLK_REL_WR); 1115 1116 memset(brq, 0, sizeof(struct mmc_blk_request)); 1117 brq->mrq.cmd = &brq->cmd; 1118 brq->mrq.data = &brq->data; 1119 1120 brq->cmd.arg = blk_rq_pos(req); 1121 if (!mmc_card_blockaddr(card)) 1122 brq->cmd.arg <<= 9; 1123 brq->cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; 1124 brq->data.blksz = 512; 1125 brq->stop.opcode = MMC_STOP_TRANSMISSION; 1126 brq->stop.arg = 0; 1127 brq->stop.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC; 1128 brq->data.blocks = blk_rq_sectors(req); 1129 1130 /* 1131 * The block layer doesn't support all sector count 1132 * restrictions, so we need to be prepared for too big 1133 * requests. 1134 */ 1135 if (brq->data.blocks > card->host->max_blk_count) 1136 brq->data.blocks = card->host->max_blk_count; 1137 1138 if (brq->data.blocks > 1) { 1139 /* 1140 * After a read error, we redo the request one sector 1141 * at a time in order to accurately determine which 1142 * sectors can be read successfully. 1143 */ 1144 if (disable_multi) 1145 brq->data.blocks = 1; 1146 1147 /* Some controllers can't do multiblock reads due to hw bugs */ 1148 if (card->host->caps2 & MMC_CAP2_NO_MULTI_READ && 1149 rq_data_dir(req) == READ) 1150 brq->data.blocks = 1; 1151 } 1152 1153 if (brq->data.blocks > 1 || do_rel_wr) { 1154 /* SPI multiblock writes terminate using a special 1155 * token, not a STOP_TRANSMISSION request. 1156 */ 1157 if (!mmc_host_is_spi(card->host) || 1158 rq_data_dir(req) == READ) 1159 brq->mrq.stop = &brq->stop; 1160 readcmd = MMC_READ_MULTIPLE_BLOCK; 1161 writecmd = MMC_WRITE_MULTIPLE_BLOCK; 1162 } else { 1163 brq->mrq.stop = NULL; 1164 readcmd = MMC_READ_SINGLE_BLOCK; 1165 writecmd = MMC_WRITE_BLOCK; 1166 } 1167 if (rq_data_dir(req) == READ) { 1168 brq->cmd.opcode = readcmd; 1169 brq->data.flags |= MMC_DATA_READ; 1170 } else { 1171 brq->cmd.opcode = writecmd; 1172 brq->data.flags |= MMC_DATA_WRITE; 1173 } 1174 1175 if (do_rel_wr) 1176 mmc_apply_rel_rw(brq, card, req); 1177 1178 /* 1179 * Data tag is used only during writing meta data to speed 1180 * up write and any subsequent read of this meta data 1181 */ 1182 do_data_tag = (card->ext_csd.data_tag_unit_size) && 1183 (req->cmd_flags & REQ_META) && 1184 (rq_data_dir(req) == WRITE) && 1185 ((brq->data.blocks * brq->data.blksz) >= 1186 card->ext_csd.data_tag_unit_size); 1187 1188 /* 1189 * Pre-defined multi-block transfers are preferable to 1190 * open ended-ones (and necessary for reliable writes). 1191 * However, it is not sufficient to just send CMD23, 1192 * and avoid the final CMD12, as on an error condition 1193 * CMD12 (stop) needs to be sent anyway. This, coupled 1194 * with Auto-CMD23 enhancements provided by some 1195 * hosts, means that the complexity of dealing 1196 * with this is best left to the host. If CMD23 is 1197 * supported by card and host, we'll fill sbc in and let 1198 * the host deal with handling it correctly. This means 1199 * that for hosts that don't expose MMC_CAP_CMD23, no 1200 * change of behavior will be observed. 1201 * 1202 * N.B: Some MMC cards experience perf degradation. 1203 * We'll avoid using CMD23-bounded multiblock writes for 1204 * these, while retaining features like reliable writes. 1205 */ 1206 if ((md->flags & MMC_BLK_CMD23) && mmc_op_multi(brq->cmd.opcode) && 1207 (do_rel_wr || !(card->quirks & MMC_QUIRK_BLK_NO_CMD23) || 1208 do_data_tag)) { 1209 brq->sbc.opcode = MMC_SET_BLOCK_COUNT; 1210 brq->sbc.arg = brq->data.blocks | 1211 (do_rel_wr ? (1 << 31) : 0) | 1212 (do_data_tag ? (1 << 29) : 0); 1213 brq->sbc.flags = MMC_RSP_R1 | MMC_CMD_AC; 1214 brq->mrq.sbc = &brq->sbc; 1215 } 1216 1217 mmc_set_data_timeout(&brq->data, card); 1218 1219 brq->data.sg = mqrq->sg; 1220 brq->data.sg_len = mmc_queue_map_sg(mq, mqrq); 1221 1222 /* 1223 * Adjust the sg list so it is the same size as the 1224 * request. 1225 */ 1226 if (brq->data.blocks != blk_rq_sectors(req)) { 1227 int i, data_size = brq->data.blocks << 9; 1228 struct scatterlist *sg; 1229 1230 for_each_sg(brq->data.sg, sg, brq->data.sg_len, i) { 1231 data_size -= sg->length; 1232 if (data_size <= 0) { 1233 sg->length += data_size; 1234 i++; 1235 break; 1236 } 1237 } 1238 brq->data.sg_len = i; 1239 } 1240 1241 mqrq->mmc_active.mrq = &brq->mrq; 1242 mqrq->mmc_active.err_check = mmc_blk_err_check; 1243 1244 mmc_queue_bounce_pre(mqrq); 1245} 1246 1247static int mmc_blk_cmd_err(struct mmc_blk_data *md, struct mmc_card *card, 1248 struct mmc_blk_request *brq, struct request *req, 1249 int ret) 1250{ 1251 /* 1252 * If this is an SD card and we're writing, we can first 1253 * mark the known good sectors as ok. 1254 * 1255 * If the card is not SD, we can still ok written sectors 1256 * as reported by the controller (which might be less than 1257 * the real number of written sectors, but never more). 1258 */ 1259 if (mmc_card_sd(card)) { 1260 u32 blocks; 1261 1262 blocks = mmc_sd_num_wr_blocks(card); 1263 if (blocks != (u32)-1) { 1264 ret = blk_end_request(req, 0, blocks << 9); 1265 } 1266 } else { 1267 ret = blk_end_request(req, 0, brq->data.bytes_xfered); 1268 } 1269 return ret; 1270} 1271 1272static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc) 1273{ 1274 struct mmc_blk_data *md = mq->data; 1275 struct mmc_card *card = md->queue.card; 1276 struct mmc_blk_request *brq = &mq->mqrq_cur->brq; 1277 int ret = 1, disable_multi = 0, retry = 0, type; 1278 enum mmc_blk_status status; 1279 struct mmc_queue_req *mq_rq; 1280 struct request *req = rqc; 1281 struct mmc_async_req *areq; 1282 1283 if (!rqc && !mq->mqrq_prev->req) 1284 return 0; 1285 1286 do { 1287 if (rqc) { 1288 /* 1289 * When 4KB native sector is enabled, only 8 blocks 1290 * multiple read or write is allowed 1291 */ 1292 if ((brq->data.blocks & 0x07) && 1293 (card->ext_csd.data_sector_size == 4096)) { 1294 pr_err("%s: Transfer size is not 4KB sector size aligned\n", 1295 req->rq_disk->disk_name); 1296 goto cmd_abort; 1297 } 1298 mmc_blk_rw_rq_prep(mq->mqrq_cur, card, 0, mq); 1299 areq = &mq->mqrq_cur->mmc_active; 1300 } else 1301 areq = NULL; 1302 areq = mmc_start_req(card->host, areq, (int *) &status); 1303 if (!areq) 1304 return 0; 1305 1306 mq_rq = container_of(areq, struct mmc_queue_req, mmc_active); 1307 brq = &mq_rq->brq; 1308 req = mq_rq->req; 1309 type = rq_data_dir(req) == READ ? MMC_BLK_READ : MMC_BLK_WRITE; 1310 mmc_queue_bounce_post(mq_rq); 1311 1312 switch (status) { 1313 case MMC_BLK_SUCCESS: 1314 case MMC_BLK_PARTIAL: 1315 /* 1316 * A block was successfully transferred. 1317 */ 1318 mmc_blk_reset_success(md, type); 1319 ret = blk_end_request(req, 0, 1320 brq->data.bytes_xfered); 1321 /* 1322 * If the blk_end_request function returns non-zero even 1323 * though all data has been transferred and no errors 1324 * were returned by the host controller, it's a bug. 1325 */ 1326 if (status == MMC_BLK_SUCCESS && ret) { 1327 pr_err("%s BUG rq_tot %d d_xfer %d\n", 1328 __func__, blk_rq_bytes(req), 1329 brq->data.bytes_xfered); 1330 rqc = NULL; 1331 goto cmd_abort; 1332 } 1333 break; 1334 case MMC_BLK_CMD_ERR: 1335 ret = mmc_blk_cmd_err(md, card, brq, req, ret); 1336 if (!mmc_blk_reset(md, card->host, type)) 1337 break; 1338 goto cmd_abort; 1339 case MMC_BLK_RETRY: 1340 if (retry++ < 5) 1341 break; 1342 /* Fall through */ 1343 case MMC_BLK_ABORT: 1344 if (!mmc_blk_reset(md, card->host, type)) 1345 break; 1346 goto cmd_abort; 1347 case MMC_BLK_DATA_ERR: { 1348 int err; 1349 1350 err = mmc_blk_reset(md, card->host, type); 1351 if (!err) 1352 break; 1353 if (err == -ENODEV) 1354 goto cmd_abort; 1355 /* Fall through */ 1356 } 1357 case MMC_BLK_ECC_ERR: 1358 if (brq->data.blocks > 1) { 1359 /* Redo read one sector at a time */ 1360 pr_warning("%s: retrying using single block read\n", 1361 req->rq_disk->disk_name); 1362 disable_multi = 1; 1363 break; 1364 } 1365 /* 1366 * After an error, we redo I/O one sector at a 1367 * time, so we only reach here after trying to 1368 * read a single sector. 1369 */ 1370 ret = blk_end_request(req, -EIO, 1371 brq->data.blksz); 1372 if (!ret) 1373 goto start_new_req; 1374 break; 1375 case MMC_BLK_NOMEDIUM: 1376 goto cmd_abort; 1377 } 1378 1379 if (ret) { 1380 /* 1381 * In case of a incomplete request 1382 * prepare it again and resend. 1383 */ 1384 mmc_blk_rw_rq_prep(mq_rq, card, disable_multi, mq); 1385 mmc_start_req(card->host, &mq_rq->mmc_active, NULL); 1386 } 1387 } while (ret); 1388 1389 return 1; 1390 1391 cmd_abort: 1392 if (mmc_card_removed(card)) 1393 req->cmd_flags |= REQ_QUIET; 1394 while (ret) 1395 ret = blk_end_request(req, -EIO, blk_rq_cur_bytes(req)); 1396 1397 start_new_req: 1398 if (rqc) { 1399 mmc_blk_rw_rq_prep(mq->mqrq_cur, card, 0, mq); 1400 mmc_start_req(card->host, &mq->mqrq_cur->mmc_active, NULL); 1401 } 1402 1403 return 0; 1404} 1405 1406static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req) 1407{ 1408 int ret; 1409 struct mmc_blk_data *md = mq->data; 1410 struct mmc_card *card = md->queue.card; 1411 1412 if (req && !mq->mqrq_prev->req) 1413 /* claim host only for the first request */ 1414 mmc_claim_host(card->host); 1415 1416 ret = mmc_blk_part_switch(card, md); 1417 if (ret) { 1418 if (req) { 1419 blk_end_request_all(req, -EIO); 1420 } 1421 ret = 0; 1422 goto out; 1423 } 1424 1425 if (req && req->cmd_flags & REQ_DISCARD) { 1426 /* complete ongoing async transfer before issuing discard */ 1427 if (card->host->areq) 1428 mmc_blk_issue_rw_rq(mq, NULL); 1429 if (req->cmd_flags & REQ_SECURE && 1430 !(card->quirks & MMC_QUIRK_SEC_ERASE_TRIM_BROKEN)) 1431 ret = mmc_blk_issue_secdiscard_rq(mq, req); 1432 else 1433 ret = mmc_blk_issue_discard_rq(mq, req); 1434 } else if (req && req->cmd_flags & REQ_FLUSH) { 1435 /* complete ongoing async transfer before issuing flush */ 1436 if (card->host->areq) 1437 mmc_blk_issue_rw_rq(mq, NULL); 1438 ret = mmc_blk_issue_flush(mq, req); 1439 } else { 1440 ret = mmc_blk_issue_rw_rq(mq, req); 1441 } 1442 1443out: 1444 if (!req) 1445 /* release host only when there are no more requests */ 1446 mmc_release_host(card->host); 1447 return ret; 1448} 1449 1450static inline int mmc_blk_readonly(struct mmc_card *card) 1451{ 1452 return mmc_card_readonly(card) || 1453 !(card->csd.cmdclass & CCC_BLOCK_WRITE); 1454} 1455 1456static struct mmc_blk_data *mmc_blk_alloc_req(struct mmc_card *card, 1457 struct device *parent, 1458 sector_t size, 1459 bool default_ro, 1460 const char *subname, 1461 int area_type) 1462{ 1463 struct mmc_blk_data *md; 1464 int devidx, ret; 1465 1466 devidx = find_first_zero_bit(dev_use, max_devices); 1467 if (devidx >= max_devices) 1468 return ERR_PTR(-ENOSPC); 1469 __set_bit(devidx, dev_use); 1470 1471 md = kzalloc(sizeof(struct mmc_blk_data), GFP_KERNEL); 1472 if (!md) { 1473 ret = -ENOMEM; 1474 goto out; 1475 } 1476 1477 /* 1478 * !subname implies we are creating main mmc_blk_data that will be 1479 * associated with mmc_card with mmc_set_drvdata. Due to device 1480 * partitions, devidx will not coincide with a per-physical card 1481 * index anymore so we keep track of a name index. 1482 */ 1483 if (!subname) { 1484 md->name_idx = find_first_zero_bit(name_use, max_devices); 1485 __set_bit(md->name_idx, name_use); 1486 } else 1487 md->name_idx = ((struct mmc_blk_data *) 1488 dev_to_disk(parent)->private_data)->name_idx; 1489 1490 md->area_type = area_type; 1491 1492 /* 1493 * Set the read-only status based on the supported commands 1494 * and the write protect switch. 1495 */ 1496 md->read_only = mmc_blk_readonly(card); 1497 1498 md->disk = alloc_disk(perdev_minors); 1499 if (md->disk == NULL) { 1500 ret = -ENOMEM; 1501 goto err_kfree; 1502 } 1503 1504 spin_lock_init(&md->lock); 1505 INIT_LIST_HEAD(&md->part); 1506 md->usage = 1; 1507 1508 ret = mmc_init_queue(&md->queue, card, &md->lock, subname); 1509 if (ret) 1510 goto err_putdisk; 1511 1512 md->queue.issue_fn = mmc_blk_issue_rq; 1513 md->queue.data = md; 1514 1515 md->disk->major = MMC_BLOCK_MAJOR; 1516 md->disk->first_minor = devidx * perdev_minors; 1517 md->disk->fops = &mmc_bdops; 1518 md->disk->private_data = md; 1519 md->disk->queue = md->queue.queue; 1520 md->disk->driverfs_dev = parent; 1521 set_disk_ro(md->disk, md->read_only || default_ro); 1522 if (area_type & MMC_BLK_DATA_AREA_RPMB) 1523 md->disk->flags |= GENHD_FL_NO_PART_SCAN; 1524 1525 /* 1526 * As discussed on lkml, GENHD_FL_REMOVABLE should: 1527 * 1528 * - be set for removable media with permanent block devices 1529 * - be unset for removable block devices with permanent media 1530 * 1531 * Since MMC block devices clearly fall under the second 1532 * case, we do not set GENHD_FL_REMOVABLE. Userspace 1533 * should use the block device creation/destruction hotplug 1534 * messages to tell when the card is present. 1535 */ 1536 1537 snprintf(md->disk->disk_name, sizeof(md->disk->disk_name), 1538 "mmcblk%d%s", md->name_idx, subname ? subname : ""); 1539 1540 if (mmc_card_mmc(card)) 1541 blk_queue_logical_block_size(md->queue.queue, 1542 card->ext_csd.data_sector_size); 1543 else 1544 blk_queue_logical_block_size(md->queue.queue, 512); 1545 1546 set_capacity(md->disk, size); 1547 1548 if (mmc_host_cmd23(card->host)) { 1549 if (mmc_card_mmc(card) || 1550 (mmc_card_sd(card) && 1551 card->scr.cmds & SD_SCR_CMD23_SUPPORT)) 1552 md->flags |= MMC_BLK_CMD23; 1553 } 1554 1555 if (mmc_card_mmc(card) && 1556 md->flags & MMC_BLK_CMD23 && 1557 ((card->ext_csd.rel_param & EXT_CSD_WR_REL_PARAM_EN) || 1558 card->ext_csd.rel_sectors)) { 1559 md->flags |= MMC_BLK_REL_WR; 1560 blk_queue_flush(md->queue.queue, REQ_FLUSH | REQ_FUA); 1561 } 1562 1563 return md; 1564 1565 err_putdisk: 1566 put_disk(md->disk); 1567 err_kfree: 1568 kfree(md); 1569 out: 1570 return ERR_PTR(ret); 1571} 1572 1573static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card) 1574{ 1575 sector_t size; 1576 struct mmc_blk_data *md; 1577 1578 if (!mmc_card_sd(card) && mmc_card_blockaddr(card)) { 1579 /* 1580 * The EXT_CSD sector count is in number or 512 byte 1581 * sectors. 1582 */ 1583 size = card->ext_csd.sectors; 1584 } else { 1585 /* 1586 * The CSD capacity field is in units of read_blkbits. 1587 * set_capacity takes units of 512 bytes. 1588 */ 1589 size = card->csd.capacity << (card->csd.read_blkbits - 9); 1590 } 1591 1592 md = mmc_blk_alloc_req(card, &card->dev, size, false, NULL, 1593 MMC_BLK_DATA_AREA_MAIN); 1594 return md; 1595} 1596 1597static int mmc_blk_alloc_part(struct mmc_card *card, 1598 struct mmc_blk_data *md, 1599 unsigned int part_type, 1600 sector_t size, 1601 bool default_ro, 1602 const char *subname, 1603 int area_type) 1604{ 1605 char cap_str[10]; 1606 struct mmc_blk_data *part_md; 1607 1608 part_md = mmc_blk_alloc_req(card, disk_to_dev(md->disk), size, default_ro, 1609 subname, area_type); 1610 if (IS_ERR(part_md)) 1611 return PTR_ERR(part_md); 1612 part_md->part_type = part_type; 1613 list_add(&part_md->part, &md->part); 1614 1615 string_get_size((u64)get_capacity(part_md->disk) << 9, STRING_UNITS_2, 1616 cap_str, sizeof(cap_str)); 1617 pr_info("%s: %s %s partition %u %s\n", 1618 part_md->disk->disk_name, mmc_card_id(card), 1619 mmc_card_name(card), part_md->part_type, cap_str); 1620 return 0; 1621} 1622 1623/* MMC Physical partitions consist of two boot partitions and 1624 * up to four general purpose partitions. 1625 * For each partition enabled in EXT_CSD a block device will be allocatedi 1626 * to provide access to the partition. 1627 */ 1628 1629static int mmc_blk_alloc_parts(struct mmc_card *card, struct mmc_blk_data *md) 1630{ 1631 int idx, ret = 0; 1632 1633 if (!mmc_card_mmc(card)) 1634 return 0; 1635 1636 for (idx = 0; idx < card->nr_parts; idx++) { 1637 if (card->part[idx].size) { 1638 ret = mmc_blk_alloc_part(card, md, 1639 card->part[idx].part_cfg, 1640 card->part[idx].size >> 9, 1641 card->part[idx].force_ro, 1642 card->part[idx].name, 1643 card->part[idx].area_type); 1644 if (ret) 1645 return ret; 1646 } 1647 } 1648 1649 return ret; 1650} 1651 1652static void mmc_blk_remove_req(struct mmc_blk_data *md) 1653{ 1654 struct mmc_card *card; 1655 1656 if (md) { 1657 card = md->queue.card; 1658 if (md->disk->flags & GENHD_FL_UP) { 1659 device_remove_file(disk_to_dev(md->disk), &md->force_ro); 1660 if ((md->area_type & MMC_BLK_DATA_AREA_BOOT) && 1661 card->ext_csd.boot_ro_lockable) 1662 device_remove_file(disk_to_dev(md->disk), 1663 &md->power_ro_lock); 1664 1665 /* Stop new requests from getting into the queue */ 1666 del_gendisk(md->disk); 1667 } 1668 1669 /* Then flush out any already in there */ 1670 mmc_cleanup_queue(&md->queue); 1671 mmc_blk_put(md); 1672 } 1673} 1674 1675static void mmc_blk_remove_parts(struct mmc_card *card, 1676 struct mmc_blk_data *md) 1677{ 1678 struct list_head *pos, *q; 1679 struct mmc_blk_data *part_md; 1680 1681 __clear_bit(md->name_idx, name_use); 1682 list_for_each_safe(pos, q, &md->part) { 1683 part_md = list_entry(pos, struct mmc_blk_data, part); 1684 list_del(pos); 1685 mmc_blk_remove_req(part_md); 1686 } 1687} 1688 1689static int mmc_add_disk(struct mmc_blk_data *md) 1690{ 1691 int ret; 1692 struct mmc_card *card = md->queue.card; 1693 1694 add_disk(md->disk); 1695 md->force_ro.show = force_ro_show; 1696 md->force_ro.store = force_ro_store; 1697 sysfs_attr_init(&md->force_ro.attr); 1698 md->force_ro.attr.name = "force_ro"; 1699 md->force_ro.attr.mode = S_IRUGO | S_IWUSR; 1700 ret = device_create_file(disk_to_dev(md->disk), &md->force_ro); 1701 if (ret) 1702 goto force_ro_fail; 1703 1704 if ((md->area_type & MMC_BLK_DATA_AREA_BOOT) && 1705 card->ext_csd.boot_ro_lockable) { 1706 umode_t mode; 1707 1708 if (card->ext_csd.boot_ro_lock & EXT_CSD_BOOT_WP_B_PWR_WP_DIS) 1709 mode = S_IRUGO; 1710 else 1711 mode = S_IRUGO | S_IWUSR; 1712 1713 md->power_ro_lock.show = power_ro_lock_show; 1714 md->power_ro_lock.store = power_ro_lock_store; 1715 sysfs_attr_init(&md->power_ro_lock.attr); 1716 md->power_ro_lock.attr.mode = mode; 1717 md->power_ro_lock.attr.name = 1718 "ro_lock_until_next_power_on"; 1719 ret = device_create_file(disk_to_dev(md->disk), 1720 &md->power_ro_lock); 1721 if (ret) 1722 goto power_ro_lock_fail; 1723 } 1724 return ret; 1725 1726power_ro_lock_fail: 1727 device_remove_file(disk_to_dev(md->disk), &md->force_ro); 1728force_ro_fail: 1729 del_gendisk(md->disk); 1730 1731 return ret; 1732} 1733 1734#define CID_MANFID_SANDISK 0x2 1735#define CID_MANFID_TOSHIBA 0x11 1736#define CID_MANFID_MICRON 0x13 1737#define CID_MANFID_SAMSUNG 0x15 1738 1739static const struct mmc_fixup blk_fixups[] = 1740{ 1741 MMC_FIXUP("SEM02G", CID_MANFID_SANDISK, 0x100, add_quirk, 1742 MMC_QUIRK_INAND_CMD38), 1743 MMC_FIXUP("SEM04G", CID_MANFID_SANDISK, 0x100, add_quirk, 1744 MMC_QUIRK_INAND_CMD38), 1745 MMC_FIXUP("SEM08G", CID_MANFID_SANDISK, 0x100, add_quirk, 1746 MMC_QUIRK_INAND_CMD38), 1747 MMC_FIXUP("SEM16G", CID_MANFID_SANDISK, 0x100, add_quirk, 1748 MMC_QUIRK_INAND_CMD38), 1749 MMC_FIXUP("SEM32G", CID_MANFID_SANDISK, 0x100, add_quirk, 1750 MMC_QUIRK_INAND_CMD38), 1751 1752 /* 1753 * Some MMC cards experience performance degradation with CMD23 1754 * instead of CMD12-bounded multiblock transfers. For now we'll 1755 * black list what's bad... 1756 * - Certain Toshiba cards. 1757 * 1758 * N.B. This doesn't affect SD cards. 1759 */ 1760 MMC_FIXUP("MMC08G", CID_MANFID_TOSHIBA, CID_OEMID_ANY, add_quirk_mmc, 1761 MMC_QUIRK_BLK_NO_CMD23), 1762 MMC_FIXUP("MMC16G", CID_MANFID_TOSHIBA, CID_OEMID_ANY, add_quirk_mmc, 1763 MMC_QUIRK_BLK_NO_CMD23), 1764 MMC_FIXUP("MMC32G", CID_MANFID_TOSHIBA, CID_OEMID_ANY, add_quirk_mmc, 1765 MMC_QUIRK_BLK_NO_CMD23), 1766 1767 /* 1768 * Some Micron MMC cards needs longer data read timeout than 1769 * indicated in CSD. 1770 */ 1771 MMC_FIXUP(CID_NAME_ANY, CID_MANFID_MICRON, 0x200, add_quirk_mmc, 1772 MMC_QUIRK_LONG_READ_TIME), 1773 1774 /* 1775 * On these Samsung MoviNAND parts, performing secure erase or 1776 * secure trim can result in unrecoverable corruption due to a 1777 * firmware bug. 1778 */ 1779 MMC_FIXUP("M8G2FA", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc, 1780 MMC_QUIRK_SEC_ERASE_TRIM_BROKEN), 1781 MMC_FIXUP("MAG4FA", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc, 1782 MMC_QUIRK_SEC_ERASE_TRIM_BROKEN), 1783 MMC_FIXUP("MBG8FA", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc, 1784 MMC_QUIRK_SEC_ERASE_TRIM_BROKEN), 1785 MMC_FIXUP("MCGAFA", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc, 1786 MMC_QUIRK_SEC_ERASE_TRIM_BROKEN), 1787 MMC_FIXUP("VAL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc, 1788 MMC_QUIRK_SEC_ERASE_TRIM_BROKEN), 1789 MMC_FIXUP("VYL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc, 1790 MMC_QUIRK_SEC_ERASE_TRIM_BROKEN), 1791 MMC_FIXUP("KYL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc, 1792 MMC_QUIRK_SEC_ERASE_TRIM_BROKEN), 1793 MMC_FIXUP("VZL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc, 1794 MMC_QUIRK_SEC_ERASE_TRIM_BROKEN), 1795 1796 END_FIXUP 1797}; 1798 1799static int mmc_blk_probe(struct mmc_card *card) 1800{ 1801 struct mmc_blk_data *md, *part_md; 1802 char cap_str[10]; 1803 1804 /* 1805 * Check that the card supports the command class(es) we need. 1806 */ 1807 if (!(card->csd.cmdclass & CCC_BLOCK_READ)) 1808 return -ENODEV; 1809 1810 md = mmc_blk_alloc(card); 1811 if (IS_ERR(md)) 1812 return PTR_ERR(md); 1813 1814 string_get_size((u64)get_capacity(md->disk) << 9, STRING_UNITS_2, 1815 cap_str, sizeof(cap_str)); 1816 pr_info("%s: %s %s %s %s\n", 1817 md->disk->disk_name, mmc_card_id(card), mmc_card_name(card), 1818 cap_str, md->read_only ? "(ro)" : ""); 1819 1820 if (mmc_blk_alloc_parts(card, md)) 1821 goto out; 1822 1823 mmc_set_drvdata(card, md); 1824 mmc_fixup_device(card, blk_fixups); 1825 1826 if (mmc_add_disk(md)) 1827 goto out; 1828 1829 list_for_each_entry(part_md, &md->part, part) { 1830 if (mmc_add_disk(part_md)) 1831 goto out; 1832 } 1833 return 0; 1834 1835 out: 1836 mmc_blk_remove_parts(card, md); 1837 mmc_blk_remove_req(md); 1838 return 0; 1839} 1840 1841static void mmc_blk_remove(struct mmc_card *card) 1842{ 1843 struct mmc_blk_data *md = mmc_get_drvdata(card); 1844 1845 mmc_blk_remove_parts(card, md); 1846 mmc_claim_host(card->host); 1847 mmc_blk_part_switch(card, md); 1848 mmc_release_host(card->host); 1849 mmc_blk_remove_req(md); 1850 mmc_set_drvdata(card, NULL); 1851} 1852 1853#ifdef CONFIG_PM 1854static int mmc_blk_suspend(struct mmc_card *card) 1855{ 1856 struct mmc_blk_data *part_md; 1857 struct mmc_blk_data *md = mmc_get_drvdata(card); 1858 1859 if (md) { 1860 mmc_queue_suspend(&md->queue); 1861 list_for_each_entry(part_md, &md->part, part) { 1862 mmc_queue_suspend(&part_md->queue); 1863 } 1864 } 1865 return 0; 1866} 1867 1868static int mmc_blk_resume(struct mmc_card *card) 1869{ 1870 struct mmc_blk_data *part_md; 1871 struct mmc_blk_data *md = mmc_get_drvdata(card); 1872 1873 if (md) { 1874 /* 1875 * Resume involves the card going into idle state, 1876 * so current partition is always the main one. 1877 */ 1878 md->part_curr = md->part_type; 1879 mmc_queue_resume(&md->queue); 1880 list_for_each_entry(part_md, &md->part, part) { 1881 mmc_queue_resume(&part_md->queue); 1882 } 1883 } 1884 return 0; 1885} 1886#else 1887#define mmc_blk_suspend NULL 1888#define mmc_blk_resume NULL 1889#endif 1890 1891static struct mmc_driver mmc_driver = { 1892 .drv = { 1893 .name = "mmcblk", 1894 }, 1895 .probe = mmc_blk_probe, 1896 .remove = mmc_blk_remove, 1897 .suspend = mmc_blk_suspend, 1898 .resume = mmc_blk_resume, 1899}; 1900 1901static int __init mmc_blk_init(void) 1902{ 1903 int res; 1904 1905 if (perdev_minors != CONFIG_MMC_BLOCK_MINORS) 1906 pr_info("mmcblk: using %d minors per device\n", perdev_minors); 1907 1908 max_devices = 256 / perdev_minors; 1909 1910 res = register_blkdev(MMC_BLOCK_MAJOR, "mmc"); 1911 if (res) 1912 goto out; 1913 1914 res = mmc_register_driver(&mmc_driver); 1915 if (res) 1916 goto out2; 1917 1918 return 0; 1919 out2: 1920 unregister_blkdev(MMC_BLOCK_MAJOR, "mmc"); 1921 out: 1922 return res; 1923} 1924 1925static void __exit mmc_blk_exit(void) 1926{ 1927 mmc_unregister_driver(&mmc_driver); 1928 unregister_blkdev(MMC_BLOCK_MAJOR, "mmc"); 1929} 1930 1931module_init(mmc_blk_init); 1932module_exit(mmc_blk_exit); 1933 1934MODULE_LICENSE("GPL"); 1935MODULE_DESCRIPTION("Multimedia Card (MMC) block device driver"); 1936 1937