/*
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
*/
#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,
*/
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,
*/
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.
*/
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
*/
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
*/
void ISPProtocol_DelayMS(uint8_t DelayMS)
{
- while (DelayMS-- && TimeoutTicksRemaining)
- Delay_MS(1);
+ while (DelayMS-- && TimeoutTicksRemaining)
+ Delay_MS(1);
}
#endif
projects / pub / USBasp.git / blobdiff