1 // SPDX-License-Identifier: GPL-2.0
2 /******************************************************************************
5 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
6 * Linux device driver for RTL8192SU
8 * Modifications for inclusion into the Linux staging tree are
9 * Copyright(c) 2010 Larry Finger. All rights reserved.
11 * Contact information:
12 * WLAN FAE <wlanfae@realtek.com>
13 * Larry Finger <Larry.Finger@lwfinger.net>
15 ******************************************************************************/
17 #define _RTL871X_CMD_C_
19 #include <linux/compiler.h>
20 #include <linux/kernel.h>
21 #include <linux/errno.h>
22 #include <linux/slab.h>
23 #include <linux/module.h>
24 #include <linux/kref.h>
25 #include <linux/netdevice.h>
26 #include <linux/skbuff.h>
27 #include <linux/usb.h>
28 #include <linux/usb/ch9.h>
29 #include <linux/circ_buf.h>
30 #include <linux/uaccess.h>
31 #include <asm/byteorder.h>
32 #include <linux/atomic.h>
33 #include <linux/semaphore.h>
34 #include <linux/rtnetlink.h>
36 #include "osdep_service.h"
37 #include "drv_types.h"
38 #include "recv_osdep.h"
39 #include "mlme_osdep.h"
42 * Caller and the r8712_cmd_thread can protect cmd_q by spin_lock.
43 * No irqsave is necessary.
46 int r8712_init_cmd_priv(struct cmd_priv *pcmdpriv)
48 init_completion(&pcmdpriv->cmd_queue_comp);
49 init_completion(&pcmdpriv->terminate_cmdthread_comp);
51 _init_queue(&(pcmdpriv->cmd_queue));
53 /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
54 pcmdpriv->cmd_seq = 1;
55 pcmdpriv->cmd_allocated_buf = kmalloc(MAX_CMDSZ + CMDBUFF_ALIGN_SZ,
57 if (!pcmdpriv->cmd_allocated_buf)
59 pcmdpriv->cmd_buf = pcmdpriv->cmd_allocated_buf + CMDBUFF_ALIGN_SZ -
60 ((addr_t)(pcmdpriv->cmd_allocated_buf) &
61 (CMDBUFF_ALIGN_SZ - 1));
62 pcmdpriv->rsp_allocated_buf = kmalloc(MAX_RSPSZ + 4, GFP_ATOMIC);
63 if (!pcmdpriv->rsp_allocated_buf) {
64 kfree(pcmdpriv->cmd_allocated_buf);
65 pcmdpriv->cmd_allocated_buf = NULL;
68 pcmdpriv->rsp_buf = pcmdpriv->rsp_allocated_buf + 4 -
69 ((addr_t)(pcmdpriv->rsp_allocated_buf) & 3);
70 pcmdpriv->cmd_issued_cnt = 0;
71 pcmdpriv->cmd_done_cnt = 0;
72 pcmdpriv->rsp_cnt = 0;
76 int r8712_init_evt_priv(struct evt_priv *pevtpriv)
78 /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
79 pevtpriv->event_seq = 0;
80 pevtpriv->evt_allocated_buf = kmalloc(MAX_EVTSZ + 4, GFP_ATOMIC);
82 if (!pevtpriv->evt_allocated_buf)
84 pevtpriv->evt_buf = pevtpriv->evt_allocated_buf + 4 -
85 ((addr_t)(pevtpriv->evt_allocated_buf) & 3);
86 pevtpriv->evt_done_cnt = 0;
90 void r8712_free_evt_priv(struct evt_priv *pevtpriv)
92 kfree(pevtpriv->evt_allocated_buf);
95 void r8712_free_cmd_priv(struct cmd_priv *pcmdpriv)
98 kfree(pcmdpriv->cmd_allocated_buf);
99 kfree(pcmdpriv->rsp_allocated_buf);
106 * r8712_enqueue_cmd can only be called between kernel thread,
107 * since only spin_lock is used.
109 * ISR/Call-Back functions can't call this sub-function.
113 void r8712_enqueue_cmd(struct cmd_priv *pcmdpriv, struct cmd_obj *obj)
115 struct __queue *queue;
118 if (pcmdpriv->padapter->eeprompriv.bautoload_fail_flag)
122 queue = &pcmdpriv->cmd_queue;
123 spin_lock_irqsave(&queue->lock, irqL);
124 list_add_tail(&obj->list, &queue->queue);
125 spin_unlock_irqrestore(&queue->lock, irqL);
126 complete(&pcmdpriv->cmd_queue_comp);
129 struct cmd_obj *r8712_dequeue_cmd(struct __queue *queue)
134 spin_lock_irqsave(&queue->lock, irqL);
135 obj = list_first_entry_or_null(&queue->queue,
136 struct cmd_obj, list);
138 list_del_init(&obj->list);
139 spin_unlock_irqrestore(&queue->lock, irqL);
143 void r8712_enqueue_cmd_ex(struct cmd_priv *pcmdpriv, struct cmd_obj *obj)
146 struct __queue *queue;
150 if (pcmdpriv->padapter->eeprompriv.bautoload_fail_flag)
152 queue = &pcmdpriv->cmd_queue;
153 spin_lock_irqsave(&queue->lock, irqL);
154 list_add_tail(&obj->list, &queue->queue);
155 spin_unlock_irqrestore(&queue->lock, irqL);
156 complete(&pcmdpriv->cmd_queue_comp);
159 void r8712_free_cmd_obj(struct cmd_obj *pcmd)
161 if ((pcmd->cmdcode != _JoinBss_CMD_) &&
162 (pcmd->cmdcode != _CreateBss_CMD_))
163 kfree(pcmd->parmbuf);
165 if (pcmd->rspsz != 0)
171 u8 r8712_sitesurvey_cmd(struct _adapter *padapter,
172 struct ndis_802_11_ssid *pssid)
173 __must_hold(&padapter->mlmepriv.lock)
175 struct cmd_obj *ph2c;
176 struct sitesurvey_parm *psurveyPara;
177 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
178 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
180 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
183 psurveyPara = kmalloc(sizeof(*psurveyPara), GFP_ATOMIC);
188 init_h2fwcmd_w_parm_no_rsp(ph2c, psurveyPara,
189 GEN_CMD_CODE(_SiteSurvey));
190 psurveyPara->bsslimit = cpu_to_le32(48);
191 psurveyPara->passive_mode = cpu_to_le32(pmlmepriv->passive_mode);
192 psurveyPara->ss_ssidlen = 0;
193 memset(psurveyPara->ss_ssid, 0, IW_ESSID_MAX_SIZE + 1);
194 if (pssid && pssid->SsidLength) {
195 int len = min_t(int, pssid->SsidLength, IW_ESSID_MAX_SIZE);
197 memcpy(psurveyPara->ss_ssid, pssid->Ssid, len);
198 psurveyPara->ss_ssidlen = cpu_to_le32(len);
200 set_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
201 r8712_enqueue_cmd(pcmdpriv, ph2c);
202 mod_timer(&pmlmepriv->scan_to_timer,
203 jiffies + msecs_to_jiffies(SCANNING_TIMEOUT));
204 padapter->ledpriv.LedControlHandler(padapter, LED_CTL_SITE_SURVEY);
205 complete(&padapter->rx_filter_ready);
209 int r8712_setdatarate_cmd(struct _adapter *padapter, u8 *rateset)
211 struct cmd_obj *ph2c;
212 struct setdatarate_parm *pbsetdataratepara;
213 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
215 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
218 pbsetdataratepara = kmalloc(sizeof(*pbsetdataratepara), GFP_ATOMIC);
219 if (!pbsetdataratepara) {
223 init_h2fwcmd_w_parm_no_rsp(ph2c, pbsetdataratepara,
224 GEN_CMD_CODE(_SetDataRate));
225 pbsetdataratepara->mac_id = 5;
226 memcpy(pbsetdataratepara->datarates, rateset, NumRates);
227 r8712_enqueue_cmd(pcmdpriv, ph2c);
231 void r8712_set_chplan_cmd(struct _adapter *padapter, int chplan)
233 struct cmd_obj *ph2c;
234 struct SetChannelPlan_param *psetchplanpara;
235 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
237 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
240 psetchplanpara = kmalloc(sizeof(*psetchplanpara), GFP_ATOMIC);
241 if (!psetchplanpara) {
245 init_h2fwcmd_w_parm_no_rsp(ph2c, psetchplanpara, GEN_CMD_CODE(_SetChannelPlan));
246 psetchplanpara->ChannelPlan = chplan;
247 r8712_enqueue_cmd(pcmdpriv, ph2c);
250 int r8712_setrfreg_cmd(struct _adapter *padapter, u8 offset, u32 val)
252 struct cmd_obj *ph2c;
253 struct writeRF_parm *pwriterfparm;
254 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
256 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
259 pwriterfparm = kmalloc(sizeof(*pwriterfparm), GFP_ATOMIC);
264 init_h2fwcmd_w_parm_no_rsp(ph2c, pwriterfparm, GEN_CMD_CODE(_SetRFReg));
265 pwriterfparm->offset = offset;
266 pwriterfparm->value = val;
267 r8712_enqueue_cmd(pcmdpriv, ph2c);
271 int r8712_getrfreg_cmd(struct _adapter *padapter, u8 offset, u8 *pval)
273 struct cmd_obj *ph2c;
274 struct readRF_parm *prdrfparm;
275 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
277 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
280 prdrfparm = kmalloc(sizeof(*prdrfparm), GFP_ATOMIC);
285 INIT_LIST_HEAD(&ph2c->list);
286 ph2c->cmdcode = GEN_CMD_CODE(_GetRFReg);
287 ph2c->parmbuf = (unsigned char *)prdrfparm;
288 ph2c->cmdsz = sizeof(struct readRF_parm);
290 ph2c->rspsz = sizeof(struct readRF_rsp);
291 prdrfparm->offset = offset;
292 r8712_enqueue_cmd(pcmdpriv, ph2c);
296 void r8712_getbbrfreg_cmdrsp_callback(struct _adapter *padapter,
297 struct cmd_obj *pcmd)
299 kfree(pcmd->parmbuf);
301 padapter->mppriv.workparam.bcompleted = true;
304 void r8712_readtssi_cmdrsp_callback(struct _adapter *padapter, struct cmd_obj *pcmd)
306 kfree(pcmd->parmbuf);
309 padapter->mppriv.workparam.bcompleted = true;
312 int r8712_createbss_cmd(struct _adapter *padapter)
314 struct cmd_obj *pcmd;
315 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
316 struct wlan_bssid_ex *pdev_network =
317 &padapter->registrypriv.dev_network;
319 padapter->ledpriv.LedControlHandler(padapter, LED_CTL_START_TO_LINK);
320 pcmd = kmalloc(sizeof(*pcmd), GFP_ATOMIC);
323 INIT_LIST_HEAD(&pcmd->list);
324 pcmd->cmdcode = _CreateBss_CMD_;
325 pcmd->parmbuf = (unsigned char *)pdev_network;
326 pcmd->cmdsz = r8712_get_wlan_bssid_ex_sz(pdev_network);
329 /* notes: translate IELength & Length after assign to cmdsz; */
330 pdev_network->Length = pcmd->cmdsz;
331 pdev_network->IELength = pdev_network->IELength;
332 pdev_network->Ssid.SsidLength = pdev_network->Ssid.SsidLength;
333 r8712_enqueue_cmd(pcmdpriv, pcmd);
337 int r8712_joinbss_cmd(struct _adapter *padapter, struct wlan_network *pnetwork)
339 struct wlan_bssid_ex *psecnetwork;
340 struct cmd_obj *pcmd;
341 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
342 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
343 struct qos_priv *pqospriv = &pmlmepriv->qospriv;
344 struct security_priv *psecuritypriv = &padapter->securitypriv;
345 struct registry_priv *pregistrypriv = &padapter->registrypriv;
346 enum NDIS_802_11_NETWORK_INFRASTRUCTURE ndis_network_mode =
347 pnetwork->network.InfrastructureMode;
349 padapter->ledpriv.LedControlHandler(padapter, LED_CTL_START_TO_LINK);
350 pcmd = kmalloc(sizeof(*pcmd), GFP_ATOMIC);
354 /* for hidden ap to set fw_state here */
355 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE | WIFI_ADHOC_STATE) !=
357 switch (ndis_network_mode) {
359 pmlmepriv->fw_state |= WIFI_ADHOC_STATE;
361 case Ndis802_11Infrastructure:
362 pmlmepriv->fw_state |= WIFI_STATION_STATE;
364 case Ndis802_11APMode:
365 case Ndis802_11AutoUnknown:
366 case Ndis802_11InfrastructureMax:
370 psecnetwork = &psecuritypriv->sec_bss;
371 memcpy(psecnetwork, &pnetwork->network, sizeof(*psecnetwork));
372 psecuritypriv->authenticator_ie[0] = (unsigned char)
373 psecnetwork->IELength;
374 if ((psecnetwork->IELength - 12) < (256 - 1))
375 memcpy(&psecuritypriv->authenticator_ie[1], &psecnetwork->IEs[12],
376 psecnetwork->IELength - 12);
378 memcpy(&psecuritypriv->authenticator_ie[1], &psecnetwork->IEs[12], (256 - 1));
379 psecnetwork->IELength = 0;
381 * If the driver wants to use the bssid to create the connection.
382 * If not, we copy the connecting AP's MAC address to it so that
383 * the driver just has the bssid information for PMKIDList searching.
385 if (!pmlmepriv->assoc_by_bssid)
386 ether_addr_copy(&pmlmepriv->assoc_bssid[0],
387 &pnetwork->network.MacAddress[0]);
388 psecnetwork->IELength = r8712_restruct_sec_ie(padapter, &pnetwork->network.IEs[0],
389 &psecnetwork->IEs[0], pnetwork->network.IELength);
390 pqospriv->qos_option = 0;
391 if (pregistrypriv->wmm_enable) {
394 tmp_len = r8712_restruct_wmm_ie(padapter, &pnetwork->network.IEs[0],
395 &psecnetwork->IEs[0], pnetwork->network.IELength,
396 psecnetwork->IELength);
397 if (psecnetwork->IELength != tmp_len) {
398 psecnetwork->IELength = tmp_len;
399 pqospriv->qos_option = 1; /* WMM IE in beacon */
401 pqospriv->qos_option = 0; /* no WMM IE in beacon */
404 if (pregistrypriv->ht_enable) {
406 * For WEP mode, we will use the bg mode to do the connection
407 * to avoid some IOT issues, especially for Realtek 8192u
410 if ((padapter->securitypriv.PrivacyAlgrthm != _WEP40_) &&
411 (padapter->securitypriv.PrivacyAlgrthm != _WEP104_)) {
412 /* restructure_ht_ie */
413 r8712_restructure_ht_ie(padapter,
414 &pnetwork->network.IEs[0],
415 &psecnetwork->IEs[0],
416 pnetwork->network.IELength,
417 &psecnetwork->IELength);
420 psecuritypriv->supplicant_ie[0] = (u8)psecnetwork->IELength;
421 if (psecnetwork->IELength < 255)
422 memcpy(&psecuritypriv->supplicant_ie[1], &psecnetwork->IEs[0],
423 psecnetwork->IELength);
425 memcpy(&psecuritypriv->supplicant_ie[1], &psecnetwork->IEs[0],
427 /* get cmdsz before endian conversion */
428 pcmd->cmdsz = r8712_get_wlan_bssid_ex_sz(psecnetwork);
430 /* wlan_network endian conversion */
431 psecnetwork->Length = cpu_to_le32(psecnetwork->Length);
432 psecnetwork->Ssid.SsidLength = cpu_to_le32(psecnetwork->Ssid.SsidLength);
433 psecnetwork->Privacy = cpu_to_le32(psecnetwork->Privacy);
434 psecnetwork->Rssi = cpu_to_le32(psecnetwork->Rssi);
435 psecnetwork->NetworkTypeInUse = cpu_to_le32(psecnetwork->NetworkTypeInUse);
436 psecnetwork->Configuration.ATIMWindow = cpu_to_le32(psecnetwork->Configuration.ATIMWindow);
437 psecnetwork->Configuration.BeaconPeriod = cpu_to_le32(psecnetwork->Configuration.BeaconPeriod);
438 psecnetwork->Configuration.DSConfig = cpu_to_le32(psecnetwork->Configuration.DSConfig);
439 psecnetwork->Configuration.FHConfig.DwellTime = cpu_to_le32(psecnetwork->Configuration.FHConfig.DwellTime);
440 psecnetwork->Configuration.FHConfig.HopPattern = cpu_to_le32(psecnetwork->Configuration.FHConfig.HopPattern);
441 psecnetwork->Configuration.FHConfig.HopSet = cpu_to_le32(psecnetwork->Configuration.FHConfig.HopSet);
442 psecnetwork->Configuration.FHConfig.Length = cpu_to_le32(psecnetwork->Configuration.FHConfig.Length);
443 psecnetwork->Configuration.Length = cpu_to_le32(psecnetwork->Configuration.Length);
444 psecnetwork->InfrastructureMode = cpu_to_le32(psecnetwork->InfrastructureMode);
445 psecnetwork->IELength = cpu_to_le32(psecnetwork->IELength);
447 INIT_LIST_HEAD(&pcmd->list);
448 pcmd->cmdcode = _JoinBss_CMD_;
449 pcmd->parmbuf = (unsigned char *)psecnetwork;
452 r8712_enqueue_cmd(pcmdpriv, pcmd);
456 void r8712_disassoc_cmd(struct _adapter *padapter) /* for sta_mode */
458 struct cmd_obj *pdisconnect_cmd;
459 struct disconnect_parm *pdisconnect;
460 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
462 pdisconnect_cmd = kmalloc(sizeof(*pdisconnect_cmd), GFP_ATOMIC);
463 if (!pdisconnect_cmd)
465 pdisconnect = kmalloc(sizeof(*pdisconnect), GFP_ATOMIC);
467 kfree(pdisconnect_cmd);
470 init_h2fwcmd_w_parm_no_rsp(pdisconnect_cmd, pdisconnect, _DisConnect_CMD_);
471 r8712_enqueue_cmd(pcmdpriv, pdisconnect_cmd);
474 void r8712_setopmode_cmd(struct _adapter *padapter,
475 enum NDIS_802_11_NETWORK_INFRASTRUCTURE networktype)
477 struct cmd_obj *ph2c;
478 struct setopmode_parm *psetop;
480 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
482 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
485 psetop = kmalloc(sizeof(*psetop), GFP_ATOMIC);
490 init_h2fwcmd_w_parm_no_rsp(ph2c, psetop, _SetOpMode_CMD_);
491 psetop->mode = (u8)networktype;
492 r8712_enqueue_cmd(pcmdpriv, ph2c);
495 void r8712_setstakey_cmd(struct _adapter *padapter, u8 *psta, u8 unicast_key)
497 struct cmd_obj *ph2c;
498 struct set_stakey_parm *psetstakey_para;
499 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
500 struct set_stakey_rsp *psetstakey_rsp = NULL;
501 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
502 struct security_priv *psecuritypriv = &padapter->securitypriv;
503 struct sta_info *sta = (struct sta_info *)psta;
505 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
508 psetstakey_para = kmalloc(sizeof(*psetstakey_para), GFP_ATOMIC);
509 if (!psetstakey_para) {
513 psetstakey_rsp = kmalloc(sizeof(*psetstakey_rsp), GFP_ATOMIC);
514 if (!psetstakey_rsp) {
516 kfree(psetstakey_para);
519 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_);
520 ph2c->rsp = (u8 *)psetstakey_rsp;
521 ph2c->rspsz = sizeof(struct set_stakey_rsp);
522 ether_addr_copy(psetstakey_para->addr, sta->hwaddr);
523 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
524 psetstakey_para->algorithm = (unsigned char)
525 psecuritypriv->PrivacyAlgrthm;
527 GET_ENCRY_ALGO(psecuritypriv, sta, psetstakey_para->algorithm, false);
529 memcpy(&psetstakey_para->key, &sta->x_UncstKey, 16);
531 memcpy(&psetstakey_para->key, &psecuritypriv->XGrpKey[psecuritypriv->XGrpKeyid - 1].
533 r8712_enqueue_cmd(pcmdpriv, ph2c);
536 void r8712_setMacAddr_cmd(struct _adapter *padapter, const u8 *mac_addr)
538 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
539 struct cmd_obj *ph2c;
540 struct SetMacAddr_param *psetMacAddr_para;
542 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
545 psetMacAddr_para = kmalloc(sizeof(*psetMacAddr_para), GFP_ATOMIC);
546 if (!psetMacAddr_para) {
550 init_h2fwcmd_w_parm_no_rsp(ph2c, psetMacAddr_para, _SetMacAddress_CMD_);
551 ether_addr_copy(psetMacAddr_para->MacAddr, mac_addr);
552 r8712_enqueue_cmd(pcmdpriv, ph2c);
555 void r8712_addbareq_cmd(struct _adapter *padapter, u8 tid)
557 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
558 struct cmd_obj *ph2c;
559 struct addBaReq_parm *paddbareq_parm;
561 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
564 paddbareq_parm = kmalloc(sizeof(*paddbareq_parm), GFP_ATOMIC);
565 if (!paddbareq_parm) {
569 paddbareq_parm->tid = tid;
570 init_h2fwcmd_w_parm_no_rsp(ph2c, paddbareq_parm, GEN_CMD_CODE(_AddBAReq));
571 r8712_enqueue_cmd_ex(pcmdpriv, ph2c);
574 void r8712_wdg_wk_cmd(struct _adapter *padapter)
576 struct cmd_obj *ph2c;
577 struct drvint_cmd_parm *pdrvintcmd_param;
578 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
580 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
583 pdrvintcmd_param = kmalloc(sizeof(*pdrvintcmd_param), GFP_ATOMIC);
584 if (!pdrvintcmd_param) {
588 pdrvintcmd_param->i_cid = WDG_WK_CID;
589 pdrvintcmd_param->sz = 0;
590 pdrvintcmd_param->pbuf = NULL;
591 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvintcmd_param, _DRV_INT_CMD_);
592 r8712_enqueue_cmd_ex(pcmdpriv, ph2c);
595 void r8712_survey_cmd_callback(struct _adapter *padapter, struct cmd_obj *pcmd)
597 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
599 if (pcmd->res != H2C_SUCCESS)
600 clr_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
601 r8712_free_cmd_obj(pcmd);
604 void r8712_disassoc_cmd_callback(struct _adapter *padapter,
605 struct cmd_obj *pcmd)
608 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
610 if (pcmd->res != H2C_SUCCESS) {
611 spin_lock_irqsave(&pmlmepriv->lock, irqL);
612 set_fwstate(pmlmepriv, _FW_LINKED);
613 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
616 r8712_free_cmd_obj(pcmd);
619 void r8712_joinbss_cmd_callback(struct _adapter *padapter, struct cmd_obj *pcmd)
621 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
623 if (pcmd->res != H2C_SUCCESS)
624 mod_timer(&pmlmepriv->assoc_timer, jiffies + msecs_to_jiffies(1));
625 r8712_free_cmd_obj(pcmd);
628 void r8712_createbss_cmd_callback(struct _adapter *padapter, struct cmd_obj *pcmd)
631 struct sta_info *psta = NULL;
632 struct wlan_network *pwlan = NULL;
633 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
634 struct wlan_bssid_ex *pnetwork = (struct wlan_bssid_ex *)pcmd->parmbuf;
635 struct wlan_network *tgt_network = &(pmlmepriv->cur_network);
637 if (pcmd->res != H2C_SUCCESS)
638 mod_timer(&pmlmepriv->assoc_timer, jiffies + msecs_to_jiffies(1));
639 del_timer(&pmlmepriv->assoc_timer);
642 pnetwork->Length = le32_to_cpu(pnetwork->Length);
643 pnetwork->Ssid.SsidLength = le32_to_cpu(pnetwork->Ssid.SsidLength);
644 pnetwork->Privacy = le32_to_cpu(pnetwork->Privacy);
645 pnetwork->Rssi = le32_to_cpu(pnetwork->Rssi);
646 pnetwork->NetworkTypeInUse = le32_to_cpu(pnetwork->NetworkTypeInUse);
647 pnetwork->Configuration.ATIMWindow = le32_to_cpu(pnetwork->Configuration.ATIMWindow);
648 pnetwork->Configuration.DSConfig = le32_to_cpu(pnetwork->Configuration.DSConfig);
649 pnetwork->Configuration.FHConfig.DwellTime = le32_to_cpu(pnetwork->Configuration.FHConfig.DwellTime);
650 pnetwork->Configuration.FHConfig.HopPattern = le32_to_cpu(pnetwork->Configuration.FHConfig.HopPattern);
651 pnetwork->Configuration.FHConfig.HopSet = le32_to_cpu(pnetwork->Configuration.FHConfig.HopSet);
652 pnetwork->Configuration.FHConfig.Length = le32_to_cpu(pnetwork->Configuration.FHConfig.Length);
653 pnetwork->Configuration.Length = le32_to_cpu(pnetwork->Configuration.Length);
654 pnetwork->InfrastructureMode = le32_to_cpu(pnetwork->InfrastructureMode);
655 pnetwork->IELength = le32_to_cpu(pnetwork->IELength);
657 spin_lock_irqsave(&pmlmepriv->lock, irqL);
658 if ((pmlmepriv->fw_state) & WIFI_AP_STATE) {
659 psta = r8712_get_stainfo(&padapter->stapriv, pnetwork->MacAddress);
661 psta = r8712_alloc_stainfo(&padapter->stapriv, pnetwork->MacAddress);
663 goto createbss_cmd_fail;
665 r8712_indicate_connect(padapter);
667 pwlan = _r8712_alloc_network(pmlmepriv);
669 pwlan = r8712_get_oldest_wlan_network(&pmlmepriv->scanned_queue);
671 goto createbss_cmd_fail;
672 pwlan->last_scanned = jiffies;
674 list_add_tail(&(pwlan->list), &pmlmepriv->scanned_queue.queue);
676 pnetwork->Length = r8712_get_wlan_bssid_ex_sz(pnetwork);
677 memcpy(&(pwlan->network), pnetwork, pnetwork->Length);
679 memcpy(&tgt_network->network, pnetwork, (r8712_get_wlan_bssid_ex_sz(pnetwork)));
680 if (pmlmepriv->fw_state & _FW_UNDER_LINKING)
681 pmlmepriv->fw_state ^= _FW_UNDER_LINKING;
683 * we will set _FW_LINKED when there is one more sat to
684 * join us (stassoc_event_callback)
688 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
689 r8712_free_cmd_obj(pcmd);
692 void r8712_setstaKey_cmdrsp_callback(struct _adapter *padapter, struct cmd_obj *pcmd)
694 struct sta_priv *pstapriv = &padapter->stapriv;
695 struct set_stakey_rsp *psetstakey_rsp = (struct set_stakey_rsp *) (pcmd->rsp);
696 struct sta_info *psta = r8712_get_stainfo(pstapriv, psetstakey_rsp->addr);
700 psta->aid = psta->mac_id = psetstakey_rsp->keyid; /*CAM_ID(CAM_ENTRY)*/
702 r8712_free_cmd_obj(pcmd);
705 void r8712_setassocsta_cmdrsp_callback(struct _adapter *padapter,
706 struct cmd_obj *pcmd)
709 struct sta_priv *pstapriv = &padapter->stapriv;
710 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
711 struct set_assocsta_parm *passocsta_parm = (struct set_assocsta_parm *)(pcmd->parmbuf);
712 struct set_assocsta_rsp *passocsta_rsp = (struct set_assocsta_rsp *) (pcmd->rsp);
713 struct sta_info *psta = r8712_get_stainfo(pstapriv, passocsta_parm->addr);
717 psta->aid = psta->mac_id = passocsta_rsp->cam_id;
718 spin_lock_irqsave(&pmlmepriv->lock, irqL);
719 if ((check_fwstate(pmlmepriv, WIFI_MP_STATE)) && (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)))
720 pmlmepriv->fw_state ^= _FW_UNDER_LINKING;
721 set_fwstate(pmlmepriv, _FW_LINKED);
722 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
723 r8712_free_cmd_obj(pcmd);
726 void r8712_disconnectCtrlEx_cmd(struct _adapter *adapter, u32 enableDrvCtrl, u32 tryPktCnt,
727 u32 tryPktInterval, u32 firstStageTO)
729 struct cmd_obj *ph2c;
730 struct DisconnectCtrlEx_param *param;
731 struct cmd_priv *pcmdpriv = &adapter->cmdpriv;
733 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
736 param = kzalloc(sizeof(*param), GFP_ATOMIC);
742 param->EnableDrvCtrl = (unsigned char)enableDrvCtrl;
743 param->TryPktCnt = (unsigned char)tryPktCnt;
744 param->TryPktInterval = (unsigned char)tryPktInterval;
745 param->FirstStageTO = (unsigned int)firstStageTO;
747 init_h2fwcmd_w_parm_no_rsp(ph2c, param, GEN_CMD_CODE(_DisconnectCtrlEx));
748 r8712_enqueue_cmd(pcmdpriv, ph2c);