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

static ssize_t usblp_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos){	struct usblp *usblp = file->private_data;	char *writebuf;	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 ((writebuf = kmalloc(USBLP_BUF_SIZE, GFP_KERNEL)) == NULL)			goto raise_buf;		if ((writeurb = usb_alloc_urb(0, GFP_KERNEL)) == NULL)			goto raise_urb;		usb_fill_bulk_urb(writeurb, usblp->dev,			usb_sndbulkpipe(usblp->dev,			  usblp->protocol[usblp->current_protocol].epwrite->bEndpointAddress),			writebuf, transfer_length, usblp_bulk_write, usblp);		usb_anchor_urb(writeurb, &usblp->urbs);		if (copy_from_user(writebuf,				   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:	kfree(writebuf);raise_buf:raise_wait:collect_error:		/* Out of raise sequence */	mutex_unlock(&usblp->wmut);raise_biglock:	return writecount ? writecount : rv;//.........这里部分代码省略.........

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;	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:		/*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;	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;	spin_lock(&dev->rx_lock);	list_add_tail(&list_elem->list, &dev->rx_list);	spin_unlock(&dev->rx_lock);	rd_cb_time = cpu_clock(smp_processor_id());	wake_up(&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);			dev_err(dev->devicep, "%s: Error re-submitting Int URB %d/n",					__func__, status);		}		DBG_NOTI("[CHKRA:%d]>", iface_num);	}}

int diag_bridge_read(char *data, int size){	struct urb		*urb = NULL;	unsigned int		pipe;	struct diag_bridge	*dev = __dev;	int			ret;	pr_debug("reading %d bytes", size);	if (!dev || !dev->ifc) {		pr_err("device is disconnected");		return -ENODEV;	}	if (!dev->ops) {		pr_err("bridge is not open");		return -ENODEV;	}	if (!size) {		dev_err(&dev->ifc->dev, "invalid size:%d/n", size);		return -EINVAL;	}	/* if there was a previous unrecoverable error, just quit */	if (dev->err)		return -ENODEV;	kref_get(&dev->kref);	urb = usb_alloc_urb(0, GFP_KERNEL);	if (!urb) {		dev_err(&dev->ifc->dev, "unable to allocate urb/n");		ret = -ENOMEM;		goto error;	}	ret = usb_autopm_get_interface(dev->ifc);	if (ret < 0 && ret != -EAGAIN && ret != -EACCES) {		pr_err_ratelimited("read: autopm_get failed:%d", ret);		goto free_error;	}	pipe = usb_rcvbulkpipe(dev->udev, dev->in_epAddr);	usb_fill_bulk_urb(urb, dev->udev, pipe, data, size,				diag_bridge_read_cb, dev);	usb_anchor_urb(urb, &dev->submitted);	dev->pending_reads++;	ret = usb_submit_urb(urb, GFP_KERNEL);	if (ret) {		pr_err_ratelimited("submitting urb failed err:%d", ret);		dev->pending_reads--;		usb_unanchor_urb(urb);	}	usb_autopm_put_interface(dev->ifc);free_error:	usb_free_urb(urb);error:	if (ret) /* otherwise this is done in the completion handler */		kref_put(&dev->kref, diag_bridge_delete);	return ret;}

static netdev_tx_t gs_can_start_xmit(struct sk_buff *skb, struct net_device *netdev){	struct gs_can *dev = netdev_priv(netdev);	struct net_device_stats *stats = &dev->netdev->stats;	struct urb *urb;	struct gs_host_frame *hf;	struct can_frame *cf;	int rc;	unsigned int idx;	struct gs_tx_context *txc;	if (can_dropped_invalid_skb(netdev, skb))		return NETDEV_TX_OK;	/* find an empty context to keep track of transmission */	txc = gs_alloc_tx_context(dev);	if (!txc)		return NETDEV_TX_BUSY;	/* create a URB, and a buffer for it */	urb = usb_alloc_urb(0, GFP_ATOMIC);	if (!urb) {		netdev_err(netdev, "No memory left for URB/n");		goto nomem_urb;	}	hf = usb_alloc_coherent(dev->udev, sizeof(*hf), GFP_ATOMIC,				&urb->transfer_dma);	if (!hf) {		netdev_err(netdev, "No memory left for USB buffer/n");		goto nomem_hf;	}	idx = txc->echo_id;	if (idx >= GS_MAX_TX_URBS) {		netdev_err(netdev, "Invalid tx context %d/n", idx);		goto badidx;	}	hf->echo_id = idx;	hf->channel = dev->channel;	cf = (struct can_frame *)skb->data;	hf->can_id = cf->can_id;	hf->can_dlc = cf->can_dlc;	memcpy(hf->data, cf->data, cf->can_dlc);	usb_fill_bulk_urb(urb, dev->udev,			  usb_sndbulkpipe(dev->udev, GSUSB_ENDPOINT_OUT),			  hf,			  sizeof(*hf),			  gs_usb_xmit_callback,			  txc);	urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	usb_anchor_urb(urb, &dev->tx_submitted);	can_put_echo_skb(skb, netdev, idx);	atomic_inc(&dev->active_tx_urbs);	rc = usb_submit_urb(urb, GFP_ATOMIC);	if (unlikely(rc)) {			/* usb send failed */		atomic_dec(&dev->active_tx_urbs);		can_free_echo_skb(netdev, idx);		gs_free_tx_context(txc);		usb_unanchor_urb(urb);		usb_free_coherent(dev->udev,				  sizeof(*hf),				  hf,				  urb->transfer_dma);		if (rc == -ENODEV) {			netif_device_detach(netdev);		} else {			netdev_err(netdev, "usb_submit failed (err=%d)/n", rc);			stats->tx_dropped++;		}	} else {		/* Slow down tx path */		if (atomic_read(&dev->active_tx_urbs) >= GS_MAX_TX_URBS)			netif_stop_queue(netdev);	}	/* let usb core take care of this urb */	usb_free_urb(urb);	return NETDEV_TX_OK; badidx:	usb_free_coherent(dev->udev,			  sizeof(*hf),			  hf,			  urb->transfer_dma); nomem_hf://.........这里部分代码省略.........

//.........这里部分代码省略.........            RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,                     "Can't allocate skb for bulk IN!/n");            goto resubmit;        }        _rtl_install_trx_info(rtlusb, skb, rtlusb->in_ep);        /* Make sure the payload data is 4 byte aligned. */        skb_reserve(skb, padding);        /* reserve some space for mac80211's radiotap */        skb_reserve(skb, __RADIO_TAP_SIZE_RSV);        memcpy(skb_put(skb, size), _urb->transfer_buffer, size);        skb_queue_tail(&rtlusb->rx_queue, skb);        tasklet_schedule(&rtlusb->rx_work_tasklet);        goto resubmit;    }    switch (_urb->status) {    /* disconnect */    case -ENOENT:    case -ECONNRESET:    case -ENODEV:    case -ESHUTDOWN:        goto free;    default:        break;    }resubmit:    usb_anchor_urb(_urb, &rtlusb->rx_submitted);    err = usb_submit_urb(_urb, GFP_ATOMIC);    if (unlikely(err)) {        usb_unanchor_urb(_urb);        goto free;    }    return;free:    /* On some architectures, usb_free_coherent must not be called from     * hardirq context. Queue urb to cleanup list.     */    usb_anchor_urb(_urb, &rtlusb->rx_cleanup_urbs);}#undef __RADIO_TAP_SIZE_RSVstatic void _rtl_usb_cleanup_rx(struct ieee80211_hw *hw){    struct rtl_priv *rtlpriv = rtl_priv(hw);    struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));    struct urb *urb;    usb_kill_anchored_urbs(&rtlusb->rx_submitted);    tasklet_kill(&rtlusb->rx_work_tasklet);    cancel_work_sync(&rtlpriv->works.lps_change_work);    flush_workqueue(rtlpriv->works.rtl_wq);    destroy_workqueue(rtlpriv->works.rtl_wq);    skb_queue_purge(&rtlusb->rx_queue);

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)			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);		urb->dev      = data->udev;		urb->pipe     = pipe;		urb->context  = skb;		urb->complete = btusb_isoc_tx_complete;		urb->interval = data->isoc_tx_ep->bInterval;		urb->transfer_flags  = URB_ISO_ASAP;		urb->transfer_buffer = skb->data;		urb->transfer_buffer_length = skb->len;		__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);//.........这里部分代码省略.........

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 = cpu_to_le32(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;	}	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_free_coherent(dev->udev, size, buf, urb->transfer_dma);		usb_free_urb(urb);		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);			stats->tx_dropped++;		}//.........这里部分代码省略.........

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;		if (count == 0)		goto exit;	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) {				dev->errors = 0;				retval = (retval == -EPIPE) ? retval : -EIO;	}	spin_unlock_irq(&dev->err_lock);	if (retval < 0)		goto error;		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;	}		mutex_lock(&dev->io_mutex);	if (!dev->interface) {				mutex_unlock(&dev->io_mutex);		retval = -ENODEV;		goto error;	}		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);		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;	}	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);		usb_free_urb(urb);	}	up(&dev->limit_sem);exit:	return retval;}

