自学教程：C++ usb_stor_clear_halt函数代码示例

/* This issues a Bulk-only Reset to the device in question, including * clearing the subsequent endpoint halts that may occur. */int usb_stor_Bulk_reset(struct us_data *us){	int result;	US_DEBUGP("Bulk reset requested/n");	/* if the device was removed, then we're already reset */	if (!us->pusb_dev)		return SUCCESS;	result = usb_control_msg(us->pusb_dev, 				 usb_sndctrlpipe(us->pusb_dev,0), 				 US_BULK_RESET_REQUEST, 				 USB_TYPE_CLASS | USB_RECIP_INTERFACE,				 0, us->ifnum, NULL, 0, HZ*5);	if (result < 0) {		US_DEBUGP("Bulk soft reset failed %d/n", result);		return FAILED;	}	/* long wait for reset */	set_current_state(TASK_UNINTERRUPTIBLE);	schedule_timeout(HZ*6);	set_current_state(TASK_RUNNING);	usb_stor_clear_halt(us,			usb_rcvbulkpipe(us->pusb_dev, us->ep_in));	usb_stor_clear_halt(us,			usb_sndbulkpipe(us->pusb_dev, us->ep_out));	US_DEBUGP("Bulk soft reset completed/n");	return SUCCESS;}

/* Determine what the maximum LUN supported is */int usb_stor_Bulk_max_lun(struct us_data *us){	unsigned char data;	int result;	int pipe;	/* issue the command */	pipe = usb_rcvctrlpipe(us->pusb_dev, 0);	result = usb_control_msg(us->pusb_dev, pipe,				 US_BULK_GET_MAX_LUN, 				 USB_DIR_IN | USB_TYPE_CLASS | 				 USB_RECIP_INTERFACE,				 0, us->ifnum, &data, sizeof(data), HZ);	US_DEBUGP("GetMaxLUN command result is %d, data is %d/n", 		  result, data);	/* if we have a successful request, return the result */	if (result == 1)		return data;	/* if we get a STALL, clear the stall */	if (result == -EPIPE) {		US_DEBUGP("clearing endpoint halt for pipe 0x%x/n", pipe);		usb_stor_clear_halt(us->pusb_dev, pipe);	}	/* return the default -- no LUNs */	return 0;}

/* * This is the common part of the device reset code. * * It's handy that every transport mechanism uses the control endpoint for * resets. * * Basically, we send a reset with a 5-second timeout, so we don't get * jammed attempting to do the reset. */static int usb_stor_reset_common(struct us_data *us,		u8 request, u8 requesttype,		u16 value, u16 index, void *data, u16 size){	int result;	int result2;	if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {		usb_stor_dbg(us, "No reset during disconnect/n");		return -EIO;	}	result = usb_stor_control_msg(us, us->send_ctrl_pipe,			request, requesttype, value, index, data, size,			5*HZ);	if (result < 0) {		usb_stor_dbg(us, "Soft reset failed: %d/n", result);		return result;	}	/*	 * Give the device some time to recover from the reset,	 * but don't delay disconnect processing.	 */	wait_event_interruptible_timeout(us->delay_wait,			test_bit(US_FLIDX_DISCONNECTING, &us->dflags),			HZ*6);	if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {		usb_stor_dbg(us, "Reset interrupted by disconnect/n");		return -EIO;	}	usb_stor_dbg(us, "Soft reset: clearing bulk-in endpoint halt/n");	result = usb_stor_clear_halt(us, us->recv_bulk_pipe);	usb_stor_dbg(us, "Soft reset: clearing bulk-out endpoint halt/n");	result2 = usb_stor_clear_halt(us, us->send_bulk_pipe);	/* return a result code based on the result of the clear-halts */	if (result >= 0)		result = result2;	if (result < 0)		usb_stor_dbg(us, "Soft reset failed/n");	else		usb_stor_dbg(us, "Soft reset done/n");	return result;}

