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