rtw_cmd.c revision 43de03040998e98d8703b48dd0bf7705b649dfae
1/****************************************************************************** 2 * 3 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved. 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 ******************************************************************************/ 15#define _RTW_CMD_C_ 16 17#include <osdep_service.h> 18#include <drv_types.h> 19#include <recv_osdep.h> 20#include <mlme_osdep.h> 21#include <rtl8723a_cmd.h> 22#include <rtw_sreset.h> 23 24#ifdef CONFIG_8723AU_BT_COEXIST 25#include <rtl8723a_hal.h> 26#endif /* CONFIG_8723AU_BT_COEXIST */ 27 28static struct cmd_hdl wlancmds[] = { 29 GEN_DRV_CMD_HANDLER(0, NULL) /*0*/ 30 GEN_DRV_CMD_HANDLER(0, NULL) 31 GEN_DRV_CMD_HANDLER(0, NULL) 32 GEN_DRV_CMD_HANDLER(0, NULL) 33 GEN_DRV_CMD_HANDLER(0, NULL) 34 GEN_DRV_CMD_HANDLER(0, NULL) 35 GEN_MLME_EXT_HANDLER(0, NULL) 36 GEN_MLME_EXT_HANDLER(0, NULL) 37 GEN_MLME_EXT_HANDLER(0, NULL) 38 GEN_MLME_EXT_HANDLER(0, NULL) 39 GEN_MLME_EXT_HANDLER(0, NULL) /*10*/ 40 GEN_MLME_EXT_HANDLER(0, NULL) 41 GEN_MLME_EXT_HANDLER(0, NULL) 42 GEN_MLME_EXT_HANDLER(0, NULL) 43 GEN_MLME_EXT_HANDLER(sizeof (struct wlan_bssid_ex), join_cmd_hdl23a) /*14*/ 44 GEN_MLME_EXT_HANDLER(sizeof (struct disconnect_parm), disconnect_hdl23a) 45 GEN_MLME_EXT_HANDLER(sizeof (struct wlan_bssid_ex), createbss_hdl23a) 46 GEN_MLME_EXT_HANDLER(sizeof (struct setopmode_parm), setopmode_hdl23a) 47 GEN_MLME_EXT_HANDLER(sizeof (struct sitesurvey_parm), sitesurvey_cmd_hdl23a) /*18*/ 48 GEN_MLME_EXT_HANDLER(sizeof (struct setauth_parm), setauth_hdl23a) 49 GEN_MLME_EXT_HANDLER(sizeof (struct setkey_parm), setkey_hdl23a) /*20*/ 50 GEN_MLME_EXT_HANDLER(sizeof (struct set_stakey_parm), set_stakey_hdl23a) 51 GEN_MLME_EXT_HANDLER(sizeof (struct set_assocsta_parm), NULL) 52 GEN_MLME_EXT_HANDLER(sizeof (struct del_assocsta_parm), NULL) 53 GEN_MLME_EXT_HANDLER(sizeof (struct setstapwrstate_parm), NULL) 54 GEN_MLME_EXT_HANDLER(sizeof (struct setbasicrate_parm), NULL) 55 GEN_MLME_EXT_HANDLER(sizeof (struct getbasicrate_parm), NULL) 56 GEN_MLME_EXT_HANDLER(sizeof (struct setdatarate_parm), NULL) 57 GEN_MLME_EXT_HANDLER(sizeof (struct getdatarate_parm), NULL) 58 GEN_MLME_EXT_HANDLER(sizeof (struct setphyinfo_parm), NULL) 59 GEN_MLME_EXT_HANDLER(sizeof (struct getphyinfo_parm), NULL) /*30*/ 60 GEN_MLME_EXT_HANDLER(sizeof (struct setphy_parm), NULL) 61 GEN_MLME_EXT_HANDLER(sizeof (struct getphy_parm), NULL) 62 GEN_MLME_EXT_HANDLER(0, NULL) 63 GEN_MLME_EXT_HANDLER(0, NULL) 64 GEN_MLME_EXT_HANDLER(0, NULL) 65 GEN_MLME_EXT_HANDLER(0, NULL) 66 GEN_MLME_EXT_HANDLER(0, NULL) 67 GEN_MLME_EXT_HANDLER(0, NULL) 68 GEN_MLME_EXT_HANDLER(0, NULL) 69 GEN_MLME_EXT_HANDLER(0, NULL) /*40*/ 70 GEN_MLME_EXT_HANDLER(0, NULL) 71 GEN_MLME_EXT_HANDLER(0, NULL) 72 GEN_MLME_EXT_HANDLER(0, NULL) 73 GEN_MLME_EXT_HANDLER(0, NULL) 74 GEN_MLME_EXT_HANDLER(sizeof(struct addBaReq_parm), add_ba_hdl23a) 75 GEN_MLME_EXT_HANDLER(sizeof(struct set_ch_parm), set_ch_hdl23a) /* 46 */ 76 GEN_MLME_EXT_HANDLER(0, NULL) 77 GEN_MLME_EXT_HANDLER(0, NULL) 78 GEN_MLME_EXT_HANDLER(0, NULL) 79 GEN_MLME_EXT_HANDLER(0, NULL) /*50*/ 80 GEN_MLME_EXT_HANDLER(0, NULL) 81 GEN_MLME_EXT_HANDLER(0, NULL) 82 GEN_MLME_EXT_HANDLER(0, NULL) 83 GEN_MLME_EXT_HANDLER(0, NULL) 84 GEN_MLME_EXT_HANDLER(sizeof(struct Tx_Beacon_param), tx_beacon_hdl23a) /*55*/ 85 86 GEN_MLME_EXT_HANDLER(0, mlme_evt_hdl23a) /*56*/ 87 GEN_MLME_EXT_HANDLER(0, rtw_drvextra_cmd_hdl23a) /*57*/ 88 89 GEN_MLME_EXT_HANDLER(0, h2c_msg_hdl23a) /*58*/ 90 GEN_MLME_EXT_HANDLER(sizeof(struct SetChannelPlan_param), set_chplan_hdl23a) /*59*/ 91 GEN_MLME_EXT_HANDLER(sizeof(struct LedBlink_param), led_blink_hdl23a) /*60*/ 92 93 GEN_MLME_EXT_HANDLER(sizeof(struct SetChannelSwitch_param), set_csa_hdl23a) /*61*/ 94 GEN_MLME_EXT_HANDLER(sizeof(struct TDLSoption_param), tdls_hdl23a) /*62*/ 95}; 96 97struct _cmd_callback rtw_cmd_callback[] = { 98 {GEN_CMD_CODE(_Read_MACREG), NULL}, /*0*/ 99 {GEN_CMD_CODE(_Write_MACREG), NULL}, 100 {GEN_CMD_CODE(_Read_BBREG), &rtw_getbbrfreg_cmdrsp_callback23a}, 101 {GEN_CMD_CODE(_Write_BBREG), NULL}, 102 {GEN_CMD_CODE(_Read_RFREG), &rtw_getbbrfreg_cmdrsp_callback23a}, 103 {GEN_CMD_CODE(_Write_RFREG), NULL}, /*5*/ 104 {GEN_CMD_CODE(_Read_EEPROM), NULL}, 105 {GEN_CMD_CODE(_Write_EEPROM), NULL}, 106 {GEN_CMD_CODE(_Read_EFUSE), NULL}, 107 {GEN_CMD_CODE(_Write_EFUSE), NULL}, 108 109 {GEN_CMD_CODE(_Read_CAM), NULL}, /*10*/ 110 {GEN_CMD_CODE(_Write_CAM), NULL}, 111 {GEN_CMD_CODE(_setBCNITV), NULL}, 112 {GEN_CMD_CODE(_setMBIDCFG), NULL}, 113 {GEN_CMD_CODE(_JoinBss), &rtw_joinbss_cmd23a_callback}, /*14*/ 114 {GEN_CMD_CODE(_DisConnect), &rtw_disassoc_cmd23a_callback}, /*15*/ 115 {GEN_CMD_CODE(_CreateBss), &rtw_createbss_cmd23a_callback}, 116 {GEN_CMD_CODE(_SetOpMode), NULL}, 117 {GEN_CMD_CODE(_SiteSurvey), &rtw_survey_cmd_callback23a}, /*18*/ 118 {GEN_CMD_CODE(_SetAuth), NULL}, 119 120 {GEN_CMD_CODE(_SetKey), NULL}, /*20*/ 121 {GEN_CMD_CODE(_SetStaKey), &rtw_setstaKey_cmdrsp_callback23a}, 122 {GEN_CMD_CODE(_SetAssocSta), &rtw_setassocsta_cmdrsp_callback23a}, 123 {GEN_CMD_CODE(_DelAssocSta), NULL}, 124 {GEN_CMD_CODE(_SetStaPwrState), NULL}, 125 {GEN_CMD_CODE(_SetBasicRate), NULL}, /*25*/ 126 {GEN_CMD_CODE(_GetBasicRate), NULL}, 127 {GEN_CMD_CODE(_SetDataRate), NULL}, 128 {GEN_CMD_CODE(_GetDataRate), NULL}, 129 {GEN_CMD_CODE(_SetPhyInfo), NULL}, 130 131 {GEN_CMD_CODE(_GetPhyInfo), NULL}, /*30*/ 132 {GEN_CMD_CODE(_SetPhy), NULL}, 133 {GEN_CMD_CODE(_GetPhy), NULL}, 134 {GEN_CMD_CODE(_readRssi), NULL}, 135 {GEN_CMD_CODE(_readGain), NULL}, 136 {GEN_CMD_CODE(_SetAtim), NULL}, /*35*/ 137 {GEN_CMD_CODE(_SetPwrMode), NULL}, 138 {GEN_CMD_CODE(_JoinbssRpt), NULL}, 139 {GEN_CMD_CODE(_SetRaTable), NULL}, 140 {GEN_CMD_CODE(_GetRaTable), NULL}, 141 142 {GEN_CMD_CODE(_GetCCXReport), NULL}, /*40*/ 143 {GEN_CMD_CODE(_GetDTMReport), NULL}, 144 {GEN_CMD_CODE(_GetTXRateStatistics), NULL}, 145 {GEN_CMD_CODE(_SetUsbSuspend), NULL}, 146 {GEN_CMD_CODE(_SetH2cLbk), NULL}, 147 {GEN_CMD_CODE(_AddBAReq), NULL}, /*45*/ 148 {GEN_CMD_CODE(_SetChannel), NULL}, /*46*/ 149 {GEN_CMD_CODE(_SetTxPower), NULL}, 150 {GEN_CMD_CODE(_SwitchAntenna), NULL}, 151 {GEN_CMD_CODE(_SetCrystalCap), NULL}, 152 {GEN_CMD_CODE(_SetSingleCarrierTx), NULL}, /*50*/ 153 154 {GEN_CMD_CODE(_SetSingleToneTx), NULL}, /*51*/ 155 {GEN_CMD_CODE(_SetCarrierSuppressionTx), NULL}, 156 {GEN_CMD_CODE(_SetContinuousTx), NULL}, 157 {GEN_CMD_CODE(_SwitchBandwidth), NULL}, /*54*/ 158 {GEN_CMD_CODE(_TX_Beacon), NULL},/*55*/ 159 160 {GEN_CMD_CODE(_Set_MLME_EVT), NULL},/*56*/ 161 {GEN_CMD_CODE(_Set_Drv_Extra), NULL},/*57*/ 162 {GEN_CMD_CODE(_Set_H2C_MSG), NULL},/*58*/ 163 {GEN_CMD_CODE(_SetChannelPlan), NULL},/*59*/ 164 {GEN_CMD_CODE(_LedBlink), NULL},/*60*/ 165 166 {GEN_CMD_CODE(_SetChannelSwitch), NULL},/*61*/ 167 {GEN_CMD_CODE(_TDLS), NULL},/*62*/ 168}; 169 170/* 171Caller and the rtw_cmd_thread23a can protect cmd_q by spin_lock. 172No irqsave is necessary. 173*/ 174 175int rtw_init_cmd_priv23a(struct cmd_priv *pcmdpriv) 176{ 177 int res = _SUCCESS; 178 179 pcmdpriv->cmd_issued_cnt = 0; 180 pcmdpriv->cmd_done_cnt = 0; 181 pcmdpriv->rsp_cnt = 0; 182 183 pcmdpriv->wq = alloc_workqueue("rtl8723au_cmd", 0, 1); 184 if (!pcmdpriv->wq) 185 res = _FAIL; 186 187 return res; 188} 189 190/* forward definition */ 191 192static void rtw_irq_work(struct work_struct *work); 193 194u32 rtw_init_evt_priv23a(struct evt_priv *pevtpriv) 195{ 196 pevtpriv->wq = alloc_workqueue("rtl8723au_evt", 0, 1); 197 198 INIT_WORK(&pevtpriv->irq_wk, rtw_irq_work); 199 200 return _SUCCESS; 201} 202 203void rtw_free_evt_priv23a(struct evt_priv *pevtpriv) 204{ 205 cancel_work_sync(&pevtpriv->irq_wk); 206} 207 208static int rtw_cmd_filter(struct cmd_priv *pcmdpriv, struct cmd_obj *cmd_obj) 209{ 210 struct drvextra_cmd_parm *pdrvextra_cmd_parm; 211 /* set to true to allow enqueuing cmd when hw_init_completed is false */ 212 u8 bAllow = false; 213 214 /* To decide allow or not */ 215 if (pcmdpriv->padapter->pwrctrlpriv.bHWPwrPindetect && 216 !pcmdpriv->padapter->registrypriv.usbss_enable) { 217 if (cmd_obj->cmdcode == GEN_CMD_CODE(_Set_Drv_Extra)) { 218 pdrvextra_cmd_parm = 219 (struct drvextra_cmd_parm *)cmd_obj->parmbuf; 220 if (pdrvextra_cmd_parm->ec_id == 221 POWER_SAVING_CTRL_WK_CID) 222 bAllow = true; 223 } 224 } 225 226 if (cmd_obj->cmdcode == GEN_CMD_CODE(_SetChannelPlan)) 227 bAllow = true; 228 229 if (pcmdpriv->padapter->hw_init_completed == false && bAllow == false) 230 return _FAIL; 231 return _SUCCESS; 232} 233 234static void rtw_cmd_work(struct work_struct *work); 235 236int rtw_enqueue_cmd23a(struct cmd_priv *pcmdpriv, struct cmd_obj *cmd_obj) 237{ 238 int res = _FAIL; 239 240 if (!cmd_obj) 241 goto exit; 242 243 cmd_obj->padapter = pcmdpriv->padapter; 244 245 res = rtw_cmd_filter(pcmdpriv, cmd_obj); 246 if (res == _FAIL) { 247 rtw_free_cmd_obj23a(cmd_obj); 248 goto exit; 249 } 250 251 INIT_WORK(&cmd_obj->work, rtw_cmd_work); 252 253 res = queue_work(pcmdpriv->wq, &cmd_obj->work); 254 255 if (!res) { 256 printk(KERN_ERR "%s: Call to queue_work() failed\n", __func__); 257 res = _FAIL; 258 } else 259 res = _SUCCESS; 260exit: 261 262 return res; 263} 264 265void rtw_cmd_clr_isr23a(struct cmd_priv *pcmdpriv) 266{ 267 pcmdpriv->cmd_done_cnt++; 268} 269 270void rtw_free_cmd_obj23a(struct cmd_obj *pcmd) 271{ 272 273 if (pcmd->cmdcode != _JoinBss_CMD_ && 274 pcmd->cmdcode != _CreateBss_CMD_) { 275 /* free parmbuf in cmd_obj */ 276 kfree(pcmd->parmbuf); 277 } 278 279 if (pcmd->rsp) { 280 if (pcmd->rspsz != 0) { 281 /* free rsp in cmd_obj */ 282 kfree(pcmd->rsp); 283 } 284 } 285 286 kfree(pcmd); 287} 288 289static void rtw_cmd_work(struct work_struct *work) 290{ 291 int (*cmd_hdl)(struct rtw_adapter *padapter, const u8 *pbuf); 292 void (*pcmd_callback)(struct rtw_adapter *dev, struct cmd_obj *pcmd); 293 struct cmd_priv *pcmdpriv; 294 struct cmd_obj *pcmd = container_of(work, struct cmd_obj, work); 295 296 pcmdpriv = &pcmd->padapter->cmdpriv; 297 298 if (rtw_cmd_filter(pcmdpriv, pcmd) == _FAIL) { 299 pcmd->res = H2C_DROPPED; 300 goto post_process; 301 } 302 303 pcmdpriv->cmd_issued_cnt++; 304 305 pcmd->cmdsz = ALIGN(pcmd->cmdsz, 4); 306 307 if (pcmd->cmdcode < (sizeof(wlancmds)/sizeof(struct cmd_hdl))) { 308 cmd_hdl = wlancmds[pcmd->cmdcode].h2cfuns; 309 310 if (cmd_hdl) 311 pcmd->res = cmd_hdl(pcmd->padapter, pcmd->parmbuf); 312 else 313 pcmd->res = H2C_DROPPED; 314 } else 315 pcmd->res = H2C_PARAMETERS_ERROR; 316 317post_process: 318 /* call callback function for post-processed */ 319 if (pcmd->cmdcode < (sizeof(rtw_cmd_callback) / 320 sizeof(struct _cmd_callback))) { 321 pcmd_callback = rtw_cmd_callback[pcmd->cmdcode].callback; 322 if (!pcmd_callback) { 323 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, 324 ("mlme_cmd_hdl(): pcmd_callback = 0x%p, " 325 "cmdcode = 0x%x\n", 326 pcmd_callback, pcmd->cmdcode)); 327 rtw_free_cmd_obj23a(pcmd); 328 } else { 329 /* need conider that free cmd_obj in 330 rtw_cmd_callback */ 331 pcmd_callback(pcmd->padapter, pcmd); 332 } 333 } else { 334 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, 335 ("%s: cmdcode = 0x%x callback not defined!\n", 336 __func__, pcmd->cmdcode)); 337 rtw_free_cmd_obj23a(pcmd); 338 } 339} 340 341 342int rtw_sitesurvey_cmd23a(struct rtw_adapter *padapter, 343 struct cfg80211_ssid *ssid, int ssid_num, 344 struct rtw_ieee80211_channel *ch, int ch_num) 345{ 346 int res = _FAIL; 347 struct cmd_obj *ph2c; 348 struct sitesurvey_parm *psurveyPara; 349 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 350 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 351 352 if (check_fwstate(pmlmepriv, _FW_LINKED)) 353 rtw_lps_ctrl_wk_cmd23a(padapter, LPS_CTRL_SCAN, 1); 354 355 ph2c = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC); 356 if (!ph2c) 357 return _FAIL; 358 359 psurveyPara = kzalloc(sizeof(struct sitesurvey_parm), GFP_ATOMIC); 360 if (!psurveyPara) { 361 kfree(ph2c); 362 return _FAIL; 363 } 364 365 rtw_free_network_queue23a(padapter); 366 367 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, 368 ("%s: flush network queue\n", __func__)); 369 370 init_h2fwcmd_w_parm_no_rsp(ph2c, psurveyPara, 371 GEN_CMD_CODE(_SiteSurvey)); 372 373 /* psurveyPara->bsslimit = 48; */ 374 psurveyPara->scan_mode = pmlmepriv->scan_mode; 375 376 /* prepare ssid list */ 377 if (ssid) { 378 int i; 379 for (i = 0; i < ssid_num && i < RTW_SSID_SCAN_AMOUNT; i++) { 380 if (ssid[i].ssid_len) { 381 memcpy(&psurveyPara->ssid[i], &ssid[i], 382 sizeof(struct cfg80211_ssid)); 383 psurveyPara->ssid_num++; 384 } 385 } 386 } 387 388 /* prepare channel list */ 389 if (ch) { 390 int i; 391 for (i = 0; i < ch_num && i < RTW_CHANNEL_SCAN_AMOUNT; i++) { 392 if (ch[i].hw_value && 393 !(ch[i].flags & IEEE80211_CHAN_DISABLED)) { 394 memcpy(&psurveyPara->ch[i], &ch[i], 395 sizeof(struct rtw_ieee80211_channel)); 396 psurveyPara->ch_num++; 397 } 398 } 399 } 400 401 set_fwstate(pmlmepriv, _FW_UNDER_SURVEY); 402 403 res = rtw_enqueue_cmd23a(pcmdpriv, ph2c); 404 405 if (res == _SUCCESS) { 406 mod_timer(&pmlmepriv->scan_to_timer, jiffies + 407 msecs_to_jiffies(SCANNING_TIMEOUT)); 408 409 rtw_led_control(padapter, LED_CTL_SITE_SURVEY); 410 411 pmlmepriv->scan_interval = SCAN_INTERVAL;/* 30*2 sec = 60sec */ 412 } else 413 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY); 414 415 return res; 416} 417 418void rtw_getbbrfreg_cmdrsp_callback23a(struct rtw_adapter *padapter, 419 struct cmd_obj *pcmd) 420{ 421 kfree(pcmd->parmbuf); 422 kfree(pcmd); 423} 424 425int rtw_createbss_cmd23a(struct rtw_adapter *padapter) 426{ 427 struct cmd_obj *pcmd; 428 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 429 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 430 struct wlan_bssid_ex *pdev_network; 431 u8 res = _SUCCESS; 432 433 pdev_network = &padapter->registrypriv.dev_network; 434 435 rtw_led_control(padapter, LED_CTL_START_TO_LINK); 436 437 if (pmlmepriv->assoc_ssid.ssid_len == 0) { 438 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, 439 (" createbss for Any SSid:%s\n", 440 pmlmepriv->assoc_ssid.ssid)); 441 } else { 442 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, 443 (" createbss for SSid:%s\n", 444 pmlmepriv->assoc_ssid.ssid)); 445 } 446 447 pcmd = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC); 448 if (!pcmd) { 449 res = _FAIL; 450 goto exit; 451 } 452 453 pcmd->cmdcode = _CreateBss_CMD_; 454 pcmd->parmbuf = (unsigned char *)pdev_network; 455 pcmd->cmdsz = get_wlan_bssid_ex_sz(pdev_network); 456 pcmd->rsp = NULL; 457 pcmd->rspsz = 0; 458 459 pdev_network->Length = pcmd->cmdsz; 460 461 res = rtw_enqueue_cmd23a(pcmdpriv, pcmd); 462 463exit: 464 465 return res; 466} 467 468int rtw_joinbss_cmd23a(struct rtw_adapter *padapter, 469 struct wlan_network *pnetwork) 470{ 471 u8 *auth; 472 int res = _SUCCESS; 473 struct wlan_bssid_ex *psecnetwork; 474 struct cmd_obj *pcmd; 475 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 476 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 477 struct security_priv *psecuritypriv = &padapter->securitypriv; 478 struct registry_priv *pregistrypriv = &padapter->registrypriv; 479 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 480 enum nl80211_iftype ifmode; 481 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 482 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info; 483 484 ifmode = pnetwork->network.ifmode; 485 486 rtw_led_control(padapter, LED_CTL_START_TO_LINK); 487 488 if (pmlmepriv->assoc_ssid.ssid_len == 0) { 489 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, 490 ("+Join cmd: Any SSid\n")); 491 } else { 492 RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, 493 ("+Join cmd: SSid =[%s]\n", 494 pmlmepriv->assoc_ssid.ssid)); 495 } 496 497 pcmd = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC); 498 if (!pcmd) { 499 res = _FAIL; 500 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, 501 ("rtw_joinbss_cmd23a: memory allocate for cmd_obj " 502 "fail!!!\n")); 503 goto exit; 504 } 505 506 /* for hidden ap to set fw_state here */ 507 if (!check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_ADHOC_STATE)) { 508 switch (ifmode) { 509 case NL80211_IFTYPE_ADHOC: 510 set_fwstate(pmlmepriv, WIFI_ADHOC_STATE); 511 break; 512 case NL80211_IFTYPE_P2P_CLIENT: 513 case NL80211_IFTYPE_STATION: 514 set_fwstate(pmlmepriv, WIFI_STATION_STATE); 515 break; 516 default: 517 break; 518 } 519 } 520 521 psecnetwork = &psecuritypriv->sec_bss; 522 if (!psecnetwork) { 523 if (pcmd) 524 kfree(pcmd); 525 526 res = _FAIL; 527 528 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, 529 ("rtw_joinbss_cmd23a :psecnetwork == NULL!!!\n")); 530 531 goto exit; 532 } 533 534 memset(psecnetwork, 0, sizeof(struct wlan_bssid_ex)); 535 536 memcpy(psecnetwork, &pnetwork->network, 537 get_wlan_bssid_ex_sz(&pnetwork->network)); 538 539 auth = &psecuritypriv->authenticator_ie[0]; 540 psecuritypriv->authenticator_ie[0] = 541 (unsigned char)psecnetwork->IELength; 542 543 if ((psecnetwork->IELength-12) < (256-1)) { 544 memcpy(&psecuritypriv->authenticator_ie[1], 545 &psecnetwork->IEs[12], psecnetwork->IELength - 12); 546 } else { 547 memcpy(&psecuritypriv->authenticator_ie[1], 548 &psecnetwork->IEs[12], 256 - 1); 549 } 550 551 psecnetwork->IELength = 0; 552 /* Added by Albert 2009/02/18 */ 553 /* If the the driver wants to use the bssid to create the 554 * connection. If not, we have to copy the connecting AP's 555 * MAC address to it so that the driver just has the bssid 556 * information for PMKIDList searching. */ 557 558 if (pmlmepriv->assoc_by_bssid == false) 559 ether_addr_copy(&pmlmepriv->assoc_bssid[0], 560 &pnetwork->network.MacAddress[0]); 561 562 psecnetwork->IELength = 563 rtw_restruct_sec_ie23a(padapter, &pnetwork->network.IEs[0], 564 &psecnetwork->IEs[0], 565 pnetwork->network.IELength); 566 567 pmlmepriv->qos_option = 0; 568 569 if (pregistrypriv->wmm_enable) { 570 u32 tmp_len; 571 572 tmp_len = rtw_restruct_wmm_ie23a(padapter, 573 &pnetwork->network.IEs[0], 574 &psecnetwork->IEs[0], 575 pnetwork->network.IELength, 576 psecnetwork->IELength); 577 578 if (psecnetwork->IELength != tmp_len) { 579 psecnetwork->IELength = tmp_len; 580 /* There is WMM IE in this corresp. beacon */ 581 pmlmepriv->qos_option = 1; 582 } else { 583 /* There is no WMM IE in this corresp. beacon */ 584 pmlmepriv->qos_option = 0; 585 } 586 } 587 588 phtpriv->ht_option = false; 589 if (pregistrypriv->ht_enable) { 590 u32 algo = padapter->securitypriv.dot11PrivacyAlgrthm; 591 /* Added by Albert 2010/06/23 */ 592 /* For the WEP mode, we will use the bg mode to do 593 the connection to avoid some IOT issue. */ 594 /* Especially for Realtek 8192u SoftAP. */ 595 if (algo != WLAN_CIPHER_SUITE_WEP40 && 596 algo != WLAN_CIPHER_SUITE_WEP104 && 597 algo != WLAN_CIPHER_SUITE_TKIP) { 598 /* rtw_restructure_ht_ie23a */ 599 rtw_restructure_ht_ie23a(padapter, 600 &pnetwork->network.IEs[0], 601 &psecnetwork->IEs[0], 602 pnetwork->network.IELength, 603 &psecnetwork->IELength); 604 } 605 } 606 607 pmlmeinfo->assoc_AP_vendor = 608 check_assoc_AP23a(pnetwork->network.IEs, 609 pnetwork->network.IELength); 610 611 if (pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_TENDA) 612 padapter->pwrctrlpriv.smart_ps = 0; 613 else 614 padapter->pwrctrlpriv.smart_ps = 615 padapter->registrypriv.smart_ps; 616 617 DBG_8723A("%s: smart_ps =%d\n", __func__, 618 padapter->pwrctrlpriv.smart_ps); 619 620 /* get cmdsz before endian conversion */ 621 pcmd->cmdsz = get_wlan_bssid_ex_sz(psecnetwork); 622 623 pcmd->cmdcode = _JoinBss_CMD_;/* GEN_CMD_CODE(_JoinBss) */ 624 pcmd->parmbuf = (unsigned char *)psecnetwork; 625 pcmd->rsp = NULL; 626 pcmd->rspsz = 0; 627 628 res = rtw_enqueue_cmd23a(pcmdpriv, pcmd); 629exit: 630 631 return res; 632} 633 634int rtw_disassoc_cmd23a(struct rtw_adapter*padapter, u32 deauth_timeout_ms, 635 bool enqueue) 636{ 637 struct cmd_obj *cmdobj = NULL; 638 struct disconnect_parm *param = NULL; 639 struct cmd_priv *cmdpriv = &padapter->cmdpriv; 640 int res = _SUCCESS; 641 642 RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, 643 ("+rtw_disassoc_cmd23a\n")); 644 645 /* prepare cmd parameter */ 646 param = kzalloc(sizeof(*param), GFP_ATOMIC); 647 if (param == NULL) { 648 res = _FAIL; 649 goto exit; 650 } 651 param->deauth_timeout_ms = deauth_timeout_ms; 652 653 if (enqueue) { 654 /* need enqueue, prepare cmd_obj and enqueue */ 655 cmdobj = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC); 656 if (!cmdobj) { 657 res = _FAIL; 658 kfree(param); 659 goto exit; 660 } 661 init_h2fwcmd_w_parm_no_rsp(cmdobj, param, _DisConnect_CMD_); 662 res = rtw_enqueue_cmd23a(cmdpriv, cmdobj); 663 } else { 664 /* no need to enqueue, do the cmd hdl directly and 665 free cmd parameter */ 666 if (H2C_SUCCESS != disconnect_hdl23a(padapter, (u8 *)param)) 667 res = _FAIL; 668 kfree(param); 669 } 670 671exit: 672 return res; 673} 674 675int rtw_setopmode_cmd23a(struct rtw_adapter *padapter, 676 enum nl80211_iftype ifmode) 677{ 678 struct cmd_obj *ph2c; 679 struct setopmode_parm *psetop; 680 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 681 int res = _SUCCESS; 682 683 ph2c = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL); 684 if (!ph2c) { 685 res = false; 686 goto exit; 687 } 688 psetop = kzalloc(sizeof(struct setopmode_parm), GFP_KERNEL); 689 690 if (!psetop) { 691 kfree(ph2c); 692 res = false; 693 goto exit; 694 } 695 696 init_h2fwcmd_w_parm_no_rsp(ph2c, psetop, _SetOpMode_CMD_); 697 psetop->mode = ifmode; 698 699 res = rtw_enqueue_cmd23a(pcmdpriv, ph2c); 700exit: 701 return res; 702} 703 704int rtw_setstakey_cmd23a(struct rtw_adapter *padapter, u8 *psta, u8 unicast_key) 705{ 706 struct cmd_obj *ph2c; 707 struct set_stakey_parm *psetstakey_para; 708 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 709 struct set_stakey_rsp *psetstakey_rsp = NULL; 710 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 711 struct security_priv *psecuritypriv = &padapter->securitypriv; 712 struct sta_info *sta = (struct sta_info*)psta; 713 int res = _SUCCESS; 714 715 ph2c = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL); 716 if (!ph2c) { 717 res = _FAIL; 718 goto exit; 719 } 720 721 psetstakey_para = kzalloc(sizeof(struct set_stakey_parm), GFP_KERNEL); 722 if (!psetstakey_para) { 723 kfree(ph2c); 724 res = _FAIL; 725 goto exit; 726 } 727 728 psetstakey_rsp = kzalloc(sizeof(struct set_stakey_rsp), GFP_KERNEL); 729 if (!psetstakey_rsp) { 730 kfree(ph2c); 731 kfree(psetstakey_para); 732 res = _FAIL; 733 goto exit; 734 } 735 736 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_); 737 ph2c->rsp = (u8 *) psetstakey_rsp; 738 ph2c->rspsz = sizeof(struct set_stakey_rsp); 739 740 ether_addr_copy(psetstakey_para->addr, sta->hwaddr); 741 742 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) { 743 psetstakey_para->algorithm = 744 (unsigned char)psecuritypriv->dot11PrivacyAlgrthm; 745 } else { 746 GET_ENCRY_ALGO(psecuritypriv, sta, psetstakey_para->algorithm, 747 false); 748 } 749 750 if (unicast_key == true) { 751 memcpy(&psetstakey_para->key, &sta->dot118021x_UncstKey, 16); 752 } else { 753 int idx = psecuritypriv->dot118021XGrpKeyid; 754 memcpy(&psetstakey_para->key, 755 &psecuritypriv->dot118021XGrpKey[idx].skey, 16); 756 } 757 758 /* jeff: set this becasue at least sw key is ready */ 759 padapter->securitypriv.busetkipkey = 1; 760 761 res = rtw_enqueue_cmd23a(pcmdpriv, ph2c); 762 763exit: 764 765 return res; 766} 767 768int rtw_clearstakey_cmd23a(struct rtw_adapter *padapter, u8 *psta, u8 entry, 769 u8 enqueue) 770{ 771 struct cmd_obj *ph2c; 772 struct set_stakey_parm *psetstakey_para; 773 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 774 struct set_stakey_rsp *psetstakey_rsp = NULL; 775 struct sta_info *sta = (struct sta_info *)psta; 776 int res = _SUCCESS; 777 778 if (!enqueue) { 779 clear_cam_entry23a(padapter, entry); 780 } else { 781 ph2c = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL); 782 if (!ph2c) { 783 res = _FAIL; 784 goto exit; 785 } 786 787 psetstakey_para = kzalloc(sizeof(struct set_stakey_parm), 788 GFP_KERNEL); 789 if (!psetstakey_para) { 790 kfree(ph2c); 791 res = _FAIL; 792 goto exit; 793 } 794 795 psetstakey_rsp = kzalloc(sizeof(struct set_stakey_rsp), 796 GFP_KERNEL); 797 if (!psetstakey_rsp) { 798 kfree(ph2c); 799 kfree(psetstakey_para); 800 res = _FAIL; 801 goto exit; 802 } 803 804 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, 805 _SetStaKey_CMD_); 806 ph2c->rsp = (u8 *) psetstakey_rsp; 807 ph2c->rspsz = sizeof(struct set_stakey_rsp); 808 809 ether_addr_copy(psetstakey_para->addr, sta->hwaddr); 810 811 psetstakey_para->algorithm = 0; 812 813 psetstakey_para->id = entry; 814 815 res = rtw_enqueue_cmd23a(pcmdpriv, ph2c); 816 } 817exit: 818 return res; 819} 820 821int rtw_addbareq_cmd23a(struct rtw_adapter*padapter, u8 tid, u8 *addr) 822{ 823 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 824 struct cmd_obj *ph2c; 825 struct addBaReq_parm *paddbareq_parm; 826 int res = _SUCCESS; 827 828 if (tid >= MAXTID) { 829 res = _FAIL; 830 goto exit; 831 } 832 833 ph2c = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC); 834 if (!ph2c) { 835 res = _FAIL; 836 goto exit; 837 } 838 839 paddbareq_parm = kzalloc(sizeof(struct addBaReq_parm), GFP_ATOMIC); 840 if (!paddbareq_parm) { 841 kfree(ph2c); 842 res = _FAIL; 843 goto exit; 844 } 845 846 paddbareq_parm->tid = tid; 847 ether_addr_copy(paddbareq_parm->addr, addr); 848 849 init_h2fwcmd_w_parm_no_rsp(ph2c, paddbareq_parm, 850 GEN_CMD_CODE(_AddBAReq)); 851 852 res = rtw_enqueue_cmd23a(pcmdpriv, ph2c); 853exit: 854 return res; 855} 856 857int rtw_dynamic_chk_wk_cmd23a(struct rtw_adapter*padapter) 858{ 859 struct cmd_obj *ph2c; 860 struct drvextra_cmd_parm *pdrvextra_cmd_parm; 861 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 862 int res = _SUCCESS; 863 864 ph2c = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC); 865 if (!ph2c) { 866 res = _FAIL; 867 goto exit; 868 } 869 870 pdrvextra_cmd_parm = kzalloc(sizeof(*pdrvextra_cmd_parm), GFP_ATOMIC); 871 if (!pdrvextra_cmd_parm) { 872 kfree(ph2c); 873 res = _FAIL; 874 goto exit; 875 } 876 877 pdrvextra_cmd_parm->ec_id = DYNAMIC_CHK_WK_CID; 878 pdrvextra_cmd_parm->type_size = 0; 879 pdrvextra_cmd_parm->pbuf = (u8 *)padapter; 880 881 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, 882 GEN_CMD_CODE(_Set_Drv_Extra)); 883 884 res = rtw_enqueue_cmd23a(pcmdpriv, ph2c); 885exit: 886 887 return res; 888} 889 890/* 891 * This is only ever called from on_action_spct23a_ch_switch () which isn't 892 * called from anywhere itself 893 */ 894int rtw_set_ch_cmd23a(struct rtw_adapter*padapter, u8 ch, u8 bw, u8 ch_offset, 895 u8 enqueue) 896{ 897 struct cmd_obj *pcmdobj; 898 struct set_ch_parm *set_ch_parm; 899 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 900 int res = _SUCCESS; 901 902 DBG_8723A("%s(%s): ch:%u, bw:%u, ch_offset:%u\n", __func__, 903 padapter->pnetdev->name, ch, bw, ch_offset); 904 905 /* check input parameter */ 906 907 /* prepare cmd parameter */ 908 set_ch_parm = kzalloc(sizeof(*set_ch_parm), GFP_KERNEL); 909 if (!set_ch_parm) { 910 res = _FAIL; 911 goto exit; 912 } 913 set_ch_parm->ch = ch; 914 set_ch_parm->bw = bw; 915 set_ch_parm->ch_offset = ch_offset; 916 917 if (enqueue) { 918 /* need enqueue, prepare cmd_obj and enqueue */ 919 pcmdobj = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL); 920 if (!pcmdobj) { 921 kfree(set_ch_parm); 922 res = _FAIL; 923 goto exit; 924 } 925 926 init_h2fwcmd_w_parm_no_rsp(pcmdobj, set_ch_parm, 927 GEN_CMD_CODE(_SetChannel)); 928 res = rtw_enqueue_cmd23a(pcmdpriv, pcmdobj); 929 } else { 930 /* no need to enqueue, do the cmd hdl directly and 931 free cmd parameter */ 932 if (H2C_SUCCESS != set_ch_hdl23a(padapter, (u8 *)set_ch_parm)) 933 res = _FAIL; 934 935 kfree(set_ch_parm); 936 } 937 938 /* do something based on res... */ 939exit: 940 941 DBG_8723A("%s(%s): res:%u\n", __func__, padapter->pnetdev->name, res); 942 943 return res; 944} 945 946static void traffic_status_watchdog(struct rtw_adapter *padapter) 947{ 948 u8 bEnterPS; 949 u8 bBusyTraffic = false, bTxBusyTraffic = false, bRxBusyTraffic = false; 950 u8 bHigherBusyTraffic = false, bHigherBusyRxTraffic = false; 951 u8 bHigherBusyTxTraffic = false; 952 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 953#ifndef CONFIG_8723AU_BT_COEXIST 954 int BusyThreshold = 100; 955#endif 956 /* */ 957 /* Determine if our traffic is busy now */ 958 /* */ 959 if (check_fwstate(pmlmepriv, _FW_LINKED)) { 960#ifdef CONFIG_8723AU_BT_COEXIST 961 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > 50 || 962 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod > 50) 963#else /* !CONFIG_8723AU_BT_COEXIST */ 964 /* if we raise bBusyTraffic in last watchdog, using 965 lower threshold. */ 966 if (pmlmepriv->LinkDetectInfo.bBusyTraffic) 967 BusyThreshold = 75; 968 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > BusyThreshold || 969 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod > BusyThreshold) 970#endif /* !CONFIG_8723AU_BT_COEXIST */ 971 { 972 bBusyTraffic = true; 973 974 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > 975 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod) 976 bRxBusyTraffic = true; 977 else 978 bTxBusyTraffic = true; 979 } 980 981 /* Higher Tx/Rx data. */ 982 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > 4000 || 983 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod > 4000) { 984 bHigherBusyTraffic = true; 985 986 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > 987 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod) 988 bHigherBusyRxTraffic = true; 989 else 990 bHigherBusyTxTraffic = true; 991 } 992 993 if (!rtl8723a_BT_coexist(padapter) || 994 !rtl8723a_BT_using_antenna_1(padapter)) { 995 /* check traffic for powersaving. */ 996 if (((pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod + 997 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod) > 8) || 998 pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod >2) 999 bEnterPS = false; 1000 else 1001 bEnterPS = true; 1002 1003 /* LeisurePS only work in infra mode. */ 1004 if (bEnterPS) 1005 LPS_Enter23a(padapter); 1006 else 1007 LPS_Leave23a(padapter); 1008 } 1009 } else 1010 LPS_Leave23a(padapter); 1011 1012 pmlmepriv->LinkDetectInfo.NumRxOkInPeriod = 0; 1013 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod = 0; 1014 pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod = 0; 1015 pmlmepriv->LinkDetectInfo.bBusyTraffic = bBusyTraffic; 1016 pmlmepriv->LinkDetectInfo.bTxBusyTraffic = bTxBusyTraffic; 1017 pmlmepriv->LinkDetectInfo.bRxBusyTraffic = bRxBusyTraffic; 1018 pmlmepriv->LinkDetectInfo.bHigherBusyTraffic = bHigherBusyTraffic; 1019 pmlmepriv->LinkDetectInfo.bHigherBusyRxTraffic = bHigherBusyRxTraffic; 1020 pmlmepriv->LinkDetectInfo.bHigherBusyTxTraffic = bHigherBusyTxTraffic; 1021} 1022 1023static void dynamic_chk_wk_hdl(struct rtw_adapter *padapter, u8 *pbuf, int sz) 1024{ 1025 struct mlme_priv *pmlmepriv; 1026 1027 padapter = (struct rtw_adapter *)pbuf; 1028 pmlmepriv = &padapter->mlmepriv; 1029 1030#ifdef CONFIG_8723AU_AP_MODE 1031 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) 1032 expire_timeout_chk23a(padapter); 1033#endif 1034 1035 rtl8723a_sreset_xmit_status_check(padapter); 1036 1037 linked_status_chk23a(padapter); 1038 traffic_status_watchdog(padapter); 1039 1040 rtl8723a_HalDmWatchDog(padapter); 1041 1042 /* */ 1043 /* BT-Coexist */ 1044 /* */ 1045 rtl8723a_BT_do_coexist(padapter); 1046} 1047 1048static void lps_ctrl_wk_hdl(struct rtw_adapter *padapter, u8 lps_ctrl_type) 1049{ 1050 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv; 1051 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1052 u8 mstatus; 1053 1054 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) || 1055 check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) 1056 return; 1057 1058 switch (lps_ctrl_type) 1059 { 1060 case LPS_CTRL_SCAN: 1061 rtl8723a_BT_wifiscan_notify(padapter, true); 1062 if (!rtl8723a_BT_using_antenna_1(padapter)) { 1063 if (check_fwstate(pmlmepriv, _FW_LINKED)) 1064 LPS_Leave23a(padapter); 1065 } 1066 break; 1067 case LPS_CTRL_JOINBSS: 1068 LPS_Leave23a(padapter); 1069 break; 1070 case LPS_CTRL_CONNECT: 1071 mstatus = 1;/* connect */ 1072 /* Reset LPS Setting */ 1073 padapter->pwrctrlpriv.LpsIdleCount = 0; 1074 rtl8723a_set_FwJoinBssReport_cmd(padapter, 1); 1075 rtl8723a_BT_mediastatus_notify(padapter, mstatus); 1076 break; 1077 case LPS_CTRL_DISCONNECT: 1078 mstatus = 0;/* disconnect */ 1079 rtl8723a_BT_mediastatus_notify(padapter, mstatus); 1080 if (!rtl8723a_BT_using_antenna_1(padapter)) 1081 LPS_Leave23a(padapter); 1082 rtl8723a_set_FwJoinBssReport_cmd(padapter, 0); 1083 break; 1084 case LPS_CTRL_SPECIAL_PACKET: 1085 pwrpriv->DelayLPSLastTimeStamp = jiffies; 1086#ifdef CONFIG_8723AU_BT_COEXIST 1087 BT_SpecialPacketNotify(padapter); 1088 if (rtl8723a_BT_using_antenna_1(padapter) == false) 1089#endif 1090 { 1091 LPS_Leave23a(padapter); 1092 } 1093 break; 1094 case LPS_CTRL_LEAVE: 1095#ifdef CONFIG_8723AU_BT_COEXIST 1096 BT_LpsLeave(padapter); 1097 if (rtl8723a_BT_using_antenna_1(padapter) == false) 1098#endif 1099 { 1100 LPS_Leave23a(padapter); 1101 } 1102 break; 1103 1104 default: 1105 break; 1106 } 1107} 1108 1109int rtw_lps_ctrl_wk_cmd23a(struct rtw_adapter *padapter, 1110 u8 lps_ctrl_type, u8 enqueue) 1111{ 1112 struct cmd_obj *ph2c; 1113 struct drvextra_cmd_parm *pdrvextra_cmd_parm; 1114 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1115 int res = _SUCCESS; 1116 1117 if (enqueue) { 1118 ph2c = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC); 1119 if (!ph2c) { 1120 res = _FAIL; 1121 goto exit; 1122 } 1123 1124 pdrvextra_cmd_parm = kzalloc(sizeof(struct drvextra_cmd_parm), 1125 GFP_ATOMIC); 1126 if (!pdrvextra_cmd_parm) { 1127 kfree(ph2c); 1128 res = _FAIL; 1129 goto exit; 1130 } 1131 1132 pdrvextra_cmd_parm->ec_id = LPS_CTRL_WK_CID; 1133 pdrvextra_cmd_parm->type_size = lps_ctrl_type; 1134 pdrvextra_cmd_parm->pbuf = NULL; 1135 1136 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, 1137 GEN_CMD_CODE(_Set_Drv_Extra)); 1138 1139 res = rtw_enqueue_cmd23a(pcmdpriv, ph2c); 1140 } else 1141 lps_ctrl_wk_hdl(padapter, lps_ctrl_type); 1142exit: 1143 1144 return res; 1145} 1146 1147static void power_saving_wk_hdl(struct rtw_adapter *padapter, u8 *pbuf, int sz) 1148{ 1149 rtw_ps_processor23a(padapter); 1150} 1151 1152int rtw_ps_cmd23a(struct rtw_adapter*padapter) 1153{ 1154 struct cmd_obj *ppscmd; 1155 struct drvextra_cmd_parm *pdrvextra_cmd_parm; 1156 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1157 int res = _SUCCESS; 1158 1159 ppscmd = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC); 1160 if (!ppscmd) { 1161 res = _FAIL; 1162 goto exit; 1163 } 1164 1165 pdrvextra_cmd_parm = kzalloc(sizeof(struct drvextra_cmd_parm), 1166 GFP_ATOMIC); 1167 if (!pdrvextra_cmd_parm) { 1168 kfree(ppscmd); 1169 res = _FAIL; 1170 goto exit; 1171 } 1172 1173 pdrvextra_cmd_parm->ec_id = POWER_SAVING_CTRL_WK_CID; 1174 pdrvextra_cmd_parm->pbuf = NULL; 1175 init_h2fwcmd_w_parm_no_rsp(ppscmd, pdrvextra_cmd_parm, 1176 GEN_CMD_CODE(_Set_Drv_Extra)); 1177 1178 res = rtw_enqueue_cmd23a(pcmdpriv, ppscmd); 1179exit: 1180 1181 return res; 1182} 1183 1184#ifdef CONFIG_8723AU_AP_MODE 1185 1186static void rtw_chk_hi_queue_hdl(struct rtw_adapter *padapter) 1187{ 1188 int cnt = 0; 1189 struct sta_info *psta_bmc; 1190 struct sta_priv *pstapriv = &padapter->stapriv; 1191 1192 psta_bmc = rtw_get_bcmc_stainfo23a(padapter); 1193 if (!psta_bmc) 1194 return; 1195 1196 if (psta_bmc->sleepq_len == 0) { 1197 bool val; 1198 1199 val = rtl8723a_chk_hi_queue_empty(padapter); 1200 1201 while (val == false) { 1202 msleep(100); 1203 1204 cnt++; 1205 1206 if (cnt>10) 1207 break; 1208 1209 val = rtl8723a_chk_hi_queue_empty(padapter); 1210 } 1211 1212 if (cnt <= 10) { 1213 pstapriv->tim_bitmap &= ~BIT(0); 1214 pstapriv->sta_dz_bitmap &= ~BIT(0); 1215 1216 update_beacon23a(padapter, WLAN_EID_TIM, NULL, false); 1217 } else /* re check again */ 1218 rtw_chk_hi_queue_cmd23a(padapter); 1219 } 1220} 1221 1222int rtw_chk_hi_queue_cmd23a(struct rtw_adapter*padapter) 1223{ 1224 struct cmd_obj *ph2c; 1225 struct drvextra_cmd_parm *pdrvextra_cmd_parm; 1226 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1227 int res = _SUCCESS; 1228 1229 ph2c = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC); 1230 if (!ph2c) { 1231 res = _FAIL; 1232 goto exit; 1233 } 1234 1235 pdrvextra_cmd_parm = kzalloc(sizeof(struct drvextra_cmd_parm), 1236 GFP_ATOMIC); 1237 if (!pdrvextra_cmd_parm) { 1238 kfree(ph2c); 1239 res = _FAIL; 1240 goto exit; 1241 } 1242 1243 pdrvextra_cmd_parm->ec_id = CHECK_HIQ_WK_CID; 1244 pdrvextra_cmd_parm->type_size = 0; 1245 pdrvextra_cmd_parm->pbuf = NULL; 1246 1247 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, 1248 GEN_CMD_CODE(_Set_Drv_Extra)); 1249 1250 res = rtw_enqueue_cmd23a(pcmdpriv, ph2c); 1251exit: 1252 1253 return res; 1254} 1255#endif 1256 1257int rtw_c2h_wk_cmd23a(struct rtw_adapter *padapter, u8 *c2h_evt) 1258{ 1259 struct cmd_obj *ph2c; 1260 struct drvextra_cmd_parm *pdrvextra_cmd_parm; 1261 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1262 int res = _SUCCESS; 1263 1264 ph2c = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC); 1265 if (!ph2c) { 1266 res = _FAIL; 1267 goto exit; 1268 } 1269 1270 pdrvextra_cmd_parm = kzalloc(sizeof(struct drvextra_cmd_parm), 1271 GFP_ATOMIC); 1272 if (!pdrvextra_cmd_parm) { 1273 kfree(ph2c); 1274 res = _FAIL; 1275 goto exit; 1276 } 1277 1278 pdrvextra_cmd_parm->ec_id = C2H_WK_CID; 1279 pdrvextra_cmd_parm->type_size = c2h_evt?16:0; 1280 pdrvextra_cmd_parm->pbuf = c2h_evt; 1281 1282 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, 1283 GEN_CMD_CODE(_Set_Drv_Extra)); 1284 1285 res = rtw_enqueue_cmd23a(pcmdpriv, ph2c); 1286 1287exit: 1288 1289 return res; 1290} 1291 1292static int c2h_evt_hdl(struct rtw_adapter *adapter, struct c2h_evt_hdr *c2h_evt) 1293{ 1294 int ret = _FAIL; 1295 u8 buf[16]; 1296 1297 if (!c2h_evt) { 1298 /* No c2h event in cmd_obj, read c2h event before handling*/ 1299 if (c2h_evt_read23a(adapter, buf) == _SUCCESS) { 1300 c2h_evt = (struct c2h_evt_hdr *)buf; 1301 1302 ret = c2h_handler_8723a(adapter, c2h_evt); 1303 } 1304 } else 1305 ret = c2h_handler_8723a(adapter, c2h_evt); 1306 1307 return ret; 1308} 1309 1310static void rtw_irq_work(struct work_struct *work) 1311{ 1312 struct evt_priv *evtpriv; 1313 struct rtw_adapter *adapter; 1314 1315 evtpriv = container_of(work, struct evt_priv, irq_wk); 1316 adapter = container_of(evtpriv, struct rtw_adapter, evtpriv); 1317 1318 c2h_evt_clear23a(adapter); 1319} 1320 1321void rtw_evt_work(struct work_struct *work) 1322{ 1323 struct evt_work *ework; 1324 struct rtw_adapter *adapter; 1325 1326 ework = container_of(work, struct evt_work, work); 1327 adapter = ework->adapter; 1328 1329 c2h_evt_clear23a(adapter); 1330 1331 if (!c2h_evt_exist(&ework->u.c2h_evt)) { 1332 kfree(ework); 1333 return; 1334 } 1335 1336 if (c2h_id_filter_ccx_8723a(ework->u.c2h_evt.id) == true) { 1337 /* Handle CCX report here */ 1338 c2h_handler_8723a(adapter, &ework->u.c2h_evt); 1339 kfree(ework); 1340 } else { 1341 /* 1342 * Enqueue into cmd_thread for others. 1343 * ework will be turned into a c2h_evt and freed once it 1344 * has been consumed. 1345 */ 1346 rtw_c2h_wk_cmd23a(adapter, (u8 *)&ework->u.c2h_evt); 1347 } 1348} 1349 1350int rtw_drvextra_cmd_hdl23a(struct rtw_adapter *padapter, const u8 *pbuf) 1351{ 1352 const struct drvextra_cmd_parm *pdrvextra_cmd; 1353 1354 if (!pbuf) 1355 return H2C_PARAMETERS_ERROR; 1356 1357 pdrvextra_cmd = (struct drvextra_cmd_parm *)pbuf; 1358 1359 switch (pdrvextra_cmd->ec_id) 1360 { 1361 case DYNAMIC_CHK_WK_CID: 1362 dynamic_chk_wk_hdl(padapter, pdrvextra_cmd->pbuf, 1363 pdrvextra_cmd->type_size); 1364 break; 1365 case POWER_SAVING_CTRL_WK_CID: 1366 power_saving_wk_hdl(padapter, pdrvextra_cmd->pbuf, 1367 pdrvextra_cmd->type_size); 1368 break; 1369 case LPS_CTRL_WK_CID: 1370 lps_ctrl_wk_hdl(padapter, (u8)pdrvextra_cmd->type_size); 1371 break; 1372#ifdef CONFIG_8723AU_AP_MODE 1373 case CHECK_HIQ_WK_CID: 1374 rtw_chk_hi_queue_hdl(padapter); 1375 break; 1376#endif /* CONFIG_8723AU_AP_MODE */ 1377 case C2H_WK_CID: 1378 c2h_evt_hdl(padapter, 1379 (struct c2h_evt_hdr *)pdrvextra_cmd->pbuf); 1380 break; 1381 1382 default: 1383 break; 1384 } 1385 1386 if (pdrvextra_cmd->pbuf && (pdrvextra_cmd->type_size > 0)) { 1387 kfree(pdrvextra_cmd->pbuf); 1388 /* 1389 * No need to set pdrvextra_cmd->pbuf = NULL as we were 1390 * operating on a copy of the original pcmd->parmbuf 1391 * created in rtw_cmd_work(). 1392 */ 1393 } 1394 1395 return H2C_SUCCESS; 1396} 1397 1398void rtw_survey_cmd_callback23a(struct rtw_adapter *padapter, 1399 struct cmd_obj *pcmd) 1400{ 1401 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1402 1403 if (pcmd->res == H2C_DROPPED) { 1404 /* TODO: cancel timer and do timeout handler directly... */ 1405 /* need to make timeout handlerOS independent */ 1406 mod_timer(&pmlmepriv->scan_to_timer, 1407 jiffies + msecs_to_jiffies(1)); 1408 } else if (pcmd->res != H2C_SUCCESS) { 1409 mod_timer(&pmlmepriv->scan_to_timer, 1410 jiffies + msecs_to_jiffies(1)); 1411 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, 1412 ("\n ********Error: MgntActrtw_set_802_11_bssid23a_" 1413 "LIST_SCAN Fail ************\n\n.")); 1414 } 1415 1416 /* free cmd */ 1417 rtw_free_cmd_obj23a(pcmd); 1418} 1419 1420void rtw_disassoc_cmd23a_callback(struct rtw_adapter *padapter, 1421 struct cmd_obj *pcmd) 1422{ 1423 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1424 1425 if (pcmd->res != H2C_SUCCESS) { 1426 spin_lock_bh(&pmlmepriv->lock); 1427 set_fwstate(pmlmepriv, _FW_LINKED); 1428 spin_unlock_bh(&pmlmepriv->lock); 1429 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, 1430 ("\n ***Error: disconnect_cmd_callback Fail ***\n.")); 1431 return; 1432 } 1433 1434 /* free cmd */ 1435 rtw_free_cmd_obj23a(pcmd); 1436} 1437 1438void rtw_joinbss_cmd23a_callback(struct rtw_adapter *padapter, 1439 struct cmd_obj *pcmd) 1440{ 1441 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1442 1443 if (pcmd->res == H2C_DROPPED) { 1444 /* TODO: cancel timer and do timeout handler directly... */ 1445 /* need to make timeout handlerOS independent */ 1446 mod_timer(&pmlmepriv->assoc_timer, 1447 jiffies + msecs_to_jiffies(1)); 1448 } else if (pcmd->res != H2C_SUCCESS) { 1449 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, 1450 ("********Error:rtw_select_and_join_from_scanned_" 1451 "queue Wait Sema Fail ************\n")); 1452 mod_timer(&pmlmepriv->assoc_timer, 1453 jiffies + msecs_to_jiffies(1)); 1454 } 1455 1456 rtw_free_cmd_obj23a(pcmd); 1457} 1458 1459void rtw_createbss_cmd23a_callback(struct rtw_adapter *padapter, 1460 struct cmd_obj *pcmd) 1461{ 1462 struct sta_info *psta; 1463 struct wlan_network *pwlan; 1464 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1465 struct wlan_bssid_ex *pnetwork = (struct wlan_bssid_ex *)pcmd->parmbuf; 1466 struct wlan_network *tgt_network = &pmlmepriv->cur_network; 1467 1468 if (pcmd->res != H2C_SUCCESS) { 1469 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, 1470 ("\n ********Error: rtw_createbss_cmd23a_callback " 1471 "Fail ************\n\n.")); 1472 mod_timer(&pmlmepriv->assoc_timer, 1473 jiffies + msecs_to_jiffies(1)); 1474 } 1475 1476 del_timer_sync(&pmlmepriv->assoc_timer); 1477 1478 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) { 1479 psta = rtw_get_stainfo23a(&padapter->stapriv, 1480 pnetwork->MacAddress); 1481 if (!psta) { 1482 psta = rtw_alloc_stainfo23a(&padapter->stapriv, 1483 pnetwork->MacAddress, 1484 GFP_KERNEL); 1485 if (!psta) { 1486 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, 1487 ("\nCan't alloc sta_info when " 1488 "createbss_cmd_callback\n")); 1489 goto createbss_cmd_fail ; 1490 } 1491 } 1492 1493 spin_lock_bh(&pmlmepriv->lock); 1494 rtw_indicate_connect23a(padapter); 1495 spin_unlock_bh(&pmlmepriv->lock); 1496 } else { 1497 pwlan = rtw_alloc_network(pmlmepriv, GFP_KERNEL); 1498 spin_lock_bh(&pmlmepriv->scanned_queue.lock); 1499 if (!pwlan) { 1500 pwlan = rtw_get_oldest_wlan_network23a(&pmlmepriv->scanned_queue); 1501 if (!pwlan) { 1502 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, 1503 ("\n Error: can't get pwlan in " 1504 "rtw23a_joinbss_event_cb\n")); 1505 spin_unlock_bh(&pmlmepriv->scanned_queue.lock); 1506 goto createbss_cmd_fail; 1507 } 1508 pwlan->last_scanned = jiffies; 1509 } else { 1510 list_add_tail(&pwlan->list, 1511 &pmlmepriv->scanned_queue.queue); 1512 } 1513 1514 pnetwork->Length = get_wlan_bssid_ex_sz(pnetwork); 1515 memcpy(&pwlan->network, pnetwork, pnetwork->Length); 1516 /* pwlan->fixed = true; */ 1517 1518 /* list_add_tail(&pwlan->list, 1519 &pmlmepriv->scanned_queue.queue); */ 1520 1521 /* copy pdev_network information to 1522 pmlmepriv->cur_network */ 1523 memcpy(&tgt_network->network, pnetwork, 1524 get_wlan_bssid_ex_sz(pnetwork)); 1525 1526 /* reset DSConfig */ 1527 1528 clr_fwstate(pmlmepriv, _FW_UNDER_LINKING); 1529 1530 spin_unlock_bh(&pmlmepriv->scanned_queue.lock); 1531 /* we will set _FW_LINKED when there is one more sat to 1532 join us (rtw_stassoc_event_callback23a) */ 1533 } 1534 1535createbss_cmd_fail: 1536 1537 rtw_free_cmd_obj23a(pcmd); 1538} 1539 1540void rtw_setstaKey_cmdrsp_callback23a(struct rtw_adapter *padapter, 1541 struct cmd_obj *pcmd) 1542{ 1543 struct sta_priv *pstapriv; 1544 struct set_stakey_rsp *psetstakey_rsp; 1545 struct sta_info *psta; 1546 1547 pstapriv = &padapter->stapriv; 1548 psetstakey_rsp = (struct set_stakey_rsp*) (pcmd->rsp); 1549 psta = rtw_get_stainfo23a(pstapriv, psetstakey_rsp->addr); 1550 1551 if (!psta) { 1552 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, 1553 ("\nERROR: rtw_setstaKey_cmdrsp_callback23a => " 1554 "can't get sta_info\n\n")); 1555 goto exit; 1556 } 1557 1558exit: 1559 1560 rtw_free_cmd_obj23a(pcmd); 1561} 1562 1563void rtw_setassocsta_cmdrsp_callback23a(struct rtw_adapter *padapter, 1564 struct cmd_obj *pcmd) 1565{ 1566 struct sta_priv *pstapriv = &padapter->stapriv; 1567 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1568 struct set_assocsta_parm* passocsta_parm; 1569 struct set_assocsta_rsp* passocsta_rsp; 1570 struct sta_info *psta; 1571 1572 passocsta_parm = (struct set_assocsta_parm *)(pcmd->parmbuf); 1573 passocsta_rsp = (struct set_assocsta_rsp*) (pcmd->rsp); 1574 psta = rtw_get_stainfo23a(pstapriv, passocsta_parm->addr); 1575 1576 if (psta == NULL) { 1577 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, 1578 ("\nERROR: setassocsta_cmdrsp_callbac => can't " 1579 "get sta_info\n\n")); 1580 goto exit; 1581 } 1582 1583 psta->aid = psta->mac_id = passocsta_rsp->cam_id; 1584 1585 spin_lock_bh(&pmlmepriv->lock); 1586 1587 if (check_fwstate(pmlmepriv, WIFI_MP_STATE) && 1588 check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) 1589 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 1590 1591 set_fwstate(pmlmepriv, _FW_LINKED); 1592 spin_unlock_bh(&pmlmepriv->lock); 1593 1594exit: 1595 rtw_free_cmd_obj23a(pcmd); 1596} 1597