Altered all endpoint/pipe stream transfers so that the new BytesProcessed parameter...

[pub/USBasp.git] / Projects / AVRISP-MKII / Lib / ISP / ISPProtocol.c

diff --git a/Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.c b/Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.c
index e49f590..9a732de 100644 (file)
--- a/Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.c
+++ b/Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.c
@@ -1,21 +1,21 @@
 /*
              LUFA Library
 /*
              LUFA Library

-     Copyright (C) Dean Camera, 2010.
-              
+     Copyright (C) Dean Camera, 2011.
+

   dean [at] fourwalledcubicle [dot] com
   dean [at] fourwalledcubicle [dot] com

-      www.fourwalledcubicle.com
+           www.lufa-lib.org

 */
 
 /*
 */
 
 /*

-  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+  Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)

 
 

-  Permission to use, copy, modify, distribute, and sell this 
+  Permission to use, copy, modify, distribute, and sell this

   software and its documentation for any purpose is hereby granted
   software and its documentation for any purpose is hereby granted

-  without fee, provided that the above copyright notice appear in 
+  without fee, provided that the above copyright notice appear in

   all copies and that both that the copyright notice and this
   all copies and that both that the copyright notice and this

-  permission notice and warranty disclaimer appear in supporting 
-  documentation, and that the name of the author not be used in 
-  advertising or publicity pertaining to distribution of the 
+  permission notice and warranty disclaimer appear in supporting
+  documentation, and that the name of the author not be used in
+  advertising or publicity pertaining to distribution of the

   software without specific, written prior permission.
 
   The author disclaim all warranties with regard to this
   software without specific, written prior permission.
 
   The author disclaim all warranties with regard to this


@@ -53,30 +53,24 @@ void ISPProtocol_EnterISPMode(void)
                uint8_t PollIndex;
                uint8_t EnterProgBytes[4];
        } Enter_ISP_Params;
                uint8_t PollIndex;
                uint8_t EnterProgBytes[4];
        } Enter_ISP_Params;

-       
-       Endpoint_Read_Stream_LE(&Enter_ISP_Params, sizeof(Enter_ISP_Params), NO_STREAM_CALLBACK);
+
+       Endpoint_Read_Stream_LE(&Enter_ISP_Params, sizeof(Enter_ISP_Params), NULL);

 
        Endpoint_ClearOUT();
        Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 
        uint8_t ResponseStatus = STATUS_CMD_FAILED;
 
        Endpoint_ClearOUT();
        Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 
        uint8_t ResponseStatus = STATUS_CMD_FAILED;

-       
+

        CurrentAddress = 0;
        CurrentAddress = 0;

-       
-       /* Set up the synchronous USART to generate the recovery clock on XCK pin */
-       UBRR1  = (F_CPU / 500000UL);
-       UCSR1B = (1 << TXEN1);
-       UCSR1C = (1 << UMSEL10) | (1 << UPM11) | (1 << USBS1) | (1 << UCSZ11) | (1 << UCSZ10) | (1 << UCPOL1);
-       DDRD  |= (1 << 5);

 
        /* Perform execution delay, initialize SPI bus */
 
        /* Perform execution delay, initialize SPI bus */

