Add user callback function to the Bluetooth host demo to filter out connections from...

[pub/USBasp.git] / Projects / AVRISP-MKII / Lib / XPROG / XPROGProtocol.c

diff --git a/Projects/AVRISP-MKII/Lib/XPROG/XPROGProtocol.c b/Projects/AVRISP-MKII/Lib/XPROG/XPROGProtocol.c
index 5275cca..cc521ce 100644 (file)
--- a/Projects/AVRISP-MKII/Lib/XPROG/XPROGProtocol.c
+++ b/Projects/AVRISP-MKII/Lib/XPROG/XPROGProtocol.c
@@ -1,13 +1,13 @@
 /*\r
              LUFA Library\r
 /*\r
              LUFA Library\r

-     Copyright (C) Dean Camera, 2009.\r
+     Copyright (C) Dean Camera, 2010.\r

               \r
   dean [at] fourwalledcubicle [dot] com\r
       www.fourwalledcubicle.com\r
 */\r
 \r
 /*\r
               \r
   dean [at] fourwalledcubicle [dot] com\r
       www.fourwalledcubicle.com\r
 */\r
 \r
 /*\r

-  Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)\r
+  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)\r

 \r
   Permission to use, copy, modify, distribute, and sell this \r
   software and its documentation for any purpose is hereby granted\r
 \r
   Permission to use, copy, modify, distribute, and sell this \r
   software and its documentation for any purpose is hereby granted\r


@@ -38,7 +38,7 @@
 \r
 #if defined(ENABLE_XPROG_PROTOCOL) || defined(__DOXYGEN__)\r
 /** Base absolute address for the target's NVM controller for PDI programming */\r
 \r
 #if defined(ENABLE_XPROG_PROTOCOL) || defined(__DOXYGEN__)\r
 /** Base absolute address for the target's NVM controller for PDI programming */\r

-uint32_t XPROG_Param_NVMBase    = 0x010001C0;\r
+uint32_t XPROG_Param_NVMBase = 0x010001C0;\r

 \r
 /** Size in bytes of the target's EEPROM page */\r
 uint16_t XPROG_Param_EEPageSize;\r
 \r
 /** Size in bytes of the target's EEPROM page */\r
 uint16_t XPROG_Param_EEPageSize;\r


@@ -62,9 +62,10 @@ void XPROGProtocol_SetMode(void)
                uint8_t Protocol;\r
        } SetMode_XPROG_Params;\r
        \r
                uint8_t Protocol;\r
        } SetMode_XPROG_Params;\r
        \r

-       Endpoint_Read_Stream_LE(&SetMode_XPROG_Params, sizeof(SetMode_XPROG_Params));\r
+       Endpoint_Read_Stream_LE(&SetMode_XPROG_Params, sizeof(SetMode_XPROG_Params), NO_STREAM_CALLBACK);\r

 \r
        Endpoint_ClearOUT();\r
 \r
        Endpoint_ClearOUT();\r

+       Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);\r

        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
        \r
        XPROG_SelectedProtocol = SetMode_XPROG_Params.Protocol;\r
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
        \r
        XPROG_SelectedProtocol = SetMode_XPROG_Params.Protocol;\r


