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