AVRISP-MKII Clone: Clean up ISP driver code, namespace module variables.

5 files changed, 552 insertions, 547 deletions

diff --git a/LUFA/DoxygenPages/ChangeLog.txt b/LUFA/DoxygenPages/ChangeLog.txt
index 4f2ae7732..55d5f55a8 100644
--- a/LUFA/DoxygenPages/ChangeLog.txt
+++ b/LUFA/DoxygenPages/ChangeLog.txt
@@ -13,6 +13,7 @@
   *   - New CCID class driver and associated demos (thanks to Filipe Rodrigues)
   *  - Library Applications:
   *   - Added Microsoft OS Compatibility descriptors to the RNDIS demos for driverless install on Windows 7 and newer
+  *   - Added AVRISP-MKII support for target OSCCAL calibration (thanks to Jacob September)
   *
   *  <b>Changed:</b>
   *  - Core:
diff --git a/Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.c b/Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.c
index 133c4512b..5fc321e73 100644
--- a/Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.c
+++ b/Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.c
@@ -8,7 +8,7 @@
 
 /*
   Copyright 2018  Dean Camera (dean [at] fourwalledcubicle [dot] com)
-  
+
   Copyright 2019 Jacob September (jacobseptember [at] gmail [dot] com)
 
   Permission to use, copy, modify, distribute, and sell this
@@ -36,100 +36,119 @@
  */
 
 #include "ISPProtocol.h"
-#include <util/atomic.h>
 
 #if defined(ENABLE_ISP_PROTOCOL) || defined(__DOXYGEN__)
 