@@ -111,6 +112,7 @@ void XPROGProtocol_Command(void)
 static void XPROGProtocol_EnterXPROGMode(void)\r
 {\r
        Endpoint_ClearOUT();\r
 static void XPROGProtocol_EnterXPROGMode(void)\r
 {\r
        Endpoint_ClearOUT();\r

+       Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);\r

        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
        \r
        bool NVMBusEnabled;\r
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
        \r
        bool NVMBusEnabled;\r


@@ -119,11 +121,15 @@ static void XPROGProtocol_EnterXPROGMode(void)
        {\r
                /* Enable PDI programming mode with the attached target */\r
                XPROGTarget_EnableTargetPDI();\r
        {\r
                /* Enable PDI programming mode with the attached target */\r
                XPROGTarget_EnableTargetPDI();\r

-               \r
+\r

                /* Store the RESET key into the RESET PDI register to keep the XMEGA in reset */\r
                XPROGTarget_SendByte(PDI_CMD_STCS | PDI_RESET_REG);     \r
                XPROGTarget_SendByte(PDI_RESET_KEY);\r
 \r
                /* Store the RESET key into the RESET PDI register to keep the XMEGA in reset */\r
                XPROGTarget_SendByte(PDI_CMD_STCS | PDI_RESET_REG);     \r
                XPROGTarget_SendByte(PDI_RESET_KEY);\r
 \r

+               /* Lower direction change guard time to 0 USART bits */\r
+               XPROGTarget_SendByte(PDI_CMD_STCS | PDI_CTRL_REG);      \r
+               XPROGTarget_SendByte(0x07);\r
+\r

                /* Enable access to the XPROG NVM bus by sending the documented NVM access key to the device */\r
                XPROGTarget_SendByte(PDI_CMD_KEY);      \r
                for (uint8_t i = sizeof(PDI_NVMENABLE_KEY); i > 0; i--)\r
                /* Enable access to the XPROG NVM bus by sending the documented NVM access key to the device */\r
                XPROGTarget_SendByte(PDI_CMD_KEY);      \r
                for (uint8_t i = sizeof(PDI_NVMENABLE_KEY); i > 0; i--)\r


@@ -134,10 +140,13 @@ static void XPROGProtocol_EnterXPROGMode(void)
        }\r
        else\r
        {\r
        }\r
        else\r
        {\r

-       #if 0\r

                /* Enable TPI programming mode with the attached target */\r
                XPROGTarget_EnableTargetTPI();\r
                \r
                /* Enable TPI programming mode with the attached target */\r
                XPROGTarget_EnableTargetTPI();\r
                \r

+               /* Lower direction change guard time to 0 USART bits */\r
+               XPROGTarget_SendByte(TPI_CMD_SSTCS | TPI_CTRL_REG);\r
+               XPROGTarget_SendByte(0x07);\r
+               \r

                /* Enable access to the XPROG NVM bus by sending the documented NVM access key to the device */\r
                XPROGTarget_SendByte(TPI_CMD_SKEY);     \r
                for (uint8_t i = sizeof(TPI_NVMENABLE_KEY); i > 0; i--)\r
                /* Enable access to the XPROG NVM bus by sending the documented NVM access key to the device */\r
                XPROGTarget_SendByte(TPI_CMD_SKEY);     \r
                for (uint8_t i = sizeof(TPI_NVMENABLE_KEY); i > 0; i--)\r


@@ -145,8 +154,6 @@ static void XPROGProtocol_EnterXPROGMode(void)
 \r
                /* Wait until the NVM bus becomes active */\r
                NVMBusEnabled = TINYNVM_WaitWhileNVMBusBusy();\r
 \r
                /* Wait until the NVM bus becomes active */\r
                NVMBusEnabled = TINYNVM_WaitWhileNVMBusBusy();\r

-       #endif\r
-               NVMBusEnabled = true;\r

        }\r
        \r
        Endpoint_Write_Byte(CMD_XPROG);\r
        }\r
        \r
        Endpoint_Write_Byte(CMD_XPROG);\r


@@ -161,18 +168,27 @@ static void XPROGProtocol_EnterXPROGMode(void)
 static void XPROGProtocol_LeaveXPROGMode(void)\r
 {\r
        Endpoint_ClearOUT();\r
 static void XPROGProtocol_LeaveXPROGMode(void)\r
 {\r
        Endpoint_ClearOUT();\r

+       Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);\r

        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
        \r
        if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)\r
        {\r
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
        \r
        if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)\r
        {\r

+               XMEGANVM_WaitWhileNVMBusBusy();\r
+\r

                /* Clear the RESET key in the RESET PDI register to allow the XMEGA to run */\r
                XPROGTarget_SendByte(PDI_CMD_STCS | PDI_RESET_REG);     \r
                XPROGTarget_SendByte(0x00);\r
 \r
                /* Clear the RESET key in the RESET PDI register to allow the XMEGA to run */\r
                XPROGTarget_SendByte(PDI_CMD_STCS | PDI_RESET_REG);     \r
                XPROGTarget_SendByte(0x00);\r
 \r

+               /* Do it twice to make sure it takes affect (silicon bug?) */\r
+               XPROGTarget_SendByte(PDI_CMD_STCS | PDI_RESET_REG);     \r
+               XPROGTarget_SendByte(0x00);\r
+\r

                XPROGTarget_DisableTargetPDI();\r
        }\r
        else\r
        {\r
                XPROGTarget_DisableTargetPDI();\r
        }\r
        else\r
        {\r

+               TINYNVM_WaitWhileNVMBusBusy();\r
+\r

                /* Clear the NVMEN bit in the TPI CONTROL register to disable TPI mode */\r
                XPROGTarget_SendByte(TPI_CMD_SSTCS | TPI_CTRL_REG);     \r
                XPROGTarget_SendByte(0x00);\r
                /* Clear the NVMEN bit in the TPI CONTROL register to disable TPI mode */\r
                XPROGTarget_SendByte(TPI_CMD_SSTCS | TPI_CTRL_REG);     \r
                XPROGTarget_SendByte(0x00);\r


@@ -197,33 +213,48 @@ static void XPROGProtocol_Erase(void)
                uint32_t Address;\r
        } Erase_XPROG_Params;\r
 \r
                uint32_t Address;\r
        } Erase_XPROG_Params;\r
 \r

