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

//.........这里部分代码省略.........		if ( altsetting->desc.bNumEndpoints != MTS_EP_TOTAL ) {		MTS_WARNING( "expecting %d got %d endpoints! Bailing out./n",			     (int)MTS_EP_TOTAL, (int)altsetting->desc.bNumEndpoints );		return -ENODEV;	}	for( i = 0; i < altsetting->desc.bNumEndpoints; i++ ) {		if ((altsetting->endpoint[i].desc.bmAttributes &		     USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK) {			MTS_WARNING( "can only deal with bulk endpoints; endpoint %d is not bulk./n",			     (int)altsetting->endpoint[i].desc.bEndpointAddress );		} else {			if (altsetting->endpoint[i].desc.bEndpointAddress &			    USB_DIR_IN)				*ep_in_current++					= altsetting->endpoint[i].desc.bEndpointAddress &					USB_ENDPOINT_NUMBER_MASK;			else {				if ( ep_out != -1 ) {					MTS_WARNING( "can only deal with one output endpoints. Bailing out." );					return -ENODEV;				}				ep_out = altsetting->endpoint[i].desc.bEndpointAddress &					USB_ENDPOINT_NUMBER_MASK;			}		}	}	if ( ep_out == -1 ) {		MTS_WARNING( "couldn't find an output bulk endpoint. Bailing out./n" );		return -ENODEV;	}	new_desc = kzalloc(sizeof(struct mts_desc), GFP_KERNEL);	if (!new_desc)		goto out;	new_desc->urb = usb_alloc_urb(0, GFP_KERNEL);	if (!new_desc->urb)		goto out_kfree;	new_desc->context.scsi_status = kmalloc(1, GFP_KERNEL);	if (!new_desc->context.scsi_status)		goto out_free_urb;	new_desc->usb_dev = dev;	new_desc->usb_intf = intf;		new_desc->ep_out = ep_out;	new_desc->ep_response = ep_in_set[0];	new_desc->ep_image = ep_in_set[1];	if ( new_desc->ep_out != MTS_EP_OUT )		MTS_WARNING( "will this work? Command EP is not usually %d/n",			     (int)new_desc->ep_out );	if ( new_desc->ep_response != MTS_EP_RESPONSE )		MTS_WARNING( "will this work? Response EP is not usually %d/n",			     (int)new_desc->ep_response );	if ( new_desc->ep_image != MTS_EP_IMAGE )		MTS_WARNING( "will this work? Image data EP is not usually %d/n",			     (int)new_desc->ep_image );	new_desc->host = scsi_host_alloc(&mts_scsi_host_template,			sizeof(new_desc));	if (!new_desc->host)		goto out_kfree2;	new_desc->host->hostdata[0] = (unsigned long)new_desc;	if (scsi_add_host(new_desc->host, &dev->dev)) {		err_retval = -EIO;		goto out_host_put;	}	scsi_scan_host(new_desc->host);	usb_set_intfdata(intf, new_desc);	return 0; out_host_put:	scsi_host_put(new_desc->host); out_kfree2:	kfree(new_desc->context.scsi_status); out_free_urb:	usb_free_urb(new_desc->urb); out_kfree:	kfree(new_desc); out:	return err_retval;}

//.........这里部分代码省略.........		goto error_0;	}		ret = usb_set_interface(ucpia->dev, ucpia->iface, 3);	if (ret < 0) {		printk(KERN_ERR "cpia_usb_open: usb_set_interface error (ret = %d)/n", ret);		retval = -EBUSY;		goto error_1;	}	ucpia->buffers[0]->status = FRAME_EMPTY;	ucpia->buffers[0]->length = 0;	ucpia->buffers[1]->status = FRAME_EMPTY;	ucpia->buffers[1]->length = 0;	ucpia->buffers[2]->status = FRAME_EMPTY;	ucpia->buffers[2]->length = 0;	ucpia->curbuff = ucpia->buffers[0];	ucpia->workbuff = ucpia->buffers[1];	/* We double buffer the Iso lists, and also know the polling	 * interval is every frame (1 == (1 << (bInterval -1))).	 */	urb = usb_alloc_urb(FRAMES_PER_DESC, GFP_KERNEL);	if (!urb) {		printk(KERN_ERR "cpia_init_isoc: usb_alloc_urb 0/n");		retval = -ENOMEM;		goto error_1;	}	ucpia->sbuf[0].urb = urb;	urb->dev = ucpia->dev;	urb->context = ucpia;	urb->pipe = usb_rcvisocpipe(ucpia->dev, 1);	urb->transfer_flags = URB_ISO_ASAP;	urb->transfer_buffer = ucpia->sbuf[0].data;	urb->complete = cpia_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;	}	urb = usb_alloc_urb(FRAMES_PER_DESC, GFP_KERNEL);	if (!urb) {		printk(KERN_ERR "cpia_init_isoc: usb_alloc_urb 1/n");		retval = -ENOMEM;		goto error_urb0;	}	ucpia->sbuf[1].urb = urb;	urb->dev = ucpia->dev;	urb->context = ucpia;	urb->pipe = usb_rcvisocpipe(ucpia->dev, 1);	urb->transfer_flags = URB_ISO_ASAP;	urb->transfer_buffer = ucpia->sbuf[1].data;	urb->complete = cpia_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 */	err = usb_submit_urb(ucpia->sbuf[0].urb, GFP_KERNEL);	if (err) {		printk(KERN_ERR "cpia_init_isoc: usb_submit_urb 0 ret %d/n",			err);		goto error_urb1;	}	err = usb_submit_urb(ucpia->sbuf[1].urb, GFP_KERNEL);	if (err) {		printk(KERN_ERR "cpia_init_isoc: usb_submit_urb 1 ret %d/n",			err);		goto error_urb1;	}	ucpia->streaming = 1;	ucpia->open = 1;	return 0;error_urb1:		/* free urb 1 */	usb_free_urb(ucpia->sbuf[1].urb);	ucpia->sbuf[1].urb = NULL;error_urb0:		/* free urb 0 */	usb_free_urb(ucpia->sbuf[0].urb);	ucpia->sbuf[0].urb = NULL;error_1:	kfree (ucpia->sbuf[1].data);	ucpia->sbuf[1].data = NULL;error_0:	kfree (ucpia->sbuf[0].data);	ucpia->sbuf[0].data = NULL;		return retval;}

