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

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

File: drivers/usb/storage/scsiglue.c
Instrumentation mode: function-decision-multicondition
TER: 13 % ( 19/151)

Start/	End/
True	False	-	Line	Source
			1	/* Driver for USB Mass Storage compliant devices
			2	* SCSI layer glue code
			3	*
			4	* $Id: scsiglue.c,v 1.26 2002/04/22 03:39:43 mdharm Exp $
			5	*
			6	* Current development and maintenance by:
			7	*   (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
			8	*
			9	* Developed with the assistance of:
			10	*   (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
			11	*   (c) 2000 Stephen J. Gowdy (SGowdy@lbl.gov)
			12	*
			13	* Initial work by:
			14	*   (c) 1999 Michael Gee (michael@linuxspecific.com)
			15	*
			16	* This driver is based on the 'USB Mass Storage Class' document. This
			17	* describes in detail the protocol used to communicate with such
			18	* devices.  Clearly, the designers had SCSI and ATAPI commands in
			19	* mind when they created this document.  The commands are all very
			20	* similar to commands in the SCSI-II and ATAPI specifications.
			21	*
			22	* It is important to note that in a number of cases this class
			23	* exhibits class-specific exemptions from the USB specification.
			24	* Notably the usage of NAK, STALL and ACK differs from the norm, in
			25	* that they are used to communicate wait, failed and OK on commands.
			26	*
			27	* Also, for certain devices, the interrupt endpoint is used to convey
			28	* status of a command.
			29	*
			30	* Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
			31	* information about this driver.
			32	*
			33	* This program is free software; you can redistribute it and/or modify it
			34	* under the terms of the GNU General Public License as published by the
			35	* Free Software Foundation; either version 2, or (at your option) any
			36	* later version.
			37	*
			38	* This program is distributed in the hope that it will be useful, but
			39	* WITHOUT ANY WARRANTY; without even the implied warranty of
			40	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
			41	* General Public License for more details.
			42	*
			43	* You should have received a copy of the GNU General Public License along
			44	* with this program; if not, write to the Free Software Foundation, Inc.,
			45	* 675 Mass Ave, Cambridge, MA 02139, USA.
			46	*/
			47
			48	#include <linux/slab.h>
			49	#include <linux/module.h>
			50
			51	#include <scsi/scsi.h>
			52	#include <scsi/scsi_cmnd.h>
			53	#include <scsi/scsi_devinfo.h>
			54	#include <scsi/scsi_device.h>
			55	#include <scsi/scsi_eh.h>
			56
			57	#include "usb.h"
			58	#include "scsiglue.h"
			59	#include "debug.h"
			60	#include "transport.h"
			61	#include "protocol.h"
			62
			63	/***********************************************************************
			64	* Host functions
			65	***********************************************************************/
			66
6	0		67	static const char* host_info(struct Scsi_Host *host)
			68	{
6			69	return "SCSI emulation for USB Mass Storage devices";
			70	}
			71
48	0		72	static int slave_alloc (struct scsi_device *sdev)
			73	{
			74	/*
			75	* Set the INQUIRY transfer length to 36.  We don't use any of
			76	* the extra data and many devices choke if asked for more or
			77	* less than 36 bytes.
			78	*/
			79	sdev->inquiry_len = 36;
48			80	return 0;
			81	}
			82
