tmk_core/protocol/lufa/LUFA-git/Demos/Host/LowLevel/RNDISEthernetHost/RNDISEthernetHost.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2014.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2014  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 disclaims 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 /** Main program entry point. This routine configures the hardware required by the application, then
  40  *  enters a loop to run the application tasks in sequence.
  41  */
  42 int main(void)
  43 {
  44         SetupHardware();
  45
  46         puts_P(PSTR(ESC_FG_CYAN "RNDIS Host Demo running.\r\n" ESC_FG_WHITE));
  47
  48         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  49         GlobalInterruptEnable();
  50
  51         for (;;)
  52         {
  53                 RNDISHost_Task();
  54
  55                 USB_USBTask();
  56         }
  57 }
  58
  59 /** Configures the board hardware and chip peripherals for the demo's functionality. */
  60 void SetupHardware(void)
  61 {
  62 #if (ARCH == ARCH_AVR8)
  63         /* Disable watchdog if enabled by bootloader/fuses */
  64         MCUSR &= ~(1 << WDRF);
  65         wdt_disable();
  66
  67         /* Disable clock division */
  68         clock_prescale_set(clock_div_1);
  69 #endif
  70
  71         /* Hardware Initialization */
  72         Serial_Init(9600, false);
  73         LEDs_Init();
  74         USB_Init();
  75
  76         /* Create a stdio stream for the serial port for stdin and stdout */
  77         Serial_CreateStream(NULL);
  78 }
  79
  80 /** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and
  81  *  starts the library USB task to begin the enumeration and USB management process.
  82  */
  83 void EVENT_USB_Host_DeviceAttached(void)
  84 {
  85         puts_P(PSTR(ESC_FG_GREEN "Device Attached.\r\n" ESC_FG_WHITE));
  86         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
  87 }
  88
  89 /** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and
  90  *  stops the library USB task management process.
  91  */
  92 void EVENT_USB_Host_DeviceUnattached(void)
  93 {
  94         puts_P(PSTR(ESC_FG_GREEN "\r\nDevice Unattached.\r\n" ESC_FG_WHITE));
  95         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  96 }
  97
  98 /** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
  99  *  enumerated by the host and is now ready to be used by the application.
 100  */
 101 void EVENT_USB_Host_DeviceEnumerationComplete(void)
 102 {
 103         puts_P(PSTR("Getting Config Data.\r\n"));
 104
 105         uint8_t ErrorCode;
 106
 107         /* Get and process the configuration descriptor data */
 108         if ((ErrorCode = ProcessConfigurationDescriptor()) != SuccessfulConfigRead)
 109         {
 110                 if (ErrorCode == ControlError)
 111                   puts_P(PSTR(ESC_FG_RED "Control Error (Get Configuration).\r\n"));
 112                 else
 113                   puts_P(PSTR(ESC_FG_RED "Invalid Device.\r\n"));
 114
 115                 printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 116
 117                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 118                 return;
 119         }
 120
 121         /* Set the device configuration to the first configuration (rarely do devices use multiple configurations) */
 122         if ((ErrorCode = USB_Host_SetDeviceConfiguration(1)) != HOST_SENDCONTROL_Successful)
 123         {
 124                 printf_P(PSTR(ESC_FG_RED "Control Error (Set Configuration).\r\n"
 125                                          " -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 126
 127                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 128                 return;
 129         }
 130
 131         uint16_t DeviceMaxPacketSize;
 132         if ((ErrorCode = RNDIS_InitializeDevice(1024, &DeviceMaxPacketSize)) != HOST_SENDCONTROL_Successful)
 133         {
 134                 printf_P(PSTR(ESC_FG_RED "Error Initializing Device.\r\n"
 135                                          " -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 136
 137                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 138                 USB_Host_SetDeviceConfiguration(0);
 139                 return;
 140         }
 141
 142         printf_P(PSTR("Device Max Transfer Size: %lu bytes.\r\n"), DeviceMaxPacketSize);
 143
 144         /* We set the default filter to only receive packets we would be interested in */
 145         uint32_t PacketFilter = (REMOTE_NDIS_PACKET_DIRECTED | REMOTE_NDIS_PACKET_BROADCAST | REMOTE_NDIS_PACKET_ALL_MULTICAST);
 146         if ((ErrorCode = RNDIS_SetRNDISProperty(OID_GEN_CURRENT_PACKET_FILTER,
 147                                                 &PacketFilter, sizeof(PacketFilter))) != HOST_SENDCONTROL_Successful)
 148         {
 149                 printf_P(PSTR(ESC_FG_RED "Error Setting Device Packet Filter.\r\n"
 150                                          " -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 151
 152                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 153                 USB_Host_SetDeviceConfiguration(0);
 154                 return;
 155         }
 156
 157         uint32_t VendorID;
 158         if ((ErrorCode = RNDIS_QueryRNDISProperty(OID_GEN_VENDOR_ID,
 159                                                   &VendorID, sizeof(VendorID))) != HOST_SENDCONTROL_Successful)
 160         {
 161                 printf_P(PSTR(ESC_FG_RED "Error Getting Vendor ID.\r\n"
 162                                          " -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 163
 164                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 165                 USB_Host_SetDeviceConfiguration(0);
 166                 return;
 167         }
 168
 169         printf_P(PSTR("Device Vendor ID: 0x%08lX\r\n"), VendorID);
 170
 171         puts_P(PSTR("RNDIS Device Enumerated.\r\n"));
 172         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 173 }
 174
 175 /** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
 176 void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
 177 {
 178         USB_Disable();
 179
 180         printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
 181                                  " -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
 182
 183         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 184         for(;;);
 185 }
 186
 187 /** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
 188  *  enumerating an attached USB device.
 189  */
 190 void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode,
 191                                             const uint8_t SubErrorCode)
 192 {
 193         printf_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n"
 194                                  " -- Error Code %d\r\n"
 195                                  " -- Sub Error Code %d\r\n"
 196                                  " -- In State %d\r\n" ESC_FG_WHITE), ErrorCode, SubErrorCode, USB_HostState);
 197
 198         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 199 }
 200
 201 /** Task to read in data received from the attached RNDIS device and print it to the serial port.
 202  */
 203 void RNDISHost_Task(void)
 204 {
 205         if (USB_HostState != HOST_STATE_Configured)
 206           return;
 207
 208         uint8_t ErrorCode;
 209
 210         LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
 211
 212         uint16_t PacketLength;
 213         if ((ErrorCode = RNDIS_GetPacketLength(&PacketLength)) != HOST_SENDCONTROL_Successful)
 214         {
 215                 printf_P(PSTR(ESC_FG_RED "Packet Reception Error.\r\n"
 216                                          " -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 217                 return;
 218         }
 219
 220         if (!(PacketLength))
 221           return;
 222
 223         Pipe_Unfreeze();
 224
 225         printf_P(PSTR("***PACKET (Size %d)***\r\n"), PacketLength);
 226
 227         if (PacketLength > 1024)
 228         {
 229                 puts_P(PSTR(ESC_FG_RED "Packet too large.\r\n" ESC_FG_WHITE));
 230                 Pipe_Discard_Stream(PacketLength, NULL);
 231         }
 232         else
 233         {
 234                 uint8_t PacketBuffer[PacketLength];
 235
 236                 Pipe_Read_Stream_LE(&PacketBuffer, PacketLength, NULL);
 237
 238                 for (uint16_t i = 0; i < PacketLength; i++)
 239                   printf("0x%02x ", PacketBuffer[i]);
 240         }
 241
 242         Pipe_ClearIN();
 243         Pipe_Freeze();
 244
 245         printf("\r\n\r\n");
 246
 247         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 248 }
 249