aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--LUFA/DoxygenPages/ChangeLog.txt1
-rw-r--r--Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.c977
-rw-r--r--Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.h17
-rw-r--r--Projects/AVRISP-MKII/Lib/ISP/ISPTarget.c94
-rw-r--r--Projects/AVRISP-MKII/Lib/ISP/ISPTarget.h10
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);