/* * Interpret the results of a URB transfer * * This function prints appropriate debugging messages, clears halts on * non-control endpoints, and translates the status to the corresponding * USB_STOR_XFER_xxx return code. */static int interpret_urb_result(struct us_data *us, unsigned int pipe,		unsigned int length, int result, unsigned int partial){	usb_stor_dbg(us, "Status code %d; transferred %u/%u/n",		     result, partial, length);	switch (result) {	/* no error code; did we send all the data? */	case 0:		if (partial != length) {			usb_stor_dbg(us, "-- short transfer/n");			return USB_STOR_XFER_SHORT;		}		usb_stor_dbg(us, "-- transfer complete/n");		return USB_STOR_XFER_GOOD;	/* stalled */	case -EPIPE:		/* for control endpoints, (used by CB[I]) a stall indicates		 * a failed command */		if (usb_pipecontrol(pipe)) {			usb_stor_dbg(us, "-- stall on control pipe/n");			return USB_STOR_XFER_STALLED;		}		/* for other sorts of endpoint, clear the stall */		usb_stor_dbg(us, "clearing endpoint halt for pipe 0x%x/n",			     pipe);		if (usb_stor_clear_halt(us, pipe) < 0)			return USB_STOR_XFER_ERROR;		return USB_STOR_XFER_STALLED;	/* babble - the device tried to send more than we wanted to read */	case -EOVERFLOW:		usb_stor_dbg(us, "-- babble/n");		return USB_STOR_XFER_LONG;	/* the transfer was cancelled by abort, disconnect, or timeout */	case -ECONNRESET:		usb_stor_dbg(us, "-- transfer cancelled/n");		return USB_STOR_XFER_ERROR;	/* short scatter-gather read transfer */	case -EREMOTEIO:		usb_stor_dbg(us, "-- short read transfer/n");		return USB_STOR_XFER_SHORT;	/* abort or disconnect in progress */	case -EIO:		usb_stor_dbg(us, "-- abort or disconnect in progress/n");		return USB_STOR_XFER_ERROR;	/* the catch-all error case */	default:		usb_stor_dbg(us, "-- unknown error/n");		return USB_STOR_XFER_ERROR;	}}

/* * usb_stor_reset_common() */static int usb_stor_reset_common(struct us_data *us,		u8 request, u8 requesttype,		u16 value, u16 index, void *data, u16 size){	int result;	int result2;	/* pr_info("transport --- usb_stor_reset_common/n"); */	if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {		/* pr_info("No reset during disconnect/n"); */		return -EIO;	}	result = usb_stor_control_msg(us, us->send_ctrl_pipe,			request, requesttype, value, index, data, size,	5*HZ);	if (result < 0) {		/* pr_info("Soft reset failed: %d/n", result); */		return result;	}	wait_event_interruptible_timeout(us->delay_wait,			test_bit(US_FLIDX_DISCONNECTING, &us->dflags),	HZ*6);	if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {		/* pr_info("Reset interrupted by disconnect/n"); */		return -EIO;	}	/* pr_info("Soft reset: clearing bulk-in endpoint halt/n"); */	result = usb_stor_clear_halt(us, us->recv_bulk_pipe);	/* pr_info("Soft reset: clearing bulk-out endpoint halt/n"); */	result2 = usb_stor_clear_halt(us, us->send_bulk_pipe);	/* return a result code based on the result of the clear-halts */	if (result >= 0)		result = result2;	/* if (result < 0) */		/* pr_info("Soft reset failed/n"); */	/* else */		/* pr_info("Soft reset done/n"); */	return result;}

/* * Control/Bulk transport */int usb_stor_CB_transport(Scsi_Cmnd *srb, struct us_data *us){	int result;	/* COMMAND STAGE */	/* let's send the command via the control pipe */	result = usb_stor_control_msg(us, usb_sndctrlpipe(us->pusb_dev,0),				      US_CBI_ADSC, 				      USB_TYPE_CLASS | USB_RECIP_INTERFACE, 0, 				      us->ifnum, srb->cmnd, srb->cmd_len);	/* check the return code for the command */	US_DEBUGP("Call to usb_stor_control_msg() returned %d/n", result);	if (result < 0) {		/* if the command was aborted, indicate that */		if (result == -ECONNRESET)			return USB_STOR_TRANSPORT_ABORTED;		/* a stall is a fatal condition from the device */		if (result == -EPIPE) {			US_DEBUGP("-- Stall on control pipe. Clearing/n");			result = usb_stor_clear_halt(us,				usb_sndctrlpipe(us->pusb_dev, 0));			/* if the command was aborted, indicate that */			if (result == -ECONNRESET)				return USB_STOR_TRANSPORT_ABORTED;			return USB_STOR_TRANSPORT_FAILED;		}		/* Uh oh... serious problem here */		return USB_STOR_TRANSPORT_ERROR;	}	/* DATA STAGE */	/* transfer the data payload for this command, if one exists*/	if (usb_stor_transfer_length(srb)) {		usb_stor_transfer(srb, us);		result = srb->result;		US_DEBUGP("CB data stage result is 0x%x/n", result);		/* report any errors */		if (result == US_BULK_TRANSFER_ABORTED) {			return USB_STOR_TRANSPORT_ABORTED;		}		if (result == US_BULK_TRANSFER_FAILED) {			return USB_STOR_TRANSPORT_FAILED;		}	}	/* STATUS STAGE */	/* NOTE: CB does not have a status stage.  Silly, I know.  So	 * we have to catch this at a higher level.	 */	return USB_STOR_TRANSPORT_GOOD;}

