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

/*	Send raw message in pieces of wMaxPacketSize bytes.*/int line6_send_raw_message(struct usb_line6 *line6, const char *buffer,			   int size){	int i, done = 0;#if DO_DUMP_URB_SEND	line6_write_hexdump(line6, 'S', buffer, size);#endif	for (i = 0; i < size; i += line6->max_packet_size) {		int partial;		const char *frag_buf = buffer + i;		int frag_size = min(line6->max_packet_size, size - i);		int retval;		retval = usb_interrupt_msg(line6->usbdev,					   usb_sndintpipe(line6->usbdev,							  line6->ep_control_write),					   (char *)frag_buf, frag_size,					   &partial, LINE6_TIMEOUT * HZ);		if (retval) {			dev_err(line6->ifcdev,				"usb_interrupt_msg failed (%d)/n", retval);			break;		}		done += frag_size;	}	return done;}

/*	Transmit Line6 control parameter.*/int line6_transmit_parameter(struct usb_line6 *line6, int param, u8 value){	int retval;	unsigned char *buffer;	int partial;	buffer = kmalloc(3, GFP_KERNEL);	if (!buffer) {		dev_err(line6->ifcdev, "out of memory/n");		return -ENOMEM;	}	buffer[0] = LINE6_PARAM_CHANGE | LINE6_CHANNEL_HOST;	buffer[1] = param;	buffer[2] = value;	retval = usb_interrupt_msg(line6->usbdev,				   usb_sndintpipe(line6->usbdev,						  line6->ep_control_write),				   buffer, 3, &partial, LINE6_TIMEOUT * HZ);	if (retval)		dev_err(line6->ifcdev, "usb_interrupt_msg failed (%d)/n",			retval);	kfree(buffer);	return retval;}

/*	Asynchronously send part of a raw message.*/static int line6_send_raw_message_async_part(struct message *msg,					     struct urb *urb){	int retval;	struct usb_line6 *line6 = msg->line6;	int done = msg->done;	int bytes = min(msg->size - done, line6->max_packet_size);	usb_fill_int_urb(urb, line6->usbdev,		usb_sndintpipe(line6->usbdev, line6->properties->ep_ctrl_w),		(char *)msg->buffer + done, bytes,		line6_async_request_sent, msg, line6->interval);	msg->done += bytes;	retval = usb_submit_urb(urb, GFP_ATOMIC);	if (retval < 0) {		dev_err(line6->ifcdev, "%s: usb_submit_urb failed (%d)/n",			__func__, retval);		usb_free_urb(urb);		kfree(msg);		return retval;	}	return 0;}

static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad){	struct usb_endpoint_descriptor *ep_irq_out;	int error = -ENOMEM;	if (xpad->xtype != XTYPE_XBOX360 && xpad->xtype != XTYPE_XBOX)		return 0;	xpad->odata = usb_alloc_coherent(xpad->udev, XPAD_PKT_LEN,					 GFP_KERNEL, &xpad->odata_dma);	if (!xpad->odata)		goto fail1;	mutex_init(&xpad->odata_mutex);	xpad->irq_out = usb_alloc_urb(0, GFP_KERNEL);	if (!xpad->irq_out)		goto fail2;	ep_irq_out = &intf->cur_altsetting->endpoint[1].desc;	usb_fill_int_urb(xpad->irq_out, xpad->udev,			 usb_sndintpipe(xpad->udev, ep_irq_out->bEndpointAddress),			 xpad->odata, XPAD_PKT_LEN,			 xpad_irq_out, xpad, ep_irq_out->bInterval);	xpad->irq_out->transfer_dma = xpad->odata_dma;	xpad->irq_out->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	return 0; fail2:	usb_free_coherent(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma); fail1:	return error;}

static int metrousb_send_unidirectional_cmd(u8 cmd, struct usb_serial_port *port){	int ret;	int actual_len;	u8 *buffer_cmd = NULL;	if (!metrousb_is_unidirectional_mode(port))		return 0;	buffer_cmd = kzalloc(sizeof(cmd), GFP_KERNEL);	if (!buffer_cmd)		return -ENOMEM;	*buffer_cmd = cmd;	ret = usb_interrupt_msg(port->serial->dev,		usb_sndintpipe(port->serial->dev, port->interrupt_out_endpointAddress),		buffer_cmd, sizeof(cmd),		&actual_len, USB_CTRL_SET_TIMEOUT);	kfree(buffer_cmd);	if (ret < 0)		return ret;	else if (actual_len != sizeof(cmd))		return -EIO;	return 0;}

