Fixed incorrect USB device state set when a suspended LUFA device is woken while...

[pub/USBasp.git] / Demos / Device / LowLevel / RNDISEthernet / RNDISEthernet.c

diff --git a/Demos/Device/LowLevel/RNDISEthernet/RNDISEthernet.c b/Demos/Device/LowLevel/RNDISEthernet/RNDISEthernet.c
index d11829d..2837a10 100644 (file)
--- a/Demos/Device/LowLevel/RNDISEthernet/RNDISEthernet.c
+++ b/Demos/Device/LowLevel/RNDISEthernet/RNDISEthernet.c
@@ -1,24 +1,24 @@
 /*
              LUFA Library
 /*
              LUFA Library

-     Copyright (C) Dean Camera, 2010.
-              
+     Copyright (C) Dean Camera, 2013.
+

   dean [at] fourwalledcubicle [dot] com
   dean [at] fourwalledcubicle [dot] com

-      www.fourwalledcubicle.com
+           www.lufa-lib.org

 */
 
 /*
 */
 
 /*

-  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+  Copyright 2013  Dean Camera (dean [at] fourwalledcubicle [dot] com)

 
 

-  Permission to use, copy, modify, distribute, and sell this 
+  Permission to use, copy, modify, distribute, and sell this

   software and its documentation for any purpose is hereby granted
   software and its documentation for any purpose is hereby granted

-  without fee, provided that the above copyright notice appear in 
+  without fee, provided that the above copyright notice appear in

   all copies and that both that the copyright notice and this
   all copies and that both that the copyright notice and this

-  permission notice and warranty disclaimer appear in supporting 
-  documentation, and that the name of the author not be used in 
-  advertising or publicity pertaining to distribution of the 
+  permission notice and warranty disclaimer appear in supporting
+  documentation, and that the name of the author not be used in
+  advertising or publicity pertaining to distribution of the

   software without specific, written prior permission.
 
   software without specific, written prior permission.
 

-  The author disclaim all warranties with regard to this
+  The author disclaims all warranties with regard to this

   software, including all implied warranties of merchantability
   and fitness.  In no event shall the author be liable for any
   special, indirect or consequential damages or any damages
   software, including all implied warranties of merchantability
   and fitness.  In no event shall the author be liable for any
   special, indirect or consequential damages or any damages


@@ -48,8 +48,8 @@ int main(void)
        Webserver_Init();
 
        LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
        Webserver_Init();
 
        LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);

-       sei();
-       
+       GlobalInterruptEnable();
+

        for (;;)
        {
                Ethernet_Task();
        for (;;)
        {
                Ethernet_Task();


@@ -62,17 +62,32 @@ int main(void)
 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 void SetupHardware(void)
 {
 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 void SetupHardware(void)
 {

+#if (ARCH == ARCH_AVR8)

        /* Disable watchdog if enabled by bootloader/fuses */
        MCUSR &= ~(1 << WDRF);
        wdt_disable();
 
        /* Disable clock division */
        clock_prescale_set(clock_div_1);
        /* Disable watchdog if enabled by bootloader/fuses */
        MCUSR &= ~(1 << WDRF);
        wdt_disable();
 
        /* Disable clock division */
        clock_prescale_set(clock_div_1);

+#elif (ARCH == ARCH_XMEGA)
+       /* Start the PLL to multiply the 2MHz RC oscillator to 32MHz and switch the CPU core to run from it */
+       XMEGACLK_StartPLL(CLOCK_SRC_INT_RC2MHZ, 2000000, F_CPU);
+       XMEGACLK_SetCPUClockSource(CLOCK_SRC_PLL);
+
+       /* Start the 32MHz internal RC oscillator and start the DFLL to increase it to 48MHz using the USB SOF as a reference */
+       XMEGACLK_StartInternalOscillator(CLOCK_SRC_INT_RC32MHZ);
+       XMEGACLK_StartDFLL(CLOCK_SRC_INT_RC32MHZ, DFLL_REF_INT_USBSOF, F_USB);
+
+       PMIC.CTRL = PMIC_LOLVLEN_bm | PMIC_MEDLVLEN_bm | PMIC_HILVLEN_bm;
+#endif

 
        /* Hardware Initialization */
        LEDs_Init();
 
        /* Hardware Initialization */
        LEDs_Init();

-       SerialStream_Init(9600, false);
+       Serial_Init(9600, false);

        USB_Init();
        USB_Init();