/* * Transfer one SCSI scatter-gather buffer via bulk transfer * * Note that this function is necessary because we want the ability to * use scatter-gather memory.  Good performance is achieved by a combination * of scatter-gather and clustering (which makes each chunk bigger). * * Note that the lower layer will always retry when a NAK occurs, up to the * timeout limit.  Thus we don't have to worry about it for individual * packets. */int usb_stor_transfer_partial(struct us_data *us, char *buf, int length){	int result;	int partial;	int pipe;	/* calculate the appropriate pipe information */	if (us->srb->sc_data_direction == SCSI_DATA_READ)		pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);	else		pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);	/* transfer the data */	US_DEBUGP("usb_stor_transfer_partial(): xfer %d bytes/n", length);	result = usb_stor_bulk_msg(us, buf, pipe, length, &partial);	US_DEBUGP("usb_stor_bulk_msg() returned %d xferred %d/%d/n",		  result, partial, length);	/* if we stall, we need to clear it before we go on */	if (result == -EPIPE) {		US_DEBUGP("clearing endpoint halt for pipe 0x%x/n", pipe);		usb_stor_clear_halt(us->pusb_dev, pipe);	}	/* did we send all the data? */	if (partial == length) {		US_DEBUGP("usb_stor_transfer_partial(): transfer complete/n");		return US_BULK_TRANSFER_GOOD;	}	/* uh oh... we have an error code, so something went wrong. */	if (result) {		/* NAK - that means we've retried a few times already */		if (result == -ETIMEDOUT) {			US_DEBUGP("usb_stor_transfer_partial(): device NAKed/n");			return US_BULK_TRANSFER_FAILED;		}		/* -ENOENT -- we canceled this transfer */		if (result == -ENOENT) {			US_DEBUGP("usb_stor_transfer_partial(): transfer aborted/n");			return US_BULK_TRANSFER_ABORTED;		}		/* the catch-all case */		US_DEBUGP("usb_stor_transfer_partial(): unknown error/n");		return US_BULK_TRANSFER_FAILED;	}	/* no error code, so we must have transferred some data, 	 * just not all of it */	return US_BULK_TRANSFER_SHORT;}

/* Determine what the maximum LUN supported is */int usb_stor_Bulk_max_lun(struct us_data *us){	int result;	/* issue the command */	us->iobuf[0] = 0;	result = usb_stor_control_msg(us, us->recv_ctrl_pipe,				 US_BULK_GET_MAX_LUN, 				 USB_DIR_IN | USB_TYPE_CLASS | 				 USB_RECIP_INTERFACE,				 0, us->ifnum, us->iobuf, 1, HZ);	US_DEBUGP("GetMaxLUN command result is %d, data is %d/n", 		  result, us->iobuf[0]);	/* if we have a successful request, return the result */	if (result > 0)		return us->iobuf[0];	/* 	 * Some devices (i.e. Iomega Zip100) need this -- apparently	 * the bulk pipes get STALLed when the GetMaxLUN request is	 * processed.   This is, in theory, harmless to all other devices	 * (regardless of if they stall or not).	 */	if (result == -EPIPE) {		usb_stor_clear_halt(us, us->recv_bulk_pipe);		usb_stor_clear_halt(us, us->send_bulk_pipe);	}	/*	 * Some devices don't like GetMaxLUN.  They may STALL the control	 * pipe, they may return a zero-length result, they may do nothing at	 * all and timeout, or they may fail in even more bizarrely creative	 * ways.  In these cases the best approach is to use the default	 * value: only one LUN.	 */	return 0;}

