CHROMIUM: gobi: Remove worker.exit hack.

drivers/net/usb/gobi/qcusbnet.c

 /* qcusbnet.c - gobi network device
  * Copyright (c) 2011, 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 @@
                 if (entry == key) {
                         kref_get(&entry->refcount);
                         mutex_unlock(&qcusbnet_lock);
                         return entry;
                 }
         }
         mutex_unlock(&qcusbnet_lock);
         return NULL;
 }
 
+static void wake_worker(struct worker *worker)
+{
+        atomic_inc(&worker->work_count);
+        wake_up(&worker->waitq);
+}
+
 int qc_suspend(struct usb_interface *iface, pm_message_t event)
 {
         struct usbnet *usbnet;
         struct qcusbnet *dev;
 
         if (!iface)
                 return -ENOMEM;
 
         usbnet = usb_get_intfdata(iface);
 
@@ skipping 62 matching lines @@
                         DBG("usbnet_resume error %d\n", ret);
                         return ret;
                 }
 
                 ret = qc_startread(dev);
                 if (ret) {
                         DBG("qc_startread error %d\n", ret);
                         return ret;
                 }
 
-                complete(&dev->worker.work);
+                wake_worker(&dev->worker);
         } else {
                 DBG("nothing to resume\n");
                 return 0;
         }
 
         return ret;
 }
 
 static int qcnet_bind(struct usbnet *usbnet, struct usb_interface *iface)
 {
@@ skipping 75 matching lines @@
         }
 
         if (urb->status) {
                 DBG("urb finished with error %d\n", urb->status);
         }
 
         spin_lock_irqsave(&worker->active_lock, flags);
         worker->active = ERR_PTR(-EAGAIN);
         spin_unlock_irqrestore(&worker->active_lock, flags);
         /* XXX-fix race against qcnet_stop()? */
-        complete(&worker->work);
+        wake_worker(worker);
         usb_free_urb(urb);
 }
 
 static void qcnet_txtimeout(struct net_device *netdev)
 {
         struct list_head *node, *tmp;
         struct qcusbnet *dev;
         struct worker *worker;
         struct urbreq *req;
         unsigned long activeflags, listflags;
@@ skipping 20 matching lines @@
 
         spin_lock_irqsave(&worker->urbs_lock, listflags);
         list_for_each_safe(node, tmp, &worker->urbs) {
                 req = list_entry(node, struct urbreq, node);
                 usb_free_urb(req->urb);
                 list_del(&req->node);
                 kfree(req);
         }
         spin_unlock_irqrestore(&worker->urbs_lock, listflags);
 
-        complete(&worker->work);
+        wake_worker(worker);
+}
+
+static int worker_should_wake(struct worker *worker)
+{
+        if (kthread_should_stop())
+                return 1;
+        /* This is safe only because we are the only place that decrements this
+         * counter. */
+        if (atomic_read(&worker->work_count))
+                return 1;
+        return 0;
 }
 
 static int qcnet_worker(void *arg)
 {
         struct list_head *node, *tmp;
         unsigned long activeflags, listflags;
         struct urbreq *req;
         int status;
         struct usb_device *usbdev;
         struct worker *worker = arg;
         if (!worker) {
                 DBG("passed null pointer\n");
                 return -EINVAL;
         }
 
         usbdev = interface_to_usbdev(worker->iface);
 
         DBG("traffic thread started\n");
 
-        while (!worker->exit && !kthread_should_stop()) {
-                wait_for_completion_interruptible(&worker->work);
+        while (!kthread_should_stop()) {
+                wait_event(worker->waitq, worker_should_wake(worker));
 
-                if (worker->exit || kthread_should_stop()) {
-                        spin_lock_irqsave(&worker->active_lock, activeflags);
-                        if (worker->active) {
-                                usb_kill_urb(worker->active);
-                        }
-                        spin_unlock_irqrestore(&worker->active_lock, activeflags);
-
-                        spin_lock_irqsave(&worker->urbs_lock, listflags);
-                        list_for_each_safe(node, tmp, &worker->urbs) {
-                                req = list_entry(node, struct urbreq, node);
-                                usb_free_urb(req->urb);
-                                list_del(&req->node);
-                                kfree(req);
-                        }
-                        spin_unlock_irqrestore(&worker->urbs_lock, listflags);
-
+                if (kthread_should_stop())
                         break;
-                }
+                atomic_dec(&worker->work_count);
 
                 spin_lock_irqsave(&worker->active_lock, activeflags);
                 if (IS_ERR(worker->active) && PTR_ERR(worker->active) == -EAGAIN) {
                         worker->active = NULL;
                         spin_unlock_irqrestore(&worker->active_lock, activeflags);
                         usb_autopm_put_interface(worker->iface);
                         spin_lock_irqsave(&worker->active_lock, activeflags);
                 }
 
                 if (worker->active) {
@@ skipping 34 matching lines @@
                 }
 
                 status = usb_submit_urb(worker->active, GFP_KERNEL);
                 if (status < 0) {
                         DBG("Failed to submit URB: %d.  Packet dropped\n", status);
                         spin_lock_irqsave(&worker->active_lock, activeflags);
                         usb_free_urb(worker->active);
                         worker->active = NULL;
                         spin_unlock_irqrestore(&worker->active_lock, activeflags);
                         usb_autopm_put_interface(worker->iface);
-                        complete(&worker->work);
+                        wake_worker(worker);
                 }
 
                 kfree(req);
         }
 
+        spin_lock_irqsave(&worker->active_lock, activeflags);
+        if (worker->active) {
+                usb_kill_urb(worker->active);
+        }
+        spin_unlock_irqrestore(&worker->active_lock, activeflags);
+
+        spin_lock_irqsave(&worker->urbs_lock, listflags);
+        list_for_each_safe(node, tmp, &worker->urbs) {
+                req = list_entry(node, struct urbreq, node);
+                usb_free_urb(req->urb);
+                list_del(&req->node);
+                kfree(req);
+        }
+        spin_unlock_irqrestore(&worker->urbs_lock, listflags);
+
         DBG("traffic thread exiting\n");
         worker->thread = NULL;
         return 0;
 }
 
 static int qcnet_startxmit(struct sk_buff *skb, struct net_device *netdev)
 {
         unsigned long listflags;
         struct qcusbnet *dev;
         struct worker *worker;
@@ skipping 44 matching lines @@
         }
         memcpy(data, skb->data, skb->len);
 
         usb_fill_bulk_urb(req->urb, dev->usbnet->udev, dev->usbnet->out,
                           data, skb->len, qcnet_urbhook, worker);
 
         spin_lock_irqsave(&worker->urbs_lock, listflags);
         list_add_tail(&req->node, &worker->urbs);
         spin_unlock_irqrestore(&worker->urbs_lock, listflags);
 
-        complete(&worker->work);
+        wake_worker(worker);
 
         netdev->trans_start = jiffies;
         dev_kfree_skb_any(skb);
 
         return NETDEV_TX_OK;
 }
 
 static int qcnet_open(struct net_device *netdev)
 {
         int status = 0;
@@ skipping 11 matching lines @@
                 return -ENXIO;
         }
 
         DBG("\n");
 
         dev->worker.iface = dev->iface;
         INIT_LIST_HEAD(&dev->worker.urbs);
         dev->worker.active = NULL;
         spin_lock_init(&dev->worker.urbs_lock);
         spin_lock_init(&dev->worker.active_lock);
