1
2
3
4
5
6
7
8
9
10
11
12
13
14#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15
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>
25
26#include "gdm_usb.h"
27#include "gdm_lte.h"
28#include "hci.h"
29#include "hci_packet.h"
30#include "gdm_endian.h"
31
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,\
36 .idVendor = vid,\
37 .idProduct = pid,\
38 .bInterfaceClass = USB_CLASS_COMM,\
39 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET
40
41#define USB_DEVICE_MASS_DATA(vid, pid) \
42 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
43 USB_DEVICE_ID_MATCH_INT_INFO,\
44 .idVendor = vid,\
45 .idProduct = pid,\
46 .bInterfaceSubClass = USB_SC_SCSI, \
47 .bInterfaceClass = USB_CLASS_MASS_STORAGE,\
48 .bInterfaceProtocol = USB_PR_BULK
49
50static const struct usb_device_id id_table[] = {
51 { USB_DEVICE_CDC_DATA(VID_GCT, PID_GDM7240) },
52 { USB_DEVICE_CDC_DATA(VID_GCT, PID_GDM7243) },
53 { }
54};
55
56MODULE_DEVICE_TABLE(usb, id_table);
57
58static void do_tx(struct work_struct *work);
59static void do_rx(struct work_struct *work);
60
61static int gdm_usb_recv(void *priv_dev,
62 int (*cb)(void *cb_data,
63 void *data, int len, int context),
64 void *cb_data,
65 int context);
66
67static int request_mac_address(struct lte_udev *udev)
68{
69 u8 buf[16] = {0,};
70 struct hci_packet *hci = (struct hci_packet *)buf;
71 struct usb_device *usbdev = udev->usbdev;
72 int actual;
73 int ret = -1;
74
75 hci->cmd_evt = gdm_cpu_to_dev16(&udev->gdm_ed, LTE_GET_INFORMATION);
76 hci->len = gdm_cpu_to_dev16(&udev->gdm_ed, 1);
77 hci->data[0] = MAC_ADDRESS;
78
79 ret = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 2), buf, 5,
80 &actual, 1000);
81
82 udev->request_mac_addr = 1;
83
84 return ret;
85}
86
87static struct usb_tx *alloc_tx_struct(int len)
88{
89 struct usb_tx *t = NULL;
90 int ret = 0;
91
92 t = kzalloc(sizeof(*t), GFP_ATOMIC);
93 if (!t) {
94 ret = -ENOMEM;
95 goto out;
96 }
97
98 t->urb = usb_alloc_urb(0, GFP_ATOMIC);
99 if (!(len % 512))
100 len++;
101
102 t->buf = kmalloc(len, GFP_ATOMIC);
103 if (!t->urb || !t->buf) {
104 ret = -ENOMEM;
105 goto out;
106 }
107
108out:
109 if (ret < 0) {
110 if (t) {
111 usb_free_urb(t->urb);
112 kfree(t->buf);
113 kfree(t);
114 }
115 return NULL;
116 }
117
118 return t;
119}
120
121static struct usb_tx_sdu *alloc_tx_sdu_struct(void)
122{
123 struct usb_tx_sdu *t_sdu;
124
125 t_sdu = kzalloc(sizeof(*t_sdu), GFP_KERNEL);
126 if (!t_sdu)
127 return NULL;
128
129 t_sdu->buf = kmalloc(SDU_BUF_SIZE, GFP_KERNEL);
130 if (!t_sdu->buf) {
131 kfree(t_sdu);
132 return NULL;
133 }
134
135 return t_sdu;
136}
137
138static void free_tx_struct(struct usb_tx *t)
139{
140 if (t) {
141 usb_free_urb(t->urb);
142 kfree(t->buf);
143 kfree(t);
144 }
145}
146
147static void free_tx_sdu_struct(struct usb_tx_sdu *t_sdu)
148{
149 if (t_sdu) {
150 kfree(t_sdu->buf);
151 kfree(t_sdu);
152 }
153}
154
155static struct usb_tx_sdu *get_tx_sdu_struct(struct tx_cxt *tx, int *no_spc)
156{
157 struct usb_tx_sdu *t_sdu;
158
159 if (list_empty(&tx->free_list))
160 return NULL;
161
162 t_sdu = list_entry(tx->free_list.next, struct usb_tx_sdu, list);
163 list_del(&t_sdu->list);
164
165 tx->avail_count--;
166
167 *no_spc = list_empty(&tx->free_list) ? 1 : 0;
168
169 return t_sdu;
170}
171
172static void put_tx_struct(struct tx_cxt *tx, struct usb_tx_sdu *t_sdu)
173{
174 list_add_tail(&t_sdu->list, &tx->free_list);
175 tx->avail_count++;
176}
177
178static struct usb_rx *alloc_rx_struct(void)
179{
180 struct usb_rx *r = NULL;
181 int ret = 0;
182
183 r = kmalloc(sizeof(*r), GFP_KERNEL);
184 if (!r) {
185 ret = -ENOMEM;
186 goto out;
187 }
188
189 r->urb = usb_alloc_urb(0, GFP_KERNEL);
190 r->buf = kmalloc(RX_BUF_SIZE, GFP_KERNEL);
191 if (!r->urb || !r->buf) {
192 ret = -ENOMEM;
193 goto out;
194 }
195out:
196
197 if (ret < 0) {
198 if (r) {
199 usb_free_urb(r->urb);
200 kfree(r->buf);
201 kfree(r);
202 }
203 return NULL;
204 }
205
206 return r;
207}
208
209static void free_rx_struct(struct usb_rx *r)
210{
211 if (r) {
212 usb_free_urb(r->urb);
213 kfree(r->buf);
214 kfree(r);
215 }
216}
217
218static struct usb_rx *get_rx_struct(struct rx_cxt *rx, int *no_spc)
219{
220 struct usb_rx *r;
221 unsigned long flags;
222
223 spin_lock_irqsave(&rx->rx_lock, flags);
224
225 if (list_empty(&rx->free_list)) {
226 spin_unlock_irqrestore(&rx->rx_lock, flags);
227 return NULL;
228 }
229
230 r = list_entry(rx->free_list.next, struct usb_rx, free_list);
231 list_del(&r->free_list);
232
233 rx->avail_count--;
234
235 *no_spc = list_empty(&rx->free_list) ? 1 : 0;
236
237 spin_unlock_irqrestore(&rx->rx_lock, flags);
238
239 return r;
240}
241
242static void put_rx_struct(struct rx_cxt *rx, struct usb_rx *r)
243{
244 unsigned long flags;
245
246 spin_lock_irqsave(&rx->rx_lock, flags);
247
248 list_add_tail(&r->free_list, &rx->free_list);
249 rx->avail_count++;
250
251 spin_unlock_irqrestore(&rx->rx_lock, flags);
252}
253
254static void release_usb(struct lte_udev *udev)
255{
256 struct rx_cxt *rx = &udev->rx;
257 struct tx_cxt *tx = &udev->tx;
258 struct usb_tx *t, *t_next;
259 struct usb_rx *r, *r_next;
260 struct usb_tx_sdu *t_sdu, *t_sdu_next;
261 unsigned long flags;
262
263 spin_lock_irqsave(&tx->lock, flags);
264 list_for_each_entry_safe(t_sdu, t_sdu_next, &tx->sdu_list, list) {
265 list_del(&t_sdu->list);
266 free_tx_sdu_struct(t_sdu);
267 }
268
269 list_for_each_entry_safe(t, t_next, &tx->hci_list, list) {
270 list_del(&t->list);
271 free_tx_struct(t);
272 }
273
274 list_for_each_entry_safe(t_sdu, t_sdu_next, &tx->free_list, list) {
275 list_del(&t_sdu->list);
276 free_tx_sdu_struct(t_sdu);
277 }
278 spin_unlock_irqrestore(&tx->lock, flags);
279
280 spin_lock_irqsave(&rx->submit_lock, flags);
281 list_for_each_entry_safe(r, r_next, &rx->rx_submit_list,
282 rx_submit_list) {
283 spin_unlock_irqrestore(&rx->submit_lock, flags);
284 usb_kill_urb(r->urb);
285 spin_lock_irqsave(&rx->submit_lock, flags);
286 }
287 spin_unlock_irqrestore(&rx->submit_lock, flags);
288
289 spin_lock_irqsave(&rx->rx_lock, flags);
290 list_for_each_entry_safe(r, r_next, &rx->free_list, free_list) {
291 list_del(&r->free_list);
292 free_rx_struct(r);
293 }
294 spin_unlock_irqrestore(&rx->rx_lock, flags);
295
296 spin_lock_irqsave(&rx->to_host_lock, flags);
297 list_for_each_entry_safe(r, r_next, &rx->to_host_list, to_host_list) {
298 if (r->index == (void *)udev) {
299 list_del(&r->to_host_list);
300 free_rx_struct(r);
301 }
302 }
303 spin_unlock_irqrestore(&rx->to_host_lock, flags);
304}
305
306static int init_usb(struct lte_udev *udev)
307{
308 int ret = 0;
309 int i;
310 struct tx_cxt *tx = &udev->tx;
311 struct rx_cxt *rx = &udev->rx;
312 struct usb_tx_sdu *t_sdu = NULL;
313 struct usb_rx *r = NULL;
314
315 udev->send_complete = 1;
316 udev->tx_stop = 0;
317 udev->request_mac_addr = 0;
318 udev->usb_state = PM_NORMAL;
319
320 INIT_LIST_HEAD(&tx->sdu_list);
321 INIT_LIST_HEAD(&tx->hci_list);
322 INIT_LIST_HEAD(&tx->free_list);
323 INIT_LIST_HEAD(&rx->rx_submit_list);
324 INIT_LIST_HEAD(&rx->free_list);
325 INIT_LIST_HEAD(&rx->to_host_list);
326 spin_lock_init(&tx->lock);
327 spin_lock_init(&rx->rx_lock);
328 spin_lock_init(&rx->submit_lock);
329 spin_lock_init(&rx->to_host_lock);
330
331 tx->avail_count = 0;
332 rx->avail_count = 0;
333
334 udev->rx_cb = NULL;
335
336 for (i = 0; i < MAX_NUM_SDU_BUF; i++) {
337 t_sdu = alloc_tx_sdu_struct();
338 if (!t_sdu) {
339 ret = -ENOMEM;
340 goto fail;
341 }
342
343 list_add(&t_sdu->list, &tx->free_list);
344 tx->avail_count++;
345 }
346
347 for (i = 0; i < MAX_RX_SUBMIT_COUNT * 2; i++) {
348 r = alloc_rx_struct();
349 if (!r) {
350 ret = -ENOMEM;
351 goto fail;
352 }
353
354 list_add(&r->free_list, &rx->free_list);
355 rx->avail_count++;
356 }
357 INIT_DELAYED_WORK(&udev->work_tx, do_tx);
358 INIT_DELAYED_WORK(&udev->work_rx, do_rx);
359 return 0;
360fail:
361 release_usb(udev);
362 return ret;
363}
364
365static int set_mac_address(u8 *data, void *arg)
366{
367 struct phy_dev *phy_dev = arg;
368 struct lte_udev *udev = phy_dev->priv_dev;
369 struct tlv *tlv = (struct tlv *)data;
370 u8 mac_address[ETH_ALEN] = {0, };
371
372 if (tlv->type == MAC_ADDRESS && udev->request_mac_addr) {
373 memcpy(mac_address, tlv->data, tlv->len);
374
375 if (register_lte_device(phy_dev,
376 &udev->intf->dev, mac_address) < 0)
377 pr_err("register lte device failed\n");
378
379 udev->request_mac_addr = 0;
380
381 return 1;
382 }
383
384 return 0;
385}
386
387static void do_rx(struct work_struct *work)
388{
389 struct lte_udev *udev =
390 container_of(work, struct lte_udev, work_rx.work);
391 struct rx_cxt *rx = &udev->rx;
392 struct usb_rx *r;
393 struct hci_packet *hci;
394 struct phy_dev *phy_dev;
395 u16 cmd_evt;
396 int ret;
397 unsigned long flags;
398
399 while (1) {
400 spin_lock_irqsave(&rx->to_host_lock, flags);
401 if (list_empty(&rx->to_host_list)) {
402 spin_unlock_irqrestore(&rx->to_host_lock, flags);
403 break;
404 }
405 r = list_entry(rx->to_host_list.next,
406 struct usb_rx, to_host_list);
407 list_del(&r->to_host_list);
408 spin_unlock_irqrestore(&rx->to_host_lock, flags);
409
410 phy_dev = r->cb_data;
411 udev = phy_dev->priv_dev;
412 hci = (struct hci_packet *)r->buf;
413 cmd_evt = gdm_dev16_to_cpu(&udev->gdm_ed, hci->cmd_evt);
414
415 switch (cmd_evt) {
416 case LTE_GET_INFORMATION_RESULT:
417 if (set_mac_address(hci->data, r->cb_data) == 0) {
418 r->callback(r->cb_data,
419 r->buf,
420 r->urb->actual_length,
421 KERNEL_THREAD);
422 }
423 break;
424
425 default:
426 if (r->callback) {
427 ret = r->callback(r->cb_data,
428 r->buf,
429 r->urb->actual_length,
430 KERNEL_THREAD);
431
432 if (ret == -EAGAIN)
433 pr_err("failed to send received data\n");
434 }
435 break;
436 }
437
438 put_rx_struct(rx, r);
439
440 gdm_usb_recv(udev,
441 r->callback,
442 r->cb_data,
443 USB_COMPLETE);
444 }
445}
446
447static void remove_rx_submit_list(struct usb_rx *r, struct rx_cxt *rx)
448{
449 unsigned long flags;
450 struct usb_rx *r_remove, *r_remove_next;
451
452 spin_lock_irqsave(&rx->submit_lock, flags);
453 list_for_each_entry_safe(r_remove, r_remove_next,
454 &rx->rx_submit_list, rx_submit_list) {
455 if (r == r_remove) {
456 list_del(&r->rx_submit_list);
457 break;
458 }
459 }
460 spin_unlock_irqrestore(&rx->submit_lock, flags);
461}
462
463static void gdm_usb_rcv_complete(struct urb *urb)
464{
465 struct usb_rx *r = urb->context;
466 struct rx_cxt *rx = r->rx;
467 unsigned long flags;
468 struct lte_udev *udev = container_of(r->rx, struct lte_udev, rx);
469 struct usb_device *usbdev = udev->usbdev;
470
471 remove_rx_submit_list(r, rx);
472
473 if (!urb->status && r->callback) {
474 spin_lock_irqsave(&rx->to_host_lock, flags);
475 list_add_tail(&r->to_host_list, &rx->to_host_list);
476 schedule_work(&udev->work_rx.work);
477 spin_unlock_irqrestore(&rx->to_host_lock, flags);
478 } else {
479 if (urb->status && udev->usb_state == PM_NORMAL)
480 dev_err(&urb->dev->dev, "%s: urb status error %d\n",
481 __func__, urb->status);
482
483 put_rx_struct(rx, r);
484 }
485
486 usb_mark_last_busy(usbdev);
487}
488
489static int gdm_usb_recv(void *priv_dev,
490 int (*cb)(void *cb_data,
491 void *data, int len, int context),
492 void *cb_data,
493 int context)
494{
495 struct lte_udev *udev = priv_dev;
496 struct usb_device *usbdev = udev->usbdev;
497 struct rx_cxt *rx = &udev->rx;
498 struct usb_rx *r;
499 int no_spc;
500 int ret;
501 unsigned long flags;
502
503 if (!udev->usbdev) {
504 pr_err("invalid device\n");
505 return -ENODEV;
506 }
507
508 r = get_rx_struct(rx, &no_spc);
509 if (!r) {
510 pr_err("Out of Memory\n");
511 return -ENOMEM;
512 }
513
514 udev->rx_cb = cb;
515 r->callback = cb;
516 r->cb_data = cb_data;
517 r->index = (void *)udev;
518 r->rx = rx;
519
520 usb_fill_bulk_urb(r->urb,
521 usbdev,
522 usb_rcvbulkpipe(usbdev, 0x83),
523 r->buf,
524 RX_BUF_SIZE,
525 gdm_usb_rcv_complete,
526 r);
527
528 spin_lock_irqsave(&rx->submit_lock, flags);
529 list_add_tail(&r->rx_submit_list, &rx->rx_submit_list);
530 spin_unlock_irqrestore(&rx->submit_lock, flags);
531
532 if (context == KERNEL_THREAD)
533 ret = usb_submit_urb(r->urb, GFP_KERNEL);
534 else
535 ret = usb_submit_urb(r->urb, GFP_ATOMIC);
536
537 if (ret) {
538 spin_lock_irqsave(&rx->submit_lock, flags);
539 list_del(&r->rx_submit_list);
540 spin_unlock_irqrestore(&rx->submit_lock, flags);
541
542 pr_err("usb_submit_urb failed (%p)\n", r);
543 put_rx_struct(rx, r);
544 }
545
546 return ret;
547}
548
549static void gdm_usb_send_complete(struct urb *urb)
550{
551 struct usb_tx *t = urb->context;
552 struct tx_cxt *tx = t->tx;
553 struct lte_udev *udev = container_of(tx, struct lte_udev, tx);
554 unsigned long flags;
555
556 if (urb->status == -ECONNRESET) {
557 dev_info(&urb->dev->dev, "CONNRESET\n");
558 return;
559 }
560
561 if (t->callback)
562 t->callback(t->cb_data);
563
564 free_tx_struct(t);
565
566 spin_lock_irqsave(&tx->lock, flags);
567 udev->send_complete = 1;
568 schedule_work(&udev->work_tx.work);
569 spin_unlock_irqrestore(&tx->lock, flags);
570}
571
572static int send_tx_packet(struct usb_device *usbdev, struct usb_tx *t, u32 len)
573{
574 int ret = 0;
575
576 if (!(len % 512))
577 len++;
578
579 usb_fill_bulk_urb(t->urb,
580 usbdev,
581 usb_sndbulkpipe(usbdev, 2),
582 t->buf,
583 len,
584 gdm_usb_send_complete,
585 t);
586
587 ret = usb_submit_urb(t->urb, GFP_ATOMIC);
588
589 if (ret)
590 dev_err(&usbdev->dev, "usb_submit_urb failed: %d\n",
591 ret);
592
593 usb_mark_last_busy(usbdev);
594
595 return ret;
596}
597
598static u32 packet_aggregation(struct lte_udev *udev, u8 *send_buf)
599{
600 struct tx_cxt *tx = &udev->tx;
601 struct usb_tx_sdu *t_sdu = NULL;
602 struct multi_sdu *multi_sdu = (struct multi_sdu *)send_buf;
603 u16 send_len = 0;
604 u16 num_packet = 0;
605 unsigned long flags;
606
607 multi_sdu->cmd_evt = gdm_cpu_to_dev16(&udev->gdm_ed, LTE_TX_MULTI_SDU);
608
609 while (num_packet < MAX_PACKET_IN_MULTI_SDU) {
610 spin_lock_irqsave(&tx->lock, flags);
611 if (list_empty(&tx->sdu_list)) {
612 spin_unlock_irqrestore(&tx->lock, flags);
613 break;
614 }
615
616 t_sdu = list_entry(tx->sdu_list.next, struct usb_tx_sdu, list);
617 if (send_len + t_sdu->len > MAX_SDU_SIZE) {
618 spin_unlock_irqrestore(&tx->lock, flags);
619 break;
620 }
621
622 list_del(&t_sdu->list);
623 spin_unlock_irqrestore(&tx->lock, flags);
624
625 memcpy(multi_sdu->data + send_len, t_sdu->buf, t_sdu->len);
626
627 send_len += (t_sdu->len + 3) & 0xfffc;
628 num_packet++;
629
630 if (tx->avail_count > 10)
631 t_sdu->callback(t_sdu->cb_data);
632
633 spin_lock_irqsave(&tx->lock, flags);
634 put_tx_struct(tx, t_sdu);
635 spin_unlock_irqrestore(&tx->lock, flags);
636 }
637
638 multi_sdu->len = gdm_cpu_to_dev16(&udev->gdm_ed, send_len);
639 multi_sdu->num_packet = gdm_cpu_to_dev16(&udev->gdm_ed, num_packet);
640
641 return send_len + offsetof(struct multi_sdu, data);
642}
643
644static void do_tx(struct work_struct *work)
645{
646 struct lte_udev *udev =
647 container_of(work, struct lte_udev, work_tx.work);
648 struct usb_device *usbdev = udev->usbdev;
649 struct tx_cxt *tx = &udev->tx;
650 struct usb_tx *t = NULL;
651 int is_send = 0;
652 u32 len = 0;
653 unsigned long flags;
654
655 if (!usb_autopm_get_interface(udev->intf))
656 usb_autopm_put_interface(udev->intf);
657
658 if (udev->usb_state == PM_SUSPEND)
659 return;
660
661 spin_lock_irqsave(&tx->lock, flags);
662 if (!udev->send_complete) {
663 spin_unlock_irqrestore(&tx->lock, flags);
664 return;
665 }
666 udev->send_complete = 0;
667
668 if (!list_empty(&tx->hci_list)) {
669 t = list_entry(tx->hci_list.next, struct usb_tx, list);
670 list_del(&t->list);
671 len = t->len;
672 t->is_sdu = 0;
673 is_send = 1;
674 } else if (!list_empty(&tx->sdu_list)) {
675 if (udev->tx_stop) {
676 udev->send_complete = 1;
677 spin_unlock_irqrestore(&tx->lock, flags);
678 return;
679 }
680
681 t = alloc_tx_struct(TX_BUF_SIZE);
682 if (!t) {
683 spin_unlock_irqrestore(&tx->lock, flags);
684 return;
685 }
686 t->callback = NULL;
687 t->tx = tx;
688 t->is_sdu = 1;
689 is_send = 1;
690 }
691
692 if (!is_send) {
693 udev->send_complete = 1;
694 spin_unlock_irqrestore(&tx->lock, flags);
695 return;
696 }
697 spin_unlock_irqrestore(&tx->lock, flags);
698
699 if (t->is_sdu)
700 len = packet_aggregation(udev, t->buf);
701
702 if (send_tx_packet(usbdev, t, len)) {
703 pr_err("send_tx_packet failed\n");
704 t->callback = NULL;
705 gdm_usb_send_complete(t->urb);
706 }
707}
708
709#define SDU_PARAM_LEN 12
710static int gdm_usb_sdu_send(void *priv_dev, void *data, int len,
711 unsigned int dft_eps_ID, unsigned int eps_ID,
712 void (*cb)(void *data), void *cb_data,
713 int dev_idx, int nic_type)
714{
715 struct lte_udev *udev = priv_dev;
716 struct tx_cxt *tx = &udev->tx;
717 struct usb_tx_sdu *t_sdu;
718 struct sdu *sdu = NULL;
719 unsigned long flags;
720 int no_spc = 0;
721 u16 send_len;
722
723 if (!udev->usbdev) {
724 pr_err("sdu send - invalid device\n");
725 return TX_NO_DEV;
726 }
727
728 spin_lock_irqsave(&tx->lock, flags);
729 t_sdu = get_tx_sdu_struct(tx, &no_spc);
730 spin_unlock_irqrestore(&tx->lock, flags);
731
732 if (!t_sdu) {
733 pr_err("sdu send - free list empty\n");
734 return TX_NO_SPC;
735 }
736
737 sdu = (struct sdu *)t_sdu->buf;
738 sdu->cmd_evt = gdm_cpu_to_dev16(&udev->gdm_ed, LTE_TX_SDU);
739 if (nic_type == NIC_TYPE_ARP) {
740 send_len = len + SDU_PARAM_LEN;
741 memcpy(sdu->data, data, len);
742 } else {
743 send_len = len - ETH_HLEN;
744 send_len += SDU_PARAM_LEN;
745 memcpy(sdu->data, data + ETH_HLEN, len - ETH_HLEN);
746 }
747
748 sdu->len = gdm_cpu_to_dev16(&udev->gdm_ed, send_len);
749 sdu->dft_eps_ID = gdm_cpu_to_dev32(&udev->gdm_ed, dft_eps_ID);
750 sdu->bearer_ID = gdm_cpu_to_dev32(&udev->gdm_ed, eps_ID);
751 sdu->nic_type = gdm_cpu_to_dev32(&udev->gdm_ed, nic_type);
752
753 t_sdu->len = send_len + HCI_HEADER_SIZE;
754 t_sdu->callback = cb;
755 t_sdu->cb_data = cb_data;
756
757 spin_lock_irqsave(&tx->lock, flags);
758 list_add_tail(&t_sdu->list, &tx->sdu_list);
759 schedule_work(&udev->work_tx.work);
760 spin_unlock_irqrestore(&tx->lock, flags);
761
762 if (no_spc)
763 return TX_NO_BUFFER;
764
765 return 0;
766}
767
768static int gdm_usb_hci_send(void *priv_dev, void *data, int len,
769 void (*cb)(void *data), void *cb_data)
770{
771 struct lte_udev *udev = priv_dev;
772 struct tx_cxt *tx = &udev->tx;
773 struct usb_tx *t;
774 unsigned long flags;
775
776 if (!udev->usbdev) {
777 pr_err("hci send - invalid device\n");
778 return -ENODEV;
779 }
780
781 t = alloc_tx_struct(len);
782 if (!t) {
783 pr_err("hci_send - out of memory\n");
784 return -ENOMEM;
785 }
786
787 memcpy(t->buf, data, len);
788 t->callback = cb;
789 t->cb_data = cb_data;
790 t->len = len;
791 t->tx = tx;
792 t->is_sdu = 0;
793
794 spin_lock_irqsave(&tx->lock, flags);
795 list_add_tail(&t->list, &tx->hci_list);
796 schedule_work(&udev->work_tx.work);
797 spin_unlock_irqrestore(&tx->lock, flags);
798
799 return 0;
800}
801
802static struct gdm_endian *gdm_usb_get_endian(void *priv_dev)
803{
804 struct lte_udev *udev = priv_dev;
805
806 return &udev->gdm_ed;
807}
808
809static int gdm_usb_probe(struct usb_interface *intf,
810 const struct usb_device_id *id)
811{
812 int ret = 0;
813 struct phy_dev *phy_dev = NULL;
814 struct lte_udev *udev = NULL;
815 u16 idVendor, idProduct;
816 int bInterfaceNumber;
817 struct usb_device *usbdev = interface_to_usbdev(intf);
818
819 bInterfaceNumber = intf->cur_altsetting->desc.bInterfaceNumber;
820 idVendor = __le16_to_cpu(usbdev->descriptor.idVendor);
821 idProduct = __le16_to_cpu(usbdev->descriptor.idProduct);
822
823 pr_info("net vid = 0x%04x pid = 0x%04x\n", idVendor, idProduct);
824
825 if (bInterfaceNumber > NETWORK_INTERFACE) {
826 pr_info("not a network device\n");
827 return -ENODEV;
828 }
829
830 phy_dev = kzalloc(sizeof(*phy_dev), GFP_KERNEL);
831 if (!phy_dev)
832 return -ENOMEM;
833
834 udev = kzalloc(sizeof(*udev), GFP_KERNEL);
835 if (!udev) {
836 ret = -ENOMEM;
837 goto err_udev;
838 }
839
840 phy_dev->priv_dev = (void *)udev;
841 phy_dev->send_hci_func = gdm_usb_hci_send;
842 phy_dev->send_sdu_func = gdm_usb_sdu_send;
843 phy_dev->rcv_func = gdm_usb_recv;
844 phy_dev->get_endian = gdm_usb_get_endian;
845
846 udev->usbdev = usbdev;
847 ret = init_usb(udev);
848 if (ret < 0) {
849 dev_err(intf->usb_dev, "init_usb func failed\n");
850 goto err_init_usb;
851 }
852 udev->intf = intf;
853
854 intf->needs_remote_wakeup = 1;
855 usb_enable_autosuspend(usbdev);
856 pm_runtime_set_autosuspend_delay(&usbdev->dev, AUTO_SUSPEND_TIMER);
857
858
859
860
861 if (idProduct == PID_GDM7243)
862 gdm_set_endian(&udev->gdm_ed, ENDIANNESS_BIG);
863 else
864 gdm_set_endian(&udev->gdm_ed, ENDIANNESS_LITTLE);
865
866 ret = request_mac_address(udev);
867 if (ret < 0) {
868 dev_err(intf->usb_dev, "request Mac address failed\n");
869 goto err_mac_address;
870 }
871
872 start_rx_proc(phy_dev);
873 usb_get_dev(usbdev);
874 usb_set_intfdata(intf, phy_dev);
875
876 return 0;
877
878err_mac_address:
879 release_usb(udev);
880err_init_usb:
881 kfree(udev);
882err_udev:
883 kfree(phy_dev);
884
885 return ret;
886}
887
888static void gdm_usb_disconnect(struct usb_interface *intf)
889{
890 struct phy_dev *phy_dev;
891 struct lte_udev *udev;
892 u16 idVendor, idProduct;
893 struct usb_device *usbdev;
894
895 usbdev = interface_to_usbdev(intf);
896
897 idVendor = __le16_to_cpu(usbdev->descriptor.idVendor);
898 idProduct = __le16_to_cpu(usbdev->descriptor.idProduct);
899
900 phy_dev = usb_get_intfdata(intf);
901
902 udev = phy_dev->priv_dev;
903 unregister_lte_device(phy_dev);
904
905 release_usb(udev);
906
907 kfree(udev);
908 udev = NULL;
909
910 kfree(phy_dev);
911 phy_dev = NULL;
912
913 usb_put_dev(usbdev);
914}
915
916static int gdm_usb_suspend(struct usb_interface *intf, pm_message_t pm_msg)
917{
918 struct phy_dev *phy_dev;
919 struct lte_udev *udev;
920 struct rx_cxt *rx;
921 struct usb_rx *r;
922 struct usb_rx *r_next;
923 unsigned long flags;
924
925 phy_dev = usb_get_intfdata(intf);
926 udev = phy_dev->priv_dev;
927 rx = &udev->rx;
928 if (udev->usb_state != PM_NORMAL) {
929 dev_err(intf->usb_dev, "usb suspend - invalid state\n");
930 return -1;
931 }
932
933 udev->usb_state = PM_SUSPEND;
934
935 spin_lock_irqsave(&rx->submit_lock, flags);
936 list_for_each_entry_safe(r, r_next, &rx->rx_submit_list,
937 rx_submit_list) {
938 spin_unlock_irqrestore(&rx->submit_lock, flags);
939 usb_kill_urb(r->urb);
940 spin_lock_irqsave(&rx->submit_lock, flags);
941 }
942 spin_unlock_irqrestore(&rx->submit_lock, flags);
943
944 cancel_work_sync(&udev->work_tx.work);
945 cancel_work_sync(&udev->work_rx.work);
946
947 return 0;
948}
949
950static int gdm_usb_resume(struct usb_interface *intf)
951{
952 struct phy_dev *phy_dev;
953 struct lte_udev *udev;
954 struct tx_cxt *tx;
955 struct rx_cxt *rx;
956 unsigned long flags;
957 int issue_count;
958 int i;
959
960 phy_dev = usb_get_intfdata(intf);
961 udev = phy_dev->priv_dev;
962 rx = &udev->rx;
963
964 if (udev->usb_state != PM_SUSPEND) {
965 dev_err(intf->usb_dev, "usb resume - invalid state\n");
966 return -1;
967 }
968 udev->usb_state = PM_NORMAL;
969
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);
973
974 if (issue_count >= 0) {
975 for (i = 0; i < issue_count; i++)
976 gdm_usb_recv(phy_dev->priv_dev,
977 udev->rx_cb,
978 phy_dev,
979 USB_COMPLETE);
980 }
981
982 tx = &udev->tx;
983 spin_lock_irqsave(&tx->lock, flags);
984 schedule_work(&udev->work_tx.work);
985 spin_unlock_irqrestore(&tx->lock, flags);
986
987 return 0;
988}
989
990static struct usb_driver gdm_usb_lte_driver = {
991 .name = "gdm_lte",
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,
999};
1000
1001static int __init gdm_usb_lte_init(void)
1002{
1003 if (gdm_lte_event_init() < 0) {
1004 pr_err("error creating event\n");
1005 return -1;
1006 }
1007
1008 return usb_register(&gdm_usb_lte_driver);
1009}
1010
1011static void __exit gdm_usb_lte_exit(void)
1012{
1013 gdm_lte_event_exit();
1014
1015 usb_deregister(&gdm_usb_lte_driver);
1016}
1017
1018module_init(gdm_usb_lte_init);
1019module_exit(gdm_usb_lte_exit);
1020
1021MODULE_VERSION(DRIVER_VERSION);
1022MODULE_DESCRIPTION("GCT LTE USB Device Driver");
1023MODULE_LICENSE("GPL");
1024
