Bootloaders/DFU/BootloaderDFU.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2012.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2012  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 static 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 and other board hardware drivers */
 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 static void ResetHardware(void)
 164 {
 165         /* Shut down the USB and other board hardware drivers */
 166         USB_Disable();
 167         LEDs_Disable();
 168
 169         /* Relocate the interrupt vector table back to the application section */
 170         MCUCR = (1 << IVCE);
 171         MCUCR = 0;
 172 }
 173
 174 /** ISR to periodically toggle the LEDs on the board to indicate that the bootloader is active. */
 175 ISR(TIMER1_OVF_vect, ISR_BLOCK)
 176 {
 177         LEDs_ToggleLEDs(LEDS_LED1 | LEDS_LED2);
 178 }
 179
 180 /** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
 181  *  the device from the USB host before passing along unhandled control requests to the library for processing
 182  *  internally.
 183  */
 184 void EVENT_USB_Device_ControlRequest(void)
 185 {
 186         /* Ignore any requests that aren't directed to the DFU interface */
 187         if ((USB_ControlRequest.bmRequestType & (CONTROL_REQTYPE_TYPE | CONTROL_REQTYPE_RECIPIENT)) !=
 188             (REQTYPE_CLASS | REQREC_INTERFACE))
 189         {
 190                 return;
 191         }
 192
 193         /* Activity - toggle indicator LEDs */
 194         LEDs_ToggleLEDs(LEDS_LED1 | LEDS_LED2);
 195
 196         /* Get the size of the command and data from the wLength value */
 197         SentCommand.DataSize = USB_ControlRequest.wLength;
 198
 199         switch (USB_ControlRequest.bRequest)
 200         {
 201                 case DFU_REQ_DNLOAD:
 202                         Endpoint_ClearSETUP();
 203
 204                         /* Check if bootloader is waiting to terminate */
 205                         if (WaitForExit)
 206                         {
 207                                 /* Bootloader is terminating - process last received command */
 208                                 ProcessBootloaderCommand();
 209
 210                                 /* Indicate that the last command has now been processed - free to exit bootloader */
 211                                 WaitForExit = false;
 212                         }
 213
 214                         /* If the request has a data stage, load it into the command struct */
 215                         if (SentCommand.DataSize)
 216                         {
 217                                 while (!(Endpoint_IsOUTReceived()))
 218                                 {
 219                                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 220                                           return;
 221                                 }
 222
 223                                 /* First byte of the data stage is the DNLOAD request's command */
 224                                 SentCommand.Command = Endpoint_Read_8();
 225
 226                                 /* One byte of the data stage is the command, so subtract it from the total data bytes */
 227                                 SentCommand.DataSize--;
 228
 229                                 /* Load in the rest of the data stage as command parameters */
 230                                 for (uint8_t DataByte = 0; (DataByte < sizeof(SentCommand.Data)) &&
 231                                      Endpoint_BytesInEndpoint(); DataByte++)
 232                                 {
 233                                         SentCommand.Data[DataByte] = Endpoint_Read_8();
 234                                         SentCommand.DataSize--;
 235                                 }
 236
 237                                 /* Process the command */
 238                                 ProcessBootloaderCommand();
 239                         }
 240
 241                         /* Check if currently downloading firmware */
 242                         if (DFU_State == dfuDNLOAD_IDLE)
 243                         {
 244                                 if (!(SentCommand.DataSize))
 245                                 {
 246                                         DFU_State = dfuIDLE;
 247                                 }
 248                                 else
 249                                 {
 250                                         /* Throw away the filler bytes before the start of the firmware */
 251                                         DiscardFillerBytes(DFU_FILLER_BYTES_SIZE);
 252
 253                                         /* Throw away the packet alignment filler bytes before the start of the firmware */
 254                                         DiscardFillerBytes(StartAddr % FIXED_CONTROL_ENDPOINT_SIZE);
 255
 256                                         /* Calculate the number of bytes remaining to be written */
 257                                         uint16_t BytesRemaining = ((EndAddr - StartAddr) + 1);
 258
 259                                         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))        // Write flash
 260                                         {
 261                                                 /* Calculate the number of words to be written from the number of bytes to be written */
 262                                                 uint16_t WordsRemaining = (BytesRemaining >> 1);
 263
 264                                                 union
 265                                                 {
 266                                                         uint16_t Words[2];
 267                                                         uint32_t Long;
 268                                                 } CurrFlashAddress                 = {.Words = {StartAddr, Flash64KBPage}};
 269
 270                                                 uint32_t CurrFlashPageStartAddress = CurrFlashAddress.Long;
 271                                                 uint8_t  WordsInFlashPage          = 0;
 272
 273                                                 while (WordsRemaining--)
 274                                                 {
 275                                                         /* Check if endpoint is empty - if so clear it and wait until ready for next packet */
 276                                                         if (!(Endpoint_BytesInEndpoint()))
 277                                                         {
 278                                                                 Endpoint_ClearOUT();
 279
 280                                                                 while (!(Endpoint_IsOUTReceived()))
 281                                                                 {
 282                                                                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 283                                                                           return;
 284                                                                 }
 285                                                         }
 286
 287                                                         /* Write the next word into the current flash page */
 288                                                         boot_page_fill(CurrFlashAddress.Long, Endpoint_Read_16_LE());
 289
 290                                                         /* Adjust counters */
 291                                                         WordsInFlashPage      += 1;
 292                                                         CurrFlashAddress.Long += 2;
 293
 294                                                         /* See if an entire page has been written to the flash page buffer */
 295                                                         if ((WordsInFlashPage == (SPM_PAGESIZE >> 1)) || !(WordsRemaining))
 296                                                         {
 297                                                                 /* Commit the flash page to memory */
 298                                                                 boot_page_write(CurrFlashPageStartAddress);
 299                                                                 boot_spm_busy_wait();
 300
 301                                                                 /* Check if programming incomplete */
 302                                                                 if (WordsRemaining)
 303                                                                 {
 304                                                                         CurrFlashPageStartAddress = CurrFlashAddress.Long;
 305                                                                         WordsInFlashPage          = 0;
 306
 307                                                                         /* Erase next page's temp buffer */
 308                                                                         boot_page_erase(CurrFlashAddress.Long);
 309                                                                         boot_spm_busy_wait();
 310                                                                 }
 311                                                         }
 312                                                 }
 313
 314                                                 /* Once programming complete, start address equals the end address */
 315                                                 StartAddr = EndAddr;
 316
 317                                                 /* Re-enable the RWW section of flash */
 318                                                 boot_rww_enable();
 319                                         }
 320                                         else                                                   // Write EEPROM
 321                                         {
 322                                                 while (BytesRemaining--)
 323                                                 {
 324                                                         /* Check if endpoint is empty - if so clear it and wait until ready for next packet */
 325                                                         if (!(Endpoint_BytesInEndpoint()))
 326                                                         {
 327                                                                 Endpoint_ClearOUT();
 328
 329                                                                 while (!(Endpoint_IsOUTReceived()))
 330                                                                 {
 331                                                                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 332                                                                           return;
 333                                                                 }
 334                                                         }
 335
 336                                                         /* Read the byte from the USB interface and write to to the EEPROM */
 337                                                         eeprom_write_byte((uint8_t*)StartAddr, Endpoint_Read_8());
 338
 339                                                         /* Adjust counters */
 340                                                         StartAddr++;
 341                                                 }
 342                                         }
 343
 344                                         /* Throw away the currently unused DFU file suffix */
 345                                         DiscardFillerBytes(DFU_FILE_SUFFIX_SIZE);
 346                                 }
 347                         }
 348
 349                         Endpoint_ClearOUT();
 350
 351                         Endpoint_ClearStatusStage();
 352
 353                         break;
 354                 case DFU_REQ_UPLOAD:
 355                         Endpoint_ClearSETUP();
 356
 357                         while (!(Endpoint_IsINReady()))
 358                         {
 359                                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 360                                   return;
 361                         }
 362
 363                         if (DFU_State != dfuUPLOAD_IDLE)
 364                         {
 365                                 if ((DFU_State == dfuERROR) && IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))       // Blank Check
 366                                 {
 367                                         /* Blank checking is performed in the DFU_DNLOAD request - if we get here we've told the host
 368                                            that the memory isn't blank, and the host is requesting the first non-blank address */
 369                                         Endpoint_Write_16_LE(StartAddr);
 370                                 }
 371                                 else
 372                                 {
 373                                         /* Idle state upload - send response to last issued command */
 374                                         Endpoint_Write_8(ResponseByte);
 375                                 }
 376                         }
 377                         else
 378                         {
 379                                 /* Determine the number of bytes remaining in the current block */
 380                                 uint16_t BytesRemaining = ((EndAddr - StartAddr) + 1);
 381
 382                                 if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))            // Read FLASH
 383                                 {
 384                                         /* Calculate the number of words to be written from the number of bytes to be written */
 385                                         uint16_t WordsRemaining = (BytesRemaining >> 1);
 386
 387                                         union
 388                                         {
 389                                                 uint16_t Words[2];
 390                                                 uint32_t Long;
 391                                         } CurrFlashAddress = {.Words = {StartAddr, Flash64KBPage}};
 392
 393                                         while (WordsRemaining--)
 394                                         {
 395                                                 /* Check if endpoint is full - if so clear it and wait until ready for next packet */
 396                                                 if (Endpoint_BytesInEndpoint() == FIXED_CONTROL_ENDPOINT_SIZE)
 397                                                 {
 398                                                         Endpoint_ClearIN();
 399
 400                                                         while (!(Endpoint_IsINReady()))
 401                                                         {
 402                                                                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 403                                                                   return;
 404                                                         }
 405                                                 }
 406
 407                                                 /* Read the flash word and send it via USB to the host */
 408                                                 #if (FLASHEND > 0xFFFF)
 409                                                         Endpoint_Write_16_LE(pgm_read_word_far(CurrFlashAddress.Long));
 410                                                 #else
 411                                                         Endpoint_Write_16_LE(pgm_read_word(CurrFlashAddress.Long));
 412                                                 #endif
 413
 414                                                 /* Adjust counters */
 415                                                 CurrFlashAddress.Long += 2;
 416                                         }
 417
 418                                         /* Once reading is complete, start address equals the end address */
 419                                         StartAddr = EndAddr;
 420                                 }
 421                                 else if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x02))       // Read EEPROM
 422                                 {
 423                                         while (BytesRemaining--)
 424                                         {
 425                                                 /* Check if endpoint is full - if so clear it and wait until ready for next packet */
 426                                                 if (Endpoint_BytesInEndpoint() == FIXED_CONTROL_ENDPOINT_SIZE)
 427                                                 {
 428                                                         Endpoint_ClearIN();
 429
 430                                                         while (!(Endpoint_IsINReady()))
 431                                                         {
 432                                                                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 433                                                                   return;
 434                                                         }
 435                                                 }
 436
 437                                                 /* Read the EEPROM byte and send it via USB to the host */
 438                                                 Endpoint_Write_8(eeprom_read_byte((uint8_t*)StartAddr));
 439
 440                                                 /* Adjust counters */
 441                                                 StartAddr++;
 442                                         }
 443                                 }
 444
 445                                 /* Return to idle state */
 446                                 DFU_State = dfuIDLE;
 447                         }
 448
 449                         Endpoint_ClearIN();
 450
 451                         Endpoint_ClearStatusStage();
 452                         break;
 453                 case DFU_REQ_GETSTATUS:
 454                         Endpoint_ClearSETUP();
 455
 456                         /* Write 8-bit status value */
 457                         Endpoint_Write_8(DFU_Status);
 458
 459                         /* Write 24-bit poll timeout value */
 460                         Endpoint_Write_8(0);
 461                         Endpoint_Write_16_LE(0);
 462
 463                         /* Write 8-bit state value */
 464                         Endpoint_Write_8(DFU_State);
 465
 466                         /* Write 8-bit state string ID number */
 467                         Endpoint_Write_8(0);
 468
 469                         Endpoint_ClearIN();
 470
 471                         Endpoint_ClearStatusStage();
 472                         break;
 473                 case DFU_REQ_CLRSTATUS:
 474                         Endpoint_ClearSETUP();
 475
 476                         /* Reset the status value variable to the default OK status */
 477                         DFU_Status = OK;
 478
 479                         Endpoint_ClearStatusStage();
 480                         break;
 481                 case DFU_REQ_GETSTATE:
 482                         Endpoint_ClearSETUP();
 483
 484                         /* Write the current device state to the endpoint */
 485                         Endpoint_Write_8(DFU_State);
 486
 487                         Endpoint_ClearIN();
 488
 489                         Endpoint_ClearStatusStage();
 490                         break;
 491                 case DFU_REQ_ABORT:
 492                         Endpoint_ClearSETUP();
 493
 494                         /* Reset the current state variable to the default idle state */
 495                         DFU_State = dfuIDLE;
 496
 497                         Endpoint_ClearStatusStage();
 498                         break;
 499         }
 500 }
 501
 502 /** Routine to discard the specified number of bytes from the control endpoint stream. This is used to
 503  *  discard unused bytes in the stream from the host, including the memory program block suffix.
 504  *
 505  *  \param[in] NumberOfBytes  Number of bytes to discard from the host from the control endpoint
 506  */
 507 static void DiscardFillerBytes(uint8_t NumberOfBytes)
 508 {
 509         while (NumberOfBytes--)
 510         {
 511                 if (!(Endpoint_BytesInEndpoint()))
 512                 {
 513                         Endpoint_ClearOUT();
 514
 515                         /* Wait until next data packet received */
 516                         while (!(Endpoint_IsOUTReceived()))
 517                         {
 518                                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 519                                   return;
 520                         }
 521                 }
 522                 else
 523                 {
 524                         Endpoint_Discard_8();
 525                 }
 526         }
 527 }
 528
 529 /** Routine to process an issued command from the host, via a DFU_DNLOAD request wrapper. This routine ensures
 530  *  that the command is allowed based on the current secure mode flag value, and passes the command off to the
 531  *  appropriate handler function.
 532  */
 533 static void ProcessBootloaderCommand(void)
 534 {
 535         /* Check if device is in secure mode */
 536         if (IsSecure)
 537         {
 538                 /* Don't process command unless it is a READ or chip erase command */
 539                 if (!(((SentCommand.Command == COMMAND_WRITE)             &&
 540                         IS_TWOBYTE_COMMAND(SentCommand.Data, 0x00, 0xFF)) ||
 541                            (SentCommand.Command == COMMAND_READ)))
 542                 {
 543                         /* Set the state and status variables to indicate the error */
 544                         DFU_State  = dfuERROR;
 545                         DFU_Status = errWRITE;
 546
 547                         /* Stall command */
 548                         Endpoint_StallTransaction();
 549
 550                         /* Don't process the command */
 551                         return;
 552                 }
 553         }
 554
 555         /* Dispatch the required command processing routine based on the command type */
 556         switch (SentCommand.Command)
 557         {
 558                 case COMMAND_PROG_START:
 559                         ProcessMemProgCommand();
 560                         break;
 561                 case COMMAND_DISP_DATA:
 562                         ProcessMemReadCommand();
 563                         break;
 564                 case COMMAND_WRITE:
 565                         ProcessWriteCommand();
 566                         break;
 567                 case COMMAND_READ:
 568                         ProcessReadCommand();
 569                         break;
 570                 case COMMAND_CHANGE_BASE_ADDR:
 571                         if (IS_TWOBYTE_COMMAND(SentCommand.Data, 0x03, 0x00))              // Set 64KB flash page command
 572                           Flash64KBPage = SentCommand.Data[2];
 573
 574                         break;
 575         }
 576 }
 577
 578 /** Routine to concatenate the given pair of 16-bit memory start and end addresses from the host, and store them
 579  *  in the StartAddr and EndAddr global variables.
 580  */
 581 static void LoadStartEndAddresses(void)
 582 {
 583         union
 584         {
 585                 uint8_t  Bytes[2];
 586                 uint16_t Word;
 587         } Address[2] = {{.Bytes = {SentCommand.Data[2], SentCommand.Data[1]}},
 588                         {.Bytes = {SentCommand.Data[4], SentCommand.Data[3]}}};
 589
 590         /* Load in the start and ending read addresses from the sent data packet */
 591         StartAddr = Address[0].Word;
 592         EndAddr   = Address[1].Word;
 593 }
 594
 595 /** Handler for a Memory Program command issued by the host. This routine handles the preparations needed
 596  *  to write subsequent data from the host into the specified memory.
 597  */
 598 static void ProcessMemProgCommand(void)
 599 {
 600         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00) ||                          // Write FLASH command
 601             IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))                            // Write EEPROM command
 602         {
 603                 /* Load in the start and ending read addresses */
 604                 LoadStartEndAddresses();
 605
 606                 /* If FLASH is being written to, we need to pre-erase the first page to write to */
 607                 if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))
 608                 {
 609                         union
 610                         {
 611                                 uint16_t Words[2];
 612                                 uint32_t Long;
 613                         } CurrFlashAddress = {.Words = {StartAddr, Flash64KBPage}};
 614
 615                         /* Erase the current page's temp buffer */
 616                         boot_page_erase(CurrFlashAddress.Long);
 617                         boot_spm_busy_wait();
 618                 }
 619
 620                 /* Set the state so that the next DNLOAD requests reads in the firmware */
 621                 DFU_State = dfuDNLOAD_IDLE;
 622         }
 623 }
 624
 625 /** Handler for a Memory Read command issued by the host. This routine handles the preparations needed
 626  *  to read subsequent data from the specified memory out to the host, as well as implementing the memory
 627  *  blank check command.
 628  */
 629 static void ProcessMemReadCommand(void)
 630 {
 631         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00) ||                          // Read FLASH command
 632         IS_ONEBYTE_COMMAND(SentCommand.Data, 0x02))                            // Read EEPROM command
 633         {
 634                 /* Load in the start and ending read addresses */
 635                 LoadStartEndAddresses();
 636
 637                 /* Set the state so that the next UPLOAD requests read out the firmware */
 638                 DFU_State = dfuUPLOAD_IDLE;
 639         }
 640         else if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))                       // Blank check FLASH command
 641         {
 642                 uint32_t CurrFlashAddress = 0;
 643
 644                 while (CurrFlashAddress < BOOT_START_ADDR)
 645                 {
 646                         /* Check if the current byte is not blank */
 647                         #if (FLASHEND > 0xFFFF)
 648                         if (pgm_read_byte_far(CurrFlashAddress) != 0xFF)
 649                         #else
 650                         if (pgm_read_byte(CurrFlashAddress) != 0xFF)
 651                         #endif
 652                         {
 653                                 /* Save the location of the first non-blank byte for response back to the host */
 654                                 Flash64KBPage = (CurrFlashAddress >> 16);
 655                                 StartAddr     = CurrFlashAddress;
 656
 657                                 /* Set state and status variables to the appropriate error values */
 658                                 DFU_State  = dfuERROR;
 659                                 DFU_Status = errCHECK_ERASED;
 660
 661                                 break;
 662                         }
 663
 664                         CurrFlashAddress++;
 665                 }
 666         }
 667 }
 668
 669 /** Handler for a Data Write command issued by the host. This routine handles non-programming commands such as
 670  *  bootloader exit (both via software jumps and hardware watchdog resets) and flash memory erasure.
 671  */
 672 static void ProcessWriteCommand(void)
 673 {
 674         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x03))                            // Start application
 675         {
 676                 /* Indicate that the bootloader is terminating */
 677                 WaitForExit = true;
 678
 679                 /* Check if data supplied for the Start Program command - no data executes the program */
 680                 if (SentCommand.DataSize)
 681                 {
 682                         if (SentCommand.Data[1] == 0x01)                                   // Start via jump
 683                         {
 684                                 union
 685                                 {
 686                                         uint8_t  Bytes[2];
 687                                         AppPtr_t FuncPtr;
 688                                 } Address = {.Bytes = {SentCommand.Data[4], SentCommand.Data[3]}};
 689
 690                                 /* Load in the jump address into the application start address pointer */
 691                                 AppStartPtr = Address.FuncPtr;
 692                         }
 693                 }
 694                 else
 695                 {
 696                         if (SentCommand.Data[1] == 0x00)                                   // Start via watchdog
 697                         {
 698                                 /* Start the watchdog to reset the AVR once the communications are finalized */
 699                                 wdt_enable(WDTO_250MS);
 700                         }
 701                         else                                                               // Start via jump
 702                         {
 703                                 /* Set the flag to terminate the bootloader at next opportunity */
 704                                 RunBootloader = false;
 705                         }
 706                 }
 707         }
 708         else if (IS_TWOBYTE_COMMAND(SentCommand.Data, 0x00, 0xFF))                 // Erase flash
 709         {
 710                 uint32_t CurrFlashAddress = 0;
 711
 712                 /* Clear the application section of flash */
 713                 while (CurrFlashAddress < BOOT_START_ADDR)
 714                 {
 715                         boot_page_erase(CurrFlashAddress);
 716                         boot_spm_busy_wait();
 717                         boot_page_write(CurrFlashAddress);
 718                         boot_spm_busy_wait();
 719
 720                         CurrFlashAddress += SPM_PAGESIZE;
 721                 }
 722
 723                 /* Re-enable the RWW section of flash as writing to the flash locks it out */
 724                 boot_rww_enable();
 725
 726                 /* Memory has been erased, reset the security bit so that programming/reading is allowed */
 727                 IsSecure = false;
 728         }
 729 }
 730
 731 /** Handler for a Data Read command issued by the host. This routine handles bootloader information retrieval
 732  *  commands such as device signature and bootloader version retrieval.
 733  */
 734 static void ProcessReadCommand(void)
 735 {
 736         const uint8_t BootloaderInfo[3] = {BOOTLOADER_VERSION, BOOTLOADER_ID_BYTE1, BOOTLOADER_ID_BYTE2};
 737         const uint8_t SignatureInfo[3]  = {AVR_SIGNATURE_1,    AVR_SIGNATURE_2,     AVR_SIGNATURE_3};
 738
 739         uint8_t DataIndexToRead = SentCommand.Data[1];
 740
 741         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))                         // Read bootloader info
 742           ResponseByte = BootloaderInfo[DataIndexToRead];
 743         else if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))                    // Read signature byte
 744           ResponseByte = SignatureInfo[DataIndexToRead - 0x30];
 745 }
 746