drivers/staging/gdm724x/gdm_mux.c

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