Quelle  rtw8852c_rfk.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
/* Copyright(c) 2019-2022  Realtek Corporation
 */

#include "chan.h"
#include "coex.h"
#include "debug.h"
#include "fw.h"
#include "phy.h"
#include "reg.h"
#include "rtw8852c.h"
#include "rtw8852c_rfk.h"
#include "rtw8852c_rfk_table.h"
#include "rtw8852c_table.h"

struct rxck_def {
 u32 ctl;
 u32 en;
 u32 bw0;
 u32 bw1;
 u32 mul;
 u32 lp;
};

#define _TSSI_DE_MASK GENMASK(21, 12)
static const u32 _tssi_de_cck_long[RF_PATH_NUM_8852C] = {0x5858, 0x7858};
static const u32 _tssi_de_cck_short[RF_PATH_NUM_8852C] = {0x5860, 0x7860};
static const u32 _tssi_de_mcs_20m[RF_PATH_NUM_8852C] = {0x5838, 0x7838};
static const u32 _tssi_de_mcs_40m[RF_PATH_NUM_8852C] = {0x5840, 0x7840};
static const u32 _tssi_de_mcs_80m[RF_PATH_NUM_8852C] = {0x5848, 0x7848};
static const u32 _tssi_de_mcs_80m_80m[RF_PATH_NUM_8852C] = {0x5850, 0x7850};
static const u32 _tssi_de_mcs_5m[RF_PATH_NUM_8852C] = {0x5828, 0x7828};
static const u32 _tssi_de_mcs_10m[RF_PATH_NUM_8852C] = {0x5830, 0x7830};

static const u32 rtw8852c_backup_bb_regs[] = {
 0x8120, 0xc0d4, 0xc0d8, 0xc0e8, 0x8220, 0xc1d4, 0xc1d8, 0xc1e8
};

static const u32 rtw8852c_backup_rf_regs[] = {
 0xdf, 0x5f, 0x8f, 0x97, 0xa3, 0x5, 0x10005
};

#define BACKUP_BB_REGS_NR ARRAY_SIZE(rtw8852c_backup_bb_regs)
#define BACKUP_RF_REGS_NR ARRAY_SIZE(rtw8852c_backup_rf_regs)

#define RXK_GROUP_NR 4
static const u32 _rxk_a6_idxrxgain[RXK_GROUP_NR] = {0x190, 0x196, 0x290, 0x316};
static const u32 _rxk_a6_idxattc2[RXK_GROUP_NR] = {0x00, 0x0, 0x00, 0x00};
static const u32 _rxk_a_idxrxgain[RXK_GROUP_NR] = {0x190, 0x198, 0x310, 0x318};
static const u32 _rxk_a_idxattc2[RXK_GROUP_NR] = {0x00, 0x00, 0x00, 0x00};
static const u32 _rxk_g_idxrxgain[RXK_GROUP_NR] = {0x252, 0x26c, 0x350, 0x360};
static const u32 _rxk_g_idxattc2[RXK_GROUP_NR] = {0x00, 0x07, 0x00, 0x3};

#define TXK_GROUP_NR 3
static const u32 _txk_a6_power_range[TXK_GROUP_NR] = {0x0, 0x0, 0x0};
static const u32 _txk_a6_track_range[TXK_GROUP_NR] = {0x6, 0x7, 0x7};
static const u32 _txk_a6_gain_bb[TXK_GROUP_NR] = {0x12, 0x09, 0x0e};
static const u32 _txk_a6_itqt[TXK_GROUP_NR] = {0x12, 0x12, 0x12};
static const u32 _txk_a_power_range[TXK_GROUP_NR] = {0x0, 0x0, 0x0};
static const u32 _txk_a_track_range[TXK_GROUP_NR] = {0x5, 0x6, 0x7};
static const u32 _txk_a_gain_bb[TXK_GROUP_NR] = {0x12, 0x09, 0x0e};
static const u32 _txk_a_itqt[TXK_GROUP_NR] = {0x12, 0x12, 0x12};
static const u32 _txk_g_power_range[TXK_GROUP_NR] = {0x0, 0x0, 0x0};
static const u32 _txk_g_track_range[TXK_GROUP_NR] = {0x5, 0x6, 0x6};
static const u32 _txk_g_gain_bb[TXK_GROUP_NR] = {0x0e, 0x0a, 0x0e};
static const u32 _txk_g_itqt[TXK_GROUP_NR] = { 0x12, 0x12, 0x12};

static const u32 dpk_par_regs[RTW89_DPK_RF_PATH][4] = {
 {0x8190, 0x8194, 0x8198, 0x81a4},
 {0x81a8, 0x81c4, 0x81c8, 0x81e8},
};

static const u8 _dck_addr_bs[RF_PATH_NUM_8852C] = {0x0, 0x10};
static const u8 _dck_addr[RF_PATH_NUM_8852C] = {0xc, 0x1c};

static const struct rxck_def _ck480M = {0x8, 0x2, 0x3, 0xf, 0x0, 0x9};
static const struct rxck_def _ck960M = {0x8, 0x2, 0x2, 0x8, 0x0, 0x9};
static const struct rxck_def _ck1920M = {0x8, 0x0, 0x2, 0x4, 0x6, 0x9};

static u8 _kpath(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy_idx)
{
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RFK]dbcc_en: %x, PHY%d\n",
      rtwdev->dbcc_en, phy_idx);

 if (!rtwdev->dbcc_en)
  return RF_AB;

 if (phy_idx == RTW89_PHY_0)
  return RF_A;
 else
  return RF_B;
}

static void _rfk_backup_bb_reg(struct rtw89_dev *rtwdev, u32 backup_bb_reg_val[])
{
 u32 i;

 for (i = 0; i < BACKUP_BB_REGS_NR; i++) {
  backup_bb_reg_val[i] =
   rtw89_phy_read32_mask(rtwdev, rtw8852c_backup_bb_regs[i],
           MASKDWORD);
  rtw89_debug(rtwdev, RTW89_DBG_RFK,
       "[IQK]backup bb reg : %x, value =%x\n",
       rtw8852c_backup_bb_regs[i], backup_bb_reg_val[i]);
 }
}

static void _rfk_backup_rf_reg(struct rtw89_dev *rtwdev, u32 backup_rf_reg_val[],
          u8 rf_path)
{
 u32 i;

 for (i = 0; i < BACKUP_RF_REGS_NR; i++) {
  backup_rf_reg_val[i] =
   rtw89_read_rf(rtwdev, rf_path,
          rtw8852c_backup_rf_regs[i], RFREG_MASK);
  rtw89_debug(rtwdev, RTW89_DBG_RFK,
       "[IQK]backup rf S%d reg : %x, value =%x\n", rf_path,
       rtw8852c_backup_rf_regs[i], backup_rf_reg_val[i]);
 }
}

static void _rfk_restore_bb_reg(struct rtw89_dev *rtwdev, u32 backup_bb_reg_val[])
{
 u32 i;

 for (i = 0; i < BACKUP_BB_REGS_NR; i++) {
  rtw89_phy_write32_mask(rtwdev, rtw8852c_backup_bb_regs[i],
           MASKDWORD, backup_bb_reg_val[i]);
  rtw89_debug(rtwdev, RTW89_DBG_RFK,
       "[IQK]restore bb reg : %x, value =%x\n",
       rtw8852c_backup_bb_regs[i], backup_bb_reg_val[i]);
 }
}

static void _rfk_restore_rf_reg(struct rtw89_dev *rtwdev, u32 backup_rf_reg_val[],
    u8 rf_path)
{
 u32 i;

 for (i = 0; i < BACKUP_RF_REGS_NR; i++) {
  rtw89_write_rf(rtwdev, rf_path, rtw8852c_backup_rf_regs[i],
          RFREG_MASK, backup_rf_reg_val[i]);

  rtw89_debug(rtwdev, RTW89_DBG_RFK,
       "[IQK]restore rf S%d reg: %x, value =%x\n", rf_path,
       rtw8852c_backup_rf_regs[i], backup_rf_reg_val[i]);
 }
}

static void _wait_rx_mode(struct rtw89_dev *rtwdev, u8 kpath)
{
 u8 path;
 u32 rf_mode;
 int ret;

 for (path = 0; path < RF_PATH_MAX; path++) {
  if (!(kpath & BIT(path)))
   continue;

  ret = read_poll_timeout_atomic(rtw89_read_rf, rf_mode, rf_mode != 2,
            2, 5000, false, rtwdev, path, 0x00,
            RR_MOD_MASK);
  rtw89_debug(rtwdev, RTW89_DBG_RFK,
       "[RFK] Wait S%d to Rx mode!! (ret = %d)\n",
       path, ret);
 }
}

static void _dack_dump(struct rtw89_dev *rtwdev)
{
 struct rtw89_dack_info *dack = &rtwdev->dack;
 u8 i;
 u8 t;

 rtw89_debug(rtwdev, RTW89_DBG_RFK,
      "[DACK]S0 ADC_DCK ic = 0x%x, qc = 0x%x\n",
      dack->addck_d[0][0], dack->addck_d[0][1]);
 rtw89_debug(rtwdev, RTW89_DBG_RFK,
      "[DACK]S1 ADC_DCK ic = 0x%x, qc = 0x%x\n",
      dack->addck_d[1][0], dack->addck_d[1][1]);
 rtw89_debug(rtwdev, RTW89_DBG_RFK,
      "[DACK]S0 DAC_DCK ic = 0x%x, qc = 0x%x\n",
      dack->dadck_d[0][0], dack->dadck_d[0][1]);
 rtw89_debug(rtwdev, RTW89_DBG_RFK,
      "[DACK]S1 DAC_DCK ic = 0x%x, qc = 0x%x\n",
      dack->dadck_d[1][0], dack->dadck_d[1][1]);

 rtw89_debug(rtwdev, RTW89_DBG_RFK,
      "[DACK]S0 biask ic = 0x%x, qc = 0x%x\n",
      dack->biask_d[0][0], dack->biask_d[0][1]);
 rtw89_debug(rtwdev, RTW89_DBG_RFK,
      "[DACK]S1 biask ic = 0x%x, qc = 0x%x\n",
      dack->biask_d[1][0], dack->biask_d[1][1]);

 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]S0 MSBK ic:\n");
 for (i = 0; i < RTW89_DACK_MSBK_NR; i++) {
  t = dack->msbk_d[0][0][i];
  rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0x%x\n", t);
 }
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]S0 MSBK qc:\n");
 for (i = 0; i < RTW89_DACK_MSBK_NR; i++) {
  t = dack->msbk_d[0][1][i];
  rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0x%x\n", t);
 }
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]S1 MSBK ic:\n");
 for (i = 0; i < RTW89_DACK_MSBK_NR; i++) {
  t = dack->msbk_d[1][0][i];
  rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0x%x\n", t);
 }
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]S1 MSBK qc:\n");
 for (i = 0; i < RTW89_DACK_MSBK_NR; i++) {
  t = dack->msbk_d[1][1][i];
  rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0x%x\n", t);
 }
}

