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

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

File: drivers/usb/storage/transport.c
Instrumentation mode: function-decision-multicondition
TER: 28 % ( 95/345)

Start/	End/
True	False	-	Line	Source
			1	/* Driver for USB Mass Storage compliant devices
			2	*
			3	* $Id: transport.c,v 1.47 2002/04/22 03:39:43 mdharm Exp $
			4	*
			5	* Current development and maintenance by:
			6	*   (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
			7	*
			8	* Developed with the assistance of:
			9	*   (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
			10	*   (c) 2000 Stephen J. Gowdy (SGowdy@lbl.gov)
			11	*   (c) 2002 Alan Stern <stern@rowland.org>
			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/config.h>
			49	#include <linux/sched.h>
			50	#include <linux/errno.h>
			51	#include <linux/slab.h>
			52
			53	#include <scsi/scsi.h>
			54	#include <scsi/scsi_cmnd.h>
			55	#include <scsi/scsi_device.h>
			56
			57	#include "usb.h"
			58	#include "transport.h"
			59	#include "protocol.h"
			60	#include "scsiglue.h"
			61	#include "debug.h"
			62
			63
			64	/***********************************************************************
			65	* Data transfer routines
			66	***********************************************************************/
			67
			68	/*
			69	* This is subtle, so pay attention:
			70	* ---------------------------------
			71	* We're very concerned about races with a command abort.  Hanging this code
			72	* is a sure fire way to hang the kernel.  (Note that this discussion applies
			73	* only to transactions resulting from a scsi queued-command, since only
			74	* these transactions are subject to a scsi abort.  Other transactions, such
			75	* as those occurring during device-specific initialization, must be handled
			76	* by a separate code path.)
			77	*
			78	* The abort function (usb_storage_command_abort() in scsiglue.c) first
			79	* sets the machine state and the ABORTING bit in us->flags to prevent
			80	* new URBs from being submitted.  It then calls usb_stor_stop_transport()
			81	* below, which atomically tests-and-clears the URB_ACTIVE bit in us->flags
			82	* to see if the current_urb needs to be stopped.  Likewise, the SG_ACTIVE
			83	* bit is tested to see if the current_sg scatter-gather request needs to be
			84	* stopped.  The timeout callback routine does much the same thing.
			85	*
			86	* When a disconnect occurs, the DISCONNECTING bit in us->flags is set to
			87	* prevent new URBs from being submitted, and usb_stor_stop_transport() is
			88	* called to stop any ongoing requests.
			89	*
			90	* The submit function first verifies that the submitting is allowed
			91	* (neither ABORTING nor DISCONNECTING bits are set) and that the submit
			92	* completes without errors, and only then sets the URB_ACTIVE bit.  This
			93	* prevents the stop_transport() function from trying to cancel the URB
			94	* while the submit call is underway.  Next, the submit function must test
			95	* the flags to see if an abort or disconnect occurred during the submission
			96	* or before the URB_ACTIVE bit was set.  If so, it's essential to cancel
			97	* the URB if it hasn't been cancelled already (i.e., if the URB_ACTIVE bit
			98	* is still set).  Either way, the function must then wait for the URB to
			99	* finish.  Note that the URB can still be in progress even after a call to
			100	* usb_unlink_urb() returns.
			101	*
			102	* The idea is that (1) once the ABORTING or DISCONNECTING bit is set,
			103	* either the stop_transport() function or the submitting function
			104	* is guaranteed to call usb_unlink_urb() for an active URB,
			105	* and (2) test_and_clear_bit() prevents usb_unlink_urb() from being
			106	* called more than once or from being called during usb_submit_urb().
			107	*/
			108
			109	/* This is the completion handler which will wake us up when an URB
			110	* completes.
			111	*/
4175	4175		112	static void usb_stor_blocking_completion(struct urb *urb, struct pt_regs *regs)
			113	{
			114	struct completion *urb_done_ptr = (struct completion *)urb->context;
			115
			116	complete(urb_done_ptr);
			117	}
			118
			119	/* This is the timeout handler which will cancel an URB when its timeout
			120	* expires.
			121	*/
0	0	-	122	static void timeout_handler(unsigned long us_)
			123	{
			124	struct us_data *us = (struct us_data *) us_;
			125
0	0	-	126	if (test_and_clear_bit(US_FLIDX_URB_ACTIVE, &us->flags)) {
			127	US_DEBUGP("Timeout -- cancelling URB\n");
			128	usb_unlink_urb(us->current_urb);
			129	}
			130	}
			131
			132	/* This is the common part of the URB message submission code
			133	*
			134	* All URBs from the usb-storage driver involved in handling a queued scsi
			135	* command _must_ pass through this function (or something like it) for the
			136	* abort mechanisms to work properly.
			137	*/
