Demos/Host/ClassDriver/RNDISEthernetHost/RNDISEthernetHost.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2011.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2011  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 /** \file
  32  *
  33  *  Main source file for the RNDISEthernetHost demo. This file contains the main tasks of
  34  *  the demo and is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "RNDISEthernetHost.h"
  38
  39 /** Buffer to hold incoming and outgoing Ethernet packets. */
  40 static int8_t PacketBuffer[1024];
  41
  42 /** LUFA RNDIS Class driver interface configuration and state information. This structure is
  43  *  passed to all RNDIS Class driver functions, so that multiple instances of the same class
  44  *  within a device can be differentiated from one another.
  45  */
  46 USB_ClassInfo_RNDIS_Host_t Ethernet_RNDIS_Interface =
  47         {
  48                 .Config =
  49                         {
  50                                 .DataINPipeNumber           = 1,
  51                                 .DataINPipeDoubleBank       = false,
  52
  53                                 .DataOUTPipeNumber          = 2,
  54                                 .DataOUTPipeDoubleBank      = false,
  55
  56                                 .NotificationPipeNumber     = 3,
  57                                 .NotificationPipeDoubleBank = false,
  58
  59                                 .HostMaxPacketSize          = sizeof(PacketBuffer),
  60                         },
  61         };
  62
  63
  64 /** Main program entry point. This routine configures the hardware required by the application, then
  65  *  enters a loop to run the application tasks in sequence.
  66  */
  67 int main(void)
  68 {
  69         SetupHardware();
  70
  71         puts_P(PSTR(ESC_FG_CYAN "RNDIS Host Demo running.\r\n" ESC_FG_WHITE));
  72
  73         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  74         sei();
  75
  76         for (;;)
  77         {
  78                 switch (USB_HostState)
  79                 {
  80                         case HOST_STATE_Addressed:
  81                                 LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
  82
  83                                 uint16_t ConfigDescriptorSize;
  84                                 uint8_t  ConfigDescriptorData[512];
  85
  86                                 if (USB_Host_GetDeviceConfigDescriptor(1, &ConfigDescriptorSize, ConfigDescriptorData,
  87                                                                        sizeof(ConfigDescriptorData)) != HOST_GETCONFIG_Successful)
  88                                 {
  89                                         puts_P(PSTR("Error Retrieving Configuration Descriptor.\r\n"));
  90                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
  91                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
  92                                         break;
  93                                 }
  94
  95                                 if (RNDIS_Host_ConfigurePipes(&Ethernet_RNDIS_Interface,
  96                                                               ConfigDescriptorSize, ConfigDescriptorData) != RNDIS_ENUMERROR_NoError)
  97                                 {
  98                                         puts_P(PSTR("Attached Device Not a Valid RNDIS Class Device.\r\n"));
  99                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 100                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 101                                         break;
 102                                 }
 103
 104                                 if (USB_Host_SetDeviceConfiguration(1) != HOST_SENDCONTROL_Successful)
 105                                 {
 106                                         puts_P(PSTR("Error Setting Device Configuration.\r\n"));
 107                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 108                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 109                                         break;
 110                                 }
 111
 112                                 if (RNDIS_Host_InitializeDevice(&Ethernet_RNDIS_Interface) != HOST_SENDCONTROL_Successful)
 113                                 {
 114                                         puts_P(PSTR("Error Initializing Device.\r\n"));
 115
 116                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 117                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 118                                         break;
 119                                 }
 120
 121                                 printf_P(PSTR("Device Max Transfer Size: %lu bytes.\r\n"), Ethernet_RNDIS_Interface.State.DeviceMaxPacketSize);
 122
 123                                 uint32_t PacketFilter = (REMOTE_NDIS_PACKET_DIRECTED | REMOTE_NDIS_PACKET_BROADCAST | REMOTE_NDIS_PACKET_ALL_MULTICAST);
 124                                 if (RNDIS_Host_SetRNDISProperty(&Ethernet_RNDIS_Interface, OID_GEN_CURRENT_PACKET_FILTER,
 125                                                                 &PacketFilter, sizeof(PacketFilter)) != HOST_SENDCONTROL_Successful)
 126                                 {
 127                                         puts_P(PSTR("Error Setting Device Packet Filter.\r\n"));
 128
 129                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 130                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 131                                         break;
 132                                 }
 133
 134                                 uint32_t VendorID;
 135                                 if (RNDIS_Host_QueryRNDISProperty(&Ethernet_RNDIS_Interface, OID_GEN_VENDOR_ID,
 136                                                                   &VendorID, sizeof(VendorID)) != HOST_SENDCONTROL_Successful)
 137                                 {
 138                                         puts_P(PSTR("Error Getting Vendor ID.\r\n"));
 139
 140                                         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 141                                         USB_HostState = HOST_STATE_WaitForDeviceRemoval;
 142                                         break;
 143                                 }
 144
 145                                 printf_P(PSTR("Device Vendor ID: 0x%08lX\r\n"), VendorID);
 146
 147                                 puts_P(PSTR("RNDIS Device Enumerated.\r\n"));
 148                                 LEDs_SetAllLEDs(LEDMASK_USB_READY);
 149                                 USB_HostState = HOST_STATE_Configured;
 150                                 break;
 151                         case HOST_STATE_Configured:
 152                                 PrintIncomingPackets();
 153
 154                                 break;
 155                 }
 156
 157                 RNDIS_Host_USBTask(&Ethernet_RNDIS_Interface);
 158                 USB_USBTask();
 159         }
 160 }
 161
 162 /** Prints incoming packets from the attached RNDIS device to the serial port. */
 163 void PrintIncomingPackets(void)
 164 {
 165         if (RNDIS_Host_IsPacketReceived(&Ethernet_RNDIS_Interface))
 166         {
 167                 LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
 168
 169                 uint16_t PacketLength;
 170                 RNDIS_Host_ReadPacket(&Ethernet_RNDIS_Interface, &PacketBuffer, &PacketLength);
 171
 172                 printf_P(PSTR("***PACKET (Size %d)***\r\n"), PacketLength);
 173
 174                 for (uint16_t i = 0; i < PacketLength; i++)
 175                   printf("0x%02x ", PacketBuffer[i]);
 176
 177                 printf_P(PSTR("\r\n\r\n"));
 178
 179                 LEDs_SetAllLEDs(LEDMASK_USB_READY);
 180         }
 181 }
 182
 183 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 184 void SetupHardware(void)
 185 {
 186         /* Disable watchdog if enabled by bootloader/fuses */
 187         MCUSR &= ~(1 << WDRF);
 188         wdt_disable();
 189
 190         /* Disable clock division */
 191         clock_prescale_set(clock_div_1);
 192
 193         /* Hardware Initialization */
 194         Serial_Init(9600, false);
 195         LEDs_Init();
 196         USB_Init();
 197
 198         /* Create a stdio stream for the serial port for stdin and stdout */
 199         Serial_CreateStream(NULL);
 200 }
 201
 202 /** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and
 203  *  starts the library USB task to begin the enumeration and USB management process.
 204  */
 205 void EVENT_USB_Host_DeviceAttached(void)
 206 {
 207         puts_P(PSTR("Device Attached.\r\n"));
 208         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 209 }
 210
 211 /** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and
 212  *  stops the library USB task management process.
 213  */
 214 void EVENT_USB_Host_DeviceUnattached(void)
 215 {
 216         puts_P(PSTR("\r\nDevice Unattached.\r\n"));
 217         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 218 }
 219
 220 /** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
 221  *  enumerated by the host and is now ready to be used by the application.
 222  */
 223 void EVENT_USB_Host_DeviceEnumerationComplete(void)
 224 {
 225         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 226 }
 227
 228 /** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
 229 void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
 230 {
 231         USB_Disable();
 232
 233         printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
 234                                  " -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
 235
 236         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 237         for(;;);
 238 }
 239
 240 /** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
 241  *  enumerating an attached USB device.
 242  */
 243 void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode,
 244                                             const uint8_t SubErrorCode)
 245 {
 246         printf_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n"
 247                                  " -- Error Code %d\r\n"
 248                                  " -- Sub Error Code %d\r\n"
 249                                  " -- In State %d\r\n" ESC_FG_WHITE), ErrorCode, SubErrorCode, USB_HostState);
 250
 251         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 252 }
 253