protocol/lufa/LUFA-git/Bootloaders/DFU/BootloaderDFU.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2014.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2014  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 disclaims 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         GlobalInterruptEnable();
 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                         while (!(Endpoint_IsINReady()))
 493                         {
 494                                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 495                                   return;
 496                         }
 497
 498                         /* Write 8-bit status value */
 499                         Endpoint_Write_8(DFU_Status);
 500
 501                         /* Write 24-bit poll timeout value */
 502                         Endpoint_Write_8(0);
 503                         Endpoint_Write_16_LE(0);
 504
 505                         /* Write 8-bit state value */
 506                         Endpoint_Write_8(DFU_State);
 507
 508                         /* Write 8-bit state string ID number */
 509                         Endpoint_Write_8(0);
 510
 511                         Endpoint_ClearIN();
 512
 513                         Endpoint_ClearStatusStage();
 514                         break;
 515                 case DFU_REQ_CLRSTATUS:
 516                         Endpoint_ClearSETUP();
 517
 518                         /* Reset the status value variable to the default OK status */
 519                         DFU_Status = OK;
 520
 521                         Endpoint_ClearStatusStage();
 522                         break;
 523                 case DFU_REQ_GETSTATE:
 524                         Endpoint_ClearSETUP();
 525
 526                         while (!(Endpoint_IsINReady()))
 527                         {
 528                                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 529                                   return;
 530                         }
 531
 532                         /* Write the current device state to the endpoint */
 533                         Endpoint_Write_8(DFU_State);
 534
 535                         Endpoint_ClearIN();
 536
 537                         Endpoint_ClearStatusStage();
 538                         break;
 539                 case DFU_REQ_ABORT:
 540                         Endpoint_ClearSETUP();
 541
 542                         /* Reset the current state variable to the default idle state */
 543                         DFU_State = dfuIDLE;
 544
 545                         Endpoint_ClearStatusStage();
 546                         break;
 547         }
 548 }
 549
 550 /** Routine to discard the specified number of bytes from the control endpoint stream. This is used to
 551  *  discard unused bytes in the stream from the host, including the memory program block suffix.
 552  *
 553  *  \param[in] NumberOfBytes  Number of bytes to discard from the host from the control endpoint
 554  */
 555 static void DiscardFillerBytes(uint8_t NumberOfBytes)
 556 {
 557         while (NumberOfBytes--)
 558         {
 559                 if (!(Endpoint_BytesInEndpoint()))
 560                 {
 561                         Endpoint_ClearOUT();
 562
 563                         /* Wait until next data packet received */
 564                         while (!(Endpoint_IsOUTReceived()))
 565                         {
 566                                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 567                                   return;
 568                         }
 569                 }
 570                 else
 571                 {
 572                         Endpoint_Discard_8();
 573                 }
 574         }
 575 }
 576
 577 /** Routine to process an issued command from the host, via a DFU_DNLOAD request wrapper. This routine ensures
 578  *  that the command is allowed based on the current secure mode flag value, and passes the command off to the
 579  *  appropriate handler function.
 580  */
 581 static void ProcessBootloaderCommand(void)
 582 {
 583         /* Check if device is in secure mode */
 584         if (IsSecure)
 585         {
 586                 /* Don't process command unless it is a READ or chip erase command */
 587                 if (!(((SentCommand.Command == COMMAND_WRITE)             &&
 588                         IS_TWOBYTE_COMMAND(SentCommand.Data, 0x00, 0xFF)) ||
 589                            (SentCommand.Command == COMMAND_READ)))
 590                 {
 591                         /* Set the state and status variables to indicate the error */
 592                         DFU_State  = dfuERROR;
 593                         DFU_Status = errWRITE;
 594
 595                         /* Stall command */
 596                         Endpoint_StallTransaction();
 597
 598                         /* Don't process the command */
 599                         return;
 600                 }
 601         }
 602
 603         /* Dispatch the required command processing routine based on the command type */
 604         switch (SentCommand.Command)
 605         {
 606                 case COMMAND_PROG_START:
 607                         ProcessMemProgCommand();
 608                         break;
 609                 case COMMAND_DISP_DATA:
 610                         ProcessMemReadCommand();
 611                         break;
 612                 case COMMAND_WRITE:
 613                         ProcessWriteCommand();
 614                         break;
 615                 case COMMAND_READ:
 616                         ProcessReadCommand();
 617                         break;
 618                 case COMMAND_CHANGE_BASE_ADDR:
 619                         if (IS_TWOBYTE_COMMAND(SentCommand.Data, 0x03, 0x00))              // Set 64KB flash page command
 620                           Flash64KBPage = SentCommand.Data[2];
 621
 622                         break;
 623         }
 624 }
 625
 626 /** Routine to concatenate the given pair of 16-bit memory start and end addresses from the host, and store them
 627  *  in the StartAddr and EndAddr global variables.
 628  */
 629 static void LoadStartEndAddresses(void)
 630 {
 631         union
 632         {
 633                 uint8_t  Bytes[2];
 634                 uint16_t Word;
 635         } Address[2] = {{.Bytes = {SentCommand.Data[2], SentCommand.Data[1]}},
 636                         {.Bytes = {SentCommand.Data[4], SentCommand.Data[3]}}};
 637
 638         /* Load in the start and ending read addresses from the sent data packet */
 639         StartAddr = Address[0].Word;
 640         EndAddr   = Address[1].Word;
 641 }
 642
 643 /** Handler for a Memory Program command issued by the host. This routine handles the preparations needed
 644  *  to write subsequent data from the host into the specified memory.
 645  */
 646 static void ProcessMemProgCommand(void)
 647 {
 648         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00) ||                          // Write FLASH command
 649             IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))                            // Write EEPROM command
 650         {
 651                 /* Load in the start and ending read addresses */
 652                 LoadStartEndAddresses();
 653
 654                 /* If FLASH is being written to, we need to pre-erase the first page to write to */
 655                 if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))
 656                 {
 657                         union
 658                         {
 659                                 uint16_t Words[2];
 660                                 uint32_t Long;
 661                         } CurrFlashAddress = {.Words = {StartAddr, Flash64KBPage}};
 662
 663                         /* Erase the current page's temp buffer */
 664                         boot_page_erase(CurrFlashAddress.Long);
 665                         boot_spm_busy_wait();
 666                 }
 667
 668                 /* Set the state so that the next DNLOAD requests reads in the firmware */
 669                 DFU_State = dfuDNLOAD_IDLE;
 670         }
 671 }
 672
 673 /** Handler for a Memory Read command issued by the host. This routine handles the preparations needed
 674  *  to read subsequent data from the specified memory out to the host, as well as implementing the memory
 675  *  blank check command.
 676  */
 677 static void ProcessMemReadCommand(void)
 678 {
 679         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00) ||                          // Read FLASH command
 680         IS_ONEBYTE_COMMAND(SentCommand.Data, 0x02))                            // Read EEPROM command
 681         {
 682                 /* Load in the start and ending read addresses */
 683                 LoadStartEndAddresses();
 684
 685                 /* Set the state so that the next UPLOAD requests read out the firmware */
 686                 DFU_State = dfuUPLOAD_IDLE;
 687         }
 688         else if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))                       // Blank check FLASH command
 689         {
 690                 uint32_t CurrFlashAddress = 0;
 691
 692                 while (CurrFlashAddress < (uint32_t)BOOT_START_ADDR)
 693                 {
 694                         /* Check if the current byte is not blank */
 695                         #if (FLASHEND > 0xFFFF)
 696                         if (pgm_read_byte_far(CurrFlashAddress) != 0xFF)
 697                         #else
 698                         if (pgm_read_byte(CurrFlashAddress) != 0xFF)
 699                         #endif
 700                         {
 701                                 /* Save the location of the first non-blank byte for response back to the host */
 702                                 Flash64KBPage = (CurrFlashAddress >> 16);
 703                                 StartAddr     = CurrFlashAddress;
 704
 705                                 /* Set state and status variables to the appropriate error values */
 706                                 DFU_State  = dfuERROR;
 707                                 DFU_Status = errCHECK_ERASED;
 708
 709                                 break;
 710                         }
 711
 712                         CurrFlashAddress++;
 713                 }
 714         }
 715 }
 716
 717 /** Handler for a Data Write command issued by the host. This routine handles non-programming commands such as
 718  *  bootloader exit (both via software jumps and hardware watchdog resets) and flash memory erasure.
 719  */
 720 static void ProcessWriteCommand(void)
 721 {
 722         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x03))                            // Start application
 723         {
 724                 /* Indicate that the bootloader is terminating */
 725                 WaitForExit = true;
 726
 727                 /* Check if data supplied for the Start Program command - no data executes the program */
 728                 if (SentCommand.DataSize)
 729                 {
 730                         if (SentCommand.Data[1] == 0x01)                                   // Start via jump
 731                         {
 732                                 union
 733                                 {
 734                                         uint8_t  Bytes[2];
 735                                         AppPtr_t FuncPtr;
 736                                 } Address = {.Bytes = {SentCommand.Data[4], SentCommand.Data[3]}};
 737
 738                                 /* Load in the jump address into the application start address pointer */
 739                                 AppStartPtr = Address.FuncPtr;
 740                         }
 741                 }
 742                 else
 743                 {
 744                         if (SentCommand.Data[1] == 0x00)                                   // Start via watchdog
 745                         {
 746                                 /* Unlock the forced application start mode of the bootloader if it is restarted */
 747                                 MagicBootKey = MAGIC_BOOT_KEY;
 748
 749                                 /* Start the watchdog to reset the AVR once the communications are finalized */
 750                                 wdt_enable(WDTO_250MS);
 751                         }
 752                         else                                                               // Start via jump
 753                         {
 754                                 /* Set the flag to terminate the bootloader at next opportunity */
 755                                 RunBootloader = false;
 756                         }
 757                 }
 758         }
 759         else if (IS_TWOBYTE_COMMAND(SentCommand.Data, 0x00, 0xFF))                 // Erase flash
 760         {
 761                 uint32_t CurrFlashAddress = 0;
 762
 763                 /* Clear the application section of flash */
 764                 while (CurrFlashAddress < (uint32_t)BOOT_START_ADDR)
 765                 {
 766                         boot_page_erase(CurrFlashAddress);
 767                         boot_spm_busy_wait();
 768                         boot_page_write(CurrFlashAddress);
 769                         boot_spm_busy_wait();
 770
 771                         CurrFlashAddress += SPM_PAGESIZE;
 772                 }
 773
 774                 /* Re-enable the RWW section of flash as writing to the flash locks it out */
 775                 boot_rww_enable();
 776
 777                 /* Memory has been erased, reset the security bit so that programming/reading is allowed */
 778                 IsSecure = false;
 779         }
 780 }
 781
 782 /** Handler for a Data Read command issued by the host. This routine handles bootloader information retrieval
 783  *  commands such as device signature and bootloader version retrieval.
 784  */
 785 static void ProcessReadCommand(void)
 786 {
 787         const uint8_t BootloaderInfo[3] = {BOOTLOADER_VERSION, BOOTLOADER_ID_BYTE1, BOOTLOADER_ID_BYTE2};
 788         const uint8_t SignatureInfo[4]  = {0x58, AVR_SIGNATURE_1, AVR_SIGNATURE_2, AVR_SIGNATURE_3};
 789
 790         uint8_t DataIndexToRead = SentCommand.Data[1];
 791
 792         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))                        // Read bootloader info
 793         {
 794                 ResponseByte = BootloaderInfo[DataIndexToRead];
 795         }
 796         else if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))                    // Read signature byte
 797         {
 798                 if (DataIndexToRead < 0x60)
 799                   ResponseByte = SignatureInfo[DataIndexToRead - 0x30];
 800                 else
 801                   ResponseByte = SignatureInfo[DataIndexToRead - 0x60 + 3];
 802         }
 803 }
 804