4175	0		138	static int usb_stor_msg_common(struct us_data *us, int timeout)
			139	{
			140	struct completion urb_done;
			141	struct timer_list to_timer;
			142	int status;
			143
			144	/* don't submit URBs during abort/disconnect processing */
0	4175	-	145	if (us->flags & ABORTING_OR_DISCONNECTING)
0		-	146	return -EIO;
			147
			148	/* set up data structures for the wakeup system */
			149	init_completion(&urb_done);
			150
			151	/* fill the common fields in the URB */
			152	us->current_urb->context = &urb_done;
			153	us->current_urb->actual_length = 0;
			154	us->current_urb->error_count = 0;
			155	us->current_urb->status = 0;
			156
			157	/* we assume that if transfer_buffer isn't us->iobuf then it
			158	* hasn't been mapped for DMA.  Yes, this is clunky, but it's
			159	* easier than always having the caller tell us whether the
			160	* transfer buffer has already been mapped. */
			161	us->current_urb->transfer_flags = URB_NO_SETUP_DMA_MAP;
4156	19		162	if (us->current_urb->transfer_buffer == us->iobuf)
			163	us->current_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
			164	us->current_urb->transfer_dma = us->iobuf_dma;
			165	us->current_urb->setup_dma = us->cr_dma;
			166
			167	/* submit the URB */
			168	status = usb_submit_urb(us->current_urb, GFP_NOIO);
0	4175	-	169	if (status) {
			170	/* something went wrong */
0		-	171	return status;
			172	}
			173
			174	/* since the URB has been submitted successfully, it's now okay
			175	* to cancel it */
			176	set_bit(US_FLIDX_URB_ACTIVE, &us->flags);
			177
			178	/* did an abort/disconnect occur during the submission? */
0	4175	-	179	if (us->flags & ABORTING_OR_DISCONNECTING) {
			180
			181	/* cancel the URB, if it hasn't been cancelled already */
0	0	-	182	if (test_and_clear_bit(US_FLIDX_URB_ACTIVE, &us->flags)) {
			183	US_DEBUGP("-- cancelling URB\n");
			184	usb_unlink_urb(us->current_urb);
			185	}
			186	}
			187
			188	/* submit the timeout timer, if a timeout was requested */
6	4169		189	if (timeout > 0) {
			190	init_timer(&to_timer);
			191	to_timer.expires = jiffies + timeout;
			192	to_timer.function = timeout_handler;
			193	to_timer.data = (unsigned long) us;
			194	add_timer(&to_timer);
			195	}
			196
			197	/* wait for the completion of the URB */
			198	wait_for_completion(&urb_done);
			199	clear_bit(US_FLIDX_URB_ACTIVE, &us->flags);
			200
			201	/* clean up the timeout timer */
6	4169		202	if (timeout > 0)
			203	del_timer_sync(&to_timer);
			204
			205	/* return the URB status */
4175			206	return us->current_urb->status;
			207	}
			208
			209	/*
			210	* Transfer one control message, with timeouts, and allowing early
			211	* termination.  Return codes are usual -Exxx, *not* USB_STOR_XFER_xxx.
			212	*/
6	0		213	int usb_stor_control_msg(struct us_data *us, unsigned int pipe,
			214	u8 request, u8 requesttype, u16 value, u16 index,
			215	void *data, u16 size, int timeout)
			216	{
			217	int status;
			218
			219	US_DEBUGP("%s: rq=%02x rqtype=%02x value=%04x index=%02x len=%u\n",
			220	__FUNCTION__, request, requesttype,
			221	value, index, size);
			222
			223	/* fill in the devrequest structure */
			224	us->cr->bRequestType = requesttype;
			225	us->cr->bRequest = request;
			226	us->cr->wValue = cpu_to_le16(value);
			227	us->cr->wIndex = cpu_to_le16(index);
			228	us->cr->wLength = cpu_to_le16(size);
			229
			230	/* fill and submit the URB */
			231	usb_fill_control_urb(us->current_urb, us->pusb_dev, pipe,
			232	(unsigned char*) us->cr, data, size,
			233	usb_stor_blocking_completion, NULL);
			234	status = usb_stor_msg_common(us, timeout);
			235
			236	/* return the actual length of the data transferred if no error */
6	0	-	237	if (status == 0)
			238	status = us->current_urb->actual_length;
6			239	return status;
			240	}
			241
			242	/* This is a version of usb_clear_halt() that allows early termination and
			243	* doesn't read the status from the device -- this is because some devices
			244	* crash their internal firmware when the status is requested after a halt.
			245	*
			246	* A definitive list of these 'bad' devices is too difficult to maintain or
			247	* make complete enough to be useful.  This problem was first observed on the
			248	* Hagiwara FlashGate DUAL unit.  However, bus traces reveal that neither
			249	* MacOS nor Windows checks the status after clearing a halt.
			250	*
			251	* Since many vendors in this space limit their testing to interoperability
			252	* with these two OSes, specification violations like this one are common.
			253	*/