static void _addck_backup(struct rtw89_dev *rtwdev)
{
 struct rtw89_dack_info *dack = &rtwdev->dack;

 rtw89_phy_write32_mask(rtwdev, R_ADDCK0, B_ADDCK0, 0x0);
 dack->addck_d[0][0] = rtw89_phy_read32_mask(rtwdev, R_ADDCKR0,
          B_ADDCKR0_A0);
 dack->addck_d[0][1] = rtw89_phy_read32_mask(rtwdev, R_ADDCKR0,
          B_ADDCKR0_A1);

 rtw89_phy_write32_mask(rtwdev, R_ADDCK1, B_ADDCK1, 0x0);
 dack->addck_d[1][0] = rtw89_phy_read32_mask(rtwdev, R_ADDCKR1,
          B_ADDCKR1_A0);
 dack->addck_d[1][1] = rtw89_phy_read32_mask(rtwdev, R_ADDCKR1,
          B_ADDCKR1_A1);
}

static void _addck_reload(struct rtw89_dev *rtwdev)
{
 struct rtw89_dack_info *dack = &rtwdev->dack;

 rtw89_phy_write32_mask(rtwdev, R_ADDCK0_RL, B_ADDCK0_RL1,
          dack->addck_d[0][0]);
 rtw89_phy_write32_mask(rtwdev, R_ADDCK0_RL, B_ADDCK0_RL0,
          dack->addck_d[0][1]);
 rtw89_phy_write32_mask(rtwdev, R_ADDCK0_RL, B_ADDCK0_RLS, 0x3);
 rtw89_phy_write32_mask(rtwdev, R_ADDCK1_RL, B_ADDCK1_RL1,
          dack->addck_d[1][0]);
 rtw89_phy_write32_mask(rtwdev, R_ADDCK1_RL, B_ADDCK1_RL0,
          dack->addck_d[1][1]);
 rtw89_phy_write32_mask(rtwdev, R_ADDCK1_RL, B_ADDCK1_RLS, 0x3);
}

static void _dack_backup_s0(struct rtw89_dev *rtwdev)
{
 struct rtw89_dack_info *dack = &rtwdev->dack;
 u8 i;

 rtw89_phy_write32_mask(rtwdev, R_P0_NRBW, B_P0_NRBW_DBG, 0x1);
 for (i = 0; i < RTW89_DACK_MSBK_NR; i++) {
  rtw89_phy_write32_mask(rtwdev, R_DCOF0, B_DCOF0_V, i);
  dack->msbk_d[0][0][i] = rtw89_phy_read32_mask(rtwdev,
             R_DACK_S0P2,
             B_DACK_S0M0);
  rtw89_phy_write32_mask(rtwdev, R_DCOF8, B_DCOF8_V, i);
  dack->msbk_d[0][1][i] = rtw89_phy_read32_mask(rtwdev,
             R_DACK_S0P3,
             B_DACK_S0M1);
 }
 dack->biask_d[0][0] = rtw89_phy_read32_mask(rtwdev, R_DACK_BIAS00,
          B_DACK_BIAS00);
 dack->biask_d[0][1] = rtw89_phy_read32_mask(rtwdev, R_DACK_BIAS01,
          B_DACK_BIAS01);
 dack->dadck_d[0][0] = rtw89_phy_read32_mask(rtwdev, R_DACK_DADCK00,
          B_DACK_DADCK00);
 dack->dadck_d[0][1] = rtw89_phy_read32_mask(rtwdev, R_DACK_DADCK01,
          B_DACK_DADCK01);
}

static void _dack_backup_s1(struct rtw89_dev *rtwdev)
{
 struct rtw89_dack_info *dack = &rtwdev->dack;
 u8 i;

 rtw89_phy_write32_mask(rtwdev, R_P1_DBGMOD, B_P1_DBGMOD_ON, 0x1);
 for (i = 0; i < RTW89_DACK_MSBK_NR; i++) {
  rtw89_phy_write32_mask(rtwdev, R_DACK10, B_DACK10, i);
  dack->msbk_d[1][0][i] = rtw89_phy_read32_mask(rtwdev,
             R_DACK10S,
             B_DACK10S);
  rtw89_phy_write32_mask(rtwdev, R_DACK11, B_DACK11, i);
  dack->msbk_d[1][1][i] = rtw89_phy_read32_mask(rtwdev,
             R_DACK11S,
             B_DACK11S);
 }
 dack->biask_d[1][0] = rtw89_phy_read32_mask(rtwdev, R_DACK_BIAS10,
          B_DACK_BIAS10);
 dack->biask_d[1][1] = rtw89_phy_read32_mask(rtwdev, R_DACK_BIAS11,
          B_DACK_BIAS11);
 dack->dadck_d[1][0] = rtw89_phy_read32_mask(rtwdev, R_DACK_DADCK10,
          B_DACK_DADCK10);
 dack->dadck_d[1][1] = rtw89_phy_read32_mask(rtwdev, R_DACK_DADCK11,
          B_DACK_DADCK11);
}

static void _dack_reload_by_path(struct rtw89_dev *rtwdev,
     enum rtw89_rf_path path, u8 index)
{
 struct rtw89_dack_info *dack = &rtwdev->dack;
 u32 idx_offset, path_offset;
 u32 val32, offset, addr;
 u8 i;

 idx_offset = (index == 0 ? 0 : 0x14);
 path_offset = (path == RF_PATH_A ? 0 : 0x28);
 offset = idx_offset + path_offset;

 rtw89_rfk_parser(rtwdev, &rtw8852c_dack_reload_defs_tbl);

 /* msbk_d: 15/14/13/12 */
 val32 = 0x0;
 for (i = 0; i < RTW89_DACK_MSBK_NR / 4; i++)
  val32 |= dack->msbk_d[path][index][i + 12] << (i * 8);
 addr = 0xc200 + offset;
 rtw89_phy_write32(rtwdev, addr, val32);
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0x%x=0x%x\n", addr,
      rtw89_phy_read32_mask(rtwdev, addr, MASKDWORD));

 /* msbk_d: 11/10/9/8 */
 val32 = 0x0;
 for (i = 0; i < RTW89_DACK_MSBK_NR / 4; i++)
  val32 |= dack->msbk_d[path][index][i + 8] << (i * 8);
 addr = 0xc204 + offset;
 rtw89_phy_write32(rtwdev, addr, val32);
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0x%x=0x%x\n", addr,
      rtw89_phy_read32_mask(rtwdev, addr, MASKDWORD));

 /* msbk_d: 7/6/5/4 */
 val32 = 0x0;
 for (i = 0; i < RTW89_DACK_MSBK_NR / 4; i++)
  val32 |= dack->msbk_d[path][index][i + 4] << (i * 8);
 addr = 0xc208 + offset;
 rtw89_phy_write32(rtwdev, addr, val32);
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0x%x=0x%x\n", addr,
      rtw89_phy_read32_mask(rtwdev, addr, MASKDWORD));

 /* msbk_d: 3/2/1/0 */
 val32 = 0x0;
 for (i = 0; i < RTW89_DACK_MSBK_NR / 4; i++)
  val32 |= dack->msbk_d[path][index][i] << (i * 8);
 addr = 0xc20c + offset;
 rtw89_phy_write32(rtwdev, addr, val32);
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0x%x=0x%x\n", addr,
      rtw89_phy_read32_mask(rtwdev, addr, MASKDWORD));

 /* dadak_d/biask_d */
 val32 = (dack->biask_d[path][index] << 22) |
  (dack->dadck_d[path][index] << 14);
 addr = 0xc210 + offset;
 rtw89_phy_write32(rtwdev, addr, val32);
 rtw89_phy_write32_set(rtwdev, addr, BIT(0));
}

static void _dack_reload(struct rtw89_dev *rtwdev, enum rtw89_rf_path path)
{
 u8 i;

 for (i = 0; i < 2; i++)
  _dack_reload_by_path(rtwdev, path, i);
}

static void _addck(struct rtw89_dev *rtwdev)
{
 struct rtw89_dack_info *dack = &rtwdev->dack;
 u32 val;
 int ret;

 /* S0 */
 rtw89_phy_write32_mask(rtwdev, R_ADDCK0, B_ADDCK0_RST, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_ADDCK0, B_ADDCK0_EN, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_ADDCK0, B_ADDCK0_EN, 0x0);
 fsleep(1);
 rtw89_phy_write32_mask(rtwdev, R_ADDCK0, B_ADDCK0, 0x1);

 ret = read_poll_timeout_atomic(rtw89_phy_read32_mask, val, val,
           1, 10000, false, rtwdev, 0xc0fc, BIT(0));
 if (ret) {
  rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]S0 ADDCK timeout\n");
  dack->addck_timeout[0] = true;
 }

 rtw89_phy_write32_mask(rtwdev, R_ADDCK0, B_ADDCK0_RST, 0x0);

 /* S1 */
 rtw89_phy_write32_mask(rtwdev, R_ADDCK1, B_ADDCK1_RST, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_ADDCK1, B_ADDCK1_EN, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_ADDCK1, B_ADDCK1_EN, 0x0);
 udelay(1);
 rtw89_phy_write32_mask(rtwdev, R_ADDCK1, B_ADDCK1, 0x1);

 ret = read_poll_timeout_atomic(rtw89_phy_read32_mask, val, val,
           1, 10000, false, rtwdev, 0xc1fc, BIT(0));
 if (ret) {
  rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]S1 ADDCK timeout\n");
  dack->addck_timeout[0] = true;
 }
 rtw89_phy_write32_mask(rtwdev, R_ADDCK1, B_ADDCK1_RST, 0x0);
}

static void _dack_reset(struct rtw89_dev *rtwdev, u8 path)
{
 rtw89_rfk_parser_by_cond(rtwdev, path == RF_PATH_A,
     &rtw8852c_dack_reset_defs_a_tbl,
     &rtw8852c_dack_reset_defs_b_tbl);
}

enum adc_ck {
 ADC_NA = 0,
 ADC_480M = 1,
 ADC_960M = 2,
 ADC_1920M = 3,
};

enum dac_ck {
 DAC_40M = 0,
 DAC_80M = 1,
 DAC_120M = 2,
 DAC_160M = 3,
 DAC_240M = 4,
 DAC_320M = 5,
 DAC_480M = 6,
 DAC_960M = 7,
};

enum rf_mode {
 RF_SHUT_DOWN = 0x0,
 RF_STANDBY = 0x1,
 RF_TX = 0x2,
 RF_RX = 0x3,
 RF_TXIQK = 0x4,
 RF_DPK = 0x5,
 RF_RXK1 = 0x6,
 RF_RXK2 = 0x7,
};

static void rtw8852c_txck_force(struct rtw89_dev *rtwdev, u8 path, bool force,
    enum dac_ck ck)
{
 rtw89_phy_write32_mask(rtwdev, R_P0_RXCK | (path << 13), B_P0_TXCK_ON, 0x0);

 if (!force)
  return;

 rtw89_phy_write32_mask(rtwdev, R_P0_RXCK | (path << 13), B_P0_TXCK_VAL, ck);
 rtw89_phy_write32_mask(rtwdev, R_P0_RXCK | (path << 13), B_P0_TXCK_ON, 0x1);
}

static void rtw8852c_rxck_force(struct rtw89_dev *rtwdev, u8 path, bool force,
    enum adc_ck ck)
{
 const struct rxck_def *def;

 rtw89_phy_write32_mask(rtwdev, R_P0_RXCK | (path << 13), B_P0_RXCK_ON, 0x0);

 if (!force)
  return;

 rtw89_phy_write32_mask(rtwdev, R_P0_RXCK | (path << 13), B_P0_RXCK_VAL, ck);
 rtw89_phy_write32_mask(rtwdev, R_P0_RXCK | (path << 13), B_P0_RXCK_ON, 0x1);