-        init_completion(&dev->worker.work);
+        atomic_set(&dev->worker.work_count, 0);
+        init_waitqueue_head(&dev->worker.waitq);
 
-        dev->worker.exit = 0;
         dev->worker.thread = kthread_run(qcnet_worker, &dev->worker, "qcnet_worker");
         if (IS_ERR(dev->worker.thread)) {
                 DBG("AutoPM thread creation error\n");
                 return PTR_ERR(dev->worker.thread);
         }
 
         qc_cleardown(dev, DOWN_NET_IFACE_STOPPED);
         if (dev->open) {
                 status = dev->open(netdev);
                 if (status == 0) {
@@ skipping 16 matching lines @@
                 return -ENXIO;
         }
 
         dev = (struct qcusbnet *)usbnet->data[0];
         if (!dev) {
                 DBG("failed to get QMIDevice\n");
                 return -ENXIO;
         }
 
         qc_setdown(dev, DOWN_NET_IFACE_STOPPED);
-        dev->worker.exit = 1;
-        complete(&dev->worker.work);
         kthread_stop(dev->worker.thread);
         DBG("thread stopped\n");
 
         if (dev->stop != NULL)
                 return dev->stop(netdev);
         return 0;
 }
 
 static const struct driver_info qc_netinfo = {
         .description   = "QCUSBNet Ethernet Device",
@@ skipping 108 matching lines @@
         memset(&(dev->meid), '0', 14);
 
         dev->valid = false;
         memset(&dev->qmi, 0, sizeof(dev->qmi));
 
         dev->qmi.devclass = devclass;
 
         kref_init(&dev->refcount);
         INIT_LIST_HEAD(&dev->node);
         INIT_LIST_HEAD(&dev->qmi.clients);
-        init_completion(&dev->worker.work);
+        atomic_set(&dev->worker.work_count, 0);
+        init_waitqueue_head(&dev->worker.waitq);
         spin_lock_init(&dev->qmi.clients_lock);
 
         dev->down = 0;
         qc_setdown(dev, DOWN_NO_NDIS_CONNECTION);
         qc_setdown(dev, DOWN_NET_IFACE_STOPPED);
 
         status = qc_register(dev);
         if (status) {
                 qc_deregister(dev);
         } else {
@@ skipping 43 matching lines @@
 }
 module_exit(modexit);
 
 MODULE_VERSION(DRIVER_VERSION);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("Dual BSD/GPL");
 
 module_param(qcusbnet_debug, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(qcusbnet_debug, "Debugging enabled or not");