Lines Matching refs:data
591 int (*recv_bulk)(struct btusb_data *data, void *buffer, int count);
601 struct btusb_data *data = hci_get_drvdata(hdev);
602 struct gpio_desc *reset_gpio = data->reset_gpio;
604 if (++data->cmd_timeout_cnt < 5)
619 if (test_and_set_bit(BTUSB_HW_RESET_ACTIVE, &data->flags)) {
632 struct btusb_data *data = hci_get_drvdata(hdev);
633 struct gpio_desc *reset_gpio = data->reset_gpio;
635 if (++data->cmd_timeout_cnt < 5)
649 if (test_and_set_bit(BTUSB_HW_RESET_ACTIVE, &data->flags)) {
662 struct btusb_data *data = hci_get_drvdata(hdev);
665 if (++data->cmd_timeout_cnt < 5)
670 err = usb_autopm_get_interface(data->intf);
672 usb_queue_reset_device(data->intf);
677 static inline void btusb_free_frags(struct btusb_data *data)
681 spin_lock_irqsave(&data->rxlock, flags);
683 dev_kfree_skb_irq(data->evt_skb);
684 data->evt_skb = NULL;
686 dev_kfree_skb_irq(data->acl_skb);
687 data->acl_skb = NULL;
689 dev_kfree_skb_irq(data->sco_skb);
690 data->sco_skb = NULL;
692 spin_unlock_irqrestore(&data->rxlock, flags);
695 static int btusb_recv_intr(struct btusb_data *data, void *buffer, int count)
701 spin_lock_irqsave(&data->rxlock, flags);
702 skb = data->evt_skb;
740 data->recv_event(data->hdev, skb);
745 data->evt_skb = skb;
746 spin_unlock_irqrestore(&data->rxlock, flags);
751 static int btusb_recv_bulk(struct btusb_data *data, void *buffer, int count)
757 spin_lock_irqsave(&data->rxlock, flags);
758 skb = data->acl_skb;
798 hci_recv_frame(data->hdev, skb);
803 data->acl_skb = skb;
804 spin_unlock_irqrestore(&data->rxlock, flags);
809 static int btusb_recv_isoc(struct btusb_data *data, void *buffer, int count)
815 spin_lock_irqsave(&data->rxlock, flags);
816 skb = data->sco_skb;
854 hci_recv_frame(data->hdev, skb);
859 data->sco_skb = skb;
860 spin_unlock_irqrestore(&data->rxlock, flags);
868 struct btusb_data *data = hci_get_drvdata(hdev);
880 if (btusb_recv_intr(data, urb->transfer_buffer,
890 if (!test_bit(BTUSB_INTR_RUNNING, &data->flags))
893 usb_mark_last_busy(data->udev);
894 usb_anchor_urb(urb, &data->intr_anchor);
910 struct btusb_data *data = hci_get_drvdata(hdev);
918 if (!data->intr_ep)
925 size = le16_to_cpu(data->intr_ep->wMaxPacketSize);
933 pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress);
935 usb_fill_int_urb(urb, data->udev, pipe, buf, size,
936 btusb_intr_complete, hdev, data->intr_ep->bInterval);
940 usb_anchor_urb(urb, &data->intr_anchor);
958 struct btusb_data *data = hci_get_drvdata(hdev);
970 if (data->recv_bulk(data, urb->transfer_buffer,
980 if (!test_bit(BTUSB_BULK_RUNNING, &data->flags))
983 usb_anchor_urb(urb, &data->bulk_anchor);
984 usb_mark_last_busy(data->udev);
1000 struct btusb_data *data = hci_get_drvdata(hdev);
1008 if (!data->bulk_rx_ep)
1021 pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress);
1023 usb_fill_bulk_urb(urb, data->udev, pipe, buf, size,
1028 usb_mark_last_busy(data->udev);
1029 usb_anchor_urb(urb, &data->bulk_anchor);
1047 struct btusb_data *data = hci_get_drvdata(hdev);
1066 if (btusb_recv_isoc(data, urb->transfer_buffer + offset,
1077 if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags))
1080 usb_anchor_urb(urb, &data->isoc_anchor);
1095 int mtu, struct btusb_data *data)
1108 if (data->usb_alt6_packet_flow) {
1110 data->usb_alt6_packet_flow = false;
1113 data->usb_alt6_packet_flow = true;
1153 struct btusb_data *data = hci_get_drvdata(hdev);
1161 if (!data->isoc_rx_ep)
1168 size = le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize) *
1177 pipe = usb_rcvisocpipe(data->udev, data->isoc_rx_ep->bEndpointAddress);
1179 usb_fill_int_urb(urb, data->udev, pipe, buf, size, btusb_isoc_complete,
1180 hdev, data->isoc_rx_ep->bInterval);
1185 le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize));
1187 usb_anchor_urb(urb, &data->isoc_anchor);
1205 struct btusb_data *data = hci_get_drvdata(hdev);
1225 if (!test_bit(BTUSB_DIAG_RUNNING, &data->flags))
1228 usb_anchor_urb(urb, &data->diag_anchor);
1229 usb_mark_last_busy(data->udev);
1245 struct btusb_data *data = hci_get_drvdata(hdev);
1253 if (!data->diag_rx_ep)
1266 pipe = usb_rcvbulkpipe(data->udev, data->diag_rx_ep->bEndpointAddress);
1268 usb_fill_bulk_urb(urb, data->udev, pipe, buf, size,
1273 usb_mark_last_busy(data->udev);
1274 usb_anchor_urb(urb, &data->diag_anchor);
1293 struct btusb_data *data = hci_get_drvdata(hdev);
1308 spin_lock_irqsave(&data->txlock, flags);
1309 data->tx_in_flight--;
1310 spin_unlock_irqrestore(&data->txlock, flags);
1341 struct btusb_data *data = hci_get_drvdata(hdev);
1346 err = usb_autopm_get_interface(data->intf);
1353 if (data->setup_on_usb) {
1354 err = data->setup_on_usb(hdev);
1359 data->intf->needs_remote_wakeup = 1;
1365 if (test_bit(BTUSB_WAKEUP_DISABLE, &data->flags))
1366 device_wakeup_disable(&data->udev->dev);
1368 if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags))
1377 usb_kill_anchored_urbs(&data->intr_anchor);
1381 set_bit(BTUSB_BULK_RUNNING, &data->flags);
1384 if (data->diag) {
1386 set_bit(BTUSB_DIAG_RUNNING, &data->flags);
1390 usb_autopm_put_interface(data->intf);
1394 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
1396 usb_autopm_put_interface(data->intf);
1400 static void btusb_stop_traffic(struct btusb_data *data)
1402 usb_kill_anchored_urbs(&data->intr_anchor);
1403 usb_kill_anchored_urbs(&data->bulk_anchor);
1404 usb_kill_anchored_urbs(&data->isoc_anchor);
1405 usb_kill_anchored_urbs(&data->diag_anchor);
1406 usb_kill_anchored_urbs(&data->ctrl_anchor);
1411 struct btusb_data *data = hci_get_drvdata(hdev);
1416 cancel_work_sync(&data->work);
1417 cancel_work_sync(&data->waker);
1419 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1420 clear_bit(BTUSB_BULK_RUNNING, &data->flags);
1421 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
1422 clear_bit(BTUSB_DIAG_RUNNING, &data->flags);
1424 btusb_stop_traffic(data);
1425 btusb_free_frags(data);
1427 err = usb_autopm_get_interface(data->intf);
1431 data->intf->needs_remote_wakeup = 0;
1434 if (test_bit(BTUSB_WAKEUP_DISABLE, &data->flags))
1435 data->intf->needs_remote_wakeup = 1;
1437 usb_autopm_put_interface(data->intf);
1440 usb_scuttle_anchored_urbs(&data->deferred);
1446 struct btusb_data *data = hci_get_drvdata(hdev);
1450 usb_kill_anchored_urbs(&data->tx_anchor);
1451 btusb_free_frags(data);
1458 struct btusb_data *data = hci_get_drvdata(hdev);
1473 dr->bRequestType = data->cmdreq_type;
1474 dr->bRequest = data->cmdreq;
1479 pipe = usb_sndctrlpipe(data->udev, 0x00);
1481 usb_fill_control_urb(urb, data->udev, pipe, (void *)dr,
1482 skb->data, skb->len, btusb_tx_complete, skb);
1491 struct btusb_data *data = hci_get_drvdata(hdev);
1495 if (!data->bulk_tx_ep)
1502 pipe = usb_sndbulkpipe(data->udev, data->bulk_tx_ep->bEndpointAddress);
1504 usb_fill_bulk_urb(urb, data->udev, pipe,
1505 skb->data, skb->len, btusb_tx_complete, skb);
1514 struct btusb_data *data = hci_get_drvdata(hdev);
1518 if (!data->isoc_tx_ep)
1525 pipe = usb_sndisocpipe(data->udev, data->isoc_tx_ep->bEndpointAddress);
1527 usb_fill_int_urb(urb, data->udev, pipe,
1528 skb->data, skb->len, btusb_isoc_tx_complete,
1529 skb, data->isoc_tx_ep->bInterval);
1533 if (data->isoc_altsetting == 6)
1535 le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize),
1536 data);
1539 le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));
1547 struct btusb_data *data = hci_get_drvdata(hdev);
1550 usb_anchor_urb(urb, &data->tx_anchor);
1560 usb_mark_last_busy(data->udev);
1569 struct btusb_data *data = hci_get_drvdata(hdev);
1573 spin_lock_irqsave(&data->txlock, flags);
1574 suspending = test_bit(BTUSB_SUSPENDING, &data->flags);
1576 data->tx_in_flight++;
1577 spin_unlock_irqrestore(&data->txlock, flags);
1582 usb_anchor_urb(urb, &data->deferred);
1583 schedule_work(&data->waker);
1629 struct btusb_data *data = hci_get_drvdata(hdev);
1633 if (hci_conn_num(hdev, SCO_LINK) != data->sco_num) {
1634 data->sco_num = hci_conn_num(hdev, SCO_LINK);
1635 data->air_mode = evt;
1636 schedule_work(&data->work);
1642 struct btusb_data *data = hci_get_drvdata(hdev);
1643 struct usb_interface *intf = data->isoc;
1647 if (!data->isoc)
1650 err = usb_set_interface(data->udev, data->isoc_ifnum, altsetting);
1656 data->isoc_altsetting = altsetting;
1658 data->isoc_tx_ep = NULL;
1659 data->isoc_rx_ep = NULL;
1664 if (!data->isoc_tx_ep && usb_endpoint_is_isoc_out(ep_desc)) {
1665 data->isoc_tx_ep = ep_desc;
1669 if (!data->isoc_rx_ep && usb_endpoint_is_isoc_in(ep_desc)) {
1670 data->isoc_rx_ep = ep_desc;
1675 if (!data->isoc_tx_ep || !data->isoc_rx_ep) {
1685 struct btusb_data *data = hci_get_drvdata(hdev);
1688 if (data->isoc_altsetting != new_alts) {
1691 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1692 usb_kill_anchored_urbs(&data->isoc_anchor);
1703 spin_lock_irqsave(&data->rxlock, flags);
1704 dev_kfree_skb_irq(data->sco_skb);
1705 data->sco_skb = NULL;
1706 spin_unlock_irqrestore(&data->rxlock, flags);
1713 if (!test_and_set_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
1715 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1723 static struct usb_host_interface *btusb_find_altsetting(struct btusb_data *data,
1726 struct usb_interface *intf = data->isoc;
1744 struct btusb_data *data = container_of(work, struct btusb_data, work);
1745 struct hci_dev *hdev = data->hdev;
1749 if (data->sco_num > 0) {
1750 if (!test_bit(BTUSB_DID_ISO_RESUME, &data->flags)) {
1751 err = usb_autopm_get_interface(data->isoc ? data->isoc : data->intf);
1753 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1754 usb_kill_anchored_urbs(&data->isoc_anchor);
1758 set_bit(BTUSB_DID_ISO_RESUME, &data->flags);
1761 if (data->air_mode == HCI_NOTIFY_ENABLE_SCO_CVSD) {
1765 new_alts = alts[data->sco_num - 1];
1767 new_alts = data->sco_num;
1769 } else if (data->air_mode == HCI_NOTIFY_ENABLE_SCO_TRANSP) {
1775 * data satisfy 60 bytes), requiring
1779 if (btusb_find_altsetting(data, 6))
1781 else if (btusb_find_altsetting(data, 3) &&
1783 test_bit(BTUSB_USE_ALT3_FOR_WBS, &data->flags))
1792 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1793 usb_kill_anchored_urbs(&data->isoc_anchor);
1796 if (test_and_clear_bit(BTUSB_DID_ISO_RESUME, &data->flags))
1797 usb_autopm_put_interface(data->isoc ? data->isoc : data->intf);
1803 struct btusb_data *data = container_of(work, struct btusb_data, waker);
1806 err = usb_autopm_get_interface(data->intf);
1810 usb_autopm_put_interface(data->intf);
1831 struct btusb_data *data = hci_get_drvdata(hdev);
1832 u16 bcdDevice = le16_to_cpu(data->udev->descriptor.bcdDevice);
1853 rp = (struct hci_rp_read_local_version *)skb->data;
1986 int remain = fw->size - (*fw_ptr - fw->data);
2006 /* Ensure that the remain firmware data is long enough than the length
2018 * because there are no patch data to load.
2069 /* It ensures that the returned event matches the event data read from
2080 if (memcmp(skb->data, evt_param, evt->plen)) {
2133 * have. If there is no patch data in the device, it is always 0x00.
2151 fw_ptr = fw->data;
2155 * firmware patch data and configuration parameters.
2165 /* The firmware data file consists of list of Intel specific HCI
2185 while (fw->size > fw_ptr - fw->data) {
2274 static int btusb_recv_bulk_intel(struct btusb_data *data, void *buffer,
2281 if (test_bit(BTUSB_BOOTLOADER, &data->flags))
2282 return btusb_recv_intr(data, buffer, count);
2284 return btusb_recv_bulk(data, buffer, count);
2287 static void btusb_intel_bootup(struct btusb_data *data, const void *ptr,
2295 if (test_and_clear_bit(BTUSB_BOOTING, &data->flags))
2296 wake_up_bit(&data->flags, BTUSB_BOOTING);
2299 static void btusb_intel_secure_send_result(struct btusb_data *data,
2308 set_bit(BTUSB_FIRMWARE_FAILED, &data->flags);
2310 if (test_and_clear_bit(BTUSB_DOWNLOADING, &data->flags) &&
2311 test_bit(BTUSB_FIRMWARE_LOADED, &data->flags))
2312 wake_up_bit(&data->flags, BTUSB_DOWNLOADING);
2317 struct btusb_data *data = hci_get_drvdata(hdev);
2319 if (test_bit(BTUSB_BOOTLOADER, &data->flags)) {
2320 struct hci_event_hdr *hdr = (void *)skb->data;
2324 const void *ptr = skb->data + HCI_EVENT_HDR_SIZE + 1;
2327 switch (skb->data[2]) {
2333 btusb_intel_bootup(data, ptr, len);
2341 btusb_intel_secure_send_result(data, ptr, len);
2352 struct btusb_data *data = hci_get_drvdata(hdev);
2359 if (test_bit(BTUSB_BOOTLOADER, &data->flags)) {
2360 struct hci_command_hdr *cmd = (void *)skb->data;
2448 struct btusb_data *data = hci_get_drvdata(hdev);
2498 clear_bit(BTUSB_BOOTLOADER, &data->flags);
2580 set_bit(BTUSB_DOWNLOADING, &data->flags);
2591 set_bit(BTUSB_FIRMWARE_LOADED, &data->flags);
2606 err = wait_on_bit_timeout(&data->flags, BTUSB_DOWNLOADING,
2621 if (test_bit(BTUSB_FIRMWARE_FAILED, &data->flags)) {
2634 struct btusb_data *data = hci_get_drvdata(hdev);
2681 set_bit(BTUSB_BOOTING, &data->flags);
2699 err = wait_on_bit_timeout(&data->flags, BTUSB_BOOTING,
2720 clear_bit(BTUSB_BOOTLOADER, &data->flags);
2859 u8 data[];
2884 const void *data;
2891 struct btusb_data *data = hci_get_drvdata(hdev);
2912 hdr = (void *)skb->data;
2922 if (test_bit(BTUSB_TX_WAIT_VND_EVT, &data->flags)) {
2923 data->evt_skb = skb_clone(skb, GFP_ATOMIC);
2924 if (!data->evt_skb) {
2933 kfree_skb(data->evt_skb);
2934 data->evt_skb = NULL;
2940 &data->flags)) {
2943 wake_up_bit(&data->flags,
2953 usb_mark_last_busy(data->udev);
2964 usb_anchor_urb(urb, &data->ctrl_anchor);
2980 struct btusb_data *data = hci_get_drvdata(hdev);
3010 pipe = usb_rcvctrlpipe(data->udev, 0);
3012 usb_fill_control_urb(urb, data->udev, pipe, (void *)dr,
3017 usb_anchor_urb(urb, &data->ctrl_anchor);
3034 struct btusb_data *data = hci_get_drvdata(hdev);
3056 memcpy(wc->data, wmt_params->data, wmt_params->dlen);
3058 set_bit(BTUSB_TX_WAIT_VND_EVT, &data->flags);
3066 err = usb_autopm_get_interface(data->intf);
3073 clear_bit(BTUSB_TX_WAIT_VND_EVT, &data->flags);
3074 usb_autopm_put_interface(data->intf);
3081 usb_autopm_put_interface(data->intf);
3095 err = wait_on_bit_timeout(&data->flags, BTUSB_TX_WAIT_VND_EVT,
3099 clear_bit(BTUSB_TX_WAIT_VND_EVT, &data->flags);
3105 clear_bit(BTUSB_TX_WAIT_VND_EVT, &data->flags);
3110 if (data->evt_skb == NULL)
3114 wmt_evt = (struct btmtk_hci_wmt_evt *)data->evt_skb->data;
3144 kfree_skb(data->evt_skb);
3145 data->evt_skb = NULL;
3166 /* Power on data RAM the firmware relies on. */
3171 wmt_params.data = ¶m;
3176 bt_dev_err(hdev, "Failed to power on data RAM (%d)", err);
3180 fw_ptr = fw->data;
3207 wmt_params.data = fw_ptr;
3223 wmt_params.data = NULL;
3252 wmt_params.data = ¶m;
3264 static int btusb_mtk_reg_read(struct btusb_data *data, u32 reg, u32 *val)
3273 pipe = usb_rcvctrlpipe(data->udev, 0);
3274 err = usb_control_msg(data->udev, pipe, 0x63,
3289 static int btusb_mtk_id_get(struct btusb_data *data, u32 reg, u32 *id)
3291 return btusb_mtk_reg_read(data, reg, id);
3296 struct btusb_data *data = hci_get_drvdata(hdev);
3309 err = btusb_mtk_id_get(data, 0x80000008, &dev_id);
3332 wmt_params.data = NULL;
3373 wmt_params.data = ¶m;
3418 wmt_params.data = ¶m;
3438 struct btusb_data *data = hci_get_drvdata(hdev);
3439 struct device *dev = &data->udev->dev;
3588 void *data, u16 size)
3608 memcpy(data, buf, size);
3633 memcpy(buf, firmware->data, size);
3659 memcpy(buf, firmware->data + sent, size);
3710 rver = (struct qca_rampatch_version *)(fw->data + info->ver_offset);
3833 struct btusb_data *data = hci_get_drvdata(hdev);
3834 struct usb_interface *intf = data->diag;
3837 if (!data->diag)
3840 data->diag_tx_ep = NULL;
3841 data->diag_rx_ep = NULL;
3848 if (!data->diag_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {
3849 data->diag_tx_ep = ep_desc;
3853 if (!data->diag_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {
3854 data->diag_rx_ep = ep_desc;
3859 if (!data->diag_tx_ep || !data->diag_rx_ep) {
3869 struct btusb_data *data = hci_get_drvdata(hdev);
3874 if (!data->diag_tx_ep)
3890 pipe = usb_sndbulkpipe(data->udev, data->diag_tx_ep->bEndpointAddress);
3892 usb_fill_bulk_urb(urb, data->udev, pipe,
3893 skb->data, skb->len, btusb_tx_complete, skb);
3902 struct btusb_data *data = hci_get_drvdata(hdev);
3905 if (!data->diag)
3921 struct btusb_data *data = priv;
3923 pm_wakeup_event(&data->udev->dev, 0);
3927 if (test_and_clear_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags)) {
3945 struct btusb_data *data = hci_get_drvdata(hdev);
3946 struct device *dev = &data->udev->dev;
3949 clear_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags);
3963 0, "OOB Wake-on-BT", data);
3975 data->oob_wake_irq = irq;
3989 struct btusb_data *data = hci_get_drvdata(hdev);
3991 if (test_bit(BTUSB_WAKEUP_DISABLE, &data->flags))
3994 return !device_may_wakeup(&data->udev->dev);
4002 struct btusb_data *data;
4041 data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);
4042 if (!data)
4048 if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {
4049 data->intr_ep = ep_desc;
4053 if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {
4054 data->bulk_tx_ep = ep_desc;
4058 if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {
4059 data->bulk_rx_ep = ep_desc;
4064 if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep)
4068 data->cmdreq_type = USB_TYPE_CLASS | 0x01;
4069 data->cmdreq = 0x2b;
4071 data->cmdreq_type = USB_TYPE_CLASS;
4072 data->cmdreq = 0x00;
4075 data->udev = interface_to_usbdev(intf);
4076 data->intf = intf;
4078 INIT_WORK(&data->work, btusb_work);
4079 INIT_WORK(&data->waker, btusb_waker);
4080 init_usb_anchor(&data->deferred);
4081 init_usb_anchor(&data->tx_anchor);
4082 spin_lock_init(&data->txlock);
4084 init_usb_anchor(&data->intr_anchor);
4085 init_usb_anchor(&data->bulk_anchor);
4086 init_usb_anchor(&data->isoc_anchor);
4087 init_usb_anchor(&data->diag_anchor);
4088 init_usb_anchor(&data->ctrl_anchor);
4089 spin_lock_init(&data->rxlock);
4092 data->recv_event = btusb_recv_event_intel;
4093 data->recv_bulk = btusb_recv_bulk_intel;
4094 set_bit(BTUSB_BOOTLOADER, &data->flags);
4096 data->recv_event = hci_recv_frame;
4097 data->recv_bulk = btusb_recv_bulk;
4105 hci_set_drvdata(hdev, data);
4112 data->hdev = hdev;
4116 reset_gpio = gpiod_get_optional(&data->udev->dev, "reset",
4122 data->reset_gpio = reset_gpio;
4138 if (id->driver_info & BTUSB_MARVELL && data->oob_wake_irq) {
4161 data->diag = usb_ifnum_to_if(data->udev, ifnum_base + 2);
4171 data->diag = usb_ifnum_to_if(data->udev, ifnum_base + 2);
4222 data->setup_on_usb = btusb_setup_qca;
4229 data->setup_on_usb = btusb_setup_qca;
4237 data->setup_on_usb = btusb_setup_qca;
4245 data->isoc = NULL;
4248 data->isoc = usb_ifnum_to_if(data->udev, ifnum_base + 1);
4249 data->isoc_ifnum = ifnum_base + 1;
4262 set_bit(BTUSB_WAKEUP_DISABLE, &data->flags);
4263 set_bit(BTUSB_USE_ALT3_FOR_WBS, &data->flags);
4275 data->isoc = NULL;
4284 data->cmdreq_type = USB_TYPE_VENDOR;
4289 struct usb_device *udev = data->udev;
4306 struct usb_device *udev = data->udev;
4317 err = usb_set_interface(data->udev, 0, 0);
4324 if (data->isoc) {
4326 data->isoc, data);
4331 if (IS_ENABLED(CONFIG_BT_HCIBTUSB_BCM) && data->diag) {
4333 data->diag, data))
4336 data->diag = NULL;
4340 usb_enable_autosuspend(data->udev);
4346 usb_set_intfdata(intf, data);
4351 if (data->reset_gpio)
4352 gpiod_put(data->reset_gpio);
4359 struct btusb_data *data = usb_get_intfdata(intf);
4364 if (!data)
4367 hdev = data->hdev;
4368 usb_set_intfdata(data->intf, NULL);
4370 if (data->isoc)
4371 usb_set_intfdata(data->isoc, NULL);
4373 if (data->diag)
4374 usb_set_intfdata(data->diag, NULL);
4378 if (intf == data->intf) {
4379 if (data->isoc)
4380 usb_driver_release_interface(&btusb_driver, data->isoc);
4381 if (data->diag)
4382 usb_driver_release_interface(&btusb_driver, data->diag);
4383 } else if (intf == data->isoc) {
4384 if (data->diag)
4385 usb_driver_release_interface(&btusb_driver, data->diag);
4386 usb_driver_release_interface(&btusb_driver, data->intf);
4387 } else if (intf == data->diag) {
4388 usb_driver_release_interface(&btusb_driver, data->intf);
4389 if (data->isoc)
4390 usb_driver_release_interface(&btusb_driver, data->isoc);
4393 if (data->oob_wake_irq)
4394 device_init_wakeup(&data->udev->dev, false);
4396 if (data->reset_gpio)
4397 gpiod_put(data->reset_gpio);
4405 struct btusb_data *data = usb_get_intfdata(intf);
4409 if (data->suspend_count++)
4412 spin_lock_irq(&data->txlock);
4413 if (!(PMSG_IS_AUTO(message) && data->tx_in_flight)) {
4414 set_bit(BTUSB_SUSPENDING, &data->flags);
4415 spin_unlock_irq(&data->txlock);
4417 spin_unlock_irq(&data->txlock);
4418 data->suspend_count--;
4422 cancel_work_sync(&data->work);
4424 btusb_stop_traffic(data);
4425 usb_kill_anchored_urbs(&data->tx_anchor);
4427 if (data->oob_wake_irq && device_may_wakeup(&data->udev->dev)) {
4428 set_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags);
4429 enable_irq_wake(data->oob_wake_irq);
4430 enable_irq(data->oob_wake_irq);
4438 if (test_bit(BTUSB_WAKEUP_DISABLE, &data->flags)) {
4440 device_can_wakeup(&data->udev->dev))
4441 data->udev->do_remote_wakeup = 1;
4443 data->udev->reset_resume = 1;
4449 static void play_deferred(struct btusb_data *data)
4454 while ((urb = usb_get_from_anchor(&data->deferred))) {
4455 usb_anchor_urb(urb, &data->tx_anchor);
4461 data->hdev->name, urb, -err);
4468 data->tx_in_flight++;
4473 while ((urb = usb_get_from_anchor(&data->deferred))) {
4481 struct btusb_data *data = usb_get_intfdata(intf);
4482 struct hci_dev *hdev = data->hdev;
4487 if (--data->suspend_count)
4491 if (test_and_clear_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags)) {
4492 disable_irq(data->oob_wake_irq);
4493 disable_irq_wake(data->oob_wake_irq);
4499 if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {
4502 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
4507 if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {
4510 clear_bit(BTUSB_BULK_RUNNING, &data->flags);
4517 if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
4519 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
4524 spin_lock_irq(&data->txlock);
4525 play_deferred(data);
4526 clear_bit(BTUSB_SUSPENDING, &data->flags);
4527 spin_unlock_irq(&data->txlock);
4528 schedule_work(&data->work);
4533 usb_scuttle_anchored_urbs(&data->deferred);
4535 spin_lock_irq(&data->txlock);
4536 clear_bit(BTUSB_SUSPENDING, &data->flags);
4537 spin_unlock_irq(&data->txlock);