static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad){	struct usb_endpoint_descriptor *ep_irq_out;	int ep_irq_out_idx;	if (xpad->xtype == XTYPE_UNKNOWN)		return 0;	xpad->odata = usb_alloc_coherent(xpad->udev, XPAD_PKT_LEN,					 GFP_KERNEL, &xpad->odata_dma);	if (!xpad->odata) {		return -ENOMEM;	}	mutex_init(&xpad->odata_mutex);	xpad->irq_out = usb_alloc_urb(0, GFP_KERNEL);	if (!xpad->irq_out) {		usb_free_coherent(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma);		return -ENOMEM;	}	/* Xbox One controller has in/out endpoints swapped. */	ep_irq_out_idx = xpad->xtype == XTYPE_XBOXONE ? 0 : 1;	ep_irq_out = &intf->cur_altsetting->endpoint[ep_irq_out_idx].desc;	usb_fill_int_urb(xpad->irq_out, xpad->udev,			 usb_sndintpipe(xpad->udev, ep_irq_out->bEndpointAddress),			 xpad->odata, XPAD_PKT_LEN,			 xpad_irq_out, xpad, ep_irq_out->bInterval);	xpad->irq_out->transfer_dma = xpad->odata_dma;	xpad->irq_out->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	return 0;}

/*	Send channel number (i.e., switch to a different sound).*/int line6_send_program(struct usb_line6 *line6, u8 value){	int retval;	unsigned char *buffer;	int partial;	buffer = kmalloc(2, GFP_KERNEL);	if (!buffer)		return -ENOMEM;	buffer[0] = LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_HOST;	buffer[1] = value;	retval = usb_interrupt_msg(line6->usbdev,				   usb_sndintpipe(line6->usbdev,						  line6->ep_control_write),				   buffer, 2, &partial, LINE6_TIMEOUT * HZ);	if (retval)		dev_err(line6->ifcdev, "usb_interrupt_msg failed (%d)/n",			retval);	kfree(buffer);	return retval;}

/*	Send raw message in pieces of wMaxPacketSize bytes.*/static int line6_send_raw_message(struct usb_line6 *line6, const char *buffer,				  int size){	int i, done = 0;	for (i = 0; i < size; i += line6->max_packet_size) {		int partial;		const char *frag_buf = buffer + i;		int frag_size = min(line6->max_packet_size, size - i);		int retval;		retval = usb_interrupt_msg(line6->usbdev,					usb_sndintpipe(line6->usbdev,						line6->properties->ep_ctrl_w),					(char *)frag_buf, frag_size,					&partial, LINE6_TIMEOUT * HZ);		if (retval) {			dev_err(line6->ifcdev,				"usb_interrupt_msg failed (%d)/n", retval);			break;		}		done += frag_size;	}	return done;}

