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

/** * wq_clear_halt - work queue function * @wq_obj: work_struct object to execute * * This sends a clear_halt to the given USB pipe. */static void wq_clear_halt(struct work_struct *wq_obj){	struct clear_hold_work *clear_work = to_clear_hold_work(wq_obj);	struct most_dev *mdev = clear_work->mdev;	unsigned int channel = clear_work->channel;	int pipe = clear_work->pipe;	mutex_lock(&mdev->io_mutex);	most_stop_enqueue(&mdev->iface, channel);	free_anchored_buffers(mdev, channel, MBO_E_INVAL);	if (usb_clear_halt(mdev->usb_device, pipe))		dev_warn(&mdev->usb_device->dev, "Failed to reset endpoint./n");	mdev->is_channel_healthy[channel] = true;	most_resume_enqueue(&mdev->iface, channel);	mutex_unlock(&mdev->io_mutex);}

static voidRD_do_read (int timeout){	int	bytes_read, read_size;	read_size = RD_wanted - RD_buffer_used;	if (read_size < AUTO_READ_SIZE)		read_size = AUTO_READ_SIZE;	else if (read_size > MAX_READ_SIZE)		read_size = MAX_READ_SIZE;	LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "Reading: len: %d, timeout: %d./n", read_size, timeout));	bytes_read = usb_bulk_read (USB_handle, USB_in_endpoint, RD_usb_buffer, read_size, timeout);	LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "%s %d (%s): %d/n", 		__FILE__, __LINE__, __FUNCTION__, bytes_read));	if (bytes_read < 0) {		if (bytes_read == -ENODEV) {			LOG((PI_DBG_DEV, PI_DBG_LVL_NONE, "Device went byebye!/n"));			RD_running = 0;			return;#ifdef ELAST		} else if (bytes_read == -(ELAST + 1)) {			usb_clear_halt (USB_handle, USB_in_endpoint);			return;#endif		} else if (bytes_read == -ETIMEDOUT)			return;		LOG((PI_DBG_DEV, PI_DBG_LVL_ERR, "libusb: USB bulk read returned error code %d/n", bytes_read));		return;	}	if (!bytes_read)		return;		pthread_mutex_lock (&RD_buffer_mutex);	if ((RD_buffer_used + bytes_read) > RD_buffer_size) {		RD_buffer_size = ((RD_buffer_used + bytes_read + 0xfffe) & ~0xffff) - 1;	/* 64k chunks. */		RD_buffer = realloc (RD_buffer, RD_buffer_size);	}	memcpy (RD_buffer + RD_buffer_used, RD_usb_buffer, bytes_read);	RD_buffer_used += bytes_read;	pthread_cond_broadcast (&RD_buffer_available_cond);	pthread_mutex_unlock (&RD_buffer_mutex);}

static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port){	struct sierra_port_private *portdata;	struct usb_serial *serial = port->serial;	struct sierra_intf_private *intfdata = usb_get_serial_data(serial);	int i;	int err;	int endpoint;	struct urb *urb;	portdata = usb_get_serial_port_data(port);	endpoint = port->bulk_in_endpointAddress;	for (i = 0; i < portdata->num_in_urbs; i++) {		urb = sierra_setup_urb(serial, endpoint, USB_DIR_IN, port,					IN_BUFLEN, GFP_KERNEL,					sierra_indat_callback);		portdata->in_urbs[i] = urb;	}	/* clear halt condition */	usb_clear_halt(serial->dev,			usb_sndbulkpipe(serial->dev, endpoint) | USB_DIR_IN);	err = sierra_submit_rx_urbs(port, GFP_KERNEL);	if (err)		goto err_submit;	spin_lock_irq(&intfdata->susp_lock);	if (++intfdata->open_ports == 1)		serial->interface->needs_remote_wakeup = 1;	spin_unlock_irq(&intfdata->susp_lock);	usb_autopm_put_interface(serial->interface);	return 0;err_submit:	sierra_stop_rx_urbs(port);	for (i = 0; i < portdata->num_in_urbs; i++) {		sierra_release_urb(portdata->in_urbs[i]);		portdata->in_urbs[i] = NULL;	}	return err;}

static int  cyberjack_open(struct tty_struct *tty,					struct usb_serial_port *port){	struct cyberjack_private *priv;	unsigned long flags;	dev_dbg(&port->dev, "%s - usb_clear_halt/n", __func__);	usb_clear_halt(port->serial->dev, port->write_urb->pipe);	priv = usb_get_serial_port_data(port);	spin_lock_irqsave(&priv->lock, flags);	priv->rdtodo = 0;	priv->wrfilled = 0;	priv->wrsent = 0;	spin_unlock_irqrestore(&priv->lock, flags);	return 0;}

static int libusb_get_interrupt(usb_dev_handle *udev, unsigned char *buf, int bufsize, int timeout){	int ret;	if (!udev) {		return -1;	}	/* FIXME: hardcoded interrupt EP => need to get EP descr for IF descr */	ret = usb_interrupt_read(udev, 0x81, (char *)buf, bufsize, timeout);	/* Clear stall condition */	if (ret == -EPIPE) {		ret = usb_clear_halt(udev, 0x81);	}	return libusb_strerror(ret, __func__);}

static int metrousb_open(struct tty_struct *tty, struct usb_serial_port *port){	struct usb_serial *serial = port->serial;	struct metrousb_private *metro_priv = usb_get_serial_port_data(port);	unsigned long flags = 0;	int result = 0;	dev_dbg(&port->dev, "%s/n", __func__);	/* Make sure the urb is initialized. */	if (!port->interrupt_in_urb) {		dev_dbg(&port->dev, "%s - interrupt urb not initialized/n",			__func__);		return -ENODEV;	}	/* Set the private data information for the port. */	spin_lock_irqsave(&metro_priv->lock, flags);	metro_priv->control_state = 0;	metro_priv->throttled = 0;	spin_unlock_irqrestore(&metro_priv->lock, flags);	/* Clear the urb pipe. */	usb_clear_halt(serial->dev, port->interrupt_in_urb->pipe);	/* Start reading from the device */	usb_fill_int_urb(port->interrupt_in_urb, serial->dev,			  usb_rcvintpipe(serial->dev, port->interrupt_in_endpointAddress),			   port->interrupt_in_urb->transfer_buffer,			   port->interrupt_in_urb->transfer_buffer_length,			   metrousb_read_int_callback, port, 1);	result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);	if (result) {		dev_dbg(&port->dev,			"%s - failed submitting interrupt in urb, error code=%d/n",			__func__, result);		goto exit;	}	dev_dbg(&port->dev, "%s - port open/n", __func__);exit:	return result;}

