diff --git a/Target/Demo/ARM7_LPC2000_Olimex_LPC_L2294_GCC/Boot/blt_conf.h b/Target/Demo/ARM7_LPC2000_Olimex_LPC_L2294_GCC/Boot/blt_conf.h index 45aad51b..bbc07bb8 100644 --- a/Target/Demo/ARM7_LPC2000_Olimex_LPC_L2294_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARM7_LPC2000_Olimex_LPC_L2294_GCC/Boot/blt_conf.h @@ -159,7 +159,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARM7_LPC2000_Olimex_LPC_L2294_GCC/Boot/hooks.c b/Target/Demo/ARM7_LPC2000_Olimex_LPC_L2294_GCC/Boot/hooks.c index 873c1b61..76f6880a 100644 --- a/Target/Demo/ARM7_LPC2000_Olimex_LPC_L2294_GCC/Boot/hooks.c +++ b/Target/Demo/ARM7_LPC2000_Olimex_LPC_L2294_GCC/Boot/hooks.c @@ -275,7 +275,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_GCC/Boot/blt_conf.h index 9ef29204..82537360 100644 --- a/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_GCC/Boot/blt_conf.h @@ -142,7 +142,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_GCC/Boot/hooks.c b/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_GCC/Boot/hooks.c index bd4d8433..98a512b8 100644 --- a/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_GCC/Boot/hooks.c +++ b/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_GCC/Boot/hooks.c @@ -286,7 +286,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_IAR/Boot/blt_conf.h index 5bff29ad..aff86a10 100644 --- a/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_IAR/Boot/blt_conf.h @@ -142,7 +142,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_IAR/Boot/hooks.c b/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_IAR/Boot/hooks.c index 731f804e..2bfa0ca6 100644 --- a/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_IAR/Boot/hooks.c @@ -286,7 +286,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_Keil/Boot/blt_conf.h b/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_Keil/Boot/blt_conf.h index 06bd73c5..38c0aebd 100644 --- a/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_Keil/Boot/blt_conf.h +++ b/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_Keil/Boot/blt_conf.h @@ -142,7 +142,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_Keil/Boot/hooks.c b/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_Keil/Boot/hooks.c index 3a6fa108..3c59c9ce 100644 --- a/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_Keil/Boot/hooks.c +++ b/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_Keil/Boot/hooks.c @@ -286,7 +286,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_TrueStudio/Boot/blt_conf.h b/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_TrueStudio/Boot/blt_conf.h index d4056d2d..2e2e725c 100644 --- a/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_TrueStudio/Boot/blt_conf.h +++ b/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_TrueStudio/Boot/blt_conf.h @@ -142,7 +142,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_TrueStudio/Boot/hooks.c b/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_TrueStudio/Boot/hooks.c index 87893e4b..3b7bdbf9 100644 --- a/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_TrueStudio/Boot/hooks.c +++ b/Target/Demo/ARMCM0_STM32F0_Discovery_STM32F051_TrueStudio/Boot/hooks.c @@ -286,7 +286,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/blt_conf.h index 9c8eded6..dc8c5904 100644 --- a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/blt_conf.h @@ -159,7 +159,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/hooks.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/hooks.c index d1027d47..9ef75a23 100644 --- a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/hooks.c +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/hooks.c @@ -287,7 +287,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_IAR/Boot/blt_conf.h index 6345de77..148ec7da 100644 --- a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_IAR/Boot/blt_conf.h @@ -159,7 +159,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_IAR/Boot/hooks.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_IAR/Boot/hooks.c index 32743360..89050bb3 100644 --- a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_IAR/Boot/hooks.c @@ -287,7 +287,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_Keil/Boot/blt_conf.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_Keil/Boot/blt_conf.h index b3055636..873a248f 100644 --- a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_Keil/Boot/blt_conf.h +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_Keil/Boot/blt_conf.h @@ -159,7 +159,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_Keil/Boot/hooks.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_Keil/Boot/hooks.c index cae1d272..f55aff33 100644 --- a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_Keil/Boot/hooks.c +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_Keil/Boot/hooks.c @@ -287,7 +287,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_TrueStudio/Boot/blt_conf.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_TrueStudio/Boot/blt_conf.h index 1a0f607c..78abc465 100644 --- a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_TrueStudio/Boot/blt_conf.h +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_TrueStudio/Boot/blt_conf.h @@ -159,7 +159,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_TrueStudio/Boot/hooks.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_TrueStudio/Boot/hooks.c index ae356d06..eb5c735c 100644 --- a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_TrueStudio/Boot/hooks.c +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_TrueStudio/Boot/hooks.c @@ -287,7 +287,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM0_XMC1_XMC1400_Boot_Kit_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM0_XMC1_XMC1400_Boot_Kit_GCC/Boot/blt_conf.h index 9fa3735a..712bc080 100644 --- a/Target/Demo/ARMCM0_XMC1_XMC1400_Boot_Kit_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARMCM0_XMC1_XMC1400_Boot_Kit_GCC/Boot/blt_conf.h @@ -159,7 +159,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM0_XMC1_XMC1400_Boot_Kit_GCC/Boot/hooks.c b/Target/Demo/ARMCM0_XMC1_XMC1400_Boot_Kit_GCC/Boot/hooks.c index 5e5905ae..771adca1 100644 --- a/Target/Demo/ARMCM0_XMC1_XMC1400_Boot_Kit_GCC/Boot/hooks.c +++ b/Target/Demo/ARMCM0_XMC1_XMC1400_Boot_Kit_GCC/Boot/hooks.c @@ -275,7 +275,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM0_XMC1_XMC1400_Boot_Kit_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM0_XMC1_XMC1400_Boot_Kit_IAR/Boot/blt_conf.h index 0459ff73..3d983eeb 100644 --- a/Target/Demo/ARMCM0_XMC1_XMC1400_Boot_Kit_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM0_XMC1_XMC1400_Boot_Kit_IAR/Boot/blt_conf.h @@ -159,7 +159,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM0_XMC1_XMC1400_Boot_Kit_IAR/Boot/hooks.c b/Target/Demo/ARMCM0_XMC1_XMC1400_Boot_Kit_IAR/Boot/hooks.c index 3264a652..5f7eabfb 100644 --- a/Target/Demo/ARMCM0_XMC1_XMC1400_Boot_Kit_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM0_XMC1_XMC1400_Boot_Kit_IAR/Boot/hooks.c @@ -275,7 +275,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_Crossworks/Boot/blt_conf.h b/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_Crossworks/Boot/blt_conf.h index 8ed72cba..079aca12 100644 --- a/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_Crossworks/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_Crossworks/Boot/blt_conf.h @@ -131,7 +131,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_Crossworks/Boot/hooks.c b/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_Crossworks/Boot/hooks.c index afb2ee43..6fbe49cc 100644 --- a/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_Crossworks/Boot/hooks.c +++ b/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_Crossworks/Boot/hooks.c @@ -261,7 +261,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_GCC/Boot/blt_conf.h index 9a204526..b10cef89 100644 --- a/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_GCC/Boot/blt_conf.h @@ -131,7 +131,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_GCC/Boot/hooks.c b/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_GCC/Boot/hooks.c index 91d98b44..90289d4c 100644 --- a/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_GCC/Boot/hooks.c +++ b/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_GCC/Boot/hooks.c @@ -261,7 +261,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_IAR/Boot/blt_conf.h index 1ab88386..eb141b3e 100644 --- a/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_IAR/Boot/blt_conf.h @@ -131,7 +131,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_IAR/Boot/hooks.c b/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_IAR/Boot/hooks.c index e88b887e..ef07391c 100644 --- a/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM3_EFM32_Olimex_EM32G880F128STK_IAR/Boot/hooks.c @@ -261,7 +261,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_Crossworks/Boot/blt_conf.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_Crossworks/Boot/blt_conf.h index f9d0fb6a..5fc76074 100644 --- a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_Crossworks/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_Crossworks/Boot/blt_conf.h @@ -239,7 +239,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_Crossworks/Boot/hooks.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_Crossworks/Boot/hooks.c index abfce216..0c6dc43a 100644 --- a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_Crossworks/Boot/hooks.c +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_Crossworks/Boot/hooks.c @@ -525,7 +525,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/blt_conf.h index 0dd2566c..1ac34b3c 100644 --- a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/blt_conf.h @@ -239,7 +239,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/hooks.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/hooks.c index 59e31396..e1c0d6b7 100644 --- a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/hooks.c +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_GCC/Boot/hooks.c @@ -525,7 +525,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_IAR/Boot/blt_conf.h index b6cf560d..e8193147 100644 --- a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_IAR/Boot/blt_conf.h @@ -239,7 +239,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_IAR/Boot/hooks.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_IAR/Boot/hooks.c index fa89b95c..aa1216f5 100644 --- a/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S6965_IAR/Boot/hooks.c @@ -525,7 +525,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_Crossworks/Boot/blt_conf.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_Crossworks/Boot/blt_conf.h index 6782e982..23921976 100644 --- a/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_Crossworks/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_Crossworks/Boot/blt_conf.h @@ -170,7 +170,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_Crossworks/Boot/hooks.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_Crossworks/Boot/hooks.c index 3fd2a3fa..3689b910 100644 --- a/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_Crossworks/Boot/hooks.c +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_Crossworks/Boot/hooks.c @@ -261,7 +261,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_GCC/Boot/blt_conf.h index 46b71b33..bf94b99a 100644 --- a/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_GCC/Boot/blt_conf.h @@ -170,7 +170,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_GCC/Boot/hooks.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_GCC/Boot/hooks.c index 1b879c07..2b1d64ff 100644 --- a/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_GCC/Boot/hooks.c +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_GCC/Boot/hooks.c @@ -261,7 +261,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_IAR/Boot/blt_conf.h index a3a52d4f..fae98c3c 100644 --- a/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_IAR/Boot/blt_conf.h @@ -170,7 +170,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_IAR/Boot/hooks.c b/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_IAR/Boot/hooks.c index 9f192b15..39fd13d2 100644 --- a/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM3_LM3S_EK_LM3S8962_IAR/Boot/hooks.c @@ -261,7 +261,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_GCC/Boot/blt_conf.h index 8637af24..bc9fb14c 100644 --- a/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_GCC/Boot/blt_conf.h @@ -148,7 +148,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_GCC/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_GCC/Boot/hooks.c index 813cd88e..3ebd8d57 100644 --- a/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_GCC/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_GCC/Boot/hooks.c @@ -286,7 +286,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_IAR/Boot/blt_conf.h index 206bcce3..3f81620e 100644 --- a/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_IAR/Boot/blt_conf.h @@ -148,7 +148,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_IAR/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_IAR/Boot/hooks.c index 6726b7ba..42f25662 100644 --- a/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_IAR/Boot/hooks.c @@ -286,7 +286,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_TrueStudio/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_TrueStudio/Boot/blt_conf.h index 41b2e82a..60ee7f7d 100644 --- a/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_TrueStudio/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_TrueStudio/Boot/blt_conf.h @@ -148,7 +148,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_TrueStudio/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_TrueStudio/Boot/hooks.c index c33039c5..a2784382 100644 --- a/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_TrueStudio/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F1_Nucleo_F103RB_TrueStudio/Boot/hooks.c @@ -286,7 +286,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_Crossworks/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_Crossworks/Boot/blt_conf.h index 01d0bb6d..abfd4275 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_Crossworks/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_Crossworks/Boot/blt_conf.h @@ -152,7 +152,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_Crossworks/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_Crossworks/Boot/hooks.c index 8bcdef62..f3efb1e6 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_Crossworks/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_Crossworks/Boot/hooks.c @@ -338,7 +338,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_GCC/Boot/blt_conf.h index 4e98b28e..125dc646 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_GCC/Boot/blt_conf.h @@ -158,7 +158,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_GCC/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_GCC/Boot/hooks.c index 4c562c5e..97136ae9 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_GCC/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_GCC/Boot/hooks.c @@ -338,7 +338,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_IAR/Boot/blt_conf.h index c2f85289..32314ffd 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_IAR/Boot/blt_conf.h @@ -158,7 +158,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_IAR/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_IAR/Boot/hooks.c index 3f32fd8a..8f30ba0c 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_IAR/Boot/hooks.c @@ -338,7 +338,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_TrueStudio/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_TrueStudio/Boot/blt_conf.h index 4f47bfcb..8926ec52 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_TrueStudio/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_TrueStudio/Boot/blt_conf.h @@ -158,7 +158,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_TrueStudio/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_TrueStudio/Boot/hooks.c index b4f40323..702a8646 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_TrueStudio/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32H103_TrueStudio/Boot/hooks.c @@ -338,7 +338,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_Crossworks/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_Crossworks/Boot/blt_conf.h index bd5d5e12..685867ba 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_Crossworks/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_Crossworks/Boot/blt_conf.h @@ -195,7 +195,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_Crossworks/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_Crossworks/Boot/hooks.c index 014a5213..089ffeb0 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_Crossworks/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_Crossworks/Boot/hooks.c @@ -451,7 +451,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_GCC/Boot/blt_conf.h index a9f0d0d7..60cd48d7 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_GCC/Boot/blt_conf.h @@ -206,7 +206,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_GCC/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_GCC/Boot/hooks.c index e337b26a..549d433f 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_GCC/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_GCC/Boot/hooks.c @@ -451,7 +451,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_IAR/Boot/blt_conf.h index 4db355ce..6fffd37a 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_IAR/Boot/blt_conf.h @@ -206,7 +206,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_IAR/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_IAR/Boot/hooks.c index 64045042..db767ae0 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_IAR/Boot/hooks.c @@ -451,7 +451,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_Keil/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_Keil/Boot/blt_conf.h index dd173fdf..2580d8ef 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_Keil/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_Keil/Boot/blt_conf.h @@ -195,7 +195,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_Keil/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_Keil/Boot/hooks.c index 8153a7ec..cec4ec3b 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_Keil/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_Keil/Boot/hooks.c @@ -451,7 +451,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_TrueStudio/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_TrueStudio/Boot/blt_conf.h index 0ddce893..ef9f1f85 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_TrueStudio/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_TrueStudio/Boot/blt_conf.h @@ -206,7 +206,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_TrueStudio/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_TrueStudio/Boot/hooks.c index 6a592e63..39910928 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_TrueStudio/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F1_Olimex_STM32P103_TrueStudio/Boot/hooks.c @@ -451,7 +451,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_GCC/Boot/blt_conf.h index 67191fa4..99cd9f4a 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_GCC/Boot/blt_conf.h @@ -216,7 +216,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_GCC/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_GCC/Boot/hooks.c index 64859602..2118ccaf 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_GCC/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_GCC/Boot/hooks.c @@ -514,7 +514,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_IAR/Boot/blt_conf.h index 3c1deb87..0004d08f 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_IAR/Boot/blt_conf.h @@ -216,7 +216,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_IAR/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_IAR/Boot/hooks.c index 50a90d20..a6abf298 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_IAR/Boot/hooks.c @@ -514,7 +514,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_TrueStudio/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_TrueStudio/Boot/blt_conf.h index d185580e..3f9c2b91 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_TrueStudio/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_TrueStudio/Boot/blt_conf.h @@ -216,7 +216,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_TrueStudio/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_TrueStudio/Boot/hooks.c index 854af200..f684177b 100644 --- a/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_TrueStudio/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F1_Olimexino_STM32_TrueStudio/Boot/hooks.c @@ -514,7 +514,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_GCC/Boot/blt_conf.h index bddafee2..a92cb0ed 100644 --- a/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_GCC/Boot/blt_conf.h @@ -195,7 +195,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_GCC/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_GCC/Boot/hooks.c index b3506da6..ae4a7315 100644 --- a/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_GCC/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_GCC/Boot/hooks.c @@ -487,7 +487,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_IAR/Boot/blt_conf.h index f851ad7b..f2573c24 100644 --- a/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_IAR/Boot/blt_conf.h @@ -195,7 +195,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_IAR/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_IAR/Boot/hooks.c index eac424cc..28ba27d4 100644 --- a/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_IAR/Boot/hooks.c @@ -487,7 +487,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_TrueStudio/Boot/blt_conf.h b/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_TrueStudio/Boot/blt_conf.h index 9018d672..5143c5df 100644 --- a/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_TrueStudio/Boot/blt_conf.h +++ b/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_TrueStudio/Boot/blt_conf.h @@ -195,7 +195,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_TrueStudio/Boot/hooks.c b/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_TrueStudio/Boot/hooks.c index c28c4ecd..443edc78 100644 --- a/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_TrueStudio/Boot/hooks.c +++ b/Target/Demo/ARMCM3_STM32F2_Olimex_STM32P207_TrueStudio/Boot/hooks.c @@ -487,7 +487,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_GCC/Boot/blt_conf.h index f438f16a..f93ba503 100644 --- a/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_GCC/Boot/blt_conf.h @@ -168,7 +168,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_GCC/Boot/hooks.c b/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_GCC/Boot/hooks.c index 09986b84..ad51dcb8 100644 --- a/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_GCC/Boot/hooks.c +++ b/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_GCC/Boot/hooks.c @@ -356,7 +356,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_IAR/Boot/blt_conf.h index 11422574..4ad888f3 100644 --- a/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_IAR/Boot/blt_conf.h @@ -168,7 +168,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_IAR/Boot/hooks.c b/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_IAR/Boot/hooks.c index a632769c..f40443d3 100644 --- a/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_IAR/Boot/hooks.c @@ -356,7 +356,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_TrueStudio/Boot/blt_conf.h b/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_TrueStudio/Boot/blt_conf.h index 928cd5fc..3f4ae25c 100644 --- a/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_TrueStudio/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_TrueStudio/Boot/blt_conf.h @@ -168,7 +168,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_TrueStudio/Boot/hooks.c b/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_TrueStudio/Boot/hooks.c index 842f093b..0efcd1c7 100644 --- a/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_TrueStudio/Boot/hooks.c +++ b/Target/Demo/ARMCM4_STM32F3_Discovery_F303VC_TrueStudio/Boot/hooks.c @@ -356,7 +356,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/blt_conf.h index d5aa8f5b..32ae7547 100644 --- a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/blt_conf.h @@ -159,7 +159,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/hooks.c b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/hooks.c index abcbb6b0..4aef1b0e 100644 --- a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/hooks.c +++ b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/hooks.c @@ -287,7 +287,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_IAR/Boot/blt_conf.h index 1be1e65d..5d7b8ac9 100644 --- a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_IAR/Boot/blt_conf.h @@ -159,7 +159,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_IAR/Boot/hooks.c b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_IAR/Boot/hooks.c index d09c92ff..b3a18f4c 100644 --- a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_IAR/Boot/hooks.c @@ -287,7 +287,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_TrueStudio/Boot/blt_conf.h b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_TrueStudio/Boot/blt_conf.h index a3897843..be5814f4 100644 --- a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_TrueStudio/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_TrueStudio/Boot/blt_conf.h @@ -159,7 +159,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_TrueStudio/Boot/hooks.c b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_TrueStudio/Boot/hooks.c index 41019fb6..cebc3bfd 100644 --- a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_TrueStudio/Boot/hooks.c +++ b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_TrueStudio/Boot/hooks.c @@ -287,7 +287,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_GCC/Boot/blt_conf.h index 589bb3a8..406bb742 100644 --- a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_GCC/Boot/blt_conf.h @@ -291,7 +291,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_GCC/Boot/hooks.c b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_GCC/Boot/hooks.c index d9bbcc52..70503226 100644 --- a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_GCC/Boot/hooks.c +++ b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_GCC/Boot/hooks.c @@ -497,7 +497,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_IAR/Boot/blt_conf.h index e791f521..217609e3 100644 --- a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_IAR/Boot/blt_conf.h @@ -291,7 +291,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_IAR/Boot/hooks.c b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_IAR/Boot/hooks.c index 491f8667..07772ba1 100644 --- a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_IAR/Boot/hooks.c @@ -497,7 +497,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_TrueStudio/Boot/blt_conf.h b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_TrueStudio/Boot/blt_conf.h index 14b99a92..489d8311 100644 --- a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_TrueStudio/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_TrueStudio/Boot/blt_conf.h @@ -291,7 +291,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_TrueStudio/Boot/hooks.c b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_TrueStudio/Boot/hooks.c index 388f18ee..b1b476c6 100644 --- a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_TrueStudio/Boot/hooks.c +++ b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32E407_TrueStudio/Boot/hooks.c @@ -497,7 +497,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_GCC/Boot/blt_conf.h index 36fbeefa..fca7c27c 100644 --- a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_GCC/Boot/blt_conf.h @@ -235,7 +235,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_GCC/Boot/hooks.c b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_GCC/Boot/hooks.c index eb73f042..6bc599b8 100644 --- a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_GCC/Boot/hooks.c +++ b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_GCC/Boot/hooks.c @@ -540,7 +540,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_IAR/Boot/blt_conf.h index 69db37cf..7fbe7dda 100644 --- a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_IAR/Boot/blt_conf.h @@ -235,7 +235,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_IAR/Boot/hooks.c b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_IAR/Boot/hooks.c index 59ac9c2c..16eb6696 100644 --- a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_IAR/Boot/hooks.c @@ -540,7 +540,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_TrueStudio/Boot/blt_conf.h b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_TrueStudio/Boot/blt_conf.h index d25dfa7f..afec4703 100644 --- a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_TrueStudio/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_TrueStudio/Boot/blt_conf.h @@ -235,7 +235,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_TrueStudio/Boot/hooks.c b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_TrueStudio/Boot/hooks.c index 5e2aed32..51ea5cc0 100644 --- a/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_TrueStudio/Boot/hooks.c +++ b/Target/Demo/ARMCM4_STM32F4_Olimex_STM32P405_TrueStudio/Boot/hooks.c @@ -540,7 +540,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_GCC/Boot/blt_conf.h index e8f8719f..31a54bb0 100644 --- a/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_GCC/Boot/blt_conf.h @@ -159,7 +159,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_GCC/Boot/hooks.c b/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_GCC/Boot/hooks.c index c8bb0b09..d1018c0d 100644 --- a/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_GCC/Boot/hooks.c +++ b/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_GCC/Boot/hooks.c @@ -288,7 +288,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_IAR/Boot/blt_conf.h index 2629c569..eb57173d 100644 --- a/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_IAR/Boot/blt_conf.h @@ -159,7 +159,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_IAR/Boot/hooks.c b/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_IAR/Boot/hooks.c index cbc6f157..9c5584d9 100644 --- a/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_IAR/Boot/hooks.c @@ -288,7 +288,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_TrueStudio/Boot/blt_conf.h b/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_TrueStudio/Boot/blt_conf.h index 296f43ba..c0cf5294 100644 --- a/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_TrueStudio/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_TrueStudio/Boot/blt_conf.h @@ -159,7 +159,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_TrueStudio/Boot/hooks.c b/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_TrueStudio/Boot/hooks.c index 5d73e8c8..d06a6e27 100644 --- a/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_TrueStudio/Boot/hooks.c +++ b/Target/Demo/ARMCM4_STM32L4_Nucleo_L476RG_TrueStudio/Boot/hooks.c @@ -288,7 +288,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_TM4C_DK_TM4C123G_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM4_TM4C_DK_TM4C123G_IAR/Boot/blt_conf.h index e1376faa..8055b8bf 100644 --- a/Target/Demo/ARMCM4_TM4C_DK_TM4C123G_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_TM4C_DK_TM4C123G_IAR/Boot/blt_conf.h @@ -196,7 +196,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_TM4C_DK_TM4C123G_IAR/Boot/hooks.c b/Target/Demo/ARMCM4_TM4C_DK_TM4C123G_IAR/Boot/hooks.c index 4cb28c53..795e6f8c 100644 --- a/Target/Demo/ARMCM4_TM4C_DK_TM4C123G_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM4_TM4C_DK_TM4C123G_IAR/Boot/hooks.c @@ -520,7 +520,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_XMC4_XMC4700_Relax_Kit_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM4_XMC4_XMC4700_Relax_Kit_GCC/Boot/blt_conf.h index 1a63a28e..69ecde9a 100644 --- a/Target/Demo/ARMCM4_XMC4_XMC4700_Relax_Kit_GCC/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_XMC4_XMC4700_Relax_Kit_GCC/Boot/blt_conf.h @@ -159,7 +159,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_XMC4_XMC4700_Relax_Kit_GCC/Boot/hooks.c b/Target/Demo/ARMCM4_XMC4_XMC4700_Relax_Kit_GCC/Boot/hooks.c index a5437b2e..9d01fc08 100644 --- a/Target/Demo/ARMCM4_XMC4_XMC4700_Relax_Kit_GCC/Boot/hooks.c +++ b/Target/Demo/ARMCM4_XMC4_XMC4700_Relax_Kit_GCC/Boot/hooks.c @@ -287,7 +287,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/ARMCM4_XMC4_XMC4700_Relax_Kit_IAR/Boot/blt_conf.h b/Target/Demo/ARMCM4_XMC4_XMC4700_Relax_Kit_IAR/Boot/blt_conf.h index b124a197..0dc19207 100644 --- a/Target/Demo/ARMCM4_XMC4_XMC4700_Relax_Kit_IAR/Boot/blt_conf.h +++ b/Target/Demo/ARMCM4_XMC4_XMC4700_Relax_Kit_IAR/Boot/blt_conf.h @@ -159,7 +159,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/ARMCM4_XMC4_XMC4700_Relax_Kit_IAR/Boot/hooks.c b/Target/Demo/ARMCM4_XMC4_XMC4700_Relax_Kit_IAR/Boot/hooks.c index 3f2c4aae..9b2f9eef 100644 --- a/Target/Demo/ARMCM4_XMC4_XMC4700_Relax_Kit_IAR/Boot/hooks.c +++ b/Target/Demo/ARMCM4_XMC4_XMC4700_Relax_Kit_IAR/Boot/hooks.c @@ -287,7 +287,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Demo/HCS12_Evbplus_Dragon12p_CodeWarrior/Boot/blt_conf.h b/Target/Demo/HCS12_Evbplus_Dragon12p_CodeWarrior/Boot/blt_conf.h index d36e3faa..c3e7a6d7 100644 --- a/Target/Demo/HCS12_Evbplus_Dragon12p_CodeWarrior/Boot/blt_conf.h +++ b/Target/Demo/HCS12_Evbplus_Dragon12p_CodeWarrior/Boot/blt_conf.h @@ -195,7 +195,7 @@ * operations can be performed, access to this resource need to be unlocked. * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that * implements the unlocking algorithm. The demo programs are configured for the (simple) - * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * algorithm in "libseednkey.dll". The source code for this DLL is available so it can be * customized to your needs. * During the unlock sequence, Microboot requests a seed from the bootloader, which is in * the format of a byte array. Using this seed the unlock algorithm in the DLL computes diff --git a/Target/Demo/HCS12_Evbplus_Dragon12p_CodeWarrior/Boot/hooks.c b/Target/Demo/HCS12_Evbplus_Dragon12p_CodeWarrior/Boot/hooks.c index 24d7ff80..b61cca92 100644 --- a/Target/Demo/HCS12_Evbplus_Dragon12p_CodeWarrior/Boot/hooks.c +++ b/Target/Demo/HCS12_Evbplus_Dragon12p_CodeWarrior/Boot/hooks.c @@ -261,7 +261,7 @@ blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) /* suppress compiler warning for unused parameter */ len = len; - /* the example key algorithm in "FeaserKey.dll" works as follows: + /* the example key algorithm in "libseednkey.dll" works as follows: * - PGM will be unlocked if key = seed - 1 */ diff --git a/Target/Source/xcp.c b/Target/Source/xcp.c index ea75e64f..81eaf915 100644 --- a/Target/Source/xcp.c +++ b/Target/Source/xcp.c @@ -36,7 +36,7 @@ /**************************************************************************************** * Type definitions ****************************************************************************************/ -/** \brief Struture type for grouping XCP internal module information. */ +/** \brief Structure type for grouping XCP internal module information. */ typedef struct { blt_int8u connected; /**< connection established */ @@ -900,7 +900,7 @@ static void XcpCmdGetSeed(blt_int8u *data) /* seed cannot be longer than XCP_CTO_PACKET_LEN-2 */ if (xcpInfo.ctoData[1] > (XCP_CTO_PACKET_LEN-2)) { - /* seed length length is too long */ + /* seed length is too long */ XcpSetCtoError(XCP_ERR_OUT_OF_RANGE); return; }