1 // SPDX-License-Identifier: GPL-2.0 2 /****************************************************************************** 3 * 4 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved. 5 * 6 ******************************************************************************/ 7 #define _RTW_CMD_C_ 8 9 #include <drv_types.h> 10 #include <rtw_debug.h> 11 #include <hal_btcoex.h> 12 #include <linux/jiffies.h> 13 14 static struct _cmd_callback rtw_cmd_callback[] = { 15 {GEN_CMD_CODE(_Read_MACREG), NULL}, /*0*/ 16 {GEN_CMD_CODE(_Write_MACREG), NULL}, 17 {GEN_CMD_CODE(_Read_BBREG), &rtw_getbbrfreg_cmdrsp_callback}, 18 {GEN_CMD_CODE(_Write_BBREG), NULL}, 19 {GEN_CMD_CODE(_Read_RFREG), &rtw_getbbrfreg_cmdrsp_callback}, 20 {GEN_CMD_CODE(_Write_RFREG), NULL}, /*5*/ 21 {GEN_CMD_CODE(_Read_EEPROM), NULL}, 22 {GEN_CMD_CODE(_Write_EEPROM), NULL}, 23 {GEN_CMD_CODE(_Read_EFUSE), NULL}, 24 {GEN_CMD_CODE(_Write_EFUSE), NULL}, 25 26 {GEN_CMD_CODE(_Read_CAM), NULL}, /*10*/ 27 {GEN_CMD_CODE(_Write_CAM), NULL}, 28 {GEN_CMD_CODE(_setBCNITV), NULL}, 29 {GEN_CMD_CODE(_setMBIDCFG), NULL}, 30 {GEN_CMD_CODE(_JoinBss), &rtw_joinbss_cmd_callback}, /*14*/ 31 {GEN_CMD_CODE(_DisConnect), &rtw_disassoc_cmd_callback}, /*15*/ 32 {GEN_CMD_CODE(_CreateBss), &rtw_createbss_cmd_callback}, 33 {GEN_CMD_CODE(_SetOpMode), NULL}, 34 {GEN_CMD_CODE(_SiteSurvey), &rtw_survey_cmd_callback}, /*18*/ 35 {GEN_CMD_CODE(_SetAuth), NULL}, 36 37 {GEN_CMD_CODE(_SetKey), NULL}, /*20*/ 38 {GEN_CMD_CODE(_SetStaKey), &rtw_setstaKey_cmdrsp_callback}, 39 {GEN_CMD_CODE(_SetAssocSta), &rtw_setassocsta_cmdrsp_callback}, 40 {GEN_CMD_CODE(_DelAssocSta), NULL}, 41 {GEN_CMD_CODE(_SetStaPwrState), NULL}, 42 {GEN_CMD_CODE(_SetBasicRate), NULL}, /*25*/ 43 {GEN_CMD_CODE(_GetBasicRate), NULL}, 44 {GEN_CMD_CODE(_SetDataRate), NULL}, 45 {GEN_CMD_CODE(_GetDataRate), NULL}, 46 {GEN_CMD_CODE(_SetPhyInfo), NULL}, 47 48 {GEN_CMD_CODE(_GetPhyInfo), NULL}, /*30*/ 49 {GEN_CMD_CODE(_SetPhy), NULL}, 50 {GEN_CMD_CODE(_GetPhy), NULL}, 51 {GEN_CMD_CODE(_readRssi), NULL}, 52 {GEN_CMD_CODE(_readGain), NULL}, 53 {GEN_CMD_CODE(_SetAtim), NULL}, /*35*/ 54 {GEN_CMD_CODE(_SetPwrMode), NULL}, 55 {GEN_CMD_CODE(_JoinbssRpt), NULL}, 56 {GEN_CMD_CODE(_SetRaTable), NULL}, 57 {GEN_CMD_CODE(_GetRaTable), NULL}, 58 59 {GEN_CMD_CODE(_GetCCXReport), NULL}, /*40*/ 60 {GEN_CMD_CODE(_GetDTMReport), NULL}, 61 {GEN_CMD_CODE(_GetTXRateStatistics), NULL}, 62 {GEN_CMD_CODE(_SetUsbSuspend), NULL}, 63 {GEN_CMD_CODE(_SetH2cLbk), NULL}, 64 {GEN_CMD_CODE(_AddBAReq), NULL}, /*45*/ 65 {GEN_CMD_CODE(_SetChannel), NULL}, /*46*/ 66 {GEN_CMD_CODE(_SetTxPower), NULL}, 67 {GEN_CMD_CODE(_SwitchAntenna), NULL}, 68 {GEN_CMD_CODE(_SetCrystalCap), NULL}, 69 {GEN_CMD_CODE(_SetSingleCarrierTx), NULL}, /*50*/ 70 71 {GEN_CMD_CODE(_SetSingleToneTx), NULL}, /*51*/ 72 {GEN_CMD_CODE(_SetCarrierSuppressionTx), NULL}, 73 {GEN_CMD_CODE(_SetContinuousTx), NULL}, 74 {GEN_CMD_CODE(_SwitchBandwidth), NULL}, /*54*/ 75 {GEN_CMD_CODE(_TX_Beacon), NULL},/*55*/ 76 77 {GEN_CMD_CODE(_Set_MLME_EVT), NULL},/*56*/ 78 {GEN_CMD_CODE(_Set_Drv_Extra), NULL},/*57*/ 79 {GEN_CMD_CODE(_Set_H2C_MSG), NULL},/*58*/ 80 {GEN_CMD_CODE(_SetChannelPlan), NULL},/*59*/ 81 {GEN_CMD_CODE(_LedBlink), NULL},/*60*/ 82 83 {GEN_CMD_CODE(_SetChannelSwitch), NULL},/*61*/ 84 {GEN_CMD_CODE(_TDLS), NULL},/*62*/ 85 {GEN_CMD_CODE(_ChkBMCSleepq), NULL}, /*63*/ 86 87 {GEN_CMD_CODE(_RunInThreadCMD), NULL},/*64*/ 88 }; 89 90 static struct cmd_hdl wlancmds[] = { 91 GEN_DRV_CMD_HANDLER(0, NULL) /*0*/ 92 GEN_DRV_CMD_HANDLER(0, NULL) 93 GEN_DRV_CMD_HANDLER(0, NULL) 94 GEN_DRV_CMD_HANDLER(0, NULL) 95 GEN_DRV_CMD_HANDLER(0, NULL) 96 GEN_DRV_CMD_HANDLER(0, NULL) 97 GEN_MLME_EXT_HANDLER(0, NULL) 98 GEN_MLME_EXT_HANDLER(0, NULL) 99 GEN_MLME_EXT_HANDLER(0, NULL) 100 GEN_MLME_EXT_HANDLER(0, NULL) 101 GEN_MLME_EXT_HANDLER(0, NULL) /*10*/ 102 GEN_MLME_EXT_HANDLER(0, NULL) 103 GEN_MLME_EXT_HANDLER(0, NULL) 104 GEN_MLME_EXT_HANDLER(0, NULL) 105 GEN_MLME_EXT_HANDLER(sizeof(struct joinbss_parm), join_cmd_hdl) /*14*/ 106 GEN_MLME_EXT_HANDLER(sizeof(struct disconnect_parm), disconnect_hdl) 107 GEN_MLME_EXT_HANDLER(sizeof(struct createbss_parm), createbss_hdl) 108 GEN_MLME_EXT_HANDLER(sizeof(struct setopmode_parm), setopmode_hdl) 109 GEN_MLME_EXT_HANDLER(sizeof(struct sitesurvey_parm), sitesurvey_cmd_hdl) /*18*/ 110 GEN_MLME_EXT_HANDLER(sizeof(struct setauth_parm), setauth_hdl) 111 GEN_MLME_EXT_HANDLER(sizeof(struct setkey_parm), setkey_hdl) /*20*/ 112 GEN_MLME_EXT_HANDLER(sizeof(struct set_stakey_parm), set_stakey_hdl) 113 GEN_MLME_EXT_HANDLER(sizeof(struct set_assocsta_parm), NULL) 114 GEN_MLME_EXT_HANDLER(sizeof(struct del_assocsta_parm), NULL) 115 GEN_MLME_EXT_HANDLER(sizeof(struct setstapwrstate_parm), NULL) 116 GEN_MLME_EXT_HANDLER(sizeof(struct setbasicrate_parm), NULL) 117 GEN_MLME_EXT_HANDLER(sizeof(struct getbasicrate_parm), NULL) 118 GEN_MLME_EXT_HANDLER(sizeof(struct setdatarate_parm), NULL) 119 GEN_MLME_EXT_HANDLER(sizeof(struct getdatarate_parm), NULL) 120 GEN_MLME_EXT_HANDLER(sizeof(struct setphyinfo_parm), NULL) 121 GEN_MLME_EXT_HANDLER(sizeof(struct getphyinfo_parm), NULL) /*30*/ 122 GEN_MLME_EXT_HANDLER(sizeof(struct setphy_parm), NULL) 123 GEN_MLME_EXT_HANDLER(sizeof(struct getphy_parm), NULL) 124 GEN_MLME_EXT_HANDLER(0, NULL) 125 GEN_MLME_EXT_HANDLER(0, NULL) 126 GEN_MLME_EXT_HANDLER(0, NULL) 127 GEN_MLME_EXT_HANDLER(0, NULL) 128 GEN_MLME_EXT_HANDLER(0, NULL) 129 GEN_MLME_EXT_HANDLER(0, NULL) 130 GEN_MLME_EXT_HANDLER(0, NULL) 131 GEN_MLME_EXT_HANDLER(0, NULL) /*40*/ 132 GEN_MLME_EXT_HANDLER(0, NULL) 133 GEN_MLME_EXT_HANDLER(0, NULL) 134 GEN_MLME_EXT_HANDLER(0, NULL) 135 GEN_MLME_EXT_HANDLER(0, NULL) 136 GEN_MLME_EXT_HANDLER(sizeof(struct addBaReq_parm), add_ba_hdl) 137 GEN_MLME_EXT_HANDLER(sizeof(struct set_ch_parm), set_ch_hdl) /* 46 */ 138 GEN_MLME_EXT_HANDLER(0, NULL) 139 GEN_MLME_EXT_HANDLER(0, NULL) 140 GEN_MLME_EXT_HANDLER(0, NULL) 141 GEN_MLME_EXT_HANDLER(0, NULL) /*50*/ 142 GEN_MLME_EXT_HANDLER(0, NULL) 143 GEN_MLME_EXT_HANDLER(0, NULL) 144 GEN_MLME_EXT_HANDLER(0, NULL) 145 GEN_MLME_EXT_HANDLER(0, NULL) 146 GEN_MLME_EXT_HANDLER(sizeof(struct Tx_Beacon_param), tx_beacon_hdl) /*55*/ 147 148 GEN_MLME_EXT_HANDLER(0, mlme_evt_hdl) /*56*/ 149 GEN_MLME_EXT_HANDLER(0, rtw_drvextra_cmd_hdl) /*57*/ 150 151 GEN_MLME_EXT_HANDLER(0, h2c_msg_hdl) /*58*/ 152 GEN_MLME_EXT_HANDLER(sizeof(struct SetChannelPlan_param), set_chplan_hdl) /*59*/ 153 GEN_MLME_EXT_HANDLER(sizeof(struct LedBlink_param), led_blink_hdl) /*60*/ 154 155 GEN_MLME_EXT_HANDLER(sizeof(struct SetChannelSwitch_param), set_csa_hdl) /*61*/ 156 GEN_MLME_EXT_HANDLER(sizeof(struct TDLSoption_param), tdls_hdl) /*62*/ 157 GEN_MLME_EXT_HANDLER(0, chk_bmc_sleepq_hdl) /*63*/ 158 GEN_MLME_EXT_HANDLER(sizeof(struct RunInThread_param), run_in_thread_hdl) /*63*/ 159 }; 160 161 /* 162 Caller and the rtw_cmd_thread can protect cmd_q by spin_lock. 163 No irqsave is necessary. 164 */ 165 166 int rtw_init_cmd_priv(struct cmd_priv *pcmdpriv) 167 { 168 int res = 0; 169 170 init_completion(&pcmdpriv->cmd_queue_comp); 171 init_completion(&pcmdpriv->terminate_cmdthread_comp); 172 173 _rtw_init_queue(&(pcmdpriv->cmd_queue)); 174 175 /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */ 176 177 pcmdpriv->cmd_seq = 1; 178 179 pcmdpriv->cmd_allocated_buf = rtw_zmalloc(MAX_CMDSZ + CMDBUFF_ALIGN_SZ); 180 181 if (!pcmdpriv->cmd_allocated_buf) { 182 res = -ENOMEM; 183 goto exit; 184 } 185 186 pcmdpriv->cmd_buf = pcmdpriv->cmd_allocated_buf + CMDBUFF_ALIGN_SZ - ((SIZE_PTR)(pcmdpriv->cmd_allocated_buf) & (CMDBUFF_ALIGN_SZ-1)); 187 188 pcmdpriv->rsp_allocated_buf = rtw_zmalloc(MAX_RSPSZ + 4); 189 190 if (!pcmdpriv->rsp_allocated_buf) { 191 res = -ENOMEM; 192 goto exit; 193 } 194 195 pcmdpriv->rsp_buf = pcmdpriv->rsp_allocated_buf + 4 - ((SIZE_PTR)(pcmdpriv->rsp_allocated_buf) & 3); 196 197 pcmdpriv->cmd_issued_cnt = pcmdpriv->cmd_done_cnt = pcmdpriv->rsp_cnt = 0; 198 199 mutex_init(&pcmdpriv->sctx_mutex); 200 exit: 201 return res; 202 } 203 204 static void c2h_wk_callback(_workitem *work); 205 int rtw_init_evt_priv(struct evt_priv *pevtpriv) 206 { 207 /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */ 208 atomic_set(&pevtpriv->event_seq, 0); 209 pevtpriv->evt_done_cnt = 0; 210 211 _init_workitem(&pevtpriv->c2h_wk, c2h_wk_callback, NULL); 212 pevtpriv->c2h_wk_alive = false; 213 pevtpriv->c2h_queue = rtw_cbuf_alloc(C2H_QUEUE_MAX_LEN+1); 214 if (!pevtpriv->c2h_queue) 215 return -ENOMEM; 216 217 return 0; 218 } 219 220 void _rtw_free_evt_priv(struct evt_priv *pevtpriv) 221 { 222 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("+_rtw_free_evt_priv\n")); 223 224 _cancel_workitem_sync(&pevtpriv->c2h_wk); 225 while (pevtpriv->c2h_wk_alive) 226 msleep(10); 227 228 while (!rtw_cbuf_empty(pevtpriv->c2h_queue)) { 229 void *c2h = rtw_cbuf_pop(pevtpriv->c2h_queue); 230 if (c2h != NULL && c2h != (void *)pevtpriv) { 231 kfree(c2h); 232 } 233 } 234 kfree(pevtpriv->c2h_queue); 235 236 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("-_rtw_free_evt_priv\n")); 237 } 238 239 void _rtw_free_cmd_priv(struct cmd_priv *pcmdpriv) 240 { 241 if (pcmdpriv) { 242 kfree(pcmdpriv->cmd_allocated_buf); 243 244 kfree(pcmdpriv->rsp_allocated_buf); 245 246 mutex_destroy(&pcmdpriv->sctx_mutex); 247 } 248 } 249 250 /* 251 Calling Context: 252 253 rtw_enqueue_cmd can only be called between kernel thread, 254 since only spin_lock is used. 255 256 ISR/Call-Back functions can't call this sub-function. 257 258 */ 259 260 int _rtw_enqueue_cmd(struct __queue *queue, struct cmd_obj *obj) 261 { 262 _irqL irqL; 263 264 if (obj == NULL) 265 goto exit; 266 267 /* spin_lock_bh(&queue->lock); */ 268 spin_lock_irqsave(&queue->lock, irqL); 269 270 list_add_tail(&obj->list, &queue->queue); 271 272 /* spin_unlock_bh(&queue->lock); */ 273 spin_unlock_irqrestore(&queue->lock, irqL); 274 275 exit: 276 return _SUCCESS; 277 } 278 279 struct cmd_obj *_rtw_dequeue_cmd(struct __queue *queue) 280 { 281 _irqL irqL; 282 struct cmd_obj *obj; 283 284 /* spin_lock_bh(&(queue->lock)); */ 285 spin_lock_irqsave(&queue->lock, irqL); 286 if (list_empty(&(queue->queue))) 287 obj = NULL; 288 else { 289 obj = LIST_CONTAINOR(get_next(&(queue->queue)), struct cmd_obj, list); 290 list_del_init(&obj->list); 291 } 292 293 /* spin_unlock_bh(&(queue->lock)); */ 294 spin_unlock_irqrestore(&queue->lock, irqL); 295 296 return obj; 297 } 298 299 void rtw_free_evt_priv(struct evt_priv *pevtpriv) 300 { 301 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("rtw_free_evt_priv\n")); 302 _rtw_free_evt_priv(pevtpriv); 303 } 304 305 void rtw_free_cmd_priv(struct cmd_priv *pcmdpriv) 306 { 307 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("rtw_free_cmd_priv\n")); 308 _rtw_free_cmd_priv(pcmdpriv); 309 } 310 311 int rtw_cmd_filter(struct cmd_priv *pcmdpriv, struct cmd_obj *cmd_obj); 312 int rtw_cmd_filter(struct cmd_priv *pcmdpriv, struct cmd_obj *cmd_obj) 313 { 314 u8 bAllow = false; /* set to true to allow enqueuing cmd when hw_init_completed is false */ 315 316 if (cmd_obj->cmdcode == GEN_CMD_CODE(_SetChannelPlan)) 317 bAllow = true; 318 319 if ((pcmdpriv->padapter->hw_init_completed == false && bAllow == false) 320 || atomic_read(&(pcmdpriv->cmdthd_running)) == false /* com_thread not running */ 321 ) { 322 /* DBG_871X("%s:%s: drop cmdcode:%u, hw_init_completed:%u, cmdthd_running:%u\n", caller_func, __func__, */ 323 /* cmd_obj->cmdcode, */ 324 /* pcmdpriv->padapter->hw_init_completed, */ 325 /* pcmdpriv->cmdthd_running */ 326 /* */ 327 328 return _FAIL; 329 } 330 return _SUCCESS; 331 } 332 333 334 335 int rtw_enqueue_cmd(struct cmd_priv *pcmdpriv, struct cmd_obj *cmd_obj) 336 { 337 int res = _FAIL; 338 struct adapter *padapter = pcmdpriv->padapter; 339 340 if (cmd_obj == NULL) { 341 goto exit; 342 } 343 344 cmd_obj->padapter = padapter; 345 346 res = rtw_cmd_filter(pcmdpriv, cmd_obj); 347 if (_FAIL == res) { 348 rtw_free_cmd_obj(cmd_obj); 349 goto exit; 350 } 351 352 res = _rtw_enqueue_cmd(&pcmdpriv->cmd_queue, cmd_obj); 353 354 if (res == _SUCCESS) 355 complete(&pcmdpriv->cmd_queue_comp); 356 357 exit: 358 return res; 359 } 360 361 struct cmd_obj *rtw_dequeue_cmd(struct cmd_priv *pcmdpriv) 362 { 363 struct cmd_obj *cmd_obj; 364 365 cmd_obj = _rtw_dequeue_cmd(&pcmdpriv->cmd_queue); 366 367 return cmd_obj; 368 } 369 370 void rtw_free_cmd_obj(struct cmd_obj *pcmd) 371 { 372 if ((pcmd->cmdcode != _JoinBss_CMD_) && 373 (pcmd->cmdcode != _CreateBss_CMD_)) { 374 /* free parmbuf in cmd_obj */ 375 kfree((unsigned char *)pcmd->parmbuf); 376 } 377 378 if (pcmd->rsp != NULL) { 379 if (pcmd->rspsz != 0) { 380 /* free rsp in cmd_obj */ 381 kfree((unsigned char *)pcmd->rsp); 382 } 383 } 384 385 /* free cmd_obj */ 386 kfree(pcmd); 387 } 388 389 390 void rtw_stop_cmd_thread(struct adapter *adapter) 391 { 392 if (adapter->cmdThread && 393 atomic_read(&(adapter->cmdpriv.cmdthd_running)) == true && 394 adapter->cmdpriv.stop_req == 0) { 395 adapter->cmdpriv.stop_req = 1; 396 complete(&adapter->cmdpriv.cmd_queue_comp); 397 wait_for_completion(&adapter->cmdpriv.terminate_cmdthread_comp); 398 } 399 } 400 401 int rtw_cmd_thread(void *context) 402 { 403 u8 ret; 404 struct cmd_obj *pcmd; 405 u8 *pcmdbuf, *prspbuf; 406 unsigned long cmd_start_time; 407 unsigned long cmd_process_time; 408 u8 (*cmd_hdl)(struct adapter *padapter, u8 *pbuf); 409 void (*pcmd_callback)(struct adapter *dev, struct cmd_obj *pcmd); 410 struct adapter *padapter = context; 411 struct cmd_priv *pcmdpriv = &(padapter->cmdpriv); 412 struct drvextra_cmd_parm *extra_parm = NULL; 413 414 thread_enter("RTW_CMD_THREAD"); 415 416 pcmdbuf = pcmdpriv->cmd_buf; 417 prspbuf = pcmdpriv->rsp_buf; 418 419 pcmdpriv->stop_req = 0; 420 atomic_set(&(pcmdpriv->cmdthd_running), true); 421 complete(&pcmdpriv->terminate_cmdthread_comp); 422 423 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("start r871x rtw_cmd_thread !!!!\n")); 424 425 while (1) { 426 if (wait_for_completion_interruptible(&pcmdpriv->cmd_queue_comp)) { 427 DBG_871X_LEVEL(_drv_always_, FUNC_ADPT_FMT" wait_for_completion_interruptible(&pcmdpriv->cmd_queue_comp) return != 0, break\n", FUNC_ADPT_ARG(padapter)); 428 break; 429 } 430 431 if ((padapter->bDriverStopped == true) || (padapter->bSurpriseRemoved == true)) { 432 DBG_871X_LEVEL(_drv_always_, "%s: DriverStopped(%d) SurpriseRemoved(%d) break at line %d\n", 433 __func__, padapter->bDriverStopped, padapter->bSurpriseRemoved, __LINE__); 434 break; 435 } 436 437 if (pcmdpriv->stop_req) { 438 DBG_871X_LEVEL(_drv_always_, FUNC_ADPT_FMT" stop_req:%u, break\n", FUNC_ADPT_ARG(padapter), pcmdpriv->stop_req); 439 break; 440 } 441 442 if (list_empty(&(pcmdpriv->cmd_queue.queue))) { 443 /* DBG_871X("%s: cmd queue is empty!\n", __func__); */ 444 continue; 445 } 446 447 if (rtw_register_cmd_alive(padapter) != _SUCCESS) { 448 RT_TRACE(_module_hal_xmit_c_, _drv_notice_, 449 ("%s: wait to leave LPS_LCLK\n", __func__)); 450 continue; 451 } 452 453 _next: 454 if ((padapter->bDriverStopped == true) || (padapter->bSurpriseRemoved == true)) { 455 DBG_871X_LEVEL(_drv_always_, "%s: DriverStopped(%d) SurpriseRemoved(%d) break at line %d\n", 456 __func__, padapter->bDriverStopped, padapter->bSurpriseRemoved, __LINE__); 457 break; 458 } 459 460 pcmd = rtw_dequeue_cmd(pcmdpriv); 461 if (!pcmd) { 462 rtw_unregister_cmd_alive(padapter); 463 continue; 464 } 465 466 cmd_start_time = jiffies; 467 468 if (_FAIL == rtw_cmd_filter(pcmdpriv, pcmd)) { 469 pcmd->res = H2C_DROPPED; 470 goto post_process; 471 } 472 473 pcmdpriv->cmd_issued_cnt++; 474 475 pcmd->cmdsz = _RND4((pcmd->cmdsz));/* _RND4 */ 476 477 memcpy(pcmdbuf, pcmd->parmbuf, pcmd->cmdsz); 478 479 if (pcmd->cmdcode < ARRAY_SIZE(wlancmds)) { 480 cmd_hdl = wlancmds[pcmd->cmdcode].h2cfuns; 481 482 if (cmd_hdl) { 483 ret = cmd_hdl(pcmd->padapter, pcmdbuf); 484 pcmd->res = ret; 485 } 486 487 pcmdpriv->cmd_seq++; 488 } else { 489 pcmd->res = H2C_PARAMETERS_ERROR; 490 } 491 492 cmd_hdl = NULL; 493 494 post_process: 495 496 if (mutex_lock_interruptible(&(pcmd->padapter->cmdpriv.sctx_mutex)) == 0) { 497 if (pcmd->sctx) { 498 DBG_871X_LEVEL(_drv_always_, FUNC_ADPT_FMT" pcmd->sctx\n", 499 FUNC_ADPT_ARG(pcmd->padapter)); 500 501 if (pcmd->res == H2C_SUCCESS) 502 rtw_sctx_done(&pcmd->sctx); 503 else 504 rtw_sctx_done_err(&pcmd->sctx, RTW_SCTX_DONE_CMD_ERROR); 505 } 506 mutex_unlock(&(pcmd->padapter->cmdpriv.sctx_mutex)); 507 } 508 509 cmd_process_time = jiffies_to_msecs(jiffies - cmd_start_time); 510 if (cmd_process_time > 1000) { 511 if (pcmd->cmdcode == GEN_CMD_CODE(_Set_Drv_Extra)) { 512 DBG_871X(ADPT_FMT" cmd =%d process_time =%lu > 1 sec\n", 513 ADPT_ARG(pcmd->padapter), pcmd->cmdcode, cmd_process_time); 514 /* rtw_warn_on(1); */ 515 } else if (pcmd->cmdcode == GEN_CMD_CODE(_Set_MLME_EVT)) { 516 DBG_871X(ADPT_FMT" cmd =%d, process_time =%lu > 1 sec\n", 517 ADPT_ARG(pcmd->padapter), pcmd->cmdcode, cmd_process_time); 518 /* rtw_warn_on(1); */ 519 } else { 520 DBG_871X(ADPT_FMT" cmd =%d, process_time =%lu > 1 sec\n", 521 ADPT_ARG(pcmd->padapter), pcmd->cmdcode, cmd_process_time); 522 /* rtw_warn_on(1); */ 523 } 524 } 525 526 /* call callback function for post-processed */ 527 if (pcmd->cmdcode < ARRAY_SIZE(rtw_cmd_callback)) { 528 pcmd_callback = rtw_cmd_callback[pcmd->cmdcode].callback; 529 if (pcmd_callback == NULL) { 530 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("mlme_cmd_hdl(): pcmd_callback = 0x%p, cmdcode = 0x%x\n", pcmd_callback, pcmd->cmdcode)); 531 rtw_free_cmd_obj(pcmd); 532 } else { 533 /* todo: !!! fill rsp_buf to pcmd->rsp if (pcmd->rsp!= NULL) */ 534 pcmd_callback(pcmd->padapter, pcmd);/* need conider that free cmd_obj in rtw_cmd_callback */ 535 } 536 } else { 537 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("%s: cmdcode = 0x%x callback not defined!\n", __func__, pcmd->cmdcode)); 538 rtw_free_cmd_obj(pcmd); 539 } 540 541 flush_signals_thread(); 542 543 goto _next; 544 545 } 546 547 /* free all cmd_obj resources */ 548 do { 549 pcmd = rtw_dequeue_cmd(pcmdpriv); 550 if (pcmd == NULL) { 551 rtw_unregister_cmd_alive(padapter); 552 break; 553 } 554 555 /* DBG_871X("%s: leaving... drop cmdcode:%u size:%d\n", __func__, pcmd->cmdcode, pcmd->cmdsz); */ 556 557 if (pcmd->cmdcode == GEN_CMD_CODE(_Set_Drv_Extra)) { 558 extra_parm = (struct drvextra_cmd_parm *)pcmd->parmbuf; 559 if (extra_parm->pbuf && extra_parm->size > 0) { 560 kfree(extra_parm->pbuf); 561 } 562 } 563 564 rtw_free_cmd_obj(pcmd); 565 } while (1); 566 567 complete(&pcmdpriv->terminate_cmdthread_comp); 568 atomic_set(&(pcmdpriv->cmdthd_running), false); 569 570 thread_exit(); 571 } 572 573 /* 574 rtw_sitesurvey_cmd(~) 575 ### NOTE:#### (!!!!) 576 MUST TAKE CARE THAT BEFORE CALLING THIS FUNC, YOU SHOULD HAVE LOCKED pmlmepriv->lock 577 */ 578 u8 rtw_sitesurvey_cmd(struct adapter *padapter, struct ndis_802_11_ssid *ssid, int ssid_num, 579 struct rtw_ieee80211_channel *ch, int ch_num) 580 { 581 u8 res = _FAIL; 582 struct cmd_obj *ph2c; 583 struct sitesurvey_parm *psurveyPara; 584 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 585 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 586 587 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) { 588 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_SCAN, 1); 589 } 590 591 ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 592 if (ph2c == NULL) 593 return _FAIL; 594 595 psurveyPara = rtw_zmalloc(sizeof(struct sitesurvey_parm)); 596 if (psurveyPara == NULL) { 597 kfree(ph2c); 598 return _FAIL; 599 } 600 601 rtw_free_network_queue(padapter, false); 602 603 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("%s: flush network queue\n", __func__)); 604 605 init_h2fwcmd_w_parm_no_rsp(ph2c, psurveyPara, GEN_CMD_CODE(_SiteSurvey)); 606 607 /* psurveyPara->bsslimit = 48; */ 608 psurveyPara->scan_mode = pmlmepriv->scan_mode; 609 610 /* prepare ssid list */ 611 if (ssid) { 612 int i; 613 for (i = 0; i < ssid_num && i < RTW_SSID_SCAN_AMOUNT; i++) { 614 if (ssid[i].SsidLength) { 615 memcpy(&psurveyPara->ssid[i], &ssid[i], sizeof(struct ndis_802_11_ssid)); 616 psurveyPara->ssid_num++; 617 618 DBG_871X(FUNC_ADPT_FMT" ssid:(%s, %d)\n", FUNC_ADPT_ARG(padapter), 619 psurveyPara->ssid[i].Ssid, psurveyPara->ssid[i].SsidLength); 620 } 621 } 622 } 623 624 /* prepare channel list */ 625 if (ch) { 626 int i; 627 for (i = 0; i < ch_num && i < RTW_CHANNEL_SCAN_AMOUNT; i++) { 628 if (ch[i].hw_value && !(ch[i].flags & RTW_IEEE80211_CHAN_DISABLED)) { 629 memcpy(&psurveyPara->ch[i], &ch[i], sizeof(struct rtw_ieee80211_channel)); 630 psurveyPara->ch_num++; 631 632 DBG_871X(FUNC_ADPT_FMT" ch:%u\n", FUNC_ADPT_ARG(padapter), 633 psurveyPara->ch[i].hw_value); 634 } 635 } 636 } 637 638 set_fwstate(pmlmepriv, _FW_UNDER_SURVEY); 639 640 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 641 642 if (res == _SUCCESS) { 643 644 pmlmepriv->scan_start_time = jiffies; 645 _set_timer(&pmlmepriv->scan_to_timer, SCANNING_TIMEOUT); 646 } else { 647 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY); 648 } 649 return res; 650 } 651 652 u8 rtw_setdatarate_cmd(struct adapter *padapter, u8 *rateset) 653 { 654 struct cmd_obj *ph2c; 655 struct setdatarate_parm *pbsetdataratepara; 656 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 657 u8 res = _SUCCESS; 658 659 ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 660 if (ph2c == NULL) { 661 res = _FAIL; 662 goto exit; 663 } 664 665 pbsetdataratepara = rtw_zmalloc(sizeof(struct setdatarate_parm)); 666 if (pbsetdataratepara == NULL) { 667 kfree(ph2c); 668 res = _FAIL; 669 goto exit; 670 } 671 672 init_h2fwcmd_w_parm_no_rsp(ph2c, pbsetdataratepara, GEN_CMD_CODE(_SetDataRate)); 673 pbsetdataratepara->mac_id = 5; 674 memcpy(pbsetdataratepara->datarates, rateset, NumRates); 675 676 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 677 exit: 678 return res; 679 } 680 681 void rtw_getbbrfreg_cmdrsp_callback(struct adapter *padapter, struct cmd_obj *pcmd) 682 { 683 /* rtw_free_cmd_obj(pcmd); */ 684 kfree(pcmd->parmbuf); 685 kfree(pcmd); 686 } 687 688 u8 rtw_createbss_cmd(struct adapter *padapter) 689 { 690 struct cmd_obj *pcmd; 691 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 692 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 693 struct wlan_bssid_ex *pdev_network = &padapter->registrypriv.dev_network; 694 u8 res = _SUCCESS; 695 696 if (pmlmepriv->assoc_ssid.SsidLength == 0) { 697 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, (" createbss for Any SSid:%s\n", pmlmepriv->assoc_ssid.Ssid)); 698 } else { 699 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, (" createbss for SSid:%s\n", pmlmepriv->assoc_ssid.Ssid)); 700 } 701 702 pcmd = rtw_zmalloc(sizeof(struct cmd_obj)); 703 if (pcmd == NULL) { 704 res = _FAIL; 705 goto exit; 706 } 707 708 INIT_LIST_HEAD(&pcmd->list); 709 pcmd->cmdcode = _CreateBss_CMD_; 710 pcmd->parmbuf = (unsigned char *)pdev_network; 711 pcmd->cmdsz = get_wlan_bssid_ex_sz((struct wlan_bssid_ex *)pdev_network); 712 pcmd->rsp = NULL; 713 pcmd->rspsz = 0; 714 715 pdev_network->Length = pcmd->cmdsz; 716 717 res = rtw_enqueue_cmd(pcmdpriv, pcmd); 718 719 exit: 720 return res; 721 } 722 723 int rtw_startbss_cmd(struct adapter *padapter, int flags) 724 { 725 struct cmd_obj *pcmd; 726 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 727 struct submit_ctx sctx; 728 int res = _SUCCESS; 729 730 if (flags & RTW_CMDF_DIRECTLY) { 731 /* no need to enqueue, do the cmd hdl directly and free cmd parameter */ 732 start_bss_network(padapter, (u8 *)&(padapter->mlmepriv.cur_network.network)); 733 } else { 734 /* need enqueue, prepare cmd_obj and enqueue */ 735 pcmd = rtw_zmalloc(sizeof(struct cmd_obj)); 736 if (pcmd == NULL) { 737 res = _FAIL; 738 goto exit; 739 } 740 741 INIT_LIST_HEAD(&pcmd->list); 742 pcmd->cmdcode = GEN_CMD_CODE(_CreateBss); 743 pcmd->parmbuf = NULL; 744 pcmd->cmdsz = 0; 745 pcmd->rsp = NULL; 746 pcmd->rspsz = 0; 747 748 if (flags & RTW_CMDF_WAIT_ACK) { 749 pcmd->sctx = &sctx; 750 rtw_sctx_init(&sctx, 2000); 751 } 752 753 res = rtw_enqueue_cmd(pcmdpriv, pcmd); 754 755 if (res == _SUCCESS && (flags & RTW_CMDF_WAIT_ACK)) { 756 rtw_sctx_wait(&sctx, __func__); 757 if (mutex_lock_interruptible(&pcmdpriv->sctx_mutex) == 0) { 758 if (sctx.status == RTW_SCTX_SUBMITTED) 759 pcmd->sctx = NULL; 760 mutex_unlock(&pcmdpriv->sctx_mutex); 761 } 762 } 763 } 764 765 exit: 766 return res; 767 } 768 769 u8 rtw_joinbss_cmd(struct adapter *padapter, struct wlan_network *pnetwork) 770 { 771 u8 *auth, res = _SUCCESS; 772 uint t_len = 0; 773 struct wlan_bssid_ex *psecnetwork; 774 struct cmd_obj *pcmd; 775 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 776 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 777 struct qos_priv *pqospriv = &pmlmepriv->qospriv; 778 struct security_priv *psecuritypriv = &padapter->securitypriv; 779 struct registry_priv *pregistrypriv = &padapter->registrypriv; 780 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 781 enum NDIS_802_11_NETWORK_INFRASTRUCTURE ndis_network_mode = pnetwork->network.InfrastructureMode; 782 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 783 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 784 u32 tmp_len; 785 u8 *ptmp = NULL; 786 787 if (pmlmepriv->assoc_ssid.SsidLength == 0) { 788 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("+Join cmd: Any SSid\n")); 789 } else { 790 RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+Join cmd: SSid =[%s]\n", pmlmepriv->assoc_ssid.Ssid)); 791 } 792 793 pcmd = rtw_zmalloc(sizeof(struct cmd_obj)); 794 if (pcmd == NULL) { 795 res = _FAIL; 796 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("rtw_joinbss_cmd: memory allocate for cmd_obj fail!!!\n")); 797 goto exit; 798 } 799 /* for IEs is fix buf size */ 800 t_len = sizeof(struct wlan_bssid_ex); 801 802 803 /* for hidden ap to set fw_state here */ 804 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_ADHOC_STATE) != true) { 805 switch (ndis_network_mode) { 806 case Ndis802_11IBSS: 807 set_fwstate(pmlmepriv, WIFI_ADHOC_STATE); 808 break; 809 810 case Ndis802_11Infrastructure: 811 set_fwstate(pmlmepriv, WIFI_STATION_STATE); 812 break; 813 814 case Ndis802_11APMode: 815 case Ndis802_11AutoUnknown: 816 case Ndis802_11InfrastructureMax: 817 break; 818 819 } 820 } 821 822 psecnetwork = (struct wlan_bssid_ex *)&psecuritypriv->sec_bss; 823 824 memset(psecnetwork, 0, t_len); 825 826 memcpy(psecnetwork, &pnetwork->network, get_wlan_bssid_ex_sz(&pnetwork->network)); 827 828 auth = &psecuritypriv->authenticator_ie[0]; 829 psecuritypriv->authenticator_ie[0] = (unsigned char)psecnetwork->IELength; 830 831 if ((psecnetwork->IELength-12) < (256-1)) { 832 memcpy(&psecuritypriv->authenticator_ie[1], &psecnetwork->IEs[12], psecnetwork->IELength-12); 833 } else { 834 memcpy(&psecuritypriv->authenticator_ie[1], &psecnetwork->IEs[12], (256-1)); 835 } 836 837 psecnetwork->IELength = 0; 838 /* Added by Albert 2009/02/18 */ 839 /* If the the driver wants to use the bssid to create the connection. */ 840 /* If not, we have to copy the connecting AP's MAC address to it so that */ 841 /* the driver just has the bssid information for PMKIDList searching. */ 842 843 if (pmlmepriv->assoc_by_bssid == false) { 844 memcpy(&pmlmepriv->assoc_bssid[0], &pnetwork->network.MacAddress[0], ETH_ALEN); 845 } 846 847 psecnetwork->IELength = rtw_restruct_sec_ie(padapter, &pnetwork->network.IEs[0], &psecnetwork->IEs[0], pnetwork->network.IELength); 848 849 850 pqospriv->qos_option = 0; 851 852 if (pregistrypriv->wmm_enable) { 853 tmp_len = rtw_restruct_wmm_ie(padapter, &pnetwork->network.IEs[0], &psecnetwork->IEs[0], pnetwork->network.IELength, psecnetwork->IELength); 854 855 if (psecnetwork->IELength != tmp_len) { 856 psecnetwork->IELength = tmp_len; 857 pqospriv->qos_option = 1; /* There is WMM IE in this corresp. beacon */ 858 } else { 859 pqospriv->qos_option = 0;/* There is no WMM IE in this corresp. beacon */ 860 } 861 } 862 863 phtpriv->ht_option = false; 864 ptmp = rtw_get_ie(&pnetwork->network.IEs[12], _HT_CAPABILITY_IE_, &tmp_len, pnetwork->network.IELength-12); 865 if (pregistrypriv->ht_enable && ptmp && tmp_len > 0) { 866 /* Added by Albert 2010/06/23 */ 867 /* For the WEP mode, we will use the bg mode to do the connection to avoid some IOT issue. */ 868 /* Especially for Realtek 8192u SoftAP. */ 869 if ((padapter->securitypriv.dot11PrivacyAlgrthm != _WEP40_) && 870 (padapter->securitypriv.dot11PrivacyAlgrthm != _WEP104_) && 871 (padapter->securitypriv.dot11PrivacyAlgrthm != _TKIP_)) { 872 rtw_ht_use_default_setting(padapter); 873 874 rtw_build_wmm_ie_ht(padapter, &psecnetwork->IEs[12], &psecnetwork->IELength); 875 876 /* rtw_restructure_ht_ie */ 877 rtw_restructure_ht_ie(padapter, &pnetwork->network.IEs[12], &psecnetwork->IEs[0], 878 pnetwork->network.IELength-12, &psecnetwork->IELength, 879 pnetwork->network.Configuration.DSConfig); 880 } 881 } 882 883 rtw_append_exented_cap(padapter, &psecnetwork->IEs[0], &psecnetwork->IELength); 884 885 pmlmeinfo->assoc_AP_vendor = check_assoc_AP(pnetwork->network.IEs, pnetwork->network.IELength); 886 887 pcmd->cmdsz = get_wlan_bssid_ex_sz(psecnetwork);/* get cmdsz before endian conversion */ 888 889 INIT_LIST_HEAD(&pcmd->list); 890 pcmd->cmdcode = _JoinBss_CMD_;/* GEN_CMD_CODE(_JoinBss) */ 891 pcmd->parmbuf = (unsigned char *)psecnetwork; 892 pcmd->rsp = NULL; 893 pcmd->rspsz = 0; 894 895 res = rtw_enqueue_cmd(pcmdpriv, pcmd); 896 897 exit: 898 return res; 899 } 900 901 u8 rtw_disassoc_cmd(struct adapter *padapter, u32 deauth_timeout_ms, bool enqueue) /* for sta_mode */ 902 { 903 struct cmd_obj *cmdobj = NULL; 904 struct disconnect_parm *param = NULL; 905 struct cmd_priv *cmdpriv = &padapter->cmdpriv; 906 u8 res = _SUCCESS; 907 908 RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+rtw_disassoc_cmd\n")); 909 910 /* prepare cmd parameter */ 911 param = rtw_zmalloc(sizeof(*param)); 912 if (param == NULL) { 913 res = _FAIL; 914 goto exit; 915 } 916 param->deauth_timeout_ms = deauth_timeout_ms; 917 918 if (enqueue) { 919 /* need enqueue, prepare cmd_obj and enqueue */ 920 cmdobj = rtw_zmalloc(sizeof(*cmdobj)); 921 if (cmdobj == NULL) { 922 res = _FAIL; 923 kfree(param); 924 goto exit; 925 } 926 init_h2fwcmd_w_parm_no_rsp(cmdobj, param, _DisConnect_CMD_); 927 res = rtw_enqueue_cmd(cmdpriv, cmdobj); 928 } else { 929 /* no need to enqueue, do the cmd hdl directly and free cmd parameter */ 930 if (H2C_SUCCESS != disconnect_hdl(padapter, (u8 *)param)) 931 res = _FAIL; 932 kfree(param); 933 } 934 935 exit: 936 return res; 937 } 938 939 u8 rtw_setopmode_cmd(struct adapter *padapter, enum NDIS_802_11_NETWORK_INFRASTRUCTURE networktype, bool enqueue) 940 { 941 struct cmd_obj *ph2c; 942 struct setopmode_parm *psetop; 943 944 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 945 u8 res = _SUCCESS; 946 947 psetop = rtw_zmalloc(sizeof(struct setopmode_parm)); 948 949 if (psetop == NULL) { 950 res = _FAIL; 951 goto exit; 952 } 953 psetop->mode = (u8)networktype; 954 955 if (enqueue) { 956 ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 957 if (ph2c == NULL) { 958 kfree(psetop); 959 res = _FAIL; 960 goto exit; 961 } 962 963 init_h2fwcmd_w_parm_no_rsp(ph2c, psetop, _SetOpMode_CMD_); 964 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 965 } else { 966 setopmode_hdl(padapter, (u8 *)psetop); 967 kfree(psetop); 968 } 969 exit: 970 return res; 971 } 972 973 u8 rtw_setstakey_cmd(struct adapter *padapter, struct sta_info *sta, u8 unicast_key, bool enqueue) 974 { 975 struct cmd_obj *ph2c; 976 struct set_stakey_parm *psetstakey_para; 977 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 978 struct set_stakey_rsp *psetstakey_rsp = NULL; 979 980 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 981 struct security_priv *psecuritypriv = &padapter->securitypriv; 982 u8 res = _SUCCESS; 983 984 psetstakey_para = rtw_zmalloc(sizeof(struct set_stakey_parm)); 985 if (psetstakey_para == NULL) { 986 res = _FAIL; 987 goto exit; 988 } 989 990 memcpy(psetstakey_para->addr, sta->hwaddr, ETH_ALEN); 991 992 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) { 993 psetstakey_para->algorithm = (unsigned char) psecuritypriv->dot11PrivacyAlgrthm; 994 } else { 995 GET_ENCRY_ALGO(psecuritypriv, sta, psetstakey_para->algorithm, false); 996 } 997 998 if (unicast_key == true) { 999 memcpy(&psetstakey_para->key, &sta->dot118021x_UncstKey, 16); 1000 } else { 1001 memcpy(&psetstakey_para->key, &psecuritypriv->dot118021XGrpKey[psecuritypriv->dot118021XGrpKeyid].skey, 16); 1002 } 1003 1004 /* jeff: set this becasue at least sw key is ready */ 1005 padapter->securitypriv.busetkipkey = true; 1006 1007 if (enqueue) { 1008 ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1009 if (ph2c == NULL) { 1010 kfree(psetstakey_para); 1011 res = _FAIL; 1012 goto exit; 1013 } 1014 1015 psetstakey_rsp = rtw_zmalloc(sizeof(struct set_stakey_rsp)); 1016 if (psetstakey_rsp == NULL) { 1017 kfree(ph2c); 1018 kfree(psetstakey_para); 1019 res = _FAIL; 1020 goto exit; 1021 } 1022 1023 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_); 1024 ph2c->rsp = (u8 *) psetstakey_rsp; 1025 ph2c->rspsz = sizeof(struct set_stakey_rsp); 1026 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 1027 } else { 1028 set_stakey_hdl(padapter, (u8 *)psetstakey_para); 1029 kfree(psetstakey_para); 1030 } 1031 exit: 1032 return res; 1033 } 1034 1035 u8 rtw_clearstakey_cmd(struct adapter *padapter, struct sta_info *sta, u8 enqueue) 1036 { 1037 struct cmd_obj *ph2c; 1038 struct set_stakey_parm *psetstakey_para; 1039 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1040 struct set_stakey_rsp *psetstakey_rsp = NULL; 1041 s16 cam_id = 0; 1042 u8 res = _SUCCESS; 1043 1044 if (!enqueue) { 1045 while ((cam_id = rtw_camid_search(padapter, sta->hwaddr, -1)) >= 0) { 1046 DBG_871X_LEVEL(_drv_always_, "clear key for addr:"MAC_FMT", camid:%d\n", MAC_ARG(sta->hwaddr), cam_id); 1047 clear_cam_entry(padapter, cam_id); 1048 rtw_camid_free(padapter, cam_id); 1049 } 1050 } else { 1051 ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1052 if (ph2c == NULL) { 1053 res = _FAIL; 1054 goto exit; 1055 } 1056 1057 psetstakey_para = rtw_zmalloc(sizeof(struct set_stakey_parm)); 1058 if (psetstakey_para == NULL) { 1059 kfree(ph2c); 1060 res = _FAIL; 1061 goto exit; 1062 } 1063 1064 psetstakey_rsp = rtw_zmalloc(sizeof(struct set_stakey_rsp)); 1065 if (psetstakey_rsp == NULL) { 1066 kfree(ph2c); 1067 kfree(psetstakey_para); 1068 res = _FAIL; 1069 goto exit; 1070 } 1071 1072 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_); 1073 ph2c->rsp = (u8 *) psetstakey_rsp; 1074 ph2c->rspsz = sizeof(struct set_stakey_rsp); 1075 1076 memcpy(psetstakey_para->addr, sta->hwaddr, ETH_ALEN); 1077 1078 psetstakey_para->algorithm = _NO_PRIVACY_; 1079 1080 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 1081 1082 } 1083 1084 exit: 1085 return res; 1086 } 1087 1088 u8 rtw_addbareq_cmd(struct adapter *padapter, u8 tid, u8 *addr) 1089 { 1090 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1091 struct cmd_obj *ph2c; 1092 struct addBaReq_parm *paddbareq_parm; 1093 1094 u8 res = _SUCCESS; 1095 1096 ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1097 if (ph2c == NULL) { 1098 res = _FAIL; 1099 goto exit; 1100 } 1101 1102 paddbareq_parm = rtw_zmalloc(sizeof(struct addBaReq_parm)); 1103 if (paddbareq_parm == NULL) { 1104 kfree(ph2c); 1105 res = _FAIL; 1106 goto exit; 1107 } 1108 1109 paddbareq_parm->tid = tid; 1110 memcpy(paddbareq_parm->addr, addr, ETH_ALEN); 1111 1112 init_h2fwcmd_w_parm_no_rsp(ph2c, paddbareq_parm, GEN_CMD_CODE(_AddBAReq)); 1113 1114 /* DBG_871X("rtw_addbareq_cmd, tid =%d\n", tid); */ 1115 1116 /* rtw_enqueue_cmd(pcmdpriv, ph2c); */ 1117 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 1118 1119 exit: 1120 return res; 1121 } 1122 /* add for CONFIG_IEEE80211W, none 11w can use it */ 1123 u8 rtw_reset_securitypriv_cmd(struct adapter *padapter) 1124 { 1125 struct cmd_obj *ph2c; 1126 struct drvextra_cmd_parm *pdrvextra_cmd_parm; 1127 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1128 u8 res = _SUCCESS; 1129 1130 ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1131 if (ph2c == NULL) { 1132 res = _FAIL; 1133 goto exit; 1134 } 1135 1136 pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1137 if (pdrvextra_cmd_parm == NULL) { 1138 kfree(ph2c); 1139 res = _FAIL; 1140 goto exit; 1141 } 1142 1143 pdrvextra_cmd_parm->ec_id = RESET_SECURITYPRIV; 1144 pdrvextra_cmd_parm->type = 0; 1145 pdrvextra_cmd_parm->size = 0; 1146 pdrvextra_cmd_parm->pbuf = NULL; 1147 1148 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra)); 1149 1150 1151 /* rtw_enqueue_cmd(pcmdpriv, ph2c); */ 1152 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 1153 1154 exit: 1155 return res; 1156 } 1157 1158 u8 rtw_free_assoc_resources_cmd(struct adapter *padapter) 1159 { 1160 struct cmd_obj *ph2c; 1161 struct drvextra_cmd_parm *pdrvextra_cmd_parm; 1162 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1163 u8 res = _SUCCESS; 1164 1165 ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1166 if (ph2c == NULL) { 1167 res = _FAIL; 1168 goto exit; 1169 } 1170 1171 pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1172 if (pdrvextra_cmd_parm == NULL) { 1173 kfree(ph2c); 1174 res = _FAIL; 1175 goto exit; 1176 } 1177 1178 pdrvextra_cmd_parm->ec_id = FREE_ASSOC_RESOURCES; 1179 pdrvextra_cmd_parm->type = 0; 1180 pdrvextra_cmd_parm->size = 0; 1181 pdrvextra_cmd_parm->pbuf = NULL; 1182 1183 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra)); 1184 1185 1186 /* rtw_enqueue_cmd(pcmdpriv, ph2c); */ 1187 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 1188 1189 exit: 1190 return res; 1191 } 1192 1193 u8 rtw_dynamic_chk_wk_cmd(struct adapter *padapter) 1194 { 1195 struct cmd_obj *ph2c; 1196 struct drvextra_cmd_parm *pdrvextra_cmd_parm; 1197 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1198 u8 res = _SUCCESS; 1199 1200 /* only primary padapter does this cmd */ 1201 ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1202 if (ph2c == NULL) { 1203 res = _FAIL; 1204 goto exit; 1205 } 1206 1207 pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1208 if (pdrvextra_cmd_parm == NULL) { 1209 kfree(ph2c); 1210 res = _FAIL; 1211 goto exit; 1212 } 1213 1214 pdrvextra_cmd_parm->ec_id = DYNAMIC_CHK_WK_CID; 1215 pdrvextra_cmd_parm->type = 0; 1216 pdrvextra_cmd_parm->size = 0; 1217 pdrvextra_cmd_parm->pbuf = NULL; 1218 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra)); 1219 1220 1221 /* rtw_enqueue_cmd(pcmdpriv, ph2c); */ 1222 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 1223 1224 exit: 1225 return res; 1226 } 1227 1228 u8 rtw_set_chplan_cmd(struct adapter *padapter, u8 chplan, u8 enqueue, u8 swconfig) 1229 { 1230 struct cmd_obj *pcmdobj; 1231 struct SetChannelPlan_param *setChannelPlan_param; 1232 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1233 1234 u8 res = _SUCCESS; 1235 1236 RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+rtw_set_chplan_cmd\n")); 1237 1238 /* check if allow software config */ 1239 if (swconfig && rtw_hal_is_disable_sw_channel_plan(padapter) == true) { 1240 res = _FAIL; 1241 goto exit; 1242 } 1243 1244 /* check input parameter */ 1245 if (!rtw_is_channel_plan_valid(chplan)) { 1246 res = _FAIL; 1247 goto exit; 1248 } 1249 1250 /* prepare cmd parameter */ 1251 setChannelPlan_param = rtw_zmalloc(sizeof(struct SetChannelPlan_param)); 1252 if (setChannelPlan_param == NULL) { 1253 res = _FAIL; 1254 goto exit; 1255 } 1256 setChannelPlan_param->channel_plan = chplan; 1257 1258 if (enqueue) { 1259 /* need enqueue, prepare cmd_obj and enqueue */ 1260 pcmdobj = rtw_zmalloc(sizeof(struct cmd_obj)); 1261 if (pcmdobj == NULL) { 1262 kfree(setChannelPlan_param); 1263 res = _FAIL; 1264 goto exit; 1265 } 1266 1267 init_h2fwcmd_w_parm_no_rsp(pcmdobj, setChannelPlan_param, GEN_CMD_CODE(_SetChannelPlan)); 1268 res = rtw_enqueue_cmd(pcmdpriv, pcmdobj); 1269 } else { 1270 /* no need to enqueue, do the cmd hdl directly and free cmd parameter */ 1271 if (H2C_SUCCESS != set_chplan_hdl(padapter, (unsigned char *)setChannelPlan_param)) 1272 res = _FAIL; 1273 1274 kfree(setChannelPlan_param); 1275 } 1276 1277 /* do something based on res... */ 1278 if (res == _SUCCESS) 1279 padapter->mlmepriv.ChannelPlan = chplan; 1280 1281 exit: 1282 return res; 1283 } 1284 1285 static void collect_traffic_statistics(struct adapter *padapter) 1286 { 1287 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter); 1288 1289 /* Tx */ 1290 pdvobjpriv->traffic_stat.tx_bytes = padapter->xmitpriv.tx_bytes; 1291 pdvobjpriv->traffic_stat.tx_pkts = padapter->xmitpriv.tx_pkts; 1292 pdvobjpriv->traffic_stat.tx_drop = padapter->xmitpriv.tx_drop; 1293 1294 /* Rx */ 1295 pdvobjpriv->traffic_stat.rx_bytes = padapter->recvpriv.rx_bytes; 1296 pdvobjpriv->traffic_stat.rx_pkts = padapter->recvpriv.rx_pkts; 1297 pdvobjpriv->traffic_stat.rx_drop = padapter->recvpriv.rx_drop; 1298 1299 /* Calculate throughput in last interval */ 1300 pdvobjpriv->traffic_stat.cur_tx_bytes = pdvobjpriv->traffic_stat.tx_bytes - pdvobjpriv->traffic_stat.last_tx_bytes; 1301 pdvobjpriv->traffic_stat.cur_rx_bytes = pdvobjpriv->traffic_stat.rx_bytes - pdvobjpriv->traffic_stat.last_rx_bytes; 1302 pdvobjpriv->traffic_stat.last_tx_bytes = pdvobjpriv->traffic_stat.tx_bytes; 1303 pdvobjpriv->traffic_stat.last_rx_bytes = pdvobjpriv->traffic_stat.rx_bytes; 1304 1305 pdvobjpriv->traffic_stat.cur_tx_tp = (u32)(pdvobjpriv->traffic_stat.cur_tx_bytes * 8/2/1024/1024); 1306 pdvobjpriv->traffic_stat.cur_rx_tp = (u32)(pdvobjpriv->traffic_stat.cur_rx_bytes * 8/2/1024/1024); 1307 } 1308 1309 u8 traffic_status_watchdog(struct adapter *padapter, u8 from_timer) 1310 { 1311 u8 bEnterPS = false; 1312 u16 BusyThresholdHigh = 25; 1313 u16 BusyThresholdLow = 10; 1314 u16 BusyThreshold = BusyThresholdHigh; 1315 u8 bBusyTraffic = false, bTxBusyTraffic = false, bRxBusyTraffic = false; 1316 u8 bHigherBusyTraffic = false, bHigherBusyRxTraffic = false, bHigherBusyTxTraffic = false; 1317 1318 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1319 1320 collect_traffic_statistics(padapter); 1321 1322 /* */ 1323 /* Determine if our traffic is busy now */ 1324 /* */ 1325 if ((check_fwstate(pmlmepriv, _FW_LINKED) == true) 1326 /*&& !MgntInitAdapterInProgress(pMgntInfo)*/) { 1327 /* if we raise bBusyTraffic in last watchdog, using lower threshold. */ 1328 if (pmlmepriv->LinkDetectInfo.bBusyTraffic) 1329 BusyThreshold = BusyThresholdLow; 1330 1331 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > BusyThreshold || 1332 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod > BusyThreshold) { 1333 bBusyTraffic = true; 1334 1335 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > pmlmepriv->LinkDetectInfo.NumTxOkInPeriod) 1336 bRxBusyTraffic = true; 1337 else 1338 bTxBusyTraffic = true; 1339 } 1340 1341 /* Higher Tx/Rx data. */ 1342 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > 4000 || 1343 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod > 4000) { 1344 bHigherBusyTraffic = true; 1345 1346 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > pmlmepriv->LinkDetectInfo.NumTxOkInPeriod) 1347 bHigherBusyRxTraffic = true; 1348 else 1349 bHigherBusyTxTraffic = true; 1350 } 1351 1352 /* check traffic for powersaving. */ 1353 if (((pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod + pmlmepriv->LinkDetectInfo.NumTxOkInPeriod) > 8) || 1354 (pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod > 2)) { 1355 /* DBG_871X("(-)Tx = %d, Rx = %d\n", pmlmepriv->LinkDetectInfo.NumTxOkInPeriod, pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod); */ 1356 bEnterPS = false; 1357 1358 if (bBusyTraffic == true) { 1359 if (pmlmepriv->LinkDetectInfo.TrafficTransitionCount <= 4) 1360 pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 4; 1361 1362 pmlmepriv->LinkDetectInfo.TrafficTransitionCount++; 1363 1364 /* DBG_871X("Set TrafficTransitionCount to %d\n", pmlmepriv->LinkDetectInfo.TrafficTransitionCount); */ 1365 1366 if (pmlmepriv->LinkDetectInfo.TrafficTransitionCount > 30/*TrafficTransitionLevel*/) { 1367 pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 30; 1368 } 1369 } 1370 } else { 1371 /* DBG_871X("(+)Tx = %d, Rx = %d\n", pmlmepriv->LinkDetectInfo.NumTxOkInPeriod, pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod); */ 1372 1373 if (pmlmepriv->LinkDetectInfo.TrafficTransitionCount >= 2) 1374 pmlmepriv->LinkDetectInfo.TrafficTransitionCount -= 2; 1375 else 1376 pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 0; 1377 1378 if (pmlmepriv->LinkDetectInfo.TrafficTransitionCount == 0) 1379 bEnterPS = true; 1380 } 1381 1382 /* LeisurePS only work in infra mode. */ 1383 if (bEnterPS) { 1384 if (!from_timer) 1385 LPS_Enter(padapter, "TRAFFIC_IDLE"); 1386 } else { 1387 if (!from_timer) 1388 LPS_Leave(padapter, "TRAFFIC_BUSY"); 1389 else 1390 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_TRAFFIC_BUSY, 1); 1391 } 1392 } else { 1393 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter); 1394 int n_assoc_iface = 0; 1395 1396 if (check_fwstate(&(dvobj->padapters->mlmepriv), WIFI_ASOC_STATE)) 1397 n_assoc_iface++; 1398 1399 if (!from_timer && n_assoc_iface == 0) 1400 LPS_Leave(padapter, "NON_LINKED"); 1401 } 1402 1403 pmlmepriv->LinkDetectInfo.NumRxOkInPeriod = 0; 1404 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod = 0; 1405 pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod = 0; 1406 pmlmepriv->LinkDetectInfo.bBusyTraffic = bBusyTraffic; 1407 pmlmepriv->LinkDetectInfo.bTxBusyTraffic = bTxBusyTraffic; 1408 pmlmepriv->LinkDetectInfo.bRxBusyTraffic = bRxBusyTraffic; 1409 pmlmepriv->LinkDetectInfo.bHigherBusyTraffic = bHigherBusyTraffic; 1410 pmlmepriv->LinkDetectInfo.bHigherBusyRxTraffic = bHigherBusyRxTraffic; 1411 pmlmepriv->LinkDetectInfo.bHigherBusyTxTraffic = bHigherBusyTxTraffic; 1412 1413 return bEnterPS; 1414 1415 } 1416 1417 static void dynamic_chk_wk_hdl(struct adapter *padapter) 1418 { 1419 struct mlme_priv *pmlmepriv; 1420 pmlmepriv = &(padapter->mlmepriv); 1421 1422 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) { 1423 expire_timeout_chk(padapter); 1424 } 1425 1426 /* for debug purpose */ 1427 _linked_info_dump(padapter); 1428 1429 1430 /* if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING|_FW_UNDER_SURVEY) ==false) */ 1431 { 1432 linked_status_chk(padapter); 1433 traffic_status_watchdog(padapter, 0); 1434 } 1435 1436 rtw_hal_dm_watchdog(padapter); 1437 1438 /* check_hw_pbc(padapter, pdrvextra_cmd->pbuf, pdrvextra_cmd->type); */ 1439 1440 /* */ 1441 /* BT-Coexist */ 1442 /* */ 1443 hal_btcoex_Handler(padapter); 1444 1445 1446 /* always call rtw_ps_processor() at last one. */ 1447 if (is_primary_adapter(padapter)) 1448 rtw_ps_processor(padapter); 1449 } 1450 1451 void lps_ctrl_wk_hdl(struct adapter *padapter, u8 lps_ctrl_type); 1452 void lps_ctrl_wk_hdl(struct adapter *padapter, u8 lps_ctrl_type) 1453 { 1454 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter); 1455 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1456 u8 mstatus; 1457 1458 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) 1459 || (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true)) { 1460 return; 1461 } 1462 1463 switch (lps_ctrl_type) { 1464 case LPS_CTRL_SCAN: 1465 /* DBG_871X("LPS_CTRL_SCAN\n"); */ 1466 rtw_btcoex_ScanNotify(padapter, true); 1467 1468 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) { 1469 /* connect */ 1470 LPS_Leave(padapter, "LPS_CTRL_SCAN"); 1471 } 1472 break; 1473 case LPS_CTRL_JOINBSS: 1474 /* DBG_871X("LPS_CTRL_JOINBSS\n"); */ 1475 LPS_Leave(padapter, "LPS_CTRL_JOINBSS"); 1476 break; 1477 case LPS_CTRL_CONNECT: 1478 /* DBG_871X("LPS_CTRL_CONNECT\n"); */ 1479 mstatus = 1;/* connect */ 1480 /* Reset LPS Setting */ 1481 pwrpriv->LpsIdleCount = 0; 1482 rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_JOINBSSRPT, (u8 *)(&mstatus)); 1483 rtw_btcoex_MediaStatusNotify(padapter, mstatus); 1484 break; 1485 case LPS_CTRL_DISCONNECT: 1486 /* DBG_871X("LPS_CTRL_DISCONNECT\n"); */ 1487 mstatus = 0;/* disconnect */ 1488 rtw_btcoex_MediaStatusNotify(padapter, mstatus); 1489 LPS_Leave(padapter, "LPS_CTRL_DISCONNECT"); 1490 rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_JOINBSSRPT, (u8 *)(&mstatus)); 1491 break; 1492 case LPS_CTRL_SPECIAL_PACKET: 1493 /* DBG_871X("LPS_CTRL_SPECIAL_PACKET\n"); */ 1494 pwrpriv->DelayLPSLastTimeStamp = jiffies; 1495 hal_btcoex_SpecialPacketNotify(padapter, PACKET_DHCP); 1496 LPS_Leave(padapter, "LPS_CTRL_SPECIAL_PACKET"); 1497 break; 1498 case LPS_CTRL_LEAVE: 1499 /* DBG_871X("LPS_CTRL_LEAVE\n"); */ 1500 LPS_Leave(padapter, "LPS_CTRL_LEAVE"); 1501 break; 1502 case LPS_CTRL_TRAFFIC_BUSY: 1503 LPS_Leave(padapter, "LPS_CTRL_TRAFFIC_BUSY"); 1504 default: 1505 break; 1506 } 1507 } 1508 1509 u8 rtw_lps_ctrl_wk_cmd(struct adapter *padapter, u8 lps_ctrl_type, u8 enqueue) 1510 { 1511 struct cmd_obj *ph2c; 1512 struct drvextra_cmd_parm *pdrvextra_cmd_parm; 1513 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1514 /* struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter); */ 1515 u8 res = _SUCCESS; 1516 1517 /* if (!pwrctrlpriv->bLeisurePs) */ 1518 /* return res; */ 1519 1520 if (enqueue) { 1521 ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1522 if (ph2c == NULL) { 1523 res = _FAIL; 1524 goto exit; 1525 } 1526 1527 pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1528 if (pdrvextra_cmd_parm == NULL) { 1529 kfree(ph2c); 1530 res = _FAIL; 1531 goto exit; 1532 } 1533 1534 pdrvextra_cmd_parm->ec_id = LPS_CTRL_WK_CID; 1535 pdrvextra_cmd_parm->type = lps_ctrl_type; 1536 pdrvextra_cmd_parm->size = 0; 1537 pdrvextra_cmd_parm->pbuf = NULL; 1538 1539 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra)); 1540 1541 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 1542 } else { 1543 lps_ctrl_wk_hdl(padapter, lps_ctrl_type); 1544 } 1545 1546 exit: 1547 return res; 1548 } 1549 1550 static void rtw_dm_in_lps_hdl(struct adapter *padapter) 1551 { 1552 rtw_hal_set_hwreg(padapter, HW_VAR_DM_IN_LPS, NULL); 1553 } 1554 1555 u8 rtw_dm_in_lps_wk_cmd(struct adapter *padapter) 1556 { 1557 struct cmd_obj *ph2c; 1558 struct drvextra_cmd_parm *pdrvextra_cmd_parm; 1559 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1560 u8 res = _SUCCESS; 1561 1562 1563 ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1564 if (ph2c == NULL) { 1565 res = _FAIL; 1566 goto exit; 1567 } 1568 1569 pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1570 if (pdrvextra_cmd_parm == NULL) { 1571 kfree(ph2c); 1572 res = _FAIL; 1573 goto exit; 1574 } 1575 1576 pdrvextra_cmd_parm->ec_id = DM_IN_LPS_WK_CID; 1577 pdrvextra_cmd_parm->type = 0; 1578 pdrvextra_cmd_parm->size = 0; 1579 pdrvextra_cmd_parm->pbuf = NULL; 1580 1581 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra)); 1582 1583 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 1584 1585 exit: 1586 1587 return res; 1588 1589 } 1590 1591 static void rtw_lps_change_dtim_hdl(struct adapter *padapter, u8 dtim) 1592 { 1593 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter); 1594 1595 if (dtim <= 0 || dtim > 16) 1596 return; 1597 1598 if (hal_btcoex_IsBtControlLps(padapter) == true) 1599 return; 1600 1601 mutex_lock(&pwrpriv->lock); 1602 1603 if (pwrpriv->dtim != dtim) { 1604 DBG_871X("change DTIM from %d to %d, bFwCurrentInPSMode =%d, ps_mode =%d\n", pwrpriv->dtim, dtim, 1605 pwrpriv->bFwCurrentInPSMode, pwrpriv->pwr_mode); 1606 1607 pwrpriv->dtim = dtim; 1608 } 1609 1610 if ((pwrpriv->bFwCurrentInPSMode == true) && (pwrpriv->pwr_mode > PS_MODE_ACTIVE)) { 1611 u8 ps_mode = pwrpriv->pwr_mode; 1612 1613 /* DBG_871X("change DTIM from %d to %d, ps_mode =%d\n", pwrpriv->dtim, dtim, ps_mode); */ 1614 1615 rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE, (u8 *)(&ps_mode)); 1616 } 1617 1618 mutex_unlock(&pwrpriv->lock); 1619 } 1620 1621 static void rtw_dm_ra_mask_hdl(struct adapter *padapter, struct sta_info *psta) 1622 { 1623 if (psta) { 1624 set_sta_rate(padapter, psta); 1625 } 1626 } 1627 1628 u8 rtw_dm_ra_mask_wk_cmd(struct adapter *padapter, u8 *psta) 1629 { 1630 struct cmd_obj *ph2c; 1631 struct drvextra_cmd_parm *pdrvextra_cmd_parm; 1632 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1633 u8 res = _SUCCESS; 1634 1635 1636 ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1637 if (ph2c == NULL) { 1638 res = _FAIL; 1639 goto exit; 1640 } 1641 1642 pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1643 if (pdrvextra_cmd_parm == NULL) { 1644 kfree(ph2c); 1645 res = _FAIL; 1646 goto exit; 1647 } 1648 1649 pdrvextra_cmd_parm->ec_id = DM_RA_MSK_WK_CID; 1650 pdrvextra_cmd_parm->type = 0; 1651 pdrvextra_cmd_parm->size = 0; 1652 pdrvextra_cmd_parm->pbuf = psta; 1653 1654 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra)); 1655 1656 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 1657 1658 exit: 1659 1660 return res; 1661 1662 } 1663 1664 u8 rtw_ps_cmd(struct adapter *padapter) 1665 { 1666 struct cmd_obj *ppscmd; 1667 struct drvextra_cmd_parm *pdrvextra_cmd_parm; 1668 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1669 u8 res = _SUCCESS; 1670 1671 ppscmd = rtw_zmalloc(sizeof(struct cmd_obj)); 1672 if (ppscmd == NULL) { 1673 res = _FAIL; 1674 goto exit; 1675 } 1676 1677 pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1678 if (pdrvextra_cmd_parm == NULL) { 1679 kfree(ppscmd); 1680 res = _FAIL; 1681 goto exit; 1682 } 1683 1684 pdrvextra_cmd_parm->ec_id = POWER_SAVING_CTRL_WK_CID; 1685 pdrvextra_cmd_parm->type = 0; 1686 pdrvextra_cmd_parm->size = 0; 1687 pdrvextra_cmd_parm->pbuf = NULL; 1688 init_h2fwcmd_w_parm_no_rsp(ppscmd, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra)); 1689 1690 res = rtw_enqueue_cmd(pcmdpriv, ppscmd); 1691 1692 exit: 1693 return res; 1694 } 1695 1696 u32 g_wait_hiq_empty; 1697 1698 static void rtw_chk_hi_queue_hdl(struct adapter *padapter) 1699 { 1700 struct sta_info *psta_bmc; 1701 struct sta_priv *pstapriv = &padapter->stapriv; 1702 unsigned long start = jiffies; 1703 u8 empty = false; 1704 1705 psta_bmc = rtw_get_bcmc_stainfo(padapter); 1706 if (!psta_bmc) 1707 return; 1708 1709 rtw_hal_get_hwreg(padapter, HW_VAR_CHK_HI_QUEUE_EMPTY, &empty); 1710 1711 while (false == empty && jiffies_to_msecs(jiffies - start) < g_wait_hiq_empty) { 1712 msleep(100); 1713 rtw_hal_get_hwreg(padapter, HW_VAR_CHK_HI_QUEUE_EMPTY, &empty); 1714 } 1715 1716 if (psta_bmc->sleepq_len == 0) { 1717 if (empty == _SUCCESS) { 1718 bool update_tim = false; 1719 1720 if (pstapriv->tim_bitmap & BIT(0)) 1721 update_tim = true; 1722 1723 pstapriv->tim_bitmap &= ~BIT(0); 1724 pstapriv->sta_dz_bitmap &= ~BIT(0); 1725 1726 if (update_tim) 1727 update_beacon(padapter, _TIM_IE_, NULL, true); 1728 } else {/* re check again */ 1729 rtw_chk_hi_queue_cmd(padapter); 1730 } 1731 1732 } 1733 1734 } 1735 1736 u8 rtw_chk_hi_queue_cmd(struct adapter *padapter) 1737 { 1738 struct cmd_obj *ph2c; 1739 struct drvextra_cmd_parm *pdrvextra_cmd_parm; 1740 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1741 u8 res = _SUCCESS; 1742 1743 ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1744 if (ph2c == NULL) { 1745 res = _FAIL; 1746 goto exit; 1747 } 1748 1749 pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1750 if (pdrvextra_cmd_parm == NULL) { 1751 kfree(ph2c); 1752 res = _FAIL; 1753 goto exit; 1754 } 1755 1756 pdrvextra_cmd_parm->ec_id = CHECK_HIQ_WK_CID; 1757 pdrvextra_cmd_parm->type = 0; 1758 pdrvextra_cmd_parm->size = 0; 1759 pdrvextra_cmd_parm->pbuf = NULL; 1760 1761 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra)); 1762 1763 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 1764 1765 exit: 1766 1767 return res; 1768 1769 } 1770 1771 struct btinfo { 1772 u8 cid; 1773 u8 len; 1774 1775 u8 bConnection:1; 1776 u8 bSCOeSCO:1; 1777 u8 bInQPage:1; 1778 u8 bACLBusy:1; 1779 u8 bSCOBusy:1; 1780 u8 bHID:1; 1781 u8 bA2DP:1; 1782 u8 bFTP:1; 1783 1784 u8 retry_cnt:4; 1785 u8 rsvd_34:1; 1786 u8 rsvd_35:1; 1787 u8 rsvd_36:1; 1788 u8 rsvd_37:1; 1789 1790 u8 rssi; 1791 1792 u8 rsvd_50:1; 1793 u8 rsvd_51:1; 1794 u8 rsvd_52:1; 1795 u8 rsvd_53:1; 1796 u8 rsvd_54:1; 1797 u8 rsvd_55:1; 1798 u8 eSCO_SCO:1; 1799 u8 Master_Slave:1; 1800 1801 u8 rsvd_6; 1802 u8 rsvd_7; 1803 }; 1804 1805 static void rtw_btinfo_hdl(struct adapter *adapter, u8 *buf, u16 buf_len) 1806 { 1807 #define BTINFO_WIFI_FETCH 0x23 1808 #define BTINFO_BT_AUTO_RPT 0x27 1809 struct btinfo *info = (struct btinfo *)buf; 1810 u8 cmd_idx; 1811 u8 len; 1812 1813 cmd_idx = info->cid; 1814 1815 if (info->len > buf_len-2) { 1816 rtw_warn_on(1); 1817 len = buf_len-2; 1818 } else { 1819 len = info->len; 1820 } 1821 1822 /* define DBG_PROC_SET_BTINFO_EVT */ 1823 #ifdef DBG_PROC_SET_BTINFO_EVT 1824 btinfo_evt_dump(RTW_DBGDUMP, info); 1825 #endif 1826 1827 /* transform BT-FW btinfo to WiFI-FW C2H format and notify */ 1828 if (cmd_idx == BTINFO_WIFI_FETCH) 1829 buf[1] = 0; 1830 else if (cmd_idx == BTINFO_BT_AUTO_RPT) 1831 buf[1] = 2; 1832 rtw_btcoex_BtInfoNotify(adapter, len+1, &buf[1]); 1833 } 1834 1835 u8 rtw_c2h_packet_wk_cmd(struct adapter *padapter, u8 *pbuf, u16 length) 1836 { 1837 struct cmd_obj *ph2c; 1838 struct drvextra_cmd_parm *pdrvextra_cmd_parm; 1839 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1840 u8 res = _SUCCESS; 1841 1842 ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1843 if (ph2c == NULL) { 1844 res = _FAIL; 1845 goto exit; 1846 } 1847 1848 pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1849 if (pdrvextra_cmd_parm == NULL) { 1850 kfree(ph2c); 1851 res = _FAIL; 1852 goto exit; 1853 } 1854 1855 pdrvextra_cmd_parm->ec_id = C2H_WK_CID; 1856 pdrvextra_cmd_parm->type = 0; 1857 pdrvextra_cmd_parm->size = length; 1858 pdrvextra_cmd_parm->pbuf = pbuf; 1859 1860 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra)); 1861 1862 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 1863 1864 exit: 1865 return res; 1866 } 1867 1868 /* dont call R/W in this function, beucase SDIO interrupt have claim host */ 1869 /* or deadlock will happen and cause special-systemserver-died in android */ 1870 u8 rtw_c2h_wk_cmd(struct adapter *padapter, u8 *c2h_evt) 1871 { 1872 struct cmd_obj *ph2c; 1873 struct drvextra_cmd_parm *pdrvextra_cmd_parm; 1874 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1875 u8 res = _SUCCESS; 1876 1877 ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1878 if (ph2c == NULL) { 1879 res = _FAIL; 1880 goto exit; 1881 } 1882 1883 pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1884 if (pdrvextra_cmd_parm == NULL) { 1885 kfree(ph2c); 1886 res = _FAIL; 1887 goto exit; 1888 } 1889 1890 pdrvextra_cmd_parm->ec_id = C2H_WK_CID; 1891 pdrvextra_cmd_parm->type = 0; 1892 pdrvextra_cmd_parm->size = c2h_evt?16:0; 1893 pdrvextra_cmd_parm->pbuf = c2h_evt; 1894 1895 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra)); 1896 1897 res = rtw_enqueue_cmd(pcmdpriv, ph2c); 1898 1899 exit: 1900 1901 return res; 1902 } 1903 1904 static void c2h_wk_callback(_workitem *work) 1905 { 1906 struct evt_priv *evtpriv = container_of(work, struct evt_priv, c2h_wk); 1907 struct adapter *adapter = container_of(evtpriv, struct adapter, evtpriv); 1908 u8 *c2h_evt; 1909 c2h_id_filter ccx_id_filter = rtw_hal_c2h_id_filter_ccx(adapter); 1910 1911 evtpriv->c2h_wk_alive = true; 1912 1913 while (!rtw_cbuf_empty(evtpriv->c2h_queue)) { 1914 c2h_evt = (u8 *)rtw_cbuf_pop(evtpriv->c2h_queue); 1915 if (c2h_evt != NULL) { 1916 /* This C2H event is read, clear it */ 1917 c2h_evt_clear(adapter); 1918 } else { 1919 c2h_evt = rtw_malloc(16); 1920 if (c2h_evt != NULL) { 1921 /* This C2H event is not read, read & clear now */ 1922 if (c2h_evt_read_88xx(adapter, c2h_evt) != _SUCCESS) { 1923 kfree(c2h_evt); 1924 continue; 1925 } 1926 } 1927 } 1928 1929 /* Special pointer to trigger c2h_evt_clear only */ 1930 if ((void *)c2h_evt == (void *)evtpriv) 1931 continue; 1932 1933 if (!rtw_hal_c2h_valid(adapter, c2h_evt)) { 1934 kfree(c2h_evt); 1935 continue; 1936 } 1937 1938 if (ccx_id_filter(c2h_evt) == true) { 1939 /* Handle CCX report here */ 1940 rtw_hal_c2h_handler(adapter, c2h_evt); 1941 kfree(c2h_evt); 1942 } else { 1943 /* Enqueue into cmd_thread for others */ 1944 rtw_c2h_wk_cmd(adapter, c2h_evt); 1945 } 1946 } 1947 1948 evtpriv->c2h_wk_alive = false; 1949 } 1950 1951 u8 rtw_drvextra_cmd_hdl(struct adapter *padapter, unsigned char *pbuf) 1952 { 1953 struct drvextra_cmd_parm *pdrvextra_cmd; 1954 1955 if (!pbuf) 1956 return H2C_PARAMETERS_ERROR; 1957 1958 pdrvextra_cmd = (struct drvextra_cmd_parm *)pbuf; 1959 1960 switch (pdrvextra_cmd->ec_id) { 1961 case DYNAMIC_CHK_WK_CID:/* only primary padapter go to this cmd, but execute dynamic_chk_wk_hdl() for two interfaces */ 1962 dynamic_chk_wk_hdl(padapter); 1963 break; 1964 case POWER_SAVING_CTRL_WK_CID: 1965 rtw_ps_processor(padapter); 1966 break; 1967 case LPS_CTRL_WK_CID: 1968 lps_ctrl_wk_hdl(padapter, (u8)pdrvextra_cmd->type); 1969 break; 1970 case DM_IN_LPS_WK_CID: 1971 rtw_dm_in_lps_hdl(padapter); 1972 break; 1973 case LPS_CHANGE_DTIM_CID: 1974 rtw_lps_change_dtim_hdl(padapter, (u8)pdrvextra_cmd->type); 1975 break; 1976 case CHECK_HIQ_WK_CID: 1977 rtw_chk_hi_queue_hdl(padapter); 1978 break; 1979 /* add for CONFIG_IEEE80211W, none 11w can use it */ 1980 case RESET_SECURITYPRIV: 1981 rtw_reset_securitypriv(padapter); 1982 break; 1983 case FREE_ASSOC_RESOURCES: 1984 rtw_free_assoc_resources(padapter, 1); 1985 break; 1986 case C2H_WK_CID: 1987 rtw_hal_set_hwreg_with_buf(padapter, HW_VAR_C2H_HANDLE, pdrvextra_cmd->pbuf, pdrvextra_cmd->size); 1988 break; 1989 case DM_RA_MSK_WK_CID: 1990 rtw_dm_ra_mask_hdl(padapter, (struct sta_info *)pdrvextra_cmd->pbuf); 1991 break; 1992 case BTINFO_WK_CID: 1993 rtw_btinfo_hdl(padapter, pdrvextra_cmd->pbuf, pdrvextra_cmd->size); 1994 break; 1995 default: 1996 break; 1997 } 1998 1999 if (pdrvextra_cmd->pbuf && pdrvextra_cmd->size > 0) { 2000 kfree(pdrvextra_cmd->pbuf); 2001 } 2002 2003 return H2C_SUCCESS; 2004 } 2005 2006 void rtw_survey_cmd_callback(struct adapter *padapter, struct cmd_obj *pcmd) 2007 { 2008 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2009 2010 if (pcmd->res == H2C_DROPPED) { 2011 /* TODO: cancel timer and do timeout handler directly... */ 2012 /* need to make timeout handlerOS independent */ 2013 _set_timer(&pmlmepriv->scan_to_timer, 1); 2014 } else if (pcmd->res != H2C_SUCCESS) { 2015 _set_timer(&pmlmepriv->scan_to_timer, 1); 2016 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n ********Error: MgntActrtw_set_802_11_bssid_LIST_SCAN Fail ************\n\n.")); 2017 } 2018 2019 /* free cmd */ 2020 rtw_free_cmd_obj(pcmd); 2021 } 2022 2023 void rtw_disassoc_cmd_callback(struct adapter *padapter, struct cmd_obj *pcmd) 2024 { 2025 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2026 2027 if (pcmd->res != H2C_SUCCESS) { 2028 spin_lock_bh(&pmlmepriv->lock); 2029 set_fwstate(pmlmepriv, _FW_LINKED); 2030 spin_unlock_bh(&pmlmepriv->lock); 2031 2032 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n ***Error: disconnect_cmd_callback Fail ***\n.")); 2033 return; 2034 } 2035 /* free cmd */ 2036 rtw_free_cmd_obj(pcmd); 2037 } 2038 2039 void rtw_joinbss_cmd_callback(struct adapter *padapter, struct cmd_obj *pcmd) 2040 { 2041 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2042 2043 if (pcmd->res == H2C_DROPPED) { 2044 /* TODO: cancel timer and do timeout handler directly... */ 2045 /* need to make timeout handlerOS independent */ 2046 _set_timer(&pmlmepriv->assoc_timer, 1); 2047 } else if (pcmd->res != H2C_SUCCESS) { 2048 _set_timer(&pmlmepriv->assoc_timer, 1); 2049 } 2050 2051 rtw_free_cmd_obj(pcmd); 2052 } 2053 2054 void rtw_createbss_cmd_callback(struct adapter *padapter, struct cmd_obj *pcmd) 2055 { 2056 u8 timer_cancelled; 2057 struct sta_info *psta = NULL; 2058 struct wlan_network *pwlan = NULL; 2059 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2060 struct wlan_bssid_ex *pnetwork = (struct wlan_bssid_ex *)pcmd->parmbuf; 2061 struct wlan_network *tgt_network = &(pmlmepriv->cur_network); 2062 2063 if (pcmd->parmbuf == NULL) 2064 goto exit; 2065 2066 if ((pcmd->res != H2C_SUCCESS)) { 2067 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n ********Error: rtw_createbss_cmd_callback Fail ************\n\n.")); 2068 _set_timer(&pmlmepriv->assoc_timer, 1); 2069 } 2070 2071 _cancel_timer(&pmlmepriv->assoc_timer, &timer_cancelled); 2072 2073 spin_lock_bh(&pmlmepriv->lock); 2074 2075 2076 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) { 2077 psta = rtw_get_stainfo(&padapter->stapriv, pnetwork->MacAddress); 2078 if (!psta) { 2079 psta = rtw_alloc_stainfo(&padapter->stapriv, pnetwork->MacAddress); 2080 if (psta == NULL) { 2081 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\nCan't alloc sta_info when createbss_cmd_callback\n")); 2082 goto createbss_cmd_fail; 2083 } 2084 } 2085 2086 rtw_indicate_connect(padapter); 2087 } else { 2088 pwlan = rtw_alloc_network(pmlmepriv); 2089 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 2090 if (pwlan == NULL) { 2091 pwlan = rtw_get_oldest_wlan_network(&pmlmepriv->scanned_queue); 2092 if (pwlan == NULL) { 2093 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n Error: can't get pwlan in rtw_joinbss_event_callback\n")); 2094 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 2095 goto createbss_cmd_fail; 2096 } 2097 pwlan->last_scanned = jiffies; 2098 } else { 2099 list_add_tail(&(pwlan->list), &pmlmepriv->scanned_queue.queue); 2100 } 2101 2102 pnetwork->Length = get_wlan_bssid_ex_sz(pnetwork); 2103 memcpy(&(pwlan->network), pnetwork, pnetwork->Length); 2104 /* pwlan->fixed = true; */ 2105 2106 /* list_add_tail(&(pwlan->list), &pmlmepriv->scanned_queue.queue); */ 2107 2108 /* copy pdev_network information to pmlmepriv->cur_network */ 2109 memcpy(&tgt_network->network, pnetwork, (get_wlan_bssid_ex_sz(pnetwork))); 2110 2111 /* reset DSConfig */ 2112 /* tgt_network->network.Configuration.DSConfig = (u32)rtw_ch2freq(pnetwork->Configuration.DSConfig); */ 2113 2114 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 2115 2116 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 2117 /* we will set _FW_LINKED when there is one more sat to join us (rtw_stassoc_event_callback) */ 2118 2119 } 2120 2121 createbss_cmd_fail: 2122 2123 spin_unlock_bh(&pmlmepriv->lock); 2124 exit: 2125 rtw_free_cmd_obj(pcmd); 2126 } 2127 2128 2129 2130 void rtw_setstaKey_cmdrsp_callback(struct adapter *padapter, struct cmd_obj *pcmd) 2131 { 2132 2133 struct sta_priv *pstapriv = &padapter->stapriv; 2134 struct set_stakey_rsp *psetstakey_rsp = (struct set_stakey_rsp *) (pcmd->rsp); 2135 struct sta_info *psta = rtw_get_stainfo(pstapriv, psetstakey_rsp->addr); 2136 2137 if (psta == NULL) { 2138 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\nERROR: rtw_setstaKey_cmdrsp_callback => can't get sta_info\n\n")); 2139 goto exit; 2140 } 2141 exit: 2142 rtw_free_cmd_obj(pcmd); 2143 } 2144 2145 void rtw_setassocsta_cmdrsp_callback(struct adapter *padapter, struct cmd_obj *pcmd) 2146 { 2147 struct sta_priv *pstapriv = &padapter->stapriv; 2148 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2149 struct set_assocsta_parm *passocsta_parm = (struct set_assocsta_parm *)(pcmd->parmbuf); 2150 struct set_assocsta_rsp *passocsta_rsp = (struct set_assocsta_rsp *) (pcmd->rsp); 2151 struct sta_info *psta = rtw_get_stainfo(pstapriv, passocsta_parm->addr); 2152 2153 if (psta == NULL) { 2154 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\nERROR: setassocsta_cmdrsp_callbac => can't get sta_info\n\n")); 2155 goto exit; 2156 } 2157 2158 psta->aid = psta->mac_id = passocsta_rsp->cam_id; 2159 2160 spin_lock_bh(&pmlmepriv->lock); 2161 2162 if ((check_fwstate(pmlmepriv, WIFI_MP_STATE) == true) && (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true)) 2163 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 2164 2165 set_fwstate(pmlmepriv, _FW_LINKED); 2166 spin_unlock_bh(&pmlmepriv->lock); 2167 2168 exit: 2169 rtw_free_cmd_obj(pcmd); 2170 } 2171