Make HID device class driver reselect the correct endpoint after the user callbacks...

[pub/USBasp.git] / Bootloaders / DFU / BootloaderDFU.c

diff --git a/Bootloaders/DFU/BootloaderDFU.c b/Bootloaders/DFU/BootloaderDFU.c
index 6bea9b2..71b37ea 100644 (file)
--- a/Bootloaders/DFU/BootloaderDFU.c
+++ b/Bootloaders/DFU/BootloaderDFU.c
@@ -92,11 +92,29 @@ uint16_t StartAddr = 0x0000;
  */\r
 uint16_t EndAddr = 0x0000;\r
 \r
  */\r
 uint16_t EndAddr = 0x0000;\r
 \r

+\r

 /** Main program entry point. This routine configures the hardware required by the bootloader, then continuously \r
  *  runs the bootloader processing routine until instructed to soft-exit, or hard-reset via the watchdog to start\r
  *  the loaded application code.\r
  */\r
 /** Main program entry point. This routine configures the hardware required by the bootloader, then continuously \r
  *  runs the bootloader processing routine until instructed to soft-exit, or hard-reset via the watchdog to start\r
  *  the loaded application code.\r
  */\r

-int main (void)\r
+int main(void)\r
+{\r
+       /* Configure hardware required by the bootloader */\r
+       SetupHardware();\r
+\r
+       /* Run the USB management task while the bootloader is supposed to be running */\r
+       while (RunBootloader || WaitForExit)\r
+         USB_USBTask();\r
+       \r
+       /* Reset configured hardware back to their original states for the user application */\r
+       ResetHardware();\r
+       \r
+       /* Start the user application */\r
+       AppStartPtr();\r
+}\r
+\r
+/** Configures all hardware required for the bootloader. */\r
+void SetupHardware(void)\r

 {\r
        /* Disable watchdog if enabled by bootloader/fuses */\r
        MCUSR &= ~(1 << WDRF);\r
 {\r
        /* Disable watchdog if enabled by bootloader/fuses */\r
        MCUSR &= ~(1 << WDRF);\r


@@ -111,59 +129,32 @@ int main (void)
 \r
        /* Initialize the USB subsystem */\r
        USB_Init();\r
 \r
        /* Initialize the USB subsystem */\r
        USB_Init();\r

+}\r

 \r
 \r

-       /* Run the USB management task while the bootloader is supposed to be running */\r
-       while (RunBootloader || WaitForExit)\r
-         USB_USBTask();\r
-       \r
+/** Resets all configured hardware required for the bootloader back to their original states. */\r
+void ResetHardware(void)\r
+{\r

        /* Shut down the USB subsystem */\r
        USB_ShutDown();\r
        \r
        /* Relocate the interrupt vector table back to the application section */\r
        MCUCR = (1 << IVCE);\r
        MCUCR = 0;\r
        /* Shut down the USB subsystem */\r
        USB_ShutDown();\r
        \r
        /* Relocate the interrupt vector table back to the application section */\r
        MCUCR = (1 << IVCE);\r
        MCUCR = 0;\r

-\r
-       /* Reset any used hardware ports back to their defaults */\r
-       PORTD = 0;\r
-       DDRD  = 0;\r
-       \r
-       #if defined(PORTE)\r
-       PORTE = 0;\r
-       DDRE  = 0;\r
-       #endif\r
-       \r
-       /* Start the user application */\r
-       AppStartPtr();\r
-}\r
-\r
-/** Event handler for the USB_Disconnect event. This indicates that the bootloader should exit and the user\r
- *  application started.\r
- */\r
-EVENT_HANDLER(USB_Disconnect)\r
-{\r
-       /* Upon disconnection, run user application */\r
-       RunBootloader = false;\r

 }\r
 \r
 }\r
 \r

-/** Event handler for the USB_UnhandledControlPacket event. This is used to catch standard and class specific\r
+/** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific\r

  *  control requests that are not handled internally by the USB library (including the DFU commands, which are\r
  *  all issued via the control endpoint), so that they can be handled appropriately for the application.\r
  */\r
  *  control requests that are not handled internally by the USB library (including the DFU commands, which are\r
  *  all issued via the control endpoint), so that they can be handled appropriately for the application.\r
  */\r

