drivers/usb/misc/mdm_ctrl_bridge.c

   1 /* Copyright (c) 2011-2012, Code Aurora Forum. All rights reserved.
   2  *
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License version 2 and
   5  * only version 2 as published by the Free Software Foundation.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  */
  12
  13 #include <linux/kernel.h>
  14 #include <linux/errno.h>
  15 #include <linux/init.h>
  16 #include <linux/slab.h>
  17 #include <linux/module.h>
  18 #include <linux/kref.h>
  19 #include <linux/debugfs.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/uaccess.h>
  22 #include <linux/ratelimit.h>
  23 #include <linux/usb/ch9.h>
  24 #include <linux/usb/cdc.h>
  25 #include <linux/termios.h>
  26 #include <asm/unaligned.h>
  27 #include <mach/usb_bridge.h>
  28 #include <linux/mdm_hsic_pm.h>
  29
  30 static const char const *ctrl_bridge_names[] = {
  31         "dun_ctrl_hsic0",
  32         "rmnet_ctrl_hsic0"
  33 };
  34
  35 /* polling interval for Interrupt ep */
  36 #define HS_INTERVAL             7
  37 #define FS_LS_INTERVAL          3
  38
  39 #define ACM_CTRL_DTR            (1 << 0)
  40 #define DEFAULT_READ_URB_LENGTH 4096
  41
  42 #define SUSPENDED               BIT(0)
  43
  44 struct ctrl_bridge {
  45         struct usb_device       *udev;
  46         struct usb_interface    *intf;
  47
  48         unsigned int            int_pipe;
  49         struct urb              *inturb;
  50         void                    *intbuf;
  51
  52         struct urb              *readurb;
  53         void                    *readbuf;
  54
  55         struct usb_anchor       tx_submitted;
  56         struct usb_anchor       tx_deferred;
  57         struct usb_ctrlrequest  *in_ctlreq;
  58
  59         struct bridge           *brdg;
  60         struct platform_device  *pdev;
  61
  62         unsigned long           flags;
  63
  64         /* input control lines (DSR, CTS, CD, RI) */
  65         unsigned int            cbits_tohost;
  66
  67         /* output control lines (DTR, RTS) */
  68         unsigned int            cbits_tomdm;
  69
  70         /* counters */
  71         unsigned int            snd_encap_cmd;
  72         unsigned int            get_encap_res;
  73         unsigned int            resp_avail;
  74         unsigned int            set_ctrl_line_sts;
  75         unsigned int            notify_ser_state;
  76 };
  77
  78 static struct ctrl_bridge       *__dev[MAX_BRIDGE_DEVICES];
  79
  80 /* counter used for indexing ctrl bridge devices */
  81 static int      ch_id;
  82
  83 unsigned int ctrl_bridge_get_cbits_tohost(unsigned int id)
  84 {
  85         struct ctrl_bridge      *dev;
  86
  87         if (id >= MAX_BRIDGE_DEVICES)
  88                 return -EINVAL;
  89
  90         dev = __dev[id];
  91         if (!dev)
  92                 return -ENODEV;
  93
  94         return dev->cbits_tohost;
  95 }
  96 EXPORT_SYMBOL(ctrl_bridge_get_cbits_tohost);
  97
  98 int ctrl_bridge_set_cbits(unsigned int id, unsigned int cbits)
  99 {
 100         struct ctrl_bridge      *dev;
 101         struct bridge           *brdg;
 102         int                     retval;
 103
 104         if (id >= MAX_BRIDGE_DEVICES)
 105                 return -EINVAL;
 106
 107         dev = __dev[id];
 108         if (!dev)
 109                 return -ENODEV;
 110
 111         pr_debug("%s: dev[id] =%u cbits : %u\n", __func__, id, cbits);
 112
 113         brdg = dev->brdg;
 114         if (!brdg)
 115                 return -ENODEV;
 116
 117         dev->cbits_tomdm = cbits;
 118
 119         retval = ctrl_bridge_write(id, NULL, 0);
 120
 121         /* if DTR is high, update latest modem info to host */
 122         if (brdg && (cbits & ACM_CTRL_DTR) && brdg->ops.send_cbits)
 123                 brdg->ops.send_cbits(brdg->ctx, dev->cbits_tohost);
 124
 125         return retval;
 126 }
 127 EXPORT_SYMBOL(ctrl_bridge_set_cbits);
 128
 129 static void resp_avail_cb(struct urb *urb)
 130 {
 131         struct ctrl_bridge      *dev = urb->context;
 132         struct usb_device       *udev;
 133         int                     status = 0;
 134         int                     resubmit_urb = 1;
 135         struct bridge           *brdg = dev->brdg;
 136         unsigned int            iface_num;
 137
 138         udev = interface_to_usbdev(dev->intf);
 139         iface_num = dev->intf->cur_altsetting->desc.bInterfaceNumber;
 140
 141         switch (urb->status) {
 142         case -ENOENT:
 143         case 0:
 144                 /*success*/
 145                 dev->get_encap_res++;
 146                 pr_info("[RACB:%d]<\n", iface_num);
 147                 if (brdg && brdg->ops.send_pkt)
 148                         brdg->ops.send_pkt(brdg->ctx, urb->transfer_buffer,
 149                                 urb->actual_length);
 150                 break;
 151
 152         /*do not resubmit*/
 153         case -ESHUTDOWN:
 154         case -ECONNRESET:
 155                 /* unplug */
 156         case -EPROTO:
 157                 /*babble error*/
 158                 resubmit_urb = 0;
 159         /*resubmit*/
 160         case -EOVERFLOW:
 161         default:
 162                 dev_dbg(&udev->dev, "%s: non zero urb status = %d\n",
 163                         __func__, urb->status);
 164         }
 165
 166         if (urb->status != -ENOENT && resubmit_urb) {
 167                 /*re- submit int urb to check response available*/
 168                 status = usb_submit_urb(dev->inturb, GFP_ATOMIC);
 169                 if (status) {
 170                         dev_err(&udev->dev,
 171                                 "%s: Error re-submitting Int URB %d\n",
 172                                 __func__, status);
 173                 }
 174                 pr_info("[CHKRA:%d]>\n", iface_num);
 175         }
 176 }
 177
 178 static void notification_available_cb(struct urb *urb)
 179 {
 180         int                             status;
 181         struct usb_cdc_notification     *ctrl;
 182         struct usb_device               *udev;
 183         struct ctrl_bridge              *dev = urb->context;
 184         struct bridge                   *brdg = dev->brdg;
 185         unsigned int                    ctrl_bits;
 186         unsigned char                   *data;
 187         unsigned int            iface_num;
 188
 189         /* if this intf is already disconnected, this urb free-ed before
 190          * calling from qh_completions. just return and do nothing */
 191         if (!dev->intf)
 192                 return;
 193
 194         udev = interface_to_usbdev(dev->intf);
 195         iface_num = dev->intf->cur_altsetting->desc.bInterfaceNumber;
 196
 197         switch (urb->status) {
 198         case 0:
 199                 pr_info("[NACB:%d]<\n", iface_num);
 200                 /*success*/
 201                 break;
 202         case -ESHUTDOWN:
 203         case -ENOENT:
 204         case -ECONNRESET:
 205         case -EPROTO:
 206                  /* unplug */
 207                  return;
 208         case -EPIPE:
 209                 dev_err(&udev->dev, "%s: stall on int endpoint\n", __func__);
 210                 /* TBD : halt to be cleared in work */
 211         case -EOVERFLOW:
 212         default:
 213                 pr_debug_ratelimited("%s: non zero urb status = %d\n",
 214                                         __func__, urb->status);
 215                 goto resubmit_int_urb;
 216         }
 217
 218         ctrl = (struct usb_cdc_notification *)urb->transfer_buffer;
 219         data = (unsigned char *)(ctrl + 1);
 220
 221         switch (ctrl->bNotificationType) {
 222         case USB_CDC_NOTIFY_RESPONSE_AVAILABLE:
 223                 dev->resp_avail++;
 224                 usb_fill_control_urb(dev->readurb, udev,
 225                                         usb_rcvctrlpipe(udev, 0),
 226                                         (unsigned char *)dev->in_ctlreq,
 227                                         dev->readbuf,
 228                                         DEFAULT_READ_URB_LENGTH,
 229                                         resp_avail_cb, dev);
 230
 231                 status = usb_submit_urb(dev->readurb, GFP_ATOMIC);
 232                 if (status) {
 233                         dev_err(&udev->dev,
 234                                 "%s: Error submitting Read URB %d\n",
 235                                 __func__, status);
 236                         goto resubmit_int_urb;
 237                 } else
 238                         pr_info("[NRA:%d]>\n", iface_num);
 239                 return;
 240         case USB_CDC_NOTIFY_NETWORK_CONNECTION:
 241                 dev_dbg(&udev->dev, "%s network\n", ctrl->wValue ?
 242                                         "connected to" : "disconnected from");
 243                 break;
 244         case USB_CDC_NOTIFY_SERIAL_STATE:
 245                 dev->notify_ser_state++;
 246                 ctrl_bits = get_unaligned_le16(data);
 247                 dev_dbg(&udev->dev, "serial state: %d\n", ctrl_bits);
 248                 dev->cbits_tohost = ctrl_bits;
 249                 if (brdg && brdg->ops.send_cbits)
 250                         brdg->ops.send_cbits(brdg->ctx, ctrl_bits);
 251                 break;
 252         default:
 253                 dev_err(&udev->dev, "%s: unknown notification %d received:"
 254                         "index %d len %d data0 %d data1 %d",
 255                         __func__, ctrl->bNotificationType, ctrl->wIndex,
 256                         ctrl->wLength, data[0], data[1]);
 257         }
 258
 259 resubmit_int_urb:
 260         status = usb_submit_urb(urb, GFP_ATOMIC);
 261         if (status) {
 262                 dev_err(&udev->dev, "%s: Error re-submitting Int URB %d\n",
 263                 __func__, status);
 264         } else
 265                 pr_info("[CHKRA:%d]>\n", iface_num);
 266 }
 267
 268 int ctrl_bridge_start_read(struct ctrl_bridge *dev)
 269 {
 270         int                     retval = 0;
 271         struct usb_device       *udev;
 272         unsigned int            iface_num;
 273
 274         udev = interface_to_usbdev(dev->intf);
 275         iface_num = dev->intf->cur_altsetting->desc.bInterfaceNumber;
 276
 277         if (!dev->inturb) {
 278                 dev_err(&dev->udev->dev, "%s: inturb is NULL\n", __func__);
 279                 return -ENODEV;
 280         }
 281
 282         retval = usb_submit_urb(dev->inturb, GFP_KERNEL);
 283         if (retval < 0) {
 284                 dev_err(&dev->udev->dev,
 285                         "%s error submitting int urb %d\n",
 286                         __func__, retval);
 287
 288         } else
 289                 pr_info("[CHKRA:%d]>\n", iface_num);
 290
 291         return retval;
 292 }
 293
 294 void ctrl_bridge_stop_read(struct ctrl_bridge *dev)
 295 {
 296         usb_kill_urb(dev->readurb);
 297         usb_kill_urb(dev->inturb);
 298 }
 299
 300 void ctrl_bridge_stop_all(void)
 301 {
 302         int id;
 303
 304         for (id = 0; id < MAX_BRIDGE_DEVICES; id++) {
 305                 if (__dev[id])
 306                         ctrl_bridge_stop_read(__dev[id]);
 307         }
 308 }
 309 EXPORT_SYMBOL(ctrl_bridge_stop_all);
 310
 311 int ctrl_bridge_open(struct bridge *brdg)
 312 {
 313         struct ctrl_bridge      *dev;
 314         int                     ret;
 315
 316         if (!brdg) {
 317                 err("bridge is null\n");
 318                 return -EINVAL;
 319         }
 320
 321         if (brdg->ch_id >= MAX_BRIDGE_DEVICES)
 322                 return -EINVAL;
 323
 324         dev = __dev[brdg->ch_id];
 325         if (!dev) {
 326                 err("dev is null\n");
 327                 return -ENODEV;
 328         }
 329
 330         dev->brdg = brdg;
 331         dev->snd_encap_cmd = 0;
 332         dev->get_encap_res = 0;
 333         dev->resp_avail = 0;
 334         dev->set_ctrl_line_sts = 0;
 335         dev->notify_ser_state = 0;
 336
 337         ret = usb_autopm_get_interface(dev->intf);
 338         if (ret < 0) {
 339                 dev_err(&dev->udev->dev, "%s autopm_get fail: %d\n",
 340                         __func__, ret);
 341                 return ret;
 342         }
 343
 344         ret = ctrl_bridge_start_read(dev);
 345         usb_autopm_put_interface(dev->intf);
 346         return ret;
 347 }
 348 EXPORT_SYMBOL(ctrl_bridge_open);
 349
 350 void ctrl_bridge_close(unsigned int id)
 351 {
 352         struct ctrl_bridge      *dev;
 353
 354         if (id >= MAX_BRIDGE_DEVICES)
 355                 return;
 356
 357         dev  = __dev[id];
 358         if (!dev || !dev->brdg)
 359                 return;
 360
 361         dev_dbg(&dev->udev->dev, "%s:\n", __func__);
 362
 363         ctrl_bridge_set_cbits(dev->brdg->ch_id, 0);
 364         usb_unlink_anchored_urbs(&dev->tx_submitted);
 365
 366         dev->brdg = NULL;
 367 }
 368 EXPORT_SYMBOL(ctrl_bridge_close);
 369
 370 static void ctrl_write_callback(struct urb *urb)
 371 {
 372         struct ctrl_bridge      *dev = urb->context;
 373
 374         if (urb->status) {
 375                 pr_debug("Write status/size %d/%d\n",
 376                         urb->status, urb->actual_length);
 377         }
 378
 379         kfree(urb->transfer_buffer);
 380         kfree(urb->setup_packet);
 381         usb_free_urb(urb);
 382         usb_autopm_put_interface_async(dev->intf);
 383 }
 384
 385 int ctrl_bridge_write(unsigned int id, char *data, size_t size)
 386 {
 387         int                     result;
 388         struct urb              *writeurb;
 389         struct usb_ctrlrequest  *out_ctlreq;
 390         struct usb_device       *udev;
 391         struct ctrl_bridge      *dev;
 392
 393         if (id >= MAX_BRIDGE_DEVICES) {
 394                 result = -EINVAL;
 395                 goto free_data;
 396         }
 397
 398         dev = __dev[id];
 399
 400         if (!dev) {
 401                 result = -ENODEV;
 402                 goto free_data;
 403         }
 404
 405         udev = interface_to_usbdev(dev->intf);
 406
 407         dev_dbg(&udev->dev, "%s:[id]:%u: write (%d bytes)\n",
 408                 __func__, id, size);
 409
 410         writeurb = usb_alloc_urb(0, GFP_ATOMIC);
 411         if (!writeurb) {
 412                 dev_err(&udev->dev, "%s: error allocating read urb\n",
 413                         __func__);
 414                 result = -ENOMEM;
 415                 goto free_data;
 416         }
 417
 418         out_ctlreq = kmalloc(sizeof(*out_ctlreq), GFP_ATOMIC);
 419         if (!out_ctlreq) {
 420                 dev_err(&udev->dev,
 421                         "%s: error allocating setup packet buffer\n",
 422                         __func__);
 423                 result = -ENOMEM;
 424                 goto free_urb;
 425         }
 426
 427         /* CDC Send Encapsulated Request packet */
 428         out_ctlreq->bRequestType = (USB_DIR_OUT | USB_TYPE_CLASS |
 429                                  USB_RECIP_INTERFACE);
 430         if (!data && !size) {
 431                 out_ctlreq->bRequest = USB_CDC_REQ_SET_CONTROL_LINE_STATE;
 432                 out_ctlreq->wValue = dev->cbits_tomdm;
 433                 dev->set_ctrl_line_sts++;
 434         } else {
 435                 out_ctlreq->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;
 436                 out_ctlreq->wValue = 0;
 437                 dev->snd_encap_cmd++;
 438         }
 439         out_ctlreq->wIndex =
 440                 dev->intf->cur_altsetting->desc.bInterfaceNumber;
 441         out_ctlreq->wLength = cpu_to_le16(size);
 442
 443         usb_fill_control_urb(writeurb, udev,
 444                                  usb_sndctrlpipe(udev, 0),
 445                                  (unsigned char *)out_ctlreq,
 446                                  (void *)data, size,
 447                                  ctrl_write_callback, dev);
 448
 449         result = usb_autopm_get_interface_async(dev->intf);
 450         if (result < 0) {
 451                 dev_err(&udev->dev, "%s: unable to resume interface: %d\n",
 452                         __func__, result);
 453
 454                 /*
 455                   * Revisit: if (result == -EPERM)
 456                   * bridge_suspend(dev->intf, PMSG_SUSPEND);
 457                   */
 458
 459                 goto free_ctrlreq;
 460         }
 461
 462         if (test_bit(SUSPENDED, &dev->flags)) {
 463                 usb_anchor_urb(writeurb, &dev->tx_deferred);
 464                 goto deferred;
 465         }
 466
 467         usb_anchor_urb(writeurb, &dev->tx_submitted);
 468         result = usb_submit_urb(writeurb, GFP_ATOMIC);
 469         if (result < 0) {
 470                 dev_err(&udev->dev, "%s: submit URB error %d\n",
 471                         __func__, result);
 472                 usb_autopm_put_interface_async(dev->intf);
 473                 goto unanchor_urb;
 474         }
 475 deferred:
 476         return size;
 477
 478 unanchor_urb:
 479         usb_unanchor_urb(writeurb);
 480 free_ctrlreq:
 481         kfree(out_ctlreq);
 482 free_urb:
 483         usb_free_urb(writeurb);
 484 free_data:
 485         kfree(data);
 486
 487         return result;
 488 }
 489 EXPORT_SYMBOL(ctrl_bridge_write);
 490
 491 int ctrl_bridge_suspend(unsigned int id)
 492 {
 493         struct ctrl_bridge      *dev;
 494
 495         if (id >= MAX_BRIDGE_DEVICES)
 496                 return -EINVAL;
 497
 498         dev = __dev[id];
 499         if (!dev)
 500                 return -ENODEV;
 501
 502         set_bit(SUSPENDED, &dev->flags);
 503         usb_kill_anchored_urbs(&dev->tx_submitted);
 504         ctrl_bridge_stop_read(dev);
 505
 506         return 0;
 507 }
 508
 509 int ctrl_bridge_resume(unsigned int id)
 510 {
 511         struct ctrl_bridge      *dev;
 512         struct urb              *urb;
 513
 514         if (id >= MAX_BRIDGE_DEVICES)
 515                 return -EINVAL;
 516
 517         dev = __dev[id];
 518         if (!dev)
 519                 return -ENODEV;
 520
 521         if (!test_and_clear_bit(SUSPENDED, &dev->flags))
 522                 return 0;
 523
 524         /* submit pending write requests */
 525         while ((urb = usb_get_from_anchor(&dev->tx_deferred))) {
 526                 int ret;
 527                 usb_anchor_urb(urb, &dev->tx_submitted);
 528                 ret = usb_submit_urb(urb, GFP_ATOMIC);
 529                 if (ret < 0) {
 530                         usb_unanchor_urb(urb);
 531                         kfree(urb->setup_packet);
 532                         kfree(urb->transfer_buffer);
 533                         usb_free_urb(urb);
 534                         usb_autopm_put_interface_async(dev->intf);
 535                 }
 536         }
 537
 538         /* if the bridge is open, resume reading */
 539 #ifndef CONFIG_MDM_HSIC_PM
 540         if (dev->brdg)
 541                 return ctrl_bridge_start_read(dev);
 542 #else
 543         /* if the bridge is open or not, resume to consume mdm request
 544          * because this link is not dead, it's alive
 545          */
 546         return ctrl_bridge_start_read(dev);
 547 #endif
 548         return 0;
 549 }
 550
 551 #if defined(CONFIG_DEBUG_FS)
 552 #define DEBUG_BUF_SIZE  1024
 553 static ssize_t ctrl_bridge_read_stats(struct file *file, char __user *ubuf,
 554                 size_t count, loff_t *ppos)
 555 {
 556         struct ctrl_bridge      *dev;
 557         char                    *buf;
 558         int                     ret;
 559         int                     i;
 560         int                     temp = 0;
 561
 562         buf = kzalloc(sizeof(char) * DEBUG_BUF_SIZE, GFP_KERNEL);
 563         if (!buf)
 564                 return -ENOMEM;
 565
 566         for (i = 0; i < ch_id; i++) {
 567                 dev = __dev[i];
 568                 if (!dev)
 569                         continue;
 570
 571                 temp += scnprintf(buf + temp, DEBUG_BUF_SIZE - temp,
 572                                 "\nName#%s dev %p\n"
 573                                 "snd encap cmd cnt: %u\n"
 574                                 "get encap res cnt: %u\n"
 575                                 "res available cnt: %u\n"
 576                                 "set ctrlline sts cnt: %u\n"
 577                                 "notify ser state cnt: %u\n"
 578                                 "cbits_tomdm: %d\n"
 579                                 "cbits_tohost: %d\n"
 580                                 "suspended: %d\n",
 581                                 dev->pdev->name, dev,
 582                                 dev->snd_encap_cmd,
 583                                 dev->get_encap_res,
 584                                 dev->resp_avail,
 585                                 dev->set_ctrl_line_sts,
 586                                 dev->notify_ser_state,
 587                                 dev->cbits_tomdm,
 588                                 dev->cbits_tohost,
 589                                 test_bit(SUSPENDED, &dev->flags));
 590         }
 591
 592         ret = simple_read_from_buffer(ubuf, count, ppos, buf, temp);
 593
 594         kfree(buf);
 595
 596         return ret;
 597 }
 598
 599 static ssize_t ctrl_bridge_reset_stats(struct file *file,
 600         const char __user *buf, size_t count, loff_t *ppos)
 601 {
 602         struct ctrl_bridge      *dev;
 603         int                     i;
 604
 605         for (i = 0; i < ch_id; i++) {
 606                 dev = __dev[i];
 607                 if (!dev)
 608                         continue;
 609
 610                 dev->snd_encap_cmd = 0;
 611                 dev->get_encap_res = 0;
 612                 dev->resp_avail = 0;
 613                 dev->set_ctrl_line_sts = 0;
 614                 dev->notify_ser_state = 0;
 615         }
 616         return count;
 617 }
 618
 619 const struct file_operations ctrl_stats_ops = {
 620         .read = ctrl_bridge_read_stats,
 621         .write = ctrl_bridge_reset_stats,
 622 };
 623
 624 struct dentry   *ctrl_dent;
 625 struct dentry   *ctrl_dfile;
 626 static void ctrl_bridge_debugfs_init(void)
 627 {
 628         ctrl_dent = debugfs_create_dir("ctrl_hsic_bridge", 0);
 629         if (IS_ERR(ctrl_dent))
 630                 return;
 631
 632         ctrl_dfile =
 633                 debugfs_create_file("status", 0644, ctrl_dent, 0,
 634                         &ctrl_stats_ops);
 635         if (!ctrl_dfile || IS_ERR(ctrl_dfile))
 636                 debugfs_remove(ctrl_dent);
 637 }
 638
 639 static void ctrl_bridge_debugfs_exit(void)
 640 {
 641         debugfs_remove(ctrl_dfile);
 642         debugfs_remove(ctrl_dent);
 643 }
 644
 645 #else
 646 static void ctrl_bridge_debugfs_init(void) { }
 647 static void ctrl_bridge_debugfs_exit(void) { }
 648 #endif
 649
 650 int
 651 ctrl_bridge_probe(struct usb_interface *ifc, struct usb_host_endpoint *int_in,
 652                 int id)
 653 {
 654         struct ctrl_bridge              *dev;
 655         struct usb_device               *udev;
 656         struct usb_endpoint_descriptor  *ep;
 657         u16                             wMaxPacketSize;
 658         int                             retval = 0;
 659         int                             interval;
 660
 661         udev = interface_to_usbdev(ifc);
 662
 663         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 664         if (!dev) {
 665                 dev_err(&udev->dev, "%s: unable to allocate dev\n",
 666                         __func__);
 667                 return -ENOMEM;
 668         }
 669         dev->pdev = platform_device_alloc(ctrl_bridge_names[id], id);
 670         if (!dev->pdev) {
 671                 dev_err(&dev->udev->dev,
 672                         "%s: unable to allocate platform device\n", __func__);
 673                 retval = -ENOMEM;
 674                 goto nomem;
 675         }
 676
 677         dev->udev = udev;
 678         dev->int_pipe = usb_rcvintpipe(udev,
 679                 int_in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
 680         dev->intf = ifc;
 681
 682         init_usb_anchor(&dev->tx_submitted);
 683         init_usb_anchor(&dev->tx_deferred);
 684
 685         /*use max pkt size from ep desc*/
 686         ep = &dev->intf->cur_altsetting->endpoint[0].desc;
 687
 688         dev->inturb = usb_alloc_urb(0, GFP_KERNEL);
 689         if (!dev->inturb) {
 690                 dev_err(&udev->dev, "%s: error allocating int urb\n", __func__);
 691                 retval = -ENOMEM;
 692                 goto pdev_del;
 693         }
 694
 695         wMaxPacketSize = le16_to_cpu(ep->wMaxPacketSize);
 696
 697         dev->intbuf = kmalloc(wMaxPacketSize, GFP_KERNEL);
 698         if (!dev->intbuf) {
 699                 dev_err(&udev->dev, "%s: error allocating int buffer\n",
 700                         __func__);
 701                 retval = -ENOMEM;
 702                 goto free_inturb;
 703         }
 704
 705         interval =
 706                 (udev->speed == USB_SPEED_HIGH) ? HS_INTERVAL : FS_LS_INTERVAL;
 707
 708         usb_fill_int_urb(dev->inturb, udev, dev->int_pipe,
 709                                 dev->intbuf, wMaxPacketSize,
 710                                 notification_available_cb, dev, interval);
 711
 712         dev->readurb = usb_alloc_urb(0, GFP_KERNEL);
 713         if (!dev->readurb) {
 714                 dev_err(&udev->dev, "%s: error allocating read urb\n",
 715                         __func__);
 716                 retval = -ENOMEM;
 717                 goto free_intbuf;
 718         }
 719
 720         dev->readbuf = kmalloc(DEFAULT_READ_URB_LENGTH, GFP_KERNEL);
 721         if (!dev->readbuf) {
 722                 dev_err(&udev->dev, "%s: error allocating read buffer\n",
 723                         __func__);
 724                 retval = -ENOMEM;
 725                 goto free_rurb;
 726         }
 727
 728         dev->in_ctlreq = kmalloc(sizeof(*dev->in_ctlreq), GFP_KERNEL);
 729         if (!dev->in_ctlreq) {
 730                 dev_err(&udev->dev,
 731                         "%s:error allocating setup packet buffer\n",
 732                         __func__);
 733                 retval = -ENOMEM;
 734                 goto free_rbuf;
 735         }
 736
 737         dev->in_ctlreq->bRequestType =
 738                         (USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE);
 739         dev->in_ctlreq->bRequest  = USB_CDC_GET_ENCAPSULATED_RESPONSE;
 740         dev->in_ctlreq->wValue = 0;
 741         dev->in_ctlreq->wIndex =
 742                 dev->intf->cur_altsetting->desc.bInterfaceNumber;
 743         dev->in_ctlreq->wLength = cpu_to_le16(DEFAULT_READ_URB_LENGTH);
 744
 745         __dev[id] = dev;
 746
 747         platform_device_add(dev->pdev);
 748
 749         ch_id++;
 750
 751 #ifdef CONFIG_MDM_HSIC_PM
 752         /* if the bridge is open or not, resume to consume mdm request
 753          * because this link is not dead, it's alive
 754          */
 755         ctrl_bridge_start_read(dev);
 756 #endif
 757         return retval;
 758
 759 free_rbuf:
 760         kfree(dev->readbuf);
 761 free_rurb:
 762         usb_free_urb(dev->readurb);
 763 free_intbuf:
 764         kfree(dev->intbuf);
 765 free_inturb:
 766         usb_free_urb(dev->inturb);
 767 pdev_del:
 768         platform_device_del(dev->pdev);
 769 nomem:
 770         kfree(dev);
 771
 772         return retval;
 773 }
 774
 775 void ctrl_bridge_disconnect(unsigned int id)
 776 {
 777         struct ctrl_bridge      *dev = __dev[id];
 778
 779         dev_dbg(&dev->udev->dev, "%s:\n", __func__);
 780
 781         platform_device_del(dev->pdev);
 782
 783         dev->intf = NULL;
 784         usb_kill_urb(dev->readurb);
 785         usb_kill_urb(dev->inturb);
 786
 787         kfree(dev->in_ctlreq);
 788         kfree(dev->readbuf);
 789         kfree(dev->intbuf);
 790
 791         usb_free_urb(dev->readurb);
 792         usb_free_urb(dev->inturb);
 793
 794         __dev[id] = NULL;
 795         ch_id--;
 796
 797         kfree(dev);
 798 }
 799
 800 static int __init ctrl_bridge_init(void)
 801 {
 802         ctrl_bridge_debugfs_init();
 803
 804         return 0;
 805 }
 806 module_init(ctrl_bridge_init);
 807
 808 static void __exit ctrl_bridge_exit(void)
 809 {
 810         ctrl_bridge_debugfs_exit();
 811 }
 812 module_exit(ctrl_bridge_exit);
 813
 814 MODULE_DESCRIPTION("Qualcomm modem control bridge driver");
 815 MODULE_LICENSE("GPL v2");