/* TX */
 void mt76x0_tx(struct ieee80211_hw *hw, struct ieee80211_tx_control *control,
                struct sk_buff *skb);
-struct mt76x02_txwi *
-mt76x0_push_txwi(struct mt76x0_dev *dev, struct sk_buff *skb,
-                struct ieee80211_sta *sta, struct mt76_wcid *wcid,
-                int pkt_len);
-
 void mt76x0_queue_rx_skb(struct mt76_dev *mdev, enum mt76_rxq_id q,
                         struct sk_buff *skb);
 
 
 #include "../mt76x02_util.h"
 #include "../mt76x02_usb.h"
 
-struct mt76x02_txwi *
-mt76x0_push_txwi(struct mt76x0_dev *dev, struct sk_buff *skb,
-                struct ieee80211_sta *sta, struct mt76_wcid *wcid,
-                int pkt_len)
-{
-       struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
-       struct ieee80211_tx_rate *rate = &info->control.rates[0];
-       struct mt76x02_txwi *txwi;
-       unsigned long flags;
-       u16 rate_ctl;
-       u8 nss;
-
-       txwi = (struct mt76x02_txwi *)skb_push(skb, sizeof(struct mt76x02_txwi));
-       memset(txwi, 0, sizeof(*txwi));
-
-       if (!wcid->tx_rate_set)
-               ieee80211_get_tx_rates(info->control.vif, sta, skb,
-                                      info->control.rates, 1);
-
-       spin_lock_irqsave(&dev->mt76.lock, flags);
-       if (rate->idx < 0 || !rate->count) {
-               rate_ctl = wcid->tx_rate;
-               nss = wcid->tx_rate_nss;
-       } else {
-               rate_ctl = mt76x02_mac_tx_rate_val(&dev->mt76, rate, &nss);
-       }
-       spin_unlock_irqrestore(&dev->mt76.lock, flags);
-
-       txwi->wcid = wcid->idx;
-       txwi->rate = cpu_to_le16(rate_ctl);
-       txwi->pktid = (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) ? 1 : 0;
-
-       mt76x02_mac_fill_txwi(txwi, skb, sta, pkt_len, nss);
-
-       return txwi;
-}
-EXPORT_SYMBOL_GPL(mt76x0_push_txwi);
-
 void mt76x0_tx(struct ieee80211_hw *hw, struct ieee80211_tx_control *control,
               struct sk_buff *skb)
 {
 
        .wake_tx_queue = mt76_wake_tx_queue,
 };
 
-static int mt76x0u_tx_prepare_skb(struct mt76_dev *mdev, void *data,
-                                 struct sk_buff *skb, struct mt76_queue *q,
-                                 struct mt76_wcid *wcid, struct ieee80211_sta *sta,
-                                 u32 *tx_info)
-{
-       struct mt76x0_dev *dev = container_of(mdev, struct mt76x0_dev, mt76);
-       struct mt76x02_txwi *txwi;
-       int len = skb->len;
-
-       mt76x02_insert_hdr_pad(skb);
-       txwi = mt76x0_push_txwi(dev, skb, sta, wcid, len);
-
-       return mt76x02u_set_txinfo(skb, wcid, q2ep(q->hw_idx));
-}
-
 static int mt76x0u_register_device(struct mt76x0_dev *dev)
 {
        struct ieee80211_hw *hw = dev->mt76.hw;
                         const struct usb_device_id *id)
 {
        static const struct mt76_driver_ops drv_ops = {
-               .tx_prepare_skb = mt76x0u_tx_prepare_skb,
+               .tx_prepare_skb = mt76x02u_tx_prepare_skb,
                .tx_complete_skb = mt76x02_tx_complete_skb,
                .tx_status_data = mt76x02_tx_status_data,
                .rx_skb = mt76x0_queue_rx_skb,
 
 }
 EXPORT_SYMBOL_GPL(mt76x02_txq_init);
 
-void mt76x02_mac_fill_txwi(struct mt76x02_txwi *txwi, struct sk_buff *skb,
-                         struct ieee80211_sta *sta, int len, u8 nss)
+static void
+mt76x02_mac_fill_txwi(struct mt76x02_txwi *txwi, struct sk_buff *skb,
+                     struct ieee80211_sta *sta, int len, u8 nss)
 {
        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
        txwi->flags |= cpu_to_le16(txwi_flags);
        txwi->len_ctl = cpu_to_le16(len);
 }
-EXPORT_SYMBOL_GPL(mt76x02_mac_fill_txwi);
 
-__le16
+static __le16
 mt76x02_mac_tx_rate_val(struct mt76_dev *dev,
                       const struct ieee80211_tx_rate *rate, u8 *nss_val)
 {
        *nss_val = nss;
        return cpu_to_le16(rateval);
 }
-EXPORT_SYMBOL_GPL(mt76x02_mac_tx_rate_val);
 
 void mt76x02_mac_wcid_set_rate(struct mt76_dev *dev, struct mt76_wcid *wcid,
                              const struct ieee80211_tx_rate *rate)
 
 }
 
 void mt76x02_txq_init(struct mt76_dev *dev, struct ieee80211_txq *txq);