static int mwifiex_usb_construct_send_urb(struct mwifiex_adapter *adapter,					  struct usb_tx_data_port *port, u8 ep,					  struct urb_context *context,					  struct sk_buff *skb_send){	struct usb_card_rec *card = adapter->card;	int ret = -EINPROGRESS;	struct urb *tx_urb;	context->adapter = adapter;	context->ep = ep;	context->skb = skb_send;	tx_urb = context->urb;	if (ep == card->tx_cmd_ep &&	    card->tx_cmd_ep_type == USB_ENDPOINT_XFER_INT)		usb_fill_int_urb(tx_urb, card->udev,				 usb_sndintpipe(card->udev, ep), skb_send->data,				 skb_send->len, mwifiex_usb_tx_complete,				 (void *)context, card->tx_cmd_interval);	else		usb_fill_bulk_urb(tx_urb, card->udev,				  usb_sndbulkpipe(card->udev, ep),				  skb_send->data, skb_send->len,				  mwifiex_usb_tx_complete, (void *)context);	tx_urb->transfer_flags |= URB_ZERO_PACKET;	if (ep == card->tx_cmd_ep)		atomic_inc(&card->tx_cmd_urb_pending);	else		atomic_inc(&port->tx_data_urb_pending);	if (ep != card->tx_cmd_ep &&	    atomic_read(&port->tx_data_urb_pending) ==					MWIFIEX_TX_DATA_URB) {		port->block_status = true;		adapter->data_sent = mwifiex_usb_data_sent(adapter);		ret = -ENOSR;	}	if (usb_submit_urb(tx_urb, GFP_ATOMIC)) {		mwifiex_dbg(adapter, ERROR,			    "%s: usb_submit_urb failed/n", __func__);		if (ep == card->tx_cmd_ep) {			atomic_dec(&card->tx_cmd_urb_pending);		} else {			atomic_dec(&port->tx_data_urb_pending);			port->block_status = false;			adapter->data_sent = false;			if (port->tx_data_ix)				port->tx_data_ix--;			else				port->tx_data_ix = MWIFIEX_TX_DATA_URB;		}		ret = -1;	}	return ret;}

/*	Send channel number (i.e., switch to a different sound).*/int line6_send_program(struct usb_line6 *line6, int value){	int retval;	unsigned char *buffer;	unsigned int partial;	buffer = kmalloc(2, GFP_KERNEL);	if (!buffer) {		dev_err(line6->ifcdev, "out of memory/n");		return -ENOMEM;	}	buffer[0] = LINE6_PROGRAM_CHANGE | LINE6_CHANNEL_HOST;	buffer[1] = value;#if DO_DUMP_URB_SEND	line6_write_hexdump(line6, 'S', buffer, 2);#endif	retval = usb_interrupt_msg(line6->usbdev,				   usb_sndintpipe(line6->usbdev,						  line6->ep_control_write),				   buffer, 2, &partial, LINE6_TIMEOUT * HZ);	if (retval)		dev_err(line6->ifcdev, "usb_interrupt_msg failed (%d)/n", retval);	kfree(buffer);	return retval;}

/*	Asynchronously send part of a raw message.*/static int line6_send_raw_message_async_part(struct message *msg,					     struct urb *urb){	int retval;	struct usb_line6 *line6 = msg->line6;	int done = msg->done;	int bytes = min(msg->size - done, line6->max_packet_size);	usb_fill_int_urb(urb, line6->usbdev,			 usb_sndintpipe(line6->usbdev, line6->ep_control_write),			 (char *)msg->buffer + done, bytes,			 line6_async_request_sent, msg, line6->interval);#if DO_DUMP_URB_SEND	line6_write_hexdump(line6, 'S', (char *)msg->buffer + done, bytes);#endif	msg->done += bytes;	retval = usb_submit_urb(urb, GFP_ATOMIC);	if (retval < 0) {		dev_err(line6->ifcdev, "%s: usb_submit_urb failed (%d)/n",			__func__, retval);		usb_free_urb(urb);		kfree(msg);		return -EINVAL;	}	return 0;}

T_EpOut selectBestEpOut(WORD *epOutSize, WORD requestedSize){	UINT ep2_size = 0;  	UINT ep6_size = 0;	T_EpOut bestEpOut;#if  (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,10))	ep2_size = ((unicorn_usb_dev.usb_dev->epmaxpacketout[EP_OBC_ISO_OUT]) / 2);  //bytes to Words	ep6_size = ((unicorn_usb_dev.usb_dev->epmaxpacketout[EP_OBC_INT_OUT]) / 2);  //bytes to Words#else	ep2_size = ((usb_maxpacket(unicorn_usb_dev.usb_dev,usb_sndisocpipe(unicorn_usb_dev.usb_dev, EP_OBC_ISO_OUT),1)) / 2);  //bytes to Words	ep6_size = ((usb_maxpacket(unicorn_usb_dev.usb_dev,usb_sndintpipe(unicorn_usb_dev.usb_dev,EP_OBC_INT_OUT),1))  / 2);  //bytes to Words#endif	if(requestedSize <= ep6_size) 	{		*epOutSize = ep6_size;		bestEpOut = EP6;	}	else 	{		*epOutSize = ep2_size;		bestEpOut = EP2;	}	return bestEpOut;}

int InterruptOut(PMINI_ADAPTER Adapter, PUCHAR pData){        int 	status = STATUS_SUCCESS;	int 	lenwritten = 0;    PS_INTERFACE_ADAPTER psInterfaceAdapter = Adapter->pvInterfaceAdapter;        if( FALSE == Adapter->bShutStatus &&		FALSE == Adapter->IdleMode &&		FALSE == Adapter->bPreparingForLowPowerMode &&        FALSE == Adapter->device_removed)       {	    status = usb_interrupt_msg (psInterfaceAdapter->udev, 			     usb_sndintpipe(psInterfaceAdapter->udev,            	 psInterfaceAdapter->sIntrOut.int_out_endpointAddr),       			 pData, 		    	 8, 			     &lenwritten, 			     5000);    }	if(status)	{		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "Sending clear pattern down fails with status:%d../n",status);		return status;	}	else	{	    BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "NOB Sent down :%d", lenwritten);	        return STATUS_SUCCESS;	}} /* InterruptOut() */

static int iforce_usb_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 *epirq, *epout;	struct iforce *iforce;	int err = -ENOMEM;	interface = intf->cur_altsetting;	epirq = &interface->endpoint[0].desc;	epout = &interface->endpoint[1].desc;	if (!(iforce = kzalloc(sizeof(struct iforce) + 32, GFP_KERNEL)))		goto fail;	if (!(iforce->irq = usb_alloc_urb(0, GFP_KERNEL)))		goto fail;	if (!(iforce->out = usb_alloc_urb(0, GFP_KERNEL)))		goto fail;	if (!(iforce->ctrl = usb_alloc_urb(0, GFP_KERNEL)))		goto fail;	iforce->bus = IFORCE_USB;	iforce->usbdev = dev;	iforce->cr.bRequestType = USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_INTERFACE;	iforce->cr.wIndex = 0;	iforce->cr.wLength = cpu_to_le16(16);	usb_fill_int_urb(iforce->irq, dev, usb_rcvintpipe(dev, epirq->bEndpointAddress),			iforce->data, 16, iforce_usb_irq, iforce, epirq->bInterval);	usb_fill_int_urb(iforce->out, dev, usb_sndintpipe(dev, epout->bEndpointAddress),			iforce + 1, 32, iforce_usb_out, iforce, epout->bInterval);	usb_fill_control_urb(iforce->ctrl, dev, usb_rcvctrlpipe(dev, 0),			(void*) &iforce->cr, iforce->edata, 16, iforce_usb_ctrl, iforce);	err = iforce_init_device(iforce);	if (err)		goto fail;	usb_set_intfdata(intf, iforce);	return 0;fail:	if (iforce) {		usb_free_urb(iforce->irq);		usb_free_urb(iforce->out);		usb_free_urb(iforce->ctrl);		kfree(iforce);	}	return err;}