 switch (ck) {
 case ADC_480M:
  def = &_ck480M;
  break;
 case ADC_960M:
  def = &_ck960M;
  break;
 case ADC_1920M:
 default:
  def = &_ck1920M;
  break;
 }

 rtw89_phy_write32_mask(rtwdev, R_P0_CFCH_BW0 | (path << 8), B_P0_CFCH_CTL, def->ctl);
 rtw89_phy_write32_mask(rtwdev, R_P0_CFCH_BW0 | (path << 8), B_P0_CFCH_EN, def->en);
 rtw89_phy_write32_mask(rtwdev, R_P0_CFCH_BW0 | (path << 8), B_P0_CFCH_BW0, def->bw0);
 rtw89_phy_write32_mask(rtwdev, R_P0_CFCH_BW1 | (path << 8), B_P0_CFCH_BW1, def->bw1);
 rtw89_phy_write32_mask(rtwdev, R_DRCK | (path << 8), B_DRCK_MUL, def->mul);
 rtw89_phy_write32_mask(rtwdev, R_ADCMOD | (path << 8), B_ADCMOD_LP, def->lp);
}

static bool _check_dack_done(struct rtw89_dev *rtwdev, bool s0)
{
 if (s0) {
  if (rtw89_phy_read32_mask(rtwdev, R_DACK_S0P0, B_DACK_S0P0_OK) == 0 ||
      rtw89_phy_read32_mask(rtwdev, R_DACK_S0P1, B_DACK_S0P1_OK) == 0 ||
      rtw89_phy_read32_mask(rtwdev, R_DACK_S0P2, B_DACK_S0P2_OK) == 0 ||
      rtw89_phy_read32_mask(rtwdev, R_DACK_S0P3, B_DACK_S0P3_OK) == 0)
   return false;
 } else {
  if (rtw89_phy_read32_mask(rtwdev, R_DACK_S1P0, B_DACK_S1P0_OK) == 0 ||
      rtw89_phy_read32_mask(rtwdev, R_DACK_S1P1, B_DACK_S1P1_OK) == 0 ||
      rtw89_phy_read32_mask(rtwdev, R_DACK_S1P2, B_DACK_S1P2_OK) == 0 ||
      rtw89_phy_read32_mask(rtwdev, R_DACK_S1P3, B_DACK_S1P3_OK) == 0)
   return false;
 }

 return true;
}

static void _dack_s0(struct rtw89_dev *rtwdev)
{
 struct rtw89_dack_info *dack = &rtwdev->dack;
 bool done;
 int ret;

 rtw8852c_txck_force(rtwdev, RF_PATH_A, true, DAC_160M);
 rtw89_rfk_parser(rtwdev, &rtw8852c_dack_defs_s0_tbl);

 _dack_reset(rtwdev, RF_PATH_A);

 rtw89_phy_write32_mask(rtwdev, R_DCOF1, B_DCOF1_S, 0x1);
 ret = read_poll_timeout_atomic(_check_dack_done, done, done,
           1, 10000, false, rtwdev, true);
 if (ret) {
  rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]S0 DACK timeout\n");
  dack->msbk_timeout[0] = true;
 }
 rtw89_phy_write32_mask(rtwdev, R_DCOF1, B_DCOF1_S, 0x0);
 rtw8852c_txck_force(rtwdev, RF_PATH_A, false, DAC_960M);
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]after S0 DADCK\n");

 _dack_backup_s0(rtwdev);
 _dack_reload(rtwdev, RF_PATH_A);
 rtw89_phy_write32_mask(rtwdev, R_P0_NRBW, B_P0_NRBW_DBG, 0x0);
}

static void _dack_s1(struct rtw89_dev *rtwdev)
{
 struct rtw89_dack_info *dack = &rtwdev->dack;
 bool done;
 int ret;

 rtw8852c_txck_force(rtwdev, RF_PATH_B, true, DAC_160M);
 rtw89_rfk_parser(rtwdev, &rtw8852c_dack_defs_s1_tbl);

 _dack_reset(rtwdev, RF_PATH_B);

 rtw89_phy_write32_mask(rtwdev, R_DACK1_K, B_DACK1_EN, 0x1);
 ret = read_poll_timeout_atomic(_check_dack_done, done, done,
           1, 10000, false, rtwdev, false);
 if (ret) {
  rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]S1 DACK timeout\n");
  dack->msbk_timeout[0] = true;
 }
 rtw89_phy_write32_mask(rtwdev, R_DACK1_K, B_DACK1_EN, 0x0);
 rtw8852c_txck_force(rtwdev, RF_PATH_B, false, DAC_960M);
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]after S1 DADCK\n");

 _dack_backup_s1(rtwdev);
 _dack_reload(rtwdev, RF_PATH_B);
 rtw89_phy_write32_mask(rtwdev, R_P1_DBGMOD, B_P1_DBGMOD_ON, 0x0);
}

static void _dack(struct rtw89_dev *rtwdev)
{
 _dack_s0(rtwdev);
 _dack_s1(rtwdev);
}

static void _drck(struct rtw89_dev *rtwdev)
{
 u32 val;
 int ret;

 rtw89_phy_write32_mask(rtwdev, R_DRCK, B_DRCK_EN, 0x1);
 ret = read_poll_timeout_atomic(rtw89_phy_read32_mask, val, val,
           1, 10000, false, rtwdev, 0xc0c8, BIT(3));
 if (ret)
  rtw89_debug(rtwdev, RTW89_DBG_RFK,  "[DACK]DRCK timeout\n");

 rtw89_rfk_parser(rtwdev, &rtw8852c_drck_defs_tbl);

 val = rtw89_phy_read32_mask(rtwdev, R_DRCK_RES, B_DRCK_RES);
 rtw89_phy_write32_mask(rtwdev, R_DRCK, B_DRCK_IDLE, 0x0);
 rtw89_phy_write32_mask(rtwdev, R_DRCK, B_DRCK_VAL, val);
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0xc0c4 = 0x%x\n",
      rtw89_phy_read32_mask(rtwdev, R_DRCK, MASKDWORD));
}

static void _dac_cal(struct rtw89_dev *rtwdev, bool force,
       enum rtw89_chanctx_idx chanctx_idx)
{
 struct rtw89_dack_info *dack = &rtwdev->dack;
 u32 rf0_0, rf1_0;
 u8 phy_map = rtw89_btc_phymap(rtwdev, RTW89_PHY_0, RF_AB, chanctx_idx);

 dack->dack_done = false;
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]DACK b\n");
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]DACK start!!!\n");
 rf0_0 = rtw89_read_rf(rtwdev, RF_PATH_A, RR_MOD, RFREG_MASK);
 rf1_0 = rtw89_read_rf(rtwdev, RF_PATH_B, RR_MOD, RFREG_MASK);
 _drck(rtwdev);

 rtw89_write_rf(rtwdev, RF_PATH_A, RR_RSV1, RR_RSV1_RST, 0x0);
 rtw89_write_rf(rtwdev, RF_PATH_B, RR_RSV1, RR_RSV1_RST, 0x0);
 rtw89_write_rf(rtwdev, RF_PATH_A, RR_MOD, RFREG_MASK, 0x337e1);
 rtw89_write_rf(rtwdev, RF_PATH_B, RR_MOD, RFREG_MASK, 0x337e1);
 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_DACK, BTC_WRFK_ONESHOT_START);
 _addck(rtwdev);
 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_DACK, BTC_WRFK_ONESHOT_STOP);

 _addck_backup(rtwdev);
 _addck_reload(rtwdev);
 rtw89_write_rf(rtwdev, RF_PATH_A, RR_MODOPT, RFREG_MASK, 0x0);
 rtw89_write_rf(rtwdev, RF_PATH_B, RR_MODOPT, RFREG_MASK, 0x0);
 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_DACK, BTC_WRFK_ONESHOT_START);
 _dack(rtwdev);
 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_DACK, BTC_WRFK_ONESHOT_STOP);

 _dack_dump(rtwdev);
 dack->dack_done = true;
 rtw89_write_rf(rtwdev, RF_PATH_A, RR_MOD, RFREG_MASK, rf0_0);
 rtw89_write_rf(rtwdev, RF_PATH_B, RR_MOD, RFREG_MASK, rf1_0);
 rtw89_write_rf(rtwdev, RF_PATH_A, RR_RSV1, RR_RSV1_RST, 0x1);
 rtw89_write_rf(rtwdev, RF_PATH_B, RR_RSV1, RR_RSV1_RST, 0x1);
 dack->dack_cnt++;
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]DACK finish!!!\n");
}

#define RTW8852C_NCTL_VER 0xd
#define RTW8852C_IQK_VER 0x2a
#define RTW8852C_IQK_SS 2
#define RTW8852C_IQK_THR_REK 8
#define RTW8852C_IQK_CFIR_GROUP_NR 4

enum rtw8852c_iqk_type {
 ID_TXAGC,
 ID_G_FLOK_COARSE,
 ID_A_FLOK_COARSE,
 ID_G_FLOK_FINE,
 ID_A_FLOK_FINE,
 ID_FLOK_VBUFFER,
 ID_TXK,
 ID_RXAGC,
 ID_RXK,
 ID_NBTXK,
 ID_NBRXK,
};

static void rtw8852c_disable_rxagc(struct rtw89_dev *rtwdev, u8 path, u8 en_rxgac)
{
 if (path == RF_PATH_A)
  rtw89_phy_write32_mask(rtwdev, R_P0_AGC_CTL, B_P0_AGC_EN, en_rxgac);
 else
  rtw89_phy_write32_mask(rtwdev, R_P1_AGC_CTL, B_P1_AGC_EN, en_rxgac);
}

static void _iqk_rxk_setting(struct rtw89_dev *rtwdev, u8 path)
{
 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;

 if (path == RF_PATH_A)
  rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_RXK, 0x0101);
 else
  rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_RXK, 0x0202);

 switch (iqk_info->iqk_bw[path]) {
 case RTW89_CHANNEL_WIDTH_20:
 case RTW89_CHANNEL_WIDTH_40:
  rtw89_phy_write32_mask(rtwdev, R_UPD_CLK + (path << 13), B_DPD_GDIS, 0x1);
  rtw8852c_rxck_force(rtwdev, path, true, ADC_480M);
  rtw89_phy_write32_mask(rtwdev, R_UPD_CLK + (path << 13), B_ACK_VAL, 0x0);
  rtw89_write_rf(rtwdev, path, RR_RXBB2, RR_RXBB2_CKT, 0x1);
  rtw89_phy_write32_mask(rtwdev, R_P0_NRBW + (path << 13), B_P0_NRBW_DBG, 0x1);
  break;
 case RTW89_CHANNEL_WIDTH_80:
  rtw89_phy_write32_mask(rtwdev, R_UPD_CLK + (path << 13), B_DPD_GDIS, 0x1);
  rtw8852c_rxck_force(rtwdev, path, true, ADC_960M);
  rtw89_phy_write32_mask(rtwdev, R_UPD_CLK + (path << 13), B_ACK_VAL, 0x1);
  rtw89_write_rf(rtwdev, path, RR_RXBB2, RR_RXBB2_CKT, 0x1);
  rtw89_phy_write32_mask(rtwdev, R_P0_NRBW + (path << 13), B_P0_NRBW_DBG, 0x1);
 break;
 case RTW89_CHANNEL_WIDTH_160:
  rtw89_phy_write32_mask(rtwdev, R_UPD_CLK + (path << 13), B_DPD_GDIS, 0x1);
  rtw8852c_rxck_force(rtwdev, path, true, ADC_1920M);
  rtw89_phy_write32_mask(rtwdev, R_UPD_CLK + (path << 13), B_ACK_VAL, 0x2);
  rtw89_write_rf(rtwdev, path, RR_RXBB2, RR_RXBB2_CKT, 0x1);
  rtw89_phy_write32_mask(rtwdev, R_P0_NRBW + (path << 13), B_P0_NRBW_DBG, 0x1);
  break;
 default:
  break;
 }

 rtw89_rfk_parser(rtwdev, &rtw8852c_iqk_rxk_cfg_defs_tbl);

 if (path == RF_PATH_A)
  rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_RXK, 0x1101);
 else
  rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_RXK, 0x2202);
}

