CHROMIUM: gobi: resubmit interrupt urb on failed reads

drivers/net/usb/gobi/qmidevice.c

 /* qmidevice.c - gobi QMI device
  * Copyright (c) 2010, Code Aurora Forum. All rights reserved.
 
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
  * only version 2 as published by the Free Software Foundation.
 
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
@@ skipping 50 matching lines @@
 static struct client *client_bycid(struct qcusbnet *dev, u16 cid);
 static bool client_addread(struct qcusbnet *dev, u16 cid, u16 tid, void *data, u16 size);
 static bool client_delread(struct qcusbnet *dev, u16 cid, u16 tid, void **data, u16 *size);
 static bool client_addnotify(struct qcusbnet *dev, u16 cid, u16 tid,
                              void (*hook)(struct qcusbnet *, u16 cid, void *),
                              void *data);
 static bool client_notify(struct qcusbnet *dev, u16 cid, u16 tid);
 static bool client_addurb(struct qcusbnet *dev, u16 cid, struct urb *urb);
 static struct urb *client_delurb(struct qcusbnet *dev, u16 cid);
 
+static int resubmit_int_urb(struct urb *urb);
+
 static int devqmi_open(struct inode *inode, struct file *file);
 static int devqmi_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
 static int devqmi_release(struct inode *inode, struct file *file);
 static ssize_t devqmi_read(struct file *file, char __user *buf, size_t size,
                            loff_t *pos);
 static ssize_t devqmi_write(struct file *file, const char __user *buf,
                             size_t size, loff_t *pos);
 
 static bool qmi_ready(struct qcusbnet *dev, u16 timeout);
 static void wds_callback(struct qcusbnet *dev, u16 cid, void *data);
@@ skipping 44 matching lines @@
         clear_bit(reason, &dev->down);
         if (!dev->down)
                 netif_carrier_on(dev->usbnet->net);
 }
 
 bool qc_isdown(struct qcusbnet *dev, u8 reason)
 {
         return test_bit(reason, &dev->down);
 }
 
+static int resubmit_int_urb(struct urb *urb)
+{
+        int status;
+        int interval;
+        if (!urb || !urb->dev)
+                return -EINVAL;
+        interval = urb->dev->speed == USB_SPEED_HIGH ? 7 : 3;
+        usb_fill_int_urb(urb, urb->dev, urb->pipe, urb->transfer_buffer,
+                         urb->transfer_buffer_length, urb->complete,
+                         urb->context, interval);
+        status = usb_submit_urb(urb, GFP_ATOMIC);
+        if (status)
+                DBG("status %d", status);
+        return status;
+}
+
 static void read_callback(struct urb *urb)
 {
         struct list_head *node;
         int result;
         u16 cid;
         struct client *client;
         void *data;
         void *copy;
         u16 size;
         struct qcusbnet *dev;
         unsigned long flags;
         u16 tid;
 
         if (!urb) {
                 DBG("bad read URB\n");
                 return;
         }
 
         dev = urb->context;
         if (!device_valid(dev)) {
                 DBG("Invalid device!\n");
                 return;
         }
 
         if (urb->status) {
                 DBG("Read status = %d\n", urb->status);
+                resubmit_int_urb(dev->qmi.inturb);
                 return;
         }
 
         DBG("Read %d bytes\n", urb->actual_length);
 
         data = urb->transfer_buffer;
         size = urb->actual_length;
 
         if (qcusbnet_debug)
                 print_hex_dump(KERN_INFO, "gobi-read: ", DUMP_PREFIX_OFFSET,
                                16, 1, data, size, true);
 
         result = qmux_parse(&cid, data, size);
         if (result < 0) {
                 DBG("Read error parsing QMUX %d\n", result);
+                resubmit_int_urb(dev->qmi.inturb);
                 return;
         }
 
         if (size < result + 3) {
                 DBG("Data buffer too small to parse\n");
+                resubmit_int_urb(dev->qmi.inturb);
                 return;
         }
 
         if (cid == QMICTL)
                 tid = *(u8 *)(data + result + 1);
         else
                 tid = *(u16 *)(data + result + 1);
         spin_lock_irqsave(&dev->qmi.clients_lock, flags);
 
         list_for_each(node, &dev->qmi.clients) {
                 client = list_entry(node, struct client, node);
                 if (client->cid == cid || (client->cid | 0xff00) == cid) {
                         copy = kmalloc(size, GFP_ATOMIC);
                         memcpy(copy, data, size);
                         if (!client_addread(dev, client->cid, tid, copy, size)) {
                                 DBG("Error allocating pReadMemListEntry "
                                           "read will be discarded\n");
                                 kfree(copy);
                                 spin_unlock_irqrestore(&dev->qmi.clients_lock, flags);
+                                resubmit_int_urb(dev->qmi.inturb);
                                 return;
                         }
 
                         DBG("Creating new readListEntry for client 0x%04X, TID %x\n",
                             cid, tid);
 
                         client_notify(dev, client->cid, tid);
 
                         if (cid >> 8 != 0xff)
                                 break;
                 }
         }
 
         spin_unlock_irqrestore(&dev->qmi.clients_lock, flags);
+        resubmit_int_urb(dev->qmi.inturb);
 }
 
 static void int_callback(struct urb *urb)
 {
         int status;
         int interval;
         struct qcusbnet *dev = (struct qcusbnet *)urb->context;
 
         if (!device_valid(dev)) {
                 DBG("Invalid device!\n");
@@ skipping 33 matching lines @@
                 } else {
                         DBG("ignoring invalid interrupt in packet\n");
                         if (qcusbnet_debug)
                                 print_hex_dump(KERN_INFO, "gobi-int: ",
                                                DUMP_PREFIX_OFFSET, 16, 1,
                                                urb->transfer_buffer,
                                                urb->actual_length, true);
                 }
         }
 
-        interval = (dev->usbnet->udev->speed == USB_SPEED_HIGH) ? 7 : 3;
-
-        usb_fill_int_urb(urb, urb->dev, urb->pipe, urb->transfer_buffer,
-                         urb->transfer_buffer_length, urb->complete,
-                         urb->context, interval);
-        status = usb_submit_urb(urb, GFP_ATOMIC);
-        if (status)
-                DBG("Error re-submitting Int URB %d\n", status);
+        resubmit_int_urb(dev->qmi.inturb);
         return;
 }
 
 int qc_startread(struct qcusbnet *dev)
 {
         int interval;
 
         if (!device_valid(dev)) {
                 DBG("Invalid device!\n");
                 return -ENXIO;
@@ skipping 1252 matching lines @@
                 DBG("bad get MEID resp\n");
                 memset(&dev->meid[0], '0', 14);
         }
 
         client_free(dev, cid);
         return 0;
 }
 
 module_param(qcusbnet2k_fwdelay, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(qcusbnet2k_fwdelay, "Delay for old firmware");