drivers/staging/rtl8712/rtl871x_cmd.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /******************************************************************************
   3  * rtl871x_cmd.c
   4  *
   5  * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
   6  * Linux device driver for RTL8192SU
   7  *
   8  * Modifications for inclusion into the Linux staging tree are
   9  * Copyright(c) 2010 Larry Finger. All rights reserved.
  10  *
  11  * Contact information:
  12  * WLAN FAE <wlanfae@realtek.com>
  13  * Larry Finger <Larry.Finger@lwfinger.net>
  14  *
  15  ******************************************************************************/
  16
  17 #define _RTL871X_CMD_C_
  18
  19 #include <linux/compiler.h>
  20 #include <linux/kernel.h>
  21 #include <linux/errno.h>
  22 #include <linux/slab.h>
  23 #include <linux/module.h>
  24 #include <linux/kref.h>
  25 #include <linux/netdevice.h>
  26 #include <linux/skbuff.h>
  27 #include <linux/usb.h>
  28 #include <linux/usb/ch9.h>
  29 #include <linux/circ_buf.h>
  30 #include <linux/uaccess.h>
  31 #include <asm/byteorder.h>
  32 #include <linux/atomic.h>
  33 #include <linux/semaphore.h>
  34 #include <linux/rtnetlink.h>
  35
  36 #include "osdep_service.h"
  37 #include "drv_types.h"
  38 #include "recv_osdep.h"
  39 #include "mlme_osdep.h"
  40
  41 /*
  42  * Caller and the r8712_cmd_thread can protect cmd_q by spin_lock.
  43  * No irqsave is necessary.
  44  */
  45
  46 int r8712_init_cmd_priv(struct cmd_priv *pcmdpriv)
  47 {
  48         init_completion(&pcmdpriv->cmd_queue_comp);
  49         init_completion(&pcmdpriv->terminate_cmdthread_comp);
  50
  51         _init_queue(&(pcmdpriv->cmd_queue));
  52
  53         /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
  54         pcmdpriv->cmd_seq = 1;
  55         pcmdpriv->cmd_allocated_buf = kmalloc(MAX_CMDSZ + CMDBUFF_ALIGN_SZ,
  56                                               GFP_ATOMIC);
  57         if (!pcmdpriv->cmd_allocated_buf)
  58                 return -ENOMEM;
  59         pcmdpriv->cmd_buf = pcmdpriv->cmd_allocated_buf  +  CMDBUFF_ALIGN_SZ -
  60                             ((addr_t)(pcmdpriv->cmd_allocated_buf) &
  61                             (CMDBUFF_ALIGN_SZ - 1));
  62         pcmdpriv->rsp_allocated_buf = kmalloc(MAX_RSPSZ + 4, GFP_ATOMIC);
  63         if (!pcmdpriv->rsp_allocated_buf) {
  64                 kfree(pcmdpriv->cmd_allocated_buf);
  65                 pcmdpriv->cmd_allocated_buf = NULL;
  66                 return -ENOMEM;
  67         }
  68         pcmdpriv->rsp_buf = pcmdpriv->rsp_allocated_buf  +  4 -
  69                             ((addr_t)(pcmdpriv->rsp_allocated_buf) & 3);
  70         pcmdpriv->cmd_issued_cnt = 0;
  71         pcmdpriv->cmd_done_cnt = 0;
  72         pcmdpriv->rsp_cnt = 0;
  73         return 0;
  74 }
  75
  76 int r8712_init_evt_priv(struct evt_priv *pevtpriv)
  77 {
  78         /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
  79         pevtpriv->event_seq = 0;
  80         pevtpriv->evt_allocated_buf = kmalloc(MAX_EVTSZ + 4, GFP_ATOMIC);
  81
  82         if (!pevtpriv->evt_allocated_buf)
  83                 return -ENOMEM;
  84         pevtpriv->evt_buf = pevtpriv->evt_allocated_buf  +  4 -
  85                             ((addr_t)(pevtpriv->evt_allocated_buf) & 3);
  86         pevtpriv->evt_done_cnt = 0;
  87         return 0;
  88 }
  89
  90 void r8712_free_evt_priv(struct evt_priv *pevtpriv)
  91 {
  92         kfree(pevtpriv->evt_allocated_buf);
  93 }
  94
  95 void r8712_free_cmd_priv(struct cmd_priv *pcmdpriv)
  96 {
  97         if (pcmdpriv) {
  98                 kfree(pcmdpriv->cmd_allocated_buf);
  99                 kfree(pcmdpriv->rsp_allocated_buf);
 100         }
 101 }
 102
 103 /*
 104  * Calling Context:
 105  *
 106  * r8712_enqueue_cmd can only be called between kernel thread,
 107  * since only spin_lock is used.
 108  *
 109  * ISR/Call-Back functions can't call this sub-function.
 110  *
 111  */
 112
 113 void r8712_enqueue_cmd(struct cmd_priv *pcmdpriv, struct cmd_obj *obj)
 114 {
 115         struct __queue *queue;
 116         unsigned long irqL;
 117
 118         if (pcmdpriv->padapter->eeprompriv.bautoload_fail_flag)
 119                 return;
 120         if (!obj)
 121                 return;
 122         queue = &pcmdpriv->cmd_queue;
 123         spin_lock_irqsave(&queue->lock, irqL);
 124         list_add_tail(&obj->list, &queue->queue);
 125         spin_unlock_irqrestore(&queue->lock, irqL);
 126         complete(&pcmdpriv->cmd_queue_comp);
 127 }
 128
 129 struct cmd_obj *r8712_dequeue_cmd(struct  __queue *queue)
 130 {
 131         unsigned long irqL;
 132         struct cmd_obj *obj;
 133
 134         spin_lock_irqsave(&queue->lock, irqL);
 135         obj = list_first_entry_or_null(&queue->queue,
 136                                        struct cmd_obj, list);
 137         if (obj)
 138                 list_del_init(&obj->list);
 139         spin_unlock_irqrestore(&queue->lock, irqL);
 140         return obj;
 141 }
 142
 143 void r8712_enqueue_cmd_ex(struct cmd_priv *pcmdpriv, struct cmd_obj *obj)
 144 {
 145         unsigned long irqL;
 146         struct  __queue *queue;
 147
 148         if (!obj)
 149                 return;
 150         if (pcmdpriv->padapter->eeprompriv.bautoload_fail_flag)
 151                 return;
 152         queue = &pcmdpriv->cmd_queue;
 153         spin_lock_irqsave(&queue->lock, irqL);
 154         list_add_tail(&obj->list, &queue->queue);
 155         spin_unlock_irqrestore(&queue->lock, irqL);
 156         complete(&pcmdpriv->cmd_queue_comp);
 157 }
 158
 159 void r8712_free_cmd_obj(struct cmd_obj *pcmd)
 160 {
 161         if ((pcmd->cmdcode != _JoinBss_CMD_) &&
 162             (pcmd->cmdcode != _CreateBss_CMD_))
 163                 kfree(pcmd->parmbuf);
 164         if (pcmd->rsp) {
 165                 if (pcmd->rspsz != 0)
 166                         kfree(pcmd->rsp);
 167         }
 168         kfree(pcmd);
 169 }
 170
 171 u8 r8712_sitesurvey_cmd(struct _adapter *padapter,
 172                         struct ndis_802_11_ssid *pssid)
 173         __must_hold(&padapter->mlmepriv.lock)
 174 {
 175         struct cmd_obj  *ph2c;
 176         struct sitesurvey_parm  *psurveyPara;
 177         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 178         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 179
 180         ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
 181         if (!ph2c)
 182                 return _FAIL;
 183         psurveyPara = kmalloc(sizeof(*psurveyPara), GFP_ATOMIC);
 184         if (!psurveyPara) {
 185                 kfree(ph2c);
 186                 return _FAIL;
 187         }
 188         init_h2fwcmd_w_parm_no_rsp(ph2c, psurveyPara,
 189                                    GEN_CMD_CODE(_SiteSurvey));
 190         psurveyPara->bsslimit = cpu_to_le32(48);
 191         psurveyPara->passive_mode = cpu_to_le32(pmlmepriv->passive_mode);
 192         psurveyPara->ss_ssidlen = 0;
 193         memset(psurveyPara->ss_ssid, 0, IW_ESSID_MAX_SIZE + 1);
 194         if (pssid && pssid->SsidLength) {
 195                 int len = min_t(int, pssid->SsidLength, IW_ESSID_MAX_SIZE);
 196
 197                 memcpy(psurveyPara->ss_ssid, pssid->Ssid, len);
 198                 psurveyPara->ss_ssidlen = cpu_to_le32(len);
 199         }
 200         set_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
 201         r8712_enqueue_cmd(pcmdpriv, ph2c);
 202         mod_timer(&pmlmepriv->scan_to_timer,
 203                   jiffies + msecs_to_jiffies(SCANNING_TIMEOUT));
 204         padapter->ledpriv.LedControlHandler(padapter, LED_CTL_SITE_SURVEY);
 205         padapter->blnEnableRxFF0Filter = 0;
 206         return _SUCCESS;
 207 }
 208
 209 int r8712_setdatarate_cmd(struct _adapter *padapter, u8 *rateset)
 210 {
 211         struct cmd_obj          *ph2c;
 212         struct setdatarate_parm *pbsetdataratepara;
 213         struct cmd_priv         *pcmdpriv = &padapter->cmdpriv;
 214
 215         ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
 216         if (!ph2c)
 217                 return -ENOMEM;
 218         pbsetdataratepara = kmalloc(sizeof(*pbsetdataratepara), GFP_ATOMIC);
 219         if (!pbsetdataratepara) {
 220                 kfree(ph2c);
 221                 return -ENOMEM;
 222         }
 223         init_h2fwcmd_w_parm_no_rsp(ph2c, pbsetdataratepara,
 224                                    GEN_CMD_CODE(_SetDataRate));
 225         pbsetdataratepara->mac_id = 5;
 226         memcpy(pbsetdataratepara->datarates, rateset, NumRates);
 227         r8712_enqueue_cmd(pcmdpriv, ph2c);
 228         return 0;
 229 }
 230
 231 void r8712_set_chplan_cmd(struct _adapter *padapter, int chplan)
 232 {
 233         struct cmd_obj *ph2c;
 234         struct SetChannelPlan_param *psetchplanpara;
 235         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 236
 237         ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
 238         if (!ph2c)
 239                 return;
 240         psetchplanpara = kmalloc(sizeof(*psetchplanpara), GFP_ATOMIC);
 241         if (!psetchplanpara) {
 242                 kfree(ph2c);
 243                 return;
 244         }
 245         init_h2fwcmd_w_parm_no_rsp(ph2c, psetchplanpara,
 246                                 GEN_CMD_CODE(_SetChannelPlan));
 247         psetchplanpara->ChannelPlan = chplan;
 248         r8712_enqueue_cmd(pcmdpriv, ph2c);
 249 }
 250
 251 int r8712_setrfreg_cmd(struct _adapter  *padapter, u8 offset, u32 val)
 252 {
 253         struct cmd_obj *ph2c;
 254         struct writeRF_parm *pwriterfparm;
 255         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 256
 257         ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
 258         if (!ph2c)
 259                 return -ENOMEM;
 260         pwriterfparm = kmalloc(sizeof(*pwriterfparm), GFP_ATOMIC);
 261         if (!pwriterfparm) {
 262                 kfree(ph2c);
 263                 return -ENOMEM;
 264         }
 265         init_h2fwcmd_w_parm_no_rsp(ph2c, pwriterfparm, GEN_CMD_CODE(_SetRFReg));
 266         pwriterfparm->offset = offset;
 267         pwriterfparm->value = val;
 268         r8712_enqueue_cmd(pcmdpriv, ph2c);
 269         return 0;
 270 }
 271
 272 int r8712_getrfreg_cmd(struct _adapter *padapter, u8 offset, u8 *pval)
 273 {
 274         struct cmd_obj *ph2c;
 275         struct readRF_parm *prdrfparm;
 276         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 277
 278         ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
 279         if (!ph2c)
 280                 return -ENOMEM;
 281         prdrfparm = kmalloc(sizeof(*prdrfparm), GFP_ATOMIC);
 282         if (!prdrfparm) {
 283                 kfree(ph2c);
 284                 return -ENOMEM;
 285         }
 286         INIT_LIST_HEAD(&ph2c->list);
 287         ph2c->cmdcode = GEN_CMD_CODE(_GetRFReg);
 288         ph2c->parmbuf = (unsigned char *)prdrfparm;
 289         ph2c->cmdsz =  sizeof(struct readRF_parm);
 290         ph2c->rsp = pval;
 291         ph2c->rspsz = sizeof(struct readRF_rsp);
 292         prdrfparm->offset = offset;
 293         r8712_enqueue_cmd(pcmdpriv, ph2c);
 294         return 0;
 295 }
 296
 297 void r8712_getbbrfreg_cmdrsp_callback(struct _adapter *padapter,
 298                                       struct cmd_obj *pcmd)
 299 {
 300         kfree(pcmd->parmbuf);
 301         kfree(pcmd);
 302         padapter->mppriv.workparam.bcompleted = true;
 303 }
 304
 305 void r8712_readtssi_cmdrsp_callback(struct _adapter *padapter,
 306                                 struct cmd_obj *pcmd)
 307 {
 308         kfree(pcmd->parmbuf);
 309         kfree(pcmd);
 310
 311         padapter->mppriv.workparam.bcompleted = true;
 312 }
 313
 314 int r8712_createbss_cmd(struct _adapter *padapter)
 315 {
 316         struct cmd_obj *pcmd;
 317         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 318         struct wlan_bssid_ex *pdev_network =
 319                                  &padapter->registrypriv.dev_network;
 320
 321         padapter->ledpriv.LedControlHandler(padapter, LED_CTL_START_TO_LINK);
 322         pcmd = kmalloc(sizeof(*pcmd), GFP_ATOMIC);
 323         if (!pcmd)
 324                 return -ENOMEM;
 325         INIT_LIST_HEAD(&pcmd->list);
 326         pcmd->cmdcode = _CreateBss_CMD_;
 327         pcmd->parmbuf = (unsigned char *)pdev_network;
 328         pcmd->cmdsz = r8712_get_wlan_bssid_ex_sz(pdev_network);
 329         pcmd->rsp = NULL;
 330         pcmd->rspsz = 0;
 331         /* notes: translate IELength & Length after assign to cmdsz; */
 332         pdev_network->Length = pcmd->cmdsz;
 333         pdev_network->IELength = pdev_network->IELength;
 334         pdev_network->Ssid.SsidLength = pdev_network->Ssid.SsidLength;
 335         r8712_enqueue_cmd(pcmdpriv, pcmd);
 336         return 0;
 337 }
 338
 339 int r8712_joinbss_cmd(struct _adapter  *padapter, struct wlan_network *pnetwork)
 340 {
 341         struct wlan_bssid_ex *psecnetwork;
 342         struct cmd_obj          *pcmd;
 343         struct cmd_priv         *pcmdpriv = &padapter->cmdpriv;
 344         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
 345         struct qos_priv         *pqospriv = &pmlmepriv->qospriv;
 346         struct security_priv    *psecuritypriv = &padapter->securitypriv;
 347         struct registry_priv    *pregistrypriv = &padapter->registrypriv;
 348         enum NDIS_802_11_NETWORK_INFRASTRUCTURE ndis_network_mode =
 349                 pnetwork->network.InfrastructureMode;
 350
 351         padapter->ledpriv.LedControlHandler(padapter, LED_CTL_START_TO_LINK);
 352         pcmd = kmalloc(sizeof(*pcmd), GFP_ATOMIC);
 353         if (!pcmd)
 354                 return -ENOMEM;
 355
 356         /* for hidden ap to set fw_state here */
 357         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE | WIFI_ADHOC_STATE) !=
 358             true) {
 359                 switch (ndis_network_mode) {
 360                 case Ndis802_11IBSS:
 361                         pmlmepriv->fw_state |= WIFI_ADHOC_STATE;
 362                         break;
 363                 case Ndis802_11Infrastructure:
 364                         pmlmepriv->fw_state |= WIFI_STATION_STATE;
 365                         break;
 366                 case Ndis802_11APMode:
 367                 case Ndis802_11AutoUnknown:
 368                 case Ndis802_11InfrastructureMax:
 369                         break;
 370                 }
 371         }
 372         psecnetwork = &psecuritypriv->sec_bss;
 373         memcpy(psecnetwork, &pnetwork->network, sizeof(*psecnetwork));
 374         psecuritypriv->authenticator_ie[0] = (unsigned char)
 375                                              psecnetwork->IELength;
 376         if ((psecnetwork->IELength - 12) < (256 - 1))
 377                 memcpy(&psecuritypriv->authenticator_ie[1],
 378                         &psecnetwork->IEs[12], psecnetwork->IELength - 12);
 379         else
 380                 memcpy(&psecuritypriv->authenticator_ie[1],
 381                         &psecnetwork->IEs[12], (256 - 1));
 382         psecnetwork->IELength = 0;
 383         /*
 384          * If the driver wants to use the bssid to create the connection.
 385          * If not, we copy the connecting AP's MAC address to it so that
 386          * the driver just has the bssid information for PMKIDList searching.
 387          */
 388         if (!pmlmepriv->assoc_by_bssid)
 389                 ether_addr_copy(&pmlmepriv->assoc_bssid[0],
 390                                 &pnetwork->network.MacAddress[0]);
 391         psecnetwork->IELength = r8712_restruct_sec_ie(padapter,
 392                                                 &pnetwork->network.IEs[0],
 393                                                 &psecnetwork->IEs[0],
 394                                                 pnetwork->network.IELength);
 395         pqospriv->qos_option = 0;
 396         if (pregistrypriv->wmm_enable) {
 397                 u32 tmp_len;
 398
 399                 tmp_len = r8712_restruct_wmm_ie(padapter,
 400                                           &pnetwork->network.IEs[0],
 401                                           &psecnetwork->IEs[0],
 402                                           pnetwork->network.IELength,
 403                                           psecnetwork->IELength);
 404                 if (psecnetwork->IELength != tmp_len) {
 405                         psecnetwork->IELength = tmp_len;
 406                         pqospriv->qos_option = 1; /* WMM IE in beacon */
 407                 } else {
 408                         pqospriv->qos_option = 0; /* no WMM IE in beacon */
 409                 }
 410         }
 411         if (pregistrypriv->ht_enable) {
 412                 /*
 413                  * For WEP mode, we will use the bg mode to do the connection
 414                  * to avoid some IOT issues, especially for Realtek 8192u
 415                  * SoftAP.
 416                  */
 417                 if ((padapter->securitypriv.PrivacyAlgrthm != _WEP40_) &&
 418                     (padapter->securitypriv.PrivacyAlgrthm != _WEP104_)) {
 419                         /* restructure_ht_ie */
 420                         r8712_restructure_ht_ie(padapter,
 421                                                 &pnetwork->network.IEs[0],
 422                                                 &psecnetwork->IEs[0],
 423                                                 pnetwork->network.IELength,
 424                                                 &psecnetwork->IELength);
 425                 }
 426         }
 427         psecuritypriv->supplicant_ie[0] = (u8)psecnetwork->IELength;
 428         if (psecnetwork->IELength < 255)
 429                 memcpy(&psecuritypriv->supplicant_ie[1], &psecnetwork->IEs[0],
 430                         psecnetwork->IELength);
 431         else
 432                 memcpy(&psecuritypriv->supplicant_ie[1], &psecnetwork->IEs[0],
 433                         255);
 434         /* get cmdsz before endian conversion */
 435         pcmd->cmdsz = r8712_get_wlan_bssid_ex_sz(psecnetwork);
 436 #ifdef __BIG_ENDIAN
 437         /* wlan_network endian conversion */
 438         psecnetwork->Length = cpu_to_le32(psecnetwork->Length);
 439         psecnetwork->Ssid.SsidLength = cpu_to_le32(
 440                                        psecnetwork->Ssid.SsidLength);
 441         psecnetwork->Privacy = cpu_to_le32(psecnetwork->Privacy);
 442         psecnetwork->Rssi = cpu_to_le32(psecnetwork->Rssi);
 443         psecnetwork->NetworkTypeInUse = cpu_to_le32(
 444                                         psecnetwork->NetworkTypeInUse);
 445         psecnetwork->Configuration.ATIMWindow = cpu_to_le32(
 446                                 psecnetwork->Configuration.ATIMWindow);
 447         psecnetwork->Configuration.BeaconPeriod = cpu_to_le32(
 448                                  psecnetwork->Configuration.BeaconPeriod);
 449         psecnetwork->Configuration.DSConfig = cpu_to_le32(
 450                                 psecnetwork->Configuration.DSConfig);
 451         psecnetwork->Configuration.FHConfig.DwellTime = cpu_to_le32(
 452                                 psecnetwork->Configuration.FHConfig.DwellTime);
 453         psecnetwork->Configuration.FHConfig.HopPattern = cpu_to_le32(
 454                                 psecnetwork->Configuration.FHConfig.HopPattern);
 455         psecnetwork->Configuration.FHConfig.HopSet = cpu_to_le32(
 456                                 psecnetwork->Configuration.FHConfig.HopSet);
 457         psecnetwork->Configuration.FHConfig.Length = cpu_to_le32(
 458                                 psecnetwork->Configuration.FHConfig.Length);
 459         psecnetwork->Configuration.Length = cpu_to_le32(
 460                                 psecnetwork->Configuration.Length);
 461         psecnetwork->InfrastructureMode = cpu_to_le32(
 462                                 psecnetwork->InfrastructureMode);
 463         psecnetwork->IELength = cpu_to_le32(psecnetwork->IELength);
 464 #endif
 465         INIT_LIST_HEAD(&pcmd->list);
 466         pcmd->cmdcode = _JoinBss_CMD_;
 467         pcmd->parmbuf = (unsigned char *)psecnetwork;
 468         pcmd->rsp = NULL;
 469         pcmd->rspsz = 0;
 470         r8712_enqueue_cmd(pcmdpriv, pcmd);
 471         return 0;
 472 }
 473
 474 void r8712_disassoc_cmd(struct _adapter *padapter) /* for sta_mode */
 475 {
 476         struct cmd_obj *pdisconnect_cmd;
 477         struct disconnect_parm *pdisconnect;
 478         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 479
 480         pdisconnect_cmd = kmalloc(sizeof(*pdisconnect_cmd), GFP_ATOMIC);
 481         if (!pdisconnect_cmd)
 482                 return;
 483         pdisconnect = kmalloc(sizeof(*pdisconnect), GFP_ATOMIC);
 484         if (!pdisconnect) {
 485                 kfree(pdisconnect_cmd);
 486                 return;
 487         }
 488         init_h2fwcmd_w_parm_no_rsp(pdisconnect_cmd, pdisconnect,
 489                                    _DisConnect_CMD_);
 490         r8712_enqueue_cmd(pcmdpriv, pdisconnect_cmd);
 491 }
 492
 493 void r8712_setopmode_cmd(struct _adapter *padapter,
 494                  enum NDIS_802_11_NETWORK_INFRASTRUCTURE networktype)
 495 {
 496         struct cmd_obj *ph2c;
 497         struct setopmode_parm *psetop;
 498
 499         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 500
 501         ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
 502         if (!ph2c)
 503                 return;
 504         psetop = kmalloc(sizeof(*psetop), GFP_ATOMIC);
 505         if (!psetop) {
 506                 kfree(ph2c);
 507                 return;
 508         }
 509         init_h2fwcmd_w_parm_no_rsp(ph2c, psetop, _SetOpMode_CMD_);
 510         psetop->mode = (u8)networktype;
 511         r8712_enqueue_cmd(pcmdpriv, ph2c);
 512 }
 513
 514 void r8712_setstakey_cmd(struct _adapter *padapter, u8 *psta, u8 unicast_key)
 515 {
 516         struct cmd_obj *ph2c;
 517         struct set_stakey_parm *psetstakey_para;
 518         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 519         struct set_stakey_rsp *psetstakey_rsp = NULL;
 520         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 521         struct security_priv *psecuritypriv = &padapter->securitypriv;
 522         struct sta_info *sta = (struct sta_info *)psta;
 523
 524         ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
 525         if (!ph2c)
 526                 return;
 527         psetstakey_para = kmalloc(sizeof(*psetstakey_para), GFP_ATOMIC);
 528         if (!psetstakey_para) {
 529                 kfree(ph2c);
 530                 return;
 531         }
 532         psetstakey_rsp = kmalloc(sizeof(*psetstakey_rsp), GFP_ATOMIC);
 533         if (!psetstakey_rsp) {
 534                 kfree(ph2c);
 535                 kfree(psetstakey_para);
 536                 return;
 537         }
 538         init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_);
 539         ph2c->rsp = (u8 *) psetstakey_rsp;
 540         ph2c->rspsz = sizeof(struct set_stakey_rsp);
 541         ether_addr_copy(psetstakey_para->addr, sta->hwaddr);
 542         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
 543                 psetstakey_para->algorithm = (unsigned char)
 544                                             psecuritypriv->PrivacyAlgrthm;
 545         else
 546                 GET_ENCRY_ALGO(psecuritypriv, sta,
 547                                psetstakey_para->algorithm, false);
 548         if (unicast_key)
 549                 memcpy(&psetstakey_para->key, &sta->x_UncstKey, 16);
 550         else
 551                 memcpy(&psetstakey_para->key,
 552                         &psecuritypriv->XGrpKey[
 553                         psecuritypriv->XGrpKeyid - 1]. skey, 16);
 554         r8712_enqueue_cmd(pcmdpriv, ph2c);
 555 }
 556
 557 void r8712_setMacAddr_cmd(struct _adapter *padapter, u8 *mac_addr)
 558 {
 559         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 560         struct cmd_obj *ph2c;
 561         struct SetMacAddr_param *psetMacAddr_para;
 562
 563         ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
 564         if (!ph2c)
 565                 return;
 566         psetMacAddr_para = kmalloc(sizeof(*psetMacAddr_para), GFP_ATOMIC);
 567         if (!psetMacAddr_para) {
 568                 kfree(ph2c);
 569                 return;
 570         }
 571         init_h2fwcmd_w_parm_no_rsp(ph2c, psetMacAddr_para,
 572                                    _SetMacAddress_CMD_);
 573         ether_addr_copy(psetMacAddr_para->MacAddr, mac_addr);
 574         r8712_enqueue_cmd(pcmdpriv, ph2c);
 575 }
 576
 577 void r8712_addbareq_cmd(struct _adapter *padapter, u8 tid)
 578 {
 579         struct cmd_priv         *pcmdpriv = &padapter->cmdpriv;
 580         struct cmd_obj          *ph2c;
 581         struct addBaReq_parm    *paddbareq_parm;
 582
 583         ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
 584         if (!ph2c)
 585                 return;
 586         paddbareq_parm = kmalloc(sizeof(*paddbareq_parm), GFP_ATOMIC);
 587         if (!paddbareq_parm) {
 588                 kfree(ph2c);
 589                 return;
 590         }
 591         paddbareq_parm->tid = tid;
 592         init_h2fwcmd_w_parm_no_rsp(ph2c, paddbareq_parm,
 593                                    GEN_CMD_CODE(_AddBAReq));
 594         r8712_enqueue_cmd_ex(pcmdpriv, ph2c);
 595 }
 596
 597 void r8712_wdg_wk_cmd(struct _adapter *padapter)
 598 {
 599         struct cmd_obj *ph2c;
 600         struct drvint_cmd_parm  *pdrvintcmd_param;
 601         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 602
 603         ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
 604         if (!ph2c)
 605                 return;
 606         pdrvintcmd_param = kmalloc(sizeof(*pdrvintcmd_param), GFP_ATOMIC);
 607         if (!pdrvintcmd_param) {
 608                 kfree(ph2c);
 609                 return;
 610         }
 611         pdrvintcmd_param->i_cid = WDG_WK_CID;
 612         pdrvintcmd_param->sz = 0;
 613         pdrvintcmd_param->pbuf = NULL;
 614         init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvintcmd_param, _DRV_INT_CMD_);
 615         r8712_enqueue_cmd_ex(pcmdpriv, ph2c);
 616 }
 617
 618 void r8712_survey_cmd_callback(struct _adapter *padapter, struct cmd_obj *pcmd)
 619 {
 620         struct  mlme_priv *pmlmepriv = &padapter->mlmepriv;
 621
 622         if (pcmd->res != H2C_SUCCESS)
 623                 clr_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
 624         r8712_free_cmd_obj(pcmd);
 625 }
 626
 627 void r8712_disassoc_cmd_callback(struct _adapter *padapter,
 628                                  struct cmd_obj *pcmd)
 629 {
 630         unsigned long irqL;
 631         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 632
 633         if (pcmd->res != H2C_SUCCESS) {
 634                 spin_lock_irqsave(&pmlmepriv->lock, irqL);
 635                 set_fwstate(pmlmepriv, _FW_LINKED);
 636                 spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
 637                 return;
 638         }
 639         r8712_free_cmd_obj(pcmd);
 640 }
 641
 642 void r8712_joinbss_cmd_callback(struct _adapter *padapter, struct cmd_obj *pcmd)
 643 {
 644         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 645
 646         if (pcmd->res != H2C_SUCCESS)
 647                 mod_timer(&pmlmepriv->assoc_timer,
 648                           jiffies + msecs_to_jiffies(1));
 649         r8712_free_cmd_obj(pcmd);
 650 }
 651
 652 void r8712_createbss_cmd_callback(struct _adapter *padapter,
 653                                   struct cmd_obj *pcmd)
 654 {
 655         unsigned long irqL;
 656         struct sta_info *psta = NULL;
 657         struct wlan_network *pwlan = NULL;
 658         struct  mlme_priv *pmlmepriv = &padapter->mlmepriv;
 659         struct wlan_bssid_ex *pnetwork = (struct wlan_bssid_ex *)pcmd->parmbuf;
 660         struct wlan_network *tgt_network = &(pmlmepriv->cur_network);
 661
 662         if (pcmd->res != H2C_SUCCESS)
 663                 mod_timer(&pmlmepriv->assoc_timer,
 664                           jiffies + msecs_to_jiffies(1));
 665         del_timer(&pmlmepriv->assoc_timer);
 666 #ifdef __BIG_ENDIAN
 667         /* endian_convert */
 668         pnetwork->Length = le32_to_cpu(pnetwork->Length);
 669         pnetwork->Ssid.SsidLength = le32_to_cpu(pnetwork->Ssid.SsidLength);
 670         pnetwork->Privacy = le32_to_cpu(pnetwork->Privacy);
 671         pnetwork->Rssi = le32_to_cpu(pnetwork->Rssi);
 672         pnetwork->NetworkTypeInUse = le32_to_cpu(pnetwork->NetworkTypeInUse);
 673         pnetwork->Configuration.ATIMWindow =
 674                 le32_to_cpu(pnetwork->Configuration.ATIMWindow);
 675         pnetwork->Configuration.DSConfig =
 676                 le32_to_cpu(pnetwork->Configuration.DSConfig);
 677         pnetwork->Configuration.FHConfig.DwellTime =
 678                 le32_to_cpu(pnetwork->Configuration.FHConfig.DwellTime);
 679         pnetwork->Configuration.FHConfig.HopPattern =
 680                 le32_to_cpu(pnetwork->Configuration.FHConfig.HopPattern);
 681         pnetwork->Configuration.FHConfig.HopSet =
 682                 le32_to_cpu(pnetwork->Configuration.FHConfig.HopSet);
 683         pnetwork->Configuration.FHConfig.Length =
 684                 le32_to_cpu(pnetwork->Configuration.FHConfig.Length);
 685         pnetwork->Configuration.Length =
 686                 le32_to_cpu(pnetwork->Configuration.Length);
 687         pnetwork->InfrastructureMode =
 688                 le32_to_cpu(pnetwork->InfrastructureMode);
 689         pnetwork->IELength = le32_to_cpu(pnetwork->IELength);
 690 #endif
 691         spin_lock_irqsave(&pmlmepriv->lock, irqL);
 692         if ((pmlmepriv->fw_state) & WIFI_AP_STATE) {
 693                 psta = r8712_get_stainfo(&padapter->stapriv,
 694                                          pnetwork->MacAddress);
 695                 if (!psta) {
 696                         psta = r8712_alloc_stainfo(&padapter->stapriv,
 697                                                    pnetwork->MacAddress);
 698                         if (!psta)
 699                                 goto createbss_cmd_fail;
 700                 }
 701                 r8712_indicate_connect(padapter);
 702         } else {
 703                 pwlan = _r8712_alloc_network(pmlmepriv);
 704                 if (!pwlan) {
 705                         pwlan = r8712_get_oldest_wlan_network(
 706                                 &pmlmepriv->scanned_queue);
 707                         if (!pwlan)
 708                                 goto createbss_cmd_fail;
 709                         pwlan->last_scanned = jiffies;
 710                 } else {
 711                         list_add_tail(&(pwlan->list),
 712                                          &pmlmepriv->scanned_queue.queue);
 713                 }
 714                 pnetwork->Length = r8712_get_wlan_bssid_ex_sz(pnetwork);
 715                 memcpy(&(pwlan->network), pnetwork, pnetwork->Length);
 716                 pwlan->fixed = true;
 717                 memcpy(&tgt_network->network, pnetwork,
 718                         (r8712_get_wlan_bssid_ex_sz(pnetwork)));
 719                 if (pmlmepriv->fw_state & _FW_UNDER_LINKING)
 720                         pmlmepriv->fw_state ^= _FW_UNDER_LINKING;
 721                 /*
 722                  * we will set _FW_LINKED when there is one more sat to
 723                  * join us (stassoc_event_callback)
 724                  */
 725         }
 726 createbss_cmd_fail:
 727         spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
 728         r8712_free_cmd_obj(pcmd);
 729 }
 730
 731 void r8712_setstaKey_cmdrsp_callback(struct _adapter *padapter,
 732                                      struct cmd_obj *pcmd)
 733 {
 734         struct sta_priv *pstapriv = &padapter->stapriv;
 735         struct set_stakey_rsp *psetstakey_rsp = (struct set_stakey_rsp *)
 736                                                 (pcmd->rsp);
 737         struct sta_info *psta = r8712_get_stainfo(pstapriv,
 738                                                   psetstakey_rsp->addr);
 739
 740         if (!psta)
 741                 goto exit;
 742         psta->aid = psta->mac_id = psetstakey_rsp->keyid; /*CAM_ID(CAM_ENTRY)*/
 743 exit:
 744         r8712_free_cmd_obj(pcmd);
 745 }
 746
 747 void r8712_setassocsta_cmdrsp_callback(struct _adapter *padapter,
 748                                        struct cmd_obj *pcmd)
 749 {
 750         unsigned long   irqL;
 751         struct sta_priv *pstapriv = &padapter->stapriv;
 752         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 753         struct set_assocsta_parm *passocsta_parm =
 754                                 (struct set_assocsta_parm *)(pcmd->parmbuf);
 755         struct set_assocsta_rsp *passocsta_rsp =
 756                                 (struct set_assocsta_rsp *) (pcmd->rsp);
 757         struct sta_info *psta = r8712_get_stainfo(pstapriv,
 758                                                   passocsta_parm->addr);
 759
 760         if (!psta)
 761                 return;
 762         psta->aid = psta->mac_id = passocsta_rsp->cam_id;
 763         spin_lock_irqsave(&pmlmepriv->lock, irqL);
 764         if ((check_fwstate(pmlmepriv, WIFI_MP_STATE)) &&
 765             (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)))
 766                 pmlmepriv->fw_state ^= _FW_UNDER_LINKING;
 767         set_fwstate(pmlmepriv, _FW_LINKED);
 768         spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
 769         r8712_free_cmd_obj(pcmd);
 770 }
 771
 772 void r8712_disconnectCtrlEx_cmd(struct _adapter *adapter, u32 enableDrvCtrl,
 773                         u32 tryPktCnt, u32 tryPktInterval, u32 firstStageTO)
 774 {
 775         struct cmd_obj *ph2c;
 776         struct DisconnectCtrlEx_param *param;
 777         struct cmd_priv *pcmdpriv = &adapter->cmdpriv;
 778
 779         ph2c = kmalloc(sizeof(*ph2c), GFP_ATOMIC);
 780         if (!ph2c)
 781                 return;
 782         param = kzalloc(sizeof(*param), GFP_ATOMIC);
 783         if (!param) {
 784                 kfree(ph2c);
 785                 return;
 786         }
 787
 788         param->EnableDrvCtrl = (unsigned char)enableDrvCtrl;
 789         param->TryPktCnt = (unsigned char)tryPktCnt;
 790         param->TryPktInterval = (unsigned char)tryPktInterval;
 791         param->FirstStageTO = (unsigned int)firstStageTO;
 792
 793         init_h2fwcmd_w_parm_no_rsp(ph2c, param,
 794                                 GEN_CMD_CODE(_DisconnectCtrlEx));
 795         r8712_enqueue_cmd(pcmdpriv, ph2c);
 796 }