Des_api

Functions
void	DESReset (uint32_t ui32Base)
void	DESConfigSet (uint32_t ui32Base, uint32_t ui32Config)
void	DESKeySet (uint32_t ui32Base, uint32_t *pui32Key)
bool	DESIVSet (uint32_t ui32Base, uint32_t *pui32IVdata)
void	DESLengthSet (uint32_t ui32Base, uint32_t ui32Length)
bool	DESDataReadNonBlocking (uint32_t ui32Base, uint32_t *pui32Dest)
void	DESDataRead (uint32_t ui32Base, uint32_t *pui32Dest)
bool	DESDataWriteNonBlocking (uint32_t ui32Base, uint32_t *pui32Src)
void	DESDataWrite (uint32_t ui32Base, uint32_t *pui32Src)
bool	DESDataProcess (uint32_t ui32Base, uint32_t *pui32Src, uint32_t *pui32Dest, uint32_t ui32Length)
uint32_t	DESIntStatus (uint32_t ui32Base, bool bMasked)
void	DESIntEnable (uint32_t ui32Base, uint32_t ui32IntFlags)
void	DESIntDisable (uint32_t ui32Base, uint32_t ui32IntFlags)
void	DESIntClear (uint32_t ui32Base, uint32_t ui32IntFlags)
void	DESIntRegister (uint32_t ui32Base, void(*pfnHandler)(void))
void	DESIntUnregister (uint32_t ui32Base)
void	DESDMAEnable (uint32_t ui32Base, uint32_t ui32Flags)
void	DESDMADisable (uint32_t ui32Base, uint32_t ui32Flags)

Detailed Description

Function Documentation

void DESConfigSet	(	uint32_t	ui32Base,
		uint32_t	ui32Config
	)

Configures the DES module for operation.

Parameters

ui32Base	is the base address of the DES module.
ui32Config	is the configuration of the DES module.

This function configures the DES module for operation.

The ui32Config parameter is a bit-wise OR of a number of configuration flags. The valid flags are grouped below based on their function.

The direction of the operation is specified with one of the following two flags. Only one is permitted.

• DES_CFG_DIR_ENCRYPT - Encryption
• DES_CFG_DIR_DECRYPT - Decryption

The operational mode of the DES engine is specified with one of the following flags. Only one is permitted.

• DES_CFG_MODE_ECB - Electronic Codebook Mode
• DES_CFG_MODE_CBC - Cipher-Block Chaining Mode
• DES_CFG_MODE_CFB - Cipher Feedback Mode

The selection of single DES or triple DES is specified with one of the following two flags. Only one is permitted.

• DES_CFG_SINGLE - Single DES
• DES_CFG_TRIPLE - Triple DES

Returns

None.

Definition at line 125 of file des.c.

References ASSERT, DES_BASE, DES_CTRL_CONTEXT, DES_O_CTRL, and HWREG.

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

    //
    // Backup the save context field.
    //
    ui32Config |= (HWREG(ui32Base + DES_O_CTRL) & DES_CTRL_CONTEXT);

    //
    // Write the control register.
    //
    HWREG(ui32Base + DES_O_CTRL) = ui32Config;
}

bool DESDataProcess	(	uint32_t	ui32Base,
		uint32_t *	pui32Src,
		uint32_t *	pui32Dest,
		uint32_t	ui32Length
	)

Processes blocks of data through the DES module.

Parameters

ui32Base	is the base address of the DES module.
pui32Src	is a pointer to an array of words that contains the source data for processing.
pui32Dest	is a pointer to an array of words consisting of the processed data.
ui32Length	is the length of the cryptographic data in bytes. It must be a multiple of eight.

This function takes the data contained in the pui32Src array and processes it using the DES engine. The resulting data is stored in the pui32Dest array. The function blocks until all of the data has been processed. If processing is successful, the function returns true.

Note

This functions assumes that the DES module has been configured, and initialization values and keys have been written.

Returns

true or false.

Definition at line 438 of file des.c.

References ASSERT, DES_BASE, DES_CTRL_INPUT_READY, DES_CTRL_OUTPUT_READY, DES_O_CTRL, DES_O_LENGTH, DESDataReadNonBlocking(), DESDataWriteNonBlocking(), and HWREG.

