CTC++ Coverage Report - Execution Profile    #519/1532

Files Summary | Functions Summary | Execution Profile | Index | No Index
First | Previous | Next | Last

File: drivers/mmc/mmc_block.c
Instrumentation mode: function-decision-multicondition
TER: 0 % ( 0/171)

Start/	End/
True	False	-	Line	Source
			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	#include <linux/mutex.h>
			32
			33	#include <linux/mmc/card.h>
			34	#include <linux/mmc/protocol.h>
			35
			36	#include <asm/system.h>
			37	#include <asm/uaccess.h>
			38
			39	#include "mmc_queue.h"
			40
			41	/*
			42	* max 8 partitions per card
			43	*/
			44	#define MMC_SHIFT   3
			45
			46	static int major;
			47
			48	/*
			49	* There is one mmc_blk_data per slot.
			50	*/
			51	struct mmc_blk_data {
			52	spinlock_t   lock;
			53	struct gendisk   *disk;
			54	struct mmc_queue queue;
			55
			56	unsigned int   usage;
			57	unsigned int   block_bits;
			58	unsigned int   read_only;
			59	};
			60
			61	static DEFINE_MUTEX(open_lock);
			62
0	0	-	63	static struct mmc_blk_data *mmc_blk_get(struct gendisk *disk)
			64	{
			65	struct mmc_blk_data *md;
			66
			67	mutex_lock(&open_lock);
			68	md = disk->private_data;
0	0	-	69	if (md && md->usage == 0)
0		-	69	T && T
	0	-	69	T && F
	0	-	69	F && _
			70	md = NULL;
0	0	-	71	if (md)
			72	md->usage++;
			73	mutex_unlock(&open_lock);
			74
0		-	75	return md;
			76	}
			77
0	0	-	78	static void mmc_blk_put(struct mmc_blk_data *md)
			79	{
			80	mutex_lock(&open_lock);
			81	md->usage--;
0	0	-	82	if (md->usage == 0) {
			83	put_disk(md->disk);
			84	mmc_cleanup_queue(&md->queue);
			85	kfree(md);
			86	}
			87	mutex_unlock(&open_lock);
			88	}
			89
0	0	-	90	static int mmc_blk_open(struct inode *inode, struct file *filp)
			91	{
			92	struct mmc_blk_data *md;
			93	int ret = -ENXIO;
			94
			95	md = mmc_blk_get(inode->i_bdev->bd_disk);
0	0	-	96	if (md) {
0	0	-	97	if (md->usage == 2)
			98	check_disk_change(inode->i_bdev);
			99	ret = 0;
			100
0	0	-	101	if ((filp->f_mode & FMODE_WRITE) && md->read_only)
0		-	101	(T) && T
	0	-	101	(T) && F
	0	-	101	(F) && _
			102	ret = -EROFS;
			103	}
			104
0		-	105	return ret;
			106	}
			107
0	0	-	108	static int mmc_blk_release(struct inode *inode, struct file *filp)
			109	{
			110	struct mmc_blk_data *md = inode->i_bdev->bd_disk->private_data;
			111
			112	mmc_blk_put(md);
0		-	113	return 0;
			114	}
			115
			116	static int
0	0	-	117	mmc_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
			118	{
			119	geo->cylinders = get_capacity(bdev->bd_disk) / (4 * 16);
			120	geo->heads = 4;
			121	geo->sectors = 16;
0		-	122	return 0;
			123	}
			124
			125	static struct block_device_operations mmc_bdops = {
			126	.open         = mmc_blk_open,
			127	.release      = mmc_blk_release,
			128	.getgeo         = mmc_blk_getgeo,
			129	.owner         = THIS_MODULE,
			130	};
			131
			132	struct mmc_blk_request {
			133	struct mmc_request   mrq;
			134	struct mmc_command   cmd;
			135	struct mmc_command   stop;
			136	struct mmc_data      data;
			137	};
			138
0	0	-	139	static int mmc_blk_prep_rq(struct mmc_queue *mq, struct request *req)
			140	{
			141	struct mmc_blk_data *md = mq->data;
			142	int stat = BLKPREP_OK;
			143
			144	/*
			145	* If we have no device, we haven't finished initialising.
			146	*/
0	0	-	147	if (!md || !mq->card) {
0		-	147	T || _
0		-	147	F || T
	0	-	147	F || F
			148	printk(KERN_ERR "%s: killing request - no device/host\n",
			149	req->rq_disk->disk_name);
			150	stat = BLKPREP_KILL;
			151	}
			152
0		-	153	return stat;
			154	}
			155