-       Endpoint_Read_Stream_LE(&Erase_XPROG_Params, sizeof(Erase_XPROG_Params));\r
+       Endpoint_Read_Stream_LE(&Erase_XPROG_Params, sizeof(Erase_XPROG_Params), NO_STREAM_CALLBACK);\r

        Erase_XPROG_Params.Address = SwapEndian_32(Erase_XPROG_Params.Address);\r
 \r
        Endpoint_ClearOUT();\r
        Erase_XPROG_Params.Address = SwapEndian_32(Erase_XPROG_Params.Address);\r
 \r
        Endpoint_ClearOUT();\r

+       Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);\r

        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
        \r
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
        \r

-       uint8_t EraseCommand = XMEGA_NVM_CMD_NOOP;\r
-       \r
+       uint8_t EraseCommand;\r
+\r

        if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)\r
        if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)\r

-       {\r
+       {       \r

                /* Determine which NVM command to send to the device depending on the memory to erase */\r
                /* Determine which NVM command to send to the device depending on the memory to erase */\r

-               if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_CHIP)\r
-                 EraseCommand = XMEGA_NVM_CMD_CHIPERASE;\r
-               else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_APP)\r
-                 EraseCommand = XMEGA_NVM_CMD_ERASEAPPSEC;\r
-               else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_BOOT)\r
-                 EraseCommand = XMEGA_NVM_CMD_ERASEBOOTSEC;\r
-               else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_EEPROM)\r
-                 EraseCommand = XMEGA_NVM_CMD_ERASEEEPROM;\r
-               else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_APP_PAGE)\r
-                 EraseCommand = XMEGA_NVM_CMD_ERASEAPPSECPAGE;\r
-               else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_BOOT_PAGE)\r
-                 EraseCommand = XMEGA_NVM_CMD_ERASEBOOTSECPAGE;\r
-               else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_EEPROM_PAGE)\r
-                 EraseCommand = XMEGA_NVM_CMD_ERASEEEPROMPAGE;\r
-               else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_USERSIG)\r
-                 EraseCommand = XMEGA_NVM_CMD_ERASEUSERSIG;\r
+               switch (Erase_XPROG_Params.MemoryType)\r
+               {\r
+                       case XPRG_ERASE_CHIP:\r
+                               EraseCommand = XMEGA_NVM_CMD_CHIPERASE;\r
+                               break;\r
+                       case XPRG_ERASE_APP:\r
+                               EraseCommand = XMEGA_NVM_CMD_ERASEAPPSEC;\r
+                               break;\r
+                       case XPRG_ERASE_BOOT:\r
+                               EraseCommand = XMEGA_NVM_CMD_ERASEBOOTSEC;\r
+                               break;\r
+                       case XPRG_ERASE_EEPROM:\r
+                               EraseCommand = XMEGA_NVM_CMD_ERASEEEPROM;\r
+                               break;\r
+                       case XPRG_ERASE_APP_PAGE:\r
+                               EraseCommand = XMEGA_NVM_CMD_ERASEAPPSECPAGE;\r
+                               break;\r
+                       case XPRG_ERASE_BOOT_PAGE:\r
+                               EraseCommand = XMEGA_NVM_CMD_ERASEBOOTSECPAGE;\r
+                               break;\r
+                       case XPRG_ERASE_EEPROM_PAGE:\r
+                               EraseCommand = XMEGA_NVM_CMD_ERASEEEPROMPAGE;\r
+                               break;\r
+                       case XPRG_ERASE_USERSIG:\r
+                               EraseCommand = XMEGA_NVM_CMD_ERASEUSERSIG;\r
+                               break;\r
+                       default:\r
+                               EraseCommand = XMEGA_NVM_CMD_NOOP;\r
+                               break;\r
+               }\r

                \r
                /* Erase the target memory, indicate timeout if ocurred */\r
                if (!(XMEGANVM_EraseMemory(EraseCommand, Erase_XPROG_Params.Address)))\r
                \r
                /* Erase the target memory, indicate timeout if ocurred */\r
                if (!(XMEGANVM_EraseMemory(EraseCommand, Erase_XPROG_Params.Address)))\r