unsigned intSysUsbIntPipe(pUsb_device pUdev, unsigned char addr, unsigned char dir){        struct usb_device *udev = (struct usb_device *) pUdev;        if( USB_DIR_IN==dir ) return usb_rcvintpipe(udev, addr);        return usb_sndintpipe(udev, addr);}

static int get_pipe(struct stub_device *sdev, int epnum, int dir){	struct usb_device *udev = interface_to_usbdev(sdev->interface);	struct usb_host_endpoint *ep;	struct usb_endpoint_descriptor *epd = NULL;	ep = get_ep_from_epnum(udev, epnum);	if (!ep) {		uerr("no such endpoint?, %d", epnum);		BUG();	}	epd = &ep->desc;#if 0	/* epnum 0 is always control */	if (epnum == 0) {		if (dir == USBIP_DIR_OUT)			return usb_sndctrlpipe(udev, 0);		else			return usb_rcvctrlpipe(udev, 0);	}#endif	if (usb_endpoint_xfer_control(epd)) {		if (dir == USBIP_DIR_OUT)			return usb_sndctrlpipe(udev, epnum);		else			return usb_rcvctrlpipe(udev, epnum);	}	if (usb_endpoint_xfer_bulk(epd)) {		if (dir == USBIP_DIR_OUT)			return usb_sndbulkpipe(udev, epnum);		else			return usb_rcvbulkpipe(udev, epnum);	}	if (usb_endpoint_xfer_int(epd)) {		if (dir == USBIP_DIR_OUT)			return usb_sndintpipe(udev, epnum);		else			return usb_rcvintpipe(udev, epnum);	}	if (usb_endpoint_xfer_isoc(epd)) {		if (dir == USBIP_DIR_OUT)			return usb_sndisocpipe(udev, epnum);		else			return usb_rcvisocpipe(udev, epnum);	}	/* NOT REACHED */	uerr("get pipe, epnum %d/n", epnum);	return 0;}

static ssize_t exemple_write (struct file * file,                              const char __user * data,                              size_t length, loff_t * offset){	int o0, o1, o2, o3, o4, o5, o6, o7;	char * buffer;	int err;		buffer = kmalloc(length, GFP_KERNEL);	if (buffer == NULL) {		return -ENOMEM;	}	if (copy_from_user(buffer, data, length)) {		kfree(buffer);		return -EINVAL;	}	err = (sscanf(buffer, "%d %d %d %d %d %d %d %d", &o0, &o1, &o2, &o3, &o4, &o5, &o6, &o7) != 8);	kfree(buffer);	if (err)		return -EINVAL;	if (mutex_lock_interruptible(& exemple_mtx))		return -ERESTARTSYS;	while(exemple_out_busy)		if (wait_event_interruptible_timeout(exemple_out_wq, ! exemple_out_busy, HZ) <= 0) {			mutex_unlock(& exemple_mtx);			return -ERESTARTSYS;		}	exemple_out_busy = 1;		exemple_out_buffer[0] = o0 & 0xFF; 	exemple_out_buffer[1] = o1 & 0xFF;	exemple_out_buffer[2] = o2 & 0xFF;	exemple_out_buffer[3] = o3 & 0xFF;	exemple_out_buffer[4] = o4 & 0xFF;	exemple_out_buffer[5] = o5 & 0xFF;	exemple_out_buffer[6] = o6 & 0xFF;	exemple_out_buffer[7] = o7 & 0xFF;	usb_fill_int_urb(exemple_out_urb,	                 exemple_usb_device,	                 usb_sndintpipe(exemple_usb_device,					        exemple_out_endpoint->bEndpointAddress),	                 exemple_out_buffer,					 EXEMPLE_OUT_BUFFER_SIZE,					 exemple_write_callback,					 NULL,					 exemple_out_endpoint->bInterval);	err = usb_submit_urb(exemple_out_urb, GFP_KERNEL);	mutex_unlock(& exemple_mtx);	if (err == 0)		return length;	return err;}

/* Don't start the URB */static void auerisdn_bintbo_setup(struct auerisdn *ip, unsigned int len){	ip->intbo_state = INTBOS_IDLE;	FILL_INT_URB(ip->intbo_urbp, ip->usbdev,		     usb_sndintpipe(ip->usbdev, ip->intbo_endp),		     ip->intbo_bufp, len, auerisdn_bintbo_complete, ip,		     ip->outInterval);	ip->intbo_urbp->transfer_flags |= USB_ASYNC_UNLINK;	ip->intbo_urbp->status = 0;}

static void usb6fire_comm_init_urb(struct comm_runtime *rt, struct urb *urb,		u8 *buffer, void *context, void(*handler)(struct urb *urb)){	usb_init_urb(urb);	urb->transfer_buffer = buffer;	urb->pipe = usb_sndintpipe(rt->chip->dev, COMM_EP);	urb->complete = handler;	urb->context = context;	urb->interval = 1;	urb->dev = rt->chip->dev;}

static ssize_t write_exemple (struct file * file,     const char __user * data, size_t length, loff_t * offset){	int o0, o1, o2, o3, o4, o5, o6, o7;	char * buffer;	int err;		buffer = kmalloc(length, GFP_KERNEL);	if (buffer == NULL) {		return -ENOMEM;	}	if (copy_from_user(buffer, data, length)) {		kfree(buffer);		return -EINVAL;	}	err = (sscanf(buffer, "%d %d %d %d %d %d %d %d", &o0, &o1, &o2, &o3, &o4, &o5, &o6, &o7) != 8);	kfree(buffer);	if (err)		return -EINVAL;	/*	 * Attendre que la requete precedente soit terminee.	 */	while(intr_out_busy_exemple)		if (wait_event_interruptible(intr_out_queue_exemple, ! intr_out_busy_exemple))			return -ERESTARTSYS;	intr_out_busy_exemple = 1;		intr_out_buf_exemple[0] = o0 & 0xFF; 	intr_out_buf_exemple[1] = o1 & 0xFF;	intr_out_buf_exemple[2] = o2 & 0xFF;	intr_out_buf_exemple[3] = o3 & 0xFF;	intr_out_buf_exemple[4] = o4 & 0xFF;	intr_out_buf_exemple[5] = o5 & 0xFF;	intr_out_buf_exemple[6] = o6 & 0xFF;	intr_out_buf_exemple[7] = o7 & 0xFF;		usb_fill_int_urb(intr_out_urb_exemple,	                 usb_device_exemple,	                 usb_sndintpipe(usb_device_exemple,					        intr_out_end_exemple->bEndpointAddress),	                 intr_out_buf_exemple,					 INTERRUPT_OUT_SIZE_EXEMPLE,					 write_callback_exemple,					 NULL,					 intr_out_end_exemple->bInterval);	err = usb_submit_urb(intr_out_urb_exemple, GFP_KERNEL);	if (err == 0)		return length;	return err;}

static int usb6fire_comm_send_buffer(u8 *buffer, struct usb_device *dev){	int ret;	int actual_len;	ret = usb_interrupt_msg(dev, usb_sndintpipe(dev, COMM_EP),			buffer, buffer[1] + 2, &actual_len, HZ);	if (ret < 0)		return ret;	else if (actual_len != buffer[1] + 2)		return -EIO;	return 0;}

static int bcd2000_init_midi(struct bcd2000 *bcd2k){	int ret;	struct snd_rawmidi *rmidi;	ret = snd_rawmidi_new(bcd2k->card, bcd2k->card->shortname, 0,					1, /* output */					1, /* input */					&rmidi);	if (ret < 0)		return ret;	strlcpy(rmidi->name, bcd2k->card->shortname, sizeof(rmidi->name));	rmidi->info_flags = SNDRV_RAWMIDI_INFO_DUPLEX;	rmidi->private_data = bcd2k;	rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT;	snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,					&bcd2000_midi_output);	rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT;	snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,					&bcd2000_midi_input);	bcd2k->rmidi = rmidi;	bcd2k->midi_in_urb = usb_alloc_urb(0, GFP_KERNEL);	bcd2k->midi_out_urb = usb_alloc_urb(0, GFP_KERNEL);	if (!bcd2k->midi_in_urb || !bcd2k->midi_out_urb) {		dev_err(&bcd2k->dev->dev, PREFIX "usb_alloc_urb failed/n");		return -ENOMEM;	}	usb_fill_int_urb(bcd2k->midi_in_urb, bcd2k->dev,				usb_rcvintpipe(bcd2k->dev, 0x81),				bcd2k->midi_in_buf, BUFSIZE,				bcd2000_input_complete, bcd2k, 1);	usb_fill_int_urb(bcd2k->midi_out_urb, bcd2k->dev,				usb_sndintpipe(bcd2k->dev, 0x1),				bcd2k->midi_out_buf, BUFSIZE,				bcd2000_output_complete, bcd2k, 1);	bcd2000_init_device(bcd2k);	return 0;}