{
    uint32_t ui32Count;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == DES_BASE);
    ASSERT((ui32Length % 8) == 0);

    //
    // Write the length register first.  This triggers the engine to start
    // using this context.
    //
    HWREG(ui32Base + DES_O_LENGTH) = ui32Length;

    //
    // Now loop until the blocks are written.
    //
    for(ui32Count = 0; ui32Count < (ui32Length / 4); ui32Count += 2)
    {
        //
        // Check if the input ready is fine
        //
        while((DES_CTRL_INPUT_READY & (HWREG(ui32Base + DES_O_CTRL))) == 0)
        {
        }

        //
        // Write the block data.
        //
        DESDataWriteNonBlocking(ui32Base, pui32Src + ui32Count);

        //
        // Wait for the output ready
        //
        while((DES_CTRL_OUTPUT_READY & (HWREG(ui32Base + DES_O_CTRL))) == 0)
        {
        }

        //
        // Read the processed data block.
        //
        DESDataReadNonBlocking(ui32Base, pui32Dest + ui32Count);
    }

    //
    // Return true to indicate the process was successful.
    //
    return(true);
}

Here is the call graph for this function:

void DESDataRead	(	uint32_t	ui32Base,
		uint32_t *	pui32Dest
	)

Reads plaintext/ciphertext from data registers with blocking.

Parameters

ui32Base	is the base address of the DES module.
pui32Dest	is a pointer to an array of bytes.

This function waits until the DES module is finished and encrypted or decrypted data is ready. The output data is then stored in the pui32Dest array.

Returns

None

Definition at line 316 of file des.c.

References ASSERT, DES_BASE, DES_CTRL_OUTPUT_READY, DES_O_CTRL, DES_O_DATA_H, DES_O_DATA_L, and HWREG.

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

    //
    // Wait for data output to be ready.
    //
    while((HWREG(ui32Base + DES_O_CTRL) & DES_CTRL_OUTPUT_READY) == 0)
    {
    }

    //
    // Read two words of data from the data registers.
    //
    pui32Dest[0] = HWREG(DES_BASE + DES_O_DATA_L);
    pui32Dest[1] = HWREG(DES_BASE + DES_O_DATA_H);
}

bool DESDataReadNonBlocking	(	uint32_t	ui32Base,
		uint32_t *	pui32Dest
	)

Reads plaintext/ciphertext from data registers without blocking

Parameters

ui32Base	is the base address of the DES module.
pui32Dest	is a pointer to an array of 2 words.

This function returns true if the data was ready when the function was called. If the data was not ready, false is returned.

Returns

True or false.

Definition at line 274 of file des.c.

References ASSERT, DES_BASE, DES_CTRL_OUTPUT_READY, DES_O_CTRL, DES_O_DATA_H, DES_O_DATA_L, and HWREG.

Referenced by DESDataProcess().

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

    //
    // Check to see if the data is ready to be read.
    //
    if((DES_CTRL_OUTPUT_READY & (HWREG(ui32Base + DES_O_CTRL))) == 0)
    {
        return(false);
    }

    //
    // Read two words of data from the data registers.
    //
    pui32Dest[0] = HWREG(DES_BASE + DES_O_DATA_L);
    pui32Dest[1] = HWREG(DES_BASE + DES_O_DATA_H);

    //
    // Return true to indicate a successful write.
    //
    return(true);
}

Here is the caller graph for this function:

void DESDataWrite	(	uint32_t	ui32Base,
		uint32_t *	pui32Src
	)

Writes plaintext/ciphertext to data registers without blocking

Parameters

ui32Base	is the base address of the DES module.
pui32Src	is a pointer to an array of bytes.

This function waits until the DES module is ready before writing the data contained in the pui32Src array.

Returns

None.

Definition at line 393 of file des.c.

References ASSERT, DES_BASE, DES_CTRL_INPUT_READY, DES_O_CTRL, DES_O_DATA_H, DES_O_DATA_L, and HWREG.

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

    //
    // Wait for the input ready bit to go high.
    //
    while(((HWREG(ui32Base + DES_O_CTRL) & DES_CTRL_INPUT_READY)) == 0)
    {
    }

    //
    // Write the data.
    //
    HWREG(DES_BASE + DES_O_DATA_L) = pui32Src[0];
    HWREG(DES_BASE + DES_O_DATA_H) = pui32Src[1];
}