static bool _iqk_check_cal(struct rtw89_dev *rtwdev, u8 path, u8 ktype)
{
 u32 tmp;
 u32 val;
 int ret;

 ret = read_poll_timeout_atomic(rtw89_phy_read32_mask, val, val == 0x55,
           1, 8200, false, rtwdev, 0xbff8, MASKBYTE0);
 if (ret)
  rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]IQK timeout!!!\n");

 rtw89_phy_write32_clr(rtwdev, R_NCTL_N1, MASKBYTE0);
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]S%x, ret=%d\n", path, ret);
 tmp = rtw89_phy_read32_mask(rtwdev, R_NCTL_RPT, MASKDWORD);
 rtw89_debug(rtwdev, RTW89_DBG_RFK,
      "[IQK]S%x, type= %x, 0x8008 = 0x%x\n", path, ktype, tmp);

 return false;
}

static bool _iqk_one_shot(struct rtw89_dev *rtwdev,
     enum rtw89_phy_idx phy_idx, u8 path, u8 ktype)
{
 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
 u32 addr_rfc_ctl = R_UPD_CLK + (path << 13);
 u32 iqk_cmd;
 bool fail;

 switch (ktype) {
 case ID_TXAGC:
  iqk_cmd = 0x008 | (1 << (4 + path)) | (path << 1);
  break;
 case ID_A_FLOK_COARSE:
  rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x1);
  iqk_cmd = 0x008 | (1 << (4 + path));
  break;
 case ID_G_FLOK_COARSE:
  rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x1);
  iqk_cmd = 0x108 | (1 << (4 + path));
  break;
 case ID_A_FLOK_FINE:
  rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x1);
  iqk_cmd = 0x508 | (1 << (4 + path));
  break;
 case ID_G_FLOK_FINE:
  rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x1);
  iqk_cmd = 0x208 | (1 << (4 + path));
  break;
 case ID_FLOK_VBUFFER:
  rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x1);
  iqk_cmd = 0x308 | (1 << (4 + path));
  break;
 case ID_TXK:
  rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x0);
  iqk_cmd = 0x008 | (1 << (4 + path)) | ((0x8 + iqk_info->iqk_bw[path]) << 8);
  break;
 case ID_RXAGC:
  iqk_cmd = 0x508 | (1 << (4 + path)) | (path << 1);
  break;
 case ID_RXK:
  rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x1);
  iqk_cmd = 0x008 | (1 << (4 + path)) | ((0xc + iqk_info->iqk_bw[path]) << 8);
  break;
 case ID_NBTXK:
  rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x0);
  iqk_cmd = 0x408 | (1 << (4 + path));
  break;
 case ID_NBRXK:
  rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x1);
  iqk_cmd = 0x608 | (1 << (4 + path));
  break;
 default:
  return false;
 }

 rtw89_phy_write32_mask(rtwdev, R_NCTL_CFG, MASKDWORD, iqk_cmd + 1);
 fsleep(15);
 fail = _iqk_check_cal(rtwdev, path, ktype);
 rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x0);

 return fail;
}

static bool _rxk_group_sel(struct rtw89_dev *rtwdev,
      enum rtw89_phy_idx phy_idx, u8 path)
{
 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
 bool fail;
 u32 tmp;
 u32 bkrf0;
 u8 gp;

 bkrf0 = rtw89_read_rf(rtwdev, path, RR_MOD, RR_MOD_NBW);
 if (path == RF_PATH_B) {
  rtw89_write_rf(rtwdev, RF_PATH_B, RR_IQKPLL, RR_IQKPLL_MOD, 0x3);
  tmp = rtw89_read_rf(rtwdev, RF_PATH_B, RR_CHTR, RR_CHTR_MOD);
  rtw89_write_rf(rtwdev, RF_PATH_B, RR_RSV4, RR_RSV4_AGH, tmp);
  tmp = rtw89_read_rf(rtwdev, RF_PATH_B, RR_CHTR, RR_CHTR_TXRX);
  rtw89_write_rf(rtwdev, RF_PATH_B, RR_RSV4, RR_RSV4_PLLCH, tmp);
 }

 switch (iqk_info->iqk_band[path]) {
 case RTW89_BAND_2G:
 default:
  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, 0xc);
  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_NBW, 0x0);
  rtw89_write_rf(rtwdev, path, RR_RXG, RR_RXG_IQKMOD, 0x9);
  break;
 case RTW89_BAND_5G:
  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, 0xc);
  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_NBW, 0x0);
  rtw89_write_rf(rtwdev, path, RR_RXAE, RR_RXAE_IQKMOD, 0x8);
  break;
 case RTW89_BAND_6G:
  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, 0xc);
  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_NBW, 0x0);
  rtw89_write_rf(rtwdev, path, RR_RXAE, RR_RXAE_IQKMOD, 0x9);
  break;
 }

 fsleep(10);

 for (gp = 0; gp < RXK_GROUP_NR; gp++) {
  switch (iqk_info->iqk_band[path]) {
  case RTW89_BAND_2G:
  default:
   rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_M_RXG,
           _rxk_g_idxrxgain[gp]);
   rtw89_write_rf(rtwdev, path, RR_RXBB, RR_RXBB_VOBUF,
           _rxk_g_idxattc2[gp]);
   break;
  case RTW89_BAND_5G:
   rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_M_RXG,
           _rxk_a_idxrxgain[gp]);
   rtw89_write_rf(rtwdev, path, RR_RXA2, RR_RXA2_IATT,
           _rxk_a_idxattc2[gp]);
   break;
  case RTW89_BAND_6G:
   rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_M_RXG,
           _rxk_a6_idxrxgain[gp]);
   rtw89_write_rf(rtwdev, path, RR_RXA2, RR_RXA2_IATT,
           _rxk_a6_idxattc2[gp]);
   break;
  }
  rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8),
           B_CFIR_LUT_SEL, 0x1);
  rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8),
           B_CFIR_LUT_SET, 0x0);
  rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8),
           B_CFIR_LUT_GP_V1, gp);
  fail = _iqk_one_shot(rtwdev, phy_idx, path, ID_RXK);
 }

 if (path == RF_PATH_B)
  rtw89_write_rf(rtwdev, path, RR_IQKPLL, RR_IQKPLL_MOD, 0x0);
 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_NBW, bkrf0);

 if (fail) {
  iqk_info->nb_rxcfir[path] = 0x40000002;
  iqk_info->is_wb_rxiqk[path] = false;
 } else {
  iqk_info->nb_rxcfir[path] = 0x40000000;
  iqk_info->is_wb_rxiqk[path] = true;
 }

 return false;
}

static bool _iqk_nbrxk(struct rtw89_dev *rtwdev,
         enum rtw89_phy_idx phy_idx, u8 path)
{
 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
 bool fail;
 u32 tmp;
 u32 bkrf0;
 u8 gp = 0x2;

 bkrf0 = rtw89_read_rf(rtwdev, path, RR_MOD, RR_MOD_NBW);
 if (path == RF_PATH_B) {
  rtw89_write_rf(rtwdev, RF_PATH_B, RR_IQKPLL, RR_IQKPLL_MOD, 0x3);
  tmp = rtw89_read_rf(rtwdev, RF_PATH_B, RR_CHTR, RR_CHTR_MOD);
  rtw89_write_rf(rtwdev, RF_PATH_B, RR_RSV4, RR_RSV4_AGH, tmp);
  tmp = rtw89_read_rf(rtwdev, RF_PATH_B, RR_CHTR, RR_CHTR_TXRX);
  rtw89_write_rf(rtwdev, RF_PATH_B, RR_RSV4, RR_RSV4_PLLCH, tmp);
 }

 switch (iqk_info->iqk_band[path]) {
 case RTW89_BAND_2G:
 default:
  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, 0xc);
  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_NBW, 0x0);
  rtw89_write_rf(rtwdev, path, RR_RXG, RR_RXG_IQKMOD, 0x9);
  break;
 case RTW89_BAND_5G:
  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, 0xc);
  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_NBW, 0x0);
  rtw89_write_rf(rtwdev, path, RR_RXAE, RR_RXAE_IQKMOD, 0x8);
  break;
 case RTW89_BAND_6G:
  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, 0xc);
  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_NBW, 0x0);
  rtw89_write_rf(rtwdev, path, RR_RXAE, RR_RXAE_IQKMOD, 0x9);
  break;
 }

 fsleep(10);

 switch (iqk_info->iqk_band[path]) {
 case RTW89_BAND_2G:
 default:
  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_M_RXG, _rxk_g_idxrxgain[gp]);
  rtw89_write_rf(rtwdev, path, RR_RXBB, RR_RXBB_VOBUF, _rxk_g_idxattc2[gp]);
  break;
 case RTW89_BAND_5G:
  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_M_RXG, _rxk_a_idxrxgain[gp]);
  rtw89_write_rf(rtwdev, path, RR_RXA2, RR_RXA2_IATT, _rxk_a_idxattc2[gp]);
  break;
 case RTW89_BAND_6G:
  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_M_RXG, _rxk_a6_idxrxgain[gp]);
  rtw89_write_rf(rtwdev, path, RR_RXA2, RR_RXA2_IATT, _rxk_a6_idxattc2[gp]);
  break;
 }

 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8), B_CFIR_LUT_SEL, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8), B_CFIR_LUT_SET, 0x0);
 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8), B_CFIR_LUT_GP_V1, gp);
 fail = _iqk_one_shot(rtwdev, phy_idx, path, ID_RXK);

 if (path == RF_PATH_B)
  rtw89_write_rf(rtwdev, path, RR_IQKPLL, RR_IQKPLL_MOD, 0x0);

 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_NBW, bkrf0);

 if (fail)
  iqk_info->nb_rxcfir[path] =
   rtw89_phy_read32_mask(rtwdev, R_RXIQC + (path << 8),
           MASKDWORD) | 0x2;
 else
  iqk_info->nb_rxcfir[path] = 0x40000002;

 iqk_info->is_wb_rxiqk[path] = false;
 return fail;
}

static bool _txk_group_sel(struct rtw89_dev *rtwdev,
      enum rtw89_phy_idx phy_idx, u8 path)
{
 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
 bool fail;
 u8 gp;

