1 /****************************************************************************** 2 * 3 * Copyright(c) 2009-2012 Realtek Corporation. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of version 2 of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 * more details. 13 * 14 * The full GNU General Public License is included in this distribution in the 15 * file called LICENSE. 16 * 17 * Contact Information: 18 * wlanfae <wlanfae@realtek.com> 19 * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park, 20 * Hsinchu 300, Taiwan. 21 * 22 * Larry Finger <Larry.Finger@lwfinger.net> 23 * 24 *****************************************************************************/ 25 26 #include "wifi.h" 27 #include "rc.h" 28 #include "base.h" 29 #include "efuse.h" 30 #include "cam.h" 31 #include "ps.h" 32 #include "regd.h" 33 #include "pci.h" 34 #include <linux/ip.h> 35 #include <linux/module.h> 36 #include <linux/udp.h> 37 38 /* 39 *NOTICE!!!: This file will be very big, we should 40 *keep it clear under following roles: 41 * 42 *This file include following parts, so, if you add new 43 *functions into this file, please check which part it 44 *should includes. or check if you should add new part 45 *for this file: 46 * 47 *1) mac80211 init functions 48 *2) tx information functions 49 *3) functions called by core.c 50 *4) wq & timer callback functions 51 *5) frame process functions 52 *6) IOT functions 53 *7) sysfs functions 54 *8) vif functions 55 *9) ... 56 */ 57 58 /********************************************************* 59 * 60 * mac80211 init functions 61 * 62 *********************************************************/ 63 static struct ieee80211_channel rtl_channeltable_2g[] = { 64 {.center_freq = 2412, .hw_value = 1,}, 65 {.center_freq = 2417, .hw_value = 2,}, 66 {.center_freq = 2422, .hw_value = 3,}, 67 {.center_freq = 2427, .hw_value = 4,}, 68 {.center_freq = 2432, .hw_value = 5,}, 69 {.center_freq = 2437, .hw_value = 6,}, 70 {.center_freq = 2442, .hw_value = 7,}, 71 {.center_freq = 2447, .hw_value = 8,}, 72 {.center_freq = 2452, .hw_value = 9,}, 73 {.center_freq = 2457, .hw_value = 10,}, 74 {.center_freq = 2462, .hw_value = 11,}, 75 {.center_freq = 2467, .hw_value = 12,}, 76 {.center_freq = 2472, .hw_value = 13,}, 77 {.center_freq = 2484, .hw_value = 14,}, 78 }; 79 80 static struct ieee80211_channel rtl_channeltable_5g[] = { 81 {.center_freq = 5180, .hw_value = 36,}, 82 {.center_freq = 5200, .hw_value = 40,}, 83 {.center_freq = 5220, .hw_value = 44,}, 84 {.center_freq = 5240, .hw_value = 48,}, 85 {.center_freq = 5260, .hw_value = 52,}, 86 {.center_freq = 5280, .hw_value = 56,}, 87 {.center_freq = 5300, .hw_value = 60,}, 88 {.center_freq = 5320, .hw_value = 64,}, 89 {.center_freq = 5500, .hw_value = 100,}, 90 {.center_freq = 5520, .hw_value = 104,}, 91 {.center_freq = 5540, .hw_value = 108,}, 92 {.center_freq = 5560, .hw_value = 112,}, 93 {.center_freq = 5580, .hw_value = 116,}, 94 {.center_freq = 5600, .hw_value = 120,}, 95 {.center_freq = 5620, .hw_value = 124,}, 96 {.center_freq = 5640, .hw_value = 128,}, 97 {.center_freq = 5660, .hw_value = 132,}, 98 {.center_freq = 5680, .hw_value = 136,}, 99 {.center_freq = 5700, .hw_value = 140,}, 100 {.center_freq = 5745, .hw_value = 149,}, 101 {.center_freq = 5765, .hw_value = 153,}, 102 {.center_freq = 5785, .hw_value = 157,}, 103 {.center_freq = 5805, .hw_value = 161,}, 104 {.center_freq = 5825, .hw_value = 165,}, 105 }; 106 107 static struct ieee80211_rate rtl_ratetable_2g[] = { 108 {.bitrate = 10, .hw_value = 0x00,}, 109 {.bitrate = 20, .hw_value = 0x01,}, 110 {.bitrate = 55, .hw_value = 0x02,}, 111 {.bitrate = 110, .hw_value = 0x03,}, 112 {.bitrate = 60, .hw_value = 0x04,}, 113 {.bitrate = 90, .hw_value = 0x05,}, 114 {.bitrate = 120, .hw_value = 0x06,}, 115 {.bitrate = 180, .hw_value = 0x07,}, 116 {.bitrate = 240, .hw_value = 0x08,}, 117 {.bitrate = 360, .hw_value = 0x09,}, 118 {.bitrate = 480, .hw_value = 0x0a,}, 119 {.bitrate = 540, .hw_value = 0x0b,}, 120 }; 121 122 static struct ieee80211_rate rtl_ratetable_5g[] = { 123 {.bitrate = 60, .hw_value = 0x04,}, 124 {.bitrate = 90, .hw_value = 0x05,}, 125 {.bitrate = 120, .hw_value = 0x06,}, 126 {.bitrate = 180, .hw_value = 0x07,}, 127 {.bitrate = 240, .hw_value = 0x08,}, 128 {.bitrate = 360, .hw_value = 0x09,}, 129 {.bitrate = 480, .hw_value = 0x0a,}, 130 {.bitrate = 540, .hw_value = 0x0b,}, 131 }; 132 133 static const struct ieee80211_supported_band rtl_band_2ghz = { 134 .band = NL80211_BAND_2GHZ, 135 136 .channels = rtl_channeltable_2g, 137 .n_channels = ARRAY_SIZE(rtl_channeltable_2g), 138 139 .bitrates = rtl_ratetable_2g, 140 .n_bitrates = ARRAY_SIZE(rtl_ratetable_2g), 141 142 .ht_cap = {0}, 143 }; 144 145 static struct ieee80211_supported_band rtl_band_5ghz = { 146 .band = NL80211_BAND_5GHZ, 147 148 .channels = rtl_channeltable_5g, 149 .n_channels = ARRAY_SIZE(rtl_channeltable_5g), 150 151 .bitrates = rtl_ratetable_5g, 152 .n_bitrates = ARRAY_SIZE(rtl_ratetable_5g), 153 154 .ht_cap = {0}, 155 }; 156 157 static const u8 tid_to_ac[] = { 158 2, /* IEEE80211_AC_BE */ 159 3, /* IEEE80211_AC_BK */ 160 3, /* IEEE80211_AC_BK */ 161 2, /* IEEE80211_AC_BE */ 162 1, /* IEEE80211_AC_VI */ 163 1, /* IEEE80211_AC_VI */ 164 0, /* IEEE80211_AC_VO */ 165 0, /* IEEE80211_AC_VO */ 166 }; 167 168 u8 rtl_tid_to_ac(u8 tid) 169 { 170 return tid_to_ac[tid]; 171 } 172 EXPORT_SYMBOL_GPL(rtl_tid_to_ac); 173 174 static void _rtl_init_hw_ht_capab(struct ieee80211_hw *hw, 175 struct ieee80211_sta_ht_cap *ht_cap) 176 { 177 struct rtl_priv *rtlpriv = rtl_priv(hw); 178 struct rtl_phy *rtlphy = &(rtlpriv->phy); 179 180 ht_cap->ht_supported = true; 181 ht_cap->cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 | 182 IEEE80211_HT_CAP_SGI_40 | 183 IEEE80211_HT_CAP_SGI_20 | 184 IEEE80211_HT_CAP_DSSSCCK40 | IEEE80211_HT_CAP_MAX_AMSDU; 185 186 if (rtlpriv->rtlhal.disable_amsdu_8k) 187 ht_cap->cap &= ~IEEE80211_HT_CAP_MAX_AMSDU; 188 189 /* 190 *Maximum length of AMPDU that the STA can receive. 191 *Length = 2 ^ (13 + max_ampdu_length_exp) - 1 (octets) 192 */ 193 ht_cap->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 194 195 /*Minimum MPDU start spacing , */ 196 ht_cap->ampdu_density = IEEE80211_HT_MPDU_DENSITY_16; 197 198 ht_cap->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED; 199 200 /*hw->wiphy->bands[NL80211_BAND_2GHZ] 201 *base on ant_num 202 *rx_mask: RX mask 203 *if rx_ant = 1 rx_mask[0]= 0xff;==>MCS0-MCS7 204 *if rx_ant = 2 rx_mask[1]= 0xff;==>MCS8-MCS15 205 *if rx_ant >= 3 rx_mask[2]= 0xff; 206 *if BW_40 rx_mask[4]= 0x01; 207 *highest supported RX rate 208 */ 209 if (rtlpriv->dm.supp_phymode_switch) { 210 pr_info("Support phy mode switch\n"); 211 212 ht_cap->mcs.rx_mask[0] = 0xFF; 213 ht_cap->mcs.rx_mask[1] = 0xFF; 214 ht_cap->mcs.rx_mask[4] = 0x01; 215 216 ht_cap->mcs.rx_highest = cpu_to_le16(MAX_BIT_RATE_40MHZ_MCS15); 217 } else { 218 if (get_rf_type(rtlphy) == RF_1T2R || 219 get_rf_type(rtlphy) == RF_2T2R) { 220 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 221 "1T2R or 2T2R\n"); 222 ht_cap->mcs.rx_mask[0] = 0xFF; 223 ht_cap->mcs.rx_mask[1] = 0xFF; 224 ht_cap->mcs.rx_mask[4] = 0x01; 225 226 ht_cap->mcs.rx_highest = 227 cpu_to_le16(MAX_BIT_RATE_40MHZ_MCS15); 228 } else if (get_rf_type(rtlphy) == RF_1T1R) { 229 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "1T1R\n"); 230 231 ht_cap->mcs.rx_mask[0] = 0xFF; 232 ht_cap->mcs.rx_mask[1] = 0x00; 233 ht_cap->mcs.rx_mask[4] = 0x01; 234 235 ht_cap->mcs.rx_highest = 236 cpu_to_le16(MAX_BIT_RATE_40MHZ_MCS7); 237 } 238 } 239 } 240 241 static void _rtl_init_hw_vht_capab(struct ieee80211_hw *hw, 242 struct ieee80211_sta_vht_cap *vht_cap) 243 { 244 struct rtl_priv *rtlpriv = rtl_priv(hw); 245 struct rtl_hal *rtlhal = rtl_hal(rtlpriv); 246 247 if (!(rtlpriv->cfg->spec_ver & RTL_SPEC_SUPPORT_VHT)) 248 return; 249 250 if (rtlhal->hw_type == HARDWARE_TYPE_RTL8812AE || 251 rtlhal->hw_type == HARDWARE_TYPE_RTL8822BE) { 252 u16 mcs_map; 253 254 vht_cap->vht_supported = true; 255 vht_cap->cap = 256 IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454 | 257 IEEE80211_VHT_CAP_SHORT_GI_80 | 258 IEEE80211_VHT_CAP_TXSTBC | 259 IEEE80211_VHT_CAP_RXSTBC_1 | 260 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE | 261 IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE | 262 IEEE80211_VHT_CAP_HTC_VHT | 263 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK | 264 IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN | 265 IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN | 266 0; 267 268 mcs_map = IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 | 269 IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 | 270 IEEE80211_VHT_MCS_NOT_SUPPORTED << 4 | 271 IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 | 272 IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 | 273 IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 | 274 IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 | 275 IEEE80211_VHT_MCS_NOT_SUPPORTED << 14; 276 277 vht_cap->vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map); 278 vht_cap->vht_mcs.rx_highest = 279 cpu_to_le16(MAX_BIT_RATE_SHORT_GI_2NSS_80MHZ_MCS9); 280 vht_cap->vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map); 281 vht_cap->vht_mcs.tx_highest = 282 cpu_to_le16(MAX_BIT_RATE_SHORT_GI_2NSS_80MHZ_MCS9); 283 } else if (rtlhal->hw_type == HARDWARE_TYPE_RTL8821AE) { 284 u16 mcs_map; 285 286 vht_cap->vht_supported = true; 287 vht_cap->cap = 288 IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454 | 289 IEEE80211_VHT_CAP_SHORT_GI_80 | 290 IEEE80211_VHT_CAP_TXSTBC | 291 IEEE80211_VHT_CAP_RXSTBC_1 | 292 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE | 293 IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE | 294 IEEE80211_VHT_CAP_HTC_VHT | 295 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK | 296 IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN | 297 IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN | 298 0; 299 300 mcs_map = IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 | 301 IEEE80211_VHT_MCS_NOT_SUPPORTED << 2 | 302 IEEE80211_VHT_MCS_NOT_SUPPORTED << 4 | 303 IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 | 304 IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 | 305 IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 | 306 IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 | 307 IEEE80211_VHT_MCS_NOT_SUPPORTED << 14; 308 309 vht_cap->vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map); 310 vht_cap->vht_mcs.rx_highest = 311 cpu_to_le16(MAX_BIT_RATE_SHORT_GI_1NSS_80MHZ_MCS9); 312 vht_cap->vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map); 313 vht_cap->vht_mcs.tx_highest = 314 cpu_to_le16(MAX_BIT_RATE_SHORT_GI_1NSS_80MHZ_MCS9); 315 } 316 } 317 318 static void _rtl_init_mac80211(struct ieee80211_hw *hw) 319 { 320 struct rtl_priv *rtlpriv = rtl_priv(hw); 321 struct rtl_hal *rtlhal = rtl_hal(rtlpriv); 322 struct rtl_mac *rtlmac = rtl_mac(rtl_priv(hw)); 323 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 324 struct ieee80211_supported_band *sband; 325 326 if (rtlhal->macphymode == SINGLEMAC_SINGLEPHY && 327 rtlhal->bandset == BAND_ON_BOTH) { 328 /* 1: 2.4 G bands */ 329 /* <1> use mac->bands as mem for hw->wiphy->bands */ 330 sband = &(rtlmac->bands[NL80211_BAND_2GHZ]); 331 332 /* <2> set hw->wiphy->bands[NL80211_BAND_2GHZ] 333 * to default value(1T1R) */ 334 memcpy(&(rtlmac->bands[NL80211_BAND_2GHZ]), &rtl_band_2ghz, 335 sizeof(struct ieee80211_supported_band)); 336 337 /* <3> init ht cap base on ant_num */ 338 _rtl_init_hw_ht_capab(hw, &sband->ht_cap); 339 340 /* <4> set mac->sband to wiphy->sband */ 341 hw->wiphy->bands[NL80211_BAND_2GHZ] = sband; 342 343 /* 2: 5 G bands */ 344 /* <1> use mac->bands as mem for hw->wiphy->bands */ 345 sband = &(rtlmac->bands[NL80211_BAND_5GHZ]); 346 347 /* <2> set hw->wiphy->bands[NL80211_BAND_5GHZ] 348 * to default value(1T1R) */ 349 memcpy(&(rtlmac->bands[NL80211_BAND_5GHZ]), &rtl_band_5ghz, 350 sizeof(struct ieee80211_supported_band)); 351 352 /* <3> init ht cap base on ant_num */ 353 _rtl_init_hw_ht_capab(hw, &sband->ht_cap); 354 355 _rtl_init_hw_vht_capab(hw, &sband->vht_cap); 356 /* <4> set mac->sband to wiphy->sband */ 357 hw->wiphy->bands[NL80211_BAND_5GHZ] = sband; 358 } else { 359 if (rtlhal->current_bandtype == BAND_ON_2_4G) { 360 /* <1> use mac->bands as mem for hw->wiphy->bands */ 361 sband = &(rtlmac->bands[NL80211_BAND_2GHZ]); 362 363 /* <2> set hw->wiphy->bands[NL80211_BAND_2GHZ] 364 * to default value(1T1R) */ 365 memcpy(&(rtlmac->bands[NL80211_BAND_2GHZ]), 366 &rtl_band_2ghz, 367 sizeof(struct ieee80211_supported_band)); 368 369 /* <3> init ht cap base on ant_num */ 370 _rtl_init_hw_ht_capab(hw, &sband->ht_cap); 371 372 /* <4> set mac->sband to wiphy->sband */ 373 hw->wiphy->bands[NL80211_BAND_2GHZ] = sband; 374 } else if (rtlhal->current_bandtype == BAND_ON_5G) { 375 /* <1> use mac->bands as mem for hw->wiphy->bands */ 376 sband = &(rtlmac->bands[NL80211_BAND_5GHZ]); 377 378 /* <2> set hw->wiphy->bands[NL80211_BAND_5GHZ] 379 * to default value(1T1R) */ 380 memcpy(&(rtlmac->bands[NL80211_BAND_5GHZ]), 381 &rtl_band_5ghz, 382 sizeof(struct ieee80211_supported_band)); 383 384 /* <3> init ht cap base on ant_num */ 385 _rtl_init_hw_ht_capab(hw, &sband->ht_cap); 386 387 _rtl_init_hw_vht_capab(hw, &sband->vht_cap); 388 /* <4> set mac->sband to wiphy->sband */ 389 hw->wiphy->bands[NL80211_BAND_5GHZ] = sband; 390 } else { 391 pr_err("Err BAND %d\n", 392 rtlhal->current_bandtype); 393 } 394 } 395 /* <5> set hw caps */ 396 ieee80211_hw_set(hw, SIGNAL_DBM); 397 ieee80211_hw_set(hw, RX_INCLUDES_FCS); 398 ieee80211_hw_set(hw, AMPDU_AGGREGATION); 399 ieee80211_hw_set(hw, MFP_CAPABLE); 400 ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS); 401 ieee80211_hw_set(hw, SUPPORTS_AMSDU_IN_AMPDU); 402 ieee80211_hw_set(hw, SUPPORT_FAST_XMIT); 403 404 /* swlps or hwlps has been set in diff chip in init_sw_vars */ 405 if (rtlpriv->psc.swctrl_lps) { 406 ieee80211_hw_set(hw, SUPPORTS_PS); 407 ieee80211_hw_set(hw, PS_NULLFUNC_STACK); 408 } 409 if (rtlpriv->psc.fwctrl_lps) { 410 ieee80211_hw_set(hw, SUPPORTS_PS); 411 ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS); 412 } 413 hw->wiphy->interface_modes = 414 BIT(NL80211_IFTYPE_AP) | 415 BIT(NL80211_IFTYPE_STATION) | 416 BIT(NL80211_IFTYPE_ADHOC) | 417 BIT(NL80211_IFTYPE_MESH_POINT) | 418 BIT(NL80211_IFTYPE_P2P_CLIENT) | 419 BIT(NL80211_IFTYPE_P2P_GO); 420 hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 421 422 hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 423 424 hw->wiphy->rts_threshold = 2347; 425 426 hw->queues = AC_MAX; 427 hw->extra_tx_headroom = RTL_TX_HEADER_SIZE; 428 429 /* TODO: Correct this value for our hw */ 430 hw->max_listen_interval = MAX_LISTEN_INTERVAL; 431 hw->max_rate_tries = MAX_RATE_TRIES; 432 /* hw->max_rates = 1; */ 433 hw->sta_data_size = sizeof(struct rtl_sta_info); 434 435 /* wowlan is not supported by kernel if CONFIG_PM is not defined */ 436 #ifdef CONFIG_PM 437 if (rtlpriv->psc.wo_wlan_mode) { 438 if (rtlpriv->psc.wo_wlan_mode & WAKE_ON_MAGIC_PACKET) 439 rtlpriv->wowlan.flags = WIPHY_WOWLAN_MAGIC_PKT; 440 if (rtlpriv->psc.wo_wlan_mode & WAKE_ON_PATTERN_MATCH) { 441 rtlpriv->wowlan.n_patterns = 442 MAX_SUPPORT_WOL_PATTERN_NUM; 443 rtlpriv->wowlan.pattern_min_len = MIN_WOL_PATTERN_SIZE; 444 rtlpriv->wowlan.pattern_max_len = MAX_WOL_PATTERN_SIZE; 445 } 446 hw->wiphy->wowlan = &rtlpriv->wowlan; 447 } 448 #endif 449 450 /* <6> mac address */ 451 if (is_valid_ether_addr(rtlefuse->dev_addr)) { 452 SET_IEEE80211_PERM_ADDR(hw, rtlefuse->dev_addr); 453 } else { 454 u8 rtlmac1[] = { 0x00, 0xe0, 0x4c, 0x81, 0x92, 0x00 }; 455 get_random_bytes((rtlmac1 + (ETH_ALEN - 1)), 1); 456 SET_IEEE80211_PERM_ADDR(hw, rtlmac1); 457 } 458 } 459 460 static void _rtl_init_deferred_work(struct ieee80211_hw *hw) 461 { 462 struct rtl_priv *rtlpriv = rtl_priv(hw); 463 464 /* <1> timer */ 465 timer_setup(&rtlpriv->works.watchdog_timer, 466 rtl_watch_dog_timer_callback, 0); 467 timer_setup(&rtlpriv->works.dualmac_easyconcurrent_retrytimer, 468 rtl_easy_concurrent_retrytimer_callback, 0); 469 /* <2> work queue */ 470 rtlpriv->works.hw = hw; 471 rtlpriv->works.rtl_wq = alloc_workqueue("%s", 0, 0, rtlpriv->cfg->name); 472 INIT_DELAYED_WORK(&rtlpriv->works.watchdog_wq, 473 (void *)rtl_watchdog_wq_callback); 474 INIT_DELAYED_WORK(&rtlpriv->works.ips_nic_off_wq, 475 (void *)rtl_ips_nic_off_wq_callback); 476 INIT_DELAYED_WORK(&rtlpriv->works.ps_work, 477 (void *)rtl_swlps_wq_callback); 478 INIT_DELAYED_WORK(&rtlpriv->works.ps_rfon_wq, 479 (void *)rtl_swlps_rfon_wq_callback); 480 INIT_DELAYED_WORK(&rtlpriv->works.fwevt_wq, 481 (void *)rtl_fwevt_wq_callback); 482 INIT_DELAYED_WORK(&rtlpriv->works.c2hcmd_wq, 483 (void *)rtl_c2hcmd_wq_callback); 484 485 } 486 487 void rtl_deinit_deferred_work(struct ieee80211_hw *hw, bool ips_wq) 488 { 489 struct rtl_priv *rtlpriv = rtl_priv(hw); 490 491 del_timer_sync(&rtlpriv->works.watchdog_timer); 492 493 cancel_delayed_work_sync(&rtlpriv->works.watchdog_wq); 494 if (ips_wq) 495 cancel_delayed_work(&rtlpriv->works.ips_nic_off_wq); 496 else 497 cancel_delayed_work_sync(&rtlpriv->works.ips_nic_off_wq); 498 cancel_delayed_work_sync(&rtlpriv->works.ps_work); 499 cancel_delayed_work_sync(&rtlpriv->works.ps_rfon_wq); 500 cancel_delayed_work_sync(&rtlpriv->works.fwevt_wq); 501 cancel_delayed_work_sync(&rtlpriv->works.c2hcmd_wq); 502 } 503 EXPORT_SYMBOL_GPL(rtl_deinit_deferred_work); 504 505 void rtl_init_rfkill(struct ieee80211_hw *hw) 506 { 507 struct rtl_priv *rtlpriv = rtl_priv(hw); 508 509 bool radio_state; 510 bool blocked; 511 u8 valid = 0; 512 513 /*set init state to on */ 514 rtlpriv->rfkill.rfkill_state = true; 515 wiphy_rfkill_set_hw_state(hw->wiphy, 0); 516 517 radio_state = rtlpriv->cfg->ops->radio_onoff_checking(hw, &valid); 518 519 if (valid) { 520 pr_info("rtlwifi: wireless switch is %s\n", 521 rtlpriv->rfkill.rfkill_state ? "on" : "off"); 522 523 rtlpriv->rfkill.rfkill_state = radio_state; 524 525 blocked = (rtlpriv->rfkill.rfkill_state == 1) ? 0 : 1; 526 wiphy_rfkill_set_hw_state(hw->wiphy, blocked); 527 } 528 529 wiphy_rfkill_start_polling(hw->wiphy); 530 } 531 EXPORT_SYMBOL(rtl_init_rfkill); 532 533 void rtl_deinit_rfkill(struct ieee80211_hw *hw) 534 { 535 wiphy_rfkill_stop_polling(hw->wiphy); 536 } 537 EXPORT_SYMBOL_GPL(rtl_deinit_rfkill); 538 539 int rtl_init_core(struct ieee80211_hw *hw) 540 { 541 struct rtl_priv *rtlpriv = rtl_priv(hw); 542 struct rtl_mac *rtlmac = rtl_mac(rtl_priv(hw)); 543 544 /* <1> init mac80211 */ 545 _rtl_init_mac80211(hw); 546 rtlmac->hw = hw; 547 548 /* <2> rate control register */ 549 hw->rate_control_algorithm = "rtl_rc"; 550 551 /* 552 * <3> init CRDA must come after init 553 * mac80211 hw in _rtl_init_mac80211. 554 */ 555 if (rtl_regd_init(hw, rtl_reg_notifier)) { 556 pr_err("REGD init failed\n"); 557 return 1; 558 } 559 560 /* <4> locks */ 561 mutex_init(&rtlpriv->locks.conf_mutex); 562 mutex_init(&rtlpriv->locks.ips_mutex); 563 mutex_init(&rtlpriv->locks.lps_mutex); 564 spin_lock_init(&rtlpriv->locks.irq_th_lock); 565 spin_lock_init(&rtlpriv->locks.h2c_lock); 566 spin_lock_init(&rtlpriv->locks.rf_ps_lock); 567 spin_lock_init(&rtlpriv->locks.rf_lock); 568 spin_lock_init(&rtlpriv->locks.waitq_lock); 569 spin_lock_init(&rtlpriv->locks.entry_list_lock); 570 spin_lock_init(&rtlpriv->locks.c2hcmd_lock); 571 spin_lock_init(&rtlpriv->locks.scan_list_lock); 572 spin_lock_init(&rtlpriv->locks.cck_and_rw_pagea_lock); 573 spin_lock_init(&rtlpriv->locks.fw_ps_lock); 574 spin_lock_init(&rtlpriv->locks.iqk_lock); 575 /* <5> init list */ 576 INIT_LIST_HEAD(&rtlpriv->entry_list); 577 INIT_LIST_HEAD(&rtlpriv->scan_list.list); 578 skb_queue_head_init(&rtlpriv->tx_report.queue); 579 skb_queue_head_init(&rtlpriv->c2hcmd_queue); 580 581 rtlmac->link_state = MAC80211_NOLINK; 582 583 /* <6> init deferred work */ 584 _rtl_init_deferred_work(hw); 585 586 return 0; 587 } 588 EXPORT_SYMBOL_GPL(rtl_init_core); 589 590 static void rtl_free_entries_from_scan_list(struct ieee80211_hw *hw); 591 static void rtl_free_entries_from_ack_queue(struct ieee80211_hw *hw, 592 bool timeout); 593 594 void rtl_deinit_core(struct ieee80211_hw *hw) 595 { 596 rtl_c2hcmd_launcher(hw, 0); 597 rtl_free_entries_from_scan_list(hw); 598 rtl_free_entries_from_ack_queue(hw, false); 599 } 600 EXPORT_SYMBOL_GPL(rtl_deinit_core); 601 602 void rtl_init_rx_config(struct ieee80211_hw *hw) 603 { 604 struct rtl_priv *rtlpriv = rtl_priv(hw); 605 struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 606 607 rtlpriv->cfg->ops->get_hw_reg(hw, HW_VAR_RCR, (u8 *) (&mac->rx_conf)); 608 } 609 EXPORT_SYMBOL_GPL(rtl_init_rx_config); 610 611 /********************************************************* 612 * 613 * tx information functions 614 * 615 *********************************************************/ 616 static void _rtl_qurey_shortpreamble_mode(struct ieee80211_hw *hw, 617 struct rtl_tcb_desc *tcb_desc, 618 struct ieee80211_tx_info *info) 619 { 620 struct rtl_priv *rtlpriv = rtl_priv(hw); 621 u8 rate_flag = info->control.rates[0].flags; 622 623 tcb_desc->use_shortpreamble = false; 624 625 /* 1M can only use Long Preamble. 11B spec */ 626 if (tcb_desc->hw_rate == rtlpriv->cfg->maps[RTL_RC_CCK_RATE1M]) 627 return; 628 else if (rate_flag & IEEE80211_TX_RC_USE_SHORT_PREAMBLE) 629 tcb_desc->use_shortpreamble = true; 630 631 return; 632 } 633 634 static void _rtl_query_shortgi(struct ieee80211_hw *hw, 635 struct ieee80211_sta *sta, 636 struct rtl_tcb_desc *tcb_desc, 637 struct ieee80211_tx_info *info) 638 { 639 struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 640 u8 rate_flag = info->control.rates[0].flags; 641 u8 sgi_40 = 0, sgi_20 = 0, bw_40 = 0; 642 u8 sgi_80 = 0, bw_80 = 0; 643 tcb_desc->use_shortgi = false; 644 645 if (sta == NULL) 646 return; 647 648 sgi_40 = sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40; 649 sgi_20 = sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20; 650 sgi_80 = sta->vht_cap.cap & IEEE80211_VHT_CAP_SHORT_GI_80; 651 652 if ((!sta->ht_cap.ht_supported) && (!sta->vht_cap.vht_supported)) 653 return; 654 655 if (!sgi_40 && !sgi_20) 656 return; 657 658 if (mac->opmode == NL80211_IFTYPE_STATION) { 659 bw_40 = mac->bw_40; 660 bw_80 = mac->bw_80; 661 } else if (mac->opmode == NL80211_IFTYPE_AP || 662 mac->opmode == NL80211_IFTYPE_ADHOC || 663 mac->opmode == NL80211_IFTYPE_MESH_POINT) { 664 bw_40 = sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40; 665 bw_80 = sta->vht_cap.vht_supported; 666 } 667 668 if (bw_80) { 669 if (sgi_80) 670 tcb_desc->use_shortgi = true; 671 else 672 tcb_desc->use_shortgi = false; 673 } else { 674 if (bw_40 && sgi_40) 675 tcb_desc->use_shortgi = true; 676 else if (!bw_40 && sgi_20) 677 tcb_desc->use_shortgi = true; 678 } 679 680 if (!(rate_flag & IEEE80211_TX_RC_SHORT_GI)) 681 tcb_desc->use_shortgi = false; 682 } 683 684 static void _rtl_query_protection_mode(struct ieee80211_hw *hw, 685 struct rtl_tcb_desc *tcb_desc, 686 struct ieee80211_tx_info *info) 687 { 688 struct rtl_priv *rtlpriv = rtl_priv(hw); 689 u8 rate_flag = info->control.rates[0].flags; 690 691 /* Common Settings */ 692 tcb_desc->rts_stbc = false; 693 tcb_desc->cts_enable = false; 694 tcb_desc->rts_sc = 0; 695 tcb_desc->rts_bw = false; 696 tcb_desc->rts_use_shortpreamble = false; 697 tcb_desc->rts_use_shortgi = false; 698 699 if (rate_flag & IEEE80211_TX_RC_USE_CTS_PROTECT) { 700 /* Use CTS-to-SELF in protection mode. */ 701 tcb_desc->rts_enable = true; 702 tcb_desc->cts_enable = true; 703 tcb_desc->rts_rate = rtlpriv->cfg->maps[RTL_RC_OFDM_RATE24M]; 704 } else if (rate_flag & IEEE80211_TX_RC_USE_RTS_CTS) { 705 /* Use RTS-CTS in protection mode. */ 706 tcb_desc->rts_enable = true; 707 tcb_desc->rts_rate = rtlpriv->cfg->maps[RTL_RC_OFDM_RATE24M]; 708 } 709 } 710 711 u8 rtl_mrate_idx_to_arfr_id(struct ieee80211_hw *hw, u8 rate_index, 712 enum wireless_mode wirelessmode) 713 { 714 struct rtl_priv *rtlpriv = rtl_priv(hw); 715 struct rtl_phy *rtlphy = &rtlpriv->phy; 716 u8 ret = 0; 717 718 switch (rate_index) { 719 case RATR_INX_WIRELESS_NGB: 720 if (rtlphy->rf_type == RF_1T1R) 721 ret = RATEID_IDX_BGN_40M_1SS; 722 else 723 ret = RATEID_IDX_BGN_40M_2SS; 724 ; break; 725 case RATR_INX_WIRELESS_N: 726 case RATR_INX_WIRELESS_NG: 727 if (rtlphy->rf_type == RF_1T1R) 728 ret = RATEID_IDX_GN_N1SS; 729 else 730 ret = RATEID_IDX_GN_N2SS; 731 ; break; 732 case RATR_INX_WIRELESS_NB: 733 if (rtlphy->rf_type == RF_1T1R) 734 ret = RATEID_IDX_BGN_20M_1SS_BN; 735 else 736 ret = RATEID_IDX_BGN_20M_2SS_BN; 737 ; break; 738 case RATR_INX_WIRELESS_GB: 739 ret = RATEID_IDX_BG; 740 break; 741 case RATR_INX_WIRELESS_G: 742 ret = RATEID_IDX_G; 743 break; 744 case RATR_INX_WIRELESS_B: 745 ret = RATEID_IDX_B; 746 break; 747 case RATR_INX_WIRELESS_MC: 748 if (wirelessmode == WIRELESS_MODE_B || 749 wirelessmode == WIRELESS_MODE_G || 750 wirelessmode == WIRELESS_MODE_N_24G || 751 wirelessmode == WIRELESS_MODE_AC_24G) 752 ret = RATEID_IDX_BG; 753 else 754 ret = RATEID_IDX_G; 755 break; 756 case RATR_INX_WIRELESS_AC_5N: 757 if (rtlphy->rf_type == RF_1T1R) 758 ret = RATEID_IDX_VHT_1SS; 759 else 760 ret = RATEID_IDX_VHT_2SS; 761 break; 762 case RATR_INX_WIRELESS_AC_24N: 763 if (rtlphy->current_chan_bw == HT_CHANNEL_WIDTH_80) { 764 if (rtlphy->rf_type == RF_1T1R) 765 ret = RATEID_IDX_VHT_1SS; 766 else 767 ret = RATEID_IDX_VHT_2SS; 768 } else { 769 if (rtlphy->rf_type == RF_1T1R) 770 ret = RATEID_IDX_MIX1; 771 else 772 ret = RATEID_IDX_MIX2; 773 } 774 break; 775 default: 776 ret = RATEID_IDX_BGN_40M_2SS; 777 break; 778 } 779 return ret; 780 } 781 EXPORT_SYMBOL(rtl_mrate_idx_to_arfr_id); 782 783 static void _rtl_txrate_selectmode(struct ieee80211_hw *hw, 784 struct ieee80211_sta *sta, 785 struct rtl_tcb_desc *tcb_desc) 786 { 787 #define SET_RATE_ID(rate_id) \ 788 ({typeof(rate_id) _id = rate_id; \ 789 ((rtlpriv->cfg->spec_ver & RTL_SPEC_NEW_RATEID) ? \ 790 rtl_mrate_idx_to_arfr_id(hw, _id, \ 791 (sta_entry ? sta_entry->wireless_mode : \ 792 WIRELESS_MODE_G)) : \ 793 _id); }) 794 795 struct rtl_priv *rtlpriv = rtl_priv(hw); 796 struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 797 struct rtl_sta_info *sta_entry = NULL; 798 u8 ratr_index = SET_RATE_ID(RATR_INX_WIRELESS_MC); 799 800 if (sta) { 801 sta_entry = (struct rtl_sta_info *) sta->drv_priv; 802 ratr_index = sta_entry->ratr_index; 803 } 804 if (!tcb_desc->disable_ratefallback || !tcb_desc->use_driver_rate) { 805 if (mac->opmode == NL80211_IFTYPE_STATION) { 806 tcb_desc->ratr_index = 0; 807 } else if (mac->opmode == NL80211_IFTYPE_ADHOC || 808 mac->opmode == NL80211_IFTYPE_MESH_POINT) { 809 if (tcb_desc->multicast || tcb_desc->broadcast) { 810 tcb_desc->hw_rate = 811 rtlpriv->cfg->maps[RTL_RC_CCK_RATE2M]; 812 tcb_desc->use_driver_rate = 1; 813 tcb_desc->ratr_index = 814 SET_RATE_ID(RATR_INX_WIRELESS_MC); 815 } else { 816 tcb_desc->ratr_index = ratr_index; 817 } 818 } else if (mac->opmode == NL80211_IFTYPE_AP) { 819 tcb_desc->ratr_index = ratr_index; 820 } 821 } 822 823 if (rtlpriv->dm.useramask) { 824 tcb_desc->ratr_index = ratr_index; 825 /* TODO we will differentiate adhoc and station future */ 826 if (mac->opmode == NL80211_IFTYPE_STATION || 827 mac->opmode == NL80211_IFTYPE_MESH_POINT) { 828 tcb_desc->mac_id = 0; 829 830 if (sta && 831 (rtlpriv->cfg->spec_ver & RTL_SPEC_NEW_RATEID)) 832 ; /* use sta_entry->ratr_index */ 833 else if (mac->mode == WIRELESS_MODE_AC_5G) 834 tcb_desc->ratr_index = 835 SET_RATE_ID(RATR_INX_WIRELESS_AC_5N); 836 else if (mac->mode == WIRELESS_MODE_AC_24G) 837 tcb_desc->ratr_index = 838 SET_RATE_ID(RATR_INX_WIRELESS_AC_24N); 839 else if (mac->mode == WIRELESS_MODE_N_24G) 840 tcb_desc->ratr_index = 841 SET_RATE_ID(RATR_INX_WIRELESS_NGB); 842 else if (mac->mode == WIRELESS_MODE_N_5G) 843 tcb_desc->ratr_index = 844 SET_RATE_ID(RATR_INX_WIRELESS_NG); 845 else if (mac->mode & WIRELESS_MODE_G) 846 tcb_desc->ratr_index = 847 SET_RATE_ID(RATR_INX_WIRELESS_GB); 848 else if (mac->mode & WIRELESS_MODE_B) 849 tcb_desc->ratr_index = 850 SET_RATE_ID(RATR_INX_WIRELESS_B); 851 else if (mac->mode & WIRELESS_MODE_A) 852 tcb_desc->ratr_index = 853 SET_RATE_ID(RATR_INX_WIRELESS_G); 854 855 } else if (mac->opmode == NL80211_IFTYPE_AP || 856 mac->opmode == NL80211_IFTYPE_ADHOC) { 857 if (NULL != sta) { 858 if (sta->aid > 0) 859 tcb_desc->mac_id = sta->aid + 1; 860 else 861 tcb_desc->mac_id = 1; 862 } else { 863 tcb_desc->mac_id = 0; 864 } 865 } 866 } 867 #undef SET_RATE_ID 868 } 869 870 static void _rtl_query_bandwidth_mode(struct ieee80211_hw *hw, 871 struct ieee80211_sta *sta, 872 struct rtl_tcb_desc *tcb_desc) 873 { 874 struct rtl_priv *rtlpriv = rtl_priv(hw); 875 struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 876 877 tcb_desc->packet_bw = false; 878 if (!sta) 879 return; 880 if (mac->opmode == NL80211_IFTYPE_AP || 881 mac->opmode == NL80211_IFTYPE_ADHOC || 882 mac->opmode == NL80211_IFTYPE_MESH_POINT) { 883 if (!(sta->ht_cap.ht_supported) || 884 !(sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40)) 885 return; 886 } else if (mac->opmode == NL80211_IFTYPE_STATION) { 887 if (!mac->bw_40 || !(sta->ht_cap.ht_supported)) 888 return; 889 } 890 if (tcb_desc->multicast || tcb_desc->broadcast) 891 return; 892 893 /*use legency rate, shall use 20MHz */ 894 if (tcb_desc->hw_rate <= rtlpriv->cfg->maps[RTL_RC_OFDM_RATE54M]) 895 return; 896 897 tcb_desc->packet_bw = HT_CHANNEL_WIDTH_20_40; 898 899 if (rtlpriv->cfg->spec_ver & RTL_SPEC_SUPPORT_VHT) { 900 if (mac->opmode == NL80211_IFTYPE_AP || 901 mac->opmode == NL80211_IFTYPE_ADHOC || 902 mac->opmode == NL80211_IFTYPE_MESH_POINT) { 903 if (!(sta->vht_cap.vht_supported)) 904 return; 905 } else if (mac->opmode == NL80211_IFTYPE_STATION) { 906 if (!mac->bw_80 || 907 !(sta->vht_cap.vht_supported)) 908 return; 909 } 910 if (tcb_desc->hw_rate <= 911 rtlpriv->cfg->maps[RTL_RC_HT_RATEMCS15]) 912 return; 913 tcb_desc->packet_bw = HT_CHANNEL_WIDTH_80; 914 } 915 } 916 917 static u8 _rtl_get_vht_highest_n_rate(struct ieee80211_hw *hw, 918 struct ieee80211_sta *sta) 919 { 920 struct rtl_priv *rtlpriv = rtl_priv(hw); 921 struct rtl_phy *rtlphy = &(rtlpriv->phy); 922 u8 hw_rate; 923 u16 tx_mcs_map = le16_to_cpu(sta->vht_cap.vht_mcs.tx_mcs_map); 924 925 if ((get_rf_type(rtlphy) == RF_2T2R) && 926 (tx_mcs_map & 0x000c) != 0x000c) { 927 if ((tx_mcs_map & 0x000c) >> 2 == 928 IEEE80211_VHT_MCS_SUPPORT_0_7) 929 hw_rate = 930 rtlpriv->cfg->maps[RTL_RC_VHT_RATE_2SS_MCS7]; 931 else if ((tx_mcs_map & 0x000c) >> 2 == 932 IEEE80211_VHT_MCS_SUPPORT_0_8) 933 hw_rate = 934 rtlpriv->cfg->maps[RTL_RC_VHT_RATE_2SS_MCS8]; 935 else 936 hw_rate = 937 rtlpriv->cfg->maps[RTL_RC_VHT_RATE_2SS_MCS9]; 938 } else { 939 if ((tx_mcs_map & 0x0003) == 940 IEEE80211_VHT_MCS_SUPPORT_0_7) 941 hw_rate = 942 rtlpriv->cfg->maps[RTL_RC_VHT_RATE_1SS_MCS7]; 943 else if ((tx_mcs_map & 0x0003) == 944 IEEE80211_VHT_MCS_SUPPORT_0_8) 945 hw_rate = 946 rtlpriv->cfg->maps[RTL_RC_VHT_RATE_1SS_MCS8]; 947 else 948 hw_rate = 949 rtlpriv->cfg->maps[RTL_RC_VHT_RATE_1SS_MCS9]; 950 } 951 952 return hw_rate; 953 } 954 955 static u8 _rtl_get_highest_n_rate(struct ieee80211_hw *hw, 956 struct ieee80211_sta *sta) 957 { 958 struct rtl_priv *rtlpriv = rtl_priv(hw); 959 struct rtl_phy *rtlphy = &rtlpriv->phy; 960 u8 hw_rate; 961 962 if (get_rf_type(rtlphy) == RF_2T2R && 963 sta->ht_cap.mcs.rx_mask[1] != 0) 964 hw_rate = rtlpriv->cfg->maps[RTL_RC_HT_RATEMCS15]; 965 else 966 hw_rate = rtlpriv->cfg->maps[RTL_RC_HT_RATEMCS7]; 967 968 return hw_rate; 969 } 970 971 /* mac80211's rate_idx is like this: 972 * 973 * 2.4G band:rx_status->band == NL80211_BAND_2GHZ 974 * 975 * B/G rate: 976 * (rx_status->flag & RX_FLAG_HT) = 0, 977 * DESC_RATE1M-->DESC_RATE54M ==> idx is 0-->11, 978 * 979 * N rate: 980 * (rx_status->flag & RX_FLAG_HT) = 1, 981 * DESC_RATEMCS0-->DESC_RATEMCS15 ==> idx is 0-->15 982 * 983 * 5G band:rx_status->band == NL80211_BAND_5GHZ 984 * A rate: 985 * (rx_status->flag & RX_FLAG_HT) = 0, 986 * DESC_RATE6M-->DESC_RATE54M ==> idx is 0-->7, 987 * 988 * N rate: 989 * (rx_status->flag & RX_FLAG_HT) = 1, 990 * DESC_RATEMCS0-->DESC_RATEMCS15 ==> idx is 0-->15 991 * 992 * VHT rates: 993 * DESC_RATEVHT1SS_MCS0-->DESC_RATEVHT1SS_MCS9 ==> idx is 0-->9 994 * DESC_RATEVHT2SS_MCS0-->DESC_RATEVHT2SS_MCS9 ==> idx is 0-->9 995 */ 996 int rtlwifi_rate_mapping(struct ieee80211_hw *hw, bool isht, bool isvht, 997 u8 desc_rate) 998 { 999 int rate_idx; 1000 1001 if (isvht) { 1002 switch (desc_rate) { 1003 case DESC_RATEVHT1SS_MCS0: 1004 rate_idx = 0; 1005 break; 1006 case DESC_RATEVHT1SS_MCS1: 1007 rate_idx = 1; 1008 break; 1009 case DESC_RATEVHT1SS_MCS2: 1010 rate_idx = 2; 1011 break; 1012 case DESC_RATEVHT1SS_MCS3: 1013 rate_idx = 3; 1014 break; 1015 case DESC_RATEVHT1SS_MCS4: 1016 rate_idx = 4; 1017 break; 1018 case DESC_RATEVHT1SS_MCS5: 1019 rate_idx = 5; 1020 break; 1021 case DESC_RATEVHT1SS_MCS6: 1022 rate_idx = 6; 1023 break; 1024 case DESC_RATEVHT1SS_MCS7: 1025 rate_idx = 7; 1026 break; 1027 case DESC_RATEVHT1SS_MCS8: 1028 rate_idx = 8; 1029 break; 1030 case DESC_RATEVHT1SS_MCS9: 1031 rate_idx = 9; 1032 break; 1033 case DESC_RATEVHT2SS_MCS0: 1034 rate_idx = 0; 1035 break; 1036 case DESC_RATEVHT2SS_MCS1: 1037 rate_idx = 1; 1038 break; 1039 case DESC_RATEVHT2SS_MCS2: 1040 rate_idx = 2; 1041 break; 1042 case DESC_RATEVHT2SS_MCS3: 1043 rate_idx = 3; 1044 break; 1045 case DESC_RATEVHT2SS_MCS4: 1046 rate_idx = 4; 1047 break; 1048 case DESC_RATEVHT2SS_MCS5: 1049 rate_idx = 5; 1050 break; 1051 case DESC_RATEVHT2SS_MCS6: 1052 rate_idx = 6; 1053 break; 1054 case DESC_RATEVHT2SS_MCS7: 1055 rate_idx = 7; 1056 break; 1057 case DESC_RATEVHT2SS_MCS8: 1058 rate_idx = 8; 1059 break; 1060 case DESC_RATEVHT2SS_MCS9: 1061 rate_idx = 9; 1062 break; 1063 default: 1064 rate_idx = 0; 1065 break; 1066 } 1067 return rate_idx; 1068 } 1069 if (false == isht) { 1070 if (NL80211_BAND_2GHZ == hw->conf.chandef.chan->band) { 1071 switch (desc_rate) { 1072 case DESC_RATE1M: 1073 rate_idx = 0; 1074 break; 1075 case DESC_RATE2M: 1076 rate_idx = 1; 1077 break; 1078 case DESC_RATE5_5M: 1079 rate_idx = 2; 1080 break; 1081 case DESC_RATE11M: 1082 rate_idx = 3; 1083 break; 1084 case DESC_RATE6M: 1085 rate_idx = 4; 1086 break; 1087 case DESC_RATE9M: 1088 rate_idx = 5; 1089 break; 1090 case DESC_RATE12M: 1091 rate_idx = 6; 1092 break; 1093 case DESC_RATE18M: 1094 rate_idx = 7; 1095 break; 1096 case DESC_RATE24M: 1097 rate_idx = 8; 1098 break; 1099 case DESC_RATE36M: 1100 rate_idx = 9; 1101 break; 1102 case DESC_RATE48M: 1103 rate_idx = 10; 1104 break; 1105 case DESC_RATE54M: 1106 rate_idx = 11; 1107 break; 1108 default: 1109 rate_idx = 0; 1110 break; 1111 } 1112 } else { 1113 switch (desc_rate) { 1114 case DESC_RATE6M: 1115 rate_idx = 0; 1116 break; 1117 case DESC_RATE9M: 1118 rate_idx = 1; 1119 break; 1120 case DESC_RATE12M: 1121 rate_idx = 2; 1122 break; 1123 case DESC_RATE18M: 1124 rate_idx = 3; 1125 break; 1126 case DESC_RATE24M: 1127 rate_idx = 4; 1128 break; 1129 case DESC_RATE36M: 1130 rate_idx = 5; 1131 break; 1132 case DESC_RATE48M: 1133 rate_idx = 6; 1134 break; 1135 case DESC_RATE54M: 1136 rate_idx = 7; 1137 break; 1138 default: 1139 rate_idx = 0; 1140 break; 1141 } 1142 } 1143 } else { 1144 switch (desc_rate) { 1145 case DESC_RATEMCS0: 1146 rate_idx = 0; 1147 break; 1148 case DESC_RATEMCS1: 1149 rate_idx = 1; 1150 break; 1151 case DESC_RATEMCS2: 1152 rate_idx = 2; 1153 break; 1154 case DESC_RATEMCS3: 1155 rate_idx = 3; 1156 break; 1157 case DESC_RATEMCS4: 1158 rate_idx = 4; 1159 break; 1160 case DESC_RATEMCS5: 1161 rate_idx = 5; 1162 break; 1163 case DESC_RATEMCS6: 1164 rate_idx = 6; 1165 break; 1166 case DESC_RATEMCS7: 1167 rate_idx = 7; 1168 break; 1169 case DESC_RATEMCS8: 1170 rate_idx = 8; 1171 break; 1172 case DESC_RATEMCS9: 1173 rate_idx = 9; 1174 break; 1175 case DESC_RATEMCS10: 1176 rate_idx = 10; 1177 break; 1178 case DESC_RATEMCS11: 1179 rate_idx = 11; 1180 break; 1181 case DESC_RATEMCS12: 1182 rate_idx = 12; 1183 break; 1184 case DESC_RATEMCS13: 1185 rate_idx = 13; 1186 break; 1187 case DESC_RATEMCS14: 1188 rate_idx = 14; 1189 break; 1190 case DESC_RATEMCS15: 1191 rate_idx = 15; 1192 break; 1193 default: 1194 rate_idx = 0; 1195 break; 1196 } 1197 } 1198 return rate_idx; 1199 } 1200 EXPORT_SYMBOL(rtlwifi_rate_mapping); 1201 1202 static u8 _rtl_get_tx_hw_rate(struct ieee80211_hw *hw, 1203 struct ieee80211_tx_info *info) 1204 { 1205 struct rtl_priv *rtlpriv = rtl_priv(hw); 1206 struct ieee80211_tx_rate *r = &info->status.rates[0]; 1207 struct ieee80211_rate *txrate; 1208 u8 hw_value = 0x0; 1209 1210 if (r->flags & IEEE80211_TX_RC_MCS) { 1211 /* HT MCS0-15 */ 1212 hw_value = rtlpriv->cfg->maps[RTL_RC_HT_RATEMCS15] - 15 + 1213 r->idx; 1214 } else if (r->flags & IEEE80211_TX_RC_VHT_MCS) { 1215 /* VHT MCS0-9, NSS */ 1216 if (ieee80211_rate_get_vht_nss(r) == 2) 1217 hw_value = rtlpriv->cfg->maps[RTL_RC_VHT_RATE_2SS_MCS9]; 1218 else 1219 hw_value = rtlpriv->cfg->maps[RTL_RC_VHT_RATE_1SS_MCS9]; 1220 1221 hw_value = hw_value - 9 + ieee80211_rate_get_vht_mcs(r); 1222 } else { 1223 /* legacy */ 1224 txrate = ieee80211_get_tx_rate(hw, info); 1225 1226 if (txrate) 1227 hw_value = txrate->hw_value; 1228 } 1229 1230 /* check 5G band */ 1231 if (rtlpriv->rtlhal.current_bandtype == BAND_ON_5G && 1232 hw_value < rtlpriv->cfg->maps[RTL_RC_OFDM_RATE6M]) 1233 hw_value = rtlpriv->cfg->maps[RTL_RC_OFDM_RATE6M]; 1234 1235 return hw_value; 1236 } 1237 1238 void rtl_get_tcb_desc(struct ieee80211_hw *hw, 1239 struct ieee80211_tx_info *info, 1240 struct ieee80211_sta *sta, 1241 struct sk_buff *skb, struct rtl_tcb_desc *tcb_desc) 1242 { 1243 #define SET_RATE_ID(rate_id) \ 1244 ({typeof(rate_id) _id = rate_id; \ 1245 ((rtlpriv->cfg->spec_ver & RTL_SPEC_NEW_RATEID) ? \ 1246 rtl_mrate_idx_to_arfr_id(hw, _id, \ 1247 (sta_entry ? sta_entry->wireless_mode : \ 1248 WIRELESS_MODE_G)) : \ 1249 _id); }) 1250 1251 struct rtl_priv *rtlpriv = rtl_priv(hw); 1252 struct rtl_mac *rtlmac = rtl_mac(rtl_priv(hw)); 1253 struct ieee80211_hdr *hdr = rtl_get_hdr(skb); 1254 struct rtl_sta_info *sta_entry = 1255 (sta ? (struct rtl_sta_info *)sta->drv_priv : NULL); 1256 1257 __le16 fc = rtl_get_fc(skb); 1258 1259 tcb_desc->hw_rate = _rtl_get_tx_hw_rate(hw, info); 1260 1261 if (rtl_is_tx_report_skb(hw, skb)) 1262 tcb_desc->use_spe_rpt = 1; 1263 1264 if (ieee80211_is_data(fc)) { 1265 /* 1266 *we set data rate INX 0 1267 *in rtl_rc.c if skb is special data or 1268 *mgt which need low data rate. 1269 */ 1270 1271 /* 1272 *So tcb_desc->hw_rate is just used for 1273 *special data and mgt frames 1274 */ 1275 if (info->control.rates[0].idx == 0 || 1276 ieee80211_is_nullfunc(fc)) { 1277 tcb_desc->use_driver_rate = true; 1278 tcb_desc->ratr_index = 1279 SET_RATE_ID(RATR_INX_WIRELESS_MC); 1280 1281 tcb_desc->disable_ratefallback = 1; 1282 } else { 1283 /* 1284 *because hw will nerver use hw_rate 1285 *when tcb_desc->use_driver_rate = false 1286 *so we never set highest N rate here, 1287 *and N rate will all be controlled by FW 1288 *when tcb_desc->use_driver_rate = false 1289 */ 1290 if (sta && sta->vht_cap.vht_supported) { 1291 tcb_desc->hw_rate = 1292 _rtl_get_vht_highest_n_rate(hw, sta); 1293 } else { 1294 if (sta && sta->ht_cap.ht_supported) { 1295 tcb_desc->hw_rate = 1296 _rtl_get_highest_n_rate(hw, sta); 1297 } else { 1298 if (rtlmac->mode == WIRELESS_MODE_B) { 1299 tcb_desc->hw_rate = 1300 rtlpriv->cfg->maps[RTL_RC_CCK_RATE11M]; 1301 } else { 1302 tcb_desc->hw_rate = 1303 rtlpriv->cfg->maps[RTL_RC_OFDM_RATE54M]; 1304 } 1305 } 1306 } 1307 } 1308 1309 if (is_multicast_ether_addr(hdr->addr1)) 1310 tcb_desc->multicast = 1; 1311 else if (is_broadcast_ether_addr(hdr->addr1)) 1312 tcb_desc->broadcast = 1; 1313 1314 _rtl_txrate_selectmode(hw, sta, tcb_desc); 1315 _rtl_query_bandwidth_mode(hw, sta, tcb_desc); 1316 _rtl_qurey_shortpreamble_mode(hw, tcb_desc, info); 1317 _rtl_query_shortgi(hw, sta, tcb_desc, info); 1318 _rtl_query_protection_mode(hw, tcb_desc, info); 1319 } else { 1320 tcb_desc->use_driver_rate = true; 1321 tcb_desc->ratr_index = SET_RATE_ID(RATR_INX_WIRELESS_MC); 1322 tcb_desc->disable_ratefallback = 1; 1323 tcb_desc->mac_id = 0; 1324 tcb_desc->packet_bw = false; 1325 } 1326 #undef SET_RATE_ID 1327 } 1328 EXPORT_SYMBOL(rtl_get_tcb_desc); 1329 1330 bool rtl_tx_mgmt_proc(struct ieee80211_hw *hw, struct sk_buff *skb) 1331 { 1332 struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 1333 struct rtl_priv *rtlpriv = rtl_priv(hw); 1334 __le16 fc = rtl_get_fc(skb); 1335 1336 if (rtlpriv->dm.supp_phymode_switch && 1337 mac->link_state < MAC80211_LINKED && 1338 (ieee80211_is_auth(fc) || ieee80211_is_probe_req(fc))) { 1339 if (rtlpriv->cfg->ops->chk_switch_dmdp) 1340 rtlpriv->cfg->ops->chk_switch_dmdp(hw); 1341 } 1342 if (ieee80211_is_auth(fc)) { 1343 RT_TRACE(rtlpriv, COMP_SEND, DBG_DMESG, "MAC80211_LINKING\n"); 1344 1345 mac->link_state = MAC80211_LINKING; 1346 /* Dul mac */ 1347 rtlpriv->phy.need_iqk = true; 1348 1349 } 1350 1351 return true; 1352 } 1353 EXPORT_SYMBOL_GPL(rtl_tx_mgmt_proc); 1354 1355 struct sk_buff *rtl_make_del_ba(struct ieee80211_hw *hw, u8 *sa, 1356 u8 *bssid, u16 tid); 1357 1358 static void process_agg_start(struct ieee80211_hw *hw, 1359 struct ieee80211_hdr *hdr, u16 tid) 1360 { 1361 struct rtl_priv *rtlpriv = rtl_priv(hw); 1362 struct ieee80211_rx_status rx_status = { 0 }; 1363 struct sk_buff *skb_delba = NULL; 1364 1365 skb_delba = rtl_make_del_ba(hw, hdr->addr2, hdr->addr3, tid); 1366 if (skb_delba) { 1367 rx_status.freq = hw->conf.chandef.chan->center_freq; 1368 rx_status.band = hw->conf.chandef.chan->band; 1369 rx_status.flag |= RX_FLAG_DECRYPTED; 1370 rx_status.flag |= RX_FLAG_MACTIME_START; 1371 rx_status.rate_idx = 0; 1372 rx_status.signal = 50 + 10; 1373 memcpy(IEEE80211_SKB_RXCB(skb_delba), 1374 &rx_status, sizeof(rx_status)); 1375 RT_PRINT_DATA(rtlpriv, COMP_INIT, DBG_DMESG, 1376 "fake del\n", 1377 skb_delba->data, 1378 skb_delba->len); 1379 ieee80211_rx_irqsafe(hw, skb_delba); 1380 } 1381 } 1382 1383 bool rtl_action_proc(struct ieee80211_hw *hw, struct sk_buff *skb, u8 is_tx) 1384 { 1385 struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 1386 struct ieee80211_hdr *hdr = rtl_get_hdr(skb); 1387 struct rtl_priv *rtlpriv = rtl_priv(hw); 1388 __le16 fc = rtl_get_fc(skb); 1389 u8 *act = (u8 *)(((u8 *)skb->data + MAC80211_3ADDR_LEN)); 1390 u8 category; 1391 1392 if (!ieee80211_is_action(fc)) 1393 return true; 1394 1395 category = *act; 1396 act++; 1397 switch (category) { 1398 case ACT_CAT_BA: 1399 switch (*act) { 1400 case ACT_ADDBAREQ: 1401 if (mac->act_scanning) 1402 return false; 1403 1404 RT_TRACE(rtlpriv, (COMP_SEND | COMP_RECV), DBG_DMESG, 1405 "%s ACT_ADDBAREQ From :%pM\n", 1406 is_tx ? "Tx" : "Rx", hdr->addr2); 1407 RT_PRINT_DATA(rtlpriv, COMP_INIT, DBG_DMESG, "req\n", 1408 skb->data, skb->len); 1409 if (!is_tx) { 1410 struct ieee80211_sta *sta = NULL; 1411 struct rtl_sta_info *sta_entry = NULL; 1412 struct rtl_tid_data *tid_data; 1413 struct ieee80211_mgmt *mgmt = (void *)skb->data; 1414 u16 capab = 0, tid = 0; 1415 1416 rcu_read_lock(); 1417 sta = rtl_find_sta(hw, hdr->addr3); 1418 if (sta == NULL) { 1419 RT_TRACE(rtlpriv, COMP_SEND | COMP_RECV, 1420 DBG_DMESG, "sta is NULL\n"); 1421 rcu_read_unlock(); 1422 return true; 1423 } 1424 1425 sta_entry = 1426 (struct rtl_sta_info *)sta->drv_priv; 1427 if (!sta_entry) { 1428 rcu_read_unlock(); 1429 return true; 1430 } 1431 capab = 1432 le16_to_cpu(mgmt->u.action.u.addba_req.capab); 1433 tid = (capab & 1434 IEEE80211_ADDBA_PARAM_TID_MASK) >> 2; 1435 if (tid >= MAX_TID_COUNT) { 1436 rcu_read_unlock(); 1437 return true; 1438 } 1439 tid_data = &sta_entry->tids[tid]; 1440 if (tid_data->agg.rx_agg_state == 1441 RTL_RX_AGG_START) 1442 process_agg_start(hw, hdr, tid); 1443 rcu_read_unlock(); 1444 } 1445 break; 1446 case ACT_ADDBARSP: 1447 RT_TRACE(rtlpriv, (COMP_SEND | COMP_RECV), DBG_DMESG, 1448 "%s ACT_ADDBARSP From :%pM\n", 1449 is_tx ? "Tx" : "Rx", hdr->addr2); 1450 break; 1451 case ACT_DELBA: 1452 RT_TRACE(rtlpriv, (COMP_SEND | COMP_RECV), DBG_DMESG, 1453 "ACT_ADDBADEL From :%pM\n", hdr->addr2); 1454 break; 1455 } 1456 break; 1457 default: 1458 break; 1459 } 1460 1461 return true; 1462 } 1463 EXPORT_SYMBOL_GPL(rtl_action_proc); 1464 1465 static void setup_special_tx(struct rtl_priv *rtlpriv, struct rtl_ps_ctl *ppsc, 1466 int type) 1467 { 1468 struct ieee80211_hw *hw = rtlpriv->hw; 1469 1470 rtlpriv->ra.is_special_data = true; 1471 if (rtlpriv->cfg->ops->get_btc_status()) 1472 rtlpriv->btcoexist.btc_ops->btc_special_packet_notify( 1473 rtlpriv, type); 1474 rtl_lps_leave(hw); 1475 ppsc->last_delaylps_stamp_jiffies = jiffies; 1476 } 1477 1478 static const u8 *rtl_skb_ether_type_ptr(struct ieee80211_hw *hw, 1479 struct sk_buff *skb, bool is_enc) 1480 { 1481 struct rtl_priv *rtlpriv = rtl_priv(hw); 1482 u8 mac_hdr_len = ieee80211_get_hdrlen_from_skb(skb); 1483 u8 encrypt_header_len = 0; 1484 u8 offset; 1485 1486 switch (rtlpriv->sec.pairwise_enc_algorithm) { 1487 case WEP40_ENCRYPTION: 1488 case WEP104_ENCRYPTION: 1489 encrypt_header_len = 4;/*WEP_IV_LEN*/ 1490 break; 1491 case TKIP_ENCRYPTION: 1492 encrypt_header_len = 8;/*TKIP_IV_LEN*/ 1493 break; 1494 case AESCCMP_ENCRYPTION: 1495 encrypt_header_len = 8;/*CCMP_HDR_LEN;*/ 1496 break; 1497 default: 1498 break; 1499 } 1500 1501 offset = mac_hdr_len + SNAP_SIZE; 1502 if (is_enc) 1503 offset += encrypt_header_len; 1504 1505 return skb->data + offset; 1506 } 1507 1508 /*should call before software enc*/ 1509 u8 rtl_is_special_data(struct ieee80211_hw *hw, struct sk_buff *skb, u8 is_tx, 1510 bool is_enc) 1511 { 1512 struct rtl_priv *rtlpriv = rtl_priv(hw); 1513 struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); 1514 __le16 fc = rtl_get_fc(skb); 1515 u16 ether_type; 1516 const u8 *ether_type_ptr; 1517 const struct iphdr *ip; 1518 1519 if (!ieee80211_is_data(fc)) 1520 goto end; 1521 1522 ether_type_ptr = rtl_skb_ether_type_ptr(hw, skb, is_enc); 1523 ether_type = be16_to_cpup((__be16 *)ether_type_ptr); 1524 1525 if (ETH_P_IP == ether_type) { 1526 ip = (struct iphdr *)((u8 *)ether_type_ptr + 1527 PROTOC_TYPE_SIZE); 1528 if (IPPROTO_UDP == ip->protocol) { 1529 struct udphdr *udp = (struct udphdr *)((u8 *)ip + 1530 (ip->ihl << 2)); 1531 if (((((u8 *)udp)[1] == 68) && 1532 (((u8 *)udp)[3] == 67)) || 1533 ((((u8 *)udp)[1] == 67) && 1534 (((u8 *)udp)[3] == 68))) { 1535 /* 68 : UDP BOOTP client 1536 * 67 : UDP BOOTP server 1537 */ 1538 RT_TRACE(rtlpriv, (COMP_SEND | COMP_RECV), 1539 DBG_DMESG, "dhcp %s !!\n", 1540 (is_tx) ? "Tx" : "Rx"); 1541 1542 if (is_tx) 1543 setup_special_tx(rtlpriv, ppsc, 1544 PACKET_DHCP); 1545 1546 return true; 1547 } 1548 } 1549 } else if (ETH_P_ARP == ether_type) { 1550 if (is_tx) 1551 setup_special_tx(rtlpriv, ppsc, PACKET_ARP); 1552 1553 return true; 1554 } else if (ETH_P_PAE == ether_type) { 1555 /* EAPOL is seens as in-4way */ 1556 rtlpriv->btcoexist.btc_info.in_4way = true; 1557 rtlpriv->btcoexist.btc_info.in_4way_ts = jiffies; 1558 1559 RT_TRACE(rtlpriv, (COMP_SEND | COMP_RECV), DBG_DMESG, 1560 "802.1X %s EAPOL pkt!!\n", (is_tx) ? "Tx" : "Rx"); 1561 1562 if (is_tx) { 1563 rtlpriv->ra.is_special_data = true; 1564 rtl_lps_leave(hw); 1565 ppsc->last_delaylps_stamp_jiffies = jiffies; 1566 1567 setup_special_tx(rtlpriv, ppsc, PACKET_EAPOL); 1568 } 1569 1570 return true; 1571 } else if (ETH_P_IPV6 == ether_type) { 1572 /* TODO: Handle any IPv6 cases that need special handling. 1573 * For now, always return false 1574 */ 1575 goto end; 1576 } 1577 1578 end: 1579 rtlpriv->ra.is_special_data = false; 1580 return false; 1581 } 1582 EXPORT_SYMBOL_GPL(rtl_is_special_data); 1583 1584 void rtl_tx_ackqueue(struct ieee80211_hw *hw, struct sk_buff *skb) 1585 { 1586 struct rtl_priv *rtlpriv = rtl_priv(hw); 1587 struct rtl_tx_report *tx_report = &rtlpriv->tx_report; 1588 1589 __skb_queue_tail(&tx_report->queue, skb); 1590 } 1591 EXPORT_SYMBOL_GPL(rtl_tx_ackqueue); 1592 1593 static void rtl_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb, 1594 bool ack) 1595 { 1596 struct rtl_priv *rtlpriv = rtl_priv(hw); 1597 struct ieee80211_tx_info *info; 1598 1599 info = IEEE80211_SKB_CB(skb); 1600 ieee80211_tx_info_clear_status(info); 1601 if (ack) { 1602 RT_TRACE(rtlpriv, COMP_TX_REPORT, DBG_LOUD, 1603 "tx report: ack\n"); 1604 info->flags |= IEEE80211_TX_STAT_ACK; 1605 } else { 1606 RT_TRACE(rtlpriv, COMP_TX_REPORT, DBG_LOUD, 1607 "tx report: not ack\n"); 1608 info->flags &= ~IEEE80211_TX_STAT_ACK; 1609 } 1610 ieee80211_tx_status_irqsafe(hw, skb); 1611 } 1612 1613 bool rtl_is_tx_report_skb(struct ieee80211_hw *hw, struct sk_buff *skb) 1614 { 1615 u16 ether_type; 1616 const u8 *ether_type_ptr; 1617 __le16 fc = rtl_get_fc(skb); 1618 1619 ether_type_ptr = rtl_skb_ether_type_ptr(hw, skb, true); 1620 ether_type = be16_to_cpup((__be16 *)ether_type_ptr); 1621 1622 if (ether_type == ETH_P_PAE || ieee80211_is_nullfunc(fc)) 1623 return true; 1624 1625 return false; 1626 } 1627 1628 static u16 rtl_get_tx_report_sn(struct ieee80211_hw *hw, 1629 struct rtlwifi_tx_info *tx_info) 1630 { 1631 struct rtl_priv *rtlpriv = rtl_priv(hw); 1632 struct rtl_tx_report *tx_report = &rtlpriv->tx_report; 1633 u16 sn; 1634 1635 /* SW_DEFINE[11:8] are reserved (driver fills zeros) 1636 * SW_DEFINE[7:2] are used by driver 1637 * SW_DEFINE[1:0] are reserved for firmware (driver fills zeros) 1638 */ 1639 sn = (atomic_inc_return(&tx_report->sn) & 0x003F) << 2; 1640 1641 tx_report->last_sent_sn = sn; 1642 tx_report->last_sent_time = jiffies; 1643 tx_info->sn = sn; 1644 tx_info->send_time = tx_report->last_sent_time; 1645 RT_TRACE(rtlpriv, COMP_TX_REPORT, DBG_DMESG, 1646 "Send TX-Report sn=0x%X\n", sn); 1647 1648 return sn; 1649 } 1650 1651 void rtl_set_tx_report(struct rtl_tcb_desc *ptcb_desc, u8 *pdesc, 1652 struct ieee80211_hw *hw, struct rtlwifi_tx_info *tx_info) 1653 { 1654 if (ptcb_desc->use_spe_rpt) { 1655 u16 sn = rtl_get_tx_report_sn(hw, tx_info); 1656 1657 SET_TX_DESC_SPE_RPT(pdesc, 1); 1658 SET_TX_DESC_SW_DEFINE(pdesc, sn); 1659 } 1660 } 1661 EXPORT_SYMBOL_GPL(rtl_set_tx_report); 1662 1663 void rtl_tx_report_handler(struct ieee80211_hw *hw, u8 *tmp_buf, u8 c2h_cmd_len) 1664 { 1665 struct rtl_priv *rtlpriv = rtl_priv(hw); 1666 struct rtl_tx_report *tx_report = &rtlpriv->tx_report; 1667 struct rtlwifi_tx_info *tx_info; 1668 struct sk_buff_head *queue = &tx_report->queue; 1669 struct sk_buff *skb; 1670 u16 sn; 1671 u8 st, retry; 1672 1673 if (rtlpriv->cfg->spec_ver & RTL_SPEC_EXT_C2H) { 1674 sn = GET_TX_REPORT_SN_V2(tmp_buf); 1675 st = GET_TX_REPORT_ST_V2(tmp_buf); 1676 retry = GET_TX_REPORT_RETRY_V2(tmp_buf); 1677 } else { 1678 sn = GET_TX_REPORT_SN_V1(tmp_buf); 1679 st = GET_TX_REPORT_ST_V1(tmp_buf); 1680 retry = GET_TX_REPORT_RETRY_V1(tmp_buf); 1681 } 1682 1683 tx_report->last_recv_sn = sn; 1684 1685 skb_queue_walk(queue, skb) { 1686 tx_info = rtl_tx_skb_cb_info(skb); 1687 if (tx_info->sn == sn) { 1688 skb_unlink(skb, queue); 1689 rtl_tx_status(hw, skb, st == 0); 1690 break; 1691 } 1692 } 1693 RT_TRACE(rtlpriv, COMP_TX_REPORT, DBG_DMESG, 1694 "Recv TX-Report st=0x%02X sn=0x%X retry=0x%X\n", 1695 st, sn, retry); 1696 } 1697 EXPORT_SYMBOL_GPL(rtl_tx_report_handler); 1698 1699 bool rtl_check_tx_report_acked(struct ieee80211_hw *hw) 1700 { 1701 struct rtl_priv *rtlpriv = rtl_priv(hw); 1702 struct rtl_tx_report *tx_report = &rtlpriv->tx_report; 1703 1704 if (tx_report->last_sent_sn == tx_report->last_recv_sn) 1705 return true; 1706 1707 if (time_before(tx_report->last_sent_time + 3 * HZ, jiffies)) { 1708 RT_TRACE(rtlpriv, COMP_TX_REPORT, DBG_WARNING, 1709 "Check TX-Report timeout!! s_sn=0x%X r_sn=0x%X\n", 1710 tx_report->last_sent_sn, tx_report->last_recv_sn); 1711 return true; /* 3 sec. (timeout) seen as acked */ 1712 } 1713 1714 return false; 1715 } 1716 1717 void rtl_wait_tx_report_acked(struct ieee80211_hw *hw, u32 wait_ms) 1718 { 1719 struct rtl_priv *rtlpriv = rtl_priv(hw); 1720 int i; 1721 1722 for (i = 0; i < wait_ms; i++) { 1723 if (rtl_check_tx_report_acked(hw)) 1724 break; 1725 usleep_range(1000, 2000); 1726 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, 1727 "Wait 1ms (%d/%d) to disable key.\n", i, wait_ms); 1728 } 1729 } 1730 1731 u32 rtl_get_hal_edca_param(struct ieee80211_hw *hw, 1732 struct ieee80211_vif *vif, 1733 enum wireless_mode wirelessmode, 1734 struct ieee80211_tx_queue_params *param) 1735 { 1736 u32 reg = 0; 1737 u8 sifstime = 10; 1738 u8 slottime = 20; 1739 1740 /* AIFS = AIFSN * slot time + SIFS */ 1741 switch (wirelessmode) { 1742 case WIRELESS_MODE_A: 1743 case WIRELESS_MODE_N_24G: 1744 case WIRELESS_MODE_N_5G: 1745 case WIRELESS_MODE_AC_5G: 1746 case WIRELESS_MODE_AC_24G: 1747 sifstime = 16; 1748 slottime = 9; 1749 break; 1750 case WIRELESS_MODE_G: 1751 slottime = (vif->bss_conf.use_short_slot ? 9 : 20); 1752 break; 1753 default: 1754 break; 1755 } 1756 1757 reg |= (param->txop & 0x7FF) << 16; 1758 reg |= (fls(param->cw_max) & 0xF) << 12; 1759 reg |= (fls(param->cw_min) & 0xF) << 8; 1760 reg |= (param->aifs & 0x0F) * slottime + sifstime; 1761 1762 return reg; 1763 } 1764 EXPORT_SYMBOL_GPL(rtl_get_hal_edca_param); 1765 1766 /********************************************************* 1767 * 1768 * functions called by core.c 1769 * 1770 *********************************************************/ 1771 int rtl_tx_agg_start(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1772 struct ieee80211_sta *sta, u16 tid, u16 *ssn) 1773 { 1774 struct rtl_priv *rtlpriv = rtl_priv(hw); 1775 struct rtl_tid_data *tid_data; 1776 struct rtl_sta_info *sta_entry = NULL; 1777 1778 if (sta == NULL) 1779 return -EINVAL; 1780 1781 if (unlikely(tid >= MAX_TID_COUNT)) 1782 return -EINVAL; 1783 1784 sta_entry = (struct rtl_sta_info *)sta->drv_priv; 1785 if (!sta_entry) 1786 return -ENXIO; 1787 tid_data = &sta_entry->tids[tid]; 1788 1789 RT_TRACE(rtlpriv, COMP_SEND, DBG_DMESG, 1790 "on ra = %pM tid = %d seq:%d\n", sta->addr, tid, 1791 *ssn); 1792 1793 tid_data->agg.agg_state = RTL_AGG_START; 1794 1795 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1796 return 0; 1797 } 1798 1799 int rtl_tx_agg_stop(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1800 struct ieee80211_sta *sta, u16 tid) 1801 { 1802 struct rtl_priv *rtlpriv = rtl_priv(hw); 1803 struct rtl_sta_info *sta_entry = NULL; 1804 1805 if (sta == NULL) 1806 return -EINVAL; 1807 1808 RT_TRACE(rtlpriv, COMP_SEND, DBG_DMESG, 1809 "on ra = %pM tid = %d\n", sta->addr, tid); 1810 1811 if (unlikely(tid >= MAX_TID_COUNT)) 1812 return -EINVAL; 1813 1814 sta_entry = (struct rtl_sta_info *)sta->drv_priv; 1815 sta_entry->tids[tid].agg.agg_state = RTL_AGG_STOP; 1816 1817 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1818 return 0; 1819 } 1820 1821 int rtl_rx_agg_start(struct ieee80211_hw *hw, 1822 struct ieee80211_sta *sta, u16 tid) 1823 { 1824 struct rtl_priv *rtlpriv = rtl_priv(hw); 1825 struct rtl_tid_data *tid_data; 1826 struct rtl_sta_info *sta_entry = NULL; 1827 u8 reject_agg; 1828 1829 if (sta == NULL) 1830 return -EINVAL; 1831 1832 if (unlikely(tid >= MAX_TID_COUNT)) 1833 return -EINVAL; 1834 1835 if (rtlpriv->cfg->ops->get_btc_status()) { 1836 rtlpriv->btcoexist.btc_ops->btc_get_ampdu_cfg(rtlpriv, 1837 &reject_agg, 1838 NULL, NULL); 1839 if (reject_agg) 1840 return -EINVAL; 1841 } 1842 1843 sta_entry = (struct rtl_sta_info *)sta->drv_priv; 1844 if (!sta_entry) 1845 return -ENXIO; 1846 tid_data = &sta_entry->tids[tid]; 1847 1848 RT_TRACE(rtlpriv, COMP_RECV, DBG_DMESG, 1849 "on ra = %pM tid = %d\n", sta->addr, tid); 1850 1851 tid_data->agg.rx_agg_state = RTL_RX_AGG_START; 1852 return 0; 1853 } 1854 1855 int rtl_rx_agg_stop(struct ieee80211_hw *hw, 1856 struct ieee80211_sta *sta, u16 tid) 1857 { 1858 struct rtl_priv *rtlpriv = rtl_priv(hw); 1859 struct rtl_sta_info *sta_entry = NULL; 1860 1861 if (sta == NULL) 1862 return -EINVAL; 1863 1864 RT_TRACE(rtlpriv, COMP_SEND, DBG_DMESG, 1865 "on ra = %pM tid = %d\n", sta->addr, tid); 1866 1867 if (unlikely(tid >= MAX_TID_COUNT)) 1868 return -EINVAL; 1869 1870 sta_entry = (struct rtl_sta_info *)sta->drv_priv; 1871 sta_entry->tids[tid].agg.rx_agg_state = RTL_RX_AGG_STOP; 1872 1873 return 0; 1874 } 1875 int rtl_tx_agg_oper(struct ieee80211_hw *hw, 1876 struct ieee80211_sta *sta, u16 tid) 1877 { 1878 struct rtl_priv *rtlpriv = rtl_priv(hw); 1879 struct rtl_sta_info *sta_entry = NULL; 1880 1881 if (sta == NULL) 1882 return -EINVAL; 1883 1884 RT_TRACE(rtlpriv, COMP_SEND, DBG_DMESG, 1885 "on ra = %pM tid = %d\n", sta->addr, tid); 1886 1887 if (unlikely(tid >= MAX_TID_COUNT)) 1888 return -EINVAL; 1889 1890 sta_entry = (struct rtl_sta_info *)sta->drv_priv; 1891 sta_entry->tids[tid].agg.agg_state = RTL_AGG_OPERATIONAL; 1892 1893 return 0; 1894 } 1895 1896 void rtl_rx_ampdu_apply(struct rtl_priv *rtlpriv) 1897 { 1898 struct rtl_btc_ops *btc_ops = rtlpriv->btcoexist.btc_ops; 1899 u8 reject_agg = 0, ctrl_agg_size = 0, agg_size = 0; 1900 1901 if (rtlpriv->cfg->ops->get_btc_status()) 1902 btc_ops->btc_get_ampdu_cfg(rtlpriv, &reject_agg, 1903 &ctrl_agg_size, &agg_size); 1904 1905 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_DMESG, 1906 "Set RX AMPDU: coex - reject=%d, ctrl_agg_size=%d, size=%d", 1907 reject_agg, ctrl_agg_size, agg_size); 1908 1909 rtlpriv->hw->max_rx_aggregation_subframes = 1910 (ctrl_agg_size ? agg_size : IEEE80211_MAX_AMPDU_BUF_HT); 1911 } 1912 EXPORT_SYMBOL(rtl_rx_ampdu_apply); 1913 1914 /********************************************************* 1915 * 1916 * wq & timer callback functions 1917 * 1918 *********************************************************/ 1919 /* this function is used for roaming */ 1920 void rtl_beacon_statistic(struct ieee80211_hw *hw, struct sk_buff *skb) 1921 { 1922 struct rtl_priv *rtlpriv = rtl_priv(hw); 1923 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 1924 1925 if (rtlpriv->mac80211.opmode != NL80211_IFTYPE_STATION) 1926 return; 1927 1928 if (rtlpriv->mac80211.link_state < MAC80211_LINKED) 1929 return; 1930 1931 /* check if this really is a beacon */ 1932 if (!ieee80211_is_beacon(hdr->frame_control) && 1933 !ieee80211_is_probe_resp(hdr->frame_control)) 1934 return; 1935 1936 /* min. beacon length + FCS_LEN */ 1937 if (skb->len <= 40 + FCS_LEN) 1938 return; 1939 1940 /* and only beacons from the associated BSSID, please */ 1941 if (!ether_addr_equal(hdr->addr3, rtlpriv->mac80211.bssid)) 1942 return; 1943 1944 rtlpriv->link_info.bcn_rx_inperiod++; 1945 } 1946 EXPORT_SYMBOL_GPL(rtl_beacon_statistic); 1947 1948 static void rtl_free_entries_from_scan_list(struct ieee80211_hw *hw) 1949 { 1950 struct rtl_priv *rtlpriv = rtl_priv(hw); 1951 struct rtl_bssid_entry *entry, *next; 1952 1953 list_for_each_entry_safe(entry, next, &rtlpriv->scan_list.list, list) { 1954 list_del(&entry->list); 1955 kfree(entry); 1956 rtlpriv->scan_list.num--; 1957 } 1958 } 1959 1960 static void rtl_free_entries_from_ack_queue(struct ieee80211_hw *hw, 1961 bool chk_timeout) 1962 { 1963 struct rtl_priv *rtlpriv = rtl_priv(hw); 1964 struct rtl_tx_report *tx_report = &rtlpriv->tx_report; 1965 struct sk_buff_head *queue = &tx_report->queue; 1966 struct sk_buff *skb, *tmp; 1967 struct rtlwifi_tx_info *tx_info; 1968 1969 skb_queue_walk_safe(queue, skb, tmp) { 1970 tx_info = rtl_tx_skb_cb_info(skb); 1971 if (chk_timeout && 1972 time_after(tx_info->send_time + HZ, jiffies)) 1973 continue; 1974 skb_unlink(skb, queue); 1975 rtl_tx_status(hw, skb, false); 1976 } 1977 } 1978 1979 void rtl_scan_list_expire(struct ieee80211_hw *hw) 1980 { 1981 struct rtl_priv *rtlpriv = rtl_priv(hw); 1982 struct rtl_bssid_entry *entry, *next; 1983 unsigned long flags; 1984 1985 spin_lock_irqsave(&rtlpriv->locks.scan_list_lock, flags); 1986 1987 list_for_each_entry_safe(entry, next, &rtlpriv->scan_list.list, list) { 1988 /* 180 seconds */ 1989 if (jiffies_to_msecs(jiffies - entry->age) < 180000) 1990 continue; 1991 1992 list_del(&entry->list); 1993 rtlpriv->scan_list.num--; 1994 1995 RT_TRACE(rtlpriv, COMP_SCAN, DBG_LOUD, 1996 "BSSID=%pM is expire in scan list (total=%d)\n", 1997 entry->bssid, rtlpriv->scan_list.num); 1998 kfree(entry); 1999 } 2000 2001 spin_unlock_irqrestore(&rtlpriv->locks.scan_list_lock, flags); 2002 2003 rtlpriv->btcoexist.btc_info.ap_num = rtlpriv->scan_list.num; 2004 } 2005 2006 void rtl_collect_scan_list(struct ieee80211_hw *hw, struct sk_buff *skb) 2007 { 2008 struct rtl_priv *rtlpriv = rtl_priv(hw); 2009 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 2010 struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 2011 unsigned long flags; 2012 2013 struct rtl_bssid_entry *entry; 2014 bool entry_found = false; 2015 2016 /* check if it is scanning */ 2017 if (!mac->act_scanning) 2018 return; 2019 2020 /* check if this really is a beacon */ 2021 if (!ieee80211_is_beacon(hdr->frame_control) && 2022 !ieee80211_is_probe_resp(hdr->frame_control)) 2023 return; 2024 2025 spin_lock_irqsave(&rtlpriv->locks.scan_list_lock, flags); 2026 2027 list_for_each_entry(entry, &rtlpriv->scan_list.list, list) { 2028 if (memcmp(entry->bssid, hdr->addr3, ETH_ALEN) == 0) { 2029 list_del_init(&entry->list); 2030 entry_found = true; 2031 RT_TRACE(rtlpriv, COMP_SCAN, DBG_LOUD, 2032 "Update BSSID=%pM to scan list (total=%d)\n", 2033 hdr->addr3, rtlpriv->scan_list.num); 2034 break; 2035 } 2036 } 2037 2038 if (!entry_found) { 2039 entry = kmalloc(sizeof(*entry), GFP_ATOMIC); 2040 2041 if (!entry) 2042 goto label_err; 2043 2044 memcpy(entry->bssid, hdr->addr3, ETH_ALEN); 2045 rtlpriv->scan_list.num++; 2046 2047 RT_TRACE(rtlpriv, COMP_SCAN, DBG_LOUD, 2048 "Add BSSID=%pM to scan list (total=%d)\n", 2049 hdr->addr3, rtlpriv->scan_list.num); 2050 } 2051 2052 entry->age = jiffies; 2053 2054 list_add_tail(&entry->list, &rtlpriv->scan_list.list); 2055 2056 label_err: 2057 spin_unlock_irqrestore(&rtlpriv->locks.scan_list_lock, flags); 2058 } 2059 EXPORT_SYMBOL(rtl_collect_scan_list); 2060 2061 void rtl_watchdog_wq_callback(void *data) 2062 { 2063 struct rtl_works *rtlworks = container_of_dwork_rtl(data, 2064 struct rtl_works, 2065 watchdog_wq); 2066 struct ieee80211_hw *hw = rtlworks->hw; 2067 struct rtl_priv *rtlpriv = rtl_priv(hw); 2068 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 2069 struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 2070 bool busytraffic = false; 2071 bool tx_busy_traffic = false; 2072 bool rx_busy_traffic = false; 2073 bool higher_busytraffic = false; 2074 bool higher_busyrxtraffic = false; 2075 u8 idx, tid; 2076 u32 rx_cnt_inp4eriod = 0; 2077 u32 tx_cnt_inp4eriod = 0; 2078 u32 aver_rx_cnt_inperiod = 0; 2079 u32 aver_tx_cnt_inperiod = 0; 2080 u32 aver_tidtx_inperiod[MAX_TID_COUNT] = {0}; 2081 u32 tidtx_inp4eriod[MAX_TID_COUNT] = {0}; 2082 2083 if (is_hal_stop(rtlhal)) 2084 return; 2085 2086 /* <1> Determine if action frame is allowed */ 2087 if (mac->link_state > MAC80211_NOLINK) { 2088 if (mac->cnt_after_linked < 20) 2089 mac->cnt_after_linked++; 2090 } else { 2091 mac->cnt_after_linked = 0; 2092 } 2093 2094 /* <2> to check if traffic busy, if 2095 * busytraffic we don't change channel 2096 */ 2097 if (mac->link_state >= MAC80211_LINKED) { 2098 2099 /* (1) get aver_rx_cnt_inperiod & aver_tx_cnt_inperiod */ 2100 for (idx = 0; idx <= 2; idx++) { 2101 rtlpriv->link_info.num_rx_in4period[idx] = 2102 rtlpriv->link_info.num_rx_in4period[idx + 1]; 2103 rtlpriv->link_info.num_tx_in4period[idx] = 2104 rtlpriv->link_info.num_tx_in4period[idx + 1]; 2105 } 2106 rtlpriv->link_info.num_rx_in4period[3] = 2107 rtlpriv->link_info.num_rx_inperiod; 2108 rtlpriv->link_info.num_tx_in4period[3] = 2109 rtlpriv->link_info.num_tx_inperiod; 2110 for (idx = 0; idx <= 3; idx++) { 2111 rx_cnt_inp4eriod += 2112 rtlpriv->link_info.num_rx_in4period[idx]; 2113 tx_cnt_inp4eriod += 2114 rtlpriv->link_info.num_tx_in4period[idx]; 2115 } 2116 aver_rx_cnt_inperiod = rx_cnt_inp4eriod / 4; 2117 aver_tx_cnt_inperiod = tx_cnt_inp4eriod / 4; 2118 2119 /* (2) check traffic busy */ 2120 if (aver_rx_cnt_inperiod > 100 || aver_tx_cnt_inperiod > 100) { 2121 busytraffic = true; 2122 if (aver_rx_cnt_inperiod > aver_tx_cnt_inperiod) 2123 rx_busy_traffic = true; 2124 else 2125 tx_busy_traffic = false; 2126 } 2127 2128 /* Higher Tx/Rx data. */ 2129 if (aver_rx_cnt_inperiod > 4000 || 2130 aver_tx_cnt_inperiod > 4000) { 2131 higher_busytraffic = true; 2132 2133 /* Extremely high Rx data. */ 2134 if (aver_rx_cnt_inperiod > 5000) 2135 higher_busyrxtraffic = true; 2136 } 2137 2138 /* check every tid's tx traffic */ 2139 for (tid = 0; tid <= 7; tid++) { 2140 for (idx = 0; idx <= 2; idx++) 2141 rtlpriv->link_info.tidtx_in4period[tid][idx] = 2142 rtlpriv->link_info.tidtx_in4period[tid] 2143 [idx + 1]; 2144 rtlpriv->link_info.tidtx_in4period[tid][3] = 2145 rtlpriv->link_info.tidtx_inperiod[tid]; 2146 2147 for (idx = 0; idx <= 3; idx++) 2148 tidtx_inp4eriod[tid] += 2149 rtlpriv->link_info.tidtx_in4period[tid][idx]; 2150 aver_tidtx_inperiod[tid] = tidtx_inp4eriod[tid] / 4; 2151 if (aver_tidtx_inperiod[tid] > 5000) 2152 rtlpriv->link_info.higher_busytxtraffic[tid] = 2153 true; 2154 else 2155 rtlpriv->link_info.higher_busytxtraffic[tid] = 2156 false; 2157 } 2158 2159 /* PS is controlled by coex. */ 2160 if (rtlpriv->cfg->ops->get_btc_status() && 2161 rtlpriv->btcoexist.btc_ops->btc_is_bt_ctrl_lps(rtlpriv)) 2162 goto label_lps_done; 2163 2164 if (rtlpriv->link_info.num_rx_inperiod + 2165 rtlpriv->link_info.num_tx_inperiod > 8 || 2166 rtlpriv->link_info.num_rx_inperiod > 2) 2167 rtl_lps_leave(hw); 2168 else 2169 rtl_lps_enter(hw); 2170 2171 label_lps_done: 2172 ; 2173 } 2174 2175 rtlpriv->link_info.num_rx_inperiod = 0; 2176 rtlpriv->link_info.num_tx_inperiod = 0; 2177 for (tid = 0; tid <= 7; tid++) 2178 rtlpriv->link_info.tidtx_inperiod[tid] = 0; 2179 2180 rtlpriv->link_info.busytraffic = busytraffic; 2181 rtlpriv->link_info.higher_busytraffic = higher_busytraffic; 2182 rtlpriv->link_info.rx_busy_traffic = rx_busy_traffic; 2183 rtlpriv->link_info.tx_busy_traffic = tx_busy_traffic; 2184 rtlpriv->link_info.higher_busyrxtraffic = higher_busyrxtraffic; 2185 2186 rtlpriv->stats.txbytesunicast_inperiod = 2187 rtlpriv->stats.txbytesunicast - 2188 rtlpriv->stats.txbytesunicast_last; 2189 rtlpriv->stats.rxbytesunicast_inperiod = 2190 rtlpriv->stats.rxbytesunicast - 2191 rtlpriv->stats.rxbytesunicast_last; 2192 rtlpriv->stats.txbytesunicast_last = rtlpriv->stats.txbytesunicast; 2193 rtlpriv->stats.rxbytesunicast_last = rtlpriv->stats.rxbytesunicast; 2194 2195 rtlpriv->stats.txbytesunicast_inperiod_tp = 2196 (u32)(rtlpriv->stats.txbytesunicast_inperiod * 8 / 2 / 2197 1024 / 1024); 2198 rtlpriv->stats.rxbytesunicast_inperiod_tp = 2199 (u32)(rtlpriv->stats.rxbytesunicast_inperiod * 8 / 2 / 2200 1024 / 1024); 2201 2202 /* <3> DM */ 2203 if (!rtlpriv->cfg->mod_params->disable_watchdog) 2204 rtlpriv->cfg->ops->dm_watchdog(hw); 2205 2206 /* <4> roaming */ 2207 if (mac->link_state == MAC80211_LINKED && 2208 mac->opmode == NL80211_IFTYPE_STATION) { 2209 if ((rtlpriv->link_info.bcn_rx_inperiod + 2210 rtlpriv->link_info.num_rx_inperiod) == 0) { 2211 rtlpriv->link_info.roam_times++; 2212 RT_TRACE(rtlpriv, COMP_ERR, DBG_DMESG, 2213 "AP off for %d s\n", 2214 (rtlpriv->link_info.roam_times * 2)); 2215 2216 /* if we can't recv beacon for 10s, 2217 * we should reconnect this AP 2218 */ 2219 if (rtlpriv->link_info.roam_times >= 5) { 2220 pr_err("AP off, try to reconnect now\n"); 2221 rtlpriv->link_info.roam_times = 0; 2222 ieee80211_connection_loss( 2223 rtlpriv->mac80211.vif); 2224 } 2225 } else { 2226 rtlpriv->link_info.roam_times = 0; 2227 } 2228 } 2229 2230 if (rtlpriv->cfg->ops->get_btc_status()) 2231 rtlpriv->btcoexist.btc_ops->btc_periodical(rtlpriv); 2232 2233 if (rtlpriv->btcoexist.btc_info.in_4way) { 2234 if (time_after(jiffies, rtlpriv->btcoexist.btc_info.in_4way_ts + 2235 msecs_to_jiffies(IN_4WAY_TIMEOUT_TIME))) 2236 rtlpriv->btcoexist.btc_info.in_4way = false; 2237 } 2238 2239 rtlpriv->link_info.bcn_rx_inperiod = 0; 2240 2241 /* <6> scan list */ 2242 rtl_scan_list_expire(hw); 2243 2244 /* <7> check ack queue */ 2245 rtl_free_entries_from_ack_queue(hw, true); 2246 } 2247 2248 void rtl_watch_dog_timer_callback(struct timer_list *t) 2249 { 2250 struct rtl_priv *rtlpriv = from_timer(rtlpriv, t, works.watchdog_timer); 2251 2252 queue_delayed_work(rtlpriv->works.rtl_wq, 2253 &rtlpriv->works.watchdog_wq, 0); 2254 2255 mod_timer(&rtlpriv->works.watchdog_timer, 2256 jiffies + MSECS(RTL_WATCH_DOG_TIME)); 2257 } 2258 void rtl_fwevt_wq_callback(void *data) 2259 { 2260 struct rtl_works *rtlworks = 2261 container_of_dwork_rtl(data, struct rtl_works, fwevt_wq); 2262 struct ieee80211_hw *hw = rtlworks->hw; 2263 struct rtl_priv *rtlpriv = rtl_priv(hw); 2264 2265 rtlpriv->cfg->ops->c2h_command_handle(hw); 2266 } 2267 2268 static void rtl_c2h_content_parsing(struct ieee80211_hw *hw, 2269 struct sk_buff *skb); 2270 2271 static bool rtl_c2h_fast_cmd(struct ieee80211_hw *hw, struct sk_buff *skb) 2272 { 2273 u8 cmd_id = GET_C2H_CMD_ID(skb->data); 2274 2275 switch (cmd_id) { 2276 case C2H_BT_MP: 2277 return true; 2278 default: 2279 break; 2280 } 2281 2282 return false; 2283 } 2284 2285 void rtl_c2hcmd_enqueue(struct ieee80211_hw *hw, struct sk_buff *skb) 2286 { 2287 struct rtl_priv *rtlpriv = rtl_priv(hw); 2288 unsigned long flags; 2289 2290 if (rtl_c2h_fast_cmd(hw, skb)) { 2291 rtl_c2h_content_parsing(hw, skb); 2292 kfree_skb(skb); 2293 return; 2294 } 2295 2296 /* enqueue */ 2297 spin_lock_irqsave(&rtlpriv->locks.c2hcmd_lock, flags); 2298 2299 __skb_queue_tail(&rtlpriv->c2hcmd_queue, skb); 2300 2301 spin_unlock_irqrestore(&rtlpriv->locks.c2hcmd_lock, flags); 2302 2303 /* wake up wq */ 2304 queue_delayed_work(rtlpriv->works.rtl_wq, &rtlpriv->works.c2hcmd_wq, 0); 2305 } 2306 EXPORT_SYMBOL(rtl_c2hcmd_enqueue); 2307 2308 static void rtl_c2h_content_parsing(struct ieee80211_hw *hw, 2309 struct sk_buff *skb) 2310 { 2311 struct rtl_priv *rtlpriv = rtl_priv(hw); 2312 struct rtl_hal_ops *hal_ops = rtlpriv->cfg->ops; 2313 const struct rtl_btc_ops *btc_ops = rtlpriv->btcoexist.btc_ops; 2314 u8 cmd_id, cmd_seq, cmd_len; 2315 u8 *cmd_buf = NULL; 2316 2317 cmd_id = GET_C2H_CMD_ID(skb->data); 2318 cmd_seq = GET_C2H_SEQ(skb->data); 2319 cmd_len = skb->len - C2H_DATA_OFFSET; 2320 cmd_buf = GET_C2H_DATA_PTR(skb->data); 2321 2322 switch (cmd_id) { 2323 case C2H_DBG: 2324 RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD, "[C2H], C2H_DBG!!\n"); 2325 break; 2326 case C2H_TXBF: 2327 RT_TRACE(rtlpriv, COMP_FW, DBG_TRACE, 2328 "[C2H], C2H_TXBF!!\n"); 2329 break; 2330 case C2H_TX_REPORT: 2331 rtl_tx_report_handler(hw, cmd_buf, cmd_len); 2332 break; 2333 case C2H_RA_RPT: 2334 if (hal_ops->c2h_ra_report_handler) 2335 hal_ops->c2h_ra_report_handler(hw, cmd_buf, cmd_len); 2336 break; 2337 case C2H_BT_INFO: 2338 RT_TRACE(rtlpriv, COMP_FW, DBG_TRACE, 2339 "[C2H], C2H_BT_INFO!!\n"); 2340 if (rtlpriv->cfg->ops->get_btc_status()) 2341 btc_ops->btc_btinfo_notify(rtlpriv, cmd_buf, cmd_len); 2342 break; 2343 case C2H_BT_MP: 2344 RT_TRACE(rtlpriv, COMP_FW, DBG_TRACE, 2345 "[C2H], C2H_BT_MP!!\n"); 2346 if (rtlpriv->cfg->ops->get_btc_status()) 2347 btc_ops->btc_btmpinfo_notify(rtlpriv, cmd_buf, cmd_len); 2348 break; 2349 default: 2350 RT_TRACE(rtlpriv, COMP_FW, DBG_TRACE, 2351 "[C2H], Unknown packet!! cmd_id(%#X)!\n", cmd_id); 2352 break; 2353 } 2354 } 2355 2356 void rtl_c2hcmd_launcher(struct ieee80211_hw *hw, int exec) 2357 { 2358 struct rtl_priv *rtlpriv = rtl_priv(hw); 2359 struct sk_buff *skb; 2360 unsigned long flags; 2361 int i; 2362 2363 for (i = 0; i < 200; i++) { 2364 /* dequeue a task */ 2365 spin_lock_irqsave(&rtlpriv->locks.c2hcmd_lock, flags); 2366 2367 skb = __skb_dequeue(&rtlpriv->c2hcmd_queue); 2368 2369 spin_unlock_irqrestore(&rtlpriv->locks.c2hcmd_lock, flags); 2370 2371 /* do it */ 2372 if (!skb) 2373 break; 2374 2375 RT_TRACE(rtlpriv, COMP_FW, DBG_DMESG, "C2H rx_desc_shift=%d\n", 2376 *((u8 *)skb->cb)); 2377 RT_PRINT_DATA(rtlpriv, COMP_FW, DBG_DMESG, 2378 "C2H data: ", skb->data, skb->len); 2379 2380 if (exec) 2381 rtl_c2h_content_parsing(hw, skb); 2382 2383 /* free */ 2384 dev_kfree_skb_any(skb); 2385 } 2386 } 2387 2388 void rtl_c2hcmd_wq_callback(void *data) 2389 { 2390 struct rtl_works *rtlworks = container_of_dwork_rtl(data, 2391 struct rtl_works, 2392 c2hcmd_wq); 2393 struct ieee80211_hw *hw = rtlworks->hw; 2394 2395 rtl_c2hcmd_launcher(hw, 1); 2396 } 2397 2398 void rtl_easy_concurrent_retrytimer_callback(struct timer_list *t) 2399 { 2400 struct rtl_priv *rtlpriv = 2401 from_timer(rtlpriv, t, works.dualmac_easyconcurrent_retrytimer); 2402 struct ieee80211_hw *hw = rtlpriv->hw; 2403 struct rtl_priv *buddy_priv = rtlpriv->buddy_priv; 2404 2405 if (buddy_priv == NULL) 2406 return; 2407 2408 rtlpriv->cfg->ops->dualmac_easy_concurrent(hw); 2409 } 2410 /********************************************************* 2411 * 2412 * frame process functions 2413 * 2414 *********************************************************/ 2415 u8 *rtl_find_ie(u8 *data, unsigned int len, u8 ie) 2416 { 2417 struct ieee80211_mgmt *mgmt = (void *)data; 2418 u8 *pos, *end; 2419 2420 pos = (u8 *)mgmt->u.beacon.variable; 2421 end = data + len; 2422 while (pos < end) { 2423 if (pos + 2 + pos[1] > end) 2424 return NULL; 2425 2426 if (pos[0] == ie) 2427 return pos; 2428 2429 pos += 2 + pos[1]; 2430 } 2431 return NULL; 2432 } 2433 2434 /* when we use 2 rx ants we send IEEE80211_SMPS_OFF */ 2435 /* when we use 1 rx ant we send IEEE80211_SMPS_STATIC */ 2436 static struct sk_buff *rtl_make_smps_action(struct ieee80211_hw *hw, 2437 enum ieee80211_smps_mode smps, 2438 u8 *da, u8 *bssid) 2439 { 2440 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 2441 struct sk_buff *skb; 2442 struct ieee80211_mgmt *action_frame; 2443 2444 /* 27 = header + category + action + smps mode */ 2445 skb = dev_alloc_skb(27 + hw->extra_tx_headroom); 2446 if (!skb) 2447 return NULL; 2448 2449 skb_reserve(skb, hw->extra_tx_headroom); 2450 action_frame = skb_put_zero(skb, 27); 2451 memcpy(action_frame->da, da, ETH_ALEN); 2452 memcpy(action_frame->sa, rtlefuse->dev_addr, ETH_ALEN); 2453 memcpy(action_frame->bssid, bssid, ETH_ALEN); 2454 action_frame->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 2455 IEEE80211_STYPE_ACTION); 2456 action_frame->u.action.category = WLAN_CATEGORY_HT; 2457 action_frame->u.action.u.ht_smps.action = WLAN_HT_ACTION_SMPS; 2458 switch (smps) { 2459 case IEEE80211_SMPS_AUTOMATIC:/* 0 */ 2460 case IEEE80211_SMPS_NUM_MODES:/* 4 */ 2461 WARN_ON(1); 2462 /* fall through */ 2463 case IEEE80211_SMPS_OFF:/* 1 */ /*MIMO_PS_NOLIMIT*/ 2464 action_frame->u.action.u.ht_smps.smps_control = 2465 WLAN_HT_SMPS_CONTROL_DISABLED;/* 0 */ 2466 break; 2467 case IEEE80211_SMPS_STATIC:/* 2 */ /*MIMO_PS_STATIC*/ 2468 action_frame->u.action.u.ht_smps.smps_control = 2469 WLAN_HT_SMPS_CONTROL_STATIC;/* 1 */ 2470 break; 2471 case IEEE80211_SMPS_DYNAMIC:/* 3 */ /*MIMO_PS_DYNAMIC*/ 2472 action_frame->u.action.u.ht_smps.smps_control = 2473 WLAN_HT_SMPS_CONTROL_DYNAMIC;/* 3 */ 2474 break; 2475 } 2476 2477 return skb; 2478 } 2479 2480 int rtl_send_smps_action(struct ieee80211_hw *hw, 2481 struct ieee80211_sta *sta, 2482 enum ieee80211_smps_mode smps) 2483 { 2484 struct rtl_priv *rtlpriv = rtl_priv(hw); 2485 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 2486 struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); 2487 struct sk_buff *skb = NULL; 2488 struct rtl_tcb_desc tcb_desc; 2489 u8 bssid[ETH_ALEN] = {0}; 2490 2491 memset(&tcb_desc, 0, sizeof(struct rtl_tcb_desc)); 2492 2493 if (rtlpriv->mac80211.act_scanning) 2494 goto err_free; 2495 2496 if (!sta) 2497 goto err_free; 2498 2499 if (unlikely(is_hal_stop(rtlhal) || ppsc->rfpwr_state != ERFON)) 2500 goto err_free; 2501 2502 if (!test_bit(RTL_STATUS_INTERFACE_START, &rtlpriv->status)) 2503 goto err_free; 2504 2505 if (rtlpriv->mac80211.opmode == NL80211_IFTYPE_AP) 2506 memcpy(bssid, rtlpriv->efuse.dev_addr, ETH_ALEN); 2507 else 2508 memcpy(bssid, rtlpriv->mac80211.bssid, ETH_ALEN); 2509 2510 skb = rtl_make_smps_action(hw, smps, sta->addr, bssid); 2511 /* this is a type = mgmt * stype = action frame */ 2512 if (skb) { 2513 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 2514 struct rtl_sta_info *sta_entry = 2515 (struct rtl_sta_info *) sta->drv_priv; 2516 sta_entry->mimo_ps = smps; 2517 /* rtlpriv->cfg->ops->update_rate_tbl(hw, sta, 0, true); */ 2518 2519 info->control.rates[0].idx = 0; 2520 info->band = hw->conf.chandef.chan->band; 2521 rtlpriv->intf_ops->adapter_tx(hw, sta, skb, &tcb_desc); 2522 } 2523 return 1; 2524 2525 err_free: 2526 return 0; 2527 } 2528 EXPORT_SYMBOL(rtl_send_smps_action); 2529 2530 void rtl_phy_scan_operation_backup(struct ieee80211_hw *hw, u8 operation) 2531 { 2532 struct rtl_priv *rtlpriv = rtl_priv(hw); 2533 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); 2534 enum io_type iotype; 2535 2536 if (!is_hal_stop(rtlhal)) { 2537 switch (operation) { 2538 case SCAN_OPT_BACKUP: 2539 iotype = IO_CMD_PAUSE_DM_BY_SCAN; 2540 rtlpriv->cfg->ops->set_hw_reg(hw, 2541 HW_VAR_IO_CMD, 2542 (u8 *)&iotype); 2543 break; 2544 case SCAN_OPT_RESTORE: 2545 iotype = IO_CMD_RESUME_DM_BY_SCAN; 2546 rtlpriv->cfg->ops->set_hw_reg(hw, 2547 HW_VAR_IO_CMD, 2548 (u8 *)&iotype); 2549 break; 2550 default: 2551 pr_err("Unknown Scan Backup operation.\n"); 2552 break; 2553 } 2554 } 2555 } 2556 EXPORT_SYMBOL(rtl_phy_scan_operation_backup); 2557 2558 /* because mac80211 have issues when can receive del ba 2559 * so here we just make a fake del_ba if we receive a ba_req 2560 * but rx_agg was opened to let mac80211 release some ba 2561 * related resources, so please this del_ba for tx 2562 */ 2563 struct sk_buff *rtl_make_del_ba(struct ieee80211_hw *hw, 2564 u8 *sa, u8 *bssid, u16 tid) 2565 { 2566 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 2567 struct sk_buff *skb; 2568 struct ieee80211_mgmt *action_frame; 2569 u16 params; 2570 2571 /* 27 = header + category + action + smps mode */ 2572 skb = dev_alloc_skb(34 + hw->extra_tx_headroom); 2573 if (!skb) 2574 return NULL; 2575 2576 skb_reserve(skb, hw->extra_tx_headroom); 2577 action_frame = skb_put_zero(skb, 34); 2578 memcpy(action_frame->sa, sa, ETH_ALEN); 2579 memcpy(action_frame->da, rtlefuse->dev_addr, ETH_ALEN); 2580 memcpy(action_frame->bssid, bssid, ETH_ALEN); 2581 action_frame->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 2582 IEEE80211_STYPE_ACTION); 2583 action_frame->u.action.category = WLAN_CATEGORY_BACK; 2584 action_frame->u.action.u.delba.action_code = WLAN_ACTION_DELBA; 2585 params = (u16)(1 << 11); /* bit 11 initiator */ 2586 params |= (u16)(tid << 12); /* bit 15:12 TID number */ 2587 2588 action_frame->u.action.u.delba.params = cpu_to_le16(params); 2589 action_frame->u.action.u.delba.reason_code = 2590 cpu_to_le16(WLAN_REASON_QSTA_TIMEOUT); 2591 2592 return skb; 2593 } 2594 2595 /********************************************************* 2596 * 2597 * IOT functions 2598 * 2599 *********************************************************/ 2600 static bool rtl_chk_vendor_ouisub(struct ieee80211_hw *hw, 2601 struct octet_string vendor_ie) 2602 { 2603 struct rtl_priv *rtlpriv = rtl_priv(hw); 2604 bool matched = false; 2605 static u8 athcap_1[] = { 0x00, 0x03, 0x7F }; 2606 static u8 athcap_2[] = { 0x00, 0x13, 0x74 }; 2607 static u8 broadcap_1[] = { 0x00, 0x10, 0x18 }; 2608 static u8 broadcap_2[] = { 0x00, 0x0a, 0xf7 }; 2609 static u8 broadcap_3[] = { 0x00, 0x05, 0xb5 }; 2610 static u8 racap[] = { 0x00, 0x0c, 0x43 }; 2611 static u8 ciscocap[] = { 0x00, 0x40, 0x96 }; 2612 static u8 marvcap[] = { 0x00, 0x50, 0x43 }; 2613 2614 if (memcmp(vendor_ie.octet, athcap_1, 3) == 0 || 2615 memcmp(vendor_ie.octet, athcap_2, 3) == 0) { 2616 rtlpriv->mac80211.vendor = PEER_ATH; 2617 matched = true; 2618 } else if (memcmp(vendor_ie.octet, broadcap_1, 3) == 0 || 2619 memcmp(vendor_ie.octet, broadcap_2, 3) == 0 || 2620 memcmp(vendor_ie.octet, broadcap_3, 3) == 0) { 2621 rtlpriv->mac80211.vendor = PEER_BROAD; 2622 matched = true; 2623 } else if (memcmp(vendor_ie.octet, racap, 3) == 0) { 2624 rtlpriv->mac80211.vendor = PEER_RAL; 2625 matched = true; 2626 } else if (memcmp(vendor_ie.octet, ciscocap, 3) == 0) { 2627 rtlpriv->mac80211.vendor = PEER_CISCO; 2628 matched = true; 2629 } else if (memcmp(vendor_ie.octet, marvcap, 3) == 0) { 2630 rtlpriv->mac80211.vendor = PEER_MARV; 2631 matched = true; 2632 } 2633 2634 return matched; 2635 } 2636 2637 static bool rtl_find_221_ie(struct ieee80211_hw *hw, u8 *data, 2638 unsigned int len) 2639 { 2640 struct ieee80211_mgmt *mgmt = (void *)data; 2641 struct octet_string vendor_ie; 2642 u8 *pos, *end; 2643 2644 pos = (u8 *)mgmt->u.beacon.variable; 2645 end = data + len; 2646 while (pos < end) { 2647 if (pos[0] == 221) { 2648 vendor_ie.length = pos[1]; 2649 vendor_ie.octet = &pos[2]; 2650 if (rtl_chk_vendor_ouisub(hw, vendor_ie)) 2651 return true; 2652 } 2653 2654 if (pos + 2 + pos[1] > end) 2655 return false; 2656 2657 pos += 2 + pos[1]; 2658 } 2659 return false; 2660 } 2661 2662 void rtl_recognize_peer(struct ieee80211_hw *hw, u8 *data, unsigned int len) 2663 { 2664 struct rtl_priv *rtlpriv = rtl_priv(hw); 2665 struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 2666 struct ieee80211_hdr *hdr = (void *)data; 2667 u32 vendor = PEER_UNKNOWN; 2668 2669 static u8 ap3_1[3] = { 0x00, 0x14, 0xbf }; 2670 static u8 ap3_2[3] = { 0x00, 0x1a, 0x70 }; 2671 static u8 ap3_3[3] = { 0x00, 0x1d, 0x7e }; 2672 static u8 ap4_1[3] = { 0x00, 0x90, 0xcc }; 2673 static u8 ap4_2[3] = { 0x00, 0x0e, 0x2e }; 2674 static u8 ap4_3[3] = { 0x00, 0x18, 0x02 }; 2675 static u8 ap4_4[3] = { 0x00, 0x17, 0x3f }; 2676 static u8 ap4_5[3] = { 0x00, 0x1c, 0xdf }; 2677 static u8 ap5_1[3] = { 0x00, 0x1c, 0xf0 }; 2678 static u8 ap5_2[3] = { 0x00, 0x21, 0x91 }; 2679 static u8 ap5_3[3] = { 0x00, 0x24, 0x01 }; 2680 static u8 ap5_4[3] = { 0x00, 0x15, 0xe9 }; 2681 static u8 ap5_5[3] = { 0x00, 0x17, 0x9A }; 2682 static u8 ap5_6[3] = { 0x00, 0x18, 0xE7 }; 2683 static u8 ap6_1[3] = { 0x00, 0x17, 0x94 }; 2684 static u8 ap7_1[3] = { 0x00, 0x14, 0xa4 }; 2685 2686 if (mac->opmode != NL80211_IFTYPE_STATION) 2687 return; 2688 2689 if (mac->link_state == MAC80211_NOLINK) { 2690 mac->vendor = PEER_UNKNOWN; 2691 return; 2692 } 2693 2694 if (mac->cnt_after_linked > 2) 2695 return; 2696 2697 /* check if this really is a beacon */ 2698 if (!ieee80211_is_beacon(hdr->frame_control)) 2699 return; 2700 2701 /* min. beacon length + FCS_LEN */ 2702 if (len <= 40 + FCS_LEN) 2703 return; 2704 2705 /* and only beacons from the associated BSSID, please */ 2706 if (!ether_addr_equal_64bits(hdr->addr3, rtlpriv->mac80211.bssid)) 2707 return; 2708 2709 if (rtl_find_221_ie(hw, data, len)) 2710 vendor = mac->vendor; 2711 2712 if ((memcmp(mac->bssid, ap5_1, 3) == 0) || 2713 (memcmp(mac->bssid, ap5_2, 3) == 0) || 2714 (memcmp(mac->bssid, ap5_3, 3) == 0) || 2715 (memcmp(mac->bssid, ap5_4, 3) == 0) || 2716 (memcmp(mac->bssid, ap5_5, 3) == 0) || 2717 (memcmp(mac->bssid, ap5_6, 3) == 0) || 2718 vendor == PEER_ATH) { 2719 vendor = PEER_ATH; 2720 RT_TRACE(rtlpriv, COMP_MAC80211, DBG_LOUD, "=>ath find\n"); 2721 } else if ((memcmp(mac->bssid, ap4_4, 3) == 0) || 2722 (memcmp(mac->bssid, ap4_5, 3) == 0) || 2723 (memcmp(mac->bssid, ap4_1, 3) == 0) || 2724 (memcmp(mac->bssid, ap4_2, 3) == 0) || 2725 (memcmp(mac->bssid, ap4_3, 3) == 0) || 2726 vendor == PEER_RAL) { 2727 RT_TRACE(rtlpriv, COMP_MAC80211, DBG_LOUD, "=>ral find\n"); 2728 vendor = PEER_RAL; 2729 } else if (memcmp(mac->bssid, ap6_1, 3) == 0 || 2730 vendor == PEER_CISCO) { 2731 vendor = PEER_CISCO; 2732 RT_TRACE(rtlpriv, COMP_MAC80211, DBG_LOUD, "=>cisco find\n"); 2733 } else if ((memcmp(mac->bssid, ap3_1, 3) == 0) || 2734 (memcmp(mac->bssid, ap3_2, 3) == 0) || 2735 (memcmp(mac->bssid, ap3_3, 3) == 0) || 2736 vendor == PEER_BROAD) { 2737 RT_TRACE(rtlpriv, COMP_MAC80211, DBG_LOUD, "=>broad find\n"); 2738 vendor = PEER_BROAD; 2739 } else if (memcmp(mac->bssid, ap7_1, 3) == 0 || 2740 vendor == PEER_MARV) { 2741 vendor = PEER_MARV; 2742 RT_TRACE(rtlpriv, COMP_MAC80211, DBG_LOUD, "=>marv find\n"); 2743 } 2744 2745 mac->vendor = vendor; 2746 } 2747 EXPORT_SYMBOL_GPL(rtl_recognize_peer); 2748 2749 MODULE_AUTHOR("lizhaoming <chaoming_li@realsil.com.cn>"); 2750 MODULE_AUTHOR("Realtek WlanFAE <wlanfae@realtek.com>"); 2751 MODULE_AUTHOR("Larry Finger <Larry.FInger@lwfinger.net>"); 2752 MODULE_LICENSE("GPL"); 2753 MODULE_DESCRIPTION("Realtek 802.11n PCI wireless core"); 2754 2755 struct rtl_global_var rtl_global_var = {}; 2756 EXPORT_SYMBOL_GPL(rtl_global_var); 2757 2758 static int __init rtl_core_module_init(void) 2759 { 2760 BUILD_BUG_ON(TX_PWR_BY_RATE_NUM_RATE < TX_PWR_BY_RATE_NUM_SECTION); 2761 BUILD_BUG_ON(MAX_RATE_SECTION_NUM != MAX_RATE_SECTION); 2762 BUILD_BUG_ON(MAX_BASE_NUM_IN_PHY_REG_PG_24G != MAX_RATE_SECTION); 2763 BUILD_BUG_ON(MAX_BASE_NUM_IN_PHY_REG_PG_5G != (MAX_RATE_SECTION - 1)); 2764 2765 if (rtl_rate_control_register()) 2766 pr_err("rtl: Unable to register rtl_rc, use default RC !!\n"); 2767 2768 /* add debugfs */ 2769 rtl_debugfs_add_topdir(); 2770 2771 /* init some global vars */ 2772 INIT_LIST_HEAD(&rtl_global_var.glb_priv_list); 2773 spin_lock_init(&rtl_global_var.glb_list_lock); 2774 2775 return 0; 2776 } 2777 2778 static void __exit rtl_core_module_exit(void) 2779 { 2780 /*RC*/ 2781 rtl_rate_control_unregister(); 2782 2783 /* remove debugfs */ 2784 rtl_debugfs_remove_topdir(); 2785 } 2786 2787 module_init(rtl_core_module_init); 2788 module_exit(rtl_core_module_exit); 2789