int diag_bridge_write(int id, char *data, int size){	struct urb		*urb = NULL;	unsigned int		pipe;	struct diag_bridge	*dev;	int			ret;	if (id < 0 || id >= MAX_DIAG_BRIDGE_DEVS) {		pr_err("Invalid device ID");		return -ENODEV;	}	pr_debug("writing %d bytes", size);	dev = __dev[id];	if (!dev) {		pr_err("device is disconnected");		return -ENODEV;	}	mutex_lock(&dev->ifc_mutex);	if (!dev->ifc) {		ret = -ENODEV;		goto error;	}	if (!dev->ops) {		pr_err("bridge is not open");		ret = -ENODEV;		goto error;	}	if (!size) {		dev_err(&dev->ifc->dev, "invalid size:%d/n", size);		ret = -EINVAL;		goto error;	}	/* if there was a previous unrecoverable error, just quit */	if (dev->err) {		ret = -ENODEV;		goto error;	}	kref_get(&dev->kref);	urb = usb_alloc_urb(0, GFP_KERNEL);	if (!urb) {		dev_err(&dev->ifc->dev, "unable to allocate urb/n");		ret = -ENOMEM;		goto put_error;	}	ret = usb_autopm_get_interface(dev->ifc);	if (ret < 0 && ret != -EAGAIN && ret != -EACCES) {		pr_err_ratelimited("write: autopm_get failed:%d", ret);		goto free_error;	}	pipe = usb_sndbulkpipe(dev->udev, dev->out_epAddr);	usb_fill_bulk_urb(urb, dev->udev, pipe, data, size,				diag_bridge_write_cb, dev);	urb->transfer_flags |= URB_ZERO_PACKET;	usb_anchor_urb(urb, &dev->submitted);	dev->pending_writes++;	ret = usb_submit_urb(urb, GFP_KERNEL);	if (ret) {		pr_err_ratelimited("submitting urb failed err:%d", ret);		dev->pending_writes--;		usb_unanchor_urb(urb);		usb_autopm_put_interface(dev->ifc);		goto free_error;	}free_error:	usb_free_urb(urb);put_error:	if (ret) /* otherwise this is done in the completion handler */		kref_put(&dev->kref, diag_bridge_delete);error:	mutex_unlock(&dev->ifc_mutex);	return ret;}

