[net-next-2.6.git] / drivers / mmc / card / block.c

/*
 * Block driver for media (i.e., flash cards)
 *
 * Copyright 2002 Hewlett-Packard Company
 * Copyright 2005-2008 Pierre Ossman
 *
 * Use consistent with the GNU GPL is permitted,
 * provided that this copyright notice is
 * preserved in its entirety in all copies and derived works.
 *
 * HEWLETT-PACKARD COMPANY MAKES NO WARRANTIES, EXPRESSED OR IMPLIED,
 * AS TO THE USEFULNESS OR CORRECTNESS OF THIS CODE OR ITS
 * FITNESS FOR ANY PARTICULAR PURPOSE.
 *
 * Many thanks to Alessandro Rubini and Jonathan Corbet!
 *
 * Author:  Andrew Christian
 *          28 May 2002
 */
#include <linux/moduleparam.h>
#include <linux/module.h>
#include <linux/init.h>

#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/hdreg.h>
#include <linux/kdev_t.h>
#include <linux/blkdev.h>
#include <linux/mutex.h>
#include <linux/scatterlist.h>
#include <linux/string_helpers.h>

#include <linux/mmc/card.h>
#include <linux/mmc/host.h>
#include <linux/mmc/mmc.h>
#include <linux/mmc/sd.h>

#include <asm/system.h>
#include <asm/uaccess.h>

#include "queue.h"

MODULE_ALIAS("mmc:block");

/*
 * max 8 partitions per card
 */
#define MMC_SHIFT	3
#define MMC_NUM_MINORS	(256 >> MMC_SHIFT)

static DECLARE_BITMAP(dev_use, MMC_NUM_MINORS);

/*
 * There is one mmc_blk_data per slot.
 */
struct mmc_blk_data {
	spinlock_t	lock;
	struct gendisk	*disk;
	struct mmc_queue queue;

	unsigned int	usage;
	unsigned int	read_only;
};

static DEFINE_MUTEX(open_lock);

static struct mmc_blk_data *mmc_blk_get(struct gendisk *disk)
{
	struct mmc_blk_data *md;

	mutex_lock(&open_lock);
	md = disk->private_data;
	if (md && md->usage == 0)
		md = NULL;
	if (md)
		md->usage++;
	mutex_unlock(&open_lock);

	return md;
}

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)) >> MMC_SHIFT;

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

		blk_cleanup_queue(md->queue.queue);

		__clear_bit(devidx, dev_use);

		put_disk(md->disk);
		kfree(md);
	}
	mutex_unlock(&open_lock);
}

static int mmc_blk_open(struct block_device *bdev, fmode_t mode)
{
	struct mmc_blk_data *md = mmc_blk_get(bdev->bd_disk);
	int ret = -ENXIO;

	if (md) {
		if (md->usage == 2)
			check_disk_change(bdev);
		ret = 0;

		if ((mode & FMODE_WRITE) && md->read_only) {
			mmc_blk_put(md);
			ret = -EROFS;
		}
	}

	return ret;
}

static int mmc_blk_release(struct gendisk *disk, fmode_t mode)
{
	struct mmc_blk_data *md = disk->private_data;

	mmc_blk_put(md);
	return 0;
}

static int
mmc_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
{
	geo->cylinders = get_capacity(bdev->bd_disk) / (4 * 16);
	geo->heads = 4;
	geo->sectors = 16;
	return 0;
}

static const struct block_device_operations mmc_bdops = {
	.open			= mmc_blk_open,
	.release		= mmc_blk_release,
	.getgeo			= mmc_blk_getgeo,
	.owner			= THIS_MODULE,
};

struct mmc_blk_request {
	struct mmc_request	mrq;
	struct mmc_command	cmd;
	struct mmc_command	stop;
	struct mmc_data		data;
};

static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
{
	int err;
	u32 result;
	__be32 *blocks;

	struct mmc_request mrq;
	struct mmc_command cmd;
	struct mmc_data data;
	unsigned int timeout_us;

	struct scatterlist sg;

	memset(&cmd, 0, sizeof(struct mmc_command));

	cmd.opcode = MMC_APP_CMD;
	cmd.arg = card->rca << 16;
	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;

	err = mmc_wait_for_cmd(card->host, &cmd, 0);
	if (err)
		return (u32)-1;
	if (!mmc_host_is_spi(card->host) && !(cmd.resp[0] & R1_APP_CMD))
		return (u32)-1;

	memset(&cmd, 0, sizeof(struct mmc_command));

	cmd.opcode = SD_APP_SEND_NUM_WR_BLKS;
	cmd.arg = 0;
	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;

	memset(&data, 0, sizeof(struct mmc_data));

	data.timeout_ns = card->csd.tacc_ns * 100;
	data.timeout_clks = card->csd.tacc_clks * 100;

	timeout_us = data.timeout_ns / 1000;
	timeout_us += data.timeout_clks * 1000 /
		(card->host->ios.clock / 1000);

	if (timeout_us > 100000) {
		data.timeout_ns = 100000000;
		data.timeout_clks = 0;
	}

	data.blksz = 4;
	data.blocks = 1;
	data.flags = MMC_DATA_READ;
	data.sg = &sg;
	data.sg_len = 1;

	memset(&mrq, 0, sizeof(struct mmc_request));

	mrq.cmd = &cmd;
	mrq.data = &data;

	blocks = kmalloc(4, GFP_KERNEL);
	if (!blocks)
		return (u32)-1;

	sg_init_one(&sg, blocks, 4);

	mmc_wait_for_req(card->host, &mrq);

	result = ntohl(*blocks);
	kfree(blocks);

	if (cmd.error || data.error)
		result = (u32)-1;

	return result;
}