-EVENT_HANDLER(USB_UnhandledControlPacket)\r
+void EVENT_USB_Device_UnhandledControlRequest(void)\r

 {\r
 {\r

-       /* Discard unused wIndex value */\r
-       Endpoint_Discard_Word();\r
-       \r
-       /* Discard unused wValue value */\r
-       Endpoint_Discard_Word();\r
-\r

        /* Get the size of the command and data from the wLength value */\r
        /* Get the size of the command and data from the wLength value */\r

-       SentCommand.DataSize = Endpoint_Read_Word_LE();\r
+       SentCommand.DataSize = USB_ControlRequest.wLength;\r

 \r
 \r

-       switch (bRequest)\r
+       switch (USB_ControlRequest.bRequest)\r

        {\r
                case DFU_DNLOAD:\r
        {\r
                case DFU_DNLOAD:\r

-                       Endpoint_ClearSetupReceived();\r
+                       Endpoint_ClearSETUP();\r

                        \r
                        /* Check if bootloader is waiting to terminate */\r
                        if (WaitForExit)\r
                        \r
                        /* Check if bootloader is waiting to terminate */\r
                        if (WaitForExit)\r


@@ -178,7 +169,11 @@ EVENT_HANDLER(USB_UnhandledControlPacket)
                        /* If the request has a data stage, load it into the command struct */\r
                        if (SentCommand.DataSize)\r
                        {\r
                        /* If the request has a data stage, load it into the command struct */\r
                        if (SentCommand.DataSize)\r
                        {\r

-                               while (!(Endpoint_IsSetupOUTReceived()));\r
+                               while (!(Endpoint_IsOUTReceived()))\r
+                               {                               \r
+                                       if (USB_DeviceState == DEVICE_STATE_Unattached)\r
+                                         return;\r
+                               }\r

 \r
                                /* First byte of the data stage is the DNLOAD request's command */\r
                                SentCommand.Command = Endpoint_Read_Byte();\r
 \r
                                /* First byte of the data stage is the DNLOAD request's command */\r
                                SentCommand.Command = Endpoint_Read_Byte();\r


@@ -225,7 +220,7 @@ EVENT_HANDLER(USB_UnhandledControlPacket)
                                                {\r
                                                        uint16_t Words[2];\r
                                                        uint32_t Long;\r
                                                {\r
                                                        uint16_t Words[2];\r
                                                        uint32_t Long;\r

-                                               } CurrFlashAddress                 = {Words: {StartAddr, Flash64KBPage}};\r
+                                               } CurrFlashAddress                 = {.Words = {StartAddr, Flash64KBPage}};\r

                                                \r
                                                uint32_t CurrFlashPageStartAddress = CurrFlashAddress.Long;\r
                                                uint8_t  WordsInFlashPage          = 0;\r
                                                \r
                                                uint32_t CurrFlashPageStartAddress = CurrFlashAddress.Long;\r
                                                uint8_t  WordsInFlashPage          = 0;\r


@@ -235,8 +230,13 @@ EVENT_HANDLER(USB_UnhandledControlPacket)
                                                        /* Check if endpoint is empty - if so clear it and wait until ready for next packet */\r
                                                        if (!(Endpoint_BytesInEndpoint()))\r
                                                        {\r
                                                        /* Check if endpoint is empty - if so clear it and wait until ready for next packet */\r
                                                        if (!(Endpoint_BytesInEndpoint()))\r
                                                        {\r

-                                                               Endpoint_ClearSetupOUT();\r
-                                                               while (!(Endpoint_IsSetupOUTReceived()));\r
+                                                               Endpoint_ClearOUT();\r
+\r
+                                                               while (!(Endpoint_IsOUTReceived()))\r
+                                                               {                               \r
+                                                                       if (USB_DeviceState == DEVICE_STATE_Unattached)\r
+                                                                         return;\r
+                                                               }\r

                                                        }\r
 \r
                                                        /* Write the next word into the current flash page */\r
                                                        }\r
 \r
                                                        /* Write the next word into the current flash page */\r


@@ -279,8 +279,13 @@ EVENT_HANDLER(USB_UnhandledControlPacket)
                                                        /* Check if endpoint is empty - if so clear it and wait until ready for next packet */\r
                                                        if (!(Endpoint_BytesInEndpoint()))\r
                                                        {\r
                                                        /* Check if endpoint is empty - if so clear it and wait until ready for next packet */\r
                                                        if (!(Endpoint_BytesInEndpoint()))\r
                                                        {\r

-                                                               Endpoint_ClearSetupOUT();\r
-                                                               while (!(Endpoint_IsSetupOUTReceived()));\r
+                                                               Endpoint_ClearOUT();\r
+\r
+                                                               while (!(Endpoint_IsOUTReceived()))\r
+                                                               {                               \r
+                                                                       if (USB_DeviceState == DEVICE_STATE_Unattached)\r
+                                                                         return;\r
+                                                               }\r

                                                        }\r
 \r
                                                        /* Read the byte from the USB interface and write to to the EEPROM */\r
                                                        }\r
 \r
                                                        /* Read the byte from the USB interface and write to to the EEPROM */\r


@@ -296,18 +301,20 @@ EVENT_HANDLER(USB_UnhandledControlPacket)
                                }\r
                        }\r
 \r
                                }\r
                        }\r
 \r

-                       Endpoint_ClearSetupOUT();\r
+                       Endpoint_ClearOUT();\r
+\r
+                       Endpoint_ClearStatusStage();\r

 \r
 \r

-                       /* Acknowledge status stage */\r
-                       while (!(Endpoint_IsSetupINReady()));\r
-                       Endpoint_ClearSetupIN();\r
-                               \r

                        break;\r
                case DFU_UPLOAD:\r
                        break;\r
                case DFU_UPLOAD:\r

-                       Endpoint_ClearSetupReceived();\r
-\r
-                       while (!(Endpoint_IsSetupINReady()));\r
+                       Endpoint_ClearSETUP();\r

 \r
 \r

+                       while (!(Endpoint_IsINReady()))\r
+                       {                               \r
+                               if (USB_DeviceState == DEVICE_STATE_Unattached)\r
+                                 return;\r
+                       }\r
+                                                       \r

                        if (DFU_State != dfuUPLOAD_IDLE)\r
                        {\r
                                if ((DFU_State == dfuERROR) && IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))       // Blank Check\r
                        if (DFU_State != dfuUPLOAD_IDLE)\r
                        {\r
                                if ((DFU_State == dfuERROR) && IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))       // Blank Check\r


@@ -336,19 +343,24 @@ EVENT_HANDLER(USB_UnhandledControlPacket)
                                        {\r
                                                uint16_t Words[2];\r
                                                uint32_t Long;\r
                                        {\r
                                                uint16_t Words[2];\r
                                                uint32_t Long;\r

-                                       } CurrFlashAddress = {Words: {StartAddr, Flash64KBPage}};\r
+                                       } CurrFlashAddress = {.Words = {StartAddr, Flash64KBPage}};\r

 \r
                                        while (WordsRemaining--)\r
                                        {\r
                                                /* Check if endpoint is full - if so clear it and wait until ready for next packet */\r
                                                if (Endpoint_BytesInEndpoint() == FIXED_CONTROL_ENDPOINT_SIZE)\r
                                                {\r
 \r
                                        while (WordsRemaining--)\r
                                        {\r
                                                /* Check if endpoint is full - if so clear it and wait until ready for next packet */\r
                                                if (Endpoint_BytesInEndpoint() == FIXED_CONTROL_ENDPOINT_SIZE)\r
                                                {\r

-                                                       Endpoint_ClearSetupIN();\r
-                                                       while (!(Endpoint_IsSetupINReady()));\r
+                                                       Endpoint_ClearIN();\r
+\r
+                                                       while (!(Endpoint_IsINReady()))\r
+                                                       {                               \r
+                                                               if (USB_DeviceState == DEVICE_STATE_Unattached)\r
+                                                                 return;\r
+                                                       }\r

                                                }\r
 \r
                                                /* Read the flash word and send it via USB to the host */\r
                                                }\r
 \r
                                                /* Read the flash word and send it via USB to the host */\r

-                                               #if defined(RAMPZ)\r
+                                               #if (FLASHEND > 0xFFFF)\r

                                                        Endpoint_Write_Word_LE(pgm_read_word_far(CurrFlashAddress.Long));\r
                                                #else\r
                                                        Endpoint_Write_Word_LE(pgm_read_word(CurrFlashAddress.Long));                                                   \r
                                                        Endpoint_Write_Word_LE(pgm_read_word_far(CurrFlashAddress.Long));\r
                                                #else\r
                                                        Endpoint_Write_Word_LE(pgm_read_word(CurrFlashAddress.Long));                                                   \r


@@ -368,8 +380,13 @@ EVENT_HANDLER(USB_UnhandledControlPacket)
                                                /* Check if endpoint is full - if so clear it and wait until ready for next packet */\r
                                                if (Endpoint_BytesInEndpoint() == FIXED_CONTROL_ENDPOINT_SIZE)\r
                                                {\r
                                                /* Check if endpoint is full - if so clear it and wait until ready for next packet */\r
                                                if (Endpoint_BytesInEndpoint() == FIXED_CONTROL_ENDPOINT_SIZE)\r
                                                {\r

-                                                       Endpoint_ClearSetupIN();\r
-                                                       while (!(Endpoint_IsSetupINReady()));\r
+                                                       Endpoint_ClearIN();\r
+                                                       \r
+                                                       while (!(Endpoint_IsINReady()))\r
+                                                       {                               \r
+                                                               if (USB_DeviceState == DEVICE_STATE_Unattached)\r
+                                                                 return;\r
+                                                       }\r

                                                }\r
 \r
                                                /* Read the EEPROM byte and send it via USB to the host */\r
                                                }\r
 \r
                                                /* Read the EEPROM byte and send it via USB to the host */\r


@@ -384,15 +401,12 @@ EVENT_HANDLER(USB_UnhandledControlPacket)
                                DFU_State = dfuIDLE;\r
                        }\r
 \r
                                DFU_State = dfuIDLE;\r
                        }\r
 \r

-                       Endpoint_ClearSetupIN();\r
-\r
-                       /* Acknowledge status stage */\r
-                       while (!(Endpoint_IsSetupOUTReceived()));\r
-                       Endpoint_ClearSetupOUT();\r
+                       Endpoint_ClearIN();\r

 \r
 \r

+                       Endpoint_ClearStatusStage();\r

                        break;\r
                case DFU_GETSTATUS:\r
                        break;\r
                case DFU_GETSTATUS:\r

-                       Endpoint_ClearSetupReceived();\r
+                       Endpoint_ClearSETUP();\r

                        \r
                        /* Write 8-bit status value */\r
                        Endpoint_Write_Byte(DFU_Status);\r
                        \r
                        /* Write 8-bit status value */\r
                        Endpoint_Write_Byte(DFU_Status);\r


@@ -407,47 +421,35 @@ EVENT_HANDLER(USB_UnhandledControlPacket)
                        /* Write 8-bit state string ID number */\r
                        Endpoint_Write_Byte(0);\r
 \r
                        /* Write 8-bit state string ID number */\r
                        Endpoint_Write_Byte(0);\r
 \r

-                       Endpoint_ClearSetupIN();\r
+                       Endpoint_ClearIN();\r

                        \r
                        \r

-                       /* Acknowledge status stage */\r
-                       while (!(Endpoint_IsSetupOUTReceived()));\r
-                       Endpoint_ClearSetupOUT();\r
-       \r
+                       Endpoint_ClearStatusStage();\r

                        break;          \r
                case DFU_CLRSTATUS:\r
                        break;          \r
                case DFU_CLRSTATUS:\r

-                       Endpoint_ClearSetupReceived();\r
+                       Endpoint_ClearSETUP();\r

                        \r
                        /* Reset the status value variable to the default OK status */\r
                        DFU_Status = OK;\r
 \r
                        \r
                        /* Reset the status value variable to the default OK status */\r
                        DFU_Status = OK;\r
 \r

-                       /* Acknowledge status stage */\r
-                       while (!(Endpoint_IsSetupINReady()));\r
-                       Endpoint_ClearSetupIN();\r
-                       \r
+                       Endpoint_ClearStatusStage();\r

                        break;\r
                case DFU_GETSTATE:\r
                        break;\r
                case DFU_GETSTATE:\r

-                       Endpoint_ClearSetupReceived();\r
+                       Endpoint_ClearSETUP();\r

                        \r
                        /* Write the current device state to the endpoint */\r
                        Endpoint_Write_Byte(DFU_State);\r
                \r
                        \r
                        /* Write the current device state to the endpoint */\r
                        Endpoint_Write_Byte(DFU_State);\r
                \r

-                       Endpoint_ClearSetupIN();\r
+                       Endpoint_ClearIN();\r

                        \r
                        \r

-                       /* Acknowledge status stage */\r
-                       while (!(Endpoint_IsSetupOUTReceived()));\r
-                       Endpoint_ClearSetupOUT();\r
-\r
+                       Endpoint_ClearStatusStage();\r

                        break;\r
                case DFU_ABORT:\r
                        break;\r
                case DFU_ABORT:\r

-                       Endpoint_ClearSetupReceived();\r
+                       Endpoint_ClearSETUP();\r

                        \r
                        /* Reset the current state variable to the default idle state */\r
                        DFU_State = dfuIDLE;\r
                        \r
                        /* Reset the current state variable to the default idle state */\r
                        DFU_State = dfuIDLE;\r

-                       \r
-                       /* Acknowledge status stage */\r
-                       while (!(Endpoint_IsSetupINReady()));\r
-                       Endpoint_ClearSetupIN();\r

 \r
 \r

+                       Endpoint_ClearStatusStage();\r

                        break;\r
        }\r
 }\r
                        break;\r
        }\r
 }\r