bool IdacUsb::claim(){	CHECK_PRECOND_RETVAL(!m_bClaimed, false);	int res;	/*	quint8 data[18];	res = usb_control_msg(m_handle, 0x80, 0x06, 0x0100, 0x0000, (char*) &data, 18, 5000);	if (res >= 0)	{		for (int i = 0; i < 18; i += 2)			std::cerr << qPrintable(QString("%0 ").arg((int)data[0], 16));		std::cerr << std::endl;	}	*/	int idConfiguration = m_dev->config[0].bConfigurationValue;	res = usb_set_configuration(m_handle, idConfiguration);	if (res < 0)		return false;	int idInterface = m_dev->config[0].interface[0].altsetting[0].bInterfaceNumber;	res = usb_claim_interface(m_handle, idInterface);	if (res < 0)		return false;	usb_interface_descriptor* setting = &m_dev->config[0].interface[0].altsetting[0];	res = usb_set_altinterface(m_handle, setting->bAlternateSetting);	if (res < 0)		return false;	for (int iPipe = 0; iPipe < setting->bNumEndpoints; iPipe++)	{		int idPipe = setting->endpoint[iPipe].bEndpointAddress;		res = usb_clear_halt(m_handle, idPipe);	}	m_bClaimed = true;	m_driver = new IdacUsbDriver4(this);	return m_driver->boot();}

/* Workqueue routine to reset the device or clear a halt */static void hid_reset(struct work_struct *work){	struct usbhid_device *usbhid =		container_of(work, struct usbhid_device, reset_work);	struct hid_device *hid = usbhid->hid;	int rc = 0;	if (test_bit(HID_CLEAR_HALT, &usbhid->iofl)) {		dev_dbg(&usbhid->intf->dev, "clear halt/n");		rc = usb_clear_halt(hid_to_usb_dev(hid), usbhid->urbin->pipe);		clear_bit(HID_CLEAR_HALT, &usbhid->iofl);		hid_start_in(hid);	}	else if (test_bit(HID_RESET_PENDING, &usbhid->iofl)) {		dev_dbg(&usbhid->intf->dev, "resetting device/n");		rc = usb_lock_device_for_reset(hid_to_usb_dev(hid), usbhid->intf);		if (rc == 0) {			rc = usb_reset_device(hid_to_usb_dev(hid));			usb_unlock_device(hid_to_usb_dev(hid));		}		clear_bit(HID_RESET_PENDING, &usbhid->iofl);	}	switch (rc) {	case 0:		if (!test_bit(HID_IN_RUNNING, &usbhid->iofl))			hid_io_error(hid);		break;	default:		hid_err(hid, "can't reset device, %s-%s/input%d, status %d/n",			hid_to_usb_dev(hid)->bus->bus_name,			hid_to_usb_dev(hid)->devpath,			usbhid->ifnum, rc);		/* FALLTHROUGH */	case -EHOSTUNREACH:	case -ENODEV:	case -EINTR:		break;	}}

static int  cyberjack_open(struct tty_struct *tty,			struct usb_serial_port *port, struct file *filp){	struct cyberjack_private *priv;	unsigned long flags;	int result = 0;	dbg("%s - port %d", __func__, port->number);	dbg("%s - usb_clear_halt", __func__);	usb_clear_halt(port->serial->dev, port->write_urb->pipe);	priv = usb_get_serial_port_data(port);	spin_lock_irqsave(&priv->lock, flags);	priv->rdtodo = 0;	priv->wrfilled = 0;	priv->wrsent = 0;	spin_unlock_irqrestore(&priv->lock, flags);	return result;}