 for (gp = 0; gp < TXK_GROUP_NR; gp++) {
  switch (iqk_info->iqk_band[path]) {
  case RTW89_BAND_2G:
   rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0,
           _txk_g_power_range[gp]);
   rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1,
           _txk_g_track_range[gp]);
   rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG,
           _txk_g_gain_bb[gp]);
   rtw89_phy_write32_mask(rtwdev,
            R_KIP_IQP + (path << 8),
            MASKDWORD, _txk_g_itqt[gp]);
   break;
  case RTW89_BAND_5G:
   rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0,
           _txk_a_power_range[gp]);
   rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1,
           _txk_a_track_range[gp]);
   rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG,
           _txk_a_gain_bb[gp]);
   rtw89_phy_write32_mask(rtwdev,
            R_KIP_IQP + (path << 8),
            MASKDWORD, _txk_a_itqt[gp]);
   break;
  case RTW89_BAND_6G:
   rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0,
           _txk_a6_power_range[gp]);
   rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1,
           _txk_a6_track_range[gp]);
   rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG,
           _txk_a6_gain_bb[gp]);
   rtw89_phy_write32_mask(rtwdev,
            R_KIP_IQP + (path << 8),
            MASKDWORD, _txk_a6_itqt[gp]);
   break;
  default:
   break;
  }
  rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8),
           B_CFIR_LUT_SEL, 0x1);
  rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8),
           B_CFIR_LUT_SET, 0x1);
  rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8),
           B_CFIR_LUT_G2, 0x0);
  rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8),
           B_CFIR_LUT_GP, gp + 1);
  rtw89_phy_write32_mask(rtwdev, R_IQK_DIF4, B_IQK_DIF4_TXT, 0x00b);
  rtw89_phy_write32_mask(rtwdev, R_NCTL_N1, B_NCTL_N1_CIP, 0x00);
  fail = _iqk_one_shot(rtwdev, phy_idx, path, ID_TXK);
 }

 if (fail) {
  iqk_info->nb_txcfir[path] = 0x40000002;
  iqk_info->is_wb_txiqk[path] = false;
 } else {
  iqk_info->nb_txcfir[path] = 0x40000000;
  iqk_info->is_wb_txiqk[path] = true;
 }

 return fail;
}

static bool _iqk_nbtxk(struct rtw89_dev *rtwdev,
         enum rtw89_phy_idx phy_idx, u8 path)
{
 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
 bool fail;
 u8 gp = 0x2;

 switch (iqk_info->iqk_band[path]) {
 case RTW89_BAND_2G:
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0, _txk_g_power_range[gp]);
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1, _txk_g_track_range[gp]);
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, _txk_g_gain_bb[gp]);
  rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
           MASKDWORD, _txk_g_itqt[gp]);
  break;
 case RTW89_BAND_5G:
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0, _txk_a_power_range[gp]);
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1, _txk_a_track_range[gp]);
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, _txk_a_gain_bb[gp]);
  rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
           MASKDWORD, _txk_a_itqt[gp]);
  break;
 case RTW89_BAND_6G:
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0, _txk_a6_power_range[gp]);
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1, _txk_a6_track_range[gp]);
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, _txk_a6_gain_bb[gp]);
  rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
           MASKDWORD, _txk_a6_itqt[gp]);
 break;
 default:
  break;
 }

 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8), B_CFIR_LUT_SEL, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8), B_CFIR_LUT_SET, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8), B_CFIR_LUT_G2, 0x0);
 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8), B_CFIR_LUT_GP, gp + 1);
 rtw89_phy_write32_mask(rtwdev, R_IQK_DIF4, B_IQK_DIF4_TXT, 0x00b);
 rtw89_phy_write32_mask(rtwdev, R_NCTL_N1, B_NCTL_N1_CIP, 0x00);
 fail = _iqk_one_shot(rtwdev, phy_idx, path, ID_NBTXK);

 if (!fail)
  iqk_info->nb_txcfir[path] =
   rtw89_phy_read32_mask(rtwdev, R_TXIQC + (path << 8),
           MASKDWORD) | 0x2;
 else
  iqk_info->nb_txcfir[path] = 0x40000002;

 iqk_info->is_wb_txiqk[path] = false;

 return fail;
}

static bool _lok_finetune_check(struct rtw89_dev *rtwdev, u8 path)
{
 struct rtw89_rfk_mcc_info_data *rfk_mcc = rtwdev->rfk_mcc.data;
 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
 u8 idx = rfk_mcc->table_idx;
 bool is_fail1,  is_fail2;
 u32 val;
 u32 core_i;
 u32 core_q;
 u32 vbuff_i;
 u32 vbuff_q;

 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]===>%s\n", __func__);
 val = rtw89_read_rf(rtwdev,  path, RR_TXMO, RFREG_MASK);
 core_i = FIELD_GET(RR_TXMO_COI, val);
 core_q = FIELD_GET(RR_TXMO_COQ, val);

 if (core_i < 0x2 || core_i > 0x1d || core_q < 0x2 || core_q > 0x1d)
  is_fail1 = true;
 else
  is_fail1 = false;

 iqk_info->lok_idac[idx][path] = val;

 val = rtw89_read_rf(rtwdev, path, RR_LOKVB, RFREG_MASK);
 vbuff_i = FIELD_GET(RR_LOKVB_COI, val);
 vbuff_q = FIELD_GET(RR_LOKVB_COQ, val);

 if (vbuff_i < 0x2 || vbuff_i > 0x3d || vbuff_q < 0x2 || vbuff_q > 0x3d)
  is_fail2 = true;
 else
  is_fail2 = false;

 iqk_info->lok_vbuf[idx][path] = val;

 return is_fail1 || is_fail2;
}

static bool _iqk_lok(struct rtw89_dev *rtwdev,
       enum rtw89_phy_idx phy_idx, u8 path)
{
 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
 u8 tmp_id = 0x0;
 bool fail = false;
 bool tmp = false;

 /* Step 0: Init RF gain & tone idx= 8.25Mhz */
 rtw89_phy_write32_mask(rtwdev, R_IQK_DIF4, B_IQK_DIF4_TXT, IQK_DF4_TXT_8_25MHZ);

 /* Step 1  START: _lok_coarse_fine_wi_swap */
 switch (iqk_info->iqk_band[path]) {
 case RTW89_BAND_2G:
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x6);
  rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
           B_KIP_IQP_IQSW, 0x9);
  tmp_id = ID_G_FLOK_COARSE;
  break;
 case RTW89_BAND_5G:
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x6);
  rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
           B_KIP_IQP_IQSW, 0x9);
  tmp_id = ID_A_FLOK_COARSE;
  break;
 case RTW89_BAND_6G:
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x6);
  rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
           B_KIP_IQP_IQSW, 0x9);
  tmp_id = ID_A_FLOK_COARSE;
  break;
 default:
  break;
 }
 tmp = _iqk_one_shot(rtwdev, phy_idx, path, tmp_id);
 iqk_info->lok_cor_fail[0][path] = tmp;

 /* Step 2 */
 switch (iqk_info->iqk_band[path]) {
 case RTW89_BAND_2G:
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x12);
  rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
           B_KIP_IQP_IQSW, 0x1b);
  break;
 case RTW89_BAND_5G:
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x12);
  rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
           B_KIP_IQP_IQSW, 0x1b);
  break;
 case RTW89_BAND_6G:
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x12);
  rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
           B_KIP_IQP_IQSW, 0x1b);
  break;
 default:
  break;
 }
 tmp = _iqk_one_shot(rtwdev, phy_idx, path, ID_FLOK_VBUFFER);

 /* Step 3 */
 switch (iqk_info->iqk_band[path]) {
 case RTW89_BAND_2G:
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x6);
  rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
           B_KIP_IQP_IQSW, 0x9);
  tmp_id = ID_G_FLOK_FINE;
  break;
 case RTW89_BAND_5G:
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x6);
  rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
           B_KIP_IQP_IQSW, 0x9);
  tmp_id = ID_A_FLOK_FINE;
  break;
 case RTW89_BAND_6G:
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x6);
  rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
           B_KIP_IQP_IQSW, 0x9);
  tmp_id = ID_A_FLOK_FINE;
  break;
 default:
  break;
 }
 tmp = _iqk_one_shot(rtwdev, phy_idx, path, tmp_id);
 iqk_info->lok_fin_fail[0][path] = tmp;

 /* Step 4 large rf gain */
 switch (iqk_info->iqk_band[path]) {
 case RTW89_BAND_2G:
 default:
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x12);
  rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
           B_KIP_IQP_IQSW, 0x1b);
  break;
 case RTW89_BAND_5G:
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x12);
  rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
           B_KIP_IQP_IQSW, 0x1b);
  break;
 case RTW89_BAND_6G:
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x12);
  rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
           B_KIP_IQP_IQSW, 0x1b);
  break;
 }
 tmp = _iqk_one_shot(rtwdev, phy_idx, path, ID_FLOK_VBUFFER);
 fail = _lok_finetune_check(rtwdev, path);

 return fail;
}

static void _iqk_txk_setting(struct rtw89_dev *rtwdev, u8 path)
{
 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;

 switch (iqk_info->iqk_band[path]) {
 case RTW89_BAND_2G:
 default:
  rtw89_write_rf(rtwdev, path, RR_TXG1, RR_TXG1_ATT2, 0x0);
  rtw89_write_rf(rtwdev, path, RR_TXG1, RR_TXG1_ATT1, 0x0);
  rtw89_write_rf(rtwdev, path, RR_TXG2, RR_TXG2_ATT0, 0x1);
  rtw89_write_rf(rtwdev, path, RR_TXA2, RR_TXA2_LDO, 0xf);
  rtw89_write_rf(rtwdev, path, RR_TXGA, RR_TXGA_LOK_EXT, 0x0);
  rtw89_write_rf(rtwdev, path, RR_LUTWE, RR_LUTWE_LOK, 0x1);
  rtw89_write_rf(rtwdev, path, RR_MOD, RFREG_MASK,
          0x403e0 | iqk_info->syn1to2);
  fsleep(10);
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0, 0x0);
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1, 0x6);
  break;
 case RTW89_BAND_5G:
  rtw89_write_rf(rtwdev, path, RR_TXATANK, RR_TXATANK_LBSW2, 0x0);
  rtw89_write_rf(rtwdev, path, RR_TXPOW, RR_TXPOW_TXAS, 0x1);
  rtw89_write_rf(rtwdev, path, RR_TXA2, RR_TXA2_LDO, 0xf);
  rtw89_write_rf(rtwdev, path, RR_TXGA, RR_TXGA_LOK_EXT, 0x0);
  rtw89_write_rf(rtwdev, path, RR_LUTWE, RR_LUTWE_LOK, 0x1);
  rtw89_write_rf(rtwdev, path, RR_MOD, RFREG_MASK,
          0x403e0 | iqk_info->syn1to2);
  fsleep(10);
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0, 0x0);
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1, 0x6);
  break;
 case RTW89_BAND_6G:
  rtw89_write_rf(rtwdev, path, RR_TXATANK, RR_TXATANK_LBSW2, 0x0);
  rtw89_write_rf(rtwdev, path, RR_TXPOW, RR_TXPOW_TXAS, 0x1);
  rtw89_write_rf(rtwdev, path, RR_TXA2, RR_TXA2_LDO, 0xf);
  rtw89_write_rf(rtwdev, path, RR_TXGA, RR_TXGA_LOK_EXT, 0x0);
  rtw89_write_rf(rtwdev, path, RR_LUTWE, RR_LUTWE_LOK, 0x1);
  rtw89_write_rf(rtwdev, path, RR_MOD, RFREG_MASK,
          0x403e0  | iqk_info->syn1to2);
  fsleep(10);
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0, 0x0);
  rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1, 0x6);
  break;
 }
}