/* * Called from net/core when new frame is available. */static int kingsun_hard_xmit(struct sk_buff *skb, struct net_device *netdev){	struct kingsun_cb *kingsun;	int wraplen;	int ret = 0;	if (skb == NULL || netdev == NULL)		return -EINVAL;	netif_stop_queue(netdev);	/* the IRDA wrapping routines don't deal with non linear skb */	SKB_LINEAR_ASSERT(skb);	kingsun = netdev_priv(netdev);	spin_lock(&kingsun->lock);	/* Append data to the end of whatever data remains to be transmitted */	wraplen = async_wrap_skb(skb,		kingsun->out_buf,		KINGSUN_FIFO_SIZE);	/* Calculate how much data can be transmitted in this urb */	usb_fill_int_urb(kingsun->tx_urb, kingsun->usbdev,		usb_sndintpipe(kingsun->usbdev, kingsun->ep_out),		kingsun->out_buf, wraplen, kingsun_send_irq,		kingsun, 1);	if ((ret = usb_submit_urb(kingsun->tx_urb, GFP_ATOMIC))) {		err("kingsun_hard_xmit: failed tx_urb submit: %d", ret);		switch (ret) {		case -ENODEV:		case -EPIPE:			break;		default:			kingsun->stats.tx_errors++;			netif_start_queue(netdev);		}	} else {		kingsun->stats.tx_packets++;		kingsun->stats.tx_bytes += skb->len;	}	dev_kfree_skb(skb);	spin_unlock(&kingsun->lock);	return ret;}

