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)
41 sema_init(&(pcmdpriv->cmd_queue_sema), 0);
42 /* sema_init(&(pcmdpriv->cmd_done_sema), 0); */
43 sema_init(&(pcmdpriv->terminate_cmdthread_sema), 0);
46 _rtw_init_queue(&(pcmdpriv->cmd_queue));
48 /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
50 pcmdpriv->cmd_seq = 1;
52 pcmdpriv->cmd_allocated_buf = rtw_zmalloc(MAX_CMDSZ + CMDBUFF_ALIGN_SZ);
54 if (pcmdpriv->cmd_allocated_buf == NULL) {
59 pcmdpriv->cmd_buf = pcmdpriv->cmd_allocated_buf + CMDBUFF_ALIGN_SZ - ((size_t)(pcmdpriv->cmd_allocated_buf) & (CMDBUFF_ALIGN_SZ-1));
61 pcmdpriv->rsp_allocated_buf = rtw_zmalloc(MAX_RSPSZ + 4);
63 if (pcmdpriv->rsp_allocated_buf == NULL) {
68 pcmdpriv->rsp_buf = pcmdpriv->rsp_allocated_buf + 4 - ((size_t)(pcmdpriv->rsp_allocated_buf) & 3);
70 pcmdpriv->cmd_issued_cnt = 0;
71 pcmdpriv->cmd_done_cnt = 0;
72 pcmdpriv->rsp_cnt = 0;
78 static void c2h_wk_callback(struct work_struct *work);
80 int _rtw_init_evt_priv(struct evt_priv *pevtpriv)
86 /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
87 atomic_set(&pevtpriv->event_seq, 0);
88 pevtpriv->evt_done_cnt = 0;
90 _init_workitem(&pevtpriv->c2h_wk, c2h_wk_callback, NULL);
91 pevtpriv->c2h_wk_alive = false;
92 pevtpriv->c2h_queue = rtw_cbuf_alloc(C2H_QUEUE_MAX_LEN+1);
99 void rtw_free_evt_priv(struct evt_priv *pevtpriv)
103 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("+rtw_free_evt_priv\n"));
105 _cancel_workitem_sync(&pevtpriv->c2h_wk);
106 while (pevtpriv->c2h_wk_alive)
109 while (!rtw_cbuf_empty(pevtpriv->c2h_queue)) {
110 void *c2h = rtw_cbuf_pop(pevtpriv->c2h_queue);
111 if (c2h != NULL && c2h != (void *)pevtpriv)
114 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("-rtw_free_evt_priv\n"));
119 void _rtw_free_cmd_priv (struct cmd_priv *pcmdpriv)
124 if (pcmdpriv->cmd_allocated_buf)
125 kfree(pcmdpriv->cmd_allocated_buf);
127 if (pcmdpriv->rsp_allocated_buf)
128 kfree(pcmdpriv->rsp_allocated_buf);
136 rtw_enqueue_cmd can only be called between kernel thread,
137 since only spin_lock is used.
139 ISR/Call-Back functions can't call this sub-function.
143 int _rtw_enqueue_cmd(struct __queue *queue, struct cmd_obj *obj)
152 spin_lock_irqsave(&queue->lock, irqL);
154 rtw_list_insert_tail(&obj->list, &queue->queue);
156 spin_unlock_irqrestore(&queue->lock, irqL);
165 struct cmd_obj *_rtw_dequeue_cmd(struct __queue *queue)
172 spin_lock_irqsave(&queue->lock, irqL);
173 if (rtw_is_list_empty(&(queue->queue))) {
176 obj = LIST_CONTAINOR(get_next(&(queue->queue)), struct cmd_obj, list);
177 rtw_list_delete(&obj->list);
180 spin_unlock_irqrestore(&queue->lock, irqL);
187 u32 rtw_init_cmd_priv(struct cmd_priv *pcmdpriv)
191 res = _rtw_init_cmd_priv (pcmdpriv);
196 u32 rtw_init_evt_priv (struct evt_priv *pevtpriv)
200 res = _rtw_init_evt_priv(pevtpriv);
205 void rtw_free_cmd_priv(struct cmd_priv *pcmdpriv)
208 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("rtw_free_cmd_priv\n"));
209 _rtw_free_cmd_priv(pcmdpriv);
213 static int rtw_cmd_filter(struct cmd_priv *pcmdpriv, struct cmd_obj *cmd_obj)
215 u8 bAllow = false; /* set to true to allow enqueuing cmd when hw_init_completed is false */
217 /* To decide allow or not */
218 if ((pcmdpriv->padapter->pwrctrlpriv.bHWPwrPindetect) &&
219 (!pcmdpriv->padapter->registrypriv.usbss_enable)) {
220 if (cmd_obj->cmdcode == GEN_CMD_CODE(_Set_Drv_Extra)) {
221 struct drvextra_cmd_parm *pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)cmd_obj->parmbuf;
222 if (pdrvextra_cmd_parm->ec_id == POWER_SAVING_CTRL_WK_CID)
227 if (cmd_obj->cmdcode == GEN_CMD_CODE(_SetChannelPlan))
230 if ((!pcmdpriv->padapter->hw_init_completed && !bAllow) ||
231 !pcmdpriv->cmdthd_running) /* com_thread not running */
236 u32 rtw_enqueue_cmd(struct cmd_priv *pcmdpriv, struct cmd_obj *cmd_obj)
239 struct adapter *padapter = pcmdpriv->padapter;
246 cmd_obj->padapter = padapter;
248 res = rtw_cmd_filter(pcmdpriv, cmd_obj);
250 rtw_free_cmd_obj(cmd_obj);
254 res = _rtw_enqueue_cmd(&pcmdpriv->cmd_queue, cmd_obj);
257 up(&pcmdpriv->cmd_queue_sema);
266 struct cmd_obj *rtw_dequeue_cmd(struct cmd_priv *pcmdpriv)
268 struct cmd_obj *cmd_obj;
272 cmd_obj = _rtw_dequeue_cmd(&pcmdpriv->cmd_queue);
278 void rtw_cmd_clr_isr(struct cmd_priv *pcmdpriv)
281 pcmdpriv->cmd_done_cnt++;
282 /* up(&(pcmdpriv->cmd_done_sema)); */
286 void rtw_free_cmd_obj(struct cmd_obj *pcmd)
290 if ((pcmd->cmdcode != _JoinBss_CMD_) && (pcmd->cmdcode != _CreateBss_CMD_)) {
291 /* free parmbuf in cmd_obj */
292 kfree(pcmd->parmbuf);
295 if (pcmd->rsp != NULL) {
296 if (pcmd->rspsz != 0) {
297 /* free rsp in cmd_obj */
308 int rtw_cmd_thread(void *context)
311 struct cmd_obj *pcmd;
313 u8 (*cmd_hdl)(struct adapter *padapter, u8 *pbuf);
314 void (*pcmd_callback)(struct adapter *dev, struct cmd_obj *pcmd);
315 struct adapter *padapter = (struct adapter *)context;
316 struct cmd_priv *pcmdpriv = &(padapter->cmdpriv);
320 thread_enter("RTW_CMD_THREAD");
322 pcmdbuf = pcmdpriv->cmd_buf;
324 pcmdpriv->cmdthd_running = true;
325 up(&pcmdpriv->terminate_cmdthread_sema);
327 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("start r871x rtw_cmd_thread !!!!\n"));
330 if (_rtw_down_sema(&pcmdpriv->cmd_queue_sema) == _FAIL)
333 if (padapter->bDriverStopped ||
334 padapter->bSurpriseRemoved) {
335 DBG_88E("%s: DriverStopped(%d) SurpriseRemoved(%d) break at line %d\n",
336 __func__, padapter->bDriverStopped, padapter->bSurpriseRemoved, __LINE__);
340 if (padapter->bDriverStopped ||
341 padapter->bSurpriseRemoved) {
342 DBG_88E("%s: DriverStopped(%d) SurpriseRemoved(%d) break at line %d\n",
343 __func__, padapter->bDriverStopped, padapter->bSurpriseRemoved, __LINE__);
347 pcmd = rtw_dequeue_cmd(pcmdpriv);
351 if (_FAIL == rtw_cmd_filter(pcmdpriv, pcmd)) {
352 pcmd->res = H2C_DROPPED;
356 pcmdpriv->cmd_issued_cnt++;
358 pcmd->cmdsz = _RND4((pcmd->cmdsz));/* _RND4 */
360 memcpy(pcmdbuf, pcmd->parmbuf, pcmd->cmdsz);
362 if (pcmd->cmdcode < ARRAY_SIZE(wlancmds)) {
363 cmd_hdl = wlancmds[pcmd->cmdcode].h2cfuns;
366 ret = cmd_hdl(pcmd->padapter, pcmdbuf);
372 pcmd->res = H2C_PARAMETERS_ERROR;
379 /* call callback function for post-processed */
380 if (pcmd->cmdcode < ARRAY_SIZE(rtw_cmd_callback)) {
381 pcmd_callback = rtw_cmd_callback[pcmd->cmdcode].callback;
382 if (pcmd_callback == NULL) {
383 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("mlme_cmd_hdl(): pcmd_callback = 0x%p, cmdcode = 0x%x\n", pcmd_callback, pcmd->cmdcode));
384 rtw_free_cmd_obj(pcmd);
386 /* todo: !!! fill rsp_buf to pcmd->rsp if (pcmd->rsp!= NULL) */
387 pcmd_callback(pcmd->padapter, pcmd);/* need conider that free cmd_obj in rtw_cmd_callback */
390 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("%s: cmdcode = 0x%x callback not defined!\n", __func__, pcmd->cmdcode));
391 rtw_free_cmd_obj(pcmd);
394 flush_signals_thread();
398 pcmdpriv->cmdthd_running = false;
400 /* free all cmd_obj resources */
402 pcmd = rtw_dequeue_cmd(pcmdpriv);
406 /* DBG_88E("%s: leaving... drop cmdcode:%u\n", __func__, pcmd->cmdcode); */
408 rtw_free_cmd_obj(pcmd);
411 up(&pcmdpriv->terminate_cmdthread_sema);
415 complete_and_exit(NULL, 0);
418 u8 rtw_setstandby_cmd(struct adapter *padapter, uint action)
420 struct cmd_obj *ph2c;
421 struct usb_suspend_parm *psetusbsuspend;
422 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
428 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
434 psetusbsuspend = (struct usb_suspend_parm *)rtw_zmalloc(sizeof(struct usb_suspend_parm));
435 if (psetusbsuspend == NULL) {
441 psetusbsuspend->action = action;
443 init_h2fwcmd_w_parm_no_rsp(ph2c, psetusbsuspend, GEN_CMD_CODE(_SetUsbSuspend));
445 ret = rtw_enqueue_cmd(pcmdpriv, ph2c);
455 rtw_sitesurvey_cmd(~)
457 MUST TAKE CARE THAT BEFORE CALLING THIS FUNC, YOU SHOULD HAVE LOCKED pmlmepriv->lock
459 u8 rtw_sitesurvey_cmd(struct adapter *padapter, struct ndis_802_11_ssid *ssid, int ssid_num,
460 struct rtw_ieee80211_channel *ch, int ch_num)
463 struct cmd_obj *ph2c;
464 struct sitesurvey_parm *psurveyPara;
465 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
466 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
469 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
470 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_SCAN, 1);
473 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
474 p2p_ps_wk_cmd(padapter, P2P_PS_SCAN, 1);
477 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
481 psurveyPara = (struct sitesurvey_parm *)rtw_zmalloc(sizeof(struct sitesurvey_parm));
482 if (psurveyPara == NULL) {
487 rtw_free_network_queue(padapter, false);
489 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("%s: flush network queue\n", __func__));
491 init_h2fwcmd_w_parm_no_rsp(ph2c, psurveyPara, GEN_CMD_CODE(_SiteSurvey));
493 /* psurveyPara->bsslimit = 48; */
494 psurveyPara->scan_mode = pmlmepriv->scan_mode;
496 /* prepare ssid list */
499 for (i = 0; i < ssid_num && i < RTW_SSID_SCAN_AMOUNT; i++) {
500 if (ssid[i].SsidLength) {
501 memcpy(&psurveyPara->ssid[i], &ssid[i], sizeof(struct ndis_802_11_ssid));
502 psurveyPara->ssid_num++;
504 DBG_88E(FUNC_ADPT_FMT" ssid:(%s, %d)\n", FUNC_ADPT_ARG(padapter),
505 psurveyPara->ssid[i].Ssid, psurveyPara->ssid[i].SsidLength);
510 /* prepare channel list */
513 for (i = 0; i < ch_num && i < RTW_CHANNEL_SCAN_AMOUNT; i++) {
514 if (ch[i].hw_value && !(ch[i].flags & RTW_IEEE80211_CHAN_DISABLED)) {
515 memcpy(&psurveyPara->ch[i], &ch[i], sizeof(struct rtw_ieee80211_channel));
516 psurveyPara->ch_num++;
518 DBG_88E(FUNC_ADPT_FMT" ch:%u\n", FUNC_ADPT_ARG(padapter),
519 psurveyPara->ch[i].hw_value);
524 set_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
526 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
528 if (res == _SUCCESS) {
529 pmlmepriv->scan_start_time = jiffies;
531 _set_timer(&pmlmepriv->scan_to_timer, SCANNING_TIMEOUT);
533 rtw_led_control(padapter, LED_CTL_SITE_SURVEY);
535 pmlmepriv->scan_interval = SCAN_INTERVAL;/* 30*2 sec = 60sec */
537 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
545 u8 rtw_setdatarate_cmd(struct adapter *padapter, u8 *rateset)
547 struct cmd_obj *ph2c;
548 struct setdatarate_parm *pbsetdataratepara;
549 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
554 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
560 pbsetdataratepara = (struct setdatarate_parm *)rtw_zmalloc(sizeof(struct setdatarate_parm));
561 if (pbsetdataratepara == NULL) {
567 init_h2fwcmd_w_parm_no_rsp(ph2c, pbsetdataratepara, GEN_CMD_CODE(_SetDataRate));
568 pbsetdataratepara->mac_id = 5;
569 memcpy(pbsetdataratepara->datarates, rateset, NumRates);
570 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
578 u8 rtw_setbasicrate_cmd(struct adapter *padapter, u8 *rateset)
580 struct cmd_obj *ph2c;
581 struct setbasicrate_parm *pssetbasicratepara;
582 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
587 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
592 pssetbasicratepara = (struct setbasicrate_parm *)rtw_zmalloc(sizeof(struct setbasicrate_parm));
594 if (pssetbasicratepara == NULL) {
600 init_h2fwcmd_w_parm_no_rsp(ph2c, pssetbasicratepara, _SetBasicRate_CMD_);
602 memcpy(pssetbasicratepara->basicrates, rateset, NumRates);
604 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
614 unsigned char rtw_setphy_cmd(unsigned char *adapter)
616 1. be called only after rtw_update_registrypriv_dev_network(~) or mp testing program
617 2. for AdHoc/Ap mode or mp mode?
620 u8 rtw_setphy_cmd(struct adapter *padapter, u8 modem, u8 ch)
622 struct cmd_obj *ph2c;
623 struct setphy_parm *psetphypara;
624 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
629 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
634 psetphypara = (struct setphy_parm *)rtw_zmalloc(sizeof(struct setphy_parm));
636 if (psetphypara == NULL) {
642 init_h2fwcmd_w_parm_no_rsp(ph2c, psetphypara, _SetPhy_CMD_);
644 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("CH =%d, modem =%d", ch, modem));
646 psetphypara->modem = modem;
647 psetphypara->rfchannel = ch;
649 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
655 u8 rtw_setbbreg_cmd(struct adapter *padapter, u8 offset, u8 val)
657 struct cmd_obj *ph2c;
658 struct writeBB_parm *pwritebbparm;
659 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
663 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
668 pwritebbparm = (struct writeBB_parm *)rtw_zmalloc(sizeof(struct writeBB_parm));
670 if (pwritebbparm == NULL) {
676 init_h2fwcmd_w_parm_no_rsp(ph2c, pwritebbparm, GEN_CMD_CODE(_SetBBReg));
678 pwritebbparm->offset = offset;
679 pwritebbparm->value = val;
681 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
687 u8 rtw_getbbreg_cmd(struct adapter *padapter, u8 offset, u8 *pval)
689 struct cmd_obj *ph2c;
690 struct readBB_parm *prdbbparm;
691 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
695 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
700 prdbbparm = (struct readBB_parm *)rtw_zmalloc(sizeof(struct readBB_parm));
702 if (prdbbparm == NULL) {
707 _rtw_init_listhead(&ph2c->list);
708 ph2c->cmdcode = GEN_CMD_CODE(_GetBBReg);
709 ph2c->parmbuf = (unsigned char *)prdbbparm;
710 ph2c->cmdsz = sizeof(struct readBB_parm);
712 ph2c->rspsz = sizeof(struct readBB_rsp);
714 prdbbparm->offset = offset;
716 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
722 u8 rtw_setrfreg_cmd(struct adapter *padapter, u8 offset, u32 val)
724 struct cmd_obj *ph2c;
725 struct writeRF_parm *pwriterfparm;
726 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
729 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
734 pwriterfparm = (struct writeRF_parm *)rtw_zmalloc(sizeof(struct writeRF_parm));
736 if (pwriterfparm == NULL) {
742 init_h2fwcmd_w_parm_no_rsp(ph2c, pwriterfparm, GEN_CMD_CODE(_SetRFReg));
744 pwriterfparm->offset = offset;
745 pwriterfparm->value = val;
747 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
753 u8 rtw_getrfreg_cmd(struct adapter *padapter, u8 offset, u8 *pval)
755 struct cmd_obj *ph2c;
756 struct readRF_parm *prdrfparm;
757 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
762 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
768 prdrfparm = (struct readRF_parm *)rtw_zmalloc(sizeof(struct readRF_parm));
769 if (prdrfparm == NULL) {
775 _rtw_init_listhead(&ph2c->list);
776 ph2c->cmdcode = GEN_CMD_CODE(_GetRFReg);
777 ph2c->parmbuf = (unsigned char *)prdrfparm;
778 ph2c->cmdsz = sizeof(struct readRF_parm);
780 ph2c->rspsz = sizeof(struct readRF_rsp);
782 prdrfparm->offset = offset;
784 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
793 void rtw_getbbrfreg_cmdrsp_callback(struct adapter *padapter, struct cmd_obj *pcmd)
797 kfree(pcmd->parmbuf);
800 if (padapter->registrypriv.mp_mode == 1)
801 padapter->mppriv.workparam.bcompleted = true;
805 void rtw_readtssi_cmdrsp_callback(struct adapter *padapter, struct cmd_obj *pcmd)
809 kfree(pcmd->parmbuf);
812 if (padapter->registrypriv.mp_mode == 1)
813 padapter->mppriv.workparam.bcompleted = true;
817 u8 rtw_createbss_cmd(struct adapter *padapter)
819 struct cmd_obj *pcmd;
820 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
821 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
822 struct wlan_bssid_ex *pdev_network = &padapter->registrypriv.dev_network;
827 rtw_led_control(padapter, LED_CTL_START_TO_LINK);
829 if (pmlmepriv->assoc_ssid.SsidLength == 0)
830 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, (" createbss for Any SSid:%s\n", pmlmepriv->assoc_ssid.Ssid));
832 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, (" createbss for SSid:%s\n", pmlmepriv->assoc_ssid.Ssid));
834 pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
840 _rtw_init_listhead(&pcmd->list);
841 pcmd->cmdcode = _CreateBss_CMD_;
842 pcmd->parmbuf = (unsigned char *)pdev_network;
843 pcmd->cmdsz = get_wlan_bssid_ex_sz((struct wlan_bssid_ex *)pdev_network);
846 pdev_network->Length = pcmd->cmdsz;
847 res = rtw_enqueue_cmd(pcmdpriv, pcmd);
855 u8 rtw_createbss_cmd_ex(struct adapter *padapter, unsigned char *pbss, unsigned int sz)
857 struct cmd_obj *pcmd;
858 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
863 pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
869 _rtw_init_listhead(&pcmd->list);
870 pcmd->cmdcode = GEN_CMD_CODE(_CreateBss);
871 pcmd->parmbuf = pbss;
876 res = rtw_enqueue_cmd(pcmdpriv, pcmd);
885 u8 rtw_joinbss_cmd(struct adapter *padapter, struct wlan_network *pnetwork)
889 struct wlan_bssid_ex *psecnetwork;
890 struct cmd_obj *pcmd;
891 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
892 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
893 struct qos_priv *pqospriv = &pmlmepriv->qospriv;
894 struct security_priv *psecuritypriv = &padapter->securitypriv;
895 struct registry_priv *pregistrypriv = &padapter->registrypriv;
896 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
897 enum ndis_802_11_network_infra ndis_network_mode = pnetwork->network.InfrastructureMode;
898 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
899 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
903 rtw_led_control(padapter, LED_CTL_START_TO_LINK);
905 if (pmlmepriv->assoc_ssid.SsidLength == 0) {
906 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("+Join cmd: Any SSid\n"));
908 RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+Join cmd: SSid =[%s]\n", pmlmepriv->assoc_ssid.Ssid));
911 pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
914 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("rtw_joinbss_cmd: memory allocate for cmd_obj fail!!!\n"));
917 /* for IEs is fix buf size */
918 t_len = sizeof(struct wlan_bssid_ex);
921 /* for hidden ap to set fw_state here */
922 if (!check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_ADHOC_STATE)) {
923 switch (ndis_network_mode) {
925 set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
927 case Ndis802_11Infrastructure:
928 set_fwstate(pmlmepriv, WIFI_STATION_STATE);
930 case Ndis802_11APMode:
931 case Ndis802_11AutoUnknown:
932 case Ndis802_11InfrastructureMax:
937 psecnetwork = (struct wlan_bssid_ex *)&psecuritypriv->sec_bss;
938 if (psecnetwork == NULL) {
944 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("rtw_joinbss_cmd :psecnetwork == NULL!!!\n"));
949 _rtw_memset(psecnetwork, 0, t_len);
951 memcpy(psecnetwork, &pnetwork->network, get_wlan_bssid_ex_sz(&pnetwork->network));
953 psecuritypriv->authenticator_ie[0] = (unsigned char)psecnetwork->IELength;
955 if ((psecnetwork->IELength-12) < (256-1)) {
956 memcpy(&psecuritypriv->authenticator_ie[1], &psecnetwork->IEs[12], psecnetwork->IELength-12);
958 memcpy(&psecuritypriv->authenticator_ie[1], &psecnetwork->IEs[12], (256-1));
961 psecnetwork->IELength = 0;
962 /* Added by Albert 2009/02/18 */
963 /* If the the driver wants to use the bssid to create the connection. */
964 /* If not, we have to copy the connecting AP's MAC address to it so that */
965 /* the driver just has the bssid information for PMKIDList searching. */
967 if (!pmlmepriv->assoc_by_bssid)
968 memcpy(&pmlmepriv->assoc_bssid[0], &pnetwork->network.MacAddress[0], ETH_ALEN);
970 psecnetwork->IELength = rtw_restruct_sec_ie(padapter, &pnetwork->network.IEs[0], &psecnetwork->IEs[0], pnetwork->network.IELength);
973 pqospriv->qos_option = 0;
975 if (pregistrypriv->wmm_enable) {
978 tmp_len = rtw_restruct_wmm_ie(padapter, &pnetwork->network.IEs[0], &psecnetwork->IEs[0], pnetwork->network.IELength, psecnetwork->IELength);
980 if (psecnetwork->IELength != tmp_len) {
981 psecnetwork->IELength = tmp_len;
982 pqospriv->qos_option = 1; /* There is WMM IE in this corresp. beacon */
984 pqospriv->qos_option = 0;/* There is no WMM IE in this corresp. beacon */
988 phtpriv->ht_option = false;
989 if (pregistrypriv->ht_enable) {
990 /* Added by Albert 2010/06/23 */
991 /* For the WEP mode, we will use the bg mode to do the connection to avoid some IOT issue. */
992 /* Especially for Realtek 8192u SoftAP. */
993 if ((padapter->securitypriv.dot11PrivacyAlgrthm != _WEP40_) &&
994 (padapter->securitypriv.dot11PrivacyAlgrthm != _WEP104_) &&
995 (padapter->securitypriv.dot11PrivacyAlgrthm != _TKIP_)) {
996 /* rtw_restructure_ht_ie */
997 rtw_restructure_ht_ie(padapter, &pnetwork->network.IEs[0], &psecnetwork->IEs[0],
998 pnetwork->network.IELength, &psecnetwork->IELength);
1002 pmlmeinfo->assoc_AP_vendor = check_assoc_AP(pnetwork->network.IEs, pnetwork->network.IELength);
1004 if (pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_TENDA)
1005 padapter->pwrctrlpriv.smart_ps = 0;
1007 padapter->pwrctrlpriv.smart_ps = padapter->registrypriv.smart_ps;
1009 DBG_88E("%s: smart_ps =%d\n", __func__, padapter->pwrctrlpriv.smart_ps);
1011 pcmd->cmdsz = get_wlan_bssid_ex_sz(psecnetwork);/* get cmdsz before endian conversion */
1013 _rtw_init_listhead(&pcmd->list);
1014 pcmd->cmdcode = _JoinBss_CMD_;/* GEN_CMD_CODE(_JoinBss) */
1015 pcmd->parmbuf = (unsigned char *)psecnetwork;
1019 res = rtw_enqueue_cmd(pcmdpriv, pcmd);
1028 u8 rtw_disassoc_cmd(struct adapter *padapter, u32 deauth_timeout_ms, bool enqueue) /* for sta_mode */
1030 struct cmd_obj *cmdobj = NULL;
1031 struct disconnect_parm *param = NULL;
1032 struct cmd_priv *cmdpriv = &padapter->cmdpriv;
1037 RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+rtw_disassoc_cmd\n"));
1039 /* prepare cmd parameter */
1040 param = (struct disconnect_parm *)rtw_zmalloc(sizeof(*param));
1041 if (param == NULL) {
1045 param->deauth_timeout_ms = deauth_timeout_ms;
1048 /* need enqueue, prepare cmd_obj and enqueue */
1049 cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(*cmdobj));
1050 if (cmdobj == NULL) {
1055 init_h2fwcmd_w_parm_no_rsp(cmdobj, param, _DisConnect_CMD_);
1056 res = rtw_enqueue_cmd(cmdpriv, cmdobj);
1058 /* no need to enqueue, do the cmd hdl directly and free cmd parameter */
1059 if (H2C_SUCCESS != disconnect_hdl(padapter, (u8 *)param))
1071 u8 rtw_setopmode_cmd(struct adapter *padapter, enum ndis_802_11_network_infra networktype)
1073 struct cmd_obj *ph2c;
1074 struct setopmode_parm *psetop;
1076 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1081 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1086 psetop = (struct setopmode_parm *)rtw_zmalloc(sizeof(struct setopmode_parm));
1088 if (psetop == NULL) {
1094 init_h2fwcmd_w_parm_no_rsp(ph2c, psetop, _SetOpMode_CMD_);
1095 psetop->mode = (u8)networktype;
1097 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1106 u8 rtw_setstakey_cmd(struct adapter *padapter, u8 *psta, u8 unicast_key)
1108 struct cmd_obj *ph2c;
1109 struct set_stakey_parm *psetstakey_para;
1110 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1111 struct set_stakey_rsp *psetstakey_rsp = NULL;
1113 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1114 struct security_priv *psecuritypriv = &padapter->securitypriv;
1115 struct sta_info *sta = (struct sta_info *)psta;
1120 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1126 psetstakey_para = (struct set_stakey_parm *)rtw_zmalloc(sizeof(struct set_stakey_parm));
1127 if (psetstakey_para == NULL) {
1133 psetstakey_rsp = (struct set_stakey_rsp *)rtw_zmalloc(sizeof(struct set_stakey_rsp));
1134 if (psetstakey_rsp == NULL) {
1136 kfree(psetstakey_para);
1141 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_);
1142 ph2c->rsp = (u8 *)psetstakey_rsp;
1143 ph2c->rspsz = sizeof(struct set_stakey_rsp);
1145 memcpy(psetstakey_para->addr, sta->hwaddr, ETH_ALEN);
1147 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
1148 psetstakey_para->algorithm = (unsigned char) psecuritypriv->dot11PrivacyAlgrthm;
1150 GET_ENCRY_ALGO(psecuritypriv, sta, psetstakey_para->algorithm, false);
1153 memcpy(&psetstakey_para->key, &sta->dot118021x_UncstKey, 16);
1155 memcpy(&psetstakey_para->key, &psecuritypriv->dot118021XGrpKey[psecuritypriv->dot118021XGrpKeyid].skey, 16);
1157 /* jeff: set this because at least sw key is ready */
1158 padapter->securitypriv.busetkipkey = true;
1160 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1169 u8 rtw_clearstakey_cmd(struct adapter *padapter, u8 *psta, u8 entry, u8 enqueue)
1171 struct cmd_obj *ph2c;
1172 struct set_stakey_parm *psetstakey_para;
1173 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1174 struct set_stakey_rsp *psetstakey_rsp = NULL;
1175 struct sta_info *sta = (struct sta_info *)psta;
1181 clear_cam_entry(padapter, entry);
1183 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1189 psetstakey_para = (struct set_stakey_parm *)rtw_zmalloc(sizeof(struct set_stakey_parm));
1190 if (psetstakey_para == NULL) {
1196 psetstakey_rsp = (struct set_stakey_rsp *)rtw_zmalloc(sizeof(struct set_stakey_rsp));
1197 if (psetstakey_rsp == NULL) {
1199 kfree(psetstakey_para);
1204 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_);
1205 ph2c->rsp = (u8 *)psetstakey_rsp;
1206 ph2c->rspsz = sizeof(struct set_stakey_rsp);
1208 memcpy(psetstakey_para->addr, sta->hwaddr, ETH_ALEN);
1210 psetstakey_para->algorithm = _NO_PRIVACY_;
1212 psetstakey_para->id = entry;
1214 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1223 u8 rtw_setrttbl_cmd(struct adapter *padapter, struct setratable_parm *prate_table)
1225 struct cmd_obj *ph2c;
1226 struct setratable_parm *psetrttblparm;
1227 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1231 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1236 psetrttblparm = (struct setratable_parm *)rtw_zmalloc(sizeof(struct setratable_parm));
1238 if (psetrttblparm == NULL) {
1244 init_h2fwcmd_w_parm_no_rsp(ph2c, psetrttblparm, GEN_CMD_CODE(_SetRaTable));
1246 memcpy(psetrttblparm, prate_table, sizeof(struct setratable_parm));
1248 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1254 u8 rtw_getrttbl_cmd(struct adapter *padapter, struct getratable_rsp *pval)
1256 struct cmd_obj *ph2c;
1257 struct getratable_parm *pgetrttblparm;
1258 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1262 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1267 pgetrttblparm = (struct getratable_parm *)rtw_zmalloc(sizeof(struct getratable_parm));
1269 if (pgetrttblparm == NULL) {
1275 /* init_h2fwcmd_w_parm_no_rsp(ph2c, psetrttblparm, GEN_CMD_CODE(_SetRaTable)); */
1277 _rtw_init_listhead(&ph2c->list);
1278 ph2c->cmdcode = GEN_CMD_CODE(_GetRaTable);
1279 ph2c->parmbuf = (unsigned char *)pgetrttblparm;
1280 ph2c->cmdsz = sizeof(struct getratable_parm);
1281 ph2c->rsp = (u8 *)pval;
1282 ph2c->rspsz = sizeof(struct getratable_rsp);
1284 pgetrttblparm->rsvd = 0x0;
1286 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1292 u8 rtw_setassocsta_cmd(struct adapter *padapter, u8 *mac_addr)
1294 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1295 struct cmd_obj *ph2c;
1296 struct set_assocsta_parm *psetassocsta_para;
1297 struct set_stakey_rsp *psetassocsta_rsp = NULL;
1303 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1309 psetassocsta_para = (struct set_assocsta_parm *)rtw_zmalloc(sizeof(struct set_assocsta_parm));
1310 if (psetassocsta_para == NULL) {
1316 psetassocsta_rsp = (struct set_stakey_rsp *)rtw_zmalloc(sizeof(struct set_assocsta_rsp));
1317 if (psetassocsta_rsp == NULL) {
1319 kfree(psetassocsta_para);
1323 init_h2fwcmd_w_parm_no_rsp(ph2c, psetassocsta_para, _SetAssocSta_CMD_);
1324 ph2c->rsp = (u8 *)psetassocsta_rsp;
1325 ph2c->rspsz = sizeof(struct set_assocsta_rsp);
1327 memcpy(psetassocsta_para->addr, mac_addr, ETH_ALEN);
1329 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1338 u8 rtw_addbareq_cmd(struct adapter *padapter, u8 tid, u8 *addr)
1340 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1341 struct cmd_obj *ph2c;
1342 struct addBaReq_parm *paddbareq_parm;
1347 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1353 paddbareq_parm = (struct addBaReq_parm *)rtw_zmalloc(sizeof(struct addBaReq_parm));
1354 if (paddbareq_parm == NULL) {
1360 paddbareq_parm->tid = tid;
1361 memcpy(paddbareq_parm->addr, addr, ETH_ALEN);
1363 init_h2fwcmd_w_parm_no_rsp(ph2c, paddbareq_parm, GEN_CMD_CODE(_AddBAReq));
1365 /* DBG_88E("rtw_addbareq_cmd, tid =%d\n", tid); */
1367 /* rtw_enqueue_cmd(pcmdpriv, ph2c); */
1368 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1377 u8 rtw_dynamic_chk_wk_cmd(struct adapter *padapter)
1379 struct cmd_obj *ph2c;
1380 struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1381 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1386 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1392 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1393 if (pdrvextra_cmd_parm == NULL) {
1399 pdrvextra_cmd_parm->ec_id = DYNAMIC_CHK_WK_CID;
1400 pdrvextra_cmd_parm->type_size = 0;
1401 pdrvextra_cmd_parm->pbuf = (u8 *)padapter;
1403 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1406 /* rtw_enqueue_cmd(pcmdpriv, ph2c); */
1407 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1413 u8 rtw_set_ch_cmd(struct adapter *padapter, u8 ch, u8 bw, u8 ch_offset, u8 enqueue)
1415 struct cmd_obj *pcmdobj;
1416 struct set_ch_parm *set_ch_parm;
1417 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1423 DBG_88E(FUNC_NDEV_FMT" ch:%u, bw:%u, ch_offset:%u\n",
1424 FUNC_NDEV_ARG(padapter->pnetdev), ch, bw, ch_offset);
1426 /* check input parameter */
1428 /* prepare cmd parameter */
1429 set_ch_parm = (struct set_ch_parm *)rtw_zmalloc(sizeof(*set_ch_parm));
1430 if (set_ch_parm == NULL) {
1434 set_ch_parm->ch = ch;
1435 set_ch_parm->bw = bw;
1436 set_ch_parm->ch_offset = ch_offset;
1439 /* need enqueue, prepare cmd_obj and enqueue */
1440 pcmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1441 if (pcmdobj == NULL) {
1447 init_h2fwcmd_w_parm_no_rsp(pcmdobj, set_ch_parm, GEN_CMD_CODE(_SetChannel));
1448 res = rtw_enqueue_cmd(pcmdpriv, pcmdobj);
1450 /* no need to enqueue, do the cmd hdl directly and free cmd parameter */
1451 if (H2C_SUCCESS != set_ch_hdl(padapter, (u8 *)set_ch_parm))
1457 /* do something based on res... */
1461 DBG_88E(FUNC_NDEV_FMT" res:%u\n", FUNC_NDEV_ARG(padapter->pnetdev), res);
1468 u8 rtw_set_chplan_cmd(struct adapter *padapter, u8 chplan, u8 enqueue)
1470 struct cmd_obj *pcmdobj;
1471 struct SetChannelPlan_param *setChannelPlan_param;
1472 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1478 RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+rtw_set_chplan_cmd\n"));
1480 /* check input parameter */
1481 if (!rtw_is_channel_plan_valid(chplan)) {
1486 /* prepare cmd parameter */
1487 setChannelPlan_param = (struct SetChannelPlan_param *)rtw_zmalloc(sizeof(struct SetChannelPlan_param));
1488 if (setChannelPlan_param == NULL) {
1492 setChannelPlan_param->channel_plan = chplan;
1495 /* need enqueue, prepare cmd_obj and enqueue */
1496 pcmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1497 if (pcmdobj == NULL) {
1498 kfree(setChannelPlan_param);
1503 init_h2fwcmd_w_parm_no_rsp(pcmdobj, setChannelPlan_param, GEN_CMD_CODE(_SetChannelPlan));
1504 res = rtw_enqueue_cmd(pcmdpriv, pcmdobj);
1506 /* no need to enqueue, do the cmd hdl directly and free cmd parameter */
1507 if (H2C_SUCCESS != set_chplan_hdl(padapter, (unsigned char *)setChannelPlan_param))
1510 kfree(setChannelPlan_param);
1513 /* do something based on res... */
1514 if (res == _SUCCESS)
1515 padapter->mlmepriv.ChannelPlan = chplan;
1524 u8 rtw_led_blink_cmd(struct adapter *padapter, struct LED_871x *pLed)
1526 struct cmd_obj *pcmdobj;
1527 struct LedBlink_param *ledBlink_param;
1528 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1534 RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+rtw_led_blink_cmd\n"));
1536 pcmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1537 if (pcmdobj == NULL) {
1542 ledBlink_param = (struct LedBlink_param *)rtw_zmalloc(sizeof(struct LedBlink_param));
1543 if (ledBlink_param == NULL) {
1549 ledBlink_param->pLed = pLed;
1551 init_h2fwcmd_w_parm_no_rsp(pcmdobj, ledBlink_param, GEN_CMD_CODE(_LedBlink));
1552 res = rtw_enqueue_cmd(pcmdpriv, pcmdobj);
1561 u8 rtw_set_csa_cmd(struct adapter *padapter, u8 new_ch_no)
1563 struct cmd_obj *pcmdobj;
1564 struct SetChannelSwitch_param *setChannelSwitch_param;
1565 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1571 RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+rtw_set_csa_cmd\n"));
1573 pcmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1574 if (pcmdobj == NULL) {
1579 setChannelSwitch_param = (struct SetChannelSwitch_param *)rtw_zmalloc(sizeof(struct SetChannelSwitch_param));
1580 if (setChannelSwitch_param == NULL) {
1586 setChannelSwitch_param->new_ch_no = new_ch_no;
1588 init_h2fwcmd_w_parm_no_rsp(pcmdobj, setChannelSwitch_param, GEN_CMD_CODE(_SetChannelSwitch));
1589 res = rtw_enqueue_cmd(pcmdpriv, pcmdobj);
1598 u8 rtw_tdls_cmd(struct adapter *padapter, u8 *addr, u8 option)
1603 static void traffic_status_watchdog(struct adapter *padapter)
1606 u8 bBusyTraffic = false, bTxBusyTraffic = false, bRxBusyTraffic = false;
1607 u8 bHigherBusyTraffic = false, bHigherBusyRxTraffic = false, bHigherBusyTxTraffic = false;
1608 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1611 /* Determine if our traffic is busy now */
1613 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
1614 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > 100 ||
1615 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod > 100) {
1616 bBusyTraffic = true;
1618 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > pmlmepriv->LinkDetectInfo.NumTxOkInPeriod)
1619 bRxBusyTraffic = true;
1621 bTxBusyTraffic = true;
1624 /* Higher Tx/Rx data. */
1625 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > 4000 ||
1626 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod > 4000) {
1627 bHigherBusyTraffic = true;
1629 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > pmlmepriv->LinkDetectInfo.NumTxOkInPeriod)
1630 bHigherBusyRxTraffic = true;
1632 bHigherBusyTxTraffic = true;
1635 /* check traffic for powersaving. */
1636 if (((pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod + pmlmepriv->LinkDetectInfo.NumTxOkInPeriod) > 8) ||
1637 (pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod > 2))
1642 /* LeisurePS only work in infra mode. */
1644 LPS_Enter(padapter);
1646 LPS_Leave(padapter);
1648 LPS_Leave(padapter);
1651 pmlmepriv->LinkDetectInfo.NumRxOkInPeriod = 0;
1652 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod = 0;
1653 pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod = 0;
1654 pmlmepriv->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
1655 pmlmepriv->LinkDetectInfo.bTxBusyTraffic = bTxBusyTraffic;
1656 pmlmepriv->LinkDetectInfo.bRxBusyTraffic = bRxBusyTraffic;
1657 pmlmepriv->LinkDetectInfo.bHigherBusyTraffic = bHigherBusyTraffic;
1658 pmlmepriv->LinkDetectInfo.bHigherBusyRxTraffic = bHigherBusyRxTraffic;
1659 pmlmepriv->LinkDetectInfo.bHigherBusyTxTraffic = bHigherBusyTxTraffic;
1662 static void dynamic_chk_wk_hdl(struct adapter *padapter, u8 *pbuf, int sz)
1664 struct mlme_priv *pmlmepriv;
1666 padapter = (struct adapter *)pbuf;
1667 pmlmepriv = &(padapter->mlmepriv);
1669 #ifdef CONFIG_88EU_AP_MODE
1670 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true)
1671 expire_timeout_chk(padapter);
1674 rtw_hal_sreset_xmit_status_check(padapter);
1676 linked_status_chk(padapter);
1677 traffic_status_watchdog(padapter);
1679 rtw_hal_dm_watchdog(padapter);
1682 static void lps_ctrl_wk_hdl(struct adapter *padapter, u8 lps_ctrl_type)
1684 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
1685 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1690 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) ||
1691 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true))
1694 switch (lps_ctrl_type) {
1696 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
1698 LPS_Leave(padapter);
1701 case LPS_CTRL_JOINBSS:
1702 LPS_Leave(padapter);
1704 case LPS_CTRL_CONNECT:
1705 mstatus = 1;/* connect */
1706 /* Reset LPS Setting */
1707 padapter->pwrctrlpriv.LpsIdleCount = 0;
1708 rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_JOINBSSRPT, (u8 *)(&mstatus));
1710 case LPS_CTRL_DISCONNECT:
1711 mstatus = 0;/* disconnect */
1712 LPS_Leave(padapter);
1713 rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_JOINBSSRPT, (u8 *)(&mstatus));
1715 case LPS_CTRL_SPECIAL_PACKET:
1716 /* DBG_88E("LPS_CTRL_SPECIAL_PACKET\n"); */
1717 pwrpriv->DelayLPSLastTimeStamp = jiffies;
1718 LPS_Leave(padapter);
1720 case LPS_CTRL_LEAVE:
1721 LPS_Leave(padapter);
1730 u8 rtw_lps_ctrl_wk_cmd(struct adapter *padapter, u8 lps_ctrl_type, u8 enqueue)
1732 struct cmd_obj *ph2c;
1733 struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1734 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1735 /* struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv; */
1740 /* if (!pwrctrlpriv->bLeisurePs) */
1744 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1750 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1751 if (pdrvextra_cmd_parm == NULL) {
1757 pdrvextra_cmd_parm->ec_id = LPS_CTRL_WK_CID;
1758 pdrvextra_cmd_parm->type_size = lps_ctrl_type;
1759 pdrvextra_cmd_parm->pbuf = NULL;
1761 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1763 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1765 lps_ctrl_wk_hdl(padapter, lps_ctrl_type);
1775 static void rpt_timer_setting_wk_hdl(struct adapter *padapter, u16 min_time)
1777 rtw_hal_set_hwreg(padapter, HW_VAR_RPT_TIMER_SETTING, (u8 *)(&min_time));
1780 u8 rtw_rpt_timer_cfg_cmd(struct adapter *padapter, u16 min_time)
1782 struct cmd_obj *ph2c;
1783 struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1784 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1789 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1795 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1796 if (pdrvextra_cmd_parm == NULL) {
1802 pdrvextra_cmd_parm->ec_id = RTP_TIMER_CFG_WK_CID;
1803 pdrvextra_cmd_parm->type_size = min_time;
1804 pdrvextra_cmd_parm->pbuf = NULL;
1805 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1806 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1814 static void antenna_select_wk_hdl(struct adapter *padapter, u8 antenna)
1816 rtw_hal_set_hwreg(padapter, HW_VAR_ANTENNA_DIVERSITY_SELECT, (u8 *)(&antenna));
1819 u8 rtw_antenna_select_cmd(struct adapter *padapter, u8 antenna, u8 enqueue)
1821 struct cmd_obj *ph2c;
1822 struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1823 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1828 rtw_hal_get_def_var(padapter, HAL_DEF_IS_SUPPORT_ANT_DIV, &support_ant_div);
1829 if (!support_ant_div)
1833 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1839 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1840 if (pdrvextra_cmd_parm == NULL) {
1846 pdrvextra_cmd_parm->ec_id = ANT_SELECT_WK_CID;
1847 pdrvextra_cmd_parm->type_size = antenna;
1848 pdrvextra_cmd_parm->pbuf = NULL;
1849 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1851 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1853 antenna_select_wk_hdl(padapter, antenna);
1862 static void power_saving_wk_hdl(struct adapter *padapter, u8 *pbuf, int sz)
1864 rtw_ps_processor(padapter);
1867 #ifdef CONFIG_88EU_P2P
1868 u8 p2p_protocol_wk_cmd(struct adapter *padapter, int intCmdType)
1870 struct cmd_obj *ph2c;
1871 struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1872 struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
1873 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1878 if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
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 = P2P_PROTO_WK_CID;
1895 pdrvextra_cmd_parm->type_size = intCmdType; /* As the command tppe. */
1896 pdrvextra_cmd_parm->pbuf = NULL; /* Must be NULL here */
1898 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1900 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1908 #endif /* CONFIG_88EU_P2P */
1910 u8 rtw_ps_cmd(struct adapter *padapter)
1912 struct cmd_obj *ppscmd;
1913 struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1914 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1919 ppscmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1920 if (ppscmd == NULL) {
1925 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1926 if (pdrvextra_cmd_parm == NULL) {
1932 pdrvextra_cmd_parm->ec_id = POWER_SAVING_CTRL_WK_CID;
1933 pdrvextra_cmd_parm->pbuf = NULL;
1934 init_h2fwcmd_w_parm_no_rsp(ppscmd, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1936 res = rtw_enqueue_cmd(pcmdpriv, ppscmd);
1945 #ifdef CONFIG_88EU_AP_MODE
1947 static void rtw_chk_hi_queue_hdl(struct adapter *padapter)
1950 struct sta_info *psta_bmc;
1951 struct sta_priv *pstapriv = &padapter->stapriv;
1953 psta_bmc = rtw_get_bcmc_stainfo(padapter);
1957 if (psta_bmc->sleepq_len == 0) {
1960 /* while ((rtw_read32(padapter, 0x414)&0x00ffff00)!= 0) */
1961 /* while ((rtw_read32(padapter, 0x414)&0x0000ff00)!= 0) */
1963 rtw_hal_get_hwreg(padapter, HW_VAR_CHK_HI_QUEUE_EMPTY, &val);
1973 rtw_hal_get_hwreg(padapter, HW_VAR_CHK_HI_QUEUE_EMPTY, &val);
1977 pstapriv->tim_bitmap &= ~BIT(0);
1978 pstapriv->sta_dz_bitmap &= ~BIT(0);
1980 update_beacon(padapter, _TIM_IE_, NULL, false);
1981 } else { /* re check again */
1982 rtw_chk_hi_queue_cmd(padapter);
1987 u8 rtw_chk_hi_queue_cmd(struct adapter *padapter)
1989 struct cmd_obj *ph2c;
1990 struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1991 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1994 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
2000 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
2001 if (pdrvextra_cmd_parm == NULL) {
2007 pdrvextra_cmd_parm->ec_id = CHECK_HIQ_WK_CID;
2008 pdrvextra_cmd_parm->type_size = 0;
2009 pdrvextra_cmd_parm->pbuf = NULL;
2011 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
2013 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
2019 u8 rtw_c2h_wk_cmd(struct adapter *padapter, u8 *c2h_evt)
2021 struct cmd_obj *ph2c;
2022 struct drvextra_cmd_parm *pdrvextra_cmd_parm;
2023 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
2026 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
2032 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
2033 if (pdrvextra_cmd_parm == NULL) {
2039 pdrvextra_cmd_parm->ec_id = C2H_WK_CID;
2040 pdrvextra_cmd_parm->type_size = c2h_evt ? 16 : 0;
2041 pdrvextra_cmd_parm->pbuf = c2h_evt;
2043 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
2045 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
2052 static s32 c2h_evt_hdl(struct adapter *adapter, struct c2h_evt_hdr *c2h_evt, c2h_id_filter filter)
2058 /* No c2h event in cmd_obj, read c2h event before handling*/
2059 if (c2h_evt_read(adapter, buf) == _SUCCESS) {
2060 c2h_evt = (struct c2h_evt_hdr *)buf;
2062 if (filter && filter(c2h_evt->id) == false)
2065 ret = rtw_hal_c2h_handler(adapter, c2h_evt);
2068 if (filter && filter(c2h_evt->id) == false)
2071 ret = rtw_hal_c2h_handler(adapter, c2h_evt);
2077 static void c2h_wk_callback(struct work_struct *work)
2079 struct evt_priv *evtpriv = container_of(work, struct evt_priv, c2h_wk);
2080 struct adapter *adapter = container_of(evtpriv, struct adapter, evtpriv);
2081 struct c2h_evt_hdr *c2h_evt;
2082 c2h_id_filter ccx_id_filter = rtw_hal_c2h_id_filter_ccx(adapter);
2084 evtpriv->c2h_wk_alive = true;
2086 while (!rtw_cbuf_empty(evtpriv->c2h_queue)) {
2087 if ((c2h_evt = (struct c2h_evt_hdr *)rtw_cbuf_pop(evtpriv->c2h_queue)) != NULL) {
2088 /* This C2H event is read, clear it */
2089 c2h_evt_clear(adapter);
2090 } else if ((c2h_evt = (struct c2h_evt_hdr *)rtw_malloc(16)) != NULL) {
2091 /* This C2H event is not read, read & clear now */
2092 if (c2h_evt_read(adapter, (u8 *)c2h_evt) != _SUCCESS)
2096 /* Special pointer to trigger c2h_evt_clear only */
2097 if ((void *)c2h_evt == (void *)evtpriv)
2100 if (!c2h_evt_exist(c2h_evt)) {
2105 if (ccx_id_filter(c2h_evt->id) == true) {
2106 /* Handle CCX report here */
2107 rtw_hal_c2h_handler(adapter, c2h_evt);
2110 #ifdef CONFIG_88EU_P2P
2111 /* Enqueue into cmd_thread for others */
2112 rtw_c2h_wk_cmd(adapter, (u8 *)c2h_evt);
2117 evtpriv->c2h_wk_alive = false;
2120 u8 rtw_drvextra_cmd_hdl(struct adapter *padapter, unsigned char *pbuf)
2122 struct drvextra_cmd_parm *pdrvextra_cmd;
2125 return H2C_PARAMETERS_ERROR;
2127 pdrvextra_cmd = (struct drvextra_cmd_parm *)pbuf;
2129 switch (pdrvextra_cmd->ec_id) {
2130 case DYNAMIC_CHK_WK_CID:
2131 dynamic_chk_wk_hdl(padapter, pdrvextra_cmd->pbuf, pdrvextra_cmd->type_size);
2133 case POWER_SAVING_CTRL_WK_CID:
2134 power_saving_wk_hdl(padapter, pdrvextra_cmd->pbuf, pdrvextra_cmd->type_size);
2136 case LPS_CTRL_WK_CID:
2137 lps_ctrl_wk_hdl(padapter, (u8)pdrvextra_cmd->type_size);
2139 case RTP_TIMER_CFG_WK_CID:
2140 rpt_timer_setting_wk_hdl(padapter, pdrvextra_cmd->type_size);
2142 case ANT_SELECT_WK_CID:
2143 antenna_select_wk_hdl(padapter, pdrvextra_cmd->type_size);
2145 #ifdef CONFIG_88EU_P2P
2147 p2p_ps_wk_hdl(padapter, pdrvextra_cmd->type_size);
2149 case P2P_PROTO_WK_CID:
2150 /* Commented by Albert 2011/07/01 */
2151 /* I used the type_size as the type command */
2152 p2p_protocol_wk_hdl(padapter, pdrvextra_cmd->type_size);
2155 #ifdef CONFIG_88EU_AP_MODE
2156 case CHECK_HIQ_WK_CID:
2157 rtw_chk_hi_queue_hdl(padapter);
2159 #endif /* CONFIG_88EU_AP_MODE */
2161 c2h_evt_hdl(padapter, (struct c2h_evt_hdr *)pdrvextra_cmd->pbuf, NULL);
2167 if (pdrvextra_cmd->pbuf && pdrvextra_cmd->type_size > 0)
2168 kfree(pdrvextra_cmd->pbuf);
2173 void rtw_survey_cmd_callback(struct adapter *padapter, struct cmd_obj *pcmd)
2175 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2179 if (pcmd->res == H2C_DROPPED) {
2180 /* TODO: cancel timer and do timeout handler directly... */
2181 /* need to make timeout handlerOS independent */
2182 _set_timer(&pmlmepriv->scan_to_timer, 1);
2183 } else if (pcmd->res != H2C_SUCCESS) {
2184 _set_timer(&pmlmepriv->scan_to_timer, 1);
2185 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n ********Error: MgntActrtw_set_802_11_bssid_LIST_SCAN Fail ************\n\n."));
2189 rtw_free_cmd_obj(pcmd);
2193 void rtw_disassoc_cmd_callback(struct adapter *padapter, struct cmd_obj *pcmd)
2195 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2199 if (pcmd->res != H2C_SUCCESS) {
2200 spin_lock_bh(&pmlmepriv->lock);
2201 set_fwstate(pmlmepriv, _FW_LINKED);
2202 spin_unlock_bh(&pmlmepriv->lock);
2204 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n ***Error: disconnect_cmd_callback Fail ***\n."));
2207 } else /* clear bridge database */
2208 nat25_db_cleanup(padapter);
2211 rtw_free_cmd_obj(pcmd);
2218 void rtw_joinbss_cmd_callback(struct adapter *padapter, struct cmd_obj *pcmd)
2220 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2224 if (pcmd->res == H2C_DROPPED) {
2225 /* TODO: cancel timer and do timeout handler directly... */
2226 /* need to make timeout handlerOS independent */
2227 _set_timer(&pmlmepriv->assoc_timer, 1);
2228 } else if (pcmd->res != H2C_SUCCESS) {
2229 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("********Error:rtw_select_and_join_from_scanned_queue Wait Sema Fail ************\n"));
2230 _set_timer(&pmlmepriv->assoc_timer, 1);
2233 rtw_free_cmd_obj(pcmd);
2238 void rtw_createbss_cmd_callback(struct adapter *padapter, struct cmd_obj *pcmd)
2241 struct sta_info *psta = NULL;
2242 struct wlan_network *pwlan = NULL;
2243 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2244 struct wlan_bssid_ex *pnetwork = (struct wlan_bssid_ex *)pcmd->parmbuf;
2245 struct wlan_network *tgt_network = &(pmlmepriv->cur_network);
2249 if ((pcmd->res != H2C_SUCCESS)) {
2250 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n ********Error: rtw_createbss_cmd_callback Fail ************\n\n."));
2251 _set_timer(&pmlmepriv->assoc_timer, 1);
2254 _cancel_timer(&pmlmepriv->assoc_timer, &timer_cancelled);
2256 spin_lock_bh(&pmlmepriv->lock);
2258 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
2259 psta = rtw_get_stainfo(&padapter->stapriv, pnetwork->MacAddress);
2261 psta = rtw_alloc_stainfo(&padapter->stapriv, pnetwork->MacAddress);
2263 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\nCan't alloc sta_info when createbss_cmd_callback\n"));
2264 goto createbss_cmd_fail ;
2268 rtw_indicate_connect(padapter);
2270 pwlan = _rtw_alloc_network(pmlmepriv);
2271 spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
2272 if (pwlan == NULL) {
2273 pwlan = rtw_get_oldest_wlan_network(&pmlmepriv->scanned_queue);
2274 if (pwlan == NULL) {
2275 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n Error: can't get pwlan in rtw_joinbss_event_callback\n"));
2276 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
2277 goto createbss_cmd_fail;
2279 pwlan->last_scanned = jiffies;
2281 rtw_list_insert_tail(&(pwlan->list), &pmlmepriv->scanned_queue.queue);
2284 pnetwork->Length = get_wlan_bssid_ex_sz(pnetwork);
2285 memcpy(&(pwlan->network), pnetwork, pnetwork->Length);
2287 memcpy(&tgt_network->network, pnetwork, (get_wlan_bssid_ex_sz(pnetwork)));
2289 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
2291 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
2292 /* we will set _FW_LINKED when there is one more sat to join us (rtw_stassoc_event_callback) */
2297 spin_unlock_bh(&pmlmepriv->lock);
2299 rtw_free_cmd_obj(pcmd);
2304 void rtw_setstaKey_cmdrsp_callback(struct adapter *padapter, struct cmd_obj *pcmd)
2306 struct sta_priv *pstapriv = &padapter->stapriv;
2307 struct set_stakey_rsp *psetstakey_rsp = (struct set_stakey_rsp *)(pcmd->rsp);
2308 struct sta_info *psta = rtw_get_stainfo(pstapriv, psetstakey_rsp->addr);
2313 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\nERROR: rtw_setstaKey_cmdrsp_callback => can't get sta_info\n\n"));
2317 rtw_free_cmd_obj(pcmd);
2321 void rtw_setassocsta_cmdrsp_callback(struct adapter *padapter, struct cmd_obj *pcmd)
2323 struct sta_priv *pstapriv = &padapter->stapriv;
2324 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2325 struct set_assocsta_parm *passocsta_parm = (struct set_assocsta_parm *)(pcmd->parmbuf);
2326 struct set_assocsta_rsp *passocsta_rsp = (struct set_assocsta_rsp *)(pcmd->rsp);
2327 struct sta_info *psta = rtw_get_stainfo(pstapriv, passocsta_parm->addr);
2332 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\nERROR: setassocsta_cmdrsp_callbac => can't get sta_info\n\n"));
2336 psta->aid = passocsta_rsp->cam_id;
2337 psta->mac_id = passocsta_rsp->cam_id;
2339 spin_lock_bh(&pmlmepriv->lock);
2341 if ((check_fwstate(pmlmepriv, WIFI_MP_STATE) == true) && (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true))
2342 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
2344 set_fwstate(pmlmepriv, _FW_LINKED);
2345 spin_unlock_bh(&pmlmepriv->lock);
2348 rtw_free_cmd_obj(pcmd);