static u32 get_card_status(struct mmc_card *card, struct request *req)
{
	struct mmc_command cmd;
	int err;

	memset(&cmd, 0, sizeof(struct mmc_command));
	cmd.opcode = MMC_SEND_STATUS;
	if (!mmc_host_is_spi(card->host))
		cmd.arg = card->rca << 16;
	cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
	err = mmc_wait_for_cmd(card->host, &cmd, 0);
	if (err)
		printk(KERN_ERR "%s: error %d sending status comand",
		       req->rq_disk->disk_name, err);
	return cmd.resp[0];
}

static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
{
	struct mmc_blk_data *md = mq->data;
	struct mmc_card *card = md->queue.card;
	struct mmc_blk_request brq;
	int ret = 1, disable_multi = 0;

	mmc_claim_host(card->host);

	do {
		struct mmc_command cmd;
		u32 readcmd, writecmd, status = 0;

		memset(&brq, 0, sizeof(struct mmc_blk_request));
		brq.mrq.cmd = &brq.cmd;
		brq.mrq.data = &brq.data;

		brq.cmd.arg = blk_rq_pos(req);
		if (!mmc_card_blockaddr(card))
			brq.cmd.arg <<= 9;
		brq.cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
		brq.data.blksz = 512;
		brq.stop.opcode = MMC_STOP_TRANSMISSION;
		brq.stop.arg = 0;
		brq.stop.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
		brq.data.blocks = blk_rq_sectors(req);

		/*
		 * The block layer doesn't support all sector count
		 * restrictions, so we need to be prepared for too big
		 * requests.
		 */
		if (brq.data.blocks > card->host->max_blk_count)
			brq.data.blocks = card->host->max_blk_count;

		/*
		 * After a read error, we redo the request one sector at a time
		 * in order to accurately determine which sectors can be read
		 * successfully.
		 */
		if (disable_multi && brq.data.blocks > 1)
			brq.data.blocks = 1;

		if (brq.data.blocks > 1) {
			/* SPI multiblock writes terminate using a special
			 * token, not a STOP_TRANSMISSION request.
			 */
			if (!mmc_host_is_spi(card->host)
					|| rq_data_dir(req) == READ)
				brq.mrq.stop = &brq.stop;
			readcmd = MMC_READ_MULTIPLE_BLOCK;
			writecmd = MMC_WRITE_MULTIPLE_BLOCK;
		} else {
			brq.mrq.stop = NULL;
			readcmd = MMC_READ_SINGLE_BLOCK;
			writecmd = MMC_WRITE_BLOCK;
		}

		if (rq_data_dir(req) == READ) {
			brq.cmd.opcode = readcmd;
			brq.data.flags |= MMC_DATA_READ;
		} else {
			brq.cmd.opcode = writecmd;
			brq.data.flags |= MMC_DATA_WRITE;
		}

		mmc_set_data_timeout(&brq.data, card);

		brq.data.sg = mq->sg;
		brq.data.sg_len = mmc_queue_map_sg(mq);

		/*
		 * Adjust the sg list so it is the same size as the
		 * request.
		 */
		if (brq.data.blocks != blk_rq_sectors(req)) {
			int i, data_size = brq.data.blocks << 9;
			struct scatterlist *sg;

			for_each_sg(brq.data.sg, sg, brq.data.sg_len, i) {
				data_size -= sg->length;
				if (data_size <= 0) {
					sg->length += data_size;
					i++;
					break;
				}
			}
			brq.data.sg_len = i;
		}

		mmc_queue_bounce_pre(mq);

		mmc_wait_for_req(card->host, &brq.mrq);

		mmc_queue_bounce_post(mq);

		/*
		 * Check for errors here, but don't jump to cmd_err
		 * until later as we need to wait for the card to leave
		 * programming mode even when things go wrong.
		 */
		if (brq.cmd.error || brq.data.error || brq.stop.error) {
			if (brq.data.blocks > 1 && rq_data_dir(req) == READ) {
				/* Redo read one sector at a time */
				printk(KERN_WARNING "%s: retrying using single "
				       "block read\n", req->rq_disk->disk_name);
				disable_multi = 1;
				continue;
			}
			status = get_card_status(card, req);
		}

		if (brq.cmd.error) {
			printk(KERN_ERR "%s: error %d sending read/write "
			       "command, response %#x, card status %#x\n",
			       req->rq_disk->disk_name, brq.cmd.error,
			       brq.cmd.resp[0], status);
		}

		if (brq.data.error) {
			if (brq.data.error == -ETIMEDOUT && brq.mrq.stop)
				/* 'Stop' response contains card status */
				status = brq.mrq.stop->resp[0];
			printk(KERN_ERR "%s: error %d transferring data,"
			       " sector %u, nr %u, card status %#x\n",
			       req->rq_disk->disk_name, brq.data.error,
			       (unsigned)blk_rq_pos(req),
			       (unsigned)blk_rq_sectors(req), status);
		}

		if (brq.stop.error) {
			printk(KERN_ERR "%s: error %d sending stop command, "
			       "response %#x, card status %#x\n",
			       req->rq_disk->disk_name, brq.stop.error,
			       brq.stop.resp[0], status);
		}

		if (!mmc_host_is_spi(card->host) && rq_data_dir(req) != READ) {
			do {
				int err;

				cmd.opcode = MMC_SEND_STATUS;
				cmd.arg = card->rca << 16;
				cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
				err = mmc_wait_for_cmd(card->host, &cmd, 5);
				if (err) {
					printk(KERN_ERR "%s: error %d requesting status\n",
					       req->rq_disk->disk_name, err);
					goto cmd_err;
				}
				/*
				 * Some cards mishandle the status bits,
				 * so make sure to check both the busy
				 * indication and the card state.
				 */
			} while (!(cmd.resp[0] & R1_READY_FOR_DATA) ||
				(R1_CURRENT_STATE(cmd.resp[0]) == 7));

#if 0
			if (cmd.resp[0] & ~0x00000900)
				printk(KERN_ERR "%s: status = %08x\n",
				       req->rq_disk->disk_name, cmd.resp[0]);
			if (mmc_decode_status(cmd.resp))
				goto cmd_err;
#endif
		}

		if (brq.cmd.error || brq.stop.error || brq.data.error) {
			if (rq_data_dir(req) == READ) {
				/*
				 * After an error, we redo I/O one sector at a
				 * time, so we only reach here after trying to
				 * read a single sector.
				 */
				spin_lock_irq(&md->lock);
				ret = __blk_end_request(req, -EIO, brq.data.blksz);
				spin_unlock_irq(&md->lock);
				continue;
			}
			goto cmd_err;
		}

		/*
		 * A block was successfully transferred.
		 */
		spin_lock_irq(&md->lock);
		ret = __blk_end_request(req, 0, brq.data.bytes_xfered);
		spin_unlock_irq(&md->lock);
	} while (ret);

	mmc_release_host(card->host);

	return 1;

 cmd_err:
 	/*
 	 * If this is an SD card and we're writing, we can first
 	 * mark the known good sectors as ok.
 	 *
	 * If the card is not SD, we can still ok written sectors
	 * as reported by the controller (which might be less than
	 * the real number of written sectors, but never more).
	 */
	if (mmc_card_sd(card)) {
		u32 blocks;

		blocks = mmc_sd_num_wr_blocks(card);
		if (blocks != (u32)-1) {
			spin_lock_irq(&md->lock);
			ret = __blk_end_request(req, 0, blocks << 9);
			spin_unlock_irq(&md->lock);
		}
	} else {
		spin_lock_irq(&md->lock);
		ret = __blk_end_request(req, 0, brq.data.bytes_xfered);
		spin_unlock_irq(&md->lock);
	}

	mmc_release_host(card->host);

	spin_lock_irq(&md->lock);
	while (ret)
		ret = __blk_end_request(req, -EIO, blk_rq_cur_bytes(req));
	spin_unlock_irq(&md->lock);

	return 0;
}


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)
{
	struct mmc_blk_data *md;
	int devidx, ret;

	devidx = find_first_zero_bit(dev_use, MMC_NUM_MINORS);
	if (devidx >= MMC_NUM_MINORS)
		return ERR_PTR(-ENOSPC);
	__set_bit(devidx, dev_use);

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


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

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

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

	ret = mmc_init_queue(&md->queue, card, &md->lock);
	if (ret)
		goto err_putdisk;

	md->queue.issue_fn = mmc_blk_issue_rq;
	md->queue.data = md;

	md->disk->major	= MMC_BLOCK_MAJOR;
	md->disk->first_minor = devidx << MMC_SHIFT;
	md->disk->fops = &mmc_bdops;
	md->disk->private_data = md;
	md->disk->queue = md->queue.queue;
	md->disk->driverfs_dev = &card->dev;

	/*
	 * As discussed on lkml, GENHD_FL_REMOVABLE should:
	 *
	 * - be set for removable media with permanent block devices
	 * - be unset for removable block devices with permanent media
	 *
	 * Since MMC block devices clearly fall under the second
	 * case, we do not set GENHD_FL_REMOVABLE.  Userspace
	 * should use the block device creation/destruction hotplug
	 * messages to tell when the card is present.
	 */

	sprintf(md->disk->disk_name, "mmcblk%d", devidx);

	blk_queue_logical_block_size(md->queue.queue, 512);

	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);
	} 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));
	}
	return md;

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