-       ISPProtocol_DelayMS(Enter_ISP_Params.ExecutionDelayMS); 
-       SPI_Init(ISPTarget_GetSPIPrescalerMask() | SPI_SCK_LEAD_RISING | SPI_SAMPLE_LEADING | SPI_MODE_MASTER);
+       ISPProtocol_DelayMS(Enter_ISP_Params.ExecutionDelayMS);
+       ISPTarget_EnableTargetISP();

 
        /* 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 */
 
        /* 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-- && (ResponseStatus == STATUS_CMD_FAILED) && TimeoutMSRemaining)
+       while (Enter_ISP_Params.SynchLoops-- && (ResponseStatus != STATUS_CMD_OK) && TimeoutTicksRemaining)

        {
                uint8_t ResponseBytes[4];
 
        {
                uint8_t ResponseBytes[4];
 


@@ -86,9 +80,9 @@ void ISPProtocol_EnterISPMode(void)
                for (uint8_t RByte = 0; RByte < sizeof(ResponseBytes); RByte++)
                {
                        ISPProtocol_DelayMS(Enter_ISP_Params.ByteDelay);
                for (uint8_t RByte = 0; RByte < sizeof(ResponseBytes); RByte++)
                {
                        ISPProtocol_DelayMS(Enter_ISP_Params.ByteDelay);

-                       ResponseBytes[RByte] = SPI_TransferByte(Enter_ISP_Params.EnterProgBytes[RByte]);
+                       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))
                {
                /* 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))
                {


@@ -115,8 +109,8 @@ void ISPProtocol_LeaveISPMode(void)
                uint8_t PostDelayMS;
        } Leave_ISP_Params;
 
                uint8_t PostDelayMS;
        } Leave_ISP_Params;
 

-       Endpoint_Read_Stream_LE(&Leave_ISP_Params, sizeof(Leave_ISP_Params), NO_STREAM_CALLBACK);
-       
+       Endpoint_Read_Stream_LE(&Leave_ISP_Params, sizeof(Leave_ISP_Params), NULL);
+

        Endpoint_ClearOUT();
        Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
        Endpoint_ClearOUT();
        Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);


@@ -124,15 +118,9 @@ void ISPProtocol_LeaveISPMode(void)
        /* 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);
        /* 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);

-       SPI_ShutDown();
+       ISPTarget_DisableTargetISP();

        ISPProtocol_DelayMS(Leave_ISP_Params.PostDelayMS);
 
        ISPProtocol_DelayMS(Leave_ISP_Params.PostDelayMS);
 

-       /* Turn off the synchronous USART to terminate the recovery clock on XCK pin */
-       UBRR1  = (F_CPU / 500000UL);
-       UCSR1B = (1 << TXEN1);
-       UCSR1C = (1 << UMSEL10) | (1 << UPM11) | (1 << USBS1) | (1 << UCSZ11) | (1 << UCSZ10) | (1 << UCPOL1);
-       DDRD  &= ~(1 << 5);
-

        Endpoint_Write_Byte(CMD_LEAVE_PROGMODE_ISP);
        Endpoint_Write_Byte(STATUS_CMD_OK);
        Endpoint_ClearIN();
        Endpoint_Write_Byte(CMD_LEAVE_PROGMODE_ISP);
        Endpoint_Write_Byte(STATUS_CMD_OK);
        Endpoint_ClearIN();


@@ -155,13 +143,11 @@ void ISPProtocol_ProgramMemory(uint8_t V2Command)
                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
                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)), NO_STREAM_CALLBACK);
-

 
 

+       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);
        Write_Memory_Params.BytesToWrite = SwapEndian_16(Write_Memory_Params.BytesToWrite);

-       
+

        if (Write_Memory_Params.BytesToWrite > sizeof(Write_Memory_Params.ProgData))
        {
                Endpoint_ClearOUT();
        if (Write_Memory_Params.BytesToWrite > sizeof(Write_Memory_Params.ProgData))
        {
                Endpoint_ClearOUT();


@@ -173,135 +159,107 @@ void ISPProtocol_ProgramMemory(uint8_t V2Command)
                Endpoint_ClearIN();
                return;
        }
                Endpoint_ClearIN();
                return;
        }

-       
-       Endpoint_Read_Stream_LE(&Write_Memory_Params.ProgData, Write_Memory_Params.BytesToWrite, NO_STREAM_CALLBACK);
+
+       Endpoint_Read_Stream_LE(&Write_Memory_Params.ProgData, Write_Memory_Params.BytesToWrite, NULL);

 
        Endpoint_ClearOUT();
        Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 
 
        Endpoint_ClearOUT();
        Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 

