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