; generated by ARM C/C++ Compiler, 4.1 [Build 894]
; commandline ArmCC [--list --split_sections --debug -c --asm --interleave -o.\STM324xG_EVAL\stm32f4xx_usart.o --asm_dir=.\STM324xG_EVAL\ --list_dir=.\STM324xG_EVAL\ --depend=.\STM324xG_EVAL\stm32f4xx_usart.d --cpu=Cortex-M4.fp --apcs=interwork -O0 -Otime -I..\ -I..\..\..\Libraries\CMSIS\Device\ST\STM32F4xx\Include -I..\..\..\Libraries\STM32F4xx_StdPeriph_Driver\inc -I..\..\..\Utilities\STM32_EVAL\Common -I..\..\..\Utilities\STM32_EVAL\STM3240_41_G_EVAL -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -IC:\Keil\ARM\Inc\ST\STM32F4xx -D__MICROLIB -DUSE_STM324xG_EVAL -DSTM32F4XX -DUSE_STDPERIPH_DRIVER --omf_browse=.\STM324xG_EVAL\stm32f4xx_usart.crf ..\..\..\Libraries\STM32F4xx_StdPeriph_Driver\src\stm32f4xx_usart.c]
                          THUMB

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

                  USART_ClearFlag PROC
;;;1320     */
;;;1321   void USART_ClearFlag(USART_TypeDef* USARTx, uint16_t USART_FLAG)
000000  f4017200          AND      r2,r1,#0x200
;;;1322   {
;;;1323     /* Check the parameters */
;;;1324     assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;1325     assert_param(IS_USART_CLEAR_FLAG(USART_FLAG));
;;;1326   
;;;1327     /* The CTS flag is not available for UART4 and UART5 */
;;;1328     if ((USART_FLAG & USART_FLAG_CTS) == USART_FLAG_CTS)
000004  f5b27f00          CMP      r2,#0x200
000008  d100              BNE      |L1.12|
;;;1329     {
;;;1330       assert_param(IS_USART_1236_PERIPH(USARTx));
00000a  bf00              NOP      
                  |L1.12|
;;;1331     } 
;;;1332          
;;;1333     USARTx->SR = (uint16_t)~USART_FLAG;
00000c  43ca              MVNS     r2,r1
00000e  8002              STRH     r2,[r0,#0]
;;;1334   }
000010  4770              BX       lr
;;;1335   
                          ENDP


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

                  USART_ClearITPendingBit PROC
;;;1428     */
;;;1429   void USART_ClearITPendingBit(USART_TypeDef* USARTx, uint16_t USART_IT)
000000  b510              PUSH     {r4,lr}
;;;1430   {
;;;1431     uint16_t bitpos = 0x00, itmask = 0x00;
000002  2200              MOVS     r2,#0
000004  2300              MOVS     r3,#0
;;;1432     /* Check the parameters */
;;;1433     assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;1434     assert_param(IS_USART_CLEAR_IT(USART_IT)); 
;;;1435   
;;;1436     /* The CTS interrupt is not available for UART4 and UART5 */
;;;1437     if (USART_IT == USART_IT_CTS)
000006  f5a16410          SUB      r4,r1,#0x900
00000a  3c6a              SUBS     r4,r4,#0x6a
00000c  d100              BNE      |L2.16|
;;;1438     {
;;;1439       assert_param(IS_USART_1236_PERIPH(USARTx));
00000e  bf00              NOP      
                  |L2.16|
;;;1440     } 
;;;1441       
;;;1442     bitpos = USART_IT >> 0x08;
000010  120a              ASRS     r2,r1,#8
;;;1443     itmask = ((uint16_t)0x01 << (uint16_t)bitpos);
000012  2401              MOVS     r4,#1
000014  4094              LSLS     r4,r4,r2
000016  b2a3              UXTH     r3,r4
;;;1444     USARTx->SR = (uint16_t)~itmask;
000018  43dc              MVNS     r4,r3
00001a  8004              STRH     r4,[r0,#0]
;;;1445   }
00001c  bd10              POP      {r4,pc}
;;;1446   
                          ENDP


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

                  USART_ClockInit PROC
;;;359      */
;;;360    void USART_ClockInit(USART_TypeDef* USARTx, USART_ClockInitTypeDef* USART_ClockInitStruct)
000000  b510              PUSH     {r4,lr}
;;;361    {
000002  4602              MOV      r2,r0
;;;362      uint32_t tmpreg = 0x00;
000004  2000              MOVS     r0,#0
;;;363      /* Check the parameters */
;;;364      assert_param(IS_USART_1236_PERIPH(USARTx));
;;;365      assert_param(IS_USART_CLOCK(USART_ClockInitStruct->USART_Clock));
;;;366      assert_param(IS_USART_CPOL(USART_ClockInitStruct->USART_CPOL));
;;;367      assert_param(IS_USART_CPHA(USART_ClockInitStruct->USART_CPHA));
;;;368      assert_param(IS_USART_LASTBIT(USART_ClockInitStruct->USART_LastBit));
;;;369      
;;;370    /*---------------------------- USART CR2 Configuration -----------------------*/
;;;371      tmpreg = USARTx->CR2;
000006  8a10              LDRH     r0,[r2,#0x10]
;;;372      /* Clear CLKEN, CPOL, CPHA and LBCL bits */
;;;373      tmpreg &= (uint32_t)~((uint32_t)CR2_CLOCK_CLEAR_MASK);
000008  f4206070          BIC      r0,r0,#0xf00
;;;374      /* Configure the USART Clock, CPOL, CPHA and LastBit ------------*/
;;;375      /* Set CLKEN bit according to USART_Clock value */
;;;376      /* Set CPOL bit according to USART_CPOL value */
;;;377      /* Set CPHA bit according to USART_CPHA value */
;;;378      /* Set LBCL bit according to USART_LastBit value */
;;;379      tmpreg |= (uint32_t)USART_ClockInitStruct->USART_Clock | USART_ClockInitStruct->USART_CPOL | 
00000c  880b              LDRH     r3,[r1,#0]
00000e  884c              LDRH     r4,[r1,#2]
000010  4323              ORRS     r3,r3,r4
000012  888c              LDRH     r4,[r1,#4]
000014  4323              ORRS     r3,r3,r4
000016  88cc              LDRH     r4,[r1,#6]
000018  4323              ORRS     r3,r3,r4
00001a  4318              ORRS     r0,r0,r3
;;;380                     USART_ClockInitStruct->USART_CPHA | USART_ClockInitStruct->USART_LastBit;
;;;381      /* Write to USART CR2 */
;;;382      USARTx->CR2 = (uint16_t)tmpreg;
00001c  8210              STRH     r0,[r2,#0x10]
;;;383    }
00001e  bd10              POP      {r4,pc}
;;;384    
                          ENDP


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

                  USART_ClockStructInit PROC
;;;390      */
;;;391    void USART_ClockStructInit(USART_ClockInitTypeDef* USART_ClockInitStruct)
000000  2100              MOVS     r1,#0
;;;392    {
;;;393      /* USART_ClockInitStruct members default value */
;;;394      USART_ClockInitStruct->USART_Clock = USART_Clock_Disable;
000002  8001              STRH     r1,[r0,#0]
;;;395      USART_ClockInitStruct->USART_CPOL = USART_CPOL_Low;
000004  8041              STRH     r1,[r0,#2]
;;;396      USART_ClockInitStruct->USART_CPHA = USART_CPHA_1Edge;
000006  8081              STRH     r1,[r0,#4]
;;;397      USART_ClockInitStruct->USART_LastBit = USART_LastBit_Disable;
000008  80c1              STRH     r1,[r0,#6]
;;;398    }
00000a  4770              BX       lr
;;;399    
                          ENDP


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

                  USART_Cmd PROC
;;;407      */
;;;408    void USART_Cmd(USART_TypeDef* USARTx, FunctionalState NewState)
000000  b121              CBZ      r1,|L5.12|
;;;409    {
;;;410      /* Check the parameters */
;;;411      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;412      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;413      
;;;414      if (NewState != DISABLE)
;;;415      {
;;;416        /* Enable the selected USART by setting the UE bit in the CR1 register */
;;;417        USARTx->CR1 |= USART_CR1_UE;
000002  8982              LDRH     r2,[r0,#0xc]
000004  f4425200          ORR      r2,r2,#0x2000
000008  8182              STRH     r2,[r0,#0xc]
00000a  e004              B        |L5.22|
                  |L5.12|
;;;418      }
;;;419      else
;;;420      {
;;;421        /* Disable the selected USART by clearing the UE bit in the CR1 register */
;;;422        USARTx->CR1 &= (uint16_t)~((uint16_t)USART_CR1_UE);
00000c  8982              LDRH     r2,[r0,#0xc]
00000e  f64d73ff          MOV      r3,#0xdfff
000012  401a              ANDS     r2,r2,r3
000014  8182              STRH     r2,[r0,#0xc]
                  |L5.22|
;;;423      }
;;;424    }
000016  4770              BX       lr
;;;425    
                          ENDP


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

                  USART_DMACmd PROC
;;;1079     */
;;;1080   void USART_DMACmd(USART_TypeDef* USARTx, uint16_t USART_DMAReq, FunctionalState NewState)
000000  b510              PUSH     {r4,lr}
;;;1081   {
;;;1082     /* Check the parameters */
;;;1083     assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;1084     assert_param(IS_USART_DMAREQ(USART_DMAReq));  
;;;1085     assert_param(IS_FUNCTIONAL_STATE(NewState)); 
;;;1086   
;;;1087     if (NewState != DISABLE)
000002  b11a              CBZ      r2,|L6.12|
;;;1088     {
;;;1089       /* Enable the DMA transfer for selected requests by setting the DMAT and/or
;;;1090          DMAR bits in the USART CR3 register */
;;;1091       USARTx->CR3 |= USART_DMAReq;
000004  8a83              LDRH     r3,[r0,#0x14]
000006  430b              ORRS     r3,r3,r1
000008  8283              STRH     r3,[r0,#0x14]
00000a  e004              B        |L6.22|
                  |L6.12|
;;;1092     }
;;;1093     else
;;;1094     {
;;;1095       /* Disable the DMA transfer for selected requests by clearing the DMAT and/or
;;;1096          DMAR bits in the USART CR3 register */
;;;1097       USARTx->CR3 &= (uint16_t)~USART_DMAReq;
00000c  8a83              LDRH     r3,[r0,#0x14]
00000e  43cc              MVNS     r4,r1
000010  b2a4              UXTH     r4,r4
000012  4023              ANDS     r3,r3,r4
000014  8283              STRH     r3,[r0,#0x14]
                  |L6.22|
;;;1098     }
;;;1099   }
000016  bd10              POP      {r4,pc}
;;;1100   
                          ENDP


                          AREA ||i.USART_DeInit||, CODE, READONLY, ALIGN=2

                  USART_DeInit PROC
;;;177      */
;;;178    void USART_DeInit(USART_TypeDef* USARTx)
000000  b510              PUSH     {r4,lr}
;;;179    {
000002  4604              MOV      r4,r0
;;;180      /* Check the parameters */
;;;181      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;182    
;;;183      if (USARTx == USART1)
000004  4825              LDR      r0,|L7.156|
000006  4284              CMP      r4,r0
000008  d108              BNE      |L7.28|
;;;184      {
;;;185        RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, ENABLE);
00000a  2101              MOVS     r1,#1
00000c  2010              MOVS     r0,#0x10
00000e  f7fffffe          BL       RCC_APB2PeriphResetCmd
;;;186        RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, DISABLE);
000012  2100              MOVS     r1,#0
000014  2010              MOVS     r0,#0x10
000016  f7fffffe          BL       RCC_APB2PeriphResetCmd
00001a  e03e              B        |L7.154|
                  |L7.28|
;;;187      }
;;;188      else if (USARTx == USART2)
00001c  4820              LDR      r0,|L7.160|
00001e  4284              CMP      r4,r0
000020  d109              BNE      |L7.54|
;;;189      {
;;;190        RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, ENABLE);
000022  2101              MOVS     r1,#1
000024  0448              LSLS     r0,r1,#17
000026  f7fffffe          BL       RCC_APB1PeriphResetCmd
;;;191        RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, DISABLE);
00002a  2100              MOVS     r1,#0
00002c  f44f3000          MOV      r0,#0x20000
000030  f7fffffe          BL       RCC_APB1PeriphResetCmd
000034  e031              B        |L7.154|
                  |L7.54|
;;;192      }
;;;193      else if (USARTx == USART3)
000036  481b              LDR      r0,|L7.164|
000038  4284              CMP      r4,r0
00003a  d109              BNE      |L7.80|
;;;194      {
;;;195        RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, ENABLE);
00003c  2101              MOVS     r1,#1
00003e  0488              LSLS     r0,r1,#18
000040  f7fffffe          BL       RCC_APB1PeriphResetCmd
;;;196        RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, DISABLE);
000044  2100              MOVS     r1,#0
000046  f44f2080          MOV      r0,#0x40000
00004a  f7fffffe          BL       RCC_APB1PeriphResetCmd
00004e  e024              B        |L7.154|
                  |L7.80|
;;;197      }    
;;;198      else if (USARTx == UART4)
000050  4815              LDR      r0,|L7.168|
000052  4284              CMP      r4,r0
000054  d109              BNE      |L7.106|
;;;199      {
;;;200        RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, ENABLE);
000056  2101              MOVS     r1,#1
000058  04c8              LSLS     r0,r1,#19
00005a  f7fffffe          BL       RCC_APB1PeriphResetCmd
;;;201        RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, DISABLE);
00005e  2100              MOVS     r1,#0
000060  f44f2000          MOV      r0,#0x80000
000064  f7fffffe          BL       RCC_APB1PeriphResetCmd
000068  e017              B        |L7.154|
                  |L7.106|
;;;202      }
;;;203      else if (USARTx == UART5)
00006a  4810              LDR      r0,|L7.172|
00006c  4284              CMP      r4,r0
00006e  d109              BNE      |L7.132|
;;;204      {
;;;205        RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, ENABLE);
000070  2101              MOVS     r1,#1
000072  0508              LSLS     r0,r1,#20
000074  f7fffffe          BL       RCC_APB1PeriphResetCmd
;;;206        RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, DISABLE);
000078  2100              MOVS     r1,#0
00007a  f44f1080          MOV      r0,#0x100000
00007e  f7fffffe          BL       RCC_APB1PeriphResetCmd
000082  e00a              B        |L7.154|
                  |L7.132|
;;;207      }     
;;;208      else
;;;209      {
;;;210        if (USARTx == USART6)
000084  480a              LDR      r0,|L7.176|
000086  4284              CMP      r4,r0
000088  d107              BNE      |L7.154|
;;;211        { 
;;;212          RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART6, ENABLE);
00008a  2101              MOVS     r1,#1
00008c  2020              MOVS     r0,#0x20
00008e  f7fffffe          BL       RCC_APB2PeriphResetCmd
;;;213          RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART6, DISABLE);
000092  2100              MOVS     r1,#0
000094  2020              MOVS     r0,#0x20
000096  f7fffffe          BL       RCC_APB2PeriphResetCmd
                  |L7.154|
;;;214        }
;;;215      }
;;;216    }
00009a  bd10              POP      {r4,pc}
;;;217    
                          ENDP

                  |L7.156|
                          DCD      0x40011000
                  |L7.160|
                          DCD      0x40004400
                  |L7.164|
                          DCD      0x40004800
                  |L7.168|
                          DCD      0x40004c00
                  |L7.172|
                          DCD      0x40005000
                  |L7.176|
                          DCD      0x40011400

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

                  USART_GetFlagStatus PROC
;;;1271     */
;;;1272   FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG)
000000  4602              MOV      r2,r0
;;;1273   {
;;;1274     FlagStatus bitstatus = RESET;
000002  2000              MOVS     r0,#0
;;;1275     /* Check the parameters */
;;;1276     assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;1277     assert_param(IS_USART_FLAG(USART_FLAG));
;;;1278   
;;;1279     /* The CTS flag is not available for UART4 and UART5 */
;;;1280     if (USART_FLAG == USART_FLAG_CTS)
000004  f5b17f00          CMP      r1,#0x200
000008  d100              BNE      |L8.12|
;;;1281     {
;;;1282       assert_param(IS_USART_1236_PERIPH(USARTx));
00000a  bf00              NOP      
                  |L8.12|
;;;1283     } 
;;;1284       
;;;1285     if ((USARTx->SR & USART_FLAG) != (uint16_t)RESET)
00000c  8813              LDRH     r3,[r2,#0]
00000e  420b              TST      r3,r1
000010  d001              BEQ      |L8.22|
;;;1286     {
;;;1287       bitstatus = SET;
000012  2001              MOVS     r0,#1
000014  e000              B        |L8.24|
                  |L8.22|
;;;1288     }
;;;1289     else
;;;1290     {
;;;1291       bitstatus = RESET;
000016  2000              MOVS     r0,#0
                  |L8.24|
;;;1292     }
;;;1293     return bitstatus;
;;;1294   }
000018  4770              BX       lr
;;;1295   
                          ENDP


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

                  USART_GetITStatus PROC
;;;1354     */
;;;1355   ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint16_t USART_IT)
000000  b530              PUSH     {r4,r5,lr}
;;;1356   {
000002  4602              MOV      r2,r0
;;;1357     uint32_t bitpos = 0x00, itmask = 0x00, usartreg = 0x00;
000004  2400              MOVS     r4,#0
000006  2300              MOVS     r3,#0
000008  469c              MOV      r12,r3
;;;1358     ITStatus bitstatus = RESET;
00000a  2000              MOVS     r0,#0
;;;1359     /* Check the parameters */
;;;1360     assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;1361     assert_param(IS_USART_GET_IT(USART_IT)); 
;;;1362   
;;;1363     /* The CTS interrupt is not available for UART4 and UART5 */ 
;;;1364     if (USART_IT == USART_IT_CTS)
00000c  f5a16510          SUB      r5,r1,#0x900
000010  3d6a              SUBS     r5,r5,#0x6a
000012  d100              BNE      |L9.22|
;;;1365     {
;;;1366       assert_param(IS_USART_1236_PERIPH(USARTx));
000014  bf00              NOP      
                  |L9.22|
;;;1367     } 
;;;1368       
;;;1369     /* Get the USART register index */
;;;1370     usartreg = (((uint8_t)USART_IT) >> 0x05);
000016  f3c11c42          UBFX     r12,r1,#5,#3
;;;1371     /* Get the interrupt position */
;;;1372     itmask = USART_IT & IT_MASK;
00001a  f001031f          AND      r3,r1,#0x1f
;;;1373     itmask = (uint32_t)0x01 << itmask;
00001e  2501              MOVS     r5,#1
000020  fa05f303          LSL      r3,r5,r3
;;;1374     
;;;1375     if (usartreg == 0x01) /* The IT  is in CR1 register */
000024  f1bc0f01          CMP      r12,#1
000028  d102              BNE      |L9.48|
;;;1376     {
;;;1377       itmask &= USARTx->CR1;
00002a  8995              LDRH     r5,[r2,#0xc]
00002c  402b              ANDS     r3,r3,r5
00002e  e007              B        |L9.64|
                  |L9.48|
;;;1378     }
;;;1379     else if (usartreg == 0x02) /* The IT  is in CR2 register */
000030  f1bc0f02          CMP      r12,#2
000034  d102              BNE      |L9.60|
;;;1380     {
;;;1381       itmask &= USARTx->CR2;
000036  8a15              LDRH     r5,[r2,#0x10]
000038  402b              ANDS     r3,r3,r5
00003a  e001              B        |L9.64|
                  |L9.60|
;;;1382     }
;;;1383     else /* The IT  is in CR3 register */
;;;1384     {
;;;1385       itmask &= USARTx->CR3;
00003c  8a95              LDRH     r5,[r2,#0x14]
00003e  402b              ANDS     r3,r3,r5
                  |L9.64|
;;;1386     }
;;;1387     
;;;1388     bitpos = USART_IT >> 0x08;
000040  120c              ASRS     r4,r1,#8
;;;1389     bitpos = (uint32_t)0x01 << bitpos;
000042  2501              MOVS     r5,#1
000044  fa05f404          LSL      r4,r5,r4
;;;1390     bitpos &= USARTx->SR;
000048  8815              LDRH     r5,[r2,#0]
00004a  402c              ANDS     r4,r4,r5
;;;1391     if ((itmask != (uint16_t)RESET)&&(bitpos != (uint16_t)RESET))
00004c  b113              CBZ      r3,|L9.84|
00004e  b10c              CBZ      r4,|L9.84|
;;;1392     {
;;;1393       bitstatus = SET;
000050  2001              MOVS     r0,#1
000052  e000              B        |L9.86|
                  |L9.84|
;;;1394     }
;;;1395     else
;;;1396     {
;;;1397       bitstatus = RESET;
000054  2000              MOVS     r0,#0
                  |L9.86|
;;;1398     }
;;;1399     
;;;1400     return bitstatus;  
;;;1401   }
000056  bd30              POP      {r4,r5,pc}
;;;1402   
                          ENDP


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

                  USART_HalfDuplexCmd PROC
;;;815      */
;;;816    void USART_HalfDuplexCmd(USART_TypeDef* USARTx, FunctionalState NewState)
000000  b121              CBZ      r1,|L10.12|
;;;817    {
;;;818      /* Check the parameters */
;;;819      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;820      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;821      
;;;822      if (NewState != DISABLE)
;;;823      {
;;;824        /* Enable the Half-Duplex mode by setting the HDSEL bit in the CR3 register */
;;;825        USARTx->CR3 |= USART_CR3_HDSEL;
000002  8a82              LDRH     r2,[r0,#0x14]
000004  f0420208          ORR      r2,r2,#8
000008  8282              STRH     r2,[r0,#0x14]
00000a  e004              B        |L10.22|
                  |L10.12|
;;;826      }
;;;827      else
;;;828      {
;;;829        /* Disable the Half-Duplex mode by clearing the HDSEL bit in the CR3 register */
;;;830        USARTx->CR3 &= (uint16_t)~((uint16_t)USART_CR3_HDSEL);
00000c  8a82              LDRH     r2,[r0,#0x14]
00000e  f64f73f7          MOV      r3,#0xfff7
000012  401a              ANDS     r2,r2,r3
000014  8282              STRH     r2,[r0,#0x14]
                  |L10.22|
;;;831      }
;;;832    }
000016  4770              BX       lr
;;;833    
                          ENDP


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

                  USART_ITConfig PROC
;;;1207     */
;;;1208   void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT, FunctionalState NewState)
000000  b570              PUSH     {r4-r6,lr}
;;;1209   {
000002  4603              MOV      r3,r0
;;;1210     uint32_t usartreg = 0x00, itpos = 0x00, itmask = 0x00;
000004  2400              MOVS     r4,#0
000006  46a4              MOV      r12,r4
000008  2500              MOVS     r5,#0
;;;1211     uint32_t usartxbase = 0x00;
00000a  2000              MOVS     r0,#0
;;;1212     /* Check the parameters */
;;;1213     assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;1214     assert_param(IS_USART_CONFIG_IT(USART_IT));
;;;1215     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1216   
;;;1217     /* The CTS interrupt is not available for UART4 and UART5 */
;;;1218     if (USART_IT == USART_IT_CTS)
00000c  f5a16610          SUB      r6,r1,#0x900
000010  3e6a              SUBS     r6,r6,#0x6a
000012  d100              BNE      |L11.22|
;;;1219     {
;;;1220       assert_param(IS_USART_1236_PERIPH(USARTx));
000014  bf00              NOP      
                  |L11.22|
;;;1221     } 
;;;1222       
;;;1223     usartxbase = (uint32_t)USARTx;
000016  4618              MOV      r0,r3
;;;1224   
;;;1225     /* Get the USART register index */
;;;1226     usartreg = (((uint8_t)USART_IT) >> 0x05);
000018  f3c11442          UBFX     r4,r1,#5,#3
;;;1227   
;;;1228     /* Get the interrupt position */
;;;1229     itpos = USART_IT & IT_MASK;
00001c  f0010c1f          AND      r12,r1,#0x1f
;;;1230     itmask = (((uint32_t)0x01) << itpos);
000020  2601              MOVS     r6,#1
000022  fa06f50c          LSL      r5,r6,r12
;;;1231       
;;;1232     if (usartreg == 0x01) /* The IT is in CR1 register */
000026  2c01              CMP      r4,#1
000028  d101              BNE      |L11.46|
;;;1233     {
;;;1234       usartxbase += 0x0C;
00002a  300c              ADDS     r0,r0,#0xc
00002c  e004              B        |L11.56|
                  |L11.46|
;;;1235     }
;;;1236     else if (usartreg == 0x02) /* The IT is in CR2 register */
00002e  2c02              CMP      r4,#2
000030  d101              BNE      |L11.54|
;;;1237     {
;;;1238       usartxbase += 0x10;
000032  3010              ADDS     r0,r0,#0x10
000034  e000              B        |L11.56|
                  |L11.54|
;;;1239     }
;;;1240     else /* The IT is in CR3 register */
;;;1241     {
;;;1242       usartxbase += 0x14; 
000036  3014              ADDS     r0,r0,#0x14
                  |L11.56|
;;;1243     }
;;;1244     if (NewState != DISABLE)
000038  b11a              CBZ      r2,|L11.66|
;;;1245     {
;;;1246       *(__IO uint32_t*)usartxbase  |= itmask;
00003a  6806              LDR      r6,[r0,#0]
00003c  432e              ORRS     r6,r6,r5
00003e  6006              STR      r6,[r0,#0]
000040  e002              B        |L11.72|
                  |L11.66|
;;;1247     }
;;;1248     else
;;;1249     {
;;;1250       *(__IO uint32_t*)usartxbase &= ~itmask;
000042  6806              LDR      r6,[r0,#0]
000044  43ae              BICS     r6,r6,r5
000046  6006              STR      r6,[r0,#0]
                  |L11.72|
;;;1251     }
;;;1252   }
000048  bd70              POP      {r4-r6,pc}
;;;1253   
                          ENDP


                          AREA ||i.USART_Init||, CODE, READONLY, ALIGN=2

                  USART_Init PROC
;;;226      */
;;;227    void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct)
000000  e92d47ff          PUSH     {r0-r10,lr}
;;;228    {
000004  4605              MOV      r5,r0
000006  460e              MOV      r6,r1
;;;229      uint32_t tmpreg = 0x00, apbclock = 0x00;
000008  2400              MOVS     r4,#0
00000a  46a1              MOV      r9,r4
;;;230      uint32_t integerdivider = 0x00;
00000c  bf00              NOP      
;;;231      uint32_t fractionaldivider = 0x00;
00000e  46a0              MOV      r8,r4
;;;232      RCC_ClocksTypeDef RCC_ClocksStatus;
;;;233    
;;;234      /* Check the parameters */
;;;235      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;236      assert_param(IS_USART_BAUDRATE(USART_InitStruct->USART_BaudRate));  
;;;237      assert_param(IS_USART_WORD_LENGTH(USART_InitStruct->USART_WordLength));
;;;238      assert_param(IS_USART_STOPBITS(USART_InitStruct->USART_StopBits));
;;;239      assert_param(IS_USART_PARITY(USART_InitStruct->USART_Parity));
;;;240      assert_param(IS_USART_MODE(USART_InitStruct->USART_Mode));
;;;241      assert_param(IS_USART_HARDWARE_FLOW_CONTROL(USART_InitStruct->USART_HardwareFlowControl));
;;;242    
;;;243      /* The hardware flow control is available only for USART1, USART2, USART3 and USART6 */
;;;244      if (USART_InitStruct->USART_HardwareFlowControl != USART_HardwareFlowControl_None)
000010  89b0              LDRH     r0,[r6,#0xc]
000012  b100              CBZ      r0,|L12.22|
;;;245      {
;;;246        assert_param(IS_USART_1236_PERIPH(USARTx));
000014  bf00              NOP      
                  |L12.22|
;;;247      }
;;;248    
;;;249    /*---------------------------- USART CR2 Configuration -----------------------*/
;;;250      tmpreg = USARTx->CR2;
000016  8a2c              LDRH     r4,[r5,#0x10]
;;;251    
;;;252      /* Clear STOP[13:12] bits */
;;;253      tmpreg &= (uint32_t)~((uint32_t)USART_CR2_STOP);
000018  f4245440          BIC      r4,r4,#0x3000
;;;254    
;;;255      /* Configure the USART Stop Bits, Clock, CPOL, CPHA and LastBit :
;;;256          Set STOP[13:12] bits according to USART_StopBits value */
;;;257      tmpreg |= (uint32_t)USART_InitStruct->USART_StopBits;
00001c  88f0              LDRH     r0,[r6,#6]
00001e  4304              ORRS     r4,r4,r0
;;;258      
;;;259      /* Write to USART CR2 */
;;;260      USARTx->CR2 = (uint16_t)tmpreg;
000020  822c              STRH     r4,[r5,#0x10]
;;;261    
;;;262    /*---------------------------- USART CR1 Configuration -----------------------*/
;;;263      tmpreg = USARTx->CR1;
000022  89ac              LDRH     r4,[r5,#0xc]
;;;264    
;;;265      /* Clear M, PCE, PS, TE and RE bits */
;;;266      tmpreg &= (uint32_t)~((uint32_t)CR1_CLEAR_MASK);
000024  f241600c          MOV      r0,#0x160c
000028  4384              BICS     r4,r4,r0
;;;267    
;;;268      /* Configure the USART Word Length, Parity and mode: 
;;;269         Set the M bits according to USART_WordLength value 
;;;270         Set PCE and PS bits according to USART_Parity value
;;;271         Set TE and RE bits according to USART_Mode value */
;;;272      tmpreg |= (uint32_t)USART_InitStruct->USART_WordLength | USART_InitStruct->USART_Parity |
00002a  88b0              LDRH     r0,[r6,#4]
00002c  8931              LDRH     r1,[r6,#8]
00002e  4308              ORRS     r0,r0,r1
000030  8971              LDRH     r1,[r6,#0xa]
000032  4308              ORRS     r0,r0,r1
000034  4304              ORRS     r4,r4,r0
;;;273                USART_InitStruct->USART_Mode;
;;;274    
;;;275      /* Write to USART CR1 */
;;;276      USARTx->CR1 = (uint16_t)tmpreg;
000036  81ac              STRH     r4,[r5,#0xc]
;;;277    
;;;278    /*---------------------------- USART CR3 Configuration -----------------------*/  
;;;279      tmpreg = USARTx->CR3;
000038  8aac              LDRH     r4,[r5,#0x14]
;;;280    
;;;281      /* Clear CTSE and RTSE bits */
;;;282      tmpreg &= (uint32_t)~((uint32_t)CR3_CLEAR_MASK);
00003a  f4247440          BIC      r4,r4,#0x300
;;;283    
;;;284      /* Configure the USART HFC : 
;;;285          Set CTSE and RTSE bits according to USART_HardwareFlowControl value */
;;;286      tmpreg |= USART_InitStruct->USART_HardwareFlowControl;
00003e  89b0              LDRH     r0,[r6,#0xc]
000040  4304              ORRS     r4,r4,r0
;;;287    
;;;288      /* Write to USART CR3 */
;;;289      USARTx->CR3 = (uint16_t)tmpreg;
000042  82ac              STRH     r4,[r5,#0x14]
;;;290    
;;;291    /*---------------------------- USART BRR Configuration -----------------------*/
;;;292      /* Configure the USART Baud Rate */
;;;293      RCC_GetClocksFreq(&RCC_ClocksStatus);
000044  4668              MOV      r0,sp
000046  f7fffffe          BL       RCC_GetClocksFreq
;;;294    
;;;295      if ((USARTx == USART1) || (USARTx == USART6))
00004a  4820              LDR      r0,|L12.204|
00004c  4285              CMP      r5,r0
00004e  d002              BEQ      |L12.86|
000050  481f              LDR      r0,|L12.208|
000052  4285              CMP      r5,r0
000054  d102              BNE      |L12.92|
                  |L12.86|
;;;296      {
;;;297        apbclock = RCC_ClocksStatus.PCLK2_Frequency;
000056  f8dd900c          LDR      r9,[sp,#0xc]
00005a  e001              B        |L12.96|
                  |L12.92|
;;;298      }
;;;299      else
;;;300      {
;;;301        apbclock = RCC_ClocksStatus.PCLK1_Frequency;
00005c  f8dd9008          LDR      r9,[sp,#8]
                  |L12.96|
;;;302      }
;;;303      
;;;304      /* Determine the integer part */
;;;305      if ((USARTx->CR1 & USART_CR1_OVER8) != 0)
000060  89a8              LDRH     r0,[r5,#0xc]
000062  f4104f00          TST      r0,#0x8000
000066  d008              BEQ      |L12.122|
;;;306      {
;;;307        /* Integer part computing in case Oversampling mode is 8 Samples */
;;;308        integerdivider = ((25 * apbclock) / (2 * (USART_InitStruct->USART_BaudRate)));    
000068  eb0900c9          ADD      r0,r9,r9,LSL #3
00006c  eb001009          ADD      r0,r0,r9,LSL #4
000070  6831              LDR      r1,[r6,#0]
000072  0049              LSLS     r1,r1,#1
000074  fbb0f7f1          UDIV     r7,r0,r1
000078  e007              B        |L12.138|
                  |L12.122|
;;;309      }
;;;310      else /* if ((USARTx->CR1 & USART_CR1_OVER8) == 0) */
;;;311      {
;;;312        /* Integer part computing in case Oversampling mode is 16 Samples */
;;;313        integerdivider = ((25 * apbclock) / (4 * (USART_InitStruct->USART_BaudRate)));    
00007a  eb0900c9          ADD      r0,r9,r9,LSL #3
00007e  eb001009          ADD      r0,r0,r9,LSL #4
000082  6831              LDR      r1,[r6,#0]
000084  0089              LSLS     r1,r1,#2
000086  fbb0f7f1          UDIV     r7,r0,r1
                  |L12.138|
;;;314      }
;;;315      tmpreg = (integerdivider / 100) << 4;
00008a  2064              MOVS     r0,#0x64
00008c  fbb7f0f0          UDIV     r0,r7,r0
000090  0104              LSLS     r4,r0,#4
;;;316    
;;;317      /* Determine the fractional part */
;;;318      fractionaldivider = integerdivider - (100 * (tmpreg >> 4));
000092  0920              LSRS     r0,r4,#4
000094  2164              MOVS     r1,#0x64
000096  fb017810          MLS      r8,r1,r0,r7
;;;319    
;;;320      /* Implement the fractional part in the register */
;;;321      if ((USARTx->CR1 & USART_CR1_OVER8) != 0)
00009a  89a8              LDRH     r0,[r5,#0xc]
00009c  f4104f00          TST      r0,#0x8000
0000a0  d008              BEQ      |L12.180|
;;;322      {
;;;323        tmpreg |= ((((fractionaldivider * 8) + 50) / 100)) & ((uint8_t)0x07);
0000a2  2032              MOVS     r0,#0x32
0000a4  eb0000c8          ADD      r0,r0,r8,LSL #3
0000a8  fbb0f0f1          UDIV     r0,r0,r1
0000ac  f0000007          AND      r0,r0,#7
0000b0  4304              ORRS     r4,r4,r0
0000b2  e008              B        |L12.198|
                  |L12.180|
;;;324      }
;;;325      else /* if ((USARTx->CR1 & USART_CR1_OVER8) == 0) */
;;;326      {
;;;327        tmpreg |= ((((fractionaldivider * 16) + 50) / 100)) & ((uint8_t)0x0F);
0000b4  2032              MOVS     r0,#0x32
0000b6  eb001008          ADD      r0,r0,r8,LSL #4
0000ba  2164              MOVS     r1,#0x64
0000bc  fbb0f0f1          UDIV     r0,r0,r1
0000c0  f000000f          AND      r0,r0,#0xf
0000c4  4304              ORRS     r4,r4,r0
                  |L12.198|
;;;328      }
;;;329      
;;;330      /* Write to USART BRR register */
;;;331      USARTx->BRR = (uint16_t)tmpreg;
0000c6  812c              STRH     r4,[r5,#8]
;;;332    }
0000c8  e8bd87ff          POP      {r0-r10,pc}
;;;333    
                          ENDP

                  |L12.204|
                          DCD      0x40011000
                  |L12.208|
                          DCD      0x40011400

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

                  USART_IrDACmd PROC
;;;1033     */
;;;1034   void USART_IrDACmd(USART_TypeDef* USARTx, FunctionalState NewState)
000000  b121              CBZ      r1,|L13.12|
;;;1035   {
;;;1036     /* Check the parameters */
;;;1037     assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;1038     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1039       
;;;1040     if (NewState != DISABLE)
;;;1041     {
;;;1042       /* Enable the IrDA mode by setting the IREN bit in the CR3 register */
;;;1043       USARTx->CR3 |= USART_CR3_IREN;
000002  8a82              LDRH     r2,[r0,#0x14]
000004  f0420202          ORR      r2,r2,#2
000008  8282              STRH     r2,[r0,#0x14]
00000a  e004              B        |L13.22|
                  |L13.12|
;;;1044     }
;;;1045     else
;;;1046     {
;;;1047       /* Disable the IrDA mode by clearing the IREN bit in the CR3 register */
;;;1048       USARTx->CR3 &= (uint16_t)~((uint16_t)USART_CR3_IREN);
00000c  8a82              LDRH     r2,[r0,#0x14]
00000e  f64f73fd          MOV      r3,#0xfffd
000012  401a              ANDS     r2,r2,r3
000014  8282              STRH     r2,[r0,#0x14]
                  |L13.22|
;;;1049     }
;;;1050   }
000016  4770              BX       lr
;;;1051   
                          ENDP


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

                  USART_IrDAConfig PROC
;;;1015     */
;;;1016   void USART_IrDAConfig(USART_TypeDef* USARTx, uint16_t USART_IrDAMode)
000000  8a82              LDRH     r2,[r0,#0x14]
;;;1017   {
;;;1018     /* Check the parameters */
;;;1019     assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;1020     assert_param(IS_USART_IRDA_MODE(USART_IrDAMode));
;;;1021       
;;;1022     USARTx->CR3 &= (uint16_t)~((uint16_t)USART_CR3_IRLP);
000002  f64f73fb          MOV      r3,#0xfffb
000006  401a              ANDS     r2,r2,r3
000008  8282              STRH     r2,[r0,#0x14]
;;;1023     USARTx->CR3 |= USART_IrDAMode;
00000a  8a82              LDRH     r2,[r0,#0x14]
00000c  430a              ORRS     r2,r2,r1
00000e  8282              STRH     r2,[r0,#0x14]
;;;1024   }
000010  4770              BX       lr
;;;1025   
                          ENDP


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

                  USART_LINBreakDetectLengthConfig PROC
;;;720      */
;;;721    void USART_LINBreakDetectLengthConfig(USART_TypeDef* USARTx, uint16_t USART_LINBreakDetectLength)
000000  8a02              LDRH     r2,[r0,#0x10]
;;;722    {
;;;723      /* Check the parameters */
;;;724      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;725      assert_param(IS_USART_LIN_BREAK_DETECT_LENGTH(USART_LINBreakDetectLength));
;;;726      
;;;727      USARTx->CR2 &= (uint16_t)~((uint16_t)USART_CR2_LBDL);
000002  f64f73df          MOV      r3,#0xffdf
000006  401a              ANDS     r2,r2,r3
000008  8202              STRH     r2,[r0,#0x10]
;;;728      USARTx->CR2 |= USART_LINBreakDetectLength;  
00000a  8a02              LDRH     r2,[r0,#0x10]
00000c  430a              ORRS     r2,r2,r1
00000e  8202              STRH     r2,[r0,#0x10]
;;;729    }
000010  4770              BX       lr
;;;730    
                          ENDP


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

                  USART_LINCmd PROC
;;;738      */
;;;739    void USART_LINCmd(USART_TypeDef* USARTx, FunctionalState NewState)
000000  b121              CBZ      r1,|L16.12|
;;;740    {
;;;741      /* Check the parameters */
;;;742      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;743      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;744      
;;;745      if (NewState != DISABLE)
;;;746      {
;;;747        /* Enable the LIN mode by setting the LINEN bit in the CR2 register */
;;;748        USARTx->CR2 |= USART_CR2_LINEN;
000002  8a02              LDRH     r2,[r0,#0x10]
000004  f4424280          ORR      r2,r2,#0x4000
000008  8202              STRH     r2,[r0,#0x10]
00000a  e004              B        |L16.22|
                  |L16.12|
;;;749      }
;;;750      else
;;;751      {
;;;752        /* Disable the LIN mode by clearing the LINEN bit in the CR2 register */
;;;753        USARTx->CR2 &= (uint16_t)~((uint16_t)USART_CR2_LINEN);
00000c  8a02              LDRH     r2,[r0,#0x10]
00000e  f64b73ff          MOV      r3,#0xbfff
000012  401a              ANDS     r2,r2,r3
000014  8202              STRH     r2,[r0,#0x10]
                  |L16.22|
;;;754      }
;;;755    }
000016  4770              BX       lr
;;;756    
                          ENDP


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

                  USART_OneBitMethodCmd PROC
;;;480      */
;;;481    void USART_OneBitMethodCmd(USART_TypeDef* USARTx, FunctionalState NewState)
000000  b121              CBZ      r1,|L17.12|
;;;482    {
;;;483      /* Check the parameters */
;;;484      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;485      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;486      
;;;487      if (NewState != DISABLE)
;;;488      {
;;;489        /* Enable the one bit method by setting the ONEBITE bit in the CR3 register */
;;;490        USARTx->CR3 |= USART_CR3_ONEBIT;
000002  8a82              LDRH     r2,[r0,#0x14]
000004  f4426200          ORR      r2,r2,#0x800
000008  8282              STRH     r2,[r0,#0x14]
00000a  e004              B        |L17.22|
                  |L17.12|
;;;491      }
;;;492      else
;;;493      {
;;;494        /* Disable the one bit method by clearing the ONEBITE bit in the CR3 register */
;;;495        USARTx->CR3 &= (uint16_t)~((uint16_t)USART_CR3_ONEBIT);
00000c  8a82              LDRH     r2,[r0,#0x14]
00000e  f24f73ff          MOV      r3,#0xf7ff
000012  401a              ANDS     r2,r2,r3
000014  8282              STRH     r2,[r0,#0x14]
                  |L17.22|
;;;496      }
;;;497    }
000016  4770              BX       lr
;;;498    
                          ENDP


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

                  USART_OverSampling8Cmd PROC
;;;454      */
;;;455    void USART_OverSampling8Cmd(USART_TypeDef* USARTx, FunctionalState NewState)
000000  b121              CBZ      r1,|L18.12|
;;;456    {
;;;457      /* Check the parameters */
;;;458      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;459      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;460      
;;;461      if (NewState != DISABLE)
;;;462      {
;;;463        /* Enable the 8x Oversampling mode by setting the OVER8 bit in the CR1 register */
;;;464        USARTx->CR1 |= USART_CR1_OVER8;
000002  8982              LDRH     r2,[r0,#0xc]
000004  f4424200          ORR      r2,r2,#0x8000
000008  8182              STRH     r2,[r0,#0xc]
00000a  e003              B        |L18.20|
                  |L18.12|
;;;465      }
;;;466      else
;;;467      {
;;;468        /* Disable the 8x Oversampling mode by clearing the OVER8 bit in the CR1 register */
;;;469        USARTx->CR1 &= (uint16_t)~((uint16_t)USART_CR1_OVER8);
00000c  8982              LDRH     r2,[r0,#0xc]
00000e  f3c2020e          UBFX     r2,r2,#0,#15
000012  8182              STRH     r2,[r0,#0xc]
                  |L18.20|
;;;470      }
;;;471    }  
000014  4770              BX       lr
;;;472    
                          ENDP


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

                  USART_ReceiveData PROC
;;;553      */
;;;554    uint16_t USART_ReceiveData(USART_TypeDef* USARTx)
000000  4601              MOV      r1,r0
;;;555    {
;;;556      /* Check the parameters */
;;;557      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;558      
;;;559      /* Receive Data */
;;;560      return (uint16_t)(USARTx->DR & (uint16_t)0x01FF);
000002  8888              LDRH     r0,[r1,#4]
000004  f3c00008          UBFX     r0,r0,#0,#9
;;;561    }
000008  4770              BX       lr
;;;562    
                          ENDP


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

                  USART_ReceiverWakeUpCmd PROC
;;;624      */
;;;625    void USART_ReceiverWakeUpCmd(USART_TypeDef* USARTx, FunctionalState NewState)
000000  b121              CBZ      r1,|L20.12|
;;;626    {
;;;627      /* Check the parameters */
;;;628      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;629      assert_param(IS_FUNCTIONAL_STATE(NewState)); 
;;;630      
;;;631      if (NewState != DISABLE)
;;;632      {
;;;633        /* Enable the USART mute mode  by setting the RWU bit in the CR1 register */
;;;634        USARTx->CR1 |= USART_CR1_RWU;
000002  8982              LDRH     r2,[r0,#0xc]
000004  f0420202          ORR      r2,r2,#2
000008  8182              STRH     r2,[r0,#0xc]
00000a  e004              B        |L20.22|
                  |L20.12|
;;;635      }
;;;636      else
;;;637      {
;;;638        /* Disable the USART mute mode by clearing the RWU bit in the CR1 register */
;;;639        USARTx->CR1 &= (uint16_t)~((uint16_t)USART_CR1_RWU);
00000c  8982              LDRH     r2,[r0,#0xc]
00000e  f64f73fd          MOV      r3,#0xfffd
000012  401a              ANDS     r2,r2,r3
000014  8182              STRH     r2,[r0,#0xc]
                  |L20.22|
;;;640      }
;;;641    }
000016  4770              BX       lr
;;;642    /**
                          ENDP


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

                  USART_SendBreak PROC
;;;762      */
;;;763    void USART_SendBreak(USART_TypeDef* USARTx)
000000  8981              LDRH     r1,[r0,#0xc]
;;;764    {
;;;765      /* Check the parameters */
;;;766      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;767      
;;;768      /* Send break characters */
;;;769      USARTx->CR1 |= USART_CR1_SBK;
000002  f0410101          ORR      r1,r1,#1
000006  8181              STRH     r1,[r0,#0xc]
;;;770    }
000008  4770              BX       lr
;;;771    
                          ENDP


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

                  USART_SendData PROC
;;;537      */
;;;538    void USART_SendData(USART_TypeDef* USARTx, uint16_t Data)
000000  f3c10208          UBFX     r2,r1,#0,#9
;;;539    {
;;;540      /* Check the parameters */
;;;541      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;542      assert_param(IS_USART_DATA(Data)); 
;;;543        
;;;544      /* Transmit Data */
;;;545      USARTx->DR = (Data & (uint16_t)0x01FF);
000004  8082              STRH     r2,[r0,#4]
;;;546    }
000006  4770              BX       lr
;;;547    
                          ENDP


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

                  USART_SetAddress PROC
;;;604      */
;;;605    void USART_SetAddress(USART_TypeDef* USARTx, uint8_t USART_Address)
000000  8a02              LDRH     r2,[r0,#0x10]
;;;606    {
;;;607      /* Check the parameters */
;;;608      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;609      assert_param(IS_USART_ADDRESS(USART_Address)); 
;;;610        
;;;611      /* Clear the USART address */
;;;612      USARTx->CR2 &= (uint16_t)~((uint16_t)USART_CR2_ADD);
000002  f64f73f0          MOV      r3,#0xfff0
000006  401a              ANDS     r2,r2,r3
000008  8202              STRH     r2,[r0,#0x10]
;;;613      /* Set the USART address node */
;;;614      USARTx->CR2 |= USART_Address;
00000a  8a02              LDRH     r2,[r0,#0x10]
00000c  430a              ORRS     r2,r2,r1
00000e  8202              STRH     r2,[r0,#0x10]
;;;615    }
000010  4770              BX       lr
;;;616    
                          ENDP


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

                  USART_SetGuardTime PROC
;;;900      */
;;;901    void USART_SetGuardTime(USART_TypeDef* USARTx, uint8_t USART_GuardTime)
000000  8b02              LDRH     r2,[r0,#0x18]
;;;902    {    
;;;903      /* Check the parameters */
;;;904      assert_param(IS_USART_1236_PERIPH(USARTx));
;;;905      
;;;906      /* Clear the USART Guard time */
;;;907      USARTx->GTPR &= USART_GTPR_PSC;
000002  b2d2              UXTB     r2,r2
000004  8302              STRH     r2,[r0,#0x18]
;;;908      /* Set the USART guard time */
;;;909      USARTx->GTPR |= (uint16_t)((uint16_t)USART_GuardTime << 0x08);
000006  8b02              LDRH     r2,[r0,#0x18]
000008  ea422201          ORR      r2,r2,r1,LSL #8
00000c  8302              STRH     r2,[r0,#0x18]
;;;910    }
00000e  4770              BX       lr
;;;911    
                          ENDP


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

                  USART_SetPrescaler PROC
;;;433      */
;;;434    void USART_SetPrescaler(USART_TypeDef* USARTx, uint8_t USART_Prescaler)
000000  8b02              LDRH     r2,[r0,#0x18]
;;;435    { 
;;;436      /* Check the parameters */
;;;437      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;438      
;;;439      /* Clear the USART prescaler */
;;;440      USARTx->GTPR &= USART_GTPR_GT;
000002  f402427f          AND      r2,r2,#0xff00
000006  8302              STRH     r2,[r0,#0x18]
;;;441      /* Set the USART prescaler */
;;;442      USARTx->GTPR |= USART_Prescaler;
000008  8b02              LDRH     r2,[r0,#0x18]
00000a  430a              ORRS     r2,r2,r1
00000c  8302              STRH     r2,[r0,#0x18]
;;;443    }
00000e  4770              BX       lr
;;;444    
                          ENDP


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

                  USART_SmartCardCmd PROC
;;;919      */
;;;920    void USART_SmartCardCmd(USART_TypeDef* USARTx, FunctionalState NewState)
000000  b121              CBZ      r1,|L26.12|
;;;921    {
;;;922      /* Check the parameters */
;;;923      assert_param(IS_USART_1236_PERIPH(USARTx));
;;;924      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;925      if (NewState != DISABLE)
;;;926      {
;;;927        /* Enable the SC mode by setting the SCEN bit in the CR3 register */
;;;928        USARTx->CR3 |= USART_CR3_SCEN;
000002  8a82              LDRH     r2,[r0,#0x14]
000004  f0420220          ORR      r2,r2,#0x20
000008  8282              STRH     r2,[r0,#0x14]
00000a  e004              B        |L26.22|
                  |L26.12|
;;;929      }
;;;930      else
;;;931      {
;;;932        /* Disable the SC mode by clearing the SCEN bit in the CR3 register */
;;;933        USARTx->CR3 &= (uint16_t)~((uint16_t)USART_CR3_SCEN);
00000c  8a82              LDRH     r2,[r0,#0x14]
00000e  f64f73df          MOV      r3,#0xffdf
000012  401a              ANDS     r2,r2,r3
000014  8282              STRH     r2,[r0,#0x14]
                  |L26.22|
;;;934      }
;;;935    }
000016  4770              BX       lr
;;;936    
                          ENDP


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

                  USART_SmartCardNACKCmd PROC
;;;944      */
;;;945    void USART_SmartCardNACKCmd(USART_TypeDef* USARTx, FunctionalState NewState)
000000  b121              CBZ      r1,|L27.12|
;;;946    {
;;;947      /* Check the parameters */
;;;948      assert_param(IS_USART_1236_PERIPH(USARTx)); 
;;;949      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;950      if (NewState != DISABLE)
;;;951      {
;;;952        /* Enable the NACK transmission by setting the NACK bit in the CR3 register */
;;;953        USARTx->CR3 |= USART_CR3_NACK;
000002  8a82              LDRH     r2,[r0,#0x14]
000004  f0420210          ORR      r2,r2,#0x10
000008  8282              STRH     r2,[r0,#0x14]
00000a  e004              B        |L27.22|
                  |L27.12|
;;;954      }
;;;955      else
;;;956      {
;;;957        /* Disable the NACK transmission by clearing the NACK bit in the CR3 register */
;;;958        USARTx->CR3 &= (uint16_t)~((uint16_t)USART_CR3_NACK);
00000c  8a82              LDRH     r2,[r0,#0x14]
00000e  f64f73ef          MOV      r3,#0xffef
000012  401a              ANDS     r2,r2,r3
000014  8282              STRH     r2,[r0,#0x14]
                  |L27.22|
;;;959      }
;;;960    }
000016  4770              BX       lr
;;;961    
                          ENDP


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

                  USART_StructInit PROC
;;;339      */
;;;340    void USART_StructInit(USART_InitTypeDef* USART_InitStruct)
000000  f44f5116          MOV      r1,#0x2580
;;;341    {
;;;342      /* USART_InitStruct members default value */
;;;343      USART_InitStruct->USART_BaudRate = 9600;
000004  6001              STR      r1,[r0,#0]
;;;344      USART_InitStruct->USART_WordLength = USART_WordLength_8b;
000006  2100              MOVS     r1,#0
000008  8081              STRH     r1,[r0,#4]
;;;345      USART_InitStruct->USART_StopBits = USART_StopBits_1;
00000a  80c1              STRH     r1,[r0,#6]
;;;346      USART_InitStruct->USART_Parity = USART_Parity_No ;
00000c  8101              STRH     r1,[r0,#8]
;;;347      USART_InitStruct->USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
00000e  210c              MOVS     r1,#0xc
000010  8141              STRH     r1,[r0,#0xa]
;;;348      USART_InitStruct->USART_HardwareFlowControl = USART_HardwareFlowControl_None;  
000012  2100              MOVS     r1,#0
000014  8181              STRH     r1,[r0,#0xc]
;;;349    }
000016  4770              BX       lr
;;;350    
                          ENDP


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

                  USART_WakeUpConfig PROC
;;;651      */
;;;652    void USART_WakeUpConfig(USART_TypeDef* USARTx, uint16_t USART_WakeUp)
000000  8982              LDRH     r2,[r0,#0xc]
;;;653    {
;;;654      /* Check the parameters */
;;;655      assert_param(IS_USART_ALL_PERIPH(USARTx));
;;;656      assert_param(IS_USART_WAKEUP(USART_WakeUp));
;;;657      
;;;658      USARTx->CR1 &= (uint16_t)~((uint16_t)USART_CR1_WAKE);
000002  f24f73ff          MOV      r3,#0xf7ff
000006  401a              ANDS     r2,r2,r3
000008  8182              STRH     r2,[r0,#0xc]
;;;659      USARTx->CR1 |= USART_WakeUp;
00000a  8982              LDRH     r2,[r0,#0xc]
00000c  430a              ORRS     r2,r2,r1
00000e  8182              STRH     r2,[r0,#0xc]
;;;660    }
000010  4770              BX       lr
;;;661    
                          ENDP


;*** Start embedded assembler ***

#line 1 "..\\..\\..\\Libraries\\STM32F4xx_StdPeriph_Driver\\src\\stm32f4xx_usart.c"
	AREA ||.rev16_text||, CODE, READONLY
	THUMB
	EXPORT |__asm___17_stm32f4xx_usart_c_9565154b____REV16|
#line 114 "C:\\Keil\\ARM\\CMSIS\\Include\\core_cmInstr.h"
|__asm___17_stm32f4xx_usart_c_9565154b____REV16| PROC
#line 115

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

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
