/Host/Source/SerialBoot/xcpmaster.c - Annotate - AMiRo-OS - Research for Cognitive Interaction

amiro-blt / Host / Source / SerialBoot / xcpmaster.c @ f7d2c786

History | View | Annotate | Download (31.607 KB)

-            69661903
+/************************************************************************************//**
 * \file         xcpmaster.c
 * \brief        XCP Master source file.
 * \ingroup      SerialBoot
 * \internal
 *----------------------------------------------------------------------------------------
 *                          C O P Y R I G H T
 *----------------------------------------------------------------------------------------
 *   Copyright (c) 2014  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/>.
+*
-            d54d2f07
+* 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
-            69661903
+* proprietary components. The exception text is included at the bottom of the license
 * file <license.html>.
-            d54d2f07
+            Thomas Schöpping
-            69661903
+* \endinternal
 ****************************************************************************************/
 /****************************************************************************************
 * Include files
 ****************************************************************************************/
 #include <assert.h>                                   /* assertion module              */
 #include <sb_types.h>                                 /* C types                       */
 #include "xcpmaster.h"                                /* XCP master protocol module    */
 /****************************************************************************************
 * Macro definitions
 ****************************************************************************************/
 /* XCP command codes as defined by the protocol currently supported by this module */
 #define XCP_MASTER_CMD_CONNECT         (0xFF)
 #define XCP_MASTER_CMD_DISCONNECT      (0xFE)
 #define XCP_MASTER_CMD_SET_MTA         (0xF6)
 #define XCP_MASTER_CMD_UPLOAD          (0xF5)
 #define XCP_MASTER_CMD_PROGRAM_START   (0xD2)
 #define XCP_MASTER_CMD_PROGRAM_CLEAR   (0xD1)
 #define XCP_MASTER_CMD_PROGRAM         (0xD0)
 #define XCP_MASTER_CMD_PROGRAM_RESET   (0xCF)
 #define XCP_MASTER_CMD_PROGRAM_MAX     (0xC9)
 /* XCP response packet IDs as defined by the protocol */
 #define XCP_MASTER_CMD_PID_RES         (0xFF) /* positive response */
 /* timeout values */
 #define XCP_MASTER_CONNECT_TIMEOUT_MS  (20)
 #define XCP_MASTER_TIMEOUT_T1_MS       (1000)  /* standard command timeout */
 #define XCP_MASTER_TIMEOUT_T2_MS       (2000)  /* build checksum timeout */
 #define XCP_MASTER_TIMEOUT_T3_MS       (2000)  /* program start timeout */
 #define XCP_MASTER_TIMEOUT_T4_MS       (10000) /* erase timeout */
 #define XCP_MASTER_TIMEOUT_T5_MS       (1000)  /* write and reset timeout */
 #define XCP_MASTER_TIMEOUT_T6_MS       (1000)  /* user specific connect connect timeout */
 #define XCP_MASTER_TIMEOUT_T7_MS       (2000)  /* wait timer timeout */
 /* XCP error codes */
 /** \brief Cmd processor synchronization error code. */
 #define XCP_ERR_CMD_SYNCH           (0x00)
 /** \brief Command was not executed error code. */
 #define XCP_ERR_CMD_BUSY            (0x10)
 /** \brief Unknown or unsupported command error code. */
 #define XCP_ERR_CMD_UNKNOWN         (0x20)
 /** \brief Parameter out of range error code. */
 #define XCP_ERR_OUT_OF_RANGE        (0x22)
 /** \brief Protected error code. Seed/key required. */
 #define XCP_ERR_ACCESS_LOCKED       (0x25)
 /** \brief Cal page not valid error code. */
 #define XCP_ERR_PAGE_NOT_VALID      (0x26)
 /** \brief Sequence error code. */
 #define XCP_ERR_SEQUENCE            (0x29)
 /** \brief Generic error code. */
 #define XCP_ERR_GENERIC             (0x31)
 /** \brief Number of retries to connect to the XCP slave. */
 #define XCP_MASTER_CONNECT_RETRIES     (5)
 /****************************************************************************************
 * Function prototypes
 ****************************************************************************************/
