projects / pub / USBasp.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Cleanups to the MassStorage Device demos, and the MassStorage Device Class driver.
[pub/USBasp.git] / Projects / AVRISP / Lib / V2Protocol.c
diff --git a/Projects/AVRISP/Lib/V2Protocol.c b/Projects/AVRISP/Lib/V2Protocol.c
index 304eef4..d03bd89 100644 (file)
--- a/Projects/AVRISP/Lib/V2Protocol.c
+++ b/Projects/AVRISP/Lib/V2Protocol.c
@@ -36,126 +36,584 @@
 #define  INCLUDE_FROM_V2PROTOCOL_C\r
 #include "V2Protocol.h"\r
 \r
 #define  INCLUDE_FROM_V2PROTOCOL_C\r
 #include "V2Protocol.h"\r
 \r
-ParameterItem_t ParameterTable[] EEMEM = \r
-       {\r
-               { .ParameterID    = PARAM_BUILD_NUMBER_LOW,\r
-                 .ParameterValue = 0x00                    },\r
-               { .ParameterID    = PARAM_BUILD_NUMBER_HIGH,\r
-                 .ParameterValue = 0x00                    },\r
-               { .ParameterID    = PARAM_HW_VER,\r
-                 .ParameterValue = 0x01                    },\r
-               { .ParameterID    = PARAM_SW_MAJOR,\r
-                 .ParameterValue = 0x01                    },\r
-               { .ParameterID    = PARAM_SW_MINOR,\r
-                 .ParameterValue = 0x00                    },\r
-               { .ParameterID    = PARAM_VTARGET,\r
-                 .ParameterValue = 0x00                    },\r
-               { .ParameterID    = PARAM_SCK_DURATION,\r
-                 .ParameterValue = 0x00                    },\r
-               { .ParameterID    = PARAM_RESET_POLARITY,\r
-                 .ParameterValue = 0x00                    },\r
-               { .ParameterID    = PARAM_STATUS_TGT_CONN,\r
-                 .ParameterValue = 0x00                    },\r
-               { .ParameterID    = PARAM_DISCHARGEDELAY,\r
-                 .ParameterValue = 0x00                    },\r
-       };\r
-
-void V2Protocol_ProcessCommand(void)
-{
+/** Master V2 Protocol packet handler, for received V2 Protocol packets from a connected host.\r
+ *  This routine decodes the issued command and passes off the handling of the command to the\r
+ *  appropriate function.\r
+ */\r
+void V2Protocol_ProcessCommand(void)\r
+{\r
        uint8_t V2Command = Endpoint_Read_Byte();\r
                  \r
        uint8_t V2Command = Endpoint_Read_Byte();\r
                  \r
-       printf("COMMAND %d\r\n", V2Command);\r
-\r
        switch (V2Command)\r
        {\r
                case CMD_SIGN_ON:\r
        switch (V2Command)\r
        {\r
                case CMD_SIGN_ON:\r
-                       V2Protocol_ProcessCmdSignOn();\r
+                       V2Protocol_Command_SignOn();\r
                        break;\r
                case CMD_SET_PARAMETER:\r
                        break;\r
                case CMD_SET_PARAMETER:\r
-                       V2Protocol_ProcessCmdSetParam();\r
-                       break;\r
                case CMD_GET_PARAMETER:\r
                case CMD_GET_PARAMETER:\r
-                       V2Protocol_ProcessCmdGetParam();\r
+                       V2Protocol_Command_GetSetParam(V2Command);\r
+                       break;\r
+               case CMD_LOAD_ADDRESS:\r
+                       V2Protocol_Command_LoadAddress();\r
+                       break;\r
+               case CMD_RESET_PROTECTION:\r
+                       V2Protocol_Command_ResetProtection();\r
+                       break;\r
+               case CMD_ENTER_PROGMODE_ISP:\r
+                       V2Protocol_Command_EnterISPMode();\r
+                       break;\r
+               case CMD_LEAVE_PROGMODE_ISP:\r
+                       V2Protocol_Command_LeaveISPMode();\r
+                       break;\r
+               case CMD_PROGRAM_FLASH_ISP:\r
+               case CMD_PROGRAM_EEPROM_ISP:\r
+                       V2Protocol_Command_ProgramMemory(V2Command);                    \r
+                       break;\r
+               case CMD_READ_FLASH_ISP:\r
+               case CMD_READ_EEPROM_ISP:\r
+                       V2Protocol_Command_ReadMemory(V2Command);\r
+                       break;\r
+               case CMD_CHIP_ERASE_ISP:\r
+                       V2Protocol_Command_ChipErase();\r
+                       break;\r
+               case CMD_READ_FUSE_ISP:\r
+               case CMD_READ_LOCK_ISP:\r
+               case CMD_READ_SIGNATURE_ISP:\r
+               case CMD_READ_OSCCAL_ISP:\r
+                       V2Protocol_Command_ReadFuseLockSigOSCCAL(V2Command);\r
+                       break;\r
+               case CMD_PROGRAM_FUSE_ISP:\r
+               case CMD_PROGRAM_LOCK_ISP:\r
+                       V2Protocol_Command_WriteFuseLock(V2Command);\r
+                       break;\r
+               case CMD_SPI_MULTI:\r
+                       V2Protocol_Command_SPIMulti();\r
                        break;\r
                default:\r
                        break;\r
                default:\r
-                       Endpoint_ClearOUT();\r
-                       Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
-                       Endpoint_Write_Byte(STATUS_CMD_UNKNOWN);\r
-                       Endpoint_ClearIN();\r
+                       V2Protocol_Command_Unknown(V2Command);\r
                        break;\r
        }\r
        \r
                        break;\r
        }\r
        \r
-       /* Reset Endpoint direction to OUT ready for next command */\r
-       Endpoint_SetEndpointDirection(ENDPOINT_DIR_OUT);        
+       Endpoint_WaitUntilReady();\r
+       Endpoint_SetEndpointDirection(ENDPOINT_DIR_OUT);\r
 }\r
 \r
 }\r
 \r
