void mt7615_mcu_fill_msg(struct mt7615_dev *dev, struct sk_buff *skb,
                         int cmd, int *wait_seq)
 {
-       int txd_len, mcu_cmd = cmd & MCU_CMD_MASK;
+       int txd_len, mcu_cmd = FIELD_GET(__MCU_CMD_FIELD_ID, cmd);
        struct mt7615_uni_txd *uni_txd;
        struct mt7615_mcu_txd *mcu_txd;
        u8 seq, q_idx, pkt_fmt;
        mcu_txd->s2d_index = MCU_S2D_H2N;
        mcu_txd->pkt_type = MCU_PKT_ID;
        mcu_txd->seq = seq;
+       mcu_txd->cid = mcu_cmd;
+       mcu_txd->ext_cid = FIELD_GET(__MCU_CMD_FIELD_EXT_ID, cmd);
 
-       switch (cmd & ~MCU_CMD_MASK) {
-       case MCU_FW_PREFIX:
-               mcu_txd->set_query = MCU_Q_NA;
-               mcu_txd->cid = mcu_cmd;
-               break;
-       case MCU_CE_PREFIX:
-               if (cmd & MCU_QUERY_MASK)
+       if (mcu_txd->ext_cid || (cmd & MCU_CE_PREFIX)) {
+               if (cmd & __MCU_CMD_FIELD_QUERY)
                        mcu_txd->set_query = MCU_Q_QUERY;
                else
                        mcu_txd->set_query = MCU_Q_SET;
-               mcu_txd->cid = mcu_cmd;
-               break;
-       default:
-               mcu_txd->cid = MCU_CMD_EXT_CID;
-               if (cmd & MCU_QUERY_PREFIX)
-                       mcu_txd->set_query = MCU_Q_QUERY;
-               else
-                       mcu_txd->set_query = MCU_Q_SET;
-               mcu_txd->ext_cid = mcu_cmd;
-               mcu_txd->ext_cid_ack = 1;
-               break;
+               mcu_txd->ext_cid_ack = !!mcu_txd->ext_cid;
+       } else {
+               mcu_txd->set_query = MCU_Q_NA;
        }
 }
 EXPORT_SYMBOL_GPL(mt7615_mcu_fill_msg);
        if (seq != rxd->seq)
                return -EAGAIN;
 
-       switch (cmd) {
-       case MCU_CMD_PATCH_SEM_CONTROL:
+       if (cmd == MCU_CMD_PATCH_SEM_CONTROL) {
                skb_pull(skb, sizeof(*rxd) - 4);
                ret = *skb->data;
-               break;
-       case MCU_EXT_CMD_GET_TEMP:
+       } else if (cmd == MCU_EXT_CMD(GET_TEMP)) {
                skb_pull(skb, sizeof(*rxd));
                ret = le32_to_cpu(*(__le32 *)skb->data);
-               break;
-       case MCU_EXT_CMD_RF_REG_ACCESS | MCU_QUERY_PREFIX:
+       } else if (cmd == MCU_EXT_QUERY(RF_REG_ACCESS)) {
                skb_pull(skb, sizeof(*rxd));
                ret = le32_to_cpu(*(__le32 *)&skb->data[8]);
-               break;
-       case MCU_UNI_CMD_DEV_INFO_UPDATE:
-       case MCU_UNI_CMD_BSS_INFO_UPDATE:
-       case MCU_UNI_CMD_STA_REC_UPDATE:
-       case MCU_UNI_CMD_HIF_CTRL:
-       case MCU_UNI_CMD_OFFLOAD:
-       case MCU_UNI_CMD_SUSPEND: {
+       } else if (cmd == MCU_UNI_CMD_DEV_INFO_UPDATE ||
+                  cmd == MCU_UNI_CMD_BSS_INFO_UPDATE ||
+                  cmd == MCU_UNI_CMD_STA_REC_UPDATE ||
+                  cmd == MCU_UNI_CMD_HIF_CTRL ||
+                  cmd == MCU_UNI_CMD_OFFLOAD ||
+                  cmd == MCU_UNI_CMD_SUSPEND) {
                struct mt7615_mcu_uni_event *event;
 
                skb_pull(skb, sizeof(*rxd));
                event = (struct mt7615_mcu_uni_event *)skb->data;
                ret = le32_to_cpu(event->status);
-               break;
-       }
-       case MCU_CMD_REG_READ: {
+       } else if (cmd == MCU_CMD_REG_READ) {
                struct mt7615_mcu_reg_event *event;
 
                skb_pull(skb, sizeof(*rxd));
                event = (struct mt7615_mcu_reg_event *)skb->data;
                ret = (int)le32_to_cpu(event->val);
-               break;
-       }
-       default:
-               break;
        }
 
        return ret;
                .address = cpu_to_le32(reg),
        };
 
-       return mt76_mcu_send_msg(&dev->mt76,
-                                MCU_EXT_CMD_RF_REG_ACCESS | MCU_QUERY_PREFIX,
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_QUERY(RF_REG_ACCESS),
                                 &req, sizeof(req), true);
 }
 
                .data = cpu_to_le32(val),
        };
 
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_RF_REG_ACCESS, &req,
-                                sizeof(req), false);
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(RF_REG_ACCESS),
+                                &req, sizeof(req), false);
 }
 
 void mt7622_trigger_hif_int(struct mt7615_dev *dev, bool en)
        if (enable)
                ether_addr_copy(req.addr, addr);
 
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_MUAR_UPDATE, &req,
-                                sizeof(req), true);
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(MUAR_UPDATE),
+                                &req, sizeof(req), true);
 }
 
 static int
                return mt7615_mcu_muar_config(dev, vif, false, enable);
 
        memcpy(data.tlv.omac_addr, vif->addr, ETH_ALEN);
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_DEV_INFO_UPDATE,
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(DEV_INFO_UPDATE),
                                 &data, sizeof(data), true);
 }
 
        dev_kfree_skb(skb);
 
 out:
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_BCN_OFFLOAD, &req,
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(BCN_OFFLOAD), &req,
                                 sizeof(req), true);
 }
 
                .band_idx = band,
        };
 
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_PM_STATE_CTRL, &req,
-                                sizeof(req), true);
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(PM_STATE_CTRL),
+                                &req, sizeof(req), true);
 }
 
 static int
                mt7615_mcu_bss_ext_tlv(skb, mvif);
 
        return mt76_mcu_skb_send_msg(&dev->mt76, skb,
-                                    MCU_EXT_CMD_BSS_INFO_UPDATE, true);
+                                    MCU_EXT_CMD(BSS_INFO_UPDATE), true);
 }
 
 static int
        mt76_connac_mcu_wtbl_ba_tlv(&dev->mt76, skb, params, enable, true,
                                    NULL, wtbl_hdr);
 
