void mt76_rx(struct mt76_dev *dev, enum mt76_rxq_id q, struct sk_buff *skb)
 {
-       if (!test_bit(MT76_STATE_RUNNING, &dev->state)) {
+       struct mt76_rx_status *status = (struct mt76_rx_status *)skb->cb;
+       struct mt76_phy *phy = mt76_dev_phy(dev, status->ext_phy);
+
+       if (!test_bit(MT76_STATE_RUNNING, &phy->state)) {
                dev_kfree_skb(skb);
                return;
        }
 {
        ktime_t cur_time;
 
-       if (!test_bit(MT76_STATE_RUNNING, &dev->state))
-               return;
-
        if (dev->drv->update_survey)
                dev->drv->update_survey(dev);
 
 void mt76_sw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
                  const u8 *mac)
 {
-       struct mt76_dev *dev = hw->priv;
+       struct mt76_phy *phy = hw->priv;
 
-       set_bit(MT76_SCANNING, &dev->state);
+       set_bit(MT76_SCANNING, &phy->state);
 }
 EXPORT_SYMBOL_GPL(mt76_sw_scan);
 
 void mt76_sw_scan_complete(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
 {
-       struct mt76_dev *dev = hw->priv;
+       struct mt76_phy *phy = hw->priv;
 
-       clear_bit(MT76_SCANNING, &dev->state);
+       clear_bit(MT76_SCANNING, &phy->state);
 }
 EXPORT_SYMBOL_GPL(mt76_sw_scan_complete);
 
 
        struct ieee80211_hw *hw;
        struct mt76_dev *dev;
 
+       unsigned long state;
+
        struct cfg80211_chan_def chandef;
        struct ieee80211_channel *main_chan;
 
 
        u8 macaddr[ETH_ALEN];
        u32 rev;
-       unsigned long state;
 
        u32 aggr_stats[32];
 
 int mt76_eeprom_init(struct mt76_dev *dev, int len);
 void mt76_eeprom_override(struct mt76_dev *dev);
 
+static inline struct mt76_phy *
+mt76_dev_phy(struct mt76_dev *dev, bool phy_ext)
+{
+       if (phy_ext && dev->phy2)
+               return dev->phy2;
+       return &dev->phy;
+}
+
 static inline struct ieee80211_hw *
 mt76_phy_hw(struct mt76_dev *dev, bool phy_ext)
 {
-       if (phy_ext && dev->phy2)
-               return dev->phy2->hw;
-       return dev->phy.hw;
+       return mt76_dev_phy(dev, phy_ext)->hw;
 }
 
 static inline u8 *
 
        intr = mt76_rr(dev, MT_INT_SOURCE_CSR);
        mt76_wr(dev, MT_INT_SOURCE_CSR, intr);
 
-       if (!test_bit(MT76_STATE_INITIALIZED, &dev->mt76.state))
+       if (!test_bit(MT76_STATE_INITIALIZED, &dev->mphy.state))
                return IRQ_NONE;
 
        intr &= dev->mt76.mmio.irqmask;
 
        mt76_wr(dev, MT_WPDMA_GLO_CFG, 0x52000850);
        mt7603_mac_dma_start(dev);
        dev->rxfilter = mt76_rr(dev, MT_WF_RFCR);
-       set_bit(MT76_STATE_INITIALIZED, &dev->mt76.state);
+       set_bit(MT76_STATE_INITIALIZED, &dev->mphy.state);
 
        for (i = 0; i < MT7603_WTBL_SIZE; i++) {
                mt76_wr(dev, MT_PSE_RTA, MT_PSE_RTA_BUSY | MT_PSE_RTA_WRITE |
 
        int i;
 
        ieee80211_stop_queues(dev->mt76.hw);
-       set_bit(MT76_RESET, &dev->mt76.state);
+       set_bit(MT76_RESET, &dev->mphy.state);
 
        /* lock/unlock all queues to ensure that no tx is pending */
        mt76_txq_schedule_all(&dev->mphy);
        mt7603_irq_enable(dev, mask);
 
 skip_dma_reset:
-       clear_bit(MT76_RESET, &dev->mt76.state);
+       clear_bit(MT76_RESET, &dev->mphy.state);
        mutex_unlock(&dev->mt76.mutex);
 
        tasklet_enable(&dev->mt76.tx_tasklet);
 
        mt7603_mac_reset_counters(dev);
        mt7603_mac_start(dev);
        dev->mphy.survey_time = ktime_get_boottime();
-       set_bit(MT76_STATE_RUNNING, &dev->mt76.state);
+       set_bit(MT76_STATE_RUNNING, &dev->mphy.state);
        mt7603_mac_work(&dev->mt76.mac_work.work);
 
        return 0;
 {
        struct mt7603_dev *dev = hw->priv;
 
-       clear_bit(MT76_STATE_RUNNING, &dev->mt76.state);
+       clear_bit(MT76_STATE_RUNNING, &dev->mphy.state);
        cancel_delayed_work_sync(&dev->mt76.mac_work);
        mt7603_mac_stop(dev);
 }
        tasklet_disable(&dev->mt76.pre_tbtt_tasklet);
 
        mutex_lock(&dev->mt76.mutex);
-       set_bit(MT76_RESET, &dev->mt76.state);
+       set_bit(MT76_RESET, &dev->mphy.state);
 
        mt7603_beacon_set_timer(dev, -1, 0);
        mt76_set_channel(&dev->mphy);
        mt7603_mac_set_timing(dev);
        mt7603_mac_start(dev);
 
-       clear_bit(MT76_RESET, &dev->mt76.state);
+       clear_bit(MT76_RESET, &dev->mphy.state);
 
        mt76_txq_schedule_all(&dev->mphy);
 
 
        if (ret)
                return ret;
 
-       set_bit(MT76_STATE_INITIALIZED, &dev->mt76.state);
+       set_bit(MT76_STATE_INITIALIZED, &dev->mphy.state);
 
        ret = mt7615_mcu_init(dev);
        if (ret)
 
        bool unicast, remove_pad, insert_ccmp_hdr = false;
        int i, idx;
 
-       if (!test_bit(MT76_STATE_RUNNING, &dev->mt76.state))
+       if (!test_bit(MT76_STATE_RUNNING, &dev->mphy.state))
                return -EINVAL;
 
        memset(status, 0, sizeof(*status));
        if (dev->mt76.region == NL80211_DFS_UNSET)
                return 0;
 
-       if (test_bit(MT76_SCANNING, &dev->mt76.state))
+       if (test_bit(MT76_SCANNING, &dev->mphy.state))
                return 0;
 
        if (dev->dfs_state == chandef->chan->dfs_state)
 
        mt7615_mac_reset_counters(dev);
 
        dev->mphy.survey_time = ktime_get_boottime();
-       set_bit(MT76_STATE_RUNNING, &dev->mt76.state);
+       set_bit(MT76_STATE_RUNNING, &dev->mphy.state);
        ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mt76.mac_work,
                                     MT7615_WATCHDOG_TIME);
 
 {
        struct mt7615_dev *dev = hw->priv;
 
-       clear_bit(MT76_STATE_RUNNING, &dev->mt76.state);
+       clear_bit(MT76_STATE_RUNNING, &dev->mphy.state);
        cancel_delayed_work_sync(&dev->mt76.mac_work);
 }
 
        cancel_delayed_work_sync(&dev->mt76.mac_work);
 
        mutex_lock(&dev->mt76.mutex);
-       set_bit(MT76_RESET, &dev->mt76.state);
+       set_bit(MT76_RESET, &dev->mphy.state);
 
        mt7615_dfs_check_channel(dev);
 
        mt7615_mac_reset_counters(dev);
 
 out:
-       clear_bit(MT76_RESET, &dev->mt76.state);
+       clear_bit(MT76_RESET, &dev->mphy.state);
        mutex_unlock(&dev->mt76.mutex);
 
        mt76_txq_schedule_all(&dev->mphy);
 
        if (wait_seq)
                *wait_seq = seq;
 
-       if (test_bit(MT76_STATE_MCU_RUNNING, &dev->mt76.state))
+       if (test_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state))
                qid = MT_TXQ_MCU;
        else
                qid = MT_TXQ_FWDL;
        if (ret)
                return ret;
 
-       set_bit(MT76_STATE_MCU_RUNNING, &dev->mt76.state);
+       set_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state);
 
        return 0;
 }
 
        intr = mt76_rr(dev, MT_INT_SOURCE_CSR);
        mt76_wr(dev, MT_INT_SOURCE_CSR, intr);
 
-       if (!test_bit(MT76_STATE_INITIALIZED, &dev->mt76.state))
+       if (!test_bit(MT76_STATE_INITIALIZED, &dev->mphy.state))
                return IRQ_NONE;
 
        intr &= dev->mt76.mmio.irqmask;
 
        if (changed & IEEE80211_CONF_CHANGE_POWER) {
                dev->mt76.txpower_conf = hw->conf.power_level * 2;
 
-               if (test_bit(MT76_STATE_RUNNING, &dev->mt76.state))
+               if (test_bit(MT76_STATE_RUNNING, &dev->mphy.state))
                        mt76x0_phy_set_txpower(dev);
        }
 
 
                                     MT_MAC_WORK_INTERVAL);
        ieee80211_queue_delayed_work(dev->mt76.hw, &dev->cal_work,
                                     MT_CALIBRATE_INTERVAL);