bool DESDataWriteNonBlocking	(	uint32_t	ui32Base,
		uint32_t *	pui32Src
	)

Writes plaintext/ciphertext to data registers without blocking

Parameters

ui32Base	is the base address of the DES module.
pui32Src	is a pointer to an array of 2 words.

This function returns false if the DES module is not ready to accept data. It returns true if the data was written successfully.

Returns

true or false.

Definition at line 351 of file des.c.

References ASSERT, DES_BASE, DES_CTRL_INPUT_READY, DES_O_CTRL, DES_O_DATA_H, DES_O_DATA_L, and HWREG.

Referenced by DESDataProcess().

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

    //
    // Check if the DES module is ready to encrypt or decrypt data.  If it
    // is not, return false.
    //
    if(!(DES_CTRL_INPUT_READY & (HWREG(ui32Base + DES_O_CTRL))))
    {
        return(false);
    }

    //
    // Write the data.
    //
    HWREG(DES_BASE + DES_O_DATA_L) = pui32Src[0];
    HWREG(DES_BASE + DES_O_DATA_H) = pui32Src[1];

    //
    // Return true to indicate a successful write.
    //
    return(true);
}

Here is the caller graph for this function:

void DESDMADisable	(	uint32_t	ui32Base,
		uint32_t	ui32Flags
	)

Disables DMA request sources in the DES module.

Parameters

ui32Base	is the base address of the DES module.
ui32Flags	is a bit mask of the DMA requests to be disabled.

This function disables DMA request sources in the DES module. The ui32Flags parameter should be the logical OR of any of the following:

• DES_DMA_CONTEXT_IN - Context In
• DES_DMA_DATA_OUT - Data Out
• DES_DMA_DATA_IN - Data In

Returns

None.

Definition at line 786 of file des.c.

References ASSERT, DES_BASE, DES_DMA_CONTEXT_IN, DES_DMA_DATA_IN, DES_DMA_DATA_OUT, DES_O_SYSCONFIG, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == DES_BASE);
    ASSERT((ui32Flags & DES_DMA_CONTEXT_IN) ||
           (ui32Flags & DES_DMA_DATA_OUT) ||
           (ui32Flags & DES_DMA_DATA_IN));

    //
    // Disable the DMA sources.
    //
    HWREG(ui32Base + DES_O_SYSCONFIG) &= ~ui32Flags;
}

void DESDMAEnable	(	uint32_t	ui32Base,
		uint32_t	ui32Flags
	)

Enables DMA request sources in the DES module.

Parameters

ui32Base	is the base address of the DES module.
ui32Flags	is a bit mask of the DMA requests to be enabled.

This function enables DMA request sources in the DES module. The ui32Flags parameter should be the logical OR of any of the following:

• DES_DMA_CONTEXT_IN - Context In
• DES_DMA_DATA_OUT - Data Out
• DES_DMA_DATA_IN - Data In

Returns

None.

Definition at line 752 of file des.c.

References ASSERT, DES_BASE, DES_DMA_CONTEXT_IN, DES_DMA_DATA_IN, DES_DMA_DATA_OUT, DES_O_SYSCONFIG, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == DES_BASE);
    ASSERT((ui32Flags & DES_DMA_CONTEXT_IN) ||
           (ui32Flags & DES_DMA_DATA_OUT) ||
           (ui32Flags & DES_DMA_DATA_IN));

    //
    // Set the data in and data out DMA request enable bits.
    //
    HWREG(ui32Base + DES_O_SYSCONFIG) |= ui32Flags;
}

void DESIntClear	(	uint32_t	ui32Base,
		uint32_t	ui32IntFlags
	)

Clears interrupts in the DES module.

Parameters

ui32Base	is the base address of the DES module.
ui32IntFlags	is a bit mask of the interrupts to be disabled.

This function disables interrupt sources in the DES module. ui32IntFlags should be a logical OR of one or more of the following values:

• DES_INT_DMA_CONTEXT_IN - Context interrupt
• DES_INT_DMA_DATA_IN - Data input interrupt
• DES_INT_DMA_DATA_OUT - Data output interrupt

Note

The DMA done interrupts are the only interrupts that can be cleared. The remaining interrupts can be disabled instead using DESIntDisable().

Returns

None.

Definition at line 643 of file des.c.

References ASSERT, DES_BASE, DES_INT_DMA_CONTEXT_IN, DES_INT_DMA_DATA_IN, DES_INT_DMA_DATA_OUT, DES_O_DMAIC, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == DES_BASE);
    ASSERT((ui32IntFlags & DES_INT_DMA_CONTEXT_IN) ||
           (ui32IntFlags & DES_INT_DMA_DATA_IN) ||
           (ui32IntFlags & DES_INT_DMA_DATA_OUT));

    HWREG(ui32Base + DES_O_DMAIC) = (ui32IntFlags & 0x00070000) >> 16;
}

void DESIntDisable	(	uint32_t	ui32Base,
		uint32_t	ui32IntFlags
	)

Disables interrupts in the DES module.

Parameters

ui32Base	is the base address of the DES module.
ui32IntFlags	is a bit mask of the interrupts to be disabled.

This function disables interrupt sources in the DES module. ui32IntFlags should be a logical OR of one or more of the following values:

• DES_INT_CONTEXT_IN - Context interrupt
• DES_INT_DATA_IN - Data input interrupt
• DES_INT_DATA_OUT - Data output interrupt
• DES_INT_DMA_CONTEXT_IN - Context DMA done interrupt
• DES_INT_DMA_DATA_IN - Data input DMA done interrupt
• DES_INT_DMA_DATA_OUT - Data output DMA done interrupt

Returns

None.

Definition at line 601 of file des.c.

References ASSERT, DES_BASE, DES_INT_CONTEXT_IN, DES_INT_DATA_IN, DES_INT_DATA_OUT, DES_INT_DMA_CONTEXT_IN, DES_INT_DMA_DATA_IN, DES_INT_DMA_DATA_OUT, DES_O_DMAIM, DES_O_IRQENABLE, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == DES_BASE);
    ASSERT((ui32IntFlags & DES_INT_CONTEXT_IN) ||
           (ui32IntFlags & DES_INT_DATA_IN) ||
           (ui32IntFlags & DES_INT_DATA_OUT) ||
           (ui32IntFlags & DES_INT_DMA_CONTEXT_IN) ||
           (ui32IntFlags & DES_INT_DMA_DATA_IN) ||
           (ui32IntFlags & DES_INT_DMA_DATA_OUT));

    //
    // Clear the interrupts from the flags.
    //
    HWREG(ui32Base + DES_O_DMAIM) &= ~((ui32IntFlags & 0x00070000) >> 16);
    HWREG(ui32Base + DES_O_IRQENABLE) &= ~(ui32IntFlags & 0x0000ffff);
}

void DESIntEnable	(	uint32_t	ui32Base,
		uint32_t	ui32IntFlags
	)

Enables interrupts in the DES module.

Parameters

ui32Base	is the base address of the DES module.
ui32IntFlags	is a bit mask of the interrupts to be enabled.

ui32IntFlags should be a logical OR of one or more of the following values:

• DES_INT_CONTEXT_IN - Context interrupt
• DES_INT_DATA_IN - Data input interrupt
• DES_INT_DATA_OUT - Data output interrupt
• DES_INT_DMA_CONTEXT_IN - Context DMA done interrupt
• DES_INT_DMA_DATA_IN - Data input DMA done interrupt
• DES_INT_DMA_DATA_OUT - Data output DMA done interrupt

Returns

None.

Definition at line 559 of file des.c.

