1fbb35286SLarry Finger // SPDX-License-Identifier: GPL-2.0 2fbb35286SLarry Finger /* Copyright(c) 2009-2013 Realtek Corporation.*/ 3f1d2b4d3SLarry Finger 4f1d2b4d3SLarry Finger #include "../wifi.h" 5f1d2b4d3SLarry Finger #include "../base.h" 6f1d2b4d3SLarry Finger #include "../pci.h" 7f1d2b4d3SLarry Finger #include "../core.h" 8f1d2b4d3SLarry Finger #include "reg.h" 9f1d2b4d3SLarry Finger #include "def.h" 10f1d2b4d3SLarry Finger #include "phy.h" 11f1d2b4d3SLarry Finger #include "dm.h" 12f1d2b4d3SLarry Finger #include "fw.h" 13f1d2b4d3SLarry Finger #include "trx.h" 14f1d2b4d3SLarry Finger 15f1d2b4d3SLarry Finger static const u32 ofdmswing_table[OFDM_TABLE_SIZE] = { 16f1d2b4d3SLarry Finger 0x7f8001fe, /* 0, +6.0dB */ 17f1d2b4d3SLarry Finger 0x788001e2, /* 1, +5.5dB */ 18f1d2b4d3SLarry Finger 0x71c001c7, /* 2, +5.0dB */ 19f1d2b4d3SLarry Finger 0x6b8001ae, /* 3, +4.5dB */ 20f1d2b4d3SLarry Finger 0x65400195, /* 4, +4.0dB */ 21f1d2b4d3SLarry Finger 0x5fc0017f, /* 5, +3.5dB */ 22f1d2b4d3SLarry Finger 0x5a400169, /* 6, +3.0dB */ 23f1d2b4d3SLarry Finger 0x55400155, /* 7, +2.5dB */ 24f1d2b4d3SLarry Finger 0x50800142, /* 8, +2.0dB */ 25f1d2b4d3SLarry Finger 0x4c000130, /* 9, +1.5dB */ 26f1d2b4d3SLarry Finger 0x47c0011f, /* 10, +1.0dB */ 27f1d2b4d3SLarry Finger 0x43c0010f, /* 11, +0.5dB */ 28f1d2b4d3SLarry Finger 0x40000100, /* 12, +0dB */ 29f1d2b4d3SLarry Finger 0x3c8000f2, /* 13, -0.5dB */ 30f1d2b4d3SLarry Finger 0x390000e4, /* 14, -1.0dB */ 31f1d2b4d3SLarry Finger 0x35c000d7, /* 15, -1.5dB */ 32f1d2b4d3SLarry Finger 0x32c000cb, /* 16, -2.0dB */ 33f1d2b4d3SLarry Finger 0x300000c0, /* 17, -2.5dB */ 34f1d2b4d3SLarry Finger 0x2d4000b5, /* 18, -3.0dB */ 35f1d2b4d3SLarry Finger 0x2ac000ab, /* 19, -3.5dB */ 36f1d2b4d3SLarry Finger 0x288000a2, /* 20, -4.0dB */ 37f1d2b4d3SLarry Finger 0x26000098, /* 21, -4.5dB */ 38f1d2b4d3SLarry Finger 0x24000090, /* 22, -5.0dB */ 39f1d2b4d3SLarry Finger 0x22000088, /* 23, -5.5dB */ 40f1d2b4d3SLarry Finger 0x20000080, /* 24, -6.0dB */ 41f1d2b4d3SLarry Finger 0x1e400079, /* 25, -6.5dB */ 42f1d2b4d3SLarry Finger 0x1c800072, /* 26, -7.0dB */ 43f1d2b4d3SLarry Finger 0x1b00006c, /* 27. -7.5dB */ 44f1d2b4d3SLarry Finger 0x19800066, /* 28, -8.0dB */ 45f1d2b4d3SLarry Finger 0x18000060, /* 29, -8.5dB */ 46f1d2b4d3SLarry Finger 0x16c0005b, /* 30, -9.0dB */ 47f1d2b4d3SLarry Finger 0x15800056, /* 31, -9.5dB */ 48f1d2b4d3SLarry Finger 0x14400051, /* 32, -10.0dB */ 49f1d2b4d3SLarry Finger 0x1300004c, /* 33, -10.5dB */ 50f1d2b4d3SLarry Finger 0x12000048, /* 34, -11.0dB */ 51f1d2b4d3SLarry Finger 0x11000044, /* 35, -11.5dB */ 52f1d2b4d3SLarry Finger 0x10000040, /* 36, -12.0dB */ 53f1d2b4d3SLarry Finger 0x0f00003c, /* 37, -12.5dB */ 54f1d2b4d3SLarry Finger 0x0e400039, /* 38, -13.0dB */ 55f1d2b4d3SLarry Finger 0x0d800036, /* 39, -13.5dB */ 56f1d2b4d3SLarry Finger 0x0cc00033, /* 40, -14.0dB */ 57f1d2b4d3SLarry Finger 0x0c000030, /* 41, -14.5dB */ 58f1d2b4d3SLarry Finger 0x0b40002d, /* 42, -15.0dB */ 59f1d2b4d3SLarry Finger }; 60f1d2b4d3SLarry Finger 61f1d2b4d3SLarry Finger static const u8 cck_tbl_ch1_13[CCK_TABLE_SIZE][8] = { 62f1d2b4d3SLarry Finger {0x36, 0x35, 0x2e, 0x25, 0x1c, 0x12, 0x09, 0x04}, /* 0, +0dB */ 63f1d2b4d3SLarry Finger {0x33, 0x32, 0x2b, 0x23, 0x1a, 0x11, 0x08, 0x04}, /* 1, -0.5dB */ 64f1d2b4d3SLarry Finger {0x30, 0x2f, 0x29, 0x21, 0x19, 0x10, 0x08, 0x03}, /* 2, -1.0dB */ 65f1d2b4d3SLarry Finger {0x2d, 0x2d, 0x27, 0x1f, 0x18, 0x0f, 0x08, 0x03}, /* 3, -1.5dB */ 66f1d2b4d3SLarry Finger {0x2b, 0x2a, 0x25, 0x1e, 0x16, 0x0e, 0x07, 0x03}, /* 4, -2.0dB */ 67f1d2b4d3SLarry Finger {0x28, 0x28, 0x22, 0x1c, 0x15, 0x0d, 0x07, 0x03}, /* 5, -2.5dB */ 68f1d2b4d3SLarry Finger {0x26, 0x25, 0x21, 0x1b, 0x14, 0x0d, 0x06, 0x03}, /* 6, -3.0dB */ 69f1d2b4d3SLarry Finger {0x24, 0x23, 0x1f, 0x19, 0x13, 0x0c, 0x06, 0x03}, /* 7, -3.5dB */ 70f1d2b4d3SLarry Finger {0x22, 0x21, 0x1d, 0x18, 0x11, 0x0b, 0x06, 0x02}, /* 8, -4.0dB */ 71f1d2b4d3SLarry Finger {0x20, 0x20, 0x1b, 0x16, 0x11, 0x08, 0x05, 0x02}, /* 9, -4.5dB */ 72f1d2b4d3SLarry Finger {0x1f, 0x1e, 0x1a, 0x15, 0x10, 0x0a, 0x05, 0x02}, /* 10, -5.0dB */ 73f1d2b4d3SLarry Finger {0x1d, 0x1c, 0x18, 0x14, 0x0f, 0x0a, 0x05, 0x02}, /* 11, -5.5dB */ 74f1d2b4d3SLarry Finger {0x1b, 0x1a, 0x17, 0x13, 0x0e, 0x09, 0x04, 0x02}, /* 12, -6.0dB */ 75f1d2b4d3SLarry Finger {0x1a, 0x19, 0x16, 0x12, 0x0d, 0x09, 0x04, 0x02}, /* 13, -6.5dB */ 76f1d2b4d3SLarry Finger {0x18, 0x17, 0x15, 0x11, 0x0c, 0x08, 0x04, 0x02}, /* 14, -7.0dB */ 77f1d2b4d3SLarry Finger {0x17, 0x16, 0x13, 0x10, 0x0c, 0x08, 0x04, 0x02}, /* 15, -7.5dB */ 78f1d2b4d3SLarry Finger {0x16, 0x15, 0x12, 0x0f, 0x0b, 0x07, 0x04, 0x01}, /* 16, -8.0dB */ 79f1d2b4d3SLarry Finger {0x14, 0x14, 0x11, 0x0e, 0x0b, 0x07, 0x03, 0x02}, /* 17, -8.5dB */ 80f1d2b4d3SLarry Finger {0x13, 0x13, 0x10, 0x0d, 0x0a, 0x06, 0x03, 0x01}, /* 18, -9.0dB */ 81f1d2b4d3SLarry Finger {0x12, 0x12, 0x0f, 0x0c, 0x09, 0x06, 0x03, 0x01}, /* 19, -9.5dB */ 82f1d2b4d3SLarry Finger {0x11, 0x11, 0x0f, 0x0c, 0x09, 0x06, 0x03, 0x01}, /* 20, -10.0dB*/ 83f1d2b4d3SLarry Finger {0x10, 0x10, 0x0e, 0x0b, 0x08, 0x05, 0x03, 0x01}, /* 21, -10.5dB*/ 84f1d2b4d3SLarry Finger {0x0f, 0x0f, 0x0d, 0x0b, 0x08, 0x05, 0x03, 0x01}, /* 22, -11.0dB*/ 85f1d2b4d3SLarry Finger {0x0e, 0x0e, 0x0c, 0x0a, 0x08, 0x05, 0x02, 0x01}, /* 23, -11.5dB*/ 86f1d2b4d3SLarry Finger {0x0d, 0x0d, 0x0c, 0x0a, 0x07, 0x05, 0x02, 0x01}, /* 24, -12.0dB*/ 87f1d2b4d3SLarry Finger {0x0d, 0x0c, 0x0b, 0x09, 0x07, 0x04, 0x02, 0x01}, /* 25, -12.5dB*/ 88f1d2b4d3SLarry Finger {0x0c, 0x0c, 0x0a, 0x09, 0x06, 0x04, 0x02, 0x01}, /* 26, -13.0dB*/ 89f1d2b4d3SLarry Finger {0x0b, 0x0b, 0x0a, 0x08, 0x06, 0x04, 0x02, 0x01}, /* 27, -13.5dB*/ 90f1d2b4d3SLarry Finger {0x0b, 0x0a, 0x09, 0x08, 0x06, 0x04, 0x02, 0x01}, /* 28, -14.0dB*/ 91f1d2b4d3SLarry Finger {0x0a, 0x0a, 0x09, 0x07, 0x05, 0x03, 0x02, 0x01}, /* 29, -14.5dB*/ 92f1d2b4d3SLarry Finger {0x0a, 0x09, 0x08, 0x07, 0x05, 0x03, 0x02, 0x01}, /* 30, -15.0dB*/ 93f1d2b4d3SLarry Finger {0x09, 0x09, 0x08, 0x06, 0x05, 0x03, 0x01, 0x01}, /* 31, -15.5dB*/ 94f1d2b4d3SLarry Finger {0x09, 0x08, 0x07, 0x06, 0x04, 0x03, 0x01, 0x01} /* 32, -16.0dB*/ 95f1d2b4d3SLarry Finger }; 96f1d2b4d3SLarry Finger 97f1d2b4d3SLarry Finger static const u8 cck_tbl_ch14[CCK_TABLE_SIZE][8] = { 98f1d2b4d3SLarry Finger {0x36, 0x35, 0x2e, 0x1b, 0x00, 0x00, 0x00, 0x00}, /* 0, +0dB */ 99f1d2b4d3SLarry Finger {0x33, 0x32, 0x2b, 0x19, 0x00, 0x00, 0x00, 0x00}, /* 1, -0.5dB */ 100f1d2b4d3SLarry Finger {0x30, 0x2f, 0x29, 0x18, 0x00, 0x00, 0x00, 0x00}, /* 2, -1.0dB */ 101f1d2b4d3SLarry Finger {0x2d, 0x2d, 0x17, 0x17, 0x00, 0x00, 0x00, 0x00}, /* 3, -1.5dB */ 102f1d2b4d3SLarry Finger {0x2b, 0x2a, 0x25, 0x15, 0x00, 0x00, 0x00, 0x00}, /* 4, -2.0dB */ 103f1d2b4d3SLarry Finger {0x28, 0x28, 0x24, 0x14, 0x00, 0x00, 0x00, 0x00}, /* 5, -2.5dB */ 104f1d2b4d3SLarry Finger {0x26, 0x25, 0x21, 0x13, 0x00, 0x00, 0x00, 0x00}, /* 6, -3.0dB */ 105f1d2b4d3SLarry Finger {0x24, 0x23, 0x1f, 0x12, 0x00, 0x00, 0x00, 0x00}, /* 7, -3.5dB */ 106f1d2b4d3SLarry Finger {0x22, 0x21, 0x1d, 0x11, 0x00, 0x00, 0x00, 0x00}, /* 8, -4.0dB */ 107f1d2b4d3SLarry Finger {0x20, 0x20, 0x1b, 0x10, 0x00, 0x00, 0x00, 0x00}, /* 9, -4.5dB */ 108f1d2b4d3SLarry Finger {0x1f, 0x1e, 0x1a, 0x0f, 0x00, 0x00, 0x00, 0x00}, /* 10, -5.0dB */ 109f1d2b4d3SLarry Finger {0x1d, 0x1c, 0x18, 0x0e, 0x00, 0x00, 0x00, 0x00}, /* 11, -5.5dB */ 110f1d2b4d3SLarry Finger {0x1b, 0x1a, 0x17, 0x0e, 0x00, 0x00, 0x00, 0x00}, /* 12, -6.0dB */ 111f1d2b4d3SLarry Finger {0x1a, 0x19, 0x16, 0x0d, 0x00, 0x00, 0x00, 0x00}, /* 13, -6.5dB */ 112f1d2b4d3SLarry Finger {0x18, 0x17, 0x15, 0x0c, 0x00, 0x00, 0x00, 0x00}, /* 14, -7.0dB */ 113f1d2b4d3SLarry Finger {0x17, 0x16, 0x13, 0x0b, 0x00, 0x00, 0x00, 0x00}, /* 15, -7.5dB */ 114f1d2b4d3SLarry Finger {0x16, 0x15, 0x12, 0x0b, 0x00, 0x00, 0x00, 0x00}, /* 16, -8.0dB */ 115f1d2b4d3SLarry Finger {0x14, 0x14, 0x11, 0x0a, 0x00, 0x00, 0x00, 0x00}, /* 17, -8.5dB */ 116f1d2b4d3SLarry Finger {0x13, 0x13, 0x10, 0x0a, 0x00, 0x00, 0x00, 0x00}, /* 18, -9.0dB */ 117f1d2b4d3SLarry Finger {0x12, 0x12, 0x0f, 0x09, 0x00, 0x00, 0x00, 0x00}, /* 19, -9.5dB */ 118f1d2b4d3SLarry Finger {0x11, 0x11, 0x0f, 0x09, 0x00, 0x00, 0x00, 0x00}, /* 20, -10.0dB*/ 119f1d2b4d3SLarry Finger {0x10, 0x10, 0x0e, 0x08, 0x00, 0x00, 0x00, 0x00}, /* 21, -10.5dB*/ 120f1d2b4d3SLarry Finger {0x0f, 0x0f, 0x0d, 0x08, 0x00, 0x00, 0x00, 0x00}, /* 22, -11.0dB*/ 121f1d2b4d3SLarry Finger {0x0e, 0x0e, 0x0c, 0x07, 0x00, 0x00, 0x00, 0x00}, /* 23, -11.5dB*/ 122f1d2b4d3SLarry Finger {0x0d, 0x0d, 0x0c, 0x07, 0x00, 0x00, 0x00, 0x00}, /* 24, -12.0dB*/ 123f1d2b4d3SLarry Finger {0x0d, 0x0c, 0x0b, 0x06, 0x00, 0x00, 0x00, 0x00}, /* 25, -12.5dB*/ 124f1d2b4d3SLarry Finger {0x0c, 0x0c, 0x0a, 0x06, 0x00, 0x00, 0x00, 0x00}, /* 26, -13.0dB*/ 125f1d2b4d3SLarry Finger {0x0b, 0x0b, 0x0a, 0x06, 0x00, 0x00, 0x00, 0x00}, /* 27, -13.5dB*/ 126f1d2b4d3SLarry Finger {0x0b, 0x0a, 0x09, 0x05, 0x00, 0x00, 0x00, 0x00}, /* 28, -14.0dB*/ 127f1d2b4d3SLarry Finger {0x0a, 0x0a, 0x09, 0x05, 0x00, 0x00, 0x00, 0x00}, /* 29, -14.5dB*/ 128f1d2b4d3SLarry Finger {0x0a, 0x09, 0x08, 0x05, 0x00, 0x00, 0x00, 0x00}, /* 30, -15.0dB*/ 129f1d2b4d3SLarry Finger {0x09, 0x09, 0x08, 0x05, 0x00, 0x00, 0x00, 0x00}, /* 31, -15.5dB*/ 130f1d2b4d3SLarry Finger {0x09, 0x08, 0x07, 0x04, 0x00, 0x00, 0x00, 0x00} /* 32, -16.0dB*/ 131f1d2b4d3SLarry Finger }; 132f1d2b4d3SLarry Finger 133f1d2b4d3SLarry Finger #define CAL_SWING_OFF(_off, _dir, _size, _del) \ 134f1d2b4d3SLarry Finger do { \ 135f1d2b4d3SLarry Finger for (_off = 0; _off < _size; _off++) { \ 136f1d2b4d3SLarry Finger if (_del < thermal_threshold[_dir][_off]) { \ 137f1d2b4d3SLarry Finger if (_off != 0) \ 138f1d2b4d3SLarry Finger _off--; \ 139f1d2b4d3SLarry Finger break; \ 140f1d2b4d3SLarry Finger } \ 141f1d2b4d3SLarry Finger } \ 142f1d2b4d3SLarry Finger if (_off >= _size) \ 143f1d2b4d3SLarry Finger _off = _size - 1; \ 144f1d2b4d3SLarry Finger } while (0) 145f1d2b4d3SLarry Finger 146f1d2b4d3SLarry Finger static void rtl88e_set_iqk_matrix(struct ieee80211_hw *hw, 147f1d2b4d3SLarry Finger u8 ofdm_index, u8 rfpath, 148f1d2b4d3SLarry Finger long iqk_result_x, long iqk_result_y) 149f1d2b4d3SLarry Finger { 150f1d2b4d3SLarry Finger long ele_a = 0, ele_d, ele_c = 0, value32; 151f1d2b4d3SLarry Finger 152f1d2b4d3SLarry Finger ele_d = (ofdmswing_table[ofdm_index] & 0xFFC00000)>>22; 153f1d2b4d3SLarry Finger 154f1d2b4d3SLarry Finger if (iqk_result_x != 0) { 155f1d2b4d3SLarry Finger if ((iqk_result_x & 0x00000200) != 0) 156f1d2b4d3SLarry Finger iqk_result_x = iqk_result_x | 0xFFFFFC00; 157f1d2b4d3SLarry Finger ele_a = ((iqk_result_x * ele_d)>>8)&0x000003FF; 158f1d2b4d3SLarry Finger 159f1d2b4d3SLarry Finger if ((iqk_result_y & 0x00000200) != 0) 160f1d2b4d3SLarry Finger iqk_result_y = iqk_result_y | 0xFFFFFC00; 161f1d2b4d3SLarry Finger ele_c = ((iqk_result_y * ele_d)>>8)&0x000003FF; 162f1d2b4d3SLarry Finger 163f1d2b4d3SLarry Finger switch (rfpath) { 164f1d2b4d3SLarry Finger case RF90_PATH_A: 165f1d2b4d3SLarry Finger value32 = (ele_d << 22)|((ele_c & 0x3F)<<16) | ele_a; 166f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM0_XATXIQIMBALANCE, 167f1d2b4d3SLarry Finger MASKDWORD, value32); 168f1d2b4d3SLarry Finger value32 = (ele_c & 0x000003C0) >> 6; 169f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM0_XCTXAFE, MASKH4BITS, 170f1d2b4d3SLarry Finger value32); 171f1d2b4d3SLarry Finger value32 = ((iqk_result_x * ele_d) >> 7) & 0x01; 172f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM0_ECCATHRESHOLD, BIT(24), 173f1d2b4d3SLarry Finger value32); 174f1d2b4d3SLarry Finger break; 175f1d2b4d3SLarry Finger case RF90_PATH_B: 176f1d2b4d3SLarry Finger value32 = (ele_d << 22)|((ele_c & 0x3F)<<16) | ele_a; 177f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM0_XBTXIQIMBALANCE, MASKDWORD, 178f1d2b4d3SLarry Finger value32); 179f1d2b4d3SLarry Finger value32 = (ele_c & 0x000003C0) >> 6; 180f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM0_XDTXAFE, MASKH4BITS, value32); 181f1d2b4d3SLarry Finger value32 = ((iqk_result_x * ele_d) >> 7) & 0x01; 182f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM0_ECCATHRESHOLD, BIT(28), 183f1d2b4d3SLarry Finger value32); 184f1d2b4d3SLarry Finger break; 185f1d2b4d3SLarry Finger default: 186f1d2b4d3SLarry Finger break; 187f1d2b4d3SLarry Finger } 188f1d2b4d3SLarry Finger } else { 189f1d2b4d3SLarry Finger switch (rfpath) { 190f1d2b4d3SLarry Finger case RF90_PATH_A: 191f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM0_XATXIQIMBALANCE, 192f1d2b4d3SLarry Finger MASKDWORD, ofdmswing_table[ofdm_index]); 193f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM0_XCTXAFE, 194f1d2b4d3SLarry Finger MASKH4BITS, 0x00); 195f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM0_ECCATHRESHOLD, 196f1d2b4d3SLarry Finger BIT(24), 0x00); 197f1d2b4d3SLarry Finger break; 198f1d2b4d3SLarry Finger case RF90_PATH_B: 199f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM0_XBTXIQIMBALANCE, 200f1d2b4d3SLarry Finger MASKDWORD, ofdmswing_table[ofdm_index]); 201f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM0_XDTXAFE, 202f1d2b4d3SLarry Finger MASKH4BITS, 0x00); 203f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM0_ECCATHRESHOLD, 204f1d2b4d3SLarry Finger BIT(28), 0x00); 205f1d2b4d3SLarry Finger break; 206f1d2b4d3SLarry Finger default: 207f1d2b4d3SLarry Finger break; 208f1d2b4d3SLarry Finger } 209f1d2b4d3SLarry Finger } 210f1d2b4d3SLarry Finger } 211f1d2b4d3SLarry Finger 212f1d2b4d3SLarry Finger void rtl88e_dm_txpower_track_adjust(struct ieee80211_hw *hw, 213f1d2b4d3SLarry Finger u8 type, u8 *pdirection, u32 *poutwrite_val) 214f1d2b4d3SLarry Finger { 215f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 216f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 217f1d2b4d3SLarry Finger u8 pwr_val = 0; 218f1d2b4d3SLarry Finger u8 cck_base = rtldm->swing_idx_cck_base; 219f1d2b4d3SLarry Finger u8 cck_val = rtldm->swing_idx_cck; 220f1d2b4d3SLarry Finger u8 ofdm_base = rtldm->swing_idx_ofdm_base[0]; 221f1d2b4d3SLarry Finger u8 ofdm_val = rtlpriv->dm.swing_idx_ofdm[RF90_PATH_A]; 222f1d2b4d3SLarry Finger 223f1d2b4d3SLarry Finger if (type == 0) { 224f1d2b4d3SLarry Finger if (ofdm_val <= ofdm_base) { 225f1d2b4d3SLarry Finger *pdirection = 1; 226f1d2b4d3SLarry Finger pwr_val = ofdm_base - ofdm_val; 227f1d2b4d3SLarry Finger } else { 228f1d2b4d3SLarry Finger *pdirection = 2; 229f1d2b4d3SLarry Finger pwr_val = ofdm_base - ofdm_val; 230f1d2b4d3SLarry Finger } 231f1d2b4d3SLarry Finger } else if (type == 1) { 232f1d2b4d3SLarry Finger if (cck_val <= cck_base) { 233f1d2b4d3SLarry Finger *pdirection = 1; 234f1d2b4d3SLarry Finger pwr_val = cck_base - cck_val; 235f1d2b4d3SLarry Finger } else { 236f1d2b4d3SLarry Finger *pdirection = 2; 237f1d2b4d3SLarry Finger pwr_val = cck_val - cck_base; 238f1d2b4d3SLarry Finger } 239f1d2b4d3SLarry Finger } 240f1d2b4d3SLarry Finger 241f1d2b4d3SLarry Finger if (pwr_val >= TXPWRTRACK_MAX_IDX && (*pdirection == 1)) 242f1d2b4d3SLarry Finger pwr_val = TXPWRTRACK_MAX_IDX; 243f1d2b4d3SLarry Finger 244f1d2b4d3SLarry Finger *poutwrite_val = pwr_val | (pwr_val << 8) | (pwr_val << 16) | 245f1d2b4d3SLarry Finger (pwr_val << 24); 246f1d2b4d3SLarry Finger } 247f1d2b4d3SLarry Finger 248f1d2b4d3SLarry Finger static void dm_tx_pwr_track_set_pwr(struct ieee80211_hw *hw, 249f1d2b4d3SLarry Finger enum pwr_track_control_method method, 250f1d2b4d3SLarry Finger u8 rfpath, u8 channel_mapped_index) 251f1d2b4d3SLarry Finger { 252f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 253f1d2b4d3SLarry Finger struct rtl_phy *rtlphy = &rtlpriv->phy; 254f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 255f1d2b4d3SLarry Finger 256f1d2b4d3SLarry Finger if (method == TXAGC) { 257f1d2b4d3SLarry Finger if (rtldm->swing_flag_ofdm || 258f1d2b4d3SLarry Finger rtldm->swing_flag_cck) { 259f1d2b4d3SLarry Finger rtl88e_phy_set_txpower_level(hw, 260f1d2b4d3SLarry Finger rtlphy->current_channel); 261f1d2b4d3SLarry Finger rtldm->swing_flag_ofdm = false; 262f1d2b4d3SLarry Finger rtldm->swing_flag_cck = false; 263f1d2b4d3SLarry Finger } 264f1d2b4d3SLarry Finger } else if (method == BBSWING) { 265f1d2b4d3SLarry Finger if (!rtldm->cck_inch14) { 266f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0xa22, 267f1d2b4d3SLarry Finger cck_tbl_ch1_13[rtldm->swing_idx_cck][0]); 268f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0xa23, 269f1d2b4d3SLarry Finger cck_tbl_ch1_13[rtldm->swing_idx_cck][1]); 270f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0xa24, 271f1d2b4d3SLarry Finger cck_tbl_ch1_13[rtldm->swing_idx_cck][2]); 272f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0xa25, 273f1d2b4d3SLarry Finger cck_tbl_ch1_13[rtldm->swing_idx_cck][3]); 274f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0xa26, 275f1d2b4d3SLarry Finger cck_tbl_ch1_13[rtldm->swing_idx_cck][4]); 276f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0xa27, 277f1d2b4d3SLarry Finger cck_tbl_ch1_13[rtldm->swing_idx_cck][5]); 278f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0xa28, 279f1d2b4d3SLarry Finger cck_tbl_ch1_13[rtldm->swing_idx_cck][6]); 280f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0xa29, 281f1d2b4d3SLarry Finger cck_tbl_ch1_13[rtldm->swing_idx_cck][7]); 282f1d2b4d3SLarry Finger } else { 283f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0xa22, 284f1d2b4d3SLarry Finger cck_tbl_ch14[rtldm->swing_idx_cck][0]); 285f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0xa23, 286f1d2b4d3SLarry Finger cck_tbl_ch14[rtldm->swing_idx_cck][1]); 287f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0xa24, 288f1d2b4d3SLarry Finger cck_tbl_ch14[rtldm->swing_idx_cck][2]); 289f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0xa25, 290f1d2b4d3SLarry Finger cck_tbl_ch14[rtldm->swing_idx_cck][3]); 291f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0xa26, 292f1d2b4d3SLarry Finger cck_tbl_ch14[rtldm->swing_idx_cck][4]); 293f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0xa27, 294f1d2b4d3SLarry Finger cck_tbl_ch14[rtldm->swing_idx_cck][5]); 295f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0xa28, 296f1d2b4d3SLarry Finger cck_tbl_ch14[rtldm->swing_idx_cck][6]); 297f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0xa29, 298f1d2b4d3SLarry Finger cck_tbl_ch14[rtldm->swing_idx_cck][7]); 299f1d2b4d3SLarry Finger } 300f1d2b4d3SLarry Finger 301f1d2b4d3SLarry Finger if (rfpath == RF90_PATH_A) { 302f1d2b4d3SLarry Finger rtl88e_set_iqk_matrix(hw, rtldm->swing_idx_ofdm[rfpath], 303f1d2b4d3SLarry Finger rfpath, rtlphy->iqk_matrix 304f1d2b4d3SLarry Finger [channel_mapped_index]. 305f1d2b4d3SLarry Finger value[0][0], 306f1d2b4d3SLarry Finger rtlphy->iqk_matrix 307f1d2b4d3SLarry Finger [channel_mapped_index]. 308f1d2b4d3SLarry Finger value[0][1]); 309f1d2b4d3SLarry Finger } else if (rfpath == RF90_PATH_B) { 310f1d2b4d3SLarry Finger rtl88e_set_iqk_matrix(hw, rtldm->swing_idx_ofdm[rfpath], 311f1d2b4d3SLarry Finger rfpath, rtlphy->iqk_matrix 312f1d2b4d3SLarry Finger [channel_mapped_index]. 313f1d2b4d3SLarry Finger value[0][4], 314f1d2b4d3SLarry Finger rtlphy->iqk_matrix 315f1d2b4d3SLarry Finger [channel_mapped_index]. 316f1d2b4d3SLarry Finger value[0][5]); 317f1d2b4d3SLarry Finger } 318f1d2b4d3SLarry Finger } else { 319f1d2b4d3SLarry Finger return; 320f1d2b4d3SLarry Finger } 321f1d2b4d3SLarry Finger } 322f1d2b4d3SLarry Finger 323f1d2b4d3SLarry Finger static u8 rtl88e_dm_initial_gain_min_pwdb(struct ieee80211_hw *hw) 324f1d2b4d3SLarry Finger { 325f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 326f1d2b4d3SLarry Finger struct dig_t *dm_dig = &rtlpriv->dm_digtable; 327f1d2b4d3SLarry Finger long rssi_val_min = 0; 328f1d2b4d3SLarry Finger 329f1d2b4d3SLarry Finger if ((dm_dig->curmultista_cstate == DIG_MULTISTA_CONNECT) && 330f1d2b4d3SLarry Finger (dm_dig->cur_sta_cstate == DIG_STA_CONNECT)) { 331f1d2b4d3SLarry Finger if (rtlpriv->dm.entry_min_undec_sm_pwdb != 0) 332f1d2b4d3SLarry Finger rssi_val_min = 333f1d2b4d3SLarry Finger (rtlpriv->dm.entry_min_undec_sm_pwdb > 334f1d2b4d3SLarry Finger rtlpriv->dm.undec_sm_pwdb) ? 335f1d2b4d3SLarry Finger rtlpriv->dm.undec_sm_pwdb : 336f1d2b4d3SLarry Finger rtlpriv->dm.entry_min_undec_sm_pwdb; 337f1d2b4d3SLarry Finger else 338f1d2b4d3SLarry Finger rssi_val_min = rtlpriv->dm.undec_sm_pwdb; 339f1d2b4d3SLarry Finger } else if (dm_dig->cur_sta_cstate == DIG_STA_CONNECT || 340f1d2b4d3SLarry Finger dm_dig->cur_sta_cstate == DIG_STA_BEFORE_CONNECT) { 341f1d2b4d3SLarry Finger rssi_val_min = rtlpriv->dm.undec_sm_pwdb; 342f1d2b4d3SLarry Finger } else if (dm_dig->curmultista_cstate == 343f1d2b4d3SLarry Finger DIG_MULTISTA_CONNECT) { 344f1d2b4d3SLarry Finger rssi_val_min = rtlpriv->dm.entry_min_undec_sm_pwdb; 345f1d2b4d3SLarry Finger } 346f1d2b4d3SLarry Finger 347f1d2b4d3SLarry Finger return (u8)rssi_val_min; 348f1d2b4d3SLarry Finger } 349f1d2b4d3SLarry Finger 350f1d2b4d3SLarry Finger static void rtl88e_dm_false_alarm_counter_statistics(struct ieee80211_hw *hw) 351f1d2b4d3SLarry Finger { 352f1d2b4d3SLarry Finger u32 ret_value; 353f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 354f1d2b4d3SLarry Finger struct false_alarm_statistics *falsealm_cnt = &rtlpriv->falsealm_cnt; 355f1d2b4d3SLarry Finger 356f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM0_LSTF, BIT(31), 1); 357f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM1_LSTF, BIT(31), 1); 358f1d2b4d3SLarry Finger 359f1d2b4d3SLarry Finger ret_value = rtl_get_bbreg(hw, ROFDM0_FRAMESYNC, MASKDWORD); 360f1d2b4d3SLarry Finger falsealm_cnt->cnt_fast_fsync_fail = (ret_value&0xffff); 361f1d2b4d3SLarry Finger falsealm_cnt->cnt_sb_search_fail = ((ret_value&0xffff0000)>>16); 362f1d2b4d3SLarry Finger 363f1d2b4d3SLarry Finger ret_value = rtl_get_bbreg(hw, ROFDM_PHYCOUNTER1, MASKDWORD); 364f1d2b4d3SLarry Finger falsealm_cnt->cnt_ofdm_cca = (ret_value&0xffff); 365f1d2b4d3SLarry Finger falsealm_cnt->cnt_parity_fail = ((ret_value & 0xffff0000) >> 16); 366f1d2b4d3SLarry Finger 367f1d2b4d3SLarry Finger ret_value = rtl_get_bbreg(hw, ROFDM_PHYCOUNTER2, MASKDWORD); 368f1d2b4d3SLarry Finger falsealm_cnt->cnt_rate_illegal = (ret_value & 0xffff); 369f1d2b4d3SLarry Finger falsealm_cnt->cnt_crc8_fail = ((ret_value & 0xffff0000) >> 16); 370f1d2b4d3SLarry Finger 371f1d2b4d3SLarry Finger ret_value = rtl_get_bbreg(hw, ROFDM_PHYCOUNTER3, MASKDWORD); 372f1d2b4d3SLarry Finger falsealm_cnt->cnt_mcs_fail = (ret_value & 0xffff); 373f1d2b4d3SLarry Finger falsealm_cnt->cnt_ofdm_fail = falsealm_cnt->cnt_parity_fail + 374f1d2b4d3SLarry Finger falsealm_cnt->cnt_rate_illegal + 375f1d2b4d3SLarry Finger falsealm_cnt->cnt_crc8_fail + 376f1d2b4d3SLarry Finger falsealm_cnt->cnt_mcs_fail + 377f1d2b4d3SLarry Finger falsealm_cnt->cnt_fast_fsync_fail + 378f1d2b4d3SLarry Finger falsealm_cnt->cnt_sb_search_fail; 379f1d2b4d3SLarry Finger 380f1d2b4d3SLarry Finger ret_value = rtl_get_bbreg(hw, REG_SC_CNT, MASKDWORD); 381f1d2b4d3SLarry Finger falsealm_cnt->cnt_bw_lsc = (ret_value & 0xffff); 382f1d2b4d3SLarry Finger falsealm_cnt->cnt_bw_usc = ((ret_value & 0xffff0000) >> 16); 383f1d2b4d3SLarry Finger 384f1d2b4d3SLarry Finger rtl_set_bbreg(hw, RCCK0_FALSEALARMREPORT, BIT(12), 1); 385f1d2b4d3SLarry Finger rtl_set_bbreg(hw, RCCK0_FALSEALARMREPORT, BIT(14), 1); 386f1d2b4d3SLarry Finger 387f1d2b4d3SLarry Finger ret_value = rtl_get_bbreg(hw, RCCK0_FACOUNTERLOWER, MASKBYTE0); 388f1d2b4d3SLarry Finger falsealm_cnt->cnt_cck_fail = ret_value; 389f1d2b4d3SLarry Finger 390f1d2b4d3SLarry Finger ret_value = rtl_get_bbreg(hw, RCCK0_FACOUNTERUPPER, MASKBYTE3); 391f1d2b4d3SLarry Finger falsealm_cnt->cnt_cck_fail += (ret_value & 0xff) << 8; 392f1d2b4d3SLarry Finger 393f1d2b4d3SLarry Finger ret_value = rtl_get_bbreg(hw, RCCK0_CCA_CNT, MASKDWORD); 394f1d2b4d3SLarry Finger falsealm_cnt->cnt_cck_cca = ((ret_value & 0xff) << 8) | 395f1d2b4d3SLarry Finger ((ret_value&0xFF00)>>8); 396f1d2b4d3SLarry Finger 397f1d2b4d3SLarry Finger falsealm_cnt->cnt_all = (falsealm_cnt->cnt_fast_fsync_fail + 398f1d2b4d3SLarry Finger falsealm_cnt->cnt_sb_search_fail + 399f1d2b4d3SLarry Finger falsealm_cnt->cnt_parity_fail + 400f1d2b4d3SLarry Finger falsealm_cnt->cnt_rate_illegal + 401f1d2b4d3SLarry Finger falsealm_cnt->cnt_crc8_fail + 402f1d2b4d3SLarry Finger falsealm_cnt->cnt_mcs_fail + 403f1d2b4d3SLarry Finger falsealm_cnt->cnt_cck_fail); 404f1d2b4d3SLarry Finger falsealm_cnt->cnt_cca_all = falsealm_cnt->cnt_ofdm_cca + 405f1d2b4d3SLarry Finger falsealm_cnt->cnt_cck_cca; 406f1d2b4d3SLarry Finger 407f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM0_TRSWISOLATION, BIT(31), 1); 408f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM0_TRSWISOLATION, BIT(31), 0); 409f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM1_LSTF, BIT(27), 1); 410f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM1_LSTF, BIT(27), 0); 411f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM0_LSTF, BIT(31), 0); 412f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM1_LSTF, BIT(31), 0); 413f1d2b4d3SLarry Finger rtl_set_bbreg(hw, RCCK0_FALSEALARMREPORT, BIT(13)|BIT(12), 0); 414f1d2b4d3SLarry Finger rtl_set_bbreg(hw, RCCK0_FALSEALARMREPORT, BIT(13)|BIT(12), 2); 415f1d2b4d3SLarry Finger rtl_set_bbreg(hw, RCCK0_FALSEALARMREPORT, BIT(15)|BIT(14), 0); 416f1d2b4d3SLarry Finger rtl_set_bbreg(hw, RCCK0_FALSEALARMREPORT, BIT(15)|BIT(14), 2); 417f1d2b4d3SLarry Finger 418f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_DIG, DBG_TRACE, 419f1d2b4d3SLarry Finger "cnt_parity_fail = %d, cnt_rate_illegal = %d, cnt_crc8_fail = %d, cnt_mcs_fail = %d\n", 420f1d2b4d3SLarry Finger falsealm_cnt->cnt_parity_fail, 421f1d2b4d3SLarry Finger falsealm_cnt->cnt_rate_illegal, 422f1d2b4d3SLarry Finger falsealm_cnt->cnt_crc8_fail, falsealm_cnt->cnt_mcs_fail); 423f1d2b4d3SLarry Finger 424f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_DIG, DBG_TRACE, 425f1d2b4d3SLarry Finger "cnt_ofdm_fail = %x, cnt_cck_fail = %x, cnt_all = %x\n", 426f1d2b4d3SLarry Finger falsealm_cnt->cnt_ofdm_fail, 427f1d2b4d3SLarry Finger falsealm_cnt->cnt_cck_fail, falsealm_cnt->cnt_all); 428f1d2b4d3SLarry Finger } 429f1d2b4d3SLarry Finger 430f1d2b4d3SLarry Finger static void rtl88e_dm_cck_packet_detection_thresh(struct ieee80211_hw *hw) 431f1d2b4d3SLarry Finger { 432f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 433f1d2b4d3SLarry Finger struct dig_t *dm_dig = &rtlpriv->dm_digtable; 434f1d2b4d3SLarry Finger u8 cur_cck_cca_thresh; 435f1d2b4d3SLarry Finger 436f1d2b4d3SLarry Finger if (dm_dig->cur_sta_cstate == DIG_STA_CONNECT) { 437f1d2b4d3SLarry Finger dm_dig->rssi_val_min = rtl88e_dm_initial_gain_min_pwdb(hw); 438f1d2b4d3SLarry Finger if (dm_dig->rssi_val_min > 25) { 439f1d2b4d3SLarry Finger cur_cck_cca_thresh = 0xcd; 440f1d2b4d3SLarry Finger } else if ((dm_dig->rssi_val_min <= 25) && 441f1d2b4d3SLarry Finger (dm_dig->rssi_val_min > 10)) { 442f1d2b4d3SLarry Finger cur_cck_cca_thresh = 0x83; 443f1d2b4d3SLarry Finger } else { 444f1d2b4d3SLarry Finger if (rtlpriv->falsealm_cnt.cnt_cck_fail > 1000) 445f1d2b4d3SLarry Finger cur_cck_cca_thresh = 0x83; 446f1d2b4d3SLarry Finger else 447f1d2b4d3SLarry Finger cur_cck_cca_thresh = 0x40; 448f1d2b4d3SLarry Finger } 449f1d2b4d3SLarry Finger 450f1d2b4d3SLarry Finger } else { 451f1d2b4d3SLarry Finger if (rtlpriv->falsealm_cnt.cnt_cck_fail > 1000) 452f1d2b4d3SLarry Finger cur_cck_cca_thresh = 0x83; 453f1d2b4d3SLarry Finger else 454f1d2b4d3SLarry Finger cur_cck_cca_thresh = 0x40; 455f1d2b4d3SLarry Finger } 456f1d2b4d3SLarry Finger 457f1d2b4d3SLarry Finger if (dm_dig->cur_cck_cca_thres != cur_cck_cca_thresh) 458f1d2b4d3SLarry Finger rtl_set_bbreg(hw, RCCK0_CCA, MASKBYTE2, cur_cck_cca_thresh); 459f1d2b4d3SLarry Finger 460f1d2b4d3SLarry Finger dm_dig->cur_cck_cca_thres = cur_cck_cca_thresh; 461f1d2b4d3SLarry Finger dm_dig->pre_cck_cca_thres = dm_dig->cur_cck_cca_thres; 462f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_DIG, DBG_TRACE, 463f1d2b4d3SLarry Finger "CCK cca thresh hold =%x\n", dm_dig->cur_cck_cca_thres); 464f1d2b4d3SLarry Finger } 465f1d2b4d3SLarry Finger 466f1d2b4d3SLarry Finger static void rtl88e_dm_dig(struct ieee80211_hw *hw) 467f1d2b4d3SLarry Finger { 468f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 469f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 470f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 471f1d2b4d3SLarry Finger struct dig_t *dm_dig = &rtlpriv->dm_digtable; 472f1d2b4d3SLarry Finger u8 dig_dynamic_min, dig_maxofmin; 473f1d2b4d3SLarry Finger bool bfirstconnect; 474f1d2b4d3SLarry Finger u8 dm_dig_max, dm_dig_min; 475f1d2b4d3SLarry Finger u8 current_igi = dm_dig->cur_igvalue; 476f1d2b4d3SLarry Finger 477f1d2b4d3SLarry Finger if (rtlpriv->dm.dm_initialgain_enable == false) 478f1d2b4d3SLarry Finger return; 479f1d2b4d3SLarry Finger if (dm_dig->dig_enable_flag == false) 480f1d2b4d3SLarry Finger return; 481f1d2b4d3SLarry Finger if (mac->act_scanning == true) 482f1d2b4d3SLarry Finger return; 483f1d2b4d3SLarry Finger 484f1d2b4d3SLarry Finger if (mac->link_state >= MAC80211_LINKED) 485f1d2b4d3SLarry Finger dm_dig->cur_sta_cstate = DIG_STA_CONNECT; 486f1d2b4d3SLarry Finger else 487f1d2b4d3SLarry Finger dm_dig->cur_sta_cstate = DIG_STA_DISCONNECT; 488f1d2b4d3SLarry Finger if (rtlpriv->mac80211.opmode == NL80211_IFTYPE_AP || 489f1d2b4d3SLarry Finger rtlpriv->mac80211.opmode == NL80211_IFTYPE_ADHOC) 490f1d2b4d3SLarry Finger dm_dig->cur_sta_cstate = DIG_STA_DISCONNECT; 491f1d2b4d3SLarry Finger 492f1d2b4d3SLarry Finger dm_dig_max = DM_DIG_MAX; 493f1d2b4d3SLarry Finger dm_dig_min = DM_DIG_MIN; 494f1d2b4d3SLarry Finger dig_maxofmin = DM_DIG_MAX_AP; 495f1d2b4d3SLarry Finger dig_dynamic_min = dm_dig->dig_min_0; 496f1d2b4d3SLarry Finger bfirstconnect = ((mac->link_state >= MAC80211_LINKED) ? true : false) && 497f1d2b4d3SLarry Finger !dm_dig->media_connect_0; 498f1d2b4d3SLarry Finger 499f1d2b4d3SLarry Finger dm_dig->rssi_val_min = 500f1d2b4d3SLarry Finger rtl88e_dm_initial_gain_min_pwdb(hw); 501f1d2b4d3SLarry Finger 502f1d2b4d3SLarry Finger if (mac->link_state >= MAC80211_LINKED) { 503f1d2b4d3SLarry Finger if ((dm_dig->rssi_val_min + 20) > dm_dig_max) 504f1d2b4d3SLarry Finger dm_dig->rx_gain_max = dm_dig_max; 505f1d2b4d3SLarry Finger else if ((dm_dig->rssi_val_min + 20) < dm_dig_min) 506f1d2b4d3SLarry Finger dm_dig->rx_gain_max = dm_dig_min; 507f1d2b4d3SLarry Finger else 508f1d2b4d3SLarry Finger dm_dig->rx_gain_max = dm_dig->rssi_val_min + 20; 509f1d2b4d3SLarry Finger 510f1d2b4d3SLarry Finger if (rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) { 511f1d2b4d3SLarry Finger dig_dynamic_min = dm_dig->antdiv_rssi_max; 512f1d2b4d3SLarry Finger } else { 513f1d2b4d3SLarry Finger if (dm_dig->rssi_val_min < dm_dig_min) 514f1d2b4d3SLarry Finger dig_dynamic_min = dm_dig_min; 515f1d2b4d3SLarry Finger else if (dm_dig->rssi_val_min < dig_maxofmin) 516f1d2b4d3SLarry Finger dig_dynamic_min = dig_maxofmin; 517f1d2b4d3SLarry Finger else 518f1d2b4d3SLarry Finger dig_dynamic_min = dm_dig->rssi_val_min; 519f1d2b4d3SLarry Finger } 520f1d2b4d3SLarry Finger } else { 521f1d2b4d3SLarry Finger dm_dig->rx_gain_max = dm_dig_max; 522f1d2b4d3SLarry Finger dig_dynamic_min = dm_dig_min; 523f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_DIG, DBG_LOUD, "no link\n"); 524f1d2b4d3SLarry Finger } 525f1d2b4d3SLarry Finger 526f1d2b4d3SLarry Finger if (rtlpriv->falsealm_cnt.cnt_all > 10000) { 527f1d2b4d3SLarry Finger dm_dig->large_fa_hit++; 528f1d2b4d3SLarry Finger if (dm_dig->forbidden_igi < current_igi) { 529f1d2b4d3SLarry Finger dm_dig->forbidden_igi = current_igi; 530f1d2b4d3SLarry Finger dm_dig->large_fa_hit = 1; 531f1d2b4d3SLarry Finger } 532f1d2b4d3SLarry Finger 533f1d2b4d3SLarry Finger if (dm_dig->large_fa_hit >= 3) { 534f1d2b4d3SLarry Finger if ((dm_dig->forbidden_igi + 1) > 535f1d2b4d3SLarry Finger dm_dig->rx_gain_max) 536f1d2b4d3SLarry Finger dm_dig->rx_gain_min = 537f1d2b4d3SLarry Finger dm_dig->rx_gain_max; 538f1d2b4d3SLarry Finger else 539f1d2b4d3SLarry Finger dm_dig->rx_gain_min = 540f1d2b4d3SLarry Finger dm_dig->forbidden_igi + 1; 541f1d2b4d3SLarry Finger dm_dig->recover_cnt = 3600; 542f1d2b4d3SLarry Finger } 543f1d2b4d3SLarry Finger } else { 544f1d2b4d3SLarry Finger if (dm_dig->recover_cnt != 0) { 545f1d2b4d3SLarry Finger dm_dig->recover_cnt--; 546f1d2b4d3SLarry Finger } else { 547f1d2b4d3SLarry Finger if (dm_dig->large_fa_hit == 0) { 548f1d2b4d3SLarry Finger if ((dm_dig->forbidden_igi - 1) < 549f1d2b4d3SLarry Finger dig_dynamic_min) { 550f1d2b4d3SLarry Finger dm_dig->forbidden_igi = dig_dynamic_min; 551f1d2b4d3SLarry Finger dm_dig->rx_gain_min = dig_dynamic_min; 552f1d2b4d3SLarry Finger } else { 553f1d2b4d3SLarry Finger dm_dig->forbidden_igi--; 554f1d2b4d3SLarry Finger dm_dig->rx_gain_min = 555f1d2b4d3SLarry Finger dm_dig->forbidden_igi + 1; 556f1d2b4d3SLarry Finger } 557f1d2b4d3SLarry Finger } else if (dm_dig->large_fa_hit == 3) { 558f1d2b4d3SLarry Finger dm_dig->large_fa_hit = 0; 559f1d2b4d3SLarry Finger } 560f1d2b4d3SLarry Finger } 561f1d2b4d3SLarry Finger } 562f1d2b4d3SLarry Finger 563f1d2b4d3SLarry Finger if (dm_dig->cur_sta_cstate == DIG_STA_CONNECT) { 564f1d2b4d3SLarry Finger if (bfirstconnect) { 565f1d2b4d3SLarry Finger current_igi = dm_dig->rssi_val_min; 566f1d2b4d3SLarry Finger } else { 567f1d2b4d3SLarry Finger if (rtlpriv->falsealm_cnt.cnt_all > DM_DIG_FA_TH2) 568f1d2b4d3SLarry Finger current_igi += 2; 569f1d2b4d3SLarry Finger else if (rtlpriv->falsealm_cnt.cnt_all > DM_DIG_FA_TH1) 570f1d2b4d3SLarry Finger current_igi++; 571f1d2b4d3SLarry Finger else if (rtlpriv->falsealm_cnt.cnt_all < DM_DIG_FA_TH0) 572f1d2b4d3SLarry Finger current_igi--; 573f1d2b4d3SLarry Finger } 574f1d2b4d3SLarry Finger } else { 575f1d2b4d3SLarry Finger if (rtlpriv->falsealm_cnt.cnt_all > 10000) 576f1d2b4d3SLarry Finger current_igi += 2; 577f1d2b4d3SLarry Finger else if (rtlpriv->falsealm_cnt.cnt_all > 8000) 578f1d2b4d3SLarry Finger current_igi++; 579f1d2b4d3SLarry Finger else if (rtlpriv->falsealm_cnt.cnt_all < 500) 580f1d2b4d3SLarry Finger current_igi--; 581f1d2b4d3SLarry Finger } 582f1d2b4d3SLarry Finger 583f1d2b4d3SLarry Finger if (current_igi > DM_DIG_FA_UPPER) 584f1d2b4d3SLarry Finger current_igi = DM_DIG_FA_UPPER; 585f1d2b4d3SLarry Finger else if (current_igi < DM_DIG_FA_LOWER) 586f1d2b4d3SLarry Finger current_igi = DM_DIG_FA_LOWER; 587f1d2b4d3SLarry Finger 588f1d2b4d3SLarry Finger if (rtlpriv->falsealm_cnt.cnt_all > 10000) 589f1d2b4d3SLarry Finger current_igi = DM_DIG_FA_UPPER; 590f1d2b4d3SLarry Finger 591f1d2b4d3SLarry Finger dm_dig->cur_igvalue = current_igi; 592f1d2b4d3SLarry Finger rtl88e_dm_write_dig(hw); 593f1d2b4d3SLarry Finger dm_dig->media_connect_0 = 594f1d2b4d3SLarry Finger ((mac->link_state >= MAC80211_LINKED) ? true : false); 595f1d2b4d3SLarry Finger dm_dig->dig_min_0 = dig_dynamic_min; 596f1d2b4d3SLarry Finger 597f1d2b4d3SLarry Finger rtl88e_dm_cck_packet_detection_thresh(hw); 598f1d2b4d3SLarry Finger } 599f1d2b4d3SLarry Finger 600f1d2b4d3SLarry Finger static void rtl88e_dm_init_dynamic_txpower(struct ieee80211_hw *hw) 601f1d2b4d3SLarry Finger { 602f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 603f1d2b4d3SLarry Finger 604f1d2b4d3SLarry Finger rtlpriv->dm.dynamic_txpower_enable = false; 605f1d2b4d3SLarry Finger 606f1d2b4d3SLarry Finger rtlpriv->dm.last_dtp_lvl = TXHIGHPWRLEVEL_NORMAL; 607f1d2b4d3SLarry Finger rtlpriv->dm.dynamic_txhighpower_lvl = TXHIGHPWRLEVEL_NORMAL; 608f1d2b4d3SLarry Finger } 609f1d2b4d3SLarry Finger 610f1d2b4d3SLarry Finger static void rtl92c_dm_dynamic_txpower(struct ieee80211_hw *hw) 611f1d2b4d3SLarry Finger { 612f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 613f1d2b4d3SLarry Finger struct rtl_phy *rtlphy = &rtlpriv->phy; 614f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 615f1d2b4d3SLarry Finger long undec_sm_pwdb; 616f1d2b4d3SLarry Finger 617f1d2b4d3SLarry Finger if (!rtlpriv->dm.dynamic_txpower_enable) 618f1d2b4d3SLarry Finger return; 619f1d2b4d3SLarry Finger 620f1d2b4d3SLarry Finger if (rtlpriv->dm.dm_flag & HAL_DM_HIPWR_DISABLE) { 621f1d2b4d3SLarry Finger rtlpriv->dm.dynamic_txhighpower_lvl = TXHIGHPWRLEVEL_NORMAL; 622f1d2b4d3SLarry Finger return; 623f1d2b4d3SLarry Finger } 624f1d2b4d3SLarry Finger 625f1d2b4d3SLarry Finger if ((mac->link_state < MAC80211_LINKED) && 626f1d2b4d3SLarry Finger (rtlpriv->dm.entry_min_undec_sm_pwdb == 0)) { 627f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER, DBG_TRACE, 628f1d2b4d3SLarry Finger "Not connected to any\n"); 629f1d2b4d3SLarry Finger 630f1d2b4d3SLarry Finger rtlpriv->dm.dynamic_txhighpower_lvl = TXHIGHPWRLEVEL_NORMAL; 631f1d2b4d3SLarry Finger 632f1d2b4d3SLarry Finger rtlpriv->dm.last_dtp_lvl = TXHIGHPWRLEVEL_NORMAL; 633f1d2b4d3SLarry Finger return; 634f1d2b4d3SLarry Finger } 635f1d2b4d3SLarry Finger 636f1d2b4d3SLarry Finger if (mac->link_state >= MAC80211_LINKED) { 637f1d2b4d3SLarry Finger if (mac->opmode == NL80211_IFTYPE_ADHOC) { 638f1d2b4d3SLarry Finger undec_sm_pwdb = 639f1d2b4d3SLarry Finger rtlpriv->dm.entry_min_undec_sm_pwdb; 640f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 641f1d2b4d3SLarry Finger "AP Client PWDB = 0x%lx\n", 642f1d2b4d3SLarry Finger undec_sm_pwdb); 643f1d2b4d3SLarry Finger } else { 644f1d2b4d3SLarry Finger undec_sm_pwdb = 645f1d2b4d3SLarry Finger rtlpriv->dm.undec_sm_pwdb; 646f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 647f1d2b4d3SLarry Finger "STA Default Port PWDB = 0x%lx\n", 648f1d2b4d3SLarry Finger undec_sm_pwdb); 649f1d2b4d3SLarry Finger } 650f1d2b4d3SLarry Finger } else { 651f1d2b4d3SLarry Finger undec_sm_pwdb = 652f1d2b4d3SLarry Finger rtlpriv->dm.entry_min_undec_sm_pwdb; 653f1d2b4d3SLarry Finger 654f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 655f1d2b4d3SLarry Finger "AP Ext Port PWDB = 0x%lx\n", 656f1d2b4d3SLarry Finger undec_sm_pwdb); 657f1d2b4d3SLarry Finger } 658f1d2b4d3SLarry Finger 659f1d2b4d3SLarry Finger if (undec_sm_pwdb >= TX_POWER_NEAR_FIELD_THRESH_LVL2) { 660f1d2b4d3SLarry Finger rtlpriv->dm.dynamic_txhighpower_lvl = TXHIGHPWRLEVEL_LEVEL1; 661f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 662f1d2b4d3SLarry Finger "TXHIGHPWRLEVEL_LEVEL1 (TxPwr = 0x0)\n"); 663f1d2b4d3SLarry Finger } else if ((undec_sm_pwdb < 664f1d2b4d3SLarry Finger (TX_POWER_NEAR_FIELD_THRESH_LVL2 - 3)) && 665f1d2b4d3SLarry Finger (undec_sm_pwdb >= 666f1d2b4d3SLarry Finger TX_POWER_NEAR_FIELD_THRESH_LVL1)) { 667f1d2b4d3SLarry Finger rtlpriv->dm.dynamic_txhighpower_lvl = TXHIGHPWRLEVEL_LEVEL1; 668f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 669f1d2b4d3SLarry Finger "TXHIGHPWRLEVEL_LEVEL1 (TxPwr = 0x10)\n"); 670f1d2b4d3SLarry Finger } else if (undec_sm_pwdb < 671f1d2b4d3SLarry Finger (TX_POWER_NEAR_FIELD_THRESH_LVL1 - 5)) { 672f1d2b4d3SLarry Finger rtlpriv->dm.dynamic_txhighpower_lvl = TXHIGHPWRLEVEL_NORMAL; 673f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 674f1d2b4d3SLarry Finger "TXHIGHPWRLEVEL_NORMAL\n"); 675f1d2b4d3SLarry Finger } 676f1d2b4d3SLarry Finger 677f1d2b4d3SLarry Finger if ((rtlpriv->dm.dynamic_txhighpower_lvl != 678f1d2b4d3SLarry Finger rtlpriv->dm.last_dtp_lvl)) { 679f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 680f1d2b4d3SLarry Finger "PHY_SetTxPowerLevel8192S() Channel = %d\n", 681f1d2b4d3SLarry Finger rtlphy->current_channel); 682f1d2b4d3SLarry Finger rtl88e_phy_set_txpower_level(hw, rtlphy->current_channel); 683f1d2b4d3SLarry Finger } 684f1d2b4d3SLarry Finger 685f1d2b4d3SLarry Finger rtlpriv->dm.last_dtp_lvl = rtlpriv->dm.dynamic_txhighpower_lvl; 686f1d2b4d3SLarry Finger } 687f1d2b4d3SLarry Finger 688f1d2b4d3SLarry Finger void rtl88e_dm_write_dig(struct ieee80211_hw *hw) 689f1d2b4d3SLarry Finger { 690f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 691f1d2b4d3SLarry Finger struct dig_t *dm_dig = &rtlpriv->dm_digtable; 692f1d2b4d3SLarry Finger 693f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_DIG, DBG_LOUD, 694f1d2b4d3SLarry Finger "cur_igvalue = 0x%x, pre_igvalue = 0x%x, backoff_val = %d\n", 695f1d2b4d3SLarry Finger dm_dig->cur_igvalue, dm_dig->pre_igvalue, 696f1d2b4d3SLarry Finger dm_dig->back_val); 697f1d2b4d3SLarry Finger 698f1d2b4d3SLarry Finger if (dm_dig->cur_igvalue > 0x3f) 699f1d2b4d3SLarry Finger dm_dig->cur_igvalue = 0x3f; 700f1d2b4d3SLarry Finger if (dm_dig->pre_igvalue != dm_dig->cur_igvalue) { 701f1d2b4d3SLarry Finger rtl_set_bbreg(hw, ROFDM0_XAAGCCORE1, 0x7f, 702f1d2b4d3SLarry Finger dm_dig->cur_igvalue); 703f1d2b4d3SLarry Finger 704f1d2b4d3SLarry Finger dm_dig->pre_igvalue = dm_dig->cur_igvalue; 705f1d2b4d3SLarry Finger } 706f1d2b4d3SLarry Finger } 707f1d2b4d3SLarry Finger 708f1d2b4d3SLarry Finger static void rtl88e_dm_pwdb_monitor(struct ieee80211_hw *hw) 709f1d2b4d3SLarry Finger { 710f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 711f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 712f1d2b4d3SLarry Finger struct rtl_sta_info *drv_priv; 713f1d2b4d3SLarry Finger static u64 last_record_txok_cnt; 714f1d2b4d3SLarry Finger static u64 last_record_rxok_cnt; 715f1d2b4d3SLarry Finger long tmp_entry_max_pwdb = 0, tmp_entry_min_pwdb = 0xff; 716f1d2b4d3SLarry Finger 717f1d2b4d3SLarry Finger if (rtlhal->oem_id == RT_CID_819X_HP) { 718f1d2b4d3SLarry Finger u64 cur_txok_cnt = 0; 719f1d2b4d3SLarry Finger u64 cur_rxok_cnt = 0; 720f1d2b4d3SLarry Finger cur_txok_cnt = rtlpriv->stats.txbytesunicast - 721f1d2b4d3SLarry Finger last_record_txok_cnt; 722f1d2b4d3SLarry Finger cur_rxok_cnt = rtlpriv->stats.rxbytesunicast - 723f1d2b4d3SLarry Finger last_record_rxok_cnt; 724f1d2b4d3SLarry Finger last_record_txok_cnt = cur_txok_cnt; 725f1d2b4d3SLarry Finger last_record_rxok_cnt = cur_rxok_cnt; 726f1d2b4d3SLarry Finger 727f1d2b4d3SLarry Finger if (cur_rxok_cnt > (cur_txok_cnt * 6)) 728f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_ARFR0, 0x8f015); 729f1d2b4d3SLarry Finger else 730f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, REG_ARFR0, 0xff015); 731f1d2b4d3SLarry Finger } 732f1d2b4d3SLarry Finger 733f1d2b4d3SLarry Finger /* AP & ADHOC & MESH */ 734f1d2b4d3SLarry Finger spin_lock_bh(&rtlpriv->locks.entry_list_lock); 735f1d2b4d3SLarry Finger list_for_each_entry(drv_priv, &rtlpriv->entry_list, list) { 736f1d2b4d3SLarry Finger if (drv_priv->rssi_stat.undec_sm_pwdb < 737f1d2b4d3SLarry Finger tmp_entry_min_pwdb) 738f1d2b4d3SLarry Finger tmp_entry_min_pwdb = drv_priv->rssi_stat.undec_sm_pwdb; 739f1d2b4d3SLarry Finger if (drv_priv->rssi_stat.undec_sm_pwdb > 740f1d2b4d3SLarry Finger tmp_entry_max_pwdb) 741f1d2b4d3SLarry Finger tmp_entry_max_pwdb = drv_priv->rssi_stat.undec_sm_pwdb; 742f1d2b4d3SLarry Finger } 743f1d2b4d3SLarry Finger spin_unlock_bh(&rtlpriv->locks.entry_list_lock); 744f1d2b4d3SLarry Finger 745f1d2b4d3SLarry Finger /* If associated entry is found */ 746f1d2b4d3SLarry Finger if (tmp_entry_max_pwdb != 0) { 747f1d2b4d3SLarry Finger rtlpriv->dm.entry_max_undec_sm_pwdb = tmp_entry_max_pwdb; 748f1d2b4d3SLarry Finger RTPRINT(rtlpriv, FDM, DM_PWDB, "EntryMaxPWDB = 0x%lx(%ld)\n", 749f1d2b4d3SLarry Finger tmp_entry_max_pwdb, tmp_entry_max_pwdb); 750f1d2b4d3SLarry Finger } else { 751f1d2b4d3SLarry Finger rtlpriv->dm.entry_max_undec_sm_pwdb = 0; 752f1d2b4d3SLarry Finger } 753f1d2b4d3SLarry Finger /* If associated entry is found */ 754f1d2b4d3SLarry Finger if (tmp_entry_min_pwdb != 0xff) { 755f1d2b4d3SLarry Finger rtlpriv->dm.entry_min_undec_sm_pwdb = tmp_entry_min_pwdb; 756f1d2b4d3SLarry Finger RTPRINT(rtlpriv, FDM, DM_PWDB, "EntryMinPWDB = 0x%lx(%ld)\n", 757f1d2b4d3SLarry Finger tmp_entry_min_pwdb, tmp_entry_min_pwdb); 758f1d2b4d3SLarry Finger } else { 759f1d2b4d3SLarry Finger rtlpriv->dm.entry_min_undec_sm_pwdb = 0; 760f1d2b4d3SLarry Finger } 761f1d2b4d3SLarry Finger /* Indicate Rx signal strength to FW. */ 762f1d2b4d3SLarry Finger if (rtlpriv->dm.useramask) { 763f1d2b4d3SLarry Finger u8 h2c_parameter[3] = { 0 }; 764f1d2b4d3SLarry Finger 765f1d2b4d3SLarry Finger h2c_parameter[2] = (u8)(rtlpriv->dm.undec_sm_pwdb & 0xFF); 766f1d2b4d3SLarry Finger h2c_parameter[0] = 0x20; 767f1d2b4d3SLarry Finger } else { 768f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0x4fe, rtlpriv->dm.undec_sm_pwdb); 769f1d2b4d3SLarry Finger } 770f1d2b4d3SLarry Finger } 771f1d2b4d3SLarry Finger 772f1d2b4d3SLarry Finger void rtl88e_dm_init_edca_turbo(struct ieee80211_hw *hw) 773f1d2b4d3SLarry Finger { 774f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 775f1d2b4d3SLarry Finger 776f1d2b4d3SLarry Finger rtlpriv->dm.current_turbo_edca = false; 777f1d2b4d3SLarry Finger rtlpriv->dm.is_any_nonbepkts = false; 778f1d2b4d3SLarry Finger rtlpriv->dm.is_cur_rdlstate = false; 779f1d2b4d3SLarry Finger } 780f1d2b4d3SLarry Finger 781f1d2b4d3SLarry Finger static void rtl88e_dm_check_edca_turbo(struct ieee80211_hw *hw) 782f1d2b4d3SLarry Finger { 783f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 784f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 785f1d2b4d3SLarry Finger static u64 last_txok_cnt; 786f1d2b4d3SLarry Finger static u64 last_rxok_cnt; 787f1d2b4d3SLarry Finger static u32 last_bt_edca_ul; 788f1d2b4d3SLarry Finger static u32 last_bt_edca_dl; 789f1d2b4d3SLarry Finger u64 cur_txok_cnt = 0; 790f1d2b4d3SLarry Finger u64 cur_rxok_cnt = 0; 791f1d2b4d3SLarry Finger u32 edca_be_ul = 0x5ea42b; 792f1d2b4d3SLarry Finger u32 edca_be_dl = 0x5ea42b; 793f1d2b4d3SLarry Finger bool bt_change_edca = false; 794f1d2b4d3SLarry Finger 795f1d2b4d3SLarry Finger if ((last_bt_edca_ul != rtlpriv->btcoexist.bt_edca_ul) || 796f1d2b4d3SLarry Finger (last_bt_edca_dl != rtlpriv->btcoexist.bt_edca_dl)) { 797f1d2b4d3SLarry Finger rtlpriv->dm.current_turbo_edca = false; 798f1d2b4d3SLarry Finger last_bt_edca_ul = rtlpriv->btcoexist.bt_edca_ul; 799f1d2b4d3SLarry Finger last_bt_edca_dl = rtlpriv->btcoexist.bt_edca_dl; 800f1d2b4d3SLarry Finger } 801f1d2b4d3SLarry Finger 802f1d2b4d3SLarry Finger if (rtlpriv->btcoexist.bt_edca_ul != 0) { 803f1d2b4d3SLarry Finger edca_be_ul = rtlpriv->btcoexist.bt_edca_ul; 804f1d2b4d3SLarry Finger bt_change_edca = true; 805f1d2b4d3SLarry Finger } 806f1d2b4d3SLarry Finger 807f1d2b4d3SLarry Finger if (rtlpriv->btcoexist.bt_edca_dl != 0) { 808f1d2b4d3SLarry Finger edca_be_ul = rtlpriv->btcoexist.bt_edca_dl; 809f1d2b4d3SLarry Finger bt_change_edca = true; 810f1d2b4d3SLarry Finger } 811f1d2b4d3SLarry Finger 812f1d2b4d3SLarry Finger if (mac->link_state != MAC80211_LINKED) { 813f1d2b4d3SLarry Finger rtlpriv->dm.current_turbo_edca = false; 814f1d2b4d3SLarry Finger return; 815f1d2b4d3SLarry Finger } 816f1d2b4d3SLarry Finger if ((bt_change_edca) || 817f1d2b4d3SLarry Finger ((!rtlpriv->dm.is_any_nonbepkts) && 818f1d2b4d3SLarry Finger (!rtlpriv->dm.disable_framebursting))) { 819f1d2b4d3SLarry Finger 820f1d2b4d3SLarry Finger cur_txok_cnt = rtlpriv->stats.txbytesunicast - last_txok_cnt; 821f1d2b4d3SLarry Finger cur_rxok_cnt = rtlpriv->stats.rxbytesunicast - last_rxok_cnt; 822f1d2b4d3SLarry Finger 823f1d2b4d3SLarry Finger if (cur_rxok_cnt > 4 * cur_txok_cnt) { 824f1d2b4d3SLarry Finger if (!rtlpriv->dm.is_cur_rdlstate || 825f1d2b4d3SLarry Finger !rtlpriv->dm.current_turbo_edca) { 826f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, 827f1d2b4d3SLarry Finger REG_EDCA_BE_PARAM, 828f1d2b4d3SLarry Finger edca_be_dl); 829f1d2b4d3SLarry Finger rtlpriv->dm.is_cur_rdlstate = true; 830f1d2b4d3SLarry Finger } 831f1d2b4d3SLarry Finger } else { 832f1d2b4d3SLarry Finger if (rtlpriv->dm.is_cur_rdlstate || 833f1d2b4d3SLarry Finger !rtlpriv->dm.current_turbo_edca) { 834f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, 835f1d2b4d3SLarry Finger REG_EDCA_BE_PARAM, 836f1d2b4d3SLarry Finger edca_be_ul); 837f1d2b4d3SLarry Finger rtlpriv->dm.is_cur_rdlstate = false; 838f1d2b4d3SLarry Finger } 839f1d2b4d3SLarry Finger } 840f1d2b4d3SLarry Finger rtlpriv->dm.current_turbo_edca = true; 841f1d2b4d3SLarry Finger } else { 842f1d2b4d3SLarry Finger if (rtlpriv->dm.current_turbo_edca) { 843f1d2b4d3SLarry Finger u8 tmp = AC0_BE; 844f1d2b4d3SLarry Finger 845f1d2b4d3SLarry Finger rtlpriv->cfg->ops->set_hw_reg(hw, 846f1d2b4d3SLarry Finger HW_VAR_AC_PARAM, 847f1d2b4d3SLarry Finger &tmp); 848f1d2b4d3SLarry Finger rtlpriv->dm.current_turbo_edca = false; 849f1d2b4d3SLarry Finger } 850f1d2b4d3SLarry Finger } 851f1d2b4d3SLarry Finger 852f1d2b4d3SLarry Finger rtlpriv->dm.is_any_nonbepkts = false; 853f1d2b4d3SLarry Finger last_txok_cnt = rtlpriv->stats.txbytesunicast; 854f1d2b4d3SLarry Finger last_rxok_cnt = rtlpriv->stats.rxbytesunicast; 855f1d2b4d3SLarry Finger } 856f1d2b4d3SLarry Finger 857f1d2b4d3SLarry Finger static void dm_txpower_track_cb_therm(struct ieee80211_hw *hw) 858f1d2b4d3SLarry Finger { 859f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 860f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 861f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 862f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 863f1d2b4d3SLarry Finger u8 thermalvalue = 0, delta, delta_lck, delta_iqk, offset; 864f1d2b4d3SLarry Finger u8 thermalvalue_avg_count = 0; 865f1d2b4d3SLarry Finger u32 thermalvalue_avg = 0; 866f1d2b4d3SLarry Finger long ele_d, temp_cck; 86708aba42fSArnd Bergmann s8 ofdm_index[2], cck_index = 0, 868f1d2b4d3SLarry Finger ofdm_index_old[2] = {0, 0}, cck_index_old = 0; 869f1d2b4d3SLarry Finger int i = 0; 870f1d2b4d3SLarry Finger /*bool is2t = false;*/ 871f1d2b4d3SLarry Finger 872f1d2b4d3SLarry Finger u8 ofdm_min_index = 6, rf = 1; 873f1d2b4d3SLarry Finger /*u8 index_for_channel;*/ 874f1d2b4d3SLarry Finger enum _power_dec_inc {power_dec, power_inc}; 875f1d2b4d3SLarry Finger 876f1d2b4d3SLarry Finger /*0.1 the following TWO tables decide the 877f1d2b4d3SLarry Finger *final index of OFDM/CCK swing table 878f1d2b4d3SLarry Finger */ 87908aba42fSArnd Bergmann s8 delta_swing_table_idx[2][15] = { 880f1d2b4d3SLarry Finger {0, 0, 2, 3, 4, 4, 5, 6, 7, 7, 8, 9, 10, 10, 11}, 881f1d2b4d3SLarry Finger {0, 0, -1, -2, -3, -4, -4, -4, -4, -5, -7, -8, -9, -9, -10} 882f1d2b4d3SLarry Finger }; 883f1d2b4d3SLarry Finger u8 thermal_threshold[2][15] = { 884f1d2b4d3SLarry Finger {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 27}, 885f1d2b4d3SLarry Finger {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 25, 25, 25} 886f1d2b4d3SLarry Finger }; 887f1d2b4d3SLarry Finger 888f1d2b4d3SLarry Finger /*Initilization (7 steps in total) */ 889f1d2b4d3SLarry Finger rtlpriv->dm.txpower_trackinginit = true; 890f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD, 891f1d2b4d3SLarry Finger "dm_txpower_track_cb_therm\n"); 892f1d2b4d3SLarry Finger 893f1d2b4d3SLarry Finger thermalvalue = (u8)rtl_get_rfreg(hw, RF90_PATH_A, RF_T_METER, 894f1d2b4d3SLarry Finger 0xfc00); 895f1d2b4d3SLarry Finger if (!thermalvalue) 896f1d2b4d3SLarry Finger return; 897f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD, 898f1d2b4d3SLarry Finger "Readback Thermal Meter = 0x%x pre thermal meter 0x%x eeprom_thermalmeter 0x%x\n", 899f1d2b4d3SLarry Finger thermalvalue, rtlpriv->dm.thermalvalue, 900f1d2b4d3SLarry Finger rtlefuse->eeprom_thermalmeter); 901f1d2b4d3SLarry Finger 902f1d2b4d3SLarry Finger /*1. Query OFDM Default Setting: Path A*/ 903f1d2b4d3SLarry Finger ele_d = rtl_get_bbreg(hw, ROFDM0_XATXIQIMBALANCE, MASKDWORD) & 904f1d2b4d3SLarry Finger MASKOFDM_D; 905f1d2b4d3SLarry Finger for (i = 0; i < OFDM_TABLE_LENGTH; i++) { 906f1d2b4d3SLarry Finger if (ele_d == (ofdmswing_table[i] & MASKOFDM_D)) { 907f1d2b4d3SLarry Finger ofdm_index_old[0] = (u8)i; 908f1d2b4d3SLarry Finger rtldm->swing_idx_ofdm_base[RF90_PATH_A] = (u8)i; 909f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD, 910f1d2b4d3SLarry Finger "Initial pathA ele_d reg0x%x = 0x%lx, ofdm_index = 0x%x\n", 911f1d2b4d3SLarry Finger ROFDM0_XATXIQIMBALANCE, 912f1d2b4d3SLarry Finger ele_d, ofdm_index_old[0]); 913f1d2b4d3SLarry Finger break; 914f1d2b4d3SLarry Finger } 915f1d2b4d3SLarry Finger } 916f1d2b4d3SLarry Finger 917f1d2b4d3SLarry Finger /*2.Query CCK default setting From 0xa24*/ 918f1d2b4d3SLarry Finger temp_cck = rtl_get_bbreg(hw, RCCK0_TXFILTER2, MASKDWORD) & MASKCCK; 919f1d2b4d3SLarry Finger for (i = 0; i < CCK_TABLE_LENGTH; i++) { 920f1d2b4d3SLarry Finger if (rtlpriv->dm.cck_inch14) { 921f1d2b4d3SLarry Finger if (memcmp(&temp_cck, &cck_tbl_ch14[i][2], 4) == 0) { 922f1d2b4d3SLarry Finger cck_index_old = (u8)i; 923f1d2b4d3SLarry Finger rtldm->swing_idx_cck_base = (u8)i; 924f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, 925f1d2b4d3SLarry Finger DBG_LOUD, 926f1d2b4d3SLarry Finger "Initial reg0x%x = 0x%lx, cck_index = 0x%x, ch 14 %d\n", 927f1d2b4d3SLarry Finger RCCK0_TXFILTER2, temp_cck, 928f1d2b4d3SLarry Finger cck_index_old, 929f1d2b4d3SLarry Finger rtlpriv->dm.cck_inch14); 930f1d2b4d3SLarry Finger break; 931f1d2b4d3SLarry Finger } 932f1d2b4d3SLarry Finger } else { 933f1d2b4d3SLarry Finger if (memcmp(&temp_cck, &cck_tbl_ch1_13[i][2], 4) == 0) { 934f1d2b4d3SLarry Finger cck_index_old = (u8)i; 935f1d2b4d3SLarry Finger rtldm->swing_idx_cck_base = (u8)i; 936f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, 937f1d2b4d3SLarry Finger DBG_LOUD, 938f1d2b4d3SLarry Finger "Initial reg0x%x = 0x%lx, cck_index = 0x%x, ch14 %d\n", 939f1d2b4d3SLarry Finger RCCK0_TXFILTER2, temp_cck, 940f1d2b4d3SLarry Finger cck_index_old, 941f1d2b4d3SLarry Finger rtlpriv->dm.cck_inch14); 942f1d2b4d3SLarry Finger break; 943f1d2b4d3SLarry Finger } 944f1d2b4d3SLarry Finger } 945f1d2b4d3SLarry Finger } 946f1d2b4d3SLarry Finger 947f1d2b4d3SLarry Finger /*3 Initialize ThermalValues of RFCalibrateInfo*/ 948f1d2b4d3SLarry Finger if (!rtldm->thermalvalue) { 949f1d2b4d3SLarry Finger rtlpriv->dm.thermalvalue = rtlefuse->eeprom_thermalmeter; 950f1d2b4d3SLarry Finger rtlpriv->dm.thermalvalue_lck = thermalvalue; 951f1d2b4d3SLarry Finger rtlpriv->dm.thermalvalue_iqk = thermalvalue; 952f1d2b4d3SLarry Finger for (i = 0; i < rf; i++) 953f1d2b4d3SLarry Finger rtlpriv->dm.ofdm_index[i] = ofdm_index_old[i]; 954f1d2b4d3SLarry Finger rtlpriv->dm.cck_index = cck_index_old; 955f1d2b4d3SLarry Finger } 956f1d2b4d3SLarry Finger 957f1d2b4d3SLarry Finger /*4 Calculate average thermal meter*/ 958f1d2b4d3SLarry Finger rtldm->thermalvalue_avg[rtldm->thermalvalue_avg_index] = thermalvalue; 959f1d2b4d3SLarry Finger rtldm->thermalvalue_avg_index++; 960f1d2b4d3SLarry Finger if (rtldm->thermalvalue_avg_index == AVG_THERMAL_NUM_88E) 961f1d2b4d3SLarry Finger rtldm->thermalvalue_avg_index = 0; 962f1d2b4d3SLarry Finger 963f1d2b4d3SLarry Finger for (i = 0; i < AVG_THERMAL_NUM_88E; i++) { 964f1d2b4d3SLarry Finger if (rtldm->thermalvalue_avg[i]) { 965f1d2b4d3SLarry Finger thermalvalue_avg += rtldm->thermalvalue_avg[i]; 966f1d2b4d3SLarry Finger thermalvalue_avg_count++; 967f1d2b4d3SLarry Finger } 968f1d2b4d3SLarry Finger } 969f1d2b4d3SLarry Finger 970f1d2b4d3SLarry Finger if (thermalvalue_avg_count) 971f1d2b4d3SLarry Finger thermalvalue = (u8)(thermalvalue_avg / thermalvalue_avg_count); 972f1d2b4d3SLarry Finger 973f1d2b4d3SLarry Finger /* 5 Calculate delta, delta_LCK, delta_IQK.*/ 974f1d2b4d3SLarry Finger if (rtlhal->reloadtxpowerindex) { 975f1d2b4d3SLarry Finger delta = (thermalvalue > rtlefuse->eeprom_thermalmeter) ? 976f1d2b4d3SLarry Finger (thermalvalue - rtlefuse->eeprom_thermalmeter) : 977f1d2b4d3SLarry Finger (rtlefuse->eeprom_thermalmeter - thermalvalue); 978f1d2b4d3SLarry Finger rtlhal->reloadtxpowerindex = false; 979f1d2b4d3SLarry Finger rtlpriv->dm.done_txpower = false; 980f1d2b4d3SLarry Finger } else if (rtlpriv->dm.done_txpower) { 981f1d2b4d3SLarry Finger delta = (thermalvalue > rtlpriv->dm.thermalvalue) ? 982f1d2b4d3SLarry Finger (thermalvalue - rtlpriv->dm.thermalvalue) : 983f1d2b4d3SLarry Finger (rtlpriv->dm.thermalvalue - thermalvalue); 984f1d2b4d3SLarry Finger } else { 985f1d2b4d3SLarry Finger delta = (thermalvalue > rtlefuse->eeprom_thermalmeter) ? 986f1d2b4d3SLarry Finger (thermalvalue - rtlefuse->eeprom_thermalmeter) : 987f1d2b4d3SLarry Finger (rtlefuse->eeprom_thermalmeter - thermalvalue); 988f1d2b4d3SLarry Finger } 989f1d2b4d3SLarry Finger delta_lck = (thermalvalue > rtlpriv->dm.thermalvalue_lck) ? 990f1d2b4d3SLarry Finger (thermalvalue - rtlpriv->dm.thermalvalue_lck) : 991f1d2b4d3SLarry Finger (rtlpriv->dm.thermalvalue_lck - thermalvalue); 992f1d2b4d3SLarry Finger delta_iqk = (thermalvalue > rtlpriv->dm.thermalvalue_iqk) ? 993f1d2b4d3SLarry Finger (thermalvalue - rtlpriv->dm.thermalvalue_iqk) : 994f1d2b4d3SLarry Finger (rtlpriv->dm.thermalvalue_iqk - thermalvalue); 995f1d2b4d3SLarry Finger 996f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD, 997f1d2b4d3SLarry Finger "Readback Thermal Meter = 0x%x pre thermal meter 0x%x eeprom_thermalmeter 0x%x delta 0x%x delta_lck 0x%x delta_iqk 0x%x\n", 998f1d2b4d3SLarry Finger thermalvalue, rtlpriv->dm.thermalvalue, 999f1d2b4d3SLarry Finger rtlefuse->eeprom_thermalmeter, delta, delta_lck, 1000f1d2b4d3SLarry Finger delta_iqk); 1001f1d2b4d3SLarry Finger /* 6 If necessary, do LCK.*/ 1002f1d2b4d3SLarry Finger if (delta_lck >= 8) { 1003f1d2b4d3SLarry Finger rtlpriv->dm.thermalvalue_lck = thermalvalue; 1004f1d2b4d3SLarry Finger rtl88e_phy_lc_calibrate(hw); 1005f1d2b4d3SLarry Finger } 1006f1d2b4d3SLarry Finger 1007f1d2b4d3SLarry Finger /* 7 If necessary, move the index of 1008f1d2b4d3SLarry Finger * swing table to adjust Tx power. 1009f1d2b4d3SLarry Finger */ 1010f1d2b4d3SLarry Finger if (delta > 0 && rtlpriv->dm.txpower_track_control) { 1011f1d2b4d3SLarry Finger delta = (thermalvalue > rtlefuse->eeprom_thermalmeter) ? 1012f1d2b4d3SLarry Finger (thermalvalue - rtlefuse->eeprom_thermalmeter) : 1013f1d2b4d3SLarry Finger (rtlefuse->eeprom_thermalmeter - thermalvalue); 1014f1d2b4d3SLarry Finger 1015f1d2b4d3SLarry Finger /* 7.1 Get the final CCK_index and OFDM_index for each 1016f1d2b4d3SLarry Finger * swing table. 1017f1d2b4d3SLarry Finger */ 1018f1d2b4d3SLarry Finger if (thermalvalue > rtlefuse->eeprom_thermalmeter) { 1019f1d2b4d3SLarry Finger CAL_SWING_OFF(offset, power_inc, INDEX_MAPPING_NUM, 1020f1d2b4d3SLarry Finger delta); 1021f1d2b4d3SLarry Finger for (i = 0; i < rf; i++) 1022f1d2b4d3SLarry Finger ofdm_index[i] = 1023f1d2b4d3SLarry Finger rtldm->ofdm_index[i] + 1024f1d2b4d3SLarry Finger delta_swing_table_idx[power_inc][offset]; 1025f1d2b4d3SLarry Finger cck_index = rtldm->cck_index + 1026f1d2b4d3SLarry Finger delta_swing_table_idx[power_inc][offset]; 1027f1d2b4d3SLarry Finger } else { 1028f1d2b4d3SLarry Finger CAL_SWING_OFF(offset, power_dec, INDEX_MAPPING_NUM, 1029f1d2b4d3SLarry Finger delta); 1030f1d2b4d3SLarry Finger for (i = 0; i < rf; i++) 1031f1d2b4d3SLarry Finger ofdm_index[i] = 1032f1d2b4d3SLarry Finger rtldm->ofdm_index[i] + 1033f1d2b4d3SLarry Finger delta_swing_table_idx[power_dec][offset]; 1034f1d2b4d3SLarry Finger cck_index = rtldm->cck_index + 1035f1d2b4d3SLarry Finger delta_swing_table_idx[power_dec][offset]; 1036f1d2b4d3SLarry Finger } 1037f1d2b4d3SLarry Finger 1038f1d2b4d3SLarry Finger /* 7.2 Handle boundary conditions of index.*/ 1039f1d2b4d3SLarry Finger for (i = 0; i < rf; i++) { 1040f1d2b4d3SLarry Finger if (ofdm_index[i] > OFDM_TABLE_SIZE-1) 1041f1d2b4d3SLarry Finger ofdm_index[i] = OFDM_TABLE_SIZE-1; 1042f1d2b4d3SLarry Finger else if (rtldm->ofdm_index[i] < ofdm_min_index) 1043f1d2b4d3SLarry Finger ofdm_index[i] = ofdm_min_index; 1044f1d2b4d3SLarry Finger } 1045f1d2b4d3SLarry Finger 1046f1d2b4d3SLarry Finger if (cck_index > CCK_TABLE_SIZE-1) 1047f1d2b4d3SLarry Finger cck_index = CCK_TABLE_SIZE-1; 1048f1d2b4d3SLarry Finger else if (cck_index < 0) 1049f1d2b4d3SLarry Finger cck_index = 0; 1050f1d2b4d3SLarry Finger 1051f1d2b4d3SLarry Finger /*7.3Configure the Swing Table to adjust Tx Power.*/ 1052f1d2b4d3SLarry Finger if (rtlpriv->dm.txpower_track_control) { 1053f1d2b4d3SLarry Finger rtldm->done_txpower = true; 1054f1d2b4d3SLarry Finger rtldm->swing_idx_ofdm[RF90_PATH_A] = 1055f1d2b4d3SLarry Finger (u8)ofdm_index[RF90_PATH_A]; 1056f1d2b4d3SLarry Finger rtldm->swing_idx_cck = cck_index; 1057f1d2b4d3SLarry Finger if (rtldm->swing_idx_ofdm_cur != 1058f1d2b4d3SLarry Finger rtldm->swing_idx_ofdm[0]) { 1059f1d2b4d3SLarry Finger rtldm->swing_idx_ofdm_cur = 1060f1d2b4d3SLarry Finger rtldm->swing_idx_ofdm[0]; 1061f1d2b4d3SLarry Finger rtldm->swing_flag_ofdm = true; 1062f1d2b4d3SLarry Finger } 1063f1d2b4d3SLarry Finger 1064f1d2b4d3SLarry Finger if (rtldm->swing_idx_cck_cur != rtldm->swing_idx_cck) { 1065f1d2b4d3SLarry Finger rtldm->swing_idx_cck_cur = rtldm->swing_idx_cck; 1066f1d2b4d3SLarry Finger rtldm->swing_flag_cck = true; 1067f1d2b4d3SLarry Finger } 1068f1d2b4d3SLarry Finger 1069f1d2b4d3SLarry Finger dm_tx_pwr_track_set_pwr(hw, TXAGC, 0, 0); 1070f1d2b4d3SLarry Finger } 1071f1d2b4d3SLarry Finger } 1072f1d2b4d3SLarry Finger 1073f1d2b4d3SLarry Finger if (delta_iqk >= 8) { 1074f1d2b4d3SLarry Finger rtlpriv->dm.thermalvalue_iqk = thermalvalue; 1075f1d2b4d3SLarry Finger rtl88e_phy_iq_calibrate(hw, false); 1076f1d2b4d3SLarry Finger } 1077f1d2b4d3SLarry Finger 1078f1d2b4d3SLarry Finger if (rtldm->txpower_track_control) 1079f1d2b4d3SLarry Finger rtldm->thermalvalue = thermalvalue; 1080f1d2b4d3SLarry Finger rtldm->txpowercount = 0; 1081f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD, "end\n"); 1082f1d2b4d3SLarry Finger } 1083f1d2b4d3SLarry Finger 1084f1d2b4d3SLarry Finger static void rtl88e_dm_init_txpower_tracking(struct ieee80211_hw *hw) 1085f1d2b4d3SLarry Finger { 1086f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1087f1d2b4d3SLarry Finger 1088f1d2b4d3SLarry Finger rtlpriv->dm.txpower_tracking = true; 1089f1d2b4d3SLarry Finger rtlpriv->dm.txpower_trackinginit = false; 1090f1d2b4d3SLarry Finger rtlpriv->dm.txpowercount = 0; 1091f1d2b4d3SLarry Finger rtlpriv->dm.txpower_track_control = true; 1092f1d2b4d3SLarry Finger 1093f1d2b4d3SLarry Finger rtlpriv->dm.swing_idx_ofdm[RF90_PATH_A] = 12; 1094f1d2b4d3SLarry Finger rtlpriv->dm.swing_idx_ofdm_cur = 12; 1095f1d2b4d3SLarry Finger rtlpriv->dm.swing_flag_ofdm = false; 1096f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD, 1097f1d2b4d3SLarry Finger "rtlpriv->dm.txpower_tracking = %d\n", 1098f1d2b4d3SLarry Finger rtlpriv->dm.txpower_tracking); 1099f1d2b4d3SLarry Finger } 1100f1d2b4d3SLarry Finger 1101f1d2b4d3SLarry Finger void rtl88e_dm_check_txpower_tracking(struct ieee80211_hw *hw) 1102f1d2b4d3SLarry Finger { 1103f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1104f1d2b4d3SLarry Finger 1105f1d2b4d3SLarry Finger if (!rtlpriv->dm.txpower_tracking) 1106f1d2b4d3SLarry Finger return; 1107f1d2b4d3SLarry Finger 1108f1d2b4d3SLarry Finger if (!rtlpriv->dm.tm_trigger) { 1109f1d2b4d3SLarry Finger rtl_set_rfreg(hw, RF90_PATH_A, RF_T_METER, BIT(17)|BIT(16), 1110f1d2b4d3SLarry Finger 0x03); 1111f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD, 1112f1d2b4d3SLarry Finger "Trigger 88E Thermal Meter!!\n"); 1113f1d2b4d3SLarry Finger rtlpriv->dm.tm_trigger = 1; 1114f1d2b4d3SLarry Finger return; 1115f1d2b4d3SLarry Finger } else { 1116f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD, 1117f1d2b4d3SLarry Finger "Schedule TxPowerTracking !!\n"); 1118f1d2b4d3SLarry Finger dm_txpower_track_cb_therm(hw); 1119f1d2b4d3SLarry Finger rtlpriv->dm.tm_trigger = 0; 1120f1d2b4d3SLarry Finger } 1121f1d2b4d3SLarry Finger } 1122f1d2b4d3SLarry Finger 1123f1d2b4d3SLarry Finger void rtl88e_dm_init_rate_adaptive_mask(struct ieee80211_hw *hw) 1124f1d2b4d3SLarry Finger { 1125f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1126f1d2b4d3SLarry Finger struct rate_adaptive *p_ra = &rtlpriv->ra; 1127f1d2b4d3SLarry Finger 1128f1d2b4d3SLarry Finger p_ra->ratr_state = DM_RATR_STA_INIT; 1129f1d2b4d3SLarry Finger p_ra->pre_ratr_state = DM_RATR_STA_INIT; 1130f1d2b4d3SLarry Finger 1131f1d2b4d3SLarry Finger if (rtlpriv->dm.dm_type == DM_TYPE_BYDRIVER) 1132f1d2b4d3SLarry Finger rtlpriv->dm.useramask = true; 1133f1d2b4d3SLarry Finger else 1134f1d2b4d3SLarry Finger rtlpriv->dm.useramask = false; 1135f1d2b4d3SLarry Finger } 1136f1d2b4d3SLarry Finger 1137f1d2b4d3SLarry Finger static void rtl88e_dm_refresh_rate_adaptive_mask(struct ieee80211_hw *hw) 1138f1d2b4d3SLarry Finger { 1139f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1140f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 1141f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 1142f1d2b4d3SLarry Finger struct rate_adaptive *p_ra = &rtlpriv->ra; 1143f1d2b4d3SLarry Finger u32 low_rssithresh_for_ra, high_rssithresh_for_ra; 1144f1d2b4d3SLarry Finger struct ieee80211_sta *sta = NULL; 1145f1d2b4d3SLarry Finger 1146f1d2b4d3SLarry Finger if (is_hal_stop(rtlhal)) { 1147f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_RATE, DBG_LOUD, 1148f1d2b4d3SLarry Finger "driver is going to unload\n"); 1149f1d2b4d3SLarry Finger return; 1150f1d2b4d3SLarry Finger } 1151f1d2b4d3SLarry Finger 1152f1d2b4d3SLarry Finger if (!rtlpriv->dm.useramask) { 1153f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_RATE, DBG_LOUD, 1154f1d2b4d3SLarry Finger "driver does not control rate adaptive mask\n"); 1155f1d2b4d3SLarry Finger return; 1156f1d2b4d3SLarry Finger } 1157f1d2b4d3SLarry Finger 1158f1d2b4d3SLarry Finger if (mac->link_state == MAC80211_LINKED && 1159f1d2b4d3SLarry Finger mac->opmode == NL80211_IFTYPE_STATION) { 1160f1d2b4d3SLarry Finger switch (p_ra->pre_ratr_state) { 1161f1d2b4d3SLarry Finger case DM_RATR_STA_HIGH: 1162f1d2b4d3SLarry Finger high_rssithresh_for_ra = 50; 1163f1d2b4d3SLarry Finger low_rssithresh_for_ra = 20; 1164f1d2b4d3SLarry Finger break; 1165f1d2b4d3SLarry Finger case DM_RATR_STA_MIDDLE: 1166f1d2b4d3SLarry Finger high_rssithresh_for_ra = 55; 1167f1d2b4d3SLarry Finger low_rssithresh_for_ra = 20; 1168f1d2b4d3SLarry Finger break; 1169f1d2b4d3SLarry Finger case DM_RATR_STA_LOW: 1170f1d2b4d3SLarry Finger high_rssithresh_for_ra = 50; 1171f1d2b4d3SLarry Finger low_rssithresh_for_ra = 25; 1172f1d2b4d3SLarry Finger break; 1173f1d2b4d3SLarry Finger default: 1174f1d2b4d3SLarry Finger high_rssithresh_for_ra = 50; 1175f1d2b4d3SLarry Finger low_rssithresh_for_ra = 20; 1176f1d2b4d3SLarry Finger break; 1177f1d2b4d3SLarry Finger } 1178f1d2b4d3SLarry Finger 1179f1d2b4d3SLarry Finger if (rtlpriv->dm.undec_sm_pwdb > 1180f1d2b4d3SLarry Finger (long)high_rssithresh_for_ra) 1181f1d2b4d3SLarry Finger p_ra->ratr_state = DM_RATR_STA_HIGH; 1182f1d2b4d3SLarry Finger else if (rtlpriv->dm.undec_sm_pwdb > 1183f1d2b4d3SLarry Finger (long)low_rssithresh_for_ra) 1184f1d2b4d3SLarry Finger p_ra->ratr_state = DM_RATR_STA_MIDDLE; 1185f1d2b4d3SLarry Finger else 1186f1d2b4d3SLarry Finger p_ra->ratr_state = DM_RATR_STA_LOW; 1187f1d2b4d3SLarry Finger 1188f1d2b4d3SLarry Finger if (p_ra->pre_ratr_state != p_ra->ratr_state) { 1189f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_RATE, DBG_LOUD, 1190f1d2b4d3SLarry Finger "RSSI = %ld\n", 1191f1d2b4d3SLarry Finger rtlpriv->dm.undec_sm_pwdb); 1192f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_RATE, DBG_LOUD, 1193f1d2b4d3SLarry Finger "RSSI_LEVEL = %d\n", p_ra->ratr_state); 1194f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_RATE, DBG_LOUD, 1195f1d2b4d3SLarry Finger "PreState = %d, CurState = %d\n", 1196f1d2b4d3SLarry Finger p_ra->pre_ratr_state, p_ra->ratr_state); 1197f1d2b4d3SLarry Finger 1198f1d2b4d3SLarry Finger rcu_read_lock(); 1199f1d2b4d3SLarry Finger sta = rtl_find_sta(hw, mac->bssid); 1200f1d2b4d3SLarry Finger if (sta) 1201f1d2b4d3SLarry Finger rtlpriv->cfg->ops->update_rate_tbl(hw, sta, 12021d22b177SPing-Ke Shih p_ra->ratr_state, 12031d22b177SPing-Ke Shih true); 1204f1d2b4d3SLarry Finger rcu_read_unlock(); 1205f1d2b4d3SLarry Finger 1206f1d2b4d3SLarry Finger p_ra->pre_ratr_state = p_ra->ratr_state; 1207f1d2b4d3SLarry Finger } 1208f1d2b4d3SLarry Finger } 1209f1d2b4d3SLarry Finger } 1210f1d2b4d3SLarry Finger 1211f1d2b4d3SLarry Finger static void rtl92c_dm_init_dynamic_bb_powersaving(struct ieee80211_hw *hw) 1212f1d2b4d3SLarry Finger { 1213f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1214f1d2b4d3SLarry Finger struct ps_t *dm_pstable = &rtlpriv->dm_pstable; 1215f1d2b4d3SLarry Finger 1216f1d2b4d3SLarry Finger dm_pstable->pre_ccastate = CCA_MAX; 1217f1d2b4d3SLarry Finger dm_pstable->cur_ccasate = CCA_MAX; 1218f1d2b4d3SLarry Finger dm_pstable->pre_rfstate = RF_MAX; 1219f1d2b4d3SLarry Finger dm_pstable->cur_rfstate = RF_MAX; 1220f1d2b4d3SLarry Finger dm_pstable->rssi_val_min = 0; 1221f1d2b4d3SLarry Finger } 1222f1d2b4d3SLarry Finger 1223f1d2b4d3SLarry Finger static void rtl88e_dm_update_rx_idle_ant(struct ieee80211_hw *hw, 1224f1d2b4d3SLarry Finger u8 ant) 1225f1d2b4d3SLarry Finger { 1226f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1227f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 1228f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1229f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1230f1d2b4d3SLarry Finger u32 default_ant, optional_ant; 1231f1d2b4d3SLarry Finger 1232f1d2b4d3SLarry Finger if (pfat_table->rx_idle_ant != ant) { 1233f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, 1234f1d2b4d3SLarry Finger "need to update rx idle ant\n"); 1235f1d2b4d3SLarry Finger if (ant == MAIN_ANT) { 1236f1d2b4d3SLarry Finger default_ant = 1237f1d2b4d3SLarry Finger (pfat_table->rx_idle_ant == CG_TRX_HW_ANTDIV) ? 1238f1d2b4d3SLarry Finger MAIN_ANT_CG_TRX : MAIN_ANT_CGCS_RX; 1239f1d2b4d3SLarry Finger optional_ant = 1240f1d2b4d3SLarry Finger (pfat_table->rx_idle_ant == CG_TRX_HW_ANTDIV) ? 1241f1d2b4d3SLarry Finger AUX_ANT_CG_TRX : AUX_ANT_CGCS_RX; 1242f1d2b4d3SLarry Finger } else { 1243f1d2b4d3SLarry Finger default_ant = 1244f1d2b4d3SLarry Finger (pfat_table->rx_idle_ant == CG_TRX_HW_ANTDIV) ? 1245f1d2b4d3SLarry Finger AUX_ANT_CG_TRX : AUX_ANT_CGCS_RX; 1246f1d2b4d3SLarry Finger optional_ant = 1247f1d2b4d3SLarry Finger (pfat_table->rx_idle_ant == CG_TRX_HW_ANTDIV) ? 1248f1d2b4d3SLarry Finger MAIN_ANT_CG_TRX : MAIN_ANT_CGCS_RX; 1249f1d2b4d3SLarry Finger } 1250f1d2b4d3SLarry Finger 1251f1d2b4d3SLarry Finger if (rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) { 1252f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, 1253f1d2b4d3SLarry Finger BIT(5) | BIT(4) | BIT(3), default_ant); 1254f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, 1255f1d2b4d3SLarry Finger BIT(8) | BIT(7) | BIT(6), optional_ant); 1256f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANTSEL_CTRL_11N, 1257f1d2b4d3SLarry Finger BIT(14) | BIT(13) | BIT(12), 1258f1d2b4d3SLarry Finger default_ant); 1259f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RESP_TX_11N, 1260f1d2b4d3SLarry Finger BIT(6) | BIT(7), default_ant); 1261f1d2b4d3SLarry Finger } else if (rtlefuse->antenna_div_type == CGCS_RX_HW_ANTDIV) { 1262f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, 1263f1d2b4d3SLarry Finger BIT(5) | BIT(4) | BIT(3), default_ant); 1264f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, 1265f1d2b4d3SLarry Finger BIT(8) | BIT(7) | BIT(6), optional_ant); 1266f1d2b4d3SLarry Finger } 1267f1d2b4d3SLarry Finger } 1268f1d2b4d3SLarry Finger pfat_table->rx_idle_ant = ant; 1269f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "RxIdleAnt %s\n", 1270f1d2b4d3SLarry Finger (ant == MAIN_ANT) ? ("MAIN_ANT") : ("AUX_ANT")); 1271f1d2b4d3SLarry Finger } 1272f1d2b4d3SLarry Finger 1273f1d2b4d3SLarry Finger static void rtl88e_dm_update_tx_ant(struct ieee80211_hw *hw, 1274f1d2b4d3SLarry Finger u8 ant, u32 mac_id) 1275f1d2b4d3SLarry Finger { 1276f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1277f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1278f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1279f1d2b4d3SLarry Finger u8 target_ant; 1280f1d2b4d3SLarry Finger 1281f1d2b4d3SLarry Finger if (ant == MAIN_ANT) 1282f1d2b4d3SLarry Finger target_ant = MAIN_ANT_CG_TRX; 1283f1d2b4d3SLarry Finger else 1284f1d2b4d3SLarry Finger target_ant = AUX_ANT_CG_TRX; 1285f1d2b4d3SLarry Finger 1286f1d2b4d3SLarry Finger pfat_table->antsel_a[mac_id] = target_ant & BIT(0); 1287f1d2b4d3SLarry Finger pfat_table->antsel_b[mac_id] = (target_ant & BIT(1)) >> 1; 1288f1d2b4d3SLarry Finger pfat_table->antsel_c[mac_id] = (target_ant & BIT(2)) >> 2; 1289f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "txfrominfo target ant %s\n", 1290f1d2b4d3SLarry Finger (ant == MAIN_ANT) ? ("MAIN_ANT") : ("AUX_ANT")); 1291f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "antsel_tr_mux = 3'b%d%d%d\n", 1292f1d2b4d3SLarry Finger pfat_table->antsel_c[mac_id], 1293f1d2b4d3SLarry Finger pfat_table->antsel_b[mac_id], 1294f1d2b4d3SLarry Finger pfat_table->antsel_a[mac_id]); 1295f1d2b4d3SLarry Finger } 1296f1d2b4d3SLarry Finger 1297f1d2b4d3SLarry Finger static void rtl88e_dm_rx_hw_antena_div_init(struct ieee80211_hw *hw) 1298f1d2b4d3SLarry Finger { 1299f1d2b4d3SLarry Finger u32 value32; 1300f1d2b4d3SLarry Finger 1301f1d2b4d3SLarry Finger /*MAC Setting*/ 1302f1d2b4d3SLarry Finger value32 = rtl_get_bbreg(hw, DM_REG_ANTSEL_PIN_11N, MASKDWORD); 1303f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANTSEL_PIN_11N, 1304f1d2b4d3SLarry Finger MASKDWORD, value32 | (BIT(23) | BIT(25))); 1305f1d2b4d3SLarry Finger /*Pin Setting*/ 1306f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_PIN_CTRL_11N, BIT(9) | BIT(8), 0); 1307f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, BIT(10), 0); 1308f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_LNA_SWITCH_11N, BIT(22), 1); 1309f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_LNA_SWITCH_11N, BIT(31), 1); 1310f1d2b4d3SLarry Finger /*OFDM Setting*/ 1311f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANTDIV_PARA1_11N, MASKDWORD, 0x000000a0); 1312f1d2b4d3SLarry Finger /*CCK Setting*/ 1313f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_BB_PWR_SAV4_11N, BIT(7), 1); 1314f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_CCK_ANTDIV_PARA2_11N, BIT(4), 1); 1315f1d2b4d3SLarry Finger rtl88e_dm_update_rx_idle_ant(hw, MAIN_ANT); 1316f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_MAPPING1_11N, MASKLWORD, 0x0201); 1317f1d2b4d3SLarry Finger } 1318f1d2b4d3SLarry Finger 1319f1d2b4d3SLarry Finger static void rtl88e_dm_trx_hw_antenna_div_init(struct ieee80211_hw *hw) 1320f1d2b4d3SLarry Finger { 1321f1d2b4d3SLarry Finger u32 value32; 1322f1d2b4d3SLarry Finger 1323f1d2b4d3SLarry Finger /*MAC Setting*/ 1324f1d2b4d3SLarry Finger value32 = rtl_get_bbreg(hw, DM_REG_ANTSEL_PIN_11N, MASKDWORD); 1325f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANTSEL_PIN_11N, MASKDWORD, 1326f1d2b4d3SLarry Finger value32 | (BIT(23) | BIT(25))); 1327f1d2b4d3SLarry Finger /*Pin Setting*/ 1328f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_PIN_CTRL_11N, BIT(9) | BIT(8), 0); 1329f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, BIT(10), 0); 1330f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_LNA_SWITCH_11N, BIT(22), 0); 1331f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_LNA_SWITCH_11N, BIT(31), 1); 1332f1d2b4d3SLarry Finger /*OFDM Setting*/ 1333f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANTDIV_PARA1_11N, MASKDWORD, 0x000000a0); 1334f1d2b4d3SLarry Finger /*CCK Setting*/ 1335f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_BB_PWR_SAV4_11N, BIT(7), 1); 1336f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_CCK_ANTDIV_PARA2_11N, BIT(4), 1); 1337f1d2b4d3SLarry Finger /*TX Setting*/ 1338f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_TX_ANT_CTRL_11N, BIT(21), 0); 1339f1d2b4d3SLarry Finger rtl88e_dm_update_rx_idle_ant(hw, MAIN_ANT); 1340f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_MAPPING1_11N, MASKLWORD, 0x0201); 1341f1d2b4d3SLarry Finger } 1342f1d2b4d3SLarry Finger 1343f1d2b4d3SLarry Finger static void rtl88e_dm_fast_training_init(struct ieee80211_hw *hw) 1344f1d2b4d3SLarry Finger { 1345f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1346f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1347f1d2b4d3SLarry Finger u32 ant_combination = 2; 1348f1d2b4d3SLarry Finger u32 value32, i; 1349f1d2b4d3SLarry Finger 1350f1d2b4d3SLarry Finger for (i = 0; i < 6; i++) { 1351f1d2b4d3SLarry Finger pfat_table->bssid[i] = 0; 1352f1d2b4d3SLarry Finger pfat_table->ant_sum[i] = 0; 1353f1d2b4d3SLarry Finger pfat_table->ant_cnt[i] = 0; 1354f1d2b4d3SLarry Finger pfat_table->ant_ave[i] = 0; 1355f1d2b4d3SLarry Finger } 1356f1d2b4d3SLarry Finger pfat_table->train_idx = 0; 1357f1d2b4d3SLarry Finger pfat_table->fat_state = FAT_NORMAL_STATE; 1358f1d2b4d3SLarry Finger 1359f1d2b4d3SLarry Finger /*MAC Setting*/ 1360f1d2b4d3SLarry Finger value32 = rtl_get_bbreg(hw, DM_REG_ANTSEL_PIN_11N, MASKDWORD); 1361f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANTSEL_PIN_11N, 1362f1d2b4d3SLarry Finger MASKDWORD, value32 | (BIT(23) | BIT(25))); 1363f1d2b4d3SLarry Finger value32 = rtl_get_bbreg(hw, DM_REG_ANT_TRAIN_PARA2_11N, MASKDWORD); 1364f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_TRAIN_PARA2_11N, 1365f1d2b4d3SLarry Finger MASKDWORD, value32 | (BIT(16) | BIT(17))); 1366f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_TRAIN_PARA2_11N, 1367f1d2b4d3SLarry Finger MASKLWORD, 0); 1368f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_TRAIN_PARA1_11N, 1369f1d2b4d3SLarry Finger MASKDWORD, 0); 1370f1d2b4d3SLarry Finger 1371f1d2b4d3SLarry Finger /*Pin Setting*/ 1372f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_PIN_CTRL_11N, BIT(9) | BIT(8), 0); 1373f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, BIT(10), 0); 1374f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_LNA_SWITCH_11N, BIT(22), 0); 1375f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_LNA_SWITCH_11N, BIT(31), 1); 1376f1d2b4d3SLarry Finger 1377f1d2b4d3SLarry Finger /*OFDM Setting*/ 1378f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANTDIV_PARA1_11N, MASKDWORD, 0x000000a0); 1379f1d2b4d3SLarry Finger /*antenna mapping table*/ 1380f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_MAPPING1_11N, MASKBYTE0, 1); 1381f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_MAPPING1_11N, MASKBYTE1, 2); 1382f1d2b4d3SLarry Finger 1383f1d2b4d3SLarry Finger /*TX Setting*/ 1384f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_TX_ANT_CTRL_11N, BIT(21), 1); 1385f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, 1386f1d2b4d3SLarry Finger BIT(5) | BIT(4) | BIT(3), 0); 1387f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, 1388f1d2b4d3SLarry Finger BIT(8) | BIT(7) | BIT(6), 1); 1389f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, 1390f1d2b4d3SLarry Finger BIT(2) | BIT(1) | BIT(0), (ant_combination - 1)); 1391f1d2b4d3SLarry Finger 1392f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_IGI_A_11N, BIT(7), 1); 1393f1d2b4d3SLarry Finger } 1394f1d2b4d3SLarry Finger 1395f1d2b4d3SLarry Finger static void rtl88e_dm_antenna_div_init(struct ieee80211_hw *hw) 1396f1d2b4d3SLarry Finger { 1397f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 1398f1d2b4d3SLarry Finger 1399f1d2b4d3SLarry Finger if (rtlefuse->antenna_div_type == CGCS_RX_HW_ANTDIV) 1400f1d2b4d3SLarry Finger rtl88e_dm_rx_hw_antena_div_init(hw); 1401f1d2b4d3SLarry Finger else if (rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) 1402f1d2b4d3SLarry Finger rtl88e_dm_trx_hw_antenna_div_init(hw); 1403f1d2b4d3SLarry Finger else if (rtlefuse->antenna_div_type == CG_TRX_SMART_ANTDIV) 1404f1d2b4d3SLarry Finger rtl88e_dm_fast_training_init(hw); 1405f1d2b4d3SLarry Finger 1406f1d2b4d3SLarry Finger } 1407f1d2b4d3SLarry Finger 1408f1d2b4d3SLarry Finger void rtl88e_dm_set_tx_ant_by_tx_info(struct ieee80211_hw *hw, 1409f1d2b4d3SLarry Finger u8 *pdesc, u32 mac_id) 1410f1d2b4d3SLarry Finger { 1411f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 1412f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1413f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1414f1d2b4d3SLarry Finger 1415f1d2b4d3SLarry Finger if ((rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) || 1416f1d2b4d3SLarry Finger (rtlefuse->antenna_div_type == CG_TRX_SMART_ANTDIV)) { 1417f1d2b4d3SLarry Finger SET_TX_DESC_ANTSEL_A(pdesc, pfat_table->antsel_a[mac_id]); 1418f1d2b4d3SLarry Finger SET_TX_DESC_ANTSEL_B(pdesc, pfat_table->antsel_b[mac_id]); 1419f1d2b4d3SLarry Finger SET_TX_DESC_ANTSEL_C(pdesc, pfat_table->antsel_c[mac_id]); 1420f1d2b4d3SLarry Finger } 1421f1d2b4d3SLarry Finger } 1422f1d2b4d3SLarry Finger 1423f1d2b4d3SLarry Finger void rtl88e_dm_ant_sel_statistics(struct ieee80211_hw *hw, 1424f1d2b4d3SLarry Finger u8 antsel_tr_mux, u32 mac_id, 1425f1d2b4d3SLarry Finger u32 rx_pwdb_all) 1426f1d2b4d3SLarry Finger { 1427f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 1428f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1429f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1430f1d2b4d3SLarry Finger 1431f1d2b4d3SLarry Finger if (rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) { 1432f1d2b4d3SLarry Finger if (antsel_tr_mux == MAIN_ANT_CG_TRX) { 1433f1d2b4d3SLarry Finger pfat_table->main_ant_sum[mac_id] += rx_pwdb_all; 1434f1d2b4d3SLarry Finger pfat_table->main_ant_cnt[mac_id]++; 1435f1d2b4d3SLarry Finger } else { 1436f1d2b4d3SLarry Finger pfat_table->aux_ant_sum[mac_id] += rx_pwdb_all; 1437f1d2b4d3SLarry Finger pfat_table->aux_ant_cnt[mac_id]++; 1438f1d2b4d3SLarry Finger } 1439f1d2b4d3SLarry Finger } else if (rtlefuse->antenna_div_type == CGCS_RX_HW_ANTDIV) { 1440f1d2b4d3SLarry Finger if (antsel_tr_mux == MAIN_ANT_CGCS_RX) { 1441f1d2b4d3SLarry Finger pfat_table->main_ant_sum[mac_id] += rx_pwdb_all; 1442f1d2b4d3SLarry Finger pfat_table->main_ant_cnt[mac_id]++; 1443f1d2b4d3SLarry Finger } else { 1444f1d2b4d3SLarry Finger pfat_table->aux_ant_sum[mac_id] += rx_pwdb_all; 1445f1d2b4d3SLarry Finger pfat_table->aux_ant_cnt[mac_id]++; 1446f1d2b4d3SLarry Finger } 1447f1d2b4d3SLarry Finger } 1448f1d2b4d3SLarry Finger } 1449f1d2b4d3SLarry Finger 1450f1d2b4d3SLarry Finger static void rtl88e_dm_hw_ant_div(struct ieee80211_hw *hw) 1451f1d2b4d3SLarry Finger { 1452f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1453f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 1454f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1455f1d2b4d3SLarry Finger struct rtl_sta_info *drv_priv; 1456f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1457f1d2b4d3SLarry Finger struct dig_t *dm_dig = &rtlpriv->dm_digtable; 1458f1d2b4d3SLarry Finger u32 i, min_rssi = 0xff, ant_div_max_rssi = 0; 1459f1d2b4d3SLarry Finger u32 max_rssi = 0, local_min_rssi, local_max_rssi; 1460f1d2b4d3SLarry Finger u32 main_rssi, aux_rssi; 1461f1d2b4d3SLarry Finger u8 rx_idle_ant = 0, target_ant = 7; 1462f1d2b4d3SLarry Finger 1463f1d2b4d3SLarry Finger /*for sta its self*/ 1464f1d2b4d3SLarry Finger i = 0; 1465f1d2b4d3SLarry Finger main_rssi = (pfat_table->main_ant_cnt[i] != 0) ? 1466f1d2b4d3SLarry Finger (pfat_table->main_ant_sum[i] / pfat_table->main_ant_cnt[i]) : 0; 1467f1d2b4d3SLarry Finger aux_rssi = (pfat_table->aux_ant_cnt[i] != 0) ? 1468f1d2b4d3SLarry Finger (pfat_table->aux_ant_sum[i] / pfat_table->aux_ant_cnt[i]) : 0; 1469f1d2b4d3SLarry Finger target_ant = (main_rssi == aux_rssi) ? 1470f1d2b4d3SLarry Finger pfat_table->rx_idle_ant : ((main_rssi >= aux_rssi) ? 1471f1d2b4d3SLarry Finger MAIN_ANT : AUX_ANT); 1472f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, 1473f1d2b4d3SLarry Finger "main_ant_sum %d main_ant_cnt %d\n", 1474f1d2b4d3SLarry Finger pfat_table->main_ant_sum[i], 1475f1d2b4d3SLarry Finger pfat_table->main_ant_cnt[i]); 1476f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, 1477f1d2b4d3SLarry Finger "aux_ant_sum %d aux_ant_cnt %d\n", 1478f1d2b4d3SLarry Finger pfat_table->aux_ant_sum[i], pfat_table->aux_ant_cnt[i]); 1479f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "main_rssi %d aux_rssi%d\n", 1480f1d2b4d3SLarry Finger main_rssi, aux_rssi); 1481f1d2b4d3SLarry Finger local_max_rssi = (main_rssi > aux_rssi) ? main_rssi : aux_rssi; 1482f1d2b4d3SLarry Finger if ((local_max_rssi > ant_div_max_rssi) && (local_max_rssi < 40)) 1483f1d2b4d3SLarry Finger ant_div_max_rssi = local_max_rssi; 1484f1d2b4d3SLarry Finger if (local_max_rssi > max_rssi) 1485f1d2b4d3SLarry Finger max_rssi = local_max_rssi; 1486f1d2b4d3SLarry Finger 1487f1d2b4d3SLarry Finger if ((pfat_table->rx_idle_ant == MAIN_ANT) && (main_rssi == 0)) 1488f1d2b4d3SLarry Finger main_rssi = aux_rssi; 1489f1d2b4d3SLarry Finger else if ((pfat_table->rx_idle_ant == AUX_ANT) && (aux_rssi == 0)) 1490f1d2b4d3SLarry Finger aux_rssi = main_rssi; 1491f1d2b4d3SLarry Finger 1492f1d2b4d3SLarry Finger local_min_rssi = (main_rssi > aux_rssi) ? aux_rssi : main_rssi; 1493f1d2b4d3SLarry Finger if (local_min_rssi < min_rssi) { 1494f1d2b4d3SLarry Finger min_rssi = local_min_rssi; 1495f1d2b4d3SLarry Finger rx_idle_ant = target_ant; 1496f1d2b4d3SLarry Finger } 1497f1d2b4d3SLarry Finger if (rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) 1498f1d2b4d3SLarry Finger rtl88e_dm_update_tx_ant(hw, target_ant, i); 1499f1d2b4d3SLarry Finger 1500f1d2b4d3SLarry Finger if (rtlpriv->mac80211.opmode == NL80211_IFTYPE_AP || 1501f1d2b4d3SLarry Finger rtlpriv->mac80211.opmode == NL80211_IFTYPE_ADHOC) { 1502f1d2b4d3SLarry Finger spin_lock_bh(&rtlpriv->locks.entry_list_lock); 1503f1d2b4d3SLarry Finger list_for_each_entry(drv_priv, &rtlpriv->entry_list, list) { 1504f1d2b4d3SLarry Finger i++; 1505f1d2b4d3SLarry Finger main_rssi = (pfat_table->main_ant_cnt[i] != 0) ? 1506f1d2b4d3SLarry Finger (pfat_table->main_ant_sum[i] / 1507f1d2b4d3SLarry Finger pfat_table->main_ant_cnt[i]) : 0; 1508f1d2b4d3SLarry Finger aux_rssi = (pfat_table->aux_ant_cnt[i] != 0) ? 1509f1d2b4d3SLarry Finger (pfat_table->aux_ant_sum[i] / 1510f1d2b4d3SLarry Finger pfat_table->aux_ant_cnt[i]) : 0; 1511f1d2b4d3SLarry Finger target_ant = (main_rssi == aux_rssi) ? 1512f1d2b4d3SLarry Finger pfat_table->rx_idle_ant : ((main_rssi >= 1513f1d2b4d3SLarry Finger aux_rssi) ? MAIN_ANT : AUX_ANT); 1514f1d2b4d3SLarry Finger 1515f1d2b4d3SLarry Finger local_max_rssi = (main_rssi > aux_rssi) ? 1516f1d2b4d3SLarry Finger main_rssi : aux_rssi; 1517f1d2b4d3SLarry Finger if ((local_max_rssi > ant_div_max_rssi) && 1518f1d2b4d3SLarry Finger (local_max_rssi < 40)) 1519f1d2b4d3SLarry Finger ant_div_max_rssi = local_max_rssi; 1520f1d2b4d3SLarry Finger if (local_max_rssi > max_rssi) 1521f1d2b4d3SLarry Finger max_rssi = local_max_rssi; 1522f1d2b4d3SLarry Finger 1523f1d2b4d3SLarry Finger if ((pfat_table->rx_idle_ant == MAIN_ANT) && 1524f1d2b4d3SLarry Finger (main_rssi == 0)) 1525f1d2b4d3SLarry Finger main_rssi = aux_rssi; 1526f1d2b4d3SLarry Finger else if ((pfat_table->rx_idle_ant == AUX_ANT) && 1527f1d2b4d3SLarry Finger (aux_rssi == 0)) 1528f1d2b4d3SLarry Finger aux_rssi = main_rssi; 1529f1d2b4d3SLarry Finger 1530f1d2b4d3SLarry Finger local_min_rssi = (main_rssi > aux_rssi) ? 1531f1d2b4d3SLarry Finger aux_rssi : main_rssi; 1532f1d2b4d3SLarry Finger if (local_min_rssi < min_rssi) { 1533f1d2b4d3SLarry Finger min_rssi = local_min_rssi; 1534f1d2b4d3SLarry Finger rx_idle_ant = target_ant; 1535f1d2b4d3SLarry Finger } 1536f1d2b4d3SLarry Finger if (rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) 1537f1d2b4d3SLarry Finger rtl88e_dm_update_tx_ant(hw, target_ant, i); 1538f1d2b4d3SLarry Finger } 1539f1d2b4d3SLarry Finger spin_unlock_bh(&rtlpriv->locks.entry_list_lock); 1540f1d2b4d3SLarry Finger } 1541f1d2b4d3SLarry Finger 1542f1d2b4d3SLarry Finger for (i = 0; i < ASSOCIATE_ENTRY_NUM; i++) { 1543f1d2b4d3SLarry Finger pfat_table->main_ant_sum[i] = 0; 1544f1d2b4d3SLarry Finger pfat_table->aux_ant_sum[i] = 0; 1545f1d2b4d3SLarry Finger pfat_table->main_ant_cnt[i] = 0; 1546f1d2b4d3SLarry Finger pfat_table->aux_ant_cnt[i] = 0; 1547f1d2b4d3SLarry Finger } 1548f1d2b4d3SLarry Finger 1549f1d2b4d3SLarry Finger rtl88e_dm_update_rx_idle_ant(hw, rx_idle_ant); 1550f1d2b4d3SLarry Finger 1551f1d2b4d3SLarry Finger dm_dig->antdiv_rssi_max = ant_div_max_rssi; 1552f1d2b4d3SLarry Finger dm_dig->rssi_max = max_rssi; 1553f1d2b4d3SLarry Finger } 1554f1d2b4d3SLarry Finger 1555f1d2b4d3SLarry Finger static void rtl88e_set_next_mac_address_target(struct ieee80211_hw *hw) 1556f1d2b4d3SLarry Finger { 1557f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1558f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 1559f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1560f1d2b4d3SLarry Finger struct rtl_sta_info *drv_priv; 1561f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1562f1d2b4d3SLarry Finger u32 value32, i, j = 0; 1563f1d2b4d3SLarry Finger 1564f1d2b4d3SLarry Finger if (mac->link_state >= MAC80211_LINKED) { 1565f1d2b4d3SLarry Finger for (i = 0; i < ASSOCIATE_ENTRY_NUM; i++) { 1566f1d2b4d3SLarry Finger if ((pfat_table->train_idx + 1) == ASSOCIATE_ENTRY_NUM) 1567f1d2b4d3SLarry Finger pfat_table->train_idx = 0; 1568f1d2b4d3SLarry Finger else 1569f1d2b4d3SLarry Finger pfat_table->train_idx++; 1570f1d2b4d3SLarry Finger 1571f1d2b4d3SLarry Finger if (pfat_table->train_idx == 0) { 1572f1d2b4d3SLarry Finger value32 = (mac->mac_addr[5] << 8) | 1573f1d2b4d3SLarry Finger mac->mac_addr[4]; 1574f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_TRAIN_PARA2_11N, 1575f1d2b4d3SLarry Finger MASKLWORD, value32); 1576f1d2b4d3SLarry Finger 1577f1d2b4d3SLarry Finger value32 = (mac->mac_addr[3] << 24) | 1578f1d2b4d3SLarry Finger (mac->mac_addr[2] << 16) | 1579f1d2b4d3SLarry Finger (mac->mac_addr[1] << 8) | 1580f1d2b4d3SLarry Finger mac->mac_addr[0]; 1581f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_TRAIN_PARA1_11N, 1582f1d2b4d3SLarry Finger MASKDWORD, value32); 1583f1d2b4d3SLarry Finger break; 1584f1d2b4d3SLarry Finger } 1585f1d2b4d3SLarry Finger 1586f1d2b4d3SLarry Finger if (rtlpriv->mac80211.opmode != 1587f1d2b4d3SLarry Finger NL80211_IFTYPE_STATION) { 1588f1d2b4d3SLarry Finger spin_lock_bh(&rtlpriv->locks.entry_list_lock); 1589f1d2b4d3SLarry Finger list_for_each_entry(drv_priv, 1590f1d2b4d3SLarry Finger &rtlpriv->entry_list, list) { 1591f1d2b4d3SLarry Finger j++; 1592f1d2b4d3SLarry Finger if (j != pfat_table->train_idx) 1593f1d2b4d3SLarry Finger continue; 1594f1d2b4d3SLarry Finger 1595f1d2b4d3SLarry Finger value32 = (drv_priv->mac_addr[5] << 8) | 1596f1d2b4d3SLarry Finger drv_priv->mac_addr[4]; 1597f1d2b4d3SLarry Finger rtl_set_bbreg(hw, 1598f1d2b4d3SLarry Finger DM_REG_ANT_TRAIN_PARA2_11N, 1599f1d2b4d3SLarry Finger MASKLWORD, value32); 1600f1d2b4d3SLarry Finger 1601f1d2b4d3SLarry Finger value32 = (drv_priv->mac_addr[3] << 24) | 1602f1d2b4d3SLarry Finger (drv_priv->mac_addr[2] << 16) | 1603f1d2b4d3SLarry Finger (drv_priv->mac_addr[1] << 8) | 1604f1d2b4d3SLarry Finger drv_priv->mac_addr[0]; 1605f1d2b4d3SLarry Finger rtl_set_bbreg(hw, 1606f1d2b4d3SLarry Finger DM_REG_ANT_TRAIN_PARA1_11N, 1607f1d2b4d3SLarry Finger MASKDWORD, value32); 1608f1d2b4d3SLarry Finger break; 1609f1d2b4d3SLarry Finger } 1610f1d2b4d3SLarry Finger spin_unlock_bh(&rtlpriv->locks.entry_list_lock); 1611f1d2b4d3SLarry Finger /*find entry, break*/ 1612f1d2b4d3SLarry Finger if (j == pfat_table->train_idx) 1613f1d2b4d3SLarry Finger break; 1614f1d2b4d3SLarry Finger } 1615f1d2b4d3SLarry Finger } 1616f1d2b4d3SLarry Finger } 1617f1d2b4d3SLarry Finger } 1618f1d2b4d3SLarry Finger 1619f1d2b4d3SLarry Finger static void rtl88e_dm_fast_ant_training(struct ieee80211_hw *hw) 1620f1d2b4d3SLarry Finger { 1621f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1622f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1623f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1624f1d2b4d3SLarry Finger u32 i, max_rssi = 0; 1625f1d2b4d3SLarry Finger u8 target_ant = 2; 1626f1d2b4d3SLarry Finger bool bpkt_filter_match = false; 1627f1d2b4d3SLarry Finger 1628f1d2b4d3SLarry Finger if (pfat_table->fat_state == FAT_TRAINING_STATE) { 1629f1d2b4d3SLarry Finger for (i = 0; i < 7; i++) { 1630f1d2b4d3SLarry Finger if (pfat_table->ant_cnt[i] == 0) { 1631f1d2b4d3SLarry Finger pfat_table->ant_ave[i] = 0; 1632f1d2b4d3SLarry Finger } else { 1633f1d2b4d3SLarry Finger pfat_table->ant_ave[i] = 1634f1d2b4d3SLarry Finger pfat_table->ant_sum[i] / 1635f1d2b4d3SLarry Finger pfat_table->ant_cnt[i]; 1636f1d2b4d3SLarry Finger bpkt_filter_match = true; 1637f1d2b4d3SLarry Finger } 1638f1d2b4d3SLarry Finger 1639f1d2b4d3SLarry Finger if (pfat_table->ant_ave[i] > max_rssi) { 1640f1d2b4d3SLarry Finger max_rssi = pfat_table->ant_ave[i]; 1641f1d2b4d3SLarry Finger target_ant = (u8) i; 1642f1d2b4d3SLarry Finger } 1643f1d2b4d3SLarry Finger } 1644f1d2b4d3SLarry Finger 1645f1d2b4d3SLarry Finger if (bpkt_filter_match == false) { 1646f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_TXAGC_A_1_MCS32_11N, 1647f1d2b4d3SLarry Finger BIT(16), 0); 1648f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_IGI_A_11N, BIT(7), 0); 1649f1d2b4d3SLarry Finger } else { 1650f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_TXAGC_A_1_MCS32_11N, 1651f1d2b4d3SLarry Finger BIT(16), 0); 1652f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, BIT(8) | 1653f1d2b4d3SLarry Finger BIT(7) | BIT(6), target_ant); 1654f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_TX_ANT_CTRL_11N, 1655f1d2b4d3SLarry Finger BIT(21), 1); 1656f1d2b4d3SLarry Finger 1657f1d2b4d3SLarry Finger pfat_table->antsel_a[pfat_table->train_idx] = 1658f1d2b4d3SLarry Finger target_ant & BIT(0); 1659f1d2b4d3SLarry Finger pfat_table->antsel_b[pfat_table->train_idx] = 1660f1d2b4d3SLarry Finger (target_ant & BIT(1)) >> 1; 1661f1d2b4d3SLarry Finger pfat_table->antsel_c[pfat_table->train_idx] = 1662f1d2b4d3SLarry Finger (target_ant & BIT(2)) >> 2; 1663f1d2b4d3SLarry Finger 1664f1d2b4d3SLarry Finger if (target_ant == 0) 1665f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_IGI_A_11N, BIT(7), 0); 1666f1d2b4d3SLarry Finger } 1667f1d2b4d3SLarry Finger 1668f1d2b4d3SLarry Finger for (i = 0; i < 7; i++) { 1669f1d2b4d3SLarry Finger pfat_table->ant_sum[i] = 0; 1670f1d2b4d3SLarry Finger pfat_table->ant_cnt[i] = 0; 1671f1d2b4d3SLarry Finger } 1672f1d2b4d3SLarry Finger 1673f1d2b4d3SLarry Finger pfat_table->fat_state = FAT_NORMAL_STATE; 1674f1d2b4d3SLarry Finger return; 1675f1d2b4d3SLarry Finger } 1676f1d2b4d3SLarry Finger 1677f1d2b4d3SLarry Finger if (pfat_table->fat_state == FAT_NORMAL_STATE) { 1678f1d2b4d3SLarry Finger rtl88e_set_next_mac_address_target(hw); 1679f1d2b4d3SLarry Finger 1680f1d2b4d3SLarry Finger pfat_table->fat_state = FAT_TRAINING_STATE; 1681f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_TXAGC_A_1_MCS32_11N, BIT(16), 1); 1682f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_IGI_A_11N, BIT(7), 1); 1683f1d2b4d3SLarry Finger 1684f1d2b4d3SLarry Finger mod_timer(&rtlpriv->works.fast_antenna_training_timer, 1685f1d2b4d3SLarry Finger jiffies + MSECS(RTL_WATCH_DOG_TIME)); 1686f1d2b4d3SLarry Finger } 1687f1d2b4d3SLarry Finger } 1688f1d2b4d3SLarry Finger 16897c51d17cSKees Cook void rtl88e_dm_fast_antenna_training_callback(struct timer_list *t) 1690f1d2b4d3SLarry Finger { 16917c51d17cSKees Cook struct rtl_priv *rtlpriv = 16927c51d17cSKees Cook from_timer(rtlpriv, t, works.fast_antenna_training_timer); 16937c51d17cSKees Cook struct ieee80211_hw *hw = rtlpriv->hw; 1694f1d2b4d3SLarry Finger 1695f1d2b4d3SLarry Finger rtl88e_dm_fast_ant_training(hw); 1696f1d2b4d3SLarry Finger } 1697f1d2b4d3SLarry Finger 1698f1d2b4d3SLarry Finger static void rtl88e_dm_antenna_diversity(struct ieee80211_hw *hw) 1699f1d2b4d3SLarry Finger { 1700f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1701f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 1702f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 1703f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1704f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1705f1d2b4d3SLarry Finger 1706f1d2b4d3SLarry Finger if (mac->link_state < MAC80211_LINKED) { 1707f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_DIG, DBG_LOUD, "No Link\n"); 1708f1d2b4d3SLarry Finger if (pfat_table->becomelinked) { 1709f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_DIG, DBG_LOUD, 1710f1d2b4d3SLarry Finger "need to turn off HW AntDiv\n"); 1711f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_IGI_A_11N, BIT(7), 0); 1712f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_CCK_ANTDIV_PARA1_11N, 1713f1d2b4d3SLarry Finger BIT(15), 0); 1714f1d2b4d3SLarry Finger if (rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) 1715f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_TX_ANT_CTRL_11N, 1716f1d2b4d3SLarry Finger BIT(21), 0); 1717f1d2b4d3SLarry Finger pfat_table->becomelinked = 1718f1d2b4d3SLarry Finger (mac->link_state == MAC80211_LINKED) ? 1719f1d2b4d3SLarry Finger true : false; 1720f1d2b4d3SLarry Finger } 1721f1d2b4d3SLarry Finger return; 1722f1d2b4d3SLarry Finger } else { 1723f1d2b4d3SLarry Finger if (!pfat_table->becomelinked) { 1724f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_DIG, DBG_LOUD, 1725f1d2b4d3SLarry Finger "Need to turn on HW AntDiv\n"); 1726f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_IGI_A_11N, BIT(7), 1); 1727f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_CCK_ANTDIV_PARA1_11N, 1728f1d2b4d3SLarry Finger BIT(15), 1); 1729f1d2b4d3SLarry Finger if (rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) 1730f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_TX_ANT_CTRL_11N, 1731f1d2b4d3SLarry Finger BIT(21), 1); 1732f1d2b4d3SLarry Finger pfat_table->becomelinked = 1733f1d2b4d3SLarry Finger (mac->link_state >= MAC80211_LINKED) ? 1734f1d2b4d3SLarry Finger true : false; 1735f1d2b4d3SLarry Finger } 1736f1d2b4d3SLarry Finger } 1737f1d2b4d3SLarry Finger 1738f1d2b4d3SLarry Finger if ((rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) || 1739f1d2b4d3SLarry Finger (rtlefuse->antenna_div_type == CGCS_RX_HW_ANTDIV)) 1740f1d2b4d3SLarry Finger rtl88e_dm_hw_ant_div(hw); 1741f1d2b4d3SLarry Finger else if (rtlefuse->antenna_div_type == CG_TRX_SMART_ANTDIV) 1742f1d2b4d3SLarry Finger rtl88e_dm_fast_ant_training(hw); 1743f1d2b4d3SLarry Finger } 1744f1d2b4d3SLarry Finger 1745f1d2b4d3SLarry Finger void rtl88e_dm_init(struct ieee80211_hw *hw) 1746f1d2b4d3SLarry Finger { 1747f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1748f1d2b4d3SLarry Finger u32 cur_igvalue = rtl_get_bbreg(hw, ROFDM0_XAAGCCORE1, 0x7f); 1749f1d2b4d3SLarry Finger 1750f1d2b4d3SLarry Finger rtlpriv->dm.dm_type = DM_TYPE_BYDRIVER; 1751f1d2b4d3SLarry Finger rtl_dm_diginit(hw, cur_igvalue); 1752f1d2b4d3SLarry Finger rtl88e_dm_init_dynamic_txpower(hw); 1753f1d2b4d3SLarry Finger rtl88e_dm_init_edca_turbo(hw); 1754f1d2b4d3SLarry Finger rtl88e_dm_init_rate_adaptive_mask(hw); 1755f1d2b4d3SLarry Finger rtl88e_dm_init_txpower_tracking(hw); 1756f1d2b4d3SLarry Finger rtl92c_dm_init_dynamic_bb_powersaving(hw); 1757f1d2b4d3SLarry Finger rtl88e_dm_antenna_div_init(hw); 1758f1d2b4d3SLarry Finger } 1759f1d2b4d3SLarry Finger 1760f1d2b4d3SLarry Finger void rtl88e_dm_watchdog(struct ieee80211_hw *hw) 1761f1d2b4d3SLarry Finger { 1762f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1763f1d2b4d3SLarry Finger struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); 1764f1d2b4d3SLarry Finger bool fw_current_inpsmode = false; 1765f1d2b4d3SLarry Finger bool fw_ps_awake = true; 1766f1d2b4d3SLarry Finger 1767f1d2b4d3SLarry Finger rtlpriv->cfg->ops->get_hw_reg(hw, HW_VAR_FW_PSMODE_STATUS, 1768f1d2b4d3SLarry Finger (u8 *)(&fw_current_inpsmode)); 1769f1d2b4d3SLarry Finger rtlpriv->cfg->ops->get_hw_reg(hw, HW_VAR_FWLPS_RF_ON, 1770f1d2b4d3SLarry Finger (u8 *)(&fw_ps_awake)); 1771f1d2b4d3SLarry Finger if (ppsc->p2p_ps_info.p2p_ps_mode) 1772f1d2b4d3SLarry Finger fw_ps_awake = false; 1773f1d2b4d3SLarry Finger 1774204e2ab2SLarry Finger spin_lock(&rtlpriv->locks.rf_ps_lock); 1775f1d2b4d3SLarry Finger if ((ppsc->rfpwr_state == ERFON) && 1776f1d2b4d3SLarry Finger ((!fw_current_inpsmode) && fw_ps_awake) && 1777f1d2b4d3SLarry Finger (!ppsc->rfchange_inprogress)) { 1778f1d2b4d3SLarry Finger rtl88e_dm_pwdb_monitor(hw); 1779f1d2b4d3SLarry Finger rtl88e_dm_dig(hw); 1780f1d2b4d3SLarry Finger rtl88e_dm_false_alarm_counter_statistics(hw); 1781f1d2b4d3SLarry Finger rtl92c_dm_dynamic_txpower(hw); 1782f1d2b4d3SLarry Finger rtl88e_dm_check_txpower_tracking(hw); 1783f1d2b4d3SLarry Finger rtl88e_dm_refresh_rate_adaptive_mask(hw); 1784f1d2b4d3SLarry Finger rtl88e_dm_check_edca_turbo(hw); 1785f1d2b4d3SLarry Finger rtl88e_dm_antenna_diversity(hw); 1786f1d2b4d3SLarry Finger } 1787204e2ab2SLarry Finger spin_unlock(&rtlpriv->locks.rf_ps_lock); 1788f1d2b4d3SLarry Finger } 1789