lbs_deb_cmd("PREP_CMD: No free cmdnode\n");
 
                /* Wake up main thread to execute next command */
-               wake_up_interruptible(&priv->mainthread.waitq);
+               wake_up_interruptible(&priv->waitq);
                ret = -1;
                goto done;
        }
 
        libertas_queue_cmd(adapter, cmdnode, 1);
        adapter->nr_cmd_pending++;
-       wake_up_interruptible(&priv->mainthread.waitq);
+       wake_up_interruptible(&priv->waitq);
 
        if (wait_option & CMD_OPTION_WAITFORRSP) {
                lbs_deb_cmd("PREP_CMD: Wait for CMD response\n");
 
        event->action = cpu_to_le16(CMD_ACT_GET);
        pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
        libertas_queue_cmd(adapter, pcmdnode, 1);
-       wake_up_interruptible(&priv->mainthread.waitq);
+       wake_up_interruptible(&priv->waitq);
 
        /* Sleep until response is generated by FW */
        wait_event_interruptible(pcmdnode->cmdwait_q,
        event->action = cpu_to_le16(CMD_ACT_GET);
        pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
        libertas_queue_cmd(adapter, pcmdnode, 1);
-       wake_up_interruptible(&priv->mainthread.waitq);
+       wake_up_interruptible(&priv->waitq);
 
        /* Sleep until response is generated by FW */
        wait_event_interruptible(pcmdnode->cmdwait_q,
        event->events = cpu_to_le16(event_bitmap);
 
        libertas_queue_cmd(adapter, pcmdnode, 1);
-       wake_up_interruptible(&priv->mainthread.waitq);
+       wake_up_interruptible(&priv->waitq);
 
        /* Sleep until response is generated by FW */
        wait_event_interruptible(pcmdnode->cmdwait_q,
        event->action = cpu_to_le16(CMD_ACT_GET);
        pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
        libertas_queue_cmd(adapter, pcmdnode, 1);
-       wake_up_interruptible(&priv->mainthread.waitq);
+       wake_up_interruptible(&priv->waitq);
 
        /* Sleep until response is generated by FW */
        wait_event_interruptible(pcmdnode->cmdwait_q,
        event->events = cpu_to_le16(event_bitmap);
 
        libertas_queue_cmd(adapter, pcmdnode, 1);
-       wake_up_interruptible(&priv->mainthread.waitq);
+       wake_up_interruptible(&priv->waitq);
 
        /* Sleep until response is generated by FW */
        wait_event_interruptible(pcmdnode->cmdwait_q,
        event->action = cpu_to_le16(CMD_ACT_GET);
        pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
        libertas_queue_cmd(adapter, pcmdnode, 1);
-       wake_up_interruptible(&priv->mainthread.waitq);
+       wake_up_interruptible(&priv->waitq);
 
        /* Sleep until response is generated by FW */
        wait_event_interruptible(pcmdnode->cmdwait_q,
        event->events = cpu_to_le16(event_bitmap);
 
        libertas_queue_cmd(adapter, pcmdnode, 1);
-       wake_up_interruptible(&priv->mainthread.waitq);
+       wake_up_interruptible(&priv->waitq);
 
        /* Sleep until response is generated by FW */
        wait_event_interruptible(pcmdnode->cmdwait_q,
        event->action = cpu_to_le16(CMD_ACT_GET);
        pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
        libertas_queue_cmd(adapter, pcmdnode, 1);
-       wake_up_interruptible(&priv->mainthread.waitq);
+       wake_up_interruptible(&priv->waitq);
 
        /* Sleep until response is generated by FW */
        wait_event_interruptible(pcmdnode->cmdwait_q,
        event->events = cpu_to_le16(event_bitmap);
 
        libertas_queue_cmd(adapter, pcmdnode, 1);
-       wake_up_interruptible(&priv->mainthread.waitq);
+       wake_up_interruptible(&priv->waitq);
 
        /* Sleep until response is generated by FW */
        wait_event_interruptible(pcmdnode->cmdwait_q,
        event->action = cpu_to_le16(CMD_ACT_GET);
        pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
        libertas_queue_cmd(adapter, pcmdnode, 1);
-       wake_up_interruptible(&priv->mainthread.waitq);
+       wake_up_interruptible(&priv->waitq);
 
        /* Sleep until response is generated by FW */
        wait_event_interruptible(pcmdnode->cmdwait_q,
        event->events = cpu_to_le16(event_bitmap);
 
        libertas_queue_cmd(adapter, pcmdnode, 1);
-       wake_up_interruptible(&priv->mainthread.waitq);
+       wake_up_interruptible(&priv->waitq);
 
        /* Sleep until response is generated by FW */
        wait_event_interruptible(pcmdnode->cmdwait_q,
        event->action = cpu_to_le16(CMD_ACT_GET);
        pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
        libertas_queue_cmd(adapter, pcmdnode, 1);
-       wake_up_interruptible(&priv->mainthread.waitq);
+       wake_up_interruptible(&priv->waitq);
 
        /* Sleep until response is generated by FW */
        wait_event_interruptible(pcmdnode->cmdwait_q,
        event->events = cpu_to_le16(event_bitmap);
 
        libertas_queue_cmd(adapter, pcmdnode, 1);
-       wake_up_interruptible(&priv->mainthread.waitq);
+       wake_up_interruptible(&priv->waitq);
 
        /* Sleep until response is generated by FW */
        wait_event_interruptible(pcmdnode->cmdwait_q,
 
 
 #include "defs.h"
 #include "scan.h"
-#include "thread.h"
 
 extern struct ethtool_ops libertas_ethtool_ops;
 
        struct device *hotplug_device;
 
        /** thread to service interrupts */
-       struct wlan_thread mainthread;
+       struct task_struct *main_thread;
+       wait_queue_head_t waitq;
 
        struct delayed_work assoc_work;
        struct workqueue_struct *assoc_thread;
 
        lbs_deb_fw("re-sending same command because of timeout\n");
        libertas_queue_cmd(adapter, ptempnode, 0);
 
-       wake_up_interruptible(&priv->mainthread.waitq);
+       wake_up_interruptible(&priv->waitq);
 
        return;
 }
 
                priv->dnld_sent = DNLD_RES_RECEIVED;
                /* Wake main thread if commands are pending */
                if (!adapter->cur_cmd)
-                       wake_up_interruptible(&priv->mainthread.waitq);
+                       wake_up_interruptible(&priv->waitq);
                if ((adapter->connect_status == LIBERTAS_CONNECTED)) {
                        netif_wake_queue(dev);
                        netif_wake_queue(priv->mesh_dev);
 
 #include <linux/etherdevice.h>
 #include <linux/netdevice.h>
 #include <linux/if_arp.h>
+#include <linux/kthread.h>
 
 #include <net/iw_handler.h>
 #include <net/ieee80211.h>
                        priv->adapter->eventcause = 0x01000000;
                        libertas_send_tx_feedback(priv);
                } else
-                       wake_up_interruptible(&priv->mainthread.waitq);
+                       wake_up_interruptible(&priv->waitq);
        } else if (priv->adapter->connect_status == LIBERTAS_CONNECTED) {
                netif_wake_queue(priv->dev);
                netif_wake_queue(priv->mesh_dev);
  *  @param data    A pointer to wlan_thread structure
  *  @return       0
  */
-static int wlan_service_main_thread(void *data)
+static int libertas_thread(void *data)
 {
-       struct wlan_thread *thread = data;
-       wlan_private *priv = thread->priv;
+       struct net_device *dev = data;
+       wlan_private *priv = dev->priv;
        wlan_adapter *adapter = priv->adapter;
        wait_queue_t wait;
        u8 ireg = 0;
 
        lbs_deb_enter(LBS_DEB_THREAD);
 
-       wlan_activate_thread(thread);
-
        init_waitqueue_entry(&wait, current);
 
-       set_freezable();
        for (;;) {
                lbs_deb_thread( "main-thread 111: intcounter=%d "
                       "currenttxskb=%p dnld_sent=%d\n",
                       adapter->intcounter,
                       adapter->currenttxskb, priv->dnld_sent);
 
-               add_wait_queue(&thread->waitq, &wait);
+               add_wait_queue(&priv->waitq, &wait);
                set_current_state(TASK_INTERRUPTIBLE);
                spin_lock_irq(&adapter->driver_lock);
                if ((adapter->psstate == PS_STATE_SLEEP) ||
                       adapter->currenttxskb, priv->dnld_sent);
 
                set_current_state(TASK_RUNNING);
-               remove_wait_queue(&thread->waitq, &wait);
+               remove_wait_queue(&priv->waitq, &wait);
                try_to_freeze();
 
                lbs_deb_thread("main-thread 333: intcounter=%d currenttxskb=%p "
        del_timer(&adapter->command_timer);
        adapter->nr_cmd_pending = 0;
        wake_up_all(&adapter->cmd_pending);
-       wlan_deactivate_thread(thread);
 
        lbs_deb_leave(LBS_DEB_THREAD);
        return 0;
 
        lbs_deb_enter(LBS_DEB_MAIN);
 
-       lbs_deb_thread("Starting kthread...\n");
-       priv->mainthread.priv = priv;
-       wlan_create_thread(wlan_service_main_thread,
-                          &priv->mainthread, "wlan_main_service");
+       lbs_deb_thread("Starting main thread...\n");
+       init_waitqueue_head(&priv->waitq);
+       priv->main_thread = kthread_run(libertas_thread, dev, "libertas_main");
+       if (IS_ERR(priv->main_thread)) {
+               lbs_deb_thread("Error creating main thread.\n");
+               goto done;
+       }
 
        priv->assoc_thread =
                create_singlethread_workqueue("libertas_assoc");
 err_registerdev:
        destroy_workqueue(priv->assoc_thread);
        /* Stop the thread servicing the interrupts */
-       wake_up_interruptible(&priv->mainthread.waitq);
-       wlan_terminate_thread(&priv->mainthread);
+       wake_up_interruptible(&priv->waitq);
+       kthread_stop(priv->main_thread);
 done:
        lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
        return ret;
        adapter->surpriseremoved = 1;
 
        /* Stop the thread servicing the interrupts */
-       wlan_terminate_thread(&priv->mainthread);
+       kthread_stop(priv->main_thread);
 
        libertas_debugfs_remove_one(priv);
 
                netif_wake_queue(priv->mesh_dev);
        }
 
-       wake_up_interruptible(&priv->mainthread.waitq);
+       wake_up_interruptible(&priv->waitq);
 
        lbs_deb_leave(LBS_DEB_THREAD);
 }
 
+++ /dev/null
-#ifndef        __WLAN_THREAD_H_
-#define        __WLAN_THREAD_H_
-
-#include       <linux/kthread.h>
-
-struct wlan_thread {
-       struct task_struct *task;
-       wait_queue_head_t waitq;
-       pid_t pid;
-       void *priv;
-};
-
-static inline void wlan_activate_thread(struct wlan_thread * thr)
-{
-       /** Record the thread pid */
-       thr->pid = current->pid;
-
-       /** Initialize the wait queue */
-       init_waitqueue_head(&thr->waitq);
-}
-
-static inline void wlan_deactivate_thread(struct wlan_thread * thr)
-{
-       lbs_deb_enter(LBS_DEB_THREAD);
-
-       thr->pid = 0;
-
-       lbs_deb_leave(LBS_DEB_THREAD);
-}
-
-static inline void wlan_create_thread(int (*wlanfunc) (void *),
-                                     struct wlan_thread * thr, char *name)
-{
-       thr->task = kthread_run(wlanfunc, thr, "%s", name);
-}
-
-static inline int wlan_terminate_thread(struct wlan_thread * thr)
-{
-       lbs_deb_enter(LBS_DEB_THREAD);
-
-       /* Check if the thread is active or not */
-       if (!thr->pid) {
-               printk(KERN_ERR "Thread does not exist\n");
-               return -1;
-       }
-       kthread_stop(thr->task);
-
-       lbs_deb_leave(LBS_DEB_THREAD);
-       return 0;
-}
-
-#endif