static void ieee80211_ibss_work(struct work_struct *work)
 {
        struct ieee80211_sub_if_data *sdata =
-               container_of(work, struct ieee80211_sub_if_data, u.ibss.work);
+               container_of(work, struct ieee80211_sub_if_data, work);
        struct ieee80211_local *local = sdata->local;
        struct ieee80211_if_ibss *ifibss;
        struct sk_buff *skb;
        struct ieee80211_local *local = sdata->local;
 
        set_bit(IEEE80211_IBSS_REQ_RUN, &ifibss->request);
-       ieee80211_queue_work(&local->hw, &ifibss->work);
+       ieee80211_queue_work(&local->hw, &sdata->work);
 }
 
 static void ieee80211_ibss_timer(unsigned long data)
 {
        struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
 
-       cancel_work_sync(&ifibss->work);
        if (del_timer_sync(&ifibss->timer))
                ifibss->timer_running = true;
 }
 {
        struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
 
-       INIT_WORK(&ifibss->work, ieee80211_ibss_work);
+       INIT_WORK(&sdata->work, ieee80211_ibss_work);
        setup_timer(&ifibss->timer, ieee80211_ibss_timer,
                    (unsigned long) sdata);
 }
        case IEEE80211_STYPE_PROBE_REQ:
        case IEEE80211_STYPE_AUTH:
                skb_queue_tail(&sdata->skb_queue, skb);
-               ieee80211_queue_work(&local->hw, &sdata->u.ibss.work);
+               ieee80211_queue_work(&local->hw, &sdata->work);
                return RX_QUEUED;
        }
 
        ieee80211_recalc_idle(sdata->local);
 
        set_bit(IEEE80211_IBSS_REQ_RUN, &sdata->u.ibss.request);
-       ieee80211_queue_work(&sdata->local->hw, &sdata->u.ibss.work);
+       ieee80211_queue_work(&sdata->local->hw, &sdata->work);
 
        return 0;
 }
 
        del_timer_sync(&sdata->u.ibss.timer);
        clear_bit(IEEE80211_IBSS_REQ_RUN, &sdata->u.ibss.request);
-       cancel_work_sync(&sdata->u.ibss.work);
+       cancel_work_sync(&sdata->work);
        clear_bit(IEEE80211_IBSS_REQ_RUN, &sdata->u.ibss.request);
 
        sta_info_flush(sdata->local, sdata);
 
        struct timer_list conn_mon_timer;
        struct timer_list bcn_mon_timer;
        struct timer_list chswitch_timer;
-       struct work_struct work;
        struct work_struct monitor_work;
        struct work_struct chswitch_work;
        struct work_struct beacon_connection_loss_work;
 
 struct ieee80211_if_ibss {
        struct timer_list timer;
-       struct work_struct work;
 
        unsigned long request;
        unsigned long last_scan_completed;
 };
 
 struct ieee80211_if_mesh {
-       struct work_struct work;
        struct timer_list housekeeping_timer;
        struct timer_list mesh_path_timer;
        struct timer_list mesh_path_root_timer;
 
        u16 sequence_number;
 
+       struct work_struct work;
        struct sk_buff_head skb_queue;
 
        /*
 
                 * whether the interface is running, which, at this point,
                 * it no longer is.
                 */
-               cancel_work_sync(&sdata->u.mgd.work);
                cancel_work_sync(&sdata->u.mgd.chswitch_work);
                cancel_work_sync(&sdata->u.mgd.monitor_work);
                cancel_work_sync(&sdata->u.mgd.beacon_connection_loss_work);
 
                /* fall through */
        case NL80211_IFTYPE_ADHOC:
-               if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
+               if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
                        del_timer_sync(&sdata->u.ibss.timer);
-                       cancel_work_sync(&sdata->u.ibss.work);
-               }
                /* fall through */
        case NL80211_IFTYPE_MESH_POINT:
                if (ieee80211_vif_is_mesh(&sdata->vif)) {
                }
                /* fall through */
        default:
+               cancel_work_sync(&sdata->work);
                /*
                 * When we get here, the interface is marked down.
                 * Call synchronize_rcu() to wait for the RX path
 
                return;
        }
 
-       ieee80211_queue_work(&local->hw, &ifmsh->work);
+       ieee80211_queue_work(&local->hw, &sdata->work);
 }
 
 /**
                return;
        }
 
-       ieee80211_queue_work(&local->hw, &ifmsh->work);
+       ieee80211_queue_work(&local->hw, &sdata->work);
 }
 
 static void ieee80211_mesh_path_root_timer(unsigned long data)
                return;
        }
 
-       ieee80211_queue_work(&local->hw, &ifmsh->work);
+       ieee80211_queue_work(&local->hw, &sdata->work);
 }
 
 void ieee80211_mesh_root_setup(struct ieee80211_if_mesh *ifmsh)
 {
        struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
 
-       /* might restart the timer but that doesn't matter */
-       cancel_work_sync(&ifmsh->work);
-
        /* use atomic bitops in case both timers fire at the same time */
 
        if (del_timer_sync(&ifmsh->housekeeping_timer))
 
        set_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags);
        ieee80211_mesh_root_setup(ifmsh);
-       ieee80211_queue_work(&local->hw, &ifmsh->work);
+       ieee80211_queue_work(&local->hw, &sdata->work);
        sdata->vif.bss_conf.beacon_int = MESH_DEFAULT_BEACON_INTERVAL;
        ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON |
                                                BSS_CHANGED_BEACON_ENABLED |
         * whether the interface is running, which, at this point,
         * it no longer is.
         */