/* * 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 = 50; /* 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);			usb_free_urb(urb);			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 ar9170_usb_exec_cmd(struct ar9170 *ar, enum ar9170_cmd cmd,			       unsigned int plen, void *payload,			       unsigned int outlen, void *out){	struct ar9170_usb *aru = (void *) ar;	struct urb *urb = NULL;	unsigned long flags;	int err = -ENOMEM;	if (unlikely(!IS_ACCEPTING_CMD(ar)))		return -EPERM;	if (WARN_ON(plen > AR9170_MAX_CMD_LEN - 4))		return -EINVAL;	urb = usb_alloc_urb(0, GFP_ATOMIC);	if (unlikely(!urb))		goto err_free;	ar->cmdbuf[0] = cpu_to_le32(plen);	ar->cmdbuf[0] |= cpu_to_le32(cmd << 8);	/* writing multiple regs fills this buffer already */	if (plen && payload != (u8 *)(&ar->cmdbuf[1]))		memcpy(&ar->cmdbuf[1], payload, plen);	spin_lock_irqsave(&aru->common.cmdlock, flags);	aru->readbuf = (u8 *)out;	aru->readlen = outlen;	spin_unlock_irqrestore(&aru->common.cmdlock, flags);	usb_fill_int_urb(urb, aru->udev,			 usb_sndintpipe(aru->udev, AR9170_EP_CMD),			 aru->common.cmdbuf, plen + 4,			 ar9170_usb_tx_urb_complete, NULL, 1);	usb_anchor_urb(urb, &aru->tx_submitted);	err = usb_submit_urb(urb, GFP_ATOMIC);	if (unlikely(err)) {		usb_unanchor_urb(urb);		usb_free_urb(urb);		goto err_unbuf;	}	usb_free_urb(urb);	err = wait_for_completion_timeout(&aru->cmd_wait, HZ);	if (err == 0) {		err = -ETIMEDOUT;		goto err_unbuf;	}	if (aru->readlen != outlen) {		err = -EMSGSIZE;		goto err_unbuf;	}	return 0;err_unbuf:	/* Maybe the device was removed in the second we were waiting? */	if (IS_STARTED(ar)) {		dev_err(&aru->udev->dev, "no command feedback "					 "received (%d)./n", err);		/* provide some maybe useful debug information */		print_hex_dump_bytes("ar9170 cmd: ", DUMP_PREFIX_NONE,				     aru->common.cmdbuf, plen + 4);		dump_stack();	}	/* invalidate to avoid completing the next prematurely */	spin_lock_irqsave(&aru->common.cmdlock, flags);	aru->readbuf = NULL;	aru->readlen = 0;	spin_unlock_irqrestore(&aru->common.cmdlock, flags);err_free:	return err;}

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