-       uint8_t  ProgrammingStatus = STATUS_CMD_OK;     
-       uint16_t PollAddress       = 0;
+       uint8_t  ProgrammingStatus = STATUS_CMD_OK;

        uint8_t  PollValue         = (V2Command == CMD_PROGRAM_FLASH_ISP) ? Write_Memory_Params.PollValue1 :
                                                                            Write_Memory_Params.PollValue2;
        uint8_t  PollValue         = (V2Command == CMD_PROGRAM_FLASH_ISP) ? Write_Memory_Params.PollValue1 :
                                                                            Write_Memory_Params.PollValue2;

-       uint8_t* NextWriteByte = Write_Memory_Params.ProgData;
+       uint16_t PollAddress       = 0;
+       uint8_t* NextWriteByte     = Write_Memory_Params.ProgData;
+       uint16_t PageStartAddress  = (CurrentAddress & 0xFFFF);

 
 

-       /* Check to see if the host has issued a SET ADDRESS command and we haven't sent a
-        * LOAD EXTENDED ADDRESS command (if needed, used when operating beyond the 128KB
-        * FLASH barrier) */
-       if (MustSetAddress)
+       for (uint16_t CurrentByte = 0; CurrentByte < Write_Memory_Params.BytesToWrite; CurrentByte++)

        {
        {

-               if (CurrentAddress & (1UL << 31))
-                 ISPTarget_LoadExtendedAddress();
-
-               MustSetAddress = false;
-       }
+               uint8_t ByteToWrite     = *(NextWriteByte++);
+               uint8_t ProgrammingMode = Write_Memory_Params.ProgrammingMode;

 
 

-       /* Check the programming mode desired by the host, either Paged or Word memory writes */
-       if (Write_Memory_Params.ProgrammingMode & PROG_MODE_PAGED_WRITES_MASK)
-       {
-               uint16_t StartAddress = (CurrentAddress & 0xFFFF);
-       
-               /* Paged mode memory programming */
-               for (uint16_t CurrentByte = 0; CurrentByte < Write_Memory_Params.BytesToWrite; CurrentByte++)
+               /* Check to see if we need to send a LOAD EXTENDED ADDRESS command to the target */
+               if (MustLoadExtendedAddress)

                {
                {

-                       bool    IsOddByte   = (CurrentByte & 0x01);
-                       uint8_t ByteToWrite = *(NextWriteByte++);
-               
-                       SPI_SendByte(Write_Memory_Params.ProgrammingCommands[0]);
-                       SPI_SendByte(CurrentAddress >> 8);
-                       SPI_SendByte(CurrentAddress & 0xFF);
-                       SPI_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 the write completion method, to see if we have a valid polling address */
-                       if (!(PollAddress) && (ByteToWrite != PollValue))
-                       {
-                               if (IsOddByte && (V2Command == CMD_PROGRAM_FLASH_ISP))
-                                 Write_Memory_Params.ProgrammingCommands[2] |= READ_WRITE_HIGH_BYTE_MASK;
-
-                               PollAddress = (CurrentAddress & 0xFFFF);                                
-                       }               
-
-                       /* EEPROM increments the address on each byte, flash needs to increment on each word */
-                       if (IsOddByte || (V2Command == CMD_PROGRAM_EEPROM_ISP))
-                         CurrentAddress++;
+                       ISPTarget_LoadExtendedAddress();
+                       MustLoadExtendedAddress = false;

                }
                }

-               
-               /* 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[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))

                {
                {

-                       SPI_SendByte(Write_Memory_Params.ProgrammingCommands[1]);
-                       SPI_SendByte(StartAddress >> 8);
-                       SPI_SendByte(StartAddress & 0xFF);
-                       SPI_SendByte(0x00);
-                       
-                       /* Check if polling is possible, if not switch to timed delay mode */
-                       if (!(PollAddress))
-                       {
-                               Write_Memory_Params.ProgrammingMode &= ~PROG_MODE_PAGED_VALUE_MASK;
-                               Write_Memory_Params.ProgrammingMode |=  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))
-                         ISPTarget_LoadExtendedAddress();                      
+                       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);

                }
                }

