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