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