@@ -455,7 +457,7 @@ EVENT_HANDLER(USB_UnhandledControlPacket)
 /** Routine to discard the specified number of bytes from the control endpoint stream. This is used to\r
  *  discard unused bytes in the stream from the host, including the memory program block suffix.\r
  *\r
 /** Routine to discard the specified number of bytes from the control endpoint stream. This is used to\r
  *  discard unused bytes in the stream from the host, including the memory program block suffix.\r
  *\r

- *  \param NumberOfBytes  Number of bytes to discard from the host from the control endpoint\r
+ *  \param[in] NumberOfBytes  Number of bytes to discard from the host from the control endpoint\r

  */\r
 static void DiscardFillerBytes(uint8_t NumberOfBytes)\r
 {\r
  */\r
 static void DiscardFillerBytes(uint8_t NumberOfBytes)\r
 {\r


@@ -463,13 +465,19 @@ static void DiscardFillerBytes(uint8_t NumberOfBytes)
        {\r
                if (!(Endpoint_BytesInEndpoint()))\r
                {\r
        {\r
                if (!(Endpoint_BytesInEndpoint()))\r
                {\r

-                       Endpoint_ClearSetupOUT();\r
+                       Endpoint_ClearOUT();\r

 \r
                        /* Wait until next data packet received */\r
 \r
                        /* Wait until next data packet received */\r

-                       while (!(Endpoint_IsSetupOUTReceived()));\r
+                       while (!(Endpoint_IsOUTReceived()))\r
+                       {                               \r
+                               if (USB_DeviceState == DEVICE_STATE_Unattached)\r
+                                 return;\r
+                       }\r
+               }\r
+               else\r
+               {\r
+                       Endpoint_Discard_Byte();\r

                }\r
                }\r

-\r
-               Endpoint_Discard_Byte();                                                \r

        }\r
 }\r
 \r
        }\r
 }\r
 \r


