161e12104SWon Kang /* 261e12104SWon Kang * Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved. 361e12104SWon Kang * 461e12104SWon Kang * This software is licensed under the terms of the GNU General Public 561e12104SWon Kang * License version 2, as published by the Free Software Foundation, and 661e12104SWon Kang * may be copied, distributed, and modified under those terms. 761e12104SWon Kang * 861e12104SWon Kang * This program is distributed in the hope that it will be useful, 961e12104SWon Kang * but WITHOUT ANY WARRANTY; without even the implied warranty of 1061e12104SWon Kang * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1161e12104SWon Kang * GNU General Public License for more details. 1261e12104SWon Kang */ 1361e12104SWon Kang 140ec473b5SJoe Perches #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 150ec473b5SJoe Perches 1661e12104SWon Kang #include <linux/module.h> 1761e12104SWon Kang #include <linux/kernel.h> 1861e12104SWon Kang #include <linux/usb.h> 1961e12104SWon Kang #include <linux/sched.h> 2061e12104SWon Kang #include <linux/kthread.h> 2161e12104SWon Kang #include <linux/usb/cdc.h> 2261e12104SWon Kang #include <linux/wait.h> 2361e12104SWon Kang #include <linux/if_ether.h> 2461e12104SWon Kang #include <linux/pm_runtime.h> 2561e12104SWon Kang 2661e12104SWon Kang #include "gdm_usb.h" 2761e12104SWon Kang #include "gdm_lte.h" 2861e12104SWon Kang #include "hci.h" 2961e12104SWon Kang #include "hci_packet.h" 3061e12104SWon Kang #include "gdm_endian.h" 3161e12104SWon Kang 3261e12104SWon Kang #define USB_DEVICE_CDC_DATA(vid, pid) \ 3361e12104SWon Kang .match_flags = USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS,\ 3461e12104SWon Kang .idVendor = vid,\ 3561e12104SWon Kang .idProduct = pid,\ 3661e12104SWon Kang .bInterfaceClass = USB_CLASS_COMM,\ 3761e12104SWon Kang .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET 3861e12104SWon Kang 3961e12104SWon Kang #define USB_DEVICE_MASS_DATA(vid, pid) \ 4061e12104SWon Kang .match_flags = USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_INT_INFO,\ 4161e12104SWon Kang .idVendor = vid,\ 4261e12104SWon Kang .idProduct = pid,\ 4361e12104SWon Kang .bInterfaceSubClass = USB_SC_SCSI, \ 4461e12104SWon Kang .bInterfaceClass = USB_CLASS_MASS_STORAGE,\ 4561e12104SWon Kang .bInterfaceProtocol = USB_PR_BULK 4661e12104SWon Kang 4761e12104SWon Kang static const struct usb_device_id id_table[] = { 4861e12104SWon Kang { USB_DEVICE_CDC_DATA(VID_GCT, PID_GDM7240) }, /* GCT GDM7240 */ 4961e12104SWon Kang { USB_DEVICE_CDC_DATA(VID_GCT, PID_GDM7243) }, /* GCT GDM7243 */ 5061e12104SWon Kang { } 5161e12104SWon Kang }; 5261e12104SWon Kang 5361e12104SWon Kang MODULE_DEVICE_TABLE(usb, id_table); 5461e12104SWon Kang 5561e12104SWon Kang static struct workqueue_struct *usb_tx_wq; 5661e12104SWon Kang static struct workqueue_struct *usb_rx_wq; 5761e12104SWon Kang 5861e12104SWon Kang static void do_tx(struct work_struct *work); 5961e12104SWon Kang static void do_rx(struct work_struct *work); 6061e12104SWon Kang 6161e12104SWon Kang static int gdm_usb_recv(void *priv_dev, 6261e12104SWon Kang int (*cb)(void *cb_data, void *data, int len, int context), 6361e12104SWon Kang void *cb_data, 6461e12104SWon Kang int context); 6561e12104SWon Kang 6661e12104SWon Kang static int request_mac_address(struct lte_udev *udev) 6761e12104SWon Kang { 6861e12104SWon Kang u8 buf[16] = {0,}; 6961e12104SWon Kang struct hci_packet *hci = (struct hci_packet *)buf; 7061e12104SWon Kang struct usb_device *usbdev = udev->usbdev; 7161e12104SWon Kang int actual; 7261e12104SWon Kang int ret = -1; 7361e12104SWon Kang 7461e12104SWon Kang hci->cmd_evt = gdm_cpu_to_dev16(&udev->gdm_ed, LTE_GET_INFORMATION); 7561e12104SWon Kang hci->len = gdm_cpu_to_dev16(&udev->gdm_ed, 1); 7661e12104SWon Kang hci->data[0] = MAC_ADDRESS; 7761e12104SWon Kang 7861e12104SWon Kang ret = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 2), buf, 5, 7961e12104SWon Kang &actual, 1000); 8061e12104SWon Kang 8161e12104SWon Kang udev->request_mac_addr = 1; 8261e12104SWon Kang 8361e12104SWon Kang return ret; 8461e12104SWon Kang } 8561e12104SWon Kang 8661e12104SWon Kang static struct usb_tx *alloc_tx_struct(int len) 8761e12104SWon Kang { 8861e12104SWon Kang struct usb_tx *t = NULL; 8961e12104SWon Kang int ret = 0; 9061e12104SWon Kang 911f558647STeodora Baluta t = kzalloc(sizeof(struct usb_tx), GFP_ATOMIC); 9261e12104SWon Kang if (!t) { 9361e12104SWon Kang ret = -ENOMEM; 9461e12104SWon Kang goto out; 9561e12104SWon Kang } 9661e12104SWon Kang 9761e12104SWon Kang t->urb = usb_alloc_urb(0, GFP_ATOMIC); 9861e12104SWon Kang if (!(len % 512)) 9961e12104SWon Kang len++; 10061e12104SWon Kang 10161e12104SWon Kang t->buf = kmalloc(len, GFP_ATOMIC); 10261e12104SWon Kang if (!t->urb || !t->buf) { 10361e12104SWon Kang ret = -ENOMEM; 10461e12104SWon Kang goto out; 10561e12104SWon Kang } 10661e12104SWon Kang 10761e12104SWon Kang out: 10861e12104SWon Kang if (ret < 0) { 10961e12104SWon Kang if (t) { 11061e12104SWon Kang usb_free_urb(t->urb); 11161e12104SWon Kang kfree(t->buf); 11261e12104SWon Kang kfree(t); 11361e12104SWon Kang } 11461e12104SWon Kang return NULL; 11561e12104SWon Kang } 11661e12104SWon Kang 11761e12104SWon Kang return t; 11861e12104SWon Kang } 11961e12104SWon Kang 12061e12104SWon Kang static struct usb_tx_sdu *alloc_tx_sdu_struct(void) 12161e12104SWon Kang { 12261e12104SWon Kang struct usb_tx_sdu *t_sdu = NULL; 12361e12104SWon Kang int ret = 0; 12461e12104SWon Kang 12561e12104SWon Kang 1261f558647STeodora Baluta t_sdu = kzalloc(sizeof(struct usb_tx_sdu), GFP_ATOMIC); 12761e12104SWon Kang if (!t_sdu) { 12861e12104SWon Kang ret = -ENOMEM; 12961e12104SWon Kang goto out; 13061e12104SWon Kang } 13161e12104SWon Kang 13261e12104SWon Kang t_sdu->buf = kmalloc(SDU_BUF_SIZE, GFP_ATOMIC); 13361e12104SWon Kang if (!t_sdu->buf) { 13461e12104SWon Kang ret = -ENOMEM; 13561e12104SWon Kang goto out; 13661e12104SWon Kang } 13761e12104SWon Kang out: 13861e12104SWon Kang 13961e12104SWon Kang if (ret < 0) { 14061e12104SWon Kang if (t_sdu) { 14161e12104SWon Kang kfree(t_sdu->buf); 14261e12104SWon Kang kfree(t_sdu); 14361e12104SWon Kang } 14461e12104SWon Kang return NULL; 14561e12104SWon Kang } 14661e12104SWon Kang 14761e12104SWon Kang return t_sdu; 14861e12104SWon Kang } 14961e12104SWon Kang 15061e12104SWon Kang static void free_tx_struct(struct usb_tx *t) 15161e12104SWon Kang { 15261e12104SWon Kang if (t) { 15361e12104SWon Kang usb_free_urb(t->urb); 15461e12104SWon Kang kfree(t->buf); 15561e12104SWon Kang kfree(t); 15661e12104SWon Kang } 15761e12104SWon Kang } 15861e12104SWon Kang 15961e12104SWon Kang static void free_tx_sdu_struct(struct usb_tx_sdu *t_sdu) 16061e12104SWon Kang { 16161e12104SWon Kang if (t_sdu) { 16261e12104SWon Kang kfree(t_sdu->buf); 16361e12104SWon Kang kfree(t_sdu); 16461e12104SWon Kang } 16561e12104SWon Kang } 16661e12104SWon Kang 16761e12104SWon Kang static struct usb_tx_sdu *get_tx_sdu_struct(struct tx_cxt *tx, int *no_spc) 16861e12104SWon Kang { 16961e12104SWon Kang struct usb_tx_sdu *t_sdu; 17061e12104SWon Kang 17161e12104SWon Kang if (list_empty(&tx->free_list)) 17261e12104SWon Kang return NULL; 17361e12104SWon Kang 17461e12104SWon Kang t_sdu = list_entry(tx->free_list.next, struct usb_tx_sdu, list); 17561e12104SWon Kang list_del(&t_sdu->list); 17661e12104SWon Kang 17761e12104SWon Kang tx->avail_count--; 17861e12104SWon Kang 17961e12104SWon Kang *no_spc = list_empty(&tx->free_list) ? 1 : 0; 18061e12104SWon Kang 18161e12104SWon Kang return t_sdu; 18261e12104SWon Kang } 18361e12104SWon Kang 18461e12104SWon Kang static void put_tx_struct(struct tx_cxt *tx, struct usb_tx_sdu *t_sdu) 18561e12104SWon Kang { 18661e12104SWon Kang list_add_tail(&t_sdu->list, &tx->free_list); 18761e12104SWon Kang tx->avail_count++; 18861e12104SWon Kang } 18961e12104SWon Kang 19061e12104SWon Kang static struct usb_rx *alloc_rx_struct(void) 19161e12104SWon Kang { 19261e12104SWon Kang struct usb_rx *r = NULL; 19361e12104SWon Kang int ret = 0; 19461e12104SWon Kang 19561e12104SWon Kang r = kmalloc(sizeof(struct usb_rx), GFP_ATOMIC); 19661e12104SWon Kang if (!r) { 19761e12104SWon Kang ret = -ENOMEM; 19861e12104SWon Kang goto out; 19961e12104SWon Kang } 20061e12104SWon Kang 20161e12104SWon Kang r->urb = usb_alloc_urb(0, GFP_ATOMIC); 20261e12104SWon Kang r->buf = kmalloc(RX_BUF_SIZE, GFP_ATOMIC); 20361e12104SWon Kang if (!r->urb || !r->buf) { 20461e12104SWon Kang ret = -ENOMEM; 20561e12104SWon Kang goto out; 20661e12104SWon Kang } 20761e12104SWon Kang out: 20861e12104SWon Kang 20961e12104SWon Kang if (ret < 0) { 21061e12104SWon Kang if (r) { 21161e12104SWon Kang usb_free_urb(r->urb); 21261e12104SWon Kang kfree(r->buf); 21361e12104SWon Kang kfree(r); 21461e12104SWon Kang } 21561e12104SWon Kang return NULL; 21661e12104SWon Kang } 21761e12104SWon Kang 21861e12104SWon Kang return r; 21961e12104SWon Kang } 22061e12104SWon Kang 22161e12104SWon Kang static void free_rx_struct(struct usb_rx *r) 22261e12104SWon Kang { 22361e12104SWon Kang if (r) { 22461e12104SWon Kang usb_free_urb(r->urb); 22561e12104SWon Kang kfree(r->buf); 22661e12104SWon Kang kfree(r); 22761e12104SWon Kang } 22861e12104SWon Kang } 22961e12104SWon Kang 23061e12104SWon Kang static struct usb_rx *get_rx_struct(struct rx_cxt *rx, int *no_spc) 23161e12104SWon Kang { 23261e12104SWon Kang struct usb_rx *r; 23361e12104SWon Kang unsigned long flags; 23461e12104SWon Kang 23561e12104SWon Kang spin_lock_irqsave(&rx->rx_lock, flags); 23661e12104SWon Kang 23761e12104SWon Kang if (list_empty(&rx->free_list)) { 23861e12104SWon Kang spin_unlock_irqrestore(&rx->rx_lock, flags); 23961e12104SWon Kang return NULL; 24061e12104SWon Kang } 24161e12104SWon Kang 24261e12104SWon Kang r = list_entry(rx->free_list.next, struct usb_rx, free_list); 24361e12104SWon Kang list_del(&r->free_list); 24461e12104SWon Kang 24561e12104SWon Kang rx->avail_count--; 24661e12104SWon Kang 24761e12104SWon Kang *no_spc = list_empty(&rx->free_list) ? 1 : 0; 24861e12104SWon Kang 24961e12104SWon Kang spin_unlock_irqrestore(&rx->rx_lock, flags); 25061e12104SWon Kang 25161e12104SWon Kang return r; 25261e12104SWon Kang } 25361e12104SWon Kang 25461e12104SWon Kang static void put_rx_struct(struct rx_cxt *rx, struct usb_rx *r) 25561e12104SWon Kang { 25661e12104SWon Kang unsigned long flags; 25761e12104SWon Kang 25861e12104SWon Kang spin_lock_irqsave(&rx->rx_lock, flags); 25961e12104SWon Kang 26061e12104SWon Kang list_add_tail(&r->free_list, &rx->free_list); 26161e12104SWon Kang rx->avail_count++; 26261e12104SWon Kang 26361e12104SWon Kang spin_unlock_irqrestore(&rx->rx_lock, flags); 26461e12104SWon Kang } 26561e12104SWon Kang 26661e12104SWon Kang static void release_usb(struct lte_udev *udev) 26761e12104SWon Kang { 26861e12104SWon Kang struct rx_cxt *rx = &udev->rx; 26961e12104SWon Kang struct tx_cxt *tx = &udev->tx; 27061e12104SWon Kang struct usb_tx *t, *t_next; 27161e12104SWon Kang struct usb_rx *r, *r_next; 27261e12104SWon Kang struct usb_tx_sdu *t_sdu, *t_sdu_next; 27361e12104SWon Kang unsigned long flags; 27461e12104SWon Kang 27561e12104SWon Kang spin_lock_irqsave(&tx->lock, flags); 27661e12104SWon Kang list_for_each_entry_safe(t_sdu, t_sdu_next, &tx->sdu_list, list) 27761e12104SWon Kang { 27861e12104SWon Kang list_del(&t_sdu->list); 27961e12104SWon Kang free_tx_sdu_struct(t_sdu); 28061e12104SWon Kang } 28161e12104SWon Kang 28261e12104SWon Kang list_for_each_entry_safe(t, t_next, &tx->hci_list, list) 28361e12104SWon Kang { 28461e12104SWon Kang list_del(&t->list); 28561e12104SWon Kang free_tx_struct(t); 28661e12104SWon Kang } 28761e12104SWon Kang 28861e12104SWon Kang list_for_each_entry_safe(t_sdu, t_sdu_next, &tx->free_list, list) 28961e12104SWon Kang { 29061e12104SWon Kang list_del(&t_sdu->list); 29161e12104SWon Kang free_tx_sdu_struct(t_sdu); 29261e12104SWon Kang } 29361e12104SWon Kang spin_unlock_irqrestore(&tx->lock, flags); 29461e12104SWon Kang 29561e12104SWon Kang spin_lock_irqsave(&rx->submit_lock, flags); 29661e12104SWon Kang list_for_each_entry_safe(r, r_next, &rx->rx_submit_list, rx_submit_list) 29761e12104SWon Kang { 29861e12104SWon Kang spin_unlock_irqrestore(&rx->submit_lock, flags); 29961e12104SWon Kang usb_kill_urb(r->urb); 30061e12104SWon Kang spin_lock_irqsave(&rx->submit_lock, flags); 30161e12104SWon Kang } 30261e12104SWon Kang spin_unlock_irqrestore(&rx->submit_lock, flags); 30361e12104SWon Kang 30461e12104SWon Kang spin_lock_irqsave(&rx->rx_lock, flags); 30561e12104SWon Kang list_for_each_entry_safe(r, r_next, &rx->free_list, free_list) 30661e12104SWon Kang { 30761e12104SWon Kang list_del(&r->free_list); 30861e12104SWon Kang free_rx_struct(r); 30961e12104SWon Kang } 31061e12104SWon Kang spin_unlock_irqrestore(&rx->rx_lock, flags); 31161e12104SWon Kang 31261e12104SWon Kang spin_lock_irqsave(&rx->to_host_lock, flags); 31361e12104SWon Kang list_for_each_entry_safe(r, r_next, &rx->to_host_list, to_host_list) 31461e12104SWon Kang { 31561e12104SWon Kang if (r->index == (void *)udev) { 31661e12104SWon Kang list_del(&r->to_host_list); 31761e12104SWon Kang free_rx_struct(r); 31861e12104SWon Kang } 31961e12104SWon Kang } 32061e12104SWon Kang spin_unlock_irqrestore(&rx->to_host_lock, flags); 32161e12104SWon Kang } 32261e12104SWon Kang 32361e12104SWon Kang static int init_usb(struct lte_udev *udev) 32461e12104SWon Kang { 32561e12104SWon Kang int ret = 0; 32661e12104SWon Kang int i; 32761e12104SWon Kang struct tx_cxt *tx = &udev->tx; 32861e12104SWon Kang struct rx_cxt *rx = &udev->rx; 32961e12104SWon Kang struct usb_tx_sdu *t_sdu = NULL; 33061e12104SWon Kang struct usb_rx *r = NULL; 33161e12104SWon Kang 33261e12104SWon Kang udev->send_complete = 1; 33361e12104SWon Kang udev->tx_stop = 0; 33461e12104SWon Kang udev->request_mac_addr = 0; 33561e12104SWon Kang udev->usb_state = PM_NORMAL; 33661e12104SWon Kang 33761e12104SWon Kang INIT_LIST_HEAD(&tx->sdu_list); 33861e12104SWon Kang INIT_LIST_HEAD(&tx->hci_list); 33961e12104SWon Kang INIT_LIST_HEAD(&tx->free_list); 34061e12104SWon Kang INIT_LIST_HEAD(&rx->rx_submit_list); 34161e12104SWon Kang INIT_LIST_HEAD(&rx->free_list); 34261e12104SWon Kang INIT_LIST_HEAD(&rx->to_host_list); 34361e12104SWon Kang spin_lock_init(&tx->lock); 34461e12104SWon Kang spin_lock_init(&rx->rx_lock); 34561e12104SWon Kang spin_lock_init(&rx->submit_lock); 34661e12104SWon Kang spin_lock_init(&rx->to_host_lock); 34761e12104SWon Kang 34861e12104SWon Kang tx->avail_count = 0; 34961e12104SWon Kang rx->avail_count = 0; 35061e12104SWon Kang 35161e12104SWon Kang udev->rx_cb = NULL; 35261e12104SWon Kang 35361e12104SWon Kang for (i = 0; i < MAX_NUM_SDU_BUF; i++) { 35461e12104SWon Kang t_sdu = alloc_tx_sdu_struct(); 35561e12104SWon Kang if (t_sdu == NULL) { 35661e12104SWon Kang ret = -ENOMEM; 35761e12104SWon Kang goto fail; 35861e12104SWon Kang } 35961e12104SWon Kang 36061e12104SWon Kang list_add(&t_sdu->list, &tx->free_list); 36161e12104SWon Kang tx->avail_count++; 36261e12104SWon Kang } 36361e12104SWon Kang 36461e12104SWon Kang for (i = 0; i < MAX_RX_SUBMIT_COUNT*2; i++) { 36561e12104SWon Kang r = alloc_rx_struct(); 36661e12104SWon Kang if (r == NULL) { 36761e12104SWon Kang ret = -ENOMEM; 36861e12104SWon Kang goto fail; 36961e12104SWon Kang } 37061e12104SWon Kang 37161e12104SWon Kang list_add(&r->free_list, &rx->free_list); 37261e12104SWon Kang rx->avail_count++; 37361e12104SWon Kang } 37461e12104SWon Kang INIT_DELAYED_WORK(&udev->work_tx, do_tx); 37561e12104SWon Kang INIT_DELAYED_WORK(&udev->work_rx, do_rx); 37661e12104SWon Kang return 0; 37761e12104SWon Kang fail: 37861e12104SWon Kang return ret; 37961e12104SWon Kang } 38061e12104SWon Kang 38161e12104SWon Kang static int set_mac_address(u8 *data, void *arg) 38261e12104SWon Kang { 38361e12104SWon Kang struct phy_dev *phy_dev = (struct phy_dev *)arg; 38461e12104SWon Kang struct lte_udev *udev = phy_dev->priv_dev; 38561e12104SWon Kang struct tlv *tlv = (struct tlv *)data; 38661e12104SWon Kang u8 mac_address[ETH_ALEN] = {0, }; 38761e12104SWon Kang 38861e12104SWon Kang if (tlv->type == MAC_ADDRESS && udev->request_mac_addr) { 38961e12104SWon Kang memcpy(mac_address, tlv->data, tlv->len); 39061e12104SWon Kang 39161e12104SWon Kang if (register_lte_device(phy_dev, &udev->intf->dev, mac_address) < 0) 3920ec473b5SJoe Perches pr_err("register lte device failed\n"); 39361e12104SWon Kang 39461e12104SWon Kang udev->request_mac_addr = 0; 39561e12104SWon Kang 39661e12104SWon Kang return 1; 39761e12104SWon Kang } 39861e12104SWon Kang 39961e12104SWon Kang return 0; 40061e12104SWon Kang } 40161e12104SWon Kang 40261e12104SWon Kang static void do_rx(struct work_struct *work) 40361e12104SWon Kang { 40461e12104SWon Kang struct lte_udev *udev = container_of(work, struct lte_udev, work_rx.work); 40561e12104SWon Kang struct rx_cxt *rx = &udev->rx; 40661e12104SWon Kang struct usb_rx *r; 40761e12104SWon Kang struct hci_packet *hci; 40861e12104SWon Kang struct phy_dev *phy_dev; 40961e12104SWon Kang u16 cmd_evt; 41061e12104SWon Kang int ret; 41161e12104SWon Kang unsigned long flags; 41261e12104SWon Kang 41361e12104SWon Kang while (1) { 41461e12104SWon Kang spin_lock_irqsave(&rx->to_host_lock, flags); 41561e12104SWon Kang if (list_empty(&rx->to_host_list)) { 41661e12104SWon Kang spin_unlock_irqrestore(&rx->to_host_lock, flags); 41761e12104SWon Kang break; 41861e12104SWon Kang } 41961e12104SWon Kang r = list_entry(rx->to_host_list.next, struct usb_rx, to_host_list); 42061e12104SWon Kang list_del(&r->to_host_list); 42161e12104SWon Kang spin_unlock_irqrestore(&rx->to_host_lock, flags); 42261e12104SWon Kang 42361e12104SWon Kang phy_dev = (struct phy_dev *)r->cb_data; 42461e12104SWon Kang udev = (struct lte_udev *)phy_dev->priv_dev; 42561e12104SWon Kang hci = (struct hci_packet *)r->buf; 42661e12104SWon Kang cmd_evt = gdm_dev16_to_cpu(&udev->gdm_ed, hci->cmd_evt); 42761e12104SWon Kang 42861e12104SWon Kang switch (cmd_evt) { 42961e12104SWon Kang case LTE_GET_INFORMATION_RESULT: 43061e12104SWon Kang if (set_mac_address(hci->data, r->cb_data) == 0) { 43161e12104SWon Kang ret = r->callback(r->cb_data, 43261e12104SWon Kang r->buf, 43361e12104SWon Kang r->urb->actual_length, 43461e12104SWon Kang KERNEL_THREAD); 43561e12104SWon Kang } 43661e12104SWon Kang break; 43761e12104SWon Kang 43861e12104SWon Kang default: 43961e12104SWon Kang if (r->callback) { 44061e12104SWon Kang ret = r->callback(r->cb_data, 44161e12104SWon Kang r->buf, 44261e12104SWon Kang r->urb->actual_length, 44361e12104SWon Kang KERNEL_THREAD); 44461e12104SWon Kang 44561e12104SWon Kang if (ret == -EAGAIN) 4460ec473b5SJoe Perches pr_err("failed to send received data\n"); 44761e12104SWon Kang } 44861e12104SWon Kang break; 44961e12104SWon Kang } 45061e12104SWon Kang 45161e12104SWon Kang put_rx_struct(rx, r); 45261e12104SWon Kang 45361e12104SWon Kang gdm_usb_recv(udev, 45461e12104SWon Kang r->callback, 45561e12104SWon Kang r->cb_data, 45661e12104SWon Kang USB_COMPLETE); 45761e12104SWon Kang } 45861e12104SWon Kang } 45961e12104SWon Kang 46061e12104SWon Kang static void remove_rx_submit_list(struct usb_rx *r, struct rx_cxt *rx) 46161e12104SWon Kang { 46261e12104SWon Kang unsigned long flags; 46361e12104SWon Kang struct usb_rx *r_remove, *r_remove_next; 46461e12104SWon Kang 46561e12104SWon Kang spin_lock_irqsave(&rx->submit_lock, flags); 46661e12104SWon Kang list_for_each_entry_safe(r_remove, r_remove_next, &rx->rx_submit_list, rx_submit_list) 46761e12104SWon Kang { 46861e12104SWon Kang if (r == r_remove) { 46961e12104SWon Kang list_del(&r->rx_submit_list); 47061e12104SWon Kang break; 47161e12104SWon Kang } 47261e12104SWon Kang } 47361e12104SWon Kang spin_unlock_irqrestore(&rx->submit_lock, flags); 47461e12104SWon Kang } 47561e12104SWon Kang 47661e12104SWon Kang static void gdm_usb_rcv_complete(struct urb *urb) 47761e12104SWon Kang { 47861e12104SWon Kang struct usb_rx *r = urb->context; 47961e12104SWon Kang struct rx_cxt *rx = r->rx; 48061e12104SWon Kang unsigned long flags; 48161e12104SWon Kang struct lte_udev *udev = container_of(r->rx, struct lte_udev, rx); 48261e12104SWon Kang struct usb_device *usbdev = udev->usbdev; 48361e12104SWon Kang 48461e12104SWon Kang remove_rx_submit_list(r, rx); 48561e12104SWon Kang 48661e12104SWon Kang if (!urb->status && r->callback) { 48761e12104SWon Kang spin_lock_irqsave(&rx->to_host_lock, flags); 48861e12104SWon Kang list_add_tail(&r->to_host_list, &rx->to_host_list); 48961e12104SWon Kang queue_work(usb_rx_wq, &udev->work_rx.work); 49061e12104SWon Kang spin_unlock_irqrestore(&rx->to_host_lock, flags); 49161e12104SWon Kang } else { 49261e12104SWon Kang if (urb->status && udev->usb_state == PM_NORMAL) 4930ec473b5SJoe Perches pr_err("%s: urb status error %d\n", 4940ec473b5SJoe Perches __func__, urb->status); 49561e12104SWon Kang 49661e12104SWon Kang put_rx_struct(rx, r); 49761e12104SWon Kang } 49861e12104SWon Kang 49961e12104SWon Kang usb_mark_last_busy(usbdev); 50061e12104SWon Kang } 50161e12104SWon Kang 50261e12104SWon Kang static int gdm_usb_recv(void *priv_dev, 50361e12104SWon Kang int (*cb)(void *cb_data, void *data, int len, int context), 50461e12104SWon Kang void *cb_data, 50561e12104SWon Kang int context) 50661e12104SWon Kang { 50761e12104SWon Kang struct lte_udev *udev = priv_dev; 50861e12104SWon Kang struct usb_device *usbdev = udev->usbdev; 50961e12104SWon Kang struct rx_cxt *rx = &udev->rx; 51061e12104SWon Kang struct usb_rx *r; 51161e12104SWon Kang int no_spc; 51261e12104SWon Kang int ret; 51361e12104SWon Kang unsigned long flags; 51461e12104SWon Kang 51561e12104SWon Kang if (!udev->usbdev) { 5160ec473b5SJoe Perches pr_err("invalid device\n"); 51761e12104SWon Kang return -ENODEV; 51861e12104SWon Kang } 51961e12104SWon Kang 52061e12104SWon Kang r = get_rx_struct(rx, &no_spc); 52161e12104SWon Kang if (!r) { 5220ec473b5SJoe Perches pr_err("Out of Memory\n"); 52361e12104SWon Kang return -ENOMEM; 52461e12104SWon Kang } 52561e12104SWon Kang 52661e12104SWon Kang udev->rx_cb = cb; 52761e12104SWon Kang r->callback = cb; 52861e12104SWon Kang r->cb_data = cb_data; 52961e12104SWon Kang r->index = (void *)udev; 53061e12104SWon Kang r->rx = rx; 53161e12104SWon Kang 53261e12104SWon Kang usb_fill_bulk_urb(r->urb, 53361e12104SWon Kang usbdev, 53461e12104SWon Kang usb_rcvbulkpipe(usbdev, 0x83), 53561e12104SWon Kang r->buf, 53661e12104SWon Kang RX_BUF_SIZE, 53761e12104SWon Kang gdm_usb_rcv_complete, 53861e12104SWon Kang r); 53961e12104SWon Kang 54061e12104SWon Kang spin_lock_irqsave(&rx->submit_lock, flags); 54161e12104SWon Kang list_add_tail(&r->rx_submit_list, &rx->rx_submit_list); 54261e12104SWon Kang spin_unlock_irqrestore(&rx->submit_lock, flags); 54361e12104SWon Kang 54461e12104SWon Kang if (context == KERNEL_THREAD) 54561e12104SWon Kang ret = usb_submit_urb(r->urb, GFP_KERNEL); 54661e12104SWon Kang else 54761e12104SWon Kang ret = usb_submit_urb(r->urb, GFP_ATOMIC); 54861e12104SWon Kang 54961e12104SWon Kang if (ret) { 55061e12104SWon Kang spin_lock_irqsave(&rx->submit_lock, flags); 55161e12104SWon Kang list_del(&r->rx_submit_list); 55261e12104SWon Kang spin_unlock_irqrestore(&rx->submit_lock, flags); 55361e12104SWon Kang 5540ec473b5SJoe Perches pr_err("usb_submit_urb failed (%p)\n", r); 55561e12104SWon Kang put_rx_struct(rx, r); 55661e12104SWon Kang } 55761e12104SWon Kang 55861e12104SWon Kang return ret; 55961e12104SWon Kang } 56061e12104SWon Kang 56161e12104SWon Kang static void gdm_usb_send_complete(struct urb *urb) 56261e12104SWon Kang { 56361e12104SWon Kang struct usb_tx *t = urb->context; 56461e12104SWon Kang struct tx_cxt *tx = t->tx; 56561e12104SWon Kang struct lte_udev *udev = container_of(tx, struct lte_udev, tx); 56661e12104SWon Kang unsigned long flags; 56761e12104SWon Kang 56861e12104SWon Kang if (urb->status == -ECONNRESET) { 5690ec473b5SJoe Perches pr_info("CONNRESET\n"); 57061e12104SWon Kang return; 57161e12104SWon Kang } 57261e12104SWon Kang 57361e12104SWon Kang if (t->callback) 57461e12104SWon Kang t->callback(t->cb_data); 57561e12104SWon Kang 57661e12104SWon Kang free_tx_struct(t); 57761e12104SWon Kang 57861e12104SWon Kang spin_lock_irqsave(&tx->lock, flags); 57961e12104SWon Kang udev->send_complete = 1; 58061e12104SWon Kang queue_work(usb_tx_wq, &udev->work_tx.work); 58161e12104SWon Kang spin_unlock_irqrestore(&tx->lock, flags); 58261e12104SWon Kang } 58361e12104SWon Kang 58461e12104SWon Kang static int send_tx_packet(struct usb_device *usbdev, struct usb_tx *t, u32 len) 58561e12104SWon Kang { 58661e12104SWon Kang int ret = 0; 58761e12104SWon Kang 58861e12104SWon Kang if (!(len%512)) 58961e12104SWon Kang len++; 59061e12104SWon Kang 59161e12104SWon Kang usb_fill_bulk_urb(t->urb, 59261e12104SWon Kang usbdev, 59361e12104SWon Kang usb_sndbulkpipe(usbdev, 2), 59461e12104SWon Kang t->buf, 59561e12104SWon Kang len, 59661e12104SWon Kang gdm_usb_send_complete, 59761e12104SWon Kang t); 59861e12104SWon Kang 59961e12104SWon Kang ret = usb_submit_urb(t->urb, GFP_ATOMIC); 60061e12104SWon Kang 60161e12104SWon Kang if (ret) 6020ec473b5SJoe Perches pr_err("usb_submit_urb failed: %d\n", ret); 60361e12104SWon Kang 60461e12104SWon Kang usb_mark_last_busy(usbdev); 60561e12104SWon Kang 60661e12104SWon Kang return ret; 60761e12104SWon Kang } 60861e12104SWon Kang 60961e12104SWon Kang static u32 packet_aggregation(struct lte_udev *udev, u8 *send_buf) 61061e12104SWon Kang { 61161e12104SWon Kang struct tx_cxt *tx = &udev->tx; 61261e12104SWon Kang struct usb_tx_sdu *t_sdu = NULL; 61361e12104SWon Kang struct multi_sdu *multi_sdu = (struct multi_sdu *)send_buf; 61461e12104SWon Kang u16 send_len = 0; 61561e12104SWon Kang u16 num_packet = 0; 61661e12104SWon Kang unsigned long flags; 61761e12104SWon Kang 61861e12104SWon Kang multi_sdu->cmd_evt = gdm_cpu_to_dev16(&udev->gdm_ed, LTE_TX_MULTI_SDU); 61961e12104SWon Kang 62061e12104SWon Kang while (num_packet < MAX_PACKET_IN_MULTI_SDU) { 62161e12104SWon Kang spin_lock_irqsave(&tx->lock, flags); 62261e12104SWon Kang if (list_empty(&tx->sdu_list)) { 62361e12104SWon Kang spin_unlock_irqrestore(&tx->lock, flags); 62461e12104SWon Kang break; 62561e12104SWon Kang } 62661e12104SWon Kang 62761e12104SWon Kang t_sdu = list_entry(tx->sdu_list.next, struct usb_tx_sdu, list); 62861e12104SWon Kang if (send_len + t_sdu->len > MAX_SDU_SIZE) { 62961e12104SWon Kang spin_unlock_irqrestore(&tx->lock, flags); 63061e12104SWon Kang break; 63161e12104SWon Kang } 63261e12104SWon Kang 63361e12104SWon Kang list_del(&t_sdu->list); 63461e12104SWon Kang spin_unlock_irqrestore(&tx->lock, flags); 63561e12104SWon Kang 63661e12104SWon Kang memcpy(multi_sdu->data + send_len, t_sdu->buf, t_sdu->len); 63761e12104SWon Kang 63861e12104SWon Kang send_len += (t_sdu->len + 3) & 0xfffc; 63961e12104SWon Kang num_packet++; 64061e12104SWon Kang 64161e12104SWon Kang if (tx->avail_count > 10) 64261e12104SWon Kang t_sdu->callback(t_sdu->cb_data); 64361e12104SWon Kang 64461e12104SWon Kang spin_lock_irqsave(&tx->lock, flags); 64561e12104SWon Kang put_tx_struct(tx, t_sdu); 64661e12104SWon Kang spin_unlock_irqrestore(&tx->lock, flags); 64761e12104SWon Kang } 64861e12104SWon Kang 64961e12104SWon Kang multi_sdu->len = gdm_cpu_to_dev16(&udev->gdm_ed, send_len); 65061e12104SWon Kang multi_sdu->num_packet = gdm_cpu_to_dev16(&udev->gdm_ed, num_packet); 65161e12104SWon Kang 65261e12104SWon Kang return send_len + offsetof(struct multi_sdu, data); 65361e12104SWon Kang } 65461e12104SWon Kang 65561e12104SWon Kang static void do_tx(struct work_struct *work) 65661e12104SWon Kang { 65761e12104SWon Kang struct lte_udev *udev = container_of(work, struct lte_udev, work_tx.work); 65861e12104SWon Kang struct usb_device *usbdev = udev->usbdev; 65961e12104SWon Kang struct tx_cxt *tx = &udev->tx; 66061e12104SWon Kang struct usb_tx *t = NULL; 66161e12104SWon Kang int is_send = 0; 66261e12104SWon Kang u32 len = 0; 66361e12104SWon Kang unsigned long flags; 66461e12104SWon Kang 66561e12104SWon Kang if (!usb_autopm_get_interface(udev->intf)) 66661e12104SWon Kang usb_autopm_put_interface(udev->intf); 66761e12104SWon Kang 66861e12104SWon Kang if (udev->usb_state == PM_SUSPEND) 66961e12104SWon Kang return; 67061e12104SWon Kang 67161e12104SWon Kang spin_lock_irqsave(&tx->lock, flags); 67261e12104SWon Kang if (!udev->send_complete) { 67361e12104SWon Kang spin_unlock_irqrestore(&tx->lock, flags); 67461e12104SWon Kang return; 67561e12104SWon Kang } else { 67661e12104SWon Kang udev->send_complete = 0; 67761e12104SWon Kang } 67861e12104SWon Kang 67961e12104SWon Kang if (!list_empty(&tx->hci_list)) { 68061e12104SWon Kang t = list_entry(tx->hci_list.next, struct usb_tx, list); 68161e12104SWon Kang list_del(&t->list); 68261e12104SWon Kang len = t->len; 68361e12104SWon Kang t->is_sdu = 0; 68461e12104SWon Kang is_send = 1; 68561e12104SWon Kang } else if (!list_empty(&tx->sdu_list)) { 68661e12104SWon Kang if (udev->tx_stop) { 68761e12104SWon Kang udev->send_complete = 1; 68861e12104SWon Kang spin_unlock_irqrestore(&tx->lock, flags); 68961e12104SWon Kang return; 69061e12104SWon Kang } 69161e12104SWon Kang 69261e12104SWon Kang t = alloc_tx_struct(TX_BUF_SIZE); 69361e12104SWon Kang t->callback = NULL; 69461e12104SWon Kang t->tx = tx; 69561e12104SWon Kang t->is_sdu = 1; 69661e12104SWon Kang is_send = 1; 69761e12104SWon Kang } 69861e12104SWon Kang 69961e12104SWon Kang if (!is_send) { 70061e12104SWon Kang udev->send_complete = 1; 70161e12104SWon Kang spin_unlock_irqrestore(&tx->lock, flags); 70261e12104SWon Kang return; 70361e12104SWon Kang } 70461e12104SWon Kang spin_unlock_irqrestore(&tx->lock, flags); 70561e12104SWon Kang 70661e12104SWon Kang if (t->is_sdu) 70761e12104SWon Kang len = packet_aggregation(udev, t->buf); 70861e12104SWon Kang 70961e12104SWon Kang if (send_tx_packet(usbdev, t, len)) { 7100ec473b5SJoe Perches pr_err("send_tx_packet failed\n"); 71161e12104SWon Kang t->callback = NULL; 71261e12104SWon Kang gdm_usb_send_complete(t->urb); 71361e12104SWon Kang } 71461e12104SWon Kang } 71561e12104SWon Kang 71661e12104SWon Kang #define SDU_PARAM_LEN 12 71761e12104SWon Kang static int gdm_usb_sdu_send(void *priv_dev, void *data, int len, 71861e12104SWon Kang unsigned int dftEpsId, unsigned int epsId, 71961e12104SWon Kang void (*cb)(void *data), void *cb_data, 72061e12104SWon Kang int dev_idx, int nic_type) 72161e12104SWon Kang { 72261e12104SWon Kang struct lte_udev *udev = priv_dev; 72361e12104SWon Kang struct tx_cxt *tx = &udev->tx; 72461e12104SWon Kang struct usb_tx_sdu *t_sdu; 72561e12104SWon Kang struct sdu *sdu = NULL; 72661e12104SWon Kang unsigned long flags; 72761e12104SWon Kang int no_spc = 0; 72861e12104SWon Kang u16 send_len; 72961e12104SWon Kang 73061e12104SWon Kang if (!udev->usbdev) { 7310ec473b5SJoe Perches pr_err("sdu send - invalid device\n"); 73261e12104SWon Kang return TX_NO_DEV; 73361e12104SWon Kang } 73461e12104SWon Kang 73561e12104SWon Kang spin_lock_irqsave(&tx->lock, flags); 73661e12104SWon Kang t_sdu = get_tx_sdu_struct(tx, &no_spc); 73761e12104SWon Kang spin_unlock_irqrestore(&tx->lock, flags); 73861e12104SWon Kang 73961e12104SWon Kang if (t_sdu == NULL) { 7400ec473b5SJoe Perches pr_err("sdu send - free list empty\n"); 74161e12104SWon Kang return TX_NO_SPC; 74261e12104SWon Kang } 74361e12104SWon Kang 74461e12104SWon Kang sdu = (struct sdu *)t_sdu->buf; 74561e12104SWon Kang sdu->cmd_evt = gdm_cpu_to_dev16(&udev->gdm_ed, LTE_TX_SDU); 74661e12104SWon Kang if (nic_type == NIC_TYPE_ARP) { 74761e12104SWon Kang send_len = len + SDU_PARAM_LEN; 74861e12104SWon Kang memcpy(sdu->data, data, len); 74961e12104SWon Kang } else { 75061e12104SWon Kang send_len = len - ETH_HLEN; 75161e12104SWon Kang send_len += SDU_PARAM_LEN; 75261e12104SWon Kang memcpy(sdu->data, data+ETH_HLEN, len-ETH_HLEN); 75361e12104SWon Kang } 75461e12104SWon Kang 75561e12104SWon Kang sdu->len = gdm_cpu_to_dev16(&udev->gdm_ed, send_len); 75661e12104SWon Kang sdu->dftEpsId = gdm_cpu_to_dev32(&udev->gdm_ed, dftEpsId); 75761e12104SWon Kang sdu->bearer_ID = gdm_cpu_to_dev32(&udev->gdm_ed, epsId); 75861e12104SWon Kang sdu->nic_type = gdm_cpu_to_dev32(&udev->gdm_ed, nic_type); 75961e12104SWon Kang 76061e12104SWon Kang t_sdu->len = send_len + HCI_HEADER_SIZE; 76161e12104SWon Kang t_sdu->callback = cb; 76261e12104SWon Kang t_sdu->cb_data = cb_data; 76361e12104SWon Kang 76461e12104SWon Kang spin_lock_irqsave(&tx->lock, flags); 76561e12104SWon Kang list_add_tail(&t_sdu->list, &tx->sdu_list); 76661e12104SWon Kang queue_work(usb_tx_wq, &udev->work_tx.work); 76761e12104SWon Kang spin_unlock_irqrestore(&tx->lock, flags); 76861e12104SWon Kang 76961e12104SWon Kang if (no_spc) 77061e12104SWon Kang return TX_NO_BUFFER; 77161e12104SWon Kang 77261e12104SWon Kang return 0; 77361e12104SWon Kang } 77461e12104SWon Kang 77561e12104SWon Kang static int gdm_usb_hci_send(void *priv_dev, void *data, int len, 77661e12104SWon Kang void (*cb)(void *data), void *cb_data) 77761e12104SWon Kang { 77861e12104SWon Kang struct lte_udev *udev = priv_dev; 77961e12104SWon Kang struct tx_cxt *tx = &udev->tx; 78061e12104SWon Kang struct usb_tx *t; 78161e12104SWon Kang unsigned long flags; 78261e12104SWon Kang 78361e12104SWon Kang if (!udev->usbdev) { 7840ec473b5SJoe Perches pr_err("hci send - invalid device\n"); 78561e12104SWon Kang return -ENODEV; 78661e12104SWon Kang } 78761e12104SWon Kang 78861e12104SWon Kang t = alloc_tx_struct(len); 78961e12104SWon Kang if (t == NULL) { 7900ec473b5SJoe Perches pr_err("hci_send - out of memory\n"); 79161e12104SWon Kang return -ENOMEM; 79261e12104SWon Kang } 79361e12104SWon Kang 79461e12104SWon Kang memcpy(t->buf, data, len); 79561e12104SWon Kang t->callback = cb; 79661e12104SWon Kang t->cb_data = cb_data; 79761e12104SWon Kang t->len = len; 79861e12104SWon Kang t->tx = tx; 79961e12104SWon Kang t->is_sdu = 0; 80061e12104SWon Kang 80161e12104SWon Kang spin_lock_irqsave(&tx->lock, flags); 80261e12104SWon Kang list_add_tail(&t->list, &tx->hci_list); 80361e12104SWon Kang queue_work(usb_tx_wq, &udev->work_tx.work); 80461e12104SWon Kang spin_unlock_irqrestore(&tx->lock, flags); 80561e12104SWon Kang 80661e12104SWon Kang return 0; 80761e12104SWon Kang } 80861e12104SWon Kang 80961e12104SWon Kang static struct gdm_endian *gdm_usb_get_endian(void *priv_dev) 81061e12104SWon Kang { 81161e12104SWon Kang struct lte_udev *udev = priv_dev; 81261e12104SWon Kang 81361e12104SWon Kang return &udev->gdm_ed; 81461e12104SWon Kang } 81561e12104SWon Kang 81661e12104SWon Kang static int gdm_usb_probe(struct usb_interface *intf, const struct usb_device_id *id) 81761e12104SWon Kang { 81861e12104SWon Kang int ret = 0; 81961e12104SWon Kang struct phy_dev *phy_dev = NULL; 82061e12104SWon Kang struct lte_udev *udev = NULL; 82161e12104SWon Kang u16 idVendor, idProduct; 82261e12104SWon Kang int bInterfaceNumber; 82361e12104SWon Kang struct usb_device *usbdev = interface_to_usbdev(intf); 82461e12104SWon Kang 82561e12104SWon Kang bInterfaceNumber = intf->cur_altsetting->desc.bInterfaceNumber; 82661e12104SWon Kang idVendor = __le16_to_cpu(usbdev->descriptor.idVendor); 82761e12104SWon Kang idProduct = __le16_to_cpu(usbdev->descriptor.idProduct); 82861e12104SWon Kang 8290ec473b5SJoe Perches pr_info("net vid = 0x%04x pid = 0x%04x\n", idVendor, idProduct); 83061e12104SWon Kang 83161e12104SWon Kang if (bInterfaceNumber > NETWORK_INTERFACE) { 8320ec473b5SJoe Perches pr_info("not a network device\n"); 833a34c72b3SAlexey Khoroshilov return -ENODEV; 83461e12104SWon Kang } 83561e12104SWon Kang 836a34c72b3SAlexey Khoroshilov phy_dev = kzalloc(sizeof(struct phy_dev), GFP_KERNEL); 837a34c72b3SAlexey Khoroshilov if (!phy_dev) 838a34c72b3SAlexey Khoroshilov return -ENOMEM; 83961e12104SWon Kang 840a34c72b3SAlexey Khoroshilov udev = kzalloc(sizeof(struct lte_udev), GFP_KERNEL); 84161e12104SWon Kang if (!udev) { 84261e12104SWon Kang ret = -ENOMEM; 843a34c72b3SAlexey Khoroshilov goto err_udev; 84461e12104SWon Kang } 84561e12104SWon Kang 84661e12104SWon Kang phy_dev->priv_dev = (void *)udev; 84761e12104SWon Kang phy_dev->send_hci_func = gdm_usb_hci_send; 84861e12104SWon Kang phy_dev->send_sdu_func = gdm_usb_sdu_send; 84961e12104SWon Kang phy_dev->rcv_func = gdm_usb_recv; 85061e12104SWon Kang phy_dev->get_endian = gdm_usb_get_endian; 85161e12104SWon Kang 85261e12104SWon Kang udev->usbdev = usbdev; 85361e12104SWon Kang ret = init_usb(udev); 85461e12104SWon Kang if (ret < 0) { 8550ec473b5SJoe Perches pr_err("init_usb func failed\n"); 856a34c72b3SAlexey Khoroshilov goto err_init_usb; 85761e12104SWon Kang } 85861e12104SWon Kang udev->intf = intf; 85961e12104SWon Kang 86061e12104SWon Kang intf->needs_remote_wakeup = 1; 86161e12104SWon Kang usb_enable_autosuspend(usbdev); 86261e12104SWon Kang pm_runtime_set_autosuspend_delay(&usbdev->dev, AUTO_SUSPEND_TIMER); 86361e12104SWon Kang 86461e12104SWon Kang /* List up hosts with big endians, otherwise, defaults to little endian */ 86561e12104SWon Kang if (idProduct == PID_GDM7243) 8669c02d0dbSWon Kang gdm_set_endian(&udev->gdm_ed, ENDIANNESS_BIG); 86761e12104SWon Kang else 8689c02d0dbSWon Kang gdm_set_endian(&udev->gdm_ed, ENDIANNESS_LITTLE); 86961e12104SWon Kang 87061e12104SWon Kang ret = request_mac_address(udev); 87161e12104SWon Kang if (ret < 0) { 8720ec473b5SJoe Perches pr_err("request Mac address failed\n"); 873a34c72b3SAlexey Khoroshilov goto err_mac_address; 87461e12104SWon Kang } 87561e12104SWon Kang 87661e12104SWon Kang start_rx_proc(phy_dev); 87761e12104SWon Kang usb_get_dev(usbdev); 87861e12104SWon Kang usb_set_intfdata(intf, phy_dev); 87961e12104SWon Kang 880a34c72b3SAlexey Khoroshilov return 0; 881a34c72b3SAlexey Khoroshilov 882a34c72b3SAlexey Khoroshilov err_mac_address: 883a34c72b3SAlexey Khoroshilov release_usb(udev); 884a34c72b3SAlexey Khoroshilov err_init_usb: 885a34c72b3SAlexey Khoroshilov kfree(udev); 886a34c72b3SAlexey Khoroshilov err_udev: 887a34c72b3SAlexey Khoroshilov kfree(phy_dev); 888a34c72b3SAlexey Khoroshilov 88961e12104SWon Kang return ret; 89061e12104SWon Kang } 89161e12104SWon Kang 89261e12104SWon Kang static void gdm_usb_disconnect(struct usb_interface *intf) 89361e12104SWon Kang { 89461e12104SWon Kang struct phy_dev *phy_dev; 89561e12104SWon Kang struct lte_udev *udev; 89661e12104SWon Kang u16 idVendor, idProduct; 89761e12104SWon Kang struct usb_device *usbdev; 89861e12104SWon Kang usbdev = interface_to_usbdev(intf); 89961e12104SWon Kang 90061e12104SWon Kang idVendor = __le16_to_cpu(usbdev->descriptor.idVendor); 90161e12104SWon Kang idProduct = __le16_to_cpu(usbdev->descriptor.idProduct); 90261e12104SWon Kang 90361e12104SWon Kang phy_dev = usb_get_intfdata(intf); 90461e12104SWon Kang 90561e12104SWon Kang udev = phy_dev->priv_dev; 90661e12104SWon Kang unregister_lte_device(phy_dev); 90761e12104SWon Kang 90861e12104SWon Kang release_usb(udev); 90961e12104SWon Kang 91061e12104SWon Kang kfree(udev); 91161e12104SWon Kang udev = NULL; 91261e12104SWon Kang 91361e12104SWon Kang kfree(phy_dev); 91461e12104SWon Kang phy_dev = NULL; 91561e12104SWon Kang 91661e12104SWon Kang usb_put_dev(usbdev); 91761e12104SWon Kang } 91861e12104SWon Kang 91961e12104SWon Kang static int gdm_usb_suspend(struct usb_interface *intf, pm_message_t pm_msg) 92061e12104SWon Kang { 92161e12104SWon Kang struct phy_dev *phy_dev; 92261e12104SWon Kang struct lte_udev *udev; 92361e12104SWon Kang struct rx_cxt *rx; 92461e12104SWon Kang struct usb_rx *r; 92561e12104SWon Kang struct usb_rx *r_next; 92661e12104SWon Kang unsigned long flags; 92761e12104SWon Kang 92861e12104SWon Kang phy_dev = usb_get_intfdata(intf); 92961e12104SWon Kang udev = phy_dev->priv_dev; 93061e12104SWon Kang rx = &udev->rx; 93161e12104SWon Kang if (udev->usb_state != PM_NORMAL) { 9320ec473b5SJoe Perches pr_err("usb suspend - invalid state\n"); 93361e12104SWon Kang return -1; 93461e12104SWon Kang } 93561e12104SWon Kang 93661e12104SWon Kang udev->usb_state = PM_SUSPEND; 93761e12104SWon Kang 93861e12104SWon Kang spin_lock_irqsave(&rx->submit_lock, flags); 93961e12104SWon Kang list_for_each_entry_safe(r, r_next, &rx->rx_submit_list, rx_submit_list) 94061e12104SWon Kang { 94161e12104SWon Kang spin_unlock_irqrestore(&rx->submit_lock, flags); 94261e12104SWon Kang usb_kill_urb(r->urb); 94361e12104SWon Kang spin_lock_irqsave(&rx->submit_lock, flags); 94461e12104SWon Kang } 94561e12104SWon Kang spin_unlock_irqrestore(&rx->submit_lock, flags); 94661e12104SWon Kang 94761e12104SWon Kang return 0; 94861e12104SWon Kang } 94961e12104SWon Kang 95061e12104SWon Kang static int gdm_usb_resume(struct usb_interface *intf) 95161e12104SWon Kang { 95261e12104SWon Kang struct phy_dev *phy_dev; 95361e12104SWon Kang struct lte_udev *udev; 95461e12104SWon Kang struct tx_cxt *tx; 95561e12104SWon Kang struct rx_cxt *rx; 95661e12104SWon Kang unsigned long flags; 95761e12104SWon Kang int issue_count; 95861e12104SWon Kang int i; 95961e12104SWon Kang 96061e12104SWon Kang phy_dev = usb_get_intfdata(intf); 96161e12104SWon Kang udev = phy_dev->priv_dev; 96261e12104SWon Kang rx = &udev->rx; 96361e12104SWon Kang 96461e12104SWon Kang if (udev->usb_state != PM_SUSPEND) { 9650ec473b5SJoe Perches pr_err("usb resume - invalid state\n"); 96661e12104SWon Kang return -1; 96761e12104SWon Kang } 96861e12104SWon Kang udev->usb_state = PM_NORMAL; 96961e12104SWon Kang 97061e12104SWon Kang spin_lock_irqsave(&rx->rx_lock, flags); 97161e12104SWon Kang issue_count = rx->avail_count - MAX_RX_SUBMIT_COUNT; 97261e12104SWon Kang spin_unlock_irqrestore(&rx->rx_lock, flags); 97361e12104SWon Kang 97461e12104SWon Kang if (issue_count >= 0) { 97561e12104SWon Kang for (i = 0; i < issue_count; i++) 97661e12104SWon Kang gdm_usb_recv(phy_dev->priv_dev, 97761e12104SWon Kang udev->rx_cb, 97861e12104SWon Kang phy_dev, 97961e12104SWon Kang USB_COMPLETE); 98061e12104SWon Kang } 98161e12104SWon Kang 98261e12104SWon Kang tx = &udev->tx; 98361e12104SWon Kang spin_lock_irqsave(&tx->lock, flags); 98461e12104SWon Kang queue_work(usb_tx_wq, &udev->work_tx.work); 98561e12104SWon Kang spin_unlock_irqrestore(&tx->lock, flags); 98661e12104SWon Kang 98761e12104SWon Kang return 0; 98861e12104SWon Kang } 98961e12104SWon Kang 99061e12104SWon Kang static struct usb_driver gdm_usb_lte_driver = { 99161e12104SWon Kang .name = "gdm_lte", 99261e12104SWon Kang .probe = gdm_usb_probe, 99361e12104SWon Kang .disconnect = gdm_usb_disconnect, 99461e12104SWon Kang .id_table = id_table, 99561e12104SWon Kang .supports_autosuspend = 1, 99661e12104SWon Kang .suspend = gdm_usb_suspend, 99761e12104SWon Kang .resume = gdm_usb_resume, 99861e12104SWon Kang .reset_resume = gdm_usb_resume, 99961e12104SWon Kang }; 100061e12104SWon Kang 100161e12104SWon Kang static int __init gdm_usb_lte_init(void) 100261e12104SWon Kang { 100361e12104SWon Kang if (gdm_lte_event_init() < 0) { 10040ec473b5SJoe Perches pr_err("error creating event\n"); 100561e12104SWon Kang return -1; 100661e12104SWon Kang } 100761e12104SWon Kang 100861e12104SWon Kang usb_tx_wq = create_workqueue("usb_tx_wq"); 100961e12104SWon Kang if (usb_tx_wq == NULL) 101061e12104SWon Kang return -1; 101161e12104SWon Kang 101261e12104SWon Kang usb_rx_wq = create_workqueue("usb_rx_wq"); 101361e12104SWon Kang if (usb_rx_wq == NULL) 101461e12104SWon Kang return -1; 101561e12104SWon Kang 101661e12104SWon Kang return usb_register(&gdm_usb_lte_driver); 101761e12104SWon Kang } 101861e12104SWon Kang 101961e12104SWon Kang static void __exit gdm_usb_lte_exit(void) 102061e12104SWon Kang { 102161e12104SWon Kang gdm_lte_event_exit(); 102261e12104SWon Kang 102361e12104SWon Kang usb_deregister(&gdm_usb_lte_driver); 102461e12104SWon Kang 102561e12104SWon Kang if (usb_tx_wq) { 102661e12104SWon Kang flush_workqueue(usb_tx_wq); 102761e12104SWon Kang destroy_workqueue(usb_tx_wq); 102861e12104SWon Kang } 102961e12104SWon Kang 103061e12104SWon Kang if (usb_rx_wq) { 103161e12104SWon Kang flush_workqueue(usb_rx_wq); 103261e12104SWon Kang destroy_workqueue(usb_rx_wq); 103361e12104SWon Kang } 103461e12104SWon Kang } 103561e12104SWon Kang 103661e12104SWon Kang module_init(gdm_usb_lte_init); 103761e12104SWon Kang module_exit(gdm_usb_lte_exit); 103861e12104SWon Kang 103961e12104SWon Kang MODULE_VERSION(DRIVER_VERSION); 104061e12104SWon Kang MODULE_DESCRIPTION("GCT LTE USB Device Driver"); 104161e12104SWon Kang MODULE_LICENSE("GPL"); 1042