1 /******************************************************************************
3 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19 ******************************************************************************/
22 #include <osdep_service.h>
23 #include <drv_types.h>
24 #include <recv_osdep.h>
25 #include <cmd_osdep.h>
26 #include <mlme_osdep.h>
27 #include <rtw_br_ext.h>
28 #include <rtw_mlme_ext.h>
31 Caller and the rtw_cmd_thread can protect cmd_q by spin_lock.
32 No irqsave is necessary.
35 int _rtw_init_cmd_priv(struct cmd_priv *pcmdpriv)
40 sema_init(&(pcmdpriv->cmd_queue_sema), 0);
41 /* sema_init(&(pcmdpriv->cmd_done_sema), 0); */
42 sema_init(&(pcmdpriv->terminate_cmdthread_sema), 0);
45 _rtw_init_queue(&(pcmdpriv->cmd_queue));
47 /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
49 pcmdpriv->cmd_seq = 1;
51 pcmdpriv->cmd_allocated_buf = rtw_zmalloc(MAX_CMDSZ + CMDBUFF_ALIGN_SZ);
53 if (pcmdpriv->cmd_allocated_buf == NULL) {
58 pcmdpriv->cmd_buf = pcmdpriv->cmd_allocated_buf + CMDBUFF_ALIGN_SZ - ((size_t)(pcmdpriv->cmd_allocated_buf) & (CMDBUFF_ALIGN_SZ-1));
60 pcmdpriv->rsp_allocated_buf = rtw_zmalloc(MAX_RSPSZ + 4);
62 if (pcmdpriv->rsp_allocated_buf == NULL) {
67 pcmdpriv->rsp_buf = pcmdpriv->rsp_allocated_buf + 4 - ((size_t)(pcmdpriv->rsp_allocated_buf) & 3);
69 pcmdpriv->cmd_issued_cnt = 0;
70 pcmdpriv->cmd_done_cnt = 0;
71 pcmdpriv->rsp_cnt = 0;
76 static void c2h_wk_callback(struct work_struct *work);
78 int _rtw_init_evt_priv(struct evt_priv *pevtpriv)
83 /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
84 atomic_set(&pevtpriv->event_seq, 0);
85 pevtpriv->evt_done_cnt = 0;
87 INIT_WORK(&pevtpriv->c2h_wk, c2h_wk_callback);
88 pevtpriv->c2h_wk_alive = false;
89 pevtpriv->c2h_queue = rtw_cbuf_alloc(C2H_QUEUE_MAX_LEN+1);
95 void rtw_free_evt_priv(struct evt_priv *pevtpriv)
98 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("+rtw_free_evt_priv\n"));
100 _cancel_workitem_sync(&pevtpriv->c2h_wk);
101 while (pevtpriv->c2h_wk_alive)
104 while (!rtw_cbuf_empty(pevtpriv->c2h_queue)) {
105 void *c2h = rtw_cbuf_pop(pevtpriv->c2h_queue);
106 if (c2h != NULL && c2h != (void *)pevtpriv)
109 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("-rtw_free_evt_priv\n"));
113 void _rtw_free_cmd_priv(struct cmd_priv *pcmdpriv)
117 kfree(pcmdpriv->cmd_allocated_buf);
118 kfree(pcmdpriv->rsp_allocated_buf);
125 rtw_enqueue_cmd can only be called between kernel thread,
126 since only spin_lock is used.
128 ISR/Call-Back functions can't call this sub-function.
132 int _rtw_enqueue_cmd(struct __queue *queue, struct cmd_obj *obj)
140 spin_lock_irqsave(&queue->lock, irqL);
142 rtw_list_insert_tail(&obj->list, &queue->queue);
144 spin_unlock_irqrestore(&queue->lock, irqL);
152 struct cmd_obj *_rtw_dequeue_cmd(struct __queue *queue)
158 spin_lock_irqsave(&queue->lock, irqL);
159 if (rtw_is_list_empty(&(queue->queue))) {
162 obj = container_of((&queue->queue)->next, struct cmd_obj, list);
163 rtw_list_delete(&obj->list);
166 spin_unlock_irqrestore(&queue->lock, irqL);
172 u32 rtw_init_cmd_priv(struct cmd_priv *pcmdpriv)
175 res = _rtw_init_cmd_priv(pcmdpriv);
179 u32 rtw_init_evt_priv(struct evt_priv *pevtpriv)
182 res = _rtw_init_evt_priv(pevtpriv);
186 void rtw_free_cmd_priv(struct cmd_priv *pcmdpriv)
188 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("rtw_free_cmd_priv\n"));
189 _rtw_free_cmd_priv(pcmdpriv);
192 static int rtw_cmd_filter(struct cmd_priv *pcmdpriv, struct cmd_obj *cmd_obj)
194 u8 bAllow = false; /* set to true to allow enqueuing cmd when hw_init_completed is false */
196 /* To decide allow or not */
197 if ((pcmdpriv->padapter->pwrctrlpriv.bHWPwrPindetect) &&
198 (!pcmdpriv->padapter->registrypriv.usbss_enable)) {
199 if (cmd_obj->cmdcode == GEN_CMD_CODE(_Set_Drv_Extra)) {
200 struct drvextra_cmd_parm *pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)cmd_obj->parmbuf;
201 if (pdrvextra_cmd_parm->ec_id == POWER_SAVING_CTRL_WK_CID)
206 if (cmd_obj->cmdcode == GEN_CMD_CODE(_SetChannelPlan))
209 if ((!pcmdpriv->padapter->hw_init_completed && !bAllow) ||
210 !pcmdpriv->cmdthd_running) /* com_thread not running */
215 u32 rtw_enqueue_cmd(struct cmd_priv *pcmdpriv, struct cmd_obj *cmd_obj)
218 struct adapter *padapter = pcmdpriv->padapter;
224 cmd_obj->padapter = padapter;
226 res = rtw_cmd_filter(pcmdpriv, cmd_obj);
228 rtw_free_cmd_obj(cmd_obj);
232 res = _rtw_enqueue_cmd(&pcmdpriv->cmd_queue, cmd_obj);
235 up(&pcmdpriv->cmd_queue_sema);
243 struct cmd_obj *rtw_dequeue_cmd(struct cmd_priv *pcmdpriv)
245 struct cmd_obj *cmd_obj;
248 cmd_obj = _rtw_dequeue_cmd(&pcmdpriv->cmd_queue);
253 void rtw_cmd_clr_isr(struct cmd_priv *pcmdpriv)
255 pcmdpriv->cmd_done_cnt++;
256 /* up(&(pcmdpriv->cmd_done_sema)); */
259 void rtw_free_cmd_obj(struct cmd_obj *pcmd)
262 if ((pcmd->cmdcode != _JoinBss_CMD_) && (pcmd->cmdcode != _CreateBss_CMD_)) {
263 /* free parmbuf in cmd_obj */
264 kfree(pcmd->parmbuf);
267 if (pcmd->rsp != NULL) {
268 if (pcmd->rspsz != 0) {
269 /* free rsp in cmd_obj */
279 int rtw_cmd_thread(void *context)
282 struct cmd_obj *pcmd;
284 u8 (*cmd_hdl)(struct adapter *padapter, u8 *pbuf);
285 void (*pcmd_callback)(struct adapter *dev, struct cmd_obj *pcmd);
286 struct adapter *padapter = (struct adapter *)context;
287 struct cmd_priv *pcmdpriv = &(padapter->cmdpriv);
290 thread_enter("RTW_CMD_THREAD");
292 pcmdbuf = pcmdpriv->cmd_buf;
294 pcmdpriv->cmdthd_running = true;
295 up(&pcmdpriv->terminate_cmdthread_sema);
297 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("start r871x rtw_cmd_thread !!!!\n"));
300 if (_rtw_down_sema(&pcmdpriv->cmd_queue_sema) == _FAIL)
303 if (padapter->bDriverStopped ||
304 padapter->bSurpriseRemoved) {
305 DBG_88E("%s: DriverStopped(%d) SurpriseRemoved(%d) break at line %d\n",
306 __func__, padapter->bDriverStopped, padapter->bSurpriseRemoved, __LINE__);
310 if (padapter->bDriverStopped ||
311 padapter->bSurpriseRemoved) {
312 DBG_88E("%s: DriverStopped(%d) SurpriseRemoved(%d) break at line %d\n",
313 __func__, padapter->bDriverStopped, padapter->bSurpriseRemoved, __LINE__);
317 pcmd = rtw_dequeue_cmd(pcmdpriv);
321 if (_FAIL == rtw_cmd_filter(pcmdpriv, pcmd)) {
322 pcmd->res = H2C_DROPPED;
326 pcmdpriv->cmd_issued_cnt++;
328 pcmd->cmdsz = _RND4((pcmd->cmdsz));/* _RND4 */
330 memcpy(pcmdbuf, pcmd->parmbuf, pcmd->cmdsz);
332 if (pcmd->cmdcode < ARRAY_SIZE(wlancmds)) {
333 cmd_hdl = wlancmds[pcmd->cmdcode].h2cfuns;
336 ret = cmd_hdl(pcmd->padapter, pcmdbuf);
342 pcmd->res = H2C_PARAMETERS_ERROR;
349 /* call callback function for post-processed */
350 if (pcmd->cmdcode < ARRAY_SIZE(rtw_cmd_callback)) {
351 pcmd_callback = rtw_cmd_callback[pcmd->cmdcode].callback;
352 if (pcmd_callback == NULL) {
353 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("mlme_cmd_hdl(): pcmd_callback = 0x%p, cmdcode = 0x%x\n", pcmd_callback, pcmd->cmdcode));
354 rtw_free_cmd_obj(pcmd);
356 /* todo: !!! fill rsp_buf to pcmd->rsp if (pcmd->rsp!= NULL) */
357 pcmd_callback(pcmd->padapter, pcmd);/* need conider that free cmd_obj in rtw_cmd_callback */
360 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("%s: cmdcode = 0x%x callback not defined!\n", __func__, pcmd->cmdcode));
361 rtw_free_cmd_obj(pcmd);
364 flush_signals_thread();
368 pcmdpriv->cmdthd_running = false;
370 /* free all cmd_obj resources */
372 pcmd = rtw_dequeue_cmd(pcmdpriv);
376 /* DBG_88E("%s: leaving... drop cmdcode:%u\n", __func__, pcmd->cmdcode); */
378 rtw_free_cmd_obj(pcmd);
381 up(&pcmdpriv->terminate_cmdthread_sema);
384 complete_and_exit(NULL, 0);
387 u8 rtw_setstandby_cmd(struct adapter *padapter, uint action)
389 struct cmd_obj *ph2c;
390 struct usb_suspend_parm *psetusbsuspend;
391 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
396 ph2c = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
402 psetusbsuspend = kzalloc(sizeof(struct usb_suspend_parm), GFP_KERNEL);
403 if (psetusbsuspend == NULL) {
409 psetusbsuspend->action = action;
411 init_h2fwcmd_w_parm_no_rsp(ph2c, psetusbsuspend, GEN_CMD_CODE(_SetUsbSuspend));
413 ret = rtw_enqueue_cmd(pcmdpriv, ph2c);
422 rtw_sitesurvey_cmd(~)
424 MUST TAKE CARE THAT BEFORE CALLING THIS FUNC, YOU SHOULD HAVE LOCKED pmlmepriv->lock
426 u8 rtw_sitesurvey_cmd(struct adapter *padapter, struct ndis_802_11_ssid *ssid, int ssid_num,
427 struct rtw_ieee80211_channel *ch, int ch_num)
430 struct cmd_obj *ph2c;
431 struct sitesurvey_parm *psurveyPara;
432 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
433 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
435 if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
436 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_SCAN, 1);
438 if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
439 p2p_ps_wk_cmd(padapter, P2P_PS_SCAN, 1);
441 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
445 psurveyPara = (struct sitesurvey_parm *)rtw_zmalloc(sizeof(struct sitesurvey_parm));
446 if (psurveyPara == NULL) {
451 rtw_free_network_queue(padapter, false);
453 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("%s: flush network queue\n", __func__));
455 init_h2fwcmd_w_parm_no_rsp(ph2c, psurveyPara, GEN_CMD_CODE(_SiteSurvey));
457 /* psurveyPara->bsslimit = 48; */
458 psurveyPara->scan_mode = pmlmepriv->scan_mode;
460 /* prepare ssid list */
463 for (i = 0; i < ssid_num && i < RTW_SSID_SCAN_AMOUNT; i++) {
464 if (ssid[i].SsidLength) {
465 memcpy(&psurveyPara->ssid[i], &ssid[i], sizeof(struct ndis_802_11_ssid));
466 psurveyPara->ssid_num++;
471 /* prepare channel list */
474 for (i = 0; i < ch_num && i < RTW_CHANNEL_SCAN_AMOUNT; i++) {
475 if (ch[i].hw_value && !(ch[i].flags & RTW_IEEE80211_CHAN_DISABLED)) {
476 memcpy(&psurveyPara->ch[i], &ch[i], sizeof(struct rtw_ieee80211_channel));
477 psurveyPara->ch_num++;
482 set_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
484 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
486 if (res == _SUCCESS) {
487 pmlmepriv->scan_start_time = jiffies;
489 _set_timer(&pmlmepriv->scan_to_timer, SCANNING_TIMEOUT);
491 rtw_led_control(padapter, LED_CTL_SITE_SURVEY);
493 pmlmepriv->scan_interval = SCAN_INTERVAL;/* 30*2 sec = 60sec */
495 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
502 u8 rtw_setdatarate_cmd(struct adapter *padapter, u8 *rateset)
504 struct cmd_obj *ph2c;
505 struct setdatarate_parm *pbsetdataratepara;
506 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
510 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
516 pbsetdataratepara = (struct setdatarate_parm *)rtw_zmalloc(sizeof(struct setdatarate_parm));
517 if (pbsetdataratepara == NULL) {
523 init_h2fwcmd_w_parm_no_rsp(ph2c, pbsetdataratepara, GEN_CMD_CODE(_SetDataRate));
524 pbsetdataratepara->mac_id = 5;
525 memcpy(pbsetdataratepara->datarates, rateset, NumRates);
526 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
533 u8 rtw_setbasicrate_cmd(struct adapter *padapter, u8 *rateset)
535 struct cmd_obj *ph2c;
536 struct setbasicrate_parm *pssetbasicratepara;
537 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
541 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
546 pssetbasicratepara = (struct setbasicrate_parm *)rtw_zmalloc(sizeof(struct setbasicrate_parm));
548 if (pssetbasicratepara == NULL) {
554 init_h2fwcmd_w_parm_no_rsp(ph2c, pssetbasicratepara, _SetBasicRate_CMD_);
556 memcpy(pssetbasicratepara->basicrates, rateset, NumRates);
558 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
567 unsigned char rtw_setphy_cmd(unsigned char *adapter)
569 1. be called only after rtw_update_registrypriv_dev_network(~) or mp testing program
570 2. for AdHoc/Ap mode or mp mode?
573 u8 rtw_setphy_cmd(struct adapter *padapter, u8 modem, u8 ch)
575 struct cmd_obj *ph2c;
576 struct setphy_parm *psetphypara;
577 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
581 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
586 psetphypara = (struct setphy_parm *)rtw_zmalloc(sizeof(struct setphy_parm));
588 if (psetphypara == NULL) {
594 init_h2fwcmd_w_parm_no_rsp(ph2c, psetphypara, _SetPhy_CMD_);
596 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("CH =%d, modem =%d", ch, modem));
598 psetphypara->modem = modem;
599 psetphypara->rfchannel = ch;
601 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
606 u8 rtw_setbbreg_cmd(struct adapter *padapter, u8 offset, u8 val)
608 struct cmd_obj *ph2c;
609 struct writeBB_parm *pwritebbparm;
610 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
613 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
618 pwritebbparm = (struct writeBB_parm *)rtw_zmalloc(sizeof(struct writeBB_parm));
620 if (pwritebbparm == NULL) {
626 init_h2fwcmd_w_parm_no_rsp(ph2c, pwritebbparm, GEN_CMD_CODE(_SetBBReg));
628 pwritebbparm->offset = offset;
629 pwritebbparm->value = val;
631 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
636 u8 rtw_getbbreg_cmd(struct adapter *padapter, u8 offset, u8 *pval)
638 struct cmd_obj *ph2c;
639 struct readBB_parm *prdbbparm;
640 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
643 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
648 prdbbparm = (struct readBB_parm *)rtw_zmalloc(sizeof(struct readBB_parm));
650 if (prdbbparm == NULL) {
655 _rtw_init_listhead(&ph2c->list);
656 ph2c->cmdcode = GEN_CMD_CODE(_GetBBReg);
657 ph2c->parmbuf = (unsigned char *)prdbbparm;
658 ph2c->cmdsz = sizeof(struct readBB_parm);
660 ph2c->rspsz = sizeof(struct readBB_rsp);
662 prdbbparm->offset = offset;
664 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
669 u8 rtw_setrfreg_cmd(struct adapter *padapter, u8 offset, u32 val)
671 struct cmd_obj *ph2c;
672 struct writeRF_parm *pwriterfparm;
673 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
675 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
680 pwriterfparm = (struct writeRF_parm *)rtw_zmalloc(sizeof(struct writeRF_parm));
682 if (pwriterfparm == NULL) {
688 init_h2fwcmd_w_parm_no_rsp(ph2c, pwriterfparm, GEN_CMD_CODE(_SetRFReg));
690 pwriterfparm->offset = offset;
691 pwriterfparm->value = val;
693 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
698 u8 rtw_getrfreg_cmd(struct adapter *padapter, u8 offset, u8 *pval)
700 struct cmd_obj *ph2c;
701 struct readRF_parm *prdrfparm;
702 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
706 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
712 prdrfparm = (struct readRF_parm *)rtw_zmalloc(sizeof(struct readRF_parm));
713 if (prdrfparm == NULL) {
719 _rtw_init_listhead(&ph2c->list);
720 ph2c->cmdcode = GEN_CMD_CODE(_GetRFReg);
721 ph2c->parmbuf = (unsigned char *)prdrfparm;
722 ph2c->cmdsz = sizeof(struct readRF_parm);
724 ph2c->rspsz = sizeof(struct readRF_rsp);
726 prdrfparm->offset = offset;
728 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
736 void rtw_getbbrfreg_cmdrsp_callback(struct adapter *padapter, struct cmd_obj *pcmd)
739 kfree(pcmd->parmbuf);
742 if (padapter->registrypriv.mp_mode == 1)
743 padapter->mppriv.workparam.bcompleted = true;
746 void rtw_readtssi_cmdrsp_callback(struct adapter *padapter, struct cmd_obj *pcmd)
749 kfree(pcmd->parmbuf);
752 if (padapter->registrypriv.mp_mode == 1)
753 padapter->mppriv.workparam.bcompleted = true;
756 u8 rtw_createbss_cmd(struct adapter *padapter)
758 struct cmd_obj *pcmd;
759 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
760 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
761 struct wlan_bssid_ex *pdev_network = &padapter->registrypriv.dev_network;
765 rtw_led_control(padapter, LED_CTL_START_TO_LINK);
767 if (pmlmepriv->assoc_ssid.SsidLength == 0)
768 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, (" createbss for Any SSid:%s\n", pmlmepriv->assoc_ssid.Ssid));
770 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, (" createbss for SSid:%s\n", pmlmepriv->assoc_ssid.Ssid));
772 pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
778 _rtw_init_listhead(&pcmd->list);
779 pcmd->cmdcode = _CreateBss_CMD_;
780 pcmd->parmbuf = (unsigned char *)pdev_network;
781 pcmd->cmdsz = get_wlan_bssid_ex_sz((struct wlan_bssid_ex *)pdev_network);
784 pdev_network->Length = pcmd->cmdsz;
785 res = rtw_enqueue_cmd(pcmdpriv, pcmd);
792 u8 rtw_createbss_cmd_ex(struct adapter *padapter, unsigned char *pbss, unsigned int sz)
794 struct cmd_obj *pcmd;
795 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
799 pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
805 _rtw_init_listhead(&pcmd->list);
806 pcmd->cmdcode = GEN_CMD_CODE(_CreateBss);
807 pcmd->parmbuf = pbss;
812 res = rtw_enqueue_cmd(pcmdpriv, pcmd);
820 u8 rtw_joinbss_cmd(struct adapter *padapter, struct wlan_network *pnetwork)
824 struct wlan_bssid_ex *psecnetwork;
825 struct cmd_obj *pcmd;
826 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
827 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
828 struct qos_priv *pqospriv = &pmlmepriv->qospriv;
829 struct security_priv *psecuritypriv = &padapter->securitypriv;
830 struct registry_priv *pregistrypriv = &padapter->registrypriv;
831 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
832 enum ndis_802_11_network_infra ndis_network_mode = pnetwork->network.InfrastructureMode;
833 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
834 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
837 rtw_led_control(padapter, LED_CTL_START_TO_LINK);
839 if (pmlmepriv->assoc_ssid.SsidLength == 0)
840 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("+Join cmd: Any SSid\n"));
842 RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+Join cmd: SSid =[%s]\n", pmlmepriv->assoc_ssid.Ssid));
844 pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
847 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("rtw_joinbss_cmd: memory allocate for cmd_obj fail!!!\n"));
850 /* for IEs is fix buf size */
851 t_len = sizeof(struct wlan_bssid_ex);
854 /* for hidden ap to set fw_state here */
855 if (!check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_ADHOC_STATE)) {
856 switch (ndis_network_mode) {
858 set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
860 case Ndis802_11Infrastructure:
861 set_fwstate(pmlmepriv, WIFI_STATION_STATE);
863 case Ndis802_11APMode:
864 case Ndis802_11AutoUnknown:
865 case Ndis802_11InfrastructureMax:
870 psecnetwork = (struct wlan_bssid_ex *)&psecuritypriv->sec_bss;
871 if (psecnetwork == NULL) {
877 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("rtw_joinbss_cmd :psecnetwork == NULL!!!\n"));
882 _rtw_memset(psecnetwork, 0, t_len);
884 memcpy(psecnetwork, &pnetwork->network, get_wlan_bssid_ex_sz(&pnetwork->network));
886 psecuritypriv->authenticator_ie[0] = (unsigned char)psecnetwork->IELength;
888 if ((psecnetwork->IELength-12) < (256-1))
889 memcpy(&psecuritypriv->authenticator_ie[1], &psecnetwork->IEs[12], psecnetwork->IELength-12);
891 memcpy(&psecuritypriv->authenticator_ie[1], &psecnetwork->IEs[12], (256-1));
893 psecnetwork->IELength = 0;
894 /* Added by Albert 2009/02/18 */
895 /* If the the driver wants to use the bssid to create the connection. */
896 /* If not, we have to copy the connecting AP's MAC address to it so that */
897 /* the driver just has the bssid information for PMKIDList searching. */
899 if (!pmlmepriv->assoc_by_bssid)
900 memcpy(&pmlmepriv->assoc_bssid[0], &pnetwork->network.MacAddress[0], ETH_ALEN);
902 psecnetwork->IELength = rtw_restruct_sec_ie(padapter, &pnetwork->network.IEs[0], &psecnetwork->IEs[0], pnetwork->network.IELength);
905 pqospriv->qos_option = 0;
907 if (pregistrypriv->wmm_enable) {
910 tmp_len = rtw_restruct_wmm_ie(padapter, &pnetwork->network.IEs[0], &psecnetwork->IEs[0], pnetwork->network.IELength, psecnetwork->IELength);
912 if (psecnetwork->IELength != tmp_len) {
913 psecnetwork->IELength = tmp_len;
914 pqospriv->qos_option = 1; /* There is WMM IE in this corresp. beacon */
916 pqospriv->qos_option = 0;/* There is no WMM IE in this corresp. beacon */
920 phtpriv->ht_option = false;
921 if (pregistrypriv->ht_enable) {
923 * Added by Albert 2010/06/23
924 * For the WEP mode, we will use the bg mode to do
925 * the connection to avoid some IOT issue.
926 * Especially for Realtek 8192u SoftAP.
928 if ((padapter->securitypriv.dot11PrivacyAlgrthm != _WEP40_) &&
929 (padapter->securitypriv.dot11PrivacyAlgrthm != _WEP104_) &&
930 (padapter->securitypriv.dot11PrivacyAlgrthm != _TKIP_)) {
931 /* rtw_restructure_ht_ie */
932 rtw_restructure_ht_ie(padapter, &pnetwork->network.IEs[0], &psecnetwork->IEs[0],
933 pnetwork->network.IELength, &psecnetwork->IELength);
937 pmlmeinfo->assoc_AP_vendor = check_assoc_AP(pnetwork->network.IEs, pnetwork->network.IELength);
939 if (pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_TENDA)
940 padapter->pwrctrlpriv.smart_ps = 0;
942 padapter->pwrctrlpriv.smart_ps = padapter->registrypriv.smart_ps;
944 DBG_88E("%s: smart_ps =%d\n", __func__, padapter->pwrctrlpriv.smart_ps);
946 pcmd->cmdsz = get_wlan_bssid_ex_sz(psecnetwork);/* get cmdsz before endian conversion */
948 _rtw_init_listhead(&pcmd->list);
949 pcmd->cmdcode = _JoinBss_CMD_;/* GEN_CMD_CODE(_JoinBss) */
950 pcmd->parmbuf = (unsigned char *)psecnetwork;
954 res = rtw_enqueue_cmd(pcmdpriv, pcmd);
962 u8 rtw_disassoc_cmd(struct adapter *padapter, u32 deauth_timeout_ms, bool enqueue) /* for sta_mode */
964 struct cmd_obj *cmdobj = NULL;
965 struct disconnect_parm *param = NULL;
966 struct cmd_priv *cmdpriv = &padapter->cmdpriv;
970 RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+rtw_disassoc_cmd\n"));
972 /* prepare cmd parameter */
973 param = (struct disconnect_parm *)rtw_zmalloc(sizeof(*param));
978 param->deauth_timeout_ms = deauth_timeout_ms;
981 /* need enqueue, prepare cmd_obj and enqueue */
982 cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(*cmdobj));
983 if (cmdobj == NULL) {
988 init_h2fwcmd_w_parm_no_rsp(cmdobj, param, _DisConnect_CMD_);
989 res = rtw_enqueue_cmd(cmdpriv, cmdobj);
991 /* no need to enqueue, do the cmd hdl directly and free cmd parameter */
992 if (H2C_SUCCESS != disconnect_hdl(padapter, (u8 *)param))
1003 u8 rtw_setopmode_cmd(struct adapter *padapter, enum ndis_802_11_network_infra networktype)
1005 struct cmd_obj *ph2c;
1006 struct setopmode_parm *psetop;
1008 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1012 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1017 psetop = (struct setopmode_parm *)rtw_zmalloc(sizeof(struct setopmode_parm));
1019 if (psetop == NULL) {
1025 init_h2fwcmd_w_parm_no_rsp(ph2c, psetop, _SetOpMode_CMD_);
1026 psetop->mode = (u8)networktype;
1028 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1036 u8 rtw_setstakey_cmd(struct adapter *padapter, u8 *psta, u8 unicast_key)
1038 struct cmd_obj *ph2c;
1039 struct set_stakey_parm *psetstakey_para;
1040 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1041 struct set_stakey_rsp *psetstakey_rsp = NULL;
1043 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1044 struct security_priv *psecuritypriv = &padapter->securitypriv;
1045 struct sta_info *sta = (struct sta_info *)psta;
1049 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1055 psetstakey_para = (struct set_stakey_parm *)rtw_zmalloc(sizeof(struct set_stakey_parm));
1056 if (psetstakey_para == NULL) {
1062 psetstakey_rsp = (struct set_stakey_rsp *)rtw_zmalloc(sizeof(struct set_stakey_rsp));
1063 if (psetstakey_rsp == NULL) {
1065 kfree(psetstakey_para);
1070 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_);
1071 ph2c->rsp = (u8 *)psetstakey_rsp;
1072 ph2c->rspsz = sizeof(struct set_stakey_rsp);
1074 ether_addr_copy(psetstakey_para->addr, sta->hwaddr);
1076 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
1077 psetstakey_para->algorithm = (unsigned char) psecuritypriv->dot11PrivacyAlgrthm;
1079 GET_ENCRY_ALGO(psecuritypriv, sta, psetstakey_para->algorithm, false);
1082 memcpy(&psetstakey_para->key, &sta->dot118021x_UncstKey, 16);
1084 memcpy(&psetstakey_para->key, &psecuritypriv->dot118021XGrpKey[psecuritypriv->dot118021XGrpKeyid].skey, 16);
1086 /* jeff: set this because at least sw key is ready */
1087 padapter->securitypriv.busetkipkey = true;
1089 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1097 u8 rtw_clearstakey_cmd(struct adapter *padapter, u8 *psta, u8 entry, u8 enqueue)
1099 struct cmd_obj *ph2c;
1100 struct set_stakey_parm *psetstakey_para;
1101 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1102 struct set_stakey_rsp *psetstakey_rsp = NULL;
1103 struct sta_info *sta = (struct sta_info *)psta;
1108 clear_cam_entry(padapter, entry);
1110 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1116 psetstakey_para = (struct set_stakey_parm *)rtw_zmalloc(sizeof(struct set_stakey_parm));
1117 if (psetstakey_para == NULL) {
1123 psetstakey_rsp = (struct set_stakey_rsp *)rtw_zmalloc(sizeof(struct set_stakey_rsp));
1124 if (psetstakey_rsp == NULL) {
1126 kfree(psetstakey_para);
1131 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_);
1132 ph2c->rsp = (u8 *)psetstakey_rsp;
1133 ph2c->rspsz = sizeof(struct set_stakey_rsp);
1135 ether_addr_copy(psetstakey_para->addr, sta->hwaddr);
1137 psetstakey_para->algorithm = _NO_PRIVACY_;
1139 psetstakey_para->id = entry;
1141 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1149 u8 rtw_setrttbl_cmd(struct adapter *padapter, struct setratable_parm *prate_table)
1151 struct cmd_obj *ph2c;
1152 struct setratable_parm *psetrttblparm;
1153 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1156 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1161 psetrttblparm = (struct setratable_parm *)rtw_zmalloc(sizeof(struct setratable_parm));
1163 if (psetrttblparm == NULL) {
1169 init_h2fwcmd_w_parm_no_rsp(ph2c, psetrttblparm, GEN_CMD_CODE(_SetRaTable));
1171 memcpy(psetrttblparm, prate_table, sizeof(struct setratable_parm));
1173 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1178 u8 rtw_getrttbl_cmd(struct adapter *padapter, struct getratable_rsp *pval)
1180 struct cmd_obj *ph2c;
1181 struct getratable_parm *pgetrttblparm;
1182 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1185 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1190 pgetrttblparm = (struct getratable_parm *)rtw_zmalloc(sizeof(struct getratable_parm));
1192 if (pgetrttblparm == NULL) {
1198 _rtw_init_listhead(&ph2c->list);
1199 ph2c->cmdcode = GEN_CMD_CODE(_GetRaTable);
1200 ph2c->parmbuf = (unsigned char *)pgetrttblparm;
1201 ph2c->cmdsz = sizeof(struct getratable_parm);
1202 ph2c->rsp = (u8 *)pval;
1203 ph2c->rspsz = sizeof(struct getratable_rsp);
1205 pgetrttblparm->rsvd = 0x0;
1207 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1212 u8 rtw_setassocsta_cmd(struct adapter *padapter, u8 *mac_addr)
1214 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1215 struct cmd_obj *ph2c;
1216 struct set_assocsta_parm *psetassocsta_para;
1217 struct set_stakey_rsp *psetassocsta_rsp = NULL;
1222 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1228 psetassocsta_para = (struct set_assocsta_parm *)rtw_zmalloc(sizeof(struct set_assocsta_parm));
1229 if (psetassocsta_para == NULL) {
1235 psetassocsta_rsp = (struct set_stakey_rsp *)rtw_zmalloc(sizeof(struct set_assocsta_rsp));
1236 if (psetassocsta_rsp == NULL) {
1238 kfree(psetassocsta_para);
1242 init_h2fwcmd_w_parm_no_rsp(ph2c, psetassocsta_para, _SetAssocSta_CMD_);
1243 ph2c->rsp = (u8 *)psetassocsta_rsp;
1244 ph2c->rspsz = sizeof(struct set_assocsta_rsp);
1246 ether_addr_copy(psetassocsta_para->addr, mac_addr);
1248 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1256 u8 rtw_addbareq_cmd(struct adapter *padapter, u8 tid, u8 *addr)
1258 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1259 struct cmd_obj *ph2c;
1260 struct addBaReq_parm *paddbareq_parm;
1264 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1270 paddbareq_parm = (struct addBaReq_parm *)rtw_zmalloc(sizeof(struct addBaReq_parm));
1271 if (paddbareq_parm == NULL) {
1277 paddbareq_parm->tid = tid;
1278 memcpy(paddbareq_parm->addr, addr, ETH_ALEN);
1280 init_h2fwcmd_w_parm_no_rsp(ph2c, paddbareq_parm, GEN_CMD_CODE(_AddBAReq));
1282 /* DBG_88E("rtw_addbareq_cmd, tid =%d\n", tid); */
1284 /* rtw_enqueue_cmd(pcmdpriv, ph2c); */
1285 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1293 u8 rtw_dynamic_chk_wk_cmd(struct adapter *padapter)
1295 struct cmd_obj *ph2c;
1296 struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1297 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1301 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1307 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1308 if (pdrvextra_cmd_parm == NULL) {
1314 pdrvextra_cmd_parm->ec_id = DYNAMIC_CHK_WK_CID;
1315 pdrvextra_cmd_parm->type_size = 0;
1316 pdrvextra_cmd_parm->pbuf = (u8 *)padapter;
1318 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1321 /* rtw_enqueue_cmd(pcmdpriv, ph2c); */
1322 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1327 u8 rtw_set_ch_cmd(struct adapter *padapter, u8 ch, u8 bw, u8 ch_offset, u8 enqueue)
1329 struct cmd_obj *pcmdobj;
1330 struct set_ch_parm *set_ch_parm;
1331 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1336 DBG_88E(FUNC_NDEV_FMT" ch:%u, bw:%u, ch_offset:%u\n",
1337 FUNC_NDEV_ARG(padapter->pnetdev), ch, bw, ch_offset);
1339 /* check input parameter */
1341 /* prepare cmd parameter */
1342 set_ch_parm = (struct set_ch_parm *)rtw_zmalloc(sizeof(*set_ch_parm));
1343 if (set_ch_parm == NULL) {
1347 set_ch_parm->ch = ch;
1348 set_ch_parm->bw = bw;
1349 set_ch_parm->ch_offset = ch_offset;
1352 /* need enqueue, prepare cmd_obj and enqueue */
1353 pcmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1354 if (pcmdobj == NULL) {
1360 init_h2fwcmd_w_parm_no_rsp(pcmdobj, set_ch_parm, GEN_CMD_CODE(_SetChannel));
1361 res = rtw_enqueue_cmd(pcmdpriv, pcmdobj);
1363 /* no need to enqueue, do the cmd hdl directly and free cmd parameter */
1364 if (H2C_SUCCESS != set_ch_hdl(padapter, (u8 *)set_ch_parm))
1370 /* do something based on res... */
1374 DBG_88E(FUNC_NDEV_FMT" res:%u\n", FUNC_NDEV_ARG(padapter->pnetdev), res);
1380 u8 rtw_set_chplan_cmd(struct adapter *padapter, u8 chplan, u8 enqueue)
1382 struct cmd_obj *pcmdobj;
1383 struct SetChannelPlan_param *setChannelPlan_param;
1384 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1389 RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+rtw_set_chplan_cmd\n"));
1391 /* check input parameter */
1392 if (!rtw_is_channel_plan_valid(chplan)) {
1397 /* prepare cmd parameter */
1398 setChannelPlan_param = (struct SetChannelPlan_param *)rtw_zmalloc(sizeof(struct SetChannelPlan_param));
1399 if (setChannelPlan_param == NULL) {
1403 setChannelPlan_param->channel_plan = chplan;
1406 /* need enqueue, prepare cmd_obj and enqueue */
1407 pcmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1408 if (pcmdobj == NULL) {
1409 kfree(setChannelPlan_param);
1414 init_h2fwcmd_w_parm_no_rsp(pcmdobj, setChannelPlan_param, GEN_CMD_CODE(_SetChannelPlan));
1415 res = rtw_enqueue_cmd(pcmdpriv, pcmdobj);
1417 /* no need to enqueue, do the cmd hdl directly and free cmd parameter */
1418 if (H2C_SUCCESS != set_chplan_hdl(padapter, (unsigned char *)setChannelPlan_param))
1421 kfree(setChannelPlan_param);
1424 /* do something based on res... */
1425 if (res == _SUCCESS)
1426 padapter->mlmepriv.ChannelPlan = chplan;
1434 u8 rtw_set_csa_cmd(struct adapter *padapter, u8 new_ch_no)
1436 struct cmd_obj *pcmdobj;
1437 struct SetChannelSwitch_param *setChannelSwitch_param;
1438 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1443 RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+rtw_set_csa_cmd\n"));
1445 pcmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1446 if (pcmdobj == NULL) {
1451 setChannelSwitch_param = (struct SetChannelSwitch_param *)rtw_zmalloc(sizeof(struct SetChannelSwitch_param));
1452 if (setChannelSwitch_param == NULL) {
1458 setChannelSwitch_param->new_ch_no = new_ch_no;
1460 init_h2fwcmd_w_parm_no_rsp(pcmdobj, setChannelSwitch_param, GEN_CMD_CODE(_SetChannelSwitch));
1461 res = rtw_enqueue_cmd(pcmdpriv, pcmdobj);
1469 u8 rtw_tdls_cmd(struct adapter *padapter, u8 *addr, u8 option)
1474 static void traffic_status_watchdog(struct adapter *padapter)
1477 u8 bBusyTraffic = false, bTxBusyTraffic = false, bRxBusyTraffic = false;
1478 u8 bHigherBusyTraffic = false, bHigherBusyRxTraffic = false, bHigherBusyTxTraffic = false;
1479 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1482 /* Determine if our traffic is busy now */
1484 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
1485 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > 100 ||
1486 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod > 100) {
1487 bBusyTraffic = true;
1489 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > pmlmepriv->LinkDetectInfo.NumTxOkInPeriod)
1490 bRxBusyTraffic = true;
1492 bTxBusyTraffic = true;
1495 /* Higher Tx/Rx data. */
1496 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > 4000 ||
1497 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod > 4000) {
1498 bHigherBusyTraffic = true;
1500 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > pmlmepriv->LinkDetectInfo.NumTxOkInPeriod)
1501 bHigherBusyRxTraffic = true;
1503 bHigherBusyTxTraffic = true;
1506 /* check traffic for powersaving. */
1507 if (((pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod + pmlmepriv->LinkDetectInfo.NumTxOkInPeriod) > 8) ||
1508 (pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod > 2))
1513 /* LeisurePS only work in infra mode. */
1515 LPS_Enter(padapter);
1517 LPS_Leave(padapter);
1519 LPS_Leave(padapter);
1522 pmlmepriv->LinkDetectInfo.NumRxOkInPeriod = 0;
1523 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod = 0;
1524 pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod = 0;
1525 pmlmepriv->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
1526 pmlmepriv->LinkDetectInfo.bTxBusyTraffic = bTxBusyTraffic;
1527 pmlmepriv->LinkDetectInfo.bRxBusyTraffic = bRxBusyTraffic;
1528 pmlmepriv->LinkDetectInfo.bHigherBusyTraffic = bHigherBusyTraffic;
1529 pmlmepriv->LinkDetectInfo.bHigherBusyRxTraffic = bHigherBusyRxTraffic;
1530 pmlmepriv->LinkDetectInfo.bHigherBusyTxTraffic = bHigherBusyTxTraffic;
1533 static void dynamic_chk_wk_hdl(struct adapter *padapter, u8 *pbuf, int sz)
1535 struct mlme_priv *pmlmepriv;
1537 padapter = (struct adapter *)pbuf;
1538 pmlmepriv = &(padapter->mlmepriv);
1540 #ifdef CONFIG_88EU_AP_MODE
1541 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true)
1542 expire_timeout_chk(padapter);
1545 rtw_hal_sreset_xmit_status_check(padapter);
1547 linked_status_chk(padapter);
1548 traffic_status_watchdog(padapter);
1550 rtw_hal_dm_watchdog(padapter);
1553 static void lps_ctrl_wk_hdl(struct adapter *padapter, u8 lps_ctrl_type)
1555 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
1556 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1560 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) ||
1561 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true))
1564 switch (lps_ctrl_type) {
1566 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
1568 LPS_Leave(padapter);
1571 case LPS_CTRL_JOINBSS:
1572 LPS_Leave(padapter);
1574 case LPS_CTRL_CONNECT:
1575 mstatus = 1;/* connect */
1576 /* Reset LPS Setting */
1577 padapter->pwrctrlpriv.LpsIdleCount = 0;
1578 rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_JOINBSSRPT, (u8 *)(&mstatus));
1580 case LPS_CTRL_DISCONNECT:
1581 mstatus = 0;/* disconnect */
1582 LPS_Leave(padapter);
1583 rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_JOINBSSRPT, (u8 *)(&mstatus));
1585 case LPS_CTRL_SPECIAL_PACKET:
1586 /* DBG_88E("LPS_CTRL_SPECIAL_PACKET\n"); */
1587 pwrpriv->DelayLPSLastTimeStamp = jiffies;
1588 LPS_Leave(padapter);
1590 case LPS_CTRL_LEAVE:
1591 LPS_Leave(padapter);
1599 u8 rtw_lps_ctrl_wk_cmd(struct adapter *padapter, u8 lps_ctrl_type, u8 enqueue)
1601 struct cmd_obj *ph2c;
1602 struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1603 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1604 /* struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv; */
1608 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1614 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1615 if (pdrvextra_cmd_parm == NULL) {
1621 pdrvextra_cmd_parm->ec_id = LPS_CTRL_WK_CID;
1622 pdrvextra_cmd_parm->type_size = lps_ctrl_type;
1623 pdrvextra_cmd_parm->pbuf = NULL;
1625 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1627 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1629 lps_ctrl_wk_hdl(padapter, lps_ctrl_type);
1638 static void rpt_timer_setting_wk_hdl(struct adapter *padapter, u16 min_time)
1640 rtw_hal_set_hwreg(padapter, HW_VAR_RPT_TIMER_SETTING, (u8 *)(&min_time));
1643 u8 rtw_rpt_timer_cfg_cmd(struct adapter *padapter, u16 min_time)
1645 struct cmd_obj *ph2c;
1646 struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1647 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1651 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1657 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1658 if (pdrvextra_cmd_parm == NULL) {
1664 pdrvextra_cmd_parm->ec_id = RTP_TIMER_CFG_WK_CID;
1665 pdrvextra_cmd_parm->type_size = min_time;
1666 pdrvextra_cmd_parm->pbuf = NULL;
1667 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1668 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1675 static void antenna_select_wk_hdl(struct adapter *padapter, u8 antenna)
1677 rtw_hal_set_hwreg(padapter, HW_VAR_ANTENNA_DIVERSITY_SELECT, (u8 *)(&antenna));
1680 u8 rtw_antenna_select_cmd(struct adapter *padapter, u8 antenna, u8 enqueue)
1682 struct cmd_obj *ph2c;
1683 struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1684 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1688 rtw_hal_get_def_var(padapter, HAL_DEF_IS_SUPPORT_ANT_DIV, &support_ant_div);
1689 if (!support_ant_div)
1693 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1699 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1700 if (pdrvextra_cmd_parm == NULL) {
1706 pdrvextra_cmd_parm->ec_id = ANT_SELECT_WK_CID;
1707 pdrvextra_cmd_parm->type_size = antenna;
1708 pdrvextra_cmd_parm->pbuf = NULL;
1709 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1711 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1713 antenna_select_wk_hdl(padapter, antenna);
1721 static void power_saving_wk_hdl(struct adapter *padapter, u8 *pbuf, int sz)
1723 rtw_ps_processor(padapter);
1726 #ifdef CONFIG_88EU_P2P
1727 u8 p2p_protocol_wk_cmd(struct adapter *padapter, int intCmdType)
1729 struct cmd_obj *ph2c;
1730 struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1731 struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
1732 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1736 if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
1739 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1745 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1746 if (pdrvextra_cmd_parm == NULL) {
1752 pdrvextra_cmd_parm->ec_id = P2P_PROTO_WK_CID;
1753 pdrvextra_cmd_parm->type_size = intCmdType; /* As the command tppe. */
1754 pdrvextra_cmd_parm->pbuf = NULL; /* Must be NULL here */
1756 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1758 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1765 #endif /* CONFIG_88EU_P2P */
1767 u8 rtw_ps_cmd(struct adapter *padapter)
1769 struct cmd_obj *ppscmd;
1770 struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1771 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1775 ppscmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1776 if (ppscmd == NULL) {
1781 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1782 if (pdrvextra_cmd_parm == NULL) {
1788 pdrvextra_cmd_parm->ec_id = POWER_SAVING_CTRL_WK_CID;
1789 pdrvextra_cmd_parm->pbuf = NULL;
1790 init_h2fwcmd_w_parm_no_rsp(ppscmd, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1792 res = rtw_enqueue_cmd(pcmdpriv, ppscmd);
1800 #ifdef CONFIG_88EU_AP_MODE
1802 static void rtw_chk_hi_queue_hdl(struct adapter *padapter)
1805 struct sta_info *psta_bmc;
1806 struct sta_priv *pstapriv = &padapter->stapriv;
1808 psta_bmc = rtw_get_bcmc_stainfo(padapter);
1812 if (psta_bmc->sleepq_len == 0) {
1815 /* while ((rtw_read32(padapter, 0x414)&0x00ffff00)!= 0) */
1816 /* while ((rtw_read32(padapter, 0x414)&0x0000ff00)!= 0) */
1818 rtw_hal_get_hwreg(padapter, HW_VAR_CHK_HI_QUEUE_EMPTY, &val);
1828 rtw_hal_get_hwreg(padapter, HW_VAR_CHK_HI_QUEUE_EMPTY, &val);
1832 pstapriv->tim_bitmap &= ~BIT(0);
1833 pstapriv->sta_dz_bitmap &= ~BIT(0);
1835 update_beacon(padapter, _TIM_IE_, NULL, false);
1836 } else { /* re check again */
1837 rtw_chk_hi_queue_cmd(padapter);
1842 u8 rtw_chk_hi_queue_cmd(struct adapter *padapter)
1844 struct cmd_obj *ph2c;
1845 struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1846 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1849 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1855 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1856 if (pdrvextra_cmd_parm == NULL) {
1862 pdrvextra_cmd_parm->ec_id = CHECK_HIQ_WK_CID;
1863 pdrvextra_cmd_parm->type_size = 0;
1864 pdrvextra_cmd_parm->pbuf = NULL;
1866 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1868 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1874 u8 rtw_c2h_wk_cmd(struct adapter *padapter, u8 *c2h_evt)
1876 struct cmd_obj *ph2c;
1877 struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1878 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1881 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1887 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1888 if (pdrvextra_cmd_parm == NULL) {
1894 pdrvextra_cmd_parm->ec_id = C2H_WK_CID;
1895 pdrvextra_cmd_parm->type_size = c2h_evt ? 16 : 0;
1896 pdrvextra_cmd_parm->pbuf = c2h_evt;
1898 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1900 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1907 static s32 c2h_evt_hdl(struct adapter *adapter, struct c2h_evt_hdr *c2h_evt, c2h_id_filter filter)
1913 /* No c2h event in cmd_obj, read c2h event before handling*/
1914 if (c2h_evt_read(adapter, buf) == _SUCCESS) {
1915 c2h_evt = (struct c2h_evt_hdr *)buf;
1917 if (filter && filter(c2h_evt->id) == false)
1920 ret = rtw_hal_c2h_handler(adapter, c2h_evt);
1923 if (filter && filter(c2h_evt->id) == false)
1926 ret = rtw_hal_c2h_handler(adapter, c2h_evt);
1932 static void c2h_wk_callback(struct work_struct *work)
1934 struct evt_priv *evtpriv = container_of(work, struct evt_priv, c2h_wk);
1935 struct adapter *adapter = container_of(evtpriv, struct adapter, evtpriv);
1936 struct c2h_evt_hdr *c2h_evt;
1937 c2h_id_filter ccx_id_filter = rtw_hal_c2h_id_filter_ccx(adapter);
1939 evtpriv->c2h_wk_alive = true;
1941 while (!rtw_cbuf_empty(evtpriv->c2h_queue)) {
1942 c2h_evt = (struct c2h_evt_hdr *)
1943 rtw_cbuf_pop(evtpriv->c2h_queue);
1944 if (c2h_evt != NULL)
1945 /* This C2H event is read, clear it */
1946 c2h_evt_clear(adapter);
1948 c2h_evt = (struct c2h_evt_hdr *)rtw_malloc(16);
1949 /* This C2H event is not read, read & clear now */
1950 if (c2h_evt != NULL &&
1951 c2h_evt_read(adapter, (u8 *)c2h_evt) != _SUCCESS)
1955 /* Special pointer to trigger c2h_evt_clear only */
1956 if ((void *)c2h_evt == (void *)evtpriv)
1959 if (!c2h_evt_exist(c2h_evt)) {
1964 if (ccx_id_filter(c2h_evt->id) == true) {
1965 /* Handle CCX report here */
1966 rtw_hal_c2h_handler(adapter, c2h_evt);
1969 #ifdef CONFIG_88EU_P2P
1970 /* Enqueue into cmd_thread for others */
1971 rtw_c2h_wk_cmd(adapter, (u8 *)c2h_evt);
1976 evtpriv->c2h_wk_alive = false;
1979 u8 rtw_drvextra_cmd_hdl(struct adapter *padapter, unsigned char *pbuf)
1981 struct drvextra_cmd_parm *pdrvextra_cmd;
1984 return H2C_PARAMETERS_ERROR;
1986 pdrvextra_cmd = (struct drvextra_cmd_parm *)pbuf;
1988 switch (pdrvextra_cmd->ec_id) {
1989 case DYNAMIC_CHK_WK_CID:
1990 dynamic_chk_wk_hdl(padapter, pdrvextra_cmd->pbuf, pdrvextra_cmd->type_size);
1992 case POWER_SAVING_CTRL_WK_CID:
1993 power_saving_wk_hdl(padapter, pdrvextra_cmd->pbuf, pdrvextra_cmd->type_size);
1995 case LPS_CTRL_WK_CID:
1996 lps_ctrl_wk_hdl(padapter, (u8)pdrvextra_cmd->type_size);
1998 case RTP_TIMER_CFG_WK_CID:
1999 rpt_timer_setting_wk_hdl(padapter, pdrvextra_cmd->type_size);
2001 case ANT_SELECT_WK_CID:
2002 antenna_select_wk_hdl(padapter, pdrvextra_cmd->type_size);
2004 #ifdef CONFIG_88EU_P2P
2006 p2p_ps_wk_hdl(padapter, pdrvextra_cmd->type_size);
2008 case P2P_PROTO_WK_CID:
2010 * Commented by Albert 2011/07/01
2011 * I used the type_size as the type command
2013 p2p_protocol_wk_hdl(padapter, pdrvextra_cmd->type_size);
2016 #ifdef CONFIG_88EU_AP_MODE
2017 case CHECK_HIQ_WK_CID:
2018 rtw_chk_hi_queue_hdl(padapter);
2020 #endif /* CONFIG_88EU_AP_MODE */
2022 c2h_evt_hdl(padapter, (struct c2h_evt_hdr *)pdrvextra_cmd->pbuf, NULL);
2028 if (pdrvextra_cmd->pbuf && pdrvextra_cmd->type_size > 0)
2029 kfree(pdrvextra_cmd->pbuf);
2034 void rtw_survey_cmd_callback(struct adapter *padapter, struct cmd_obj *pcmd)
2036 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2039 if (pcmd->res == H2C_DROPPED) {
2040 /* TODO: cancel timer and do timeout handler directly... */
2041 /* need to make timeout handlerOS independent */
2042 _set_timer(&pmlmepriv->scan_to_timer, 1);
2043 } else if (pcmd->res != H2C_SUCCESS) {
2044 _set_timer(&pmlmepriv->scan_to_timer, 1);
2045 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n ********Error: MgntActrtw_set_802_11_bssid_LIST_SCAN Fail ************\n\n."));
2049 rtw_free_cmd_obj(pcmd);
2052 void rtw_disassoc_cmd_callback(struct adapter *padapter, struct cmd_obj *pcmd)
2054 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2057 if (pcmd->res != H2C_SUCCESS) {
2058 spin_lock_bh(&pmlmepriv->lock);
2059 set_fwstate(pmlmepriv, _FW_LINKED);
2060 spin_unlock_bh(&pmlmepriv->lock);
2062 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n ***Error: disconnect_cmd_callback Fail ***\n."));
2064 } else /* clear bridge database */
2065 nat25_db_cleanup(padapter);
2068 rtw_free_cmd_obj(pcmd);
2071 void rtw_joinbss_cmd_callback(struct adapter *padapter, struct cmd_obj *pcmd)
2073 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2076 if (pcmd->res == H2C_DROPPED) {
2077 /* TODO: cancel timer and do timeout handler directly... */
2078 /* need to make timeout handlerOS independent */
2079 _set_timer(&pmlmepriv->assoc_timer, 1);
2080 } else if (pcmd->res != H2C_SUCCESS) {
2081 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("********Error:rtw_select_and_join_from_scanned_queue Wait Sema Fail ************\n"));
2082 _set_timer(&pmlmepriv->assoc_timer, 1);
2085 rtw_free_cmd_obj(pcmd);
2089 void rtw_createbss_cmd_callback(struct adapter *padapter, struct cmd_obj *pcmd)
2092 struct sta_info *psta = NULL;
2093 struct wlan_network *pwlan = NULL;
2094 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2095 struct wlan_bssid_ex *pnetwork = (struct wlan_bssid_ex *)pcmd->parmbuf;
2096 struct wlan_network *tgt_network = &(pmlmepriv->cur_network);
2099 if (pcmd->res != H2C_SUCCESS) {
2100 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n ********Error: rtw_createbss_cmd_callback Fail ************\n\n."));
2101 _set_timer(&pmlmepriv->assoc_timer, 1);
2104 _cancel_timer(&pmlmepriv->assoc_timer, &timer_cancelled);
2106 spin_lock_bh(&pmlmepriv->lock);
2108 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
2109 psta = rtw_get_stainfo(&padapter->stapriv, pnetwork->MacAddress);
2111 psta = rtw_alloc_stainfo(&padapter->stapriv, pnetwork->MacAddress);
2113 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\nCan't alloc sta_info when createbss_cmd_callback\n"));
2114 goto createbss_cmd_fail;
2118 rtw_indicate_connect(padapter);
2120 pwlan = _rtw_alloc_network(pmlmepriv);
2121 spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
2122 if (pwlan == NULL) {
2123 pwlan = rtw_get_oldest_wlan_network(&pmlmepriv->scanned_queue);
2124 if (pwlan == NULL) {
2125 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n Error: can't get pwlan in rtw_joinbss_event_callback\n"));
2126 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
2127 goto createbss_cmd_fail;
2129 pwlan->last_scanned = jiffies;
2131 rtw_list_insert_tail(&(pwlan->list), &pmlmepriv->scanned_queue.queue);
2134 pnetwork->Length = get_wlan_bssid_ex_sz(pnetwork);
2135 memcpy(&(pwlan->network), pnetwork, pnetwork->Length);
2137 memcpy(&tgt_network->network, pnetwork, (get_wlan_bssid_ex_sz(pnetwork)));
2139 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
2141 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
2142 /* we will set _FW_LINKED when there is one more sat to join us (rtw_stassoc_event_callback) */
2147 spin_unlock_bh(&pmlmepriv->lock);
2149 rtw_free_cmd_obj(pcmd);
2153 void rtw_setstaKey_cmdrsp_callback(struct adapter *padapter, struct cmd_obj *pcmd)
2155 struct sta_priv *pstapriv = &padapter->stapriv;
2156 struct set_stakey_rsp *psetstakey_rsp = (struct set_stakey_rsp *)(pcmd->rsp);
2157 struct sta_info *psta = rtw_get_stainfo(pstapriv, psetstakey_rsp->addr);
2161 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\nERROR: rtw_setstaKey_cmdrsp_callback => can't get sta_info\n\n"));
2165 rtw_free_cmd_obj(pcmd);
2168 void rtw_setassocsta_cmdrsp_callback(struct adapter *padapter, struct cmd_obj *pcmd)
2170 struct sta_priv *pstapriv = &padapter->stapriv;
2171 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2172 struct set_assocsta_parm *passocsta_parm = (struct set_assocsta_parm *)(pcmd->parmbuf);
2173 struct set_assocsta_rsp *passocsta_rsp = (struct set_assocsta_rsp *)(pcmd->rsp);
2174 struct sta_info *psta = rtw_get_stainfo(pstapriv, passocsta_parm->addr);
2178 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\nERROR: setassocsta_cmdrsp_callbac => can't get sta_info\n\n"));
2182 psta->aid = passocsta_rsp->cam_id;
2183 psta->mac_id = passocsta_rsp->cam_id;
2185 spin_lock_bh(&pmlmepriv->lock);
2187 if ((check_fwstate(pmlmepriv, WIFI_MP_STATE) == true) && (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true))
2188 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
2190 set_fwstate(pmlmepriv, _FW_LINKED);
2191 spin_unlock_bh(&pmlmepriv->lock);
2194 rtw_free_cmd_obj(pcmd);