0	0	-	156	static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
			157	{
			158	struct mmc_blk_data *md = mq->data;
			159	struct mmc_card *card = md->queue.card;
			160	int ret;
			161
0	0	-	162	if (mmc_card_claim_host(card))
0		-	163	goto cmd_err;
			164
			165	do {
			166	struct mmc_blk_request brq;
			167	struct mmc_command cmd;
			168
			169	memset(&brq, 0, sizeof(struct mmc_blk_request));
			170	brq.mrq.cmd = &brq.cmd;
			171	brq.mrq.data = &brq.data;
			172
			173	brq.cmd.arg = req->sector << 9;
			174	brq.cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
			175	brq.data.timeout_ns = card->csd.tacc_ns * 10;
			176	brq.data.timeout_clks = card->csd.tacc_clks * 10;
			177	brq.data.blksz_bits = md->block_bits;
			178	brq.data.blocks = req->nr_sectors >> (md->block_bits - 9);
			179	brq.stop.opcode = MMC_STOP_TRANSMISSION;
			180	brq.stop.arg = 0;
			181	brq.stop.flags = MMC_RSP_R1B | MMC_CMD_AC;
			182
0	0	-	183	if (rq_data_dir(req) == READ) {
			184	brq.cmd.opcode = brq.data.blocks > 1 ? MMC_READ_MULTIPLE_BLOCK : MMC_READ_SINGLE_BLOCK;
0	0	-	184	ternary-?: brq . data . blocks > 1
			185	brq.data.flags |= MMC_DATA_READ;
			186	} else {
			187	brq.cmd.opcode = MMC_WRITE_BLOCK;
			188	brq.data.flags |= MMC_DATA_WRITE;
			189	brq.data.blocks = 1;
			190	}
			191
0	0	-	192	if (brq.data.blocks > 1) {
			193	brq.data.flags |= MMC_DATA_MULTI;
			194	brq.mrq.stop = &brq.stop;
			195	} else {
			196	brq.mrq.stop = NULL;
			197	}
			198
			199	brq.data.sg = mq->sg;
			200	brq.data.sg_len = blk_rq_map_sg(req->q, req, brq.data.sg);
			201
			202	mmc_wait_for_req(card->host, &brq.mrq);
0	0	-	203	if (brq.cmd.error) {
			204	printk(KERN_ERR "%s: error %d sending read/write command\n",
			205	req->rq_disk->disk_name, brq.cmd.error);
0		-	206	goto cmd_err;
			207	}
			208
0	0	-	209	if (brq.data.error) {
			210	printk(KERN_ERR "%s: error %d transferring data\n",
			211	req->rq_disk->disk_name, brq.data.error);
0		-	212	goto cmd_err;
			213	}
			214
0	0	-	215	if (brq.stop.error) {
			216	printk(KERN_ERR "%s: error %d sending stop command\n",
			217	req->rq_disk->disk_name, brq.stop.error);
0		-	218	goto cmd_err;
			219	}
			220
			221	do {
			222	int err;
			223
			224	cmd.opcode = MMC_SEND_STATUS;
			225	cmd.arg = card->rca << 16;
			226	cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
			227	err = mmc_wait_for_cmd(card->host, &cmd, 5);
0	0	-	228	if (err) {
			229	printk(KERN_ERR "%s: error %d requesting status\n",
			230	req->rq_disk->disk_name, err);
0		-	231	goto cmd_err;
			232	}
0	0	-	233	} while (!(cmd.resp[0] & R1_READY_FOR_DATA));
			234
			235	#if 0
			236	if (cmd.resp[0] & ~0x00000900)
			237	printk(KERN_ERR "%s: status = %08x\n",
			238	req->rq_disk->disk_name, cmd.resp[0]);
			239	if (mmc_decode_status(cmd.resp))
			240	goto cmd_err;
			241	#endif
			242
			243	/*
			244	* A block was successfully transferred.
			245	*/
			246	spin_lock_irq(&md->lock);
			246	do
			246	do
0	0	-	246	do-while (0)
0	0	-	246	do-while (0)
0	0	-	246	do-while (0)
			247	ret = end_that_request_chunk(req, 1, brq.data.bytes_xfered);
0	0	-	248	if (!ret) {
			249	/*
			250	* The whole request completed successfully.
			251	*/
			252	add_disk_randomness(req->rq_disk);
			253	blkdev_dequeue_request(req);
			254	end_that_request_last(req, 1);
			255	}
			256	spin_unlock_irq(&md->lock);
			256	do
			256	do
0	0	-	256	do-while (0)
0	0	-	256	do-while (0)
0	0	-	256	do-while (0)
0	0	-	257	} while (ret);
			258
			259	mmc_card_release_host(card);
			260
0		-	261	return 1;
			262
			263	cmd_err:
			264	mmc_card_release_host(card);
			265
			266	/*
			267	* This is a little draconian, but until we get proper
			268	* error handling sorted out here, its the best we can
			269	* do - especially as some hosts have no idea how much
			270	* data was transferred before the error occurred.
			271	*/
			272	spin_lock_irq(&md->lock);
			272	do
			272	do
0	0	-	272	do-while (0)
0	0	-	272	do-while (0)
0	0	-	272	do-while (0)
			273	do {
			274	ret = end_that_request_chunk(req, 0,
			275	req->current_nr_sectors << 9);
0	0	-	276	} while (ret);
			277
			278	add_disk_randomness(req->rq_disk);
			279	blkdev_dequeue_request(req);
			280	end_that_request_last(req, 0);
			281	spin_unlock_irq(&md->lock);
			281	do
			281	do
0	0	-	281	do-while (0)
0	0	-	281	do-while (0)
0	0	-	281	do-while (0)
			282
0		-	283	return 0;
			284	}
			285
			286	#define MMC_NUM_MINORS   (256 >> MMC_SHIFT)
			287
			288	static unsigned long dev_use[MMC_NUM_MINORS/(8*sizeof(unsigned long))];
			289
