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

static ssize_t skel_write(struct file *file, const char *user_buffer, size_t count, loff_t *ppos){	struct usb_skel *dev;	int retval = 0;	struct urb *urb = NULL;	char *buf = NULL;	size_t writesize = min(count, (size_t)MAX_TRANSFER);	dev = (struct usb_skel *)file->private_data;	/* verify that we actually have some data to write */	if (count == 0)		goto exit;	/* limit the number of URBs in flight to stop a user from using up all RAM */	if (down_interruptible(&dev->limit_sem)) {		retval = -ERESTARTSYS;		goto exit;	}	spin_lock_irq(&dev->err_lock);	if ((retval = dev->errors) < 0) {		/* any error is reported once */		dev->errors = 0;		/* to preserve notifications about reset */		retval = (retval == -EPIPE) ? retval : -EIO;	}	spin_unlock_irq(&dev->err_lock);	if (retval < 0)		goto error;	/* create a urb, and a buffer for it, and copy the data to the urb */	urb = usb_alloc_urb(0, GFP_KERNEL);	if (!urb) {		retval = -ENOMEM;		goto error;	}	buf = usb_buffer_alloc(dev->udev, writesize, GFP_KERNEL, &urb->transfer_dma);	if (!buf) {		retval = -ENOMEM;		goto error;	}	if (copy_from_user(buf, user_buffer, writesize)) {		retval = -EFAULT;		goto error;	}	/* this lock makes sure we don't submit URBs to gone devices */	mutex_lock(&dev->io_mutex);	if (!dev->interface) {		/* disconnect() was called */		mutex_unlock(&dev->io_mutex);		retval = -ENODEV;		goto error;	}	/* initialize the urb properly */	usb_fill_bulk_urb(urb, dev->udev,			  usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),			  buf, writesize, skel_write_bulk_callback, dev);	urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	usb_anchor_urb(urb, &dev->submitted);	/* send the data out the bulk port */	retval = usb_submit_urb(urb, GFP_KERNEL);	mutex_unlock(&dev->io_mutex);	if (retval) {		err("%s - failed submitting write urb, error %d", __FUNCTION__, retval);		goto error_unanchor;	}	/* release our reference to this urb, the USB core will eventually free it entirely */	usb_free_urb(urb);	return writesize;error_unanchor:	usb_unanchor_urb(urb);error:	if (urb) {		usb_buffer_free(dev->udev, writesize, buf, urb->transfer_dma);		usb_free_urb(urb);	}	up(&dev->limit_sem);exit:	return retval;}

static void rx_urb_complete(struct urb *urb){	int r;	struct zd_usb *usb;	struct zd_usb_rx *rx;	const u8 *buffer;	unsigned int length;	switch (urb->status) {	case 0:		break;	case -ESHUTDOWN:	case -EINVAL:	case -ENODEV:	case -ENOENT:	case -ECONNRESET:	case -EPIPE:		dev_dbg_f(urb_dev(urb), "urb %p error %d/n", urb, urb->status);		return;	default:		dev_dbg_f(urb_dev(urb), "urb %p error %d/n", urb, urb->status);		goto resubmit;	}	buffer = urb->transfer_buffer;	length = urb->actual_length;	usb = urb->context;	rx = &usb->rx;	tasklet_schedule(&rx->reset_timer_tasklet);	if (length%rx->usb_packet_size > rx->usb_packet_size-4) {		/* If there is an old first fragment, we don't care. */		dev_dbg_f(urb_dev(urb), "*** first fragment ***/n");		ZD_ASSERT(length <= ARRAY_SIZE(rx->fragment));		spin_lock(&rx->lock);		memcpy(rx->fragment, buffer, length);		rx->fragment_length = length;		spin_unlock(&rx->lock);		goto resubmit;	}	spin_lock(&rx->lock);	if (rx->fragment_length > 0) {		/* We are on a second fragment, we believe */		ZD_ASSERT(length + rx->fragment_length <=			  ARRAY_SIZE(rx->fragment));		dev_dbg_f(urb_dev(urb), "*** second fragment ***/n");		memcpy(rx->fragment+rx->fragment_length, buffer, length);		handle_rx_packet(usb, rx->fragment,			         rx->fragment_length + length);		rx->fragment_length = 0;		spin_unlock(&rx->lock);	} else {		spin_unlock(&rx->lock);		handle_rx_packet(usb, buffer, length);	}resubmit:	r = usb_submit_urb(urb, GFP_ATOMIC);	if (r)		dev_dbg_f(urb_dev(urb), "urb %p resubmit error %d/n", urb, r);}

