drivers/staging/rtl8188eu/core/rtw_mp_ioctl.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2011 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_MP_IOCTL_C_
  21
  22 #include <osdep_service.h>
  23 #include <drv_types.h>
  24 #include <mlme_osdep.h>
  25
  26 /* include <rtw_mp.h> */
  27 #include <rtw_mp_ioctl.h>
  28
  29
  30 /*   rtl8188eu_oid_rtl_seg_81_85   section start **************** */
  31 int rtl8188eu_oid_rt_wireless_mode_hdl(struct oid_par_priv *poid_par_priv)
  32 {
  33         int status = NDIS_STATUS_SUCCESS;
  34         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
  35
  36
  37         if (poid_par_priv->information_buf_len < sizeof(u8))
  38                 return NDIS_STATUS_INVALID_LENGTH;
  39
  40         if (poid_par_priv->type_of_oid == SET_OID) {
  41                 Adapter->registrypriv.wireless_mode = *(u8 *)poid_par_priv->information_buf;
  42         } else if (poid_par_priv->type_of_oid == QUERY_OID) {
  43                 *(u8 *)poid_par_priv->information_buf = Adapter->registrypriv.wireless_mode;
  44                 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
  45                  RT_TRACE(_module_mp_, _drv_info_, ("-query Wireless Mode=%d\n", Adapter->registrypriv.wireless_mode));
  46         } else {
  47                 status = NDIS_STATUS_NOT_ACCEPTED;
  48         }
  49
  50
  51         return status;
  52 }
  53 /*   rtl8188eu_oid_rtl_seg_81_87_80   section start **************** */
  54 int rtl8188eu_oid_rt_pro_write_bb_reg_hdl(struct oid_par_priv *poid_par_priv)
  55 {
  56         struct bb_reg_param *pbbreg;
  57         u16 offset;
  58         u32 value;
  59         int status = NDIS_STATUS_SUCCESS;
  60         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
  61
  62
  63         RT_TRACE(_module_mp_, _drv_notice_, ("+rtl8188eu_oid_rt_pro_write_bb_reg_hdl\n"));
  64
  65         if (poid_par_priv->type_of_oid != SET_OID)
  66                 return NDIS_STATUS_NOT_ACCEPTED;
  67
  68         if (poid_par_priv->information_buf_len < sizeof(struct bb_reg_param))
  69                 return NDIS_STATUS_INVALID_LENGTH;
  70
  71         pbbreg = (struct bb_reg_param *)(poid_par_priv->information_buf);
  72
  73         offset = (u16)(pbbreg->offset) & 0xFFF; /* 0ffset :0x800~0xfff */
  74         if (offset < BB_REG_BASE_ADDR)
  75                 offset |= BB_REG_BASE_ADDR;
  76
  77         value = pbbreg->value;
  78
  79         RT_TRACE(_module_mp_, _drv_notice_,
  80                  ("rtl8188eu_oid_rt_pro_write_bb_reg_hdl: offset=0x%03X value=0x%08X\n",
  81                   offset, value));
  82
  83         _irqlevel_changed_(&oldirql, LOWER);
  84         write_bbreg(Adapter, offset, 0xFFFFFFFF, value);
  85         _irqlevel_changed_(&oldirql, RAISE);
  86
  87
  88         return status;
  89 }
  90 /*  */
  91 int rtl8188eu_oid_rt_pro_read_bb_reg_hdl(struct oid_par_priv *poid_par_priv)
  92 {
  93         struct bb_reg_param *pbbreg;
  94         u16 offset;
  95         u32 value;
  96         int status = NDIS_STATUS_SUCCESS;
  97         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
  98
  99
 100         RT_TRACE(_module_mp_, _drv_notice_, ("+rtl8188eu_oid_rt_pro_read_bb_reg_hdl\n"));
 101
 102         if (poid_par_priv->type_of_oid != QUERY_OID)
 103                 return NDIS_STATUS_NOT_ACCEPTED;
 104
 105         if (poid_par_priv->information_buf_len < sizeof(struct bb_reg_param))
 106                 return NDIS_STATUS_INVALID_LENGTH;
 107
 108         pbbreg = (struct bb_reg_param *)(poid_par_priv->information_buf);
 109
 110         offset = (u16)(pbbreg->offset) & 0xFFF; /* 0ffset :0x800~0xfff */
 111         if (offset < BB_REG_BASE_ADDR)
 112                 offset |= BB_REG_BASE_ADDR;
 113
 114         _irqlevel_changed_(&oldirql, LOWER);
 115         value = read_bbreg(Adapter, offset, 0xFFFFFFFF);
 116         _irqlevel_changed_(&oldirql, RAISE);
 117
 118         pbbreg->value = value;
 119         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 120
 121         RT_TRACE(_module_mp_, _drv_notice_,
 122                  ("-rtl8188eu_oid_rt_pro_read_bb_reg_hdl: offset=0x%03X value:0x%08X\n",
 123                   offset, value));
 124
 125         return status;
 126 }
 127 /*  */
 128 int rtl8188eu_oid_rt_pro_write_rf_reg_hdl(struct oid_par_priv *poid_par_priv)
 129 {
 130         struct rf_reg_param *pbbreg;
 131         u8 path;
 132         u8 offset;
 133         u32 value;
 134         int status = NDIS_STATUS_SUCCESS;
 135         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 136
 137
 138         RT_TRACE(_module_mp_, _drv_notice_, ("+rtl8188eu_oid_rt_pro_write_rf_reg_hdl\n"));
 139
 140         if (poid_par_priv->type_of_oid != SET_OID)
 141                 return NDIS_STATUS_NOT_ACCEPTED;
 142
 143         if (poid_par_priv->information_buf_len < sizeof(struct rf_reg_param))
 144                 return NDIS_STATUS_INVALID_LENGTH;
 145
 146         pbbreg = (struct rf_reg_param *)(poid_par_priv->information_buf);
 147
 148         if (pbbreg->path >= MAX_RF_PATH_NUMS)
 149                 return NDIS_STATUS_NOT_ACCEPTED;
 150         if (pbbreg->offset > 0xFF)
 151                 return NDIS_STATUS_NOT_ACCEPTED;
 152         if (pbbreg->value > 0xFFFFF)
 153                 return NDIS_STATUS_NOT_ACCEPTED;
 154
 155         path = (u8)pbbreg->path;
 156         offset = (u8)pbbreg->offset;
 157         value = pbbreg->value;
 158
 159         RT_TRACE(_module_mp_, _drv_notice_,
 160                  ("rtl8188eu_oid_rt_pro_write_rf_reg_hdl: path=%d offset=0x%02X value=0x%05X\n",
 161                   path, offset, value));
 162
 163         _irqlevel_changed_(&oldirql, LOWER);
 164         write_rfreg(Adapter, path, offset, value);
 165         _irqlevel_changed_(&oldirql, RAISE);
 166
 167
 168         return status;
 169 }
 170 /*  */
 171 int rtl8188eu_oid_rt_pro_read_rf_reg_hdl(struct oid_par_priv *poid_par_priv)
 172 {
 173         struct rf_reg_param *pbbreg;
 174         u8 path;
 175         u8 offset;
 176         u32 value;
 177         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 178         int status = NDIS_STATUS_SUCCESS;
 179
 180
 181         RT_TRACE(_module_mp_, _drv_notice_, ("+rtl8188eu_oid_rt_pro_read_rf_reg_hdl\n"));
 182
 183         if (poid_par_priv->type_of_oid != QUERY_OID)
 184                 return NDIS_STATUS_NOT_ACCEPTED;
 185
 186         if (poid_par_priv->information_buf_len < sizeof(struct rf_reg_param))
 187                 return NDIS_STATUS_INVALID_LENGTH;
 188
 189         pbbreg = (struct rf_reg_param *)(poid_par_priv->information_buf);
 190
 191         if (pbbreg->path >= MAX_RF_PATH_NUMS)
 192                 return NDIS_STATUS_NOT_ACCEPTED;
 193         if (pbbreg->offset > 0xFF)
 194                 return NDIS_STATUS_NOT_ACCEPTED;
 195
 196         path = (u8)pbbreg->path;
 197         offset = (u8)pbbreg->offset;
 198
 199         _irqlevel_changed_(&oldirql, LOWER);
 200         value = read_rfreg(Adapter, path, offset);
 201         _irqlevel_changed_(&oldirql, RAISE);
 202
 203         pbbreg->value = value;
 204
 205         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 206
 207         RT_TRACE(_module_mp_, _drv_notice_,
 208                  ("-rtl8188eu_oid_rt_pro_read_rf_reg_hdl: path=%d offset=0x%02X value=0x%05X\n",
 209                   path, offset, value));
 210
 211
 212         return status;
 213 }
 214 /*   rtl8188eu_oid_rtl_seg_81_87_00   section end**************** */
 215 /*  */
 216
 217 /*   rtl8188eu_oid_rtl_seg_81_80_00   section start **************** */
 218 /*  */
 219 int rtl8188eu_oid_rt_pro_set_data_rate_hdl(struct oid_par_priv *poid_par_priv)
 220 {
 221         u32             ratevalue;/* 4 */
 222         int status = NDIS_STATUS_SUCCESS;
 223         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 224
 225
 226         RT_TRACE(_module_mp_, _drv_notice_,
 227                  ("+rtl8188eu_oid_rt_pro_set_data_rate_hdl\n"));
 228
 229         if (poid_par_priv->type_of_oid != SET_OID)
 230                 return NDIS_STATUS_NOT_ACCEPTED;
 231
 232         if (poid_par_priv->information_buf_len != sizeof(u32))
 233                 return NDIS_STATUS_INVALID_LENGTH;
 234
 235         ratevalue = *((u32 *)poid_par_priv->information_buf);/* 4 */
 236         RT_TRACE(_module_mp_, _drv_notice_,
 237                  ("rtl8188eu_oid_rt_pro_set_data_rate_hdl: data rate idx=%d\n", ratevalue));
 238         if (ratevalue >= MPT_RATE_LAST)
 239                 return NDIS_STATUS_INVALID_DATA;
 240
 241         Adapter->mppriv.rateidx = ratevalue;
 242
 243         _irqlevel_changed_(&oldirql, LOWER);
 244         SetDataRate(Adapter);
 245         _irqlevel_changed_(&oldirql, RAISE);
 246
 247
 248         return status;
 249 }
 250 /*  */
 251 int rtl8188eu_oid_rt_pro_start_test_hdl(struct oid_par_priv *poid_par_priv)
 252 {
 253         u32             mode;
 254         int status = NDIS_STATUS_SUCCESS;
 255         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 256
 257
 258         RT_TRACE(_module_mp_, _drv_notice_, ("+rtl8188eu_oid_rt_pro_start_test_hdl\n"));
 259
 260         if (Adapter->registrypriv.mp_mode == 0)
 261                 return NDIS_STATUS_NOT_ACCEPTED;
 262
 263         if (poid_par_priv->type_of_oid != SET_OID)
 264                 return NDIS_STATUS_NOT_ACCEPTED;
 265
 266         _irqlevel_changed_(&oldirql, LOWER);
 267
 268         /* IQCalibrateBcut(Adapter); */
 269
 270         mode = *((u32 *)poid_par_priv->information_buf);
 271         Adapter->mppriv.mode = mode;/*  1 for loopback */
 272
 273         if (mp_start_test(Adapter) == _FAIL) {
 274                 status = NDIS_STATUS_NOT_ACCEPTED;
 275                 goto exit;
 276         }
 277
 278 exit:
 279         _irqlevel_changed_(&oldirql, RAISE);
 280
 281         RT_TRACE(_module_mp_, _drv_notice_, ("-rtl8188eu_oid_rt_pro_start_test_hdl: mp_mode=%d\n", Adapter->mppriv.mode));
 282
 283
 284         return status;
 285 }
 286 /*  */
 287 int rtl8188eu_oid_rt_pro_stop_test_hdl(struct oid_par_priv *poid_par_priv)
 288 {
 289         int status = NDIS_STATUS_SUCCESS;
 290         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 291
 292
 293         RT_TRACE(_module_mp_, _drv_notice_, ("+Set OID_RT_PRO_STOP_TEST\n"));
 294
 295         if (poid_par_priv->type_of_oid != SET_OID)
 296                 return NDIS_STATUS_NOT_ACCEPTED;
 297
 298         _irqlevel_changed_(&oldirql, LOWER);
 299         mp_stop_test(Adapter);
 300         _irqlevel_changed_(&oldirql, RAISE);
 301
 302         RT_TRACE(_module_mp_, _drv_notice_, ("-Set OID_RT_PRO_STOP_TEST\n"));
 303
 304
 305         return status;
 306 }
 307 /*  */
 308 int rtl8188eu_oid_rt_pro_set_channel_direct_call_hdl(struct oid_par_priv *poid_par_priv)
 309 {
 310         u32             Channel;
 311         int status = NDIS_STATUS_SUCCESS;
 312         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 313
 314
 315         RT_TRACE(_module_mp_, _drv_notice_, ("+rtl8188eu_oid_rt_pro_set_channel_direct_call_hdl\n"));
 316
 317         if (poid_par_priv->information_buf_len != sizeof(u32))
 318                 return NDIS_STATUS_INVALID_LENGTH;
 319
 320         if (poid_par_priv->type_of_oid == QUERY_OID) {
 321                 *((u32 *)poid_par_priv->information_buf) = Adapter->mppriv.channel;
 322                 return NDIS_STATUS_SUCCESS;
 323         }
 324
 325         if (poid_par_priv->type_of_oid != SET_OID)
 326                 return NDIS_STATUS_NOT_ACCEPTED;
 327
 328         Channel = *((u32 *)poid_par_priv->information_buf);
 329         RT_TRACE(_module_mp_, _drv_notice_, ("rtl8188eu_oid_rt_pro_set_channel_direct_call_hdl: Channel=%d\n", Channel));
 330         if (Channel > 14)
 331                 return NDIS_STATUS_NOT_ACCEPTED;
 332         Adapter->mppriv.channel = Channel;
 333
 334         _irqlevel_changed_(&oldirql, LOWER);
 335         SetChannel(Adapter);
 336         _irqlevel_changed_(&oldirql, RAISE);
 337
 338
 339         return status;
 340 }
 341 /*  */
 342 int rtl8188eu_oid_rt_set_bandwidth_hdl(struct oid_par_priv *poid_par_priv)
 343 {
 344         u16             bandwidth;
 345         u16             channel_offset;
 346         int status = NDIS_STATUS_SUCCESS;
 347         struct adapter *padapter = (struct adapter *)(poid_par_priv->adapter_context);
 348
 349
 350         RT_TRACE(_module_mp_, _drv_info_,
 351                  ("+rtl8188eu_oid_rt_set_bandwidth_hdl\n"));
 352
 353         if (poid_par_priv->type_of_oid != SET_OID)
 354                 return NDIS_STATUS_NOT_ACCEPTED;
 355
 356         if (poid_par_priv->information_buf_len < sizeof(u32))
 357                 return NDIS_STATUS_INVALID_LENGTH;
 358
 359         bandwidth = *((u32 *)poid_par_priv->information_buf);/* 4 */
 360         channel_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
 361
 362         if (bandwidth != HT_CHANNEL_WIDTH_40)
 363                 bandwidth = HT_CHANNEL_WIDTH_20;
 364         padapter->mppriv.bandwidth = (u8)bandwidth;
 365         padapter->mppriv.prime_channel_offset = (u8)channel_offset;
 366
 367         _irqlevel_changed_(&oldirql, LOWER);
 368         SetBandwidth(padapter);
 369         _irqlevel_changed_(&oldirql, RAISE);
 370
 371         RT_TRACE(_module_mp_, _drv_notice_,
 372                  ("-rtl8188eu_oid_rt_set_bandwidth_hdl: bandwidth=%d channel_offset=%d\n",
 373                   bandwidth, channel_offset));
 374
 375
 376         return status;
 377 }
 378 /*  */
 379 int rtl8188eu_oid_rt_pro_set_antenna_bb_hdl(struct oid_par_priv *poid_par_priv)
 380 {
 381         u32             antenna;
 382         int status = NDIS_STATUS_SUCCESS;
 383         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 384
 385
 386         RT_TRACE(_module_mp_, _drv_notice_, ("+rtl8188eu_oid_rt_pro_set_antenna_bb_hdl\n"));
 387
 388         if (poid_par_priv->information_buf_len != sizeof(u32))
 389                 return NDIS_STATUS_INVALID_LENGTH;
 390
 391         if (poid_par_priv->type_of_oid == SET_OID) {
 392                 antenna = *(u32 *)poid_par_priv->information_buf;
 393
 394                 Adapter->mppriv.antenna_tx = (u16)((antenna & 0xFFFF0000) >> 16);
 395                 Adapter->mppriv.antenna_rx = (u16)(antenna & 0x0000FFFF);
 396                 RT_TRACE(_module_mp_, _drv_notice_,
 397                          ("rtl8188eu_oid_rt_pro_set_antenna_bb_hdl: tx_ant=0x%04x rx_ant=0x%04x\n",
 398                           Adapter->mppriv.antenna_tx, Adapter->mppriv.antenna_rx));
 399
 400                 _irqlevel_changed_(&oldirql, LOWER);
 401                 SetAntenna(Adapter);
 402                 _irqlevel_changed_(&oldirql, RAISE);
 403         } else {
 404                 antenna = (Adapter->mppriv.antenna_tx << 16)|Adapter->mppriv.antenna_rx;
 405                 *(u32 *)poid_par_priv->information_buf = antenna;
 406         }
 407
 408
 409         return status;
 410 }
 411
 412 int rtl8188eu_oid_rt_pro_set_tx_power_control_hdl(struct oid_par_priv *poid_par_priv)
 413 {
 414         u32             tx_pwr_idx;
 415         int status = NDIS_STATUS_SUCCESS;
 416         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 417
 418
 419         RT_TRACE(_module_mp_, _drv_info_, ("+rtl8188eu_oid_rt_pro_set_tx_power_control_hdl\n"));
 420
 421         if (poid_par_priv->type_of_oid != SET_OID)
 422                 return NDIS_STATUS_NOT_ACCEPTED;
 423
 424         if (poid_par_priv->information_buf_len != sizeof(u32))
 425                 return NDIS_STATUS_INVALID_LENGTH;
 426
 427         tx_pwr_idx = *((u32 *)poid_par_priv->information_buf);
 428         if (tx_pwr_idx > MAX_TX_PWR_INDEX_N_MODE)
 429                 return NDIS_STATUS_NOT_ACCEPTED;
 430
 431         Adapter->mppriv.txpoweridx = (u8)tx_pwr_idx;
 432
 433         RT_TRACE(_module_mp_, _drv_notice_,
 434                  ("rtl8188eu_oid_rt_pro_set_tx_power_control_hdl: idx=0x%2x\n",
 435                   Adapter->mppriv.txpoweridx));
 436
 437         _irqlevel_changed_(&oldirql, LOWER);
 438         SetTxPower(Adapter);
 439         _irqlevel_changed_(&oldirql, RAISE);
 440
 441
 442         return status;
 443 }
 444
 445 /*  */
 446 /*   rtl8188eu_oid_rtl_seg_81_80_20   section start **************** */
 447 /*  */
 448 int rtl8188eu_oid_rt_pro_query_tx_packet_sent_hdl(struct oid_par_priv *poid_par_priv)
 449 {
 450         int status = NDIS_STATUS_SUCCESS;
 451         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 452
 453
 454         if (poid_par_priv->type_of_oid != QUERY_OID) {
 455                 status = NDIS_STATUS_NOT_ACCEPTED;
 456                 return status;
 457         }
 458
 459         if (poid_par_priv->information_buf_len == sizeof(u32)) {
 460                 *(u32 *)poid_par_priv->information_buf =  Adapter->mppriv.tx_pktcount;
 461                 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 462         } else {
 463                 status = NDIS_STATUS_INVALID_LENGTH;
 464         }
 465
 466
 467         return status;
 468 }
 469 /*  */
 470 int rtl8188eu_oid_rt_pro_query_rx_packet_received_hdl(struct oid_par_priv *poid_par_priv)
 471 {
 472         int status = NDIS_STATUS_SUCCESS;
 473         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 474
 475
 476         if (poid_par_priv->type_of_oid != QUERY_OID) {
 477                 status = NDIS_STATUS_NOT_ACCEPTED;
 478                 return status;
 479         }
 480         RT_TRACE(_module_mp_, _drv_alert_, ("===> rtl8188eu_oid_rt_pro_query_rx_packet_received_hdl.\n"));
 481         if (poid_par_priv->information_buf_len == sizeof(u32)) {
 482                 *(u32 *)poid_par_priv->information_buf =  Adapter->mppriv.rx_pktcount;
 483                 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 484                 RT_TRACE(_module_mp_, _drv_alert_, ("recv_ok:%d\n", Adapter->mppriv.rx_pktcount));
 485         } else {
 486                 status = NDIS_STATUS_INVALID_LENGTH;
 487         }
 488
 489
 490         return status;
 491 }
 492 /*  */
 493 int rtl8188eu_oid_rt_pro_query_rx_packet_crc32_error_hdl(struct oid_par_priv *poid_par_priv)
 494 {
 495         int status = NDIS_STATUS_SUCCESS;
 496         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 497
 498
 499         if (poid_par_priv->type_of_oid != QUERY_OID) {
 500                 status = NDIS_STATUS_NOT_ACCEPTED;
 501                 return status;
 502         }
 503         RT_TRACE(_module_mp_, _drv_alert_, ("===> rtl8188eu_oid_rt_pro_query_rx_packet_crc32_error_hdl.\n"));
 504         if (poid_par_priv->information_buf_len == sizeof(u32)) {
 505                 *(u32 *)poid_par_priv->information_buf =  Adapter->mppriv.rx_crcerrpktcount;
 506                 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 507                 RT_TRACE(_module_mp_, _drv_alert_, ("recv_err:%d\n", Adapter->mppriv.rx_crcerrpktcount));
 508         } else {
 509                 status = NDIS_STATUS_INVALID_LENGTH;
 510         }
 511
 512
 513         return status;
 514 }
 515 /*  */
 516
 517 int rtl8188eu_oid_rt_pro_reset_tx_packet_sent_hdl(struct oid_par_priv *poid_par_priv)
 518 {
 519         int status = NDIS_STATUS_SUCCESS;
 520         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 521
 522
 523         if (poid_par_priv->type_of_oid != SET_OID) {
 524                 status = NDIS_STATUS_NOT_ACCEPTED;
 525                 return status;
 526         }
 527
 528         RT_TRACE(_module_mp_, _drv_alert_, ("===> rtl8188eu_oid_rt_pro_reset_tx_packet_sent_hdl.\n"));
 529         Adapter->mppriv.tx_pktcount = 0;
 530
 531
 532         return status;
 533 }
 534 /*  */
 535 int rtl8188eu_oid_rt_pro_reset_rx_packet_received_hdl(struct oid_par_priv *poid_par_priv)
 536 {
 537         int status = NDIS_STATUS_SUCCESS;
 538         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 539
 540
 541         if (poid_par_priv->type_of_oid != SET_OID) {
 542                 status = NDIS_STATUS_NOT_ACCEPTED;
 543                 return status;
 544         }
 545
 546         if (poid_par_priv->information_buf_len == sizeof(u32)) {
 547                 Adapter->mppriv.rx_pktcount = 0;
 548                 Adapter->mppriv.rx_crcerrpktcount = 0;
 549         } else {
 550                 status = NDIS_STATUS_INVALID_LENGTH;
 551         }
 552
 553
 554         return status;
 555 }
 556 /*  */
 557 int rtl8188eu_oid_rt_reset_phy_rx_packet_count_hdl(struct oid_par_priv *poid_par_priv)
 558 {
 559         int status = NDIS_STATUS_SUCCESS;
 560         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 561
 562
 563         if (poid_par_priv->type_of_oid != SET_OID) {
 564                 status = NDIS_STATUS_NOT_ACCEPTED;
 565                 return status;
 566         }
 567
 568         _irqlevel_changed_(&oldirql, LOWER);
 569         ResetPhyRxPktCount(Adapter);
 570         _irqlevel_changed_(&oldirql, RAISE);
 571
 572
 573         return status;
 574 }
 575 /*  */
 576 int rtl8188eu_oid_rt_get_phy_rx_packet_received_hdl(struct oid_par_priv *poid_par_priv)
 577 {
 578         int status = NDIS_STATUS_SUCCESS;
 579         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 580
 581
 582         RT_TRACE(_module_mp_, _drv_info_, ("+rtl8188eu_oid_rt_get_phy_rx_packet_received_hdl\n"));
 583
 584         if (poid_par_priv->type_of_oid != QUERY_OID)
 585                 return NDIS_STATUS_NOT_ACCEPTED;
 586
 587         if (poid_par_priv->information_buf_len != sizeof(u32))
 588                 return NDIS_STATUS_INVALID_LENGTH;
 589
 590         _irqlevel_changed_(&oldirql, LOWER);
 591         *(u32 *)poid_par_priv->information_buf = GetPhyRxPktReceived(Adapter);
 592         _irqlevel_changed_(&oldirql, RAISE);
 593
 594         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 595
 596         RT_TRACE(_module_mp_, _drv_notice_, ("-rtl8188eu_oid_rt_get_phy_rx_packet_received_hdl: recv_ok=%d\n", *(u32 *)poid_par_priv->information_buf));
 597
 598
 599         return status;
 600 }
 601 /*  */
 602 int rtl8188eu_oid_rt_get_phy_rx_packet_crc32_error_hdl(struct oid_par_priv *poid_par_priv)
 603 {
 604         int status = NDIS_STATUS_SUCCESS;
 605         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 606
 607
 608         RT_TRACE(_module_mp_, _drv_info_, ("+rtl8188eu_oid_rt_get_phy_rx_packet_crc32_error_hdl\n"));
 609
 610         if (poid_par_priv->type_of_oid != QUERY_OID)
 611                 return NDIS_STATUS_NOT_ACCEPTED;
 612
 613
 614         if (poid_par_priv->information_buf_len != sizeof(u32))
 615                 return NDIS_STATUS_INVALID_LENGTH;
 616
 617         _irqlevel_changed_(&oldirql, LOWER);
 618         *(u32 *)poid_par_priv->information_buf = GetPhyRxPktCRC32Error(Adapter);
 619         _irqlevel_changed_(&oldirql, RAISE);
 620
 621         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 622
 623         RT_TRACE(_module_mp_, _drv_info_,
 624                  ("-rtl8188eu_oid_rt_get_phy_rx_packet_crc32_error_hdl: recv_err =%d\n",
 625                  *(u32 *)poid_par_priv->information_buf));
 626
 627
 628         return status;
 629 }
 630 /*   rtl8188eu_oid_rtl_seg_81_80_20   section end **************** */
 631 int rtl8188eu_oid_rt_pro_set_continuous_tx_hdl(struct oid_par_priv *poid_par_priv)
 632 {
 633         u32             bStartTest;
 634         int status = NDIS_STATUS_SUCCESS;
 635         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 636
 637
 638         RT_TRACE(_module_mp_, _drv_notice_, ("+rtl8188eu_oid_rt_pro_set_continuous_tx_hdl\n"));
 639
 640         if (poid_par_priv->type_of_oid != SET_OID)
 641                 return NDIS_STATUS_NOT_ACCEPTED;
 642
 643         bStartTest = *((u32 *)poid_par_priv->information_buf);
 644
 645         _irqlevel_changed_(&oldirql, LOWER);
 646         SetContinuousTx(Adapter, (u8)bStartTest);
 647         if (bStartTest) {
 648                 struct mp_priv *pmp_priv = &Adapter->mppriv;
 649                 if (pmp_priv->tx.stop == 0) {
 650                         pmp_priv->tx.stop = 1;
 651                         DBG_88E("%s: pkt tx is running...\n", __func__);
 652                         msleep(5);
 653                 }
 654                 pmp_priv->tx.stop = 0;
 655                 pmp_priv->tx.count = 1;
 656                 SetPacketTx(Adapter);
 657         }
 658         _irqlevel_changed_(&oldirql, RAISE);
 659
 660
 661         return status;
 662 }
 663
 664 int rtl8188eu_oid_rt_pro_set_single_carrier_tx_hdl(struct oid_par_priv *poid_par_priv)
 665 {
 666         u32             bStartTest;
 667         int status = NDIS_STATUS_SUCCESS;
 668         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 669
 670
 671         RT_TRACE(_module_mp_, _drv_alert_, ("+rtl8188eu_oid_rt_pro_set_single_carrier_tx_hdl\n"));
 672
 673         if (poid_par_priv->type_of_oid != SET_OID)
 674                 return NDIS_STATUS_NOT_ACCEPTED;
 675
 676         bStartTest = *((u32 *)poid_par_priv->information_buf);
 677
 678         _irqlevel_changed_(&oldirql, LOWER);
 679         SetSingleCarrierTx(Adapter, (u8)bStartTest);
 680         if (bStartTest) {
 681                 struct mp_priv *pmp_priv = &Adapter->mppriv;
 682                 if (pmp_priv->tx.stop == 0) {
 683                         pmp_priv->tx.stop = 1;
 684                         DBG_88E("%s: pkt tx is running...\n", __func__);
 685                         msleep(5);
 686                 }
 687                 pmp_priv->tx.stop = 0;
 688                 pmp_priv->tx.count = 1;
 689                 SetPacketTx(Adapter);
 690         }
 691         _irqlevel_changed_(&oldirql, RAISE);
 692
 693
 694         return status;
 695 }
 696
 697 int rtl8188eu_oid_rt_pro_set_carrier_suppression_tx_hdl(struct oid_par_priv *poid_par_priv)
 698 {
 699         u32             bStartTest;
 700         int status = NDIS_STATUS_SUCCESS;
 701         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 702
 703
 704         RT_TRACE(_module_mp_, _drv_notice_, ("+rtl8188eu_oid_rt_pro_set_carrier_suppression_tx_hdl\n"));
 705
 706         if (poid_par_priv->type_of_oid != SET_OID)
 707                 return NDIS_STATUS_NOT_ACCEPTED;
 708
 709         bStartTest = *((u32 *)poid_par_priv->information_buf);
 710
 711         _irqlevel_changed_(&oldirql, LOWER);
 712         SetCarrierSuppressionTx(Adapter, (u8)bStartTest);
 713         if (bStartTest) {
 714                 struct mp_priv *pmp_priv = &Adapter->mppriv;
 715                 if (pmp_priv->tx.stop == 0) {
 716                         pmp_priv->tx.stop = 1;
 717                         DBG_88E("%s: pkt tx is running...\n", __func__);
 718                         msleep(5);
 719                 }
 720                 pmp_priv->tx.stop = 0;
 721                 pmp_priv->tx.count = 1;
 722                 SetPacketTx(Adapter);
 723         }
 724         _irqlevel_changed_(&oldirql, RAISE);
 725
 726
 727         return status;
 728 }
 729
 730 int rtl8188eu_oid_rt_pro_set_single_tone_tx_hdl(struct oid_par_priv *poid_par_priv)
 731 {
 732         u32             bStartTest;
 733         int status = NDIS_STATUS_SUCCESS;
 734         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 735
 736
 737         RT_TRACE(_module_mp_, _drv_alert_, ("+rtl8188eu_oid_rt_pro_set_single_tone_tx_hdl\n"));
 738
 739         if (poid_par_priv->type_of_oid != SET_OID)
 740                 return NDIS_STATUS_NOT_ACCEPTED;
 741
 742         bStartTest = *((u32 *)poid_par_priv->information_buf);
 743
 744         _irqlevel_changed_(&oldirql, LOWER);
 745         SetSingleToneTx(Adapter, (u8)bStartTest);
 746         _irqlevel_changed_(&oldirql, RAISE);
 747
 748
 749         return status;
 750 }
 751
 752 int rtl8188eu_oid_rt_pro_set_modulation_hdl(struct oid_par_priv *poid_par_priv)
 753 {
 754         return 0;
 755 }
 756
 757 int rtl8188eu_oid_rt_pro_trigger_gpio_hdl(struct oid_par_priv *poid_par_priv)
 758 {
 759         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 760         int status = NDIS_STATUS_SUCCESS;
 761
 762         if (poid_par_priv->type_of_oid != SET_OID)
 763                 return NDIS_STATUS_NOT_ACCEPTED;
 764
 765         _irqlevel_changed_(&oldirql, LOWER);
 766         rtw_hal_set_hwreg(Adapter, HW_VAR_TRIGGER_GPIO_0, NULL);
 767         _irqlevel_changed_(&oldirql, RAISE);
 768
 769
 770         return status;
 771 }
 772 /*   rtl8188eu_oid_rtl_seg_81_80_00   section end **************** */
 773 /*  */
 774 int rtl8188eu_oid_rt_pro8711_join_bss_hdl(struct oid_par_priv *poid_par_priv)
 775 {
 776         return 0;
 777 }
 778 /*  */
 779 int rtl8188eu_oid_rt_pro_read_register_hdl(struct oid_par_priv *poid_par_priv)
 780 {
 781         struct mp_rw_reg *RegRWStruct;
 782         u32             offset, width;
 783         int status = NDIS_STATUS_SUCCESS;
 784         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 785
 786
 787         RT_TRACE(_module_mp_, _drv_info_,
 788                  ("+rtl8188eu_oid_rt_pro_read_register_hdl\n"));
 789
 790         if (poid_par_priv->type_of_oid != QUERY_OID)
 791                 return NDIS_STATUS_NOT_ACCEPTED;
 792
 793         RegRWStruct = (struct mp_rw_reg *)poid_par_priv->information_buf;
 794         offset = RegRWStruct->offset;
 795         width = RegRWStruct->width;
 796
 797         if (offset > 0xFFF)
 798                 return NDIS_STATUS_NOT_ACCEPTED;
 799
 800         _irqlevel_changed_(&oldirql, LOWER);
 801
 802         switch (width) {
 803         case 1:
 804                 RegRWStruct->value = rtw_read8(Adapter, offset);
 805                 break;
 806         case 2:
 807                 RegRWStruct->value = rtw_read16(Adapter, offset);
 808                 break;
 809         default:
 810                 width = 4;
 811                 RegRWStruct->value = rtw_read32(Adapter, offset);
 812                 break;
 813         }
 814         RT_TRACE(_module_mp_, _drv_notice_,
 815                  ("rtl8188eu_oid_rt_pro_read_register_hdl: offset:0x%04X value:0x%X\n",
 816                   offset, RegRWStruct->value));
 817
 818         _irqlevel_changed_(&oldirql, RAISE);
 819
 820         *poid_par_priv->bytes_rw = width;
 821
 822
 823         return status;
 824 }
 825 /*  */
 826 int rtl8188eu_oid_rt_pro_write_register_hdl(struct oid_par_priv *poid_par_priv)
 827 {
 828         struct mp_rw_reg *RegRWStruct;
 829         u32             offset, width, value;
 830         int status = NDIS_STATUS_SUCCESS;
 831         struct adapter *padapter = (struct adapter *)(poid_par_priv->adapter_context);
 832
 833
 834         RT_TRACE(_module_mp_, _drv_info_,
 835                  ("+rtl8188eu_oid_rt_pro_write_register_hdl\n"));
 836
 837         if (poid_par_priv->type_of_oid != SET_OID)
 838                 return NDIS_STATUS_NOT_ACCEPTED;
 839
 840         RegRWStruct = (struct mp_rw_reg *)poid_par_priv->information_buf;
 841         offset = RegRWStruct->offset;
 842         width = RegRWStruct->width;
 843         value = RegRWStruct->value;
 844
 845         if (offset > 0xFFF)
 846                 return NDIS_STATUS_NOT_ACCEPTED;
 847
 848         _irqlevel_changed_(&oldirql, LOWER);
 849
 850         switch (RegRWStruct->width) {
 851         case 1:
 852                 if (value > 0xFF) {
 853                         status = NDIS_STATUS_NOT_ACCEPTED;
 854                         break;
 855                 }
 856                 rtw_write8(padapter, offset, (u8)value);
 857                 break;
 858         case 2:
 859                 if (value > 0xFFFF) {
 860                         status = NDIS_STATUS_NOT_ACCEPTED;
 861                         break;
 862                 }
 863                 rtw_write16(padapter, offset, (u16)value);
 864                 break;
 865         case 4:
 866                 rtw_write32(padapter, offset, value);
 867                 break;
 868         default:
 869                 status = NDIS_STATUS_NOT_ACCEPTED;
 870                 break;
 871         }
 872
 873         _irqlevel_changed_(&oldirql, RAISE);
 874
 875         RT_TRACE(_module_mp_, _drv_info_,
 876                  ("-rtl8188eu_oid_rt_pro_write_register_hdl: offset=0x%08X width=%d value=0x%X\n",
 877                   offset, width, value));
 878
 879
 880         return status;
 881 }
 882 /*  */
 883 int rtl8188eu_oid_rt_pro_burst_read_register_hdl(struct oid_par_priv *poid_par_priv)
 884 {
 885         return 0;
 886 }
 887 /*  */
 888 int rtl8188eu_oid_rt_pro_burst_write_register_hdl(struct oid_par_priv *poid_par_priv)
 889 {
 890         return 0;
 891 }
 892 /*  */
 893 int rtl8188eu_oid_rt_pro_write_txcmd_hdl(struct oid_par_priv *poid_par_priv)
 894 {
 895         return 0;
 896 }
 897
 898 /*  */
 899 int rtl8188eu_oid_rt_pro_read16_eeprom_hdl(struct oid_par_priv *poid_par_priv)
 900 {
 901         return 0;
 902 }
 903
 904 /*  */
 905 int rtl8188eu_oid_rt_pro_write16_eeprom_hdl (struct oid_par_priv *poid_par_priv)
 906 {
 907         return 0;
 908 }
 909 /*  */
 910 int rtl8188eu_oid_rt_pro8711_wi_poll_hdl(struct oid_par_priv *poid_par_priv)
 911 {
 912         return 0;
 913 }
 914 /*  */
 915 int rtl8188eu_oid_rt_pro8711_pkt_loss_hdl(struct oid_par_priv *poid_par_priv)
 916 {
 917         return 0;
 918 }
 919 /*  */
 920 int rtl8188eu_oid_rt_rd_attrib_mem_hdl(struct oid_par_priv *poid_par_priv)
 921 {
 922         return 0;
 923 }
 924 /*  */
 925 int rtl8188eu_oid_rt_wr_attrib_mem_hdl (struct oid_par_priv *poid_par_priv)
 926 {
 927         return 0;
 928 }
 929 /*  */
 930 int  rtl8188eu_oid_rt_pro_set_rf_intfs_hdl(struct oid_par_priv *poid_par_priv)
 931 {
 932         return 0;
 933 }
 934 /*  */
 935 int rtl8188eu_oid_rt_poll_rx_status_hdl(struct oid_par_priv *poid_par_priv)
 936 {
 937         return 0;
 938 }
 939 /*  */
 940 int rtl8188eu_oid_rt_pro_cfg_debug_message_hdl(struct oid_par_priv *poid_par_priv)
 941 {
 942         return 0;
 943 }
 944 /*  */
 945 int rtl8188eu_oid_rt_pro_set_data_rate_ex_hdl(struct oid_par_priv *poid_par_priv)
 946 {
 947         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 948
 949         int status = NDIS_STATUS_SUCCESS;
 950
 951
 952         RT_TRACE(_module_mp_, _drv_notice_, ("+OID_RT_PRO_SET_DATA_RATE_EX\n"));
 953
 954         if (poid_par_priv->type_of_oid != SET_OID)
 955                 return NDIS_STATUS_NOT_ACCEPTED;
 956
 957         _irqlevel_changed_(&oldirql, LOWER);
 958
 959         if (rtw_setdatarate_cmd(Adapter, poid_par_priv->information_buf) != _SUCCESS)
 960                 status = NDIS_STATUS_NOT_ACCEPTED;
 961
 962         _irqlevel_changed_(&oldirql, RAISE);
 963
 964
 965         return status;
 966 }
 967 /*  */
 968 int rtl8188eu_oid_rt_get_thermal_meter_hdl(struct oid_par_priv *poid_par_priv)
 969 {
 970         int status = NDIS_STATUS_SUCCESS;
 971         u8 thermal = 0;
 972         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
 973
 974
 975         RT_TRACE(_module_mp_, _drv_notice_, ("+rtl8188eu_oid_rt_get_thermal_meter_hdl\n"));
 976
 977         if (poid_par_priv->type_of_oid != QUERY_OID)
 978                 return NDIS_STATUS_NOT_ACCEPTED;
 979
 980         if (poid_par_priv->information_buf_len < sizeof(u32))
 981                 return NDIS_STATUS_INVALID_LENGTH;
 982
 983         _irqlevel_changed_(&oldirql, LOWER);
 984         GetThermalMeter(Adapter, &thermal);
 985         _irqlevel_changed_(&oldirql, RAISE);
 986
 987         *(u32 *)poid_par_priv->information_buf = (u32)thermal;
 988         *poid_par_priv->bytes_rw = sizeof(u32);
 989
 990
 991         return status;
 992 }
 993 /*  */
 994 int rtl8188eu_oid_rt_pro_read_tssi_hdl(struct oid_par_priv *poid_par_priv)
 995 {
 996         return 0;
 997 }
 998 /*  */
 999 int rtl8188eu_oid_rt_pro_set_power_tracking_hdl(struct oid_par_priv *poid_par_priv)