+/* Half cycles of the OSCCAL calibration period remaining */
+static volatile uint16_t ISPProtocol_HalfCyclesRemaining;
+
+/** Target device response I/O pin toggles remaining for successful OSCCAL calibration */
+static volatile uint8_t  ISPProtocol_ResponseTogglesRemaining;
+
+
+/** ISR to toggle MOSI pin when TIMER1 overflows */
+ISR(TIMER1_OVF_vect, ISR_BLOCK)
+{
+    PINB |= (1 << PB2); // toggle PB2 (MOSI) by writing 1 to its bit in PINB
+    ISPProtocol_HalfCyclesRemaining--;
+}
+
+/** ISR to listen for toggles on MISO pin */
+ISR(PCINT0_vect, ISR_BLOCK)
+{
+    ISPProtocol_ResponseTogglesRemaining--;
+}
+
 /** Handler for the CMD_ENTER_PROGMODE_ISP command, which attempts to enter programming mode on
  *  the attached device, returning success or failure back to the host.
  */
 void ISPProtocol_EnterISPMode(void)
 {
-	struct
-	{
-		uint8_t TimeoutMS;
-		uint8_t PinStabDelayMS;
-		uint8_t ExecutionDelayMS;
-		uint8_t SynchLoops;
-		uint8_t ByteDelay;
-		uint8_t PollValue;
-		uint8_t PollIndex;
-		uint8_t EnterProgBytes[4];
-	} Enter_ISP_Params;
-
-	Endpoint_Read_Stream_LE(&Enter_ISP_Params, sizeof(Enter_ISP_Params), NULL);
-
-	Endpoint_ClearOUT();
-	Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
-	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
-
-	uint8_t ResponseStatus = STATUS_CMD_FAILED;
-
-	CurrentAddress = 0;
-
-	/* Perform execution delay, initialize SPI bus */
-	ISPProtocol_DelayMS(Enter_ISP_Params.ExecutionDelayMS);
-	ISPTarget_EnableTargetISP();
-
-	ISPTarget_ChangeTargetResetLine(true);
-	ISPProtocol_DelayMS(Enter_ISP_Params.PinStabDelayMS);
-
-	/* Continuously attempt to synchronize with the target until either the number of attempts specified
-	 * by the host has exceeded, or the the device sends back the expected response values */
-	while (Enter_ISP_Params.SynchLoops-- && TimeoutTicksRemaining)
-	{
-		uint8_t ResponseBytes[4];
-
-		for (uint8_t RByte = 0; RByte < sizeof(ResponseBytes); RByte++)
-		{
-			ISPProtocol_DelayMS(Enter_ISP_Params.ByteDelay);
-			ResponseBytes[RByte] = ISPTarget_TransferByte(Enter_ISP_Params.EnterProgBytes[RByte]);
-		}
-
-		/* Check if polling disabled, or if the polled value matches the expected value */
-		if (!(Enter_ISP_Params.PollIndex) || (ResponseBytes[Enter_ISP_Params.PollIndex - 1] == Enter_ISP_Params.PollValue))
-		{
-			ResponseStatus = STATUS_CMD_OK;
-			break;
-		}
-		else
-		{
-			ISPTarget_ChangeTargetResetLine(false);
-			ISPProtocol_DelayMS(Enter_ISP_Params.PinStabDelayMS);
-			ISPTarget_ChangeTargetResetLine(true);
-			ISPProtocol_DelayMS(Enter_ISP_Params.PinStabDelayMS);
-		}
-	}
-
-	Endpoint_Write_8(CMD_ENTER_PROGMODE_ISP);
-	Endpoint_Write_8(ResponseStatus);
-	Endpoint_ClearIN();
+    struct
+    {
+        uint8_t TimeoutMS;
+        uint8_t PinStabDelayMS;
+        uint8_t ExecutionDelayMS;
+        uint8_t SynchLoops;
+        uint8_t ByteDelay;
+        uint8_t PollValue;
+        uint8_t PollIndex;
+        uint8_t EnterProgBytes[4];
+    } Enter_ISP_Params;
+
+    Endpoint_Read_Stream_LE(&Enter_ISP_Params, sizeof(Enter_ISP_Params), NULL);
+
+    Endpoint_ClearOUT();
+    Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
+    Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
+
+    uint8_t ResponseStatus = STATUS_CMD_FAILED;
+
+    CurrentAddress = 0;
+
+    /* Perform execution delay, initialize SPI bus */
+    ISPProtocol_DelayMS(Enter_ISP_Params.ExecutionDelayMS);
+    ISPTarget_EnableTargetISP();
+
+    ISPTarget_ChangeTargetResetLine(true);
+    ISPProtocol_DelayMS(Enter_ISP_Params.PinStabDelayMS);
+
+    /* Continuously attempt to synchronize with the target until either the number of attempts specified
+     * by the host has exceeded, or the the device sends back the expected response values */
+    while (Enter_ISP_Params.SynchLoops-- && TimeoutTicksRemaining)
+    {
+        uint8_t ResponseBytes[4];
+
+        for (uint8_t RByte = 0; RByte < sizeof(ResponseBytes); RByte++)
+        {
+            ISPProtocol_DelayMS(Enter_ISP_Params.ByteDelay);
+            ResponseBytes[RByte] = ISPTarget_TransferByte(Enter_ISP_Params.EnterProgBytes[RByte]);
+        }
+
+        /* Check if polling disabled, or if the polled value matches the expected value */
+        if (!(Enter_ISP_Params.PollIndex) || (ResponseBytes[Enter_ISP_Params.PollIndex - 1] == Enter_ISP_Params.PollValue))
+        {
+            ResponseStatus = STATUS_CMD_OK;
+            break;
+        }
+        else
+        {
+            ISPTarget_ChangeTargetResetLine(false);
+            ISPProtocol_DelayMS(Enter_ISP_Params.PinStabDelayMS);
+            ISPTarget_ChangeTargetResetLine(true);
+            ISPProtocol_DelayMS(Enter_ISP_Params.PinStabDelayMS);
+        }
+    }
+
+    Endpoint_Write_8(CMD_ENTER_PROGMODE_ISP);
+    Endpoint_Write_8(ResponseStatus);
+    Endpoint_ClearIN();
 }
 
 /** Handler for the CMD_LEAVE_ISP command, which releases the target from programming mode. */
 void ISPProtocol_LeaveISPMode(void)
 {
-	struct
-	{
-		uint8_t PreDelayMS;
-		uint8_t PostDelayMS;
-	} Leave_ISP_Params;
-
-	Endpoint_Read_Stream_LE(&Leave_ISP_Params, sizeof(Leave_ISP_Params), NULL);
-
-	Endpoint_ClearOUT();
-	Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
-	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
-
-	/* Perform pre-exit delay, release the target /RESET, disable the SPI bus and perform the post-exit delay */
-	ISPProtocol_DelayMS(Leave_ISP_Params.PreDelayMS);
-	ISPTarget_ChangeTargetResetLine(false);
-	ISPTarget_DisableTargetISP();
-	ISPProtocol_DelayMS(Leave_ISP_Params.PostDelayMS);
-
-	Endpoint_Write_8(CMD_LEAVE_PROGMODE_ISP);
-	Endpoint_Write_8(STATUS_CMD_OK);
-	Endpoint_ClearIN();
+    struct
+    {
+        uint8_t PreDelayMS;
+        uint8_t PostDelayMS;
+    } Leave_ISP_Params;
+
+    Endpoint_Read_Stream_LE(&Leave_ISP_Params, sizeof(Leave_ISP_Params), NULL);
+
+    Endpoint_ClearOUT();
+    Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
+    Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
+
+    /* Perform pre-exit delay, release the target /RESET, disable the SPI bus and perform the post-exit delay */
+    ISPProtocol_DelayMS(Leave_ISP_Params.PreDelayMS);
+    ISPTarget_ChangeTargetResetLine(false);
+    ISPTarget_DisableTargetISP();
+    ISPProtocol_DelayMS(Leave_ISP_Params.PostDelayMS);
+
+    Endpoint_Write_8(CMD_LEAVE_PROGMODE_ISP);
+    Endpoint_Write_8(STATUS_CMD_OK);
+    Endpoint_ClearIN();
 }
 
 /** Handler for the CMD_PROGRAM_FLASH_ISP and CMD_PROGRAM_EEPROM_ISP commands, writing out bytes,
@@ -139,146 +158,146 @@ void ISPProtocol_LeaveISPMode(void)
  */
 void ISPProtocol_ProgramMemory(uint8_t V2Command)
 {
-	struct
-	{
-		uint16_t BytesToWrite;
-		uint8_t  ProgrammingMode;
-		uint8_t  DelayMS;
-		uint8_t  ProgrammingCommands[3];
-		uint8_t  PollValue1;
-		uint8_t  PollValue2;
-		uint8_t  ProgData[256]; // Note, the Jungo driver has a very short ACK timeout period, need to buffer the
-	} Write_Memory_Params;      // whole page and ACK the packet as fast as possible to prevent it from aborting
-
-	Endpoint_Read_Stream_LE(&Write_Memory_Params, (sizeof(Write_Memory_Params) -
-	                                               sizeof(Write_Memory_Params.ProgData)), NULL);
-	Write_Memory_Params.BytesToWrite = SwapEndian_16(Write_Memory_Params.BytesToWrite);
-
-	if (Write_Memory_Params.BytesToWrite > sizeof(Write_Memory_Params.ProgData))
-	{
-		Endpoint_ClearOUT();
-		Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
-		Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
-
-		Endpoint_Write_8(V2Command);
-		Endpoint_Write_8(STATUS_CMD_FAILED);
-		Endpoint_ClearIN();
-		return;
-	}
-
-	Endpoint_Read_Stream_LE(&Write_Memory_Params.ProgData, Write_Memory_Params.BytesToWrite, NULL);
-
-	// The driver will terminate transfers that are a round multiple of the endpoint bank in size with a ZLP, need
-	// to catch this and discard it before continuing on with packet processing to prevent communication issues
-	if (((sizeof(uint8_t) + sizeof(Write_Memory_Params) - sizeof(Write_Memory_Params.ProgData)) +
-	    Write_Memory_Params.BytesToWrite) % AVRISP_DATA_EPSIZE == 0)
-	{
-		Endpoint_ClearOUT();
-		Endpoint_WaitUntilReady();
-	}
-
-	Endpoint_ClearOUT();
-	Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
-	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
-
-	uint8_t  ProgrammingStatus = STATUS_CMD_OK;
-	uint8_t  PollValue         = (V2Command == CMD_PROGRAM_FLASH_ISP) ? Write_Memory_Params.PollValue1 :
-	                                                                    Write_Memory_Params.PollValue2;
-	uint16_t PollAddress       = 0;
-	uint8_t* NextWriteByte     = Write_Memory_Params.ProgData;
-	uint16_t PageStartAddress  = (CurrentAddress & 0xFFFF);
-
-	for (uint16_t CurrentByte = 0; CurrentByte < Write_Memory_Params.BytesToWrite; CurrentByte++)
-	{
-		uint8_t ByteToWrite     = *(NextWriteByte++);
-		uint8_t ProgrammingMode = Write_Memory_Params.ProgrammingMode;
-
-		/* Check to see if we need to send a LOAD EXTENDED ADDRESS command to the target */
-		if (MustLoadExtendedAddress)
-		{
-			ISPTarget_LoadExtendedAddress();
-			MustLoadExtendedAddress = false;
-		}
-
-		ISPTarget_SendByte(Write_Memory_Params.ProgrammingCommands[0]);
-		ISPTarget_SendByte(CurrentAddress >> 8);
-		ISPTarget_SendByte(CurrentAddress & 0xFF);
-		ISPTarget_SendByte(ByteToWrite);
-
-		/* AVR FLASH addressing requires us to modify the write command based on if we are writing a high
-		 * or low byte at the current word address */
-		if (V2Command == CMD_PROGRAM_FLASH_ISP)
-		  Write_Memory_Params.ProgrammingCommands[0] ^= READ_WRITE_HIGH_BYTE_MASK;
-
-		/* Check to see if we have a valid polling address */
-		if (!(PollAddress) && (ByteToWrite != PollValue))
-		{
-			if ((CurrentByte & 0x01) && (V2Command == CMD_PROGRAM_FLASH_ISP))
-			  Write_Memory_Params.ProgrammingCommands[2] |=  READ_WRITE_HIGH_BYTE_MASK;
-			else
-			  Write_Memory_Params.ProgrammingCommands[2] &= ~READ_WRITE_HIGH_BYTE_MASK;
-
-			PollAddress = (CurrentAddress & 0xFFFF);
-		}
-
-		/* If in word programming mode, commit the byte to the target's memory */
-		if (!(ProgrammingMode & PROG_MODE_PAGED_WRITES_MASK))
-		{
-			/* If the current polling address is invalid, switch to timed delay write completion mode */
-			if (!(PollAddress) && !(ProgrammingMode & PROG_MODE_WORD_READYBUSY_MASK))
-			  ProgrammingMode = (ProgrammingMode & ~PROG_MODE_WORD_VALUE_MASK) | PROG_MODE_WORD_TIMEDELAY_MASK;
-
-			ProgrammingStatus = ISPTarget_WaitForProgComplete(ProgrammingMode, PollAddress, PollValue,
-			                                                  Write_Memory_Params.DelayMS,
-			                                                  Write_Memory_Params.ProgrammingCommands[2]);
-
-			/* Abort the programming loop early if the byte/word programming failed */
-			if (ProgrammingStatus != STATUS_CMD_OK)
-			  break;
-
-			/* Must reset the polling address afterwards, so it is not erroneously used for the next byte */
-			PollAddress = 0;
-		}
-
-		/* EEPROM just increments the address each byte, flash needs to increment on each word and
-		 * also check to ensure that a LOAD EXTENDED ADDRESS command is issued each time the extended
-		 * address boundary has been crossed during FLASH memory programming */
-		if ((CurrentByte & 0x01) || (V2Command == CMD_PROGRAM_EEPROM_ISP))
-		{
-			CurrentAddress++;
-
-			if ((V2Command == CMD_PROGRAM_FLASH_ISP) && !(CurrentAddress & 0xFFFF))
-			  MustLoadExtendedAddress = true;
-		}
-	}
-
-	/* If the current page must be committed, send the PROGRAM PAGE command to the target */
-	if (Write_Memory_Params.ProgrammingMode & PROG_MODE_COMMIT_PAGE_MASK)
-	{
-		ISPTarget_SendByte(Write_Memory_Params.ProgrammingCommands[1]);
-		ISPTarget_SendByte(PageStartAddress >> 8);
-		ISPTarget_SendByte(PageStartAddress & 0xFF);
-		ISPTarget_SendByte(0x00);
-
-		/* Check if polling is enabled and possible, if not switch to timed delay mode */
-		if ((Write_Memory_Params.ProgrammingMode & PROG_MODE_PAGED_VALUE_MASK) && !(PollAddress))
-		{
-			Write_Memory_Params.ProgrammingMode = (Write_Memory_Params.ProgrammingMode & ~PROG_MODE_PAGED_VALUE_MASK) |
-												   PROG_MODE_PAGED_TIMEDELAY_MASK;
-		}
-
-		ProgrammingStatus = ISPTarget_WaitForProgComplete(Write_Memory_Params.ProgrammingMode, PollAddress, PollValue,
-		                                                  Write_Memory_Params.DelayMS,
-		                                                  Write_Memory_Params.ProgrammingCommands[2]);
-
-		/* Check to see if the FLASH address has crossed the extended address boundary */
-		if ((V2Command == CMD_PROGRAM_FLASH_ISP) && !(CurrentAddress & 0xFFFF))
-		  MustLoadExtendedAddress = true;
-	}
-
-	Endpoint_Write_8(V2Command);
-	Endpoint_Write_8(ProgrammingStatus);
-	Endpoint_ClearIN();
+    struct
+    {
+        uint16_t BytesToWrite;
+        uint8_t  ProgrammingMode;
+        uint8_t  DelayMS;
+        uint8_t  ProgrammingCommands[3];
+        uint8_t  PollValue1;
+        uint8_t  PollValue2;
+        uint8_t  ProgData[256]; // Note, the Jungo driver has a very short ACK timeout period, need to buffer the
+    } Write_Memory_Params;      // whole page and ACK the packet as fast as possible to prevent it from aborting
+
+    Endpoint_Read_Stream_LE(&Write_Memory_Params, (sizeof(Write_Memory_Params) -
+                                                   sizeof(Write_Memory_Params.ProgData)), NULL);
+    Write_Memory_Params.BytesToWrite = SwapEndian_16(Write_Memory_Params.BytesToWrite);
+
+    if (Write_Memory_Params.BytesToWrite > sizeof(Write_Memory_Params.ProgData))
+    {
+        Endpoint_ClearOUT();
+        Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
+        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
+
+        Endpoint_Write_8(V2Command);
+        Endpoint_Write_8(STATUS_CMD_FAILED);
+        Endpoint_ClearIN();
+        return;
+    }
+
+    Endpoint_Read_Stream_LE(&Write_Memory_Params.ProgData, Write_Memory_Params.BytesToWrite, NULL);
+
+    // The driver will terminate transfers that are a round multiple of the endpoint bank in size with a ZLP, need
+    // to catch this and discard it before continuing on with packet processing to prevent communication issues
+    if (((sizeof(uint8_t) + sizeof(Write_Memory_Params) - sizeof(Write_Memory_Params.ProgData)) +
+        Write_Memory_Params.BytesToWrite) % AVRISP_DATA_EPSIZE == 0)
+    {
+        Endpoint_ClearOUT();
+        Endpoint_WaitUntilReady();
+    }
+
+    Endpoint_ClearOUT();
+    Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
+    Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
+
+    uint8_t  ProgrammingStatus = STATUS_CMD_OK;
+    uint8_t  PollValue         = (V2Command == CMD_PROGRAM_FLASH_ISP) ? Write_Memory_Params.PollValue1 :
+                                                                        Write_Memory_Params.PollValue2;
+    uint16_t PollAddress       = 0;
+    uint8_t* NextWriteByte     = Write_Memory_Params.ProgData;
+    uint16_t PageStartAddress  = (CurrentAddress & 0xFFFF);
+
+    for (uint16_t CurrentByte = 0; CurrentByte < Write_Memory_Params.BytesToWrite; CurrentByte++)
+    {
+        uint8_t ByteToWrite     = *(NextWriteByte++);
+        uint8_t ProgrammingMode = Write_Memory_Params.ProgrammingMode;
+
+        /* Check to see if we need to send a LOAD EXTENDED ADDRESS command to the target */
+        if (MustLoadExtendedAddress)
+        {
+            ISPTarget_LoadExtendedAddress();
+            MustLoadExtendedAddress = false;
+        }
+
+        ISPTarget_SendByte(Write_Memory_Params.ProgrammingCommands[0]);
+        ISPTarget_SendByte(CurrentAddress >> 8);
+        ISPTarget_SendByte(CurrentAddress & 0xFF);
+        ISPTarget_SendByte(ByteToWrite);
+
+        /* AVR FLASH addressing requires us to modify the write command based on if we are writing a high
+         * or low byte at the current word address */
+        if (V2Command == CMD_PROGRAM_FLASH_ISP)
+          Write_Memory_Params.ProgrammingCommands[0] ^= READ_WRITE_HIGH_BYTE_MASK;
+
+        /* Check to see if we have a valid polling address */
+        if (!(PollAddress) && (ByteToWrite != PollValue))
+        {
+            if ((CurrentByte & 0x01) && (V2Command == CMD_PROGRAM_FLASH_ISP))
+              Write_Memory_Params.ProgrammingCommands[2] |=  READ_WRITE_HIGH_BYTE_MASK;
+            else
+              Write_Memory_Params.ProgrammingCommands[2] &= ~READ_WRITE_HIGH_BYTE_MASK;
+
+            PollAddress = (CurrentAddress & 0xFFFF);
+        }
+
+        /* If in word programming mode, commit the byte to the target's memory */
+        if (!(ProgrammingMode & PROG_MODE_PAGED_WRITES_MASK))
+        {
+            /* If the current polling address is invalid, switch to timed delay write completion mode */
+            if (!(PollAddress) && !(ProgrammingMode & PROG_MODE_WORD_READYBUSY_MASK))
+              ProgrammingMode = (ProgrammingMode & ~PROG_MODE_WORD_VALUE_MASK) | PROG_MODE_WORD_TIMEDELAY_MASK;
+
+            ProgrammingStatus = ISPTarget_WaitForProgComplete(ProgrammingMode, PollAddress, PollValue,
+                                                              Write_Memory_Params.DelayMS,
+                                                              Write_Memory_Params.ProgrammingCommands[2]);
+
+            /* Abort the programming loop early if the byte/word programming failed */
+            if (ProgrammingStatus != STATUS_CMD_OK)
+              break;
+
+            /* Must reset the polling address afterwards, so it is not erroneously used for the next byte */
+            PollAddress = 0;
+        }
+
+        /* EEPROM just increments the address each byte, flash needs to increment on each word and
+         * also check to ensure that a LOAD EXTENDED ADDRESS command is issued each time the extended
+         * address boundary has been crossed during FLASH memory programming */
+        if ((CurrentByte & 0x01) || (V2Command == CMD_PROGRAM_EEPROM_ISP))
+        {
+            CurrentAddress++;
+
+            if ((V2Command == CMD_PROGRAM_FLASH_ISP) && !(CurrentAddress & 0xFFFF))
+              MustLoadExtendedAddress = true;
+        }
+    }
+
+    /* If the current page must be committed, send the PROGRAM PAGE command to the target */
+    if (Write_Memory_Params.ProgrammingMode & PROG_MODE_COMMIT_PAGE_MASK)
+    {
+        ISPTarget_SendByte(Write_Memory_Params.ProgrammingCommands[1]);
+        ISPTarget_SendByte(PageStartAddress >> 8);
+        ISPTarget_SendByte(PageStartAddress & 0xFF);
+        ISPTarget_SendByte(0x00);
+
+        /* Check if polling is enabled and possible, if not switch to timed delay mode */
+        if ((Write_Memory_Params.ProgrammingMode & PROG_MODE_PAGED_VALUE_MASK) && !(PollAddress))
+        {
+            Write_Memory_Params.ProgrammingMode = (Write_Memory_Params.ProgrammingMode & ~PROG_MODE_PAGED_VALUE_MASK) |
+                                                   PROG_MODE_PAGED_TIMEDELAY_MASK;
+        }
+
+        ProgrammingStatus = ISPTarget_WaitForProgComplete(Write_Memory_Params.ProgrammingMode, PollAddress, PollValue,
+                                                          Write_Memory_Params.DelayMS,
+                                                          Write_Memory_Params.ProgrammingCommands[2]);
+
+        /* Check to see if the FLASH address has crossed the extended address boundary */
+        if ((V2Command == CMD_PROGRAM_FLASH_ISP) && !(CurrentAddress & 0xFFFF))
+          MustLoadExtendedAddress = true;
+    }
+
+    Endpoint_Write_8(V2Command);
+    Endpoint_Write_8(ProgrammingStatus);
+    Endpoint_ClearIN();
 }
 
 /** Handler for the CMD_READ_FLASH_ISP and CMD_READ_EEPROM_ISP commands, reading in bytes,
@@ -288,192 +307,160 @@ void ISPProtocol_ProgramMemory(uint8_t V2Command)
  */
 void ISPProtocol_ReadMemory(uint8_t V2Command)
 {
-	struct
-	{
-		uint16_t BytesToRead;
-		uint8_t  ReadMemoryCommand;
-	} Read_Memory_Params;
-
-	Endpoint_Read_Stream_LE(&Read_Memory_Params, sizeof(Read_Memory_Params), NULL);
-	Read_Memory_Params.BytesToRead = SwapEndian_16(Read_Memory_Params.BytesToRead);
-
-	Endpoint_ClearOUT();
-	Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
-	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
-
-	Endpoint_Write_8(V2Command);
-	Endpoint_Write_8(STATUS_CMD_OK);
-
-	/* Read each byte from the device and write them to the packet for the host */
-	for (uint16_t CurrentByte = 0; CurrentByte < Read_Memory_Params.BytesToRead; CurrentByte++)
-	{
-		/* Check to see if we need to send a LOAD EXTENDED ADDRESS command to the target */
-		if (MustLoadExtendedAddress)
-		{
-			ISPTarget_LoadExtendedAddress();
-			MustLoadExtendedAddress = false;
-		}
-
-		/* Read the next byte from the desired memory space in the device */
-		ISPTarget_SendByte(Read_Memory_Params.ReadMemoryCommand);
-		ISPTarget_SendByte(CurrentAddress >> 8);
-		ISPTarget_SendByte(CurrentAddress & 0xFF);
-		Endpoint_Write_8(ISPTarget_ReceiveByte());
-
-		/* Check if the endpoint bank is currently full, if so send the packet */
-		if (!(Endpoint_IsReadWriteAllowed()))
-		{
-			Endpoint_ClearIN();
-			Endpoint_WaitUntilReady();
-		}
-
-		/* AVR FLASH addressing requires us to modify the read command based on if we are reading a high
-		 * or low byte at the current word address */
-		if (V2Command == CMD_READ_FLASH_ISP)
-		  Read_Memory_Params.ReadMemoryCommand ^= READ_WRITE_HIGH_BYTE_MASK;
-
-		/* EEPROM just increments the address each byte, flash needs to increment on each word and
-		 * also check to ensure that a LOAD EXTENDED ADDRESS command is issued each time the extended
-		 * address boundary has been crossed */
-		if ((CurrentByte & 0x01) || (V2Command == CMD_READ_EEPROM_ISP))
-		{
-			CurrentAddress++;
-
-			if ((V2Command != CMD_READ_EEPROM_ISP) && !(CurrentAddress & 0xFFFF))
-			  MustLoadExtendedAddress = true;
-		}
-	}
-
-	Endpoint_Write_8(STATUS_CMD_OK);
-
-	bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
-	Endpoint_ClearIN();
-
-	/* Ensure last packet is a short packet to terminate the transfer */
-	if (IsEndpointFull)
-	{
-		Endpoint_WaitUntilReady();
-		Endpoint_ClearIN();
-		Endpoint_WaitUntilReady();
-	}
+    struct
+    {
+        uint16_t BytesToRead;
+        uint8_t  ReadMemoryCommand;
+    } Read_Memory_Params;
+
+    Endpoint_Read_Stream_LE(&Read_Memory_Params, sizeof(Read_Memory_Params), NULL);
+    Read_Memory_Params.BytesToRead = SwapEndian_16(Read_Memory_Params.BytesToRead);
+
+    Endpoint_ClearOUT();
+    Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
+    Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
+
+    Endpoint_Write_8(V2Command);
+    Endpoint_Write_8(STATUS_CMD_OK);
+
+    /* Read each byte from the device and write them to the packet for the host */
+    for (uint16_t CurrentByte = 0; CurrentByte < Read_Memory_Params.BytesToRead; CurrentByte++)
+    {
+        /* Check to see if we need to send a LOAD EXTENDED ADDRESS command to the target */
+        if (MustLoadExtendedAddress)
+        {
+            ISPTarget_LoadExtendedAddress();
+            MustLoadExtendedAddress = false;
+        }
+
+        /* Read the next byte from the desired memory space in the device */
+        ISPTarget_SendByte(Read_Memory_Params.ReadMemoryCommand);
+        ISPTarget_SendByte(CurrentAddress >> 8);
+        ISPTarget_SendByte(CurrentAddress & 0xFF);
+        Endpoint_Write_8(ISPTarget_ReceiveByte());
+
+        /* Check if the endpoint bank is currently full, if so send the packet */
+        if (!(Endpoint_IsReadWriteAllowed()))
+        {
+            Endpoint_ClearIN();
+            Endpoint_WaitUntilReady();
+        }
+
+        /* AVR FLASH addressing requires us to modify the read command based on if we are reading a high
+         * or low byte at the current word address */
+        if (V2Command == CMD_READ_FLASH_ISP)
+          Read_Memory_Params.ReadMemoryCommand ^= READ_WRITE_HIGH_BYTE_MASK;
+
+        /* EEPROM just increments the address each byte, flash needs to increment on each word and
+         * also check to ensure that a LOAD EXTENDED ADDRESS command is issued each time the extended
+         * address boundary has been crossed */
+        if ((CurrentByte & 0x01) || (V2Command == CMD_READ_EEPROM_ISP))
+        {
+            CurrentAddress++;
+
+            if ((V2Command != CMD_READ_EEPROM_ISP) && !(CurrentAddress & 0xFFFF))
+              MustLoadExtendedAddress = true;
+        }
+    }
+
+    Endpoint_Write_8(STATUS_CMD_OK);
+
+    bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
+    Endpoint_ClearIN();
+
+    /* Ensure last packet is a short packet to terminate the transfer */
+    if (IsEndpointFull)
+    {
+        Endpoint_WaitUntilReady();
+        Endpoint_ClearIN();
+        Endpoint_WaitUntilReady();
+    }
 }
 
 /** Handler for the CMD_CHI_ERASE_ISP command, clearing the target's FLASH memory. */
 void ISPProtocol_ChipErase(void)
 {
-	struct
-	{
-		uint8_t EraseDelayMS;
-		uint8_t PollMethod;
-		uint8_t EraseCommandBytes[4];
-	} Erase_Chip_Params;
-
-	Endpoint_Read_Stream_LE(&Erase_Chip_Params, sizeof(Erase_Chip_Params), NULL);
-
-	Endpoint_ClearOUT();
-	Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
-	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
-
-	uint8_t ResponseStatus = STATUS_CMD_OK;
-
-	/* Send the chip erase commands as given by the host to the device */
-	for (uint8_t SByte = 0; SByte < sizeof(Erase_Chip_Params.EraseCommandBytes); SByte++)
-	  ISPTarget_SendByte(Erase_Chip_Params.EraseCommandBytes[SByte]);
-
-	/* Use appropriate command completion check as given by the host (delay or busy polling) */
-	if (!(Erase_Chip_Params.PollMethod))
-	  ISPProtocol_DelayMS(Erase_Chip_Params.EraseDelayMS);
-	else
-	  ResponseStatus = ISPTarget_WaitWhileTargetBusy();
-
-	Endpoint_Write_8(CMD_CHIP_ERASE_ISP);
-	Endpoint_Write_8(ResponseStatus);
-	Endpoint_ClearIN();
-}
-
-/** Global volatile variables used in ISRs relating to ISPProtocol_Calibrate() */
-volatile uint16_t HalfCyclesRemaining;
-volatile uint8_t  ResponseTogglesRemaining;
-
-/** ISR to toggle MOSI pin when TIMER1 overflows */
-ISR(TIMER1_OVF_vect, ISR_BLOCK)
-{
-	PINB |= (1 << PB2);	// toggle PB2 (MOSI) by writing 1 to its bit in PINB
-	HalfCyclesRemaining--;
-}
-
-/** ISR to listen for toggles on MISO pin */
-ISR(PCINT0_vect, ISR_BLOCK)
-{
-	ResponseTogglesRemaining--;
+    struct
+    {
+        uint8_t EraseDelayMS;
+        uint8_t PollMethod;
+        uint8_t EraseCommandBytes[4];
+    } Erase_Chip_Params;
+
+    Endpoint_Read_Stream_LE(&Erase_Chip_Params, sizeof(Erase_Chip_Params), NULL);
+
+    Endpoint_ClearOUT();
+    Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
+    Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
+
+    uint8_t ResponseStatus = STATUS_CMD_OK;
+
+    /* Send the chip erase commands as given by the host to the device */
+    for (uint8_t SByte = 0; SByte < sizeof(Erase_Chip_Params.EraseCommandBytes); SByte++)
+      ISPTarget_SendByte(Erase_Chip_Params.EraseCommandBytes[SByte]);
+
+    /* Use appropriate command completion check as given by the host (delay or busy polling) */
+    if (!(Erase_Chip_Params.PollMethod))
+      ISPProtocol_DelayMS(Erase_Chip_Params.EraseDelayMS);
+    else
+      ResponseStatus = ISPTarget_WaitWhileTargetBusy();
+
+    Endpoint_Write_8(CMD_CHIP_ERASE_ISP);
+    Endpoint_Write_8(ResponseStatus);
+    Endpoint_ClearIN();
 }
 
 /** Handler for the CMD_OSCCAL command, entering RC-calibration mode as specified in AVR053 */
 void ISPProtocol_Calibrate(void)
 {
-	#define CALIB_CLOCK			32768
-		// CALIB_TICKS uses 2x frequency because we toggle twice per cycle
-		//  and adds 1/2 denom. to nom. to ensure rounding instead of flooring of integer division
-	#define CALIB_TICKS			( (F_CPU+CALIB_CLOCK) / (2*CALIB_CLOCK) )
-		// Per AVR053, calibration guaranteed to take 1024 cycles (2048 half-cycles) or fewer;
-		//  add some cycles for response delay (5-10 after success) and response itself
-	#define HALF_CYCLE_LIMIT	(2*1024 + 50)
-	#define SUCCESS_TOGGLE_NUM	8
-	
-	uint8_t ResponseStatus = STATUS_CMD_OK;
-	
-	/* Don't entirely know why this is needed, something to do with the USB communication back to PC */
-	Endpoint_ClearOUT();
-	Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
-	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
-	
-	/* Enable pullup on MISO and release ~RESET */
-	DDRB	=  ~(1 << PB3);					// explicitly set all PORTB to outputs except PB3 (MISO)
-	PORTB  |= ( (1 << PB4) | (1 << PB3) );	// set PB4 (TARG_RST) high (i.e. not reset) and enable pullup on PB3 (MISO)
-	
-	/* Set up MISO pin (PCINT3) to listen for toggles */
-	PCMSK0	= (1 << PCINT3);	// set mask to enable PCINT on only Pin 3 (MISO)
-	
-	/* Set up timer that fires at a rate of 65536 Hz - this will drive the MOSI toggle */
-	OCR1A	= CALIB_TICKS - 1;		// zero-indexed counter; for 16MHz system clock, this becomes 243
-	TCCR1A	= ( (1 << WGM11) | (1 << WGM10) );					// set for fast PWM, TOP = OCR1A
-	TCCR1B	= ( (1 << WGM13) | (1 << WGM12) | (1 << CS10) );	//  ... and no clock prescaling
-	TCNT1	= 0;												// reset counter
-
-	/* Initialize counter variables */
-	HalfCyclesRemaining			= HALF_CYCLE_LIMIT;
-	ResponseTogglesRemaining	= SUCCESS_TOGGLE_NUM;
-
-	/* Turn on interrupts */
-	PCICR  |= (1 << PCIE0);	// enable interrupts for PCINT7:0 (don't touch setting for PCINT12:8)
-	TIMSK1	= (1 << TOIE1);	// enable T1 OVF interrupt (and no other T1 interrupts)
-	
-	/* Turn on global interrupts for the following block, restoring current state at end */
-	NONATOMIC_BLOCK(NONATOMIC_RESTORESTATE)
-	{
-		/* Let device do its calibration, wait for reponse on MISO */
-		while ( HalfCyclesRemaining && ResponseTogglesRemaining )
-		{
-			// do nothing...
-		}
-		
-		/* Disable interrupts */
-		PCICR  &= ~(1 << PCIE0);
-		TIMSK1	= 0;
-	}
-	
-	/* Check if device responded with a success message or if we timed out */
-	if (ResponseTogglesRemaining)
-	{
-		ResponseStatus = STATUS_CMD_TOUT;
-	}
-
-	/* Report back to PC via USB */
-	Endpoint_Write_8(CMD_OSCCAL);
-	Endpoint_Write_8(ResponseStatus);
-	Endpoint_ClearIN();
-	
-} // void ISPProtocol_Calibrate(void)
+    uint8_t ResponseStatus = STATUS_CMD_OK;
+
+    /* Don't entirely know why this is needed, something to do with the USB communication back to PC */
+    Endpoint_ClearOUT();
+    Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
+    Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
+
+    /* Enable pull-up on MISO and release ~RESET */
+    DDRB    =  ~(1 << PB3);
+    PORTB  |= ( (1 << PB4) | (1 << PB3) );
+
+    /* Set up MISO pin (PCINT3) to listen for toggles */
+    PCMSK0  = (1 << PCINT3);
+
+    /* Set up timer that fires at a rate of 65536 Hz - this will drive the MOSI toggle */
+    OCR1A  = ISPPROTOCOL_CALIB_TICKS - 1;
+    TCCR1A = ( (1 << WGM11) | (1 << WGM10) );               // set for fast PWM, TOP = OCR1A
+    TCCR1B = ( (1 << WGM13) | (1 << WGM12) | (1 << CS10) ); //  ... and no clock prescaling
+    TCNT1  = 0;
+
+    /* Initialize counter variables */
+    ISPProtocol_HalfCyclesRemaining      = ISPPROTOCOL_CALIB_HALF_CYCLE_LIMIT;
+    ISPProtocol_ResponseTogglesRemaining = ISPPROTOCOL_CALIB_SUCCESS_TOGGLE_NUM;
+
+    /* Turn on interrupts */
+    PCICR  |= (1 << PCIE0); // enable interrupts for PCINT7:0 (don't touch setting for PCINT12:8)
+    TIMSK1  = (1 << TOIE1); // enable T1 OVF interrupt (and no other T1 interrupts)
+
+    /* Turn on global interrupts for the following block, restoring current state at end */
+    NONATOMIC_BLOCK(NONATOMIC_RESTORESTATE)
+    {
+        /* Let device do its calibration, wait for response on MISO */
+        while (ISPProtocol_HalfCyclesRemaining && ISPProtocol_ResponseTogglesRemaining);
+
+        /* Disable timer and pin change interrupts */
+        PCICR  &= ~(1 << PCIE0);
+        TIMSK1  = 0;
+    }
+
+    /* Check if device responded with a success message or if we timed out */
+    if (ISPProtocol_ResponseTogglesRemaining)
+      ResponseStatus = STATUS_CMD_TOUT;
+
+    /* Report back to PC via USB */
+    Endpoint_Write_8(CMD_OSCCAL);
+    Endpoint_Write_8(ResponseStatus);
+    Endpoint_ClearIN();
+}
 
 /** Handler for the CMD_READ_FUSE_ISP, CMD_READ_LOCK_ISP, CMD_READ_SIGNATURE_ISP and CMD_READ_OSCCAL commands,
  *  reading the requested configuration byte from the device.
@@ -482,29 +469,29 @@ void ISPProtocol_Calibrate(void)
  */
 void ISPProtocol_ReadFuseLockSigOSCCAL(uint8_t V2Command)
 {
-	struct
-	{
-		uint8_t RetByte;
-		uint8_t ReadCommandBytes[4];
-	} Read_FuseLockSigOSCCAL_Params;
+    struct
+    {
+        uint8_t RetByte;
+        uint8_t ReadCommandBytes[4];
+    } Read_FuseLockSigOSCCAL_Params;
 
-	Endpoint_Read_Stream_LE(&Read_FuseLockSigOSCCAL_Params, sizeof(Read_FuseLockSigOSCCAL_Params), NULL);
+    Endpoint_Read_Stream_LE(&Read_FuseLockSigOSCCAL_Params, sizeof(Read_FuseLockSigOSCCAL_Params), NULL);
 
-	Endpoint_ClearOUT();
-	Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
-	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
+    Endpoint_ClearOUT();
+    Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
+    Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 
-	uint8_t ResponseBytes[4];
+    uint8_t ResponseBytes[4];
 
-	/* Send the Fuse or Lock byte read commands as given by the host to the device, store response */
-	for (uint8_t RByte = 0; RByte < sizeof(ResponseBytes); RByte++)
-	  ResponseBytes[RByte] = ISPTarget_TransferByte(Read_FuseLockSigOSCCAL_Params.ReadCommandBytes[RByte]);
+    /* Send the Fuse or Lock byte read commands as given by the host to the device, store response */
+    for (uint8_t RByte = 0; RByte < sizeof(ResponseBytes); RByte++)
+      ResponseBytes[RByte] = ISPTarget_TransferByte(Read_FuseLockSigOSCCAL_Params.ReadCommandBytes[RByte]);
 
-	Endpoint_Write_8(V2Command);
-	Endpoint_Write_8(STATUS_CMD_OK);
-	Endpoint_Write_8(ResponseBytes[Read_FuseLockSigOSCCAL_Params.RetByte - 1]);
-	Endpoint_Write_8(STATUS_CMD_OK);
-	Endpoint_ClearIN();
+    Endpoint_Write_8(V2Command);
+    Endpoint_Write_8(STATUS_CMD_OK);
+    Endpoint_Write_8(ResponseBytes[Read_FuseLockSigOSCCAL_Params.RetByte - 1]);
+    Endpoint_Write_8(STATUS_CMD_OK);
+    Endpoint_ClearIN();
 }
 
 /** Handler for the CMD_WRITE_FUSE_ISP and CMD_WRITE_LOCK_ISP commands, writing the requested configuration
@@ -514,92 +501,92 @@ void ISPProtocol_ReadFuseLockSigOSCCAL(uint8_t V2Command)
  */
 void ISPProtocol_WriteFuseLock(uint8_t V2Command)
 {
-	struct
-	{
-		uint8_t WriteCommandBytes[4];
-	} Write_FuseLockSig_Params;
+    struct
+    {
+        uint8_t WriteCommandBytes[4];
+    } Write_FuseLockSig_Params;
 
-	Endpoint_Read_Stream_LE(&Write_FuseLockSig_Params, sizeof(Write_FuseLockSig_Params), NULL);
+    Endpoint_Read_Stream_LE(&Write_FuseLockSig_Params, sizeof(Write_FuseLockSig_Params), NULL);
 
-	Endpoint_ClearOUT();
-	Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
-	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
+    Endpoint_ClearOUT();
+    Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
+    Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 
-	/* Send the Fuse or Lock byte program commands as given by the host to the device */
-	for (uint8_t SByte = 0; SByte < sizeof(Write_FuseLockSig_Params.WriteCommandBytes); SByte++)
-	  ISPTarget_SendByte(Write_FuseLockSig_Params.WriteCommandBytes[SByte]);
+    /* Send the Fuse or Lock byte program commands as given by the host to the device */
+    for (uint8_t SByte = 0; SByte < sizeof(Write_FuseLockSig_Params.WriteCommandBytes); SByte++)
+      ISPTarget_SendByte(Write_FuseLockSig_Params.WriteCommandBytes[SByte]);
 
-	Endpoint_Write_8(V2Command);
-	Endpoint_Write_8(STATUS_CMD_OK);
-	Endpoint_Write_8(STATUS_CMD_OK);
-	Endpoint_ClearIN();
+    Endpoint_Write_8(V2Command);
+    Endpoint_Write_8(STATUS_CMD_OK);
+    Endpoint_Write_8(STATUS_CMD_OK);
+    Endpoint_ClearIN();
 }
 
 /** Handler for the CMD_SPI_MULTI command, writing and reading arbitrary SPI data to and from the attached device. */
 void ISPProtocol_SPIMulti(void)
 {
-	struct
-	{
-		uint8_t TxBytes;
-		uint8_t RxBytes;
-		uint8_t RxStartAddr;
-		uint8_t TxData[255];
-	} SPI_Multi_Params;
-
-	Endpoint_Read_Stream_LE(&SPI_Multi_Params, (sizeof(SPI_Multi_Params) - sizeof(SPI_Multi_Params.TxData)), NULL);
-	Endpoint_Read_Stream_LE(&SPI_Multi_Params.TxData, SPI_Multi_Params.TxBytes, NULL);
-
-	Endpoint_ClearOUT();
-	Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
-	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
-
-	Endpoint_Write_8(CMD_SPI_MULTI);
-	Endpoint_Write_8(STATUS_CMD_OK);
-
-	uint8_t CurrTxPos = 0;
-	uint8_t CurrRxPos = 0;
-
-	/* Write out bytes to transmit until the start of the bytes to receive is met */
-	while (CurrTxPos < SPI_Multi_Params.RxStartAddr)
-	{
-		if (CurrTxPos < SPI_Multi_Params.TxBytes)
-		  ISPTarget_SendByte(SPI_Multi_Params.TxData[CurrTxPos]);
-		else
-		  ISPTarget_SendByte(0);
-
-		CurrTxPos++;
-	}
-
-	/* Transmit remaining bytes with padding as needed, read in response bytes */
-	while (CurrRxPos < SPI_Multi_Params.RxBytes)
-	{
-		if (CurrTxPos < SPI_Multi_Params.TxBytes)
-		  Endpoint_Write_8(ISPTarget_TransferByte(SPI_Multi_Params.TxData[CurrTxPos++]));
-		else
-		  Endpoint_Write_8(ISPTarget_ReceiveByte());
-
-		/* Check to see if we have filled the endpoint bank and need to send the packet */
-		if (!(Endpoint_IsReadWriteAllowed()))
-		{
-			Endpoint_ClearIN();
-			Endpoint_WaitUntilReady();
-		}
-
-		CurrRxPos++;
-	}
-
-	Endpoint_Write_8(STATUS_CMD_OK);
-
-	bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
-	Endpoint_ClearIN();
-
-	/* Ensure last packet is a short packet to terminate the transfer */
-	if (IsEndpointFull)
-	{
-		Endpoint_WaitUntilReady();
-		Endpoint_ClearIN();
-		Endpoint_WaitUntilReady();
-	}
+    struct
+    {
+        uint8_t TxBytes;
+        uint8_t RxBytes;
+        uint8_t RxStartAddr;
+        uint8_t TxData[255];
+    } SPI_Multi_Params;
+
+    Endpoint_Read_Stream_LE(&SPI_Multi_Params, (sizeof(SPI_Multi_Params) - sizeof(SPI_Multi_Params.TxData)), NULL);
+    Endpoint_Read_Stream_LE(&SPI_Multi_Params.TxData, SPI_Multi_Params.TxBytes, NULL);
+
+    Endpoint_ClearOUT();
+    Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPADDR);
+    Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
+
+    Endpoint_Write_8(CMD_SPI_MULTI);
+    Endpoint_Write_8(STATUS_CMD_OK);
+
+    uint8_t CurrTxPos = 0;
+    uint8_t CurrRxPos = 0;
+
+    /* Write out bytes to transmit until the start of the bytes to receive is met */
+    while (CurrTxPos < SPI_Multi_Params.RxStartAddr)
+    {
+        if (CurrTxPos < SPI_Multi_Params.TxBytes)
+          ISPTarget_SendByte(SPI_Multi_Params.TxData[CurrTxPos]);
+        else
+          ISPTarget_SendByte(0);
+
+        CurrTxPos++;
+    }
+
+    /* Transmit remaining bytes with padding as needed, read in response bytes */
+    while (CurrRxPos < SPI_Multi_Params.RxBytes)
+    {
+        if (CurrTxPos < SPI_Multi_Params.TxBytes)
+          Endpoint_Write_8(ISPTarget_TransferByte(SPI_Multi_Params.TxData[CurrTxPos++]));
+        else
+          Endpoint_Write_8(ISPTarget_ReceiveByte());
+
+        /* Check to see if we have filled the endpoint bank and need to send the packet */
+        if (!(Endpoint_IsReadWriteAllowed()))
+        {
+            Endpoint_ClearIN();
+            Endpoint_WaitUntilReady();
+        }
+
+        CurrRxPos++;
+    }
+
+    Endpoint_Write_8(STATUS_CMD_OK);
+
+    bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
+    Endpoint_ClearIN();
+
+    /* Ensure last packet is a short packet to terminate the transfer */
+    if (IsEndpointFull)
+    {
+        Endpoint_WaitUntilReady();
+        Endpoint_ClearIN();
+        Endpoint_WaitUntilReady();
+    }
 }
 
 /** Blocking delay for a given number of milliseconds. This provides a simple wrapper around
@@ -610,8 +597,8 @@ void ISPProtocol_SPIMulti(void)
  */
 void ISPProtocol_DelayMS(uint8_t DelayMS)
 {
-	while (DelayMS-- && TimeoutTicksRemaining)
-	  Delay_MS(1);
+    while (DelayMS-- && TimeoutTicksRemaining)
+      Delay_MS(1);
 }
 
 #endif