-            d54d2f07
+static sb_uint8 XcpMasterSendCmdConnect(sb_uint32 flashingTargetID);
-            69661903
+static sb_uint8 XcpMasterSendCmdSetMta(sb_uint32 address);
 static sb_uint8 XcpMasterSendCmdUpload(sb_uint8 data[], sb_uint8 length);
 static sb_uint8 XcpMasterSendCmdProgramStart(void);
 static sb_uint8 XcpMasterSendCmdDisconnect(void);
 static sb_uint8 XcpMasterSendCmdProgramReset(void);
 static sb_uint8 XcpMasterSendCmdProgram(sb_uint8 length, sb_uint8 data[]);
 static sb_uint8 XcpMasterSendCmdProgramMax(sb_uint8 data[]);
 static sb_uint8 XcpMasterSendCmdProgramClear(sb_uint32 length);
 static void     XcpMasterSetOrderedLong(sb_uint32 value, sb_uint8 data[]);
 static void     XcpMasterPrintError(sb_uint8 error);
 /****************************************************************************************
 * Local data declarations
 ****************************************************************************************/
 /** \brief Store the byte ordering of the XCP slave. */
 static sb_uint8 xcpSlaveIsIntel = SB_FALSE;
 /** \brief The max number of bytes in the command transmit object (master->slave). */
 static sb_uint8 xcpMaxCto;
 /** \brief The max number of bytes in the command transmit object (master->slave) during
  *         a programming session.
  */
 static sb_uint8 xcpMaxProgCto = 0;
 /** \brief The max number of bytes in the data transmit object (slave->master). */
 static sb_uint8 xcpMaxDto;
 /** \brief Internal data buffer for storing the data of the XCP response packet. */
 static tXcpTransportResponsePacket responsePacket;
 /************************************************************************************//**
 ** \brief     Initializes the XCP master protocol layer.
 ** \param     device Serial communication device name. For example "COM4".
 ** \param     baudrate Communication speed in bits/sec.
 ** \return    SB_TRUE is successful, SB_FALSE otherwise.
 **
 ****************************************************************************************/
 sb_uint8 XcpMasterInit(sb_char *device, sb_uint32 baudrate, sb_uint8 comIsUart)
+{
   /* initialize the underlying transport layer that is used for the communication */
   return XcpTransportInit(device, baudrate, comIsUart);
 } /*** end of XcpMasterInit ***/
 /************************************************************************************//**
 ** \brief     Uninitializes the XCP master protocol layer.
 ** \return    none.
 **
 ****************************************************************************************/
 void XcpMasterDeinit(void)
+{
   XcpTransportClose();
 } /*** end of XcpMasterDeinit ***/
 /************************************************************************************//**
 ** \brief     Connect to the XCP slave.
 ** \return    SB_TRUE is successfull, SB_FALSE otherwise.
 **
 ****************************************************************************************/
-            d54d2f07
+sb_uint8 XcpMasterConnect(sb_uint32 flashingTargetID)
-            69661903
+            Thomas Schöpping
   sb_uint8 cnt;
   sb_uint8 retries = 1;
   if (flashingTargetID <= 0) {
     retries = XCP_MASTER_CONNECT_RETRIES;
+  }
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* try to connect with a finite amount of retries */
   for (cnt=0; cnt<retries; cnt++)
+  {
     /* send the connect command */
     if (XcpMasterSendCmdConnect(flashingTargetID) == SB_TRUE)
+    {
       /* connected so no need to retry */
       return SB_TRUE;
+    }
+  }
   /* still here so could not connect */
   return SB_FALSE;
 } /*** end of XcpMasterConnect ***/
 /************************************************************************************//**
 ** \brief     Disconnect the slave.
 ** \return    SB_TRUE is successfull, SB_FALSE otherwise.
 **
 ****************************************************************************************/
 sb_uint8 XcpMasterDisconnect(void)
+{
   /* send reset command instead of the disconnect. this causes the user program on the
    * slave to automatically start again if present.
    */
   return XcpMasterSendCmdDisconnect();
 } /*** end of XcpMasterDisconnect ***/
 /************************************************************************************//**
 ** \brief     Resets the user program.
 ** \return    SB_TRUE is successfull, SB_FALSE otherwise.
 **
 ****************************************************************************************/
 sb_uint8 XcpMasterProgramReset(void)