0	0	-	254	int usb_stor_clear_halt(struct us_data *us, unsigned int pipe)
			255	{
			256	int result;
			257	int endp = usb_pipeendpoint(pipe);
			258
0	0	-	259	if (usb_pipein (pipe))
			260	endp |= USB_DIR_IN;
			261
			262	result = usb_stor_control_msg(us, us->send_ctrl_pipe,
			263	USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT,
			264	USB_ENDPOINT_HALT, endp,
			265	NULL, 0, 3*HZ);
			266
			267	/* reset the endpoint toggle */
0	0	-	268	if (result >= 0)
			269	usb_settoggle(us->pusb_dev, usb_pipeendpoint(pipe),
			270	usb_pipeout(pipe), 0);
			271
			272	US_DEBUGP("%s: result = %d\n", __FUNCTION__, result);
0		-	273	return result;
			274	}
			275
			276
			277	/*
			278	* Interpret the results of a URB transfer
			279	*
			280	* This function prints appropriate debugging messages, clears halts on
			281	* non-control endpoints, and translates the status to the corresponding
			282	* USB_STOR_XFER_xxx return code.
			283	*/
6202	0		284	static int interpret_urb_result(struct us_data *us, unsigned int pipe,
			285	unsigned int length, int result, unsigned int partial)
			286	{
			287	US_DEBUGP("Status code %d; transferred %u/%u\n",
			288	result, partial, length);
			289	switch (result) {
			290
			291	/* no error code; did we send all the data? */
6200			292	case 0:
0	6200	-	293	if (partial != length) {
			294	US_DEBUGP("-- short transfer\n");
0		-	295	return USB_STOR_XFER_SHORT;
			296	}
			297
			298	US_DEBUGP("-- transfer complete\n");
6200			299	return USB_STOR_XFER_GOOD;
			300
			301	/* stalled */
0		-	302	case -EPIPE:
			303	/* for control endpoints, (used by CB[I]) a stall indicates
			304	* a failed command */
0	0	-	305	if (usb_pipecontrol(pipe)) {
			306	US_DEBUGP("-- stall on control pipe\n");
0		-	307	return USB_STOR_XFER_STALLED;
			308	}
			309
			310	/* for other sorts of endpoint, clear the stall */
			311	US_DEBUGP("clearing endpoint halt for pipe 0x%x\n", pipe);
0	0	-	312	if (usb_stor_clear_halt(us, pipe) < 0)
0		-	313	return USB_STOR_XFER_ERROR;
0		-	314	return USB_STOR_XFER_STALLED;
			315
			316	/* timeout or excessively long NAK */
0		-	317	case -ETIMEDOUT:
			318	US_DEBUGP("-- timeout or NAK\n");
0		-	319	return USB_STOR_XFER_ERROR;
			320
			321	/* babble - the device tried to send more than we wanted to read */
0		-	322	case -EOVERFLOW:
			323	US_DEBUGP("-- babble\n");
0		-	324	return USB_STOR_XFER_LONG;
			325
			326	/* the transfer was cancelled by abort, disconnect, or timeout */
0		-	327	case -ECONNRESET:
			328	US_DEBUGP("-- transfer cancelled\n");
0		-	329	return USB_STOR_XFER_ERROR;
			330
			331	/* short scatter-gather read transfer */
2			332	case -EREMOTEIO:
			333	US_DEBUGP("-- short read transfer\n");
2			334	return USB_STOR_XFER_SHORT;
			335
			336	/* abort or disconnect in progress */
0		-	337	case -EIO:
			338	US_DEBUGP("-- abort or disconnect in progress\n");
0		-	339	return USB_STOR_XFER_ERROR;
			340
			341	/* the catch-all error case */
0		-	342	default:
			343	US_DEBUGP("-- unknown error\n");
0		-	344	return USB_STOR_XFER_ERROR;
			345	}
			346	}
			347
			348	/*
			349	* Transfer one control message, without timeouts, but allowing early
			350	* termination.  Return codes are USB_STOR_XFER_xxx.
			351	*/