-       set_bit(MT76_STATE_RUNNING, &dev->mt76.state);
+       set_bit(MT76_STATE_RUNNING, &dev->mphy.state);
 
        return 0;
 }
 {
        struct mt76x02_dev *dev = hw->priv;
 
-       clear_bit(MT76_STATE_RUNNING, &dev->mt76.state);
+       clear_bit(MT76_STATE_RUNNING, &dev->mphy.state);
        mt76x0e_stop_hw(dev);
 }
 
        if (err < 0)
                return err;
 
-       set_bit(MT76_STATE_INITIALIZED, &dev->mt76.state);
+       set_bit(MT76_STATE_INITIALIZED, &dev->mphy.state);
 
        return 0;
 }
 
 static void mt76x0e_cleanup(struct mt76x02_dev *dev)
 {
-       clear_bit(MT76_STATE_INITIALIZED, &dev->mt76.state);
+       clear_bit(MT76_STATE_INITIALIZED, &dev->mphy.state);
        tasklet_disable(&dev->mt76.pre_tbtt_tasklet);
        mt76x0_chip_onoff(dev, false, false);
        mt76x0e_stop_hw(dev);
 
        if (err < 0)
                return err;
 
-       set_bit(MT76_STATE_MCU_RUNNING, &dev->mt76.state);
+       set_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state);
 
        return 0;
 }
 
        int ret = 0;
        u8 bank, reg;
 
