int tx_dma_idx[4];
 
        struct tasklet_struct tx_tasklet;
+       struct delayed_work mac_work;
 
        wait_queue_head_t tx_wait;
        struct sk_buff_head status_list;
 
 
        spin_lock_init(&dev->ps_lock);
 
-       INIT_DELAYED_WORK(&dev->mac_work, mt7603_mac_work);
+       INIT_DELAYED_WORK(&dev->mt76.mac_work, mt7603_mac_work);
        tasklet_init(&dev->pre_tbtt_tasklet, mt7603_pre_tbtt_tasklet,
                     (unsigned long)dev);
 
 
 void mt7603_mac_work(struct work_struct *work)
 {
        struct mt7603_dev *dev = container_of(work, struct mt7603_dev,
-                                             mac_work.work);
+                                             mt76.mac_work.work);
        bool reset = false;
 
        mt76_tx_status_check(&dev->mt76, NULL, false);
        if (reset)
                mt7603_mac_watchdog_reset(dev);
 
-       ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mac_work,
+       ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mt76.mac_work,
                                     msecs_to_jiffies(MT7603_WATCHDOG_TIME));
 }
 
        mt7603_mac_start(dev);
        dev->survey_time = ktime_get_boottime();
        set_bit(MT76_STATE_RUNNING, &dev->mt76.state);
-       mt7603_mac_work(&dev->mac_work.work);
+       mt7603_mac_work(&dev->mt76.mac_work.work);
 
        return 0;
 }
        struct mt7603_dev *dev = hw->priv;
 
        clear_bit(MT76_STATE_RUNNING, &dev->mt76.state);
-       cancel_delayed_work_sync(&dev->mac_work);
+       cancel_delayed_work_sync(&dev->mt76.mac_work);
        mt7603_mac_stop(dev);
 }
 
        u8 bw = MT_BW_20;
        bool failed = false;
 
-       cancel_delayed_work_sync(&dev->mac_work);
+       cancel_delayed_work_sync(&dev->mt76.mac_work);
 
        mutex_lock(&dev->mt76.mutex);
        set_bit(MT76_RESET, &dev->mt76.state);
 
        mt76_txq_schedule_all(&dev->mt76);
 
-       ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mac_work,
+       ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mt76.mac_work,
                                     MT7603_WATCHDOG_TIME);
 
        /* reset channel stats */
        mutex_unlock(&dev->mt76.mutex);
 
        if (failed)
-               mt7603_mac_work(&dev->mac_work.work);
+               mt7603_mac_work(&dev->mt76.mac_work.work);
 
        return ret;
 }
 
 
        unsigned int reset_cause[__RESET_CAUSE_MAX];
 
-       struct delayed_work mac_work;
        struct tasklet_struct pre_tbtt_tasklet;
 };
 
 
 
        mt76x02_mac_start(dev);
        mt76x0_phy_calibrate(dev, true);
-       ieee80211_queue_delayed_work(dev->mt76.hw, &dev->mac_work,
+       ieee80211_queue_delayed_work(dev->mt76.hw, &dev->mt76.mac_work,
                                     MT_MAC_WORK_INTERVAL);
        ieee80211_queue_delayed_work(dev->mt76.hw, &dev->cal_work,
                                     MT_CALIBRATE_INTERVAL);
 static void mt76x0e_stop_hw(struct mt76x02_dev *dev)
 {
        cancel_delayed_work_sync(&dev->cal_work);
-       cancel_delayed_work_sync(&dev->mac_work);
+       cancel_delayed_work_sync(&dev->mt76.mac_work);
 
        if (!mt76_poll(dev, MT_WPDMA_GLO_CFG, MT_WPDMA_GLO_CFG_TX_DMA_BUSY,
                       0, 1000))
 
 {
        clear_bit(MT76_STATE_RUNNING, &dev->mt76.state);
        cancel_delayed_work_sync(&dev->cal_work);
-       cancel_delayed_work_sync(&dev->mac_work);
+       cancel_delayed_work_sync(&dev->mt76.mac_work);
        mt76u_stop_stat_wk(&dev->mt76);
        mt76x02u_exit_beacon_config(dev);
 
                goto out;
 
        mt76x0_phy_calibrate(dev, true);
-       ieee80211_queue_delayed_work(dev->mt76.hw, &dev->mac_work,
+       ieee80211_queue_delayed_work(dev->mt76.hw, &dev->mt76.mac_work,
                                     MT_MAC_WORK_INTERVAL);
        ieee80211_queue_delayed_work(dev->mt76.hw, &dev->cal_work,
                                     MT_CALIBRATE_INTERVAL);
 
        struct tasklet_struct tx_tasklet;
        struct tasklet_struct pre_tbtt_tasklet;
        struct delayed_work cal_work;
-       struct delayed_work mac_work;
        struct delayed_work wdt_work;
 
        struct hrtimer pre_tbtt_timer;
 
 void mt76x02_mac_work(struct work_struct *work)
 {
        struct mt76x02_dev *dev = container_of(work, struct mt76x02_dev,
-                                              mac_work.work);
+                                              mt76.mac_work.work);
        int i, idx;
 
        mutex_lock(&dev->mt76.mutex);
 
        mt76_tx_status_check(&dev->mt76, NULL, false);
 
-       ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mac_work,
+       ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mt76.mac_work,
                                     MT_MAC_WORK_INTERVAL);
 }
 
 
        struct ieee80211_hw *hw = mt76_hw(dev);
        struct wiphy *wiphy = hw->wiphy;
 
-       INIT_DELAYED_WORK(&dev->mac_work, mt76x02_mac_work);
+       INIT_DELAYED_WORK(&dev->mt76.mac_work, mt76x02_mac_work);
 
        hw->queues = 4;
        hw->max_rates = 1;
 
 void mt76x2_stop_hardware(struct mt76x02_dev *dev)
 {
        cancel_delayed_work_sync(&dev->cal_work);
-       cancel_delayed_work_sync(&dev->mac_work);
+       cancel_delayed_work_sync(&dev->mt76.mac_work);
        cancel_delayed_work_sync(&dev->wdt_work);
        mt76x02_mcu_set_radio_state(dev, false);
        mt76x2_mac_stop(dev, false);
 
        if (ret)
                goto out;
 
-       ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mac_work,
+       ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mt76.mac_work,
                                     MT_MAC_WORK_INTERVAL);
        ieee80211_queue_delayed_work(mt76_hw(dev), &dev->wdt_work,
                                     MT_WATCHDOG_TIME);
 
 {
        mt76u_stop_stat_wk(&dev->mt76);
        cancel_delayed_work_sync(&dev->cal_work);
-       cancel_delayed_work_sync(&dev->mac_work);
+       cancel_delayed_work_sync(&dev->mt76.mac_work);
        mt76x2u_mac_stop(dev);
 }
 
 
        if (ret)
                goto out;
 
-       ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mac_work,
+       ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mt76.mac_work,
                                     MT_MAC_WORK_INTERVAL);
        set_bit(MT76_STATE_RUNNING, &dev->mt76.state);