Lines Matching refs:data
847 int (*recv_bulk)(struct btusb_data *data, void *buffer, int count);
859 struct btusb_data *data;
867 data = hci_get_drvdata(hdev);
869 err = usb_autopm_get_interface(data->intf);
876 usb_queue_reset_device(data->intf);
881 struct btusb_data *data = hci_get_drvdata(hdev);
882 struct gpio_desc *reset_gpio = data->reset_gpio;
885 if (++data->cmd_timeout_cnt < 5)
915 if (test_and_set_bit(BTUSB_HW_RESET_ACTIVE, &data->flags)) {
962 struct btusb_data *data = hci_get_drvdata(hdev);
963 struct gpio_desc *reset_gpio = data->reset_gpio;
970 if (++data->cmd_timeout_cnt < 5)
984 if (test_and_set_bit(BTUSB_HW_RESET_ACTIVE, &data->flags)) {
1009 struct btusb_data *data = hci_get_drvdata(hdev);
1010 struct gpio_desc *reset_gpio = data->reset_gpio;
1012 if (test_bit(BTUSB_HW_SSR_ACTIVE, &data->flags)) {
1017 if (++data->cmd_timeout_cnt < 5)
1029 if (test_and_set_bit(BTUSB_HW_RESET_ACTIVE, &data->flags)) {
1044 static inline void btusb_free_frags(struct btusb_data *data)
1048 spin_lock_irqsave(&data->rxlock, flags);
1050 dev_kfree_skb_irq(data->evt_skb);
1051 data->evt_skb = NULL;
1053 dev_kfree_skb_irq(data->acl_skb);
1054 data->acl_skb = NULL;
1056 dev_kfree_skb_irq(data->sco_skb);
1057 data->sco_skb = NULL;
1059 spin_unlock_irqrestore(&data->rxlock, flags);
1062 static int btusb_recv_event(struct btusb_data *data, struct sk_buff *skb)
1064 if (data->intr_interval) {
1066 schedule_delayed_work(&data->rx_work, 0);
1069 return data->recv_event(data->hdev, skb);
1072 static int btusb_recv_intr(struct btusb_data *data, void *buffer, int count)
1078 spin_lock_irqsave(&data->rxlock, flags);
1079 skb = data->evt_skb;
1117 btusb_recv_event(data, skb);
1122 data->evt_skb = skb;
1123 spin_unlock_irqrestore(&data->rxlock, flags);
1128 static int btusb_recv_acl(struct btusb_data *data, struct sk_buff *skb)
1133 if (!data->intr_interval)
1134 return data->recv_acl(data->hdev, skb);
1136 skb_queue_tail(&data->acl_q, skb);
1137 schedule_delayed_work(&data->rx_work, data->intr_interval);
1142 static int btusb_recv_bulk(struct btusb_data *data, void *buffer, int count)
1148 spin_lock_irqsave(&data->rxlock, flags);
1149 skb = data->acl_skb;
1189 btusb_recv_acl(data, skb);
1194 data->acl_skb = skb;
1195 spin_unlock_irqrestore(&data->rxlock, flags);
1228 static int btusb_recv_isoc(struct btusb_data *data, void *buffer, int count)
1234 spin_lock_irqsave(&data->rxlock, flags);
1235 skb = data->sco_skb;
1265 !btusb_validate_sco_handle(data->hdev, hdr)) {
1276 hci_recv_frame(data->hdev, skb);
1281 data->sco_skb = skb;
1282 spin_unlock_irqrestore(&data->rxlock, flags);
1290 struct btusb_data *data = hci_get_drvdata(hdev);
1302 if (btusb_recv_intr(data, urb->transfer_buffer,
1312 if (!test_bit(BTUSB_INTR_RUNNING, &data->flags))
1315 usb_mark_last_busy(data->udev);
1316 usb_anchor_urb(urb, &data->intr_anchor);
1334 struct btusb_data *data = hci_get_drvdata(hdev);
1342 if (!data->intr_ep)
1349 size = le16_to_cpu(data->intr_ep->wMaxPacketSize);
1357 pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress);
1359 usb_fill_int_urb(urb, data->udev, pipe, buf, size,
1360 btusb_intr_complete, hdev, data->intr_ep->bInterval);
1364 usb_anchor_urb(urb, &data->intr_anchor);
1377 if (!data->poll_sync)
1390 data->intr_interval = usecs_to_jiffies(urb->interval * 125);
1393 data->intr_interval = msecs_to_jiffies(urb->interval);
1406 struct btusb_data *data = hci_get_drvdata(hdev);
1418 if (data->recv_bulk(data, urb->transfer_buffer,
1428 if (!test_bit(BTUSB_BULK_RUNNING, &data->flags))
1431 usb_anchor_urb(urb, &data->bulk_anchor);
1432 usb_mark_last_busy(data->udev);
1448 struct btusb_data *data = hci_get_drvdata(hdev);
1456 if (!data->bulk_rx_ep)
1469 pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress);
1471 usb_fill_bulk_urb(urb, data->udev, pipe, buf, size,
1476 usb_mark_last_busy(data->udev);
1477 usb_anchor_urb(urb, &data->bulk_anchor);
1495 struct btusb_data *data = hci_get_drvdata(hdev);
1514 if (btusb_recv_isoc(data, urb->transfer_buffer + offset,
1525 if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags))
1528 usb_anchor_urb(urb, &data->isoc_anchor);
1543 int mtu, struct btusb_data *data)
1550 /* For mSBC ALT 6 settings some chips need to transmit the data
1553 if (test_bit(BTUSB_ALT6_CONTINUOUS_TX, &data->flags))
1562 if (data->usb_alt6_packet_flow) {
1564 data->usb_alt6_packet_flow = false;
1567 data->usb_alt6_packet_flow = true;
1608 struct btusb_data *data = hci_get_drvdata(hdev);
1616 if (!data->isoc_rx_ep)
1623 size = le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize) *
1632 pipe = usb_rcvisocpipe(data->udev, data->isoc_rx_ep->bEndpointAddress);
1634 usb_fill_int_urb(urb, data->udev, pipe, buf, size, btusb_isoc_complete,
1635 hdev, data->isoc_rx_ep->bInterval);
1640 le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize));
1642 usb_anchor_urb(urb, &data->isoc_anchor);
1660 struct btusb_data *data = hci_get_drvdata(hdev);
1680 if (!test_bit(BTUSB_DIAG_RUNNING, &data->flags))
1683 usb_anchor_urb(urb, &data->diag_anchor);
1684 usb_mark_last_busy(data->udev);
1700 struct btusb_data *data = hci_get_drvdata(hdev);
1708 if (!data->diag_rx_ep)
1721 pipe = usb_rcvbulkpipe(data->udev, data->diag_rx_ep->bEndpointAddress);
1723 usb_fill_bulk_urb(urb, data->udev, pipe, buf, size,
1728 usb_mark_last_busy(data->udev);
1729 usb_anchor_urb(urb, &data->diag_anchor);
1748 struct btusb_data *data = hci_get_drvdata(hdev);
1766 spin_lock_irqsave(&data->txlock, flags);
1767 data->tx_in_flight--;
1768 spin_unlock_irqrestore(&data->txlock, flags);
1799 struct btusb_data *data = hci_get_drvdata(hdev);
1804 err = usb_autopm_get_interface(data->intf);
1811 if (data->setup_on_usb) {
1812 err = data->setup_on_usb(hdev);
1817 data->intf->needs_remote_wakeup = 1;
1819 if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags))
1828 usb_kill_anchored_urbs(&data->intr_anchor);
1832 set_bit(BTUSB_BULK_RUNNING, &data->flags);
1835 if (data->diag) {
1837 set_bit(BTUSB_DIAG_RUNNING, &data->flags);
1841 usb_autopm_put_interface(data->intf);
1845 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
1847 usb_autopm_put_interface(data->intf);
1851 static void btusb_stop_traffic(struct btusb_data *data)
1853 usb_kill_anchored_urbs(&data->intr_anchor);
1854 usb_kill_anchored_urbs(&data->bulk_anchor);
1855 usb_kill_anchored_urbs(&data->isoc_anchor);
1856 usb_kill_anchored_urbs(&data->diag_anchor);
1857 usb_kill_anchored_urbs(&data->ctrl_anchor);
1862 struct btusb_data *data = hci_get_drvdata(hdev);
1867 cancel_delayed_work(&data->rx_work);
1868 cancel_work_sync(&data->work);
1869 cancel_work_sync(&data->waker);
1871 skb_queue_purge(&data->acl_q);
1873 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1874 clear_bit(BTUSB_BULK_RUNNING, &data->flags);
1875 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
1876 clear_bit(BTUSB_DIAG_RUNNING, &data->flags);
1878 btusb_stop_traffic(data);
1879 btusb_free_frags(data);
1881 err = usb_autopm_get_interface(data->intf);
1885 data->intf->needs_remote_wakeup = 0;
1888 if (test_bit(BTUSB_WAKEUP_AUTOSUSPEND, &data->flags))
1889 data->intf->needs_remote_wakeup = 1;
1891 usb_autopm_put_interface(data->intf);
1894 usb_scuttle_anchored_urbs(&data->deferred);
1900 struct btusb_data *data = hci_get_drvdata(hdev);
1904 cancel_delayed_work(&data->rx_work);
1906 skb_queue_purge(&data->acl_q);
1908 usb_kill_anchored_urbs(&data->tx_anchor);
1909 btusb_free_frags(data);
1916 struct btusb_data *data = hci_get_drvdata(hdev);
1931 dr->bRequestType = data->cmdreq_type;
1932 dr->bRequest = data->cmdreq;
1937 pipe = usb_sndctrlpipe(data->udev, 0x00);
1939 usb_fill_control_urb(urb, data->udev, pipe, (void *)dr,
1940 skb->data, skb->len, btusb_tx_complete, skb);
1949 struct btusb_data *data = hci_get_drvdata(hdev);
1953 if (!data->bulk_tx_ep)
1960 pipe = usb_sndbulkpipe(data->udev, data->bulk_tx_ep->bEndpointAddress);
1962 usb_fill_bulk_urb(urb, data->udev, pipe,
1963 skb->data, skb->len, btusb_tx_complete, skb);
1972 struct btusb_data *data = hci_get_drvdata(hdev);
1976 if (!data->isoc_tx_ep)
1983 pipe = usb_sndisocpipe(data->udev, data->isoc_tx_ep->bEndpointAddress);
1985 usb_fill_int_urb(urb, data->udev, pipe,
1986 skb->data, skb->len, btusb_isoc_tx_complete,
1987 skb, data->isoc_tx_ep->bInterval);
1991 if (data->isoc_altsetting == 6)
1993 le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize),
1994 data);
1997 le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));
2005 struct btusb_data *data = hci_get_drvdata(hdev);
2008 usb_anchor_urb(urb, &data->tx_anchor);
2018 usb_mark_last_busy(data->udev);
2027 struct btusb_data *data = hci_get_drvdata(hdev);
2031 spin_lock_irqsave(&data->txlock, flags);
2032 suspending = test_bit(BTUSB_SUSPENDING, &data->flags);
2034 data->tx_in_flight++;
2035 spin_unlock_irqrestore(&data->txlock, flags);
2040 usb_anchor_urb(urb, &data->deferred);
2041 schedule_work(&data->waker);
2094 struct btusb_data *data = hci_get_drvdata(hdev);
2098 if (hci_conn_num(hdev, SCO_LINK) != data->sco_num) {
2099 data->sco_num = hci_conn_num(hdev, SCO_LINK);
2100 data->air_mode = evt;
2101 schedule_work(&data->work);
2107 struct btusb_data *data = hci_get_drvdata(hdev);
2108 struct usb_interface *intf = data->isoc;
2112 if (!data->isoc)
2115 err = usb_set_interface(data->udev, data->isoc_ifnum, altsetting);
2121 data->isoc_altsetting = altsetting;
2123 data->isoc_tx_ep = NULL;
2124 data->isoc_rx_ep = NULL;
2129 if (!data->isoc_tx_ep && usb_endpoint_is_isoc_out(ep_desc)) {
2130 data->isoc_tx_ep = ep_desc;
2134 if (!data->isoc_rx_ep && usb_endpoint_is_isoc_in(ep_desc)) {
2135 data->isoc_rx_ep = ep_desc;
2140 if (!data->isoc_tx_ep || !data->isoc_rx_ep) {
2150 struct btusb_data *data = hci_get_drvdata(hdev);
2153 if (data->isoc_altsetting != new_alts) {
2156 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
2157 usb_kill_anchored_urbs(&data->isoc_anchor);
2168 spin_lock_irqsave(&data->rxlock, flags);
2169 dev_kfree_skb_irq(data->sco_skb);
2170 data->sco_skb = NULL;
2171 spin_unlock_irqrestore(&data->rxlock, flags);
2178 if (!test_and_set_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
2180 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
2188 static struct usb_host_interface *btusb_find_altsetting(struct btusb_data *data,
2191 struct usb_interface *intf = data->isoc;
2209 struct btusb_data *data = container_of(work, struct btusb_data, work);
2210 struct hci_dev *hdev = data->hdev;
2214 if (data->sco_num > 0) {
2215 if (!test_bit(BTUSB_DID_ISO_RESUME, &data->flags)) {
2216 err = usb_autopm_get_interface(data->isoc ? data->isoc : data->intf);
2218 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
2219 usb_kill_anchored_urbs(&data->isoc_anchor);
2223 set_bit(BTUSB_DID_ISO_RESUME, &data->flags);
2226 if (data->air_mode == HCI_NOTIFY_ENABLE_SCO_CVSD) {
2230 new_alts = alts[data->sco_num - 1];
2232 new_alts = data->sco_num;
2234 } else if (data->air_mode == HCI_NOTIFY_ENABLE_SCO_TRANSP) {
2240 * data satisfy 60 bytes), requiring
2244 if (btusb_find_altsetting(data, 6))
2246 else if (btusb_find_altsetting(data, 3) &&
2248 test_bit(BTUSB_USE_ALT3_FOR_WBS, &data->flags))
2257 usb_kill_anchored_urbs(&data->isoc_anchor);
2259 if (test_and_clear_bit(BTUSB_ISOC_RUNNING, &data->flags))
2262 if (test_and_clear_bit(BTUSB_DID_ISO_RESUME, &data->flags))
2263 usb_autopm_put_interface(data->isoc ? data->isoc : data->intf);
2269 struct btusb_data *data = container_of(work, struct btusb_data, waker);
2272 err = usb_autopm_get_interface(data->intf);
2276 usb_autopm_put_interface(data->intf);
2281 struct btusb_data *data = container_of(work, struct btusb_data,
2285 /* Dequeue ACL data received during the interval */
2286 while ((skb = skb_dequeue(&data->acl_q)))
2287 data->recv_acl(data->hdev, skb);
2308 struct btusb_data *data = hci_get_drvdata(hdev);
2309 u16 bcdDevice = le16_to_cpu(data->udev->descriptor.bcdDevice);
2419 * 1. Their bulk RX endpoint will never report any data unless
2421 * 2. They will not wakeup when autosuspended and receiving data
2437 pm_runtime_allow(&data->udev->dev);
2439 ret = pm_runtime_suspend(&data->udev->dev);
2445 pm_runtime_forbid(&data->udev->dev);
2447 device_set_wakeup_capable(&data->udev->dev, false);
2451 usb_enable_autosuspend(data->udev);
2484 static int btusb_recv_bulk_intel(struct btusb_data *data, void *buffer,
2487 struct hci_dev *hdev = data->hdev;
2494 return btusb_recv_intr(data, buffer, count);
2496 return btusb_recv_bulk(data, buffer, count);
2508 struct hci_command_hdr *cmd = (void *)skb->data;
2568 struct btusb_data *data = hci_get_drvdata(hdev);
2573 if (btrealtek_test_flag(data->hdev, REALTEK_ALT6_CONTINUOUS_TX_CHIP))
2574 set_bit(BTUSB_ALT6_CONTINUOUS_TX, &data->flags);
2581 if (skb->data[0] == HCI_VENDOR_PKT && skb->data[2] == RTK_SUB_EVENT_CODE_COREDUMP) {
2589 btusb_rtl_alloc_devcoredump(hdev, &hdr, skb->data, skb->len);
2614 struct btusb_data *data = hci_get_drvdata(hdev);
2637 if (test_bit(BTUSB_TX_WAIT_VND_EVT, &data->flags)) {
2638 data->evt_skb = skb_clone(skb, GFP_ATOMIC);
2639 if (!data->evt_skb) {
2648 kfree_skb(data->evt_skb);
2649 data->evt_skb = NULL;
2655 &data->flags)) {
2658 wake_up_bit(&data->flags,
2668 usb_mark_last_busy(data->udev);
2679 usb_anchor_urb(urb, &data->ctrl_anchor);
2695 struct btusb_data *data = hci_get_drvdata(hdev);
2725 pipe = usb_rcvctrlpipe(data->udev, 0);
2727 usb_fill_control_urb(urb, data->udev, pipe, (void *)dr,
2732 usb_anchor_urb(urb, &data->ctrl_anchor);
2749 struct btusb_data *data = hci_get_drvdata(hdev);
2771 memcpy(wc->data, wmt_params->data, wmt_params->dlen);
2773 set_bit(BTUSB_TX_WAIT_VND_EVT, &data->flags);
2781 err = usb_autopm_get_interface(data->intf);
2788 clear_bit(BTUSB_TX_WAIT_VND_EVT, &data->flags);
2789 usb_autopm_put_interface(data->intf);
2796 usb_autopm_put_interface(data->intf);
2810 err = wait_on_bit_timeout(&data->flags, BTUSB_TX_WAIT_VND_EVT,
2814 clear_bit(BTUSB_TX_WAIT_VND_EVT, &data->flags);
2820 clear_bit(BTUSB_TX_WAIT_VND_EVT, &data->flags);
2825 if (data->evt_skb == NULL)
2829 wmt_evt = (struct btmtk_hci_wmt_evt *)data->evt_skb->data;
2867 kfree_skb(data->evt_skb);
2868 data->evt_skb = NULL;
2884 wmt_params.data = ¶m;
2896 static int btusb_mtk_uhw_reg_write(struct btusb_data *data, u32 reg, u32 val)
2898 struct hci_dev *hdev = data->hdev;
2908 pipe = usb_sndctrlpipe(data->udev, 0);
2909 err = usb_control_msg(data->udev, pipe, 0x02,
2924 static int btusb_mtk_uhw_reg_read(struct btusb_data *data, u32 reg, u32 *val)
2926 struct hci_dev *hdev = data->hdev;
2934 pipe = usb_rcvctrlpipe(data->udev, 0);
2935 err = usb_control_msg(data->udev, pipe, 0x01,
2953 static int btusb_mtk_reg_read(struct btusb_data *data, u32 reg, u32 *val)
2962 pipe = usb_rcvctrlpipe(data->udev, 0);
2963 err = usb_control_msg(data->udev, pipe, 0x63,
2978 static int btusb_mtk_id_get(struct btusb_data *data, u32 reg, u32 *id)
2980 return btusb_mtk_reg_read(data, reg, id);
2985 struct btusb_data *data = hci_get_drvdata(hdev);
2988 btusb_mtk_uhw_reg_read(data, MTK_BT_MISC, &val);
2995 struct btusb_data *data = hci_get_drvdata(hdev);
3001 if (test_and_set_bit(BTUSB_HW_RESET_ACTIVE, &data->flags)) {
3006 err = usb_autopm_get_interface(data->intf);
3010 btusb_stop_traffic(data);
3011 usb_kill_anchored_urbs(&data->tx_anchor);
3015 btusb_mtk_uhw_reg_read(data, MTK_BT_RESET_REG_CONNV3, &val);
3017 btusb_mtk_uhw_reg_write(data, MTK_BT_RESET_REG_CONNV3, val);
3018 btusb_mtk_uhw_reg_read(data, MTK_BT_RESET_REG_CONNV3, &val);
3021 btusb_mtk_uhw_reg_write(data, MTK_BT_RESET_REG_CONNV3, val);
3022 btusb_mtk_uhw_reg_write(data, MTK_EP_RST_OPT, 0x00010001);
3023 btusb_mtk_uhw_reg_read(data, MTK_BT_RESET_REG_CONNV3, &val);
3025 btusb_mtk_uhw_reg_write(data, MTK_BT_RESET_REG_CONNV3, val);
3026 btusb_mtk_uhw_reg_write(data, MTK_UDMA_INT_STA_BT, 0x000000FF);
3027 btusb_mtk_uhw_reg_read(data, MTK_UDMA_INT_STA_BT, &val);
3028 btusb_mtk_uhw_reg_write(data, MTK_UDMA_INT_STA_BT1, 0x000000FF);
3029 btusb_mtk_uhw_reg_read(data, MTK_UDMA_INT_STA_BT1, &val);
3034 btusb_mtk_uhw_reg_write(data, MTK_EP_RST_OPT, MTK_EP_RST_IN_OUT_OPT);
3035 btusb_mtk_uhw_reg_read(data, MTK_BT_WDT_STATUS, &val);
3038 btusb_mtk_uhw_reg_write(data, MTK_BT_SUBSYS_RST, 1);
3039 btusb_mtk_uhw_reg_write(data, MTK_UDMA_INT_STA_BT, 0x000000FF);
3040 btusb_mtk_uhw_reg_read(data, MTK_UDMA_INT_STA_BT, &val);
3041 btusb_mtk_uhw_reg_write(data, MTK_UDMA_INT_STA_BT1, 0x000000FF);
3042 btusb_mtk_uhw_reg_read(data, MTK_UDMA_INT_STA_BT1, &val);
3045 btusb_mtk_uhw_reg_write(data, MTK_BT_SUBSYS_RST, 0);
3046 btusb_mtk_uhw_reg_read(data, MTK_BT_SUBSYS_RST, &val);
3054 btusb_mtk_id_get(data, 0x70010200, &val);
3058 usb_queue_reset_device(data->intf);
3060 clear_bit(BTUSB_HW_RESET_ACTIVE, &data->flags);
3067 struct btusb_data *data = hci_get_drvdata(hdev);
3083 err = btusb_mtk_id_get(data, 0x80000008, &dev_id);
3090 err = btusb_mtk_id_get(data, 0x70010200, &dev_id);
3095 err = btusb_mtk_id_get(data, 0x80021004, &fw_version);
3137 btusb_mtk_uhw_reg_write(data, MTK_EP_RST_OPT, MTK_EP_RST_IN_OUT_OPT);
3144 wmt_params.data = ¶m;
3166 wmt_params.data = NULL;
3208 wmt_params.data = ¶m;
3254 wmt_params.data = ¶m;
3268 struct btusb_data *data = hci_get_drvdata(hdev);
3276 usb_disable_autosuspend(data->udev);
3303 struct btusb_data *data = hci_get_drvdata(hdev);
3304 struct device *dev = &data->udev->dev;
3423 u8 data[0];
3490 sk_ptr = skb->data;
3512 if ((sk_len < offsetof(struct qca_dump_hdr, data))
3545 sk_ptr += offsetof(struct qca_dump_hdr, data);
3546 sk_len -= offsetof(struct qca_dump_hdr, data);
3658 void *data, u16 size)
3678 memcpy(data, buf, size);
3703 memcpy(buf, firmware->data, size);
3729 memcpy(buf, firmware->data + sent, size);
3780 rver = (struct qca_rampatch_version *)(fw->data + info->ver_offset);
3966 struct btusb_data *data = hci_get_drvdata(hdev);
3967 struct usb_interface *intf = data->diag;
3970 if (!data->diag)
3973 data->diag_tx_ep = NULL;
3974 data->diag_rx_ep = NULL;
3981 if (!data->diag_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {
3982 data->diag_tx_ep = ep_desc;
3986 if (!data->diag_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {
3987 data->diag_rx_ep = ep_desc;
3992 if (!data->diag_tx_ep || !data->diag_rx_ep) {
4002 struct btusb_data *data = hci_get_drvdata(hdev);
4007 if (!data->diag_tx_ep)
4023 pipe = usb_sndbulkpipe(data->udev, data->diag_tx_ep->bEndpointAddress);
4025 usb_fill_bulk_urb(urb, data->udev, pipe,
4026 skb->data, skb->len, btusb_tx_complete, skb);
4035 struct btusb_data *data = hci_get_drvdata(hdev);
4038 if (!data->diag)
4054 struct btusb_data *data = priv;
4056 pm_wakeup_event(&data->udev->dev, 0);
4060 if (test_and_clear_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags)) {
4078 struct btusb_data *data = hci_get_drvdata(hdev);
4079 struct device *dev = &data->udev->dev;
4082 clear_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags);
4096 0, "OOB Wake-on-BT", data);
4108 data->oob_wake_irq = irq;
4122 struct btusb_data *data = hci_get_drvdata(hdev);
4124 return device_may_wakeup(&data->udev->dev);
4144 struct btusb_data *data = file->private_data;
4147 buf[0] = data->poll_sync ? 'Y' : 'N';
4157 struct btusb_data *data = file->private_data;
4166 if (test_bit(HCI_UP, &data->hdev->flags))
4169 if (data->poll_sync == enable)
4172 data->poll_sync = enable;
4189 struct btusb_data *data;
4225 data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);
4226 if (!data)
4232 if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {
4233 data->intr_ep = ep_desc;
4237 if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {
4238 data->bulk_tx_ep = ep_desc;
4242 if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {
4243 data->bulk_rx_ep = ep_desc;
4248 if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep)
4252 data->cmdreq_type = USB_TYPE_CLASS | 0x01;
4253 data->cmdreq = 0x2b;
4255 data->cmdreq_type = USB_TYPE_CLASS;
4256 data->cmdreq = 0x00;
4259 data->udev = interface_to_usbdev(intf);
4260 data->intf = intf;
4262 INIT_WORK(&data->work, btusb_work);
4263 INIT_WORK(&data->waker, btusb_waker);
4264 INIT_DELAYED_WORK(&data->rx_work, btusb_rx_work);
4266 skb_queue_head_init(&data->acl_q);
4268 init_usb_anchor(&data->deferred);
4269 init_usb_anchor(&data->tx_anchor);
4270 spin_lock_init(&data->txlock);
4272 init_usb_anchor(&data->intr_anchor);
4273 init_usb_anchor(&data->bulk_anchor);
4274 init_usb_anchor(&data->isoc_anchor);
4275 init_usb_anchor(&data->diag_anchor);
4276 init_usb_anchor(&data->ctrl_anchor);
4277 spin_lock_init(&data->rxlock);
4281 data->recv_event = hci_recv_frame;
4282 data->recv_bulk = btusb_recv_bulk;
4289 data->recv_event = btintel_recv_event;
4290 data->recv_bulk = btusb_recv_bulk_intel;
4295 data->recv_event = btusb_recv_event_realtek;
4301 data->recv_acl = hci_recv_frame;
4308 hci_set_drvdata(hdev, data);
4315 data->hdev = hdev;
4319 reset_gpio = gpiod_get_optional(&data->udev->dev, "reset",
4325 data->reset_gpio = reset_gpio;
4341 if (id->driver_info & BTUSB_MARVELL && data->oob_wake_irq) {
4364 data->diag = usb_ifnum_to_if(data->udev, ifnum_base + 2);
4374 data->diag = usb_ifnum_to_if(data->udev, ifnum_base + 2);
4409 data->recv_acl = btusb_recv_acl_mtk;
4423 data->setup_on_usb = btusb_setup_qca;
4430 data->setup_on_usb = btusb_setup_qca;
4439 data->qca_dump.id_vendor = id->idVendor;
4440 data->qca_dump.id_product = id->idProduct;
4441 data->recv_event = btusb_recv_evt_qca;
4442 data->recv_acl = btusb_recv_acl_qca;
4444 data->setup_on_usb = btusb_setup_qca;
4454 data->isoc = NULL;
4457 data->isoc = usb_ifnum_to_if(data->udev, ifnum_base + 1);
4458 data->isoc_ifnum = ifnum_base + 1;
4470 set_bit(BTUSB_WAKEUP_AUTOSUSPEND, &data->flags);
4471 set_bit(BTUSB_USE_ALT3_FOR_WBS, &data->flags);
4491 data->isoc = NULL;
4500 data->cmdreq_type = USB_TYPE_VENDOR;
4505 struct usb_device *udev = data->udev;
4522 struct usb_device *udev = data->udev;
4533 err = usb_set_interface(data->udev, 0, 0);
4540 if (data->isoc) {
4542 data->isoc, data);
4547 if (IS_ENABLED(CONFIG_BT_HCIBTUSB_BCM) && data->diag) {
4549 data->diag, data))
4552 data->diag = NULL;
4556 usb_enable_autosuspend(data->udev);
4558 data->poll_sync = enable_poll_sync;
4564 usb_set_intfdata(intf, data);
4566 debugfs_create_file("force_poll_sync", 0644, hdev->debugfs, data,
4572 if (data->reset_gpio)
4573 gpiod_put(data->reset_gpio);
4580 struct btusb_data *data = usb_get_intfdata(intf);
4585 if (!data)
4588 hdev = data->hdev;
4589 usb_set_intfdata(data->intf, NULL);
4591 if (data->isoc)
4592 usb_set_intfdata(data->isoc, NULL);
4594 if (data->diag)
4595 usb_set_intfdata(data->diag, NULL);
4599 if (intf == data->intf) {
4600 if (data->isoc)
4601 usb_driver_release_interface(&btusb_driver, data->isoc);
4602 if (data->diag)
4603 usb_driver_release_interface(&btusb_driver, data->diag);
4604 } else if (intf == data->isoc) {
4605 if (data->diag)
4606 usb_driver_release_interface(&btusb_driver, data->diag);
4607 usb_driver_release_interface(&btusb_driver, data->intf);
4608 } else if (intf == data->diag) {
4609 usb_driver_release_interface(&btusb_driver, data->intf);
4610 if (data->isoc)
4611 usb_driver_release_interface(&btusb_driver, data->isoc);
4614 if (data->oob_wake_irq)
4615 device_init_wakeup(&data->udev->dev, false);
4617 if (data->reset_gpio)
4618 gpiod_put(data->reset_gpio);
4626 struct btusb_data *data = usb_get_intfdata(intf);
4630 if (data->suspend_count++)
4633 spin_lock_irq(&data->txlock);
4634 if (!(PMSG_IS_AUTO(message) && data->tx_in_flight)) {
4635 set_bit(BTUSB_SUSPENDING, &data->flags);
4636 spin_unlock_irq(&data->txlock);
4638 spin_unlock_irq(&data->txlock);
4639 data->suspend_count--;
4643 cancel_work_sync(&data->work);
4645 btusb_stop_traffic(data);
4646 usb_kill_anchored_urbs(&data->tx_anchor);
4648 if (data->oob_wake_irq && device_may_wakeup(&data->udev->dev)) {
4649 set_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags);
4650 enable_irq_wake(data->oob_wake_irq);
4651 enable_irq(data->oob_wake_irq);
4659 if (test_bit(BTUSB_WAKEUP_AUTOSUSPEND, &data->flags)) {
4661 device_can_wakeup(&data->udev->dev))
4662 data->udev->do_remote_wakeup = 1;
4664 !device_may_wakeup(&data->udev->dev)) {
4665 data->udev->do_remote_wakeup = 0;
4666 data->udev->reset_resume = 1;
4673 static void play_deferred(struct btusb_data *data)
4678 while ((urb = usb_get_from_anchor(&data->deferred))) {
4679 usb_anchor_urb(urb, &data->tx_anchor);
4685 data->hdev->name, urb, -err);
4692 data->tx_in_flight++;
4697 while ((urb = usb_get_from_anchor(&data->deferred))) {
4705 struct btusb_data *data = usb_get_intfdata(intf);
4706 struct hci_dev *hdev = data->hdev;
4711 if (--data->suspend_count)
4715 if (test_and_clear_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags)) {
4716 disable_irq(data->oob_wake_irq);
4717 disable_irq_wake(data->oob_wake_irq);
4723 if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {
4726 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
4731 if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {
4734 clear_bit(BTUSB_BULK_RUNNING, &data->flags);
4741 if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
4743 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
4748 spin_lock_irq(&data->txlock);
4749 play_deferred(data);
4750 clear_bit(BTUSB_SUSPENDING, &data->flags);
4751 spin_unlock_irq(&data->txlock);
4752 schedule_work(&data->work);
4757 usb_scuttle_anchored_urbs(&data->deferred);
4759 spin_lock_irq(&data->txlock);
4760 clear_bit(BTUSB_SUSPENDING, &data->flags);
4761 spin_unlock_irq(&data->txlock);
4770 struct btusb_data *data = dev_get_drvdata(dev);
4771 struct hci_dev *hdev = data->hdev;