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