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

static void tx_complete(struct usb_ep *ep, struct usb_request *req){	struct sk_buff	*skb;	struct eth_dev	*dev;	struct net_device *net;	struct usb_request *new_req;	struct usb_ep *in;	int length;	int retval;	if (!ep->driver_data) {		usb_ep_free_request(ep, req);		return;	}	dev = ep->driver_data;	net = dev->net;	if (!dev->port_usb) {		usb_ep_free_request(ep, req);		return;	}	switch (req->status) {	default:		dev->net->stats.tx_errors++;		VDBG(dev, "tx err %d/n", req->status);			case -ECONNRESET:			case -ESHUTDOWN:				break;	case 0:		if (!req->zero)			dev->net->stats.tx_bytes += req->length-1;		else			dev->net->stats.tx_bytes += req->length;	}	dev->net->stats.tx_packets++;	spin_lock(&dev->req_lock);	list_add_tail(&req->list, &dev->tx_reqs);	if (dev->port_usb->multi_pkt_xfer && !req->context) {		dev->no_tx_req_used--;		req->length = 0;		in = dev->port_usb->in_ep;		if (!list_empty(&dev->tx_reqs)) {			new_req = container_of(dev->tx_reqs.next,					struct usb_request, list);			list_del(&new_req->list);			spin_unlock(&dev->req_lock);			if (new_req->length > 0) {				length = new_req->length;				if (dev->port_usb->is_fixed &&					length == dev->port_usb->fixed_in_len &&					(length % in->maxpacket) == 0)					new_req->zero = 0;				else					new_req->zero = 1;				if (new_req->zero && !dev->zlp &&						(length % in->maxpacket) == 0) {					new_req->zero = 0;					length++;				}				new_req->length = length;				retval = usb_ep_queue(in, new_req, GFP_ATOMIC);				switch (retval) {				default:					DBG(dev, "tx queue err %d/n", retval);					new_req->length = 0;					spin_lock(&dev->req_lock);					list_add_tail(&new_req->list,							&dev->tx_reqs);					spin_unlock(&dev->req_lock);					break;				case 0:					spin_lock(&dev->req_lock);					dev->no_tx_req_used++;					spin_unlock(&dev->req_lock);					net->trans_start = jiffies;				}			} else {				spin_lock(&dev->req_lock);				list_add_tail(&new_req->list, &dev->tx_reqs);				spin_unlock(&dev->req_lock);			}		} else {

//.........这里部分代码省略.........			/* ignores USB_CDC_PACKET_TYPE_MULTICAST and host			 * SET_ETHERNET_MULTICAST_FILTERS requests			 */			if (is_broadcast_ether_addr(dest))				type = USB_CDC_PACKET_TYPE_BROADCAST;			else				type = USB_CDC_PACKET_TYPE_ALL_MULTICAST;			if (!(cdc_filter & type)) {				dev_kfree_skb_any(skb);				return NETDEV_TX_OK;			}		}		/* ignores USB_CDC_PACKET_TYPE_DIRECTED */	}	spin_lock_irqsave(&dev->req_lock, flags);	/*	 * this freelist can be empty if an interrupt triggered disconnect()	 * and reconfigured the gadget (shutting down this queue) after the	 * network stack decided to xmit but before we got the spinlock.	 */	if (list_empty(&dev->tx_reqs)) {		spin_unlock_irqrestore(&dev->req_lock, flags);		return NETDEV_TX_BUSY;	}	req = container_of(dev->tx_reqs.next, struct usb_request, list);	list_del(&req->list);	/* temporarily stop TX queue when the freelist empties */	if (list_empty(&dev->tx_reqs))		netif_stop_queue(net);	spin_unlock_irqrestore(&dev->req_lock, flags);	/* no buffer copies needed, unless the network stack did it	 * or the hardware can't use skb buffers.	 * or there's not enough space for extra headers we need	 */	if (dev->wrap) {		unsigned long	flags;		spin_lock_irqsave(&dev->lock, flags);		if (dev->port_usb)			skb = dev->wrap(dev->port_usb, skb);		spin_unlock_irqrestore(&dev->lock, flags);		if (!skb)			goto drop;		length = skb->len;	}	req->buf = skb->data;	req->context = skb;	req->complete = tx_complete;	/* NCM requires no zlp if transfer is dwNtbInMaxSize */	if (dev->port_usb->is_fixed &&	    length == dev->port_usb->fixed_in_len &&	    (length % in->maxpacket) == 0)		req->zero = 0;	else		req->zero = 1;	/* use zlp framing on tx for strict CDC-Ether conformance,	 * though any robust network rx path ignores extra padding.	 * and some hardware doesn't like to write zlps.	 */	if (req->zero && !dev->zlp && (length % in->maxpacket) == 0)		length++;	req->length = length;	/* throttle high/super speed IRQ rate back slightly */	if (gadget_is_dualspeed(dev->gadget))		req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH ||				     dev->gadget->speed == USB_SPEED_SUPER)			? ((atomic_read(&dev->tx_qlen) % qmult) != 0)			: 0;	retval = usb_ep_queue(in, req, GFP_ATOMIC);	switch (retval) {	default:		DBG(dev, "tx queue err %d/n", retval);		break;	case 0:		net->trans_start = jiffies;		atomic_inc(&dev->tx_qlen);	}	if (retval) {		dev_kfree_skb_any(skb);drop:		dev->net->stats.tx_dropped++;		spin_lock_irqsave(&dev->req_lock, flags);		if (list_empty(&dev->tx_reqs))			netif_start_queue(net);		list_add(&req->list, &dev->tx_reqs);		spin_unlock_irqrestore(&dev->req_lock, flags);	}	return NETDEV_TX_OK;}

static intgser_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl){	struct f_gser            *gser = func_to_gser(f);	struct usb_composite_dev *cdev = f->config->cdev;	struct usb_request	 *req = cdev->req;	int			 value = -EOPNOTSUPP;	u16			 w_index = le16_to_cpu(ctrl->wIndex);	u16			 w_value = le16_to_cpu(ctrl->wValue);	u16			 w_length = le16_to_cpu(ctrl->wLength);	switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {		case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)			| USB_CDC_REQ_SET_LINE_CODING:		if (w_length != sizeof(struct usb_cdc_line_coding))			goto invalid;		value = w_length;		cdev->gadget->ep0->driver_data = gser;		req->complete = gser_complete_set_line_coding;		break;		case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)			| USB_CDC_REQ_GET_LINE_CODING:		value = min_t(unsigned, w_length,				sizeof(struct usb_cdc_line_coding));		memcpy(req->buf, &gser->port_line_coding, value);		break;		case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)			| USB_CDC_REQ_SET_CONTROL_LINE_STATE:		value = 0;		gser->port_handshake_bits = w_value;		if (gser->port.notify_modem) {			unsigned port_num =				gserial_ports[gser->port_num].client_port_num;			gser->port.notify_modem(&gser->port,					port_num, w_value);		}		break;	default:invalid:		DBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d/n",			ctrl->bRequestType, ctrl->bRequest,			w_value, w_index, w_length);	}		if (value >= 0) {		DBG(cdev, "gser ttyGS%d req%02x.%02x v%04x i%04x l%d/n",			gser->port_num, ctrl->bRequestType, ctrl->bRequest,			w_value, w_index, w_length);		req->zero = 0;		req->length = value;		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);		if (value < 0)			ERROR(cdev, "gser response on ttyGS%d, err %d/n",					gser->port_num, value);	}		return value;}

static int mtp_ioctl(struct inode *inode, struct file *file,		unsigned int cmd, unsigned long arg){	int len, clen, count, n;	struct usb_request *req;	struct mtp_event_data event;	if (!g_usb_mtp_context.online)		return -EINVAL;	switch (cmd) {	case MTP_IOC_EVENT:		if (g_usb_mtp_context.intr_in_busy) {			mtp_err("interrupt in request busy/n");			return -EBUSY;		}		count = MIN(_IOC_SIZE(cmd), MTP_EVENT_SIZE);		if (copy_from_user(event.data, (void *)arg,  count))			return -EINVAL;		/* length is in little endian */		memcpy(&len, event.data, sizeof(len));		clen = le32_to_cpu(len);		mtp_debug("len=%d cpu len=%d/n", len, clen);		/* send event through interrupt in */		req = g_usb_mtp_context.int_tx_req;		if (!req)			return -EINVAL;		count = MIN(MTP_EVENT_SIZE, clen);		memcpy(req->buf, event.data, count);		req->length = count;		req->zero = 0;		g_usb_mtp_context.intr_in_busy = 1;		if (usb_ep_queue(g_usb_mtp_context.intr_in, req, GFP_ATOMIC)) {			g_usb_mtp_context.intr_in_busy = 0;			return -EINVAL;		}		break;	case MTP_IOC_SEND_ZLP:		req = req_get(&g_usb_mtp_context.tx_reqs);		if (!req)			return -EINVAL;		req->length = 0;		req->zero = 0;		if (usb_ep_queue(g_usb_mtp_context.bulk_in, req, GFP_ATOMIC)) {			req_put(&g_usb_mtp_context.tx_reqs, req);			return -EINVAL;		}		break;	case MTP_IOC_GET_EP_SIZE_IN:		/* get endpoint buffer size for bulk in */		len = BULK_BUFFER_SIZE;		if (copy_to_user((void *)arg, &len, sizeof(int)))			return -EINVAL;		break;	case MTP_IOC_CANCEL_IO:		mtp_debug("MTP_IOC_CANCEL_IO:/n");		g_usb_mtp_context.cancel = 1;		for (n = 0; n < MAX_BULK_RX_REQ_NUM; n++) {			req = pending_reqs[n];			if (req && req->actual) {				mtp_err("n=%d %p %d/n", n, req, req->actual);				req->actual = 0;			}		}		/* we've cancelled the recv urb, start new one */		mtp_debug("MTP_IOC_CANCEL_IO end:/n");		wake_up(&g_usb_mtp_context.rx_wq);		wake_up(&g_usb_mtp_context.tx_wq);		break;	case MTP_IOC_DEVICE_RESET:		g_usb_mtp_context.cancel = 1;		g_usb_mtp_context.ctl_cancel = 1;		wake_up(&g_usb_mtp_context.rx_wq);		wake_up(&g_usb_mtp_context.tx_wq);		wake_up(&g_usb_mtp_context.ctl_rx_wq);		wake_up(&g_usb_mtp_context.ctl_tx_wq);		break;	}	return 0;}

static void tx_complete(struct usb_ep *ep, struct usb_request *req){	struct sk_buff	*skb = req->context;	struct eth_dev	*dev = ep->driver_data;#ifdef CONFIG_USB_RNDIS_MULTIPACKET	struct net_device *net;	struct usb_request *new_req;	struct usb_ep *in;	int length;	int retval;	if (!ep->driver_data) {		pr_err("%s: driver_data is null/n", __func__);		usb_ep_free_request(ep, req);		return;	}	dev = ep->driver_data;	net = dev->net;	if (!dev->port_usb) {		pr_err("%s: port_usb is null/n", __func__);		usb_ep_free_request(ep, req);		return;	}#endif	switch (req->status) {	default:		dev->net->stats.tx_errors++;		VDBG(dev, "tx err %d/n", req->status);#ifdef CONFIG_USB_NCM_SUPPORT_MTU_CHANGE		printk(KERN_ERR"usb:%s tx err %d/n",__func__, req->status);#endif		/* FALLTHROUGH */	case -ECONNRESET:		/* unlink */	case -ESHUTDOWN:		/* disconnect etc */		break;	case 0:#ifdef CONFIG_USB_RNDIS_MULTIPACKET		if (!req->zero)			dev->net->stats.tx_bytes += req->length-1;		else			dev->net->stats.tx_bytes += req->length;#else		dev->net->stats.tx_bytes += skb->len;#endif	}	dev->net->stats.tx_packets++;	spin_lock(&dev->req_lock);#ifdef CONFIG_USB_RNDIS_MULTIPACKET	list_add_tail(&req->list, &dev->tx_reqs);	if (dev->port_usb->multi_pkt_xfer) {		dev->no_tx_req_used--;		req->length = 0;		in = dev->port_usb->in_ep;		if (!list_empty(&dev->tx_reqs)) {			new_req = container_of(dev->tx_reqs.next,					struct usb_request, list);			list_del(&new_req->list);			spin_unlock(&dev->req_lock);			if (new_req->length > 0) {				length = new_req->length;				/* NCM requires no zlp if transfer is				 * dwNtbInMaxSize */				if (dev->port_usb->is_fixed &&					length == dev->port_usb->fixed_in_len &&					(length % in->maxpacket) == 0)					new_req->zero = 0;				else					new_req->zero = 1;				/* use zlp framing on tx for strict CDC-Ether				 * conformance, though any robust network rx				 * path ignores extra padding. and some hardware				 * doesn't like to write zlps.				 */				if (new_req->zero && !dev->zlp &&						(length % in->maxpacket) == 0) {					new_req->zero = 0;					length++;				}				new_req->length = length;				new_req->complete = tx_complete;				retval = usb_ep_queue(in, new_req, GFP_ATOMIC);				switch (retval) {				default:					DBG(dev, "tx queue err %d/n", retval);					new_req->length = 0;					spin_lock(&dev->req_lock);					list_add_tail(&new_req->list, &dev->tx_reqs);					spin_unlock(&dev->req_lock);					break;				case 0:					spin_lock(&dev->req_lock);//.........这里部分代码省略.........

static intrndis_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl){    struct f_rndis		*rndis = func_to_rndis(f);    struct usb_composite_dev *cdev = f->config->cdev;    struct usb_request	*req = cdev->req;    int			value = -EOPNOTSUPP;    u16			w_index = le16_to_cpu(ctrl->wIndex);    u16			w_value = le16_to_cpu(ctrl->wValue);    u16			w_length = le16_to_cpu(ctrl->wLength);    /* composite driver infrastructure handles everything except     * CDC class messages; interface activation uses set_alt().     */    switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {    /* RNDIS uses the CDC command encapsulation mechanism to implement     * an RPC scheme, with much getting/setting of attributes by OID.     */    case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)            | USB_CDC_SEND_ENCAPSULATED_COMMAND:        if (w_value || w_index != rndis->ctrl_id)            goto invalid;        /* read the request; process it later */        value = w_length;        req->complete = rndis_command_complete;        req->context = rndis;        /* later, rndis_response_available() sends a notification */        break;    case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)            | USB_CDC_GET_ENCAPSULATED_RESPONSE:        if (w_value || w_index != rndis->ctrl_id)            goto invalid;        else {            u8 *buf;            u32 n;            /* return the result */            buf = rndis_get_next_response(rndis->config, &n);            if (buf) {                memcpy(req->buf, buf, n);                req->complete = rndis_response_complete;                req->context = rndis;                rndis_free_response(rndis->config, buf);                value = n;            }            /* else stalls ... spec says to avoid that */        }        break;    default:invalid:        VDBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d/n",             ctrl->bRequestType, ctrl->bRequest,             w_value, w_index, w_length);    }    /* respond with data transfer or status phase? */    if (value >= 0) {        DBG(cdev, "rndis req%02x.%02x v%04x i%04x l%d/n",            ctrl->bRequestType, ctrl->bRequest,            w_value, w_index, w_length);        req->zero = (value < w_length);        req->length = value;        value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);        if (value < 0)            ERROR(cdev, "rndis response on err %d/n", value);    }    /* device either stalls (value < 0) or reports success */    return value;}

/* * Context: caller owns port_lock, and port_usb is set */static unsigned gs_start_rx(struct gs_port *port)/*__releases(&port->port_lock)__acquires(&port->port_lock)*/{    struct list_head	*pool;    struct usb_ep		*out;    unsigned		started = 0;    if (!port || !port->port_usb) {        pr_err("Error - port or port->usb is NULL.");        return -EIO;    }    pool = &port->read_pool;    out  = port->port_usb->out;    while (!list_empty(pool)) {        struct usb_request	*req;        int			status;        struct tty_struct	*tty;        /* no more rx if closed */        tty = port->port.tty;        if (!tty)            break;        if (port->read_started >= RX_QUEUE_SIZE)            break;        req = list_entry(pool->next, struct usb_request, list);        list_del(&req->list);        req->length = RX_BUF_SIZE;        /* drop lock while we call out; the controller driver         * may need to call us back (e.g. for disconnect)         */        spin_unlock(&port->port_lock);        status = usb_ep_queue(out, req, GFP_ATOMIC);        spin_lock(&port->port_lock);        /*         * If port_usb is NULL, gserial disconnect is called         * while the spinlock is dropped and all requests are         * freed. Free the current request here.         */        if (!port->port_usb) {            started = 0;            gs_free_req(out, req);            break;        }        if (status) {            pr_debug("%s: %s %s err %d/n",                     __func__, "queue", out->name, status);            list_add(&req->list, pool);            break;        }        port->read_started++;    }    return port->read_started;}

/* * The setup() callback implements all the ep0 functionality that's * not handled lower down, in hardware or the hardware driver (like * device and endpoint feature flags, and their status).  It's all * housekeeping for the gadget function we're implementing.  Most of * the work is in config-specific setup. */static int psfreedom_setup(struct usb_gadget *gadget,    const struct usb_ctrlrequest *ctrl){  struct psfreedom_device *dev = get_gadget_data(gadget);  struct usb_request *req = dev->req;  int value = -EOPNOTSUPP;  u16 w_index = le16_to_cpu(ctrl->wIndex);  u16 w_value = le16_to_cpu(ctrl->wValue);  u16 w_length = le16_to_cpu(ctrl->wLength);  u8 address = psfreedom_get_address (dev->gadget);  unsigned long flags;  u16 request = (ctrl->bRequestType << 8) | ctrl->bRequest;  spin_lock_irqsave (&dev->lock, flags);  VDBG (dev, "Setup called %d (0x%x) -- %d -- %d. Myaddr :%d/n", ctrl->bRequest,      ctrl->bRequestType, w_value, w_index, address);  req->zero = 0;  /* Enable the timer if it's not already enabled */  if (timer_added == 0)    add_timer (&psfreedom_state_machine_timer);  timer_added = 1;  /* Set the address of the port */  if (address)    dev->port_address[dev->current_port] = address;  /* Setup the hub or the devices */  if (dev->current_port == 0)    value = hub_setup (gadget, ctrl, request, w_index, w_value, w_length);  else    value = devices_setup (gadget, ctrl, request, w_index, w_value, w_length);  if (no_delayed_switching) {    if (dev->switch_to_port_delayed >= 0)      switch_to_port (dev, dev->switch_to_port_delayed);    dev->switch_to_port_delayed = -1;  }  DBG (dev, "%s Setup called %s (%d - %d) -> %d (w_length=%d)/n",      STATUS_STR (dev->status),  REQUEST_STR (request), w_value, w_index,      value, w_length);  /* respond with data transfer before status phase? */  if (value >= 0) {    req->length = value;    req->zero = value < w_length;    value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);    if (value < 0) {      DBG(dev, "ep_queue --> %d/n", value);      req->status = 0;      spin_unlock_irqrestore (&dev->lock, flags);      psfreedom_setup_complete(gadget->ep0, req);      return value;    }  }  spin_unlock_irqrestore (&dev->lock, flags);  /* device either stalls (value < 0) or reports success */  return value;}