//----- interpret_urb_result() ---------------------static int interpret_urb_result(struct us_data *us, unsigned int pipe,		unsigned int length, int result, unsigned int partial){	//printk("transport --- interpret_urb_result/n");	switch (result) {	/* no error code; did we send all the data? */	case 0:		if (partial != length)		{			//printk("-- short transfer/n");			return USB_STOR_XFER_SHORT;		}		//printk("-- transfer complete/n");		return USB_STOR_XFER_GOOD;	case -EPIPE:		if (usb_pipecontrol(pipe))		{			//printk("-- stall on control pipe/n");			return USB_STOR_XFER_STALLED;		}		//printk("clearing endpoint halt for pipe 0x%x/n", pipe);		if (usb_stor_clear_halt(us, pipe) < 0)			return USB_STOR_XFER_ERROR;		return USB_STOR_XFER_STALLED;	case -EOVERFLOW:		//printk("-- babble/n");		return USB_STOR_XFER_LONG;	case -ECONNRESET:		//printk("-- transfer cancelled/n");		return USB_STOR_XFER_ERROR;	case -EREMOTEIO:		//printk("-- short read transfer/n");		return USB_STOR_XFER_SHORT;	case -EIO:		//printk("-- abort or disconnect in progress/n");		return USB_STOR_XFER_ERROR;	default:		//printk("-- unknown error/n");		return USB_STOR_XFER_ERROR;	}}