diff --git a/Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.h b/Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.h
index 7bf2ff7b5..0a84e044b 100644
--- a/Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.h
+++ b/Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.h
@@ -38,6 +38,7 @@
 
 	/* Includes: */
 		#include <avr/io.h>
+		#include <util/atomic.h>
 		#include <util/delay.h>
 
 		#include <LUFA/Drivers/USB/USB.h>
@@ -45,6 +46,22 @@
 		#include "../V2Protocol.h"
 		#include "Config/AppConfig.h"
 
+	/* Macros: */
+		/** Calibration clock frequency for target OSCCAL calibration, see AVR053 application note. */
+	    #define ISPPROTOCOL_CALIB_CLOCK_HZ            32768
+
+		/** Internal timer ticks per calibration clock cycle, see AVR053 application note. */
+	    #define ISPPROTOCOL_CALIB_TICKS               ( (F_CPU + ISPPROTOCOL_CALIB_CLOCK_HZ) / (2 * ISPPROTOCOL_CALIB_CLOCK_HZ) )
+
+	    /** Per AVR053, calibration guaranteed to take 1024 cycles (2048 half-cycles) or fewer;
+	     *  add some cycles for response delay (5-10 after success) and response itself.
+		 */
+	    #define ISPPROTOCOL_CALIB_HALF_CYCLE_LIMIT    (2*1024 + 50)
+
+	    /** Per AVR053, target will toggle I/O pin 8 times to indicate a successful clock calibration.
+		 */
+	    #define ISPPROTOCOL_CALIB_SUCCESS_TOGGLE_NUM  8
+
 	/* Preprocessor Checks: */
 		#if ((BOARD == BOARD_XPLAIN) || (BOARD == BOARD_XPLAIN_REV1))
 			#undef ENABLE_ISP_PROTOCOL
