1 /* 2 * Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved. 3 * 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. 7 * 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. 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/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> 26 27 #include "gdm_mux.h" 28 29 static struct workqueue_struct *mux_rx_wq; 30 31 static u16 packet_type[TTY_MAX_COUNT] = {0xF011, 0xF010}; 32 33 #define USB_DEVICE_CDC_DATA(vid, pid) \ 34 .match_flags = \ 35 USB_DEVICE_ID_MATCH_DEVICE |\ 36 USB_DEVICE_ID_MATCH_INT_CLASS |\ 37 USB_DEVICE_ID_MATCH_INT_SUBCLASS,\ 38 .idVendor = vid,\ 39 .idProduct = pid,\ 40 .bInterfaceClass = USB_CLASS_COMM,\ 41 .bInterfaceSubClass = USB_CDC_SUBCLASS_ACM 42 43 static const struct usb_device_id id_table[] = { 44 { USB_DEVICE_CDC_DATA(0x1076, 0x8000) }, /* GCT GDM7240 */ 45 { USB_DEVICE_CDC_DATA(0x1076, 0x8f00) }, /* GCT GDM7243 */ 46 { USB_DEVICE_CDC_DATA(0x1076, 0x9000) }, /* GCT GDM7243 */ 47 { USB_DEVICE_CDC_DATA(0x1d74, 0x2300) }, /* LGIT Phoenix */ 48 {} 49 }; 50 51 MODULE_DEVICE_TABLE(usb, id_table); 52 53 static int packet_type_to_index(u16 packetType) 54 { 55 int i; 56 57 for (i = 0; i < TTY_MAX_COUNT; i++) { 58 if (packet_type[i] == packetType) 59 return i; 60 } 61 62 return -1; 63 } 64 65 static struct mux_tx *alloc_mux_tx(int len) 66 { 67 struct mux_tx *t = NULL; 68 69 t = kzalloc(sizeof(*t), GFP_ATOMIC); 70 if (!t) 71 return NULL; 72 73 t->urb = usb_alloc_urb(0, GFP_ATOMIC); 74 t->buf = kmalloc(MUX_TX_MAX_SIZE, GFP_ATOMIC); 75 if (!t->urb || !t->buf) { 76 usb_free_urb(t->urb); 77 kfree(t->buf); 78 kfree(t); 79 return NULL; 80 } 81 82 return t; 83 } 84 85 static void free_mux_tx(struct mux_tx *t) 86 { 87 if (t) { 88 usb_free_urb(t->urb); 89 kfree(t->buf); 90 kfree(t); 91 } 92 } 93 94 static struct mux_rx *alloc_mux_rx(void) 95 { 96 struct mux_rx *r = NULL; 97 98 r = kzalloc(sizeof(*r), GFP_KERNEL); 99 if (!r) 100 return NULL; 101 102 r->urb = usb_alloc_urb(0, GFP_KERNEL); 103 r->buf = kmalloc(MUX_RX_MAX_SIZE, GFP_KERNEL); 104 if (!r->urb || !r->buf) { 105 usb_free_urb(r->urb); 106 kfree(r->buf); 107 kfree(r); 108 return NULL; 109 } 110 111 return r; 112 } 113 114 static void free_mux_rx(struct mux_rx *r) 115 { 116 if (r) { 117 usb_free_urb(r->urb); 118 kfree(r->buf); 119 kfree(r); 120 } 121 } 122 123 static struct mux_rx *get_rx_struct(struct rx_cxt *rx) 124 { 125 struct mux_rx *r; 126 unsigned long flags; 127 128 spin_lock_irqsave(&rx->free_list_lock, flags); 129 130 if (list_empty(&rx->rx_free_list)) { 131 spin_unlock_irqrestore(&rx->free_list_lock, flags); 132 return NULL; 133 } 134 135 r = list_entry(rx->rx_free_list.prev, struct mux_rx, free_list); 136 list_del(&r->free_list); 137 138 spin_unlock_irqrestore(&rx->free_list_lock, flags); 139 140 return r; 141 } 142 143 static void put_rx_struct(struct rx_cxt *rx, struct mux_rx *r) 144 { 145 unsigned long flags; 146 147 spin_lock_irqsave(&rx->free_list_lock, flags); 148 list_add_tail(&r->free_list, &rx->rx_free_list); 149 spin_unlock_irqrestore(&rx->free_list_lock, flags); 150 } 151 152 static int up_to_host(struct mux_rx *r) 153 { 154 struct mux_dev *mux_dev = r->mux_dev; 155 struct mux_pkt_header *mux_header; 156 unsigned int start_flag; 157 unsigned int payload_size; 158 unsigned short packet_type; 159 int total_len; 160 u32 packet_size_sum = r->offset; 161 int index; 162 int ret = TO_HOST_INVALID_PACKET; 163 int len = r->len; 164 165 while (1) { 166 mux_header = (struct mux_pkt_header *)(r->buf + 167 packet_size_sum); 168 start_flag = __le32_to_cpu(mux_header->start_flag); 169 payload_size = __le32_to_cpu(mux_header->payload_size); 170 packet_type = __le16_to_cpu(mux_header->packet_type); 171 172 if (start_flag != START_FLAG) { 173 pr_err("invalid START_FLAG %x\n", start_flag); 174 break; 175 } 176 177 total_len = ALIGN(MUX_HEADER_SIZE + payload_size, 4); 178 179 if (len - packet_size_sum < 180 total_len) { 181 pr_err("invalid payload : %d %d %04x\n", 182 payload_size, len, packet_type); 183 break; 184 } 185 186 index = packet_type_to_index(packet_type); 187 if (index < 0) { 188 pr_err("invalid index %d\n", index); 189 break; 190 } 191 192 ret = r->callback(mux_header->data, 193 payload_size, 194 index, 195 mux_dev->tty_dev, 196 RECV_PACKET_PROCESS_CONTINUE 197 ); 198 if (ret == TO_HOST_BUFFER_REQUEST_FAIL) { 199 r->offset += packet_size_sum; 200 break; 201 } 202 203 packet_size_sum += total_len; 204 if (len - packet_size_sum <= MUX_HEADER_SIZE + 2) { 205 ret = r->callback(NULL, 206 0, 207 index, 208 mux_dev->tty_dev, 209 RECV_PACKET_PROCESS_COMPLETE 210 ); 211 break; 212 } 213 } 214 215 return ret; 216 } 217 218 static void do_rx(struct work_struct *work) 219 { 220 struct mux_dev *mux_dev = 221 container_of(work, struct mux_dev, work_rx.work); 222 struct mux_rx *r; 223 struct rx_cxt *rx = &mux_dev->rx; 224 unsigned long flags; 225 int ret = 0; 226 227 while (1) { 228 spin_lock_irqsave(&rx->to_host_lock, flags); 229 if (list_empty(&rx->to_host_list)) { 230 spin_unlock_irqrestore(&rx->to_host_lock, flags); 231 break; 232 } 233 r = list_entry(rx->to_host_list.next, struct mux_rx, 234 to_host_list); 235 list_del(&r->to_host_list); 236 spin_unlock_irqrestore(&rx->to_host_lock, flags); 237 238 ret = up_to_host(r); 239 if (ret == TO_HOST_BUFFER_REQUEST_FAIL) 240 pr_err("failed to send mux data to host\n"); 241 else 242 put_rx_struct(rx, r); 243 } 244 } 245 246 static void remove_rx_submit_list(struct mux_rx *r, struct rx_cxt *rx) 247 { 248 unsigned long flags; 249 struct mux_rx *r_remove, *r_remove_next; 250 251 spin_lock_irqsave(&rx->submit_list_lock, flags); 252 list_for_each_entry_safe(r_remove, r_remove_next, &rx->rx_submit_list, 253 rx_submit_list) { 254 if (r == r_remove) 255 list_del(&r->rx_submit_list); 256 } 257 spin_unlock_irqrestore(&rx->submit_list_lock, flags); 258 } 259 260 static void gdm_mux_rcv_complete(struct urb *urb) 261 { 262 struct mux_rx *r = urb->context; 263 struct mux_dev *mux_dev = r->mux_dev; 264 struct rx_cxt *rx = &mux_dev->rx; 265 unsigned long flags; 266 267 remove_rx_submit_list(r, rx); 268 269 if (urb->status) { 270 if (mux_dev->usb_state == PM_NORMAL) 271 dev_err(&urb->dev->dev, "%s: urb status error %d\n", 272 __func__, urb->status); 273 put_rx_struct(rx, r); 274 } else { 275 r->len = r->urb->actual_length; 276 spin_lock_irqsave(&rx->to_host_lock, flags); 277 list_add_tail(&r->to_host_list, &rx->to_host_list); 278 queue_work(mux_rx_wq, &mux_dev->work_rx.work); 279 spin_unlock_irqrestore(&rx->to_host_lock, flags); 280 } 281 } 282 283 static int gdm_mux_recv(void *priv_dev, int (*cb)(void *data, int len, 284 int tty_index, struct tty_dev *tty_dev, int complete)) 285 { 286 struct mux_dev *mux_dev = priv_dev; 287 struct usb_device *usbdev = mux_dev->usbdev; 288 struct mux_rx *r; 289 struct rx_cxt *rx = &mux_dev->rx; 290 unsigned long flags; 291 int ret; 292 293 if (!usbdev) { 294 pr_err("device is disconnected\n"); 295 return -ENODEV; 296 } 297 298 r = get_rx_struct(rx); 299 if (!r) { 300 pr_err("get_rx_struct fail\n"); 301 return -ENOMEM; 302 } 303 304 r->offset = 0; 305 r->mux_dev = (void *)mux_dev; 306 r->callback = cb; 307 mux_dev->rx_cb = cb; 308 309 usb_fill_bulk_urb(r->urb, 310 usbdev, 311 usb_rcvbulkpipe(usbdev, 0x86), 312 r->buf, 313 MUX_RX_MAX_SIZE, 314 gdm_mux_rcv_complete, 315 r); 316 317 spin_lock_irqsave(&rx->submit_list_lock, flags); 318 list_add_tail(&r->rx_submit_list, &rx->rx_submit_list); 319 spin_unlock_irqrestore(&rx->submit_list_lock, flags); 320 321 ret = usb_submit_urb(r->urb, GFP_KERNEL); 322 323 if (ret) { 324 spin_lock_irqsave(&rx->submit_list_lock, flags); 325 list_del(&r->rx_submit_list); 326 spin_unlock_irqrestore(&rx->submit_list_lock, flags); 327 328 put_rx_struct(rx, r); 329 330 pr_err("usb_submit_urb ret=%d\n", ret); 331 } 332 333 usb_mark_last_busy(usbdev); 334 335 return ret; 336 } 337 338 static void gdm_mux_send_complete(struct urb *urb) 339 { 340 struct mux_tx *t = urb->context; 341 342 if (urb->status == -ECONNRESET) { 343 dev_info(&urb->dev->dev, "CONNRESET\n"); 344 free_mux_tx(t); 345 return; 346 } 347 348 if (t->callback) 349 t->callback(t->cb_data); 350 351 free_mux_tx(t); 352 } 353 354 static int gdm_mux_send(void *priv_dev, void *data, int len, int tty_index, 355 void (*cb)(void *data), void *cb_data) 356 { 357 struct mux_dev *mux_dev = priv_dev; 358 struct usb_device *usbdev = mux_dev->usbdev; 359 struct mux_pkt_header *mux_header; 360 struct mux_tx *t = NULL; 361 static u32 seq_num = 1; 362 int total_len; 363 int ret; 364 unsigned long flags; 365 366 if (mux_dev->usb_state == PM_SUSPEND) { 367 ret = usb_autopm_get_interface(mux_dev->intf); 368 if (!ret) 369 usb_autopm_put_interface(mux_dev->intf); 370 } 371 372 spin_lock_irqsave(&mux_dev->write_lock, flags); 373 374 total_len = ALIGN(MUX_HEADER_SIZE + len, 4); 375 376 t = alloc_mux_tx(total_len); 377 if (!t) { 378 pr_err("alloc_mux_tx fail\n"); 379 spin_unlock_irqrestore(&mux_dev->write_lock, flags); 380 return -ENOMEM; 381 } 382 383 mux_header = (struct mux_pkt_header *)t->buf; 384 mux_header->start_flag = __cpu_to_le32(START_FLAG); 385 mux_header->seq_num = __cpu_to_le32(seq_num++); 386 mux_header->payload_size = __cpu_to_le32((u32)len); 387 mux_header->packet_type = __cpu_to_le16(packet_type[tty_index]); 388 389 memcpy(t->buf + MUX_HEADER_SIZE, data, len); 390 memset(t->buf + MUX_HEADER_SIZE + len, 0, total_len - MUX_HEADER_SIZE - 391 len); 392 393 t->len = total_len; 394 t->callback = cb; 395 t->cb_data = cb_data; 396 397 usb_fill_bulk_urb(t->urb, 398 usbdev, 399 usb_sndbulkpipe(usbdev, 5), 400 t->buf, 401 total_len, 402 gdm_mux_send_complete, 403 t); 404 405 ret = usb_submit_urb(t->urb, GFP_ATOMIC); 406 407 spin_unlock_irqrestore(&mux_dev->write_lock, flags); 408 409 if (ret) 410 pr_err("usb_submit_urb Error: %d\n", ret); 411 412 usb_mark_last_busy(usbdev); 413 414 return ret; 415 } 416 417 static int gdm_mux_send_control(void *priv_dev, int request, int value, 418 void *buf, int len) 419 { 420 struct mux_dev *mux_dev = priv_dev; 421 struct usb_device *usbdev = mux_dev->usbdev; 422 int ret; 423 424 ret = usb_control_msg(usbdev, 425 usb_sndctrlpipe(usbdev, 0), 426 request, 427 USB_RT_ACM, 428 value, 429 2, 430 buf, 431 len, 432 5000 433 ); 434 435 if (ret < 0) 436 pr_err("usb_control_msg error: %d\n", ret); 437 438 return ret < 0 ? ret : 0; 439 } 440 441 static void release_usb(struct mux_dev *mux_dev) 442 { 443 struct rx_cxt *rx = &mux_dev->rx; 444 struct mux_rx *r, *r_next; 445 unsigned long flags; 446 447 cancel_delayed_work(&mux_dev->work_rx); 448 449 spin_lock_irqsave(&rx->submit_list_lock, flags); 450 list_for_each_entry_safe(r, r_next, &rx->rx_submit_list, 451 rx_submit_list) { 452 spin_unlock_irqrestore(&rx->submit_list_lock, flags); 453 usb_kill_urb(r->urb); 454 spin_lock_irqsave(&rx->submit_list_lock, flags); 455 } 456 spin_unlock_irqrestore(&rx->submit_list_lock, flags); 457 458 spin_lock_irqsave(&rx->free_list_lock, flags); 459 list_for_each_entry_safe(r, r_next, &rx->rx_free_list, free_list) { 460 list_del(&r->free_list); 461 free_mux_rx(r); 462 } 463 spin_unlock_irqrestore(&rx->free_list_lock, flags); 464 465 spin_lock_irqsave(&rx->to_host_lock, flags); 466 list_for_each_entry_safe(r, r_next, &rx->to_host_list, to_host_list) { 467 if (r->mux_dev == (void *)mux_dev) { 468 list_del(&r->to_host_list); 469 free_mux_rx(r); 470 } 471 } 472 spin_unlock_irqrestore(&rx->to_host_lock, flags); 473 } 474 475 static int init_usb(struct mux_dev *mux_dev) 476 { 477 struct mux_rx *r; 478 struct rx_cxt *rx = &mux_dev->rx; 479 int ret = 0; 480 int i; 481 482 spin_lock_init(&mux_dev->write_lock); 483 INIT_LIST_HEAD(&rx->to_host_list); 484 INIT_LIST_HEAD(&rx->rx_submit_list); 485 INIT_LIST_HEAD(&rx->rx_free_list); 486 spin_lock_init(&rx->to_host_lock); 487 spin_lock_init(&rx->submit_list_lock); 488 spin_lock_init(&rx->free_list_lock); 489 490 for (i = 0; i < MAX_ISSUE_NUM * 2; i++) { 491 r = alloc_mux_rx(); 492 if (!r) { 493 ret = -ENOMEM; 494 break; 495 } 496 497 list_add(&r->free_list, &rx->rx_free_list); 498 } 499 500 INIT_DELAYED_WORK(&mux_dev->work_rx, do_rx); 501 502 return ret; 503 } 504 505 static int gdm_mux_probe(struct usb_interface *intf, 506 const struct usb_device_id *id) 507 { 508 struct mux_dev *mux_dev; 509 struct tty_dev *tty_dev; 510 u16 idVendor, idProduct; 511 int bInterfaceNumber; 512 int ret; 513 int i; 514 struct usb_device *usbdev = interface_to_usbdev(intf); 515 516 bInterfaceNumber = intf->cur_altsetting->desc.bInterfaceNumber; 517 518 idVendor = __le16_to_cpu(usbdev->descriptor.idVendor); 519 idProduct = __le16_to_cpu(usbdev->descriptor.idProduct); 520 521 pr_info("mux vid = 0x%04x pid = 0x%04x\n", idVendor, idProduct); 522 523 if (bInterfaceNumber != 2) 524 return -ENODEV; 525 526 mux_dev = kzalloc(sizeof(*mux_dev), GFP_KERNEL); 527 if (!mux_dev) 528 return -ENOMEM; 529 530 tty_dev = kzalloc(sizeof(*tty_dev), GFP_KERNEL); 531 if (!tty_dev) { 532 ret = -ENOMEM; 533 goto err_free_mux; 534 } 535 536 mux_dev->usbdev = usbdev; 537 mux_dev->control_intf = intf; 538 539 ret = init_usb(mux_dev); 540 if (ret) 541 goto err_free_usb; 542 543 tty_dev->priv_dev = (void *)mux_dev; 544 tty_dev->send_func = gdm_mux_send; 545 tty_dev->recv_func = gdm_mux_recv; 546 tty_dev->send_control = gdm_mux_send_control; 547 548 ret = register_lte_tty_device(tty_dev, &intf->dev); 549 if (ret) 550 goto err_unregister_tty; 551 552 for (i = 0; i < TTY_MAX_COUNT; i++) 553 mux_dev->tty_dev = tty_dev; 554 555 mux_dev->intf = intf; 556 mux_dev->usb_state = PM_NORMAL; 557 558 usb_get_dev(usbdev); 559 usb_set_intfdata(intf, tty_dev); 560 561 return 0; 562 563 err_unregister_tty: 564 unregister_lte_tty_device(tty_dev); 565 err_free_usb: 566 release_usb(mux_dev); 567 kfree(tty_dev); 568 err_free_mux: 569 kfree(mux_dev); 570 571 return ret; 572 } 573 574 static void gdm_mux_disconnect(struct usb_interface *intf) 575 { 576 struct tty_dev *tty_dev; 577 struct mux_dev *mux_dev; 578 struct usb_device *usbdev = interface_to_usbdev(intf); 579 580 tty_dev = usb_get_intfdata(intf); 581 582 mux_dev = tty_dev->priv_dev; 583 584 release_usb(mux_dev); 585 unregister_lte_tty_device(tty_dev); 586 587 kfree(mux_dev); 588 kfree(tty_dev); 589 590 usb_put_dev(usbdev); 591 } 592 593 static int gdm_mux_suspend(struct usb_interface *intf, pm_message_t pm_msg) 594 { 595 struct tty_dev *tty_dev; 596 struct mux_dev *mux_dev; 597 struct rx_cxt *rx; 598 struct mux_rx *r, *r_next; 599 unsigned long flags; 600 601 tty_dev = usb_get_intfdata(intf); 602 mux_dev = tty_dev->priv_dev; 603 rx = &mux_dev->rx; 604 605 if (mux_dev->usb_state != PM_NORMAL) { 606 dev_err(intf->usb_dev, "usb suspend - invalid state\n"); 607 return -1; 608 } 609 610 mux_dev->usb_state = PM_SUSPEND; 611 612 spin_lock_irqsave(&rx->submit_list_lock, flags); 613 list_for_each_entry_safe(r, r_next, &rx->rx_submit_list, 614 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); 618 } 619 spin_unlock_irqrestore(&rx->submit_list_lock, flags); 620 621 return 0; 622 } 623 624 static int gdm_mux_resume(struct usb_interface *intf) 625 { 626 struct tty_dev *tty_dev; 627 struct mux_dev *mux_dev; 628 u8 i; 629 630 tty_dev = usb_get_intfdata(intf); 631 mux_dev = tty_dev->priv_dev; 632 633 if (mux_dev->usb_state != PM_SUSPEND) { 634 dev_err(intf->usb_dev, "usb resume - invalid state\n"); 635 return -1; 636 } 637 638 mux_dev->usb_state = PM_NORMAL; 639 640 for (i = 0; i < MAX_ISSUE_NUM; i++) 641 gdm_mux_recv(mux_dev, mux_dev->rx_cb); 642 643 return 0; 644 } 645 646 static struct usb_driver gdm_mux_driver = { 647 .name = "gdm_mux", 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, 655 }; 656 657 static int __init gdm_usb_mux_init(void) 658 { 659 660 mux_rx_wq = create_workqueue("mux_rx_wq"); 661 if (!mux_rx_wq) { 662 pr_err("work queue create fail\n"); 663 return -1; 664 } 665 666 register_lte_tty_driver(); 667 668 return usb_register(&gdm_mux_driver); 669 } 670 671 static void __exit gdm_usb_mux_exit(void) 672 { 673 unregister_lte_tty_driver(); 674 675 if (mux_rx_wq) { 676 flush_workqueue(mux_rx_wq); 677 destroy_workqueue(mux_rx_wq); 678 } 679 680 usb_deregister(&gdm_mux_driver); 681 } 682 683 module_init(gdm_usb_mux_init); 684 module_exit(gdm_usb_mux_exit); 685 686 MODULE_DESCRIPTION("GCT LTE TTY Device Driver"); 687 MODULE_LICENSE("GPL"); 688