References ASSERT, DES_BASE, DES_INT_CONTEXT_IN, DES_INT_DATA_IN, DES_INT_DATA_OUT, DES_INT_DMA_CONTEXT_IN, DES_INT_DMA_DATA_IN, DES_INT_DMA_DATA_OUT, DES_O_DMAIM, DES_O_IRQENABLE, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == DES_BASE);
    ASSERT((ui32IntFlags & DES_INT_CONTEXT_IN) ||
           (ui32IntFlags & DES_INT_DATA_IN) ||
           (ui32IntFlags & DES_INT_DATA_OUT) ||
           (ui32IntFlags & DES_INT_DMA_CONTEXT_IN) ||
           (ui32IntFlags & DES_INT_DMA_DATA_IN) ||
           (ui32IntFlags & DES_INT_DMA_DATA_OUT));

    //
    // Enable the interrupts from the flags.
    //
    HWREG(ui32Base + DES_O_DMAIM) |= (ui32IntFlags & 0x00070000) >> 16;
    HWREG(ui32Base + DES_O_IRQENABLE) |= ui32IntFlags & 0x0000ffff;
}

void DESIntRegister	(	uint32_t	ui32Base,
		void(*)(void)	pfnHandler
	)

Registers an interrupt handler for the DES module.

Parameters

ui32Base	is the base address of the DES module.
pfnHandler	is a pointer to the function to be called when the enabled DES interrupts occur.

This function registers the interrupt handler in the interrupt vector table, and enables DES interrupts on the interrupt controller; specific DES interrupt sources must be enabled using DESIntEnable(). The interrupt handler being registered must clear the source of the interrupt using DESIntClear().

If the application is using a static interrupt vector table stored in flash, then it is not necessary to register the interrupt handler this way. Instead, IntEnable() should be used to enable DES interrupts on the interrupt controller.

See also

IntRegister() for important information about registering interrupt handlers.

Returns

None.

Definition at line 682 of file des.c.

References ASSERT, DES_BASE, INT_DES0_TM4C129, IntEnable(), and IntRegister().

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

    //
    // Register the interrupt handler.
    //
    IntRegister(INT_DES0_TM4C129, pfnHandler);

    //
    // Enable the interrupt.
    //
    IntEnable(INT_DES0_TM4C129);
}

Here is the call graph for this function:

uint32_t DESIntStatus	(	uint32_t	ui32Base,
		bool	bMasked
	)

Returns the current interrupt status of the DES module.

Parameters

ui32Base	is the base address of the DES module.
bMasked	is false if the raw interrupt status is required and true if the masked interrupt status is required.

This function gets the current interrupt status of the DES module. The value returned is a logical OR of the following values:

• DES_INT_CONTEXT_IN - Context interrupt
• DES_INT_DATA_IN - Data input interrupt
• DES_INT_DATA_OUT_INT - Data output interrupt
• DES_INT_DMA_CONTEXT_IN - Context DMA done interrupt
• DES_INT_DMA_DATA_IN - Data input DMA done interrupt
• DES_INT_DMA_DATA_OUT - Data output DMA done interrupt

Returns

A bit mask of the current interrupt status.

Definition at line 513 of file des.c.

References ASSERT, DES_BASE, DES_O_DMAMIS, DES_O_DMARIS, DES_O_IRQENABLE, DES_O_IRQSTATUS, and HWREG.

{
    uint32_t ui32Status, ui32Enable;

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

    //
    // Read the status register and return the value.
    //
    ui32Status = HWREG(ui32Base + DES_O_IRQSTATUS);
    if(bMasked)
    {
        ui32Enable = HWREG(ui32Base + DES_O_IRQENABLE);
        return((ui32Status & ui32Enable) |
               (HWREG(ui32Base + DES_O_DMAMIS) << 16));
    }
    else
    {
        return(ui32Status | (HWREG(ui32Base + DES_O_DMARIS) << 16));
    }
}

void DESIntUnregister

(

uint32_t

ui32Base

)

Unregisters an interrupt handler for the DES module.

Parameters

ui32Base

is the base address of the DES module.

This function unregisters the previously registered interrupt handler and disables the interrupt in the interrupt controller.

See also

IntRegister() for important information about registering interrupt handlers.

Returns

None.

Definition at line 716 of file des.c.

References ASSERT, DES_BASE, INT_DES0_TM4C129, IntDisable(), and IntUnregister().

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

    //
    // Disable the interrupt.
    //
    IntDisable(INT_DES0_TM4C129);

    //
    // Unregister the interrupt handler.
    //
    IntUnregister(INT_DES0_TM4C129);
}

Here is the call graph for this function:

bool DESIVSet	(	uint32_t	ui32Base,
		uint32_t *	pui32IVdata
	)

