3 Copyright (C) Dean Camera, 2017.
5 dean [at] fourwalledcubicle [dot] com
10 Copyright 2017 Dean Camera (dean [at] fourwalledcubicle [dot] com)
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.
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
33 * Main source file for the DFU class bootloader. This file contains the complete bootloader logic.
36 #define INCLUDE_FROM_BOOTLOADER_C
37 #include "BootloaderDFU.h"
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.
43 static bool IsSecure = SECURE_MODE;
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).
49 static bool RunBootloader = true;
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.
56 static bool WaitForExit = false;
58 /** Current DFU state machine state, one of the values in the DFU_State_t enum. */
59 static uint8_t DFU_State = dfuIDLE;
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.
64 static uint8_t DFU_Status = OK;
66 /** Data containing the DFU command sent from the host. */
67 static DFU_Command_t SentCommand;
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.
73 static uint8_t ResponseByte;
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.
78 static AppPtr_t AppStartPtr = (AppPtr_t)0x0000;
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.
83 static uint8_t Flash64KBPage = 0;
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).
88 static uint16_t StartAddr = 0x0000;
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).
93 static uint16_t EndAddr = 0x0000;
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.
100 uint16_t MagicBootKey ATTR_NO_INIT;
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.
107 void Application_Jump_Check(void)
109 bool JumpToApplication = false;
111 #if (BOARD == BOARD_LEONARDO)
112 /* Enable pull-up on the IO13 pin so we can use it to select the mode */
116 /* If IO13 is not jumpered to ground, start the user application instead */
117 JumpToApplication = ((PINC & (1 << 7)) != 0);
119 /* Disable pull-up after the check has completed */
121 #elif ((BOARD == BOARD_XPLAIN) || (BOARD == BOARD_XPLAIN_REV1))
122 /* Disable JTAG debugging */
125 /* Enable pull-up on the JTAG TCK pin so we can use it to select the mode */
129 /* If the TCK pin is not jumpered to ground, start the user application instead */
130 JumpToApplication = ((PINF & (1 << 4)) != 0);
132 /* Re-enable JTAG debugging */
135 /* Check if the device's BOOTRST fuse is set */
136 if (boot_lock_fuse_bits_get(GET_HIGH_FUSE_BITS) & FUSE_BOOTRST)
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;
142 /* Clear reset source */
143 MCUSR &= ~(1 << EXTRF);
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;
152 /* Clear reset source */
153 MCUSR &= ~(1 << WDRF);
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);
160 /* If a request has been made to jump to the user application, honor it */
161 if (JumpToApplication && ApplicationValid)
163 /* Turn off the watchdog */
164 MCUSR &= ~(1 << WDRF);
167 /* Clear the boot key and jump to the user application */
170 // cppcheck-suppress constStatement
171 ((void (*)(void))0x0000)();
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.
181 /* Configure hardware required by the bootloader */
184 /* Turn on first LED on the board to indicate that the bootloader has started */
185 LEDs_SetAllLEDs(LEDS_LED1 | LEDS_LED2);
187 /* Enable global interrupts so that the USB stack can function */
188 GlobalInterruptEnable();
191 #if (BOARD == BOARD_QMK)
192 uint16_t keypress = 0;
195 /* Run the USB management task while the bootloader is supposed to be running */
196 while (RunBootloader || WaitForExit) {
198 #if (BOARD == BOARD_QMK)
199 bool pressed = (PIN(QMK_ESC_ROW) & NUM(QMK_ESC_ROW));
200 if ((DFU_State == dfuIDLE) && (keypress > 5000) && pressed) {
212 /* Reset configured hardware back to their original states for the user application */
215 /* Start the user application */
219 /** Configures all hardware required for the bootloader. */
220 static void SetupHardware(void)
222 /* Disable watchdog if enabled by bootloader/fuses */
223 MCUSR &= ~(1 << WDRF);
226 /* Disable clock division */
227 clock_prescale_set(clock_div_1);
229 /* Relocate the interrupt vector table to the bootloader section */
231 MCUCR = (1 << IVSEL);
233 #if (BOARD == BOARD_QMK)
235 DDR(QMK_ESC_COL) |= NUM(QMK_ESC_COL);
236 PORT(QMK_ESC_COL) |= NUM(QMK_ESC_COL);
239 DDR(QMK_ESC_ROW) |= NUM(QMK_ESC_ROW);
242 /* Initialize the USB and other board hardware drivers */
246 /* Bootloader active LED toggle timer initialization */
247 TIMSK1 = (1 << TOIE1);
248 TCCR1B = ((1 << CS11) | (1 << CS10));
252 /** Resets all configured hardware required for the bootloader back to their original states. */
253 static void ResetHardware(void)
255 /* Shut down the USB and other board hardware drivers */
259 /* Disable Bootloader active LED toggle timer */
263 /* Relocate the interrupt vector table back to the application section */
267 #if (BOARD == BOARD_QMK)
268 DDR(QMK_ESC_COL) = PORT(QMK_ESC_COL) = DDR(QMK_ESC_ROW) = PORT(QMK_ESC_ROW) = 0;
272 /** ISR to periodically toggle the LEDs on the board to indicate that the bootloader is active. */
273 ISR(TIMER1_OVF_vect, ISR_BLOCK)
275 LEDs_ToggleLEDs(LEDS_LED1 | LEDS_LED2);
278 /** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
279 * the device from the USB host before passing along unhandled control requests to the library for processing
282 void EVENT_USB_Device_ControlRequest(void)
284 /* Ignore any requests that aren't directed to the DFU interface */
285 if ((USB_ControlRequest.bmRequestType & (CONTROL_REQTYPE_TYPE | CONTROL_REQTYPE_RECIPIENT)) !=
286 (REQTYPE_CLASS | REQREC_INTERFACE))
291 /* Activity - toggle indicator LEDs */
292 LEDs_ToggleLEDs(LEDS_LED1 | LEDS_LED2);
294 /* Get the size of the command and data from the wLength value */
295 SentCommand.DataSize = USB_ControlRequest.wLength;
297 switch (USB_ControlRequest.bRequest)
300 Endpoint_ClearSETUP();
302 /* Check if bootloader is waiting to terminate */
305 /* Bootloader is terminating - process last received command */
306 ProcessBootloaderCommand();
308 /* Indicate that the last command has now been processed - free to exit bootloader */
312 /* If the request has a data stage, load it into the command struct */
313 if (SentCommand.DataSize)
315 while (!(Endpoint_IsOUTReceived()))
317 if (USB_DeviceState == DEVICE_STATE_Unattached)
321 /* First byte of the data stage is the DNLOAD request's command */
322 SentCommand.Command = Endpoint_Read_8();
324 /* One byte of the data stage is the command, so subtract it from the total data bytes */
325 SentCommand.DataSize--;
327 /* Load in the rest of the data stage as command parameters */
328 for (uint8_t DataByte = 0; (DataByte < sizeof(SentCommand.Data)) &&
329 Endpoint_BytesInEndpoint(); DataByte++)
331 SentCommand.Data[DataByte] = Endpoint_Read_8();
332 SentCommand.DataSize--;
335 /* Process the command */
336 ProcessBootloaderCommand();
339 /* Check if currently downloading firmware */
340 if (DFU_State == dfuDNLOAD_IDLE)
342 if (!(SentCommand.DataSize))
348 /* Throw away the filler bytes before the start of the firmware */
349 DiscardFillerBytes(DFU_FILLER_BYTES_SIZE);
351 /* Throw away the packet alignment filler bytes before the start of the firmware */
352 DiscardFillerBytes(StartAddr % FIXED_CONTROL_ENDPOINT_SIZE);
354 /* Calculate the number of bytes remaining to be written */
355 uint16_t BytesRemaining = ((EndAddr - StartAddr) + 1);
357 if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00)) // Write flash
359 /* Calculate the number of words to be written from the number of bytes to be written */
360 uint16_t WordsRemaining = (BytesRemaining >> 1);
366 } CurrFlashAddress = {.Words = {StartAddr, Flash64KBPage}};
368 uint32_t CurrFlashPageStartAddress = CurrFlashAddress.Long;
369 uint8_t WordsInFlashPage = 0;
371 while (WordsRemaining--)
373 /* Check if endpoint is empty - if so clear it and wait until ready for next packet */
374 if (!(Endpoint_BytesInEndpoint()))
378 while (!(Endpoint_IsOUTReceived()))
380 if (USB_DeviceState == DEVICE_STATE_Unattached)
385 /* Write the next word into the current flash page */
386 boot_page_fill(CurrFlashAddress.Long, Endpoint_Read_16_LE());
388 /* Adjust counters */
389 WordsInFlashPage += 1;
390 CurrFlashAddress.Long += 2;
392 /* See if an entire page has been written to the flash page buffer */
393 if ((WordsInFlashPage == (SPM_PAGESIZE >> 1)) || !(WordsRemaining))
395 /* Commit the flash page to memory */
396 boot_page_write(CurrFlashPageStartAddress);
397 boot_spm_busy_wait();
399 /* Check if programming incomplete */
402 CurrFlashPageStartAddress = CurrFlashAddress.Long;
403 WordsInFlashPage = 0;
405 /* Erase next page's temp buffer */
406 boot_page_erase(CurrFlashAddress.Long);
407 boot_spm_busy_wait();
412 /* Once programming complete, start address equals the end address */
415 /* Re-enable the RWW section of flash */
420 while (BytesRemaining--)
422 /* Check if endpoint is empty - if so clear it and wait until ready for next packet */
423 if (!(Endpoint_BytesInEndpoint()))
427 while (!(Endpoint_IsOUTReceived()))
429 if (USB_DeviceState == DEVICE_STATE_Unattached)
434 /* Read the byte from the USB interface and write to to the EEPROM */
435 eeprom_update_byte((uint8_t*)StartAddr, Endpoint_Read_8());
437 /* Adjust counters */
442 /* Throw away the currently unused DFU file suffix */
443 DiscardFillerBytes(DFU_FILE_SUFFIX_SIZE);
449 Endpoint_ClearStatusStage();
453 Endpoint_ClearSETUP();
455 while (!(Endpoint_IsINReady()))
457 if (USB_DeviceState == DEVICE_STATE_Unattached)
461 if (DFU_State != dfuUPLOAD_IDLE)
463 if ((DFU_State == dfuERROR) && IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01)) // Blank Check
465 /* Blank checking is performed in the DFU_DNLOAD request - if we get here we've told the host
466 that the memory isn't blank, and the host is requesting the first non-blank address */
467 Endpoint_Write_16_LE(StartAddr);
471 /* Idle state upload - send response to last issued command */
472 Endpoint_Write_8(ResponseByte);
477 /* Determine the number of bytes remaining in the current block */
478 uint16_t BytesRemaining = ((EndAddr - StartAddr) + 1);
480 if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00)) // Read FLASH
482 /* Calculate the number of words to be written from the number of bytes to be written */
483 uint16_t WordsRemaining = (BytesRemaining >> 1);
489 } CurrFlashAddress = {.Words = {StartAddr, Flash64KBPage}};
491 while (WordsRemaining--)
493 /* Check if endpoint is full - if so clear it and wait until ready for next packet */
494 if (Endpoint_BytesInEndpoint() == FIXED_CONTROL_ENDPOINT_SIZE)
498 while (!(Endpoint_IsINReady()))
500 if (USB_DeviceState == DEVICE_STATE_Unattached)
505 /* Read the flash word and send it via USB to the host */
506 #if (FLASHEND > 0xFFFF)
507 Endpoint_Write_16_LE(pgm_read_word_far(CurrFlashAddress.Long));
509 Endpoint_Write_16_LE(pgm_read_word(CurrFlashAddress.Long));
512 /* Adjust counters */
513 CurrFlashAddress.Long += 2;
516 /* Once reading is complete, start address equals the end address */
519 else if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x02)) // Read EEPROM
521 while (BytesRemaining--)
523 /* Check if endpoint is full - if so clear it and wait until ready for next packet */
524 if (Endpoint_BytesInEndpoint() == FIXED_CONTROL_ENDPOINT_SIZE)
528 while (!(Endpoint_IsINReady()))
530 if (USB_DeviceState == DEVICE_STATE_Unattached)
535 /* Read the EEPROM byte and send it via USB to the host */
536 Endpoint_Write_8(eeprom_read_byte((uint8_t*)StartAddr));
538 /* Adjust counters */
543 /* Return to idle state */
549 Endpoint_ClearStatusStage();
551 case DFU_REQ_GETSTATUS:
552 Endpoint_ClearSETUP();
554 while (!(Endpoint_IsINReady()))
556 if (USB_DeviceState == DEVICE_STATE_Unattached)
560 /* Write 8-bit status value */
561 Endpoint_Write_8(DFU_Status);
563 /* Write 24-bit poll timeout value */
565 Endpoint_Write_16_LE(0);
567 /* Write 8-bit state value */
568 Endpoint_Write_8(DFU_State);
570 /* Write 8-bit state string ID number */
575 Endpoint_ClearStatusStage();
577 case DFU_REQ_CLRSTATUS:
578 Endpoint_ClearSETUP();
580 /* Reset the status value variable to the default OK status */
583 Endpoint_ClearStatusStage();
585 case DFU_REQ_GETSTATE:
586 Endpoint_ClearSETUP();
588 while (!(Endpoint_IsINReady()))
590 if (USB_DeviceState == DEVICE_STATE_Unattached)
594 /* Write the current device state to the endpoint */
595 Endpoint_Write_8(DFU_State);
599 Endpoint_ClearStatusStage();
602 Endpoint_ClearSETUP();
604 /* Reset the current state variable to the default idle state */
607 Endpoint_ClearStatusStage();
612 /** Routine to discard the specified number of bytes from the control endpoint stream. This is used to
613 * discard unused bytes in the stream from the host, including the memory program block suffix.
615 * \param[in] NumberOfBytes Number of bytes to discard from the host from the control endpoint
617 static void DiscardFillerBytes(uint8_t NumberOfBytes)
619 while (NumberOfBytes--)
621 if (!(Endpoint_BytesInEndpoint()))
625 /* Wait until next data packet received */
626 while (!(Endpoint_IsOUTReceived()))
628 if (USB_DeviceState == DEVICE_STATE_Unattached)
634 Endpoint_Discard_8();
639 /** Routine to process an issued command from the host, via a DFU_DNLOAD request wrapper. This routine ensures
640 * that the command is allowed based on the current secure mode flag value, and passes the command off to the
641 * appropriate handler function.
643 static void ProcessBootloaderCommand(void)
645 /* Check if device is in secure mode */
648 /* Don't process command unless it is a READ or chip erase command */
649 if (!(((SentCommand.Command == COMMAND_WRITE) &&
650 IS_TWOBYTE_COMMAND(SentCommand.Data, 0x00, 0xFF)) ||
651 (SentCommand.Command == COMMAND_READ)))
653 /* Set the state and status variables to indicate the error */
654 DFU_State = dfuERROR;
655 DFU_Status = errWRITE;
658 Endpoint_StallTransaction();
660 /* Don't process the command */
665 /* Dispatch the required command processing routine based on the command type */
666 switch (SentCommand.Command)
668 case COMMAND_PROG_START:
669 ProcessMemProgCommand();
671 case COMMAND_DISP_DATA:
672 ProcessMemReadCommand();
675 ProcessWriteCommand();
678 ProcessReadCommand();
680 case COMMAND_CHANGE_BASE_ADDR:
681 if (IS_TWOBYTE_COMMAND(SentCommand.Data, 0x03, 0x00)) // Set 64KB flash page command
682 Flash64KBPage = SentCommand.Data[2];
688 /** Routine to concatenate the given pair of 16-bit memory start and end addresses from the host, and store them
689 * in the StartAddr and EndAddr global variables.
691 static void LoadStartEndAddresses(void)
697 } Address[2] = {{.Bytes = {SentCommand.Data[2], SentCommand.Data[1]}},
698 {.Bytes = {SentCommand.Data[4], SentCommand.Data[3]}}};
700 /* Load in the start and ending read addresses from the sent data packet */
701 StartAddr = Address[0].Word;
702 EndAddr = Address[1].Word;
705 /** Handler for a Memory Program command issued by the host. This routine handles the preparations needed
706 * to write subsequent data from the host into the specified memory.
708 static void ProcessMemProgCommand(void)
710 if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00) || // Write FLASH command
711 IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01)) // Write EEPROM command
713 /* Load in the start and ending read addresses */
714 LoadStartEndAddresses();
716 /* If FLASH is being written to, we need to pre-erase the first page to write to */
717 if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))
723 } CurrFlashAddress = {.Words = {StartAddr, Flash64KBPage}};
725 /* Erase the current page's temp buffer */
726 boot_page_erase(CurrFlashAddress.Long);
727 boot_spm_busy_wait();
730 /* Set the state so that the next DNLOAD requests reads in the firmware */
731 DFU_State = dfuDNLOAD_IDLE;
735 /** Handler for a Memory Read command issued by the host. This routine handles the preparations needed
736 * to read subsequent data from the specified memory out to the host, as well as implementing the memory
737 * blank check command.
739 static void ProcessMemReadCommand(void)
741 if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00) || // Read FLASH command
742 IS_ONEBYTE_COMMAND(SentCommand.Data, 0x02)) // Read EEPROM command
744 /* Load in the start and ending read addresses */
745 LoadStartEndAddresses();
747 /* Set the state so that the next UPLOAD requests read out the firmware */
748 DFU_State = dfuUPLOAD_IDLE;
750 else if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01)) // Blank check FLASH command
752 uint32_t CurrFlashAddress = 0;
754 while (CurrFlashAddress < (uint32_t)BOOT_START_ADDR)
756 /* Check if the current byte is not blank */
757 #if (FLASHEND > 0xFFFF)
758 if (pgm_read_byte_far(CurrFlashAddress) != 0xFF)
760 if (pgm_read_byte(CurrFlashAddress) != 0xFF)
763 /* Save the location of the first non-blank byte for response back to the host */
764 Flash64KBPage = (CurrFlashAddress >> 16);
765 StartAddr = CurrFlashAddress;
767 /* Set state and status variables to the appropriate error values */
768 DFU_State = dfuERROR;
769 DFU_Status = errCHECK_ERASED;
779 /** Handler for a Data Write command issued by the host. This routine handles non-programming commands such as
780 * bootloader exit (both via software jumps and hardware watchdog resets) and flash memory erasure.
782 static void ProcessWriteCommand(void)
784 if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x03)) // Start application
786 /* Indicate that the bootloader is terminating */
789 /* Check if data supplied for the Start Program command - no data executes the program */
790 if (SentCommand.DataSize)
792 if (SentCommand.Data[1] == 0x01) // Start via jump
798 } Address = {.Bytes = {SentCommand.Data[4], SentCommand.Data[3]}};
800 /* Load in the jump address into the application start address pointer */
801 AppStartPtr = Address.FuncPtr;
806 if (SentCommand.Data[1] == 0x00) // Start via watchdog
808 /* Unlock the forced application start mode of the bootloader if it is restarted */
809 MagicBootKey = MAGIC_BOOT_KEY;
811 /* Start the watchdog to reset the AVR once the communications are finalized */
812 wdt_enable(WDTO_250MS);
814 else // Start via jump
816 /* Set the flag to terminate the bootloader at next opportunity if a valid application has been loaded */
817 if (pgm_read_word_near(0) == 0xFFFF)
818 RunBootloader = false;
822 else if (IS_TWOBYTE_COMMAND(SentCommand.Data, 0x00, 0xFF)) // Erase flash
824 uint32_t CurrFlashAddress = 0;
826 /* Clear the application section of flash */
827 while (CurrFlashAddress < (uint32_t)BOOT_START_ADDR)
829 boot_page_erase(CurrFlashAddress);
830 boot_spm_busy_wait();
831 boot_page_write(CurrFlashAddress);
832 boot_spm_busy_wait();
834 CurrFlashAddress += SPM_PAGESIZE;
837 /* Re-enable the RWW section of flash as writing to the flash locks it out */
840 /* Memory has been erased, reset the security bit so that programming/reading is allowed */
845 /** Handler for a Data Read command issued by the host. This routine handles bootloader information retrieval
846 * commands such as device signature and bootloader version retrieval.
848 static void ProcessReadCommand(void)
850 const uint8_t BootloaderInfo[3] = {BOOTLOADER_VERSION, BOOTLOADER_ID_BYTE1, BOOTLOADER_ID_BYTE2};
851 const uint8_t SignatureInfo[4] = {0x58, AVR_SIGNATURE_1, AVR_SIGNATURE_2, AVR_SIGNATURE_3};
853 uint8_t DataIndexToRead = SentCommand.Data[1];
854 bool ReadAddressInvalid = false;
856 if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00)) // Read bootloader info
858 if (DataIndexToRead < 3)
859 ResponseByte = BootloaderInfo[DataIndexToRead];
861 ReadAddressInvalid = true;
863 else if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01)) // Read signature byte
865 switch (DataIndexToRead)
868 ResponseByte = SignatureInfo[0];
871 ResponseByte = SignatureInfo[1];
874 ResponseByte = SignatureInfo[2];
877 ResponseByte = SignatureInfo[3];
880 ReadAddressInvalid = true;
885 if (ReadAddressInvalid)
887 /* Set the state and status variables to indicate the error */
888 DFU_State = dfuERROR;
889 DFU_Status = errADDRESS;