-void mt76x02_mac_fill_txwi(struct mt76x02_txwi *txwi, struct sk_buff *skb,
-                         struct ieee80211_sta *sta, int len, u8 nss);
 enum mt76x02_cipher_type
 mt76x02_mac_get_key_info(struct ieee80211_key_conf *key, u8 *key_data);
 
 void mt76x02_mac_wcid_set_drop(struct mt76_dev *dev, u8 idx, bool drop);
 void mt76x02_mac_wcid_set_rate(struct mt76_dev *dev, struct mt76_wcid *wcid,
                              const struct ieee80211_tx_rate *rate);
-__le16
-mt76x02_mac_tx_rate_val(struct mt76_dev *dev,
-                      const struct ieee80211_tx_rate *rate, u8 *nss_val);
 bool mt76x02_mac_load_tx_status(struct mt76_dev *dev,
                               struct mt76x02_tx_status *stat);
 void mt76x02_send_tx_status(struct mt76_dev *dev,
 
                              int data_len, u32 max_payload, u32 offset);
 
 int mt76x02u_skb_dma_info(struct sk_buff *skb, int port, u32 flags);
-int mt76x02u_set_txinfo(struct sk_buff *skb, struct mt76_wcid *wcid, u8 ep);
+int mt76x02u_tx_prepare_skb(struct mt76_dev *dev, void *data,
+                           struct sk_buff *skb, struct mt76_queue *q,
+                           struct mt76_wcid *wcid, struct ieee80211_sta *sta,
+                           u32 *tx_info);
 #endif /* __MT76x02_USB_H */
 
 
 #include "mt76.h"
 #include "mt76x02_dma.h"
+#include "mt76x02_mac.h"
+#include "mt76x02_util.h"
+
+static int mt76x02u_check_skb_rooms(struct sk_buff *skb)
+{
+       int hdr_len = ieee80211_get_hdrlen_from_skb(skb);
+       u32 need_head;
+
+       need_head = sizeof(struct mt76x02_txwi) + MT_DMA_HDR_LEN;
+       if (hdr_len % 4)
+               need_head += 2;
+       return skb_cow(skb, need_head);
+}
 
 int mt76x02u_skb_dma_info(struct sk_buff *skb, int port, u32 flags)
 {
        return 0;
 }
 
-int mt76x02u_set_txinfo(struct sk_buff *skb, struct mt76_wcid *wcid, u8 ep)
+static int
+mt76x02u_set_txinfo(struct sk_buff *skb, struct mt76_wcid *wcid, u8 ep)
 {
        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
        enum mt76_qsel qsel;
 
        return mt76x02u_skb_dma_info(skb, WLAN_PORT, flags);
 }
