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