int __carl9170_exec_cmd(struct ar9170 *ar, struct carl9170_cmd *cmd,			const bool free_buf){	struct urb *urb;	int err = 0;	if (!IS_INITIALIZED(ar)) {		err = -EPERM;		goto err_free;	}	if (WARN_ON(cmd->hdr.len > CARL9170_MAX_CMD_LEN - 4)) {		err = -EINVAL;		goto err_free;	}	urb = usb_alloc_urb(0, GFP_ATOMIC);	if (!urb) {		err = -ENOMEM;		goto err_free;	}	if (ar->usb_ep_cmd_is_bulk)		usb_fill_bulk_urb(urb, ar->udev,				  usb_sndbulkpipe(ar->udev, AR9170_USB_EP_CMD),				  cmd, cmd->hdr.len + 4,				  carl9170_usb_cmd_complete, ar);	else		usb_fill_int_urb(urb, ar->udev,				 usb_sndintpipe(ar->udev, AR9170_USB_EP_CMD),				 cmd, cmd->hdr.len + 4,				 carl9170_usb_cmd_complete, ar, 1);	if (free_buf)		urb->transfer_flags |= URB_FREE_BUFFER;	usb_anchor_urb(urb, &ar->tx_cmd);	usb_free_urb(urb);	return carl9170_usb_submit_cmd_urb(ar);err_free:	if (free_buf)		kfree(cmd);	return err;}

