rtl8821ce/core/rtw_mp_ioctl.c

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