X-Git-Url: http://git.linex4red.de/pub/USBasp.git/blobdiff_plain/2281750b5fdf046ed606e567eb60cf4e647015dd..4f74075fad7f1e7a35d04ff534d9d6a57d2b97fc:/Projects/AVRISP/Lib/PDIProtocol.c

diff --git a/Projects/AVRISP/Lib/PDIProtocol.c b/Projects/AVRISP/Lib/PDIProtocol.c
index d98c51c43..1b3fc53c4 100644
--- a/Projects/AVRISP/Lib/PDIProtocol.c
+++ b/Projects/AVRISP/Lib/PDIProtocol.c
@@ -28,10 +28,6 @@
   this software.
 */
 
-#if defined(ENABLE_PDI_PROTOCOL) || defined(__DOXYGEN__)
-
-#warning PDI Programming Protocol support is incomplete and not currently suitable for use.
-
 /** \file
  *
  *  PDI Protocol handler, to process V2 Protocol wrapped PDI commands used in Atmel programmer devices.
@@ -40,7 +36,11 @@
 #define  INCLUDE_FROM_PDIPROTOCOL_C
 #include "PDIProtocol.h"
 
+#if defined(ENABLE_PDI_PROTOCOL) || defined(__DOXYGEN__)
+/** Base absolute address for the target's NVM controller */
 uint32_t XPROG_Param_NVMBase;
+
+/** Size in bytes of the target's EEPROM page */
 uint32_t XPROG_Param_EEPageSize;
 
 /** Handler for the CMD_XPROG_SETMODE command, which sets the programmer-to-target protocol used for PDI
@@ -59,7 +59,7 @@ void PDIProtocol_XPROG_SetMode(void)
 	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 	
 	Endpoint_Write_Byte(CMD_XPROG_SETMODE);
-	Endpoint_Write_Byte(SetMode_XPROG_Params.Protocol ? STATUS_CMD_FAILED : STATUS_CMD_OK);
+	Endpoint_Write_Byte((SetMode_XPROG_Params.Protocol == XPRG_PROTOCOL_PDI) ? STATUS_CMD_OK : STATUS_CMD_FAILED);
 	Endpoint_ClearIN();	
 }
 
@@ -99,38 +99,27 @@ void PDIProtocol_XPROG_Command(void)
 /** Handler for the XPROG ENTER_PROGMODE command to establish a PDI connection with the attached device. */
 static void PDIProtocol_EnterXPROGMode(void)
 {
-	uint8_t ReturnStatus = XPRG_ERR_OK;
-
 	Endpoint_ClearOUT();
 	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 	
-	PDIDATA_LINE_DDR  |= PDIDATA_LINE_MASK;
-	PDICLOCK_LINE_DDR |= PDICLOCK_LINE_MASK;
-	
-	/* Must hold DATA line high for at least 90nS to enable PDI interface */
-	PDIDATA_LINE_PORT |= PDIDATA_LINE_MASK;
-	asm volatile ("NOP"::);
-	#if (F_CPU > 8000000)
-	asm volatile ("NOP"::);
-	#endif
-	
-	/* Toggle CLOCK line 16 times within 100uS of the original 90nS timeout to keep PDI interface enabled */
-	for (uint8_t i = 0; i < 16; i++)
-	  TOGGLE_PDI_CLOCK;
+	/* Enable PDI programming mode with the attached target */
+	PDITarget_EnableTargetPDI();
 	
+	/* Store the RESET key into the RESET PDI register to keep the XMEGA in reset */
+	PDITarget_SendByte(PDI_CMD_STCS | PDI_RESET_REG);	
+	PDITarget_SendByte(PDI_RESET_KEY);
+
 	/* Enable access to the XPROG NVM bus by sending the documented NVM access key to the device */
 	PDITarget_SendByte(PDI_CMD_KEY);	
-	for (uint8_t i = 0; i < 8; i++)
-	  PDITarget_SendByte(PDI_NVMENABLE_KEY[i]);
+	for (uint8_t i = sizeof(PDI_NVMENABLE_KEY); i > 0; i--)
+	  PDITarget_SendByte(PDI_NVMENABLE_KEY[i - 1]);
 
-	/* Read out the STATUS register to check that NVM access was successfully enabled */
-	PDITarget_SendByte(PDI_CMD_LDCS | PD_STATUS_REG);	
-	if (!(PDITarget_ReceiveByte() & PDI_STATUS_NVM))
-	  ReturnStatus = XPRG_ERR_FAILED;
+	/* Wait until the NVM bus becomes active */
+	bool NVMBusEnabled = PDITarget_WaitWhileNVMBusBusy();
 	
 	Endpoint_Write_Byte(CMD_XPROG);
 	Endpoint_Write_Byte(XPRG_CMD_ENTER_PROGMODE);
-	Endpoint_Write_Byte(ReturnStatus);
+	Endpoint_Write_Byte(NVMBusEnabled ? XPRG_ERR_OK : XPRG_ERR_FAILED);
 	Endpoint_ClearIN();
 }
 