-       err = mt76_mcu_skb_send_msg(&dev->mt76, skb, MCU_EXT_CMD_WTBL_UPDATE,
-                                   true);
+       err = mt76_mcu_skb_send_msg(&dev->mt76, skb,
+                                   MCU_EXT_CMD(WTBL_UPDATE), true);
        if (err < 0)
                return err;
 
        mt76_connac_mcu_sta_ba_tlv(skb, params, enable, true);
 
        return mt76_mcu_skb_send_msg(&dev->mt76, skb,
-                                    MCU_EXT_CMD_STA_REC_UPDATE, true);
+                                    MCU_EXT_CMD(STA_REC_UPDATE), true);
 }
 
 static int
        mt76_connac_mcu_sta_ba_tlv(skb, params, enable, false);
 
        err = mt76_mcu_skb_send_msg(&dev->mt76, skb,
-                                   MCU_EXT_CMD_STA_REC_UPDATE, true);
+                                   MCU_EXT_CMD(STA_REC_UPDATE), true);
        if (err < 0 || !enable)
                return err;
 
        mt76_connac_mcu_wtbl_ba_tlv(&dev->mt76, skb, params, enable, false,
                                    NULL, wtbl_hdr);
 
-       return mt76_mcu_skb_send_msg(&dev->mt76, skb, MCU_EXT_CMD_WTBL_UPDATE,
-                                    true);
+       return mt76_mcu_skb_send_msg(&dev->mt76, skb,
+                                    MCU_EXT_CMD(WTBL_UPDATE), true);
 }
 
 static int
                                                   NULL, wtbl_hdr);
        }
 
-       cmd = enable ? MCU_EXT_CMD_WTBL_UPDATE : MCU_EXT_CMD_STA_REC_UPDATE;
+       cmd = enable ? MCU_EXT_CMD(WTBL_UPDATE) : MCU_EXT_CMD(STA_REC_UPDATE);
        skb = enable ? wskb : sskb;
 
        err = mt76_mcu_skb_send_msg(&dev->mt76, skb, cmd, true);
                return err;
        }
 