Sets the initialization vector in the DES module.

Parameters

ui32Base	is the base address of the DES module.
pui32IVdata	is a pointer to an array of 64 bits (2 words) of data to be written into the initialization vectors registers.

This function sets the initialization vector in the DES module. It returns true if the registers were successfully written. If the context registers cannot be written at the time the function was called, then false is returned.

Returns

True or false.

Definition at line 202 of file des.c.

References ASSERT, DES_BASE, DES_CTRL_CONTEXT, DES_O_CTRL, DES_O_IV_H, DES_O_IV_L, and HWREG.

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

    //
    // Check to see if context registers can be overwritten.  If not, return
    // false.
    //
    if((HWREG(ui32Base + DES_O_CTRL) & DES_CTRL_CONTEXT) == 0)
    {
        return(false);
    }

    //
    // Write the initialization vector registers.
    //
    HWREG(ui32Base + DES_O_IV_L) = pui32IVdata[0];
    HWREG(ui32Base + DES_O_IV_H) = pui32IVdata[1];

    //
    // Return true to indicate the write was successful.
    //
    return(true);
}

void DESKeySet	(	uint32_t	ui32Base,
		uint32_t *	pui32Key
	)

Sets the key used for DES operations.

Parameters

ui32Base	is the base address of the DES module.
pui32Key	is a pointer to an array that holds the key

This function sets the key used for DES operations.

pui32Key should be 64 bits long (2 words) if single DES is being used or 192 bits (6 words) if triple DES is being used.

Returns

None.

Definition at line 159 of file des.c.

References ASSERT, DES_BASE, DES_CFG_TRIPLE, DES_O_CTRL, DES_O_KEY1_H, DES_O_KEY1_L, DES_O_KEY2_H, DES_O_KEY2_L, DES_O_KEY3_H, DES_O_KEY3_L, and HWREG.

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

    //
    // Write the first part of the key.
    //
    HWREG(ui32Base + DES_O_KEY1_L) = pui32Key[0];
    HWREG(ui32Base + DES_O_KEY1_H) = pui32Key[1];

    //
    // If we are performing tripe DES, then write the key registers for
    // the second and third rounds.
    //
    if(HWREG(ui32Base + DES_O_CTRL) & DES_CFG_TRIPLE)
    {
        HWREG(ui32Base + DES_O_KEY2_L) = pui32Key[2];
        HWREG(ui32Base + DES_O_KEY2_H) = pui32Key[3];
        HWREG(ui32Base + DES_O_KEY3_L) = pui32Key[4];
        HWREG(ui32Base + DES_O_KEY3_H) = pui32Key[5];
    }
}

void DESLengthSet	(	uint32_t	ui32Base,
		uint32_t	ui32Length
	)

Sets the crytographic data length in the DES module.

Parameters

ui32Base	is the base address of the DES module.
ui32Length	is the length of the data in bytes.

This function writes the cryptographic data length into the DES module. When this register is written, the engine is triggered to start using this context.

Note

Data lengths up to (2^32 - 1) bytes are allowed.

Returns

None.

Definition at line 247 of file des.c.

References ASSERT, DES_BASE, DES_O_LENGTH, and HWREG.

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

    //
    // Write the length register.
    //
    HWREG(ui32Base + DES_O_LENGTH) = ui32Length;
}

void DESReset

(

uint32_t

ui32Base

)

Resets the DES Module.

Parameters

ui32Base

is the base address of the DES module.

This function performs a soft-reset sequence of the DES module.

Returns

None.

Definition at line 69 of file des.c.

References ASSERT, DES_BASE, DES_O_SYSCONFIG, DES_O_SYSSTATUS, DES_SYSCONFIG_SOFTRESET, DES_SYSSTATUS_RESETDONE, and HWREG.

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

    //
    // Trigger the soft reset.
    //
    HWREG(ui32Base + DES_O_SYSCONFIG) |= DES_SYSCONFIG_SOFTRESET;

    //
    // Wait for the reset to finish.
    //
    while((HWREG(ui32Base + DES_O_SYSSTATUS) &
           DES_SYSSTATUS_RESETDONE) == 0)
    {
    }
}