@@ -231,8 +262,13 @@ static void XPROGProtocol_Erase(void)
        }\r
        else\r
        {\r
        }\r
        else\r
        {\r

+               if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_CHIP)\r
+                 EraseCommand = TINY_NVM_CMD_CHIPERASE;\r
+               else\r
+                 EraseCommand = TINY_NVM_CMD_SECTIONERASE;\r
+       \r

                /* Erase the target memory, indicate timeout if ocurred */\r
                /* Erase the target memory, indicate timeout if ocurred */\r

-               if (!(TINYNVM_EraseMemory()))\r
+               if (!(TINYNVM_EraseMemory(EraseCommand, Erase_XPROG_Params.Address)))\r

                  ReturnStatus = XPRG_ERR_TIMEOUT;\r
        }\r
        \r
                  ReturnStatus = XPRG_ERR_TIMEOUT;\r
        }\r
        \r


@@ -257,51 +293,49 @@ static void XPROGProtocol_WriteMemory(void)
        } WriteMemory_XPROG_Params;\r
        \r
        Endpoint_Read_Stream_LE(&WriteMemory_XPROG_Params, (sizeof(WriteMemory_XPROG_Params) -\r
        } WriteMemory_XPROG_Params;\r
        \r
        Endpoint_Read_Stream_LE(&WriteMemory_XPROG_Params, (sizeof(WriteMemory_XPROG_Params) -\r

-                                                           sizeof(WriteMemory_XPROG_Params).ProgData));\r
+                                                           sizeof(WriteMemory_XPROG_Params).ProgData), NO_STREAM_CALLBACK);\r

        WriteMemory_XPROG_Params.Address = SwapEndian_32(WriteMemory_XPROG_Params.Address);\r
        WriteMemory_XPROG_Params.Length  = SwapEndian_16(WriteMemory_XPROG_Params.Length);\r
        WriteMemory_XPROG_Params.Address = SwapEndian_32(WriteMemory_XPROG_Params.Address);\r
        WriteMemory_XPROG_Params.Length  = SwapEndian_16(WriteMemory_XPROG_Params.Length);\r

-       Endpoint_Read_Stream_LE(&WriteMemory_XPROG_Params.ProgData, WriteMemory_XPROG_Params.Length);\r
+       Endpoint_Read_Stream_LE(&WriteMemory_XPROG_Params.ProgData, WriteMemory_XPROG_Params.Length, NO_STREAM_CALLBACK);\r

 \r
        Endpoint_ClearOUT();\r
 \r
        Endpoint_ClearOUT();\r

+       Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);\r

        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
 \r
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
 \r

