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