static void _iqk_info_iqk(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy_idx,
     u8 path)
{
 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
 u32 tmp;
 bool flag;

 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]S%d_thermal = %lu\n", path,
      ewma_thermal_read(&rtwdev->phystat.avg_thermal[path]));
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]S%d_LOK_COR_fail= %d\n", path,
      iqk_info->lok_cor_fail[0][path]);
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]S%d_LOK_FIN_fail= %d\n", path,
      iqk_info->lok_fin_fail[0][path]);
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]S%d_TXIQK_fail = %d\n", path,
      iqk_info->iqk_tx_fail[0][path]);
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]S%d_RXIQK_fail= %d,\n", path,
      iqk_info->iqk_rx_fail[0][path]);

 flag = iqk_info->lok_cor_fail[0][path];
 rtw89_phy_write32_mask(rtwdev, R_IQKINF, B_IQKINF_FCOR << (path * 4), flag);
 flag = iqk_info->lok_fin_fail[0][path];
 rtw89_phy_write32_mask(rtwdev, R_IQKINF, B_IQKINF_FFIN << (path * 4), flag);
 flag = iqk_info->iqk_tx_fail[0][path];
 rtw89_phy_write32_mask(rtwdev, R_IQKINF, B_IQKINF_FTX << (path * 4), flag);
 flag = iqk_info->iqk_rx_fail[0][path];
 rtw89_phy_write32_mask(rtwdev, R_IQKINF, B_IQKINF_F_RX << (path * 4), flag);

 tmp = rtw89_phy_read32_mask(rtwdev, R_IQK_RES + (path << 8), MASKDWORD);
 iqk_info->bp_iqkenable[path] = tmp;
 tmp = rtw89_phy_read32_mask(rtwdev, R_TXIQC + (path << 8), MASKDWORD);
 iqk_info->bp_txkresult[path] = tmp;
 tmp = rtw89_phy_read32_mask(rtwdev, R_RXIQC + (path << 8), MASKDWORD);
 iqk_info->bp_rxkresult[path] = tmp;

 rtw89_phy_write32_mask(rtwdev, R_IQKINF2, B_IQKINF2_KCNT,
          iqk_info->iqk_times);

 tmp = rtw89_phy_read32_mask(rtwdev, R_IQKINF, B_IQKINF_FAIL << (path * 4));
 if (tmp != 0x0)
  iqk_info->iqk_fail_cnt++;
 rtw89_phy_write32_mask(rtwdev, R_IQKINF2, B_IQKINF2_FCNT << (path * 4),
          iqk_info->iqk_fail_cnt);
}

static void _iqk_by_path(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy_idx, u8 path)
{
 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;

 _iqk_txk_setting(rtwdev, path);
 iqk_info->lok_fail[path] = _iqk_lok(rtwdev, phy_idx, path);

 if (iqk_info->is_nbiqk)
  iqk_info->iqk_tx_fail[0][path] = _iqk_nbtxk(rtwdev, phy_idx, path);
 else
  iqk_info->iqk_tx_fail[0][path] = _txk_group_sel(rtwdev, phy_idx, path);

 _iqk_rxk_setting(rtwdev, path);
 if (iqk_info->is_nbiqk)
  iqk_info->iqk_rx_fail[0][path] = _iqk_nbrxk(rtwdev, phy_idx, path);
 else
  iqk_info->iqk_rx_fail[0][path] = _rxk_group_sel(rtwdev, phy_idx, path);

 _iqk_info_iqk(rtwdev, phy_idx, path);
}

static void _iqk_get_ch_info(struct rtw89_dev *rtwdev,
        enum rtw89_phy_idx phy, u8 path,
        enum rtw89_chanctx_idx chanctx_idx)
{
 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, chanctx_idx);
 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;

 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]===>%s\n", __func__);

 iqk_info->iqk_band[path] = chan->band_type;
 iqk_info->iqk_bw[path] = chan->band_width;
 iqk_info->iqk_ch[path] = chan->channel;

 rtw89_debug(rtwdev, RTW89_DBG_RFK,
      "[IQK]iqk_info->iqk_band[%x] = 0x%x\n", path,
      iqk_info->iqk_band[path]);
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]iqk_info->iqk_bw[%x] = 0x%x\n",
      path, iqk_info->iqk_bw[path]);
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]iqk_info->iqk_ch[%x] = 0x%x\n",
      path, iqk_info->iqk_ch[path]);
 rtw89_debug(rtwdev, RTW89_DBG_RFK,
      "[IQK]S%d (PHY%d): / DBCC %s/ %s/ CH%d/ %s\n", path, phy,
      rtwdev->dbcc_en ? "on" : "off",
      iqk_info->iqk_band[path] == 0 ? "2G" :
      iqk_info->iqk_band[path] == 1 ? "5G" : "6G",
      iqk_info->iqk_ch[path],
      iqk_info->iqk_bw[path] == 0 ? "20M" :
      iqk_info->iqk_bw[path] == 1 ? "40M" : "80M");
 if (!rtwdev->dbcc_en)
  iqk_info->syn1to2 = 0x1;
 else
  iqk_info->syn1to2 = 0x3;

 rtw89_phy_write32_mask(rtwdev, R_IQKINF, B_IQKINF_VER, RTW8852C_IQK_VER);
 rtw89_phy_write32_mask(rtwdev, R_IQKCH, B_IQKCH_BAND << (path * 16),
          iqk_info->iqk_band[path]);
 rtw89_phy_write32_mask(rtwdev, R_IQKCH, B_IQKCH_BW << (path * 16),
          iqk_info->iqk_bw[path]);
 rtw89_phy_write32_mask(rtwdev, R_IQKCH, B_IQKCH_CH << (path * 16),
          iqk_info->iqk_ch[path]);

 rtw89_phy_write32_mask(rtwdev, R_IQKINF2, B_IQKINF2_NCTLV, RTW8852C_NCTL_VER);
}

static void _iqk_start_iqk(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy_idx,
      u8 path)
{
 _iqk_by_path(rtwdev, phy_idx, path);
}

static void _iqk_restore(struct rtw89_dev *rtwdev, u8 path)
{
 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
 bool fail;

 rtw89_phy_write32_mask(rtwdev, R_TXIQC + (path << 8), MASKDWORD,
          iqk_info->nb_txcfir[path]);
 rtw89_phy_write32_mask(rtwdev, R_RXIQC + (path << 8), MASKDWORD,
          iqk_info->nb_rxcfir[path]);
 rtw89_phy_write32_mask(rtwdev, R_NCTL_CFG, MASKDWORD,
          0x00001219 + (path << 4));
 fsleep(200);
 fail = _iqk_check_cal(rtwdev, path, 0x12);
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK] restore fail = %x\n", fail);

 rtw89_phy_write32_mask(rtwdev, R_NCTL_N1, B_NCTL_N1_CIP, 0x00);
 rtw89_phy_write32_mask(rtwdev, R_NCTL_RPT, MASKDWORD, 0x00000000);
 rtw89_phy_write32_mask(rtwdev, R_KIP_SYSCFG, MASKDWORD, 0x80000000);

 rtw89_write_rf(rtwdev, path, RR_LUTWE, RR_LUTWE_LOK, 0x0);
 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, RR_MOD_V_RX);
 rtw89_write_rf(rtwdev, path, RR_RSV1, RR_RSV1_RST, 0x1);
}

static void _iqk_afebb_restore(struct rtw89_dev *rtwdev,
          enum rtw89_phy_idx phy_idx, u8 path)
{
 rtw89_rfk_parser_by_cond(rtwdev, path == RF_PATH_A,
     &rtw8852c_iqk_afebb_restore_defs_a_tbl,
     &rtw8852c_iqk_afebb_restore_defs_b_tbl);

 rtw8852c_disable_rxagc(rtwdev, path, 0x1);
}

static void _iqk_preset(struct rtw89_dev *rtwdev, u8 path)
{
 struct rtw89_rfk_mcc_info_data *rfk_mcc = rtwdev->rfk_mcc.data;
 u8 idx = 0;

 idx = rfk_mcc->table_idx;
 rtw89_phy_write32_mask(rtwdev, R_COEF_SEL + (path << 8), B_COEF_SEL_IQC, idx);
 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8), B_CFIR_LUT_G3, idx);
 rtw89_write_rf(rtwdev, path, RR_RSV1, RR_RSV1_RST, 0x0);
 rtw89_phy_write32_mask(rtwdev, R_NCTL_RPT, MASKDWORD, 0x00000080);
 rtw89_phy_write32_mask(rtwdev, R_KIP_SYSCFG, MASKDWORD, 0x81ff010a);
}

static void _iqk_macbb_setting(struct rtw89_dev *rtwdev,
          enum rtw89_phy_idx phy_idx, u8 path)
{
 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]===> %s\n", __func__);

 /* 01_BB_AFE_for DPK_S0_20210820 */
 rtw89_write_rf(rtwdev,  path, RR_BBDC, RR_BBDC_SEL, 0x0);
 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A0 << path, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A1 << path, 0x0);
 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A2 << path, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A3 << path, 0x0);

 /* disable rxgac */
 rtw8852c_disable_rxagc(rtwdev, path, 0x0);
 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK | (path << 13), MASKDWORD, 0xf801fffd);
 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK | (path << 13), B_DPD_DIS, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK | (path << 13), B_DAC_VAL, 0x1);

 rtw8852c_txck_force(rtwdev, path, true, DAC_960M);
 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK | (path << 13), B_DPD_GDIS, 0x1);

 rtw8852c_rxck_force(rtwdev, path, true, ADC_1920M);
 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK | (path << 13), B_ACK_VAL, 0x2);

 rtw89_phy_write32_mask(rtwdev, R_P0_NRBW | (path << 13), B_P0_NRBW_DBG, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_ANAPAR_PW15, B_ANAPAR_PW15, 0x1f);
 rtw89_phy_write32_mask(rtwdev, R_ANAPAR_PW15, B_ANAPAR_PW15, 0x13);
 rtw89_phy_write32_mask(rtwdev, R_ANAPAR, B_ANAPAR_15, 0x0001);
 rtw89_phy_write32_mask(rtwdev, R_ANAPAR, B_ANAPAR_15, 0x0041);
 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A1 << path, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A3 << path, 0x1);
}

static void _rck(struct rtw89_dev *rtwdev, enum rtw89_rf_path path)
{
 u32 rf_reg5, rck_val = 0;
 u32 val;
 int ret;

 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RCK] ====== S%d RCK ======\n", path);

 rf_reg5 = rtw89_read_rf(rtwdev, path, RR_RSV1, RFREG_MASK);

 rtw89_write_rf(rtwdev, path, RR_RSV1, RR_RSV1_RST, 0x0);
 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, RR_MOD_V_RX);

 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RCK] RF0x00 = 0x%x\n",
      rtw89_read_rf(rtwdev, path, RR_MOD, RFREG_MASK));

 /* RCK trigger */
 rtw89_write_rf(rtwdev, path, RR_RCKC, RFREG_MASK, 0x00240);

 ret = read_poll_timeout_atomic(rtw89_read_rf, val, val, 2, 20,
           false, rtwdev, path, 0x1c, BIT(3));
 if (ret)
  rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RCK] RCK timeout\n");

 rck_val = rtw89_read_rf(rtwdev, path, RR_RCKC, RR_RCKC_CA);
 rtw89_write_rf(rtwdev, path, RR_RCKC, RFREG_MASK, rck_val);

 rtw89_write_rf(rtwdev, path, RR_RSV1, RFREG_MASK, rf_reg5);

 rtw89_debug(rtwdev, RTW89_DBG_RFK,
      "[RCK] RF 0x1b / 0x1c = 0x%x / 0x%x\n",
      rtw89_read_rf(rtwdev, path, RR_RCKC, RFREG_MASK),
      rtw89_read_rf(rtwdev, path, RR_RCKS, RFREG_MASK));
}

