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 sema_init(&(pcmdpriv->cmd_queue_sema), 0);
61 sema_init(&(pcmdpriv->terminate_cmdthread_sema), 0);
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 == NULL)
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 == NULL)
77 pcmdpriv->rsp_buf = pcmdpriv->rsp_allocated_buf + 4 -
78 ((addr_t)(pcmdpriv->rsp_allocated_buf) & 3);
79 pcmdpriv->cmd_issued_cnt = 0;
80 pcmdpriv->cmd_done_cnt = 0;
81 pcmdpriv->rsp_cnt = 0;
85 static sint _init_evt_priv(struct evt_priv *pevtpriv)
87 /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
88 pevtpriv->event_seq = 0;
89 pevtpriv->evt_allocated_buf = kmalloc(MAX_EVTSZ + 4, GFP_ATOMIC);
91 if (pevtpriv->evt_allocated_buf == NULL)
93 pevtpriv->evt_buf = pevtpriv->evt_allocated_buf + 4 -
94 ((addr_t)(pevtpriv->evt_allocated_buf) & 3);
95 pevtpriv->evt_done_cnt = 0;
99 static void _free_evt_priv(struct evt_priv *pevtpriv)
101 kfree(pevtpriv->evt_allocated_buf);
104 static void _free_cmd_priv(struct cmd_priv *pcmdpriv)
107 kfree(pcmdpriv->cmd_allocated_buf);
108 kfree(pcmdpriv->rsp_allocated_buf);
115 _enqueue_cmd can only be called between kernel thread,
116 since only spin_lock is used.
118 ISR/Call-Back functions can't call this sub-function.
122 static sint _enqueue_cmd(struct __queue *queue, struct cmd_obj *obj)
128 spin_lock_irqsave(&queue->lock, irqL);
129 list_insert_tail(&obj->list, &queue->queue);
130 spin_unlock_irqrestore(&queue->lock, irqL);
134 static struct cmd_obj *_dequeue_cmd(struct __queue *queue)
139 spin_lock_irqsave(&(queue->lock), irqL);
140 if (is_list_empty(&(queue->queue)))
143 obj = LIST_CONTAINOR(get_next(&(queue->queue)),
144 struct cmd_obj, list);
145 list_delete(&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 == true)
177 res = _enqueue_cmd(&pcmdpriv->cmd_queue, obj);
178 up(&pcmdpriv->cmd_queue_sema);
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 == true)
191 queue = &pcmdpriv->cmd_queue;
192 spin_lock_irqsave(&queue->lock, irqL);
193 list_insert_tail(&obj->list, &queue->queue);
194 spin_unlock_irqrestore(&queue->lock, irqL);
195 up(&pcmdpriv->cmd_queue_sema);
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((unsigned char *)pcmd->parmbuf);
209 if (pcmd->rsp != NULL) {
210 if (pcmd->rspsz != 0)
211 kfree((unsigned char *)pcmd->rsp);
213 kfree((unsigned char *)pcmd);
217 r8712_sitesurvey_cmd(~)
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(struct cmd_obj), GFP_ATOMIC);
233 psurveyPara = kmalloc(sizeof(struct sitesurvey_parm), GFP_ATOMIC);
234 if (psurveyPara == NULL) {
235 kfree((unsigned char *) ph2c);
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 memcpy(psurveyPara->ss_ssid, pssid->Ssid, pssid->SsidLength);
246 psurveyPara->ss_ssidlen = cpu_to_le32(pssid->SsidLength);
248 set_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
249 r8712_enqueue_cmd(pcmdpriv, ph2c);
250 _set_timer(&pmlmepriv->scan_to_timer, SCANNING_TIMEOUT);
251 padapter->ledpriv.LedControlHandler(padapter, LED_CTL_SITE_SURVEY);
252 padapter->blnEnableRxFF0Filter = 0;
256 u8 r8712_setdatarate_cmd(struct _adapter *padapter, u8 *rateset)
258 struct cmd_obj *ph2c;
259 struct setdatarate_parm *pbsetdataratepara;
260 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
262 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
265 pbsetdataratepara = kmalloc(sizeof(struct setdatarate_parm),
267 if (pbsetdataratepara == NULL) {
271 init_h2fwcmd_w_parm_no_rsp(ph2c, pbsetdataratepara,
272 GEN_CMD_CODE(_SetDataRate));
273 pbsetdataratepara->mac_id = 5;
274 memcpy(pbsetdataratepara->datarates, rateset, NumRates);
275 r8712_enqueue_cmd(pcmdpriv, ph2c);
279 u8 r8712_set_chplan_cmd(struct _adapter *padapter, int chplan)
281 struct cmd_obj *ph2c;
282 struct SetChannelPlan_param *psetchplanpara;
283 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
285 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
288 psetchplanpara = kmalloc(sizeof(struct SetChannelPlan_param),
290 if (psetchplanpara == NULL) {
294 init_h2fwcmd_w_parm_no_rsp(ph2c, psetchplanpara,
295 GEN_CMD_CODE(_SetChannelPlan));
296 psetchplanpara->ChannelPlan = chplan;
297 r8712_enqueue_cmd(pcmdpriv, ph2c);
301 u8 r8712_setbasicrate_cmd(struct _adapter *padapter, u8 *rateset)
303 struct cmd_obj *ph2c;
304 struct setbasicrate_parm *pssetbasicratepara;
305 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
307 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
310 pssetbasicratepara = kmalloc(sizeof(struct setbasicrate_parm),
312 if (pssetbasicratepara == NULL) {
316 init_h2fwcmd_w_parm_no_rsp(ph2c, pssetbasicratepara,
318 memcpy(pssetbasicratepara->basicrates, rateset, NumRates);
319 r8712_enqueue_cmd(pcmdpriv, ph2c);
323 /* power tracking mechanism setting */
324 u8 r8712_setptm_cmd(struct _adapter *padapter, u8 type)
326 struct cmd_obj *ph2c;
327 struct writePTM_parm *pwriteptmparm;
328 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
330 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
333 pwriteptmparm = kmalloc(sizeof(struct writePTM_parm), GFP_ATOMIC);
334 if (pwriteptmparm == NULL) {
338 init_h2fwcmd_w_parm_no_rsp(ph2c, pwriteptmparm, GEN_CMD_CODE(_SetPT));
339 pwriteptmparm->type = type;
340 r8712_enqueue_cmd(pcmdpriv, ph2c);
344 u8 r8712_setfwdig_cmd(struct _adapter *padapter, u8 type)
346 struct cmd_obj *ph2c;
347 struct writePTM_parm *pwriteptmparm;
348 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
350 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
353 pwriteptmparm = kmalloc(sizeof(struct writePTM_parm), GFP_ATOMIC);
354 if (pwriteptmparm == NULL) {
358 init_h2fwcmd_w_parm_no_rsp(ph2c, pwriteptmparm, GEN_CMD_CODE(_SetDIG));
359 pwriteptmparm->type = type;
360 r8712_enqueue_cmd(pcmdpriv, ph2c);
364 u8 r8712_setfwra_cmd(struct _adapter *padapter, u8 type)
366 struct cmd_obj *ph2c;
367 struct writePTM_parm *pwriteptmparm;
368 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
370 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
373 pwriteptmparm = kmalloc(sizeof(struct writePTM_parm), GFP_ATOMIC);
374 if (pwriteptmparm == NULL) {
378 init_h2fwcmd_w_parm_no_rsp(ph2c, pwriteptmparm, GEN_CMD_CODE(_SetRA));
379 pwriteptmparm->type = type;
380 r8712_enqueue_cmd(pcmdpriv, ph2c);
384 u8 r8712_setrfreg_cmd(struct _adapter *padapter, u8 offset, u32 val)
386 struct cmd_obj *ph2c;
387 struct writeRF_parm *pwriterfparm;
388 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
390 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
393 pwriterfparm = kmalloc(sizeof(struct writeRF_parm), GFP_ATOMIC);
394 if (pwriterfparm == NULL) {
398 init_h2fwcmd_w_parm_no_rsp(ph2c, pwriterfparm, GEN_CMD_CODE(_SetRFReg));
399 pwriterfparm->offset = offset;
400 pwriterfparm->value = val;
401 r8712_enqueue_cmd(pcmdpriv, ph2c);
405 u8 r8712_getrfreg_cmd(struct _adapter *padapter, u8 offset, u8 *pval)
407 struct cmd_obj *ph2c;
408 struct readRF_parm *prdrfparm;
409 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
411 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
414 prdrfparm = kmalloc(sizeof(struct readRF_parm), GFP_ATOMIC);
415 if (prdrfparm == NULL) {
419 _init_listhead(&ph2c->list);
420 ph2c->cmdcode = GEN_CMD_CODE(_GetRFReg);
421 ph2c->parmbuf = (unsigned char *)prdrfparm;
422 ph2c->cmdsz = sizeof(struct readRF_parm);
424 ph2c->rspsz = sizeof(struct readRF_rsp);
425 prdrfparm->offset = offset;
426 r8712_enqueue_cmd(pcmdpriv, ph2c);
430 void r8712_getbbrfreg_cmdrsp_callback(struct _adapter *padapter,
431 struct cmd_obj *pcmd)
433 kfree(pcmd->parmbuf);
435 padapter->mppriv.workparam.bcompleted = true;
438 void r8712_readtssi_cmdrsp_callback(struct _adapter *padapter,
439 struct cmd_obj *pcmd)
441 kfree(pcmd->parmbuf);
444 padapter->mppriv.workparam.bcompleted = true;
447 u8 r8712_createbss_cmd(struct _adapter *padapter)
449 struct cmd_obj *pcmd;
450 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
451 struct wlan_bssid_ex *pdev_network =
452 &padapter->registrypriv.dev_network;
454 padapter->ledpriv.LedControlHandler(padapter, LED_CTL_START_TO_LINK);
455 pcmd = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
458 _init_listhead(&pcmd->list);
459 pcmd->cmdcode = _CreateBss_CMD_;
460 pcmd->parmbuf = (unsigned char *)pdev_network;
461 pcmd->cmdsz = r8712_get_ndis_wlan_bssid_ex_sz((
462 struct ndis_wlan_bssid_ex *)
466 /* notes: translate IELength & Length after assign to cmdsz; */
467 pdev_network->Length = pcmd->cmdsz;
468 pdev_network->IELength = pdev_network->IELength;
469 pdev_network->Ssid.SsidLength = pdev_network->Ssid.SsidLength;
470 r8712_enqueue_cmd(pcmdpriv, pcmd);
474 u8 r8712_joinbss_cmd(struct _adapter *padapter, struct wlan_network *pnetwork)
478 struct ndis_wlan_bssid_ex *psecnetwork;
479 struct cmd_obj *pcmd;
480 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
481 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
482 struct qos_priv *pqospriv = &pmlmepriv->qospriv;
483 struct security_priv *psecuritypriv = &padapter->securitypriv;
484 struct registry_priv *pregistrypriv = &padapter->registrypriv;
485 enum NDIS_802_11_NETWORK_INFRASTRUCTURE ndis_network_mode = pnetwork->
486 network.InfrastructureMode;
488 padapter->ledpriv.LedControlHandler(padapter, LED_CTL_START_TO_LINK);
489 pcmd = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
492 t_len = sizeof(u32) + 6 * sizeof(unsigned char) + 2 +
493 sizeof(struct ndis_802_11_ssid) + sizeof(u32) +
495 sizeof(enum NDIS_802_11_NETWORK_TYPE) +
496 sizeof(struct NDIS_802_11_CONFIGURATION) +
497 sizeof(enum NDIS_802_11_NETWORK_INFRASTRUCTURE) +
498 sizeof(NDIS_802_11_RATES_EX) +
499 sizeof(u32) + MAX_IE_SZ;
501 /* for hidden ap to set fw_state here */
502 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_ADHOC_STATE) !=
504 switch (ndis_network_mode) {
506 pmlmepriv->fw_state |= WIFI_ADHOC_STATE;
508 case Ndis802_11Infrastructure:
509 pmlmepriv->fw_state |= WIFI_STATION_STATE;
511 case Ndis802_11APMode:
512 case Ndis802_11AutoUnknown:
513 case Ndis802_11InfrastructureMax:
517 psecnetwork = (struct ndis_wlan_bssid_ex *)&psecuritypriv->sec_bss;
518 if (psecnetwork == NULL) {
522 memcpy(psecnetwork, &pnetwork->network, t_len);
523 auth = &psecuritypriv->authenticator_ie[0];
524 psecuritypriv->authenticator_ie[0] = (unsigned char)
525 psecnetwork->IELength;
526 if ((psecnetwork->IELength-12) < (256 - 1))
527 memcpy(&psecuritypriv->authenticator_ie[1],
528 &psecnetwork->IEs[12], psecnetwork->IELength-12);
530 memcpy(&psecuritypriv->authenticator_ie[1],
531 &psecnetwork->IEs[12], (256-1));
532 psecnetwork->IELength = 0;
533 /* If the the driver wants to use the bssid to create the connection.
534 * If not, we copy the connecting AP's MAC address to it so that
535 * the driver just has the bssid information for PMKIDList searching.
537 if (pmlmepriv->assoc_by_bssid == false)
538 memcpy(&pmlmepriv->assoc_bssid[0],
539 &pnetwork->network.MacAddress[0], ETH_ALEN);
540 psecnetwork->IELength = r8712_restruct_sec_ie(padapter,
541 &pnetwork->network.IEs[0],
542 &psecnetwork->IEs[0],
543 pnetwork->network.IELength);
544 pqospriv->qos_option = 0;
545 if (pregistrypriv->wmm_enable) {
548 tmp_len = r8712_restruct_wmm_ie(padapter,
549 &pnetwork->network.IEs[0],
550 &psecnetwork->IEs[0],
551 pnetwork->network.IELength,
552 psecnetwork->IELength);
553 if (psecnetwork->IELength != tmp_len) {
554 psecnetwork->IELength = tmp_len;
555 pqospriv->qos_option = 1; /* WMM IE in beacon */
557 pqospriv->qos_option = 0; /* no WMM IE in beacon */
559 if (pregistrypriv->ht_enable) {
560 /* For WEP mode, we will use the bg mode to do the connection
561 * to avoid some IOT issues, especially for Realtek 8192u
564 if ((padapter->securitypriv.PrivacyAlgrthm != _WEP40_) &&
565 (padapter->securitypriv.PrivacyAlgrthm != _WEP104_)) {
566 /* restructure_ht_ie */
567 r8712_restructure_ht_ie(padapter,
568 &pnetwork->network.IEs[0],
569 &psecnetwork->IEs[0],
570 pnetwork->network.IELength,
571 &psecnetwork->IELength);
574 psecuritypriv->supplicant_ie[0] = (u8)psecnetwork->IELength;
575 if (psecnetwork->IELength < 255)
576 memcpy(&psecuritypriv->supplicant_ie[1], &psecnetwork->IEs[0],
577 psecnetwork->IELength);
579 memcpy(&psecuritypriv->supplicant_ie[1], &psecnetwork->IEs[0],
581 /* get cmdsz before endian conversion */
582 pcmd->cmdsz = r8712_get_ndis_wlan_bssid_ex_sz(psecnetwork);
584 /* wlan_network endian conversion */
585 psecnetwork->Length = cpu_to_le32(psecnetwork->Length);
586 psecnetwork->Ssid.SsidLength = cpu_to_le32(
587 psecnetwork->Ssid.SsidLength);
588 psecnetwork->Privacy = cpu_to_le32(psecnetwork->Privacy);
589 psecnetwork->Rssi = cpu_to_le32(psecnetwork->Rssi);
590 psecnetwork->NetworkTypeInUse = cpu_to_le32(
591 psecnetwork->NetworkTypeInUse);
592 psecnetwork->Configuration.ATIMWindow = cpu_to_le32(
593 psecnetwork->Configuration.ATIMWindow);
594 psecnetwork->Configuration.BeaconPeriod = cpu_to_le32(
595 psecnetwork->Configuration.BeaconPeriod);
596 psecnetwork->Configuration.DSConfig = cpu_to_le32(
597 psecnetwork->Configuration.DSConfig);
598 psecnetwork->Configuration.FHConfig.DwellTime = cpu_to_le32(
599 psecnetwork->Configuration.FHConfig.DwellTime);
600 psecnetwork->Configuration.FHConfig.HopPattern = cpu_to_le32(
601 psecnetwork->Configuration.FHConfig.HopPattern);
602 psecnetwork->Configuration.FHConfig.HopSet = cpu_to_le32(
603 psecnetwork->Configuration.FHConfig.HopSet);
604 psecnetwork->Configuration.FHConfig.Length = cpu_to_le32(
605 psecnetwork->Configuration.FHConfig.Length);
606 psecnetwork->Configuration.Length = cpu_to_le32(
607 psecnetwork->Configuration.Length);
608 psecnetwork->InfrastructureMode = cpu_to_le32(
609 psecnetwork->InfrastructureMode);
610 psecnetwork->IELength = cpu_to_le32(psecnetwork->IELength);
612 _init_listhead(&pcmd->list);
613 pcmd->cmdcode = _JoinBss_CMD_;
614 pcmd->parmbuf = (unsigned char *)psecnetwork;
617 r8712_enqueue_cmd(pcmdpriv, pcmd);
621 u8 r8712_disassoc_cmd(struct _adapter *padapter) /* for sta_mode */
623 struct cmd_obj *pdisconnect_cmd;
624 struct disconnect_parm *pdisconnect;
625 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
627 pdisconnect_cmd = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
628 if (pdisconnect_cmd == NULL)
630 pdisconnect = kmalloc(sizeof(struct disconnect_parm), GFP_ATOMIC);
631 if (pdisconnect == NULL) {
632 kfree((u8 *)pdisconnect_cmd);
635 init_h2fwcmd_w_parm_no_rsp(pdisconnect_cmd, pdisconnect,
637 r8712_enqueue_cmd(pcmdpriv, pdisconnect_cmd);
641 u8 r8712_setopmode_cmd(struct _adapter *padapter,
642 enum NDIS_802_11_NETWORK_INFRASTRUCTURE networktype)
644 struct cmd_obj *ph2c;
645 struct setopmode_parm *psetop;
647 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
649 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
652 psetop = kmalloc(sizeof(struct setopmode_parm), GFP_ATOMIC);
653 if (psetop == NULL) {
657 init_h2fwcmd_w_parm_no_rsp(ph2c, psetop, _SetOpMode_CMD_);
658 psetop->mode = (u8)networktype;
659 r8712_enqueue_cmd(pcmdpriv, ph2c);
663 u8 r8712_setstakey_cmd(struct _adapter *padapter, u8 *psta, u8 unicast_key)
665 struct cmd_obj *ph2c;
666 struct set_stakey_parm *psetstakey_para;
667 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
668 struct set_stakey_rsp *psetstakey_rsp = NULL;
669 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
670 struct security_priv *psecuritypriv = &padapter->securitypriv;
671 struct sta_info *sta = (struct sta_info *)psta;
673 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
676 psetstakey_para = kmalloc(sizeof(struct set_stakey_parm), GFP_ATOMIC);
677 if (psetstakey_para == NULL) {
681 psetstakey_rsp = kmalloc(sizeof(struct set_stakey_rsp), GFP_ATOMIC);
682 if (psetstakey_rsp == NULL) {
684 kfree((u8 *) psetstakey_para);
687 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_);
688 ph2c->rsp = (u8 *) psetstakey_rsp;
689 ph2c->rspsz = sizeof(struct set_stakey_rsp);
690 memcpy(psetstakey_para->addr, sta->hwaddr, ETH_ALEN);
691 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
692 psetstakey_para->algorithm = (unsigned char)
693 psecuritypriv->PrivacyAlgrthm;
695 GET_ENCRY_ALGO(psecuritypriv, sta,
696 psetstakey_para->algorithm, false);
697 if (unicast_key == true)
698 memcpy(&psetstakey_para->key, &sta->x_UncstKey, 16);
700 memcpy(&psetstakey_para->key,
701 &psecuritypriv->XGrpKey[
702 psecuritypriv->XGrpKeyid - 1]. skey, 16);
703 r8712_enqueue_cmd(pcmdpriv, ph2c);
707 u8 r8712_setrfintfs_cmd(struct _adapter *padapter, u8 mode)
709 struct cmd_obj *ph2c;
710 struct setrfintfs_parm *psetrfintfsparm;
711 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
713 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
716 psetrfintfsparm = kmalloc(sizeof(struct setrfintfs_parm), GFP_ATOMIC);
717 if (psetrfintfsparm == NULL) {
718 kfree((unsigned char *) ph2c);
721 init_h2fwcmd_w_parm_no_rsp(ph2c, psetrfintfsparm,
722 GEN_CMD_CODE(_SetRFIntFs));
723 psetrfintfsparm->rfintfs = mode;
724 r8712_enqueue_cmd(pcmdpriv, ph2c);
728 u8 r8712_setrttbl_cmd(struct _adapter *padapter,
729 struct setratable_parm *prate_table)
731 struct cmd_obj *ph2c;
732 struct setratable_parm *psetrttblparm;
733 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
735 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
738 psetrttblparm = kmalloc(sizeof(struct setratable_parm), GFP_ATOMIC);
739 if (psetrttblparm == NULL) {
740 kfree((unsigned char *)ph2c);
743 init_h2fwcmd_w_parm_no_rsp(ph2c, psetrttblparm,
744 GEN_CMD_CODE(_SetRaTable));
745 memcpy(psetrttblparm, prate_table, sizeof(struct setratable_parm));
746 r8712_enqueue_cmd(pcmdpriv, ph2c);
750 u8 r8712_gettssi_cmd(struct _adapter *padapter, u8 offset, u8 *pval)
752 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
753 struct cmd_obj *ph2c;
754 struct readTSSI_parm *prdtssiparm;
756 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
759 prdtssiparm = kmalloc(sizeof(struct readTSSI_parm), GFP_ATOMIC);
760 if (prdtssiparm == NULL) {
761 kfree((unsigned char *) ph2c);
764 _init_listhead(&ph2c->list);
765 ph2c->cmdcode = GEN_CMD_CODE(_ReadTSSI);
766 ph2c->parmbuf = (unsigned char *)prdtssiparm;
767 ph2c->cmdsz = sizeof(struct readTSSI_parm);
769 ph2c->rspsz = sizeof(struct readTSSI_rsp);
771 prdtssiparm->offset = offset;
772 r8712_enqueue_cmd(pcmdpriv, ph2c);
776 u8 r8712_setMacAddr_cmd(struct _adapter *padapter, u8 *mac_addr)
778 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
779 struct cmd_obj *ph2c;
780 struct SetMacAddr_param *psetMacAddr_para;
782 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
785 psetMacAddr_para = kmalloc(sizeof(struct SetMacAddr_param),
787 if (psetMacAddr_para == NULL) {
791 init_h2fwcmd_w_parm_no_rsp(ph2c, psetMacAddr_para,
792 _SetMacAddress_CMD_);
793 memcpy(psetMacAddr_para->MacAddr, mac_addr, ETH_ALEN);
794 r8712_enqueue_cmd(pcmdpriv, ph2c);
798 u8 r8712_setassocsta_cmd(struct _adapter *padapter, u8 *mac_addr)
800 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
801 struct cmd_obj *ph2c;
802 struct set_assocsta_parm *psetassocsta_para;
803 struct set_assocsta_rsp *psetassocsta_rsp = NULL;
805 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
808 psetassocsta_para = kmalloc(sizeof(struct set_assocsta_parm),
810 if (psetassocsta_para == NULL) {
814 psetassocsta_rsp = kmalloc(sizeof(struct set_assocsta_rsp),
816 if (psetassocsta_rsp == NULL) {
818 kfree((u8 *)psetassocsta_para);
821 init_h2fwcmd_w_parm_no_rsp(ph2c, psetassocsta_para, _SetAssocSta_CMD_);
822 ph2c->rsp = (u8 *) psetassocsta_rsp;
823 ph2c->rspsz = sizeof(struct set_assocsta_rsp);
824 memcpy(psetassocsta_para->addr, mac_addr, ETH_ALEN);
825 r8712_enqueue_cmd(pcmdpriv, ph2c);
829 u8 r8712_addbareq_cmd(struct _adapter *padapter, u8 tid)
831 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
832 struct cmd_obj *ph2c;
833 struct addBaReq_parm *paddbareq_parm;
835 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
838 paddbareq_parm = kmalloc(sizeof(struct addBaReq_parm), GFP_ATOMIC);
839 if (paddbareq_parm == NULL) {
840 kfree((unsigned char *)ph2c);
843 paddbareq_parm->tid = tid;
844 init_h2fwcmd_w_parm_no_rsp(ph2c, paddbareq_parm,
845 GEN_CMD_CODE(_AddBAReq));
846 r8712_enqueue_cmd_ex(pcmdpriv, ph2c);
850 u8 r8712_wdg_wk_cmd(struct _adapter *padapter)
852 struct cmd_obj *ph2c;
853 struct drvint_cmd_parm *pdrvintcmd_param;
854 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
856 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
859 pdrvintcmd_param = kmalloc(sizeof(struct drvint_cmd_parm), GFP_ATOMIC);
860 if (pdrvintcmd_param == NULL) {
861 kfree((unsigned char *)ph2c);
864 pdrvintcmd_param->i_cid = WDG_WK_CID;
865 pdrvintcmd_param->sz = 0;
866 pdrvintcmd_param->pbuf = NULL;
867 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvintcmd_param, _DRV_INT_CMD_);
868 r8712_enqueue_cmd_ex(pcmdpriv, ph2c);
872 void r8712_survey_cmd_callback(struct _adapter *padapter, struct cmd_obj *pcmd)
874 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
876 if (pcmd->res != H2C_SUCCESS)
877 clr_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
878 r8712_free_cmd_obj(pcmd);
881 void r8712_disassoc_cmd_callback(struct _adapter *padapter,
882 struct cmd_obj *pcmd)
885 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
887 if (pcmd->res != H2C_SUCCESS) {
888 spin_lock_irqsave(&pmlmepriv->lock, irqL);
889 set_fwstate(pmlmepriv, _FW_LINKED);
890 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
893 r8712_free_cmd_obj(pcmd);
896 void r8712_joinbss_cmd_callback(struct _adapter *padapter, struct cmd_obj *pcmd)
898 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
900 if (pcmd->res != H2C_SUCCESS)
901 _set_timer(&pmlmepriv->assoc_timer, 1);
902 r8712_free_cmd_obj(pcmd);
905 void r8712_createbss_cmd_callback(struct _adapter *padapter,
906 struct cmd_obj *pcmd)
910 struct sta_info *psta = NULL;
911 struct wlan_network *pwlan = NULL;
912 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
913 struct ndis_wlan_bssid_ex *pnetwork = (struct ndis_wlan_bssid_ex *)
915 struct wlan_network *tgt_network = &(pmlmepriv->cur_network);
917 if (pcmd->res != H2C_SUCCESS)
918 _set_timer(&pmlmepriv->assoc_timer, 1);
919 _cancel_timer(&pmlmepriv->assoc_timer, &timer_cancelled);
922 pnetwork->Length = le32_to_cpu(pnetwork->Length);
923 pnetwork->Ssid.SsidLength = le32_to_cpu(pnetwork->Ssid.SsidLength);
924 pnetwork->Privacy = le32_to_cpu(pnetwork->Privacy);
925 pnetwork->Rssi = le32_to_cpu(pnetwork->Rssi);
926 pnetwork->NetworkTypeInUse = le32_to_cpu(pnetwork->NetworkTypeInUse);
927 pnetwork->Configuration.ATIMWindow = le32_to_cpu(pnetwork->
928 Configuration.ATIMWindow);
929 pnetwork->Configuration.DSConfig = le32_to_cpu(pnetwork->
930 Configuration.DSConfig);
931 pnetwork->Configuration.FHConfig.DwellTime = le32_to_cpu(pnetwork->
932 Configuration.FHConfig.DwellTime);
933 pnetwork->Configuration.FHConfig.HopPattern = le32_to_cpu(pnetwork->
934 Configuration.FHConfig.HopPattern);
935 pnetwork->Configuration.FHConfig.HopSet = le32_to_cpu(pnetwork->
936 Configuration.FHConfig.HopSet);
937 pnetwork->Configuration.FHConfig.Length = le32_to_cpu(pnetwork->
938 Configuration.FHConfig.Length);
939 pnetwork->Configuration.Length = le32_to_cpu(pnetwork->
940 Configuration.Length);
941 pnetwork->InfrastructureMode = le32_to_cpu(pnetwork->
943 pnetwork->IELength = le32_to_cpu(pnetwork->IELength);
945 spin_lock_irqsave(&pmlmepriv->lock, irqL);
946 if ((pmlmepriv->fw_state) & WIFI_AP_STATE) {
947 psta = r8712_get_stainfo(&padapter->stapriv,
948 pnetwork->MacAddress);
950 psta = r8712_alloc_stainfo(&padapter->stapriv,
951 pnetwork->MacAddress);
953 goto createbss_cmd_fail;
955 r8712_indicate_connect(padapter);
957 pwlan = _r8712_alloc_network(pmlmepriv);
959 pwlan = r8712_get_oldest_wlan_network(
960 &pmlmepriv->scanned_queue);
962 goto createbss_cmd_fail;
963 pwlan->last_scanned = jiffies;
965 list_insert_tail(&(pwlan->list),
966 &pmlmepriv->scanned_queue.queue);
967 pnetwork->Length = r8712_get_ndis_wlan_bssid_ex_sz(pnetwork);
968 memcpy(&(pwlan->network), pnetwork, pnetwork->Length);
970 memcpy(&tgt_network->network, pnetwork,
971 (r8712_get_ndis_wlan_bssid_ex_sz(pnetwork)));
972 if (pmlmepriv->fw_state & _FW_UNDER_LINKING)
973 pmlmepriv->fw_state ^= _FW_UNDER_LINKING;
974 /* we will set _FW_LINKED when there is one more sat to
975 * join us (stassoc_event_callback) */
978 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
979 r8712_free_cmd_obj(pcmd);
982 void r8712_setstaKey_cmdrsp_callback(struct _adapter *padapter,
983 struct cmd_obj *pcmd)
985 struct sta_priv *pstapriv = &padapter->stapriv;
986 struct set_stakey_rsp *psetstakey_rsp = (struct set_stakey_rsp *)
988 struct sta_info *psta = r8712_get_stainfo(pstapriv,
989 psetstakey_rsp->addr);
993 psta->aid = psta->mac_id = psetstakey_rsp->keyid; /*CAM_ID(CAM_ENTRY)*/
995 r8712_free_cmd_obj(pcmd);
998 void r8712_setassocsta_cmdrsp_callback(struct _adapter *padapter,
999 struct cmd_obj *pcmd)
1002 struct sta_priv *pstapriv = &padapter->stapriv;
1003 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1004 struct set_assocsta_parm *passocsta_parm =
1005 (struct set_assocsta_parm *)(pcmd->parmbuf);
1006 struct set_assocsta_rsp *passocsta_rsp =
1007 (struct set_assocsta_rsp *) (pcmd->rsp);
1008 struct sta_info *psta = r8712_get_stainfo(pstapriv,
1009 passocsta_parm->addr);
1013 psta->aid = psta->mac_id = passocsta_rsp->cam_id;
1014 spin_lock_irqsave(&pmlmepriv->lock, irqL);
1015 if ((check_fwstate(pmlmepriv, WIFI_MP_STATE)) &&
1016 (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)))
1017 pmlmepriv->fw_state ^= _FW_UNDER_LINKING;
1018 set_fwstate(pmlmepriv, _FW_LINKED);
1019 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
1020 r8712_free_cmd_obj(pcmd);
1023 u8 r8712_disconnectCtrlEx_cmd(struct _adapter *adapter, u32 enableDrvCtrl,
1024 u32 tryPktCnt, u32 tryPktInterval, u32 firstStageTO)
1026 struct cmd_obj *ph2c;
1027 struct DisconnectCtrlEx_param *param;
1028 struct cmd_priv *pcmdpriv = &adapter->cmdpriv;
1030 ph2c = kmalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
1033 param = kzalloc(sizeof(struct DisconnectCtrlEx_param), GFP_ATOMIC);
1034 if (param == NULL) {
1035 kfree((unsigned char *) ph2c);
1039 param->EnableDrvCtrl = (unsigned char)enableDrvCtrl;
1040 param->TryPktCnt = (unsigned char)tryPktCnt;
1041 param->TryPktInterval = (unsigned char)tryPktInterval;
1042 param->FirstStageTO = (unsigned int)firstStageTO;
1044 init_h2fwcmd_w_parm_no_rsp(ph2c, param,
1045 GEN_CMD_CODE(_DisconnectCtrlEx));
1046 r8712_enqueue_cmd(pcmdpriv, ph2c);