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 }