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