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