+{
   /* send reset command instead of the disconnect. this causes the user program on the
    * slave to automatically start again if present.
    */
   return XcpMasterSendCmdProgramReset();
 } /*** end of XcpMasterDisconnect ***/
 /************************************************************************************//**
 ** \brief     Puts a connected slave in programming session.
 ** \return    SB_TRUE is successfull, SB_FALSE otherwise.
 **
 ****************************************************************************************/
 sb_uint8 XcpMasterStartProgrammingSession(void)
+{
   /* place the slave in programming mode */
   return XcpMasterSendCmdProgramStart();
 } /*** end of XcpMasterStartProgrammingSession ***/
 /************************************************************************************//**
 ** \brief     Stops the programming session by sending a program command with size 0 and
 **            then resetting the slave.
 ** \return    SB_TRUE is successfull, SB_FALSE otherwise.
 **
 ****************************************************************************************/
 sb_uint8 XcpMasterStopProgrammingSession(void)
+{
   /* stop programming by sending the program command with size 0 */
   if (XcpMasterSendCmdProgram(0, SB_NULL) == SB_FALSE)
+  {
     return SB_FALSE;
+  }
   /* request a reset of the slave */
 //  return XcpMasterSendCmdProgramReset();
   return SB_TRUE;
 } /*** end of XcpMasterStopProgrammingSession ***/
 /************************************************************************************//**
 ** \brief     Erases non volatile memory on the slave.
 ** \param     addr Base memory address for the erase operation.
 ** \param     len Number of bytes to erase.
 ** \return    SB_TRUE is successfull, SB_FALSE otherwise.
 **
 ****************************************************************************************/
 sb_uint8 XcpMasterClearMemory(sb_uint32 addr, sb_uint32 len)
+{
   /* first set the MTA pointer */
   if (XcpMasterSendCmdSetMta(addr) == SB_FALSE)
+  {
     return SB_FALSE;
+  }
   /* now perform the erase operation */
   return XcpMasterSendCmdProgramClear(len);
 } /*** end of XcpMasterClearMemory ***/
 /************************************************************************************//**
 ** \brief     Reads data from the slave's memory.
 ** \param     addr Base memory address for the read operation
 ** \param     len Number of bytes to read.
 ** \param     data Destination buffer for storing the read data bytes.
 ** \return    SB_TRUE is successfull, SB_FALSE otherwise.
 **
 ****************************************************************************************/
 sb_uint8 XcpMasterReadData(sb_uint32 addr, sb_uint32 len, sb_uint8 data[])
+{
   sb_uint8 currentReadCnt;
   sb_uint32 bufferOffset = 0;
   /* first set the MTA pointer */
   if (XcpMasterSendCmdSetMta(addr) == SB_FALSE)
+  {
     return SB_FALSE;
+  }
   /* perform segmented upload of the data */
   while (len > 0)
+  {
     /* set the current read length to make optimal use of the available packet data. */
     currentReadCnt = len % (xcpMaxDto - 1);
     if (currentReadCnt == 0)
+    {
       currentReadCnt = (xcpMaxDto - 1);
+    }
     /* upload some data */
     if (XcpMasterSendCmdUpload(&data[bufferOffset], currentReadCnt) == SB_FALSE)
+    {
       return SB_FALSE;
+    }
     /* update loop variables */
     len -= currentReadCnt;
     bufferOffset += currentReadCnt;
+  }
   /* still here so all data successfully read from the slave */
   return SB_TRUE;
 } /*** end of XcpMasterReadData ***/
 /************************************************************************************//**
 ** \brief     Programs data to the slave's non volatile memory. Note that it must be
 **            erased first.
 ** \param     addr Base memory address for the program operation
 ** \param     len Number of bytes to program.
 ** \param     data Source buffer with the to be programmed bytes.
 ** \return    SB_TRUE is successfull, SB_FALSE otherwise.
 **
 ****************************************************************************************/
 sb_uint8 XcpMasterProgramData(sb_uint32 addr, sb_uint32 len, sb_uint8 data[])
