projects / pub / USBasp.git / blob
? search:


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