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