int main(void){//	printf("SizeOF %ld/n", sizeof(struct usb_dev_handle*));    libusb_init();    libusb_set_debug(2);    libusb_find_busses();    libusb_find_devices();	struct usb_dev_handle* green = malloc(256);	green = get_green(bus, dev);	printf("Detach: %d/n", usb_detach_kernel_driver_np(green, 0));	printf("Halt: %d/n", usb_clear_halt(green, 0x81));	printf("Interface: %d/n", usb_claim_interface(green, 0));	libusb_alloc_transfer(0);	   //	printf("Buffer: %x/n", buffer);	return 0;}

static int opticon_open(struct tty_struct *tty, struct usb_serial_port *port){	struct opticon_private *priv = usb_get_serial_data(port->serial);	unsigned long flags;	int result = 0;	dbg("%s - port %d", __func__, port->number);	spin_lock_irqsave(&priv->lock, flags);	priv->throttled = false;	priv->actually_throttled = false;	priv->port = port;	priv->rts = false;	spin_unlock_irqrestore(&priv->lock, flags);	/* Clear RTS line */	send_control_msg(port, CONTROL_RTS, 0);	/* Setup the read URB and start reading from the device */	usb_fill_bulk_urb(priv->bulk_read_urb, priv->udev,			  usb_rcvbulkpipe(priv->udev,					  priv->bulk_address),			  priv->bulk_in_buffer, priv->buffer_size,			  opticon_read_bulk_callback, priv);	/* clear the halt status of the enpoint */	usb_clear_halt(priv->udev, priv->bulk_read_urb->pipe);	result = usb_submit_urb(priv->bulk_read_urb, GFP_KERNEL);	if (result)		dev_err(&port->dev,			"%s - failed resubmitting read urb, error %d/n",			__func__, result);	/* Request CTS line state, sometimes during opening the current	 * CTS state can be missed. */	send_control_msg(port, RESEND_CTS_STATE, 1);	return result;}

static int ptp_io_write(struct ptpfs_sb_info *sb, unsigned char *bytes, unsigned int size){    ssize_t bytes_written = 0;    int retval = 0;    /* verify that the device wasn't unplugged */    if (sb->usb_device->udev == NULL)    {        retval = -ENODEV;        goto exit;    }    /* verify that we actually have some data to write */    if (size == 0)    {        goto exit;    }    int pipe =  usb_sndbulkpipe (sb->usb_device->udev, sb->usb_device->outep);    //retval = usb_ptp_bulk_msg(sb,pipe,bytes, size,&bytes_written);    retval = usb_bulk_msg( sb->usb_device->udev,pipe,bytes, size,&bytes_written,5*HZ);    if (retval == -EPIPE)    {        //stall        usb_clear_halt(sb->usb_device->udev,pipe);    }    if (!retval)    {        retval = bytes_written;    }    exit:    return retval;}

/* * Callback that is called by usb_device_open() that handles USB device * settings prior to accepting the devide. At the very least claim the * device here. Detaching the kernel driver will be handled by the * caller, don't do this here. Return < 0 on error, 0 or higher on * success. */static int driver_callback(usb_dev_handle *handle, USBDevice_t *device){	if (usb_set_configuration(handle, 1) < 0) {		upsdebugx(5, "Can't set USB configuration");		return -1;	}	if (usb_claim_interface(handle, 0) < 0) {		upsdebugx(5, "Can't claim USB interface");		return -1;	}	if (usb_set_altinterface(handle, 0) < 0) {		upsdebugx(5, "Can't set USB alternate interface");		return -1;	}	if (usb_clear_halt(handle, 0x81) < 0) {		upsdebugx(5, "Can't reset USB endpoint");		return -1;	}	return 1;}

int usb_urb_init(struct usb_data_stream *stream, struct usb_data_stream_properties *props){	if (stream == NULL || props == NULL)		return -EINVAL;	memcpy(&stream->props, props, sizeof(*props));	usb_clear_halt(stream->udev,usb_rcvbulkpipe(stream->udev,stream->props.endpoint));	if (stream->complete == NULL) {		err("there is no data callback - this doesn't make sense.");		return -EINVAL;	}	switch (stream->props.type) {		case USB_BULK:			return usb_bulk_urb_init(stream);		case USB_ISOC:			return usb_isoc_urb_init(stream);		default:			err("unkown URB-type for data transfer.");			return -EINVAL;	}}

static int ptp_io_read(struct ptpfs_sb_info *sb, unsigned char *bytes, unsigned int size){    int retval = 0;    int count = 0;    memset(bytes,0,size);    /* do an immediate bulk read to get data from the device */    int pipe =  usb_rcvbulkpipe (sb->usb_device->udev, sb->usb_device->inep);    //retval = usb_ptp_bulk_msg (sb,pipe,bytes, size,&count);    retval = usb_bulk_msg ( sb->usb_device->udev,pipe,bytes, size,&count,3*HZ);    /* if the read was successful, copy the data to userspace */    if (!retval)    {        retval = count;    }    else if (retval == -EPIPE)    {        //stall        usb_clear_halt(sb->usb_device->udev,pipe);    }    return retval;}

/* * Allocate URBs and start IRQ */int cx231xx_init_vbi_isoc(struct cx231xx *dev, int max_packets,			  int num_bufs, int max_pkt_size,			  int (*bulk_copy) (struct cx231xx *dev,					    struct urb *urb)){	struct cx231xx_dmaqueue *dma_q = &dev->vbi_mode.vidq;	int i;	int sb_size, pipe;	struct urb *urb;	int rc;	cx231xx_info(DRIVER_NAME "cx231xx: called cx231xx_prepare_isoc/n");	/* De-allocates all pending stuff */	cx231xx_uninit_vbi_isoc(dev);	/* clear if any halt */	usb_clear_halt(dev->udev,		       usb_rcvbulkpipe(dev->udev,				       dev->vbi_mode.end_point_addr));	dev->vbi_mode.bulk_ctl.bulk_copy = bulk_copy;	dev->vbi_mode.bulk_ctl.num_bufs = num_bufs;	dma_q->pos = 0;	dma_q->is_partial_line = 0;	dma_q->last_sav = 0;	dma_q->current_field = -1;	dma_q->bytes_left_in_line = dev->width << 1;	dma_q->lines_per_field = ((dev->norm & V4L2_STD_625_50) ?				  PAL_VBI_LINES : NTSC_VBI_LINES);	dma_q->lines_completed = 0;	for (i = 0; i < 8; i++)		dma_q->partial_buf[i] = 0;	dev->vbi_mode.bulk_ctl.urb = kzalloc(sizeof(void *) * num_bufs,					     GFP_KERNEL);	if (!dev->vbi_mode.bulk_ctl.urb) {		cx231xx_errdev("cannot alloc memory for usb buffers/n");		return -ENOMEM;	}	dev->vbi_mode.bulk_ctl.transfer_buffer =	    kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL);	if (!dev->vbi_mode.bulk_ctl.transfer_buffer) {		cx231xx_errdev("cannot allocate memory for usbtransfer/n");		kfree(dev->vbi_mode.bulk_ctl.urb);		return -ENOMEM;	}	dev->vbi_mode.bulk_ctl.max_pkt_size = max_pkt_size;	dev->vbi_mode.bulk_ctl.buf = NULL;	sb_size = max_packets * dev->vbi_mode.bulk_ctl.max_pkt_size;	/* allocate urbs and transfer buffers */	for (i = 0; i < dev->vbi_mode.bulk_ctl.num_bufs; i++) {		urb = usb_alloc_urb(0, GFP_KERNEL);		if (!urb) {			cx231xx_err(DRIVER_NAME				    ": cannot alloc bulk_ctl.urb %i/n", i);			cx231xx_uninit_vbi_isoc(dev);			return -ENOMEM;		}		dev->vbi_mode.bulk_ctl.urb[i] = urb;		urb->transfer_flags = 0;		dev->vbi_mode.bulk_ctl.transfer_buffer[i] =		    kzalloc(sb_size, GFP_KERNEL);		if (!dev->vbi_mode.bulk_ctl.transfer_buffer[i]) {			cx231xx_err(DRIVER_NAME				    ": unable to allocate %i bytes for transfer"				    " buffer %i%s/n", sb_size, i,				    in_interrupt() ? " while in int" : "");			cx231xx_uninit_vbi_isoc(dev);			return -ENOMEM;		}		pipe = usb_rcvbulkpipe(dev->udev, dev->vbi_mode.end_point_addr);		usb_fill_bulk_urb(urb, dev->udev, pipe,				  dev->vbi_mode.bulk_ctl.transfer_buffer[i],				  sb_size, cx231xx_irq_vbi_callback, dma_q);	}	init_waitqueue_head(&dma_q->wq);	/* submit urbs and enables IRQ */	for (i = 0; i < dev->vbi_mode.bulk_ctl.num_bufs; i++) {		rc = usb_submit_urb(dev->vbi_mode.bulk_ctl.urb[i], GFP_ATOMIC);		if (rc) {			cx231xx_err(DRIVER_NAME				    ": submit of urb %i failed (error=%i)/n", i,				    rc);			cx231xx_uninit_vbi_isoc(dev);			return rc;		}	}//.........这里部分代码省略.........

static int ultracam_resetPipe(struct uvd *uvd){	usb_clear_halt(uvd->dev, uvd->video_endp);	return 0;}

/* * Sends a barker buffer to the device * * This helper will allocate a kmalloced buffer and use it to transmit * (then free it). Reason for this is that other arches cannot use * stack/vmalloc/text areas for DMA transfers. * * Error recovery here is simpler: anything is considered a hard error * and will move the reset code to use a last-resort bus-based reset. */staticint __i2400mu_send_barker(struct i2400mu *i2400mu,			  const __le32 *barker,			  size_t barker_size,			  unsigned endpoint){	struct usb_endpoint_descriptor *epd = NULL;	int pipe, actual_len, ret;	struct device *dev = &i2400mu->usb_iface->dev;	void *buffer;	int do_autopm = 1;	ret = usb_autopm_get_interface(i2400mu->usb_iface);	if (ret < 0) {		dev_err(dev, "RESET: can't get autopm: %d/n", ret);		do_autopm = 0;	}	ret = -ENOMEM;	buffer = kmalloc(barker_size, GFP_KERNEL);	if (buffer == NULL)		goto error_kzalloc;	epd = usb_get_epd(i2400mu->usb_iface, endpoint);	pipe = usb_sndbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress);	memcpy(buffer, barker, barker_size);retry:	ret = usb_bulk_msg(i2400mu->usb_dev, pipe, buffer, barker_size,			   &actual_len, 200);	switch (ret) {	case 0:		if (actual_len != barker_size) {	/* Too short? drop it */			dev_err(dev, "E: %s: short write (%d B vs %zu "				"expected)/n",				__func__, actual_len, barker_size);			ret = -EIO;		}		break;	case -EPIPE:		/*		 * Stall -- maybe the device is choking with our		 * requests. Clear it and give it some time. If they		 * happen to often, it might be another symptom, so we		 * reset.		 *		 * No error handling for usb_clear_halt(0; if it		 * works, the retry works; if it fails, this switch		 * does the error handling for us.		 */		if (edc_inc(&i2400mu->urb_edc,			    10 * EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) {			dev_err(dev, "E: %s: too many stalls in "				"URB; resetting device/n", __func__);			usb_queue_reset_device(i2400mu->usb_iface);			/* fallthrough */		} else {			usb_clear_halt(i2400mu->usb_dev, pipe);			msleep(10);	/* give the device some time */			goto retry;		}	case -EINVAL:			/* while removing driver */	case -ENODEV:			/* dev disconnect ... */	case -ENOENT:			/* just ignore it */	case -ESHUTDOWN:		/* and exit */	case -ECONNRESET:		ret = -ESHUTDOWN;		break;	default:			/* Some error? */		if (edc_inc(&i2400mu->urb_edc,			    EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) {			dev_err(dev, "E: %s: maximum errors in URB "				"exceeded; resetting device/n",				__func__);			usb_queue_reset_device(i2400mu->usb_iface);		} else {			dev_warn(dev, "W: %s: cannot send URB: %d/n",				 __func__, ret);			goto retry;		}	}	kfree(buffer);error_kzalloc:	if (do_autopm)		usb_autopm_put_interface(i2400mu->usb_iface);	return ret;}

static void kevent(void *data){	struct usbnet *dev = (struct usbnet *)data;#elsestatic void kevent(struct work_struct *work){	struct usbnet		*dev =		container_of(work, struct usbnet, kevent);#endif	int			status;	/* usb_clear_halt() needs a thread context */	if (test_bit(EVENT_TX_HALT, &dev->flags)) {		unlink_urbs(dev, &dev->txq);		status = usb_clear_halt(dev->udev, dev->out);		if (status < 0				&& status != -EPIPE				&& status != -ESHUTDOWN) {			if (netif_msg_tx_err(dev))				deverr(dev, "can't clear tx halt, status %d",				       status);		} else {			clear_bit(EVENT_TX_HALT, &dev->flags);			if (status != -ESHUTDOWN)				netif_wake_queue(dev->net);		}	}	if (test_bit(EVENT_RX_HALT, &dev->flags)) {		unlink_urbs(dev, &dev->rxq);		status = usb_clear_halt(dev->udev, dev->in);		if (status < 0				&& status != -EPIPE				&& status != -ESHUTDOWN) {			if (netif_msg_rx_err(dev))				deverr(dev, "can't clear rx halt, status %d",				       status);		} else {			clear_bit(EVENT_RX_HALT, &dev->flags);			tasklet_schedule(&dev->bh);		}	}	/* tasklet could resubmit itself forever if memory is tight */	if (test_bit(EVENT_RX_MEMORY, &dev->flags)) {		struct urb	*urb = NULL;		if (netif_running(dev->net))			urb = usb_alloc_urb(0, GFP_KERNEL);		else			clear_bit(EVENT_RX_MEMORY, &dev->flags);		if (urb != NULL) {			clear_bit(EVENT_RX_MEMORY, &dev->flags);#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 14)			urb->transfer_flags |= URB_ASYNC_UNLINK;#endif			rx_submit(dev, urb, GFP_KERNEL);			tasklet_schedule(&dev->bh);		}	}	if (test_bit(EVENT_LINK_RESET, &dev->flags)) {		struct driver_info	*info = dev->driver_info;		int			retval = 0;		clear_bit(EVENT_LINK_RESET, &dev->flags);		if (info->link_reset) {			retval = info->link_reset(dev);			if (retval < 0) {				devinfo(dev,					"link reset failed (%d) usbnet usb-%s-%s, %s",					retval,					dev->udev->bus->bus_name,					dev->udev->devpath,					info->description);			}		}	}	if (dev->flags)		devdbg(dev, "kevent done, flags = 0x%lx", dev->flags);}/*-------------------------------------------------------------------------*/#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)static void tx_complete(struct urb *urb, struct pt_regs *regs)#elsestatic void tx_complete(struct urb *urb)#endif{	struct sk_buff		*skb = (struct sk_buff *) urb->context;	struct skb_data		*entry = (struct skb_data *) skb->cb;	struct usbnet		*dev = entry->dev;	if (urb->status == 0) {		dev->stats.tx_packets++;		dev->stats.tx_bytes += entry->length;//.........这里部分代码省略.........

/** * usb_set_interface - Makes a particular alternate setting be current * @dev: the device whose interface is being updated * @interface: the interface being updated * @alternate: the setting being chosen. * Context: !in_interrupt () * * This is used to enable data transfers on interfaces that may not * be enabled by default.  Not all devices support such configurability. * Only the driver bound to an interface may change its setting. * * Within any given configuration, each interface may have several * alternative settings.  These are often used to control levels of * bandwidth consumption.  For example, the default setting for a high * speed interrupt endpoint may not send more than 64 bytes per microframe, * while interrupt transfers of up to 3KBytes per microframe are legal. * Also, isochronous endpoints may never be part of an * interface's default setting.  To access such bandwidth, alternate * interface settings must be made current. * * Note that in the Linux USB subsystem, bandwidth associated with * an endpoint in a given alternate setting is not reserved until an URB * is submitted that needs that bandwidth.  Some other operating systems * allocate bandwidth early, when a configuration is chosen. * * This call is synchronous, and may not be used in an interrupt context. * Also, drivers must not change altsettings while urbs are scheduled for * endpoints in that interface; all such urbs must first be completed * (perhaps forced by unlinking). * * Returns zero on success, or else the status code returned by the * underlying usb_control_msg() call. */int usb_set_interface(struct usb_device *dev, int interface, int alternate){	struct usb_interface *iface;	struct usb_host_interface *alt;	int ret;	int manual = 0;	iface = usb_ifnum_to_if(dev, interface);	if (!iface) {		dev_dbg(&dev->dev, "selecting invalid interface %d/n",			interface);		return -EINVAL;	}	alt = usb_altnum_to_altsetting(iface, alternate);	if (!alt) {		warn("selecting invalid altsetting %d", alternate);		return -EINVAL;	}	ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),				   USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,				   alternate, interface, NULL, 0, HZ * 5);	/* 9.4.10 says devices don't need this and are free to STALL the	 * request if the interface only has one alternate setting.	 */	if (ret == -EPIPE && iface->num_altsetting == 1) {		dev_dbg(&dev->dev,			"manual set_interface for iface %d, alt %d/n",			interface, alternate);		manual = 1;	} else if (ret < 0)		return ret;	/* FIXME drivers shouldn't need to replicate/bugfix the logic here	 * when they implement async or easily-killable versions of this or	 * other "should-be-internal" functions (like clear_halt).	 * should hcd+usbcore postprocess control requests?	 */	/* prevent submissions using previous endpoint settings */	usb_disable_interface(dev, iface);	iface->cur_altsetting = alt;	/* If the interface only has one altsetting and the device didn't	 * accept the request, we attempt to carry out the equivalent action	 * by manually clearing the HALT feature for each endpoint in the	 * new altsetting.	 */	if (manual) {		int i;		for (i = 0; i < alt->desc.bNumEndpoints; i++) {			unsigned int epaddr =				alt->endpoint[i].desc.bEndpointAddress;			unsigned int pipe =	__create_pipe(dev, USB_ENDPOINT_NUMBER_MASK & epaddr)	| (usb_endpoint_out(epaddr) ? USB_DIR_OUT : USB_DIR_IN);			usb_clear_halt(dev, pipe);		}	}	/* 9.1.1.5: reset toggles for all endpoints in the new altsetting	 *//.........这里部分代码省略.........

/***************************************************************************** * Connect Tech's White Heat serial driver functions *****************************************************************************/static int whiteheat_attach(struct usb_serial *serial){	struct usb_serial_port *command_port;	struct whiteheat_command_private *command_info;	struct whiteheat_hw_info *hw_info;	int pipe;	int ret;	int alen;	__u8 *command;	__u8 *result;	command_port = serial->port[COMMAND_PORT];	pipe = usb_sndbulkpipe(serial->dev,			command_port->bulk_out_endpointAddress);	command = kmalloc(2, GFP_KERNEL);	if (!command)		goto no_command_buffer;	command[0] = WHITEHEAT_GET_HW_INFO;	command[1] = 0;	result = kmalloc(sizeof(*hw_info) + 1, GFP_KERNEL);	if (!result)		goto no_result_buffer;	/*	 * When the module is reloaded the firmware is still there and	 * the endpoints are still in the usb core unchanged. This is the	 * unlinking bug in disguise. Same for the call below.	 */	usb_clear_halt(serial->dev, pipe);	ret = usb_bulk_msg(serial->dev, pipe, command, 2,						&alen, COMMAND_TIMEOUT_MS);	if (ret) {		dev_err(&serial->dev->dev, "%s: Couldn't send command [%d]/n",			serial->type->description, ret);		goto no_firmware;	} else if (alen != 2) {		dev_err(&serial->dev->dev, "%s: Send command incomplete [%d]/n",			serial->type->description, alen);		goto no_firmware;	}	pipe = usb_rcvbulkpipe(serial->dev,				command_port->bulk_in_endpointAddress);	/* See the comment on the usb_clear_halt() above */	usb_clear_halt(serial->dev, pipe);	ret = usb_bulk_msg(serial->dev, pipe, result,			sizeof(*hw_info) + 1, &alen, COMMAND_TIMEOUT_MS);	if (ret) {		dev_err(&serial->dev->dev, "%s: Couldn't get results [%d]/n",			serial->type->description, ret);		goto no_firmware;	} else if (alen != sizeof(*hw_info) + 1) {		dev_err(&serial->dev->dev, "%s: Get results incomplete [%d]/n",			serial->type->description, alen);		goto no_firmware;	} else if (result[0] != command[0]) {		dev_err(&serial->dev->dev, "%s: Command failed [%d]/n",			serial->type->description, result[0]);		goto no_firmware;	}	hw_info = (struct whiteheat_hw_info *)&result[1];	dev_info(&serial->dev->dev, "%s: Firmware v%d.%02d/n",		 serial->type->description,		 hw_info->sw_major_rev, hw_info->sw_minor_rev);	command_info = kmalloc(sizeof(struct whiteheat_command_private),								GFP_KERNEL);	if (command_info == NULL) {		dev_err(&serial->dev->dev,			"%s: Out of memory for port structures/n",			serial->type->description);		goto no_command_private;	}	mutex_init(&command_info->mutex);	command_info->port_running = 0;	init_waitqueue_head(&command_info->wait_command);	usb_set_serial_port_data(command_port, command_info);	command_port->write_urb->complete = command_port_write_callback;	command_port->read_urb->complete = command_port_read_callback;	kfree(result);	kfree(command);	return 0;no_firmware:	/* Firmware likely not running */	dev_err(&serial->dev->dev,		"%s: Unable to retrieve firmware version, try replugging/n",		serial->type->description);	dev_err(&serial->dev->dev,		"%s: If the firmware is not running (status led not blinking)/n",		serial->type->description);	dev_err(&serial->dev->dev,//.........这里部分代码省略.........

static int lme2510_load_firmware_by_num(struct usb_device *dev,					const struct firmware *fw,					u8 num){	u8 *b, *p;	u8 msg[] = { 0x06, 0x00, 0x54, 0x80, 0x08 };	int pl = 50, ret = 0, i, actlen;	info("start downloading lme2510 firmware");	p = kmalloc(53, GFP_KERNEL);	b = kmalloc(1, GFP_KERNEL);	if ((p != NULL) && (b != NULL)) {		for (i = 0; i < fw->size; i += 50) {			if ((i + 50) < fw->size){				pl = 50;				p[0] = num;			} else {				pl = fw->size - i;				p[0] = 0x80 | num;			}			p[1] = pl - 1;			memcpy(p + 2, fw->data + i, pl);			p[pl + 2] = zum(p + 2, pl);			deb_xfer(">>> ");			debug_dump(p, pl + 3, deb_xfer);			ret = usb_bulk_msg(dev, usb_sndbulkpipe(dev, 0x01),					p, pl + 3, &actlen, 2000);			ret |= usb_bulk_msg(dev, usb_rcvbulkpipe(dev, 0x81),					b, 1, &actlen, 2000);			if ((ret != 0) || (b[0]!= 0x88)) {				err("error while transferring firmware %d: %d, "					"answer: 0x%02x/n", num, ret, b[0]);				ret = -EINVAL;				break;			}		}	}	memcpy(p, &msg[0], 5);	usb_clear_halt(dev, usb_sndbulkpipe(dev, 0x01));	ret = usb_bulk_msg(dev, usb_sndbulkpipe(dev, 0x01),			p, 5, &actlen, 2000);	usb_clear_halt(dev, usb_rcvbulkpipe(dev, 0x81));	ret |= usb_bulk_msg(dev, usb_rcvbulkpipe(dev, 0x81),			b, 1, &actlen, 2000);	if ((ret != 0) || (b[0]!= 0x77)) {		err("error after transferring firmware %d: %d, "			"answer: 0x%02x/n",				num, ret, b[0]);		ret = -EINVAL;	}	kfree(p);	kfree(b);	return ret;};

static int us_one_transfer(struct us_data *us, int pipe, char *buf, int length){    int max_size;    int this_xfer;    int result;    int partial;    int maxtry;    int stat;    /* determine the maximum packet size for these transfers */    max_size = usb_maxpacket(us->pusb_dev, pipe) * 16;    /* while we have data left to transfer */    while (length) {        /* calculate how long this will be -- maximum or a remainder */        this_xfer = length > max_size ? max_size : length;        length -= this_xfer;        /* setup the retry counter */        maxtry = 10;        /* set up the transfer loop */        do {            /* transfer the data */            USB_STOR_PRINTF("Bulk xfer 0x%x(%d) try #%d/n",                            (unsigned int)buf, this_xfer, 11 - maxtry);            result = usb_bulk_msg(us->pusb_dev, pipe, buf,                                  this_xfer, &partial, USB_CNTL_TIMEOUT*5);            USB_STOR_PRINTF("bulk_msg returned %d xferred %d/%d/n",                            result, partial, this_xfer);            if(us->pusb_dev->status!=0) {                /* if we stall, we need to clear it before we go on */#ifdef USB_STOR_DEBUG                display_int_status(us->pusb_dev->status);#endif                if (us->pusb_dev->status & USB_ST_STALLED) {                    USB_STOR_PRINTF("stalled ->clearing endpoint halt for pipe 0x%x/n", pipe);                    stat = us->pusb_dev->status;                    usb_clear_halt(us->pusb_dev, pipe);                    us->pusb_dev->status=stat;                    if(this_xfer == partial) {                        USB_STOR_PRINTF("bulk transferred with error %X, but data ok/n",us->pusb_dev->status);                        return 0;                    }                    else                        return result;                }                if (us->pusb_dev->status & USB_ST_NAK_REC) {                    USB_STOR_PRINTF("Device NAKed bulk_msg/n");                    return result;                }                if(this_xfer == partial) {                    USB_STOR_PRINTF("bulk transferred with error %d, but data ok/n",us->pusb_dev->status);                    return 0;                }                /* if our try counter reaches 0, bail out */                USB_STOR_PRINTF("bulk transferred with error %d, data %d/n",us->pusb_dev->status,partial);                if (!maxtry--)                    return result;            }            /* update to show what data was transferred */            this_xfer -= partial;            buf += partial;            /* continue until this transfer is done */        } while ( this_xfer );    }    /* if we get here, we're done and successful */    return 0;}

static int rtl2832u_power_ctrl(struct dvb_usb_device *d, int onoff){	int ret;	u8 val;	dev_dbg(&d->udev->dev, "%s: onoff=%d/n", __func__, onoff);	if (onoff) {		/* set output values */		ret = rtl28xx_rd_reg(d, SYS_GPIO_OUT_VAL, &val);		if (ret)			goto err;		val |= 0x08;		val &= 0xef;		ret = rtl28xx_wr_reg(d, SYS_GPIO_OUT_VAL, val);		if (ret)			goto err;		/* demod_ctl_1 */		ret = rtl28xx_rd_reg(d, SYS_DEMOD_CTL1, &val);		if (ret)			goto err;		val &= 0xef;		ret = rtl28xx_wr_reg(d, SYS_DEMOD_CTL1, val);		if (ret)			goto err;		/* demod control */		/* PLL enable */		ret = rtl28xx_rd_reg(d, SYS_DEMOD_CTL, &val);		if (ret)			goto err;		/* bit 7 to 1 */		val |= 0x80;		ret = rtl28xx_wr_reg(d, SYS_DEMOD_CTL, val);		if (ret)			goto err;		ret = rtl28xx_rd_reg(d, SYS_DEMOD_CTL, &val);		if (ret)			goto err;		val |= 0x20;		ret = rtl28xx_wr_reg(d, SYS_DEMOD_CTL, val);		if (ret)			goto err;		mdelay(5);		/*enable ADC_Q and ADC_I */		ret = rtl28xx_rd_reg(d, SYS_DEMOD_CTL, &val);		if (ret)			goto err;		val |= 0x48;		ret = rtl28xx_wr_reg(d, SYS_DEMOD_CTL, val);		if (ret)			goto err;		/* streaming EP: clear stall & reset */		ret = rtl28xx_wr_regs(d, USB_EPA_CTL, "/x00/x00", 2);		if (ret)			goto err;		ret = usb_clear_halt(d->udev, usb_rcvbulkpipe(d->udev, 0x81));		if (ret)			goto err;	} else {		/* demod_ctl_1 */		ret = rtl28xx_rd_reg(d, SYS_DEMOD_CTL1, &val);		if (ret)			goto err;		val |= 0x0c;		ret = rtl28xx_wr_reg(d, SYS_DEMOD_CTL1, val);		if (ret)			goto err;		/* set output values */		ret = rtl28xx_rd_reg(d, SYS_GPIO_OUT_VAL, &val);		if (ret)				goto err;		val |= 0x10;		ret = rtl28xx_wr_reg(d, SYS_GPIO_OUT_VAL, val);		if (ret)			goto err;		/* demod control */		ret = rtl28xx_rd_reg(d, SYS_DEMOD_CTL, &val);//.........这里部分代码省略.........

static int sddr55_raw_bulk(struct us_data *us, 		int direction,		unsigned char *data,		unsigned int len) {	int result;	int act_len;	int pipe;	if (direction == SCSI_DATA_READ)		pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);	else		pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);	result = usb_stor_bulk_msg(us, data, pipe, len, &act_len);	/* if we stall, we need to clear it before we go on */	if (result == -EPIPE) {		US_DEBUGP("EPIPE: clearing endpoint halt for"			" pipe 0x%x, stalled at %d bytes/n",			pipe, act_len);		usb_clear_halt(us->pusb_dev, pipe);	}	if (result) {		/* NAK - that means we've retried a few times already */		if (result == -ETIMEDOUT) {			US_DEBUGP("usbat_raw_bulk():"				" device NAKed/n");			return US_BULK_TRANSFER_FAILED;		}		/* -ECONNRESET -- we canceled this transfer */		if (result == -ECONNRESET) {			US_DEBUGP("usbat_raw_bulk():"				" transfer aborted/n");			return US_BULK_TRANSFER_ABORTED;		}		if (result == -EPIPE) {			US_DEBUGP("usbat_raw_bulk():"				" output pipe stalled/n");			return US_BULK_TRANSFER_FAILED;		}		/* the catch-all case */		US_DEBUGP("us_transfer_partial(): unknown error/n");		return US_BULK_TRANSFER_FAILED;	}	if (act_len != len) {		US_DEBUGP("Warning: Transferred only %d bytes/n",			act_len);		return US_BULK_TRANSFER_SHORT;	}	US_DEBUGP("Transferred %d of %d bytes/n", act_len, len);	return US_BULK_TRANSFER_GOOD;}

/* work that cannot be done in interrupt context uses keventd. * * NOTE:  with 2.5 we could do more of this using completion callbacks, * especially now that control transfers can be queued. */static voidkevent (struct work_struct *work){	struct usbnet		*dev =		container_of(work, struct usbnet, kevent);	int			status;	/* usb_clear_halt() needs a thread context */	if (test_bit (EVENT_TX_HALT, &dev->flags)) {		unlink_urbs (dev, &dev->txq);		status = usb_autopm_get_interface(dev->intf);		if (status < 0)			goto fail_pipe;		status = usb_clear_halt (dev->udev, dev->out);		usb_autopm_put_interface(dev->intf);		if (status < 0 &&		    status != -EPIPE &&		    status != -ESHUTDOWN) {			if (netif_msg_tx_err (dev))fail_pipe:				netdev_err(dev->net, "can't clear tx halt, status %d/n",					   status);		} else {			clear_bit (EVENT_TX_HALT, &dev->flags);			if (status != -ESHUTDOWN)				netif_wake_queue (dev->net);		}	}	if (test_bit (EVENT_RX_HALT, &dev->flags)) {		unlink_urbs (dev, &dev->rxq);		status = usb_autopm_get_interface(dev->intf);		if (status < 0)			goto fail_halt;		status = usb_clear_halt (dev->udev, dev->in);		usb_autopm_put_interface(dev->intf);		if (status < 0 &&		    status != -EPIPE &&		    status != -ESHUTDOWN) {			if (netif_msg_rx_err (dev))fail_halt:				netdev_err(dev->net, "can't clear rx halt, status %d/n",					   status);		} else {			clear_bit (EVENT_RX_HALT, &dev->flags);			tasklet_schedule (&dev->bh);		}	}	/* tasklet could resubmit itself forever if memory is tight */	if (test_bit (EVENT_RX_MEMORY, &dev->flags)) {		struct urb	*urb = NULL;		if (netif_running (dev->net))			urb = usb_alloc_urb (0, GFP_KERNEL);		else			clear_bit (EVENT_RX_MEMORY, &dev->flags);		if (urb != NULL) {			clear_bit (EVENT_RX_MEMORY, &dev->flags);			status = usb_autopm_get_interface(dev->intf);			if (status < 0)				goto fail_lowmem;			rx_submit (dev, urb, GFP_KERNEL);			usb_autopm_put_interface(dev->intf);fail_lowmem:			tasklet_schedule (&dev->bh);		}	}	if (test_bit (EVENT_LINK_RESET, &dev->flags)) {		struct driver_info	*info = dev->driver_info;		int			retval = 0;		clear_bit (EVENT_LINK_RESET, &dev->flags);		status = usb_autopm_get_interface(dev->intf);		if (status < 0)			goto skip_reset;		if(info->link_reset && (retval = info->link_reset(dev)) < 0) {			usb_autopm_put_interface(dev->intf);skip_reset:			netdev_info(dev->net, "link reset failed (%d) usbnet usb-%s-%s, %s/n",				    retval,				    dev->udev->bus->bus_name,				    dev->udev->devpath,				    info->description);		} else {			usb_autopm_put_interface(dev->intf);		}	}	if (dev->flags)		netdev_dbg(dev->net, "kevent done, flags = 0x%lx/n", dev->flags);}

static int rtl2831u_power_ctrl(struct dvb_usb_device *d, int onoff){	int ret;	u8 gpio, sys0, epa_ctl[2];	dev_dbg(&d->udev->dev, "%s: onoff=%d/n", __func__, onoff);	/* demod adc */	ret = rtl28xx_rd_reg(d, SYS_SYS0, &sys0);	if (ret)		goto err;	/* tuner power, read GPIOs */	ret = rtl28xx_rd_reg(d, SYS_GPIO_OUT_VAL, &gpio);	if (ret)		goto err;	dev_dbg(&d->udev->dev, "%s: RD SYS0=%02x GPIO_OUT_VAL=%02x/n", __func__,			sys0, gpio);	if (onoff) {		gpio |= 0x01; /* GPIO0 = 1 */		gpio &= (~0x10); /* GPIO4 = 0 */		gpio |= 0x04; /* GPIO2 = 1, LED on */		sys0 = sys0 & 0x0f;		sys0 |= 0xe0;		epa_ctl[0] = 0x00; /* clear stall */		epa_ctl[1] = 0x00; /* clear reset */	} else {		gpio &= (~0x01); /* GPIO0 = 0 */		gpio |= 0x10; /* GPIO4 = 1 */		gpio &= (~0x04); /* GPIO2 = 1, LED off */		sys0 = sys0 & (~0xc0);		epa_ctl[0] = 0x10; /* set stall */		epa_ctl[1] = 0x02; /* set reset */	}	dev_dbg(&d->udev->dev, "%s: WR SYS0=%02x GPIO_OUT_VAL=%02x/n", __func__,			sys0, gpio);	/* demod adc */	ret = rtl28xx_wr_reg(d, SYS_SYS0, sys0);	if (ret)		goto err;	/* tuner power, write GPIOs */	ret = rtl28xx_wr_reg(d, SYS_GPIO_OUT_VAL, gpio);	if (ret)		goto err;	/* streaming EP: stall & reset */	ret = rtl28xx_wr_regs(d, USB_EPA_CTL, epa_ctl, 2);	if (ret)		goto err;	if (onoff)		usb_clear_halt(d->udev, usb_rcvbulkpipe(d->udev, 0x81));	return ret;err:	dev_dbg(&d->udev->dev, "%s: failed=%d/n", __func__, ret);	return ret;}

static void cxacru_upload_firmware(struct cxacru_data *instance,				   const struct firmware *fw,				   const struct firmware *bp){	int ret;	struct usbatm_data *usbatm = instance->usbatm;	struct usb_device *usb_dev = usbatm->usb_dev;	__le16 signature[] = { usb_dev->descriptor.idVendor,			       usb_dev->descriptor.idProduct };	__le32 val;	dbg("cxacru_upload_firmware");	/* FirmwarePllFClkValue */	val = cpu_to_le32(instance->modem_type->pll_f_clk);	ret = cxacru_fw(usb_dev, FW_WRITE_MEM, 0x2, 0x0, PLLFCLK_ADDR, (u8 *) &val, 4);	if (ret) {		usb_err(usbatm, "FirmwarePllFClkValue failed: %d/n", ret);		return;	}	/* FirmwarePllBClkValue */	val = cpu_to_le32(instance->modem_type->pll_b_clk);	ret = cxacru_fw(usb_dev, FW_WRITE_MEM, 0x2, 0x0, PLLBCLK_ADDR, (u8 *) &val, 4);	if (ret) {		usb_err(usbatm, "FirmwarePllBClkValue failed: %d/n", ret);		return;	}	/* Enable SDRAM */	val = cpu_to_le32(SDRAM_ENA);	ret = cxacru_fw(usb_dev, FW_WRITE_MEM, 0x2, 0x0, SDRAMEN_ADDR, (u8 *) &val, 4);	if (ret) {		usb_err(usbatm, "Enable SDRAM failed: %d/n", ret);		return;	}	/* Firmware */	usb_info(usbatm, "loading firmware/n");	ret = cxacru_fw(usb_dev, FW_WRITE_MEM, 0x2, 0x0, FW_ADDR, fw->data, fw->size);	if (ret) {		usb_err(usbatm, "Firmware upload failed: %d/n", ret);		return;	}	/* Boot ROM patch */	if (instance->modem_type->boot_rom_patch) {		usb_info(usbatm, "loading boot ROM patch/n");		ret = cxacru_fw(usb_dev, FW_WRITE_MEM, 0x2, 0x0, BR_ADDR, bp->data, bp->size);		if (ret) {			usb_err(usbatm, "Boot ROM patching failed: %d/n", ret);			return;		}	}	/* Signature */	ret = cxacru_fw(usb_dev, FW_WRITE_MEM, 0x2, 0x0, SIG_ADDR, (u8 *) signature, 4);	if (ret) {		usb_err(usbatm, "Signature storing failed: %d/n", ret);		return;	}	usb_info(usbatm, "starting device/n");	if (instance->modem_type->boot_rom_patch) {		val = cpu_to_le32(BR_ADDR);		ret = cxacru_fw(usb_dev, FW_WRITE_MEM, 0x2, 0x0, BR_STACK_ADDR, (u8 *) &val, 4);	} else {		ret = cxacru_fw(usb_dev, FW_GOTO_MEM, 0x0, 0x0, FW_ADDR, NULL, 0);	}	if (ret) {		usb_err(usbatm, "Passing control to firmware failed: %d/n", ret);		return;	}	/* Delay to allow firmware to start up. */	msleep_interruptible(1000);	usb_clear_halt(usb_dev, usb_sndbulkpipe(usb_dev, CXACRU_EP_CMD));	usb_clear_halt(usb_dev, usb_rcvbulkpipe(usb_dev, CXACRU_EP_CMD));	usb_clear_halt(usb_dev, usb_sndbulkpipe(usb_dev, CXACRU_EP_DATA));	usb_clear_halt(usb_dev, usb_rcvbulkpipe(usb_dev, CXACRU_EP_DATA));	ret = cxacru_cm(instance, CM_REQUEST_CARD_GET_STATUS, NULL, 0, NULL, 0);	if (ret < 0) {		usb_err(usbatm, "modem failed to initialize: %d/n", ret);		return;	}}