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

static int bpa10x_send_frame(struct sk_buff *skb){	struct hci_dev *hdev = (struct hci_dev *) skb->dev;	struct bpa10x_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;	urb = usb_alloc_urb(0, GFP_ATOMIC);	if (!urb)		return -ENOMEM;	/* Prepend skb with frame type */	*skb_push(skb, 1) = bt_cb(skb)->pkt_type;	switch (bt_cb(skb)->pkt_type) {	case HCI_COMMAND_PKT:		dr = kmalloc(sizeof(*dr), GFP_ATOMIC);		if (!dr) {			usb_free_urb(urb);			return -ENOMEM;		}		dr->bRequestType = USB_TYPE_VENDOR;		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, bpa10x_tx_complete, skb);		hdev->stat.cmd_tx++;		break;	case HCI_ACLDATA_PKT:		pipe = usb_sndbulkpipe(data->udev, 0x02);		usb_fill_bulk_urb(urb, data->udev, pipe,				skb->data, skb->len, bpa10x_tx_complete, skb);		hdev->stat.acl_tx++;		break;	case HCI_SCODATA_PKT:		pipe = usb_sndbulkpipe(data->udev, 0x02);		usb_fill_bulk_urb(urb, data->udev, pipe,				skb->data, skb->len, bpa10x_tx_complete, skb);		hdev->stat.sco_tx++;		break;	default:		usb_free_urb(urb);		return -EILSEQ;	}	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);		usb_unanchor_urb(urb);	}	usb_free_urb(urb);	return 0;}

static int btusb_send_frame(struct sk_buff *skb){	struct hci_dev *hdev = (struct hci_dev *) skb->dev;	struct btusb_data *data = hci_get_drvdata(hdev);	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)			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) {		if (err != -EPERM && err != -ENODEV)			BT_ERR("%s urb %p submission failed (%d)",						hdev->name, urb, -err);//.........这里部分代码省略.........

/* * callback for bulk IN urb */static void ems_usb_read_bulk_callback(struct urb *urb){	struct ems_usb *dev = urb->context;	struct net_device *netdev;	int retval;	netdev = dev->netdev;	if (!netif_device_present(netdev))		return;	switch (urb->status) {	case 0: /* success */		break;	case -ENOENT:		return;	default:		netdev_info(netdev, "Rx URB aborted (%d)/n", urb->status);		goto resubmit_urb;	}	if (urb->actual_length > CPC_HEADER_SIZE) {		struct ems_cpc_msg *msg;		u8 *ibuf = urb->transfer_buffer;		u8 msg_count, again, start;		msg_count = ibuf[0] & ~0x80;		again = ibuf[0] & 0x80;		start = CPC_HEADER_SIZE;		while (msg_count) {			msg = (struct ems_cpc_msg *)&ibuf[start];			switch (msg->type) {			case CPC_MSG_TYPE_CAN_STATE:				/* Process CAN state changes */				ems_usb_rx_err(dev, msg);				break;			case CPC_MSG_TYPE_CAN_FRAME:			case CPC_MSG_TYPE_EXT_CAN_FRAME:			case CPC_MSG_TYPE_RTR_FRAME:			case CPC_MSG_TYPE_EXT_RTR_FRAME:				ems_usb_rx_can_msg(dev, msg);				break;			case CPC_MSG_TYPE_CAN_FRAME_ERROR:				/* Process errorframe */				ems_usb_rx_err(dev, msg);				break;			case CPC_MSG_TYPE_OVERRUN:				/* Message lost while receiving */				ems_usb_rx_err(dev, msg);				break;			}			start += CPC_MSG_HEADER_LEN + msg->length;			msg_count--;			if (start > urb->transfer_buffer_length) {				netdev_err(netdev, "format error/n");				break;			}		}	}resubmit_urb:	usb_fill_bulk_urb(urb, dev->udev, usb_rcvbulkpipe(dev->udev, 2),			  urb->transfer_buffer, RX_BUFFER_SIZE,			  ems_usb_read_bulk_callback, dev);	retval = usb_submit_urb(urb, GFP_ATOMIC);	if (retval == -ENODEV)		netif_device_detach(netdev);	else if (retval)		netdev_err(netdev,			   "failed resubmitting read bulk urb: %d/n", retval);}

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);//.........这里部分代码省略.........

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

