[linux-2.6-block.git] / drivers / mmc / mmc_block.c

/*
 * Block driver for media (i.e., flash cards)
 *
 * Copyright 2002 Hewlett-Packard Company
 *
 * 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/sched.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/hdreg.h>
#include <linux/kdev_t.h>
#include <linux/blkdev.h>
#include <linux/devfs_fs_kernel.h>

#include <linux/mmc/card.h>
#include <linux/mmc/protocol.h>

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

#include "mmc_queue.h"

/*
 * max 8 partitions per card
 */
#define MMC_SHIFT	3

static int major;

/*
 * 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	block_bits;
};

static DECLARE_MUTEX(open_lock);

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

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

	return md;
}

static void mmc_blk_put(struct mmc_blk_data *md)
{
	down(&open_lock);
	md->usage--;
	if (md->usage == 0) {
		put_disk(md->disk);
		mmc_cleanup_queue(&md->queue);
		kfree(md);
	}
	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)
{
	struct mmc_blk_data *md;
	int ret = -ENXIO;

	md = mmc_blk_get(inode->i_bdev->bd_disk);
	if (md) {
		if (md->usage == 2)
			check_disk_change(inode->i_bdev);
		ret = 0;

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

	return ret;
}

static int mmc_blk_release(struct inode *inode, struct file *filp)
{
	struct mmc_blk_data *md = inode->i_bdev->bd_disk->private_data;

	mmc_blk_put(md);
	return 0;
}

static int
mmc_blk_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
{
	struct block_device *bdev = inode->i_bdev;

	if (cmd == HDIO_GETGEO) {
		struct hd_geometry geo;

		memset(&geo, 0, sizeof(struct hd_geometry));

		geo.cylinders	= get_capacity(bdev->bd_disk) / (4 * 16);
		geo.heads	= 4;
		geo.sectors	= 16;
		geo.start	= get_start_sect(bdev);

		return copy_to_user((void __user *)arg, &geo, sizeof(geo))
			? -EFAULT : 0;
	}

	return -ENOTTY;
}

static struct block_device_operations mmc_bdops = {
	.open			= mmc_blk_open,
	.release		= mmc_blk_release,
	.ioctl			= mmc_blk_ioctl,
	.owner			= THIS_MODULE,
};

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

static int mmc_blk_prep_rq(struct mmc_queue *mq, struct request *req)
{
	struct mmc_blk_data *md = mq->data;
	int stat = BLKPREP_OK;

	/*
	 * If we have no device, we haven't finished initialising.
	 */
	if (!md || !mq->card) {
		printk(KERN_ERR "%s: killing request - no device/host\n",
		       req->rq_disk->disk_name);
		stat = BLKPREP_KILL;
	}

	return stat;
}

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;
	int ret;

	if (mmc_card_claim_host(card))
		goto cmd_err;

	do {
		struct mmc_blk_request brq;
		struct mmc_command cmd;

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

		brq.cmd.arg = req->sector << 9;
		brq.cmd.flags = MMC_RSP_R1;
		brq.data.timeout_ns = card->csd.tacc_ns * 10;
		brq.data.timeout_clks = card->csd.tacc_clks * 10;
		brq.data.blksz_bits = md->block_bits;
		brq.data.blocks = req->nr_sectors >> (md->block_bits - 9);
		brq.stop.opcode = MMC_STOP_TRANSMISSION;
		brq.stop.arg = 0;
		brq.stop.flags = MMC_RSP_R1B;

		if (rq_data_dir(req) == READ) {
			brq.cmd.opcode = brq.data.blocks > 1 ? MMC_READ_MULTIPLE_BLOCK : MMC_READ_SINGLE_BLOCK;
			brq.data.flags |= MMC_DATA_READ;
		} else {
			brq.cmd.opcode = MMC_WRITE_BLOCK;
			brq.data.flags |= MMC_DATA_WRITE;
			brq.data.blocks = 1;
		}
		brq.mrq.stop = brq.data.blocks > 1 ? &brq.stop : NULL;

		brq.data.sg = mq->sg;
		brq.data.sg_len = blk_rq_map_sg(req->q, req, brq.data.sg);

		mmc_wait_for_req(card->host, &brq.mrq);
		if (brq.cmd.error) {
			printk(KERN_ERR "%s: error %d sending read/write command\n",
			       req->rq_disk->disk_name, brq.cmd.error);
			goto cmd_err;
		}

		if (brq.data.error) {
			printk(KERN_ERR "%s: error %d transferring data\n",
			       req->rq_disk->disk_name, brq.data.error);
			goto cmd_err;
		}

		if (brq.stop.error) {
			printk(KERN_ERR "%s: error %d sending stop command\n",
			       req->rq_disk->disk_name, brq.stop.error);
			goto cmd_err;
		}

		do {
			int err;

			cmd.opcode = MMC_SEND_STATUS;
			cmd.arg = card->rca << 16;
			cmd.flags = MMC_RSP_R1;
			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;
			}
		} while (!(cmd.resp[0] & R1_READY_FOR_DATA));