+
+       /* Create a stdio stream for the serial port for stdin and stdout */
+       Serial_CreateStream(NULL);

 }
 
 /** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs and
 }
 
 /** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs and


@@ -98,64 +113,43 @@ void EVENT_USB_Device_Disconnect(void)
  */
 void EVENT_USB_Device_ConfigurationChanged(void)
 {
  */
 void EVENT_USB_Device_ConfigurationChanged(void)
 {

-       /* Indicate USB connected and ready */
-       LEDs_SetAllLEDs(LEDMASK_USB_READY);
+       bool ConfigSuccess = true;

 
 

-       /* Setup CDC Notification, Rx and Tx Endpoints */
-       if (!(Endpoint_ConfigureEndpoint(CDC_TX_EPNUM, EP_TYPE_BULK,
-                                            ENDPOINT_DIR_IN, CDC_TXRX_EPSIZE,
-                                        ENDPOINT_BANK_SINGLE)))
-       {
-               LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
-       }                                                          
+       /* Setup RNDIS Data Endpoints */
+       ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_TX_EPADDR, EP_TYPE_BULK, CDC_TXRX_EPSIZE, 1);
+       ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_RX_EPADDR, EP_TYPE_BULK, CDC_TXRX_EPSIZE, 1);
+       ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_NOTIFICATION_EPADDR, EP_TYPE_INTERRUPT, CDC_NOTIFICATION_EPSIZE, 1);

 
 

-       if (!(Endpoint_ConfigureEndpoint(CDC_RX_EPNUM, EP_TYPE_BULK,
-                                            ENDPOINT_DIR_OUT, CDC_TXRX_EPSIZE,
-                                        ENDPOINT_BANK_SINGLE)))
-       {
-               LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
-       }
-
-       if (!(Endpoint_ConfigureEndpoint(CDC_NOTIFICATION_EPNUM, EP_TYPE_INTERRUPT,
-                                            ENDPOINT_DIR_IN, CDC_NOTIFICATION_EPSIZE,
-                                        ENDPOINT_BANK_SINGLE)))
-       {
-               LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
-       }
+       /* Indicate endpoint configuration success or failure */
+       LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);

 }
 
 }
 

-/** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific
- *  control requests that are not handled internally by the USB library (including the RNDIS control commands,
- *  which set up the USB RNDIS network adapter), so that they can be handled appropriately for the application.
+/** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
+ *  the device from the USB host before passing along unhandled control requests to the library for processing
+ *  internally.

  */
  */

-void EVENT_USB_Device_UnhandledControlRequest(void)
+void EVENT_USB_Device_ControlRequest(void)

 {
        /* Process RNDIS class commands */
        switch (USB_ControlRequest.bRequest)
        {
 {
        /* Process RNDIS class commands */
        switch (USB_ControlRequest.bRequest)
        {

-               case REQ_SendEncapsulatedCommand:
+               case RNDIS_REQ_SendEncapsulatedCommand:

                        if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
                        {
                        if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
                        {

-                               /* Clear the SETUP packet, ready for data transfer */

                                Endpoint_ClearSETUP();
                                Endpoint_ClearSETUP();

-                               
+

                                /* Read in the RNDIS message into the message buffer */
                                Endpoint_Read_Control_Stream_LE(RNDISMessageBuffer, USB_ControlRequest.wLength);
                                /* Read in the RNDIS message into the message buffer */
                                Endpoint_Read_Control_Stream_LE(RNDISMessageBuffer, USB_ControlRequest.wLength);

-
-                               /* Finalize the stream transfer to clear the last packet from the host */

                                Endpoint_ClearIN();
 
                                /* Process the RNDIS message */
                                ProcessRNDISControlMessage();
                        }
                                Endpoint_ClearIN();
 
                                /* Process the RNDIS message */
                                ProcessRNDISControlMessage();
                        }

-                       
+

                        break;
                        break;

-               case REQ_GetEncapsulatedResponse:
+               case RNDIS_REQ_GetEncapsulatedResponse:

                        if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
                        {
                        if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
                        {

-                               /* Clear the SETUP packet, ready for data transfer */
-                               Endpoint_ClearSETUP();
-                               

                                /* Check if a response to the last message is ready */
                                if (!(MessageHeader->MessageLength))
                                {
                                /* Check if a response to the last message is ready */
                                if (!(MessageHeader->MessageLength))
                                {


@@ -164,16 +158,16 @@ void EVENT_USB_Device_UnhandledControlRequest(void)
                                        MessageHeader->MessageLength = 1;
                                }
 
                                        MessageHeader->MessageLength = 1;
                                }
 

+                               Endpoint_ClearSETUP();
+

                                /* Write the message response data to the endpoint */
                                Endpoint_Write_Control_Stream_LE(RNDISMessageBuffer, MessageHeader->MessageLength);
                                /* Write the message response data to the endpoint */
                                Endpoint_Write_Control_Stream_LE(RNDISMessageBuffer, MessageHeader->MessageLength);

-                               
-                               /* Finalize the stream transfer to send the last packet or clear the host abort */

                                Endpoint_ClearOUT();
 
                                /* Reset the message header once again after transmission */
                                MessageHeader->MessageLength = 0;
                        }
                                Endpoint_ClearOUT();
 
                                /* Reset the message header once again after transmission */
                                MessageHeader->MessageLength = 0;
                        }

-       
+

                        break;
        }
 }
                        break;
        }
 }


