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