static void notification_available_cb(struct urb *urb){	int				status;	struct usb_cdc_notification	*ctrl;	struct ctrl_bridge		*dev = urb->context;	struct bridge			*brdg = dev->brdg;	unsigned int			ctrl_bits;	unsigned char			*data;	switch (urb->status) {	case 0:	/*if non zero lenght of data received while unlink*/	case -ENOENT:		/*success*/		break;	case -ESHUTDOWN:	case -ECONNRESET:	case -EPROTO:		 /* unplug */		 return;	case -EPIPE:		dev_err(&dev->intf->dev,			"%s: stall on int endpoint/n", __func__);		/* TBD : halt to be cleared in work */	case -EOVERFLOW:	default:		pr_debug_ratelimited("%s: non zero urb status = %d/n",					__func__, urb->status);		goto resubmit_int_urb;	}	if (!urb->actual_length)		return;	ctrl = (struct usb_cdc_notification *)urb->transfer_buffer;	data = (unsigned char *)(ctrl + 1);	switch (ctrl->bNotificationType) {	case USB_CDC_NOTIFY_RESPONSE_AVAILABLE:		dev->resp_avail++;		//pr_info("GOT notification /n");		usb_mark_last_busy(dev->udev);		if (urb->status == -ENOENT)			pr_info("URB status is ENOENT");                queue_work(dev->wq, &dev->get_encap_work);		return;	case USB_CDC_NOTIFY_NETWORK_CONNECTION:		dev_dbg(&dev->intf->dev, "%s network/n", ctrl->wValue ?					"connected to" : "disconnected from");		break;	case USB_CDC_NOTIFY_SERIAL_STATE:		dev->notify_ser_state++;		ctrl_bits = get_unaligned_le16(data);		dev_dbg(&dev->intf->dev, "serial state: %d/n", ctrl_bits);		dev->cbits_tohost = ctrl_bits;		if (brdg && brdg->ops.send_cbits)			brdg->ops.send_cbits(brdg->ctx, ctrl_bits);		break;	default:		dev_err(&dev->intf->dev, "%s: unknown notification %d received:"			"index %d len %d data0 %d data1 %d",			__func__, ctrl->bNotificationType, ctrl->wIndex,			ctrl->wLength, data[0], data[1]);	}resubmit_int_urb:	usb_anchor_urb(urb, &dev->tx_submitted);	status = usb_submit_urb(urb, GFP_ATOMIC);	if (status) {		dev_err(&dev->intf->dev, "%s: Error re-submitting Int URB %d/n",		__func__, status);		usb_unanchor_urb(urb);	}}

/* Write */static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,					const unsigned char *buf, int count){	struct sierra_port_private *portdata;	struct sierra_intf_private *intfdata;	struct usb_serial *serial = port->serial;	unsigned long flags;	unsigned char *buffer;	struct urb *urb;	size_t writesize = min((size_t)count, (size_t)MAX_TRANSFER);	int retval = 0;	/* verify that we actually have some data to write */	if (count == 0)		return 0;	portdata = usb_get_serial_port_data(port);	intfdata = usb_get_serial_data(serial);	dev_dbg(&port->dev, "%s: write (%zd bytes)/n", __func__, writesize);	spin_lock_irqsave(&portdata->lock, flags);	dev_dbg(&port->dev, "%s - outstanding_urbs: %d/n", __func__,		portdata->outstanding_urbs);	if (portdata->outstanding_urbs > portdata->num_out_urbs) {		spin_unlock_irqrestore(&portdata->lock, flags);		dev_dbg(&port->dev, "%s - write limit hit/n", __func__);		return 0;	}	portdata->outstanding_urbs++;	dev_dbg(&port->dev, "%s - 1, outstanding_urbs: %d/n", __func__,		portdata->outstanding_urbs);	spin_unlock_irqrestore(&portdata->lock, flags);	retval = usb_autopm_get_interface_async(serial->interface);	if (retval < 0) {		spin_lock_irqsave(&portdata->lock, flags);		portdata->outstanding_urbs--;		spin_unlock_irqrestore(&portdata->lock, flags);		goto error_simple;	}	buffer = kmalloc(writesize, GFP_ATOMIC);	if (!buffer) {		retval = -ENOMEM;		goto error_no_buffer;	}	urb = usb_alloc_urb(0, GFP_ATOMIC);	if (!urb) {		retval = -ENOMEM;		goto error_no_urb;	}	memcpy(buffer, buf, writesize);	usb_serial_debug_data(&port->dev, __func__, writesize, buffer);	usb_fill_bulk_urb(urb, serial->dev,			  usb_sndbulkpipe(serial->dev,					  port->bulk_out_endpointAddress),			  buffer, writesize, sierra_outdat_callback, port);	/* Handle the need to send a zero length packet */	urb->transfer_flags |= URB_ZERO_PACKET;	spin_lock_irqsave(&intfdata->susp_lock, flags);	if (intfdata->suspended) {		usb_anchor_urb(urb, &portdata->delayed);		spin_unlock_irqrestore(&intfdata->susp_lock, flags);		goto skip_power;	} else {		usb_anchor_urb(urb, &portdata->active);	}	/* send it down the pipe */	retval = usb_submit_urb(urb, GFP_ATOMIC);	if (retval) {		usb_unanchor_urb(urb);		spin_unlock_irqrestore(&intfdata->susp_lock, flags);		dev_err(&port->dev, "%s - usb_submit_urb(write bulk) failed "			"with status = %d/n", __func__, retval);		goto error;	} else {		intfdata->in_flight++;		spin_unlock_irqrestore(&intfdata->susp_lock, flags);	}skip_power:	/* 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 writesize;error:	usb_free_urb(urb);error_no_urb:	kfree(buffer);error_no_buffer:	spin_lock_irqsave(&portdata->lock, flags);//.........这里部分代码省略.........

//.........这里部分代码省略.........	len = skb->len;	tx_hdr = (struct rtw_ieee80211_hdr *)(skb->data);	fc = le16_to_cpu(tx_hdr->frame_ctl);	bmcst = IS_MCAST(tx_hdr->addr1);	if ((fc & RTW_IEEE80211_FCTL_FTYPE) != RTW_IEEE80211_FTYPE_MGMT)		goto _exit;#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)) // http://www.mail-archive.com/[email
C++ usb_autopm_get_interface函数代码示例
C++ usb_altnum_to_altsetting函数代码示例