Crc_api

Functions
void	CRCConfigSet (uint32_t ui32Base, uint32_t ui32CRCConfig)
void	CRCSeedSet (uint32_t ui32Base, uint32_t ui32Seed)
void	CRCDataWrite (uint32_t ui32Base, uint32_t ui32Data)
uint32_t	CRCResultRead (uint32_t ui32Base, bool bPPResult)
uint32_t	CRCDataProcess (uint32_t ui32Base, uint32_t *pui32DataIn, uint32_t ui32DataLength, bool bPPResult)

Detailed Description

Function Documentation

void CRCConfigSet	(	uint32_t	ui32Base,
		uint32_t	ui32CRCConfig
	)

Set the configuration of CRC functionality with the EC module.

Parameters

ui32Base	is the base address of the EC module.
ui32CRCConfig	is the configuration of the CRC engine.

This function configures the operation of the CRC engine within the EC module. The configuration is specified with the ui32CRCConfig argument. It is the logical OR of any of the following options:

CRC Initialization Value

• CRC_CFG_INIT_SEED - Initialize with seed value
• CRC_CFG_INIT_0 - Initialize to all '0s'
• CRC_CFG_INIT_1 - Initialize to all '1s'

Input Data Size

• CRC_CFG_SIZE_8BIT - Input data size of 8 bits
• CRC_CFG_SIZE_32BIT - Input data size of 32 bits

Post Process Reverse/Inverse

• CRC_CFG_RESINV - Result inverse enable
• CRC_CFG_OBR - Output reverse enable

Input Bit Reverse

• CRC_CFG_IBR - Bit reverse enable

Endian Control

• CRC_CFG_ENDIAN_SBHW - Swap byte in half-word
• CRC_CFG_ENDIAN_SHW - Swap half-word

Operation Type

• CRC_CFG_TYPE_P8005 - Polynomial 0x8005
• CRC_CFG_TYPE_P1021 - Polynomial 0x1021
• CRC_CFG_TYPE_P4C11DB7 - Polynomial 0x4C11DB7
• CRC_CFG_TYPE_P1EDC6F41 - Polynomial 0x1EDC6F41
• CRC_CFG_TYPE_TCPCHKSUM - TCP checksum

Returns

None.

Definition at line 98 of file crc.c.

References ASSERT, CCM0_BASE, CCM_O_CRCCTRL, CRC_CFG_ENDIAN_SBHW, CRC_CFG_ENDIAN_SHW, CRC_CFG_IBR, CRC_CFG_INIT_0, CRC_CFG_INIT_1, CRC_CFG_INIT_SEED, CRC_CFG_OBR, CRC_CFG_RESINV, CRC_CFG_SIZE_32BIT, CRC_CFG_SIZE_8BIT, CRC_CFG_TYPE_P1021, CRC_CFG_TYPE_P1EDC6F41, CRC_CFG_TYPE_P4C11DB7, CRC_CFG_TYPE_P8005, CRC_CFG_TYPE_TCPCHKSUM, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == CCM0_BASE);
    ASSERT((ui32CRCConfig & CRC_CFG_INIT_SEED) ||
           (ui32CRCConfig & CRC_CFG_INIT_0) ||
           (ui32CRCConfig & CRC_CFG_INIT_1) ||
           (ui32CRCConfig & CRC_CFG_SIZE_8BIT) ||
           (ui32CRCConfig & CRC_CFG_SIZE_32BIT) ||
           (ui32CRCConfig & CRC_CFG_RESINV) ||
           (ui32CRCConfig & CRC_CFG_OBR) ||
           (ui32CRCConfig & CRC_CFG_IBR) ||
           (ui32CRCConfig & CRC_CFG_ENDIAN_SBHW) ||
           (ui32CRCConfig & CRC_CFG_ENDIAN_SHW) ||
           (ui32CRCConfig & CRC_CFG_TYPE_P8005) ||
           (ui32CRCConfig & CRC_CFG_TYPE_P1021) ||
           (ui32CRCConfig & CRC_CFG_TYPE_P4C11DB7) ||
           (ui32CRCConfig & CRC_CFG_TYPE_P1EDC6F41) ||
           (ui32CRCConfig & CRC_CFG_TYPE_TCPCHKSUM));

    //
    // Write the control register with the configuration.
    //
    HWREG(ui32Base + CCM_O_CRCCTRL) = ui32CRCConfig;
}

uint32_t CRCDataProcess	(	uint32_t	ui32Base,
		uint32_t *	pui32DataIn,
		uint32_t	ui32DataLength,
		bool	bPPResult
	)

Process data to generate a CRC with the EC module.

Parameters

