put_unaligned_le32(val, skb_put(skb, 4));
 }
 
-int
-mt76x0_mcu_calibrate(struct mt76x0_dev *dev, enum mcu_calibrate cal, u32 val)
-{
-       struct sk_buff *skb;
-       struct {
-               __le32 id;
-               __le32 value;
-       } __packed __aligned(4) msg = {
-               .id = cpu_to_le32(cal),
-               .value = cpu_to_le32(val),
-       };
-
-       skb = mt76_mcu_msg_alloc(dev, &msg, sizeof(msg));
-       return mt76_mcu_send_msg(dev, skb, CMD_CALIBRATION_OP, true);
-}
-
 struct mt76_fw {
        struct mt76x02_fw_header hdr;
        u8 ivb[MT_MCU_IVB_SIZE];
 
 int mt76x0_mcu_init(struct mt76x0_dev *dev);
 int mt76x0_mcu_cmd_init(struct mt76x0_dev *dev);
 
-int
-mt76x0_mcu_calibrate(struct mt76x0_dev *dev, enum mcu_calibrate cal, u32 val);
-
 #endif
 
 
        mt76x0_vco_cal(dev, channel);
        if (scan)
-               mt76x0_mcu_calibrate(dev, MCU_CAL_RXDCOC, 1);
+               mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_RXDCOC, 1, false);
 
        mt76x0_phy_set_chan_pwr(dev, channel);
 
        u8 channel = dev->mt76.chandef.chan->hw_value;
        int is_5ghz = (dev->mt76.chandef.chan->band == NL80211_BAND_5GHZ) ? 1 : 0;
 
-       mt76x0_mcu_calibrate(dev, MCU_CAL_R, 0);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_R, 0, false);
 
        mt76x0_vco_cal(dev, channel);
 
        reg_val &= 0xffffff7e;
        mt76_wr(dev, 0x2124, reg_val);
 
-       mt76x0_mcu_calibrate(dev, MCU_CAL_RXDCOC, 0);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_RXDCOC, 0, false);
 
-       mt76x0_mcu_calibrate(dev, MCU_CAL_LC, is_5ghz);
-       mt76x0_mcu_calibrate(dev, MCU_CAL_LOFT, is_5ghz);
-       mt76x0_mcu_calibrate(dev, MCU_CAL_TXIQ, is_5ghz);
-       mt76x0_mcu_calibrate(dev, MCU_CAL_TX_GROUP_DELAY, is_5ghz);
-       mt76x0_mcu_calibrate(dev, MCU_CAL_RXIQ, is_5ghz);
-       mt76x0_mcu_calibrate(dev, MCU_CAL_RX_GROUP_DELAY, is_5ghz);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_LC, is_5ghz, false);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_LOFT, is_5ghz, false);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_TXIQ, is_5ghz, false);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_TX_GROUP_DELAY,
+                             is_5ghz, false);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_RXIQ, is_5ghz, false);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_RX_GROUP_DELAY,
+                             is_5ghz, false);
 
        mt76_wr(dev, 0x2124, reg_val);
        mt76_wr(dev, MT_TX_ALC_CFG_0, tx_alc);
        msleep(100);
 
-       mt76x0_mcu_calibrate(dev, MCU_CAL_RXDCOC, 1);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_RXDCOC, 1, false);
 }
 
 void mt76x0_agc_save(struct mt76x0_dev *dev)
 
 }
 EXPORT_SYMBOL_GPL(mt76x02_mcu_set_radio_state);
 
