AMiRo-OS

/************************************************************************************//**

* \file         Source\file.c

* \brief        Bootloader file system interface source file.

* \ingroup      Core

* \internal

*----------------------------------------------------------------------------------------

*                          C O P Y R I G H T

*----------------------------------------------------------------------------------------

*   Copyright (c) 2013  by Feaser    http://www.feaser.com    All rights reserved

*

*----------------------------------------------------------------------------------------

*                            L I C E N S E

*----------------------------------------------------------------------------------------

* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or

* modify it under the terms of the GNU General Public License as published by the Free

* Software Foundation, either version 3 of the License, or (at your option) any later

* version.

*

* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;

* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

* PURPOSE. See the GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License along with OpenBLT.

* If not, see <http://www.gnu.org/licenses/>.

*

* A special exception to the GPL is included to allow you to distribute a combined work 

* that includes OpenBLT without being obliged to provide the source code for any 

* proprietary components. The exception text is included at the bottom of the license

* file <license.html>.

* 

* \endinternal

****************************************************************************************/

/****************************************************************************************

* Include files

****************************************************************************************/

#include "boot.h"                                     /* bootloader generic header     */

#include <string.h>                                   /* for strcpy etc.               */

#include <ctype.h>                                    /* for toupper() etc.            */

#if (BOOT_FILE_SYS_ENABLE > 0)

/****************************************************************************************

* Type definitions

****************************************************************************************/

/** \brief Enumeration for the different internal module states. */

typedef enum 

{ 

  FIRMWARE_UPDATE_STATE_IDLE,                    /**< idle state                       */

  FIRMWARE_UPDATE_STATE_STARTING,                /**< starting state                   */

  FIRMWARE_UPDATE_STATE_ERASING,                 /**< erasing state                    */

  FIRMWARE_UPDATE_STATE_PROGRAMMING              /**< programming state                */

} tFirmwareUpdateState;

/** \brief Structure type with information for the memory erase opeartion. */

typedef struct 

{

  blt_addr   start_address;                      /**< erase start address              */

  blt_int32u total_size;                         /**< total number of bytes to erase   */

} tFileEraseInfo;

/** \brief Structure type for grouping FATFS related objects used by this module. */

typedef struct 

{

  FATFS fs;                                      /**< file system object for mouting   */

  FIL   file;                                    /**< file object for firmware file    */

} tFatFsObjects;

/****************************************************************************************

* Function prototypes

****************************************************************************************/

#if (BOOT_FILE_LOGGING_ENABLE > 0)

static blt_char      FileLibByteNibbleToChar(blt_int8u nibble);

static blt_char     *FileLibByteToHexString(blt_int8u byte_val, blt_char *destination);

static blt_char     *FileLibLongToIntString(blt_int32u long_val, blt_char *destination);

#endif

static blt_int8u     FileLibHexStringToByte(const blt_char *hexstring);

/****************************************************************************************

* Hook functions

****************************************************************************************/

extern blt_bool        FileIsFirmwareUpdateRequestedHook(void);

extern const blt_char *FileGetFirmwareFilenameHook(void);

extern void            FileFirmwareUpdateStartedHook(void);

extern void            FileFirmwareUpdateCompletedHook(void);

extern void            FileFirmwareUpdateErrorHook(blt_int8u error_code);

extern void            FileFirmwareUpdateLogHook(blt_char *info_string);

/****************************************************************************************

* Local data declarations

****************************************************************************************/

/** \brief Local variable that holds the internal module state. */

static tFirmwareUpdateState firmwareUpdateState;

/** \brief Local variable for the used FATFS objects in this module. */

static tFatFsObjects        fatFsObjects;

/** \brief Local variable for storing S-record line parsing results. */

static tSrecLineParseObject lineParseObject;

/** \brief Local variable for storing information regarding the memory erase operation.*/

static tFileEraseInfo       eraseInfo;

#if (BOOT_FILE_LOGGING_ENABLE > 0)

/** \brief Local character buffer for storing the string with log information. */

static blt_char             loggingStr[64];

#endif

/***********************************************************************************//**

** \brief     Initializes the file system interface module. The initial firmware

**            update state is set to idle and the file system is mounted as 

**            logical disk 0.

** \return    none

**

****************************************************************************************/

void FileInit(void)

{

  FRESULT fresult;

  /* set the initial state */

  firmwareUpdateState = FIRMWARE_UPDATE_STATE_IDLE;

  /* mount the file system, using logical disk 0 */

  fresult = f_mount(0, &fatFsObjects.fs);

  /* mounting does not access the disk and should succeed unless misconfigured */

  ASSERT_RT(fresult == FR_OK);

} /*** end of FileInit ***/

