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