0	0	-	352	int usb_stor_ctrl_transfer(struct us_data *us, unsigned int pipe,
			353	u8 request, u8 requesttype, u16 value, u16 index,
			354	void *data, u16 size)
			355	{
			356	int result;
			357
			358	US_DEBUGP("%s: rq=%02x rqtype=%02x value=%04x index=%02x len=%u\n",
			359	__FUNCTION__, request, requesttype,
			360	value, index, size);
			361
			362	/* fill in the devrequest structure */
			363	us->cr->bRequestType = requesttype;
			364	us->cr->bRequest = request;
			365	us->cr->wValue = cpu_to_le16(value);
			366	us->cr->wIndex = cpu_to_le16(index);
			367	us->cr->wLength = cpu_to_le16(size);
			368
			369	/* fill and submit the URB */
			370	usb_fill_control_urb(us->current_urb, us->pusb_dev, pipe,
			371	(unsigned char*) us->cr, data, size,
			372	usb_stor_blocking_completion, NULL);
			373	result = usb_stor_msg_common(us, 0);
			374
			375	return interpret_urb_result(us, pipe, size, result,
0		-	376	us->current_urb->actual_length);
			377	}
			378
			379	/*
			380	* Receive one interrupt buffer, without timeouts, but allowing early
			381	* termination.  Return codes are USB_STOR_XFER_xxx.
			382	*
			383	* This routine always uses us->recv_intr_pipe as the pipe and
			384	* us->ep_bInterval as the interrupt interval.
			385	*/
0	0	-	386	static int usb_stor_intr_transfer(struct us_data *us, void *buf,
			387	unsigned int length)
			388	{
			389	int result;
			390	unsigned int pipe = us->recv_intr_pipe;
			391	unsigned int maxp;
			392
			393	US_DEBUGP("%s: xfer %u bytes\n", __FUNCTION__, length);
			394
			395	/* calculate the max packet size */
			396	maxp = usb_maxpacket(us->pusb_dev, pipe, usb_pipeout(pipe));
0	0	-	397	if (maxp > length)
			398	maxp = length;
			399
			400	/* fill and submit the URB */
			401	usb_fill_int_urb(us->current_urb, us->pusb_dev, pipe, buf,
			402	maxp, usb_stor_blocking_completion, NULL,
			403	us->ep_bInterval);
			404	result = usb_stor_msg_common(us, 0);
			405
			406	return interpret_urb_result(us, pipe, length, result,
0		-	407	us->current_urb->actual_length);
			408	}
			409
			410	/*
			411	* Transfer one buffer via bulk pipe, without timeouts, but allowing early
			412	* termination.  Return codes are USB_STOR_XFER_xxx.  If the bulk pipe
			413	* stalls during the transfer, the halt is automatically cleared.
			414	*/
4169	0		415	int usb_stor_bulk_transfer_buf(struct us_data *us, unsigned int pipe,
			416	void *buf, unsigned int length, unsigned int *act_len)
			417	{
			418	int result;
			419
			420	US_DEBUGP("%s: xfer %u bytes\n", __FUNCTION__, length);
			421
			422	/* fill and submit the URB */
			423	usb_fill_bulk_urb(us->current_urb, us->pusb_dev, pipe, buf, length,
			424	usb_stor_blocking_completion, NULL);
			425	result = usb_stor_msg_common(us, 0);
			426
			427	/* store the actual length of the data transferred */
2094	2075		428	if (act_len)
			429	*act_len = us->current_urb->actual_length;
			430	return interpret_urb_result(us, pipe, length, result,
4169			431	us->current_urb->actual_length);
			432	}
			433
			434	/*
			435	* Transfer a scatter-gather list via bulk transfer
			436	*
			437	* This function does basically the same thing as usb_stor_bulk_transfer_buf()
			438	* above, but it uses the usbcore scatter-gather library.
			439	*/
