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

static int btusb_close(struct hci_dev *hdev){	struct btusb_data *data = hdev->driver_data;	int err;	BT_DBG("%s", hdev->name);	if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))		return 0;	cancel_work_sync(&data->work);	cancel_work_sync(&data->waker);	clear_bit(BTUSB_ISOC_RUNNING, &data->flags);	clear_bit(BTUSB_BULK_RUNNING, &data->flags);	clear_bit(BTUSB_INTR_RUNNING, &data->flags);	btusb_stop_traffic(data);	err = usb_autopm_get_interface(data->intf);	if (err < 0)		goto failed;	data->intf->needs_remote_wakeup = 0;	usb_autopm_put_interface(data->intf);failed:	usb_scuttle_anchored_urbs(&data->deferred);	return 0;}

void ctrl_bridge_disconnect(unsigned int id){	struct ctrl_bridge	*dev = __dev[id];	dev_dbg(&dev->intf->dev, "%s:/n", __func__);	/*set device name to none to get correct channel id	 * at the time of bridge open	 */	dev->name = "none";	platform_device_unregister(dev->pdev);	usb_scuttle_anchored_urbs(&dev->tx_deferred);	usb_kill_anchored_urbs(&dev->tx_submitted);	usb_kill_urb(dev->inturb);	usb_kill_urb(dev->readurb);	kfree(dev->in_ctlreq);	kfree(dev->readbuf);	kfree(dev->intbuf);	usb_free_urb(dev->readurb);	usb_free_urb(dev->inturb);}

static int btusb_resume(struct usb_interface *intf){	struct btusb_data *data = usb_get_intfdata(intf);	struct hci_dev *hdev = data->hdev;	int err = 0;	BT_DBG("intf %p", intf);	if (--data->suspend_count)		return 0;	if (!test_bit(HCI_RUNNING, &hdev->flags))		goto done;	if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {		err = btusb_submit_intr_urb(hdev, GFP_NOIO);		if (err < 0) {			clear_bit(BTUSB_INTR_RUNNING, &data->flags);			goto failed;		}	}	if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {		err = btusb_submit_bulk_urb(hdev, GFP_NOIO);		if (err < 0) {			clear_bit(BTUSB_BULK_RUNNING, &data->flags);			goto failed;		}		btusb_submit_bulk_urb(hdev, GFP_NOIO);	}	if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {		if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0)			clear_bit(BTUSB_ISOC_RUNNING, &data->flags);		else			btusb_submit_isoc_urb(hdev, GFP_NOIO);	}	spin_lock_irq(&data->txlock);	play_deferred(data);	clear_bit(BTUSB_SUSPENDING, &data->flags);	spin_unlock_irq(&data->txlock);	schedule_work(&data->work);	return 0;failed:	usb_scuttle_anchored_urbs(&data->deferred);done:	spin_lock_irq(&data->txlock);	clear_bit(BTUSB_SUSPENDING, &data->flags);	spin_unlock_irq(&data->txlock);	return err;}

static int carl9170_usb_init_rx_bulk_urbs(struct ar9170 *ar){	struct urb *urb;	int i, err = -EINVAL;	/*	 * The driver actively maintains a second shadow	 * pool for inactive, but fully-prepared rx urbs.	 *	 * The pool should help the driver to master huge	 * workload spikes without running the risk of	 * undersupplying the hardware or wasting time by	 * processing rx data (streams) inside the urb	 * completion (hardirq context).	 */	for (i = 0; i < AR9170_NUM_RX_URBS_POOL; i++) {		urb = carl9170_usb_alloc_rx_urb(ar, GFP_KERNEL);		if (!urb) {			err = -ENOMEM;			goto err_out;		}		usb_anchor_urb(urb, &ar->rx_pool);		atomic_inc(&ar->rx_pool_urbs);		usb_free_urb(urb);	}	err = carl9170_usb_submit_rx_urb(ar, GFP_KERNEL);	if (err)		goto err_out;	/* the device now waiting for the firmware. */	carl9170_set_state_when(ar, CARL9170_STOPPED, CARL9170_IDLE);	return 0;err_out:	usb_scuttle_anchored_urbs(&ar->rx_pool);	usb_scuttle_anchored_urbs(&ar->rx_work);	usb_kill_anchored_urbs(&ar->rx_anch);	return err;}

static void carl9170_usb_cancel_urbs(struct ar9170 *ar){	int err;	carl9170_set_state(ar, CARL9170_UNKNOWN_STATE);	err = carl9170_usb_flush(ar);	if (err)		dev_err(&ar->udev->dev, "stuck tx urbs!/n");	usb_poison_anchored_urbs(&ar->tx_anch);	carl9170_usb_handle_tx_err(ar);	usb_poison_anchored_urbs(&ar->rx_anch);	tasklet_kill(&ar->usb_tasklet);	usb_scuttle_anchored_urbs(&ar->rx_work);	usb_scuttle_anchored_urbs(&ar->rx_pool);	usb_scuttle_anchored_urbs(&ar->tx_cmd);}

static void play_deferred(struct btusb_data *data){	struct urb *urb;	int err;	while ((urb = usb_get_from_anchor(&data->deferred))) {		err = usb_submit_urb(urb, GFP_ATOMIC);		if (err < 0)			break;		data->tx_in_flight++;	}	usb_scuttle_anchored_urbs(&data->deferred);}

