/* PDD layer implementation for peripheral type FTFL (C) 2013 Freescale, Inc. All rights reserved. This file is static and it is generated from API-Factory */ #if !defined(FTFL_PDD_H_) #define FTFL_PDD_H_ /* ---------------------------------------------------------------------------- -- Test if supported MCU is active ---------------------------------------------------------------------------- */ #if !defined(MCU_ACTIVE) // No MCU is active #error FTFL PDD library: No derivative is active. Place proper #include with PDD memory map before including PDD library. #elif \ !defined(MCU_MK10D10) /* FTFL */ && \ !defined(MCU_MK10D5) /* FTFL */ && \ !defined(MCU_MK10D7) /* FTFL */ && \ !defined(MCU_MK10DZ10) /* FTFL */ && \ !defined(MCU_MK11D5) /* FTFL */ && \ !defined(MCU_MK11D5WS) /* FTFL */ && \ !defined(MCU_MK12D5) /* FTFL */ && \ !defined(MCU_MK20D10) /* FTFL */ && \ !defined(MCU_MK20D5) /* FTFL */ && \ !defined(MCU_MK20D7) /* FTFL */ && \ !defined(MCU_MK20DZ10) /* FTFL */ && \ !defined(MCU_MK21D5) /* FTFL */ && \ !defined(MCU_MK21D5WS) /* FTFL */ && \ !defined(MCU_MK22D5) /* FTFL */ && \ !defined(MCU_MK30D10) /* FTFL */ && \ !defined(MCU_MK30D7) /* FTFL */ && \ !defined(MCU_MK30DZ10) /* FTFL */ && \ !defined(MCU_MK40D10) /* FTFL */ && \ !defined(MCU_MK40D7) /* FTFL */ && \ !defined(MCU_MK40DZ10) /* FTFL */ && \ !defined(MCU_MK40X256VMD100) /* FTFL */ && \ !defined(MCU_MK50D10) /* FTFL */ && \ !defined(MCU_MK50D7) /* FTFL */ && \ !defined(MCU_MK50DZ10) /* FTFL */ && \ !defined(MCU_MK51D10) /* FTFL */ && \ !defined(MCU_MK51D7) /* FTFL */ && \ !defined(MCU_MK51DZ10) /* FTFL */ && \ !defined(MCU_MK52D10) /* FTFL */ && \ !defined(MCU_MK52DZ10) /* FTFL */ && \ !defined(MCU_MK53D10) /* FTFL */ && \ !defined(MCU_MK53DZ10) /* FTFL */ && \ !defined(MCU_MK60D10) /* FTFL */ && \ !defined(MCU_MK60DZ10) /* FTFL */ && \ !defined(MCU_MK60N512VMD100) /* FTFL */ && \ !defined(MCU_MKW21D5) /* FTFL */ && \ !defined(MCU_MKW21D5WS) /* FTFL */ && \ !defined(MCU_MKW22D5) /* FTFL */ && \ !defined(MCU_MKW22D5WS) /* FTFL */ && \ !defined(MCU_MKW24D5) /* FTFL */ && \ !defined(MCU_MKW24D5WS) /* FTFL */ && \ !defined(MCU_PCK20L4) /* FTFL */ // Unsupported MCU is active #error FTFL PDD library: Unsupported derivative is active. #endif #include "PDD_Types.h" /* ---------------------------------------------------------------------------- -- Method symbol definitions ---------------------------------------------------------------------------- */ /* ClearFlags constants */ #define FTFL_PDD_COMMAND_COMPLETE FTFL_FSTAT_CCIF_MASK /**< Command complete flag mask */ #define FTFL_PDD_READ_COLLISION_ERROR FTFL_FSTAT_RDCOLERR_MASK /**< Read collision error flag mask */ #define FTFL_PDD_ACCESS_ERROR FTFL_FSTAT_ACCERR_MASK /**< Access error flag mask */ #define FTFL_PDD_PROTECTION_VIOLATION FTFL_FSTAT_FPVIOL_MASK /**< Protection violation flag mask */ #define FTFL_PDD_COMMAND_COMPLETION_STATUS FTFL_FSTAT_MGSTAT0_MASK /**< Command completion ststus flag mask */ /* EnableInterrupts;, DisableInterrupts constants */ #define FTFL_PDD_COMMAND_COMPLETE_INT FTFL_FCNFG_CCIE_MASK /**< Command complete interrupt mask */ #define FTFL_PDD_READ_COLLISION_ERROR_INT FTFL_FCNFG_RDCOLLIE_MASK /**< Read collision error interrupt mask */ /* SetFCCOBCommand constants */ #define FTFL_PDD_READ_1S_BLOCK 0U /**< Read 1s Block command value */ #define FTFL_PDD_READ_1S_SECTION 0x1U /**< Read 1s Section command value */ #define FTFL_PDD_PROGRAM_CHECK 0x2U /**< Program Check command value */ #define FTFL_PDD_READ_RESOURCE 0x3U /**< Read Resource command value */ #define FTFL_PDD_PROGRAM_LONGWORD 0x6U /**< Program Longword command value */ #define FTFL_PDD_ERASE_FLASH_BLOCK 0x8U /**< Erase Flash Block command value */ #define FTFL_PDD_ERASE_FLASH_SECTOR 0x9U /**< Erase Flash Sector command value */ #define FTFL_PDD_PROGRAM_SECTION 0xBU /**< Program Section command value */ #define FTFL_PDD_READ_1S_ALL_BLOCKS 0x40U /**< Read 1s All Blocks command value */ #define FTFL_PDD_PDD_READ_ONCE 0x41U /**< Read Once command value */ #define FTFL_PDD_PROGRAM_ONCE 0x43U /**< Program Once command value */ #define FTFL_PDD_ERASE_ALL_BLOCKS 0x44U /**< Erase All Blocks command value */ #define FTFL_PDD_VERIFY_BACKDOOR_ACCESS_KEY 0x45U /**< Verify Backdoor Access Key command value */ #define FTFL_PDD_PROGRAM_PARTITION 0x80U /**< Program Partition command value */ #define FTFL_PDD_SET_EERAM_FUCTION 0x81U /**< Set FlexRAM Function command value */ /* Margin level constants */ #define FTFL_PDD_READ_MARGIN_LEVEL_NORMAL 0U /**< Normal read level constant */ #define FTFL_PDD_READ_MARGIN_LEVEL_USER 0x1U /**< User read level constant */ #define FTFL_PDD_READ_MARGIN_LEVEL_FACTORY 0x2U /**< Factory read level constant */ /* Read resource command resource code constants */ #define FTFL_PDD_RESOURCE_IFR 0U /**< IFR */ #define FTFL_PDD_RESOURCE_VERSION_ID 0x1U /**< Version ID */ /* EEPROM size constants */ #define FTFL_PDD_EEPROM_DATA_SIZE_0_B 0xFU /**< No EEPROM */ #define FTFL_PDD_EEPROM_DATA_SIZE_32_B 0x9U /**< 32 bytes of EEPROM data */ #define FTFL_PDD_EEPROM_DATA_SIZE_64_B 0x8U /**< 64 bytes of EEPROM data */ #define FTFL_PDD_EEPROM_DATA_SIZE_128_B 0x7U /**< 128 bytes of EEPROM data */ #define FTFL_PDD_EEPROM_DATA_SIZE_256_B 0x6U /**< 256 bytes of EEPROM data */ #define FTFL_PDD_EEPROM_DATA_SIZE_512_B 0x5U /**< 512 bytes of EEPROM data */ #define FTFL_PDD_EEPROM_DATA_SIZE_1024_B 0x4U /**< 1024 bytes of EEPROM data */ #define FTFL_PDD_EEPROM_SIZE_2048_B 0x3U /**< 2048 bytes of EEPROM data */ #define FTFL_PDD_EEPROM_DATA_SIZE_4096_B 0x2U /**< 4096 bytes of EEPROM data */ #define FTFL_PDD_EEPROM_DATA_SIZE_8192_B 0x1U /**< 8192 bytes of EEPROM data */ #define FTFL_PDD_EEPROM_DATA_SIZE_16384_B 0U /**< 16384 bytes of EEPROM data */ /* EEPROM backup size constants */ #define FTFL_PDD_EEPROM_BACKUP_SIZE_0_KB 0U /**< No EEPROM */ #define FTFL_PDD_EEPROM_BACKUP_SIZE_8_KB 0x1U /**< 8 KB of EEPROM backup */ #define FTFL_PDD_EEPROM_BACKUP_SIZE_16_KB 0x2U /**< 16 KB of EEPROM backup */ #define FTFL_PDD_EEPROM_BACKUP_SIZE_32_KB 0x3U /**< 32 KB of EEPROM backup */ #define FTFL_PDD_EEPROM_BACKUP_SIZE_64_KB 0x4U /**< 64 KB of EEPROM backup */ #define FTFL_PDD_EEPROM_BACKUP_SIZE_128_KB 0x5U /**< 128 KB of EEPROM backup */ #define FTFL_PDD_EEPROM_BACKUP_SIZE_256_KB 0x6U /**< 256 KB of EEPROM backup */ #define FTFL_PDD_EEPROM_BACKUP_SIZE_512_KB 0x7U /**< 512 KB of EEPROM backup */ #define FTFL_PDD_DATA_FLASH_SIZE_0_KB 0x8U /**< No data falsh */ #define FTFL_PDD_DATA_FLASH_SIZE_8_KB 0x9U /**< 8 KB of data falsh */ #define FTFL_PDD_EDATA_FLASH_SIZE_16_KB 0xAU /**< 16 KB of data falsh */ #define FTFL_PDD_DATA_FLASH_SIZE_32_KB 0xBU /**< 32 KB of data falshp */ #define FTFL_PDD_DATA_FLASH_SIZE_64_KB 0xCU /**< 64 KB of data falsh */ #define FTFL_PDD_DATA_FLASH_SIZE_128_KB 0xDU /**< 128 KB of data falsh */ #define FTFL_PDD_EDATA_FLASH_SIZE_256_KB 0xEU /**< 256 KB of data falsh */ #define FTFL_PDD_DATA_FLASH_SIZE_512_KB 0xFU /**< 512 KB of data falsh */ #define FTFL_PDD_DATA_FLASH_SIZE_MAX 0xFU /**< No EEPROM backup data falsh only */ /* FlexRAM function constants */ #define FTFL_PDD_FLEXRAM_AS_RAM 0xFFU /**< Make FlexRAM available as RAM */ #define FTFL_PDD_FLEXRAM_AS_EEPROM 0U /**< Make FlexRAM available for EEPROM */ /* BackDoorKey constants */ #define FTFL_PDD_BACKDOOR_KEY_ENABLED 0U /**< Backdoor key enable constant */ #define FTFL_PDD_BACKDOOR_KEY_DISABLED 0x1U /**< Backdoor key disable constant */ /* Mass erase constants */ #define FTFL_PDD_MASS_ERASE_ENABLED 0U /**< Mass erase enable constant */ #define FTFL_PDD_MASS_ERASE_DISABLED 0x1U /**< Mass erase disable constant */ /* Factory access constants */ #define FTFL_PDD_FACTORY_ACCESS_GRANTED 0U /**< Factory access granted constant */ #define FTFL_PDD_FACTORY_ACCESS_DENIED 0x1U /**< Factory access denied constant */ /* Security state constants */ #define FTFL_PDD_UNSECURED 0U /**< Unsecure constant */ #define FTFL_PDD_SECURED 0x1U /**< Secure constant */ /* FlashProtection constants */ #define FTFL_PDD_UNPROTECTED 0U /**< Unprotect constant */ #define FTFL_PDD_PROTECTED 0x1U /**< Protect constant */ /* ---------------------------------------------------------------------------- -- ReadStatusReg ---------------------------------------------------------------------------- */ /** * @brief Returns value of the Flash status register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Use constants from group "ClearFlags constants" for processing return * value. * @remarks The macro accesses the following registers: FTFL_FSTAT. * @par Example: * @code * uint8 result = FTFL_PDD_ReadStatusReg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadStatusReg(PeripheralBase) ( \ FTFL_FSTAT_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteStatusReg ---------------------------------------------------------------------------- */ /** * @brief Writes value to the Flash status register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Flash status register. Use constants from * group "ClearFlags constants". This parameter is 8 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FSTAT. * @par Example: * @code * FTFL_PDD_WriteStatusReg(_BASE_PTR, * FTFL_PDD_COMMAND_COMPLETE); * @endcode */ #define FTFL_PDD_WriteStatusReg(PeripheralBase, Value) ( \ FTFL_FSTAT_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- ClearCommandCompleteFlag ---------------------------------------------------------------------------- */ /** * @brief Clears Command complete flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FSTAT. * @par Example: * @code * FTFL_PDD_ClearCommandCompleteFlag(_BASE_PTR); * @endcode */ #define FTFL_PDD_ClearCommandCompleteFlag(PeripheralBase) ( \ FTFL_FSTAT_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(FTFL_FSTAT_REG(PeripheralBase) | FTFL_FSTAT_CCIF_MASK)) & (( \ (uint8)(~(uint8)FTFL_FSTAT_FPVIOL_MASK)) & (( \ (uint8)(~(uint8)FTFL_FSTAT_ACCERR_MASK)) & ( \ (uint8)(~(uint8)FTFL_FSTAT_RDCOLERR_MASK))))) \ ) /* ---------------------------------------------------------------------------- -- ClearReadCollisionErrorFlag ---------------------------------------------------------------------------- */ /** * @brief Clears Read collision error flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FSTAT. * @par Example: * @code * FTFL_PDD_ClearReadCollisionErrorFlag(_BASE_PTR); * @endcode */ #define FTFL_PDD_ClearReadCollisionErrorFlag(PeripheralBase) ( \ FTFL_FSTAT_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(FTFL_FSTAT_REG(PeripheralBase) | FTFL_FSTAT_RDCOLERR_MASK)) & (( \ (uint8)(~(uint8)FTFL_FSTAT_FPVIOL_MASK)) & (( \ (uint8)(~(uint8)FTFL_FSTAT_ACCERR_MASK)) & ( \ (uint8)(~(uint8)FTFL_FSTAT_CCIF_MASK))))) \ ) /* ---------------------------------------------------------------------------- -- ClearAccessErrorFlag ---------------------------------------------------------------------------- */ /** * @brief Clears Access error flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FSTAT. * @par Example: * @code * FTFL_PDD_ClearAccessErrorFlag(_BASE_PTR); * @endcode */ #define FTFL_PDD_ClearAccessErrorFlag(PeripheralBase) ( \ FTFL_FSTAT_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(FTFL_FSTAT_REG(PeripheralBase) | FTFL_FSTAT_ACCERR_MASK)) & (( \ (uint8)(~(uint8)FTFL_FSTAT_FPVIOL_MASK)) & (( \ (uint8)(~(uint8)FTFL_FSTAT_RDCOLERR_MASK)) & ( \ (uint8)(~(uint8)FTFL_FSTAT_CCIF_MASK))))) \ ) /* ---------------------------------------------------------------------------- -- ClearProtectionViolationErrorFlag ---------------------------------------------------------------------------- */ /** * @brief Clears Protection violation error flag. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FSTAT. * @par Example: * @code * FTFL_PDD_ClearProtectionViolationErrorFlag(_BASE_PTR); * @endcode */ #define FTFL_PDD_ClearProtectionViolationErrorFlag(PeripheralBase) ( \ FTFL_FSTAT_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(FTFL_FSTAT_REG(PeripheralBase) | FTFL_FSTAT_FPVIOL_MASK)) & (( \ (uint8)(~(uint8)FTFL_FSTAT_ACCERR_MASK)) & (( \ (uint8)(~(uint8)FTFL_FSTAT_RDCOLERR_MASK)) & ( \ (uint8)(~(uint8)FTFL_FSTAT_CCIF_MASK))))) \ ) /* ---------------------------------------------------------------------------- -- LaunchCommand ---------------------------------------------------------------------------- */ /** * @brief Starts new command. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FSTAT. * @par Example: * @code * FTFL_PDD_LaunchCommand(_BASE_PTR); * @endcode */ #define FTFL_PDD_LaunchCommand(PeripheralBase) ( \ FTFL_FSTAT_REG(PeripheralBase) = \ 0x80U \ ) /* ---------------------------------------------------------------------------- -- ClearFlags ---------------------------------------------------------------------------- */ /** * @brief Writes value to the Flash status register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Flags Interrupt mask. This parameter is a 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FSTAT. * @par Example: * @code * FTFL_PDD_ClearFlags(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_ClearFlags(PeripheralBase, Flags) ( \ FTFL_FSTAT_REG(PeripheralBase) = \ (uint8)(Flags) \ ) /* ---------------------------------------------------------------------------- -- GetFlags ---------------------------------------------------------------------------- */ /** * @brief Returns value of the Flash status register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FSTAT. * @par Example: * @code * uint8 result = FTFL_PDD_GetFlags(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetFlags(PeripheralBase) ( \ FTFL_FSTAT_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadConfigReg ---------------------------------------------------------------------------- */ /** * @brief Returns value of the Flash configuration register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCNFG. * @par Example: * @code * uint8 result = FTFL_PDD_ReadConfigReg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadConfigReg(PeripheralBase) ( \ FTFL_FCNFG_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteConfigReg ---------------------------------------------------------------------------- */ /** * @brief Writes value to the Flash configuration register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Flash configuration register. This * parameter is a 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCNFG. * @par Example: * @code * FTFL_PDD_WriteConfigReg(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteConfigReg(PeripheralBase, Value) ( \ FTFL_FCNFG_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- EnableInterrupts; ---------------------------------------------------------------------------- */ /** * @brief Enables Command commplete end Read collision error interrupts. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Mask Interrupt mask. Use constants from group "EnableInterrupts;, * DisableInterrupts constants". This parameter is 8 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCNFG. * @par Example: * @code * FTFL_PDD_EnableInterrupts(_BASE_PTR, * FTFL_PDD_COMMAND_COMPLETE_INT); * @endcode */ #define FTFL_PDD_EnableInterrupts(PeripheralBase, Mask) ( \ FTFL_FCNFG_REG(PeripheralBase) = \ (uint8)(( \ (uint8)(( \ FTFL_FCNFG_REG(PeripheralBase)) & ( \ (uint8)(~(uint8)(FTFL_FCNFG_CCIE_MASK | FTFL_FCNFG_RDCOLLIE_MASK))))) | ( \ (uint8)(Mask))) \ ) /* ---------------------------------------------------------------------------- -- DisableInterrupts ---------------------------------------------------------------------------- */ /** * @brief Disables Command commplete end Read collision error interrupts. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Mask Interrupt mask. Use constants from group "EnableInterrupts;, * DisableInterrupts constants". This parameter is 8 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCNFG. * @par Example: * @code * FTFL_PDD_DisableInterrupts(_BASE_PTR, * FTFL_PDD_COMMAND_COMPLETE_INT); * @endcode */ #define FTFL_PDD_DisableInterrupts(PeripheralBase, Mask) ( \ FTFL_FCNFG_REG(PeripheralBase) &= \ (uint8)(~(uint8)(Mask)) \ ) /* ---------------------------------------------------------------------------- -- GetEraseAllRequest ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the erase all request bit. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCNFG. * @par Example: * @code * uint8 result = FTFL_PDD_GetEraseAllRequest(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetEraseAllRequest(PeripheralBase) ( \ (uint8)(FTFL_FCNFG_REG(PeripheralBase) & FTFL_FCNFG_ERSAREQ_MASK) \ ) /* ---------------------------------------------------------------------------- -- SuspendErasing ---------------------------------------------------------------------------- */ /** * @brief Suspends the current Erase Flash Sector command execution. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCNFG. * @par Example: * @code * FTFL_PDD_SuspendErasing(_BASE_PTR); * @endcode */ #define FTFL_PDD_SuspendErasing(PeripheralBase) ( \ FTFL_FCNFG_REG(PeripheralBase) |= \ FTFL_FCNFG_ERSSUSP_MASK \ ) /* ---------------------------------------------------------------------------- -- GetRAMReady ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Ram ready bit. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCNFG. * @par Example: * @code * uint8 result = FTFL_PDD_GetRAMReady(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetRAMReady(PeripheralBase) ( \ (uint8)(FTFL_FCNFG_REG(PeripheralBase) & FTFL_FCNFG_RAMRDY_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetEEEReady ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the EEE ready bit. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCNFG. * @par Example: * @code * uint8 result = FTFL_PDD_GetEEEReady(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetEEEReady(PeripheralBase) ( \ (uint8)(FTFL_FCNFG_REG(PeripheralBase) & FTFL_FCNFG_EEERDY_MASK) \ ) /* ---------------------------------------------------------------------------- -- ReadSecurityReg ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Security register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FSEC. * @par Example: * @code * uint8 result = FTFL_PDD_ReadSecurityReg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadSecurityReg(PeripheralBase) ( \ FTFL_FSEC_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- GetBackdoorEnable ---------------------------------------------------------------------------- */ /** * @brief Returns the constant FTFL_PDD_BACKDOOR_KEY_ENABLED if backdoor key * access is enabled else returns the FTFL_PDD_BACKDOOR_KEY_DISABLED constant. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of "BackDoorKey constants" type. The value is cast to * "uint16". * @remarks The macro accesses the following registers: FTFL_FSEC. * @par Example: * @code * uint16 result = FTFL_PDD_GetBackdoorEnable(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetBackdoorEnable(PeripheralBase) ( \ (( \ (uint8)(( \ (uint8)(FTFL_FSEC_REG(PeripheralBase) & FTFL_FSEC_KEYEN_MASK)) >> ( \ FTFL_FSEC_KEYEN_SHIFT))) == ( \ 0x2U)) ? ( \ FTFL_PDD_BACKDOOR_KEY_ENABLED) : ( \ FTFL_PDD_BACKDOOR_KEY_DISABLED) \ ) /* ---------------------------------------------------------------------------- -- GetMassEraseEnable ---------------------------------------------------------------------------- */ /** * @brief Returns the constant MASS_ERASE_ENABLED if mass erase is enabled else * returns the MASS_ERASE_DISABLED constant. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of "Mass erase constants" type. The value is cast to * "uint16". * @remarks The macro accesses the following registers: FTFL_FSEC. * @par Example: * @code * uint16 result = FTFL_PDD_GetMassEraseEnable(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetMassEraseEnable(PeripheralBase) ( \ (( \ (uint8)(( \ (uint8)(FTFL_FSEC_REG(PeripheralBase) & FTFL_FSEC_MEEN_MASK)) >> ( \ FTFL_FSEC_MEEN_SHIFT))) == ( \ 0x2U)) ? ( \ FTFL_PDD_MASS_ERASE_DISABLED) : ( \ FTFL_PDD_MASS_ERASE_ENABLED) \ ) /* ---------------------------------------------------------------------------- -- GetFactoryAccess ---------------------------------------------------------------------------- */ /** * @brief Returns the constant FACTORY_ACCESS_GRANTED if access to the flash * memory contents is enabled else returns the FACTORY_ACCESS_DENIED constant. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of "Factory access constants" type. The value is cast * to "uint16". * @remarks The macro accesses the following registers: FTFL_FSEC. * @par Example: * @code * uint16 result = FTFL_PDD_GetFactoryAccess(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetFactoryAccess(PeripheralBase) ( \ ((uint8)(FTFL_FSEC_REG(PeripheralBase) & FTFL_FSEC_FSLACC_MASK) == 0U) ? ( \ FTFL_PDD_FACTORY_ACCESS_GRANTED) : ((( \ (uint8)(( \ (uint8)(FTFL_FSEC_REG(PeripheralBase) & FTFL_FSEC_FSLACC_MASK)) >> ( \ FTFL_FSEC_FSLACC_SHIFT))) == ( \ 0x3U)) ? ( \ FTFL_PDD_FACTORY_ACCESS_GRANTED) : ( \ FTFL_PDD_FACTORY_ACCESS_DENIED) \ ) \ ) /* ---------------------------------------------------------------------------- -- GetSecurityState ---------------------------------------------------------------------------- */ /** * @brief Returns the constant FTFL_PDD_SECURED if MCU is in secure state else * returns the FTFL_PDD_UNSECURED constant. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of "Security state constants" type. The value is cast * to "uint16". * @remarks The macro accesses the following registers: FTFL_FSEC. * @par Example: * @code * uint16 result = FTFL_PDD_GetSecurityState(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetSecurityState(PeripheralBase) ( \ ((uint8)(FTFL_FSEC_REG(PeripheralBase) & FTFL_FSEC_SEC_MASK) == 0x2U) ? ( \ FTFL_PDD_UNSECURED) : ( \ FTFL_PDD_SECURED) \ ) /* ---------------------------------------------------------------------------- -- ReadOptionReg ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Optional register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FOPT. * @par Example: * @code * uint8 result = FTFL_PDD_ReadOptionReg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadOptionReg(PeripheralBase) ( \ FTFL_FOPT_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadFCCOB0Reg ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Common command object register 0. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCCOB0. * @par Example: * @code * uint8 result = FTFL_PDD_ReadFCCOB0Reg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadFCCOB0Reg(PeripheralBase) ( \ FTFL_FCCOB0_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadFCCOB1Reg ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Common command object register 1. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCCOB1. * @par Example: * @code * uint8 result = FTFL_PDD_ReadFCCOB1Reg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadFCCOB1Reg(PeripheralBase) ( \ FTFL_FCCOB1_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadFCCOB2Reg ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Common command object register 2. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCCOB2. * @par Example: * @code * uint8 result = FTFL_PDD_ReadFCCOB2Reg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadFCCOB2Reg(PeripheralBase) ( \ FTFL_FCCOB2_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadFCCOB3Reg ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Common command object register 3. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCCOB3. * @par Example: * @code * uint8 result = FTFL_PDD_ReadFCCOB3Reg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadFCCOB3Reg(PeripheralBase) ( \ FTFL_FCCOB3_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadFCCOB4Reg ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Common command object register 4. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCCOB4. * @par Example: * @code * uint8 result = FTFL_PDD_ReadFCCOB4Reg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadFCCOB4Reg(PeripheralBase) ( \ FTFL_FCCOB4_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadFCCOB5Reg ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Common command object register 5. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCCOB5. * @par Example: * @code * uint8 result = FTFL_PDD_ReadFCCOB5Reg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadFCCOB5Reg(PeripheralBase) ( \ FTFL_FCCOB5_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadFCCOB6Reg ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Common command object register 6. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCCOB6. * @par Example: * @code * uint8 result = FTFL_PDD_ReadFCCOB6Reg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadFCCOB6Reg(PeripheralBase) ( \ FTFL_FCCOB6_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadFCCOB7Reg ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Common command object register 7. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCCOB7. * @par Example: * @code * uint8 result = FTFL_PDD_ReadFCCOB7Reg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadFCCOB7Reg(PeripheralBase) ( \ FTFL_FCCOB7_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadFCCOB8Reg ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Common command object register 8. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCCOB8. * @par Example: * @code * uint8 result = FTFL_PDD_ReadFCCOB8Reg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadFCCOB8Reg(PeripheralBase) ( \ FTFL_FCCOB8_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadFCCOB9Reg ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Common command object register 9. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCCOB9. * @par Example: * @code * uint8 result = FTFL_PDD_ReadFCCOB9Reg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadFCCOB9Reg(PeripheralBase) ( \ FTFL_FCCOB9_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadFCCOBAReg ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Common command object register A. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCCOBA. * @par Example: * @code * uint8 result = FTFL_PDD_ReadFCCOBAReg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadFCCOBAReg(PeripheralBase) ( \ FTFL_FCCOBA_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadFCCOBBReg ---------------------------------------------------------------------------- */ /** * @brief Returns the value of the Common command object register B. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCCOBB. * @par Example: * @code * uint8 result = FTFL_PDD_ReadFCCOBBReg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadFCCOBBReg(PeripheralBase) ( \ FTFL_FCCOBB_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOB0Reg ---------------------------------------------------------------------------- */ /** * @brief Writes the value to the FCCOB0 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the FCCOB0 register. This parameter is a 8-bit * value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB0. * @par Example: * @code * FTFL_PDD_WriteFCCOB0Reg(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOB0Reg(PeripheralBase, Value) ( \ FTFL_FCCOB0_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOB1Reg ---------------------------------------------------------------------------- */ /** * @brief Writes the value to the FCCOB1 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the FCCOB1 register. This parameter is a 8-bit * value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB1. * @par Example: * @code * FTFL_PDD_WriteFCCOB1Reg(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOB1Reg(PeripheralBase, Value) ( \ FTFL_FCCOB1_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOB2Reg ---------------------------------------------------------------------------- */ /** * @brief Writes the value to the FCCOB2 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the FCCOB2 register. This parameter is a 8-bit * value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB2. * @par Example: * @code * FTFL_PDD_WriteFCCOB2Reg(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOB2Reg(PeripheralBase, Value) ( \ FTFL_FCCOB2_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOB3Reg ---------------------------------------------------------------------------- */ /** * @brief Writes the value to the FCCOB3register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the FCCOB3 register. This parameter is a 8-bit * value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB3. * @par Example: * @code * FTFL_PDD_WriteFCCOB3Reg(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOB3Reg(PeripheralBase, Value) ( \ FTFL_FCCOB3_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOB4Reg ---------------------------------------------------------------------------- */ /** * @brief Writes the value to the FCCOB4 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the FCCOB4 register. This parameter is a 8-bit * value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB4. * @par Example: * @code * FTFL_PDD_WriteFCCOB4Reg(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOB4Reg(PeripheralBase, Value) ( \ FTFL_FCCOB4_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOB5Reg ---------------------------------------------------------------------------- */ /** * @brief Writes the value to the FCCOB5 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the FCCOB5 register. This parameter is a 8-bit * value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB5. * @par Example: * @code * FTFL_PDD_WriteFCCOB5Reg(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOB5Reg(PeripheralBase, Value) ( \ FTFL_FCCOB5_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOB6Reg ---------------------------------------------------------------------------- */ /** * @brief Writes the value to the FCCOB6 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the FCCOB6 register. This parameter is a 8-bit * value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB6. * @par Example: * @code * FTFL_PDD_WriteFCCOB6Reg(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOB6Reg(PeripheralBase, Value) ( \ FTFL_FCCOB6_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOB7Reg ---------------------------------------------------------------------------- */ /** * @brief Writes the value to the FCCOB7 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the FCCOB7 register. This parameter is a 8-bit * value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB7. * @par Example: * @code * FTFL_PDD_WriteFCCOB7Reg(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOB7Reg(PeripheralBase, Value) ( \ FTFL_FCCOB7_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOB8Reg ---------------------------------------------------------------------------- */ /** * @brief Writes the value to the FCCOB8 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the FCCOB8 register. This parameter is a 8-bit * value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB8. * @par Example: * @code * FTFL_PDD_WriteFCCOB8Reg(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOB8Reg(PeripheralBase, Value) ( \ FTFL_FCCOB8_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOB9Reg ---------------------------------------------------------------------------- */ /** * @brief Writes the value to the FCCOB9 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the FCCOB9 register. This parameter is a 8-bit * value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB9. * @par Example: * @code * FTFL_PDD_WriteFCCOB9Reg(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOB9Reg(PeripheralBase, Value) ( \ FTFL_FCCOB9_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOBAReg ---------------------------------------------------------------------------- */ /** * @brief Writes the value to the FCCOBA register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the FCCOBA register. This parameter is a 8-bit * value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOBA. * @par Example: * @code * FTFL_PDD_WriteFCCOBAReg(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOBAReg(PeripheralBase, Value) ( \ FTFL_FCCOBA_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOBBReg ---------------------------------------------------------------------------- */ /** * @brief Writes the value to the FCCOBB register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the FCCOBB register. This parameter is a 8-bit * value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOBB. * @par Example: * @code * FTFL_PDD_WriteFCCOBBReg(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOBBReg(PeripheralBase, Value) ( \ FTFL_FCCOBB_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- SetFCCOBCommand ---------------------------------------------------------------------------- */ /** * @brief Writes the value to the FCCOB Command register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Command Value written to the FCCOB Command register. This parameter is * a 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB0. * @par Example: * @code * FTFL_PDD_SetFCCOBCommand(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_SetFCCOBCommand(PeripheralBase, Command) ( \ FTFL_FCCOB0_REG(PeripheralBase) = \ (uint8)(Command) \ ) /* ---------------------------------------------------------------------------- -- SetFCCOBAddress ---------------------------------------------------------------------------- */ /** * @brief Writes the value to the FCCOB Address register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Address Value written to the FCCOB Address register. This parameter is * a 24-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB3, * FTFL_FCCOB2, FTFL_FCCOB1 (depending on the peripheral). * @par Example: * @code * FTFL_PDD_SetFCCOBAddress(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_SetFCCOBAddress(PeripheralBase, Address) ( \ (FTFL_FCCOB3_REG(PeripheralBase) = \ (uint8)(Address)), \ ((FTFL_FCCOB2_REG(PeripheralBase) = \ (uint8)((uint32)(Address) >> 8U)), \ (FTFL_FCCOB1_REG(PeripheralBase) = \ (uint8)((uint32)(Address) >> 16U))) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOBData0 ---------------------------------------------------------------------------- */ /** * @brief Writes Data byte 0. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Data Value written to the FCCOB Data 0 register. This parameter is a * 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB4. * @par Example: * @code * FTFL_PDD_WriteFCCOBData0(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOBData0(PeripheralBase, Data) ( \ FTFL_FCCOB4_REG(PeripheralBase) = \ (uint8)(Data) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOBData1 ---------------------------------------------------------------------------- */ /** * @brief Writes Data byte 1. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Data Value written to the FCCOB Data 1 register. This parameter is a * 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB5. * @par Example: * @code * FTFL_PDD_WriteFCCOBData1(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOBData1(PeripheralBase, Data) ( \ FTFL_FCCOB5_REG(PeripheralBase) = \ (uint8)(Data) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOBData2 ---------------------------------------------------------------------------- */ /** * @brief Writes Data byte 2. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Data Value written to the FCCOB Data 2 register. This parameter is a * 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB6. * @par Example: * @code * FTFL_PDD_WriteFCCOBData2(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOBData2(PeripheralBase, Data) ( \ FTFL_FCCOB6_REG(PeripheralBase) = \ (uint8)(Data) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOBData3 ---------------------------------------------------------------------------- */ /** * @brief Writes Data byte 3. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Data Value written to the FCCOB Data 3 register. This parameter is a * 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB7. * @par Example: * @code * FTFL_PDD_WriteFCCOBData3(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOBData3(PeripheralBase, Data) ( \ FTFL_FCCOB7_REG(PeripheralBase) = \ (uint8)(Data) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOBData4 ---------------------------------------------------------------------------- */ /** * @brief Writes Data byte 4. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Data Value written to the FCCOB Data 4 register. This parameter is a * 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB8. * @par Example: * @code * FTFL_PDD_WriteFCCOBData4(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOBData4(PeripheralBase, Data) ( \ FTFL_FCCOB8_REG(PeripheralBase) = \ (uint8)(Data) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOBData5 ---------------------------------------------------------------------------- */ /** * @brief Writes Data byte 5. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Data Value written to the FCCOB Data 5 register. This parameter is a * 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB9. * @par Example: * @code * FTFL_PDD_WriteFCCOBData5(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOBData5(PeripheralBase, Data) ( \ FTFL_FCCOB9_REG(PeripheralBase) = \ (uint8)(Data) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOBData6 ---------------------------------------------------------------------------- */ /** * @brief Writes Data byte 6. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Data Value written to the FCCOB Data 6 register. This parameter is a * 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOBA. * @par Example: * @code * FTFL_PDD_WriteFCCOBData6(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOBData6(PeripheralBase, Data) ( \ FTFL_FCCOBA_REG(PeripheralBase) = \ (uint8)(Data) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOBData7 ---------------------------------------------------------------------------- */ /** * @brief Writes Data byte 7. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Data Value written to the FCCOB Data 7 register. This parameter is a * 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOBB. * @par Example: * @code * FTFL_PDD_WriteFCCOBData7(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOBData7(PeripheralBase, Data) ( \ FTFL_FCCOBB_REG(PeripheralBase) = \ (uint8)(Data) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOBLongWordData ---------------------------------------------------------------------------- */ /** * @brief Sets longword data to be programmed. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Data Value written to the Flash in the CPU native endian format. This * parameter is a 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB4, * FTFL_FCCOB5, FTFL_FCCOB6, FTFL_FCCOB7 (depending on the peripheral). * @par Example: * @code * FTFL_PDD_WriteFCCOBLongWordData(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOBLongWordData(PeripheralBase, Data) ( \ (FTFL_FCCOB4_REG(PeripheralBase) = \ (uint8)((uint32)(Data) >> 24U)), \ ((FTFL_FCCOB5_REG(PeripheralBase) = \ (uint8)((uint32)(Data) >> 16U)), \ ((FTFL_FCCOB6_REG(PeripheralBase) = \ (uint8)((uint32)(Data) >> 8U)), \ (FTFL_FCCOB7_REG(PeripheralBase) = \ (uint8)(Data)))) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOBFirstLongWordData ---------------------------------------------------------------------------- */ /** * @brief Sets first longword data to be programmed. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Data Value written to the Flash in the CPU native endian format. This * parameter is a 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB4, * FTFL_FCCOB5, FTFL_FCCOB6, FTFL_FCCOB7 (depending on the peripheral). * @par Example: * @code * FTFL_PDD_WriteFCCOBFirstLongWordData(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOBFirstLongWordData(PeripheralBase, Data) ( \ (FTFL_FCCOB4_REG(PeripheralBase) = \ (uint8)((uint32)(Data) >> 24U)), \ ((FTFL_FCCOB5_REG(PeripheralBase) = \ (uint8)((uint32)(Data) >> 16U)), \ ((FTFL_FCCOB6_REG(PeripheralBase) = \ (uint8)((uint32)(Data) >> 8U)), \ (FTFL_FCCOB7_REG(PeripheralBase) = \ (uint8)(Data)))) \ ) /* ---------------------------------------------------------------------------- -- WriteFCCOBSecondLongWordData ---------------------------------------------------------------------------- */ /** * @brief Sets second longword data to be programmed. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Data Value written to the Flash in the CPU native endian format. This * parameter is a 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB8, * FTFL_FCCOB9, FTFL_FCCOBA, FTFL_FCCOBB (depending on the peripheral). * @par Example: * @code * FTFL_PDD_WriteFCCOBSecondLongWordData(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteFCCOBSecondLongWordData(PeripheralBase, Data) ( \ (FTFL_FCCOB8_REG(PeripheralBase) = \ (uint8)((uint32)(Data) >> 24U)), \ ((FTFL_FCCOB9_REG(PeripheralBase) = \ (uint8)((uint32)(Data) >> 16U)), \ ((FTFL_FCCOBA_REG(PeripheralBase) = \ (uint8)((uint32)(Data) >> 8U)), \ (FTFL_FCCOBB_REG(PeripheralBase) = \ (uint8)(Data)))) \ ) /* ---------------------------------------------------------------------------- -- SetPFlashProtectionState ---------------------------------------------------------------------------- */ /** * @brief Sets program Flash protection state. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Regions Protected regions. This parameter is a 32-bit value. * @param State Requested state. This parameter is of "FlashProtection * constants" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FPROT3. * @par Example: * @code * FTFL_PDD_SetPFlashProtectionState(_BASE_PTR, 1, * FTFL_PDD_UNPROTECTED); * @endcode */ #define FTFL_PDD_SetPFlashProtectionState(PeripheralBase, Regions, State) ( \ ((State) == FTFL_PDD_UNPROTECTED) ? ( \ *(uint32 *)(void *)&(FTFL_FPROT3_REG(PeripheralBase)) |= \ (uint32)(Regions)) : ( \ *(uint32 *)(void *)&(FTFL_FPROT3_REG(PeripheralBase)) &= \ (uint32)(~(uint32)(Regions))) \ ) /* ---------------------------------------------------------------------------- -- GetPFlashProtectionState ---------------------------------------------------------------------------- */ /** * @brief Returns program falsh protection state. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: FTFL_FPROT3. * @par Example: * @code * uint32 result = * FTFL_PDD_GetPFlashProtectionState(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetPFlashProtectionState(PeripheralBase) ( \ (uint32)(~(*(uint32 *)(void *)&(FTFL_FPROT3_REG(PeripheralBase)))) \ ) /* ---------------------------------------------------------------------------- -- ReadProgramFlashProtection0Reg ---------------------------------------------------------------------------- */ /** * @brief Reads program flash protection 0 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FPROT0. * @par Example: * @code * uint8 result = * FTFL_PDD_ReadProgramFlashProtection0Reg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadProgramFlashProtection0Reg(PeripheralBase) ( \ FTFL_FPROT0_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteProgramFlashProtection0Reg ---------------------------------------------------------------------------- */ /** * @brief Writes new value specified by the Value parameter into program flash * protection 0 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value to be written to the program flash protection 0 register. * This parameter is a 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FPROT0. * @par Example: * @code * FTFL_PDD_WriteProgramFlashProtection0Reg(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteProgramFlashProtection0Reg(PeripheralBase, Value) ( \ FTFL_FPROT0_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- ReadProgramFlashProtection1Reg ---------------------------------------------------------------------------- */ /** * @brief Reads program flash protection 1 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FPROT1. * @par Example: * @code * uint8 result = * FTFL_PDD_ReadProgramFlashProtection1Reg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadProgramFlashProtection1Reg(PeripheralBase) ( \ FTFL_FPROT1_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteProgramFlashProtection1Reg ---------------------------------------------------------------------------- */ /** * @brief Writes new value specified by the Value parameter into program flash * protection 1 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value to be written to the program flash protection 1 register. * This parameter is a 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FPROT1. * @par Example: * @code * FTFL_PDD_WriteProgramFlashProtection1Reg(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteProgramFlashProtection1Reg(PeripheralBase, Value) ( \ FTFL_FPROT1_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- ReadProgramFlashProtection2Reg ---------------------------------------------------------------------------- */ /** * @brief Reads program flash protection 2 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FPROT2. * @par Example: * @code * uint8 result = * FTFL_PDD_ReadProgramFlashProtection2Reg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadProgramFlashProtection2Reg(PeripheralBase) ( \ FTFL_FPROT2_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteProgramFlashProtection2Reg ---------------------------------------------------------------------------- */ /** * @brief Writes new value specified by the Value parameter into program flash * protection 2 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value to be written to the program flash protection 2 register. * This parameter is a 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FPROT2. * @par Example: * @code * FTFL_PDD_WriteProgramFlashProtection2Reg(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteProgramFlashProtection2Reg(PeripheralBase, Value) ( \ FTFL_FPROT2_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- ReadProgramFlashProtection3Reg ---------------------------------------------------------------------------- */ /** * @brief Reads program flash protection 3 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FPROT3. * @par Example: * @code * uint8 result = * FTFL_PDD_ReadProgramFlashProtection3Reg(_BASE_PTR); * @endcode */ #define FTFL_PDD_ReadProgramFlashProtection3Reg(PeripheralBase) ( \ FTFL_FPROT3_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteProgramFlashProtection3Reg ---------------------------------------------------------------------------- */ /** * @brief Writes new value specified by the Value parameter into program flash * protection 3 register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value to be written to the program flash protection 3 register. * This parameter is a 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FPROT3. * @par Example: * @code * FTFL_PDD_WriteProgramFlashProtection3Reg(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_WriteProgramFlashProtection3Reg(PeripheralBase, Value) ( \ FTFL_FPROT3_REG(PeripheralBase) = \ (uint8)(Value) \ ) /* ---------------------------------------------------------------------------- -- GetErrorFlags ---------------------------------------------------------------------------- */ /** * @brief Returns all error flags in the Flash status register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FSTAT. * @par Example: * @code * uint8 result = FTFL_PDD_GetErrorFlags(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetErrorFlags(PeripheralBase) ( \ (uint8)(( \ FTFL_FSTAT_REG(PeripheralBase)) & ( \ (uint8)(( \ FTFL_FSTAT_RDCOLERR_MASK) | (( \ FTFL_FSTAT_ACCERR_MASK) | (( \ FTFL_FSTAT_FPVIOL_MASK) | ( \ FTFL_FSTAT_MGSTAT0_MASK)))))) \ ) /* ---------------------------------------------------------------------------- -- ClearErrorFlags ---------------------------------------------------------------------------- */ /** * @brief Clear all error flags in the Flash status register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FSTAT. * @par Example: * @code * FTFL_PDD_ClearErrorFlags(_BASE_PTR); * @endcode */ #define FTFL_PDD_ClearErrorFlags(PeripheralBase) ( \ FTFL_FSTAT_REG(PeripheralBase) = \ (uint8)(FTFL_FSTAT_RDCOLERR_MASK | (FTFL_FSTAT_ACCERR_MASK | FTFL_FSTAT_FPVIOL_MASK)) \ ) /* ---------------------------------------------------------------------------- -- GetCmdCompleteFlag ---------------------------------------------------------------------------- */ /** * @brief Returns non-zero value if the "Command complete" flag is set otherwise * returns zero. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FSTAT. * @par Example: * @code * uint8 result = FTFL_PDD_GetCmdCompleteFlag(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetCmdCompleteFlag(PeripheralBase) ( \ (uint8)(FTFL_FSTAT_REG(PeripheralBase) & FTFL_FSTAT_CCIF_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetReadCollisionErrorFlag ---------------------------------------------------------------------------- */ /** * @brief Returns non-zero value if the "Read collision error" flag is set * otherwise returns zero. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FSTAT. * @par Example: * @code * uint8 result = * FTFL_PDD_GetReadCollisionErrorFlag(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetReadCollisionErrorFlag(PeripheralBase) ( \ (uint8)(FTFL_FSTAT_REG(PeripheralBase) & FTFL_FSTAT_RDCOLERR_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetAccessErrorFlag ---------------------------------------------------------------------------- */ /** * @brief Returns non-zero value if the "Access error" flag is set otherwise * returns zero. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FSTAT. * @par Example: * @code * uint8 result = FTFL_PDD_GetAccessErrorFlag(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetAccessErrorFlag(PeripheralBase) ( \ (uint8)(FTFL_FSTAT_REG(PeripheralBase) & FTFL_FSTAT_ACCERR_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetProtectionViolationFlag ---------------------------------------------------------------------------- */ /** * @brief Returns non-zero value if the "Protection violationr" flag is set * otherwise returns zero. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FSTAT. * @par Example: * @code * uint8 result = * FTFL_PDD_GetProtectionViolationFlag(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetProtectionViolationFlag(PeripheralBase) ( \ (uint8)(FTFL_FSTAT_REG(PeripheralBase) & FTFL_FSTAT_FPVIOL_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetCmdCompleteStatusFlag ---------------------------------------------------------------------------- */ /** * @brief Returns non-zero value if the "Memory controller command completion * status" flag is set otherwise returns zero. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FSTAT. * @par Example: * @code * uint8 result = * FTFL_PDD_GetCmdCompleteStatusFlag(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetCmdCompleteStatusFlag(PeripheralBase) ( \ (uint8)(FTFL_FSTAT_REG(PeripheralBase) & FTFL_FSTAT_MGSTAT0_MASK) \ ) /* ---------------------------------------------------------------------------- -- StartCmd ---------------------------------------------------------------------------- */ /** * @brief Starts commad execution. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FSTAT. * @par Example: * @code * FTFL_PDD_StartCmd(_BASE_PTR); * @endcode */ #define FTFL_PDD_StartCmd(PeripheralBase) ( \ FTFL_FSTAT_REG(PeripheralBase) = \ FTFL_FSTAT_CCIF_MASK \ ) /* ---------------------------------------------------------------------------- -- GetCmdCode ---------------------------------------------------------------------------- */ /** * @brief Returns the current command (value of the FCCOB0 register). This macro * is common for all commands. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCCOB0. * @par Example: * @code * uint8 result = FTFL_PDD_GetCmdCode(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetCmdCode(PeripheralBase) ( \ FTFL_FCCOB0_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- Cmd_Read1sBlock_Init ---------------------------------------------------------------------------- */ /** * @brief Initialzes FCCOB registers for Read 1s block command. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Address Address in the flash block to be verified. Must be dword * aligned. This parameter is a 24-bit value. * @param MarginLevel Read-1 margin choice. Use constants from group "Margin * level constants". This parameter is 8 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB4. * @par Example: * @code * FTFL_PDD_Cmd_Read1sBlock_Init(_BASE_PTR, 1, * FTFL_PDD_READ_MARGIN_LEVEL_NORMAL); * @endcode */ #define FTFL_PDD_Cmd_Read1sBlock_Init(PeripheralBase, Address, MarginLevel) ( \ *(uint32*)&FTFL_FCCOB3_REG(PeripheralBase) = (Address) | (FTFL_PDD_READ_1S_BLOCK << 24), \ (FTFL_FCCOB4_REG(PeripheralBase) = \ (uint8)(MarginLevel)) \ ) /* ---------------------------------------------------------------------------- -- Cmd_Read1sBlock_GetAddress ---------------------------------------------------------------------------- */ /** * @brief Returns the address field of the command (value of the FCCOB1-FCC0B3 * registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @par Example: * @code * uint32 result = * FTFL_PDD_Cmd_Read1sBlock_GetAddress(_BASE_PTR); * @endcode */ #define FTFL_PDD_Cmd_Read1sBlock_GetAddress(PeripheralBase) ( \ (uint32)((*(uint32 *)(void *)&(FTFL_FCCOB3_REG(PeripheralBase))) & 0xFFFFFF) \ ) /* ---------------------------------------------------------------------------- -- Cmd_Read1sBlock_SetAddress ---------------------------------------------------------------------------- */ /** * @brief Sets the address field of the command (FCCOB1-FCC0B3 registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Address Address in the flash block to be verified. Must be dword * aligned. This parameter is a 24-bit value. * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_Read1sBlock_SetAddress(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_Cmd_Read1sBlock_SetAddress(PeripheralBase, Address) ( \ *(uint32*)&FTFL_FCCOB3_REG(PeripheralBase) = (Address) | (FTFL_PDD_READ_1S_BLOCK << 24) \ ) /* ---------------------------------------------------------------------------- -- Cmd_Read1sBlock_GetMarginLevel ---------------------------------------------------------------------------- */ /** * @brief Returns margin level field of the command (FCCOB4 register). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @par Example: * @code * uint8 result = * FTFL_PDD_Cmd_Read1sBlock_GetMarginLevel(_BASE_PTR); * @endcode */ #define FTFL_PDD_Cmd_Read1sBlock_GetMarginLevel(PeripheralBase) ( \ (FTFL_FCCOB4_REG(PeripheralBase)) \ ) /* ---------------------------------------------------------------------------- -- Cmd_Read1sBlock_SetMarginLevel ---------------------------------------------------------------------------- */ /** * @brief Sets the margin level field of the command (FCCOB4 register). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param MarginLevel Read-1 margin choice. Use constants from group "Margin * level constants". This parameter is 8 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB4. * @par Example: * @code * FTFL_PDD_Cmd_Read1sBlock_SetMarginLevel(_BASE_PTR, * FTFL_PDD_READ_MARGIN_LEVEL_NORMAL); * @endcode */ #define FTFL_PDD_Cmd_Read1sBlock_SetMarginLevel(PeripheralBase, MarginLevel) ( \ FTFL_FCCOB4_REG(PeripheralBase) = \ (uint8)(MarginLevel) \ ) /* ---------------------------------------------------------------------------- -- Cmd_Read1sSection_Init ---------------------------------------------------------------------------- */ /** * @brief Initialzes FCCOB registers for Read 1s section command. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Address Flash address in the flash block to be verified. This * parameter is a 24-bit value. * @param SectionUnitCount Number of section units to be verified. This * parameter is a 16-bit value. * @param MarginLevel Read-1 margin choice. Use constants from group "Margin * level constants". This parameter is 8 bits wide. * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_Read1sSection_Init(_BASE_PTR, 1, 1, * FTFL_PDD_READ_MARGIN_LEVEL_NORMAL); * @endcode */ #define FTFL_PDD_Cmd_Read1sSection_Init(PeripheralBase, Address, SectionUnitCount, MarginLevel) ( \ *(uint32*)&FTFL_FCCOB3_REG(PeripheralBase) = (Address) | (FTFL_PDD_READ_1S_SECTION << 24), \ *(uint32*)&FTFL_FCCOB7_REG(PeripheralBase) = (SectionUnitCount << 16) | (MarginLevel << 8) \ ) /* ---------------------------------------------------------------------------- -- Cmd_Read1sSection_GetAddress ---------------------------------------------------------------------------- */ /** * @brief Returns the address field of the command (value of the FCCOB1-FCC0B3 * registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @par Example: * @code * uint32 result = * FTFL_PDD_Cmd_Read1sSection_GetAddress(_BASE_PTR); * @endcode */ #define FTFL_PDD_Cmd_Read1sSection_GetAddress(PeripheralBase) ( \ (uint32)((*(uint32 *)(void *)&(FTFL_FCCOB3_REG(PeripheralBase))) & 0xFFFFFF) \ ) /* ---------------------------------------------------------------------------- -- Cmd_Read1sSection_SetAddress ---------------------------------------------------------------------------- */ /** * @brief Sets the address field of the command (FCCOB1-FCC0B3 registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Address Address in the flash block to be verified. Must be dword * aligned. This parameter is a 24-bit value. * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_Read1sSection_SetAddress(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_Cmd_Read1sSection_SetAddress(PeripheralBase, Address) ( \ *(uint32*)&FTFL_FCCOB3_REG(PeripheralBase) = (Address) | (FTFL_PDD_READ_1S_SECTION << 24) \ ) /* ---------------------------------------------------------------------------- -- Cmd_Read1sSection_GetSize ---------------------------------------------------------------------------- */ /** * @brief Returns the size field of the command (value of the FCCOB4-FCC0B5 * registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 16-bit value. * @par Example: * @code * uint16 result = * FTFL_PDD_Cmd_Read1sSection_GetSize(_BASE_PTR); * @endcode */ #define FTFL_PDD_Cmd_Read1sSection_GetSize(PeripheralBase) ( \ (uint16)((*(uint16 *)(void *)&(FTFL_FCCOB5_REG(PeripheralBase)))) \ ) /* ---------------------------------------------------------------------------- -- Cmd_Read1sSection_SetSize ---------------------------------------------------------------------------- */ /** * @brief Sets the size field of the command (FCCOB6 register). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param SectionUnitCount Number of section units to be verified. This * parameter is a 16-bit value. * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_Read1sSection_SetSize(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_Cmd_Read1sSection_SetSize(PeripheralBase, SectionUnitCount) ( \ *(uint16*)&FTFL_FCCOB5_REG(PeripheralBase) = (SectionUnitCount) \ ) /* ---------------------------------------------------------------------------- -- Cmd_Read1sSection_GetMarginLevel ---------------------------------------------------------------------------- */ /** * @brief Returns margin level field of the command (FCCOB6 register). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @par Example: * @code * uint8 result = * FTFL_PDD_Cmd_Read1sSection_GetMarginLevel(_BASE_PTR); * @endcode */ #define FTFL_PDD_Cmd_Read1sSection_GetMarginLevel(PeripheralBase) ( \ (FTFL_FCCOB6_REG(PeripheralBase)) \ ) /* ---------------------------------------------------------------------------- -- Cmd_Read1sSection_SetMarginLevel ---------------------------------------------------------------------------- */ /** * @brief Sets the margin level field of the command (FCCOB6 register). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param MarginLevel Read-1 margin choice. Use constants from group "Margin * level constants". This parameter is 8 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB6. * @par Example: * @code * FTFL_PDD_Cmd_Read1sSection_SetMarginLevel(_BASE_PTR, * FTFL_PDD_READ_MARGIN_LEVEL_NORMAL); * @endcode */ #define FTFL_PDD_Cmd_Read1sSection_SetMarginLevel(PeripheralBase, MarginLevel) ( \ FTFL_FCCOB6_REG(PeripheralBase) = \ (uint8)(MarginLevel) \ ) /* ---------------------------------------------------------------------------- -- Cmd_ProgramCheck_Init ---------------------------------------------------------------------------- */ /** * @brief Initialzes FCCOB registers for Program check command. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Address Flash address in the flash block. Must be longword aligned. * This parameter is a 24-bit value. * @param Data Expected data. This parameter is a 32-bit value. * @param MarginLevel Read-1 margin choice. Use constants from group "Margin * level constants". This parameter is 8 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB4. * @par Example: * @code * FTFL_PDD_Cmd_ProgramCheck_Init(_BASE_PTR, 1, 1, * FTFL_PDD_READ_MARGIN_LEVEL_NORMAL); * @endcode */ #define FTFL_PDD_Cmd_ProgramCheck_Init(PeripheralBase, Address, Data, MarginLevel) ( \ *(uint32*)&FTFL_FCCOB3_REG(PeripheralBase) = (Address) | (FTFL_PDD_PROGRAM_CHECK << 24), \ ((FTFL_FCCOB4_REG(PeripheralBase) = \ (uint8)(MarginLevel)), \ *(uint32*)&FTFL_FCCOBB_REG(PeripheralBase) = Data) \ ) /* ---------------------------------------------------------------------------- -- Cmd_ProgramCheck_GetAddress ---------------------------------------------------------------------------- */ /** * @brief Returns the address field of the command (value of the FCCOB1-FCC0B3 * registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @par Example: * @code * uint32 result = * FTFL_PDD_Cmd_ProgramCheck_GetAddress(_BASE_PTR); * @endcode */ #define FTFL_PDD_Cmd_ProgramCheck_GetAddress(PeripheralBase) ( \ (uint32)((*(uint32 *)(void *)&(FTFL_FCCOB3_REG(PeripheralBase))) & 0xFFFFFF) \ ) /* ---------------------------------------------------------------------------- -- Cmd_ProgramCheck_SetAddress ---------------------------------------------------------------------------- */ /** * @brief Sets the address field of the command (FCCOB1-FCC0B3 registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Address Flash address in the flash block. Must be longword aligned. * This parameter is a 24-bit value. * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_ProgramCheck_SetAddress(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_Cmd_ProgramCheck_SetAddress(PeripheralBase, Address) ( \ *(uint32*)&FTFL_FCCOB3_REG(PeripheralBase) = (Address) | (FTFL_PDD_PROGRAM_CHECK << 24) \ ) /* ---------------------------------------------------------------------------- -- Cmd_ProgramCheck_GetData ---------------------------------------------------------------------------- */ /** * @brief Returns the data field of the command (FCCOB8-FCC0BB registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @par Example: * @code * uint32 result = * FTFL_PDD_Cmd_ProgramCheck_GetData(_BASE_PTR); * @endcode */ #define FTFL_PDD_Cmd_ProgramCheck_GetData(PeripheralBase) ( \ (uint32)(*(uint32 *)(void *)&FTFL_FCCOBB_REG(PeripheralBase)) \ ) /* ---------------------------------------------------------------------------- -- Cmd_ProgramCheck_SetData ---------------------------------------------------------------------------- */ /** * @brief Sets the data field of the command (FCCOB8-FCC0BB registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Data Expected data. This parameter is a 32-bit value. * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_ProgramCheck_SetData(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_Cmd_ProgramCheck_SetData(PeripheralBase, Data) ( \ *(uint32*)&FTFL_FCCOBB_REG(PeripheralBase) = Data \ ) /* ---------------------------------------------------------------------------- -- Cmd_ProgramCheck_GetMarginLevel ---------------------------------------------------------------------------- */ /** * @brief Returns margin level field of the command (FCCOB4 register). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @par Example: * @code * uint8 result = * FTFL_PDD_Cmd_ProgramCheck_GetMarginLevel(_BASE_PTR); * @endcode */ #define FTFL_PDD_Cmd_ProgramCheck_GetMarginLevel(PeripheralBase) ( \ (FTFL_FCCOB4_REG(PeripheralBase)) \ ) /* ---------------------------------------------------------------------------- -- Cmd_ProgramCheck_SetMarginLevel ---------------------------------------------------------------------------- */ /** * @brief Sets the margin level field of the command (FCCOB4 register). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param MarginLevel Read-1 margin choice. Use constants from group "Margin * level constants". This parameter is 8 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB4. * @par Example: * @code * FTFL_PDD_Cmd_ProgramCheck_SetMarginLevel(_BASE_PTR, * FTFL_PDD_READ_MARGIN_LEVEL_NORMAL); * @endcode */ #define FTFL_PDD_Cmd_ProgramCheck_SetMarginLevel(PeripheralBase, MarginLevel) ( \ FTFL_FCCOB4_REG(PeripheralBase) = \ (uint8)(MarginLevel) \ ) /* ---------------------------------------------------------------------------- -- Cmd_ProgramLongword_Init ---------------------------------------------------------------------------- */ /** * @brief Initialzes FCCOB registers for Program longword command. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Address Flash address in the flash block. Must be 32-bit aligned. This * parameter is a 24-bit value. * @param Data Longword to be written. This parameter is a 32-bit value. * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_ProgramLongword_Init(_BASE_PTR, 1, 1); * @endcode */ #define FTFL_PDD_Cmd_ProgramLongword_Init(PeripheralBase, Address, Data) ( \ *(uint32*)&FTFL_FCCOB3_REG(PeripheralBase) = (Address) | (FTFL_PDD_PROGRAM_LONGWORD << 24), \ *(uint32*)&FTFL_FCCOB7_REG(PeripheralBase) = Data \ ) /* ---------------------------------------------------------------------------- -- Cmd_ProgramLongword_getAddress ---------------------------------------------------------------------------- */ /** * @brief Returns the address field of the command (value of the FCCOB1-FCC0B3 * registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @par Example: * @code * uint32 result = * FTFL_PDD_Cmd_ProgramLongword_getAddress(_BASE_PTR); * @endcode */ #define FTFL_PDD_Cmd_ProgramLongword_getAddress(PeripheralBase) ( \ (uint32)((*(uint32 *)(void *)&(FTFL_FCCOB3_REG(PeripheralBase))) & 0xFFFFFF) \ ) /* ---------------------------------------------------------------------------- -- Cmd_ProgramLongword_SetAddress ---------------------------------------------------------------------------- */ /** * @brief Sets the address field of the command (FCCOB1-FCC0B3 registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Address Flash address in the flash block. Must be dword aligned. This * parameter is a 24-bit value. * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_ProgramLongword_SetAddress(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_Cmd_ProgramLongword_SetAddress(PeripheralBase, Address) ( \ *(uint32*)&FTFL_FCCOB3_REG(PeripheralBase) = (Address) | (FTFL_PDD_PROGRAM_LONGWORD << 24) \ ) /* ---------------------------------------------------------------------------- -- Cmd_ProgramLongword_GetDWord ---------------------------------------------------------------------------- */ /** * @brief Returns the data field of the command (FCCOB4-FCC0B7 registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @par Example: * @code * uint32 result = * FTFL_PDD_Cmd_ProgramLongword_GetDWord(_BASE_PTR); * @endcode */ #define FTFL_PDD_Cmd_ProgramLongword_GetDWord(PeripheralBase) ( \ (uint32)(*(uint32 *)(void *)&FTFL_FCCOB7_REG(PeripheralBase)) \ ) /* ---------------------------------------------------------------------------- -- Cmd_ProgramLongword_SetDWord ---------------------------------------------------------------------------- */ /** * @brief Sets the data field of the command (FCCOB4-FCC0B7 registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param DWord Expected data. This parameter is a 32-bit value. * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_ProgramLongword_SetDWord(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_Cmd_ProgramLongword_SetDWord(PeripheralBase, DWord) ( \ *(uint32*)&FTFL_FCCOB7_REG(PeripheralBase) = DWord \ ) /* ---------------------------------------------------------------------------- -- Cmd_EraseFlashBlock_Init ---------------------------------------------------------------------------- */ /** * @brief Initialzes FCCOB registers for Erase flash block command. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Address Flash address in the flash block to be erased. Must be dword * aligned. This parameter is a 24-bit value. * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_EraseFlashBlock_Init(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_Cmd_EraseFlashBlock_Init(PeripheralBase, Address) ( \ *(uint32*)&FTFL_FCCOB3_REG(PeripheralBase) = (Address) | (FTFL_PDD_ERASE_FLASH_BLOCK << 24) \ ) /* ---------------------------------------------------------------------------- -- Cmd_EraseFlashBlock_GetAddress ---------------------------------------------------------------------------- */ /** * @brief Returns the address field of the command (value of the FCCOB1-FCC0B3 * registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @par Example: * @code * uint32 result = * FTFL_PDD_Cmd_EraseFlashBlock_GetAddress(_BASE_PTR); * @endcode */ #define FTFL_PDD_Cmd_EraseFlashBlock_GetAddress(PeripheralBase) ( \ (uint32)((*(uint32 *)(void *)&(FTFL_FCCOB3_REG(PeripheralBase))) & 0xFFFFFF) \ ) /* ---------------------------------------------------------------------------- -- Cmd_EraseFlashBlock_SetAddress ---------------------------------------------------------------------------- */ /** * @brief Sets the address field of the command (FCCOB1-FCC0B3 registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Address Flash address in the flash block. Must be dword aligned. This * parameter is a 24-bit value. * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_EraseFlashBlock_SetAddress(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_Cmd_EraseFlashBlock_SetAddress(PeripheralBase, Address) ( \ *(uint32*)&FTFL_FCCOB3_REG(PeripheralBase) = (Address) | (FTFL_PDD_PROGRAM_LONGWORD << 24) \ ) /* ---------------------------------------------------------------------------- -- Cmd_EraseSector_Init ---------------------------------------------------------------------------- */ /** * @brief Initialzes FCCOB registers for Erase flash sector command. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Address Flash address in the flash sector to be erased. Must be dword * aligned. This parameter is a 24-bit value. * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_EraseSector_Init(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_Cmd_EraseSector_Init(PeripheralBase, Address) ( \ *(uint32*)&FTFL_FCCOB3_REG(PeripheralBase) = (Address) | (FTFL_PDD_ERASE_FLASH_SECTOR << 24) \ ) /* ---------------------------------------------------------------------------- -- Cmd_EraseSector_GetAddress ---------------------------------------------------------------------------- */ /** * @brief Returns the address field of the command (value of the FCCOB1-FCC0B3 * registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @par Example: * @code * uint32 result = * FTFL_PDD_Cmd_EraseSector_GetAddress(_BASE_PTR); * @endcode */ #define FTFL_PDD_Cmd_EraseSector_GetAddress(PeripheralBase) ( \ (uint32)((*(uint32 *)(void *)&(FTFL_FCCOB3_REG(PeripheralBase))) & 0xFFFFFF) \ ) /* ---------------------------------------------------------------------------- -- Cmd_EraseSector_SetAddress ---------------------------------------------------------------------------- */ /** * @brief Sets the address field of the command (FCCOB1-FCC0B3 registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Address Flash address in the flash sector. Must be dword aligned. This * parameter is a 24-bit value. * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_EraseSector_SetAddress(_BASE_PTR, 1); * @endcode */ #define FTFL_PDD_Cmd_EraseSector_SetAddress(PeripheralBase, Address) ( \ *(uint32*)&FTFL_FCCOB3_REG(PeripheralBase) = (Address) | (FTFL_PDD_PROGRAM_LONGWORD << 24) \ ) /* ---------------------------------------------------------------------------- -- Cmd_Read1sAllBlocks_Init ---------------------------------------------------------------------------- */ /** * @brief Initialzes FCCOB registers for Read 1s all blocks command. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param MarginLevel Read-1 margin choice. Use constants from group "Margin * level constants". This parameter is 8 bits wide. * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_Read1sAllBlocks_Init(_BASE_PTR, * FTFL_PDD_READ_MARGIN_LEVEL_NORMAL); * @endcode */ #define FTFL_PDD_Cmd_Read1sAllBlocks_Init(PeripheralBase, MarginLevel) ( \ *(uint16*)&FTFL_FCCOB1_REG(PeripheralBase) = MarginLevel | (FTFL_PDD_READ_1S_ALL_BLOCKS << 8) \ ) /* ---------------------------------------------------------------------------- -- Cmd_Read1sAllBlocks_GetMarginLevel ---------------------------------------------------------------------------- */ /** * @brief Returns margin level field of the command (FCCOB1 register). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @par Example: * @code * uint8 result = * FTFL_PDD_Cmd_Read1sAllBlocks_GetMarginLevel(_BASE_PTR); * @endcode */ #define FTFL_PDD_Cmd_Read1sAllBlocks_GetMarginLevel(PeripheralBase) ( \ (FTFL_FCCOB1_REG(PeripheralBase)) \ ) /* ---------------------------------------------------------------------------- -- Cmd_Read1sAllBlocks_SetMarginLevel ---------------------------------------------------------------------------- */ /** * @brief Sets the margin level field of the command (FCCOB1 register). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param MarginLevel Read-1 margin choice. Use constants from group "Margin * level constants". This parameter is 8 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB1. * @par Example: * @code * FTFL_PDD_Cmd_Read1sAllBlocks_SetMarginLevel(_BASE_PTR, * FTFL_PDD_READ_MARGIN_LEVEL_NORMAL); * @endcode */ #define FTFL_PDD_Cmd_Read1sAllBlocks_SetMarginLevel(PeripheralBase, MarginLevel) ( \ FTFL_FCCOB1_REG(PeripheralBase) = \ (uint8)(MarginLevel) \ ) /* ---------------------------------------------------------------------------- -- Cmd_EraseAllBlocks_Init ---------------------------------------------------------------------------- */ /** * @brief Initialzes FCCOB registers for Erase all blocks command. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_EraseAllBlocks_Init(_BASE_PTR); * @endcode */ #define FTFL_PDD_Cmd_EraseAllBlocks_Init(PeripheralBase) ( \ *(uint8*)&FTFL_FCCOB0_REG(PeripheralBase) = FTFL_PDD_ERASE_ALL_BLOCKS \ ) /* ---------------------------------------------------------------------------- -- Cmd_ProgramPartition_Init ---------------------------------------------------------------------------- */ /** * @brief Initialzes FCCOB registers for Program partition command. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param EepromDataSize EEPROM data size and split factor(if supported) code. * Use constants from group "EEPROM size constants". This parameter is 8 * bits wide. * @param EepromBackupSize EEPROM backup size. Use constants from group "EEPROM * backup size constants". This parameter is 8 bits wide. * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_ProgramPartition_Init(_BASE_PTR, * FTFL_PDD_EEPROM_DATA_SIZE_0_B, FTFL_PDD_EEPROM_BACKUP_SIZE_0_KB); * @endcode */ #define FTFL_PDD_Cmd_ProgramPartition_Init(PeripheralBase, EepromDataSize, EepromBackupSize) ( \ *(uint8*)&FTFL_FCCOB0_REG(PeripheralBase) = FTFL_PDD_PROGRAM_PARTITION, \ (*(uint8*)&FTFL_FCCOB4_REG(PeripheralBase) = EepromDataSize, \ *(uint8*)&FTFL_FCCOB5_REG(PeripheralBase) = EepromBackupSize) \ ) /* ---------------------------------------------------------------------------- -- Cmd_ReadPartition_Init ---------------------------------------------------------------------------- */ /** * @brief Initialzes FCCOB registers for Read Resource command. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_ReadPartition_Init(_BASE_PTR); * @endcode */ #define FTFL_PDD_Cmd_ReadPartition_Init(PeripheralBase) ( \ *(uint8*)&FTFL_FCCOB8_REG(PeripheralBase) = 0x00, \ (*(uint32*)&FTFL_FCCOB3_REG(PeripheralBase) = 0x00800000 | 0xFC | (FTFL_PDD_READ_RESOURCE << 24), \ *(uint8*)&FTFL_FCCOB8_REG(PeripheralBase) = FTFL_PDD_RESOURCE_IFR) \ ) /* ---------------------------------------------------------------------------- -- Cmd_ReadPartition_GetEepromDataSize ---------------------------------------------------------------------------- */ /** * @brief Returns the address field of the command (value of the FCCOB1-FCC0B3 * registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCCOB4. * @par Example: * @code * uint8 result = * FTFL_PDD_Cmd_ReadPartition_GetEepromDataSize(_BASE_PTR); * @endcode */ #define FTFL_PDD_Cmd_ReadPartition_GetEepromDataSize(PeripheralBase) ( \ FTFL_FCCOB4_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- Cmd_ReadPartition_GetEepromBackUpSize ---------------------------------------------------------------------------- */ /** * @brief Returns the address field of the command (value of the FCCOB1-FCC0B3 * registers). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FCCOB5. * @par Example: * @code * uint8 result = * FTFL_PDD_Cmd_ReadPartition_GetEepromBackUpSize(_BASE_PTR); * @endcode */ #define FTFL_PDD_Cmd_ReadPartition_GetEepromBackUpSize(PeripheralBase) ( \ FTFL_FCCOB5_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- Cmd_SetFlexRAMFunction_Init ---------------------------------------------------------------------------- */ /** * @brief Initialzes FCCOB registers for Set FlexRAM Function command. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Function FrexRam function choice. Use constants from group "FlexRAM * function constants". This parameter is 8 bits wide. * @return Returns a value of void type. * @par Example: * @code * FTFL_PDD_Cmd_SetFlexRAMFunction_Init(_BASE_PTR, * FTFL_PDD_FLEXRAM_AS_RAM); * @endcode */ #define FTFL_PDD_Cmd_SetFlexRAMFunction_Init(PeripheralBase, Function) ( \ *(uint16*)&FTFL_FCCOB1_REG(PeripheralBase) = Function | (FTFL_PDD_SET_EERAM_FUCTION << 8) \ ) /* ---------------------------------------------------------------------------- -- Cmd_VerifyBackdoorAccessKey_Init ---------------------------------------------------------------------------- */ /** * @brief Initialzes FCCOB registers for Verify Backdoor Access Key command. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Key0 Key 0. This parameter is a 8-bit value. * @param Key1 Key 0. This parameter is a 8-bit value. * @param Key2 Key 0. This parameter is a 8-bit value. * @param Key3 Key 0. This parameter is a 8-bit value. * @param Key4 Key 0. This parameter is a 8-bit value. * @param Key5 Key 0. This parameter is a 8-bit value. * @param Key6 Key 0. This parameter is a 8-bit value. * @param Key7 Key 0. This parameter is a 8-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FCCOB4, * FTFL_FCCOB5, FTFL_FCCOB6, FTFL_FCCOB7, FTFL_FCCOB8, FTFL_FCCOB9, FTFL_FCCOBA, * FTFL_FCCOBB (depending on the peripheral). * @par Example: * @code * FTFL_PDD_Cmd_VerifyBackdoorAccessKey_Init(_BASE_PTR, 1, 1, * 1, 1, 1, 1, 1, 1); * @endcode */ #define FTFL_PDD_Cmd_VerifyBackdoorAccessKey_Init(PeripheralBase, Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7) ( \ *(uint8*)&FTFL_FCCOB0_REG(PeripheralBase) = FTFL_PDD_VERIFY_BACKDOOR_ACCESS_KEY, \ ((FTFL_FCCOB4_REG(PeripheralBase) = \ (uint8)(Key0)), \ ((FTFL_FCCOB5_REG(PeripheralBase) = \ (uint8)(Key1)), \ ((FTFL_FCCOB6_REG(PeripheralBase) = \ (uint8)(Key2)), \ ((FTFL_FCCOB7_REG(PeripheralBase) = \ (uint8)(Key3)), \ ((FTFL_FCCOB8_REG(PeripheralBase) = \ (uint8)(Key4)), \ ((FTFL_FCCOB9_REG(PeripheralBase) = \ (uint8)(Key5)), \ ((FTFL_FCCOBA_REG(PeripheralBase) = \ (uint8)(Key6)), \ (FTFL_FCCOBB_REG(PeripheralBase) = \ (uint8)(Key7))))))))) \ ) /* ---------------------------------------------------------------------------- -- SetDFlashProtectionState ---------------------------------------------------------------------------- */ /** * @brief Sets data Flash protection state. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Regions FTFL_PDD_PROTECTED or FTFL_PDD_UNPROTECTED. This parameter is * a 8-bit value. * @param State Requested state. This parameter is of "FlashProtection * constants" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FDPROT. * @par Example: * @code * FTFL_PDD_SetDFlashProtectionState(_BASE_PTR, 1, * FTFL_PDD_UNPROTECTED); * @endcode */ #define FTFL_PDD_SetDFlashProtectionState(PeripheralBase, Regions, State) ( \ ((State) == FTFL_PDD_UNPROTECTED) ? ( \ FTFL_FDPROT_REG(PeripheralBase) |= \ (uint8)(Regions)) : ( \ FTFL_FDPROT_REG(PeripheralBase) &= \ (uint8)(~(uint8)(Regions))) \ ) /* ---------------------------------------------------------------------------- -- GetDFlashProtectionState ---------------------------------------------------------------------------- */ /** * @brief Each bit of the returned value represent 1/8 of the Data FLASH memory. * If the bit is set the region is protected else the region is unprotected. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FDPROT. * @par Example: * @code * uint8 result = * FTFL_PDD_GetDFlashProtectionState(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetDFlashProtectionState(PeripheralBase) ( \ (uint8)(~(uint8)FTFL_FDPROT_REG(PeripheralBase)) \ ) /* ---------------------------------------------------------------------------- -- SetEERAMProtectionState ---------------------------------------------------------------------------- */ /** * @brief Each bit of the Region parameter represent 1/8 of the EERPROM memory. * To change the protection state of the region(s) select requested regions * (Region param) and set new state (State param). * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Regions Protected regions. This parameter is a 8-bit value. * @param State Requested state. This parameter is of "FlashProtection * constants" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: FTFL_FEPROT. * @par Example: * @code * FTFL_PDD_SetEERAMProtectionState(_BASE_PTR, 1, * FTFL_PDD_UNPROTECTED); * @endcode */ #define FTFL_PDD_SetEERAMProtectionState(PeripheralBase, Regions, State) ( \ ((State) == FTFL_PDD_UNPROTECTED) ? ( \ FTFL_FEPROT_REG(PeripheralBase) |= \ (uint8)(Regions)) : ( \ FTFL_FEPROT_REG(PeripheralBase) &= \ (uint8)(~(uint8)(Regions))) \ ) /* ---------------------------------------------------------------------------- -- GetEERAMProtectionState ---------------------------------------------------------------------------- */ /** * @brief Each bit of the returned value represent 1/8 of the EERPROM memory. If * the bit is set the region is protected else the region is unprotected. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 8-bit value. * @remarks The macro accesses the following registers: FTFL_FEPROT. * @par Example: * @code * uint8 result = * FTFL_PDD_GetEERAMProtectionState(_BASE_PTR); * @endcode */ #define FTFL_PDD_GetEERAMProtectionState(PeripheralBase) ( \ (uint8)(~(uint8)FTFL_FEPROT_REG(PeripheralBase)) \ ) #endif /* #if defined(FTFL_PDD_H_) */ /* FTFL_PDD.h, eof. */