/****************************************************************************** * *  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;}

static int bcm5974_probe(struct usb_interface *iface,			 const struct usb_device_id *id){	struct usb_device *udev = interface_to_usbdev(iface);	const struct bcm5974_config *cfg;	struct bcm5974 *dev;	struct input_dev *input_dev;	int error = -ENOMEM;	/* find the product index */	cfg = bcm5974_get_config(udev);	/* allocate memory for our device state and initialize it */	dev = kzalloc(sizeof(struct bcm5974), GFP_KERNEL);	input_dev = input_allocate_device();	if (!dev || !input_dev) {		err("bcm5974: out of memory");		goto err_free_devs;	}	dev->udev = udev;	dev->intf = iface;	dev->input = input_dev;	dev->cfg = *cfg;	mutex_init(&dev->pm_mutex);	/* setup urbs */	dev->bt_urb = usb_alloc_urb(0, GFP_KERNEL);	if (!dev->bt_urb)		goto err_free_devs;	dev->tp_urb = usb_alloc_urb(0, GFP_KERNEL);	if (!dev->tp_urb)		goto err_free_bt_urb;	dev->bt_data = usb_alloc_coherent(dev->udev,					  dev->cfg.bt_datalen, GFP_KERNEL,					  &dev->bt_urb->transfer_dma);	if (!dev->bt_data)		goto err_free_urb;	dev->tp_data = usb_alloc_coherent(dev->udev,					  dev->cfg.tp_datalen, GFP_KERNEL,					  &dev->tp_urb->transfer_dma);	if (!dev->tp_data)		goto err_free_bt_buffer;	usb_fill_int_urb(dev->bt_urb, udev,			 usb_rcvintpipe(udev, cfg->bt_ep),			 dev->bt_data, dev->cfg.bt_datalen,			 bcm5974_irq_button, dev, 1);	usb_fill_int_urb(dev->tp_urb, udev,			 usb_rcvintpipe(udev, cfg->tp_ep),			 dev->tp_data, dev->cfg.tp_datalen,			 bcm5974_irq_trackpad, dev, 1);	/* create bcm5974 device */	usb_make_path(udev, dev->phys, sizeof(dev->phys));	strlcat(dev->phys, "/input0", sizeof(dev->phys));	input_dev->name = "bcm5974";	input_dev->phys = dev->phys;	usb_to_input_id(dev->udev, &input_dev->id);	/* report driver capabilities via the version field */	input_dev->id.version = cfg->caps;	input_dev->dev.parent = &iface->dev;	input_set_drvdata(input_dev, dev);	input_dev->open = bcm5974_open;	input_dev->close = bcm5974_close;	setup_events_to_report(input_dev, cfg);	error = input_register_device(dev->input);	if (error)		goto err_free_buffer;	/* save our data pointer in this interface device */	usb_set_intfdata(iface, dev);	return 0;err_free_buffer:	usb_free_coherent(dev->udev, dev->cfg.tp_datalen,		dev->tp_data, dev->tp_urb->transfer_dma);err_free_bt_buffer:	usb_free_coherent(dev->udev, dev->cfg.bt_datalen,		dev->bt_data, dev->bt_urb->transfer_dma);err_free_urb:	usb_free_urb(dev->tp_urb);err_free_bt_urb:	usb_free_urb(dev->bt_urb);err_free_devs:	usb_set_intfdata(iface, NULL);	input_free_device(input_dev);	kfree(dev);	return error;}

void free_urb(struct urb *urb){   usb_kill_urb(urb);   kfree(urb->transfer_buffer);   usb_free_urb(urb);}