-       cmd = enable ? MCU_EXT_CMD_STA_REC_UPDATE : MCU_EXT_CMD_WTBL_UPDATE;
+       cmd = enable ? MCU_EXT_CMD(STA_REC_UPDATE) : MCU_EXT_CMD(WTBL_UPDATE);
        skb = enable ? sskb : wskb;
 
        return mt76_mcu_skb_send_msg(&dev->mt76, skb, cmd, true);
 
        mt76_connac_mcu_wtbl_hdr_trans_tlv(skb, vif, &msta->wcid, NULL,
                                           wtbl_hdr);
-       return mt76_mcu_skb_send_msg(&dev->mt76, skb, MCU_EXT_CMD_WTBL_UPDATE,
-                                    true);
+       return mt76_mcu_skb_send_msg(&dev->mt76, skb,
+                                    MCU_EXT_CMD(WTBL_UPDATE), true);
 }
 
 static const struct mt7615_mcu_ops wtbl_update_ops = {
                                    sta_wtbl, wtbl_hdr);
 
        return mt76_mcu_skb_send_msg(&dev->mt76, skb,
-                                    MCU_EXT_CMD_STA_REC_UPDATE, true);
+                                    MCU_EXT_CMD(STA_REC_UPDATE), true);
 }
 
 static int
                   struct ieee80211_sta *sta, bool enable)
 {
        return __mt7615_mcu_add_sta(phy->mt76, vif, sta, enable,
-                                   MCU_EXT_CMD_STA_REC_UPDATE, false);
+                                   MCU_EXT_CMD(STA_REC_UPDATE), false);
 }
 
 static int
 
        return mt76_connac_mcu_sta_update_hdr_trans(&dev->mt76,
                                                    vif, &msta->wcid,
-                                                   MCU_EXT_CMD_STA_REC_UPDATE);
+                                                   MCU_EXT_CMD(STA_REC_UPDATE));
 }
 
 static const struct mt7615_mcu_ops sta_update_ops = {
                .ctrl_val = ctrl
        };
 
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_FW_LOG_2_HOST, &data,
-                                sizeof(data), true);
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(FW_LOG_2_HOST),
+                                &data, sizeof(data), true);
 }
 
 static int mt7615_mcu_cal_cache_apply(struct mt7615_dev *dev)
                .cache_enable = true
        };
 
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_CAL_CACHE, &data,
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(CAL_CACHE), &data,
                                 sizeof(data), false);
 }
 
        skb_put_data(skb, eep + offset, eep_len);
 
        return mt76_mcu_skb_send_msg(&dev->mt76, skb,
-                                    MCU_EXT_CMD_EFUSE_BUFFER_MODE, true);
+                                    MCU_EXT_CMD(EFUSE_BUFFER_MODE), true);
 }
 
 int mt7615_mcu_set_wmm(struct mt7615_dev *dev, u8 queue,
        if (params->cw_max)
                req.cw_max = cpu_to_le16(fls(params->cw_max));
 
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_EDCA_UPDATE, &req,
-                                sizeof(req), true);
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(EDCA_UPDATE),
+                                &req, sizeof(req), true);
 }
 
 int mt7615_mcu_set_dbdc(struct mt7615_dev *dev)
        ADD_DBDC_ENTRY(DBDC_TYPE_MGMT, 1, 1);
 
 out:
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_DBDC_CTRL, &req,
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(DBDC_CTRL), &req,
                                 sizeof(req), true);
 }
 
                .operation = WTBL_RESET_ALL,
        };
 
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_WTBL_UPDATE, &req,
-                                sizeof(req), true);
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(WTBL_UPDATE),
+                                &req, sizeof(req), true);
 }
 
 int mt7615_mcu_rdd_cmd(struct mt7615_dev *dev,
                .val = val,
        };
 
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_SET_RDD_CTRL, &req,
-                                sizeof(req), true);
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(SET_RDD_CTRL),
+                                &req, sizeof(req), true);
 }
 
 int mt7615_mcu_set_fcc5_lpn(struct mt7615_dev *dev, int val)
                .min_lpn = cpu_to_le16(val),
        };
 
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_SET_RDD_TH, &req,
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(SET_RDD_TH), &req,
                                 sizeof(req), true);
 }
 
 #undef  __req_field
        };
 
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_SET_RDD_TH, &req,
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(SET_RDD_TH), &req,
                                 sizeof(req), true);
 }
 
 #undef __req_field_u32
        };
 
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_SET_RDD_TH, &req,
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(SET_RDD_TH), &req,
                                 sizeof(req), true);
 }
 
                req.pattern[i].start_time = cpu_to_le32(ts);
        }
 
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_SET_RDD_PATTERN,
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(SET_RDD_PATTERN),
                                 &req, sizeof(req), false);
 }
 
                u8 rsv[3];
        } req = {};
 
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_GET_TEMP, &req,
-                                sizeof(req), true);
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(GET_TEMP),
+                                &req, sizeof(req), true);
 }
 
 int mt7615_mcu_set_test_param(struct mt7615_dev *dev, u8 param, bool test_mode,
                .value = cpu_to_le32(val),
        };
 
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_ATE_CTRL, &req,
-                                sizeof(req), false);
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(ATE_CTRL),
+                                &req, sizeof(req), false);
 }
 
 int mt7615_mcu_set_sku_en(struct mt7615_phy *phy, bool enable)
        };
 
        return mt76_mcu_send_msg(&dev->mt76,
-                                MCU_EXT_CMD_TX_POWER_FEATURE_CTRL, &req,
-                                sizeof(req), true);
+                                MCU_EXT_CMD(TX_POWER_FEATURE_CTRL),
+                                &req, sizeof(req), true);
 }
 
 static int mt7615_find_freq_idx(const u16 *freqs, int n_freqs, u16 cur)
 
 out:
        req.center_freq = cpu_to_le16(center_freq);