-static ParameterItem_t* V2Protocol_GetParameterItem(uint8_t ParamID)\r
+/** Handler for unknown V2 protocol commands. This discards all sent data and returns a\r
+ *  STATUS_CMD_UNKNOWN status back to the host.\r
+ *\r
+ *  \param[in] V2Command  Issued V2 Protocol command byte from the host\r
+ */\r
+static void V2Protocol_Command_Unknown(uint8_t V2Command)\r
 {\r
 {\r
-       for (uint8_t TableIndex = 0; TableIndex < (sizeof(ParameterTable) / sizeof(ParameterTable[0])); TableIndex++)\r
+       /* Discard all incoming data */\r
+       while (Endpoint_BytesInEndpoint() == AVRISP_DATA_EPSIZE)\r
        {\r
        {\r
-               if (ParamID == eeprom_read_byte(&ParameterTable[TableIndex].ParameterID))\r
-                 return &ParameterTable[TableIndex];\r
+               Endpoint_ClearOUT();\r
+               Endpoint_WaitUntilReady();\r
        }\r
        }\r
+\r
+       Endpoint_ClearOUT();\r
+       Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
+\r
+       Endpoint_Write_Byte(V2Command);\r
+       Endpoint_Write_Byte(STATUS_CMD_UNKNOWN);\r
+       Endpoint_ClearIN();\r
+}\r
+\r
+/** Handler for the CMD_SIGN_ON command, returning the programmer ID string to the host. */\r
+static void V2Protocol_Command_SignOn(void)\r
+{\r
+       Endpoint_ClearOUT();\r
+       Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
+\r
+       Endpoint_Write_Byte(CMD_SIGN_ON);\r
+       Endpoint_Write_Byte(STATUS_CMD_OK);\r
+       Endpoint_Write_Byte(sizeof(PROGRAMMER_ID) - 1);\r
+       Endpoint_Write_Stream_LE(PROGRAMMER_ID, (sizeof(PROGRAMMER_ID) - 1));\r
+       Endpoint_ClearIN();\r
+}\r
+\r
+/** Handler for the CMD_SET_PARAMETER and CMD_GET_PARAMETER commands from the host, setting or\r
+ *  getting a device parameter's value from the parameter table.\r
+ *\r
+ *  \param[in] V2Command  Issued V2 Protocol command byte from the host\r
+ */\r
+static void V2Protocol_Command_GetSetParam(uint8_t V2Command)\r
+{\r
+       uint8_t ParamID = Endpoint_Read_Byte();\r
+       uint8_t ParamValue;\r
        \r
        \r
-       return NULL;\r
-}
-
-static void V2Protocol_ProcessCmdSignOn(void)\r
+       if (V2Command == CMD_SET_PARAMETER)\r
+         ParamValue = Endpoint_Read_Byte();\r
+\r
+       Endpoint_ClearOUT();\r
+       Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
+       \r
+       Endpoint_Write_Byte(V2Command);\r
+       \r
+       uint8_t ParamPrivs = V2Params_GetParameterPrivileges(ParamID);\r
+       \r
+       if ((V2Command == CMD_SET_PARAMETER) && (ParamPrivs & PARAM_PRIV_WRITE))\r
+       {\r
+               Endpoint_Write_Byte(STATUS_CMD_OK);\r
+               V2Params_SetParameterValue(ParamID, ParamValue);\r
+       }\r
+       else if ((V2Command == CMD_GET_PARAMETER) && (ParamPrivs & PARAM_PRIV_READ))\r
+       {\r
+               Endpoint_Write_Byte(STATUS_CMD_OK);\r
+               Endpoint_Write_Byte(V2Params_GetParameterValue(ParamID));\r
+       }\r
+       else\r
+       {       \r
+               Endpoint_Write_Byte(STATUS_CMD_FAILED);\r
+       }\r
+\r
+       Endpoint_ClearIN();\r
+}\r
+\r
+/** Handler for the CMD_LOAD_ADDRESS command, loading the given device address into a\r
+ *  global storage variable for later use, and issuing LOAD EXTENDED ADDRESS commands\r
+ *  to the attached device as required.\r
+ */\r
+static void V2Protocol_Command_LoadAddress(void)\r
 {\r
 {\r
+       Endpoint_Read_Stream_BE(&CurrentAddress, sizeof(CurrentAddress));\r
+\r
        Endpoint_ClearOUT();\r
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
        \r
        Endpoint_ClearOUT();\r
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
        \r
-       Endpoint_Write_Byte(CMD_SIGN_ON);\r
+       if (CurrentAddress & (1UL << 31))\r
+         V2Protocol_LoadExtendedAddress();\r
+\r
+       Endpoint_Write_Byte(CMD_LOAD_ADDRESS);\r
        Endpoint_Write_Byte(STATUS_CMD_OK);\r
        Endpoint_Write_Byte(STATUS_CMD_OK);\r
-       Endpoint_Write_Byte(PROGRAMMER_ID_LEN);\r
-       Endpoint_Write_Stream_LE(PROGRAMMER_ID, PROGRAMMER_ID_LEN);\r
        Endpoint_ClearIN();\r
 }\r
 \r
        Endpoint_ClearIN();\r
 }\r
 \r