@@ -142,14 +131,12 @@ static void PDIProtocol_LeaveXPROGMode(void)
 	Endpoint_ClearOUT();
 	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 	
-	/* Set DATA and CLOCK lines to inputs */
-	PDIDATA_LINE_DDR   &= ~PDIDATA_LINE_MASK;
-	PDICLOCK_LINE_DDR  &= ~PDICLOCK_LINE_MASK;
-	
-	/* Tristate DATA and CLOCK lines */
-	PDIDATA_LINE_PORT  &= ~PDIDATA_LINE_MASK;
-	PDICLOCK_LINE_PORT &= ~PDICLOCK_LINE_MASK;
-	
+	/* Clear the RESET key in the RESET PDI register to allow the XMEGA to run */
+	PDITarget_SendByte(PDI_CMD_STCS | PDI_RESET_REG);	
+	PDITarget_SendByte(0x00);
+
+	PDITarget_DisableTargetPDI();
+
 	Endpoint_Write_Byte(CMD_XPROG);
 	Endpoint_Write_Byte(XPRG_CMD_LEAVE_PROGMODE);
 	Endpoint_Write_Byte(XPRG_ERR_OK);
@@ -168,11 +155,34 @@ static void PDIProtocol_Erase(void)
 	} Erase_XPROG_Params;
 
 	Endpoint_Read_Stream_LE(&Erase_XPROG_Params, sizeof(Erase_XPROG_Params));
+	Erase_XPROG_Params.Address = SwapEndian_32(Erase_XPROG_Params.Address);
 
 	Endpoint_ClearOUT();
 	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 	
-	// TODO: Send erase command here via PDI protocol
+	uint8_t EraseCommand = NVM_CMD_NOOP;
+	
+	/* Determine which NVM command to send to the device depending on the memory to erase */
+	if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_CHIP)
+	  EraseCommand = NVM_CMD_CHIPERASE;
+	else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_APP)
+	  EraseCommand = NVM_CMD_ERASEAPPSEC;
+	else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_BOOT)
+	  EraseCommand = NVM_CMD_ERASEBOOTSEC;
+	else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_EEPROM)
+	  EraseCommand = NVM_CMD_ERASEEEPROM;
+	else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_APP_PAGE)
+	  EraseCommand = NVM_CMD_ERASEAPPSECPAGE;
+	else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_BOOT_PAGE)
+	  EraseCommand = NVM_CMD_ERASEBOOTSECPAGE;
+	else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_EEPROM_PAGE)
+	  EraseCommand = NVM_CMD_ERASEEEPROMPAGE;
+	else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_USERSIG)
+	  EraseCommand = NVM_CMD_ERASEUSERSIG;
+	
+	/* Erase the target memory, indicate timeout if ocurred */
+	if (!(NVMTarget_EraseMemory(EraseCommand, Erase_XPROG_Params.Address)))
+	  ReturnStatus = XPRG_ERR_TIMEOUT;
 	
 	Endpoint_Write_Byte(CMD_XPROG);
 	Endpoint_Write_Byte(XPRG_CMD_ERASE);
@@ -188,6 +198,7 @@ static void PDIProtocol_WriteMemory(void)
 	struct
 	{
 		uint8_t  MemoryType;
+		uint8_t  PageMode;
 		uint32_t Address;
 		uint16_t Length;
 		uint8_t  ProgData[256];
@@ -201,11 +212,56 @@ static void PDIProtocol_WriteMemory(void)
 
 	Endpoint_ClearOUT();
 	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
+
+	/* Assume FLASH page programming by default, as it is the common case */
+	uint8_t WriteCommand     = NVM_CMD_WRITEFLASHPAGE;
+	uint8_t WriteBuffCommand = NVM_CMD_LOADFLASHPAGEBUFF;
+	uint8_t EraseBuffCommand = NVM_CMD_ERASEFLASHPAGEBUFF;
+	bool    PagedMemory      = true;
+	
+	if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_APPL)
+	{
+		WriteCommand     = NVM_CMD_WRITEAPPSECPAGE;
+	}
+	else if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_BOOT)
+	{
+		WriteCommand     = NVM_CMD_WRITEBOOTSECPAGE;
+	}
+	else if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_EEPROM)
+	{
+		WriteCommand     = NVM_CMD_WRITEEEPROMPAGE;
+		WriteBuffCommand = NVM_CMD_LOADEEPROMPAGEBUFF;
+		EraseBuffCommand = NVM_CMD_ERASEEEPROMPAGEBUFF;
+	}
+	else if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_USERSIG)
+	{
+		/* User signature is paged, but needs us to manually indicate the mode bits since the host doesn't set them */
+		WriteMemory_XPROG_Params.PageMode = (XPRG_PAGEMODE_ERASE | XPRG_PAGEMODE_WRITE);
+		WriteCommand     = NVM_CMD_WRITEUSERSIG;
+	}
+	else if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_FUSE)
+	{
+		WriteCommand     = NVM_CMD_WRITEFUSE;
+		PagedMemory      = false;
+	}
+	else if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_LOCKBITS)
+	{
+		WriteCommand     = NVM_CMD_WRITELOCK;
+		PagedMemory      = false;
+	}
 	