-       ret = mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_RXDCOC_CAL, &req,
+       ret = mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(RXDCOC_CAL), &req,
                                sizeof(req), true);
 
        if ((chandef->width == NL80211_CHAN_WIDTH_80P80 ||
 
 out:
        req.center_freq = cpu_to_le16(center_freq);
-       ret = mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_TXDPD_CAL, &req,
-                               sizeof(req), true);
+       ret = mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(TXDPD_CAL),
+                               &req, sizeof(req), true);
 
        if ((chandef->width == NL80211_CHAN_WIDTH_80P80 ||
             chandef->width == NL80211_CHAN_WIDTH_160) && !req.is_freq2) {
                .etype = cpu_to_le16(ETH_P_PAE),
        };
 
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_RX_HDR_TRANS,
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(RX_HDR_TRANS),
                                 &req, sizeof(req), false);
 }
 
 
        if (seq != rxd->seq)
                return -EAGAIN;
 
-       switch (cmd) {
-       case MCU_CMD_PATCH_SEM_CONTROL:
+       if (cmd == MCU_CMD_PATCH_SEM_CONTROL) {
                skb_pull(skb, sizeof(*rxd) - 4);
                ret = *skb->data;
-               break;
-       case MCU_EXT_CMD_GET_TEMP:
+       } else if (cmd == MCU_EXT_CMD(GET_TEMP)) {
                skb_pull(skb, sizeof(*rxd) + 4);
                ret = le32_to_cpu(*(__le32 *)skb->data);
-               break;
-       case MCU_EXT_CMD_EFUSE_ACCESS:
+       } else if (cmd == MCU_EXT_CMD(EFUSE_ACCESS)) {
                ret = mt7921_mcu_parse_eeprom(mdev, skb);
-               break;
-       case MCU_UNI_CMD_DEV_INFO_UPDATE:
-       case MCU_UNI_CMD_BSS_INFO_UPDATE:
-       case MCU_UNI_CMD_STA_REC_UPDATE:
-       case MCU_UNI_CMD_HIF_CTRL:
-       case MCU_UNI_CMD_OFFLOAD:
-       case MCU_UNI_CMD_SUSPEND: {
+       } else if (cmd == MCU_UNI_CMD_DEV_INFO_UPDATE ||
+                  cmd == MCU_UNI_CMD_BSS_INFO_UPDATE ||
+                  cmd == MCU_UNI_CMD_STA_REC_UPDATE ||
+                  cmd == MCU_UNI_CMD_HIF_CTRL ||
+                  cmd == MCU_UNI_CMD_OFFLOAD ||
+                  cmd == MCU_UNI_CMD_SUSPEND) {
                struct mt7921_mcu_uni_event *event;
 
                skb_pull(skb, sizeof(*rxd));
                /* skip invalid event */
                if (mcu_cmd != event->cid)
                        ret = -EAGAIN;
-               break;
-       }
-       case MCU_CMD_REG_READ: {
+       } else if (cmd == MCU_CMD_REG_READ) {
                struct mt7921_mcu_reg_event *event;
 
                skb_pull(skb, sizeof(*rxd));
                event = (struct mt7921_mcu_reg_event *)skb->data;
                ret = (int)le32_to_cpu(event->val);
-               break;
-       }
-       default:
+       } else {
                skb_pull(skb, sizeof(struct mt7921_mcu_rxd));
-               break;
        }
 
        return ret;
                            int cmd, int *wait_seq)
 {
        struct mt7921_dev *dev = container_of(mdev, struct mt7921_dev, mt76);
-       int txd_len, mcu_cmd = cmd & MCU_CMD_MASK;
+       int txd_len, mcu_cmd = FIELD_GET(__MCU_CMD_FIELD_ID, cmd);
        struct mt7921_uni_txd *uni_txd;
        struct mt7921_mcu_txd *mcu_txd;
        __le32 *txd;
                                               MT_TX_MCU_PORT_RX_Q0));
        mcu_txd->pkt_type = MCU_PKT_ID;
        mcu_txd->seq = seq;