+{
   sb_uint8 currentWriteCnt;
   sb_uint32 bufferOffset = 0;
   /* first set the MTA pointer */
   if (XcpMasterSendCmdSetMta(addr) == SB_FALSE)
+  {
     return SB_FALSE;
+  }
   /* perform segmented programming of the data */
   while (len > 0)
+  {
     /* set the current read length to make optimal use of the available packet data. */
     currentWriteCnt = len % (xcpMaxProgCto - 1);
     if (currentWriteCnt == 0)
+    {
       currentWriteCnt = (xcpMaxProgCto - 1);
+    }
     /* prepare the packed data for the program command */
     if (currentWriteCnt < (xcpMaxProgCto - 1))
+    {
       /* program data */
       if (XcpMasterSendCmdProgram(currentWriteCnt, &data[bufferOffset]) == SB_FALSE)
+      {
         return SB_FALSE;
+      }
+    }
     else
+    {
       /* program max data */
       if (XcpMasterSendCmdProgramMax(&data[bufferOffset]) == SB_FALSE)
+      {
         return SB_FALSE;
+      }
+    }
     /* update loop variables */
     len -= currentWriteCnt;
     bufferOffset += currentWriteCnt;
+  }
   /* still here so all data successfully programmed */
   return SB_TRUE;
 } /*** end of XcpMasterProgramData ***/
 /************************************************************************************//**
 ** \brief     Sends the XCP Connect command.
 ** \return    SB_TRUE is successfull, SB_FALSE otherwise.
 **
 ****************************************************************************************/
-            d54d2f07
+static sb_uint8 XcpMasterSendCmdConnect(sb_uint32 flashingTargetID)
-            69661903
+            Thomas Schöpping
-            d54d2f07
+  sb_uint8 packetData[1+4];
-            69661903
+  tXcpTransportResponsePacket *responsePacketPtr;
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* prepare the command packet */
   packetData[0] = XCP_MASTER_CMD_CONNECT;
-            d54d2f07
+  packetData[1] = (sb_uint8)(0xFF & flashingTargetID >> 0);
   packetData[2] = (sb_uint8)(0xFF & flashingTargetID >> 8);
   packetData[3] = (sb_uint8)(0xFF & flashingTargetID >> 16);
   packetData[4] = (sb_uint8)(0xFF & flashingTargetID >> 24);
   /* send the packet
    * NOTE: For legacy support the following code depends on the MSB if the flashingTargetID.
    *       If the MSB (packData[4]) is zero (i.e. 0x00??????) the system switches to legacy mode.
    *       In legacy mode, the flashingTargetID was only one byte - the LSB (packingData[1]).
    */
   if (XcpTransportSendPacket(packetData, 1 + ((packetData[4] != 0) ? 4 : 1), XCP_MASTER_CONNECT_TIMEOUT_MS) == SB_FALSE)
-            69661903
+            Thomas Schöpping
     /* cound not set packet or receive response within the specified timeout */
     return SB_FALSE;
+  }
   /* still here so a response was received */
   responsePacketPtr = XcpTransportReadResponsePacket();
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* check if the reponse was valid */
   if ( (responsePacketPtr->len == 0) || (responsePacketPtr->data[0] != XCP_MASTER_CMD_PID_RES) )
+  {
     /* not a valid or positive response */
     return SB_FALSE;
+  }
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* process response data */
   if ((responsePacketPtr->data[2] & 0x01) == 0)
+  {
     /* store slave's byte ordering information */
     xcpSlaveIsIntel = SB_TRUE;
+  }
   /* store max number of bytes the slave allows for master->slave packets. */
   xcpMaxCto = responsePacketPtr->data[3];
   xcpMaxProgCto = xcpMaxCto;
   /* store max number of bytes the slave allows for slave->master packets. */
   if (xcpSlaveIsIntel == SB_TRUE)
+  {
     xcpMaxDto = responsePacketPtr->data[4] + (responsePacketPtr->data[5] << 8);
+  }
   else
+  {
     xcpMaxDto = responsePacketPtr->data[5] + (responsePacketPtr->data[4] << 8);
+  }
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* double check size configuration of the master */
   assert(XCP_MASTER_TX_MAX_DATA >= xcpMaxCto);
   assert(XCP_MASTER_RX_MAX_DATA >= xcpMaxDto);
-            d54d2f07
+            Thomas Schöpping
   /* still here so all went well */