static void _iqk_init(struct rtw89_dev *rtwdev)
{
 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
 u8 ch, path;

 rtw89_phy_write32_clr(rtwdev, R_IQKINF, MASKDWORD);
 if (iqk_info->is_iqk_init)
  return;

 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]===>%s\n", __func__);
 iqk_info->is_iqk_init = true;
 iqk_info->is_nbiqk = false;
 iqk_info->iqk_fft_en = false;
 iqk_info->iqk_sram_en = false;
 iqk_info->iqk_cfir_en = false;
 iqk_info->iqk_xym_en = false;
 iqk_info->iqk_times = 0x0;

 for (ch = 0; ch < RTW89_IQK_CHS_NR; ch++) {
  iqk_info->iqk_channel[ch] = 0x0;
  for (path = 0; path < RTW8852C_IQK_SS; path++) {
   iqk_info->lok_cor_fail[ch][path] = false;
   iqk_info->lok_fin_fail[ch][path] = false;
   iqk_info->iqk_tx_fail[ch][path] = false;
   iqk_info->iqk_rx_fail[ch][path] = false;
   iqk_info->iqk_mcc_ch[ch][path] = 0x0;
   iqk_info->iqk_table_idx[path] = 0x0;
  }
 }
}

static void _doiqk(struct rtw89_dev *rtwdev, bool force,
     enum rtw89_phy_idx phy_idx, u8 path,
     enum rtw89_chanctx_idx chanctx_idx)
{
 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
 u32 backup_bb_val[BACKUP_BB_REGS_NR];
 u32 backup_rf_val[RTW8852C_IQK_SS][BACKUP_RF_REGS_NR];
 u8 phy_map = rtw89_btc_phymap(rtwdev, phy_idx, RF_AB, chanctx_idx);

 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_IQK, BTC_WRFK_ONESHOT_START);

 rtw89_debug(rtwdev, RTW89_DBG_RFK,
      "[IQK]==========IQK start!!!!!==========\n");
 iqk_info->iqk_times++;
 iqk_info->version = RTW8852C_IQK_VER;

 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]Test Ver 0x%x\n", iqk_info->version);
 _iqk_get_ch_info(rtwdev, phy_idx, path, chanctx_idx);
 _rfk_backup_bb_reg(rtwdev, backup_bb_val);
 _rfk_backup_rf_reg(rtwdev, backup_rf_val[path], path);
 _iqk_macbb_setting(rtwdev, phy_idx, path);
 _iqk_preset(rtwdev, path);
 _iqk_start_iqk(rtwdev, phy_idx, path);
 _iqk_restore(rtwdev, path);
 _iqk_afebb_restore(rtwdev, phy_idx, path);
 _rfk_restore_bb_reg(rtwdev, backup_bb_val);
 _rfk_restore_rf_reg(rtwdev, backup_rf_val[path], path);
 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_IQK, BTC_WRFK_ONESHOT_STOP);
}

static void _iqk(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy_idx, bool force,
   enum rtw89_chanctx_idx chanctx_idx)
{
 switch (_kpath(rtwdev, phy_idx)) {
 case RF_A:
  _doiqk(rtwdev, force, phy_idx, RF_PATH_A, chanctx_idx);
  break;
 case RF_B:
  _doiqk(rtwdev, force, phy_idx, RF_PATH_B, chanctx_idx);
  break;
 case RF_AB:
  _doiqk(rtwdev, force, phy_idx, RF_PATH_A, chanctx_idx);
  _doiqk(rtwdev, force, phy_idx, RF_PATH_B, chanctx_idx);
  break;
 default:
  break;
 }
}

static void _rx_dck_value_rewrite(struct rtw89_dev *rtwdev, u8 path, u8 addr,
      u8 val_i, u8 val_q)
{
 u32 ofst_val;

 rtw89_debug(rtwdev, RTW89_DBG_RFK,
      "[RX_DCK] rewrite val_i = 0x%x, val_q = 0x%x\n", val_i, val_q);

 /* val_i and val_q are 7 bits, and target is 6 bits. */
 ofst_val = u32_encode_bits(val_q >> 1, RR_LUTWD0_MB) |
     u32_encode_bits(val_i >> 1, RR_LUTWD0_LB);

 rtw89_write_rf(rtwdev, path, RR_LUTPLL, RR_CAL_RW, 0x1);
 rtw89_write_rf(rtwdev, path, RR_RFC, RR_WCAL, 0x1);
 rtw89_write_rf(rtwdev, path, RR_DCK, RR_DCK_FINE, 0x1);
 rtw89_write_rf(rtwdev, path, RR_LUTWA, MASKBYTE0, addr);
 rtw89_write_rf(rtwdev, path, RR_LUTWD0, RFREG_MASK, ofst_val);
 rtw89_write_rf(rtwdev, path, RR_LUTWD0, RFREG_MASK, ofst_val);
 rtw89_write_rf(rtwdev, path, RR_DCK, RR_DCK_FINE, 0x0);
 rtw89_write_rf(rtwdev, path, RR_RFC, RR_WCAL, 0x0);
 rtw89_write_rf(rtwdev, path, RR_LUTPLL, RR_CAL_RW, 0x0);

 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RX_DCK] Final val_i = 0x%x, val_q = 0x%x\n",
      u32_get_bits(ofst_val, RR_LUTWD0_LB) << 1,
      u32_get_bits(ofst_val, RR_LUTWD0_MB) << 1);
}

static bool _rx_dck_rek_check(struct rtw89_dev *rtwdev, u8 path)
{
 u8 i_even_bs, q_even_bs;
 u8 i_odd_bs, q_odd_bs;
 u8 i_even, q_even;
 u8 i_odd, q_odd;
 const u8 th = 10;
 u8 i;

 for (i = 0; i < RF_PATH_NUM_8852C; i++) {
  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_DCK, _dck_addr_bs[i]);
  i_even_bs = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_TIA);
  q_even_bs = rtw89_read_rf(rtwdev, path, RR_DCK1, RR_DCK1_TIA);
  rtw89_debug(rtwdev, RTW89_DBG_RFK,
       "[RX_DCK] Gain[0x%x] i_even_bs/ q_even_bs = 0x%x/ 0x%x\n",
       _dck_addr_bs[i], i_even_bs, q_even_bs);

  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_DCK, _dck_addr[i]);
  i_even = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_TIA);
  q_even = rtw89_read_rf(rtwdev, path, RR_DCK1, RR_DCK1_TIA);
  rtw89_debug(rtwdev, RTW89_DBG_RFK,
       "[RX_DCK] Gain[0x%x] i_even/ q_even = 0x%x/ 0x%x\n",
       _dck_addr[i], i_even, q_even);

  if (abs(i_even_bs - i_even) > th || abs(q_even_bs - q_even) > th)
   return true;

  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_DCK, _dck_addr_bs[i] + 1);
  i_odd_bs = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_TIA);
  q_odd_bs = rtw89_read_rf(rtwdev, path, RR_DCK1, RR_DCK1_TIA);
  rtw89_debug(rtwdev, RTW89_DBG_RFK,
       "[RX_DCK] Gain[0x%x] i_odd_bs/ q_odd_bs = 0x%x/ 0x%x\n",
       _dck_addr_bs[i] + 1, i_odd_bs, q_odd_bs);

  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_DCK, _dck_addr[i] + 1);
  i_odd = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_TIA);
  q_odd = rtw89_read_rf(rtwdev, path, RR_DCK1, RR_DCK1_TIA);
  rtw89_debug(rtwdev, RTW89_DBG_RFK,
       "[RX_DCK] Gain[0x%x] i_odd/ q_odd = 0x%x/ 0x%x\n",
       _dck_addr[i] + 1, i_odd, q_odd);

  if (abs(i_odd_bs - i_odd) > th || abs(q_odd_bs - q_odd) > th)
   return true;
 }

 return false;
}

static void _rx_dck_fix_if_need(struct rtw89_dev *rtwdev, u8 path, u8 addr,
    u8 val_i_bs, u8 val_q_bs, u8 val_i, u8 val_q)
{
 const u8 th = 10;

 if ((abs(val_i_bs - val_i) < th) && (abs(val_q_bs - val_q) <= th)) {
  rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RX_DCK] offset check PASS!!\n");
  return;
 }

 if (abs(val_i_bs - val_i) > th) {
  rtw89_debug(rtwdev, RTW89_DBG_RFK,
       "[RX_DCK] val_i over TH (0x%x / 0x%x)\n", val_i_bs, val_i);
  val_i = val_i_bs;
 }

 if (abs(val_q_bs - val_q) > th) {
  rtw89_debug(rtwdev, RTW89_DBG_RFK,
       "[RX_DCK] val_q over TH (0x%x / 0x%x)\n", val_q_bs, val_q);
  val_q = val_q_bs;
 }

 _rx_dck_value_rewrite(rtwdev, path, addr, val_i, val_q);
}

static void _rx_dck_recover(struct rtw89_dev *rtwdev, u8 path)
{
 u8 i_even_bs, q_even_bs;
 u8 i_odd_bs, q_odd_bs;
 u8 i_even, q_even;
 u8 i_odd, q_odd;
 u8 i;

 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RX_DCK] ===> recovery\n");

 for (i = 0; i < RF_PATH_NUM_8852C; i++) {
  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_DCK, _dck_addr_bs[i]);
  i_even_bs = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_TIA);
  q_even_bs = rtw89_read_rf(rtwdev, path, RR_DCK1, RR_DCK1_TIA);

  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_DCK, _dck_addr_bs[i] + 1);
  i_odd_bs = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_TIA);
  q_odd_bs = rtw89_read_rf(rtwdev, path, RR_DCK1, RR_DCK1_TIA);

  rtw89_debug(rtwdev, RTW89_DBG_RFK,
       "[RX_DCK] Gain[0x%x] i_even_bs/ q_even_bs = 0x%x/ 0x%x\n",
       _dck_addr_bs[i], i_even_bs, q_even_bs);

  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_DCK, _dck_addr[i]);
  i_even = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_TIA);
  q_even = rtw89_read_rf(rtwdev, path, RR_DCK1, RR_DCK1_TIA);

  rtw89_debug(rtwdev, RTW89_DBG_RFK,
       "[RX_DCK] Gain[0x%x] i_even/ q_even = 0x%x/ 0x%x\n",
       _dck_addr[i], i_even, q_even);
  _rx_dck_fix_if_need(rtwdev, path, _dck_addr[i],
        i_even_bs, q_even_bs, i_even, q_even);

  rtw89_debug(rtwdev, RTW89_DBG_RFK,
       "[RX_DCK] Gain[0x%x] i_odd_bs/ q_odd_bs = 0x%x/ 0x%x\n",
       _dck_addr_bs[i] + 1, i_odd_bs, q_odd_bs);

  rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_DCK, _dck_addr[i] + 1);
  i_odd = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_TIA);
  q_odd = rtw89_read_rf(rtwdev, path, RR_DCK1, RR_DCK1_TIA);

  rtw89_debug(rtwdev, RTW89_DBG_RFK,
       "[RX_DCK] Gain[0x%x] i_odd/ q_odd = 0x%x/ 0x%x\n",
       _dck_addr[i] + 1, i_odd, q_odd);
  _rx_dck_fix_if_need(rtwdev, path, _dck_addr[i] + 1,
        i_odd_bs, q_odd_bs, i_odd, q_odd);
 }
}