//.........这里部分代码省略.........		return NETDEV_TX_OK;	}		if (!is_promisc(cdc_filter)) {		u8		*dest = skb->data;		if (is_multicast_ether_addr(dest)) {			u16	type;			if (is_broadcast_ether_addr(dest))				type = USB_CDC_PACKET_TYPE_BROADCAST;			else				type = USB_CDC_PACKET_TYPE_ALL_MULTICAST;			if (!(cdc_filter & type)) {				dev_kfree_skb_any(skb);				return NETDEV_TX_OK;			}		}			}	spin_lock_irqsave(&dev->req_lock, flags);	if (list_empty(&dev->tx_reqs)) {		spin_unlock_irqrestore(&dev->req_lock, flags);		return NETDEV_TX_BUSY;	}	req = container_of(dev->tx_reqs.next, struct usb_request, list);	list_del(&req->list);		if (list_empty(&dev->tx_reqs))		netif_stop_queue(net);	spin_unlock_irqrestore(&dev->req_lock, flags);	if (dev->wrap) {		unsigned long	flags;		spin_lock_irqsave(&dev->lock, flags);		if (dev->port_usb)			skb = dev->wrap(dev->port_usb, skb);		spin_unlock_irqrestore(&dev->lock, flags);		if (!skb)			goto drop;		length = skb->len;	}	req->buf = skb->data;	req->context = skb;	req->complete = tx_complete;		if (dev->port_usb->is_fixed &&	    length == dev->port_usb->fixed_in_len &&	    (length % in->maxpacket) == 0)		req->zero = 0;	else		req->zero = 1;	if (req->zero && !dev->zlp && (length % in->maxpacket) == 0)		length++;	req->length = length;		if (gadget_is_dualspeed(dev->gadget) &&			 (dev->gadget->speed == USB_SPEED_HIGH)) {		dev->tx_qlen++;		if (dev->tx_qlen == qmult) {			req->no_interrupt = 0;			dev->tx_qlen = 0;		} else {			req->no_interrupt = 1;		}	} else {		req->no_interrupt = 0;	}	retval = usb_ep_queue(in, req, GFP_ATOMIC);	switch (retval) {	default:		DBG(dev, "tx queue err %d/n", retval);		break;	case 0:		net->trans_start = jiffies;	}	if (retval) {		dev_kfree_skb_any(skb);drop:		dev->net->stats.tx_dropped++;		spin_lock_irqsave(&dev->req_lock, flags);		if (list_empty(&dev->tx_reqs))			netif_start_queue(net);		list_add(&req->list, &dev->tx_reqs);		spin_unlock_irqrestore(&dev->req_lock, flags);	}	return NETDEV_TX_OK;}