static int
mmc_blk_set_blksize(struct mmc_blk_data *md, struct mmc_card *card)
{
	struct mmc_command cmd;
	int err;

	/* Block-addressed cards ignore MMC_SET_BLOCKLEN. */
	if (mmc_card_blockaddr(card))
		return 0;

	mmc_claim_host(card->host);
	cmd.opcode = MMC_SET_BLOCKLEN;
	cmd.arg = 512;
	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
	err = mmc_wait_for_cmd(card->host, &cmd, 5);
	mmc_release_host(card->host);

	if (err) {
		printk(KERN_ERR "%s: unable to set block size to %d: %d\n",
			md->disk->disk_name, cmd.arg, err);
		return -EINVAL;
	}

	return 0;
}

static int mmc_blk_probe(struct mmc_card *card)
{
	struct mmc_blk_data *md;
	int err;

	char cap_str[10];

	/*
	 * Check that the card supports the command class(es) we need.
	 */
	if (!(card->csd.cmdclass & CCC_BLOCK_READ))
		return -ENODEV;

	md = mmc_blk_alloc(card);
	if (IS_ERR(md))
		return PTR_ERR(md);

	err = mmc_blk_set_blksize(md, card);
	if (err)
		goto out;

	string_get_size((u64)get_capacity(md->disk) << 9, STRING_UNITS_2,
			cap_str, sizeof(cap_str));
	printk(KERN_INFO "%s: %s %s %s %s\n",
		md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
		cap_str, md->read_only ? "(ro)" : "");

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

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

	return err;
}

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_set_drvdata(card, NULL);
}

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

	if (md) {
		mmc_queue_suspend(&md->queue);
	}
	return 0;
}

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

	if (md) {
		mmc_blk_set_blksize(md, card);
		mmc_queue_resume(&md->queue);
	}
	return 0;
}
#else
#define	mmc_blk_suspend	NULL
#define mmc_blk_resume	NULL
#endif

static struct mmc_driver mmc_driver = {
	.drv		= {
		.name	= "mmcblk",
	},
	.probe		= mmc_blk_probe,
	.remove		= mmc_blk_remove,
	.suspend	= mmc_blk_suspend,
	.resume		= mmc_blk_resume,
};

static int __init mmc_blk_init(void)
{
	int res;

	res = register_blkdev(MMC_BLOCK_MAJOR, "mmc");
	if (res)
		goto out;

	res = mmc_register_driver(&mmc_driver);
	if (res)
		goto out2;

	return 0;
 out2:
	unregister_blkdev(MMC_BLOCK_MAJOR, "mmc");
 out:
	return res;
}