6	0		83	static int slave_configure(struct scsi_device *sdev)
			84	{
			85	struct us_data *us = host_to_us(sdev->host);
			86
			87	/* Scatter-gather buffers (all but the last) must have a length
			88	* divisible by the bulk maxpacket size.  Otherwise a data packet
			89	* would end up being short, causing a premature end to the data
			90	* transfer.  Since high-speed bulk pipes have a maxpacket size
			91	* of 512, we'll use that as the scsi device queue's DMA alignment
			92	* mask.  Guaranteeing proper alignment of the first buffer will
			93	* have the desired effect because, except at the beginning and
			94	* the end, scatter-gather buffers follow page boundaries. */
			95	blk_queue_dma_alignment(sdev->request_queue, (512 - 1));
			96
			97	/* Set the SCSI level to at least 2.  We'll leave it at 3 if that's
			98	* what is originally reported.  We need this to avoid confusing
			99	* the SCSI layer with devices that report 0 or 1, but need 10-byte
			100	* commands (ala ATAPI devices behind certain bridges, or devices
			101	* which simply have broken INQUIRY data).
			102	*
			103	* NOTE: This means /dev/sg programs (ala cdrecord) will get the
			104	* actual information.  This seems to be the preference for
			105	* programs like that.
			106	*
			107	* NOTE: This also means that /proc/scsi/scsi and sysfs may report
			108	* the actual value or the modified one, depending on where the
			109	* data comes from.
			110	*/
0	6	-	111	if (sdev->scsi_level < SCSI_2)
			112	sdev->scsi_level = sdev->sdev_target->scsi_level = SCSI_2;
			113
			114	/* According to the technical support people at Genesys Logic,
			115	* devices using their chips have problems transferring more than
			116	* 32 KB at a time.  In practice people have found that 64 KB
			117	* works okay and that's what Windows does.  But we'll be
			118	* conservative; people can always use the sysfs interface to
			119	* increase max_sectors. */
			120	if (le16_to_cpu(us->pusb_dev->descriptor.idVendor) == USB_VENDOR_ID_GENESYS &&
0	6	-	121	sdev->request_queue->max_sectors > 64)
0		-	121	T && T
	0	-	121	T && F
	6		121	F && _
			122	blk_queue_max_sectors(sdev->request_queue, 64);
			123
			124	/* We can't put these settings in slave_alloc() because that gets
			125	* called before the device type is known.  Consequently these
			126	* settings can't be overridden via the scsi devinfo mechanism. */
6	0	-	127	if (sdev->type == TYPE_DISK) {
			128
			129	/* Disk-type devices use MODE SENSE(6) if the protocol
			130	* (SubClass) is Transparent SCSI, otherwise they use
			131	* MODE SENSE(10). */
0	6	-	132	if (us->subclass != US_SC_SCSI)
			133	sdev->use_10_for_ms = 1;
			134
			135	/* Many disks only accept MODE SENSE transfer lengths of
			136	* 192 bytes (that's what Windows uses). */
			137	sdev->use_192_bytes_for_3f = 1;
			138
			139	/* Some devices don't like MODE SENSE with page=0x3f,
			140	* which is the command used for checking if a device
			141	* is write-protected.  Now that we tell the sd driver
			142	* to do a 192-byte transfer with this command the
			143	* majority of devices work fine, but a few still can't
			144	* handle it.  The sd driver will simply assume those
			145	* devices are write-enabled. */
0	6	-	146	if (us->flags & US_FL_NO_WP_DETECT)
			147	sdev->skip_ms_page_3f = 1;
			148
			149	/* A number of devices have problems with MODE SENSE for
			150	* page x08, so we will skip it. */
			151	sdev->skip_ms_page_8 = 1;
			152
			153	/* Some disks return the total number of blocks in response
			154	* to READ CAPACITY rather than the highest block number.
			155	* If this device makes that mistake, tell the sd driver. */
0	6	-	156	if (us->flags & US_FL_FIX_CAPACITY)
			157	sdev->fix_capacity = 1;
			158
			159	/* Some devices report a SCSI revision level above 2 but are
			160	* unable to handle the REPORT LUNS command (for which
			161	* support is mandatory at level 3).  Since we already have
			162	* a Get-Max-LUN request, we won't lose much by setting the
			163	* revision level down to 2.  The only devices that would be
			164	* affected are those with sparse LUNs. */
			165	sdev->scsi_level = sdev->sdev_target->scsi_level = SCSI_2;
			166
			167	/* USB-IDE bridges tend to report SK = 0x04 (Non-recoverable
			168	* Hardware Error) when any low-level error occurs,
			169	* recoverable or not.  Setting this flag tells the SCSI
			170	* midlayer to retry such commands, which frequently will
			171	* succeed and fix the error.  The worst this can lead to
			172	* is an occasional series of retries that will all fail. */
			173	sdev->retry_hwerror = 1;
			174
			175	} else {
			176
			177	/* Non-disk-type devices don't need to blacklist any pages
			178	* or to force 192-byte transfer lengths for MODE SENSE.
			179	* But they do need to use MODE SENSE(10). */
			180	sdev->use_10_for_ms = 1;
			181	}
			182
			183	/* Some devices choke when they receive a PREVENT-ALLOW MEDIUM
			184	* REMOVAL command, so suppress those commands. */
0	6	-	185	if (us->flags & US_FL_NOT_LOCKABLE)
			186	sdev->lockable = 0;
			187
			188	/* this is to satisfy the compiler, tho I don't think the
			189	* return code is ever checked anywhere. */
6			190	return 0;
			191	}
			192
			193	/* queue a command */
			194	/* This is always called with scsi_lock(host) held */