-       if (test_bit(MT76_REMOVED, &dev->mt76.state))
+       if (test_bit(MT76_REMOVED, &dev->mphy.state))
                return -ENODEV;
 
        bank = MT_RF_BANK(offset);
        u32 val;
        u8 bank, reg;
 
-       if (test_bit(MT76_REMOVED, &dev->mt76.state))
+       if (test_bit(MT76_REMOVED, &dev->mphy.state))
                return -ENODEV;
 
        bank = MT_RF_BANK(offset);
                };
 
                WARN_ON_ONCE(!test_bit(MT76_STATE_MCU_RUNNING,
-                                      &dev->mt76.state));
+                                      &dev->mphy.state));
                return mt76_wr_rp(dev, MT_MCU_MEMMAP_RF, &pair, 1);
        } else {
                return mt76x0_rf_csr_wr(dev, offset, val);
                };
 
                WARN_ON_ONCE(!test_bit(MT76_STATE_MCU_RUNNING,
-                                      &dev->mt76.state));
+                                      &dev->mphy.state));
                ret = mt76_rd_rp(dev, MT_MCU_MEMMAP_RF, &pair, 1);
                val = pair.value;
        } else {
                      FIELD_PREP(MT_EXT_CCA_CFG_CCA3, 0) |
                      FIELD_PREP(MT_EXT_CCA_CFG_CCA_MASK, BIT(3)),
        };
