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