LXR linux/drivers/staging/rtl8712/rtl871x_ioctl

   1/******************************************************************************
   2 * rtl871x_ioctl_rtl.c
   3 *
   4 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
   5 * Linux device driver for RTL8192SU
   6 *
   7 * This program is free software; you can redistribute it and/or modify it
   8 * under the terms of version 2 of the GNU General Public License as
   9 * published by the Free Software Foundation.
  10 *
  11 * This program is distributed in the hope that it will be useful, but WITHOUT
  12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14 * more details.
  15 *
  16 * You should have received a copy of the GNU General Public License along with
  17 * this program; if not, write to the Free Software Foundation, Inc.,
  18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  19 *
  20 * Modifications for inclusion into the Linux staging tree are
  21 * Copyright(c) 2010 Larry Finger. All rights reserved.
  22 *
  23 * Contact information:
  24 * WLAN FAE <wlanfae@realtek.com>
  25 * Larry Finger <Larry.Finger@lwfinger.net>
  26 *
  27 ******************************************************************************/
  28
  29#define  _RTL871X_IOCTL_RTL_C_
  30
  31#include <linux/rndis.h>
  32#include "osdep_service.h"
  33#include "drv_types.h"
  34#include "wlan_bssdef.h"
  35#include "wifi.h"
  36#include "rtl871x_ioctl.h"
  37#include "rtl871x_ioctl_set.h"
  38#include "rtl871x_ioctl_rtl.h"
  39#include "mp_custom_oid.h"
  40#include "rtl871x_mp.h"
  41#include "rtl871x_mp_ioctl.h"
  42
  43uint oid_rt_get_signal_quality_hdl(struct oid_par_priv *poid_par_priv)
  44{
  45        if (poid_par_priv->type_of_oid != QUERY_OID)
  46                return RNDIS_STATUS_NOT_ACCEPTED;
  47        return RNDIS_STATUS_SUCCESS;
  48}
  49
  50uint oid_rt_get_small_packet_crc_hdl(struct oid_par_priv *poid_par_priv)
  51{
  52        struct _adapter *padapter = poid_par_priv->adapter_context;
  53
  54        if (poid_par_priv->type_of_oid != QUERY_OID)
  55                return RNDIS_STATUS_NOT_ACCEPTED;
  56        if (poid_par_priv->information_buf_len >=  sizeof(u32)) {
  57                *(u32 *)poid_par_priv->information_buf =
  58                                padapter->recvpriv.rx_smallpacket_crcerr;
  59                *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
  60        } else {
  61                return RNDIS_STATUS_INVALID_LENGTH;
  62        }
  63        return RNDIS_STATUS_SUCCESS;
  64}
  65
  66uint oid_rt_get_middle_packet_crc_hdl(struct oid_par_priv *poid_par_priv)
  67{
  68        struct _adapter *padapter = poid_par_priv->adapter_context;
  69
  70        if (poid_par_priv->type_of_oid != QUERY_OID)
  71                return RNDIS_STATUS_NOT_ACCEPTED;
  72        if (poid_par_priv->information_buf_len >=  sizeof(u32)) {
  73                *(u32 *)poid_par_priv->information_buf =
  74                                padapter->recvpriv.rx_middlepacket_crcerr;
  75                *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
  76        } else {
  77                return RNDIS_STATUS_INVALID_LENGTH;
  78        }
  79        return RNDIS_STATUS_SUCCESS;
  80}
  81
  82uint oid_rt_get_large_packet_crc_hdl(struct oid_par_priv *poid_par_priv)
  83{
  84        struct _adapter *padapter = poid_par_priv->adapter_context;
  85
  86        if (poid_par_priv->type_of_oid != QUERY_OID)
  87                return RNDIS_STATUS_NOT_ACCEPTED;
  88        if (poid_par_priv->information_buf_len >=  sizeof(u32)) {
  89                *(u32 *)poid_par_priv->information_buf =
  90                                 padapter->recvpriv.rx_largepacket_crcerr;
  91                *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
  92        } else {
  93                return RNDIS_STATUS_INVALID_LENGTH;
  94        }
  95        return RNDIS_STATUS_SUCCESS;
  96}
  97
  98uint oid_rt_get_tx_retry_hdl(struct oid_par_priv *poid_par_priv)
  99{
 100        if (poid_par_priv->type_of_oid != QUERY_OID)
 101                return RNDIS_STATUS_NOT_ACCEPTED;
 102        return RNDIS_STATUS_SUCCESS;
 103}
 104
 105uint oid_rt_get_rx_retry_hdl(struct oid_par_priv *poid_par_priv)
 106{
 107        if (poid_par_priv->type_of_oid != QUERY_OID)
 108                return RNDIS_STATUS_NOT_ACCEPTED;
 109        *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 110        return RNDIS_STATUS_SUCCESS;
 111}
 112
 113uint oid_rt_get_rx_total_packet_hdl(struct oid_par_priv *poid_par_priv)
 114{
 115        struct _adapter *padapter = poid_par_priv->adapter_context;
 116
 117        if (poid_par_priv->type_of_oid != QUERY_OID)
 118                return RNDIS_STATUS_NOT_ACCEPTED;
 119        if (poid_par_priv->information_buf_len >=  sizeof(u32)) {
 120                *(u32 *)poid_par_priv->information_buf =
 121                                         padapter->recvpriv.rx_pkts +
 122                                         padapter->recvpriv.rx_drop;
 123                *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 124        } else {
 125                return RNDIS_STATUS_INVALID_LENGTH;
 126        }
 127        return RNDIS_STATUS_SUCCESS;
 128}
 129
 130uint oid_rt_get_tx_beacon_ok_hdl(struct oid_par_priv *poid_par_priv)
 131{
 132        if (poid_par_priv->type_of_oid != QUERY_OID)
 133                return RNDIS_STATUS_NOT_ACCEPTED;
 134        return RNDIS_STATUS_SUCCESS;
 135}
 136
 137uint oid_rt_get_tx_beacon_err_hdl(struct oid_par_priv *poid_par_priv)
 138{
 139        if (poid_par_priv->type_of_oid != QUERY_OID)
 140                return RNDIS_STATUS_NOT_ACCEPTED;
 141        return RNDIS_STATUS_SUCCESS;
 142}
 143
 144uint oid_rt_get_rx_icv_err_hdl(struct oid_par_priv *poid_par_priv)
 145{
 146        struct _adapter *padapter = poid_par_priv->adapter_context;
 147
 148        if (poid_par_priv->type_of_oid != QUERY_OID)
 149                return RNDIS_STATUS_NOT_ACCEPTED;
 150        if (poid_par_priv->information_buf_len >= sizeof(u32)) {
 151                *(uint *)poid_par_priv->information_buf =
 152                                         padapter->recvpriv.rx_icv_err;
 153                *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 154        } else {
 155                return RNDIS_STATUS_INVALID_LENGTH;
 156        }
 157        return RNDIS_STATUS_SUCCESS;
 158}
 159
 160uint oid_rt_set_encryption_algorithm_hdl(struct oid_par_priv
 161                                                *poid_par_priv)
 162{
 163        if (poid_par_priv->type_of_oid != SET_OID)
 164                return RNDIS_STATUS_NOT_ACCEPTED;
 165        return RNDIS_STATUS_SUCCESS;
 166}
 167
 168uint oid_rt_get_preamble_mode_hdl(struct oid_par_priv *poid_par_priv)
 169{
 170        struct _adapter *padapter = poid_par_priv->adapter_context;
 171        u32 preamblemode = 0;
 172
 173        if (poid_par_priv->type_of_oid != QUERY_OID)
 174                return RNDIS_STATUS_NOT_ACCEPTED;
 175        if (poid_par_priv->information_buf_len >= sizeof(u32)) {
 176                if (padapter->registrypriv.preamble == PREAMBLE_LONG)
 177                        preamblemode = 0;
 178                else if (padapter->registrypriv.preamble == PREAMBLE_AUTO)
 179                        preamblemode = 1;
 180                else if (padapter->registrypriv.preamble == PREAMBLE_SHORT)
 181                        preamblemode = 2;
 182                *(u32 *)poid_par_priv->information_buf = preamblemode;
 183                *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 184        } else {
 185                return RNDIS_STATUS_INVALID_LENGTH;
 186        }
 187        return RNDIS_STATUS_SUCCESS;
 188}
 189
 190uint oid_rt_get_ap_ip_hdl(struct oid_par_priv *poid_par_priv)
 191{
 192        if (poid_par_priv->type_of_oid != QUERY_OID)
 193                return RNDIS_STATUS_NOT_ACCEPTED;
 194        return RNDIS_STATUS_SUCCESS;
 195}
 196
 197uint oid_rt_get_channelplan_hdl(struct oid_par_priv *poid_par_priv)
 198{
 199        struct _adapter *padapter = poid_par_priv->adapter_context;
 200        struct eeprom_priv *peeprompriv = &padapter->eeprompriv;
 201
 202        if (poid_par_priv->type_of_oid != QUERY_OID)
 203                return RNDIS_STATUS_NOT_ACCEPTED;
 204        *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 205        *(u16 *)poid_par_priv->information_buf = peeprompriv->channel_plan;
 206        return RNDIS_STATUS_SUCCESS;
 207}
 208
 209uint oid_rt_set_channelplan_hdl(struct oid_par_priv
 210                                       *poid_par_priv)
 211{
 212        struct _adapter *padapter = poid_par_priv->adapter_context;
 213        struct eeprom_priv *peeprompriv = &padapter->eeprompriv;
 214
 215        if (poid_par_priv->type_of_oid != SET_OID)
 216                return RNDIS_STATUS_NOT_ACCEPTED;
 217        peeprompriv->channel_plan = *(u16 *)poid_par_priv->information_buf;
 218        return RNDIS_STATUS_SUCCESS;
 219}
 220
 221uint oid_rt_set_preamble_mode_hdl(struct oid_par_priv
 222                                         *poid_par_priv)
 223{
 224        struct _adapter *padapter = poid_par_priv->adapter_context;
 225        u32 preamblemode = 0;
 226
 227        if (poid_par_priv->type_of_oid != SET_OID)
 228                return RNDIS_STATUS_NOT_ACCEPTED;
 229        if (poid_par_priv->information_buf_len >= sizeof(u32)) {
 230                preamblemode = *(u32 *)poid_par_priv->information_buf;
 231                if (preamblemode == 0)
 232                        padapter->registrypriv.preamble = PREAMBLE_LONG;
 233                else if (preamblemode == 1)
 234                        padapter->registrypriv.preamble = PREAMBLE_AUTO;
 235                else if (preamblemode == 2)
 236                        padapter->registrypriv.preamble = PREAMBLE_SHORT;
 237                *(u32 *)poid_par_priv->information_buf = preamblemode;
 238                *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 239        } else {
 240                return RNDIS_STATUS_INVALID_LENGTH;
 241        }
 242        return RNDIS_STATUS_SUCCESS;
 243}
 244
 245uint oid_rt_set_bcn_intvl_hdl(struct oid_par_priv *poid_par_priv)
 246{
 247        if (poid_par_priv->type_of_oid != SET_OID)
 248                return RNDIS_STATUS_NOT_ACCEPTED;
 249        return RNDIS_STATUS_SUCCESS;
 250}
 251
 252uint oid_rt_dedicate_probe_hdl(struct oid_par_priv
 253                                      *poid_par_priv)
 254{
 255        return RNDIS_STATUS_SUCCESS;
 256}
 257
 258uint oid_rt_get_total_tx_bytes_hdl(struct oid_par_priv
 259                                          *poid_par_priv)
 260{
 261        struct _adapter *padapter = poid_par_priv->adapter_context;
 262
 263        if (poid_par_priv->type_of_oid != QUERY_OID)
 264                return RNDIS_STATUS_NOT_ACCEPTED;
 265        if (poid_par_priv->information_buf_len >= sizeof(u32)) {
 266                *(u32 *)poid_par_priv->information_buf =
 267                                                 padapter->xmitpriv.tx_bytes;
 268                *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 269        } else {
 270                return RNDIS_STATUS_INVALID_LENGTH;
 271        }
 272        return RNDIS_STATUS_SUCCESS;
 273}
 274
 275uint oid_rt_get_total_rx_bytes_hdl(struct oid_par_priv
 276                                          *poid_par_priv)
 277{
 278        struct _adapter *padapter = poid_par_priv->adapter_context;
 279
 280        if (poid_par_priv->type_of_oid != QUERY_OID)
 281                return RNDIS_STATUS_NOT_ACCEPTED;
 282        if (poid_par_priv->information_buf_len >= sizeof(u32)) {
 283                *(u32 *)poid_par_priv->information_buf =
 284                                           padapter->recvpriv.rx_bytes;
 285                *poid_par_priv->bytes_rw = poid_par_priv->
 286                                           information_buf_len;
 287        } else {
 288                return RNDIS_STATUS_INVALID_LENGTH;
 289        }
 290        return RNDIS_STATUS_SUCCESS;
 291}
 292
 293uint oid_rt_current_tx_power_level_hdl(struct oid_par_priv
 294                                              *poid_par_priv)
 295{
 296        return RNDIS_STATUS_SUCCESS;
 297}
 298
 299uint oid_rt_get_enc_key_mismatch_count_hdl(struct oid_par_priv
 300                                                  *poid_par_priv)
 301{
 302        if (poid_par_priv->type_of_oid != QUERY_OID)
 303                return RNDIS_STATUS_NOT_ACCEPTED;
 304        return RNDIS_STATUS_SUCCESS;
 305}
 306
 307uint oid_rt_get_enc_key_match_count_hdl(struct oid_par_priv
 308                                               *poid_par_priv)
 309{
 310        if (poid_par_priv->type_of_oid != QUERY_OID)
 311                return RNDIS_STATUS_NOT_ACCEPTED;
 312        return RNDIS_STATUS_SUCCESS;
 313}
 314
 315uint oid_rt_get_channel_hdl(struct oid_par_priv *poid_par_priv)
 316{
 317        struct _adapter *padapter = poid_par_priv->adapter_context;
 318        struct  mlme_priv *pmlmepriv = &padapter->mlmepriv;
 319        struct NDIS_802_11_CONFIGURATION *pnic_Config;
 320        u32   channelnum;
 321
 322        if (poid_par_priv->type_of_oid != QUERY_OID)
 323                return RNDIS_STATUS_NOT_ACCEPTED;
 324        if (check_fwstate(pmlmepriv, _FW_LINKED) ||
 325            check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE))
 326                pnic_Config = &pmlmepriv->cur_network.network.Configuration;
 327        else
 328                pnic_Config = &padapter->registrypriv.dev_network.
 329                              Configuration;
 330        channelnum = pnic_Config->DSConfig;
 331        *(u32 *)poid_par_priv->information_buf = channelnum;
 332        *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 333        return RNDIS_STATUS_SUCCESS;
 334}
 335
 336uint oid_rt_get_hardware_radio_off_hdl(struct oid_par_priv
 337                         *poid_par_priv)
 338{
 339        if (poid_par_priv->type_of_oid != QUERY_OID)
 340                return RNDIS_STATUS_NOT_ACCEPTED;
 341        return RNDIS_STATUS_SUCCESS;
 342}
 343
 344uint oid_rt_get_key_mismatch_hdl(struct oid_par_priv *poid_par_priv)
 345{
 346        if (poid_par_priv->type_of_oid != QUERY_OID)
 347                return RNDIS_STATUS_NOT_ACCEPTED;
 348        return RNDIS_STATUS_SUCCESS;
 349}
 350
 351uint oid_rt_supported_wireless_mode_hdl(struct oid_par_priv
 352                                               *poid_par_priv)
 353{
 354        u32 ulInfo = 0;
 355
 356        if (poid_par_priv->type_of_oid != QUERY_OID)
 357                return RNDIS_STATUS_NOT_ACCEPTED;
 358        if (poid_par_priv->information_buf_len >= sizeof(u32)) {
 359                ulInfo |= 0x0100; /* WIRELESS_MODE_B */
 360                ulInfo |= 0x0200; /* WIRELESS_MODE_G */
 361                ulInfo |= 0x0400; /* WIRELESS_MODE_A */
 362                *(u32 *) poid_par_priv->information_buf = ulInfo;
 363                *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
 364        } else {
 365                return RNDIS_STATUS_INVALID_LENGTH;
 366        }
 367        return RNDIS_STATUS_SUCCESS;
 368}
 369
 370uint oid_rt_get_channel_list_hdl(struct oid_par_priv *poid_par_priv)
 371{
 372        if (poid_par_priv->type_of_oid != QUERY_OID)
 373                return RNDIS_STATUS_NOT_ACCEPTED;
 374        return RNDIS_STATUS_SUCCESS;
 375}
 376
 377uint oid_rt_get_scan_in_progress_hdl(struct oid_par_priv *poid_par_priv)
 378{
 379        if (poid_par_priv->type_of_oid != QUERY_OID)
 380                return RNDIS_STATUS_NOT_ACCEPTED;
 381        return RNDIS_STATUS_SUCCESS;
 382}
 383
 384
 385uint oid_rt_forced_data_rate_hdl(struct oid_par_priv *poid_par_priv)
 386{
 387        return RNDIS_STATUS_SUCCESS;
 388}
 389
 390uint oid_rt_wireless_mode_for_scan_list_hdl(struct oid_par_priv
 391                                                   *poid_par_priv)
 392{
 393        return RNDIS_STATUS_SUCCESS;
 394}
 395
 396uint oid_rt_get_bss_wireless_mode_hdl(struct oid_par_priv
 397                                             *poid_par_priv)
 398{
 399        if (poid_par_priv->type_of_oid != QUERY_OID)
 400                return RNDIS_STATUS_NOT_ACCEPTED;
 401        return RNDIS_STATUS_SUCCESS;
 402}
 403
 404uint oid_rt_scan_with_magic_packet_hdl(struct oid_par_priv
 405                                              *poid_par_priv)
 406{
 407        return RNDIS_STATUS_SUCCESS;
 408}
 409
 410uint oid_rt_ap_get_associated_station_list_hdl(struct oid_par_priv
 411                                                      *poid_par_priv)
 412{
 413        if (poid_par_priv->type_of_oid != QUERY_OID)
 414                return RNDIS_STATUS_NOT_ACCEPTED;
 415        return RNDIS_STATUS_SUCCESS;
 416}
 417
 418uint oid_rt_ap_switch_into_ap_mode_hdl(struct oid_par_priv*
 419                                              poid_par_priv)
 420{
 421        return RNDIS_STATUS_SUCCESS;
 422}
 423
 424uint oid_rt_ap_supported_hdl(struct oid_par_priv *poid_par_priv)
 425{
 426        return RNDIS_STATUS_SUCCESS;
 427}
 428
 429uint oid_rt_ap_set_passphrase_hdl(struct oid_par_priv *poid_par_priv)
 430{
 431        if (poid_par_priv->type_of_oid != SET_OID)
 432                return RNDIS_STATUS_NOT_ACCEPTED;
 433        return RNDIS_STATUS_SUCCESS;
 434}
 435
 436uint oid_rt_pro_rf_write_registry_hdl(struct oid_par_priv*
 437                                             poid_par_priv)
 438{
 439        uint status = RNDIS_STATUS_SUCCESS;
 440        struct _adapter *Adapter = poid_par_priv->adapter_context;
 441
 442        if (poid_par_priv->type_of_oid != SET_OID) /* QUERY_OID */
 443                return RNDIS_STATUS_NOT_ACCEPTED;
 444        if (poid_par_priv->information_buf_len ==
 445           (sizeof(unsigned long) * 3)) {
 446                if (!r8712_setrfreg_cmd(Adapter,
 447                        *(unsigned char *)poid_par_priv->information_buf,
 448                        (unsigned long)(*((unsigned long *)
 449                                        poid_par_priv->information_buf + 2))))
 450                        status = RNDIS_STATUS_NOT_ACCEPTED;
 451        } else {
 452                status = RNDIS_STATUS_INVALID_LENGTH;
 453        }
 454        return status;
 455}
 456
 457uint oid_rt_pro_rf_read_registry_hdl(struct oid_par_priv *poid_par_priv)
 458{
 459        uint status = RNDIS_STATUS_SUCCESS;
 460        struct _adapter *Adapter = poid_par_priv->adapter_context;
 461
 462        if (poid_par_priv->type_of_oid != SET_OID) /* QUERY_OID */
 463                return RNDIS_STATUS_NOT_ACCEPTED;
 464        if (poid_par_priv->information_buf_len == (sizeof(unsigned long) *
 465                                                   3)) {
 466                if (Adapter->mppriv.act_in_progress) {
 467                        status = RNDIS_STATUS_NOT_ACCEPTED;
 468                } else {
 469                        /* init workparam */
 470                        Adapter->mppriv.act_in_progress = true;
 471                        Adapter->mppriv.workparam.bcompleted = false;
 472                        Adapter->mppriv.workparam.act_type = MPT_READ_RF;
 473                        Adapter->mppriv.workparam.io_offset = *(unsigned long *)
 474                                                poid_par_priv->information_buf;
 475                        Adapter->mppriv.workparam.io_value = 0xcccccccc;
 476
 477                /* RegOffsetValue       - The offset of RF register to read.
 478                 * RegDataWidth - The data width of RF register to read.
 479                 * RegDataValue - The value to read.
 480                 * RegOffsetValue = *((unsigned long *)InformationBuffer);
 481                 * RegDataWidth = *((unsigned long *)InformationBuffer+1);
 482                 * RegDataValue =  *((unsigned long *)InformationBuffer+2);
 483                 */
 484                        if (!r8712_getrfreg_cmd(Adapter,
 485                            *(unsigned char *)poid_par_priv->information_buf,
 486                            (unsigned char *)&Adapter->mppriv.workparam.
 487                            io_value))
 488                                status = RNDIS_STATUS_NOT_ACCEPTED;
 489                }
 490        } else {
 491                status = RNDIS_STATUS_INVALID_LENGTH;
 492        }
 493        return status;
 494}
 495
 496enum _CONNECT_STATE_ {
 497        CHECKINGSTATUS,
 498        ASSOCIATED,
 499        ADHOCMODE,
 500        NOTASSOCIATED
 501};
 502
 503uint oid_rt_get_connect_state_hdl(struct oid_par_priv *poid_par_priv)
 504{
 505        struct _adapter *padapter = poid_par_priv->adapter_context;
 506        struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 507        u32 ulInfo;
 508
 509        if (poid_par_priv->type_of_oid != QUERY_OID)
 510                return RNDIS_STATUS_NOT_ACCEPTED;
 511        /* nStatus==0   CheckingStatus
 512         * nStatus==1   Associated
 513         * nStatus==2   AdHocMode
 514         * nStatus==3   NotAssociated
 515         */
 516        if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING))
 517                ulInfo = CHECKINGSTATUS;
 518        else if (check_fwstate(pmlmepriv, _FW_LINKED))
 519                ulInfo = ASSOCIATED;
 520        else if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE))
 521                ulInfo = ADHOCMODE;
 522        else
 523                ulInfo = NOTASSOCIATED;
 524        *(u32 *)poid_par_priv->information_buf = ulInfo;
 525        *poid_par_priv->bytes_rw =  poid_par_priv->information_buf_len;
 526        return RNDIS_STATUS_SUCCESS;
 527}
 528
 529uint oid_rt_set_default_key_id_hdl(struct oid_par_priv *poid_par_priv)
 530{
 531        if (poid_par_priv->type_of_oid != SET_OID)
 532                return RNDIS_STATUS_NOT_ACCEPTED;
 533        return RNDIS_STATUS_SUCCESS;
 534}
 535