drivers/staging/rtl8188eu/core/rtw_cmd.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17  *
  18  *
  19  ******************************************************************************/
  20 #define _RTW_CMD_C_
  21
  22 #include <osdep_service.h>
  23 #include <drv_types.h>
  24 #include <recv_osdep.h>
  25 #include <cmd_osdep.h>
  26 #include <mlme_osdep.h>
  27 #include <rtw_br_ext.h>
  28 #include <rtw_mlme_ext.h>
  29
  30 /*
  31 Caller and the rtw_cmd_thread can protect cmd_q by spin_lock.
  32 No irqsave is necessary.
  33 */
  34
  35 int _rtw_init_cmd_priv(struct cmd_priv *pcmdpriv)
  36 {
  37         int res = _SUCCESS;
  38
  39
  40         sema_init(&(pcmdpriv->cmd_queue_sema), 0);
  41         /* sema_init(&(pcmdpriv->cmd_done_sema), 0); */
  42         sema_init(&(pcmdpriv->terminate_cmdthread_sema), 0);
  43
  44
  45         _rtw_init_queue(&(pcmdpriv->cmd_queue));
  46
  47         /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
  48
  49         pcmdpriv->cmd_seq = 1;
  50
  51         pcmdpriv->cmd_allocated_buf = rtw_zmalloc(MAX_CMDSZ + CMDBUFF_ALIGN_SZ);
  52
  53         if (pcmdpriv->cmd_allocated_buf == NULL) {
  54                 res = _FAIL;
  55                 goto exit;
  56         }
  57
  58         pcmdpriv->cmd_buf = pcmdpriv->cmd_allocated_buf  +  CMDBUFF_ALIGN_SZ - ((size_t)(pcmdpriv->cmd_allocated_buf) & (CMDBUFF_ALIGN_SZ-1));
  59
  60         pcmdpriv->rsp_allocated_buf = rtw_zmalloc(MAX_RSPSZ + 4);
  61
  62         if (pcmdpriv->rsp_allocated_buf == NULL) {
  63                 res = _FAIL;
  64                 goto exit;
  65         }
  66
  67         pcmdpriv->rsp_buf = pcmdpriv->rsp_allocated_buf  +  4 - ((size_t)(pcmdpriv->rsp_allocated_buf) & 3);
  68
  69         pcmdpriv->cmd_issued_cnt = 0;
  70         pcmdpriv->cmd_done_cnt = 0;
  71         pcmdpriv->rsp_cnt = 0;
  72 exit:
  73         return res;
  74 }
  75
  76 static void c2h_wk_callback(struct work_struct *work);
  77
  78 int _rtw_init_evt_priv(struct evt_priv *pevtpriv)
  79 {
  80         int res = _SUCCESS;
  81
  82
  83         /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
  84         atomic_set(&pevtpriv->event_seq, 0);
  85         pevtpriv->evt_done_cnt = 0;
  86
  87         INIT_WORK(&pevtpriv->c2h_wk, c2h_wk_callback);
  88         pevtpriv->c2h_wk_alive = false;
  89         pevtpriv->c2h_queue = rtw_cbuf_alloc(C2H_QUEUE_MAX_LEN+1);
  90
  91
  92         return res;
  93 }
  94
  95 void rtw_free_evt_priv(struct evt_priv *pevtpriv)
  96 {
  97
  98         RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("+rtw_free_evt_priv\n"));
  99
 100         _cancel_workitem_sync(&pevtpriv->c2h_wk);
 101         while (pevtpriv->c2h_wk_alive)
 102                 msleep(10);
 103
 104         while (!rtw_cbuf_empty(pevtpriv->c2h_queue)) {
 105                 void *c2h = rtw_cbuf_pop(pevtpriv->c2h_queue);
 106                 if (c2h != NULL && c2h != (void *)pevtpriv)
 107                         kfree(c2h);
 108         }
 109         RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("-rtw_free_evt_priv\n"));
 110
 111 }
 112
 113 void _rtw_free_cmd_priv(struct cmd_priv *pcmdpriv)
 114 {
 115
 116         if (pcmdpriv) {
 117                 kfree(pcmdpriv->cmd_allocated_buf);
 118                 kfree(pcmdpriv->rsp_allocated_buf);
 119         }
 120 }
 121
 122 /*
 123 Calling Context:
 124
 125 rtw_enqueue_cmd can only be called between kernel thread,
 126 since only spin_lock is used.
 127
 128 ISR/Call-Back functions can't call this sub-function.
 129
 130 */
 131
 132 int _rtw_enqueue_cmd(struct __queue *queue, struct cmd_obj *obj)
 133 {
 134         unsigned long irqL;
 135
 136
 137         if (obj == NULL)
 138                 goto exit;
 139
 140         spin_lock_irqsave(&queue->lock, irqL);
 141
 142         rtw_list_insert_tail(&obj->list, &queue->queue);
 143
 144         spin_unlock_irqrestore(&queue->lock, irqL);
 145
 146 exit:
 147
 148
 149         return _SUCCESS;
 150 }
 151
 152 struct  cmd_obj *_rtw_dequeue_cmd(struct __queue *queue)
 153 {
 154         unsigned long irqL;
 155         struct cmd_obj *obj;
 156
 157
 158         spin_lock_irqsave(&queue->lock, irqL);
 159         if (rtw_is_list_empty(&(queue->queue))) {
 160                 obj = NULL;
 161         } else {
 162                 obj = container_of((&queue->queue)->next, struct cmd_obj, list);
 163                 rtw_list_delete(&obj->list);
 164         }
 165
 166         spin_unlock_irqrestore(&queue->lock, irqL);
 167
 168
 169         return obj;
 170 }
 171
 172 u32 rtw_init_cmd_priv(struct cmd_priv *pcmdpriv)
 173 {
 174         u32     res;
 175         res = _rtw_init_cmd_priv(pcmdpriv);
 176         return res;
 177 }
 178
 179 u32 rtw_init_evt_priv(struct evt_priv *pevtpriv)
 180 {
 181         int res;
 182         res = _rtw_init_evt_priv(pevtpriv);
 183         return res;
 184 }
 185
 186 void rtw_free_cmd_priv(struct cmd_priv *pcmdpriv)
 187 {
 188         RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("rtw_free_cmd_priv\n"));
 189         _rtw_free_cmd_priv(pcmdpriv);
 190 }
 191
 192 static int rtw_cmd_filter(struct cmd_priv *pcmdpriv, struct cmd_obj *cmd_obj)
 193 {
 194         u8 bAllow = false; /* set to true to allow enqueuing cmd when hw_init_completed is false */
 195
 196         /* To decide allow or not */
 197         if ((pcmdpriv->padapter->pwrctrlpriv.bHWPwrPindetect) &&
 198             (!pcmdpriv->padapter->registrypriv.usbss_enable)) {
 199                 if (cmd_obj->cmdcode == GEN_CMD_CODE(_Set_Drv_Extra)) {
 200                         struct drvextra_cmd_parm        *pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)cmd_obj->parmbuf;
 201                         if (pdrvextra_cmd_parm->ec_id == POWER_SAVING_CTRL_WK_CID)
 202                                 bAllow = true;
 203                 }
 204         }
 205
 206         if (cmd_obj->cmdcode == GEN_CMD_CODE(_SetChannelPlan))
 207                 bAllow = true;
 208
 209         if ((!pcmdpriv->padapter->hw_init_completed && !bAllow) ||
 210             !pcmdpriv->cmdthd_running)  /* com_thread not running */
 211                 return _FAIL;
 212         return _SUCCESS;
 213 }
 214
 215 u32 rtw_enqueue_cmd(struct cmd_priv *pcmdpriv, struct cmd_obj *cmd_obj)
 216 {
 217         int res = _FAIL;
 218         struct adapter *padapter = pcmdpriv->padapter;
 219
 220
 221         if (cmd_obj == NULL)
 222                 goto exit;
 223
 224         cmd_obj->padapter = padapter;
 225
 226         res = rtw_cmd_filter(pcmdpriv, cmd_obj);
 227         if (_FAIL == res) {
 228                 rtw_free_cmd_obj(cmd_obj);
 229                 goto exit;
 230         }
 231
 232         res = _rtw_enqueue_cmd(&pcmdpriv->cmd_queue, cmd_obj);
 233
 234         if (res == _SUCCESS)
 235                 up(&pcmdpriv->cmd_queue_sema);
 236
 237 exit:
 238
 239
 240         return res;
 241 }
 242
 243 struct cmd_obj  *rtw_dequeue_cmd(struct cmd_priv *pcmdpriv)
 244 {
 245         struct cmd_obj *cmd_obj;
 246
 247
 248         cmd_obj = _rtw_dequeue_cmd(&pcmdpriv->cmd_queue);
 249
 250         return cmd_obj;
 251 }
 252
 253 void rtw_cmd_clr_isr(struct cmd_priv *pcmdpriv)
 254 {
 255         pcmdpriv->cmd_done_cnt++;
 256         /* up(&(pcmdpriv->cmd_done_sema)); */
 257 }
 258
 259 void rtw_free_cmd_obj(struct cmd_obj *pcmd)
 260 {
 261
 262         if ((pcmd->cmdcode != _JoinBss_CMD_) && (pcmd->cmdcode != _CreateBss_CMD_)) {
 263                 /* free parmbuf in cmd_obj */
 264                 kfree(pcmd->parmbuf);
 265         }
 266
 267         if (pcmd->rsp != NULL) {
 268                 if (pcmd->rspsz != 0) {
 269                         /* free rsp in cmd_obj */
 270                         kfree(pcmd->rsp);
 271                 }
 272         }
 273
 274         /* free cmd_obj */
 275         kfree(pcmd);
 276
 277 }
 278
 279 int rtw_cmd_thread(void *context)
 280 {
 281         u8 ret;
 282         struct cmd_obj *pcmd;
 283         u8 *pcmdbuf;
 284         u8 (*cmd_hdl)(struct adapter *padapter, u8 *pbuf);
 285         void (*pcmd_callback)(struct adapter *dev, struct cmd_obj *pcmd);
 286         struct adapter *padapter = (struct adapter *)context;
 287         struct cmd_priv *pcmdpriv = &(padapter->cmdpriv);
 288
 289
 290         thread_enter("RTW_CMD_THREAD");
 291
 292         pcmdbuf = pcmdpriv->cmd_buf;
 293
 294         pcmdpriv->cmdthd_running = true;
 295         up(&pcmdpriv->terminate_cmdthread_sema);
 296
 297         RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("start r871x rtw_cmd_thread !!!!\n"));
 298
 299         while (1) {
 300                 if (_rtw_down_sema(&pcmdpriv->cmd_queue_sema) == _FAIL)
 301                         break;
 302
 303                 if (padapter->bDriverStopped ||
 304                     padapter->bSurpriseRemoved) {
 305                         DBG_88E("%s: DriverStopped(%d) SurpriseRemoved(%d) break at line %d\n",
 306                                 __func__, padapter->bDriverStopped, padapter->bSurpriseRemoved, __LINE__);
 307                         break;
 308                 }
 309 _next:
 310                 if (padapter->bDriverStopped ||
 311                     padapter->bSurpriseRemoved) {
 312                         DBG_88E("%s: DriverStopped(%d) SurpriseRemoved(%d) break at line %d\n",
 313                                 __func__, padapter->bDriverStopped, padapter->bSurpriseRemoved, __LINE__);
 314                         break;
 315                 }
 316
 317                 pcmd = rtw_dequeue_cmd(pcmdpriv);
 318                 if (!pcmd)
 319                         continue;
 320
 321                 if (_FAIL == rtw_cmd_filter(pcmdpriv, pcmd)) {
 322                         pcmd->res = H2C_DROPPED;
 323                         goto post_process;
 324                 }
 325
 326                 pcmdpriv->cmd_issued_cnt++;
 327
 328                 pcmd->cmdsz = _RND4((pcmd->cmdsz));/* _RND4 */
 329
 330                 memcpy(pcmdbuf, pcmd->parmbuf, pcmd->cmdsz);
 331
 332                 if (pcmd->cmdcode < ARRAY_SIZE(wlancmds)) {
 333                         cmd_hdl = wlancmds[pcmd->cmdcode].h2cfuns;
 334
 335                         if (cmd_hdl) {
 336                                 ret = cmd_hdl(pcmd->padapter, pcmdbuf);
 337                                 pcmd->res = ret;
 338                         }
 339
 340                         pcmdpriv->cmd_seq++;
 341                 } else {
 342                         pcmd->res = H2C_PARAMETERS_ERROR;
 343                 }
 344
 345                 cmd_hdl = NULL;
 346
 347 post_process:
 348
 349                 /* call callback function for post-processed */
 350                 if (pcmd->cmdcode < ARRAY_SIZE(rtw_cmd_callback)) {
 351                         pcmd_callback = rtw_cmd_callback[pcmd->cmdcode].callback;
 352                         if (pcmd_callback == NULL) {
 353                                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("mlme_cmd_hdl(): pcmd_callback = 0x%p, cmdcode = 0x%x\n", pcmd_callback, pcmd->cmdcode));
 354                                 rtw_free_cmd_obj(pcmd);
 355                         } else {
 356                                 /* todo: !!! fill rsp_buf to pcmd->rsp if (pcmd->rsp!= NULL) */
 357                                 pcmd_callback(pcmd->padapter, pcmd);/* need conider that free cmd_obj in rtw_cmd_callback */
 358                         }
 359                 } else {
 360                         RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("%s: cmdcode = 0x%x callback not defined!\n", __func__, pcmd->cmdcode));
 361                         rtw_free_cmd_obj(pcmd);
 362                 }
 363
 364                 flush_signals_thread();
 365
 366                 goto _next;
 367         }
 368         pcmdpriv->cmdthd_running = false;
 369
 370         /*  free all cmd_obj resources */
 371         do {
 372                 pcmd = rtw_dequeue_cmd(pcmdpriv);
 373                 if (pcmd == NULL)
 374                         break;
 375
 376                 /* DBG_88E("%s: leaving... drop cmdcode:%u\n", __func__, pcmd->cmdcode); */
 377
 378                 rtw_free_cmd_obj(pcmd);
 379         } while (1);
 380
 381         up(&pcmdpriv->terminate_cmdthread_sema);
 382
 383
 384         complete_and_exit(NULL, 0);
 385 }
 386
 387 u8 rtw_setstandby_cmd(struct adapter *padapter, uint action)
 388 {
 389         struct cmd_obj *ph2c;
 390         struct usb_suspend_parm *psetusbsuspend;
 391         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 392
 393         u8 ret = _SUCCESS;
 394
 395
 396         ph2c = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
 397         if (ph2c == NULL) {
 398                 ret = _FAIL;
 399                 goto exit;
 400         }
 401
 402         psetusbsuspend = kzalloc(sizeof(struct usb_suspend_parm), GFP_KERNEL);
 403         if (psetusbsuspend == NULL) {
 404                 kfree(ph2c);
 405                 ret = _FAIL;
 406                 goto exit;
 407         }
 408
 409         psetusbsuspend->action = action;
 410
 411         init_h2fwcmd_w_parm_no_rsp(ph2c, psetusbsuspend, GEN_CMD_CODE(_SetUsbSuspend));
 412
 413         ret = rtw_enqueue_cmd(pcmdpriv, ph2c);
 414
 415 exit:
 416
 417
 418         return ret;
 419 }
 420
 421 /*
 422 rtw_sitesurvey_cmd(~)
 423         ### NOTE:#### (!!!!)
 424         MUST TAKE CARE THAT BEFORE CALLING THIS FUNC, YOU SHOULD HAVE LOCKED pmlmepriv->lock
 425 */
 426 u8 rtw_sitesurvey_cmd(struct adapter  *padapter, struct ndis_802_11_ssid *ssid, int ssid_num,
 427         struct rtw_ieee80211_channel *ch, int ch_num)
 428 {
 429         u8 res = _FAIL;
 430         struct cmd_obj          *ph2c;
 431         struct sitesurvey_parm  *psurveyPara;
 432         struct cmd_priv         *pcmdpriv = &padapter->cmdpriv;
 433         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
 434
 435         if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
 436                 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_SCAN, 1);
 437
 438         if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
 439                 p2p_ps_wk_cmd(padapter, P2P_PS_SCAN, 1);
 440
 441         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
 442         if (ph2c == NULL)
 443                 return _FAIL;
 444
 445         psurveyPara = (struct sitesurvey_parm *)rtw_zmalloc(sizeof(struct sitesurvey_parm));
 446         if (psurveyPara == NULL) {
 447                 kfree(ph2c);
 448                 return _FAIL;
 449         }
 450
 451         rtw_free_network_queue(padapter, false);
 452
 453         RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("%s: flush network queue\n", __func__));
 454
 455         init_h2fwcmd_w_parm_no_rsp(ph2c, psurveyPara, GEN_CMD_CODE(_SiteSurvey));
 456
 457         /* psurveyPara->bsslimit = 48; */
 458         psurveyPara->scan_mode = pmlmepriv->scan_mode;
 459
 460         /* prepare ssid list */
 461         if (ssid) {
 462                 int i;
 463                 for (i = 0; i < ssid_num && i < RTW_SSID_SCAN_AMOUNT; i++) {
 464                         if (ssid[i].SsidLength) {
 465                                 memcpy(&psurveyPara->ssid[i], &ssid[i], sizeof(struct ndis_802_11_ssid));
 466                                 psurveyPara->ssid_num++;
 467                         }
 468                 }
 469         }
 470
 471         /* prepare channel list */
 472         if (ch) {
 473                 int i;
 474                 for (i = 0; i < ch_num && i < RTW_CHANNEL_SCAN_AMOUNT; i++) {
 475                         if (ch[i].hw_value && !(ch[i].flags & RTW_IEEE80211_CHAN_DISABLED)) {
 476                                 memcpy(&psurveyPara->ch[i], &ch[i], sizeof(struct rtw_ieee80211_channel));
 477                                 psurveyPara->ch_num++;
 478                         }
 479                 }
 480         }
 481
 482         set_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
 483
 484         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
 485
 486         if (res == _SUCCESS) {
 487                 pmlmepriv->scan_start_time = jiffies;
 488
 489                 _set_timer(&pmlmepriv->scan_to_timer, SCANNING_TIMEOUT);
 490
 491                 rtw_led_control(padapter, LED_CTL_SITE_SURVEY);
 492
 493                 pmlmepriv->scan_interval = SCAN_INTERVAL;/*  30*2 sec = 60sec */
 494         } else {
 495                 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
 496         }
 497
 498
 499         return res;
 500 }
 501
 502 u8 rtw_setdatarate_cmd(struct adapter *padapter, u8 *rateset)
 503 {
 504         struct cmd_obj *ph2c;
 505         struct setdatarate_parm *pbsetdataratepara;
 506         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 507         u8      res = _SUCCESS;
 508
 509
 510         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
 511         if (ph2c == NULL) {
 512                 res = _FAIL;
 513                 goto exit;
 514         }
 515
 516         pbsetdataratepara = (struct setdatarate_parm *)rtw_zmalloc(sizeof(struct setdatarate_parm));
 517         if (pbsetdataratepara == NULL) {
 518                 kfree(ph2c);
 519                 res = _FAIL;
 520                 goto exit;
 521         }
 522
 523         init_h2fwcmd_w_parm_no_rsp(ph2c, pbsetdataratepara, GEN_CMD_CODE(_SetDataRate));
 524         pbsetdataratepara->mac_id = 5;
 525         memcpy(pbsetdataratepara->datarates, rateset, NumRates);
 526         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
 527 exit:
 528
 529
 530         return res;
 531 }
 532
 533 u8 rtw_setbasicrate_cmd(struct adapter *padapter, u8 *rateset)
 534 {
 535         struct cmd_obj *ph2c;
 536         struct setbasicrate_parm *pssetbasicratepara;
 537         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 538         u8      res = _SUCCESS;
 539
 540
 541         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
 542         if (ph2c == NULL) {
 543                 res = _FAIL;
 544                 goto exit;
 545         }
 546         pssetbasicratepara = (struct setbasicrate_parm *)rtw_zmalloc(sizeof(struct setbasicrate_parm));
 547
 548         if (pssetbasicratepara == NULL) {
 549                 kfree(ph2c);
 550                 res = _FAIL;
 551                 goto exit;
 552         }
 553
 554         init_h2fwcmd_w_parm_no_rsp(ph2c, pssetbasicratepara, _SetBasicRate_CMD_);
 555
 556         memcpy(pssetbasicratepara->basicrates, rateset, NumRates);
 557
 558         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
 559 exit:
 560
 561
 562         return res;
 563 }
 564
 565
 566 /*
 567 unsigned char rtw_setphy_cmd(unsigned char  *adapter)
 568
 569 1.  be called only after rtw_update_registrypriv_dev_network(~) or mp testing program
 570 2.  for AdHoc/Ap mode or mp mode?
 571
 572 */
 573 u8 rtw_setphy_cmd(struct adapter *padapter, u8 modem, u8 ch)
 574 {
 575         struct cmd_obj *ph2c;
 576         struct setphy_parm *psetphypara;
 577         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 578         u8      res = _SUCCESS;
 579
 580
 581         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
 582         if (ph2c == NULL) {
 583                 res = _FAIL;
 584                 goto exit;
 585                 }
 586         psetphypara = (struct setphy_parm *)rtw_zmalloc(sizeof(struct setphy_parm));
 587
 588         if (psetphypara == NULL) {
 589                 kfree(ph2c);
 590                 res = _FAIL;
 591                 goto exit;
 592         }
 593
 594         init_h2fwcmd_w_parm_no_rsp(ph2c, psetphypara, _SetPhy_CMD_);
 595
 596         RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("CH =%d, modem =%d", ch, modem));
 597
 598         psetphypara->modem = modem;
 599         psetphypara->rfchannel = ch;
 600
 601         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
 602 exit:
 603         return res;
 604 }
 605
 606 u8 rtw_setbbreg_cmd(struct adapter *padapter, u8 offset, u8 val)
 607 {
 608         struct cmd_obj *ph2c;
 609         struct writeBB_parm *pwritebbparm;
 610         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 611         u8      res = _SUCCESS;
 612
 613         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
 614         if (ph2c == NULL) {
 615                 res = _FAIL;
 616                 goto exit;
 617                 }
 618         pwritebbparm = (struct writeBB_parm *)rtw_zmalloc(sizeof(struct writeBB_parm));
 619
 620         if (pwritebbparm == NULL) {
 621                 kfree(ph2c);
 622                 res = _FAIL;
 623                 goto exit;
 624         }
 625
 626         init_h2fwcmd_w_parm_no_rsp(ph2c, pwritebbparm, GEN_CMD_CODE(_SetBBReg));
 627
 628         pwritebbparm->offset = offset;
 629         pwritebbparm->value = val;
 630
 631         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
 632 exit:
 633         return res;
 634 }
 635
 636 u8 rtw_getbbreg_cmd(struct adapter  *padapter, u8 offset, u8 *pval)
 637 {
 638         struct cmd_obj *ph2c;
 639         struct readBB_parm *prdbbparm;
 640         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 641         u8      res = _SUCCESS;
 642
 643         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
 644         if (ph2c == NULL) {
 645                 res = _FAIL;
 646                 goto exit;
 647                 }
 648         prdbbparm = (struct readBB_parm *)rtw_zmalloc(sizeof(struct readBB_parm));
 649
 650         if (prdbbparm == NULL) {
 651                 kfree(ph2c);
 652                 return _FAIL;
 653         }
 654
 655         _rtw_init_listhead(&ph2c->list);
 656         ph2c->cmdcode = GEN_CMD_CODE(_GetBBReg);
 657         ph2c->parmbuf = (unsigned char *)prdbbparm;
 658         ph2c->cmdsz =  sizeof(struct readBB_parm);
 659         ph2c->rsp = pval;
 660         ph2c->rspsz = sizeof(struct readBB_rsp);
 661
 662         prdbbparm->offset = offset;
 663
 664         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
 665 exit:
 666         return res;
 667 }
 668
 669 u8 rtw_setrfreg_cmd(struct adapter  *padapter, u8 offset, u32 val)
 670 {
 671         struct cmd_obj *ph2c;
 672         struct writeRF_parm *pwriterfparm;
 673         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 674         u8      res = _SUCCESS;
 675         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
 676         if (ph2c == NULL) {
 677                 res = _FAIL;
 678                 goto exit;
 679         }
 680         pwriterfparm = (struct writeRF_parm *)rtw_zmalloc(sizeof(struct writeRF_parm));
 681
 682         if (pwriterfparm == NULL) {
 683                 kfree(ph2c);
 684                 res = _FAIL;
 685                 goto exit;
 686         }
 687
 688         init_h2fwcmd_w_parm_no_rsp(ph2c, pwriterfparm, GEN_CMD_CODE(_SetRFReg));
 689
 690         pwriterfparm->offset = offset;
 691         pwriterfparm->value = val;
 692
 693         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
 694 exit:
 695         return res;
 696 }
 697
 698 u8 rtw_getrfreg_cmd(struct adapter  *padapter, u8 offset, u8 *pval)
 699 {
 700         struct cmd_obj *ph2c;
 701         struct readRF_parm *prdrfparm;
 702         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 703         u8      res = _SUCCESS;
 704
 705
 706         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
 707         if (ph2c == NULL) {
 708                 res = _FAIL;
 709                 goto exit;
 710         }
 711
 712         prdrfparm = (struct readRF_parm *)rtw_zmalloc(sizeof(struct readRF_parm));
 713         if (prdrfparm == NULL) {
 714                 kfree(ph2c);
 715                 res = _FAIL;
 716                 goto exit;
 717         }
 718
 719         _rtw_init_listhead(&ph2c->list);
 720         ph2c->cmdcode = GEN_CMD_CODE(_GetRFReg);
 721         ph2c->parmbuf = (unsigned char *)prdrfparm;
 722         ph2c->cmdsz =  sizeof(struct readRF_parm);
 723         ph2c->rsp = pval;
 724         ph2c->rspsz = sizeof(struct readRF_rsp);
 725
 726         prdrfparm->offset = offset;
 727
 728         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
 729
 730 exit:
 731
 732
 733         return res;
 734 }
 735
 736 void rtw_getbbrfreg_cmdrsp_callback(struct adapter *padapter,  struct cmd_obj *pcmd)
 737 {
 738
 739         kfree(pcmd->parmbuf);
 740         kfree(pcmd);
 741
 742         if (padapter->registrypriv.mp_mode == 1)
 743                 padapter->mppriv.workparam.bcompleted = true;
 744 }
 745
 746 void rtw_readtssi_cmdrsp_callback(struct adapter *padapter,  struct cmd_obj *pcmd)
 747 {
 748
 749         kfree(pcmd->parmbuf);
 750         kfree(pcmd);
 751
 752         if (padapter->registrypriv.mp_mode == 1)
 753                 padapter->mppriv.workparam.bcompleted = true;
 754 }
 755
 756 u8 rtw_createbss_cmd(struct adapter  *padapter)
 757 {
 758         struct cmd_obj *pcmd;
 759         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 760         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 761         struct wlan_bssid_ex *pdev_network = &padapter->registrypriv.dev_network;
 762         u8      res = _SUCCESS;
 763
 764
 765         rtw_led_control(padapter, LED_CTL_START_TO_LINK);
 766
 767         if (pmlmepriv->assoc_ssid.SsidLength == 0)
 768                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, (" createbss for Any SSid:%s\n", pmlmepriv->assoc_ssid.Ssid));
 769         else
 770                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, (" createbss for SSid:%s\n", pmlmepriv->assoc_ssid.Ssid));
 771
 772         pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
 773         if (pcmd == NULL) {
 774                 res = _FAIL;
 775                 goto exit;
 776         }
 777
 778         _rtw_init_listhead(&pcmd->list);
 779         pcmd->cmdcode = _CreateBss_CMD_;
 780         pcmd->parmbuf = (unsigned char *)pdev_network;
 781         pcmd->cmdsz = get_wlan_bssid_ex_sz((struct wlan_bssid_ex *)pdev_network);
 782         pcmd->rsp = NULL;
 783         pcmd->rspsz = 0;
 784         pdev_network->Length = pcmd->cmdsz;
 785         res = rtw_enqueue_cmd(pcmdpriv, pcmd);
 786 exit:
 787
 788
 789         return res;
 790 }
 791
 792 u8 rtw_createbss_cmd_ex(struct adapter  *padapter, unsigned char *pbss, unsigned int sz)
 793 {
 794         struct cmd_obj *pcmd;
 795         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 796         u8      res = _SUCCESS;
 797
 798
 799         pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
 800         if (pcmd == NULL) {
 801                 res = _FAIL;
 802                 goto exit;
 803         }
 804
 805         _rtw_init_listhead(&pcmd->list);
 806         pcmd->cmdcode = GEN_CMD_CODE(_CreateBss);
 807         pcmd->parmbuf = pbss;
 808         pcmd->cmdsz =  sz;
 809         pcmd->rsp = NULL;
 810         pcmd->rspsz = 0;
 811
 812         res = rtw_enqueue_cmd(pcmdpriv, pcmd);
 813
 814 exit:
 815
 816
 817         return res;
 818 }
 819
 820 u8 rtw_joinbss_cmd(struct adapter  *padapter, struct wlan_network *pnetwork)
 821 {
 822         u8      res = _SUCCESS;
 823         uint    t_len = 0;
 824         struct wlan_bssid_ex            *psecnetwork;
 825         struct cmd_obj          *pcmd;
 826         struct cmd_priv         *pcmdpriv = &padapter->cmdpriv;
 827         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
 828         struct qos_priv         *pqospriv = &pmlmepriv->qospriv;
 829         struct security_priv    *psecuritypriv = &padapter->securitypriv;
 830         struct registry_priv    *pregistrypriv = &padapter->registrypriv;
 831         struct ht_priv          *phtpriv = &pmlmepriv->htpriv;
 832         enum ndis_802_11_network_infra ndis_network_mode = pnetwork->network.InfrastructureMode;
 833         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 834         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 835
 836
 837         rtw_led_control(padapter, LED_CTL_START_TO_LINK);
 838
 839         if (pmlmepriv->assoc_ssid.SsidLength == 0)
 840                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("+Join cmd: Any SSid\n"));
 841         else
 842                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+Join cmd: SSid =[%s]\n", pmlmepriv->assoc_ssid.Ssid));
 843
 844         pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
 845         if (pcmd == NULL) {
 846                 res = _FAIL;
 847                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("rtw_joinbss_cmd: memory allocate for cmd_obj fail!!!\n"));
 848                 goto exit;
 849         }
 850         /* for IEs is fix buf size */
 851         t_len = sizeof(struct wlan_bssid_ex);
 852
 853
 854         /* for hidden ap to set fw_state here */
 855         if (!check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_ADHOC_STATE)) {
 856                 switch (ndis_network_mode) {
 857                 case Ndis802_11IBSS:
 858                         set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
 859                         break;
 860                 case Ndis802_11Infrastructure:
 861                         set_fwstate(pmlmepriv, WIFI_STATION_STATE);
 862                         break;
 863                 case Ndis802_11APMode:
 864                 case Ndis802_11AutoUnknown:
 865                 case Ndis802_11InfrastructureMax:
 866                         break;
 867                 }
 868         }
 869
 870         psecnetwork = (struct wlan_bssid_ex *)&psecuritypriv->sec_bss;
 871         if (psecnetwork == NULL) {
 872                 if (pcmd != NULL)
 873                         kfree(pcmd);
 874
 875                 res = _FAIL;
 876
 877                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("rtw_joinbss_cmd :psecnetwork == NULL!!!\n"));
 878
 879                 goto exit;
 880         }
 881
 882         _rtw_memset(psecnetwork, 0, t_len);
 883
 884         memcpy(psecnetwork, &pnetwork->network, get_wlan_bssid_ex_sz(&pnetwork->network));
 885
 886         psecuritypriv->authenticator_ie[0] = (unsigned char)psecnetwork->IELength;
 887
 888         if ((psecnetwork->IELength-12) < (256-1))
 889                 memcpy(&psecuritypriv->authenticator_ie[1], &psecnetwork->IEs[12], psecnetwork->IELength-12);
 890         else
 891                 memcpy(&psecuritypriv->authenticator_ie[1], &psecnetwork->IEs[12], (256-1));
 892
 893         psecnetwork->IELength = 0;
 894         /*  Added by Albert 2009/02/18 */
 895         /*  If the the driver wants to use the bssid to create the connection. */
 896         /*  If not,  we have to copy the connecting AP's MAC address to it so that */
 897         /*  the driver just has the bssid information for PMKIDList searching. */
 898
 899         if (!pmlmepriv->assoc_by_bssid)
 900                 memcpy(&pmlmepriv->assoc_bssid[0], &pnetwork->network.MacAddress[0], ETH_ALEN);
 901
 902         psecnetwork->IELength = rtw_restruct_sec_ie(padapter, &pnetwork->network.IEs[0], &psecnetwork->IEs[0], pnetwork->network.IELength);
 903
 904
 905         pqospriv->qos_option = 0;
 906
 907         if (pregistrypriv->wmm_enable) {
 908                 u32 tmp_len;
 909
 910                 tmp_len = rtw_restruct_wmm_ie(padapter, &pnetwork->network.IEs[0], &psecnetwork->IEs[0], pnetwork->network.IELength, psecnetwork->IELength);
 911
 912                 if (psecnetwork->IELength != tmp_len) {
 913                         psecnetwork->IELength = tmp_len;
 914                         pqospriv->qos_option = 1; /* There is WMM IE in this corresp. beacon */
 915                 } else {
 916                         pqospriv->qos_option = 0;/* There is no WMM IE in this corresp. beacon */
 917                 }
 918         }
 919
 920         phtpriv->ht_option = false;
 921         if (pregistrypriv->ht_enable) {
 922                 /*
 923                  * Added by Albert 2010/06/23
 924                  * For the WEP mode, we will use the bg mode to do
 925                  * the connection to avoid some IOT issue.
 926                  * Especially for Realtek 8192u SoftAP.
 927                  */
 928                 if ((padapter->securitypriv.dot11PrivacyAlgrthm != _WEP40_) &&
 929                     (padapter->securitypriv.dot11PrivacyAlgrthm != _WEP104_) &&
 930                     (padapter->securitypriv.dot11PrivacyAlgrthm != _TKIP_)) {
 931                         /* rtw_restructure_ht_ie */
 932                         rtw_restructure_ht_ie(padapter, &pnetwork->network.IEs[0], &psecnetwork->IEs[0],
 933                                                                         pnetwork->network.IELength, &psecnetwork->IELength);
 934                 }
 935         }
 936
 937         pmlmeinfo->assoc_AP_vendor = check_assoc_AP(pnetwork->network.IEs, pnetwork->network.IELength);
 938
 939         if (pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_TENDA)
 940                 padapter->pwrctrlpriv.smart_ps = 0;
 941         else
 942                 padapter->pwrctrlpriv.smart_ps = padapter->registrypriv.smart_ps;
 943
 944         DBG_88E("%s: smart_ps =%d\n", __func__, padapter->pwrctrlpriv.smart_ps);
 945
 946         pcmd->cmdsz = get_wlan_bssid_ex_sz(psecnetwork);/* get cmdsz before endian conversion */
 947
 948         _rtw_init_listhead(&pcmd->list);
 949         pcmd->cmdcode = _JoinBss_CMD_;/* GEN_CMD_CODE(_JoinBss) */
 950         pcmd->parmbuf = (unsigned char *)psecnetwork;
 951         pcmd->rsp = NULL;
 952         pcmd->rspsz = 0;
 953
 954         res = rtw_enqueue_cmd(pcmdpriv, pcmd);
 955
 956 exit:
 957
 958
 959         return res;
 960 }
 961
 962 u8 rtw_disassoc_cmd(struct adapter *padapter, u32 deauth_timeout_ms, bool enqueue) /* for sta_mode */
 963 {
 964         struct cmd_obj *cmdobj = NULL;
 965         struct disconnect_parm *param = NULL;
 966         struct cmd_priv *cmdpriv = &padapter->cmdpriv;
 967         u8 res = _SUCCESS;
 968
 969
 970         RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+rtw_disassoc_cmd\n"));
 971
 972         /* prepare cmd parameter */
 973         param = (struct disconnect_parm *)rtw_zmalloc(sizeof(*param));
 974         if (param == NULL) {
 975                 res = _FAIL;
 976                 goto exit;
 977         }
 978         param->deauth_timeout_ms = deauth_timeout_ms;
 979
 980         if (enqueue) {
 981                 /* need enqueue, prepare cmd_obj and enqueue */
 982                 cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(*cmdobj));
 983                 if (cmdobj == NULL) {
 984                         res = _FAIL;
 985                         kfree(param);
 986                         goto exit;
 987                 }
 988                 init_h2fwcmd_w_parm_no_rsp(cmdobj, param, _DisConnect_CMD_);
 989                 res = rtw_enqueue_cmd(cmdpriv, cmdobj);
 990         } else {
 991                 /* no need to enqueue, do the cmd hdl directly and free cmd parameter */
 992                 if (H2C_SUCCESS != disconnect_hdl(padapter, (u8 *)param))
 993                         res = _FAIL;
 994                 kfree(param);
 995         }
 996
 997 exit:
 998
 999
