1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved. */
4 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
6 #include <linux/module.h>
7 #include <linux/kernel.h>
9 #include <linux/sched.h>
10 #include <linux/kthread.h>
11 #include <linux/usb/cdc.h>
12 #include <linux/wait.h>
13 #include <linux/if_ether.h>
14 #include <linux/pm_runtime.h>
19 #include "hci_packet.h"
20 #include "gdm_endian.h"
22 #define USB_DEVICE_CDC_DATA(vid, pid) \
23 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
24 USB_DEVICE_ID_MATCH_INT_CLASS | \
25 USB_DEVICE_ID_MATCH_INT_SUBCLASS,\
28 .bInterfaceClass = USB_CLASS_COMM,\
29 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET
31 #define USB_DEVICE_MASS_DATA(vid, pid) \
32 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
33 USB_DEVICE_ID_MATCH_INT_INFO,\
36 .bInterfaceSubClass = USB_SC_SCSI, \
37 .bInterfaceClass = USB_CLASS_MASS_STORAGE,\
38 .bInterfaceProtocol = USB_PR_BULK
40 static const struct usb_device_id id_table[] = {
41 { USB_DEVICE_CDC_DATA(VID_GCT, PID_GDM7240) }, /* GCT GDM7240 */
42 { USB_DEVICE_CDC_DATA(VID_GCT, PID_GDM7243) }, /* GCT GDM7243 */
46 MODULE_DEVICE_TABLE(usb, id_table);
48 static void do_tx(struct work_struct *work);
49 static void do_rx(struct work_struct *work);
51 static int gdm_usb_recv(void *priv_dev,
52 int (*cb)(void *cb_data,
53 void *data, int len, int context),
57 static int request_mac_address(struct lte_udev *udev)
60 struct hci_packet *hci = (struct hci_packet *)buf;
61 struct usb_device *usbdev = udev->usbdev;
65 hci->cmd_evt = gdm_cpu_to_dev16(udev->gdm_ed, LTE_GET_INFORMATION);
66 hci->len = gdm_cpu_to_dev16(udev->gdm_ed, 1);
67 hci->data[0] = MAC_ADDRESS;
69 ret = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 2), buf, 5,
72 udev->request_mac_addr = 1;
77 static struct usb_tx *alloc_tx_struct(int len)
79 struct usb_tx *t = NULL;
82 t = kzalloc(sizeof(*t), GFP_ATOMIC);
88 t->urb = usb_alloc_urb(0, GFP_ATOMIC);
92 t->buf = kmalloc(len, GFP_ATOMIC);
93 if (!t->urb || !t->buf) {
101 usb_free_urb(t->urb);
111 static struct usb_tx_sdu *alloc_tx_sdu_struct(void)
113 struct usb_tx_sdu *t_sdu;
115 t_sdu = kzalloc(sizeof(*t_sdu), GFP_KERNEL);
119 t_sdu->buf = kmalloc(SDU_BUF_SIZE, GFP_KERNEL);
128 static void free_tx_struct(struct usb_tx *t)
131 usb_free_urb(t->urb);
137 static void free_tx_sdu_struct(struct usb_tx_sdu *t_sdu)
145 static struct usb_tx_sdu *get_tx_sdu_struct(struct tx_cxt *tx, int *no_spc)
147 struct usb_tx_sdu *t_sdu;
149 if (list_empty(&tx->free_list))
152 t_sdu = list_entry(tx->free_list.next, struct usb_tx_sdu, list);
153 list_del(&t_sdu->list);
157 *no_spc = list_empty(&tx->free_list) ? 1 : 0;
162 static void put_tx_struct(struct tx_cxt *tx, struct usb_tx_sdu *t_sdu)
164 list_add_tail(&t_sdu->list, &tx->free_list);
168 static struct usb_rx *alloc_rx_struct(void)
170 struct usb_rx *r = NULL;
173 r = kmalloc(sizeof(*r), GFP_KERNEL);
179 r->urb = usb_alloc_urb(0, GFP_KERNEL);
180 r->buf = kmalloc(RX_BUF_SIZE, GFP_KERNEL);
181 if (!r->urb || !r->buf) {
189 usb_free_urb(r->urb);
199 static void free_rx_struct(struct usb_rx *r)
202 usb_free_urb(r->urb);
208 static struct usb_rx *get_rx_struct(struct rx_cxt *rx, int *no_spc)
213 spin_lock_irqsave(&rx->rx_lock, flags);
215 if (list_empty(&rx->free_list)) {
216 spin_unlock_irqrestore(&rx->rx_lock, flags);
220 r = list_entry(rx->free_list.next, struct usb_rx, free_list);
221 list_del(&r->free_list);
225 *no_spc = list_empty(&rx->free_list) ? 1 : 0;
227 spin_unlock_irqrestore(&rx->rx_lock, flags);
232 static void put_rx_struct(struct rx_cxt *rx, struct usb_rx *r)
236 spin_lock_irqsave(&rx->rx_lock, flags);
238 list_add_tail(&r->free_list, &rx->free_list);
241 spin_unlock_irqrestore(&rx->rx_lock, flags);
244 static void release_usb(struct lte_udev *udev)
246 struct rx_cxt *rx = &udev->rx;
247 struct tx_cxt *tx = &udev->tx;
248 struct usb_tx *t, *t_next;
249 struct usb_rx *r, *r_next;
250 struct usb_tx_sdu *t_sdu, *t_sdu_next;
253 spin_lock_irqsave(&tx->lock, flags);
254 list_for_each_entry_safe(t_sdu, t_sdu_next, &tx->sdu_list, list) {
255 list_del(&t_sdu->list);
256 free_tx_sdu_struct(t_sdu);
259 list_for_each_entry_safe(t, t_next, &tx->hci_list, list) {
264 list_for_each_entry_safe(t_sdu, t_sdu_next, &tx->free_list, list) {
265 list_del(&t_sdu->list);
266 free_tx_sdu_struct(t_sdu);
268 spin_unlock_irqrestore(&tx->lock, flags);
270 spin_lock_irqsave(&rx->submit_lock, flags);
271 list_for_each_entry_safe(r, r_next, &rx->rx_submit_list,
273 spin_unlock_irqrestore(&rx->submit_lock, flags);
274 usb_kill_urb(r->urb);
275 spin_lock_irqsave(&rx->submit_lock, flags);
277 spin_unlock_irqrestore(&rx->submit_lock, flags);
279 spin_lock_irqsave(&rx->rx_lock, flags);
280 list_for_each_entry_safe(r, r_next, &rx->free_list, free_list) {
281 list_del(&r->free_list);
284 spin_unlock_irqrestore(&rx->rx_lock, flags);
286 spin_lock_irqsave(&rx->to_host_lock, flags);
287 list_for_each_entry_safe(r, r_next, &rx->to_host_list, to_host_list) {
288 if (r->index == (void *)udev) {
289 list_del(&r->to_host_list);
293 spin_unlock_irqrestore(&rx->to_host_lock, flags);
296 static int init_usb(struct lte_udev *udev)
300 struct tx_cxt *tx = &udev->tx;
301 struct rx_cxt *rx = &udev->rx;
302 struct usb_tx_sdu *t_sdu = NULL;
303 struct usb_rx *r = NULL;
305 udev->send_complete = 1;
307 udev->request_mac_addr = 0;
308 udev->usb_state = PM_NORMAL;
310 INIT_LIST_HEAD(&tx->sdu_list);
311 INIT_LIST_HEAD(&tx->hci_list);
312 INIT_LIST_HEAD(&tx->free_list);
313 INIT_LIST_HEAD(&rx->rx_submit_list);
314 INIT_LIST_HEAD(&rx->free_list);
315 INIT_LIST_HEAD(&rx->to_host_list);
316 spin_lock_init(&tx->lock);
317 spin_lock_init(&rx->rx_lock);
318 spin_lock_init(&rx->submit_lock);
319 spin_lock_init(&rx->to_host_lock);
326 for (i = 0; i < MAX_NUM_SDU_BUF; i++) {
327 t_sdu = alloc_tx_sdu_struct();
333 list_add(&t_sdu->list, &tx->free_list);
337 for (i = 0; i < MAX_RX_SUBMIT_COUNT * 2; i++) {
338 r = alloc_rx_struct();
344 list_add(&r->free_list, &rx->free_list);
347 INIT_DELAYED_WORK(&udev->work_tx, do_tx);
348 INIT_DELAYED_WORK(&udev->work_rx, do_rx);
355 static int set_mac_address(u8 *data, void *arg)
357 struct phy_dev *phy_dev = arg;
358 struct lte_udev *udev = phy_dev->priv_dev;
359 struct tlv *tlv = (struct tlv *)data;
360 u8 mac_address[ETH_ALEN] = {0, };
362 if (tlv->type == MAC_ADDRESS && udev->request_mac_addr) {
363 memcpy(mac_address, tlv->data, tlv->len);
365 if (register_lte_device(phy_dev,
366 &udev->intf->dev, mac_address) < 0)
367 pr_err("register lte device failed\n");
369 udev->request_mac_addr = 0;
377 static void do_rx(struct work_struct *work)
379 struct lte_udev *udev =
380 container_of(work, struct lte_udev, work_rx.work);
381 struct rx_cxt *rx = &udev->rx;
383 struct hci_packet *hci;
384 struct phy_dev *phy_dev;
390 spin_lock_irqsave(&rx->to_host_lock, flags);
391 if (list_empty(&rx->to_host_list)) {
392 spin_unlock_irqrestore(&rx->to_host_lock, flags);
395 r = list_entry(rx->to_host_list.next,
396 struct usb_rx, to_host_list);
397 list_del(&r->to_host_list);
398 spin_unlock_irqrestore(&rx->to_host_lock, flags);
400 phy_dev = r->cb_data;
401 udev = phy_dev->priv_dev;
402 hci = (struct hci_packet *)r->buf;
403 cmd_evt = gdm_dev16_to_cpu(udev->gdm_ed, hci->cmd_evt);
406 case LTE_GET_INFORMATION_RESULT:
407 if (set_mac_address(hci->data, r->cb_data) == 0) {
408 r->callback(r->cb_data,
410 r->urb->actual_length,
417 ret = r->callback(r->cb_data,
419 r->urb->actual_length,
423 pr_err("failed to send received data\n");
428 put_rx_struct(rx, r);
437 static void remove_rx_submit_list(struct usb_rx *r, struct rx_cxt *rx)
440 struct usb_rx *r_remove, *r_remove_next;
442 spin_lock_irqsave(&rx->submit_lock, flags);
443 list_for_each_entry_safe(r_remove, r_remove_next,
444 &rx->rx_submit_list, rx_submit_list) {
446 list_del(&r->rx_submit_list);
450 spin_unlock_irqrestore(&rx->submit_lock, flags);
453 static void gdm_usb_rcv_complete(struct urb *urb)
455 struct usb_rx *r = urb->context;
456 struct rx_cxt *rx = r->rx;
458 struct lte_udev *udev = container_of(r->rx, struct lte_udev, rx);
459 struct usb_device *usbdev = udev->usbdev;
461 remove_rx_submit_list(r, rx);
463 if (!urb->status && r->callback) {
464 spin_lock_irqsave(&rx->to_host_lock, flags);
465 list_add_tail(&r->to_host_list, &rx->to_host_list);
466 schedule_work(&udev->work_rx.work);
467 spin_unlock_irqrestore(&rx->to_host_lock, flags);
469 if (urb->status && udev->usb_state == PM_NORMAL)
470 dev_err(&urb->dev->dev, "%s: urb status error %d\n",
471 __func__, urb->status);
473 put_rx_struct(rx, r);
476 usb_mark_last_busy(usbdev);
479 static int gdm_usb_recv(void *priv_dev,
480 int (*cb)(void *cb_data,
481 void *data, int len, int context),
485 struct lte_udev *udev = priv_dev;
486 struct usb_device *usbdev = udev->usbdev;
487 struct rx_cxt *rx = &udev->rx;
494 pr_err("invalid device\n");
498 r = get_rx_struct(rx, &no_spc);
500 pr_err("Out of Memory\n");
506 r->cb_data = cb_data;
507 r->index = (void *)udev;
510 usb_fill_bulk_urb(r->urb,
512 usb_rcvbulkpipe(usbdev, 0x83),
515 gdm_usb_rcv_complete,
518 spin_lock_irqsave(&rx->submit_lock, flags);
519 list_add_tail(&r->rx_submit_list, &rx->rx_submit_list);
520 spin_unlock_irqrestore(&rx->submit_lock, flags);
522 if (context == KERNEL_THREAD)
523 ret = usb_submit_urb(r->urb, GFP_KERNEL);
525 ret = usb_submit_urb(r->urb, GFP_ATOMIC);
528 spin_lock_irqsave(&rx->submit_lock, flags);
529 list_del(&r->rx_submit_list);
530 spin_unlock_irqrestore(&rx->submit_lock, flags);
532 pr_err("usb_submit_urb failed (%p)\n", r);
533 put_rx_struct(rx, r);
539 static void gdm_usb_send_complete(struct urb *urb)
541 struct usb_tx *t = urb->context;
542 struct tx_cxt *tx = t->tx;
543 struct lte_udev *udev = container_of(tx, struct lte_udev, tx);
546 if (urb->status == -ECONNRESET) {
547 dev_info(&urb->dev->dev, "CONNRESET\n");
552 t->callback(t->cb_data);
556 spin_lock_irqsave(&tx->lock, flags);
557 udev->send_complete = 1;
558 schedule_work(&udev->work_tx.work);
559 spin_unlock_irqrestore(&tx->lock, flags);
562 static int send_tx_packet(struct usb_device *usbdev, struct usb_tx *t, u32 len)
569 usb_fill_bulk_urb(t->urb,
571 usb_sndbulkpipe(usbdev, 2),
574 gdm_usb_send_complete,
577 ret = usb_submit_urb(t->urb, GFP_ATOMIC);
580 dev_err(&usbdev->dev, "usb_submit_urb failed: %d\n",
583 usb_mark_last_busy(usbdev);
588 static u32 packet_aggregation(struct lte_udev *udev, u8 *send_buf)
590 struct tx_cxt *tx = &udev->tx;
591 struct usb_tx_sdu *t_sdu = NULL;
592 struct multi_sdu *multi_sdu = (struct multi_sdu *)send_buf;
597 multi_sdu->cmd_evt = gdm_cpu_to_dev16(udev->gdm_ed, LTE_TX_MULTI_SDU);
599 while (num_packet < MAX_PACKET_IN_MULTI_SDU) {
600 spin_lock_irqsave(&tx->lock, flags);
601 if (list_empty(&tx->sdu_list)) {
602 spin_unlock_irqrestore(&tx->lock, flags);
606 t_sdu = list_entry(tx->sdu_list.next, struct usb_tx_sdu, list);
607 if (send_len + t_sdu->len > MAX_SDU_SIZE) {
608 spin_unlock_irqrestore(&tx->lock, flags);
612 list_del(&t_sdu->list);
613 spin_unlock_irqrestore(&tx->lock, flags);
615 memcpy(multi_sdu->data + send_len, t_sdu->buf, t_sdu->len);
617 send_len += (t_sdu->len + 3) & 0xfffc;
620 if (tx->avail_count > 10)
621 t_sdu->callback(t_sdu->cb_data);
623 spin_lock_irqsave(&tx->lock, flags);
624 put_tx_struct(tx, t_sdu);
625 spin_unlock_irqrestore(&tx->lock, flags);
628 multi_sdu->len = gdm_cpu_to_dev16(udev->gdm_ed, send_len);
629 multi_sdu->num_packet = gdm_cpu_to_dev16(udev->gdm_ed, num_packet);
631 return send_len + offsetof(struct multi_sdu, data);
634 static void do_tx(struct work_struct *work)
636 struct lte_udev *udev =
637 container_of(work, struct lte_udev, work_tx.work);
638 struct usb_device *usbdev = udev->usbdev;
639 struct tx_cxt *tx = &udev->tx;
640 struct usb_tx *t = NULL;
645 if (!usb_autopm_get_interface(udev->intf))
646 usb_autopm_put_interface(udev->intf);
648 if (udev->usb_state == PM_SUSPEND)
651 spin_lock_irqsave(&tx->lock, flags);
652 if (!udev->send_complete) {
653 spin_unlock_irqrestore(&tx->lock, flags);
656 udev->send_complete = 0;
658 if (!list_empty(&tx->hci_list)) {
659 t = list_entry(tx->hci_list.next, struct usb_tx, list);
664 } else if (!list_empty(&tx->sdu_list)) {
666 udev->send_complete = 1;
667 spin_unlock_irqrestore(&tx->lock, flags);
671 t = alloc_tx_struct(TX_BUF_SIZE);
673 spin_unlock_irqrestore(&tx->lock, flags);
683 udev->send_complete = 1;
684 spin_unlock_irqrestore(&tx->lock, flags);
687 spin_unlock_irqrestore(&tx->lock, flags);
690 len = packet_aggregation(udev, t->buf);
692 if (send_tx_packet(usbdev, t, len)) {
693 pr_err("send_tx_packet failed\n");
695 gdm_usb_send_complete(t->urb);
699 #define SDU_PARAM_LEN 12
700 static int gdm_usb_sdu_send(void *priv_dev, void *data, int len,
701 unsigned int dft_eps_ID, unsigned int eps_ID,
702 void (*cb)(void *data), void *cb_data,
703 int dev_idx, int nic_type)
705 struct lte_udev *udev = priv_dev;
706 struct tx_cxt *tx = &udev->tx;
707 struct usb_tx_sdu *t_sdu;
708 struct sdu *sdu = NULL;
714 pr_err("sdu send - invalid device\n");
718 spin_lock_irqsave(&tx->lock, flags);
719 t_sdu = get_tx_sdu_struct(tx, &no_spc);
720 spin_unlock_irqrestore(&tx->lock, flags);
723 pr_err("sdu send - free list empty\n");
727 sdu = (struct sdu *)t_sdu->buf;
728 sdu->cmd_evt = gdm_cpu_to_dev16(udev->gdm_ed, LTE_TX_SDU);
729 if (nic_type == NIC_TYPE_ARP) {
730 send_len = len + SDU_PARAM_LEN;
731 memcpy(sdu->data, data, len);
733 send_len = len - ETH_HLEN;
734 send_len += SDU_PARAM_LEN;
735 memcpy(sdu->data, data + ETH_HLEN, len - ETH_HLEN);
738 sdu->len = gdm_cpu_to_dev16(udev->gdm_ed, send_len);
739 sdu->dft_eps_ID = gdm_cpu_to_dev32(udev->gdm_ed, dft_eps_ID);
740 sdu->bearer_ID = gdm_cpu_to_dev32(udev->gdm_ed, eps_ID);
741 sdu->nic_type = gdm_cpu_to_dev32(udev->gdm_ed, nic_type);
743 t_sdu->len = send_len + HCI_HEADER_SIZE;
744 t_sdu->callback = cb;
745 t_sdu->cb_data = cb_data;
747 spin_lock_irqsave(&tx->lock, flags);
748 list_add_tail(&t_sdu->list, &tx->sdu_list);
749 schedule_work(&udev->work_tx.work);
750 spin_unlock_irqrestore(&tx->lock, flags);
758 static int gdm_usb_hci_send(void *priv_dev, void *data, int len,
759 void (*cb)(void *data), void *cb_data)
761 struct lte_udev *udev = priv_dev;
762 struct tx_cxt *tx = &udev->tx;
767 pr_err("hci send - invalid device\n");
771 t = alloc_tx_struct(len);
773 pr_err("hci_send - out of memory\n");
777 memcpy(t->buf, data, len);
779 t->cb_data = cb_data;
784 spin_lock_irqsave(&tx->lock, flags);
785 list_add_tail(&t->list, &tx->hci_list);
786 schedule_work(&udev->work_tx.work);
787 spin_unlock_irqrestore(&tx->lock, flags);
792 static u8 gdm_usb_get_endian(void *priv_dev)
794 struct lte_udev *udev = priv_dev;
799 static int gdm_usb_probe(struct usb_interface *intf,
800 const struct usb_device_id *id)
803 struct phy_dev *phy_dev = NULL;
804 struct lte_udev *udev = NULL;
805 u16 idVendor, idProduct;
806 int bInterfaceNumber;
807 struct usb_device *usbdev = interface_to_usbdev(intf);
809 bInterfaceNumber = intf->cur_altsetting->desc.bInterfaceNumber;
810 idVendor = __le16_to_cpu(usbdev->descriptor.idVendor);
811 idProduct = __le16_to_cpu(usbdev->descriptor.idProduct);
813 pr_info("net vid = 0x%04x pid = 0x%04x\n", idVendor, idProduct);
815 if (bInterfaceNumber > NETWORK_INTERFACE) {
816 pr_info("not a network device\n");
820 phy_dev = kzalloc(sizeof(*phy_dev), GFP_KERNEL);
824 udev = kzalloc(sizeof(*udev), GFP_KERNEL);
830 phy_dev->priv_dev = (void *)udev;
831 phy_dev->send_hci_func = gdm_usb_hci_send;
832 phy_dev->send_sdu_func = gdm_usb_sdu_send;
833 phy_dev->rcv_func = gdm_usb_recv;
834 phy_dev->get_endian = gdm_usb_get_endian;
836 udev->usbdev = usbdev;
837 ret = init_usb(udev);
839 dev_err(intf->usb_dev, "init_usb func failed\n");
844 intf->needs_remote_wakeup = 1;
845 usb_enable_autosuspend(usbdev);
846 pm_runtime_set_autosuspend_delay(&usbdev->dev, AUTO_SUSPEND_TIMER);
848 /* List up hosts with big endians, otherwise,
849 * defaults to little endian
851 if (idProduct == PID_GDM7243)
852 udev->gdm_ed = ENDIANNESS_BIG;
854 udev->gdm_ed = ENDIANNESS_LITTLE;
856 ret = request_mac_address(udev);
858 dev_err(intf->usb_dev, "request Mac address failed\n");
859 goto err_mac_address;
862 start_rx_proc(phy_dev);
864 usb_set_intfdata(intf, phy_dev);
878 static void gdm_usb_disconnect(struct usb_interface *intf)
880 struct phy_dev *phy_dev;
881 struct lte_udev *udev;
882 struct usb_device *usbdev;
884 usbdev = interface_to_usbdev(intf);
885 phy_dev = usb_get_intfdata(intf);
887 udev = phy_dev->priv_dev;
888 unregister_lte_device(phy_dev);
901 static int gdm_usb_suspend(struct usb_interface *intf, pm_message_t pm_msg)
903 struct phy_dev *phy_dev;
904 struct lte_udev *udev;
907 struct usb_rx *r_next;
910 phy_dev = usb_get_intfdata(intf);
911 udev = phy_dev->priv_dev;
913 if (udev->usb_state != PM_NORMAL) {
914 dev_err(intf->usb_dev, "usb suspend - invalid state\n");
918 udev->usb_state = PM_SUSPEND;
920 spin_lock_irqsave(&rx->submit_lock, flags);
921 list_for_each_entry_safe(r, r_next, &rx->rx_submit_list,
923 spin_unlock_irqrestore(&rx->submit_lock, flags);
924 usb_kill_urb(r->urb);
925 spin_lock_irqsave(&rx->submit_lock, flags);
927 spin_unlock_irqrestore(&rx->submit_lock, flags);
929 cancel_work_sync(&udev->work_tx.work);
930 cancel_work_sync(&udev->work_rx.work);
935 static int gdm_usb_resume(struct usb_interface *intf)
937 struct phy_dev *phy_dev;
938 struct lte_udev *udev;
945 phy_dev = usb_get_intfdata(intf);
946 udev = phy_dev->priv_dev;
949 if (udev->usb_state != PM_SUSPEND) {
950 dev_err(intf->usb_dev, "usb resume - invalid state\n");
953 udev->usb_state = PM_NORMAL;
955 spin_lock_irqsave(&rx->rx_lock, flags);
956 issue_count = rx->avail_count - MAX_RX_SUBMIT_COUNT;
957 spin_unlock_irqrestore(&rx->rx_lock, flags);
959 if (issue_count >= 0) {
960 for (i = 0; i < issue_count; i++)
961 gdm_usb_recv(phy_dev->priv_dev,
968 spin_lock_irqsave(&tx->lock, flags);
969 schedule_work(&udev->work_tx.work);
970 spin_unlock_irqrestore(&tx->lock, flags);
975 static struct usb_driver gdm_usb_lte_driver = {
977 .probe = gdm_usb_probe,
978 .disconnect = gdm_usb_disconnect,
979 .id_table = id_table,
980 .supports_autosuspend = 1,
981 .suspend = gdm_usb_suspend,
982 .resume = gdm_usb_resume,
983 .reset_resume = gdm_usb_resume,
986 static int __init gdm_usb_lte_init(void)
988 if (gdm_lte_event_init() < 0) {
989 pr_err("error creating event\n");
993 return usb_register(&gdm_usb_lte_driver);
996 static void __exit gdm_usb_lte_exit(void)
998 gdm_lte_event_exit();
1000 usb_deregister(&gdm_usb_lte_driver);
1003 module_init(gdm_usb_lte_init);
1004 module_exit(gdm_usb_lte_exit);
1006 MODULE_VERSION(DRIVER_VERSION);
1007 MODULE_DESCRIPTION("GCT LTE USB Device Driver");
1008 MODULE_LICENSE("GPL");