#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

		/*
		 * A block was successfully transferred.
		 */
		spin_lock_irq(&md->lock);
		ret = end_that_request_chunk(req, 1, brq.data.bytes_xfered);
		if (!ret) {
			/*
			 * The whole request completed successfully.
			 */
			add_disk_randomness(req->rq_disk);
			blkdev_dequeue_request(req);
			end_that_request_last(req);
		}
		spin_unlock_irq(&md->lock);
	} while (ret);

	mmc_card_release_host(card);

	return 1;

 cmd_err:
	mmc_card_release_host(card);

	/*
	 * This is a little draconian, but until we get proper
	 * error handling sorted out here, its the best we can
	 * do - especially as some hosts have no idea how much
	 * data was transferred before the error occurred.
	 */
	spin_lock_irq(&md->lock);
	do {
		ret = end_that_request_chunk(req, 0,
				req->current_nr_sectors << 9);
	} while (ret);

	add_disk_randomness(req->rq_disk);
	blkdev_dequeue_request(req);
	end_that_request_last(req);
	spin_unlock_irq(&md->lock);

	return 0;
}

#define MMC_NUM_MINORS	(256 >> MMC_SHIFT)

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

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 = kmalloc(sizeof(struct mmc_blk_data), GFP_KERNEL);
	if (md) {
		memset(md, 0, sizeof(struct mmc_blk_data));

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

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

		ret = mmc_init_queue(&md->queue, card, &md->lock);
		if (ret) {
			put_disk(md->disk);
			kfree(md);
			md = ERR_PTR(ret);
			goto out;
		}
		md->queue.prep_fn = mmc_blk_prep_rq;
		md->queue.issue_fn = mmc_blk_issue_rq;
		md->queue.data = md;

		md->disk->major	= 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);
		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);

		/*
		 * 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));
	}
 out:
	return md;
}

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

	mmc_card_claim_host(card);
	cmd.opcode = MMC_SET_BLOCKLEN;
	cmd.arg = 1 << md->block_bits;
	cmd.flags = MMC_RSP_R1;
	err = mmc_wait_for_cmd(card->host, &cmd, 5);
	mmc_card_release_host(card);

	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;

	/*
	 * Check that the card supports the command class(es) we need.
	 */
	if (!(card->csd.cmdclass & CCC_BLOCK_READ))
		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);
	if (IS_ERR(md))
		return PTR_ERR(md);

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

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

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

 out:
	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) {
		int devidx;

		del_gendisk(md->disk);

		/*
		 * I think this is needed.
		 */
		md->disk->queue = NULL;

		devidx = md->disk->first_minor >> MMC_SHIFT;
		__clear_bit(devidx, dev_use);

		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 = -ENOMEM;

	res = register_blkdev(major, "mmc");
	if (res < 0) {
		printk(KERN_WARNING "Unable to get major %d for MMC media: %d\n",
		       major, res);
		goto out;
	}
	if (major == 0)
		major = res;

	devfs_mk_dir("mmc");
	return mmc_register_driver(&mmc_driver);

 out:
	return res;
}

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