-       }
-       else
-       {
-               /* Word/byte mode memory programming */
-               for (uint16_t CurrentByte = 0; CurrentByte < Write_Memory_Params.BytesToWrite; CurrentByte++)
+
+               /* If in word programming mode, commit the byte to the target's memory */
+               if (!(ProgrammingMode & PROG_MODE_PAGED_WRITES_MASK))

                {
                {

-                       bool    IsOddByte   = (CurrentByte & 0x01);
-                       uint8_t ByteToWrite = *(NextWriteByte++);
-                         
-                       SPI_SendByte(Write_Memory_Params.ProgrammingCommands[0]);
-                       SPI_SendByte(CurrentAddress >> 8);
-                       SPI_SendByte(CurrentAddress & 0xFF);
-                       SPI_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;
-
-                       if (ByteToWrite != PollValue)
-                       {
-                               if (IsOddByte && (V2Command == CMD_PROGRAM_FLASH_ISP))
-                                 Write_Memory_Params.ProgrammingCommands[2] |= READ_WRITE_HIGH_BYTE_MASK;
-                                 
-                               PollAddress = (CurrentAddress & 0xFFFF);
-                       }
-                       
-                       ProgrammingStatus = ISPTarget_WaitForProgComplete(Write_Memory_Params.ProgrammingMode, PollAddress, PollValue,
-                                                                         Write_Memory_Params.DelayMS, Write_Memory_Params.ProgrammingCommands[2]);
-                         
+                       /* 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;
 
                        /* Abort the programming loop early if the byte/word programming failed */
                        if (ProgrammingStatus != STATUS_CMD_OK)
                          break;
 

-                       /* 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 (V2Command == CMD_PROGRAM_EEPROM_ISP)
-                       {
-                               CurrentAddress++;
-                       }
-                       else if (IsOddByte)
-                       {
-                               if (!(++CurrentAddress & 0xFFFF))
-                                 ISPTarget_LoadExtendedAddress();                      
-                       }
+                       /* Must reset the polling address afterwards, so it is not erronously 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 */
+               if ((CurrentByte & 0x01) || (V2Command == CMD_PROGRAM_EEPROM_ISP))
+               {
+                       CurrentAddress++;
+
+                       if ((V2Command != CMD_PROGRAM_EEPROM_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_Byte(V2Command);
        Endpoint_Write_Byte(ProgrammingStatus);
 
        Endpoint_Write_Byte(V2Command);
        Endpoint_Write_Byte(ProgrammingStatus);


@@ -320,60 +278,54 @@ void ISPProtocol_ReadMemory(uint8_t V2Command)
                uint16_t BytesToRead;
                uint8_t  ReadMemoryCommand;
        } Read_Memory_Params;
                uint16_t BytesToRead;
                uint8_t  ReadMemoryCommand;
        } Read_Memory_Params;

-       
-       Endpoint_Read_Stream_LE(&Read_Memory_Params, sizeof(Read_Memory_Params), NO_STREAM_CALLBACK);
+
+       Endpoint_Read_Stream_LE(&Read_Memory_Params, sizeof(Read_Memory_Params), NULL);

        Read_Memory_Params.BytesToRead = SwapEndian_16(Read_Memory_Params.BytesToRead);
        Read_Memory_Params.BytesToRead = SwapEndian_16(Read_Memory_Params.BytesToRead);

-       
+

        Endpoint_ClearOUT();
        Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
        Endpoint_ClearOUT();
        Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);

-       
+

        Endpoint_Write_Byte(V2Command);
        Endpoint_Write_Byte(STATUS_CMD_OK);
        Endpoint_Write_Byte(V2Command);
        Endpoint_Write_Byte(STATUS_CMD_OK);

-       
-       /* Check to see if the host has issued a SET ADDRESS command and we haven't sent a
-        * LOAD EXTENDED ADDRESS command (if needed, used when operating beyond the 128KB
-        * FLASH barrier) */
-       if (MustSetAddress)
-       {
-               if (CurrentAddress & (1UL << 31))
-                 ISPTarget_LoadExtendedAddress();
-
-               MustSetAddress = false;
-       }

 
        /* 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++)
        {
 
        /* 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 */
                /* Read the next byte from the desired memory space in the device */

-               SPI_SendByte(Read_Memory_Params.ReadMemoryCommand);
-               SPI_SendByte(CurrentAddress >> 8);
-               SPI_SendByte(CurrentAddress & 0xFF);
-               Endpoint_Write_Byte(SPI_ReceiveByte());
-               
+               ISPTarget_SendByte(Read_Memory_Params.ReadMemoryCommand);
+               ISPTarget_SendByte(CurrentAddress >> 8);
+               ISPTarget_SendByte(CurrentAddress & 0xFF);
+               Endpoint_Write_Byte(ISPTarget_ReceiveByte());
+

                /* Check if the endpoint bank is currently full, if so send the packet */
                if (!(Endpoint_IsReadWriteAllowed()))
                {
                        Endpoint_ClearIN();
                        Endpoint_WaitUntilReady();
                }
                /* 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;
                /* 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 */
                /* 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 (V2Command == CMD_READ_EEPROM_ISP)
+               if ((CurrentByte & 0x01) || (V2Command == CMD_READ_EEPROM_ISP))

                {
                        CurrentAddress++;
                {
                        CurrentAddress++;

-               }
-               else if (CurrentByte & 0x01)
-               {
-                       if (!(++CurrentAddress & 0xFFFF))
-                         ISPTarget_LoadExtendedAddress();                      
+
+                       if ((V2Command != CMD_READ_EEPROM_ISP) && !(CurrentAddress & 0xFFFF))
+                         MustLoadExtendedAddress = true;

                }
        }
 
                }
        }
 


@@ -381,13 +333,13 @@ void ISPProtocol_ReadMemory(uint8_t V2Command)
 
        bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
        Endpoint_ClearIN();
 
        bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
        Endpoint_ClearIN();

-       
+

        /* Ensure last packet is a short packet to terminate the transfer */
        if (IsEndpointFull)
        {
        /* Ensure last packet is a short packet to terminate the transfer */
        if (IsEndpointFull)
        {

-               Endpoint_WaitUntilReady();      
+               Endpoint_WaitUntilReady();

                Endpoint_ClearIN();
                Endpoint_ClearIN();

-               Endpoint_WaitUntilReady();      
+               Endpoint_WaitUntilReady();

        }
 }
 
        }
 }
 


@@ -400,25 +352,25 @@ void ISPProtocol_ChipErase(void)
                uint8_t PollMethod;
                uint8_t EraseCommandBytes[4];
        } Erase_Chip_Params;
                uint8_t PollMethod;
                uint8_t EraseCommandBytes[4];
        } Erase_Chip_Params;

