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. */ 762073f8138Szhengbin if (!rtlpriv->dm.useramask) 763f1d2b4d3SLarry Finger rtl_write_byte(rtlpriv, 0x4fe, rtlpriv->dm.undec_sm_pwdb); 764f1d2b4d3SLarry Finger } 765f1d2b4d3SLarry Finger 766f1d2b4d3SLarry Finger void rtl88e_dm_init_edca_turbo(struct ieee80211_hw *hw) 767f1d2b4d3SLarry Finger { 768f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 769f1d2b4d3SLarry Finger 770f1d2b4d3SLarry Finger rtlpriv->dm.current_turbo_edca = false; 771f1d2b4d3SLarry Finger rtlpriv->dm.is_any_nonbepkts = false; 772f1d2b4d3SLarry Finger rtlpriv->dm.is_cur_rdlstate = false; 773f1d2b4d3SLarry Finger } 774f1d2b4d3SLarry Finger 775f1d2b4d3SLarry Finger static void rtl88e_dm_check_edca_turbo(struct ieee80211_hw *hw) 776f1d2b4d3SLarry Finger { 777f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 778f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 779f1d2b4d3SLarry Finger static u64 last_txok_cnt; 780f1d2b4d3SLarry Finger static u64 last_rxok_cnt; 781f1d2b4d3SLarry Finger static u32 last_bt_edca_ul; 782f1d2b4d3SLarry Finger static u32 last_bt_edca_dl; 783f1d2b4d3SLarry Finger u64 cur_txok_cnt = 0; 784f1d2b4d3SLarry Finger u64 cur_rxok_cnt = 0; 785f1d2b4d3SLarry Finger u32 edca_be_ul = 0x5ea42b; 786f1d2b4d3SLarry Finger u32 edca_be_dl = 0x5ea42b; 787f1d2b4d3SLarry Finger bool bt_change_edca = false; 788f1d2b4d3SLarry Finger 789f1d2b4d3SLarry Finger if ((last_bt_edca_ul != rtlpriv->btcoexist.bt_edca_ul) || 790f1d2b4d3SLarry Finger (last_bt_edca_dl != rtlpriv->btcoexist.bt_edca_dl)) { 791f1d2b4d3SLarry Finger rtlpriv->dm.current_turbo_edca = false; 792f1d2b4d3SLarry Finger last_bt_edca_ul = rtlpriv->btcoexist.bt_edca_ul; 793f1d2b4d3SLarry Finger last_bt_edca_dl = rtlpriv->btcoexist.bt_edca_dl; 794f1d2b4d3SLarry Finger } 795f1d2b4d3SLarry Finger 796f1d2b4d3SLarry Finger if (rtlpriv->btcoexist.bt_edca_ul != 0) { 797f1d2b4d3SLarry Finger edca_be_ul = rtlpriv->btcoexist.bt_edca_ul; 798f1d2b4d3SLarry Finger bt_change_edca = true; 799f1d2b4d3SLarry Finger } 800f1d2b4d3SLarry Finger 801f1d2b4d3SLarry Finger if (rtlpriv->btcoexist.bt_edca_dl != 0) { 802f1d2b4d3SLarry Finger edca_be_ul = rtlpriv->btcoexist.bt_edca_dl; 803f1d2b4d3SLarry Finger bt_change_edca = true; 804f1d2b4d3SLarry Finger } 805f1d2b4d3SLarry Finger 806f1d2b4d3SLarry Finger if (mac->link_state != MAC80211_LINKED) { 807f1d2b4d3SLarry Finger rtlpriv->dm.current_turbo_edca = false; 808f1d2b4d3SLarry Finger return; 809f1d2b4d3SLarry Finger } 810f1d2b4d3SLarry Finger if ((bt_change_edca) || 811f1d2b4d3SLarry Finger ((!rtlpriv->dm.is_any_nonbepkts) && 812f1d2b4d3SLarry Finger (!rtlpriv->dm.disable_framebursting))) { 813f1d2b4d3SLarry Finger 814f1d2b4d3SLarry Finger cur_txok_cnt = rtlpriv->stats.txbytesunicast - last_txok_cnt; 815f1d2b4d3SLarry Finger cur_rxok_cnt = rtlpriv->stats.rxbytesunicast - last_rxok_cnt; 816f1d2b4d3SLarry Finger 817f1d2b4d3SLarry Finger if (cur_rxok_cnt > 4 * cur_txok_cnt) { 818f1d2b4d3SLarry Finger if (!rtlpriv->dm.is_cur_rdlstate || 819f1d2b4d3SLarry Finger !rtlpriv->dm.current_turbo_edca) { 820f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, 821f1d2b4d3SLarry Finger REG_EDCA_BE_PARAM, 822f1d2b4d3SLarry Finger edca_be_dl); 823f1d2b4d3SLarry Finger rtlpriv->dm.is_cur_rdlstate = true; 824f1d2b4d3SLarry Finger } 825f1d2b4d3SLarry Finger } else { 826f1d2b4d3SLarry Finger if (rtlpriv->dm.is_cur_rdlstate || 827f1d2b4d3SLarry Finger !rtlpriv->dm.current_turbo_edca) { 828f1d2b4d3SLarry Finger rtl_write_dword(rtlpriv, 829f1d2b4d3SLarry Finger REG_EDCA_BE_PARAM, 830f1d2b4d3SLarry Finger edca_be_ul); 831f1d2b4d3SLarry Finger rtlpriv->dm.is_cur_rdlstate = false; 832f1d2b4d3SLarry Finger } 833f1d2b4d3SLarry Finger } 834f1d2b4d3SLarry Finger rtlpriv->dm.current_turbo_edca = true; 835f1d2b4d3SLarry Finger } else { 836f1d2b4d3SLarry Finger if (rtlpriv->dm.current_turbo_edca) { 837f1d2b4d3SLarry Finger u8 tmp = AC0_BE; 838f1d2b4d3SLarry Finger 839f1d2b4d3SLarry Finger rtlpriv->cfg->ops->set_hw_reg(hw, 840f1d2b4d3SLarry Finger HW_VAR_AC_PARAM, 841f1d2b4d3SLarry Finger &tmp); 842f1d2b4d3SLarry Finger rtlpriv->dm.current_turbo_edca = false; 843f1d2b4d3SLarry Finger } 844f1d2b4d3SLarry Finger } 845f1d2b4d3SLarry Finger 846f1d2b4d3SLarry Finger rtlpriv->dm.is_any_nonbepkts = false; 847f1d2b4d3SLarry Finger last_txok_cnt = rtlpriv->stats.txbytesunicast; 848f1d2b4d3SLarry Finger last_rxok_cnt = rtlpriv->stats.rxbytesunicast; 849f1d2b4d3SLarry Finger } 850f1d2b4d3SLarry Finger 851f1d2b4d3SLarry Finger static void dm_txpower_track_cb_therm(struct ieee80211_hw *hw) 852f1d2b4d3SLarry Finger { 853f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 854f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 855f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 856f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 857f1d2b4d3SLarry Finger u8 thermalvalue = 0, delta, delta_lck, delta_iqk, offset; 858f1d2b4d3SLarry Finger u8 thermalvalue_avg_count = 0; 859f1d2b4d3SLarry Finger u32 thermalvalue_avg = 0; 860f1d2b4d3SLarry Finger long ele_d, temp_cck; 86108aba42fSArnd Bergmann s8 ofdm_index[2], cck_index = 0, 862f1d2b4d3SLarry Finger ofdm_index_old[2] = {0, 0}, cck_index_old = 0; 863f1d2b4d3SLarry Finger int i = 0; 864f1d2b4d3SLarry Finger /*bool is2t = false;*/ 865f1d2b4d3SLarry Finger 866f1d2b4d3SLarry Finger u8 ofdm_min_index = 6, rf = 1; 867f1d2b4d3SLarry Finger /*u8 index_for_channel;*/ 868f1d2b4d3SLarry Finger enum _power_dec_inc {power_dec, power_inc}; 869f1d2b4d3SLarry Finger 870f1d2b4d3SLarry Finger /*0.1 the following TWO tables decide the 871f1d2b4d3SLarry Finger *final index of OFDM/CCK swing table 872f1d2b4d3SLarry Finger */ 87340c66c68SJoe Perches static const s8 delta_swing_table_idx[2][15] = { 874f1d2b4d3SLarry Finger {0, 0, 2, 3, 4, 4, 5, 6, 7, 7, 8, 9, 10, 10, 11}, 875f1d2b4d3SLarry Finger {0, 0, -1, -2, -3, -4, -4, -4, -4, -5, -7, -8, -9, -9, -10} 876f1d2b4d3SLarry Finger }; 87740c66c68SJoe Perches static const u8 thermal_threshold[2][15] = { 878f1d2b4d3SLarry Finger {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 27}, 879f1d2b4d3SLarry Finger {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 25, 25, 25} 880f1d2b4d3SLarry Finger }; 881f1d2b4d3SLarry Finger 882f1d2b4d3SLarry Finger /*Initilization (7 steps in total) */ 883f1d2b4d3SLarry Finger rtlpriv->dm.txpower_trackinginit = true; 884f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD, 885f1d2b4d3SLarry Finger "dm_txpower_track_cb_therm\n"); 886f1d2b4d3SLarry Finger 887f1d2b4d3SLarry Finger thermalvalue = (u8)rtl_get_rfreg(hw, RF90_PATH_A, RF_T_METER, 888f1d2b4d3SLarry Finger 0xfc00); 889f1d2b4d3SLarry Finger if (!thermalvalue) 890f1d2b4d3SLarry Finger return; 891f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD, 892f1d2b4d3SLarry Finger "Readback Thermal Meter = 0x%x pre thermal meter 0x%x eeprom_thermalmeter 0x%x\n", 893f1d2b4d3SLarry Finger thermalvalue, rtlpriv->dm.thermalvalue, 894f1d2b4d3SLarry Finger rtlefuse->eeprom_thermalmeter); 895f1d2b4d3SLarry Finger 896f1d2b4d3SLarry Finger /*1. Query OFDM Default Setting: Path A*/ 897f1d2b4d3SLarry Finger ele_d = rtl_get_bbreg(hw, ROFDM0_XATXIQIMBALANCE, MASKDWORD) & 898f1d2b4d3SLarry Finger MASKOFDM_D; 899f1d2b4d3SLarry Finger for (i = 0; i < OFDM_TABLE_LENGTH; i++) { 900f1d2b4d3SLarry Finger if (ele_d == (ofdmswing_table[i] & MASKOFDM_D)) { 901f1d2b4d3SLarry Finger ofdm_index_old[0] = (u8)i; 902f1d2b4d3SLarry Finger rtldm->swing_idx_ofdm_base[RF90_PATH_A] = (u8)i; 903f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD, 904f1d2b4d3SLarry Finger "Initial pathA ele_d reg0x%x = 0x%lx, ofdm_index = 0x%x\n", 905f1d2b4d3SLarry Finger ROFDM0_XATXIQIMBALANCE, 906f1d2b4d3SLarry Finger ele_d, ofdm_index_old[0]); 907f1d2b4d3SLarry Finger break; 908f1d2b4d3SLarry Finger } 909f1d2b4d3SLarry Finger } 910f1d2b4d3SLarry Finger 911f1d2b4d3SLarry Finger /*2.Query CCK default setting From 0xa24*/ 912f1d2b4d3SLarry Finger temp_cck = rtl_get_bbreg(hw, RCCK0_TXFILTER2, MASKDWORD) & MASKCCK; 913f1d2b4d3SLarry Finger for (i = 0; i < CCK_TABLE_LENGTH; i++) { 914f1d2b4d3SLarry Finger if (rtlpriv->dm.cck_inch14) { 915f1d2b4d3SLarry Finger if (memcmp(&temp_cck, &cck_tbl_ch14[i][2], 4) == 0) { 916f1d2b4d3SLarry Finger cck_index_old = (u8)i; 917f1d2b4d3SLarry Finger rtldm->swing_idx_cck_base = (u8)i; 918f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, 919f1d2b4d3SLarry Finger DBG_LOUD, 920f1d2b4d3SLarry Finger "Initial reg0x%x = 0x%lx, cck_index = 0x%x, ch 14 %d\n", 921f1d2b4d3SLarry Finger RCCK0_TXFILTER2, temp_cck, 922f1d2b4d3SLarry Finger cck_index_old, 923f1d2b4d3SLarry Finger rtlpriv->dm.cck_inch14); 924f1d2b4d3SLarry Finger break; 925f1d2b4d3SLarry Finger } 926f1d2b4d3SLarry Finger } else { 927f1d2b4d3SLarry Finger if (memcmp(&temp_cck, &cck_tbl_ch1_13[i][2], 4) == 0) { 928f1d2b4d3SLarry Finger cck_index_old = (u8)i; 929f1d2b4d3SLarry Finger rtldm->swing_idx_cck_base = (u8)i; 930f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, 931f1d2b4d3SLarry Finger DBG_LOUD, 932f1d2b4d3SLarry Finger "Initial reg0x%x = 0x%lx, cck_index = 0x%x, ch14 %d\n", 933f1d2b4d3SLarry Finger RCCK0_TXFILTER2, temp_cck, 934f1d2b4d3SLarry Finger cck_index_old, 935f1d2b4d3SLarry Finger rtlpriv->dm.cck_inch14); 936f1d2b4d3SLarry Finger break; 937f1d2b4d3SLarry Finger } 938f1d2b4d3SLarry Finger } 939f1d2b4d3SLarry Finger } 940f1d2b4d3SLarry Finger 941f1d2b4d3SLarry Finger /*3 Initialize ThermalValues of RFCalibrateInfo*/ 942f1d2b4d3SLarry Finger if (!rtldm->thermalvalue) { 943f1d2b4d3SLarry Finger rtlpriv->dm.thermalvalue = rtlefuse->eeprom_thermalmeter; 944f1d2b4d3SLarry Finger rtlpriv->dm.thermalvalue_lck = thermalvalue; 945f1d2b4d3SLarry Finger rtlpriv->dm.thermalvalue_iqk = thermalvalue; 946f1d2b4d3SLarry Finger for (i = 0; i < rf; i++) 947f1d2b4d3SLarry Finger rtlpriv->dm.ofdm_index[i] = ofdm_index_old[i]; 948f1d2b4d3SLarry Finger rtlpriv->dm.cck_index = cck_index_old; 949f1d2b4d3SLarry Finger } 950f1d2b4d3SLarry Finger 951f1d2b4d3SLarry Finger /*4 Calculate average thermal meter*/ 952f1d2b4d3SLarry Finger rtldm->thermalvalue_avg[rtldm->thermalvalue_avg_index] = thermalvalue; 953f1d2b4d3SLarry Finger rtldm->thermalvalue_avg_index++; 954f1d2b4d3SLarry Finger if (rtldm->thermalvalue_avg_index == AVG_THERMAL_NUM_88E) 955f1d2b4d3SLarry Finger rtldm->thermalvalue_avg_index = 0; 956f1d2b4d3SLarry Finger 957f1d2b4d3SLarry Finger for (i = 0; i < AVG_THERMAL_NUM_88E; i++) { 958f1d2b4d3SLarry Finger if (rtldm->thermalvalue_avg[i]) { 959f1d2b4d3SLarry Finger thermalvalue_avg += rtldm->thermalvalue_avg[i]; 960f1d2b4d3SLarry Finger thermalvalue_avg_count++; 961f1d2b4d3SLarry Finger } 962f1d2b4d3SLarry Finger } 963f1d2b4d3SLarry Finger 964f1d2b4d3SLarry Finger if (thermalvalue_avg_count) 965f1d2b4d3SLarry Finger thermalvalue = (u8)(thermalvalue_avg / thermalvalue_avg_count); 966f1d2b4d3SLarry Finger 967f1d2b4d3SLarry Finger /* 5 Calculate delta, delta_LCK, delta_IQK.*/ 968f1d2b4d3SLarry Finger if (rtlhal->reloadtxpowerindex) { 969f1d2b4d3SLarry Finger delta = (thermalvalue > rtlefuse->eeprom_thermalmeter) ? 970f1d2b4d3SLarry Finger (thermalvalue - rtlefuse->eeprom_thermalmeter) : 971f1d2b4d3SLarry Finger (rtlefuse->eeprom_thermalmeter - thermalvalue); 972f1d2b4d3SLarry Finger rtlhal->reloadtxpowerindex = false; 973f1d2b4d3SLarry Finger rtlpriv->dm.done_txpower = false; 974f1d2b4d3SLarry Finger } else if (rtlpriv->dm.done_txpower) { 975f1d2b4d3SLarry Finger delta = (thermalvalue > rtlpriv->dm.thermalvalue) ? 976f1d2b4d3SLarry Finger (thermalvalue - rtlpriv->dm.thermalvalue) : 977f1d2b4d3SLarry Finger (rtlpriv->dm.thermalvalue - thermalvalue); 978f1d2b4d3SLarry Finger } else { 979f1d2b4d3SLarry Finger delta = (thermalvalue > rtlefuse->eeprom_thermalmeter) ? 980f1d2b4d3SLarry Finger (thermalvalue - rtlefuse->eeprom_thermalmeter) : 981f1d2b4d3SLarry Finger (rtlefuse->eeprom_thermalmeter - thermalvalue); 982f1d2b4d3SLarry Finger } 983f1d2b4d3SLarry Finger delta_lck = (thermalvalue > rtlpriv->dm.thermalvalue_lck) ? 984f1d2b4d3SLarry Finger (thermalvalue - rtlpriv->dm.thermalvalue_lck) : 985f1d2b4d3SLarry Finger (rtlpriv->dm.thermalvalue_lck - thermalvalue); 986f1d2b4d3SLarry Finger delta_iqk = (thermalvalue > rtlpriv->dm.thermalvalue_iqk) ? 987f1d2b4d3SLarry Finger (thermalvalue - rtlpriv->dm.thermalvalue_iqk) : 988f1d2b4d3SLarry Finger (rtlpriv->dm.thermalvalue_iqk - thermalvalue); 989f1d2b4d3SLarry Finger 990f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD, 991f1d2b4d3SLarry 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", 992f1d2b4d3SLarry Finger thermalvalue, rtlpriv->dm.thermalvalue, 993f1d2b4d3SLarry Finger rtlefuse->eeprom_thermalmeter, delta, delta_lck, 994f1d2b4d3SLarry Finger delta_iqk); 995f1d2b4d3SLarry Finger /* 6 If necessary, do LCK.*/ 996f1d2b4d3SLarry Finger if (delta_lck >= 8) { 997f1d2b4d3SLarry Finger rtlpriv->dm.thermalvalue_lck = thermalvalue; 998f1d2b4d3SLarry Finger rtl88e_phy_lc_calibrate(hw); 999f1d2b4d3SLarry Finger } 1000f1d2b4d3SLarry Finger 1001f1d2b4d3SLarry Finger /* 7 If necessary, move the index of 1002f1d2b4d3SLarry Finger * swing table to adjust Tx power. 1003f1d2b4d3SLarry Finger */ 1004f1d2b4d3SLarry Finger if (delta > 0 && rtlpriv->dm.txpower_track_control) { 1005f1d2b4d3SLarry Finger delta = (thermalvalue > rtlefuse->eeprom_thermalmeter) ? 1006f1d2b4d3SLarry Finger (thermalvalue - rtlefuse->eeprom_thermalmeter) : 1007f1d2b4d3SLarry Finger (rtlefuse->eeprom_thermalmeter - thermalvalue); 1008f1d2b4d3SLarry Finger 1009f1d2b4d3SLarry Finger /* 7.1 Get the final CCK_index and OFDM_index for each 1010f1d2b4d3SLarry Finger * swing table. 1011f1d2b4d3SLarry Finger */ 1012f1d2b4d3SLarry Finger if (thermalvalue > rtlefuse->eeprom_thermalmeter) { 1013f1d2b4d3SLarry Finger CAL_SWING_OFF(offset, power_inc, INDEX_MAPPING_NUM, 1014f1d2b4d3SLarry Finger delta); 1015f1d2b4d3SLarry Finger for (i = 0; i < rf; i++) 1016f1d2b4d3SLarry Finger ofdm_index[i] = 1017f1d2b4d3SLarry Finger rtldm->ofdm_index[i] + 1018f1d2b4d3SLarry Finger delta_swing_table_idx[power_inc][offset]; 1019f1d2b4d3SLarry Finger cck_index = rtldm->cck_index + 1020f1d2b4d3SLarry Finger delta_swing_table_idx[power_inc][offset]; 1021f1d2b4d3SLarry Finger } else { 1022f1d2b4d3SLarry Finger CAL_SWING_OFF(offset, power_dec, INDEX_MAPPING_NUM, 1023f1d2b4d3SLarry Finger delta); 1024f1d2b4d3SLarry Finger for (i = 0; i < rf; i++) 1025f1d2b4d3SLarry Finger ofdm_index[i] = 1026f1d2b4d3SLarry Finger rtldm->ofdm_index[i] + 1027f1d2b4d3SLarry Finger delta_swing_table_idx[power_dec][offset]; 1028f1d2b4d3SLarry Finger cck_index = rtldm->cck_index + 1029f1d2b4d3SLarry Finger delta_swing_table_idx[power_dec][offset]; 1030f1d2b4d3SLarry Finger } 1031f1d2b4d3SLarry Finger 1032f1d2b4d3SLarry Finger /* 7.2 Handle boundary conditions of index.*/ 1033f1d2b4d3SLarry Finger for (i = 0; i < rf; i++) { 1034f1d2b4d3SLarry Finger if (ofdm_index[i] > OFDM_TABLE_SIZE-1) 1035f1d2b4d3SLarry Finger ofdm_index[i] = OFDM_TABLE_SIZE-1; 1036f1d2b4d3SLarry Finger else if (rtldm->ofdm_index[i] < ofdm_min_index) 1037f1d2b4d3SLarry Finger ofdm_index[i] = ofdm_min_index; 1038f1d2b4d3SLarry Finger } 1039f1d2b4d3SLarry Finger 1040f1d2b4d3SLarry Finger if (cck_index > CCK_TABLE_SIZE-1) 1041f1d2b4d3SLarry Finger cck_index = CCK_TABLE_SIZE-1; 1042f1d2b4d3SLarry Finger else if (cck_index < 0) 1043f1d2b4d3SLarry Finger cck_index = 0; 1044f1d2b4d3SLarry Finger 1045f1d2b4d3SLarry Finger /*7.3Configure the Swing Table to adjust Tx Power.*/ 1046f1d2b4d3SLarry Finger if (rtlpriv->dm.txpower_track_control) { 1047f1d2b4d3SLarry Finger rtldm->done_txpower = true; 1048f1d2b4d3SLarry Finger rtldm->swing_idx_ofdm[RF90_PATH_A] = 1049f1d2b4d3SLarry Finger (u8)ofdm_index[RF90_PATH_A]; 1050f1d2b4d3SLarry Finger rtldm->swing_idx_cck = cck_index; 1051f1d2b4d3SLarry Finger if (rtldm->swing_idx_ofdm_cur != 1052f1d2b4d3SLarry Finger rtldm->swing_idx_ofdm[0]) { 1053f1d2b4d3SLarry Finger rtldm->swing_idx_ofdm_cur = 1054f1d2b4d3SLarry Finger rtldm->swing_idx_ofdm[0]; 1055f1d2b4d3SLarry Finger rtldm->swing_flag_ofdm = true; 1056f1d2b4d3SLarry Finger } 1057f1d2b4d3SLarry Finger 1058f1d2b4d3SLarry Finger if (rtldm->swing_idx_cck_cur != rtldm->swing_idx_cck) { 1059f1d2b4d3SLarry Finger rtldm->swing_idx_cck_cur = rtldm->swing_idx_cck; 1060f1d2b4d3SLarry Finger rtldm->swing_flag_cck = true; 1061f1d2b4d3SLarry Finger } 1062f1d2b4d3SLarry Finger 1063f1d2b4d3SLarry Finger dm_tx_pwr_track_set_pwr(hw, TXAGC, 0, 0); 1064f1d2b4d3SLarry Finger } 1065f1d2b4d3SLarry Finger } 1066f1d2b4d3SLarry Finger 1067f1d2b4d3SLarry Finger if (delta_iqk >= 8) { 1068f1d2b4d3SLarry Finger rtlpriv->dm.thermalvalue_iqk = thermalvalue; 1069f1d2b4d3SLarry Finger rtl88e_phy_iq_calibrate(hw, false); 1070f1d2b4d3SLarry Finger } 1071f1d2b4d3SLarry Finger 1072f1d2b4d3SLarry Finger if (rtldm->txpower_track_control) 1073f1d2b4d3SLarry Finger rtldm->thermalvalue = thermalvalue; 1074f1d2b4d3SLarry Finger rtldm->txpowercount = 0; 1075f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD, "end\n"); 1076f1d2b4d3SLarry Finger } 1077f1d2b4d3SLarry Finger 1078f1d2b4d3SLarry Finger static void rtl88e_dm_init_txpower_tracking(struct ieee80211_hw *hw) 1079f1d2b4d3SLarry Finger { 1080f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1081f1d2b4d3SLarry Finger 1082f1d2b4d3SLarry Finger rtlpriv->dm.txpower_tracking = true; 1083f1d2b4d3SLarry Finger rtlpriv->dm.txpower_trackinginit = false; 1084f1d2b4d3SLarry Finger rtlpriv->dm.txpowercount = 0; 1085f1d2b4d3SLarry Finger rtlpriv->dm.txpower_track_control = true; 1086f1d2b4d3SLarry Finger 1087f1d2b4d3SLarry Finger rtlpriv->dm.swing_idx_ofdm[RF90_PATH_A] = 12; 1088f1d2b4d3SLarry Finger rtlpriv->dm.swing_idx_ofdm_cur = 12; 1089f1d2b4d3SLarry Finger rtlpriv->dm.swing_flag_ofdm = false; 1090f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD, 1091f1d2b4d3SLarry Finger "rtlpriv->dm.txpower_tracking = %d\n", 1092f1d2b4d3SLarry Finger rtlpriv->dm.txpower_tracking); 1093f1d2b4d3SLarry Finger } 1094f1d2b4d3SLarry Finger 1095f1d2b4d3SLarry Finger void rtl88e_dm_check_txpower_tracking(struct ieee80211_hw *hw) 1096f1d2b4d3SLarry Finger { 1097f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1098f1d2b4d3SLarry Finger 1099f1d2b4d3SLarry Finger if (!rtlpriv->dm.txpower_tracking) 1100f1d2b4d3SLarry Finger return; 1101f1d2b4d3SLarry Finger 1102f1d2b4d3SLarry Finger if (!rtlpriv->dm.tm_trigger) { 1103f1d2b4d3SLarry Finger rtl_set_rfreg(hw, RF90_PATH_A, RF_T_METER, BIT(17)|BIT(16), 1104f1d2b4d3SLarry Finger 0x03); 1105f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD, 1106f1d2b4d3SLarry Finger "Trigger 88E Thermal Meter!!\n"); 1107f1d2b4d3SLarry Finger rtlpriv->dm.tm_trigger = 1; 1108f1d2b4d3SLarry Finger return; 1109f1d2b4d3SLarry Finger } else { 1110f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD, 1111f1d2b4d3SLarry Finger "Schedule TxPowerTracking !!\n"); 1112f1d2b4d3SLarry Finger dm_txpower_track_cb_therm(hw); 1113f1d2b4d3SLarry Finger rtlpriv->dm.tm_trigger = 0; 1114f1d2b4d3SLarry Finger } 1115f1d2b4d3SLarry Finger } 1116f1d2b4d3SLarry Finger 1117f1d2b4d3SLarry Finger void rtl88e_dm_init_rate_adaptive_mask(struct ieee80211_hw *hw) 1118f1d2b4d3SLarry Finger { 1119f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1120f1d2b4d3SLarry Finger struct rate_adaptive *p_ra = &rtlpriv->ra; 1121f1d2b4d3SLarry Finger 1122f1d2b4d3SLarry Finger p_ra->ratr_state = DM_RATR_STA_INIT; 1123f1d2b4d3SLarry Finger p_ra->pre_ratr_state = DM_RATR_STA_INIT; 1124f1d2b4d3SLarry Finger 1125f1d2b4d3SLarry Finger if (rtlpriv->dm.dm_type == DM_TYPE_BYDRIVER) 1126f1d2b4d3SLarry Finger rtlpriv->dm.useramask = true; 1127f1d2b4d3SLarry Finger else 1128f1d2b4d3SLarry Finger rtlpriv->dm.useramask = false; 1129f1d2b4d3SLarry Finger } 1130f1d2b4d3SLarry Finger 1131f1d2b4d3SLarry Finger static void rtl88e_dm_refresh_rate_adaptive_mask(struct ieee80211_hw *hw) 1132f1d2b4d3SLarry Finger { 1133f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1134f1d2b4d3SLarry Finger struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 1135f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 1136f1d2b4d3SLarry Finger struct rate_adaptive *p_ra = &rtlpriv->ra; 1137f1d2b4d3SLarry Finger u32 low_rssithresh_for_ra, high_rssithresh_for_ra; 1138f1d2b4d3SLarry Finger struct ieee80211_sta *sta = NULL; 1139f1d2b4d3SLarry Finger 1140f1d2b4d3SLarry Finger if (is_hal_stop(rtlhal)) { 1141f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_RATE, DBG_LOUD, 1142f1d2b4d3SLarry Finger "driver is going to unload\n"); 1143f1d2b4d3SLarry Finger return; 1144f1d2b4d3SLarry Finger } 1145f1d2b4d3SLarry Finger 1146f1d2b4d3SLarry Finger if (!rtlpriv->dm.useramask) { 1147f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_RATE, DBG_LOUD, 1148f1d2b4d3SLarry Finger "driver does not control rate adaptive mask\n"); 1149f1d2b4d3SLarry Finger return; 1150f1d2b4d3SLarry Finger } 1151f1d2b4d3SLarry Finger 1152f1d2b4d3SLarry Finger if (mac->link_state == MAC80211_LINKED && 1153f1d2b4d3SLarry Finger mac->opmode == NL80211_IFTYPE_STATION) { 1154f1d2b4d3SLarry Finger switch (p_ra->pre_ratr_state) { 1155f1d2b4d3SLarry Finger case DM_RATR_STA_HIGH: 1156f1d2b4d3SLarry Finger high_rssithresh_for_ra = 50; 1157f1d2b4d3SLarry Finger low_rssithresh_for_ra = 20; 1158f1d2b4d3SLarry Finger break; 1159f1d2b4d3SLarry Finger case DM_RATR_STA_MIDDLE: 1160f1d2b4d3SLarry Finger high_rssithresh_for_ra = 55; 1161f1d2b4d3SLarry Finger low_rssithresh_for_ra = 20; 1162f1d2b4d3SLarry Finger break; 1163f1d2b4d3SLarry Finger case DM_RATR_STA_LOW: 1164f1d2b4d3SLarry Finger high_rssithresh_for_ra = 50; 1165f1d2b4d3SLarry Finger low_rssithresh_for_ra = 25; 1166f1d2b4d3SLarry Finger break; 1167f1d2b4d3SLarry Finger default: 1168f1d2b4d3SLarry Finger high_rssithresh_for_ra = 50; 1169f1d2b4d3SLarry Finger low_rssithresh_for_ra = 20; 1170f1d2b4d3SLarry Finger break; 1171f1d2b4d3SLarry Finger } 1172f1d2b4d3SLarry Finger 1173f1d2b4d3SLarry Finger if (rtlpriv->dm.undec_sm_pwdb > 1174f1d2b4d3SLarry Finger (long)high_rssithresh_for_ra) 1175f1d2b4d3SLarry Finger p_ra->ratr_state = DM_RATR_STA_HIGH; 1176f1d2b4d3SLarry Finger else if (rtlpriv->dm.undec_sm_pwdb > 1177f1d2b4d3SLarry Finger (long)low_rssithresh_for_ra) 1178f1d2b4d3SLarry Finger p_ra->ratr_state = DM_RATR_STA_MIDDLE; 1179f1d2b4d3SLarry Finger else 1180f1d2b4d3SLarry Finger p_ra->ratr_state = DM_RATR_STA_LOW; 1181f1d2b4d3SLarry Finger 1182f1d2b4d3SLarry Finger if (p_ra->pre_ratr_state != p_ra->ratr_state) { 1183f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_RATE, DBG_LOUD, 1184f1d2b4d3SLarry Finger "RSSI = %ld\n", 1185f1d2b4d3SLarry Finger rtlpriv->dm.undec_sm_pwdb); 1186f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_RATE, DBG_LOUD, 1187f1d2b4d3SLarry Finger "RSSI_LEVEL = %d\n", p_ra->ratr_state); 1188f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_RATE, DBG_LOUD, 1189f1d2b4d3SLarry Finger "PreState = %d, CurState = %d\n", 1190f1d2b4d3SLarry Finger p_ra->pre_ratr_state, p_ra->ratr_state); 1191f1d2b4d3SLarry Finger 1192f1d2b4d3SLarry Finger rcu_read_lock(); 1193f1d2b4d3SLarry Finger sta = rtl_find_sta(hw, mac->bssid); 1194f1d2b4d3SLarry Finger if (sta) 1195f1d2b4d3SLarry Finger rtlpriv->cfg->ops->update_rate_tbl(hw, sta, 11961d22b177SPing-Ke Shih p_ra->ratr_state, 11971d22b177SPing-Ke Shih true); 1198f1d2b4d3SLarry Finger rcu_read_unlock(); 1199f1d2b4d3SLarry Finger 1200f1d2b4d3SLarry Finger p_ra->pre_ratr_state = p_ra->ratr_state; 1201f1d2b4d3SLarry Finger } 1202f1d2b4d3SLarry Finger } 1203f1d2b4d3SLarry Finger } 1204f1d2b4d3SLarry Finger 1205f1d2b4d3SLarry Finger static void rtl92c_dm_init_dynamic_bb_powersaving(struct ieee80211_hw *hw) 1206f1d2b4d3SLarry Finger { 1207f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1208f1d2b4d3SLarry Finger struct ps_t *dm_pstable = &rtlpriv->dm_pstable; 1209f1d2b4d3SLarry Finger 1210f1d2b4d3SLarry Finger dm_pstable->pre_ccastate = CCA_MAX; 1211f1d2b4d3SLarry Finger dm_pstable->cur_ccasate = CCA_MAX; 1212f1d2b4d3SLarry Finger dm_pstable->pre_rfstate = RF_MAX; 1213f1d2b4d3SLarry Finger dm_pstable->cur_rfstate = RF_MAX; 1214f1d2b4d3SLarry Finger dm_pstable->rssi_val_min = 0; 1215f1d2b4d3SLarry Finger } 1216f1d2b4d3SLarry Finger 1217f1d2b4d3SLarry Finger static void rtl88e_dm_update_rx_idle_ant(struct ieee80211_hw *hw, 1218f1d2b4d3SLarry Finger u8 ant) 1219f1d2b4d3SLarry Finger { 1220f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1221f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 1222f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1223f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1224f1d2b4d3SLarry Finger u32 default_ant, optional_ant; 1225f1d2b4d3SLarry Finger 1226f1d2b4d3SLarry Finger if (pfat_table->rx_idle_ant != ant) { 1227f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, 1228f1d2b4d3SLarry Finger "need to update rx idle ant\n"); 1229f1d2b4d3SLarry Finger if (ant == MAIN_ANT) { 1230f1d2b4d3SLarry Finger default_ant = 1231f1d2b4d3SLarry Finger (pfat_table->rx_idle_ant == CG_TRX_HW_ANTDIV) ? 1232f1d2b4d3SLarry Finger MAIN_ANT_CG_TRX : MAIN_ANT_CGCS_RX; 1233f1d2b4d3SLarry Finger optional_ant = 1234f1d2b4d3SLarry Finger (pfat_table->rx_idle_ant == CG_TRX_HW_ANTDIV) ? 1235f1d2b4d3SLarry Finger AUX_ANT_CG_TRX : AUX_ANT_CGCS_RX; 1236f1d2b4d3SLarry Finger } else { 1237f1d2b4d3SLarry Finger default_ant = 1238f1d2b4d3SLarry Finger (pfat_table->rx_idle_ant == CG_TRX_HW_ANTDIV) ? 1239f1d2b4d3SLarry Finger AUX_ANT_CG_TRX : AUX_ANT_CGCS_RX; 1240f1d2b4d3SLarry Finger optional_ant = 1241f1d2b4d3SLarry Finger (pfat_table->rx_idle_ant == CG_TRX_HW_ANTDIV) ? 1242f1d2b4d3SLarry Finger MAIN_ANT_CG_TRX : MAIN_ANT_CGCS_RX; 1243f1d2b4d3SLarry Finger } 1244f1d2b4d3SLarry Finger 1245f1d2b4d3SLarry Finger if (rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) { 1246f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, 1247f1d2b4d3SLarry Finger BIT(5) | BIT(4) | BIT(3), default_ant); 1248f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, 1249f1d2b4d3SLarry Finger BIT(8) | BIT(7) | BIT(6), optional_ant); 1250f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANTSEL_CTRL_11N, 1251f1d2b4d3SLarry Finger BIT(14) | BIT(13) | BIT(12), 1252f1d2b4d3SLarry Finger default_ant); 1253f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RESP_TX_11N, 1254f1d2b4d3SLarry Finger BIT(6) | BIT(7), default_ant); 1255f1d2b4d3SLarry Finger } else if (rtlefuse->antenna_div_type == CGCS_RX_HW_ANTDIV) { 1256f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, 1257f1d2b4d3SLarry Finger BIT(5) | BIT(4) | BIT(3), default_ant); 1258f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, 1259f1d2b4d3SLarry Finger BIT(8) | BIT(7) | BIT(6), optional_ant); 1260f1d2b4d3SLarry Finger } 1261f1d2b4d3SLarry Finger } 1262f1d2b4d3SLarry Finger pfat_table->rx_idle_ant = ant; 1263f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "RxIdleAnt %s\n", 1264f1d2b4d3SLarry Finger (ant == MAIN_ANT) ? ("MAIN_ANT") : ("AUX_ANT")); 1265f1d2b4d3SLarry Finger } 1266f1d2b4d3SLarry Finger 1267f1d2b4d3SLarry Finger static void rtl88e_dm_update_tx_ant(struct ieee80211_hw *hw, 1268f1d2b4d3SLarry Finger u8 ant, u32 mac_id) 1269f1d2b4d3SLarry Finger { 1270f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1271f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1272f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1273f1d2b4d3SLarry Finger u8 target_ant; 1274f1d2b4d3SLarry Finger 1275f1d2b4d3SLarry Finger if (ant == MAIN_ANT) 1276f1d2b4d3SLarry Finger target_ant = MAIN_ANT_CG_TRX; 1277f1d2b4d3SLarry Finger else 1278f1d2b4d3SLarry Finger target_ant = AUX_ANT_CG_TRX; 1279f1d2b4d3SLarry Finger 1280f1d2b4d3SLarry Finger pfat_table->antsel_a[mac_id] = target_ant & BIT(0); 1281f1d2b4d3SLarry Finger pfat_table->antsel_b[mac_id] = (target_ant & BIT(1)) >> 1; 1282f1d2b4d3SLarry Finger pfat_table->antsel_c[mac_id] = (target_ant & BIT(2)) >> 2; 1283f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "txfrominfo target ant %s\n", 1284f1d2b4d3SLarry Finger (ant == MAIN_ANT) ? ("MAIN_ANT") : ("AUX_ANT")); 1285f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "antsel_tr_mux = 3'b%d%d%d\n", 1286f1d2b4d3SLarry Finger pfat_table->antsel_c[mac_id], 1287f1d2b4d3SLarry Finger pfat_table->antsel_b[mac_id], 1288f1d2b4d3SLarry Finger pfat_table->antsel_a[mac_id]); 1289f1d2b4d3SLarry Finger } 1290f1d2b4d3SLarry Finger 1291f1d2b4d3SLarry Finger static void rtl88e_dm_rx_hw_antena_div_init(struct ieee80211_hw *hw) 1292f1d2b4d3SLarry Finger { 1293f1d2b4d3SLarry Finger u32 value32; 1294f1d2b4d3SLarry Finger 1295f1d2b4d3SLarry Finger /*MAC Setting*/ 1296f1d2b4d3SLarry Finger value32 = rtl_get_bbreg(hw, DM_REG_ANTSEL_PIN_11N, MASKDWORD); 1297f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANTSEL_PIN_11N, 1298f1d2b4d3SLarry Finger MASKDWORD, value32 | (BIT(23) | BIT(25))); 1299f1d2b4d3SLarry Finger /*Pin Setting*/ 1300f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_PIN_CTRL_11N, BIT(9) | BIT(8), 0); 1301f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, BIT(10), 0); 1302f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_LNA_SWITCH_11N, BIT(22), 1); 1303f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_LNA_SWITCH_11N, BIT(31), 1); 1304f1d2b4d3SLarry Finger /*OFDM Setting*/ 1305f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANTDIV_PARA1_11N, MASKDWORD, 0x000000a0); 1306f1d2b4d3SLarry Finger /*CCK Setting*/ 1307f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_BB_PWR_SAV4_11N, BIT(7), 1); 1308f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_CCK_ANTDIV_PARA2_11N, BIT(4), 1); 1309f1d2b4d3SLarry Finger rtl88e_dm_update_rx_idle_ant(hw, MAIN_ANT); 1310f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_MAPPING1_11N, MASKLWORD, 0x0201); 1311f1d2b4d3SLarry Finger } 1312f1d2b4d3SLarry Finger 1313f1d2b4d3SLarry Finger static void rtl88e_dm_trx_hw_antenna_div_init(struct ieee80211_hw *hw) 1314f1d2b4d3SLarry Finger { 1315f1d2b4d3SLarry Finger u32 value32; 1316f1d2b4d3SLarry Finger 1317f1d2b4d3SLarry Finger /*MAC Setting*/ 1318f1d2b4d3SLarry Finger value32 = rtl_get_bbreg(hw, DM_REG_ANTSEL_PIN_11N, MASKDWORD); 1319f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANTSEL_PIN_11N, MASKDWORD, 1320f1d2b4d3SLarry Finger value32 | (BIT(23) | BIT(25))); 1321f1d2b4d3SLarry Finger /*Pin Setting*/ 1322f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_PIN_CTRL_11N, BIT(9) | BIT(8), 0); 1323f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, BIT(10), 0); 1324f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_LNA_SWITCH_11N, BIT(22), 0); 1325f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_LNA_SWITCH_11N, BIT(31), 1); 1326f1d2b4d3SLarry Finger /*OFDM Setting*/ 1327f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANTDIV_PARA1_11N, MASKDWORD, 0x000000a0); 1328f1d2b4d3SLarry Finger /*CCK Setting*/ 1329f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_BB_PWR_SAV4_11N, BIT(7), 1); 1330f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_CCK_ANTDIV_PARA2_11N, BIT(4), 1); 1331f1d2b4d3SLarry Finger /*TX Setting*/ 1332f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_TX_ANT_CTRL_11N, BIT(21), 0); 1333f1d2b4d3SLarry Finger rtl88e_dm_update_rx_idle_ant(hw, MAIN_ANT); 1334f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_MAPPING1_11N, MASKLWORD, 0x0201); 1335f1d2b4d3SLarry Finger } 1336f1d2b4d3SLarry Finger 1337f1d2b4d3SLarry Finger static void rtl88e_dm_fast_training_init(struct ieee80211_hw *hw) 1338f1d2b4d3SLarry Finger { 1339f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1340f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1341f1d2b4d3SLarry Finger u32 ant_combination = 2; 1342f1d2b4d3SLarry Finger u32 value32, i; 1343f1d2b4d3SLarry Finger 1344f1d2b4d3SLarry Finger for (i = 0; i < 6; i++) { 1345f1d2b4d3SLarry Finger pfat_table->bssid[i] = 0; 1346f1d2b4d3SLarry Finger pfat_table->ant_sum[i] = 0; 1347f1d2b4d3SLarry Finger pfat_table->ant_cnt[i] = 0; 1348f1d2b4d3SLarry Finger pfat_table->ant_ave[i] = 0; 1349f1d2b4d3SLarry Finger } 1350f1d2b4d3SLarry Finger pfat_table->train_idx = 0; 1351f1d2b4d3SLarry Finger pfat_table->fat_state = FAT_NORMAL_STATE; 1352f1d2b4d3SLarry Finger 1353f1d2b4d3SLarry Finger /*MAC Setting*/ 1354f1d2b4d3SLarry Finger value32 = rtl_get_bbreg(hw, DM_REG_ANTSEL_PIN_11N, MASKDWORD); 1355f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANTSEL_PIN_11N, 1356f1d2b4d3SLarry Finger MASKDWORD, value32 | (BIT(23) | BIT(25))); 1357f1d2b4d3SLarry Finger value32 = rtl_get_bbreg(hw, DM_REG_ANT_TRAIN_PARA2_11N, MASKDWORD); 1358f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_TRAIN_PARA2_11N, 1359f1d2b4d3SLarry Finger MASKDWORD, value32 | (BIT(16) | BIT(17))); 1360f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_TRAIN_PARA2_11N, 1361f1d2b4d3SLarry Finger MASKLWORD, 0); 1362f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_TRAIN_PARA1_11N, 1363f1d2b4d3SLarry Finger MASKDWORD, 0); 1364f1d2b4d3SLarry Finger 1365f1d2b4d3SLarry Finger /*Pin Setting*/ 1366f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_PIN_CTRL_11N, BIT(9) | BIT(8), 0); 1367f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, BIT(10), 0); 1368f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_LNA_SWITCH_11N, BIT(22), 0); 1369f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_LNA_SWITCH_11N, BIT(31), 1); 1370f1d2b4d3SLarry Finger 1371f1d2b4d3SLarry Finger /*OFDM Setting*/ 1372f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANTDIV_PARA1_11N, MASKDWORD, 0x000000a0); 1373f1d2b4d3SLarry Finger /*antenna mapping table*/ 1374f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_MAPPING1_11N, MASKBYTE0, 1); 1375f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_MAPPING1_11N, MASKBYTE1, 2); 1376f1d2b4d3SLarry Finger 1377f1d2b4d3SLarry Finger /*TX Setting*/ 1378f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_TX_ANT_CTRL_11N, BIT(21), 1); 1379f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, 1380f1d2b4d3SLarry Finger BIT(5) | BIT(4) | BIT(3), 0); 1381f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, 1382f1d2b4d3SLarry Finger BIT(8) | BIT(7) | BIT(6), 1); 1383f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, 1384f1d2b4d3SLarry Finger BIT(2) | BIT(1) | BIT(0), (ant_combination - 1)); 1385f1d2b4d3SLarry Finger 1386f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_IGI_A_11N, BIT(7), 1); 1387f1d2b4d3SLarry Finger } 1388f1d2b4d3SLarry Finger 1389f1d2b4d3SLarry Finger static void rtl88e_dm_antenna_div_init(struct ieee80211_hw *hw) 1390f1d2b4d3SLarry Finger { 1391f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 1392f1d2b4d3SLarry Finger 1393f1d2b4d3SLarry Finger if (rtlefuse->antenna_div_type == CGCS_RX_HW_ANTDIV) 1394f1d2b4d3SLarry Finger rtl88e_dm_rx_hw_antena_div_init(hw); 1395f1d2b4d3SLarry Finger else if (rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) 1396f1d2b4d3SLarry Finger rtl88e_dm_trx_hw_antenna_div_init(hw); 1397f1d2b4d3SLarry Finger else if (rtlefuse->antenna_div_type == CG_TRX_SMART_ANTDIV) 1398f1d2b4d3SLarry Finger rtl88e_dm_fast_training_init(hw); 1399f1d2b4d3SLarry Finger 1400f1d2b4d3SLarry Finger } 1401f1d2b4d3SLarry Finger 1402f1d2b4d3SLarry Finger void rtl88e_dm_set_tx_ant_by_tx_info(struct ieee80211_hw *hw, 1403f1d2b4d3SLarry Finger u8 *pdesc, u32 mac_id) 1404f1d2b4d3SLarry Finger { 1405f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 1406f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1407f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1408e53e30baSLarry Finger __le32 *pdesc32 = (__le32 *)pdesc; 1409f1d2b4d3SLarry Finger 1410f1d2b4d3SLarry Finger if ((rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) || 1411f1d2b4d3SLarry Finger (rtlefuse->antenna_div_type == CG_TRX_SMART_ANTDIV)) { 1412e53e30baSLarry Finger set_tx_desc_antsel_a(pdesc32, pfat_table->antsel_a[mac_id]); 1413e53e30baSLarry Finger set_tx_desc_antsel_b(pdesc32, pfat_table->antsel_b[mac_id]); 1414e53e30baSLarry Finger set_tx_desc_antsel_c(pdesc32, pfat_table->antsel_c[mac_id]); 1415f1d2b4d3SLarry Finger } 1416f1d2b4d3SLarry Finger } 1417f1d2b4d3SLarry Finger 1418f1d2b4d3SLarry Finger void rtl88e_dm_ant_sel_statistics(struct ieee80211_hw *hw, 1419f1d2b4d3SLarry Finger u8 antsel_tr_mux, u32 mac_id, 1420f1d2b4d3SLarry Finger u32 rx_pwdb_all) 1421f1d2b4d3SLarry Finger { 1422f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 1423f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1424f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1425f1d2b4d3SLarry Finger 1426f1d2b4d3SLarry Finger if (rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) { 1427f1d2b4d3SLarry Finger if (antsel_tr_mux == MAIN_ANT_CG_TRX) { 1428f1d2b4d3SLarry Finger pfat_table->main_ant_sum[mac_id] += rx_pwdb_all; 1429f1d2b4d3SLarry Finger pfat_table->main_ant_cnt[mac_id]++; 1430f1d2b4d3SLarry Finger } else { 1431f1d2b4d3SLarry Finger pfat_table->aux_ant_sum[mac_id] += rx_pwdb_all; 1432f1d2b4d3SLarry Finger pfat_table->aux_ant_cnt[mac_id]++; 1433f1d2b4d3SLarry Finger } 1434f1d2b4d3SLarry Finger } else if (rtlefuse->antenna_div_type == CGCS_RX_HW_ANTDIV) { 1435f1d2b4d3SLarry Finger if (antsel_tr_mux == MAIN_ANT_CGCS_RX) { 1436f1d2b4d3SLarry Finger pfat_table->main_ant_sum[mac_id] += rx_pwdb_all; 1437f1d2b4d3SLarry Finger pfat_table->main_ant_cnt[mac_id]++; 1438f1d2b4d3SLarry Finger } else { 1439f1d2b4d3SLarry Finger pfat_table->aux_ant_sum[mac_id] += rx_pwdb_all; 1440f1d2b4d3SLarry Finger pfat_table->aux_ant_cnt[mac_id]++; 1441f1d2b4d3SLarry Finger } 1442f1d2b4d3SLarry Finger } 1443f1d2b4d3SLarry Finger } 1444f1d2b4d3SLarry Finger 1445f1d2b4d3SLarry Finger static void rtl88e_dm_hw_ant_div(struct ieee80211_hw *hw) 1446f1d2b4d3SLarry Finger { 1447f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1448f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 1449f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1450f1d2b4d3SLarry Finger struct rtl_sta_info *drv_priv; 1451f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1452f1d2b4d3SLarry Finger struct dig_t *dm_dig = &rtlpriv->dm_digtable; 1453f1d2b4d3SLarry Finger u32 i, min_rssi = 0xff, ant_div_max_rssi = 0; 1454f1d2b4d3SLarry Finger u32 max_rssi = 0, local_min_rssi, local_max_rssi; 1455f1d2b4d3SLarry Finger u32 main_rssi, aux_rssi; 1456f1d2b4d3SLarry Finger u8 rx_idle_ant = 0, target_ant = 7; 1457f1d2b4d3SLarry Finger 1458f1d2b4d3SLarry Finger /*for sta its self*/ 1459f1d2b4d3SLarry Finger i = 0; 1460f1d2b4d3SLarry Finger main_rssi = (pfat_table->main_ant_cnt[i] != 0) ? 1461f1d2b4d3SLarry Finger (pfat_table->main_ant_sum[i] / pfat_table->main_ant_cnt[i]) : 0; 1462f1d2b4d3SLarry Finger aux_rssi = (pfat_table->aux_ant_cnt[i] != 0) ? 1463f1d2b4d3SLarry Finger (pfat_table->aux_ant_sum[i] / pfat_table->aux_ant_cnt[i]) : 0; 1464f1d2b4d3SLarry Finger target_ant = (main_rssi == aux_rssi) ? 1465f1d2b4d3SLarry Finger pfat_table->rx_idle_ant : ((main_rssi >= aux_rssi) ? 1466f1d2b4d3SLarry Finger MAIN_ANT : AUX_ANT); 1467f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, 1468f1d2b4d3SLarry Finger "main_ant_sum %d main_ant_cnt %d\n", 1469f1d2b4d3SLarry Finger pfat_table->main_ant_sum[i], 1470f1d2b4d3SLarry Finger pfat_table->main_ant_cnt[i]); 1471f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, 1472f1d2b4d3SLarry Finger "aux_ant_sum %d aux_ant_cnt %d\n", 1473f1d2b4d3SLarry Finger pfat_table->aux_ant_sum[i], pfat_table->aux_ant_cnt[i]); 1474f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "main_rssi %d aux_rssi%d\n", 1475f1d2b4d3SLarry Finger main_rssi, aux_rssi); 1476f1d2b4d3SLarry Finger local_max_rssi = (main_rssi > aux_rssi) ? main_rssi : aux_rssi; 1477f1d2b4d3SLarry Finger if ((local_max_rssi > ant_div_max_rssi) && (local_max_rssi < 40)) 1478f1d2b4d3SLarry Finger ant_div_max_rssi = local_max_rssi; 1479f1d2b4d3SLarry Finger if (local_max_rssi > max_rssi) 1480f1d2b4d3SLarry Finger max_rssi = local_max_rssi; 1481f1d2b4d3SLarry Finger 1482f1d2b4d3SLarry Finger if ((pfat_table->rx_idle_ant == MAIN_ANT) && (main_rssi == 0)) 1483f1d2b4d3SLarry Finger main_rssi = aux_rssi; 1484f1d2b4d3SLarry Finger else if ((pfat_table->rx_idle_ant == AUX_ANT) && (aux_rssi == 0)) 1485f1d2b4d3SLarry Finger aux_rssi = main_rssi; 1486f1d2b4d3SLarry Finger 1487f1d2b4d3SLarry Finger local_min_rssi = (main_rssi > aux_rssi) ? aux_rssi : main_rssi; 1488f1d2b4d3SLarry Finger if (local_min_rssi < min_rssi) { 1489f1d2b4d3SLarry Finger min_rssi = local_min_rssi; 1490f1d2b4d3SLarry Finger rx_idle_ant = target_ant; 1491f1d2b4d3SLarry Finger } 1492f1d2b4d3SLarry Finger if (rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) 1493f1d2b4d3SLarry Finger rtl88e_dm_update_tx_ant(hw, target_ant, i); 1494f1d2b4d3SLarry Finger 1495f1d2b4d3SLarry Finger if (rtlpriv->mac80211.opmode == NL80211_IFTYPE_AP || 1496f1d2b4d3SLarry Finger rtlpriv->mac80211.opmode == NL80211_IFTYPE_ADHOC) { 1497f1d2b4d3SLarry Finger spin_lock_bh(&rtlpriv->locks.entry_list_lock); 1498f1d2b4d3SLarry Finger list_for_each_entry(drv_priv, &rtlpriv->entry_list, list) { 1499f1d2b4d3SLarry Finger i++; 1500f1d2b4d3SLarry Finger main_rssi = (pfat_table->main_ant_cnt[i] != 0) ? 1501f1d2b4d3SLarry Finger (pfat_table->main_ant_sum[i] / 1502f1d2b4d3SLarry Finger pfat_table->main_ant_cnt[i]) : 0; 1503f1d2b4d3SLarry Finger aux_rssi = (pfat_table->aux_ant_cnt[i] != 0) ? 1504f1d2b4d3SLarry Finger (pfat_table->aux_ant_sum[i] / 1505f1d2b4d3SLarry Finger pfat_table->aux_ant_cnt[i]) : 0; 1506f1d2b4d3SLarry Finger target_ant = (main_rssi == aux_rssi) ? 1507f1d2b4d3SLarry Finger pfat_table->rx_idle_ant : ((main_rssi >= 1508f1d2b4d3SLarry Finger aux_rssi) ? MAIN_ANT : AUX_ANT); 1509f1d2b4d3SLarry Finger 1510f1d2b4d3SLarry Finger local_max_rssi = (main_rssi > aux_rssi) ? 1511f1d2b4d3SLarry Finger main_rssi : aux_rssi; 1512f1d2b4d3SLarry Finger if ((local_max_rssi > ant_div_max_rssi) && 1513f1d2b4d3SLarry Finger (local_max_rssi < 40)) 1514f1d2b4d3SLarry Finger ant_div_max_rssi = local_max_rssi; 1515f1d2b4d3SLarry Finger if (local_max_rssi > max_rssi) 1516f1d2b4d3SLarry Finger max_rssi = local_max_rssi; 1517f1d2b4d3SLarry Finger 1518f1d2b4d3SLarry Finger if ((pfat_table->rx_idle_ant == MAIN_ANT) && 1519f1d2b4d3SLarry Finger (main_rssi == 0)) 1520f1d2b4d3SLarry Finger main_rssi = aux_rssi; 1521f1d2b4d3SLarry Finger else if ((pfat_table->rx_idle_ant == AUX_ANT) && 1522f1d2b4d3SLarry Finger (aux_rssi == 0)) 1523f1d2b4d3SLarry Finger aux_rssi = main_rssi; 1524f1d2b4d3SLarry Finger 1525f1d2b4d3SLarry Finger local_min_rssi = (main_rssi > aux_rssi) ? 1526f1d2b4d3SLarry Finger aux_rssi : main_rssi; 1527f1d2b4d3SLarry Finger if (local_min_rssi < min_rssi) { 1528f1d2b4d3SLarry Finger min_rssi = local_min_rssi; 1529f1d2b4d3SLarry Finger rx_idle_ant = target_ant; 1530f1d2b4d3SLarry Finger } 1531f1d2b4d3SLarry Finger if (rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) 1532f1d2b4d3SLarry Finger rtl88e_dm_update_tx_ant(hw, target_ant, i); 1533f1d2b4d3SLarry Finger } 1534f1d2b4d3SLarry Finger spin_unlock_bh(&rtlpriv->locks.entry_list_lock); 1535f1d2b4d3SLarry Finger } 1536f1d2b4d3SLarry Finger 1537f1d2b4d3SLarry Finger for (i = 0; i < ASSOCIATE_ENTRY_NUM; i++) { 1538f1d2b4d3SLarry Finger pfat_table->main_ant_sum[i] = 0; 1539f1d2b4d3SLarry Finger pfat_table->aux_ant_sum[i] = 0; 1540f1d2b4d3SLarry Finger pfat_table->main_ant_cnt[i] = 0; 1541f1d2b4d3SLarry Finger pfat_table->aux_ant_cnt[i] = 0; 1542f1d2b4d3SLarry Finger } 1543f1d2b4d3SLarry Finger 1544f1d2b4d3SLarry Finger rtl88e_dm_update_rx_idle_ant(hw, rx_idle_ant); 1545f1d2b4d3SLarry Finger 1546f1d2b4d3SLarry Finger dm_dig->antdiv_rssi_max = ant_div_max_rssi; 1547f1d2b4d3SLarry Finger dm_dig->rssi_max = max_rssi; 1548f1d2b4d3SLarry Finger } 1549f1d2b4d3SLarry Finger 1550f1d2b4d3SLarry Finger static void rtl88e_set_next_mac_address_target(struct ieee80211_hw *hw) 1551f1d2b4d3SLarry Finger { 1552f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1553f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 1554f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1555f1d2b4d3SLarry Finger struct rtl_sta_info *drv_priv; 1556f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1557f1d2b4d3SLarry Finger u32 value32, i, j = 0; 1558f1d2b4d3SLarry Finger 1559f1d2b4d3SLarry Finger if (mac->link_state >= MAC80211_LINKED) { 1560f1d2b4d3SLarry Finger for (i = 0; i < ASSOCIATE_ENTRY_NUM; i++) { 1561f1d2b4d3SLarry Finger if ((pfat_table->train_idx + 1) == ASSOCIATE_ENTRY_NUM) 1562f1d2b4d3SLarry Finger pfat_table->train_idx = 0; 1563f1d2b4d3SLarry Finger else 1564f1d2b4d3SLarry Finger pfat_table->train_idx++; 1565f1d2b4d3SLarry Finger 1566f1d2b4d3SLarry Finger if (pfat_table->train_idx == 0) { 1567f1d2b4d3SLarry Finger value32 = (mac->mac_addr[5] << 8) | 1568f1d2b4d3SLarry Finger mac->mac_addr[4]; 1569f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_TRAIN_PARA2_11N, 1570f1d2b4d3SLarry Finger MASKLWORD, value32); 1571f1d2b4d3SLarry Finger 1572f1d2b4d3SLarry Finger value32 = (mac->mac_addr[3] << 24) | 1573f1d2b4d3SLarry Finger (mac->mac_addr[2] << 16) | 1574f1d2b4d3SLarry Finger (mac->mac_addr[1] << 8) | 1575f1d2b4d3SLarry Finger mac->mac_addr[0]; 1576f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_ANT_TRAIN_PARA1_11N, 1577f1d2b4d3SLarry Finger MASKDWORD, value32); 1578f1d2b4d3SLarry Finger break; 1579f1d2b4d3SLarry Finger } 1580f1d2b4d3SLarry Finger 1581f1d2b4d3SLarry Finger if (rtlpriv->mac80211.opmode != 1582f1d2b4d3SLarry Finger NL80211_IFTYPE_STATION) { 1583f1d2b4d3SLarry Finger spin_lock_bh(&rtlpriv->locks.entry_list_lock); 1584f1d2b4d3SLarry Finger list_for_each_entry(drv_priv, 1585f1d2b4d3SLarry Finger &rtlpriv->entry_list, list) { 1586f1d2b4d3SLarry Finger j++; 1587f1d2b4d3SLarry Finger if (j != pfat_table->train_idx) 1588f1d2b4d3SLarry Finger continue; 1589f1d2b4d3SLarry Finger 1590f1d2b4d3SLarry Finger value32 = (drv_priv->mac_addr[5] << 8) | 1591f1d2b4d3SLarry Finger drv_priv->mac_addr[4]; 1592f1d2b4d3SLarry Finger rtl_set_bbreg(hw, 1593f1d2b4d3SLarry Finger DM_REG_ANT_TRAIN_PARA2_11N, 1594f1d2b4d3SLarry Finger MASKLWORD, value32); 1595f1d2b4d3SLarry Finger 1596f1d2b4d3SLarry Finger value32 = (drv_priv->mac_addr[3] << 24) | 1597f1d2b4d3SLarry Finger (drv_priv->mac_addr[2] << 16) | 1598f1d2b4d3SLarry Finger (drv_priv->mac_addr[1] << 8) | 1599f1d2b4d3SLarry Finger drv_priv->mac_addr[0]; 1600f1d2b4d3SLarry Finger rtl_set_bbreg(hw, 1601f1d2b4d3SLarry Finger DM_REG_ANT_TRAIN_PARA1_11N, 1602f1d2b4d3SLarry Finger MASKDWORD, value32); 1603f1d2b4d3SLarry Finger break; 1604f1d2b4d3SLarry Finger } 1605f1d2b4d3SLarry Finger spin_unlock_bh(&rtlpriv->locks.entry_list_lock); 1606f1d2b4d3SLarry Finger /*find entry, break*/ 1607f1d2b4d3SLarry Finger if (j == pfat_table->train_idx) 1608f1d2b4d3SLarry Finger break; 1609f1d2b4d3SLarry Finger } 1610f1d2b4d3SLarry Finger } 1611f1d2b4d3SLarry Finger } 1612f1d2b4d3SLarry Finger } 1613f1d2b4d3SLarry Finger 1614f1d2b4d3SLarry Finger static void rtl88e_dm_fast_ant_training(struct ieee80211_hw *hw) 1615f1d2b4d3SLarry Finger { 1616f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1617f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1618f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1619f1d2b4d3SLarry Finger u32 i, max_rssi = 0; 1620f1d2b4d3SLarry Finger u8 target_ant = 2; 1621f1d2b4d3SLarry Finger bool bpkt_filter_match = false; 1622f1d2b4d3SLarry Finger 1623f1d2b4d3SLarry Finger if (pfat_table->fat_state == FAT_TRAINING_STATE) { 1624f1d2b4d3SLarry Finger for (i = 0; i < 7; i++) { 1625f1d2b4d3SLarry Finger if (pfat_table->ant_cnt[i] == 0) { 1626f1d2b4d3SLarry Finger pfat_table->ant_ave[i] = 0; 1627f1d2b4d3SLarry Finger } else { 1628f1d2b4d3SLarry Finger pfat_table->ant_ave[i] = 1629f1d2b4d3SLarry Finger pfat_table->ant_sum[i] / 1630f1d2b4d3SLarry Finger pfat_table->ant_cnt[i]; 1631f1d2b4d3SLarry Finger bpkt_filter_match = true; 1632f1d2b4d3SLarry Finger } 1633f1d2b4d3SLarry Finger 1634f1d2b4d3SLarry Finger if (pfat_table->ant_ave[i] > max_rssi) { 1635f1d2b4d3SLarry Finger max_rssi = pfat_table->ant_ave[i]; 1636f1d2b4d3SLarry Finger target_ant = (u8) i; 1637f1d2b4d3SLarry Finger } 1638f1d2b4d3SLarry Finger } 1639f1d2b4d3SLarry Finger 1640f1d2b4d3SLarry Finger if (bpkt_filter_match == false) { 1641f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_TXAGC_A_1_MCS32_11N, 1642f1d2b4d3SLarry Finger BIT(16), 0); 1643f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_IGI_A_11N, BIT(7), 0); 1644f1d2b4d3SLarry Finger } else { 1645f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_TXAGC_A_1_MCS32_11N, 1646f1d2b4d3SLarry Finger BIT(16), 0); 1647f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_RX_ANT_CTRL_11N, BIT(8) | 1648f1d2b4d3SLarry Finger BIT(7) | BIT(6), target_ant); 1649f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_TX_ANT_CTRL_11N, 1650f1d2b4d3SLarry Finger BIT(21), 1); 1651f1d2b4d3SLarry Finger 1652f1d2b4d3SLarry Finger pfat_table->antsel_a[pfat_table->train_idx] = 1653f1d2b4d3SLarry Finger target_ant & BIT(0); 1654f1d2b4d3SLarry Finger pfat_table->antsel_b[pfat_table->train_idx] = 1655f1d2b4d3SLarry Finger (target_ant & BIT(1)) >> 1; 1656f1d2b4d3SLarry Finger pfat_table->antsel_c[pfat_table->train_idx] = 1657f1d2b4d3SLarry Finger (target_ant & BIT(2)) >> 2; 1658f1d2b4d3SLarry Finger 1659f1d2b4d3SLarry Finger if (target_ant == 0) 1660f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_IGI_A_11N, BIT(7), 0); 1661f1d2b4d3SLarry Finger } 1662f1d2b4d3SLarry Finger 1663f1d2b4d3SLarry Finger for (i = 0; i < 7; i++) { 1664f1d2b4d3SLarry Finger pfat_table->ant_sum[i] = 0; 1665f1d2b4d3SLarry Finger pfat_table->ant_cnt[i] = 0; 1666f1d2b4d3SLarry Finger } 1667f1d2b4d3SLarry Finger 1668f1d2b4d3SLarry Finger pfat_table->fat_state = FAT_NORMAL_STATE; 1669f1d2b4d3SLarry Finger return; 1670f1d2b4d3SLarry Finger } 1671f1d2b4d3SLarry Finger 1672f1d2b4d3SLarry Finger if (pfat_table->fat_state == FAT_NORMAL_STATE) { 1673f1d2b4d3SLarry Finger rtl88e_set_next_mac_address_target(hw); 1674f1d2b4d3SLarry Finger 1675f1d2b4d3SLarry Finger pfat_table->fat_state = FAT_TRAINING_STATE; 1676f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_TXAGC_A_1_MCS32_11N, BIT(16), 1); 1677f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_IGI_A_11N, BIT(7), 1); 1678f1d2b4d3SLarry Finger 1679f1d2b4d3SLarry Finger mod_timer(&rtlpriv->works.fast_antenna_training_timer, 1680f1d2b4d3SLarry Finger jiffies + MSECS(RTL_WATCH_DOG_TIME)); 1681f1d2b4d3SLarry Finger } 1682f1d2b4d3SLarry Finger } 1683f1d2b4d3SLarry Finger 16847c51d17cSKees Cook void rtl88e_dm_fast_antenna_training_callback(struct timer_list *t) 1685f1d2b4d3SLarry Finger { 16867c51d17cSKees Cook struct rtl_priv *rtlpriv = 16877c51d17cSKees Cook from_timer(rtlpriv, t, works.fast_antenna_training_timer); 16887c51d17cSKees Cook struct ieee80211_hw *hw = rtlpriv->hw; 1689f1d2b4d3SLarry Finger 1690f1d2b4d3SLarry Finger rtl88e_dm_fast_ant_training(hw); 1691f1d2b4d3SLarry Finger } 1692f1d2b4d3SLarry Finger 1693f1d2b4d3SLarry Finger static void rtl88e_dm_antenna_diversity(struct ieee80211_hw *hw) 1694f1d2b4d3SLarry Finger { 1695f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1696f1d2b4d3SLarry Finger struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 1697f1d2b4d3SLarry Finger struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 1698f1d2b4d3SLarry Finger struct rtl_dm *rtldm = rtl_dm(rtl_priv(hw)); 1699f1d2b4d3SLarry Finger struct fast_ant_training *pfat_table = &rtldm->fat_table; 1700f1d2b4d3SLarry Finger 1701f1d2b4d3SLarry Finger if (mac->link_state < MAC80211_LINKED) { 1702f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_DIG, DBG_LOUD, "No Link\n"); 1703f1d2b4d3SLarry Finger if (pfat_table->becomelinked) { 1704f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_DIG, DBG_LOUD, 1705f1d2b4d3SLarry Finger "need to turn off HW AntDiv\n"); 1706f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_IGI_A_11N, BIT(7), 0); 1707f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_CCK_ANTDIV_PARA1_11N, 1708f1d2b4d3SLarry Finger BIT(15), 0); 1709f1d2b4d3SLarry Finger if (rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) 1710f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_TX_ANT_CTRL_11N, 1711f1d2b4d3SLarry Finger BIT(21), 0); 1712f1d2b4d3SLarry Finger pfat_table->becomelinked = 1713f1d2b4d3SLarry Finger (mac->link_state == MAC80211_LINKED) ? 1714f1d2b4d3SLarry Finger true : false; 1715f1d2b4d3SLarry Finger } 1716f1d2b4d3SLarry Finger return; 1717f1d2b4d3SLarry Finger } else { 1718f1d2b4d3SLarry Finger if (!pfat_table->becomelinked) { 1719f1d2b4d3SLarry Finger RT_TRACE(rtlpriv, COMP_DIG, DBG_LOUD, 1720f1d2b4d3SLarry Finger "Need to turn on HW AntDiv\n"); 1721f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_IGI_A_11N, BIT(7), 1); 1722f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_CCK_ANTDIV_PARA1_11N, 1723f1d2b4d3SLarry Finger BIT(15), 1); 1724f1d2b4d3SLarry Finger if (rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) 1725f1d2b4d3SLarry Finger rtl_set_bbreg(hw, DM_REG_TX_ANT_CTRL_11N, 1726f1d2b4d3SLarry Finger BIT(21), 1); 1727f1d2b4d3SLarry Finger pfat_table->becomelinked = 1728f1d2b4d3SLarry Finger (mac->link_state >= MAC80211_LINKED) ? 1729f1d2b4d3SLarry Finger true : false; 1730f1d2b4d3SLarry Finger } 1731f1d2b4d3SLarry Finger } 1732f1d2b4d3SLarry Finger 1733f1d2b4d3SLarry Finger if ((rtlefuse->antenna_div_type == CG_TRX_HW_ANTDIV) || 1734f1d2b4d3SLarry Finger (rtlefuse->antenna_div_type == CGCS_RX_HW_ANTDIV)) 1735f1d2b4d3SLarry Finger rtl88e_dm_hw_ant_div(hw); 1736f1d2b4d3SLarry Finger else if (rtlefuse->antenna_div_type == CG_TRX_SMART_ANTDIV) 1737f1d2b4d3SLarry Finger rtl88e_dm_fast_ant_training(hw); 1738f1d2b4d3SLarry Finger } 1739f1d2b4d3SLarry Finger 1740f1d2b4d3SLarry Finger void rtl88e_dm_init(struct ieee80211_hw *hw) 1741f1d2b4d3SLarry Finger { 1742f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1743f1d2b4d3SLarry Finger u32 cur_igvalue = rtl_get_bbreg(hw, ROFDM0_XAAGCCORE1, 0x7f); 1744f1d2b4d3SLarry Finger 1745f1d2b4d3SLarry Finger rtlpriv->dm.dm_type = DM_TYPE_BYDRIVER; 1746f1d2b4d3SLarry Finger rtl_dm_diginit(hw, cur_igvalue); 1747f1d2b4d3SLarry Finger rtl88e_dm_init_dynamic_txpower(hw); 1748f1d2b4d3SLarry Finger rtl88e_dm_init_edca_turbo(hw); 1749f1d2b4d3SLarry Finger rtl88e_dm_init_rate_adaptive_mask(hw); 1750f1d2b4d3SLarry Finger rtl88e_dm_init_txpower_tracking(hw); 1751f1d2b4d3SLarry Finger rtl92c_dm_init_dynamic_bb_powersaving(hw); 1752f1d2b4d3SLarry Finger rtl88e_dm_antenna_div_init(hw); 1753f1d2b4d3SLarry Finger } 1754f1d2b4d3SLarry Finger 1755f1d2b4d3SLarry Finger void rtl88e_dm_watchdog(struct ieee80211_hw *hw) 1756f1d2b4d3SLarry Finger { 1757f1d2b4d3SLarry Finger struct rtl_priv *rtlpriv = rtl_priv(hw); 1758f1d2b4d3SLarry Finger struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); 1759f1d2b4d3SLarry Finger bool fw_current_inpsmode = false; 1760f1d2b4d3SLarry Finger bool fw_ps_awake = true; 1761f1d2b4d3SLarry Finger 1762f1d2b4d3SLarry Finger rtlpriv->cfg->ops->get_hw_reg(hw, HW_VAR_FW_PSMODE_STATUS, 1763f1d2b4d3SLarry Finger (u8 *)(&fw_current_inpsmode)); 1764f1d2b4d3SLarry Finger rtlpriv->cfg->ops->get_hw_reg(hw, HW_VAR_FWLPS_RF_ON, 1765f1d2b4d3SLarry Finger (u8 *)(&fw_ps_awake)); 1766f1d2b4d3SLarry Finger if (ppsc->p2p_ps_info.p2p_ps_mode) 1767f1d2b4d3SLarry Finger fw_ps_awake = false; 1768f1d2b4d3SLarry Finger 1769204e2ab2SLarry Finger spin_lock(&rtlpriv->locks.rf_ps_lock); 1770f1d2b4d3SLarry Finger if ((ppsc->rfpwr_state == ERFON) && 1771f1d2b4d3SLarry Finger ((!fw_current_inpsmode) && fw_ps_awake) && 1772f1d2b4d3SLarry Finger (!ppsc->rfchange_inprogress)) { 1773f1d2b4d3SLarry Finger rtl88e_dm_pwdb_monitor(hw); 1774f1d2b4d3SLarry Finger rtl88e_dm_dig(hw); 1775f1d2b4d3SLarry Finger rtl88e_dm_false_alarm_counter_statistics(hw); 1776f1d2b4d3SLarry Finger rtl92c_dm_dynamic_txpower(hw); 1777f1d2b4d3SLarry Finger rtl88e_dm_check_txpower_tracking(hw); 1778f1d2b4d3SLarry Finger rtl88e_dm_refresh_rate_adaptive_mask(hw); 1779f1d2b4d3SLarry Finger rtl88e_dm_check_edca_turbo(hw); 1780f1d2b4d3SLarry Finger rtl88e_dm_antenna_diversity(hw); 1781f1d2b4d3SLarry Finger } 1782204e2ab2SLarry Finger spin_unlock(&rtlpriv->locks.rf_ps_lock); 1783f1d2b4d3SLarry Finger } 1784