-       cancel_work_sync(&sdata->u.mesh.work);
+       cancel_work_sync(&sdata->work);
 }
 
 static void ieee80211_mesh_rx_bcn_presp(struct ieee80211_sub_if_data *sdata,
 static void ieee80211_mesh_work(struct work_struct *work)
 {
        struct ieee80211_sub_if_data *sdata =
-               container_of(work, struct ieee80211_sub_if_data, u.mesh.work);
+               container_of(work, struct ieee80211_sub_if_data, work);
        struct ieee80211_local *local = sdata->local;
        struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
        struct sk_buff *skb;
        rcu_read_lock();
        list_for_each_entry_rcu(sdata, &local->interfaces, list)
                if (ieee80211_vif_is_mesh(&sdata->vif))
-                       ieee80211_queue_work(&local->hw, &sdata->u.mesh.work);
+                       ieee80211_queue_work(&local->hw, &sdata->work);
        rcu_read_unlock();
 }
 
 {
        struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
 
-       INIT_WORK(&ifmsh->work, ieee80211_mesh_work);
+       INIT_WORK(&sdata->work, ieee80211_mesh_work);
        setup_timer(&ifmsh->housekeeping_timer,
                    ieee80211_mesh_housekeeping_timer,
                    (unsigned long) sdata);
 ieee80211_mesh_rx_mgmt(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb)
 {
        struct ieee80211_local *local = sdata->local;
-       struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
        struct ieee80211_mgmt *mgmt;
        u16 fc;
 
        case IEEE80211_STYPE_PROBE_RESP:
        case IEEE80211_STYPE_BEACON:
                skb_queue_tail(&sdata->skb_queue, skb);
-               ieee80211_queue_work(&local->hw, &ifmsh->work);
+               ieee80211_queue_work(&local->hw, &sdata->work);
                return RX_QUEUED;
        }
 
 
        spin_unlock(&ifmsh->mesh_preq_queue_lock);
 
        if (time_after(jiffies, ifmsh->last_preq + min_preq_int_jiff(sdata)))
-               ieee80211_queue_work(&sdata->local->hw, &ifmsh->work);
+               ieee80211_queue_work(&sdata->local->hw, &sdata->work);
 
        else if (time_before(jiffies, ifmsh->last_preq)) {
                /* avoid long wait if did not send preqs for a long time
                 * and jiffies wrapped around
                 */
                ifmsh->last_preq = jiffies - min_preq_int_jiff(sdata) - 1;
-               ieee80211_queue_work(&sdata->local->hw, &ifmsh->work);
+               ieee80211_queue_work(&sdata->local->hw, &sdata->work);
        } else
                mod_timer(&ifmsh->mesh_path_timer, ifmsh->last_preq +
                                                min_preq_int_jiff(sdata));
 
        read_unlock(&pathtbl_resize_lock);
        if (grow) {
                set_bit(MESH_WORK_GROW_MPATH_TABLE,  &ifmsh->wrkq_flags);
-               ieee80211_queue_work(&local->hw, &ifmsh->work);
+               ieee80211_queue_work(&local->hw, &sdata->work);
        }
        return 0;
 
        read_unlock(&pathtbl_resize_lock);
        if (grow) {
                set_bit(MESH_WORK_GROW_MPP_TABLE,  &ifmsh->wrkq_flags);
-               ieee80211_queue_work(&local->hw, &ifmsh->work);
+               ieee80211_queue_work(&local->hw, &sdata->work);
        }
        return 0;
 
 
        case IEEE80211_STYPE_DISASSOC:
        case IEEE80211_STYPE_ACTION:
                skb_queue_tail(&sdata->skb_queue, skb);
-               ieee80211_queue_work(&local->hw, &sdata->u.mgd.work);
+               ieee80211_queue_work(&local->hw, &sdata->work);
                return RX_QUEUED;
        }
 
                return;
        }
 
-       ieee80211_queue_work(&local->hw, &ifmgd->work);
+       ieee80211_queue_work(&local->hw, &sdata->work);
 }
 
 static void ieee80211_sta_work(struct work_struct *work)
 {
        struct ieee80211_sub_if_data *sdata =
-               container_of(work, struct ieee80211_sub_if_data, u.mgd.work);
+               container_of(work, struct ieee80211_sub_if_data, work);
        struct ieee80211_local *local = sdata->local;
        struct ieee80211_if_managed *ifmgd;
        struct sk_buff *skb;
                ieee80211_queue_work(&sdata->local->hw,
                           &sdata->u.mgd.monitor_work);
                /* and do all the other regular work too */
-               ieee80211_queue_work(&sdata->local->hw,
-                          &sdata->u.mgd.work);
+               ieee80211_queue_work(&sdata->local->hw, &sdata->work);
        }
 }
 
         * time -- the code here is properly synchronised.
         */
 
-       cancel_work_sync(&ifmgd->work);
        cancel_work_sync(&ifmgd->beacon_connection_loss_work);
        if (del_timer_sync(&ifmgd->timer))
                set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
        struct ieee80211_if_managed *ifmgd;
 
        ifmgd = &sdata->u.mgd;
-       INIT_WORK(&ifmgd->work, ieee80211_sta_work);
+       INIT_WORK(&sdata->work, ieee80211_sta_work);
        INIT_WORK(&ifmgd->monitor_work, ieee80211_sta_monitor_work);
        INIT_WORK(&ifmgd->chswitch_work, ieee80211_chswitch_work);
        INIT_WORK(&ifmgd->beacon_connection_loss_work,
 
 
        /* remove all interfaces */
        list_for_each_entry(sdata, &local->interfaces, list) {
+               cancel_work_sync(&sdata->work);
+
                switch(sdata->vif.type) {
                case NL80211_IFTYPE_STATION:
                        ieee80211_sta_quiesce(sdata);