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