Bootloaders/DFU/BootloaderDFU.c

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