-       bool scan = test_bit(MT76_SCANNING, &dev->mt76.state);
+       bool scan = test_bit(MT76_SCANNING, &dev->mphy.state);
        int ch_group_index, freq, freq1;
        u8 channel;
        u32 val;
 
 
 static void mt76x0u_cleanup(struct mt76x02_dev *dev)
 {
-       clear_bit(MT76_STATE_INITIALIZED, &dev->mt76.state);
+       clear_bit(MT76_STATE_INITIALIZED, &dev->mphy.state);
        mt76x0_chip_onoff(dev, false, false);
        mt76u_queues_deinit(&dev->mt76);
 }
 {
        struct mt76x02_dev *dev = hw->priv;
 
-       clear_bit(MT76_STATE_RUNNING, &dev->mt76.state);
+       clear_bit(MT76_STATE_RUNNING, &dev->mphy.state);
        cancel_delayed_work_sync(&dev->cal_work);
        cancel_delayed_work_sync(&dev->mt76.mac_work);
        mt76u_stop_tx(&dev->mt76);
        mt76x02u_exit_beacon_config(dev);
 
-       if (test_bit(MT76_REMOVED, &dev->mt76.state))
+       if (test_bit(MT76_REMOVED, &dev->mphy.state))
                return;
 
        if (!mt76_poll(dev, MT_USB_DMA_CFG, MT_USB_DMA_CFG_TX_BUSY, 0, 1000))
                                     MT_MAC_WORK_INTERVAL);
        ieee80211_queue_delayed_work(dev->mt76.hw, &dev->cal_work,
                                     MT_CALIBRATE_INTERVAL);
-       set_bit(MT76_STATE_RUNNING, &dev->mt76.state);
+       set_bit(MT76_STATE_RUNNING, &dev->mphy.state);
        return 0;
 }
 
        else
                hw->max_tx_fragments = 1;
 
-       set_bit(MT76_STATE_INITIALIZED, &dev->mt76.state);
+       set_bit(MT76_STATE_INITIALIZED, &dev->mphy.state);
 
        return 0;
 
 static void mt76x0_disconnect(struct usb_interface *usb_intf)
 {
        struct mt76x02_dev *dev = usb_get_intfdata(usb_intf);
-       bool initialized = test_bit(MT76_STATE_INITIALIZED, &dev->mt76.state);
+       bool initialized = test_bit(MT76_STATE_INITIALIZED, &dev->mphy.state);
 
        if (!initialized)
                return;
        struct mt76x02_dev *dev = usb_get_intfdata(usb_intf);
 
        mt76u_stop_rx(&dev->mt76);
-       clear_bit(MT76_STATE_MCU_RUNNING, &dev->mt76.state);
+       clear_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state);
        mt76x0_chip_onoff(dev, false, false);
 
        return 0;
 
        if (ret < 0)
                return ret;
 
-       set_bit(MT76_STATE_MCU_RUNNING, &dev->mt76.state);
+       set_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state);
 
        return 0;
 }
 
        u32 engine_mask;
        int i;
 
