drivers/net/wireless/rockchip_wlan/rtl8723bu/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 <drv_types.h>
  23 #include <rtw_mp_ioctl.h>
  24 #include "../hal/OUTSRC/phydm_precomp.h"
  25
  26 //****************  oid_rtl_seg_81_85   section start ****************
  27 NDIS_STATUS oid_rt_wireless_mode_hdl(struct oid_par_priv *poid_par_priv)
  28 {
  29         NDIS_STATUS status = NDIS_STATUS_SUCCESS;
  30         PADAPTER Adapter = (PADAPTER)(poid_par_priv->adapter_context);
  31
  32 _func_enter_;
  33
  34         if (poid_par_priv->information_buf_len < sizeof(u8))
  35                 return NDIS_STATUS_INVALID_LENGTH;
  36
  37         if (poid_par_priv->type_of_oid == SET_OID) {
  38                 Adapter->registrypriv.wireless_mode = *(u8*)poid_par_priv->information_buf;
  39         } else if (poid_par_priv->type_of_oid == QUERY_OID) {
  40                 *(u8*)poid_par_priv->information_buf = Adapter->registrypriv.wireless_mode;
  41                 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
  42                  RT_TRACE(_module_mp_, _drv_info_, ("-query Wireless Mode=%d\n", Adapter->registrypriv.wireless_mode));
  43         } else {
  44                 status = NDIS_STATUS_NOT_ACCEPTED;
  45         }
  46
  47 _func_exit_;
  48
  49         return status;
  50 }
  51 //****************  oid_rtl_seg_81_87_80   section start ****************
  52 NDIS_STATUS oid_rt_pro_write_bb_reg_hdl(struct oid_par_priv *poid_par_priv)
  53 {
  54 #ifdef PLATFORM_OS_XP
  55         _irqL oldirql;
  56 #endif
  57         struct bb_reg_param *pbbreg;
  58         u16 offset;
  59         u32 value;
  60         NDIS_STATUS status = NDIS_STATUS_SUCCESS;
  61         PADAPTER Adapter = (PADAPTER)(poid_par_priv->adapter_context);
  62
  63 _func_enter_;
  64
  65         RT_TRACE(_module_mp_, _drv_notice_, ("+oid_rt_pro_write_bb_reg_hdl\n"));
  66
  67         if (poid_par_priv->type_of_oid != SET_OID)
  68                 return NDIS_STATUS_NOT_ACCEPTED;
  69
  70         if (poid_par_priv->information_buf_len < sizeof(struct bb_reg_param))
  71                 return NDIS_STATUS_INVALID_LENGTH;
  72
  73         pbbreg = (struct bb_reg_param *)(poid_par_priv->information_buf);
  74
  75         offset = (u16)(pbbreg->offset) & 0xFFF; //0ffset :0x800~0xfff
  76         if (offset < BB_REG_BASE_ADDR) offset |= BB_REG_BASE_ADDR;
  77
  78         value = pbbreg->value;
  79
  80         RT_TRACE(_module_mp_, _drv_notice_,
  81                  ("oid_rt_pro_write_bb_reg_hdl: offset=0x%03X value=0x%08X\n",
  82                   offset, value));
  83
  84         _irqlevel_changed_(&oldirql, LOWER);
  85         write_bbreg(Adapter, offset, 0xFFFFFFFF, value);
  86         _irqlevel_changed_(&oldirql, RAISE);
  87
  88 _func_exit_;
  89
  90         return status;
  91 }
  92 //------------------------------------------------------------------------------
  93 NDIS_STATUS oid_rt_pro_read_bb_reg_hdl(struct oid_par_priv *poid_par_priv)
  94 {
  95 #ifdef PLATFORM_OS_XP
  96         _irqL oldirql;
  97 #endif
  98         struct bb_reg_param *pbbreg;
  99         u16 offset;
 100         u32 value;
 101         NDIS_STATUS status = NDIS_STATUS_SUCCESS;
 102         PADAPTER Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 103
 104 _func_enter_;
 105
 106         RT_TRACE(_module_mp_, _drv_notice_, ("+oid_rt_pro_read_bb_reg_hdl\n"));
 107
 108         if (poid_par_priv->type_of_oid != QUERY_OID)
 109                 return NDIS_STATUS_NOT_ACCEPTED;
 110
 111         if (poid_par_priv->information_buf_len < sizeof(struct bb_reg_param))
 112                 return NDIS_STATUS_INVALID_LENGTH;
 113
 114         pbbreg = (struct bb_reg_param *)(poid_par_priv->information_buf);
 115
 116         offset = (u16)(pbbreg->offset) & 0xFFF; //0ffset :0x800~0xfff
 117         if (offset < BB_REG_BASE_ADDR) offset |= BB_REG_BASE_ADDR;
 118
 119         _irqlevel_changed_(&oldirql, LOWER);
 120         value = read_bbreg(Adapter, offset, 0xFFFFFFFF);
 121         _irqlevel_changed_(&oldirql, RAISE);
 122
 123         pbbreg->value = value;
 124         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 125
 126         RT_TRACE(_module_mp_, _drv_notice_,
 127                  ("-oid_rt_pro_read_bb_reg_hdl: offset=0x%03X value:0x%08X\n",
 128                   offset, value));
 129 _func_exit_;
 130
 131         return status;
 132 }
 133 //------------------------------------------------------------------------------
 134 NDIS_STATUS oid_rt_pro_write_rf_reg_hdl(struct oid_par_priv *poid_par_priv)
 135 {
 136 #ifdef PLATFORM_OS_XP
 137         _irqL oldirql;
 138 #endif
 139         struct rf_reg_param *pbbreg;
 140         u8 path;
 141         u8 offset;
 142         u32 value;
 143         NDIS_STATUS status = NDIS_STATUS_SUCCESS;
 144         PADAPTER Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 145
 146 _func_enter_;
 147
 148         RT_TRACE(_module_mp_, _drv_notice_, ("+oid_rt_pro_write_rf_reg_hdl\n"));
 149
 150         if (poid_par_priv->type_of_oid != SET_OID)
 151                 return NDIS_STATUS_NOT_ACCEPTED;
 152
 153         if (poid_par_priv->information_buf_len < sizeof(struct rf_reg_param))
 154                 return NDIS_STATUS_INVALID_LENGTH;
 155
 156         pbbreg = (struct rf_reg_param *)(poid_par_priv->information_buf);
 157
 158         if (pbbreg->path >= MAX_RF_PATH_NUMS)
 159                 return NDIS_STATUS_NOT_ACCEPTED;
 160         if (pbbreg->offset > 0xFF)
 161                 return NDIS_STATUS_NOT_ACCEPTED;
 162         if (pbbreg->value > 0xFFFFF)
 163                 return NDIS_STATUS_NOT_ACCEPTED;
 164
 165         path = (u8)pbbreg->path;
 166         offset = (u8)pbbreg->offset;
 167         value = pbbreg->value;
 168
 169         RT_TRACE(_module_mp_, _drv_notice_,
 170                  ("oid_rt_pro_write_rf_reg_hdl: path=%d offset=0x%02X value=0x%05X\n",
 171                   path, offset, value));
 172
 173         _irqlevel_changed_(&oldirql, LOWER);
 174         write_rfreg(Adapter, path, offset, value);
 175         _irqlevel_changed_(&oldirql, RAISE);
 176
 177 _func_exit_;
 178
 179         return status;
 180 }
 181 //------------------------------------------------------------------------------
 182 NDIS_STATUS oid_rt_pro_read_rf_reg_hdl(struct oid_par_priv *poid_par_priv)
 183 {
 184 #ifdef PLATFORM_OS_XP
 185         _irqL oldirql;
 186 #endif
 187         struct rf_reg_param *pbbreg;
 188         u8 path;
 189         u8 offset;
 190         u32 value;
 191         PADAPTER Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 192         NDIS_STATUS status = NDIS_STATUS_SUCCESS;
 193
 194 _func_enter_;
 195
 196         RT_TRACE(_module_mp_, _drv_notice_, ("+oid_rt_pro_read_rf_reg_hdl\n"));
 197
 198         if (poid_par_priv->type_of_oid != QUERY_OID)
 199                 return NDIS_STATUS_NOT_ACCEPTED;
 200
 201         if (poid_par_priv->information_buf_len < sizeof(struct rf_reg_param))
 202                 return NDIS_STATUS_INVALID_LENGTH;
 203
 204         pbbreg = (struct rf_reg_param *)(poid_par_priv->information_buf);
 205
 206         if (pbbreg->path >= MAX_RF_PATH_NUMS)
 207                 return NDIS_STATUS_NOT_ACCEPTED;
 208         if (pbbreg->offset > 0xFF)
 209                 return NDIS_STATUS_NOT_ACCEPTED;
 210
 211         path = (u8)pbbreg->path;
 212         offset = (u8)pbbreg->offset;
 213
 214         _irqlevel_changed_(&oldirql, LOWER);
 215         value = read_rfreg(Adapter, path, offset);
 216         _irqlevel_changed_(&oldirql, RAISE);
 217
 218         pbbreg->value = value;
 219
 220         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 221
 222         RT_TRACE(_module_mp_, _drv_notice_,
 223                  ("-oid_rt_pro_read_rf_reg_hdl: path=%d offset=0x%02X value=0x%05X\n",
 224                   path, offset, value));
 225
 226 _func_exit_;
 227
 228         return status;
 229 }
 230 //****************  oid_rtl_seg_81_87_00   section end****************
 231 //------------------------------------------------------------------------------
 232
 233 //****************  oid_rtl_seg_81_80_00   section start ****************
 234 //------------------------------------------------------------------------------
 235 NDIS_STATUS oid_rt_pro_set_data_rate_hdl(struct oid_par_priv *poid_par_priv)
 236 {
 237 #ifdef PLATFORM_OS_XP
 238         _irqL           oldirql;
 239 #endif
 240         u32             ratevalue;//4
 241         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 242         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 243
 244 _func_enter_;
 245
 246         RT_TRACE(_module_mp_, _drv_notice_,
 247                  ("+oid_rt_pro_set_data_rate_hdl\n"));
 248
 249         if (poid_par_priv->type_of_oid != SET_OID)
 250                 return NDIS_STATUS_NOT_ACCEPTED;
 251
 252         if (poid_par_priv->information_buf_len != sizeof(u32))
 253                 return NDIS_STATUS_INVALID_LENGTH;
 254
 255         ratevalue = *((u32*)poid_par_priv->information_buf);//4
 256         RT_TRACE(_module_mp_, _drv_notice_,
 257                  ("oid_rt_pro_set_data_rate_hdl: data rate idx=%d\n", ratevalue));
 258         if (ratevalue >= MPT_RATE_LAST)
 259                 return NDIS_STATUS_INVALID_DATA;
 260
 261         Adapter->mppriv.rateidx = ratevalue;
 262
 263         _irqlevel_changed_(&oldirql, LOWER);
 264         SetDataRate(Adapter);
 265         _irqlevel_changed_(&oldirql, RAISE);
 266
 267 _func_exit_;
 268
 269         return status;
 270 }
 271 //------------------------------------------------------------------------------
 272 NDIS_STATUS oid_rt_pro_start_test_hdl(struct oid_par_priv *poid_par_priv)
 273 {
 274 #ifdef PLATFORM_OS_XP
 275         _irqL           oldirql;
 276 #endif
 277         u32             mode;
 278         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 279         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 280
 281 _func_enter_;
 282
 283         RT_TRACE(_module_mp_, _drv_notice_, ("+oid_rt_pro_start_test_hdl\n"));
 284
 285         if (Adapter->registrypriv.mp_mode == 0)
 286                 return NDIS_STATUS_NOT_ACCEPTED;
 287
 288         if (poid_par_priv->type_of_oid != SET_OID)
 289                 return NDIS_STATUS_NOT_ACCEPTED;
 290
 291         _irqlevel_changed_(&oldirql, LOWER);
 292
 293         //IQCalibrateBcut(Adapter);
 294
 295         mode = *((u32*)poid_par_priv->information_buf);
 296         Adapter->mppriv.mode = mode;// 1 for loopback
 297
 298         if (mp_start_test(Adapter) == _FAIL) {
 299                 status = NDIS_STATUS_NOT_ACCEPTED;
 300                 goto exit;
 301         }
 302
 303 exit:
 304         _irqlevel_changed_(&oldirql, RAISE);
 305
 306         RT_TRACE(_module_mp_, _drv_notice_, ("-oid_rt_pro_start_test_hdl: mp_mode=%d\n", Adapter->mppriv.mode));
 307
 308 _func_exit_;
 309
 310         return status;
 311 }
 312 //------------------------------------------------------------------------------
 313 NDIS_STATUS oid_rt_pro_stop_test_hdl(struct oid_par_priv *poid_par_priv)
 314 {
 315 #ifdef PLATFORM_OS_XP
 316         _irqL           oldirql;
 317 #endif
 318         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 319         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 320
 321 _func_enter_;
 322
 323         RT_TRACE(_module_mp_, _drv_notice_, ("+Set OID_RT_PRO_STOP_TEST\n"));
 324
 325         if (poid_par_priv->type_of_oid != SET_OID)
 326                 return NDIS_STATUS_NOT_ACCEPTED;
 327
 328         _irqlevel_changed_(&oldirql, LOWER);
 329         mp_stop_test(Adapter);
 330         _irqlevel_changed_(&oldirql, RAISE);
 331
 332         RT_TRACE(_module_mp_, _drv_notice_, ("-Set OID_RT_PRO_STOP_TEST\n"));
 333
 334 _func_exit_;
 335
 336         return status;
 337 }
 338 //------------------------------------------------------------------------------
 339 NDIS_STATUS oid_rt_pro_set_channel_direct_call_hdl(struct oid_par_priv *poid_par_priv)
 340 {
 341 #ifdef PLATFORM_OS_XP
 342         _irqL           oldirql;
 343 #endif
 344         u32             Channel;
 345         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 346         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 347
 348 _func_enter_;
 349
 350         RT_TRACE(_module_mp_, _drv_notice_, ("+oid_rt_pro_set_channel_direct_call_hdl\n"));
 351
 352         if (poid_par_priv->information_buf_len != sizeof(u32))
 353                 return NDIS_STATUS_INVALID_LENGTH;
 354
 355         if (poid_par_priv->type_of_oid == QUERY_OID) {
 356                 *((u32*)poid_par_priv->information_buf) = Adapter->mppriv.channel;
 357                 return NDIS_STATUS_SUCCESS;
 358         }
 359
 360         if (poid_par_priv->type_of_oid != SET_OID)
 361                 return NDIS_STATUS_NOT_ACCEPTED;
 362
 363         Channel = *((u32*)poid_par_priv->information_buf);
 364         RT_TRACE(_module_mp_, _drv_notice_, ("oid_rt_pro_set_channel_direct_call_hdl: Channel=%d\n", Channel));
 365         if (Channel > 14)
 366                 return NDIS_STATUS_NOT_ACCEPTED;
 367         Adapter->mppriv.channel = Channel;
 368
 369         _irqlevel_changed_(&oldirql, LOWER);
 370         SetChannel(Adapter);
 371         _irqlevel_changed_(&oldirql, RAISE);
 372
 373 _func_exit_;
 374
 375         return status;
 376 }
 377 //------------------------------------------------------------------------------
 378 NDIS_STATUS oid_rt_set_bandwidth_hdl(struct oid_par_priv *poid_par_priv)
 379 {
 380 #ifdef PLATFORM_OS_XP
 381         _irqL           oldirql;
 382 #endif
 383         u16             bandwidth;
 384         u16             channel_offset;
 385         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 386         PADAPTER        padapter = (PADAPTER)(poid_par_priv->adapter_context);
 387
 388 _func_enter_;
 389
 390         RT_TRACE(_module_mp_, _drv_info_,
 391                  ("+oid_rt_set_bandwidth_hdl\n"));
 392
 393         if (poid_par_priv->type_of_oid != SET_OID)
 394                 return NDIS_STATUS_NOT_ACCEPTED;
 395
 396         if (poid_par_priv->information_buf_len < sizeof(u32))
 397                 return NDIS_STATUS_INVALID_LENGTH;
 398
 399         bandwidth = *((u32*)poid_par_priv->information_buf);//4
 400         channel_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
 401
 402         if (bandwidth != CHANNEL_WIDTH_40)
 403                 bandwidth = CHANNEL_WIDTH_20;
 404         padapter->mppriv.bandwidth = (u8)bandwidth;
 405         padapter->mppriv.prime_channel_offset = (u8)channel_offset;
 406
 407         _irqlevel_changed_(&oldirql, LOWER);
 408         SetBandwidth(padapter);
 409         _irqlevel_changed_(&oldirql, RAISE);
 410
 411         RT_TRACE(_module_mp_, _drv_notice_,
 412                  ("-oid_rt_set_bandwidth_hdl: bandwidth=%d channel_offset=%d\n",
 413                   bandwidth, channel_offset));
 414
 415 _func_exit_;
 416
 417         return status;
 418 }
 419 //------------------------------------------------------------------------------
 420 NDIS_STATUS oid_rt_pro_set_antenna_bb_hdl(struct oid_par_priv *poid_par_priv)
 421 {
 422 #ifdef PLATFORM_OS_XP
 423         _irqL           oldirql;
 424 #endif
 425         u32             antenna;
 426         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 427         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 428
 429 _func_enter_;
 430
 431         RT_TRACE(_module_mp_, _drv_notice_, ("+oid_rt_pro_set_antenna_bb_hdl\n"));
 432
 433         if (poid_par_priv->information_buf_len != sizeof(u32))
 434                 return NDIS_STATUS_INVALID_LENGTH;
 435
 436         if (poid_par_priv->type_of_oid == SET_OID)
 437         {
 438                 antenna = *(u32*)poid_par_priv->information_buf;
 439
 440                 Adapter->mppriv.antenna_tx = (u16)((antenna & 0xFFFF0000) >> 16);
 441                 Adapter->mppriv.antenna_rx = (u16)(antenna & 0x0000FFFF);
 442                 RT_TRACE(_module_mp_, _drv_notice_,
 443                          ("oid_rt_pro_set_antenna_bb_hdl: tx_ant=0x%04x rx_ant=0x%04x\n",
 444                           Adapter->mppriv.antenna_tx, Adapter->mppriv.antenna_rx));
 445
 446                 _irqlevel_changed_(&oldirql, LOWER);
 447                 SetAntenna(Adapter);
 448                 _irqlevel_changed_(&oldirql, RAISE);
 449         } else {
 450                 antenna = (Adapter->mppriv.antenna_tx << 16)|Adapter->mppriv.antenna_rx;
 451                 *(u32*)poid_par_priv->information_buf = antenna;
 452         }
 453
 454 _func_exit_;
 455
 456         return status;
 457 }
 458
 459 NDIS_STATUS oid_rt_pro_set_tx_power_control_hdl(struct oid_par_priv *poid_par_priv)
 460 {
 461 #ifdef PLATFORM_OS_XP
 462         _irqL           oldirql;
 463 #endif
 464         u32             tx_pwr_idx;
 465         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 466         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 467
 468 _func_enter_;
 469
 470         RT_TRACE(_module_mp_, _drv_info_, ("+oid_rt_pro_set_tx_power_control_hdl\n"));
 471
 472         if (poid_par_priv->type_of_oid != SET_OID)
 473                 return NDIS_STATUS_NOT_ACCEPTED;
 474
 475         if (poid_par_priv->information_buf_len != sizeof(u32))
 476                 return NDIS_STATUS_INVALID_LENGTH;
 477
 478         tx_pwr_idx = *((u32*)poid_par_priv->information_buf);
 479         if (tx_pwr_idx > MAX_TX_PWR_INDEX_N_MODE)
 480                 return NDIS_STATUS_NOT_ACCEPTED;
 481
 482         Adapter->mppriv.txpoweridx = (u8)tx_pwr_idx;
 483
 484         RT_TRACE(_module_mp_, _drv_notice_,
 485                  ("oid_rt_pro_set_tx_power_control_hdl: idx=0x%2x\n",
 486                   Adapter->mppriv.txpoweridx));
 487
 488         _irqlevel_changed_(&oldirql, LOWER);
 489         SetTxPower(Adapter);
 490         _irqlevel_changed_(&oldirql, RAISE);
 491
 492 _func_exit_;
 493
 494         return status;
 495 }
 496
 497 //------------------------------------------------------------------------------
 498 //****************  oid_rtl_seg_81_80_20   section start ****************
 499 //------------------------------------------------------------------------------
 500 NDIS_STATUS oid_rt_pro_query_tx_packet_sent_hdl(struct oid_par_priv *poid_par_priv)
 501 {
 502         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 503         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 504
 505 _func_enter_;
 506
 507         if (poid_par_priv->type_of_oid !=QUERY_OID) {
 508                 status = NDIS_STATUS_NOT_ACCEPTED;
 509                 return status;
 510         }
 511
 512         if (poid_par_priv->information_buf_len == sizeof(ULONG)) {
 513                 *(ULONG*)poid_par_priv->information_buf =  Adapter->mppriv.tx_pktcount;
 514                 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 515         } else {
 516                 status = NDIS_STATUS_INVALID_LENGTH;
 517         }
 518
 519 _func_exit_;
 520
 521         return status;
 522 }
 523 //------------------------------------------------------------------------------
 524 NDIS_STATUS oid_rt_pro_query_rx_packet_received_hdl(struct oid_par_priv *poid_par_priv)
 525 {
 526         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 527         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 528
 529 _func_enter_;
 530
 531         if (poid_par_priv->type_of_oid != QUERY_OID) {
 532                 status = NDIS_STATUS_NOT_ACCEPTED;
 533                 return status;
 534         }
 535         RT_TRACE(_module_mp_, _drv_alert_, ("===> oid_rt_pro_query_rx_packet_received_hdl.\n"));
 536         if (poid_par_priv->information_buf_len == sizeof(ULONG)) {
 537                 *(ULONG*)poid_par_priv->information_buf =  Adapter->mppriv.rx_pktcount;
 538                 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 539                 RT_TRACE(_module_mp_, _drv_alert_, ("recv_ok:%d \n",Adapter->mppriv.rx_pktcount));
 540         } else {
 541                 status = NDIS_STATUS_INVALID_LENGTH;
 542         }
 543
 544 _func_exit_;
 545
 546         return status;
 547 }
 548 //------------------------------------------------------------------------------
 549 NDIS_STATUS oid_rt_pro_query_rx_packet_crc32_error_hdl(struct oid_par_priv *poid_par_priv)
 550 {
 551         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 552         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 553
 554 _func_enter_;
 555
 556         if (poid_par_priv->type_of_oid != QUERY_OID) {
 557                 status = NDIS_STATUS_NOT_ACCEPTED;
 558                 return status;
 559         }
 560         RT_TRACE(_module_mp_, _drv_alert_, ("===> oid_rt_pro_query_rx_packet_crc32_error_hdl.\n"));
 561         if (poid_par_priv->information_buf_len == sizeof(ULONG)) {
 562                 *(ULONG*)poid_par_priv->information_buf =  Adapter->mppriv.rx_crcerrpktcount;
 563                 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 564                 RT_TRACE(_module_mp_, _drv_alert_, ("recv_err:%d \n",Adapter->mppriv.rx_crcerrpktcount));
 565         } else {
 566                 status = NDIS_STATUS_INVALID_LENGTH;
 567         }
 568
 569 _func_exit_;
 570
 571         return status;
 572 }
 573 //------------------------------------------------------------------------------
 574
 575 NDIS_STATUS oid_rt_pro_reset_tx_packet_sent_hdl(struct oid_par_priv *poid_par_priv)
 576 {
 577         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 578         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 579
 580 _func_enter_;
 581
 582         if (poid_par_priv->type_of_oid != SET_OID) {
 583                 status = NDIS_STATUS_NOT_ACCEPTED;
 584                 return status;
 585         }
 586
 587         RT_TRACE(_module_mp_, _drv_alert_, ("===> oid_rt_pro_reset_tx_packet_sent_hdl.\n"));
 588         Adapter->mppriv.tx_pktcount = 0;
 589
 590 _func_exit_;
 591
 592         return status;
 593 }
 594 //------------------------------------------------------------------------------
 595 NDIS_STATUS oid_rt_pro_reset_rx_packet_received_hdl(struct oid_par_priv *poid_par_priv)
 596 {
 597         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 598         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 599
 600 _func_enter_;
 601
 602         if (poid_par_priv->type_of_oid != SET_OID)
 603         {
 604                 status = NDIS_STATUS_NOT_ACCEPTED;
 605                 return status;
 606         }
 607
 608         if (poid_par_priv->information_buf_len == sizeof(ULONG)) {
 609                 Adapter->mppriv.rx_pktcount = 0;
 610                 Adapter->mppriv.rx_crcerrpktcount = 0;
 611         } else {
 612                 status = NDIS_STATUS_INVALID_LENGTH;
 613         }
 614
 615 _func_exit_;
 616
 617         return status;
 618 }
 619 //------------------------------------------------------------------------------
 620 NDIS_STATUS oid_rt_reset_phy_rx_packet_count_hdl(struct oid_par_priv *poid_par_priv)
 621 {
 622 #ifdef PLATFORM_OS_XP
 623         _irqL           oldirql;
 624 #endif
 625         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 626         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 627
 628 _func_enter_;
 629
 630         if (poid_par_priv->type_of_oid != SET_OID) {
 631                 status = NDIS_STATUS_NOT_ACCEPTED;
 632                 return status;
 633         }
 634
 635         _irqlevel_changed_(&oldirql, LOWER);
 636         ResetPhyRxPktCount(Adapter);
 637         _irqlevel_changed_(&oldirql, RAISE);
 638
 639 _func_exit_;
 640
 641         return status;
 642 }
 643 //------------------------------------------------------------------------------
 644 NDIS_STATUS oid_rt_get_phy_rx_packet_received_hdl(struct oid_par_priv *poid_par_priv)
 645 {
 646 #ifdef PLATFORM_OS_XP
 647         _irqL           oldirql;
 648 #endif
 649         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 650         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 651
 652 _func_enter_;
 653
 654         RT_TRACE(_module_mp_, _drv_info_, ("+oid_rt_get_phy_rx_packet_received_hdl\n"));
 655
 656         if (poid_par_priv->type_of_oid != QUERY_OID)
 657                 return NDIS_STATUS_NOT_ACCEPTED;
 658
 659         if (poid_par_priv->information_buf_len != sizeof(ULONG))
 660                 return NDIS_STATUS_INVALID_LENGTH;
 661
 662         _irqlevel_changed_(&oldirql, LOWER);
 663         *(ULONG*)poid_par_priv->information_buf = GetPhyRxPktReceived(Adapter);
 664         _irqlevel_changed_(&oldirql, RAISE);
 665
 666         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 667
 668         RT_TRACE(_module_mp_, _drv_notice_, ("-oid_rt_get_phy_rx_packet_received_hdl: recv_ok=%d\n", *(ULONG*)poid_par_priv->information_buf));
 669
 670 _func_exit_;
 671
 672         return status;
 673 }
 674 //------------------------------------------------------------------------------
 675 NDIS_STATUS oid_rt_get_phy_rx_packet_crc32_error_hdl(struct oid_par_priv *poid_par_priv)
 676 {
 677 #ifdef PLATFORM_OS_XP
 678         _irqL           oldirql;
 679 #endif
 680         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 681         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 682
 683 _func_enter_;
 684
 685         RT_TRACE(_module_mp_, _drv_info_, ("+oid_rt_get_phy_rx_packet_crc32_error_hdl\n"));
 686
 687         if (poid_par_priv->type_of_oid != QUERY_OID)
 688                 return NDIS_STATUS_NOT_ACCEPTED;
 689
 690
 691         if (poid_par_priv->information_buf_len != sizeof(ULONG))
 692                 return NDIS_STATUS_INVALID_LENGTH;
 693
 694         _irqlevel_changed_(&oldirql, LOWER);
 695         *(ULONG*)poid_par_priv->information_buf = GetPhyRxPktCRC32Error(Adapter);
 696         _irqlevel_changed_(&oldirql, RAISE);
 697
 698         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 699
 700         RT_TRACE(_module_mp_, _drv_info_, ("-oid_rt_get_phy_rx_packet_crc32_error_hdl: recv_err=%d\n", *(ULONG*)poid_par_priv->information_buf));
 701
 702 _func_exit_;
 703
 704         return status;
 705 }
 706 //****************  oid_rtl_seg_81_80_20   section end ****************
 707 NDIS_STATUS oid_rt_pro_set_continuous_tx_hdl(struct oid_par_priv *poid_par_priv)
 708 {
 709 #ifdef PLATFORM_OS_XP
 710         _irqL           oldirql;
 711 #endif
 712         u32             bStartTest;
 713         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 714         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 715
 716 _func_enter_;
 717
 718         RT_TRACE(_module_mp_, _drv_notice_, ("+oid_rt_pro_set_continuous_tx_hdl\n"));
 719
 720         if (poid_par_priv->type_of_oid != SET_OID)
 721                 return NDIS_STATUS_NOT_ACCEPTED;
 722
 723         bStartTest = *((u32*)poid_par_priv->information_buf);
 724
 725         _irqlevel_changed_(&oldirql, LOWER);
 726         SetContinuousTx(Adapter,(u8)bStartTest);
 727         if (bStartTest) {
 728                 struct mp_priv *pmp_priv = &Adapter->mppriv;
 729                 if (pmp_priv->tx.stop == 0) {
 730                         pmp_priv->tx.stop = 1;
 731                         DBG_871X("%s: pkt tx is running...\n", __func__);
 732                         rtw_msleep_os(5);
 733                 }
 734                 pmp_priv->tx.stop = 0;
 735                 pmp_priv->tx.count = 1;
 736                 SetPacketTx(Adapter);
 737         }
 738         _irqlevel_changed_(&oldirql, RAISE);
 739
 740 _func_exit_;
 741
 742         return status;
 743 }
 744
 745 NDIS_STATUS oid_rt_pro_set_single_carrier_tx_hdl(struct oid_par_priv *poid_par_priv)
 746 {
 747 #ifdef PLATFORM_OS_XP
 748         _irqL           oldirql;
 749 #endif
 750         u32             bStartTest;
 751         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 752         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 753
 754 _func_enter_;
 755
 756         RT_TRACE(_module_mp_, _drv_alert_, ("+oid_rt_pro_set_single_carrier_tx_hdl\n"));
 757
 758         if (poid_par_priv->type_of_oid != SET_OID)
 759                 return NDIS_STATUS_NOT_ACCEPTED;
 760
 761         bStartTest = *((u32*)poid_par_priv->information_buf);
 762
 763         _irqlevel_changed_(&oldirql, LOWER);
 764         SetSingleCarrierTx(Adapter, (u8)bStartTest);
 765         if (bStartTest) {
 766                 struct mp_priv *pmp_priv = &Adapter->mppriv;
 767                 if (pmp_priv->tx.stop == 0) {
 768                         pmp_priv->tx.stop = 1;
 769                         DBG_871X("%s: pkt tx is running...\n", __func__);
 770                         rtw_msleep_os(5);
 771                 }
 772                 pmp_priv->tx.stop = 0;
 773                 pmp_priv->tx.count = 1;
 774                 SetPacketTx(Adapter);
 775         }
 776         _irqlevel_changed_(&oldirql, RAISE);
 777
 778 _func_exit_;
 779
 780         return status;
 781 }
 782
 783 NDIS_STATUS oid_rt_pro_set_carrier_suppression_tx_hdl(struct oid_par_priv *poid_par_priv)
 784 {
 785 #ifdef PLATFORM_OS_XP
 786         _irqL           oldirql;
 787 #endif
 788         u32             bStartTest;
 789         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 790         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 791
 792 _func_enter_;
 793
 794         RT_TRACE(_module_mp_, _drv_notice_, ("+oid_rt_pro_set_carrier_suppression_tx_hdl\n"));
 795
 796         if (poid_par_priv->type_of_oid != SET_OID)
 797                 return NDIS_STATUS_NOT_ACCEPTED;
 798
 799         bStartTest = *((u32*)poid_par_priv->information_buf);
 800
 801         _irqlevel_changed_(&oldirql, LOWER);
 802         SetCarrierSuppressionTx(Adapter, (u8)bStartTest);
 803         if (bStartTest) {
 804                 struct mp_priv *pmp_priv = &Adapter->mppriv;
 805                 if (pmp_priv->tx.stop == 0) {
 806                         pmp_priv->tx.stop = 1;
 807                         DBG_871X("%s: pkt tx is running...\n", __func__);
 808                         rtw_msleep_os(5);
 809                 }
 810                 pmp_priv->tx.stop = 0;
 811                 pmp_priv->tx.count = 1;
 812                 SetPacketTx(Adapter);
 813         }
 814         _irqlevel_changed_(&oldirql, RAISE);
 815
 816 _func_exit_;
 817
 818         return status;
 819 }
 820
 821 NDIS_STATUS oid_rt_pro_set_single_tone_tx_hdl(struct oid_par_priv *poid_par_priv)
 822 {
 823 #ifdef PLATFORM_OS_XP
 824         _irqL           oldirql;
 825 #endif
 826         u32             bStartTest;
 827         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 828         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 829
 830 _func_enter_;
 831
 832         RT_TRACE(_module_mp_, _drv_alert_, ("+oid_rt_pro_set_single_tone_tx_hdl\n"));
 833
 834         if (poid_par_priv->type_of_oid != SET_OID)
 835                 return NDIS_STATUS_NOT_ACCEPTED;
 836
 837         bStartTest = *((u32*)poid_par_priv->information_buf);
 838
 839         _irqlevel_changed_(&oldirql, LOWER);
 840         SetSingleToneTx(Adapter,(u8)bStartTest);
 841         _irqlevel_changed_(&oldirql, RAISE);
 842
 843 _func_exit_;
 844
 845         return status;
 846 }
 847
 848 NDIS_STATUS oid_rt_pro_set_modulation_hdl(struct oid_par_priv* poid_par_priv)
 849 {
 850         return 0;
 851 }
 852
 853 NDIS_STATUS oid_rt_pro_trigger_gpio_hdl(struct oid_par_priv *poid_par_priv)
 854 {
 855         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 856
 857 #ifdef PLATFORM_OS_XP
 858         _irqL           oldirql;
 859 #endif
 860         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 861 _func_enter_;
 862
 863         if (poid_par_priv->type_of_oid != SET_OID)
 864                 return NDIS_STATUS_NOT_ACCEPTED;
 865
 866         _irqlevel_changed_(&oldirql, LOWER);
 867         rtw_hal_set_hwreg(Adapter, HW_VAR_TRIGGER_GPIO_0, 0);
 868         _irqlevel_changed_(&oldirql, RAISE);
 869
 870 _func_exit_;
 871
 872         return status;
 873 }
 874 //****************  oid_rtl_seg_81_80_00   section end ****************
 875 //------------------------------------------------------------------------------
 876 NDIS_STATUS oid_rt_pro8711_join_bss_hdl(struct oid_par_priv *poid_par_priv)
 877 {
 878 #if 0
 879         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 880
 881 #ifdef PLATFORM_OS_XP
 882         _irqL           oldirql;
 883 #endif
 884         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 885
 886         PNDIS_802_11_SSID pssid;
 887
 888 _func_enter_;
 889
 890         if (poid_par_priv->type_of_oid != SET_OID)
 891                 return NDIS_STATUS_NOT_ACCEPTED;
 892
 893         *poid_par_priv->bytes_needed = (u32)sizeof(NDIS_802_11_SSID);
 894         *poid_par_priv->bytes_rw = 0;
 895         if (poid_par_priv->information_buf_len < *poid_par_priv->bytes_needed)
 896                 return NDIS_STATUS_INVALID_LENGTH;
 897
 898         pssid = (PNDIS_802_11_SSID)poid_par_priv->information_buf;
 899
 900         _irqlevel_changed_(&oldirql, LOWER);
 901
 902         if (mp_start_joinbss(Adapter, pssid) == _FAIL)
 903                 status = NDIS_STATUS_NOT_ACCEPTED;
 904
 905         _irqlevel_changed_(&oldirql, RAISE);
 906
 907         *poid_par_priv->bytes_rw = sizeof(NDIS_802_11_SSID);
 908
 909 _func_exit_;
 910
 911         return status;
 912 #else
 913         return 0;
 914 #endif
 915 }
 916 //------------------------------------------------------------------------------
 917 NDIS_STATUS oid_rt_pro_read_register_hdl(struct oid_par_priv *poid_par_priv)
 918 {
 919 #ifdef PLATFORM_OS_XP
 920         _irqL           oldirql;
 921 #endif
 922         pRW_Reg         RegRWStruct;
 923         u32             offset, width;
 924         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 925         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
 926
 927 _func_enter_;
 928
 929         RT_TRACE(_module_mp_, _drv_info_,
 930                  ("+oid_rt_pro_read_register_hdl\n"));
 931
 932         if (poid_par_priv->type_of_oid != QUERY_OID)
 933                 return NDIS_STATUS_NOT_ACCEPTED;
 934
 935         RegRWStruct = (pRW_Reg)poid_par_priv->information_buf;
 936         offset = RegRWStruct->offset;
 937         width = RegRWStruct->width;
 938
 939         if (offset > 0xFFF)
 940                 return NDIS_STATUS_NOT_ACCEPTED;
 941
 942         _irqlevel_changed_(&oldirql, LOWER);
 943
 944         switch (width) {
 945                 case 1:
 946                         RegRWStruct->value = rtw_read8(Adapter, offset);
 947                         break;
 948                 case 2:
 949                         RegRWStruct->value = rtw_read16(Adapter, offset);
 950                         break;
 951                 default:
 952                         width = 4;
 953                         RegRWStruct->value = rtw_read32(Adapter, offset);
 954                         break;
 955         }
 956         RT_TRACE(_module_mp_, _drv_notice_,
 957                  ("oid_rt_pro_read_register_hdl: offset:0x%04X value:0x%X\n",
 958                   offset, RegRWStruct->value));
 959
 960         _irqlevel_changed_(&oldirql, RAISE);
 961
 962         *poid_par_priv->bytes_rw = width;
 963
 964 _func_exit_;
 965
 966         return status;
 967 }
 968 //------------------------------------------------------------------------------
 969 NDIS_STATUS oid_rt_pro_write_register_hdl(struct oid_par_priv *poid_par_priv)
 970 {
 971 #ifdef PLATFORM_OS_XP
 972         _irqL           oldirql;
 973 #endif
 974         pRW_Reg         RegRWStruct;
 975         u32             offset, width, value;
 976         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
 977         PADAPTER        padapter = (PADAPTER)(poid_par_priv->adapter_context);
 978
 979 _func_enter_;
 980
 981         RT_TRACE(_module_mp_, _drv_info_,
 982                  ("+oid_rt_pro_write_register_hdl\n"));
 983
 984         if (poid_par_priv->type_of_oid != SET_OID)
 985                 return NDIS_STATUS_NOT_ACCEPTED;
 986
 987         RegRWStruct = (pRW_Reg)poid_par_priv->information_buf;
 988         offset = RegRWStruct->offset;
 989         width = RegRWStruct->width;
 990         value = RegRWStruct->value;
 991
 992         if (offset > 0xFFF)
 993                 return NDIS_STATUS_NOT_ACCEPTED;
 994
 995         _irqlevel_changed_(&oldirql, LOWER);
 996
 997         switch (RegRWStruct->width)
 998         {
 999                 case 1:
1000                         if (value > 0xFF) {
1001                                 status = NDIS_STATUS_NOT_ACCEPTED;
1002                                 break;
1003                         }
1004                         rtw_write8(padapter, offset, (u8)value);
1005                         break;
1006                 case 2:
1007                         if (value > 0xFFFF) {
1008                                 status = NDIS_STATUS_NOT_ACCEPTED;
1009                                 break;
1010                         }
1011                         rtw_write16(padapter, offset, (u16)value);
1012                         break;
1013                 case 4:
1014                         rtw_write32(padapter, offset, value);
1015                         break;
1016                 default:
1017                         status = NDIS_STATUS_NOT_ACCEPTED;
1018                         break;
1019         }
1020
1021         _irqlevel_changed_(&oldirql, RAISE);
1022
1023         RT_TRACE(_module_mp_, _drv_info_,
1024                  ("-oid_rt_pro_write_register_hdl: offset=0x%08X width=%d value=0x%X\n",
1025                   offset, width, value));
1026
1027 _func_exit_;
1028
1029         return status;
1030 }
1031 //------------------------------------------------------------------------------
1032 NDIS_STATUS oid_rt_pro_burst_read_register_hdl(struct oid_par_priv *poid_par_priv)
1033 {
1034 #if 0
1035 #ifdef PLATFORM_OS_XP
1036         _irqL           oldirql;
1037 #endif
1038         pBurst_RW_Reg   pBstRwReg;
1039         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1040         PADAPTER        padapter = (PADAPTER)(poid_par_priv->adapter_context);
1041
1042 _func_enter_;
1043
1044         RT_TRACE(_module_mp_, _drv_notice_, ("+oid_rt_pro_burst_read_register_hdl\n"));
1045
1046         if (poid_par_priv->type_of_oid != QUERY_OID)
1047                 return NDIS_STATUS_NOT_ACCEPTED;
1048
1049         pBstRwReg = (pBurst_RW_Reg)poid_par_priv->information_buf;
1050
1051         _irqlevel_changed_(&oldirql, LOWER);
1052         rtw_read_mem(padapter, pBstRwReg->offset, (u32)pBstRwReg->len, pBstRwReg->Data);
1053         _irqlevel_changed_(&oldirql, RAISE);
1054
1055         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
1056
1057         RT_TRACE(_module_mp_, _drv_info_, ("-oid_rt_pro_burst_read_register_hdl\n"));
1058
1059 _func_exit_;
1060
1061         return status;
1062 #else
1063         return 0;
1064 #endif
1065 }
1066 //------------------------------------------------------------------------------
1067 NDIS_STATUS oid_rt_pro_burst_write_register_hdl(struct oid_par_priv *poid_par_priv)
1068 {
1069 #if 0
1070 #ifdef PLATFORM_OS_XP
1071         _irqL           oldirql;
1072 #endif
1073         pBurst_RW_Reg   pBstRwReg;
1074         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1075         PADAPTER        padapter = (PADAPTER)(poid_par_priv->adapter_context);
1076
1077 _func_enter_;
1078
1079         RT_TRACE(_module_mp_, _drv_notice_, ("+oid_rt_pro_burst_write_register_hdl\n"));
1080
1081         if (poid_par_priv->type_of_oid != SET_OID)
1082                 return NDIS_STATUS_NOT_ACCEPTED;
1083
1084         pBstRwReg = (pBurst_RW_Reg)poid_par_priv->information_buf;
1085
1086         _irqlevel_changed_(&oldirql, LOWER);
1087         rtw_write_mem(padapter, pBstRwReg->offset, (u32)pBstRwReg->len, pBstRwReg->Data);
1088         _irqlevel_changed_(&oldirql, RAISE);
1089
1090         RT_TRACE(_module_mp_, _drv_info_, ("-oid_rt_pro_burst_write_register_hdl\n"));
1091
1092 _func_exit_;
1093
1094         return status;
1095 #else
1096         return 0;
1097 #endif
1098 }
1099 //------------------------------------------------------------------------------
1100 NDIS_STATUS oid_rt_pro_write_txcmd_hdl(struct oid_par_priv *poid_par_priv)
1101 {
1102 #if 0
1103         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1104
1105         PADAPTER        Adapter = (PADAPTER)( poid_par_priv->adapter_context);
1106
1107 #ifdef PLATFORM_OS_XP
1108         _irqL           oldirql;
1109 #endif
1110
1111         TX_CMD_Desc     *TxCmd_Info;
1112
1113 _func_enter_;
1114
1115         if (poid_par_priv->type_of_oid != SET_OID)
1116                 return NDIS_STATUS_NOT_ACCEPTED;
1117
1118         RT_TRACE(_module_mp_, _drv_info_, ("+Set OID_RT_PRO_WRITE_TXCMD\n"));
1119
1120         TxCmd_Info=(TX_CMD_Desc*)poid_par_priv->information_buf;
1121
1122         RT_TRACE(_module_mp_, _drv_info_, ("WRITE_TXCMD:Addr=%.8X\n", TxCmd_Info->offset));
1123         RT_TRACE(_module_mp_, _drv_info_, ("WRITE_TXCMD:1.)%.8X\n", (ULONG)TxCmd_Info->TxCMD.value[0]));
1124         RT_TRACE(_module_mp_, _drv_info_, ("WRITE_TXCMD:2.)%.8X\n", (ULONG)TxCmd_Info->TxCMD.value[1]));
1125         RT_TRACE(_module_mp_, _drv_info_, (("WRITE_TXCMD:3.)%.8X\n", (ULONG)TxCmd_Info->TxCMD.value[2]));
1126         RT_TRACE(_module_mp_, _drv_info_, ("WRITE_TXCMD:4.)%.8X\n", (ULONG)TxCmd_Info->TxCMD.value[3]));
1127
1128         _irqlevel_changed_(&oldirql, LOWER);
1129
1130         rtw_write32(Adapter, TxCmd_Info->offset + 0, (unsigned int)TxCmd_Info->TxCMD.value[0]);
1131         rtw_write32(Adapter, TxCmd_Info->offset + 4, (unsigned int)TxCmd_Info->TxCMD.value[1]);
1132
1133         _irqlevel_changed_(&oldirql, RAISE);
1134
1135         RT_TRACE(_module_mp_, _drv_notice_,
1136                  ("-Set OID_RT_PRO_WRITE_TXCMD: status=0x%08X\n", status));
1137
1138 _func_exit_;
1139
1140         return status;
1141 #else
1142         return 0;
1143 #endif
1144 }
1145
1146 //------------------------------------------------------------------------------
1147 NDIS_STATUS oid_rt_pro_read16_eeprom_hdl(struct oid_par_priv *poid_par_priv)
1148 {
1149 #if 0
1150 #ifdef PLATFORM_OS_XP
1151         _irqL           oldirql;
1152 #endif
1153         pEEPROM_RWParam pEEPROM;
1154         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1155         PADAPTER        padapter = (PADAPTER)(poid_par_priv->adapter_context);
1156
1157 _func_enter_;
1158
1159         RT_TRACE(_module_mp_, _drv_info_, ("+Query OID_RT_PRO_READ16_EEPROM\n"));
1160
1161         if (poid_par_priv->type_of_oid != QUERY_OID)
1162                 return NDIS_STATUS_NOT_ACCEPTED;
1163
1164         pEEPROM = (pEEPROM_RWParam)poid_par_priv->information_buf;
1165
1166         _irqlevel_changed_(&oldirql, LOWER);
1167         pEEPROM->value = eeprom_read16(padapter, (u16)(pEEPROM->offset >> 1));
1168         _irqlevel_changed_(&oldirql, RAISE);
1169
1170         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
1171
1172         RT_TRACE(_module_mp_,  _drv_notice_,
1173                  ("-Query OID_RT_PRO_READ16_EEPROM: offset=0x%x value=0x%x\n",
1174                   pEEPROM->offset, pEEPROM->value));
1175
1176 _func_exit_;
1177
1178         return status;
1179 #else
1180         return 0;
1181 #endif
1182 }
1183
1184 //------------------------------------------------------------------------------
1185 NDIS_STATUS oid_rt_pro_write16_eeprom_hdl (struct oid_par_priv *poid_par_priv)
1186 {
1187 #if 0
1188 #ifdef PLATFORM_OS_XP
1189         _irqL           oldirql;
1190 #endif
1191         pEEPROM_RWParam pEEPROM;
1192         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1193         PADAPTER        padapter = (PADAPTER)(poid_par_priv->adapter_context);
1194
1195 _func_enter_;
1196
1197         RT_TRACE(_module_mp_, _drv_notice_, ("+Set OID_RT_PRO_WRITE16_EEPROM\n"));
1198
1199         if (poid_par_priv->type_of_oid != SET_OID)
1200                 return NDIS_STATUS_NOT_ACCEPTED;
1201
1202         pEEPROM = (pEEPROM_RWParam)poid_par_priv->information_buf;
1203
1204         _irqlevel_changed_(&oldirql, LOWER);
1205         eeprom_write16(padapter, (u16)(pEEPROM->offset >> 1), pEEPROM->value);
1206         _irqlevel_changed_(&oldirql, RAISE);
1207
1208         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
1209
1210 _func_exit_;
1211
1212         return status;
1213 #else
1214         return 0;
1215 #endif
1216 }
1217 //------------------------------------------------------------------------------
1218 NDIS_STATUS oid_rt_pro8711_wi_poll_hdl(struct oid_par_priv *poid_par_priv)
1219 {
1220 #if 0
1221         PADAPTER        Adapter = (PADAPTER)( poid_par_priv->adapter_context);
1222
1223         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1224
1225         struct mp_wiparam *pwi_param;
1226
1227 _func_enter_;
1228
1229         if (poid_par_priv->type_of_oid != QUERY_OID)
1230                 return NDIS_STATUS_NOT_ACCEPTED;
1231
1232         if (poid_par_priv->information_buf_len < sizeof(struct mp_wiparam))
1233                 return NDIS_STATUS_INVALID_LENGTH;
1234
1235         if (Adapter->mppriv.workparam.bcompleted == _FALSE)
1236                 return NDIS_STATUS_NOT_ACCEPTED;
1237
1238         pwi_param = (struct mp_wiparam *)poid_par_priv->information_buf;
1239
1240         _rtw_memcpy(pwi_param, &Adapter->mppriv.workparam, sizeof(struct mp_wiparam));
1241         Adapter->mppriv.act_in_progress = _FALSE;
1242 //      RT_TRACE(_module_mp_, _drv_info_, ("rf:%x\n", pwiparam->IoValue));
1243         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
1244
1245 _func_exit_;
1246
1247         return status;
1248 #else
1249         return 0;
1250 #endif
1251 }
1252 //------------------------------------------------------------------------------
1253 NDIS_STATUS oid_rt_pro8711_pkt_loss_hdl(struct oid_par_priv *poid_par_priv)
1254 {
1255 #if 0
1256         PADAPTER        Adapter = (PADAPTER)( poid_par_priv->adapter_context);
1257
1258         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1259
1260 _func_enter_;
1261
1262         RT_TRACE(_module_mp_, _drv_notice_, ("+oid_rt_pro8711_pkt_loss_hdl\n"));
1263
1264         if (poid_par_priv->type_of_oid != QUERY_OID)
1265                 return NDIS_STATUS_NOT_ACCEPTED;
1266
1267         if (poid_par_priv->information_buf_len < sizeof(uint)*2) {
1268                 RT_TRACE(_module_mp_, _drv_err_, ("-oid_rt_pro8711_pkt_loss_hdl: buf_len=%d\n", (int)poid_par_priv->information_buf_len));
1269                 return NDIS_STATUS_INVALID_LENGTH;
1270         }
1271
1272         if (*(uint*)poid_par_priv->information_buf == 1)//init==1
1273                 Adapter->mppriv.rx_pktloss = 0;
1274
1275         *((uint*)poid_par_priv->information_buf+1) = Adapter->mppriv.rx_pktloss;
1276         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
1277
1278 _func_exit_;
1279
1280         return status;
1281 #else
1282         return 0;
1283 #endif
1284 }
1285 //------------------------------------------------------------------------------
1286 NDIS_STATUS oid_rt_rd_attrib_mem_hdl(struct oid_par_priv *poid_par_priv)
1287 {
1288 #if 0
1289         PADAPTER        Adapter = (PADAPTER)( poid_par_priv->adapter_context);
1290         struct io_queue *pio_queue = (struct io_queue *)Adapter->pio_queue;
1291         struct intf_hdl *pintfhdl = &pio_queue->intf;
1292
1293 #ifdef PLATFORM_OS_XP
1294         _irqL           oldirql;
1295 #endif
1296         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1297
1298 #ifdef CONFIG_SDIO_HCI
1299         void (*_attrib_read)(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pmem);
1300 #endif
1301
1302 _func_enter_;
1303
1304         RT_TRACE(_module_mp_, _drv_notice_, ("+Query OID_RT_RD_ATTRIB_MEM\n"));
1305
1306         if (poid_par_priv->type_of_oid != QUERY_OID)
1307                 return NDIS_STATUS_NOT_ACCEPTED;
1308
1309 #ifdef CONFIG_SDIO_HCI
1310         _irqlevel_changed_(&oldirql, LOWER);
1311 {
1312         u32 *plmem = (u32*)poid_par_priv->information_buf+2;
1313         _attrib_read = pintfhdl->io_ops._attrib_read;
1314         _attrib_read(pintfhdl, *((u32*)poid_par_priv->information_buf),
1315                                 *((u32*)poid_par_priv->information_buf+1), (u8*)plmem);
1316         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
1317 }
1318         _irqlevel_changed_(&oldirql, RAISE);
1319 #endif
1320
1321 _func_exit_;
1322
1323         return status;
1324 #else
1325         return 0;
1326 #endif
1327 }
1328 //------------------------------------------------------------------------------
1329 NDIS_STATUS oid_rt_wr_attrib_mem_hdl (struct oid_par_priv *poid_par_priv)
1330 {
1331 #if 0
1332         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
1333         struct io_queue *pio_queue = (struct io_queue *)Adapter->pio_queue;
1334         struct intf_hdl *pintfhdl = &pio_queue->intf;
1335
1336 #ifdef PLATFORM_OS_XP
1337         _irqL           oldirql;
1338 #endif
1339         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1340
1341 #ifdef CONFIG_SDIO_HCI
1342         void (*_attrib_write)(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pmem);
1343 #endif
1344
1345 _func_enter_;
1346
1347         if (poid_par_priv->type_of_oid != SET_OID)
1348                 return NDIS_STATUS_NOT_ACCEPTED;
1349
1350 #ifdef CONFIG_SDIO_HCI
1351         _irqlevel_changed_(&oldirql, LOWER);
1352 {
1353         u32 *plmem = (u32*)poid_par_priv->information_buf + 2;
1354         _attrib_write = pintfhdl->io_ops._attrib_write;
1355         _attrib_write(pintfhdl, *(u32*)poid_par_priv->information_buf,
1356                                 *((u32*)poid_par_priv->information_buf+1), (u8*)plmem);
1357 }
1358         _irqlevel_changed_(&oldirql, RAISE);
1359 #endif
1360
1361 _func_exit_;
1362
1363         return status;
1364 #else
1365         return 0;
1366 #endif
1367 }
1368 //------------------------------------------------------------------------------
1369 NDIS_STATUS  oid_rt_pro_set_rf_intfs_hdl(struct oid_par_priv *poid_par_priv)
1370 {
1371 #if 0
1372         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
1373
1374 #ifdef PLATFORM_OS_XP
1375         _irqL           oldirql;
1376 #endif
1377         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1378
1379 _func_enter_;
1380
1381         RT_TRACE(_module_mp_, _drv_notice_, ("+OID_RT_PRO_SET_RF_INTFS\n"));
1382
1383         if (poid_par_priv->type_of_oid != SET_OID)
1384                 return NDIS_STATUS_NOT_ACCEPTED;
1385
1386         _irqlevel_changed_(&oldirql, LOWER);
1387
1388         if (rtw_setrfintfs_cmd(Adapter, *(unsigned char*)poid_par_priv->information_buf) == _FAIL)
1389                 status = NDIS_STATUS_NOT_ACCEPTED;
1390
1391         _irqlevel_changed_(&oldirql, RAISE);
1392
1393 _func_exit_;
1394
1395         return status;
1396 #else
1397         return 0;
1398 #endif
1399 }
1400 //------------------------------------------------------------------------------
1401 NDIS_STATUS oid_rt_poll_rx_status_hdl(struct oid_par_priv *poid_par_priv)
1402 {
1403 #if 0
1404         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
1405
1406         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1407
1408 _func_enter_;
1409
1410         if (poid_par_priv->type_of_oid != QUERY_OID)
1411                 return NDIS_STATUS_NOT_ACCEPTED;
1412
1413         _rtw_memcpy(poid_par_priv->information_buf, (unsigned char*)&Adapter->mppriv.rxstat, sizeof(struct recv_stat));
1414         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
1415
1416 _func_exit_;
1417
1418         return status;
1419 #else
1420         return 0;
1421 #endif
1422 }
1423 //------------------------------------------------------------------------------
1424 NDIS_STATUS oid_rt_pro_cfg_debug_message_hdl(struct oid_par_priv *poid_par_priv)
1425 {
1426 #if 0
1427         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
1428
1429         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1430
1431         PCFG_DBG_MSG_STRUCT pdbg_msg;
1432
1433 _func_enter_;
1434
1435 //      RT_TRACE(0xffffffffff,_drv_alert_,("===> oid_rt_pro_cfg_debug_message_hdl.\n"));
1436
1437 #if 0//#ifdef CONFIG_DEBUG_RTL871X
1438
1439         pdbg_msg = (PCFG_DBG_MSG_STRUCT)(poid_par_priv->information_buf);
1440
1441         if (poid_par_priv->type_of_oid == SET_OID) {
1442                 RT_TRACE(0xffffffffff, _drv_alert_,
1443                          ("===>Set level :0x%08x, H32:0x%08x L32:0x%08x\n",
1444                           pdbg_msg->DebugLevel, pdbg_msg->DebugComponent_H32, pdbg_msg->DebugComponent_L32));
1445
1446                 GlobalDebugLevel = pdbg_msg->DebugLevel;
1447                 GlobalDebugComponents = (pdbg_msg->DebugComponent_H32 << 32) | pdbg_msg->DebugComponent_L32;
1448                 RT_TRACE(0xffffffffff, _drv_alert_,
1449                          ("===> Set level :0x%08x, component:0x%016x\n",
1450                           GlobalDebugLevel, (u32)GlobalDebugComponents));
1451         } else {
1452                 pdbg_msg->DebugLevel = GlobalDebugLevel;
1453                 pdbg_msg->DebugComponent_H32 = (u32)(GlobalDebugComponents >> 32);
1454                 pdbg_msg->DebugComponent_L32 = (u32)GlobalDebugComponents;
1455                 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
1456
1457                 RT_TRACE(0xffffffffff, _drv_alert_,
1458                          ("===>Query level:0x%08x H32:0x%08x L32:0x%08x\n",
1459                           (u32)pdbg_msg->DebugLevel, (u32)pdbg_msg->DebugComponent_H32, (u32)pdbg_msg->DebugComponent_L32));
1460         }
1461
1462 #endif
1463
1464 _func_exit_;
1465
1466         return status;
1467 #else
1468         return 0;
1469 #endif
1470 }
1471 //------------------------------------------------------------------------------
1472 NDIS_STATUS oid_rt_pro_set_data_rate_ex_hdl(struct oid_par_priv *poid_par_priv)
1473 {
1474         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
1475
1476 #ifdef PLATFORM_OS_XP
1477         _irqL           oldirql;
1478 #endif
1479         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1480
1481 _func_enter_;
1482
1483         RT_TRACE(_module_mp_, _drv_notice_, ("+OID_RT_PRO_SET_DATA_RATE_EX\n"));
1484
1485         if (poid_par_priv->type_of_oid != SET_OID)
1486                 return NDIS_STATUS_NOT_ACCEPTED;
1487
1488         _irqlevel_changed_(&oldirql, LOWER);
1489
1490         if (rtw_setdatarate_cmd(Adapter, poid_par_priv->information_buf) !=_SUCCESS)
1491                 status = NDIS_STATUS_NOT_ACCEPTED;
1492
1493         _irqlevel_changed_(&oldirql, RAISE);
1494
1495 _func_exit_;
1496
1497         return status;
1498 }
1499 //-----------------------------------------------------------------------------
1500 NDIS_STATUS oid_rt_get_thermal_meter_hdl(struct oid_par_priv *poid_par_priv)
1501 {
1502 #ifdef PLATFORM_OS_XP
1503         _irqL           oldirql;
1504 #endif
1505         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1506         u8 thermal = 0;
1507         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
1508
1509 _func_enter_;
1510
1511         RT_TRACE(_module_mp_, _drv_notice_, ("+oid_rt_get_thermal_meter_hdl\n"));
1512
1513         if (poid_par_priv->type_of_oid != QUERY_OID)
1514                 return NDIS_STATUS_NOT_ACCEPTED;
1515
1516         if (poid_par_priv->information_buf_len < sizeof(u32))
1517                 return NDIS_STATUS_INVALID_LENGTH;
1518
1519         _irqlevel_changed_(&oldirql, LOWER);
1520         GetThermalMeter(Adapter, &thermal);
1521         _irqlevel_changed_(&oldirql, RAISE);
1522
1523         *(u32*)poid_par_priv->information_buf = (u32)thermal;
1524         *poid_par_priv->bytes_rw = sizeof(u32);
1525
1526 _func_exit_;
1527
1528         return status;
1529 }
1530 //-----------------------------------------------------------------------------
1531 NDIS_STATUS oid_rt_pro_read_tssi_hdl(struct oid_par_priv *poid_par_priv)
1532 {
1533 #if 0
1534         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
1535
1536 #ifdef PLATFORM_OS_XP
1537         _irqL           oldirql;
1538 #endif
1539         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1540
1541 _func_enter_;
1542
1543         RT_TRACE(_module_mp_, _drv_notice_, ("+oid_rt_pro_read_tssi_hdl\n"));
1544
1545         if (poid_par_priv->type_of_oid != SET_OID)
1546                 return NDIS_STATUS_NOT_ACCEPTED;
1547
1548         if (Adapter->mppriv.act_in_progress == _TRUE)
1549                 return NDIS_STATUS_NOT_ACCEPTED;
1550
1551         if (poid_par_priv->information_buf_len < sizeof(u8))
1552                 return NDIS_STATUS_INVALID_LENGTH;
1553
1554         //init workparam
1555         Adapter->mppriv.act_in_progress = _TRUE;
1556         Adapter->mppriv.workparam.bcompleted = _FALSE;
1557         Adapter->mppriv.workparam.act_type = MPT_READ_TSSI;
1558         Adapter->mppriv.workparam.io_offset = 0;
1559         Adapter->mppriv.workparam.io_value = 0xFFFFFFFF;
1560
1561         _irqlevel_changed_(&oldirql, LOWER);
1562
1563         if (!rtw_gettssi_cmd(Adapter,0, (u8*)&Adapter->mppriv.workparam.io_value))
1564                 status = NDIS_STATUS_NOT_ACCEPTED;
1565
1566         _irqlevel_changed_(&oldirql, RAISE);
1567
1568 _func_exit_;
1569
1570         return status;
1571 #else
1572         return 0;
1573 #endif
1574 }
1575 //------------------------------------------------------------------------------
1576 NDIS_STATUS oid_rt_pro_set_power_tracking_hdl(struct oid_par_priv *poid_par_priv)
1577 {
1578 #ifdef PLATFORM_OS_XP
1579         _irqL           oldirql;
1580 #endif
1581         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1582         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
1583
1584
1585 _func_enter_;
1586
1587 //      if (poid_par_priv->type_of_oid != SET_OID)
1588 //              return NDIS_STATUS_NOT_ACCEPTED;
1589
1590         if (poid_par_priv->information_buf_len < sizeof(u8))
1591                 return NDIS_STATUS_INVALID_LENGTH;
1592
1593         _irqlevel_changed_(&oldirql, LOWER);
1594         if (poid_par_priv->type_of_oid == SET_OID) {
1595                 u8 enable;
1596
1597                 enable = *(u8*)poid_par_priv->information_buf;
1598                 RT_TRACE(_module_mp_, _drv_notice_,
1599                          ("+oid_rt_pro_set_power_tracking_hdl: enable=%d\n", enable));
1600
1601                 SetPowerTracking(Adapter, enable);
1602         } else {
1603                 GetPowerTracking(Adapter, (u8*)poid_par_priv->information_buf);
1604         }
1605         _irqlevel_changed_(&oldirql, RAISE);
1606
1607 _func_exit_;
1608
1609         return status;
1610 }
1611 //-----------------------------------------------------------------------------
1612 NDIS_STATUS oid_rt_pro_set_basic_rate_hdl(struct oid_par_priv *poid_par_priv)
1613 {
1614 #if 0
1615 #ifdef PLATFORM_OS_XP
1616         _irqL           oldirql;
1617 #endif
1618         u32 ratevalue;
1619         u8 datarates[NumRates];
1620         int i;
1621         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1622         PADAPTER        padapter = (PADAPTER)(poid_par_priv->adapter_context);
1623
1624 _func_enter_;
1625
1626         RT_TRACE(_module_mp_, _drv_info_, ("+OID_RT_PRO_SET_BASIC_RATE\n"));
1627
1628         if (poid_par_priv->type_of_oid != SET_OID)
1629                 return NDIS_STATUS_NOT_ACCEPTED;
1630 #if 0
1631         ratevalue = *((u32*)poid_par_priv->information_buf);
1632
1633         for (i = 0; i < NumRates; i++) {
1634                 if (ratevalue == mpdatarate[i])
1635                         datarates[i] = mpdatarate[i];
1636                 else
1637                         datarates[i] = 0xff;
1638                 RT_TRACE(_module_rtl871x_ioctl_c_, _drv_info_, ("basicrate_inx=%d\n", datarates[i]));
1639         }
1640
1641         _irqlevel_changed_(&oldirql, LOWER);
1642
1643         if (rtw_setbasicrate_cmd(padapter, datarates) != _SUCCESS)
1644                 status = NDIS_STATUS_NOT_ACCEPTED;
1645
1646         _irqlevel_changed_(&oldirql, RAISE);
1647 #endif
1648         RT_TRACE(_module_mp_, _drv_notice_,
1649                  ("-OID_RT_PRO_SET_BASIC_RATE: status=0x%08X\n", status));
1650
1651 _func_exit_;
1652
1653         return status;
1654 #else
1655         return 0;
1656 #endif
1657 }
1658 //------------------------------------------------------------------------------
1659 NDIS_STATUS oid_rt_pro_qry_pwrstate_hdl(struct oid_par_priv *poid_par_priv)
1660 {
1661 #if 0
1662         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
1663
1664         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1665
1666 _func_enter_;
1667
1668         if (poid_par_priv->type_of_oid != QUERY_OID)
1669                 return NDIS_STATUS_NOT_ACCEPTED;
1670
1671         if (poid_par_priv->information_buf_len < 8)
1672                 return NDIS_STATUS_INVALID_LENGTH;
1673
1674         *poid_par_priv->bytes_rw = 8;
1675         _rtw_memcpy(poid_par_priv->information_buf, &(adapter_to_pwrctl(Adapter)->pwr_mode), 8);
1676         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
1677
1678         RT_TRACE(_module_mp_, _drv_notice_,
1679                  ("-oid_rt_pro_qry_pwrstate_hdl: pwr_mode=%d smart_ps=%d\n",
1680                   adapter_to_pwrctl(Adapter)->pwr_mode, adapter_to_pwrctl(Adapter)->smart_ps));
1681
1682 _func_exit_;
1683
1684         return status;
1685 #else
1686         return 0;
1687 #endif
1688 }
1689 //------------------------------------------------------------------------------
1690 NDIS_STATUS oid_rt_pro_set_pwrstate_hdl(struct oid_par_priv *poid_par_priv)
1691 {
1692 #if 0
1693         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
1694
1695         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1696
1697         uint pwr_mode, smart_ps;
1698
1699 _func_enter_;
1700
1701         RT_TRACE(_module_mp_, _drv_notice_, ("+Set OID_RT_PRO_SET_PWRSTATE\n"));
1702
1703         if (poid_par_priv->type_of_oid != SET_OID)
1704                 return NDIS_STATUS_NOT_ACCEPTED;
1705
1706         *poid_par_priv->bytes_rw = 0;
1707         *poid_par_priv->bytes_needed = 8;
1708
1709         if (poid_par_priv->information_buf_len < 8)
1710                 return NDIS_STATUS_INVALID_LENGTH;
1711
1712         pwr_mode = *(uint *)(poid_par_priv->information_buf);
1713         smart_ps = *(uint *)((int)poid_par_priv->information_buf + 4);
1714
1715         *poid_par_priv->bytes_rw = 8;
1716
1717 _func_exit_;
1718
1719         return status;
1720 #else
1721         return 0;
1722 #endif
1723 }
1724 //------------------------------------------------------------------------------
1725 NDIS_STATUS oid_rt_pro_h2c_set_rate_table_hdl(struct oid_par_priv *poid_par_priv)
1726 {
1727 #if 0
1728         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
1729
1730 #ifdef PLATFORM_OS_XP
1731         _irqL           oldirql;
1732 #endif
1733         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1734
1735         struct setratable_parm *prate_table;
1736         u8              res;
1737
1738 _func_enter_;
1739
1740         if (poid_par_priv->type_of_oid != SET_OID)
1741                 return NDIS_STATUS_NOT_ACCEPTED;
1742
1743         *poid_par_priv->bytes_needed  = sizeof(struct setratable_parm);
1744         if (poid_par_priv->information_buf_len < sizeof(struct setratable_parm))
1745                 return NDIS_STATUS_INVALID_LENGTH;
1746
1747         prate_table = (struct setratable_parm*)poid_par_priv->information_buf;
1748
1749         _irqlevel_changed_(&oldirql, LOWER);
1750         res = rtw_setrttbl_cmd(Adapter, prate_table);
1751         _irqlevel_changed_(&oldirql, RAISE);
1752
1753         if (res == _FAIL)
1754                 status = NDIS_STATUS_FAILURE;
1755
1756 _func_exit_;
1757
1758         return status;
1759 #else
1760         return 0;
1761 #endif
1762 }
1763 //------------------------------------------------------------------------------
1764 NDIS_STATUS oid_rt_pro_h2c_get_rate_table_hdl(struct oid_par_priv *poid_par_priv)
1765 {
1766 #if 0
1767         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
1768
1769         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1770
1771 _func_enter_;
1772
1773         if (poid_par_priv->type_of_oid != QUERY_OID)
1774                 return NDIS_STATUS_NOT_ACCEPTED;
1775
1776         #if 0
1777                         struct mp_wi_cntx *pmp_wi_cntx=&(Adapter->mppriv.wi_cntx);
1778                         u8 res=_SUCCESS;
1779                         DEBUG_INFO(("===> Set OID_RT_PRO_H2C_GET_RATE_TABLE.\n"));
1780
1781                         if(pmp_wi_cntx->bmp_wi_progress ==_TRUE){
1782                                 DEBUG_ERR(("\n mp workitem is progressing, not allow to set another workitem right now!!!\n"));
1783                                 Status = NDIS_STATUS_NOT_ACCEPTED;
1784                                 break;
1785                         }
1786                         else{
1787                                 pmp_wi_cntx->bmp_wi_progress=_TRUE;
1788                                 pmp_wi_cntx->param.bcompleted=_FALSE;
1789                                 pmp_wi_cntx->param.act_type=MPT_GET_RATE_TABLE;
1790                                 pmp_wi_cntx->param.io_offset=0x0;
1791                                 pmp_wi_cntx->param.bytes_cnt=sizeof(struct getratable_rsp);
1792                                 pmp_wi_cntx->param.io_value=0xffffffff;
1793
1794                                 res=rtw_getrttbl_cmd(Adapter,(struct getratable_rsp *)pmp_wi_cntx->param.data);
1795                                 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
1796                                 if(res != _SUCCESS)
1797                                 {
1798                                         Status = NDIS_STATUS_NOT_ACCEPTED;
1799                                 }
1800                         }
1801                         DEBUG_INFO(("\n <=== Set OID_RT_PRO_H2C_GET_RATE_TABLE.\n"));
1802         #endif
1803
1804 _func_exit_;
1805
1806         return status;
1807 #else
1808         return 0;
1809 #endif
1810 }
1811
1812 //****************  oid_rtl_seg_87_12_00   section start ****************
1813 NDIS_STATUS oid_rt_pro_encryption_ctrl_hdl(struct oid_par_priv *poid_par_priv)
1814 {
1815 #if 0
1816         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
1817         struct security_priv *psecuritypriv = &Adapter->securitypriv;
1818
1819         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1820
1821         ENCRY_CTRL_STATE encry_mode;
1822
1823
1824         *poid_par_priv->bytes_needed = sizeof(u8);
1825         if (poid_par_priv->information_buf_len < *poid_par_priv->bytes_needed)
1826                 return NDIS_STATUS_INVALID_LENGTH;
1827
1828         if (poid_par_priv->type_of_oid == SET_OID)
1829         {
1830                 encry_mode = *((u8*)poid_par_priv->information_buf);
1831                 switch (encry_mode)
1832                 {
1833                         case HW_CONTROL:
1834                                 #if 0
1835                                 Adapter->registrypriv.software_decrypt=_FALSE;
1836                                 Adapter->registrypriv.software_encrypt=_FALSE;
1837                                 #else
1838                                 psecuritypriv->sw_decrypt = _FALSE;
1839                                 psecuritypriv->sw_encrypt = _FALSE;
1840                                 #endif
1841                                 break;
1842                         case SW_CONTROL:
1843                                 #if 0
1844                                 Adapter->registrypriv.software_decrypt=_TRUE;
1845                                 Adapter->registrypriv.software_encrypt=_TRUE;
1846                                 #else
1847                                 psecuritypriv->sw_decrypt = _TRUE;
1848                                 psecuritypriv->sw_encrypt = _TRUE;
1849                                 #endif
1850                                 break;
1851                         case HW_ENCRY_SW_DECRY:
1852                                 #if 0
1853                                 Adapter->registrypriv.software_decrypt=_TRUE;
1854                                 Adapter->registrypriv.software_encrypt=_FALSE;
1855                                 #else
1856                                 psecuritypriv->sw_decrypt = _TRUE;
1857                                 psecuritypriv->sw_encrypt = _FALSE;
1858                                 #endif
1859                                 break;
1860                         case SW_ENCRY_HW_DECRY:
1861                                 #if 0
1862                                 Adapter->registrypriv.software_decrypt=_FALSE;
1863                                 Adapter->registrypriv.software_encrypt=_TRUE;
1864                                 #else
1865                                 psecuritypriv->sw_decrypt = _FALSE;
1866                                 psecuritypriv->sw_encrypt = _TRUE;
1867                                 #endif
1868                                 break;
1869                 }
1870
1871                 RT_TRACE(_module_rtl871x_ioctl_c_, _drv_notice_,
1872                          ("-oid_rt_pro_encryption_ctrl_hdl: SET encry_mode=0x%x sw_encrypt=0x%x sw_decrypt=0x%x\n",
1873                           encry_mode, psecuritypriv->sw_encrypt, psecuritypriv->sw_decrypt));
1874         }
1875         else {
1876                 #if 0
1877                 if (Adapter->registrypriv.software_encrypt == _FALSE) {
1878                         if (Adapter->registrypriv.software_decrypt == _FALSE)
1879                                 encry_mode = HW_CONTROL;
1880                         else
1881                                 encry_mode = HW_ENCRY_SW_DECRY;
1882                 }
1883                 else {
1884                         if (Adapter->registrypriv.software_decrypt == _FALSE)
1885                                 encry_mode = SW_ENCRY_HW_DECRY;
1886                         else
1887                                 encry_mode = SW_CONTROL;
1888                 }
1889                 #else
1890
1891                 if ((psecuritypriv->sw_encrypt == _FALSE) && (psecuritypriv->sw_decrypt == _FALSE))
1892                         encry_mode = HW_CONTROL;
1893                 else if ((psecuritypriv->sw_encrypt == _FALSE) && (psecuritypriv->sw_decrypt == _TRUE))
1894                         encry_mode = HW_ENCRY_SW_DECRY;
1895                 else if ((psecuritypriv->sw_encrypt == _TRUE) && (psecuritypriv->sw_decrypt == _FALSE))
1896                         encry_mode = SW_ENCRY_HW_DECRY;
1897                 else if ((psecuritypriv->sw_encrypt == _TRUE) && (psecuritypriv->sw_decrypt == _TRUE))
1898                         encry_mode = SW_CONTROL;
1899
1900                 #endif
1901
1902                 *(u8*)poid_par_priv->information_buf =  encry_mode;
1903                 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
1904
1905                 RT_TRACE(_module_mp_, _drv_notice_,
1906                          ("-oid_rt_pro_encryption_ctrl_hdl: QUERY encry_mode=0x%x\n",
1907                           encry_mode));
1908         }
1909
1910         return status;
1911 #else
1912         return 0;
1913 #endif
1914 }
1915 //------------------------------------------------------------------------------
1916 NDIS_STATUS oid_rt_pro_add_sta_info_hdl(struct oid_par_priv *poid_par_priv)
1917 {
1918 #if 0
1919         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
1920
1921 #ifdef PLATFORM_OS_XP
1922         _irqL           oldirql;
1923 #endif
1924         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1925
1926         struct sta_info *psta = NULL;
1927         UCHAR           *macaddr;
1928
1929
1930         if (poid_par_priv->type_of_oid != SET_OID)
1931                 return NDIS_STATUS_NOT_ACCEPTED;
1932
1933         *poid_par_priv->bytes_needed = ETH_ALEN;
1934         if (poid_par_priv->information_buf_len < *poid_par_priv->bytes_needed)
1935                 return NDIS_STATUS_INVALID_LENGTH;
1936
1937         macaddr = (UCHAR *) poid_par_priv->information_buf ;
1938
1939         RT_TRACE(_module_rtl871x_ioctl_c_,_drv_notice_,
1940                  ("OID_RT_PRO_ADD_STA_INFO: addr="MAC_FMT"\n", MAC_ARG(macaddr) ));
1941
1942         _irqlevel_changed_(&oldirql, LOWER);
1943
1944         psta = rtw_get_stainfo(&Adapter->stapriv, macaddr);
1945
1946         if (psta == NULL) { // the sta have been in sta_info_queue => do nothing
1947                 psta = rtw_alloc_stainfo(&Adapter->stapriv, macaddr);
1948
1949                 if (psta == NULL) {
1950                         RT_TRACE(_module_rtl871x_ioctl_c_,_drv_err_,("Can't alloc sta_info when OID_RT_PRO_ADD_STA_INFO\n"));
1951                         status = NDIS_STATUS_FAILURE;
1952                 }
1953         } else { //(between drv has received this event before and  fw have not yet to set key to CAM_ENTRY)
1954                 RT_TRACE(_module_rtl871x_ioctl_c_, _drv_err_,
1955                         ("Error: OID_RT_PRO_ADD_STA_INFO: sta has been in sta_hash_queue \n"));
1956         }
1957
1958         _irqlevel_changed_(&oldirql, RAISE);
1959
1960         return status;
1961 #else
1962         return 0;
1963 #endif
1964 }
1965 //------------------------------------------------------------------------------
1966 NDIS_STATUS oid_rt_pro_dele_sta_info_hdl(struct oid_par_priv *poid_par_priv)
1967 {
1968 #if 0
1969         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
1970
1971 #ifdef PLATFORM_OS_XP
1972         _irqL           oldirql;
1973 #endif
1974         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
1975
1976         struct sta_info *psta = NULL;
1977         UCHAR           *macaddr;
1978
1979
1980         if (poid_par_priv->type_of_oid != SET_OID)
1981                 return NDIS_STATUS_NOT_ACCEPTED;
1982
1983         *poid_par_priv->bytes_needed = ETH_ALEN;
1984         if (poid_par_priv->information_buf_len < *poid_par_priv->bytes_needed)
1985                 return NDIS_STATUS_INVALID_LENGTH;
1986
1987         macaddr = (UCHAR *) poid_par_priv->information_buf ;
1988         RT_TRACE(_module_rtl871x_ioctl_c_,_drv_notice_,
1989                  ("+OID_RT_PRO_ADD_STA_INFO: addr="MAC_FMT"\n", MAC_ARG(macaddr) ));
1990
1991         psta = rtw_get_stainfo(&Adapter->stapriv, macaddr);
1992         if (psta != NULL) {
1993                 //_enter_critical(&(Adapter->stapriv.sta_hash_lock), &irqL);
1994                 rtw_free_stainfo(Adapter, psta);
1995                 //_exit_critical(&(Adapter->stapriv.sta_hash_lock), &irqL);
1996         }
1997
1998         return status;
1999 #else
2000         return 0;
2001 #endif
2002 }
2003 //------------------------------------------------------------------------------
2004 #if 0
2005 static u32 mp_query_drv_var(_adapter *padapter, u8 offset, u32 var)
2006 {
2007 #ifdef CONFIG_SDIO_HCI
2008
2009         if (offset == 1) {
2010                 u16 tmp_blk_num;
2011                 tmp_blk_num = rtw_read16(padapter, SDIO_RX0_RDYBLK_NUM);
2012                 RT_TRACE(_module_mp_, _drv_err_, ("Query Information, mp_query_drv_var  SDIO_RX0_RDYBLK_NUM=0x%x   dvobj.rxblknum=0x%x\n", tmp_blk_num, adapter_to_dvobj(padapter)->rxblknum));
2013                 if (adapter_to_dvobj(padapter)->rxblknum != tmp_blk_num) {
2014                         RT_TRACE(_module_mp_,_drv_err_, ("Query Information, mp_query_drv_var  call recv rx\n"));
2015                 //      sd_recv_rxfifo(padapter);
2016                 }
2017         }
2018
2019 #if 0
2020         if(offset <=100){  //For setting data rate and query data rate
2021                 if(offset==100){ //For query data rate
2022                         RT_TRACE(_module_mp_, _drv_emerg_, ("\n mp_query_drv_var: offset(%d): query rate=0x%.2x \n",offset,padapter->registrypriv.tx_rate));
2023                         var=padapter->registrypriv.tx_rate;
2024
2025                 }
2026                 else if(offset<0x1d){  //For setting data rate
2027                         padapter->registrypriv.tx_rate=offset;
2028                         var=padapter->registrypriv.tx_rate;
2029                         padapter->registrypriv.use_rate=_TRUE;
2030                         RT_TRACE(_module_mp_, _drv_emerg_, ("\n mp_query_drv_var: offset(%d): set rate=0x%.2x \n",offset,padapter->registrypriv.tx_rate));
2031                 }
2032                 else{ //not use the data rate
2033                         padapter->registrypriv.use_rate=_FALSE;
2034                         RT_TRACE(_module_mp_, _drv_emerg_, ("\n mp_query_drv_var: offset(%d) out of rate range\n",offset));
2035                 }
2036         }
2037         else if (offset<=110){  //for setting debug level
2038                 RT_TRACE(_module_mp_, _drv_emerg_, (" mp_query_drv_var: offset(%d) for set debug level\n",offset));
2039                 if(offset==110){ //For query data rate
2040                         RT_TRACE(_module_mp_, _drv_emerg_, (" mp_query_drv_var: offset(%d): query dbg level=0x%.2x \n",offset,padapter->registrypriv.dbg_level));
2041                         padapter->registrypriv.dbg_level=GlobalDebugLevel;
2042                         var=padapter->registrypriv.dbg_level;
2043                 }
2044                 else if(offset<110 && offset>100){
2045                         RT_TRACE(_module_mp_, _drv_emerg_, (" mp_query_drv_var: offset(%d): set dbg level=0x%.2x \n",offset,offset-100));
2046                         padapter->registrypriv.dbg_level=GlobalDebugLevel=offset-100;
2047                         var=padapter->registrypriv.dbg_level;
2048                         RT_TRACE(_module_mp_, _drv_emerg_, (" mp_query_drv_var(_drv_emerg_): offset(%d): set dbg level=0x%.2x \n",offset,GlobalDebugLevel));
2049                         RT_TRACE(_module_mp_, _drv_alert_, (" mp_query_drv_var(_drv_alert_): offset(%d): set dbg level=0x%.2x \n",offset,GlobalDebugLevel));
2050                         RT_TRACE(_module_mp_, _drv_crit_, (" mp_query_drv_var(_drv_crit_): offset(%d): set dbg level=0x%.2x \n",offset,GlobalDebugLevel));
2051                         RT_TRACE(_module_mp_, _drv_err_, (" mp_query_drv_var(_drv_err_): offset(%d): set dbg level=0x%.2x \n",offset,GlobalDebugLevel));
2052                         RT_TRACE(_module_mp_, _drv_warning_, (" mp_query_drv_var(_drv_warning_): offset(%d): set dbg level=0x%.2x \n",offset,GlobalDebugLevel));
2053                         RT_TRACE(_module_mp_, _drv_notice_, (" mp_query_drv_var(_drv_notice_): offset(%d): set dbg level=0x%.2x \n",offset,GlobalDebugLevel));
2054                         RT_TRACE(_module_mp_, _drv_info_, (" mp_query_drv_var(_drv_info_): offset(%d): set dbg level=0x%.2x \n",offset,GlobalDebugLevel));
2055                         RT_TRACE(_module_mp_, _drv_debug_, (" mp_query_drv_var(_drv_debug_): offset(%d): set dbg level=0x%.2x \n",offset,GlobalDebugLevel));
2056
2057                 }
2058         }
2059         else if(offset >110 &&offset <116){
2060                 if(115==offset){
2061                         RT_TRACE(_module_mp_, _drv_emerg_, (" mp_query_drv_var(_drv_emerg_): offset(%d): query TRX access type: [tx_block_mode=%x,rx_block_mode=%x]\n",\
2062                                                                                                                         offset, adapter_to_dvobj(padapter)->tx_block_mode, adapter_to_dvobj(padapter)->rx_block_mode));
2063                 }
2064                 else {
2065                         switch(offset){
2066                                 case 111:
2067                                         adapter_to_dvobj(padapter)->tx_block_mode=1;
2068                                         adapter_to_dvobj(padapter)->rx_block_mode=1;
2069                                         RT_TRACE(_module_mp_, _drv_emerg_, \
2070                                                 (" mp_query_drv_var(_drv_emerg_): offset(%d): SET TRX access type:(TX block/RX block) [tx_block_mode=%x,rx_block_mode=%x]\n",\
2071                                                 offset, adapter_to_dvobj(padapter)->tx_block_mode, adapter_to_dvobj(padapter)->rx_block_mode));
2072                                         break;
2073                                 case 112:
2074                                         adapter_to_dvobj(padapter)->tx_block_mode=1;
2075                                         adapter_to_dvobj(padapter)->rx_block_mode=0;
2076                                         RT_TRACE(_module_mp_, _drv_emerg_, \
2077                                                 (" mp_query_drv_var(_drv_emerg_): offset(%d): SET TRX access type:(TX block/RX byte) [tx_block_mode=%x,rx_block_mode=%x]\n",\
2078                                                 offset, adapter_to_dvobj(padapter)->tx_block_mode, adapter_to_dvobj(padapter)->rx_block_mode));
2079                                         break;
2080                                 case 113:
2081                                         adapter_to_dvobj(padapter)->tx_block_mode=0;
2082                                         adapter_to_dvobj(padapter)->rx_block_mode=1;
2083                                         RT_TRACE(_module_mp_, _drv_emerg_, \
2084                                                 (" mp_query_drv_var(_drv_emerg_): offset(%d): SET TRX access type:(TX byte/RX block) [tx_block_mode=%x,rx_block_mode=%x]\n",\
2085                                                 offset, adapter_to_dvobj(padapter)->tx_block_mode, adapter_to_dvobj(padapter)->rx_block_mode));
2086                                         break;
2087                                 case 114:
2088                                         adapter_to_dvobj(padapter)->tx_block_mode=0;
2089                                         adapter_to_dvobj(padapter)->rx_block_mode=0;
2090                                         RT_TRACE(_module_mp_, _drv_emerg_, \
2091                                                 (" mp_query_drv_var(_drv_emerg_): offset(%d): SET TRX access type:(TX byte/RX byte) [tx_block_mode=%x,rx_block_mode=%x]\n",\
2092                                                 offset, adapter_to_dvobj(padapter)->tx_block_mode, adapter_to_dvobj(padapter)->rx_block_mode));
2093                                         break;
2094                                 default :
2095                                         break;
2096
2097                         }
2098
2099                 }
2100
2101         }
2102         else if(offset>=127){
2103                 u64     prnt_dbg_comp;
2104                 u8   chg_idx;
2105                 u64     tmp_dbg_comp;
2106                 chg_idx=offset-0x80;
2107                 tmp_dbg_comp=BIT(chg_idx);
2108                 prnt_dbg_comp=padapter->registrypriv.dbg_component= GlobalDebugComponents;
2109                 RT_TRACE(_module_mp_, _drv_emerg_, (" 1: mp_query_drv_var: offset(%d;0x%x):for dbg conpoment prnt_dbg_comp=0x%.16x GlobalDebugComponents=0x%.16x padapter->registrypriv.dbg_component=0x%.16x\n",offset,offset,prnt_dbg_comp,GlobalDebugComponents,padapter->registrypriv.dbg_component));
2110                 if(offset==127){
2111         //              prnt_dbg_comp=padapter->registrypriv.dbg_component= GlobalDebugComponents;
2112                         var=(u32)(padapter->registrypriv.dbg_component);
2113                         RT_TRACE(0xffffffff, _drv_emerg_, ("2: mp_query_drv_var: offset(%d;0x%x):for query dbg conpoment=0x%x(l) 0x%x(h)  GlobalDebugComponents=0x%x(l) 0x%x(h) \n",offset,offset,padapter->registrypriv.dbg_component,prnt_dbg_comp));
2114                         prnt_dbg_comp=GlobalDebugComponents;
2115                         RT_TRACE(0xffffffff, _drv_emerg_, ("2-1: mp_query_drv_var: offset(%d;0x%x):for query dbg conpoment=0x%x(l) 0x%x(h)  GlobalDebugComponents=0x%x(l) 0x%x(h)\n",offset,offset,padapter->registrypriv.dbg_component,prnt_dbg_comp));
2116                         prnt_dbg_comp=GlobalDebugComponents=padapter->registrypriv.dbg_component;
2117                         RT_TRACE(0xffffffff, _drv_emerg_, ("2-2: mp_query_drv_var: offset(%d;0x%x):for query dbg conpoment=0x%x(l) 0x%x(h)  GlobalDebugComponents=0x%x(l) 0x%x(h)\n",offset,offset,padapter->registrypriv.dbg_component,prnt_dbg_comp));
2118
2119                 }
2120                 else{
2121                         RT_TRACE(0xffffffff, _drv_emerg_, ("3: mp_query_drv_var: offset(%d;0x%x):for query dbg conpoment=0x%x(l) 0x%x(h) GlobalDebugComponents=0x%x(l) 0x%x(h) chg_idx=%d\n",offset,offset,padapter->registrypriv.dbg_component,prnt_dbg_comp,chg_idx));
2122                         prnt_dbg_comp=GlobalDebugComponents;
2123                         RT_TRACE(0xffffffff, _drv_emerg_,("3-1: mp_query_drv_var: offset(%d;0x%x):for query dbg conpoment=0x%x(l) 0x%x(h)  GlobalDebugComponents=0x%x(l) 0x%x(h) chg_idx=%d\n",offset,offset,padapter->registrypriv.dbg_component,prnt_dbg_comp,chg_idx));// ("3-1: mp_query_drv_var: offset(%d;0x%x):before set dbg conpoment=0x%x chg_idx=%d or0x%x BIT(chg_idx[%d]=0x%x)\n",offset,offset,prnt_dbg_comp,chg_idx,chg_idx,(chg_idx),tmp_dbg_comp)
2124                         prnt_dbg_comp=GlobalDebugComponents=padapter->registrypriv.dbg_component;
2125                         RT_TRACE(0xffffffff, _drv_emerg_, ("3-2: mp_query_drv_var: offset(%d;0x%x):for query dbg conpoment=0x%x(l) 0x%x(h)  GlobalDebugComponents=0x%x(l) 0x%x(h)\n",offset,offset,padapter->registrypriv.dbg_component,prnt_dbg_comp));
2126
2127                         if(GlobalDebugComponents&tmp_dbg_comp){
2128                                 //this bit is already set, now clear it
2129                                 GlobalDebugComponents=GlobalDebugComponents&(~tmp_dbg_comp);
2130                         }
2131                         else{
2132                                 //this bit is not set, now set it.
2133                                 GlobalDebugComponents =GlobalDebugComponents|tmp_dbg_comp;
2134                         }
2135                         RT_TRACE(0xffffffff, _drv_emerg_, ("4: mp_query_drv_var: offset(%d;0x%x):before set dbg conpoment tmp_dbg_comp=0x%x GlobalDebugComponents=0x%x(l) 0x%x(h)",offset,offset,tmp_dbg_comp,prnt_dbg_comp));
2136                         prnt_dbg_comp=GlobalDebugComponents;
2137                         RT_TRACE(0xffffffff, _drv_emerg_, ("4-1: mp_query_drv_var: offset(%d;0x%x):before set dbg conpoment tmp_dbg_comp=0x%x GlobalDebugComponents=0x%x(l) 0x%x(h)",offset,offset,tmp_dbg_comp,prnt_dbg_comp));
2138
2139                         RT_TRACE(_module_rtl871x_xmit_c_, _drv_emerg_, ("0: mp_query_drv_var(_module_rtl871x_xmit_c_:0): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,prnt_dbg_comp));
2140                         RT_TRACE(_module_xmit_osdep_c_, _drv_emerg_, ("1: mp_query_drv_var(_module_xmit_osdep_c_:1): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2141                         RT_TRACE(_module_rtl871x_recv_c_, _drv_emerg_, ("2: mp_query_drv_var(_module_rtl871x_recv_c_:2): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2142                         RT_TRACE(_module_recv_osdep_c_, _drv_emerg_, ("3: mp_query_drv_var(_module_recv_osdep_c_:3): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2143                         RT_TRACE(_module_rtl871x_mlme_c_, _drv_emerg_, ("4: mp_query_drv_var(_module_rtl871x_mlme_c_:4): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2144                         RT_TRACE(_module_mlme_osdep_c_, _drv_emerg_, (" 5:mp_query_drv_var(_module_mlme_osdep_c_:5): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2145                         RT_TRACE(_module_rtl871x_sta_mgt_c_, _drv_emerg_, ("6: mp_query_drv_var(_module_rtl871x_sta_mgt_c_:6): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2146                         RT_TRACE(_module_rtl871x_cmd_c_, _drv_emerg_, ("7: mp_query_drv_var(_module_rtl871x_cmd_c_:7): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2147                         RT_TRACE(_module_cmd_osdep_c_, _drv_emerg_, ("8: mp_query_drv_var(_module_cmd_osdep_c_:8): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2148                         RT_TRACE(_module_rtl871x_io_c_, _drv_emerg_, ("9: mp_query_drv_var(_module_rtl871x_io_c_:9): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2149                         RT_TRACE(_module_io_osdep_c_, _drv_emerg_, ("10: mp_query_drv_var(_module_io_osdep_c_:10): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2150                         RT_TRACE(_module_os_intfs_c_, _drv_emerg_, ("11: mp_query_drv_var(_module_os_intfs_c_:11): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2151                         RT_TRACE(_module_rtl871x_security_c_, _drv_emerg_, ("12: mp_query_drv_var(_module_rtl871x_security_c_:12): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2152                         RT_TRACE(_module_rtl871x_eeprom_c_, _drv_emerg_, ("13: mp_query_drv_var(_module_rtl871x_eeprom_c_:13): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2153                         RT_TRACE(_module_hal_init_c_, _drv_emerg_, ("14: mp_query_drv_var(_module_hal_init_c_:14): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2154                         RT_TRACE(_module_hci_hal_init_c_, _drv_emerg_, ("15: mp_query_drv_var(_module_hci_hal_init_c_:15): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2155                         RT_TRACE(_module_rtl871x_ioctl_c_, _drv_emerg_, ("16: mp_query_drv_var(_module_rtl871x_ioctl_c_:16): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2156                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_emerg_, ("17: mp_query_drv_var(_module_rtl871x_ioctl_set_c_:17): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2157                         RT_TRACE(_module_rtl871x_ioctl_query_c_, _drv_emerg_, ("18: mp_query_drv_var(_module_rtl871x_ioctl_query_c_:18): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2158                         RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_emerg_, ("19: mp_query_drv_var(_module_rtl871x_pwrctrl_c_:19): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2159                         RT_TRACE(_module_hci_intfs_c_, _drv_emerg_, ("20: mp_query_drv_var(_module_hci_intfs_c_:20): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2160                         RT_TRACE(_module_hci_ops_c_, _drv_emerg_, ("21: mp_query_drv_var(_module_hci_ops_c_:21): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2161                         RT_TRACE(_module_osdep_service_c_, _drv_emerg_, ("22: mp_query_drv_var(_module_osdep_service_c_:22): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2162                         RT_TRACE(_module_mp_, _drv_emerg_, ("23: mp_query_drv_var(_module_mp_:23): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2163                         RT_TRACE(_module_hci_ops_os_c_, _drv_emerg_, ("24: mp_query_drv_var(_module_hci_ops_os_c_:24): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2164                         var=(u32)(GlobalDebugComponents);
2165                         //GlobalDebugComponents=padapter->registrypriv.dbg_component;
2166                         RT_TRACE(0xffffffff, _drv_emerg_, (" ==mp_query_drv_var(_module_mp_): offset(%d;0x%x):before set dbg conpoment=0x%x(l) 0x%x(h)\n",offset,offset,GlobalDebugComponents));
2167
2168                 }
2169         }
2170         else{
2171                 RT_TRACE(_module_mp_, _drv_emerg_, ("\n mp_query_drv_var: offset(%d) >110\n",offset));
2172         }
2173 #endif
2174 #endif
2175
2176         return var;
2177 }
2178 #endif
2179
2180 NDIS_STATUS oid_rt_pro_query_dr_variable_hdl(struct oid_par_priv *poid_par_priv)
2181 {
2182 #if 0
2183         PADAPTER                Adapter = (PADAPTER)(poid_par_priv->adapter_context);
2184
2185 #ifdef PLATFORM_OS_XP
2186         _irqL                   oldirql;
2187 #endif
2188         NDIS_STATUS             status = NDIS_STATUS_SUCCESS;
2189
2190         DR_VARIABLE_STRUCT      *pdrv_var;
2191
2192
2193         if (poid_par_priv->type_of_oid != QUERY_OID)
2194                 return NDIS_STATUS_NOT_ACCEPTED;
2195
2196         *poid_par_priv->bytes_needed = sizeof(DR_VARIABLE_STRUCT);
2197         if (poid_par_priv->information_buf_len < *poid_par_priv->bytes_needed)
2198                 return NDIS_STATUS_INVALID_LENGTH;
2199
2200         RT_TRACE(_module_mp_, _drv_notice_, ("+Query Information, OID_RT_PRO_QUERY_DR_VARIABLE\n"));
2201
2202         pdrv_var = (struct _DR_VARIABLE_STRUCT_ *)poid_par_priv->information_buf;
2203
2204         _irqlevel_changed_(&oldirql, LOWER);
2205         pdrv_var->variable = mp_query_drv_var(Adapter, pdrv_var->offset, pdrv_var->variable);
2206         _irqlevel_changed_(&oldirql, RAISE);
2207
2208         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
2209
2210         RT_TRACE(_module_mp_, _drv_notice_,
2211                  ("-oid_rt_pro_query_dr_variable_hdl: offset=0x%x valule=0x%x\n",
2212                   pdrv_var->offset, pdrv_var->variable));
2213
2214         return status;
2215 #else
2216         return 0;
2217 #endif
2218 }
2219 //------------------------------------------------------------------------------
2220 NDIS_STATUS oid_rt_pro_rx_packet_type_hdl(struct oid_par_priv *poid_par_priv)
2221 {
2222 #if 0
2223         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
2224
2225         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
2226
2227         RT_TRACE(_module_mp_, _drv_err_, ("oid_rt_pro_rx_packet_type_hdl...................\n"));
2228
2229         if (poid_par_priv->information_buf_len < sizeof (UCHAR)) {
2230                 status = NDIS_STATUS_INVALID_LENGTH;
2231                 *poid_par_priv->bytes_needed = sizeof(UCHAR);
2232                 return status;
2233         }
2234
2235         if (poid_par_priv->type_of_oid == SET_OID) {
2236                 Adapter->mppriv.rx_with_status = *(UCHAR *) poid_par_priv->information_buf;
2237                 RT_TRACE(_module_rtl871x_ioctl_c_,_drv_err_, ("Query Information, OID_RT_PRO_RX_PACKET_TYPE:%d \n",\
2238                                                                                                 Adapter->mppriv.rx_with_status));
2239
2240                 RT_TRACE(_module_rtl871x_ioctl_c_,_drv_err_,("MAC addr=0x%x:0x%x:0x%x:0x%x:0x%x:0x%x  \n",
2241                         Adapter->eeprompriv.mac_addr[0],Adapter->eeprompriv.mac_addr[1],Adapter->eeprompriv.mac_addr[2],\
2242                         Adapter->eeprompriv.mac_addr[3],Adapter->eeprompriv.mac_addr[4],Adapter->eeprompriv.mac_addr[5]));
2243
2244         }
2245         else {
2246                 *(UCHAR *) poid_par_priv->information_buf = Adapter->mppriv.rx_with_status;
2247                 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
2248
2249                 RT_TRACE(_module_rtl871x_ioctl_c_,_drv_err_, ("Query Information, OID_RT_PRO_RX_PACKET_TYPE:%d \n", \
2250                                                                                                 Adapter->mppriv.rx_with_status));
2251
2252                 //*(u32 *)&Adapter->eeprompriv.mac_addr[0]=rtw_read32(Adapter, 0x10250050);
2253                 //*(u16 *)&Adapter->eeprompriv.mac_addr[4]=rtw_read16(Adapter, 0x10250054);
2254                 RT_TRACE(_module_rtl871x_ioctl_c_,_drv_err_,("MAC addr=0x%x:0x%x:0x%x:0x%x:0x%x:0x%x  \n",
2255                         Adapter->eeprompriv.mac_addr[0],Adapter->eeprompriv.mac_addr[1],Adapter->eeprompriv.mac_addr[2],\
2256                         Adapter->eeprompriv.mac_addr[3],Adapter->eeprompriv.mac_addr[4],Adapter->eeprompriv.mac_addr[5]));
2257         }
2258 #endif
2259
2260         return NDIS_STATUS_SUCCESS;
2261 }
2262 //------------------------------------------------------------------------------
2263 NDIS_STATUS oid_rt_pro_read_efuse_hdl(struct oid_par_priv *poid_par_priv)
2264 {
2265 #ifdef PLATFORM_OS_XP
2266         _irqL oldirql;
2267 #endif
2268         PEFUSE_ACCESS_STRUCT pefuse;
2269         u8 *data;
2270         u16 addr = 0, cnts = 0, max_available_size = 0;
2271         NDIS_STATUS status = NDIS_STATUS_SUCCESS;
2272         PADAPTER Adapter = (PADAPTER)(poid_par_priv->adapter_context);
2273
2274 _func_enter_;
2275
2276         if (poid_par_priv->type_of_oid != QUERY_OID)
2277                 return NDIS_STATUS_NOT_ACCEPTED;
2278
2279         if (poid_par_priv->information_buf_len < sizeof(EFUSE_ACCESS_STRUCT))
2280                 return NDIS_STATUS_INVALID_LENGTH;
2281
2282         pefuse = (PEFUSE_ACCESS_STRUCT)poid_par_priv->information_buf;
2283         addr = pefuse->start_addr;
2284         cnts = pefuse->cnts;
2285         data = pefuse->data;
2286
2287         RT_TRACE(_module_mp_, _drv_notice_,
2288                 ("+oid_rt_pro_read_efuse_hd: buf_len=%d addr=%d cnts=%d\n",
2289                  poid_par_priv->information_buf_len, addr, cnts));
2290
2291         EFUSE_GetEfuseDefinition(Adapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (PVOID)&max_available_size, _FALSE);
2292
2293         if ((addr + cnts) > max_available_size) {
2294                 RT_TRACE(_module_mp_, _drv_err_, ("!oid_rt_pro_read_efuse_hdl: parameter error!\n"));
2295                 return NDIS_STATUS_NOT_ACCEPTED;
2296         }
2297
2298         _irqlevel_changed_(&oldirql, LOWER);
2299         if (rtw_efuse_access(Adapter, _FALSE, addr, cnts, data) == _FAIL) {
2300                 RT_TRACE(_module_mp_, _drv_err_, ("!oid_rt_pro_read_efuse_hdl: rtw_efuse_access FAIL!\n"));
2301                 status = NDIS_STATUS_FAILURE;
2302         } else
2303                 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
2304         _irqlevel_changed_(&oldirql, RAISE);
2305
2306 _func_exit_;
2307
2308         return status;
2309 }
2310 //------------------------------------------------------------------------------
2311 NDIS_STATUS oid_rt_pro_write_efuse_hdl(struct oid_par_priv *poid_par_priv)
2312 {
2313 #ifdef PLATFORM_OS_XP
2314         _irqL oldirql;
2315 #endif
2316         PEFUSE_ACCESS_STRUCT pefuse;
2317         u8 *data;
2318         u16 addr = 0, cnts = 0, max_available_size = 0;
2319         NDIS_STATUS status = NDIS_STATUS_SUCCESS;
2320         PADAPTER Adapter = (PADAPTER)(poid_par_priv->adapter_context);
2321
2322
2323 _func_enter_;
2324
2325         if (poid_par_priv->type_of_oid != SET_OID)
2326                 return NDIS_STATUS_NOT_ACCEPTED;
2327
2328         pefuse = (PEFUSE_ACCESS_STRUCT)poid_par_priv->information_buf;
2329         addr = pefuse->start_addr;
2330         cnts = pefuse->cnts;
2331         data = pefuse->data;
2332
2333         RT_TRACE(_module_mp_, _drv_notice_,
2334                  ("+oid_rt_pro_write_efuse_hdl: buf_len=%d addr=0x%04x cnts=%d\n",
2335                   poid_par_priv->information_buf_len, addr, cnts));
2336
2337         EFUSE_GetEfuseDefinition(Adapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (PVOID)&max_available_size, _FALSE);
2338
2339         if ((addr + cnts) > max_available_size) {
2340                 RT_TRACE(_module_mp_, _drv_err_, ("!oid_rt_pro_write_efuse_hdl: parameter error"));
2341                 return NDIS_STATUS_NOT_ACCEPTED;
2342         }
2343
2344         _irqlevel_changed_(&oldirql, LOWER);
2345         if (rtw_efuse_access(Adapter, _TRUE, addr, cnts, data) == _FAIL)
2346                 status = NDIS_STATUS_FAILURE;
2347         _irqlevel_changed_(&oldirql, RAISE);
2348
2349 _func_exit_;
2350
2351         return status;
2352 }
2353 //------------------------------------------------------------------------------
2354 NDIS_STATUS oid_rt_pro_rw_efuse_pgpkt_hdl(struct oid_par_priv *poid_par_priv)
2355 {
2356 #ifdef PLATFORM_OS_XP
2357         _irqL           oldirql;
2358 #endif
2359         PPGPKT_STRUCT   ppgpkt;
2360         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
2361         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
2362
2363 _func_enter_;
2364
2365 //      RT_TRACE(_module_mp_, _drv_info_, ("+oid_rt_pro_rw_efuse_pgpkt_hdl\n"));
2366
2367         *poid_par_priv->bytes_rw = 0;
2368
2369         if (poid_par_priv->information_buf_len < sizeof(PGPKT_STRUCT))
2370                 return NDIS_STATUS_INVALID_LENGTH;
2371
2372         ppgpkt = (PPGPKT_STRUCT)poid_par_priv->information_buf;
2373
2374         _irqlevel_changed_(&oldirql, LOWER);
2375
2376         if (poid_par_priv->type_of_oid == QUERY_OID)
2377         {
2378                 RT_TRACE(_module_mp_, _drv_notice_,
2379                         ("oid_rt_pro_rw_efuse_pgpkt_hdl: Read offset=0x%x\n",\
2380                         ppgpkt->offset));
2381
2382                 Efuse_PowerSwitch(Adapter, _FALSE, _TRUE);
2383                 if (Efuse_PgPacketRead(Adapter, ppgpkt->offset, ppgpkt->data, _FALSE) == _TRUE)
2384                         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
2385                 else
2386                         status = NDIS_STATUS_FAILURE;
2387                 Efuse_PowerSwitch(Adapter, _FALSE, _FALSE);
2388         } else {
2389                 RT_TRACE(_module_mp_, _drv_notice_,
2390                         ("oid_rt_pro_rw_efuse_pgpkt_hdl: Write offset=0x%x word_en=0x%x\n",\
2391                         ppgpkt->offset, ppgpkt->word_en));
2392
2393                 Efuse_PowerSwitch(Adapter, _TRUE, _TRUE);
2394                 if (Efuse_PgPacketWrite(Adapter, ppgpkt->offset, ppgpkt->word_en, ppgpkt->data, _FALSE) == _TRUE)
2395                         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
2396                 else
2397                         status = NDIS_STATUS_FAILURE;
2398                 Efuse_PowerSwitch(Adapter, _TRUE, _FALSE);
2399         }
2400
2401         _irqlevel_changed_(&oldirql, RAISE);
2402
2403         RT_TRACE(_module_mp_, _drv_info_,
2404                  ("-oid_rt_pro_rw_efuse_pgpkt_hdl: status=0x%08X\n", status));
2405
2406 _func_exit_;
2407
2408         return status;
2409 }
2410 //------------------------------------------------------------------------------
2411 NDIS_STATUS oid_rt_get_efuse_current_size_hdl(struct oid_par_priv *poid_par_priv)
2412 {
2413 #ifdef PLATFORM_OS_XP
2414         _irqL           oldirql;
2415 #endif
2416         u16 size;
2417         u8 ret;
2418         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
2419         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
2420
2421 _func_enter_;
2422
2423         if (poid_par_priv->type_of_oid != QUERY_OID)
2424                 return NDIS_STATUS_NOT_ACCEPTED;
2425
2426         if (poid_par_priv->information_buf_len <sizeof(u32))
2427                 return NDIS_STATUS_INVALID_LENGTH;
2428
2429         _irqlevel_changed_(&oldirql, LOWER);
2430         ret = efuse_GetCurrentSize(Adapter, &size);
2431         _irqlevel_changed_(&oldirql, RAISE);
2432         if (ret == _SUCCESS) {
2433                 *(u32*)poid_par_priv->information_buf = size;
2434                 *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
2435         } else
2436                 status = NDIS_STATUS_FAILURE;
2437
2438 _func_exit_;
2439
2440         return status;
2441 }
2442 //------------------------------------------------------------------------------
2443 NDIS_STATUS oid_rt_get_efuse_max_size_hdl(struct oid_par_priv *poid_par_priv)
2444 {
2445         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
2446         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
2447
2448 _func_enter_;
2449
2450         if (poid_par_priv->type_of_oid != QUERY_OID)
2451                 return NDIS_STATUS_NOT_ACCEPTED;
2452
2453         if (poid_par_priv->information_buf_len < sizeof(u32))
2454                 return NDIS_STATUS_INVALID_LENGTH;
2455
2456         *(u32*)poid_par_priv->information_buf = efuse_GetMaxSize(Adapter);
2457         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
2458
2459         RT_TRACE(_module_mp_, _drv_info_,
2460                  ("-oid_rt_get_efuse_max_size_hdl: size=%d status=0x%08X\n",
2461                   *(int*)poid_par_priv->information_buf, status));
2462
2463 _func_exit_;
2464
2465         return status;
2466 }
2467 //------------------------------------------------------------------------------
2468 NDIS_STATUS oid_rt_pro_efuse_hdl(struct oid_par_priv *poid_par_priv)
2469 {
2470         NDIS_STATUS     status;
2471
2472 _func_enter_;
2473
2474         RT_TRACE(_module_mp_, _drv_info_, ("+oid_rt_pro_efuse_hdl\n"));
2475
2476         if (poid_par_priv->type_of_oid == QUERY_OID)
2477                 status = oid_rt_pro_read_efuse_hdl(poid_par_priv);
2478         else
2479                 status = oid_rt_pro_write_efuse_hdl(poid_par_priv);
2480
2481         RT_TRACE(_module_mp_, _drv_info_, ("-oid_rt_pro_efuse_hdl: status=0x%08X\n", status));
2482
2483 _func_exit_;
2484
2485         return status;
2486 }
2487 //------------------------------------------------------------------------------
2488 NDIS_STATUS oid_rt_pro_efuse_map_hdl(struct oid_par_priv *poid_par_priv)
2489 {
2490 #ifdef PLATFORM_OS_XP
2491         _irqL           oldirql;
2492 #endif
2493         u8              *data;
2494         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
2495         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
2496         u16     mapLen=0;
2497
2498 _func_enter_;
2499
2500         RT_TRACE(_module_mp_, _drv_notice_, ("+oid_rt_pro_efuse_map_hdl\n"));
2501
2502         EFUSE_GetEfuseDefinition(Adapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (PVOID)&mapLen, _FALSE);
2503
2504         *poid_par_priv->bytes_rw = 0;
2505
2506         if (poid_par_priv->information_buf_len < mapLen)
2507                 return NDIS_STATUS_INVALID_LENGTH;
2508
2509         data = (u8*)poid_par_priv->information_buf;
2510
2511         _irqlevel_changed_(&oldirql, LOWER);
2512
2513         if (poid_par_priv->type_of_oid == QUERY_OID)
2514         {
2515                 RT_TRACE(_module_mp_, _drv_info_,
2516                         ("oid_rt_pro_efuse_map_hdl: READ\n"));
2517
2518                 if (rtw_efuse_map_read(Adapter, 0, mapLen, data) == _SUCCESS)
2519                         *poid_par_priv->bytes_rw = mapLen;
2520                 else {
2521                         RT_TRACE(_module_mp_, _drv_err_,
2522                                 ("oid_rt_pro_efuse_map_hdl: READ fail\n"));
2523                         status = NDIS_STATUS_FAILURE;
2524                 }
2525         } else {
2526                 // SET_OID
2527                 RT_TRACE(_module_mp_, _drv_info_,
2528                         ("oid_rt_pro_efuse_map_hdl: WRITE\n"));
2529
2530                 if (rtw_efuse_map_write(Adapter, 0, mapLen, data) == _SUCCESS)
2531                         *poid_par_priv->bytes_rw = mapLen;
2532                 else {
2533                         RT_TRACE(_module_mp_, _drv_err_,
2534                                 ("oid_rt_pro_efuse_map_hdl: WRITE fail\n"));
2535                         status = NDIS_STATUS_FAILURE;
2536                 }
2537         }
2538
2539         _irqlevel_changed_(&oldirql, RAISE);
2540
2541         RT_TRACE(_module_mp_, _drv_info_,
2542                  ("-oid_rt_pro_efuse_map_hdl: status=0x%08X\n", status));
2543
2544 _func_exit_;
2545
2546         return status;
2547 }
2548
2549 NDIS_STATUS oid_rt_set_crystal_cap_hdl(struct oid_par_priv *poid_par_priv)
2550 {
2551         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
2552 #if 0
2553         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
2554
2555 #ifdef PLATFORM_OS_XP
2556         _irqL           oldirql;
2557 #endif
2558
2559         u32             crystal_cap = 0;
2560
2561 _func_enter_;
2562
2563         if (poid_par_priv->type_of_oid != SET_OID)
2564                 return NDIS_STATUS_NOT_ACCEPTED;
2565
2566         if (poid_par_priv->information_buf_len <sizeof(u32))
2567                 return NDIS_STATUS_INVALID_LENGTH;
2568
2569         crystal_cap = *((u32*)poid_par_priv->information_buf);//4
2570         if (crystal_cap > 0xf)
2571                 return NDIS_STATUS_NOT_ACCEPTED;
2572
2573         Adapter->mppriv.curr_crystalcap = crystal_cap;
2574
2575         _irqlevel_changed_(&oldirql,LOWER);
2576         SetCrystalCap(Adapter);
2577         _irqlevel_changed_(&oldirql,RAISE);
2578
2579 _func_exit_;
2580
2581 #endif
2582         return status;
2583 }
2584
2585 NDIS_STATUS oid_rt_set_rx_packet_type_hdl(struct oid_par_priv *poid_par_priv)
2586 {
2587 #ifdef PLATFORM_OS_XP
2588         _irqL           oldirql;
2589 #endif
2590         u8              rx_pkt_type;
2591 //      u32             rcr_val32;
2592         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
2593 //      PADAPTER        padapter = (PADAPTER)(poid_par_priv->adapter_context);
2594
2595 _func_enter_;
2596
2597         RT_TRACE(_module_mp_, _drv_notice_, ("+oid_rt_set_rx_packet_type_hdl\n"));
2598
2599         if (poid_par_priv->type_of_oid != SET_OID)
2600                 return NDIS_STATUS_NOT_ACCEPTED;
2601
2602         if (poid_par_priv->information_buf_len < sizeof(u8))
2603                 return NDIS_STATUS_INVALID_LENGTH;
2604
2605         rx_pkt_type = *((u8*)poid_par_priv->information_buf);//4
2606
2607         RT_TRACE(_module_mp_, _drv_info_, ("rx_pkt_type: %x\n",rx_pkt_type ));
2608 #if 0
2609         _irqlevel_changed_(&oldirql, LOWER);
2610 #if 0
2611         rcr_val8 = rtw_read8(Adapter, 0x10250048);//RCR
2612         rcr_val8 &= ~(RCR_AB|RCR_AM|RCR_APM|RCR_AAP);
2613
2614         if(rx_pkt_type == RX_PKT_BROADCAST){
2615                 rcr_val8 |= (RCR_AB | RCR_ACRC32 );
2616         }
2617         else if(rx_pkt_type == RX_PKT_DEST_ADDR){
2618                 rcr_val8 |= (RCR_AAP| RCR_AM |RCR_ACRC32);
2619         }
2620         else if(rx_pkt_type == RX_PKT_PHY_MATCH){
2621                 rcr_val8 |= (RCR_APM|RCR_ACRC32);
2622         }
2623         else{
2624                 rcr_val8 &= ~(RCR_AAP|RCR_APM|RCR_AM|RCR_AB|RCR_ACRC32);
2625         }
2626         rtw_write8(padapter, 0x10250048,rcr_val8);
2627 #else
2628         rcr_val32 = rtw_read32(padapter, RCR);//RCR = 0x10250048
2629         rcr_val32 &= ~(RCR_CBSSID|RCR_AB|RCR_AM|RCR_APM|RCR_AAP);
2630 #if 0
2631         if(rx_pkt_type == RX_PKT_BROADCAST){
2632                 rcr_val32 |= (RCR_AB|RCR_AM|RCR_APM|RCR_AAP|RCR_ACRC32);
2633         }
2634         else if(rx_pkt_type == RX_PKT_DEST_ADDR){
2635                 //rcr_val32 |= (RCR_CBSSID|RCR_AAP|RCR_AM|RCR_ACRC32);
2636                 rcr_val32 |= (RCR_CBSSID|RCR_APM|RCR_ACRC32);
2637         }
2638         else if(rx_pkt_type == RX_PKT_PHY_MATCH){
2639                 rcr_val32 |= (RCR_APM|RCR_ACRC32);
2640                 //rcr_val32 |= (RCR_AAP|RCR_ACRC32);
2641         }
2642         else{
2643                 rcr_val32 &= ~(RCR_AAP|RCR_APM|RCR_AM|RCR_AB|RCR_ACRC32);
2644         }
2645 #else
2646         switch (rx_pkt_type)
2647         {
2648                 case RX_PKT_BROADCAST :
2649                         rcr_val32 |= (RCR_AB|RCR_AM|RCR_APM|RCR_AAP|RCR_ACRC32);
2650                         break;
2651                 case RX_PKT_DEST_ADDR :
2652                         rcr_val32 |= (RCR_AB|RCR_AM|RCR_APM|RCR_AAP|RCR_ACRC32);
2653                         break;
2654                 case RX_PKT_PHY_MATCH:
2655                         rcr_val32 |= (RCR_APM|RCR_ACRC32);
2656                         break;
2657                 default:
2658                         rcr_val32 &= ~(RCR_AAP|RCR_APM|RCR_AM|RCR_AB|RCR_ACRC32);
2659                         break;
2660         }
2661
2662         if (rx_pkt_type == RX_PKT_DEST_ADDR) {
2663                 padapter->mppriv.check_mp_pkt = 1;
2664         } else {
2665                 padapter->mppriv.check_mp_pkt = 0;
2666         }
2667 #endif
2668         rtw_write32(padapter, RCR, rcr_val32);
2669
2670 #endif
2671         _irqlevel_changed_(&oldirql, RAISE);
2672 #endif
2673 _func_exit_;
2674
2675         return status;
2676 }
2677
2678 NDIS_STATUS oid_rt_pro_set_tx_agc_offset_hdl(struct oid_par_priv *poid_par_priv)
2679 {
2680 #if 0
2681         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
2682
2683 #ifdef PLATFORM_OS_XP
2684         _irqL           oldirql;
2685 #endif
2686         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
2687
2688         u32             txagc;
2689
2690 _func_enter_;
2691
2692         if (poid_par_priv->type_of_oid != SET_OID)
2693                 return NDIS_STATUS_NOT_ACCEPTED;
2694
2695         if (poid_par_priv->information_buf_len < sizeof(u32))
2696                 return NDIS_STATUS_INVALID_LENGTH;
2697
2698         txagc = *(u32*)poid_par_priv->information_buf;
2699         RT_TRACE(_module_mp_, _drv_info_,
2700                  ("oid_rt_pro_set_tx_agc_offset_hdl: 0x%08x\n", txagc));
2701
2702         _irqlevel_changed_(&oldirql, LOWER);
2703         SetTxAGCOffset(Adapter, txagc);
2704         _irqlevel_changed_(&oldirql, RAISE);
2705
2706 _func_exit_;
2707
2708         return status;
2709 #else
2710         return 0;
2711 #endif
2712 }
2713
2714 NDIS_STATUS oid_rt_pro_set_pkt_test_mode_hdl(struct oid_par_priv *poid_par_priv)
2715 {
2716 #if 0
2717         PADAPTER                Adapter = (PADAPTER)(poid_par_priv->adapter_context);
2718
2719         NDIS_STATUS             status = NDIS_STATUS_SUCCESS;
2720
2721         struct mlme_priv        *pmlmepriv = &Adapter->mlmepriv;
2722         struct mp_priv          *pmppriv = &Adapter->mppriv;
2723         u32                     type;
2724
2725 _func_enter_;
2726
2727         if (poid_par_priv->type_of_oid != SET_OID)
2728                 return NDIS_STATUS_NOT_ACCEPTED;
2729
2730         if (poid_par_priv->information_buf_len <sizeof(u32))
2731                 return NDIS_STATUS_INVALID_LENGTH;
2732
2733         type = *(u32*)poid_par_priv->information_buf;
2734
2735         if (_LOOPBOOK_MODE_ == type) {
2736                 pmppriv->mode = type;
2737                 set_fwstate(pmlmepriv, WIFI_MP_LPBK_STATE); //append txdesc
2738                 RT_TRACE(_module_mp_, _drv_info_, ("test mode change to loopback mode:0x%08x.\n", get_fwstate(pmlmepriv)));
2739         } else if (_2MAC_MODE_ == type){
2740                 pmppriv->mode = type;
2741                 _clr_fwstate_(pmlmepriv, WIFI_MP_LPBK_STATE);
2742                 RT_TRACE(_module_mp_, _drv_info_, ("test mode change to 2mac mode:0x%08x.\n", get_fwstate(pmlmepriv)));
2743         } else
2744                 status = NDIS_STATUS_NOT_ACCEPTED;
2745
2746 _func_exit_;
2747
2748         return status;
2749 #else
2750         return 0;
2751 #endif
2752 }
2753
2754 unsigned int mp_ioctl_xmit_packet_hdl(struct oid_par_priv *poid_par_priv)
2755 {
2756         PMP_XMIT_PARM pparm;
2757         PADAPTER padapter;
2758         struct mp_priv *pmp_priv;
2759         struct pkt_attrib *pattrib;
2760
2761         RT_TRACE(_module_mp_, _drv_notice_, ("+%s\n", __func__));
2762
2763         pparm = (PMP_XMIT_PARM)poid_par_priv->information_buf;
2764         padapter = (PADAPTER)poid_par_priv->adapter_context;
2765         pmp_priv = &padapter->mppriv;
2766
2767         if (poid_par_priv->type_of_oid == QUERY_OID) {
2768                 pparm->enable = !pmp_priv->tx.stop;
2769                 pparm->count = pmp_priv->tx.sended;
2770         } else {
2771                 if (pparm->enable == 0) {
2772                         pmp_priv->tx.stop = 1;
2773                 } else if (pmp_priv->tx.stop == 1) {
2774                         pmp_priv->tx.stop = 0;
2775                         pmp_priv->tx.count = pparm->count;
2776                         pmp_priv->tx.payload = pparm->payload_type;
2777                         pattrib = &pmp_priv->tx.attrib;
2778                         pattrib->pktlen = pparm->length;
2779                         _rtw_memcpy(pattrib->dst, pparm->da, ETH_ALEN);
2780                         SetPacketTx(padapter);
2781                 } else
2782                         return NDIS_STATUS_FAILURE;
2783         }
2784
2785         return NDIS_STATUS_SUCCESS;
2786 }
2787
2788 #if 0
2789 unsigned int mp_ioctl_xmit_packet_hdl(struct oid_par_priv *poid_par_priv)
2790 {
2791         unsigned char *pframe, *pmp_pkt;
2792         struct ethhdr *pethhdr;
2793         struct pkt_attrib *pattrib;
2794         struct rtw_ieee80211_hdr *pwlanhdr;
2795         unsigned short *fctrl;
2796         int llc_sz, payload_len;
2797         struct mp_xmit_frame *pxframe=  NULL;
2798         struct mp_xmit_packet *pmp_xmitpkt = (struct mp_xmit_packet*)param;
2799         u8 addr3[] = {0x02, 0xE0, 0x4C, 0x87, 0x66, 0x55};
2800
2801 //      DBG_871X("+mp_ioctl_xmit_packet_hdl\n");
2802
2803         pxframe = alloc_mp_xmitframe(&padapter->mppriv);
2804         if (pxframe == NULL)
2805         {
2806                 DEBUG_ERR(("Can't alloc pmpframe %d:%s\n", __LINE__, __FILE__));
2807                 return -1;
2808         }
2809
2810         //mp_xmit_pkt
2811         payload_len = pmp_xmitpkt->len - 14;
2812         pmp_pkt = (unsigned char*)pmp_xmitpkt->mem;
2813         pethhdr = (struct ethhdr *)pmp_pkt;
2814
2815         //DBG_871X("payload_len=%d, pkt_mem=0x%x\n", pmp_xmitpkt->len, (void*)pmp_xmitpkt->mem);
2816
2817         //DBG_871X("pxframe=0x%x\n", (void*)pxframe);
2818         //DBG_871X("pxframe->mem=0x%x\n", (void*)pxframe->mem);
2819
2820         //update attribute
2821         pattrib = &pxframe->attrib;
2822         memset((u8 *)(pattrib), 0, sizeof (struct pkt_attrib));
2823         pattrib->pktlen = pmp_xmitpkt->len;
2824         pattrib->ether_type = ntohs(pethhdr->h_proto);
2825         pattrib->hdrlen = 24;
2826         pattrib->nr_frags = 1;
2827         pattrib->priority = 0;
2828 #ifndef CONFIG_MP_LINUX
2829         if(IS_MCAST(pethhdr->h_dest))
2830                 pattrib->mac_id = 4;
2831         else
2832                 pattrib->mac_id = 5;
2833 #else
2834         pattrib->mac_id = 5;
2835 #endif
2836
2837         //
2838         memset(pxframe->mem, 0 , WLANHDR_OFFSET);
2839         pframe = (u8 *)(pxframe->mem) + WLANHDR_OFFSET;
2840
2841         pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
2842
2843         fctrl = &(pwlanhdr->frame_ctl);
2844         *(fctrl) = 0;
2845         SetFrameSubType(pframe, WIFI_DATA);
2846
2847         _rtw_memcpy(pwlanhdr->addr1, pethhdr->h_dest, ETH_ALEN);
2848         _rtw_memcpy(pwlanhdr->addr2, pethhdr->h_source, ETH_ALEN);
2849
2850         _rtw_memcpy(pwlanhdr->addr3, addr3, ETH_ALEN);
2851
2852         pwlanhdr->seq_ctl = 0;
2853         pframe += pattrib->hdrlen;
2854
2855         llc_sz= rtw_put_snap(pframe, pattrib->ether_type);
2856         pframe += llc_sz;
2857
2858         _rtw_memcpy(pframe, (void*)(pmp_pkt+14),  payload_len);
2859
2860         pattrib->last_txcmdsz = pattrib->hdrlen + llc_sz + payload_len;
2861
2862         DEBUG_INFO(("issuing mp_xmit_frame, tx_len=%d, ether_type=0x%x\n", pattrib->last_txcmdsz, pattrib->ether_type));
2863         xmit_mp_frame(padapter, pxframe);
2864
2865         return _SUCCESS;
2866 }
2867 #endif
2868 //------------------------------------------------------------------------------
2869 NDIS_STATUS oid_rt_set_power_down_hdl(struct oid_par_priv *poid_par_priv)
2870 {
2871 #ifdef PLATFORM_OS_XP
2872         _irqL           oldirql;
2873 #endif
2874         u8              bpwrup;
2875         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
2876 #ifdef PLATFORM_LINUX
2877 #if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
2878         PADAPTER        padapter = (PADAPTER)(poid_par_priv->adapter_context);
2879 #endif
2880 #endif
2881
2882 _func_enter_;
2883
2884         if (poid_par_priv->type_of_oid != SET_OID) {
2885                 status = NDIS_STATUS_NOT_ACCEPTED;
2886                 return status;
2887         }
2888
2889         RT_TRACE(_module_mp_, _drv_info_,
2890                  ("\n ===> Setoid_rt_set_power_down_hdl.\n"));
2891
2892         _irqlevel_changed_(&oldirql, LOWER);
2893
2894         bpwrup = *(u8 *)poid_par_priv->information_buf;
2895         //CALL  the power_down function
2896 #ifdef PLATFORM_LINUX
2897 #if defined(CONFIG_RTL8712) //Linux MP insmod unknown symbol
2898         dev_power_down(padapter,bpwrup);
2899 #endif
2900 #endif
2901         _irqlevel_changed_(&oldirql, RAISE);
2902
2903         //DEBUG_ERR(("\n <=== Query OID_RT_PRO_READ_REGISTER.
2904         //      Add:0x%08x Width:%d Value:0x%08x\n",RegRWStruct->offset,RegRWStruct->width,RegRWStruct->value));
2905
2906 _func_exit_;
2907
2908         return status;
2909 }
2910 //------------------------------------------------------------------------------
2911 NDIS_STATUS oid_rt_get_power_mode_hdl(struct oid_par_priv *poid_par_priv)
2912 {
2913 #if 0
2914         NDIS_STATUS     status = NDIS_STATUS_SUCCESS;
2915         PADAPTER        Adapter = (PADAPTER)(poid_par_priv->adapter_context);
2916 //#ifdef PLATFORM_OS_XP
2917 //      _irqL           oldirql;
2918 //#endif
2919
2920 _func_enter_;
2921
2922         if (poid_par_priv->type_of_oid != QUERY_OID) {
2923                 status = NDIS_STATUS_NOT_ACCEPTED;
2924                 return status;
2925         }
2926         if (poid_par_priv->information_buf_len < sizeof(u32)) {
2927                 status = NDIS_STATUS_INVALID_LENGTH;
2928                 return status;
2929         }
2930
2931         RT_TRACE(_module_mp_, _drv_info_,
2932                  ("\n ===> oid_rt_get_power_mode_hdl.\n"));
2933
2934 //      _irqlevel_changed_(&oldirql, LOWER);
2935         *(int*)poid_par_priv->information_buf = Adapter->registrypriv.low_power ? POWER_LOW : POWER_NORMAL;
2936         *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
2937 //      _irqlevel_changed_(&oldirql, RAISE);
2938
2939 _func_exit_;
2940
2941         return status;
2942 #else
2943         return 0;
2944 #endif
2945 }
2946