1 /******************************************************************************
4 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
5 * Linux device driver for RTL8192SU
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
20 * Modifications for inclusion into the Linux staging tree are
21 * Copyright(c) 2010 Larry Finger. All rights reserved.
23 * Contact information:
24 * WLAN FAE <wlanfae@realtek.com>
25 * Larry Finger <Larry.Finger@lwfinger.net>
27 ******************************************************************************/
29 #define _RTL871X_CMD_C_
31 #include <linux/compiler.h>
32 #include <linux/kernel.h>
33 #include <linux/errno.h>
34 #include <linux/slab.h>
35 #include <linux/module.h>
36 #include <linux/kref.h>
37 #include <linux/netdevice.h>
38 #include <linux/skbuff.h>
39 #include <linux/usb.h>
40 #include <linux/usb/ch9.h>
41 #include <linux/circ_buf.h>
42 #include <linux/uaccess.h>
43 #include <asm/byteorder.h>
44 #include <linux/atomic.h>
45 #include <linux/semaphore.h>
46 #include <linux/rtnetlink.h>
48 #include "osdep_service.h"
49 #include "drv_types.h"
50 #include "recv_osdep.h"
51 #include "mlme_osdep.h"
54 * Caller and the r8712_cmd_thread can protect cmd_q by spin_lock.
55 * No irqsave is necessary.
58 static sint _init_cmd_priv(struct cmd_priv *pcmdpriv)
60 init_completion(&pcmdpriv->cmd_queue_comp);
61 init_completion(&pcmdpriv->terminate_cmdthread_comp);
63 _init_queue(&(pcmdpriv->cmd_queue));
65 /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
66 pcmdpriv->cmd_seq = 1;
67 pcmdpriv->cmd_allocated_buf = kmalloc(MAX_CMDSZ + CMDBUFF_ALIGN_SZ,
69 if (!pcmdpriv->cmd_allocated_buf)
71 pcmdpriv->cmd_buf = pcmdpriv->cmd_allocated_buf + CMDBUFF_ALIGN_SZ -
72 ((addr_t)(pcmdpriv->cmd_allocated_buf) &
73 (CMDBUFF_ALIGN_SZ - 1));
74 pcmdpriv->rsp_allocated_buf = kmalloc(MAX_RSPSZ + 4, GFP_ATOMIC);
75 if (!pcmdpriv->rsp_allocated_buf) {
76 kfree(pcmdpriv->cmd_allocated_buf);
77 pcmdpriv->cmd_allocated_buf = NULL;
80 pcmdpriv->rsp_buf = pcmdpriv->rsp_allocated_buf + 4 -
81 ((addr_t)(pcmdpriv->rsp_allocated_buf) & 3);
82 pcmdpriv->cmd_issued_cnt = 0;
83 pcmdpriv->cmd_done_cnt = 0;
84 pcmdpriv->rsp_cnt = 0;
88 static sint _init_evt_priv(struct evt_priv *pevtpriv)
90 /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
91 pevtpriv->event_seq = 0;
92 pevtpriv->evt_allocated_buf = kmalloc(MAX_EVTSZ + 4, GFP_ATOMIC);
94 if (!pevtpriv->evt_allocated_buf)
96 pevtpriv->evt_buf = pevtpriv->evt_allocated_buf + 4 -
97 ((addr_t)(pevtpriv->evt_allocated_buf) & 3);
98 pevtpriv->evt_done_cnt = 0;
102 static void _free_evt_priv(struct evt_priv *pevtpriv)
104 kfree(pevtpriv->evt_allocated_buf);
107 static void _free_cmd_priv(struct cmd_priv *pcmdpriv)
110 kfree(pcmdpriv->cmd_allocated_buf);
111 kfree(pcmdpriv->rsp_allocated_buf);
118 * _enqueue_cmd can only be called between kernel thread,
119 * since only spin_lock is used.
121 * ISR/Call-Back functions can't call this sub-function.
125 static sint _enqueue_cmd(struct __queue *queue, struct cmd_obj *obj)
131 spin_lock_irqsave(&queue->lock, irqL);
132 list_add_tail(&obj->list, &queue->queue);
133 spin_unlock_irqrestore(&queue->lock, irqL);
137 static struct cmd_obj *_dequeue_cmd(struct __queue *queue)
142 spin_lock_irqsave(&queue->lock, irqL);
143 obj = list_first_entry_or_null(&queue->queue,
144 struct cmd_obj, list);
146 list_del_init(&obj->list);
147 spin_unlock_irqrestore(&queue->lock, irqL);
151 u32 r8712_init_cmd_priv(struct cmd_priv *pcmdpriv)
153 return _init_cmd_priv(pcmdpriv);
156 u32 r8712_init_evt_priv(struct evt_priv *pevtpriv)
158 return _init_evt_priv(pevtpriv);
161 void r8712_free_evt_priv(struct evt_priv *pevtpriv)
163 _free_evt_priv(pevtpriv);
166 void r8712_free_cmd_priv(struct cmd_priv *pcmdpriv)
168 _free_cmd_priv(pcmdpriv);
171 u32 r8712_enqueue_cmd(struct cmd_priv *pcmdpriv, struct cmd_obj *obj)
175 if (pcmdpriv->padapter->eeprompriv.bautoload_fail_flag)
177 res = _enqueue_cmd(&pcmdpriv->cmd_queue, obj);
178 complete(&pcmdpriv->cmd_queue_comp);
182 u32 r8712_enqueue_cmd_ex(struct cmd_priv *pcmdpriv, struct cmd_obj *obj)
185 struct __queue *queue;
189 if (pcmdpriv->padapter->eeprompriv.bautoload_fail_flag)
191 queue = &pcmdpriv->cmd_queue;
192 spin_lock_irqsave(&queue->lock, irqL);
193 list_add_tail(&obj->list, &queue->queue);
194 spin_unlock_irqrestore(&queue->lock, irqL);
195 complete(&pcmdpriv->cmd_queue_comp);
199 struct cmd_obj *r8712_dequeue_cmd(struct __queue *queue)
201 return _dequeue_cmd(queue);
204 void r8712_free_cmd_obj(struct cmd_obj *pcmd)
206 if ((pcmd->cmdcode != _JoinBss_CMD_) &&
207 (pcmd->cmdcode != _CreateBss_CMD_))
208 kfree(pcmd->parmbuf);
209 if (pcmd->rsp != NULL) {
210 if (pcmd->rspsz != 0)
217 * r8712_sitesurvey_cmd(~)
218 * ### NOTE:#### (!!!!)
219 * MUST TAKE CARE THAT BEFORE CALLING THIS FUNC,
220 * YOU SHOULD HAVE LOCKED pmlmepriv->lock
222 u8 r8712_sitesurvey_cmd(struct _adapter *padapter,
223 struct ndis_802_11_ssid *pssid)
225 struct cmd_obj *ph2c;
226 struct sitesurvey_parm *psurveyPara;
227 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
228 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
230 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
233 psurveyPara = kmalloc(sizeof(*psurveyPara), GFP_ATOMIC);
238 init_h2fwcmd_w_parm_no_rsp(ph2c, psurveyPara,
239 GEN_CMD_CODE(_SiteSurvey));
240 psurveyPara->bsslimit = cpu_to_le32(48);
241 psurveyPara->passive_mode = cpu_to_le32(pmlmepriv->passive_mode);
242 psurveyPara->ss_ssidlen = 0;
243 memset(psurveyPara->ss_ssid, 0, IW_ESSID_MAX_SIZE + 1);
244 if ((pssid != NULL) && (pssid->SsidLength)) {
245 int len = min_t(int, pssid->SsidLength, IW_ESSID_MAX_SIZE);
247 memcpy(psurveyPara->ss_ssid, pssid->Ssid, len);
248 psurveyPara->ss_ssidlen = cpu_to_le32(len);
250 set_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
251 r8712_enqueue_cmd(pcmdpriv, ph2c);
252 mod_timer(&pmlmepriv->scan_to_timer,
253 jiffies + msecs_to_jiffies(SCANNING_TIMEOUT));
254 padapter->ledpriv.LedControlHandler(padapter, LED_CTL_SITE_SURVEY);
255 padapter->blnEnableRxFF0Filter = 0;
259 u8 r8712_setdatarate_cmd(struct _adapter *padapter, u8 *rateset)
261 struct cmd_obj *ph2c;
262 struct setdatarate_parm *pbsetdataratepara;
263 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
265 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
268 pbsetdataratepara = kmalloc(sizeof(*pbsetdataratepara), GFP_ATOMIC);
269 if (!pbsetdataratepara) {
273 init_h2fwcmd_w_parm_no_rsp(ph2c, pbsetdataratepara,
274 GEN_CMD_CODE(_SetDataRate));
275 pbsetdataratepara->mac_id = 5;
276 memcpy(pbsetdataratepara->datarates, rateset, NumRates);
277 r8712_enqueue_cmd(pcmdpriv, ph2c);
281 u8 r8712_set_chplan_cmd(struct _adapter *padapter, int chplan)
283 struct cmd_obj *ph2c;
284 struct SetChannelPlan_param *psetchplanpara;
285 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
287 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
290 psetchplanpara = kmalloc(sizeof(*psetchplanpara), GFP_ATOMIC);
291 if (!psetchplanpara) {
295 init_h2fwcmd_w_parm_no_rsp(ph2c, psetchplanpara,
296 GEN_CMD_CODE(_SetChannelPlan));
297 psetchplanpara->ChannelPlan = chplan;
298 r8712_enqueue_cmd(pcmdpriv, ph2c);
302 u8 r8712_setbasicrate_cmd(struct _adapter *padapter, u8 *rateset)
304 struct cmd_obj *ph2c;
305 struct setbasicrate_parm *pssetbasicratepara;
306 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
308 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
311 pssetbasicratepara = kmalloc(sizeof(*pssetbasicratepara), GFP_ATOMIC);
312 if (!pssetbasicratepara) {
316 init_h2fwcmd_w_parm_no_rsp(ph2c, pssetbasicratepara,
318 memcpy(pssetbasicratepara->basicrates, rateset, NumRates);
319 r8712_enqueue_cmd(pcmdpriv, ph2c);
323 u8 r8712_setfwdig_cmd(struct _adapter *padapter, u8 type)
325 struct cmd_obj *ph2c;
326 struct writePTM_parm *pwriteptmparm;
327 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
329 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
332 pwriteptmparm = kmalloc(sizeof(*pwriteptmparm), GFP_ATOMIC);
333 if (!pwriteptmparm) {
337 init_h2fwcmd_w_parm_no_rsp(ph2c, pwriteptmparm, GEN_CMD_CODE(_SetDIG));
338 pwriteptmparm->type = type;
339 r8712_enqueue_cmd(pcmdpriv, ph2c);
343 u8 r8712_setfwra_cmd(struct _adapter *padapter, u8 type)
345 struct cmd_obj *ph2c;
346 struct writePTM_parm *pwriteptmparm;
347 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
349 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
352 pwriteptmparm = kmalloc(sizeof(*pwriteptmparm), GFP_ATOMIC);
353 if (!pwriteptmparm) {
357 init_h2fwcmd_w_parm_no_rsp(ph2c, pwriteptmparm, GEN_CMD_CODE(_SetRA));
358 pwriteptmparm->type = type;
359 r8712_enqueue_cmd(pcmdpriv, ph2c);
363 u8 r8712_setrfreg_cmd(struct _adapter *padapter, u8 offset, u32 val)
365 struct cmd_obj *ph2c;
366 struct writeRF_parm *pwriterfparm;
367 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
369 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
372 pwriterfparm = kmalloc(sizeof(*pwriterfparm), GFP_ATOMIC);
377 init_h2fwcmd_w_parm_no_rsp(ph2c, pwriterfparm, GEN_CMD_CODE(_SetRFReg));
378 pwriterfparm->offset = offset;
379 pwriterfparm->value = val;
380 r8712_enqueue_cmd(pcmdpriv, ph2c);
384 u8 r8712_getrfreg_cmd(struct _adapter *padapter, u8 offset, u8 *pval)
386 struct cmd_obj *ph2c;
387 struct readRF_parm *prdrfparm;
388 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
390 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
393 prdrfparm = kmalloc(sizeof(*prdrfparm), GFP_ATOMIC);
398 INIT_LIST_HEAD(&ph2c->list);
399 ph2c->cmdcode = GEN_CMD_CODE(_GetRFReg);
400 ph2c->parmbuf = (unsigned char *)prdrfparm;
401 ph2c->cmdsz = sizeof(struct readRF_parm);
403 ph2c->rspsz = sizeof(struct readRF_rsp);
404 prdrfparm->offset = offset;
405 r8712_enqueue_cmd(pcmdpriv, ph2c);
409 void r8712_getbbrfreg_cmdrsp_callback(struct _adapter *padapter,
410 struct cmd_obj *pcmd)
412 kfree(pcmd->parmbuf);
414 padapter->mppriv.workparam.bcompleted = true;
417 void r8712_readtssi_cmdrsp_callback(struct _adapter *padapter,
418 struct cmd_obj *pcmd)
420 kfree(pcmd->parmbuf);
423 padapter->mppriv.workparam.bcompleted = true;
426 u8 r8712_createbss_cmd(struct _adapter *padapter)
428 struct cmd_obj *pcmd;
429 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
430 struct wlan_bssid_ex *pdev_network =
431 &padapter->registrypriv.dev_network;
433 padapter->ledpriv.LedControlHandler(padapter, LED_CTL_START_TO_LINK);
434 pcmd = kmalloc(sizeof(*pcmd), GFP_ATOMIC);
437 INIT_LIST_HEAD(&pcmd->list);
438 pcmd->cmdcode = _CreateBss_CMD_;
439 pcmd->parmbuf = (unsigned char *)pdev_network;
440 pcmd->cmdsz = r8712_get_wlan_bssid_ex_sz(pdev_network);
443 /* notes: translate IELength & Length after assign to cmdsz; */
444 pdev_network->Length = pcmd->cmdsz;
445 pdev_network->IELength = pdev_network->IELength;
446 pdev_network->Ssid.SsidLength = pdev_network->Ssid.SsidLength;
447 r8712_enqueue_cmd(pcmdpriv, pcmd);
451 u8 r8712_joinbss_cmd(struct _adapter *padapter, struct wlan_network *pnetwork)
453 struct wlan_bssid_ex *psecnetwork;
454 struct cmd_obj *pcmd;
455 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
456 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
457 struct qos_priv *pqospriv = &pmlmepriv->qospriv;
458 struct security_priv *psecuritypriv = &padapter->securitypriv;
459 struct registry_priv *pregistrypriv = &padapter->registrypriv;
460 enum NDIS_802_11_NETWORK_INFRASTRUCTURE ndis_network_mode = pnetwork->
461 network.InfrastructureMode;
463 padapter->ledpriv.LedControlHandler(padapter, LED_CTL_START_TO_LINK);
464 pcmd = kmalloc(sizeof(*pcmd), GFP_ATOMIC);
468 /* for hidden ap to set fw_state here */
469 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE | WIFI_ADHOC_STATE) !=
471 switch (ndis_network_mode) {
473 pmlmepriv->fw_state |= WIFI_ADHOC_STATE;
475 case Ndis802_11Infrastructure:
476 pmlmepriv->fw_state |= WIFI_STATION_STATE;
478 case Ndis802_11APMode:
479 case Ndis802_11AutoUnknown:
480 case Ndis802_11InfrastructureMax:
484 psecnetwork = &psecuritypriv->sec_bss;
489 memcpy(psecnetwork, &pnetwork->network, sizeof(*psecnetwork));
490 psecuritypriv->authenticator_ie[0] = (unsigned char)
491 psecnetwork->IELength;
492 if ((psecnetwork->IELength - 12) < (256 - 1))
493 memcpy(&psecuritypriv->authenticator_ie[1],
494 &psecnetwork->IEs[12], psecnetwork->IELength - 12);
496 memcpy(&psecuritypriv->authenticator_ie[1],
497 &psecnetwork->IEs[12], (256 - 1));
498 psecnetwork->IELength = 0;
500 * If the driver wants to use the bssid to create the connection.
501 * If not, we copy the connecting AP's MAC address to it so that
502 * the driver just has the bssid information for PMKIDList searching.
504 if (!pmlmepriv->assoc_by_bssid)
505 ether_addr_copy(&pmlmepriv->assoc_bssid[0],
506 &pnetwork->network.MacAddress[0]);
507 psecnetwork->IELength = r8712_restruct_sec_ie(padapter,
508 &pnetwork->network.IEs[0],
509 &psecnetwork->IEs[0],
510 pnetwork->network.IELength);
511 pqospriv->qos_option = 0;
512 if (pregistrypriv->wmm_enable) {
515 tmp_len = r8712_restruct_wmm_ie(padapter,
516 &pnetwork->network.IEs[0],
517 &psecnetwork->IEs[0],
518 pnetwork->network.IELength,
519 psecnetwork->IELength);
520 if (psecnetwork->IELength != tmp_len) {
521 psecnetwork->IELength = tmp_len;
522 pqospriv->qos_option = 1; /* WMM IE in beacon */
524 pqospriv->qos_option = 0; /* no WMM IE in beacon */
527 if (pregistrypriv->ht_enable) {
529 * For WEP mode, we will use the bg mode to do the connection
530 * to avoid some IOT issues, especially for Realtek 8192u
533 if ((padapter->securitypriv.PrivacyAlgrthm != _WEP40_) &&
534 (padapter->securitypriv.PrivacyAlgrthm != _WEP104_)) {
535 /* restructure_ht_ie */
536 r8712_restructure_ht_ie(padapter,
537 &pnetwork->network.IEs[0],
538 &psecnetwork->IEs[0],
539 pnetwork->network.IELength,
540 &psecnetwork->IELength);
543 psecuritypriv->supplicant_ie[0] = (u8)psecnetwork->IELength;
544 if (psecnetwork->IELength < 255)
545 memcpy(&psecuritypriv->supplicant_ie[1], &psecnetwork->IEs[0],
546 psecnetwork->IELength);
548 memcpy(&psecuritypriv->supplicant_ie[1], &psecnetwork->IEs[0],
550 /* get cmdsz before endian conversion */
551 pcmd->cmdsz = r8712_get_wlan_bssid_ex_sz(psecnetwork);
553 /* wlan_network endian conversion */
554 psecnetwork->Length = cpu_to_le32(psecnetwork->Length);
555 psecnetwork->Ssid.SsidLength = cpu_to_le32(
556 psecnetwork->Ssid.SsidLength);
557 psecnetwork->Privacy = cpu_to_le32(psecnetwork->Privacy);
558 psecnetwork->Rssi = cpu_to_le32(psecnetwork->Rssi);
559 psecnetwork->NetworkTypeInUse = cpu_to_le32(
560 psecnetwork->NetworkTypeInUse);
561 psecnetwork->Configuration.ATIMWindow = cpu_to_le32(
562 psecnetwork->Configuration.ATIMWindow);
563 psecnetwork->Configuration.BeaconPeriod = cpu_to_le32(
564 psecnetwork->Configuration.BeaconPeriod);
565 psecnetwork->Configuration.DSConfig = cpu_to_le32(
566 psecnetwork->Configuration.DSConfig);
567 psecnetwork->Configuration.FHConfig.DwellTime = cpu_to_le32(
568 psecnetwork->Configuration.FHConfig.DwellTime);
569 psecnetwork->Configuration.FHConfig.HopPattern = cpu_to_le32(
570 psecnetwork->Configuration.FHConfig.HopPattern);
571 psecnetwork->Configuration.FHConfig.HopSet = cpu_to_le32(
572 psecnetwork->Configuration.FHConfig.HopSet);
573 psecnetwork->Configuration.FHConfig.Length = cpu_to_le32(
574 psecnetwork->Configuration.FHConfig.Length);
575 psecnetwork->Configuration.Length = cpu_to_le32(
576 psecnetwork->Configuration.Length);
577 psecnetwork->InfrastructureMode = cpu_to_le32(
578 psecnetwork->InfrastructureMode);
579 psecnetwork->IELength = cpu_to_le32(psecnetwork->IELength);
581 INIT_LIST_HEAD(&pcmd->list);
582 pcmd->cmdcode = _JoinBss_CMD_;
583 pcmd->parmbuf = (unsigned char *)psecnetwork;
586 r8712_enqueue_cmd(pcmdpriv, pcmd);
590 u8 r8712_disassoc_cmd(struct _adapter *padapter) /* for sta_mode */
592 struct cmd_obj *pdisconnect_cmd;
593 struct disconnect_parm *pdisconnect;
594 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
596 pdisconnect_cmd = kmalloc(sizeof(*pdisconnect_cmd), GFP_ATOMIC);
597 if (!pdisconnect_cmd)
599 pdisconnect = kmalloc(sizeof(*pdisconnect), GFP_ATOMIC);
601 kfree(pdisconnect_cmd);
604 init_h2fwcmd_w_parm_no_rsp(pdisconnect_cmd, pdisconnect,
606 r8712_enqueue_cmd(pcmdpriv, pdisconnect_cmd);
610 u8 r8712_setopmode_cmd(struct _adapter *padapter,
611 enum NDIS_802_11_NETWORK_INFRASTRUCTURE networktype)
613 struct cmd_obj *ph2c;
614 struct setopmode_parm *psetop;
616 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
618 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
621 psetop = kmalloc(sizeof(*psetop), GFP_ATOMIC);
626 init_h2fwcmd_w_parm_no_rsp(ph2c, psetop, _SetOpMode_CMD_);
627 psetop->mode = (u8)networktype;
628 r8712_enqueue_cmd(pcmdpriv, ph2c);
632 u8 r8712_setstakey_cmd(struct _adapter *padapter, u8 *psta, u8 unicast_key)
634 struct cmd_obj *ph2c;
635 struct set_stakey_parm *psetstakey_para;
636 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
637 struct set_stakey_rsp *psetstakey_rsp = NULL;
638 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
639 struct security_priv *psecuritypriv = &padapter->securitypriv;
640 struct sta_info *sta = (struct sta_info *)psta;
642 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
645 psetstakey_para = kmalloc(sizeof(*psetstakey_para), GFP_ATOMIC);
646 if (!psetstakey_para) {
650 psetstakey_rsp = kmalloc(sizeof(*psetstakey_rsp), GFP_ATOMIC);
651 if (!psetstakey_rsp) {
653 kfree(psetstakey_para);
656 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_);
657 ph2c->rsp = (u8 *) psetstakey_rsp;
658 ph2c->rspsz = sizeof(struct set_stakey_rsp);
659 ether_addr_copy(psetstakey_para->addr, sta->hwaddr);
660 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
661 psetstakey_para->algorithm = (unsigned char)
662 psecuritypriv->PrivacyAlgrthm;
664 GET_ENCRY_ALGO(psecuritypriv, sta,
665 psetstakey_para->algorithm, false);
667 memcpy(&psetstakey_para->key, &sta->x_UncstKey, 16);
669 memcpy(&psetstakey_para->key,
670 &psecuritypriv->XGrpKey[
671 psecuritypriv->XGrpKeyid - 1]. skey, 16);
672 r8712_enqueue_cmd(pcmdpriv, ph2c);
676 u8 r8712_setrfintfs_cmd(struct _adapter *padapter, u8 mode)
678 struct cmd_obj *ph2c;
679 struct setrfintfs_parm *psetrfintfsparm;
680 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
682 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
685 psetrfintfsparm = kmalloc(sizeof(*psetrfintfsparm), GFP_ATOMIC);
686 if (!psetrfintfsparm) {
690 init_h2fwcmd_w_parm_no_rsp(ph2c, psetrfintfsparm,
691 GEN_CMD_CODE(_SetRFIntFs));
692 psetrfintfsparm->rfintfs = mode;
693 r8712_enqueue_cmd(pcmdpriv, ph2c);
697 u8 r8712_setrttbl_cmd(struct _adapter *padapter,
698 struct setratable_parm *prate_table)
700 struct cmd_obj *ph2c;
701 struct setratable_parm *psetrttblparm;
702 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
704 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
707 psetrttblparm = kmalloc(sizeof(*psetrttblparm), GFP_ATOMIC);
708 if (!psetrttblparm) {
712 init_h2fwcmd_w_parm_no_rsp(ph2c, psetrttblparm,
713 GEN_CMD_CODE(_SetRaTable));
714 memcpy(psetrttblparm, prate_table, sizeof(struct setratable_parm));
715 r8712_enqueue_cmd(pcmdpriv, ph2c);
719 u8 r8712_setMacAddr_cmd(struct _adapter *padapter, u8 *mac_addr)
721 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
722 struct cmd_obj *ph2c;
723 struct SetMacAddr_param *psetMacAddr_para;
725 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
728 psetMacAddr_para = kmalloc(sizeof(*psetMacAddr_para), GFP_ATOMIC);
729 if (!psetMacAddr_para) {
733 init_h2fwcmd_w_parm_no_rsp(ph2c, psetMacAddr_para,
734 _SetMacAddress_CMD_);
735 ether_addr_copy(psetMacAddr_para->MacAddr, mac_addr);
736 r8712_enqueue_cmd(pcmdpriv, ph2c);
740 u8 r8712_setassocsta_cmd(struct _adapter *padapter, u8 *mac_addr)
742 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
743 struct cmd_obj *ph2c;
744 struct set_assocsta_parm *psetassocsta_para;
745 struct set_assocsta_rsp *psetassocsta_rsp = NULL;
747 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
750 psetassocsta_para = kmalloc(sizeof(*psetassocsta_para), GFP_ATOMIC);
751 if (!psetassocsta_para) {
755 psetassocsta_rsp = kmalloc(sizeof(*psetassocsta_rsp), GFP_ATOMIC);
756 if (!psetassocsta_rsp) {
758 kfree(psetassocsta_para);
761 init_h2fwcmd_w_parm_no_rsp(ph2c, psetassocsta_para, _SetAssocSta_CMD_);
762 ph2c->rsp = (u8 *) psetassocsta_rsp;
763 ph2c->rspsz = sizeof(struct set_assocsta_rsp);
764 ether_addr_copy(psetassocsta_para->addr, mac_addr);
765 r8712_enqueue_cmd(pcmdpriv, ph2c);
769 u8 r8712_addbareq_cmd(struct _adapter *padapter, u8 tid)
771 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
772 struct cmd_obj *ph2c;
773 struct addBaReq_parm *paddbareq_parm;
775 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
778 paddbareq_parm = kmalloc(sizeof(*paddbareq_parm), GFP_ATOMIC);
779 if (!paddbareq_parm) {
783 paddbareq_parm->tid = tid;
784 init_h2fwcmd_w_parm_no_rsp(ph2c, paddbareq_parm,
785 GEN_CMD_CODE(_AddBAReq));
786 r8712_enqueue_cmd_ex(pcmdpriv, ph2c);
790 u8 r8712_wdg_wk_cmd(struct _adapter *padapter)
792 struct cmd_obj *ph2c;
793 struct drvint_cmd_parm *pdrvintcmd_param;
794 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
796 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
799 pdrvintcmd_param = kmalloc(sizeof(*pdrvintcmd_param), GFP_ATOMIC);
800 if (!pdrvintcmd_param) {
804 pdrvintcmd_param->i_cid = WDG_WK_CID;
805 pdrvintcmd_param->sz = 0;
806 pdrvintcmd_param->pbuf = NULL;
807 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvintcmd_param, _DRV_INT_CMD_);
808 r8712_enqueue_cmd_ex(pcmdpriv, ph2c);
812 void r8712_survey_cmd_callback(struct _adapter *padapter, struct cmd_obj *pcmd)
814 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
816 if (pcmd->res != H2C_SUCCESS)
817 clr_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
818 r8712_free_cmd_obj(pcmd);
821 void r8712_disassoc_cmd_callback(struct _adapter *padapter,
822 struct cmd_obj *pcmd)
825 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
827 if (pcmd->res != H2C_SUCCESS) {
828 spin_lock_irqsave(&pmlmepriv->lock, irqL);
829 set_fwstate(pmlmepriv, _FW_LINKED);
830 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
833 r8712_free_cmd_obj(pcmd);
836 void r8712_joinbss_cmd_callback(struct _adapter *padapter, struct cmd_obj *pcmd)
838 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
840 if (pcmd->res != H2C_SUCCESS)
841 mod_timer(&pmlmepriv->assoc_timer,
842 jiffies + msecs_to_jiffies(1));
843 r8712_free_cmd_obj(pcmd);
846 void r8712_createbss_cmd_callback(struct _adapter *padapter,
847 struct cmd_obj *pcmd)
850 struct sta_info *psta = NULL;
851 struct wlan_network *pwlan = NULL;
852 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
853 struct wlan_bssid_ex *pnetwork = (struct wlan_bssid_ex *)pcmd->parmbuf;
854 struct wlan_network *tgt_network = &(pmlmepriv->cur_network);
856 if (pcmd->res != H2C_SUCCESS)
857 mod_timer(&pmlmepriv->assoc_timer,
858 jiffies + msecs_to_jiffies(1));
859 del_timer(&pmlmepriv->assoc_timer);
862 pnetwork->Length = le32_to_cpu(pnetwork->Length);
863 pnetwork->Ssid.SsidLength = le32_to_cpu(pnetwork->Ssid.SsidLength);
864 pnetwork->Privacy = le32_to_cpu(pnetwork->Privacy);
865 pnetwork->Rssi = le32_to_cpu(pnetwork->Rssi);
866 pnetwork->NetworkTypeInUse = le32_to_cpu(pnetwork->NetworkTypeInUse);
867 pnetwork->Configuration.ATIMWindow = le32_to_cpu(pnetwork->
868 Configuration.ATIMWindow);
869 pnetwork->Configuration.DSConfig = le32_to_cpu(pnetwork->
870 Configuration.DSConfig);
871 pnetwork->Configuration.FHConfig.DwellTime = le32_to_cpu(pnetwork->
872 Configuration.FHConfig.DwellTime);
873 pnetwork->Configuration.FHConfig.HopPattern = le32_to_cpu(pnetwork->
874 Configuration.FHConfig.HopPattern);
875 pnetwork->Configuration.FHConfig.HopSet = le32_to_cpu(pnetwork->
876 Configuration.FHConfig.HopSet);
877 pnetwork->Configuration.FHConfig.Length = le32_to_cpu(pnetwork->
878 Configuration.FHConfig.Length);
879 pnetwork->Configuration.Length = le32_to_cpu(pnetwork->
880 Configuration.Length);
881 pnetwork->InfrastructureMode = le32_to_cpu(pnetwork->
883 pnetwork->IELength = le32_to_cpu(pnetwork->IELength);
885 spin_lock_irqsave(&pmlmepriv->lock, irqL);
886 if ((pmlmepriv->fw_state) & WIFI_AP_STATE) {
887 psta = r8712_get_stainfo(&padapter->stapriv,
888 pnetwork->MacAddress);
890 psta = r8712_alloc_stainfo(&padapter->stapriv,
891 pnetwork->MacAddress);
893 goto createbss_cmd_fail;
895 r8712_indicate_connect(padapter);
897 pwlan = _r8712_alloc_network(pmlmepriv);
899 pwlan = r8712_get_oldest_wlan_network(
900 &pmlmepriv->scanned_queue);
902 goto createbss_cmd_fail;
903 pwlan->last_scanned = jiffies;
905 list_add_tail(&(pwlan->list),
906 &pmlmepriv->scanned_queue.queue);
907 pnetwork->Length = r8712_get_wlan_bssid_ex_sz(pnetwork);
908 memcpy(&(pwlan->network), pnetwork, pnetwork->Length);
910 memcpy(&tgt_network->network, pnetwork,
911 (r8712_get_wlan_bssid_ex_sz(pnetwork)));
912 if (pmlmepriv->fw_state & _FW_UNDER_LINKING)
913 pmlmepriv->fw_state ^= _FW_UNDER_LINKING;
915 * we will set _FW_LINKED when there is one more sat to
916 * join us (stassoc_event_callback)
920 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
921 r8712_free_cmd_obj(pcmd);
924 void r8712_setstaKey_cmdrsp_callback(struct _adapter *padapter,
925 struct cmd_obj *pcmd)
927 struct sta_priv *pstapriv = &padapter->stapriv;
928 struct set_stakey_rsp *psetstakey_rsp = (struct set_stakey_rsp *)
930 struct sta_info *psta = r8712_get_stainfo(pstapriv,
931 psetstakey_rsp->addr);
935 psta->aid = psta->mac_id = psetstakey_rsp->keyid; /*CAM_ID(CAM_ENTRY)*/
937 r8712_free_cmd_obj(pcmd);
940 void r8712_setassocsta_cmdrsp_callback(struct _adapter *padapter,
941 struct cmd_obj *pcmd)
944 struct sta_priv *pstapriv = &padapter->stapriv;
945 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
946 struct set_assocsta_parm *passocsta_parm =
947 (struct set_assocsta_parm *)(pcmd->parmbuf);
948 struct set_assocsta_rsp *passocsta_rsp =
949 (struct set_assocsta_rsp *) (pcmd->rsp);
950 struct sta_info *psta = r8712_get_stainfo(pstapriv,
951 passocsta_parm->addr);
955 psta->aid = psta->mac_id = passocsta_rsp->cam_id;
956 spin_lock_irqsave(&pmlmepriv->lock, irqL);
957 if ((check_fwstate(pmlmepriv, WIFI_MP_STATE)) &&
958 (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)))
959 pmlmepriv->fw_state ^= _FW_UNDER_LINKING;
960 set_fwstate(pmlmepriv, _FW_LINKED);
961 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
962 r8712_free_cmd_obj(pcmd);
965 u8 r8712_disconnectCtrlEx_cmd(struct _adapter *adapter, u32 enableDrvCtrl,
966 u32 tryPktCnt, u32 tryPktInterval, u32 firstStageTO)
968 struct cmd_obj *ph2c;
969 struct DisconnectCtrlEx_param *param;
970 struct cmd_priv *pcmdpriv = &adapter->cmdpriv;
972 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
975 param = kzalloc(sizeof(*param), GFP_ATOMIC);
981 param->EnableDrvCtrl = (unsigned char)enableDrvCtrl;
982 param->TryPktCnt = (unsigned char)tryPktCnt;
983 param->TryPktInterval = (unsigned char)tryPktInterval;
984 param->FirstStageTO = (unsigned int)firstStageTO;
986 init_h2fwcmd_w_parm_no_rsp(ph2c, param,
987 GEN_CMD_CODE(_DisconnectCtrlEx));
988 r8712_enqueue_cmd(pcmdpriv, ph2c);