-       
-       Endpoint_Read_Stream_LE(&Erase_Chip_Params, sizeof(Erase_Chip_Params), NO_STREAM_CALLBACK);
-       
+
+       Endpoint_Read_Stream_LE(&Erase_Chip_Params, sizeof(Erase_Chip_Params), NULL);
+

        Endpoint_ClearOUT();
        Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
        Endpoint_ClearOUT();
        Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);

-       
+

        uint8_t ResponseStatus = STATUS_CMD_OK;
        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++)
        /* 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++)

-         SPI_SendByte(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();
 
        /* 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_Byte(CMD_CHIP_ERASE_ISP);
        Endpoint_Write_Byte(ResponseStatus);
        Endpoint_ClearIN();
        Endpoint_Write_Byte(CMD_CHIP_ERASE_ISP);
        Endpoint_Write_Byte(ResponseStatus);
        Endpoint_ClearIN();


@@ -436,8 +388,8 @@ void ISPProtocol_ReadFuseLockSigOSCCAL(uint8_t V2Command)
                uint8_t RetByte;
                uint8_t ReadCommandBytes[4];
        } Read_FuseLockSigOSCCAL_Params;
                uint8_t RetByte;
                uint8_t ReadCommandBytes[4];
        } Read_FuseLockSigOSCCAL_Params;

-       
-       Endpoint_Read_Stream_LE(&Read_FuseLockSigOSCCAL_Params, sizeof(Read_FuseLockSigOSCCAL_Params), NO_STREAM_CALLBACK);
+
+       Endpoint_Read_Stream_LE(&Read_FuseLockSigOSCCAL_Params, sizeof(Read_FuseLockSigOSCCAL_Params), NULL);

 
        Endpoint_ClearOUT();
        Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
 
        Endpoint_ClearOUT();
        Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);


@@ -447,8 +399,8 @@ void ISPProtocol_ReadFuseLockSigOSCCAL(uint8_t V2Command)
 
        /* 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++)
 
        /* 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] = SPI_TransferByte(Read_FuseLockSigOSCCAL_Params.ReadCommandBytes[RByte]);
-               
+         ResponseBytes[RByte] = ISPTarget_TransferByte(Read_FuseLockSigOSCCAL_Params.ReadCommandBytes[RByte]);
+

        Endpoint_Write_Byte(V2Command);
        Endpoint_Write_Byte(STATUS_CMD_OK);
        Endpoint_Write_Byte(ResponseBytes[Read_FuseLockSigOSCCAL_Params.RetByte - 1]);
        Endpoint_Write_Byte(V2Command);
        Endpoint_Write_Byte(STATUS_CMD_OK);
        Endpoint_Write_Byte(ResponseBytes[Read_FuseLockSigOSCCAL_Params.RetByte - 1]);


@@ -467,8 +419,8 @@ void ISPProtocol_WriteFuseLock(uint8_t V2Command)
        {
                uint8_t WriteCommandBytes[4];
        } Write_FuseLockSig_Params;
        {
                uint8_t WriteCommandBytes[4];
        } Write_FuseLockSig_Params;

-       
-       Endpoint_Read_Stream_LE(&Write_FuseLockSig_Params, sizeof(Write_FuseLockSig_Params), NO_STREAM_CALLBACK);
+
+       Endpoint_Read_Stream_LE(&Write_FuseLockSig_Params, sizeof(Write_FuseLockSig_Params), NULL);

 
        Endpoint_ClearOUT();
        Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
 
        Endpoint_ClearOUT();
        Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);


@@ -476,8 +428,8 @@ void ISPProtocol_WriteFuseLock(uint8_t V2Command)
 
        /* 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++)
 
        /* 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++)

-         SPI_SendByte(Write_FuseLockSig_Params.WriteCommandBytes[SByte]);
-               
+         ISPTarget_SendByte(Write_FuseLockSig_Params.WriteCommandBytes[SByte]);
+

        Endpoint_Write_Byte(V2Command);
        Endpoint_Write_Byte(STATUS_CMD_OK);
        Endpoint_Write_Byte(STATUS_CMD_OK);
        Endpoint_Write_Byte(V2Command);
        Endpoint_Write_Byte(STATUS_CMD_OK);
        Endpoint_Write_Byte(STATUS_CMD_OK);


@@ -494,14 +446,14 @@ void ISPProtocol_SPIMulti(void)
                uint8_t RxStartAddr;
                uint8_t TxData[255];
        } SPI_Multi_Params;
                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)), NO_STREAM_CALLBACK);
-       Endpoint_Read_Stream_LE(&SPI_Multi_Params.TxData, SPI_Multi_Params.TxBytes, NO_STREAM_CALLBACK);
-       
+
+       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_EPNUM);
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
        Endpoint_ClearOUT();
        Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
        Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);

-       
+

        Endpoint_Write_Byte(CMD_SPI_MULTI);
        Endpoint_Write_Byte(STATUS_CMD_OK);
 
        Endpoint_Write_Byte(CMD_SPI_MULTI);
        Endpoint_Write_Byte(STATUS_CMD_OK);
 


@@ -512,10 +464,10 @@ void ISPProtocol_SPIMulti(void)
        while (CurrTxPos < SPI_Multi_Params.RxStartAddr)
        {
                if (CurrTxPos < SPI_Multi_Params.TxBytes)
        while (CurrTxPos < SPI_Multi_Params.RxStartAddr)
        {
                if (CurrTxPos < SPI_Multi_Params.TxBytes)

-                 SPI_SendByte(SPI_Multi_Params.TxData[CurrTxPos]);
+                 ISPTarget_SendByte(SPI_Multi_Params.TxData[CurrTxPos]);

                else
                else

-                 SPI_SendByte(0);
-               
+                 ISPTarget_SendByte(0);
+

                CurrTxPos++;
        }
 
                CurrTxPos++;
        }
 


@@ -523,31 +475,31 @@ void ISPProtocol_SPIMulti(void)
        while (CurrRxPos < SPI_Multi_Params.RxBytes)
        {
                if (CurrTxPos < SPI_Multi_Params.TxBytes)
        while (CurrRxPos < SPI_Multi_Params.RxBytes)
        {
                if (CurrTxPos < SPI_Multi_Params.TxBytes)

-                 Endpoint_Write_Byte(SPI_TransferByte(SPI_Multi_Params.TxData[CurrTxPos++]));
+                 Endpoint_Write_Byte(ISPTarget_TransferByte(SPI_Multi_Params.TxData[CurrTxPos++]));

                else
                else

-                 Endpoint_Write_Byte(SPI_ReceiveByte());
-                 
+                 Endpoint_Write_Byte(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();
                }
                /* Check to see if we have filled the endpoint bank and need to send the packet */
                if (!(Endpoint_IsReadWriteAllowed()))
                {
                        Endpoint_ClearIN();
                        Endpoint_WaitUntilReady();
                }