1000 {
1001         int status = NDIS_STATUS_SUCCESS;
1002         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
1003
1004
1005
1006         if (poid_par_priv->information_buf_len < sizeof(u8))
1007                 return NDIS_STATUS_INVALID_LENGTH;
1008
1009         _irqlevel_changed_(&oldirql, LOWER);
1010         if (poid_par_priv->type_of_oid == SET_OID) {
1011                 u8 enable;
1012
1013                 enable = *(u8 *)poid_par_priv->information_buf;
1014                 RT_TRACE(_module_mp_, _drv_notice_,
1015                          ("+rtl8188eu_oid_rt_pro_set_power_tracking_hdl: enable =%d\n", enable));
1016
1017                 SetPowerTracking(Adapter, enable);
1018         } else {
1019                 GetPowerTracking(Adapter, (u8 *)poid_par_priv->information_buf);
1020         }
1021         _irqlevel_changed_(&oldirql, RAISE);
1022
1023
1024         return status;
1025 }
1026 /*  */
1027 int rtl8188eu_oid_rt_pro_set_basic_rate_hdl(struct oid_par_priv *poid_par_priv)
1028 {
1029         return 0;
1030 }
1031 /*  */
1032 int rtl8188eu_oid_rt_pro_qry_pwrstate_hdl(struct oid_par_priv *poid_par_priv)
1033 {
1034         return 0;
1035 }
1036 /*  */
1037 int rtl8188eu_oid_rt_pro_set_pwrstate_hdl(struct oid_par_priv *poid_par_priv)
1038 {
1039         return 0;
1040 }
1041 /*  */
1042 int rtl8188eu_oid_rt_pro_h2c_set_rate_table_hdl(struct oid_par_priv *poid_par_priv)
1043 {
1044         return 0;
1045 }
1046 /*  */
1047 int rtl8188eu_oid_rt_pro_h2c_get_rate_table_hdl(struct oid_par_priv *poid_par_priv)
1048 {
1049         return 0;
1050 }
1051
1052 /*   rtl8188eu_oid_rtl_seg_87_12_00   section start **************** */
1053 int rtl8188eu_oid_rt_pro_encryption_ctrl_hdl(struct oid_par_priv *poid_par_priv)
1054 {
1055         return 0;
1056 }
1057
1058 int rtl8188eu_oid_rt_pro_add_sta_info_hdl(struct oid_par_priv *poid_par_priv)
1059 {
1060         return 0;
1061 }
1062
1063 int rtl8188eu_oid_rt_pro_dele_sta_info_hdl(struct oid_par_priv *poid_par_priv)
1064 {
1065         return 0;
1066 }
1067
1068 int rtl8188eu_oid_rt_pro_query_dr_variable_hdl(struct oid_par_priv *poid_par_priv)
1069 {
1070         return 0;
1071 }
1072
1073 int rtl8188eu_oid_rt_pro_rx_packet_type_hdl(struct oid_par_priv *poid_par_priv)
1074 {
1075         return NDIS_STATUS_SUCCESS;
1076 }
1077 /*  */
1078 int rtl8188eu_oid_rt_pro_read_efuse_hdl(struct oid_par_priv *poid_par_priv)
1079 {
1080         struct efuse_access_struct *pefuse;
1081         u8 *data;
1082         u16 addr = 0, cnts = 0, max_available_size = 0;
1083         int status = NDIS_STATUS_SUCCESS;
1084         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
1085
1086
1087         if (poid_par_priv->type_of_oid != QUERY_OID)
1088                 return NDIS_STATUS_NOT_ACCEPTED;
1089
1090         if (poid_par_priv->information_buf_len < sizeof(struct efuse_access_struct))
1091                 return NDIS_STATUS_INVALID_LENGTH;
1092
1093         pefuse = (struct efuse_access_struct *)poid_par_priv->information_buf;
1094         addr = pefuse->start_addr;
1095         cnts = pefuse->cnts;
1096         data = pefuse->data;
1097
1098         RT_TRACE(_module_mp_, _drv_notice_,
1099                  ("+rtl8188eu_oid_rt_pro_read_efuse_hd: buf_len=%d addr=%d cnts=%d\n",
1100                   poid_par_priv->information_buf_len, addr, cnts));
1101
1102         EFUSE_GetEfuseDefinition(Adapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false);
1103
1104         if ((addr + cnts) > max_available_size) {
1105                 RT_TRACE(_module_mp_, _drv_err_, ("!rtl8188eu_oid_rt_pro_read_efuse_hdl: parameter error!\n"));
1106                 return NDIS_STATUS_NOT_ACCEPTED;
1107         }
1108
1109         _irqlevel_changed_(&oldirql, LOWER);
1110         if (rtw_efuse_access(Adapter, false, addr, cnts, data) == _FAIL) {
1111                 RT_TRACE(_module_mp_, _drv_err_, ("!rtl8188eu_oid_rt_pro_read_efuse_hdl: rtw_efuse_access FAIL!\n"));
1112                 status = NDIS_STATUS_FAILURE;
1113         } else {
1114                 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
1115         }
1116         _irqlevel_changed_(&oldirql, RAISE);
1117
1118
1119         return status;
1120 }
1121 /*  */
1122 int rtl8188eu_oid_rt_pro_write_efuse_hdl(struct oid_par_priv *poid_par_priv)
1123 {
1124         struct efuse_access_struct *pefuse;
1125         u8 *data;
1126         u16 addr = 0, cnts = 0, max_available_size = 0;
1127         int status = NDIS_STATUS_SUCCESS;
1128         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
1129
1130
1131
1132         if (poid_par_priv->type_of_oid != SET_OID)
1133                 return NDIS_STATUS_NOT_ACCEPTED;
1134
1135         pefuse = (struct efuse_access_struct *)poid_par_priv->information_buf;
1136         addr = pefuse->start_addr;
1137         cnts = pefuse->cnts;
1138         data = pefuse->data;
1139
1140         RT_TRACE(_module_mp_, _drv_notice_,
1141                  ("+rtl8188eu_oid_rt_pro_write_efuse_hdl: buf_len=%d addr=0x%04x cnts=%d\n",
1142                   poid_par_priv->information_buf_len, addr, cnts));
1143
1144         EFUSE_GetEfuseDefinition(Adapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false);
1145
1146         if ((addr + cnts) > max_available_size) {
1147                 RT_TRACE(_module_mp_, _drv_err_, ("!rtl8188eu_oid_rt_pro_write_efuse_hdl: parameter error"));
1148                 return NDIS_STATUS_NOT_ACCEPTED;
1149         }
1150
1151         _irqlevel_changed_(&oldirql, LOWER);
1152         if (rtw_efuse_access(Adapter, true, addr, cnts, data) == _FAIL)
1153                 status = NDIS_STATUS_FAILURE;
1154         _irqlevel_changed_(&oldirql, RAISE);
1155
1156
1157         return status;
1158 }
1159 /*  */
1160 int rtl8188eu_oid_rt_pro_rw_efuse_pgpkt_hdl(struct oid_par_priv *poid_par_priv)
1161 {
1162         struct pgpkt *ppgpkt;
1163         int status = NDIS_STATUS_SUCCESS;
1164         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
1165
1166
1167         *poid_par_priv->bytes_rw = 0;
1168
1169         if (poid_par_priv->information_buf_len < sizeof(struct pgpkt *))
1170                 return NDIS_STATUS_INVALID_LENGTH;
1171
1172         ppgpkt = (struct pgpkt *)poid_par_priv->information_buf;
1173
1174         _irqlevel_changed_(&oldirql, LOWER);
1175
1176         if (poid_par_priv->type_of_oid == QUERY_OID) {
1177                 RT_TRACE(_module_mp_, _drv_notice_,
1178                          ("rtl8188eu_oid_rt_pro_rw_efuse_pgpkt_hdl: Read offset=0x%x\n",\
1179                          ppgpkt->offset));
1180
1181                 Efuse_PowerSwitch(Adapter, false, true);
1182                 if (Efuse_PgPacketRead(Adapter, ppgpkt->offset, ppgpkt->data, false) == true)
1183                         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
1184                 else
1185                         status = NDIS_STATUS_FAILURE;
1186                 Efuse_PowerSwitch(Adapter, false, false);
1187         } else {
1188                 RT_TRACE(_module_mp_, _drv_notice_,
1189                          ("rtl8188eu_oid_rt_pro_rw_efuse_pgpkt_hdl: Write offset=0x%x word_en=0x%x\n",\
1190                          ppgpkt->offset, ppgpkt->word_en));
1191
1192                 Efuse_PowerSwitch(Adapter, true, true);
1193                 if (Efuse_PgPacketWrite(Adapter, ppgpkt->offset, ppgpkt->word_en, ppgpkt->data, false) == true)
1194                         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
1195                 else
1196                         status = NDIS_STATUS_FAILURE;
1197                 Efuse_PowerSwitch(Adapter, true, false);
1198         }
1199
1200         _irqlevel_changed_(&oldirql, RAISE);
1201
1202         RT_TRACE(_module_mp_, _drv_info_,
1203                  ("-rtl8188eu_oid_rt_pro_rw_efuse_pgpkt_hdl: status=0x%08X\n", status));
1204
1205
1206         return status;
1207 }
1208 /*  */
1209 int rtl8188eu_oid_rt_get_efuse_current_size_hdl(struct oid_par_priv *poid_par_priv)
1210 {
1211         u16 size;
1212         u8 ret;
1213         int status = NDIS_STATUS_SUCCESS;
1214         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
1215
1216
1217         if (poid_par_priv->type_of_oid != QUERY_OID)
1218                 return NDIS_STATUS_NOT_ACCEPTED;
1219
1220         if (poid_par_priv->information_buf_len < sizeof(u32))
1221                 return NDIS_STATUS_INVALID_LENGTH;
1222
1223         _irqlevel_changed_(&oldirql, LOWER);
1224         ret = efuse_GetCurrentSize(Adapter, &size);
1225         _irqlevel_changed_(&oldirql, RAISE);
1226         if (ret == _SUCCESS) {
1227                 *(u32 *)poid_par_priv->information_buf = size;
1228                 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
1229         } else {
1230                 status = NDIS_STATUS_FAILURE;
1231         }
1232
1233         return status;
1234 }
1235 /*  */
1236 int rtl8188eu_oid_rt_get_efuse_max_size_hdl(struct oid_par_priv *poid_par_priv)
1237 {
1238         int status = NDIS_STATUS_SUCCESS;
1239         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
1240
1241
1242         if (poid_par_priv->type_of_oid != QUERY_OID)
1243                 return NDIS_STATUS_NOT_ACCEPTED;
1244
1245         if (poid_par_priv->information_buf_len < sizeof(u32))
1246                 return NDIS_STATUS_INVALID_LENGTH;
1247
1248         *(u32 *)poid_par_priv->information_buf = efuse_GetMaxSize(Adapter);
1249         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
1250
1251         RT_TRACE(_module_mp_, _drv_info_,
1252                  ("-rtl8188eu_oid_rt_get_efuse_max_size_hdl: size=%d status=0x%08X\n",
1253                   *(int *)poid_par_priv->information_buf, status));
1254
1255
1256         return status;
1257 }
1258 /*  */
1259 int rtl8188eu_oid_rt_pro_efuse_hdl(struct oid_par_priv *poid_par_priv)
1260 {
1261         int status;
1262
1263
1264         RT_TRACE(_module_mp_, _drv_info_, ("+rtl8188eu_oid_rt_pro_efuse_hdl\n"));
1265
1266         if (poid_par_priv->type_of_oid == QUERY_OID)
1267                 status = rtl8188eu_oid_rt_pro_read_efuse_hdl(poid_par_priv);
1268         else
1269                 status = rtl8188eu_oid_rt_pro_write_efuse_hdl(poid_par_priv);
1270
1271         RT_TRACE(_module_mp_, _drv_info_, ("-rtl8188eu_oid_rt_pro_efuse_hdl: status=0x%08X\n", status));
1272
1273
1274         return status;
1275 }
1276 /*  */
1277 int rtl8188eu_oid_rt_pro_efuse_map_hdl(struct oid_par_priv *poid_par_priv)
1278 {
1279         u8              *data;
1280         int status = NDIS_STATUS_SUCCESS;
1281         struct adapter *Adapter = (struct adapter *)(poid_par_priv->adapter_context);
1282         u16     maplen = 0;
1283
1284
1285         RT_TRACE(_module_mp_, _drv_notice_, ("+rtl8188eu_oid_rt_pro_efuse_map_hdl\n"));
1286
1287         EFUSE_GetEfuseDefinition(Adapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (void *)&maplen, false);
1288
1289         *poid_par_priv->bytes_rw = 0;
1290
1291         if (poid_par_priv->information_buf_len < maplen)
1292                 return NDIS_STATUS_INVALID_LENGTH;
1293
1294         data = (u8 *)poid_par_priv->information_buf;
1295
1296         _irqlevel_changed_(&oldirql, LOWER);
1297
1298         if (poid_par_priv->type_of_oid == QUERY_OID) {
1299                 RT_TRACE(_module_mp_, _drv_info_,
1300                          ("rtl8188eu_oid_rt_pro_efuse_map_hdl: READ\n"));
1301
1302                 if (rtw_efuse_map_read(Adapter, 0, maplen, data) == _SUCCESS) {
1303                         *poid_par_priv->bytes_rw = maplen;
1304                 } else {
1305                         RT_TRACE(_module_mp_, _drv_err_,
1306                                  ("rtl8188eu_oid_rt_pro_efuse_map_hdl: READ fail\n"));
1307                         status = NDIS_STATUS_FAILURE;
1308                 }
1309         } else {
1310                 /*  SET_OID */
1311                 RT_TRACE(_module_mp_, _drv_info_,
1312                          ("rtl8188eu_oid_rt_pro_efuse_map_hdl: WRITE\n"));
1313
1314                 if (rtw_efuse_map_write(Adapter, 0, maplen, data) == _SUCCESS) {
1315                         *poid_par_priv->bytes_rw = maplen;
1316                 } else {
1317                         RT_TRACE(_module_mp_, _drv_err_,
1318                                  ("rtl8188eu_oid_rt_pro_efuse_map_hdl: WRITE fail\n"));
1319                         status = NDIS_STATUS_FAILURE;
1320                 }
1321         }
1322
1323         _irqlevel_changed_(&oldirql, RAISE);
1324
1325         RT_TRACE(_module_mp_, _drv_info_,
1326                  ("-rtl8188eu_oid_rt_pro_efuse_map_hdl: status=0x%08X\n", status));
1327
1328
1329         return status;
1330 }
1331
1332 int rtl8188eu_oid_rt_set_crystal_cap_hdl(struct oid_par_priv *poid_par_priv)
1333 {
1334         int status = NDIS_STATUS_SUCCESS;
1335         return status;
1336 }
1337
1338 int rtl8188eu_oid_rt_set_rx_packet_type_hdl(struct oid_par_priv *poid_par_priv)
1339 {
1340         u8              rx_pkt_type;
1341         int status = NDIS_STATUS_SUCCESS;
1342
1343
1344         RT_TRACE(_module_mp_, _drv_notice_, ("+rtl8188eu_oid_rt_set_rx_packet_type_hdl\n"));
1345
1346         if (poid_par_priv->type_of_oid != SET_OID)
1347                 return NDIS_STATUS_NOT_ACCEPTED;
1348
1349         if (poid_par_priv->information_buf_len < sizeof(u8))
1350                 return NDIS_STATUS_INVALID_LENGTH;
1351
1352         rx_pkt_type = *((u8 *)poid_par_priv->information_buf);/* 4 */
1353
1354         RT_TRACE(_module_mp_, _drv_info_, ("rx_pkt_type: %x\n", rx_pkt_type));
1355
1356         return status;
1357 }
1358
1359 int rtl8188eu_oid_rt_pro_set_tx_agc_offset_hdl(struct oid_par_priv *poid_par_priv)
1360 {
1361         return 0;
1362 }
1363
1364 int rtl8188eu_oid_rt_pro_set_pkt_test_mode_hdl(struct oid_par_priv *poid_par_priv)
1365 {
1366         return 0;
1367 }
1368
1369 int rtl8188eu_mp_ioctl_xmit_packet_hdl(struct oid_par_priv *poid_par_priv)
1370 {
1371         struct mp_xmit_parm *pparm;
1372         struct adapter *padapter;
1373         struct mp_priv *pmp_priv;
1374         struct pkt_attrib *pattrib;
1375
1376         RT_TRACE(_module_mp_, _drv_notice_, ("+%s\n", __func__));
1377
1378         pparm = (struct mp_xmit_parm *)poid_par_priv->information_buf;
1379         padapter = (struct adapter *)poid_par_priv->adapter_context;
1380         pmp_priv = &padapter->mppriv;
1381
1382         if (poid_par_priv->type_of_oid == QUERY_OID) {
1383                 pparm->enable = !pmp_priv->tx.stop;
1384                 pparm->count = pmp_priv->tx.sended;
1385         } else {
1386                 if (pparm->enable == 0) {
1387                         pmp_priv->tx.stop = 1;
1388                 } else if (pmp_priv->tx.stop == 1) {
1389                         pmp_priv->tx.stop = 0;
1390                         pmp_priv->tx.count = pparm->count;
1391                         pmp_priv->tx.payload = pparm->payload_type;
1392                         pattrib = &pmp_priv->tx.attrib;
1393                         pattrib->pktlen = pparm->length;
1394                         memcpy(pattrib->dst, pparm->da, ETH_ALEN);
1395                         SetPacketTx(padapter);
1396                 } else {
1397                         return NDIS_STATUS_FAILURE;
1398                 }
1399         }
1400
1401         return NDIS_STATUS_SUCCESS;
1402 }
1403
1404 /*  */
1405 int rtl8188eu_oid_rt_set_power_down_hdl(struct oid_par_priv *poid_par_priv)
1406 {
1407         int status = NDIS_STATUS_SUCCESS;
1408
1409
1410         if (poid_par_priv->type_of_oid != SET_OID) {
1411                 status = NDIS_STATUS_NOT_ACCEPTED;
1412                 return status;
1413         }
1414
1415         RT_TRACE(_module_mp_, _drv_info_,
1416                  ("\n ===> Setrtl8188eu_oid_rt_set_power_down_hdl.\n"));
1417
1418         _irqlevel_changed_(&oldirql, LOWER);
1419
1420         /* CALL  the power_down function */
1421         _irqlevel_changed_(&oldirql, RAISE);
1422
1423
1424         return status;
1425 }
1426 /*  */
1427 int rtl8188eu_oid_rt_get_power_mode_hdl(struct oid_par_priv *poid_par_priv)
1428 {
1429         return 0;
1430 }