-static void V2Protocol_ProcessCmdSetParam(void)\r
+/** Handler for the CMD_RESET_PROTECTION command, currently implemented as a dummy ACK function\r
+ *  as no ISP short-circuit protection is currently implemented.\r
+ */\r
+static void V2Protocol_Command_ResetProtection(void)\r
 {\r
 {\r
-       uint8_t ParamID    = Endpoint_Read_Byte();\r
-       uint8_t ParamValue = Endpoint_Read_Byte();\r
+       Endpoint_ClearOUT();\r
+       Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
+       \r
+       Endpoint_Write_Byte(CMD_RESET_PROTECTION);\r
+       Endpoint_Write_Byte(STATUS_CMD_OK);\r
+       Endpoint_ClearIN();     \r
+}\r
 \r
 \r
-       ParameterItem_t* ParameterItem = V2Protocol_GetParameterItem(ParamID);\r
+/** Handler for the CMD_ENTER_PROGMODE_ISP command, which attempts to enter programming mode on\r
+ *  the attached device, returning success or failure back to the host.\r
+ */\r
+static void V2Protocol_Command_EnterISPMode(void)\r
+{\r
+       struct\r
+       {\r
+               uint8_t TimeoutMS;\r
+               uint8_t PinStabDelayMS;\r
+               uint8_t ExecutionDelayMS;\r
+               uint8_t SynchLoops;\r
+               uint8_t ByteDelay;\r
+               uint8_t PollValue;\r
+               uint8_t PollIndex;\r
+               uint8_t EnterProgBytes[4];\r
+       } Enter_ISP_Params;\r
        \r
        \r
+       Endpoint_Read_Stream_LE(&Enter_ISP_Params, sizeof(Enter_ISP_Params));\r
+\r
        Endpoint_ClearOUT();\r
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
 \r
        Endpoint_ClearOUT();\r
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
 \r
-       if (ParameterItem != NULL)\r
+       uint8_t ResponseStatus = STATUS_CMD_FAILED;\r
+       \r
+       CurrentAddress = 0;\r
+\r
+       V2Protocol_DelayMS(Enter_ISP_Params.ExecutionDelayMS);    \r
+       SPI_Init(V2Protocol_GetSPIPrescalerMask() | SPI_SCK_LEAD_RISING | SPI_SAMPLE_LEADING | SPI_MODE_MASTER);\r
+               \r
+       while (Enter_ISP_Params.SynchLoops-- && (ResponseStatus == STATUS_CMD_FAILED))\r
        {\r
        {\r
-               eeprom_write_byte(&ParameterItem->ParameterValue, ParamValue);\r
+               uint8_t ResponseBytes[4];\r
+\r
+               V2Protocol_ChangeTargetResetLine(true);\r
+               V2Protocol_DelayMS(Enter_ISP_Params.PinStabDelayMS);\r
 \r
 \r
-               Endpoint_Write_Byte(CMD_SET_PARAMETER);\r
-               Endpoint_Write_Byte(STATUS_CMD_OK);     \r
+               for (uint8_t RByte = 0; RByte < sizeof(ResponseBytes); RByte++)\r
+               {\r
+                       V2Protocol_DelayMS(Enter_ISP_Params.ByteDelay);\r
+                       ResponseBytes[RByte] = SPI_TransferByte(Enter_ISP_Params.EnterProgBytes[RByte]);\r
+               }\r
+               \r
+               /* Check if polling disabled, or if the polled value matches the expected value */\r
+               if (!(Enter_ISP_Params.PollIndex) || (ResponseBytes[Enter_ISP_Params.PollIndex - 1] == Enter_ISP_Params.PollValue))\r
+               {\r
+                       ResponseStatus = STATUS_CMD_OK;\r
+               }\r
+               else\r
+               {\r
+                       V2Protocol_ChangeTargetResetLine(false);\r
+                       V2Protocol_DelayMS(Enter_ISP_Params.PinStabDelayMS);\r
+               }\r
        }\r
        }\r
-       else\r
+\r
+       Endpoint_Write_Byte(CMD_ENTER_PROGMODE_ISP);\r
+       Endpoint_Write_Byte(ResponseStatus);\r
+       Endpoint_ClearIN();\r
+}\r
+\r
+/** Handler for the CMD_LEAVE_ISP command, which releases the target from programming mode. */\r
+static void V2Protocol_Command_LeaveISPMode(void)\r
+{\r
+       struct\r
+       {\r
+               uint8_t PreDelayMS;\r
+               uint8_t PostDelayMS;\r
+       } Leave_ISP_Params;\r
+\r
+       Endpoint_Read_Stream_LE(&Leave_ISP_Params, sizeof(Leave_ISP_Params));\r
+       \r
+       Endpoint_ClearOUT();\r
+       Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
+\r
+       V2Protocol_DelayMS(Leave_ISP_Params.PreDelayMS);\r
+       V2Protocol_ChangeTargetResetLine(false);\r
+       SPI_ShutDown();\r
+       V2Protocol_DelayMS(Leave_ISP_Params.PostDelayMS);\r
+\r
+       Endpoint_Write_Byte(CMD_LEAVE_PROGMODE_ISP);\r
+       Endpoint_Write_Byte(STATUS_CMD_OK);\r
+       Endpoint_ClearIN();\r
+}\r
+\r
+/** Handler for the CMD_PROGRAM_FLASH_ISP and CMD_PROGRAM_EEPROM_ISP commands, writing out bytes,\r
+ *  words or pages of data to the attached device.\r
+ *\r
+ *  \param[in] V2Command  Issued V2 Protocol command byte from the host\r
+ */\r
+static void V2Protocol_Command_ProgramMemory(uint8_t V2Command)\r
+{\r
+       struct\r
+       {\r
+               uint16_t BytesToWrite;\r
+               uint8_t  ProgrammingMode;\r
+               uint8_t  DelayMS;\r
+               uint8_t  ProgrammingCommands[3];\r
+               uint8_t  PollValue1;\r
+               uint8_t  PollValue2;\r
+               uint8_t  ProgData[256]; // Note, the Jungo driver has a very short ACK timeout period, need to buffer the\r
+       } Write_Memory_Params;      // whole page and ACK the packet as fast as possible to prevent it from aborting\r
+       \r
+       Endpoint_Read_Stream_LE(&Write_Memory_Params, sizeof(Write_Memory_Params) - sizeof(Write_Memory_Params.ProgData));\r
+       Write_Memory_Params.BytesToWrite = SwapEndian_16(Write_Memory_Params.BytesToWrite);\r
+       \r
+       if (Write_Memory_Params.BytesToWrite > sizeof(Write_Memory_Params.ProgData))\r
        {\r
        {\r
+               Endpoint_ClearOUT();\r
+               Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
+\r
+               Endpoint_Write_Byte(V2Command);\r
                Endpoint_Write_Byte(STATUS_CMD_FAILED);\r
                Endpoint_Write_Byte(STATUS_CMD_FAILED);\r
+               Endpoint_ClearIN();\r
+               return;\r
+       }\r
+       \r
+       Endpoint_Read_Stream_LE(&Write_Memory_Params.ProgData, Write_Memory_Params.BytesToWrite);\r
+\r
+       Endpoint_ClearOUT();\r
+       Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
+\r
+       uint8_t  ProgrammingStatus = STATUS_CMD_OK;     \r
+       uint16_t PollAddress       = 0;\r
+       uint8_t  PollValue         = (V2Command == CMD_PROGRAM_FLASH_ISP) ? Write_Memory_Params.PollValue1 :\r
+                                                                           Write_Memory_Params.PollValue2;\r
+       uint8_t* NextWriteByte = Write_Memory_Params.ProgData;\r
+\r
+       if (Write_Memory_Params.ProgrammingMode & PROG_MODE_PAGED_WRITES_MASK)\r
+       {\r
+               uint16_t StartAddress = (CurrentAddress & 0xFFFF);\r
+       \r
+               /* Paged mode memory programming */\r
+               for (uint16_t CurrentByte = 0; CurrentByte < Write_Memory_Params.BytesToWrite; CurrentByte++)\r
+               {\r
+                       bool    IsOddByte   = (CurrentByte & 0x01);\r
+                       uint8_t ByteToWrite = *(NextWriteByte++);\r
+               \r
+                       if (IsOddByte && (V2Command == CMD_PROGRAM_FLASH_ISP))\r
+                         Write_Memory_Params.ProgrammingCommands[0] |=  READ_WRITE_HIGH_BYTE_MASK;\r
+                       else\r
+                         Write_Memory_Params.ProgrammingCommands[0] &= ~READ_WRITE_HIGH_BYTE_MASK;\r
+                         \r
+                       SPI_SendByte(Write_Memory_Params.ProgrammingCommands[0]);\r
+                       SPI_SendByte(CurrentAddress >> 8);\r
+                       SPI_SendByte(CurrentAddress & 0xFF);\r
+                       SPI_SendByte(ByteToWrite);\r
+                       \r
+                       if (!(PollAddress) && (ByteToWrite != PollValue))\r
+                       {\r
+                               if (IsOddByte && (V2Command == CMD_PROGRAM_FLASH_ISP))\r
+                                 Write_Memory_Params.ProgrammingCommands[2] |= READ_WRITE_HIGH_BYTE_MASK;\r
+                                 \r
+                               PollAddress = (CurrentAddress & 0xFFFF);                                \r
+                       }               \r
+\r
+                       if (IsOddByte || (V2Command == CMD_PROGRAM_EEPROM_ISP))\r
+                         CurrentAddress++;\r
+               }\r
+               \r
+               /* If the current page must be committed, send the PROGRAM PAGE command to the target */\r
+               if (Write_Memory_Params.ProgrammingMode & PROG_MODE_COMMIT_PAGE_MASK)\r
+               {\r
+                       SPI_SendByte(Write_Memory_Params.ProgrammingCommands[1]);\r
+                       SPI_SendByte(StartAddress >> 8);\r
+                       SPI_SendByte(StartAddress & 0xFF);\r
+                       SPI_SendByte(0x00);\r
+                       \r
+                       /* Check if polling is possible, if not switch to timed delay mode */\r
+                       if (!(PollAddress))\r
+                       {\r
+                               Write_Memory_Params.ProgrammingMode &= ~PROG_MODE_PAGED_VALUE_MASK;\r
+                               Write_Memory_Params.ProgrammingMode |=  PROG_MODE_PAGED_TIMEDELAY_MASK;                         \r
+                       }\r
+\r
+                       ProgrammingStatus = V2Protocol_WaitForProgComplete(Write_Memory_Params.ProgrammingMode, PollAddress, PollValue,\r
+                                                                                                                          Write_Memory_Params.DelayMS, Write_Memory_Params.ProgrammingCommands[2]);\r
+               }\r
+       }\r
+       else\r
+       {\r
+               /* Word/byte mode memory programming */\r
+               for (uint16_t CurrentByte = 0; CurrentByte < Write_Memory_Params.BytesToWrite; CurrentByte++)\r
+               {\r
+                       bool    IsOddByte   = (CurrentByte & 0x01);\r
+                       uint8_t ByteToWrite = *(NextWriteByte++);\r
+               \r
+                       if (IsOddByte && (V2Command == CMD_READ_FLASH_ISP))\r
+                         Write_Memory_Params.ProgrammingCommands[0] |=  READ_WRITE_HIGH_BYTE_MASK;\r
+                       else\r
+                         Write_Memory_Params.ProgrammingCommands[0] &= ~READ_WRITE_HIGH_BYTE_MASK;                     \r
+                         \r
+                       SPI_SendByte(Write_Memory_Params.ProgrammingCommands[0]);\r
+                       SPI_SendByte(CurrentAddress >> 8);\r
+                       SPI_SendByte(CurrentAddress & 0xFF);\r
+                       SPI_SendByte(ByteToWrite);\r
+                       \r
+                       if (ByteToWrite != PollValue)\r
+                       {\r
+                               if (IsOddByte && (V2Command == CMD_PROGRAM_FLASH_ISP))\r
+                                 Write_Memory_Params.ProgrammingCommands[2] |= READ_WRITE_HIGH_BYTE_MASK;\r
+                                 \r
+                               PollAddress = (CurrentAddress & 0xFFFF);\r
+                       }\r
+\r
+                       if (IsOddByte || (V2Command == CMD_PROGRAM_EEPROM_ISP))\r
+                         CurrentAddress++;\r
+                       \r
+                       ProgrammingStatus = V2Protocol_WaitForProgComplete(Write_Memory_Params.ProgrammingMode, PollAddress, PollValue,\r
+                                                                          Write_Memory_Params.DelayMS, Write_Memory_Params.ProgrammingCommands[2]);\r
+                         \r
+                       if (ProgrammingStatus != STATUS_CMD_OK)\r
+                         break;\r
+               }\r
        }\r
 \r
        }\r
 \r
+       Endpoint_Write_Byte(V2Command);\r
+       Endpoint_Write_Byte(ProgrammingStatus);\r
        Endpoint_ClearIN();\r
 }\r
 \r
        Endpoint_ClearIN();\r
 }\r
 \r