+int mt76x02_mcu_calibrate(struct mt76_dev *dev, int type,
+                         u32 param, bool wait)
+{
+       struct sk_buff *skb;
+       struct {
+               __le32 id;
+               __le32 value;
+       } __packed __aligned(4) msg = {
+               .id = cpu_to_le32(type),
+               .value = cpu_to_le32(param),
+       };
+       int ret;
+
+       if (wait)
+               dev->bus->rmw(dev, MT_MCU_COM_REG0, BIT(31), 0);
+
+       skb = dev->mcu_ops->mcu_msg_alloc(&msg, sizeof(msg));
+       ret = dev->mcu_ops->mcu_send_msg(dev, skb, CMD_CALIBRATION_OP, true);
+       if (ret)
+               return ret;
+
+       if (wait &&
+           WARN_ON(!__mt76_poll_msec(dev, MT_MCU_COM_REG0,
+                                     BIT(31), BIT(31), 100)))
+               return -ETIMEDOUT;
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(mt76x02_mcu_calibrate);
+
 int mt76x02_mcu_cleanup(struct mt76_dev *dev)
 {
        struct sk_buff *skb;
 
 };
 
 int mt76x02_mcu_cleanup(struct mt76_dev *dev);
+int mt76x02_mcu_calibrate(struct mt76_dev *dev, int type,
+                         u32 param, bool wait);
 struct sk_buff *mt76x02_mcu_msg_alloc(const void *data, int len);
 int mt76x02_mcu_msg_send(struct mt76_dev *dev, struct sk_buff *skb,
                         int cmd, bool wait_resp);
 
        return -ENOENT;
 }
 
-int mt76x2_mcu_calibrate(struct mt76x2_dev *dev, enum mcu_calibration type,
-                        u32 param)
-{
-       struct sk_buff *skb;
-       struct {
-               __le32 id;
-               __le32 value;
-       } __packed __aligned(4) msg = {
-               .id = cpu_to_le32(type),
-               .value = cpu_to_le32(param),
-       };
-       int ret;
-
-       mt76_clear(dev, MT_MCU_COM_REG0, BIT(31));
-
-       skb = mt76_mcu_msg_alloc(dev, &msg, sizeof(msg));
-       ret = mt76_mcu_send_msg(dev, skb, CMD_CALIBRATION_OP, true);
-       if (ret)
-               return ret;
-
-       if (WARN_ON(!mt76_poll_msec(dev, MT_MCU_COM_REG0,
-                                   BIT(31), BIT(31), 100)))
-               return -ETIMEDOUT;
-
-       return 0;
-}
-
 int mt76x2_mcu_init(struct mt76x2_dev *dev)
 {
        static const struct mt76_mcu_ops mt76x2_mcu_ops = {
 
        u8 offset1;
 } __packed __aligned(4);
 
-int mt76x2_mcu_calibrate(struct mt76x2_dev *dev, enum mcu_calibration type,
-                        u32 param);
 int mt76x2_mcu_tssi_comp(struct mt76x2_dev *dev, struct mt76x2_tssi_comp *tssi_data);
 int mt76x2_mcu_init_gain(struct mt76x2_dev *dev, u8 channel, u32 gain,
                         bool force);
 
        if (mt76x2_ext_pa_enabled(dev, chan->band))
                flag |= BIT(8);
 
-       mt76x2_mcu_calibrate(dev, MCU_CAL_TSSI, flag);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_TSSI, flag, true);
        dev->cal.tssi_cal_done = true;
        return true;
 }
                mt76x2_mac_stop(dev, false);
 
        if (is_5ghz)
-               mt76x2_mcu_calibrate(dev, MCU_CAL_LC, 0);
+               mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_LC, 0, true);
 
-       mt76x2_mcu_calibrate(dev, MCU_CAL_TX_LOFT, is_5ghz);
-       mt76x2_mcu_calibrate(dev, MCU_CAL_TXIQ, is_5ghz);
-       mt76x2_mcu_calibrate(dev, MCU_CAL_RXIQC_FI, is_5ghz);
-       mt76x2_mcu_calibrate(dev, MCU_CAL_TEMP_SENSOR, 0);
-       mt76x2_mcu_calibrate(dev, MCU_CAL_TX_SHAPING, 0);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_TX_LOFT, is_5ghz, true);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_TXIQ, is_5ghz, true);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_RXIQC_FI, is_5ghz, true);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_TEMP_SENSOR, 0, true);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_TX_SHAPING, 0, true);
 
        if (!mac_stopped)
                mt76x2_mac_resume(dev);
                u8 val = mt76x2_eeprom_get(dev, MT_EE_BT_RCAL_RESULT);
 
                if (val != 0xff)
-                       mt76x2_mcu_calibrate(dev, MCU_CAL_R, 0);
+                       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_R, 0, true);
        }
 
-       mt76x2_mcu_calibrate(dev, MCU_CAL_RXDCOC, channel);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_RXDCOC, channel, true);
 
        /* Rx LPF calibration */
        if (!dev->cal.init_cal_done)