1000         return res;
1001 }
1002
1003 u8 rtw_setopmode_cmd(struct adapter  *padapter, enum ndis_802_11_network_infra networktype)
1004 {
1005         struct  cmd_obj *ph2c;
1006         struct  setopmode_parm *psetop;
1007
1008         struct  cmd_priv   *pcmdpriv = &padapter->cmdpriv;
1009         u8      res = _SUCCESS;
1010
1011
1012         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1013         if (ph2c == NULL) {
1014                 res = false;
1015                 goto exit;
1016         }
1017         psetop = (struct setopmode_parm *)rtw_zmalloc(sizeof(struct setopmode_parm));
1018
1019         if (psetop == NULL) {
1020                 kfree(ph2c);
1021                 res = false;
1022                 goto exit;
1023         }
1024
1025         init_h2fwcmd_w_parm_no_rsp(ph2c, psetop, _SetOpMode_CMD_);
1026         psetop->mode = (u8)networktype;
1027
1028         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1029
1030 exit:
1031
1032
1033         return res;
1034 }
1035
1036 u8 rtw_setstakey_cmd(struct adapter *padapter, u8 *psta, u8 unicast_key)
1037 {
1038         struct cmd_obj *ph2c;
1039         struct set_stakey_parm *psetstakey_para;
1040         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1041         struct set_stakey_rsp *psetstakey_rsp = NULL;
1042
1043         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1044         struct security_priv *psecuritypriv = &padapter->securitypriv;
1045         struct sta_info *sta = (struct sta_info *)psta;
1046         u8      res = _SUCCESS;
1047
1048
1049         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1050         if (ph2c == NULL) {
1051                 res = _FAIL;
1052                 goto exit;
1053         }
1054
1055         psetstakey_para = (struct set_stakey_parm *)rtw_zmalloc(sizeof(struct set_stakey_parm));
1056         if (psetstakey_para == NULL) {
1057                 kfree(ph2c);
1058                 res = _FAIL;
1059                 goto exit;
1060         }
1061
1062         psetstakey_rsp = (struct set_stakey_rsp *)rtw_zmalloc(sizeof(struct set_stakey_rsp));
1063         if (psetstakey_rsp == NULL) {
1064                 kfree(ph2c);
1065                 kfree(psetstakey_para);
1066                 res = _FAIL;
1067                 goto exit;
1068         }
1069
1070         init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_);
1071         ph2c->rsp = (u8 *)psetstakey_rsp;
1072         ph2c->rspsz = sizeof(struct set_stakey_rsp);
1073
1074         ether_addr_copy(psetstakey_para->addr, sta->hwaddr);
1075
1076         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
1077                 psetstakey_para->algorithm = (unsigned char) psecuritypriv->dot11PrivacyAlgrthm;
1078         else
1079                 GET_ENCRY_ALGO(psecuritypriv, sta, psetstakey_para->algorithm, false);
1080
1081         if (unicast_key)
1082                 memcpy(&psetstakey_para->key, &sta->dot118021x_UncstKey, 16);
1083         else
1084                 memcpy(&psetstakey_para->key, &psecuritypriv->dot118021XGrpKey[psecuritypriv->dot118021XGrpKeyid].skey, 16);
1085
1086         /* jeff: set this because at least sw key is ready */
1087         padapter->securitypriv.busetkipkey = true;
1088
1089         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1090
1091 exit:
1092
1093
1094         return res;
1095 }
1096
1097 u8 rtw_clearstakey_cmd(struct adapter *padapter, u8 *psta, u8 entry, u8 enqueue)
1098 {
1099         struct cmd_obj *ph2c;
1100         struct set_stakey_parm  *psetstakey_para;
1101         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1102         struct set_stakey_rsp *psetstakey_rsp = NULL;
1103         struct sta_info *sta = (struct sta_info *)psta;
1104         u8      res = _SUCCESS;
1105
1106
1107         if (!enqueue) {
1108                 clear_cam_entry(padapter, entry);
1109         } else {
1110                 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1111                 if (ph2c == NULL) {
1112                         res = _FAIL;
1113                         goto exit;
1114                 }
1115
1116                 psetstakey_para = (struct set_stakey_parm *)rtw_zmalloc(sizeof(struct set_stakey_parm));
1117                 if (psetstakey_para == NULL) {
1118                         kfree(ph2c);
1119                         res = _FAIL;
1120                         goto exit;
1121                 }
1122
1123                 psetstakey_rsp = (struct set_stakey_rsp *)rtw_zmalloc(sizeof(struct set_stakey_rsp));
1124                 if (psetstakey_rsp == NULL) {
1125                         kfree(ph2c);
1126                         kfree(psetstakey_para);
1127                         res = _FAIL;
1128                         goto exit;
1129                 }
1130
1131                 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_);
1132                 ph2c->rsp = (u8 *)psetstakey_rsp;
1133                 ph2c->rspsz = sizeof(struct set_stakey_rsp);
1134
1135                 ether_addr_copy(psetstakey_para->addr, sta->hwaddr);
1136
1137                 psetstakey_para->algorithm = _NO_PRIVACY_;
1138
1139                 psetstakey_para->id = entry;
1140
1141                 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1142         }
1143 exit:
1144
1145
1146         return res;
1147 }
1148
1149 u8 rtw_setrttbl_cmd(struct adapter  *padapter, struct setratable_parm *prate_table)
1150 {
1151         struct cmd_obj *ph2c;
1152         struct setratable_parm *psetrttblparm;
1153         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1154         u8      res = _SUCCESS;
1155
1156         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1157         if (ph2c == NULL) {
1158                 res = _FAIL;
1159                 goto exit;
1160         }
1161         psetrttblparm = (struct setratable_parm *)rtw_zmalloc(sizeof(struct setratable_parm));
1162
1163         if (psetrttblparm == NULL) {
1164                 kfree(ph2c);
1165                 res = _FAIL;
1166                 goto exit;
1167         }
1168
1169         init_h2fwcmd_w_parm_no_rsp(ph2c, psetrttblparm, GEN_CMD_CODE(_SetRaTable));
1170
1171         memcpy(psetrttblparm, prate_table, sizeof(struct setratable_parm));
1172
1173         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1174 exit:
1175         return res;
1176 }
1177
1178 u8 rtw_getrttbl_cmd(struct adapter  *padapter, struct getratable_rsp *pval)
1179 {
1180         struct cmd_obj *ph2c;
1181         struct getratable_parm *pgetrttblparm;
1182         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1183         u8      res = _SUCCESS;
1184
1185         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1186         if (ph2c == NULL) {
1187                 res = _FAIL;
1188                 goto exit;
1189         }
1190         pgetrttblparm = (struct getratable_parm *)rtw_zmalloc(sizeof(struct getratable_parm));
1191
1192         if (pgetrttblparm == NULL) {
1193                 kfree(ph2c);
1194                 res = _FAIL;
1195                 goto exit;
1196         }
1197
1198         _rtw_init_listhead(&ph2c->list);
1199         ph2c->cmdcode = GEN_CMD_CODE(_GetRaTable);
1200         ph2c->parmbuf = (unsigned char *)pgetrttblparm;
1201         ph2c->cmdsz =  sizeof(struct getratable_parm);
1202         ph2c->rsp = (u8 *)pval;
1203         ph2c->rspsz = sizeof(struct getratable_rsp);
1204
1205         pgetrttblparm->rsvd = 0x0;
1206
1207         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1208 exit:
1209         return res;
1210 }
1211
1212 u8 rtw_setassocsta_cmd(struct adapter  *padapter, u8 *mac_addr)
1213 {
1214         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1215         struct cmd_obj *ph2c;
1216         struct set_assocsta_parm *psetassocsta_para;
1217         struct set_stakey_rsp *psetassocsta_rsp = NULL;
1218
1219         u8      res = _SUCCESS;
1220
1221
1222         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1223         if (ph2c == NULL) {
1224                 res = _FAIL;
1225                 goto exit;
1226         }
1227
1228         psetassocsta_para = (struct set_assocsta_parm *)rtw_zmalloc(sizeof(struct set_assocsta_parm));
1229         if (psetassocsta_para == NULL) {
1230                 kfree(ph2c);
1231                 res = _FAIL;
1232                 goto exit;
1233         }
1234
1235         psetassocsta_rsp = (struct set_stakey_rsp *)rtw_zmalloc(sizeof(struct set_assocsta_rsp));
1236         if (psetassocsta_rsp == NULL) {
1237                 kfree(ph2c);
1238                 kfree(psetassocsta_para);
1239                 return _FAIL;
1240         }
1241
1242         init_h2fwcmd_w_parm_no_rsp(ph2c, psetassocsta_para, _SetAssocSta_CMD_);
1243         ph2c->rsp = (u8 *)psetassocsta_rsp;
1244         ph2c->rspsz = sizeof(struct set_assocsta_rsp);
1245
1246         ether_addr_copy(psetassocsta_para->addr, mac_addr);
1247
1248         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1249
1250 exit:
1251
1252
1253         return res;
1254 }
1255
1256 u8 rtw_addbareq_cmd(struct adapter *padapter, u8 tid, u8 *addr)
1257 {
1258         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1259         struct cmd_obj *ph2c;
1260         struct addBaReq_parm *paddbareq_parm;
1261         u8      res = _SUCCESS;
1262
1263
1264         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1265         if (ph2c == NULL) {
1266                 res = _FAIL;
1267                 goto exit;
1268         }
1269
1270         paddbareq_parm = (struct addBaReq_parm *)rtw_zmalloc(sizeof(struct addBaReq_parm));
1271         if (paddbareq_parm == NULL) {
1272                 kfree(ph2c);
1273                 res = _FAIL;
1274                 goto exit;
1275         }
1276
1277         paddbareq_parm->tid = tid;
1278         memcpy(paddbareq_parm->addr, addr, ETH_ALEN);
1279
1280         init_h2fwcmd_w_parm_no_rsp(ph2c, paddbareq_parm, GEN_CMD_CODE(_AddBAReq));
1281
1282         /* DBG_88E("rtw_addbareq_cmd, tid =%d\n", tid); */
1283
1284         /* rtw_enqueue_cmd(pcmdpriv, ph2c); */
1285         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1286
1287 exit:
1288
1289
1290         return res;
1291 }
1292
1293 u8 rtw_dynamic_chk_wk_cmd(struct adapter *padapter)
1294 {
1295         struct cmd_obj *ph2c;
1296         struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1297         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1298         u8      res = _SUCCESS;
1299
1300
1301         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1302         if (ph2c == NULL) {
1303                 res = _FAIL;
1304                 goto exit;
1305         }
1306
1307         pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1308         if (pdrvextra_cmd_parm == NULL) {
1309                 kfree(ph2c);
1310                 res = _FAIL;
1311                 goto exit;
1312         }
1313
1314         pdrvextra_cmd_parm->ec_id = DYNAMIC_CHK_WK_CID;
1315         pdrvextra_cmd_parm->type_size = 0;
1316         pdrvextra_cmd_parm->pbuf = (u8 *)padapter;
1317
1318         init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1319
1320
1321         /* rtw_enqueue_cmd(pcmdpriv, ph2c); */
1322         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1323 exit:
1324         return res;
1325 }
1326
1327 u8 rtw_set_ch_cmd(struct adapter *padapter, u8 ch, u8 bw, u8 ch_offset, u8 enqueue)
1328 {
1329         struct cmd_obj *pcmdobj;
1330         struct set_ch_parm *set_ch_parm;
1331         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1332
1333         u8 res = _SUCCESS;
1334
1335
1336         DBG_88E(FUNC_NDEV_FMT" ch:%u, bw:%u, ch_offset:%u\n",
1337                 FUNC_NDEV_ARG(padapter->pnetdev), ch, bw, ch_offset);
1338
1339         /* check input parameter */
1340
1341         /* prepare cmd parameter */
1342         set_ch_parm = (struct set_ch_parm *)rtw_zmalloc(sizeof(*set_ch_parm));
1343         if (set_ch_parm == NULL) {
1344                 res = _FAIL;
1345                 goto exit;
1346         }
1347         set_ch_parm->ch = ch;
1348         set_ch_parm->bw = bw;
1349         set_ch_parm->ch_offset = ch_offset;
1350
1351         if (enqueue) {
1352                 /* need enqueue, prepare cmd_obj and enqueue */
1353                 pcmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct   cmd_obj));
1354                 if (pcmdobj == NULL) {
1355                         kfree(set_ch_parm);
1356                         res = _FAIL;
1357                         goto exit;
1358                 }
1359
1360                 init_h2fwcmd_w_parm_no_rsp(pcmdobj, set_ch_parm, GEN_CMD_CODE(_SetChannel));
1361                 res = rtw_enqueue_cmd(pcmdpriv, pcmdobj);
1362         } else {
1363                 /* no need to enqueue, do the cmd hdl directly and free cmd parameter */
1364                 if (H2C_SUCCESS != set_ch_hdl(padapter, (u8 *)set_ch_parm))
1365                         res = _FAIL;
1366
1367                 kfree(set_ch_parm);
1368         }
1369
1370         /* do something based on res... */
1371
1372 exit:
1373
1374         DBG_88E(FUNC_NDEV_FMT" res:%u\n", FUNC_NDEV_ARG(padapter->pnetdev), res);
1375
1376
1377         return res;
1378 }
1379
1380 u8 rtw_set_chplan_cmd(struct adapter *padapter, u8 chplan, u8 enqueue)
1381 {
1382         struct  cmd_obj *pcmdobj;
1383         struct  SetChannelPlan_param *setChannelPlan_param;
1384         struct  cmd_priv   *pcmdpriv = &padapter->cmdpriv;
1385
1386         u8      res = _SUCCESS;
1387
1388
1389         RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+rtw_set_chplan_cmd\n"));
1390
1391         /* check input parameter */
1392         if (!rtw_is_channel_plan_valid(chplan)) {
1393                 res = _FAIL;
1394                 goto exit;
1395         }
1396
1397         /* prepare cmd parameter */
1398         setChannelPlan_param = (struct  SetChannelPlan_param *)rtw_zmalloc(sizeof(struct SetChannelPlan_param));
1399         if (setChannelPlan_param == NULL) {
1400                 res = _FAIL;
1401                 goto exit;
1402         }
1403         setChannelPlan_param->channel_plan = chplan;
1404
1405         if (enqueue) {
1406                 /* need enqueue, prepare cmd_obj and enqueue */
1407                 pcmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct   cmd_obj));
1408                 if (pcmdobj == NULL) {
1409                         kfree(setChannelPlan_param);
1410                         res = _FAIL;
1411                         goto exit;
1412                 }
1413
1414                 init_h2fwcmd_w_parm_no_rsp(pcmdobj, setChannelPlan_param, GEN_CMD_CODE(_SetChannelPlan));
1415                 res = rtw_enqueue_cmd(pcmdpriv, pcmdobj);
1416         } else {
1417                 /* no need to enqueue, do the cmd hdl directly and free cmd parameter */
1418                 if (H2C_SUCCESS != set_chplan_hdl(padapter, (unsigned char *)setChannelPlan_param))
1419                         res = _FAIL;
1420
1421                 kfree(setChannelPlan_param);
1422         }
1423
1424         /* do something based on res... */
1425         if (res == _SUCCESS)
1426                 padapter->mlmepriv.ChannelPlan = chplan;
1427
1428 exit:
1429
1430
1431         return res;
1432 }
1433
1434 u8 rtw_set_csa_cmd(struct adapter *padapter, u8 new_ch_no)
1435 {
1436         struct  cmd_obj *pcmdobj;
1437         struct  SetChannelSwitch_param *setChannelSwitch_param;
1438         struct  cmd_priv   *pcmdpriv = &padapter->cmdpriv;
1439
1440         u8      res = _SUCCESS;
1441
1442
1443         RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+rtw_set_csa_cmd\n"));
1444
1445         pcmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct   cmd_obj));
1446         if (pcmdobj == NULL) {
1447                 res = _FAIL;
1448                 goto exit;
1449         }
1450
1451         setChannelSwitch_param = (struct SetChannelSwitch_param *)rtw_zmalloc(sizeof(struct     SetChannelSwitch_param));
1452         if (setChannelSwitch_param == NULL) {
1453                 kfree(pcmdobj);
1454                 res = _FAIL;
1455                 goto exit;
1456         }
1457
1458         setChannelSwitch_param->new_ch_no = new_ch_no;
1459
1460         init_h2fwcmd_w_parm_no_rsp(pcmdobj, setChannelSwitch_param, GEN_CMD_CODE(_SetChannelSwitch));
1461         res = rtw_enqueue_cmd(pcmdpriv, pcmdobj);
1462
1463 exit:
1464
1465
1466         return res;
1467 }
1468
1469 u8 rtw_tdls_cmd(struct adapter *padapter, u8 *addr, u8 option)
1470 {
1471         return _SUCCESS;
1472 }
1473
1474 static void traffic_status_watchdog(struct adapter *padapter)
1475 {
1476         u8      bEnterPS;
1477         u8      bBusyTraffic = false, bTxBusyTraffic = false, bRxBusyTraffic = false;
1478         u8      bHigherBusyTraffic = false, bHigherBusyRxTraffic = false, bHigherBusyTxTraffic = false;
1479         struct mlme_priv                *pmlmepriv = &(padapter->mlmepriv);
1480
1481         /*  */
1482         /*  Determine if our traffic is busy now */
1483         /*  */
1484         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
1485                 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > 100 ||
1486                     pmlmepriv->LinkDetectInfo.NumTxOkInPeriod > 100) {
1487                         bBusyTraffic = true;
1488
1489                         if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > pmlmepriv->LinkDetectInfo.NumTxOkInPeriod)
1490                                 bRxBusyTraffic = true;
1491                         else
1492                                 bTxBusyTraffic = true;
1493                 }
1494
1495                 /*  Higher Tx/Rx data. */
1496                 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > 4000 ||
1497                     pmlmepriv->LinkDetectInfo.NumTxOkInPeriod > 4000) {
1498                         bHigherBusyTraffic = true;
1499
1500                         if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > pmlmepriv->LinkDetectInfo.NumTxOkInPeriod)
1501                                 bHigherBusyRxTraffic = true;
1502                         else
1503                                 bHigherBusyTxTraffic = true;
1504                 }
1505
1506                 /*  check traffic for  powersaving. */
1507                 if (((pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod + pmlmepriv->LinkDetectInfo.NumTxOkInPeriod) > 8) ||
1508                     (pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod > 2))
1509                         bEnterPS = false;
1510                 else
1511                         bEnterPS = true;
1512
1513                 /*  LeisurePS only work in infra mode. */
1514                 if (bEnterPS)
1515                         LPS_Enter(padapter);
1516                 else
1517                         LPS_Leave(padapter);
1518         } else {
1519                 LPS_Leave(padapter);
1520         }
1521
1522         pmlmepriv->LinkDetectInfo.NumRxOkInPeriod = 0;
1523         pmlmepriv->LinkDetectInfo.NumTxOkInPeriod = 0;
1524         pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod = 0;
1525         pmlmepriv->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
1526         pmlmepriv->LinkDetectInfo.bTxBusyTraffic = bTxBusyTraffic;
1527         pmlmepriv->LinkDetectInfo.bRxBusyTraffic = bRxBusyTraffic;
1528         pmlmepriv->LinkDetectInfo.bHigherBusyTraffic = bHigherBusyTraffic;
1529         pmlmepriv->LinkDetectInfo.bHigherBusyRxTraffic = bHigherBusyRxTraffic;
1530         pmlmepriv->LinkDetectInfo.bHigherBusyTxTraffic = bHigherBusyTxTraffic;
1531 }
1532
1533 static void dynamic_chk_wk_hdl(struct adapter *padapter, u8 *pbuf, int sz)
1534 {
1535         struct mlme_priv *pmlmepriv;
1536
1537         padapter = (struct adapter *)pbuf;
1538         pmlmepriv = &(padapter->mlmepriv);
1539
1540 #ifdef CONFIG_88EU_AP_MODE
1541         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true)
1542                 expire_timeout_chk(padapter);
1543 #endif
1544
1545         rtw_hal_sreset_xmit_status_check(padapter);
1546
1547         linked_status_chk(padapter);
1548         traffic_status_watchdog(padapter);
1549
1550         rtw_hal_dm_watchdog(padapter);
1551 }
1552
1553 static void lps_ctrl_wk_hdl(struct adapter *padapter, u8 lps_ctrl_type)
1554 {
1555         struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
1556         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1557         u8      mstatus;
1558
1559
1560         if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) ||
1561             (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true))
1562                 return;
1563
1564         switch (lps_ctrl_type) {
1565         case LPS_CTRL_SCAN:
1566                 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
1567                         /* connect */
1568                         LPS_Leave(padapter);
1569                 }
1570                 break;
1571         case LPS_CTRL_JOINBSS:
1572                 LPS_Leave(padapter);
1573                 break;
1574         case LPS_CTRL_CONNECT:
1575                 mstatus = 1;/* connect */
1576                 /*  Reset LPS Setting */
1577                 padapter->pwrctrlpriv.LpsIdleCount = 0;
1578                 rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_JOINBSSRPT, (u8 *)(&mstatus));
1579                 break;
1580         case LPS_CTRL_DISCONNECT:
1581                 mstatus = 0;/* disconnect */
1582                 LPS_Leave(padapter);
1583                 rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_JOINBSSRPT, (u8 *)(&mstatus));
1584                 break;
1585         case LPS_CTRL_SPECIAL_PACKET:
1586                 /* DBG_88E("LPS_CTRL_SPECIAL_PACKET\n"); */
1587                 pwrpriv->DelayLPSLastTimeStamp = jiffies;
1588                 LPS_Leave(padapter);
1589                 break;
1590         case LPS_CTRL_LEAVE:
1591                 LPS_Leave(padapter);
1592                 break;
1593         default:
1594                 break;
1595         }
1596
1597 }
1598
1599 u8 rtw_lps_ctrl_wk_cmd(struct adapter *padapter, u8 lps_ctrl_type, u8 enqueue)
1600 {
1601         struct cmd_obj  *ph2c;
1602         struct drvextra_cmd_parm        *pdrvextra_cmd_parm;
1603         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1604         /* struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv; */
1605         u8      res = _SUCCESS;
1606
1607         if (enqueue) {
1608                 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1609                 if (ph2c == NULL) {
1610                         res = _FAIL;
1611                         goto exit;
1612                 }
1613
1614                 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1615                 if (pdrvextra_cmd_parm == NULL) {
1616                         kfree(ph2c);
1617                         res = _FAIL;
1618                         goto exit;
1619                 }
1620
1621                 pdrvextra_cmd_parm->ec_id = LPS_CTRL_WK_CID;
1622                 pdrvextra_cmd_parm->type_size = lps_ctrl_type;
1623                 pdrvextra_cmd_parm->pbuf = NULL;
1624
1625                 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1626
1627                 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1628         } else {
1629                 lps_ctrl_wk_hdl(padapter, lps_ctrl_type);
1630         }
1631
1632 exit:
1633
1634
1635         return res;
1636 }
1637
1638 static void rpt_timer_setting_wk_hdl(struct adapter *padapter, u16 min_time)
1639 {
1640         rtw_hal_set_hwreg(padapter, HW_VAR_RPT_TIMER_SETTING, (u8 *)(&min_time));
1641 }
1642
1643 u8 rtw_rpt_timer_cfg_cmd(struct adapter *padapter, u16 min_time)
1644 {
1645         struct cmd_obj          *ph2c;
1646         struct drvextra_cmd_parm        *pdrvextra_cmd_parm;
1647         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1648
1649         u8      res = _SUCCESS;
1650
1651         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1652         if (ph2c == NULL) {
1653                 res = _FAIL;
1654                 goto exit;
1655         }
1656
1657         pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1658         if (pdrvextra_cmd_parm == NULL) {
1659                 kfree(ph2c);
1660                 res = _FAIL;
1661                 goto exit;
1662         }
1663
1664         pdrvextra_cmd_parm->ec_id = RTP_TIMER_CFG_WK_CID;
1665         pdrvextra_cmd_parm->type_size = min_time;
1666         pdrvextra_cmd_parm->pbuf = NULL;
1667         init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1668         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1669 exit:
1670
1671
1672         return res;
1673 }
1674
1675 static void antenna_select_wk_hdl(struct adapter *padapter, u8 antenna)
1676 {
1677         rtw_hal_set_hwreg(padapter, HW_VAR_ANTENNA_DIVERSITY_SELECT, (u8 *)(&antenna));
1678 }
1679
1680 u8 rtw_antenna_select_cmd(struct adapter *padapter, u8 antenna, u8 enqueue)
1681 {
1682         struct cmd_obj          *ph2c;
1683         struct drvextra_cmd_parm        *pdrvextra_cmd_parm;
1684         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1685         u8      support_ant_div;
1686         u8      res = _SUCCESS;
1687
1688         rtw_hal_get_def_var(padapter, HAL_DEF_IS_SUPPORT_ANT_DIV, &support_ant_div);
1689         if (!support_ant_div)
1690                 return res;
1691
1692         if (enqueue) {
1693                 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1694                 if (ph2c == NULL) {
1695                         res = _FAIL;
1696                         goto exit;
1697                 }
1698
1699                 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1700                 if (pdrvextra_cmd_parm == NULL) {
1701                         kfree(ph2c);
1702                         res = _FAIL;
1703                         goto exit;
1704                 }
1705
1706                 pdrvextra_cmd_parm->ec_id = ANT_SELECT_WK_CID;
1707                 pdrvextra_cmd_parm->type_size = antenna;
1708                 pdrvextra_cmd_parm->pbuf = NULL;
1709                 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1710
1711                 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1712         } else {
1713                 antenna_select_wk_hdl(padapter, antenna);
1714         }
1715 exit:
1716
1717
1718         return res;
1719 }
1720
1721 static void power_saving_wk_hdl(struct adapter *padapter, u8 *pbuf, int sz)
1722 {
1723          rtw_ps_processor(padapter);
1724 }
1725
1726 #ifdef CONFIG_88EU_P2P
1727 u8 p2p_protocol_wk_cmd(struct adapter *padapter, int intCmdType)
1728 {
1729         struct cmd_obj  *ph2c;
1730         struct drvextra_cmd_parm        *pdrvextra_cmd_parm;
1731         struct wifidirect_info  *pwdinfo = &(padapter->wdinfo);
1732         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1733         u8      res = _SUCCESS;
1734
1735
1736         if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
1737                 return res;
1738
1739         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1740         if (ph2c == NULL) {
1741                 res = _FAIL;
1742                 goto exit;
1743         }
1744
1745         pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1746         if (pdrvextra_cmd_parm == NULL) {
1747                 kfree(ph2c);
1748                 res = _FAIL;
1749                 goto exit;
1750         }
1751
1752         pdrvextra_cmd_parm->ec_id = P2P_PROTO_WK_CID;
1753         pdrvextra_cmd_parm->type_size = intCmdType; /* As the command tppe. */
1754         pdrvextra_cmd_parm->pbuf = NULL;            /* Must be NULL here */
1755
1756         init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1757
1758         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1759
1760 exit:
1761
1762
1763         return res;
1764 }
1765 #endif /* CONFIG_88EU_P2P */
1766
1767 u8 rtw_ps_cmd(struct adapter *padapter)
1768 {
1769         struct cmd_obj          *ppscmd;
1770         struct drvextra_cmd_parm        *pdrvextra_cmd_parm;
1771         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1772
1773         u8      res = _SUCCESS;
1774
1775         ppscmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1776         if (ppscmd == NULL) {
1777                 res = _FAIL;
1778                 goto exit;
1779         }
1780
1781         pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1782         if (pdrvextra_cmd_parm == NULL) {
1783                 kfree(ppscmd);
1784                 res = _FAIL;
1785                 goto exit;
1786         }
1787
1788         pdrvextra_cmd_parm->ec_id = POWER_SAVING_CTRL_WK_CID;
1789         pdrvextra_cmd_parm->pbuf = NULL;
1790         init_h2fwcmd_w_parm_no_rsp(ppscmd, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1791
1792         res = rtw_enqueue_cmd(pcmdpriv, ppscmd);
1793
1794 exit:
1795
1796
1797         return res;
1798 }
1799
1800 #ifdef CONFIG_88EU_AP_MODE
1801
1802 static void rtw_chk_hi_queue_hdl(struct adapter *padapter)
1803 {
1804         int cnt = 0;
1805         struct sta_info *psta_bmc;
1806         struct sta_priv *pstapriv = &padapter->stapriv;
1807
1808         psta_bmc = rtw_get_bcmc_stainfo(padapter);
1809         if (!psta_bmc)
1810                 return;
1811
1812         if (psta_bmc->sleepq_len == 0) {
1813                 u8 val = 0;
1814
1815                 /* while ((rtw_read32(padapter, 0x414)&0x00ffff00)!= 0) */
1816                 /* while ((rtw_read32(padapter, 0x414)&0x0000ff00)!= 0) */
1817
1818                 rtw_hal_get_hwreg(padapter, HW_VAR_CHK_HI_QUEUE_EMPTY, &val);
1819
1820                 while (!val) {
1821                         msleep(100);
1822
1823                         cnt++;
1824
1825                         if (cnt > 10)
1826                                 break;
1827
1828                         rtw_hal_get_hwreg(padapter, HW_VAR_CHK_HI_QUEUE_EMPTY, &val);
1829                 }
1830
1831                 if (cnt <= 10) {
1832                         pstapriv->tim_bitmap &= ~BIT(0);
1833                         pstapriv->sta_dz_bitmap &= ~BIT(0);
1834
1835                         update_beacon(padapter, _TIM_IE_, NULL, false);
1836                 } else { /* re check again */
1837                         rtw_chk_hi_queue_cmd(padapter);
1838                 }
1839         }
1840 }
1841
1842 u8 rtw_chk_hi_queue_cmd(struct adapter *padapter)
1843 {
1844         struct cmd_obj  *ph2c;
1845         struct drvextra_cmd_parm        *pdrvextra_cmd_parm;
1846         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1847         u8      res = _SUCCESS;
1848
1849         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1850         if (ph2c == NULL) {
1851                 res = _FAIL;
1852                 goto exit;
1853         }
1854
1855         pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1856         if (pdrvextra_cmd_parm == NULL) {
1857                 kfree(ph2c);
1858                 res = _FAIL;
1859                 goto exit;
1860         }
1861
1862         pdrvextra_cmd_parm->ec_id = CHECK_HIQ_WK_CID;
1863         pdrvextra_cmd_parm->type_size = 0;
1864         pdrvextra_cmd_parm->pbuf = NULL;
1865
1866         init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1867
1868         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1869 exit:
1870         return res;
1871 }
1872 #endif
1873
1874 u8 rtw_c2h_wk_cmd(struct adapter *padapter, u8 *c2h_evt)
1875 {
1876         struct cmd_obj *ph2c;
1877         struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1878         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1879         u8      res = _SUCCESS;
1880
1881         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1882         if (ph2c == NULL) {
1883                 res = _FAIL;
1884                 goto exit;
1885         }
1886
1887         pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1888         if (pdrvextra_cmd_parm == NULL) {
1889                 kfree(ph2c);
1890                 res = _FAIL;
1891                 goto exit;
1892         }
1893
1894         pdrvextra_cmd_parm->ec_id = C2H_WK_CID;
1895         pdrvextra_cmd_parm->type_size = c2h_evt ? 16 : 0;
1896         pdrvextra_cmd_parm->pbuf = c2h_evt;
1897
1898         init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1899
1900         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1901
1902 exit:
1903
1904         return res;
1905 }
1906
1907 static s32 c2h_evt_hdl(struct adapter *adapter, struct c2h_evt_hdr *c2h_evt, c2h_id_filter filter)
1908 {
1909         s32 ret = _FAIL;
1910         u8 buf[16];
1911
1912         if (!c2h_evt) {
1913                 /* No c2h event in cmd_obj, read c2h event before handling*/
1914                 if (c2h_evt_read(adapter, buf) == _SUCCESS) {
1915                         c2h_evt = (struct c2h_evt_hdr *)buf;
1916
1917                         if (filter && filter(c2h_evt->id) == false)
1918                                 goto exit;
1919
1920                         ret = rtw_hal_c2h_handler(adapter, c2h_evt);
1921                 }
1922         } else {
1923                 if (filter && filter(c2h_evt->id) == false)
1924                         goto exit;
1925
1926                 ret = rtw_hal_c2h_handler(adapter, c2h_evt);
1927         }
1928 exit:
1929         return ret;
1930 }
1931
1932 static void c2h_wk_callback(struct work_struct *work)
1933 {
1934         struct evt_priv *evtpriv = container_of(work, struct evt_priv, c2h_wk);
1935         struct adapter *adapter = container_of(evtpriv, struct adapter, evtpriv);
1936         struct c2h_evt_hdr *c2h_evt;
1937         c2h_id_filter ccx_id_filter = rtw_hal_c2h_id_filter_ccx(adapter);
1938
1939         evtpriv->c2h_wk_alive = true;
1940
1941         while (!rtw_cbuf_empty(evtpriv->c2h_queue)) {
1942                 c2h_evt = (struct c2h_evt_hdr *)
1943                         rtw_cbuf_pop(evtpriv->c2h_queue);
1944                 if (c2h_evt != NULL)
1945                         /* This C2H event is read, clear it */
1946                         c2h_evt_clear(adapter);
1947                 else {
1948                         c2h_evt = (struct c2h_evt_hdr *)rtw_malloc(16);
1949                         /* This C2H event is not read, read & clear now */
1950                         if (c2h_evt != NULL &&
1951                             c2h_evt_read(adapter, (u8 *)c2h_evt) != _SUCCESS)
1952                                 continue;
1953                 }
1954
1955                 /* Special pointer to trigger c2h_evt_clear only */
1956                 if ((void *)c2h_evt == (void *)evtpriv)
1957                         continue;
1958
1959                 if (!c2h_evt_exist(c2h_evt)) {
1960                         kfree(c2h_evt);
1961                         continue;
1962                 }
1963
1964                 if (ccx_id_filter(c2h_evt->id) == true) {
1965                         /* Handle CCX report here */
1966                         rtw_hal_c2h_handler(adapter, c2h_evt);
1967                         kfree(c2h_evt);
1968                 } else {
1969 #ifdef CONFIG_88EU_P2P
1970                         /* Enqueue into cmd_thread for others */
1971                         rtw_c2h_wk_cmd(adapter, (u8 *)c2h_evt);
1972 #endif
1973                 }
1974         }
1975
1976         evtpriv->c2h_wk_alive = false;
1977 }
1978
1979 u8 rtw_drvextra_cmd_hdl(struct adapter *padapter, unsigned char *pbuf)
1980 {
1981         struct drvextra_cmd_parm *pdrvextra_cmd;
1982
1983         if (!pbuf)
1984                 return H2C_PARAMETERS_ERROR;
1985
1986         pdrvextra_cmd = (struct drvextra_cmd_parm *)pbuf;
1987
1988         switch (pdrvextra_cmd->ec_id) {
1989         case DYNAMIC_CHK_WK_CID:
1990                 dynamic_chk_wk_hdl(padapter, pdrvextra_cmd->pbuf, pdrvextra_cmd->type_size);
1991                 break;
1992         case POWER_SAVING_CTRL_WK_CID:
1993                 power_saving_wk_hdl(padapter, pdrvextra_cmd->pbuf, pdrvextra_cmd->type_size);
1994                 break;
1995         case LPS_CTRL_WK_CID:
1996                 lps_ctrl_wk_hdl(padapter, (u8)pdrvextra_cmd->type_size);
1997                 break;
1998         case RTP_TIMER_CFG_WK_CID:
1999                 rpt_timer_setting_wk_hdl(padapter, pdrvextra_cmd->type_size);
2000                 break;
2001         case ANT_SELECT_WK_CID:
2002                 antenna_select_wk_hdl(padapter, pdrvextra_cmd->type_size);
2003                 break;
2004 #ifdef CONFIG_88EU_P2P
2005         case P2P_PS_WK_CID:
2006                 p2p_ps_wk_hdl(padapter, pdrvextra_cmd->type_size);
2007                 break;
2008         case P2P_PROTO_WK_CID:
2009                 /*
2010                  * Commented by Albert 2011/07/01
2011                  * I used the type_size as the type command
2012                  */
2013                 p2p_protocol_wk_hdl(padapter, pdrvextra_cmd->type_size);
2014                 break;
2015 #endif
2016 #ifdef CONFIG_88EU_AP_MODE
2017         case CHECK_HIQ_WK_CID:
2018                 rtw_chk_hi_queue_hdl(padapter);
2019                 break;
2020 #endif /* CONFIG_88EU_AP_MODE */
2021         case C2H_WK_CID:
2022                 c2h_evt_hdl(padapter, (struct c2h_evt_hdr *)pdrvextra_cmd->pbuf, NULL);
2023                 break;
2024         default:
2025                 break;
2026         }
2027
2028         if (pdrvextra_cmd->pbuf && pdrvextra_cmd->type_size > 0)
2029                 kfree(pdrvextra_cmd->pbuf);
2030
2031         return H2C_SUCCESS;
2032 }
2033
2034 void rtw_survey_cmd_callback(struct adapter *padapter,  struct cmd_obj *pcmd)
2035 {
2036         struct  mlme_priv *pmlmepriv = &padapter->mlmepriv;
2037
2038
2039         if (pcmd->res == H2C_DROPPED) {
2040                 /* TODO: cancel timer and do timeout handler directly... */
2041                 /* need to make timeout handlerOS independent */
2042                 _set_timer(&pmlmepriv->scan_to_timer, 1);
2043         } else if (pcmd->res != H2C_SUCCESS) {
2044                 _set_timer(&pmlmepriv->scan_to_timer, 1);
2045                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n ********Error: MgntActrtw_set_802_11_bssid_LIST_SCAN Fail ************\n\n."));
2046         }
2047
2048         /*  free cmd */
2049         rtw_free_cmd_obj(pcmd);
2050
2051 }
2052 void rtw_disassoc_cmd_callback(struct adapter *padapter, struct cmd_obj *pcmd)
2053 {
2054         struct  mlme_priv *pmlmepriv = &padapter->mlmepriv;
2055
2056
2057         if (pcmd->res != H2C_SUCCESS) {
2058                 spin_lock_bh(&pmlmepriv->lock);
2059                 set_fwstate(pmlmepriv, _FW_LINKED);
2060                 spin_unlock_bh(&pmlmepriv->lock);
2061
2062                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n ***Error: disconnect_cmd_callback Fail ***\n."));
2063                 return;
2064         } else /* clear bridge database */
2065                 nat25_db_cleanup(padapter);
2066
2067         /*  free cmd */
2068         rtw_free_cmd_obj(pcmd);
2069 }
2070
2071 void rtw_joinbss_cmd_callback(struct adapter *padapter,  struct cmd_obj *pcmd)
2072 {
2073         struct  mlme_priv *pmlmepriv = &padapter->mlmepriv;
2074
2075
2076         if (pcmd->res == H2C_DROPPED) {
2077                 /* TODO: cancel timer and do timeout handler directly... */
2078                 /* need to make timeout handlerOS independent */
2079                 _set_timer(&pmlmepriv->assoc_timer, 1);
2080         } else if (pcmd->res != H2C_SUCCESS) {
2081                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("********Error:rtw_select_and_join_from_scanned_queue Wait Sema  Fail ************\n"));
2082                 _set_timer(&pmlmepriv->assoc_timer, 1);
2083         }
2084
2085         rtw_free_cmd_obj(pcmd);
2086
2087 }
2088
2089 void rtw_createbss_cmd_callback(struct adapter *padapter, struct cmd_obj *pcmd)
2090 {
2091         u8 timer_cancelled;
2092         struct sta_info *psta = NULL;
2093         struct wlan_network *pwlan = NULL;
2094         struct  mlme_priv *pmlmepriv = &padapter->mlmepriv;
2095         struct wlan_bssid_ex *pnetwork = (struct wlan_bssid_ex *)pcmd->parmbuf;
2096         struct wlan_network *tgt_network = &(pmlmepriv->cur_network);
2097
2098
2099         if (pcmd->res != H2C_SUCCESS) {
2100                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n ********Error: rtw_createbss_cmd_callback  Fail ************\n\n."));
2101                 _set_timer(&pmlmepriv->assoc_timer, 1);
2102         }
2103
2104         _cancel_timer(&pmlmepriv->assoc_timer, &timer_cancelled);
2105
2106         spin_lock_bh(&pmlmepriv->lock);
2107
2108         if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
2109                 psta = rtw_get_stainfo(&padapter->stapriv, pnetwork->MacAddress);
2110                 if (!psta) {
2111                         psta = rtw_alloc_stainfo(&padapter->stapriv, pnetwork->MacAddress);
2112                         if (psta == NULL) {
2113                                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\nCan't alloc sta_info when createbss_cmd_callback\n"));
2114                                 goto createbss_cmd_fail;
2115                         }
2116                 }
2117
2118                 rtw_indicate_connect(padapter);
2119         } else {
2120                 pwlan = _rtw_alloc_network(pmlmepriv);
2121                 spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
2122                 if (pwlan == NULL) {
2123                         pwlan = rtw_get_oldest_wlan_network(&pmlmepriv->scanned_queue);
2124                         if (pwlan == NULL) {
2125                                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n Error:  can't get pwlan in rtw_joinbss_event_callback\n"));
2126                                 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
2127                                 goto createbss_cmd_fail;
2128                         }
2129                         pwlan->last_scanned = jiffies;
2130                 } else {
2131                         rtw_list_insert_tail(&(pwlan->list), &pmlmepriv->scanned_queue.queue);
2132                 }
2133
2134                 pnetwork->Length = get_wlan_bssid_ex_sz(pnetwork);
2135                 memcpy(&(pwlan->network), pnetwork, pnetwork->Length);
2136
2137                 memcpy(&tgt_network->network, pnetwork, (get_wlan_bssid_ex_sz(pnetwork)));
2138
2139                 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
2140
2141                 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
2142                 /*  we will set _FW_LINKED when there is one more sat to join us (rtw_stassoc_event_callback) */
2143         }
2144
2145 createbss_cmd_fail:
2146
2147         spin_unlock_bh(&pmlmepriv->lock);
2148
2149         rtw_free_cmd_obj(pcmd);
2150
2151 }
2152
2153 void rtw_setstaKey_cmdrsp_callback(struct adapter *padapter,  struct cmd_obj *pcmd)
2154 {
2155         struct sta_priv *pstapriv = &padapter->stapriv;
2156         struct set_stakey_rsp *psetstakey_rsp = (struct set_stakey_rsp *)(pcmd->rsp);
2157         struct sta_info *psta = rtw_get_stainfo(pstapriv, psetstakey_rsp->addr);
2158
2159
2160         if (psta == NULL) {
2161                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\nERROR: rtw_setstaKey_cmdrsp_callback => can't get sta_info\n\n"));
2162                 goto exit;
2163         }
2164 exit:
2165         rtw_free_cmd_obj(pcmd);
2166 }
2167
2168 void rtw_setassocsta_cmdrsp_callback(struct adapter *padapter,  struct cmd_obj *pcmd)
2169 {
2170         struct sta_priv *pstapriv = &padapter->stapriv;
2171         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2172         struct set_assocsta_parm *passocsta_parm = (struct set_assocsta_parm *)(pcmd->parmbuf);
2173         struct set_assocsta_rsp *passocsta_rsp = (struct set_assocsta_rsp *)(pcmd->rsp);
2174         struct sta_info *psta = rtw_get_stainfo(pstapriv, passocsta_parm->addr);
2175
2176
2177         if (psta == NULL) {
2178                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\nERROR: setassocsta_cmdrsp_callbac => can't get sta_info\n\n"));
2179                 goto exit;
2180         }
2181
2182         psta->aid = passocsta_rsp->cam_id;
2183         psta->mac_id = passocsta_rsp->cam_id;
2184
2185         spin_lock_bh(&pmlmepriv->lock);
2186
2187         if ((check_fwstate(pmlmepriv, WIFI_MP_STATE) == true) && (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true))
2188                 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
2189
2190         set_fwstate(pmlmepriv, _FW_LINKED);
2191         spin_unlock_bh(&pmlmepriv->lock);
2192
2193 exit:
2194         rtw_free_cmd_obj(pcmd);
2195
2196 }