diff --git a/Projects/AVRISP-MKII/Lib/ISP/ISPTarget.c b/Projects/AVRISP-MKII/Lib/ISP/ISPTarget.c
index 5adc4abde..2fcb3763f 100644
--- a/Projects/AVRISP-MKII/Lib/ISP/ISPTarget.c
+++ b/Projects/AVRISP-MKII/Lib/ISP/ISPTarget.c
@@ -70,48 +70,48 @@ static const uint8_t SPIMaskFromSCKDuration[] PROGMEM =
  */
 static const uint16_t TimerCompareFromSCKDuration[] PROGMEM =
 {
-	TIMER_COMP(96386), TIMER_COMP(89888), TIMER_COMP(84211), TIMER_COMP(79208), TIMER_COMP(74767),
-	TIMER_COMP(70797), TIMER_COMP(67227), TIMER_COMP(64000), TIMER_COMP(61069), TIMER_COMP(58395),
-	TIMER_COMP(55945), TIMER_COMP(51613), TIMER_COMP(49690), TIMER_COMP(47905), TIMER_COMP(46243),
-	TIMER_COMP(43244), TIMER_COMP(41885), TIMER_COMP(39409), TIMER_COMP(38278), TIMER_COMP(36200),
-	TIMER_COMP(34335), TIMER_COMP(32654), TIMER_COMP(31129), TIMER_COMP(29740), TIMER_COMP(28470),
-	TIMER_COMP(27304), TIMER_COMP(25724), TIMER_COMP(24768), TIMER_COMP(23461), TIMER_COMP(22285),
-	TIMER_COMP(21221), TIMER_COMP(20254), TIMER_COMP(19371), TIMER_COMP(18562), TIMER_COMP(17583),
-	TIMER_COMP(16914), TIMER_COMP(16097), TIMER_COMP(15356), TIMER_COMP(14520), TIMER_COMP(13914),
-	TIMER_COMP(13224), TIMER_COMP(12599), TIMER_COMP(12031), TIMER_COMP(11511), TIMER_COMP(10944),
-	TIMER_COMP(10431), TIMER_COMP(9963),  TIMER_COMP(9468),  TIMER_COMP(9081),  TIMER_COMP(8612),
-	TIMER_COMP(8239),  TIMER_COMP(7851),  TIMER_COMP(7498),  TIMER_COMP(7137),  TIMER_COMP(6809),
-	TIMER_COMP(6478),  TIMER_COMP(6178),  TIMER_COMP(5879),  TIMER_COMP(5607),  TIMER_COMP(5359),
-	TIMER_COMP(5093),  TIMER_COMP(4870),  TIMER_COMP(4633),  TIMER_COMP(4418),  TIMER_COMP(4209),
-	TIMER_COMP(4019),  TIMER_COMP(3823),  TIMER_COMP(3645),  TIMER_COMP(3474),  TIMER_COMP(3310),
-	TIMER_COMP(3161),  TIMER_COMP(3011),  TIMER_COMP(2869),  TIMER_COMP(2734),  TIMER_COMP(2611),
-	TIMER_COMP(2484),  TIMER_COMP(2369),  TIMER_COMP(2257),  TIMER_COMP(2152),  TIMER_COMP(2052),
-	TIMER_COMP(1956),  TIMER_COMP(1866),  TIMER_COMP(1779),  TIMER_COMP(1695),  TIMER_COMP(1615),
-	TIMER_COMP(1539),  TIMER_COMP(1468),  TIMER_COMP(1398),  TIMER_COMP(1333),  TIMER_COMP(1271),
-	TIMER_COMP(1212),  TIMER_COMP(1155),  TIMER_COMP(1101),  TIMER_COMP(1049),  TIMER_COMP(1000),
-	TIMER_COMP(953),   TIMER_COMP(909),   TIMER_COMP(866),   TIMER_COMP(826),   TIMER_COMP(787),
-	TIMER_COMP(750),   TIMER_COMP(715),   TIMER_COMP(682),   TIMER_COMP(650),   TIMER_COMP(619),
-	TIMER_COMP(590),   TIMER_COMP(563),   TIMER_COMP(536),   TIMER_COMP(511),   TIMER_COMP(487),
-	TIMER_COMP(465),   TIMER_COMP(443),   TIMER_COMP(422),   TIMER_COMP(402),   TIMER_COMP(384),
-	TIMER_COMP(366),   TIMER_COMP(349),   TIMER_COMP(332),   TIMER_COMP(317),   TIMER_COMP(302),
-	TIMER_COMP(288),   TIMER_COMP(274),   TIMER_COMP(261),   TIMER_COMP(249),   TIMER_COMP(238),
-	TIMER_COMP(226),   TIMER_COMP(216),   TIMER_COMP(206),   TIMER_COMP(196),   TIMER_COMP(187),
-	TIMER_COMP(178),   TIMER_COMP(170),   TIMER_COMP(162),   TIMER_COMP(154),   TIMER_COMP(147),
-	TIMER_COMP(140),   TIMER_COMP(134),   TIMER_COMP(128),   TIMER_COMP(122),   TIMER_COMP(116),
-	TIMER_COMP(111),   TIMER_COMP(105),   TIMER_COMP(100),   TIMER_COMP(95.4),  TIMER_COMP(90.9),
-	TIMER_COMP(86.6),  TIMER_COMP(82.6),  TIMER_COMP(78.7),  TIMER_COMP(75.0),  TIMER_COMP(71.5),
-	TIMER_COMP(68.2),  TIMER_COMP(65.0),  TIMER_COMP(61.9),  TIMER_COMP(59.0),  TIMER_COMP(56.3),
-	TIMER_COMP(53.6),  TIMER_COMP(51.1)
+	ISP_TIMER_COMP(96386), ISP_TIMER_COMP(89888), ISP_TIMER_COMP(84211), ISP_TIMER_COMP(79208), ISP_TIMER_COMP(74767),
+	ISP_TIMER_COMP(70797), ISP_TIMER_COMP(67227), ISP_TIMER_COMP(64000), ISP_TIMER_COMP(61069), ISP_TIMER_COMP(58395),
+	ISP_TIMER_COMP(55945), ISP_TIMER_COMP(51613), ISP_TIMER_COMP(49690), ISP_TIMER_COMP(47905), ISP_TIMER_COMP(46243),
+	ISP_TIMER_COMP(43244), ISP_TIMER_COMP(41885), ISP_TIMER_COMP(39409), ISP_TIMER_COMP(38278), ISP_TIMER_COMP(36200),
+	ISP_TIMER_COMP(34335), ISP_TIMER_COMP(32654), ISP_TIMER_COMP(31129), ISP_TIMER_COMP(29740), ISP_TIMER_COMP(28470),
+	ISP_TIMER_COMP(27304), ISP_TIMER_COMP(25724), ISP_TIMER_COMP(24768), ISP_TIMER_COMP(23461), ISP_TIMER_COMP(22285),
+	ISP_TIMER_COMP(21221), ISP_TIMER_COMP(20254), ISP_TIMER_COMP(19371), ISP_TIMER_COMP(18562), ISP_TIMER_COMP(17583),
+	ISP_TIMER_COMP(16914), ISP_TIMER_COMP(16097), ISP_TIMER_COMP(15356), ISP_TIMER_COMP(14520), ISP_TIMER_COMP(13914),
+	ISP_TIMER_COMP(13224), ISP_TIMER_COMP(12599), ISP_TIMER_COMP(12031), ISP_TIMER_COMP(11511), ISP_TIMER_COMP(10944),
+	ISP_TIMER_COMP(10431), ISP_TIMER_COMP(9963),  ISP_TIMER_COMP(9468),  ISP_TIMER_COMP(9081),  ISP_TIMER_COMP(8612),
+	ISP_TIMER_COMP(8239),  ISP_TIMER_COMP(7851),  ISP_TIMER_COMP(7498),  ISP_TIMER_COMP(7137),  ISP_TIMER_COMP(6809),
+	ISP_TIMER_COMP(6478),  ISP_TIMER_COMP(6178),  ISP_TIMER_COMP(5879),  ISP_TIMER_COMP(5607),  ISP_TIMER_COMP(5359),
+	ISP_TIMER_COMP(5093),  ISP_TIMER_COMP(4870),  ISP_TIMER_COMP(4633),  ISP_TIMER_COMP(4418),  ISP_TIMER_COMP(4209),
+	ISP_TIMER_COMP(4019),  ISP_TIMER_COMP(3823),  ISP_TIMER_COMP(3645),  ISP_TIMER_COMP(3474),  ISP_TIMER_COMP(3310),
+	ISP_TIMER_COMP(3161),  ISP_TIMER_COMP(3011),  ISP_TIMER_COMP(2869),  ISP_TIMER_COMP(2734),  ISP_TIMER_COMP(2611),
+	ISP_TIMER_COMP(2484),  ISP_TIMER_COMP(2369),  ISP_TIMER_COMP(2257),  ISP_TIMER_COMP(2152),  ISP_TIMER_COMP(2052),
+	ISP_TIMER_COMP(1956),  ISP_TIMER_COMP(1866),  ISP_TIMER_COMP(1779),  ISP_TIMER_COMP(1695),  ISP_TIMER_COMP(1615),
+	ISP_TIMER_COMP(1539),  ISP_TIMER_COMP(1468),  ISP_TIMER_COMP(1398),  ISP_TIMER_COMP(1333),  ISP_TIMER_COMP(1271),
+	ISP_TIMER_COMP(1212),  ISP_TIMER_COMP(1155),  ISP_TIMER_COMP(1101),  ISP_TIMER_COMP(1049),  ISP_TIMER_COMP(1000),
+	ISP_TIMER_COMP(953),   ISP_TIMER_COMP(909),   ISP_TIMER_COMP(866),   ISP_TIMER_COMP(826),   ISP_TIMER_COMP(787),
+	ISP_TIMER_COMP(750),   ISP_TIMER_COMP(715),   ISP_TIMER_COMP(682),   ISP_TIMER_COMP(650),   ISP_TIMER_COMP(619),
+	ISP_TIMER_COMP(590),   ISP_TIMER_COMP(563),   ISP_TIMER_COMP(536),   ISP_TIMER_COMP(511),   ISP_TIMER_COMP(487),
+	ISP_TIMER_COMP(465),   ISP_TIMER_COMP(443),   ISP_TIMER_COMP(422),   ISP_TIMER_COMP(402),   ISP_TIMER_COMP(384),
+	ISP_TIMER_COMP(366),   ISP_TIMER_COMP(349),   ISP_TIMER_COMP(332),   ISP_TIMER_COMP(317),   ISP_TIMER_COMP(302),
+	ISP_TIMER_COMP(288),   ISP_TIMER_COMP(274),   ISP_TIMER_COMP(261),   ISP_TIMER_COMP(249),   ISP_TIMER_COMP(238),
+	ISP_TIMER_COMP(226),   ISP_TIMER_COMP(216),   ISP_TIMER_COMP(206),   ISP_TIMER_COMP(196),   ISP_TIMER_COMP(187),
+	ISP_TIMER_COMP(178),   ISP_TIMER_COMP(170),   ISP_TIMER_COMP(162),   ISP_TIMER_COMP(154),   ISP_TIMER_COMP(147),
+	ISP_TIMER_COMP(140),   ISP_TIMER_COMP(134),   ISP_TIMER_COMP(128),   ISP_TIMER_COMP(122),   ISP_TIMER_COMP(116),
+	ISP_TIMER_COMP(111),   ISP_TIMER_COMP(105),   ISP_TIMER_COMP(100),   ISP_TIMER_COMP(95.4),  ISP_TIMER_COMP(90.9),
+	ISP_TIMER_COMP(86.6),  ISP_TIMER_COMP(82.6),  ISP_TIMER_COMP(78.7),  ISP_TIMER_COMP(75.0),  ISP_TIMER_COMP(71.5),
+	ISP_TIMER_COMP(68.2),  ISP_TIMER_COMP(65.0),  ISP_TIMER_COMP(61.9),  ISP_TIMER_COMP(59.0),  ISP_TIMER_COMP(56.3),
+	ISP_TIMER_COMP(53.6),  ISP_TIMER_COMP(51.1)
 };
 
 /** Currently selected SPI driver, either hardware (for fast ISP speeds) or software (for slower ISP speeds). */