+       mcu_txd->cid = mcu_cmd;
+       mcu_txd->s2d_index = MCU_S2D_H2N;
+       mcu_txd->ext_cid = FIELD_GET(__MCU_CMD_FIELD_EXT_ID, cmd);
 
-       switch (cmd & ~MCU_CMD_MASK) {
-       case MCU_FW_PREFIX:
-               mcu_txd->set_query = MCU_Q_NA;
-               mcu_txd->cid = mcu_cmd;
-               break;
-       case MCU_CE_PREFIX:
-               if (cmd & MCU_QUERY_MASK)
-                       mcu_txd->set_query = MCU_Q_QUERY;
-               else
-                       mcu_txd->set_query = MCU_Q_SET;
-               mcu_txd->cid = mcu_cmd;
-               break;
-       default:
-               mcu_txd->cid = MCU_CMD_EXT_CID;
-               if (cmd & MCU_QUERY_PREFIX || cmd == MCU_EXT_CMD_EFUSE_ACCESS)
+       if (mcu_txd->ext_cid || (cmd & MCU_CE_PREFIX)) {
+               if (cmd & __MCU_CMD_FIELD_QUERY)
                        mcu_txd->set_query = MCU_Q_QUERY;
                else
                        mcu_txd->set_query = MCU_Q_SET;
-               mcu_txd->ext_cid = mcu_cmd;
-               mcu_txd->ext_cid_ack = 1;
-               break;
+               mcu_txd->ext_cid_ack = !!mcu_txd->ext_cid;
+       } else {
+               mcu_txd->set_query = MCU_Q_NA;
        }
 
-       mcu_txd->s2d_index = MCU_S2D_H2N;
-       WARN_ON(cmd == MCU_EXT_CMD_EFUSE_ACCESS &&
-               mcu_txd->set_query != MCU_Q_QUERY);
-
 exit:
        if (wait_seq)
                *wait_seq = seq;
                        e->cw_max = cpu_to_le16(10);
        }
 
-       ret = mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_EDCA_UPDATE, &req,
-                               sizeof(req), true);
+       ret = mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(EDCA_UPDATE),
+                               &req, sizeof(req), true);
        if (ret)
                return ret;
 
        else
                req.switch_reason = CH_SWITCH_NORMAL;
 
-       if (cmd == MCU_EXT_CMD_CHANNEL_SWITCH)
+       if (cmd == MCU_EXT_CMD(CHANNEL_SWITCH))
                req.rx_streams = hweight8(req.rx_streams);
 
        if (chandef->width == NL80211_CHAN_WIDTH_80P80) {
                .format = EE_FORMAT_WHOLE,
        };
 
-       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_EFUSE_BUFFER_MODE,
+       return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(EFUSE_BUFFER_MODE),
                                 &req, sizeof(req), true);
 }
 EXPORT_SYMBOL_GPL(mt7921_mcu_set_eeprom);
        int ret;
        u8 *buf;
 
-       ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_EXT_CMD_EFUSE_ACCESS, &req,
-                                       sizeof(req), true, &skb);
+       ret = mt76_mcu_send_and_get_msg(&dev->mt76,
+                                       MCU_EXT_QUERY(EFUSE_ACCESS),
+                                       &req, sizeof(req), true, &skb);
        if (ret)
                return ret;