-            69661903
+  return SB_TRUE;
 } /*** end of XcpMasterSendCmdConnect ***/
 /************************************************************************************//**
 ** \brief     Sends the XCP Set MTA command.
 ** \param     address New MTA address for the slave.
 ** \return    SB_TRUE is successfull, SB_FALSE otherwise.
 **
 ****************************************************************************************/
 static sb_uint8 XcpMasterSendCmdSetMta(sb_uint32 address)
+{
   sb_uint8 packetData[8];
   tXcpTransportResponsePacket *responsePacketPtr;
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* prepare the command packet */
   packetData[0] = XCP_MASTER_CMD_SET_MTA;
   packetData[1] = 0; /* reserved */
   packetData[2] = 0; /* reserved */
   packetData[3] = 0; /* address extension not supported */
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* set the address taking into account byte ordering */
   XcpMasterSetOrderedLong(address, &packetData[4]);
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* send the packet */
   if (XcpTransportSendPacket(packetData, 8, XCP_MASTER_TIMEOUT_T4_MS) == SB_FALSE) //XCP_MASTER_TIMEOUT_T1_MS
+  {
     /* cound not set packet or receive response within the specified timeout */
     printf("\nno response (set MTA)\n");
     return SB_FALSE;
+  }
   /* still here so a response was received */
   responsePacketPtr = XcpTransportReadResponsePacket();
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* check if the reponse was valid */
   if ( (responsePacketPtr->len == 0) || (responsePacketPtr->data[0] != XCP_MASTER_CMD_PID_RES) )
+  {
     /* not a valid or positive response */
     if (responsePacketPtr->len == 0) {
       printf("\nmessage length = 0");
     } else {
       XcpMasterPrintError(responsePacketPtr->data[1]);
+    }
     printf(" (set MTA)\n");
     return SB_FALSE;
+  }
-            d54d2f07
+            Thomas Schöpping
   /* still here so all went well */
-            69661903
+  return SB_TRUE;
 } /*** end of XcpMasterSendCmdSetMta ***/
 /************************************************************************************//**
 ** \brief     Sends the XCP UPLOAD command.
 ** \param     data Destination data buffer.
 ** \param     length Number of bytes to upload.
 ** \return    SB_TRUE is successfull, SB_FALSE otherwise.
 **
 ****************************************************************************************/
 static sb_uint8 XcpMasterSendCmdUpload(sb_uint8 data[], sb_uint8 length)
+{
   sb_uint8 packetData[2];
   tXcpTransportResponsePacket *responsePacketPtr;
   sb_uint8 data_index;
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* cannot request more data then the max rx data - 1 */
   assert(length < XCP_MASTER_RX_MAX_DATA);
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* prepare the command packet */
   packetData[0] = XCP_MASTER_CMD_UPLOAD;
   packetData[1] = length;
   /* send the packet */
   if (XcpTransportSendPacket(packetData, 2, XCP_MASTER_TIMEOUT_T4_MS) == SB_FALSE) //XCP_MASTER_TIMEOUT_T1_MS
+  {
     /* cound not set packet or receive response within the specified timeout */
     printf("\nno response (upload)\n");
     return SB_FALSE;
+  }
   /* still here so a response was received */
   responsePacketPtr = XcpTransportReadResponsePacket();
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* check if the reponse was valid */
   if ( (responsePacketPtr->len == 0) || (responsePacketPtr->data[0] != XCP_MASTER_CMD_PID_RES) )
+  {
     /* not a valid or positive response */
     if (responsePacketPtr->len == 0) {
       printf("\nmessage length = 0");
     } else {
       XcpMasterPrintError(responsePacketPtr->data[1]);
+    }
     printf(" (upload)\n");
     return SB_FALSE;
+  }
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* now store the uploaded data */
   for (data_index=0; data_index<length; data_index++)
+  {
     data[data_index] = responsePacketPtr->data[data_index+1];
+  }
-            d54d2f07
+            Thomas Schöpping
   /* still here so all went well */
-            69661903
+  return SB_TRUE;
 } /*** end of XcpMasterSendCmdUpload ***/
 /************************************************************************************//**
 ** \brief     Sends the XCP PROGRAM START command.
 ** \return    SB_TRUE is successfull, SB_FALSE otherwise.
 **
 ****************************************************************************************/
 static sb_uint8 XcpMasterSendCmdProgramStart(void)
