mmc: MMC boot partitions support. (371a689f) · Commits · 戴 / test

Documentation/mmc/00-INDEX

+2 −0

Original line number	Diff line number	Diff line
		@@ -2,3 +2,5 @@
		- this file
		mmc-dev-attrs.txt
		- info on SD and MMC device attributes
		mmc-dev-parts.txt
		- info on SD and MMC device partitions

Documentation/mmc/mmc-dev-attrs.txt

+10 −0

Original line number	Diff line number	Diff line
		SD and MMC Block Device Attributes
		==================================

		These attributes are defined for the block devices associated with the
		SD or MMC device.

		The following attributes are read/write.

		force_ro Enforce read-only access even if write protect switch is off.

		SD and MMC Device Attributes
		============================

Documentation/mmc/mmc-dev-parts.txt

0 → 100644

+27 −0

Original line number	Diff line number	Diff line
		SD and MMC Device Partitions
		============================

		Device partitions are additional logical block devices present on the
		SD/MMC device.

		As of this writing, MMC boot partitions as supported and exposed as
		/dev/mmcblkXboot0 and /dev/mmcblkXboot1, where X is the index of the
		parent /dev/mmcblkX.

		MMC Boot Partitions
		===================

		Read and write access is provided to the two MMC boot partitions. Due to
		the sensitive nature of the boot partition contents, which often store
		a bootloader or bootloader configuration tables crucial to booting the
		platform, write access is disabled by default to reduce the chance of
		accidental bricking.

		To enable write access to /dev/mmcblkXbootY, disable the forced read-only
		access with:

		echo 0 > /sys/block/mmcblkXbootY/force_ro

		To re-enable read-only access:

		echo 1 > /sys/block/mmcblkXbootY/force_ro

drivers/mmc/card/block.c

+239 −35