/***********************************************************************************//**

** \brief     This function checks if a firmware update through the locally attached

**            storage is in progress or not (idle).

** \return    BLT_TRUE when in idle state, BLT_FALSE otherwise.

**

****************************************************************************************/

blt_bool FileIsIdle(void)

{

  if (firmwareUpdateState == FIRMWARE_UPDATE_STATE_IDLE)

  {

    return BLT_TRUE;

  }

  return BLT_FALSE;

} /*** end of FileIsIdle ***/

/***********************************************************************************//**

** \brief     This function checks if a firmware update through the locally attached

**            storage is requested to be started and if so processes this request

**            by transitioning from the IDLE to the STARTING state.

** \return    BLT_TRUE when a firmware update is requested, BLT_FALSE otherwise.

**

****************************************************************************************/

blt_bool FileHandleFirmwareUpdateRequest(void)

{

  #if (BOOT_COM_ENABLE > 0)

  /* make sure that there is no connection with a remote host to prevent two firmware

   * updates happening at the same time

   */

  if (ComIsConnected() == BLT_TRUE)

  {

    return BLT_FALSE;

  }

  #endif

  /* a new firmware update request can only be handled if not already busy with one */

  if (firmwareUpdateState != FIRMWARE_UPDATE_STATE_IDLE)

  {

    return BLT_FALSE;

  }

  /* check if a firmware update is requested */

  if (FileIsFirmwareUpdateRequestedHook() == BLT_TRUE)

  {

    /* transition from IDLE to STARTING state, which kicks off the update sequence */

    firmwareUpdateState = FIRMWARE_UPDATE_STATE_STARTING;

    return BLT_TRUE;

  }

  /* still here so no update request pending */

  return BLT_FALSE;

} /*** end of FileHandleFirmwareUpdateRequest ***/

/***********************************************************************************//**

** \brief     File system task function for managing the firmware updates from

**                 locally attached storage.

** \return    none.

**

****************************************************************************************/

void FileTask(void)

{

  blt_int16s  parse_result;

  blt_char   *read_line_ptr;

  /* ------------------------------- idle -------------------------------------------- */

  if (firmwareUpdateState == FIRMWARE_UPDATE_STATE_IDLE)

  {

    /* currently, nothings need to be done while idling */

  }

  /* ------------------------------- starting ---------------------------------------- */

  else if (firmwareUpdateState == FIRMWARE_UPDATE_STATE_STARTING)

  {

    #if (BOOT_FILE_STARTED_HOOK_ENABLE > 0)

    /* inform application about update started event via hook function */

    FileFirmwareUpdateStartedHook();

    #endif

    #if (BOOT_FILE_LOGGING_ENABLE > 0)

    FileFirmwareUpdateLogHook("Firmware update request detected\n\r");

    FileFirmwareUpdateLogHook("Opening firmware file for reading...");

    #endif

    /* attempt to obtain a file object for the firmware file */

    if (f_open(&fatFsObjects.file, FileGetFirmwareFilenameHook(), FA_OPEN_EXISTING | FA_READ) != FR_OK)

    {

      /* can't open file */

      #if (BOOT_FILE_LOGGING_ENABLE > 0)

      FileFirmwareUpdateLogHook("ERROR\n\r");

      #endif

      #if (BOOT_FILE_ERROR_HOOK_ENABLE > 0)

      FileFirmwareUpdateErrorHook(FILE_ERROR_CANNOT_OPEN_FIRMWARE_FILE);

      #endif        

      /* nothing left to do now */

      return;

    }

    #if (BOOT_FILE_LOGGING_ENABLE > 0)

    FileFirmwareUpdateLogHook("OK\n\r");

    FileFirmwareUpdateLogHook("Starting the programming sequence\n\r");

    FileFirmwareUpdateLogHook("Parsing firmware file to obtain erase size...");

    #endif

    /* prepare data objects for the erasing state */

    eraseInfo.start_address = 0;

    eraseInfo.total_size = 0;

    /* transition from idle to erasing state */

    firmwareUpdateState = FIRMWARE_UPDATE_STATE_ERASING;

  }

  /* ------------------------------- erasing ----------------------------------------- */

  else if (firmwareUpdateState == FIRMWARE_UPDATE_STATE_ERASING)

  {

    /* read a line from the file */

    read_line_ptr = f_gets(lineParseObject.line, sizeof(lineParseObject.line), &fatFsObjects.file);

    /* check if an error occurred */

    if (f_error(&fatFsObjects.file) > 0)

    {

      #if (BOOT_FILE_LOGGING_ENABLE >