aesCcmData->ccmData.message,
                             aesCcmData->ccmData.message,
                             result);

            if (*result)
                AppendUToEncryptedMessage (noOfBytesInU,
                                           (BYTE *)&u,
                                           (BYTE *)&(aesCcmData->ccmData.messageLength),
                                           aesCcmData->ccmData.message);
        }
    }
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
#pragma vector=ENC_VECTOR
__near_func __interrupt void  AesIsr (void)// interrupt MCU_AES_INTERRUPT_VECTOR_NO
{
    BYTE XDATA transferCount,
               aesCommandReg;

    FetchAesTransferCount ((BYTE *)&transferCount);
    transferCount = transferCount - SIXTEEN_BYTES_BLOCK;

    if (transferCount != 0)
    {
        SaveAesTransferCount (transferCount);
        aesCommandReg = ENCCS;
        aesCommandReg |= AES_START_COMMAND;
        ENCCS = aesCommandReg & 0xF7;
    }
    else
    {
        SaveAesFinished (TRUE);
        DMAARM = DMA_TO_AES_STOP;
        DMAARM = DMA_FROM_AES_STOP;
    }

    S0CON = FALSE;
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void EnableAesInterrupt (void)
{
    S0CON = FALSE;
    ENCIE /*EX10*/ = TRUE;
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void DisableAesInterrupt (void)
{
    ENCIE /*EX10*/  = FALSE;
    S0CON = FALSE;
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void MacAesCtr (KEY_MATERIAL XDATA   *keyMaterial,
                ENCRYPTION_TYPE      encryptionType,
                BYTE                 noOfBytes,
                BYTE XDATA           *bytes,
                BOOL XDATA           *result)
{
    IV XDATA iv;

    BuildAesCtrInputBlock (keyMaterial->frameCounter,
                           keyMaterial->keySequenceCounter,
                           &keyMaterial->extendedSourceAddress,
                           (BYTE *)&iv);
    Aes (AES_MODE_CTR,
         encryptionType,
         &keyMaterial->key,
         &iv,
         noOfBytes,
         bytes,
         bytes,
         result);

}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void MacAesCcm (KEY_MATERIAL XDATA  *keyMaterial,
                ENCRYPTION_TYPE     encryptionType,
                OUTPUT_MODE         outputMode,
                U XDATA             *u,
                CCM_DATA XDATA      *ccmData,
                BOOL XDATA          *result)
{
    AES_CCM_DATA XDATA  aesCcmData;

    BuildA0 (keyMaterial->frameCounter,
             keyMaterial->keySequenceCounter,
             &keyMaterial->extendedSourceAddress,
             (A0 *)&(aesCcmData.a0));
    BuildB0 (ccmData->messageLength,
             outputMode,
             keyMaterial->frameCounter,
             keyMaterial->keySequenceCounter,
             &keyMaterial->extendedSourceAddress,
             (B0 *)&(aesCcmData.b0));
    memcpy (&aesCcmData.key,
            &keyMaterial->key,
            KEY_LENGTH);
    aesCcmData.outputMode = outputMode;
    memcpy (&aesCcmData.ccmData,
            ccmData,
            sizeof (ccmData));

    if (encryptionType == ENCRYPTION_TYPE_ENCRYPT)
        AesCcmEncrypt ((AES_CCM_DATA *)&aesCcmData, result);
    else
        AesCcmDecrypt ((AES_CCM_DATA *)&aesCcmData,
                       (U *)&u,
                       result);

}

//-------------------------------------------------------------------------------------------------------
//
// Internal functions
//
//-------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
static void AppendFrameKeyAndSource (DWORD          frameCounter,
                                     BYTE           keySequenceCounter,
                                     ADDRESS XDATA  *extendedSourceAddress,
                                     BYTE XDATA     *bytes)
{   BYTE    i,
            j;

    memcpy (bytes,
            extendedSourceAddress,
            sizeof (ADDRESS));
    j = sizeof (ADDRESS);

    for ( i = 0; i < sizeof (DWORD); i++)
    {
        bytes[j] = (BYTE)frameCounter;
        ++j;
        frameCounter = frameCounter >> 8;
    }

   bytes[j] = keySequenceCounter;
    ++j;

}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
static void AppendUToEncryptedMessage (BYTE         noOfBytes,
                                       BYTE XDATA   *u,
                                       BYTE XDATA   *messageLength,
                                       BYTE XDATA   *message)
{
    BYTE i,
         j;

    j = *messageLength;

    for ( i = 0; i < noOfBytes; i++)
    {
        message[j] = u[i];
        ++j;
    }

    *messageLength = (BYTE)(*messageLength + i);
}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
static void BuildAesCtrInputBlock (DWORD            frameCounter,
                                   BYTE             keySequenceCounter,
                                   ADDRESS XDATA    *extendedSourceAddress,
                                   BYTE XDATA       *iv)
{
    BYTE j;

    j = 0;
    iv[j] = AES_CTR_FLAGS_FIELD;
    ++j;

    AppendFrameKeyAndSource (frameCounter,
                             keySequenceCounter,
                             extendedSourceAddress,
                             (BYTE *)&iv[j]);
    j = (BYTE)(j +
        sizeof (frameCounter) +
        sizeof (keySequenceCounter) +
        sizeof (extendedSourceAddress));
    iv[j] = 0;
    ++j;
    iv[j] = 0;

}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
static void BuildAuthenticationData (B0 XDATA   *b0,
                                     BYTE       authenticationLength,
                                     BYTE XDATA *authenticationData,
                                     BYTE XDATA *additionalLength,
                                     BYTE XDATA *additionalAuthData)
{
    *additionalLength = sizeof(B0);

    DmaMemcpy (additionalAuthData,
               b0,
               *additionalLength);
    additionalAuthData[sizeof(B0)] = 00;
    additionalAuthData[sizeof(B0) + 1] = authenticationLength;
    DmaMemcpy (&additionalAuthData[*additionalLength + NO_OF_BYTES_IN_LA],
               authenticationData,
               authenticationLength);
    *additionalLength = (BYTE)(*additionalLength +
                                authenticationLength +
                                NO_OF_BYTES_IN_LA);
    ZeroPadData (additionalLength, additionalAuthData);

}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
static void BuildA0 (DWORD          frameCounter,
                     BYTE           keySequenceCounter,
                     ADDRESS XDATA  *extendedSourceAddress,
                     A0 XDATA       *a0)
{
    BYTE i,
	     XDATA *a;

    i = 0;
	a = (BYTE *)a0;
    a[i] = A0_L2;
    i++;
    AppendFrameKeyAndSource (frameCounter,
                             keySequenceCounter,
                             extendedSourceAddress,
                             (BYTE *)&a[i]);
    i = (BYTE)(i +
        sizeof (frameCounter) +
        sizeof (keySequenceCounter) +
        sizeof (extendedSourceAddress));

    a[i] = 0;
    a[i+1] = 0;

}

//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
static void BuildB0 (BYTE           messageLength,
                     OUTPUT_MODE    outputMode,
                     DWORD          frameCounter,
                     BYTE           keySequenceCounter,
                     ADDRESS XDATA  *extendedSourceAddress,
                     B0 XDATA       *b0)
{
    BYTE i,
	     XDATA *b;

    i = 0;
    b = (BYTE *)b0;

    switch (outputMode)
    {
        case OUTPUT_MODE_RESULT_128:
           b[i] =  B0_M128_L2;
           break;

        case OUTPUT_MODE_RESULT_64:
           b[i] =  B0_M64_L2;
           break;

        case OUTPUT_MODE_RESULT_32:
           b[i] =  B0_M32_L2;
           break;
    }

    AppendFrameKeyAndSource (frameCounter,
                             keySequenceCounter,
                             extendedSourceAddress,
                             (BYTE *)&b[i]);
    i = (BYTE)(i +
        sizeof (frameCounter) +
        sizeof (keySequenceCounter) +
        sizeof (extendedSourceAddress));

    b[i] = 0;
    b[i + 1] = messageLength;