Bootloaders/DFU/BootloaderDFU.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2011.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 /** \file
  32  *
  33  *  Main source file for the DFU class bootloader. This file contains the complete bootloader logic.
  34  */
  35
  36 #define  INCLUDE_FROM_BOOTLOADER_C
  37 #include "BootloaderDFU.h"
  38
  39 /** Flag to indicate if the bootloader is currently running in secure mode, disallowing memory operations
  40  *  other than erase. This is initially set to the value set by SECURE_MODE, and cleared by the bootloader
  41  *  once a memory erase has completed in a bootloader session.
  42  */
  43 static bool IsSecure = SECURE_MODE;
  44
  45 /** Flag to indicate if the bootloader should be running, or should exit and allow the application code to run
  46  *  via a soft reset. When cleared, the bootloader will abort, the USB interface will shut down and the application
  47  *  jumped to via an indirect jump to location 0x0000 (or other location specified by the host).
  48  */
  49 static bool RunBootloader = true;
  50
  51 /** Flag to indicate if the bootloader is waiting to exit. When the host requests the bootloader to exit and
  52  *  jump to the application address it specifies, it sends two sequential commands which must be properly
  53  *  acknowledged. Upon reception of the first the RunBootloader flag is cleared and the WaitForExit flag is set,
  54  *  causing the bootloader to wait for the final exit command before shutting down.
  55  */
  56 static bool WaitForExit = false;
  57
  58 /** Current DFU state machine state, one of the values in the DFU_State_t enum. */
  59 static uint8_t DFU_State = dfuIDLE;
  60
  61 /** Status code of the last executed DFU command. This is set to one of the values in the DFU_Status_t enum after
  62  *  each operation, and returned to the host when a Get Status DFU request is issued.
  63  */
  64 static uint8_t DFU_Status = OK;
  65
  66 /** Data containing the DFU command sent from the host. */
  67 static DFU_Command_t SentCommand;
  68
  69 /** Response to the last issued Read Data DFU command. Unlike other DFU commands, the read command
  70  *  requires a single byte response from the bootloader containing the read data when the next DFU_UPLOAD command
  71  *  is issued by the host.
  72  */
  73 static uint8_t ResponseByte;
  74
  75 /** Pointer to the start of the user application. By default this is 0x0000 (the reset vector), however the host
  76  *  may specify an alternate address when issuing the application soft-start command.
  77  */
  78 static AppPtr_t AppStartPtr = (AppPtr_t)0x0000;
  79
  80 /** 64-bit flash page number. This is concatenated with the current 16-bit address on USB AVRs containing more than
  81  *  64KB of flash memory.
  82  */
  83 static uint8_t Flash64KBPage = 0;
  84
  85 /** Memory start address, indicating the current address in the memory being addressed (either FLASH or EEPROM
  86  *  depending on the issued command from the host).
  87  */
  88 static uint16_t StartAddr = 0x0000;
  89
  90 /** Memory end address, indicating the end address to read from/write to in the memory being addressed (either FLASH
  91  *  of EEPROM depending on the issued command from the host).
  92  */
  93 static uint16_t EndAddr = 0x0000;
  94
  95
  96 /** Main program entry point. This routine configures the hardware required by the bootloader, then continuously
  97  *  runs the bootloader processing routine until instructed to soft-exit, or hard-reset via the watchdog to start
  98  *  the loaded application code.
  99  */
 100 int main(void)
 101 {
 102         /* Configure hardware required by the bootloader */
 103         SetupHardware();
 104
 105         #if ((BOARD == BOARD_XPLAIN) || (BOARD == BOARD_XPLAIN_REV1))
 106         /* Disable JTAG debugging */
 107         MCUCR |= (1 << JTD);
 108         MCUCR |= (1 << JTD);
 109
 110         /* Enable pull-up on the JTAG TCK pin so we can use it to select the mode */
 111         PORTF |= (1 << 4);
 112         Delay_MS(10);
 113
 114         /* If the TCK pin is not jumpered to ground, start the user application instead */
 115         RunBootloader = (!(PINF & (1 << 4)));
 116
 117         /* Re-enable JTAG debugging */
 118         MCUCR &= ~(1 << JTD);
 119         MCUCR &= ~(1 << JTD);
 120         #endif
 121
 122         /* Turn on first LED on the board to indicate that the bootloader has started */
 123         LEDs_SetAllLEDs(LEDS_LED1);
 124
 125         /* Enable global interrupts so that the USB stack can function */
 126         sei();
 127
 128         /* Run the USB management task while the bootloader is supposed to be running */
 129         while (RunBootloader || WaitForExit)
 130           USB_USBTask();
 131
 132         /* Reset configured hardware back to their original states for the user application */
 133         ResetHardware();
 134
 135         /* Start the user application */
 136         AppStartPtr();
 137 }
 138
 139 /** Configures all hardware required for the bootloader. */
 140 void SetupHardware(void)
 141 {
 142         /* Disable watchdog if enabled by bootloader/fuses */
 143         MCUSR &= ~(1 << WDRF);
 144         wdt_disable();
 145
 146         /* Disable clock division */
 147         clock_prescale_set(clock_div_1);
 148
 149         /* Relocate the interrupt vector table to the bootloader section */
 150         MCUCR = (1 << IVCE);
 151         MCUCR = (1 << IVSEL);
 152
 153         /* Initialize the USB subsystem */
 154         USB_Init();
 155         LEDs_Init();
 156
 157         /* Bootloader active LED toggle timer initialization */
 158         TIMSK1 = (1 << TOIE1);
 159         TCCR1B = ((1 << CS11) | (1 << CS10));
 160 }
 161
 162 /** Resets all configured hardware required for the bootloader back to their original states. */
 163 void ResetHardware(void)
 164 {
 165         /* Shut down the USB subsystem */
 166         USB_Disable();
 167
 168         /* Relocate the interrupt vector table back to the application section */
 169         MCUCR = (1 << IVCE);
 170         MCUCR = 0;
 171 }
 172
 173 /** ISR to periodically toggle the LEDs on the board to indicate that the bootloader is active. */
 174 ISR(TIMER1_OVF_vect, ISR_BLOCK)
 175 {
 176         LEDs_ToggleLEDs(LEDS_LED1 | LEDS_LED2);
 177 }
 178
 179 /** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
 180  *  the device from the USB host before passing along unhandled control requests to the library for processing
 181  *  internally.
 182  */
 183 void EVENT_USB_Device_ControlRequest(void)
 184 {
 185         /* Ignore any requests that aren't directed to the DFU interface */
 186         if ((USB_ControlRequest.bmRequestType & (CONTROL_REQTYPE_TYPE | CONTROL_REQTYPE_RECIPIENT)) !=
 187             (REQTYPE_CLASS | REQREC_INTERFACE))
 188         {
 189                 return;
 190         }
 191
 192         /* Activity - toggle indicator LEDs */
 193         LEDs_ToggleLEDs(LEDS_LED1 | LEDS_LED2);
 194
 195         /* Get the size of the command and data from the wLength value */
 196         SentCommand.DataSize = USB_ControlRequest.wLength;
 197
 198         switch (USB_ControlRequest.bRequest)
 199         {
 200                 case DFU_REQ_DNLOAD:
 201                         Endpoint_ClearSETUP();
 202
 203                         /* Check if bootloader is waiting to terminate */
 204                         if (WaitForExit)
 205                         {
 206                                 /* Bootloader is terminating - process last received command */
 207                                 ProcessBootloaderCommand();
 208
 209                                 /* Indicate that the last command has now been processed - free to exit bootloader */
 210                                 WaitForExit = false;
 211                         }
 212
 213                         /* If the request has a data stage, load it into the command struct */
 214                         if (SentCommand.DataSize)
 215                         {
 216                                 while (!(Endpoint_IsOUTReceived()))
 217                                 {
 218                                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 219                                           return;
 220                                 }
 221
 222                                 /* First byte of the data stage is the DNLOAD request's command */
 223                                 SentCommand.Command = Endpoint_Read_8();
 224
 225                                 /* One byte of the data stage is the command, so subtract it from the total data bytes */
 226                                 SentCommand.DataSize--;
 227
 228                                 /* Load in the rest of the data stage as command parameters */
 229                                 for (uint8_t DataByte = 0; (DataByte < sizeof(SentCommand.Data)) &&
 230                                      Endpoint_BytesInEndpoint(); DataByte++)
 231                                 {
 232                                         SentCommand.Data[DataByte] = Endpoint_Read_8();
 233                                         SentCommand.DataSize--;
 234                                 }
 235
 236                                 /* Process the command */
 237                                 ProcessBootloaderCommand();
 238                         }
 239
 240                         /* Check if currently downloading firmware */
 241                         if (DFU_State == dfuDNLOAD_IDLE)
 242                         {
 243                                 if (!(SentCommand.DataSize))
 244                                 {
 245                                         DFU_State = dfuIDLE;
 246                                 }
 247                                 else
 248                                 {
 249                                         /* Throw away the filler bytes before the start of the firmware */
 250                                         DiscardFillerBytes(DFU_FILLER_BYTES_SIZE);
 251
 252                                         /* Throw away the packet alignment filler bytes before the start of the firmware */
 253                                         DiscardFillerBytes(StartAddr % FIXED_CONTROL_ENDPOINT_SIZE);
 254
 255                                         /* Calculate the number of bytes remaining to be written */
 256                                         uint16_t BytesRemaining = ((EndAddr - StartAddr) + 1);
 257
 258                                         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))        // Write flash
 259                                         {
 260                                                 /* Calculate the number of words to be written from the number of bytes to be written */
 261                                                 uint16_t WordsRemaining = (BytesRemaining >> 1);
 262
 263                                                 union
 264                                                 {
 265                                                         uint16_t Words[2];
 266                                                         uint32_t Long;
 267                                                 } CurrFlashAddress                 = {.Words = {StartAddr, Flash64KBPage}};
 268
 269                                                 uint32_t CurrFlashPageStartAddress = CurrFlashAddress.Long;
 270                                                 uint8_t  WordsInFlashPage          = 0;
 271
 272                                                 while (WordsRemaining--)
 273                                                 {
 274                                                         /* Check if endpoint is empty - if so clear it and wait until ready for next packet */
 275                                                         if (!(Endpoint_BytesInEndpoint()))
 276                                                         {
 277                                                                 Endpoint_ClearOUT();
 278
 279                                                                 while (!(Endpoint_IsOUTReceived()))
 280                                                                 {
 281                                                                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 282                                                                           return;
 283                                                                 }
 284                                                         }
 285
 286                                                         /* Write the next word into the current flash page */
 287                                                         boot_page_fill(CurrFlashAddress.Long, Endpoint_Read_16_LE());
 288
 289                                                         /* Adjust counters */
 290                                                         WordsInFlashPage      += 1;
 291                                                         CurrFlashAddress.Long += 2;
 292
 293                                                         /* See if an entire page has been written to the flash page buffer */
 294                                                         if ((WordsInFlashPage == (SPM_PAGESIZE >> 1)) || !(WordsRemaining))
 295                                                         {
 296                                                                 /* Commit the flash page to memory */
 297                                                                 boot_page_write(CurrFlashPageStartAddress);
 298                                                                 boot_spm_busy_wait();
 299
 300                                                                 /* Check if programming incomplete */
 301                                                                 if (WordsRemaining)
 302                                                                 {
 303                                                                         CurrFlashPageStartAddress = CurrFlashAddress.Long;
 304                                                                         WordsInFlashPage          = 0;
 305
 306                                                                         /* Erase next page's temp buffer */
 307                                                                         boot_page_erase(CurrFlashAddress.Long);
 308                                                                         boot_spm_busy_wait();
 309                                                                 }
 310                                                         }
 311                                                 }
 312
 313                                                 /* Once programming complete, start address equals the end address */
 314                                                 StartAddr = EndAddr;
 315
 316                                                 /* Re-enable the RWW section of flash */
 317                                                 boot_rww_enable();
 318                                         }
 319                                         else                                                   // Write EEPROM
 320                                         {
 321                                                 while (BytesRemaining--)
 322                                                 {
 323                                                         /* Check if endpoint is empty - if so clear it and wait until ready for next packet */
 324                                                         if (!(Endpoint_BytesInEndpoint()))
 325                                                         {
 326                                                                 Endpoint_ClearOUT();
 327
 328                                                                 while (!(Endpoint_IsOUTReceived()))
 329                                                                 {
 330                                                                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 331                                                                           return;
 332                                                                 }
 333                                                         }
 334
 335                                                         /* Read the byte from the USB interface and write to to the EEPROM */
 336                                                         eeprom_write_byte((uint8_t*)StartAddr, Endpoint_Read_8());
 337
 338                                                         /* Adjust counters */
 339                                                         StartAddr++;
 340                                                 }
 341                                         }
 342
 343                                         /* Throw away the currently unused DFU file suffix */
 344                                         DiscardFillerBytes(DFU_FILE_SUFFIX_SIZE);
 345                                 }
 346                         }
 347
 348                         Endpoint_ClearOUT();
 349
 350                         Endpoint_ClearStatusStage();
 351
 352                         break;
 353                 case DFU_REQ_UPLOAD:
 354                         Endpoint_ClearSETUP();
 355
 356                         while (!(Endpoint_IsINReady()))
 357                         {
 358                                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 359                                   return;
 360                         }
 361
 362                         if (DFU_State != dfuUPLOAD_IDLE)
 363                         {
 364                                 if ((DFU_State == dfuERROR) && IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))       // Blank Check
 365                                 {
 366                                         /* Blank checking is performed in the DFU_DNLOAD request - if we get here we've told the host
 367                                            that the memory isn't blank, and the host is requesting the first non-blank address */
 368                                         Endpoint_Write_16_LE(StartAddr);
 369                                 }
 370                                 else
 371                                 {
 372                                         /* Idle state upload - send response to last issued command */
 373                                         Endpoint_Write_8(ResponseByte);
 374                                 }
 375                         }
 376                         else
 377                         {
 378                                 /* Determine the number of bytes remaining in the current block */
 379                                 uint16_t BytesRemaining = ((EndAddr - StartAddr) + 1);
 380
 381                                 if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))            // Read FLASH
 382                                 {
 383                                         /* Calculate the number of words to be written from the number of bytes to be written */
 384                                         uint16_t WordsRemaining = (BytesRemaining >> 1);
 385
 386                                         union
 387                                         {
 388                                                 uint16_t Words[2];
 389                                                 uint32_t Long;
 390                                         } CurrFlashAddress = {.Words = {StartAddr, Flash64KBPage}};
 391
 392                                         while (WordsRemaining--)
 393                                         {
 394                                                 /* Check if endpoint is full - if so clear it and wait until ready for next packet */
 395                                                 if (Endpoint_BytesInEndpoint() == FIXED_CONTROL_ENDPOINT_SIZE)
 396                                                 {
 397                                                         Endpoint_ClearIN();
 398
 399                                                         while (!(Endpoint_IsINReady()))
 400                                                         {
 401                                                                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 402                                                                   return;
 403                                                         }
 404                                                 }
 405
 406                                                 /* Read the flash word and send it via USB to the host */
 407                                                 #if (FLASHEND > 0xFFFF)
 408                                                         Endpoint_Write_16_LE(pgm_read_word_far(CurrFlashAddress.Long));
 409                                                 #else
 410                                                         Endpoint_Write_16_LE(pgm_read_word(CurrFlashAddress.Long));
 411                                                 #endif
 412
 413                                                 /* Adjust counters */
 414                                                 CurrFlashAddress.Long += 2;
 415                                         }
 416
 417                                         /* Once reading is complete, start address equals the end address */
 418                                         StartAddr = EndAddr;
 419                                 }
 420                                 else if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x02))       // Read EEPROM
 421                                 {
 422                                         while (BytesRemaining--)
 423                                         {
 424                                                 /* Check if endpoint is full - if so clear it and wait until ready for next packet */
 425                                                 if (Endpoint_BytesInEndpoint() == FIXED_CONTROL_ENDPOINT_SIZE)
 426                                                 {
 427                                                         Endpoint_ClearIN();
 428
 429                                                         while (!(Endpoint_IsINReady()))
 430                                                         {
 431                                                                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 432                                                                   return;
 433                                                         }
 434                                                 }
 435
 436                                                 /* Read the EEPROM byte and send it via USB to the host */
 437                                                 Endpoint_Write_8(eeprom_read_byte((uint8_t*)StartAddr));
 438
 439                                                 /* Adjust counters */
 440                                                 StartAddr++;
 441                                         }
 442                                 }
 443
 444                                 /* Return to idle state */
 445                                 DFU_State = dfuIDLE;
 446                         }
 447
 448                         Endpoint_ClearIN();
 449
 450                         Endpoint_ClearStatusStage();
 451                         break;
 452                 case DFU_REQ_GETSTATUS:
 453                         Endpoint_ClearSETUP();
 454
 455                         /* Write 8-bit status value */
 456                         Endpoint_Write_8(DFU_Status);
 457
 458                         /* Write 24-bit poll timeout value */
 459                         Endpoint_Write_8(0);
 460                         Endpoint_Write_16_LE(0);
 461
 462                         /* Write 8-bit state value */
 463                         Endpoint_Write_8(DFU_State);
 464
 465                         /* Write 8-bit state string ID number */
 466                         Endpoint_Write_8(0);
 467
 468                         Endpoint_ClearIN();
 469
 470                         Endpoint_ClearStatusStage();
 471                         break;
 472                 case DFU_REQ_CLRSTATUS:
 473                         Endpoint_ClearSETUP();
 474
 475                         /* Reset the status value variable to the default OK status */
 476                         DFU_Status = OK;
 477
 478                         Endpoint_ClearStatusStage();
 479                         break;
 480                 case DFU_REQ_GETSTATE:
 481                         Endpoint_ClearSETUP();
 482
 483                         /* Write the current device state to the endpoint */
 484                         Endpoint_Write_8(DFU_State);
 485
 486                         Endpoint_ClearIN();
 487
 488                         Endpoint_ClearStatusStage();
 489                         break;
 490                 case DFU_REQ_ABORT:
 491                         Endpoint_ClearSETUP();
 492
 493                         /* Reset the current state variable to the default idle state */
 494                         DFU_State = dfuIDLE;
 495
 496                         Endpoint_ClearStatusStage();
 497                         break;
 498         }
 499 }
 500
 501 /** Routine to discard the specified number of bytes from the control endpoint stream. This is used to
 502  *  discard unused bytes in the stream from the host, including the memory program block suffix.
 503  *
 504  *  \param[in] NumberOfBytes  Number of bytes to discard from the host from the control endpoint
 505  */
 506 static void DiscardFillerBytes(uint8_t NumberOfBytes)
 507 {
 508         while (NumberOfBytes--)
 509         {
 510                 if (!(Endpoint_BytesInEndpoint()))
 511                 {
 512                         Endpoint_ClearOUT();
 513
 514                         /* Wait until next data packet received */
 515                         while (!(Endpoint_IsOUTReceived()))
 516                         {
 517                                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 518                                   return;
 519                         }
 520                 }
 521                 else
 522                 {
 523                         Endpoint_Discard_8();
 524                 }
 525         }
 526 }
 527
 528 /** Routine to process an issued command from the host, via a DFU_DNLOAD request wrapper. This routine ensures
 529  *  that the command is allowed based on the current secure mode flag value, and passes the command off to the
 530  *  appropriate handler function.
 531  */
 532 static void ProcessBootloaderCommand(void)
 533 {
 534         /* Check if device is in secure mode */
 535         if (IsSecure)
 536         {
 537                 /* Don't process command unless it is a READ or chip erase command */
 538                 if (!(((SentCommand.Command == COMMAND_WRITE)             &&
 539                         IS_TWOBYTE_COMMAND(SentCommand.Data, 0x00, 0xFF)) ||
 540                            (SentCommand.Command == COMMAND_READ)))
 541                 {
 542                         /* Set the state and status variables to indicate the error */
 543                         DFU_State  = dfuERROR;
 544                         DFU_Status = errWRITE;
 545
 546                         /* Stall command */
 547                         Endpoint_StallTransaction();
 548
 549                         /* Don't process the command */
 550                         return;
 551                 }
 552         }
 553
 554         /* Dispatch the required command processing routine based on the command type */
 555         switch (SentCommand.Command)
 556         {
 557                 case COMMAND_PROG_START:
 558                         ProcessMemProgCommand();
 559                         break;
 560                 case COMMAND_DISP_DATA:
 561                         ProcessMemReadCommand();
 562                         break;
 563                 case COMMAND_WRITE:
 564                         ProcessWriteCommand();
 565                         break;
 566                 case COMMAND_READ:
 567                         ProcessReadCommand();
 568                         break;
 569                 case COMMAND_CHANGE_BASE_ADDR:
 570                         if (IS_TWOBYTE_COMMAND(SentCommand.Data, 0x03, 0x00))              // Set 64KB flash page command
 571                           Flash64KBPage = SentCommand.Data[2];
 572
 573                         break;
 574         }
 575 }
 576
 577 /** Routine to concatenate the given pair of 16-bit memory start and end addresses from the host, and store them
 578  *  in the StartAddr and EndAddr global variables.
 579  */
 580 static void LoadStartEndAddresses(void)
 581 {
 582         union
 583         {
 584                 uint8_t  Bytes[2];
 585                 uint16_t Word;
 586         } Address[2] = {{.Bytes = {SentCommand.Data[2], SentCommand.Data[1]}},
 587                         {.Bytes = {SentCommand.Data[4], SentCommand.Data[3]}}};
 588
 589         /* Load in the start and ending read addresses from the sent data packet */
 590         StartAddr = Address[0].Word;
 591         EndAddr   = Address[1].Word;
 592 }
 593
 594 /** Handler for a Memory Program command issued by the host. This routine handles the preparations needed
 595  *  to write subsequent data from the host into the specified memory.
 596  */
 597 static void ProcessMemProgCommand(void)
 598 {
 599         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00) ||                          // Write FLASH command
 600             IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))                            // Write EEPROM command
 601         {
 602                 /* Load in the start and ending read addresses */
 603                 LoadStartEndAddresses();
 604
 605                 /* If FLASH is being written to, we need to pre-erase the first page to write to */
 606                 if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))
 607                 {
 608                         union
 609                         {
 610                                 uint16_t Words[2];
 611                                 uint32_t Long;
 612                         } CurrFlashAddress = {.Words = {StartAddr, Flash64KBPage}};
 613
 614                         /* Erase the current page's temp buffer */
 615                         boot_page_erase(CurrFlashAddress.Long);
 616                         boot_spm_busy_wait();
 617                 }
 618
 619                 /* Set the state so that the next DNLOAD requests reads in the firmware */
 620                 DFU_State = dfuDNLOAD_IDLE;
 621         }
 622 }
 623
 624 /** Handler for a Memory Read command issued by the host. This routine handles the preparations needed
 625  *  to read subsequent data from the specified memory out to the host, as well as implementing the memory
 626  *  blank check command.
 627  */
 628 static void ProcessMemReadCommand(void)
 629 {
 630         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00) ||                          // Read FLASH command
 631         IS_ONEBYTE_COMMAND(SentCommand.Data, 0x02))                            // Read EEPROM command
 632         {
 633                 /* Load in the start and ending read addresses */
 634                 LoadStartEndAddresses();
 635
 636                 /* Set the state so that the next UPLOAD requests read out the firmware */
 637                 DFU_State = dfuUPLOAD_IDLE;
 638         }
 639         else if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))                       // Blank check FLASH command
 640         {
 641                 uint32_t CurrFlashAddress = 0;
 642
 643                 while (CurrFlashAddress < BOOT_START_ADDR)
 644                 {
 645                         /* Check if the current byte is not blank */
 646                         #if (FLASHEND > 0xFFFF)
 647                         if (pgm_read_byte_far(CurrFlashAddress) != 0xFF)
 648                         #else
 649                         if (pgm_read_byte(CurrFlashAddress) != 0xFF)
 650                         #endif
 651                         {
 652                                 /* Save the location of the first non-blank byte for response back to the host */
 653                                 Flash64KBPage = (CurrFlashAddress >> 16);
 654                                 StartAddr     = CurrFlashAddress;
 655
 656                                 /* Set state and status variables to the appropriate error values */
 657                                 DFU_State  = dfuERROR;
 658                                 DFU_Status = errCHECK_ERASED;
 659
 660                                 break;
 661                         }
 662
 663                         CurrFlashAddress++;
 664                 }
 665         }
 666 }
 667
 668 /** Handler for a Data Write command issued by the host. This routine handles non-programming commands such as
 669  *  bootloader exit (both via software jumps and hardware watchdog resets) and flash memory erasure.
 670  */
 671 static void ProcessWriteCommand(void)
 672 {
 673         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x03))                            // Start application
 674         {
 675                 /* Indicate that the bootloader is terminating */
 676                 WaitForExit = true;
 677
 678                 /* Check if data supplied for the Start Program command - no data executes the program */
 679                 if (SentCommand.DataSize)
 680                 {
 681                         if (SentCommand.Data[1] == 0x01)                                   // Start via jump
 682                         {
 683                                 union
 684                                 {
 685                                         uint8_t  Bytes[2];
 686                                         AppPtr_t FuncPtr;
 687                                 } Address = {.Bytes = {SentCommand.Data[4], SentCommand.Data[3]}};
 688
 689                                 /* Load in the jump address into the application start address pointer */
 690                                 AppStartPtr = Address.FuncPtr;
 691                         }
 692                 }
 693                 else
 694                 {
 695                         if (SentCommand.Data[1] == 0x00)                                   // Start via watchdog
 696                         {
 697                                 /* Start the watchdog to reset the AVR once the communications are finalized */
 698                                 wdt_enable(WDTO_250MS);
 699                         }
 700                         else                                                               // Start via jump
 701                         {
 702                                 /* Set the flag to terminate the bootloader at next opportunity */
 703                                 RunBootloader = false;
 704                         }
 705                 }
 706         }
 707         else if (IS_TWOBYTE_COMMAND(SentCommand.Data, 0x00, 0xFF))                 // Erase flash
 708         {
 709                 uint32_t CurrFlashAddress = 0;
 710
 711                 /* Clear the application section of flash */
 712                 while (CurrFlashAddress < BOOT_START_ADDR)
 713                 {
 714                         boot_page_erase(CurrFlashAddress);
 715                         boot_spm_busy_wait();
 716                         boot_page_write(CurrFlashAddress);
 717                         boot_spm_busy_wait();
 718
 719                         CurrFlashAddress += SPM_PAGESIZE;
 720                 }
 721
 722                 /* Re-enable the RWW section of flash as writing to the flash locks it out */
 723                 boot_rww_enable();
 724
 725                 /* Memory has been erased, reset the security bit so that programming/reading is allowed */
 726                 IsSecure = false;
 727         }
 728 }
 729
 730 /** Handler for a Data Read command issued by the host. This routine handles bootloader information retrieval
 731  *  commands such as device signature and bootloader version retrieval.
 732  */
 733 static void ProcessReadCommand(void)
 734 {
 735         const uint8_t BootloaderInfo[3] = {BOOTLOADER_VERSION, BOOTLOADER_ID_BYTE1, BOOTLOADER_ID_BYTE2};
 736         const uint8_t SignatureInfo[3]  = {AVR_SIGNATURE_1,    AVR_SIGNATURE_2,     AVR_SIGNATURE_3};
 737
 738         uint8_t DataIndexToRead = SentCommand.Data[1];
 739
 740         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))                         // Read bootloader info
 741           ResponseByte = BootloaderInfo[DataIndexToRead];
 742         else if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))                    // Read signature byte
 743           ResponseByte = SignatureInfo[DataIndexToRead - 0x30];
 744 }
 745