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