+{
   sb_uint8 packetData[1];
   tXcpTransportResponsePacket *responsePacketPtr;
   /* prepare the command packet */
   packetData[0] = XCP_MASTER_CMD_PROGRAM_START;
   /* send the packet */
   if (XcpTransportSendPacket(packetData, 1, XCP_MASTER_TIMEOUT_T4_MS) == SB_FALSE) //XCP_MASTER_TIMEOUT_T3_MS
+  {
     /* cound not set packet or receive response within the specified timeout */
     printf("\nno response (program start)\n");
     return SB_FALSE;
+  }
   /* still here so a response was received */
   responsePacketPtr = XcpTransportReadResponsePacket();
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* check if the reponse was valid */
   if ( (responsePacketPtr->len == 0) || (responsePacketPtr->data[0] != XCP_MASTER_CMD_PID_RES) )
+  {
     /* not a valid or positive response */
     if (responsePacketPtr->len == 0) {
       printf("\nmessage length = 0");
     } else {
       XcpMasterPrintError(responsePacketPtr->data[1]);
+    }
     printf(" (program start)\n");
     return SB_FALSE;
+  }
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* store max number of bytes the slave allows for master->slave packets during the
    * programming session
    */
   xcpMaxProgCto = responsePacketPtr->data[3];
-            d54d2f07
+            Thomas Schöpping
   /* still here so all went well */
-            69661903
+  return SB_TRUE;
 } /*** end of XcpMasterSendCmdProgramStart ***/
 /************************************************************************************//**
 ** \brief     Sends the XCP PROGRAM DISCONNECT command.
 ** \return    SB_TRUE is successfull, SB_FALSE otherwise.
 **
 ****************************************************************************************/
 static sb_uint8 XcpMasterSendCmdDisconnect(void)
+{
   sb_uint8 packetData[1];
   tXcpTransportResponsePacket *responsePacketPtr;
   /* prepare the command packet */
   packetData[0] = XCP_MASTER_CMD_DISCONNECT;
   /* send the packet */
   if (XcpTransportSendPacket(packetData, 1, XCP_MASTER_TIMEOUT_T4_MS) == SB_FALSE)
+  {
     /* cound not set packet or receive response within the specified timeout */
     return SB_FALSE;
+  }
   /* still here so a response was received */
   responsePacketPtr = XcpTransportReadResponsePacket();
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* check if the reponse was valid */
   if ( (responsePacketPtr->len == 0) || (responsePacketPtr->data[0] != XCP_MASTER_CMD_PID_RES) )
+  {
     /* not a valid or positive response */
     return SB_FALSE;
+  }
-            d54d2f07
+            Thomas Schöpping
   /* still here so all went well */
-            69661903
+  return SB_TRUE;
 } /*** end of XcpMasterSendCmdProgramStart ***/
 /************************************************************************************//**
-            d54d2f07
+** \brief     Sends the XCP PROGRAM RESET command. Note that this command is a bit
-            69661903
+**            different as in it does not require a response.
 ** \return    SB_TRUE is successfull, SB_FALSE otherwise.
 **
 ****************************************************************************************/
 static sb_uint8 XcpMasterSendCmdProgramReset(void)
+{
   sb_uint8 packetData[1];
   tXcpTransportResponsePacket *responsePacketPtr;
   /* prepare the command packet */
   packetData[0] = XCP_MASTER_CMD_PROGRAM_RESET;
   /* send the packet, assume the sending itself is ok and check if a response was
    * received.
    */
   if (XcpTransportSendPacket(packetData, 1, XCP_MASTER_TIMEOUT_T4_MS) == SB_FALSE) //XCP_MASTER_TIMEOUT_T5_MS
+  {
     /* probably no response received within the specified timeout, but that is allowed
      * for the reset command.
      */
 //    printf("no response");
     return SB_TRUE;
+  }
 /*
  * The following part is critical if the user program uses the same connection like the flashing program!
  * In this case the bootloader doesn't send any information after the reset command. According to this
  * the following code part can be skipped.
  */
 //  /* still here so a response was received */
 //  responsePacketPtr = XcpTransportReadResponsePacket();
-            d54d2f07
+//
-            69661903
+//  /* check if the reponse was valid */
 //  printf("response not valid\nlength: %u\nresponse: %i", responsePacketPtr->len, *(responsePacketPtr->data));
 //  if ( (responsePacketPtr->len == 0) || (responsePacketPtr->data[0] != XCP_MASTER_CMD_PID_RES) )
 //  {
 //    /* not a valid or positive response */
 //    return SB_FALSE;
 //  }
-            d54d2f07
+            Thomas Schöpping
   /* still here so all went well */
-            69661903
+  return SB_TRUE;
 } /*** end of XcpMasterSendCmdProgramReset ***/
 /************************************************************************************//**
 ** \brief     Sends the XCP PROGRAM command.
 ** \param     length Number of bytes in the data array to program.
 ** \param     data Array with data bytes to program.
 ** \return    SB_TRUE is successfull, SB_FALSE otherwise.
 **
 ****************************************************************************************/
 static sb_uint8 XcpMasterSendCmdProgram(sb_uint8 length, sb_uint8 data[])
