Commit | Line | Data |
---|---|---|
94a79942 LF |
1 | /****************************************************************************** |
2 | * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved. | |
3 | * | |
4 | * Based on the r8180 driver, which is: | |
559a4c31 | 5 | * Copyright 2004-2005 Andrea Merello <andrea.merello@gmail.com>, et al. |
94a79942 LF |
6 | * This program is free software; you can redistribute it and/or modify it |
7 | * under the terms of version 2 of the GNU General Public License as | |
8 | * published by the Free Software Foundation. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, but WITHOUT | |
11 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
12 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
13 | * more details. | |
14 | * | |
94a79942 LF |
15 | * The full GNU General Public License is included in this distribution in the |
16 | * file called LICENSE. | |
17 | * | |
18 | * Contact Information: | |
19 | * wlanfae <wlanfae@realtek.com> | |
20 | ******************************************************************************/ | |
21 | #include "rtl_core.h" | |
22 | #include "r8192E_phy.h" | |
23 | #include "r8192E_phyreg.h" | |
24 | #include "r8190P_rtl8256.h" | |
25 | #include "r8192E_cmdpkt.h" | |
26 | #include "rtl_dm.h" | |
27 | #include "rtl_wx.h" | |
28 | ||
35e33b04 MK |
29 | static int WDCAPARA_ADD[] = {EDCAPARA_BE, EDCAPARA_BK, EDCAPARA_VI, |
30 | EDCAPARA_VO}; | |
94a79942 | 31 | |
89d4a8be | 32 | void rtl92e_start_beacon(struct net_device *dev) |
94a79942 LF |
33 | { |
34 | struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); | |
35 | struct rtllib_network *net = &priv->rtllib->current_network; | |
36 | u16 BcnTimeCfg = 0; | |
52629477 LF |
37 | u16 BcnCW = 6; |
38 | u16 BcnIFS = 0xf; | |
94a79942 | 39 | |
b7b50d65 | 40 | rtl92e_irq_disable(dev); |
94a79942 | 41 | |
6dee0c88 | 42 | rtl92e_writew(dev, ATIMWND, 2); |
94a79942 | 43 | |
6dee0c88 MK |
44 | rtl92e_writew(dev, BCN_INTERVAL, net->beacon_interval); |
45 | rtl92e_writew(dev, BCN_DRV_EARLY_INT, 10); | |
46 | rtl92e_writew(dev, BCN_DMATIME, 256); | |
94a79942 | 47 | |
d8ae1967 | 48 | rtl92e_writeb(dev, BCN_ERR_THRESH, 100); |
94a79942 LF |
49 | |
50 | BcnTimeCfg |= BcnCW<<BCN_TCFG_CW_SHIFT; | |
51 | BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS; | |
6dee0c88 | 52 | rtl92e_writew(dev, BCN_TCFG, BcnTimeCfg); |
b74299cd | 53 | rtl92e_irq_enable(dev); |
94a79942 LF |
54 | } |
55 | ||
6ded6893 | 56 | static void _rtl92e_update_msr(struct net_device *dev) |
94a79942 LF |
57 | { |
58 | struct r8192_priv *priv = rtllib_priv(dev); | |
59 | u8 msr; | |
4fd7cedc | 60 | enum led_ctl_mode LedAction = LED_CTL_NO_LINK; |
3a6b70c3 | 61 | |
b59a4ca3 | 62 | msr = rtl92e_readb(dev, MSR); |
52629477 | 63 | msr &= ~MSR_LINK_MASK; |
94a79942 LF |
64 | |
65 | switch (priv->rtllib->iw_mode) { | |
66 | case IW_MODE_INFRA: | |
67 | if (priv->rtllib->state == RTLLIB_LINKED) | |
68 | msr |= (MSR_LINK_MANAGED << MSR_LINK_SHIFT); | |
69 | else | |
70 | msr |= (MSR_LINK_NONE << MSR_LINK_SHIFT); | |
71 | LedAction = LED_CTL_LINK; | |
72 | break; | |
73 | case IW_MODE_ADHOC: | |
74 | if (priv->rtllib->state == RTLLIB_LINKED) | |
75 | msr |= (MSR_LINK_ADHOC << MSR_LINK_SHIFT); | |
76 | else | |
77 | msr |= (MSR_LINK_NONE << MSR_LINK_SHIFT); | |
78 | break; | |
79 | case IW_MODE_MASTER: | |
80 | if (priv->rtllib->state == RTLLIB_LINKED) | |
81 | msr |= (MSR_LINK_MASTER << MSR_LINK_SHIFT); | |
82 | else | |
83 | msr |= (MSR_LINK_NONE << MSR_LINK_SHIFT); | |
84 | break; | |
85 | default: | |
86 | break; | |
87 | } | |
88 | ||
d8ae1967 | 89 | rtl92e_writeb(dev, MSR, msr); |
94a79942 LF |
90 | if (priv->rtllib->LedControlHandler) |
91 | priv->rtllib->LedControlHandler(dev, LedAction); | |
92 | } | |
93 | ||
61fea239 | 94 | void rtl92e_set_reg(struct net_device *dev, u8 variable, u8 *val) |
94a79942 | 95 | { |
52629477 | 96 | struct r8192_priv *priv = rtllib_priv(dev); |
94a79942 | 97 | |
52629477 LF |
98 | switch (variable) { |
99 | case HW_VAR_BSSID: | |
8ea54100 | 100 | rtl92e_writel(dev, BSSIDR, ((u32 *)(val))[0]); |
6dee0c88 | 101 | rtl92e_writew(dev, BSSIDR+2, ((u16 *)(val+2))[0]); |
94a79942 LF |
102 | break; |
103 | ||
52629477 LF |
104 | case HW_VAR_MEDIA_STATUS: |
105 | { | |
106 | enum rt_op_mode OpMode = *((enum rt_op_mode *)(val)); | |
b59a4ca3 | 107 | u8 btMsr = rtl92e_readb(dev, MSR); |
94a79942 | 108 | |
52629477 | 109 | btMsr &= 0xfc; |
94a79942 | 110 | |
52629477 LF |
111 | switch (OpMode) { |
112 | case RT_OP_MODE_INFRASTRUCTURE: | |
113 | btMsr |= MSR_INFRA; | |
52629477 | 114 | break; |
94a79942 | 115 | |
52629477 LF |
116 | case RT_OP_MODE_IBSS: |
117 | btMsr |= MSR_ADHOC; | |
118 | break; | |
94a79942 | 119 | |
52629477 LF |
120 | case RT_OP_MODE_AP: |
121 | btMsr |= MSR_AP; | |
52629477 | 122 | break; |
94a79942 | 123 | |
52629477 LF |
124 | default: |
125 | btMsr |= MSR_NOLINK; | |
126 | break; | |
127 | } | |
94a79942 | 128 | |
d8ae1967 | 129 | rtl92e_writeb(dev, MSR, btMsr); |
94a79942 | 130 | |
52629477 LF |
131 | } |
132 | break; | |
94a79942 | 133 | |
52629477 LF |
134 | case HW_VAR_CECHK_BSSID: |
135 | { | |
136 | u32 RegRCR, Type; | |
94a79942 | 137 | |
52629477 | 138 | Type = ((u8 *)(val))[0]; |
99aa47e0 | 139 | RegRCR = rtl92e_readl(dev, RCR); |
52629477 | 140 | priv->ReceiveConfig = RegRCR; |
94a79942 | 141 | |
52629477 LF |
142 | if (Type == true) |
143 | RegRCR |= (RCR_CBSSID); | |
144 | else if (Type == false) | |
145 | RegRCR &= (~RCR_CBSSID); | |
94a79942 | 146 | |
8ea54100 | 147 | rtl92e_writel(dev, RCR, RegRCR); |
52629477 | 148 | priv->ReceiveConfig = RegRCR; |
94a79942 | 149 | |
52629477 LF |
150 | } |
151 | break; | |
94a79942 | 152 | |
52629477 | 153 | case HW_VAR_SLOT_TIME: |
94a79942 | 154 | |
52629477 | 155 | priv->slot_time = val[0]; |
d8ae1967 | 156 | rtl92e_writeb(dev, SLOT_TIME, val[0]); |
94a79942 | 157 | |
94a79942 LF |
158 | break; |
159 | ||
52629477 LF |
160 | case HW_VAR_ACK_PREAMBLE: |
161 | { | |
162 | u32 regTmp; | |
3a6b70c3 | 163 | |
52629477 LF |
164 | priv->short_preamble = (bool)(*(u8 *)val); |
165 | regTmp = priv->basic_rate; | |
166 | if (priv->short_preamble) | |
167 | regTmp |= BRSR_AckShortPmb; | |
8ea54100 | 168 | rtl92e_writel(dev, RRSR, regTmp); |
94a79942 | 169 | break; |
52629477 | 170 | } |
94a79942 | 171 | |
52629477 | 172 | case HW_VAR_CPU_RST: |
8ea54100 | 173 | rtl92e_writel(dev, CPU_GEN, ((u32 *)(val))[0]); |
94a79942 LF |
174 | break; |
175 | ||
52629477 LF |
176 | case HW_VAR_AC_PARAM: |
177 | { | |
178 | u8 pAcParam = *((u8 *)val); | |
179 | u32 eACI = pAcParam; | |
180 | u8 u1bAIFS; | |
181 | u32 u4bAcParam; | |
182 | u8 mode = priv->rtllib->mode; | |
35e33b04 | 183 | struct rtllib_qos_parameters *qop = |
52629477 LF |
184 | &priv->rtllib->current_network.qos_data.parameters; |
185 | ||
35e33b04 | 186 | u1bAIFS = qop->aifs[pAcParam] * |
52629477 LF |
187 | ((mode&(IEEE_G|IEEE_N_24G)) ? 9 : 20) + aSifsTime; |
188 | ||
7842c2d5 | 189 | rtl92e_dm_init_edca_turbo(dev); |
52629477 | 190 | |
35e33b04 MK |
191 | u4bAcParam = (le16_to_cpu(qop->tx_op_limit[pAcParam]) << |
192 | AC_PARAM_TXOP_LIMIT_OFFSET) | | |
193 | ((le16_to_cpu(qop->cw_max[pAcParam])) << | |
194 | AC_PARAM_ECW_MAX_OFFSET) | | |
195 | ((le16_to_cpu(qop->cw_min[pAcParam])) << | |
196 | AC_PARAM_ECW_MIN_OFFSET) | | |
197 | (((u32)u1bAIFS) << AC_PARAM_AIFS_OFFSET); | |
52629477 LF |
198 | |
199 | RT_TRACE(COMP_DBG, "%s():HW_VAR_AC_PARAM eACI:%x:%x\n", | |
200 | __func__, eACI, u4bAcParam); | |
201 | switch (eACI) { | |
202 | case AC1_BK: | |
8ea54100 | 203 | rtl92e_writel(dev, EDCAPARA_BK, u4bAcParam); |
52629477 | 204 | break; |
94a79942 | 205 | |
52629477 | 206 | case AC0_BE: |
8ea54100 | 207 | rtl92e_writel(dev, EDCAPARA_BE, u4bAcParam); |
52629477 | 208 | break; |
94a79942 | 209 | |
52629477 | 210 | case AC2_VI: |
8ea54100 | 211 | rtl92e_writel(dev, EDCAPARA_VI, u4bAcParam); |
52629477 | 212 | break; |
94a79942 | 213 | |
52629477 | 214 | case AC3_VO: |
8ea54100 | 215 | rtl92e_writel(dev, EDCAPARA_VO, u4bAcParam); |
52629477 | 216 | break; |
94a79942 | 217 | |
52629477 | 218 | default: |
d69d2054 MK |
219 | netdev_info(dev, "SetHwReg8185(): invalid ACI: %d !\n", |
220 | eACI); | |
52629477 LF |
221 | break; |
222 | } | |
223 | priv->rtllib->SetHwRegHandler(dev, HW_VAR_ACM_CTRL, | |
224 | (u8 *)(&pAcParam)); | |
225 | break; | |
226 | } | |
94a79942 | 227 | |
52629477 LF |
228 | case HW_VAR_ACM_CTRL: |
229 | { | |
230 | struct rtllib_qos_parameters *qos_parameters = | |
231 | &priv->rtllib->current_network.qos_data.parameters; | |
232 | u8 pAcParam = *((u8 *)val); | |
233 | u32 eACI = pAcParam; | |
234 | union aci_aifsn *pAciAifsn = (union aci_aifsn *) & | |
235 | (qos_parameters->aifs[0]); | |
236 | u8 acm = pAciAifsn->f.acm; | |
b59a4ca3 | 237 | u8 AcmCtrl = rtl92e_readb(dev, AcmHwCtrl); |
52629477 LF |
238 | |
239 | RT_TRACE(COMP_DBG, "===========>%s():HW_VAR_ACM_CTRL:%x\n", | |
240 | __func__, eACI); | |
241 | AcmCtrl = AcmCtrl | ((priv->AcmMethod == 2) ? 0x0 : 0x1); | |
242 | ||
243 | if (acm) { | |
244 | switch (eACI) { | |
94a79942 | 245 | case AC0_BE: |
52629477 | 246 | AcmCtrl |= AcmHw_BeqEn; |
94a79942 LF |
247 | break; |
248 | ||
249 | case AC2_VI: | |
52629477 | 250 | AcmCtrl |= AcmHw_ViqEn; |
94a79942 LF |
251 | break; |
252 | ||
253 | case AC3_VO: | |
52629477 | 254 | AcmCtrl |= AcmHw_VoqEn; |
94a79942 LF |
255 | break; |
256 | ||
257 | default: | |
0822339b MK |
258 | RT_TRACE(COMP_QOS, |
259 | "SetHwReg8185(): [HW_VAR_ACM_CTRL] acm set failed: eACI is %d\n", | |
260 | eACI); | |
94a79942 LF |
261 | break; |
262 | } | |
52629477 LF |
263 | } else { |
264 | switch (eACI) { | |
265 | case AC0_BE: | |
266 | AcmCtrl &= (~AcmHw_BeqEn); | |
267 | break; | |
94a79942 | 268 | |
52629477 LF |
269 | case AC2_VI: |
270 | AcmCtrl &= (~AcmHw_ViqEn); | |
271 | break; | |
94a79942 | 272 | |
52629477 LF |
273 | case AC3_VO: |
274 | AcmCtrl &= (~AcmHw_BeqEn); | |
275 | break; | |
94a79942 | 276 | |
52629477 LF |
277 | default: |
278 | break; | |
94a79942 | 279 | } |
94a79942 | 280 | } |
52629477 | 281 | |
0822339b MK |
282 | RT_TRACE(COMP_QOS, |
283 | "SetHwReg8190pci(): [HW_VAR_ACM_CTRL] Write 0x%X\n", | |
284 | AcmCtrl); | |
d8ae1967 | 285 | rtl92e_writeb(dev, AcmHwCtrl, AcmCtrl); |
94a79942 | 286 | break; |
52629477 | 287 | } |
94a79942 | 288 | |
52629477 | 289 | case HW_VAR_SIFS: |
d8ae1967 MK |
290 | rtl92e_writeb(dev, SIFS, val[0]); |
291 | rtl92e_writeb(dev, SIFS+1, val[0]); | |
94a79942 LF |
292 | break; |
293 | ||
52629477 LF |
294 | case HW_VAR_RF_TIMING: |
295 | { | |
296 | u8 Rf_Timing = *((u8 *)val); | |
3a6b70c3 | 297 | |
d8ae1967 | 298 | rtl92e_writeb(dev, rFPGA0_RFTiming1, Rf_Timing); |
94a79942 | 299 | break; |
52629477 | 300 | } |
94a79942 | 301 | |
52629477 | 302 | default: |
94a79942 LF |
303 | break; |
304 | } | |
305 | ||
306 | } | |
307 | ||
676b8bae | 308 | static void _rtl92e_read_eeprom_info(struct net_device *dev) |
94a79942 LF |
309 | { |
310 | struct r8192_priv *priv = rtllib_priv(dev); | |
06c11107 | 311 | const u8 bMac_Tmp_Addr[ETH_ALEN] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x01}; |
52629477 LF |
312 | u8 tempval; |
313 | u8 ICVer8192, ICVer8256; | |
314 | u16 i, usValue, IC_Version; | |
315 | u16 EEPROMId; | |
3a6b70c3 | 316 | |
676b8bae | 317 | RT_TRACE(COMP_INIT, "====> _rtl92e_read_eeprom_info\n"); |
94a79942 | 318 | |
68cb7b7a | 319 | EEPROMId = rtl92e_eeprom_read(dev, 0); |
52629477 | 320 | if (EEPROMId != RTL8190_EEPROM_ID) { |
3b4140af MK |
321 | netdev_err(dev, "%s(): Invalid EEPROM ID: %x\n", __func__, |
322 | EEPROMId); | |
52629477 LF |
323 | priv->AutoloadFailFlag = true; |
324 | } else { | |
325 | priv->AutoloadFailFlag = false; | |
94a79942 LF |
326 | } |
327 | ||
52629477 | 328 | if (!priv->AutoloadFailFlag) { |
68cb7b7a MK |
329 | priv->eeprom_vid = rtl92e_eeprom_read(dev, EEPROM_VID >> 1); |
330 | priv->eeprom_did = rtl92e_eeprom_read(dev, EEPROM_DID >> 1); | |
94a79942 | 331 | |
68cb7b7a MK |
332 | usValue = rtl92e_eeprom_read(dev, |
333 | (u16)(EEPROM_Customer_ID>>1)) >> 8; | |
52629477 | 334 | priv->eeprom_CustomerID = (u8)(usValue & 0xff); |
68cb7b7a MK |
335 | usValue = rtl92e_eeprom_read(dev, |
336 | EEPROM_ICVersion_ChannelPlan>>1); | |
94a79942 | 337 | priv->eeprom_ChannelPlan = usValue&0xff; |
0c401c1d | 338 | IC_Version = (usValue & 0xff00)>>8; |
94a79942 | 339 | |
94a79942 | 340 | ICVer8192 = (IC_Version&0xf); |
0c401c1d | 341 | ICVer8256 = (IC_Version & 0xf0)>>4; |
94a79942 LF |
342 | RT_TRACE(COMP_INIT, "\nICVer8192 = 0x%x\n", ICVer8192); |
343 | RT_TRACE(COMP_INIT, "\nICVer8256 = 0x%x\n", ICVer8256); | |
52629477 | 344 | if (ICVer8192 == 0x2) { |
94a79942 | 345 | if (ICVer8256 == 0x5) |
52629477 | 346 | priv->card_8192_version = VERSION_8190_BE; |
94a79942 | 347 | } |
52629477 LF |
348 | switch (priv->card_8192_version) { |
349 | case VERSION_8190_BD: | |
350 | case VERSION_8190_BE: | |
351 | break; | |
352 | default: | |
353 | priv->card_8192_version = VERSION_8190_BD; | |
354 | break; | |
94a79942 | 355 | } |
52629477 LF |
356 | RT_TRACE(COMP_INIT, "\nIC Version = 0x%x\n", |
357 | priv->card_8192_version); | |
358 | } else { | |
94a79942 LF |
359 | priv->card_8192_version = VERSION_8190_BD; |
360 | priv->eeprom_vid = 0; | |
361 | priv->eeprom_did = 0; | |
362 | priv->eeprom_CustomerID = 0; | |
363 | priv->eeprom_ChannelPlan = 0; | |
364 | RT_TRACE(COMP_INIT, "\nIC Version = 0x%x\n", 0xff); | |
365 | } | |
366 | ||
367 | RT_TRACE(COMP_INIT, "EEPROM VID = 0x%4x\n", priv->eeprom_vid); | |
368 | RT_TRACE(COMP_INIT, "EEPROM DID = 0x%4x\n", priv->eeprom_did); | |
52629477 LF |
369 | RT_TRACE(COMP_INIT, "EEPROM Customer ID: 0x%2x\n", |
370 | priv->eeprom_CustomerID); | |
371 | ||
372 | if (!priv->AutoloadFailFlag) { | |
373 | for (i = 0; i < 6; i += 2) { | |
68cb7b7a | 374 | usValue = rtl92e_eeprom_read(dev, |
52629477 LF |
375 | (u16)((EEPROM_NODE_ADDRESS_BYTE_0 + i) >> 1)); |
376 | *(u16 *)(&dev->dev_addr[i]) = usValue; | |
94a79942 LF |
377 | } |
378 | } else { | |
b57ceb19 | 379 | ether_addr_copy(dev->dev_addr, bMac_Tmp_Addr); |
94a79942 LF |
380 | } |
381 | ||
52629477 LF |
382 | RT_TRACE(COMP_INIT, "Permanent Address = %pM\n", |
383 | dev->dev_addr); | |
94a79942 | 384 | |
52629477 | 385 | if (priv->card_8192_version > VERSION_8190_BD) |
94a79942 | 386 | priv->bTXPowerDataReadFromEEPORM = true; |
52629477 | 387 | else |
94a79942 | 388 | priv->bTXPowerDataReadFromEEPORM = false; |
94a79942 LF |
389 | |
390 | priv->rf_type = RTL819X_DEFAULT_RF_TYPE; | |
391 | ||
52629477 LF |
392 | if (priv->card_8192_version > VERSION_8190_BD) { |
393 | if (!priv->AutoloadFailFlag) { | |
68cb7b7a MK |
394 | tempval = (rtl92e_eeprom_read(dev, |
395 | (EEPROM_RFInd_PowerDiff >> 1))) & 0xff; | |
94a79942 LF |
396 | priv->EEPROMLegacyHTTxPowerDiff = tempval & 0xf; |
397 | ||
398 | if (tempval&0x80) | |
399 | priv->rf_type = RF_1T2R; | |
400 | else | |
401 | priv->rf_type = RF_2T4R; | |
52629477 | 402 | } else { |
94a79942 LF |
403 | priv->EEPROMLegacyHTTxPowerDiff = 0x04; |
404 | } | |
405 | RT_TRACE(COMP_INIT, "EEPROMLegacyHTTxPowerDiff = %d\n", | |
406 | priv->EEPROMLegacyHTTxPowerDiff); | |
407 | ||
408 | if (!priv->AutoloadFailFlag) | |
68cb7b7a | 409 | priv->EEPROMThermalMeter = (u8)(((rtl92e_eeprom_read(dev, |
52629477 LF |
410 | (EEPROM_ThermalMeter>>1))) & |
411 | 0xff00)>>8); | |
94a79942 | 412 | else |
94a79942 | 413 | priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter; |
52629477 LF |
414 | RT_TRACE(COMP_INIT, "ThermalMeter = %d\n", |
415 | priv->EEPROMThermalMeter); | |
416 | priv->TSSI_13dBm = priv->EEPROMThermalMeter * 100; | |
417 | ||
418 | if (priv->epromtype == EEPROM_93C46) { | |
419 | if (!priv->AutoloadFailFlag) { | |
68cb7b7a | 420 | usValue = rtl92e_eeprom_read(dev, |
0c401c1d | 421 | EEPROM_TxPwDiff_CrystalCap >> 1); |
94a79942 | 422 | priv->EEPROMAntPwDiff = (usValue&0x0fff); |
52629477 LF |
423 | priv->EEPROMCrystalCap = (u8)((usValue & 0xf000) |
424 | >> 12); | |
425 | } else { | |
426 | priv->EEPROMAntPwDiff = | |
427 | EEPROM_Default_AntTxPowerDiff; | |
428 | priv->EEPROMCrystalCap = | |
429 | EEPROM_Default_TxPwDiff_CrystalCap; | |
94a79942 | 430 | } |
52629477 LF |
431 | RT_TRACE(COMP_INIT, "EEPROMAntPwDiff = %d\n", |
432 | priv->EEPROMAntPwDiff); | |
433 | RT_TRACE(COMP_INIT, "EEPROMCrystalCap = %d\n", | |
434 | priv->EEPROMCrystalCap); | |
435 | ||
436 | for (i = 0; i < 14; i += 2) { | |
437 | if (!priv->AutoloadFailFlag) | |
68cb7b7a | 438 | usValue = rtl92e_eeprom_read(dev, |
52629477 LF |
439 | (u16)((EEPROM_TxPwIndex_CCK + |
440 | i) >> 1)); | |
441 | else | |
442 | usValue = EEPROM_Default_TxPower; | |
443 | *((u16 *)(&priv->EEPROMTxPowerLevelCCK[i])) = | |
444 | usValue; | |
0822339b MK |
445 | RT_TRACE(COMP_INIT, |
446 | "CCK Tx Power Level, Index %d = 0x%02x\n", | |
447 | i, priv->EEPROMTxPowerLevelCCK[i]); | |
448 | RT_TRACE(COMP_INIT, | |
449 | "CCK Tx Power Level, Index %d = 0x%02x\n", | |
450 | i+1, priv->EEPROMTxPowerLevelCCK[i+1]); | |
94a79942 | 451 | } |
52629477 LF |
452 | for (i = 0; i < 14; i += 2) { |
453 | if (!priv->AutoloadFailFlag) | |
68cb7b7a | 454 | usValue = rtl92e_eeprom_read(dev, |
52629477 LF |
455 | (u16)((EEPROM_TxPwIndex_OFDM_24G |
456 | + i) >> 1)); | |
457 | else | |
458 | usValue = EEPROM_Default_TxPower; | |
459 | *((u16 *)(&priv->EEPROMTxPowerLevelOFDM24G[i])) | |
460 | = usValue; | |
0822339b MK |
461 | RT_TRACE(COMP_INIT, |
462 | "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", | |
463 | i, priv->EEPROMTxPowerLevelOFDM24G[i]); | |
464 | RT_TRACE(COMP_INIT, | |
465 | "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", | |
466 | i + 1, | |
52629477 | 467 | priv->EEPROMTxPowerLevelOFDM24G[i+1]); |
94a79942 | 468 | } |
94a79942 | 469 | } |
52629477 LF |
470 | if (priv->epromtype == EEPROM_93C46) { |
471 | for (i = 0; i < 14; i++) { | |
472 | priv->TxPowerLevelCCK[i] = | |
473 | priv->EEPROMTxPowerLevelCCK[i]; | |
474 | priv->TxPowerLevelOFDM24G[i] = | |
475 | priv->EEPROMTxPowerLevelOFDM24G[i]; | |
94a79942 | 476 | } |
52629477 LF |
477 | priv->LegacyHTTxPowerDiff = |
478 | priv->EEPROMLegacyHTTxPowerDiff; | |
479 | priv->AntennaTxPwDiff[0] = (priv->EEPROMAntPwDiff & | |
480 | 0xf); | |
0c401c1d AM |
481 | priv->AntennaTxPwDiff[1] = (priv->EEPROMAntPwDiff & |
482 | 0xf0) >> 4; | |
483 | priv->AntennaTxPwDiff[2] = (priv->EEPROMAntPwDiff & | |
484 | 0xf00) >> 8; | |
94a79942 | 485 | priv->CrystalCap = priv->EEPROMCrystalCap; |
52629477 LF |
486 | priv->ThermalMeter[0] = (priv->EEPROMThermalMeter & |
487 | 0xf); | |
0c401c1d AM |
488 | priv->ThermalMeter[1] = (priv->EEPROMThermalMeter & |
489 | 0xf0) >> 4; | |
52629477 LF |
490 | } else if (priv->epromtype == EEPROM_93C56) { |
491 | ||
492 | for (i = 0; i < 3; i++) { | |
493 | priv->TxPowerLevelCCK_A[i] = | |
494 | priv->EEPROMRfACCKChnl1TxPwLevel[0]; | |
495 | priv->TxPowerLevelOFDM24G_A[i] = | |
496 | priv->EEPROMRfAOfdmChnlTxPwLevel[0]; | |
497 | priv->TxPowerLevelCCK_C[i] = | |
498 | priv->EEPROMRfCCCKChnl1TxPwLevel[0]; | |
499 | priv->TxPowerLevelOFDM24G_C[i] = | |
500 | priv->EEPROMRfCOfdmChnlTxPwLevel[0]; | |
94a79942 | 501 | } |
52629477 LF |
502 | for (i = 3; i < 9; i++) { |
503 | priv->TxPowerLevelCCK_A[i] = | |
504 | priv->EEPROMRfACCKChnl1TxPwLevel[1]; | |
505 | priv->TxPowerLevelOFDM24G_A[i] = | |
506 | priv->EEPROMRfAOfdmChnlTxPwLevel[1]; | |
507 | priv->TxPowerLevelCCK_C[i] = | |
508 | priv->EEPROMRfCCCKChnl1TxPwLevel[1]; | |
509 | priv->TxPowerLevelOFDM24G_C[i] = | |
510 | priv->EEPROMRfCOfdmChnlTxPwLevel[1]; | |
94a79942 | 511 | } |
52629477 LF |
512 | for (i = 9; i < 14; i++) { |
513 | priv->TxPowerLevelCCK_A[i] = | |
514 | priv->EEPROMRfACCKChnl1TxPwLevel[2]; | |
515 | priv->TxPowerLevelOFDM24G_A[i] = | |
516 | priv->EEPROMRfAOfdmChnlTxPwLevel[2]; | |
517 | priv->TxPowerLevelCCK_C[i] = | |
518 | priv->EEPROMRfCCCKChnl1TxPwLevel[2]; | |
519 | priv->TxPowerLevelOFDM24G_C[i] = | |
520 | priv->EEPROMRfCOfdmChnlTxPwLevel[2]; | |
94a79942 | 521 | } |
52629477 | 522 | for (i = 0; i < 14; i++) |
0822339b MK |
523 | RT_TRACE(COMP_INIT, |
524 | "priv->TxPowerLevelCCK_A[%d] = 0x%x\n", | |
525 | i, priv->TxPowerLevelCCK_A[i]); | |
52629477 | 526 | for (i = 0; i < 14; i++) |
0822339b MK |
527 | RT_TRACE(COMP_INIT, |
528 | "priv->TxPowerLevelOFDM24G_A[%d] = 0x%x\n", | |
529 | i, priv->TxPowerLevelOFDM24G_A[i]); | |
52629477 | 530 | for (i = 0; i < 14; i++) |
0822339b MK |
531 | RT_TRACE(COMP_INIT, |
532 | "priv->TxPowerLevelCCK_C[%d] = 0x%x\n", | |
533 | i, priv->TxPowerLevelCCK_C[i]); | |
52629477 | 534 | for (i = 0; i < 14; i++) |
0822339b MK |
535 | RT_TRACE(COMP_INIT, |
536 | "priv->TxPowerLevelOFDM24G_C[%d] = 0x%x\n", | |
537 | i, priv->TxPowerLevelOFDM24G_C[i]); | |
52629477 LF |
538 | priv->LegacyHTTxPowerDiff = |
539 | priv->EEPROMLegacyHTTxPowerDiff; | |
94a79942 LF |
540 | priv->AntennaTxPwDiff[0] = 0; |
541 | priv->AntennaTxPwDiff[1] = 0; | |
542 | priv->AntennaTxPwDiff[2] = 0; | |
543 | priv->CrystalCap = priv->EEPROMCrystalCap; | |
52629477 LF |
544 | priv->ThermalMeter[0] = (priv->EEPROMThermalMeter & |
545 | 0xf); | |
0c401c1d AM |
546 | priv->ThermalMeter[1] = (priv->EEPROMThermalMeter & |
547 | 0xf0) >> 4; | |
94a79942 LF |
548 | } |
549 | } | |
550 | ||
52629477 LF |
551 | if (priv->rf_type == RF_1T2R) { |
552 | /* no matter what checkpatch says, the braces are needed */ | |
94a79942 | 553 | RT_TRACE(COMP_INIT, "\n1T2R config\n"); |
52629477 | 554 | } else if (priv->rf_type == RF_2T4R) { |
94a79942 LF |
555 | RT_TRACE(COMP_INIT, "\n2T4R config\n"); |
556 | } | |
557 | ||
2e3ba83a | 558 | rtl92e_init_adaptive_rate(dev); |
94a79942 | 559 | |
52629477 | 560 | priv->rf_chip = RF_8256; |
94a79942 LF |
561 | |
562 | if (priv->RegChannelPlan == 0xf) | |
94a79942 | 563 | priv->ChannelPlan = priv->eeprom_ChannelPlan; |
94a79942 | 564 | else |
94a79942 | 565 | priv->ChannelPlan = priv->RegChannelPlan; |
94a79942 | 566 | |
52629477 | 567 | if (priv->eeprom_vid == 0x1186 && priv->eeprom_did == 0x3304) |
94a79942 | 568 | priv->CustomerID = RT_CID_DLINK; |
94a79942 | 569 | |
52629477 LF |
570 | switch (priv->eeprom_CustomerID) { |
571 | case EEPROM_CID_DEFAULT: | |
572 | priv->CustomerID = RT_CID_DEFAULT; | |
573 | break; | |
574 | case EEPROM_CID_CAMEO: | |
575 | priv->CustomerID = RT_CID_819x_CAMEO; | |
576 | break; | |
577 | case EEPROM_CID_RUNTOP: | |
578 | priv->CustomerID = RT_CID_819x_RUNTOP; | |
579 | break; | |
580 | case EEPROM_CID_NetCore: | |
581 | priv->CustomerID = RT_CID_819x_Netcore; | |
582 | break; | |
583 | case EEPROM_CID_TOSHIBA: | |
584 | priv->CustomerID = RT_CID_TOSHIBA; | |
585 | if (priv->eeprom_ChannelPlan&0x80) | |
586 | priv->ChannelPlan = priv->eeprom_ChannelPlan&0x7f; | |
587 | else | |
588 | priv->ChannelPlan = 0x0; | |
589 | RT_TRACE(COMP_INIT, "Toshiba ChannelPlan = 0x%x\n", | |
590 | priv->ChannelPlan); | |
591 | break; | |
592 | case EEPROM_CID_Nettronix: | |
593 | priv->ScanDelay = 100; | |
594 | priv->CustomerID = RT_CID_Nettronix; | |
595 | break; | |
596 | case EEPROM_CID_Pronet: | |
597 | priv->CustomerID = RT_CID_PRONET; | |
598 | break; | |
599 | case EEPROM_CID_DLINK: | |
600 | priv->CustomerID = RT_CID_DLINK; | |
601 | break; | |
94a79942 | 602 | |
52629477 LF |
603 | case EEPROM_CID_WHQL: |
604 | break; | |
605 | default: | |
606 | break; | |
94a79942 LF |
607 | } |
608 | ||
609 | if (priv->ChannelPlan > CHANNEL_PLAN_LEN - 1) | |
610 | priv->ChannelPlan = 0; | |
94a79942 | 611 | priv->ChannelPlan = COUNTRY_CODE_WORLD_WIDE_13; |
94a79942 | 612 | |
52629477 | 613 | if (priv->eeprom_vid == 0x1186 && priv->eeprom_did == 0x3304) |
94a79942 LF |
614 | priv->rtllib->bSupportRemoteWakeUp = true; |
615 | else | |
616 | priv->rtllib->bSupportRemoteWakeUp = false; | |
617 | ||
618 | RT_TRACE(COMP_INIT, "RegChannelPlan(%d)\n", priv->RegChannelPlan); | |
52629477 | 619 | RT_TRACE(COMP_INIT, "ChannelPlan = %d\n", priv->ChannelPlan); |
94a79942 | 620 | RT_TRACE(COMP_TRACE, "<==== ReadAdapterInfo\n"); |
94a79942 LF |
621 | } |
622 | ||
b095be37 | 623 | void rtl92e_get_eeprom_size(struct net_device *dev) |
94a79942 | 624 | { |
52629477 | 625 | u16 curCR; |
94a79942 | 626 | struct r8192_priv *priv = rtllib_priv(dev); |
52629477 | 627 | |
94a79942 | 628 | RT_TRACE(COMP_INIT, "===========>%s()\n", __func__); |
99aa47e0 | 629 | curCR = rtl92e_readl(dev, EPROM_CMD); |
52629477 LF |
630 | RT_TRACE(COMP_INIT, "read from Reg Cmd9346CR(%x):%x\n", EPROM_CMD, |
631 | curCR); | |
632 | priv->epromtype = (curCR & EPROM_CMD_9356SEL) ? EEPROM_93C56 : | |
633 | EEPROM_93C46; | |
634 | RT_TRACE(COMP_INIT, "<===========%s(), epromtype:%d\n", __func__, | |
635 | priv->epromtype); | |
676b8bae | 636 | _rtl92e_read_eeprom_info(dev); |
94a79942 LF |
637 | } |
638 | ||
f588a225 | 639 | static void _rtl92e_hwconfig(struct net_device *dev) |
94a79942 LF |
640 | { |
641 | u32 regRATR = 0, regRRSR = 0; | |
642 | u8 regBwOpMode = 0, regTmp = 0; | |
643 | struct r8192_priv *priv = rtllib_priv(dev); | |
644 | ||
52629477 | 645 | switch (priv->rtllib->mode) { |
94a79942 LF |
646 | case WIRELESS_MODE_B: |
647 | regBwOpMode = BW_OPMODE_20MHZ; | |
648 | regRATR = RATE_ALL_CCK; | |
649 | regRRSR = RATE_ALL_CCK; | |
650 | break; | |
651 | case WIRELESS_MODE_A: | |
52629477 | 652 | regBwOpMode = BW_OPMODE_5G | BW_OPMODE_20MHZ; |
94a79942 LF |
653 | regRATR = RATE_ALL_OFDM_AG; |
654 | regRRSR = RATE_ALL_OFDM_AG; | |
655 | break; | |
656 | case WIRELESS_MODE_G: | |
657 | regBwOpMode = BW_OPMODE_20MHZ; | |
658 | regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG; | |
659 | regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG; | |
660 | break; | |
661 | case WIRELESS_MODE_AUTO: | |
662 | case WIRELESS_MODE_N_24G: | |
663 | regBwOpMode = BW_OPMODE_20MHZ; | |
52629477 LF |
664 | regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | |
665 | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS; | |
94a79942 LF |
666 | regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG; |
667 | break; | |
668 | case WIRELESS_MODE_N_5G: | |
669 | regBwOpMode = BW_OPMODE_5G; | |
52629477 LF |
670 | regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | |
671 | RATE_ALL_OFDM_2SS; | |
94a79942 LF |
672 | regRRSR = RATE_ALL_OFDM_AG; |
673 | break; | |
674 | default: | |
675 | regBwOpMode = BW_OPMODE_20MHZ; | |
676 | regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG; | |
677 | regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG; | |
678 | break; | |
679 | } | |
680 | ||
d8ae1967 | 681 | rtl92e_writeb(dev, BW_OPMODE, regBwOpMode); |
94a79942 | 682 | { |
7949be66 | 683 | u32 ratr_value; |
3a6b70c3 | 684 | |
94a79942 LF |
685 | ratr_value = regRATR; |
686 | if (priv->rf_type == RF_1T2R) | |
94a79942 | 687 | ratr_value &= ~(RATE_ALL_OFDM_2SS); |
8ea54100 | 688 | rtl92e_writel(dev, RATR0, ratr_value); |
d8ae1967 | 689 | rtl92e_writeb(dev, UFWP, 1); |
94a79942 | 690 | } |
b59a4ca3 | 691 | regTmp = rtl92e_readb(dev, 0x313); |
94a79942 | 692 | regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff); |
8ea54100 | 693 | rtl92e_writel(dev, RRSR, regRRSR); |
94a79942 | 694 | |
6dee0c88 MK |
695 | rtl92e_writew(dev, RETRY_LIMIT, |
696 | priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT | | |
697 | priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT); | |
94a79942 LF |
698 | } |
699 | ||
46026629 | 700 | bool rtl92e_start_adapter(struct net_device *dev) |
94a79942 LF |
701 | { |
702 | struct r8192_priv *priv = rtllib_priv(dev); | |
703 | u32 ulRegRead; | |
704 | bool rtStatus = true; | |
705 | u8 tmpvalue; | |
52629477 | 706 | u8 ICVersion, SwitchingRegulatorOutput; |
94a79942 | 707 | bool bfirmwareok = true; |
94a79942 LF |
708 | u32 tmpRegA, tmpRegC, TempCCk; |
709 | int i = 0; | |
710 | u32 retry_times = 0; | |
711 | ||
712 | RT_TRACE(COMP_INIT, "====>%s()\n", __func__); | |
713 | priv->being_init_adapter = true; | |
714 | ||
94a79942 | 715 | start: |
36154dc3 | 716 | rtl92e_reset_desc_ring(dev); |
94a79942 | 717 | priv->Rf_Mode = RF_OP_By_SW_3wire; |
52629477 | 718 | if (priv->ResetProgress == RESET_TYPE_NORESET) { |
d8ae1967 | 719 | rtl92e_writeb(dev, ANAPAR, 0x37); |
52629477 LF |
720 | mdelay(500); |
721 | } | |
6167a6c8 | 722 | priv->pFirmware->status = FW_STATUS_0_INIT; |
94a79942 | 723 | |
4bb01423 | 724 | if (priv->RegRfOff) |
94a79942 LF |
725 | priv->rtllib->eRFPowerState = eRfOff; |
726 | ||
99aa47e0 | 727 | ulRegRead = rtl92e_readl(dev, CPU_GEN); |
6167a6c8 | 728 | if (priv->pFirmware->status == FW_STATUS_0_INIT) |
94a79942 | 729 | ulRegRead |= CPU_GEN_SYSTEM_RESET; |
6167a6c8 | 730 | else if (priv->pFirmware->status == FW_STATUS_5_READY) |
94a79942 LF |
731 | ulRegRead |= CPU_GEN_FIRMWARE_RESET; |
732 | else | |
3b4140af | 733 | netdev_err(dev, "%s(): undefined firmware state: %d.\n", |
6167a6c8 | 734 | __func__, priv->pFirmware->status); |
94a79942 | 735 | |
8ea54100 | 736 | rtl92e_writel(dev, CPU_GEN, ulRegRead); |
94a79942 | 737 | |
b59a4ca3 | 738 | ICVersion = rtl92e_readb(dev, IC_VERRSION); |
52629477 | 739 | if (ICVersion >= 0x4) { |
b59a4ca3 | 740 | SwitchingRegulatorOutput = rtl92e_readb(dev, SWREGULATOR); |
52629477 | 741 | if (SwitchingRegulatorOutput != 0xb8) { |
d8ae1967 | 742 | rtl92e_writeb(dev, SWREGULATOR, 0xa8); |
94a79942 | 743 | mdelay(1); |
d8ae1967 | 744 | rtl92e_writeb(dev, SWREGULATOR, 0xb8); |
94a79942 LF |
745 | } |
746 | } | |
94a79942 | 747 | RT_TRACE(COMP_INIT, "BB Config Start!\n"); |
2949353d | 748 | rtStatus = rtl92e_config_bb(dev); |
4bb01423 | 749 | if (!rtStatus) { |
3b4140af | 750 | netdev_warn(dev, "%s(): Failed to configure BB\n", __func__); |
94a79942 LF |
751 | return rtStatus; |
752 | } | |
52629477 | 753 | RT_TRACE(COMP_INIT, "BB Config Finished!\n"); |
94a79942 LF |
754 | |
755 | priv->LoopbackMode = RTL819X_NO_LOOPBACK; | |
52629477 | 756 | if (priv->ResetProgress == RESET_TYPE_NORESET) { |
99aa47e0 | 757 | ulRegRead = rtl92e_readl(dev, CPU_GEN); |
52629477 LF |
758 | if (priv->LoopbackMode == RTL819X_NO_LOOPBACK) |
759 | ulRegRead = ((ulRegRead & CPU_GEN_NO_LOOPBACK_MSK) | | |
760 | CPU_GEN_NO_LOOPBACK_SET); | |
761 | else if (priv->LoopbackMode == RTL819X_MAC_LOOPBACK) | |
762 | ulRegRead |= CPU_CCK_LOOPBACK; | |
763 | else | |
3b4140af MK |
764 | netdev_err(dev, "%s: Invalid loopback mode setting.\n", |
765 | __func__); | |
94a79942 | 766 | |
8ea54100 | 767 | rtl92e_writel(dev, CPU_GEN, ulRegRead); |
94a79942 | 768 | |
52629477 | 769 | udelay(500); |
94a79942 | 770 | } |
f588a225 | 771 | _rtl92e_hwconfig(dev); |
d8ae1967 | 772 | rtl92e_writeb(dev, CMDR, CR_RE | CR_TE); |
94a79942 | 773 | |
d8ae1967 MK |
774 | rtl92e_writeb(dev, PCIF, ((MXDMA2_NoLimit<<MXDMA2_RX_SHIFT) | |
775 | (MXDMA2_NoLimit<<MXDMA2_TX_SHIFT))); | |
8ea54100 | 776 | rtl92e_writel(dev, MAC0, ((u32 *)dev->dev_addr)[0]); |
6dee0c88 | 777 | rtl92e_writew(dev, MAC4, ((u16 *)(dev->dev_addr + 4))[0]); |
8ea54100 MK |
778 | rtl92e_writel(dev, RCR, priv->ReceiveConfig); |
779 | ||
780 | rtl92e_writel(dev, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK << | |
781 | RSVD_FW_QUEUE_PAGE_BK_SHIFT | | |
782 | NUM_OF_PAGE_IN_FW_QUEUE_BE << | |
783 | RSVD_FW_QUEUE_PAGE_BE_SHIFT | | |
784 | NUM_OF_PAGE_IN_FW_QUEUE_VI << | |
785 | RSVD_FW_QUEUE_PAGE_VI_SHIFT | | |
786 | NUM_OF_PAGE_IN_FW_QUEUE_VO << | |
787 | RSVD_FW_QUEUE_PAGE_VO_SHIFT); | |
788 | rtl92e_writel(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << | |
789 | RSVD_FW_QUEUE_PAGE_MGNT_SHIFT); | |
790 | rtl92e_writel(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW | | |
791 | NUM_OF_PAGE_IN_FW_QUEUE_BCN << | |
792 | RSVD_FW_QUEUE_PAGE_BCN_SHIFT| | |
793 | NUM_OF_PAGE_IN_FW_QUEUE_PUB << | |
794 | RSVD_FW_QUEUE_PAGE_PUB_SHIFT); | |
94a79942 | 795 | |
94199b35 | 796 | rtl92e_tx_enable(dev); |
630268b7 | 797 | rtl92e_rx_enable(dev); |
99aa47e0 | 798 | ulRegRead = (0xFFF00000 & rtl92e_readl(dev, RRSR)) | |
52629477 | 799 | RATE_ALL_OFDM_AG | RATE_ALL_CCK; |
8ea54100 MK |
800 | rtl92e_writel(dev, RRSR, ulRegRead); |
801 | rtl92e_writel(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK)); | |
94a79942 | 802 | |
d8ae1967 | 803 | rtl92e_writeb(dev, ACK_TIMEOUT, 0x30); |
94a79942 LF |
804 | |
805 | if (priv->ResetProgress == RESET_TYPE_NORESET) | |
35bf848f | 806 | rtl92e_set_wireless_mode(dev, priv->rtllib->mode); |
358e4ee1 | 807 | rtl92e_cam_reset(dev); |
94a79942 LF |
808 | { |
809 | u8 SECR_value = 0x0; | |
3a6b70c3 | 810 | |
94a79942 LF |
811 | SECR_value |= SCR_TxEncEnable; |
812 | SECR_value |= SCR_RxDecEnable; | |
813 | SECR_value |= SCR_NoSKMC; | |
d8ae1967 | 814 | rtl92e_writeb(dev, SECR, SECR_value); |
94a79942 | 815 | } |
6dee0c88 MK |
816 | rtl92e_writew(dev, ATIMWND, 2); |
817 | rtl92e_writew(dev, BCN_INTERVAL, 100); | |
94a79942 LF |
818 | { |
819 | int i; | |
3a6b70c3 | 820 | |
52629477 | 821 | for (i = 0; i < QOS_QUEUE_NUM; i++) |
8ea54100 | 822 | rtl92e_writel(dev, WDCAPARA_ADD[i], 0x005e4332); |
94a79942 | 823 | } |
d8ae1967 | 824 | rtl92e_writeb(dev, 0xbe, 0xc0); |
94a79942 | 825 | |
0efe7104 | 826 | rtl92e_config_mac(dev); |
94a79942 LF |
827 | |
828 | if (priv->card_8192_version > (u8) VERSION_8190_BD) { | |
78cc16fa | 829 | rtl92e_get_tx_power(dev); |
5aa1b9ca | 830 | rtl92e_set_tx_power(dev, priv->chan); |
94a79942 LF |
831 | } |
832 | ||
b59a4ca3 | 833 | tmpvalue = rtl92e_readb(dev, IC_VERRSION); |
52629477 | 834 | priv->IC_Cut = tmpvalue; |
94a79942 | 835 | RT_TRACE(COMP_INIT, "priv->IC_Cut= 0x%x\n", priv->IC_Cut); |
52629477 LF |
836 | if (priv->IC_Cut >= IC_VersionCut_D) { |
837 | if (priv->IC_Cut == IC_VersionCut_D) { | |
838 | /* no matter what checkpatch says, braces are needed */ | |
94a79942 | 839 | RT_TRACE(COMP_INIT, "D-cut\n"); |
52629477 | 840 | } else if (priv->IC_Cut == IC_VersionCut_E) { |
94a79942 LF |
841 | RT_TRACE(COMP_INIT, "E-cut\n"); |
842 | } | |
843 | } else { | |
844 | RT_TRACE(COMP_INIT, "Before C-cut\n"); | |
845 | } | |
846 | ||
847 | RT_TRACE(COMP_INIT, "Load Firmware!\n"); | |
b8216b69 | 848 | bfirmwareok = rtl92e_init_fw(dev); |
94a79942 LF |
849 | if (!bfirmwareok) { |
850 | if (retry_times < 10) { | |
851 | retry_times++; | |
852 | goto start; | |
853 | } else { | |
854 | rtStatus = false; | |
855 | goto end; | |
856 | } | |
857 | } | |
858 | RT_TRACE(COMP_INIT, "Load Firmware finished!\n"); | |
859 | if (priv->ResetProgress == RESET_TYPE_NORESET) { | |
860 | RT_TRACE(COMP_INIT, "RF Config Started!\n"); | |
31aebbe2 | 861 | rtStatus = rtl92e_config_phy(dev); |
4bb01423 | 862 | if (!rtStatus) { |
3b4140af | 863 | netdev_info(dev, "RF Config failed\n"); |
94a79942 LF |
864 | return rtStatus; |
865 | } | |
866 | RT_TRACE(COMP_INIT, "RF Config Finished!\n"); | |
867 | } | |
94a79942 | 868 | |
153f9ddb MK |
869 | rtl92e_set_bb_reg(dev, rFPGA0_RFMOD, bCCKEn, 0x1); |
870 | rtl92e_set_bb_reg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1); | |
94a79942 | 871 | |
d8ae1967 | 872 | rtl92e_writeb(dev, 0x87, 0x0); |
94a79942 | 873 | |
4bb01423 | 874 | if (priv->RegRfOff) { |
52629477 LF |
875 | RT_TRACE((COMP_INIT | COMP_RF | COMP_POWER), |
876 | "%s(): Turn off RF for RegRfOff ----------\n", | |
877 | __func__); | |
2937a5d2 | 878 | rtl92e_set_rf_state(dev, eRfOff, RF_CHANGE_BY_SW); |
94a79942 | 879 | } else if (priv->rtllib->RfOffReason > RF_CHANGE_BY_PS) { |
0822339b MK |
880 | RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), |
881 | "%s(): Turn off RF for RfOffReason(%d) ----------\n", | |
882 | __func__, priv->rtllib->RfOffReason); | |
2937a5d2 | 883 | rtl92e_set_rf_state(dev, eRfOff, priv->rtllib->RfOffReason); |
94a79942 | 884 | } else if (priv->rtllib->RfOffReason >= RF_CHANGE_BY_IPS) { |
0822339b MK |
885 | RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), |
886 | "%s(): Turn off RF for RfOffReason(%d) ----------\n", | |
887 | __func__, priv->rtllib->RfOffReason); | |
2937a5d2 | 888 | rtl92e_set_rf_state(dev, eRfOff, priv->rtllib->RfOffReason); |
94a79942 | 889 | } else { |
52629477 LF |
890 | RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): RF-ON\n", |
891 | __func__); | |
94a79942 LF |
892 | priv->rtllib->eRFPowerState = eRfOn; |
893 | priv->rtllib->RfOffReason = 0; | |
94a79942 LF |
894 | } |
895 | ||
896 | if (priv->rtllib->FwRWRF) | |
897 | priv->Rf_Mode = RF_OP_By_FW; | |
898 | else | |
899 | priv->Rf_Mode = RF_OP_By_SW_3wire; | |
900 | ||
52629477 | 901 | if (priv->ResetProgress == RESET_TYPE_NORESET) { |
5a9f18cf | 902 | rtl92e_dm_init_txpower_tracking(dev); |
94a79942 | 903 | |
52629477 | 904 | if (priv->IC_Cut >= IC_VersionCut_D) { |
3c351fec MK |
905 | tmpRegA = rtl92e_get_bb_reg(dev, rOFDM0_XATxIQImbalance, |
906 | bMaskDWord); | |
907 | tmpRegC = rtl92e_get_bb_reg(dev, rOFDM0_XCTxIQImbalance, | |
908 | bMaskDWord); | |
52629477 | 909 | for (i = 0; i < TxBBGainTableLength; i++) { |
20b7ec09 | 910 | if (tmpRegA == dm_tx_bb_gain[i]) { |
52629477 LF |
911 | priv->rfa_txpowertrackingindex = (u8)i; |
912 | priv->rfa_txpowertrackingindex_real = | |
913 | (u8)i; | |
914 | priv->rfa_txpowertracking_default = | |
915 | priv->rfa_txpowertrackingindex; | |
94a79942 LF |
916 | break; |
917 | } | |
918 | } | |
919 | ||
3c351fec MK |
920 | TempCCk = rtl92e_get_bb_reg(dev, rCCK0_TxFilter1, |
921 | bMaskByte2); | |
94a79942 LF |
922 | |
923 | for (i = 0; i < CCKTxBBGainTableLength; i++) { | |
20b7ec09 | 924 | if (TempCCk == dm_cck_tx_bb_gain[i][0]) { |
52629477 | 925 | priv->CCKPresentAttentuation_20Mdefault = (u8)i; |
94a79942 LF |
926 | break; |
927 | } | |
928 | } | |
929 | priv->CCKPresentAttentuation_40Mdefault = 0; | |
930 | priv->CCKPresentAttentuation_difference = 0; | |
52629477 LF |
931 | priv->CCKPresentAttentuation = |
932 | priv->CCKPresentAttentuation_20Mdefault; | |
0822339b MK |
933 | RT_TRACE(COMP_POWER_TRACKING, |
934 | "priv->rfa_txpowertrackingindex_initial = %d\n", | |
52629477 | 935 | priv->rfa_txpowertrackingindex); |
0822339b MK |
936 | RT_TRACE(COMP_POWER_TRACKING, |
937 | "priv->rfa_txpowertrackingindex_real__initial = %d\n", | |
52629477 | 938 | priv->rfa_txpowertrackingindex_real); |
0822339b MK |
939 | RT_TRACE(COMP_POWER_TRACKING, |
940 | "priv->CCKPresentAttentuation_difference_initial = %d\n", | |
52629477 | 941 | priv->CCKPresentAttentuation_difference); |
0822339b MK |
942 | RT_TRACE(COMP_POWER_TRACKING, |
943 | "priv->CCKPresentAttentuation_initial = %d\n", | |
52629477 | 944 | priv->CCKPresentAttentuation); |
94a79942 LF |
945 | priv->btxpower_tracking = false; |
946 | } | |
947 | } | |
b74299cd | 948 | rtl92e_irq_enable(dev); |
94a79942 LF |
949 | end: |
950 | priv->being_init_adapter = false; | |
951 | return rtStatus; | |
952 | } | |
953 | ||
479e2b8c | 954 | static void _rtl92e_net_update(struct net_device *dev) |
94a79942 LF |
955 | { |
956 | ||
957 | struct r8192_priv *priv = rtllib_priv(dev); | |
958 | struct rtllib_network *net; | |
959 | u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf; | |
960 | u16 rate_config = 0; | |
961 | ||
962 | net = &priv->rtllib->current_network; | |
122fe9f1 | 963 | rtl92e_config_rate(dev, &rate_config); |
94a79942 LF |
964 | priv->dot11CurrentPreambleMode = PREAMBLE_AUTO; |
965 | priv->basic_rate = rate_config &= 0x15f; | |
8ea54100 | 966 | rtl92e_writel(dev, BSSIDR, ((u32 *)net->bssid)[0]); |
6dee0c88 | 967 | rtl92e_writew(dev, BSSIDR+4, ((u16 *)net->bssid)[2]); |
94a79942 LF |
968 | |
969 | if (priv->rtllib->iw_mode == IW_MODE_ADHOC) { | |
6dee0c88 MK |
970 | rtl92e_writew(dev, ATIMWND, 2); |
971 | rtl92e_writew(dev, BCN_DMATIME, 256); | |
972 | rtl92e_writew(dev, BCN_INTERVAL, net->beacon_interval); | |
973 | rtl92e_writew(dev, BCN_DRV_EARLY_INT, 10); | |
d8ae1967 | 974 | rtl92e_writeb(dev, BCN_ERR_THRESH, 100); |
94a79942 LF |
975 | |
976 | BcnTimeCfg |= (BcnCW<<BCN_TCFG_CW_SHIFT); | |
977 | BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS; | |
978 | ||
6dee0c88 | 979 | rtl92e_writew(dev, BCN_TCFG, BcnTimeCfg); |
94a79942 LF |
980 | } |
981 | } | |
982 | ||
b974b289 | 983 | void rtl92e_link_change(struct net_device *dev) |
94a79942 LF |
984 | { |
985 | struct r8192_priv *priv = rtllib_priv(dev); | |
52629477 | 986 | struct rtllib_device *ieee = priv->rtllib; |
94a79942 LF |
987 | |
988 | if (!priv->up) | |
52629477 | 989 | return; |
94a79942 LF |
990 | |
991 | if (ieee->state == RTLLIB_LINKED) { | |
479e2b8c | 992 | _rtl92e_net_update(dev); |
94a79942 | 993 | priv->ops->update_ratr_table(dev); |
4c29207a MK |
994 | if ((ieee->pairwise_key_type == KEY_TYPE_WEP40) || |
995 | (ieee->pairwise_key_type == KEY_TYPE_WEP104)) | |
37420932 | 996 | rtl92e_enable_hw_security_config(dev); |
94a79942 | 997 | } else { |
d8ae1967 | 998 | rtl92e_writeb(dev, 0x173, 0); |
94a79942 | 999 | } |
6ded6893 | 1000 | _rtl92e_update_msr(dev); |
94a79942 LF |
1001 | |
1002 | if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC) { | |
7949be66 | 1003 | u32 reg; |
3a6b70c3 | 1004 | |
99aa47e0 | 1005 | reg = rtl92e_readl(dev, RCR); |
94a79942 LF |
1006 | if (priv->rtllib->state == RTLLIB_LINKED) { |
1007 | if (ieee->IntelPromiscuousModeInfo.bPromiscuousOn) | |
52629477 LF |
1008 | ; |
1009 | else | |
94a79942 LF |
1010 | priv->ReceiveConfig = reg |= RCR_CBSSID; |
1011 | } else | |
1012 | priv->ReceiveConfig = reg &= ~RCR_CBSSID; | |
1013 | ||
8ea54100 | 1014 | rtl92e_writel(dev, RCR, reg); |
94a79942 LF |
1015 | } |
1016 | } | |
1017 | ||
33e1748d MK |
1018 | void rtl92e_set_monitor_mode(struct net_device *dev, bool bAllowAllDA, |
1019 | bool WriteIntoReg) | |
94a79942 | 1020 | { |
52629477 | 1021 | struct r8192_priv *priv = rtllib_priv(dev); |
94a79942 | 1022 | |
52629477 LF |
1023 | if (bAllowAllDA) |
1024 | priv->ReceiveConfig |= RCR_AAP; | |
1025 | else | |
1026 | priv->ReceiveConfig &= ~RCR_AAP; | |
94a79942 | 1027 | |
52629477 | 1028 | if (WriteIntoReg) |
8ea54100 | 1029 | rtl92e_writel(dev, RCR, priv->ReceiveConfig); |
94a79942 LF |
1030 | } |
1031 | ||
615c8d8d | 1032 | static u8 _rtl92e_rate_mgn_to_hw(u8 rate) |
94a79942 LF |
1033 | { |
1034 | u8 ret = DESC90_RATE1M; | |
1035 | ||
1036 | switch (rate) { | |
1037 | case MGN_1M: | |
1038 | ret = DESC90_RATE1M; | |
1039 | break; | |
1040 | case MGN_2M: | |
1041 | ret = DESC90_RATE2M; | |
1042 | break; | |
1043 | case MGN_5_5M: | |
1044 | ret = DESC90_RATE5_5M; | |
1045 | break; | |
1046 | case MGN_11M: | |
1047 | ret = DESC90_RATE11M; | |
1048 | break; | |
1049 | case MGN_6M: | |
1050 | ret = DESC90_RATE6M; | |
1051 | break; | |
1052 | case MGN_9M: | |
1053 | ret = DESC90_RATE9M; | |
1054 | break; | |
1055 | case MGN_12M: | |
1056 | ret = DESC90_RATE12M; | |
1057 | break; | |
1058 | case MGN_18M: | |
1059 | ret = DESC90_RATE18M; | |
1060 | break; | |
1061 | case MGN_24M: | |
1062 | ret = DESC90_RATE24M; | |
1063 | break; | |
1064 | case MGN_36M: | |
1065 | ret = DESC90_RATE36M; | |
1066 | break; | |
1067 | case MGN_48M: | |
1068 | ret = DESC90_RATE48M; | |
1069 | break; | |
1070 | case MGN_54M: | |
1071 | ret = DESC90_RATE54M; | |
1072 | break; | |
1073 | case MGN_MCS0: | |
1074 | ret = DESC90_RATEMCS0; | |
1075 | break; | |
1076 | case MGN_MCS1: | |
1077 | ret = DESC90_RATEMCS1; | |
1078 | break; | |
1079 | case MGN_MCS2: | |
1080 | ret = DESC90_RATEMCS2; | |
1081 | break; | |
1082 | case MGN_MCS3: | |
1083 | ret = DESC90_RATEMCS3; | |
1084 | break; | |
1085 | case MGN_MCS4: | |
1086 | ret = DESC90_RATEMCS4; | |
1087 | break; | |
1088 | case MGN_MCS5: | |
1089 | ret = DESC90_RATEMCS5; | |
1090 | break; | |
1091 | case MGN_MCS6: | |
1092 | ret = DESC90_RATEMCS6; | |
1093 | break; | |
1094 | case MGN_MCS7: | |
1095 | ret = DESC90_RATEMCS7; | |
1096 | break; | |
1097 | case MGN_MCS8: | |
1098 | ret = DESC90_RATEMCS8; | |
1099 | break; | |
1100 | case MGN_MCS9: | |
1101 | ret = DESC90_RATEMCS9; | |
1102 | break; | |
1103 | case MGN_MCS10: | |
1104 | ret = DESC90_RATEMCS10; | |
1105 | break; | |
1106 | case MGN_MCS11: | |
1107 | ret = DESC90_RATEMCS11; | |
1108 | break; | |
1109 | case MGN_MCS12: | |
1110 | ret = DESC90_RATEMCS12; | |
1111 | break; | |
1112 | case MGN_MCS13: | |
1113 | ret = DESC90_RATEMCS13; | |
1114 | break; | |
1115 | case MGN_MCS14: | |
1116 | ret = DESC90_RATEMCS14; | |
1117 | break; | |
1118 | case MGN_MCS15: | |
1119 | ret = DESC90_RATEMCS15; | |
1120 | break; | |
1121 | case (0x80|0x20): | |
1122 | ret = DESC90_RATEMCS32; | |
1123 | break; | |
1124 | default: | |
1125 | break; | |
1126 | } | |
1127 | return ret; | |
1128 | } | |
1129 | ||
e77891b3 MK |
1130 | static u8 _rtl92e_hw_queue_to_fw_queue(struct net_device *dev, u8 QueueID, |
1131 | u8 priority) | |
94a79942 LF |
1132 | { |
1133 | u8 QueueSelect = 0x0; | |
1134 | ||
1135 | switch (QueueID) { | |
1136 | case BE_QUEUE: | |
1137 | QueueSelect = QSLT_BE; | |
1138 | break; | |
1139 | ||
1140 | case BK_QUEUE: | |
1141 | QueueSelect = QSLT_BK; | |
1142 | break; | |
1143 | ||
1144 | case VO_QUEUE: | |
1145 | QueueSelect = QSLT_VO; | |
1146 | break; | |
1147 | ||
1148 | case VI_QUEUE: | |
1149 | QueueSelect = QSLT_VI; | |
1150 | break; | |
1151 | case MGNT_QUEUE: | |
1152 | QueueSelect = QSLT_MGNT; | |
1153 | break; | |
1154 | case BEACON_QUEUE: | |
1155 | QueueSelect = QSLT_BEACON; | |
1156 | break; | |
1157 | case TXCMD_QUEUE: | |
1158 | QueueSelect = QSLT_CMD; | |
1159 | break; | |
1160 | case HIGH_QUEUE: | |
1161 | QueueSelect = QSLT_HIGH; | |
1162 | break; | |
1163 | default: | |
3b4140af MK |
1164 | netdev_warn(dev, "%s(): Impossible Queue Selection: %d\n", |
1165 | __func__, QueueID); | |
94a79942 LF |
1166 | break; |
1167 | } | |
1168 | return QueueSelect; | |
1169 | } | |
1170 | ||
45de4283 | 1171 | static u8 _rtl92e_query_is_short(u8 TxHT, u8 TxRate, struct cb_desc *tcb_desc) |
01b67faf MK |
1172 | { |
1173 | u8 tmp_Short; | |
1174 | ||
1175 | tmp_Short = (TxHT == 1) ? ((tcb_desc->bUseShortGI) ? 1 : 0) : | |
1176 | ((tcb_desc->bUseShortPreamble) ? 1 : 0); | |
1177 | if (TxHT == 1 && TxRate != DESC90_RATEMCS15) | |
1178 | tmp_Short = 0; | |
1179 | ||
1180 | return tmp_Short; | |
1181 | } | |
1182 | ||
072b3948 MK |
1183 | void rtl92e_fill_tx_desc(struct net_device *dev, struct tx_desc *pdesc, |
1184 | struct cb_desc *cb_desc, struct sk_buff *skb) | |
94a79942 | 1185 | { |
52629477 LF |
1186 | struct r8192_priv *priv = rtllib_priv(dev); |
1187 | dma_addr_t mapping = pci_map_single(priv->pdev, skb->data, skb->len, | |
1188 | PCI_DMA_TODEVICE); | |
7949be66 | 1189 | struct tx_fwinfo_8190pci *pTxFwInfo; |
3a6b70c3 | 1190 | |
52629477 LF |
1191 | pTxFwInfo = (struct tx_fwinfo_8190pci *)skb->data; |
1192 | memset(pTxFwInfo, 0, sizeof(struct tx_fwinfo_8190pci)); | |
1193 | pTxFwInfo->TxHT = (cb_desc->data_rate & 0x80) ? 1 : 0; | |
615c8d8d | 1194 | pTxFwInfo->TxRate = _rtl92e_rate_mgn_to_hw((u8)cb_desc->data_rate); |
52629477 | 1195 | pTxFwInfo->EnableCPUDur = cb_desc->bTxEnableFwCalcDur; |
45de4283 MK |
1196 | pTxFwInfo->Short = _rtl92e_query_is_short(pTxFwInfo->TxHT, |
1197 | pTxFwInfo->TxRate, cb_desc); | |
52629477 | 1198 | |
2dcb4a29 | 1199 | if (pci_dma_mapping_error(priv->pdev, mapping)) |
3b4140af | 1200 | netdev_err(dev, "%s(): DMA Mapping error\n", __func__); |
52629477 LF |
1201 | if (cb_desc->bAMPDUEnable) { |
1202 | pTxFwInfo->AllowAggregation = 1; | |
1203 | pTxFwInfo->RxMF = cb_desc->ampdu_factor; | |
1204 | pTxFwInfo->RxAMD = cb_desc->ampdu_density; | |
1205 | } else { | |
1206 | pTxFwInfo->AllowAggregation = 0; | |
1207 | pTxFwInfo->RxMF = 0; | |
1208 | pTxFwInfo->RxAMD = 0; | |
1209 | } | |
1210 | ||
1211 | pTxFwInfo->RtsEnable = (cb_desc->bRTSEnable) ? 1 : 0; | |
1212 | pTxFwInfo->CtsEnable = (cb_desc->bCTSEnable) ? 1 : 0; | |
1213 | pTxFwInfo->RtsSTBC = (cb_desc->bRTSSTBC) ? 1 : 0; | |
1214 | pTxFwInfo->RtsHT = (cb_desc->rts_rate&0x80) ? 1 : 0; | |
615c8d8d | 1215 | pTxFwInfo->RtsRate = _rtl92e_rate_mgn_to_hw((u8)cb_desc->rts_rate); |
52629477 LF |
1216 | pTxFwInfo->RtsBandwidth = 0; |
1217 | pTxFwInfo->RtsSubcarrier = cb_desc->RTSSC; | |
1218 | pTxFwInfo->RtsShort = (pTxFwInfo->RtsHT == 0) ? | |
1219 | (cb_desc->bRTSUseShortPreamble ? 1 : 0) : | |
1220 | (cb_desc->bRTSUseShortGI ? 1 : 0); | |
1221 | if (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40) { | |
1222 | if (cb_desc->bPacketBW) { | |
1223 | pTxFwInfo->TxBandwidth = 1; | |
1224 | pTxFwInfo->TxSubCarrier = 0; | |
1225 | } else { | |
1226 | pTxFwInfo->TxBandwidth = 0; | |
1227 | pTxFwInfo->TxSubCarrier = priv->nCur40MhzPrimeSC; | |
1228 | } | |
1229 | } else { | |
1230 | pTxFwInfo->TxBandwidth = 0; | |
1231 | pTxFwInfo->TxSubCarrier = 0; | |
1232 | } | |
1233 | ||
1234 | memset((u8 *)pdesc, 0, 12); | |
1235 | pdesc->LINIP = 0; | |
1236 | pdesc->CmdInit = 1; | |
1237 | pdesc->Offset = sizeof(struct tx_fwinfo_8190pci) + 8; | |
1238 | pdesc->PktSize = (u16)skb->len-sizeof(struct tx_fwinfo_8190pci); | |
1239 | ||
1240 | pdesc->SecCAMID = 0; | |
1241 | pdesc->RATid = cb_desc->RATRIndex; | |
1242 | ||
1243 | ||
1244 | pdesc->NoEnc = 1; | |
1245 | pdesc->SecType = 0x0; | |
1246 | if (cb_desc->bHwSec) { | |
1247 | static u8 tmp; | |
3a6b70c3 | 1248 | |
52629477 LF |
1249 | if (!tmp) { |
1250 | RT_TRACE(COMP_DBG, "==>================hw sec\n"); | |
1251 | tmp = 1; | |
1252 | } | |
1253 | switch (priv->rtllib->pairwise_key_type) { | |
1254 | case KEY_TYPE_WEP40: | |
1255 | case KEY_TYPE_WEP104: | |
1256 | pdesc->SecType = 0x1; | |
1257 | pdesc->NoEnc = 0; | |
1258 | break; | |
1259 | case KEY_TYPE_TKIP: | |
1260 | pdesc->SecType = 0x2; | |
1261 | pdesc->NoEnc = 0; | |
1262 | break; | |
1263 | case KEY_TYPE_CCMP: | |
1264 | pdesc->SecType = 0x3; | |
1265 | pdesc->NoEnc = 0; | |
1266 | break; | |
1267 | case KEY_TYPE_NA: | |
1268 | pdesc->SecType = 0x0; | |
1269 | pdesc->NoEnc = 1; | |
1270 | break; | |
1271 | } | |
1272 | } | |
1273 | ||
1274 | pdesc->PktId = 0x0; | |
1275 | ||
e77891b3 MK |
1276 | pdesc->QueueSelect = _rtl92e_hw_queue_to_fw_queue(dev, |
1277 | cb_desc->queue_index, | |
1278 | cb_desc->priority); | |
52629477 LF |
1279 | pdesc->TxFWInfoSize = sizeof(struct tx_fwinfo_8190pci); |
1280 | ||
1281 | pdesc->DISFB = cb_desc->bTxDisableRateFallBack; | |
1282 | pdesc->USERATE = cb_desc->bTxUseDriverAssingedRate; | |
1283 | ||
1284 | pdesc->FirstSeg = 1; | |
1285 | pdesc->LastSeg = 1; | |
1286 | pdesc->TxBufferSize = skb->len; | |
1287 | ||
285cce05 | 1288 | pdesc->TxBuffAddr = mapping; |
94a79942 LF |
1289 | } |
1290 | ||
63b544a1 MK |
1291 | void rtl92e_fill_tx_cmd_desc(struct net_device *dev, struct tx_desc_cmd *entry, |
1292 | struct cb_desc *cb_desc, struct sk_buff *skb) | |
94a79942 | 1293 | { |
52629477 LF |
1294 | struct r8192_priv *priv = rtllib_priv(dev); |
1295 | dma_addr_t mapping = pci_map_single(priv->pdev, skb->data, skb->len, | |
1296 | PCI_DMA_TODEVICE); | |
1297 | ||
2dcb4a29 | 1298 | if (pci_dma_mapping_error(priv->pdev, mapping)) |
3b4140af | 1299 | netdev_err(dev, "%s(): DMA Mapping error\n", __func__); |
52629477 LF |
1300 | memset(entry, 0, 12); |
1301 | entry->LINIP = cb_desc->bLastIniPkt; | |
1302 | entry->FirstSeg = 1; | |
1303 | entry->LastSeg = 1; | |
1304 | if (cb_desc->bCmdOrInit == DESC_PACKET_TYPE_INIT) { | |
1305 | entry->CmdInit = DESC_PACKET_TYPE_INIT; | |
1306 | } else { | |
3f8ddea0 | 1307 | struct tx_desc *entry_tmp = (struct tx_desc *)entry; |
3a6b70c3 | 1308 | |
52629477 LF |
1309 | entry_tmp->CmdInit = DESC_PACKET_TYPE_NORMAL; |
1310 | entry_tmp->Offset = sizeof(struct tx_fwinfo_8190pci) + 8; | |
1311 | entry_tmp->PktSize = (u16)(cb_desc->pkt_size + | |
1312 | entry_tmp->Offset); | |
1313 | entry_tmp->QueueSelect = QSLT_CMD; | |
1314 | entry_tmp->TxFWInfoSize = 0x08; | |
1315 | entry_tmp->RATid = (u8)DESC_PACKET_TYPE_INIT; | |
1316 | } | |
1317 | entry->TxBufferSize = skb->len; | |
285cce05 | 1318 | entry->TxBuffAddr = mapping; |
52629477 | 1319 | entry->OWN = 1; |
94a79942 LF |
1320 | } |
1321 | ||
01d5f566 | 1322 | static u8 _rtl92e_rate_hw_to_mgn(bool bIsHT, u8 rate) |
94a79942 LF |
1323 | { |
1324 | u8 ret_rate = 0x02; | |
1325 | ||
1326 | if (!bIsHT) { | |
1327 | switch (rate) { | |
52629477 LF |
1328 | case DESC90_RATE1M: |
1329 | ret_rate = MGN_1M; | |
1330 | break; | |
1331 | case DESC90_RATE2M: | |
1332 | ret_rate = MGN_2M; | |
1333 | break; | |
1334 | case DESC90_RATE5_5M: | |
1335 | ret_rate = MGN_5_5M; | |
1336 | break; | |
1337 | case DESC90_RATE11M: | |
1338 | ret_rate = MGN_11M; | |
1339 | break; | |
1340 | case DESC90_RATE6M: | |
1341 | ret_rate = MGN_6M; | |
1342 | break; | |
1343 | case DESC90_RATE9M: | |
1344 | ret_rate = MGN_9M; | |
1345 | break; | |
1346 | case DESC90_RATE12M: | |
1347 | ret_rate = MGN_12M; | |
1348 | break; | |
1349 | case DESC90_RATE18M: | |
1350 | ret_rate = MGN_18M; | |
1351 | break; | |
1352 | case DESC90_RATE24M: | |
1353 | ret_rate = MGN_24M; | |
1354 | break; | |
1355 | case DESC90_RATE36M: | |
1356 | ret_rate = MGN_36M; | |
1357 | break; | |
1358 | case DESC90_RATE48M: | |
1359 | ret_rate = MGN_48M; | |
1360 | break; | |
1361 | case DESC90_RATE54M: | |
1362 | ret_rate = MGN_54M; | |
1363 | break; | |
94a79942 | 1364 | |
52629477 | 1365 | default: |
0822339b | 1366 | RT_TRACE(COMP_RECV, |
01d5f566 | 1367 | "_rtl92e_rate_hw_to_mgn(): Non supportedRate [%x], bIsHT = %d!!!\n", |
0822339b MK |
1368 | rate, bIsHT); |
1369 | break; | |
94a79942 LF |
1370 | } |
1371 | ||
1372 | } else { | |
1373 | switch (rate) { | |
52629477 LF |
1374 | case DESC90_RATEMCS0: |
1375 | ret_rate = MGN_MCS0; | |
1376 | break; | |
1377 | case DESC90_RATEMCS1: | |
1378 | ret_rate = MGN_MCS1; | |
1379 | break; | |
1380 | case DESC90_RATEMCS2: | |
1381 | ret_rate = MGN_MCS2; | |
1382 | break; | |
1383 | case DESC90_RATEMCS3: | |
1384 | ret_rate = MGN_MCS3; | |
1385 | break; | |
1386 | case DESC90_RATEMCS4: | |
1387 | ret_rate = MGN_MCS4; | |
1388 | break; | |
1389 | case DESC90_RATEMCS5: | |
1390 | ret_rate = MGN_MCS5; | |
1391 | break; | |
1392 | case DESC90_RATEMCS6: | |
1393 | ret_rate = MGN_MCS6; | |
1394 | break; | |
1395 | case DESC90_RATEMCS7: | |
1396 | ret_rate = MGN_MCS7; | |
1397 | break; | |
1398 | case DESC90_RATEMCS8: | |
1399 | ret_rate = MGN_MCS8; | |
1400 | break; | |
1401 | case DESC90_RATEMCS9: | |
1402 | ret_rate = MGN_MCS9; | |
1403 | break; | |
1404 | case DESC90_RATEMCS10: | |
1405 | ret_rate = MGN_MCS10; | |
1406 | break; | |
1407 | case DESC90_RATEMCS11: | |
1408 | ret_rate = MGN_MCS11; | |
1409 | break; | |
1410 | case DESC90_RATEMCS12: | |
1411 | ret_rate = MGN_MCS12; | |
1412 | break; | |
1413 | case DESC90_RATEMCS13: | |
1414 | ret_rate = MGN_MCS13; | |
1415 | break; | |
1416 | case DESC90_RATEMCS14: | |
1417 | ret_rate = MGN_MCS14; | |
1418 | break; | |
1419 | case DESC90_RATEMCS15: | |
1420 | ret_rate = MGN_MCS15; | |
1421 | break; | |
1422 | case DESC90_RATEMCS32: | |
1423 | ret_rate = (0x80|0x20); | |
1424 | break; | |
94a79942 | 1425 | |
52629477 | 1426 | default: |
0822339b | 1427 | RT_TRACE(COMP_RECV, |
01d5f566 | 1428 | "_rtl92e_rate_hw_to_mgn(): Non supported Rate [%x], bIsHT = %d!!!\n", |
0822339b | 1429 | rate, bIsHT); |
52629477 | 1430 | break; |
94a79942 LF |
1431 | } |
1432 | } | |
1433 | ||
1434 | return ret_rate; | |
1435 | } | |
1436 | ||
af82349a | 1437 | static long _rtl92e_signal_scale_mapping(struct r8192_priv *priv, long currsig) |
94a79942 LF |
1438 | { |
1439 | long retsig; | |
1440 | ||
94a79942 | 1441 | if (currsig >= 61 && currsig <= 100) |
94a79942 | 1442 | retsig = 90 + ((currsig - 60) / 4); |
94a79942 | 1443 | else if (currsig >= 41 && currsig <= 60) |
94a79942 | 1444 | retsig = 78 + ((currsig - 40) / 2); |
94a79942 | 1445 | else if (currsig >= 31 && currsig <= 40) |
94a79942 | 1446 | retsig = 66 + (currsig - 30); |
94a79942 | 1447 | else if (currsig >= 21 && currsig <= 30) |
94a79942 | 1448 | retsig = 54 + (currsig - 20); |
94a79942 | 1449 | else if (currsig >= 5 && currsig <= 20) |
94a79942 | 1450 | retsig = 42 + (((currsig - 5) * 2) / 3); |
94a79942 | 1451 | else if (currsig == 4) |
94a79942 | 1452 | retsig = 36; |
94a79942 | 1453 | else if (currsig == 3) |
94a79942 | 1454 | retsig = 27; |
94a79942 | 1455 | else if (currsig == 2) |
94a79942 | 1456 | retsig = 18; |
94a79942 | 1457 | else if (currsig == 1) |
94a79942 | 1458 | retsig = 9; |
94a79942 | 1459 | else |
94a79942 | 1460 | retsig = currsig; |
94a79942 LF |
1461 | |
1462 | return retsig; | |
1463 | } | |
1464 | ||
1465 | ||
52629477 LF |
1466 | #define rx_hal_is_cck_rate(_pdrvinfo)\ |
1467 | ((_pdrvinfo->RxRate == DESC90_RATE1M ||\ | |
94a79942 LF |
1468 | _pdrvinfo->RxRate == DESC90_RATE2M ||\ |
1469 | _pdrvinfo->RxRate == DESC90_RATE5_5M ||\ | |
1470 | _pdrvinfo->RxRate == DESC90_RATE11M) &&\ | |
52629477 LF |
1471 | !_pdrvinfo->RxHT) |
1472 | ||
410bfd1d | 1473 | static void _rtl92e_query_rxphystatus( |
52629477 LF |
1474 | struct r8192_priv *priv, |
1475 | struct rtllib_rx_stats *pstats, | |
4f534b36 | 1476 | struct rx_desc *pdesc, |
6f22c620 | 1477 | struct rx_fwinfo *pdrvinfo, |
52629477 | 1478 | struct rtllib_rx_stats *precord_stats, |
94a79942 LF |
1479 | bool bpacket_match_bssid, |
1480 | bool bpacket_toself, | |
1481 | bool bPacketBeacon, | |
1482 | bool bToSelfBA | |
1483 | ) | |
1484 | { | |
52629477 LF |
1485 | struct phy_sts_ofdm_819xpci *pofdm_buf; |
1486 | struct phy_sts_cck_819xpci *pcck_buf; | |
1487 | struct phy_ofdm_rx_status_rxsc_sgien_exintfflag *prxsc; | |
1488 | u8 *prxpkt; | |
1489 | u8 i, max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg; | |
5d5fd353 AB |
1490 | s8 rx_pwr[4], rx_pwr_all = 0; |
1491 | s8 rx_snrX, rx_evmX; | |
52629477 LF |
1492 | u8 evm, pwdb_all; |
1493 | u32 RSSI, total_rssi = 0; | |
1494 | u8 is_cck_rate = 0; | |
1495 | u8 rf_rx_num = 0; | |
1496 | static u8 check_reg824; | |
1497 | static u32 reg824_bit9; | |
94a79942 LF |
1498 | |
1499 | priv->stats.numqry_phystatus++; | |
1500 | ||
94a79942 LF |
1501 | is_cck_rate = rx_hal_is_cck_rate(pdrvinfo); |
1502 | memset(precord_stats, 0, sizeof(struct rtllib_rx_stats)); | |
52629477 LF |
1503 | pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = |
1504 | bpacket_match_bssid; | |
94a79942 LF |
1505 | pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself; |
1506 | pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate; | |
1507 | pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon; | |
1508 | pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA; | |
52629477 | 1509 | if (check_reg824 == 0) { |
3c351fec MK |
1510 | reg824_bit9 = rtl92e_get_bb_reg(priv->rtllib->dev, |
1511 | rFPGA0_XA_HSSIParameter2, | |
1512 | 0x200); | |
94a79942 LF |
1513 | check_reg824 = 1; |
1514 | } | |
1515 | ||
1516 | ||
52629477 | 1517 | prxpkt = (u8 *)pdrvinfo; |
94a79942 | 1518 | |
6f22c620 | 1519 | prxpkt += sizeof(struct rx_fwinfo); |
94a79942 | 1520 | |
ececd694 | 1521 | pcck_buf = (struct phy_sts_cck_819xpci *)prxpkt; |
2ae7ea8c | 1522 | pofdm_buf = (struct phy_sts_ofdm_819xpci *)prxpkt; |
94a79942 LF |
1523 | |
1524 | pstats->RxMIMOSignalQuality[0] = -1; | |
1525 | pstats->RxMIMOSignalQuality[1] = -1; | |
1526 | precord_stats->RxMIMOSignalQuality[0] = -1; | |
1527 | precord_stats->RxMIMOSignalQuality[1] = -1; | |
1528 | ||
52629477 | 1529 | if (is_cck_rate) { |
94a79942 | 1530 | u8 report; |
b1d5ee70 LF |
1531 | |
1532 | priv->stats.numqry_phystatusCCK++; | |
52629477 | 1533 | if (!reg824_bit9) { |
94a79942 | 1534 | report = pcck_buf->cck_agc_rpt & 0xc0; |
0dbffe07 | 1535 | report >>= 6; |
52629477 LF |
1536 | switch (report) { |
1537 | case 0x3: | |
1538 | rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & | |
1539 | 0x3e); | |
1540 | break; | |
1541 | case 0x2: | |
1542 | rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & | |
1543 | 0x3e); | |
1544 | break; | |
1545 | case 0x1: | |
1546 | rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & | |
1547 | 0x3e); | |
1548 | break; | |
1549 | case 0x0: | |
1550 | rx_pwr_all = 8 - (pcck_buf->cck_agc_rpt & 0x3e); | |
1551 | break; | |
94a79942 | 1552 | } |
52629477 | 1553 | } else { |
94a79942 | 1554 | report = pcck_buf->cck_agc_rpt & 0x60; |
0dbffe07 | 1555 | report >>= 5; |
52629477 LF |
1556 | switch (report) { |
1557 | case 0x3: | |
1558 | rx_pwr_all = -35 - | |
1559 | ((pcck_buf->cck_agc_rpt & | |
1560 | 0x1f) << 1); | |
1561 | break; | |
1562 | case 0x2: | |
1563 | rx_pwr_all = -23 - | |
1564 | ((pcck_buf->cck_agc_rpt & | |
1565 | 0x1f) << 1); | |
1566 | break; | |
1567 | case 0x1: | |
1568 | rx_pwr_all = -11 - | |
1569 | ((pcck_buf->cck_agc_rpt & | |
1570 | 0x1f) << 1); | |
1571 | break; | |
1572 | case 0x0: | |
1573 | rx_pwr_all = -8 - | |
1574 | ((pcck_buf->cck_agc_rpt & | |
1575 | 0x1f) << 1); | |
1576 | break; | |
94a79942 LF |
1577 | } |
1578 | } | |
1579 | ||
aa804031 | 1580 | pwdb_all = rtl92e_rx_db_to_percent(rx_pwr_all); |
94a79942 LF |
1581 | pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all; |
1582 | pstats->RecvSignalPower = rx_pwr_all; | |
1583 | ||
52629477 | 1584 | if (bpacket_match_bssid) { |
94a79942 LF |
1585 | u8 sq; |
1586 | ||
52629477 | 1587 | if (pstats->RxPWDBAll > 40) { |
94a79942 | 1588 | sq = 100; |
52629477 | 1589 | } else { |
94a79942 LF |
1590 | sq = pcck_buf->sq_rpt; |
1591 | ||
1592 | if (pcck_buf->sq_rpt > 64) | |
1593 | sq = 0; | |
1594 | else if (pcck_buf->sq_rpt < 20) | |
1595 | sq = 100; | |
1596 | else | |
1597 | sq = ((64-sq) * 100) / 44; | |
1598 | } | |
52629477 LF |
1599 | pstats->SignalQuality = sq; |
1600 | precord_stats->SignalQuality = sq; | |
1601 | pstats->RxMIMOSignalQuality[0] = sq; | |
1602 | precord_stats->RxMIMOSignalQuality[0] = sq; | |
1603 | pstats->RxMIMOSignalQuality[1] = -1; | |
1604 | precord_stats->RxMIMOSignalQuality[1] = -1; | |
94a79942 | 1605 | } |
52629477 | 1606 | } else { |
94a79942 | 1607 | priv->stats.numqry_phystatusHT++; |
52629477 | 1608 | for (i = RF90_PATH_A; i < RF90_PATH_MAX; i++) { |
94a79942 LF |
1609 | if (priv->brfpath_rxenable[i]) |
1610 | rf_rx_num++; | |
1611 | ||
52629477 LF |
1612 | rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i] & 0x3F) * |
1613 | 2) - 110; | |
94a79942 LF |
1614 | |
1615 | tmp_rxsnr = pofdm_buf->rxsnr_X[i]; | |
5d5fd353 | 1616 | rx_snrX = (s8)(tmp_rxsnr); |
94a79942 LF |
1617 | rx_snrX /= 2; |
1618 | priv->stats.rxSNRdB[i] = (long)rx_snrX; | |
1619 | ||
aa804031 | 1620 | RSSI = rtl92e_rx_db_to_percent(rx_pwr[i]); |
94a79942 LF |
1621 | if (priv->brfpath_rxenable[i]) |
1622 | total_rssi += RSSI; | |
1623 | ||
52629477 LF |
1624 | if (bpacket_match_bssid) { |
1625 | pstats->RxMIMOSignalStrength[i] = (u8) RSSI; | |
1626 | precord_stats->RxMIMOSignalStrength[i] = | |
1627 | (u8) RSSI; | |
94a79942 LF |
1628 | } |
1629 | } | |
1630 | ||
1631 | ||
52629477 | 1632 | rx_pwr_all = (((pofdm_buf->pwdb_all) >> 1) & 0x7f) - 106; |
aa804031 | 1633 | pwdb_all = rtl92e_rx_db_to_percent(rx_pwr_all); |
94a79942 LF |
1634 | |
1635 | pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all; | |
1636 | pstats->RxPower = precord_stats->RxPower = rx_pwr_all; | |
1637 | pstats->RecvSignalPower = rx_pwr_all; | |
52629477 LF |
1638 | if (pdrvinfo->RxHT && pdrvinfo->RxRate >= DESC90_RATEMCS8 && |
1639 | pdrvinfo->RxRate <= DESC90_RATEMCS15) | |
94a79942 LF |
1640 | max_spatial_stream = 2; |
1641 | else | |
1642 | max_spatial_stream = 1; | |
1643 | ||
52629477 | 1644 | for (i = 0; i < max_spatial_stream; i++) { |
94a79942 | 1645 | tmp_rxevm = pofdm_buf->rxevm_X[i]; |
5d5fd353 | 1646 | rx_evmX = (s8)(tmp_rxevm); |
94a79942 LF |
1647 | |
1648 | rx_evmX /= 2; | |
1649 | ||
6b89d0e7 | 1650 | evm = rtl92e_evm_db_to_percent(rx_evmX); |
52629477 LF |
1651 | if (bpacket_match_bssid) { |
1652 | if (i == 0) { | |
1653 | pstats->SignalQuality = (u8)(evm & | |
1654 | 0xff); | |
1655 | precord_stats->SignalQuality = (u8)(evm | |
1656 | & 0xff); | |
1657 | } | |
1658 | pstats->RxMIMOSignalQuality[i] = (u8)(evm & | |
1659 | 0xff); | |
1660 | precord_stats->RxMIMOSignalQuality[i] = (u8)(evm | |
1661 | & 0xff); | |
94a79942 LF |
1662 | } |
1663 | } | |
1664 | ||
1665 | ||
1666 | rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg; | |
52629477 LF |
1667 | prxsc = (struct phy_ofdm_rx_status_rxsc_sgien_exintfflag *) |
1668 | &rxsc_sgien_exflg; | |
94a79942 LF |
1669 | if (pdrvinfo->BW) |
1670 | priv->stats.received_bwtype[1+prxsc->rxsc]++; | |
1671 | else | |
1672 | priv->stats.received_bwtype[0]++; | |
1673 | } | |
1674 | ||
52629477 LF |
1675 | if (is_cck_rate) { |
1676 | pstats->SignalStrength = precord_stats->SignalStrength = | |
af82349a | 1677 | (u8)(_rtl92e_signal_scale_mapping(priv, |
52629477 | 1678 | (long)pwdb_all)); |
94a79942 | 1679 | |
52629477 | 1680 | } else { |
94a79942 | 1681 | if (rf_rx_num != 0) |
52629477 | 1682 | pstats->SignalStrength = precord_stats->SignalStrength = |
af82349a | 1683 | (u8)(_rtl92e_signal_scale_mapping(priv, |
52629477 | 1684 | (long)(total_rssi /= rf_rx_num))); |
94a79942 LF |
1685 | } |
1686 | } | |
1687 | ||
1325ba08 | 1688 | static void _rtl92e_process_phyinfo(struct r8192_priv *priv, u8 *buffer, |
49aab5fd LF |
1689 | struct rtllib_rx_stats *prev_st, |
1690 | struct rtllib_rx_stats *curr_st) | |
94a79942 LF |
1691 | { |
1692 | bool bcheck = false; | |
1693 | u8 rfpath; | |
52629477 LF |
1694 | u32 ij, tmp_val; |
1695 | static u32 slide_rssi_index, slide_rssi_statistics; | |
1696 | static u32 slide_evm_index, slide_evm_statistics; | |
1697 | static u32 last_rssi, last_evm; | |
1698 | static u32 slide_beacon_adc_pwdb_index; | |
1699 | static u32 slide_beacon_adc_pwdb_statistics; | |
1700 | static u32 last_beacon_adc_pwdb; | |
94a79942 | 1701 | struct rtllib_hdr_3addr *hdr; |
52629477 LF |
1702 | u16 sc; |
1703 | unsigned int frag, seq; | |
1704 | ||
94a79942 LF |
1705 | hdr = (struct rtllib_hdr_3addr *)buffer; |
1706 | sc = le16_to_cpu(hdr->seq_ctl); | |
1707 | frag = WLAN_GET_SEQ_FRAG(sc); | |
1708 | seq = WLAN_GET_SEQ_SEQ(sc); | |
52629477 LF |
1709 | curr_st->Seq_Num = seq; |
1710 | if (!prev_st->bIsAMPDU) | |
94a79942 LF |
1711 | bcheck = true; |
1712 | ||
52629477 | 1713 | if (slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX) { |
94a79942 LF |
1714 | slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX; |
1715 | last_rssi = priv->stats.slide_signal_strength[slide_rssi_index]; | |
1716 | priv->stats.slide_rssi_total -= last_rssi; | |
1717 | } | |
52629477 | 1718 | priv->stats.slide_rssi_total += prev_st->SignalStrength; |
94a79942 | 1719 | |
52629477 LF |
1720 | priv->stats.slide_signal_strength[slide_rssi_index++] = |
1721 | prev_st->SignalStrength; | |
94a79942 LF |
1722 | if (slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX) |
1723 | slide_rssi_index = 0; | |
1724 | ||
1725 | tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics; | |
f54f10bf MK |
1726 | priv->stats.signal_strength = rtl92e_translate_to_dbm(priv, |
1727 | (u8)tmp_val); | |
52629477 LF |
1728 | curr_st->rssi = priv->stats.signal_strength; |
1729 | if (!prev_st->bPacketMatchBSSID) { | |
1730 | if (!prev_st->bToSelfBA) | |
94a79942 LF |
1731 | return; |
1732 | } | |
1733 | ||
1734 | if (!bcheck) | |
1735 | return; | |
1736 | ||
94a79942 | 1737 | priv->stats.num_process_phyinfo++; |
52629477 LF |
1738 | if (!prev_st->bIsCCK && prev_st->bPacketToSelf) { |
1739 | for (rfpath = RF90_PATH_A; rfpath < RF90_PATH_C; rfpath++) { | |
5948d1fe | 1740 | if (!rtl92e_is_legal_rf_path(priv->rtllib->dev, rfpath)) |
94a79942 | 1741 | continue; |
0822339b MK |
1742 | RT_TRACE(COMP_DBG, |
1743 | "Jacken -> pPreviousstats->RxMIMOSignalStrength[rfpath] = %d\n", | |
52629477 LF |
1744 | prev_st->RxMIMOSignalStrength[rfpath]); |
1745 | if (priv->stats.rx_rssi_percentage[rfpath] == 0) { | |
94a79942 | 1746 | priv->stats.rx_rssi_percentage[rfpath] = |
52629477 | 1747 | prev_st->RxMIMOSignalStrength[rfpath]; |
94a79942 | 1748 | } |
52629477 LF |
1749 | if (prev_st->RxMIMOSignalStrength[rfpath] > |
1750 | priv->stats.rx_rssi_percentage[rfpath]) { | |
1751 | priv->stats.rx_rssi_percentage[rfpath] = | |
1752 | ((priv->stats.rx_rssi_percentage[rfpath] | |
1753 | * (RX_SMOOTH - 1)) + | |
1754 | (prev_st->RxMIMOSignalStrength | |
1755 | [rfpath])) / (RX_SMOOTH); | |
94a79942 | 1756 | priv->stats.rx_rssi_percentage[rfpath] = |
52629477 LF |
1757 | priv->stats.rx_rssi_percentage[rfpath] |
1758 | + 1; | |
1759 | } else { | |
1760 | priv->stats.rx_rssi_percentage[rfpath] = | |
1761 | ((priv->stats.rx_rssi_percentage[rfpath] * | |
1762 | (RX_SMOOTH-1)) + | |
1763 | (prev_st->RxMIMOSignalStrength[rfpath])) / | |
1764 | (RX_SMOOTH); | |
94a79942 | 1765 | } |
0822339b MK |
1766 | RT_TRACE(COMP_DBG, |
1767 | "Jacken -> priv->RxStats.RxRSSIPercentage[rfPath] = %d\n", | |
52629477 | 1768 | priv->stats.rx_rssi_percentage[rfpath]); |
94a79942 LF |
1769 | } |
1770 | } | |
1771 | ||
1772 | ||
52629477 LF |
1773 | if (prev_st->bPacketBeacon) { |
1774 | if (slide_beacon_adc_pwdb_statistics++ >= | |
1775 | PHY_Beacon_RSSI_SLID_WIN_MAX) { | |
1776 | slide_beacon_adc_pwdb_statistics = | |
1777 | PHY_Beacon_RSSI_SLID_WIN_MAX; | |
1778 | last_beacon_adc_pwdb = priv->stats.Slide_Beacon_pwdb | |
1779 | [slide_beacon_adc_pwdb_index]; | |
94a79942 LF |
1780 | priv->stats.Slide_Beacon_Total -= last_beacon_adc_pwdb; |
1781 | } | |
52629477 LF |
1782 | priv->stats.Slide_Beacon_Total += prev_st->RxPWDBAll; |
1783 | priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index] = | |
1784 | prev_st->RxPWDBAll; | |
94a79942 LF |
1785 | slide_beacon_adc_pwdb_index++; |
1786 | if (slide_beacon_adc_pwdb_index >= PHY_Beacon_RSSI_SLID_WIN_MAX) | |
1787 | slide_beacon_adc_pwdb_index = 0; | |
52629477 LF |
1788 | prev_st->RxPWDBAll = priv->stats.Slide_Beacon_Total / |
1789 | slide_beacon_adc_pwdb_statistics; | |
1790 | if (prev_st->RxPWDBAll >= 3) | |
1791 | prev_st->RxPWDBAll -= 3; | |
94a79942 LF |
1792 | } |
1793 | ||
1794 | RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n", | |
52629477 LF |
1795 | prev_st->bIsCCK ? "CCK" : "OFDM", |
1796 | prev_st->RxPWDBAll); | |
94a79942 | 1797 | |
52629477 LF |
1798 | if (prev_st->bPacketToSelf || prev_st->bPacketBeacon || |
1799 | prev_st->bToSelfBA) { | |
94a79942 | 1800 | if (priv->undecorated_smoothed_pwdb < 0) |
52629477 LF |
1801 | priv->undecorated_smoothed_pwdb = prev_st->RxPWDBAll; |
1802 | if (prev_st->RxPWDBAll > (u32)priv->undecorated_smoothed_pwdb) { | |
94a79942 | 1803 | priv->undecorated_smoothed_pwdb = |
52629477 LF |
1804 | (((priv->undecorated_smoothed_pwdb) * |
1805 | (RX_SMOOTH-1)) + | |
1806 | (prev_st->RxPWDBAll)) / (RX_SMOOTH); | |
1807 | priv->undecorated_smoothed_pwdb = | |
1808 | priv->undecorated_smoothed_pwdb + 1; | |
1809 | } else { | |
94a79942 | 1810 | priv->undecorated_smoothed_pwdb = |
52629477 LF |
1811 | (((priv->undecorated_smoothed_pwdb) * |
1812 | (RX_SMOOTH-1)) + | |
1813 | (prev_st->RxPWDBAll)) / (RX_SMOOTH); | |
94a79942 | 1814 | } |
97ef450b | 1815 | rtl92e_update_rx_statistics(priv, prev_st); |
94a79942 LF |
1816 | } |
1817 | ||
52629477 LF |
1818 | if (prev_st->SignalQuality != 0) { |
1819 | if (prev_st->bPacketToSelf || prev_st->bPacketBeacon || | |
1820 | prev_st->bToSelfBA) { | |
1821 | if (slide_evm_statistics++ >= PHY_RSSI_SLID_WIN_MAX) { | |
94a79942 | 1822 | slide_evm_statistics = PHY_RSSI_SLID_WIN_MAX; |
52629477 LF |
1823 | last_evm = |
1824 | priv->stats.slide_evm[slide_evm_index]; | |
94a79942 LF |
1825 | priv->stats.slide_evm_total -= last_evm; |
1826 | } | |
1827 | ||
52629477 | 1828 | priv->stats.slide_evm_total += prev_st->SignalQuality; |
94a79942 | 1829 | |
52629477 LF |
1830 | priv->stats.slide_evm[slide_evm_index++] = |
1831 | prev_st->SignalQuality; | |
94a79942 LF |
1832 | if (slide_evm_index >= PHY_RSSI_SLID_WIN_MAX) |
1833 | slide_evm_index = 0; | |
1834 | ||
52629477 LF |
1835 | tmp_val = priv->stats.slide_evm_total / |
1836 | slide_evm_statistics; | |
94a79942 LF |
1837 | priv->stats.signal_quality = tmp_val; |
1838 | priv->stats.last_signal_strength_inpercent = tmp_val; | |
1839 | } | |
1840 | ||
52629477 LF |
1841 | if (prev_st->bPacketToSelf || |
1842 | prev_st->bPacketBeacon || | |
1843 | prev_st->bToSelfBA) { | |
1844 | for (ij = 0; ij < 2; ij++) { | |
1845 | if (prev_st->RxMIMOSignalQuality[ij] != -1) { | |
1846 | if (priv->stats.rx_evm_percentage[ij] == 0) | |
1847 | priv->stats.rx_evm_percentage[ij] = | |
1848 | prev_st->RxMIMOSignalQuality[ij]; | |
1849 | priv->stats.rx_evm_percentage[ij] = | |
1850 | ((priv->stats.rx_evm_percentage[ij] * | |
1851 | (RX_SMOOTH - 1)) + | |
1852 | (prev_st->RxMIMOSignalQuality[ij])) / | |
1853 | (RX_SMOOTH); | |
94a79942 LF |
1854 | } |
1855 | } | |
1856 | } | |
1857 | } | |
94a79942 LF |
1858 | } |
1859 | ||
9d70ed83 MK |
1860 | static void _rtl92e_translate_rx_signal_stats(struct net_device *dev, |
1861 | struct sk_buff *skb, | |
1862 | struct rtllib_rx_stats *pstats, | |
1863 | struct rx_desc *pdesc, | |
1864 | struct rx_fwinfo *pdrvinfo) | |
94a79942 | 1865 | { |
52629477 LF |
1866 | struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); |
1867 | bool bpacket_match_bssid, bpacket_toself; | |
1868 | bool bPacketBeacon = false; | |
1869 | struct rtllib_hdr_3addr *hdr; | |
1870 | bool bToSelfBA = false; | |
1871 | static struct rtllib_rx_stats previous_stats; | |
1872 | u16 fc, type; | |
1873 | u8 *tmp_buf; | |
1874 | u8 *praddr; | |
1875 | ||
1876 | tmp_buf = skb->data + pstats->RxDrvInfoSize + pstats->RxBufShift; | |
1877 | ||
1878 | hdr = (struct rtllib_hdr_3addr *)tmp_buf; | |
1879 | fc = le16_to_cpu(hdr->frame_ctl); | |
1880 | type = WLAN_FC_GET_TYPE(fc); | |
1881 | praddr = hdr->addr1; | |
1882 | ||
8329419a | 1883 | bpacket_match_bssid = |
4c29207a | 1884 | ((type != RTLLIB_FTYPE_CTL) && |
8329419a JP |
1885 | ether_addr_equal(priv->rtllib->current_network.bssid, |
1886 | (fc & RTLLIB_FCTL_TODS) ? hdr->addr1 : | |
1887 | (fc & RTLLIB_FCTL_FROMDS) ? hdr->addr2 : | |
1888 | hdr->addr3) && | |
1889 | (!pstats->bHwError) && (!pstats->bCRC) && (!pstats->bICV)); | |
1890 | bpacket_toself = bpacket_match_bssid && /* check this */ | |
1891 | ether_addr_equal(praddr, priv->rtllib->dev->dev_addr); | |
52629477 LF |
1892 | if (WLAN_FC_GET_FRAMETYPE(fc) == RTLLIB_STYPE_BEACON) |
1893 | bPacketBeacon = true; | |
1894 | if (bpacket_match_bssid) | |
1895 | priv->stats.numpacket_matchbssid++; | |
1896 | if (bpacket_toself) | |
1897 | priv->stats.numpacket_toself++; | |
1325ba08 | 1898 | _rtl92e_process_phyinfo(priv, tmp_buf, &previous_stats, pstats); |
410bfd1d | 1899 | _rtl92e_query_rxphystatus(priv, pstats, pdesc, pdrvinfo, |
52629477 LF |
1900 | &previous_stats, bpacket_match_bssid, |
1901 | bpacket_toself, bPacketBeacon, bToSelfBA); | |
e58701da | 1902 | rtl92e_copy_mpdu_stats(pstats, &previous_stats); |
94a79942 LF |
1903 | } |
1904 | ||
77055c56 | 1905 | static void _rtl92e_update_received_rate_histogram_stats( |
49aab5fd | 1906 | struct net_device *dev, |
52629477 | 1907 | struct rtllib_rx_stats *pstats) |
94a79942 LF |
1908 | { |
1909 | struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); | |
52629477 | 1910 | u32 rcvType = 1; |
94a79942 LF |
1911 | u32 rateIndex; |
1912 | u32 preamble_guardinterval; | |
1913 | ||
1914 | if (pstats->bCRC) | |
1915 | rcvType = 2; | |
1916 | else if (pstats->bICV) | |
1917 | rcvType = 3; | |
1918 | ||
1919 | if (pstats->bShortPreamble) | |
1920 | preamble_guardinterval = 1; | |
1921 | else | |
1922 | preamble_guardinterval = 0; | |
1923 | ||
52629477 LF |
1924 | switch (pstats->rate) { |
1925 | case MGN_1M: | |
1926 | rateIndex = 0; | |
1927 | break; | |
1928 | case MGN_2M: | |
1929 | rateIndex = 1; | |
1930 | break; | |
1931 | case MGN_5_5M: | |
1932 | rateIndex = 2; | |
1933 | break; | |
1934 | case MGN_11M: | |
1935 | rateIndex = 3; | |
1936 | break; | |
1937 | case MGN_6M: | |
1938 | rateIndex = 4; | |
1939 | break; | |
1940 | case MGN_9M: | |
1941 | rateIndex = 5; | |
1942 | break; | |
1943 | case MGN_12M: | |
1944 | rateIndex = 6; | |
1945 | break; | |
1946 | case MGN_18M: | |
1947 | rateIndex = 7; | |
1948 | break; | |
1949 | case MGN_24M: | |
1950 | rateIndex = 8; | |
1951 | break; | |
1952 | case MGN_36M: | |
1953 | rateIndex = 9; | |
1954 | break; | |
1955 | case MGN_48M: | |
1956 | rateIndex = 10; | |
1957 | break; | |
1958 | case MGN_54M: | |
1959 | rateIndex = 11; | |
1960 | break; | |
1961 | case MGN_MCS0: | |
1962 | rateIndex = 12; | |
1963 | break; | |
1964 | case MGN_MCS1: | |
1965 | rateIndex = 13; | |
1966 | break; | |
1967 | case MGN_MCS2: | |
1968 | rateIndex = 14; | |
1969 | break; | |
1970 | case MGN_MCS3: | |
1971 | rateIndex = 15; | |
1972 | break; | |
1973 | case MGN_MCS4: | |
1974 | rateIndex = 16; | |
1975 | break; | |
1976 | case MGN_MCS5: | |
1977 | rateIndex = 17; | |
1978 | break; | |
1979 | case MGN_MCS6: | |
1980 | rateIndex = 18; | |
1981 | break; | |
1982 | case MGN_MCS7: | |
1983 | rateIndex = 19; | |
1984 | break; | |
1985 | case MGN_MCS8: | |
1986 | rateIndex = 20; | |
1987 | break; | |
1988 | case MGN_MCS9: | |
1989 | rateIndex = 21; | |
1990 | break; | |
1991 | case MGN_MCS10: | |
1992 | rateIndex = 22; | |
1993 | break; | |
1994 | case MGN_MCS11: | |
1995 | rateIndex = 23; | |
1996 | break; | |
1997 | case MGN_MCS12: | |
1998 | rateIndex = 24; | |
1999 | break; | |
2000 | case MGN_MCS13: | |
2001 | rateIndex = 25; | |
2002 | break; | |
2003 | case MGN_MCS14: | |
2004 | rateIndex = 26; | |
2005 | break; | |
2006 | case MGN_MCS15: | |
2007 | rateIndex = 27; | |
2008 | break; | |
2009 | default: | |
2010 | rateIndex = 28; | |
2011 | break; | |
94a79942 LF |
2012 | } |
2013 | priv->stats.received_preamble_GI[preamble_guardinterval][rateIndex]++; | |
2014 | priv->stats.received_rate_histogram[0][rateIndex]++; | |
2015 | priv->stats.received_rate_histogram[rcvType][rateIndex]++; | |
2016 | } | |
2017 | ||
7897285c MK |
2018 | bool rtl92e_get_rx_stats(struct net_device *dev, struct rtllib_rx_stats *stats, |
2019 | struct rx_desc *pdesc, struct sk_buff *skb) | |
94a79942 LF |
2020 | { |
2021 | struct r8192_priv *priv = rtllib_priv(dev); | |
285b7c00 | 2022 | struct rx_fwinfo *pDrvInfo = NULL; |
94a79942 LF |
2023 | |
2024 | stats->bICV = pdesc->ICV; | |
2025 | stats->bCRC = pdesc->CRC32; | |
2026 | stats->bHwError = pdesc->CRC32 | pdesc->ICV; | |
2027 | ||
2028 | stats->Length = pdesc->Length; | |
2029 | if (stats->Length < 24) | |
2030 | stats->bHwError |= 1; | |
2031 | ||
2032 | if (stats->bHwError) { | |
2033 | stats->bShift = false; | |
2034 | ||
2035 | if (pdesc->CRC32) { | |
52629477 | 2036 | if (pdesc->Length < 500) |
94a79942 | 2037 | priv->stats.rxcrcerrmin++; |
52629477 | 2038 | else if (pdesc->Length > 1000) |
94a79942 LF |
2039 | priv->stats.rxcrcerrmax++; |
2040 | else | |
2041 | priv->stats.rxcrcerrmid++; | |
2042 | } | |
2043 | return false; | |
285b7c00 | 2044 | } |
3a6b70c3 | 2045 | |
285b7c00 MK |
2046 | stats->RxDrvInfoSize = pdesc->RxDrvInfoSize; |
2047 | stats->RxBufShift = ((pdesc->Shift)&0x03); | |
2048 | stats->Decrypted = !pdesc->SWDec; | |
94a79942 | 2049 | |
285b7c00 | 2050 | pDrvInfo = (struct rx_fwinfo *)(skb->data + stats->RxBufShift); |
94a79942 | 2051 | |
01d5f566 MK |
2052 | stats->rate = _rtl92e_rate_hw_to_mgn((bool)pDrvInfo->RxHT, |
2053 | (u8)pDrvInfo->RxRate); | |
285b7c00 | 2054 | stats->bShortPreamble = pDrvInfo->SPLCP; |
94a79942 | 2055 | |
77055c56 | 2056 | _rtl92e_update_received_rate_histogram_stats(dev, stats); |
94a79942 | 2057 | |
285b7c00 MK |
2058 | stats->bIsAMPDU = (pDrvInfo->PartAggr == 1); |
2059 | stats->bFirstMPDU = (pDrvInfo->PartAggr == 1) && | |
2060 | (pDrvInfo->FirstAGGR == 1); | |
94a79942 | 2061 | |
285b7c00 | 2062 | stats->TimeStampLow = pDrvInfo->TSFL; |
99aa47e0 | 2063 | stats->TimeStampHigh = rtl92e_readl(dev, TSFR+4); |
94a79942 | 2064 | |
7879efc5 | 2065 | rtl92e_update_rx_pkt_timestamp(dev, stats); |
94a79942 | 2066 | |
285b7c00 MK |
2067 | if ((stats->RxBufShift + stats->RxDrvInfoSize) > 0) |
2068 | stats->bShift = 1; | |
94a79942 | 2069 | |
285b7c00 | 2070 | stats->RxIs40MHzPacket = pDrvInfo->BW; |
94a79942 | 2071 | |
9d70ed83 | 2072 | _rtl92e_translate_rx_signal_stats(dev, skb, stats, pdesc, pDrvInfo); |
94a79942 | 2073 | |
285b7c00 MK |
2074 | if (pDrvInfo->FirstAGGR == 1 || pDrvInfo->PartAggr == 1) |
2075 | RT_TRACE(COMP_RXDESC, | |
2076 | "pDrvInfo->FirstAGGR = %d, pDrvInfo->PartAggr = %d\n", | |
2077 | pDrvInfo->FirstAGGR, pDrvInfo->PartAggr); | |
2078 | skb_trim(skb, skb->len - 4/*sCrcLng*/); | |
94a79942 LF |
2079 | |
2080 | ||
285b7c00 MK |
2081 | stats->packetlength = stats->Length-4; |
2082 | stats->fraglength = stats->packetlength; | |
2083 | stats->fragoffset = 0; | |
2084 | stats->ntotalfrag = 1; | |
2085 | return true; | |
94a79942 LF |
2086 | } |
2087 | ||
fe99c77b | 2088 | void rtl92e_stop_adapter(struct net_device *dev, bool reset) |
94a79942 LF |
2089 | { |
2090 | struct r8192_priv *priv = rtllib_priv(dev); | |
2091 | int i; | |
2092 | u8 OpMode; | |
2093 | u8 u1bTmp; | |
2094 | u32 ulRegRead; | |
94a79942 LF |
2095 | |
2096 | OpMode = RT_OP_MODE_NO_LINK; | |
2097 | priv->rtllib->SetHwRegHandler(dev, HW_VAR_MEDIA_STATUS, &OpMode); | |
2098 | ||
52629477 | 2099 | if (!priv->rtllib->bSupportRemoteWakeUp) { |
94a79942 | 2100 | u1bTmp = 0x0; |
d8ae1967 | 2101 | rtl92e_writeb(dev, CMDR, u1bTmp); |
94a79942 | 2102 | } |
94a79942 LF |
2103 | |
2104 | mdelay(20); | |
2105 | ||
52629477 | 2106 | if (!reset) { |
94a79942 LF |
2107 | mdelay(150); |
2108 | ||
f8f3b8a5 | 2109 | priv->bHwRfOffAction = 2; |
94a79942 | 2110 | |
52629477 | 2111 | if (!priv->rtllib->bSupportRemoteWakeUp) { |
3803cb21 | 2112 | rtl92e_set_rf_off(dev); |
99aa47e0 | 2113 | ulRegRead = rtl92e_readl(dev, CPU_GEN); |
52629477 | 2114 | ulRegRead |= CPU_GEN_SYSTEM_RESET; |
8ea54100 | 2115 | rtl92e_writel(dev, CPU_GEN, ulRegRead); |
52629477 | 2116 | } else { |
8ea54100 MK |
2117 | rtl92e_writel(dev, WFCRC0, 0xffffffff); |
2118 | rtl92e_writel(dev, WFCRC1, 0xffffffff); | |
2119 | rtl92e_writel(dev, WFCRC2, 0xffffffff); | |
94a79942 LF |
2120 | |
2121 | ||
d8ae1967 MK |
2122 | rtl92e_writeb(dev, PMR, 0x5); |
2123 | rtl92e_writeb(dev, MacBlkCtrl, 0xa); | |
94a79942 LF |
2124 | } |
2125 | } | |
2126 | ||
52629477 LF |
2127 | for (i = 0; i < MAX_QUEUE_SIZE; i++) |
2128 | skb_queue_purge(&priv->rtllib->skb_waitQ[i]); | |
2129 | for (i = 0; i < MAX_QUEUE_SIZE; i++) | |
2130 | skb_queue_purge(&priv->rtllib->skb_aggQ[i]); | |
94a79942 LF |
2131 | |
2132 | skb_queue_purge(&priv->skb_queue); | |
94a79942 LF |
2133 | } |
2134 | ||
575d48c5 | 2135 | void rtl92e_update_ratr_table(struct net_device *dev) |
94a79942 | 2136 | { |
52629477 LF |
2137 | struct r8192_priv *priv = rtllib_priv(dev); |
2138 | struct rtllib_device *ieee = priv->rtllib; | |
2139 | u8 *pMcsRate = ieee->dot11HTOperationalRateSet; | |
94a79942 | 2140 | u32 ratr_value = 0; |
71c8d893 | 2141 | u16 rate_config = 0; |
94a79942 LF |
2142 | u8 rate_index = 0; |
2143 | ||
122fe9f1 | 2144 | rtl92e_config_rate(dev, &rate_config); |
71c8d893 | 2145 | ratr_value = rate_config | *pMcsRate << 12; |
52629477 LF |
2146 | switch (ieee->mode) { |
2147 | case IEEE_A: | |
2148 | ratr_value &= 0x00000FF0; | |
2149 | break; | |
2150 | case IEEE_B: | |
2151 | ratr_value &= 0x0000000F; | |
2152 | break; | |
2153 | case IEEE_G: | |
2154 | case IEEE_G|IEEE_B: | |
2155 | ratr_value &= 0x00000FF7; | |
2156 | break; | |
2157 | case IEEE_N_24G: | |
2158 | case IEEE_N_5G: | |
2159 | if (ieee->pHTInfo->PeerMimoPs == 0) { | |
2160 | ratr_value &= 0x0007F007; | |
2161 | } else { | |
2162 | if (priv->rf_type == RF_1T2R) | |
2163 | ratr_value &= 0x000FF007; | |
2164 | else | |
2165 | ratr_value &= 0x0F81F007; | |
2166 | } | |
2167 | break; | |
2168 | default: | |
2169 | break; | |
94a79942 LF |
2170 | } |
2171 | ratr_value &= 0x0FFFFFFF; | |
52629477 LF |
2172 | if (ieee->pHTInfo->bCurTxBW40MHz && |
2173 | ieee->pHTInfo->bCurShortGI40MHz) | |
94a79942 | 2174 | ratr_value |= 0x80000000; |
52629477 LF |
2175 | else if (!ieee->pHTInfo->bCurTxBW40MHz && |
2176 | ieee->pHTInfo->bCurShortGI20MHz) | |
94a79942 | 2177 | ratr_value |= 0x80000000; |
8ea54100 | 2178 | rtl92e_writel(dev, RATR0+rate_index*4, ratr_value); |
d8ae1967 | 2179 | rtl92e_writeb(dev, UFWP, 1); |
94a79942 LF |
2180 | } |
2181 | ||
2182 | void | |
df85a131 | 2183 | rtl92e_init_variables(struct net_device *dev) |
94a79942 LF |
2184 | { |
2185 | struct r8192_priv *priv = rtllib_priv(dev); | |
2186 | ||
94a79942 | 2187 | strcpy(priv->nick, "rtl8192E"); |
94a79942 | 2188 | |
94a79942 LF |
2189 | priv->rtllib->softmac_features = IEEE_SOFTMAC_SCAN | |
2190 | IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ | | |
8852112e | 2191 | IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE; |
94a79942 | 2192 | |
a07dc3d1 | 2193 | priv->rtllib->tx_headroom = sizeof(struct tx_fwinfo_8190pci); |
94a79942 LF |
2194 | |
2195 | priv->ShortRetryLimit = 0x30; | |
2196 | priv->LongRetryLimit = 0x30; | |
2197 | ||
94a79942 LF |
2198 | priv->ReceiveConfig = RCR_ADD3 | |
2199 | RCR_AMF | RCR_ADF | | |
2200 | RCR_AICV | | |
2201 | RCR_AB | RCR_AM | RCR_APM | | |
2202 | RCR_AAP | ((u32)7<<RCR_MXDMA_OFFSET) | | |
2203 | ((u32)7 << RCR_FIFO_OFFSET) | RCR_ONLYERLPKT; | |
2204 | ||
52629477 LF |
2205 | priv->irq_mask[0] = (u32)(IMR_ROK | IMR_VODOK | IMR_VIDOK | |
2206 | IMR_BEDOK | IMR_BKDOK | IMR_HCCADOK | | |
2207 | IMR_MGNTDOK | IMR_COMDOK | IMR_HIGHDOK | | |
2208 | IMR_BDOK | IMR_RXCMDOK | IMR_TIMEOUT0 | | |
2209 | IMR_RDU | IMR_RXFOVW | IMR_TXFOVW | | |
2210 | IMR_BcnInt | IMR_TBDOK | IMR_TBDER); | |
94a79942 | 2211 | |
94a79942 LF |
2212 | priv->PwrDomainProtect = false; |
2213 | ||
014e4c27 | 2214 | priv->bfirst_after_down = false; |
94a79942 LF |
2215 | } |
2216 | ||
6d99c68e | 2217 | void rtl92e_enable_irq(struct net_device *dev) |
94a79942 LF |
2218 | { |
2219 | struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); | |
3a6b70c3 | 2220 | |
94a79942 LF |
2221 | priv->irq_enabled = 1; |
2222 | ||
8ea54100 | 2223 | rtl92e_writel(dev, INTA_MASK, priv->irq_mask[0]); |
94a79942 | 2224 | |
94a79942 LF |
2225 | } |
2226 | ||
baadea56 | 2227 | void rtl92e_disable_irq(struct net_device *dev) |
94a79942 LF |
2228 | { |
2229 | struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); | |
2230 | ||
8ea54100 | 2231 | rtl92e_writel(dev, INTA_MASK, 0); |
94a79942 | 2232 | |
94a79942 LF |
2233 | priv->irq_enabled = 0; |
2234 | } | |
2235 | ||
dc578b41 | 2236 | void rtl92e_clear_irq(struct net_device *dev) |
94a79942 | 2237 | { |
7949be66 | 2238 | u32 tmp; |
3a6b70c3 | 2239 | |
99aa47e0 | 2240 | tmp = rtl92e_readl(dev, ISR); |
8ea54100 | 2241 | rtl92e_writel(dev, ISR, tmp); |
94a79942 LF |
2242 | } |
2243 | ||
2244 | ||
78c352b2 | 2245 | void rtl92e_enable_rx(struct net_device *dev) |
94a79942 | 2246 | { |
52629477 | 2247 | struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); |
3a6b70c3 | 2248 | |
8ea54100 | 2249 | rtl92e_writel(dev, RDQDA, priv->rx_ring_dma[RX_MPDU_QUEUE]); |
94a79942 LF |
2250 | } |
2251 | ||
52629477 LF |
2252 | static const u32 TX_DESC_BASE[] = { |
2253 | BKQDA, BEQDA, VIQDA, VOQDA, HCCAQDA, CQDA, MQDA, HQDA, BQDA | |
2254 | }; | |
2255 | ||
6af7a8b6 | 2256 | void rtl92e_enable_tx(struct net_device *dev) |
94a79942 | 2257 | { |
52629477 LF |
2258 | struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); |
2259 | u32 i; | |
94a79942 | 2260 | |
52629477 | 2261 | for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) |
8ea54100 | 2262 | rtl92e_writel(dev, TX_DESC_BASE[i], priv->tx_ring[i].dma); |
94a79942 LF |
2263 | } |
2264 | ||
2265 | ||
a57165d1 | 2266 | void rtl92e_ack_irq(struct net_device *dev, u32 *p_inta, u32 *p_intb) |
94a79942 | 2267 | { |
99aa47e0 | 2268 | *p_inta = rtl92e_readl(dev, ISR); |
8ea54100 | 2269 | rtl92e_writel(dev, ISR, *p_inta); |
94a79942 LF |
2270 | } |
2271 | ||
4d73bd26 | 2272 | bool rtl92e_is_rx_stuck(struct net_device *dev) |
94a79942 LF |
2273 | { |
2274 | struct r8192_priv *priv = rtllib_priv(dev); | |
1c0a7c0e | 2275 | u16 RegRxCounter = rtl92e_readw(dev, 0x130); |
94a79942 | 2276 | bool bStuck = false; |
52629477 | 2277 | static u8 rx_chk_cnt; |
94a79942 LF |
2278 | u32 SlotIndex = 0, TotalRxStuckCount = 0; |
2279 | u8 i; | |
2280 | u8 SilentResetRxSoltNum = 4; | |
2281 | ||
52629477 LF |
2282 | RT_TRACE(COMP_RESET, "%s(): RegRxCounter is %d, RxCounter is %d\n", |
2283 | __func__, RegRxCounter, priv->RxCounter); | |
94a79942 LF |
2284 | |
2285 | rx_chk_cnt++; | |
52629477 | 2286 | if (priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5)) { |
94a79942 | 2287 | rx_chk_cnt = 0; |
52629477 LF |
2288 | } else if ((priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High + 5)) |
2289 | && (((priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20) && | |
2290 | (priv->undecorated_smoothed_pwdb >= RateAdaptiveTH_Low_40M)) | |
2291 | || ((priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20) && | |
2292 | (priv->undecorated_smoothed_pwdb >= RateAdaptiveTH_Low_20M)))) { | |
2293 | if (rx_chk_cnt < 2) | |
94a79942 | 2294 | return bStuck; |
285b7c00 | 2295 | rx_chk_cnt = 0; |
94a79942 LF |
2296 | } else if ((((priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20) && |
2297 | (priv->undecorated_smoothed_pwdb < RateAdaptiveTH_Low_40M)) || | |
2298 | ((priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20) && | |
2299 | (priv->undecorated_smoothed_pwdb < RateAdaptiveTH_Low_20M))) && | |
2300 | priv->undecorated_smoothed_pwdb >= VeryLowRSSI) { | |
52629477 | 2301 | if (rx_chk_cnt < 4) |
94a79942 | 2302 | return bStuck; |
285b7c00 | 2303 | rx_chk_cnt = 0; |
94a79942 | 2304 | } else { |
52629477 | 2305 | if (rx_chk_cnt < 8) |
94a79942 | 2306 | return bStuck; |
285b7c00 | 2307 | rx_chk_cnt = 0; |
94a79942 LF |
2308 | } |
2309 | ||
2310 | ||
2311 | SlotIndex = (priv->SilentResetRxSlotIndex++)%SilentResetRxSoltNum; | |
2312 | ||
52629477 | 2313 | if (priv->RxCounter == RegRxCounter) { |
94a79942 LF |
2314 | priv->SilentResetRxStuckEvent[SlotIndex] = 1; |
2315 | ||
52629477 | 2316 | for (i = 0; i < SilentResetRxSoltNum; i++) |
94a79942 LF |
2317 | TotalRxStuckCount += priv->SilentResetRxStuckEvent[i]; |
2318 | ||
52629477 LF |
2319 | if (TotalRxStuckCount == SilentResetRxSoltNum) { |
2320 | bStuck = true; | |
2321 | for (i = 0; i < SilentResetRxSoltNum; i++) | |
2322 | TotalRxStuckCount += | |
2323 | priv->SilentResetRxStuckEvent[i]; | |
94a79942 LF |
2324 | } |
2325 | ||
2326 | ||
2327 | } else { | |
2328 | priv->SilentResetRxStuckEvent[SlotIndex] = 0; | |
2329 | } | |
2330 | ||
2331 | priv->RxCounter = RegRxCounter; | |
2332 | ||
2333 | return bStuck; | |
2334 | } | |
2335 | ||
c9cf5e78 | 2336 | bool rtl92e_is_tx_stuck(struct net_device *dev) |
94a79942 LF |
2337 | { |
2338 | struct r8192_priv *priv = rtllib_priv(dev); | |
2339 | bool bStuck = false; | |
1c0a7c0e | 2340 | u16 RegTxCounter = rtl92e_readw(dev, 0x128); |
94a79942 LF |
2341 | |
2342 | RT_TRACE(COMP_RESET, "%s():RegTxCounter is %d,TxCounter is %d\n", | |
52629477 | 2343 | __func__, RegTxCounter, priv->TxCounter); |
94a79942 LF |
2344 | |
2345 | if (priv->TxCounter == RegTxCounter) | |
2346 | bStuck = true; | |
2347 | ||
2348 | priv->TxCounter = RegTxCounter; | |
2349 | ||
2350 | return bStuck; | |
2351 | } | |
2352 | ||
56a5b5af | 2353 | bool rtl92e_get_nmode_support_by_sec(struct net_device *dev) |
94a79942 | 2354 | { |
94a79942 LF |
2355 | struct r8192_priv *priv = rtllib_priv(dev); |
2356 | struct rtllib_device *ieee = priv->rtllib; | |
3a6b70c3 | 2357 | |
94a79942 | 2358 | if (ieee->rtllib_ap_sec_type && |
52629477 LF |
2359 | (ieee->rtllib_ap_sec_type(priv->rtllib)&(SEC_ALG_WEP | |
2360 | SEC_ALG_TKIP))) { | |
94a79942 LF |
2361 | return false; |
2362 | } else { | |
2363 | return true; | |
2364 | } | |
94a79942 LF |
2365 | } |
2366 | ||
86534a29 | 2367 | bool rtl92e_is_halfn_supported_by_ap(struct net_device *dev) |
94a79942 | 2368 | { |
52629477 LF |
2369 | struct r8192_priv *priv = rtllib_priv(dev); |
2370 | struct rtllib_device *ieee = priv->rtllib; | |
94a79942 | 2371 | |
99d4f5d2 | 2372 | return ieee->bHalfWirelessN24GMode; |
94a79942 | 2373 | } |