@@ -531,15 +539,15 @@ static void LoadStartEndAddresses(void)
        {\r
                uint8_t  Bytes[2];\r
                uint16_t Word;\r
        {\r
                uint8_t  Bytes[2];\r
                uint16_t Word;\r

-       } Address[2] = {{Bytes: {SentCommand.Data[2], SentCommand.Data[1]}},\r
-                       {Bytes: {SentCommand.Data[4], SentCommand.Data[3]}}};\r
+       } Address[2] = {{.Bytes = {SentCommand.Data[2], SentCommand.Data[1]}},\r
+                       {.Bytes = {SentCommand.Data[4], SentCommand.Data[3]}}};\r

                \r
        /* Load in the start and ending read addresses from the sent data packet */\r
        StartAddr = Address[0].Word;\r
        EndAddr   = Address[1].Word;\r
 }\r
 \r
                \r
        /* Load in the start and ending read addresses from the sent data packet */\r
        StartAddr = Address[0].Word;\r
        EndAddr   = Address[1].Word;\r
 }\r
 \r

-/** Handler for a Memory Program command issued by the host. This routine handles the preperations needed\r
+/** Handler for a Memory Program command issued by the host. This routine handles the preparations needed\r

  *  to write subsequent data from the host into the specified memory.\r
  */\r
 static void ProcessMemProgCommand(void)\r
  *  to write subsequent data from the host into the specified memory.\r
  */\r
 static void ProcessMemProgCommand(void)\r