+{
   sb_uint8 packetData[XCP_MASTER_TX_MAX_DATA];
   tXcpTransportResponsePacket *responsePacketPtr;
   sb_uint8 cnt;
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* verify that this number of bytes actually first in this command */
   assert(length <= (xcpMaxProgCto-2) && (xcpMaxProgCto <= XCP_MASTER_TX_MAX_DATA));
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* prepare the command packet */
   packetData[0] = XCP_MASTER_CMD_PROGRAM;
   packetData[1] = length;
   for (cnt=0; cnt<length; cnt++)
+  {
     packetData[cnt+2] = data[cnt];
+  }
   /* send the packet */
   if (XcpTransportSendPacket(packetData, length+2, XCP_MASTER_TIMEOUT_T4_MS) == SB_FALSE) //XCP_MASTER_TIMEOUT_T5_MS
+  {
     /* cound not set packet or receive response within the specified timeout */
     printf("\nno response (program)\n");
     return SB_FALSE;
+  }
   /* still here so a response was received */
   responsePacketPtr = XcpTransportReadResponsePacket();
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* check if the reponse was valid */
   if ( (responsePacketPtr->len == 0) || (responsePacketPtr->data[0] != XCP_MASTER_CMD_PID_RES) )
+  {
     /* not a valid or positive response */
     if (responsePacketPtr->len == 0) {
       printf("\nmessage length = 0");
     } else {
       XcpMasterPrintError(responsePacketPtr->data[1]);
+    }
     printf(" (program)\n");
     return SB_FALSE;
+  }
-            d54d2f07
+            Thomas Schöpping
   /* still here so all went well */
-            69661903
+  return SB_TRUE;
 } /*** end of XcpMasterSendCmdProgram ***/
 /************************************************************************************//**
 ** \brief     Sends the XCP PROGRAM MAX command.
 ** \param     data Array with data bytes to program.
 ** \return    SB_TRUE is successfull, SB_FALSE otherwise.
 **
 ****************************************************************************************/
 static sb_uint8 XcpMasterSendCmdProgramMax(sb_uint8 data[])
+{
   sb_uint8 packetData[XCP_MASTER_TX_MAX_DATA];
   tXcpTransportResponsePacket *responsePacketPtr;
   sb_uint8 cnt;
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* verify that this number of bytes actually first in this command */
   assert(xcpMaxProgCto <= XCP_MASTER_TX_MAX_DATA);
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* prepare the command packet */
   packetData[0] = XCP_MASTER_CMD_PROGRAM_MAX;
   for (cnt=0; cnt<(xcpMaxProgCto-1); cnt++)
+  {
     packetData[cnt+1] = data[cnt];
+  }
   /* send the packet */
   if (XcpTransportSendPacket(packetData, xcpMaxProgCto, XCP_MASTER_TIMEOUT_T4_MS) == SB_FALSE) //XCP_MASTER_TIMEOUT_T5_MS
+  {
     /* cound not set packet or receive response within the specified timeout */
     printf("\nno response (program max)\n");
     return SB_FALSE;
+  }
   /* still here so a response was received */
   responsePacketPtr = XcpTransportReadResponsePacket();
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* check if the reponse was valid */
   if ( (responsePacketPtr->len == 0) || (responsePacketPtr->data[0] != XCP_MASTER_CMD_PID_RES) )
+  {
     /* not a valid or positive response */
     if (responsePacketPtr->len == 0) {
       printf("\nmessage length = 0");
     } else {
       XcpMasterPrintError(responsePacketPtr->data[1]);
+    }
     printf(" (program max)\n");
     return SB_FALSE;
+  }
-            d54d2f07
+            Thomas Schöpping
   /* still here so all went well */
-            69661903
+  return SB_TRUE;
 } /*** end of XcpMasterSendCmdProgramMax ***/
 /************************************************************************************//**
 ** \brief     Sends the XCP PROGRAM CLEAR command.
 ** \return    SB_TRUE is successfull, SB_FALSE otherwise.
 **
 ****************************************************************************************/
 static sb_uint8 XcpMasterSendCmdProgramClear(sb_uint32 length)