static void rx_submit (struct usbnet *dev, struct urb *urb, int flags){	struct sk_buff		*skb;	struct skb_data		*entry;	int			retval = 0;	unsigned long		lockflags;	size_t			size;#ifdef CONFIG_USB_NET1080	if (dev->driver_info->flags & FLAG_FRAMING_NC)		size = FRAMED_SIZE (dev->net.mtu);	else#endif#ifdef CONFIG_USB_GENESYS	if (dev->driver_info->flags & FLAG_FRAMING_GL)		size = GL_RCV_BUF_SIZE;	else#endif		size = (sizeof (struct ethhdr) + dev->net.mtu);	if ((skb = alloc_skb (size, flags)) == 0) {		dbg ("no rx skb");		tasklet_schedule (&dev->bh);		usb_free_urb (urb);		return;	}	entry = (struct skb_data *) skb->cb;	entry->urb = urb;	entry->dev = dev;	entry->state = rx_start;	entry->length = 0;	FILL_BULK_URB (urb, dev->udev,		usb_rcvbulkpipe (dev->udev, dev->driver_info->in),		skb->data, size, rx_complete, skb);	urb->transfer_flags |= USB_ASYNC_UNLINK;#ifdef	REALLY_QUEUE	urb->transfer_flags |= USB_QUEUE_BULK;#endif#if 0	// Idle-but-posted reads with UHCI really chew up	// PCI bandwidth unless FSBR is disabled	urb->transfer_flags |= USB_NO_FSBR;#endif	spin_lock_irqsave (&dev->rxq.lock, lockflags);	if (netif_running (&dev->net)) {		if ((retval = usb_submit_urb (urb)) != 0) {			dbg ("%s rx submit, %d", dev->net.name, retval);			tasklet_schedule (&dev->bh);		} else {			__skb_queue_tail (&dev->rxq, skb);		}	} else {		dbg ("rx: stopped");		retval = -ENOLINK;	}	spin_unlock_irqrestore (&dev->rxq.lock, lockflags);	if (retval) {		dev_kfree_skb_any (skb);		usb_free_urb (urb);	}}

static void resp_avail_cb(struct urb *urb){	struct usb_device		*udev;	struct ctrl_pkt_list_elem	*list_elem = NULL;	struct rmnet_ctrl_dev		*rx_dev, *dev = urb->context;	void				*cpkt;	int				ch_id, status = 0;	size_t				cpkt_size = 0;	unsigned int		iface_num;	udev = interface_to_usbdev(dev->intf);	iface_num = dev->intf->cur_altsetting->desc.bInterfaceNumber;	usb_autopm_put_interface_async(dev->intf);	switch (urb->status) {	case 0:		pr_info("[RACB:%d]</n", iface_num);		/*success*/		break;	/*do not resubmit*/	case -ESHUTDOWN:	case -ENOENT:	case -ECONNRESET:	case -EPROTO:		return;	/*resubmit*/	case -EOVERFLOW:		pr_err_ratelimited("%s: Babble error happened/n", __func__);	default:		pr_debug_ratelimited("%s: Non zero urb status = %d/n",				__func__, urb->status);		goto resubmit_int_urb;	}	dev_dbg(dev->devicep, "Read %d bytes for %s/n",		urb->actual_length, dev->name);	cpkt = urb->transfer_buffer;	cpkt_size = urb->actual_length;	if (!cpkt_size) {		dev->zlp_cnt++;		dev_dbg(dev->devicep, "%s: zero length pkt received/n",				__func__);		goto resubmit_int_urb;	}	list_elem = kmalloc(sizeof(struct ctrl_pkt_list_elem), GFP_ATOMIC);	if (!list_elem) {		dev_err(dev->devicep, "%s: list_elem alloc failed/n", __func__);		return;	}	list_elem->cpkt.data = kmalloc(cpkt_size, GFP_ATOMIC);	if (!list_elem->cpkt.data) {		dev_err(dev->devicep, "%s: list_elem->data alloc failed/n",			__func__);		kfree(list_elem);		return;	}	memcpy(list_elem->cpkt.data, cpkt, cpkt_size);	list_elem->cpkt.data_size = cpkt_size;	rx_dev = dev;	if (test_bit(RMNET_CTRL_DEV_MUX_EN, &dev->status)) {		ch_id = rmnet_usb_ctrl_dmux(list_elem);		if (ch_id < 0) {			kfree(list_elem->cpkt.data);			kfree(list_elem);			goto resubmit_int_urb;		}		rx_dev = &ctrl_devs[dev->id][ch_id];	}	rx_dev->get_encap_resp_cnt++;	spin_lock(&rx_dev->rx_lock);	list_add_tail(&list_elem->list, &rx_dev->rx_list);	spin_unlock(&rx_dev->rx_lock);	wake_up(&rx_dev->read_wait_queue);resubmit_int_urb:	/*check if it is already submitted in resume*/	if (!dev->inturb->anchor) {		usb_mark_last_busy(udev);		usb_anchor_urb(dev->inturb, &dev->rx_submitted);		status = usb_submit_urb(dev->inturb, GFP_ATOMIC);		if (status) {			usb_unanchor_urb(dev->inturb);			if (status != -ENODEV)				dev_err(dev->devicep,				"%s: Error re-submitting Int URB %d/n",				__func__, status);		}		pr_info("[CHKRA:%d]>/n", iface_num);	}//.........这里部分代码省略.........

/** *	usb_alphatrack_write */static ssize_t usb_alphatrack_write(struct file *file, const char __user *buffer,			    size_t count, loff_t *ppos){	struct usb_alphatrack *dev;	size_t bytes_to_write;	int retval = 0;	dev = file->private_data;	/* verify that we actually have some data to write */	if (count == 0)		goto exit;	/* lock this object */	if (down_interruptible(&dev->sem)) {		retval = -ERESTARTSYS;		goto exit;	}	/* verify that the device wasn't unplugged */	if (dev->intf == NULL) {		retval = -ENODEV;		err("No device or device unplugged %d/n", retval);		goto unlock_exit;	}	/* wait until previous transfer is finished */	if (dev->interrupt_out_busy) {		if (file->f_flags & O_NONBLOCK) {			retval = -EAGAIN;			goto unlock_exit;		}		retval = wait_event_interruptible(dev->write_wait, !dev->interrupt_out_busy);		if (retval < 0) {			goto unlock_exit;		}	}	/* write the data into interrupt_out_buffer from userspace */  /* FIXME - if you write more than 12 bytes this breaks */	bytes_to_write = min(count, write_buffer_size*dev->interrupt_out_endpoint_size);	if (bytes_to_write < count)		dev_warn(&dev->intf->dev, "Write buffer overflow, %zd bytes dropped/n",count-bytes_to_write);	dbg_info(&dev->intf->dev, "%s: count = %zd, bytes_to_write = %zd/n", __func__, count, bytes_to_write);	if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write)) {		retval = -EFAULT;		goto unlock_exit;	}	if (dev->interrupt_out_endpoint == NULL) {		err("Endpoint should not be be null! /n");		goto unlock_exit;	}	/* send off the urb */	usb_fill_int_urb(dev->interrupt_out_urb,			 interface_to_usbdev(dev->intf),			 usb_sndintpipe(interface_to_usbdev(dev->intf),					dev->interrupt_out_endpoint->bEndpointAddress),			 dev->interrupt_out_buffer,			 bytes_to_write,			 usb_alphatrack_interrupt_out_callback,			 dev,			 dev->interrupt_out_interval);	dev->interrupt_out_busy = 1;	atomic_inc(&dev->writes_pending);	wmb();	retval = usb_submit_urb(dev->interrupt_out_urb, GFP_KERNEL);	if (retval) {		dev->interrupt_out_busy = 0;		err("Couldn't submit interrupt_out_urb %d/n", retval);		atomic_dec(&dev->writes_pending);		goto unlock_exit;	}	retval = bytes_to_write;unlock_exit:	/* unlock the device */	up(&dev->sem);exit:	return retval;}

static void resp_avail_cb(struct urb *urb){	struct usb_device		*udev;	struct ctrl_pkt_list_elem	*list_elem = NULL;	struct rmnet_ctrl_dev		*dev = urb->context;	void				*cpkt;	int				status = 0;	size_t				cpkt_size = 0;	udev = interface_to_usbdev(dev->intf);	switch (urb->status) {	case 0:		/*success*/		dev->get_encap_resp_cnt++;		break;	/*do not resubmit*/	case -ESHUTDOWN:	case -ENOENT:	case -ECONNRESET:	case -EPROTO:		return;	/*resubmit*/	case -EOVERFLOW:		pr_err_ratelimited("%s: Babble error happened/n", __func__);	default:		pr_debug_ratelimited("%s: Non zero urb status = %d/n",				__func__, urb->status);		goto resubmit_int_urb;	}	dev_dbg(dev->devicep, "Read %d bytes for %s/n",		urb->actual_length, dev->name);	cpkt = urb->transfer_buffer;	cpkt_size = urb->actual_length;	list_elem = kmalloc(sizeof(struct ctrl_pkt_list_elem), GFP_ATOMIC);	if (!list_elem) {		dev_err(dev->devicep, "%s: list_elem alloc failed/n", __func__);		return;	}	list_elem->cpkt.data = kmalloc(cpkt_size, GFP_ATOMIC);	if (!list_elem->cpkt.data) {		dev_err(dev->devicep, "%s: list_elem->data alloc failed/n",			__func__);		kfree(list_elem);		return;	}	memcpy(list_elem->cpkt.data, cpkt, cpkt_size);	list_elem->cpkt.data_size = cpkt_size;	spin_lock(&dev->rx_lock);	list_add_tail(&list_elem->list, &dev->rx_list);	spin_unlock(&dev->rx_lock);	wake_up(&dev->read_wait_queue);resubmit_int_urb:	/*re-submit int urb to check response available*/	status = usb_submit_urb(dev->inturb, GFP_ATOMIC);	if (status)		dev_err(dev->devicep, "%s: Error re-submitting Int URB %d/n",			__func__, status);}