-bool HardwareSPIMode = true;
+bool ISPTarget_HardwareSPIMode = true;
 
 /** Software SPI data register for sending and receiving */
-static volatile uint8_t SoftSPI_Data;
+static volatile uint8_t ISPTarget_SoftSPI_Data;
 
 /** Number of bits left to transfer in the software SPI driver */
-static volatile uint8_t SoftSPI_BitsRemaining;
+static volatile uint8_t ISPTarget_SoftSPI_BitsRemaining;
 
 
 /** ISR to handle software SPI transmission and reception */
@@ -120,23 +120,23 @@ ISR(TIMER1_COMPA_vect, ISR_BLOCK)
 	/* Check if rising edge (output next bit) or falling edge (read in next bit) */
 	if (!(PINB & (1 << 1)))
 	{
-		if (SoftSPI_Data & (1 << 7))
+		if (ISPTarget_SoftSPI_Data & (1 << 7))
 		  PORTB |=  (1 << 2);
 		else
 		  PORTB &= ~(1 << 2);
 	}
 	else
 	{
-		SoftSPI_Data <<= 1;
+		ISPTarget_SoftSPI_Data <<= 1;
 
-		if (!(--SoftSPI_BitsRemaining))
+		if (!(--ISPTarget_SoftSPI_BitsRemaining))
 		{
 			TCCR1B = 0;
 			TIFR1  = (1 << OCF1A);
 		}
 
 		if (PINB & (1 << 3))
-		  SoftSPI_Data |= (1 << 0);
+		  ISPTarget_SoftSPI_Data |= (1 << 0);
 	}
 
 	/* Fast toggle of PORTB.1 via the PIN register (see datasheet) */
