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/errno.h>
20 #include <linux/init.h>
21 #include <linux/tty.h>
22 #include <linux/tty_driver.h>
23 #include <linux/tty_flip.h>
24 #include <linux/slab.h>
25 #include <linux/usb/cdc.h>
29 static u16 packet_type
[TTY_MAX_COUNT
] = {0xF011, 0xF010};
31 #define USB_DEVICE_CDC_DATA(vid, pid) \
33 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_ACM
41 static const struct usb_device_id id_table
[] = {
42 { USB_DEVICE_CDC_DATA(0x1076, 0x8000) }, /* GCT GDM7240 */
43 { USB_DEVICE_CDC_DATA(0x1076, 0x8f00) }, /* GCT GDM7243 */
44 { USB_DEVICE_CDC_DATA(0x1076, 0x9000) }, /* GCT GDM7243 */
45 { USB_DEVICE_CDC_DATA(0x1d74, 0x2300) }, /* LGIT Phoenix */
49 MODULE_DEVICE_TABLE(usb
, id_table
);
51 static int packet_type_to_index(u16 packetType
)
55 for (i
= 0; i
< TTY_MAX_COUNT
; i
++) {
56 if (packet_type
[i
] == packetType
)
63 static struct mux_tx
*alloc_mux_tx(int len
)
65 struct mux_tx
*t
= NULL
;
67 t
= kzalloc(sizeof(*t
), GFP_ATOMIC
);
71 t
->urb
= usb_alloc_urb(0, GFP_ATOMIC
);
72 t
->buf
= kmalloc(MUX_TX_MAX_SIZE
, GFP_ATOMIC
);
73 if (!t
->urb
|| !t
->buf
) {
83 static void free_mux_tx(struct mux_tx
*t
)
92 static struct mux_rx
*alloc_mux_rx(void)
94 struct mux_rx
*r
= NULL
;
96 r
= kzalloc(sizeof(*r
), GFP_KERNEL
);
100 r
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
101 r
->buf
= kmalloc(MUX_RX_MAX_SIZE
, GFP_KERNEL
);
102 if (!r
->urb
|| !r
->buf
) {
103 usb_free_urb(r
->urb
);
112 static void free_mux_rx(struct mux_rx
*r
)
115 usb_free_urb(r
->urb
);
121 static struct mux_rx
*get_rx_struct(struct rx_cxt
*rx
)
126 spin_lock_irqsave(&rx
->free_list_lock
, flags
);
128 if (list_empty(&rx
->rx_free_list
)) {
129 spin_unlock_irqrestore(&rx
->free_list_lock
, flags
);
133 r
= list_entry(rx
->rx_free_list
.prev
, struct mux_rx
, free_list
);
134 list_del(&r
->free_list
);
136 spin_unlock_irqrestore(&rx
->free_list_lock
, flags
);
141 static void put_rx_struct(struct rx_cxt
*rx
, struct mux_rx
*r
)
145 spin_lock_irqsave(&rx
->free_list_lock
, flags
);
146 list_add_tail(&r
->free_list
, &rx
->rx_free_list
);
147 spin_unlock_irqrestore(&rx
->free_list_lock
, flags
);
150 static int up_to_host(struct mux_rx
*r
)
152 struct mux_dev
*mux_dev
= r
->mux_dev
;
153 struct mux_pkt_header
*mux_header
;
154 unsigned int start_flag
;
155 unsigned int payload_size
;
156 unsigned short packet_type
;
158 u32 packet_size_sum
= r
->offset
;
160 int ret
= TO_HOST_INVALID_PACKET
;
164 mux_header
= (struct mux_pkt_header
*)(r
->buf
+
166 start_flag
= __le32_to_cpu(mux_header
->start_flag
);
167 payload_size
= __le32_to_cpu(mux_header
->payload_size
);
168 packet_type
= __le16_to_cpu(mux_header
->packet_type
);
170 if (start_flag
!= START_FLAG
) {
171 pr_err("invalid START_FLAG %x\n", start_flag
);
175 total_len
= ALIGN(MUX_HEADER_SIZE
+ payload_size
, 4);
177 if (len
- packet_size_sum
<
179 pr_err("invalid payload : %d %d %04x\n",
180 payload_size
, len
, packet_type
);
184 index
= packet_type_to_index(packet_type
);
186 pr_err("invalid index %d\n", index
);
190 ret
= r
->callback(mux_header
->data
,
194 RECV_PACKET_PROCESS_CONTINUE
196 if (ret
== TO_HOST_BUFFER_REQUEST_FAIL
) {
197 r
->offset
+= packet_size_sum
;
201 packet_size_sum
+= total_len
;
202 if (len
- packet_size_sum
<= MUX_HEADER_SIZE
+ 2) {
203 ret
= r
->callback(NULL
,
207 RECV_PACKET_PROCESS_COMPLETE
216 static void do_rx(struct work_struct
*work
)
218 struct mux_dev
*mux_dev
=
219 container_of(work
, struct mux_dev
, work_rx
.work
);
221 struct rx_cxt
*rx
= &mux_dev
->rx
;
226 spin_lock_irqsave(&rx
->to_host_lock
, flags
);
227 if (list_empty(&rx
->to_host_list
)) {
228 spin_unlock_irqrestore(&rx
->to_host_lock
, flags
);
231 r
= list_entry(rx
->to_host_list
.next
, struct mux_rx
,
233 list_del(&r
->to_host_list
);
234 spin_unlock_irqrestore(&rx
->to_host_lock
, flags
);
237 if (ret
== TO_HOST_BUFFER_REQUEST_FAIL
)
238 pr_err("failed to send mux data to host\n");
240 put_rx_struct(rx
, r
);
244 static void remove_rx_submit_list(struct mux_rx
*r
, struct rx_cxt
*rx
)
247 struct mux_rx
*r_remove
, *r_remove_next
;
249 spin_lock_irqsave(&rx
->submit_list_lock
, flags
);
250 list_for_each_entry_safe(r_remove
, r_remove_next
, &rx
->rx_submit_list
,
253 list_del(&r
->rx_submit_list
);
255 spin_unlock_irqrestore(&rx
->submit_list_lock
, flags
);
258 static void gdm_mux_rcv_complete(struct urb
*urb
)
260 struct mux_rx
*r
= urb
->context
;
261 struct mux_dev
*mux_dev
= r
->mux_dev
;
262 struct rx_cxt
*rx
= &mux_dev
->rx
;
265 remove_rx_submit_list(r
, rx
);
268 if (mux_dev
->usb_state
== PM_NORMAL
)
269 dev_err(&urb
->dev
->dev
, "%s: urb status error %d\n",
270 __func__
, urb
->status
);
271 put_rx_struct(rx
, r
);
273 r
->len
= r
->urb
->actual_length
;
274 spin_lock_irqsave(&rx
->to_host_lock
, flags
);
275 list_add_tail(&r
->to_host_list
, &rx
->to_host_list
);
276 schedule_work(&mux_dev
->work_rx
.work
);
277 spin_unlock_irqrestore(&rx
->to_host_lock
, flags
);
281 static int gdm_mux_recv(void *priv_dev
,
282 int (*cb
)(void *data
, int len
, int tty_index
,
283 struct tty_dev
*tty_dev
, int complete
))
285 struct mux_dev
*mux_dev
= priv_dev
;
286 struct usb_device
*usbdev
= mux_dev
->usbdev
;
288 struct rx_cxt
*rx
= &mux_dev
->rx
;
293 pr_err("device is disconnected\n");
297 r
= get_rx_struct(rx
);
299 pr_err("get_rx_struct fail\n");
304 r
->mux_dev
= (void *)mux_dev
;
308 usb_fill_bulk_urb(r
->urb
,
310 usb_rcvbulkpipe(usbdev
, 0x86),
313 gdm_mux_rcv_complete
,
316 spin_lock_irqsave(&rx
->submit_list_lock
, flags
);
317 list_add_tail(&r
->rx_submit_list
, &rx
->rx_submit_list
);
318 spin_unlock_irqrestore(&rx
->submit_list_lock
, flags
);
320 ret
= usb_submit_urb(r
->urb
, GFP_KERNEL
);
323 spin_lock_irqsave(&rx
->submit_list_lock
, flags
);
324 list_del(&r
->rx_submit_list
);
325 spin_unlock_irqrestore(&rx
->submit_list_lock
, flags
);
327 put_rx_struct(rx
, r
);
329 pr_err("usb_submit_urb ret=%d\n", ret
);
332 usb_mark_last_busy(usbdev
);
337 static void gdm_mux_send_complete(struct urb
*urb
)
339 struct mux_tx
*t
= urb
->context
;
341 if (urb
->status
== -ECONNRESET
) {
342 dev_info(&urb
->dev
->dev
, "CONNRESET\n");
348 t
->callback(t
->cb_data
);
353 static int gdm_mux_send(void *priv_dev
, void *data
, int len
, int tty_index
,
354 void (*cb
)(void *data
), void *cb_data
)
356 struct mux_dev
*mux_dev
= priv_dev
;
357 struct usb_device
*usbdev
= mux_dev
->usbdev
;
358 struct mux_pkt_header
*mux_header
;
359 struct mux_tx
*t
= NULL
;
360 static u32 seq_num
= 1;
365 if (mux_dev
->usb_state
== PM_SUSPEND
) {
366 ret
= usb_autopm_get_interface(mux_dev
->intf
);
368 usb_autopm_put_interface(mux_dev
->intf
);
371 spin_lock_irqsave(&mux_dev
->write_lock
, flags
);
373 total_len
= ALIGN(MUX_HEADER_SIZE
+ len
, 4);
375 t
= alloc_mux_tx(total_len
);
377 pr_err("alloc_mux_tx fail\n");
378 spin_unlock_irqrestore(&mux_dev
->write_lock
, flags
);
382 mux_header
= (struct mux_pkt_header
*)t
->buf
;
383 mux_header
->start_flag
= __cpu_to_le32(START_FLAG
);
384 mux_header
->seq_num
= __cpu_to_le32(seq_num
++);
385 mux_header
->payload_size
= __cpu_to_le32((u32
)len
);
386 mux_header
->packet_type
= __cpu_to_le16(packet_type
[tty_index
]);
388 memcpy(t
->buf
+ MUX_HEADER_SIZE
, data
, len
);
389 memset(t
->buf
+ MUX_HEADER_SIZE
+ len
, 0, total_len
- MUX_HEADER_SIZE
-
394 t
->cb_data
= cb_data
;
396 usb_fill_bulk_urb(t
->urb
,
398 usb_sndbulkpipe(usbdev
, 5),
401 gdm_mux_send_complete
,
404 ret
= usb_submit_urb(t
->urb
, GFP_ATOMIC
);
406 spin_unlock_irqrestore(&mux_dev
->write_lock
, flags
);
409 pr_err("usb_submit_urb Error: %d\n", ret
);
411 usb_mark_last_busy(usbdev
);
416 static int gdm_mux_send_control(void *priv_dev
, int request
, int value
,
419 struct mux_dev
*mux_dev
= priv_dev
;
420 struct usb_device
*usbdev
= mux_dev
->usbdev
;
423 ret
= usb_control_msg(usbdev
,
424 usb_sndctrlpipe(usbdev
, 0),
435 pr_err("usb_control_msg error: %d\n", ret
);
440 static void release_usb(struct mux_dev
*mux_dev
)
442 struct rx_cxt
*rx
= &mux_dev
->rx
;
443 struct mux_rx
*r
, *r_next
;
446 cancel_delayed_work(&mux_dev
->work_rx
);
448 spin_lock_irqsave(&rx
->submit_list_lock
, flags
);
449 list_for_each_entry_safe(r
, r_next
, &rx
->rx_submit_list
,
451 spin_unlock_irqrestore(&rx
->submit_list_lock
, flags
);
452 usb_kill_urb(r
->urb
);
453 spin_lock_irqsave(&rx
->submit_list_lock
, flags
);
455 spin_unlock_irqrestore(&rx
->submit_list_lock
, flags
);
457 spin_lock_irqsave(&rx
->free_list_lock
, flags
);
458 list_for_each_entry_safe(r
, r_next
, &rx
->rx_free_list
, free_list
) {
459 list_del(&r
->free_list
);
462 spin_unlock_irqrestore(&rx
->free_list_lock
, flags
);
464 spin_lock_irqsave(&rx
->to_host_lock
, flags
);
465 list_for_each_entry_safe(r
, r_next
, &rx
->to_host_list
, to_host_list
) {
466 if (r
->mux_dev
== (void *)mux_dev
) {
467 list_del(&r
->to_host_list
);
471 spin_unlock_irqrestore(&rx
->to_host_lock
, flags
);
474 static int init_usb(struct mux_dev
*mux_dev
)
477 struct rx_cxt
*rx
= &mux_dev
->rx
;
481 spin_lock_init(&mux_dev
->write_lock
);
482 INIT_LIST_HEAD(&rx
->to_host_list
);
483 INIT_LIST_HEAD(&rx
->rx_submit_list
);
484 INIT_LIST_HEAD(&rx
->rx_free_list
);
485 spin_lock_init(&rx
->to_host_lock
);
486 spin_lock_init(&rx
->submit_list_lock
);
487 spin_lock_init(&rx
->free_list_lock
);
489 for (i
= 0; i
< MAX_ISSUE_NUM
* 2; i
++) {
496 list_add(&r
->free_list
, &rx
->rx_free_list
);
499 INIT_DELAYED_WORK(&mux_dev
->work_rx
, do_rx
);
504 static int gdm_mux_probe(struct usb_interface
*intf
,
505 const struct usb_device_id
*id
)
507 struct mux_dev
*mux_dev
;
508 struct tty_dev
*tty_dev
;
509 u16 idVendor
, idProduct
;
510 int bInterfaceNumber
;
513 struct usb_device
*usbdev
= interface_to_usbdev(intf
);
515 bInterfaceNumber
= intf
->cur_altsetting
->desc
.bInterfaceNumber
;
517 idVendor
= __le16_to_cpu(usbdev
->descriptor
.idVendor
);
518 idProduct
= __le16_to_cpu(usbdev
->descriptor
.idProduct
);
520 pr_info("mux vid = 0x%04x pid = 0x%04x\n", idVendor
, idProduct
);
522 if (bInterfaceNumber
!= 2)
525 mux_dev
= kzalloc(sizeof(*mux_dev
), GFP_KERNEL
);
529 tty_dev
= kzalloc(sizeof(*tty_dev
), GFP_KERNEL
);
535 mux_dev
->usbdev
= usbdev
;
536 mux_dev
->control_intf
= intf
;
538 ret
= init_usb(mux_dev
);
542 tty_dev
->priv_dev
= (void *)mux_dev
;
543 tty_dev
->send_func
= gdm_mux_send
;
544 tty_dev
->recv_func
= gdm_mux_recv
;
545 tty_dev
->send_control
= gdm_mux_send_control
;
547 ret
= register_lte_tty_device(tty_dev
, &intf
->dev
);
549 goto err_unregister_tty
;
551 for (i
= 0; i
< TTY_MAX_COUNT
; i
++)
552 mux_dev
->tty_dev
= tty_dev
;
554 mux_dev
->intf
= intf
;
555 mux_dev
->usb_state
= PM_NORMAL
;
558 usb_set_intfdata(intf
, tty_dev
);
563 unregister_lte_tty_device(tty_dev
);
565 release_usb(mux_dev
);
573 static void gdm_mux_disconnect(struct usb_interface
*intf
)
575 struct tty_dev
*tty_dev
;
576 struct mux_dev
*mux_dev
;
577 struct usb_device
*usbdev
= interface_to_usbdev(intf
);
579 tty_dev
= usb_get_intfdata(intf
);
581 mux_dev
= tty_dev
->priv_dev
;
583 release_usb(mux_dev
);
584 unregister_lte_tty_device(tty_dev
);
592 static int gdm_mux_suspend(struct usb_interface
*intf
, pm_message_t pm_msg
)
594 struct tty_dev
*tty_dev
;
595 struct mux_dev
*mux_dev
;
597 struct mux_rx
*r
, *r_next
;
600 tty_dev
= usb_get_intfdata(intf
);
601 mux_dev
= tty_dev
->priv_dev
;
604 cancel_work_sync(&mux_dev
->work_rx
.work
);
606 if (mux_dev
->usb_state
!= PM_NORMAL
) {
607 dev_err(intf
->usb_dev
, "usb suspend - invalid state\n");
611 mux_dev
->usb_state
= PM_SUSPEND
;
613 spin_lock_irqsave(&rx
->submit_list_lock
, flags
);
614 list_for_each_entry_safe(r
, r_next
, &rx
->rx_submit_list
,
616 spin_unlock_irqrestore(&rx
->submit_list_lock
, flags
);
617 usb_kill_urb(r
->urb
);
618 spin_lock_irqsave(&rx
->submit_list_lock
, flags
);
620 spin_unlock_irqrestore(&rx
->submit_list_lock
, flags
);
625 static int gdm_mux_resume(struct usb_interface
*intf
)
627 struct tty_dev
*tty_dev
;
628 struct mux_dev
*mux_dev
;
631 tty_dev
= usb_get_intfdata(intf
);
632 mux_dev
= tty_dev
->priv_dev
;
634 if (mux_dev
->usb_state
!= PM_SUSPEND
) {
635 dev_err(intf
->usb_dev
, "usb resume - invalid state\n");
639 mux_dev
->usb_state
= PM_NORMAL
;
641 for (i
= 0; i
< MAX_ISSUE_NUM
; i
++)
642 gdm_mux_recv(mux_dev
, mux_dev
->rx_cb
);
647 static struct usb_driver gdm_mux_driver
= {
649 .probe
= gdm_mux_probe
,
650 .disconnect
= gdm_mux_disconnect
,
651 .id_table
= id_table
,
652 .supports_autosuspend
= 1,
653 .suspend
= gdm_mux_suspend
,
654 .resume
= gdm_mux_resume
,
655 .reset_resume
= gdm_mux_resume
,
658 static int __init
gdm_usb_mux_init(void)
660 register_lte_tty_driver();
662 return usb_register(&gdm_mux_driver
);
665 static void __exit
gdm_usb_mux_exit(void)
667 unregister_lte_tty_driver();
669 usb_deregister(&gdm_mux_driver
);
672 module_init(gdm_usb_mux_init
);
673 module_exit(gdm_usb_mux_exit
);
675 MODULE_DESCRIPTION("GCT LTE TTY Device Driver");
676 MODULE_LICENSE("GPL");