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