/* * The ES1 USB Bridge device contains 4 endpoints * 1 Control - usual USB stuff + AP -> SVC messages * 1 Interrupt IN - SVC -> AP messages * 1 Bulk IN - CPort data in * 1 Bulk OUT - CPort data out */static int ap_probe(struct usb_interface *interface,		    const struct usb_device_id *id){	struct es1_ap_dev *es1;	struct greybus_host_device *hd;	struct usb_device *udev;	struct usb_host_interface *iface_desc;	struct usb_endpoint_descriptor *endpoint;	int bulk_in = 0;	int bulk_out = 0;	int retval = -ENOMEM;	int i;	int num_cports;	udev = usb_get_dev(interface_to_usbdev(interface));	num_cports = apb1_get_cport_count(udev);	if (num_cports < 0) {		usb_put_dev(udev);		dev_err(&udev->dev, "Cannot retrieve CPort count: %d/n",			num_cports);		return num_cports;	}	hd = greybus_create_hd(&es1_driver, &udev->dev, ES1_GBUF_MSG_SIZE_MAX,			       num_cports);	if (IS_ERR(hd)) {		usb_put_dev(udev);		return PTR_ERR(hd);	}	es1 = hd_to_es1(hd);	es1->hd = hd;	es1->usb_intf = interface;	es1->usb_dev = udev;	spin_lock_init(&es1->cport_out_urb_lock);	usb_set_intfdata(interface, es1);	es1->cport_to_ep = kcalloc(hd->num_cports, sizeof(*es1->cport_to_ep),				   GFP_KERNEL);	if (!es1->cport_to_ep) {		retval = -ENOMEM;		goto error;	}	/* find all 3 of our endpoints */	iface_desc = interface->cur_altsetting;	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {		endpoint = &iface_desc->endpoint[i].desc;		if (usb_endpoint_is_bulk_in(endpoint)) {			es1->cport_in[bulk_in++].endpoint =				endpoint->bEndpointAddress;		} else if (usb_endpoint_is_bulk_out(endpoint)) {			es1->cport_out[bulk_out++].endpoint =				endpoint->bEndpointAddress;		} else {			dev_err(&udev->dev,				"Unknown endpoint type found, address %x/n",				endpoint->bEndpointAddress);		}	}	if ((bulk_in == 0) ||	    (bulk_out == 0)) {		dev_err(&udev->dev, "Not enough endpoints found in device, aborting!/n");		goto error;	}	/* Allocate buffers for our cport in messages and start them up */	for (bulk_in = 0; bulk_in < NUM_BULKS; bulk_in++) {		struct es1_cport_in *cport_in = &es1->cport_in[bulk_in];		for (i = 0; i < NUM_CPORT_IN_URB; ++i) {			struct urb *urb;			u8 *buffer;			urb = usb_alloc_urb(0, GFP_KERNEL);			if (!urb)				goto error;			buffer = kmalloc(ES1_GBUF_MSG_SIZE_MAX, GFP_KERNEL);			if (!buffer)				goto error;			usb_fill_bulk_urb(urb, udev,					  usb_rcvbulkpipe(udev,							  cport_in->endpoint),					  buffer, ES1_GBUF_MSG_SIZE_MAX,					  cport_in_callback, hd);			cport_in->urb[i] = urb;			cport_in->buffer[i] = buffer;			retval = usb_submit_urb(urb, GFP_KERNEL);			if (retval)				goto error;		}//.........这里部分代码省略.........

static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags){	struct sk_buff		*skb;	struct skb_data		*entry;	usb_complete_t		complete_fn;	int			retval = 0;	unsigned long		lockflags;	size_t			size = dev->rx_urb_size;	skb = __netdev_alloc_skb_ip_align(dev->net, size, 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;	}	entry = (struct skb_data *) skb->cb;	entry->urb = urb;	entry->dev = dev;	entry->length = 0;	if (dev->driver_info->rx_complete)		complete_fn = dev->driver_info->rx_complete;	else		complete_fn = rx_complete;	usb_fill_bulk_urb (urb, dev->udev, dev->in,		skb->data, size, complete_fn, 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);			queue_work(usbnet_wq, &dev->bh_w);			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;}

u32 usb_read_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *rmem){		_irqL irqL;	int err, pipe;	u32 tmpaddr=0;        int alignment=0;	u32 ret = _SUCCESS;	PURB purb = NULL;		struct recv_buf	*precvbuf = (struct recv_buf *)rmem;	struct intf_priv	*pintfpriv = pintfhdl->pintfpriv;	struct dvobj_priv	*pdvobj = (struct dvobj_priv *)pintfpriv->intf_dev;	_adapter			*adapter = (_adapter *)pdvobj->padapter;	struct recv_priv	*precvpriv = &adapter->recvpriv;	struct usb_device	*pusbd = pdvobj->pusbdev;	_func_enter_;		if(adapter->bDriverStopped || adapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)	{		RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port:( padapter->bDriverStopped ||padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!/n"));		return _FAIL;	}#ifdef CONFIG_PREALLOC_RECV_SKB	if((precvbuf->reuse == _FALSE) || (precvbuf->pskb == NULL))	{		if (NULL != (precvbuf->pskb = skb_dequeue(&precvpriv->free_recv_skb_queue)))		{			precvbuf->reuse = _TRUE;		}	}#endif		if(precvbuf !=NULL)	{			init_recvbuf(adapter, precvbuf);				//re-assign for linux based on skb		if((precvbuf->reuse == _FALSE) || (precvbuf->pskb == NULL))		{			//precvbuf->pskb = alloc_skb(MAX_RECVBUF_SZ, GFP_ATOMIC);//don't use this after v2.6.25#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)) // http://www.mail-archive.com/[email
C++ usb_fill_control_urb函数代码示例
C++ usb_ep_queue函数代码示例