static void mct_u232_read_int_callback(struct urb *urb){    struct usb_serial_port *port = urb->context;    struct mct_u232_private *priv = usb_get_serial_port_data(port);    struct usb_serial *serial = port->serial;    struct tty_struct *tty;    unsigned char *data = urb->transfer_buffer;    int retval;    int status = urb->status;    unsigned long flags;    switch (status) {    case 0:        /* success */        break;    case -ECONNRESET:    case -ENOENT:    case -ESHUTDOWN:        /* this urb is terminated, clean up */        dbg("%s - urb shutting down with status: %d",            __func__, status);        return;    default:        dbg("%s - nonzero urb status received: %d",            __func__, status);        goto exit;    }    if (!serial) {        dbg("%s - bad serial pointer, exiting", __func__);        return;    }    dbg("%s - port %d", __func__, port->number);    usb_serial_debug_data(debug, &port->dev, __func__,                          urb->actual_length, data);    /*     * Work-a-round: handle the 'usual' bulk-in pipe here     */    if (urb->transfer_buffer_length > 2) {        if (urb->actual_length) {            tty = tty_port_tty_get(&port->port);            if (tty) {                tty_insert_flip_string(tty, data,                                       urb->actual_length);                tty_flip_buffer_push(tty);            }            tty_kref_put(tty);        }        goto exit;    }    /*     * The interrupt-in pipe signals exceptional conditions (modem line     * signal changes and errors). data[0] holds MSR, data[1] holds LSR.     */    spin_lock_irqsave(&priv->lock, flags);    priv->last_msr = data[MCT_U232_MSR_INDEX];    /* Record Control Line states */    mct_u232_msr_to_state(&priv->control_state, priv->last_msr);    mct_u232_msr_to_icount(&priv->icount, priv->last_msr);#if 0    /* Not yet handled. See belkin_sa.c for further information */    /* Now to report any errors */    priv->last_lsr = data[MCT_U232_LSR_INDEX];    /*     * fill in the flip buffer here, but I do not know the relation     * to the current/next receive buffer or characters.  I need     * to look in to this before committing any code.     */    if (priv->last_lsr & MCT_U232_LSR_ERR) {        tty = tty_port_tty_get(&port->port);        /* Overrun Error */        if (priv->last_lsr & MCT_U232_LSR_OE) {        }        /* Parity Error */        if (priv->last_lsr & MCT_U232_LSR_PE) {        }        /* Framing Error */        if (priv->last_lsr & MCT_U232_LSR_FE) {        }        /* Break Indicator */        if (priv->last_lsr & MCT_U232_LSR_BI) {        }        tty_kref_put(tty);    }#endif    wake_up_interruptible(&port->delta_msr_wait);    spin_unlock_irqrestore(&priv->lock, flags);exit:    retval = usb_submit_urb(urb, GFP_ATOMIC);    if (retval)        dev_err(&port->dev,                "%s - usb_submit_urb failed with result %d/n",                __func__, retval);} /* mct_u232_read_int_callback */

static void lme2510_int_response(struct urb *lme_urb){	struct dvb_usb_adapter *adap = lme_urb->context;	struct lme2510_state *st = adap_to_priv(adap);	u8 *ibuf, *rbuf;	int i = 0, offset;	u32 key;	u8 signal_lock = 0;	switch (lme_urb->status) {	case 0:	case -ETIMEDOUT:		break;	case -ECONNRESET:	case -ENOENT:	case -ESHUTDOWN:		return;	default:		info("Error %x", lme_urb->status);		break;	}	rbuf = (u8 *) lme_urb->transfer_buffer;	offset = ((lme_urb->actual_length/8) > 4)			? 4 : (lme_urb->actual_length/8) ;	for (i = 0; i < offset; ++i) {		ibuf = (u8 *)&rbuf[i*8];		deb_info(5, "INT O/S C =%02x C/O=%02x Type =%02x%02x",		offset, i, ibuf[0], ibuf[1]);		switch (ibuf[0]) {		case 0xaa:			debug_data_snipet(1, "INT Remote data snipet", ibuf);			if (!adap_to_d(adap)->rc_dev)				break;			key = RC_SCANCODE_NEC32(ibuf[2] << 24 |						ibuf[3] << 16 |						ibuf[4] << 8  |						ibuf[5]);			deb_info(1, "INT Key = 0x%08x", key);			rc_keydown(adap_to_d(adap)->rc_dev, RC_PROTO_NEC32, key,				   0);			break;		case 0xbb:			switch (st->tuner_config) {			case TUNER_LG:				signal_lock = ibuf[2] & BIT(5);				st->signal_level = ibuf[4];				st->signal_sn = ibuf[3];				st->time_key = ibuf[7];				break;			case TUNER_S7395:			case TUNER_S0194:				/* Tweak for earlier firmware*/				if (ibuf[1] == 0x03) {					signal_lock = ibuf[2] & BIT(4);					st->signal_level = ibuf[3];					st->signal_sn = ibuf[4];				} else {					st->signal_level = ibuf[4];					st->signal_sn = ibuf[5];				}				break;			case TUNER_RS2000:				signal_lock = ibuf[2] & 0xee;				st->signal_level = ibuf[5];				st->signal_sn = ibuf[4];				st->time_key = ibuf[7];			default:				break;			}			/* Interrupt will also throw just BIT 0 as lock */			signal_lock |= ibuf[2] & BIT(0);			if (!signal_lock)				st->lock_status &= ~FE_HAS_LOCK;			lme2510_update_stats(adap);			debug_data_snipet(5, "INT Remote data snipet in", ibuf);		break;		case 0xcc:			debug_data_snipet(1, "INT Control data snipet", ibuf);			break;		default:			debug_data_snipet(1, "INT Unknown data snipet", ibuf);		break;		}	}	usb_submit_urb(lme_urb, GFP_ATOMIC);	/* Interrupt urb is due every 48 msecs while streaming the buffer	 * stores up to 4 periods if missed. Allow 200 msec for next interrupt.	 *///.........这里部分代码省略.........

static int  mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port){    struct usb_serial *serial = port->serial;    struct mct_u232_private *priv = usb_get_serial_port_data(port);    int retval = 0;    unsigned int control_state;    unsigned long flags;    unsigned char last_lcr;    unsigned char last_msr;    dbg("%s port %d", __func__, port->number);    /* Compensate for a hardware bug: although the Sitecom U232-P25     * device reports a maximum output packet size of 32 bytes,     * it seems to be able to accept only 16 bytes (and that's what     * SniffUSB says too...)     */    if (le16_to_cpu(serial->dev->descriptor.idProduct)            == MCT_U232_SITECOM_PID)        port->bulk_out_size = 16;    /* Do a defined restart: the normal serial device seems to     * always turn on DTR and RTS here, so do the same. I'm not     * sure if this is really necessary. But it should not harm     * either.     */    spin_lock_irqsave(&priv->lock, flags);    if (tty && (tty->termios.c_cflag & CBAUD))        priv->control_state = TIOCM_DTR | TIOCM_RTS;    else        priv->control_state = 0;    priv->last_lcr = (MCT_U232_DATA_BITS_8 |                      MCT_U232_PARITY_NONE |                      MCT_U232_STOP_BITS_1);    control_state = priv->control_state;    last_lcr = priv->last_lcr;    spin_unlock_irqrestore(&priv->lock, flags);    mct_u232_set_modem_ctrl(serial, control_state);    mct_u232_set_line_ctrl(serial, last_lcr);    /* Read modem status and update control state */    mct_u232_get_modem_stat(serial, &last_msr);    spin_lock_irqsave(&priv->lock, flags);    priv->last_msr = last_msr;    mct_u232_msr_to_state(&priv->control_state, priv->last_msr);    spin_unlock_irqrestore(&priv->lock, flags);    retval = usb_submit_urb(port->read_urb, GFP_KERNEL);    if (retval) {        dev_err(&port->dev,                "usb_submit_urb(read bulk) failed pipe 0x%x err %d/n",                port->read_urb->pipe, retval);        goto error;    }    retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);    if (retval) {        usb_kill_urb(port->read_urb);        dev_err(&port->dev,                "usb_submit_urb(read int) failed pipe 0x%x err %d",                port->interrupt_in_urb->pipe, retval);        goto error;    }    return 0;error:    return retval;} /* mct_u232_open */

static void opticon_bulk_callback(struct urb *urb){	struct opticon_private *priv = urb->context;	unsigned char *data = urb->transfer_buffer;	struct usb_serial_port *port = priv->port;	int status = urb->status;	struct tty_struct *tty;	int result;	int data_length;	dbg("%s - port %d", __func__, port->number);	switch (status) {	case 0:		/* success */		break;	case -ECONNRESET:	case -ENOENT:	case -ESHUTDOWN:		/* this urb is terminated, clean up */		dbg("%s - urb shutting down with status: %d",		    __func__, status);		return;	default:		dbg("%s - nonzero urb status received: %d",		    __func__, status);		goto exit;	}	usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length,			      data);	if (urb->actual_length > 2) {		data_length = urb->actual_length - 2;		/*		 * Data from the device comes with a 2 byte header:		 *		 * <0x00><0x00>data...		 * 	This is real data to be sent to the tty layer		 * <0x00><0x01)level		 * 	This is a RTS level change, the third byte is the RTS		 * 	value (0 for low, 1 for high).		 */		if ((data[0] == 0x00) && (data[1] == 0x00)) {			/* real data, send it to the tty layer */			tty = tty_port_tty_get(&port->port);			if (tty) {				tty_insert_flip_string(tty, data + 2,						       data_length);				tty_flip_buffer_push(tty);				tty_kref_put(tty);			}		} else {			if ((data[0] == 0x00) && (data[1] == 0x01)) {				if (data[2] == 0x00)					priv->rts = false;				else					priv->rts = true;			} else {			dev_dbg(&priv->udev->dev,				"Unknown data packet received from the device:"				" %2x %2x/n",				data[0], data[1]);			}		}	} else {		dev_dbg(&priv->udev->dev,			"Improper amount of data received from the device, "			"%d bytes", urb->actual_length);	}exit:	spin_lock(&priv->lock);	/* Continue trying to always read if we should */	if (!priv->throttled) {		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_bulk_callback, priv);		result = usb_submit_urb(priv->bulk_read_urb, GFP_ATOMIC);		if (result)			dev_err(&port->dev,			    "%s - failed resubmitting read urb, error %d/n",							__func__, result);	} else		priv->actually_throttled = true;	spin_unlock(&priv->lock);}

