[MMC] Improve MMC card block size selection (a6f6c96b) · Commits · e / devices / android_kernel_teracube_mt6765

drivers/mmc/mmc.c

+10 −0

Original line number	Original line	Diff line number	Diff line
	@@ -550,6 +550,11 @@ static void mmc_decode_csd(struct mmc_card *card)
	csd->capacity = (1 + m) << (e + 2);		csd->capacity = (1 + m) << (e + 2);

	csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);		csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
			csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
			csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
			csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
			csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
			csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
	} else {		} else {
	/*		/*
	* We only understand CSD structure v1.1 and v1.2.		* We only understand CSD structure v1.1 and v1.2.
	@@ -579,6 +584,11 @@ static void mmc_decode_csd(struct mmc_card *card)
	csd->capacity = (1 + m) << (e + 2);		csd->capacity = (1 + m) << (e + 2);

	csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);		csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
			csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
			csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
			csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
			csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
			csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
	}		}
	}		}

drivers/mmc/mmc_block.c

+113 −62

Original line number	Original line	Diff line number	Diff line
	@@ -54,6 +54,7 @@ struct mmc_blk_data {

	unsigned int usage;		unsigned int usage;
	unsigned int block_bits;		unsigned int block_bits;
			unsigned int read_only;
	};		};

	static DECLARE_MUTEX(open_lock);		static DECLARE_MUTEX(open_lock);
	@@ -85,12 +86,6 @@ static void mmc_blk_put(struct mmc_blk_data *md)
	up(&open_lock);		up(&open_lock);
	}		}

	static inline int mmc_blk_readonly(struct mmc_card *card)
	{
	return mmc_card_readonly(card) \|\|
	!(card->csd.cmdclass & CCC_BLOCK_WRITE);
	}

	static int mmc_blk_open(struct inode inode, struct file filp)		static int mmc_blk_open(struct inode inode, struct file filp)
	{		{
	struct mmc_blk_data *md;		struct mmc_blk_data *md;
	@@ -102,8 +97,7 @@ static int mmc_blk_open(struct inode inode, struct file filp)
	check_disk_change(inode->i_bdev);		check_disk_change(inode->i_bdev);
	ret = 0;		ret = 0;

	if ((filp->f_mode & FMODE_WRITE) &&		if ((filp->f_mode & FMODE_WRITE) && md->read_only)
	mmc_blk_readonly(md->queue.card))
	ret = -EROFS;		ret = -EROFS;
	}		}

	@@ -299,6 +293,12 @@ static int mmc_blk_issue_rq(struct mmc_queue mq, struct request req)

	static unsigned long dev_use[MMC_NUM_MINORS/(8*sizeof(unsigned long))];		static unsigned long dev_use[MMC_NUM_MINORS/(8*sizeof(unsigned long))];

			static inline int mmc_blk_readonly(struct mmc_card *card)
			{
			return mmc_card_readonly(card) \|\|
			!(card->csd.cmdclass & CCC_BLOCK_WRITE);
			}

	static struct mmc_blk_data mmc_blk_alloc(struct mmc_card card)		static struct mmc_blk_data mmc_blk_alloc(struct mmc_card card)
	{		{
	struct mmc_blk_data *md;		struct mmc_blk_data *md;
	@@ -310,26 +310,80 @@ static struct mmc_blk_data mmc_blk_alloc(struct mmc_card card)
	__set_bit(devidx, dev_use);		__set_bit(devidx, dev_use);

	md = kmalloc(sizeof(struct mmc_blk_data), GFP_KERNEL);		md = kmalloc(sizeof(struct mmc_blk_data), GFP_KERNEL);
	if (md) {		if (!md) {
			ret = -ENOMEM;
			goto out;
			}

	memset(md, 0, sizeof(struct mmc_blk_data));		memset(md, 0, sizeof(struct mmc_blk_data));

			/*
			* Set the read-only status based on the supported commands
			* and the write protect switch.
			*/
			md->read_only = mmc_blk_readonly(card);

			/*
			* Figure out a workable block size. MMC cards have:
			* - two block sizes, one for read and one for write.
			* - may support partial reads and/or writes
			* (allows block sizes smaller than specified)
			*/
			md->block_bits = card->csd.read_blkbits;
			if (card->csd.write_blkbits != card->csd.read_blkbits) {
			if (card->csd.write_blkbits < card->csd.read_blkbits &&
			card->csd.read_partial) {
			/*
			* write block size is smaller than read block
			* size, but we support partial reads, so choose
			* the smaller write block size.
			*/
			md->block_bits = card->csd.write_blkbits;
			} else if (card->csd.write_blkbits > card->csd.read_blkbits &&
			card->csd.write_partial) {
			/*
			* read block size is smaller than write block
			* size, but we support partial writes. Use read
			* block size.
			*/
			} else {
			/*
			* We don't support this configuration for writes.
			*/
			printk(KERN_ERR "%s: unable to select block size for "
			"writing (rb%u wb%u rp%u wp%u)\n",
			md->disk->disk_name,
			1 << card->csd.read_blkbits,
			1 << card->csd.write_blkbits,
			card->csd.read_partial,
			card->csd.write_partial);
			md->read_only = 1;
			}
			}

			/*
			* Refuse to allow block sizes smaller than 512 bytes.
			*/
			if (md->block_bits < 9) {
			printk(KERN_ERR "%s: unable to support block size %u\n",
			mmc_card_id(card), 1 << md->block_bits);
			ret = -EINVAL;
			goto err_kfree;
			}

	md->disk = alloc_disk(1 << MMC_SHIFT);		md->disk = alloc_disk(1 << MMC_SHIFT);
	if (md->disk == NULL) {		if (md->disk == NULL) {
	kfree(md);		ret = -ENOMEM;
	md = ERR_PTR(-ENOMEM);		goto err_kfree;
	goto out;
	}		}

	spin_lock_init(&md->lock);		spin_lock_init(&md->lock);
	md->usage = 1;		md->usage = 1;

	ret = mmc_init_queue(&md->queue, card, &md->lock);		ret = mmc_init_queue(&md->queue, card, &md->lock);
	if (ret) {		if (ret)
	put_disk(md->disk);		goto err_putdisk;
	kfree(md);
	md = ERR_PTR(ret);
	goto out;
	}
	md->queue.prep_fn = mmc_blk_prep_rq;		md->queue.prep_fn = mmc_blk_prep_rq;
	md->queue.issue_fn = mmc_blk_issue_rq;		md->queue.issue_fn = mmc_blk_issue_rq;
	md->queue.data = md;		md->queue.data = md;
	@@ -356,8 +410,6 @@ static struct mmc_blk_data mmc_blk_alloc(struct mmc_card card)
	sprintf(md->disk->disk_name, "mmcblk%d", devidx);		sprintf(md->disk->disk_name, "mmcblk%d", devidx);
	sprintf(md->disk->devfs_name, "mmc/blk%d", devidx);		sprintf(md->disk->devfs_name, "mmc/blk%d", devidx);

	md->block_bits = card->csd.read_blkbits;

	blk_queue_hardsect_size(md->queue.queue, 1 << md->block_bits);		blk_queue_hardsect_size(md->queue.queue, 1 << md->block_bits);

	/*		/*
	@@ -365,9 +417,14 @@ static struct mmc_blk_data mmc_blk_alloc(struct mmc_card card)
	* set_capacity takes units of 512 bytes.		* set_capacity takes units of 512 bytes.
	*/		*/
	set_capacity(md->disk, card->csd.capacity << (card->csd.read_blkbits - 9));		set_capacity(md->disk, card->csd.capacity << (card->csd.read_blkbits - 9));
	}
	out:
	return md;		return md;

			err_putdisk:
			put_disk(md->disk);
			err_kfree:
			kfree(md);
			out:
			return ERR_PTR(ret);
	}		}

	static int		static int
	@@ -403,12 +460,6 @@ static int mmc_blk_probe(struct mmc_card *card)
	if (!(card->csd.cmdclass & CCC_BLOCK_READ))		if (!(card->csd.cmdclass & CCC_BLOCK_READ))
	return -ENODEV;		return -ENODEV;

	if (card->csd.read_blkbits < 9) {
	printk(KERN_WARNING "%s: read blocksize too small (%u)\n",
	mmc_card_id(card), 1 << card->csd.read_blkbits);
	return -ENODEV;
	}

	md = mmc_blk_alloc(card);		md = mmc_blk_alloc(card);
	if (IS_ERR(md))		if (IS_ERR(md))
	return PTR_ERR(md);		return PTR_ERR(md);
	@@ -419,7 +470,7 @@ static int mmc_blk_probe(struct mmc_card *card)

	printk(KERN_INFO "%s: %s %s %luKiB %s\n",		printk(KERN_INFO "%s: %s %s %luKiB %s\n",
	md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),		md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
	get_capacity(md->disk) >> 1, mmc_blk_readonly(card)?"(ro)":"");		get_capacity(md->disk) >> 1, md->read_only ? "(ro)" : "");

	mmc_set_drvdata(card, md);		mmc_set_drvdata(card, md);
	add_disk(md->disk);		add_disk(md->disk);

include/linux/mmc/card.h

+5 −0

Original line number	Original line	Diff line number	Diff line
	@@ -30,7 +30,12 @@ struct mmc_csd {
	unsigned int tacc_ns;		unsigned int tacc_ns;
	unsigned int max_dtr;		unsigned int max_dtr;
	unsigned int read_blkbits;		unsigned int read_blkbits;
			unsigned int write_blkbits;
	unsigned int capacity;		unsigned int capacity;
			unsigned int read_partial:1,
			read_misalign:1,
			write_partial:1
			write_misalign:1;
	};		};

	struct sd_scr {		struct sd_scr {