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

void gobi_usbnet_tx_timeout_3_0_6 (struct net_device *net){   struct usbnet		*dev = netdev_priv(net);#ifdef TX_URB_MONITOR   int count = 0;      int iRet = -1;   unsigned char b_usb_if_num = 0;   // Get the USB interface   iRet = get_usb_interface_from_device (dev, &b_usb_if_num);	   count = unlink_urbs (dev, &dev->txq);   tasklet_schedule (&dev->bh);   if ((URB_monitor) && (0==iRet))   {       while (count)	   {			URB_monitor(false, b_usb_if_num);			count--;	   }   }#else // TX_URB_MONITOR   unlink_urbs (dev, &dev->txq);   tasklet_schedule (&dev->bh);#endif // TX_URB_MONITOR   // FIXME: device recovery -- reset?}

// precondition: never called in_interruptstatic void usbnet_terminate_urbs(struct usbnet *dev){	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);	DECLARE_WAITQUEUE(wait, current);	int temp;	/* ensure there are no more active urbs */	add_wait_queue(&unlink_wakeup, &wait);	set_current_state(TASK_UNINTERRUPTIBLE);	dev->wait = &unlink_wakeup;	temp = unlink_urbs(dev, &dev->txq) +		unlink_urbs(dev, &dev->rxq);	/* maybe wait for deletions to finish. */	while (!skb_queue_empty(&dev->rxq)		&& !skb_queue_empty(&dev->txq)		&& !skb_queue_empty(&dev->done)) {			schedule_timeout(UNLINK_TIMEOUT_MS);			set_current_state(TASK_UNINTERRUPTIBLE);			netif_dbg(dev, ifdown, dev->net,				  "waited for %d urb completions/n", temp);	}	set_current_state(TASK_RUNNING);	dev->wait = NULL;	remove_wait_queue(&unlink_wakeup, &wait);}

void usbnet_unlink_rx_urbs(struct usbnet *dev){	if (netif_running(dev->net)) {		(void) unlink_urbs (dev, &dev->rxq);		tasklet_schedule(&dev->bh);	}}

void usbnet_unlink_rx_urbs(struct usbnet *dev){	if (netif_running(dev->net)) {		(void) unlink_urbs (dev, &dev->rxq);		queue_work(usbnet_wq, &dev->bh_w);	}}

void usbnet_tx_timeout (struct net_device *net){	struct usbnet		*dev = netdev_priv(net);	unlink_urbs (dev, &dev->txq);	tasklet_schedule (&dev->bh);	// FIXME: device recovery -- reset?}

void usbnet_tx_timeout (struct net_device *net){	struct usbnet		*dev = netdev_priv(net);	unlink_urbs (dev, &dev->txq);	queue_work(usbnet_wq, &dev->bh_w);	// FIXME: device recovery -- reset?}

int usbnet_suspend (struct usb_interface *intf, pm_message_t message){	struct usbnet		*dev = usb_get_intfdata(intf);	if (!dev->suspend_count++) {#if defined(CONFIG_ERICSSON_F3307_ENABLE)		spin_lock_irq(&dev->txq.lock);		/* don't autosuspend while transmitting */		if (dev->txq.qlen && (message.event & PM_EVENT_AUTO)) {			spin_unlock_irq(&dev->txq.lock);			return -EBUSY;		} else {			set_bit(EVENT_DEV_ASLEEP, &dev->flags);			spin_unlock_irq(&dev->txq.lock);		}#endif		/*		 * accelerate emptying of the rx and queues, to avoid		 * having everything error out.		 */		netif_device_detach (dev->net);#if !defined(CONFIG_ERICSSON_F3307_ENABLE)		(void) unlink_urbs (dev, &dev->rxq);		(void) unlink_urbs (dev, &dev->txq);#else		usbnet_terminate_urbs(dev);		usb_kill_urb(dev->interrupt);#endif		/*		 * reattach so runtime management can use and		 * wake the device		 */		netif_device_attach (dev->net);	}	return 0;}

static void suspend_timeout(unsigned long data){#ifdef CONFIG_NO_USB_SUSPEND_RESUME	return;#else#ifdef CONFIG_DSPLOG_USB	/*		 This will prevent the case that suspend port when doing dsplog. 		 this is a temporary solution for the case of dsplog and ipc function simultaneously.	 */	if(dsplog_active)   		return;#endif	if(!usb_host_resumed)	{		printk("/n!!!suspend timer has been started. however host not resumed/n");		return;	}	if( !(UHCRHPS3 & 0x2))        {                printk("/n suspend_timeout:port has been disabled./n");                return;        }	if((bvd_ipc->suspend_flag == 1))	{		bvd_ipc->suspend_flag = 0;		mod_timer(&suspend_timer, jiffies+(IPC_USB_SUSPEND_INTERVAL*HZ/1000));		bvd_dbg("suspend_timeout: add the suspend timer again");		}else	{		unlink_urbs(&bvd_ipc->readurb_mux);		clear_BLE();		mdelay(1);		UHCRHPS3 = 0x4;		bvd_dbg("suspend_timeout: send SUSPEND cmd! UHCRHPS3=0x%x/n", UHCRHPS3);		while(!(UHCRHPS3 & 0x4)) mdelay(1);//		ipc_traffic = 0;		host_port_suspended = 1;		printk("ipc-suspend/n");		if(in_bprdy_interrupt())			clear_in_bprdy_interrupt();	}#endif}

/* work that cannot be done in interrupt context uses keventd. * * NOTE:  with 2.5 we could do more of this using completion callbacks, * especially now that control transfers can be queued. */static voidkevent (struct work_struct *work){	struct usbnet		*dev =		container_of(work, struct usbnet, kevent);	int			status;	/* usb_clear_halt() needs a thread context */	if (test_bit (EVENT_TX_HALT, &dev->flags)) {		unlink_urbs (dev, &dev->txq);		status = usb_autopm_get_interface(dev->intf);		if (status < 0)			goto fail_pipe;		status = usb_clear_halt (dev->udev, dev->out);		usb_autopm_put_interface(dev->intf);		if (status < 0 &&		    status != -EPIPE &&		    status != -ESHUTDOWN) {			if (netif_msg_tx_err (dev))fail_pipe:				netdev_err(dev->net, "can't clear tx halt, status %d/n",					   status);		} else {			clear_bit (EVENT_TX_HALT, &dev->flags);			if (status != -ESHUTDOWN)				netif_wake_queue (dev->net);		}	}	if (test_bit (EVENT_RX_HALT, &dev->flags)) {		unlink_urbs (dev, &dev->rxq);		status = usb_autopm_get_interface(dev->intf);		if (status < 0)			goto fail_halt;		status = usb_clear_halt (dev->udev, dev->in);		usb_autopm_put_interface(dev->intf);		if (status < 0 &&		    status != -EPIPE &&		    status != -ESHUTDOWN) {			if (netif_msg_rx_err (dev))fail_halt:				netdev_err(dev->net, "can't clear rx halt, status %d/n",					   status);		} else {			clear_bit (EVENT_RX_HALT, &dev->flags);			tasklet_schedule (&dev->bh);		}	}	/* tasklet could resubmit itself forever if memory is tight */	if (test_bit (EVENT_RX_MEMORY, &dev->flags)) {		struct urb	*urb = NULL;		if (netif_running (dev->net))			urb = usb_alloc_urb (0, GFP_KERNEL);		else			clear_bit (EVENT_RX_MEMORY, &dev->flags);		if (urb != NULL) {			clear_bit (EVENT_RX_MEMORY, &dev->flags);			status = usb_autopm_get_interface(dev->intf);			if (status < 0)				goto fail_lowmem;			rx_submit (dev, urb, GFP_KERNEL);			usb_autopm_put_interface(dev->intf);fail_lowmem:			tasklet_schedule (&dev->bh);		}	}	if (test_bit (EVENT_LINK_RESET, &dev->flags)) {		struct driver_info	*info = dev->driver_info;		int			retval = 0;		clear_bit (EVENT_LINK_RESET, &dev->flags);		status = usb_autopm_get_interface(dev->intf);		if (status < 0)			goto skip_reset;		if(info->link_reset && (retval = info->link_reset(dev)) < 0) {			usb_autopm_put_interface(dev->intf);skip_reset:			netdev_info(dev->net, "link reset failed (%d) usbnet usb-%s-%s, %s/n",				    retval,				    dev->udev->bus->bus_name,				    dev->udev->devpath,				    info->description);		} else {			usb_autopm_put_interface(dev->intf);		}	}	if (dev->flags)		netdev_dbg(dev->net, "kevent done, flags = 0x%lx/n", dev->flags);}

static void kevent(void *data){	struct usbnet *dev = (struct usbnet *)data;#elsestatic void kevent(struct work_struct *work){	struct usbnet		*dev =		container_of(work, struct usbnet, kevent);#endif	int			status;	/* usb_clear_halt() needs a thread context */	if (test_bit(EVENT_TX_HALT, &dev->flags)) {		unlink_urbs(dev, &dev->txq);		status = usb_clear_halt(dev->udev, dev->out);		if (status < 0				&& status != -EPIPE				&& status != -ESHUTDOWN) {			if (netif_msg_tx_err(dev))				deverr(dev, "can't clear tx halt, status %d",				       status);		} else {			clear_bit(EVENT_TX_HALT, &dev->flags);			if (status != -ESHUTDOWN)				netif_wake_queue(dev->net);		}	}	if (test_bit(EVENT_RX_HALT, &dev->flags)) {		unlink_urbs(dev, &dev->rxq);		status = usb_clear_halt(dev->udev, dev->in);		if (status < 0				&& status != -EPIPE				&& status != -ESHUTDOWN) {			if (netif_msg_rx_err(dev))				deverr(dev, "can't clear rx halt, status %d",				       status);		} else {			clear_bit(EVENT_RX_HALT, &dev->flags);			tasklet_schedule(&dev->bh);		}	}	/* tasklet could resubmit itself forever if memory is tight */	if (test_bit(EVENT_RX_MEMORY, &dev->flags)) {		struct urb	*urb = NULL;		if (netif_running(dev->net))			urb = usb_alloc_urb(0, GFP_KERNEL);		else			clear_bit(EVENT_RX_MEMORY, &dev->flags);		if (urb != NULL) {			clear_bit(EVENT_RX_MEMORY, &dev->flags);#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 14)			urb->transfer_flags |= URB_ASYNC_UNLINK;#endif			rx_submit(dev, urb, GFP_KERNEL);			tasklet_schedule(&dev->bh);		}	}	if (test_bit(EVENT_LINK_RESET, &dev->flags)) {		struct driver_info	*info = dev->driver_info;		int			retval = 0;		clear_bit(EVENT_LINK_RESET, &dev->flags);		if (info->link_reset) {			retval = info->link_reset(dev);			if (retval < 0) {				devinfo(dev,					"link reset failed (%d) usbnet usb-%s-%s, %s",					retval,					dev->udev->bus->bus_name,					dev->udev->devpath,					info->description);			}		}	}	if (dev->flags)		devdbg(dev, "kevent done, flags = 0x%lx", dev->flags);}/*-------------------------------------------------------------------------*/#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)static void tx_complete(struct urb *urb, struct pt_regs *regs)#elsestatic void tx_complete(struct urb *urb)#endif{	struct sk_buff		*skb = (struct sk_buff *) urb->context;	struct skb_data		*entry = (struct skb_data *) skb->cb;	struct usbnet		*dev = entry->dev;	if (urb->status == 0) {		dev->stats.tx_packets++;		dev->stats.tx_bytes += entry->length;//.........这里部分代码省略.........

staticint axusbnet_stop(struct net_device *net){	struct usbnet		*dev = netdev_priv(net);	struct driver_info	*info = dev->driver_info;	int			temp;	int			retval;#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 18)	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);#else	DECLARE_WAIT_QUEUE_HEAD(unlink_wakeup);#endif	DECLARE_WAITQUEUE(wait, current);	netif_stop_queue(net);	if (netif_msg_ifdown(dev))		devinfo(dev, "stop stats: rx/tx %ld/%ld, errs %ld/%ld",			dev->stats.rx_packets, dev->stats.tx_packets,			dev->stats.rx_errors, dev->stats.tx_errors);	/* allow minidriver to stop correctly (wireless devices to turn off	 * radio etc) */	if (info->stop) {		retval = info->stop(dev);		if (retval < 0 && netif_msg_ifdown(dev))			devinfo(dev,				"stop fail (%d) usbnet usb-%s-%s, %s",				retval,				dev->udev->bus->bus_name, dev->udev->devpath,				info->description);	}	if (!(info->flags & FLAG_AVOID_UNLINK_URBS)) {		/* ensure there are no more active urbs */		add_wait_queue(&unlink_wakeup, &wait);		dev->wait = &unlink_wakeup;		temp = unlink_urbs(dev, &dev->txq) +			unlink_urbs(dev, &dev->rxq);		/* maybe wait for deletions to finish. */		while (!skb_queue_empty(&dev->rxq)				&& !skb_queue_empty(&dev->txq)				&& !skb_queue_empty(&dev->done)) {			msleep(UNLINK_TIMEOUT_MS);			if (netif_msg_ifdown(dev))				devdbg(dev, "waited for %d urb completions",				       temp);		}		dev->wait = NULL;		remove_wait_queue(&unlink_wakeup, &wait);	}	usb_kill_urb(dev->interrupt);	/* deferred work (task, timer, softirq) must also stop.	 * can't flush_scheduled_work() until we drop rtnl (later),	 * else workers could deadlock; so make workers a NOP.	 */	dev->flags = 0;	del_timer_sync(&dev->delay);	tasklet_kill(&dev->bh);	return 0;}

/* work that cannot be done in interrupt context uses keventd. * * NOTE:  with 2.5 we could do more of this using completion callbacks, * especially now that control transfers can be queued. */static voidkevent (struct work_struct *work){	struct usbnet		*dev =		container_of(work, struct usbnet, kevent);	int			status;	/* usb_clear_halt() needs a thread context */	if (test_bit (EVENT_TX_HALT, &dev->flags)) {		unlink_urbs (dev, &dev->txq);		status = usb_autopm_get_interface(dev->intf);		if (status < 0)			goto fail_pipe;		status = usb_clear_halt (dev->udev, dev->out);		usb_autopm_put_interface(dev->intf);		if (status < 0 &&		    status != -EPIPE &&		    status != -ESHUTDOWN) {			if (netif_msg_tx_err (dev))fail_pipe:				netdev_err(dev->net, "can't clear tx halt, status %d/n",					   status);		} else {			clear_bit (EVENT_TX_HALT, &dev->flags);			if (status != -ESHUTDOWN)				netif_wake_queue (dev->net);		}	}	if (test_bit (EVENT_RX_HALT, &dev->flags)) {		//HTC+++		//lock cpu perf		usbnet_lock_perf();		//queue usbnet_unlock_perf_delayed_work		usbnet_rx_len = 0;		schedule_delayed_work(&usbnet_unlock_perf_delayed_work, msecs_to_jiffies(PM_QOS_USBNET_PERF_UNLOCK_TIMER));		pr_info("%s(%d) [USBNET] EVENT_RX_HALT unlink_urbs !!!/n", __func__, __LINE__);		pr_info("%s(%d) [USBNET] dev->rxq.qlen:%d/n", __func__, __LINE__, dev->rxq.qlen);		//HTC---		unlink_urbs (dev, &dev->rxq);		status = usb_autopm_get_interface(dev->intf);		if (status < 0)			goto fail_halt;		status = usb_clear_halt (dev->udev, dev->in);		//HTC+++		pr_info("%s(%d) [USBNET] EVENT_RX_HALT usb_clear_halt:%d !!!/n", __func__, __LINE__, status);		//HTC---		usb_autopm_put_interface(dev->intf);		if (status < 0 &&		    status != -EPIPE &&		    status != -ESHUTDOWN) {			if (netif_msg_rx_err (dev))fail_halt:				netdev_err(dev->net, "can't clear rx halt, status %d/n",					   status);		} else {			//HTC+++			pr_info("%s(%d) [USBNET] clear_bit EVENT_RX_HALT !!!/n", __func__, __LINE__);			//HTC---			clear_bit (EVENT_RX_HALT, &dev->flags);			tasklet_schedule (&dev->bh);		}	}	/* tasklet could resubmit itself forever if memory is tight */	if (test_bit (EVENT_RX_MEMORY, &dev->flags)) {		struct urb	*urb = NULL;		int resched = 1;		if (netif_running (dev->net))			urb = usb_alloc_urb (0, GFP_KERNEL);		else			clear_bit (EVENT_RX_MEMORY, &dev->flags);		if (urb != NULL) {			clear_bit (EVENT_RX_MEMORY, &dev->flags);			status = usb_autopm_get_interface(dev->intf);			if (status < 0) {				usb_free_urb(urb);				goto fail_lowmem;			}			if (rx_submit (dev, urb, GFP_KERNEL) == -ENOLINK)				resched = 0;			usb_autopm_put_interface(dev->intf);fail_lowmem:			if (resched)				tasklet_schedule (&dev->bh);		}	}	if (test_bit (EVENT_LINK_RESET, &dev->flags)) {		struct driver_info	*info = dev->driver_info;//.........这里部分代码省略.........