; 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_can.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_can.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_can.crf ..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries\STM32F4xx_StdPeriph_Driver\src\stm32f4xx_can.c]
                          THUMB

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

                  CAN_CancelTransmit PROC
;;;701      */
;;;702    void CAN_CancelTransmit(CAN_TypeDef* CANx, uint8_t Mailbox)
000000  b141              CBZ      r1,|L1.20|
;;;703    {
;;;704      /* Check the parameters */
;;;705      assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;706      assert_param(IS_CAN_TRANSMITMAILBOX(Mailbox));
;;;707      /* abort transmission */
;;;708      switch (Mailbox)
000002  2901              CMP      r1,#1
000004  d00a              BEQ      |L1.28|
000006  2902              CMP      r1,#2
000008  d103              BNE      |L1.18|
;;;709      {
;;;710        case (CAN_TXMAILBOX_0): CANx->TSR |= CAN_TSR_ABRQ0;
;;;711          break;
;;;712        case (CAN_TXMAILBOX_1): CANx->TSR |= CAN_TSR_ABRQ1;
;;;713          break;
;;;714        case (CAN_TXMAILBOX_2): CANx->TSR |= CAN_TSR_ABRQ2;
00000a  6881              LDR      r1,[r0,#8]
00000c  f4410100          ORR      r1,r1,#0x800000
                  |L1.16|
000010  6081              STR      r1,[r0,#8]
                  |L1.18|
;;;715          break;
;;;716        default:
;;;717          break;
;;;718      }
;;;719    }
000012  4770              BX       lr
                  |L1.20|
000014  6881              LDR      r1,[r0,#8]            ;710
000016  f0410180          ORR      r1,r1,#0x80           ;710
00001a  e7f9              B        |L1.16|
                  |L1.28|
00001c  6881              LDR      r1,[r0,#8]            ;712
00001e  f4414100          ORR      r1,r1,#0x8000         ;712
000022  e7f5              B        |L1.16|
;;;720    /**
                          ENDP


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

                  CAN_ClearFlag PROC
;;;1428     */
;;;1429   void CAN_ClearFlag(CAN_TypeDef* CANx, uint32_t CAN_FLAG)
000000  4a0a              LDR      r2,|L2.44|
;;;1430   {
;;;1431     uint32_t flagtmp=0;
;;;1432     /* Check the parameters */
;;;1433     assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;1434     assert_param(IS_CAN_CLEAR_FLAG(CAN_FLAG));
;;;1435     
;;;1436     if (CAN_FLAG == CAN_FLAG_LEC) /* ESR register */
000002  4291              CMP      r1,r2
000004  d102              BNE      |L2.12|
;;;1437     {
;;;1438       /* Clear the selected CAN flags */
;;;1439       CANx->ESR = (uint32_t)RESET;
000006  2100              MOVS     r1,#0
000008  6181              STR      r1,[r0,#0x18]
;;;1440     }
;;;1441     else /* MSR or TSR or RF0R or RF1R */
;;;1442     {
;;;1443       flagtmp = CAN_FLAG & 0x000FFFFF;
;;;1444   
;;;1445       if ((CAN_FLAG & CAN_FLAGS_RF0R)!=(uint32_t)RESET)
;;;1446       {
;;;1447         /* Receive Flags */
;;;1448         CANx->RF0R = (uint32_t)(flagtmp);
;;;1449       }
;;;1450       else if ((CAN_FLAG & CAN_FLAGS_RF1R)!=(uint32_t)RESET)
;;;1451       {
;;;1452         /* Receive Flags */
;;;1453         CANx->RF1R = (uint32_t)(flagtmp);
;;;1454       }
;;;1455       else if ((CAN_FLAG & CAN_FLAGS_TSR)!=(uint32_t)RESET)
;;;1456       {
;;;1457         /* Transmit Flags */
;;;1458         CANx->TSR = (uint32_t)(flagtmp);
;;;1459       }
;;;1460       else /* If((CAN_FLAG & CAN_FLAGS_MSR)!=(uint32_t)RESET) */
;;;1461       {
;;;1462         /* Operating mode Flags */
;;;1463         CANx->MSR = (uint32_t)(flagtmp);
;;;1464       }
;;;1465     }
;;;1466   }
00000a  4770              BX       lr
                  |L2.12|
00000c  f3c10213          UBFX     r2,r1,#0,#20          ;1443
000010  018b              LSLS     r3,r1,#6              ;1445
000012  d501              BPL      |L2.24|
000014  60c2              STR      r2,[r0,#0xc]          ;1448
000016  4770              BX       lr
                  |L2.24|
000018  014b              LSLS     r3,r1,#5              ;1450
00001a  d501              BPL      |L2.32|
00001c  6102              STR      r2,[r0,#0x10]         ;1453
00001e  4770              BX       lr
                  |L2.32|
000020  0109              LSLS     r1,r1,#4              ;1455
000022  d501              BPL      |L2.40|
000024  6082              STR      r2,[r0,#8]            ;1458
000026  4770              BX       lr
                  |L2.40|
000028  6042              STR      r2,[r0,#4]            ;1463
00002a  4770              BX       lr
;;;1467   
                          ENDP

                  |L2.44|
                          DCD      0x30f00070

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

                  CAN_ClearITPendingBit PROC
;;;1592     */
;;;1593   void CAN_ClearITPendingBit(CAN_TypeDef* CANx, uint32_t CAN_IT)
000000  b530              PUSH     {r4,r5,lr}
;;;1594   {
;;;1595     /* Check the parameters */
;;;1596     assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;1597     assert_param(IS_CAN_CLEAR_IT(CAN_IT));
;;;1598   
;;;1599     switch (CAN_IT)
;;;1600     {
;;;1601       case CAN_IT_TME:
;;;1602         /* Clear CAN_TSR_RQCPx (rc_w1)*/
;;;1603         CANx->TSR = CAN_TSR_RQCP0|CAN_TSR_RQCP1|CAN_TSR_RQCP2;  
;;;1604         break;
;;;1605       case CAN_IT_FF0:
;;;1606         /* Clear CAN_RF0R_FULL0 (rc_w1)*/
;;;1607         CANx->RF0R = CAN_RF0R_FULL0; 
000002  2308              MOVS     r3,#8
;;;1608         break;
;;;1609       case CAN_IT_FOV0:
;;;1610         /* Clear CAN_RF0R_FOVR0 (rc_w1)*/
;;;1611         CANx->RF0R = CAN_RF0R_FOVR0; 
000004  2410              MOVS     r4,#0x10
;;;1612         break;
;;;1613       case CAN_IT_FF1:
;;;1614         /* Clear CAN_RF1R_FULL1 (rc_w1)*/
;;;1615         CANx->RF1R = CAN_RF1R_FULL1;  
;;;1616         break;
;;;1617       case CAN_IT_FOV1:
;;;1618         /* Clear CAN_RF1R_FOVR1 (rc_w1)*/
;;;1619         CANx->RF1R = CAN_RF1R_FOVR1; 
;;;1620         break;
;;;1621       case CAN_IT_WKU:
;;;1622         /* Clear CAN_MSR_WKUI (rc_w1)*/
;;;1623         CANx->MSR = CAN_MSR_WKUI;  
;;;1624         break;
;;;1625       case CAN_IT_SLK:
;;;1626         /* Clear CAN_MSR_SLAKI (rc_w1)*/ 
;;;1627         CANx->MSR = CAN_MSR_SLAKI;   
;;;1628         break;
;;;1629       case CAN_IT_EWG:
;;;1630         /* Clear CAN_MSR_ERRI (rc_w1) */
;;;1631         CANx->MSR = CAN_MSR_ERRI;
000006  2204              MOVS     r2,#4
000008  f5b17f00          CMP      r1,#0x200             ;1599
00000c  d01d              BEQ      |L3.74|
00000e  dc10              BGT      |L3.50|
000010  2920              CMP      r1,#0x20              ;1599
000012  d029              BEQ      |L3.104|
000014  dc07              BGT      |L3.38|
000016  2901              CMP      r1,#1                 ;1599
000018  d021              BEQ      |L3.94|
00001a  2904              CMP      r1,#4                 ;1599
00001c  d022              BEQ      |L3.100|
00001e  2908              CMP      r1,#8                 ;1599
000020  d100              BNE      |L3.36|
000022  60c4              STR      r4,[r0,#0xc]          ;1611
                  |L3.36|
;;;1632          /* @note the corresponding Flag is cleared by hardware depending on the CAN Bus status*/ 
;;;1633         break;
;;;1634       case CAN_IT_EPV:
;;;1635         /* Clear CAN_MSR_ERRI (rc_w1) */
;;;1636         CANx->MSR = CAN_MSR_ERRI; 
;;;1637          /* @note the corresponding Flag is cleared by hardware depending on the CAN Bus status*/
;;;1638         break;
;;;1639       case CAN_IT_BOF:
;;;1640         /* Clear CAN_MSR_ERRI (rc_w1) */ 
;;;1641         CANx->MSR = CAN_MSR_ERRI; 
;;;1642          /* @note the corresponding Flag is cleared by hardware depending on the CAN Bus status*/
;;;1643          break;
;;;1644       case CAN_IT_LEC:
;;;1645         /*  Clear LEC bits */
;;;1646         CANx->ESR = RESET; 
;;;1647         /* Clear CAN_MSR_ERRI (rc_w1) */
;;;1648         CANx->MSR = CAN_MSR_ERRI; 
;;;1649         break;
;;;1650       case CAN_IT_ERR:
;;;1651         /*Clear LEC bits */
;;;1652         CANx->ESR = RESET; 
;;;1653         /* Clear CAN_MSR_ERRI (rc_w1) */
;;;1654         CANx->MSR = CAN_MSR_ERRI; 
;;;1655          /* @note BOFF, EPVF and EWGF Flags are cleared by hardware depending on the CAN Bus status*/
;;;1656          break;
;;;1657       default:
;;;1658          break;
;;;1659      }
;;;1660   }
000024  bd30              POP      {r4,r5,pc}
                  |L3.38|
000026  2940              CMP      r1,#0x40              ;1599
000028  d020              BEQ      |L3.108|
00002a  f5b17f80          CMP      r1,#0x100             ;1599
00002e  d1f9              BNE      |L3.36|
000030  e00b              B        |L3.74|
                  |L3.50|
000032  2500              MOVS     r5,#0                 ;1599
000034  f5b14f00          CMP      r1,#0x8000            ;1599
000038  d006              BEQ      |L3.72|
00003a  dc08              BGT      |L3.78|
00003c  f5b16f80          CMP      r1,#0x400             ;1599
000040  d003              BEQ      |L3.74|
000042  f5b16f00          CMP      r1,#0x800             ;1599
000046  d1ed              BNE      |L3.36|
                  |L3.72|
000048  6185              STR      r5,[r0,#0x18]         ;1652
                  |L3.74|
00004a  6042              STR      r2,[r0,#4]            ;1641
                  |L3.76|
00004c  bd30              POP      {r4,r5,pc}
                  |L3.78|
00004e  f5b13f80          CMP      r1,#0x10000           ;1599
000052  d00d              BEQ      |L3.112|
000054  f5b13f00          CMP      r1,#0x20000           ;1599
000058  d1f8              BNE      |L3.76|
00005a  6044              STR      r4,[r0,#4]            ;1627
00005c  bd30              POP      {r4,r5,pc}
                  |L3.94|
00005e  4905              LDR      r1,|L3.116|
000060  6081              STR      r1,[r0,#8]            ;1603
000062  bd30              POP      {r4,r5,pc}
                  |L3.100|
000064  60c3              STR      r3,[r0,#0xc]          ;1607
000066  bd30              POP      {r4,r5,pc}
                  |L3.104|
000068  6103              STR      r3,[r0,#0x10]         ;1615
00006a  bd30              POP      {r4,r5,pc}
                  |L3.108|
00006c  6104              STR      r4,[r0,#0x10]         ;1619
00006e  bd30              POP      {r4,r5,pc}
                  |L3.112|
000070  6043              STR      r3,[r0,#4]            ;1623
000072  bd30              POP      {r4,r5,pc}
;;;1661    /**
                          ENDP

                  |L3.116|
                          DCD      0x00010101

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

                  CAN_DBGFreeze PROC
;;;491      */
;;;492    void CAN_DBGFreeze(CAN_TypeDef* CANx, FunctionalState NewState)
000000  2900              CMP      r1,#0
;;;493    {
;;;494      /* Check the parameters */
;;;495      assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;496      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;497      
;;;498      if (NewState != DISABLE)
;;;499      {
;;;500        /* Enable Debug Freeze  */
;;;501        CANx->MCR |= MCR_DBF;
;;;502      }
;;;503      else
;;;504      {
;;;505        /* Disable Debug Freeze */
;;;506        CANx->MCR &= ~MCR_DBF;
000002  6801              LDR      r1,[r0,#0]
000004  d002              BEQ      |L4.12|
000006  f4413180          ORR      r1,r1,#0x10000        ;501
00000a  e001              B        |L4.16|
                  |L4.12|
00000c  f4213180          BIC      r1,r1,#0x10000
                  |L4.16|
000010  6001              STR      r1,[r0,#0]            ;501
;;;507      }
;;;508    }
000012  4770              BX       lr
;;;509    
                          ENDP


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

                  CAN_DeInit PROC
;;;165      */
;;;166    void CAN_DeInit(CAN_TypeDef* CANx)
000000  4909              LDR      r1,|L5.40|
;;;167    {
000002  b510              PUSH     {r4,lr}
;;;168      /* Check the parameters */
;;;169      assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;170     
;;;171      if (CANx == CAN1)
000004  4288              CMP      r0,r1
;;;172      {
;;;173        /* Enable CAN1 reset state */
;;;174        RCC_APB1PeriphResetCmd(RCC_APB1Periph_CAN1, ENABLE);
;;;175        /* Release CAN1 from reset state */
;;;176        RCC_APB1PeriphResetCmd(RCC_APB1Periph_CAN1, DISABLE);
;;;177      }
;;;178      else
;;;179      {  
;;;180        /* Enable CAN2 reset state */
;;;181        RCC_APB1PeriphResetCmd(RCC_APB1Periph_CAN2, ENABLE);
000006  f04f0101          MOV      r1,#1
00000a  d101              BNE      |L5.16|
00000c  064c              LSLS     r4,r1,#25             ;174
00000e  e001              B        |L5.20|
                  |L5.16|
000010  f04f6480          MOV      r4,#0x4000000
                  |L5.20|
000014  4620              MOV      r0,r4
000016  f7fffffe          BL       RCC_APB1PeriphResetCmd
;;;182        /* Release CAN2 from reset state */
;;;183        RCC_APB1PeriphResetCmd(RCC_APB1Periph_CAN2, DISABLE);
00001a  4620              MOV      r0,r4
00001c  e8bd4010          POP      {r4,lr}
000020  2100              MOVS     r1,#0
000022  f7ffbffe          B.W      RCC_APB1PeriphResetCmd
;;;184      }
;;;185    }
;;;186    
                          ENDP

000026  0000              DCW      0x0000
                  |L5.40|
                          DCD      0x40006400

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

                  CAN_FIFORelease PROC
;;;797      */
;;;798    void CAN_FIFORelease(CAN_TypeDef* CANx, uint8_t FIFONumber)
000000  b121              CBZ      r1,|L6.12|
;;;799    {
;;;800      /* Check the parameters */
;;;801      assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;802      assert_param(IS_CAN_FIFO(FIFONumber));
;;;803      /* Release FIFO0 */
;;;804      if (FIFONumber == CAN_FIFO0)
;;;805      {
;;;806        CANx->RF0R |= CAN_RF0R_RFOM0;
;;;807      }
;;;808      /* Release FIFO1 */
;;;809      else /* FIFONumber == CAN_FIFO1 */
;;;810      {
;;;811        CANx->RF1R |= CAN_RF1R_RFOM1;
000002  6901              LDR      r1,[r0,#0x10]
000004  f0410120          ORR      r1,r1,#0x20
000008  6101              STR      r1,[r0,#0x10]
;;;812      }
;;;813    }
00000a  4770              BX       lr
                  |L6.12|
00000c  68c1              LDR      r1,[r0,#0xc]          ;806
00000e  f0410120          ORR      r1,r1,#0x20           ;806
000012  60c1              STR      r1,[r0,#0xc]          ;806
000014  4770              BX       lr
;;;814    
                          ENDP


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

                  CAN_FilterInit PROC
;;;332      */
;;;333    void CAN_FilterInit(CAN_FilterInitTypeDef* CAN_FilterInitStruct)
000000  b5f0              PUSH     {r4-r7,lr}
;;;334    {
;;;335      uint32_t filter_number_bit_pos = 0;
;;;336      /* Check the parameters */
;;;337      assert_param(IS_CAN_FILTER_NUMBER(CAN_FilterInitStruct->CAN_FilterNumber));
;;;338      assert_param(IS_CAN_FILTER_MODE(CAN_FilterInitStruct->CAN_FilterMode));
;;;339      assert_param(IS_CAN_FILTER_SCALE(CAN_FilterInitStruct->CAN_FilterScale));
;;;340      assert_param(IS_CAN_FILTER_FIFO(CAN_FilterInitStruct->CAN_FilterFIFOAssignment));
;;;341      assert_param(IS_FUNCTIONAL_STATE(CAN_FilterInitStruct->CAN_FilterActivation));
;;;342    
;;;343      filter_number_bit_pos = ((uint32_t)1) << CAN_FilterInitStruct->CAN_FilterNumber;
000002  7a82              LDRB     r2,[r0,#0xa]
;;;344    
;;;345      /* Initialisation mode for the filter */
;;;346      CAN1->FMR |= FMR_FINIT;
000004  4d2f              LDR      r5,|L7.196|
000006  2101              MOVS     r1,#1                 ;343
000008  4091              LSLS     r1,r1,r2              ;343
00000a  682a              LDR      r2,[r5,#0]
00000c  f0420201          ORR      r2,r2,#1
000010  602a              STR      r2,[r5,#0]
;;;347    
;;;348      /* Filter Deactivation */
;;;349      CAN1->FA1R &= ~(uint32_t)filter_number_bit_pos;
000012  4e2c              LDR      r6,|L7.196|
000014  361c              ADDS     r6,r6,#0x1c
000016  6832              LDR      r2,[r6,#0]
000018  438a              BICS     r2,r2,r1
00001a  6032              STR      r2,[r6,#0]
;;;350    
;;;351      /* Filter Scale */
;;;352      if (CAN_FilterInitStruct->CAN_FilterScale == CAN_FilterScale_16bit)
;;;353      {
;;;354        /* 16-bit scale for the filter */
;;;355        CAN1->FS1R &= ~(uint32_t)filter_number_bit_pos;
00001c  4a29              LDR      r2,|L7.196|
00001e  7b04              LDRB     r4,[r0,#0xc]          ;352
;;;356    
;;;357        /* First 16-bit identifier and First 16-bit mask */
;;;358        /* Or First 16-bit identifier and Second 16-bit identifier */
;;;359        CAN1->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR1 = 
000020  4b29              LDR      r3,|L7.200|
000022  320c              ADDS     r2,r2,#0xc            ;355
000024  b9a4              CBNZ     r4,|L7.80|
000026  6814              LDR      r4,[r2,#0]            ;355
000028  438c              BICS     r4,r4,r1              ;355
00002a  6014              STR      r4,[r2,#0]            ;355
00002c  8844              LDRH     r4,[r0,#2]
00002e  88c7              LDRH     r7,[r0,#6]
000030  ea444407          ORR      r4,r4,r7,LSL #16
000034  7a87              LDRB     r7,[r0,#0xa]
000036  eb0307c7          ADD      r7,r3,r7,LSL #3
00003a  f8c74640          STR      r4,[r7,#0x640]
;;;360           ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdLow) << 16) |
;;;361            (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdLow);
;;;362    
;;;363        /* Second 16-bit identifier and Second 16-bit mask */
;;;364        /* Or Third 16-bit identifier and Fourth 16-bit identifier */
;;;365        CAN1->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR2 = 
00003e  8804              LDRH     r4,[r0,#0]
000040  8887              LDRH     r7,[r0,#4]
000042  ea444407          ORR      r4,r4,r7,LSL #16
000046  7a87              LDRB     r7,[r0,#0xa]
000048  eb0307c7          ADD      r7,r3,r7,LSL #3
00004c  f8c74644          STR      r4,[r7,#0x644]
                  |L7.80|
;;;366           ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdHigh) << 16) |
;;;367            (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdHigh);
;;;368      }
;;;369    
;;;370      if (CAN_FilterInitStruct->CAN_FilterScale == CAN_FilterScale_32bit)
000050  7b04              LDRB     r4,[r0,#0xc]
000052  2c01              CMP      r4,#1
000054  d112              BNE      |L7.124|
;;;371      {
;;;372        /* 32-bit scale for the filter */
;;;373        CAN1->FS1R |= filter_number_bit_pos;
000056  6814              LDR      r4,[r2,#0]
000058  430c              ORRS     r4,r4,r1
00005a  6014              STR      r4,[r2,#0]
;;;374        /* 32-bit identifier or First 32-bit identifier */
;;;375        CAN1->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR1 = 
00005c  7a84              LDRB     r4,[r0,#0xa]
00005e  6802              LDR      r2,[r0,#0]
000060  eb0304c4          ADD      r4,r3,r4,LSL #3
000064  ea4f4232          ROR      r2,r2,#16
000068  f8c42640          STR      r2,[r4,#0x640]
;;;376           ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdHigh) << 16) |
;;;377            (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdLow);
;;;378        /* 32-bit mask or Second 32-bit identifier */
;;;379        CAN1->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR2 = 
00006c  7a84              LDRB     r4,[r0,#0xa]
00006e  6842              LDR      r2,[r0,#4]
000070  eb0303c4          ADD      r3,r3,r4,LSL #3
000074  ea4f4232          ROR      r2,r2,#16
000078  f8c32644          STR      r2,[r3,#0x644]
                  |L7.124|
;;;380           ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdHigh) << 16) |
;;;381            (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdLow);
;;;382      }
;;;383    
;;;384      /* Filter Mode */
;;;385      if (CAN_FilterInitStruct->CAN_FilterMode == CAN_FilterMode_IdMask)
;;;386      {
;;;387        /*Id/Mask mode for the filter*/
;;;388        CAN1->FM1R &= ~(uint32_t)filter_number_bit_pos;
00007c  4a11              LDR      r2,|L7.196|
00007e  7ac3              LDRB     r3,[r0,#0xb]          ;385
000080  1d12              ADDS     r2,r2,#4
000082  2b00              CMP      r3,#0                 ;385
;;;389      }
;;;390      else /* CAN_FilterInitStruct->CAN_FilterMode == CAN_FilterMode_IdList */
;;;391      {
;;;392        /*Identifier list mode for the filter*/
;;;393        CAN1->FM1R |= (uint32_t)filter_number_bit_pos;
000084  6813              LDR      r3,[r2,#0]
000086  d006              BEQ      |L7.150|
000088  430b              ORRS     r3,r3,r1
                  |L7.138|
00008a  6013              STR      r3,[r2,#0]
;;;394      }
;;;395    
;;;396      /* Filter FIFO assignment */
;;;397      if (CAN_FilterInitStruct->CAN_FilterFIFOAssignment == CAN_Filter_FIFO0)
;;;398      {
;;;399        /* FIFO 0 assignation for the filter */
;;;400        CAN1->FFA1R &= ~(uint32_t)filter_number_bit_pos;
00008c  4a0d              LDR      r2,|L7.196|
00008e  8903              LDRH     r3,[r0,#8]            ;397
000090  3214              ADDS     r2,r2,#0x14
000092  b113              CBZ      r3,|L7.154|
000094  e004              B        |L7.160|
                  |L7.150|
000096  438b              BICS     r3,r3,r1              ;388
000098  e7f7              B        |L7.138|
                  |L7.154|
00009a  6813              LDR      r3,[r2,#0]
00009c  438b              BICS     r3,r3,r1
00009e  6013              STR      r3,[r2,#0]
                  |L7.160|
;;;401      }
;;;402    
;;;403      if (CAN_FilterInitStruct->CAN_FilterFIFOAssignment == CAN_Filter_FIFO1)
0000a0  8903              LDRH     r3,[r0,#8]
0000a2  2b01              CMP      r3,#1
0000a4  d102              BNE      |L7.172|
;;;404      {
;;;405        /* FIFO 1 assignation for the filter */
;;;406        CAN1->FFA1R |= (uint32_t)filter_number_bit_pos;
0000a6  6813              LDR      r3,[r2,#0]
0000a8  430b              ORRS     r3,r3,r1
0000aa  6013              STR      r3,[r2,#0]
                  |L7.172|
;;;407      }
;;;408      
;;;409      /* Filter activation */
;;;410      if (CAN_FilterInitStruct->CAN_FilterActivation == ENABLE)
0000ac  7b40              LDRB     r0,[r0,#0xd]
0000ae  2801              CMP      r0,#1
0000b0  d102              BNE      |L7.184|
;;;411      {
;;;412        CAN1->FA1R |= filter_number_bit_pos;
0000b2  6830              LDR      r0,[r6,#0]
0000b4  4308              ORRS     r0,r0,r1
0000b6  6030              STR      r0,[r6,#0]
                  |L7.184|
;;;413      }
;;;414    
;;;415      /* Leave the initialisation mode for the filter */
;;;416      CAN1->FMR &= ~FMR_FINIT;
0000b8  6828              LDR      r0,[r5,#0]
0000ba  f0200001          BIC      r0,r0,#1
0000be  6028              STR      r0,[r5,#0]
;;;417    }
0000c0  bdf0              POP      {r4-r7,pc}
;;;418    
                          ENDP

0000c2  0000              DCW      0x0000
                  |L7.196|
                          DCD      0x40006600
                  |L7.200|
                          DCD      0x40006000

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

                  CAN_GetFlagStatus PROC
;;;1328     */
;;;1329   FlagStatus CAN_GetFlagStatus(CAN_TypeDef* CANx, uint32_t CAN_FLAG)
000000  4602              MOV      r2,r0
;;;1330   {
;;;1331     FlagStatus bitstatus = RESET;
000002  2000              MOVS     r0,#0
;;;1332     
;;;1333     /* Check the parameters */
;;;1334     assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;1335     assert_param(IS_CAN_GET_FLAG(CAN_FLAG));
;;;1336     
;;;1337   
;;;1338     if((CAN_FLAG & CAN_FLAGS_ESR) != (uint32_t)RESET)
000004  f4110f70          TST      r1,#0xf00000
000008  d003              BEQ      |L8.18|
;;;1339     { 
;;;1340       /* Check the status of the specified CAN flag */
;;;1341       if ((CANx->ESR & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET)
00000a  6992              LDR      r2,[r2,#0x18]
00000c  e004              B        |L8.24|
                  |L8.14|
;;;1342       { 
;;;1343         /* CAN_FLAG is set */
;;;1344         bitstatus = SET;
00000e  2001              MOVS     r0,#1
;;;1345       }
;;;1346       else
;;;1347       { 
;;;1348         /* CAN_FLAG is reset */
;;;1349         bitstatus = RESET;
;;;1350       }
;;;1351     }
;;;1352     else if((CAN_FLAG & CAN_FLAGS_MSR) != (uint32_t)RESET)
;;;1353     { 
;;;1354       /* Check the status of the specified CAN flag */
;;;1355       if ((CANx->MSR & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET)
;;;1356       { 
;;;1357         /* CAN_FLAG is set */
;;;1358         bitstatus = SET;
;;;1359       }
;;;1360       else
;;;1361       { 
;;;1362         /* CAN_FLAG is reset */
;;;1363         bitstatus = RESET;
;;;1364       }
;;;1365     }
;;;1366     else if((CAN_FLAG & CAN_FLAGS_TSR) != (uint32_t)RESET)
;;;1367     { 
;;;1368       /* Check the status of the specified CAN flag */
;;;1369       if ((CANx->TSR & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET)
;;;1370       { 
;;;1371         /* CAN_FLAG is set */
;;;1372         bitstatus = SET;
;;;1373       }
;;;1374       else
;;;1375       { 
;;;1376         /* CAN_FLAG is reset */
;;;1377         bitstatus = RESET;
;;;1378       }
;;;1379     }
;;;1380     else if((CAN_FLAG & CAN_FLAGS_RF0R) != (uint32_t)RESET)
;;;1381     { 
;;;1382       /* Check the status of the specified CAN flag */
;;;1383       if ((CANx->RF0R & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET)
;;;1384       { 
;;;1385         /* CAN_FLAG is set */
;;;1386         bitstatus = SET;
;;;1387       }
;;;1388       else
;;;1389       { 
;;;1390         /* CAN_FLAG is reset */
;;;1391         bitstatus = RESET;
;;;1392       }
;;;1393     }
;;;1394     else /* If(CAN_FLAG & CAN_FLAGS_RF1R != (uint32_t)RESET) */
;;;1395     { 
;;;1396       /* Check the status of the specified CAN flag */
;;;1397       if ((uint32_t)(CANx->RF1R & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET)
;;;1398       { 
;;;1399         /* CAN_FLAG is set */
;;;1400         bitstatus = SET;
;;;1401       }
;;;1402       else
;;;1403       { 
;;;1404         /* CAN_FLAG is reset */
;;;1405         bitstatus = RESET;
;;;1406       }
;;;1407     }
;;;1408     /* Return the CAN_FLAG status */
;;;1409     return  bitstatus;
;;;1410   }
000010  4770              BX       lr
                  |L8.18|
000012  01cb              LSLS     r3,r1,#7              ;1352
000014  d504              BPL      |L8.32|
000016  6852              LDR      r2,[r2,#4]            ;1355
                  |L8.24|
000018  400a              ANDS     r2,r2,r1              ;1341
00001a  0311              LSLS     r1,r2,#12             ;1341
00001c  d1f7              BNE      |L8.14|
00001e  4770              BX       lr
                  |L8.32|
000020  010b              LSLS     r3,r1,#4              ;1366
000022  d501              BPL      |L8.40|
000024  6892              LDR      r2,[r2,#8]            ;1369
000026  e7f7              B        |L8.24|
                  |L8.40|
000028  018b              LSLS     r3,r1,#6              ;1380
00002a  d501              BPL      |L8.48|
00002c  68d2              LDR      r2,[r2,#0xc]          ;1383
00002e  e7f3              B        |L8.24|
                  |L8.48|
000030  6912              LDR      r2,[r2,#0x10]         ;1397
000032  e7f1              B        |L8.24|
;;;1411   
                          ENDP


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

                  CAN_GetITStatus PROC
;;;1488     */
;;;1489   ITStatus CAN_GetITStatus(CAN_TypeDef* CANx, uint32_t CAN_IT)
000000  4602              MOV      r2,r0
;;;1490   {
;;;1491     ITStatus itstatus = RESET;
000002  2000              MOVS     r0,#0
;;;1492     /* Check the parameters */
;;;1493     assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;1494     assert_param(IS_CAN_IT(CAN_IT));
;;;1495     
;;;1496     /* check the interrupt enable bit */
;;;1497    if((CANx->IER & CAN_IT) != RESET)
000004  6953              LDR      r3,[r2,#0x14]
000006  420b              TST      r3,r1
000008  d04a              BEQ      |L9.160|
;;;1498    {
;;;1499      /* in case the Interrupt is enabled, .... */
;;;1500       switch (CAN_IT)
00000a  f5b17f80          CMP      r1,#0x100
00000e  d03b              BEQ      |L9.136|
000010  dc13              BGT      |L9.58|
000012  2908              CMP      r1,#8
000014  d02e              BEQ      |L9.116|
000016  dc07              BGT      |L9.40|
000018  2901              CMP      r1,#1
00001a  d026              BEQ      |L9.106|
00001c  2902              CMP      r1,#2
00001e  d027              BEQ      |L9.112|
000020  2904              CMP      r1,#4
000022  d13d              BNE      |L9.160|
;;;1501       {
;;;1502         case CAN_IT_TME:
;;;1503           /* Check CAN_TSR_RQCPx bits */
;;;1504           itstatus = CheckITStatus(CANx->TSR, CAN_TSR_RQCP0|CAN_TSR_RQCP1|CAN_TSR_RQCP2);  
;;;1505           break;
;;;1506         case CAN_IT_FMP0:
;;;1507           /* Check CAN_RF0R_FMP0 bit */
;;;1508           itstatus = CheckITStatus(CANx->RF0R, CAN_RF0R_FMP0);  
;;;1509           break;
;;;1510         case CAN_IT_FF0:
;;;1511           /* Check CAN_RF0R_FULL0 bit */
;;;1512           itstatus = CheckITStatus(CANx->RF0R, CAN_RF0R_FULL0);  
000024  68d0              LDR      r0,[r2,#0xc]
;;;1513           break;
000026  e02b              B        |L9.128|
                  |L9.40|
000028  2910              CMP      r1,#0x10              ;1500
00002a  d025              BEQ      |L9.120|
00002c  2920              CMP      r1,#0x20              ;1500
00002e  d026              BEQ      |L9.126|
000030  2940              CMP      r1,#0x40              ;1500
000032  d135              BNE      |L9.160|
;;;1514         case CAN_IT_FOV0:
;;;1515           /* Check CAN_RF0R_FOVR0 bit */
;;;1516           itstatus = CheckITStatus(CANx->RF0R, CAN_RF0R_FOVR0);  
;;;1517           break;
;;;1518         case CAN_IT_FMP1:
;;;1519           /* Check CAN_RF1R_FMP1 bit */
;;;1520           itstatus = CheckITStatus(CANx->RF1R, CAN_RF1R_FMP1);  
;;;1521           break;
;;;1522         case CAN_IT_FF1:
;;;1523           /* Check CAN_RF1R_FULL1 bit */
;;;1524           itstatus = CheckITStatus(CANx->RF1R, CAN_RF1R_FULL1);  
;;;1525           break;
;;;1526         case CAN_IT_FOV1:
;;;1527           /* Check CAN_RF1R_FOVR1 bit */
;;;1528           itstatus = CheckITStatus(CANx->RF1R, CAN_RF1R_FOVR1);  
000034  6910              LDR      r0,[r2,#0x10]
                  |L9.54|
000036  2110              MOVS     r1,#0x10              ;1516
000038  e030              B        |L9.156|
                  |L9.58|
00003a  f5b14f00          CMP      r1,#0x8000            ;1500
00003e  d02b              BEQ      |L9.152|
000040  dc0b              BGT      |L9.90|
000042  f5b17f00          CMP      r1,#0x200             ;1500
000046  d022              BEQ      |L9.142|
000048  f5b16f80          CMP      r1,#0x400             ;1500
00004c  d022              BEQ      |L9.148|
00004e  f5b16f00          CMP      r1,#0x800             ;1500
000052  d125              BNE      |L9.160|
;;;1529           break;
;;;1530         case CAN_IT_WKU:
;;;1531           /* Check CAN_MSR_WKUI bit */
;;;1532           itstatus = CheckITStatus(CANx->MSR, CAN_MSR_WKUI);  
;;;1533           break;
;;;1534         case CAN_IT_SLK:
;;;1535           /* Check CAN_MSR_SLAKI bit */
;;;1536           itstatus = CheckITStatus(CANx->MSR, CAN_MSR_SLAKI);  
;;;1537           break;
;;;1538         case CAN_IT_EWG:
;;;1539           /* Check CAN_ESR_EWGF bit */
;;;1540           itstatus = CheckITStatus(CANx->ESR, CAN_ESR_EWGF);  
;;;1541           break;
;;;1542         case CAN_IT_EPV:
;;;1543           /* Check CAN_ESR_EPVF bit */
;;;1544           itstatus = CheckITStatus(CANx->ESR, CAN_ESR_EPVF);  
;;;1545           break;
;;;1546         case CAN_IT_BOF:
;;;1547           /* Check CAN_ESR_BOFF bit */
;;;1548           itstatus = CheckITStatus(CANx->ESR, CAN_ESR_BOFF);  
;;;1549           break;
;;;1550         case CAN_IT_LEC:
;;;1551           /* Check CAN_ESR_LEC bit */
;;;1552           itstatus = CheckITStatus(CANx->ESR, CAN_ESR_LEC);  
000054  6990              LDR      r0,[r2,#0x18]
000056  2170              MOVS     r1,#0x70
;;;1553           break;
000058  e020              B        |L9.156|
                  |L9.90|
00005a  f5b13f80          CMP      r1,#0x10000           ;1500
00005e  d011              BEQ      |L9.132|
000060  f5b13f00          CMP      r1,#0x20000           ;1500
000064  d11c              BNE      |L9.160|
000066  6850              LDR      r0,[r2,#4]            ;1536
000068  e7e5              B        |L9.54|
                  |L9.106|
00006a  6890              LDR      r0,[r2,#8]            ;1504
00006c  490d              LDR      r1,|L9.164|
00006e  e015              B        |L9.156|
                  |L9.112|
000070  68d0              LDR      r0,[r2,#0xc]          ;1508
000072  e002              B        |L9.122|
                  |L9.116|
000074  68d0              LDR      r0,[r2,#0xc]          ;1516
000076  e7de              B        |L9.54|
                  |L9.120|
000078  6910              LDR      r0,[r2,#0x10]         ;1520
                  |L9.122|
00007a  2103              MOVS     r1,#3                 ;1508
00007c  e00e              B        |L9.156|
                  |L9.126|
00007e  6910              LDR      r0,[r2,#0x10]         ;1524
                  |L9.128|
000080  2108              MOVS     r1,#8                 ;1512
000082  e00b              B        |L9.156|
                  |L9.132|
000084  6850              LDR      r0,[r2,#4]            ;1532
000086  e7fb              B        |L9.128|
                  |L9.136|
000088  6990              LDR      r0,[r2,#0x18]         ;1540
00008a  2101              MOVS     r1,#1                 ;1540
00008c  e006              B        |L9.156|
                  |L9.142|
00008e  6990              LDR      r0,[r2,#0x18]         ;1544
000090  2102              MOVS     r1,#2                 ;1544
000092  e003              B        |L9.156|
                  |L9.148|
000094  6990              LDR      r0,[r2,#0x18]         ;1548
000096  e000              B        |L9.154|
                  |L9.152|
;;;1554         case CAN_IT_ERR:
;;;1555           /* Check CAN_MSR_ERRI bit */ 
;;;1556           itstatus = CheckITStatus(CANx->MSR, CAN_MSR_ERRI); 
000098  6850              LDR      r0,[r2,#4]
                  |L9.154|
00009a  2104              MOVS     r1,#4                 ;1548
                  |L9.156|
00009c  f7ffbffe          B.W      CheckITStatus
                  |L9.160|
;;;1557           break;
;;;1558         default:
;;;1559           /* in case of error, return RESET */
;;;1560           itstatus = RESET;
;;;1561           break;
;;;1562       }
;;;1563     }
;;;1564     else
;;;1565     {
;;;1566      /* in case the Interrupt is not enabled, return RESET */
;;;1567       itstatus  = RESET;
;;;1568     }
;;;1569     
;;;1570     /* Return the CAN_IT status */
;;;1571     return  itstatus;
;;;1572   }
0000a0  4770              BX       lr
;;;1573   
                          ENDP

0000a2  0000              DCW      0x0000
                  |L9.164|
                          DCD      0x00010101

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

                  CAN_GetLSBTransmitErrorCounter PROC
;;;1083     */
;;;1084   uint8_t CAN_GetLSBTransmitErrorCounter(CAN_TypeDef* CANx)
000000  6980              LDR      r0,[r0,#0x18]
;;;1085   {
;;;1086     uint8_t counter=0;
;;;1087     
;;;1088     /* Check the parameters */
;;;1089     assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;1090     
;;;1091     /* Get the LSB of the 9-bit CANx Transmit Error Counter(TEC) */
;;;1092     counter = (uint8_t)((CANx->ESR & CAN_ESR_TEC)>> 16);
000002  f3c04007          UBFX     r0,r0,#16,#8
;;;1093     
;;;1094     /* Return the LSB of the 9-bit CANx Transmit Error Counter(TEC) */
;;;1095     return counter;
;;;1096   }
000006  4770              BX       lr
;;;1097   /**
                          ENDP


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

                  CAN_GetLastErrorCode PROC
;;;1038     */
;;;1039   uint8_t CAN_GetLastErrorCode(CAN_TypeDef* CANx)
000000  6980              LDR      r0,[r0,#0x18]
;;;1040   {
;;;1041     uint8_t errorcode=0;
;;;1042     
;;;1043     /* Check the parameters */
;;;1044     assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;1045     
;;;1046     /* Get the error code*/
;;;1047     errorcode = (((uint8_t)CANx->ESR) & (uint8_t)CAN_ESR_LEC);
000002  f3c01002          UBFX     r0,r0,#4,#3
000006  0100              LSLS     r0,r0,#4
;;;1048     
;;;1049     /* Return the error code*/
;;;1050     return errorcode;
;;;1051   }
000008  4770              BX       lr
;;;1052   
                          ENDP


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

                  CAN_GetReceiveErrorCounter PROC
;;;1063     */
;;;1064   uint8_t CAN_GetReceiveErrorCounter(CAN_TypeDef* CANx)
000000  6980              LDR      r0,[r0,#0x18]
;;;1065   {
;;;1066     uint8_t counter=0;
;;;1067     
;;;1068     /* Check the parameters */
;;;1069     assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;1070     
;;;1071     /* Get the Receive Error Counter*/
;;;1072     counter = (uint8_t)((CANx->ESR & CAN_ESR_REC)>> 24);
000002  0e00              LSRS     r0,r0,#24
;;;1073     
;;;1074     /* Return the Receive Error Counter*/
;;;1075     return counter;
;;;1076   }
000004  4770              BX       lr
;;;1077   
                          ENDP


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

                  CAN_ITConfig PROC
;;;1288     */
;;;1289   void CAN_ITConfig(CAN_TypeDef* CANx, uint32_t CAN_IT, FunctionalState NewState)
000000  2a00              CMP      r2,#0
;;;1290   {
;;;1291     /* Check the parameters */
;;;1292     assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;1293     assert_param(IS_CAN_IT(CAN_IT));
;;;1294     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1295   
;;;1296     if (NewState != DISABLE)
;;;1297     {
;;;1298       /* Enable the selected CANx interrupt */
;;;1299       CANx->IER |= CAN_IT;
;;;1300     }
;;;1301     else
;;;1302     {
;;;1303       /* Disable the selected CANx interrupt */
;;;1304       CANx->IER &= ~CAN_IT;
000002  6942              LDR      r2,[r0,#0x14]
000004  d001              BEQ      |L13.10|
000006  430a              ORRS     r2,r2,r1              ;1299
000008  e000              B        |L13.12|
                  |L13.10|
00000a  438a              BICS     r2,r2,r1
                  |L13.12|
00000c  6142              STR      r2,[r0,#0x14]         ;1299
;;;1305     }
;;;1306   }
00000e  4770              BX       lr
;;;1307   /**
                          ENDP


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

                  CAN_Init PROC
;;;195      */
;;;196    uint8_t CAN_Init(CAN_TypeDef* CANx, CAN_InitTypeDef* CAN_InitStruct)
000000  b510              PUSH     {r4,lr}
;;;197    {
;;;198      uint8_t InitStatus = CAN_InitStatus_Failed;
;;;199      uint32_t wait_ack = 0x00000000;
;;;200      /* Check the parameters */
;;;201      assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;202      assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_TTCM));
;;;203      assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_ABOM));
;;;204      assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_AWUM));
;;;205      assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_NART));
;;;206      assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_RFLM));
;;;207      assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_TXFP));
;;;208      assert_param(IS_CAN_MODE(CAN_InitStruct->CAN_Mode));
;;;209      assert_param(IS_CAN_SJW(CAN_InitStruct->CAN_SJW));
;;;210      assert_param(IS_CAN_BS1(CAN_InitStruct->CAN_BS1));
;;;211      assert_param(IS_CAN_BS2(CAN_InitStruct->CAN_BS2));
;;;212      assert_param(IS_CAN_PRESCALER(CAN_InitStruct->CAN_Prescaler));
;;;213    
;;;214      /* Exit from sleep mode */
;;;215      CANx->MCR &= (~(uint32_t)CAN_MCR_SLEEP);
000002  6803              LDR      r3,[r0,#0]
000004  2200              MOVS     r2,#0                 ;199
000006  f0230302          BIC      r3,r3,#2
00000a  6003              STR      r3,[r0,#0]
;;;216    
;;;217      /* Request initialisation */
;;;218      CANx->MCR |= CAN_MCR_INRQ ;
00000c  6803              LDR      r3,[r0,#0]
00000e  f0430301          ORR      r3,r3,#1
000012  6003              STR      r3,[r0,#0]
;;;219    
;;;220      /* Wait the acknowledge */
;;;221      while (((CANx->MSR & CAN_MSR_INAK) != CAN_MSR_INAK) && (wait_ack != INAK_TIMEOUT))
000014  f64f73ff          MOV      r3,#0xffff
000018  e000              B        |L14.28|
                  |L14.26|
00001a  1c52              ADDS     r2,r2,#1              ;197
                  |L14.28|
00001c  6844              LDR      r4,[r0,#4]
00001e  07e4              LSLS     r4,r4,#31
000020  d101              BNE      |L14.38|
000022  429a              CMP      r2,r3
000024  d1f9              BNE      |L14.26|
                  |L14.38|
;;;222      {
;;;223        wait_ack++;
;;;224      }
;;;225    
;;;226      /* Check acknowledge */
;;;227      if ((CANx->MSR & CAN_MSR_INAK) != CAN_MSR_INAK)
000026  6842              LDR      r2,[r0,#4]
000028  07d2              LSLS     r2,r2,#31
00002a  d03e              BEQ      |L14.170|
;;;228      {
;;;229        InitStatus = CAN_InitStatus_Failed;
;;;230      }
;;;231      else 
;;;232      {
;;;233        /* Set the time triggered communication mode */
;;;234        if (CAN_InitStruct->CAN_TTCM == ENABLE)
00002c  798a              LDRB     r2,[r1,#6]
00002e  2a01              CMP      r2,#1
;;;235        {
;;;236          CANx->MCR |= CAN_MCR_TTCM;
;;;237        }
;;;238        else
;;;239        {
;;;240          CANx->MCR &= ~(uint32_t)CAN_MCR_TTCM;
000030  6802              LDR      r2,[r0,#0]
000032  d03c              BEQ      |L14.174|
000034  f0220280          BIC      r2,r2,#0x80
                  |L14.56|
000038  6002              STR      r2,[r0,#0]
;;;241        }
;;;242    
;;;243        /* Set the automatic bus-off management */
;;;244        if (CAN_InitStruct->CAN_ABOM == ENABLE)
00003a  79ca              LDRB     r2,[r1,#7]
00003c  2a01              CMP      r2,#1
;;;245        {
;;;246          CANx->MCR |= CAN_MCR_ABOM;
;;;247        }
;;;248        else
;;;249        {
;;;250          CANx->MCR &= ~(uint32_t)CAN_MCR_ABOM;
00003e  6802              LDR      r2,[r0,#0]
000040  d038              BEQ      |L14.180|
000042  f0220240          BIC      r2,r2,#0x40
                  |L14.70|
000046  6002              STR      r2,[r0,#0]
;;;251        }
;;;252    
;;;253        /* Set the automatic wake-up mode */
;;;254        if (CAN_InitStruct->CAN_AWUM == ENABLE)
000048  7a0a              LDRB     r2,[r1,#8]
00004a  2a01              CMP      r2,#1
;;;255        {
;;;256          CANx->MCR |= CAN_MCR_AWUM;
;;;257        }
;;;258        else
;;;259        {
;;;260          CANx->MCR &= ~(uint32_t)CAN_MCR_AWUM;
00004c  6802              LDR      r2,[r0,#0]
00004e  d034              BEQ      |L14.186|
000050  f0220220          BIC      r2,r2,#0x20
                  |L14.84|
000054  6002              STR      r2,[r0,#0]
;;;261        }
;;;262    
;;;263        /* Set the no automatic retransmission */
;;;264        if (CAN_InitStruct->CAN_NART == ENABLE)
000056  7a4a              LDRB     r2,[r1,#9]
000058  2a01              CMP      r2,#1
;;;265        {
;;;266          CANx->MCR |= CAN_MCR_NART;
;;;267        }
;;;268        else
;;;269        {
;;;270          CANx->MCR &= ~(uint32_t)CAN_MCR_NART;
00005a  6802              LDR      r2,[r0,#0]
00005c  d030              BEQ      |L14.192|
00005e  f0220210          BIC      r2,r2,#0x10
                  |L14.98|
000062  6002              STR      r2,[r0,#0]
;;;271        }
;;;272    
;;;273        /* Set the receive FIFO locked mode */
;;;274        if (CAN_InitStruct->CAN_RFLM == ENABLE)
000064  7a8a              LDRB     r2,[r1,#0xa]
000066  2a01              CMP      r2,#1
;;;275        {
;;;276          CANx->MCR |= CAN_MCR_RFLM;
;;;277        }
;;;278        else
;;;279        {
;;;280          CANx->MCR &= ~(uint32_t)CAN_MCR_RFLM;
000068  6802              LDR      r2,[r0,#0]
00006a  d02c              BEQ      |L14.198|
00006c  f0220208          BIC      r2,r2,#8
                  |L14.112|
000070  6002              STR      r2,[r0,#0]
;;;281        }
;;;282    
;;;283        /* Set the transmit FIFO priority */
;;;284        if (CAN_InitStruct->CAN_TXFP == ENABLE)
000072  7aca              LDRB     r2,[r1,#0xb]
000074  2a01              CMP      r2,#1
;;;285        {
;;;286          CANx->MCR |= CAN_MCR_TXFP;
;;;287        }
;;;288        else
;;;289        {
;;;290          CANx->MCR &= ~(uint32_t)CAN_MCR_TXFP;
000076  6802              LDR      r2,[r0,#0]
000078  d028              BEQ      |L14.204|
00007a  f0220204          BIC      r2,r2,#4
                  |L14.126|
00007e  6002              STR      r2,[r0,#0]
;;;291        }
;;;292    
;;;293        /* Set the bit timing register */
;;;294        CANx->BTR = (uint32_t)((uint32_t)CAN_InitStruct->CAN_Mode << 30) | \
000080  788a              LDRB     r2,[r1,#2]
000082  78cc              LDRB     r4,[r1,#3]
000084  0792              LSLS     r2,r2,#30
000086  ea426204          ORR      r2,r2,r4,LSL #24
00008a  790c              LDRB     r4,[r1,#4]
00008c  ea424204          ORR      r2,r2,r4,LSL #16
000090  794c              LDRB     r4,[r1,#5]
000092  8809              LDRH     r1,[r1,#0]
000094  ea425204          ORR      r2,r2,r4,LSL #20
000098  1e49              SUBS     r1,r1,#1
00009a  430a              ORRS     r2,r2,r1
00009c  61c2              STR      r2,[r0,#0x1c]
;;;295                    ((uint32_t)CAN_InitStruct->CAN_SJW << 24) | \
;;;296                    ((uint32_t)CAN_InitStruct->CAN_BS1 << 16) | \
;;;297                    ((uint32_t)CAN_InitStruct->CAN_BS2 << 20) | \
;;;298                   ((uint32_t)CAN_InitStruct->CAN_Prescaler - 1);
;;;299    
;;;300        /* Request leave initialisation */
;;;301        CANx->MCR &= ~(uint32_t)CAN_MCR_INRQ;
00009e  6801              LDR      r1,[r0,#0]
0000a0  f0210101          BIC      r1,r1,#1
0000a4  6001              STR      r1,[r0,#0]
;;;302    
;;;303       /* Wait the acknowledge */
;;;304       wait_ack = 0;
0000a6  2100              MOVS     r1,#0
0000a8  e014              B        |L14.212|
                  |L14.170|
0000aa  2000              MOVS     r0,#0                 ;229
;;;305    
;;;306       while (((CANx->MSR & CAN_MSR_INAK) == CAN_MSR_INAK) && (wait_ack != INAK_TIMEOUT))
;;;307       {
;;;308         wait_ack++;
;;;309       }
;;;310    
;;;311        /* ...and check acknowledged */
;;;312        if ((CANx->MSR & CAN_MSR_INAK) == CAN_MSR_INAK)
;;;313        {
;;;314          InitStatus = CAN_InitStatus_Failed;
;;;315        }
;;;316        else
;;;317        {
;;;318          InitStatus = CAN_InitStatus_Success ;
;;;319        }
;;;320      }
;;;321    
;;;322      /* At this step, return the status of initialization */
;;;323      return InitStatus;
;;;324    }
0000ac  bd10              POP      {r4,pc}
                  |L14.174|
0000ae  f0420280          ORR      r2,r2,#0x80           ;236
0000b2  e7c1              B        |L14.56|
                  |L14.180|
0000b4  f0420240          ORR      r2,r2,#0x40           ;246
0000b8  e7c5              B        |L14.70|
                  |L14.186|
0000ba  f0420220          ORR      r2,r2,#0x20           ;256
0000be  e7c9              B        |L14.84|
                  |L14.192|
0000c0  f0420210          ORR      r2,r2,#0x10           ;266
0000c4  e7cd              B        |L14.98|
                  |L14.198|
0000c6  f0420208          ORR      r2,r2,#8              ;276
0000ca  e7d1              B        |L14.112|
                  |L14.204|
0000cc  f0420204          ORR      r2,r2,#4              ;286
0000d0  e7d5              B        |L14.126|
                  |L14.210|
0000d2  1c49              ADDS     r1,r1,#1              ;286
                  |L14.212|
0000d4  6842              LDR      r2,[r0,#4]            ;306
0000d6  07d2              LSLS     r2,r2,#31             ;306
0000d8  d001              BEQ      |L14.222|
0000da  4299              CMP      r1,r3                 ;306
0000dc  d1f9              BNE      |L14.210|
                  |L14.222|
0000de  6840              LDR      r0,[r0,#4]            ;312
0000e0  07c0              LSLS     r0,r0,#31             ;312
0000e2  d1e2              BNE      |L14.170|
0000e4  2001              MOVS     r0,#1                 ;318
0000e6  bd10              POP      {r4,pc}
;;;325    
                          ENDP


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

                  CAN_MessagePending PROC
;;;820      */
;;;821    uint8_t CAN_MessagePending(CAN_TypeDef* CANx, uint8_t FIFONumber)
000000  4602              MOV      r2,r0
;;;822    {
;;;823      uint8_t message_pending=0;
000002  2000              MOVS     r0,#0
000004  b129              CBZ      r1,|L15.18|
;;;824      /* Check the parameters */
;;;825      assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;826      assert_param(IS_CAN_FIFO(FIFONumber));
;;;827      if (FIFONumber == CAN_FIFO0)
;;;828      {
;;;829        message_pending = (uint8_t)(CANx->RF0R&(uint32_t)0x03);
;;;830      }
;;;831      else if (FIFONumber == CAN_FIFO1)
000006  2901              CMP      r1,#1
000008  d102              BNE      |L15.16|
;;;832      {
;;;833        message_pending = (uint8_t)(CANx->RF1R&(uint32_t)0x03);
00000a  6910              LDR      r0,[r2,#0x10]
                  |L15.12|
00000c  f0000003          AND      r0,r0,#3              ;829
                  |L15.16|
;;;834      }
;;;835      else
;;;836      {
;;;837        message_pending = 0;
;;;838      }
;;;839      return message_pending;
;;;840    }
000010  4770              BX       lr
                  |L15.18|
000012  68d0              LDR      r0,[r2,#0xc]          ;829
000014  e7fa              B        |L15.12|
;;;841    /**
                          ENDP


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

                  CAN_OperatingModeRequest PROC
;;;870      */
;;;871    uint8_t CAN_OperatingModeRequest(CAN_TypeDef* CANx, uint8_t CAN_OperatingMode)
000000  2300              MOVS     r3,#0
;;;872    {
;;;873      uint8_t status = CAN_ModeStatus_Failed;
;;;874      
;;;875      /* Timeout for INAK or also for SLAK bits*/
;;;876      uint32_t timeout = INAK_TIMEOUT; 
000002  f64f72ff          MOV      r2,#0xffff
000006  b121              CBZ      r1,|L16.18|
;;;877    
;;;878      /* Check the parameters */
;;;879      assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;880      assert_param(IS_CAN_OPERATING_MODE(CAN_OperatingMode));
;;;881    
;;;882      if (CAN_OperatingMode == CAN_OperatingMode_Initialization)
;;;883      {
;;;884        /* Request initialisation */
;;;885        CANx->MCR = (uint32_t)((CANx->MCR & (uint32_t)(~(uint32_t)CAN_MCR_SLEEP)) | CAN_MCR_INRQ);
;;;886    
;;;887        /* Wait the acknowledge */
;;;888        while (((CANx->MSR & CAN_MODE_MASK) != CAN_MSR_INAK) && (timeout != 0))
;;;889        {
;;;890          timeout--;
;;;891        }
;;;892        if ((CANx->MSR & CAN_MODE_MASK) != CAN_MSR_INAK)
;;;893        {
;;;894          status = CAN_ModeStatus_Failed;
;;;895        }
;;;896        else
;;;897        {
;;;898          status = CAN_ModeStatus_Success;
;;;899        }
;;;900      }
;;;901      else  if (CAN_OperatingMode == CAN_OperatingMode_Normal)
000008  2901              CMP      r1,#1
00000a  d017              BEQ      |L16.60|
;;;902      {
;;;903        /* Request leave initialisation and sleep mode  and enter Normal mode */
;;;904        CANx->MCR &= (uint32_t)(~(CAN_MCR_SLEEP|CAN_MCR_INRQ));
;;;905    
;;;906        /* Wait the acknowledge */
;;;907        while (((CANx->MSR & CAN_MODE_MASK) != 0) && (timeout!=0))
;;;908        {
;;;909          timeout--;
;;;910        }
;;;911        if ((CANx->MSR & CAN_MODE_MASK) != 0)
;;;912        {
;;;913          status = CAN_ModeStatus_Failed;
;;;914        }
;;;915        else
;;;916        {
;;;917          status = CAN_ModeStatus_Success;
;;;918        }
;;;919      }
;;;920      else  if (CAN_OperatingMode == CAN_OperatingMode_Sleep)
00000c  2902              CMP      r1,#2
00000e  d024              BEQ      |L16.90|
000010  e03a              B        |L16.136|
                  |L16.18|
000012  6801              LDR      r1,[r0,#0]            ;885
000014  f0210102          BIC      r1,r1,#2              ;885
000018  f0410101          ORR      r1,r1,#1              ;885
00001c  6001              STR      r1,[r0,#0]            ;885
00001e  e000              B        |L16.34|
                  |L16.32|
000020  1e52              SUBS     r2,r2,#1              ;888
                  |L16.34|
000022  6841              LDR      r1,[r0,#4]            ;888
000024  f0010103          AND      r1,r1,#3              ;888
000028  2901              CMP      r1,#1                 ;888
00002a  d001              BEQ      |L16.48|
00002c  2a00              CMP      r2,#0                 ;888
00002e  d1f7              BNE      |L16.32|
                  |L16.48|
000030  6840              LDR      r0,[r0,#4]            ;892
000032  f0000003          AND      r0,r0,#3              ;892
000036  2801              CMP      r0,#1                 ;892
000038  d123              BNE      |L16.130|
00003a  e024              B        |L16.134|
                  |L16.60|
00003c  6801              LDR      r1,[r0,#0]            ;904
00003e  f0210103          BIC      r1,r1,#3              ;904
000042  6001              STR      r1,[r0,#0]            ;904
000044  e000              B        |L16.72|
                  |L16.70|
000046  1e52              SUBS     r2,r2,#1              ;907
                  |L16.72|
000048  6841              LDR      r1,[r0,#4]            ;907
00004a  0789              LSLS     r1,r1,#30             ;907
00004c  d001              BEQ      |L16.82|
00004e  2a00              CMP      r2,#0                 ;907
000050  d1f9              BNE      |L16.70|
                  |L16.82|
000052  6840              LDR      r0,[r0,#4]            ;911
000054  0780              LSLS     r0,r0,#30             ;911
000056  d114              BNE      |L16.130|
000058  e015              B        |L16.134|
                  |L16.90|
;;;921      {
;;;922        /* Request Sleep mode */
;;;923        CANx->MCR = (uint32_t)((CANx->MCR & (uint32_t)(~(uint32_t)CAN_MCR_INRQ)) | CAN_MCR_SLEEP);
00005a  6801              LDR      r1,[r0,#0]
00005c  f0210101          BIC      r1,r1,#1
000060  f0410102          ORR      r1,r1,#2
000064  6001              STR      r1,[r0,#0]
;;;924    
;;;925        /* Wait the acknowledge */
;;;926        while (((CANx->MSR & CAN_MODE_MASK) != CAN_MSR_SLAK) && (timeout!=0))
000066  e000              B        |L16.106|
                  |L16.104|
000068  1e52              SUBS     r2,r2,#1
                  |L16.106|
00006a  6841              LDR      r1,[r0,#4]
00006c  f0010103          AND      r1,r1,#3
000070  2902              CMP      r1,#2
000072  d001              BEQ      |L16.120|
000074  2a00              CMP      r2,#0
000076  d1f7              BNE      |L16.104|
                  |L16.120|
;;;927        {
;;;928          timeout--;
;;;929        }
;;;930        if ((CANx->MSR & CAN_MODE_MASK) != CAN_MSR_SLAK)
000078  6840              LDR      r0,[r0,#4]
00007a  f0000003          AND      r0,r0,#3
00007e  2802              CMP      r0,#2
000080  d001              BEQ      |L16.134|
                  |L16.130|
;;;931        {
;;;932          status = CAN_ModeStatus_Failed;
000082  2300              MOVS     r3,#0
000084  e000              B        |L16.136|
                  |L16.134|
;;;933        }
;;;934        else
;;;935        {
;;;936          status = CAN_ModeStatus_Success;
000086  2301              MOVS     r3,#1
                  |L16.136|
;;;937        }
;;;938      }
;;;939      else
;;;940      {
;;;941        status = CAN_ModeStatus_Failed;
;;;942      }
;;;943    
;;;944      return  (uint8_t) status;
000088  4618              MOV      r0,r3
;;;945    }
00008a  4770              BX       lr
;;;946    
                          ENDP


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

                  CAN_Receive PROC
;;;748      */
;;;749    void CAN_Receive(CAN_TypeDef* CANx, uint8_t FIFONumber, CanRxMsg* RxMessage)
000000  b510              PUSH     {r4,lr}
;;;750    {
;;;751      /* Check the parameters */
;;;752      assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;753      assert_param(IS_CAN_FIFO(FIFONumber));
;;;754      /* Get the Id */
;;;755      RxMessage->IDE = (uint8_t)0x04 & CANx->sFIFOMailBox[FIFONumber].RIR;
000002  eb001301          ADD      r3,r0,r1,LSL #4
000006  f8d341b0          LDR      r4,[r3,#0x1b0]
00000a  f0140404          ANDS     r4,r4,#4
00000e  7214              STRB     r4,[r2,#8]
;;;756      if (RxMessage->IDE == CAN_Id_Standard)
;;;757      {
;;;758        RxMessage->StdId = (uint32_t)0x000007FF & (CANx->sFIFOMailBox[FIFONumber].RIR >> 21);
;;;759      }
;;;760      else
;;;761      {
;;;762        RxMessage->ExtId = (uint32_t)0x1FFFFFFF & (CANx->sFIFOMailBox[FIFONumber].RIR >> 3);
000010  f8d341b0          LDR      r4,[r3,#0x1b0]
000014  d033              BEQ      |L17.126|
000016  08e4              LSRS     r4,r4,#3
000018  6054              STR      r4,[r2,#4]
                  |L17.26|
;;;763      }
;;;764      
;;;765      RxMessage->RTR = (uint8_t)0x02 & CANx->sFIFOMailBox[FIFONumber].RIR;
00001a  f8d341b0          LDR      r4,[r3,#0x1b0]
00001e  f0040402          AND      r4,r4,#2
000022  7254              STRB     r4,[r2,#9]
;;;766      /* Get the DLC */
;;;767      RxMessage->DLC = (uint8_t)0x0F & CANx->sFIFOMailBox[FIFONumber].RDTR;
000024  f8d341b4          LDR      r4,[r3,#0x1b4]
000028  f004040f          AND      r4,r4,#0xf
00002c  7294              STRB     r4,[r2,#0xa]
;;;768      /* Get the FMI */
;;;769      RxMessage->FMI = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDTR >> 8);
00002e  f8d341b4          LDR      r4,[r3,#0x1b4]
000032  0a24              LSRS     r4,r4,#8
000034  74d4              STRB     r4,[r2,#0x13]
;;;770      /* Get the data field */
;;;771      RxMessage->Data[0] = (uint8_t)0xFF & CANx->sFIFOMailBox[FIFONumber].RDLR;
000036  f8d341b8          LDR      r4,[r3,#0x1b8]
00003a  72d4              STRB     r4,[r2,#0xb]
;;;772      RxMessage->Data[1] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 8);
00003c  f8d341b8          LDR      r4,[r3,#0x1b8]
000040  0a24              LSRS     r4,r4,#8
000042  7314              STRB     r4,[r2,#0xc]
;;;773      RxMessage->Data[2] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 16);
000044  f8d341b8          LDR      r4,[r3,#0x1b8]
000048  0c24              LSRS     r4,r4,#16
00004a  7354              STRB     r4,[r2,#0xd]
;;;774      RxMessage->Data[3] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 24);
00004c  f8d341b8          LDR      r4,[r3,#0x1b8]
000050  0e24              LSRS     r4,r4,#24
000052  7394              STRB     r4,[r2,#0xe]
;;;775      RxMessage->Data[4] = (uint8_t)0xFF & CANx->sFIFOMailBox[FIFONumber].RDHR;
000054  f8d341bc          LDR      r4,[r3,#0x1bc]
000058  73d4              STRB     r4,[r2,#0xf]
;;;776      RxMessage->Data[5] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 8);
00005a  f8d341bc          LDR      r4,[r3,#0x1bc]
00005e  0a24              LSRS     r4,r4,#8
000060  7414              STRB     r4,[r2,#0x10]
;;;777      RxMessage->Data[6] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 16);
000062  f8d341bc          LDR      r4,[r3,#0x1bc]
000066  0c24              LSRS     r4,r4,#16
000068  7454              STRB     r4,[r2,#0x11]
;;;778      RxMessage->Data[7] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 24);
00006a  f8d331bc          LDR      r3,[r3,#0x1bc]
00006e  0e1b              LSRS     r3,r3,#24
000070  7493              STRB     r3,[r2,#0x12]
;;;779      /* Release the FIFO */
;;;780      /* Release FIFO0 */
;;;781      if (FIFONumber == CAN_FIFO0)
000072  b139              CBZ      r1,|L17.132|
;;;782      {
;;;783        CANx->RF0R |= CAN_RF0R_RFOM0;
;;;784      }
;;;785      /* Release FIFO1 */
;;;786      else /* FIFONumber == CAN_FIFO1 */
;;;787      {
;;;788        CANx->RF1R |= CAN_RF1R_RFOM1;
000074  6901              LDR      r1,[r0,#0x10]
000076  f0410120          ORR      r1,r1,#0x20
00007a  6101              STR      r1,[r0,#0x10]
;;;789      }
;;;790    }
00007c  bd10              POP      {r4,pc}
                  |L17.126|
00007e  0d64              LSRS     r4,r4,#21             ;758
000080  6014              STR      r4,[r2,#0]            ;758
000082  e7ca              B        |L17.26|
                  |L17.132|
000084  68c1              LDR      r1,[r0,#0xc]          ;783
000086  f0410120          ORR      r1,r1,#0x20           ;783
00008a  60c1              STR      r1,[r0,#0xc]          ;783
00008c  bd10              POP      {r4,pc}
;;;791    
                          ENDP


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

                  CAN_SlaveStartBank PROC
;;;466      */
;;;467    void CAN_SlaveStartBank(uint8_t CAN_BankNumber) 
000000  4909              LDR      r1,|L18.40|
;;;468    {
;;;469      /* Check the parameters */
;;;470      assert_param(IS_CAN_BANKNUMBER(CAN_BankNumber));
;;;471      
;;;472      /* Enter Initialisation mode for the filter */
;;;473      CAN1->FMR |= FMR_FINIT;
000002  680a              LDR      r2,[r1,#0]
000004  f0420201          ORR      r2,r2,#1
000008  600a              STR      r2,[r1,#0]
;;;474      
;;;475      /* Select the start slave bank */
;;;476      CAN1->FMR &= (uint32_t)0xFFFFC0F1 ;
00000a  680a              LDR      r2,[r1,#0]
00000c  f643730e          MOV      r3,#0x3f0e
000010  439a              BICS     r2,r2,r3
000012  600a              STR      r2,[r1,#0]
;;;477      CAN1->FMR |= (uint32_t)(CAN_BankNumber)<<8;
000014  680a              LDR      r2,[r1,#0]
000016  ea422000          ORR      r0,r2,r0,LSL #8
00001a  6008              STR      r0,[r1,#0]
;;;478      
;;;479      /* Leave Initialisation mode for the filter */
;;;480      CAN1->FMR &= ~FMR_FINIT;
00001c  6808              LDR      r0,[r1,#0]
00001e  f0200001          BIC      r0,r0,#1
000022  6008              STR      r0,[r1,#0]
;;;481    }
000024  4770              BX       lr
;;;482    
                          ENDP

000026  0000              DCW      0x0000
                  |L18.40|
                          DCD      0x40006600

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

                  CAN_Sleep PROC
;;;951      */
;;;952    uint8_t CAN_Sleep(CAN_TypeDef* CANx)
000000  6802              LDR      r2,[r0,#0]
;;;953    {
;;;954      uint8_t sleepstatus = CAN_Sleep_Failed;
000002  2100              MOVS     r1,#0
;;;955      
;;;956      /* Check the parameters */
;;;957      assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;958        
;;;959      /* Request Sleep mode */
;;;960       CANx->MCR = (((CANx->MCR) & (uint32_t)(~(uint32_t)CAN_MCR_INRQ)) | CAN_MCR_SLEEP);
000004  f0220201          BIC      r2,r2,#1
000008  f0420202          ORR      r2,r2,#2
00000c  6002              STR      r2,[r0,#0]
;;;961       
;;;962      /* Sleep mode status */
;;;963      if ((CANx->MSR & (CAN_MSR_SLAK|CAN_MSR_INAK)) == CAN_MSR_SLAK)
00000e  6840              LDR      r0,[r0,#4]
000010  f0000003          AND      r0,r0,#3
000014  2802              CMP      r0,#2
000016  d100              BNE      |L19.26|
;;;964      {
;;;965        /* Sleep mode not entered */
;;;966        sleepstatus =  CAN_Sleep_Ok;
000018  2101              MOVS     r1,#1
                  |L19.26|
;;;967      }
;;;968      /* return sleep mode status */
;;;969       return (uint8_t)sleepstatus;
00001a  4608              MOV      r0,r1
;;;970    }
00001c  4770              BX       lr
;;;971    
                          ENDP


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

                  CAN_StructInit PROC
;;;423      */
;;;424    void CAN_StructInit(CAN_InitTypeDef* CAN_InitStruct)
000000  2100              MOVS     r1,#0
;;;425    {
;;;426      /* Reset CAN init structure parameters values */
;;;427      
;;;428      /* Initialize the time triggered communication mode */
;;;429      CAN_InitStruct->CAN_TTCM = DISABLE;
000002  7181              STRB     r1,[r0,#6]
;;;430      
;;;431      /* Initialize the automatic bus-off management */
;;;432      CAN_InitStruct->CAN_ABOM = DISABLE;
000004  71c1              STRB     r1,[r0,#7]
;;;433      
;;;434      /* Initialize the automatic wake-up mode */
;;;435      CAN_InitStruct->CAN_AWUM = DISABLE;
000006  7201              STRB     r1,[r0,#8]
;;;436      
;;;437      /* Initialize the no automatic retransmission */
;;;438      CAN_InitStruct->CAN_NART = DISABLE;
000008  7241              STRB     r1,[r0,#9]
;;;439      
;;;440      /* Initialize the receive FIFO locked mode */
;;;441      CAN_InitStruct->CAN_RFLM = DISABLE;
00000a  7281              STRB     r1,[r0,#0xa]
;;;442      
;;;443      /* Initialize the transmit FIFO priority */
;;;444      CAN_InitStruct->CAN_TXFP = DISABLE;
00000c  72c1              STRB     r1,[r0,#0xb]
;;;445      
;;;446      /* Initialize the CAN_Mode member */
;;;447      CAN_InitStruct->CAN_Mode = CAN_Mode_Normal;
00000e  7081              STRB     r1,[r0,#2]
;;;448      
;;;449      /* Initialize the CAN_SJW member */
;;;450      CAN_InitStruct->CAN_SJW = CAN_SJW_1tq;
000010  70c1              STRB     r1,[r0,#3]
;;;451      
;;;452      /* Initialize the CAN_BS1 member */
;;;453      CAN_InitStruct->CAN_BS1 = CAN_BS1_4tq;
000012  2103              MOVS     r1,#3
000014  7101              STRB     r1,[r0,#4]
;;;454      
;;;455      /* Initialize the CAN_BS2 member */
;;;456      CAN_InitStruct->CAN_BS2 = CAN_BS2_3tq;
000016  2102              MOVS     r1,#2
000018  7141              STRB     r1,[r0,#5]
;;;457      
;;;458      /* Initialize the CAN_Prescaler member */
;;;459      CAN_InitStruct->CAN_Prescaler = 1;
00001a  2101              MOVS     r1,#1
00001c  8001              STRH     r1,[r0,#0]
;;;460    }
00001e  4770              BX       lr
;;;461    
                          ENDP


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

                  CAN_TTComModeCmd PROC
;;;521      */
;;;522    void CAN_TTComModeCmd(CAN_TypeDef* CANx, FunctionalState NewState)
000000  2900              CMP      r1,#0
;;;523    {
;;;524      /* Check the parameters */
;;;525      assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;526      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;527      if (NewState != DISABLE)
;;;528      {
;;;529        /* Enable the TTCM mode */
;;;530        CANx->MCR |= CAN_MCR_TTCM;
;;;531    
;;;532        /* Set TGT bits */
;;;533        CANx->sTxMailBox[0].TDTR |= ((uint32_t)CAN_TDT0R_TGT);
;;;534        CANx->sTxMailBox[1].TDTR |= ((uint32_t)CAN_TDT1R_TGT);
;;;535        CANx->sTxMailBox[2].TDTR |= ((uint32_t)CAN_TDT2R_TGT);
;;;536      }
;;;537      else
;;;538      {
;;;539        /* Disable the TTCM mode */
;;;540        CANx->MCR &= (uint32_t)(~(uint32_t)CAN_MCR_TTCM);
000002  6801              LDR      r1,[r0,#0]
000004  d013              BEQ      |L21.46|
000006  f0410180          ORR      r1,r1,#0x80           ;530
00000a  6001              STR      r1,[r0,#0]            ;530
00000c  f8d01184          LDR      r1,[r0,#0x184]        ;533
000010  f4417180          ORR      r1,r1,#0x100          ;533
000014  f8c01184          STR      r1,[r0,#0x184]        ;533
000018  f8d01194          LDR      r1,[r0,#0x194]        ;534
00001c  f4417180          ORR      r1,r1,#0x100          ;534
000020  f8c01194          STR      r1,[r0,#0x194]        ;534
000024  f8d011a4          LDR      r1,[r0,#0x1a4]        ;535
000028  f4417180          ORR      r1,r1,#0x100          ;535
00002c  e012              B        |L21.84|
                  |L21.46|
00002e  f0210180          BIC      r1,r1,#0x80
000032  6001              STR      r1,[r0,#0]
;;;541    
;;;542        /* Reset TGT bits */
;;;543        CANx->sTxMailBox[0].TDTR &= ((uint32_t)~CAN_TDT0R_TGT);
000034  f8d01184          LDR      r1,[r0,#0x184]
000038  f4217180          BIC      r1,r1,#0x100
00003c  f8c01184          STR      r1,[r0,#0x184]
;;;544        CANx->sTxMailBox[1].TDTR &= ((uint32_t)~CAN_TDT1R_TGT);
000040  f8d01194          LDR      r1,[r0,#0x194]
000044  f4217180          BIC      r1,r1,#0x100
000048  f8c01194          STR      r1,[r0,#0x194]
;;;545        CANx->sTxMailBox[2].TDTR &= ((uint32_t)~CAN_TDT2R_TGT);
00004c  f8d011a4          LDR      r1,[r0,#0x1a4]
000050  f4217180          BIC      r1,r1,#0x100
                  |L21.84|
000054  f8c011a4          STR      r1,[r0,#0x1a4]        ;535
;;;546      }
;;;547    }
000058  4770              BX       lr
;;;548    /**
                          ENDP


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

                  CAN_Transmit PROC
;;;575      */
;;;576    uint8_t CAN_Transmit(CAN_TypeDef* CANx, CanTxMsg* TxMessage)
000000  b530              PUSH     {r4,r5,lr}
;;;577    {
000002  4602              MOV      r2,r0
;;;578      uint8_t transmit_mailbox = 0;
000004  2000              MOVS     r0,#0
;;;579      /* Check the parameters */
;;;580      assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;581      assert_param(IS_CAN_IDTYPE(TxMessage->IDE));
;;;582      assert_param(IS_CAN_RTR(TxMessage->RTR));
;;;583      assert_param(IS_CAN_DLC(TxMessage->DLC));
;;;584    
;;;585      /* Select one empty transmit mailbox */
;;;586      if ((CANx->TSR&CAN_TSR_TME0) == CAN_TSR_TME0)
000006  6893              LDR      r3,[r2,#8]
000008  015b              LSLS     r3,r3,#5
00000a  d408              BMI      |L22.30|
;;;587      {
;;;588        transmit_mailbox = 0;
;;;589      }
;;;590      else if ((CANx->TSR&CAN_TSR_TME1) == CAN_TSR_TME1)
00000c  6890              LDR      r0,[r2,#8]
00000e  0100              LSLS     r0,r0,#4
000010  d501              BPL      |L22.22|
;;;591      {
;;;592        transmit_mailbox = 1;
000012  2001              MOVS     r0,#1
000014  e003              B        |L22.30|
                  |L22.22|
;;;593      }
;;;594      else if ((CANx->TSR&CAN_TSR_TME2) == CAN_TSR_TME2)
000016  6890              LDR      r0,[r2,#8]
000018  00c0              LSLS     r0,r0,#3
00001a  d537              BPL      |L22.140|
;;;595      {
;;;596        transmit_mailbox = 2;
00001c  2002              MOVS     r0,#2
                  |L22.30|
;;;597      }
;;;598      else
;;;599      {
;;;600        transmit_mailbox = CAN_TxStatus_NoMailBox;
;;;601      }
;;;602    
;;;603      if (transmit_mailbox != CAN_TxStatus_NoMailBox)
;;;604      {
;;;605        /* Set up the Id */
;;;606        CANx->sTxMailBox[transmit_mailbox].TIR &= TMIDxR_TXRQ;
00001e  eb021200          ADD      r2,r2,r0,LSL #4
000022  f8d23180          LDR      r3,[r2,#0x180]
000026  f0030301          AND      r3,r3,#1
00002a  f8c23180          STR      r3,[r2,#0x180]
;;;607        if (TxMessage->IDE == CAN_Id_Standard)
00002e  7a0b              LDRB     r3,[r1,#8]
000030  b373              CBZ      r3,|L22.144|
;;;608        {
;;;609          assert_param(IS_CAN_STDID(TxMessage->StdId));  
;;;610          CANx->sTxMailBox[transmit_mailbox].TIR |= ((TxMessage->StdId << 21) | \
;;;611                                                      TxMessage->RTR);
;;;612        }
;;;613        else
;;;614        {
;;;615          assert_param(IS_CAN_EXTID(TxMessage->ExtId));
;;;616          CANx->sTxMailBox[transmit_mailbox].TIR |= ((TxMessage->ExtId << 3) | \
000032  f8d24180          LDR      r4,[r2,#0x180]
000036  684d              LDR      r5,[r1,#4]
000038  431c              ORRS     r4,r4,r3
00003a  7a4b              LDRB     r3,[r1,#9]
00003c  ea4303c5          ORR      r3,r3,r5,LSL #3
000040  431c              ORRS     r4,r4,r3
000042  f8c24180          STR      r4,[r2,#0x180]
                  |L22.70|
;;;617                                                      TxMessage->IDE | \
;;;618                                                      TxMessage->RTR);
;;;619        }
;;;620        
;;;621        /* Set up the DLC */
;;;622        TxMessage->DLC &= (uint8_t)0x0000000F;
000046  7a8b              LDRB     r3,[r1,#0xa]
000048  f003030f          AND      r3,r3,#0xf
00004c  728b              STRB     r3,[r1,#0xa]
;;;623        CANx->sTxMailBox[transmit_mailbox].TDTR &= (uint32_t)0xFFFFFFF0;
00004e  f8d23184          LDR      r3,[r2,#0x184]
000052  f023030f          BIC      r3,r3,#0xf
000056  f8c23184          STR      r3,[r2,#0x184]
;;;624        CANx->sTxMailBox[transmit_mailbox].TDTR |= TxMessage->DLC;
00005a  f8d23184          LDR      r3,[r2,#0x184]
00005e  7a8c              LDRB     r4,[r1,#0xa]
000060  4323              ORRS     r3,r3,r4
000062  f8c23184          STR      r3,[r2,#0x184]
;;;625    
;;;626        /* Set up the data field */
;;;627        CANx->sTxMailBox[transmit_mailbox].TDLR = (((uint32_t)TxMessage->Data[3] << 24) | 
000066  7acb              LDRB     r3,[r1,#0xb]
000068  68cc              LDR      r4,[r1,#0xc]
00006a  ea432304          ORR      r3,r3,r4,LSL #8
00006e  f8c23188          STR      r3,[r2,#0x188]
;;;628                                                 ((uint32_t)TxMessage->Data[2] << 16) |
;;;629                                                 ((uint32_t)TxMessage->Data[1] << 8) | 
;;;630                                                 ((uint32_t)TxMessage->Data[0]));
;;;631        CANx->sTxMailBox[transmit_mailbox].TDHR = (((uint32_t)TxMessage->Data[7] << 24) | 
000072  7bcb              LDRB     r3,[r1,#0xf]
000074  6909              LDR      r1,[r1,#0x10]
000076  ea432101          ORR      r1,r3,r1,LSL #8
00007a  f8c2118c          STR      r1,[r2,#0x18c]
;;;632                                                 ((uint32_t)TxMessage->Data[6] << 16) |
;;;633                                                 ((uint32_t)TxMessage->Data[5] << 8) |
;;;634                                                 ((uint32_t)TxMessage->Data[4]));
;;;635        /* Request transmission */
;;;636        CANx->sTxMailBox[transmit_mailbox].TIR |= TMIDxR_TXRQ;
00007e  f8d21180          LDR      r1,[r2,#0x180]
000082  f0410101          ORR      r1,r1,#1
000086  f8c21180          STR      r1,[r2,#0x180]
;;;637      }
;;;638      return transmit_mailbox;
;;;639    }
00008a  bd30              POP      {r4,r5,pc}
                  |L22.140|
00008c  2004              MOVS     r0,#4                 ;600
00008e  bd30              POP      {r4,r5,pc}
                  |L22.144|
000090  f8d23180          LDR      r3,[r2,#0x180]        ;610
000094  7a4c              LDRB     r4,[r1,#9]            ;610
000096  4323              ORRS     r3,r3,r4              ;610
000098  880c              LDRH     r4,[r1,#0]            ;610
00009a  ea435344          ORR      r3,r3,r4,LSL #21      ;610
00009e  f8c23180          STR      r3,[r2,#0x180]        ;610
0000a2  e7d0              B        |L22.70|
;;;640    
                          ENDP


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

                  CAN_TransmitStatus PROC
;;;647      */
;;;648    uint8_t CAN_TransmitStatus(CAN_TypeDef* CANx, uint8_t TransmitMailbox)
000000  2200              MOVS     r2,#0
;;;649    {
000002  b121              CBZ      r1,|L23.14|
;;;650      uint32_t state = 0;
;;;651    
;;;652      /* Check the parameters */
;;;653      assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;654      assert_param(IS_CAN_TRANSMITMAILBOX(TransmitMailbox));
;;;655     
;;;656      switch (TransmitMailbox)
000004  2901              CMP      r1,#1
000006  d005              BEQ      |L23.20|
000008  2902              CMP      r1,#2
00000a  d106              BNE      |L23.26|
00000c  e012              B        |L23.52|
                  |L23.14|
;;;657      {
;;;658        case (CAN_TXMAILBOX_0): 
;;;659          state =   CANx->TSR &  (CAN_TSR_RQCP0 | CAN_TSR_TXOK0 | CAN_TSR_TME0);
00000e  6882              LDR      r2,[r0,#8]
000010  4811              LDR      r0,|L23.88|
;;;660          break;
000012  e001              B        |L23.24|
                  |L23.20|
;;;661        case (CAN_TXMAILBOX_1): 
;;;662          state =   CANx->TSR &  (CAN_TSR_RQCP1 | CAN_TSR_TXOK1 | CAN_TSR_TME1);
000014  6882              LDR      r2,[r0,#8]
000016  4811              LDR      r0,|L23.92|
                  |L23.24|
000018  4002              ANDS     r2,r2,r0              ;659
                  |L23.26|
;;;663          break;
;;;664        case (CAN_TXMAILBOX_2): 
;;;665          state =   CANx->TSR &  (CAN_TSR_RQCP2 | CAN_TSR_TXOK2 | CAN_TSR_TME2);
;;;666          break;
;;;667        default:
;;;668          state = CAN_TxStatus_Failed;
;;;669          break;
;;;670      }
;;;671      switch (state)
00001a  4911              LDR      r1,|L23.96|
00001c  1a50              SUBS     r0,r2,r1
00001e  428a              CMP      r2,r1
000020  d014              BEQ      |L23.76|
000022  dc0a              BGT      |L23.58|
000024  b1a2              CBZ      r2,|L23.80|
000026  f06f6080          MVN      r0,#0x4000000
00002a  1810              ADDS     r0,r2,r0
00002c  d00f              BEQ      |L23.78|
00002e  2802              CMP      r0,#2
000030  d10c              BNE      |L23.76|
000032  e00f              B        |L23.84|
                  |L23.52|
000034  6882              LDR      r2,[r0,#8]            ;665
000036  480b              LDR      r0,|L23.100|
000038  e7ee              B        |L23.24|
                  |L23.58|
00003a  f5b07f00          CMP      r0,#0x200
00003e  d009              BEQ      |L23.84|
000040  4909              LDR      r1,|L23.104|
000042  1840              ADDS     r0,r0,r1
000044  d003              BEQ      |L23.78|
000046  f5b03f00          CMP      r0,#0x20000
00004a  d003              BEQ      |L23.84|
                  |L23.76|
;;;672      {
;;;673          /* transmit pending  */
;;;674        case (0x0): state = CAN_TxStatus_Pending;
;;;675          break;
;;;676          /* transmit failed  */
;;;677         case (CAN_TSR_RQCP0 | CAN_TSR_TME0): state = CAN_TxStatus_Failed;
;;;678          break;
;;;679         case (CAN_TSR_RQCP1 | CAN_TSR_TME1): state = CAN_TxStatus_Failed;
;;;680          break;
;;;681         case (CAN_TSR_RQCP2 | CAN_TSR_TME2): state = CAN_TxStatus_Failed;
;;;682          break;
;;;683          /* transmit succeeded  */
;;;684        case (CAN_TSR_RQCP0 | CAN_TSR_TXOK0 | CAN_TSR_TME0):state = CAN_TxStatus_Ok;
;;;685          break;
;;;686        case (CAN_TSR_RQCP1 | CAN_TSR_TXOK1 | CAN_TSR_TME1):state = CAN_TxStatus_Ok;
;;;687          break;
;;;688        case (CAN_TSR_RQCP2 | CAN_TSR_TXOK2 | CAN_TSR_TME2):state = CAN_TxStatus_Ok;
;;;689          break;
;;;690        default: state = CAN_TxStatus_Failed;
00004c  2000              MOVS     r0,#0
                  |L23.78|
;;;691          break;
;;;692      }
;;;693      return (uint8_t) state;
;;;694    }
00004e  4770              BX       lr
                  |L23.80|
000050  2002              MOVS     r0,#2                 ;674
000052  4770              BX       lr
                  |L23.84|
000054  2001              MOVS     r0,#1                 ;688
000056  4770              BX       lr
;;;695    
                          ENDP

                  |L23.88|
                          DCD      0x04000003
                  |L23.92|
                          DCD      0x08000300
                  |L23.96|
                          DCD      0x08000100
                  |L23.100|
                          DCD      0x10030000
                  |L23.104|
                          DCD      0xf7ff0100

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

                  CAN_WakeUp PROC
;;;976      */
;;;977    uint8_t CAN_WakeUp(CAN_TypeDef* CANx)
000000  6802              LDR      r2,[r0,#0]
;;;978    {
;;;979      uint32_t wait_slak = SLAK_TIMEOUT;
000002  f64f71ff          MOV      r1,#0xffff
;;;980      uint8_t wakeupstatus = CAN_WakeUp_Failed;
000006  2300              MOVS     r3,#0
;;;981      
;;;982      /* Check the parameters */
;;;983      assert_param(IS_CAN_ALL_PERIPH(CANx));
;;;984        
;;;985      /* Wake up request */
;;;986      CANx->MCR &= ~(uint32_t)CAN_MCR_SLEEP;
000008  f0220202          BIC      r2,r2,#2
00000c  6002              STR      r2,[r0,#0]
00000e  e000              B        |L24.18|
                  |L24.16|
000010  1e49              SUBS     r1,r1,#1              ;978
                  |L24.18|
;;;987        
;;;988      /* Sleep mode status */
;;;989      while(((CANx->MSR & CAN_MSR_SLAK) == CAN_MSR_SLAK)&&(wait_slak!=0x00))
000012  6842              LDR      r2,[r0,#4]
000014  0792              LSLS     r2,r2,#30
000016  d501              BPL      |L24.28|
000018  2900              CMP      r1,#0
00001a  d1f9              BNE      |L24.16|
                  |L24.28|
;;;990      {
;;;991       wait_slak--;
;;;992      }
;;;993      if((CANx->MSR & CAN_MSR_SLAK) != CAN_MSR_SLAK)
00001c  6840              LDR      r0,[r0,#4]
00001e  0780              LSLS     r0,r0,#30
000020  d400              BMI      |L24.36|
;;;994      {
;;;995       /* wake up done : Sleep mode exited */
;;;996        wakeupstatus = CAN_WakeUp_Ok;
000022  2301              MOVS     r3,#1
                  |L24.36|
;;;997      }
;;;998      /* return wakeup status */
;;;999      return (uint8_t)wakeupstatus;
000024  4618              MOV      r0,r3
;;;1000   }
000026  4770              BX       lr
;;;1001   /**
                          ENDP


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

                  CheckITStatus PROC
;;;1670     */
;;;1671   static ITStatus CheckITStatus(uint32_t CAN_Reg, uint32_t It_Bit)
000000  4602              MOV      r2,r0
;;;1672   {
;;;1673     ITStatus pendingbitstatus = RESET;
000002  2000              MOVS     r0,#0
;;;1674     
;;;1675     if ((CAN_Reg & It_Bit) != (uint32_t)RESET)
000004  420a              TST      r2,r1
000006  d000              BEQ      |L25.10|
;;;1676     {
;;;1677       /* CAN_IT is set */
;;;1678       pendingbitstatus = SET;
000008  2001              MOVS     r0,#1
                  |L25.10|
;;;1679     }
;;;1680     else
;;;1681     {
;;;1682       /* CAN_IT is reset */
;;;1683       pendingbitstatus = RESET;
;;;1684     }
;;;1685     return pendingbitstatus;
;;;1686   }
00000a  4770              BX       lr
;;;1687   
                          ENDP


;*** Start embedded assembler ***

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

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

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