module_init(mmc_blk_init);
module_exit(mmc_blk_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Multimedia Card (MMC) block device driver");

module_param(major, int, 0444);
MODULE_PARM_DESC(major, "specify the major device number for MMC block driver");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Block driver for media (i.e., flash cards)
	3	*
	4	* Copyright 2002 Hewlett-Packard Company
	5	*
	6	* Use consistent with the GNU GPL is permitted,
	7	* provided that this copyright notice is
	8	* preserved in its entirety in all copies and derived works.
	9	*
	10	* HEWLETT-PACKARD COMPANY MAKES NO WARRANTIES, EXPRESSED OR IMPLIED,
	11	* AS TO THE USEFULNESS OR CORRECTNESS OF THIS CODE OR ITS
	12	* FITNESS FOR ANY PARTICULAR PURPOSE.
	13	*
	14	* Many thanks to Alessandro Rubini and Jonathan Corbet!
	15	*
	16	* Author: Andrew Christian
	17	* 28 May 2002
	18	*/
	19	#include <linux/moduleparam.h>
	20	#include <linux/module.h>
	21	#include <linux/init.h>
	22
	23	#include <linux/sched.h>
	24	#include <linux/kernel.h>
	25	#include <linux/fs.h>
	26	#include <linux/errno.h>
	27	#include <linux/hdreg.h>
	28	#include <linux/kdev_t.h>
	29	#include <linux/blkdev.h>
	30	#include <linux/devfs_fs_kernel.h>
	31
	32	#include <linux/mmc/card.h>
	33	#include <linux/mmc/protocol.h>
	34
	35	#include <asm/system.h>
	36	#include <asm/uaccess.h>
	37
	38	#include "mmc_queue.h"
	39
	40	/*
	41	* max 8 partitions per card
	42	*/
	43	#define MMC_SHIFT 3
	44
	45	static int major;
	46
	47	/*
	48	* There is one mmc_blk_data per slot.
	49	*/
	50	struct mmc_blk_data {
	51	spinlock_t lock;
	52	struct gendisk *disk;
	53	struct mmc_queue queue;
	54
	55	unsigned int usage;
	56	unsigned int block_bits;
	57	};
	58
	59	static DECLARE_MUTEX(open_lock);
	60
	61	static struct mmc_blk_data mmc_blk_get(struct gendisk disk)
	62	{
	63	struct mmc_blk_data *md;
	64
65	down(&open_lock);
66	md = disk->private_data;
67	if (md && md->usage == 0)
68	md = NULL;
69	if (md)
70	md->usage++;
71	up(&open_lock);
72
73	return md;
74	}
75
76	static void mmc_blk_put(struct mmc_blk_data *md)
77	{
78	down(&open_lock);
79	md->usage--;
80	if (md->usage == 0) {
81	put_disk(md->disk);
82	mmc_cleanup_queue(&md->queue);
83	kfree(md);
84	}
85	up(&open_lock);
86	}
87
936d8592 PO	88	static inline int mmc_blk_readonly(struct mmc_card *card)
	89	{
	90	return mmc_card_readonly(card) \|\|
	91	!(card->csd.cmdclass & CCC_BLOCK_WRITE);
	92	}
	93
1da177e4 LT	94	static int mmc_blk_open(struct inode inode, struct file filp)
	95	{
	96	struct mmc_blk_data *md;
	97	int ret = -ENXIO;
	98
	99	md = mmc_blk_get(inode->i_bdev->bd_disk);
	100	if (md) {
	101	if (md->usage == 2)
	102	check_disk_change(inode->i_bdev);
	103	ret = 0;
a00fc090 PO	104
a00fc090 PO	105	if ((filp->f_mode & FMODE_WRITE) &&
936d8592	106	mmc_blk_readonly(md->queue.card))
a00fc090	107	ret = -EROFS;
1da177e4 LT	108	}
	109
	110	return ret;
	111	}
	112
	113	static int mmc_blk_release(struct inode inode, struct file filp)
	114	{
	115	struct mmc_blk_data *md = inode->i_bdev->bd_disk->private_data;
	116
	117	mmc_blk_put(md);
	118	return 0;
	119	}
	120
	121	static int
	122	mmc_blk_ioctl(struct inode inode, struct file filp, unsigned int cmd, unsigned long arg)
	123	{
	124	struct block_device *bdev = inode->i_bdev;
	125
	126	if (cmd == HDIO_GETGEO) {
	127	struct hd_geometry geo;
	128
	129	memset(&geo, 0, sizeof(struct hd_geometry));
	130
	131	geo.cylinders = get_capacity(bdev->bd_disk) / (4 * 16);
	132	geo.heads = 4;
	133	geo.sectors = 16;
	134	geo.start = get_start_sect(bdev);
	135
	136	return copy_to_user((void __user *)arg, &geo, sizeof(geo))
	137	? -EFAULT : 0;
	138	}
	139
	140	return -ENOTTY;
	141	}
	142
	143	static struct block_device_operations mmc_bdops = {
	144	.open = mmc_blk_open,
	145	.release = mmc_blk_release,
	146	.ioctl = mmc_blk_ioctl,
	147	.owner = THIS_MODULE,
	148	};
	149
	150	struct mmc_blk_request {
	151	struct mmc_request mrq;
	152	struct mmc_command cmd;
	153	struct mmc_command stop;
	154	struct mmc_data data;
	155	};
	156
	157	static int mmc_blk_prep_rq(struct mmc_queue mq, struct request req)
	158	{
	159	struct mmc_blk_data *md = mq->data;
	160	int stat = BLKPREP_OK;
	161
	162	/*
	163	* If we have no device, we haven't finished initialising.
	164	*/
	165	if (!md \|\| !mq->card) {
	166	printk(KERN_ERR "%s: killing request - no device/host\n",
	167	req->rq_disk->disk_name);
	168	stat = BLKPREP_KILL;
	169	}
	170
	171	return stat;
172	}
173
174	static int mmc_blk_issue_rq(struct mmc_queue mq, struct request req)
175	{
176	struct mmc_blk_data *md = mq->data;
177	struct mmc_card *card = md->queue.card;
178	int ret;
179
180	if (mmc_card_claim_host(card))
181	goto cmd_err;
182
183	do {
184	struct mmc_blk_request brq;
185	struct mmc_command cmd;
186
187	memset(&brq, 0, sizeof(struct mmc_blk_request));
188	brq.mrq.cmd = &brq.cmd;
189	brq.mrq.data = &brq.data;
190
191	brq.cmd.arg = req->sector << 9;
192	brq.cmd.flags = MMC_RSP_R1;
193	brq.data.timeout_ns = card->csd.tacc_ns * 10;
194	brq.data.timeout_clks = card->csd.tacc_clks * 10;
195	brq.data.blksz_bits = md->block_bits;
196	brq.data.blocks = req->nr_sectors >> (md->block_bits - 9);
197	brq.stop.opcode = MMC_STOP_TRANSMISSION;
198	brq.stop.arg = 0;
199	brq.stop.flags = MMC_RSP_R1B;
200
201	if (rq_data_dir(req) == READ) {
202	brq.cmd.opcode = brq.data.blocks > 1 ? MMC_READ_MULTIPLE_BLOCK : MMC_READ_SINGLE_BLOCK;
203	brq.data.flags \|= MMC_DATA_READ;
204	} else {
205	brq.cmd.opcode = MMC_WRITE_BLOCK;
1da177e4 LT	206	brq.data.flags \|= MMC_DATA_WRITE;
	207	brq.data.blocks = 1;
	208	}
	209	brq.mrq.stop = brq.data.blocks > 1 ? &brq.stop : NULL;
	210
	211	brq.data.sg = mq->sg;
	212	brq.data.sg_len = blk_rq_map_sg(req->q, req, brq.data.sg);
	213
	214	mmc_wait_for_req(card->host, &brq.mrq);
	215	if (brq.cmd.error) {
	216	printk(KERN_ERR "%s: error %d sending read/write command\n",
	217	req->rq_disk->disk_name, brq.cmd.error);
	218	goto cmd_err;
	219	}
	220
	221	if (brq.data.error) {
	222	printk(KERN_ERR "%s: error %d transferring data\n",
	223	req->rq_disk->disk_name, brq.data.error);
	224	goto cmd_err;
	225	}
	226
	227	if (brq.stop.error) {
	228	printk(KERN_ERR "%s: error %d sending stop command\n",
	229	req->rq_disk->disk_name, brq.stop.error);
	230	goto cmd_err;
	231	}
	232
	233	do {
	234	int err;
	235
	236	cmd.opcode = MMC_SEND_STATUS;
	237	cmd.arg = card->rca << 16;
	238	cmd.flags = MMC_RSP_R1;
	239	err = mmc_wait_for_cmd(card->host, &cmd, 5);
	240	if (err) {
	241	printk(KERN_ERR "%s: error %d requesting status\n",
	242	req->rq_disk->disk_name, err);
	243	goto cmd_err;
	244	}
	245	} while (!(cmd.resp[0] & R1_READY_FOR_DATA));
	246
	247	#if 0
	248	if (cmd.resp[0] & ~0x00000900)
	249	printk(KERN_ERR "%s: status = %08x\n",
	250	req->rq_disk->disk_name, cmd.resp[0]);
	251	if (mmc_decode_status(cmd.resp))
	252	goto cmd_err;
	253	#endif
	254
	255	/*
	256	* A block was successfully transferred.
	257	*/
	258	spin_lock_irq(&md->lock);
	259	ret = end_that_request_chunk(req, 1, brq.data.bytes_xfered);
	260	if (!ret) {
	261	/*
	262	* The whole request completed successfully.
	263	*/
	264	add_disk_randomness(req->rq_disk);
	265	blkdev_dequeue_request(req);
	266	end_that_request_last(req);
	267	}
	268	spin_unlock_irq(&md->lock);
	269	} while (ret);
270
271	mmc_card_release_host(card);
272
273	return 1;
274
275	cmd_err:
276	mmc_card_release_host(card);
277
278	/*
279	* This is a little draconian, but until we get proper
280	* error handling sorted out here, its the best we can
281	* do - especially as some hosts have no idea how much
282	* data was transferred before the error occurred.
283	*/
284	spin_lock_irq(&md->lock);
285	do {
286	ret = end_that_request_chunk(req, 0,
287	req->current_nr_sectors << 9);
288	} while (ret);
289
290	add_disk_randomness(req->rq_disk);
291	blkdev_dequeue_request(req);
292	end_that_request_last(req);
293	spin_unlock_irq(&md->lock);
294
295	return 0;
296	}
297
298	#define MMC_NUM_MINORS (256 >> MMC_SHIFT)
299
300	static unsigned long dev_use[MMC_NUM_MINORS/(8*sizeof(unsigned long))];
301
302	static struct mmc_blk_data mmc_blk_alloc(struct mmc_card card)
303	{
304	struct mmc_blk_data *md;
305	int devidx, ret;
306
307	devidx = find_first_zero_bit(dev_use, MMC_NUM_MINORS);
308	if (devidx >= MMC_NUM_MINORS)
309	return ERR_PTR(-ENOSPC);
310	__set_bit(devidx, dev_use);
311
312	md = kmalloc(sizeof(struct mmc_blk_data), GFP_KERNEL);
313	if (md) {
314	memset(md, 0, sizeof(struct mmc_blk_data));
315
316	md->disk = alloc_disk(1 << MMC_SHIFT);
317	if (md->disk == NULL) {
318	kfree(md);
319	md = ERR_PTR(-ENOMEM);
320	goto out;
321	}
322
323	spin_lock_init(&md->lock);
324	md->usage = 1;
325
326	ret = mmc_init_queue(&md->queue, card, &md->lock);
327	if (ret) {
328	put_disk(md->disk);
329	kfree(md);
330	md = ERR_PTR(ret);
331	goto out;
332	}
333	md->queue.prep_fn = mmc_blk_prep_rq;
334	md->queue.issue_fn = mmc_blk_issue_rq;
335	md->queue.data = md;
336
337	md->disk->major = major;
338	md->disk->first_minor = devidx << MMC_SHIFT;
339	md->disk->fops = &mmc_bdops;
340	md->disk->private_data = md;
341	md->disk->queue = md->queue.queue;
342	md->disk->driverfs_dev = &card->dev;
343
344	/*
345	* As discussed on lkml, GENHD_FL_REMOVABLE should:
346	*
347	* - be set for removable media with permanent block devices
348	* - be unset for removable block devices with permanent media
349	*
350	* Since MMC block devices clearly fall under the second
351	* case, we do not set GENHD_FL_REMOVABLE. Userspace
352	* should use the block device creation/destruction hotplug
353	* messages to tell when the card is present.
354	*/
355
356	sprintf(md->disk->disk_name, "mmcblk%d", devidx);
357	sprintf(md->disk->devfs_name, "mmc/blk%d", devidx);
358
359	md->block_bits = card->csd.read_blkbits;
360
361	blk_queue_hardsect_size(md->queue.queue, 1 << md->block_bits);
d2b18394 RK	362
	363	/*
	364	* The CSD capacity field is in units of read_blkbits.
	365	* set_capacity takes units of 512 bytes.
	366	*/
	367	set_capacity(md->disk, card->csd.capacity << (card->csd.read_blkbits - 9));
1da177e4 LT	368	}
	369	out:
	370	return md;
	371	}
	372
	373	static int
	374	mmc_blk_set_blksize(struct mmc_blk_data md, struct mmc_card card)
	375	{
	376	struct mmc_command cmd;
	377	int err;
	378
	379	mmc_card_claim_host(card);
	380	cmd.opcode = MMC_SET_BLOCKLEN;
d2b18394	381	cmd.arg = 1 << md->block_bits;
1da177e4 LT	382	cmd.flags = MMC_RSP_R1;
	383	err = mmc_wait_for_cmd(card->host, &cmd, 5);
	384	mmc_card_release_host(card);
	385
	386	if (err) {
	387	printk(KERN_ERR "%s: unable to set block size to %d: %d\n",
	388	md->disk->disk_name, cmd.arg, err);
	389	return -EINVAL;
	390	}
	391
	392	return 0;
	393	}
	394
	395	static int mmc_blk_probe(struct mmc_card *card)
	396	{
	397	struct mmc_blk_data *md;
	398	int err;
	399
912490db PO	400	/*
	401	* Check that the card supports the command class(es) we need.
	402	*/
	403	if (!(card->csd.cmdclass & CCC_BLOCK_READ))
1da177e4 LT	404	return -ENODEV;
	405
	406	if (card->csd.read_blkbits < 9) {
	407	printk(KERN_WARNING "%s: read blocksize too small (%u)\n",
	408	mmc_card_id(card), 1 << card->csd.read_blkbits);
	409	return -ENODEV;
	410	}
	411
	412	md = mmc_blk_alloc(card);
	413	if (IS_ERR(md))
	414	return PTR_ERR(md);
	415
	416	err = mmc_blk_set_blksize(md, card);
	417	if (err)
	418	goto out;
	419
d2b18394	420	printk(KERN_INFO "%s: %s %s %luKiB %s\n",
1da177e4	421	md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
d2b18394	422	get_capacity(md->disk) >> 1, mmc_blk_readonly(card)?"(ro)":"");
1da177e4 LT	423
	424	mmc_set_drvdata(card, md);
	425	add_disk(md->disk);
	426	return 0;
	427
	428	out:
	429	mmc_blk_put(md);
	430
	431	return err;
	432	}
	433
	434	static void mmc_blk_remove(struct mmc_card *card)
	435	{
	436	struct mmc_blk_data *md = mmc_get_drvdata(card);
	437
	438	if (md) {
	439	int devidx;
	440
	441	del_gendisk(md->disk);
	442
	443	/*
	444	* I think this is needed.
	445	*/
	446	md->disk->queue = NULL;
	447
	448	devidx = md->disk->first_minor >> MMC_SHIFT;
	449	__clear_bit(devidx, dev_use);
	450
	451	mmc_blk_put(md);
	452	}
	453	mmc_set_drvdata(card, NULL);
	454	}
	455
	456	#ifdef CONFIG_PM
	457	static int mmc_blk_suspend(struct mmc_card *card, pm_message_t state)
	458	{
	459	struct mmc_blk_data *md = mmc_get_drvdata(card);
	460
	461	if (md) {
	462	mmc_queue_suspend(&md->queue);
	463	}
	464	return 0;
	465	}
	466
	467	static int mmc_blk_resume(struct mmc_card *card)
	468	{
	469	struct mmc_blk_data *md = mmc_get_drvdata(card);
	470
	471	if (md) {
	472	mmc_blk_set_blksize(md, card);
	473	mmc_queue_resume(&md->queue);
	474	}
	475	return 0;
	476	}
	477	#else
	478	#define mmc_blk_suspend NULL
	479	#define mmc_blk_resume NULL
	480	#endif
	481
	482	static struct mmc_driver mmc_driver = {
	483	.drv = {
	484	.name = "mmcblk",
	485	},
	486	.probe = mmc_blk_probe,
487	.remove = mmc_blk_remove,
488	.suspend = mmc_blk_suspend,
489	.resume = mmc_blk_resume,
490	};
491
492	static int __init mmc_blk_init(void)
493	{
494	int res = -ENOMEM;
495
496	res = register_blkdev(major, "mmc");
497	if (res < 0) {
498	printk(KERN_WARNING "Unable to get major %d for MMC media: %d\n",
499	major, res);
500	goto out;
501	}
502	if (major == 0)
503	major = res;
504
505	devfs_mk_dir("mmc");
506	return mmc_register_driver(&mmc_driver);
507
508	out:
509	return res;
510	}
511
512	static void __exit mmc_blk_exit(void)
513	{
514	mmc_unregister_driver(&mmc_driver);
515	devfs_remove("mmc");
516	unregister_blkdev(major, "mmc");
517	}
518
519	module_init(mmc_blk_init);
520	module_exit(mmc_blk_exit);
521
522	MODULE_LICENSE("GPL");
523	MODULE_DESCRIPTION("Multimedia Card (MMC) block device driver");
524
525	module_param(major, int, 0444);
526	MODULE_PARM_DESC(major, "specify the major device number for MMC block driver");