static int btusb_close(struct hci_dev *hdev){    struct btusb_data *data = GET_DRV_DATA(hdev);    int i,err;    if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))        return 0;    RTKBT_DBG("btusb_close");    /*******************************/    for (i = 0; i < NUM_REASSEMBLY; i++)    {        if(hdev->reassembly[i])        {            kfree_skb(hdev->reassembly[i]);            hdev->reassembly[i] = NULL;            RTKBT_DBG("%s free ressembly i=%d",__FUNCTION__,i);        }    }    /*******************************/    cancel_work_sync(&data->work);    cancel_work_sync(&data->waker);    clear_bit(BTUSB_ISOC_RUNNING, &data->flags);    clear_bit(BTUSB_BULK_RUNNING, &data->flags);    clear_bit(BTUSB_INTR_RUNNING, &data->flags);    btusb_stop_traffic(data);    err = usb_autopm_get_interface(data->intf);    if (err < 0)        goto failed;    data->intf->needs_remote_wakeup = 0;    usb_autopm_put_interface(data->intf);failed:    mdelay(URB_CANCELING_DELAY_MS);     // Added by Realtek    usb_scuttle_anchored_urbs(&data->deferred);    return 0;}

static int nfcmrvl_resume(struct usb_interface *intf){	struct nfcmrvl_usb_drv_data *drv_data = usb_get_intfdata(intf);	int err = 0;	nfc_info(&drv_data->udev->dev, "intf %p", intf);	if (--drv_data->suspend_count)		return 0;	if (!test_bit(NFCMRVL_NCI_RUNNING, &drv_data->flags))		goto done;	if (test_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags)) {		err = nfcmrvl_submit_bulk_urb(drv_data, GFP_NOIO);		if (err) {			clear_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);			goto failed;		}		nfcmrvl_submit_bulk_urb(drv_data, GFP_NOIO);	}	spin_lock_irq(&drv_data->txlock);	nfcmrvl_play_deferred(drv_data);	clear_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);	spin_unlock_irq(&drv_data->txlock);	return 0;failed:	usb_scuttle_anchored_urbs(&drv_data->deferred);done:	spin_lock_irq(&drv_data->txlock);	clear_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);	spin_unlock_irq(&drv_data->txlock);	return err;}

static int nfcmrvl_usb_nci_close(struct nfcmrvl_private *priv){	struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;	int err;	cancel_work_sync(&drv_data->waker);	clear_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);	nfcmrvl_usb_stop_traffic(drv_data);	usb_kill_anchored_urbs(&drv_data->tx_anchor);	err = usb_autopm_get_interface(drv_data->intf);	if (err)		goto failed;	drv_data->intf->needs_remote_wakeup = 0;	usb_autopm_put_interface(drv_data->intf);failed:	usb_scuttle_anchored_urbs(&drv_data->deferred);	return 0;}

static void play_deferred(struct btusb_data *data){    struct urb *urb;    int err;    while ((urb = usb_get_from_anchor(&data->deferred))) {        /************************************/        usb_anchor_urb(urb, &data->tx_anchor);        err = usb_submit_urb(urb, GFP_ATOMIC);        if (err < 0) {            BT_ERR("play_deferred urb %p submission failed",  urb);            kfree(urb->setup_packet);            usb_unanchor_urb(urb);        } else {            usb_mark_last_busy(data->udev);        }        usb_free_urb(urb);        /************************************/        data->tx_in_flight++;    }    mdelay(URB_CANCELING_DELAY_MS);     // Added by Realtek    usb_scuttle_anchored_urbs(&data->deferred);}

static int btusb_resume(struct usb_interface *intf){    struct btusb_data *data = usb_get_intfdata(intf);    struct hci_dev *hdev = data->hdev;    int err = 0;    if (intf->cur_altsetting->desc.bInterfaceNumber != 0)        return 0;    /*******************************/    RTKBT_DBG("btusb_resume data->suspend_count=%d",data->suspend_count);    if (!test_bit(HCI_RUNNING, &hdev->flags))    {        RTKBT_DBG("btusb_resume-----bt is off,download patch");        download_patch(intf);    }    else        RTKBT_DBG("btusb_resume,----bt is on");    /*******************************/    if (--data->suspend_count)        return 0;    if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {        err = btusb_submit_intr_urb(hdev, GFP_NOIO);        if (err < 0) {            clear_bit(BTUSB_INTR_RUNNING, &data->flags);            goto failed;        }    }    if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {        err = btusb_submit_bulk_urb(hdev, GFP_NOIO);        if (err < 0) {            clear_bit(BTUSB_BULK_RUNNING, &data->flags);            goto failed;        }        btusb_submit_bulk_urb(hdev, GFP_NOIO);    }    if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {        if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0)            clear_bit(BTUSB_ISOC_RUNNING, &data->flags);        else            btusb_submit_isoc_urb(hdev, GFP_NOIO);    }    spin_lock_irq(&data->txlock);    play_deferred(data);    clear_bit(BTUSB_SUSPENDING, &data->flags);    spin_unlock_irq(&data->txlock);    schedule_work(&data->work);    return 0;failed:    mdelay(URB_CANCELING_DELAY_MS);      // Added by Realtek    usb_scuttle_anchored_urbs(&data->deferred);//done:    spin_lock_irq(&data->txlock);    clear_bit(BTUSB_SUSPENDING, &data->flags);    spin_unlock_irq(&data->txlock);    return err;}