@@ -152,14 +152,14 @@ void ISPTarget_EnableTargetISP(void)
 
 	if (SCKDuration < sizeof(SPIMaskFromSCKDuration))
 	{
-		HardwareSPIMode = true;
+		ISPTarget_HardwareSPIMode = true;
 
 		SPI_Init(pgm_read_byte(&SPIMaskFromSCKDuration[SCKDuration]) | SPI_ORDER_MSB_FIRST |
 		                       SPI_SCK_LEAD_RISING | SPI_SAMPLE_LEADING | SPI_MODE_MASTER);
 	}
 	else
 	{
-		HardwareSPIMode = false;
+		ISPTarget_HardwareSPIMode = false;
 
 		DDRB  |= ((1 << 1) | (1 << 2));
 		PORTB |= ((1 << 0) | (1 << 3));
@@ -173,7 +173,7 @@ void ISPTarget_EnableTargetISP(void)
  */
 void ISPTarget_DisableTargetISP(void)
 {
-	if (HardwareSPIMode)
+	if (ISPTarget_HardwareSPIMode)
 	{
 		SPI_Disable();
 	}
@@ -243,21 +243,21 @@ void ISPTarget_ConfigureSoftwareSPI(const uint8_t SCKDuration)
  */
 uint8_t ISPTarget_TransferSoftSPIByte(const uint8_t Byte)
 {
-	SoftSPI_Data          = Byte;
-	SoftSPI_BitsRemaining = 8;
+	ISPTarget_SoftSPI_Data          = Byte;
+	ISPTarget_SoftSPI_BitsRemaining = 8;
 
 	/* Set initial MOSI pin state according to the byte to be transferred */
-	if (SoftSPI_Data & (1 << 7))
+	if (ISPTarget_SoftSPI_Data & (1 << 7))
 	  PORTB |=  (1 << 2);
 	else
 	  PORTB &= ~(1 << 2);
 
 	TCNT1  = 0;
 	TCCR1B = ((1 << WGM12) | (1 << CS11));
-	while (SoftSPI_BitsRemaining && TimeoutTicksRemaining);
+	while (ISPTarget_SoftSPI_BitsRemaining && TimeoutTicksRemaining);
 	TCCR1B = 0;
 
-	return SoftSPI_Data;
+	return ISPTarget_SoftSPI_Data;
 }
 
 /** Asserts or deasserts the target's reset line, using the correct polarity as set by the host using a SET PARAM command.
diff --git a/Projects/AVRISP-MKII/Lib/ISP/ISPTarget.h b/Projects/AVRISP-MKII/Lib/ISP/ISPTarget.h
index c23bf2548..e29ce902c 100644
--- a/Projects/AVRISP-MKII/Lib/ISP/ISPTarget.h
+++ b/Projects/AVRISP-MKII/Lib/ISP/ISPTarget.h
@@ -62,13 +62,13 @@
 		#define LOAD_EXTENDED_ADDRESS_CMD     0x4D
 
 		/** Macro to convert an ISP frequency to a number of timer clock cycles for the software SPI driver. */
-		#define TIMER_COMP(freq)              (((F_CPU / 8) / 2 / freq) - 1)
+		#define ISP_TIMER_COMP(freq)          (((F_CPU / 8) / 2 / freq) - 1)
 
 		/** ISP rescue clock speed in Hz, for clocking targets with incorrectly set fuses. */
 		#define ISP_RESCUE_CLOCK_SPEED        4000000
 
 	/* External Variables: */
-		extern bool HardwareSPIMode;
+		extern bool ISPTarget_HardwareSPIMode;
 
 	/* Function Prototypes: */
 		void    ISPTarget_EnableTargetISP(void);
@@ -93,7 +93,7 @@
 		 */
 		static inline void ISPTarget_SendByte(const uint8_t Byte)
 		{
-			if (HardwareSPIMode)
+			if (ISPTarget_HardwareSPIMode)
 			  SPI_SendByte(Byte);
 			else
 			  ISPTarget_TransferSoftSPIByte(Byte);
@@ -108,7 +108,7 @@
 		{
 			uint8_t ReceivedByte;
 
-			if (HardwareSPIMode)
+			if (ISPTarget_HardwareSPIMode)
 			  ReceivedByte = SPI_ReceiveByte();
 			else
 			  ReceivedByte = ISPTarget_TransferSoftSPIByte(0x00);
@@ -131,7 +131,7 @@
 		{
 			uint8_t ReceivedByte;
 
-			if (HardwareSPIMode)
+			if (ISPTarget_HardwareSPIMode)
 			  ReceivedByte = SPI_TransferByte(Byte);
 			else
 			  ReceivedByte = ISPTarget_TransferSoftSPIByte(Byte);