ui32Base	is the base address of the EC module.
pui32DataIn	is a pointer to an array of data that is processed.
ui32DataLength	is the number of data items that are processed to produce the CRC.
bPPResult	is true to read the post-processed result, or false to read the unmodified result.

This function processes an array of data to produce a CRC result.

The data in the array pointed to be pui32DataIn is either an array of bytes or an array or words depending on the selection of the input data size options CRC_CFG_SIZE_8BIT and CRC_CFG_SIZE_32BIT.

This function returns either the unmodified CRC result or the post- processed CRC result from the EC module. The post-processing options are selectable through CRC_CFG_RESINV and CRC_CFG_OBR parameters.

Returns

The CRC result.

Definition at line 254 of file crc.c.

References ASSERT, CCM0_BASE, CCM_CRCCTRL_SIZE, CCM_O_CRCCTRL, CCM_O_CRCDIN, CRCResultRead(), and HWREG.

{
    uint8_t *pui8DataIn;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == CCM0_BASE);

    //
    // See if the CRC is operating in 8-bit or 32-bit mode.
    //
    if(HWREG(ui32Base + CCM_O_CRCCTRL) & CCM_CRCCTRL_SIZE)
    {
        //
        // The CRC is operating in 8-bit mode, so create an 8-bit pointer to
        // the data.
        //
        pui8DataIn = (uint8_t *)pui32DataIn;

        //
        // Loop through the input data.
        //
        while(ui32DataLength--)
        {
            //
            // Write the next data byte.
            //
            HWREG(ui32Base + CCM_O_CRCDIN) = *pui8DataIn++;
        }
    }
    else
    {
        //
        // The CRC is operating in 32-bit mode, so loop through the input data.
        //
        while(ui32DataLength--)
        {
            //
            // Write the next data word.
            //
            HWREG(ui32Base + CCM_O_CRCDIN) = *pui32DataIn++;
        }
    }

    //
    // Return the result.
    //
    return(CRCResultRead(ui32Base, bPPResult));
}

Here is the call graph for this function:

void CRCDataWrite	(	uint32_t	ui32Base,
		uint32_t	ui32Data
	)

Write data into the EC module for CRC operations.

Parameters

ui32Base	is the base address of the EC module.
ui32Data	is the data to be written.

This function writes either 8 or 32 bits of data into the EC module for CRC operations. The distinction between 8 and 32 bits of data is made when the CRC_CFG_SIZE_8BIT or CRC_CFG_SIZE_32BIT flag is set using the CRCConfigSet() function.

When writing 8 bits of data, ensure the data is in the least significant byte position. The remaining bytes should be written with zero. For example, when writing 0xAB, ui32Data should be 0x000000AB.

Returns

None

Definition at line 176 of file crc.c.

References ASSERT, CCM0_BASE, CCM_O_CRCDIN, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == CCM0_BASE);

    //
    // Write the data
    //
    HWREG(ui32Base + CCM_O_CRCDIN) = ui32Data;
}

uint32_t CRCResultRead	(	uint32_t	ui32Base,
		bool	bPPResult
	)

Reads the result of a CRC operation in the EC module.

Parameters

ui32Base	is the base address of the EC module.
bPPResult	is true to read the post-processed result, or false to read the unmodified result.

This function reads either the unmodified CRC result or the post processed CRC result from the EC module. The post-processing options are selectable through CRC_CFG_RESINV and CRC_CFG_OBR parameters in the CRCConfigSet() function.

Returns

The CRC result.

Definition at line 206 of file crc.c.

References ASSERT, CCM0_BASE, CCM_O_CRCRSLTPP, CCM_O_CRCSEED, and HWREG.

Referenced by CRCDataProcess().

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == CCM0_BASE);

    //
    // Depending on the value of bPPResult, read the appropriate register and
    // return value.
    //
    if(bPPResult)
    {
        return(HWREG(ui32Base + CCM_O_CRCRSLTPP));
    }
    else
    {
        return(HWREG(ui32Base + CCM_O_CRCSEED));
    }
}

Here is the caller graph for this function:

void CRCSeedSet	(	uint32_t	ui32Base,
		uint32_t	ui32Seed
	)

Write the seed value for CRC operations in the EC module.

Parameters

ui32Base	is the base address of the EC module.
ui32Seed	is the seed value.

This function writes the seed value for use with CRC operations in the EC module. This value is the start value for CRC operations. If this value is not written, then the residual seed from the previous operation is used as the starting value.

Note

The seed must be written only if CRC_CFG_INIT_SEED is set with the CRCConfigSet() function.

Definition at line 143 of file crc.c.

References ASSERT, CCM0_BASE, CCM_O_CRCSEED, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == CCM0_BASE);

    //
    // Write the seed value to the seed register.
    //
    HWREG(ui32Base + CCM_O_CRCSEED) = ui32Seed;
}