2098	0		195	static int queuecommand(struct scsi_cmnd *srb,
			196	void (*done)(struct scsi_cmnd *))
			197	{
			198	struct us_data *us = host_to_us(srb->device->host);
			199
			200	US_DEBUGP("%s called\n", __FUNCTION__);
			201
			202	/* check for state-transition errors */
0	2098	-	203	if (us->srb != NULL) {
			204	printk(KERN_ERR USB_STORAGE "Error in %s: us->srb = %p\n",
			205	__FUNCTION__, us->srb);
0		-	206	return SCSI_MLQUEUE_HOST_BUSY;
			207	}
			208
			209	/* fail the command if we are disconnecting */
0	2098	-	210	if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
2098	0	-	210	ternary-?: __builtin_constant_p ( 21 )
			211	US_DEBUGP("Fail command during disconnect\n");
			212	srb->result = DID_NO_CONNECT << 16;
			213	done(srb);
0		-	214	return 0;
			215	}
			216
			217	/* enqueue the command and wake up the control thread */
			218	srb->scsi_done = done;
			219	us->srb = srb;
			220	up(&(us->sema));
			221
2098			222	return 0;
			223	}
			224
			225	/***********************************************************************
			226	* Error handling functions
			227	***********************************************************************/
			228
			229	/* Command timeout and abort */
0	0	-	230	static int command_abort(struct scsi_cmnd *srb)
			231	{
			232	struct us_data *us = host_to_us(srb->device->host);
			233
			234	US_DEBUGP("%s called\n", __FUNCTION__);
			235
			236	/* us->srb together with the TIMED_OUT, RESETTING, and ABORTING
			237	* bits are protected by the host lock. */
			238	scsi_lock(us_to_host(us));
			238	do
			238	do
0	0	-	238	do-while (0)
0	0	-	238	do-while (0)
0	0	-	238	do-while (0)
			239
			240	/* Is this command still active? */
0	0	-	241	if (us->srb != srb) {
			242	scsi_unlock(us_to_host(us));
			242	do
			242	do
0	0	-	242	do-while (0)
0	0	-	242	do-while (0)
0	0	-	242	do-while (0)
			243	US_DEBUGP ("-- nothing to abort\n");
0		-	244	return FAILED;
			245	}
			246
			247	/* Set the TIMED_OUT bit.  Also set the ABORTING bit, but only if
			248	* a device reset isn't already in progress (to avoid interfering
			249	* with the reset).  Note that we must retain the host lock while
			250	* calling usb_stor_stop_transport(); otherwise it might interfere
			251	* with an auto-reset that begins as soon as we release the lock. */
			252	set_bit(US_FLIDX_TIMED_OUT, &us->flags);
0	0	-	253	if (!test_bit(US_FLIDX_RESETTING, &us->flags)) {
0	0	-	253	ternary-?: __builtin_constant_p ( 22 )
			254	set_bit(US_FLIDX_ABORTING, &us->flags);
			255	usb_stor_stop_transport(us);
			256	}
			257	scsi_unlock(us_to_host(us));
			257	do
			257	do
0	0	-	257	do-while (0)
0	0	-	257	do-while (0)
0	0	-	257	do-while (0)
			258
			259	/* Wait for the aborted command to finish */
			260	wait_for_completion(&us->notify);
0		-	261	return SUCCESS;
			262	}
			263
			264	/* This invokes the transport reset mechanism to reset the state of the
			265	* device */
0	0	-	266	static int device_reset(struct scsi_cmnd *srb)
			267	{
			268	struct us_data *us = host_to_us(srb->device->host);
			269	int result;
			270
			271	US_DEBUGP("%s called\n", __FUNCTION__);
			272
			273	/* lock the device pointers and do the reset */
			274	down(&(us->dev_semaphore));
			275	result = us->transport_reset(us);
			276	up(&(us->dev_semaphore));
			277
			278	return result < 0 ? FAILED : SUCCESS;
0	0	-	278	ternary-?: result < 0
0		-	278	return result < 0 ? 0x2003 : 0x2002
			279	}
			280
			281	/* Simulate a SCSI bus reset by resetting the device's USB port. */