0	0	-	290	static inline int mmc_blk_readonly(struct mmc_card *card)
			291	{
			292	return mmc_card_readonly(card) ||
0		-	293	!(card->csd.cmdclass & CCC_BLOCK_WRITE);
			294	}
			295
0	0	-	296	static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
			297	{
			298	struct mmc_blk_data *md;
			299	int devidx, ret;
			300
			301	devidx = find_first_zero_bit(dev_use, MMC_NUM_MINORS);
0	0	-	301	ternary-?: __builtin_constant_p ( ( 256 >> 3 )..
0	0	-	302	if (devidx >= MMC_NUM_MINORS)
0		-	303	return ERR_PTR(-ENOSPC);
			304	__set_bit(devidx, dev_use);
			305
			306	md = kmalloc(sizeof(struct mmc_blk_data), GFP_KERNEL);
0	0	-	307	if (!md) {
			308	ret = -ENOMEM;
0		-	309	goto out;
			310	}
			311
			312	memset(md, 0, sizeof(struct mmc_blk_data));
			313
			314	/*
			315	* Set the read-only status based on the supported commands
			316	* and the write protect switch.
			317	*/
			318	md->read_only = mmc_blk_readonly(card);
			319
			320	/*
			321	* Figure out a workable block size.  MMC cards have:
			322	*  - two block sizes, one for read and one for write.
			323	*  - may support partial reads and/or writes
			324	*    (allows block sizes smaller than specified)
			325	*/
			326	md->block_bits = card->csd.read_blkbits;
0	0	-	327	if (card->csd.write_blkbits != card->csd.read_blkbits) {
			328	if (card->csd.write_blkbits < card->csd.read_blkbits &&
0	0	-	329	card->csd.read_partial) {
0		-	329	T && T
	0	-	329	T && F
	0	-	329	F && _
			330	/*
			331	* write block size is smaller than read block
			332	* size, but we support partial reads, so choose
			333	* the smaller write block size.
			334	*/
			335	md->block_bits = card->csd.write_blkbits;
			336	} else if (card->csd.write_blkbits > card->csd.read_blkbits &&
0	0	-	337	card->csd.write_partial) {
0		-	337	T && T
	0	-	337	T && F
	0	-	337	F && _
			338	/*
			339	* read block size is smaller than write block
			340	* size, but we support partial writes.  Use read
			341	* block size.
			342	*/
			343	} else {
			344	/*
			345	* We don't support this configuration for writes.
			346	*/
			347	printk(KERN_ERR "%s: unable to select block size for "
			348	"writing (rb%u wb%u rp%u wp%u)\n",
			349	md->disk->disk_name,
			350	1 << card->csd.read_blkbits,
			351	1 << card->csd.write_blkbits,
			352	card->csd.read_partial,
			353	card->csd.write_partial);
			354	md->read_only = 1;
			355	}
			356	}
			357
			358	/*
			359	* Refuse to allow block sizes smaller than 512 bytes.
			360	*/
0	0	-	361	if (md->block_bits < 9) {
			362	printk(KERN_ERR "%s: unable to support block size %u\n",
			363	mmc_card_id(card), 1 << md->block_bits);
			364	ret = -EINVAL;
0		-	365	goto err_kfree;
			366	}
			367
			368	md->disk = alloc_disk(1 << MMC_SHIFT);
0	0	-	369	if (md->disk == NULL) {
			370	ret = -ENOMEM;
0		-	371	goto err_kfree;
			372	}
			373
			374	spin_lock_init(&md->lock);
0	0	-	374	do-while (0)
			375	md->usage = 1;
			376
			377	ret = mmc_init_queue(&md->queue, card, &md->lock);
0	0	-	378	if (ret)
0		-	379	goto err_putdisk;
			380
			381	md->queue.prep_fn = mmc_blk_prep_rq;
			382	md->queue.issue_fn = mmc_blk_issue_rq;
			383	md->queue.data = md;
			384
			385	md->disk->major   = major;
			386	md->disk->first_minor = devidx << MMC_SHIFT;
			387	md->disk->fops = &mmc_bdops;
			388	md->disk->private_data = md;
			389	md->disk->queue = md->queue.queue;
			390	md->disk->driverfs_dev = &card->dev;
			391
			392	/*
			393	* As discussed on lkml, GENHD_FL_REMOVABLE should:
			394	*
			395	* - be set for removable media with permanent block devices
			396	* - be unset for removable block devices with permanent media
			397	*
			398	* Since MMC block devices clearly fall under the second
			399	* case, we do not set GENHD_FL_REMOVABLE.  Userspace
			400	* should use the block device creation/destruction hotplug
			401	* messages to tell when the card is present.
			402	*/
			403
			404	sprintf(md->disk->disk_name, "mmcblk%d", devidx);
			405	sprintf(md->disk->devfs_name, "mmc/blk%d", devidx);
			406
			407	blk_queue_hardsect_size(md->queue.queue, 1 << md->block_bits);
			408
			409	/*
			410	* The CSD capacity field is in units of read_blkbits.
			411	* set_capacity takes units of 512 bytes.
			412	*/
			413	set_capacity(md->disk, card->csd.capacity << (card->csd.read_blkbits - 9));
0		-	414	return md;
			415
			416	err_putdisk:
			417	put_disk(md->disk);
			418	err_kfree:
			419	kfree(md);
			420	out:
0		-	421	return ERR_PTR(ret);
			422	}
			423
			424	static int
0	0	-	425	mmc_blk_set_blksize(struct mmc_blk_data *md, struct mmc_card *card)
			426	{
			427	struct mmc_command cmd;
			428	int err;
			429
			430	mmc_card_claim_host(card);
			431	cmd.opcode = MMC_SET_BLOCKLEN;
			432	cmd.arg = 1 << md->block_bits;
			433	cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
			434	err = mmc_wait_for_cmd(card->host, &cmd, 5);
			435	mmc_card_release_host(card);
			436
0	0	-	437	if (err) {
			438	printk(KERN_ERR "%s: unable to set block size to %d: %d\n",
			439	md->disk->disk_name, cmd.arg, err);
0		-	440	return -EINVAL;
			441	}
			442
0		-	443	return 0;
			444	}
			445
0	0	-	446	static int mmc_blk_probe(struct mmc_card *card)
			447	{
			448	struct mmc_blk_data *md;
			449	int err;
			450
			451	/*
			452	* Check that the card supports the command class(es) we need.
			453	*/
0	0	-	454	if (!(card->csd.cmdclass & CCC_BLOCK_READ))
0		-	455	return -ENODEV;
			456
			457	md = mmc_blk_alloc(card);
0	0	-	458	if (IS_ERR(md))
0		-	459	return PTR_ERR(md);
			460
			461	err = mmc_blk_set_blksize(md, card);
0	0	-	462	if (err)
0		-	463	goto out;
			464
			465	printk(KERN_INFO "%s: %s %s %lluKiB %s\n",
			466	md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
			467	(unsigned long long)(get_capacity(md->disk) >> 1),
			468	md->read_only ? "(ro)" : "");
0	0	-	468	ternary-?: md -> read_only
			469
			470	mmc_set_drvdata(card, md);
			471	add_disk(md->disk);
0		-	472	return 0;
			473
			474	out:
			475	mmc_blk_put(md);
			476
0		-	477	return err;
			478	}
			479
0	0	-	480	static void mmc_blk_remove(struct mmc_card *card)
			481	{
			482	struct mmc_blk_data *md = mmc_get_drvdata(card);
			483
0	0	-	484	if (md) {
			485	int devidx;
			486
			487	del_gendisk(md->disk);
			488
			489	/*
			490	* I think this is needed.
			491	*/
			492	md->disk->queue = NULL;
			493
			494	devidx = md->disk->first_minor >> MMC_SHIFT;
			495	__clear_bit(devidx, dev_use);
			496
			497	mmc_blk_put(md);
			498	}
			499	mmc_set_drvdata(card, NULL);
			500	}
			501
			502	#ifdef CONFIG_PM
0	0	-	503	static int mmc_blk_suspend(struct mmc_card *card, pm_message_t state)
			504	{
			505	struct mmc_blk_data *md = mmc_get_drvdata(card);
			506
0	0	-	507	if (md) {
			508	mmc_queue_suspend(&md->queue);
			509	}
0		-	510	return 0;
			511	}
			512
0	0	-	513	static int mmc_blk_resume(struct mmc_card *card)
			514	{
			515	struct mmc_blk_data *md = mmc_get_drv