static int opticon_write(struct tty_struct *tty, struct usb_serial_port *port,			 const unsigned char *buf, int count){	struct opticon_private *priv = usb_get_serial_data(port->serial);	struct usb_serial *serial = port->serial;	struct urb *urb;	unsigned char *buffer;	unsigned long flags;	int status;	dbg("%s - port %d", __func__, port->number);	spin_lock_irqsave(&priv->lock, flags);	if (priv->outstanding_urbs > URB_UPPER_LIMIT) {		spin_unlock_irqrestore(&priv->lock, flags);		dbg("%s - write limit hit", __func__);		return 0;	}	priv->outstanding_urbs++;	spin_unlock_irqrestore(&priv->lock, flags);	buffer = kmalloc(count, GFP_ATOMIC);	if (!buffer) {		dev_err(&port->dev, "out of memory/n");		count = -ENOMEM;		goto error_no_buffer;	}	urb = usb_alloc_urb(0, GFP_ATOMIC);	if (!urb) {		dev_err(&port->dev, "no more free urbs/n");		count = -ENOMEM;		goto error_no_urb;	}	memcpy(buffer, buf, count);	usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);	usb_fill_bulk_urb(urb, serial->dev,			  usb_sndbulkpipe(serial->dev,					  port->bulk_out_endpointAddress),			  buffer, count, opticon_write_bulk_callback, priv);	/* send it down the pipe */	status = usb_submit_urb(urb, GFP_ATOMIC);	if (status) {		dev_err(&port->dev,		   "%s - usb_submit_urb(write bulk) failed with status = %d/n",							__func__, status);		count = status;		goto error;	}	/* we are done with this urb, so let the host driver	 * really free it when it is finished with it */	usb_free_urb(urb);	return count;error:	usb_free_urb(urb);error_no_urb:	kfree(buffer);error_no_buffer:	spin_lock_irqsave(&priv->lock, flags);	--priv->outstanding_urbs;	spin_unlock_irqrestore(&priv->lock, flags);	return count;}