static netdev_tx_t kingsun_hard_xmit(struct sk_buff *skb,					   struct net_device *netdev){	struct kingsun_cb *kingsun;	int wraplen;	int ret = 0;	netif_stop_queue(netdev);		SKB_LINEAR_ASSERT(skb);	kingsun = netdev_priv(netdev);	spin_lock(&kingsun->lock);		wraplen = async_wrap_skb(skb,		kingsun->out_buf,		KINGSUN_FIFO_SIZE);		usb_fill_int_urb(kingsun->tx_urb, kingsun->usbdev,		usb_sndintpipe(kingsun->usbdev, kingsun->ep_out),		kingsun->out_buf, wraplen, kingsun_send_irq,		kingsun, 1);	if ((ret = usb_submit_urb(kingsun->tx_urb, GFP_ATOMIC))) {		err("kingsun_hard_xmit: failed tx_urb submit: %d", ret);		switch (ret) {		case -ENODEV:		case -EPIPE:			break;		default:			netdev->stats.tx_errors++;			netif_start_queue(netdev);		}	} else {		netdev->stats.tx_packets++;		netdev->stats.tx_bytes += skb->len;	}	dev_kfree_skb(skb);	spin_unlock(&kingsun->lock);	return NETDEV_TX_OK;}

static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad) //初始化设备输出 {    struct usb_endpoint_descriptor *ep_irq_out;    int ep_irq_out_idx;    int error;    xpad->odata = usb_alloc_coherent(xpad->udev, XPAD_PKT_LEN,                                     GFP_KERNEL, &xpad->odata_dma); //输出类型的 DMA接口 数据  和 地址    if (!xpad->odata)    {        error = -ENOMEM;        goto fail1;    }    //初始化互斥锁 用于同步    mutex_init(&xpad->odata_mutex);    xpad->irq_out = usb_alloc_urb(0, GFP_KERNEL); //初始化 out型 urb    if (!xpad->irq_out)    {        error = -ENOMEM;        goto fail2;    }    /* Xbox One controller has in/out endpoints swapped. */    ep_irq_out_idx =  1;    ep_irq_out = &intf->cur_altsetting->endpoint[ep_irq_out_idx].desc;	//函数结构 usb_fill_int_urb(struct urb* urb,struct  usb_device * dev,unsigned int pipe,void * transfer_buffer,int  buffer_length,usb_complete_t complete,void * context,int interval)    //根据 usb设备，usb管道，输出缓冲区的首地址，缓冲区长度，out 型 urb入口函数，手柄设备数据信息，out endpoint口的轮换间隔信息 得到 输出型的urb    usb_fill_int_urb(xpad->irq_out, xpad->udev,                     usb_sndintpipe(xpad->udev, ep_irq_out->bEndpointAddress),                     xpad->odata, XPAD_PKT_LEN,                     xpad_irq_out, xpad, ep_irq_out->bInterval);     xpad->irq_out->transfer_dma = xpad->odata_dma; //分配DMA接口地址    xpad->irq_out->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; //允许 输出型urb 进行DMA传输    return 0;fail2: usb_free_coherent(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma);fail1: return error;}

