}
 EXPORT_SYMBOL_GPL(mt76_get_antenna);
 
-int mt76_init_tx_queue(struct mt76_dev *dev, int qid, int idx,
-                      int n_desc, int ring_base)
+struct mt76_queue *
+mt76_init_queue(struct mt76_dev *dev, int qid, int idx, int n_desc,
+               int ring_base)
 {
        struct mt76_queue *hwq;
        int err;
 
        hwq = devm_kzalloc(dev->dev, sizeof(*hwq), GFP_KERNEL);
        if (!hwq)
-               return -ENOMEM;
+               return ERR_PTR(-ENOMEM);
 
        err = dev->queue_ops->alloc(dev, hwq, idx, n_desc, 0, ring_base);
        if (err < 0)
-               return err;
-
-       hwq->qid = qid;
-       dev->q_tx[qid] = hwq;
+               return ERR_PTR(err);
 
-       return 0;
+       return hwq;
 }
-EXPORT_SYMBOL_GPL(mt76_init_tx_queue);
+EXPORT_SYMBOL_GPL(mt76_init_queue);
 
        __MT_TXQ_MAX
 };
 
+enum mt76_mcuq_id {
+       __MT_MCUQ_MAX
+};
+
 enum mt76_rxq_id {
        MT_RXQ_MAIN,
        MT_RXQ_MCU,
 
        struct list_head txwi_cache;
        struct mt76_queue *q_tx[2 * __MT_TXQ_MAX];
+       struct mt76_queue *q_mcu[__MT_MCUQ_MAX];
        struct mt76_queue q_rx[__MT_RXQ_MAX];
        const struct mt76_queue_ops *queue_ops;
        int tx_dma_idx[4];
 int mt76_eeprom_init(struct mt76_dev *dev, int len);
 void mt76_eeprom_override(struct mt76_dev *dev);
 
-int mt76_init_tx_queue(struct mt76_dev *dev, int qid, int idx,
-                      int n_desc, int ring_base);
+struct mt76_queue *
+mt76_init_queue(struct mt76_dev *dev, int qid, int idx, int n_desc,
+               int ring_base);
+static inline int mt76_init_tx_queue(struct mt76_phy *phy, int qid, int idx,
+                                    int n_desc, int ring_base)
+{
+       struct mt76_queue *q;
+
+       q = mt76_init_queue(phy->dev, qid, idx, n_desc, ring_base);
+       if (IS_ERR(q))
+               return PTR_ERR(q);
+
+       q->qid = qid;
+       phy->dev->q_tx[qid] = q;
+
+       return 0;
+}
+
+static inline int mt76_init_mcu_queue(struct mt76_dev *dev, int qid, int idx,
+                                     int n_desc, int ring_base)
+{
+       struct mt76_queue *q;
+
+       q = mt76_init_queue(dev, qid, idx, n_desc, ring_base);
+       if (IS_ERR(q))
+               return PTR_ERR(q);
+
+       q->qid = qid;
+       dev->q_mcu[qid] = q;
+
+       return 0;
+}
 
 static inline struct mt76_phy *
 mt76_dev_phy(struct mt76_dev *dev, bool phy_ext)
 
 {
        int err;
 
-       err = mt76_init_tx_queue(&dev->mt76, qid, idx, n_desc,
+       err = mt76_init_tx_queue(&dev->mphy, qid, idx, n_desc,
                                 MT_TX_RING_BASE);
        if (err < 0)
                return err;
 
        int i;
 
        for (i = 0; i < ARRAY_SIZE(wmm_queue_map); i++) {
-               ret = mt76_init_tx_queue(&dev->mt76, i, wmm_queue_map[i],
+               ret = mt76_init_tx_queue(&dev->mphy, i, wmm_queue_map[i],
                                         MT7615_TX_RING_SIZE / 2,
                                         MT_TX_RING_BASE);
                if (ret)
                        return ret;
        }
 
-       ret = mt76_init_tx_queue(&dev->mt76, MT_TXQ_PSD, MT7622_TXQ_MGMT,
+       ret = mt76_init_tx_queue(&dev->mphy, MT_TXQ_PSD, MT7622_TXQ_MGMT,
                                 MT7615_TX_MGMT_RING_SIZE,
                                 MT_TX_RING_BASE);
        if (ret)
                return ret;
 
-       return mt76_init_tx_queue(&dev->mt76, MT_TXQ_MCU, MT7622_TXQ_MCU,
+       return mt76_init_tx_queue(&dev->mphy, MT_TXQ_MCU, MT7622_TXQ_MCU,
                                  MT7615_TX_MCU_RING_SIZE,
                                  MT_TX_RING_BASE);
 }
 {
        int ret, i;
 
-       ret = mt76_init_tx_queue(&dev->mt76, MT_TXQ_FWDL, MT7615_TXQ_FWDL,
+       ret = mt76_init_tx_queue(&dev->mphy, MT_TXQ_FWDL, MT7615_TXQ_FWDL,
                                 MT7615_TX_FWDL_RING_SIZE,
                                 MT_TX_RING_BASE);
        if (ret)
        if (!is_mt7615(&dev->mt76))
                return mt7622_init_tx_queues_multi(dev);
 
-       ret = mt76_init_tx_queue(&dev->mt76, 0, 0, MT7615_TX_RING_SIZE,
+       ret = mt76_init_tx_queue(&dev->mphy, 0, 0, MT7615_TX_RING_SIZE,
                                 MT_TX_RING_BASE);
        if (ret)
                return ret;
        for (i = 1; i < MT_TXQ_MCU; i++)
                dev->mt76.q_tx[i] = dev->mt76.q_tx[0];
 
-       return mt76_init_tx_queue(&dev->mt76, MT_TXQ_MCU, MT7615_TXQ_MCU,
+       return mt76_init_tx_queue(&dev->mphy, MT_TXQ_MCU, MT7615_TXQ_MCU,
                                  MT7615_TX_MCU_RING_SIZE,
                                  MT_TX_RING_BASE);
 }
 
 {
        int err;
 
-       err = mt76_init_tx_queue(&dev->mt76, qid, idx, n_desc,
+       err = mt76_init_tx_queue(&dev->mphy, qid, idx, n_desc,
                                 MT_TX_RING_BASE);
        if (err < 0)
                return err;
 
 {
        int i, err;
 
-       err = mt76_init_tx_queue(&dev->mt76, 0, idx, n_desc, MT_TX_RING_BASE);
+       err = mt76_init_tx_queue(&dev->mphy, 0, idx, n_desc, MT_TX_RING_BASE);
        if (err < 0)
                return err;
 
                return ret;
 
        /* command to WM */
-       ret = mt76_init_tx_queue(&dev->mt76, MT_TXQ_MCU, MT7915_TXQ_MCU_WM,
+       ret = mt76_init_tx_queue(&dev->mphy, MT_TXQ_MCU, MT7915_TXQ_MCU_WM,
                                 MT7915_TX_MCU_RING_SIZE, MT_TX_RING_BASE);
        if (ret)
                return ret;
 
        /* command to WA */
-       ret = mt76_init_tx_queue(&dev->mt76, MT_TXQ_MCU_WA, MT7915_TXQ_MCU_WA,
+       ret = mt76_init_tx_queue(&dev->mphy, MT_TXQ_MCU_WA, MT7915_TXQ_MCU_WA,
                                 MT7915_TX_MCU_RING_SIZE, MT_TX_RING_BASE);
        if (ret)
                return ret;
 
        /* firmware download */
-       ret = mt76_init_tx_queue(&dev->mt76, MT_TXQ_FWDL, MT7915_TXQ_FWDL,
+       ret = mt76_init_tx_queue(&dev->mphy, MT_TXQ_FWDL, MT7915_TXQ_FWDL,
                                 MT7915_TX_FWDL_RING_SIZE, MT_TX_RING_BASE);
        if (ret)
                return ret;