-	// TODO: Send program command here via PDI protocol
+	/* Send the appropriate memory write commands to the device, indicate timeout if occurred */
+	if ((PagedMemory && !NVMTarget_WritePageMemory(WriteBuffCommand, EraseBuffCommand, WriteCommand, 
+		                                           WriteMemory_XPROG_Params.PageMode, WriteMemory_XPROG_Params.Address,
+		                                           WriteMemory_XPROG_Params.ProgData, WriteMemory_XPROG_Params.Length)) ||
+	   (!PagedMemory && !NVMTarget_WriteByteMemory(WriteCommand, WriteMemory_XPROG_Params.Address,
+	                                               WriteMemory_XPROG_Params.ProgData)))
+	{
+		ReturnStatus = XPRG_ERR_TIMEOUT;
+	}
 	
 	Endpoint_Write_Byte(CMD_XPROG);
-	Endpoint_Write_Byte(XPRG_CMD_READ_MEM);
+	Endpoint_Write_Byte(XPRG_CMD_WRITE_MEM);
 	Endpoint_Write_Byte(ReturnStatus);	
 	Endpoint_ClearIN();
 }
@@ -230,13 +286,20 @@ static void PDIProtocol_ReadMemory(void)
 
 	Endpoint_ClearOUT();
 	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
+
+	uint8_t ReadBuffer[256];
 	
-	// TODO: Send read command here via PDI protocol
-	
+	/* Read the target's memory, indicate timeout if occurred */
+	if (!(NVMTarget_ReadMemory(ReadMemory_XPROG_Params.Address, ReadBuffer, ReadMemory_XPROG_Params.Length)))
+	  ReturnStatus = XPRG_ERR_TIMEOUT;
+
 	Endpoint_Write_Byte(CMD_XPROG);
 	Endpoint_Write_Byte(XPRG_CMD_READ_MEM);
 	Endpoint_Write_Byte(ReturnStatus);
 	
+	if (ReturnStatus == XPRG_ERR_OK)
+	  Endpoint_Write_Stream_LE(ReadBuffer, ReadMemory_XPROG_Params.Length);
+	
 	Endpoint_ClearIN();
 }
 
@@ -246,15 +309,30 @@ static void PDIProtocol_ReadMemory(void)
 static void PDIProtocol_ReadCRC(void)
 {
 	uint8_t ReturnStatus = XPRG_ERR_OK;
-
-	uint8_t CRCType = Endpoint_Read_Byte();
 	
+	struct
+	{
+		uint8_t CRCType;
+	} ReadCRC_XPROG_Params;
+	
+	Endpoint_Read_Stream_LE(&ReadCRC_XPROG_Params, sizeof(ReadCRC_XPROG_Params));
 	Endpoint_ClearOUT();
 	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 	
-	uint32_t MemoryCRC = 0;
+	uint8_t  CRCCommand = NVM_CMD_NOOP;
+	uint32_t MemoryCRC;
+
+	/* Determine which NVM command to send to the device depending on the memory to CRC */
+	if (ReadCRC_XPROG_Params.CRCType == XPRG_CRC_APP)
+	  CRCCommand = NVM_CMD_APPCRC;
+	else if (ReadCRC_XPROG_Params.CRCType == XPRG_CRC_BOOT)
+	  CRCCommand = NVM_CMD_BOOTCRC;
+	else
+	  CRCCommand = NVM_CMD_FLASHCRC;
 	
-	// TODO: Read device CRC for desired memory via PDI protocol
+	/* Perform and retrieve the memory CRC, indicate timeout if occurred */
+	if (!(NVMTarget_GetMemoryCRC(CRCCommand, &MemoryCRC)))
+	  ReturnStatus = XPRG_ERR_TIMEOUT;
 	
 	Endpoint_Write_Byte(CMD_XPROG);
 	Endpoint_Write_Byte(XPRG_CMD_CRC);
@@ -278,10 +356,11 @@ static void PDIProtocol_SetParam(void)
 
 	uint8_t XPROGParam = Endpoint_Read_Byte();
 	
+	/* Determine which parameter is being set, store the new parameter value */
 	if (XPROGParam == XPRG_PARAM_NVMBASE)
-	  XPROG_Param_NVMBase = Endpoint_Read_DWord_LE();
+	  XPROG_Param_NVMBase = Endpoint_Read_DWord_BE();
 	else if (XPROGParam == XPRG_PARAM_EEPPAGESIZE)
-	  XPROG_Param_EEPageSize = Endpoint_Read_Word_LE();
+	  XPROG_Param_EEPageSize = Endpoint_Read_Word_BE();
 	else
 	  ReturnStatus = XPRG_ERR_FAILED;