static int usb_serial_multi_urb_write(struct tty_struct *tty,	struct usb_serial_port *port, const unsigned char *buf, int count){	unsigned long flags;	struct urb *urb;	unsigned char *buffer;	int status;	int towrite;	int bwrite = 0;	dbg("%s - port %d", __func__, port->number);	if (count == 0)		dbg("%s - write request of 0 bytes", __func__);	while (count > 0) {		towrite = (count > port->bulk_out_size) ?			port->bulk_out_size : count;		spin_lock_irqsave(&port->lock, flags);		if (port->urbs_in_flight >		    port->serial->type->max_in_flight_urbs) {			spin_unlock_irqrestore(&port->lock, flags);			dbg("%s - write limit hit", __func__);			return bwrite;		}		port->tx_bytes_flight += towrite;		port->urbs_in_flight++;		spin_unlock_irqrestore(&port->lock, flags);		buffer = kmalloc(towrite, GFP_ATOMIC);		if (!buffer) {			dev_err(&port->dev,			"%s ran out of kernel memory for urb .../n", __func__);			goto error_no_buffer;		}		urb = usb_alloc_urb(0, GFP_ATOMIC);		if (!urb) {			dev_err(&port->dev, "%s - no more free urbs/n",				__func__);			goto error_no_urb;		}		/* Copy data */		memcpy(buffer, buf + bwrite, towrite);		usb_serial_debug_data(debug, &port->dev, __func__,				      towrite, buffer);		/* fill the buffer and send it */		usb_fill_bulk_urb(urb, port->serial->dev,			usb_sndbulkpipe(port->serial->dev,					port->bulk_out_endpointAddress),			buffer, towrite,			usb_serial_generic_write_bulk_callback, port);		status = usb_submit_urb(urb, GFP_ATOMIC);		if (status) {			dev_err(&port->dev,				"%s - failed submitting write urb, error %d/n",				__func__, status);			goto error;		}		/* This urb is the responsibility of the host driver now */		usb_free_urb(urb);		dbg("%s write: %d", __func__, towrite);		count -= towrite;		bwrite += towrite;	}	return bwrite;error:	usb_free_urb(urb);error_no_urb:	kfree(buffer);error_no_buffer:	spin_lock_irqsave(&port->lock, flags);	port->urbs_in_flight--;	port->tx_bytes_flight -= towrite;	spin_unlock_irqrestore(&port->lock, flags);	return bwrite;}

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 = 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 (!(file->f_flags & O_NONBLOCK)) {		if (down_interruptible(&dev->limit_sem)) {			retval = -ERESTARTSYS;			goto exit;		}	} else {		if (down_trylock(&dev->limit_sem)) {			retval = -EAGAIN;			goto exit;		}	}	spin_lock_irq(&dev->err_lock);	retval = dev->errors;	if (retval < 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_alloc_coherent(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", __func__,		    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_free_coherent(dev->udev, writesize, buf, urb->transfer_dma);//.........这里部分代码省略.........

static int usbsvn_write(struct net_device *dev, struct sipc4_tx_data *tx_data){	struct usbsvn *svn = netdev_priv(dev);	struct sk_buff *skb;	struct usbsvn_devdata *devdata;	struct urb *req;	int dev_id;	int err;	if (!svn->usbdev)		return -1;	/*hold on active mode until xmit*/	usb_mark_last_busy(svn->usbdev);	wake_lock_pm(svn);	err = usbsvn_initiated_resume(dev);	if (err < 0) {		printk(KERN_ERR "%s: usbsvn_initated_resume fail/n", __func__);		goto exit;	}	skb = tx_data->skb;	dev_id = SIPC4_FORMAT(tx_data->res);	devdata = &svn->devdata[dev_id];	req = usb_alloc_urb(0, GFP_ATOMIC);	if (!req) {		printk(KERN_ERR "%s: can't get urb/n", __func__);		err = -ENOMEM;		goto exit;	}	usb_fill_bulk_urb(req, svn->usbdev, devdata->tx_pipe,			skb->data, skb->len, tx_complete, skb);	if (tx_debug) {		char *buf = skb->data;		int i;		printk(KERN_ERR			"[TX] dev_id: %d, size: %d/n", dev_id, skb->len);		for (i = 0; i < skb->len; i++)			printk(KERN_ERR "%x ", *(buf + i));		if (skb->len)			printk(KERN_ERR "/n");	}	req->transfer_flags = URB_ZERO_PACKET;	err = usb_submit_urb(req, GFP_ATOMIC);	if (err < 0) {		printk(KERN_ERR "%s:usb_submit_urb fail/n", __func__);		usb_free_urb(req);		goto exit;	}	usb_mark_last_busy(svn->usbdev);	if (dev_id == SIPC4_RAW)		wake_lock_timeout_data(svn);exit:	return err;}

static ssize_t usblp_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos){	struct usblp *usblp = file->private_data;	struct urb *writeurb;	int rv;	int transfer_length;	ssize_t writecount = 0;	if (mutex_lock_interruptible(&usblp->wmut)) {		rv = -EINTR;		goto raise_biglock;	}	if ((rv = usblp_wwait(usblp, !!(file->f_flags & O_NONBLOCK))) < 0)		goto raise_wait;	while (writecount < count) {		/*		 * Step 1: Submit next block.		 */		if ((transfer_length = count - writecount) > USBLP_BUF_SIZE)			transfer_length = USBLP_BUF_SIZE;		rv = -ENOMEM;		if ((writeurb = usblp_new_writeurb(usblp, transfer_length)) == NULL)			goto raise_urb;		usb_anchor_urb(writeurb, &usblp->urbs);		if (copy_from_user(writeurb->transfer_buffer,				   buffer + writecount, transfer_length)) {			rv = -EFAULT;			goto raise_badaddr;		}		spin_lock_irq(&usblp->lock);		usblp->wcomplete = 0;		spin_unlock_irq(&usblp->lock);		if ((rv = usb_submit_urb(writeurb, GFP_KERNEL)) < 0) {			usblp->wstatus = 0;			spin_lock_irq(&usblp->lock);			usblp->no_paper = 0;			usblp->wcomplete = 1;			wake_up(&usblp->wwait);			spin_unlock_irq(&usblp->lock);			if (rv != -ENOMEM)				rv = -EIO;			goto raise_submit;		}		/*		 * Step 2: Wait for transfer to end, collect results.		 */		rv = usblp_wwait(usblp, !!(file->f_flags&O_NONBLOCK));		if (rv < 0) {			if (rv == -EAGAIN) {				/* Presume that it's going to complete well. */				writecount += transfer_length;			}			if (rv == -ENOSPC) {				spin_lock_irq(&usblp->lock);				usblp->no_paper = 1;	/* Mark for poll(2) */				spin_unlock_irq(&usblp->lock);				writecount += transfer_length;			}			/* Leave URB dangling, to be cleaned on close. */			goto collect_error;		}		if (usblp->wstatus < 0) {			rv = -EIO;			goto collect_error;		}		/*		 * This is critical: it must be our URB, not other writer's.		 * The wmut exists mainly to cover us here.		 */		writecount += usblp->wstatus;	}	mutex_unlock(&usblp->wmut);	return writecount;raise_submit:raise_badaddr:	usb_unanchor_urb(writeurb);	usb_free_urb(writeurb);raise_urb:raise_wait:collect_error:		/* Out of raise sequence */	mutex_unlock(&usblp->wmut);raise_biglock:	return writecount ? writecount : rv;}

static int usb_mouse_probe(struct usb_interface *intf, const struct usb_device_id *id){	struct usb_device *dev = interface_to_usbdev(intf);	struct usb_host_interface *interface;	struct usb_endpoint_descriptor *endpoint;	struct usb_mouse *mouse;	struct input_dev *input_dev;	int pipe, maxp;	int error = -ENOMEM;	interface = intf->cur_altsetting;	if (interface->desc.bNumEndpoints != 1)		return -ENODEV;	endpoint = &interface->endpoint[0].desc;	if (!usb_endpoint_is_int_in(endpoint))		return -ENODEV;	pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);	maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));	mouse = kzalloc(sizeof(struct usb_mouse), GFP_KERNEL);	input_dev = input_allocate_device();	if (!mouse || !input_dev)		goto fail1;	mouse->data = usb_alloc_coherent(dev, 8, GFP_ATOMIC, &mouse->data_dma);	if (!mouse->data)		goto fail1;	mouse->irq = usb_alloc_urb(0, GFP_KERNEL);	if (!mouse->irq)		goto fail2;	mouse->usbdev = dev;	mouse->dev = input_dev;	if (dev->manufacturer)		strlcpy(mouse->name, dev->manufacturer, sizeof(mouse->name));	if (dev->product) {		if (dev->manufacturer)			strlcat(mouse->name, " ", sizeof(mouse->name));		strlcat(mouse->name, dev->product, sizeof(mouse->name));	}	if (!strlen(mouse->name))		snprintf(mouse->name, sizeof(mouse->name),			 "USB HIDBP Mouse %04x:%04x",			 le16_to_cpu(dev->descriptor.idVendor),			 le16_to_cpu(dev->descriptor.idProduct));	usb_make_path(dev, mouse->phys, sizeof(mouse->phys));	strlcat(mouse->phys, "/input0", sizeof(mouse->phys));	input_dev->name = mouse->name;	input_dev->phys = mouse->phys;	usb_to_input_id(dev, &input_dev->id);	input_dev->dev.parent = &intf->dev;	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);	input_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |		BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);	input_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);	input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_SIDE) |		BIT_MASK(BTN_EXTRA);	input_dev->relbit[0] |= BIT_MASK(REL_WHEEL);	input_set_drvdata(input_dev, mouse);	input_dev->open = usb_mouse_open;	input_dev->close = usb_mouse_close;	usb_fill_int_urb(mouse->irq, dev, pipe, mouse->data,			 (maxp > 8 ? 8 : maxp),			 usb_mouse_irq, mouse, endpoint->bInterval);	mouse->irq->transfer_dma = mouse->data_dma;	mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	error = input_register_device(mouse->dev);	if (error)		goto fail3;	usb_set_intfdata(intf, mouse);	return 0;fail3:		usb_free_urb(mouse->irq);fail2:		usb_free_coherent(dev, 8, mouse->data, mouse->data_dma);fail1:		input_free_device(input_dev);	kfree(mouse);	return error;}

