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