; generated by Component: ARM Compiler 5.05 update 2 (build 169) Tool: ArmCC [4d0f38]
; commandline ArmCC [--c99 --list --split_sections --debug -c --asm --interleave -o..\..\..\..\build\bootloader\mico-fire_f429\obj_rvmdk\stm32f4xx_cryp_aes.o --asm_dir=..\..\..\..\Build\Bootloader\MICO-Fire_F429\list_RVMDK\ --list_dir=..\..\..\..\Build\Bootloader\MICO-Fire_F429\list_RVMDK\ --depend=..\..\..\..\build\bootloader\mico-fire_f429\obj_rvmdk\stm32f4xx_cryp_aes.d --cpu=Cortex-M4.fp --apcs=interwork --diag_suppress=9931,1,1293 -I..\..\..\..\Bootloader -I..\..\..\..\Board\fire_F429 -I..\..\..\..\include -I..\..\..\..\libraries\utilities -I..\..\..\..\libraries\utilities\json_c -I..\..\..\..\MICO\core -I..\..\..\..\MICO\security -I..\..\..\..\MICO\system -I..\..\..\..\MICO\system\command_console -I..\..\..\..\Platform\include -I..\..\..\..\Platform\Cortex-M4 -I..\..\..\..\Platform\Cortex-M4\CMSIS -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries\STM32F4xx_StdPeriph_Driver\inc -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries -I..\..\..\..\Platform\MCU\STM32F4xx\wlan_bus_driver -I..\..\..\..\Platform\Drivers\spi_flash -I..\..\..\..\Platform\Drivers -IG:\GIT_OSC\F429_OV2640_MICO_SDRAM\Projects\STM32F429\bootloader\RVMDK\RTE -ID:\work\keil5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0\Drivers\CMSIS\Device\ST\STM32F4xx\Include -ID:\work\keil5\ARM\CMSIS\Include -ID:\work\keil5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0 -D__MICROLIB -D__UVISION_VERSION=516 -DSTM32F429xx -DUSE_STDPERIPH_DRIVER -DBOOTLOADER -DNO_MICO_RTOS -DHSE_VALUE=25000000 --omf_browse=..\..\..\..\build\bootloader\mico-fire_f429\obj_rvmdk\stm32f4xx_cryp_aes.crf ..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries\STM32F4xx_StdPeriph_Driver\src\stm32f4xx_cryp_aes.c]
                          THUMB

                          AREA ||i.CRYP_AES_CBC||, CODE, READONLY, ALIGN=1

                  CRYP_AES_CBC PROC