static void usb_alphatrack_interrupt_in_callback(struct urb *urb){	struct usb_alphatrack *dev = urb->context;	unsigned int next_ring_head;	int retval = -1;	if (urb->status) {		if (urb->status == -ENOENT ||		    urb->status == -ECONNRESET ||		    urb->status == -ESHUTDOWN) {			goto exit;		} else {			dbg_info(&dev->intf->dev, "%s: nonzero status received: %d/n",				 __func__, urb->status);			goto resubmit; /* maybe we can recover */		}	}	if (urb->actual_length != INPUT_CMD_SIZE) {		dev_warn(&dev->intf->dev,			 "Urb length was %d bytes!! Do something intelligent /n", urb->actual_length);	} else {		 alphatrack_ocmd_info(&dev->intf->dev,&(*dev->ring_buffer)[dev->ring_tail].cmd,"%s", "bla");		 if(memcmp(dev->interrupt_in_buffer,dev->oldi_buffer,INPUT_CMD_SIZE)==0) {						goto resubmit;		}		memcpy(dev->oldi_buffer,dev->interrupt_in_buffer,INPUT_CMD_SIZE);#if SUPPRESS_EXTRA_OFFLINE_EVENTS	if(dev->offline == 2 && dev->interrupt_in_buffer[1] == 0xff) { goto resubmit; }		if(dev->offline == 1 && dev->interrupt_in_buffer[1] == 0xff) { dev->offline = 2; goto resubmit; }/* Always pass one offline event up the stack */		if(dev->offline > 0 && dev->interrupt_in_buffer[1] != 0xff) { dev->offline = 0; }		if(dev->offline == 0 && dev->interrupt_in_buffer[1] == 0xff) { dev->offline = 1; }#endif		dbg_info(&dev->intf->dev, "%s: head, tail are %x, %x/n", __func__,dev->ring_head,dev->ring_tail);		next_ring_head = (dev->ring_head+1) % ring_buffer_size;		if (next_ring_head != dev->ring_tail) {			memcpy(&((*dev->ring_buffer)[dev->ring_head]),						 dev->interrupt_in_buffer, urb->actual_length);			dev->ring_head = next_ring_head;			retval = 0;			memset(dev->interrupt_in_buffer, 0, urb->actual_length);		} else {			dev_warn(&dev->intf->dev,				 "Ring buffer overflow, %d bytes dropped/n",				 urb->actual_length);			memset(dev->interrupt_in_buffer, 0, urb->actual_length);		}	}resubmit:	/* resubmit if we're still running */	if (dev->interrupt_in_running && dev->intf) {		retval = usb_submit_urb(dev->interrupt_in_urb, GFP_ATOMIC);		if (retval)			dev_err(&dev->intf->dev,				"usb_submit_urb failed (%d)/n", retval);	}exit:	dev->interrupt_in_done = 1;	wake_up_interruptible(&dev->read_wait);}

static int xpad360_probe(struct usb_interface *interface, const struct usb_device_id *id){		int error = 0;	struct usb_device *usb_dev = interface_to_usbdev(interface);	struct xpad360_controller *controller = 		kzalloc(sizeof(struct xpad360_controller), GFP_KERNEL);			if (!controller)		return -ENOMEM;		usb_set_intfdata(interface, controller);		/* LED */	error = xpad360_setup_transfer_out(interface, 			&controller->led_out, xpad360_send, GFP_KERNEL);	if (error)		goto fail_led_setup;		controller->led_out.urb->transfer_buffer_length = 3; /* Never changes */		xpad360_async_led(controller, XPAD360_LED_ON_1);	/* Input Dev allocation, capabilities, registration */	controller->input_dev =		xpad360_create_input_dev(usb_dev,			xpad360_device_names[id - xpad360_table],			xpad360_open, xpad360_close);		if (!controller->input_dev) {		error = -ENOMEM;		goto fail_input_setup;	}		xpad360_set_capabilities(controller->input_dev);		error = input_register_device(controller->input_dev);	if (error)		goto fail_input_register;		input_set_drvdata(controller->input_dev, controller);		/* Rumble transfer setup */#ifndef XPAD360_RUMBLE_DISABLED	error = xpad360_setup_transfer_out(interface, 			&controller->rumble_out, xpad360_send, GFP_KERNEL);	if (error)		goto fail_ff_setup;		controller->rumble_out.urb->transfer_buffer_length = 8; /* Never changes */		/* ff-memless setup */	error = input_ff_create_memless(controller->input_dev, NULL, xpad360_rumble);	if (error) 		goto fail_ff_memless;#endif		/* In transfer */	error = xpad360_setup_transfer_in(interface, 			&controller->in, xpad360_receive, GFP_KERNEL);		if (error)		goto fail_in_init;		error = usb_submit_urb(controller->in.urb, GFP_KERNEL);	if (error)		goto fail_in_submit;		goto success;fail_in_submit:	xpad360_free_transfer(usb_dev, &controller->in);fail_in_init:fail_ff_memless:	xpad360_free_transfer(usb_dev, &controller->rumble_out);fail_ff_setup:	xpad360_unregister_input_dev(controller->input_dev);fail_input_register:	xpad360_free_input_dev(controller->input_dev);fail_input_setup:	xpad360_free_transfer(usb_dev, &controller->led_out);fail_led_setup:	kfree(controller);success:	return error;}

/** *	usb_alphatrack_open */static int usb_alphatrack_open(struct inode *inode, struct file *file){	struct usb_alphatrack *dev;	int subminor;	int retval = 0;	struct usb_interface *interface;	nonseekable_open(inode, file);	subminor = iminor(inode);	mutex_lock(&disconnect_mutex);	interface = usb_find_interface(&usb_alphatrack_driver, subminor);	if (!interface) {		err("%s - error, can't find device for minor %d/n",		     __func__, subminor);		retval = -ENODEV;		goto unlock_disconnect_exit;	}	dev = usb_get_intfdata(interface);	if (!dev) {		retval = -ENODEV;		goto unlock_disconnect_exit;	}	/* lock this device */	if (down_interruptible(&dev->sem)) {		retval = -ERESTARTSYS;		goto unlock_disconnect_exit;	}	/* allow opening only once */	if (dev->open_count) {		retval = -EBUSY;		goto unlock_exit;	}	dev->open_count = 1;	/* initialize in direction */	dev->ring_head = 0;	dev->ring_tail = 0;	usb_fill_int_urb(dev->interrupt_in_urb,			 interface_to_usbdev(interface),			 usb_rcvintpipe(interface_to_usbdev(interface),					dev->interrupt_in_endpoint->bEndpointAddress),			 dev->interrupt_in_buffer,			 dev->interrupt_in_endpoint_size,			 usb_alphatrack_interrupt_in_callback,			 dev,			 dev->interrupt_in_interval);	dev->interrupt_in_running = 1;	dev->interrupt_in_done = 0;	dev->enable = 1;	dev->offline = 0;	retval = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL);	if (retval) {		dev_err(&interface->dev, "Couldn't submit interrupt_in_urb %d/n", retval);		dev->interrupt_in_running = 0;		dev->open_count = 0;		goto unlock_exit;	}	/* save device in the file's private structure */	file->private_data = dev;unlock_exit:	up(&dev->sem);unlock_disconnect_exit:	mutex_unlock(&disconnect_mutex);	return retval;}

static void notification_available_cb(struct urb *urb){	int				status;	struct usb_cdc_notification	*ctrl;	struct usb_device		*udev;	struct rmnet_ctrl_dev		*dev = urb->context;	udev = interface_to_usbdev(dev->intf);	switch (urb->status) {	case 0:		/*success*/		break;	/*do not resubmit*/	case -ESHUTDOWN:	case -ENOENT:	case -ECONNRESET:	case -EPROTO:		return;	case -EPIPE:		pr_err_ratelimited("%s: Stall on int endpoint/n", __func__);		/* TBD : halt to be cleared in work */		return;	/*resubmit*/	case -EOVERFLOW:		pr_err_ratelimited("%s: Babble error happened/n", __func__);	default:		 pr_debug_ratelimited("%s: Non zero urb status = %d/n",			__func__, urb->status);		goto resubmit_int_urb;	}	ctrl = urb->transfer_buffer;	switch (ctrl->bNotificationType) {	case USB_CDC_NOTIFY_RESPONSE_AVAILABLE:		dev->resp_avail_cnt++;		usb_fill_control_urb(dev->rcvurb, udev,					usb_rcvctrlpipe(udev, 0),					(unsigned char *)dev->in_ctlreq,					dev->rcvbuf,					DEFAULT_READ_URB_LENGTH,					resp_avail_cb, dev);		status = usb_submit_urb(dev->rcvurb, GFP_ATOMIC);		if (status) {			dev_err(dev->devicep,			"%s: Error submitting Read URB %d/n", __func__, status);			goto resubmit_int_urb;		}		if (!dev->resp_available) {			dev->resp_available = true;			wake_up(&dev->open_wait_queue);		}		return;	default:		 dev_err(dev->devicep,			"%s:Command not implemented/n", __func__);	}resubmit_int_urb:	status = usb_submit_urb(urb, GFP_ATOMIC);	if (status)		dev_err(dev->devicep, "%s: Error re-submitting Int URB %d/n",		__func__, status);	return;}

/* * USB callback handler for reading data */static void iowarrior_callback(struct urb *urb){	struct iowarrior *dev = urb->context;	int intr_idx;	int read_idx;	int aux_idx;	int offset;	int status = urb->status;	int retval;	switch (status) {	case 0:		/* success */		break;	case -ECONNRESET:	case -ENOENT:	case -ESHUTDOWN:		return;	default:		goto exit;	}	spin_lock(&dev->intr_idx_lock);	intr_idx = atomic_read(&dev->intr_idx);	/* aux_idx become previous intr_idx */	aux_idx = (intr_idx == 0) ? (MAX_INTERRUPT_BUFFER - 1) : (intr_idx - 1);	read_idx = atomic_read(&dev->read_idx);	/* queue is not empty and it's interface 0 */	if ((intr_idx != read_idx)	    && (dev->interface->cur_altsetting->desc.bInterfaceNumber == 0)) {		/* + 1 for serial number */		offset = aux_idx * (dev->report_size + 1);		if (!memcmp		    (dev->read_queue + offset, urb->transfer_buffer,		     dev->report_size)) {			/* equal values on interface 0 will be ignored */			spin_unlock(&dev->intr_idx_lock);			goto exit;		}	}	/* aux_idx become next intr_idx */	aux_idx = (intr_idx == (MAX_INTERRUPT_BUFFER - 1)) ? 0 : (intr_idx + 1);	if (read_idx == aux_idx) {		/* queue full, dropping oldest input */		read_idx = (++read_idx == MAX_INTERRUPT_BUFFER) ? 0 : read_idx;		atomic_set(&dev->read_idx, read_idx);		atomic_set(&dev->overflow_flag, 1);	}	/* +1 for serial number */	offset = intr_idx * (dev->report_size + 1);	memcpy(dev->read_queue + offset, urb->transfer_buffer,	       dev->report_size);	*(dev->read_queue + offset + (dev->report_size)) = dev->serial_number++;	atomic_set(&dev->intr_idx, aux_idx);	spin_unlock(&dev->intr_idx_lock);	/* tell the blocking read about the new data */	wake_up_interruptible(&dev->read_wait);exit:	retval = usb_submit_urb(urb, GFP_ATOMIC);	if (retval)		dev_err(&dev->interface->dev, "%s - usb_submit_urb failed with result %d/n",			__func__, retval);}

static void notification_available_cb(struct urb *urb){	int				status;	struct usb_cdc_notification	*ctrl;	struct usb_device		*udev;	struct rmnet_ctrl_dev		*dev = urb->context;	unsigned int		iface_num;	udev = interface_to_usbdev(dev->intf);	iface_num = dev->intf->cur_altsetting->desc.bInterfaceNumber;	switch (urb->status) {	case 0:	/*if non zero lenght of data received while unlink*/	case -ENOENT:		pr_info("[NACB:%d]</n", iface_num);		/*success*/		break;	/*do not resubmit*/	case -ESHUTDOWN:	case -ECONNRESET:	case -EPROTO:		return;	case -EPIPE:		pr_err_ratelimited("%s: Stall on int endpoint/n", __func__);		/* TBD : halt to be cleared in work */		return;	/*resubmit*/	case -EOVERFLOW:		pr_err_ratelimited("%s: Babble error happened/n", __func__);	default:		 pr_debug_ratelimited("%s: Non zero urb status = %d/n",			__func__, urb->status);		goto resubmit_int_urb;	}	if (!urb->actual_length)		return;	ctrl = urb->transfer_buffer;	switch (ctrl->bNotificationType) {	case USB_CDC_NOTIFY_RESPONSE_AVAILABLE:		dev->resp_avail_cnt++;		/* If MUX is not enabled, wakeup up the open process		 * upon first notify response available.		 */		if (!test_bit(RMNET_CTRL_DEV_READY, &dev->status)) {			set_bit(RMNET_CTRL_DEV_READY, &dev->status);			wake_up(&dev->open_wait_queue);		}		usb_mark_last_busy(udev);		queue_work(dev->wq, &dev->get_encap_work);		return;	default:		 dev_err(dev->devicep,			"%s:Command not implemented/n", __func__);	}resubmit_int_urb:	usb_anchor_urb(urb, &dev->rx_submitted);	status = usb_submit_urb(urb, GFP_ATOMIC);	if (status) {		usb_unanchor_urb(urb);		if (status != -ENODEV)			dev_err(dev->devicep,			"%s: Error re-submitting Int URB %d/n",			__func__, status);	}	return;}

//.........这里部分代码省略.........	case USB_DEVICE_ID_CODEMERCS_IOWPV2:	case USB_DEVICE_ID_CODEMERCS_IOW40:		/* IOW24 and IOW40 use a synchronous call */		buf = kmalloc(count, GFP_KERNEL);		if (!buf) {			retval = -ENOMEM;			goto exit;		}		if (copy_from_user(buf, user_buffer, count)) {			retval = -EFAULT;			kfree(buf);			goto exit;		}		retval = usb_set_report(dev->interface, 2, 0, buf, count);		kfree(buf);		goto exit;		break;	case USB_DEVICE_ID_CODEMERCS_IOW56:		/* The IOW56 uses asynchronous IO and more urbs */		if (atomic_read(&dev->write_busy) == MAX_WRITES_IN_FLIGHT) {			/* Wait until we are below the limit for submitted urbs */			if (file->f_flags & O_NONBLOCK) {				retval = -EAGAIN;				goto exit;			} else {				retval = wait_event_interruptible(dev->write_wait,								  (!dev->present || (atomic_read (&dev-> write_busy) < MAX_WRITES_IN_FLIGHT)));				if (retval) {					/* we were interrupted by a signal */					retval = -ERESTART;					goto exit;				}				if (!dev->present) {					/* The device was unplugged */					retval = -ENODEV;					goto exit;				}				if (!dev->opened) {					/* We were closed while waiting for an URB */					retval = -ENODEV;					goto exit;				}			}		}		atomic_inc(&dev->write_busy);		int_out_urb = usb_alloc_urb(0, GFP_KERNEL);		if (!int_out_urb) {			retval = -ENOMEM;			dbg("%s Unable to allocate urb ", __func__);			goto error_no_urb;		}		buf = usb_alloc_coherent(dev->udev, dev->report_size,					 GFP_KERNEL, &int_out_urb->transfer_dma);		if (!buf) {			retval = -ENOMEM;			dbg("%s Unable to allocate buffer ", __func__);			goto error_no_buffer;		}		usb_fill_int_urb(int_out_urb, dev->udev,				 usb_sndintpipe(dev->udev,						dev->int_out_endpoint->bEndpointAddress),				 buf, dev->report_size,				 iowarrior_write_callback, dev,				 dev->int_out_endpoint->bInterval);		int_out_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;		if (copy_from_user(buf, user_buffer, count)) {			retval = -EFAULT;			goto error;		}		retval = usb_submit_urb(int_out_urb, GFP_KERNEL);		if (retval) {			dbg("%s submit error %d for urb nr.%d", __func__,			    retval, atomic_read(&dev->write_busy));			goto error;		}		/* submit was ok */		retval = count;		usb_free_urb(int_out_urb);		goto exit;		break;	default:		/* what do we have here ? An unsupported Product-ID ? */		dev_err(&dev->interface->dev, "%s - not supported for product=0x%x/n",			__func__, dev->product_id);		retval = -EFAULT;		goto exit;		break;	}error:	usb_free_coherent(dev->udev, dev->report_size, buf,			  int_out_urb->transfer_dma);error_no_buffer:	usb_free_urb(int_out_urb);error_no_urb:	atomic_dec(&dev->write_busy);	wake_up_interruptible(&dev->write_wait);exit:	mutex_unlock(&dev->mutex);	return retval;}

static int rmnet_usb_ctrl_write(struct rmnet_ctrl_dev *dev,		struct ctrl_pkt *cpkt, size_t size){	int			result;	struct urb		*sndurb;	struct usb_ctrlrequest	*out_ctlreq;	struct usb_device	*udev;	if (!test_bit(RMNET_CTRL_DEV_READY, &dev->status))		return -ENETRESET;	udev = interface_to_usbdev(dev->intf);	sndurb = usb_alloc_urb(0, GFP_KERNEL);	if (!sndurb) {		dev_err(dev->devicep, "Error allocating read urb/n");		return -ENOMEM;	}	out_ctlreq = kmalloc(sizeof(*out_ctlreq), GFP_KERNEL);	if (!out_ctlreq) {		usb_free_urb(sndurb);		dev_err(dev->devicep, "Error allocating setup packet buffer/n");		return -ENOMEM;	}	/* CDC Send Encapsulated Request packet */	out_ctlreq->bRequestType = (USB_DIR_OUT | USB_TYPE_CLASS |			     USB_RECIP_INTERFACE);	out_ctlreq->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;	out_ctlreq->wValue = 0;	out_ctlreq->wIndex = dev->intf->cur_altsetting->desc.bInterfaceNumber;	out_ctlreq->wLength = cpu_to_le16(cpkt->data_size);	usb_fill_control_urb(sndurb, udev,			     usb_sndctrlpipe(udev, 0),			     (unsigned char *)out_ctlreq, (void *)cpkt->data,			     cpkt->data_size, ctrl_write_callback, cpkt);	result = usb_autopm_get_interface(dev->intf);	if (result < 0) {		dev_dbg(dev->devicep, "%s: Unable to resume interface: %d/n",			__func__, result);		/*		* Revisit:  if (result == -EPERM)		*		rmnet_usb_suspend(dev->intf, PMSG_SUSPEND);		*/		usb_free_urb(sndurb);		kfree(out_ctlreq);		return result;	}	usb_anchor_urb(sndurb, &dev->tx_submitted);	dev->snd_encap_cmd_cnt++;	result = usb_submit_urb(sndurb, GFP_KERNEL);	if (result < 0) {		if (result != -ENODEV)			dev_err(dev->devicep,			"%s: Submit URB error %d/n",			__func__, result);		dev->snd_encap_cmd_cnt--;		usb_autopm_put_interface(dev->intf);		usb_unanchor_urb(sndurb);		usb_free_urb(sndurb);		kfree(out_ctlreq);		return result;	}	return size;}

/* control interface reports status changes with "interrupt" transfers */static void acm_ctrl_irq(struct urb *urb){	struct acm *acm = urb->context;	struct usb_cdc_notification *dr = urb->transfer_buffer;	struct tty_struct *tty;	unsigned char *data;	int newctrl;	int retval;	int status = urb->status;	switch (status) {	case 0:		/* success */		break;	case -ECONNRESET:	case -ENOENT:	case -ESHUTDOWN:		/* this urb is terminated, clean up */		dev_dbg(&acm->control->dev,				"%s - urb shutting down with status: %d/n",				__func__, status);		return;	default:		dev_dbg(&acm->control->dev,				"%s - nonzero urb status received: %d/n",				__func__, status);		goto exit;	}	usb_mark_last_busy(acm->dev);	data = (unsigned char *)(dr + 1);	switch (dr->bNotificationType) {	case USB_CDC_NOTIFY_NETWORK_CONNECTION:		dev_dbg(&acm->control->dev, "%s - network connection: %d/n",							__func__, dr->wValue);		break;	case USB_CDC_NOTIFY_SERIAL_STATE:		tty = tty_port_tty_get(&acm->port);		newctrl = get_unaligned_le16(data);		if (tty) {			if (!acm->clocal &&				(acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {				dev_dbg(&acm->control->dev,					"%s - calling hangup/n", __func__);				tty_hangup(tty);			}			tty_kref_put(tty);		}		acm->ctrlin = newctrl;		dev_dbg(&acm->control->dev,			"%s - input control lines: dcd%c dsr%c break%c "			"ring%c framing%c parity%c overrun%c/n",			__func__,			acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',			acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',			acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',			acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',			acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',			acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',			acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');			break;	default:		dev_dbg(&acm->control->dev,			"%s - unknown notification %d received: index %d "			"len %d data0 %d data1 %d/n",			__func__,			dr->bNotificationType, dr->wIndex,			dr->wLength, data[0], data[1]);		break;	}exit:	retval = usb_submit_urb(urb, GFP_ATOMIC);	if (retval)		dev_err(&acm->control->dev, "%s - usb_submit_urb failed: %d/n",							__func__, retval);}

int zd_usb_enable_int(struct zd_usb *usb){	int r;	struct usb_device *udev = zd_usb_to_usbdev(usb);	struct zd_usb_interrupt *intr = &usb->intr;	struct urb *urb;	dev_dbg_f(zd_usb_dev(usb), "/n");	urb = usb_alloc_urb(0, GFP_KERNEL);	if (!urb) {		r = -ENOMEM;		goto out;	}	ZD_ASSERT(!irqs_disabled());	spin_lock_irq(&intr->lock);	if (intr->urb) {		spin_unlock_irq(&intr->lock);		r = 0;		goto error_free_urb;	}	intr->urb = urb;	spin_unlock_irq(&intr->lock);	r = -ENOMEM;	intr->buffer = usb_alloc_coherent(udev, USB_MAX_EP_INT_BUFFER,					  GFP_KERNEL, &intr->buffer_dma);	if (!intr->buffer) {		dev_dbg_f(zd_usb_dev(usb),			"couldn't allocate transfer_buffer/n");		goto error_set_urb_null;	}	usb_fill_int_urb(urb, udev, usb_rcvintpipe(udev, EP_INT_IN),			 intr->buffer, USB_MAX_EP_INT_BUFFER,			 int_urb_complete, usb,			 intr->interval);	urb->transfer_dma = intr->buffer_dma;	urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	dev_dbg_f(zd_usb_dev(usb), "submit urb %p/n", intr->urb);	r = usb_submit_urb(urb, GFP_KERNEL);	if (r) {		dev_dbg_f(zd_usb_dev(usb),			 "Couldn't submit urb. Error number %d/n", r);		goto error;	}	return 0;error:	usb_free_coherent(udev, USB_MAX_EP_INT_BUFFER,			  intr->buffer, intr->buffer_dma);error_set_urb_null:	spin_lock_irq(&intr->lock);	intr->urb = NULL;	spin_unlock_irq(&intr->lock);error_free_urb:	usb_free_urb(urb);out:	return r;}

static void stub_recv_cmd_submit(struct stub_device *sdev, struct usbip_header *pdu){	int ret;	struct stub_priv *priv;	struct usbip_device *ud = &sdev->ud;	struct usb_device *udev = interface_to_usbdev(sdev->interface);	int pipe = get_pipe(sdev, pdu->base.ep, pdu->base.direction);	priv = stub_priv_alloc(sdev, pdu);	if (!priv)		return;	/* setup a urb */	if (usb_pipeisoc(pipe))		priv->urb = usb_alloc_urb(pdu->u.cmd_submit.number_of_packets, GFP_KERNEL);	else		priv->urb = usb_alloc_urb(0, GFP_KERNEL);	if (!priv->urb) {		uerr("malloc urb/n");		usbip_event_add(ud, SDEV_EVENT_ERROR_MALLOC);		return;	}	/* set priv->urb->transfer_buffer */	if (pdu->u.cmd_submit.transfer_buffer_length > 0) {		/*uinfo("pdu->u.cmd_submit.transfer_buffer_length = %d/n", pdu->u.cmd_submit.transfer_buffer_length);*/		priv->urb->transfer_buffer =			kzalloc(pdu->u.cmd_submit.transfer_buffer_length, GFP_KERNEL);		if (!priv->urb->transfer_buffer) {			uerr("malloc x_buff/n");			usbip_event_add(ud, SDEV_EVENT_ERROR_MALLOC);			return;		}	}	/* set priv->urb->setup_packet */	priv->urb->setup_packet = kzalloc(8, GFP_KERNEL);	if (!priv->urb->setup_packet) {		uerr("allocate setup_packet/n");		usbip_event_add(ud, SDEV_EVENT_ERROR_MALLOC);		return;	}	memcpy(priv->urb->setup_packet, &pdu->u.cmd_submit.setup, 8);	/* set other members from the base header of pdu */	priv->urb->context                = (void *) priv;	priv->urb->dev                    = udev;	priv->urb->pipe                   = pipe;	priv->urb->complete               = stub_complete;	usbip_pack_pdu(pdu, priv->urb, USBIP_CMD_SUBMIT, 0);	priv->urb->transfer_flags &= (~URB_SHORT_NOT_OK);	/* added by tf, necessarily! */	if (usbip_recv_xbuff(ud, priv->urb) < 0)		return;	if (usbip_recv_iso(ud, priv->urb) < 0)		return;	/* no need to submit an intercepted request, but harmless? */	tweak_special_requests(priv->urb);	/* urb is now ready to submit */	ret = usb_submit_urb(priv->urb, GFP_KERNEL);	if (ret == 0)		dbg_stub_rx("submit urb ok, seqnum %u/n", pdu->base.seqnum);	else {		uerr("submit_urb error, %d/n", ret);		usbip_dump_header(pdu);		usbip_dump_urb(priv->urb);		/*		 * Pessimistic.		 * This connection will be discarded.		 */		usbip_event_add(ud, SDEV_EVENT_ERROR_SUBMIT);	}	dbg_stub_rx("Leave/n");	return;}

/* * Function kingsun_net_open (dev) * *    Network device is taken up. Usually this is done by "ifconfig irda0 up" */static int kingsun_net_open(struct net_device *netdev){    struct kingsun_cb *kingsun = netdev_priv(netdev);    int err = -ENOMEM;    char hwname[16];    /* At this point, urbs are NULL, and skb is NULL (see kingsun_probe) */    kingsun->receiving = 0;    /* Initialize for SIR to copy data directly into skb.  */    kingsun->rx_buff.in_frame = FALSE;    kingsun->rx_buff.state = OUTSIDE_FRAME;    kingsun->rx_buff.truesize = IRDA_SKB_MAX_MTU;    kingsun->rx_buff.skb = dev_alloc_skb(IRDA_SKB_MAX_MTU);    if (!kingsun->rx_buff.skb)        goto free_mem;    skb_reserve(kingsun->rx_buff.skb, 1);    kingsun->rx_buff.head = kingsun->rx_buff.skb->data;    do_gettimeofday(&kingsun->rx_time);    kingsun->rx_urb = usb_alloc_urb(0, GFP_KERNEL);    if (!kingsun->rx_urb)        goto free_mem;    kingsun->tx_urb = usb_alloc_urb(0, GFP_KERNEL);    if (!kingsun->tx_urb)        goto free_mem;    /*     * Now that everything should be initialized properly,     * Open new IrLAP layer instance to take care of us...     */    sprintf(hwname, "usb#%d", kingsun->usbdev->devnum);    kingsun->irlap = irlap_open(netdev, &kingsun->qos, hwname);    if (!kingsun->irlap) {        err("kingsun-sir: irlap_open failed");        goto free_mem;    }    /* Start first reception */    usb_fill_int_urb(kingsun->rx_urb, kingsun->usbdev,              usb_rcvintpipe(kingsun->usbdev, kingsun->ep_in),              kingsun->in_buf, kingsun->max_rx,              kingsun_rcv_irq, kingsun, 1);    kingsun->rx_urb->status = 0;    err = usb_submit_urb(kingsun->rx_urb, GFP_KERNEL);    if (err) {        err("kingsun-sir: first urb-submit failed: %d", err);        goto close_irlap;    }    netif_start_queue(netdev);    /* Situation at this point:       - all work buffers allocated       - urbs allocated and ready to fill       - max rx packet known (in max_rx)       - unwrap state machine initialized, in state outside of any frame       - receive request in progress       - IrLAP layer started, about to hand over packets to send     */    return 0; close_irlap:    irlap_close(kingsun->irlap); free_mem:    if (kingsun->tx_urb) {        usb_free_urb(kingsun->tx_urb);        kingsun->tx_urb = NULL;    }    if (kingsun->rx_urb) {        usb_free_urb(kingsun->rx_urb);        kingsun->rx_urb = NULL;    }    if (kingsun->rx_buff.skb) {        kfree_skb(kingsun->rx_buff.skb);        kingsun->rx_buff.skb = NULL;        kingsun->rx_buff.head = NULL;    }    return err;}

static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags){	struct sk_buff		*skb;	struct skb_data		*entry;	int			retval = 0;	unsigned long		lockflags;	size_t			size = dev->rx_urb_size;	if ((skb = alloc_skb (size + NET_IP_ALIGN, flags)) == NULL) {		netif_dbg(dev, rx_err, dev->net, "no rx skb/n");		usbnet_defer_kevent (dev, EVENT_RX_MEMORY);		usb_free_urb (urb);		return -ENOMEM;	}	skb_reserve (skb, NET_IP_ALIGN);	entry = (struct skb_data *) skb->cb;	entry->urb = urb;	entry->dev = dev;	entry->length = 0;	usb_fill_bulk_urb (urb, dev->udev, dev->in,		skb->data, size, rx_complete, skb);	spin_lock_irqsave (&dev->rxq.lock, lockflags);	if (netif_running (dev->net) &&	    netif_device_present (dev->net) &&	    !test_bit (EVENT_RX_HALT, &dev->flags) &&	    !test_bit (EVENT_DEV_ASLEEP, &dev->flags)) {		switch (retval = usb_submit_urb (urb, GFP_ATOMIC)) {		case -EPIPE:			usbnet_defer_kevent (dev, EVENT_RX_HALT);			break;		case -ENOMEM:			usbnet_defer_kevent (dev, EVENT_RX_MEMORY);			break;		case -ENODEV:			netif_dbg(dev, ifdown, dev->net, "device gone/n");			netif_device_detach (dev->net);			break;		case -EHOSTUNREACH:			retval = -ENOLINK;			break;		default:			netif_dbg(dev, rx_err, dev->net,				  "rx submit, %d/n", retval);			tasklet_schedule (&dev->bh);			break;		case 0:			__usbnet_queue_skb(&dev->rxq, skb, rx_start);		}	} else {		netif_dbg(dev, ifdown, dev->net, "rx: stopped/n");		retval = -ENOLINK;	}	spin_unlock_irqrestore (&dev->rxq.lock, lockflags);	if (retval) {		dev_kfree_skb_any (skb);		usb_free_urb (urb);	}	return retval;}

static int usbnet_start_xmit (struct sk_buff *skb, struct net_device *net){	struct usbnet		*dev = (struct usbnet *) net->priv;	int			length = skb->len;	int			retval = NET_XMIT_SUCCESS;	struct urb		*urb = 0;	struct skb_data		*entry;	struct driver_info	*info = dev->driver_info;	unsigned long		flags;#ifdef	CONFIG_USB_NET1080	struct nc_header	*header = 0;	struct nc_trailer	*trailer = 0;#endif	/* CONFIG_USB_NET1080 */	flags = in_interrupt () ? GFP_ATOMIC : GFP_NOIO; /* might be used for nfs */	// some devices want funky USB-level framing, for	// win32 driver (usually) and/or hardware quirks	if (info->tx_fixup) {		skb = info->tx_fixup (dev, skb, flags);		if (!skb) {			dbg ("can't tx_fixup skb");			goto drop;		}	}	if (!(urb = usb_alloc_urb (0))) {		dbg ("no urb");		goto drop;	}	entry = (struct skb_data *) skb->cb;	entry->urb = urb;	entry->dev = dev;	entry->state = tx_start;	entry->length = length;	// FIXME: reorganize a bit, so that fixup() fills out NetChip	// framing too. (Packet ID update needs the spinlock...)#ifdef	CONFIG_USB_NET1080	if (info->flags & FLAG_FRAMING_NC) {		header = (struct nc_header *) skb_push (skb, sizeof *header);		header->hdr_len = cpu_to_le16 (sizeof (*header));		header->packet_len = cpu_to_le16 (length);		if (!((skb->len + sizeof *trailer) & 0x01))			*skb_put (skb, 1) = PAD_BYTE;		trailer = (struct nc_trailer *) skb_put (skb, sizeof *trailer);	} else#endif	/* CONFIG_USB_NET1080 */	/* don't assume the hardware handles USB_ZERO_PACKET */	if ((length % EP_SIZE (dev)) == 0)		skb->len++;	FILL_BULK_URB (urb, dev->udev,			usb_sndbulkpipe (dev->udev, info->out),			skb->data, skb->len, tx_complete, skb);	urb->transfer_flags |= USB_ASYNC_UNLINK;#ifdef	REALLY_QUEUE	urb->transfer_flags |= USB_QUEUE_BULK;#endif	// FIXME urb->timeout = ... jiffies ... ;	spin_lock_irqsave (&dev->txq.lock, flags);#ifdef	CONFIG_USB_NET1080	if (info->flags & FLAG_FRAMING_NC) {		header->packet_id = cpu_to_le16 (dev->packet_id++);		put_unaligned (header->packet_id, &trailer->packet_id);#if 0		devdbg (dev, "frame >tx h %d p %d id %d",			header->hdr_len, header->packet_len,			header->packet_id);#endif	}#endif	/* CONFIG_USB_NET1080 */	netif_stop_queue (net);	if ((retval = usb_submit_urb (urb)) != 0) {		netif_start_queue (net);		dbg ("%s tx: submit urb err %d", net->name, retval);	} else {		net->trans_start = jiffies;		__skb_queue_tail (&dev->txq, skb);		if (dev->txq.qlen < TX_QLEN)			netif_start_queue (net);	}	spin_unlock_irqrestore (&dev->txq.lock, flags);	if (retval) {		devdbg (dev, "drop, code %d", retval);drop:		retval = NET_XMIT_DROP;		dev->stats.tx_dropped++;		if (skb)			dev_kfree_skb_any (skb);		usb_free_urb (urb);#ifdef	VERBOSE	} else {//.........这里部分代码省略.........

/****************************************************************************** * *  submit_urbs * *****************************************************************************/static int submit_urbs(struct camera_data *cam){	struct urb *urb;	int fx, err, i, j;	for(i=0; i<NUM_SBUF; ++i) {		if (cam->sbuf[i].data)			continue;		cam->sbuf[i].data =		    kmalloc(FRAMES_PER_DESC * FRAME_SIZE_PER_DESC, GFP_KERNEL);		if (!cam->sbuf[i].data) {			while (--i >= 0) {				kfree(cam->sbuf[i].data);				cam->sbuf[i].data = NULL;			}			return -ENOMEM;		}	}	/* We double buffer the Isoc lists, and also know the polling	 * interval is every frame (1 == (1 << (bInterval -1))).	 */	for(i=0; i<NUM_SBUF; ++i) {		if(cam->sbuf[i].urb) {			continue;		}		urb = usb_alloc_urb(FRAMES_PER_DESC, GFP_KERNEL);		if (!urb) {			ERR("%s: usb_alloc_urb error!/n", __func__);			for (j = 0; j < i; j++)				usb_free_urb(cam->sbuf[j].urb);			return -ENOMEM;		}		cam->sbuf[i].urb = urb;		urb->dev = cam->dev;		urb->context = cam;		urb->pipe = usb_rcvisocpipe(cam->dev, 1 /*ISOC endpoint*/);		urb->transfer_flags = URB_ISO_ASAP;		urb->transfer_buffer = cam->sbuf[i].data;		urb->complete = cpia2_usb_complete;		urb->number_of_packets = FRAMES_PER_DESC;		urb->interval = 1;		urb->transfer_buffer_length =			FRAME_SIZE_PER_DESC * FRAMES_PER_DESC;		for (fx = 0; fx < FRAMES_PER_DESC; fx++) {			urb->iso_frame_desc[fx].offset =				FRAME_SIZE_PER_DESC * fx;			urb->iso_frame_desc[fx].length = FRAME_SIZE_PER_DESC;		}	}	/* Queue the ISO urbs, and resubmit in the completion handler */	for(i=0; i<NUM_SBUF; ++i) {		err = usb_submit_urb(cam->sbuf[i].urb, GFP_KERNEL);		if (err) {			ERR("usb_submit_urb[%d]() = %d/n", i, err);			return err;		}	}	return 0;}