-       /* Assume FLASH page programming by default, as it is the common case */\r
-       uint8_t WriteCommand     = XMEGA_NVM_CMD_WRITEFLASHPAGE;\r
-       uint8_t WriteBuffCommand = XMEGA_NVM_CMD_LOADFLASHPAGEBUFF;\r
-       uint8_t EraseBuffCommand = XMEGA_NVM_CMD_ERASEFLASHPAGEBUFF;\r
-       bool    PagedMemory      = true;\r
-\r

        if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)\r
        {\r
        if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)\r
        {\r

-               if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_APPL)\r
-               {\r
-                       WriteCommand     = XMEGA_NVM_CMD_WRITEAPPSECPAGE;\r
-               }\r
-               else if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_BOOT)\r
-               {\r
-                       WriteCommand     = XMEGA_NVM_CMD_WRITEBOOTSECPAGE;\r
-               }\r
-               else if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_EEPROM)\r
-               {\r
-                       WriteCommand     = XMEGA_NVM_CMD_WRITEEEPROMPAGE;\r
-                       WriteBuffCommand = XMEGA_NVM_CMD_LOADEEPROMPAGEBUFF;\r
-                       EraseBuffCommand = XMEGA_NVM_CMD_ERASEEEPROMPAGEBUFF;\r
-               }\r
-               else if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_USERSIG)\r
-               {\r
-                       /* User signature is paged, but needs us to manually indicate the mode bits since the host doesn't set them */\r
-                       WriteMemory_XPROG_Params.PageMode = (XPRG_PAGEMODE_ERASE | XPRG_PAGEMODE_WRITE);\r
-                       WriteCommand     = XMEGA_NVM_CMD_WRITEUSERSIG;\r
-               }\r
-               else if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_FUSE)\r
-               {\r
-                       WriteCommand     = XMEGA_NVM_CMD_WRITEFUSE;\r
-                       PagedMemory      = false;\r
-               }\r
-               else if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_LOCKBITS)\r
+               /* Assume FLASH page programming by default, as it is the common case */\r
+               uint8_t WriteCommand     = XMEGA_NVM_CMD_WRITEFLASHPAGE;\r
+               uint8_t WriteBuffCommand = XMEGA_NVM_CMD_LOADFLASHPAGEBUFF;\r
+               uint8_t EraseBuffCommand = XMEGA_NVM_CMD_ERASEFLASHPAGEBUFF;\r
+               bool    PagedMemory      = true;\r
+               \r
+               switch (WriteMemory_XPROG_Params.MemoryType)\r

                {\r
                {\r

-                       WriteCommand     = XMEGA_NVM_CMD_WRITELOCK;\r
-                       PagedMemory      = false;\r
+                       case XPRG_MEM_TYPE_APPL:\r
+                               WriteCommand     = XMEGA_NVM_CMD_WRITEAPPSECPAGE;\r
+                               break;\r
+                       case XPRG_MEM_TYPE_BOOT:\r
+                               WriteCommand     = XMEGA_NVM_CMD_WRITEBOOTSECPAGE;\r
+                               break;\r
+                       case XPRG_MEM_TYPE_EEPROM:\r
+                               WriteCommand     = XMEGA_NVM_CMD_WRITEEEPROMPAGE;\r
+                               WriteBuffCommand = XMEGA_NVM_CMD_LOADEEPROMPAGEBUFF;\r
+                               EraseBuffCommand = XMEGA_NVM_CMD_ERASEEEPROMPAGEBUFF;                   \r
+                               break;\r
+                       case XPRG_MEM_TYPE_USERSIG:\r
+                               /* User signature is paged, but needs us to manually indicate the mode bits since the host doesn't set them */\r
+                               WriteMemory_XPROG_Params.PageMode = (XPRG_PAGEMODE_ERASE | XPRG_PAGEMODE_WRITE);\r
+                               WriteCommand     = XMEGA_NVM_CMD_WRITEUSERSIG;\r
+                               break;\r
+                       case XPRG_MEM_TYPE_FUSE:\r
+                               WriteCommand     = XMEGA_NVM_CMD_WRITEFUSE;\r
+                               PagedMemory      = false;\r
+                               break;\r
+                       case XPRG_MEM_TYPE_LOCKBITS:\r
+                               WriteCommand     = XMEGA_NVM_CMD_WRITELOCK;\r
+                               PagedMemory      = false;\r
+                               break;\r

                }\r
                \r
                /* Send the appropriate memory write commands to the device, indicate timeout if occurred */\r
                }\r
                \r
                /* Send the appropriate memory write commands to the device, indicate timeout if occurred */\r