-static void V2Protocol_ProcessCmdGetParam(void)\r
+/** Handler for the CMD_READ_FLASH_ISP and CMD_READ_EEPROM_ISP commands, reading in bytes,\r
+ *  words or pages of data from the attached device.\r
+ *\r
+ *  \param[in] V2Command  Issued V2 Protocol command byte from the host\r
+ */\r
+static void V2Protocol_Command_ReadMemory(uint8_t V2Command)\r
 {\r
 {\r
-       uint8_t ParamID    = Endpoint_Read_Byte();\r
-\r
-       ParameterItem_t* ParameterItem = V2Protocol_GetParameterItem(ParamID);\r
+       struct\r
+       {\r
+               uint16_t BytesToRead;\r
+               uint8_t  ReadMemoryCommand;\r
+       } Read_Memory_Params;\r
+       \r
+       Endpoint_Read_Stream_LE(&Read_Memory_Params, sizeof(Read_Memory_Params));\r
+       Read_Memory_Params.BytesToRead = SwapEndian_16(Read_Memory_Params.BytesToRead);\r
        \r
        Endpoint_ClearOUT();\r
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
        \r
        Endpoint_ClearOUT();\r
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
+       \r
+       Endpoint_Write_Byte(V2Command);\r
+       Endpoint_Write_Byte(STATUS_CMD_OK);\r
+       \r
+       for (uint16_t CurrentByte = 0; CurrentByte < Read_Memory_Params.BytesToRead; CurrentByte++)\r
+       {\r
+               bool IsOddByte = (CurrentByte & 0x01);\r
+\r
+               if (IsOddByte && (V2Command == CMD_READ_FLASH_ISP))\r
+                 Read_Memory_Params.ReadMemoryCommand |=  READ_WRITE_HIGH_BYTE_MASK;\r
+               else\r
+                 Read_Memory_Params.ReadMemoryCommand &= ~READ_WRITE_HIGH_BYTE_MASK;\r
+\r
+               SPI_SendByte(Read_Memory_Params.ReadMemoryCommand);\r
+               SPI_SendByte(CurrentAddress >> 8);\r
+               SPI_SendByte(CurrentAddress & 0xFF);\r
+               Endpoint_Write_Byte(SPI_ReceiveByte());\r
+               \r
+               /* Check if the endpoint bank is currently full */\r
+               if (!(Endpoint_IsReadWriteAllowed()))\r
+               {\r
+                       Endpoint_ClearIN();\r
+                       Endpoint_WaitUntilReady();\r
+               }\r
+               \r
+               if ((IsOddByte && (V2Command == CMD_READ_FLASH_ISP)) || (V2Command == CMD_READ_EEPROM_ISP))\r
+                 CurrentAddress++;\r
+       }\r
+\r
+       Endpoint_Write_Byte(STATUS_CMD_OK);\r
 \r
 \r
-       if (ParameterItem != NULL)\r
+       bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());\r
+       Endpoint_ClearIN();\r
+       \r
+       /* Ensure last packet is a short packet to terminate the transfer */\r
+       if (IsEndpointFull)\r
        {\r
        {\r
-               Endpoint_Write_Byte(CMD_GET_PARAMETER);\r
-               Endpoint_Write_Byte(STATUS_CMD_OK);\r
-               Endpoint_Write_Byte(eeprom_read_byte(&ParameterItem->ParameterValue));  \r
+               Endpoint_WaitUntilReady();      \r
+               Endpoint_ClearIN();\r
+               Endpoint_WaitUntilReady();      \r
        }\r
        }\r
+}\r
+\r
+/** Handler for the CMD_CHI_ERASE_ISP command, clearing the target's FLASH memory. */\r
+static void V2Protocol_Command_ChipErase(void)\r
+{\r
+       struct\r
+       {\r
+               uint8_t EraseDelayMS;\r
+               uint8_t PollMethod;\r
+               uint8_t EraseCommandBytes[4];\r
+       } Erase_Chip_Params;\r
+       \r
+       Endpoint_Read_Stream_LE(&Erase_Chip_Params, sizeof(Erase_Chip_Params));\r
+       \r
+       Endpoint_ClearOUT();\r
+       Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
+       \r
+       uint8_t ResponseStatus = STATUS_CMD_OK;\r
+       \r
+       for (uint8_t SByte = 0; SByte < sizeof(Erase_Chip_Params.EraseCommandBytes); SByte++)\r
+         SPI_SendByte(Erase_Chip_Params.EraseCommandBytes[SByte]);\r
+\r
+       if (!(Erase_Chip_Params.PollMethod))\r
+         V2Protocol_DelayMS(Erase_Chip_Params.EraseDelayMS);\r
        else\r
        else\r
+         ResponseStatus = V2Protocol_WaitWhileTargetBusy();\r
+         \r
+       Endpoint_Write_Byte(CMD_CHIP_ERASE_ISP);\r
+       Endpoint_Write_Byte(ResponseStatus);\r
+       Endpoint_ClearIN();\r
+}\r
+\r
+/** Handler for the CMD_READ_FUSE_ISP, CMD_READ_LOCK_ISP, CMD_READ_SIGNATURE_ISP and CMD_READ_OSCCAL commands,\r
+ *  reading the requested configuration byte from the device.\r
+ *\r
+ *  \param[in] V2Command  Issued V2 Protocol command byte from the host\r
+ */\r
+static void V2Protocol_Command_ReadFuseLockSigOSCCAL(uint8_t V2Command)\r
+{\r
+       struct\r
        {\r
        {\r
-               Endpoint_Write_Byte(STATUS_CMD_FAILED);\r
+               uint8_t RetByte;\r
+               uint8_t ReadCommandBytes[4];\r
+       } Read_FuseLockSigOSCCAL_Params;\r
+       \r
+       Endpoint_Read_Stream_LE(&Read_FuseLockSigOSCCAL_Params, sizeof(Read_FuseLockSigOSCCAL_Params));\r
+\r
+       Endpoint_ClearOUT();\r
+       Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
+\r
+       uint8_t ResponseBytes[4];\r
+               \r
+       for (uint8_t RByte = 0; RByte < sizeof(ResponseBytes); RByte++)\r
+         ResponseBytes[RByte] = SPI_TransferByte(Read_FuseLockSigOSCCAL_Params.ReadCommandBytes[RByte]);\r
+               \r
+       Endpoint_Write_Byte(V2Command);\r
+       Endpoint_Write_Byte(STATUS_CMD_OK);\r
+       Endpoint_Write_Byte(ResponseBytes[Read_FuseLockSigOSCCAL_Params.RetByte - 1]);\r
+       Endpoint_Write_Byte(STATUS_CMD_OK);\r
+       Endpoint_ClearIN();\r
+}\r
+\r
+/** Handler for the CMD_WRITE_FUSE_ISP and CMD_WRITE_LOCK_ISP commands, writing the requested configuration\r
+ *  byte to the device.\r
+ *\r
+ *  \param[in] V2Command  Issued V2 Protocol command byte from the host\r
+ */\r
+static void V2Protocol_Command_WriteFuseLock(uint8_t V2Command)\r
+{\r
+       struct\r
+       {\r
+               uint8_t WriteCommandBytes[4];\r
+       } Write_FuseLockSig_Params;\r
+       \r
+       Endpoint_Read_Stream_LE(&Write_FuseLockSig_Params, sizeof(Write_FuseLockSig_Params));\r
+\r
+       Endpoint_ClearOUT();\r
+       Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
+\r
+       for (uint8_t SByte = 0; SByte < sizeof(Write_FuseLockSig_Params.WriteCommandBytes); SByte++)\r
+         SPI_SendByte(Write_FuseLockSig_Params.WriteCommandBytes[SByte]);\r
+               \r
+       Endpoint_Write_Byte(V2Command);\r
+       Endpoint_Write_Byte(STATUS_CMD_OK);\r
+       Endpoint_Write_Byte(STATUS_CMD_OK);\r
+       Endpoint_ClearIN();\r
+}\r
+\r
+/** Handler for the CMD_SPI_MULTI command, writing and reading arbitrary SPI data to and from the attached device. */\r
+static void V2Protocol_Command_SPIMulti(void)\r
+{\r
+       struct\r
+       {\r
+               uint8_t TxBytes;\r
+               uint8_t RxBytes;\r
+               uint8_t RxStartAddr;\r
+               uint8_t TxData[255];\r
+       } SPI_Multi_Params;\r
+       \r
+       Endpoint_Read_Stream_LE(&SPI_Multi_Params, sizeof(SPI_Multi_Params) - sizeof(SPI_Multi_Params.TxData));\r
+       Endpoint_Read_Stream_LE(&SPI_Multi_Params.TxData, SPI_Multi_Params.TxBytes);\r
+       \r
+       Endpoint_ClearOUT();\r
+       Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);\r
+       \r
+       Endpoint_Write_Byte(CMD_SPI_MULTI);\r
+       Endpoint_Write_Byte(STATUS_CMD_OK);\r
+\r
+       uint8_t CurrTxPos = 0;\r
+       uint8_t CurrRxPos = 0;\r
+\r
+       /* Write out bytes to transmit until the start of the bytes to receive is met */\r
+       while (CurrTxPos < SPI_Multi_Params.RxStartAddr)\r
+       {\r
+               if (CurrTxPos < SPI_Multi_Params.TxBytes)\r
+                 SPI_SendByte(SPI_Multi_Params.TxData[CurrTxPos]);\r
+               else\r
+                 SPI_SendByte(0);\r
+               \r
+               CurrTxPos++;\r
        }\r
 \r
        }\r
 \r
-       Endpoint_ClearIN();     \r
+       /* Transmit remaining bytes with padding as needed, read in response bytes */\r
+       while (CurrRxPos < SPI_Multi_Params.RxBytes)\r
+       {\r
+               if (CurrTxPos < SPI_Multi_Params.TxBytes)\r
+                 Endpoint_Write_Byte(SPI_TransferByte(SPI_Multi_Params.TxData[CurrTxPos++]));\r
+               else\r
+                 Endpoint_Write_Byte(SPI_ReceiveByte());\r
+               \r
+               CurrRxPos++;\r
+       }       \r
+       \r
+       Endpoint_Write_Byte(STATUS_CMD_OK);\r
+       Endpoint_ClearIN();\r
 }\r
 }\r
USB isp AVR programmer