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