static void __exit mmc_blk_exit(void)
{
	mmc_unregister_driver(&mmc_driver);
	unregister_blkdev(MMC_BLOCK_MAJOR, "mmc");
}

module_init(mmc_blk_init);
module_exit(mmc_blk_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Multimedia Card (MMC) block device driver");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Block driver for media (i.e., flash cards)
	3	*
	4	* Copyright 2002 Hewlett-Packard Company
979ce720	5	* Copyright 2005-2008 Pierre Ossman
1da177e4 LT	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
1da177e4 LT	24	#include <linux/kernel.h>
1da177e4 LT	25	#include <linux/fs.h>
5a0e3ad6	26	#include <linux/slab.h>
1da177e4 LT	27	#include <linux/errno.h>
	28	#include <linux/hdreg.h>
	29	#include <linux/kdev_t.h>
	30	#include <linux/blkdev.h>
a621aaed	31	#include <linux/mutex.h>
ec5a19dd	32	#include <linux/scatterlist.h>
a7bbb573	33	#include <linux/string_helpers.h>
1da177e4 LT	34
1da177e4 LT	35	#include <linux/mmc/card.h>
385e3227	36	#include <linux/mmc/host.h>
da7fbe58 PO	37	#include <linux/mmc/mmc.h>
da7fbe58 PO	38	#include <linux/mmc/sd.h>
1da177e4 LT	39
	40	#include <asm/system.h>
	41	#include <asm/uaccess.h>
	42
98ac2162	43	#include "queue.h"
1da177e4	44
6b0b6285 AW	45	MODULE_ALIAS("mmc:block");
6b0b6285 AW	46
1da177e4 LT	47	/*
	48	* max 8 partitions per card
	49	*/
	50	#define MMC_SHIFT 3
1dff3144 DW	51	#define MMC_NUM_MINORS (256 >> MMC_SHIFT)
1dff3144 DW	52
203c8018	53	static DECLARE_BITMAP(dev_use, MMC_NUM_MINORS);
1da177e4	54
1da177e4 LT	55	/*
	56	* There is one mmc_blk_data per slot.
	57	*/
	58	struct mmc_blk_data {
	59	spinlock_t lock;
	60	struct gendisk *disk;
	61	struct mmc_queue queue;
	62
	63	unsigned int usage;
a6f6c96b	64	unsigned int read_only;
1da177e4 LT	65	};
1da177e4 LT	66
a621aaed	67	static DEFINE_MUTEX(open_lock);
1da177e4 LT	68
	69	static struct mmc_blk_data mmc_blk_get(struct gendisk disk)
	70	{
	71	struct mmc_blk_data *md;
	72
a621aaed	73	mutex_lock(&open_lock);
1da177e4 LT	74	md = disk->private_data;
	75	if (md && md->usage == 0)
	76	md = NULL;
	77	if (md)
	78	md->usage++;
a621aaed	79	mutex_unlock(&open_lock);
1da177e4 LT	80
	81	return md;
	82	}
	83
	84	static void mmc_blk_put(struct mmc_blk_data *md)
	85	{
a621aaed	86	mutex_lock(&open_lock);
1da177e4 LT	87	md->usage--;
1da177e4 LT	88	if (md->usage == 0) {
7d92df69	89	int devmaj = MAJOR(disk_devt(md->disk));
f331c029	90	int devidx = MINOR(disk_devt(md->disk)) >> MMC_SHIFT;
7d92df69 AL	91
	92	if (!devmaj)
	93	devidx = md->disk->first_minor >> MMC_SHIFT;
	94
5fa83ce2 AH	95	blk_cleanup_queue(md->queue.queue);
5fa83ce2 AH	96
1dff3144 DW	97	__clear_bit(devidx, dev_use);
1dff3144 DW	98
1da177e4	99	put_disk(md->disk);
1da177e4 LT	100	kfree(md);
1da177e4 LT	101	}
a621aaed	102	mutex_unlock(&open_lock);
1da177e4 LT	103	}
1da177e4 LT	104
a5a1561f	105	static int mmc_blk_open(struct block_device *bdev, fmode_t mode)
1da177e4	106	{
a5a1561f	107	struct mmc_blk_data *md = mmc_blk_get(bdev->bd_disk);
1da177e4 LT	108	int ret = -ENXIO;
1da177e4 LT	109
1da177e4 LT	110	if (md) {
1da177e4 LT	111	if (md->usage == 2)
a5a1561f	112	check_disk_change(bdev);
1da177e4	113	ret = 0;
a00fc090	114
a5a1561f	115	if ((mode & FMODE_WRITE) && md->read_only) {
70bb0896	116	mmc_blk_put(md);
a00fc090	117	ret = -EROFS;
70bb0896	118	}
1da177e4 LT	119	}
	120
	121	return ret;
	122	}
	123
a5a1561f	124	static int mmc_blk_release(struct gendisk *disk, fmode_t mode)
1da177e4	125	{
a5a1561f	126	struct mmc_blk_data *md = disk->private_data;
1da177e4 LT	127
	128	mmc_blk_put(md);
	129	return 0;
	130	}
	131
	132	static int
a885c8c4	133	mmc_blk_getgeo(struct block_device bdev, struct hd_geometry geo)
1da177e4	134	{
a885c8c4 CH	135	geo->cylinders = get_capacity(bdev->bd_disk) / (4 * 16);
	136	geo->heads = 4;
	137	geo->sectors = 16;
	138	return 0;
1da177e4 LT	139	}
1da177e4 LT	140
83d5cde4	141	static const struct block_device_operations mmc_bdops = {
a5a1561f AV	142	.open = mmc_blk_open,
a5a1561f AV	143	.release = mmc_blk_release,
a885c8c4	144	.getgeo = mmc_blk_getgeo,
1da177e4 LT	145	.owner = THIS_MODULE,
	146	};
	147
	148	struct mmc_blk_request {
	149	struct mmc_request mrq;
	150	struct mmc_command cmd;
	151	struct mmc_command stop;
	152	struct mmc_data data;
	153	};
	154
ec5a19dd PO	155	static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
	156	{
	157	int err;
051913da BD	158	u32 result;
051913da BD	159	__be32 *blocks;
ec5a19dd PO	160
	161	struct mmc_request mrq;
	162	struct mmc_command cmd;
	163	struct mmc_data data;
	164	unsigned int timeout_us;
	165
	166	struct scatterlist sg;
	167
	168	memset(&cmd, 0, sizeof(struct mmc_command));
	169
	170	cmd.opcode = MMC_APP_CMD;
	171	cmd.arg = card->rca << 16;
7213d175	172	cmd.flags = MMC_RSP_SPI_R1 \| MMC_RSP_R1 \| MMC_CMD_AC;
ec5a19dd PO	173
ec5a19dd PO	174	err = mmc_wait_for_cmd(card->host, &cmd, 0);
7213d175 DB	175	if (err)
	176	return (u32)-1;
	177	if (!mmc_host_is_spi(card->host) && !(cmd.resp[0] & R1_APP_CMD))
ec5a19dd PO	178	return (u32)-1;
	179
	180	memset(&cmd, 0, sizeof(struct mmc_command));
	181
	182	cmd.opcode = SD_APP_SEND_NUM_WR_BLKS;
	183	cmd.arg = 0;
7213d175	184	cmd.flags = MMC_RSP_SPI_R1 \| MMC_RSP_R1 \| MMC_CMD_ADTC;
ec5a19dd PO	185
	186	memset(&data, 0, sizeof(struct mmc_data));
	187
	188	data.timeout_ns = card->csd.tacc_ns * 100;
	189	data.timeout_clks = card->csd.tacc_clks * 100;
	190
	191	timeout_us = data.timeout_ns / 1000;
	192	timeout_us += data.timeout_clks * 1000 /
	193	(card->host->ios.clock / 1000);
	194
	195	if (timeout_us > 100000) {
	196	data.timeout_ns = 100000000;
	197	data.timeout_clks = 0;
	198	}
	199
	200	data.blksz = 4;
	201	data.blocks = 1;
	202	data.flags = MMC_DATA_READ;
	203	data.sg = &sg;
	204	data.sg_len = 1;
	205
	206	memset(&mrq, 0, sizeof(struct mmc_request));
	207
	208	mrq.cmd = &cmd;
	209	mrq.data = &data;
	210
051913da BD	211	blocks = kmalloc(4, GFP_KERNEL);
	212	if (!blocks)
	213	return (u32)-1;
	214
	215	sg_init_one(&sg, blocks, 4);
ec5a19dd PO	216
	217	mmc_wait_for_req(card->host, &mrq);
	218
051913da BD	219	result = ntohl(*blocks);
	220	kfree(blocks);
	221
17b0429d	222	if (cmd.error \|\| data.error)
051913da	223	result = (u32)-1;
ec5a19dd	224
051913da	225	return result;
ec5a19dd PO	226	}
ec5a19dd PO	227
504f191f AH	228	static u32 get_card_status(struct mmc_card card, struct request req)
	229	{
	230	struct mmc_command cmd;
	231	int err;
	232
	233	memset(&cmd, 0, sizeof(struct mmc_command));
	234	cmd.opcode = MMC_SEND_STATUS;
	235	if (!mmc_host_is_spi(card->host))
	236	cmd.arg = card->rca << 16;
	237	cmd.flags = MMC_RSP_SPI_R2 \| MMC_RSP_R1 \| MMC_CMD_AC;
	238	err = mmc_wait_for_cmd(card->host, &cmd, 0);
	239	if (err)
	240	printk(KERN_ERR "%s: error %d sending status comand",
	241	req->rq_disk->disk_name, err);
	242	return cmd.resp[0];
	243	}
	244
1da177e4 LT	245	static int mmc_blk_issue_rq(struct mmc_queue mq, struct request req)
	246	{
	247	struct mmc_blk_data *md = mq->data;
	248	struct mmc_card *card = md->queue.card;
176f00ff	249	struct mmc_blk_request brq;
6a79e391	250	int ret = 1, disable_multi = 0;
1da177e4	251
b855885e	252	mmc_claim_host(card->host);
1da177e4 LT	253
1da177e4 LT	254	do {
1da177e4	255	struct mmc_command cmd;
504f191f	256	u32 readcmd, writecmd, status = 0;
1da177e4 LT	257
	258	memset(&brq, 0, sizeof(struct mmc_blk_request));
	259	brq.mrq.cmd = &brq.cmd;
	260	brq.mrq.data = &brq.data;
	261
83096ebf	262	brq.cmd.arg = blk_rq_pos(req);
fba68bd2 PL	263	if (!mmc_card_blockaddr(card))
fba68bd2 PL	264	brq.cmd.arg <<= 9;
7213d175	265	brq.cmd.flags = MMC_RSP_SPI_R1 \| MMC_RSP_R1 \| MMC_CMD_ADTC;
08846698	266	brq.data.blksz = 512;
1da177e4 LT	267	brq.stop.opcode = MMC_STOP_TRANSMISSION;
1da177e4 LT	268	brq.stop.arg = 0;
7213d175	269	brq.stop.flags = MMC_RSP_SPI_R1B \| MMC_RSP_R1B \| MMC_CMD_AC;
83096ebf	270	brq.data.blocks = blk_rq_sectors(req);
1da177e4	271
548d2de9 PO	272	/*
	273	* The block layer doesn't support all sector count
	274	* restrictions, so we need to be prepared for too big
	275	* requests.
	276	*/
	277	if (brq.data.blocks > card->host->max_blk_count)
	278	brq.data.blocks = card->host->max_blk_count;
	279
6a79e391 AH	280	/*
	281	* After a read error, we redo the request one sector at a time
	282	* in order to accurately determine which sectors can be read
	283	* successfully.
	284	*/
	285	if (disable_multi && brq.data.blocks > 1)
	286	brq.data.blocks = 1;
	287
788ee7b0	288	if (brq.data.blocks > 1) {
7213d175 DB	289	/* SPI multiblock writes terminate using a special
	290	* token, not a STOP_TRANSMISSION request.
	291	*/
	292	if (!mmc_host_is_spi(card->host)
	293	\|\| rq_data_dir(req) == READ)
	294	brq.mrq.stop = &brq.stop;
db53f28b RK	295	readcmd = MMC_READ_MULTIPLE_BLOCK;
db53f28b RK	296	writecmd = MMC_WRITE_MULTIPLE_BLOCK;
788ee7b0 RK	297	} else {
788ee7b0 RK	298	brq.mrq.stop = NULL;
db53f28b RK	299	readcmd = MMC_READ_SINGLE_BLOCK;
	300	writecmd = MMC_WRITE_BLOCK;
	301	}
	302
	303	if (rq_data_dir(req) == READ) {
	304	brq.cmd.opcode = readcmd;
	305	brq.data.flags \|= MMC_DATA_READ;
	306	} else {
	307	brq.cmd.opcode = writecmd;
	308	brq.data.flags \|= MMC_DATA_WRITE;
788ee7b0	309	}
1da177e4	310
b146d26a PO	311	mmc_set_data_timeout(&brq.data, card);
b146d26a PO	312
1da177e4	313	brq.data.sg = mq->sg;
98ccf149 PO	314	brq.data.sg_len = mmc_queue_map_sg(mq);
98ccf149 PO	315
6a79e391 AH	316	/*
	317	* Adjust the sg list so it is the same size as the
	318	* request.
	319	*/
83096ebf	320	if (brq.data.blocks != blk_rq_sectors(req)) {
6a79e391 AH	321	int i, data_size = brq.data.blocks << 9;
	322	struct scatterlist *sg;
	323
	324	for_each_sg(brq.data.sg, sg, brq.data.sg_len, i) {
	325	data_size -= sg->length;
	326	if (data_size <= 0) {
	327	sg->length += data_size;
	328	i++;
	329	break;
	330	}
	331	}
	332	brq.data.sg_len = i;
	333	}
	334
98ccf149	335	mmc_queue_bounce_pre(mq);
1da177e4 LT	336
1da177e4 LT	337	mmc_wait_for_req(card->host, &brq.mrq);
98ccf149 PO	338
	339	mmc_queue_bounce_post(mq);
	340
979ce720 PO	341	/*
	342	* Check for errors here, but don't jump to cmd_err
	343	* until later as we need to wait for the card to leave
	344	* programming mode even when things go wrong.
	345	*/
6a79e391 AH	346	if (brq.cmd.error \|\| brq.data.error \|\| brq.stop.error) {
	347	if (brq.data.blocks > 1 && rq_data_dir(req) == READ) {
	348	/* Redo read one sector at a time */
	349	printk(KERN_WARNING "%s: retrying using single "
	350	"block read\n", req->rq_disk->disk_name);
	351	disable_multi = 1;
	352	continue;
	353	}
504f191f	354	status = get_card_status(card, req);
6a79e391	355	}
504f191f	356
1da177e4	357	if (brq.cmd.error) {
504f191f AH	358	printk(KERN_ERR "%s: error %d sending read/write "
	359	"command, response %#x, card status %#x\n",
	360	req->rq_disk->disk_name, brq.cmd.error,
	361	brq.cmd.resp[0], status);
1da177e4 LT	362	}
	363
	364	if (brq.data.error) {
504f191f AH	365	if (brq.data.error == -ETIMEDOUT && brq.mrq.stop)
	366	/* 'Stop' response contains card status */
	367	status = brq.mrq.stop->resp[0];
	368	printk(KERN_ERR "%s: error %d transferring data,"
	369	" sector %u, nr %u, card status %#x\n",
	370	req->rq_disk->disk_name, brq.data.error,
83096ebf TH	371	(unsigned)blk_rq_pos(req),
83096ebf TH	372	(unsigned)blk_rq_sectors(req), status);
1da177e4 LT	373	}
	374
	375	if (brq.stop.error) {
504f191f AH	376	printk(KERN_ERR "%s: error %d sending stop command, "
	377	"response %#x, card status %#x\n",
	378	req->rq_disk->disk_name, brq.stop.error,
	379	brq.stop.resp[0], status);
1da177e4 LT	380	}
1da177e4 LT	381
7213d175	382	if (!mmc_host_is_spi(card->host) && rq_data_dir(req) != READ) {
2ed6d22c RK	383	do {
	384	int err;
	385
	386	cmd.opcode = MMC_SEND_STATUS;
	387	cmd.arg = card->rca << 16;
	388	cmd.flags = MMC_RSP_R1 \| MMC_CMD_AC;
	389	err = mmc_wait_for_cmd(card->host, &cmd, 5);
	390	if (err) {
	391	printk(KERN_ERR "%s: error %d requesting status\n",
	392	req->rq_disk->disk_name, err);
	393	goto cmd_err;
	394	}
d198f101 PO	395	/*
	396	* Some cards mishandle the status bits,
	397	* so make sure to check both the busy
	398	* indication and the card state.
	399	*/
	400	} while (!(cmd.resp[0] & R1_READY_FOR_DATA) \|\|
	401	(R1_CURRENT_STATE(cmd.resp[0]) == 7));
1da177e4 LT	402
1da177e4 LT	403	#if 0
2ed6d22c RK	404	if (cmd.resp[0] & ~0x00000900)
	405	printk(KERN_ERR "%s: status = %08x\n",
	406	req->rq_disk->disk_name, cmd.resp[0]);
	407	if (mmc_decode_status(cmd.resp))
	408	goto cmd_err;
1da177e4	409	#endif
2ed6d22c	410	}
1da177e4	411
6a79e391 AH	412	if (brq.cmd.error \|\| brq.stop.error \|\| brq.data.error) {
	413	if (rq_data_dir(req) == READ) {
	414	/*
	415	* After an error, we redo I/O one sector at a
	416	* time, so we only reach here after trying to
	417	* read a single sector.
	418	*/
	419	spin_lock_irq(&md->lock);
	420	ret = __blk_end_request(req, -EIO, brq.data.blksz);
	421	spin_unlock_irq(&md->lock);
	422	continue;
	423	}
979ce720	424	goto cmd_err;
6a79e391	425	}
979ce720	426
1da177e4 LT	427	/*
	428	* A block was successfully transferred.
	429	*/
	430	spin_lock_irq(&md->lock);
fd539832	431	ret = __blk_end_request(req, 0, brq.data.bytes_xfered);
1da177e4 LT	432	spin_unlock_irq(&md->lock);
	433	} while (ret);
	434
b855885e	435	mmc_release_host(card->host);
1da177e4 LT	436
	437	return 1;
	438
	439	cmd_err:
ec5a19dd PO	440	/*
	441	* If this is an SD card and we're writing, we can first
	442	* mark the known good sectors as ok.
	443	*
	444	* If the card is not SD, we can still ok written sectors
23af6039 PO	445	* as reported by the controller (which might be less than
23af6039 PO	446	* the real number of written sectors, but never more).
1da177e4	447	*/
6a79e391 AH	448	if (mmc_card_sd(card)) {
6a79e391 AH	449	u32 blocks;
23af6039	450
6a79e391 AH	451	blocks = mmc_sd_num_wr_blocks(card);
6a79e391 AH	452	if (blocks != (u32)-1) {
ec5a19dd	453	spin_lock_irq(&md->lock);
6a79e391	454	ret = __blk_end_request(req, 0, blocks << 9);
ec5a19dd PO	455	spin_unlock_irq(&md->lock);
ec5a19dd PO	456	}
6a79e391 AH	457	} else {
	458	spin_lock_irq(&md->lock);
	459	ret = __blk_end_request(req, 0, brq.data.bytes_xfered);
	460	spin_unlock_irq(&md->lock);
176f00ff PO	461	}
176f00ff PO	462
b855885e	463	mmc_release_host(card->host);
ec5a19dd	464
1da177e4	465	spin_lock_irq(&md->lock);
fd539832 KU	466	while (ret)
fd539832 KU	467	ret = __blk_end_request(req, -EIO, blk_rq_cur_bytes(req));
1da177e4 LT	468	spin_unlock_irq(&md->lock);
	469
	470	return 0;
	471	}
	472
1da177e4	473
a6f6c96b RK	474	static inline int mmc_blk_readonly(struct mmc_card *card)
	475	{
	476	return mmc_card_readonly(card) \|\|
	477	!(card->csd.cmdclass & CCC_BLOCK_WRITE);
	478	}
	479
1da177e4 LT	480	static struct mmc_blk_data mmc_blk_alloc(struct mmc_card card)
	481	{
	482	struct mmc_blk_data *md;
	483	int devidx, ret;
	484
	485	devidx = find_first_zero_bit(dev_use, MMC_NUM_MINORS);
	486	if (devidx >= MMC_NUM_MINORS)
	487	return ERR_PTR(-ENOSPC);
	488	__set_bit(devidx, dev_use);
	489
dd00cc48	490	md = kzalloc(sizeof(struct mmc_blk_data), GFP_KERNEL);
a6f6c96b RK	491	if (!md) {
	492	ret = -ENOMEM;
	493	goto out;
	494	}
1da177e4	495
1da177e4	496
a6f6c96b RK	497	/*
	498	* Set the read-only status based on the supported commands
	499	* and the write protect switch.
	500	*/
	501	md->read_only = mmc_blk_readonly(card);
1da177e4	502
a6f6c96b RK	503	md->disk = alloc_disk(1 << MMC_SHIFT);
	504	if (md->disk == NULL) {
	505	ret = -ENOMEM;
	506	goto err_kfree;
	507	}
1da177e4	508
a6f6c96b RK	509	spin_lock_init(&md->lock);
a6f6c96b RK	510	md->usage = 1;
1da177e4	511
a6f6c96b RK	512	ret = mmc_init_queue(&md->queue, card, &md->lock);
	513	if (ret)
	514	goto err_putdisk;
1da177e4	515
a6f6c96b RK	516	md->queue.issue_fn = mmc_blk_issue_rq;
a6f6c96b RK	517	md->queue.data = md;
d2b18394	518
fe6b4c88	519	md->disk->major = MMC_BLOCK_MAJOR;
a6f6c96b RK	520	md->disk->first_minor = devidx << MMC_SHIFT;
	521	md->disk->fops = &mmc_bdops;
	522	md->disk->private_data = md;
	523	md->disk->queue = md->queue.queue;
	524	md->disk->driverfs_dev = &card->dev;
	525
	526	/*
	527	* As discussed on lkml, GENHD_FL_REMOVABLE should:
	528	*
	529	* - be set for removable media with permanent block devices
	530	* - be unset for removable block devices with permanent media
	531	*
	532	* Since MMC block devices clearly fall under the second
	533	* case, we do not set GENHD_FL_REMOVABLE. Userspace
	534	* should use the block device creation/destruction hotplug
	535	* messages to tell when the card is present.
	536	*/
	537
	538	sprintf(md->disk->disk_name, "mmcblk%d", devidx);
a6f6c96b	539
e1defc4f	540	blk_queue_logical_block_size(md->queue.queue, 512);
a6f6c96b	541
85a18ad9 PO	542	if (!mmc_card_sd(card) && mmc_card_blockaddr(card)) {
	543	/*
	544	* The EXT_CSD sector count is in number or 512 byte
	545	* sectors.
	546	*/
	547	set_capacity(md->disk, card->ext_csd.sectors);
	548	} else {
	549	/*
	550	* The CSD capacity field is in units of read_blkbits.
	551	* set_capacity takes units of 512 bytes.
	552	*/
	553	set_capacity(md->disk,
	554	card->csd.capacity << (card->csd.read_blkbits - 9));
	555	}
1da177e4	556	return md;
a6f6c96b RK	557
	558	err_putdisk:
	559	put_disk(md->disk);
	560	err_kfree:
	561	kfree(md);
	562	out:
	563	return ERR_PTR(ret);
1da177e4 LT	564	}
	565
	566	static int
	567	mmc_blk_set_blksize(struct mmc_blk_data md, struct mmc_card card)
	568	{
	569	struct mmc_command cmd;
	570	int err;
	571
fba68bd2 PL	572	/* Block-addressed cards ignore MMC_SET_BLOCKLEN. */
	573	if (mmc_card_blockaddr(card))
	574	return 0;
	575
b855885e	576	mmc_claim_host(card->host);
1da177e4	577	cmd.opcode = MMC_SET_BLOCKLEN;
08846698	578	cmd.arg = 512;
7213d175	579	cmd.flags = MMC_RSP_SPI_R1 \| MMC_RSP_R1 \| MMC_CMD_AC;
1da177e4	580	err = mmc_wait_for_cmd(card->host, &cmd, 5);
b855885e	581	mmc_release_host(card->host);
1da177e4 LT	582
	583	if (err) {
	584	printk(KERN_ERR "%s: unable to set block size to %d: %d\n",
	585	md->disk->disk_name, cmd.arg, err);
	586	return -EINVAL;
	587	}
	588
	589	return 0;
	590	}
	591
	592	static int mmc_blk_probe(struct mmc_card *card)
	593	{
	594	struct mmc_blk_data *md;
	595	int err;
	596
a7bbb573 PO	597	char cap_str[10];
a7bbb573 PO	598
912490db PO	599	/*
	600	* Check that the card supports the command class(es) we need.
	601	*/
	602	if (!(card->csd.cmdclass & CCC_BLOCK_READ))
1da177e4 LT	603	return -ENODEV;
1da177e4 LT	604
1da177e4 LT	605	md = mmc_blk_alloc(card);
	606	if (IS_ERR(md))
	607	return PTR_ERR(md);
	608
	609	err = mmc_blk_set_blksize(md, card);
	610	if (err)
	611	goto out;
	612
444122fd	613	string_get_size((u64)get_capacity(md->disk) << 9, STRING_UNITS_2,
a7bbb573 PO	614	cap_str, sizeof(cap_str));
a7bbb573 PO	615	printk(KERN_INFO "%s: %s %s %s %s\n",
1da177e4	616	md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
a7bbb573	617	cap_str, md->read_only ? "(ro)" : "");
1da177e4 LT	618
	619	mmc_set_drvdata(card, md);
	620	add_disk(md->disk);
	621	return 0;
	622
	623	out:
0a74ff29	624	mmc_cleanup_queue(&md->queue);
1da177e4 LT	625	mmc_blk_put(md);
	626
	627	return err;
	628	}
	629
	630	static void mmc_blk_remove(struct mmc_card *card)
	631	{
	632	struct mmc_blk_data *md = mmc_get_drvdata(card);
	633
	634	if (md) {
89b4e133	635	/* Stop new requests from getting into the queue */
1da177e4 LT	636	del_gendisk(md->disk);
1da177e4 LT	637
89b4e133 PO	638	/* Then flush out any already in there */
89b4e133 PO	639	mmc_cleanup_queue(&md->queue);
1da177e4	640
1da177e4 LT	641	mmc_blk_put(md);
	642	}
	643	mmc_set_drvdata(card, NULL);
	644	}
	645
	646	#ifdef CONFIG_PM
	647	static int mmc_blk_suspend(struct mmc_card *card, pm_message_t state)
	648	{
	649	struct mmc_blk_data *md = mmc_get_drvdata(card);
	650
	651	if (md) {
	652	mmc_queue_suspend(&md->queue);
	653	}
	654	return 0;
	655	}
	656
	657	static int mmc_blk_resume(struct mmc_card *card)
	658	{
	659	struct mmc_blk_data *md = mmc_get_drvdata(card);
	660
	661	if (md) {
	662	mmc_blk_set_blksize(md, card);
	663	mmc_queue_resume(&md->queue);
	664	}
	665	return 0;
	666	}
	667	#else
	668	#define mmc_blk_suspend NULL
	669	#define mmc_blk_resume NULL
	670	#endif
	671
	672	static struct mmc_driver mmc_driver = {
	673	.drv = {
	674	.name = "mmcblk",
	675	},
	676	.probe = mmc_blk_probe,
	677	.remove = mmc_blk_remove,
	678	.suspend = mmc_blk_suspend,
	679	.resume = mmc_blk_resume,
	680	};
	681
	682	static int __init mmc_blk_init(void)
	683	{
9d4e98e9	684	int res;
1da177e4	685
fe6b4c88 PO	686	res = register_blkdev(MMC_BLOCK_MAJOR, "mmc");
fe6b4c88 PO	687	if (res)
1da177e4	688	goto out;
1da177e4	689
9d4e98e9 AM	690	res = mmc_register_driver(&mmc_driver);
	691	if (res)
	692	goto out2;
1da177e4	693
9d4e98e9 AM	694	return 0;
	695	out2:
	696	unregister_blkdev(MMC_BLOCK_MAJOR, "mmc");
1da177e4 LT	697	out:
	698	return res;
	699	}
	700
	701	static void __exit mmc_blk_exit(void)
	702	{
	703	mmc_unregister_driver(&mmc_driver);
fe6b4c88	704	unregister_blkdev(MMC_BLOCK_MAJOR, "mmc");
1da177e4 LT	705	}
	706
	707	module_init(mmc_blk_init);
	708	module_exit(mmc_blk_exit);
	709
	710	MODULE_LICENSE("GPL");
	711	MODULE_DESCRIPTION("Multimedia Card (MMC) block device driver");
	712