1 /******************************************************************************
2 * rtl871x_cmd.c
3 *
4 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
5 * Linux device driver for RTL8192SU
6 *
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.
10 *
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
14 * more details.
15 *
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
19 *
20 * Modifications for inclusion into the Linux staging tree are
21 * Copyright(c) 2010 Larry Finger. All rights reserved.
22 *
23 * Contact information:
24 * WLAN FAE <wlanfae@realtek.com>
25 * Larry Finger <Larry.Finger@lwfinger.net>
26 *
27 ******************************************************************************/
28
29 #define _RTL871X_CMD_C_
30
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>
47
48 #include "osdep_service.h"
49 #include "drv_types.h"
50 #include "recv_osdep.h"
51 #include "mlme_osdep.h"
52
53 /*
54 Caller and the r8712_cmd_thread can protect cmd_q by spin_lock.
55 No irqsave is necessary.
56 */
57
_init_cmd_priv(struct cmd_priv * pcmdpriv)58 static sint _init_cmd_priv(struct cmd_priv *pcmdpriv)
59 {
60 sema_init(&(pcmdpriv->cmd_queue_sema), 0);
61 sema_init(&(pcmdpriv->terminate_cmdthread_sema), 0);
62
63 _init_queue(&(pcmdpriv->cmd_queue));
64
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,
68 GFP_ATOMIC);
69 if (pcmdpriv->cmd_allocated_buf == NULL)
70 return _FAIL;
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)
76 return _FAIL;
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;
82 return _SUCCESS;
83 }
84
_init_evt_priv(struct evt_priv * pevtpriv)85 static sint _init_evt_priv(struct evt_priv *pevtpriv)
86 {
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);
90
91 if (pevtpriv->evt_allocated_buf == NULL)
92 return _FAIL;
93 pevtpriv->evt_buf = pevtpriv->evt_allocated_buf + 4 -
94 ((addr_t)(pevtpriv->evt_allocated_buf) & 3);
95 pevtpriv->evt_done_cnt = 0;
96 return _SUCCESS;
97 }
98
_free_evt_priv(struct evt_priv * pevtpriv)99 static void _free_evt_priv(struct evt_priv *pevtpriv)
100 {
101 kfree(pevtpriv->evt_allocated_buf);
102 }
103
_free_cmd_priv(struct cmd_priv * pcmdpriv)104 static void _free_cmd_priv(struct cmd_priv *pcmdpriv)
105 {
106 if (pcmdpriv) {
107 kfree(pcmdpriv->cmd_allocated_buf);
108 kfree(pcmdpriv->rsp_allocated_buf);
109 }
110 }
111
112 /*
113 Calling Context:
114
115 _enqueue_cmd can only be called between kernel thread,
116 since only spin_lock is used.
117
118 ISR/Call-Back functions can't call this sub-function.
119
120 */
121
_enqueue_cmd(struct __queue * queue,struct cmd_obj * obj)122 static sint _enqueue_cmd(struct __queue *queue, struct cmd_obj *obj)
123 {
124 unsigned long irqL;
125
126 if (obj == NULL)
127 return _SUCCESS;
128 spin_lock_irqsave(&queue->lock, irqL);
129 list_add_tail(&obj->list, &queue->queue);
130 spin_unlock_irqrestore(&queue->lock, irqL);
131 return _SUCCESS;
132 }
133
_dequeue_cmd(struct __queue * queue)134 static struct cmd_obj *_dequeue_cmd(struct __queue *queue)
135 {
136 unsigned long irqL;
137 struct cmd_obj *obj;
138
139 spin_lock_irqsave(&(queue->lock), irqL);
140 if (list_empty(&(queue->queue))) {
141 obj = NULL;
142 } else {
143 obj = LIST_CONTAINOR(queue->queue.next,
144 struct cmd_obj, list);
145 list_del_init(&obj->list);
146 }
147 spin_unlock_irqrestore(&(queue->lock), irqL);
148 return obj;
149 }
150
r8712_init_cmd_priv(struct cmd_priv * pcmdpriv)151 u32 r8712_init_cmd_priv(struct cmd_priv *pcmdpriv)
152 {
153 return _init_cmd_priv(pcmdpriv);
154 }
155
r8712_init_evt_priv(struct evt_priv * pevtpriv)156 u32 r8712_init_evt_priv(struct evt_priv *pevtpriv)
157 {
158 return _init_evt_priv(pevtpriv);
159 }
160
r8712_free_evt_priv(struct evt_priv * pevtpriv)161 void r8712_free_evt_priv(struct evt_priv *pevtpriv)
162 {
163 _free_evt_priv(pevtpriv);
164 }
165
r8712_free_cmd_priv(struct cmd_priv * pcmdpriv)166 void r8712_free_cmd_priv(struct cmd_priv *pcmdpriv)
167 {
168 _free_cmd_priv(pcmdpriv);
169 }
170
r8712_enqueue_cmd(struct cmd_priv * pcmdpriv,struct cmd_obj * obj)171 u32 r8712_enqueue_cmd(struct cmd_priv *pcmdpriv, struct cmd_obj *obj)
172 {
173 int res;
174
175 if (pcmdpriv->padapter->eeprompriv.bautoload_fail_flag)
176 return _FAIL;
177 res = _enqueue_cmd(&pcmdpriv->cmd_queue, obj);
178 up(&pcmdpriv->cmd_queue_sema);
179 return res;
180 }
181
r8712_enqueue_cmd_ex(struct cmd_priv * pcmdpriv,struct cmd_obj * obj)182 u32 r8712_enqueue_cmd_ex(struct cmd_priv *pcmdpriv, struct cmd_obj *obj)
183 {
184 unsigned long irqL;
185 struct __queue *queue;
186
187 if (obj == NULL)
188 return _SUCCESS;
189 if (pcmdpriv->padapter->eeprompriv.bautoload_fail_flag)
190 return _FAIL;
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 up(&pcmdpriv->cmd_queue_sema);
196 return _SUCCESS;
197 }
198
r8712_dequeue_cmd(struct __queue * queue)199 struct cmd_obj *r8712_dequeue_cmd(struct __queue *queue)
200 {
201 return _dequeue_cmd(queue);
202 }
203
r8712_free_cmd_obj(struct cmd_obj * pcmd)204 void r8712_free_cmd_obj(struct cmd_obj *pcmd)
205 {
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)
211 kfree(pcmd->rsp);
212 }
213 kfree(pcmd);
214 }
215
216 /*
217 r8712_sitesurvey_cmd(~)
218 ### NOTE:#### (!!!!)
219 MUST TAKE CARE THAT BEFORE CALLING THIS FUNC,
220 YOU SHOULD HAVE LOCKED pmlmepriv->lock
221 */
r8712_sitesurvey_cmd(struct _adapter * padapter,struct ndis_802_11_ssid * pssid)222 u8 r8712_sitesurvey_cmd(struct _adapter *padapter,
223 struct ndis_802_11_ssid *pssid)
224 {
225 struct cmd_obj *ph2c;
226 struct sitesurvey_parm *psurveyPara;
227 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
228 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
229
230 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
231 if (ph2c == NULL)
232 return _FAIL;
233 psurveyPara = kmalloc(sizeof(*psurveyPara), GFP_ATOMIC);
234 if (psurveyPara == NULL) {
235 kfree(ph2c);
236 return _FAIL;
237 }
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);
246
247 memcpy(psurveyPara->ss_ssid, pssid->Ssid, len);
248 psurveyPara->ss_ssidlen = cpu_to_le32(len);
249 }
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;
256 return _SUCCESS;
257 }
258
r8712_setdatarate_cmd(struct _adapter * padapter,u8 * rateset)259 u8 r8712_setdatarate_cmd(struct _adapter *padapter, u8 *rateset)
260 {
261 struct cmd_obj *ph2c;
262 struct setdatarate_parm *pbsetdataratepara;
263 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
264
265 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
266 if (ph2c == NULL)
267 return _FAIL;
268 pbsetdataratepara = kmalloc(sizeof(*pbsetdataratepara), GFP_ATOMIC);
269 if (pbsetdataratepara == NULL) {
270 kfree(ph2c);
271 return _FAIL;
272 }
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);
278 return _SUCCESS;
279 }
280
r8712_set_chplan_cmd(struct _adapter * padapter,int chplan)281 u8 r8712_set_chplan_cmd(struct _adapter *padapter, int chplan)
282 {
283 struct cmd_obj *ph2c;
284 struct SetChannelPlan_param *psetchplanpara;
285 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
286
287 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
288 if (ph2c == NULL)
289 return _FAIL;
290 psetchplanpara = kmalloc(sizeof(*psetchplanpara), GFP_ATOMIC);
291 if (psetchplanpara == NULL) {
292 kfree(ph2c);
293 return _FAIL;
294 }
295 init_h2fwcmd_w_parm_no_rsp(ph2c, psetchplanpara,
296 GEN_CMD_CODE(_SetChannelPlan));
297 psetchplanpara->ChannelPlan = chplan;
298 r8712_enqueue_cmd(pcmdpriv, ph2c);
299 return _SUCCESS;
300 }
301
r8712_setbasicrate_cmd(struct _adapter * padapter,u8 * rateset)302 u8 r8712_setbasicrate_cmd(struct _adapter *padapter, u8 *rateset)
303 {
304 struct cmd_obj *ph2c;
305 struct setbasicrate_parm *pssetbasicratepara;
306 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
307
308 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
309 if (ph2c == NULL)
310 return _FAIL;
311 pssetbasicratepara = kmalloc(sizeof(*pssetbasicratepara), GFP_ATOMIC);
312 if (pssetbasicratepara == NULL) {
313 kfree(ph2c);
314 return _FAIL;
315 }
316 init_h2fwcmd_w_parm_no_rsp(ph2c, pssetbasicratepara,
317 _SetBasicRate_CMD_);
318 memcpy(pssetbasicratepara->basicrates, rateset, NumRates);
319 r8712_enqueue_cmd(pcmdpriv, ph2c);
320 return _SUCCESS;
321 }
322
323 /* power tracking mechanism setting */
r8712_setptm_cmd(struct _adapter * padapter,u8 type)324 u8 r8712_setptm_cmd(struct _adapter *padapter, u8 type)
325 {
326 struct cmd_obj *ph2c;
327 struct writePTM_parm *pwriteptmparm;
328 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
329
330 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
331 if (ph2c == NULL)
332 return _FAIL;
333 pwriteptmparm = kmalloc(sizeof(*pwriteptmparm), GFP_ATOMIC);
334 if (pwriteptmparm == NULL) {
335 kfree(ph2c);
336 return _FAIL;
337 }
338 init_h2fwcmd_w_parm_no_rsp(ph2c, pwriteptmparm, GEN_CMD_CODE(_SetPT));
339 pwriteptmparm->type = type;
340 r8712_enqueue_cmd(pcmdpriv, ph2c);
341 return _SUCCESS;
342 }
343
r8712_setfwdig_cmd(struct _adapter * padapter,u8 type)344 u8 r8712_setfwdig_cmd(struct _adapter *padapter, u8 type)
345 {
346 struct cmd_obj *ph2c;
347 struct writePTM_parm *pwriteptmparm;
348 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
349
350 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
351 if (ph2c == NULL)
352 return _FAIL;
353 pwriteptmparm = kmalloc(sizeof(*pwriteptmparm), GFP_ATOMIC);
354 if (pwriteptmparm == NULL) {
355 kfree(ph2c);
356 return _FAIL;
357 }
358 init_h2fwcmd_w_parm_no_rsp(ph2c, pwriteptmparm, GEN_CMD_CODE(_SetDIG));
359 pwriteptmparm->type = type;
360 r8712_enqueue_cmd(pcmdpriv, ph2c);
361 return _SUCCESS;
362 }
363
r8712_setfwra_cmd(struct _adapter * padapter,u8 type)364 u8 r8712_setfwra_cmd(struct _adapter *padapter, u8 type)
365 {
366 struct cmd_obj *ph2c;
367 struct writePTM_parm *pwriteptmparm;
368 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
369
370 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
371 if (ph2c == NULL)
372 return _FAIL;
373 pwriteptmparm = kmalloc(sizeof(*pwriteptmparm), GFP_ATOMIC);
374 if (pwriteptmparm == NULL) {
375 kfree(ph2c);
376 return _FAIL;
377 }
378 init_h2fwcmd_w_parm_no_rsp(ph2c, pwriteptmparm, GEN_CMD_CODE(_SetRA));
379 pwriteptmparm->type = type;
380 r8712_enqueue_cmd(pcmdpriv, ph2c);
381 return _SUCCESS;
382 }
383
r8712_setrfreg_cmd(struct _adapter * padapter,u8 offset,u32 val)384 u8 r8712_setrfreg_cmd(struct _adapter *padapter, u8 offset, u32 val)
385 {
386 struct cmd_obj *ph2c;
387 struct writeRF_parm *pwriterfparm;
388 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
389
390 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
391 if (ph2c == NULL)
392 return _FAIL;
393 pwriterfparm = kmalloc(sizeof(*pwriterfparm), GFP_ATOMIC);
394 if (pwriterfparm == NULL) {
395 kfree(ph2c);
396 return _FAIL;
397 }
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);
402 return _SUCCESS;
403 }
404
r8712_getrfreg_cmd(struct _adapter * padapter,u8 offset,u8 * pval)405 u8 r8712_getrfreg_cmd(struct _adapter *padapter, u8 offset, u8 *pval)
406 {
407 struct cmd_obj *ph2c;
408 struct readRF_parm *prdrfparm;
409 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
410
411 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
412 if (ph2c == NULL)
413 return _FAIL;
414 prdrfparm = kmalloc(sizeof(*prdrfparm), GFP_ATOMIC);
415 if (prdrfparm == NULL) {
416 kfree(ph2c);
417 return _FAIL;
418 }
419 INIT_LIST_HEAD(&ph2c->list);
420 ph2c->cmdcode = GEN_CMD_CODE(_GetRFReg);
421 ph2c->parmbuf = (unsigned char *)prdrfparm;
422 ph2c->cmdsz = sizeof(struct readRF_parm);
423 ph2c->rsp = pval;
424 ph2c->rspsz = sizeof(struct readRF_rsp);
425 prdrfparm->offset = offset;
426 r8712_enqueue_cmd(pcmdpriv, ph2c);
427 return _SUCCESS;
428 }
429
r8712_getbbrfreg_cmdrsp_callback(struct _adapter * padapter,struct cmd_obj * pcmd)430 void r8712_getbbrfreg_cmdrsp_callback(struct _adapter *padapter,
431 struct cmd_obj *pcmd)
432 {
433 kfree(pcmd->parmbuf);
434 kfree(pcmd);
435 padapter->mppriv.workparam.bcompleted = true;
436 }
437
r8712_readtssi_cmdrsp_callback(struct _adapter * padapter,struct cmd_obj * pcmd)438 void r8712_readtssi_cmdrsp_callback(struct _adapter *padapter,
439 struct cmd_obj *pcmd)
440 {
441 kfree(pcmd->parmbuf);
442 kfree(pcmd);
443
444 padapter->mppriv.workparam.bcompleted = true;
445 }
446
r8712_createbss_cmd(struct _adapter * padapter)447 u8 r8712_createbss_cmd(struct _adapter *padapter)
448 {
449 struct cmd_obj *pcmd;
450 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
451 struct wlan_bssid_ex *pdev_network =
452 &padapter->registrypriv.dev_network;
453
454 padapter->ledpriv.LedControlHandler(padapter, LED_CTL_START_TO_LINK);
455 pcmd = kmalloc(sizeof(*pcmd), GFP_ATOMIC);
456 if (pcmd == NULL)
457 return _FAIL;
458 INIT_LIST_HEAD(&pcmd->list);
459 pcmd->cmdcode = _CreateBss_CMD_;
460 pcmd->parmbuf = (unsigned char *)pdev_network;
461 pcmd->cmdsz = r8712_get_wlan_bssid_ex_sz(pdev_network);
462 pcmd->rsp = NULL;
463 pcmd->rspsz = 0;
464 /* notes: translate IELength & Length after assign to cmdsz; */
465 pdev_network->Length = pcmd->cmdsz;
466 pdev_network->IELength = pdev_network->IELength;
467 pdev_network->Ssid.SsidLength = pdev_network->Ssid.SsidLength;
468 r8712_enqueue_cmd(pcmdpriv, pcmd);
469 return _SUCCESS;
470 }
471
r8712_joinbss_cmd(struct _adapter * padapter,struct wlan_network * pnetwork)472 u8 r8712_joinbss_cmd(struct _adapter *padapter, struct wlan_network *pnetwork)
473 {
474 struct wlan_bssid_ex *psecnetwork;
475 struct cmd_obj *pcmd;
476 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
477 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
478 struct qos_priv *pqospriv = &pmlmepriv->qospriv;
479 struct security_priv *psecuritypriv = &padapter->securitypriv;
480 struct registry_priv *pregistrypriv = &padapter->registrypriv;
481 enum NDIS_802_11_NETWORK_INFRASTRUCTURE ndis_network_mode = pnetwork->
482 network.InfrastructureMode;
483
484 padapter->ledpriv.LedControlHandler(padapter, LED_CTL_START_TO_LINK);
485 pcmd = kmalloc(sizeof(*pcmd), GFP_ATOMIC);
486 if (pcmd == NULL)
487 return _FAIL;
488
489 /* for hidden ap to set fw_state here */
490 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE | WIFI_ADHOC_STATE) !=
491 true) {
492 switch (ndis_network_mode) {
493 case Ndis802_11IBSS:
494 pmlmepriv->fw_state |= WIFI_ADHOC_STATE;
495 break;
496 case Ndis802_11Infrastructure:
497 pmlmepriv->fw_state |= WIFI_STATION_STATE;
498 break;
499 case Ndis802_11APMode:
500 case Ndis802_11AutoUnknown:
501 case Ndis802_11InfrastructureMax:
502 break;
503 }
504 }
505 psecnetwork = &psecuritypriv->sec_bss;
506 if (psecnetwork == NULL) {
507 kfree(pcmd);
508 return _FAIL;
509 }
510 memcpy(psecnetwork, &pnetwork->network, sizeof(*psecnetwork));
511 psecuritypriv->authenticator_ie[0] = (unsigned char)
512 psecnetwork->IELength;
513 if ((psecnetwork->IELength - 12) < (256 - 1))
514 memcpy(&psecuritypriv->authenticator_ie[1],
515 &psecnetwork->IEs[12], psecnetwork->IELength - 12);
516 else
517 memcpy(&psecuritypriv->authenticator_ie[1],
518 &psecnetwork->IEs[12], (256 - 1));
519 psecnetwork->IELength = 0;
520 /* If the driver wants to use the bssid to create the connection.
521 * If not, we copy the connecting AP's MAC address to it so that
522 * the driver just has the bssid information for PMKIDList searching.
523 */
524 if (!pmlmepriv->assoc_by_bssid)
525 ether_addr_copy(&pmlmepriv->assoc_bssid[0],
526 &pnetwork->network.MacAddress[0]);
527 psecnetwork->IELength = r8712_restruct_sec_ie(padapter,
528 &pnetwork->network.IEs[0],
529 &psecnetwork->IEs[0],
530 pnetwork->network.IELength);
531 pqospriv->qos_option = 0;
532 if (pregistrypriv->wmm_enable) {
533 u32 tmp_len;
534
535 tmp_len = r8712_restruct_wmm_ie(padapter,
536 &pnetwork->network.IEs[0],
537 &psecnetwork->IEs[0],
538 pnetwork->network.IELength,
539 psecnetwork->IELength);
540 if (psecnetwork->IELength != tmp_len) {
541 psecnetwork->IELength = tmp_len;
542 pqospriv->qos_option = 1; /* WMM IE in beacon */
543 } else {
544 pqospriv->qos_option = 0; /* no WMM IE in beacon */
545 }
546 }
547 if (pregistrypriv->ht_enable) {
548 /* For WEP mode, we will use the bg mode to do the connection
549 * to avoid some IOT issues, especially for Realtek 8192u
550 * SoftAP.
551 */
552 if ((padapter->securitypriv.PrivacyAlgrthm != _WEP40_) &&
553 (padapter->securitypriv.PrivacyAlgrthm != _WEP104_)) {
554 /* restructure_ht_ie */
555 r8712_restructure_ht_ie(padapter,
556 &pnetwork->network.IEs[0],
557 &psecnetwork->IEs[0],
558 pnetwork->network.IELength,
559 &psecnetwork->IELength);
560 }
561 }
562 psecuritypriv->supplicant_ie[0] = (u8)psecnetwork->IELength;
563 if (psecnetwork->IELength < 255)
564 memcpy(&psecuritypriv->supplicant_ie[1], &psecnetwork->IEs[0],
565 psecnetwork->IELength);
566 else
567 memcpy(&psecuritypriv->supplicant_ie[1], &psecnetwork->IEs[0],
568 255);
569 /* get cmdsz before endian conversion */
570 pcmd->cmdsz = r8712_get_wlan_bssid_ex_sz(psecnetwork);
571 #ifdef __BIG_ENDIAN
572 /* wlan_network endian conversion */
573 psecnetwork->Length = cpu_to_le32(psecnetwork->Length);
574 psecnetwork->Ssid.SsidLength = cpu_to_le32(
575 psecnetwork->Ssid.SsidLength);
576 psecnetwork->Privacy = cpu_to_le32(psecnetwork->Privacy);
577 psecnetwork->Rssi = cpu_to_le32(psecnetwork->Rssi);
578 psecnetwork->NetworkTypeInUse = cpu_to_le32(
579 psecnetwork->NetworkTypeInUse);
580 psecnetwork->Configuration.ATIMWindow = cpu_to_le32(
581 psecnetwork->Configuration.ATIMWindow);
582 psecnetwork->Configuration.BeaconPeriod = cpu_to_le32(
583 psecnetwork->Configuration.BeaconPeriod);
584 psecnetwork->Configuration.DSConfig = cpu_to_le32(
585 psecnetwork->Configuration.DSConfig);
586 psecnetwork->Configuration.FHConfig.DwellTime = cpu_to_le32(
587 psecnetwork->Configuration.FHConfig.DwellTime);
588 psecnetwork->Configuration.FHConfig.HopPattern = cpu_to_le32(
589 psecnetwork->Configuration.FHConfig.HopPattern);
590 psecnetwork->Configuration.FHConfig.HopSet = cpu_to_le32(
591 psecnetwork->Configuration.FHConfig.HopSet);
592 psecnetwork->Configuration.FHConfig.Length = cpu_to_le32(
593 psecnetwork->Configuration.FHConfig.Length);
594 psecnetwork->Configuration.Length = cpu_to_le32(
595 psecnetwork->Configuration.Length);
596 psecnetwork->InfrastructureMode = cpu_to_le32(
597 psecnetwork->InfrastructureMode);
598 psecnetwork->IELength = cpu_to_le32(psecnetwork->IELength);
599 #endif
600 INIT_LIST_HEAD(&pcmd->list);
601 pcmd->cmdcode = _JoinBss_CMD_;
602 pcmd->parmbuf = (unsigned char *)psecnetwork;
603 pcmd->rsp = NULL;
604 pcmd->rspsz = 0;
605 r8712_enqueue_cmd(pcmdpriv, pcmd);
606 return _SUCCESS;
607 }
608
r8712_disassoc_cmd(struct _adapter * padapter)609 u8 r8712_disassoc_cmd(struct _adapter *padapter) /* for sta_mode */
610 {
611 struct cmd_obj *pdisconnect_cmd;
612 struct disconnect_parm *pdisconnect;
613 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
614
615 pdisconnect_cmd = kmalloc(sizeof(*pdisconnect_cmd), GFP_ATOMIC);
616 if (pdisconnect_cmd == NULL)
617 return _FAIL;
618 pdisconnect = kmalloc(sizeof(*pdisconnect), GFP_ATOMIC);
619 if (pdisconnect == NULL) {
620 kfree(pdisconnect_cmd);
621 return _FAIL;
622 }
623 init_h2fwcmd_w_parm_no_rsp(pdisconnect_cmd, pdisconnect,
624 _DisConnect_CMD_);
625 r8712_enqueue_cmd(pcmdpriv, pdisconnect_cmd);
626 return _SUCCESS;
627 }
628
r8712_setopmode_cmd(struct _adapter * padapter,enum NDIS_802_11_NETWORK_INFRASTRUCTURE networktype)629 u8 r8712_setopmode_cmd(struct _adapter *padapter,
630 enum NDIS_802_11_NETWORK_INFRASTRUCTURE networktype)
631 {
632 struct cmd_obj *ph2c;
633 struct setopmode_parm *psetop;
634
635 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
636
637 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
638 if (ph2c == NULL)
639 return _FAIL;
640 psetop = kmalloc(sizeof(*psetop), GFP_ATOMIC);
641 if (psetop == NULL) {
642 kfree(ph2c);
643 return _FAIL;
644 }
645 init_h2fwcmd_w_parm_no_rsp(ph2c, psetop, _SetOpMode_CMD_);
646 psetop->mode = (u8)networktype;
647 r8712_enqueue_cmd(pcmdpriv, ph2c);
648 return _SUCCESS;
649 }
650
r8712_setstakey_cmd(struct _adapter * padapter,u8 * psta,u8 unicast_key)651 u8 r8712_setstakey_cmd(struct _adapter *padapter, u8 *psta, u8 unicast_key)
652 {
653 struct cmd_obj *ph2c;
654 struct set_stakey_parm *psetstakey_para;
655 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
656 struct set_stakey_rsp *psetstakey_rsp = NULL;
657 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
658 struct security_priv *psecuritypriv = &padapter->securitypriv;
659 struct sta_info *sta = (struct sta_info *)psta;
660
661 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
662 if (ph2c == NULL)
663 return _FAIL;
664 psetstakey_para = kmalloc(sizeof(*psetstakey_para), GFP_ATOMIC);
665 if (psetstakey_para == NULL) {
666 kfree(ph2c);
667 return _FAIL;
668 }
669 psetstakey_rsp = kmalloc(sizeof(*psetstakey_rsp), GFP_ATOMIC);
670 if (psetstakey_rsp == NULL) {
671 kfree(ph2c);
672 kfree(psetstakey_para);
673 return _FAIL;
674 }
675 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_);
676 ph2c->rsp = (u8 *) psetstakey_rsp;
677 ph2c->rspsz = sizeof(struct set_stakey_rsp);
678 ether_addr_copy(psetstakey_para->addr, sta->hwaddr);
679 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
680 psetstakey_para->algorithm = (unsigned char)
681 psecuritypriv->PrivacyAlgrthm;
682 else
683 GET_ENCRY_ALGO(psecuritypriv, sta,
684 psetstakey_para->algorithm, false);
685 if (unicast_key)
686 memcpy(&psetstakey_para->key, &sta->x_UncstKey, 16);
687 else
688 memcpy(&psetstakey_para->key,
689 &psecuritypriv->XGrpKey[
690 psecuritypriv->XGrpKeyid - 1]. skey, 16);
691 r8712_enqueue_cmd(pcmdpriv, ph2c);
692 return _SUCCESS;
693 }
694
r8712_setrfintfs_cmd(struct _adapter * padapter,u8 mode)695 u8 r8712_setrfintfs_cmd(struct _adapter *padapter, u8 mode)
696 {
697 struct cmd_obj *ph2c;
698 struct setrfintfs_parm *psetrfintfsparm;
699 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
700
701 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
702 if (ph2c == NULL)
703 return _FAIL;
704 psetrfintfsparm = kmalloc(sizeof(*psetrfintfsparm), GFP_ATOMIC);
705 if (psetrfintfsparm == NULL) {
706 kfree(ph2c);
707 return _FAIL;
708 }
709 init_h2fwcmd_w_parm_no_rsp(ph2c, psetrfintfsparm,
710 GEN_CMD_CODE(_SetRFIntFs));
711 psetrfintfsparm->rfintfs = mode;
712 r8712_enqueue_cmd(pcmdpriv, ph2c);
713 return _SUCCESS;
714 }
715
r8712_setrttbl_cmd(struct _adapter * padapter,struct setratable_parm * prate_table)716 u8 r8712_setrttbl_cmd(struct _adapter *padapter,
717 struct setratable_parm *prate_table)
718 {
719 struct cmd_obj *ph2c;
720 struct setratable_parm *psetrttblparm;
721 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
722
723 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
724 if (ph2c == NULL)
725 return _FAIL;
726 psetrttblparm = kmalloc(sizeof(*psetrttblparm), GFP_ATOMIC);
727 if (psetrttblparm == NULL) {
728 kfree(ph2c);
729 return _FAIL;
730 }
731 init_h2fwcmd_w_parm_no_rsp(ph2c, psetrttblparm,
732 GEN_CMD_CODE(_SetRaTable));
733 memcpy(psetrttblparm, prate_table, sizeof(struct setratable_parm));
734 r8712_enqueue_cmd(pcmdpriv, ph2c);
735 return _SUCCESS;
736 }
737
r8712_gettssi_cmd(struct _adapter * padapter,u8 offset,u8 * pval)738 u8 r8712_gettssi_cmd(struct _adapter *padapter, u8 offset, u8 *pval)
739 {
740 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
741 struct cmd_obj *ph2c;
742 struct readTSSI_parm *prdtssiparm;
743
744 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
745 if (ph2c == NULL)
746 return _FAIL;
747 prdtssiparm = kmalloc(sizeof(*prdtssiparm), GFP_ATOMIC);
748 if (prdtssiparm == NULL) {
749 kfree(ph2c);
750 return _FAIL;
751 }
752 INIT_LIST_HEAD(&ph2c->list);
753 ph2c->cmdcode = GEN_CMD_CODE(_ReadTSSI);
754 ph2c->parmbuf = (unsigned char *)prdtssiparm;
755 ph2c->cmdsz = sizeof(struct readTSSI_parm);
756 ph2c->rsp = pval;
757 ph2c->rspsz = sizeof(struct readTSSI_rsp);
758
759 prdtssiparm->offset = offset;
760 r8712_enqueue_cmd(pcmdpriv, ph2c);
761 return _SUCCESS;
762 }
763
r8712_setMacAddr_cmd(struct _adapter * padapter,u8 * mac_addr)764 u8 r8712_setMacAddr_cmd(struct _adapter *padapter, u8 *mac_addr)
765 {
766 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
767 struct cmd_obj *ph2c;
768 struct SetMacAddr_param *psetMacAddr_para;
769
770 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
771 if (ph2c == NULL)
772 return _FAIL;
773 psetMacAddr_para = kmalloc(sizeof(*psetMacAddr_para), GFP_ATOMIC);
774 if (psetMacAddr_para == NULL) {
775 kfree(ph2c);
776 return _FAIL;
777 }
778 init_h2fwcmd_w_parm_no_rsp(ph2c, psetMacAddr_para,
779 _SetMacAddress_CMD_);
780 ether_addr_copy(psetMacAddr_para->MacAddr, mac_addr);
781 r8712_enqueue_cmd(pcmdpriv, ph2c);
782 return _SUCCESS;
783 }
784
r8712_setassocsta_cmd(struct _adapter * padapter,u8 * mac_addr)785 u8 r8712_setassocsta_cmd(struct _adapter *padapter, u8 *mac_addr)
786 {
787 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
788 struct cmd_obj *ph2c;
789 struct set_assocsta_parm *psetassocsta_para;
790 struct set_assocsta_rsp *psetassocsta_rsp = NULL;
791
792 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
793 if (ph2c == NULL)
794 return _FAIL;
795 psetassocsta_para = kmalloc(sizeof(*psetassocsta_para), GFP_ATOMIC);
796 if (psetassocsta_para == NULL) {
797 kfree(ph2c);
798 return _FAIL;
799 }
800 psetassocsta_rsp = kmalloc(sizeof(*psetassocsta_rsp), GFP_ATOMIC);
801 if (psetassocsta_rsp == NULL) {
802 kfree(ph2c);
803 kfree(psetassocsta_para);
804 return _FAIL;
805 }
806 init_h2fwcmd_w_parm_no_rsp(ph2c, psetassocsta_para, _SetAssocSta_CMD_);
807 ph2c->rsp = (u8 *) psetassocsta_rsp;
808 ph2c->rspsz = sizeof(struct set_assocsta_rsp);
809 ether_addr_copy(psetassocsta_para->addr, mac_addr);
810 r8712_enqueue_cmd(pcmdpriv, ph2c);
811 return _SUCCESS;
812 }
813
r8712_addbareq_cmd(struct _adapter * padapter,u8 tid)814 u8 r8712_addbareq_cmd(struct _adapter *padapter, u8 tid)
815 {
816 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
817 struct cmd_obj *ph2c;
818 struct addBaReq_parm *paddbareq_parm;
819
820 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
821 if (ph2c == NULL)
822 return _FAIL;
823 paddbareq_parm = kmalloc(sizeof(*paddbareq_parm), GFP_ATOMIC);
824 if (paddbareq_parm == NULL) {
825 kfree(ph2c);
826 return _FAIL;
827 }
828 paddbareq_parm->tid = tid;
829 init_h2fwcmd_w_parm_no_rsp(ph2c, paddbareq_parm,
830 GEN_CMD_CODE(_AddBAReq));
831 r8712_enqueue_cmd_ex(pcmdpriv, ph2c);
832 return _SUCCESS;
833 }
834
r8712_wdg_wk_cmd(struct _adapter * padapter)835 u8 r8712_wdg_wk_cmd(struct _adapter *padapter)
836 {
837 struct cmd_obj *ph2c;
838 struct drvint_cmd_parm *pdrvintcmd_param;
839 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
840
841 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
842 if (ph2c == NULL)
843 return _FAIL;
844 pdrvintcmd_param = kmalloc(sizeof(*pdrvintcmd_param), GFP_ATOMIC);
845 if (pdrvintcmd_param == NULL) {
846 kfree(ph2c);
847 return _FAIL;
848 }
849 pdrvintcmd_param->i_cid = WDG_WK_CID;
850 pdrvintcmd_param->sz = 0;
851 pdrvintcmd_param->pbuf = NULL;
852 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvintcmd_param, _DRV_INT_CMD_);
853 r8712_enqueue_cmd_ex(pcmdpriv, ph2c);
854 return _SUCCESS;
855 }
856
r8712_survey_cmd_callback(struct _adapter * padapter,struct cmd_obj * pcmd)857 void r8712_survey_cmd_callback(struct _adapter *padapter, struct cmd_obj *pcmd)
858 {
859 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
860
861 if (pcmd->res != H2C_SUCCESS)
862 clr_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
863 r8712_free_cmd_obj(pcmd);
864 }
865
r8712_disassoc_cmd_callback(struct _adapter * padapter,struct cmd_obj * pcmd)866 void r8712_disassoc_cmd_callback(struct _adapter *padapter,
867 struct cmd_obj *pcmd)
868 {
869 unsigned long irqL;
870 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
871
872 if (pcmd->res != H2C_SUCCESS) {
873 spin_lock_irqsave(&pmlmepriv->lock, irqL);
874 set_fwstate(pmlmepriv, _FW_LINKED);
875 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
876 return;
877 }
878 r8712_free_cmd_obj(pcmd);
879 }
880
r8712_joinbss_cmd_callback(struct _adapter * padapter,struct cmd_obj * pcmd)881 void r8712_joinbss_cmd_callback(struct _adapter *padapter, struct cmd_obj *pcmd)
882 {
883 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
884
885 if (pcmd->res != H2C_SUCCESS)
886 mod_timer(&pmlmepriv->assoc_timer,
887 jiffies + msecs_to_jiffies(1));
888 r8712_free_cmd_obj(pcmd);
889 }
890
r8712_createbss_cmd_callback(struct _adapter * padapter,struct cmd_obj * pcmd)891 void r8712_createbss_cmd_callback(struct _adapter *padapter,
892 struct cmd_obj *pcmd)
893 {
894 unsigned long irqL;
895 struct sta_info *psta = NULL;
896 struct wlan_network *pwlan = NULL;
897 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
898 struct wlan_bssid_ex *pnetwork = (struct wlan_bssid_ex *)pcmd->parmbuf;
899 struct wlan_network *tgt_network = &(pmlmepriv->cur_network);
900
901 if (pcmd->res != H2C_SUCCESS)
902 mod_timer(&pmlmepriv->assoc_timer,
903 jiffies + msecs_to_jiffies(1));
904 del_timer(&pmlmepriv->assoc_timer);
905 #ifdef __BIG_ENDIAN
906 /* endian_convert */
907 pnetwork->Length = le32_to_cpu(pnetwork->Length);
908 pnetwork->Ssid.SsidLength = le32_to_cpu(pnetwork->Ssid.SsidLength);
909 pnetwork->Privacy = le32_to_cpu(pnetwork->Privacy);
910 pnetwork->Rssi = le32_to_cpu(pnetwork->Rssi);
911 pnetwork->NetworkTypeInUse = le32_to_cpu(pnetwork->NetworkTypeInUse);
912 pnetwork->Configuration.ATIMWindow = le32_to_cpu(pnetwork->
913 Configuration.ATIMWindow);
914 pnetwork->Configuration.DSConfig = le32_to_cpu(pnetwork->
915 Configuration.DSConfig);
916 pnetwork->Configuration.FHConfig.DwellTime = le32_to_cpu(pnetwork->
917 Configuration.FHConfig.DwellTime);
918 pnetwork->Configuration.FHConfig.HopPattern = le32_to_cpu(pnetwork->
919 Configuration.FHConfig.HopPattern);
920 pnetwork->Configuration.FHConfig.HopSet = le32_to_cpu(pnetwork->
921 Configuration.FHConfig.HopSet);
922 pnetwork->Configuration.FHConfig.Length = le32_to_cpu(pnetwork->
923 Configuration.FHConfig.Length);
924 pnetwork->Configuration.Length = le32_to_cpu(pnetwork->
925 Configuration.Length);
926 pnetwork->InfrastructureMode = le32_to_cpu(pnetwork->
927 InfrastructureMode);
928 pnetwork->IELength = le32_to_cpu(pnetwork->IELength);
929 #endif
930 spin_lock_irqsave(&pmlmepriv->lock, irqL);
931 if ((pmlmepriv->fw_state) & WIFI_AP_STATE) {
932 psta = r8712_get_stainfo(&padapter->stapriv,
933 pnetwork->MacAddress);
934 if (!psta) {
935 psta = r8712_alloc_stainfo(&padapter->stapriv,
936 pnetwork->MacAddress);
937 if (psta == NULL)
938 goto createbss_cmd_fail;
939 }
940 r8712_indicate_connect(padapter);
941 } else {
942 pwlan = _r8712_alloc_network(pmlmepriv);
943 if (pwlan == NULL) {
944 pwlan = r8712_get_oldest_wlan_network(
945 &pmlmepriv->scanned_queue);
946 if (pwlan == NULL)
947 goto createbss_cmd_fail;
948 pwlan->last_scanned = jiffies;
949 } else
950 list_add_tail(&(pwlan->list),
951 &pmlmepriv->scanned_queue.queue);
952 pnetwork->Length = r8712_get_wlan_bssid_ex_sz(pnetwork);
953 memcpy(&(pwlan->network), pnetwork, pnetwork->Length);
954 pwlan->fixed = true;
955 memcpy(&tgt_network->network, pnetwork,
956 (r8712_get_wlan_bssid_ex_sz(pnetwork)));
957 if (pmlmepriv->fw_state & _FW_UNDER_LINKING)
958 pmlmepriv->fw_state ^= _FW_UNDER_LINKING;
959 /* we will set _FW_LINKED when there is one more sat to
960 * join us (stassoc_event_callback) */
961 }
962 createbss_cmd_fail:
963 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
964 r8712_free_cmd_obj(pcmd);
965 }
966
r8712_setstaKey_cmdrsp_callback(struct _adapter * padapter,struct cmd_obj * pcmd)967 void r8712_setstaKey_cmdrsp_callback(struct _adapter *padapter,
968 struct cmd_obj *pcmd)
969 {
970 struct sta_priv *pstapriv = &padapter->stapriv;
971 struct set_stakey_rsp *psetstakey_rsp = (struct set_stakey_rsp *)
972 (pcmd->rsp);
973 struct sta_info *psta = r8712_get_stainfo(pstapriv,
974 psetstakey_rsp->addr);
975
976 if (psta == NULL)
977 goto exit;
978 psta->aid = psta->mac_id = psetstakey_rsp->keyid; /*CAM_ID(CAM_ENTRY)*/
979 exit:
980 r8712_free_cmd_obj(pcmd);
981 }
982
r8712_setassocsta_cmdrsp_callback(struct _adapter * padapter,struct cmd_obj * pcmd)983 void r8712_setassocsta_cmdrsp_callback(struct _adapter *padapter,
984 struct cmd_obj *pcmd)
985 {
986 unsigned long irqL;
987 struct sta_priv *pstapriv = &padapter->stapriv;
988 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
989 struct set_assocsta_parm *passocsta_parm =
990 (struct set_assocsta_parm *)(pcmd->parmbuf);
991 struct set_assocsta_rsp *passocsta_rsp =
992 (struct set_assocsta_rsp *) (pcmd->rsp);
993 struct sta_info *psta = r8712_get_stainfo(pstapriv,
994 passocsta_parm->addr);
995
996 if (psta == NULL)
997 return;
998 psta->aid = psta->mac_id = passocsta_rsp->cam_id;
999 spin_lock_irqsave(&pmlmepriv->lock, irqL);
1000 if ((check_fwstate(pmlmepriv, WIFI_MP_STATE)) &&
1001 (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)))
1002 pmlmepriv->fw_state ^= _FW_UNDER_LINKING;
1003 set_fwstate(pmlmepriv, _FW_LINKED);
1004 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
1005 r8712_free_cmd_obj(pcmd);
1006 }
1007
r8712_disconnectCtrlEx_cmd(struct _adapter * adapter,u32 enableDrvCtrl,u32 tryPktCnt,u32 tryPktInterval,u32 firstStageTO)1008 u8 r8712_disconnectCtrlEx_cmd(struct _adapter *adapter, u32 enableDrvCtrl,
1009 u32 tryPktCnt, u32 tryPktInterval, u32 firstStageTO)
1010 {
1011 struct cmd_obj *ph2c;
1012 struct DisconnectCtrlEx_param *param;
1013 struct cmd_priv *pcmdpriv = &adapter->cmdpriv;
1014
1015 ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
1016 if (ph2c == NULL)
1017 return _FAIL;
1018 param = kzalloc(sizeof(*param), GFP_ATOMIC);
1019 if (param == NULL) {
1020 kfree(ph2c);
1021 return _FAIL;
1022 }
1023
1024 param->EnableDrvCtrl = (unsigned char)enableDrvCtrl;
1025 param->TryPktCnt = (unsigned char)tryPktCnt;
1026 param->TryPktInterval = (unsigned char)tryPktInterval;
1027 param->FirstStageTO = (unsigned int)firstStageTO;
1028
1029 init_h2fwcmd_w_parm_no_rsp(ph2c, param,
1030 GEN_CMD_CODE(_DisconnectCtrlEx));
1031 r8712_enqueue_cmd(pcmdpriv, ph2c);
1032 return _SUCCESS;
1033 }
1034