LUFA/Drivers/USB/Class/Device/RNDIS.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2009.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, and distribute this software
  13   and its documentation for any purpose and without fee is hereby
  14   granted, provided that the above copyright notice appear in all
  15   copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 #include "../../HighLevel/USBMode.h"
  32 #if defined(USB_CAN_BE_DEVICE)
  33
  34 #define  INCLUDE_FROM_RNDIS_CLASS_DEVICE_C
  35 #include "RNDIS.h"
  36
  37 static const uint32_t PROGMEM AdapterSupportedOIDList[]  =
  38         {
  39                 OID_GEN_SUPPORTED_LIST,
  40                 OID_GEN_PHYSICAL_MEDIUM,
  41                 OID_GEN_HARDWARE_STATUS,
  42                 OID_GEN_MEDIA_SUPPORTED,
  43                 OID_GEN_MEDIA_IN_USE,
  44                 OID_GEN_MAXIMUM_FRAME_SIZE,
  45                 OID_GEN_MAXIMUM_TOTAL_SIZE,
  46                 OID_GEN_LINK_SPEED,
  47                 OID_GEN_TRANSMIT_BLOCK_SIZE,
  48                 OID_GEN_RECEIVE_BLOCK_SIZE,
  49                 OID_GEN_VENDOR_ID,
  50                 OID_GEN_VENDOR_DESCRIPTION,
  51                 OID_GEN_CURRENT_PACKET_FILTER,
  52                 OID_GEN_MAXIMUM_TOTAL_SIZE,
  53                 OID_GEN_MEDIA_CONNECT_STATUS,
  54                 OID_GEN_XMIT_OK,
  55                 OID_GEN_RCV_OK,
  56                 OID_GEN_XMIT_ERROR,
  57                 OID_GEN_RCV_ERROR,
  58                 OID_GEN_RCV_NO_BUFFER,
  59                 OID_802_3_PERMANENT_ADDRESS,
  60                 OID_802_3_CURRENT_ADDRESS,
  61                 OID_802_3_MULTICAST_LIST,
  62                 OID_802_3_MAXIMUM_LIST_SIZE,
  63                 OID_802_3_RCV_ERROR_ALIGNMENT,
  64                 OID_802_3_XMIT_ONE_COLLISION,
  65                 OID_802_3_XMIT_MORE_COLLISIONS,
  66         };
  67
  68 void RNDIS_Device_ProcessControlRequest(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)
  69 {
  70         if (!(Endpoint_IsSETUPReceived()))
  71           return;
  72
  73         if (USB_ControlRequest.wIndex != RNDISInterfaceInfo->Config.ControlInterfaceNumber)
  74           return;
  75
  76         switch (USB_ControlRequest.bRequest)
  77         {
  78                 case REQ_SendEncapsulatedCommand:
  79                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
  80                         {
  81                                 Endpoint_ClearSETUP();
  82
  83                                 Endpoint_Read_Control_Stream_LE(RNDISInterfaceInfo->State.RNDISMessageBuffer, USB_ControlRequest.wLength);
  84                                 Endpoint_ClearIN();
  85
  86                                 RNDIS_Device_ProcessRNDISControlMessage(RNDISInterfaceInfo);
  87                         }
  88
  89                         break;
  90                 case REQ_GetEncapsulatedResponse:
  91                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
  92                         {
  93                                 Endpoint_ClearSETUP();
  94
  95                                 RNDIS_Message_Header_t* MessageHeader = (RNDIS_Message_Header_t*)&RNDISInterfaceInfo->State.RNDISMessageBuffer;
  96
  97                                 if (!(MessageHeader->MessageLength))
  98                                 {
  99                                         RNDISInterfaceInfo->State.RNDISMessageBuffer[0] = 0;
 100                                         MessageHeader->MessageLength = 1;
 101                                 }
 102
 103                                 Endpoint_Write_Control_Stream_LE(RNDISInterfaceInfo->State.RNDISMessageBuffer, MessageHeader->MessageLength);
 104                                 Endpoint_ClearOUT();
 105
 106                                 MessageHeader->MessageLength = 0;
 107                         }
 108
 109                         break;
 110         }
 111 }
 112
 113 bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)
 114 {
 115         memset(&RNDISInterfaceInfo->State, 0x00, sizeof(RNDISInterfaceInfo->State));
 116
 117         if (!(Endpoint_ConfigureEndpoint(RNDISInterfaceInfo->Config.DataINEndpointNumber, EP_TYPE_BULK,
 118                                                                  ENDPOINT_DIR_IN, RNDISInterfaceInfo->Config.DataINEndpointSize,
 119                                                                  RNDISInterfaceInfo->Config.DataINEndpointDoubleBank ? ENDPOINT_BANK_DOUBLE : ENDPOINT_BANK_SINGLE)))
 120         {
 121                 return false;
 122         }
 123
 124         if (!(Endpoint_ConfigureEndpoint(RNDISInterfaceInfo->Config.DataOUTEndpointNumber, EP_TYPE_BULK,
 125                                          ENDPOINT_DIR_OUT, RNDISInterfaceInfo->Config.DataOUTEndpointSize,
 126                                          RNDISInterfaceInfo->Config.DataOUTEndpointDoubleBank ? ENDPOINT_BANK_DOUBLE : ENDPOINT_BANK_SINGLE)))
 127         {
 128                 return false;
 129         }
 130
 131         if (!(Endpoint_ConfigureEndpoint(RNDISInterfaceInfo->Config.NotificationEndpointNumber, EP_TYPE_INTERRUPT,
 132                                          ENDPOINT_DIR_IN, RNDISInterfaceInfo->Config.NotificationEndpointSize,
 133                                          RNDISInterfaceInfo->Config.NotificationEndpointDoubleBank ? ENDPOINT_BANK_DOUBLE : ENDPOINT_BANK_SINGLE)))
 134         {
 135                 return false;
 136         }
 137
 138         return true;
 139 }
 140
 141 void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)
 142 {
 143         if (USB_DeviceState != DEVICE_STATE_Configured)
 144           return;
 145
 146         RNDIS_Message_Header_t* MessageHeader = (RNDIS_Message_Header_t*)&RNDISInterfaceInfo->State.RNDISMessageBuffer;
 147
 148         Endpoint_SelectEndpoint(RNDISInterfaceInfo->Config.NotificationEndpointNumber);
 149
 150         if (Endpoint_IsINReady() && RNDISInterfaceInfo->State.ResponseReady)
 151         {
 152                 USB_Request_Header_t Notification = (USB_Request_Header_t)
 153                         {
 154                                 .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 155                                 .bRequest      = NOTIF_ResponseAvailable,
 156                                 .wValue        = 0,
 157                                 .wIndex        = 0,
 158                                 .wLength       = 0,
 159                         };
 160
 161                 Endpoint_Write_Stream_LE(&Notification, sizeof(USB_Request_Header_t), NO_STREAM_CALLBACK);
 162
 163                 Endpoint_ClearIN();
 164
 165                 RNDISInterfaceInfo->State.ResponseReady = false;
 166         }
 167
 168         if ((RNDISInterfaceInfo->State.CurrRNDISState == RNDIS_Data_Initialized) && !(MessageHeader->MessageLength))
 169         {
 170                 RNDIS_Packet_Message_t RNDISPacketHeader;
 171
 172                 Endpoint_SelectEndpoint(RNDISInterfaceInfo->Config.DataOUTEndpointNumber);
 173
 174                 if (Endpoint_IsOUTReceived() && !(RNDISInterfaceInfo->State.FrameIN.FrameInBuffer))
 175                 {
 176                         Endpoint_Read_Stream_LE(&RNDISPacketHeader, sizeof(RNDIS_Packet_Message_t), NO_STREAM_CALLBACK);
 177
 178                         if (RNDISPacketHeader.DataLength > ETHERNET_FRAME_SIZE_MAX)
 179                         {
 180                                 Endpoint_StallTransaction();
 181                                 return;
 182                         }
 183
 184                         Endpoint_Read_Stream_LE(RNDISInterfaceInfo->State.FrameIN.FrameData, RNDISPacketHeader.DataLength, NO_STREAM_CALLBACK);
 185
 186                         Endpoint_ClearOUT();
 187
 188                         RNDISInterfaceInfo->State.FrameIN.FrameLength = RNDISPacketHeader.DataLength;
 189
 190                         RNDISInterfaceInfo->State.FrameIN.FrameInBuffer = true;
 191                 }
 192
 193                 Endpoint_SelectEndpoint(RNDISInterfaceInfo->Config.DataINEndpointNumber);
 194
 195                 if (Endpoint_IsINReady() && RNDISInterfaceInfo->State.FrameOUT.FrameInBuffer)
 196                 {
 197                         memset(&RNDISPacketHeader, 0, sizeof(RNDIS_Packet_Message_t));
 198
 199                         RNDISPacketHeader.MessageType   = REMOTE_NDIS_PACKET_MSG;
 200                         RNDISPacketHeader.MessageLength = (sizeof(RNDIS_Packet_Message_t) + RNDISInterfaceInfo->State.FrameOUT.FrameLength);
 201                         RNDISPacketHeader.DataOffset    = (sizeof(RNDIS_Packet_Message_t) - sizeof(RNDIS_Message_Header_t));
 202                         RNDISPacketHeader.DataLength    = RNDISInterfaceInfo->State.FrameOUT.FrameLength;
 203
 204                         Endpoint_Write_Stream_LE(&RNDISPacketHeader, sizeof(RNDIS_Packet_Message_t), NO_STREAM_CALLBACK);
 205                         Endpoint_Write_Stream_LE(RNDISInterfaceInfo->State.FrameOUT.FrameData, RNDISPacketHeader.DataLength, NO_STREAM_CALLBACK);
 206                         Endpoint_ClearIN();
 207
 208                         RNDISInterfaceInfo->State.FrameOUT.FrameInBuffer = false;
 209                 }
 210         }
 211 }
 212
 213 void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo)
 214 {
 215         /* Note: Only a single buffer is used for both the received message and its response to save SRAM. Because of
 216                  this, response bytes should be filled in order so that they do not clobber unread data in the buffer. */
 217
 218         RNDIS_Message_Header_t* MessageHeader = (RNDIS_Message_Header_t*)&RNDISInterfaceInfo->State.RNDISMessageBuffer;
 219
 220         switch (MessageHeader->MessageType)
 221         {
 222                 case REMOTE_NDIS_INITIALIZE_MSG:
 223                         RNDISInterfaceInfo->State.ResponseReady = true;
 224
 225                         RNDIS_Initialize_Message_t*  INITIALIZE_Message  =
 226                                        (RNDIS_Initialize_Message_t*)&RNDISInterfaceInfo->State.RNDISMessageBuffer;
 227                         RNDIS_Initialize_Complete_t* INITIALIZE_Response =
 228                                        (RNDIS_Initialize_Complete_t*)&RNDISInterfaceInfo->State.RNDISMessageBuffer;
 229
 230                         INITIALIZE_Response->MessageType           = REMOTE_NDIS_INITIALIZE_CMPLT;
 231                         INITIALIZE_Response->MessageLength         = sizeof(RNDIS_Initialize_Complete_t);
 232                         INITIALIZE_Response->RequestId             = INITIALIZE_Message->RequestId;
 233                         INITIALIZE_Response->Status                = REMOTE_NDIS_STATUS_SUCCESS;
 234
 235                         INITIALIZE_Response->MajorVersion          = REMOTE_NDIS_VERSION_MAJOR;
 236                         INITIALIZE_Response->MinorVersion          = REMOTE_NDIS_VERSION_MINOR;
 237                         INITIALIZE_Response->DeviceFlags           = REMOTE_NDIS_DF_CONNECTIONLESS;
 238                         INITIALIZE_Response->Medium                = REMOTE_NDIS_MEDIUM_802_3;
 239                         INITIALIZE_Response->MaxPacketsPerTransfer = 1;
 240                         INITIALIZE_Response->MaxTransferSize       = (sizeof(RNDIS_Packet_Message_t) + ETHERNET_FRAME_SIZE_MAX);
 241                         INITIALIZE_Response->PacketAlignmentFactor = 0;
 242                         INITIALIZE_Response->AFListOffset          = 0;
 243                         INITIALIZE_Response->AFListSize            = 0;
 244
 245                         RNDISInterfaceInfo->State.CurrRNDISState = RNDIS_Initialized;
 246
 247                         break;
 248                 case REMOTE_NDIS_HALT_MSG:
 249                         RNDISInterfaceInfo->State.ResponseReady = false;
 250                         MessageHeader->MessageLength = 0;
 251
 252                         RNDISInterfaceInfo->State.CurrRNDISState = RNDIS_Uninitialized;
 253
 254                         break;
 255                 case REMOTE_NDIS_QUERY_MSG:
 256                         RNDISInterfaceInfo->State.ResponseReady = true;
 257
 258                         RNDIS_Query_Message_t*  QUERY_Message  = (RNDIS_Query_Message_t*)&RNDISInterfaceInfo->State.RNDISMessageBuffer;
 259                         RNDIS_Query_Complete_t* QUERY_Response = (RNDIS_Query_Complete_t*)&RNDISInterfaceInfo->State.RNDISMessageBuffer;
 260                         uint32_t                Query_Oid      = QUERY_Message->Oid;
 261
 262                         void*     QueryData = &RNDISInterfaceInfo->State.RNDISMessageBuffer[sizeof(RNDIS_Message_Header_t) +
 263                                                                                             QUERY_Message->InformationBufferOffset];
 264                         void*     ResponseData = &RNDISInterfaceInfo->State.RNDISMessageBuffer[sizeof(RNDIS_Query_Complete_t)];
 265                         uint16_t  ResponseSize;
 266
 267                         QUERY_Response->MessageType   = REMOTE_NDIS_QUERY_CMPLT;
 268                         QUERY_Response->MessageLength = sizeof(RNDIS_Query_Complete_t);
 269
 270                         if (RNDIS_Device_ProcessNDISQuery(RNDISInterfaceInfo, Query_Oid, QueryData, QUERY_Message->InformationBufferLength,
 271                                                           ResponseData, &ResponseSize))
 272                         {
 273                                 QUERY_Response->Status                  = REMOTE_NDIS_STATUS_SUCCESS;
 274                                 QUERY_Response->MessageLength          += ResponseSize;
 275
 276                                 QUERY_Response->InformationBufferLength = ResponseSize;
 277                                 QUERY_Response->InformationBufferOffset = (sizeof(RNDIS_Query_Complete_t) - sizeof(RNDIS_Message_Header_t));
 278                         }
 279                         else
 280                         {
 281                                 QUERY_Response->Status                  = REMOTE_NDIS_STATUS_NOT_SUPPORTED;
 282
 283                                 QUERY_Response->InformationBufferLength = 0;
 284                                 QUERY_Response->InformationBufferOffset = 0;
 285                         }
 286
 287                         break;
 288                 case REMOTE_NDIS_SET_MSG:
 289                         RNDISInterfaceInfo->State.ResponseReady = true;
 290
 291                         RNDIS_Set_Message_t*  SET_Message  = (RNDIS_Set_Message_t*)&RNDISInterfaceInfo->State.RNDISMessageBuffer;
 292                         RNDIS_Set_Complete_t* SET_Response = (RNDIS_Set_Complete_t*)&RNDISInterfaceInfo->State.RNDISMessageBuffer;
 293                         uint32_t              SET_Oid      = SET_Message->Oid;
 294
 295                         SET_Response->MessageType   = REMOTE_NDIS_SET_CMPLT;
 296                         SET_Response->MessageLength = sizeof(RNDIS_Set_Complete_t);
 297                         SET_Response->RequestId     = SET_Message->RequestId;
 298
 299                         void* SetData = &RNDISInterfaceInfo->State.RNDISMessageBuffer[sizeof(RNDIS_Message_Header_t) +
 300                                                                                       SET_Message->InformationBufferOffset];
 301
 302                         SET_Response->Status = RNDIS_Device_ProcessNDISSet(RNDISInterfaceInfo, SET_Oid, SetData,
 303                                                                            SET_Message->InformationBufferLength) ?
 304                                                                            REMOTE_NDIS_STATUS_SUCCESS : REMOTE_NDIS_STATUS_NOT_SUPPORTED;
 305                         break;
 306                 case REMOTE_NDIS_RESET_MSG:
 307                         RNDISInterfaceInfo->State.ResponseReady = true;
 308
 309                         RNDIS_Reset_Complete_t* RESET_Response = (RNDIS_Reset_Complete_t*)&RNDISInterfaceInfo->State.RNDISMessageBuffer;
 310
 311                         RESET_Response->MessageType     = REMOTE_NDIS_RESET_CMPLT;
 312                         RESET_Response->MessageLength   = sizeof(RNDIS_Reset_Complete_t);
 313                         RESET_Response->Status          = REMOTE_NDIS_STATUS_SUCCESS;
 314                         RESET_Response->AddressingReset = 0;
 315
 316                         break;
 317                 case REMOTE_NDIS_KEEPALIVE_MSG:
 318                         RNDISInterfaceInfo->State.ResponseReady = true;
 319
 320                         RNDIS_KeepAlive_Message_t*  KEEPALIVE_Message  =
 321                                         (RNDIS_KeepAlive_Message_t*)&RNDISInterfaceInfo->State.RNDISMessageBuffer;
 322                         RNDIS_KeepAlive_Complete_t* KEEPALIVE_Response =
 323                                         (RNDIS_KeepAlive_Complete_t*)&RNDISInterfaceInfo->State.RNDISMessageBuffer;
 324
 325                         KEEPALIVE_Response->MessageType   = REMOTE_NDIS_KEEPALIVE_CMPLT;
 326                         KEEPALIVE_Response->MessageLength = sizeof(RNDIS_KeepAlive_Complete_t);
 327                         KEEPALIVE_Response->RequestId     = KEEPALIVE_Message->RequestId;
 328                         KEEPALIVE_Response->Status        = REMOTE_NDIS_STATUS_SUCCESS;
 329
 330                         break;
 331         }
 332 }
 333
 334 static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo,
 335                                           const uint32_t OId, void* const QueryData, const uint16_t QuerySize,
 336                                           void* ResponseData, uint16_t* const ResponseSize)
 337 {
 338         (void)QueryData;
 339         (void)QuerySize;
 340
 341         switch (OId)
 342         {
 343                 case OID_GEN_SUPPORTED_LIST:
 344                         *ResponseSize = sizeof(AdapterSupportedOIDList);
 345
 346                         memcpy_P(ResponseData, AdapterSupportedOIDList, sizeof(AdapterSupportedOIDList));
 347
 348                         return true;
 349                 case OID_GEN_PHYSICAL_MEDIUM:
 350                         *ResponseSize = sizeof(uint32_t);
 351
 352                         /* Indicate that the device is a true ethernet link */
 353                         *((uint32_t*)ResponseData) = 0;
 354
 355                         return true;
 356                 case OID_GEN_HARDWARE_STATUS:
 357                         *ResponseSize = sizeof(uint32_t);
 358
 359                         *((uint32_t*)ResponseData) = NDIS_HardwareStatus_Ready;
 360
 361                         return true;
 362                 case OID_GEN_MEDIA_SUPPORTED:
 363                 case OID_GEN_MEDIA_IN_USE:
 364                         *ResponseSize = sizeof(uint32_t);
 365
 366                         *((uint32_t*)ResponseData) = REMOTE_NDIS_MEDIUM_802_3;
 367
 368                         return true;
 369                 case OID_GEN_VENDOR_ID:
 370                         *ResponseSize = sizeof(uint32_t);
 371
 372                         /* Vendor ID 0x0xFFFFFF is reserved for vendors who have not purchased a NDIS VID */
 373                         *((uint32_t*)ResponseData) = 0x00FFFFFF;
 374
 375                         return true;
 376                 case OID_GEN_MAXIMUM_FRAME_SIZE:
 377                 case OID_GEN_TRANSMIT_BLOCK_SIZE:
 378                 case OID_GEN_RECEIVE_BLOCK_SIZE:
 379                         *ResponseSize = sizeof(uint32_t);
 380
 381                         *((uint32_t*)ResponseData) = ETHERNET_FRAME_SIZE_MAX;
 382
 383                         return true;
 384                 case OID_GEN_VENDOR_DESCRIPTION:
 385                         *ResponseSize = (strlen(RNDISInterfaceInfo->Config.AdapterVendorDescription) + 1);
 386
 387                         memcpy(ResponseData, RNDISInterfaceInfo->Config.AdapterVendorDescription, *ResponseSize);
 388
 389                         return true;
 390                 case OID_GEN_MEDIA_CONNECT_STATUS:
 391                         *ResponseSize = sizeof(uint32_t);
 392
 393                         *((uint32_t*)ResponseData) = REMOTE_NDIS_MEDIA_STATE_CONNECTED;
 394
 395                         return true;
 396                 case OID_GEN_LINK_SPEED:
 397                         *ResponseSize = sizeof(uint32_t);
 398
 399                         /* Indicate 10Mb/s link speed */
 400                         *((uint32_t*)ResponseData) = 100000;
 401
 402                         return true;
 403                 case OID_802_3_PERMANENT_ADDRESS:
 404                 case OID_802_3_CURRENT_ADDRESS:
 405                         *ResponseSize = sizeof(MAC_Address_t);
 406
 407                         memcpy(ResponseData, &RNDISInterfaceInfo->Config.AdapterMACAddress, sizeof(MAC_Address_t));
 408
 409                         return true;
 410                 case OID_802_3_MAXIMUM_LIST_SIZE:
 411                         *ResponseSize = sizeof(uint32_t);
 412
 413                         /* Indicate only one multicast address supported */
 414                         *((uint32_t*)ResponseData) = 1;
 415
 416                         return true;
 417                 case OID_GEN_CURRENT_PACKET_FILTER:
 418                         *ResponseSize = sizeof(uint32_t);
 419
 420                         *((uint32_t*)ResponseData) = RNDISInterfaceInfo->State.CurrPacketFilter;
 421
 422                         return true;
 423                 case OID_GEN_XMIT_OK:
 424                 case OID_GEN_RCV_OK:
 425                 case OID_GEN_XMIT_ERROR:
 426                 case OID_GEN_RCV_ERROR:
 427                 case OID_GEN_RCV_NO_BUFFER:
 428                 case OID_802_3_RCV_ERROR_ALIGNMENT:
 429                 case OID_802_3_XMIT_ONE_COLLISION:
 430                 case OID_802_3_XMIT_MORE_COLLISIONS:
 431                         *ResponseSize = sizeof(uint32_t);
 432
 433                         /* Unused statistic OIDs - always return 0 for each */
 434                         *((uint32_t*)ResponseData) = 0;
 435
 436                         return true;
 437                 case OID_GEN_MAXIMUM_TOTAL_SIZE:
 438                         *ResponseSize = sizeof(uint32_t);
 439
 440                         /* Indicate maximum overall buffer (Ethernet frame and RNDIS header) the adapter can handle */
 441                         *((uint32_t*)ResponseData) = (RNDIS_MESSAGE_BUFFER_SIZE + ETHERNET_FRAME_SIZE_MAX);
 442
 443                         return true;
 444                 default:
 445                         return false;
 446         }
 447 }
 448
 449 static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo, const uint32_t OId,
 450                                         void* SetData, const uint16_t SetSize)
 451 {
 452         (void)SetSize;
 453
 454         switch (OId)
 455         {
 456                 case OID_GEN_CURRENT_PACKET_FILTER:
 457                         RNDISInterfaceInfo->State.CurrPacketFilter = *((uint32_t*)SetData);
 458                         RNDISInterfaceInfo->State.CurrRNDISState = ((RNDISInterfaceInfo->State.CurrPacketFilter) ?
 459                                                               RNDIS_Data_Initialized : RNDIS_Data_Initialized);
 460
 461                         return true;
 462                 case OID_802_3_MULTICAST_LIST:
 463                         /* Do nothing - throw away the value from the host as it is unused */
 464
 465                         return true;
 466                 default:
 467                         return false;
 468         }
 469 }
 470
 471 #endif