0	0	-	282	static int bus_reset(struct scsi_cmnd *srb)
			283	{
			284	struct us_data *us = host_to_us(srb->device->host);
			285	int result;
			286
			287	US_DEBUGP("%s called\n", __FUNCTION__);
			288
			289	down(&(us->dev_semaphore));
			290	result = usb_stor_port_reset(us);
			291	up(&(us->dev_semaphore));
			292
			293	return result < 0 ? FAILED : SUCCESS;
0	0	-	293	ternary-?: result < 0
0		-	293	return result < 0 ? 0x2003 : 0x2002
			294	}
			295
			296	/* Report a driver-initiated device reset to the SCSI layer.
			297	* Calling this for a SCSI-initiated reset is unnecessary but harmless.
			298	* The caller must own the SCSI host lock. */
0	0	-	299	void usb_stor_report_device_reset(struct us_data *us)
			300	{
			301	int i;
			302	struct Scsi_Host *host = us_to_host(us);
			303
			304	scsi_report_device_reset(host, 0, 0);
0	0	-	305	if (us->flags & US_FL_SCM_MULT_TARG) {
0	0	-	306	for (i = 1; i < host->max_id; ++i)
			307	scsi_report_device_reset(host, 0, i);
			308	}
			309	}
			310
			311	/* Report a driver-initiated bus reset to the SCSI layer.
			312	* Calling this for a SCSI-initiated reset is unnecessary but harmless.
			313	* The caller must own the SCSI host lock. */