static void find_usb_pipe(struct baseband_usb *usb){	struct usb_device *usbdev = usb->usb.device;	struct usb_interface *intf = usb->usb.interface;	unsigned char numendpoint = intf->cur_altsetting->desc.bNumEndpoints;	struct usb_host_endpoint *endpoint = intf->cur_altsetting->endpoint;	unsigned char n;	for (n = 0; n < numendpoint; n++) {		if (usb_endpoint_is_isoc_in(&endpoint[n].desc)) {			pr_debug("endpoint[%d] isochronous in/n", n);			usb->usb.pipe.isoch.in = usb_rcvisocpipe(usbdev,				endpoint[n].desc.bEndpointAddress);		} else if (usb_endpoint_is_isoc_out(&endpoint[n].desc)) {			pr_debug("endpoint[%d] isochronous out/n", n);			usb->usb.pipe.isoch.out = usb_sndisocpipe(usbdev,				endpoint[n].desc.bEndpointAddress);		} else if (usb_endpoint_is_bulk_in(&endpoint[n].desc)) {			pr_debug("endpoint[%d] bulk in/n", n);			usb->usb.pipe.bulk.in = usb_rcvbulkpipe(usbdev,				endpoint[n].desc.bEndpointAddress);		} else if (usb_endpoint_is_bulk_out(&endpoint[n].desc)) {			pr_debug("endpoint[%d] bulk out/n", n);			usb->usb.pipe.bulk.out = usb_sndbulkpipe(usbdev,				endpoint[n].desc.bEndpointAddress);		} else if (usb_endpoint_is_int_in(&endpoint[n].desc)) {			pr_debug("endpoint[%d] interrupt in/n", n);			usb->usb.pipe.interrupt.in = usb_rcvintpipe(usbdev,				endpoint[n].desc.bEndpointAddress);		} else if (usb_endpoint_is_int_out(&endpoint[n].desc)) {			pr_debug("endpoint[%d] interrupt out/n", n);			usb->usb.pipe.interrupt.out = usb_sndintpipe(usbdev,				endpoint[n].desc.bEndpointAddress);		} else {			pr_debug("endpoint[%d] skipped/n", n);		}	}}

/* * Send a command to the firmware. */intotus_send_cmd(struct ar9170 *ar, struct carl9170_cmd *cmd){	if (cmd->hdr.len > CARL9170_MAX_CMD_LEN - 4) {		return (EINVAL);	}	/*	 * Commands are sent on the CMD endpoint.	 */	usb_fill_int_urb(urb, ar->udev, usb_sndintpipe(ar->udev,		AR9170_USB_EP_CMD), cmd, cmd->hdr.len + 4,		carl9170_usb_cmd_complete, ar, 1);	if (free_buf)		urb->transfer_flags |= URB_FREE_BUFFER;	usb_anchor_urb(urb, &ar->tx_cmd);	usb_free_urb(urb);	return carl9170_usb_submit_cmd_urb(ar);}

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