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