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

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all 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_HOST)
  33
  34 #define  INCLUDE_FROM_RNDIS_CLASS_HOST_C
  35 #include "RNDIS.h"
  36
  37 uint8_t RNDIS_Host_ConfigurePipes(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, uint16_t ConfigDescriptorSize,
  38                                 void* ConfigDescriptorData)
  39 {
  40         uint8_t FoundEndpoints = 0;
  41
  42         memset(&RNDISInterfaceInfo->State, 0x00, sizeof(RNDISInterfaceInfo->State));
  43
  44         if (DESCRIPTOR_TYPE(ConfigDescriptorData) != DTYPE_Configuration)
  45           return RNDIS_ENUMERROR_InvalidConfigDescriptor;
  46
  47         if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  48                                       DComp_RNDIS_Host_NextRNDISControlInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  49         {
  50                 return RNDIS_ENUMERROR_NoRNDISInterfaceFound;
  51         }
  52
  53         RNDISInterfaceInfo->State.ControlInterfaceNumber = DESCRIPTOR_CAST(ConfigDescriptorData, USB_Descriptor_Interface_t).InterfaceNumber;
  54
  55         while (FoundEndpoints != (RNDIS_FOUND_NOTIFICATION_IN | RNDIS_FOUND_DATAPIPE_IN | RNDIS_FOUND_DATAPIPE_OUT))
  56         {
  57                 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  58                                               DComp_RNDIS_Host_NextRNDISInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
  59                 {
  60                         if (FoundEndpoints & RNDIS_FOUND_NOTIFICATION_IN)
  61                         {
  62                                 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  63                                                               DComp_RNDIS_Host_NextRNDISDataInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  64                                 {
  65                                         return RNDIS_ENUMERROR_NoRNDISInterfaceFound;
  66                                 }
  67                         }
  68                         else
  69                         {
  70                                 FoundEndpoints = 0;
  71
  72                                 Pipe_SelectPipe(RNDISInterfaceInfo->Config.DataINPipeNumber);
  73                                 Pipe_DisablePipe();
  74                                 Pipe_SelectPipe(RNDISInterfaceInfo->Config.DataOUTPipeNumber);
  75                                 Pipe_DisablePipe();
  76                                 Pipe_SelectPipe(RNDISInterfaceInfo->Config.NotificationPipeNumber);
  77                                 Pipe_DisablePipe();
  78
  79                                 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  80                                                               DComp_RNDIS_Host_NextRNDISControlInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  81                                 {
  82                                         return RNDIS_ENUMERROR_NoRNDISInterfaceFound;
  83                                 }
  84                         }
  85
  86                         if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  87                                                       DComp_RNDIS_Host_NextRNDISInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
  88                         {
  89                                 return RNDIS_ENUMERROR_EndpointsNotFound;
  90                         }
  91                 }
  92
  93                 USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Endpoint_t);
  94
  95                 if ((EndpointData->Attributes & EP_TYPE_MASK) == EP_TYPE_INTERRUPT)
  96                 {
  97                         if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
  98                         {
  99                                 Pipe_ConfigurePipe(RNDISInterfaceInfo->Config.NotificationPipeNumber, EP_TYPE_INTERRUPT, PIPE_TOKEN_IN,
 100                                                                    EndpointData->EndpointAddress, EndpointData->EndpointSize,
 101                                                                    RNDISInterfaceInfo->Config.NotificationPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
 102                                 RNDISInterfaceInfo->State.NotificationPipeSize = EndpointData->EndpointSize;
 103
 104                                 Pipe_SetInterruptPeriod(EndpointData->PollingIntervalMS);
 105
 106                                 FoundEndpoints |= RNDIS_FOUND_NOTIFICATION_IN;
 107                         }
 108                 }
 109                 else
 110                 {
 111                         if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
 112                         {
 113                                 Pipe_ConfigurePipe(RNDISInterfaceInfo->Config.DataINPipeNumber, EP_TYPE_BULK, PIPE_TOKEN_IN,
 114                                                    EndpointData->EndpointAddress, EndpointData->EndpointSize,
 115                                                    RNDISInterfaceInfo->Config.DataINPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
 116                                 RNDISInterfaceInfo->State.DataINPipeSize = EndpointData->EndpointSize;
 117
 118                                 FoundEndpoints |= RNDIS_FOUND_DATAPIPE_IN;
 119                         }
 120                         else
 121                         {
 122                                 Pipe_ConfigurePipe(RNDISInterfaceInfo->Config.DataOUTPipeNumber, EP_TYPE_BULK, PIPE_TOKEN_OUT,
 123                                                    EndpointData->EndpointAddress, EndpointData->EndpointSize,
 124                                                    RNDISInterfaceInfo->Config.DataOUTPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
 125
 126                                 RNDISInterfaceInfo->State.DataOUTPipeSize = EndpointData->EndpointSize;
 127
 128                                 FoundEndpoints |= RNDIS_FOUND_DATAPIPE_OUT;
 129                         }
 130                 }
 131         }
 132
 133         RNDISInterfaceInfo->State.IsActive = true;
 134         return RNDIS_ENUMERROR_NoError;
 135 }
 136
 137 static uint8_t DComp_RNDIS_Host_NextRNDISControlInterface(void* const CurrentDescriptor)
 138 {
 139         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 140         {
 141                 USB_Descriptor_Interface_t* CurrentInterface = DESCRIPTOR_PCAST(CurrentDescriptor,
 142                                                                                 USB_Descriptor_Interface_t);
 143
 144                 if ((CurrentInterface->Class    == RNDIS_CONTROL_CLASS)    &&
 145                     (CurrentInterface->SubClass == RNDIS_CONTROL_SUBCLASS) &&
 146                         (CurrentInterface->Protocol == RNDIS_CONTROL_PROTOCOL))
 147                 {
 148                         return DESCRIPTOR_SEARCH_Found;
 149                 }
 150         }
 151
 152         return DESCRIPTOR_SEARCH_NotFound;
 153 }
 154
 155 static uint8_t DComp_RNDIS_Host_NextRNDISDataInterface(void* const CurrentDescriptor)
 156 {
 157         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 158         {
 159                 USB_Descriptor_Interface_t* CurrentInterface = DESCRIPTOR_PCAST(CurrentDescriptor,
 160                                                                                 USB_Descriptor_Interface_t);
 161
 162                 if ((CurrentInterface->Class    == RNDIS_DATA_CLASS)    &&
 163                     (CurrentInterface->SubClass == RNDIS_DATA_SUBCLASS) &&
 164                         (CurrentInterface->Protocol == RNDIS_DATA_PROTOCOL))
 165                 {
 166                         return DESCRIPTOR_SEARCH_Found;
 167                 }
 168         }
 169
 170         return DESCRIPTOR_SEARCH_NotFound;
 171 }
 172
 173 static uint8_t DComp_RNDIS_Host_NextRNDISInterfaceEndpoint(void* const CurrentDescriptor)
 174 {
 175         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Endpoint)
 176         {
 177                 USB_Descriptor_Endpoint_t* CurrentEndpoint = DESCRIPTOR_PCAST(CurrentDescriptor,
 178                                                                               USB_Descriptor_Endpoint_t);
 179
 180                 uint8_t EndpointType = (CurrentEndpoint->Attributes & EP_TYPE_MASK);
 181
 182                 if ((EndpointType == EP_TYPE_BULK) || (EndpointType == EP_TYPE_INTERRUPT))
 183                 {
 184                         return DESCRIPTOR_SEARCH_Found;
 185                 }
 186         }
 187         else if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 188         {
 189                 return DESCRIPTOR_SEARCH_Fail;
 190         }
 191
 192         return DESCRIPTOR_SEARCH_NotFound;
 193 }
 194
 195 static uint8_t RNDIS_SendEncapsulatedCommand(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo,
 196                                              void* Buffer, uint16_t Length)
 197 {
 198         USB_ControlRequest = (USB_Request_Header_t)
 199                 {
 200                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 201                         .bRequest      = REQ_SendEncapsulatedCommand,
 202                         .wValue        = 0,
 203                         .wIndex        = RNDISInterfaceInfo->State.ControlInterfaceNumber,
 204                         .wLength       = Length,
 205                 };
 206
 207         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 208         return USB_Host_SendControlRequest(Buffer);
 209 }
 210
 211 static uint8_t RNDIS_GetEncapsulatedResponse(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo,
 212                                              void* Buffer, uint16_t Length)
 213 {
 214         USB_ControlRequest = (USB_Request_Header_t)
 215                 {
 216                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 217                         .bRequest      = REQ_GetEncapsulatedResponse,
 218                         .wValue        = 0,
 219                         .wIndex        = RNDISInterfaceInfo->State.ControlInterfaceNumber,
 220                         .wLength       = Length,
 221                 };
 222
 223         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 224         return USB_Host_SendControlRequest(Buffer);
 225 }
 226
 227 uint8_t RNDIS_Host_SendKeepAlive(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo)
 228 {
 229         uint8_t ErrorCode;
 230
 231         RNDIS_KeepAlive_Message_t  KeepAliveMessage;
 232         RNDIS_KeepAlive_Complete_t KeepAliveMessageResponse;
 233
 234         KeepAliveMessage.MessageType     = REMOTE_NDIS_KEEPALIVE_MSG;
 235         KeepAliveMessage.MessageLength   = sizeof(RNDIS_KeepAlive_Message_t);
 236         KeepAliveMessage.RequestId       = RNDISInterfaceInfo->State.RequestID++;
 237
 238         if ((ErrorCode = RNDIS_SendEncapsulatedCommand(RNDISInterfaceInfo, &KeepAliveMessage,
 239                                                        sizeof(RNDIS_KeepAlive_Message_t))) != HOST_SENDCONTROL_Successful)
 240         {
 241                 return ErrorCode;
 242         }
 243
 244         if ((ErrorCode = RNDIS_GetEncapsulatedResponse(RNDISInterfaceInfo, &KeepAliveMessageResponse,
 245                                                        sizeof(RNDIS_KeepAlive_Complete_t))) != HOST_SENDCONTROL_Successful)
 246         {
 247                 return ErrorCode;
 248         }
 249
 250         return HOST_SENDCONTROL_Successful;
 251 }
 252
 253 uint8_t RNDIS_Host_InitializeDevice(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo)
 254 {
 255         uint8_t ErrorCode;
 256
 257         RNDIS_Initialize_Message_t  InitMessage;
 258         RNDIS_Initialize_Complete_t InitMessageResponse;
 259
 260         InitMessage.MessageType     = REMOTE_NDIS_INITIALIZE_MSG;
 261         InitMessage.MessageLength   = sizeof(RNDIS_Initialize_Message_t);
 262         InitMessage.RequestId       = RNDISInterfaceInfo->State.RequestID++;
 263
 264         InitMessage.MajorVersion    = REMOTE_NDIS_VERSION_MAJOR;
 265         InitMessage.MinorVersion    = REMOTE_NDIS_VERSION_MINOR;
 266         InitMessage.MaxTransferSize = RNDISInterfaceInfo->Config.HostMaxPacketSize;
 267
 268         if ((ErrorCode = RNDIS_SendEncapsulatedCommand(RNDISInterfaceInfo, &InitMessage,
 269                                                        sizeof(RNDIS_Initialize_Message_t))) != HOST_SENDCONTROL_Successful)
 270         {
 271                 return ErrorCode;
 272         }
 273
 274         if ((ErrorCode = RNDIS_GetEncapsulatedResponse(RNDISInterfaceInfo, &InitMessageResponse,
 275                                                        sizeof(RNDIS_Initialize_Complete_t))) != HOST_SENDCONTROL_Successful)
 276         {
 277                 return ErrorCode;
 278         }
 279
 280         if (InitMessageResponse.Status != REMOTE_NDIS_STATUS_SUCCESS)
 281           return RNDIS_COMMAND_FAILED;
 282
 283         RNDISInterfaceInfo->State.DeviceMaxPacketSize = InitMessageResponse.MaxTransferSize;
 284
 285         return HOST_SENDCONTROL_Successful;
 286 }
 287
 288 uint8_t RNDIS_Host_SetRNDISProperty(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, uint32_t Oid, void* Buffer, uint16_t Length)
 289 {
 290         uint8_t ErrorCode;
 291
 292         struct
 293         {
 294                 RNDIS_Set_Message_t SetMessage;
 295                 uint8_t             ContigiousBuffer[Length];
 296         } SetMessageData;
 297
 298         RNDIS_Set_Complete_t SetMessageResponse;
 299
 300         SetMessageData.SetMessage.MessageType    = REMOTE_NDIS_SET_MSG;
 301         SetMessageData.SetMessage.MessageLength  = sizeof(RNDIS_Set_Message_t) + Length;
 302         SetMessageData.SetMessage.RequestId      = RNDISInterfaceInfo->State.RequestID++;
 303
 304         SetMessageData.SetMessage.Oid            = Oid;
 305         SetMessageData.SetMessage.InformationBufferLength = Length;
 306         SetMessageData.SetMessage.InformationBufferOffset = (sizeof(RNDIS_Set_Message_t) - sizeof(RNDIS_Message_Header_t));
 307         SetMessageData.SetMessage.DeviceVcHandle = 0;
 308
 309         memcpy(&SetMessageData.ContigiousBuffer, Buffer, Length);
 310
 311         if ((ErrorCode = RNDIS_SendEncapsulatedCommand(RNDISInterfaceInfo, &SetMessageData,
 312                                                        SetMessageData.SetMessage.MessageLength)) != HOST_SENDCONTROL_Successful)
 313         {
 314                 return ErrorCode;
 315         }
 316
 317         if ((ErrorCode = RNDIS_GetEncapsulatedResponse(RNDISInterfaceInfo, &SetMessageResponse,
 318                                                        sizeof(RNDIS_Set_Complete_t))) != HOST_SENDCONTROL_Successful)
 319         {
 320                 return ErrorCode;
 321         }
 322
 323         if (SetMessageResponse.Status != REMOTE_NDIS_STATUS_SUCCESS)
 324           return RNDIS_COMMAND_FAILED;
 325
 326         return HOST_SENDCONTROL_Successful;
 327 }
 328
 329 uint8_t RNDIS_Host_QueryRNDISProperty(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, uint32_t Oid, void* Buffer, uint16_t MaxLength)
 330 {
 331         uint8_t ErrorCode;
 332
 333         RNDIS_Query_Message_t QueryMessage;
 334
 335         struct
 336         {
 337                 RNDIS_Query_Complete_t QueryMessageResponse;
 338                 uint8_t                ContigiousBuffer[MaxLength];
 339         } QueryMessageResponseData;
 340
 341         QueryMessage.MessageType    = REMOTE_NDIS_QUERY_MSG;
 342         QueryMessage.MessageLength  = sizeof(RNDIS_Query_Message_t);
 343         QueryMessage.RequestId      = RNDISInterfaceInfo->State.RequestID++;
 344
 345         QueryMessage.Oid            = Oid;
 346         QueryMessage.InformationBufferLength = 0;
 347         QueryMessage.InformationBufferOffset = 0;
 348         QueryMessage.DeviceVcHandle = 0;
 349
 350         if ((ErrorCode = RNDIS_SendEncapsulatedCommand(RNDISInterfaceInfo, &QueryMessage,
 351                                                        sizeof(RNDIS_Query_Message_t))) != HOST_SENDCONTROL_Successful)
 352         {
 353                 return ErrorCode;
 354         }
 355
 356         if ((ErrorCode = RNDIS_GetEncapsulatedResponse(RNDISInterfaceInfo, &QueryMessageResponseData,
 357                                                        sizeof(QueryMessageResponseData))) != HOST_SENDCONTROL_Successful)
 358         {
 359                 return ErrorCode;
 360         }
 361
 362         if (QueryMessageResponseData.QueryMessageResponse.Status != REMOTE_NDIS_STATUS_SUCCESS)
 363           return RNDIS_COMMAND_FAILED;
 364
 365         memcpy(Buffer, &QueryMessageResponseData.ContigiousBuffer, MaxLength);
 366
 367         return HOST_SENDCONTROL_Successful;
 368 }
 369
 370 bool RNDIS_Host_IsPacketReceived(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo)
 371 {
 372         bool PacketWaiting;
 373
 374         if ((USB_HostState != HOST_STATE_Configured) || !(RNDISInterfaceInfo->State.IsActive))
 375           return false;
 376
 377         Pipe_SelectPipe(RNDISInterfaceInfo->Config.DataINPipeNumber);
 378         Pipe_SetPipeToken(PIPE_TOKEN_IN);
 379
 380         Pipe_Unfreeze();
 381
 382         PacketWaiting = (Pipe_IsINReceived() && Pipe_BytesInPipe());
 383
 384         Pipe_Freeze();
 385
 386         return PacketWaiting;
 387 }
 388
 389 uint8_t RNDIS_Host_ReadPacket(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, void* Buffer, uint16_t* PacketLength)
 390 {
 391         uint8_t ErrorCode;
 392
 393         if ((USB_HostState != HOST_STATE_Configured) || !(RNDISInterfaceInfo->State.IsActive))
 394           return PIPE_READYWAIT_DeviceDisconnected;
 395
 396         Pipe_SelectPipe(RNDISInterfaceInfo->Config.DataINPipeNumber);
 397         Pipe_SetPipeToken(PIPE_TOKEN_IN);
 398         Pipe_Unfreeze();
 399
 400         if (!(Pipe_IsReadWriteAllowed()))
 401         {
 402                 if (Pipe_IsINReceived())
 403                   Pipe_ClearIN();
 404
 405                 *PacketLength = 0;
 406                 Pipe_Freeze();
 407                 return PIPE_RWSTREAM_NoError;
 408         }
 409
 410         RNDIS_Packet_Message_t DeviceMessage;
 411
 412         if ((ErrorCode = Pipe_Read_Stream_LE(&DeviceMessage, sizeof(RNDIS_Packet_Message_t),
 413                                              NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
 414         {
 415                 return ErrorCode;
 416         }
 417
 418         *PacketLength = (uint16_t)DeviceMessage.DataLength;
 419
 420         Pipe_Discard_Stream(DeviceMessage.DataOffset - (sizeof(RNDIS_Packet_Message_t) - sizeof(RNDIS_Message_Header_t)),
 421                             NO_STREAM_CALLBACK);
 422
 423         Pipe_Read_Stream_LE(Buffer, *PacketLength, NO_STREAM_CALLBACK);
 424
 425         if (!(Pipe_BytesInPipe()))
 426           Pipe_ClearIN();
 427
 428         Pipe_Freeze();
 429
 430         return PIPE_RWSTREAM_NoError;
 431 }
 432
 433 uint8_t RNDIS_Host_SendPacket(USB_ClassInfo_RNDIS_Host_t* const RNDISInterfaceInfo, void* Buffer, uint16_t PacketLength)
 434 {
 435         uint8_t ErrorCode;
 436
 437         if ((USB_HostState != HOST_STATE_Configured) || !(RNDISInterfaceInfo->State.IsActive))
 438           return PIPE_READYWAIT_DeviceDisconnected;
 439
 440         RNDIS_Packet_Message_t DeviceMessage;
 441
 442         memset(&DeviceMessage, 0, sizeof(RNDIS_Packet_Message_t));
 443         DeviceMessage.MessageType   = REMOTE_NDIS_PACKET_MSG;
 444         DeviceMessage.MessageLength = (sizeof(RNDIS_Packet_Message_t) + PacketLength);
 445         DeviceMessage.DataOffset    = (sizeof(RNDIS_Packet_Message_t) - sizeof(RNDIS_Message_Header_t));
 446         DeviceMessage.DataLength    = PacketLength;
 447
 448         Pipe_SelectPipe(RNDISInterfaceInfo->Config.DataOUTPipeNumber);
 449         Pipe_Unfreeze();
 450
 451         if ((ErrorCode = Pipe_Write_Stream_LE(&DeviceMessage, sizeof(RNDIS_Packet_Message_t),
 452                                               NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
 453         {
 454                 return ErrorCode;
 455         }
 456
 457         Pipe_Write_Stream_LE(Buffer, PacketLength, NO_STREAM_CALLBACK);
 458         Pipe_ClearOUT();
 459
 460         Pipe_Freeze();
 461
 462         return PIPE_RWSTREAM_NoError;
 463 }
 464
 465 #endif