-       if (test_bit(MT76_SCANNING, &dev->mt76.state))
+       if (test_bit(MT76_SCANNING, &dev->mphy.state))
                goto out;
 
        if (time_is_before_jiffies(dfs_pd->last_sw_check +
 
        u8 wcid;
        int len;
 
-       if (!test_bit(MT76_STATE_RUNNING, &dev->mt76.state))
+       if (!test_bit(MT76_STATE_RUNNING, &dev->mphy.state))
                return -EINVAL;
 
        if (rxinfo & MT_RXINFO_L2PAD)
        u8 update = 1;
        bool ret;
 
-       if (!test_bit(MT76_STATE_RUNNING, &dev->mt76.state))
+       if (!test_bit(MT76_STATE_RUNNING, &dev->mphy.state))
                return;
 
        trace_mac_txstat_poll(dev);
 
        int i;
 
        for (i = 0; i < 500; i++) {
-               if (test_bit(MT76_REMOVED, &dev->state))
+               if (test_bit(MT76_REMOVED, &dev->phy.state))
                        return false;
 
                switch (dev->bus->rr(dev, MAC_CSR0)) {
 
        intr = mt76_rr(dev, MT_INT_SOURCE_CSR);
        mt76_wr(dev, MT_INT_SOURCE_CSR, intr);
 
-       if (!test_bit(MT76_STATE_INITIALIZED, &dev->mt76.state))
+       if (!test_bit(MT76_STATE_INITIALIZED, &dev->mphy.state))
                return IRQ_NONE;
 
        trace_dev_irq(dev, intr, dev->mt76.mmio.irqmask);
 
        lockdep_assert_held(&dev->mt76.mutex);
 
-       clear_bit(MT76_STATE_RUNNING, &dev->mt76.state);
+       clear_bit(MT76_STATE_RUNNING, &dev->mphy.state);
 
        rcu_read_lock();
        ieee80211_iter_keys_rcu(dev->mt76.hw, NULL, mt76x02_key_sync, NULL);
        int i;
 
        ieee80211_stop_queues(dev->mt76.hw);
-       set_bit(MT76_RESET, &dev->mt76.state);
+       set_bit(MT76_RESET, &dev->mphy.state);
 
        tasklet_disable(&dev->mt76.pre_tbtt_tasklet);
        tasklet_disable(&dev->mt76.tx_tasklet);
 
        mutex_unlock(&dev->mt76.mutex);
 
-       clear_bit(MT76_RESET, &dev->mt76.state);
+       clear_bit(MT76_RESET, &dev->mphy.state);
 
        tasklet_enable(&dev->mt76.tx_tasklet);
        napi_enable(&dev->mt76.tx_napi);
 
 
 void mt76x02u_exit_beacon_config(struct mt76x02_dev *dev)
 {
-       if (!test_bit(MT76_REMOVED, &dev->mt76.state))
+       if (!test_bit(MT76_REMOVED, &dev->mphy.state))
                mt76_clear(dev, MT_BEACON_TIME_CFG,
                           MT_BEACON_TIME_CFG_TIMER_EN |
                           MT_BEACON_TIME_CFG_SYNC_MODE |
 
        u8 seq = 0;
        u32 info;
 
-       if (test_bit(MT76_REMOVED, &dev->state))
+       if (test_bit(MT76_REMOVED, &dev->phy.state))
                return 0;
 
        if (wait_resp) {
 
 {
        struct mt76x02_dev *dev = hw->priv;
 
-       clear_bit(MT76_SCANNING, &dev->mt76.state);
+       clear_bit(MT76_SCANNING, &dev->mphy.state);
        if (dev->cal.gain_init_done) {
                /* Restore AGC gain and resume calibration after scanning. */
                dev->cal.low_gain = -1;
 
        if (ret)
                return ret;
 
-       set_bit(MT76_STATE_INITIALIZED, &dev->mt76.state);
+       set_bit(MT76_STATE_INITIALIZED, &dev->mphy.state);
        mt76x02_mac_start(dev);
 
        ret = mt76x2_mcu_init(dev);
 
        ieee80211_queue_delayed_work(mt76_hw(dev), &dev->wdt_work,
                                     MT_WATCHDOG_TIME);
 
-       set_bit(MT76_STATE_RUNNING, &dev->mt76.state);
+       set_bit(MT76_STATE_RUNNING, &dev->mphy.state);
        return 0;
 }
 
 {
        struct mt76x02_dev *dev = hw->priv;
 
-       clear_bit(MT76_STATE_RUNNING, &dev->mt76.state);
+       clear_bit(MT76_STATE_RUNNING, &dev->mphy.state);
        mt76x2_stop_hardware(dev);
 }
 
        tasklet_disable(&dev->dfs_pd.dfs_tasklet);
 
        mutex_lock(&dev->mt76.mutex);
-       set_bit(MT76_RESET, &dev->mt76.state);
+       set_bit(MT76_RESET, &dev->mphy.state);
 
        mt76_set_channel(&dev->mphy);
 
 
        mt76x2_mac_resume(dev);
 
-       clear_bit(MT76_RESET, &dev->mt76.state);
+       clear_bit(MT76_RESET, &dev->mphy.state);
        mutex_unlock(&dev->mt76.mutex);
 
        tasklet_enable(&dev->dfs_pd.dfs_tasklet);
                /* convert to per-chain power for 2x2 devices */
                dev->mt76.txpower_conf -= 6;
 
-               if (test_bit(MT76_STATE_RUNNING, &dev->mt76.state)) {
+               if (test_bit(MT76_STATE_RUNNING, &dev->mphy.state)) {
                        mt76x2_phy_set_txpower(dev);
                        mt76x02_tx_set_txpwr_auto(dev, dev->mt76.txpower_conf);
                }
 
                           struct cfg80211_chan_def *chandef)
 {
        struct ieee80211_channel *chan = chandef->chan;
-       bool scan = test_bit(MT76_SCANNING, &dev->mt76.state);
+       bool scan = test_bit(MT76_SCANNING, &dev->mphy.state);
        enum nl80211_band band = chan->band;
        u8 channel;
 
 
        struct mt76x02_dev *dev = usb_get_intfdata(intf);
        struct ieee80211_hw *hw = mt76_hw(dev);
 
-       set_bit(MT76_REMOVED, &dev->mt76.state);
+       set_bit(MT76_REMOVED, &dev->mphy.state);
        ieee80211_unregister_hw(hw);
        mt76x2u_cleanup(dev);
        mt76u_deinit(&dev->mt76);
 
        else
                hw->max_tx_fragments = 1;
 
-       set_bit(MT76_STATE_INITIALIZED, &dev->mt76.state);
+       set_bit(MT76_STATE_INITIALIZED, &dev->mphy.state);
 
        mt76x02_init_debugfs(dev);
        mt76x2_init_txpower(dev, &dev->mphy.sband_2g.sband);
 
        bool stopped = false;
        u32 rts_cfg;
 
-       if (test_bit(MT76_REMOVED, &dev->mt76.state))
+       if (test_bit(MT76_REMOVED, &dev->mphy.state))
                return -EIO;
 
        rts_cfg = mt76_rr(dev, MT_TX_RTS_CFG);
 
 
        ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mt76.mac_work,
                                     MT_MAC_WORK_INTERVAL);
-       set_bit(MT76_STATE_RUNNING, &dev->mt76.state);
+       set_bit(MT76_STATE_RUNNING, &dev->mphy.state);
 
        return 0;
 }
 {
        struct mt76x02_dev *dev = hw->priv;
 
-       clear_bit(MT76_STATE_RUNNING, &dev->mt76.state);
+       clear_bit(MT76_STATE_RUNNING, &dev->mphy.state);
        mt76u_stop_tx(&dev->mt76);
        mt76x2u_stop_hw(dev);
 }
        mt76x02_pre_tbtt_enable(dev, false);
 
        mutex_lock(&dev->mt76.mutex);
-       set_bit(MT76_RESET, &dev->mt76.state);
+       set_bit(MT76_RESET, &dev->mphy.state);
 
        mt76_set_channel(&dev->mphy);
 
        mt76x02_mac_cc_reset(dev);
        mt76x2_mac_resume(dev);
 
-       clear_bit(MT76_RESET, &dev->mt76.state);
+       clear_bit(MT76_RESET, &dev->mphy.state);
        mutex_unlock(&dev->mt76.mutex);
 
        mt76x02_pre_tbtt_enable(dev, true);
                /* convert to per-chain power for 2x2 devices */
                dev->mt76.txpower_conf -= 6;
 
-               if (test_bit(MT76_STATE_RUNNING, &dev->mt76.state))
+               if (test_bit(MT76_STATE_RUNNING, &dev->mphy.state))
                        mt76x2_phy_set_txpower(dev);
        }
 
 
                      FIELD_PREP(MT_EXT_CCA_CFG_CCA3, 0) |
                      FIELD_PREP(MT_EXT_CCA_CFG_CCA_MASK, BIT(3)),
        };
-       bool scan = test_bit(MT76_SCANNING, &dev->mt76.state);
+       bool scan = test_bit(MT76_SCANNING, &dev->mphy.state);
        struct ieee80211_channel *chan = chandef->chan;
        u8 channel = chan->hw_value, bw, bw_index;
        int ch_group_index, freq, freq1, ret;
 
                if (probe)
                        break;
 
-               if (test_bit(MT76_RESET, &dev->state))
+               if (test_bit(MT76_RESET, &phy->state))
                        return -EBUSY;
 
                skb = mt76_txq_dequeue(phy, mtxq, false);
                if (sq->swq_queued >= 4)
                        break;
 
-               if (test_bit(MT76_RESET, &dev->state)) {
+               if (test_bit(MT76_RESET, &phy->state)) {
                        ret = -EBUSY;
                        break;
                }
        struct mt76_phy *phy = hw->priv;
        struct mt76_dev *dev = phy->dev;
 
-       if (!test_bit(MT76_STATE_RUNNING, &dev->state))
+       if (!test_bit(MT76_STATE_RUNNING, &phy->state))
                return;
 
        tasklet_schedule(&dev->tx_tasklet);
 
        pipe = (req_type & USB_DIR_IN) ? usb_rcvctrlpipe(udev, 0)
                                       : usb_sndctrlpipe(udev, 0);
        for (i = 0; i < MT_VEND_REQ_MAX_RETRY; i++) {
-               if (test_bit(MT76_REMOVED, &dev->state))
+               if (test_bit(MT76_REMOVED, &dev->phy.state))
                        return -EIO;
 
                ret = usb_control_msg(udev, pipe, req, req_type, val,
                                      offset, buf, len, MT_VEND_REQ_TOUT_MS);
                if (ret == -ENODEV)
-                       set_bit(MT76_REMOVED, &dev->state);
+                       set_bit(MT76_REMOVED, &dev->phy.state);
                if (ret >= 0 || ret == -ENODEV)
                        return ret;
                usleep_range(5000, 10000);
 mt76u_wr_rp(struct mt76_dev *dev, u32 base,
            const struct mt76_reg_pair *data, int n)
 {
-       if (test_bit(MT76_STATE_MCU_RUNNING, &dev->state))
+       if (test_bit(MT76_STATE_MCU_RUNNING, &dev->phy.state))
                return dev->mcu_ops->mcu_wr_rp(dev, base, data, n);
        else
                return mt76u_req_wr_rp(dev, base, data, n);
 mt76u_rd_rp(struct mt76_dev *dev, u32 base,
            struct mt76_reg_pair *data, int n)
 {
-       if (test_bit(MT76_STATE_MCU_RUNNING, &dev->state))
+       if (test_bit(MT76_STATE_MCU_RUNNING, &dev->phy.state))
                return dev->mcu_ops->mcu_rd_rp(dev, base, data, n);
        else
                return mt76u_req_rd_rp(dev, base, data, n);
        int len, nsgs = 1;
        struct sk_buff *skb;
 
-       if (!test_bit(MT76_STATE_INITIALIZED, &dev->state))
+       if (!test_bit(MT76_STATE_INITIALIZED, &dev->phy.state))
                return 0;
 
        len = mt76u_get_rx_entry_len(data, urb->actual_length);
 
                mt76_txq_schedule(&dev->phy, i);
 
-               if (!test_and_set_bit(MT76_READING_STATS, &dev->state))
+               if (!test_and_set_bit(MT76_READING_STATS, &dev->phy.state))
                        queue_work(dev->usb.stat_wq, &dev->usb.stat_work);
                if (wake)
                        ieee80211_wake_queue(dev->hw, i);
        dev = container_of(usb, struct mt76_dev, usb);
 
        while (true) {
-               if (test_bit(MT76_REMOVED, &dev->state))
+               if (test_bit(MT76_REMOVED, &dev->phy.state))
                        break;
 
                if (!dev->drv->tx_status_data(dev, &update))
                count++;
        }
 
-       if (count && test_bit(MT76_STATE_RUNNING, &dev->state))
+       if (count && test_bit(MT76_STATE_RUNNING, &dev->phy.state))
                queue_work(usb->stat_wq, &usb->stat_work);
        else
-               clear_bit(MT76_READING_STATS, &dev->state);
+               clear_bit(MT76_READING_STATS, &dev->phy.state);
 }
 
 static void mt76u_complete_tx(struct urb *urb)
                err = usb_submit_urb(urb, GFP_ATOMIC);
                if (err < 0) {
                        if (err == -ENODEV)
-                               set_bit(MT76_REMOVED, &dev->state);
+                               set_bit(MT76_REMOVED, &dev->phy.state);
                        else
                                dev_err(dev->dev, "tx urb submit failed:%d\n",
                                        err);
        }
 
        cancel_work_sync(&dev->usb.stat_work);
-       clear_bit(MT76_READING_STATS, &dev->state);
+       clear_bit(MT76_READING_STATS, &dev->phy.state);
 
        mt76_tx_status_check(dev, NULL, true);
 }