drivers/staging/gdm724x/gdm_usb.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/sched.h>
  10 #include <linux/kthread.h>
  11 #include <linux/usb/cdc.h>
  12 #include <linux/wait.h>
  13 #include <linux/if_ether.h>
  14 #include <linux/pm_runtime.h>
  15
  16 #include "gdm_usb.h"
  17 #include "gdm_lte.h"
  18 #include "hci.h"
  19 #include "hci_packet.h"
  20 #include "gdm_endian.h"
  21
  22 #define USB_DEVICE_CDC_DATA(vid, pid) \
  23         .match_flags = 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_ETHERNET
  30
  31 #define USB_DEVICE_MASS_DATA(vid, pid) \
  32         .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
  33                 USB_DEVICE_ID_MATCH_INT_INFO,\
  34         .idVendor = vid,\
  35         .idProduct = pid,\
  36         .bInterfaceSubClass = USB_SC_SCSI, \
  37         .bInterfaceClass = USB_CLASS_MASS_STORAGE,\
  38         .bInterfaceProtocol = USB_PR_BULK
  39
  40 static const struct usb_device_id id_table[] = {
  41         { USB_DEVICE_CDC_DATA(VID_GCT, PID_GDM7240) }, /* GCT GDM7240 */
  42         { USB_DEVICE_CDC_DATA(VID_GCT, PID_GDM7243) }, /* GCT GDM7243 */
  43         { }
  44 };
  45
  46 MODULE_DEVICE_TABLE(usb, id_table);
  47
  48 static void do_tx(struct work_struct *work);
  49 static void do_rx(struct work_struct *work);
  50
  51 static int gdm_usb_recv(void *priv_dev,
  52                         int (*cb)(void *cb_data,
  53                                   void *data, int len, int context),
  54                         void *cb_data,
  55                         int context);
  56
  57 static int request_mac_address(struct lte_udev *udev)
  58 {
  59         struct hci_packet *hci;
  60         struct usb_device *usbdev = udev->usbdev;
  61         int actual;
  62         int ret = -1;
  63
  64         hci = kmalloc(struct_size(hci, data, 1), GFP_KERNEL);
  65         if (!hci)
  66                 return -ENOMEM;
  67
  68         hci->cmd_evt = gdm_cpu_to_dev16(udev->gdm_ed, LTE_GET_INFORMATION);
  69         hci->len = gdm_cpu_to_dev16(udev->gdm_ed, 1);
  70         hci->data[0] = MAC_ADDRESS;
  71
  72         ret = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 2), hci, 5,
  73                            &actual, 1000);
  74
  75         udev->request_mac_addr = 1;
  76         kfree(hci);
  77
  78         return ret;
  79 }
  80
  81 static struct usb_tx *alloc_tx_struct(int len)
  82 {
  83         struct usb_tx *t = NULL;
  84         int ret = 0;
  85
  86         t = kzalloc(sizeof(*t), GFP_ATOMIC);
  87         if (!t) {
  88                 ret = -ENOMEM;
  89                 goto out;
  90         }
  91
  92         t->urb = usb_alloc_urb(0, GFP_ATOMIC);
  93         if (!(len % 512))
  94                 len++;
  95
  96         t->buf = kmalloc(len, GFP_ATOMIC);
  97         if (!t->urb || !t->buf) {
  98                 ret = -ENOMEM;
  99                 goto out;
 100         }
 101
 102 out:
 103         if (ret < 0) {
 104                 if (t) {
 105                         usb_free_urb(t->urb);
 106                         kfree(t->buf);
 107                         kfree(t);
 108                 }
 109                 return NULL;
 110         }
 111
 112         return t;
 113 }
 114
 115 static struct usb_tx_sdu *alloc_tx_sdu_struct(void)
 116 {
 117         struct usb_tx_sdu *t_sdu;
 118
 119         t_sdu = kzalloc(sizeof(*t_sdu), GFP_KERNEL);
 120         if (!t_sdu)
 121                 return NULL;
 122
 123         t_sdu->buf = kmalloc(SDU_BUF_SIZE, GFP_KERNEL);
 124         if (!t_sdu->buf) {
 125                 kfree(t_sdu);
 126                 return NULL;
 127         }
 128
 129         return t_sdu;
 130 }
 131
 132 static void free_tx_struct(struct usb_tx *t)
 133 {
 134         if (t) {
 135                 usb_free_urb(t->urb);
 136                 kfree(t->buf);
 137                 kfree(t);
 138         }
 139 }
 140
 141 static void free_tx_sdu_struct(struct usb_tx_sdu *t_sdu)
 142 {
 143         if (t_sdu) {
 144                 kfree(t_sdu->buf);
 145                 kfree(t_sdu);
 146         }
 147 }
 148
 149 static struct usb_tx_sdu *get_tx_sdu_struct(struct tx_cxt *tx, int *no_spc)
 150 {
 151         struct usb_tx_sdu *t_sdu;
 152
 153         if (list_empty(&tx->free_list))
 154                 return NULL;
 155
 156         t_sdu = list_entry(tx->free_list.next, struct usb_tx_sdu, list);
 157         list_del(&t_sdu->list);
 158
 159         tx->avail_count--;
 160
 161         *no_spc = list_empty(&tx->free_list) ? 1 : 0;
 162
 163         return t_sdu;
 164 }
 165
 166 static void put_tx_struct(struct tx_cxt *tx, struct usb_tx_sdu *t_sdu)
 167 {
 168         list_add_tail(&t_sdu->list, &tx->free_list);
 169         tx->avail_count++;
 170 }
 171
 172 static struct usb_rx *alloc_rx_struct(void)
 173 {
 174         struct usb_rx *r = NULL;
 175         int ret = 0;
 176
 177         r = kmalloc(sizeof(*r), GFP_KERNEL);
 178         if (!r) {
 179                 ret = -ENOMEM;
 180                 goto out;
 181         }
 182
 183         r->urb = usb_alloc_urb(0, GFP_KERNEL);
 184         r->buf = kmalloc(RX_BUF_SIZE, GFP_KERNEL);
 185         if (!r->urb || !r->buf) {
 186                 ret = -ENOMEM;
 187                 goto out;
 188         }
 189 out:
 190
 191         if (ret < 0) {
 192                 if (r) {
 193                         usb_free_urb(r->urb);
 194                         kfree(r->buf);
 195                         kfree(r);
 196                 }
 197                 return NULL;
 198         }
 199
 200         return r;
 201 }
 202
 203 static void free_rx_struct(struct usb_rx *r)
 204 {
 205         if (r) {
 206                 usb_free_urb(r->urb);
 207                 kfree(r->buf);
 208                 kfree(r);
 209         }
 210 }
 211
 212 static struct usb_rx *get_rx_struct(struct rx_cxt *rx, int *no_spc)
 213 {
 214         struct usb_rx *r;
 215         unsigned long flags;
 216
 217         spin_lock_irqsave(&rx->rx_lock, flags);
 218
 219         if (list_empty(&rx->free_list)) {
 220                 spin_unlock_irqrestore(&rx->rx_lock, flags);
 221                 return NULL;
 222         }
 223
 224         r = list_entry(rx->free_list.next, struct usb_rx, free_list);
 225         list_del(&r->free_list);
 226
 227         rx->avail_count--;
 228
 229         *no_spc = list_empty(&rx->free_list) ? 1 : 0;
 230
 231         spin_unlock_irqrestore(&rx->rx_lock, flags);
 232
 233         return r;
 234 }
 235
 236 static void put_rx_struct(struct rx_cxt *rx, struct usb_rx *r)
 237 {
 238         unsigned long flags;
 239
 240         spin_lock_irqsave(&rx->rx_lock, flags);
 241
 242         list_add_tail(&r->free_list, &rx->free_list);
 243         rx->avail_count++;
 244
 245         spin_unlock_irqrestore(&rx->rx_lock, flags);
 246 }
 247
 248 static void release_usb(struct lte_udev *udev)
 249 {
 250         struct rx_cxt   *rx = &udev->rx;
 251         struct tx_cxt   *tx = &udev->tx;
 252         struct usb_tx   *t, *t_next;
 253         struct usb_rx   *r, *r_next;
 254         struct usb_tx_sdu       *t_sdu, *t_sdu_next;
 255         unsigned long flags;
 256
 257         spin_lock_irqsave(&tx->lock, flags);
 258         list_for_each_entry_safe(t_sdu, t_sdu_next, &tx->sdu_list, list) {
 259                 list_del(&t_sdu->list);
 260                 free_tx_sdu_struct(t_sdu);
 261         }
 262
 263         list_for_each_entry_safe(t, t_next, &tx->hci_list, list) {
 264                 list_del(&t->list);
 265                 free_tx_struct(t);
 266         }
 267
 268         list_for_each_entry_safe(t_sdu, t_sdu_next, &tx->free_list, list) {
 269                 list_del(&t_sdu->list);
 270                 free_tx_sdu_struct(t_sdu);
 271         }
 272         spin_unlock_irqrestore(&tx->lock, flags);
 273
 274         spin_lock_irqsave(&rx->submit_lock, flags);
 275         list_for_each_entry_safe(r, r_next, &rx->rx_submit_list,
 276                                  rx_submit_list) {
 277                 spin_unlock_irqrestore(&rx->submit_lock, flags);
 278                 usb_kill_urb(r->urb);
 279                 spin_lock_irqsave(&rx->submit_lock, flags);
 280         }
 281         spin_unlock_irqrestore(&rx->submit_lock, flags);
 282
 283         spin_lock_irqsave(&rx->rx_lock, flags);
 284         list_for_each_entry_safe(r, r_next, &rx->free_list, free_list) {
 285                 list_del(&r->free_list);
 286                 free_rx_struct(r);
 287         }
 288         spin_unlock_irqrestore(&rx->rx_lock, flags);
 289
 290         spin_lock_irqsave(&rx->to_host_lock, flags);
 291         list_for_each_entry_safe(r, r_next, &rx->to_host_list, to_host_list) {
 292                 if (r->index == (void *)udev) {
 293                         list_del(&r->to_host_list);
 294                         free_rx_struct(r);
 295                 }
 296         }
 297         spin_unlock_irqrestore(&rx->to_host_lock, flags);
 298 }
 299
 300 static int init_usb(struct lte_udev *udev)
 301 {
 302         int ret = 0;
 303         int i;
 304         struct tx_cxt *tx = &udev->tx;
 305         struct rx_cxt *rx = &udev->rx;
 306         struct usb_tx_sdu *t_sdu = NULL;
 307         struct usb_rx *r = NULL;
 308
 309         udev->send_complete = 1;
 310         udev->tx_stop = 0;
 311         udev->request_mac_addr = 0;
 312         udev->usb_state = PM_NORMAL;
 313
 314         INIT_LIST_HEAD(&tx->sdu_list);
 315         INIT_LIST_HEAD(&tx->hci_list);
 316         INIT_LIST_HEAD(&tx->free_list);
 317         INIT_LIST_HEAD(&rx->rx_submit_list);
 318         INIT_LIST_HEAD(&rx->free_list);
 319         INIT_LIST_HEAD(&rx->to_host_list);
 320         spin_lock_init(&tx->lock);
 321         spin_lock_init(&rx->rx_lock);
 322         spin_lock_init(&rx->submit_lock);
 323         spin_lock_init(&rx->to_host_lock);
 324
 325         tx->avail_count = 0;
 326         rx->avail_count = 0;
 327
 328         udev->rx_cb = NULL;
 329
 330         for (i = 0; i < MAX_NUM_SDU_BUF; i++) {
 331                 t_sdu = alloc_tx_sdu_struct();
 332                 if (!t_sdu) {
 333                         ret = -ENOMEM;
 334                         goto fail;
 335                 }
 336
 337                 list_add(&t_sdu->list, &tx->free_list);
 338                 tx->avail_count++;
 339         }
 340
 341         for (i = 0; i < MAX_RX_SUBMIT_COUNT * 2; i++) {
 342                 r = alloc_rx_struct();
 343                 if (!r) {
 344                         ret = -ENOMEM;
 345                         goto fail;
 346                 }
 347
 348                 list_add(&r->free_list, &rx->free_list);
 349                 rx->avail_count++;
 350         }
 351         INIT_DELAYED_WORK(&udev->work_tx, do_tx);
 352         INIT_DELAYED_WORK(&udev->work_rx, do_rx);
 353         return 0;
 354 fail:
 355         release_usb(udev);
 356         return ret;
 357 }
 358
 359 static int set_mac_address(u8 *data, void *arg)
 360 {
 361         struct phy_dev *phy_dev = arg;
 362         struct lte_udev *udev = phy_dev->priv_dev;
 363         struct tlv *tlv = (struct tlv *)data;
 364         u8 mac_address[ETH_ALEN] = {0, };
 365
 366         if (tlv->type == MAC_ADDRESS && udev->request_mac_addr) {
 367                 memcpy(mac_address, tlv->data, tlv->len);
 368
 369                 if (register_lte_device(phy_dev,
 370                                         &udev->intf->dev, mac_address) < 0)
 371                         pr_err("register lte device failed\n");
 372
 373                 udev->request_mac_addr = 0;
 374
 375                 return 1;
 376         }
 377
 378         return 0;
 379 }
 380
 381 static void do_rx(struct work_struct *work)
 382 {
 383         struct lte_udev *udev =
 384                 container_of(work, struct lte_udev, work_rx.work);
 385         struct rx_cxt *rx = &udev->rx;
 386         struct usb_rx *r;
 387         struct hci_packet *hci;
 388         struct phy_dev *phy_dev;
 389         u16 cmd_evt;
 390         int ret;
 391         unsigned long flags;
 392
 393         while (1) {
 394                 spin_lock_irqsave(&rx->to_host_lock, flags);
 395                 if (list_empty(&rx->to_host_list)) {
 396                         spin_unlock_irqrestore(&rx->to_host_lock, flags);
 397                         break;
 398                 }
 399                 r = list_entry(rx->to_host_list.next,
 400                                struct usb_rx, to_host_list);
 401                 list_del(&r->to_host_list);
 402                 spin_unlock_irqrestore(&rx->to_host_lock, flags);
 403
 404                 phy_dev = r->cb_data;
 405                 udev = phy_dev->priv_dev;
 406                 hci = (struct hci_packet *)r->buf;
 407                 cmd_evt = gdm_dev16_to_cpu(udev->gdm_ed, hci->cmd_evt);
 408
 409                 switch (cmd_evt) {
 410                 case LTE_GET_INFORMATION_RESULT:
 411                         if (set_mac_address(hci->data, r->cb_data) == 0) {
 412                                 r->callback(r->cb_data,
 413                                             r->buf,
 414                                             r->urb->actual_length,
 415                                             KERNEL_THREAD);
 416                         }
 417                         break;
 418
 419                 default:
 420                         if (r->callback) {
 421                                 ret = r->callback(r->cb_data,
 422                                                   r->buf,
 423                                                   r->urb->actual_length,
 424                                                   KERNEL_THREAD);
 425
 426                                 if (ret == -EAGAIN)
 427                                         pr_err("failed to send received data\n");
 428                         }
 429                         break;
 430                 }
 431
 432                 put_rx_struct(rx, r);
 433
 434                 gdm_usb_recv(udev,
 435                              r->callback,
 436                              r->cb_data,
 437                              USB_COMPLETE);
 438         }
 439 }
 440
 441 static void remove_rx_submit_list(struct usb_rx *r, struct rx_cxt *rx)
 442 {
 443         unsigned long flags;
 444         struct usb_rx   *r_remove, *r_remove_next;
 445
 446         spin_lock_irqsave(&rx->submit_lock, flags);
 447         list_for_each_entry_safe(r_remove, r_remove_next,
 448                                  &rx->rx_submit_list, rx_submit_list) {
 449                 if (r == r_remove) {
 450                         list_del(&r->rx_submit_list);
 451                         break;
 452                 }
 453         }
 454         spin_unlock_irqrestore(&rx->submit_lock, flags);
 455 }
 456
 457 static void gdm_usb_rcv_complete(struct urb *urb)
 458 {
 459         struct usb_rx *r = urb->context;
 460         struct rx_cxt *rx = r->rx;
 461         unsigned long flags;
 462         struct lte_udev *udev = container_of(r->rx, struct lte_udev, rx);
 463         struct usb_device *usbdev = udev->usbdev;
 464
 465         remove_rx_submit_list(r, rx);
 466
 467         if (!urb->status && r->callback) {
 468                 spin_lock_irqsave(&rx->to_host_lock, flags);
 469                 list_add_tail(&r->to_host_list, &rx->to_host_list);
 470                 schedule_work(&udev->work_rx.work);
 471                 spin_unlock_irqrestore(&rx->to_host_lock, flags);
 472         } else {
 473                 if (urb->status && udev->usb_state == PM_NORMAL)
 474                         dev_err(&urb->dev->dev, "%s: urb status error %d\n",
 475                                 __func__, urb->status);
 476
 477                 put_rx_struct(rx, r);
 478         }
 479
 480         usb_mark_last_busy(usbdev);
 481 }
 482
 483 static int gdm_usb_recv(void *priv_dev,
 484                         int (*cb)(void *cb_data,
 485                                   void *data, int len, int context),
 486                         void *cb_data,
 487                         int context)
 488 {
 489         struct lte_udev *udev = priv_dev;
 490         struct usb_device *usbdev = udev->usbdev;
 491         struct rx_cxt *rx = &udev->rx;
 492         struct usb_rx *r;
 493         int no_spc;
 494         int ret;
 495         unsigned long flags;
 496
 497         if (!udev->usbdev) {
 498                 pr_err("invalid device\n");
 499                 return -ENODEV;
 500         }
 501
 502         r = get_rx_struct(rx, &no_spc);
 503         if (!r) {
 504                 pr_err("Out of Memory\n");
 505                 return -ENOMEM;
 506         }
 507
 508         udev->rx_cb = cb;
 509         r->callback = cb;
 510         r->cb_data = cb_data;
 511         r->index = (void *)udev;
 512         r->rx = rx;
 513
 514         usb_fill_bulk_urb(r->urb,
 515                           usbdev,
 516                           usb_rcvbulkpipe(usbdev, 0x83),
 517                           r->buf,
 518                           RX_BUF_SIZE,
 519                           gdm_usb_rcv_complete,
 520                           r);
 521
 522         spin_lock_irqsave(&rx->submit_lock, flags);
 523         list_add_tail(&r->rx_submit_list, &rx->rx_submit_list);
 524         spin_unlock_irqrestore(&rx->submit_lock, flags);
 525
 526         if (context == KERNEL_THREAD)
 527                 ret = usb_submit_urb(r->urb, GFP_KERNEL);
 528         else
 529                 ret = usb_submit_urb(r->urb, GFP_ATOMIC);
 530
 531         if (ret) {
 532                 spin_lock_irqsave(&rx->submit_lock, flags);
 533                 list_del(&r->rx_submit_list);
 534                 spin_unlock_irqrestore(&rx->submit_lock, flags);
 535
 536                 pr_err("usb_submit_urb failed (%p)\n", r);
 537                 put_rx_struct(rx, r);
 538         }
 539
 540         return ret;
 541 }
 542
 543 static void gdm_usb_send_complete(struct urb *urb)
 544 {
 545         struct usb_tx *t = urb->context;
 546         struct tx_cxt *tx = t->tx;
 547         struct lte_udev *udev = container_of(tx, struct lte_udev, tx);
 548         unsigned long flags;
 549
 550         if (urb->status == -ECONNRESET) {
 551                 dev_info(&urb->dev->dev, "CONNRESET\n");
 552                 return;
 553         }
 554
 555         if (t->callback)
 556                 t->callback(t->cb_data);
 557
 558         free_tx_struct(t);
 559
 560         spin_lock_irqsave(&tx->lock, flags);
 561         udev->send_complete = 1;
 562         schedule_work(&udev->work_tx.work);
 563         spin_unlock_irqrestore(&tx->lock, flags);
 564 }
 565
 566 static int send_tx_packet(struct usb_device *usbdev, struct usb_tx *t, u32 len)
 567 {
 568         int ret = 0;
 569
 570         if (!(len % 512))
 571                 len++;
 572
 573         usb_fill_bulk_urb(t->urb,
 574                           usbdev,
 575                           usb_sndbulkpipe(usbdev, 2),
 576                           t->buf,
 577                           len,
 578                           gdm_usb_send_complete,
 579                           t);
 580
 581         ret = usb_submit_urb(t->urb, GFP_ATOMIC);
 582
 583         if (ret)
 584                 dev_err(&usbdev->dev, "usb_submit_urb failed: %d\n",
 585                         ret);
 586
 587         usb_mark_last_busy(usbdev);
 588
 589         return ret;
 590 }
 591
 592 static u32 packet_aggregation(struct lte_udev *udev, u8 *send_buf)
 593 {
 594         struct tx_cxt *tx = &udev->tx;
 595         struct usb_tx_sdu *t_sdu = NULL;
 596         struct multi_sdu *multi_sdu = (struct multi_sdu *)send_buf;
 597         u16 send_len = 0;
 598         u16 num_packet = 0;
 599         unsigned long flags;
 600
 601         multi_sdu->cmd_evt = gdm_cpu_to_dev16(udev->gdm_ed, LTE_TX_MULTI_SDU);
 602
 603         while (num_packet < MAX_PACKET_IN_MULTI_SDU) {
 604                 spin_lock_irqsave(&tx->lock, flags);
 605                 if (list_empty(&tx->sdu_list)) {
 606                         spin_unlock_irqrestore(&tx->lock, flags);
 607                         break;
 608                 }
 609
 610                 t_sdu = list_entry(tx->sdu_list.next, struct usb_tx_sdu, list);
 611                 if (send_len + t_sdu->len > MAX_SDU_SIZE) {
 612                         spin_unlock_irqrestore(&tx->lock, flags);
 613                         break;
 614                 }
 615
 616                 list_del(&t_sdu->list);
 617                 spin_unlock_irqrestore(&tx->lock, flags);
 618
 619                 memcpy(multi_sdu->data + send_len, t_sdu->buf, t_sdu->len);
 620
 621                 send_len += (t_sdu->len + 3) & 0xfffc;
 622                 num_packet++;
 623
 624                 if (tx->avail_count > 10)
 625                         t_sdu->callback(t_sdu->cb_data);
 626
 627                 spin_lock_irqsave(&tx->lock, flags);
 628                 put_tx_struct(tx, t_sdu);
 629                 spin_unlock_irqrestore(&tx->lock, flags);
 630         }
 631
 632         multi_sdu->len = gdm_cpu_to_dev16(udev->gdm_ed, send_len);
 633         multi_sdu->num_packet = gdm_cpu_to_dev16(udev->gdm_ed, num_packet);
 634
 635         return send_len + offsetof(struct multi_sdu, data);
 636 }
 637
 638 static void do_tx(struct work_struct *work)
 639 {
 640         struct lte_udev *udev =
 641                 container_of(work, struct lte_udev, work_tx.work);
 642         struct usb_device *usbdev = udev->usbdev;
 643         struct tx_cxt *tx = &udev->tx;
 644         struct usb_tx *t = NULL;
 645         int is_send = 0;
 646         u32 len = 0;
 647         unsigned long flags;
 648
 649         if (!usb_autopm_get_interface(udev->intf))
 650                 usb_autopm_put_interface(udev->intf);
 651
 652         if (udev->usb_state == PM_SUSPEND)
 653                 return;
 654
 655         spin_lock_irqsave(&tx->lock, flags);
 656         if (!udev->send_complete) {
 657                 spin_unlock_irqrestore(&tx->lock, flags);
 658                 return;
 659         }
 660         udev->send_complete = 0;
 661
 662         if (!list_empty(&tx->hci_list)) {
 663                 t = list_entry(tx->hci_list.next, struct usb_tx, list);
 664                 list_del(&t->list);
 665                 len = t->len;
 666                 t->is_sdu = 0;
 667                 is_send = 1;
 668         } else if (!list_empty(&tx->sdu_list)) {
 669                 if (udev->tx_stop) {
 670                         udev->send_complete = 1;
 671                         spin_unlock_irqrestore(&tx->lock, flags);
 672                         return;
 673                 }
 674
 675                 t = alloc_tx_struct(TX_BUF_SIZE);
 676                 if (!t) {
 677                         spin_unlock_irqrestore(&tx->lock, flags);
 678                         return;
 679                 }
 680                 t->callback = NULL;
 681                 t->tx = tx;
 682                 t->is_sdu = 1;
 683                 is_send = 1;
 684         }
 685
 686         if (!is_send) {
 687                 udev->send_complete = 1;
 688                 spin_unlock_irqrestore(&tx->lock, flags);
 689                 return;
 690         }
 691         spin_unlock_irqrestore(&tx->lock, flags);
 692
 693         if (t->is_sdu)
 694                 len = packet_aggregation(udev, t->buf);
 695
 696         if (send_tx_packet(usbdev, t, len)) {
 697                 pr_err("send_tx_packet failed\n");
 698                 t->callback = NULL;
 699                 gdm_usb_send_complete(t->urb);
 700         }
 701 }
 702
 703 #define SDU_PARAM_LEN 12
 704 static int gdm_usb_sdu_send(void *priv_dev, void *data, int len,
 705                             unsigned int dft_eps_ID, unsigned int eps_ID,
 706                             void (*cb)(void *data), void *cb_data,
 707                             int dev_idx, int nic_type)
 708 {
 709         struct lte_udev *udev = priv_dev;
 710         struct tx_cxt *tx = &udev->tx;
 711         struct usb_tx_sdu *t_sdu;
 712         struct sdu *sdu = NULL;
 713         unsigned long flags;
 714         int no_spc = 0;
 715         u16 send_len;
 716
 717         if (!udev->usbdev) {
 718                 pr_err("sdu send - invalid device\n");
 719                 return TX_NO_DEV;
 720         }
 721
 722         spin_lock_irqsave(&tx->lock, flags);
 723         t_sdu = get_tx_sdu_struct(tx, &no_spc);
 724         spin_unlock_irqrestore(&tx->lock, flags);
 725
 726         if (!t_sdu) {
 727                 pr_err("sdu send - free list empty\n");
 728                 return TX_NO_SPC;
 729         }
 730
 731         sdu = (struct sdu *)t_sdu->buf;
 732         sdu->cmd_evt = gdm_cpu_to_dev16(udev->gdm_ed, LTE_TX_SDU);
 733         if (nic_type == NIC_TYPE_ARP) {
 734                 send_len = len + SDU_PARAM_LEN;
 735                 memcpy(sdu->data, data, len);
 736         } else {
 737                 send_len = len - ETH_HLEN;
 738                 send_len += SDU_PARAM_LEN;
 739                 memcpy(sdu->data, data + ETH_HLEN, len - ETH_HLEN);
 740         }
 741
 742         sdu->len = gdm_cpu_to_dev16(udev->gdm_ed, send_len);
 743         sdu->dft_eps_ID = gdm_cpu_to_dev32(udev->gdm_ed, dft_eps_ID);
 744         sdu->bearer_ID = gdm_cpu_to_dev32(udev->gdm_ed, eps_ID);
 745         sdu->nic_type = gdm_cpu_to_dev32(udev->gdm_ed, nic_type);
 746
 747         t_sdu->len = send_len + HCI_HEADER_SIZE;
 748         t_sdu->callback = cb;
 749         t_sdu->cb_data = cb_data;
 750
 751         spin_lock_irqsave(&tx->lock, flags);
 752         list_add_tail(&t_sdu->list, &tx->sdu_list);
 753         schedule_work(&udev->work_tx.work);
 754         spin_unlock_irqrestore(&tx->lock, flags);
 755
 756         if (no_spc)
 757                 return TX_NO_BUFFER;
 758
 759         return 0;
 760 }
 761
 762 static int gdm_usb_hci_send(void *priv_dev, void *data, int len,
 763                             void (*cb)(void *data), void *cb_data)
 764 {
 765         struct lte_udev *udev = priv_dev;
 766         struct tx_cxt *tx = &udev->tx;
 767         struct usb_tx *t;
 768         unsigned long flags;
 769
 770         if (!udev->usbdev) {
 771                 pr_err("hci send - invalid device\n");
 772                 return -ENODEV;
 773         }
 774
 775         t = alloc_tx_struct(len);
 776         if (!t) {
 777                 pr_err("hci_send - out of memory\n");
 778                 return -ENOMEM;
 779         }
 780
 781         memcpy(t->buf, data, len);
 782         t->callback = cb;
 783         t->cb_data = cb_data;
 784         t->len = len;
 785         t->tx = tx;
 786         t->is_sdu = 0;
 787
 788         spin_lock_irqsave(&tx->lock, flags);
 789         list_add_tail(&t->list, &tx->hci_list);
 790         schedule_work(&udev->work_tx.work);
 791         spin_unlock_irqrestore(&tx->lock, flags);
 792
 793         return 0;
 794 }
 795
 796 static u8 gdm_usb_get_endian(void *priv_dev)
 797 {
 798         struct lte_udev *udev = priv_dev;
 799
 800         return udev->gdm_ed;
 801 }
 802
 803 static int gdm_usb_probe(struct usb_interface *intf,
 804                          const struct usb_device_id *id)
 805 {
 806         int ret = 0;
 807         struct phy_dev *phy_dev = NULL;
 808         struct lte_udev *udev = NULL;
 809         u16 idVendor, idProduct;
 810         int bInterfaceNumber;
 811         struct usb_device *usbdev = interface_to_usbdev(intf);
 812
 813         bInterfaceNumber = intf->cur_altsetting->desc.bInterfaceNumber;
 814         idVendor = __le16_to_cpu(usbdev->descriptor.idVendor);
 815         idProduct = __le16_to_cpu(usbdev->descriptor.idProduct);
 816
 817         pr_info("net vid = 0x%04x pid = 0x%04x\n", idVendor, idProduct);
 818
 819         if (bInterfaceNumber > NETWORK_INTERFACE) {
 820                 pr_info("not a network device\n");
 821                 return -ENODEV;
 822         }
 823
 824         phy_dev = kzalloc(sizeof(*phy_dev), GFP_KERNEL);
 825         if (!phy_dev)
 826                 return -ENOMEM;
 827
 828         udev = kzalloc(sizeof(*udev), GFP_KERNEL);
 829         if (!udev) {
 830                 ret = -ENOMEM;
 831                 goto err_udev;
 832         }
 833
 834         phy_dev->priv_dev = (void *)udev;
 835         phy_dev->send_hci_func = gdm_usb_hci_send;
 836         phy_dev->send_sdu_func = gdm_usb_sdu_send;
 837         phy_dev->rcv_func = gdm_usb_recv;
 838         phy_dev->get_endian = gdm_usb_get_endian;
 839
 840         udev->usbdev = usbdev;
 841         ret = init_usb(udev);
 842         if (ret < 0) {
 843                 dev_err(intf->usb_dev, "init_usb func failed\n");
 844                 goto err_init_usb;
 845         }
 846         udev->intf = intf;
 847
 848         intf->needs_remote_wakeup = 1;
 849         usb_enable_autosuspend(usbdev);
 850         pm_runtime_set_autosuspend_delay(&usbdev->dev, AUTO_SUSPEND_TIMER);
 851
 852         /* List up hosts with big endians, otherwise,
 853          * defaults to little endian
 854          */
 855         if (idProduct == PID_GDM7243)
 856                 udev->gdm_ed = ENDIANNESS_BIG;
 857         else
 858                 udev->gdm_ed = ENDIANNESS_LITTLE;
 859
 860         ret = request_mac_address(udev);
 861         if (ret < 0) {
 862                 dev_err(intf->usb_dev, "request Mac address failed\n");
 863                 goto err_mac_address;
 864         }
 865
 866         start_rx_proc(phy_dev);
 867         usb_get_dev(usbdev);
 868         usb_set_intfdata(intf, phy_dev);
 869
 870         return 0;
 871
 872 err_mac_address:
 873         release_usb(udev);
 874 err_init_usb:
 875         kfree(udev);
 876 err_udev:
 877         kfree(phy_dev);
 878
 879         return ret;
 880 }
 881
 882 static void gdm_usb_disconnect(struct usb_interface *intf)
 883 {
 884         struct phy_dev *phy_dev;
 885         struct lte_udev *udev;
 886         struct usb_device *usbdev;
 887
 888         usbdev = interface_to_usbdev(intf);
 889         phy_dev = usb_get_intfdata(intf);
 890
 891         udev = phy_dev->priv_dev;
 892         unregister_lte_device(phy_dev);
 893
 894         release_usb(udev);
 895
 896         kfree(udev);
 897         udev = NULL;
 898
 899         kfree(phy_dev);
 900         phy_dev = NULL;
 901
 902         usb_put_dev(usbdev);
 903 }
 904
 905 static int gdm_usb_suspend(struct usb_interface *intf, pm_message_t pm_msg)
 906 {
 907         struct phy_dev *phy_dev;
 908         struct lte_udev *udev;
 909         struct rx_cxt *rx;
 910         struct usb_rx *r;
 911         struct usb_rx *r_next;
 912         unsigned long flags;
 913
 914         phy_dev = usb_get_intfdata(intf);
 915         udev = phy_dev->priv_dev;
 916         rx = &udev->rx;
 917         if (udev->usb_state != PM_NORMAL) {
 918                 dev_err(intf->usb_dev, "usb suspend - invalid state\n");
 919                 return -1;
 920         }
 921
 922         udev->usb_state = PM_SUSPEND;
 923
 924         spin_lock_irqsave(&rx->submit_lock, flags);
 925         list_for_each_entry_safe(r, r_next, &rx->rx_submit_list,
 926                                  rx_submit_list) {
 927                 spin_unlock_irqrestore(&rx->submit_lock, flags);
 928                 usb_kill_urb(r->urb);
 929                 spin_lock_irqsave(&rx->submit_lock, flags);
 930         }
 931         spin_unlock_irqrestore(&rx->submit_lock, flags);
 932
 933         cancel_work_sync(&udev->work_tx.work);
 934         cancel_work_sync(&udev->work_rx.work);
 935
 936         return 0;
 937 }
 938
 939 static int gdm_usb_resume(struct usb_interface *intf)
 940 {
 941         struct phy_dev *phy_dev;
 942         struct lte_udev *udev;
 943         struct tx_cxt *tx;
 944         struct rx_cxt *rx;
 945         unsigned long flags;
 946         int issue_count;
 947         int i;
 948
 949         phy_dev = usb_get_intfdata(intf);
 950         udev = phy_dev->priv_dev;
 951         rx = &udev->rx;
 952
 953         if (udev->usb_state != PM_SUSPEND) {
 954                 dev_err(intf->usb_dev, "usb resume - invalid state\n");
 955                 return -1;
 956         }
 957         udev->usb_state = PM_NORMAL;
 958
 959         spin_lock_irqsave(&rx->rx_lock, flags);
 960         issue_count = rx->avail_count - MAX_RX_SUBMIT_COUNT;
 961         spin_unlock_irqrestore(&rx->rx_lock, flags);
 962
 963         if (issue_count >= 0) {
 964                 for (i = 0; i < issue_count; i++)
 965                         gdm_usb_recv(phy_dev->priv_dev,
 966                                      udev->rx_cb,
 967                                      phy_dev,
 968                                      USB_COMPLETE);
 969         }
 970
 971         tx = &udev->tx;
 972         spin_lock_irqsave(&tx->lock, flags);
 973         schedule_work(&udev->work_tx.work);
 974         spin_unlock_irqrestore(&tx->lock, flags);
 975
 976         return 0;
 977 }
 978
 979 static struct usb_driver gdm_usb_lte_driver = {
 980         .name = "gdm_lte",
 981         .probe = gdm_usb_probe,
 982         .disconnect = gdm_usb_disconnect,
 983         .id_table = id_table,
 984         .supports_autosuspend = 1,
 985         .suspend = gdm_usb_suspend,
 986         .resume = gdm_usb_resume,
 987         .reset_resume = gdm_usb_resume,
 988 };
 989
 990 static int __init gdm_usb_lte_init(void)
 991 {
 992         if (gdm_lte_event_init() < 0) {
 993                 pr_err("error creating event\n");
 994                 return -1;
 995         }
 996
 997         return usb_register(&gdm_usb_lte_driver);
 998 }
 999
1000 static void __exit gdm_usb_lte_exit(void)
1001 {
1002         gdm_lte_event_exit();
1003
1004         usb_deregister(&gdm_usb_lte_driver);
1005 }
1006
1007 module_init(gdm_usb_lte_init);
1008 module_exit(gdm_usb_lte_exit);
1009
1010 MODULE_VERSION(DRIVER_VERSION);
1011 MODULE_DESCRIPTION("GCT LTE USB Device Driver");
1012 MODULE_LICENSE("GPL");