drivers/net/wireless/rockchip_wlan/rtl8723cs/core/rtw_mp_ioctl.c

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