Bootloaders/DFU/BootloaderDFU.c

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