-EXPORT_SYMBOL_GPL(mt76x02u_set_txinfo);
+
+int mt76x02u_tx_prepare_skb(struct mt76_dev *dev, void *data,
+                           struct sk_buff *skb, struct mt76_queue *q,
+                           struct mt76_wcid *wcid, struct ieee80211_sta *sta,
+                           u32 *tx_info)
+{
+       struct mt76x02_txwi *txwi;
+       int err, len = skb->len;
+
+       err = mt76x02u_check_skb_rooms(skb);
+       if (err < 0)
+               return -ENOMEM;
+
+       mt76x02_insert_hdr_pad(skb);
+
+       txwi = skb_push(skb, sizeof(struct mt76x02_txwi));
+       mt76x02_mac_write_txwi(dev, txwi, skb, wcid, sta, len);
+
+       return mt76x02u_set_txinfo(skb, wcid, q2ep(q->hw_idx));
+}
+EXPORT_SYMBOL_GPL(mt76x02u_tx_prepare_skb);
 
 
 mt76x2u-y := \
        usb.o usb_init.o usb_main.o usb_mac.o usb_mcu.o \
-       usb_phy.o usb_core.o
+       usb_phy.o
 
 CFLAGS_pci_trace.o := -I$(src)
 
 int mt76x2u_alloc_queues(struct mt76x2_dev *dev);
 void mt76x2u_queues_deinit(struct mt76x2_dev *dev);
 void mt76x2u_stop_queues(struct mt76x2_dev *dev);
-int mt76x2u_tx_prepare_skb(struct mt76_dev *mdev, void *data,
-                          struct sk_buff *skb, struct mt76_queue *q,
-                          struct mt76_wcid *wcid, struct ieee80211_sta *sta,
-                          u32 *tx_info);
 int mt76x2u_skb_dma_info(struct sk_buff *skb, enum dma_msg_port port,
                         u32 flags);
 
 
+++ /dev/null
-/*
- * Copyright (C) 2018 Lorenzo Bianconi <lorenzo.bianconi83@gmail.com>
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include "mt76x2u.h"
-#include "../dma.h"
-#include "../mt76x02_util.h"
-#include "../mt76x02_usb.h"
-
-static int
-mt76x2u_check_skb_rooms(struct sk_buff *skb)
-{
-       int hdr_len = ieee80211_get_hdrlen_from_skb(skb);
-       u32 need_head;
-
-       need_head = sizeof(struct mt76x02_txwi) + MT_DMA_HDR_LEN;
-       if (hdr_len % 4)
-               need_head += 2;
-       return skb_cow(skb, need_head);
-}
-
-int mt76x2u_tx_prepare_skb(struct mt76_dev *mdev, void *data,
-                          struct sk_buff *skb, struct mt76_queue *q,
-                          struct mt76_wcid *wcid, struct ieee80211_sta *sta,
-                          u32 *tx_info)
-{
-       struct mt76x02_txwi *txwi;
-       int err, len = skb->len;
-
-       err = mt76x2u_check_skb_rooms(skb);
-       if (err < 0)
-               return -ENOMEM;
-
-       mt76x02_insert_hdr_pad(skb);
-
-       txwi = skb_push(skb, sizeof(struct mt76x02_txwi));
-       mt76x02_mac_write_txwi(mdev, txwi, skb, wcid, sta, len);
-
-       return mt76x02u_set_txinfo(skb, wcid, q2ep(q->hw_idx));
-}
 
 #include "../mt76x02_util.h"
 #include "../mt76x02_phy.h"
 #include "eeprom.h"
+#include "../mt76x02_usb.h"
 
 static void mt76x2u_init_dma(struct mt76x2_dev *dev)
 {
 struct mt76x2_dev *mt76x2u_alloc_device(struct device *pdev)
 {
        static const struct mt76_driver_ops drv_ops = {
-               .tx_prepare_skb = mt76x2u_tx_prepare_skb,
+               .tx_prepare_skb = mt76x02u_tx_prepare_skb,
                .tx_complete_skb = mt76x02_tx_complete_skb,
                .tx_status_data = mt76x02_tx_status_data,
                .rx_skb = mt76x2_queue_rx_skb,