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 | \
34 USB_DEVICE_ID_MATCH_INT_CLASS | \
35 USB_DEVICE_ID_MATCH_INT_SUBCLASS,\
38 .bInterfaceClass = USB_CLASS_COMM,\
39 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET
41 #define USB_DEVICE_MASS_DATA(vid, pid) \
42 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
43 USB_DEVICE_ID_MATCH_INT_INFO,\
46 .bInterfaceSubClass = USB_SC_SCSI, \
47 .bInterfaceClass = USB_CLASS_MASS_STORAGE,\
48 .bInterfaceProtocol = USB_PR_BULK
50 static const struct usb_device_id id_table[] = {
51 { USB_DEVICE_CDC_DATA(VID_GCT, PID_GDM7240) }, /* GCT GDM7240 */
52 { USB_DEVICE_CDC_DATA(VID_GCT, PID_GDM7243) }, /* GCT GDM7243 */
56 MODULE_DEVICE_TABLE(usb, id_table);
58 static struct workqueue_struct *usb_tx_wq;
59 static struct workqueue_struct *usb_rx_wq;
61 static void do_tx(struct work_struct *work);
62 static void do_rx(struct work_struct *work);
64 static int gdm_usb_recv(void *priv_dev,
65 int (*cb)(void *cb_data,
66 void *data, int len, int context),
70 static int request_mac_address(struct lte_udev *udev)
73 struct hci_packet *hci = (struct hci_packet *)buf;
74 struct usb_device *usbdev = udev->usbdev;
78 hci->cmd_evt = gdm_cpu_to_dev16(&udev->gdm_ed, LTE_GET_INFORMATION);
79 hci->len = gdm_cpu_to_dev16(&udev->gdm_ed, 1);
80 hci->data[0] = MAC_ADDRESS;
82 ret = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 2), buf, 5,
85 udev->request_mac_addr = 1;
90 static struct usb_tx *alloc_tx_struct(int len)
92 struct usb_tx *t = NULL;
95 t = kzalloc(sizeof(struct usb_tx), GFP_ATOMIC);
101 t->urb = usb_alloc_urb(0, GFP_ATOMIC);
105 t->buf = kmalloc(len, GFP_ATOMIC);
106 if (!t->urb || !t->buf) {
114 usb_free_urb(t->urb);
124 static struct usb_tx_sdu *alloc_tx_sdu_struct(void)
126 struct usb_tx_sdu *t_sdu;
128 t_sdu = kzalloc(sizeof(struct usb_tx_sdu), GFP_ATOMIC);
132 t_sdu->buf = kmalloc(SDU_BUF_SIZE, GFP_ATOMIC);
141 static void free_tx_struct(struct usb_tx *t)
144 usb_free_urb(t->urb);
150 static void free_tx_sdu_struct(struct usb_tx_sdu *t_sdu)
158 static struct usb_tx_sdu *get_tx_sdu_struct(struct tx_cxt *tx, int *no_spc)
160 struct usb_tx_sdu *t_sdu;
162 if (list_empty(&tx->free_list))
165 t_sdu = list_entry(tx->free_list.next, struct usb_tx_sdu, list);
166 list_del(&t_sdu->list);
170 *no_spc = list_empty(&tx->free_list) ? 1 : 0;
175 static void put_tx_struct(struct tx_cxt *tx, struct usb_tx_sdu *t_sdu)
177 list_add_tail(&t_sdu->list, &tx->free_list);
181 static struct usb_rx *alloc_rx_struct(void)
183 struct usb_rx *r = NULL;
186 r = kmalloc(sizeof(struct usb_rx), GFP_ATOMIC);
192 r->urb = usb_alloc_urb(0, GFP_ATOMIC);
193 r->buf = kmalloc(RX_BUF_SIZE, GFP_ATOMIC);
194 if (!r->urb || !r->buf) {
202 usb_free_urb(r->urb);
212 static void free_rx_struct(struct usb_rx *r)
215 usb_free_urb(r->urb);
221 static struct usb_rx *get_rx_struct(struct rx_cxt *rx, int *no_spc)
226 spin_lock_irqsave(&rx->rx_lock, flags);
228 if (list_empty(&rx->free_list)) {
229 spin_unlock_irqrestore(&rx->rx_lock, flags);
233 r = list_entry(rx->free_list.next, struct usb_rx, free_list);
234 list_del(&r->free_list);
238 *no_spc = list_empty(&rx->free_list) ? 1 : 0;
240 spin_unlock_irqrestore(&rx->rx_lock, flags);
245 static void put_rx_struct(struct rx_cxt *rx, struct usb_rx *r)
249 spin_lock_irqsave(&rx->rx_lock, flags);
251 list_add_tail(&r->free_list, &rx->free_list);
254 spin_unlock_irqrestore(&rx->rx_lock, flags);
257 static void release_usb(struct lte_udev *udev)
259 struct rx_cxt *rx = &udev->rx;
260 struct tx_cxt *tx = &udev->tx;
261 struct usb_tx *t, *t_next;
262 struct usb_rx *r, *r_next;
263 struct usb_tx_sdu *t_sdu, *t_sdu_next;
266 spin_lock_irqsave(&tx->lock, flags);
267 list_for_each_entry_safe(t_sdu, t_sdu_next, &tx->sdu_list, list)
269 list_del(&t_sdu->list);
270 free_tx_sdu_struct(t_sdu);
273 list_for_each_entry_safe(t, t_next, &tx->hci_list, list)
279 list_for_each_entry_safe(t_sdu, t_sdu_next, &tx->free_list, list)
281 list_del(&t_sdu->list);
282 free_tx_sdu_struct(t_sdu);
284 spin_unlock_irqrestore(&tx->lock, flags);
286 spin_lock_irqsave(&rx->submit_lock, flags);
287 list_for_each_entry_safe(r, r_next, &rx->rx_submit_list, rx_submit_list)
289 spin_unlock_irqrestore(&rx->submit_lock, flags);
290 usb_kill_urb(r->urb);
291 spin_lock_irqsave(&rx->submit_lock, flags);
293 spin_unlock_irqrestore(&rx->submit_lock, flags);
295 spin_lock_irqsave(&rx->rx_lock, flags);
296 list_for_each_entry_safe(r, r_next, &rx->free_list, free_list)
298 list_del(&r->free_list);
301 spin_unlock_irqrestore(&rx->rx_lock, flags);
303 spin_lock_irqsave(&rx->to_host_lock, flags);
304 list_for_each_entry_safe(r, r_next, &rx->to_host_list, to_host_list)
306 if (r->index == (void *)udev) {
307 list_del(&r->to_host_list);
311 spin_unlock_irqrestore(&rx->to_host_lock, flags);
314 static int init_usb(struct lte_udev *udev)
318 struct tx_cxt *tx = &udev->tx;
319 struct rx_cxt *rx = &udev->rx;
320 struct usb_tx_sdu *t_sdu = NULL;
321 struct usb_rx *r = NULL;
323 udev->send_complete = 1;
325 udev->request_mac_addr = 0;
326 udev->usb_state = PM_NORMAL;
328 INIT_LIST_HEAD(&tx->sdu_list);
329 INIT_LIST_HEAD(&tx->hci_list);
330 INIT_LIST_HEAD(&tx->free_list);
331 INIT_LIST_HEAD(&rx->rx_submit_list);
332 INIT_LIST_HEAD(&rx->free_list);
333 INIT_LIST_HEAD(&rx->to_host_list);
334 spin_lock_init(&tx->lock);
335 spin_lock_init(&rx->rx_lock);
336 spin_lock_init(&rx->submit_lock);
337 spin_lock_init(&rx->to_host_lock);
344 for (i = 0; i < MAX_NUM_SDU_BUF; i++) {
345 t_sdu = alloc_tx_sdu_struct();
351 list_add(&t_sdu->list, &tx->free_list);
355 for (i = 0; i < MAX_RX_SUBMIT_COUNT*2; i++) {
356 r = alloc_rx_struct();
362 list_add(&r->free_list, &rx->free_list);
365 INIT_DELAYED_WORK(&udev->work_tx, do_tx);
366 INIT_DELAYED_WORK(&udev->work_rx, do_rx);
372 static int set_mac_address(u8 *data, void *arg)
374 struct phy_dev *phy_dev = (struct phy_dev *)arg;
375 struct lte_udev *udev = phy_dev->priv_dev;
376 struct tlv *tlv = (struct tlv *)data;
377 u8 mac_address[ETH_ALEN] = {0, };
379 if (tlv->type == MAC_ADDRESS && udev->request_mac_addr) {
380 memcpy(mac_address, tlv->data, tlv->len);
382 if (register_lte_device(phy_dev,
383 &udev->intf->dev, mac_address) < 0)
384 pr_err("register lte device failed\n");
386 udev->request_mac_addr = 0;
394 static void do_rx(struct work_struct *work)
396 struct lte_udev *udev =
397 container_of(work, struct lte_udev, work_rx.work);
398 struct rx_cxt *rx = &udev->rx;
400 struct hci_packet *hci;
401 struct phy_dev *phy_dev;
407 spin_lock_irqsave(&rx->to_host_lock, flags);
408 if (list_empty(&rx->to_host_list)) {
409 spin_unlock_irqrestore(&rx->to_host_lock, flags);
412 r = list_entry(rx->to_host_list.next,
413 struct usb_rx, to_host_list);
414 list_del(&r->to_host_list);
415 spin_unlock_irqrestore(&rx->to_host_lock, flags);
417 phy_dev = (struct phy_dev *)r->cb_data;
418 udev = (struct lte_udev *)phy_dev->priv_dev;
419 hci = (struct hci_packet *)r->buf;
420 cmd_evt = gdm_dev16_to_cpu(&udev->gdm_ed, hci->cmd_evt);
423 case LTE_GET_INFORMATION_RESULT:
424 if (set_mac_address(hci->data, r->cb_data) == 0) {
425 ret = r->callback(r->cb_data,
427 r->urb->actual_length,
434 ret = r->callback(r->cb_data,
436 r->urb->actual_length,
440 pr_err("failed to send received data\n");
445 put_rx_struct(rx, r);
454 static void remove_rx_submit_list(struct usb_rx *r, struct rx_cxt *rx)
457 struct usb_rx *r_remove, *r_remove_next;
459 spin_lock_irqsave(&rx->submit_lock, flags);
460 list_for_each_entry_safe(r_remove,
461 r_remove_next, &rx->rx_submit_list, rx_submit_list)
464 list_del(&r->rx_submit_list);
468 spin_unlock_irqrestore(&rx->submit_lock, flags);
471 static void gdm_usb_rcv_complete(struct urb *urb)
473 struct usb_rx *r = urb->context;
474 struct rx_cxt *rx = r->rx;
476 struct lte_udev *udev = container_of(r->rx, struct lte_udev, rx);
477 struct usb_device *usbdev = udev->usbdev;
479 remove_rx_submit_list(r, rx);
481 if (!urb->status && r->callback) {
482 spin_lock_irqsave(&rx->to_host_lock, flags);
483 list_add_tail(&r->to_host_list, &rx->to_host_list);
484 queue_work(usb_rx_wq, &udev->work_rx.work);
485 spin_unlock_irqrestore(&rx->to_host_lock, flags);
487 if (urb->status && udev->usb_state == PM_NORMAL)
488 pr_err("%s: urb status error %d\n",
489 __func__, urb->status);
491 put_rx_struct(rx, r);
494 usb_mark_last_busy(usbdev);
497 static int gdm_usb_recv(void *priv_dev,
498 int (*cb)(void *cb_data,
499 void *data, int len, int context),
503 struct lte_udev *udev = priv_dev;
504 struct usb_device *usbdev = udev->usbdev;
505 struct rx_cxt *rx = &udev->rx;
512 pr_err("invalid device\n");
516 r = get_rx_struct(rx, &no_spc);
518 pr_err("Out of Memory\n");
524 r->cb_data = cb_data;
525 r->index = (void *)udev;
528 usb_fill_bulk_urb(r->urb,
530 usb_rcvbulkpipe(usbdev, 0x83),
533 gdm_usb_rcv_complete,
536 spin_lock_irqsave(&rx->submit_lock, flags);
537 list_add_tail(&r->rx_submit_list, &rx->rx_submit_list);
538 spin_unlock_irqrestore(&rx->submit_lock, flags);
540 if (context == KERNEL_THREAD)
541 ret = usb_submit_urb(r->urb, GFP_KERNEL);
543 ret = usb_submit_urb(r->urb, GFP_ATOMIC);
546 spin_lock_irqsave(&rx->submit_lock, flags);
547 list_del(&r->rx_submit_list);
548 spin_unlock_irqrestore(&rx->submit_lock, flags);
550 pr_err("usb_submit_urb failed (%p)\n", r);
551 put_rx_struct(rx, r);
557 static void gdm_usb_send_complete(struct urb *urb)
559 struct usb_tx *t = urb->context;
560 struct tx_cxt *tx = t->tx;
561 struct lte_udev *udev = container_of(tx, struct lte_udev, tx);
564 if (urb->status == -ECONNRESET) {
565 pr_info("CONNRESET\n");
570 t->callback(t->cb_data);
574 spin_lock_irqsave(&tx->lock, flags);
575 udev->send_complete = 1;
576 queue_work(usb_tx_wq, &udev->work_tx.work);
577 spin_unlock_irqrestore(&tx->lock, flags);
580 static int send_tx_packet(struct usb_device *usbdev, struct usb_tx *t, u32 len)
587 usb_fill_bulk_urb(t->urb,
589 usb_sndbulkpipe(usbdev, 2),
592 gdm_usb_send_complete,
595 ret = usb_submit_urb(t->urb, GFP_ATOMIC);
598 pr_err("usb_submit_urb failed: %d\n", ret);
600 usb_mark_last_busy(usbdev);
605 static u32 packet_aggregation(struct lte_udev *udev, u8 *send_buf)
607 struct tx_cxt *tx = &udev->tx;
608 struct usb_tx_sdu *t_sdu = NULL;
609 struct multi_sdu *multi_sdu = (struct multi_sdu *)send_buf;
614 multi_sdu->cmd_evt = gdm_cpu_to_dev16(&udev->gdm_ed, LTE_TX_MULTI_SDU);
616 while (num_packet < MAX_PACKET_IN_MULTI_SDU) {
617 spin_lock_irqsave(&tx->lock, flags);
618 if (list_empty(&tx->sdu_list)) {
619 spin_unlock_irqrestore(&tx->lock, flags);
623 t_sdu = list_entry(tx->sdu_list.next, struct usb_tx_sdu, list);
624 if (send_len + t_sdu->len > MAX_SDU_SIZE) {
625 spin_unlock_irqrestore(&tx->lock, flags);
629 list_del(&t_sdu->list);
630 spin_unlock_irqrestore(&tx->lock, flags);
632 memcpy(multi_sdu->data + send_len, t_sdu->buf, t_sdu->len);
634 send_len += (t_sdu->len + 3) & 0xfffc;
637 if (tx->avail_count > 10)
638 t_sdu->callback(t_sdu->cb_data);
640 spin_lock_irqsave(&tx->lock, flags);
641 put_tx_struct(tx, t_sdu);
642 spin_unlock_irqrestore(&tx->lock, flags);
645 multi_sdu->len = gdm_cpu_to_dev16(&udev->gdm_ed, send_len);
646 multi_sdu->num_packet = gdm_cpu_to_dev16(&udev->gdm_ed, num_packet);
648 return send_len + offsetof(struct multi_sdu, data);
651 static void do_tx(struct work_struct *work)
653 struct lte_udev *udev =
654 container_of(work, struct lte_udev, work_tx.work);
655 struct usb_device *usbdev = udev->usbdev;
656 struct tx_cxt *tx = &udev->tx;
657 struct usb_tx *t = NULL;
662 if (!usb_autopm_get_interface(udev->intf))
663 usb_autopm_put_interface(udev->intf);
665 if (udev->usb_state == PM_SUSPEND)
668 spin_lock_irqsave(&tx->lock, flags);
669 if (!udev->send_complete) {
670 spin_unlock_irqrestore(&tx->lock, flags);
673 udev->send_complete = 0;
676 if (!list_empty(&tx->hci_list)) {
677 t = list_entry(tx->hci_list.next, struct usb_tx, list);
682 } else if (!list_empty(&tx->sdu_list)) {
684 udev->send_complete = 1;
685 spin_unlock_irqrestore(&tx->lock, flags);
689 t = alloc_tx_struct(TX_BUF_SIZE);
697 udev->send_complete = 1;
698 spin_unlock_irqrestore(&tx->lock, flags);
701 spin_unlock_irqrestore(&tx->lock, flags);
704 len = packet_aggregation(udev, t->buf);
706 if (send_tx_packet(usbdev, t, len)) {
707 pr_err("send_tx_packet failed\n");
709 gdm_usb_send_complete(t->urb);
713 #define SDU_PARAM_LEN 12
714 static int gdm_usb_sdu_send(void *priv_dev, void *data, int len,
715 unsigned int dftEpsId, unsigned int epsId,
716 void (*cb)(void *data), void *cb_data,
717 int dev_idx, int nic_type)
719 struct lte_udev *udev = priv_dev;
720 struct tx_cxt *tx = &udev->tx;
721 struct usb_tx_sdu *t_sdu;
722 struct sdu *sdu = NULL;
728 pr_err("sdu send - invalid device\n");
732 spin_lock_irqsave(&tx->lock, flags);
733 t_sdu = get_tx_sdu_struct(tx, &no_spc);
734 spin_unlock_irqrestore(&tx->lock, flags);
737 pr_err("sdu send - free list empty\n");
741 sdu = (struct sdu *)t_sdu->buf;
742 sdu->cmd_evt = gdm_cpu_to_dev16(&udev->gdm_ed, LTE_TX_SDU);
743 if (nic_type == NIC_TYPE_ARP) {
744 send_len = len + SDU_PARAM_LEN;
745 memcpy(sdu->data, data, len);
747 send_len = len - ETH_HLEN;
748 send_len += SDU_PARAM_LEN;
749 memcpy(sdu->data, data+ETH_HLEN, len-ETH_HLEN);
752 sdu->len = gdm_cpu_to_dev16(&udev->gdm_ed, send_len);
753 sdu->dftEpsId = gdm_cpu_to_dev32(&udev->gdm_ed, dftEpsId);
754 sdu->bearer_ID = gdm_cpu_to_dev32(&udev->gdm_ed, epsId);
755 sdu->nic_type = gdm_cpu_to_dev32(&udev->gdm_ed, nic_type);
757 t_sdu->len = send_len + HCI_HEADER_SIZE;
758 t_sdu->callback = cb;
759 t_sdu->cb_data = cb_data;
761 spin_lock_irqsave(&tx->lock, flags);
762 list_add_tail(&t_sdu->list, &tx->sdu_list);
763 queue_work(usb_tx_wq, &udev->work_tx.work);
764 spin_unlock_irqrestore(&tx->lock, flags);
772 static int gdm_usb_hci_send(void *priv_dev, void *data, int len,
773 void (*cb)(void *data), void *cb_data)
775 struct lte_udev *udev = priv_dev;
776 struct tx_cxt *tx = &udev->tx;
781 pr_err("hci send - invalid device\n");
785 t = alloc_tx_struct(len);
787 pr_err("hci_send - out of memory\n");
791 memcpy(t->buf, data, len);
793 t->cb_data = cb_data;
798 spin_lock_irqsave(&tx->lock, flags);
799 list_add_tail(&t->list, &tx->hci_list);
800 queue_work(usb_tx_wq, &udev->work_tx.work);
801 spin_unlock_irqrestore(&tx->lock, flags);
806 static struct gdm_endian *gdm_usb_get_endian(void *priv_dev)
808 struct lte_udev *udev = priv_dev;
810 return &udev->gdm_ed;
813 static int gdm_usb_probe(struct usb_interface *intf,
814 const struct usb_device_id *id)
817 struct phy_dev *phy_dev = NULL;
818 struct lte_udev *udev = NULL;
819 u16 idVendor, idProduct;
820 int bInterfaceNumber;
821 struct usb_device *usbdev = interface_to_usbdev(intf);
823 bInterfaceNumber = intf->cur_altsetting->desc.bInterfaceNumber;
824 idVendor = __le16_to_cpu(usbdev->descriptor.idVendor);
825 idProduct = __le16_to_cpu(usbdev->descriptor.idProduct);
827 pr_info("net vid = 0x%04x pid = 0x%04x\n", idVendor, idProduct);
829 if (bInterfaceNumber > NETWORK_INTERFACE) {
830 pr_info("not a network device\n");
834 phy_dev = kzalloc(sizeof(struct phy_dev), GFP_KERNEL);
838 udev = kzalloc(sizeof(struct lte_udev), GFP_KERNEL);
844 phy_dev->priv_dev = (void *)udev;
845 phy_dev->send_hci_func = gdm_usb_hci_send;
846 phy_dev->send_sdu_func = gdm_usb_sdu_send;
847 phy_dev->rcv_func = gdm_usb_recv;
848 phy_dev->get_endian = gdm_usb_get_endian;
850 udev->usbdev = usbdev;
851 ret = init_usb(udev);
853 pr_err("init_usb func failed\n");
858 intf->needs_remote_wakeup = 1;
859 usb_enable_autosuspend(usbdev);
860 pm_runtime_set_autosuspend_delay(&usbdev->dev, AUTO_SUSPEND_TIMER);
862 /* List up hosts with big endians, otherwise,
863 * defaults to little endian
865 if (idProduct == PID_GDM7243)
866 gdm_set_endian(&udev->gdm_ed, ENDIANNESS_BIG);
868 gdm_set_endian(&udev->gdm_ed, ENDIANNESS_LITTLE);
870 ret = request_mac_address(udev);
872 pr_err("request Mac address failed\n");
873 goto err_mac_address;
876 start_rx_proc(phy_dev);
878 usb_set_intfdata(intf, phy_dev);
892 static void gdm_usb_disconnect(struct usb_interface *intf)
894 struct phy_dev *phy_dev;
895 struct lte_udev *udev;
896 u16 idVendor, idProduct;
897 struct usb_device *usbdev;
898 usbdev = interface_to_usbdev(intf);
900 idVendor = __le16_to_cpu(usbdev->descriptor.idVendor);
901 idProduct = __le16_to_cpu(usbdev->descriptor.idProduct);
903 phy_dev = usb_get_intfdata(intf);
905 udev = phy_dev->priv_dev;
906 unregister_lte_device(phy_dev);
919 static int gdm_usb_suspend(struct usb_interface *intf, pm_message_t pm_msg)
921 struct phy_dev *phy_dev;
922 struct lte_udev *udev;
925 struct usb_rx *r_next;
928 phy_dev = usb_get_intfdata(intf);
929 udev = phy_dev->priv_dev;
931 if (udev->usb_state != PM_NORMAL) {
932 pr_err("usb suspend - invalid state\n");
936 udev->usb_state = PM_SUSPEND;
938 spin_lock_irqsave(&rx->submit_lock, flags);
939 list_for_each_entry_safe(r, r_next, &rx->rx_submit_list, rx_submit_list)
941 spin_unlock_irqrestore(&rx->submit_lock, flags);
942 usb_kill_urb(r->urb);
943 spin_lock_irqsave(&rx->submit_lock, flags);
945 spin_unlock_irqrestore(&rx->submit_lock, flags);
950 static int gdm_usb_resume(struct usb_interface *intf)
952 struct phy_dev *phy_dev;
953 struct lte_udev *udev;
960 phy_dev = usb_get_intfdata(intf);
961 udev = phy_dev->priv_dev;
964 if (udev->usb_state != PM_SUSPEND) {
965 pr_err("usb resume - invalid state\n");
968 udev->usb_state = PM_NORMAL;
970 spin_lock_irqsave(&rx->rx_lock, flags);
971 issue_count = rx->avail_count - MAX_RX_SUBMIT_COUNT;
972 spin_unlock_irqrestore(&rx->rx_lock, flags);
974 if (issue_count >= 0) {
975 for (i = 0; i < issue_count; i++)
976 gdm_usb_recv(phy_dev->priv_dev,
983 spin_lock_irqsave(&tx->lock, flags);
984 queue_work(usb_tx_wq, &udev->work_tx.work);
985 spin_unlock_irqrestore(&tx->lock, flags);
990 static struct usb_driver gdm_usb_lte_driver = {
992 .probe = gdm_usb_probe,
993 .disconnect = gdm_usb_disconnect,
994 .id_table = id_table,
995 .supports_autosuspend = 1,
996 .suspend = gdm_usb_suspend,
997 .resume = gdm_usb_resume,
998 .reset_resume = gdm_usb_resume,
1001 static int __init gdm_usb_lte_init(void)
1003 if (gdm_lte_event_init() < 0) {
1004 pr_err("error creating event\n");
1008 usb_tx_wq = create_workqueue("usb_tx_wq");
1009 if (usb_tx_wq == NULL)
1012 usb_rx_wq = create_workqueue("usb_rx_wq");
1013 if (usb_rx_wq == NULL)
1016 return usb_register(&gdm_usb_lte_driver);
1019 static void __exit gdm_usb_lte_exit(void)
1021 gdm_lte_event_exit();
1023 usb_deregister(&gdm_usb_lte_driver);
1026 flush_workqueue(usb_tx_wq);
1027 destroy_workqueue(usb_tx_wq);
1031 flush_workqueue(usb_rx_wq);
1032 destroy_workqueue(usb_rx_wq);
1036 module_init(gdm_usb_lte_init);
1037 module_exit(gdm_usb_lte_exit);
1039 MODULE_VERSION(DRIVER_VERSION);
1040 MODULE_DESCRIPTION("GCT LTE USB Device Driver");
1041 MODULE_LICENSE("GPL");