;;;293      */
;;;294    ErrorStatus CRYP_AES_CBC(uint8_t Mode, uint8_t InitVectors[16], uint8_t *Key,
000000  e92d4fff          PUSH     {r0-r11,lr}
;;;295                             uint16_t Keysize, uint8_t *Input, uint32_t Ilength,
;;;296                             uint8_t *Output)
;;;297    {
000004  b091              SUB      sp,sp,#0x44
;;;298      CRYP_InitTypeDef AES_CRYP_InitStructure;
;;;299      CRYP_KeyInitTypeDef AES_CRYP_KeyInitStructure;
;;;300      CRYP_IVInitTypeDef AES_CRYP_IVInitStructure;
;;;301      __IO uint32_t counter = 0;
000006  f04f0800          MOV      r8,#0
00000a  e9dd4a1e          LDRD     r4,r10,[sp,#0x78]     ;297
00000e  9d20              LDR      r5,[sp,#0x80]
000010  469b              MOV      r11,r3                ;297
000012  4616              MOV      r6,r2                 ;297
;;;302      uint32_t busystatus = 0;
;;;303      ErrorStatus status = SUCCESS;
000014  2701              MOVS     r7,#1
;;;304      uint32_t keyaddr    = (uint32_t)Key;
;;;305      uint32_t inputaddr  = (uint32_t)Input;
;;;306      uint32_t outputaddr = (uint32_t)Output;
;;;307      uint32_t ivaddr = (uint32_t)InitVectors;
000016  4689              MOV      r9,r1
;;;308      uint32_t i = 0;
;;;309    
;;;310      /* Crypto structures initialisation*/
;;;311      CRYP_KeyStructInit(&AES_CRYP_KeyInitStructure);
000018  4668              MOV      r0,sp
00001a  f8cd8030          STR      r8,[sp,#0x30]
00001e  f7fffffe          BL       CRYP_KeyStructInit
;;;312    
;;;313      switch(Keysize)
000022  4658              MOV      r0,r11
000024  f1bb0f80          CMP      r11,#0x80
000028  d01d              BEQ      |L1.102|
00002a  0239              LSLS     r1,r7,#8
00002c  28c0              CMP      r0,#0xc0
00002e  d027              BEQ      |L1.128|
000030  458b              CMP      r11,r1
000032  d138              BNE      |L1.166|
;;;314      {
;;;315        case 128:
;;;316        AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_128b;
;;;317        AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
;;;318        keyaddr+=4;
;;;319        AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
;;;320        keyaddr+=4;
;;;321        AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
;;;322        keyaddr+=4;
;;;323        AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
;;;324        break;
;;;325        case 192:
;;;326        AES_CRYP_InitStructure.CRYP_KeySize  = CRYP_KeySize_192b;
;;;327        AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
;;;328        keyaddr+=4;
;;;329        AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
;;;330        keyaddr+=4;
;;;331        AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
;;;332        keyaddr+=4;
;;;333        AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
;;;334        keyaddr+=4;
;;;335        AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
;;;336        keyaddr+=4;
;;;337        AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
;;;338        break;
;;;339        case 256:
;;;340        AES_CRYP_InitStructure.CRYP_KeySize  = CRYP_KeySize_256b;
000034  0048              LSLS     r0,r1,#1
;;;341        AES_CRYP_KeyInitStructure.CRYP_Key0Left = __REV(*(uint32_t*)(keyaddr));
000036  900b              STR      r0,[sp,#0x2c]
000038  6830              LDR      r0,[r6,#0]
00003a  ba00              REV      r0,r0
;;;342        keyaddr+=4;
;;;343        AES_CRYP_KeyInitStructure.CRYP_Key0Right= __REV(*(uint32_t*)(keyaddr));
00003c  9000              STR      r0,[sp,#0]
00003e  6870              LDR      r0,[r6,#4]
000040  ba00              REV      r0,r0
;;;344        keyaddr+=4;
;;;345        AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
000042  9001              STR      r0,[sp,#4]
000044  68b0              LDR      r0,[r6,#8]
000046  ba00              REV      r0,r0
;;;346        keyaddr+=4;
;;;347        AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
000048  9002              STR      r0,[sp,#8]
00004a  68f0              LDR      r0,[r6,#0xc]
00004c  ba00              REV      r0,r0
;;;348        keyaddr+=4;
;;;349        AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
00004e  9003              STR      r0,[sp,#0xc]
000050  6930              LDR      r0,[r6,#0x10]
000052  ba00              REV      r0,r0
;;;350        keyaddr+=4;
;;;351        AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
000054  9004              STR      r0,[sp,#0x10]
000056  6970              LDR      r0,[r6,#0x14]
000058  ba00              REV      r0,r0
;;;352        keyaddr+=4;
;;;353        AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
00005a  9005              STR      r0,[sp,#0x14]
00005c  69b0              LDR      r0,[r6,#0x18]
00005e  ba00              REV      r0,r0
;;;354        keyaddr+=4;
;;;355        AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
000060  9006              STR      r0,[sp,#0x18]
;;;356        break;
000062  69f0              LDR      r0,[r6,#0x1c]
000064  e01d              B        |L1.162|
                  |L1.102|
000066  f8cd802c          STR      r8,[sp,#0x2c]         ;317
00006a  6830              LDR      r0,[r6,#0]            ;317
00006c  ba00              REV      r0,r0                 ;317
00006e  9004              STR      r0,[sp,#0x10]         ;319
000070  6870              LDR      r0,[r6,#4]            ;319
000072  ba00              REV      r0,r0                 ;319
000074  9005              STR      r0,[sp,#0x14]         ;321
000076  68b0              LDR      r0,[r6,#8]            ;321
000078  ba00              REV      r0,r0                 ;321
00007a  9006              STR      r0,[sp,#0x18]         ;323
00007c  68f0              LDR      r0,[r6,#0xc]          ;324
00007e  e010              B        |L1.162|
                  |L1.128|
000080  910b              STR      r1,[sp,#0x2c]         ;327
000082  6830              LDR      r0,[r6,#0]            ;327
000084  ba00              REV      r0,r0                 ;327
000086  9002              STR      r0,[sp,#8]            ;329
000088  6870              LDR      r0,[r6,#4]            ;329
00008a  ba00              REV      r0,r0                 ;329
00008c  9003              STR      r0,[sp,#0xc]          ;331
00008e  68b0              LDR      r0,[r6,#8]            ;331
000090  ba00              REV      r0,r0                 ;331
000092  9004              STR      r0,[sp,#0x10]         ;333
000094  68f0              LDR      r0,[r6,#0xc]          ;333
000096  ba00              REV      r0,r0                 ;333
000098  9005              STR      r0,[sp,#0x14]         ;335
00009a  6930              LDR      r0,[r6,#0x10]         ;335
00009c  ba00              REV      r0,r0                 ;335
00009e  9006              STR      r0,[sp,#0x18]         ;337
0000a0  6970              LDR      r0,[r6,#0x14]         ;337
                  |L1.162|
0000a2  ba00              REV      r0,r0                 ;323
0000a4  9007              STR      r0,[sp,#0x1c]         ;323
                  |L1.166|
;;;357        default:
;;;358        break;
;;;359      }
;;;360    
;;;361      /* CRYP Initialization Vectors */
;;;362      AES_CRYP_IVInitStructure.CRYP_IV0Left = __REV(*(uint32_t*)(ivaddr));
0000a6  f8d90000          LDR      r0,[r9,#0]
0000aa  ba00              REV      r0,r0
;;;363      ivaddr+=4;
;;;364      AES_CRYP_IVInitStructure.CRYP_IV0Right= __REV(*(uint32_t*)(ivaddr));
0000ac  900d              STR      r0,[sp,#0x34]
0000ae  f8d91004          LDR      r1,[r9,#4]
0000b2  ba09              REV      r1,r1
;;;365      ivaddr+=4;
;;;366      AES_CRYP_IVInitStructure.CRYP_IV1Left = __REV(*(uint32_t*)(ivaddr));
0000b4  910e              STR      r1,[sp,#0x38]
0000b6  f8d91008          LDR      r1,[r9,#8]
0000ba  ba09              REV      r1,r1
;;;367      ivaddr+=4;
;;;368      AES_CRYP_IVInitStructure.CRYP_IV1Right= __REV(*(uint32_t*)(ivaddr));
0000bc  910f              STR      r1,[sp,#0x3c]
0000be  f8d9000c          LDR      r0,[r9,#0xc]
;;;369    
;;;370    
;;;371      /*------------------ AES Decryption ------------------*/
;;;372      if(Mode == MODE_DECRYPT) /* AES decryption */
;;;373      {
;;;374        /* Flush IN/OUT FIFOs */
;;;375        CRYP_FIFOFlush();
;;;376    
;;;377        /* Crypto Init for Key preparation for decryption process */
;;;378        AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Decrypt;
;;;379        AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_Key;
;;;380        AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_32b;
;;;381    
;;;382        CRYP_Init(&AES_CRYP_InitStructure);
;;;383    
;;;384        /* Key Initialisation */
;;;385        CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
;;;386    
;;;387        /* Enable Crypto processor */
;;;388        CRYP_Cmd(ENABLE);
;;;389    
;;;390        /* wait until the Busy flag is RESET */
;;;391        do
;;;392        {
;;;393          busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
;;;394          counter++;
;;;395        }while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
0000c2  f44f3980          MOV      r9,#0x10000
0000c6  ba00              REV      r0,r0                 ;368
0000c8  9010              STR      r0,[sp,#0x40]         ;372
0000ca  9811              LDR      r0,[sp,#0x44]         ;372
0000cc  b1c8              CBZ      r0,|L1.258|
;;;396    
;;;397        if (busystatus != RESET)
;;;398       {
;;;399           status = ERROR;
;;;400        }
;;;401        else
;;;402        {
;;;403          /* Crypto Init for decryption process */  
;;;404          AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Decrypt;
;;;405        }
;;;406      }
;;;407      /*------------------ AES Encryption ------------------*/
;;;408      else /* AES encryption */
;;;409      {
;;;410        CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
0000ce  4668              MOV      r0,sp
0000d0  f7fffffe          BL       CRYP_KeyInit
;;;411    
;;;412        /* Crypto Init for Encryption process */
;;;413        AES_CRYP_InitStructure.CRYP_AlgoDir  = CRYP_AlgoDir_Encrypt;
0000d4  f8cd8020          STR      r8,[sp,#0x20]
                  |L1.216|
;;;414      }
;;;415      AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_CBC;
0000d8  2028              MOVS     r0,#0x28
;;;416      AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_8b;
0000da  9009              STR      r0,[sp,#0x24]
0000dc  2080              MOVS     r0,#0x80
;;;417      CRYP_Init(&AES_CRYP_InitStructure);
0000de  900a              STR      r0,[sp,#0x28]
0000e0  a808              ADD      r0,sp,#0x20
0000e2  f7fffffe          BL       CRYP_Init
;;;418    
;;;419      /* CRYP Initialization Vectors */
;;;420      CRYP_IVInit(&AES_CRYP_IVInitStructure);
0000e6  a80d              ADD      r0,sp,#0x34
0000e8  f7fffffe          BL       CRYP_IVInit
;;;421    
;;;422      /* Flush IN/OUT FIFOs */
;;;423      CRYP_FIFOFlush();
0000ec  f7fffffe          BL       CRYP_FIFOFlush
;;;424    
;;;425      /* Enable Crypto processor */
;;;426      CRYP_Cmd(ENABLE);
0000f0  2001              MOVS     r0,#1
0000f2  f7fffffe          BL       CRYP_Cmd
;;;427    
;;;428      if(CRYP_GetCmdStatus() == DISABLE)
0000f6  f7fffffe          BL       CRYP_GetCmdStatus
0000fa  2800              CMP      r0,#0
0000fc  d058              BEQ      |L1.432|
;;;429      {
;;;430        /* The CRYP peripheral clock is not enabled or the device doesn't embedd 
;;;431           the CRYP peripheral (please check the device sales type. */
;;;432        return(ERROR);
;;;433      }
;;;434      
;;;435      for(i=0; ((i<Ilength) && (status != ERROR)); i+=16)
0000fe  2600              MOVS     r6,#0
000100  e04e              B        |L1.416|
                  |L1.258|
000102  f7fffffe          BL       CRYP_FIFOFlush
000106  2604              MOVS     r6,#4                 ;378
000108  2038              MOVS     r0,#0x38              ;379
00010a  e9cd6008          STRD     r6,r0,[sp,#0x20]      ;380
00010e  f8cd8028          STR      r8,[sp,#0x28]         ;380
000112  a808              ADD      r0,sp,#0x20           ;382
000114  f7fffffe          BL       CRYP_Init
000118  4668              MOV      r0,sp                 ;385
00011a  f7fffffe          BL       CRYP_KeyInit
00011e  2001              MOVS     r0,#1                 ;388
000120  f7fffffe          BL       CRYP_Cmd
                  |L1.292|
000124  2010              MOVS     r0,#0x10              ;393
000126  f7fffffe          BL       CRYP_GetFlagStatus
00012a  990c              LDR      r1,[sp,#0x30]         ;394
00012c  1c49              ADDS     r1,r1,#1              ;394
00012e  910c              STR      r1,[sp,#0x30]         ;395
000130  4549              CMP      r1,r9                 ;395
000132  d002              BEQ      |L1.314|
000134  2800              CMP      r0,#0                 ;395
000136  d1f5              BNE      |L1.292|
000138  e002              B        |L1.320|
                  |L1.314|
00013a  b108              CBZ      r0,|L1.320|
00013c  2700              MOVS     r7,#0                 ;399
00013e  e7cb              B        |L1.216|
                  |L1.320|
000140  9608              STR      r6,[sp,#0x20]         ;404
000142  e7c9              B        |L1.216|
                  |L1.324|
;;;436      {
;;;437    
;;;438        /* Write the Input block in the IN FIFO */
;;;439        CRYP_DataIn(*(uint32_t*)(inputaddr));
000144  6820              LDR      r0,[r4,#0]
000146  f7fffffe          BL       CRYP_DataIn
;;;440        inputaddr+=4;
;;;441        CRYP_DataIn(*(uint32_t*)(inputaddr));
00014a  f8540f04          LDR      r0,[r4,#4]!
00014e  f7fffffe          BL       CRYP_DataIn
;;;442        inputaddr+=4;
;;;443        CRYP_DataIn(*(uint32_t*)(inputaddr));
000152  f8540f04          LDR      r0,[r4,#4]!
000156  f7fffffe          BL       CRYP_DataIn
;;;444        inputaddr+=4;
;;;445        CRYP_DataIn(*(uint32_t*)(inputaddr));
00015a  f8540f04          LDR      r0,[r4,#4]!
00015e  f7fffffe          BL       CRYP_DataIn
;;;446        inputaddr+=4;
;;;447        /* Wait until the complete message has been processed */
;;;448        counter = 0;
000162  1d24              ADDS     r4,r4,#4
000164  f8cd8030          STR      r8,[sp,#0x30]
                  |L1.360|
;;;449        do
;;;450        {
;;;451          busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
000168  2010              MOVS     r0,#0x10
00016a  f7fffffe          BL       CRYP_GetFlagStatus
;;;452          counter++;
00016e  990c              LDR      r1,[sp,#0x30]
000170  1c49              ADDS     r1,r1,#1
;;;453        }while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
000172  910c              STR      r1,[sp,#0x30]
000174  4549              CMP      r1,r9
000176  d002              BEQ      |L1.382|
000178  2800              CMP      r0,#0
00017a  d1f5              BNE      |L1.360|
00017c  e002              B        |L1.388|
                  |L1.382|
;;;454    
;;;455        if (busystatus != RESET)
00017e  b108              CBZ      r0,|L1.388|
;;;456       {
;;;457           status = ERROR;
000180  2700              MOVS     r7,#0
000182  e00c              B        |L1.414|
                  |L1.388|
;;;458        }
;;;459        else
;;;460        {
;;;461    
;;;462          /* Read the Output block from the Output FIFO */
;;;463          *(uint32_t*)(outputaddr) = CRYP_DataOut();
000184  f7fffffe          BL       CRYP_DataOut
;;;464          outputaddr+=4;
;;;465          *(uint32_t*)(outputaddr) = CRYP_DataOut();
000188  6028              STR      r0,[r5,#0]
00018a  f7fffffe          BL       CRYP_DataOut
;;;466          outputaddr+=4;
;;;467          *(uint32_t*)(outputaddr) = CRYP_DataOut();
00018e  6068              STR      r0,[r5,#4]
000190  f7fffffe          BL       CRYP_DataOut
;;;468          outputaddr+=4;
;;;469          *(uint32_t*)(outputaddr) = CRYP_DataOut();
000194  60a8              STR      r0,[r5,#8]
000196  f7fffffe          BL       CRYP_DataOut
00019a  60e8              STR      r0,[r5,#0xc]
00019c  3510              ADDS     r5,r5,#0x10
                  |L1.414|
00019e  3610              ADDS     r6,r6,#0x10
                  |L1.416|
0001a0  4556              CMP      r6,r10                ;435
0001a2  d201              BCS      |L1.424|
0001a4  2f00              CMP      r7,#0                 ;435
0001a6  d1cd              BNE      |L1.324|
                  |L1.424|
;;;470          outputaddr+=4;
;;;471        }
;;;472      }
;;;473    
;;;474      /* Disable Crypto */
;;;475      CRYP_Cmd(DISABLE);
0001a8  2000              MOVS     r0,#0
0001aa  f7fffffe          BL       CRYP_Cmd
;;;476    
;;;477      return status;
0001ae  4638              MOV      r0,r7
                  |L1.432|
;;;478    }
0001b0  b015              ADD      sp,sp,#0x54
0001b2  e8bd8ff0          POP      {r4-r11,pc}
;;;479    
                          ENDP


                          AREA ||i.CRYP_AES_CCM||, CODE, READONLY, ALIGN=1

                  CRYP_AES_CCM PROC
;;;1134     */
;;;1135   ErrorStatus CRYP_AES_CCM(uint8_t Mode, 
000000  e92d4fff          PUSH     {r0-r11,lr}
;;;1136                            uint8_t* Nonce, uint32_t NonceSize,
;;;1137                            uint8_t *Key, uint16_t Keysize,
;;;1138                            uint8_t *Input, uint32_t ILength,
;;;1139                            uint8_t *Header, uint32_t HLength, uint8_t *HBuffer,
;;;1140                            uint8_t *Output,
;;;1141                            uint8_t *AuthTAG, uint32_t TAGSize)
;;;1142   {
000004  b09f              SUB      sp,sp,#0x7c
;;;1143     CRYP_InitTypeDef AES_CRYP_InitStructure;
;;;1144     CRYP_KeyInitTypeDef AES_CRYP_KeyInitStructure;
;;;1145     CRYP_IVInitTypeDef AES_CRYP_IVInitStructure;
;;;1146     __IO uint32_t counter = 0;
000006  f04f0b00          MOV      r11,#0
00000a  e9dd0731          LDRD     r0,r7,[sp,#0xc4]      ;1142
00000e  9933              LDR      r1,[sp,#0xcc]
000010  e9dd952e          LDRD     r9,r5,[sp,#0xb8]      ;1142
000014  f8dde0c0          LDR      lr,[sp,#0xc0]
;;;1147     uint32_t busystatus = 0;
;;;1148     ErrorStatus status = SUCCESS;
;;;1149     uint32_t keyaddr    = (uint32_t)Key;
;;;1150     uint32_t inputaddr  = (uint32_t)Input;
;;;1151     uint32_t outputaddr = (uint32_t)Output;
;;;1152     uint32_t headeraddr = (uint32_t)Header;
;;;1153     uint32_t tagaddr = (uint32_t)AuthTAG;
;;;1154     uint32_t headersize = HLength;
000018  911d              STR      r1,[sp,#0x74]
00001a  46dc              MOV      r12,r11               ;1146
00001c  9e2d              LDR      r6,[sp,#0xb4]         ;1146
00001e  f8cdb040          STR      r11,[sp,#0x40]
;;;1155     uint32_t loopcounter = 0;
;;;1156     uint32_t bufferidx = 0;
;;;1157     uint8_t blockb0[16] = {0};/* Block B0 */
;;;1158     uint8_t ctr[16] = {0}; /* Counter */
000022  f8cdb00c          STR      r11,[sp,#0xc]
000026  f8cdb010          STR      r11,[sp,#0x10]
00002a  469a              MOV      r10,r3                ;1149
00002c  f8cdb000          STR      r11,[sp,#0]           ;1157
000030  f8cdb004          STR      r11,[sp,#4]           ;1157
000034  f8cdb008          STR      r11,[sp,#8]           ;1157
;;;1159     uint32_t temptag[4] = {0}; /* temporary TAG (MAC) */
000038  e9cdbc12          STRD     r11,r12,[sp,#0x48]
00003c  f8cdb014          STR      r11,[sp,#0x14]        ;1158
000040  f8cdb018          STR      r11,[sp,#0x18]        ;1158
000044  f8cdb01c          STR      r11,[sp,#0x1c]
;;;1160     uint32_t ctraddr = (uint32_t)ctr;
000048  ab04              ADD      r3,sp,#0x10
00004a  f04f0801          MOV      r8,#1                 ;1148
00004e  ea5f040e          MOVS     r4,lr                 ;1154
000052  4659              MOV      r1,r11                ;1155
000054  f8cdb044          STR      r11,[sp,#0x44]        ;1159
000058  f8cdc050          STR      r12,[sp,#0x50]        ;1142
00005c  9310              STR      r3,[sp,#0x40]         ;1142
00005e  d037              BEQ      |L2.208|
;;;1161     uint32_t b0addr = (uint32_t)blockb0;
;;;1162     
;;;1163     /************************ Formatting the header block ***********************/
;;;1164     if(headersize != 0)
;;;1165     {
;;;1166       /* Check that the associated data (or header) length is lower than 2^16 - 2^8 = 65536 - 256 = 65280 */
;;;1167       if(headersize < 65280)
;;;1168       {
;;;1169         HBuffer[bufferidx++] = (uint8_t) ((headersize >> 8) & 0xFF);
;;;1170         HBuffer[bufferidx++] = (uint8_t) ((headersize) & 0xFF);
000060  f00e03ff          AND      r3,lr,#0xff
000064  f5b44f7f          CMP      r4,#0xff00            ;1167
000068  d207              BCS      |L2.122|
00006a  ea4f2c14          LSR      r12,r4,#8             ;1169
00006e  f880c000          STRB     r12,[r0,#0]           ;1169
000072  7043              STRB     r3,[r0,#1]
000074  2302              MOVS     r3,#2
000076  1ca4              ADDS     r4,r4,#2
;;;1171         headersize += 2;
000078  e017              B        |L2.170|
                  |L2.122|
;;;1172       }
;;;1173       else
;;;1174       {
;;;1175         /* header is encoded as 0xff || 0xfe || [headersize]32, i.e., six octets */
;;;1176         HBuffer[bufferidx++] = 0xFF;
00007a  f04f0cff          MOV      r12,#0xff
00007e  f880c000          STRB     r12,[r0,#0]
;;;1177         HBuffer[bufferidx++] = 0xFE;
000082  f04f0cfe          MOV      r12,#0xfe
000086  f880c001          STRB     r12,[r0,#1]
;;;1178         HBuffer[bufferidx++] = headersize & 0xff000000;
00008a  f880b002          STRB     r11,[r0,#2]
;;;1179         HBuffer[bufferidx++] = headersize & 0x00ff0000;
00008e  f880b003          STRB     r11,[r0,#3]
;;;1180         HBuffer[bufferidx++] = headersize & 0x0000ff00;
000092  f880b004          STRB     r11,[r0,#4]
;;;1181         HBuffer[bufferidx++] = headersize & 0x000000ff;
000096  7143              STRB     r3,[r0,#5]
000098  2306              MOVS     r3,#6
00009a  1da4              ADDS     r4,r4,#6
;;;1182         headersize += 6;
00009c  e005              B        |L2.170|
                  |L2.158|
;;;1183       }
;;;1184       /* Copy the header buffer in internal buffer "HBuffer" */
;;;1185       for(loopcounter = 0; loopcounter < headersize; loopcounter++)
;;;1186       {
;;;1187         HBuffer[bufferidx++] = Header[loopcounter];
00009e  f815c001          LDRB     r12,[r5,r1]
0000a2  f800c003          STRB     r12,[r0,r3]
0000a6  1c49              ADDS     r1,r1,#1
0000a8  1c5b              ADDS     r3,r3,#1
                  |L2.170|
0000aa  42a1              CMP      r1,r4                 ;1185
0000ac  d3f7              BCC      |L2.158|
;;;1188       }
;;;1189       /* Check if the header size is modulo 16 */
;;;1190       if ((headersize % 16) != 0)
0000ae  0721              LSLS     r1,r4,#28
0000b0  d009              BEQ      |L2.198|
;;;1191       {
;;;1192         /* Padd the header buffer with 0s till the HBuffer length is modulo 16 */
;;;1193         for(loopcounter = headersize; loopcounter <= ((headersize/16) + 1) * 16; loopcounter++)
0000b2  0921              LSRS     r1,r4,#4
0000b4  0109              LSLS     r1,r1,#4
0000b6  465b              MOV      r3,r11
0000b8  3110              ADDS     r1,r1,#0x10
0000ba  e001              B        |L2.192|
                  |L2.188|
;;;1194         {
;;;1195           HBuffer[loopcounter] = 0;
0000bc  5503              STRB     r3,[r0,r4]
0000be  1c64              ADDS     r4,r4,#1
                  |L2.192|
0000c0  42a1              CMP      r1,r4                 ;1193
0000c2  d2fb              BCS      |L2.188|
;;;1196         }
;;;1197         /* Set the header size to modulo 16 */
;;;1198         headersize = ((headersize/16) + 1) * 16;
0000c4  460c              MOV      r4,r1
                  |L2.198|
;;;1199       }
;;;1200       /* set the pointer headeraddr to HBuffer */
;;;1201       headeraddr = (uint32_t)HBuffer;
0000c6  4605              MOV      r5,r0
0000c8  b114              CBZ      r4,|L2.208|
;;;1202     }
;;;1203     /************************* Formatting the block B0 **************************/
;;;1204     if(headersize != 0)
;;;1205     {
;;;1206       blockb0[0] = 0x40;
0000ca  2040              MOVS     r0,#0x40
0000cc  f88d0000          STRB     r0,[sp,#0]
                  |L2.208|
;;;1207     }
;;;1208     /* Flags byte */
;;;1209     blockb0[0] |= 0u | (((( (uint8_t) TAGSize - 2) / 2) & 0x07 ) << 3 ) | ( ( (uint8_t) (15 - NonceSize) - 1) & 0x07);
0000d0  9834              LDR      r0,[sp,#0xd0]
0000d2  466b              MOV      r3,sp                 ;1157
0000d4  b2c0              UXTB     r0,r0
0000d6  1e80              SUBS     r0,r0,#2
0000d8  eb0070d0          ADD      r0,r0,r0,LSR #31
0000dc  f3c00142          UBFX     r1,r0,#1,#3
0000e0  f1c2000e          RSB      r0,r2,#0xe
0000e4  f36100df          BFI      r0,r1,#3,#29
0000e8  f89d1000          LDRB     r1,[sp,#0]
0000ec  4308              ORRS     r0,r0,r1
0000ee  f88d0000          STRB     r0,[sp,#0]
;;;1210     
;;;1211     for (loopcounter = 0; loopcounter < NonceSize; loopcounter++)
0000f2  2000              MOVS     r0,#0
0000f4  e006              B        |L2.260|
                  |L2.246|
;;;1212     {
;;;1213       blockb0[loopcounter+1] = Nonce[loopcounter];
0000f6  9920              LDR      r1,[sp,#0x80]
0000f8  eb030c00          ADD      r12,r3,r0
0000fc  5c09              LDRB     r1,[r1,r0]
0000fe  f88c1001          STRB     r1,[r12,#1]
000102  1c40              ADDS     r0,r0,#1
                  |L2.260|
000104  4290              CMP      r0,r2                 ;1211
000106  d3f6              BCC      |L2.246|
000108  e004              B        |L2.276|
                  |L2.266|
;;;1214     }
;;;1215     for ( ; loopcounter < 13; loopcounter++)
;;;1216     {
;;;1217       blockb0[loopcounter+1] = 0;
00010a  eb030c00          ADD      r12,r3,r0
00010e  1c40              ADDS     r0,r0,#1
000110  f88cb001          STRB     r11,[r12,#1]
                  |L2.276|
000114  280d              CMP      r0,#0xd               ;1215
000116  d3f8              BCC      |L2.266|
;;;1218     }
;;;1219     
;;;1220     blockb0[14] = ((ILength >> 8) & 0xFF);
000118  ea4f2019          LSR      r0,r9,#8
00011c  f88d000e          STRB     r0,[sp,#0xe]
;;;1221     blockb0[15] = (ILength & 0xFF);
;;;1222     
;;;1223     /************************* Formatting the initial counter *******************/
;;;1224     /* Byte 0:
;;;1225        Bits 7 and 6 are reserved and shall be set to 0
;;;1226        Bits 3, 4, and 5 shall also be set to 0, to ensure that all the counter blocks
;;;1227        are distinct from B0
;;;1228        Bits 0, 1, and 2 contain the same encoding of q as in B0
;;;1229     */
;;;1230     ctr[0] = blockb0[0] & 0x07;
000120  f89d0000          LDRB     r0,[sp,#0]
000124  f88d900f          STRB     r9,[sp,#0xf]          ;1221
000128  f0000007          AND      r0,r0,#7
00012c  f88d0010          STRB     r0,[sp,#0x10]
;;;1231     /* byte 1 to NonceSize is the IV (Nonce) */
;;;1232     for(loopcounter = 1; loopcounter < NonceSize + 1; loopcounter++)
000130  2001              MOVS     r0,#1
000132  a904              ADD      r1,sp,#0x10           ;1158
000134  1c52              ADDS     r2,r2,#1              ;1158
000136  e004              B        |L2.322|
                  |L2.312|
;;;1233     {
;;;1234       ctr[loopcounter] = blockb0[loopcounter];
000138  f813c000          LDRB     r12,[r3,r0]
00013c  f801c000          STRB     r12,[r1,r0]
000140  1c40              ADDS     r0,r0,#1
                  |L2.322|
000142  4290              CMP      r0,r2                 ;1232
000144  d3f8              BCC      |L2.312|
;;;1235     }
;;;1236     /* Set the LSB to 1 */
;;;1237     ctr[15] |= 0x01;
000146  f89d001f          LDRB     r0,[sp,#0x1f]
00014a  f0400001          ORR      r0,r0,#1
00014e  f88d001f          STRB     r0,[sp,#0x1f]
;;;1238     
;;;1239     /* Crypto structures initialisation*/
;;;1240     CRYP_KeyStructInit(&AES_CRYP_KeyInitStructure);
000152  a808              ADD      r0,sp,#0x20
000154  f7fffffe          BL       CRYP_KeyStructInit
;;;1241     
;;;1242     switch(Keysize)
000158  982c              LDR      r0,[sp,#0xb0]
00015a  2880              CMP      r0,#0x80
00015c  d027              BEQ      |L2.430|
00015e  f44f7180          MOV      r1,#0x100
000162  28c0              CMP      r0,#0xc0
000164  d034              BEQ      |L2.464|
000166  4288              CMP      r0,r1
000168  d14b              BNE      |L2.514|
;;;1243     {
;;;1244       case 128:
;;;1245       AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_128b;
;;;1246       AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
;;;1247       keyaddr+=4;
;;;1248       AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
;;;1249       keyaddr+=4;
;;;1250       AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
;;;1251       keyaddr+=4;
;;;1252       AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
;;;1253       break;
;;;1254       case 192:
;;;1255       AES_CRYP_InitStructure.CRYP_KeySize  = CRYP_KeySize_192b;
;;;1256       AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
;;;1257       keyaddr+=4;
;;;1258       AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
;;;1259       keyaddr+=4;
;;;1260       AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
;;;1261       keyaddr+=4;
;;;1262       AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
;;;1263       keyaddr+=4;
;;;1264       AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
;;;1265       keyaddr+=4;
;;;1266       AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
;;;1267       break;
;;;1268       case 256:
;;;1269       AES_CRYP_InitStructure.CRYP_KeySize  = CRYP_KeySize_256b;
00016a  0040              LSLS     r0,r0,#1
;;;1270       AES_CRYP_KeyInitStructure.CRYP_Key0Left = __REV(*(uint32_t*)(keyaddr));
00016c  9018              STR      r0,[sp,#0x60]
00016e  f8da0000          LDR      r0,[r10,#0]
000172  ba00              REV      r0,r0
;;;1271       keyaddr+=4;
000174  9008              STR      r0,[sp,#0x20]
;;;1272       AES_CRYP_KeyInitStructure.CRYP_Key0Right= __REV(*(uint32_t*)(keyaddr));
000176  f8da1004          LDR      r1,[r10,#4]
00017a  f10a0004          ADD      r0,r10,#4             ;1271
00017e  ba09              REV      r1,r1
;;;1273       keyaddr+=4;
;;;1274       AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
000180  9109              STR      r1,[sp,#0x24]
000182  f8da1008          LDR      r1,[r10,#8]
000186  ba09              REV      r1,r1
;;;1275       keyaddr+=4;
;;;1276       AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
000188  910a              STR      r1,[sp,#0x28]
00018a  f8da100c          LDR      r1,[r10,#0xc]
00018e  ba09              REV      r1,r1
;;;1277       keyaddr+=4;
;;;1278       AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
000190  910b              STR      r1,[sp,#0x2c]
000192  f8da1010          LDR      r1,[r10,#0x10]
000196  ba09              REV      r1,r1
;;;1279       keyaddr+=4;
;;;1280       AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
000198  910c              STR      r1,[sp,#0x30]
00019a  f8da1014          LDR      r1,[r10,#0x14]
00019e  ba09              REV      r1,r1
;;;1281       keyaddr+=4;
;;;1282       AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
0001a0  910d              STR      r1,[sp,#0x34]
0001a2  f8da1018          LDR      r1,[r10,#0x18]
0001a6  ba09              REV      r1,r1
;;;1283       keyaddr+=4;
;;;1284       AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
0001a8  910e              STR      r1,[sp,#0x38]
0001aa  6980              LDR      r0,[r0,#0x18]
;;;1285       break;
0001ac  e027              B        |L2.510|
                  |L2.430|
0001ae  f8cdb060          STR      r11,[sp,#0x60]        ;1246
0001b2  f8da0000          LDR      r0,[r10,#0]           ;1246
0001b6  ba00              REV      r0,r0                 ;1246
0001b8  900c              STR      r0,[sp,#0x30]         ;1248
0001ba  f8da1004          LDR      r1,[r10,#4]           ;1248
0001be  ba09              REV      r1,r1                 ;1248
0001c0  910d              STR      r1,[sp,#0x34]         ;1250
0001c2  f8da1008          LDR      r1,[r10,#8]           ;1250
0001c6  ba09              REV      r1,r1                 ;1250
0001c8  910e              STR      r1,[sp,#0x38]         ;1252
0001ca  f8da000c          LDR      r0,[r10,#0xc]         ;1253
0001ce  e016              B        |L2.510|
                  |L2.464|
0001d0  9118              STR      r1,[sp,#0x60]         ;1256
0001d2  f8da0000          LDR      r0,[r10,#0]           ;1256
0001d6  ba00              REV      r0,r0                 ;1256
0001d8  900a              STR      r0,[sp,#0x28]         ;1258
0001da  f8da1004          LDR      r1,[r10,#4]           ;1258
0001de  ba09              REV      r1,r1                 ;1258
0001e0  910b              STR      r1,[sp,#0x2c]         ;1260
0001e2  f8da1008          LDR      r1,[r10,#8]           ;1260
0001e6  ba09              REV      r1,r1                 ;1260
0001e8  910c              STR      r1,[sp,#0x30]         ;1262
0001ea  f8da100c          LDR      r1,[r10,#0xc]         ;1262
0001ee  ba09              REV      r1,r1                 ;1262
0001f0  910d              STR      r1,[sp,#0x34]         ;1264
0001f2  f8da1010          LDR      r1,[r10,#0x10]        ;1264
0001f6  ba09              REV      r1,r1                 ;1264
0001f8  910e              STR      r1,[sp,#0x38]         ;1266
0001fa  f8da0014          LDR      r0,[r10,#0x14]        ;1266
                  |L2.510|
0001fe  ba00              REV      r0,r0                 ;1252
000200  900f              STR      r0,[sp,#0x3c]         ;1252
                  |L2.514|
;;;1286       default:
;;;1287       break;
;;;1288     }
;;;1289     
;;;1290     /* CRYP Initialization Vectors */
;;;1291     AES_CRYP_IVInitStructure.CRYP_IV0Left = (__REV(*(uint32_t*)(ctraddr)));
000202  9810              LDR      r0,[sp,#0x40]
;;;1292     ctraddr+=4;
;;;1293     AES_CRYP_IVInitStructure.CRYP_IV0Right= (__REV(*(uint32_t*)(ctraddr)));
;;;1294     ctraddr+=4;
;;;1295     AES_CRYP_IVInitStructure.CRYP_IV1Left = (__REV(*(uint32_t*)(ctraddr)));
;;;1296     ctraddr+=4;
;;;1297     AES_CRYP_IVInitStructure.CRYP_IV1Right= (__REV(*(uint32_t*)(ctraddr)));
;;;1298     
;;;1299     /*------------------ AES Encryption ------------------*/
;;;1300     if(Mode == MODE_ENCRYPT) /* AES encryption */
;;;1301     {
;;;1302       /* Flush IN/OUT FIFOs */
;;;1303       CRYP_FIFOFlush();
;;;1304       
;;;1305       /* Key Initialisation */
;;;1306       CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
;;;1307       
;;;1308       /* CRYP Initialization Vectors */
;;;1309       CRYP_IVInit(&AES_CRYP_IVInitStructure);
;;;1310       
;;;1311       /* Crypto Init for Key preparation for decryption process */
;;;1312       AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Encrypt;
;;;1313       AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_CCM;
000204  f04f1a08          MOV      r10,#0x80008
000208  6800              LDR      r0,[r0,#0]            ;1291
00020a  ba00              REV      r0,r0                 ;1291
00020c  9019              STR      r0,[sp,#0x64]         ;1292
00020e  9810              LDR      r0,[sp,#0x40]         ;1293
000210  6841              LDR      r1,[r0,#4]            ;1293
000212  ba09              REV      r1,r1                 ;1293
000214  911a              STR      r1,[sp,#0x68]         ;1295
000216  6881              LDR      r1,[r0,#8]            ;1295
000218  ba09              REV      r1,r1                 ;1295
00021a  911b              STR      r1,[sp,#0x6c]         ;1297
00021c  68c0              LDR      r0,[r0,#0xc]          ;1297
00021e  ba00              REV      r0,r0                 ;1297
000220  901c              STR      r0,[sp,#0x70]         ;1300
000222  981f              LDR      r0,[sp,#0x7c]         ;1300
000224  2801              CMP      r0,#1                 ;1300
000226  d035              BEQ      |L2.660|
;;;1314       AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_8b;
;;;1315       CRYP_Init(&AES_CRYP_InitStructure);
;;;1316       
;;;1317       /***************************** Init phase *********************************/
;;;1318       /* Select init phase */
;;;1319       CRYP_PhaseConfig(CRYP_Phase_Init);
;;;1320       
;;;1321       b0addr = (uint32_t)blockb0;
;;;1322       /* Write the blockb0 block in the IN FIFO */
;;;1323       CRYP_DataIn((*(uint32_t*)(b0addr)));
;;;1324       b0addr+=4;
;;;1325       CRYP_DataIn((*(uint32_t*)(b0addr)));
;;;1326       b0addr+=4;
;;;1327       CRYP_DataIn((*(uint32_t*)(b0addr)));
;;;1328       b0addr+=4;
;;;1329       CRYP_DataIn((*(uint32_t*)(b0addr)));
;;;1330       
;;;1331       /* Enable Crypto processor */
;;;1332       CRYP_Cmd(ENABLE);
;;;1333       
;;;1334       /* Wait for CRYPEN bit to be 0 */
;;;1335       while(CRYP_GetCmdStatus() == ENABLE)
;;;1336       {
;;;1337       }
;;;1338       /***************************** header phase *******************************/
;;;1339       if(headersize != 0)
;;;1340       {
;;;1341         /* Select header phase */
;;;1342         CRYP_PhaseConfig(CRYP_Phase_Header);
;;;1343         
;;;1344         /* Enable Crypto processor */
;;;1345         CRYP_Cmd(ENABLE);
;;;1346         
;;;1347         if(CRYP_GetCmdStatus() == DISABLE)
;;;1348         {
;;;1349            /* The CRYP peripheral clock is not enabled or the device doesn't embedd 
;;;1350               the CRYP peripheral (please check the device sales type. */
;;;1351            return(ERROR);
;;;1352         }
;;;1353         
;;;1354         for(loopcounter = 0; (loopcounter < headersize); loopcounter+=16)
;;;1355         {
;;;1356           /* Wait until the IFEM flag is reset */
;;;1357           while(CRYP_GetFlagStatus(CRYP_FLAG_IFEM) == RESET)
;;;1358           {
;;;1359           }
;;;1360           
;;;1361           /* Write the Input block in the IN FIFO */
;;;1362           CRYP_DataIn(*(uint32_t*)(headeraddr));
;;;1363           headeraddr+=4;
;;;1364           CRYP_DataIn(*(uint32_t*)(headeraddr));
;;;1365           headeraddr+=4;
;;;1366           CRYP_DataIn(*(uint32_t*)(headeraddr));
;;;1367           headeraddr+=4;
;;;1368           CRYP_DataIn(*(uint32_t*)(headeraddr));
;;;1369           headeraddr+=4;
;;;1370         }
;;;1371         
;;;1372         /* Wait until the complete message has been processed */
;;;1373         counter = 0;
;;;1374         do
;;;1375         {
;;;1376           busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
;;;1377           counter++;
;;;1378         }while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
;;;1379   
;;;1380         if (busystatus != RESET)
;;;1381         {
;;;1382           status = ERROR;
;;;1383         }
;;;1384       }
;;;1385       
;;;1386       /**************************** payload phase *******************************/
;;;1387       if(ILength != 0)
;;;1388       {
;;;1389         /* Select payload phase */
;;;1390         CRYP_PhaseConfig(CRYP_Phase_Payload);
;;;1391         
;;;1392         /* Enable Crypto processor */
;;;1393         CRYP_Cmd(ENABLE);
;;;1394         
;;;1395         if(CRYP_GetCmdStatus() == DISABLE)
;;;1396         {
;;;1397           /* The CRYP peripheral clock is not enabled or the device doesn't embedd 
;;;1398              the CRYP peripheral (please check the device sales type. */
;;;1399           return(ERROR);
;;;1400         }
;;;1401         
;;;1402         for(loopcounter = 0; ((loopcounter < ILength) && (status != ERROR)); loopcounter+=16)
;;;1403         {
;;;1404           /* Wait until the IFEM flag is reset */
;;;1405           while(CRYP_GetFlagStatus(CRYP_FLAG_IFEM) == RESET)
;;;1406           {
;;;1407           }
;;;1408           
;;;1409           /* Write the Input block in the IN FIFO */
;;;1410           CRYP_DataIn(*(uint32_t*)(inputaddr));
;;;1411           inputaddr+=4;
;;;1412           CRYP_DataIn(*(uint32_t*)(inputaddr));
;;;1413           inputaddr+=4;
;;;1414           CRYP_DataIn(*(uint32_t*)(inputaddr));
;;;1415           inputaddr+=4;
;;;1416           CRYP_DataIn(*(uint32_t*)(inputaddr));
;;;1417           inputaddr+=4;
;;;1418           
;;;1419           /* Wait until the complete message has been processed */
;;;1420           counter = 0;
;;;1421           do
;;;1422           {
;;;1423             busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
;;;1424             counter++;
;;;1425           }while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
;;;1426   
;;;1427           if (busystatus != RESET)
;;;1428           {
;;;1429             status = ERROR;
;;;1430           }
;;;1431           else
;;;1432           {
;;;1433             /* Wait until the OFNE flag is reset */
;;;1434             while(CRYP_GetFlagStatus(CRYP_FLAG_OFNE) == RESET)
;;;1435             {
;;;1436             }
;;;1437             
;;;1438             /* Read the Output block from the Output FIFO */
;;;1439             *(uint32_t*)(outputaddr) = CRYP_DataOut();
;;;1440             outputaddr+=4;
;;;1441             *(uint32_t*)(outputaddr) = CRYP_DataOut();
;;;1442             outputaddr+=4;
;;;1443             *(uint32_t*)(outputaddr) = CRYP_DataOut();
;;;1444             outputaddr+=4;
;;;1445             *(uint32_t*)(outputaddr) = CRYP_DataOut();
;;;1446             outputaddr+=4;
;;;1447           }
;;;1448         }
;;;1449       }
;;;1450       
;;;1451       /***************************** final phase ********************************/
;;;1452       /* Select final phase */
;;;1453       CRYP_PhaseConfig(CRYP_Phase_Final);
;;;1454       
;;;1455       /* Enable Crypto processor */
;;;1456       CRYP_Cmd(ENABLE);
;;;1457       
;;;1458       if(CRYP_GetCmdStatus() == DISABLE)
;;;1459       {
;;;1460         /* The CRYP peripheral clock is not enabled or the device doesn't embedd 
;;;1461            the CRYP peripheral (please check the device sales type. */
;;;1462         return(ERROR);
;;;1463       }
;;;1464       
;;;1465       ctraddr = (uint32_t)ctr;
;;;1466       /* Write the counter block in the IN FIFO */
;;;1467       CRYP_DataIn(*(uint32_t*)(ctraddr));
;;;1468       ctraddr+=4;
;;;1469       CRYP_DataIn(*(uint32_t*)(ctraddr));
;;;1470       ctraddr+=4;
;;;1471       CRYP_DataIn(*(uint32_t*)(ctraddr));
;;;1472       ctraddr+=4;
;;;1473       /* Reset bit 0 (after 8-bit swap) is equivalent to reset bit 24 (before 8-bit swap) */
;;;1474       CRYP_DataIn(*(uint32_t*)(ctraddr) & 0xfeffffff);
;;;1475       
;;;1476       /* Wait until the OFNE flag is reset */
;;;1477       while(CRYP_GetFlagStatus(CRYP_FLAG_OFNE) == RESET)
;;;1478       {
;;;1479       }
;;;1480       
;;;1481       /* Read the Auth TAG in the IN FIFO */
;;;1482       temptag[0] = CRYP_DataOut();
;;;1483       temptag[1] = CRYP_DataOut();
;;;1484       temptag[2] = CRYP_DataOut();
;;;1485       temptag[3] = CRYP_DataOut();
;;;1486     }
;;;1487     /*------------------ AES Decryption ------------------*/
;;;1488     else /* AES decryption */
;;;1489     {
;;;1490       /* Flush IN/OUT FIFOs */
;;;1491       CRYP_FIFOFlush();
000228  f7fffffe          BL       CRYP_FIFOFlush
;;;1492       
;;;1493       /* Key Initialisation */
;;;1494       CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
00022c  a808              ADD      r0,sp,#0x20
00022e  f7fffffe          BL       CRYP_KeyInit
;;;1495       
;;;1496       /* CRYP Initialization Vectors */
;;;1497       CRYP_IVInit(&AES_CRYP_IVInitStructure);
000232  a819              ADD      r0,sp,#0x64
000234  f7fffffe          BL       CRYP_IVInit
;;;1498       
;;;1499       /* Crypto Init for Key preparation for decryption process */
;;;1500       AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Decrypt;
000238  2004              MOVS     r0,#4
00023a  e9cd0a15          STRD     r0,r10,[sp,#0x54]
;;;1501       AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_CCM;
;;;1502       AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_8b;
00023e  2080              MOVS     r0,#0x80
;;;1503       CRYP_Init(&AES_CRYP_InitStructure);
000240  9017              STR      r0,[sp,#0x5c]
000242  a815              ADD      r0,sp,#0x54
000244  f7fffffe          BL       CRYP_Init
;;;1504       
;;;1505       /***************************** Init phase *********************************/
;;;1506       /* Select init phase */
;;;1507       CRYP_PhaseConfig(CRYP_Phase_Init);
000248  2000              MOVS     r0,#0
00024a  f7fffffe          BL       CRYP_PhaseConfig
;;;1508       
;;;1509       b0addr = (uint32_t)blockb0;
;;;1510       /* Write the blockb0 block in the IN FIFO */
;;;1511       CRYP_DataIn((*(uint32_t*)(b0addr)));
00024e  9800              LDR      r0,[sp,#0]
000250  f7fffffe          BL       CRYP_DataIn
;;;1512       b0addr+=4;
;;;1513       CRYP_DataIn((*(uint32_t*)(b0addr)));
000254  9801              LDR      r0,[sp,#4]
000256  f7fffffe          BL       CRYP_DataIn
;;;1514       b0addr+=4;
;;;1515       CRYP_DataIn((*(uint32_t*)(b0addr)));
00025a  9802              LDR      r0,[sp,#8]
00025c  f7fffffe          BL       CRYP_DataIn
;;;1516       b0addr+=4;
;;;1517       CRYP_DataIn((*(uint32_t*)(b0addr)));
000260  9803              LDR      r0,[sp,#0xc]
000262  f7fffffe          BL       CRYP_DataIn
;;;1518       
;;;1519       /* Enable Crypto processor */
;;;1520       CRYP_Cmd(ENABLE);
000266  2001              MOVS     r0,#1
000268  f7fffffe          BL       CRYP_Cmd
                  |L2.620|
;;;1521       
;;;1522       /* Wait for CRYPEN bit to be 0 */
;;;1523       while(CRYP_GetCmdStatus() == ENABLE)
00026c  f7fffffe          BL       CRYP_GetCmdStatus
000270  2801              CMP      r0,#1
000272  d0fb              BEQ      |L2.620|
;;;1524       {
;;;1525       }
;;;1526       
;;;1527       /***************************** header phase *******************************/
;;;1528       if(headersize != 0)
000274  2c00              CMP      r4,#0
000276  d07d              BEQ      |L2.884|
;;;1529       {
;;;1530         /* Select header phase */
;;;1531         CRYP_PhaseConfig(CRYP_Phase_Header);
000278  f44f3080          MOV      r0,#0x10000
00027c  f7fffffe          BL       CRYP_PhaseConfig
;;;1532         
;;;1533         /* Enable Crypto processor */
;;;1534         CRYP_Cmd(ENABLE);
000280  2001              MOVS     r0,#1
000282  f7fffffe          BL       CRYP_Cmd
;;;1535         
;;;1536         if(CRYP_GetCmdStatus() == DISABLE)
000286  f7fffffe          BL       CRYP_GetCmdStatus
00028a  2800              CMP      r0,#0
00028c  d073              BEQ      |L2.886|
;;;1537         {
;;;1538           /* The CRYP peripheral clock is not enabled or the device doesn't embedd 
;;;1539              the CRYP peripheral (please check the device sales type. */
;;;1540           return(ERROR);
;;;1541         }
;;;1542         
;;;1543         for(loopcounter = 0; (loopcounter < headersize); loopcounter+=16)
00028e  f04f0a00          MOV      r10,#0
000292  e0e7              B        |L2.1124|
                  |L2.660|
000294  f7fffffe          BL       CRYP_FIFOFlush
000298  a808              ADD      r0,sp,#0x20           ;1306
00029a  f7fffffe          BL       CRYP_KeyInit
00029e  a819              ADD      r0,sp,#0x64           ;1309
0002a0  f7fffffe          BL       CRYP_IVInit
0002a4  2080              MOVS     r0,#0x80              ;1314
0002a6  e9cda016          STRD     r10,r0,[sp,#0x58]     ;1314
0002aa  f8cdb054          STR      r11,[sp,#0x54]        ;1314
0002ae  a815              ADD      r0,sp,#0x54           ;1315
0002b0  f7fffffe          BL       CRYP_Init
0002b4  2000              MOVS     r0,#0                 ;1319
0002b6  f7fffffe          BL       CRYP_PhaseConfig
0002ba  9800              LDR      r0,[sp,#0]            ;1323
0002bc  f7fffffe          BL       CRYP_DataIn
0002c0  9801              LDR      r0,[sp,#4]            ;1325
0002c2  f7fffffe          BL       CRYP_DataIn
0002c6  9802              LDR      r0,[sp,#8]            ;1327
0002c8  f7fffffe          BL       CRYP_DataIn
0002cc  9803              LDR      r0,[sp,#0xc]          ;1329
0002ce  f7fffffe          BL       CRYP_DataIn
0002d2  2001              MOVS     r0,#1                 ;1332
0002d4  f7fffffe          BL       CRYP_Cmd
                  |L2.728|
0002d8  f7fffffe          BL       CRYP_GetCmdStatus
0002dc  2801              CMP      r0,#1                 ;1335
0002de  d0fb              BEQ      |L2.728|
0002e0  b3a4              CBZ      r4,|L2.844|
0002e2  f44f3080          MOV      r0,#0x10000           ;1342
0002e6  f7fffffe          BL       CRYP_PhaseConfig
0002ea  2001              MOVS     r0,#1                 ;1345
0002ec  f7fffffe          BL       CRYP_Cmd
0002f0  f7fffffe          BL       CRYP_GetCmdStatus
0002f4  2800              CMP      r0,#0                 ;1347
0002f6  d03e              BEQ      |L2.886|
0002f8  f04f0a00          MOV      r10,#0                ;1354
0002fc  e016              B        |L2.812|
                  |L2.766|
0002fe  2001              MOVS     r0,#1                 ;1357
000300  f7fffffe          BL       CRYP_GetFlagStatus
000304  2800              CMP      r0,#0                 ;1357
000306  d0fa              BEQ      |L2.766|
000308  6828              LDR      r0,[r5,#0]            ;1362
00030a  f7fffffe          BL       CRYP_DataIn
00030e  f8550f04          LDR      r0,[r5,#4]!           ;1364
000312  f7fffffe          BL       CRYP_DataIn
000316  f8550f04          LDR      r0,[r5,#4]!           ;1366
00031a  f7fffffe          BL       CRYP_DataIn
00031e  f8550f04          LDR      r0,[r5,#4]!           ;1368
000322  f7fffffe          BL       CRYP_DataIn
000326  f10a0a10          ADD      r10,r10,#0x10         ;1354
00032a  1d2d              ADDS     r5,r5,#4              ;1354
                  |L2.812|
00032c  45a2              CMP      r10,r4                ;1354
00032e  d3e6              BCC      |L2.766|
000330  f44f3480          MOV      r4,#0x10000           ;1342
000334  f8cdb040          STR      r11,[sp,#0x40]        ;1342
                  |L2.824|
000338  2010              MOVS     r0,#0x10              ;1376
00033a  f7fffffe          BL       CRYP_GetFlagStatus
00033e  9910              LDR      r1,[sp,#0x40]         ;1377
000340  1c49              ADDS     r1,r1,#1              ;1377
000342  9110              STR      r1,[sp,#0x40]         ;1378
000344  42a1              CMP      r1,r4                 ;1378
000346  d002              BEQ      |L2.846|
000348  2800              CMP      r0,#0                 ;1378
00034a  d1f5              BNE      |L2.824|
                  |L2.844|
00034c  e002              B        |L2.852|
                  |L2.846|
00034e  b108              CBZ      r0,|L2.852|
000350  f04f0800          MOV      r8,#0                 ;1382
                  |L2.852|
000354  f1b90f00          CMP      r9,#0                 ;1387
000358  d04e              BEQ      |L2.1016|
00035a  f44f3000          MOV      r0,#0x20000           ;1390
00035e  f7fffffe          BL       CRYP_PhaseConfig
000362  2001              MOVS     r0,#1                 ;1393
000364  f7fffffe          BL       CRYP_Cmd
000368  f7fffffe          BL       CRYP_GetCmdStatus
00036c  2800              CMP      r0,#0                 ;1395
00036e  d002              BEQ      |L2.886|
000370  2400              MOVS     r4,#0                 ;1402
000372  e03c              B        |L2.1006|
                  |L2.884|
000374  e08a              B        |L2.1164|
                  |L2.886|
000376  e0bd              B        |L2.1268|
                  |L2.888|
000378  2001              MOVS     r0,#1                 ;1405
00037a  f7fffffe          BL       CRYP_GetFlagStatus
00037e  2800              CMP      r0,#0                 ;1405
000380  d0fa              BEQ      |L2.888|
000382  6830              LDR      r0,[r6,#0]            ;1410
000384  f7fffffe          BL       CRYP_DataIn
000388  f8560f04          LDR      r0,[r6,#4]!           ;1412
00038c  f7fffffe          BL       CRYP_DataIn
000390  f8560f04          LDR      r0,[r6,#4]!           ;1414
000394  f7fffffe          BL       CRYP_DataIn
000398  f8560f04          LDR      r0,[r6,#4]!           ;1416
00039c  f7fffffe          BL       CRYP_DataIn
0003a0  f44f3580          MOV      r5,#0x10000           ;1342
0003a4  1d36              ADDS     r6,r6,#4              ;1342
0003a6  f8cdb040          STR      r11,[sp,#0x40]        ;1342
                  |L2.938|
0003aa  2010              MOVS     r0,#0x10              ;1423
0003ac  f7fffffe          BL       CRYP_GetFlagStatus
0003b0  9910              LDR      r1,[sp,#0x40]         ;1424
0003b2  1c49              ADDS     r1,r1,#1              ;1424
0003b4  9110              STR      r1,[sp,#0x40]         ;1425
0003b6  42a9              CMP      r1,r5                 ;1425
0003b8  d002              BEQ      |L2.960|
0003ba  2800              CMP      r0,#0                 ;1425
0003bc  d1f5              BNE      |L2.938|
0003be  e003              B        |L2.968|
                  |L2.960|
0003c0  b110              CBZ      r0,|L2.968|
0003c2  f04f0800          MOV      r8,#0                 ;1429
0003c6  e011              B        |L2.1004|
                  |L2.968|
0003c8  2004              MOVS     r0,#4                 ;1434
0003ca  f7fffffe          BL       CRYP_GetFlagStatus
0003ce  2800              CMP      r0,#0                 ;1434
0003d0  d0fa              BEQ      |L2.968|
0003d2  f7fffffe          BL       CRYP_DataOut
0003d6  6038              STR      r0,[r7,#0]            ;1441
0003d8  f7fffffe          BL       CRYP_DataOut
0003dc  6078              STR      r0,[r7,#4]            ;1443
0003de  f7fffffe          BL       CRYP_DataOut
0003e2  60b8              STR      r0,[r7,#8]            ;1445
0003e4  f7fffffe          BL       CRYP_DataOut
0003e8  60f8              STR      r0,[r7,#0xc]          ;1445
0003ea  3710              ADDS     r7,r7,#0x10           ;1445
                  |L2.1004|
0003ec  3410              ADDS     r4,r4,#0x10           ;1445
                  |L2.1006|
0003ee  454c              CMP      r4,r9                 ;1402
0003f0  d202              BCS      |L2.1016|
0003f2  f1b80f00          CMP      r8,#0                 ;1402
0003f6  d1bf              BNE      |L2.888|
                  |L2.1016|
0003f8  f44f3040          MOV      r0,#0x30000           ;1453
0003fc  f7fffffe          BL       CRYP_PhaseConfig
000400  2001              MOVS     r0,#1                 ;1456
000402  f7fffffe          BL       CRYP_Cmd
000406  f7fffffe          BL       CRYP_GetCmdStatus
00040a  2800              CMP      r0,#0                 ;1458
00040c  d072              BEQ      |L2.1268|
00040e  9804              LDR      r0,[sp,#0x10]         ;1467
000410  f7fffffe          BL       CRYP_DataIn
000414  9805              LDR      r0,[sp,#0x14]         ;1469
000416  f7fffffe          BL       CRYP_DataIn
00041a  9806              LDR      r0,[sp,#0x18]         ;1471
00041c  f7fffffe          BL       CRYP_DataIn
000420  9807              LDR      r0,[sp,#0x1c]         ;1474
000422  f0207080          BIC      r0,r0,#0x1000000      ;1474
000426  f7fffffe          BL       CRYP_DataIn
                  |L2.1066|
00042a  2004              MOVS     r0,#4                 ;1477
00042c  f7fffffe          BL       CRYP_GetFlagStatus
000430  2800              CMP      r0,#0                 ;1477
000432  d0fa              BEQ      |L2.1066|
000434  e099              B        |L2.1386|
                  |L2.1078|
;;;1544         {
;;;1545           /* Wait until the IFEM flag is reset */
;;;1546           while(CRYP_GetFlagStatus(CRYP_FLAG_IFEM) == RESET)
000436  2001              MOVS     r0,#1
000438  f7fffffe          BL       CRYP_GetFlagStatus
00043c  2800              CMP      r0,#0
00043e  d0fa              BEQ      |L2.1078|
;;;1547           {
;;;1548           }
;;;1549           
;;;1550           /* Write the Input block in the IN FIFO */
;;;1551           CRYP_DataIn(*(uint32_t*)(headeraddr));
000440  6828              LDR      r0,[r5,#0]
000442  f7fffffe          BL       CRYP_DataIn
;;;1552           headeraddr+=4;
;;;1553           CRYP_DataIn(*(uint32_t*)(headeraddr));
000446  f8550f04          LDR      r0,[r5,#4]!
00044a  f7fffffe          BL       CRYP_DataIn
;;;1554           headeraddr+=4;
;;;1555           CRYP_DataIn(*(uint32_t*)(headeraddr));
00044e  f8550f04          LDR      r0,[r5,#4]!
000452  f7fffffe          BL       CRYP_DataIn
;;;1556           headeraddr+=4;
;;;1557           CRYP_DataIn(*(uint32_t*)(headeraddr));
000456  f8550f04          LDR      r0,[r5,#4]!
00045a  f7fffffe          BL       CRYP_DataIn
00045e  f10a0a10          ADD      r10,r10,#0x10         ;1543
000462  1d2d              ADDS     r5,r5,#4              ;1543
                  |L2.1124|
000464  45a2              CMP      r10,r4                ;1543
000466  d3e6              BCC      |L2.1078|
000468  f44f3480          MOV      r4,#0x10000           ;1342
00046c  f8cdb040          STR      r11,[sp,#0x40]        ;1342
                  |L2.1136|
;;;1558           headeraddr+=4;
;;;1559         }
;;;1560         
;;;1561         /* Wait until the complete message has been processed */
;;;1562         counter = 0;
;;;1563         do
;;;1564         {
;;;1565           busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
000470  2010              MOVS     r0,#0x10
000472  f7fffffe          BL       CRYP_GetFlagStatus
;;;1566           counter++;
000476  9910              LDR      r1,[sp,#0x40]
000478  1c49              ADDS     r1,r1,#1
;;;1567         }while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
00047a  9110              STR      r1,[sp,#0x40]
00047c  42a1              CMP      r1,r4
00047e  d002              BEQ      |L2.1158|
000480  2800              CMP      r0,#0
000482  d1f5              BNE      |L2.1136|
000484  e002              B        |L2.1164|
                  |L2.1158|
;;;1568   
;;;1569         if (busystatus != RESET)
000486  b108              CBZ      r0,|L2.1164|
;;;1570         {
;;;1571           status = ERROR;
000488  f04f0800          MOV      r8,#0
                  |L2.1164|
;;;1572         }
;;;1573       }
;;;1574       
;;;1575       /**************************** payload phase *******************************/
;;;1576       if(ILength != 0)
00048c  f1b90f00          CMP      r9,#0
000490  d04d              BEQ      |L2.1326|
;;;1577       {
;;;1578         /* Select payload phase */
;;;1579         CRYP_PhaseConfig(CRYP_Phase_Payload);
000492  f44f3000          MOV      r0,#0x20000
000496  f7fffffe          BL       CRYP_PhaseConfig
;;;1580   
;;;1581         /* Enable Crypto processor */
;;;1582         CRYP_Cmd(ENABLE);
00049a  2001              MOVS     r0,#1
00049c  f7fffffe          BL       CRYP_Cmd
;;;1583         
;;;1584         if(CRYP_GetCmdStatus() == DISABLE)
0004a0  f7fffffe          BL       CRYP_GetCmdStatus
0004a4  2800              CMP      r0,#0
0004a6  d07a              BEQ      |L2.1438|
;;;1585         {
;;;1586           /* The CRYP peripheral clock is not enabled or the device doesn't embedd 
;;;1587              the CRYP peripheral (please check the device sales type. */
;;;1588           return(ERROR);
;;;1589         }
;;;1590         
;;;1591         for(loopcounter = 0; ((loopcounter < ILength) && (status != ERROR)); loopcounter+=16)
0004a8  2400              MOVS     r4,#0
0004aa  e03b              B        |L2.1316|
                  |L2.1196|
;;;1592         {
;;;1593           /* Wait until the IFEM flag is reset */
;;;1594           while(CRYP_GetFlagStatus(CRYP_FLAG_IFEM) == RESET)
0004ac  2001              MOVS     r0,#1
0004ae  f7fffffe          BL       CRYP_GetFlagStatus
0004b2  2800              CMP      r0,#0
0004b4  d0fa              BEQ      |L2.1196|
;;;1595           {
;;;1596           }
;;;1597           
;;;1598           /* Write the Input block in the IN FIFO */
;;;1599           CRYP_DataIn(*(uint32_t*)(inputaddr));
0004b6  6830              LDR      r0,[r6,#0]
0004b8  f7fffffe          BL       CRYP_DataIn
;;;1600           inputaddr+=4;
;;;1601           CRYP_DataIn(*(uint32_t*)(inputaddr));
0004bc  f8560f04          LDR      r0,[r6,#4]!
0004c0  f7fffffe          BL       CRYP_DataIn
;;;1602           inputaddr+=4;
;;;1603           CRYP_DataIn(*(uint32_t*)(inputaddr));
0004c4  f8560f04          LDR      r0,[r6,#4]!
0004c8  f7fffffe          BL       CRYP_DataIn
;;;1604           inputaddr+=4;
;;;1605           CRYP_DataIn(*(uint32_t*)(inputaddr));
0004cc  f8560f04          LDR      r0,[r6,#4]!
0004d0  f7fffffe          BL       CRYP_DataIn
0004d4  f44f3580          MOV      r5,#0x10000           ;1342
0004d8  1d36              ADDS     r6,r6,#4              ;1342
0004da  f8cdb040          STR      r11,[sp,#0x40]        ;1342
                  |L2.1246|
;;;1606           inputaddr+=4;
;;;1607           
;;;1608           /* Wait until the complete message has been processed */
;;;1609           counter = 0;
;;;1610           do
;;;1611           {
;;;1612             busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
0004de  2010              MOVS     r0,#0x10
0004e0  f7fffffe          BL       CRYP_GetFlagStatus
;;;1613             counter++;
0004e4  9910              LDR      r1,[sp,#0x40]
0004e6  1c49              ADDS     r1,r1,#1
;;;1614           }while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
0004e8  9110              STR      r1,[sp,#0x40]
0004ea  42a9              CMP      r1,r5
0004ec  d003              BEQ      |L2.1270|
0004ee  2800              CMP      r0,#0
0004f0  d1f5              BNE      |L2.1246|
0004f2  e004              B        |L2.1278|
                  |L2.1268|
0004f4  e053              B        |L2.1438|
                  |L2.1270|
;;;1615   
;;;1616           if (busystatus != RESET)
0004f6  b110              CBZ      r0,|L2.1278|
;;;1617           {
;;;1618             status = ERROR;
0004f8  f04f0800          MOV      r8,#0
0004fc  e011              B        |L2.1314|
                  |L2.1278|
;;;1619           }
;;;1620           else
;;;1621           {
;;;1622             /* Wait until the OFNE flag is reset */
;;;1623             while(CRYP_GetFlagStatus(CRYP_FLAG_OFNE) == RESET)
0004fe  2004              MOVS     r0,#4
000500  f7fffffe          BL       CRYP_GetFlagStatus
000504  2800              CMP      r0,#0
000506  d0fa              BEQ      |L2.1278|
;;;1624             {
;;;1625             }
;;;1626             
;;;1627             /* Read the Output block from the Output FIFO */
;;;1628             *(uint32_t*)(outputaddr) = CRYP_DataOut();
000508  f7fffffe          BL       CRYP_DataOut
;;;1629             outputaddr+=4;
;;;1630             *(uint32_t*)(outputaddr) = CRYP_DataOut();
00050c  6038              STR      r0,[r7,#0]
00050e  f7fffffe          BL       CRYP_DataOut
;;;1631             outputaddr+=4;
;;;1632             *(uint32_t*)(outputaddr) = CRYP_DataOut();
000512  6078              STR      r0,[r7,#4]
000514  f7fffffe          BL       CRYP_DataOut
;;;1633             outputaddr+=4;
;;;1634             *(uint32_t*)(outputaddr) = CRYP_DataOut();
000518  60b8              STR      r0,[r7,#8]
00051a  f7fffffe          BL       CRYP_DataOut
00051e  60f8              STR      r0,[r7,#0xc]
000520  3710              ADDS     r7,r7,#0x10
                  |L2.1314|
000522  3410              ADDS     r4,r4,#0x10
                  |L2.1316|
000524  454c              CMP      r4,r9                 ;1591
000526  d202              BCS      |L2.1326|
000528  f1b80f00          CMP      r8,#0                 ;1591
00052c  d1be              BNE      |L2.1196|
                  |L2.1326|
;;;1635             outputaddr+=4;
;;;1636           }
;;;1637         }
;;;1638       }
;;;1639       
;;;1640       /***************************** final phase ********************************/
;;;1641       /* Select final phase */
;;;1642       CRYP_PhaseConfig(CRYP_Phase_Final);
00052e  f44f3040          MOV      r0,#0x30000
000532  f7fffffe          BL       CRYP_PhaseConfig
;;;1643       
;;;1644       /* Enable Crypto processor */
;;;1645       CRYP_Cmd(ENABLE);
000536  2001              MOVS     r0,#1
000538  f7fffffe          BL       CRYP_Cmd
;;;1646       
;;;1647       if(CRYP_GetCmdStatus() == DISABLE)
00053c  f7fffffe          BL       CRYP_GetCmdStatus
000540  2800              CMP      r0,#0
000542  d02c              BEQ      |L2.1438|
;;;1648       {
;;;1649         /* The CRYP peripheral clock is not enabled or the device doesn't embedd 
;;;1650            the CRYP peripheral (please check the device sales type. */
;;;1651         return(ERROR);
;;;1652       }
;;;1653       
;;;1654       ctraddr = (uint32_t)ctr;
;;;1655       /* Write the counter block in the IN FIFO */
;;;1656       CRYP_DataIn(*(uint32_t*)(ctraddr));
000544  9804              LDR      r0,[sp,#0x10]
000546  f7fffffe          BL       CRYP_DataIn
;;;1657       ctraddr+=4;
;;;1658       CRYP_DataIn(*(uint32_t*)(ctraddr));
00054a  9805              LDR      r0,[sp,#0x14]
00054c  f7fffffe          BL       CRYP_DataIn
;;;1659       ctraddr+=4;
;;;1660       CRYP_DataIn(*(uint32_t*)(ctraddr));
000550  9806              LDR      r0,[sp,#0x18]
000552  f7fffffe          BL       CRYP_DataIn
;;;1661       ctraddr+=4;
;;;1662       /* Reset bit 0 (after 8-bit swap) is equivalent to reset bit 24 (before 8-bit swap) */
;;;1663       CRYP_DataIn(*(uint32_t*)(ctraddr) & 0xfeffffff);
000556  9807              LDR      r0,[sp,#0x1c]
000558  f0207080          BIC      r0,r0,#0x1000000
00055c  f7fffffe          BL       CRYP_DataIn
                  |L2.1376|
;;;1664       
;;;1665       /* Wait until the OFNE flag is reset */
;;;1666       while(CRYP_GetFlagStatus(CRYP_FLAG_OFNE) == RESET)
000560  2004              MOVS     r0,#4
000562  f7fffffe          BL       CRYP_GetFlagStatus
000566  2800              CMP      r0,#0
000568  d0fa              BEQ      |L2.1376|
                  |L2.1386|
;;;1667       {
;;;1668       }
;;;1669       
;;;1670       /* Read the Authentaication TAG (MAC) in the IN FIFO */
;;;1671       temptag[0] = CRYP_DataOut();
00056a  f7fffffe          BL       CRYP_DataOut
;;;1672       temptag[1] = CRYP_DataOut();
00056e  9011              STR      r0,[sp,#0x44]
000570  f7fffffe          BL       CRYP_DataOut
;;;1673       temptag[2] = CRYP_DataOut();
000574  9012              STR      r0,[sp,#0x48]
000576  f7fffffe          BL       CRYP_DataOut
;;;1674       temptag[3] = CRYP_DataOut();
00057a  9013              STR      r0,[sp,#0x4c]
00057c  f7fffffe          BL       CRYP_DataOut
;;;1675     }
;;;1676     
;;;1677     /* Copy temporary authentication TAG in user TAG buffer */
;;;1678     for(loopcounter = 0; (loopcounter < TAGSize); loopcounter++)
000580  9014              STR      r0,[sp,#0x50]
000582  2000              MOVS     r0,#0
000584  a911              ADD      r1,sp,#0x44           ;1159
000586  e003              B        |L2.1424|
                  |L2.1416|
;;;1679     {
;;;1680       /* Set the authentication TAG buffer */
;;;1681       *((uint8_t*)tagaddr+loopcounter) = *((uint8_t*)temptag+loopcounter);
000588  9a1d              LDR      r2,[sp,#0x74]
00058a  5c0b              LDRB     r3,[r1,r0]
00058c  5413              STRB     r3,[r2,r0]
00058e  1c40              ADDS     r0,r0,#1
                  |L2.1424|
000590  9a34              LDR      r2,[sp,#0xd0]         ;1678
000592  4290              CMP      r0,r2                 ;1678
000594  d3f8              BCC      |L2.1416|
;;;1682     }
;;;1683     
;;;1684     /* Disable Crypto */
;;;1685     CRYP_Cmd(DISABLE);
000596  2000              MOVS     r0,#0
000598  f7fffffe          BL       CRYP_Cmd
;;;1686   
;;;1687     return status;
00059c  4640              MOV      r0,r8
                  |L2.1438|
;;;1688   }
00059e  b023              ADD      sp,sp,#0x8c
0005a0  e8bd8ff0          POP      {r4-r11,pc}
;;;1689   
                          ENDP


                          AREA ||i.CRYP_AES_CTR||, CODE, READONLY, ALIGN=1

                  CRYP_AES_CTR PROC
;;;495      */
;;;496    ErrorStatus CRYP_AES_CTR(uint8_t Mode, uint8_t InitVectors[16], uint8_t *Key, 
000000  e92d4fff          PUSH     {r0-r11,lr}
;;;497                             uint16_t Keysize, uint8_t *Input, uint32_t Ilength,
;;;498                             uint8_t *Output)
;;;499    {
000004  b091              SUB      sp,sp,#0x44
;;;500      CRYP_InitTypeDef AES_CRYP_InitStructure;
;;;501      CRYP_KeyInitTypeDef AES_CRYP_KeyInitStructure;
;;;502      CRYP_IVInitTypeDef AES_CRYP_IVInitStructure;
;;;503      __IO uint32_t counter = 0;
000006  f04f0900          MOV      r9,#0
00000a  e9dd4b1e          LDRD     r4,r11,[sp,#0x78]     ;499
00000e  4617              MOV      r7,r2                 ;499
000010  9d20              LDR      r5,[sp,#0x80]
;;;504      uint32_t busystatus = 0;
;;;505      ErrorStatus status = SUCCESS;
000012  f04f0801          MOV      r8,#1
;;;506      uint32_t keyaddr    = (uint32_t)Key;
;;;507      uint32_t inputaddr  = (uint32_t)Input;
;;;508      uint32_t outputaddr = (uint32_t)Output;
;;;509      uint32_t ivaddr     = (uint32_t)InitVectors;
000016  468a              MOV      r10,r1
;;;510      uint32_t i = 0;
000018  464e              MOV      r6,r9
;;;511    
;;;512      /* Crypto structures initialisation*/
;;;513      CRYP_KeyStructInit(&AES_CRYP_KeyInitStructure);
00001a  4668              MOV      r0,sp
00001c  f8cd9040          STR      r9,[sp,#0x40]
000020  f7fffffe          BL       CRYP_KeyStructInit
;;;514    
;;;515      switch(Keysize)
000024  9814              LDR      r0,[sp,#0x50]
000026  2880              CMP      r0,#0x80
000028  d01e              BEQ      |L3.104|
00002a  f44f7180          MOV      r1,#0x100
00002e  28c0              CMP      r0,#0xc0
000030  d027              BEQ      |L3.130|
000032  4288              CMP      r0,r1
000034  d138              BNE      |L3.168|
;;;516      {
;;;517        case 128:
;;;518        AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_128b;
;;;519        AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
;;;520        keyaddr+=4;
;;;521        AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
;;;522        keyaddr+=4;
;;;523        AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
;;;524        keyaddr+=4;
;;;525        AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
;;;526        break;
;;;527        case 192:
;;;528        AES_CRYP_InitStructure.CRYP_KeySize  = CRYP_KeySize_192b;
;;;529        AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
;;;530        keyaddr+=4;
;;;531        AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
;;;532        keyaddr+=4;
;;;533        AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
;;;534        keyaddr+=4;
;;;535        AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
;;;536        keyaddr+=4;
;;;537        AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
;;;538        keyaddr+=4;
;;;539        AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
;;;540        break;
;;;541        case 256:
;;;542        AES_CRYP_InitStructure.CRYP_KeySize  = CRYP_KeySize_256b;
000036  0040              LSLS     r0,r0,#1
;;;543        AES_CRYP_KeyInitStructure.CRYP_Key0Left = __REV(*(uint32_t*)(keyaddr));
000038  900b              STR      r0,[sp,#0x2c]
00003a  6838              LDR      r0,[r7,#0]
00003c  ba00              REV      r0,r0
;;;544        keyaddr+=4;
;;;545        AES_CRYP_KeyInitStructure.CRYP_Key0Right= __REV(*(uint32_t*)(keyaddr));
00003e  9000              STR      r0,[sp,#0]
000040  6878              LDR      r0,[r7,#4]
000042  ba00              REV      r0,r0
;;;546        keyaddr+=4;
;;;547        AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
000044  9001              STR      r0,[sp,#4]
000046  68b8              LDR      r0,[r7,#8]
000048  ba00              REV      r0,r0
;;;548        keyaddr+=4;
;;;549        AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
00004a  9002              STR      r0,[sp,#8]
00004c  68f8              LDR      r0,[r7,#0xc]
00004e  ba00              REV      r0,r0
;;;550        keyaddr+=4;
;;;551        AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
000050  9003              STR      r0,[sp,#0xc]
000052  6938              LDR      r0,[r7,#0x10]
000054  ba00              REV      r0,r0
;;;552        keyaddr+=4;
;;;553        AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
000056  9004              STR      r0,[sp,#0x10]
000058  6978              LDR      r0,[r7,#0x14]
00005a  ba00              REV      r0,r0
;;;554        keyaddr+=4;
;;;555        AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
00005c  9005              STR      r0,[sp,#0x14]
00005e  69b8              LDR      r0,[r7,#0x18]
000060  ba00              REV      r0,r0
;;;556        keyaddr+=4;
;;;557        AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
000062  9006              STR      r0,[sp,#0x18]
;;;558        break;
000064  69f8              LDR      r0,[r7,#0x1c]
000066  e01d              B        |L3.164|
                  |L3.104|
000068  f8cd902c          STR      r9,[sp,#0x2c]         ;519
00006c  6838              LDR      r0,[r7,#0]            ;519
00006e  ba00              REV      r0,r0                 ;519
000070  9004              STR      r0,[sp,#0x10]         ;521
000072  6878              LDR      r0,[r7,#4]            ;521
000074  ba00              REV      r0,r0                 ;521
000076  9005              STR      r0,[sp,#0x14]         ;523
000078  68b8              LDR      r0,[r7,#8]            ;523
00007a  ba00              REV      r0,r0                 ;523
00007c  9006              STR      r0,[sp,#0x18]         ;525
00007e  68f8              LDR      r0,[r7,#0xc]          ;526
000080  e010              B        |L3.164|
                  |L3.130|
000082  910b              STR      r1,[sp,#0x2c]         ;529
000084  6838              LDR      r0,[r7,#0]            ;529
000086  ba00              REV      r0,r0                 ;529
000088  9002              STR      r0,[sp,#8]            ;531
00008a  6878              LDR      r0,[r7,#4]            ;531
00008c  ba00              REV      r0,r0                 ;531
00008e  9003              STR      r0,[sp,#0xc]          ;533
000090  68b8              LDR      r0,[r7,#8]            ;533
000092  ba00              REV      r0,r0                 ;533
000094  9004              STR      r0,[sp,#0x10]         ;535
000096  68f8              LDR      r0,[r7,#0xc]          ;535
000098  ba00              REV      r0,r0                 ;535
00009a  9005              STR      r0,[sp,#0x14]         ;537
00009c  6938              LDR      r0,[r7,#0x10]         ;537
00009e  ba00              REV      r0,r0                 ;537
0000a0  9006              STR      r0,[sp,#0x18]         ;539
0000a2  6978              LDR      r0,[r7,#0x14]         ;539
                  |L3.164|
0000a4  ba00              REV      r0,r0                 ;525
0000a6  9007              STR      r0,[sp,#0x1c]         ;525
                  |L3.168|
;;;559        default:
;;;560        break;
;;;561      }
;;;562      /* CRYP Initialization Vectors */
;;;563      AES_CRYP_IVInitStructure.CRYP_IV0Left = __REV(*(uint32_t*)(ivaddr));
0000a8  f8da0000          LDR      r0,[r10,#0]
0000ac  ba00              REV      r0,r0
;;;564      ivaddr+=4;
;;;565      AES_CRYP_IVInitStructure.CRYP_IV0Right= __REV(*(uint32_t*)(ivaddr));
0000ae  900c              STR      r0,[sp,#0x30]
0000b0  f8da1004          LDR      r1,[r10,#4]
0000b4  ba09              REV      r1,r1
;;;566      ivaddr+=4;
;;;567      AES_CRYP_IVInitStructure.CRYP_IV1Left = __REV(*(uint32_t*)(ivaddr));
0000b6  910d              STR      r1,[sp,#0x34]
0000b8  f8da1008          LDR      r1,[r10,#8]
0000bc  ba09              REV      r1,r1
;;;568      ivaddr+=4;
;;;569      AES_CRYP_IVInitStructure.CRYP_IV1Right= __REV(*(uint32_t*)(ivaddr));
0000be  910e              STR      r1,[sp,#0x38]
0000c0  f8da000c          LDR      r0,[r10,#0xc]
0000c4  ba00              REV      r0,r0
;;;570    
;;;571      /* Key Initialisation */
;;;572      CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
0000c6  900f              STR      r0,[sp,#0x3c]
0000c8  4668              MOV      r0,sp
0000ca  f7fffffe          BL       CRYP_KeyInit
;;;573    
;;;574      /*------------------ AES Decryption ------------------*/
;;;575      if(Mode == MODE_DECRYPT) /* AES decryption */
0000ce  9811              LDR      r0,[sp,#0x44]
0000d0  b1a8              CBZ      r0,|L3.254|
;;;576      {
;;;577        /* Crypto Init for decryption process */
;;;578        AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Decrypt;
;;;579      }
;;;580      /*------------------ AES Encryption ------------------*/
;;;581      else /* AES encryption */
;;;582      {
;;;583        /* Crypto Init for Encryption process */
;;;584        AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Encrypt;
0000d2  f8cd9020          STR      r9,[sp,#0x20]
                  |L3.214|
;;;585      }
;;;586      AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_CTR;
0000d6  2030              MOVS     r0,#0x30
;;;587      AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_8b;
0000d8  9009              STR      r0,[sp,#0x24]
0000da  2080              MOVS     r0,#0x80
;;;588      CRYP_Init(&AES_CRYP_InitStructure);
0000dc  900a              STR      r0,[sp,#0x28]
0000de  a808              ADD      r0,sp,#0x20
0000e0  f7fffffe          BL       CRYP_Init
;;;589    
;;;590      /* CRYP Initialization Vectors */
;;;591      CRYP_IVInit(&AES_CRYP_IVInitStructure);
0000e4  a80c              ADD      r0,sp,#0x30
0000e6  f7fffffe          BL       CRYP_IVInit
;;;592    
;;;593      /* Flush IN/OUT FIFOs */
;;;594      CRYP_FIFOFlush();
0000ea  f7fffffe          BL       CRYP_FIFOFlush
;;;595    
;;;596      /* Enable Crypto processor */
;;;597      CRYP_Cmd(ENABLE);
0000ee  2001              MOVS     r0,#1
0000f0  f7fffffe          BL       CRYP_Cmd
;;;598    
;;;599      if(CRYP_GetCmdStatus() == DISABLE)
0000f4  f7fffffe          BL       CRYP_GetCmdStatus
0000f8  2800              CMP      r0,#0
0000fa  d03d              BEQ      |L3.376|
0000fc  e033              B        |L3.358|
                  |L3.254|
0000fe  2004              MOVS     r0,#4                 ;578
000100  9008              STR      r0,[sp,#0x20]         ;578
000102  e7e8              B        |L3.214|
                  |L3.260|
;;;600      {
;;;601        /* The CRYP peripheral clock is not enabled or the device doesn't embedd 
;;;602           the CRYP peripheral (please check the device sales type. */
;;;603        return(ERROR);
;;;604      }
;;;605      
;;;606      for(i=0; ((i<Ilength) && (status != ERROR)); i+=16)
;;;607      {
;;;608    
;;;609        /* Write the Input block in the IN FIFO */
;;;610        CRYP_DataIn(*(uint32_t*)(inputaddr));
000104  6820              LDR      r0,[r4,#0]
000106  f7fffffe          BL       CRYP_DataIn
;;;611        inputaddr+=4;
;;;612        CRYP_DataIn(*(uint32_t*)(inputaddr));
00010a  f8540f04          LDR      r0,[r4,#4]!
00010e  f7fffffe          BL       CRYP_DataIn
;;;613        inputaddr+=4;
;;;614        CRYP_DataIn(*(uint32_t*)(inputaddr));
000112  f8540f04          LDR      r0,[r4,#4]!
000116  f7fffffe          BL       CRYP_DataIn
;;;615        inputaddr+=4;
;;;616        CRYP_DataIn(*(uint32_t*)(inputaddr));
00011a  f8540f04          LDR      r0,[r4,#4]!
00011e  f7fffffe          BL       CRYP_DataIn
;;;617        inputaddr+=4;
;;;618        /* Wait until the complete message has been processed */
;;;619        counter = 0;
;;;620        do
;;;621        {
;;;622          busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
;;;623          counter++;
;;;624        }while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
000122  f44f3780          MOV      r7,#0x10000
000126  1d24              ADDS     r4,r4,#4
000128  f8cd9040          STR      r9,[sp,#0x40]
                  |L3.300|
00012c  2010              MOVS     r0,#0x10              ;622
00012e  f7fffffe          BL       CRYP_GetFlagStatus
000132  9910              LDR      r1,[sp,#0x40]         ;623
000134  1c49              ADDS     r1,r1,#1              ;623
000136  9110              STR      r1,[sp,#0x40]
000138  42b9              CMP      r1,r7
00013a  d002              BEQ      |L3.322|
00013c  2800              CMP      r0,#0
00013e  d1f5              BNE      |L3.300|
000140  e003              B        |L3.330|
                  |L3.322|
;;;625    
;;;626        if (busystatus != RESET)
000142  b110              CBZ      r0,|L3.330|
;;;627       {
;;;628           status = ERROR;
000144  f04f0800          MOV      r8,#0
000148  e00c              B        |L3.356|
                  |L3.330|
;;;629        }
;;;630        else
;;;631        {
;;;632    
;;;633          /* Read the Output block from the Output FIFO */
;;;634          *(uint32_t*)(outputaddr) = CRYP_DataOut();
00014a  f7fffffe          BL       CRYP_DataOut
;;;635          outputaddr+=4;
;;;636          *(uint32_t*)(outputaddr) = CRYP_DataOut();
00014e  6028              STR      r0,[r5,#0]
000150  f7fffffe          BL       CRYP_DataOut
;;;637          outputaddr+=4;
;;;638          *(uint32_t*)(outputaddr) = CRYP_DataOut();
000154  6068              STR      r0,[r5,#4]
000156  f7fffffe          BL       CRYP_DataOut
;;;639          outputaddr+=4;
;;;640          *(uint32_t*)(outputaddr) = CRYP_DataOut();
00015a  60a8              STR      r0,[r5,#8]
00015c  f7fffffe          BL       CRYP_DataOut
000160  60e8              STR      r0,[r5,#0xc]
000162  3510              ADDS     r5,r5,#0x10
                  |L3.356|
000164  3610              ADDS     r6,r6,#0x10
                  |L3.358|
000166  455e              CMP      r6,r11                ;606
000168  d202              BCS      |L3.368|
00016a  f1b80f00          CMP      r8,#0                 ;606
00016e  d1c9              BNE      |L3.260|
                  |L3.368|
;;;641          outputaddr+=4;
;;;642        }
;;;643      }
;;;644      /* Disable Crypto */
;;;645      CRYP_Cmd(DISABLE);
000170  2000              MOVS     r0,#0
000172  f7fffffe          BL       CRYP_Cmd
;;;646    
;;;647      return status;
000176  4640              MOV      r0,r8
                  |L3.376|
;;;648    }
000178  b015              ADD      sp,sp,#0x54
00017a  e8bd8ff0          POP      {r4-r11,pc}
;;;649    
                          ENDP


                          AREA ||i.CRYP_AES_ECB||, CODE, READONLY, ALIGN=1

                  CRYP_AES_ECB PROC
;;;105      */
;;;106    ErrorStatus CRYP_AES_ECB(uint8_t Mode, uint8_t* Key, uint16_t Keysize,
000000  e92d4ff0          PUSH     {r4-r11,lr}
;;;107                             uint8_t* Input, uint32_t Ilength, uint8_t* Output)
;;;108    {
000004  b08d              SUB      sp,sp,#0x34
000006  4683              MOV      r11,r0
000008  e9dda516          LDRD     r10,r5,[sp,#0x58]
;;;109      CRYP_InitTypeDef AES_CRYP_InitStructure;
;;;110      CRYP_KeyInitTypeDef AES_CRYP_KeyInitStructure;
;;;111      __IO uint32_t counter = 0;
00000c  f04f0800          MOV      r8,#0
000010  461c              MOV      r4,r3                 ;108
000012  4691              MOV      r9,r2                 ;108
000014  460e              MOV      r6,r1                 ;108
;;;112      uint32_t busystatus = 0;
;;;113      ErrorStatus status = SUCCESS;
000016  2701              MOVS     r7,#1
;;;114      uint32_t keyaddr    = (uint32_t)Key;
;;;115      uint32_t inputaddr  = (uint32_t)Input;
;;;116      uint32_t outputaddr = (uint32_t)Output;
;;;117      uint32_t i = 0;
;;;118    
;;;119      /* Crypto structures initialisation*/
;;;120      CRYP_KeyStructInit(&AES_CRYP_KeyInitStructure);
000018  4668              MOV      r0,sp
00001a  f8cd8030          STR      r8,[sp,#0x30]
00001e  f7fffffe          BL       CRYP_KeyStructInit
;;;121    
;;;122      switch(Keysize)
000022  4648              MOV      r0,r9
000024  f1b90f80          CMP      r9,#0x80
000028  d01d              BEQ      |L4.102|
00002a  0239              LSLS     r1,r7,#8
00002c  28c0              CMP      r0,#0xc0
00002e  d027              BEQ      |L4.128|
000030  4589              CMP      r9,r1
000032  d138              BNE      |L4.166|
;;;123      {
;;;124        case 128:
;;;125        AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_128b;
;;;126        AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
;;;127        keyaddr+=4;
;;;128        AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
;;;129        keyaddr+=4;
;;;130        AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
;;;131        keyaddr+=4;
;;;132        AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
;;;133        break;
;;;134        case 192:
;;;135        AES_CRYP_InitStructure.CRYP_KeySize  = CRYP_KeySize_192b;
;;;136        AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
;;;137        keyaddr+=4;
;;;138        AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
;;;139        keyaddr+=4;
;;;140        AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
;;;141        keyaddr+=4;
;;;142        AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
;;;143        keyaddr+=4;
;;;144        AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
;;;145        keyaddr+=4;
;;;146        AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
;;;147        break;
;;;148        case 256:
;;;149        AES_CRYP_InitStructure.CRYP_KeySize  = CRYP_KeySize_256b;
000034  0048              LSLS     r0,r1,#1
;;;150        AES_CRYP_KeyInitStructure.CRYP_Key0Left = __REV(*(uint32_t*)(keyaddr));
000036  900b              STR      r0,[sp,#0x2c]
000038  6830              LDR      r0,[r6,#0]
00003a  ba00              REV      r0,r0
;;;151        keyaddr+=4;
;;;152        AES_CRYP_KeyInitStructure.CRYP_Key0Right= __REV(*(uint32_t*)(keyaddr));
00003c  9000              STR      r0,[sp,#0]
00003e  6870              LDR      r0,[r6,#4]
000040  ba00              REV      r0,r0
;;;153        keyaddr+=4;
;;;154        AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
000042  9001              STR      r0,[sp,#4]
000044  68b0              LDR      r0,[r6,#8]
000046  ba00              REV      r0,r0
;;;155        keyaddr+=4;
;;;156        AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
000048  9002              STR      r0,[sp,#8]
00004a  68f0              LDR      r0,[r6,#0xc]
00004c  ba00              REV      r0,r0
;;;157        keyaddr+=4;
;;;158        AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
00004e  9003              STR      r0,[sp,#0xc]
000050  6930              LDR      r0,[r6,#0x10]
000052  ba00              REV      r0,r0
;;;159        keyaddr+=4;
;;;160        AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
000054  9004              STR      r0,[sp,#0x10]
000056  6970              LDR      r0,[r6,#0x14]
000058  ba00              REV      r0,r0
;;;161        keyaddr+=4;
;;;162        AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
00005a  9005              STR      r0,[sp,#0x14]
00005c  69b0              LDR      r0,[r6,#0x18]
00005e  ba00              REV      r0,r0
;;;163        keyaddr+=4;
;;;164        AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
000060  9006              STR      r0,[sp,#0x18]
;;;165        break;
000062  69f0              LDR      r0,[r6,#0x1c]
000064  e01d              B        |L4.162|
                  |L4.102|
000066  f8cd802c          STR      r8,[sp,#0x2c]         ;126
00006a  6830              LDR      r0,[r6,#0]            ;126
00006c  ba00              REV      r0,r0                 ;126
00006e  9004              STR      r0,[sp,#0x10]         ;128
000070  6870              LDR      r0,[r6,#4]            ;128
000072  ba00              REV      r0,r0                 ;128
000074  9005              STR      r0,[sp,#0x14]         ;130
000076  68b0              LDR      r0,[r6,#8]            ;130
000078  ba00              REV      r0,r0                 ;130
00007a  9006              STR      r0,[sp,#0x18]         ;132
00007c  68f0              LDR      r0,[r6,#0xc]          ;133
00007e  e010              B        |L4.162|
                  |L4.128|
000080  910b              STR      r1,[sp,#0x2c]         ;136
000082  6830              LDR      r0,[r6,#0]            ;136
000084  ba00              REV      r0,r0                 ;136
000086  9002              STR      r0,[sp,#8]            ;138
000088  6870              LDR      r0,[r6,#4]            ;138
00008a  ba00              REV      r0,r0                 ;138
00008c  9003              STR      r0,[sp,#0xc]          ;140
00008e  68b0              LDR      r0,[r6,#8]            ;140
000090  ba00              REV      r0,r0                 ;140
000092  9004              STR      r0,[sp,#0x10]         ;142
000094  68f0              LDR      r0,[r6,#0xc]          ;142
000096  ba00              REV      r0,r0                 ;142
000098  9005              STR      r0,[sp,#0x14]         ;144
00009a  6930              LDR      r0,[r6,#0x10]         ;144
00009c  ba00              REV      r0,r0                 ;144
00009e  9006              STR      r0,[sp,#0x18]         ;146
0000a0  6970              LDR      r0,[r6,#0x14]         ;146
                  |L4.162|
0000a2  ba00              REV      r0,r0                 ;132
0000a4  9007              STR      r0,[sp,#0x1c]         ;132
                  |L4.166|
;;;166        default:
;;;167        break;
;;;168      }
;;;169    
;;;170      /*------------------ AES Decryption ------------------*/
;;;171      if(Mode == MODE_DECRYPT) /* AES decryption */
;;;172      {
;;;173        /* Flush IN/OUT FIFOs */
;;;174        CRYP_FIFOFlush();
;;;175    
;;;176        /* Crypto Init for Key preparation for decryption process */
;;;177        AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Decrypt;
;;;178        AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_Key;
;;;179        AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_32b;
;;;180        CRYP_Init(&AES_CRYP_InitStructure);
;;;181    
;;;182        /* Key Initialisation */
;;;183        CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
;;;184    
;;;185        /* Enable Crypto processor */
;;;186        CRYP_Cmd(ENABLE);
;;;187    
;;;188        /* wait until the Busy flag is RESET */
;;;189        do
;;;190        {
;;;191          busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
;;;192          counter++;
;;;193        }while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
0000a6  f44f3980          MOV      r9,#0x10000
0000aa  f1bb0f00          CMP      r11,#0                ;171
0000ae  d016              BEQ      |L4.222|
;;;194    
;;;195        if (busystatus != RESET)
;;;196       {
;;;197           status = ERROR;
;;;198        }
;;;199        else
;;;200        {
;;;201          /* Crypto Init for decryption process */  
;;;202          AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Decrypt;
;;;203        }
;;;204      }
;;;205      /*------------------ AES Encryption ------------------*/
;;;206      else /* AES encryption */
;;;207      {
;;;208    
;;;209        CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
0000b0  4668              MOV      r0,sp
0000b2  f7fffffe          BL       CRYP_KeyInit
;;;210    
;;;211        /* Crypto Init for Encryption process */
;;;212        AES_CRYP_InitStructure.CRYP_AlgoDir  = CRYP_AlgoDir_Encrypt;
0000b6  f8cd8020          STR      r8,[sp,#0x20]
                  |L4.186|
;;;213      }
;;;214    
;;;215      AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_ECB;
0000ba  2020              MOVS     r0,#0x20
;;;216      AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_8b;
0000bc  9009              STR      r0,[sp,#0x24]
0000be  2080              MOVS     r0,#0x80
;;;217      CRYP_Init(&AES_CRYP_InitStructure);
0000c0  900a              STR      r0,[sp,#0x28]
0000c2  a808              ADD      r0,sp,#0x20
0000c4  f7fffffe          BL       CRYP_Init
;;;218    
;;;219      /* Flush IN/OUT FIFOs */
;;;220      CRYP_FIFOFlush();
0000c8  f7fffffe          BL       CRYP_FIFOFlush
;;;221    
;;;222      /* Enable Crypto processor */
;;;223      CRYP_Cmd(ENABLE);
0000cc  2001              MOVS     r0,#1
0000ce  f7fffffe          BL       CRYP_Cmd
;;;224    
;;;225      if(CRYP_GetCmdStatus() == DISABLE)
0000d2  f7fffffe          BL       CRYP_GetCmdStatus
0000d6  2800              CMP      r0,#0
0000d8  d058              BEQ      |L4.396|
;;;226      {
;;;227        /* The CRYP peripheral clock is not enabled or the device doesn't embedd 
;;;228           the CRYP peripheral (please check the device sales type. */
;;;229        return(ERROR);
;;;230      }
;;;231      
;;;232      for(i=0; ((i<Ilength) && (status != ERROR)); i+=16)
0000da  2600              MOVS     r6,#0
0000dc  e04e              B        |L4.380|
                  |L4.222|
0000de  f7fffffe          BL       CRYP_FIFOFlush
0000e2  2604              MOVS     r6,#4                 ;177
0000e4  2038              MOVS     r0,#0x38              ;178
0000e6  e9cd6008          STRD     r6,r0,[sp,#0x20]      ;179
0000ea  f8cd8028          STR      r8,[sp,#0x28]         ;179
0000ee  a808              ADD      r0,sp,#0x20           ;180
0000f0  f7fffffe          BL       CRYP_Init
0000f4  4668              MOV      r0,sp                 ;183
0000f6  f7fffffe          BL       CRYP_KeyInit
0000fa  2001              MOVS     r0,#1                 ;186
0000fc  f7fffffe          BL       CRYP_Cmd
                  |L4.256|
000100  2010              MOVS     r0,#0x10              ;191
000102  f7fffffe          BL       CRYP_GetFlagStatus
000106  990c              LDR      r1,[sp,#0x30]         ;192
000108  1c49              ADDS     r1,r1,#1              ;192
00010a  910c              STR      r1,[sp,#0x30]         ;193
00010c  4549              CMP      r1,r9                 ;193
00010e  d002              BEQ      |L4.278|
000110  2800              CMP      r0,#0                 ;193
000112  d1f5              BNE      |L4.256|
000114  e002              B        |L4.284|
                  |L4.278|
000116  b108              CBZ      r0,|L4.284|
000118  2700              MOVS     r7,#0                 ;197
00011a  e7ce              B        |L4.186|
                  |L4.284|
00011c  9608              STR      r6,[sp,#0x20]         ;202
00011e  e7cc              B        |L4.186|
                  |L4.288|
;;;233      {
;;;234    
;;;235        /* Write the Input block in the IN FIFO */
;;;236        CRYP_DataIn(*(uint32_t*)(inputaddr));
000120  6820              LDR      r0,[r4,#0]
000122  f7fffffe          BL       CRYP_DataIn
;;;237        inputaddr+=4;
;;;238        CRYP_DataIn(*(uint32_t*)(inputaddr));
000126  f8540f04          LDR      r0,[r4,#4]!
00012a  f7fffffe          BL       CRYP_DataIn
;;;239        inputaddr+=4;
;;;240        CRYP_DataIn(*(uint32_t*)(inputaddr));
00012e  f8540f04          LDR      r0,[r4,#4]!
000132  f7fffffe          BL       CRYP_DataIn
;;;241        inputaddr+=4;
;;;242        CRYP_DataIn(*(uint32_t*)(inputaddr));
000136  f8540f04          LDR      r0,[r4,#4]!
00013a  f7fffffe          BL       CRYP_DataIn
;;;243        inputaddr+=4;
;;;244    
;;;245        /* Wait until the complete message has been processed */
;;;246        counter = 0;
00013e  1d24              ADDS     r4,r4,#4
000140  f8cd8030          STR      r8,[sp,#0x30]
                  |L4.324|
;;;247        do
;;;248        {
;;;249          busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
000144  2010              MOVS     r0,#0x10
000146  f7fffffe          BL       CRYP_GetFlagStatus
;;;250          counter++;
00014a  990c              LDR      r1,[sp,#0x30]
00014c  1c49              ADDS     r1,r1,#1
;;;251        }while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
00014e  910c              STR      r1,[sp,#0x30]
000150  4549              CMP      r1,r9
000152  d002              BEQ      |L4.346|
000154  2800              CMP      r0,#0
000156  d1f5              BNE      |L4.324|
000158  e002              B        |L4.352|
                  |L4.346|
;;;252    
;;;253        if (busystatus != RESET)
00015a  b108              CBZ      r0,|L4.352|
;;;254       {
;;;255           status = ERROR;
00015c  2700              MOVS     r7,#0
00015e  e00c              B        |L4.378|
                  |L4.352|
;;;256        }
;;;257        else
;;;258        {
;;;259    
;;;260          /* Read the Output block from the Output FIFO */
;;;261          *(uint32_t*)(outputaddr) = CRYP_DataOut();
000160  f7fffffe          BL       CRYP_DataOut
;;;262          outputaddr+=4;
;;;263          *(uint32_t*)(outputaddr) = CRYP_DataOut();
000164  6028              STR      r0,[r5,#0]
000166  f7fffffe          BL       CRYP_DataOut
;;;264          outputaddr+=4;
;;;265          *(uint32_t*)(outputaddr) = CRYP_DataOut();
00016a  6068              STR      r0,[r5,#4]
00016c  f7fffffe          BL       CRYP_DataOut
;;;266          outputaddr+=4;
;;;267          *(uint32_t*)(outputaddr) = CRYP_DataOut(); 
000170  60a8              STR      r0,[r5,#8]
000172  f7fffffe          BL       CRYP_DataOut
000176  60e8              STR      r0,[r5,#0xc]
000178  3510              ADDS     r5,r5,#0x10
                  |L4.378|
00017a  3610              ADDS     r6,r6,#0x10
                  |L4.380|
00017c  4556              CMP      r6,r10                ;232
00017e  d201              BCS      |L4.388|
000180  2f00              CMP      r7,#0                 ;232
000182  d1cd              BNE      |L4.288|
                  |L4.388|
;;;268          outputaddr+=4;
;;;269        }
;;;270      }
;;;271    
;;;272      /* Disable Crypto */
;;;273      CRYP_Cmd(DISABLE);
000184  2000              MOVS     r0,#0
000186  f7fffffe          BL       CRYP_Cmd
;;;274    
;;;275      return status; 
00018a  4638              MOV      r0,r7
                  |L4.396|
;;;276    }
00018c  b00d              ADD      sp,sp,#0x34
00018e  e8bd8ff0          POP      {r4-r11,pc}
;;;277    
                          ENDP


                          AREA ||i.CRYP_AES_GCM||, CODE, READONLY, ALIGN=1

                  CRYP_AES_GCM PROC
;;;669      */
;;;670    ErrorStatus CRYP_AES_GCM(uint8_t Mode, uint8_t InitVectors[16],
000000  e92d4fff          PUSH     {r0-r11,lr}
;;;671                             uint8_t *Key, uint16_t Keysize,
;;;672                             uint8_t *Input, uint32_t ILength,
;;;673                             uint8_t *Header, uint32_t HLength,
;;;674                             uint8_t *Output, uint8_t *AuthTAG)
;;;675    {
000004  b095              SUB      sp,sp,#0x54
;;;676      CRYP_InitTypeDef AES_CRYP_InitStructure;
;;;677      CRYP_KeyInitTypeDef AES_CRYP_KeyInitStructure;
;;;678      CRYP_IVInitTypeDef AES_CRYP_IVInitStructure;
;;;679      __IO uint32_t counter = 0;
000006  f04f0b00          MOV      r11,#0
00000a  e9dd9525          LDRD     r9,r5,[sp,#0x94]      ;675
00000e  e9dd4a22          LDRD     r4,r10,[sp,#0x88]     ;675
;;;680      uint32_t busystatus = 0;
;;;681      ErrorStatus status = SUCCESS;
;;;682      uint32_t keyaddr    = (uint32_t)Key;
;;;683      uint32_t inputaddr  = (uint32_t)Input;
;;;684      uint32_t outputaddr = (uint32_t)Output;
;;;685      uint32_t ivaddr     = (uint32_t)InitVectors;
;;;686      uint32_t headeraddr = (uint32_t)Header;
;;;687      uint32_t tagaddr = (uint32_t)AuthTAG;
;;;688      uint64_t headerlength = HLength * 8;/* header length in bits */
000012  9108              STR      r1,[sp,#0x20]
000014  ea4f01c9          LSL      r1,r9,#3
;;;689      uint64_t inputlength = ILength * 8;/* input length in bits */
000018  9114              STR      r1,[sp,#0x50]
00001a  ea4f01ca          LSL      r1,r10,#3
00001e  2701              MOVS     r7,#1                 ;681
000020  4690              MOV      r8,r2                 ;682
000022  9e24              LDR      r6,[sp,#0x90]         ;685
;;;690      uint32_t loopcounter = 0;
;;;691    
;;;692      /* Crypto structures initialisation*/
;;;693      CRYP_KeyStructInit(&AES_CRYP_KeyInitStructure);
000024  4668              MOV      r0,sp
000026  9112              STR      r1,[sp,#0x48]
000028  f7fffffe          BL       CRYP_KeyStructInit
;;;694    
;;;695      switch(Keysize)
00002c  9818              LDR      r0,[sp,#0x60]
00002e  2880              CMP      r0,#0x80
000030  d026              BEQ      |L5.128|
000032  0239              LSLS     r1,r7,#8
000034  28c0              CMP      r0,#0xc0
000036  d034              BEQ      |L5.162|
000038  4288              CMP      r0,r1
00003a  d14b              BNE      |L5.212|
;;;696      {
;;;697        case 128:
;;;698        AES_CRYP_InitStructure.CRYP_KeySize = CRYP_KeySize_128b;
;;;699        AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
;;;700        keyaddr+=4;
;;;701        AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
;;;702        keyaddr+=4;
;;;703        AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
;;;704        keyaddr+=4;
;;;705        AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
;;;706        break;
;;;707        case 192:
;;;708        AES_CRYP_InitStructure.CRYP_KeySize  = CRYP_KeySize_192b;
;;;709        AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
;;;710        keyaddr+=4;
;;;711        AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
;;;712        keyaddr+=4;
;;;713        AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
;;;714        keyaddr+=4;
;;;715        AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
;;;716        keyaddr+=4;
;;;717        AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
;;;718        keyaddr+=4;
;;;719        AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
;;;720        break;
;;;721        case 256:
;;;722        AES_CRYP_InitStructure.CRYP_KeySize  = CRYP_KeySize_256b;
00003c  0040              LSLS     r0,r0,#1
;;;723        AES_CRYP_KeyInitStructure.CRYP_Key0Left = __REV(*(uint32_t*)(keyaddr));
00003e  900c              STR      r0,[sp,#0x30]
000040  f8d80000          LDR      r0,[r8,#0]
000044  ba00              REV      r0,r0
;;;724        keyaddr+=4;
000046  9000              STR      r0,[sp,#0]
;;;725        AES_CRYP_KeyInitStructure.CRYP_Key0Right= __REV(*(uint32_t*)(keyaddr));
000048  f8d81004          LDR      r1,[r8,#4]
00004c  f1080004          ADD      r0,r8,#4              ;724
000050  ba09              REV      r1,r1
;;;726        keyaddr+=4;
;;;727        AES_CRYP_KeyInitStructure.CRYP_Key1Left = __REV(*(uint32_t*)(keyaddr));
000052  9101              STR      r1,[sp,#4]
000054  f8d81008          LDR      r1,[r8,#8]
000058  ba09              REV      r1,r1
;;;728        keyaddr+=4;
;;;729        AES_CRYP_KeyInitStructure.CRYP_Key1Right= __REV(*(uint32_t*)(keyaddr));
00005a  9102              STR      r1,[sp,#8]
00005c  f8d8100c          LDR      r1,[r8,#0xc]
000060  ba09              REV      r1,r1
;;;730        keyaddr+=4;
;;;731        AES_CRYP_KeyInitStructure.CRYP_Key2Left = __REV(*(uint32_t*)(keyaddr));
000062  9103              STR      r1,[sp,#0xc]
000064  f8d81010          LDR      r1,[r8,#0x10]
000068  ba09              REV      r1,r1
;;;732        keyaddr+=4;
;;;733        AES_CRYP_KeyInitStructure.CRYP_Key2Right= __REV(*(uint32_t*)(keyaddr));
00006a  9104              STR      r1,[sp,#0x10]
00006c  f8d81014          LDR      r1,[r8,#0x14]
000070  ba09              REV      r1,r1
;;;734        keyaddr+=4;
;;;735        AES_CRYP_KeyInitStructure.CRYP_Key3Left = __REV(*(uint32_t*)(keyaddr));
000072  9105              STR      r1,[sp,#0x14]
000074  f8d81018          LDR      r1,[r8,#0x18]
000078  ba09              REV      r1,r1
;;;736        keyaddr+=4;
;;;737        AES_CRYP_KeyInitStructure.CRYP_Key3Right= __REV(*(uint32_t*)(keyaddr));
00007a  9106              STR      r1,[sp,#0x18]
00007c  6980              LDR      r0,[r0,#0x18]
;;;738        break;
00007e  e027              B        |L5.208|
                  |L5.128|
000080  f8cdb030          STR      r11,[sp,#0x30]        ;699
000084  f8d80000          LDR      r0,[r8,#0]            ;699
000088  ba00              REV      r0,r0                 ;699
00008a  9004              STR      r0,[sp,#0x10]         ;701
00008c  f8d81004          LDR      r1,[r8,#4]            ;701
000090  ba09              REV      r1,r1                 ;701
000092  9105              STR      r1,[sp,#0x14]         ;703
000094  f8d81008          LDR      r1,[r8,#8]            ;703
000098  ba09              REV      r1,r1                 ;703
00009a  9106              STR      r1,[sp,#0x18]         ;705
00009c  f8d8000c          LDR      r0,[r8,#0xc]          ;706
0000a0  e016              B        |L5.208|
                  |L5.162|
0000a2  910c              STR      r1,[sp,#0x30]         ;709
0000a4  f8d80000          LDR      r0,[r8,#0]            ;709
0000a8  ba00              REV      r0,r0                 ;709
0000aa  9002              STR      r0,[sp,#8]            ;711
0000ac  f8d81004          LDR      r1,[r8,#4]            ;711
0000b0  ba09              REV      r1,r1                 ;711
0000b2  9103              STR      r1,[sp,#0xc]          ;713
0000b4  f8d81008          LDR      r1,[r8,#8]            ;713
0000b8  ba09              REV      r1,r1                 ;713
0000ba  9104              STR      r1,[sp,#0x10]         ;715
0000bc  f8d8100c          LDR      r1,[r8,#0xc]          ;715
0000c0  ba09              REV      r1,r1                 ;715
0000c2  9105              STR      r1,[sp,#0x14]         ;717
0000c4  f8d81010          LDR      r1,[r8,#0x10]         ;717
0000c8  ba09              REV      r1,r1                 ;717
0000ca  9106              STR      r1,[sp,#0x18]         ;719
0000cc  f8d80014          LDR      r0,[r8,#0x14]         ;719
                  |L5.208|
0000d0  ba00              REV      r0,r0                 ;705
0000d2  9007              STR      r0,[sp,#0x1c]         ;705
                  |L5.212|
;;;739        default:
;;;740        break;
;;;741      }
;;;742      
;;;743      /* CRYP Initialization Vectors */
;;;744      AES_CRYP_IVInitStructure.CRYP_IV0Left = __REV(*(uint32_t*)(ivaddr));
0000d4  9808              LDR      r0,[sp,#0x20]
;;;745      ivaddr+=4;
;;;746      AES_CRYP_IVInitStructure.CRYP_IV0Right= __REV(*(uint32_t*)(ivaddr));
;;;747      ivaddr+=4;
;;;748      AES_CRYP_IVInitStructure.CRYP_IV1Left = __REV(*(uint32_t*)(ivaddr));
;;;749      ivaddr+=4;
;;;750      AES_CRYP_IVInitStructure.CRYP_IV1Right= __REV(*(uint32_t*)(ivaddr));
;;;751      
;;;752      /*------------------ AES Encryption ------------------*/
;;;753      if(Mode == MODE_ENCRYPT) /* AES encryption */
;;;754      {
;;;755        /* Flush IN/OUT FIFOs */
;;;756        CRYP_FIFOFlush();
;;;757        
;;;758        /* Key Initialisation */
;;;759        CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
;;;760        
;;;761        /* CRYP Initialization Vectors */
;;;762        CRYP_IVInit(&AES_CRYP_IVInitStructure);
;;;763        
;;;764        /* Crypto Init for Key preparation for decryption process */
;;;765        AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Encrypt;
;;;766        AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_GCM;
0000d6  f44f2800          MOV      r8,#0x80000
0000da  6800              LDR      r0,[r0,#0]            ;744
0000dc  ba00              REV      r0,r0                 ;744
0000de  900d              STR      r0,[sp,#0x34]         ;745
0000e0  9808              LDR      r0,[sp,#0x20]         ;746
0000e2  6841              LDR      r1,[r0,#4]            ;746
0000e4  ba09              REV      r1,r1                 ;746
0000e6  910e              STR      r1,[sp,#0x38]         ;748
0000e8  6881              LDR      r1,[r0,#8]            ;748
0000ea  ba09              REV      r1,r1                 ;748
0000ec  910f              STR      r1,[sp,#0x3c]         ;750
0000ee  68c0              LDR      r0,[r0,#0xc]          ;750
0000f0  ba00              REV      r0,r0                 ;750
0000f2  9010              STR      r0,[sp,#0x40]         ;753
0000f4  9815              LDR      r0,[sp,#0x54]         ;753
0000f6  2801              CMP      r0,#1                 ;753
0000f8  d02a              BEQ      |L5.336|
;;;767        AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_8b;
;;;768        CRYP_Init(&AES_CRYP_InitStructure);
;;;769        
;;;770        /***************************** Init phase *********************************/
;;;771        /* Select init phase */
;;;772        CRYP_PhaseConfig(CRYP_Phase_Init);
;;;773        
;;;774        /* Enable Crypto processor */
;;;775        CRYP_Cmd(ENABLE);
;;;776        
;;;777        /* Wait for CRYPEN bit to be 0 */
;;;778        while(CRYP_GetCmdStatus() == ENABLE)
;;;779        {
;;;780        }
;;;781        
;;;782        /***************************** header phase *******************************/
;;;783        if(HLength != 0)
;;;784        {
;;;785          /* Select header phase */
;;;786          CRYP_PhaseConfig(CRYP_Phase_Header);
;;;787          
;;;788          /* Enable Crypto processor */
;;;789          CRYP_Cmd(ENABLE);
;;;790          
;;;791          if(CRYP_GetCmdStatus() == DISABLE)
;;;792          {
;;;793             /* The CRYP peripheral clock is not enabled or the device doesn't embedd 
;;;794                the CRYP peripheral (please check the device sales type. */
;;;795             return(ERROR);
;;;796          }
;;;797          
;;;798          for(loopcounter = 0; (loopcounter < HLength); loopcounter+=16)
;;;799          {
;;;800            /* Wait until the IFEM flag is reset */
;;;801            while(CRYP_GetFlagStatus(CRYP_FLAG_IFEM) == RESET)
;;;802            {
;;;803            }
;;;804            
;;;805            /* Write the Input block in the IN FIFO */
;;;806            CRYP_DataIn(*(uint32_t*)(headeraddr));
;;;807            headeraddr+=4;
;;;808            CRYP_DataIn(*(uint32_t*)(headeraddr));
;;;809            headeraddr+=4;
;;;810            CRYP_DataIn(*(uint32_t*)(headeraddr));
;;;811            headeraddr+=4;
;;;812            CRYP_DataIn(*(uint32_t*)(headeraddr));
;;;813            headeraddr+=4;
;;;814          }
;;;815          
;;;816          /* Wait until the complete message has been processed */
;;;817          counter = 0;
;;;818          do
;;;819          {
;;;820            busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
;;;821            counter++;
;;;822          }while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
;;;823    
;;;824          if (busystatus != RESET)
;;;825          {
;;;826            status = ERROR;
;;;827          }
;;;828        }
;;;829        
;;;830        /**************************** payload phase *******************************/
;;;831        if(ILength != 0)
;;;832        {
;;;833          /* Select payload phase */
;;;834          CRYP_PhaseConfig(CRYP_Phase_Payload);
;;;835          
;;;836          /* Enable Crypto processor */
;;;837          CRYP_Cmd(ENABLE);
;;;838          
;;;839          if(CRYP_GetCmdStatus() == DISABLE)
;;;840          {
;;;841            /* The CRYP peripheral clock is not enabled or the device doesn't embedd 
;;;842               the CRYP peripheral (please check the device sales type. */
;;;843            return(ERROR);
;;;844          }
;;;845          
;;;846          for(loopcounter = 0; ((loopcounter < ILength) && (status != ERROR)); loopcounter+=16)
;;;847          {
;;;848            /* Wait until the IFEM flag is reset */
;;;849            while(CRYP_GetFlagStatus(CRYP_FLAG_IFEM) == RESET)
;;;850            {
;;;851            }
;;;852            /* Write the Input block in the IN FIFO */
;;;853            CRYP_DataIn(*(uint32_t*)(inputaddr));
;;;854            inputaddr+=4;
;;;855            CRYP_DataIn(*(uint32_t*)(inputaddr));
;;;856            inputaddr+=4;
;;;857            CRYP_DataIn(*(uint32_t*)(inputaddr));
;;;858            inputaddr+=4;
;;;859            CRYP_DataIn(*(uint32_t*)(inputaddr));
;;;860            inputaddr+=4;
;;;861            
;;;862            /* Wait until the complete message has been processed */
;;;863            counter = 0;
;;;864            do
;;;865            {
;;;866              busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
;;;867              counter++;
;;;868            }while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
;;;869    
;;;870            if (busystatus != RESET)
;;;871            {
;;;872              status = ERROR;
;;;873            }
;;;874            else
;;;875            {
;;;876              /* Wait until the OFNE flag is reset */
;;;877              while(CRYP_GetFlagStatus(CRYP_FLAG_OFNE) == RESET)
;;;878              {
;;;879              }
;;;880              
;;;881              /* Read the Output block from the Output FIFO */
;;;882              *(uint32_t*)(outputaddr) = CRYP_DataOut();
;;;883              outputaddr+=4;
;;;884              *(uint32_t*)(outputaddr) = CRYP_DataOut();
;;;885              outputaddr+=4;
;;;886              *(uint32_t*)(outputaddr) = CRYP_DataOut();
;;;887              outputaddr+=4;
;;;888              *(uint32_t*)(outputaddr) = CRYP_DataOut();
;;;889              outputaddr+=4;
;;;890            }
;;;891          }
;;;892        }
;;;893        
;;;894        /***************************** final phase ********************************/
;;;895        /* Select final phase */
;;;896        CRYP_PhaseConfig(CRYP_Phase_Final);
;;;897        
;;;898        /* Enable Crypto processor */
;;;899        CRYP_Cmd(ENABLE);
;;;900        
;;;901        if(CRYP_GetCmdStatus() == DISABLE)
;;;902        {
;;;903          /* The CRYP peripheral clock is not enabled or the device doesn't embedd 
;;;904             the CRYP peripheral (please check the device sales type. */
;;;905          return(ERROR);
;;;906        }
;;;907        
;;;908        /* Write number of bits concatenated with header in the IN FIFO */
;;;909        CRYP_DataIn(__REV(headerlength>>32));
;;;910        CRYP_DataIn(__REV(headerlength));
;;;911        CRYP_DataIn(__REV(inputlength>>32));
;;;912        CRYP_DataIn(__REV(inputlength));
;;;913        /* Wait until the OFNE flag is reset */
;;;914        while(CRYP_GetFlagStatus(CRYP_FLAG_OFNE) == RESET)
;;;915        {
;;;916        }
;;;917        
;;;918        tagaddr = (uint32_t)AuthTAG;
;;;919        /* Read the Auth TAG in the IN FIFO */
;;;920        *(uint32_t*)(tagaddr) = CRYP_DataOut();
;;;921        tagaddr+=4;
;;;922        *(uint32_t*)(tagaddr) = CRYP_DataOut();
;;;923        tagaddr+=4;
;;;924        *(uint32_t*)(tagaddr) = CRYP_DataOut();
;;;925        tagaddr+=4;
;;;926        *(uint32_t*)(tagaddr) = CRYP_DataOut();
;;;927        tagaddr+=4;
;;;928      }
;;;929      /*------------------ AES Decryption ------------------*/
;;;930      else /* AES decryption */
;;;931      {
;;;932        /* Flush IN/OUT FIFOs */
;;;933        CRYP_FIFOFlush();
0000fa  f7fffffe          BL       CRYP_FIFOFlush
;;;934        
;;;935        /* Key Initialisation */
;;;936        CRYP_KeyInit(&AES_CRYP_KeyInitStructure);
0000fe  4668              MOV      r0,sp
000100  f7fffffe          BL       CRYP_KeyInit
;;;937        
;;;938        /* CRYP Initialization Vectors */
;;;939        CRYP_IVInit(&AES_CRYP_IVInitStructure);
000104  a80d              ADD      r0,sp,#0x34
000106  f7fffffe          BL       CRYP_IVInit
;;;940        
;;;941        /* Crypto Init for Key preparation for decryption process */
;;;942        AES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Decrypt;
00010a  2004              MOVS     r0,#4
00010c  e9cd0809          STRD     r0,r8,[sp,#0x24]
;;;943        AES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_AES_GCM;
;;;944        AES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_8b;
000110  2080              MOVS     r0,#0x80
;;;945        CRYP_Init(&AES_CRYP_InitStructure);
000112  900b              STR      r0,[sp,#0x2c]
000114  a809              ADD      r0,sp,#0x24
000116  f7fffffe          BL       CRYP_Init
;;;946        
;;;947        /***************************** Init phase *********************************/
;;;948        /* Select init phase */
;;;949        CRYP_PhaseConfig(CRYP_Phase_Init);
00011a  2000              MOVS     r0,#0
00011c  f7fffffe          BL       CRYP_PhaseConfig
;;;950        
;;;951        /* Enable Crypto processor */
;;;952        CRYP_Cmd(ENABLE);
000120  2001              MOVS     r0,#1
000122  f7fffffe          BL       CRYP_Cmd
                  |L5.294|
;;;953        
;;;954        /* Wait for CRYPEN bit to be 0 */
;;;955        while(CRYP_GetCmdStatus() == ENABLE)
000126  f7fffffe          BL       CRYP_GetCmdStatus
00012a  2801              CMP      r0,#1
00012c  d0fb              BEQ      |L5.294|
;;;956        {
;;;957        }
;;;958        
;;;959        /***************************** header phase *******************************/
;;;960        if(HLength != 0)
00012e  f1b90f00          CMP      r9,#0
000132  d072              BEQ      |L5.538|
;;;961        {
;;;962          /* Select header phase */
;;;963          CRYP_PhaseConfig(CRYP_Phase_Header);
000134  f44f3080          MOV      r0,#0x10000
000138  f7fffffe          BL       CRYP_PhaseConfig
;;;964          
;;;965          /* Enable Crypto processor */
;;;966          CRYP_Cmd(ENABLE);
00013c  2001              MOVS     r0,#1
00013e  f7fffffe          BL       CRYP_Cmd
;;;967          
;;;968          if(CRYP_GetCmdStatus() == DISABLE)
000142  f7fffffe          BL       CRYP_GetCmdStatus
000146  2800              CMP      r0,#0
000148  d068              BEQ      |L5.540|
;;;969          {
;;;970            /* The CRYP peripheral clock is not enabled or the device doesn't embedd 
;;;971               the CRYP peripheral (please check the device sales type. */
;;;972            return(ERROR);
;;;973          }
;;;974          
;;;975          for(loopcounter = 0; (loopcounter < HLength); loopcounter+=16)
00014a  f04f0800          MOV      r8,#0
00014e  e0dc              B        |L5.778|
                  |L5.336|
000150  f7fffffe          BL       CRYP_FIFOFlush
000154  4668              MOV      r0,sp                 ;759
000156  f7fffffe          BL       CRYP_KeyInit
00015a  a80d              ADD      r0,sp,#0x34           ;762
00015c  f7fffffe          BL       CRYP_IVInit
000160  2000              MOVS     r0,#0                 ;765
000162  e9cd0809          STRD     r0,r8,[sp,#0x24]      ;765
000166  2080              MOVS     r0,#0x80              ;767
000168  900b              STR      r0,[sp,#0x2c]         ;768
00016a  a809              ADD      r0,sp,#0x24           ;768
00016c  f7fffffe          BL       CRYP_Init
000170  2000              MOVS     r0,#0                 ;772
000172  f7fffffe          BL       CRYP_PhaseConfig
000176  2001              MOVS     r0,#1                 ;775
000178  f7fffffe          BL       CRYP_Cmd
                  |L5.380|
00017c  f7fffffe          BL       CRYP_GetCmdStatus
000180  2801              CMP      r0,#1                 ;778
000182  d0fb              BEQ      |L5.380|
000184  f1b90f00          CMP      r9,#0                 ;783
000188  d037              BEQ      |L5.506|
00018a  f44f3080          MOV      r0,#0x10000           ;786
00018e  f7fffffe          BL       CRYP_PhaseConfig
000192  2001              MOVS     r0,#1                 ;789
000194  f7fffffe          BL       CRYP_Cmd
000198  f7fffffe          BL       CRYP_GetCmdStatus
00019c  2800              CMP      r0,#0                 ;791
00019e  d03d              BEQ      |L5.540|
0001a0  f04f0800          MOV      r8,#0                 ;798
0001a4  e016              B        |L5.468|
                  |L5.422|
0001a6  2001              MOVS     r0,#1                 ;801
0001a8  f7fffffe          BL       CRYP_GetFlagStatus
0001ac  2800              CMP      r0,#0                 ;801
0001ae  d0fa              BEQ      |L5.422|
0001b0  6830              LDR      r0,[r6,#0]            ;806
0001b2  f7fffffe          BL       CRYP_DataIn
0001b6  f8560f04          LDR      r0,[r6,#4]!           ;808
0001ba  f7fffffe          BL       CRYP_DataIn
0001be  f8560f04          LDR      r0,[r6,#4]!           ;810
0001c2  f7fffffe          BL       CRYP_DataIn
0001c6  f8560f04          LDR      r0,[r6,#4]!           ;812
0001ca  f7fffffe          BL       CRYP_DataIn
0001ce  f1080810          ADD      r8,r8,#0x10           ;798
0001d2  1d36              ADDS     r6,r6,#4              ;798
                  |L5.468|
0001d4  45c8              CMP      r8,r9                 ;798
0001d6  d3e6              BCC      |L5.422|
0001d8  2000              MOVS     r0,#0                 ;817
0001da  f44f3680          MOV      r6,#0x10000           ;786
0001de  9008              STR      r0,[sp,#0x20]         ;786
                  |L5.480|
0001e0  2010              MOVS     r0,#0x10              ;820
0001e2  f7fffffe          BL       CRYP_GetFlagStatus
0001e6  9908              LDR      r1,[sp,#0x20]         ;821
0001e8  1c49              ADDS     r1,r1,#1              ;821
0001ea  9108              STR      r1,[sp,#0x20]         ;822
0001ec  42b1              CMP      r1,r6                 ;822
0001ee  d002              BEQ      |L5.502|
0001f0  2800              CMP      r0,#0                 ;822
0001f2  d1f5              BNE      |L5.480|
0001f4  e001              B        |L5.506|
                  |L5.502|
0001f6  b100              CBZ      r0,|L5.506|
0001f8  2700              MOVS     r7,#0                 ;826
                  |L5.506|
0001fa  f1ba0f00          CMP      r10,#0                ;831
0001fe  d04c              BEQ      |L5.666|
000200  f44f3000          MOV      r0,#0x20000           ;834
000204  f7fffffe          BL       CRYP_PhaseConfig
000208  2001              MOVS     r0,#1                 ;837
00020a  f7fffffe          BL       CRYP_Cmd
00020e  f7fffffe          BL       CRYP_GetCmdStatus
000212  2800              CMP      r0,#0                 ;839
000214  d002              BEQ      |L5.540|
000216  2600              MOVS     r6,#0                 ;846
000218  e03b              B        |L5.658|
                  |L5.538|
00021a  e089              B        |L5.816|
                  |L5.540|
00021c  e0bc              B        |L5.920|
                  |L5.542|
00021e  2001              MOVS     r0,#1                 ;849
000220  f7fffffe          BL       CRYP_GetFlagStatus
000224  2800              CMP      r0,#0                 ;849
000226  d0fa              BEQ      |L5.542|
000228  6820              LDR      r0,[r4,#0]            ;853
00022a  f7fffffe          BL       CRYP_DataIn
00022e  f8540f04          LDR      r0,[r4,#4]!           ;855
000232  f7fffffe          BL       CRYP_DataIn
000236  f8540f04          LDR      r0,[r4,#4]!           ;857
00023a  f7fffffe          BL       CRYP_DataIn
00023e  f8540f04          LDR      r0,[r4,#4]!           ;859
000242  f7fffffe          BL       CRYP_DataIn
000246  2000              MOVS     r0,#0                 ;863
000248  f44f3880          MOV      r8,#0x10000           ;786
00024c  1d24              ADDS     r4,r4,#4              ;786
00024e  9008              STR      r0,[sp,#0x20]         ;786
                  |L5.592|
000250  2010              MOVS     r0,#0x10              ;866
000252  f7fffffe          BL       CRYP_GetFlagStatus
000256  9908              LDR      r1,[sp,#0x20]         ;867
000258  1c49              ADDS     r1,r1,#1              ;867
00025a  9108              STR      r1,[sp,#0x20]         ;868
00025c  4541              CMP      r1,r8                 ;868
00025e  d002              BEQ      |L5.614|
000260  2800              CMP      r0,#0                 ;868
000262  d1f5              BNE      |L5.592|
000264  e002              B        |L5.620|
                  |L5.614|
000266  b108              CBZ      r0,|L5.620|
000268  2700              MOVS     r7,#0                 ;872
00026a  e011              B        |L5.656|
                  |L5.620|
00026c  2004              MOVS     r0,#4                 ;877
00026e  f7fffffe          BL       CRYP_GetFlagStatus
000272  2800              CMP      r0,#0                 ;877
000274  d0fa              BEQ      |L5.620|
000276  f7fffffe          BL       CRYP_DataOut
00027a  6028              STR      r0,[r5,#0]            ;884
00027c  f7fffffe          BL       CRYP_DataOut
000280  6068              STR      r0,[r5,#4]            ;886
000282  f7fffffe          BL       CRYP_DataOut
000286  60a8              STR      r0,[r5,#8]            ;888
000288  f7fffffe          BL       CRYP_DataOut
00028c  60e8              STR      r0,[r5,#0xc]          ;888
00028e  3510              ADDS     r5,r5,#0x10           ;888
                  |L5.656|
000290  3610              ADDS     r6,r6,#0x10           ;888
                  |L5.658|
000292  4556              CMP      r6,r10                ;846
000294  d201              BCS      |L5.666|
000296  2f00              CMP      r7,#0                 ;846
000298  d1c1              BNE      |L5.542|
                  |L5.666|
00029a  f44f3040          MOV      r0,#0x30000           ;896
00029e  f7fffffe          BL       CRYP_PhaseConfig
0002a2  2001              MOVS     r0,#1                 ;899
0002a4  f7fffffe          BL       CRYP_Cmd
0002a8  f7fffffe          BL       CRYP_GetCmdStatus
0002ac  2800              CMP      r0,#0                 ;901
0002ae  d073              BEQ      |L5.920|
0002b0  fa9bf08b          REV      r0,r11                ;909
0002b4  f7fffffe          BL       CRYP_DataIn
0002b8  9814              LDR      r0,[sp,#0x50]         ;910
0002ba  ba00              REV      r0,r0                 ;910
0002bc  f7fffffe          BL       CRYP_DataIn
0002c0  fa9bf08b          REV      r0,r11                ;911
0002c4  f7fffffe          BL       CRYP_DataIn
0002c8  9812              LDR      r0,[sp,#0x48]         ;912
0002ca  ba00              REV      r0,r0                 ;912
0002cc  f7fffffe          BL       CRYP_DataIn
                  |L5.720|
0002d0  2004              MOVS     r0,#4                 ;914
0002d2  f7fffffe          BL       CRYP_GetFlagStatus
0002d6  2800              CMP      r0,#0                 ;914
0002d8  d0fa              BEQ      |L5.720|
0002da  e098              B        |L5.1038|
                  |L5.732|
;;;976          {
;;;977            /* Wait until the IFEM flag is reset */
;;;978            while(CRYP_GetFlagStatus(CRYP_FLAG_IFEM) == RESET)
0002dc  2001              MOVS     r0,#1
0002de  f7fffffe          BL       CRYP_GetFlagStatus
0002e2  2800              CMP      r0,#0
0002e4  d0fa              BEQ      |L5.732|
;;;979            {
;;;980            }
;;;981            
;;;982            /* Write the Input block in the IN FIFO */
;;;983            CRYP_DataIn(*(uint32_t*)(headeraddr));
0002e6  6830              LDR      r0,[r6,#0]
0002e8  f7fffffe          BL       CRYP_DataIn
;;;984            headeraddr+=4;
;;;985            CRYP_DataIn(*(uint32_t*)(headeraddr));
0002ec  f8560f04          LDR      r0,[r6,#4]!
0002f0  f7fffffe          BL       CRYP_DataIn
;;;986            headeraddr+=4;
;;;987            CRYP_DataIn(*(uint32_t*)(headeraddr));
0002f4  f8560f04          LDR      r0,[r6,#4]!
0002f8  f7fffffe          BL       CRYP_DataIn
;;;988            headeraddr+=4;
;;;989            CRYP_DataIn(*(uint32_t*)(headeraddr));
0002fc  f8560f04          LDR      r0,[r6,#4]!
000300  f7fffffe          BL       CRYP_DataIn
000304  f1080810          ADD      r8,r8,#0x10           ;975
000308  1d36              ADDS     r6,r6,#4              ;975
                  |L5.778|
00030a  45c8              CMP      r8,r9                 ;975
00030c  d3e6              BCC      |L5.732|
00030e  f44f3680          MOV      r6,#0x10000           ;786
000312  f8cdb020          STR      r11,[sp,#0x20]        ;786
                  |L5.790|
;;;990            headeraddr+=4;
;;;991          }
;;;992          
;;;993          /* Wait until the complete message has been processed */
;;;994          counter = 0;
;;;995          do
;;;996          {
;;;997            busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
000316  2010              MOVS     r0,#0x10
000318  f7fffffe          BL       CRYP_GetFlagStatus
;;;998            counter++;
00031c  9908              LDR      r1,[sp,#0x20]
00031e  1c49              ADDS     r1,r1,#1
;;;999          }while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
000320  9108              STR      r1,[sp,#0x20]
000322  42b1              CMP      r1,r6
000324  d002              BEQ      |L5.812|
000326  2800              CMP      r0,#0
000328  d1f5              BNE      |L5.790|
00032a  e001              B        |L5.816|
                  |L5.812|
;;;1000   
;;;1001         if (busystatus != RESET)
00032c  b100              CBZ      r0,|L5.816|
;;;1002         {
;;;1003           status = ERROR;
00032e  2700              MOVS     r7,#0
                  |L5.816|
;;;1004         }
;;;1005       }
;;;1006       
;;;1007       /**************************** payload phase *******************************/
;;;1008       if(ILength != 0)
000330  f1ba0f00          CMP      r10,#0
000334  d04b              BEQ      |L5.974|
;;;1009       {
;;;1010         /* Select payload phase */
;;;1011         CRYP_PhaseConfig(CRYP_Phase_Payload);
000336  f44f3000          MOV      r0,#0x20000
00033a  f7fffffe          BL       CRYP_PhaseConfig
;;;1012   
;;;1013         /* Enable Crypto processor */
;;;1014         CRYP_Cmd(ENABLE);
00033e  2001              MOVS     r0,#1
000340  f7fffffe          BL       CRYP_Cmd
;;;1015         
;;;1016         if(CRYP_GetCmdStatus() == DISABLE)
000344  f7fffffe          BL       CRYP_GetCmdStatus
000348  2800              CMP      r0,#0
00034a  d071              BEQ      |L5.1072|
;;;1017         {
;;;1018           /* The CRYP peripheral clock is not enabled or the device doesn't embedd 
;;;1019              the CRYP peripheral (please check the device sales type. */
;;;1020           return(ERROR);
;;;1021         }
;;;1022         
;;;1023         for(loopcounter = 0; ((loopcounter < ILength) && (status != ERROR)); loopcounter+=16)
00034c  2600              MOVS     r6,#0
00034e  e03a              B        |L5.966|
                  |L5.848|
;;;1024         {
;;;1025           /* Wait until the IFEM flag is reset */
;;;1026           while(CRYP_GetFlagStatus(CRYP_FLAG_IFEM) == RESET)
000350  2001              MOVS     r0,#1
000352  f7fffffe          BL       CRYP_GetFlagStatus
000356  2800              CMP      r0,#0
000358  d0fa              BEQ      |L5.848|
;;;1027           {
;;;1028           }
;;;1029           /* Write the Input block in the IN FIFO */
;;;1030           CRYP_DataIn(*(uint32_t*)(inputaddr));
00035a  6820              LDR      r0,[r4,#0]
00035c  f7fffffe          BL       CRYP_DataIn
;;;1031           inputaddr+=4;
;;;1032           CRYP_DataIn(*(uint32_t*)(inputaddr));
000360  f8540f04          LDR      r0,[r4,#4]!
000364  f7fffffe          BL       CRYP_DataIn
;;;1033           inputaddr+=4;
;;;1034           CRYP_DataIn(*(uint32_t*)(inputaddr));
000368  f8540f04          LDR      r0,[r4,#4]!
00036c  f7fffffe          BL       CRYP_DataIn
;;;1035           inputaddr+=4;
;;;1036           CRYP_DataIn(*(uint32_t*)(inputaddr));
000370  f8540f04          LDR      r0,[r4,#4]!
000374  f7fffffe          BL       CRYP_DataIn
000378  f44f3880          MOV      r8,#0x10000           ;786
00037c  1d24              ADDS     r4,r4,#4              ;786
00037e  f8cdb020          STR      r11,[sp,#0x20]        ;786
                  |L5.898|
;;;1037           inputaddr+=4;
;;;1038           
;;;1039           /* Wait until the complete message has been processed */
;;;1040           counter = 0;
;;;1041           do
;;;1042           {
;;;1043             busystatus = CRYP_GetFlagStatus(CRYP_FLAG_BUSY);
000382  2010              MOVS     r0,#0x10
000384  f7fffffe          BL       CRYP_GetFlagStatus
;;;1044             counter++;
000388  9908              LDR      r1,[sp,#0x20]
00038a  1c49              ADDS     r1,r1,#1
;;;1045           }while ((counter != AESBUSY_TIMEOUT) && (busystatus != RESET));
00038c  9108              STR      r1,[sp,#0x20]
00038e  4541              CMP      r1,r8
000390  d003              BEQ      |L5.922|
000392  2800              CMP      r0,#0
000394  d1f5              BNE      |L5.898|
000396  e003              B        |L5.928|
                  |L5.920|
000398  e04a              B        |L5.1072|
                  |L5.922|
;;;1046   
;;;1047           if (busystatus != RESET)
00039a  b108              CBZ      r0,|L5.928|
;;;1048           {
;;;1049             status = ERROR;
00039c  2700              MOVS     r7,#0
00039e  e011              B        |L5.964|
                  |L5.928|
;;;1050           }
;;;1051           else
;;;1052           {
;;;1053             /* Wait until the OFNE flag is reset */
;;;1054             while(CRYP_GetFlagStatus(CRYP_FLAG_OFNE) == RESET)
0003a0  2004              MOVS     r0,#4
0003a2  f7fffffe          BL       CRYP_GetFlagStatus
0003a6  2800              CMP      r0,#0
0003a8  d0fa              BEQ      |L5.928|
;;;1055             {
;;;1056             }
;;;1057             
;;;1058             /* Read the Output block from the Output FIFO */
;;;1059             *(uint32_t*)(outputaddr) = CRYP_DataOut();
0003aa  f7fffffe          BL       CRYP_DataOut
;;;1060             outputaddr+=4;
;;;1061             *(uint32_t*)(outputaddr) = CRYP_DataOut();
0003ae  6028              STR      r0,[r5,#0]
0003b0  f7fffffe          BL       CRYP_DataOut
;;;1062             outputaddr+=4;
;;;1063             *(uint32_t*)(outputaddr) = CRYP_DataOut();
0003b4  6068              STR      r0,[r5,#4]
0003b6  f7fffffe          BL       CRYP_DataOut
;;;1064             outputaddr+=4;
;;;1065             *(uint32_t*)(outputaddr) = CRYP_DataOut();
0003ba  60a8              STR      r0,[r5,#8]
0003bc  f7fffffe          BL       CRYP_DataOut
0003c0  60e8              STR      r0,[r5,#0xc]
0003c2  3510              ADDS     r5,r5,#0x10
                  |L5.964|
0003c4  3610              ADDS     r6,r6,#0x10
                  |L5.966|
0003c6  4556              CMP      r6,r10                ;1023
0003c8  d201              BCS      |L5.974|
0003ca  2f00              CMP      r7,#0                 ;1023
0003cc  d1c0              BNE      |L5.848|
                  |L5.974|
;;;1066             outputaddr+=4;
;;;1067           }
;;;1068         }
;;;1069       }
;;;1070       
;;;1071       /***************************** final phase ********************************/
;;;1072       /* Select final phase */
;;;1073       CRYP_PhaseConfig(CRYP_Phase_Final);
0003ce  f44f3040          MOV      r0,#0x30000
0003d2  f7fffffe          BL       CRYP_PhaseConfig
;;;1074   
;;;1075       /* Enable Crypto processor */
;;;1076       CRYP_Cmd(ENABLE);
0003d6  2001              MOVS     r0,#1
0003d8  f7fffffe          BL       CRYP_Cmd
;;;1077       
;;;1078       if(CRYP_GetCmdStatus() == DISABLE)
0003dc  f7fffffe          BL       CRYP_GetCmdStatus
0003e0  2800              CMP      r0,#0
0003e2  d025              BEQ      |L5.1072|
;;;1079       {
;;;1080         /* The CRYP peripheral clock is not enabled or the device doesn't embedd 
;;;1081            the CRYP peripheral (please check the device sales type. */
;;;1082         return(ERROR);
;;;1083       }
;;;1084       
;;;1085       /* Write number of bits concatenated with header in the IN FIFO */
;;;1086       CRYP_DataIn(__REV(headerlength>>32));
0003e4  fa9bf08b          REV      r0,r11
0003e8  f7fffffe          BL       CRYP_DataIn
;;;1087       CRYP_DataIn(__REV(headerlength));
0003ec  9814              LDR      r0,[sp,#0x50]
0003ee  ba00              REV      r0,r0
0003f0  f7fffffe          BL       CRYP_DataIn
;;;1088       CRYP_DataIn(__REV(inputlength>>32));
0003f4  fa9bf08b          REV      r0,r11
0003f8  f7fffffe          BL       CRYP_DataIn
;;;1089       CRYP_DataIn(__REV(inputlength));
0003fc  9812              LDR      r0,[sp,#0x48]
0003fe  ba00              REV      r0,r0
000400  f7fffffe          BL       CRYP_DataIn
                  |L5.1028|
;;;1090       /* Wait until the OFNE flag is reset */
;;;1091       while(CRYP_GetFlagStatus(CRYP_FLAG_OFNE) == RESET)
000404  2004              MOVS     r0,#4
000406  f7fffffe          BL       CRYP_GetFlagStatus
00040a  2800              CMP      r0,#0
00040c  d0fa              BEQ      |L5.1028|
                  |L5.1038|
;;;1092       {
;;;1093       }
;;;1094       
;;;1095       tagaddr = (uint32_t)AuthTAG;
;;;1096       /* Read the Auth TAG in the IN FIFO */
;;;1097       *(uint32_t*)(tagaddr) = CRYP_DataOut();
00040e  9c27              LDR      r4,[sp,#0x9c]
000410  f7fffffe          BL       CRYP_DataOut
;;;1098       tagaddr+=4;
;;;1099       *(uint32_t*)(tagaddr) = CRYP_DataOut();
000414  6020              STR      r0,[r4,#0]
000416  f7fffffe          BL       CRYP_DataOut
;;;1100       tagaddr+=4;
;;;1101       *(uint32_t*)(tagaddr) = CRYP_DataOut();
00041a  6060              STR      r0,[r4,#4]
00041c  f7fffffe          BL       CRYP_DataOut
;;;1102       tagaddr+=4;
;;;1103       *(uint32_t*)(tagaddr) = CRYP_DataOut();
000420  60a0              STR      r0,[r4,#8]
000422  f7fffffe          BL       CRYP_DataOut
;;;1104       tagaddr+=4;
;;;1105     }
;;;1106     /* Disable Crypto */
;;;1107     CRYP_Cmd(DISABLE);
000426  60e0              STR      r0,[r4,#0xc]
000428  2000              MOVS     r0,#0
00042a  f7fffffe          BL       CRYP_Cmd
;;;1108   
;;;1109     return status;
00042e  4638              MOV      r0,r7
                  |L5.1072|
;;;1110   }
000430  b019              ADD      sp,sp,#0x64
000432  e8bd8ff0          POP      {r4-r11,pc}
;;;1111   
                          ENDP


;*** Start embedded assembler ***

#line 1 "..\\..\\..\\..\\Platform\\MCU\\STM32F4xx\\peripherals\\Libraries\\STM32F4xx_StdPeriph_Driver\\src\\stm32f4xx_cryp_aes.c"
	AREA ||.rev16_text||, CODE
	THUMB
	EXPORT |__asm___20_stm32f4xx_cryp_aes_c_c34cf6b8____REV16|
#line 114 "..\\..\\..\\..\\Platform\\Cortex-M4\\CMSIS\\core_cmInstr.h"
|__asm___20_stm32f4xx_cryp_aes_c_c34cf6b8____REV16| PROC
#line 115

 rev16 r0, r0
 bx lr
	ENDP
	AREA ||.revsh_text||, CODE
	THUMB
	EXPORT |__asm___20_stm32f4xx_cryp_aes_c_c34cf6b8____REVSH|
#line 128
|__asm___20_stm32f4xx_cryp_aes_c_c34cf6b8____REVSH| PROC
#line 129

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
