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, int (*cb)(void *data, int len,
282 int tty_index, struct tty_dev *tty_dev, int complete))
284 struct mux_dev *mux_dev = priv_dev;
285 struct usb_device *usbdev = mux_dev->usbdev;
287 struct rx_cxt *rx = &mux_dev->rx;
292 pr_err("device is disconnected\n");
296 r = get_rx_struct(rx);
298 pr_err("get_rx_struct fail\n");
303 r->mux_dev = (void *)mux_dev;
307 usb_fill_bulk_urb(r->urb,
309 usb_rcvbulkpipe(usbdev, 0x86),
312 gdm_mux_rcv_complete,
315 spin_lock_irqsave(&rx->submit_list_lock, flags);
316 list_add_tail(&r->rx_submit_list, &rx->rx_submit_list);
317 spin_unlock_irqrestore(&rx->submit_list_lock, flags);
319 ret = usb_submit_urb(r->urb, GFP_KERNEL);
322 spin_lock_irqsave(&rx->submit_list_lock, flags);
323 list_del(&r->rx_submit_list);
324 spin_unlock_irqrestore(&rx->submit_list_lock, flags);
326 put_rx_struct(rx, r);
328 pr_err("usb_submit_urb ret=%d\n", ret);
331 usb_mark_last_busy(usbdev);
336 static void gdm_mux_send_complete(struct urb *urb)
338 struct mux_tx *t = urb->context;
340 if (urb->status == -ECONNRESET) {
341 dev_info(&urb->dev->dev, "CONNRESET\n");
347 t->callback(t->cb_data);
352 static int gdm_mux_send(void *priv_dev, void *data, int len, int tty_index,
353 void (*cb)(void *data), void *cb_data)
355 struct mux_dev *mux_dev = priv_dev;
356 struct usb_device *usbdev = mux_dev->usbdev;
357 struct mux_pkt_header *mux_header;
358 struct mux_tx *t = NULL;
359 static u32 seq_num = 1;
364 if (mux_dev->usb_state == PM_SUSPEND) {
365 ret = usb_autopm_get_interface(mux_dev->intf);
367 usb_autopm_put_interface(mux_dev->intf);
370 spin_lock_irqsave(&mux_dev->write_lock, flags);
372 total_len = ALIGN(MUX_HEADER_SIZE + len, 4);
374 t = alloc_mux_tx(total_len);
376 pr_err("alloc_mux_tx fail\n");
377 spin_unlock_irqrestore(&mux_dev->write_lock, flags);
381 mux_header = (struct mux_pkt_header *)t->buf;
382 mux_header->start_flag = __cpu_to_le32(START_FLAG);
383 mux_header->seq_num = __cpu_to_le32(seq_num++);
384 mux_header->payload_size = __cpu_to_le32((u32)len);
385 mux_header->packet_type = __cpu_to_le16(packet_type[tty_index]);
387 memcpy(t->buf + MUX_HEADER_SIZE, data, len);
388 memset(t->buf + MUX_HEADER_SIZE + len, 0, total_len - MUX_HEADER_SIZE -
393 t->cb_data = cb_data;
395 usb_fill_bulk_urb(t->urb,
397 usb_sndbulkpipe(usbdev, 5),
400 gdm_mux_send_complete,
403 ret = usb_submit_urb(t->urb, GFP_ATOMIC);
405 spin_unlock_irqrestore(&mux_dev->write_lock, flags);
408 pr_err("usb_submit_urb Error: %d\n", ret);
410 usb_mark_last_busy(usbdev);
415 static int gdm_mux_send_control(void *priv_dev, int request, int value,
418 struct mux_dev *mux_dev = priv_dev;
419 struct usb_device *usbdev = mux_dev->usbdev;
422 ret = usb_control_msg(usbdev,
423 usb_sndctrlpipe(usbdev, 0),
434 pr_err("usb_control_msg error: %d\n", ret);
439 static void release_usb(struct mux_dev *mux_dev)
441 struct rx_cxt *rx = &mux_dev->rx;
442 struct mux_rx *r, *r_next;
445 cancel_delayed_work(&mux_dev->work_rx);
447 spin_lock_irqsave(&rx->submit_list_lock, flags);
448 list_for_each_entry_safe(r, r_next, &rx->rx_submit_list,
450 spin_unlock_irqrestore(&rx->submit_list_lock, flags);
451 usb_kill_urb(r->urb);
452 spin_lock_irqsave(&rx->submit_list_lock, flags);
454 spin_unlock_irqrestore(&rx->submit_list_lock, flags);
456 spin_lock_irqsave(&rx->free_list_lock, flags);
457 list_for_each_entry_safe(r, r_next, &rx->rx_free_list, free_list) {
458 list_del(&r->free_list);
461 spin_unlock_irqrestore(&rx->free_list_lock, flags);
463 spin_lock_irqsave(&rx->to_host_lock, flags);
464 list_for_each_entry_safe(r, r_next, &rx->to_host_list, to_host_list) {
465 if (r->mux_dev == (void *)mux_dev) {
466 list_del(&r->to_host_list);
470 spin_unlock_irqrestore(&rx->to_host_lock, flags);
473 static int init_usb(struct mux_dev *mux_dev)
476 struct rx_cxt *rx = &mux_dev->rx;
480 spin_lock_init(&mux_dev->write_lock);
481 INIT_LIST_HEAD(&rx->to_host_list);
482 INIT_LIST_HEAD(&rx->rx_submit_list);
483 INIT_LIST_HEAD(&rx->rx_free_list);
484 spin_lock_init(&rx->to_host_lock);
485 spin_lock_init(&rx->submit_list_lock);
486 spin_lock_init(&rx->free_list_lock);
488 for (i = 0; i < MAX_ISSUE_NUM * 2; i++) {
495 list_add(&r->free_list, &rx->rx_free_list);
498 INIT_DELAYED_WORK(&mux_dev->work_rx, do_rx);
503 static int gdm_mux_probe(struct usb_interface *intf,
504 const struct usb_device_id *id)
506 struct mux_dev *mux_dev;
507 struct tty_dev *tty_dev;
508 u16 idVendor, idProduct;
509 int bInterfaceNumber;
512 struct usb_device *usbdev = interface_to_usbdev(intf);
514 bInterfaceNumber = intf->cur_altsetting->desc.bInterfaceNumber;
516 idVendor = __le16_to_cpu(usbdev->descriptor.idVendor);
517 idProduct = __le16_to_cpu(usbdev->descriptor.idProduct);
519 pr_info("mux vid = 0x%04x pid = 0x%04x\n", idVendor, idProduct);
521 if (bInterfaceNumber != 2)
524 mux_dev = kzalloc(sizeof(*mux_dev), GFP_KERNEL);
528 tty_dev = kzalloc(sizeof(*tty_dev), GFP_KERNEL);
534 mux_dev->usbdev = usbdev;
535 mux_dev->control_intf = intf;
537 ret = init_usb(mux_dev);
541 tty_dev->priv_dev = (void *)mux_dev;
542 tty_dev->send_func = gdm_mux_send;
543 tty_dev->recv_func = gdm_mux_recv;
544 tty_dev->send_control = gdm_mux_send_control;
546 ret = register_lte_tty_device(tty_dev, &intf->dev);
548 goto err_unregister_tty;
550 for (i = 0; i < TTY_MAX_COUNT; i++)
551 mux_dev->tty_dev = tty_dev;
553 mux_dev->intf = intf;
554 mux_dev->usb_state = PM_NORMAL;
557 usb_set_intfdata(intf, tty_dev);
562 unregister_lte_tty_device(tty_dev);
564 release_usb(mux_dev);
572 static void gdm_mux_disconnect(struct usb_interface *intf)
574 struct tty_dev *tty_dev;
575 struct mux_dev *mux_dev;
576 struct usb_device *usbdev = interface_to_usbdev(intf);
578 tty_dev = usb_get_intfdata(intf);
580 mux_dev = tty_dev->priv_dev;
582 release_usb(mux_dev);
583 unregister_lte_tty_device(tty_dev);
591 static int gdm_mux_suspend(struct usb_interface *intf, pm_message_t pm_msg)
593 struct tty_dev *tty_dev;
594 struct mux_dev *mux_dev;
596 struct mux_rx *r, *r_next;
599 tty_dev = usb_get_intfdata(intf);
600 mux_dev = tty_dev->priv_dev;
603 cancel_work_sync(&mux_dev->work_rx.work);
605 if (mux_dev->usb_state != PM_NORMAL) {
606 dev_err(intf->usb_dev, "usb suspend - invalid state\n");
610 mux_dev->usb_state = PM_SUSPEND;
612 spin_lock_irqsave(&rx->submit_list_lock, flags);
613 list_for_each_entry_safe(r, r_next, &rx->rx_submit_list,
615 spin_unlock_irqrestore(&rx->submit_list_lock, flags);
616 usb_kill_urb(r->urb);
617 spin_lock_irqsave(&rx->submit_list_lock, flags);
619 spin_unlock_irqrestore(&rx->submit_list_lock, flags);
624 static int gdm_mux_resume(struct usb_interface *intf)
626 struct tty_dev *tty_dev;
627 struct mux_dev *mux_dev;
630 tty_dev = usb_get_intfdata(intf);
631 mux_dev = tty_dev->priv_dev;
633 if (mux_dev->usb_state != PM_SUSPEND) {
634 dev_err(intf->usb_dev, "usb resume - invalid state\n");
638 mux_dev->usb_state = PM_NORMAL;
640 for (i = 0; i < MAX_ISSUE_NUM; i++)
641 gdm_mux_recv(mux_dev, mux_dev->rx_cb);
646 static struct usb_driver gdm_mux_driver = {
648 .probe = gdm_mux_probe,
649 .disconnect = gdm_mux_disconnect,
650 .id_table = id_table,
651 .supports_autosuspend = 1,
652 .suspend = gdm_mux_suspend,
653 .resume = gdm_mux_resume,
654 .reset_resume = gdm_mux_resume,
657 static int __init gdm_usb_mux_init(void)
659 register_lte_tty_driver();
661 return usb_register(&gdm_mux_driver);
664 static void __exit gdm_usb_mux_exit(void)
666 unregister_lte_tty_driver();
668 usb_deregister(&gdm_mux_driver);
671 module_init(gdm_usb_mux_init);
672 module_exit(gdm_usb_mux_exit);
674 MODULE_DESCRIPTION("GCT LTE TTY Device Driver");
675 MODULE_LICENSE("GPL");