1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved. */
4 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
6 #include <linux/module.h>
7 #include <linux/kernel.h>
9 #include <linux/errno.h>
10 #include <linux/init.h>
11 #include <linux/tty.h>
12 #include <linux/tty_driver.h>
13 #include <linux/tty_flip.h>
14 #include <linux/slab.h>
15 #include <linux/usb/cdc.h>
19 static u16 packet_type_for_tty_index[TTY_MAX_COUNT] = {0xF011, 0xF010};
21 #define USB_DEVICE_CDC_DATA(vid, pid) \
23 USB_DEVICE_ID_MATCH_DEVICE |\
24 USB_DEVICE_ID_MATCH_INT_CLASS |\
25 USB_DEVICE_ID_MATCH_INT_SUBCLASS,\
28 .bInterfaceClass = USB_CLASS_COMM,\
29 .bInterfaceSubClass = USB_CDC_SUBCLASS_ACM
31 static const struct usb_device_id id_table[] = {
32 { USB_DEVICE_CDC_DATA(0x1076, 0x8000) }, /* GCT GDM7240 */
33 { USB_DEVICE_CDC_DATA(0x1076, 0x8f00) }, /* GCT GDM7243 */
34 { USB_DEVICE_CDC_DATA(0x1076, 0x9000) }, /* GCT GDM7243 */
35 { USB_DEVICE_CDC_DATA(0x1d74, 0x2300) }, /* LGIT Phoenix */
39 MODULE_DEVICE_TABLE(usb, id_table);
41 static int packet_type_to_tty_index(u16 packet_type)
45 for (i = 0; i < TTY_MAX_COUNT; i++) {
46 if (packet_type_for_tty_index[i] == packet_type)
53 static struct mux_tx *alloc_mux_tx(int len)
57 t = kzalloc(sizeof(*t), GFP_ATOMIC);
61 t->urb = usb_alloc_urb(0, GFP_ATOMIC);
62 t->buf = kmalloc(MUX_TX_MAX_SIZE, GFP_ATOMIC);
63 if (!t->urb || !t->buf) {
73 static void free_mux_tx(struct mux_tx *t)
82 static struct mux_rx *alloc_mux_rx(void)
86 r = kzalloc(sizeof(*r), GFP_KERNEL);
90 r->urb = usb_alloc_urb(0, GFP_KERNEL);
91 r->buf = kmalloc(MUX_RX_MAX_SIZE, GFP_KERNEL);
92 if (!r->urb || !r->buf) {
102 static void free_mux_rx(struct mux_rx *r)
105 usb_free_urb(r->urb);
111 static struct mux_rx *get_rx_struct(struct rx_cxt *rx)
116 spin_lock_irqsave(&rx->free_list_lock, flags);
118 if (list_empty(&rx->rx_free_list)) {
119 spin_unlock_irqrestore(&rx->free_list_lock, flags);
123 r = list_entry(rx->rx_free_list.prev, struct mux_rx, free_list);
124 list_del(&r->free_list);
126 spin_unlock_irqrestore(&rx->free_list_lock, flags);
131 static void put_rx_struct(struct rx_cxt *rx, struct mux_rx *r)
135 spin_lock_irqsave(&rx->free_list_lock, flags);
136 list_add_tail(&r->free_list, &rx->rx_free_list);
137 spin_unlock_irqrestore(&rx->free_list_lock, flags);
140 static int up_to_host(struct mux_rx *r)
142 struct mux_dev *mux_dev = r->mux_dev;
143 struct mux_pkt_header *mux_header;
144 unsigned int start_flag;
145 unsigned int payload_size;
146 unsigned short packet_type;
148 u32 packet_size_sum = r->offset;
150 int ret = TO_HOST_INVALID_PACKET;
154 mux_header = (struct mux_pkt_header *)(r->buf +
156 start_flag = __le32_to_cpu(mux_header->start_flag);
157 payload_size = __le32_to_cpu(mux_header->payload_size);
158 packet_type = __le16_to_cpu(mux_header->packet_type);
160 if (start_flag != START_FLAG) {
161 pr_err("invalid START_FLAG %x\n", start_flag);
165 total_len = ALIGN(MUX_HEADER_SIZE + payload_size, 4);
167 if (len - packet_size_sum < total_len) {
168 pr_err("invalid payload : %d %d %04x\n",
169 payload_size, len, packet_type);
173 index = packet_type_to_tty_index(packet_type);
175 pr_err("invalid index %d\n", index);
179 ret = r->callback(mux_header->data,
183 RECV_PACKET_PROCESS_CONTINUE
185 if (ret == TO_HOST_BUFFER_REQUEST_FAIL) {
186 r->offset += packet_size_sum;
190 packet_size_sum += total_len;
191 if (len - packet_size_sum <= MUX_HEADER_SIZE + 2) {
192 ret = r->callback(NULL,
196 RECV_PACKET_PROCESS_COMPLETE
205 static void do_rx(struct work_struct *work)
207 struct mux_dev *mux_dev =
208 container_of(work, struct mux_dev, work_rx.work);
210 struct rx_cxt *rx = &mux_dev->rx;
215 spin_lock_irqsave(&rx->to_host_lock, flags);
216 if (list_empty(&rx->to_host_list)) {
217 spin_unlock_irqrestore(&rx->to_host_lock, flags);
220 r = list_entry(rx->to_host_list.next, struct mux_rx,
222 list_del(&r->to_host_list);
223 spin_unlock_irqrestore(&rx->to_host_lock, flags);
226 if (ret == TO_HOST_BUFFER_REQUEST_FAIL)
227 pr_err("failed to send mux data to host\n");
229 put_rx_struct(rx, r);
233 static void remove_rx_submit_list(struct mux_rx *r, struct rx_cxt *rx)
236 struct mux_rx *r_remove, *r_remove_next;
238 spin_lock_irqsave(&rx->submit_list_lock, flags);
239 list_for_each_entry_safe(r_remove, r_remove_next, &rx->rx_submit_list,
242 list_del(&r->rx_submit_list);
244 spin_unlock_irqrestore(&rx->submit_list_lock, flags);
247 static void gdm_mux_rcv_complete(struct urb *urb)
249 struct mux_rx *r = urb->context;
250 struct mux_dev *mux_dev = r->mux_dev;
251 struct rx_cxt *rx = &mux_dev->rx;
254 remove_rx_submit_list(r, rx);
257 if (mux_dev->usb_state == PM_NORMAL)
258 dev_err(&urb->dev->dev, "%s: urb status error %d\n",
259 __func__, urb->status);
260 put_rx_struct(rx, r);
262 r->len = r->urb->actual_length;
263 spin_lock_irqsave(&rx->to_host_lock, flags);
264 list_add_tail(&r->to_host_list, &rx->to_host_list);
265 schedule_work(&mux_dev->work_rx.work);
266 spin_unlock_irqrestore(&rx->to_host_lock, flags);
270 static int gdm_mux_recv(void *priv_dev,
271 int (*cb)(void *data, int len, int tty_index,
272 struct tty_dev *tty_dev, int complete))
274 struct mux_dev *mux_dev = priv_dev;
275 struct usb_device *usbdev = mux_dev->usbdev;
277 struct rx_cxt *rx = &mux_dev->rx;
282 pr_err("device is disconnected\n");
286 r = get_rx_struct(rx);
288 pr_err("get_rx_struct fail\n");
293 r->mux_dev = (void *)mux_dev;
297 usb_fill_bulk_urb(r->urb,
299 usb_rcvbulkpipe(usbdev, 0x86),
302 gdm_mux_rcv_complete,
305 spin_lock_irqsave(&rx->submit_list_lock, flags);
306 list_add_tail(&r->rx_submit_list, &rx->rx_submit_list);
307 spin_unlock_irqrestore(&rx->submit_list_lock, flags);
309 ret = usb_submit_urb(r->urb, GFP_KERNEL);
312 spin_lock_irqsave(&rx->submit_list_lock, flags);
313 list_del(&r->rx_submit_list);
314 spin_unlock_irqrestore(&rx->submit_list_lock, flags);
316 put_rx_struct(rx, r);
318 pr_err("usb_submit_urb ret=%d\n", ret);
321 usb_mark_last_busy(usbdev);
326 static void gdm_mux_send_complete(struct urb *urb)
328 struct mux_tx *t = urb->context;
330 if (urb->status == -ECONNRESET) {
331 dev_info(&urb->dev->dev, "CONNRESET\n");
337 t->callback(t->cb_data);
342 static int gdm_mux_send(void *priv_dev, void *data, int len, int tty_index,
343 void (*cb)(void *data), void *cb_data)
345 struct mux_dev *mux_dev = priv_dev;
346 struct usb_device *usbdev = mux_dev->usbdev;
347 struct mux_pkt_header *mux_header;
348 struct mux_tx *t = NULL;
349 static u32 seq_num = 1;
354 if (mux_dev->usb_state == PM_SUSPEND) {
355 ret = usb_autopm_get_interface(mux_dev->intf);
357 usb_autopm_put_interface(mux_dev->intf);
360 spin_lock_irqsave(&mux_dev->write_lock, flags);
362 total_len = ALIGN(MUX_HEADER_SIZE + len, 4);
364 t = alloc_mux_tx(total_len);
366 pr_err("alloc_mux_tx fail\n");
367 spin_unlock_irqrestore(&mux_dev->write_lock, flags);
371 mux_header = (struct mux_pkt_header *)t->buf;
372 mux_header->start_flag = __cpu_to_le32(START_FLAG);
373 mux_header->seq_num = __cpu_to_le32(seq_num++);
374 mux_header->payload_size = __cpu_to_le32((u32)len);
375 mux_header->packet_type = __cpu_to_le16(packet_type_for_tty_index[tty_index]);
377 memcpy(t->buf + MUX_HEADER_SIZE, data, len);
378 memset(t->buf + MUX_HEADER_SIZE + len, 0,
379 total_len - MUX_HEADER_SIZE - len);
383 t->cb_data = cb_data;
385 usb_fill_bulk_urb(t->urb,
387 usb_sndbulkpipe(usbdev, 5),
390 gdm_mux_send_complete,
393 ret = usb_submit_urb(t->urb, GFP_ATOMIC);
395 spin_unlock_irqrestore(&mux_dev->write_lock, flags);
398 pr_err("usb_submit_urb Error: %d\n", ret);
400 usb_mark_last_busy(usbdev);
405 static int gdm_mux_send_control(void *priv_dev, int request, int value,
408 struct mux_dev *mux_dev = priv_dev;
409 struct usb_device *usbdev = mux_dev->usbdev;
412 ret = usb_control_msg(usbdev,
413 usb_sndctrlpipe(usbdev, 0),
424 pr_err("usb_control_msg error: %d\n", ret);
429 static void release_usb(struct mux_dev *mux_dev)
431 struct rx_cxt *rx = &mux_dev->rx;
432 struct mux_rx *r, *r_next;
435 cancel_delayed_work(&mux_dev->work_rx);
437 spin_lock_irqsave(&rx->submit_list_lock, flags);
438 list_for_each_entry_safe(r, r_next, &rx->rx_submit_list,
440 spin_unlock_irqrestore(&rx->submit_list_lock, flags);
441 usb_kill_urb(r->urb);
442 spin_lock_irqsave(&rx->submit_list_lock, flags);
444 spin_unlock_irqrestore(&rx->submit_list_lock, flags);
446 spin_lock_irqsave(&rx->free_list_lock, flags);
447 list_for_each_entry_safe(r, r_next, &rx->rx_free_list, free_list) {
448 list_del(&r->free_list);
451 spin_unlock_irqrestore(&rx->free_list_lock, flags);
453 spin_lock_irqsave(&rx->to_host_lock, flags);
454 list_for_each_entry_safe(r, r_next, &rx->to_host_list, to_host_list) {
455 if (r->mux_dev == (void *)mux_dev) {
456 list_del(&r->to_host_list);
460 spin_unlock_irqrestore(&rx->to_host_lock, flags);
463 static int init_usb(struct mux_dev *mux_dev)
466 struct rx_cxt *rx = &mux_dev->rx;
470 spin_lock_init(&mux_dev->write_lock);
471 INIT_LIST_HEAD(&rx->to_host_list);
472 INIT_LIST_HEAD(&rx->rx_submit_list);
473 INIT_LIST_HEAD(&rx->rx_free_list);
474 spin_lock_init(&rx->to_host_lock);
475 spin_lock_init(&rx->submit_list_lock);
476 spin_lock_init(&rx->free_list_lock);
478 for (i = 0; i < MAX_ISSUE_NUM * 2; i++) {
485 list_add(&r->free_list, &rx->rx_free_list);
488 INIT_DELAYED_WORK(&mux_dev->work_rx, do_rx);
493 static int gdm_mux_probe(struct usb_interface *intf,
494 const struct usb_device_id *id)
496 struct mux_dev *mux_dev;
497 struct tty_dev *tty_dev;
498 u16 idVendor, idProduct;
499 int bInterfaceNumber;
502 struct usb_device *usbdev = interface_to_usbdev(intf);
504 bInterfaceNumber = intf->cur_altsetting->desc.bInterfaceNumber;
506 idVendor = __le16_to_cpu(usbdev->descriptor.idVendor);
507 idProduct = __le16_to_cpu(usbdev->descriptor.idProduct);
509 pr_info("mux vid = 0x%04x pid = 0x%04x\n", idVendor, idProduct);
511 if (bInterfaceNumber != 2)
514 mux_dev = kzalloc(sizeof(*mux_dev), GFP_KERNEL);
518 tty_dev = kzalloc(sizeof(*tty_dev), GFP_KERNEL);
524 mux_dev->usbdev = usbdev;
525 mux_dev->control_intf = intf;
527 ret = init_usb(mux_dev);
531 tty_dev->priv_dev = (void *)mux_dev;
532 tty_dev->send_func = gdm_mux_send;
533 tty_dev->recv_func = gdm_mux_recv;
534 tty_dev->send_control = gdm_mux_send_control;
536 ret = register_lte_tty_device(tty_dev, &intf->dev);
538 goto err_unregister_tty;
540 for (i = 0; i < TTY_MAX_COUNT; i++)
541 mux_dev->tty_dev = tty_dev;
543 mux_dev->intf = intf;
544 mux_dev->usb_state = PM_NORMAL;
547 usb_set_intfdata(intf, tty_dev);
552 unregister_lte_tty_device(tty_dev);
554 release_usb(mux_dev);
562 static void gdm_mux_disconnect(struct usb_interface *intf)
564 struct tty_dev *tty_dev;
565 struct mux_dev *mux_dev;
566 struct usb_device *usbdev = interface_to_usbdev(intf);
568 tty_dev = usb_get_intfdata(intf);
570 mux_dev = tty_dev->priv_dev;
572 release_usb(mux_dev);
573 unregister_lte_tty_device(tty_dev);
581 static int gdm_mux_suspend(struct usb_interface *intf, pm_message_t pm_msg)
583 struct tty_dev *tty_dev;
584 struct mux_dev *mux_dev;
586 struct mux_rx *r, *r_next;
589 tty_dev = usb_get_intfdata(intf);
590 mux_dev = tty_dev->priv_dev;
593 cancel_work_sync(&mux_dev->work_rx.work);
595 if (mux_dev->usb_state != PM_NORMAL) {
596 dev_err(intf->usb_dev, "usb suspend - invalid state\n");
600 mux_dev->usb_state = PM_SUSPEND;
602 spin_lock_irqsave(&rx->submit_list_lock, flags);
603 list_for_each_entry_safe(r, r_next, &rx->rx_submit_list,
605 spin_unlock_irqrestore(&rx->submit_list_lock, flags);
606 usb_kill_urb(r->urb);
607 spin_lock_irqsave(&rx->submit_list_lock, flags);
609 spin_unlock_irqrestore(&rx->submit_list_lock, flags);
614 static int gdm_mux_resume(struct usb_interface *intf)
616 struct tty_dev *tty_dev;
617 struct mux_dev *mux_dev;
620 tty_dev = usb_get_intfdata(intf);
621 mux_dev = tty_dev->priv_dev;
623 if (mux_dev->usb_state != PM_SUSPEND) {
624 dev_err(intf->usb_dev, "usb resume - invalid state\n");
628 mux_dev->usb_state = PM_NORMAL;
630 for (i = 0; i < MAX_ISSUE_NUM; i++)
631 gdm_mux_recv(mux_dev, mux_dev->rx_cb);
636 static struct usb_driver gdm_mux_driver = {
638 .probe = gdm_mux_probe,
639 .disconnect = gdm_mux_disconnect,
640 .id_table = id_table,
641 .supports_autosuspend = 1,
642 .suspend = gdm_mux_suspend,
643 .resume = gdm_mux_resume,
644 .reset_resume = gdm_mux_resume,
647 static int __init gdm_usb_mux_init(void)
651 ret = register_lte_tty_driver();
655 return usb_register(&gdm_mux_driver);
658 static void __exit gdm_usb_mux_exit(void)
660 usb_deregister(&gdm_mux_driver);
661 unregister_lte_tty_driver();
664 module_init(gdm_usb_mux_init);
665 module_exit(gdm_usb_mux_exit);
667 MODULE_DESCRIPTION("GCT LTE TTY Device Driver");
668 MODULE_LICENSE("GPL");