3 Copyright (C) Dean Camera, 2013.
5 dean [at] fourwalledcubicle [dot] com
10 Copyright 2013 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 Printer class bootloader. This file contains the complete bootloader logic.
36 #include "BootloaderPrinter.h"
38 /** LUFA Printer Class driver interface configuration and state information. This structure is
39 * passed to all Printer Class driver functions, so that multiple instances of the same class
40 * within a device can be differentiated from one another.
42 USB_ClassInfo_PRNT_Device_t TextOnly_Printer_Interface
=
49 .Address
= PRINTER_IN_EPADDR
,
50 .Size
= PRINTER_IO_EPSIZE
,
55 .Address
= PRINTER_OUT_EPADDR
,
56 .Size
= PRINTER_IO_EPSIZE
,
61 "MDL:Generic_/_Text_Only;"
67 /** Intel HEX parser state machine state information, to track the contents of
68 * a HEX file streamed in as a sequence of arbitrary bytes.
72 /** Current HEX parser state machine state. */
74 /** Previously decoded numerical byte of data. */
76 /** Currently decoded numerical byte of data. */
78 /** Indicates if both bytes that correspond to a single decoded numerical
79 * byte of data (HEX encodes values in ASCII HEX, two characters per byte)
83 /** Intel HEX record type of the current Intel HEX record. */
85 /** Numerical bytes of data remaining to be read in the current record. */
87 /** Checksum of the current record received so far. */
89 /** Starting address of the last addressed FLASH page. */
90 uint32_t PageStartAddress
;
91 /** Current 32-bit byte extended base address in FLASH being targeted. */
92 uint32_t CurrBaseAddress
;
93 /** Current 32-bit byte address in FLASH being targeted. */
97 /** Indicates if there is data waiting to be written to a physical page of
100 static bool PageDirty
= false;
102 /** Flag to indicate if the bootloader should be running, or should exit and allow the application code to run
103 * via a soft reset. When cleared, the bootloader will abort, the USB interface will shut down and the application
104 * started via a forced watchdog reset.
106 static bool RunBootloader
= true;
108 /** Magic lock for forced application start. If the HWBE fuse is programmed and BOOTRST is unprogrammed, the bootloader
109 * 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
110 * low when the application attempts to start via a watchdog reset, the bootloader will re-start. If set to the value
111 * \ref MAGIC_BOOT_KEY the special init function \ref Application_Jump_Check() will force the application to start.
113 uint16_t MagicBootKey ATTR_NO_INIT
;
116 /** Special startup routine to check if the bootloader was started via a watchdog reset, and if the magic application
117 * start key has been loaded into \ref MagicBootKey. If the bootloader started via the watchdog and the key is valid,
118 * this will force the user application to start via a software jump.
120 void Application_Jump_Check(void)
122 /* If the reset source was the bootloader and the key is correct, clear it and jump to the application */
123 if ((MCUSR
& (1 << WDRF
)) && (MagicBootKey
== MAGIC_BOOT_KEY
))
127 // cppcheck-suppress constStatement
128 ((void (*)(void))0x0000)();
133 * Converts a given input byte of data from an ASCII encoded HEX value to an integer value.
135 * \note Input HEX bytes are expected to be in uppercase only.
137 * \param[in] Byte ASCII byte of data to convert
139 * \return Integer converted value of the input ASCII encoded HEX byte of data, or -1 if the
140 * input is not valid ASCII encoded HEX.
142 static int8_t HexToDecimal(const char Byte
)
144 if ((Byte
>= 'A') && (Byte
<= 'F'))
145 return (10 + (Byte
- 'A'));
146 else if ((Byte
>= '0') && (Byte
<= '9'))
153 * Flushes a partially written page of data to physical FLASH, if a page
154 * boundary has been crossed.
156 * \note If a page flush occurs the global HEX parser state is updated.
158 static void FlushPageIfRequired(void)
160 /* Abort if no data has been buffered for writing to the current page */
164 /* Flush the FLASH page to physical memory if we are crossing a page boundary */
165 uint32_t NewPageStartAddress
= (HEXParser
.CurrAddress
& ~(SPM_PAGESIZE
- 1));
166 if (HEXParser
.PageStartAddress
!= NewPageStartAddress
)
168 boot_page_write(HEXParser
.PageStartAddress
);
169 boot_spm_busy_wait();
171 HEXParser
.PageStartAddress
= NewPageStartAddress
;
178 * Parses an input Intel HEX formatted stream one character at a time, loading
179 * the data contents into the device's internal FLASH memory.
181 * \param[in] ReadCharacter Next input ASCII byte of data to parse
183 static void ParseIntelHEXByte(const char ReadCharacter
)
185 /* Reset the line parser while waiting for a new line to start */
186 if ((HEXParser
.ParserState
== HEX_PARSE_STATE_WAIT_LINE
) || (ReadCharacter
== ':'))
188 HEXParser
.Checksum
= 0;
189 HEXParser
.CurrAddress
= HEXParser
.CurrBaseAddress
;
190 HEXParser
.ReadMSB
= false;
192 /* ASCII ':' indicates the start of a new HEX record */
193 if (ReadCharacter
== ':')
194 HEXParser
.ParserState
= HEX_PARSE_STATE_BYTE_COUNT
;
199 /* Only allow ASCII HEX encoded digits, ignore all other characters */
200 int8_t ReadCharacterDec
= HexToDecimal(ReadCharacter
);
201 if (ReadCharacterDec
< 0)
204 /* Read and convert the next nibble of data from the current character */
205 HEXParser
.Data
= (HEXParser
.Data
<< 4) | ReadCharacterDec
;
206 HEXParser
.ReadMSB
= !HEXParser
.ReadMSB
;
208 /* Only process further when a full byte (two nibbles) have been read */
209 if (HEXParser
.ReadMSB
)
212 /* Intel HEX checksum is for all fields except starting character and the
215 if (HEXParser
.ParserState
!= HEX_PARSE_STATE_CHECKSUM
)
216 HEXParser
.Checksum
+= HEXParser
.Data
;
218 switch (HEXParser
.ParserState
)
220 case HEX_PARSE_STATE_BYTE_COUNT
:
221 HEXParser
.DataRem
= HEXParser
.Data
;
222 HEXParser
.ParserState
= HEX_PARSE_STATE_ADDRESS_HIGH
;
225 case HEX_PARSE_STATE_ADDRESS_HIGH
:
226 HEXParser
.CurrAddress
+= ((uint16_t)HEXParser
.Data
<< 8);
227 HEXParser
.ParserState
= HEX_PARSE_STATE_ADDRESS_LOW
;
230 case HEX_PARSE_STATE_ADDRESS_LOW
:
231 HEXParser
.CurrAddress
+= HEXParser
.Data
;
232 HEXParser
.ParserState
= HEX_PARSE_STATE_RECORD_TYPE
;
235 case HEX_PARSE_STATE_RECORD_TYPE
:
236 HEXParser
.RecordType
= HEXParser
.Data
;
237 HEXParser
.ParserState
= (HEXParser
.DataRem ? HEX_PARSE_STATE_READ_DATA
: HEX_PARSE_STATE_CHECKSUM
);
240 case HEX_PARSE_STATE_READ_DATA
:
241 /* Track the number of read data bytes in the record */
244 /* Protect the bootloader against being written to */
245 if (HEXParser
.CurrAddress
>= BOOT_START_ADDR
)
247 HEXParser
.ParserState
= HEX_PARSE_STATE_WAIT_LINE
;
252 /* Wait for a machine word (two bytes) of data to be read */
253 if (HEXParser
.DataRem
& 0x01)
255 HEXParser
.PrevData
= HEXParser
.Data
;
259 /* Convert the last two received data bytes into a 16-bit word */
260 uint16_t NewDataWord
= ((uint16_t)HEXParser
.Data
<< 8) | HEXParser
.PrevData
;
262 switch (HEXParser
.RecordType
)
264 case HEX_RECORD_TYPE_Data
:
265 /* If we are writing to a new page, we need to erase it first */
268 boot_page_erase(HEXParser
.PageStartAddress
);
269 boot_spm_busy_wait();
274 /* Fill the FLASH memory buffer with the new word of data */
275 boot_page_fill(HEXParser
.CurrAddress
, NewDataWord
);
276 HEXParser
.CurrAddress
+= 2;
278 /* Flush the FLASH page to physical memory if we are crossing a page boundary */
279 FlushPageIfRequired();
282 case HEX_RECORD_TYPE_ExtendedSegmentAddress
:
283 /* Extended address data - store the upper 12-bits of the new address */
284 HEXParser
.CurrBaseAddress
= ((uint32_t)NewDataWord
<< 4);
287 case HEX_RECORD_TYPE_ExtendedLinearAddress
:
288 /* Extended address data - store the upper 16-bits of the new address */
289 HEXParser
.CurrBaseAddress
= ((uint32_t)NewDataWord
<< 16);
293 if (!HEXParser
.DataRem
)
294 HEXParser
.ParserState
= HEX_PARSE_STATE_CHECKSUM
;
297 case HEX_PARSE_STATE_CHECKSUM
:
298 /* Verify checksum of the completed record */
299 if (HEXParser
.Data
!= ((~HEXParser
.Checksum
+ 1) & 0xFF))
302 /* Flush the FLASH page to physical memory if we are crossing a page boundary */
303 FlushPageIfRequired();
305 /* If end of the HEX file reached, the bootloader should exit at next opportunity */
306 if (HEXParser
.RecordType
== HEX_RECORD_TYPE_EndOfFile
)
307 RunBootloader
= false;
312 HEXParser
.ParserState
= HEX_PARSE_STATE_WAIT_LINE
;
317 /** Main program entry point. This routine configures the hardware required by the application, then
318 * enters a loop to run the application tasks in sequence.
324 LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY
);
325 GlobalInterruptEnable();
327 while (RunBootloader
)
329 uint8_t BytesReceived
= PRNT_Device_BytesReceived(&TextOnly_Printer_Interface
);
333 LEDs_SetAllLEDs(LEDMASK_USB_BUSY
);
335 while (BytesReceived
--)
337 int16_t ReceivedByte
= PRNT_Device_ReceiveByte(&TextOnly_Printer_Interface
);
339 /* Feed the next byte of data to the HEX parser */
340 ParseIntelHEXByte(ReceivedByte
);
343 LEDs_SetAllLEDs(LEDMASK_USB_READY
);
346 PRNT_Device_USBTask(&TextOnly_Printer_Interface
);
350 /* Disconnect from the host - USB interface will be reset later along with the AVR */
353 /* Unlock the forced application start mode of the bootloader if it is restarted */
354 MagicBootKey
= MAGIC_BOOT_KEY
;
356 /* Enable the watchdog and force a timeout to reset the AVR */
357 wdt_enable(WDTO_250MS
);
362 /** Configures the board hardware and chip peripherals for the demo's functionality. */
363 static void SetupHardware(void)
365 /* Disable watchdog if enabled by bootloader/fuses */
366 MCUSR
&= ~(1 << WDRF
);
369 /* Disable clock division */
370 clock_prescale_set(clock_div_1
);
372 /* Relocate the interrupt vector table to the bootloader section */
374 MCUCR
= (1 << IVSEL
);
376 /* Hardware Initialization */
380 /* Bootloader active LED toggle timer initialization */
381 TIMSK1
= (1 << TOIE1
);
382 TCCR1B
= ((1 << CS11
) | (1 << CS10
));
385 /** ISR to periodically toggle the LEDs on the board to indicate that the bootloader is active. */
386 ISR(TIMER1_OVF_vect
, ISR_BLOCK
)
388 LEDs_ToggleLEDs(LEDS_LED1
| LEDS_LED2
);
391 /** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs. */
392 void EVENT_USB_Device_Connect(void)
394 /* Indicate USB enumerating */
395 LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING
);
398 /** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
399 * the status LEDs and stops the Printer management task.
401 void EVENT_USB_Device_Disconnect(void)
403 /* Indicate USB not ready */
404 LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY
);
407 /** Event handler for the USB_ConfigurationChanged event. This is fired when the host set the current configuration
408 * of the USB device after enumeration - the device endpoints are configured and the Mass Storage management task started.
410 void EVENT_USB_Device_ConfigurationChanged(void)
412 bool ConfigSuccess
= true;
414 /* Setup Printer Data Endpoints */
415 ConfigSuccess
&= PRNT_Device_ConfigureEndpoints(&TextOnly_Printer_Interface
);
417 /* Reset the HEX parser upon successful connection to a host */
418 HEXParser
.ParserState
= HEX_PARSE_STATE_WAIT_LINE
;
420 /* Indicate endpoint configuration success or failure */
421 LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY
: LEDMASK_USB_ERROR
);
424 /** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
425 * the device from the USB host before passing along unhandled control requests to the library for processing
428 void EVENT_USB_Device_ControlRequest(void)
430 PRNT_Device_ProcessControlRequest(&TextOnly_Printer_Interface
);