+{
   sb_uint8 packetData[8];
   tXcpTransportResponsePacket *responsePacketPtr;
   /* prepare the command packet */
   packetData[0] = XCP_MASTER_CMD_PROGRAM_CLEAR;
   packetData[1] = 0; /* use absolute mode */
   packetData[2] = 0; /* reserved */
   packetData[3] = 0; /* reserved */
   /* set the erase length taking into account byte ordering */
   XcpMasterSetOrderedLong(length, &packetData[4]);
   /* send the packet */
   if (XcpTransportSendPacket(packetData, 8, XCP_MASTER_TIMEOUT_T4_MS) == SB_FALSE)
+  {
     /* cound not set packet or receive response within the specified timeout */
     printf("\nno response (program clear)\n");
     return SB_FALSE;
+  }
   /* still here so a response was received */
   responsePacketPtr = XcpTransportReadResponsePacket();
-            d54d2f07
+            Thomas Schöpping
-            69661903
+  /* check if the reponse was valid */
   if ( (responsePacketPtr->len == 0) || (responsePacketPtr->data[0] != XCP_MASTER_CMD_PID_RES) )
+  {
     /* not a valid or positive response */
     if (responsePacketPtr->len == 0) {
       printf("\nmessage length = 0");
     } else {
       XcpMasterPrintError(responsePacketPtr->data[1]);
+    }
     printf(" (program clear)\n");
     return SB_FALSE;
+  }
-            d54d2f07
+            Thomas Schöpping
   /* still here so all went well */
-            69661903
+  return SB_TRUE;
 } /*** end of XcpMasterSendCmdProgramClear ***/
 /************************************************************************************//**
 ** \brief     Stores a 32-bit value into a byte buffer taking into account Intel
 **            or Motorola byte ordering.
 ** \param     value The 32-bit value to store in the buffer.
 ** \param     data Array to the buffer for storage.
 ** \return    none.
 **
 ****************************************************************************************/
 static void XcpMasterSetOrderedLong(sb_uint32 value, sb_uint8 data[])
+{
   if (xcpSlaveIsIntel == SB_TRUE)
+  {
     data[3] = (sb_uint8)(value >> 24);
     data[2] = (sb_uint8)(value >> 16);
     data[1] = (sb_uint8)(value >>  8);
     data[0] = (sb_uint8)value;
+  }
   else
+  {
     data[0] = (sb_uint8)(value >> 24);
     data[1] = (sb_uint8)(value >> 16);
     data[2] = (sb_uint8)(value >>  8);
     data[3] = (sb_uint8)value;
+  }
 } /*** end of XcpMasterSetOrderedLong ***/
 static void XcpMasterPrintError(sb_uint8 error) {
   printf("\nError: ");
   switch (error) {
     case XCP_ERR_CMD_SYNCH:
       printf("command processor synchronization"); break;
     case XCP_ERR_CMD_BUSY:
       printf("command was not executed"); break;
     case XCP_ERR_CMD_UNKNOWN:
       printf("unknown or unsupported command"); break;
     case XCP_ERR_OUT_OF_RANGE:
       printf("parameter out of range"); break;
     case XCP_ERR_ACCESS_LOCKED:
       printf("protected - seed/key required"); break;
     case XCP_ERR_PAGE_NOT_VALID:
       printf("cal page not valid"); break;
     case XCP_ERR_SEQUENCE:
       printf("sequence"); break;
     case XCP_ERR_GENERIC:
       printf("generic"); break;
     default:
       printf("!UNKNOWN ERROR!");
+  }
   printf("\n");
+}
 /*********************************** end of xcpmaster.c ********************************/