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