@@ -316,8 +350,6 @@ static void XPROGProtocol_WriteMemory(void)
        }\r
        else\r
        {\r
        }\r
        else\r
        {\r

-               Serial_TxByte((uint8_t)WriteMemory_XPROG_Params.Length);\r
-       \r

                /* Send write command to the TPI device, indicate timeout if occurred */\r
                if (!(TINYNVM_WriteMemory(WriteMemory_XPROG_Params.Address, WriteMemory_XPROG_Params.ProgData,\r
                      WriteMemory_XPROG_Params.Length)))\r
                /* Send write command to the TPI device, indicate timeout if occurred */\r
                if (!(TINYNVM_WriteMemory(WriteMemory_XPROG_Params.Address, WriteMemory_XPROG_Params.ProgData,\r
                      WriteMemory_XPROG_Params.Length)))\r


@@ -346,11 +378,12 @@ static void XPROGProtocol_ReadMemory(void)
                uint16_t Length;\r
        } ReadMemory_XPROG_Params;\r
        \r
                uint16_t Length;\r
        } ReadMemory_XPROG_Params;\r
        \r

-       Endpoint_Read_Stream_LE(&ReadMemory_XPROG_Params, sizeof(ReadMemory_XPROG_Params));\r
+       Endpoint_Read_Stream_LE(&ReadMemory_XPROG_Params, sizeof(ReadMemory_XPROG_Params), NO_STREAM_CALLBACK);\r

        ReadMemory_XPROG_Params.Address = SwapEndian_32(ReadMemory_XPROG_Params.Address);\r
        ReadMemory_XPROG_Params.Length  = SwapEndian_16(ReadMemory_XPROG_Params.Length);\r
 \r
        Endpoint_ClearOUT();\r
        ReadMemory_XPROG_Params.Address = SwapEndian_32(ReadMemory_XPROG_Params.Address);\r
        ReadMemory_XPROG_Params.Length  = SwapEndian_16(ReadMemory_XPROG_Params.Length);\r
 \r
        Endpoint_ClearOUT();\r

+       Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);\r

        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
 \r
        uint8_t ReadBuffer[256];\r
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
 \r
        uint8_t ReadBuffer[256];\r


@@ -363,8 +396,6 @@ static void XPROGProtocol_ReadMemory(void)
        }\r
        else\r
        {\r
        }\r
        else\r
        {\r

-               Serial_TxByte((uint8_t)ReadMemory_XPROG_Params.Length);\r
-\r

                /* Read the TPI target's memory, indicate timeout if occurred */\r
                if (!(TINYNVM_ReadMemory(ReadMemory_XPROG_Params.Address, ReadBuffer, ReadMemory_XPROG_Params.Length)))\r
                  ReturnStatus = XPRG_ERR_TIMEOUT;\r
                /* Read the TPI target's memory, indicate timeout if occurred */\r
                if (!(TINYNVM_ReadMemory(ReadMemory_XPROG_Params.Address, ReadBuffer, ReadMemory_XPROG_Params.Length)))\r
                  ReturnStatus = XPRG_ERR_TIMEOUT;\r


@@ -375,7 +406,7 @@ static void XPROGProtocol_ReadMemory(void)
        Endpoint_Write_Byte(ReturnStatus);\r
        \r
        if (ReturnStatus == XPRG_ERR_OK)\r
        Endpoint_Write_Byte(ReturnStatus);\r
        \r
        if (ReturnStatus == XPRG_ERR_OK)\r

-         Endpoint_Write_Stream_LE(ReadBuffer, ReadMemory_XPROG_Params.Length);\r
+         Endpoint_Write_Stream_LE(ReadBuffer, ReadMemory_XPROG_Params.Length, NO_STREAM_CALLBACK);\r

        \r
        Endpoint_ClearIN();\r
 }\r
        \r
        Endpoint_ClearIN();\r
 }\r