Original line number	Diff line number	Diff line
		@@ -76,9 +76,19 @@ struct mmc_blk_data {
		spinlock_t lock;
		struct gendisk *disk;
		struct mmc_queue queue;
		struct list_head part;

		unsigned int usage;
		unsigned int read_only;
		unsigned int part_type;

		/*
		* Only set in main mmc_blk_data associated
		* with mmc_card with mmc_set_drvdata, and keeps
		* track of the current selected device partition.
		*/
		unsigned int part_curr;
		struct device_attribute force_ro;
		};

		static DEFINE_MUTEX(open_lock);
		@@ -101,17 +111,22 @@ static struct mmc_blk_data mmc_blk_get(struct gendisk disk)
		return md;
		}

		static inline int mmc_get_devidx(struct gendisk *disk)
		{
		int devmaj = MAJOR(disk_devt(disk));
		int devidx = MINOR(disk_devt(disk)) / perdev_minors;

		if (!devmaj)
		devidx = disk->first_minor / perdev_minors;
		return devidx;
		}

		static void mmc_blk_put(struct mmc_blk_data *md)
		{
		mutex_lock(&open_lock);
		md->usage--;
		if (md->usage == 0) {
		int devmaj = MAJOR(disk_devt(md->disk));
		int devidx = MINOR(disk_devt(md->disk)) / perdev_minors;

		if (!devmaj)
		devidx = md->disk->first_minor / perdev_minors;

		int devidx = mmc_get_devidx(md->disk);
		blk_cleanup_queue(md->queue.queue);

		__clear_bit(devidx, dev_use);
		@@ -122,6 +137,38 @@ static void mmc_blk_put(struct mmc_blk_data *md)
		mutex_unlock(&open_lock);
		}

		static ssize_t force_ro_show(struct device dev, struct device_attribute attr,
		char *buf)
		{
		int ret;
		struct mmc_blk_data *md = mmc_blk_get(dev_to_disk(dev));

		ret = snprintf(buf, PAGE_SIZE, "%d",
		get_disk_ro(dev_to_disk(dev)) ^
		md->read_only);
		mmc_blk_put(md);
		return ret;
		}

		static ssize_t force_ro_store(struct device dev, struct device_attribute attr,
		const char *buf, size_t count)
		{
		int ret;
		char *end;
		struct mmc_blk_data *md = mmc_blk_get(dev_to_disk(dev));
		unsigned long set = simple_strtoul(buf, &end, 0);
		if (end == buf) {
		ret = -EINVAL;
		goto out;
		}

		set_disk_ro(dev_to_disk(dev), set \|\| md->read_only);
		ret = count;
		out:
		mmc_blk_put(md);
		return ret;
		}

		static int mmc_blk_open(struct block_device *bdev, fmode_t mode)
		{
		struct mmc_blk_data *md = mmc_blk_get(bdev->bd_disk);
		@@ -176,6 +223,29 @@ struct mmc_blk_request {
		struct mmc_data data;
		};

		static inline int mmc_blk_part_switch(struct mmc_card *card,
		struct mmc_blk_data *md)
		{
		int ret;
		struct mmc_blk_data *main_md = mmc_get_drvdata(card);
		if (main_md->part_curr == md->part_type)
		return 0;

		if (mmc_card_mmc(card)) {
		card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
		card->ext_csd.part_config \|= md->part_type;

		ret = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
		EXT_CSD_PART_CONFIG, card->ext_csd.part_config,
		card->ext_csd.part_time);
		if (ret)
		return ret;
		}

		main_md->part_curr = md->part_type;
		return 0;
		}

		static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
		{
		int err;
		@@ -620,6 +690,11 @@ static int mmc_blk_issue_rq(struct mmc_queue mq, struct request req)
		struct mmc_card *card = md->queue.card;

		mmc_claim_host(card->host);
		ret = mmc_blk_part_switch(card, md);
		if (ret) {
		ret = 0;
		goto out;
		}

		if (req->cmd_flags & REQ_DISCARD) {
		if (req->cmd_flags & REQ_SECURE)
		@@ -632,6 +707,7 @@ static int mmc_blk_issue_rq(struct mmc_queue mq, struct request req)
		ret = mmc_blk_issue_rw_rq(mq, req);
		}

		out:
		mmc_release_host(card->host);
		return ret;
		}
		@@ -642,7 +718,11 @@ static inline int mmc_blk_readonly(struct mmc_card *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_req(struct mmc_card card,
		struct device *parent,
		sector_t size,
		bool default_ro,
		const char *subname)
		{
		struct mmc_blk_data *md;
		int devidx, ret;
		@@ -658,7 +738,6 @@ static struct mmc_blk_data mmc_blk_alloc(struct mmc_card card)
		goto out;
		}


		/*
		* Set the read-only status based on the supported commands
		* and the write protect switch.
		@@ -672,6 +751,7 @@ static struct mmc_blk_data mmc_blk_alloc(struct mmc_card card)
		}

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

		ret = mmc_init_queue(&md->queue, card, &md->lock);
		@@ -686,8 +766,8 @@ static struct mmc_blk_data mmc_blk_alloc(struct mmc_card card)
		md->disk->fops = &mmc_bdops;
		md->disk->private_data = md;
		md->disk->queue = md->queue.queue;
		md->disk->driverfs_dev = &card->dev;
		set_disk_ro(md->disk, md->read_only);
		md->disk->driverfs_dev = parent;
		set_disk_ro(md->disk, md->read_only \|\| default_ro);
		if (REL_WRITES_SUPPORTED(card))
		blk_queue_flush(md->queue.queue, REQ_FLUSH \| REQ_FUA);

		@@ -703,33 +783,97 @@ static struct mmc_blk_data mmc_blk_alloc(struct mmc_card card)
		* messages to tell when the card is present.
		*/

		if (subname)
		snprintf(md->disk->disk_name, sizeof(md->disk->disk_name),
		"mmcblk%d%s",
		mmc_get_devidx(dev_to_disk(parent)), subname);
		else
		snprintf(md->disk->disk_name, sizeof(md->disk->disk_name),
		"mmcblk%d", devidx);

		blk_queue_logical_block_size(md->queue.queue, 512);
		set_capacity(md->disk, size);
		return md;

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

		static struct mmc_blk_data mmc_blk_alloc(struct mmc_card card)
		{
		sector_t size;
		struct mmc_blk_data *md;

		if (!mmc_card_sd(card) && mmc_card_blockaddr(card)) {
		/*
		* The EXT_CSD sector count is in number or 512 byte
		* sectors.
		*/
		set_capacity(md->disk, card->ext_csd.sectors);
		size = card->ext_csd.sectors;
		} else {
		/*
		* The CSD capacity field is in units of read_blkbits.
		* set_capacity takes units of 512 bytes.
		*/
		set_capacity(md->disk,
		card->csd.capacity << (card->csd.read_blkbits - 9));
		size = card->csd.capacity << (card->csd.read_blkbits - 9);
		}

		md = mmc_blk_alloc_req(card, &card->dev, size, false, NULL);
		return md;
		}

		err_putdisk:
		put_disk(md->disk);
		err_kfree:
		kfree(md);
		out:
		return ERR_PTR(ret);
		static int mmc_blk_alloc_part(struct mmc_card *card,
		struct mmc_blk_data *md,
		unsigned int part_type,
		sector_t size,
		bool default_ro,
		const char *subname)
		{
		char cap_str[10];
		struct mmc_blk_data *part_md;

		part_md = mmc_blk_alloc_req(card, disk_to_dev(md->disk), size, default_ro,
		subname);
		if (IS_ERR(part_md))
		return PTR_ERR(part_md);
		part_md->part_type = part_type;
		list_add(&part_md->part, &md->part);

		string_get_size((u64)get_capacity(part_md->disk) << 9, STRING_UNITS_2,
		cap_str, sizeof(cap_str));
		printk(KERN_INFO "%s: %s %s partition %u %s\n",
		part_md->disk->disk_name, mmc_card_id(card),
		mmc_card_name(card), part_md->part_type, cap_str);
		return 0;
		}

		static int mmc_blk_alloc_parts(struct mmc_card card, struct mmc_blk_data md)
		{
		int ret = 0;

		if (!mmc_card_mmc(card))
		return 0;

		if (card->ext_csd.boot_size) {
		ret = mmc_blk_alloc_part(card, md, EXT_CSD_PART_CONFIG_ACC_BOOT0,
		card->ext_csd.boot_size >> 9,
		true,
		"boot0");
		if (ret)
		return ret;
		ret = mmc_blk_alloc_part(card, md, EXT_CSD_PART_CONFIG_ACC_BOOT1,
		card->ext_csd.boot_size >> 9,
		true,
		"boot1");
		if (ret)
		return ret;
		}

		return ret;
		}

		static int
		@@ -750,9 +894,54 @@ mmc_blk_set_blksize(struct mmc_blk_data md, struct mmc_card card)
		return 0;
		}

		static void mmc_blk_remove_req(struct mmc_blk_data *md)
		{
		if (md) {
		if (md->disk->flags & GENHD_FL_UP) {
		device_remove_file(disk_to_dev(md->disk), &md->force_ro);

		/* Stop new requests from getting into the queue */
		del_gendisk(md->disk);
		}

		/* Then flush out any already in there */
		mmc_cleanup_queue(&md->queue);
		mmc_blk_put(md);
		}
		}

		static void mmc_blk_remove_parts(struct mmc_card *card,
		struct mmc_blk_data *md)
		{
		struct list_head pos, q;
		struct mmc_blk_data *part_md;

		list_for_each_safe(pos, q, &md->part) {
		part_md = list_entry(pos, struct mmc_blk_data, part);
		list_del(pos);
		mmc_blk_remove_req(part_md);
		}
		}

		static int mmc_add_disk(struct mmc_blk_data *md)
		{
		int ret;

		add_disk(md->disk);
		md->force_ro.show = force_ro_show;
		md->force_ro.store = force_ro_store;
		md->force_ro.attr.name = "force_ro";
		md->force_ro.attr.mode = S_IRUGO \| S_IWUSR;
		ret = device_create_file(disk_to_dev(md->disk), &md->force_ro);
		if (ret)
		del_gendisk(md->disk);

		return ret;
		}

		static int mmc_blk_probe(struct mmc_card *card)
		{
		struct mmc_blk_data *md;
		struct mmc_blk_data md, part_md;
		int err;
		char cap_str[10];

		@@ -776,14 +965,22 @@ static int mmc_blk_probe(struct mmc_card *card)
		md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
		cap_str, md->read_only ? "(ro)" : "");

		if (mmc_blk_alloc_parts(card, md))
		goto out;

		mmc_set_drvdata(card, md);
		add_disk(md->disk);
		if (mmc_add_disk(md))
		goto out;

		list_for_each_entry(part_md, &md->part, part) {
		if (mmc_add_disk(part_md))
		goto out;
		}
		return 0;

		out:
		mmc_cleanup_queue(&md->queue);
		mmc_blk_put(md);

		mmc_blk_remove_parts(card, md);
		mmc_blk_remove_req(md);
		return err;
		}

		@@ -791,36 +988,43 @@ static void mmc_blk_remove(struct mmc_card *card)
		{
		struct mmc_blk_data *md = mmc_get_drvdata(card);

		if (md) {
		/* Stop new requests from getting into the queue */
		del_gendisk(md->disk);

		/* Then flush out any already in there */
		mmc_cleanup_queue(&md->queue);

		mmc_blk_put(md);
		}
		mmc_blk_remove_parts(card, md);
		mmc_blk_remove_req(md);
		mmc_set_drvdata(card, NULL);
		}

		#ifdef CONFIG_PM
		static int mmc_blk_suspend(struct mmc_card *card, pm_message_t state)
		{
		struct mmc_blk_data *part_md;
		struct mmc_blk_data *md = mmc_get_drvdata(card);

		if (md) {
		mmc_queue_suspend(&md->queue);
		list_for_each_entry(part_md, &md->part, part) {
		mmc_queue_suspend(&part_md->queue);
		}
		}
		return 0;
		}

		static int mmc_blk_resume(struct mmc_card *card)
		{
		struct mmc_blk_data *part_md;
		struct mmc_blk_data *md = mmc_get_drvdata(card);

		if (md) {
		mmc_blk_set_blksize(md, card);

		/*
		* Resume involves the card going into idle state,
		* so current partition is always the main one.
		*/
		md->part_curr = md->part_type;
		mmc_queue_resume(&md->queue);
		list_for_each_entry(part_md, &md->part, part) {
		mmc_queue_resume(&part_md->queue);
		}
		}
		return 0;
		}