int usb_stor_CBI_transport(Scsi_Cmnd *srb, struct us_data *us){	int result;	/* Set up for status notification */	atomic_set(us->ip_wanted, 1);	/* re-initialize the mutex so that we avoid any races with	 * early/late IRQs from previous commands */	init_MUTEX_LOCKED(&(us->ip_waitq));	/* COMMAND STAGE */	/* let's send the command via the control pipe */	result = usb_stor_control_msg(us, usb_sndctrlpipe(us->pusb_dev,0),				      US_CBI_ADSC, 				      USB_TYPE_CLASS | USB_RECIP_INTERFACE, 0, 				      us->ifnum, srb->cmnd, srb->cmd_len);	/* check the return code for the command */	US_DEBUGP("Call to usb_stor_control_msg() returned %d/n", result);	if (result < 0) {		/* Reset flag for status notification */		atomic_set(us->ip_wanted, 0);	}	/* if the command was aborted, indicate that */	if (result == -ECONNRESET)		return USB_STOR_TRANSPORT_ABORTED;	/* STALL must be cleared when it is detected */	if (result == -EPIPE) {		US_DEBUGP("-- Stall on control pipe. Clearing/n");		result = usb_stor_clear_halt(us,				usb_sndctrlpipe(us->pusb_dev, 0));		/* if the command was aborted, indicate that */		if (result == -ECONNRESET)			return USB_STOR_TRANSPORT_ABORTED;		return USB_STOR_TRANSPORT_FAILED;	}	if (result < 0) {		/* Uh oh... serious problem here */		return USB_STOR_TRANSPORT_ERROR;	}	/* DATA STAGE */	/* transfer the data payload for this command, if one exists*/	if (usb_stor_transfer_length(srb)) {		usb_stor_transfer(srb, us);		result = srb->result;		US_DEBUGP("CBI data stage result is 0x%x/n", result);		/* report any errors */		if (result == US_BULK_TRANSFER_ABORTED) {			atomic_set(us->ip_wanted, 0);			return USB_STOR_TRANSPORT_ABORTED;		}		if (result == US_BULK_TRANSFER_FAILED) {			atomic_set(us->ip_wanted, 0);			return USB_STOR_TRANSPORT_FAILED;		}	}	/* STATUS STAGE */	/* go to sleep until we get this interrupt */	US_DEBUGP("Current value of ip_waitq is: %d/n", atomic_read(&us->ip_waitq.count));	down(&(us->ip_waitq));	/* if we were woken up by an abort instead of the actual interrupt */	if (atomic_read(us->ip_wanted)) {		US_DEBUGP("Did not get interrupt on CBI/n");		atomic_set(us->ip_wanted, 0);		return USB_STOR_TRANSPORT_ABORTED;	}	US_DEBUGP("Got interrupt data (0x%x, 0x%x)/n", 			us->irqdata[0], us->irqdata[1]);	/* UFI gives us ASC and ASCQ, like a request sense	 *	 * REQUEST_SENSE and INQUIRY don't affect the sense data on UFI	 * devices, so we ignore the information for those commands.  Note	 * that this means we could be ignoring a real error on these	 * commands, but that can't be helped.	 */	if (us->subclass == US_SC_UFI) {		if (srb->cmnd[0] == REQUEST_SENSE ||		    srb->cmnd[0] == INQUIRY)			return USB_STOR_TRANSPORT_GOOD;		else			if (((unsigned char*)us->irq_urb->transfer_buffer)[0])				return USB_STOR_TRANSPORT_FAILED;			else				return USB_STOR_TRANSPORT_GOOD;	}	/* If not UFI, we interpret the data as a result code 	 * The first byte should always be a 0x0//.........这里部分代码省略.........

int usb_stor_CBI_transport(struct scsi_cmnd *srb, struct us_data *us){	unsigned int transfer_length = srb->request_bufflen;	unsigned int pipe = 0;	int result;	/* COMMAND STAGE */	/* let's send the command via the control pipe */	result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,				      US_CBI_ADSC, 				      USB_TYPE_CLASS | USB_RECIP_INTERFACE, 0, 				      us->ifnum, srb->cmnd, srb->cmd_len);	/* check the return code for the command */	US_DEBUGP("Call to usb_stor_ctrl_transfer() returned %d/n", result);	/* if we stalled the command, it means command failed */	if (result == USB_STOR_XFER_STALLED) {		return USB_STOR_TRANSPORT_FAILED;	}	/* Uh oh... serious problem here */	if (result != USB_STOR_XFER_GOOD) {		return USB_STOR_TRANSPORT_ERROR;	}	/* DATA STAGE */	/* transfer the data payload for this command, if one exists*/	if (transfer_length) {		pipe = srb->sc_data_direction == DMA_FROM_DEVICE ? 				us->recv_bulk_pipe : us->send_bulk_pipe;		result = usb_stor_bulk_transfer_sg(us, pipe,					srb->request_buffer, transfer_length,					srb->use_sg, &srb->resid);		US_DEBUGP("CBI data stage result is 0x%x/n", result);		/* if we stalled the data transfer it means command failed */		if (result == USB_STOR_XFER_STALLED)			return USB_STOR_TRANSPORT_FAILED;		if (result > USB_STOR_XFER_STALLED)			return USB_STOR_TRANSPORT_ERROR;	}	/* STATUS STAGE */	result = usb_stor_intr_transfer(us, us->iobuf, 2);	US_DEBUGP("Got interrupt data (0x%x, 0x%x)/n", 			us->iobuf[0], us->iobuf[1]);	if (result != USB_STOR_XFER_GOOD)		return USB_STOR_TRANSPORT_ERROR;	/* UFI gives us ASC and ASCQ, like a request sense	 *	 * REQUEST_SENSE and INQUIRY don't affect the sense data on UFI	 * devices, so we ignore the information for those commands.  Note	 * that this means we could be ignoring a real error on these	 * commands, but that can't be helped.	 */	if (us->subclass == US_SC_UFI) {		if (srb->cmnd[0] == REQUEST_SENSE ||		    srb->cmnd[0] == INQUIRY)			return USB_STOR_TRANSPORT_GOOD;		if (us->iobuf[0])			goto Failed;		return USB_STOR_TRANSPORT_GOOD;	}	/* If not UFI, we interpret the data as a result code 	 * The first byte should always be a 0x0.	 *	 * Some bogus devices don't follow that rule.  They stuff the ASC	 * into the first byte -- so if it's non-zero, call it a failure.	 */	if (us->iobuf[0]) {		_VMKLNX_USB_STOR_MSG("CBI IRQ data showed reserved bType 0x%x/n",				us->srb, us->iobuf[0]);		US_DEBUGP("CBI IRQ data showed reserved bType 0x%x/n",				us->iobuf[0]);		goto Failed;	}	/* The second byte & 0x0F should be 0x0 for good, otherwise error */	switch (us->iobuf[1] & 0x0F) {		case 0x00: 			return USB_STOR_TRANSPORT_GOOD;		case 0x01: 			goto Failed;	}	return USB_STOR_TRANSPORT_ERROR;	/* the CBI spec requires that the bulk pipe must be cleared	 * following any data-in/out command failure (section 2.4.3.1.3)	 */  Failed:	if (pipe)		usb_stor_clear_halt(us, pipe);	return USB_STOR_TRANSPORT_FAILED;}

