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			!(card->quirks & MMC_QUIRK_SEC_ERASE_TRIM_BROKEN))
1434			ret = mmc_blk_issue_secdiscard_rq(mq, req);
1435		else
1436			ret = mmc_blk_issue_discard_rq(mq, req);
1437	} else if (req && req->cmd_flags & REQ_FLUSH) {
1438		/* complete ongoing async transfer before issuing flush */
1439		if (card->host->areq)
1440			mmc_blk_issue_rw_rq(mq, NULL);
1441		ret = mmc_blk_issue_flush(mq, req);
1442	} else {
 
 
 
 
 
1443		ret = mmc_blk_issue_rw_rq(mq, req);
1444	}
1445
1446out:
1447	if (!req)
1448		/* release host only when there are no more requests */
1449		mmc_release_host(card->host);
 
 
 
 
 
 
1450	return ret;
1451}
1452
1453static inline int mmc_blk_readonly(struct mmc_card *card)
1454{
1455	return mmc_card_readonly(card) ||
1456	       !(card->csd.cmdclass & CCC_BLOCK_WRITE);
1457}
1458
1459static struct mmc_blk_data *mmc_blk_alloc_req(struct mmc_card *card,
1460					      struct device *parent,
1461					      sector_t size,
1462					      bool default_ro,
1463					      const char *subname,
1464					      int area_type)
1465{
1466	struct mmc_blk_data *md;
1467	int devidx, ret;
1468
1469	devidx = find_first_zero_bit(dev_use, max_devices);
1470	if (devidx >= max_devices)
1471		return ERR_PTR(-ENOSPC);
1472	__set_bit(devidx, dev_use);
1473
1474	md = kzalloc(sizeof(struct mmc_blk_data), GFP_KERNEL);
1475	if (!md) {
1476		ret = -ENOMEM;
1477		goto out;
1478	}
1479
1480	/*
1481	 * !subname implies we are creating main mmc_blk_data that will be
1482	 * associated with mmc_card with mmc_set_drvdata. Due to device
1483	 * partitions, devidx will not coincide with a per-physical card
1484	 * index anymore so we keep track of a name index.
1485	 */
1486	if (!subname) {
1487		md->name_idx = find_first_zero_bit(name_use, max_devices);
1488		__set_bit(md->name_idx, name_use);
1489	} else
1490		md->name_idx = ((struct mmc_blk_data *)
1491				dev_to_disk(parent)->private_data)->name_idx;
1492
1493	md->area_type = area_type;
1494
1495	/*
1496	 * Set the read-only status based on the supported commands
1497	 * and the write protect switch.
1498	 */
1499	md->read_only = mmc_blk_readonly(card);
1500
1501	md->disk = alloc_disk(perdev_minors);
1502	if (md->disk == NULL) {
1503		ret = -ENOMEM;
1504		goto err_kfree;
1505	}
1506
1507	spin_lock_init(&md->lock);
1508	INIT_LIST_HEAD(&md->part);
1509	md->usage = 1;
1510
1511	ret = mmc_init_queue(&md->queue, card, &md->lock, subname);
1512	if (ret)
1513		goto err_putdisk;
1514
1515	md->queue.issue_fn = mmc_blk_issue_rq;
1516	md->queue.data = md;
1517
1518	md->disk->major	= MMC_BLOCK_MAJOR;
1519	md->disk->first_minor = devidx * perdev_minors;
1520	md->disk->fops = &mmc_bdops;
1521	md->disk->private_data = md;
1522	md->disk->queue = md->queue.queue;
1523	md->disk->driverfs_dev = parent;
1524	set_disk_ro(md->disk, md->read_only || default_ro);
 
 
1525
1526	/*
1527	 * As discussed on lkml, GENHD_FL_REMOVABLE should:
1528	 *
1529	 * - be set for removable media with permanent block devices
1530	 * - be unset for removable block devices with permanent media
1531	 *
1532	 * Since MMC block devices clearly fall under the second
1533	 * case, we do not set GENHD_FL_REMOVABLE.  Userspace
1534	 * should use the block device creation/destruction hotplug
1535	 * messages to tell when the card is present.
1536	 */
1537
1538	snprintf(md->disk->disk_name, sizeof(md->disk->disk_name),
1539		 "mmcblk%d%s", md->name_idx, subname ? subname : "");
1540
1541	if (mmc_card_mmc(card))
1542		blk_queue_logical_block_size(md->queue.queue,
1543					     card->ext_csd.data_sector_size);
1544	else
1545		blk_queue_logical_block_size(md->queue.queue, 512);
1546
1547	set_capacity(md->disk, size);
1548
1549	if (mmc_host_cmd23(card->host)) {
1550		if (mmc_card_mmc(card) ||
1551		    (mmc_card_sd(card) &&
1552		     card->scr.cmds & SD_SCR_CMD23_SUPPORT))
1553			md->flags |= MMC_BLK_CMD23;
1554	}
1555
1556	if (mmc_card_mmc(card) &&
1557	    md->flags & MMC_BLK_CMD23 &&
1558	    ((card->ext_csd.rel_param & EXT_CSD_WR_REL_PARAM_EN) ||
1559	     card->ext_csd.rel_sectors)) {
1560		md->flags |= MMC_BLK_REL_WR;
1561		blk_queue_flush(md->queue.queue, REQ_FLUSH | REQ_FUA);
1562	}
1563
 
 
 
 
 
 
 
 
1564	return md;
1565
1566 err_putdisk:
1567	put_disk(md->disk);
1568 err_kfree:
1569	kfree(md);
1570 out:
1571	return ERR_PTR(ret);
1572}
1573
1574static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
1575{
1576	sector_t size;
1577	struct mmc_blk_data *md;
1578
1579	if (!mmc_card_sd(card) && mmc_card_blockaddr(card)) {
1580		/*
1581		 * The EXT_CSD sector count is in number or 512 byte
1582		 * sectors.
1583		 */
1584		size = card->ext_csd.sectors;
1585	} else {
1586		/*
1587		 * The CSD capacity field is in units of read_blkbits.
1588		 * set_capacity takes units of 512 bytes.
1589		 */
1590		size = card->csd.capacity << (card->csd.read_blkbits - 9);
1591	}
1592
1593	md = mmc_blk_alloc_req(card, &card->dev, size, false, NULL,
1594					MMC_BLK_DATA_AREA_MAIN);
1595	return md;
1596}
1597
1598static int mmc_blk_alloc_part(struct mmc_card *card,
1599			      struct mmc_blk_data *md,
1600			      unsigned int part_type,
1601			      sector_t size,
1602			      bool default_ro,
1603			      const char *subname,
1604			      int area_type)
1605{
1606	char cap_str[10];
1607	struct mmc_blk_data *part_md;
1608
1609	part_md = mmc_blk_alloc_req(card, disk_to_dev(md->disk), size, default_ro,
1610				    subname, area_type);
1611	if (IS_ERR(part_md))
1612		return PTR_ERR(part_md);
1613	part_md->part_type = part_type;
1614	list_add(&part_md->part, &md->part);
1615
1616	string_get_size((u64)get_capacity(part_md->disk) << 9, STRING_UNITS_2,
1617			cap_str, sizeof(cap_str));
1618	pr_info("%s: %s %s partition %u %s\n",
1619	       part_md->disk->disk_name, mmc_card_id(card),
1620	       mmc_card_name(card), part_md->part_type, cap_str);
1621	return 0;
1622}
1623
1624/* MMC Physical partitions consist of two boot partitions and
1625 * up to four general purpose partitions.
1626 * For each partition enabled in EXT_CSD a block device will be allocatedi
1627 * to provide access to the partition.
1628 */
1629
1630static int mmc_blk_alloc_parts(struct mmc_card *card, struct mmc_blk_data *md)
1631{
1632	int idx, ret = 0;
1633
1634	if (!mmc_card_mmc(card))
1635		return 0;
1636
1637	for (idx = 0; idx < card->nr_parts; idx++) {
1638		if (card->part[idx].size) {
1639			ret = mmc_blk_alloc_part(card, md,
1640				card->part[idx].part_cfg,
1641				card->part[idx].size >> 9,
1642				card->part[idx].force_ro,
1643				card->part[idx].name,
1644				card->part[idx].area_type);
1645			if (ret)
1646				return ret;
1647		}
1648	}
1649
1650	return ret;
1651}
1652
1653static void mmc_blk_remove_req(struct mmc_blk_data *md)
1654{
1655	struct mmc_card *card;
1656
1657	if (md) {
 
 
 
 
 
1658		card = md->queue.card;
 
 
 
1659		if (md->disk->flags & GENHD_FL_UP) {
1660			device_remove_file(disk_to_dev(md->disk), &md->force_ro);
1661			if ((md->area_type & MMC_BLK_DATA_AREA_BOOT) &&
1662					card->ext_csd.boot_ro_lockable)
1663				device_remove_file(disk_to_dev(md->disk),
1664					&md->power_ro_lock);
1665
1666			/* Stop new requests from getting into the queue */
1667			del_gendisk(md->disk);
1668		}
1669
1670		/* Then flush out any already in there */
1671		mmc_cleanup_queue(&md->queue);
1672		mmc_blk_put(md);
1673	}
1674}
1675
1676static void mmc_blk_remove_parts(struct mmc_card *card,
1677				 struct mmc_blk_data *md)
1678{
1679	struct list_head *pos, *q;
1680	struct mmc_blk_data *part_md;
1681
1682	__clear_bit(md->name_idx, name_use);
1683	list_for_each_safe(pos, q, &md->part) {
1684		part_md = list_entry(pos, struct mmc_blk_data, part);
1685		list_del(pos);
1686		mmc_blk_remove_req(part_md);
1687	}
1688}
1689
1690static int mmc_add_disk(struct mmc_blk_data *md)
1691{
1692	int ret;
1693	struct mmc_card *card = md->queue.card;
1694
1695	add_disk(md->disk);
1696	md->force_ro.show = force_ro_show;
1697	md->force_ro.store = force_ro_store;
1698	sysfs_attr_init(&md->force_ro.attr);
1699	md->force_ro.attr.name = "force_ro";
1700	md->force_ro.attr.mode = S_IRUGO | S_IWUSR;
1701	ret = device_create_file(disk_to_dev(md->disk), &md->force_ro);
1702	if (ret)
1703		goto force_ro_fail;
1704
1705	if ((md->area_type & MMC_BLK_DATA_AREA_BOOT) &&
1706	     card->ext_csd.boot_ro_lockable) {
1707		umode_t mode;
1708
1709		if (card->ext_csd.boot_ro_lock & EXT_CSD_BOOT_WP_B_PWR_WP_DIS)
1710			mode = S_IRUGO;
1711		else
1712			mode = S_IRUGO | S_IWUSR;
1713
1714		md->power_ro_lock.show = power_ro_lock_show;
1715		md->power_ro_lock.store = power_ro_lock_store;
1716		sysfs_attr_init(&md->power_ro_lock.attr);
1717		md->power_ro_lock.attr.mode = mode;
1718		md->power_ro_lock.attr.name =
1719					"ro_lock_until_next_power_on";
1720		ret = device_create_file(disk_to_dev(md->disk),
1721				&md->power_ro_lock);
1722		if (ret)
1723			goto power_ro_lock_fail;
1724	}
1725	return ret;
1726
1727power_ro_lock_fail:
1728	device_remove_file(disk_to_dev(md->disk), &md->force_ro);
1729force_ro_fail:
1730	del_gendisk(md->disk);
1731
1732	return ret;
1733}
1734
1735#define CID_MANFID_SANDISK	0x2
1736#define CID_MANFID_TOSHIBA	0x11
1737#define CID_MANFID_MICRON	0x13
1738#define CID_MANFID_SAMSUNG	0x15
1739
1740static const struct mmc_fixup blk_fixups[] =
1741{
1742	MMC_FIXUP("SEM02G", CID_MANFID_SANDISK, 0x100, add_quirk,
1743		  MMC_QUIRK_INAND_CMD38),
1744	MMC_FIXUP("SEM04G", CID_MANFID_SANDISK, 0x100, add_quirk,
1745		  MMC_QUIRK_INAND_CMD38),
1746	MMC_FIXUP("SEM08G", CID_MANFID_SANDISK, 0x100, add_quirk,
1747		  MMC_QUIRK_INAND_CMD38),
1748	MMC_FIXUP("SEM16G", CID_MANFID_SANDISK, 0x100, add_quirk,
1749		  MMC_QUIRK_INAND_CMD38),
1750	MMC_FIXUP("SEM32G", CID_MANFID_SANDISK, 0x100, add_quirk,
1751		  MMC_QUIRK_INAND_CMD38),
1752
1753	/*
1754	 * Some MMC cards experience performance degradation with CMD23
1755	 * instead of CMD12-bounded multiblock transfers. For now we'll
1756	 * black list what's bad...
1757	 * - Certain Toshiba cards.
1758	 *
1759	 * N.B. This doesn't affect SD cards.
1760	 */
1761	MMC_FIXUP("MMC08G", CID_MANFID_TOSHIBA, CID_OEMID_ANY, add_quirk_mmc,
1762		  MMC_QUIRK_BLK_NO_CMD23),
1763	MMC_FIXUP("MMC16G", CID_MANFID_TOSHIBA, CID_OEMID_ANY, add_quirk_mmc,
1764		  MMC_QUIRK_BLK_NO_CMD23),
1765	MMC_FIXUP("MMC32G", CID_MANFID_TOSHIBA, CID_OEMID_ANY, add_quirk_mmc,
1766		  MMC_QUIRK_BLK_NO_CMD23),
1767
1768	/*
1769	 * Some Micron MMC cards needs longer data read timeout than
1770	 * indicated in CSD.
1771	 */
1772	MMC_FIXUP(CID_NAME_ANY, CID_MANFID_MICRON, 0x200, add_quirk_mmc,
1773		  MMC_QUIRK_LONG_READ_TIME),
1774
1775	/*
1776	 * On these Samsung MoviNAND parts, performing secure erase or
1777	 * secure trim can result in unrecoverable corruption due to a
1778	 * firmware bug.
1779	 */
1780	MMC_FIXUP("M8G2FA", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
1781		  MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
1782	MMC_FIXUP("MAG4FA", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
1783		  MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
1784	MMC_FIXUP("MBG8FA", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
1785		  MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
1786	MMC_FIXUP("MCGAFA", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
1787		  MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
1788	MMC_FIXUP("VAL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
1789		  MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
1790	MMC_FIXUP("VYL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
1791		  MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
1792	MMC_FIXUP("KYL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
1793		  MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
1794	MMC_FIXUP("VZL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
1795		  MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
1796
1797	END_FIXUP
1798};
1799
1800static int mmc_blk_probe(struct mmc_card *card)
1801{
1802	struct mmc_blk_data *md, *part_md;
1803	char cap_str[10];
1804
1805	/*
1806	 * Check that the card supports the command class(es) we need.
1807	 */
1808	if (!(card->csd.cmdclass & CCC_BLOCK_READ))
1809		return -ENODEV;
1810
1811	md = mmc_blk_alloc(card);
1812	if (IS_ERR(md))
1813		return PTR_ERR(md);
1814
1815	string_get_size((u64)get_capacity(md->disk) << 9, STRING_UNITS_2,
1816			cap_str, sizeof(cap_str));
1817	pr_info("%s: %s %s %s %s\n",
1818		md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
1819		cap_str, md->read_only ? "(ro)" : "");
1820
1821	if (mmc_blk_alloc_parts(card, md))
1822		goto out;
1823
1824	mmc_set_drvdata(card, md);
1825	mmc_fixup_device(card, blk_fixups);
1826
1827	if (mmc_add_disk(md))
1828		goto out;
1829
1830	list_for_each_entry(part_md, &md->part, part) {
1831		if (mmc_add_disk(part_md))
1832			goto out;
1833	}
 
 
 
 
 
 
 
 
 
 
 
 
 
1834	return 0;
1835
1836 out:
1837	mmc_blk_remove_parts(card, md);
1838	mmc_blk_remove_req(md);
1839	return 0;
1840}
1841
1842static void mmc_blk_remove(struct mmc_card *card)
1843{
1844	struct mmc_blk_data *md = mmc_get_drvdata(card);
1845
1846	mmc_blk_remove_parts(card, md);
 
1847	mmc_claim_host(card->host);
1848	mmc_blk_part_switch(card, md);
1849	mmc_release_host(card->host);
 
 
 
1850	mmc_blk_remove_req(md);
1851	mmc_set_drvdata(card, NULL);
1852}
1853
1854#ifdef CONFIG_PM
1855static int mmc_blk_suspend(struct mmc_card *card)
1856{
1857	struct mmc_blk_data *part_md;
1858	struct mmc_blk_data *md = mmc_get_drvdata(card);
1859
1860	if (md) {
1861		mmc_queue_suspend(&md->queue);
1862		list_for_each_entry(part_md, &md->part, part) {
1863			mmc_queue_suspend(&part_md->queue);
1864		}
1865	}
1866	return 0;
1867}
1868
 
 
 
 
 
 
 
 
 
 
 
1869static int mmc_blk_resume(struct mmc_card *card)
1870{
1871	struct mmc_blk_data *part_md;
1872	struct mmc_blk_data *md = mmc_get_drvdata(card);
1873
1874	if (md) {
1875		/*
1876		 * Resume involves the card going into idle state,
1877		 * so current partition is always the main one.
1878		 */
1879		md->part_curr = md->part_type;
1880		mmc_queue_resume(&md->queue);
1881		list_for_each_entry(part_md, &md->part, part) {
1882			mmc_queue_resume(&part_md->queue);
1883		}
1884	}
1885	return 0;
1886}
1887#else
1888#define	mmc_blk_suspend	NULL
1889#define mmc_blk_resume	NULL
1890#endif
1891
1892static struct mmc_driver mmc_driver = {
1893	.drv		= {
1894		.name	= "mmcblk",
1895	},
1896	.probe		= mmc_blk_probe,
1897	.remove		= mmc_blk_remove,
1898	.suspend	= mmc_blk_suspend,
1899	.resume		= mmc_blk_resume,
 
1900};
1901
1902static int __init mmc_blk_init(void)
1903{
1904	int res;
1905
1906	if (perdev_minors != CONFIG_MMC_BLOCK_MINORS)
1907		pr_info("mmcblk: using %d minors per device\n", perdev_minors);
1908
1909	max_devices = 256 / perdev_minors;
1910
1911	res = register_blkdev(MMC_BLOCK_MAJOR, "mmc");
1912	if (res)
1913		goto out;
1914
1915	res = mmc_register_driver(&mmc_driver);
1916	if (res)
1917		goto out2;
1918
1919	return 0;
1920 out2:
1921	unregister_blkdev(MMC_BLOCK_MAJOR, "mmc");
1922 out:
1923	return res;
1924}
1925
1926static void __exit mmc_blk_exit(void)
1927{
1928	mmc_unregister_driver(&mmc_driver);
1929	unregister_blkdev(MMC_BLOCK_MAJOR, "mmc");
1930}
1931
1932module_init(mmc_blk_init);
1933module_exit(mmc_blk_exit);
1934
1935MODULE_LICENSE("GPL");
1936MODULE_DESCRIPTION("Multimedia Card (MMC) block device driver");
1937