//.........这里部分代码省略.........		goto nomem;	}	dev->udev = udev;	dev->int_pipe = usb_rcvintpipe(udev,		int_in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);	dev->intf = ifc;	init_usb_anchor(&dev->tx_submitted);	init_usb_anchor(&dev->tx_deferred);	/*use max pkt size from ep desc*/	ep = &dev->intf->cur_altsetting->endpoint[0].desc;	dev->inturb = usb_alloc_urb(0, GFP_KERNEL);	if (!dev->inturb) {		dev_err(&udev->dev, "%s: error allocating int urb/n", __func__);		retval = -ENOMEM;		goto pdev_del;	}	wMaxPacketSize = le16_to_cpu(ep->wMaxPacketSize);	dev->intbuf = kmalloc(wMaxPacketSize, GFP_KERNEL);	if (!dev->intbuf) {		dev_err(&udev->dev, "%s: error allocating int buffer/n",			__func__);		retval = -ENOMEM;		goto free_inturb;	}	interval =		(udev->speed == USB_SPEED_HIGH) ? HS_INTERVAL : FS_LS_INTERVAL;	usb_fill_int_urb(dev->inturb, udev, dev->int_pipe,				dev->intbuf, wMaxPacketSize,				notification_available_cb, dev, interval);	dev->readurb = usb_alloc_urb(0, GFP_KERNEL);	if (!dev->readurb) {		dev_err(&udev->dev, "%s: error allocating read urb/n",			__func__);		retval = -ENOMEM;		goto free_intbuf;	}	dev->readbuf = kmalloc(DEFAULT_READ_URB_LENGTH, GFP_KERNEL);	if (!dev->readbuf) {		dev_err(&udev->dev, "%s: error allocating read buffer/n",			__func__);		retval = -ENOMEM;		goto free_rurb;	}	dev->in_ctlreq = kmalloc(sizeof(*dev->in_ctlreq), GFP_KERNEL);	if (!dev->in_ctlreq) {		dev_err(&udev->dev,			"%s:error allocating setup packet buffer/n",			__func__);		retval = -ENOMEM;		goto free_rbuf;	}	dev->in_ctlreq->bRequestType =			(USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE);	dev->in_ctlreq->bRequest  = USB_CDC_GET_ENCAPSULATED_RESPONSE;	dev->in_ctlreq->wValue = 0;	dev->in_ctlreq->wIndex =		dev->intf->cur_altsetting->desc.bInterfaceNumber;	dev->in_ctlreq->wLength = cpu_to_le16(DEFAULT_READ_URB_LENGTH);	__dev[id] = dev;	platform_device_add(dev->pdev);	ch_id++;#ifdef CONFIG_MDM_HSIC_PM	/* if the bridge is open or not, resume to consume mdm request	 * because this link is not dead, it's alive	 */	ctrl_bridge_start_read(dev);#endif	return retval;free_rbuf:	kfree(dev->readbuf);free_rurb:	usb_free_urb(dev->readurb);free_intbuf:	kfree(dev->intbuf);free_inturb:	usb_free_urb(dev->inturb);pdev_del:	platform_device_del(dev->pdev);nomem:	kfree(dev);	return retval;}

//.........这里部分代码省略.........	dvb->dmxdev.capabilities = 0;	ret =  dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);	if (ret < 0) {		printk("tm6000: dvb_dmxdev_init failed (errno = %d)/n", ret);		goto dvb_dmx_err;	}	return 0;dvb_dmx_err:	dvb_dmx_release(&dvb->demux);frontend_err:	if (dvb->frontend) {		dvb_frontend_detach(dvb->frontend);		dvb_unregister_frontend(dvb->frontend);	}adapter_err:	dvb_unregister_adapter(&dvb->adapter);err:	return ret;}void unregister_dvb(struct tm6000_core *dev){	struct tm6000_dvb *dvb = dev->dvb;	if (dvb->bulk_urb != NULL) {		struct urb *bulk_urb = dvb->bulk_urb;		kfree(bulk_urb->transfer_buffer);		bulk_urb->transfer_buffer = NULL;		usb_unlink_urb(bulk_urb);		usb_free_urb(bulk_urb);	}/*	mutex_lock(&tm6000_driver.open_close_mutex); */	if (dvb->frontend) {		dvb_frontend_detach(dvb->frontend);		dvb_unregister_frontend(dvb->frontend);	}	dvb_dmxdev_release(&dvb->dmxdev);	dvb_dmx_release(&dvb->demux);	dvb_unregister_adapter(&dvb->adapter);	mutex_destroy(&dvb->mutex);/*	mutex_unlock(&tm6000_driver.open_close_mutex); */}static int dvb_init(struct tm6000_core *dev){	struct tm6000_dvb *dvb;	int rc;	if (!dev)		return 0;	if (!dev->caps.has_dvb)		return 0;	dvb = kzalloc(sizeof(struct tm6000_dvb), GFP_KERNEL);	if (!dvb) {		printk(KERN_INFO "Cannot allocate memory/n");		return -ENOMEM;	}

static bool vnt_alloc_bufs(struct vnt_private *priv){	struct vnt_usb_send_context *tx_context;	struct vnt_rcb *rcb;	int ii;	for (ii = 0; ii < priv->num_tx_context; ii++) {		tx_context = kmalloc(sizeof(struct vnt_usb_send_context),								GFP_KERNEL);		if (tx_context == NULL)			goto free_tx;		priv->tx_context[ii] = tx_context;		tx_context->priv = priv;		tx_context->pkt_no = ii;		/* allocate URBs */		tx_context->urb = usb_alloc_urb(0, GFP_ATOMIC);		if (!tx_context->urb) {			dev_err(&priv->usb->dev, "alloc tx urb failed/n");			goto free_tx;		}		tx_context->in_use = false;	}	for (ii = 0; ii < priv->num_rcb; ii++) {		priv->rcb[ii] = kzalloc(sizeof(struct vnt_rcb), GFP_KERNEL);		if (!priv->rcb[ii]) {			dev_err(&priv->usb->dev,					"failed to allocate rcb no %d/n", ii);			goto free_rx_tx;		}		rcb = priv->rcb[ii];		rcb->priv = priv;		/* allocate URBs */		rcb->urb = usb_alloc_urb(0, GFP_ATOMIC);		if (rcb->urb == NULL) {			dev_err(&priv->usb->dev, "Failed to alloc rx urb/n");			goto free_rx_tx;		}		rcb->skb = dev_alloc_skb(priv->rx_buf_sz);		if (rcb->skb == NULL)			goto free_rx_tx;		rcb->in_use = false;		/* submit rx urb */		if (vnt_submit_rx_urb(priv, rcb))			goto free_rx_tx;	}	priv->interrupt_urb = usb_alloc_urb(0, GFP_ATOMIC);	if (priv->interrupt_urb == NULL) {		dev_err(&priv->usb->dev, "Failed to alloc int urb/n");		goto free_rx_tx;	}	priv->int_buf.data_buf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);	if (priv->int_buf.data_buf == NULL) {		usb_free_urb(priv->interrupt_urb);		goto free_rx_tx;	}	return true;free_rx_tx:	vnt_free_rx_bufs(priv);free_tx:	vnt_free_tx_bufs(priv);	return false;}