int usb_stor_Bulk_transport(Scsi_Cmnd *srb, struct us_data *us){	struct bulk_cb_wrap *bcb;	struct bulk_cs_wrap *bcs;	int result;	int pipe;	int partial;	int ret = USB_STOR_TRANSPORT_ERROR;	bcb = kmalloc(sizeof *bcb, in_interrupt() ? GFP_ATOMIC : GFP_NOIO);	if (!bcb) {		return USB_STOR_TRANSPORT_ERROR;	}	bcs = kmalloc(sizeof *bcs, in_interrupt() ? GFP_ATOMIC : GFP_NOIO);	if (!bcs) {		kfree(bcb);		return USB_STOR_TRANSPORT_ERROR;	}	/* set up the command wrapper */	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);	bcb->DataTransferLength = cpu_to_le32(usb_stor_transfer_length(srb));	bcb->Flags = srb->sc_data_direction == SCSI_DATA_READ ? 1 << 7 : 0;	bcb->Tag = ++(us->tag);	bcb->Lun = srb->cmnd[1] >> 5;	if (us->flags & US_FL_SCM_MULT_TARG)		bcb->Lun |= srb->target << 4;	bcb->Length = srb->cmd_len;	/* construct the pipe handle */	pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);	/* copy the command payload */	memset(bcb->CDB, 0, sizeof(bcb->CDB));	memcpy(bcb->CDB, srb->cmnd, bcb->Length);	/* send it to out endpoint */	US_DEBUGP("Bulk command S 0x%x T 0x%x Trg %d LUN %d L %d F %d CL %d/n",		  le32_to_cpu(bcb->Signature), bcb->Tag,		  (bcb->Lun >> 4), (bcb->Lun & 0x0F), 		  bcb->DataTransferLength, bcb->Flags, bcb->Length);	result = usb_stor_bulk_msg(us, bcb, pipe, US_BULK_CB_WRAP_LEN, 				   &partial);	US_DEBUGP("Bulk command transfer result=%d/n", result);	/* if the command was aborted, indicate that */	if (result == -ECONNRESET) {		ret = USB_STOR_TRANSPORT_ABORTED;		goto out;	}	/* if we stall, we need to clear it before we go on */	if (result == -EPIPE) {		US_DEBUGP("clearing endpoint halt for pipe 0x%x/n", pipe);		result = usb_stor_clear_halt(us, pipe);		/* if the command was aborted, indicate that */		if (result == -ECONNRESET) {			ret = USB_STOR_TRANSPORT_ABORTED;			goto out;		}		result = -EPIPE;	} else if (result) {		/* unknown error -- we've got a problem */		ret = USB_STOR_TRANSPORT_ERROR;		goto out;	}	/* if the command transfered well, then we go to the data stage */	if (result == 0) {		/* send/receive data payload, if there is any */		if (bcb->DataTransferLength) {			usb_stor_transfer(srb, us);			result = srb->result;			US_DEBUGP("Bulk data transfer result 0x%x/n", result);			/* if it was aborted, we need to indicate that */			if (result == US_BULK_TRANSFER_ABORTED) {				ret = USB_STOR_TRANSPORT_ABORTED;				goto out;			}		}	}	/* See flow chart on pg 15 of the Bulk Only Transport spec for	 * an explanation of how this code works.	 */	/* construct the pipe handle */	pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);	/* get CSW for device status */	US_DEBUGP("Attempting to get CSW.../n");	result = usb_stor_bulk_msg(us, bcs, pipe, US_BULK_CS_WRAP_LEN, 				   &partial);	/* if the command was aborted, indicate that */	if (result == -ECONNRESET) {		ret = USB_STOR_TRANSPORT_ABORTED;		goto out;//.........这里部分代码省略.........