0	0	-	314	void usb_stor_report_bus_reset(struct us_data *us)
			315	{
			316	scsi_report_bus_reset(us_to_host(us), 0);
			317	}
			318
			319	/***********************************************************************
			320	* /proc/scsi/ functions
			321	***********************************************************************/
			322
			323	/* we use this macro to help us write into the buffer */
			324	#undef SPRINTF
			325	#define SPRINTF(args...) \
			326	do { if (pos < buffer+length) pos += sprintf(pos, ## args); } while (0)
			327
0	0	-	328	static int proc_info (struct Scsi_Host *host, char *buffer,
			329	char **start, off_t offset, int length, int inout)
			330	{
			331	struct us_data *us = host_to_us(host);
			332	char *pos = buffer;
			333	const char *string;
			334
			335	/* if someone is sending us data, just throw it away */
0	0	-	336	if (inout)
0		-	337	return length;
			338
			339	/* print the controller name */
			340	SPRINTF("   Host scsi%d: usb-storage\n", host->host_no);
0	0	-	340	if (pos < buffer + length)
0	0	-	340	do-while (0)
			341
			342	/* print product, vendor, and serial number strings */
0	0	-	343	if (us->pusb_dev->manufacturer)
			344	string = us->pusb_dev->manufacturer;
0	0	-	345	else if (us->unusual_dev->vendorName)
			346	string = us->unusual_dev->vendorName;
			347	else
			348	string = "Unknown";
			349	SPRINTF("       Vendor: %s\n", string);
0	0	-	349	if (pos < buffer + length)
0	0	-	349	do-while (0)
0	0	-	350	if (us->pusb_dev->product)
			351	string = us->pusb_dev->product;
0	0	-	352	else if (us->unusual_dev->productName)
			353	string = us->unusual_dev->productName;
			354	else
			355	string = "Unknown";
			356	SPRINTF("      Product: %s\n", string);
0	0	-	356	if (pos < buffer + length)
0	0	-	356	do-while (0)
0	0	-	357	if (us->pusb_dev->serial)
			358	string = us->pusb_dev->serial;
			359	else
			360	string = "None";
			361	SPRINTF("Serial Number: %s\n", string);
0	0	-	361	if (pos < buffer + length)
0	0	-	361	do-while (0)
			362
			363	/* show the protocol and transport */
			364	SPRINTF("     Protocol: %s\n", us->protocol_name);
0	0	-	364	if (pos < buffer + length)
0	0	-	364	do-while (0)
			365	SPRINTF("    Transport: %s\n", us->transport_name);
0	0	-	365	if (pos < buffer + length)
0	0	-	365	do-while (0)
			366
			367	/* show the device flags */
0	0	-	368	if (pos < buffer + length) {
			369	pos += sprintf(pos, "       Quirks:");
			370
			371	#define US_FLAG(name, value) \
			372	if (us->flags & value) pos += sprintf(pos, " " #name);
0	0	-	373	US_DO_ALL_FLAGS
0	0	-	373	if (us -> flags & 0x00000002)
0	0	-	373	if (us -> flags & 0x00000004)
0	0	-	373	if (us -> flags & 0x00000008)
0	0	-	373	if (us -> flags & 0x00000010)
0	0	-	373	if (us -> flags & 0x00000020)
0	0	-	373	if (us -> flags & 0x00000040)
0	0	-	373	if (us -> flags & 0x00000080)
0	0	-	373	if (us -> flags & 0x00000100)
0	0	-	373	if (us -> flags & 0x00000200)
			374	#undef US_FLAG
			375
			376	*(pos++) = '\n';
			377	}
			378
			379	/*
			380	* Calculate start of next buffer, and return value.
			381	*/
			382	*start = buffer + offset;
			383
0	0	-	384	if ((pos - buffer) < offset)
0		-	385	return (0);
0	0	-	386	else if ((pos - buffer - offset) < length)
0		-	387	return (pos - buffer - offset);
			388	else
0		-	389	return (length);
			390	}
			391
			392	/***********************************************************************
			393	* Sysfs interface
			394	***********************************************************************/
			395
			396	/* Output routine for the sysfs max_sectors file */
0	0	-	397	static ssize_t show_max_sectors(struct device *dev, struct device_attribute *attr, char *buf)
			398	{
			399	struct scsi_device *sdev = to_scsi_device(dev);
			400
0		-	401	return sprintf(buf, "%u\n", sdev->request_queue->max_sectors);
			402	}
			403
			404	/* Input routine for the sysfs max_sectors file */
0	0	-	405	static ssize_t store_max_sectors(struct device *dev, struct device_attribute *attr, const char *buf,
			406	size_t count)
			407	{
			408	struct scsi_device *sdev = to_scsi_device(dev);
			409	unsigned short ms;
			410
0	0	-	411	if (sscanf(buf, "%hu", &ms) > 0 && ms <= SCSI_DEFAULT_MAX_SECTORS) {
0		-	411	T && T
	0	-	411	T && F
	0	-	411	F && _
			412	blk_queue_max_sectors(sdev->request_queue, ms);
0		-	413	return strlen(buf);
			414	}
0		-	415	return -EINVAL;
			416	}
			417
			418	static DEVICE_ATTR(max_sectors, S_IRUGO | S_IWUSR, show_max_sectors,
			419	store_max_sectors);
			420
			421	static struct device_attribute *sysfs_device_attr_list[] = {
			422	&dev_attr_max_sectors,
			423	NULL,
			424	};
			425
			426	/*
			427	* this defines our host template, with which we'll allocate hosts
			428	*/
			429
			430	struct scsi_host_template usb_stor_host_template = {
			431	/* basic userland interface stuff */
			432	.name =            "usb-storage",
			433	.proc_name =         "usb-storage",
			434	.proc_info =         proc_info,
			435	.info =            host_info,
			436
			437	/* command interface -- queued only */
			438	.queuecommand =         queuecommand,
			439
			440	/* error and abort handlers */
			441	.eh_abort_handler =      command_abort,
			442	.eh_device_reset_handler =   device_reset,
			443	.eh_bus_reset_handler =      bus_reset,
			444
			445	/* queue commands only, only one command per LUN */
			446	.can_queue =         1,
			447	.cmd_per_lun =         1,
			448
			449	/* unknown initiator id */
			450	.this_id =         -1,
			451
			452	.slave_alloc =         slave_alloc,
			453	.slave_configure =      slave_configure,
			454
			455	/* lots of sg segments can be handled */
			456	.sg_tablesize =         SG_ALL,
			457
			458	/* limit the total size of a transfer to 120 KB */
			459	.max_sectors =                  240,
			460
			461	/* merge commands... this seems to help performance, but
			462	* periodically someone should test to see which setting is more
			463	* optimal.
			464	*/
			465	.use_clustering =      1,
			466
			467	/* emulated HBA */
			468	.emulated =         1,
			469
			470	/* we do our own delay after a device or bus reset */
			471	.skip_settle_delay =      1,
			472
			473	/* sysfs device attributes */
			474	.sdev_attrs =         sysfs_device_attr_list,
			475
			476	/* module management */
			477	.module =         THIS_MODULE
			478	};
			479
			480	/* To Report "Illegal Request: Invalid Field in CDB */
			481	unsigned char usb_stor_sense_invalidCDB[18] = {
			482	[0]   = 0x70,             /* current error */
&n