-               
+

                CurrRxPos++;
                CurrRxPos++;

-       }       
-       
+       }
+

        Endpoint_Write_Byte(STATUS_CMD_OK);
 
        bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
        Endpoint_ClearIN();
        Endpoint_Write_Byte(STATUS_CMD_OK);
 
        bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
        Endpoint_ClearIN();

-       
+

        /* Ensure last packet is a short packet to terminate the transfer */
        if (IsEndpointFull)
        {
        /* Ensure last packet is a short packet to terminate the transfer */
        if (IsEndpointFull)
        {

-               Endpoint_WaitUntilReady();      
+               Endpoint_WaitUntilReady();

                Endpoint_ClearIN();
                Endpoint_ClearIN();

-               Endpoint_WaitUntilReady();      
+               Endpoint_WaitUntilReady();

        }
 }
 
        }
 }
 


@@ -557,13 +509,8 @@ void ISPProtocol_SPIMulti(void)
  */
 void ISPProtocol_DelayMS(uint8_t DelayMS)
 {
  */
 void ISPProtocol_DelayMS(uint8_t DelayMS)
 {

-       while (DelayMS-- && TimeoutMSRemaining)
-       {
-               if (TimeoutMSRemaining)
-                 TimeoutMSRemaining--;
-                 
-               _delay_ms(1);
-       }
+       while (DelayMS-- && TimeoutTicksRemaining)
+         _delay_ms(1);

 }
 
 }
 

-#endif
\ No newline at end of file
+#endif