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