skb->prev = skb->next = NULL;
        dma_sync_single_for_cpu(dev->dev, t->dma_addr, sizeof(t->txwi),
                                DMA_TO_DEVICE);
-       ret = dev->drv->tx_prepare_skb(dev, &t->txwi, skb, q, wcid, sta,
+       ret = dev->drv->tx_prepare_skb(dev, &t->txwi, skb, qid, wcid, sta,
                                       &tx_info);
        dma_sync_single_for_device(dev->dev, t->dma_addr, sizeof(t->txwi),
                                   DMA_TO_DEVICE);
 
        void (*update_survey)(struct mt76_dev *dev);
 
        int (*tx_prepare_skb)(struct mt76_dev *dev, void *txwi_ptr,
-                             struct sk_buff *skb, struct mt76_queue *q,
+                             struct sk_buff *skb, enum mt76_txq_id qid,
                              struct mt76_wcid *wcid,
                              struct ieee80211_sta *sta, u32 *tx_info);
 
 
 
 static int
 mt7603_mac_write_txwi(struct mt7603_dev *dev, __le32 *txwi,
-                     struct sk_buff *skb, struct mt76_queue *q,
+                     struct sk_buff *skb, enum mt76_txq_id qid,
                      struct mt76_wcid *wcid, struct ieee80211_sta *sta,
                      int pid, struct ieee80211_key_conf *key)
 {
        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
        struct ieee80211_bar *bar = (struct ieee80211_bar *)skb->data;
        struct ieee80211_vif *vif = info->control.vif;
+       struct mt76_queue *q = &dev->mt76.q_tx[qid];
        struct mt7603_vif *mvif;
        int wlan_idx;
        int hdr_len = ieee80211_get_hdrlen_from_skb(skb);
        if (vif) {
                mvif = (struct mt7603_vif *)vif->drv_priv;
                vif_idx = mvif->idx;
-               if (vif_idx && q >= &dev->mt76.q_tx[MT_TXQ_BEACON])
+               if (vif_idx && qid >= MT_TXQ_BEACON)
                        vif_idx += 0x10;
        }
 
        }
 
        /* use maximum tx count for beacons and buffered multicast */
-       if (q >= &dev->mt76.q_tx[MT_TXQ_BEACON])
+       if (qid >= MT_TXQ_BEACON)
                tx_count = 0x1f;
 
        val = FIELD_PREP(MT_TXD3_REM_TX_COUNT, tx_count) |
 }
 
 int mt7603_tx_prepare_skb(struct mt76_dev *mdev, void *txwi_ptr,
-                         struct sk_buff *skb, struct mt76_queue *q,
+                         struct sk_buff *skb, enum mt76_txq_id qid,
                          struct mt76_wcid *wcid, struct ieee80211_sta *sta,
                          u32 *tx_info)
 {
                spin_unlock_bh(&dev->mt76.lock);
        }
 
-       mt7603_mac_write_txwi(dev, txwi_ptr, skb, q, wcid, sta, pid, key);
+       mt7603_mac_write_txwi(dev, txwi_ptr, skb, qid, wcid, sta, pid, key);
 
        return 0;
 }
 
 void mt7603_filter_tx(struct mt7603_dev *dev, int idx, bool abort);
 
 int mt7603_tx_prepare_skb(struct mt76_dev *mdev, void *txwi_ptr,
-                         struct sk_buff *skb, struct mt76_queue *q,
+                         struct sk_buff *skb, enum mt76_txq_id qid,
                          struct mt76_wcid *wcid, struct ieee80211_sta *sta,
                          u32 *tx_info);
 
 
 void mt76x02_tx(struct ieee80211_hw *hw, struct ieee80211_tx_control *control,
                struct sk_buff *skb);
 int mt76x02_tx_prepare_skb(struct mt76_dev *mdev, void *txwi,
-                          struct sk_buff *skb, struct mt76_queue *q,
+                          struct sk_buff *skb, enum mt76_txq_id qid,
                           struct mt76_wcid *wcid, struct ieee80211_sta *sta,
                           u32 *tx_info);
 void mt76x02_sw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 
 EXPORT_SYMBOL_GPL(mt76x02_tx_status_data);
 
 int mt76x02_tx_prepare_skb(struct mt76_dev *mdev, void *txwi_ptr,
-                          struct sk_buff *skb, struct mt76_queue *q,
+                          struct sk_buff *skb, enum mt76_txq_id qid,
                           struct mt76_wcid *wcid, struct ieee80211_sta *sta,
                           u32 *tx_info)
 {
        int pid;
        int ret;
 
-       if (q == &dev->mt76.q_tx[MT_TXQ_PSD] && wcid && wcid->idx < 128)
+       if (qid == MT_TXQ_PSD && wcid && wcid->idx < 128)
                mt76x02_mac_wcid_set_drop(dev, wcid->idx, false);
 
        mt76x02_mac_write_txwi(dev, txwi, skb, wcid, sta, skb->len);
 
 
 int mt76x02u_skb_dma_info(struct sk_buff *skb, int port, u32 flags);
 int mt76x02u_tx_prepare_skb(struct mt76_dev *mdev, void *data,
-                           struct sk_buff *skb, struct mt76_queue *q,
+                           struct sk_buff *skb, enum mt76_txq_id qid,
                            struct mt76_wcid *wcid, struct ieee80211_sta *sta,
                            u32 *tx_info);
 void mt76x02u_tx_complete_skb(struct mt76_dev *mdev, struct mt76_queue *q,
 
 }
 
 int mt76x02u_tx_prepare_skb(struct mt76_dev *mdev, void *data,
-                           struct sk_buff *skb, struct mt76_queue *q,
+                           struct sk_buff *skb, enum mt76_txq_id qid,
                            struct mt76_wcid *wcid, struct ieee80211_sta *sta,
                            u32 *tx_info)
 {
        struct mt76x02_dev *dev = container_of(mdev, struct mt76x02_dev, mt76);
+       int pid, len = skb->len, ep = q2ep(mdev->q_tx[qid].hw_idx);
        struct mt76x02_txwi *txwi;
        enum mt76_qsel qsel;
-       int len = skb->len;
        u32 flags;
-       int pid;
 
        mt76x02_insert_hdr_pad(skb);
 
        pid = mt76_tx_status_skb_add(mdev, wcid, skb);
        txwi->pktid = pid;
 
-       if (pid >= MT_PACKET_ID_FIRST || q2ep(q->hw_idx) == MT_EP_OUT_HCCA)
+       if (pid >= MT_PACKET_ID_FIRST || ep == MT_EP_OUT_HCCA)
                qsel = MT_QSEL_MGMT;
        else
                qsel = MT_QSEL_EDCA;
 
                return -ENOSPC;
 
        skb->prev = skb->next = NULL;
-       err = dev->drv->tx_prepare_skb(dev, NULL, skb, q, wcid, sta, NULL);
+       err = dev->drv->tx_prepare_skb(dev, NULL, skb, qid, wcid, sta, NULL);
        if (err < 0)
                return err;