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

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