@@ -185,22 +179,22 @@ void EVENT_USB_Device_UnhandledControlRequest(void)
 void RNDIS_Task(void)
 {
        /* Select the notification endpoint */
 void RNDIS_Task(void)
 {
        /* Select the notification endpoint */

-       Endpoint_SelectEndpoint(CDC_NOTIFICATION_EPNUM);
+       Endpoint_SelectEndpoint(CDC_NOTIFICATION_EPADDR);

 
        /* Check if a message response is ready for the host */
        if (Endpoint_IsINReady() && ResponseReady)
        {
 
        /* Check if a message response is ready for the host */
        if (Endpoint_IsINReady() && ResponseReady)
        {

-               USB_Notification_t Notification = (USB_Notification_t)
+               USB_Request_Header_t Notification = (USB_Request_Header_t)

                        {
                                .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
                        {
                                .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),

-                               .bNotification = NOTIF_RESPONSE_AVAILABLE,
+                               .bRequest      = RNDIS_NOTIF_ResponseAvailable,

                                .wValue        = 0,
                                .wIndex        = 0,
                                .wLength       = 0,
                        };
                                .wValue        = 0,
                                .wIndex        = 0,
                                .wLength       = 0,
                        };

-               
+

                /* Indicate that a message response is ready for the host */
                /* Indicate that a message response is ready for the host */

-               Endpoint_Write_Stream_LE(&Notification, sizeof(Notification));
+               Endpoint_Write_Stream_LE(&Notification, sizeof(Notification), NULL);

 
                /* Finalize the stream transfer to send the last packet */
                Endpoint_ClearIN();
 
                /* Finalize the stream transfer to send the last packet */
                Endpoint_ClearIN();


@@ -208,7 +202,7 @@ void RNDIS_Task(void)
                /* Indicate a response is no longer ready */
                ResponseReady = false;
        }
                /* Indicate a response is no longer ready */
                ResponseReady = false;
        }

-       
+

        /* Don't process the data endpoints until the system is in the data initialized state, and the buffer is free */
        if ((CurrRNDISState == RNDIS_Data_Initialized) && !(MessageHeader->MessageLength))
        {
        /* Don't process the data endpoints until the system is in the data initialized state, and the buffer is free */
        if ((CurrRNDISState == RNDIS_Data_Initialized) && !(MessageHeader->MessageLength))
        {


@@ -216,13 +210,13 @@ void RNDIS_Task(void)
                RNDIS_Packet_Message_t RNDISPacketHeader;
 
                /* Select the data OUT endpoint */
                RNDIS_Packet_Message_t RNDISPacketHeader;
 
                /* Select the data OUT endpoint */

-               Endpoint_SelectEndpoint(CDC_RX_EPNUM);
-               
+               Endpoint_SelectEndpoint(CDC_RX_EPADDR);
+

                /* Check if the data OUT endpoint contains data, and that the IN buffer is empty */
                /* Check if the data OUT endpoint contains data, and that the IN buffer is empty */

-               if (Endpoint_IsOUTReceived() && !(FrameIN.FrameInBuffer))
+               if (Endpoint_IsOUTReceived() && !(FrameIN.FrameLength))

                {
                        /* Read in the packet message header */
                {
                        /* Read in the packet message header */

-                       Endpoint_Read_Stream_LE(&RNDISPacketHeader, sizeof(RNDIS_Packet_Message_t));
+                       Endpoint_Read_Stream_LE(&RNDISPacketHeader, sizeof(RNDIS_Packet_Message_t), NULL);

 
                        /* Stall the request if the data is too large */
                        if (RNDISPacketHeader.DataLength > ETHERNET_FRAME_SIZE_MAX)
 
                        /* Stall the request if the data is too large */
                        if (RNDISPacketHeader.DataLength > ETHERNET_FRAME_SIZE_MAX)


@@ -230,25 +224,22 @@ void RNDIS_Task(void)
                                Endpoint_StallTransaction();
                                return;
                        }
                                Endpoint_StallTransaction();
                                return;
                        }

-                       
+

                        /* Read in the Ethernet frame into the buffer */
                        /* Read in the Ethernet frame into the buffer */

-                       Endpoint_Read_Stream_LE(FrameIN.FrameData, RNDISPacketHeader.DataLength);
+                       Endpoint_Read_Stream_LE(FrameIN.FrameData, RNDISPacketHeader.DataLength, NULL);

 
                        /* Finalize the stream transfer to send the last packet */
                        Endpoint_ClearOUT();
 
                        /* Finalize the stream transfer to send the last packet */
                        Endpoint_ClearOUT();

-                       
+

                        /* Store the size of the Ethernet frame */
                        FrameIN.FrameLength = RNDISPacketHeader.DataLength;
                        /* Store the size of the Ethernet frame */
                        FrameIN.FrameLength = RNDISPacketHeader.DataLength;

-
-                       /* Indicate Ethernet IN buffer full */
-                       FrameIN.FrameInBuffer = true;

                }
                }

-               
+

                /* Select the data IN endpoint */
                /* Select the data IN endpoint */

-               Endpoint_SelectEndpoint(CDC_TX_EPNUM);
-               
+               Endpoint_SelectEndpoint(CDC_TX_EPADDR);
+

                /* Check if the data IN endpoint is ready for more data, and that the IN buffer is full */
                /* Check if the data IN endpoint is ready for more data, and that the IN buffer is full */

-               if (Endpoint_IsINReady() && FrameOUT.FrameInBuffer)
+               if (Endpoint_IsINReady() && FrameOUT.FrameLength)

                {
                        /* Clear the packet header with all 0s so that the relevant fields can be filled */
                        memset(&RNDISPacketHeader, 0, sizeof(RNDIS_Packet_Message_t));
                {
                        /* Clear the packet header with all 0s so that the relevant fields can be filled */
                        memset(&RNDISPacketHeader, 0, sizeof(RNDIS_Packet_Message_t));


@@ -260,16 +251,16 @@ void RNDIS_Task(void)
                        RNDISPacketHeader.DataLength    = FrameOUT.FrameLength;
 
                        /* Send the packet header to the host */
                        RNDISPacketHeader.DataLength    = FrameOUT.FrameLength;
 
                        /* Send the packet header to the host */

-                       Endpoint_Write_Stream_LE(&RNDISPacketHeader, sizeof(RNDIS_Packet_Message_t));
+                       Endpoint_Write_Stream_LE(&RNDISPacketHeader, sizeof(RNDIS_Packet_Message_t), NULL);

 
                        /* Send the Ethernet frame data to the host */
 
                        /* Send the Ethernet frame data to the host */

-                       Endpoint_Write_Stream_LE(FrameOUT.FrameData, RNDISPacketHeader.DataLength);
-                       
+                       Endpoint_Write_Stream_LE(FrameOUT.FrameData, RNDISPacketHeader.DataLength, NULL);
+

                        /* Finalize the stream transfer to send the last packet */
                        Endpoint_ClearIN();
                        /* Finalize the stream transfer to send the last packet */
                        Endpoint_ClearIN();

-                       
+

                        /* Indicate Ethernet OUT buffer no longer full */
                        /* Indicate Ethernet OUT buffer no longer full */

-                       FrameOUT.FrameInBuffer = false;
+                       FrameOUT.FrameLength = 0;

                }
        }
 }
                }
        }
 }


@@ -288,7 +279,7 @@ void Ethernet_Task(void)
          return;
 
        /* Check if a frame has been written to the IN frame buffer */
          return;
 
        /* Check if a frame has been written to the IN frame buffer */

-       if (FrameIN.FrameInBuffer)
+       if (FrameIN.FrameLength)

        {
                /* Indicate packet processing started */
                LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
        {
                /* Indicate packet processing started */
                LEDs_SetAllLEDs(LEDMASK_USB_BUSY);


@@ -300,3 +291,4 @@ void Ethernet_Task(void)
                LEDs_SetAllLEDs(LEDMASK_USB_READY);
        }
 }
                LEDs_SetAllLEDs(LEDMASK_USB_READY);
        }
 }

+