2033	0		440	static int usb_stor_bulk_transfer_sglist(struct us_data *us, unsigned int pipe,
			441	struct scatterlist *sg, int num_sg, unsigned int length,
			442	unsigned int *act_len)
			443	{
			444	int result;
			445
			446	/* don't submit s-g requests during abort/disconnect processing */
0	2033	-	447	if (us->flags & ABORTING_OR_DISCONNECTING)
0		-	448	return USB_STOR_XFER_ERROR;
			449
			450	/* initialize the scatter-gather request block */
			451	US_DEBUGP("%s: xfer %u bytes, %d entries\n", __FUNCTION__,
			452	length, num_sg);
			453	result = usb_sg_init(&us->current_sg, us->pusb_dev, pipe, 0,
			454	sg, num_sg, length, SLAB_NOIO);
0	2033	-	455	if (result) {
			456	US_DEBUGP("usb_sg_init returned %d\n", result);
0		-	457	return USB_STOR_XFER_ERROR;
			458	}
			459
			460	/* since the block has been initialized successfully, it's now
			461	* okay to cancel it */
			462	set_bit(US_FLIDX_SG_ACTIVE, &us->flags);
			463
			464	/* did an abort/disconnect occur during the submission? */
0	2033	-	465	if (us->flags & ABORTING_OR_DISCONNECTING) {
			466
			467	/* cancel the request, if it hasn't been cancelled already */
0	0	-	468	if (test_and_clear_bit(US_FLIDX_SG_ACTIVE, &us->flags)) {
			469	US_DEBUGP("-- cancelling sg request\n");
			470	usb_sg_cancel(&us->current_sg);
			471	}
			472	}
			473
			474	/* wait for the completion of the transfer */
			475	usb_sg_wait(&us->current_sg);
			476	clear_bit(US_FLIDX_SG_ACTIVE, &us->flags);
			477
			478	result = us->current_sg.status;
2033	0	-	479	if (act_len)
			480	*act_len = us->current_sg.bytes;
			481	return interpret_urb_result(us, pipe, length, result,
2033			482	us->current_sg.bytes);
			483	}
			484
			485	/*
			486	* Transfer an entire SCSI command's worth of data payload over the bulk
			487	* pipe.
			488	*
			489	* Note that this uses usb_stor_bulk_transfer_buf() and
			490	* usb_stor_bulk_transfer_sglist() to achieve its goals --
			491	* this function simply determines whether we're going to use
			492	* scatter-gather or not, and acts appropriately.
			493	*/
2052	0		494	int usb_stor_bulk_transfer_sg(struct us_data* us, unsigned int pipe,
			495	void *buf, unsigned int length_left, int use_sg, int *residual)
			496	{
			497	int result;
			498	unsigned int partial;
			499
			500	/* are we scatter-gathering? */
2033	19		501	if (use_sg) {
			502	/* use the usb core scatter-gather primitives */
			503	result = usb_stor_bulk_transfer_sglist(us, pipe,
			504	(struct scatterlist *) buf, use_sg,
			505	length_left, &partial);
			506	length_left -= partial;
			507	} else {
			508	/* no scatter-gather, just make the request */
			509	result = usb_stor_bulk_transfer_buf(us, pipe, buf,
			510	length_left, &partial);
			511	length_left -= partial;
			512	}
			513
			514	/* store the residual and return the error code */
2052	0	-	515	if (residual)
			516	*residual = length_left;
2052			517	return result;
			518	}
			519
			520	/***********************************************************************
			521	* Transport routines
			522	***********************************************************************/
			523
			524	/* Invoke the transport and basic error-handling/recovery methods
			525	*
			526	* This is used by the protocol layers to actually send the message to
			527	* the device and receive the response.
			528	*/
2056	0		529	void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
			530	{
			531	int need_auto_sense;
			532	int result;
			533
			534	/* send the command to the transport layer */
			535	srb->resid = 0;
			536	result = us->transport(srb, us);
			537
			538	/* if the command gets aborted by the higher layers, we need to
			539	* short-circuit all other processing
			540	*/
0	2056	-	541	if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) {
2056	0	-	541	ternary-?: __builtin_constant_p ( 23 )
			542	US_DEBUGP("-- command was aborted\n");
			543	srb->result = DID_ABORT << 16;
0		-	544	goto Handle_Errors;
			545	}
			546
			547	/* if there is a transport error, reset and don't auto-sense */
0	2056	-	548	if (result == USB_STOR_TRANSPORT_ERROR) {
			549	US_DEBUGP("-- transport indicates error, resetting\n");
			550	srb->result = DID_ERROR << 16;
0		-	551	goto Handle_Errors;
			552	}
			553
			554	/* if the transport provided its own sense data, don't aut