amiro-blt / Target / Source / file.c @ 69661903
History | View | Annotate | Download (32.3 KB)
1 |
/************************************************************************************//** |
---|---|
2 |
* \file Source\file.c
|
3 |
* \brief Bootloader file system interface source file.
|
4 |
* \ingroup Core
|
5 |
* \internal
|
6 |
*----------------------------------------------------------------------------------------
|
7 |
* C O P Y R I G H T
|
8 |
*----------------------------------------------------------------------------------------
|
9 |
* Copyright (c) 2013 by Feaser http://www.feaser.com All rights reserved
|
10 |
*
|
11 |
*----------------------------------------------------------------------------------------
|
12 |
* L I C E N S E
|
13 |
*----------------------------------------------------------------------------------------
|
14 |
* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or
|
15 |
* modify it under the terms of the GNU General Public License as published by the Free
|
16 |
* Software Foundation, either version 3 of the License, or (at your option) any later
|
17 |
* version.
|
18 |
*
|
19 |
* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
20 |
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
21 |
* PURPOSE. See the GNU General Public License for more details.
|
22 |
*
|
23 |
* You should have received a copy of the GNU General Public License along with OpenBLT.
|
24 |
* If not, see <http://www.gnu.org/licenses/>.
|
25 |
*
|
26 |
* A special exception to the GPL is included to allow you to distribute a combined work
|
27 |
* that includes OpenBLT without being obliged to provide the source code for any
|
28 |
* proprietary components. The exception text is included at the bottom of the license
|
29 |
* file <license.html>.
|
30 |
*
|
31 |
* \endinternal
|
32 |
****************************************************************************************/
|
33 |
|
34 |
/****************************************************************************************
|
35 |
* Include files
|
36 |
****************************************************************************************/
|
37 |
#include "boot.h" /* bootloader generic header */ |
38 |
#include <string.h> /* for strcpy etc. */ |
39 |
#include <ctype.h> /* for toupper() etc. */ |
40 |
|
41 |
|
42 |
#if (BOOT_FILE_SYS_ENABLE > 0) |
43 |
/****************************************************************************************
|
44 |
* Type definitions
|
45 |
****************************************************************************************/
|
46 |
/** \brief Enumeration for the different internal module states. */
|
47 |
typedef enum |
48 |
{ |
49 |
FIRMWARE_UPDATE_STATE_IDLE, /**< idle state */
|
50 |
FIRMWARE_UPDATE_STATE_STARTING, /**< starting state */
|
51 |
FIRMWARE_UPDATE_STATE_ERASING, /**< erasing state */
|
52 |
FIRMWARE_UPDATE_STATE_PROGRAMMING /**< programming state */
|
53 |
} tFirmwareUpdateState; |
54 |
|
55 |
/** \brief Structure type with information for the memory erase opeartion. */
|
56 |
typedef struct |
57 |
{ |
58 |
blt_addr start_address; /**< erase start address */
|
59 |
blt_int32u total_size; /**< total number of bytes to erase */
|
60 |
} tFileEraseInfo; |
61 |
|
62 |
/** \brief Structure type for grouping FATFS related objects used by this module. */
|
63 |
typedef struct |
64 |
{ |
65 |
FATFS fs; /**< file system object for mouting */
|
66 |
FIL file; /**< file object for firmware file */
|
67 |
} tFatFsObjects; |
68 |
|
69 |
/****************************************************************************************
|
70 |
* Function prototypes
|
71 |
****************************************************************************************/
|
72 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
73 |
static blt_char FileLibByteNibbleToChar(blt_int8u nibble);
|
74 |
static blt_char *FileLibByteToHexString(blt_int8u byte_val, blt_char *destination);
|
75 |
static blt_char *FileLibLongToIntString(blt_int32u long_val, blt_char *destination);
|
76 |
#endif
|
77 |
static blt_int8u FileLibHexStringToByte(const blt_char *hexstring); |
78 |
|
79 |
|
80 |
/****************************************************************************************
|
81 |
* Hook functions
|
82 |
****************************************************************************************/
|
83 |
extern blt_bool FileIsFirmwareUpdateRequestedHook(void); |
84 |
extern const blt_char *FileGetFirmwareFilenameHook(void); |
85 |
extern void FileFirmwareUpdateStartedHook(void); |
86 |
extern void FileFirmwareUpdateCompletedHook(void); |
87 |
extern void FileFirmwareUpdateErrorHook(blt_int8u error_code); |
88 |
extern void FileFirmwareUpdateLogHook(blt_char *info_string); |
89 |
|
90 |
|
91 |
/****************************************************************************************
|
92 |
* Local data declarations
|
93 |
****************************************************************************************/
|
94 |
/** \brief Local variable that holds the internal module state. */
|
95 |
static tFirmwareUpdateState firmwareUpdateState;
|
96 |
/** \brief Local variable for the used FATFS objects in this module. */
|
97 |
static tFatFsObjects fatFsObjects;
|
98 |
/** \brief Local variable for storing S-record line parsing results. */
|
99 |
static tSrecLineParseObject lineParseObject;
|
100 |
/** \brief Local variable for storing information regarding the memory erase operation.*/
|
101 |
static tFileEraseInfo eraseInfo;
|
102 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
103 |
/** \brief Local character buffer for storing the string with log information. */
|
104 |
static blt_char loggingStr[64]; |
105 |
#endif
|
106 |
|
107 |
|
108 |
/***********************************************************************************//** |
109 |
** \brief Initializes the file system interface module. The initial firmware
|
110 |
** update state is set to idle and the file system is mounted as
|
111 |
** logical disk 0.
|
112 |
** \return none
|
113 |
**
|
114 |
****************************************************************************************/
|
115 |
void FileInit(void) |
116 |
{ |
117 |
FRESULT fresult; |
118 |
|
119 |
/* set the initial state */
|
120 |
firmwareUpdateState = FIRMWARE_UPDATE_STATE_IDLE; |
121 |
/* mount the file system, using logical disk 0 */
|
122 |
fresult = f_mount(0, &fatFsObjects.fs);
|
123 |
/* mounting does not access the disk and should succeed unless misconfigured */
|
124 |
ASSERT_RT(fresult == FR_OK); |
125 |
} /*** end of FileInit ***/
|
126 |
|
127 |
|
128 |
/***********************************************************************************//** |
129 |
** \brief This function checks if a firmware update through the locally attached
|
130 |
** storage is in progress or not (idle).
|
131 |
** \return BLT_TRUE when in idle state, BLT_FALSE otherwise.
|
132 |
**
|
133 |
****************************************************************************************/
|
134 |
blt_bool FileIsIdle(void)
|
135 |
{ |
136 |
if (firmwareUpdateState == FIRMWARE_UPDATE_STATE_IDLE)
|
137 |
{ |
138 |
return BLT_TRUE;
|
139 |
} |
140 |
return BLT_FALSE;
|
141 |
} /*** end of FileIsIdle ***/
|
142 |
|
143 |
|
144 |
/***********************************************************************************//** |
145 |
** \brief This function checks if a firmware update through the locally attached
|
146 |
** storage is requested to be started and if so processes this request
|
147 |
** by transitioning from the IDLE to the STARTING state.
|
148 |
** \return BLT_TRUE when a firmware update is requested, BLT_FALSE otherwise.
|
149 |
**
|
150 |
****************************************************************************************/
|
151 |
blt_bool FileHandleFirmwareUpdateRequest(void)
|
152 |
{ |
153 |
#if (BOOT_COM_ENABLE > 0) |
154 |
/* make sure that there is no connection with a remote host to prevent two firmware
|
155 |
* updates happening at the same time
|
156 |
*/
|
157 |
if (ComIsConnected() == BLT_TRUE)
|
158 |
{ |
159 |
return BLT_FALSE;
|
160 |
} |
161 |
#endif
|
162 |
/* a new firmware update request can only be handled if not already busy with one */
|
163 |
if (firmwareUpdateState != FIRMWARE_UPDATE_STATE_IDLE)
|
164 |
{ |
165 |
return BLT_FALSE;
|
166 |
} |
167 |
/* check if a firmware update is requested */
|
168 |
if (FileIsFirmwareUpdateRequestedHook() == BLT_TRUE)
|
169 |
{ |
170 |
/* transition from IDLE to STARTING state, which kicks off the update sequence */
|
171 |
firmwareUpdateState = FIRMWARE_UPDATE_STATE_STARTING; |
172 |
return BLT_TRUE;
|
173 |
} |
174 |
/* still here so no update request pending */
|
175 |
return BLT_FALSE;
|
176 |
} /*** end of FileHandleFirmwareUpdateRequest ***/
|
177 |
|
178 |
|
179 |
/***********************************************************************************//** |
180 |
** \brief File system task function for managing the firmware updates from
|
181 |
** locally attached storage.
|
182 |
** \return none.
|
183 |
**
|
184 |
****************************************************************************************/
|
185 |
void FileTask(void) |
186 |
{ |
187 |
blt_int16s parse_result; |
188 |
blt_char *read_line_ptr; |
189 |
|
190 |
/* ------------------------------- idle -------------------------------------------- */
|
191 |
if (firmwareUpdateState == FIRMWARE_UPDATE_STATE_IDLE)
|
192 |
{ |
193 |
/* currently, nothings need to be done while idling */
|
194 |
} |
195 |
/* ------------------------------- starting ---------------------------------------- */
|
196 |
else if (firmwareUpdateState == FIRMWARE_UPDATE_STATE_STARTING) |
197 |
{ |
198 |
#if (BOOT_FILE_STARTED_HOOK_ENABLE > 0) |
199 |
/* inform application about update started event via hook function */
|
200 |
FileFirmwareUpdateStartedHook(); |
201 |
#endif
|
202 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
203 |
FileFirmwareUpdateLogHook("Firmware update request detected\n\r");
|
204 |
FileFirmwareUpdateLogHook("Opening firmware file for reading...");
|
205 |
#endif
|
206 |
/* attempt to obtain a file object for the firmware file */
|
207 |
if (f_open(&fatFsObjects.file, FileGetFirmwareFilenameHook(), FA_OPEN_EXISTING | FA_READ) != FR_OK)
|
208 |
{ |
209 |
/* can't open file */
|
210 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
211 |
FileFirmwareUpdateLogHook("ERROR\n\r");
|
212 |
#endif
|
213 |
#if (BOOT_FILE_ERROR_HOOK_ENABLE > 0) |
214 |
FileFirmwareUpdateErrorHook(FILE_ERROR_CANNOT_OPEN_FIRMWARE_FILE); |
215 |
#endif
|
216 |
/* nothing left to do now */
|
217 |
return;
|
218 |
} |
219 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
220 |
FileFirmwareUpdateLogHook("OK\n\r");
|
221 |
FileFirmwareUpdateLogHook("Starting the programming sequence\n\r");
|
222 |
FileFirmwareUpdateLogHook("Parsing firmware file to obtain erase size...");
|
223 |
#endif
|
224 |
/* prepare data objects for the erasing state */
|
225 |
eraseInfo.start_address = 0;
|
226 |
eraseInfo.total_size = 0;
|
227 |
/* transition from idle to erasing state */
|
228 |
firmwareUpdateState = FIRMWARE_UPDATE_STATE_ERASING; |
229 |
} |
230 |
/* ------------------------------- erasing ----------------------------------------- */
|
231 |
else if (firmwareUpdateState == FIRMWARE_UPDATE_STATE_ERASING) |
232 |
{ |
233 |
/* read a line from the file */
|
234 |
read_line_ptr = f_gets(lineParseObject.line, sizeof(lineParseObject.line), &fatFsObjects.file);
|
235 |
/* check if an error occurred */
|
236 |
if (f_error(&fatFsObjects.file) > 0) |
237 |
{ |
238 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
239 |
FileFirmwareUpdateLogHook("ERROR\n\r");
|
240 |
#endif
|
241 |
#if (BOOT_FILE_ERROR_HOOK_ENABLE > 0) |
242 |
FileFirmwareUpdateErrorHook(FILE_ERROR_CANNOT_READ_FROM_FILE); |
243 |
#endif
|
244 |
/* close the file */
|
245 |
f_close(&fatFsObjects.file); |
246 |
/* cannot continue with firmware update so go back to idle state */
|
247 |
firmwareUpdateState = FIRMWARE_UPDATE_STATE_IDLE; |
248 |
return;
|
249 |
} |
250 |
/* parse the S-Record line without copying the data values if the line is not empty */
|
251 |
if (read_line_ptr != BLT_NULL)
|
252 |
{ |
253 |
parse_result = FileSrecParseLine(lineParseObject.line, &lineParseObject.address, BLT_NULL); |
254 |
/* check parsing result */
|
255 |
if (parse_result == ERROR_SREC_INVALID_CHECKSUM)
|
256 |
{ |
257 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
258 |
FileFirmwareUpdateLogHook("ERROR\n\r");
|
259 |
#endif
|
260 |
#if (BOOT_FILE_ERROR_HOOK_ENABLE > 0) |
261 |
FileFirmwareUpdateErrorHook(FILE_ERROR_INVALID_CHECKSUM_IN_FILE); |
262 |
#endif
|
263 |
/* close the file */
|
264 |
f_close(&fatFsObjects.file); |
265 |
/* cannot continue with firmware update so go back to idle state */
|
266 |
firmwareUpdateState = FIRMWARE_UPDATE_STATE_IDLE; |
267 |
return;
|
268 |
} |
269 |
} |
270 |
/* only process parsing results if the line contained address/data info */
|
271 |
if (parse_result > 0) |
272 |
{ |
273 |
/* is this the first address/data info we encountered? */
|
274 |
if (eraseInfo.total_size == 0) |
275 |
{ |
276 |
/* store the start_address and byte count */
|
277 |
eraseInfo.start_address = lineParseObject.address; |
278 |
eraseInfo.total_size = parse_result; |
279 |
} |
280 |
else
|
281 |
{ |
282 |
/* update the start_address and byte count */
|
283 |
if (lineParseObject.address < eraseInfo.start_address)
|
284 |
{ |
285 |
eraseInfo.start_address = lineParseObject.address; |
286 |
} |
287 |
eraseInfo.total_size += parse_result; |
288 |
} |
289 |
} |
290 |
/* check if the end of the file was reached */
|
291 |
if (f_eof(&fatFsObjects.file) > 0) |
292 |
{ |
293 |
/* rewind the file in preparation for the programming state */
|
294 |
if (f_lseek(&fatFsObjects.file, 0) != FR_OK) |
295 |
{ |
296 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
297 |
FileFirmwareUpdateLogHook("ERROR\n\r");
|
298 |
#endif
|
299 |
#if (BOOT_FILE_ERROR_HOOK_ENABLE > 0) |
300 |
FileFirmwareUpdateErrorHook(FILE_ERROR_REWINDING_FILE_READ_POINTER); |
301 |
#endif
|
302 |
/* close the file */
|
303 |
f_close(&fatFsObjects.file); |
304 |
/* cannot continue with firmware update so go back to idle state */
|
305 |
firmwareUpdateState = FIRMWARE_UPDATE_STATE_IDLE; |
306 |
return;
|
307 |
} |
308 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
309 |
FileFirmwareUpdateLogHook("OK\n\r");
|
310 |
FileFirmwareUpdateLogHook("Erasing ");
|
311 |
/* convert size to string */
|
312 |
FileLibLongToIntString(eraseInfo.total_size, loggingStr); |
313 |
FileFirmwareUpdateLogHook(loggingStr); |
314 |
FileFirmwareUpdateLogHook(" bytes from memory at 0x");
|
315 |
/* convert address to hex-string */
|
316 |
FileLibByteToHexString((blt_int8u)(eraseInfo.start_address >> 24), &loggingStr[0]); |
317 |
FileLibByteToHexString((blt_int8u)(eraseInfo.start_address >> 16), &loggingStr[2]); |
318 |
FileLibByteToHexString((blt_int8u)(eraseInfo.start_address >> 8), &loggingStr[4]); |
319 |
FileLibByteToHexString((blt_int8u)eraseInfo.start_address, &loggingStr[6]);
|
320 |
FileFirmwareUpdateLogHook(loggingStr); |
321 |
FileFirmwareUpdateLogHook("...");
|
322 |
#endif
|
323 |
/* still here so we are ready to perform the memory erase operation */
|
324 |
if (NvmErase(eraseInfo.start_address, eraseInfo.total_size) == BLT_FALSE)
|
325 |
{ |
326 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
327 |
FileFirmwareUpdateLogHook("ERROR\n\r");
|
328 |
#endif
|
329 |
#if (BOOT_FILE_ERROR_HOOK_ENABLE > 0) |
330 |
FileFirmwareUpdateErrorHook(FILE_ERROR_CANNOT_ERASE_MEMORY); |
331 |
#endif
|
332 |
/* close the file */
|
333 |
f_close(&fatFsObjects.file); |
334 |
/* cannot continue with firmware update so go back to idle state */
|
335 |
firmwareUpdateState = FIRMWARE_UPDATE_STATE_IDLE; |
336 |
return;
|
337 |
} |
338 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
339 |
FileFirmwareUpdateLogHook("OK\n\r");
|
340 |
#endif
|
341 |
/* all okay, then go to programming state */
|
342 |
firmwareUpdateState = FIRMWARE_UPDATE_STATE_PROGRAMMING; |
343 |
} |
344 |
} |
345 |
/* ------------------------------- programming ------------------------------------- */
|
346 |
else if (firmwareUpdateState == FIRMWARE_UPDATE_STATE_PROGRAMMING) |
347 |
{ |
348 |
/* read a line from the file */
|
349 |
read_line_ptr = f_gets(lineParseObject.line, sizeof(lineParseObject.line), &fatFsObjects.file);
|
350 |
/* check if an error occurred */
|
351 |
if (f_error(&fatFsObjects.file) > 0) |
352 |
{ |
353 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
354 |
FileFirmwareUpdateLogHook("Reading line from file...ERROR\n\r");
|
355 |
#endif
|
356 |
#if (BOOT_FILE_ERROR_HOOK_ENABLE > 0) |
357 |
FileFirmwareUpdateErrorHook(FILE_ERROR_CANNOT_READ_FROM_FILE); |
358 |
#endif
|
359 |
/* close the file */
|
360 |
f_close(&fatFsObjects.file); |
361 |
/* cannot continue with firmware update so go back to idle state */
|
362 |
firmwareUpdateState = FIRMWARE_UPDATE_STATE_IDLE; |
363 |
return;
|
364 |
} |
365 |
/* parse the S-Record line if the line is not empty */
|
366 |
if (read_line_ptr != BLT_NULL)
|
367 |
{ |
368 |
parse_result = FileSrecParseLine(lineParseObject.line, &lineParseObject.address, lineParseObject.data); |
369 |
/* check parsing result */
|
370 |
if (parse_result == ERROR_SREC_INVALID_CHECKSUM)
|
371 |
{ |
372 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
373 |
FileFirmwareUpdateLogHook("Invalid checksum found...ERROR\n\r");
|
374 |
#endif
|
375 |
#if (BOOT_FILE_ERROR_HOOK_ENABLE > 0) |
376 |
FileFirmwareUpdateErrorHook(FILE_ERROR_INVALID_CHECKSUM_IN_FILE); |
377 |
#endif
|
378 |
/* close the file */
|
379 |
f_close(&fatFsObjects.file); |
380 |
/* cannot continue with firmware update so go back to idle state */
|
381 |
firmwareUpdateState = FIRMWARE_UPDATE_STATE_IDLE; |
382 |
return;
|
383 |
} |
384 |
} |
385 |
/* only process parsing results if the line contained address/data info */
|
386 |
if (parse_result > 0) |
387 |
{ |
388 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
389 |
FileFirmwareUpdateLogHook("Programming ");
|
390 |
/* convert size to string */
|
391 |
FileLibLongToIntString(parse_result, loggingStr); |
392 |
FileFirmwareUpdateLogHook(loggingStr); |
393 |
FileFirmwareUpdateLogHook(" bytes to memory at 0x");
|
394 |
/* convert address to hex-string */
|
395 |
FileLibByteToHexString((blt_int8u)(lineParseObject.address >> 24), &loggingStr[0]); |
396 |
FileLibByteToHexString((blt_int8u)(lineParseObject.address >> 16), &loggingStr[2]); |
397 |
FileLibByteToHexString((blt_int8u)(lineParseObject.address >> 8), &loggingStr[4]); |
398 |
FileLibByteToHexString((blt_int8u)lineParseObject.address, &loggingStr[6]);
|
399 |
FileFirmwareUpdateLogHook(loggingStr); |
400 |
FileFirmwareUpdateLogHook("...");
|
401 |
#endif
|
402 |
/* program the data */
|
403 |
if (NvmWrite(lineParseObject.address, parse_result, lineParseObject.data) == BLT_FALSE)
|
404 |
{ |
405 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
406 |
FileFirmwareUpdateLogHook("ERROR\n\r");
|
407 |
#endif
|
408 |
#if (BOOT_FILE_ERROR_HOOK_ENABLE > 0) |
409 |
FileFirmwareUpdateErrorHook(FILE_ERROR_CANNOT_PROGRAM_MEMORY); |
410 |
#endif
|
411 |
/* close the file */
|
412 |
f_close(&fatFsObjects.file); |
413 |
/* cannot continue with firmware update so go back to idle state */
|
414 |
firmwareUpdateState = FIRMWARE_UPDATE_STATE_IDLE; |
415 |
return;
|
416 |
} |
417 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
418 |
FileFirmwareUpdateLogHook("OK\n\r");
|
419 |
#endif
|
420 |
} |
421 |
/* check if the end of the file was reached */
|
422 |
if (f_eof(&fatFsObjects.file) > 0) |
423 |
{ |
424 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
425 |
FileFirmwareUpdateLogHook("Writing program checksum...");
|
426 |
#endif
|
427 |
/* finish the programming by writing the checksum */
|
428 |
if (NvmDone() == BLT_FALSE)
|
429 |
{ |
430 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
431 |
FileFirmwareUpdateLogHook("ERROR\n\r");
|
432 |
#endif
|
433 |
#if (BOOT_FILE_ERROR_HOOK_ENABLE > 0) |
434 |
FileFirmwareUpdateErrorHook(FILE_ERROR_CANNOT_WRITE_CHECKSUM); |
435 |
#endif
|
436 |
/* close the file */
|
437 |
f_close(&fatFsObjects.file); |
438 |
/* cannot continue with firmware update so go back to idle state */
|
439 |
firmwareUpdateState = FIRMWARE_UPDATE_STATE_IDLE; |
440 |
return;
|
441 |
} |
442 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
443 |
FileFirmwareUpdateLogHook("OK\n\r");
|
444 |
FileFirmwareUpdateLogHook("Closing firmware file\n\r");
|
445 |
#endif
|
446 |
/* close the file */
|
447 |
f_close(&fatFsObjects.file); |
448 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
449 |
FileFirmwareUpdateLogHook("Firmware update successfully completed\n\r");
|
450 |
#endif
|
451 |
/* all done so transistion back to idle mode */
|
452 |
firmwareUpdateState = FIRMWARE_UPDATE_STATE_IDLE; |
453 |
#if (BOOT_FILE_COMPLETED_HOOK_ENABLE > 0) |
454 |
/* inform application about update completed event via hook function */
|
455 |
FileFirmwareUpdateCompletedHook(); |
456 |
#endif
|
457 |
/* attempt to start the user program now that programming is done. note that
|
458 |
* a call to CpuReset() won't work correctly here, because if the same firmware
|
459 |
* file is still on the locally attached storage, it will just restart the
|
460 |
* firmware update again and again..
|
461 |
*/
|
462 |
CpuStartUserProgram(); |
463 |
} |
464 |
} |
465 |
} /*** end of FileTask ***/
|
466 |
|
467 |
|
468 |
/************************************************************************************//** |
469 |
** \brief Inspects a line from a Motorola S-Record file to determine its type.
|
470 |
** \param line A line from the S-Record.
|
471 |
** \return the S-Record line type.
|
472 |
**
|
473 |
****************************************************************************************/
|
474 |
tSrecLineType FileSrecGetLineType(const blt_char *line)
|
475 |
{ |
476 |
/* check if the line starts with the 'S' character, followed by a digit */
|
477 |
if ( (toupper(line[0]) != 'S') || (isdigit(line[1]) == 0) ) |
478 |
{ |
479 |
/* not a valid S-Record line type */
|
480 |
return LINE_TYPE_UNSUPPORTED;
|
481 |
} |
482 |
/* determine the line type */
|
483 |
if (line[1] == '1') |
484 |
{ |
485 |
return LINE_TYPE_S1;
|
486 |
} |
487 |
if (line[1] == '2') |
488 |
{ |
489 |
return LINE_TYPE_S2;
|
490 |
} |
491 |
if (line[1] == '3') |
492 |
{ |
493 |
return LINE_TYPE_S3;
|
494 |
} |
495 |
/* still here so not a supported line type found */
|
496 |
return LINE_TYPE_UNSUPPORTED;
|
497 |
} /*** end of FileSrecGetLineType ***/
|
498 |
|
499 |
|
500 |
/************************************************************************************//** |
501 |
** \brief Inspects an S1, S2 or S3 line from a Motorola S-Record file to
|
502 |
** determine if the checksum at the end is corrrect.
|
503 |
** \param line An S1, S2 or S3 line from the S-Record.
|
504 |
** \return BLT_TRUE if the checksum is correct, BLT_FALSE otherwise.
|
505 |
**
|
506 |
****************************************************************************************/
|
507 |
blt_bool FileSrecVerifyChecksum(const blt_char *line)
|
508 |
{ |
509 |
blt_int16u bytes_on_line; |
510 |
blt_int8u checksum = 0;
|
511 |
|
512 |
/* adjust pointer to point to byte count value */
|
513 |
line += 2;
|
514 |
/* read out the number of byte values that follow on the line */
|
515 |
bytes_on_line = FileLibHexStringToByte(line); |
516 |
/* byte count is part of checksum */
|
517 |
checksum += bytes_on_line; |
518 |
/* adjust pointer to the first byte of the address */
|
519 |
line += 2;
|
520 |
/* add byte values of address and data, but not the final checksum */
|
521 |
do
|
522 |
{ |
523 |
/* add the next byte value to the checksum */
|
524 |
checksum += FileLibHexStringToByte(line); |
525 |
/* update counter */
|
526 |
bytes_on_line--; |
527 |
/* point to next hex string in the line */
|
528 |
line += 2;
|
529 |
} |
530 |
while (bytes_on_line > 1); |
531 |
/* the checksum is calculated by summing up the values of the byte count, address and
|
532 |
* databytes and then taking the 1-complement of the sum's least signigicant byte */
|
533 |
checksum = ~checksum; |
534 |
/* finally verify the calculated checksum with the one at the end of the line */
|
535 |
if (checksum != FileLibHexStringToByte(line))
|
536 |
{ |
537 |
/* checksum incorrect */
|
538 |
return BLT_FALSE;
|
539 |
} |
540 |
/* still here so the checksum was correct */
|
541 |
return BLT_TRUE;
|
542 |
} /*** end of FileSrecVerifyChecksum ***/
|
543 |
|
544 |
|
545 |
/************************************************************************************//** |
546 |
** \brief Parses a line from a Motorola S-Record file and looks for S1, S2 or S3
|
547 |
** lines with data. Note that if a null pointer is passed as the data
|
548 |
** parameter, then no data is extracted from the line.
|
549 |
** \param line A line from the S-Record.
|
550 |
** \param address Address found in the S-Record data line.
|
551 |
** \param data Byte array where the data bytes from the S-Record data line
|
552 |
** are stored.
|
553 |
** \return The number of data bytes found on the S-record data line, 0 in case
|
554 |
** the line is not an S1, S2 or S3 line or ERROR_SREC_INVALID_CHECKSUM
|
555 |
** in case the checksum validation failed.
|
556 |
**
|
557 |
****************************************************************************************/
|
558 |
blt_int16s FileSrecParseLine(const blt_char *line, blt_addr *address, blt_int8u *data)
|
559 |
{ |
560 |
tSrecLineType lineType; |
561 |
blt_int16s data_byte_count = 0;
|
562 |
blt_int16u bytes_on_line; |
563 |
blt_int16u i; |
564 |
|
565 |
/* check pointers and not that data can be a null pointer */
|
566 |
ASSERT_RT((address != BLT_NULL) && (line != BLT_NULL)); |
567 |
/* figure out what type of line we are dealing with */
|
568 |
lineType = FileSrecGetLineType(line); |
569 |
/* make sure it is one that we can parse */
|
570 |
if (lineType == LINE_TYPE_UNSUPPORTED)
|
571 |
{ |
572 |
/* not a parsing error, but simply no data on this line */
|
573 |
return 0; |
574 |
} |
575 |
/* verify the checksum */
|
576 |
if (FileSrecVerifyChecksum(line) == BLT_FALSE)
|
577 |
{ |
578 |
/* error on data line encountered */
|
579 |
return ERROR_SREC_INVALID_CHECKSUM;
|
580 |
} |
581 |
/* all good so far, now read out the address and databytes for the line */
|
582 |
switch (lineType)
|
583 |
{ |
584 |
/* ---------------------------- S1 line type ------------------------------------- */
|
585 |
case LINE_TYPE_S1:
|
586 |
/* adjust pointer to point to byte count value */
|
587 |
line += 2;
|
588 |
/* read out the number of byte values that follow on the line */
|
589 |
bytes_on_line = FileLibHexStringToByte(line); |
590 |
/* read out the 16-bit address */
|
591 |
line += 2;
|
592 |
*address = FileLibHexStringToByte(line) << 8;
|
593 |
line += 2;
|
594 |
*address += FileLibHexStringToByte(line); |
595 |
/* adjust pointer to point to the first data byte after the address */
|
596 |
line += 2;
|
597 |
/* determine how many data bytes are on the line */
|
598 |
data_byte_count = bytes_on_line - 3; /* -2 bytes address, -1 byte checksum */ |
599 |
/* read and store data bytes if requested */
|
600 |
if (data != BLT_NULL)
|
601 |
{ |
602 |
for (i=0; i<data_byte_count; i++) |
603 |
{ |
604 |
data[i] = FileLibHexStringToByte(line); |
605 |
line += 2;
|
606 |
} |
607 |
} |
608 |
break;
|
609 |
|
610 |
/* ---------------------------- S2 line type ------------------------------------- */
|
611 |
case LINE_TYPE_S2:
|
612 |
/* adjust pointer to point to byte count value */
|
613 |
line += 2;
|
614 |
/* read out the number of byte values that follow on the line */
|
615 |
bytes_on_line = FileLibHexStringToByte(line); |
616 |
/* read out the 32-bit address */
|
617 |
line += 2;
|
618 |
*address = FileLibHexStringToByte(line) << 16;
|
619 |
line += 2;
|
620 |
*address += FileLibHexStringToByte(line) << 8;
|
621 |
line += 2;
|
622 |
*address += FileLibHexStringToByte(line); |
623 |
/* adjust pointer to point to the first data byte after the address */
|
624 |
line += 2;
|
625 |
/* determine how many data bytes are on the line */
|
626 |
data_byte_count = bytes_on_line - 4; /* -3 bytes address, -1 byte checksum */ |
627 |
/* read and store data bytes if requested */
|
628 |
if (data != BLT_NULL)
|
629 |
{ |
630 |
for (i=0; i<data_byte_count; i++) |
631 |
{ |
632 |
data[i] = FileLibHexStringToByte(line); |
633 |
line += 2;
|
634 |
} |
635 |
} |
636 |
break;
|
637 |
|
638 |
/* ---------------------------- S3 line type ------------------------------------- */
|
639 |
case LINE_TYPE_S3:
|
640 |
/* adjust pointer to point to byte count value */
|
641 |
line += 2;
|
642 |
/* read out the number of byte values that follow on the line */
|
643 |
bytes_on_line = FileLibHexStringToByte(line); |
644 |
/* read out the 32-bit address */
|
645 |
line += 2;
|
646 |
*address = FileLibHexStringToByte(line) << 24;
|
647 |
line += 2;
|
648 |
*address += FileLibHexStringToByte(line) << 16;
|
649 |
line += 2;
|
650 |
*address += FileLibHexStringToByte(line) << 8;
|
651 |
line += 2;
|
652 |
*address += FileLibHexStringToByte(line); |
653 |
/* adjust pointer to point to the first data byte after the address */
|
654 |
line += 2;
|
655 |
/* determine how many data bytes are on the line */
|
656 |
data_byte_count = bytes_on_line - 5; /* -4 bytes address, -1 byte checksum */ |
657 |
/* read and store data bytes if requested */
|
658 |
if (data != BLT_NULL)
|
659 |
{ |
660 |
for (i=0; i<data_byte_count; i++) |
661 |
{ |
662 |
data[i] = FileLibHexStringToByte(line); |
663 |
line += 2;
|
664 |
} |
665 |
} |
666 |
break;
|
667 |
|
668 |
default:
|
669 |
break;
|
670 |
} |
671 |
|
672 |
return data_byte_count;
|
673 |
} /*** end of FileSrecParseLine ***/
|
674 |
|
675 |
|
676 |
#if (BOOT_FILE_LOGGING_ENABLE > 0) |
677 |
/************************************************************************************//** |
678 |
** \brief Helper function to convert a 4-bit value to a character that represents its
|
679 |
** value in hexadecimal format.
|
680 |
** Example: FileLibByteNibbleToChar(11) --> returns 'B'.
|
681 |
** \param nibble 4-bit value to convert.
|
682 |
** \return The resulting byte value.
|
683 |
**
|
684 |
****************************************************************************************/
|
685 |
static blt_char FileLibByteNibbleToChar(blt_int8u nibble)
|
686 |
{ |
687 |
blt_char c; |
688 |
|
689 |
/* convert to ASCII value */
|
690 |
c = (nibble & 0x0f) + '0'; |
691 |
if (nibble > 9) |
692 |
{ |
693 |
c += 7;
|
694 |
} |
695 |
else
|
696 |
{ |
697 |
c = toupper(c); |
698 |
} |
699 |
/* return the character */
|
700 |
return c;
|
701 |
} /*** end of FileLibByteNibbleToChar ***/
|
702 |
|
703 |
|
704 |
/************************************************************************************//** |
705 |
** \brief Helper function to convert a byte value to a string representing the
|
706 |
** value in hexadecimal format.
|
707 |
** Example: FileLibByteToHexString(28, strBuffer) --> returns "1C".
|
708 |
** \param byte_val 8-bit value to convert.
|
709 |
** \param destination Pointer to character buffer for storing the results.
|
710 |
** \return The resulting string.
|
711 |
**
|
712 |
****************************************************************************************/
|
713 |
static blt_char *FileLibByteToHexString(blt_int8u byte_val, blt_char *destination)
|
714 |
{ |
715 |
/* first the most significant n-bit nibble */
|
716 |
destination[0] = FileLibByteNibbleToChar(byte_val >> 4); |
717 |
/* next the least significant n-bit nibble */
|
718 |
destination[1] = FileLibByteNibbleToChar(byte_val & 0x0f); |
719 |
/* add string termination */
|
720 |
destination[2] = '\0'; |
721 |
/* return pointer to resulting string */
|
722 |
return destination;
|
723 |
} /*** end of FileLibByteToHexString ***/
|
724 |
|
725 |
|
726 |
/************************************************************************************//** |
727 |
** \brief Helper function to convert a 32-bit unsigned number to a string that
|
728 |
** represents its decimal value.
|
729 |
** Example: FileLibLongToIntString(1234, strBuffer) --> returns "1234".
|
730 |
** \param long_val 32-bit value to convert.
|
731 |
** \param destination Pointer to character buffer for storing the results.
|
732 |
** \return The resulting string.
|
733 |
**
|
734 |
****************************************************************************************/
|
735 |
static blt_char *FileLibLongToIntString(blt_int32u long_val, blt_char *destination)
|
736 |
{ |
737 |
blt_int32u long_val_cpy = long_val; |
738 |
|
739 |
/* first determine how many digits there will be */
|
740 |
do
|
741 |
{ |
742 |
destination++; |
743 |
long_val_cpy /= 10;
|
744 |
} |
745 |
while (long_val_cpy > 0); |
746 |
/* add space for the string termination and add it */
|
747 |
*destination = '\0';
|
748 |
/* now add the digits from right to left */
|
749 |
long_val_cpy = long_val; |
750 |
do
|
751 |
{ |
752 |
/* set write pointer to where the next character should go */
|
753 |
destination--; |
754 |
/* write digit in ASCII format */
|
755 |
*destination = long_val_cpy % 10 + '0'; |
756 |
/* move on to the next digit */
|
757 |
long_val_cpy /= 10;
|
758 |
} |
759 |
while (long_val_cpy > 0); |
760 |
|
761 |
return destination;
|
762 |
} /*** end of FileLibLongToIntString ***/
|
763 |
#endif /* (BOOT_FILE_LOGGING_ENABLE > 0) */ |
764 |
|
765 |
|
766 |
/************************************************************************************//** |
767 |
** \brief Helper function to convert a sequence of 2 characters that represent
|
768 |
** a hexadecimal value to the actual byte value.
|
769 |
** Example: FileLibHexStringToByte("2f") --> returns 47.
|
770 |
** \param hexstring String beginning with 2 characters that represent a hexa-
|
771 |
** decimal value.
|
772 |
** \return The resulting byte value.
|
773 |
**
|
774 |
****************************************************************************************/
|
775 |
static blt_int8u FileLibHexStringToByte(const blt_char *hexstring) |
776 |
{ |
777 |
blt_int8u result = 0;
|
778 |
blt_char c; |
779 |
blt_int8u counter; |
780 |
|
781 |
/* a hexadecimal character is 2 characters long (i.e 0x4F minus the 0x part) */
|
782 |
for (counter=0; counter < 2; counter++) |
783 |
{ |
784 |
/* read out the character */
|
785 |
c = toupper(hexstring[counter]); |
786 |
/* check that the character is 0..9 or A..F */
|
787 |
if ( (c < '0') || (c > 'F') || ( (c > '9') && (c < 'A') ) ) |
788 |
{ |
789 |
/* character not valid */
|
790 |
return 0; |
791 |
} |
792 |
/* convert character to 4-bit value (check ASCII table for more info) */
|
793 |
c -= '0';
|
794 |
if (c > 9) |
795 |
{ |
796 |
c -= 7;
|
797 |
} |
798 |
/* add it to the result */
|
799 |
result = (result << 4) + c;
|
800 |
} |
801 |
/* return the results */
|
802 |
return result;
|
803 |
} /*** end of FileLibHexStringToByte ***/
|
804 |
|
805 |
#endif /* BOOT_FILE_SYS_ENABLE > 0 */ |
806 |
|
807 |
|
808 |
/*********************************** end of file.c *************************************/
|