| #ifndef _GEU_INTERFACE_H_ | |
| #define _GEU_INTERFACE_H_ | |
| /****************************************************************************** | |
| * | |
| * (C)Copyright 2005 - 2011 Marvell. All Rights Reserved. | |
| * | |
| * THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MARVELL. | |
| * The copyright notice above does not evidence any actual or intended | |
| * publication of such source code. | |
| * This Module contains Proprietary Information of Marvell and should be | |
| * treated as Confidential. | |
| * The information in this file is provided for the exclusive use of the | |
| * licensees of Marvell. | |
| * Such users have the right to use, modify, and incorporate this code into | |
| * products for purposes authorized by the license agreement provided they | |
| * include this notice and the associated copyright notice with any such | |
| * product. | |
| * The information in this file is provided "AS IS" without warranty. | |
| ******************************************************************************/ | |
| // FUSE life cycles | |
| #define K_LIFECYCLE_STATE_VIRGIN 0 | |
| #define K_LIFECYCLE_STATE_CM 1 | |
| #define K_LIFECYCLE_STATE_DM 2 | |
| #define K_LIFECYCLE_STATE_DD 3 | |
| #define K_LIFECYCLE_STATE_FA 4 | |
| #define K_MRB_JTAG_PERM_DIS 5 | |
| #define LIFECYCLE_CM (K_LIFECYCLE_STATE_CM) | |
| #define LIFECYCLE_DM (K_LIFECYCLE_STATE_DM) | |
| #define LIFECYCLE_DD (K_LIFECYCLE_STATE_DD) | |
| #define LIFECYCLE_FA (K_LIFECYCLE_STATE_FA) | |
| #define LIFECYCLE_JPD (K_MRB_JTAG_PERM_DIS) | |
| // Fuse field sizes in bytes | |
| //FB0 | |
| #define K_AP_CONFIG_FUSE_SIZE 10 | |
| #define K_CP_CONFIG_FUSE_SIZE 2 | |
| #define K_APCP_CONFIG_FUSE_SIZE 12 | |
| #define K_MP0_FUSE_SIZE 12 | |
| #define K_APCPMP0_ECC_FUSE_SIZE 3 | |
| //FB1 | |
| #define K_RKEK_FUSE_SIZE 32 | |
| //FB2/FB3 | |
| #define K_OEM_HASH_FUSE_SIZE 32 | |
| //FB4 | |
| #define K_TRANSIT_KEY_ECC_FUSE_SIZE 4 | |
| #define K_DEVICE_PIN_ECC_SIZE 1 | |
| #define K_DFT_PASSWORD_CHANGE_FUSE_SIZE 1 | |
| #define K_OEM_KEY1_ECC_FUSE_SIZE 4 | |
| #define K_JTAG_KEY1_ECC_FUSE_SIZE 4 | |
| #define K_MP1_FUSE_SIZE 12 | |
| //FB5/FB6 | |
| #define K_JTAG_HASH_FUSE_SIZE 32 | |
| //FB7 | |
| #define K_SECURITY_CONFIG_FUSE_SIZE 4 | |
| #define K_USBID_FUSE_SIZE 4 | |
| #define K_SECURITY_USB_ECC_FUSE_SIZE 1 | |
| #define K_OEM_KEY0_ECC_FUSE_SIZE 4 | |
| #define K_JTAG_KEY0_ECC_FUSE_SIZE 4 | |
| #define K_OEM_UNIQUE_ID_FUSE_SIZE 8 | |
| #define K_OEM_UNIQUE_ID_ECC_FUSE_SIZE 1 | |
| //FB8/FB9 | |
| #define K_EC521_KEY_FUSE_SIZE 32 | |
| //FB10 | |
| #define K_TRANSIT_KEY_FUSE_SIZE 32 | |
| //FB11 | |
| #define K_DEVICE_PIN_FUSE_SIZE 8 | |
| #define K_SW_VERSION_FUSE_SIZE 8 | |
| #define K_WTM_SE_MGMT_FUSE_SIZE 14 | |
| //misc | |
| #define K_FUSEBLOCK_SIZE 32 | |
| #define K_SHA1_SIZE 20 | |
| #define K_SHA256_SIZE 32 | |
| #define K_SHA512_SIZE 64 | |
| // Fuse field buffer sizes in bytes | |
| // Data is always returned as a multiple of 4 bytes | |
| #define K_AP_CONFIG_BUFFER_SIZE 12 | |
| #define K_CP_CONFIG_BUFFER_SIZE 4 | |
| #define K_MP0_BUFFER_SIZE 12 | |
| #define K_USBID_BUFFER_SIZE 4 | |
| #define K_SECURITY_CONFIG_BUFFER_SIZE 4 | |
| #define K_OEM_HASH_BUFFER_SIZE 32 | |
| #define K_JTAG_HASH_BUFFER_SIZE 32 | |
| #define K_RKEK_BUFFER_SIZE 32 | |
| #define K_FUSEBLOCK_BUFFER_SIZE 32 | |
| #define K_OEM_UNIQUE_ID_BUFFER_SIZE 8 | |
| #define K_OEM_UNIQUE_ID_ECC_BUFFER_SIZE 4 | |
| #define K_SECURITY_USB_ECC_BUFFER_SIZE 4 | |
| #define K_AP_CP_MP_ECC_BUFFER_SIZE 4 | |
| // Fuse field sizes in bytes | |
| #define K_PIN_FUSE_SIZE 8 | |
| #define K_OEM_UID_FUSE_SIZE 8 | |
| // Fuse Block Numbers | |
| #define K_AP_CONFIG_FUSEBLOCK 0 | |
| #define K_CP_CONFIG_FUSEBLOCK 0 | |
| #define K_MP0_FUSEBLOCK 0 | |
| #define K_APCPMP0_FUSEBLOCK 0 | |
| #define K_ECC_FUSEBLOCK 0 | |
| #define K_LIFECYCLE_CM_FUSEBLOCK 0 | |
| #define K_LIFECYCLE_DM_FUSEBLOCK 0 | |
| #define K_LIFECYCLE_FUSEBLOCK_CM_DM 0 | |
| #define K_LIFECYCLE_DD_FUSEBLOCK 7 | |
| #define K_LIFECYCLE_FA_FUSEBLOCK 7 | |
| #define K_LIFECYCLE_FUSEBLOCK_DD_FA_JPD 7 | |
| #define K_MRB_JTAG_PERM_DISABLE_FUSEBLOCK 7 | |
| #define K_RKEK_FUSEBLOCK 1 | |
| #define K_OEM_FUSEBLOCK 2 | |
| #define K_SQU0_FUSEBLOCK 3 // Not Supported | |
| #define K_SQU1_FUSEBLOCK 4 // Not Supported | |
| #define K_SQU2_FUSEBLOCK 5 // Not Supported | |
| #define K_JTAG_FUSEBLOCK 6 | |
| #define K_USBID_FUSEBLOCK 7 | |
| #define K_SECURITYCONFIG_FUSEBLOCK 7 | |
| #define K_FB7_FUSEBLOCK 7 | |
| #define K_OEM_UID_FUSEBLOCK 7 | |
| #define K_OEM_UID_ECC_FUSEBLOCK 7 | |
| #define K_NO_FUSEBLOCK 0xF | |
| #define K_UNDEFINED_FUSEBLOCK K_NO_FUSEBLOCK | |
| // Burn/Status Bit Masks/bits - This is an arbitrary internal | |
| // status array that we use to determine which set we're burning | |
| // and pass status internally. | |
| #define K_AP_CONFIG_STATUS_BIT_MASK 0x00000001 | |
| #define K_CP_CONFIG_STATUS_BIT_MASK 0x00000002 | |
| #define K_MP0_STATUS_BIT_MASK 0x00000004 | |
| #define K_APCPMP0_ECC_STATUS_BIT_MASK 0x00000008 | |
| #define K_SOFTWARE_VERSION_STATUS_BIT_MASK 0x00000010 // Reserved | |
| #define K_RKEK_STATUS_BIT_MASK 0x00000020 | |
| #define K_OEM_KEY0_STATUS_BIT_MASK 0x00000040 | |
| #define K_JTAG_KEY0_STATUS_BIT_MASK 0x00000080 | |
| #define K_OEM_KEY0_ECC_STATUS_BIT_MASK 0x00000100 | |
| #define K_FUSEBLOCK_LOCK_STATUS_BIT_MASK 0x00000200 | |
| #define K_LOCK_STATUS_BIT_MASK 0x00000400 | |
| #define K_OEM_UID_STATUS_BIT_MASK 0x00000800 | |
| #define K_OEM_UID_ECC_STATUS_BIT_MASK 0x00001000 | |
| #define K_SECURITY_CONFIG_STATUS_BIT_MASK 0x00002000 | |
| #define K_USBID_STATUS_BIT_MASK 0x00004000 | |
| #define K_SECURITY_USBID_ECC_STATUS_BIT_MASK 0x00008000 | |
| #define K_LIFECYCLE_CM_STATUS_BIT_MASK 0x00010000 | |
| #define K_LIFECYCLE_DM_STATUS_BIT_MASK 0x00020000 | |
| #define K_LIFECYCLE_DD_STATUS_BIT_MASK 0x00040000 | |
| #define K_LIFECYCLE_FA_STATUS_BIT_MASK 0x00080000 | |
| #define K_LIFECYCLE_STATUS_BIT_MASK 0x00100000 | |
| #define K_MRB_JTAG_PERM_DISABLE_STATUS_BIT_MASK 0x00200000 | |
| #define K_JTAG_KEY0_ECC_STATUS_BIT_MASK 0x00400000 | |
| // DebugStatus bits | |
| #define K_FUSE_READY_TIMEOUT 0x10000000 | |
| #define K_MULTIPLE_BURN_COUNT 0x20000000 | |
| #define K_FUSE_BURN_TIMEOUT 0x40000000 | |
| #define K_FUSE_WRONG_ACLK_SETTING 0x80000000 | |
| // Lock Bit Masks | |
| #define K_FB0_FUSE_LOCK_BIT_MASK 0x01 //Bit 0/Block0 | |
| #define K_RKEK_FUSE_LOCK_BIT_MASK 0x02 //Bit 1/Block1 | |
| #define K_OEM_FUSE_LOCK_BIT_MASK 0x04 //Bit 2/block2 | |
| #define K_SQU0_FUSE_LOCK_BIT_MASK 0x08 //Bit 3/block3 | |
| #define K_SQU1_FUSE_LOCK_BIT_MASK 0x10 //Bit 4/block4 | |
| #define K_SQU2_FUSE_LOCK_BIT_MASK 0x20 //Bit 5/block5 | |
| #define K_JTAG_FUSE_LOCK_BIT_MASK 0x40 //Bit 6/Block6 | |
| #define K_FB7_FUSE_LOCK_BIT_MASK 0x80 //Bit 7/Block7 | |
| // LifeCycle/Software Version | |
| #define K_PHYSICAL_BITS_PER_LOGICAL_BIT 3 | |
| #define K_LIFECYCLE_BITSIZE 16 | |
| #define K_MAX_LIFECYCLE_LOGICAL_BITS K_LIFECYCLE_BITSIZE/K_PHYSICAL_BITS_PER_LOGICAL_BIT | |
| #define K_SOFTWARE_VERSION_BITSIZE 32 | |
| #define K_MAX_SOFTWARE_VERSION_LOGICAL_BITS K_SOFTWARE_VERSION_BITSIZE/K_PHYSICAL_BITS_PER_LOGICAL_BIT | |
| // Fuse Burn Status | |
| typedef struct GEU_FuseBurnStatus | |
| { | |
| UINT_T FinalBurnStatus; | |
| UINT_T CorrectedBurnStatus; | |
| UINT_T RawBurnStatus; | |
| UINT_T SavedBurnRequest; | |
| //UINT_T LastUsedLogicalBitOffset; | |
| UINT_T Oem_EccStatus; | |
| UINT_T Jtag_EccStatus; | |
| UINT_T ApCpMp_EccStatus; | |
| UINT_T SecurityUSB_EccStatus; | |
| UINT_T OemUid_EccStatus; | |
| UINT_T DebugStatus; | |
| }GEU_FuseBurnStatus_t; | |
| #define TRUSTBOOT_BURN_EN 0x00000001 | |
| // Note that All API's have UINT_T return values. | |
| // NoError or an error defined in errors.h | |
| /*********************************************************** | |
| * Function: | |
| * GEU_SetActiveFuseBlock | |
| * Description: | |
| * Sets the active fuse block for a set of operations. | |
| * This restricts operations to the specifed fuseblock. | |
| * Operations not targeted to the active fuseblock will fail. | |
| * Notes: | |
| * 1. The specified fuseblock must not be locked. | |
| * 2. The sticky bit must not be set. | |
| * 3. The GlobalFuseData structure (*pActveFuseBlock) is initialized. | |
| * 4. The FuseBurnStatus structure (*pFuseBurnStatus) is initialized. | |
| * 5. The SQU0, SQU1, and SQU2 fuseblocks are not supported. | |
| * 6. Fuseblock numbers below are also supported | |
| * K_NO_FUSEBLOCK | |
| * K_UNDEFINED_FUSEBLOCK | |
| * to allow clearing the internal data structures without specifying | |
| * a legitimate fuseblock. | |
| * 7. The ActiveFuseBlockField is initialize to K_UNDEFINED_FUSEBLOCK_FIELD | |
| * | |
| * Input: | |
| * n - Fuse Block Number | |
| * K_AP_CONFIG_FUSEBLOCK | |
| * K_CP_CONFIG_FUSEBLOCK | |
| * K_USBID_FUSEBLOCK | |
| * K_APCPUSB_FUSEBLOCK | |
| * K_LIFECYCLE_FUSEBLOCK | |
| * K_SOFTWARE_VERSION_FUSEBLOCK | |
| * K_RKEK_FUSEBLOCK | |
| * K_OEM_FUSEBLOCK | |
| * K_JTAG_FUSEBLOCK | |
| * K_ECC_FUSEBLOCK | |
| * K_FB7_FUSEBLOCK | |
| * K_NO_FUSEBLOCK | |
| * K_UNDEFINED_FUSEBLOCK | |
| * Output: | |
| * none | |
| * Returns: | |
| * FUSE_FuseBlockLocked | |
| * FUSE_UnsupportedFuseBlock | |
| ************************************************************/ | |
| UINT_T GEU_SetActiveFuseBlock(UINT_T n); | |
| /*********************************************************** | |
| * Function: | |
| * GEU_ReadActiveFuseBlockNumber | |
| * Description: | |
| * Returns the Active Fuse Block number | |
| * Input: | |
| * none | |
| * Output: | |
| * none | |
| * Returns: | |
| * Active Fuse Block Number | |
| ************************************************************/// Reads back Active Fuse block number | |
| UINT_T GEU_ReadActiveFuseBlockNumber(void); | |
| /*********************************************************** | |
| * Function: | |
| * GEU_GenerateRandomNumber | |
| * Description: | |
| * Generates a 32 bit random number. | |
| * Input: | |
| * Seed - 8 bit Seed number. Range 0-255. Larger number takes | |
| * less time to generate result. | |
| * Output: | |
| * none | |
| * Returns: | |
| * Returns 32 bit random number. | |
| ************************************************************/ | |
| UINT_T GEU_GenerateRandomNumber (UINT_T Seed); | |
| /*********************************************************** | |
| * Function: | |
| * GEU_ReadxxxFuseBits | |
| * | |
| * Description: | |
| * Reads the specified (xxx) fuse bits. | |
| * | |
| * Input: | |
| * pBuffer - Pointer to buffer to write the requested data. | |
| * Size - Size of buffer in bytes must be larger than the | |
| * specified field (must be larger than K_xxx_FUSE_SIZE). | |
| * Output: | |
| * none | |
| * Returns: | |
| * NoError | |
| * FUSE_BufferTooSmall | |
| * | |
| ************************************************************/ | |
| // GEU Fuse Read APIs | |
| UINT_T GEU_ReadApConfigFuseBits(UINT_T* pBuffer, UINT_T Size); | |
| UINT_T GEU_ReadCpConfigFuseBits(UINT_T* pBuffer, UINT_T Size); | |
| UINT_T GEU_ReadUsbIdFuseBits(UINT_T* pBuffer, UINT_T Size); | |
| UINT_T GEU_ReadOemHashKeyFuseBits(UINT_T* pBuffer, UINT_T Size); | |
| UINT_T GEU_ReadOemJtagHashKeyFuseBits(UINT_T* pBuffer, UINT_T Size); | |
| /*********************************************************** | |
| * Function: | |
| * GEU_ReadLifeCycle | |
| * | |
| * | |
| * Input: | |
| * none | |
| * Output: | |
| * none | |
| * Returns: | |
| * State value in the specified range. | |
| * | |
| ************************************************************/ | |
| UINT_T GEU_ReadLifeCycle(void); | |
| /*********************************************************** | |
| * Function: | |
| * GEU_SetupApConfigFuseBits | |
| * | |
| * Description: | |
| * - Confirms the Active FuseBlock and FuseBlockField conform to the | |
| * ApCpMp fuseblock field. | |
| * - Copies the caller supplied AP Config data to | |
| * the appropriate offset in the GEU_FUSE_PROG_VALn register set. | |
| * - Sets the ApConfig Burn Request. | |
| * | |
| * Note: AP/CP/MP must all be done in the same fuse burn to burn ECC. | |
| * Input: | |
| * pBuffer - pointer to a buffer containing the 80 bits of AP Config data | |
| * Size - Size (in bytes) of the data to copy (Must be K_AP_CONFIG_FUSE_SIZE). | |
| * | |
| * Output: | |
| * none | |
| * Returns: | |
| * NoError | |
| * FUSE_FuseBlockNotActive | |
| * FUSE_FuseBlockFieldNotActive | |
| * FUSE_BufferTooSmall | |
| * | |
| ************************************************************/ | |
| UINT_T GEU_SetupApConfigFuseBits(UINT_T* pBuffer, UINT_T Size); | |
| /*********************************************************** | |
| * Function: | |
| * GEU_SetupCpConfigFuseBits | |
| * | |
| * Description: | |
| * - Confirms the Active FuseBlock and FuseBlockField conform to the | |
| * ApCpMp fuseblock field. | |
| * - Copies the caller supplied CP Config data to | |
| * the appropriate offset in the GEU_FUSE_PROG_VALn register set. | |
| * - Sets the CpConfig Burn Request. | |
| * | |
| * Note: AP/CP/MP must all be done in the same fuse burn to burn ECC. | |
| * Input: | |
| * pBuffer - pointer to a buffer containing the 80 bits of AP Config data | |
| * Size - Size (in bytes) of the data to copy (Must be K_CP_CONFIG_FUSE_SIZE). | |
| * | |
| * Output: | |
| * none | |
| * Returns: | |
| * NoError | |
| * FUSE_FuseBlockNotActive | |
| * FUSE_FuseBlockFieldNotActive | |
| * FUSE_BufferTooSmall | |
| * | |
| ************************************************************/ | |
| UINT_T GEU_SetupCpConfigFuseBits(UINT_T* pBuffer, UINT_T Size); | |
| /*********************************************************** | |
| * Function: | |
| * GEU_SetupUsbIdFuseBits | |
| * | |
| * Description: | |
| * - Confirms the Active FuseBlock and FuseBlockField conform to the | |
| * ApCpUsbId fuseblock field. | |
| * - Copies the caller supplied UsbId data to | |
| * the appropriate offset in the GEU_FUSE_PROG_VALn register set. | |
| * - Sets the UsbId Burn Request. | |
| * | |
| * Note: AP/CP/USBID must all be done in the same fuse burn to burn ECC. | |
| * Input: | |
| * pBuffer - pointer to a buffer containing the 80 bits of UsbId data | |
| * Size - Size (in bytes) of the data to copy (Must be K_USBID_FUSE_SIZE). | |
| * | |
| * Output: | |
| * none | |
| * Returns: | |
| * NoError | |
| * FUSE_FuseBlockNotActive | |
| * FUSE_FuseBlockFieldNotActive | |
| * FUSE_BufferTooSmall | |
| * | |
| ************************************************************/ | |
| UINT_T GEU_SetupUsbIdFuseBits(UINT_T* pBuffer, UINT_T Size); | |
| /*********************************************************** | |
| * Function: | |
| * GEU_SetupOemHashKeyFuseBits | |
| * | |
| * Description: | |
| * - Confirms the Active FuseBlock and FuseBlockField conform to the | |
| * Block 7 fuseblock field. | |
| * - Copies the caller supplied OEM Hash Key data to | |
| * the appropriate offset in the GEU_FUSE_PROG_VALn register set. | |
| * - Sets the OEM Hash Key Burn Request. | |
| * | |
| * Input: | |
| * pBuffer - pointer to a buffer containing the 256 bits of OEM Hash key data | |
| * Size - Size (in bytes) of the data to copy (Must be K_OEM HASH_FUSE_SIZE). | |
| * | |
| * Output: | |
| * none | |
| * Returns: | |
| * NoError | |
| * FUSE_FuseBlockNotActive | |
| * FUSE_FuseBlockFieldNotActive | |
| * FUSE_BufferTooSmall | |
| * | |
| ************************************************************/ | |
| UINT_T GEU_SetupOemHashKeyFuseBits(UINT_T* pBuffer, UINT_T Size); | |
| /*********************************************************** | |
| * Function: | |
| * GEU_SetupOemJtagHashKeyFuseBits | |
| * | |
| * Description: | |
| * - Confirms the Active FuseBlock and FuseBlockField conform to the | |
| * JTAG fuseblock field. | |
| * - Copies the caller supplied OEM JTAG Hash Key data to | |
| * the appropriate offset in the GEU_FUSE_PROG_VALn register set. | |
| * - Sets the JTAG Hash Key Burn Request. | |
| * | |
| * Input: | |
| * pBuffer - pointer to a buffer containing the 256 bits of JTAG Hash key data | |
| * Size - Size (in bytes) of the data to copy (Must be K_JTAG HASH_FUSE_SIZE). | |
| * | |
| * Output: | |
| * none | |
| * Returns: | |
| * NoError | |
| * FUSE_FuseBlockNotActive | |
| * FUSE_FuseBlockFieldNotActive | |
| * FUSE_BufferTooSmall | |
| * | |
| ************************************************************/ | |
| UINT_T GEU_SetupOemJtagHashKeyFuseBits(UINT_T* pBuffer, UINT_T Size); | |
| /*********************************************************** | |
| * Function: | |
| * GEU_SetupRkekFuseBits | |
| * | |
| * Description: | |
| * - Confirms the Active FuseBlock and FuseBlockField conform to the | |
| * RKEK fuseblock field. | |
| * - Copies the caller supplied RKEK data to | |
| * the appropriate offset in the GEU_FUSE_PROG_VALn register set. | |
| * - Sets the RKEK Burn Request. | |
| * | |
| * Input: | |
| * pBuffer - pointer to a buffer containing the 256 bits of OEM Hash key data | |
| * Size - Size (in bytes) of the data to copy (Must be K_RKEK_FUSE_SIZE). | |
| * | |
| * Output: | |
| * none | |
| * Returns: | |
| * NoError | |
| * FUSE_FuseBlockNotActive | |
| * FUSE_FuseBlockFieldNotActive | |
| * FUSE_BufferTooSmall | |
| * | |
| ************************************************************/ | |
| UINT_T GEU_SetupRkekFuseBits(UINT_T* pBuffer, UINT_T Size); | |
| /*********************************************************** | |
| * Function: | |
| * GEU_SetupLifeCycleFuseBits | |
| * GEU_SetupSoftwareVersionFuseBits | |
| * | |
| * Description: | |
| * Encodes the specified state to the specified data field | |
| * in a logical bitfield with the number of "1" bits | |
| * equal to the state value. Each logical bit is encoded | |
| * as a majority rule bitfield of 3 physical bits. | |
| * If two or three physical bits are set the logical bit is "1". | |
| * If zero or one physical bit is set the logical bit is "0". | |
| * | |
| * The LifeCycle state can range for 0 to 5. | |
| * The SoftwareVersion state can range from 0 to 21. | |
| * | |
| * Note that fuse failures can limit the maximum value that | |
| * can be programmed. | |
| * | |
| * Input: | |
| * n - desired state value. Must be greater or equal to the current value. | |
| * | |
| * Output: | |
| * none | |
| * Returns: | |
| * FUSE_FuseBlockNotActive | |
| * FUSE_FuseBlockFieldNotActive | |
| * FUSE_FuseBlockFieldOverflow (no more logical bits available to burn) | |
| * FUSE_InvalidState (new value < current value) | |
| * | |
| ************************************************************/ | |
| UINT_T GEU_SetupSoftwareVersionFuseBits(UINT_T value); | |
| UINT_T GEU_SetupLifeCycleFuseBits(UINT_T value); | |
| /********************************************************** | |
| * Function: | |
| * GEU_BurnFuseBlock_ApCpMp | |
| * Description: | |
| * Burns the ApCpMp field in Fuseblock 0. This may burn one | |
| * or more of the AP Config, CP Config, or MP subfields | |
| * in the ApCpMp field. | |
| * | |
| * - Confirms that a burn request exists for one or more of the | |
| * AP, CP, or Mp subfields. | |
| * - Saves LifeCycle and Software Version state (for post burn validation). | |
| * - Saves any of the the AP, CP, or Mp subfields that are not being burned. | |
| * - Burns the fuseblock | |
| * Validates burned subfields and retries if burn not successful. | |
| * - Validates all subfields that were not burned to ensure no changes from the burn. | |
| * | |
| * Input: | |
| * pUserFuseBurnStatus - pointer to a buffer containing a FuseBurnStatus structure | |
| * | |
| * Output: | |
| * none | |
| * Returns: | |
| * NoError | |
| * FUSE_BurnError | |
| * | |
| ************************************************************/ | |
| UINT_T GEU_BurnFuseBlock_ApCpMp(struct GEU_FuseBurnStatus * pFuseBurnStatus); | |
| //UINT_T GEU_BurnFuseBlock_ApCpUsb(struct GEU_FuseBurnStatus * pFuseBurnStatus); | |
| //UINT_T GEU_BurnFuseBlock_ApCp(struct GEU_FuseBurnStatus * pFuseBurnStatus); | |
| /********************************************************** | |
| * Function: | |
| * GEU_BurnFuseBlock_OemHashKey | |
| * GEU_BurnFuesBlock_JtagHashKey | |
| * GEU_BurnFuesBlock_Rkek | |
| * Description: | |
| * Burns the specified field in the corresponding Fuseblock. | |
| * - Confirms that a burn request exists for the specified field/fuseblock. | |
| * - Burns the fuseblock | |
| * Validates the burned field/fuseblock equals the setup data | |
| * Retries if compare fails | |
| * Input: | |
| * pUserFuseBurnStatus - pointer to a buffer containing a FuseBurnStatus structure | |
| * Output: | |
| * none | |
| * Returns: | |
| * NoError | |
| * FUSE_BurnError | |
| ************************************************************/ | |
| UINT_T GEU_BurnFuseBlock_OemHashKey(struct GEU_FuseBurnStatus * pUserFuseBurnStatus); | |
| UINT_T GEU_BurnFuseBlock_Rkek(struct GEU_FuseBurnStatus * pUserFuseBurnStatus); | |
| UINT_T GEU_BurnFuseBlock_OemJtagHashKey(struct GEU_FuseBurnStatus * pUserFuseBurnStatus); | |
| /********************************************************** | |
| * Function: | |
| * GEU_BurnFuseBlock_LifeCycle | |
| * Description: | |
| * Burns the LifeCycle field in Fuseblock 0. | |
| * - Confirms that a LifeCycle burn request exists | |
| * - Saves Software Version state (for post burn validation). | |
| * - Saves the AP, CP, and USB Id subfields (they are not being burned). | |
| * - Burns the fuseblock | |
| * Validates the burned LifeCycle state equals the requested state | |
| * Retries to setup, and burn with the requested value until | |
| * successful or available fuse bits are exhausted. | |
| * - Validates all subfields that were not burned to ensure no changes from the burn. | |
| * Input: | |
| * pUserFuseBurnStatus - pointer to a buffer containing a FuseBurnStatus structure | |
| * Output: | |
| * none | |
| * Returns: | |
| * NoError | |
| * FUSE_BurnError | |
| * Note: If a FUSE_BurnError occurs, one must check the FuseBurnStatus and verify that | |
| * LastUsedLogicalBit is not at maximum (5). If it is, and a call to GEU_READ_LIFECYCLE | |
| * does not return the desired value, then all available fuse bits have been used | |
| * and it will not be possible to burn the requested value. | |
| ************************************************************/ | |
| UINT_T GEU_BurnFuseBlock_LifeCycle(struct GEU_FuseBurnStatus * pUserFuseBurnStatus); | |
| /********************************************************** | |
| * Function: | |
| * GEU_BurnFuseBlock_SoftwareVersion | |
| * Description: | |
| * Burns the SoftwareVersion field in Fuseblock 0. | |
| * - Confirms that a SoftwareVersion burn request exists | |
| * - Saves LifeCycle state (for post burn validation). | |
| * - Saves the AP, CP, and USB Id subfields (they are not being burned). | |
| * - Burns the fuseblock | |
| * Validates the burned Software Version state equals the requested state | |
| * Retries to setup, and burn with the requested value until | |
| * successful or available fuse bits are exhausted. | |
| * - Validates all subfields that were not burned to ensure no changes from the burn. | |
| * Input: | |
| * pUserFuseBurnStatus - pointer to a buffer containing a FuseBurnStatus structure | |
| * Output: | |
| * none | |
| * Returns: | |
| * NoError | |
| * FUSE_BurnError | |
| * Note: If a FUSE_BurnError occurs, one must check the FuseBurnStatus and verify that | |
| * LastUsedLogicalBit is not at maximum (21). If it is, and a call to GEU_READ_LIFECYCLE | |
| * does not return the desired value, then all available fuse bits have been used | |
| * and it will not be possible to burn the requested value. | |
| ************************************************************/ | |
| UINT_T GEU_BurnFuseBlock_SoftwareVersion(struct GEU_FuseBurnStatus * pUserFuseBurnStatus); | |
| /********************************************************** | |
| * Function: | |
| * GEU_BurnEcc | |
| * Description: | |
| * This function burns an ECC value for an ECC protected field. | |
| * This function must be called immediately after burning the ECC protected field. | |
| * | |
| * This function first determines which ECC field must be burned based | |
| * on the saved burn request in the FuseData structure. | |
| * | |
| * - Clears GEU_FUSE_PROG_VAL1 and VAL2 register sets. | |
| * - Retrieves the saved ECC value from the last burn | |
| * - and stores the ECC value in the appropriate field. | |
| * - Burns the fuseblock | |
| * - Validates all ECC fields using GEU_ECC_STATUS and checking | |
| * for uncorrectable errors. | |
| * - Retries teh burn if compare fails | |
| * Input: | |
| * pUserFuseBurnStatus - pointer to a buffer containing a FuseBurnStatus structure | |
| * Output: | |
| * none | |
| * Returns: | |
| * NoError | |
| * FUSE_BurnError | |
| ************************************************************/ | |
| UINT_T GEU_BurnECC(struct GEU_FuseBurnStatus * pUserFuseBurnStatus); | |
| /********************************************************** | |
| * Function: | |
| * GEU_LockFuseBlock | |
| * Description: | |
| * Locks a Fuse Block to prevent further programming | |
| * FuseBlocks supported: 1(OEM), 2(RKEK), 6(JTAG), and 7(ECC) only | |
| * Fuse Blocks 0, 3, 4, and 5 cannot be locked with this API | |
| * Input: | |
| * n- Fuse block to be locked | |
| * pUserFuseBurnStatus - pointer to a buffer containing a FuseBurnStatus structure | |
| * Output: | |
| * none | |
| * Returns: | |
| * NoError | |
| * FUSE_BurnError | |
| * FUSE_UnsupportedFuseBlock | |
| ************************************************************/ | |
| UINT_T GEU_LockFuseBlock(UINT_T n, struct GEU_FuseBurnStatus * pUserFuseBurnStatus); | |
| /*********************************************************** | |
| * Function: | |
| * GEU_SetFuseBlockStickyBit | |
| * GEU_ReadFuseBlockStickyBit | |
| * Description: | |
| * Sets (or Reads) the Sticky bit for fuse block zero. | |
| * Input: | |
| * none | |
| * Output: | |
| * none | |
| * Returns: | |
| * NoError | |
| ************************************************************/// Fuse block sticky bit | |
| UINT_T GEU_SetFuseBlockStickyBit(UINT_T Reserved); // Reserved - StickyBit must be zero | |
| UINT_T GEU_ReadFuseBlockStickyBit(UINT_T Reserved); // Reserved - StickyBit must be zero | |
| /*********************************************************** | |
| * Function: | |
| * GEU_ReadFuseBlockLockState | |
| * Description: | |
| * Reads the lock state of the eight fuse blocks. | |
| * Input: | |
| * pBuffer - Pointer to buffer to write the requested data. | |
| * Output: | |
| * Returns eight bits of valid data int the specified buffer. | |
| * 1 = Locked, 0 = Not Locked | |
| * Bit 0 - Block 0 | |
| * Bit 1 - Block 1 | |
| * Bit 2 - Block 2 | |
| * Bit 3 - Block 3 | |
| * Bit 4 - Block 4 | |
| * Bit 5 - Block 5 | |
| * Bit 6 - Block 6 | |
| * Bit 7 - Block 7 | |
| * Returns: | |
| * NoError | |
| ************************************************************/ | |
| UINT_T GEU_ReadFuseBlockLockState(UINT_T* pBuffer); | |
| /*********************************************************** | |
| * Function: | |
| * GEU_SetJtagEnable | |
| * GEU_ReadJtagEnable | |
| * Description: | |
| * JTAG Control - Called by Trusted Boot Software to enable JTAG | |
| * functionality through GEU until next power cycle. | |
| * Sets bit 7 of GEU_CONFIG. | |
| * Read returns the state of the bit. | |
| * Input: | |
| * none | |
| * Output: | |
| * none | |
| * Returns: | |
| * NoError | |
| ************************************************************/ | |
| UINT_T GEU_SetJtagEnable(void); | |
| UINT_T GEU_ReadJtagEnable(void); | |
| /*********************************************************** | |
| * Function: | |
| * GEU_ReadRegister | |
| * Description: | |
| * Generic function to read any register. | |
| * Input: | |
| * registerAddress - address of register to read. | |
| * pBuffer - address to store the register contents. | |
| * Output: | |
| * none | |
| * Returns: | |
| * NoError | |
| ************************************************************/ | |
| UINT_T GEU_ReadRegister(UINT_T registerAddress, UINT_T * pBuffer); | |
| UINT_T GEU_WriteRegister(UINT_T registerAddress, UINT_T value); | |
| /*********************************************************** | |
| * Function: | |
| * GEU_EnableFuseBurnPower | |
| * Description: | |
| * Enable power supply for fuse programming | |
| * Input: | |
| * none | |
| * Output: | |
| * none | |
| * Returns: | |
| * NoError | |
| ************************************************************/ | |
| UINT_T GEU_EnableFuseBurnPower(void); | |
| /* | |
| * API specified by Paul for newly added functions | |
| */ | |
| UINT_T GEU_ReadOemUidFuseBits(UINT_T* pBuffer, UINT_T Size); | |
| UINT_T GEU_ReadOemUidEcc(UINT_T* pBuffer, UINT_T Size); | |
| UINT_T GEU_SetupUidFuseBits(UINT_T* pBuffer, UINT_T Size); | |
| //UINT_T GEU_SetupUidEccFuseBits(void); | |
| UINT_T GEU_SetupUidEccFuseBits(void); | |
| UINT_T GEU_BurnFuseBlock_OemUid (struct GEU_FuseBurnStatus* pUserFuseBurnStatus); | |
| UINT_T GEU_BurnFuseBlock_OemUidEcc (struct GEU_FuseBurnStatus* pUserFuseBurnStatus); | |
| UINT_T GEU_BurnApCpMpEccFuseBits(struct GEU_FuseBurnStatus* pUserFuseBurnStatus); | |
| UINT_T GEU_BurnFuseBlock_SecurityUSBID(struct GEU_FuseBurnStatus * pUserFuseBurnStatus); | |
| UINT_T GEU_BurnFuseBlock_SecurityUSBIDECC(struct GEU_FuseBurnStatus * pUserFuseBurnStatus); | |
| //UINT_T GEU_ReadLifeCycle(void); | |
| UINT_T GEU_ReadManufacturingParameterBitsInFB0(UINT_T* pBuffer, UINT_T Size); | |
| UINT_T GEU_SetupMpFuseBits(UINT_T* pBuffer, UINT_T Size); | |
| UINT_T GEU_SetupSecurityConfigUsbIdEccFuseBits(void); | |
| UINT_T GEU_SetupApCpMpEccFuseBits(void); | |
| UINT_T GEU_SetupApCpUsbIdEccFuseBits(void); | |
| UINT_T GEU_BurnApCpUsbIDEccFuseBits (struct GEU_FuseBurnStatus* pUserFuseBurnStatus); | |
| UINT_T GEU_ReadManufacturingParameterBitsInFB0(UINT_T* pBuffer, UINT_T Size); | |
| UINT_T GEU_SetupSecurityConfigFuseBits(UINT_T* pBuffer, UINT_T Size); | |
| UINT_T GEU_ReadSecurityConfigFuseBits(UINT_T* pBuffer, UINT_T Size); | |
| UINT_T GEU_BurnApCpEccFuseBits(struct GEU_FuseBurnStatus* pUserFuseBurnStatus); | |
| #endif //_GEU_INTERFACE_H_ |