/****************************************************************************** * Filename: sha2.h * Revised: 2018-04-17 16:04:03 +0200 (Tue, 17 Apr 2018) * Revision: 51893 * * Description: SHA-2 header file. * * Copyright (c) 2015 - 2017, Texas Instruments Incorporated * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * 1) Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * 2) Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * 3) Neither the name of the ORGANIZATION nor the names of its contributors may * be used to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * ******************************************************************************/ //***************************************************************************** // //! \addtogroup peripheral_group //! @{ //! \addtogroup sha2_api //! @{ // //***************************************************************************** #ifndef __SHA2_H__ #define __SHA2_H__ //***************************************************************************** // // If building with a C++ compiler, make all of the definitions in this header // have a C binding. // //***************************************************************************** #ifdef __cplusplus extern "C" { #endif #include #include #include #include "../inc/hw_types.h" #include "../inc/hw_memmap.h" #include "../inc/hw_ints.h" #include "../inc/hw_crypto.h" #include "../inc/hw_ccfg.h" #include "debug.h" #include "interrupt.h" #include "cpu.h" //***************************************************************************** // // Support for DriverLib in ROM: // This section renames all functions that are not "static inline", so that // calling these functions will default to implementation in flash. At the end // of this file a second renaming will change the defaults to implementation in // ROM for available functions. // // To force use of the implementation in flash, e.g. for debugging: // - Globally: Define DRIVERLIB_NOROM at project level // - Per function: Use prefix "NOROM_" when calling the function // //***************************************************************************** #if !defined(DOXYGEN) #define SHA2StartDMAOperation NOROM_SHA2StartDMAOperation #define SHA2WaitForIRQFlags NOROM_SHA2WaitForIRQFlags #define SHA2ComputeInitialHash NOROM_SHA2ComputeInitialHash #define SHA2ComputeIntermediateHash NOROM_SHA2ComputeIntermediateHash #define SHA2ComputeFinalHash NOROM_SHA2ComputeFinalHash #define SHA2ComputeHash NOROM_SHA2ComputeHash #endif //***************************************************************************** // // Values that can be passed to SHA2IntEnable, SHA2IntDisable, and SHA2IntClear // as the intFlags parameter, and returned from SHA2IntStatus. // Only SHA2_DMA_IN_DONE and SHA2_RESULT_RDY are routed to the NVIC. Check each // function to see if it supports other interrupt status flags. // //***************************************************************************** #define SHA2_DMA_IN_DONE (CRYPTO_IRQEN_DMA_IN_DONE_M) #define SHA2_RESULT_RDY (CRYPTO_IRQEN_RESULT_AVAIL_M) #define SHA2_DMA_BUS_ERR (CRYPTO_IRQCLR_DMA_BUS_ERR_M) //***************************************************************************** // // General constants // //***************************************************************************** // SHA-2 module return codes #define SHA2_SUCCESS 0 #define SHA2_INVALID_ALGORITHM 1 #define SHA2_DMA_BUSY 3 #define SHA2_DMA_ERROR 4 #define SHA2_DIGEST_NOT_READY 5 #define SHA2_OLD_DIGEST_NOT_READ 6 // SHA-2 output digest lengths in bytes. #define SHA2_SHA224_DIGEST_LENGTH_BYTES (224 / 8) #define SHA2_SHA256_DIGEST_LENGTH_BYTES (256 / 8) #define SHA2_SHA384_DIGEST_LENGTH_BYTES (384 / 8) #define SHA2_SHA512_DIGEST_LENGTH_BYTES (512 / 8) //Selectable SHA-2 modes. They determine the algorithm used and if initial //values will be set to the default constants or not #define SHA2_MODE_SELECT_SHA224 (CRYPTO_HASHMODE_SHA224_MODE_M) #define SHA2_MODE_SELECT_SHA256 (CRYPTO_HASHMODE_SHA256_MODE_M) #define SHA2_MODE_SELECT_SHA384 (CRYPTO_HASHMODE_SHA384_MODE_M) #define SHA2_MODE_SELECT_SHA512 (CRYPTO_HASHMODE_SHA512_MODE_M) #define SHA2_MODE_SELECT_NEW_HASH (CRYPTO_HASHMODE_NEW_HASH_M) // SHA-2 block lengths. When hashing block-wise, they define the size of each // block provided to the new and intermediate hash functions. #define SHA2_SHA224_BLOCK_SIZE_BYTES (512 / 8) #define SHA2_SHA256_BLOCK_SIZE_BYTES (512 / 8) #define SHA2_SHA384_BLOCK_SIZE_BYTES (1024 / 8) #define SHA2_SHA512_BLOCK_SIZE_BYTES (1024 / 8) // DMA status codes #define SHA2_DMA_CHANNEL0_ACTIVE (CRYPTO_DMASTAT_CH0_ACT_M) #define SHA2_DMA_CHANNEL1_ACTIVE (CRYPTO_DMASTAT_CH1_ACT_M) #define SHA2_DMA_PORT_ERROR (CRYPTO_DMASTAT_PORT_ERR_M) // Crypto module DMA operation types #define SHA2_ALGSEL_SHA256 0x04 #define SHA2_ALGSEL_SHA512 0x08 #define SHA2_ALGSEL_TAG (CRYPTO_ALGSEL_TAG_M) //***************************************************************************** // // API Functions and prototypes // //***************************************************************************** //***************************************************************************** // //! \brief Start a crypto DMA operation //! //! Enable the crypto DMA channels, configure the channel addresses, //! and set the length of the data transfer. //! Setting the length of the data transfer automatically starts the //! transfer. It is also used by the hardware module as a signal to //! begin the encryption, decryption, or MAC operation. //! //! \param [in] channel0Addr //! A pointer to the address channel 0 shall use. //! //! \param [in] channel0Length //! Length of the data in bytes to be read from or written to at //! \c channel0Addr. Set to 0 to not set up this channel. //! //! \param [out] channel1Addr //! A pointer to the address channel 1 shall use. //! //! \param [in] channel1Length //! Length of the data in bytes to be read from or written to at //! \c channel1Addr. Set to 0 to not set up this channel. //! //! \return None // //***************************************************************************** extern void SHA2StartDMAOperation(uint8_t *channel0Addr, uint32_t channel0Length, uint8_t *channel1Addr, uint32_t channel1Length); //***************************************************************************** // //! \brief Poll the interrupt status register and clear when done. //! //! This function polls until one of the bits in the \c irqFlags is //! asserted. Only \ref SHA2_DMA_IN_DONE and \ref SHA2_RESULT_RDY can actually //! trigger the interrupt line. That means that one of those should //! always be included in \c irqFlags and will always be returned together //! with any error codes. //! //! \param [in] irqFlags //! IRQ flags to poll and mask that the status register will be //! masked with. Consists of any bitwise OR of the flags //! below that includes at least one of //! \ref SHA2_DMA_IN_DONE or \ref SHA2_RESULT_RDY : //! - \ref SHA2_DMA_IN_DONE //! - \ref SHA2_RESULT_RDY //! - \ref SHA2_DMA_BUS_ERR //! //! \return Returns the IRQ status register masked with \c irqFlags. May be any //! bitwise OR of the following masks: //! - \ref SHA2_DMA_IN_DONE //! - \ref SHA2_RESULT_RDY //! - \ref SHA2_DMA_BUS_ERR // //***************************************************************************** extern uint32_t SHA2WaitForIRQFlags(uint32_t irqFlags); //***************************************************************************** // //! \brief Start a new SHA-2 hash operation. //! //! This function begins a new piecewise hash operation. //! //! Call this function when starting a new hash operation and the //! entire message is not yet available. //! //! Call SHA2ComputeIntermediateHash() or SHA2ComputeFinalHash() //! after this call. //! //! If the device shall go into standby in between calls to this //! function and either SHA2ComputeIntermediateHash() or //! SHA2ComputeFinalHash(), the intermediate digest must be saved in //! system RAM. //! //! \param [in] message //! Byte array containing the start of the message to hash. //! Must be exactly as long as the block length of the selected //! algorithm. //! - \ref SHA2_SHA224_BLOCK_SIZE_BYTES //! - \ref SHA2_SHA256_BLOCK_SIZE_BYTES //! - \ref SHA2_SHA384_BLOCK_SIZE_BYTES //! - \ref SHA2_SHA512_BLOCK_SIZE_BYTES //! //! \param [out] intermediateDigest //! Pointer to intermediate digest. //! - NULL The intermediate digest will be stored in the internal //! registers of the SHA module. //! - Not NULL Specifies the location the intermediate digest will //! be written to. //! //! Must be of a length equal to the digest length of the selected //! hash algorithm. //! Must be 32-bit aligned. \c intermediateDigest is copied into the //! registers through the AHB slave interface in //! SHA2ComputeIntermediateHash() and SHA2ComputeFinalHash(). //! This can only be done word-by-word. //! //! \param [in] hashAlgorithm Selects the hash algorithm to use. One of: //! - \ref SHA2_MODE_SELECT_SHA224 //! - \ref SHA2_MODE_SELECT_SHA256 //! - \ref SHA2_MODE_SELECT_SHA384 //! - \ref SHA2_MODE_SELECT_SHA512 //! //! \param [in] initialMessageLength The length in bytes of the first //! section of the message to process. Must be a multiple of the //! block size. //! //! \return Returns a SHA-2 return code. //! - \ref SHA2_SUCCESS //! - \ref SHA2_INVALID_ALGORITHM //! //! \sa SHA2ComputeIntermediateHash() //! \sa SHA2ComputeFinalHash() // //***************************************************************************** extern uint32_t SHA2ComputeInitialHash(const uint8_t *message, uint32_t *intermediateDigest, uint32_t hashAlgorithm, uint32_t initialMessageLength); //***************************************************************************** // //! \brief Resume a SHA-2 hash operation but do not finalize it. //! //! This function resumes a previous hash operation. //! //! Call this function when continuing a hash operation and the //! message is not yet complete. //! //! Call this function again or SHA2ComputeFinalHash() //! after this call. //! //! If the device shall go into standby in between calls to this //! function and SHA2ComputeFinalHash(), the intermediate //! digest must be saved in system RAM. //! //! \param [in] message //! Byte array containing the start of the current block of the //! message to hash. //! Must be exactly as long as the block length of the selected //! algorithm. //! - \ref SHA2_SHA224_BLOCK_SIZE_BYTES //! - \ref SHA2_SHA256_BLOCK_SIZE_BYTES //! - \ref SHA2_SHA384_BLOCK_SIZE_BYTES //! - \ref SHA2_SHA512_BLOCK_SIZE_BYTES //! //! \param [in, out] intermediateDigest //! Pointer to intermediate digest. //! - NULL The intermediate digest will be sourced from the internal //! registers of the SHA module and stored there after the //! operation completes. //! - Not NULL Specifies the location the intermediate digest will //! be read from and written to. //! //! Must be of a length equal to the digest length of the selected //! hash algorithm. //! Must be 32-bit aligned. \c intermediateDigest is copied from and //! to the registers through the AHB slave interface. //! This can only be done word-by-word. //! //! \param [in] hashAlgorithm Selects the hash algorithm to use. One of: //! - \ref SHA2_MODE_SELECT_SHA224 //! - \ref SHA2_MODE_SELECT_SHA256 //! - \ref SHA2_MODE_SELECT_SHA384 //! - \ref SHA2_MODE_SELECT_SHA512 //! //! \param [in] intermediateMessageLength The length in bytes of this //! section of the message to process. Must be a multiple of the //! block size. //! //! \return Returns a SHA-2 return code. //! - \ref SHA2_SUCCESS //! - \ref SHA2_INVALID_ALGORITHM //! //! \sa SHA2ComputeInitialHash() //! \sa SHA2ComputeFinalHash() // //***************************************************************************** extern uint32_t SHA2ComputeIntermediateHash(const uint8_t *message, uint32_t *intermediateDigest, uint32_t hashAlgorithm, uint32_t intermediateMessageLength); //***************************************************************************** // //! \brief Resume a SHA-2 hash operation and finalize it. //! //! This function resumes a previous hash session. //! //! Call this function when continuing a hash operation and the //! message is complete. //! //! \param [in] message //! Byte array containing the final block of the message to hash. //! Any length <= the block size is acceptable. //! The DMA finalize the message as necessary. //! - \ref SHA2_SHA224_BLOCK_SIZE_BYTES //! - \ref SHA2_SHA256_BLOCK_SIZE_BYTES //! - \ref SHA2_SHA384_BLOCK_SIZE_BYTES //! - \ref SHA2_SHA512_BLOCK_SIZE_BYTES //! //! \param [out] resultDigest //! Byte array that the final digest will be written to. Must be of //! a length equal to the digest length of the selected hash algorithm. //! //! \param [in] intermediateDigest //! Pointer to intermediate digest. //! - NULL The intermediate digest will be sourced from the internal //! registers of the SHA module. //! - Not NULL Specifies the location the intermediate digest will //! be read from. //! Must be of a length equal to the digest length of the selected //! hash algorithm. //! Must be 32-bit aligned. \c intermediateDigest is copied from and //! to the registers through the AHB slave interface. //! This can only be done word-by-word. //! //! \param [in] totalMsgLength //! The length in bytes of the entire \c message including the sections //! passed to previous calls to SHA2ComputeInitialHash() and //! SHA2ComputeIntermediateHash(). //! //! \param [in] messageLength The length in bytes of the last //! section of the message to process. Does not need to be //! a multiple of the block size. //! //! \param [in] hashAlgorithm Selects the hash algorithm to use. One of: //! - \ref SHA2_MODE_SELECT_SHA224 //! - \ref SHA2_MODE_SELECT_SHA256 //! - \ref SHA2_MODE_SELECT_SHA384 //! - \ref SHA2_MODE_SELECT_SHA512 //! //! \return Returns a SHA-2 return code. //! - \ref SHA2_SUCCESS //! - \ref SHA2_INVALID_ALGORITHM //! //! \sa SHA2ComputeInitialHash() //! \sa SHA2ComputeIntermediateHash() // //***************************************************************************** extern uint32_t SHA2ComputeFinalHash(const uint8_t *message, uint8_t *resultDigest, uint32_t *intermediateDigest, uint32_t totalMsgLength, uint32_t messageLength, uint32_t hashAlgorithm); //***************************************************************************** // //! \brief Start a SHA-2 hash operation and return the finalized digest. //! //! This function starts a hash operation and returns the finalized //! digest. //! //! Use this function if the entire message is available when starting //! the hash. //! //! \param [in] message //! Byte array containing the message that will be hashed. //! Any length <= the block size is acceptable. //! The DMA will finalize the message as necessary. //! - \ref SHA2_SHA224_BLOCK_SIZE_BYTES //! - \ref SHA2_SHA256_BLOCK_SIZE_BYTES //! - \ref SHA2_SHA384_BLOCK_SIZE_BYTES //! - \ref SHA2_SHA512_BLOCK_SIZE_BYTES //! //! \param [out] resultDigest //! Byte array that the final digest will be written to. Must be of a //! length equal to the digest length of the selected hash algorithm. //! //! \param [in] totalMsgLength //! The length in bytes of the entire \c message. //! //! \param [in] hashAlgorithm Selects the hash algorithm to use. One of: //! - \ref SHA2_MODE_SELECT_SHA224 //! - \ref SHA2_MODE_SELECT_SHA256 //! - \ref SHA2_MODE_SELECT_SHA384 //! - \ref SHA2_MODE_SELECT_SHA512 //! //! \return Returns a SHA-2 return code. //! - \ref SHA2_SUCCESS //! - \ref SHA2_INVALID_ALGORITHM //! // //***************************************************************************** extern uint32_t SHA2ComputeHash(const uint8_t *message, uint8_t *resultDigest, uint32_t totalMsgLength, uint32_t hashAlgorithm); //***************************************************************************** // //! \brief Configure the crypto DMA for a particular operation. //! //! \param algorithm //! Configures the crypto DMA for a particular operation. //! It also powers on the respective part of the system. //! \ref SHA2_ALGSEL_TAG may be combined with another flag. All other //! flags are mutually exclusive. //! - 0 : Reset the module and turn off all sub-modules. //! - \ref SHA2_ALGSEL_SHA256 Configure for a SHA224 or SHA256 operation. //! - \ref SHA2_ALGSEL_SHA512 Configure for a SHA384 or SHA512 operation. //! - \ref SHA2_ALGSEL_TAG Read out hash via DMA rather than the slave interface //! //! \return None // //***************************************************************************** __STATIC_INLINE void SHA2SelectAlgorithm(uint32_t algorithm) { ASSERT((algorithm == SHA2_ALGSEL_SHA256) || (algorithm == SHA2_ALGSEL_SHA512) || (algorithm == SHA2_ALGSEL_SHA256 | SHA2_ALGSEL_TAG) || (algorithm == SHA2_ALGSEL_SHA512 | SHA2_ALGSEL_TAG)); HWREG(CRYPTO_BASE + CRYPTO_O_ALGSEL) = algorithm; } //***************************************************************************** // //! \brief Specify the total length of the message. //! //! Despite specifying it here, the crypto DMA must still be //! set up with the correct data length. //! //! Call this function only when setting up the final hash operation to //! enable finalization. //! //! \param length Total message length in bits. //! //! \return None //! //! \sa SHA2StartDMAOperation() // //***************************************************************************** __STATIC_INLINE void SHA2SetMessageLength(uint32_t length) { HWREG(CRYPTO_BASE + CRYPTO_O_HASHINLENL) = length; // CRYPTO_O_HASHINLENH is automatically set to 0. No need for the extra write. } //***************************************************************************** // //! \brief Load an intermediate digest. //! //! \param [in] digestLength //! Length of the digest in bytes. Must be one of: //! - \ref SHA2_SHA224_DIGEST_LENGTH_BYTES //! - \ref SHA2_SHA256_DIGEST_LENGTH_BYTES //! - \ref SHA2_SHA384_DIGEST_LENGTH_BYTES //! - \ref SHA2_SHA512_DIGEST_LENGTH_BYTES //! //! \param [in] digest //! Pointer to an intermediate digest. Must be 32-bit aligned. //! // //***************************************************************************** __STATIC_INLINE void SHA2SetDigest(uint32_t *digest, uint8_t digestLength) { // Check the arguments. ASSERT(!(digest == NULL) && !((uint32_t)digest & 0x03)); ASSERT((digestLength == SHA2_SHA224_DIGEST_LENGTH_BYTES) || (digestLength == SHA2_SHA256_DIGEST_LENGTH_BYTES) || (digestLength == SHA2_SHA384_DIGEST_LENGTH_BYTES) || (digestLength == SHA2_SHA512_DIGEST_LENGTH_BYTES)); // Write digest uint32_t i = 0; for (i = 0; i < (digestLength / sizeof(uint32_t)); i++) { HWREG(CRYPTO_BASE + CRYPTO_O_HASHDIGESTA + (i * sizeof(uint32_t))) = digest[i]; } } //***************************************************************************** // //! \brief Read the intermediate or final digest. //! //! \param [in] digestLength Length of the digest in bytes. Must be one of: //! - ref SHA2_SHA224_DIGEST_LENGTH_BYTES //! - ref SHA2_SHA256_DIGEST_LENGTH_BYTES //! - ref SHA2_SHA384_DIGEST_LENGTH_BYTES //! - ref SHA2_SHA512_DIGEST_LENGTH_BYTES //! //! \param [out] digest //! Pointer to an intermediate digest. Must be 32-bit aligned. //! //! \return Returns a status code. //! - \ref SHA2_OLD_DIGEST_NOT_READ //! - \ref SHA2_SUCCESS // //***************************************************************************** __STATIC_INLINE uint32_t SHA2GetDigest(uint32_t *digest, uint8_t digestLength) { // Check the arguments. ASSERT(!(digest == NULL) && !((uint32_t)digest & 0x03)); ASSERT((digestLength == SHA2_SHA224_DIGEST_LENGTH_BYTES) || (digestLength == SHA2_SHA256_DIGEST_LENGTH_BYTES) || (digestLength == SHA2_SHA384_DIGEST_LENGTH_BYTES) || (digestLength == SHA2_SHA512_DIGEST_LENGTH_BYTES)); if (HWREG(CRYPTO_BASE + CRYPTO_O_HASHIOBUFCTRL) & CRYPTO_HASHIOBUFCTRL_OUTPUT_FULL_M) { return SHA2_OLD_DIGEST_NOT_READ; } else { // Read digest uint32_t i = 0; for (i = 0; i < (digestLength / sizeof(uint32_t)); i++) { digest[i] = HWREG(CRYPTO_BASE + CRYPTO_O_HASHDIGESTA + (i * sizeof(uint32_t))); } return SHA2_SUCCESS; } } //***************************************************************************** // //! \brief Confirm digest was read. // //***************************************************************************** __STATIC_INLINE void SHA2ClearDigestAvailableFlag(void) { HWREG(CRYPTO_BASE + CRYPTO_O_HASHIOBUFCTRL) = HWREG(CRYPTO_BASE + CRYPTO_O_HASHIOBUFCTRL); } //***************************************************************************** // //! \brief Enable individual crypto interrupt sources. //! //! This function enables the indicated crypto interrupt sources. Only the //! sources that are enabled can be reflected to the processor interrupt. //! Disabled sources have no effect on the processor. //! //! \param intFlags is the bitwise OR of the interrupt sources to be enabled. //! - \ref SHA2_DMA_IN_DONE //! - \ref SHA2_RESULT_RDY //! //! \return None // //***************************************************************************** __STATIC_INLINE void SHA2IntEnable(uint32_t intFlags) { // Check the arguments. ASSERT((intFlags & SHA2_DMA_IN_DONE) || (intFlags & SHA2_RESULT_RDY)); // Using level interrupt. HWREG(CRYPTO_BASE + CRYPTO_O_IRQTYPE) = CRYPTO_IRQTYPE_LEVEL_M; // Enable the specified interrupts. HWREG(CRYPTO_BASE + CRYPTO_O_IRQEN) |= intFlags; } //***************************************************************************** // //! \brief Disable individual crypto interrupt sources. //! //! This function disables the indicated crypto interrupt sources. Only the //! sources that are enabled can be reflected to the processor interrupt. //! Disabled sources have no effect on the processor. //! //! \param intFlags is the bitwise OR of the interrupt sources to be enabled. //! - \ref SHA2_DMA_IN_DONE //! - \ref SHA2_RESULT_RDY //! //! \return None // //***************************************************************************** __STATIC_INLINE void SHA2IntDisable(uint32_t intFlags) { // Check the arguments. ASSERT((intFlags & SHA2_DMA_IN_DONE) || (intFlags & SHA2_RESULT_RDY)); // Disable the specified interrupts. HWREG(CRYPTO_BASE + CRYPTO_O_IRQEN) &= ~intFlags; } //***************************************************************************** // //! \brief Get the current masked interrupt status. //! //! This function returns the masked interrupt status of the crypto module. //! //! \return Returns the status of the masked lines when enabled: //! - \ref SHA2_DMA_IN_DONE //! - \ref SHA2_RESULT_RDY // //***************************************************************************** __STATIC_INLINE uint32_t SHA2IntStatusMasked(void) { uint32_t mask; // Return the masked interrupt status mask = HWREG(CRYPTO_BASE + CRYPTO_O_IRQEN); return(mask & HWREG(CRYPTO_BASE + CRYPTO_O_IRQSTAT)); } //***************************************************************************** // //! \brief Get the current raw interrupt status. //! //! This function returns the raw interrupt status of the crypto module. //! It returns both the status of the lines routed to the NVIC as well as the //! error flags. //! //! \return Returns the raw interrupt status: //! - \ref SHA2_DMA_IN_DONE //! - \ref SHA2_RESULT_RDY //! - \ref SHA2_DMA_BUS_ERR // //***************************************************************************** __STATIC_INLINE uint32_t SHA2IntStatusRaw(void) { // Return either the raw interrupt status return(HWREG(CRYPTO_BASE + CRYPTO_O_IRQSTAT)); } //***************************************************************************** // //! \brief Clear crypto interrupt sources. //! //! The specified crypto interrupt sources are cleared, so that they no longer //! assert. This function must be called in the interrupt handler to keep the //! interrupt from being recognized again immediately upon exit. //! //! \note Due to write buffers and synchronizers in the system it may take several //! clock cycles from a register write clearing an event in the module until the //! event is actually cleared in the NVIC of the system CPU. It is recommended to //! clear the event source early in the interrupt service routine (ISR) to allow //! the event clear to propagate to the NVIC before returning from the ISR. //! //! \param intFlags is a bit mask of the interrupt sources to be cleared. //! - \ref SHA2_DMA_IN_DONE //! - \ref SHA2_RESULT_RDY //! //! \return None // //***************************************************************************** __STATIC_INLINE void SHA2IntClear(uint32_t intFlags) { // Check the arguments. ASSERT((intFlags & SHA2_DMA_IN_DONE) || (intFlags & SHA2_RESULT_RDY)); // Clear the requested interrupt sources, HWREG(CRYPTO_BASE + CRYPTO_O_IRQCLR) = intFlags; } //***************************************************************************** // //! \brief Register an interrupt handler for a crypto interrupt in the dynamic interrupt table. //! //! \note Only use this function if you want to use the dynamic vector table (in SRAM)! //! //! This function registers a function as the interrupt handler for a specific //! interrupt and enables the corresponding interrupt in the interrupt controller. //! //! Specific crypto interrupts must be enabled via \ref SHA2IntEnable(). It is the //! interrupt handler's responsibility to clear the interrupt source. //! //! \param handlerFxn is a pointer to the function to be called when the //! crypto interrupt occurs. //! //! \return None //! //! \sa \ref IntRegister() for important information about registering interrupt //! handlers. // //***************************************************************************** __STATIC_INLINE void SHA2IntRegister(void (*handlerFxn)(void)) { // Register the interrupt handler. IntRegister(INT_CRYPTO_RESULT_AVAIL_IRQ, handlerFxn); // Enable the crypto interrupt. IntEnable(INT_CRYPTO_RESULT_AVAIL_IRQ); } //***************************************************************************** // //! \brief Unregister an interrupt handler for a crypto interrupt in the dynamic interrupt table. //! //! This function does the actual unregistering of the interrupt handler. It //! clears the handler called when a crypto interrupt occurs. This //! function also masks off the interrupt in the interrupt controller so that //! the interrupt handler no longer is called. //! //! \return None //! //! \sa \ref IntRegister() for important information about registering interrupt //! handlers. // //***************************************************************************** __STATIC_INLINE void SHA2IntUnregister(void) { // Disable the interrupt. IntDisable(INT_CRYPTO_RESULT_AVAIL_IRQ); // Unregister the interrupt handler. IntUnregister(INT_CRYPTO_RESULT_AVAIL_IRQ); } //***************************************************************************** // // Support for DriverLib in ROM: // Redirect to implementation in ROM when available. // //***************************************************************************** #if !defined(DRIVERLIB_NOROM) && !defined(DOXYGEN) #include "../driverlib/rom.h" #ifdef ROM_SHA2StartDMAOperation #undef SHA2StartDMAOperation #define SHA2StartDMAOperation ROM_SHA2StartDMAOperation #endif #ifdef ROM_SHA2WaitForIRQFlags #undef SHA2WaitForIRQFlags #define SHA2WaitForIRQFlags ROM_SHA2WaitForIRQFlags #endif #ifdef ROM_SHA2ComputeInitialHash #undef SHA2ComputeInitialHash #define SHA2ComputeInitialHash ROM_SHA2ComputeInitialHash #endif #ifdef ROM_SHA2ComputeIntermediateHash #undef SHA2ComputeIntermediateHash #define SHA2ComputeIntermediateHash ROM_SHA2ComputeIntermediateHash #endif #ifdef ROM_SHA2ComputeFinalHash #undef SHA2ComputeFinalHash #define SHA2ComputeFinalHash ROM_SHA2ComputeFinalHash #endif #ifdef ROM_SHA2ComputeHash #undef SHA2ComputeHash #define SHA2ComputeHash ROM_SHA2ComputeHash #endif #endif //***************************************************************************** // // Mark the end of the C bindings section for C++ compilers. // //***************************************************************************** #ifdef __cplusplus } #endif #endif // __SHA2_H__ //***************************************************************************** // //! Close the Doxygen group. //! @} //! @} // //*****************************************************************************