@@ -557,7 +565,7 @@ static void ProcessMemProgCommand(void)
                        {\r
                                uint16_t Words[2];\r
                                uint32_t Long;\r
                        {\r
                                uint16_t Words[2];\r
                                uint32_t Long;\r

-                       } CurrFlashAddress = {Words: {StartAddr, Flash64KBPage}};\r
+                       } CurrFlashAddress = {.Words = {StartAddr, Flash64KBPage}};\r

                        \r
                        /* Erase the current page's temp buffer */\r
                        boot_page_erase(CurrFlashAddress.Long);\r
                        \r
                        /* Erase the current page's temp buffer */\r
                        boot_page_erase(CurrFlashAddress.Long);\r


@@ -569,7 +577,7 @@ static void ProcessMemProgCommand(void)
        }\r
 }\r
 \r
        }\r
 }\r
 \r

-/** Handler for a Memory Read command issued by the host. This routine handles the preperations needed\r
+/** Handler for a Memory Read command issued by the host. This routine handles the preparations needed\r

  *  to read subsequent data from the specified memory out to the host, as well as implementing the memory\r
  *  blank check command.\r
  */\r
  *  to read subsequent data from the specified memory out to the host, as well as implementing the memory\r
  *  blank check command.\r
  */\r


@@ -591,7 +599,7 @@ static void ProcessMemReadCommand(void)
                while (CurrFlashAddress < BOOT_START_ADDR)\r
                {\r
                        /* Check if the current byte is not blank */\r
                while (CurrFlashAddress < BOOT_START_ADDR)\r
                {\r
                        /* Check if the current byte is not blank */\r

-                       #if defined(RAMPZ)\r
+                       #if (FLASHEND > 0xFFFF)\r

                        if (pgm_read_byte_far(CurrFlashAddress) != 0xFF)\r
                        #else\r
                        if (pgm_read_byte(CurrFlashAddress) != 0xFF)\r
                        if (pgm_read_byte_far(CurrFlashAddress) != 0xFF)\r
                        #else\r
                        if (pgm_read_byte(CurrFlashAddress) != 0xFF)\r


@@ -639,7 +647,7 @@ static void ProcessWriteCommand(void)
                                {\r
                                        uint8_t  Bytes[2];\r
                                        AppPtr_t FuncPtr;\r
                                {\r
                                        uint8_t  Bytes[2];\r
                                        AppPtr_t FuncPtr;\r

-                               } Address = {Bytes: {SentCommand.Data[4], SentCommand.Data[3]}};\r
+                               } Address = {.Bytes = {SentCommand.Data[4], SentCommand.Data[3]}};\r

 \r
                                AppStartPtr = Address.FuncPtr;\r
                                \r
 \r
                                AppStartPtr = Address.FuncPtr;\r
                                \r


@@ -677,7 +685,7 @@ static void ProcessWriteCommand(void)
 static void ProcessReadCommand(void)\r
 {\r
        const uint8_t BootloaderInfo[3] = {BOOTLOADER_VERSION, BOOTLOADER_ID_BYTE1, BOOTLOADER_ID_BYTE2};\r
 static void ProcessReadCommand(void)\r
 {\r
        const uint8_t BootloaderInfo[3] = {BOOTLOADER_VERSION, BOOTLOADER_ID_BYTE1, BOOTLOADER_ID_BYTE2};\r

-       const uint8_t SignatureInfo[3]  = {SIGNATURE_0, SIGNATURE_1, SIGNATURE_2};\r
+       const uint8_t SignatureInfo[3]  = {AVR_SIGNATURE_1,    AVR_SIGNATURE_2,     AVR_SIGNATURE_3};\r

 \r
        uint8_t DataIndexToRead = SentCommand.Data[1];\r
 \r
 \r
        uint8_t DataIndexToRead = SentCommand.Data[1];\r
 \r