static void _rx_dck_toggle(struct rtw89_dev *rtwdev, u8 path)
{
 int ret;
 u32 val;

 rtw89_write_rf(rtwdev, path, RR_DCK, RR_DCK_LV, 0x0);
 rtw89_write_rf(rtwdev, path, RR_DCK, RR_DCK_LV, 0x1);

 ret = read_poll_timeout_atomic(rtw89_read_rf, val, val,
           2, 2000, false, rtwdev, path,
           RR_DCK1, RR_DCK1_DONE);
 if (ret)
  rtw89_warn(rtwdev, "[RX_DCK] S%d RXDCK timeout\n", path);
 else
  rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RX_DCK] S%d RXDCK finish\n", path);

 rtw89_write_rf(rtwdev, path, RR_DCK, RR_DCK_LV, 0x0);
}

static void _set_rx_dck(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy, u8 path,
   bool is_afe)
{
 u8 res;

 rtw89_write_rf(rtwdev, path, RR_DCK1, RR_DCK1_CLR, 0x0);

 _rx_dck_toggle(rtwdev, path);
 if (rtw89_read_rf(rtwdev, path, RR_DCKC, RR_DCKC_CHK) == 0)
  return;
 res = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_DONE);
 if (res > 1) {
  rtw89_write_rf(rtwdev, path, RR_RXBB2, RR_RXBB2_IDAC, res);
  _rx_dck_toggle(rtwdev, path);
  rtw89_write_rf(rtwdev, path, RR_RXBB2, RR_RXBB2_IDAC, 0x1);
 }
}

static
u8 _rx_dck_channel_calc(struct rtw89_dev *rtwdev, const struct rtw89_chan *chan)
{
 u8 target_ch = 0;

 if (chan->band_type == RTW89_BAND_5G) {
  if (chan->channel >= 36 && chan->channel <= 64) {
   target_ch = 100;
  } else if (chan->channel >= 100 && chan->channel <= 144) {
   target_ch = chan->channel + 32;
   if (target_ch > 144)
    target_ch = chan->channel + 33;
  } else if (chan->channel >= 149 && chan->channel <= 177) {
   target_ch = chan->channel - 33;
  }
 } else if (chan->band_type == RTW89_BAND_6G) {
  if (chan->channel > 125)
   target_ch = chan->channel - 32;
  else
   target_ch = chan->channel + 32;
 } else {
  target_ch = chan->channel;
 }

 rtw89_debug(rtwdev, RTW89_DBG_RFK,
      "[RX_DCK] cur_ch / target_ch = %d / %d\n",
      chan->channel, target_ch);

 return target_ch;
}

#define RTW8852C_RF_REL_VERSION 34
#define RTW8852C_DPK_VER 0xf
#define RTW8852C_DPK_TH_AVG_NUM 4
#define RTW8852C_DPK_RF_PATH 2
#define RTW8852C_DPK_KIP_REG_NUM 7
#define RTW8852C_DPK_RXSRAM_DBG 0

enum rtw8852c_dpk_id {
 LBK_RXIQK = 0x06,
 SYNC  = 0x10,
 MDPK_IDL = 0x11,
 MDPK_MPA = 0x12,
 GAIN_LOSS = 0x13,
 GAIN_CAL = 0x14,
 DPK_RXAGC = 0x15,
 KIP_PRESET = 0x16,
 KIP_RESTORE = 0x17,
 DPK_TXAGC = 0x19,
 D_KIP_PRESET = 0x28,
 D_TXAGC  = 0x29,
 D_RXAGC  = 0x2a,
 D_SYNC  = 0x2b,
 D_GAIN_LOSS = 0x2c,
 D_MDPK_IDL = 0x2d,
 D_GAIN_NORM = 0x2f,
 D_KIP_THERMAL = 0x30,
 D_KIP_RESTORE = 0x31
};

#define DPK_TXAGC_LOWER 0x2e
#define DPK_TXAGC_UPPER 0x3f
#define DPK_TXAGC_INVAL 0xff

enum dpk_agc_step {
 DPK_AGC_STEP_SYNC_DGAIN,
 DPK_AGC_STEP_GAIN_LOSS_IDX,
 DPK_AGC_STEP_GL_GT_CRITERION,
 DPK_AGC_STEP_GL_LT_CRITERION,
 DPK_AGC_STEP_SET_TX_GAIN,
};

enum dpk_pas_result {
 DPK_PAS_NOR,
 DPK_PAS_GT,
 DPK_PAS_LT,
};

static void _rf_direct_cntrl(struct rtw89_dev *rtwdev,
        enum rtw89_rf_path path, bool is_bybb)
{
 if (is_bybb)
  rtw89_write_rf(rtwdev, path, RR_RSV1, RR_RSV1_RST, 0x1);
 else
  rtw89_write_rf(rtwdev, path, RR_RSV1, RR_RSV1_RST, 0x0);
}

static void _dpk_onoff(struct rtw89_dev *rtwdev,
         enum rtw89_rf_path path, bool off);

static void _dpk_bkup_kip(struct rtw89_dev *rtwdev, const u32 reg[],
     u32 reg_bkup[][RTW8852C_DPK_KIP_REG_NUM], u8 path)
{
 u8 i;

 for (i = 0; i < RTW8852C_DPK_KIP_REG_NUM; i++) {
  reg_bkup[path][i] =
   rtw89_phy_read32_mask(rtwdev, reg[i] + (path << 8), MASKDWORD);

  rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] Backup 0x%x = %x\n",
       reg[i] + (path << 8), reg_bkup[path][i]);
 }
}

static void _dpk_reload_kip(struct rtw89_dev *rtwdev, const u32 reg[],
       u32 reg_bkup[][RTW8852C_DPK_KIP_REG_NUM], u8 path)
{
 u8 i;

 for (i = 0; i < RTW8852C_DPK_KIP_REG_NUM; i++) {
  rtw89_phy_write32_mask(rtwdev, reg[i] + (path << 8),
           MASKDWORD, reg_bkup[path][i]);
  rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] Reload 0x%x = %x\n",
       reg[i] + (path << 8), reg_bkup[path][i]);
 }
}

static u8 _dpk_one_shot(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
   enum rtw89_rf_path path, enum rtw8852c_dpk_id id)
{
 u16 dpk_cmd;
 u32 val;
 int ret;

 dpk_cmd = (u16)((id << 8) | (0x19 + path * 0x12));

 rtw89_phy_write32_mask(rtwdev, R_NCTL_CFG, MASKDWORD, dpk_cmd);

 ret = read_poll_timeout_atomic(rtw89_phy_read32_mask, val, val == 0x55,
           10, 20000, false, rtwdev, 0xbff8, MASKBYTE0);
 udelay(10);
 rtw89_phy_write32_clr(rtwdev, R_NCTL_N1, MASKBYTE0);

 rtw89_debug(rtwdev, RTW89_DBG_RFK,
      "[DPK] one-shot for %s = 0x%x (ret=%d)\n",
      id == 0x06 ? "LBK_RXIQK" :
      id == 0x10 ? "SYNC" :
      id == 0x11 ? "MDPK_IDL" :
      id == 0x12 ? "MDPK_MPA" :
      id == 0x13 ? "GAIN_LOSS" : "PWR_CAL",
      dpk_cmd, ret);

 if (ret) {
  rtw89_debug(rtwdev, RTW89_DBG_RFK,
       "[DPK] one-shot over 20ms!!!!\n");
  return 1;
 }

 return 0;
}

static void _dpk_information(struct rtw89_dev *rtwdev,
        enum rtw89_phy_idx phy,
        enum rtw89_rf_path path, enum rtw89_chanctx_idx chanctx_idx)
{
 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, chanctx_idx);
 struct rtw89_dpk_info *dpk = &rtwdev->dpk;

 u8 kidx = dpk->cur_idx[path];

 dpk->bp[path][kidx].band = chan->band_type;
 dpk->bp[path][kidx].ch = chan->channel;
 dpk->bp[path][kidx].bw = chan->band_width;

 rtw89_debug(rtwdev, RTW89_DBG_RFK,
      "[DPK] S%d[%d] (PHY%d): TSSI %s/ DBCC %s/ %s/ CH%d/ %s\n",
      path, dpk->cur_idx[path], phy,
      rtwdev->is_tssi_mode[path] ? "on" : "off",
      rtwdev->dbcc_en ? "on" : "off",
      dpk->bp[path][kidx].band == 0 ? "2G" :
      dpk->bp[path][kidx].band == 1 ? "5G" : "6G",
      dpk->bp[path][kidx].ch,
      dpk->bp[path][kidx].bw == 0 ? "20M" :
      dpk->bp[path][kidx].bw == 1 ? "40M" : "80M");
}

static void _dpk_bb_afe_setting(struct rtw89_dev *rtwdev,
    enum rtw89_phy_idx phy,
    enum rtw89_rf_path path, u8 kpath)
{
 /*1. Keep ADC_fifo reset*/
 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A0 << path, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A1 << path, 0x0);
 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A2 << path, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A3 << path, 0x0);

 /*2. BB for IQK DBG mode*/
 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK + (path << 13), MASKDWORD, 0xd801dffd);

 /*3.Set DAC clk*/
 rtw8852c_txck_force(rtwdev, path, true, DAC_960M);

 /*4. Set ADC clk*/
 rtw8852c_rxck_force(rtwdev, path, true, ADC_1920M);
 rtw89_phy_write32_mask(rtwdev, R_P0_NRBW + (path << 13),
          B_P0_NRBW_DBG, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_ANAPAR_PW15, MASKBYTE3, 0x1f);
 rtw89_phy_write32_mask(rtwdev, R_ANAPAR_PW15, MASKBYTE3, 0x13);
 rtw89_phy_write32_mask(rtwdev, R_ANAPAR, MASKHWORD, 0x0001);
 rtw89_phy_write32_mask(rtwdev, R_ANAPAR, MASKHWORD, 0x0041);

 /*5. ADDA fifo rst*/
 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A1 << path, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A3 << path, 0x1);

 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] S%d BB/AFE setting\n", path);
}

static void _dpk_bb_afe_restore(struct rtw89_dev *rtwdev, u8 path)
{
 rtw89_phy_write32_mask(rtwdev, R_P0_NRBW + (path << 13),
          B_P0_NRBW_DBG, 0x0);
 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A0 << path, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A1 << path, 0x0);
 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A2 << path, 0x1);
 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A3 << path, 0x0);
 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK + (path << 13), MASKDWORD, 0x00000000);
--> --------------------

--> maximum size reached

--> --------------------