Обновление

Inc/CanSerialPortFrameXCP.h

@@ -75,6 +75,13 @@ typedef enum {
 
 } eXcpTypeCommand;
 
+typedef enum {
+    XCP_PROTECT_CAL_PAG = 0x01,
+    XCP_PROTECT_DAQ = 0x04,
+    XCP_PROTECT_STM = 0x08,
+    XCP_PROTECT_PGM = 0x10
+} eTypeProtect;
+
 typedef enum {
     XCP_STOP = 0,
     XCP_START = 1,
@@ -590,12 +597,12 @@ typedef struct {
     tLoggerInterface *logger;
     tVarsTabDumpObserver *varsTabDumpObserver;
 
-    uint8_t RESOURCE;
+    eTypeProtect RESOURCE;
     uint8_t ADR_EXT;
     uint32_t ADR_MTA;
     uint8_t PAGE_ID;
 
-
+    bool PROTECT[4];
 
     can_rx_message_type canFrame;
     uint8_t downloadRemaining;

Src/CanSerialPortFrameXCP.c

@@ -58,6 +58,27 @@ void PrintfDebug(uint8_t *data, uint8_t dlc) {
 
 }
 
+static bool isUNLOCK(tCanSerialPortFrameXCP *env, eTypeProtect RESOURCE) {
+
+    if ((RESOURCE == XCP_PROTECT_CAL_PAG) && (env->PROTECT[0])) {
+        return true;
+    }
+
+    if ((RESOURCE == XCP_PROTECT_DAQ) && (env->PROTECT[1])) {
+        return true;
+    }
+
+    if ((RESOURCE == XCP_PROTECT_STM) && (env->PROTECT[2])) {
+        return true;
+    }
+
+    if ((RESOURCE == XCP_PROTECT_PGM) && (env->PROTECT[3])) {
+        return true;
+    }
+
+    return false;
+}
+
 static unsigned long SeedToKeyHVAC_NAMI(unsigned char rnd, unsigned long dwSeedInfo) {
 #define Mask 0x55F388A6UL
 
@@ -261,9 +282,44 @@ static uint8_t XCP_UNLOCK_F7(tCanSerialPortFrameXCP *env) {
     if (securitySeedMy != request->KEY) {
         env->response[0] = XCP_COMMAND_DISCONNECT;
         env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        if (env->RESOURCE == XCP_PROTECT_CAL_PAG) {
+            env->PROTECT[0] = false;
+        }
+
+        if (env->RESOURCE == XCP_PROTECT_DAQ) {
+            env->PROTECT[1] = false;
+        }
+
+        if (env->RESOURCE == XCP_PROTECT_STM) {
+            env->PROTECT[2] = false;
+        }
+
+        if (env->RESOURCE == XCP_PROTECT_PGM) {
+            env->PROTECT[3] = false;
+        }
+
+
     } else {
         env->response[0] = XCP_COMMAND_CONNECT;
         env->response[1] = 0;
+
+        if (env->RESOURCE == XCP_PROTECT_CAL_PAG) {
+            env->PROTECT[0] = true;
+        }
+
+        if (env->RESOURCE == XCP_PROTECT_DAQ) {
+            env->PROTECT[1] = true;
+        }
+
+        if (env->RESOURCE == XCP_PROTECT_STM) {
+            env->PROTECT[2] = true;
+        }
+
+        if (env->RESOURCE == XCP_PROTECT_PGM) {
+            env->PROTECT[3] = true;
+        }
+
     }
 
     return 2;
@@ -372,6 +428,13 @@ static uint8_t XCP_COMMAND_DOWNLOAD_F0(tCanSerialPortFrameXCP *env) {
 
     eXcpCommand_Download *request = (eXcpCommand_Download *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_CAL_PAG) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     uint8_t COUNT = env->canFrame.dlc - 2;
 
     memcpy((uint8_t *) (env->ADR_MTA), &env->response[2], COUNT);
@@ -387,6 +450,13 @@ static uint8_t XCP_COMMAND_DOWNLOAD_NEXT_EF(tCanSerialPortFrameXCP *env) {
 
     eXcpCommand_Download *request = (eXcpCommand_Download *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_CAL_PAG) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     uint8_t COUNT = env->canFrame.dlc - 2;
 
     memcpy((uint8_t *) (env->ADR_MTA), &env->response[2], COUNT);
@@ -412,6 +482,13 @@ static uint8_t XCP_COMMAND_DOWNLOAD_NEXT_EF(tCanSerialPortFrameXCP *env) {
 
 static uint8_t XCP_COMMAND_DOWNLOAD_MAX_EE(tCanSerialPortFrameXCP *env) {
 
+    if (isUNLOCK(env, XCP_PROTECT_CAL_PAG) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     uint8_t COUNT = env->canFrame.dlc - 1;
 
     memcpy((uint8_t *) (env->ADR_MTA), &env->response[1], COUNT);
@@ -425,6 +502,13 @@ static uint8_t XCP_COMMAND_DOWNLOAD_MAX_EE(tCanSerialPortFrameXCP *env) {
 
 static uint8_t XCP_CLEAR_DAQ_LIST_E3(tCanSerialPortFrameXCP *env) {
 
+    if (isUNLOCK(env, XCP_PROTECT_DAQ) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     env->response[0] = XCP_COMMAND_CONNECT;
 
     return 1;
@@ -434,6 +518,13 @@ static uint8_t XCP_CLEAR_DAQ_LIST_E3(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_GET_DAQ_LIST_INFO_D8(tCanSerialPortFrameXCP *env) {
     eXcpCommand_Get_DAQ_List_Info_Request *request = (eXcpCommand_Get_DAQ_List_Info_Request *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_DAQ) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     if (request->DAQ_LIST_NUMBER > MAX_DAO) {
         env->response[0] = XCP_COMMAND_DISCONNECT;
         env->response[1] = XCP_ERR_OUT_OF_RANGE;
@@ -461,6 +552,13 @@ static uint8_t XCP_GET_DAQ_LIST_INFO_D8(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_ALLOC_DAQ_D5(tCanSerialPortFrameXCP *env) {
     eXcpCommand_ALLOC_DAQ *request = (eXcpCommand_ALLOC_DAQ *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_DAQ) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     env->SETUP.DAQ_COUNT = request->DAQ_COUNT;
 
     env->response[0] = XCP_COMMAND_CONNECT;
@@ -468,6 +566,14 @@ static uint8_t XCP_ALLOC_DAQ_D5(tCanSerialPortFrameXCP *env) {
 }
 
 static uint8_t XCP_FREE_DAQ_D6(tCanSerialPortFrameXCP *env) {
+
+    if (isUNLOCK(env, XCP_PROTECT_DAQ) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     FREE_DAQ(env);
 
     env->response[0] = XCP_COMMAND_CONNECT;
@@ -477,6 +583,13 @@ static uint8_t XCP_FREE_DAQ_D6(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_ALLOC_ODT_D4(tCanSerialPortFrameXCP *env) {
     eXcpCommand_ALLOC_ODT *request = (eXcpCommand_ALLOC_ODT *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_DAQ) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     env->DAQ[request->DAQ_LIST_NUMBER].ODT_COUNT = request->ODT_COUNT;
 
     env->response[0] = XCP_COMMAND_CONNECT;
@@ -487,6 +600,13 @@ static uint8_t XCP_ALLOC_ODT_D4(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_ALLOC_ODT_ENTRY_D3(tCanSerialPortFrameXCP *env) {
     eXcpCommand_ALLOC_ODT_ENTRY *request = (eXcpCommand_ALLOC_ODT_ENTRY *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_DAQ) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     env->DAQ[request->DAQ_LIST_NUMBER].ODT_NUMBER[request->ODT_NUMBER].ODT_ENTRIES_COUNT = request->ODT_ENTRIES_COUNT;
 
     env->response[0] = XCP_COMMAND_CONNECT;
@@ -497,6 +617,13 @@ static uint8_t XCP_ALLOC_ODT_ENTRY_D3(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_SET_DAQ_PTR_E2(tCanSerialPortFrameXCP *env) {
     eXcpCommand_SET_DAQ_PTR *request = (eXcpCommand_SET_DAQ_PTR *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_DAQ) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     if ((request->DAQ_LIST_NUMBER > MAX_DAO) ||
         (request->ODT_NUMBER > MAX_ODT) ||
         (request->ODT_ENTRY_NUMBER > MAX_ODT_ENTRIES_SIZE_DAQ)) {
@@ -519,6 +646,13 @@ static uint8_t XCP_SET_DAQ_PTR_E2(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_WRITE_DAQ_E1(tCanSerialPortFrameXCP *env) {
     eXcpCommand_WRITE_DAQ *request = (eXcpCommand_WRITE_DAQ *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_DAQ) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     if (env->SETUP.ODT_ENTRY_NUMBER > MAX_ODT_ENTRIES_SIZE_DAQ) {
 
         env->response[0] = XCP_COMMAND_DISCONNECT;
@@ -541,6 +675,13 @@ static uint8_t XCP_WRITE_DAQ_E1(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_SET_DAQ_LIST_MODE_E0(tCanSerialPortFrameXCP *env) {
     eXcpCommand_SET_DAQ_LIST_MODE *request = (eXcpCommand_SET_DAQ_LIST_MODE *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_DAQ) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     if ((request->DAQ_LIST_NUMBER > MAX_DAO) || (request->EVENT_CHANNEL_NUMBER > MAX_EVENT_CHANNEL)) {
         env->response[0] = XCP_COMMAND_DISCONNECT;
         env->response[1] = XCP_ERR_OUT_OF_RANGE;
@@ -568,6 +709,13 @@ static uint8_t XCP_SET_DAQ_LIST_MODE_E0(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_START_STOP_DAQ_LIST_DE(tCanSerialPortFrameXCP *env) {
     eXcpCommand_START_STOP_DAQ_LIST *request = (eXcpCommand_START_STOP_DAQ_LIST *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_DAQ) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     if (request->DAQ_LIST_NUMBER > MAX_DAO) {
         env->response[0] = XCP_COMMAND_DISCONNECT;
         env->response[1] = XCP_ERR_OUT_OF_RANGE;
@@ -594,6 +742,13 @@ static uint8_t XCP_START_STOP_DAQ_LIST_DE(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_START_STOP_SYNCH_DD(tCanSerialPortFrameXCP *env) {
     eXcpCommand_START_STOP_SYNCH *request = (eXcpCommand_START_STOP_SYNCH *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_DAQ) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     if (request->MODE == XCP_SYNC_START_SEL) {
         for (uint16 i = 0; i < MAX_DAO; ++i) {
             if (env->DAQ[i].SELECTED) {
@@ -626,6 +781,13 @@ static uint8_t XCP_START_STOP_SYNCH_DD(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_READ_DAQ_DB(tCanSerialPortFrameXCP *env) {
     eXcpCommand_WRITE_DAQ *response = (eXcpCommand_WRITE_DAQ *) env->response;
 
+    if (isUNLOCK(env, XCP_PROTECT_DAQ) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     response->COM = XCP_COMMAND_CONNECT;
     response->BIT_OFFSET = env->DAQ[env->SETUP.DAQ_LIST_NUMBER].ODT_NUMBER[env->SETUP.ODT_NUMBER].BIT_OFFSET[env->SETUP.ODT_ENTRY_NUMBER];
     response->ADR_EXT = env->DAQ[env->SETUP.DAQ_LIST_NUMBER].ODT_NUMBER[env->SETUP.ODT_NUMBER].ADR_EXT[env->SETUP.ODT_ENTRY_NUMBER];
@@ -641,6 +803,13 @@ static uint8_t XCP_GET_DAQ_PROCESSOR_INFO_DA(tCanSerialPortFrameXCP *env) {
 
     eXcpCommand_GET_DAQ_PROCESSOR_INFO *response = (eXcpCommand_GET_DAQ_PROCESSOR_INFO *) env->response;
 
+    if (isUNLOCK(env, XCP_PROTECT_DAQ) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     response->COM = XCP_COMMAND_CONNECT;
 
     response->DAQ_CONFIG_TYPE = 1; // dynamic DAQ list configuration
@@ -672,6 +841,13 @@ static uint8_t XCP_GET_DAQ_PROCESSOR_INFO_DA(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_GET_DAQ_RESOLUTION_INFO_D9(tCanSerialPortFrameXCP *env) {
     eXcpCommand_GET_DAQ_RESOLUTION_INFO *response = (eXcpCommand_GET_DAQ_RESOLUTION_INFO *) env->response;
 
+    if (isUNLOCK(env, XCP_PROTECT_DAQ) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     response->COM = XCP_COMMAND_CONNECT;
 
     response->GRANULARITY_ODT_ENTRY_SIZE_DAQ = 1;
@@ -689,6 +865,13 @@ static uint8_t XCP_GET_DAQ_LIST_MODE_DF(tCanSerialPortFrameXCP *env) {
 
     eXcpCommand_GET_DAQ_LIST_MODE_GET *request = (eXcpCommand_GET_DAQ_LIST_MODE_GET *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_DAQ) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     if (request->DAQ_LIST_NUMBER > MAX_DAO) {
         env->response[0] = XCP_COMMAND_DISCONNECT;
         env->response[1] = XCP_ERR_OUT_OF_RANGE;
@@ -722,6 +905,13 @@ static uint8_t XCP_GET_DAQ_EVENT_INFO_D7(tCanSerialPortFrameXCP *env) {
 
     eXcpCommand_GET_DAQ_EVENT_INFO_GET *request = (eXcpCommand_GET_DAQ_EVENT_INFO_GET *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_DAQ) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     if (request->EVENT_CHANNEL_NUMBER > MAX_EVENT_CHANNEL) {
         env->response[0] = XCP_COMMAND_DISCONNECT;
         env->response[1] = XCP_ERR_OUT_OF_RANGE;
@@ -779,6 +969,13 @@ static uint8_t XCP_GET_DAQ_STM(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_PROGRAM_START_D2(tCanSerialPortFrameXCP *env) {
     eXcpCommand_PROGRAM_START *response = (eXcpCommand_PROGRAM_START *) env->response;
 
+    if (isUNLOCK(env, XCP_PROTECT_PGM) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     response->COM = XCP_COMMAND_CONNECT;
     response->RESERVED1 = 0;
 
@@ -802,6 +999,13 @@ static uint8_t XCP_PROGRAM_START_D2(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_PROGRAM_CLEAR_D1(tCanSerialPortFrameXCP *env) {
     eXcpCommand_XCP_PROGRAM_CLEAR_D1 *request = (eXcpCommand_XCP_PROGRAM_CLEAR_D1 *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_PGM) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     if (request->MODE == 0) {
 
         if ((env->ADR_MTA < env->startFlashAdr) || ((env->ADR_MTA + request->CLEAR_RANGE) > env->endFlashAdr)) {
@@ -828,6 +1032,13 @@ static uint8_t XCP_PROGRAM_CLEAR_D1(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_PROGRAM_D0(tCanSerialPortFrameXCP *env) {
     eXcpCommand_Program_ProgramNext_D0_CA *request = (eXcpCommand_Program_ProgramNext_D0_CA *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_PGM) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     uint8_t COUNT = env->canFrame.dlc - 2;
 
     for (uint8_t i = 0; i < COUNT; ++i) {
@@ -855,6 +1066,13 @@ static uint8_t XCP_PROGRAM_D0(tCanSerialPortFrameXCP *env) {
 static uint8_t PROGRAM_VERIFY_C8(tCanSerialPortFrameXCP *env) {
     eXcpCommand_Program_Verify_C8 *request = (eXcpCommand_Program_Verify_C8 *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_PGM) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     if (env->bufWriteFlashCount > 0) {
         bool result = env->write_flash_func(env->bufWriteFlashAdr, env->bufWriteFlash, env->bufWriteFlashCount);
         env->bufWriteFlashCount = 0;
@@ -869,6 +1087,13 @@ static uint8_t PROGRAM_VERIFY_C8(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_PROGRAM_NEXT_CA(tCanSerialPortFrameXCP *env) {
     eXcpCommand_Program_ProgramNext_D0_CA *request = (eXcpCommand_Program_ProgramNext_D0_CA *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_PGM) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     uint8_t COUNT = env->canFrame.dlc - 2;
 
     env->write_flash_func(env->ADR_MTA, &env->canFrame.data[2], request->COUNT);
@@ -882,6 +1107,13 @@ static uint8_t XCP_PROGRAM_NEXT_CA(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_PROGRAM_PREPARE_CC(tCanSerialPortFrameXCP *env) {
     eXcpCommand_Program_Prepare_CC *request = (eXcpCommand_Program_Prepare_CC *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_PGM) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     if ((env->ADR_MTA < env->startFlashAdr) || ((env->ADR_MTA + request->CODESIZE) > env->endFlashAdr)) {
 
         env->response[0] = XCP_COMMAND_DISCONNECT;
@@ -893,22 +1125,34 @@ static uint8_t XCP_PROGRAM_PREPARE_CC(tCanSerialPortFrameXCP *env) {
     env->response[0] = XCP_COMMAND_CONNECT;
     return 1;
 
-    return 0;
 }
 
 
 static uint8_t XCP_PROGRAM_FORMAT_CB(tCanSerialPortFrameXCP *env) {
     eXcpCommand_Program_Format_CB *request = (eXcpCommand_Program_Format_CB *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_PGM) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     env->response[0] = XCP_COMMAND_CONNECT;
     return 1;
 
-    return 0;
 }
 
 static uint8_t XCP_PROGRAM_RESET_CF(tCanSerialPortFrameXCP *env) {
     env->response[0] = XCP_COMMAND_CONNECT;
 
+    if (isUNLOCK(env, XCP_PROTECT_PGM) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     if (env->bufWriteFlashCount > 0) {
         bool result = env->write_flash_func(env->bufWriteFlashAdr, env->bufWriteFlash, env->bufWriteFlashCount);
         env->bufWriteFlashCount = 0;
@@ -920,6 +1164,13 @@ static uint8_t XCP_PROGRAM_RESET_CF(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_GET_PGM_PROCESSOR_INFO_CE(tCanSerialPortFrameXCP *env) {
     eXcpCommand_PGM_PROCESSOR_INFO_CE *response = (eXcpCommand_PGM_PROCESSOR_INFO_CE *) env->response;
 
+    if (isUNLOCK(env, XCP_PROTECT_PGM) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     response->COM = XCP_COMMAND_CONNECT;
 
     response->ABSOLUTE_MODE = 1;
@@ -939,6 +1190,13 @@ static uint8_t XCP_GET_PGM_PROCESSOR_INFO_CE(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_GET_SECTOR_INFO_CD(tCanSerialPortFrameXCP *env) {
     eXcpCommand_REQ_GET_SECTOR_INFO_CD *request = (eXcpCommand_REQ_GET_SECTOR_INFO_CD *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_PGM) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     if (request->SECTOR_NUMBER > PROGRAM_MAX_SECTOR) {
         env->response[0] = XCP_COMMAND_DISCONNECT;
         env->response[1] = XCP_ERR_OUT_OF_RANGE;
@@ -988,6 +1246,13 @@ static uint8_t XCP_SET_CALIBRATION_PAGE_EB(tCanSerialPortFrameXCP *env) {
 static uint8_t XCP_GET_CAL_PAGE_EA(tCanSerialPortFrameXCP *env) {
     eXcpCommand_XCP_GET_CAL_PAGE_EA *request = (eXcpCommand_XCP_GET_CAL_PAGE_EA *) env->canFrame.data;
 
+    if (isUNLOCK(env, XCP_PROTECT_CAL_PAG) == false) {
+        env->response[0] = XCP_COMMAND_DISCONNECT;
+        env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+        return 2;
+    }
+
     env->response[0] = XCP_COMMAND_CONNECT;
     env->response[1] = env->PAGE_ID;
 
@@ -1298,7 +1563,18 @@ uint8_t vCanSerialPortFrameXcpReceive(tCanSerialPortFrameXCP *env, uint32 timeou
             }
 
         } else { // ODT
-            XCP_GET_DAQ_STM(env);
+
+            if (isUNLOCK(env, XCP_PROTECT_STM) == false) {
+                env->response[0] = XCP_COMMAND_DISCONNECT;
+                env->response[1] = XCP_ERR_ACCESS_LOCKED;
+
+                env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, 2,
+                                          PROTOCOL_CAN_ADR_XCP,
+                                          PROTOCOL_CAN_TYPE_XCP, timeout);
+            } else {
+                XCP_GET_DAQ_STM(env);
+            }
+
         }
 
         osMutexRelease(env->access);