drivers/mmc/core/mmc.c

+17 −5

Original line number	Diff line number	Diff line
		@@ -288,7 +288,10 @@ static int mmc_read_ext_csd(struct mmc_card *card)

		if (card->ext_csd.rev >= 3) {
		u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
		card->ext_csd.bootconfig = ext_csd[EXT_CSD_BOOT_CONFIG];
		card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG];

		/* EXT_CSD value is in units of 10ms, but we store in ms */
		card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME];

		/* Sleep / awake timeout in 100ns units */
		if (sa_shift > 0 && sa_shift <= 0x17)
		@@ -302,6 +305,12 @@ static int mmc_read_ext_csd(struct mmc_card *card)
		ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10;

		card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C];

		/*
		* There are two boot regions of equal size, defined in
		* multiples of 128K.
		*/
		card->ext_csd.boot_size = ext_csd[EXT_CSD_BOOT_MULT] << 17;
		}

		if (card->ext_csd.rev >= 4) {
		@@ -576,10 +585,13 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
		/*
		* Ensure eMMC user default partition is enabled
		*/
		if (card->ext_csd.bootconfig & 0x7) {
		card->ext_csd.bootconfig &= ~0x7;
		mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BOOT_CONFIG,
		card->ext_csd.bootconfig, 0);
		if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
		card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
		card->ext_csd.part_config,
		card->ext_csd.part_time);
		if (err && err != -EBADMSG)
		goto free_card;
		}

		/*

Admin message