int data_bridge_write(unsigned int id, struct sk_buff *skb){	int			result;	int			size = skb->len;	int			pending;	struct urb		*txurb;	struct timestamp_info	*info = (struct timestamp_info *)skb->cb;	struct data_bridge	*dev = __dev[id];	struct bridge		*brdg;	if (!dev || !dev->brdg || dev->err || !usb_get_intfdata(dev->intf))		return -ENODEV;	brdg = dev->brdg;	if (!brdg)		return -ENODEV;	dev_dbg(&dev->intf->dev, "%s: write (%d bytes)/n", __func__, skb->len);	result = usb_autopm_get_interface(dev->intf);	if (result < 0) {		dev_dbg(&dev->intf->dev, "%s: resume failure/n", __func__);		goto pm_error;	}	txurb = usb_alloc_urb(0, GFP_KERNEL);	if (!txurb) {		dev_err(&dev->intf->dev, "%s: error allocating read urb/n",			__func__);		result = -ENOMEM;		goto error;	}	/* store dev pointer in skb */	info->dev = dev;	info->tx_queued = get_timestamp();	usb_fill_bulk_urb(txurb, dev->udev, dev->bulk_out,			skb->data, skb->len, data_bridge_write_cb, skb);	txurb->transfer_flags |= URB_ZERO_PACKET;	if (test_bit(SUSPENDED, &dev->flags)) {		usb_anchor_urb(txurb, &dev->delayed);		goto free_urb;	}	pending = atomic_inc_return(&dev->pending_txurbs);	usb_anchor_urb(txurb, &dev->tx_active);	if (atomic_read(&dev->pending_txurbs) % tx_urb_mult)		txurb->transfer_flags |= URB_NO_INTERRUPT;	result = usb_submit_urb(txurb, GFP_KERNEL);	if (result < 0) {		usb_unanchor_urb(txurb);		atomic_dec(&dev->pending_txurbs);		dev_err(&dev->intf->dev, "%s: submit URB error %d/n",			__func__, result);		goto free_urb;	}	dev->to_modem++;	dev_dbg(&dev->intf->dev, "%s: pending_txurbs: %u/n", __func__, pending);	/* flow control: last urb submitted but return -EBUSY */	if (fctrl_support && pending > fctrl_en_thld) {		set_bit(TX_THROTTLED, &brdg->flags);		dev->tx_throttled_cnt++;		pr_debug_ratelimited("%s: enable flow ctrl pend txurbs:%u/n",					__func__, pending);		return -EBUSY;	}	return size;free_urb:	usb_free_urb(txurb);error:	dev->txurb_drp_cnt++;	usb_autopm_put_interface(dev->intf);pm_error:	return result;}

