2 * Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
4 * This software is licensed under the terms of the GNU General Public
5 * License version 2, as published by the Free Software Foundation, and
6 * may be copied, distributed, and modified under those terms.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16 #include <linux/module.h>
17 #include <linux/kernel.h>
18 #include <linux/usb.h>
19 #include <linux/sched.h>
20 #include <linux/kthread.h>
21 #include <linux/usb/cdc.h>
22 #include <linux/wait.h>
23 #include <linux/if_ether.h>
24 #include <linux/pm_runtime.h>
29 #include "hci_packet.h"
30 #include "gdm_endian.h"
32 #define USB_DEVICE_CDC_DATA(vid, pid) \
33 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS,\
36 .bInterfaceClass = USB_CLASS_COMM,\
37 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET
39 #define USB_DEVICE_MASS_DATA(vid, pid) \
40 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_INT_INFO,\
43 .bInterfaceSubClass = USB_SC_SCSI, \
44 .bInterfaceClass = USB_CLASS_MASS_STORAGE,\
45 .bInterfaceProtocol = USB_PR_BULK
47 static const struct usb_device_id id_table[] = {
48 { USB_DEVICE_CDC_DATA(VID_GCT, PID_GDM7240) }, /* GCT GDM7240 */
49 { USB_DEVICE_CDC_DATA(VID_GCT, PID_GDM7243) }, /* GCT GDM7243 */
53 MODULE_DEVICE_TABLE(usb, id_table);
55 static struct workqueue_struct *usb_tx_wq;
56 static struct workqueue_struct *usb_rx_wq;
58 static void do_tx(struct work_struct *work);
59 static void do_rx(struct work_struct *work);
61 static int gdm_usb_recv(void *priv_dev,
62 int (*cb)(void *cb_data, void *data, int len, int context),
66 static int request_mac_address(struct lte_udev *udev)
69 struct hci_packet *hci = (struct hci_packet *)buf;
70 struct usb_device *usbdev = udev->usbdev;
74 hci->cmd_evt = gdm_cpu_to_dev16(&udev->gdm_ed, LTE_GET_INFORMATION);
75 hci->len = gdm_cpu_to_dev16(&udev->gdm_ed, 1);
76 hci->data[0] = MAC_ADDRESS;
78 ret = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 2), buf, 5,
81 udev->request_mac_addr = 1;
86 static struct usb_tx *alloc_tx_struct(int len)
88 struct usb_tx *t = NULL;
91 t = kmalloc(sizeof(struct usb_tx), GFP_ATOMIC);
96 memset(t, 0, sizeof(struct usb_tx));
98 t->urb = usb_alloc_urb(0, GFP_ATOMIC);
102 t->buf = kmalloc(len, GFP_ATOMIC);
103 if (!t->urb || !t->buf) {
111 usb_free_urb(t->urb);
121 static struct usb_tx_sdu *alloc_tx_sdu_struct(void)
123 struct usb_tx_sdu *t_sdu = NULL;
127 t_sdu = kmalloc(sizeof(struct usb_tx_sdu), GFP_ATOMIC);
132 memset(t_sdu, 0, sizeof(struct usb_tx_sdu));
134 t_sdu->buf = kmalloc(SDU_BUF_SIZE, GFP_ATOMIC);
152 static void free_tx_struct(struct usb_tx *t)
155 usb_free_urb(t->urb);
161 static void free_tx_sdu_struct(struct usb_tx_sdu *t_sdu)
169 static struct usb_tx_sdu *get_tx_sdu_struct(struct tx_cxt *tx, int *no_spc)
171 struct usb_tx_sdu *t_sdu;
173 if (list_empty(&tx->free_list))
176 t_sdu = list_entry(tx->free_list.next, struct usb_tx_sdu, list);
177 list_del(&t_sdu->list);
181 *no_spc = list_empty(&tx->free_list) ? 1 : 0;
186 static void put_tx_struct(struct tx_cxt *tx, struct usb_tx_sdu *t_sdu)
188 list_add_tail(&t_sdu->list, &tx->free_list);
192 static struct usb_rx *alloc_rx_struct(void)
194 struct usb_rx *r = NULL;
197 r = kmalloc(sizeof(struct usb_rx), GFP_ATOMIC);
203 r->urb = usb_alloc_urb(0, GFP_ATOMIC);
204 r->buf = kmalloc(RX_BUF_SIZE, GFP_ATOMIC);
205 if (!r->urb || !r->buf) {
213 usb_free_urb(r->urb);
223 static void free_rx_struct(struct usb_rx *r)
226 usb_free_urb(r->urb);
232 static struct usb_rx *get_rx_struct(struct rx_cxt *rx, int *no_spc)
237 spin_lock_irqsave(&rx->rx_lock, flags);
239 if (list_empty(&rx->free_list)) {
240 spin_unlock_irqrestore(&rx->rx_lock, flags);
244 r = list_entry(rx->free_list.next, struct usb_rx, free_list);
245 list_del(&r->free_list);
249 *no_spc = list_empty(&rx->free_list) ? 1 : 0;
251 spin_unlock_irqrestore(&rx->rx_lock, flags);
256 static void put_rx_struct(struct rx_cxt *rx, struct usb_rx *r)
260 spin_lock_irqsave(&rx->rx_lock, flags);
262 list_add_tail(&r->free_list, &rx->free_list);
265 spin_unlock_irqrestore(&rx->rx_lock, flags);
268 static void release_usb(struct lte_udev *udev)
270 struct rx_cxt *rx = &udev->rx;
271 struct tx_cxt *tx = &udev->tx;
272 struct usb_tx *t, *t_next;
273 struct usb_rx *r, *r_next;
274 struct usb_tx_sdu *t_sdu, *t_sdu_next;
277 spin_lock_irqsave(&tx->lock, flags);
278 list_for_each_entry_safe(t_sdu, t_sdu_next, &tx->sdu_list, list)
280 list_del(&t_sdu->list);
281 free_tx_sdu_struct(t_sdu);
284 list_for_each_entry_safe(t, t_next, &tx->hci_list, list)
290 list_for_each_entry_safe(t_sdu, t_sdu_next, &tx->free_list, list)
292 list_del(&t_sdu->list);
293 free_tx_sdu_struct(t_sdu);
295 spin_unlock_irqrestore(&tx->lock, flags);
297 spin_lock_irqsave(&rx->submit_lock, flags);
298 list_for_each_entry_safe(r, r_next, &rx->rx_submit_list, rx_submit_list)
300 spin_unlock_irqrestore(&rx->submit_lock, flags);
301 usb_kill_urb(r->urb);
302 spin_lock_irqsave(&rx->submit_lock, flags);
304 spin_unlock_irqrestore(&rx->submit_lock, flags);
306 spin_lock_irqsave(&rx->rx_lock, flags);
307 list_for_each_entry_safe(r, r_next, &rx->free_list, free_list)
309 list_del(&r->free_list);
312 spin_unlock_irqrestore(&rx->rx_lock, flags);
314 spin_lock_irqsave(&rx->to_host_lock, flags);
315 list_for_each_entry_safe(r, r_next, &rx->to_host_list, to_host_list)
317 if (r->index == (void *)udev) {
318 list_del(&r->to_host_list);
322 spin_unlock_irqrestore(&rx->to_host_lock, flags);
325 static int init_usb(struct lte_udev *udev)
329 struct tx_cxt *tx = &udev->tx;
330 struct rx_cxt *rx = &udev->rx;
331 struct usb_tx_sdu *t_sdu = NULL;
332 struct usb_rx *r = NULL;
334 udev->send_complete = 1;
336 udev->request_mac_addr = 0;
337 udev->usb_state = PM_NORMAL;
339 INIT_LIST_HEAD(&tx->sdu_list);
340 INIT_LIST_HEAD(&tx->hci_list);
341 INIT_LIST_HEAD(&tx->free_list);
342 INIT_LIST_HEAD(&rx->rx_submit_list);
343 INIT_LIST_HEAD(&rx->free_list);
344 INIT_LIST_HEAD(&rx->to_host_list);
345 spin_lock_init(&tx->lock);
346 spin_lock_init(&rx->rx_lock);
347 spin_lock_init(&rx->submit_lock);
348 spin_lock_init(&rx->to_host_lock);
355 for (i = 0; i < MAX_NUM_SDU_BUF; i++) {
356 t_sdu = alloc_tx_sdu_struct();
362 list_add(&t_sdu->list, &tx->free_list);
366 for (i = 0; i < MAX_RX_SUBMIT_COUNT*2; i++) {
367 r = alloc_rx_struct();
373 list_add(&r->free_list, &rx->free_list);
376 INIT_DELAYED_WORK(&udev->work_tx, do_tx);
377 INIT_DELAYED_WORK(&udev->work_rx, do_rx);
383 static int set_mac_address(u8 *data, void *arg)
385 struct phy_dev *phy_dev = (struct phy_dev *)arg;
386 struct lte_udev *udev = phy_dev->priv_dev;
387 struct tlv *tlv = (struct tlv *)data;
388 u8 mac_address[ETH_ALEN] = {0, };
390 if (tlv->type == MAC_ADDRESS && udev->request_mac_addr) {
391 memcpy(mac_address, tlv->data, tlv->len);
393 if (register_lte_device(phy_dev, &udev->intf->dev, mac_address) < 0)
394 pr_err("register lte device failed\n");
396 udev->request_mac_addr = 0;
404 static void do_rx(struct work_struct *work)
406 struct lte_udev *udev = container_of(work, struct lte_udev, work_rx.work);
407 struct rx_cxt *rx = &udev->rx;
409 struct hci_packet *hci;
410 struct phy_dev *phy_dev;
416 spin_lock_irqsave(&rx->to_host_lock, flags);
417 if (list_empty(&rx->to_host_list)) {
418 spin_unlock_irqrestore(&rx->to_host_lock, flags);
421 r = list_entry(rx->to_host_list.next, struct usb_rx, to_host_list);
422 list_del(&r->to_host_list);
423 spin_unlock_irqrestore(&rx->to_host_lock, flags);
425 phy_dev = (struct phy_dev *)r->cb_data;
426 udev = (struct lte_udev *)phy_dev->priv_dev;
427 hci = (struct hci_packet *)r->buf;
428 cmd_evt = gdm_dev16_to_cpu(&udev->gdm_ed, hci->cmd_evt);
431 case LTE_GET_INFORMATION_RESULT:
432 if (set_mac_address(hci->data, r->cb_data) == 0) {
433 ret = r->callback(r->cb_data,
435 r->urb->actual_length,
442 ret = r->callback(r->cb_data,
444 r->urb->actual_length,
448 pr_err("failed to send received data\n");
453 put_rx_struct(rx, r);
462 static void remove_rx_submit_list(struct usb_rx *r, struct rx_cxt *rx)
465 struct usb_rx *r_remove, *r_remove_next;
467 spin_lock_irqsave(&rx->submit_lock, flags);
468 list_for_each_entry_safe(r_remove, r_remove_next, &rx->rx_submit_list, rx_submit_list)
471 list_del(&r->rx_submit_list);
475 spin_unlock_irqrestore(&rx->submit_lock, flags);
478 static void gdm_usb_rcv_complete(struct urb *urb)
480 struct usb_rx *r = urb->context;
481 struct rx_cxt *rx = r->rx;
483 struct lte_udev *udev = container_of(r->rx, struct lte_udev, rx);
484 struct usb_device *usbdev = udev->usbdev;
486 remove_rx_submit_list(r, rx);
488 if (!urb->status && r->callback) {
489 spin_lock_irqsave(&rx->to_host_lock, flags);
490 list_add_tail(&r->to_host_list, &rx->to_host_list);
491 queue_work(usb_rx_wq, &udev->work_rx.work);
492 spin_unlock_irqrestore(&rx->to_host_lock, flags);
494 if (urb->status && udev->usb_state == PM_NORMAL)
495 pr_err("%s: urb status error %d\n",
496 __func__, urb->status);
498 put_rx_struct(rx, r);
501 usb_mark_last_busy(usbdev);
504 static int gdm_usb_recv(void *priv_dev,
505 int (*cb)(void *cb_data, void *data, int len, int context),
509 struct lte_udev *udev = priv_dev;
510 struct usb_device *usbdev = udev->usbdev;
511 struct rx_cxt *rx = &udev->rx;
518 pr_err("invalid device\n");
522 r = get_rx_struct(rx, &no_spc);
524 pr_err("Out of Memory\n");
530 r->cb_data = cb_data;
531 r->index = (void *)udev;
534 usb_fill_bulk_urb(r->urb,
536 usb_rcvbulkpipe(usbdev, 0x83),
539 gdm_usb_rcv_complete,
542 spin_lock_irqsave(&rx->submit_lock, flags);
543 list_add_tail(&r->rx_submit_list, &rx->rx_submit_list);
544 spin_unlock_irqrestore(&rx->submit_lock, flags);
546 if (context == KERNEL_THREAD)
547 ret = usb_submit_urb(r->urb, GFP_KERNEL);
549 ret = usb_submit_urb(r->urb, GFP_ATOMIC);
552 spin_lock_irqsave(&rx->submit_lock, flags);
553 list_del(&r->rx_submit_list);
554 spin_unlock_irqrestore(&rx->submit_lock, flags);
556 pr_err("usb_submit_urb failed (%p)\n", r);
557 put_rx_struct(rx, r);
563 static void gdm_usb_send_complete(struct urb *urb)
565 struct usb_tx *t = urb->context;
566 struct tx_cxt *tx = t->tx;
567 struct lte_udev *udev = container_of(tx, struct lte_udev, tx);
570 if (urb->status == -ECONNRESET) {
571 pr_info("CONNRESET\n");
576 t->callback(t->cb_data);
580 spin_lock_irqsave(&tx->lock, flags);
581 udev->send_complete = 1;
582 queue_work(usb_tx_wq, &udev->work_tx.work);
583 spin_unlock_irqrestore(&tx->lock, flags);
586 static int send_tx_packet(struct usb_device *usbdev, struct usb_tx *t, u32 len)
593 usb_fill_bulk_urb(t->urb,
595 usb_sndbulkpipe(usbdev, 2),
598 gdm_usb_send_complete,
601 ret = usb_submit_urb(t->urb, GFP_ATOMIC);
604 pr_err("usb_submit_urb failed: %d\n", ret);
606 usb_mark_last_busy(usbdev);
611 static u32 packet_aggregation(struct lte_udev *udev, u8 *send_buf)
613 struct tx_cxt *tx = &udev->tx;
614 struct usb_tx_sdu *t_sdu = NULL;
615 struct multi_sdu *multi_sdu = (struct multi_sdu *)send_buf;
620 multi_sdu->cmd_evt = gdm_cpu_to_dev16(&udev->gdm_ed, LTE_TX_MULTI_SDU);
622 while (num_packet < MAX_PACKET_IN_MULTI_SDU) {
623 spin_lock_irqsave(&tx->lock, flags);
624 if (list_empty(&tx->sdu_list)) {
625 spin_unlock_irqrestore(&tx->lock, flags);
629 t_sdu = list_entry(tx->sdu_list.next, struct usb_tx_sdu, list);
630 if (send_len + t_sdu->len > MAX_SDU_SIZE) {
631 spin_unlock_irqrestore(&tx->lock, flags);
635 list_del(&t_sdu->list);
636 spin_unlock_irqrestore(&tx->lock, flags);
638 memcpy(multi_sdu->data + send_len, t_sdu->buf, t_sdu->len);
640 send_len += (t_sdu->len + 3) & 0xfffc;
643 if (tx->avail_count > 10)
644 t_sdu->callback(t_sdu->cb_data);
646 spin_lock_irqsave(&tx->lock, flags);
647 put_tx_struct(tx, t_sdu);
648 spin_unlock_irqrestore(&tx->lock, flags);
651 multi_sdu->len = gdm_cpu_to_dev16(&udev->gdm_ed, send_len);
652 multi_sdu->num_packet = gdm_cpu_to_dev16(&udev->gdm_ed, num_packet);
654 return send_len + offsetof(struct multi_sdu, data);
657 static void do_tx(struct work_struct *work)
659 struct lte_udev *udev = container_of(work, struct lte_udev, work_tx.work);
660 struct usb_device *usbdev = udev->usbdev;
661 struct tx_cxt *tx = &udev->tx;
662 struct usb_tx *t = NULL;
667 if (!usb_autopm_get_interface(udev->intf))
668 usb_autopm_put_interface(udev->intf);
670 if (udev->usb_state == PM_SUSPEND)
673 spin_lock_irqsave(&tx->lock, flags);
674 if (!udev->send_complete) {
675 spin_unlock_irqrestore(&tx->lock, flags);
678 udev->send_complete = 0;
681 if (!list_empty(&tx->hci_list)) {
682 t = list_entry(tx->hci_list.next, struct usb_tx, list);
687 } else if (!list_empty(&tx->sdu_list)) {
689 udev->send_complete = 1;
690 spin_unlock_irqrestore(&tx->lock, flags);
694 t = alloc_tx_struct(TX_BUF_SIZE);
702 udev->send_complete = 1;
703 spin_unlock_irqrestore(&tx->lock, flags);
706 spin_unlock_irqrestore(&tx->lock, flags);
709 len = packet_aggregation(udev, t->buf);
711 if (send_tx_packet(usbdev, t, len)) {
712 pr_err("send_tx_packet failed\n");
714 gdm_usb_send_complete(t->urb);
718 #define SDU_PARAM_LEN 12
719 static int gdm_usb_sdu_send(void *priv_dev, void *data, int len,
720 unsigned int dftEpsId, unsigned int epsId,
721 void (*cb)(void *data), void *cb_data,
722 int dev_idx, int nic_type)
724 struct lte_udev *udev = priv_dev;
725 struct tx_cxt *tx = &udev->tx;
726 struct usb_tx_sdu *t_sdu;
727 struct sdu *sdu = NULL;
733 pr_err("sdu send - invalid device\n");
737 spin_lock_irqsave(&tx->lock, flags);
738 t_sdu = get_tx_sdu_struct(tx, &no_spc);
739 spin_unlock_irqrestore(&tx->lock, flags);
742 pr_err("sdu send - free list empty\n");
746 sdu = (struct sdu *)t_sdu->buf;
747 sdu->cmd_evt = gdm_cpu_to_dev16(&udev->gdm_ed, LTE_TX_SDU);
748 if (nic_type == NIC_TYPE_ARP) {
749 send_len = len + SDU_PARAM_LEN;
750 memcpy(sdu->data, data, len);
752 send_len = len - ETH_HLEN;
753 send_len += SDU_PARAM_LEN;
754 memcpy(sdu->data, data+ETH_HLEN, len-ETH_HLEN);
757 sdu->len = gdm_cpu_to_dev16(&udev->gdm_ed, send_len);
758 sdu->dftEpsId = gdm_cpu_to_dev32(&udev->gdm_ed, dftEpsId);
759 sdu->bearer_ID = gdm_cpu_to_dev32(&udev->gdm_ed, epsId);
760 sdu->nic_type = gdm_cpu_to_dev32(&udev->gdm_ed, nic_type);
762 t_sdu->len = send_len + HCI_HEADER_SIZE;
763 t_sdu->callback = cb;
764 t_sdu->cb_data = cb_data;
766 spin_lock_irqsave(&tx->lock, flags);
767 list_add_tail(&t_sdu->list, &tx->sdu_list);
768 queue_work(usb_tx_wq, &udev->work_tx.work);
769 spin_unlock_irqrestore(&tx->lock, flags);
777 static int gdm_usb_hci_send(void *priv_dev, void *data, int len,
778 void (*cb)(void *data), void *cb_data)
780 struct lte_udev *udev = priv_dev;
781 struct tx_cxt *tx = &udev->tx;
786 pr_err("hci send - invalid device\n");
790 t = alloc_tx_struct(len);
792 pr_err("hci_send - out of memory\n");
796 memcpy(t->buf, data, len);
798 t->cb_data = cb_data;
803 spin_lock_irqsave(&tx->lock, flags);
804 list_add_tail(&t->list, &tx->hci_list);
805 queue_work(usb_tx_wq, &udev->work_tx.work);
806 spin_unlock_irqrestore(&tx->lock, flags);
811 static struct gdm_endian *gdm_usb_get_endian(void *priv_dev)
813 struct lte_udev *udev = priv_dev;
815 return &udev->gdm_ed;
818 static int gdm_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
821 struct phy_dev *phy_dev = NULL;
822 struct lte_udev *udev = NULL;
823 u16 idVendor, idProduct;
824 int bInterfaceNumber;
825 struct usb_device *usbdev = interface_to_usbdev(intf);
827 bInterfaceNumber = intf->cur_altsetting->desc.bInterfaceNumber;
828 idVendor = __le16_to_cpu(usbdev->descriptor.idVendor);
829 idProduct = __le16_to_cpu(usbdev->descriptor.idProduct);
831 pr_info("net vid = 0x%04x pid = 0x%04x\n", idVendor, idProduct);
833 if (bInterfaceNumber > NETWORK_INTERFACE) {
834 pr_info("not a network device\n");
838 phy_dev = kmalloc(sizeof(struct phy_dev), GFP_ATOMIC);
844 udev = kmalloc(sizeof(struct lte_udev), GFP_ATOMIC);
850 memset(phy_dev, 0, sizeof(struct phy_dev));
851 memset(udev, 0, sizeof(struct lte_udev));
853 phy_dev->priv_dev = (void *)udev;
854 phy_dev->send_hci_func = gdm_usb_hci_send;
855 phy_dev->send_sdu_func = gdm_usb_sdu_send;
856 phy_dev->rcv_func = gdm_usb_recv;
857 phy_dev->get_endian = gdm_usb_get_endian;
859 udev->usbdev = usbdev;
860 ret = init_usb(udev);
862 pr_err("init_usb func failed\n");
867 intf->needs_remote_wakeup = 1;
868 usb_enable_autosuspend(usbdev);
869 pm_runtime_set_autosuspend_delay(&usbdev->dev, AUTO_SUSPEND_TIMER);
871 /* List up hosts with big endians, otherwise, defaults to little endian */
872 if (idProduct == PID_GDM7243)
873 gdm_set_endian(&udev->gdm_ed, ENDIANNESS_BIG);
875 gdm_set_endian(&udev->gdm_ed, ENDIANNESS_LITTLE);
877 ret = request_mac_address(udev);
879 pr_err("request Mac address failed\n");
883 start_rx_proc(phy_dev);
895 usb_set_intfdata(intf, phy_dev);
900 static void gdm_usb_disconnect(struct usb_interface *intf)
902 struct phy_dev *phy_dev;
903 struct lte_udev *udev;
904 u16 idVendor, idProduct;
905 struct usb_device *usbdev;
906 usbdev = interface_to_usbdev(intf);
908 idVendor = __le16_to_cpu(usbdev->descriptor.idVendor);
909 idProduct = __le16_to_cpu(usbdev->descriptor.idProduct);
911 phy_dev = usb_get_intfdata(intf);
913 udev = phy_dev->priv_dev;
914 unregister_lte_device(phy_dev);
927 static int gdm_usb_suspend(struct usb_interface *intf, pm_message_t pm_msg)
929 struct phy_dev *phy_dev;
930 struct lte_udev *udev;
933 struct usb_rx *r_next;
936 phy_dev = usb_get_intfdata(intf);
937 udev = phy_dev->priv_dev;
939 if (udev->usb_state != PM_NORMAL) {
940 pr_err("usb suspend - invalid state\n");
944 udev->usb_state = PM_SUSPEND;
946 spin_lock_irqsave(&rx->submit_lock, flags);
947 list_for_each_entry_safe(r, r_next, &rx->rx_submit_list, rx_submit_list)
949 spin_unlock_irqrestore(&rx->submit_lock, flags);
950 usb_kill_urb(r->urb);
951 spin_lock_irqsave(&rx->submit_lock, flags);
953 spin_unlock_irqrestore(&rx->submit_lock, flags);
958 static int gdm_usb_resume(struct usb_interface *intf)
960 struct phy_dev *phy_dev;
961 struct lte_udev *udev;
968 phy_dev = usb_get_intfdata(intf);
969 udev = phy_dev->priv_dev;
972 if (udev->usb_state != PM_SUSPEND) {
973 pr_err("usb resume - invalid state\n");
976 udev->usb_state = PM_NORMAL;
978 spin_lock_irqsave(&rx->rx_lock, flags);
979 issue_count = rx->avail_count - MAX_RX_SUBMIT_COUNT;
980 spin_unlock_irqrestore(&rx->rx_lock, flags);
982 if (issue_count >= 0) {
983 for (i = 0; i < issue_count; i++)
984 gdm_usb_recv(phy_dev->priv_dev,
991 spin_lock_irqsave(&tx->lock, flags);
992 queue_work(usb_tx_wq, &udev->work_tx.work);
993 spin_unlock_irqrestore(&tx->lock, flags);
998 static struct usb_driver gdm_usb_lte_driver = {
1000 .probe = gdm_usb_probe,
1001 .disconnect = gdm_usb_disconnect,
1002 .id_table = id_table,
1003 .supports_autosuspend = 1,
1004 .suspend = gdm_usb_suspend,
1005 .resume = gdm_usb_resume,
1006 .reset_resume = gdm_usb_resume,
1009 static int __init gdm_usb_lte_init(void)
1011 if (gdm_lte_event_init() < 0) {
1012 pr_err("error creating event\n");
1016 usb_tx_wq = create_workqueue("usb_tx_wq");
1017 if (usb_tx_wq == NULL)
1020 usb_rx_wq = create_workqueue("usb_rx_wq");
1021 if (usb_rx_wq == NULL)
1024 return usb_register(&gdm_usb_lte_driver);
1027 static void __exit gdm_usb_lte_exit(void)
1029 gdm_lte_event_exit();
1031 usb_deregister(&gdm_usb_lte_driver);
1034 flush_workqueue(usb_tx_wq);
1035 destroy_workqueue(usb_tx_wq);
1039 flush_workqueue(usb_rx_wq);
1040 destroy_workqueue(usb_rx_wq);
1044 module_init(gdm_usb_lte_init);
1045 module_exit(gdm_usb_lte_exit);
1047 MODULE_VERSION(DRIVER_VERSION);
1048 MODULE_DESCRIPTION("GCT LTE USB Device Driver");
1049 MODULE_LICENSE("GPL");