Bootloaders/DFU/BootloaderDFU.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2009.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, and distribute this software
  13   and its documentation for any purpose and without fee is hereby
  14   granted, provided that the above copyright notice appear in all
  15   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.
  42  */
  43 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 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 bool WaitForExit = false;
  57
  58 /** Current DFU state machine state, one of the values in the DFU_State_t enum. */
  59 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 uint8_t DFU_Status = OK;
  65
  66 /** Data containing the DFU command sent from the host. */
  67 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 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 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 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 uint16_t StartAddr = 0x0000;
  89
  90 /** Memory end address, indicating the end address to read to/write from in the memory being addressed (either FLASH
  91  *  of EEPROM depending on the issued command from the host).
  92  */
  93 uint16_t EndAddr = 0x0000;
  94
  95 /** Main program entry point. This routine configures the hardware required by the bootloader, then continuously
  96  *  runs the bootloader processing routine until instructed to soft-exit, or hard-reset via the watchdog to start
  97  *  the loaded application code.
  98  */
  99 int main(void)
 100 {
 101         /* Configure hardware required by the bootloader */
 102         SetupHardware();
 103
 104         /* Run the USB management task while the bootloader is supposed to be running */
 105         while (RunBootloader || WaitForExit)
 106           USB_USBTask();
 107
 108         /* Reset configured hardware back to their original states for the user application */
 109         ResetHardware();
 110
 111         /* Start the user application */
 112         AppStartPtr();
 113 }
 114
 115 /** Configures all hardware required for the bootloader. */
 116 void SetupHardware(void)
 117 {
 118         /* Disable watchdog if enabled by bootloader/fuses */
 119         MCUSR &= ~(1 << WDRF);
 120         wdt_disable();
 121
 122         /* Disable clock division */
 123         clock_prescale_set(clock_div_1);
 124
 125         /* Relocate the interrupt vector table to the bootloader section */
 126         MCUCR = (1 << IVCE);
 127         MCUCR = (1 << IVSEL);
 128
 129         /* Initialize the USB subsystem */
 130         USB_Init();
 131 }
 132
 133 /** Resets all configured hardware required for the bootloader back to their original states. */
 134 void ResetHardware(void)
 135 {
 136         /* Shut down the USB subsystem */
 137         USB_ShutDown();
 138
 139         /* Relocate the interrupt vector table back to the application section */
 140         MCUCR = (1 << IVCE);
 141         MCUCR = 0;
 142 }
 143
 144 /** Event handler for the USB_Disconnect event. This indicates that the bootloader should exit and the user
 145  *  application started.
 146  */
 147 void EVENT_USB_Disconnect(void)
 148 {
 149         /* Upon disconnection, run user application */
 150         RunBootloader = false;
 151 }
 152
 153 /** Event handler for the USB_UnhandledControlPacket event. This is used to catch standard and class specific
 154  *  control requests that are not handled internally by the USB library (including the DFU commands, which are
 155  *  all issued via the control endpoint), so that they can be handled appropriately for the application.
 156  */
 157 void EVENT_USB_UnhandledControlPacket(void)
 158 {
 159         /* Get the size of the command and data from the wLength value */
 160         SentCommand.DataSize = USB_ControlRequest.wLength;
 161
 162         switch (USB_ControlRequest.bRequest)
 163         {
 164                 case DFU_DNLOAD:
 165                         Endpoint_ClearSETUP();
 166
 167                         /* Check if bootloader is waiting to terminate */
 168                         if (WaitForExit)
 169                         {
 170                                 /* Bootloader is terminating - process last received command */
 171                                 ProcessBootloaderCommand();
 172
 173                                 /* Indicate that the last command has now been processed - free to exit bootloader */
 174                                 WaitForExit = false;
 175                         }
 176
 177                         /* If the request has a data stage, load it into the command struct */
 178                         if (SentCommand.DataSize)
 179                         {
 180                                 while (!(Endpoint_IsOUTReceived()))
 181                                 {
 182                                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 183                                           return;
 184                                 }
 185
 186                                 /* First byte of the data stage is the DNLOAD request's command */
 187                                 SentCommand.Command = Endpoint_Read_Byte();
 188
 189                                 /* One byte of the data stage is the command, so subtract it from the total data bytes */
 190                                 SentCommand.DataSize--;
 191
 192                                 /* Load in the rest of the data stage as command parameters */
 193                                 for (uint8_t DataByte = 0; (DataByte < sizeof(SentCommand.Data)) &&
 194                                      Endpoint_BytesInEndpoint(); DataByte++)
 195                                 {
 196                                         SentCommand.Data[DataByte] = Endpoint_Read_Byte();
 197                                         SentCommand.DataSize--;
 198                                 }
 199
 200                                 /* Process the command */
 201                                 ProcessBootloaderCommand();
 202                         }
 203
 204                         /* Check if currently downloading firmware */
 205                         if (DFU_State == dfuDNLOAD_IDLE)
 206                         {
 207                                 if (!(SentCommand.DataSize))
 208                                 {
 209                                         DFU_State = dfuIDLE;
 210                                 }
 211                                 else
 212                                 {
 213                                         /* Throw away the filler bytes before the start of the firmware */
 214                                         DiscardFillerBytes(DFU_FILLER_BYTES_SIZE);
 215
 216                                         /* Throw away the page alignment filler bytes before the start of the firmware */
 217                                         DiscardFillerBytes(StartAddr % SPM_PAGESIZE);
 218
 219                                         /* Calculate the number of bytes remaining to be written */
 220                                         uint16_t BytesRemaining = ((EndAddr - StartAddr) + 1);
 221
 222                                         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))        // Write flash
 223                                         {
 224                                                 /* Calculate the number of words to be written from the number of bytes to be written */
 225                                                 uint16_t WordsRemaining = (BytesRemaining >> 1);
 226
 227                                                 union
 228                                                 {
 229                                                         uint16_t Words[2];
 230                                                         uint32_t Long;
 231                                                 } CurrFlashAddress                 = {.Words = {StartAddr, Flash64KBPage}};
 232
 233                                                 uint32_t CurrFlashPageStartAddress = CurrFlashAddress.Long;
 234                                                 uint8_t  WordsInFlashPage          = 0;
 235
 236                                                 while (WordsRemaining--)
 237                                                 {
 238                                                         /* Check if endpoint is empty - if so clear it and wait until ready for next packet */
 239                                                         if (!(Endpoint_BytesInEndpoint()))
 240                                                         {
 241                                                                 Endpoint_ClearOUT();
 242
 243                                                                 while (!(Endpoint_IsOUTReceived()))
 244                                                                 {
 245                                                                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 246                                                                           return;
 247                                                                 }
 248                                                         }
 249
 250                                                         /* Write the next word into the current flash page */
 251                                                         boot_page_fill(CurrFlashAddress.Long, Endpoint_Read_Word_LE());
 252
 253                                                         /* Adjust counters */
 254                                                         WordsInFlashPage      += 1;
 255                                                         CurrFlashAddress.Long += 2;
 256
 257                                                         /* See if an entire page has been written to the flash page buffer */
 258                                                         if ((WordsInFlashPage == (SPM_PAGESIZE >> 1)) || !(WordsRemaining))
 259                                                         {
 260                                                                 /* Commit the flash page to memory */
 261                                                                 boot_page_write(CurrFlashPageStartAddress);
 262                                                                 boot_spm_busy_wait();
 263
 264                                                                 /* Check if programming incomplete */
 265                                                                 if (WordsRemaining)
 266                                                                 {
 267                                                                         CurrFlashPageStartAddress = CurrFlashAddress.Long;
 268                                                                         WordsInFlashPage          = 0;
 269
 270                                                                         /* Erase next page's temp buffer */
 271                                                                         boot_page_erase(CurrFlashAddress.Long);
 272                                                                         boot_spm_busy_wait();
 273                                                                 }
 274                                                         }
 275                                                 }
 276
 277                                                 /* Once programming complete, start address equals the end address */
 278                                                 StartAddr = EndAddr;
 279
 280                                                 /* Re-enable the RWW section of flash */
 281                                                 boot_rww_enable();
 282                                         }
 283                                         else                                                   // Write EEPROM
 284                                         {
 285                                                 while (BytesRemaining--)
 286                                                 {
 287                                                         /* Check if endpoint is empty - if so clear it and wait until ready for next packet */
 288                                                         if (!(Endpoint_BytesInEndpoint()))
 289                                                         {
 290                                                                 Endpoint_ClearOUT();
 291
 292                                                                 while (!(Endpoint_IsOUTReceived()))
 293                                                                 {
 294                                                                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 295                                                                           return;
 296                                                                 }
 297                                                         }
 298
 299                                                         /* Read the byte from the USB interface and write to to the EEPROM */
 300                                                         eeprom_write_byte((uint8_t*)StartAddr, Endpoint_Read_Byte());
 301
 302                                                         /* Adjust counters */
 303                                                         StartAddr++;
 304                                                 }
 305                                         }
 306
 307                                         /* Throw away the currently unused DFU file suffix */
 308                                         DiscardFillerBytes(DFU_FILE_SUFFIX_SIZE);
 309                                 }
 310                         }
 311
 312                         Endpoint_ClearOUT();
 313
 314                         Endpoint_ClearStatusStage();
 315
 316                         break;
 317                 case DFU_UPLOAD:
 318                         Endpoint_ClearSETUP();
 319
 320                         while (!(Endpoint_IsINReady()))
 321                         {
 322                                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 323                                   return;
 324                         }
 325
 326                         if (DFU_State != dfuUPLOAD_IDLE)
 327                         {
 328                                 if ((DFU_State == dfuERROR) && IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))       // Blank Check
 329                                 {
 330                                         /* Blank checking is performed in the DFU_DNLOAD request - if we get here we've told the host
 331                                            that the memory isn't blank, and the host is requesting the first non-blank address */
 332                                         Endpoint_Write_Word_LE(StartAddr);
 333                                 }
 334                                 else
 335                                 {
 336                                         /* Idle state upload - send response to last issued command */
 337                                         Endpoint_Write_Byte(ResponseByte);
 338                                 }
 339                         }
 340                         else
 341                         {
 342                                 /* Determine the number of bytes remaining in the current block */
 343                                 uint16_t BytesRemaining = ((EndAddr - StartAddr) + 1);
 344
 345                                 if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))            // Read FLASH
 346                                 {
 347                                         /* Calculate the number of words to be written from the number of bytes to be written */
 348                                         uint16_t WordsRemaining = (BytesRemaining >> 1);
 349
 350                                         union
 351                                         {
 352                                                 uint16_t Words[2];
 353                                                 uint32_t Long;
 354                                         } CurrFlashAddress = {.Words = {StartAddr, Flash64KBPage}};
 355
 356                                         while (WordsRemaining--)
 357                                         {
 358                                                 /* Check if endpoint is full - if so clear it and wait until ready for next packet */
 359                                                 if (Endpoint_BytesInEndpoint() == FIXED_CONTROL_ENDPOINT_SIZE)
 360                                                 {
 361                                                         Endpoint_ClearIN();
 362
 363                                                         while (!(Endpoint_IsINReady()))
 364                                                         {
 365                                                                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 366                                                                   return;
 367                                                         }
 368                                                 }
 369
 370                                                 /* Read the flash word and send it via USB to the host */
 371                                                 #if (FLASHEND > 0xFFFF)
 372                                                         Endpoint_Write_Word_LE(pgm_read_word_far(CurrFlashAddress.Long));
 373                                                 #else
 374                                                         Endpoint_Write_Word_LE(pgm_read_word(CurrFlashAddress.Long));
 375                                                 #endif
 376
 377                                                 /* Adjust counters */
 378                                                 CurrFlashAddress.Long += 2;
 379                                         }
 380
 381                                         /* Once reading is complete, start address equals the end address */
 382                                         StartAddr = EndAddr;
 383                                 }
 384                                 else if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x02))       // Read EEPROM
 385                                 {
 386                                         while (BytesRemaining--)
 387                                         {
 388                                                 /* Check if endpoint is full - if so clear it and wait until ready for next packet */
 389                                                 if (Endpoint_BytesInEndpoint() == FIXED_CONTROL_ENDPOINT_SIZE)
 390                                                 {
 391                                                         Endpoint_ClearIN();
 392
 393                                                         while (!(Endpoint_IsINReady()))
 394                                                         {
 395                                                                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 396                                                                   return;
 397                                                         }
 398                                                 }
 399
 400                                                 /* Read the EEPROM byte and send it via USB to the host */
 401                                                 Endpoint_Write_Byte(eeprom_read_byte((uint8_t*)StartAddr));
 402
 403                                                 /* Adjust counters */
 404                                                 StartAddr++;
 405                                         }
 406                                 }
 407
 408                                 /* Return to idle state */
 409                                 DFU_State = dfuIDLE;
 410                         }
 411
 412                         Endpoint_ClearIN();
 413
 414                         Endpoint_ClearStatusStage();
 415                         break;
 416                 case DFU_GETSTATUS:
 417                         Endpoint_ClearSETUP();
 418
 419                         /* Write 8-bit status value */
 420                         Endpoint_Write_Byte(DFU_Status);
 421
 422                         /* Write 24-bit poll timeout value */
 423                         Endpoint_Write_Byte(0);
 424                         Endpoint_Write_Word_LE(0);
 425
 426                         /* Write 8-bit state value */
 427                         Endpoint_Write_Byte(DFU_State);
 428
 429                         /* Write 8-bit state string ID number */
 430                         Endpoint_Write_Byte(0);
 431
 432                         Endpoint_ClearIN();
 433
 434                         Endpoint_ClearStatusStage();
 435                         break;
 436                 case DFU_CLRSTATUS:
 437                         Endpoint_ClearSETUP();
 438
 439                         /* Reset the status value variable to the default OK status */
 440                         DFU_Status = OK;
 441
 442                         Endpoint_ClearStatusStage();
 443                         break;
 444                 case DFU_GETSTATE:
 445                         Endpoint_ClearSETUP();
 446
 447                         /* Write the current device state to the endpoint */
 448                         Endpoint_Write_Byte(DFU_State);
 449
 450                         Endpoint_ClearIN();
 451
 452                         Endpoint_ClearStatusStage();
 453                         break;
 454                 case DFU_ABORT:
 455                         Endpoint_ClearSETUP();
 456
 457                         /* Reset the current state variable to the default idle state */
 458                         DFU_State = dfuIDLE;
 459
 460                         Endpoint_ClearStatusStage();
 461                         break;
 462         }
 463 }
 464
 465 /** Routine to discard the specified number of bytes from the control endpoint stream. This is used to
 466  *  discard unused bytes in the stream from the host, including the memory program block suffix.
 467  *
 468  *  \param[in] NumberOfBytes  Number of bytes to discard from the host from the control endpoint
 469  */
 470 static void DiscardFillerBytes(uint8_t NumberOfBytes)
 471 {
 472         while (NumberOfBytes--)
 473         {
 474                 if (!(Endpoint_BytesInEndpoint()))
 475                 {
 476                         Endpoint_ClearOUT();
 477
 478                         /* Wait until next data packet received */
 479                         while (!(Endpoint_IsOUTReceived()))
 480                         {
 481                                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 482                                   return;
 483                         }
 484                 }
 485                 else
 486                 {
 487                         Endpoint_Discard_Byte();
 488                 }
 489         }
 490 }
 491
 492 /** Routine to process an issued command from the host, via a DFU_DNLOAD request wrapper. This routine ensures
 493  *  that the command is allowed based on the current secure mode flag value, and passes the command off to the
 494  *  appropriate handler function.
 495  */
 496 static void ProcessBootloaderCommand(void)
 497 {
 498         /* Check if device is in secure mode */
 499         if (IsSecure)
 500         {
 501                 /* Don't process command unless it is a READ or chip erase command */
 502                 if (!(((SentCommand.Command == COMMAND_WRITE)             &&
 503                         IS_TWOBYTE_COMMAND(SentCommand.Data, 0x00, 0xFF)) ||
 504                            (SentCommand.Command == COMMAND_READ)))
 505                 {
 506                         /* Set the state and status variables to indicate the error */
 507                         DFU_State  = dfuERROR;
 508                         DFU_Status = errWRITE;
 509
 510                         /* Stall command */
 511                         Endpoint_StallTransaction();
 512
 513                         /* Don't process the command */
 514                         return;
 515                 }
 516         }
 517
 518         /* Dispatch the required command processing routine based on the command type */
 519         switch (SentCommand.Command)
 520         {
 521                 case COMMAND_PROG_START:
 522                         ProcessMemProgCommand();
 523                         break;
 524                 case COMMAND_DISP_DATA:
 525                         ProcessMemReadCommand();
 526                         break;
 527                 case COMMAND_WRITE:
 528                         ProcessWriteCommand();
 529                         break;
 530                 case COMMAND_READ:
 531                         ProcessReadCommand();
 532                         break;
 533                 case COMMAND_CHANGE_BASE_ADDR:
 534                         if (IS_TWOBYTE_COMMAND(SentCommand.Data, 0x03, 0x00))              // Set 64KB flash page command
 535                           Flash64KBPage = SentCommand.Data[2];
 536
 537                         break;
 538         }
 539 }
 540
 541 /** Routine to concatenate the given pair of 16-bit memory start and end addresses from the host, and store them
 542  *  in the StartAddr and EndAddr global variables.
 543  */
 544 static void LoadStartEndAddresses(void)
 545 {
 546         union
 547         {
 548                 uint8_t  Bytes[2];
 549                 uint16_t Word;
 550         } Address[2] = {{.Bytes = {SentCommand.Data[2], SentCommand.Data[1]}},
 551                         {.Bytes = {SentCommand.Data[4], SentCommand.Data[3]}}};
 552
 553         /* Load in the start and ending read addresses from the sent data packet */
 554         StartAddr = Address[0].Word;
 555         EndAddr   = Address[1].Word;
 556 }
 557
 558 /** Handler for a Memory Program command issued by the host. This routine handles the preparations needed
 559  *  to write subsequent data from the host into the specified memory.
 560  */
 561 static void ProcessMemProgCommand(void)
 562 {
 563         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00) ||                          // Write FLASH command
 564             IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))                            // Write EEPROM command
 565         {
 566                 /* Load in the start and ending read addresses */
 567                 LoadStartEndAddresses();
 568
 569                 /* If FLASH is being written to, we need to pre-erase the first page to write to */
 570                 if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))
 571                 {
 572                         union
 573                         {
 574                                 uint16_t Words[2];
 575                                 uint32_t Long;
 576                         } CurrFlashAddress = {.Words = {StartAddr, Flash64KBPage}};
 577
 578                         /* Erase the current page's temp buffer */
 579                         boot_page_erase(CurrFlashAddress.Long);
 580                         boot_spm_busy_wait();
 581                 }
 582
 583                 /* Set the state so that the next DNLOAD requests reads in the firmware */
 584                 DFU_State = dfuDNLOAD_IDLE;
 585         }
 586 }
 587
 588 /** Handler for a Memory Read command issued by the host. This routine handles the preparations needed
 589  *  to read subsequent data from the specified memory out to the host, as well as implementing the memory
 590  *  blank check command.
 591  */
 592 static void ProcessMemReadCommand(void)
 593 {
 594         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00) ||                          // Read FLASH command
 595         IS_ONEBYTE_COMMAND(SentCommand.Data, 0x02))                            // Read EEPROM command
 596         {
 597                 /* Load in the start and ending read addresses */
 598                 LoadStartEndAddresses();
 599
 600                 /* Set the state so that the next UPLOAD requests read out the firmware */
 601                 DFU_State = dfuUPLOAD_IDLE;
 602         }
 603         else if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))                       // Blank check FLASH command
 604         {
 605                 uint32_t CurrFlashAddress = 0;
 606
 607                 while (CurrFlashAddress < BOOT_START_ADDR)
 608                 {
 609                         /* Check if the current byte is not blank */
 610                         #if (FLASHEND > 0xFFFF)
 611                         if (pgm_read_byte_far(CurrFlashAddress) != 0xFF)
 612                         #else
 613                         if (pgm_read_byte(CurrFlashAddress) != 0xFF)
 614                         #endif
 615                         {
 616                                 /* Save the location of the first non-blank byte for response back to the host */
 617                                 Flash64KBPage = (CurrFlashAddress >> 16);
 618                                 StartAddr     = CurrFlashAddress;
 619
 620                                 /* Set state and status variables to the appropriate error values */
 621                                 DFU_State  = dfuERROR;
 622                                 DFU_Status = errCHECK_ERASED;
 623
 624                                 break;
 625                         }
 626
 627                         CurrFlashAddress++;
 628                 }
 629         }
 630 }
 631
 632 /** Handler for a Data Write command issued by the host. This routine handles non-programming commands such as
 633  *  bootloader exit (both via software jumps and hardware watchdog resets) and flash memory erasure.
 634  */
 635 static void ProcessWriteCommand(void)
 636 {
 637         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x03))                            // Start application
 638         {
 639                 /* Indicate that the bootloader is terminating */
 640                 WaitForExit = true;
 641
 642                 /* Check if empty request data array - an empty request after a filled request retains the
 643                    previous valid request data, but initializes the reset */
 644                 if (!(SentCommand.DataSize))
 645                 {
 646                         if (SentCommand.Data[1] == 0x00)                                   // Start via watchdog
 647                         {
 648                                 /* Start the watchdog to reset the AVR once the communications are finalized */
 649                                 wdt_enable(WDTO_250MS);
 650                         }
 651                         else                                                               // Start via jump
 652                         {
 653                                 /* Load in the jump address into the application start address pointer */
 654                                 union
 655                                 {
 656                                         uint8_t  Bytes[2];
 657                                         AppPtr_t FuncPtr;
 658                                 } Address = {.Bytes = {SentCommand.Data[4], SentCommand.Data[3]}};
 659
 660                                 AppStartPtr = Address.FuncPtr;
 661
 662                                 /* Set the flag to terminate the bootloader at next opportunity */
 663                                 RunBootloader = false;
 664                         }
 665                 }
 666         }
 667         else if (IS_TWOBYTE_COMMAND(SentCommand.Data, 0x00, 0xFF))                 // Erase flash
 668         {
 669                 uint32_t CurrFlashAddress = 0;
 670
 671                 /* Clear the application section of flash */
 672                 while (CurrFlashAddress < BOOT_START_ADDR)
 673                 {
 674                         boot_page_erase(CurrFlashAddress);
 675                         boot_spm_busy_wait();
 676                         boot_page_write(CurrFlashAddress);
 677                         boot_spm_busy_wait();
 678
 679                         CurrFlashAddress += SPM_PAGESIZE;
 680                 }
 681
 682                 /* Re-enable the RWW section of flash as writing to the flash locks it out */
 683                 boot_rww_enable();
 684
 685                 /* Memory has been erased, reset the security bit so that programming/reading is allowed */
 686                 IsSecure = false;
 687         }
 688 }
 689
 690 /** Handler for a Data Read command issued by the host. This routine handles bootloader information retrieval
 691  *  commands such as device signature and bootloader version retrieval.
 692  */
 693 static void ProcessReadCommand(void)
 694 {
 695         const uint8_t BootloaderInfo[3] = {BOOTLOADER_VERSION, BOOTLOADER_ID_BYTE1, BOOTLOADER_ID_BYTE2};
 696         const uint8_t SignatureInfo[3]  = {AVR_SIGNATURE_1,    AVR_SIGNATURE_2,     AVR_SIGNATURE_3};
 697
 698         uint8_t DataIndexToRead = SentCommand.Data[1];
 699
 700         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))                         // Read bootloader info
 701         {
 702                 ResponseByte = BootloaderInfo[DataIndexToRead];
 703         }
 704         else if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))                    // Read signature byte
 705         {
 706                 ResponseByte = SignatureInfo[DataIndexToRead - 0x30];
 707         }
 708 }