-               mt76x2_mcu_calibrate(dev, MCU_CAL_RC, 0);
+               mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_RC, 0, true);
 
        dev->cal.init_cal_done = true;
 
                        return;
 
                usleep_range(10000, 20000);
-               mt76x2_mcu_calibrate(dev, MCU_CAL_DPD, chan->hw_value);
+               mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_DPD, chan->hw_value, true);
                dev->cal.dpd_cal_done = true;
        }
 }
 
 void mt76x2u_phy_set_rxpath(struct mt76x2_dev *dev);
 
 void mt76x2u_mcu_complete_urb(struct urb *urb);
-int mt76x2u_mcu_calibrate(struct mt76x2_dev *dev, enum mcu_calibration type,
-                         u32 val);
 int mt76x2u_mcu_set_dynamic_vga(struct mt76x2_dev *dev, u8 channel, bool ap,
                                bool ext, int rssi, u32 false_cca);
 int mt76x2u_mcu_init(struct mt76x2_dev *dev);
 
 #define MT76U_MCU_DLM_OFFSET           0x110000
 #define MT76U_MCU_ROM_PATCH_OFFSET     0x90000
 
-int mt76x2u_mcu_calibrate(struct mt76x2_dev *dev, enum mcu_calibration type,
-                         u32 val)
-{
-       struct {
-               __le32 id;
-               __le32 value;
-       } __packed __aligned(4) msg = {
-               .id = cpu_to_le32(type),
-               .value = cpu_to_le32(val),
-       };
-       struct sk_buff *skb;
-
-       skb = mt76_mcu_msg_alloc(dev, &msg, sizeof(msg));
-       return mt76_mcu_send_msg(dev, skb, CMD_CALIBRATION_OP, true);
-}
-
 int mt76x2u_mcu_set_dynamic_vga(struct mt76x2_dev *dev, u8 channel, bool ap,
                                bool ext, int rssi, u32 false_cca)
 {
 
        mt76x2u_mac_stop(dev);
 
        if (is_5ghz)
-               mt76x2u_mcu_calibrate(dev, MCU_CAL_LC, 0);
+               mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_LC, 0, false);
 
-       mt76x2u_mcu_calibrate(dev, MCU_CAL_TX_LOFT, is_5ghz);
-       mt76x2u_mcu_calibrate(dev, MCU_CAL_TXIQ, is_5ghz);
-       mt76x2u_mcu_calibrate(dev, MCU_CAL_RXIQC_FI, is_5ghz);
-       mt76x2u_mcu_calibrate(dev, MCU_CAL_TEMP_SENSOR, 0);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_TX_LOFT, is_5ghz, false);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_TXIQ, is_5ghz, false);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_RXIQC_FI, is_5ghz, false);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_TEMP_SENSOR, 0, false);
 
        mt76x2u_mac_resume(dev);
 }
                        return;
 
                usleep_range(10000, 20000);
-               mt76x2u_mcu_calibrate(dev, MCU_CAL_DPD, chan->hw_value);
+               mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_DPD,
+                                     chan->hw_value, false);
                dev->cal.dpd_cal_done = true;
        }
 }
                u8 val = mt76x2_eeprom_get(dev, MT_EE_BT_RCAL_RESULT);
 
                if (val != 0xff)
-                       mt76x2u_mcu_calibrate(dev, MCU_CAL_R, 0);
+                       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_R,
+                                             0, false);
        }
 
-       mt76x2u_mcu_calibrate(dev, MCU_CAL_RXDCOC, channel);
+       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_RXDCOC, channel, false);
 
        /* Rx LPF calibration */
        if (!dev->cal.init_cal_done)
-               mt76x2u_mcu_calibrate(dev, MCU_CAL_RC, 0);
+               mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_RC, 0, false);
        dev->cal.init_cal_done = true;
 
        mt76_wr(dev, MT_BBP(AGC, 61), 0xff64a4e2);
                                flag |= BIT(0);
                        if (mt76x2_ext_pa_enabled(dev, chan->band))
                                flag |= BIT(8);
-                       mt76x2u_mcu_calibrate(dev, MCU_CAL_TSSI, flag);
+                       mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_TSSI,
+                                             flag, false);
                        dev->cal.tssi_cal_done = true;
                }
        }