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