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_led_blink_cmd(struct adapter *padapter, struct LED_871x *pLed)
1435 {
1436         struct  cmd_obj *pcmdobj;
1437         struct  LedBlink_param *ledBlink_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_led_blink_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         ledBlink_param = (struct        LedBlink_param *)rtw_zmalloc(sizeof(struct      LedBlink_param));
1452         if (ledBlink_param == NULL) {
1453                 kfree(pcmdobj);
1454                 res = _FAIL;
1455                 goto exit;
1456         }
1457
1458         ledBlink_param->pLed = pLed;
1459
1460         init_h2fwcmd_w_parm_no_rsp(pcmdobj, ledBlink_param, GEN_CMD_CODE(_LedBlink));
1461         res = rtw_enqueue_cmd(pcmdpriv, pcmdobj);
1462
1463 exit:
1464
1465
1466         return res;
1467 }
1468
1469 u8 rtw_set_csa_cmd(struct adapter *padapter, u8 new_ch_no)
1470 {
1471         struct  cmd_obj *pcmdobj;
1472         struct  SetChannelSwitch_param *setChannelSwitch_param;
1473         struct  cmd_priv   *pcmdpriv = &padapter->cmdpriv;
1474
1475         u8      res = _SUCCESS;
1476
1477
1478         RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+rtw_set_csa_cmd\n"));
1479
1480         pcmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct   cmd_obj));
1481         if (pcmdobj == NULL) {
1482                 res = _FAIL;
1483                 goto exit;
1484         }
1485
1486         setChannelSwitch_param = (struct SetChannelSwitch_param *)rtw_zmalloc(sizeof(struct     SetChannelSwitch_param));
1487         if (setChannelSwitch_param == NULL) {
1488                 kfree(pcmdobj);
1489                 res = _FAIL;
1490                 goto exit;
1491         }
1492
1493         setChannelSwitch_param->new_ch_no = new_ch_no;
1494
1495         init_h2fwcmd_w_parm_no_rsp(pcmdobj, setChannelSwitch_param, GEN_CMD_CODE(_SetChannelSwitch));
1496         res = rtw_enqueue_cmd(pcmdpriv, pcmdobj);
1497
1498 exit:
1499
1500
1501         return res;
1502 }
1503
1504 u8 rtw_tdls_cmd(struct adapter *padapter, u8 *addr, u8 option)
1505 {
1506         return _SUCCESS;
1507 }
1508
1509 static void traffic_status_watchdog(struct adapter *padapter)
1510 {
1511         u8      bEnterPS;
1512         u8      bBusyTraffic = false, bTxBusyTraffic = false, bRxBusyTraffic = false;
1513         u8      bHigherBusyTraffic = false, bHigherBusyRxTraffic = false, bHigherBusyTxTraffic = false;
1514         struct mlme_priv                *pmlmepriv = &(padapter->mlmepriv);
1515
1516         /*  */
1517         /*  Determine if our traffic is busy now */
1518         /*  */
1519         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
1520                 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > 100 ||
1521                     pmlmepriv->LinkDetectInfo.NumTxOkInPeriod > 100) {
1522                         bBusyTraffic = true;
1523
1524                         if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > pmlmepriv->LinkDetectInfo.NumTxOkInPeriod)
1525                                 bRxBusyTraffic = true;
1526                         else
1527                                 bTxBusyTraffic = true;
1528                 }
1529
1530                 /*  Higher Tx/Rx data. */
1531                 if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > 4000 ||
1532                     pmlmepriv->LinkDetectInfo.NumTxOkInPeriod > 4000) {
1533                         bHigherBusyTraffic = true;
1534
1535                         if (pmlmepriv->LinkDetectInfo.NumRxOkInPeriod > pmlmepriv->LinkDetectInfo.NumTxOkInPeriod)
1536                                 bHigherBusyRxTraffic = true;
1537                         else
1538                                 bHigherBusyTxTraffic = true;
1539                 }
1540
1541                 /*  check traffic for  powersaving. */
1542                 if (((pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod + pmlmepriv->LinkDetectInfo.NumTxOkInPeriod) > 8) ||
1543                     (pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod > 2))
1544                         bEnterPS = false;
1545                 else
1546                         bEnterPS = true;
1547
1548                 /*  LeisurePS only work in infra mode. */
1549                 if (bEnterPS)
1550                         LPS_Enter(padapter);
1551                 else
1552                         LPS_Leave(padapter);
1553         } else {
1554                 LPS_Leave(padapter);
1555         }
1556
1557         pmlmepriv->LinkDetectInfo.NumRxOkInPeriod = 0;
1558         pmlmepriv->LinkDetectInfo.NumTxOkInPeriod = 0;
1559         pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod = 0;
1560         pmlmepriv->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
1561         pmlmepriv->LinkDetectInfo.bTxBusyTraffic = bTxBusyTraffic;
1562         pmlmepriv->LinkDetectInfo.bRxBusyTraffic = bRxBusyTraffic;
1563         pmlmepriv->LinkDetectInfo.bHigherBusyTraffic = bHigherBusyTraffic;
1564         pmlmepriv->LinkDetectInfo.bHigherBusyRxTraffic = bHigherBusyRxTraffic;
1565         pmlmepriv->LinkDetectInfo.bHigherBusyTxTraffic = bHigherBusyTxTraffic;
1566 }
1567
1568 static void dynamic_chk_wk_hdl(struct adapter *padapter, u8 *pbuf, int sz)
1569 {
1570         struct mlme_priv *pmlmepriv;
1571
1572         padapter = (struct adapter *)pbuf;
1573         pmlmepriv = &(padapter->mlmepriv);
1574
1575 #ifdef CONFIG_88EU_AP_MODE
1576         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true)
1577                 expire_timeout_chk(padapter);
1578 #endif
1579
1580         rtw_hal_sreset_xmit_status_check(padapter);
1581
1582         linked_status_chk(padapter);
1583         traffic_status_watchdog(padapter);
1584
1585         rtw_hal_dm_watchdog(padapter);
1586 }
1587
1588 static void lps_ctrl_wk_hdl(struct adapter *padapter, u8 lps_ctrl_type)
1589 {
1590         struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
1591         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1592         u8      mstatus;
1593
1594
1595         if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) ||
1596             (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true))
1597                 return;
1598
1599         switch (lps_ctrl_type) {
1600         case LPS_CTRL_SCAN:
1601                 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
1602                         /* connect */
1603                         LPS_Leave(padapter);
1604                 }
1605                 break;
1606         case LPS_CTRL_JOINBSS:
1607                 LPS_Leave(padapter);
1608                 break;
1609         case LPS_CTRL_CONNECT:
1610                 mstatus = 1;/* connect */
1611                 /*  Reset LPS Setting */
1612                 padapter->pwrctrlpriv.LpsIdleCount = 0;
1613                 rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_JOINBSSRPT, (u8 *)(&mstatus));
1614                 break;
1615         case LPS_CTRL_DISCONNECT:
1616                 mstatus = 0;/* disconnect */
1617                 LPS_Leave(padapter);
1618                 rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_JOINBSSRPT, (u8 *)(&mstatus));
1619                 break;
1620         case LPS_CTRL_SPECIAL_PACKET:
1621                 /* DBG_88E("LPS_CTRL_SPECIAL_PACKET\n"); */
1622                 pwrpriv->DelayLPSLastTimeStamp = jiffies;
1623                 LPS_Leave(padapter);
1624                 break;
1625         case LPS_CTRL_LEAVE:
1626                 LPS_Leave(padapter);
1627                 break;
1628         default:
1629                 break;
1630         }
1631
1632 }
1633
1634 u8 rtw_lps_ctrl_wk_cmd(struct adapter *padapter, u8 lps_ctrl_type, u8 enqueue)
1635 {
1636         struct cmd_obj  *ph2c;
1637         struct drvextra_cmd_parm        *pdrvextra_cmd_parm;
1638         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1639         /* struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv; */
1640         u8      res = _SUCCESS;
1641
1642         if (enqueue) {
1643                 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1644                 if (ph2c == NULL) {
1645                         res = _FAIL;
1646                         goto exit;
1647                 }
1648
1649                 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1650                 if (pdrvextra_cmd_parm == NULL) {
1651                         kfree(ph2c);
1652                         res = _FAIL;
1653                         goto exit;
1654                 }
1655
1656                 pdrvextra_cmd_parm->ec_id = LPS_CTRL_WK_CID;
1657                 pdrvextra_cmd_parm->type_size = lps_ctrl_type;
1658                 pdrvextra_cmd_parm->pbuf = NULL;
1659
1660                 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1661
1662                 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1663         } else {
1664                 lps_ctrl_wk_hdl(padapter, lps_ctrl_type);
1665         }
1666
1667 exit:
1668
1669
1670         return res;
1671 }
1672
1673 static void rpt_timer_setting_wk_hdl(struct adapter *padapter, u16 min_time)
1674 {
1675         rtw_hal_set_hwreg(padapter, HW_VAR_RPT_TIMER_SETTING, (u8 *)(&min_time));
1676 }
1677
1678 u8 rtw_rpt_timer_cfg_cmd(struct adapter *padapter, u16 min_time)
1679 {
1680         struct cmd_obj          *ph2c;
1681         struct drvextra_cmd_parm        *pdrvextra_cmd_parm;
1682         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1683
1684         u8      res = _SUCCESS;
1685
1686         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1687         if (ph2c == NULL) {
1688                 res = _FAIL;
1689                 goto exit;
1690         }
1691
1692         pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1693         if (pdrvextra_cmd_parm == NULL) {
1694                 kfree(ph2c);
1695                 res = _FAIL;
1696                 goto exit;
1697         }
1698
1699         pdrvextra_cmd_parm->ec_id = RTP_TIMER_CFG_WK_CID;
1700         pdrvextra_cmd_parm->type_size = min_time;
1701         pdrvextra_cmd_parm->pbuf = NULL;
1702         init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1703         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1704 exit:
1705
1706
1707         return res;
1708 }
1709
1710 static void antenna_select_wk_hdl(struct adapter *padapter, u8 antenna)
1711 {
1712         rtw_hal_set_hwreg(padapter, HW_VAR_ANTENNA_DIVERSITY_SELECT, (u8 *)(&antenna));
1713 }
1714
1715 u8 rtw_antenna_select_cmd(struct adapter *padapter, u8 antenna, u8 enqueue)
1716 {
1717         struct cmd_obj          *ph2c;
1718         struct drvextra_cmd_parm        *pdrvextra_cmd_parm;
1719         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1720         u8      support_ant_div;
1721         u8      res = _SUCCESS;
1722
1723         rtw_hal_get_def_var(padapter, HAL_DEF_IS_SUPPORT_ANT_DIV, &support_ant_div);
1724         if (!support_ant_div)
1725                 return res;
1726
1727         if (enqueue) {
1728                 ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1729                 if (ph2c == NULL) {
1730                         res = _FAIL;
1731                         goto exit;
1732                 }
1733
1734                 pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1735                 if (pdrvextra_cmd_parm == NULL) {
1736                         kfree(ph2c);
1737                         res = _FAIL;
1738                         goto exit;
1739                 }
1740
1741                 pdrvextra_cmd_parm->ec_id = ANT_SELECT_WK_CID;
1742                 pdrvextra_cmd_parm->type_size = antenna;
1743                 pdrvextra_cmd_parm->pbuf = NULL;
1744                 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1745
1746                 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1747         } else {
1748                 antenna_select_wk_hdl(padapter, antenna);
1749         }
1750 exit:
1751
1752
1753         return res;
1754 }
1755
1756 static void power_saving_wk_hdl(struct adapter *padapter, u8 *pbuf, int sz)
1757 {
1758          rtw_ps_processor(padapter);
1759 }
1760
1761 #ifdef CONFIG_88EU_P2P
1762 u8 p2p_protocol_wk_cmd(struct adapter *padapter, int intCmdType)
1763 {
1764         struct cmd_obj  *ph2c;
1765         struct drvextra_cmd_parm        *pdrvextra_cmd_parm;
1766         struct wifidirect_info  *pwdinfo = &(padapter->wdinfo);
1767         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1768         u8      res = _SUCCESS;
1769
1770
1771         if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
1772                 return res;
1773
1774         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1775         if (ph2c == NULL) {
1776                 res = _FAIL;
1777                 goto exit;
1778         }
1779
1780         pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1781         if (pdrvextra_cmd_parm == NULL) {
1782                 kfree(ph2c);
1783                 res = _FAIL;
1784                 goto exit;
1785         }
1786
1787         pdrvextra_cmd_parm->ec_id = P2P_PROTO_WK_CID;
1788         pdrvextra_cmd_parm->type_size = intCmdType; /* As the command tppe. */
1789         pdrvextra_cmd_parm->pbuf = NULL;            /* Must be NULL here */
1790
1791         init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1792
1793         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1794
1795 exit:
1796
1797
1798         return res;
1799 }
1800 #endif /* CONFIG_88EU_P2P */
1801
1802 u8 rtw_ps_cmd(struct adapter *padapter)
1803 {
1804         struct cmd_obj          *ppscmd;
1805         struct drvextra_cmd_parm        *pdrvextra_cmd_parm;
1806         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1807
1808         u8      res = _SUCCESS;
1809
1810         ppscmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1811         if (ppscmd == NULL) {
1812                 res = _FAIL;
1813                 goto exit;
1814         }
1815
1816         pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1817         if (pdrvextra_cmd_parm == NULL) {
1818                 kfree(ppscmd);
1819                 res = _FAIL;
1820                 goto exit;
1821         }
1822
1823         pdrvextra_cmd_parm->ec_id = POWER_SAVING_CTRL_WK_CID;
1824         pdrvextra_cmd_parm->pbuf = NULL;
1825         init_h2fwcmd_w_parm_no_rsp(ppscmd, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1826
1827         res = rtw_enqueue_cmd(pcmdpriv, ppscmd);
1828
1829 exit:
1830
1831
1832         return res;
1833 }
1834
1835 #ifdef CONFIG_88EU_AP_MODE
1836
1837 static void rtw_chk_hi_queue_hdl(struct adapter *padapter)
1838 {
1839         int cnt = 0;
1840         struct sta_info *psta_bmc;
1841         struct sta_priv *pstapriv = &padapter->stapriv;
1842
1843         psta_bmc = rtw_get_bcmc_stainfo(padapter);
1844         if (!psta_bmc)
1845                 return;
1846
1847         if (psta_bmc->sleepq_len == 0) {
1848                 u8 val = 0;
1849
1850                 /* while ((rtw_read32(padapter, 0x414)&0x00ffff00)!= 0) */
1851                 /* while ((rtw_read32(padapter, 0x414)&0x0000ff00)!= 0) */
1852
1853                 rtw_hal_get_hwreg(padapter, HW_VAR_CHK_HI_QUEUE_EMPTY, &val);
1854
1855                 while (!val) {
1856                         msleep(100);
1857
1858                         cnt++;
1859
1860                         if (cnt > 10)
1861                                 break;
1862
1863                         rtw_hal_get_hwreg(padapter, HW_VAR_CHK_HI_QUEUE_EMPTY, &val);
1864                 }
1865
1866                 if (cnt <= 10) {
1867                         pstapriv->tim_bitmap &= ~BIT(0);
1868                         pstapriv->sta_dz_bitmap &= ~BIT(0);
1869
1870                         update_beacon(padapter, _TIM_IE_, NULL, false);
1871                 } else { /* re check again */
1872                         rtw_chk_hi_queue_cmd(padapter);
1873                 }
1874         }
1875 }
1876
1877 u8 rtw_chk_hi_queue_cmd(struct adapter *padapter)
1878 {
1879         struct cmd_obj  *ph2c;
1880         struct drvextra_cmd_parm        *pdrvextra_cmd_parm;
1881         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1882         u8      res = _SUCCESS;
1883
1884         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1885         if (ph2c == NULL) {
1886                 res = _FAIL;
1887                 goto exit;
1888         }
1889
1890         pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1891         if (pdrvextra_cmd_parm == NULL) {
1892                 kfree(ph2c);
1893                 res = _FAIL;
1894                 goto exit;
1895         }
1896
1897         pdrvextra_cmd_parm->ec_id = CHECK_HIQ_WK_CID;
1898         pdrvextra_cmd_parm->type_size = 0;
1899         pdrvextra_cmd_parm->pbuf = NULL;
1900
1901         init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1902
1903         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1904 exit:
1905         return res;
1906 }
1907 #endif
1908
1909 u8 rtw_c2h_wk_cmd(struct adapter *padapter, u8 *c2h_evt)
1910 {
1911         struct cmd_obj *ph2c;
1912         struct drvextra_cmd_parm *pdrvextra_cmd_parm;
1913         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1914         u8      res = _SUCCESS;
1915
1916         ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
1917         if (ph2c == NULL) {
1918                 res = _FAIL;
1919                 goto exit;
1920         }
1921
1922         pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
1923         if (pdrvextra_cmd_parm == NULL) {
1924                 kfree(ph2c);
1925                 res = _FAIL;
1926                 goto exit;
1927         }
1928
1929         pdrvextra_cmd_parm->ec_id = C2H_WK_CID;
1930         pdrvextra_cmd_parm->type_size = c2h_evt ? 16 : 0;
1931         pdrvextra_cmd_parm->pbuf = c2h_evt;
1932
1933         init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
1934
1935         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1936
1937 exit:
1938
1939         return res;
1940 }
1941
1942 static s32 c2h_evt_hdl(struct adapter *adapter, struct c2h_evt_hdr *c2h_evt, c2h_id_filter filter)
1943 {
1944         s32 ret = _FAIL;
1945         u8 buf[16];
1946
1947         if (!c2h_evt) {
1948                 /* No c2h event in cmd_obj, read c2h event before handling*/
1949                 if (c2h_evt_read(adapter, buf) == _SUCCESS) {
1950                         c2h_evt = (struct c2h_evt_hdr *)buf;
1951
1952                         if (filter && filter(c2h_evt->id) == false)
1953                                 goto exit;
1954
1955                         ret = rtw_hal_c2h_handler(adapter, c2h_evt);
1956                 }
1957         } else {
1958                 if (filter && filter(c2h_evt->id) == false)
1959                         goto exit;
1960
1961                 ret = rtw_hal_c2h_handler(adapter, c2h_evt);
1962         }
1963 exit:
1964         return ret;
1965 }
1966
1967 static void c2h_wk_callback(struct work_struct *work)
1968 {
1969         struct evt_priv *evtpriv = container_of(work, struct evt_priv, c2h_wk);
1970         struct adapter *adapter = container_of(evtpriv, struct adapter, evtpriv);
1971         struct c2h_evt_hdr *c2h_evt;
1972         c2h_id_filter ccx_id_filter = rtw_hal_c2h_id_filter_ccx(adapter);
1973
1974         evtpriv->c2h_wk_alive = true;
1975
1976         while (!rtw_cbuf_empty(evtpriv->c2h_queue)) {
1977                 c2h_evt = (struct c2h_evt_hdr *)
1978                         rtw_cbuf_pop(evtpriv->c2h_queue);
1979                 if (c2h_evt != NULL)
1980                         /* This C2H event is read, clear it */
1981                         c2h_evt_clear(adapter);
1982                 else {
1983                         c2h_evt = (struct c2h_evt_hdr *)rtw_malloc(16);
1984                         /* This C2H event is not read, read & clear now */
1985                         if (c2h_evt != NULL &&
1986                             c2h_evt_read(adapter, (u8 *)c2h_evt) != _SUCCESS)
1987                                 continue;
1988                 }
1989
1990                 /* Special pointer to trigger c2h_evt_clear only */
1991                 if ((void *)c2h_evt == (void *)evtpriv)
1992                         continue;
1993
1994                 if (!c2h_evt_exist(c2h_evt)) {
1995                         kfree(c2h_evt);
1996                         continue;
1997                 }
1998
1999                 if (ccx_id_filter(c2h_evt->id) == true) {
2000                         /* Handle CCX report here */
2001                         rtw_hal_c2h_handler(adapter, c2h_evt);
2002                         kfree(c2h_evt);
2003                 } else {
2004 #ifdef CONFIG_88EU_P2P
2005                         /* Enqueue into cmd_thread for others */
2006                         rtw_c2h_wk_cmd(adapter, (u8 *)c2h_evt);
2007 #endif
2008                 }
2009         }
2010
2011         evtpriv->c2h_wk_alive = false;
2012 }
2013
2014 u8 rtw_drvextra_cmd_hdl(struct adapter *padapter, unsigned char *pbuf)
2015 {
2016         struct drvextra_cmd_parm *pdrvextra_cmd;
2017
2018         if (!pbuf)
2019                 return H2C_PARAMETERS_ERROR;
2020
2021         pdrvextra_cmd = (struct drvextra_cmd_parm *)pbuf;
2022
2023         switch (pdrvextra_cmd->ec_id) {
2024         case DYNAMIC_CHK_WK_CID:
2025                 dynamic_chk_wk_hdl(padapter, pdrvextra_cmd->pbuf, pdrvextra_cmd->type_size);
2026                 break;
2027         case POWER_SAVING_CTRL_WK_CID:
2028                 power_saving_wk_hdl(padapter, pdrvextra_cmd->pbuf, pdrvextra_cmd->type_size);
2029                 break;
2030         case LPS_CTRL_WK_CID:
2031                 lps_ctrl_wk_hdl(padapter, (u8)pdrvextra_cmd->type_size);
2032                 break;
2033         case RTP_TIMER_CFG_WK_CID:
2034                 rpt_timer_setting_wk_hdl(padapter, pdrvextra_cmd->type_size);
2035                 break;
2036         case ANT_SELECT_WK_CID:
2037                 antenna_select_wk_hdl(padapter, pdrvextra_cmd->type_size);
2038                 break;
2039 #ifdef CONFIG_88EU_P2P
2040         case P2P_PS_WK_CID:
2041                 p2p_ps_wk_hdl(padapter, pdrvextra_cmd->type_size);
2042                 break;
2043         case P2P_PROTO_WK_CID:
2044                 /*
2045                  * Commented by Albert 2011/07/01
2046                  * I used the type_size as the type command
2047                  */
2048                 p2p_protocol_wk_hdl(padapter, pdrvextra_cmd->type_size);
2049                 break;
2050 #endif
2051 #ifdef CONFIG_88EU_AP_MODE
2052         case CHECK_HIQ_WK_CID:
2053                 rtw_chk_hi_queue_hdl(padapter);
2054                 break;
2055 #endif /* CONFIG_88EU_AP_MODE */
2056         case C2H_WK_CID:
2057                 c2h_evt_hdl(padapter, (struct c2h_evt_hdr *)pdrvextra_cmd->pbuf, NULL);
2058                 break;
2059         default:
2060                 break;
2061         }
2062
2063         if (pdrvextra_cmd->pbuf && pdrvextra_cmd->type_size > 0)
2064                 kfree(pdrvextra_cmd->pbuf);
2065
2066         return H2C_SUCCESS;
2067 }
2068
2069 void rtw_survey_cmd_callback(struct adapter *padapter,  struct cmd_obj *pcmd)
2070 {
2071         struct  mlme_priv *pmlmepriv = &padapter->mlmepriv;
2072
2073
2074         if (pcmd->res == H2C_DROPPED) {
2075                 /* TODO: cancel timer and do timeout handler directly... */
2076                 /* need to make timeout handlerOS independent */
2077                 _set_timer(&pmlmepriv->scan_to_timer, 1);
2078         } else if (pcmd->res != H2C_SUCCESS) {
2079                 _set_timer(&pmlmepriv->scan_to_timer, 1);
2080                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n ********Error: MgntActrtw_set_802_11_bssid_LIST_SCAN Fail ************\n\n."));
2081         }
2082
2083         /*  free cmd */
2084         rtw_free_cmd_obj(pcmd);
2085
2086 }
2087 void rtw_disassoc_cmd_callback(struct adapter *padapter, struct cmd_obj *pcmd)
2088 {
2089         struct  mlme_priv *pmlmepriv = &padapter->mlmepriv;
2090
2091
2092         if (pcmd->res != H2C_SUCCESS) {
2093                 spin_lock_bh(&pmlmepriv->lock);
2094                 set_fwstate(pmlmepriv, _FW_LINKED);
2095                 spin_unlock_bh(&pmlmepriv->lock);
2096
2097                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n ***Error: disconnect_cmd_callback Fail ***\n."));
2098                 return;
2099         } else /* clear bridge database */
2100                 nat25_db_cleanup(padapter);
2101
2102         /*  free cmd */
2103         rtw_free_cmd_obj(pcmd);
2104 }
2105
2106 void rtw_joinbss_cmd_callback(struct adapter *padapter,  struct cmd_obj *pcmd)
2107 {
2108         struct  mlme_priv *pmlmepriv = &padapter->mlmepriv;
2109
2110
2111         if (pcmd->res == H2C_DROPPED) {
2112                 /* TODO: cancel timer and do timeout handler directly... */
2113                 /* need to make timeout handlerOS independent */
2114                 _set_timer(&pmlmepriv->assoc_timer, 1);
2115         } else if (pcmd->res != H2C_SUCCESS) {
2116                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("********Error:rtw_select_and_join_from_scanned_queue Wait Sema  Fail ************\n"));
2117                 _set_timer(&pmlmepriv->assoc_timer, 1);
2118         }
2119
2120         rtw_free_cmd_obj(pcmd);
2121
2122 }
2123
2124 void rtw_createbss_cmd_callback(struct adapter *padapter, struct cmd_obj *pcmd)
2125 {
2126         u8 timer_cancelled;
2127         struct sta_info *psta = NULL;
2128         struct wlan_network *pwlan = NULL;
2129         struct  mlme_priv *pmlmepriv = &padapter->mlmepriv;
2130         struct wlan_bssid_ex *pnetwork = (struct wlan_bssid_ex *)pcmd->parmbuf;
2131         struct wlan_network *tgt_network = &(pmlmepriv->cur_network);
2132
2133
2134         if (pcmd->res != H2C_SUCCESS) {
2135                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n ********Error: rtw_createbss_cmd_callback  Fail ************\n\n."));
2136                 _set_timer(&pmlmepriv->assoc_timer, 1);
2137         }
2138
2139         _cancel_timer(&pmlmepriv->assoc_timer, &timer_cancelled);
2140
2141         spin_lock_bh(&pmlmepriv->lock);
2142
2143         if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
2144                 psta = rtw_get_stainfo(&padapter->stapriv, pnetwork->MacAddress);
2145                 if (!psta) {
2146                         psta = rtw_alloc_stainfo(&padapter->stapriv, pnetwork->MacAddress);
2147                         if (psta == NULL) {
2148                                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\nCan't alloc sta_info when createbss_cmd_callback\n"));
2149                                 goto createbss_cmd_fail;
2150                         }
2151                 }
2152
2153                 rtw_indicate_connect(padapter);
2154         } else {
2155                 pwlan = _rtw_alloc_network(pmlmepriv);
2156                 spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
2157                 if (pwlan == NULL) {
2158                         pwlan = rtw_get_oldest_wlan_network(&pmlmepriv->scanned_queue);
2159                         if (pwlan == NULL) {
2160                                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\n Error:  can't get pwlan in rtw_joinbss_event_callback\n"));
2161                                 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
2162                                 goto createbss_cmd_fail;
2163                         }
2164                         pwlan->last_scanned = jiffies;
2165                 } else {
2166                         rtw_list_insert_tail(&(pwlan->list), &pmlmepriv->scanned_queue.queue);
2167                 }
2168
2169                 pnetwork->Length = get_wlan_bssid_ex_sz(pnetwork);
2170                 memcpy(&(pwlan->network), pnetwork, pnetwork->Length);
2171
2172                 memcpy(&tgt_network->network, pnetwork, (get_wlan_bssid_ex_sz(pnetwork)));
2173
2174                 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
2175
2176                 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
2177                 /*  we will set _FW_LINKED when there is one more sat to join us (rtw_stassoc_event_callback) */
2178         }
2179
2180 createbss_cmd_fail:
2181
2182         spin_unlock_bh(&pmlmepriv->lock);
2183
2184         rtw_free_cmd_obj(pcmd);
2185
2186 }
2187
2188 void rtw_setstaKey_cmdrsp_callback(struct adapter *padapter,  struct cmd_obj *pcmd)
2189 {
2190         struct sta_priv *pstapriv = &padapter->stapriv;
2191         struct set_stakey_rsp *psetstakey_rsp = (struct set_stakey_rsp *)(pcmd->rsp);
2192         struct sta_info *psta = rtw_get_stainfo(pstapriv, psetstakey_rsp->addr);
2193
2194
2195         if (psta == NULL) {
2196                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\nERROR: rtw_setstaKey_cmdrsp_callback => can't get sta_info\n\n"));
2197                 goto exit;
2198         }
2199 exit:
2200         rtw_free_cmd_obj(pcmd);
2201 }
2202
2203 void rtw_setassocsta_cmdrsp_callback(struct adapter *padapter,  struct cmd_obj *pcmd)
2204 {
2205         struct sta_priv *pstapriv = &padapter->stapriv;
2206         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2207         struct set_assocsta_parm *passocsta_parm = (struct set_assocsta_parm *)(pcmd->parmbuf);
2208         struct set_assocsta_rsp *passocsta_rsp = (struct set_assocsta_rsp *)(pcmd->rsp);
2209         struct sta_info *psta = rtw_get_stainfo(pstapriv, passocsta_parm->addr);
2210
2211
2212         if (psta == NULL) {
2213                 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\nERROR: setassocsta_cmdrsp_callbac => can't get sta_info\n\n"));
2214                 goto exit;
2215         }
2216
2217         psta->aid = passocsta_rsp->cam_id;
2218         psta->mac_id = passocsta_rsp->cam_id;
2219
2220         spin_lock_bh(&pmlmepriv->lock);
2221
2222         if ((check_fwstate(pmlmepriv, WIFI_MP_STATE) == true) && (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true))
2223                 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
2224
2225         set_fwstate(pmlmepriv, _FW_LINKED);
2226         spin_unlock_bh(&pmlmepriv->lock);
2227
2228 exit:
2229         rtw_free_cmd_obj(pcmd);
2230
2231 }