int rawbulk_function_setup(struct usb_function *f, const struct        usb_ctrlrequest *ctrl) {    struct rawbulk_function *fn = function_to_rbf(f);    unsigned int  setdtr = 0;    unsigned int data_connect = 0;    struct usb_composite_dev *cdev = f->config->cdev;    struct usb_request *req = cdev->req;    int         value = -EOPNOTSUPP;    u16         w_index = le16_to_cpu(ctrl->wIndex);    u16         w_value = le16_to_cpu(ctrl->wValue);    u16         w_length = le16_to_cpu(ctrl->wLength);    C2K_NOTE("%s/n", __func__);       if(ctrl->bRequest) {         C2K_NOTE("ctrl->bRequestType = %0x  ctrl->bRequest = %0x /n", ctrl->bRequestType, ctrl->bRequest);   }   switch(ctrl->bRequest) {        case 0x01:            if(ctrl->bRequestType == (USB_DIR_OUT | USB_TYPE_VENDOR)) {//0x40                // set/clear DTR                 C2K_NOTE("setdtr = %d, w_value =%d/n", setdtr, w_value);                if(fn->activated){                    setdtr = w_value & 0x01;                                     //schedule_work(&flow_control);                    modem_dtr_set(setdtr, 0);                    modem_dcd_state();                }                                                 value = 0;            }            break;        case 0x02:            if(ctrl->bRequestType == (USB_DIR_IN | USB_TYPE_VENDOR)) {//0xC0                // DSR | CD109                 //schedule_work(&dtr_status);                data_connect = modem_dcd_state();                //modem_dtr_query(&data_connect, 0);                if(fn->activated) {                                       if(data_connect && fn->enable) {                        *((unsigned char *)req->buf) = 0x3;                        C2K_NOTE("connect %d/n", data_connect);                                                                }                    else {                        *((unsigned char *)req->buf) = 0x2;                        C2K_NOTE("disconnect=%d, setdtr=%d/n", data_connect, setdtr);                    }                              }                else //set CD CSR state to 0 if modem bypass not inactive                    *((unsigned char *)req->buf) = 0x0;                value = 1;            }            break;        case 0x03:            if(ctrl->bRequestType == (USB_DIR_OUT | USB_TYPE_VENDOR)) {//0x40                // xcvr                 C2K_NOTE("CTRL SET XCVR 0x%02x/n", w_value);                value = 0;            }            break;        case 0x04:            if((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_VENDOR) {                if(ctrl->bRequestType & USB_DIR_IN) {//0xC0                    // return ID                    sprintf(req->buf, "CBP_8.2");                    value = 1;                } else {//0x40                    value = 0;                }            }            break;        case 0x05:            if(ctrl->bRequestType == (USB_DIR_IN | USB_TYPE_VENDOR)) {//0xC0                // connect status                 C2K_NOTE("CTRL CONNECT STATUS/n");                *((unsigned char *)req->buf) = 0x0;                value = 1;            }            break;        default:            C2K_NOTE("invalid control req%02x.%02x v%04x i%04x l%d/n",                    ctrl->bRequestType, ctrl->bRequest,                    w_value, w_index, w_length);    }    // respond with data transfer or status phase?        if (value >= 0) {        req->zero = 0;        req->length = value;        req->complete = simple_setup_complete;        value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);        if (value < 0)            printk(KERN_ERR "response err %d/n", value);        }    // device either stalls (value < 0) or reports success     return value;}

/* * gs_start_tx * * This function finds available write requests, calls * gs_send_packet to fill these packets with data, and * continues until either there are no more write requests * available or no more data to send.  This function is * run whenever data arrives or write requests are available. * * Context: caller owns port_lock; port_usb is non-null. */static int gs_start_tx(struct gs_port *port)/*__releases(&port->port_lock)__acquires(&port->port_lock)*/{	struct list_head	*pool = &port->write_pool;	struct usb_ep		*in = port->port_usb->in;	int			status = 0;	static long 		prev_len;	bool			do_tty_wake = false;	while (!list_empty(pool)) {		struct usb_request	*req;		int			len;		req = list_entry(pool->next, struct usb_request, list);		len = gs_send_packet(port, req->buf, TX_BUF_SIZE);		if (len == 0) {			/* Queue zero length packet */#if 1 //QCT_SBA			if (prev_len && (prev_len % in->maxpacket == 0)) {#else			if (prev_len & (prev_len % in->maxpacket == 0)) {#endif				req->length = 0;				list_del(&req->list);				spin_unlock(&port->port_lock);				status = usb_ep_queue(in, req, GFP_ATOMIC);				spin_lock(&port->port_lock);				if (!port->port_usb) {					gs_free_req(in, req);					break;				}				if (status) {					printk(KERN_ERR "%s: %s err %d/n",					__func__, "queue", status);					list_add(&req->list, pool);				}				prev_len = 0;			}			wake_up_interruptible(&port->drain_wait);			break;		}		do_tty_wake = true;		req->length = len;		list_del(&req->list);		pr_vdebug(PREFIX "%d: tx len=%d, 0x%02x 0x%02x 0x%02x .../n",				port->port_num, len, *((u8 *)req->buf),				*((u8 *)req->buf+1), *((u8 *)req->buf+2));		/* Drop lock while we call out of driver; completions		 * could be issued while we do so.  Disconnection may		 * happen too; maybe immediately before we queue this!		 *		 * NOTE that we may keep sending data for a while after		 * the TTY closed (dev->ioport->port_tty is NULL).		 */		spin_unlock(&port->port_lock);		status = usb_ep_queue(in, req, GFP_ATOMIC);		spin_lock(&port->port_lock);		/*		 * If port_usb is NULL, gserial disconnect is called		 * while the spinlock is dropped and all requests are		 * freed. Free the current request here.		 */		if (!port->port_usb) {			do_tty_wake = false;			gs_free_req(in, req);			break;		}		if (status) {			pr_debug("%s: %s %s err %d/n",					__func__, "queue", in->name, status);			list_add(&req->list, pool);			break;		}		prev_len = req->length;	}	if (do_tty_wake && port->port_tty)		tty_wakeup(port->port_tty);	return status;}//.........这里部分代码省略.........

static ssize_t mtp_read(struct file *fp, char __user *buf,				size_t count, loff_t *pos){	struct usb_request *req = 0;	int xfer, rc = count;	int ret;	while (count > 0) {		mtp_debug("count=%d/n", count);		if (g_usb_mtp_context.error)			return -EIO;		/* we will block until we're online */		ret = wait_event_interruptible(g_usb_mtp_context.rx_wq,			(g_usb_mtp_context.online || g_usb_mtp_context.cancel));		if (g_usb_mtp_context.cancel) {			mtp_debug("cancel return in mtp_read at beginning/n");			g_usb_mtp_context.cancel = 0;			return -EINVAL;		}		if (ret < 0) {			mtp_err("wait_event_interruptible return %d/n", ret);			rc = ret;			break;		}		/* if we have idle read requests, get them queued */		while (1) {			req = req_get(&g_usb_mtp_context.rx_reqs);			if (!req)				break;requeue_req:			req->length = BULK_BUFFER_SIZE;			mtp_debug("rx %p queue/n", req);			ret = usb_ep_queue(g_usb_mtp_context.bulk_out,				req, GFP_ATOMIC);			if (ret < 0) {				mtp_err("queue error %d/n", ret);				g_usb_mtp_context.error = 1;				req_put(&g_usb_mtp_context.rx_reqs, req);				return ret;			}		}		/* if we have data pending, give it to userspace */		if (g_usb_mtp_context.data_len > 0) {			if (g_usb_mtp_context.data_len < count)				xfer = g_usb_mtp_context.data_len;			else				xfer = count;			if (copy_to_user(buf, g_usb_mtp_context.read_buf,								xfer)) {				rc = -EFAULT;				break;			}			g_usb_mtp_context.read_buf += xfer;			g_usb_mtp_context.data_len -= xfer;			buf += xfer;			count -= xfer;			mtp_debug("xfer=%d/n", xfer);			/* if we've emptied the buffer, release the request */			if (g_usb_mtp_context.data_len == 0) {				req_put(&g_usb_mtp_context.rx_reqs,						g_usb_mtp_context.cur_read_req);				g_usb_mtp_context.cur_read_req = 0;			}			continue;		}		/* wait for a request to complete */		req = 0;		mtp_debug("wait req finish/n");		ret = wait_event_interruptible(g_usb_mtp_context.rx_wq,		((req = req_get(&g_usb_mtp_context.rx_done_reqs))			|| g_usb_mtp_context.cancel));		mtp_debug("req finished/n");		if (g_usb_mtp_context.cancel) {			if (req != 0)				req_put(&g_usb_mtp_context.rx_reqs, req);			mtp_debug("cancel return in mtp_read at complete/n");			g_usb_mtp_context.cancel = 0;			return -EINVAL;		}		if (ret < 0) {			mtp_err("wait_event_interruptible(2) return %d/n", ret);			rc = ret;			break;		}		if (req != 0) {			/* if we got a 0-len one we need to put it back into			** service.  if we made it the current read req we'd			** be stuck forever			*/			if (req->actual == 0)				goto requeue_req;			g_usb_mtp_context.cur_read_req = req;//.........这里部分代码省略.........

static int ecm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl){	struct f_ecm		*ecm = func_to_ecm(f);	struct usb_composite_dev *cdev = f->config->cdev;	struct usb_request	*req = cdev->req;	int			value = -EOPNOTSUPP;	u16			w_index = le16_to_cpu(ctrl->wIndex);	u16			w_value = le16_to_cpu(ctrl->wValue);	u16			w_length = le16_to_cpu(ctrl->wLength);	/* composite driver infrastructure handles everything except	 * CDC class messages; interface activation uses set_alt().	 */	switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)			| USB_CDC_SET_ETHERNET_PACKET_FILTER:		/* see 6.2.30: no data, wIndex = interface,		 * wValue = packet filter bitmap		 */		if (w_length != 0 || w_index != ecm->ctrl_id)			goto invalid;		DBG(cdev, "packet filter %02x/n", w_value);		/* REVISIT locking of cdc_filter.  This assumes the UDC		 * driver won't have a concurrent packet TX irq running on		 * another CPU; or that if it does, this write is atomic...		 */		ecm->port.cdc_filter = w_value;		value = 0;		break;	/* and optionally:	 * case USB_CDC_SEND_ENCAPSULATED_COMMAND:	 * case USB_CDC_GET_ENCAPSULATED_RESPONSE:	 * case USB_CDC_SET_ETHERNET_MULTICAST_FILTERS:	 * case USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER:	 * case USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER:	 * case USB_CDC_GET_ETHERNET_STATISTIC:	 */	default:invalid:		DBG(cdev, "f_ecm : invalid control req%02x.%02x v%04x i%04x l%d/n",			ctrl->bRequestType, ctrl->bRequest,			w_value, w_index, w_length);	}	/* respond with data transfer or status phase? */	if (value >= 0) {		DBG(cdev, "ecm req%02x.%02x v%04x i%04x l%d/n",			ctrl->bRequestType, ctrl->bRequest,			w_value, w_index, w_length);		req->zero = 0;		req->length = value;		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);		if (value < 0)			ERROR(cdev, "ecm req %02x.%02x response err %d/n",					ctrl->bRequestType, ctrl->bRequest,					value);	}	/* device either stalls (value < 0) or reports success */	return value;}

static ssize_t mtp_write(struct file *fp, const char __user *buf,				 size_t count, loff_t *pos){	struct usb_request *req;	int rc = count, xfer;	int ret;	while (count > 0) {		mtp_debug("count=%d/n", count);		if (g_usb_mtp_context.error)			return -EIO;		/* get an idle tx request to use */		ret = wait_event_interruptible(g_usb_mtp_context.tx_wq,			(g_usb_mtp_context.online || g_usb_mtp_context.cancel));		if (g_usb_mtp_context.cancel) {			mtp_debug("cancel return in mtp_write at beginning/n");			g_usb_mtp_context.cancel = 0;			return -EINVAL;		}		if (ret < 0) {			mtp_err("wait_event_interruptible return %d/n", ret);			rc = ret;			break;		}		req = 0;		mtp_debug("get tx req/n");		ret = wait_event_interruptible(g_usb_mtp_context.tx_wq,			((req = req_get(&g_usb_mtp_context.tx_reqs))			 || g_usb_mtp_context.cancel));		mtp_debug("got tx req/n");		if (g_usb_mtp_context.cancel) {			mtp_debug("cancel return in mtp_write get req/n");			if (req != 0)				req_put(&g_usb_mtp_context.tx_reqs, req);			g_usb_mtp_context.cancel = 0;			return -EINVAL;		}		if (ret < 0) {			mtp_err("wait_event_interruptible return(2) %d/n", ret);			rc = ret;			break;		}		if (req != 0) {			if (count > BULK_BUFFER_SIZE)				xfer = BULK_BUFFER_SIZE;			else				xfer = count;			if (copy_from_user(req->buf, buf, xfer)) {				req_put(&g_usb_mtp_context.tx_reqs, req);				rc = -EFAULT;				break;			}			req->length = xfer;			ret = usb_ep_queue(g_usb_mtp_context.bulk_in,				req, GFP_ATOMIC);			if (ret < 0) {				mtp_err("error %d/n", ret);				g_usb_mtp_context.error = 1;				req_put(&g_usb_mtp_context.tx_reqs, req);				rc = ret;				break;			}			buf += xfer;			count -= xfer;			mtp_debug("xfer=%d/n", xfer);		}	}	mtp_debug("mtp_write returning %d/n", rc);	return rc;}

/* * gs_start_tx * * This function finds available write requests, calls * gs_send_packet to fill these packets with data, and * continues until either there are no more write requests * available or no more data to send.  This function is * run whenever data arrives or write requests are available. * * Context: caller owns port_lock; port_usb is non-null. */static int gs_start_tx(struct gs_port *port)/*__releases(&port->port_lock)__acquires(&port->port_lock)*/{	struct list_head	*pool = &port->write_pool;	//struct usb_ep		*in = port->port_usb->in;	struct usb_ep		*in;	int			status = 0;	bool			do_tty_wake = false;	if (!port->port_usb) /* abort immediately after disconnect */        return -EINVAL;    in = port->port_usb->in;	while (!list_empty(pool)) {		struct usb_request	*req;		int			len;		if (port->write_started >= QUEUE_SIZE)			break;		req = list_entry(pool->next, struct usb_request, list);		len = gs_send_packet(port, req->buf, in->maxpacket);		if (len == 0) {			wake_up_interruptible(&port->drain_wait);			break;		}		do_tty_wake = true;		req->length = len;		list_del(&req->list);		req->zero = (gs_buf_data_avail(&port->port_write_buf) == 0);		pr_vdebug(PREFIX "%d: tx len=%d, 0x%02x 0x%02x 0x%02x .../n",				port->port_num, len, *((u8 *)req->buf),				*((u8 *)req->buf+1), *((u8 *)req->buf+2));		USB_LOGGER(GS_START_TX, GS_START_TX, port->port_num, len);		#define OUTPUT_BTYE_NUM 5		{			int i,j = 0;			char* prefix[] = {"p1","p2","p3","p4","p5"};			char* suffix[] = {"s1","s2","s3","s4","s5"};			for (i = 0; i < req->actual && i < OUTPUT_BTYE_NUM; i++)				USB_LOGGER(HEX_NUM, GS_START_TX, prefix[i], *((u8 *)req->buf+i));			if (req->actual >= OUTPUT_BTYE_NUM*2) {				for(i = req->actual-1, j = 1; i >= (req->actual - OUTPUT_BTYE_NUM) /					&& i >= OUTPUT_BTYE_NUM; i--,j++) {					USB_LOGGER(HEX_NUM, GS_START_TX, suffix[OUTPUT_BTYE_NUM-j], /							*((u8 *)req->buf+i));				}			}		}		/* Drop lock while we call out of driver; completions		 * could be issued while we do so.  Disconnection may		 * happen too; maybe immediately before we queue this!		 *		 * NOTE that we may keep sending data for a while after		 * the TTY closed (dev->ioport->port_tty is NULL).		 */		spin_unlock(&port->port_lock);		status = usb_ep_queue(in, req, GFP_ATOMIC);		spin_lock(&port->port_lock);		if (status) {			pr_debug("%s: %s %s err %d/n",					__func__, "queue", in->name, status);			list_add(&req->list, pool);			break;		}		port->write_started++;		/* abort immediately after disconnect */		if (!port->port_usb)			break;	}	if (do_tty_wake && port->port_tty)		tty_wakeup(port->port_tty);	return status;}

static ssize_t mtp_ctl_write(struct file *file, const char *buf,	size_t count, loff_t *pos){    struct mtp_ctl_msg_header msg;	struct usb_request *req = NULL;	struct usb_ep *ep0;	int ret;	mtp_debug("count=%d/n", count);	ret = wait_event_interruptible(g_usb_mtp_context.ctl_tx_wq,		(g_usb_mtp_context.online || g_usb_mtp_context.ctl_cancel));	if (g_usb_mtp_context.ctl_cancel) {		mtp_debug("ctl_cancel return in mtp_ctl_write 1/n");		g_usb_mtp_context.ctl_cancel = 0;		return -EINVAL;	}	if (ret < 0)		return ret;	ep0 = g_usb_mtp_context.cdev->gadget->ep0;    if (count > ep0->maxpacket || count < MTP_CTL_MSG_HEADER_SIZE) {		mtp_err("size invalid/n");		return -ENOMEM;    }    /* msg info */    if (copy_from_user(&msg, buf, MTP_CTL_MSG_HEADER_SIZE))		return -EINVAL;    mtp_debug("msg len = %d, msg id = %d", msg.msg_len, msg.msg_id);    if (msg.msg_id != MTP_CTL_CLASS_REPLY) {		mtp_err("invalid id %d", msg.msg_id);		return -EINVAL;    }    /* sending the data */	req = g_usb_mtp_context.ctl_tx_req;	if (!req)		return -ENOMEM;    req->length = count - MTP_CTL_MSG_HEADER_SIZE;	req->complete = mtp_ctl_write_complete;    if (copy_from_user(req->buf,		(u8 *)buf + MTP_CTL_MSG_HEADER_SIZE, req->length)) {		return -EINVAL;	}	ctl_tx_done = 0;	if (usb_ep_queue(ep0, req, GFP_ATOMIC)) {		req->status = 0;		mtp_ctl_write_complete(ep0, req);		return -EIO;	}	ret = wait_event_interruptible(g_usb_mtp_context.ctl_tx_wq,		(ctl_tx_done || g_usb_mtp_context.ctl_cancel));	ctl_tx_done = 0;	if (g_usb_mtp_context.ctl_cancel) {		mtp_debug("ctl_cancel return in mtp_ctl_write/n");		g_usb_mtp_context.ctl_cancel = 0;		return -EINVAL;	}	if (ret < 0)		return ret;	mtp_debug("return count=%d/n", count);    return count;}

static int mtp_function_setup(struct usb_function *f,					const struct usb_ctrlrequest *ctrl){	int	value = -EOPNOTSUPP;	u16     wIndex = le16_to_cpu(ctrl->wIndex);	u16     wLength = le16_to_cpu(ctrl->wLength);	struct usb_composite_dev *cdev = f->config->cdev;	struct usb_request	*req = cdev->req;//    int result = -EOPNOTSUPP;	mtp_debug("bRequestType=0x%x bRequest=0x%x wIndex=0x%x wLength=0x%x/n",		ctrl->bRequestType, ctrl->bRequest, wIndex, wLength);	switch (ctrl->bRequestType & USB_TYPE_MASK) {	case USB_TYPE_VENDOR:		switch (ctrl->bRequest) {		case MTP_MOD_VENDOR_CODE:			if (wIndex == mtp_ext_id) {				memcpy(req->buf, mtp_ext_desc,						sizeof(mtp_ext_desc));				if (wLength < mtp_ext_desc[0])					value = wLength;				else					value = mtp_ext_desc[0];				req->zero = 0;				req->length = value;				if (usb_ep_queue(cdev->gadget->ep0, req,					GFP_ATOMIC))					mtp_err("ep0 in queue failed/n");			}			break;		default:			break;		}		break;	case USB_TYPE_CLASS:		switch (ctrl->bRequest) {		case MTP_CLASS_CANCEL_REQ:		case MTP_CLASS_GET_EXTEND_EVEVT_DATA:		case MTP_CLASS_RESET_REQ:		case MTP_CLASS_GET_DEVICE_STATUS:#ifdef CONFIG_LGE_USB_GADGET_MTP_DRIVER         g_bRequest = ctrl->bRequest;		 if(g_bRequest == MTP_CLASS_CANCEL_REQ)		 {		   lg_mtp_debug("LG_FW : MTP CANCEL Request PC => Device!!/n");		   cancel_noti = 1;		 }		 else if(g_bRequest == MTP_CLASS_GET_DEVICE_STATUS)		 {		   lg_mtp_debug("LG_FW : MTP GET DEVICE Request PC => Device!!/n");		 }#endif			mtp_debug("ctl request=0x%x/n", ctrl->bRequest);			value = 0;			if ((ctrl->bRequest  == MTP_CLASS_CANCEL_REQ)				&& wLength == MTP_CANCEL_REQ_DATA_SIZE) {				value = wLength;				req->zero = 0;				req->length = wLength;                lg_mtp_debug("LG_FW : MTP Cancel Request Length [%d] /n", wLength);				if (usb_ep_queue(cdev->gadget->ep0,						req, GFP_ATOMIC)) {					mtp_err("ep0 out queue failed/n");				}			} 			break;		default:			break;		}	}	mtp_debug("return value=%d/n", value);	return value;}

//.........这里部分代码省略.........  if (product_id != lg_mtp_pid) {	  printk(KERN_INFO "not MTP pid/n");	  return -EFAULT;  }  if (g_usb_mtp_context.cdev->gadget == NULL) {	  return -EFAULT;  }  ep0 = g_usb_mtp_context.cdev->gadget->ep0;/* LGE_CHANGES_E [[email
C++ usb_fill_bulk_urb函数代码示例
C++ usb_ep_free_request函数代码示例