/* * Start interface */static int ems_usb_start(struct ems_usb *dev){	struct net_device *netdev = dev->netdev;	int err, i;	dev->intr_in_buffer[0] = 0;	dev->free_slots = 15; /* initial size */	for (i = 0; i < MAX_RX_URBS; i++) {		struct urb *urb = NULL;		u8 *buf = NULL;		/* create a URB, and a buffer for it */		urb = usb_alloc_urb(0, GFP_KERNEL);		if (!urb) {			netdev_err(netdev, "No memory left for URBs/n");			err = -ENOMEM;			break;		}		buf = usb_alloc_coherent(dev->udev, RX_BUFFER_SIZE, GFP_KERNEL,					 &urb->transfer_dma);		if (!buf) {			netdev_err(netdev, "No memory left for USB buffer/n");			usb_free_urb(urb);			err = -ENOMEM;			break;		}		usb_fill_bulk_urb(urb, dev->udev, usb_rcvbulkpipe(dev->udev, 2),				  buf, RX_BUFFER_SIZE,				  ems_usb_read_bulk_callback, dev);		urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;		usb_anchor_urb(urb, &dev->rx_submitted);		err = usb_submit_urb(urb, GFP_KERNEL);		if (err) {			usb_unanchor_urb(urb);			usb_free_coherent(dev->udev, RX_BUFFER_SIZE, buf,					  urb->transfer_dma);			break;		}		/* Drop reference, USB core will take care of freeing it */		usb_free_urb(urb);	}	/* Did we submit any URBs */	if (i == 0) {		netdev_warn(netdev, "couldn't setup read URBs/n");		return err;	}	/* Warn if we've couldn't transmit all the URBs */	if (i < MAX_RX_URBS)		netdev_warn(netdev, "rx performance may be slow/n");	/* Setup and start interrupt URB */	usb_fill_int_urb(dev->intr_urb, dev->udev,			 usb_rcvintpipe(dev->udev, 1),			 dev->intr_in_buffer,			 INTR_IN_BUFFER_SIZE,			 ems_usb_read_interrupt_callback, dev, 1);	err = usb_submit_urb(dev->intr_urb, GFP_KERNEL);	if (err) {		netdev_warn(netdev, "intr URB submit failed: %d/n", err);		return err;	}	/* CPC-USB will transfer received message to host */	err = ems_usb_control_cmd(dev, CONTR_CAN_MESSAGE | CONTR_CONT_ON);	if (err)		goto failed;	/* CPC-USB will transfer CAN state changes to host */	err = ems_usb_control_cmd(dev, CONTR_CAN_STATE | CONTR_CONT_ON);	if (err)		goto failed;	/* CPC-USB will transfer bus errors to host */	err = ems_usb_control_cmd(dev, CONTR_BUS_ERROR | CONTR_CONT_ON);	if (err)		goto failed;	err = ems_usb_write_mode(dev, SJA1000_MOD_NORMAL);	if (err)		goto failed;	dev->can.state = CAN_STATE_ERROR_ACTIVE;	return 0;failed:	netdev_warn(netdev, "couldn't submit control: %d/n", err);//.........这里部分代码省略.........

static int btusb_send_frame(struct sk_buff *skb){	struct hci_dev *hdev = (struct hci_dev *) skb->dev;	struct btusb_data *data = hdev->driver_data;	struct usb_ctrlrequest *dr;	struct urb *urb;	unsigned int pipe;	int err;	BT_DBG("%s", hdev->name);	if (!test_bit(HCI_RUNNING, &hdev->flags))		return -EBUSY;	switch (bt_cb(skb)->pkt_type) {	case HCI_COMMAND_PKT:		urb = usb_alloc_urb(0, GFP_ATOMIC);		if (!urb)			return -ENOMEM;		dr = kmalloc(sizeof(*dr), GFP_ATOMIC);		if (!dr) {			usb_free_urb(urb);			return -ENOMEM;		}		dr->bRequestType = data->cmdreq_type;		dr->bRequest     = 0;		dr->wIndex       = 0;		dr->wValue       = 0;		dr->wLength      = __cpu_to_le16(skb->len);		pipe = usb_sndctrlpipe(data->udev, 0x00);		usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,				skb->data, skb->len, btusb_tx_complete, skb);		hdev->stat.cmd_tx++;		break;	case HCI_ACLDATA_PKT:		if (!data->bulk_tx_ep || (hdev->conn_hash.acl_num < 1 &&						hdev->conn_hash.le_num < 1))			return -ENODEV;		urb = usb_alloc_urb(0, GFP_ATOMIC);		if (!urb)			return -ENOMEM;		pipe = usb_sndbulkpipe(data->udev,					data->bulk_tx_ep->bEndpointAddress);		usb_fill_bulk_urb(urb, data->udev, pipe,				skb->data, skb->len, btusb_tx_complete, skb);		hdev->stat.acl_tx++;		break;	case HCI_SCODATA_PKT:		if (!data->isoc_tx_ep || hdev->conn_hash.sco_num < 1)			return -ENODEV;		urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_ATOMIC);		if (!urb)			return -ENOMEM;		pipe = usb_sndisocpipe(data->udev,					data->isoc_tx_ep->bEndpointAddress);		usb_fill_int_urb(urb, data->udev, pipe,				skb->data, skb->len, btusb_isoc_tx_complete,				skb, data->isoc_tx_ep->bInterval);		urb->transfer_flags  = URB_ISO_ASAP;		__fill_isoc_descriptor(urb, skb->len,				le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));		hdev->stat.sco_tx++;		goto skip_waking;	default:		return -EILSEQ;	}	err = inc_tx(data);	if (err) {		usb_anchor_urb(urb, &data->deferred);		schedule_work(&data->waker);		err = 0;		goto done;	}skip_waking:	usb_anchor_urb(urb, &data->tx_anchor);	err = usb_submit_urb(urb, GFP_ATOMIC);	if (err < 0) {		BT_ERR("%s urb %p submission failed", hdev->name, urb);		kfree(urb->setup_packet);//.........这里部分代码省略.........

static netdev_tx_t ems_usb_start_xmit(struct sk_buff *skb, struct net_device *netdev){	struct ems_usb *dev = netdev_priv(netdev);	struct ems_tx_urb_context *context = NULL;	struct net_device_stats *stats = &netdev->stats;	struct can_frame *cf = (struct can_frame *)skb->data;	struct ems_cpc_msg *msg;	struct urb *urb;	u8 *buf;	int i, err;	size_t size = CPC_HEADER_SIZE + CPC_MSG_HEADER_LEN			+ sizeof(struct cpc_can_msg);	if (can_dropped_invalid_skb(netdev, skb))		return NETDEV_TX_OK;	/* create a URB, and a buffer for it, and copy the data to the URB */	urb = usb_alloc_urb(0, GFP_ATOMIC);	if (!urb) {		netdev_err(netdev, "No memory left for URBs/n");		goto nomem;	}	buf = usb_alloc_coherent(dev->udev, size, GFP_ATOMIC, &urb->transfer_dma);	if (!buf) {		netdev_err(netdev, "No memory left for USB buffer/n");		usb_free_urb(urb);		goto nomem;	}	msg = (struct ems_cpc_msg *)&buf[CPC_HEADER_SIZE];	msg->msg.can_msg.id = cf->can_id & CAN_ERR_MASK;	msg->msg.can_msg.length = cf->can_dlc;	if (cf->can_id & CAN_RTR_FLAG) {		msg->type = cf->can_id & CAN_EFF_FLAG ?			CPC_CMD_TYPE_EXT_RTR_FRAME : CPC_CMD_TYPE_RTR_FRAME;		msg->length = CPC_CAN_MSG_MIN_SIZE;	} else {		msg->type = cf->can_id & CAN_EFF_FLAG ?			CPC_CMD_TYPE_EXT_CAN_FRAME : CPC_CMD_TYPE_CAN_FRAME;		for (i = 0; i < cf->can_dlc; i++)			msg->msg.can_msg.msg[i] = cf->data[i];		msg->length = CPC_CAN_MSG_MIN_SIZE + cf->can_dlc;	}	/* Respect byte order */	msg->msg.can_msg.id = cpu_to_le32(msg->msg.can_msg.id);	for (i = 0; i < MAX_TX_URBS; i++) {		if (dev->tx_contexts[i].echo_index == MAX_TX_URBS) {			context = &dev->tx_contexts[i];			break;		}	}	/*	 * May never happen! When this happens we'd more URBs in flight as	 * allowed (MAX_TX_URBS).	 */	if (!context) {		usb_unanchor_urb(urb);		usb_free_coherent(dev->udev, size, buf, urb->transfer_dma);		netdev_warn(netdev, "couldn't find free context/n");		return NETDEV_TX_BUSY;	}	context->dev = dev;	context->echo_index = i;	context->dlc = cf->can_dlc;	usb_fill_bulk_urb(urb, dev->udev, usb_sndbulkpipe(dev->udev, 2), buf,			  size, ems_usb_write_bulk_callback, context);	urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	usb_anchor_urb(urb, &dev->tx_submitted);	can_put_echo_skb(skb, netdev, context->echo_index);	atomic_inc(&dev->active_tx_urbs);	err = usb_submit_urb(urb, GFP_ATOMIC);	if (unlikely(err)) {		can_free_echo_skb(netdev, context->echo_index);		usb_unanchor_urb(urb);		usb_free_coherent(dev->udev, size, buf, urb->transfer_dma);		dev_kfree_skb(skb);		atomic_dec(&dev->active_tx_urbs);		if (err == -ENODEV) {			netif_device_detach(netdev);		} else {			netdev_warn(netdev, "failed tx_urb %d/n", err);//.........这里部分代码省略.........

/* * probe function for new CPC-USB devices */static int ems_usb_probe(struct usb_interface *intf,			 const struct usb_device_id *id){	struct net_device *netdev;	struct ems_usb *dev;	int i, err = -ENOMEM;	netdev = alloc_candev(sizeof(struct ems_usb), MAX_TX_URBS);	if (!netdev) {		dev_err(&intf->dev, "ems_usb: Couldn't alloc candev/n");		return -ENOMEM;	}	dev = netdev_priv(netdev);	dev->udev = interface_to_usbdev(intf);	dev->netdev = netdev;	dev->can.state = CAN_STATE_STOPPED;	dev->can.clock.freq = EMS_USB_ARM7_CLOCK;	dev->can.bittiming_const = &ems_usb_bittiming_const;	dev->can.do_set_bittiming = ems_usb_set_bittiming;	dev->can.do_set_mode = ems_usb_set_mode;	dev->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES;	netdev->netdev_ops = &ems_usb_netdev_ops;	netdev->flags |= IFF_ECHO; /* we support local echo */	init_usb_anchor(&dev->rx_submitted);	init_usb_anchor(&dev->tx_submitted);	atomic_set(&dev->active_tx_urbs, 0);	for (i = 0; i < MAX_TX_URBS; i++)		dev->tx_contexts[i].echo_index = MAX_TX_URBS;	dev->intr_urb = usb_alloc_urb(0, GFP_KERNEL);	if (!dev->intr_urb) {		dev_err(&intf->dev, "Couldn't alloc intr URB/n");		goto cleanup_candev;	}	dev->intr_in_buffer = kzalloc(INTR_IN_BUFFER_SIZE, GFP_KERNEL);	if (!dev->intr_in_buffer) {		dev_err(&intf->dev, "Couldn't alloc Intr buffer/n");		goto cleanup_intr_urb;	}	dev->tx_msg_buffer = kzalloc(CPC_HEADER_SIZE +				     sizeof(struct ems_cpc_msg), GFP_KERNEL);	if (!dev->tx_msg_buffer) {		dev_err(&intf->dev, "Couldn't alloc Tx buffer/n");		goto cleanup_intr_in_buffer;	}	usb_set_intfdata(intf, dev);	SET_NETDEV_DEV(netdev, &intf->dev);	init_params_sja1000(&dev->active_params);	err = ems_usb_command_msg(dev, &dev->active_params);	if (err) {		netdev_err(netdev, "couldn't initialize controller: %d/n", err);		goto cleanup_tx_msg_buffer;	}	err = register_candev(netdev);	if (err) {		netdev_err(netdev, "couldn't register CAN device: %d/n", err);		goto cleanup_tx_msg_buffer;	}	return 0;cleanup_tx_msg_buffer:	kfree(dev->tx_msg_buffer);cleanup_intr_in_buffer:	kfree(dev->intr_in_buffer);cleanup_intr_urb:	usb_free_urb(dev->intr_urb);cleanup_candev:	free_candev(netdev);	return err;}

/* * Function ksdazzle_net_open (dev) * *    Network device is taken up. Usually this is done by "ifconfig irda0 up" */static int ksdazzle_net_open(struct net_device *netdev){	struct ksdazzle_cb *kingsun = netdev_priv(netdev);	int err = -ENOMEM;	char hwname[16];	/* At this point, urbs are NULL, and skb is NULL (see ksdazzle_probe) */	kingsun->receiving = 0;	/* Initialize for SIR to copy data directly into skb.  */	kingsun->rx_unwrap_buff.in_frame = FALSE;	kingsun->rx_unwrap_buff.state = OUTSIDE_FRAME;	kingsun->rx_unwrap_buff.truesize = IRDA_SKB_MAX_MTU;	kingsun->rx_unwrap_buff.skb = dev_alloc_skb(IRDA_SKB_MAX_MTU);	if (!kingsun->rx_unwrap_buff.skb)		goto free_mem;	skb_reserve(kingsun->rx_unwrap_buff.skb, 1);	kingsun->rx_unwrap_buff.head = kingsun->rx_unwrap_buff.skb->data;	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;	kingsun->speed_urb = usb_alloc_urb(0, GFP_KERNEL);	if (!kingsun->speed_urb)		goto free_mem;	/* Initialize speed for dongle */	kingsun->new_speed = 9600;	err = ksdazzle_change_speed(kingsun, 9600);	if (err < 0)		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("ksdazzle-sir: irlap_open failed");		goto free_mem;	}	/* Start reception. */	usb_fill_int_urb(kingsun->rx_urb, kingsun->usbdev,			 usb_rcvintpipe(kingsun->usbdev, kingsun->ep_in),			 kingsun->rx_buf, KINGSUN_RCV_MAX, ksdazzle_rcv_irq,			 kingsun, 1);	kingsun->rx_urb->status = 0;	err = usb_submit_urb(kingsun->rx_urb, GFP_KERNEL);	if (err) {		err("ksdazzle-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:	usb_free_urb(kingsun->speed_urb);	kingsun->speed_urb = NULL;	usb_free_urb(kingsun->tx_urb);	kingsun->tx_urb = NULL;	usb_free_urb(kingsun->rx_urb);	kingsun->rx_urb = NULL;	if (kingsun->rx_unwrap_buff.skb) {		kfree_skb(kingsun->rx_unwrap_buff.skb);		kingsun->rx_unwrap_buff.skb = NULL;		kingsun->rx_unwrap_buff.head = NULL;	}	return err;}

//.........这里部分代码省略.........				usb_sndintpipe(usb_dev, epwrite->bEndpointAddress),				NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);		else			usb_fill_bulk_urb(snd->urb, usb_dev,				usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),				NULL, acm->writesize, acm_write_bulk, snd);		snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;		snd->instance = acm;	}	usb_set_intfdata(intf, acm);	i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);	if (i < 0)		goto alloc_fail7;	if (cfd) { /* export the country data */		acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);		if (!acm->country_codes)			goto skip_countries;		acm->country_code_size = cfd->bLength - 4;		memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,							cfd->bLength - 4);		acm->country_rel_date = cfd->iCountryCodeRelDate;		i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);		if (i < 0) {			kfree(acm->country_codes);			acm->country_codes = NULL;			acm->country_code_size = 0;			goto skip_countries;		}		i = device_create_file(&intf->dev,						&dev_attr_iCountryCodeRelDate);		if (i < 0) {			device_remove_file(&intf->dev, &dev_attr_wCountryCodes);			kfree(acm->country_codes);			acm->country_codes = NULL;			acm->country_code_size = 0;			goto skip_countries;		}	}skip_countries:	usb_fill_int_urb(acm->ctrlurb, usb_dev,			 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),			 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,			 /* works around buggy devices */			 epctrl->bInterval ? epctrl->bInterval : 0xff);	acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	acm->ctrlurb->transfer_dma = acm->ctrl_dma;	dev_info(&intf->dev, "ttyACM%d: USB ACM device/n", minor);	acm_set_control(acm, acm->ctrlout);	acm->line.dwDTERate = cpu_to_le32(9600);	acm->line.bDataBits = 8;	acm_set_line(acm, &acm->line);	usb_driver_claim_interface(&acm_driver, data_interface, acm);	usb_set_intfdata(data_interface, acm);	usb_get_intf(control_interface);	tty_dev = tty_port_register_device(&acm->port, acm_tty_driver, minor,			&control_interface->dev);	if (IS_ERR(tty_dev)) {		rv = PTR_ERR(tty_dev);		goto alloc_fail8;	}	return 0;alloc_fail8:	if (acm->country_codes) {		device_remove_file(&acm->control->dev,				&dev_attr_wCountryCodes);		device_remove_file(&acm->control->dev,				&dev_attr_iCountryCodeRelDate);	}	device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);alloc_fail7:	usb_set_intfdata(intf, NULL);	for (i = 0; i < ACM_NW; i++)		usb_free_urb(acm->wb[i].urb);alloc_fail6:	for (i = 0; i < num_rx_buf; i++)		usb_free_urb(acm->read_urbs[i]);	acm_read_buffers_free(acm);	usb_free_urb(acm->ctrlurb);alloc_fail5:	acm_write_buffers_free(acm);alloc_fail4:	usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);alloc_fail2:	acm_release_minor(acm);	kfree(acm);alloc_fail:	return rv;}

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;	skb = alloc_skb(size + NET_IP_ALIGN, flags);	if (!skb) {		netif_dbg(dev, rx_err, dev->net, "no rx skb/n");		usbnet_defer_kevent (dev, EVENT_RX_MEMORY);		usb_free_urb (urb);		return -ENOMEM;	}	if (dev->net->type != ARPHRD_RAWIP)		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:			usb_mark_last_busy(dev->udev);			__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 exemple_probe(struct usb_interface * intf,                         const struct usb_device_id * dev_id){	int i;	int err;	struct usb_host_interface * host_intf;	struct usb_endpoint_descriptor * endpoint_desc;	exemple_usb_device = usb_get_dev(interface_to_usbdev(intf));	host_intf = intf->cur_altsetting;		for (i = 0; i < host_intf->desc.bNumEndpoints; i++) {		endpoint_desc = & (host_intf->endpoint[i].desc);		if (! (endpoint_desc->bEndpointAddress & USB_DIR_IN)) {			switch (endpoint_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {				case USB_ENDPOINT_XFER_INT:					exemple_out_endpoint = endpoint_desc;					break;				default:					break;			}		}	}		if (exemple_out_endpoint == NULL) {		printk(KERN_INFO "%s: no endpoint interrupt out in probe()/n",		       THIS_MODULE->name);		return -ENODEV;	}	if (exemple_out_endpoint->wMaxPacketSize < EXEMPLE_OUT_BUFFER_SIZE) {		printk(KERN_INFO "%s: Interrupt out max packet size too small/n",		       THIS_MODULE->name);		exemple_out_endpoint = NULL;		exemple_usb_device = NULL;		return -EINVAL;	}	exemple_out_urb = usb_alloc_urb(0, GFP_KERNEL);	if (exemple_out_urb == NULL) {		exemple_out_endpoint = NULL;		exemple_usb_device   = NULL;		return -ENOMEM;	}	exemple_out_buffer = kmalloc(EXEMPLE_OUT_BUFFER_SIZE, GFP_KERNEL);	if (exemple_out_buffer == NULL) {		usb_free_urb(exemple_out_urb);		exemple_out_urb = NULL;		exemple_out_endpoint = NULL;		exemple_usb_device = NULL;		return -ENOMEM;	}		err = usb_register_dev(intf, & exemple_usb_class_driver);	if (err != 0) {		kfree(exemple_out_buffer);		exemple_out_buffer = NULL;		usb_free_urb(exemple_out_urb);		exemple_out_urb = NULL;		exemple_out_endpoint = NULL;		exemple_usb_device = NULL;		return err;	}	printk(KERN_INFO "%s: Numero mineur : %d/n",	       THIS_MODULE->name, intf->minor);	return 0;}

//.........这里部分代码省略.........	if (id >= MAX_BRIDGE_DEVICES) {		result = -EINVAL;		goto free_data;	}	dev = __dev[id];	if (!dev) {		result = -ENODEV;		goto free_data;	}	/* wait till, LPA wake complete */	if (pm_dev_wait_lpa_wake() < 0)		return -EAGAIN;	udev = interface_to_usbdev(dev->intf);	dev_dbg(&udev->dev, "%s:[id]:%u: write (%d bytes)/n",		__func__, id, size);	writeurb = usb_alloc_urb(0, GFP_ATOMIC);	if (!writeurb) {		dev_err(&udev->dev, "%s: error allocating read urb/n",			__func__);		result = -ENOMEM;		goto free_data;	}	out_ctlreq = kmalloc(sizeof(*out_ctlreq), GFP_ATOMIC);	if (!out_ctlreq) {		dev_err(&udev->dev,			"%s: error allocating setup packet buffer/n",			__func__);		result = -ENOMEM;		goto free_urb;	}	/* CDC Send Encapsulated Request packet */	out_ctlreq->bRequestType = (USB_DIR_OUT | USB_TYPE_CLASS |				 USB_RECIP_INTERFACE);	if (!data && !size) {		out_ctlreq->bRequest = USB_CDC_REQ_SET_CONTROL_LINE_STATE;		out_ctlreq->wValue = dev->cbits_tomdm;		dev->set_ctrl_line_sts++;	} else {		out_ctlreq->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;		out_ctlreq->wValue = 0;		dev->snd_encap_cmd++;	}	out_ctlreq->wIndex =		dev->intf->cur_altsetting->desc.bInterfaceNumber;	out_ctlreq->wLength = cpu_to_le16(size);	usb_fill_control_urb(writeurb, udev,				 usb_sndctrlpipe(udev, 0),				 (unsigned char *)out_ctlreq,				 (void *)data, size,				 ctrl_write_callback, dev);	result = usb_autopm_get_interface_async(dev->intf);	if (result < 0) {		dev_err(&udev->dev, "%s: unable to resume interface: %d/n",			__func__, result);		/*		  * Revisit: if (result == -EPERM)		  * bridge_suspend(dev->intf, PMSG_SUSPEND);		  */		goto free_ctrlreq;	}	if (test_bit(SUSPENDED, &dev->flags)) {		usb_anchor_urb(writeurb, &dev->tx_deferred);		goto deferred;	}	usb_anchor_urb(writeurb, &dev->tx_submitted);	result = usb_submit_urb(writeurb, GFP_ATOMIC);	if (result < 0) {		dev_err(&udev->dev, "%s: submit URB error %d/n",			__func__, result);		usb_autopm_put_interface_async(dev->intf);		goto unanchor_urb;	}deferred:	return size;unanchor_urb:	usb_unanchor_urb(writeurb);free_ctrlreq:	kfree(out_ctlreq);free_urb:	usb_free_urb(writeurb);free_data:	kfree(data);	return result;}