@@ -392,22 +423,31 @@ static void XPROGProtocol_ReadCRC(void)
                uint8_t CRCType;\r
        } ReadCRC_XPROG_Params;\r
        \r
                uint8_t CRCType;\r
        } ReadCRC_XPROG_Params;\r
        \r

-       Endpoint_Read_Stream_LE(&ReadCRC_XPROG_Params, sizeof(ReadCRC_XPROG_Params));\r
+       Endpoint_Read_Stream_LE(&ReadCRC_XPROG_Params, sizeof(ReadCRC_XPROG_Params), NO_STREAM_CALLBACK);\r
+\r

        Endpoint_ClearOUT();\r
        Endpoint_ClearOUT();\r

+       Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);\r

        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
        \r
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
        \r

-       uint8_t  CRCCommand = XMEGA_NVM_CMD_NOOP;\r

        uint32_t MemoryCRC;\r
 \r
        if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)\r
        {\r
        uint32_t MemoryCRC;\r
 \r
        if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)\r
        {\r

+               uint8_t CRCCommand;\r
+\r

                /* Determine which NVM command to send to the device depending on the memory to CRC */\r
                /* Determine which NVM command to send to the device depending on the memory to CRC */\r

-               if (ReadCRC_XPROG_Params.CRCType == XPRG_CRC_APP)\r
-                 CRCCommand = XMEGA_NVM_CMD_APPCRC;\r
-               else if (ReadCRC_XPROG_Params.CRCType == XPRG_CRC_BOOT)\r
-                 CRCCommand = XMEGA_NVM_CMD_BOOTCRC;\r
-               else\r
-                 CRCCommand = XMEGA_NVM_CMD_FLASHCRC;\r
+               switch (ReadCRC_XPROG_Params.CRCType)\r
+               {\r
+                       case XPRG_CRC_APP:\r
+                               CRCCommand = XMEGA_NVM_CMD_APPCRC;\r
+                               break;\r
+                       case XPRG_CRC_BOOT:\r
+                               CRCCommand = XMEGA_NVM_CMD_BOOTCRC;\r
+                               break;\r
+                       default:\r
+                               CRCCommand = XMEGA_NVM_CMD_FLASHCRC;\r
+                               break;\r
+               }\r

                \r
                /* Perform and retrieve the memory CRC, indicate timeout if occurred */\r
                if (!(XMEGANVM_GetMemoryCRC(CRCCommand, &MemoryCRC)))\r
                \r
                /* Perform and retrieve the memory CRC, indicate timeout if occurred */\r
                if (!(XMEGANVM_GetMemoryCRC(CRCCommand, &MemoryCRC)))\r


@@ -450,10 +490,10 @@ static void XPROGProtocol_SetParam(void)
                case XPRG_PARAM_EEPPAGESIZE:\r
                        XPROG_Param_EEPageSize = Endpoint_Read_Word_BE();\r
                        break;\r
                case XPRG_PARAM_EEPPAGESIZE:\r
                        XPROG_Param_EEPageSize = Endpoint_Read_Word_BE();\r
                        break;\r

-               case XPRG_PARAM_NVMCMD:\r
+               case XPRG_PARAM_NVMCMD_REG:\r

                        XPROG_Param_NVMCMDRegAddr = Endpoint_Read_Byte();\r
                        break;\r
                        XPROG_Param_NVMCMDRegAddr = Endpoint_Read_Byte();\r
                        break;\r

-               case XPRG_PARAM_NVMCSR:\r
+               case XPRG_PARAM_NVMCSR_REG:\r

                        XPROG_Param_NVMCSRRegAddr = Endpoint_Read_Byte();\r
                        break;\r
                default:\r
                        XPROG_Param_NVMCSRRegAddr = Endpoint_Read_Byte();\r
                        break;\r
                default:\r


@@ -462,6 +502,7 @@ static void XPROGProtocol_SetParam(void)
        }\r
 \r
        Endpoint_ClearOUT();\r
        }\r
 \r
        Endpoint_ClearOUT();\r

+       Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);\r

        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
                  \r
        Endpoint_Write_Byte(CMD_XPROG);\r
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
                  \r
        Endpoint_Write_Byte(CMD_XPROG);\r