}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
static void CompareTAndMacTag (BYTE                     integrityLength,
                               INTEGRITY_CODE XDATA     *t,
                               INTEGRITY_CODE XDATA     *macTag,
                               BOOL XDATA               *result)
{
    BYTE i,
	     XDATA *tempT,
		 XDATA *tempMacTag;

    *result = TRUE;
	tempT = (BYTE *)t;
	tempMacTag = (BYTE *)macTag;

    for ( i = 0; i < integrityLength; i++)
    {
        if (tempMacTag[i] != tempT[i])
            *result = FALSE;
    }
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
static void ConvertOutputModeToNoOfBytes (OUTPUT_MODE outputMode, BYTE XDATA *bytesInOutput)
{
    switch (outputMode)
    {
        case OUTPUT_MODE_RESULT_128:
            *bytesInOutput = RESULT_128;
            break;

        case OUTPUT_MODE_RESULT_64:
            *bytesInOutput = RESULT_64;
            break;

        case OUTPUT_MODE_RESULT_32:
            *bytesInOutput = RESULT_32;
            break;

       case OUTPUT_MODE_RESULT_0:
       default:
            *bytesInOutput = 0;
            break;

    }
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void FetchAesFinished (BOOL XDATA *aesFinished)
{
    *aesFinished = currentAesFinished;
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void FetchAesTransferCount (BYTE XDATA *aesTransferCount)
{
    *aesTransferCount = currentAesTransferCount;
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
static void LoadIv (AES_MODE   aesMode,
                    IV XDATA   *iv,
                    BOOL XDATA *result)
{
    WriteToAes (aesMode,
                AES_COMMAND_LOAD_IV,
                IV_LENGTH,
                (BYTE *)iv,
                result);
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
static void LoadKey (AES_MODE   aesMode,
                     KEY XDATA  *key,
                     BOOL XDATA *result)
{
    WriteToAes (aesMode,
                AES_COMMAND_LOAD_KEY,
                KEY_LENGTH,
                (BYTE *)key,
                result);
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
static void PerformCcmCbcMac (AES_CCM_DATA XDATA *aesCcmData,
                              BYTE XDATA         *mac,
                              BOOL XDATA         *result)
{
    BYTE XDATA           *buffer,
         XDATA           noOfBytes;
    MAC_TX_PACKET XDATA  *macTxBuffer;

    macTxBuffer = mtxpReservePacket();

    if (macTxBuffer->occupied != NO_PACKET)
    {
        *result = TRUE;
        buffer = (BYTE *)macTxBuffer;
        BuildAuthenticationData (&aesCcmData->b0,
                                 aesCcmData->ccmData.authenticationLength,
                                 aesCcmData->ccmData.authenticationData,
                                 &noOfBytes,
                                 buffer);
        DmaMemcpy(&buffer[noOfBytes], aesCcmData->ccmData.message, aesCcmData->ccmData.messageLength);
        noOfBytes = (BYTE)(noOfBytes + aesCcmData->ccmData.messageLength);
        ZeroPadData (&noOfBytes, buffer);
        AesCbcMac (aesCcmData->outputMode,
                   &aesCcmData->key,
                   &iv0,
                   noOfBytes,
                   buffer,
                   mac,
                   result);
        mtxpReleasePacket (macTxBuffer);
    }
    else
        *result = FALSE;

}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void SaveAesFinished (BOOL aesFinished)
{
    currentAesFinished = aesFinished;
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void SaveAesTransferCount (BYTE aesTransferCount)
{
    currentAesTransferCount = aesTransferCount;
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
static void SetupAesRead (BYTE         noOfBytes,
                          BYTE XDATA   *bytes)
{
    WORD                            address;
    DMA_CHANNEL_CONFIGURATION XDATA *dmaChannelConfiguration;

    FetchDmaChannelConfiguration (DMA_FROM_AES_CHANNEL_NO, &dmaChannelConfiguration);

    address = (WORD)bytes;
    dmaChannelConfiguration->destMsb = (BYTE)(address >> 8);
    dmaChannelConfiguration->destLsb = (BYTE)address;
    dmaChannelConfiguration->lenLsb = noOfBytes;

}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
static void SetupAesWrite (BYTE         noOfBytes,
                           BYTE XDATA   *bytes)
{
    WORD                            address;
    DMA_CHANNEL_CONFIGURATION XDATA *dmaChannelConfiguration;

    FetchDmaChannelConfiguration (DMA_TO_AES_CHANNEL_NO, &dmaChannelConfiguration);

    address = (WORD)bytes;
    dmaChannelConfiguration->srcMsb = (BYTE)(address >> 8);
    dmaChannelConfiguration->srcLsb = (BYTE)address;
    dmaChannelConfiguration->lenLsb = noOfBytes;

}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
static void StartAes (AES_MODE  aesMode, AES_COMMAND    aesCommand)
{
    BYTE    aesCsrCommand;

    aesCsrCommand = (BYTE)(aesMode << AES_MODE_POSITION);
    aesCsrCommand |= (aesCommand << AES_COMMAND_POSITION);
    aesCsrCommand |= AES_START_COMMAND;

    ENCCS = aesCsrCommand;
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
static void WriteAndReadAes (AES_MODE        aesMode,
                             AES_COMMAND     aesCommand,
                             BYTE            noOfBytes,
                             BYTE XDATA      *bytesIn,
                             BYTE XDATA      *bytesOut,
                             BOOL XDATA      *result)
{
    BYTE XDATA aesFinished,
               i;

    if (noOfBytes > 0)
    {
        SaveAesTransferCount (noOfBytes);
        SaveAesFinished (FALSE);
        SetupAesWrite (noOfBytes, bytesIn);
        StartDma (DMA_TO_AES_CHANNEL_NO);
        SetupAesRead (noOfBytes, bytesOut);
        StartDma (DMA_FROM_AES_CHANNEL_NO);
        StartAes (aesMode, aesCommand);

        for ( i = 0; i < AES_WAIT_TIME; i++)
        {
            FetchAesFinished (&aesFinished);

            if ( aesFinished == TRUE)
                break;

        }

        if (i == AES_WAIT_TIME)
            *result = FALSE;
        else
            *result = TRUE;


    }

}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
static void WriteToAes (AES_MODE        aesMode,
                        AES_COMMAND     aesCommand,
                        BYTE            noOfBytes,
                        BYTE XDATA      *bytes,
                        BOOL XDATA      *result)
{
    BYTE XDATA aesFinished,
               i;

    if (noOfBytes > 0)
    {
        SaveAesTransferCount (noOfBytes);
        SaveAesFinished (FALSE);
        SetupAesWrite (noOfBytes, bytes);
        StartDma (DMA_TO_AES_CHANNEL_NO);
        StartAes (aesMode, aesCommand);

        for ( i = 0; i < AES_WAIT_TIME; i++)
        {
            FetchAesFinished (&aesFinished);

            if ( aesFinished == TRUE)
                break;

        }

        if (i == AES_WAIT_TIME)
            *result = FALSE;
        else
            *result = TRUE;

    }

}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
static void ZeroPadData (BYTE XDATA *noOfBytes, BYTE XDATA *bytesIn)
{
    BYTE i,
         noOfPaddedData,
         noOfRemaining;

    noOfRemaining = (BYTE)(*noOfBytes & REMAINING_FOUR_BITS);

    if (noOfRemaining > 0)
    {
        noOfPaddedData = (BYTE)(SIXTEEN_BYTES_BLOCK - noOfRemaining);
        for ( i = *noOfBytes; i < (BYTE)(*noOfBytes + noOfPaddedData); i++)
            bytesIn[i] = 0;
        *noOfBytes = (BYTE)(*noOfBytes + noOfPaddedData);
    }
}