; generated by ARM C/C++ Compiler, 4.1 [Build 894]
; commandline ArmCC [--c99 --list --split_sections --debug -c --asm --interleave -o.\obj\nano1xx_smartcard.o --asm_dir=.\lst\ --list_dir=.\lst\ --depend=.\obj\nano1xx_smartcard.d --cpu=Cortex-M0 --apcs=interwork -I..\inc -I..\drv -I..\bsp -I..\bsp\Cmsis -I..\bsp\Driver -I..\bsp\system -I..\lib -I..\lib\libtk -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -D__MICROLIB -D__LCDDISPLAY_BTL001_H --omf_browse=.\obj\nano1xx_smartcard.crf ..\bsp\Driver\nano1xx_smartcard.c]
                          THUMB

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

                  DrvSMARTCARD_UartClose PROC
;;;1896     */
;;;1897   void DrvSMARTCARD_UartClose(SC_TypeDef *portno)
000000  b570              PUSH     {r4-r6,lr}
;;;1898   {
000002  4604              MOV      r4,r0
;;;1899   	S_SC_DEV_T *dev;
;;;1900   	int32_t port = 0;
000004  2500              MOVS     r5,#0
;;;1901   		
;;;1902   	assert_param(CHECK_SC_PORT(portno));
;;;1903   	DrvSMARTCARD_UartDisableInt(portno);
000006  f7fffffe          BL       DrvSMARTCARD_UartDisableInt
;;;1904   
;;;1905   	if(portno==SC0)
00000a  480a              LDR      r0,|L1.52|
00000c  4284              CMP      r4,r0
00000e  d008              BEQ      |L1.34|
;;;1906   		port = 0;
;;;1907   	else if(portno==SC1)
000010  4809              LDR      r0,|L1.56|
000012  4284              CMP      r4,r0
000014  d101              BNE      |L1.26|
;;;1908   		port = 1;
000016  2501              MOVS     r5,#1
000018  e003              B        |L1.34|
                  |L1.26|
;;;1909   	else if(portno==SC2)
00001a  4808              LDR      r0,|L1.60|
00001c  4284              CMP      r4,r0
00001e  d100              BNE      |L1.34|
;;;1910   		port = 2;
000020  2502              MOVS     r5,#2
                  |L1.34|
;;;1911   	
;;;1912   	dev= (S_SC_DEV_T *)(uint32_t)&sc_device[port];	
000022  20e0              MOVS     r0,#0xe0
000024  4345              MULS     r5,r0,r5
000026  4806              LDR      r0,|L1.64|
;;;1913   	dev->uart = 0;
000028  2100              MOVS     r1,#0
00002a  1828              ADDS     r0,r5,r0              ;1912
00002c  30c0              ADDS     r0,r0,#0xc0
00002e  7781              STRB     r1,[r0,#0x1e]
;;;1914   	portno->UACTL = 0;	
000030  6361              STR      r1,[r4,#0x34]
;;;1915   	
;;;1916   	return;
;;;1917   }
000032  bd70              POP      {r4-r6,pc}
;;;1918   
                          ENDP

                  |L1.52|
                          DCD      0x40190000
                  |L1.56|
                          DCD      0x401b0000
                  |L1.60|
                          DCD      0x401c0000
                  |L1.64|
                          DCD      ||.bss||+0x65c

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

                  DrvSMARTCARD_UartDisableInt PROC
;;;2000     */
;;;2001   void DrvSMARTCARD_UartDisableInt(SC_TypeDef *portno)
000000  4601              MOV      r1,r0
;;;2002   {
;;;2003   	IRQn_Type SC_IRQn = (portno==SC0)?SC0_IRQn:((portno==SC1)?SC1_IRQn:SC2_IRQn);
000002  4808              LDR      r0,|L2.36|
000004  b510              PUSH     {r4,lr}               ;2002
000006  4281              CMP      r1,r0
000008  d101              BNE      |L2.14|
00000a  2015              MOVS     r0,#0x15
00000c  e005              B        |L2.26|
                  |L2.14|
00000e  4806              LDR      r0,|L2.40|
000010  4281              CMP      r1,r0
000012  d101              BNE      |L2.24|
000014  2016              MOVS     r0,#0x16
000016  e000              B        |L2.26|
                  |L2.24|
000018  2014              MOVS     r0,#0x14
                  |L2.26|
;;;2004   
;;;2005   	portno->IER = 0;
00001a  2200              MOVS     r2,#0
00001c  618a              STR      r2,[r1,#0x18]
;;;2006   	NVIC_DisableIRQ(SC_IRQn);
00001e  f7fffffe          BL       NVIC_DisableIRQ
;;;2007   }
000022  bd10              POP      {r4,pc}
;;;2008   
                          ENDP

                  |L2.36|
                          DCD      0x40190000
                  |L2.40|
                          DCD      0x401b0000

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

                  DrvSMARTCARD_UartEnableInt PROC
;;;1987     */
;;;1988   void DrvSMARTCARD_UartEnableInt(SC_TypeDef *portno)
000000  4909              LDR      r1,|L3.40|
;;;1989   {
;;;1990   	IRQn_Type SC_IRQn = (portno==SC0)?SC0_IRQn:((portno==SC1)?SC1_IRQn:SC2_IRQn);
000002  4288              CMP      r0,r1
000004  d101              BNE      |L3.10|
000006  2115              MOVS     r1,#0x15
000008  e005              B        |L3.22|
                  |L3.10|
00000a  4908              LDR      r1,|L3.44|
00000c  4288              CMP      r0,r1
00000e  d101              BNE      |L3.20|
000010  2116              MOVS     r1,#0x16
000012  e000              B        |L3.22|
                  |L3.20|
000014  2114              MOVS     r1,#0x14
                  |L3.22|
;;;1991   
;;;1992   	portno->IER = 0x203;	// Enable tx, rx, and rx timeout
000016  4a06              LDR      r2,|L3.48|
000018  6182              STR      r2,[r0,#0x18]
00001a  06c9              LSLS     r1,r1,#27
00001c  0ec9              LSRS     r1,r1,#27
00001e  2001              MOVS     r0,#1
000020  4088              LSLS     r0,r0,r1
000022  4904              LDR      r1,|L3.52|
000024  6008              STR      r0,[r1,#0]
;;;1993   	NVIC_EnableIRQ(SC_IRQn);
;;;1994   }
000026  4770              BX       lr
;;;1995   
                          ENDP

                  |L3.40|
                          DCD      0x40190000
                  |L3.44|
                          DCD      0x401b0000
                  |L3.48|
                          DCD      0x00000203
                  |L3.52|
                          DCD      0xe000e100

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

                  DrvSMARTCARD_UartOpen PROC
;;;1842     */
;;;1843   void DrvSMARTCARD_UartOpen(SC_TypeDef *portno, S_SC_UART *sParam)
000000  b5f8              PUSH     {r3-r7,lr}
;;;1844   {
000002  4605              MOV      r5,r0
;;;1845   	S_SC_DEV_T *dev;
;;;1846   	int32_t port = 0, div;
;;;1847   		
;;;1848   	assert_param(CHECK_SC_PORT(portno));
;;;1849   	assert_param(sParam != NULL);
;;;1850   	assert_param(sParam->u16TimeOut < 0x200);
;;;1851   	assert_param((sParam->u32CharLen & ~SC_UACTL_DATA_LEN_MASK) == 0);
;;;1852   	assert_param((sParam->u32StopBitLen & ~SC_CTL_SLEN) == 0);
;;;1853   	assert_param((sParam->u32Parity & ~(SC_UACTL_PBDIS | SC_UACTL_OPE)) == 0);
;;;1854   	assert_param((sParam->u32RxTriggerLevel & ~SC_CTL_RX_FTRI_LEV_MASK) == 0);
;;;1855   
;;;1856   	if(portno==SC0)
000004  4a27              LDR      r2,|L4.164|
000006  2000              MOVS     r0,#0                 ;1846
000008  460e              MOV      r6,r1                 ;1844
00000a  4295              CMP      r5,r2
00000c  d005              BEQ      |L4.26|
;;;1857   		port = 0;
;;;1858   	else if(portno==SC1)
00000e  4826              LDR      r0,|L4.168|
000010  4285              CMP      r5,r0
000012  d101              BNE      |L4.24|
;;;1859   		port = 1;
000014  2001              MOVS     r0,#1
000016  e000              B        |L4.26|
                  |L4.24|
;;;1860   	else
;;;1861   		port = 2;
000018  2002              MOVS     r0,#2
                  |L4.26|
;;;1862   	
;;;1863   	dev= (S_SC_DEV_T *)(uint32_t)&sc_device[port];	
00001a  21e0              MOVS     r1,#0xe0
00001c  4348              MULS     r0,r1,r0
00001e  4923              LDR      r1,|L4.172|
000020  1844              ADDS     r4,r0,r1
;;;1864   	dev->uart = 1;
000022  2001              MOVS     r0,#1
000024  21de              MOVS     r1,#0xde
000026  5508              STRB     r0,[r1,r4]
;;;1865   
;;;1866           /* Get SC clock */
;;;1867           if( (CLK->CLKSEL2 & CLK_CLKSEL2_SC_MASK) == CLK_CLKSEL2_SC_HXT )  // form HXT
000028  4821              LDR      r0,|L4.176|
00002a  6981              LDR      r1,[r0,#0x18]
00002c  0309              LSLS     r1,r1,#12
00002e  0f8b              LSRS     r3,r1,#30
;;;1868                   dev->clock = (__XTAL/1000);
000030  4920              LDR      r1,|L4.180|
000032  d006              BEQ      |L4.66|
;;;1869           else if( (CLK->CLKSEL2 & CLK_CLKSEL2_SC_MASK) >= CLK_CLKSEL2_SC_HIRC )    // form HIRC
000034  6983              LDR      r3,[r0,#0x18]
000036  2703              MOVS     r7,#3
000038  04bf              LSLS     r7,r7,#18
00003a  403b              ANDS     r3,r3,r7
00003c  0287              LSLS     r7,r0,#10
00003e  42bb              CMP      r3,r7
000040  d300              BCC      |L4.68|
                  |L4.66|
;;;1870                   dev->clock = __IRC12M/1000;
000042  6121              STR      r1,[r4,#0x10]
                  |L4.68|
;;;1871   
;;;1872           if(dev->base==SC0)
000044  6821              LDR      r1,[r4,#0]
000046  4291              CMP      r1,r2
000048  d102              BNE      |L4.80|
;;;1873                   dev->clock /= ((CLK->CLKDIV0 >> 28) + 1);
00004a  69c0              LDR      r0,[r0,#0x1c]
00004c  0f01              LSRS     r1,r0,#28
00004e  e007              B        |L4.96|
                  |L4.80|
;;;1874           else if(dev->base==SC1)
000050  4a15              LDR      r2,|L4.168|
;;;1875                   dev->clock /= ((CLK->CLKDIV1 & CLK_CLKDIV1_SC1_MASK) + 1);
;;;1876           else
;;;1877                   dev->clock /= ((CLK->CLKDIV1 >> 4) + 1);
000052  6a00              LDR      r0,[r0,#0x20]
000054  4291              CMP      r1,r2                 ;1874
000056  d102              BNE      |L4.94|
000058  0701              LSLS     r1,r0,#28             ;1875
00005a  0f09              LSRS     r1,r1,#28             ;1875
00005c  e000              B        |L4.96|
                  |L4.94|
00005e  0901              LSRS     r1,r0,#4
                  |L4.96|
000060  1c49              ADDS     r1,r1,#1              ;1875
000062  6920              LDR      r0,[r4,#0x10]         ;1875
000064  f7fffffe          BL       __aeabi_uidivmod
;;;1878   
;;;1879   	div = dev->clock / sParam->u32BaudRate - 1;
000068  6120              STR      r0,[r4,#0x10]
00006a  6837              LDR      r7,[r6,#0]
00006c  4639              MOV      r1,r7
00006e  f7fffffe          BL       __aeabi_uidivmod
000072  1e40              SUBS     r0,r0,#1
;;;1880   	if((dev->clock % sParam->u32BaudRate) > (sParam->u32BaudRate / 2))
000074  087a              LSRS     r2,r7,#1
000076  4291              CMP      r1,r2
000078  d900              BLS      |L4.124|
;;;1881   		div++;
00007a  1c40              ADDS     r0,r0,#1
                  |L4.124|
;;;1882   	portno->ETUCR = div;
00007c  6168              STR      r0,[r5,#0x14]
;;;1883   	portno->RFTMR = sParam->u16TimeOut;
00007e  8ab0              LDRH     r0,[r6,#0x14]
000080  6128              STR      r0,[r5,#0x10]
;;;1884   	portno->CTL = (portno->CTL & ~(SC_CTL_RX_FTRI_LEV_MASK | SC_CTL_SLEN)) | sParam->u32StopBitLen | sParam->u32RxTriggerLevel;	
000082  6931              LDR      r1,[r6,#0x10]
000084  68b0              LDR      r0,[r6,#8]
000086  4308              ORRS     r0,r0,r1
000088  6869              LDR      r1,[r5,#4]
00008a  4a0b              LDR      r2,|L4.184|
00008c  4011              ANDS     r1,r1,r2
00008e  4308              ORRS     r0,r0,r1
000090  6068              STR      r0,[r5,#4]
;;;1885   	portno->UACTL = sParam->u32Parity | sParam->u32CharLen | SC_UACTL_UA_MODE_EN;
000092  6871              LDR      r1,[r6,#4]
000094  68f0              LDR      r0,[r6,#0xc]
000096  4308              ORRS     r0,r0,r1
000098  2101              MOVS     r1,#1
00009a  4308              ORRS     r0,r0,r1
00009c  6368              STR      r0,[r5,#0x34]
;;;1886   	
;;;1887   	portno->ALTCTL = 3;		// reset FIFO. what ever inside is garbage before configuration finished.
00009e  2003              MOVS     r0,#3
0000a0  60a8              STR      r0,[r5,#8]
;;;1888   
;;;1889   	return;
;;;1890   }
0000a2  bdf8              POP      {r3-r7,pc}
;;;1891   
                          ENDP

                  |L4.164|
                          DCD      0x40190000
                  |L4.168|
                          DCD      0x401b0000
                  |L4.172|
                          DCD      ||.bss||+0x65c
                  |L4.176|
                          DCD      0x50000200
                  |L4.180|
                          DCD      0x00002ee0
                  |L4.184|
                          DCD      0xffff7f3f

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

                  DrvSMARTCARD_UartRead PROC
;;;1925     */
;;;1926   int32_t DrvSMARTCARD_UartRead(SC_TypeDef *portno, uint8_t *pu8RxBuf, uint32_t u32ReadBytes)
000000  b570              PUSH     {r4-r6,lr}
;;;1927   {
000002  4604              MOV      r4,r0
;;;1928   
;;;1929       uint32_t  u32Count, u32delayno;
;;;1930   
;;;1931   	assert_param(CHECK_SC_PORT(portno));
;;;1932   	assert_param(pu8RxBuf != NULL);
;;;1933   
;;;1934   	for (u32Count=0; u32Count < u32ReadBytes; u32Count++)
000004  2000              MOVS     r0,#0
;;;1935   	{
;;;1936   		u32delayno = 0;
;;;1937   		while (portno->TRSR & SC_TRSR_RX_EMPTY_F) /* Check RX empty => failed */	
;;;1938   		{
;;;1939   			u32delayno++;
;;;1940   			if ( u32delayno >= 0x40000000 )
000006  2501              MOVS     r5,#1
000008  07ad              LSLS     r5,r5,#30
00000a  e00a              B        |L5.34|
                  |L5.12|
00000c  2300              MOVS     r3,#0                 ;1936
00000e  e002              B        |L5.22|
                  |L5.16|
000010  1c5b              ADDS     r3,r3,#1              ;1939
000012  42ab              CMP      r3,r5
000014  d207              BCS      |L5.38|
                  |L5.22|
000016  6a26              LDR      r6,[r4,#0x20]         ;1937
000018  07b6              LSLS     r6,r6,#30             ;1937
00001a  d4f9              BMI      |L5.16|
;;;1941   				goto out;
;;;1942   		}
;;;1943   		pu8RxBuf[u32Count] = portno->RBR;					    /* Get Data from UART RX  */
00001c  6823              LDR      r3,[r4,#0]
00001e  540b              STRB     r3,[r1,r0]
000020  1c40              ADDS     r0,r0,#1              ;1934
                  |L5.34|
000022  4290              CMP      r0,r2                 ;1934
000024  d3f2              BCC      |L5.12|
                  |L5.38|
;;;1944   	}
;;;1945   
;;;1946   out:
;;;1947   	return(u32Count);
;;;1948   }
000026  bd70              POP      {r4-r6,pc}
;;;1949   
                          ENDP


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

                  DrvSMARTCARD_UartWrite PROC
;;;1956     */
;;;1957   int32_t DrvSMARTCARD_UartWrite(SC_TypeDef *portno, uint8_t *pu8TxBuf, uint32_t u32WriteBytes)
000000  b570              PUSH     {r4-r6,lr}
;;;1958   {
000002  4604              MOV      r4,r0
;;;1959   
;;;1960       uint32_t  u32Count, u32delayno;
;;;1961   
;;;1962   	assert_param(CHECK_SC_PORT(portno));
;;;1963   	assert_param(pu8TxBuf != NULL);
;;;1964   
;;;1965   	for (u32Count=0; u32Count < u32WriteBytes; u32Count++)
000004  2000              MOVS     r0,#0
;;;1966   	{
;;;1967   		u32delayno = 0;
;;;1968   		while (portno->TRSR & SC_TRSR_TX_FULL_F)  /* Wait Tx empty and Time-out manner */
;;;1969   		{
;;;1970   			u32delayno++;
;;;1971   			if ( u32delayno >= 0x40000000 )     	
000006  2501              MOVS     r5,#1
000008  07ad              LSLS     r5,r5,#30
00000a  e00a              B        |L6.34|
                  |L6.12|
00000c  2300              MOVS     r3,#0                 ;1967
00000e  e002              B        |L6.22|
                  |L6.16|
000010  1c5b              ADDS     r3,r3,#1              ;1970
000012  42ab              CMP      r3,r5
000014  d207              BCS      |L6.38|
                  |L6.22|
000016  6a26              LDR      r6,[r4,#0x20]         ;1968
000018  0576              LSLS     r6,r6,#21             ;1968
00001a  d4f9              BMI      |L6.16|
;;;1972   				goto out;     	
;;;1973   				
;;;1974   		}
;;;1975   		portno->THR = pu8TxBuf[u32Count]; /* Send UART Data from buffer */
00001c  5c0b              LDRB     r3,[r1,r0]
00001e  6023              STR      r3,[r4,#0]
000020  1c40              ADDS     r0,r0,#1              ;1965
                  |L6.34|
000022  4290              CMP      r0,r2                 ;1965
000024  d3f2              BCC      |L6.12|
                  |L6.38|
;;;1976   	}
;;;1977   
;;;1978   out:
;;;1979   	return(u32Count);
;;;1980   
;;;1981   }
000026  bd70              POP      {r4-r6,pc}
;;;1982   
                          ENDP


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

                  NVIC_DisableIRQ PROC
;;;511     */
;;;512    __STATIC_INLINE void NVIC_DisableIRQ(IRQn_Type IRQn)
000000  06c1              LSLS     r1,r0,#27
;;;513    {
;;;514      NVIC->ICER[0] = (1 << ((uint32_t)(IRQn) & 0x1F));
000002  0ec9              LSRS     r1,r1,#27
000004  2001              MOVS     r0,#1
000006  4088              LSLS     r0,r0,r1
000008  4901              LDR      r1,|L7.16|
00000a  6008              STR      r0,[r1,#0]
;;;515    }
00000c  4770              BX       lr
;;;516    
                          ENDP

00000e  0000              DCW      0x0000
                  |L7.16|
                          DCD      0xe000e180

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

                          REQUIRE _printf_percent
                          REQUIRE _printf_s
                          REQUIRE _printf_str
                  SMARTCARD_ActivateCard PROC
;;;749      */
;;;750    static int32_t SMARTCARD_ActivateCard(S_SC_DEV_T *dev, int resettype)
000000  b5f3              PUSH     {r0,r1,r4-r7,lr}
;;;751    {
000002  b081              SUB      sp,sp,#4
000004  4604              MOV      r4,r0
;;;752            // remain is the remaining ATR length expecting, this value would be update at run time, offset stores distance to the next TD
;;;753            //int32_t remain = 2 /* TS & T0 */, offset = -1, tckflag = 0, length = 0;
;;;754            //uint8_t *atrbuffer;
;;;755            //SC_TypeDef *SC = dev->base;
;;;756    
;;;757            ENTER();
;;;758    
;;;759            SMARTCARD_ResetReader(dev);
000006  f7fffffe          BL       SMARTCARD_ResetReader
;;;760    
;;;761            //SMARTCARD_PowerOn();
;;;762    
;;;763            // TODO: set the default ETU clock & Interrupt enable & close all timer
;;;764            SMARTCARD_SetBaudrate(dev, 1, 1);        // default 1 ETU == 372 cycles
00000a  2201              MOVS     r2,#1
00000c  4611              MOV      r1,r2
00000e  4620              MOV      r0,r4
000010  f7fffffe          BL       SMARTCARD_SetBaudrate
;;;765    
;;;766            memset(&dev->CardCapabilities, 0, sizeof(SCARD_CARD_CAPABILITIES));
000014  4620              MOV      r0,r4
000016  2184              MOVS     r1,#0x84
000018  3024              ADDS     r0,r0,#0x24
00001a  f7fffffe          BL       __aeabi_memclr4
;;;767            memset(&dev->T0, 0, sizeof(T0_DATA));
00001e  4620              MOV      r0,r4
000020  3080              ADDS     r0,r0,#0x80
000022  2500              MOVS     r5,#0
000024  6505              STR      r5,[r0,#0x50]
;;;768            memset(&dev->T1, 0, sizeof(T1_DATA));
000026  6545              STR      r5,[r0,#0x54]
000028  3058              ADDS     r0,r0,#0x58
00002a  6005              STR      r5,[r0,#0]
00002c  8085              STRH     r5,[r0,#4]
;;;769    
;;;770            // stop timer0-2
;;;771            SMARTCARD_TimerStop(dev, (E_SC_TIMER)(SC_TIMER0 | SC_TIMER1 |SC_TIMER2));
00002e  2138              MOVS     r1,#0x38
000030  4620              MOV      r0,r4
000032  f7fffffe          BL       SMARTCARD_TimerStop
;;;772    
;;;773    
;;;774            /* reset the global variable for receiving ATR */
;;;775            if(dev->base==SC0) {
000036  4f2e              LDR      r7,|L8.240|
;;;776                    atr_len0=0, atr_remain0=2/* TS & T0 */;
000038  2102              MOVS     r1,#2
00003a  6826              LDR      r6,[r4,#0]            ;775
00003c  482d              LDR      r0,|L8.244|
;;;777                    ifbyte_flag0=-1/* interface bytes flag */, tck0=0, ifcount0=0;
00003e  1eca              SUBS     r2,r1,#3
;;;778                    atr_time0 = ATR_TOTAL_TIME;
000040  4b2d              LDR      r3,|L8.248|
000042  42be              CMP      r6,r7                 ;775
000044  d108              BNE      |L8.88|
000046  6005              STR      r5,[r0,#0]            ;777  ; atr_len0
000048  1d07              ADDS     r7,r0,#4              ;777
00004a  c726              STM      r7!,{r1,r2,r5}        ;777
;;;779                    atr_check_time0 = 0;
00004c  6105              STR      r5,[r0,#0x10]  ; ifcount0
;;;780                    atr_final_chk0 = 0;
00004e  6485              STR      r5,[r0,#0x48]  ; atr_check_time0
;;;781                    atr_total_time_start_flag0 = 0;
000050  6605              STR      r5,[r0,#0x60]  ; atr_final_chk0
000052  6545              STR      r5,[r0,#0x54]  ; atr_total_time_start_flag0
000054  63c3              STR      r3,[r0,#0x3c]  ; atr_time0
000056  e018              B        |L8.138|
                  |L8.88|
;;;782            } else if(dev->base==SC1) {
000058  4f28              LDR      r7,|L8.252|
00005a  42be              CMP      r6,r7
00005c  d109              BNE      |L8.114|
;;;783                    atr_len1=0, atr_remain1=2/* TS & T0 */;
;;;784                    ifbyte_flag1=-1/* interface bytes flag */, tck1=0, ifcount1=0;
00005e  6145              STR      r5,[r0,#0x14]  ; atr_len1
000060  6205              STR      r5,[r0,#0x20]  ; tck1
;;;785                    atr_time1 = ATR_TOTAL_TIME;
;;;786                    atr_check_time1 = 0;
000062  6245              STR      r5,[r0,#0x24]  ; ifcount1
;;;787                    atr_final_chk1 = 0;
000064  64c5              STR      r5,[r0,#0x4c]  ; atr_check_time1
;;;788                    atr_total_time_start_flag1 = 0;
000066  6645              STR      r5,[r0,#0x64]  ; atr_final_chk1
000068  6585              STR      r5,[r0,#0x58]  ; atr_total_time_start_flag1
00006a  6403              STR      r3,[r0,#0x40]  ; atr_time1
00006c  61c2              STR      r2,[r0,#0x1c]  ; ifbyte_flag1
00006e  6181              STR      r1,[r0,#0x18]  ; atr_remain1
000070  e00b              B        |L8.138|
                  |L8.114|
;;;789            } else if(dev->base==SC2) {
000072  4f23              LDR      r7,|L8.256|
000074  42be              CMP      r6,r7
000076  d108              BNE      |L8.138|
;;;790                    atr_len2=0, atr_remain2=2/* TS & T0 */;
;;;791                    ifbyte_flag2=-1/* interface bytes flag */, tck2=0, ifcount2=0;
000078  6285              STR      r5,[r0,#0x28]  ; atr_len2
00007a  6345              STR      r5,[r0,#0x34]  ; tck2
;;;792                    atr_time2 = ATR_TOTAL_TIME;
;;;793                    atr_check_time2 = 0;
00007c  6385              STR      r5,[r0,#0x38]  ; ifcount2
;;;794                    atr_final_chk2 = 0;
00007e  6505              STR      r5,[r0,#0x50]  ; atr_check_time2
;;;795                    atr_total_time_start_flag2 = 0;
000080  6685              STR      r5,[r0,#0x68]  ; atr_final_chk2
000082  65c5              STR      r5,[r0,#0x5c]  ; atr_total_time_start_flag2
000084  6443              STR      r3,[r0,#0x44]  ; atr_time2
000086  6302              STR      r2,[r0,#0x30]  ; ifbyte_flag2
000088  62c1              STR      r1,[r0,#0x2c]  ; atr_remain2
                  |L8.138|
;;;796            }
;;;797    
;;;798            /* read ATR */
;;;799            dev->CardCapabilities.ATR.Length = 0;
00008a  206c              MOVS     r0,#0x6c
00008c  5505              STRB     r5,[r0,r4]
;;;800    
;;;801    #ifndef SC_SEQ_MANUAL
;;;802            // wait for 40000 clks after pull RST high
;;;803            /* [ISO 7816-3] */
;;;804            //SMARTCARD_TimerCountSet(dev, SC_TIMER0, TIMER_DC_INITIAL_END, (40000/372) + 1);
;;;805            //SMARTCARD_TimerStart(dev, SC_TIMER0);
;;;806            // wait for 42000 clks after pull RST high
;;;807            /* [EMV 2000] */
;;;808            SMARTCARD_TimerCountSet(dev, SC_TIMER0, TIMER_DC_INITIAL_END, (42000/372) + 1);
;;;809            SMARTCARD_TimerStart(dev, SC_TIMER0);
;;;810    #endif
;;;811    
;;;812            // TODO: Do the activation or warm-reset sequence
;;;813            if(resettype == SC_COLDRESET)
00008e  9802              LDR      r0,[sp,#8]
000090  2801              CMP      r0,#1
000092  d002              BEQ      |L8.154|
;;;814                    SMARTCARD_ActivationCmd( dev );
;;;815            else if(resettype == SC_WARMRESET)
000094  2802              CMP      r0,#2
000096  d004              BEQ      |L8.162|
000098  e006              B        |L8.168|
                  |L8.154|
00009a  4620              MOV      r0,r4                 ;814
00009c  f7fffffe          BL       SMARTCARD_ActivationCmd
0000a0  e002              B        |L8.168|
                  |L8.162|
;;;816                    SMARTCARD_WarmResetCmd( dev );
0000a2  4620              MOV      r0,r4
0000a4  f7fffffe          BL       SMARTCARD_WarmResetCmd
                  |L8.168|
;;;817    
;;;818            // start IST to receive ATR
;;;819            dev->errno = 0;
;;;820            dev->op_state = SC_OP_ATR_READ;
0000a8  2001              MOVS     r0,#1
0000aa  60a5              STR      r5,[r4,#8]
0000ac  6060              STR      r0,[r4,#4]
;;;821    
;;;822            // TODO: wait the ISR to receive ATR done.
;;;823            while(dev->op_state==SC_OP_ATR_READ ) {
0000ae  e004              B        |L8.186|
                  |L8.176|
;;;824                    // [2011.11.28]
;;;825                    /* EMV Certification */
;;;826                    if(dev->errno == SC_ERR_TIME2OUT || dev->errno == SC_ERR_TIME0OUT)  // 2012-04-12 Add time0out avoid user insert card in wrong direction  --ya
0000b0  4628              MOV      r0,r5
0000b2  306d              ADDS     r0,r0,#0x6d
0000b4  d00f              BEQ      |L8.214|
0000b6  1c80              ADDS     r0,r0,#2
0000b8  d00d              BEQ      |L8.214|
                  |L8.186|
0000ba  6860              LDR      r0,[r4,#4]            ;823
0000bc  2801              CMP      r0,#1                 ;823
0000be  d0f7              BEQ      |L8.176|
;;;827                            break;
;;;828            }
;;;829            if(dev->errno < 0) {
0000c0  2d00              CMP      r5,#0
0000c2  da12              BGE      |L8.234|
;;;830                    // [2011.11.28]
;;;831                    /* EMV Certification */
;;;832                    if(dev->errno == SC_ERR_TIME2OUT ||
0000c4  4628              MOV      r0,r5
0000c6  306d              ADDS     r0,r0,#0x6d
0000c8  d005              BEQ      |L8.214|
;;;833                                    dev->errno == SC_ERR_TIME0OUT ||
0000ca  356f              ADDS     r5,r5,#0x6f
0000cc  d003              BEQ      |L8.214|
;;;834                                    (dev->base->PINCSR & SC_PINCSR_CD_PIN_ST) == 0)  // 2012-04-12 Add time0out avoid user insert card in wrong direction  --ya
0000ce  6820              LDR      r0,[r4,#0]
0000d0  6a40              LDR      r0,[r0,#0x24]
0000d2  06c0              LSLS     r0,r0,#27
0000d4  d402              BMI      |L8.220|
                  |L8.214|
;;;835                            SMARTCARD_DeactivationCmd(dev);
0000d6  4620              MOV      r0,r4
0000d8  f7fffffe          BL       SMARTCARD_DeactivationCmd
                  |L8.220|
;;;836                    printf("Failed to read ATR..Error Msg:%s \n", SMARTCARD_ERRMSG(dev->errno));
0000dc  68a0              LDR      r0,[r4,#8]
0000de  f7fffffe          BL       SMARTCARD_ERRMSG
0000e2  4601              MOV      r1,r0
0000e4  a007              ADR      r0,|L8.260|
0000e6  f7fffffe          BL       __2printf
                  |L8.234|
;;;837            } else
;;;838    
;;;839    #ifdef SC_ATR_DEBUG
;;;840            {
;;;841                    int32_t j;
;;;842                    printf("ATR : Length : %d\n", dev->CardCapabilities.ATR.Length);
;;;843                    for( j = 0; j < dev->CardCapabilities.ATR.Length; j ++) {
;;;844                            printf("%02x ", dev->CardCapabilities.ATR.Buffer[j]);
;;;845                    }
;;;846                    printf("\n");
;;;847            }
;;;848    #endif
;;;849    
;;;850            LEAVE();
;;;851    
;;;852            return dev->errno;
0000ea  68a0              LDR      r0,[r4,#8]
;;;853    }
0000ec  bdfe              POP      {r1-r7,pc}
;;;854    
                          ENDP

0000ee  0000              DCW      0x0000
                  |L8.240|
                          DCD      0x40190000
                  |L8.244|
                          DCD      ||.data||
                  |L8.248|
                          DCD      0x00004e52
                  |L8.252|
                          DCD      0x401b0000
                  |L8.256|
                          DCD      0x401c0000
                  |L8.260|
000104  4661696c          DCB      "Failed to read ATR..Error Msg:%s \n",0
000108  65642074
00010c  6f207265
000110  61642041
000114  54522e2e
000118  4572726f
00011c  72204d73
000120  673a2573
000124  200a00  
000127  00                DCB      0

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

                  SMARTCARD_ActivationCmd PROC
;;;367      */
;;;368    void SMARTCARD_ActivationCmd(S_SC_DEV_T *dev)
000000  b570              PUSH     {r4-r6,lr}
;;;369    {
;;;370            SC_TypeDef *SC = dev->base;
;;;371    
;;;372    #ifdef  SC_SEQ_MANUAL
;;;373            // disable Timer1 interrupt and use polling method to check time-out happened
;;;374            SC->IER &= ~SC_IER_TMR1_IE;
000002  6804              LDR      r4,[r0,#0]
000004  4605              MOV      r5,r0                 ;369
000006  69a0              LDR      r0,[r4,#0x18]
000008  2610              MOVS     r6,#0x10
00000a  43b0              BICS     r0,r0,r6
00000c  61a0              STR      r0,[r4,#0x18]
;;;375    
;;;376            // Power
;;;377            if(dev->ActivePowerPin)
00000e  2020              MOVS     r0,#0x20
000010  5d40              LDRB     r0,[r0,r5]
000012  2800              CMP      r0,#0
;;;378                    SC->PINCSR |= SC_PINCSR_POW_EN;
;;;379            else
;;;380                    SC->PINCSR &= ~SC_PINCSR_POW_EN;
000014  6a60              LDR      r0,[r4,#0x24]
000016  d002              BEQ      |L9.30|
000018  2101              MOVS     r1,#1                 ;378
00001a  4308              ORRS     r0,r0,r1              ;378
00001c  e001              B        |L9.34|
                  |L9.30|
00001e  0840              LSRS     r0,r0,#1
000020  0040              LSLS     r0,r0,#1
                  |L9.34|
000022  6260              STR      r0,[r4,#0x24]
;;;381            // Clock
;;;382            SMARTCARD_TimerCountSet(dev, SC_TIMER1, SC_TMR_MODE_DC, 1);
000024  2301              MOVS     r3,#1
000026  2200              MOVS     r2,#0
000028  2110              MOVS     r1,#0x10
00002a  4628              MOV      r0,r5
00002c  f7fffffe          BL       SMARTCARD_TimerCountSet
;;;383            SMARTCARD_TimerStart(dev, SC_TIMER1);
000030  2110              MOVS     r1,#0x10
000032  4628              MOV      r0,r5
000034  f7fffffe          BL       SMARTCARD_TimerStart
                  |L9.56|
;;;384            while(((SC->ISR & SC_ISR_TMR1_IS) == 0x00) && (dev->errno != SC_ERR_CARD_REMOVED)) ;
000038  69e0              LDR      r0,[r4,#0x1c]
00003a  06c0              LSLS     r0,r0,#27
00003c  d402              BMI      |L9.68|
00003e  68a8              LDR      r0,[r5,#8]
000040  3078              ADDS     r0,r0,#0x78
000042  d1f9              BNE      |L9.56|
                  |L9.68|
;;;385            SC->ISR = SC_ISR_TMR1_IS;
000044  61e6              STR      r6,[r4,#0x1c]
;;;386            SC->PINCSR |= SC_PINCSR_CLK_KEEP;
000046  6a60              LDR      r0,[r4,#0x24]
000048  2140              MOVS     r1,#0x40
00004a  4308              ORRS     r0,r0,r1
00004c  6260              STR      r0,[r4,#0x24]
;;;387            // I/O
;;;388            SC->PINCSR |= SC_PINCSR_SC_DATA_O;              // output HIGH
00004e  6a60              LDR      r0,[r4,#0x24]
000050  00c9              LSLS     r1,r1,#3
000052  4308              ORRS     r0,r0,r1
000054  6260              STR      r0,[r4,#0x24]
;;;389            // Reset
;;;390            //SMARTCARD_TimerCountSet(dev, SC_TIMER1, TIMER_DC, 108);       // 108*372 = 40176 clocks
;;;391            // [2011.11.24]
;;;392            /* EMV Certification: low clock cycles number(39814) from clk high to rst high (cold reset)  */
;;;393            SMARTCARD_TimerCountSet(dev, SC_TIMER1, SC_TMR_MODE_DC, 109);   // 108*372 = 40176 clocks
000056  236d              MOVS     r3,#0x6d
000058  2200              MOVS     r2,#0
00005a  2110              MOVS     r1,#0x10
00005c  4628              MOV      r0,r5
00005e  f7fffffe          BL       SMARTCARD_TimerCountSet
;;;394            SMARTCARD_TimerStart(dev, SC_TIMER1);
000062  2110              MOVS     r1,#0x10
000064  4628              MOV      r0,r5
000066  f7fffffe          BL       SMARTCARD_TimerStart
                  |L9.106|
;;;395            while(((SC->ISR & SC_ISR_TMR1_IS) == 0x00) && (dev->errno != SC_ERR_CARD_REMOVED)) ;
00006a  69e0              LDR      r0,[r4,#0x1c]
00006c  06c0              LSLS     r0,r0,#27
00006e  d402              BMI      |L9.118|
000070  68a8              LDR      r0,[r5,#8]
000072  3078              ADDS     r0,r0,#0x78
000074  d1f9              BNE      |L9.106|
                  |L9.118|
;;;396            SC->ISR = SC_ISR_TMR1_IS;
000076  61e6              STR      r6,[r4,#0x1c]
;;;397            // enable Timer1 interrupt
;;;398            SC->IER |= SC_IER_TMR1_IE;
000078  69a0              LDR      r0,[r4,#0x18]
00007a  4330              ORRS     r0,r0,r6
00007c  61a0              STR      r0,[r4,#0x18]
;;;399            SC->PINCSR |= SC_PINCSR_SC_RST;
00007e  6a60              LDR      r0,[r4,#0x24]
000080  2102              MOVS     r1,#2
000082  4308              ORRS     r0,r0,r1
000084  6260              STR      r0,[r4,#0x24]
;;;400            // wait 42036 clock for ATR
;;;401            SMARTCARD_TimerCountSet(dev, SC_TIMER0, SC_TMR_MODE_DC, (42000/372) + 13);
000086  237d              MOVS     r3,#0x7d
000088  2200              MOVS     r2,#0
00008a  2108              MOVS     r1,#8
00008c  4628              MOV      r0,r5
00008e  f7fffffe          BL       SMARTCARD_TimerCountSet
;;;402            SMARTCARD_TimerStart(dev, SC_TIMER0);
000092  2108              MOVS     r1,#8
000094  4628              MOV      r0,r5
000096  f7fffffe          BL       SMARTCARD_TimerStart
;;;403    #else
;;;404            SC->ALTCTL |= SC_ALTCTL_ACT_EN;
;;;405    #endif
;;;406    }
00009a  bd70              POP      {r4-r6,pc}
;;;407    /**
                          ENDP


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

                  SMARTCARD_CheckCardPresent PROC
;;;125      */
;;;126    int32_t SMARTCARD_CheckCardPresent(SC_TypeDef *portno)
000000  4a09              LDR      r2,|L10.40|
;;;127    {
;;;128            S_SC_DEV_T *dev;
;;;129            int32_t port = 0;
000002  2100              MOVS     r1,#0
;;;130    
;;;131            if(portno==SC0)
000004  4290              CMP      r0,r2
000006  d008              BEQ      |L10.26|
;;;132                    port = 0;
;;;133            else if(portno==SC1)
000008  4a08              LDR      r2,|L10.44|
00000a  4290              CMP      r0,r2
00000c  d101              BNE      |L10.18|
;;;134                    port = 1;
00000e  2101              MOVS     r1,#1
000010  e003              B        |L10.26|
                  |L10.18|
;;;135            else if(portno==SC2)
000012  4a07              LDR      r2,|L10.48|
000014  4290              CMP      r0,r2
000016  d100              BNE      |L10.26|
;;;136                    port = 2;
000018  2102              MOVS     r1,#2
                  |L10.26|
;;;137    
;;;138            dev= (S_SC_DEV_T *)(uint32_t)&sc_device[port];
00001a  20e0              MOVS     r0,#0xe0
00001c  4341              MULS     r1,r0,r1
00001e  4805              LDR      r0,|L10.52|
000020  1808              ADDS     r0,r1,r0
;;;139    
;;;140            return dev->bCardRemoved;
000022  30c0              ADDS     r0,r0,#0xc0
000024  6880              LDR      r0,[r0,#8]
;;;141    }
000026  4770              BX       lr
;;;142    
                          ENDP

                  |L10.40|
                          DCD      0x40190000
                  |L10.44|
                          DCD      0x401b0000
                  |L10.48|
                          DCD      0x401c0000
                  |L10.52|
                          DCD      ||.bss||+0x65c

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

                  SMARTCARD_ClearFIFO PROC
;;;248      */
;;;249    void SMARTCARD_ClearFIFO(S_SC_DEV_T *dev)
000000  6800              LDR      r0,[r0,#0]
                  |L11.2|
;;;250    {
;;;251            SC_TypeDef *SC = dev->base;
;;;252    
;;;253            /* Check if the end of initial end sequence */
;;;254            while(SC->ALTCTL & SC_ALTCTL_WARST_EN) ;
000002  6881              LDR      r1,[r0,#8]
000004  06c9              LSLS     r1,r1,#27
000006  d4fc              BMI      |L11.2|
                  |L11.8|
;;;255            while(SC->ALTCTL & SC_ALTCTL_ACT_EN) ;
000008  6881              LDR      r1,[r0,#8]
00000a  0709              LSLS     r1,r1,#28
00000c  d4fc              BMI      |L11.8|
                  |L11.14|
;;;256            while(SC->ALTCTL & SC_ALTCTL_DACT_EN) ;
00000e  6881              LDR      r1,[r0,#8]
000010  0749              LSLS     r1,r1,#29
000012  d4fc              BMI      |L11.14|
;;;257            SC->ALTCTL |= (SC_ALTCTL_TX_RST | SC_ALTCTL_RX_RST);
000014  6881              LDR      r1,[r0,#8]
000016  2203              MOVS     r2,#3
000018  4311              ORRS     r1,r1,r2
00001a  6081              STR      r1,[r0,#8]
;;;258    
;;;259    }
00001c  4770              BX       lr
;;;260    
                          ENDP


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

                  SMARTCARD_Close PROC
;;;1521     */
;;;1522   int32_t SMARTCARD_Close(SC_TypeDef *portno)
000000  b570              PUSH     {r4-r6,lr}
;;;1523   {
;;;1524           S_SC_DEV_T *dev;
;;;1525           IRQn_Type SC_IRQn;
;;;1526           SC_TypeDef *SC;
;;;1527           int32_t port = 0;
;;;1528   
;;;1529           ENTER();
;;;1530   
;;;1531           assert_param(CHECK_SC_PORT(portno));
;;;1532   
;;;1533           SC_IRQn = (portno==SC0)?SC0_IRQn:((portno==SC1)?SC1_IRQn:SC2_IRQn);
000002  4b12              LDR      r3,|L12.76|
000004  2100              MOVS     r1,#0                 ;1527
000006  4d12              LDR      r5,|L12.80|
000008  4298              CMP      r0,r3
00000a  d101              BNE      |L12.16|
00000c  2215              MOVS     r2,#0x15
00000e  e004              B        |L12.26|
                  |L12.16|
000010  42a8              CMP      r0,r5
000012  d101              BNE      |L12.24|
000014  2216              MOVS     r2,#0x16
000016  e000              B        |L12.26|
                  |L12.24|
000018  2214              MOVS     r2,#0x14
                  |L12.26|
;;;1534   
;;;1535           SC = portno;
00001a  4604              MOV      r4,r0
;;;1536           if(portno==SC0)
00001c  4298              CMP      r0,r3
00001e  d007              BEQ      |L12.48|
;;;1537                   port = 0;
;;;1538           else if(portno==SC1)
000020  42a8              CMP      r0,r5
000022  d101              BNE      |L12.40|
;;;1539                   port = 1;
000024  2101              MOVS     r1,#1
000026  e003              B        |L12.48|
                  |L12.40|
;;;1540           else if(portno==SC2)
000028  4b0a              LDR      r3,|L12.84|
00002a  429c              CMP      r4,r3
00002c  d100              BNE      |L12.48|
;;;1541                   port = 2;
00002e  2102              MOVS     r1,#2
                  |L12.48|
;;;1542   
;;;1543           dev = (S_SC_DEV_T *)((uint32_t)&sc_device[port]);
000030  20e0              MOVS     r0,#0xe0
000032  4341              MULS     r1,r0,r1
000034  4808              LDR      r0,|L12.88|
000036  180d              ADDS     r5,r1,r0
;;;1544           //if(dev->openflag == 0)
;;;1545           //      return(SC_EIO);
;;;1546   
;;;1547           // TODO: disable group mask
;;;1548   
;;;1549           /* Disable NVIC SmartCard interrupt */
;;;1550           NVIC_DisableIRQ(SC_IRQn);
000038  4610              MOV      r0,r2
00003a  f7fffffe          BL       NVIC_DisableIRQ
;;;1551   
;;;1552           SMARTCARD_DeactivationCmd( dev );          // de-activation
00003e  4628              MOV      r0,r5
000040  f7fffffe          BL       SMARTCARD_DeactivationCmd
;;;1553           //SMARTCARD_PowerOff();
;;;1554   
;;;1555           SC->IER = 0;            // disable all interrupt
000044  2000              MOVS     r0,#0
000046  61a0              STR      r0,[r4,#0x18]
;;;1556   
;;;1557           //free(dev->rcv_buf);
;;;1558   
;;;1559           dev->openflag = 0;
000048  60e8              STR      r0,[r5,#0xc]
;;;1560   
;;;1561           LEAVE();
;;;1562   
;;;1563           return SC_STATUS_SUCCESS;
;;;1564   }
00004a  bd70              POP      {r4-r6,pc}
;;;1565   
                          ENDP

                  |L12.76|
                          DCD      0x40190000
                  |L12.80|
                          DCD      0x401b0000
                  |L12.84|
                          DCD      0x401c0000
                  |L12.88|
                          DCD      ||.bss||+0x65c

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

                          REQUIRE _printf_percent
                          REQUIRE _printf_s
                          REQUIRE _printf_str
                  SMARTCARD_ColdReset PROC
;;;1117     */
;;;1118   int32_t SMARTCARD_ColdReset(S_SC_DEV_T *dev)
000000  b510              PUSH     {r4,lr}
;;;1119   {
000002  4604              MOV      r4,r0
;;;1120           ENTER();
;;;1121   
;;;1122           //SMARTCARD_DeactivationCmd(dev);          // de-activation
;;;1123           //SMARTCARD_PowerOff(dev);
;;;1124   
;;;1125           SMARTCARD_VoltageConfig(dev);
;;;1126           dev->errno = SMARTCARD_ActivateCard(dev, SC_COLDRESET);
000004  2101              MOVS     r1,#1
000006  f7fffffe          BL       SMARTCARD_ActivateCard
;;;1127   
;;;1128           if(dev->errno != 0)
00000a  60a0              STR      r0,[r4,#8]
00000c  2800              CMP      r0,#0
00000e  d118              BNE      |L13.66|
;;;1129                   return (dev->errno);
;;;1130   
;;;1131           dev->pps_complete = 0;
000010  2100              MOVS     r1,#0
000012  20cc              MOVS     r0,#0xcc
000014  5501              STRB     r1,[r0,r4]
;;;1132           dev->errno = SmartcardUpdateCardCapabilities(dev);
000016  4620              MOV      r0,r4
000018  f7fffffe          BL       SmartcardUpdateCardCapabilities
;;;1133   
;;;1134           if(dev->errno != 0)
00001c  60a0              STR      r0,[r4,#8]
00001e  2800              CMP      r0,#0
000020  d10f              BNE      |L13.66|
;;;1135                   return (dev->errno);
;;;1136   
;;;1137           dev->errno = SMARTCARD_ParseATR(dev, SC_COLDRESET);
000022  2101              MOVS     r1,#1
000024  4620              MOV      r0,r4
000026  f7fffffe          BL       SMARTCARD_ParseATR
;;;1138   
;;;1139           if(dev->errno != 0)
00002a  60a0              STR      r0,[r4,#8]
00002c  2800              CMP      r0,#0
00002e  d005              BEQ      |L13.60|
;;;1140                   printf("SMARTCARD_ColdReset:: ParseATR..Error Msg:%s \n", SMARTCARD_ERRMSG(dev->errno));
000030  f7fffffe          BL       SMARTCARD_ERRMSG
000034  4601              MOV      r1,r0
000036  a003              ADR      r0,|L13.68|
000038  f7fffffe          BL       __2printf
                  |L13.60|
;;;1141   
;;;1142           dev->openflag = 1;
00003c  2001              MOVS     r0,#1
;;;1143   
;;;1144           LEAVE();
;;;1145           return (dev->errno);
00003e  60e0              STR      r0,[r4,#0xc]
000040  68a0              LDR      r0,[r4,#8]
                  |L13.66|
;;;1146   }
000042  bd10              POP      {r4,pc}
;;;1147   
                          ENDP

                  |L13.68|
000044  534d4152          DCB      "SMARTCARD_ColdReset:: ParseATR..Error Msg:%s \n",0
000048  54434152
00004c  445f436f
000050  6c645265
000054  7365743a
000058  3a205061
00005c  72736541
000060  54522e2e
000064  4572726f
000068  72204d73
00006c  673a2573
000070  200a00  
000073  00                DCB      0

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

                  SMARTCARD_DeInit PROC
;;;1630     */
;;;1631   void SMARTCARD_DeInit(SC_TypeDef *portno)
000000  b510              PUSH     {r4,lr}
;;;1632   {
;;;1633           IRQn_Type SC_IRQn = (portno == SC0) ? SC0_IRQn : ((portno == SC1) ? SC1_IRQn : SC2_IRQn);
000002  4b11              LDR      r3,|L14.72|
000004  4c11              LDR      r4,|L14.76|
000006  4298              CMP      r0,r3
000008  d101              BNE      |L14.14|
00000a  2115              MOVS     r1,#0x15
00000c  e004              B        |L14.24|
                  |L14.14|
00000e  42a0              CMP      r0,r4
000010  d101              BNE      |L14.22|
000012  2116              MOVS     r1,#0x16
000014  e000              B        |L14.24|
                  |L14.22|
000016  2114              MOVS     r1,#0x14
                  |L14.24|
;;;1634           if(portno==SC0)
;;;1635                   CLK->APBCLK &= ~CLK_APBCLK_SC0_EN;
000018  4a0d              LDR      r2,|L14.80|
00001a  4298              CMP      r0,r3                 ;1634
00001c  d102              BNE      |L14.36|
00001e  6890              LDR      r0,[r2,#8]
000020  0553              LSLS     r3,r2,#21
000022  e00a              B        |L14.58|
                  |L14.36|
;;;1636           else if(portno==SC1)
000024  42a0              CMP      r0,r4
000026  d103              BNE      |L14.48|
;;;1637                   CLK->APBCLK &= ~CLK_APBCLK_SC1_EN;
000028  6890              LDR      r0,[r2,#8]
00002a  0040              LSLS     r0,r0,#1
00002c  0840              LSRS     r0,r0,#1
00002e  e005              B        |L14.60|
                  |L14.48|
;;;1638           else if(portno==SC2)
000030  4b08              LDR      r3,|L14.84|
000032  4298              CMP      r0,r3
000034  d103              BNE      |L14.62|
;;;1639                   CLK->APBCLK &= ~CLK_APBCLK_SC2_EN;
000036  6890              LDR      r0,[r2,#8]
000038  2380              MOVS     r3,#0x80
                  |L14.58|
00003a  4398              BICS     r0,r0,r3              ;1635
                  |L14.60|
00003c  6090              STR      r0,[r2,#8]
                  |L14.62|
;;;1640   
;;;1641           NVIC_DisableIRQ(SC_IRQn);
00003e  4608              MOV      r0,r1
000040  f7fffffe          BL       NVIC_DisableIRQ
;;;1642   }
000044  bd10              POP      {r4,pc}
;;;1643   
                          ENDP

000046  0000              DCW      0x0000
                  |L14.72|
                          DCD      0x40190000
                  |L14.76|
                          DCD      0x401b0000
                  |L14.80|
                          DCD      0x50000200
                  |L14.84|
                          DCD      0x401c0000

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

                  SMARTCARD_DeactivationCmd PROC
;;;335      */
;;;336    void SMARTCARD_DeactivationCmd(S_SC_DEV_T *dev)
000000  b510              PUSH     {r4,lr}
;;;337    {
;;;338            SC_TypeDef *SC = dev->base;
000002  6801              LDR      r1,[r0,#0]
                  |L15.4|
;;;339    
;;;340    #ifdef  SC_SEQ_MANUAL
;;;341            // Wait for Tx & Rx get into idle mode
;;;342            while(SC->TRSR & SC_TRSR_TX_ATV) ;
000004  6a0a              LDR      r2,[r1,#0x20]
000006  2a00              CMP      r2,#0
000008  dbfc              BLT      |L15.4|
;;;343            SC->ALTCTL |= SC_ALTCTL_TX_RST;
00000a  688a              LDR      r2,[r1,#8]
00000c  2301              MOVS     r3,#1
00000e  431a              ORRS     r2,r2,r3
000010  608a              STR      r2,[r1,#8]
                  |L15.18|
;;;344            while(SC->TRSR & SC_TRSR_RX_ATV) ;
000012  6a0a              LDR      r2,[r1,#0x20]
000014  0212              LSLS     r2,r2,#8
000016  d4fc              BMI      |L15.18|
;;;345            SC->ALTCTL |= SC_ALTCTL_RX_RST;
000018  688c              LDR      r4,[r1,#8]
00001a  2202              MOVS     r2,#2
00001c  4314              ORRS     r4,r4,r2
00001e  608c              STR      r4,[r1,#8]
;;;346            // Reset
;;;347            SC->PINCSR &= ~SC_PINCSR_SC_RST;
000020  6a4c              LDR      r4,[r1,#0x24]
000022  4394              BICS     r4,r4,r2
000024  624c              STR      r4,[r1,#0x24]
                  |L15.38|
;;;348            while(SC->PINCSR & SC_PINCSR_SC_RST) ;  // wait HW reset pin really becomes LOW
000026  6a4a              LDR      r2,[r1,#0x24]
000028  0792              LSLS     r2,r2,#30
00002a  d4fc              BMI      |L15.38|
;;;349            // Clock
;;;350            SC->PINCSR &= ~SC_PINCSR_CLK_KEEP;
00002c  6a4a              LDR      r2,[r1,#0x24]
00002e  2440              MOVS     r4,#0x40
000030  43a2              BICS     r2,r2,r4
000032  624a              STR      r2,[r1,#0x24]
;;;351            // I/O
;;;352            SC->PINCSR &= ~SC_PINCSR_SC_DATA_O;             // output LOW
000034  6a4a              LDR      r2,[r1,#0x24]
000036  00e4              LSLS     r4,r4,#3
000038  43a2              BICS     r2,r2,r4
00003a  624a              STR      r2,[r1,#0x24]
                  |L15.60|
;;;353            while(SC->PINCSR & SC_PINCSR_SC_DATA_O) ;       // wait HW I/O pin really becomes LOW
00003c  6a4a              LDR      r2,[r1,#0x24]
00003e  0592              LSLS     r2,r2,#22
000040  d4fc              BMI      |L15.60|
;;;354            // Power
;;;355            if(dev->ActivePowerPin)
000042  3020              ADDS     r0,r0,#0x20
000044  7800              LDRB     r0,[r0,#0]
000046  2800              CMP      r0,#0
;;;356                    SC->PINCSR &= ~SC_PINCSR_POW_EN;
;;;357            else
;;;358                    SC->PINCSR |= SC_PINCSR_POW_EN;
000048  6a48              LDR      r0,[r1,#0x24]
00004a  d002              BEQ      |L15.82|
00004c  0840              LSRS     r0,r0,#1              ;356
00004e  0040              LSLS     r0,r0,#1              ;356
000050  e000              B        |L15.84|
                  |L15.82|
000052  4318              ORRS     r0,r0,r3
                  |L15.84|
000054  6248              STR      r0,[r1,#0x24]         ;356
;;;359    #else
;;;360            SC->ALTCTL |= SC_ALTCTL_DACT_EN;
;;;361    #endif
;;;362    }
000056  bd10              POP      {r4,pc}
;;;363    /**
                          ENDP


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

                          REQUIRE _printf_pre_padding
                          REQUIRE _printf_percent
                          REQUIRE _printf_flags
                          REQUIRE _printf_widthprec
                          REQUIRE _printf_x
                          REQUIRE _printf_longlong_hex
                          REQUIRE _printf_s
                          REQUIRE _printf_str
                          REQUIRE _printf_str
                  SMARTCARD_DoPPS PROC
;;;1196     */
;;;1197   int32_t SMARTCARD_DoPPS(S_SC_DEV_T *dev, int32_t Fi, int32_t Di, int32_t T)
000000  b5fe              PUSH     {r1-r7,lr}
;;;1198   {
000002  4604              MOV      r4,r0
;;;1199           uint8_t buf[4];
;;;1200           uint8_t *rbuf;
;;;1201           int32_t len = 4, rPck=0;
;;;1202           SC_TypeDef *SC = dev->base;
;;;1203   
;;;1204           ENTER();
;;;1205   
;;;1206           buf[0] = 0xff;                                                           /* PPSS: PPS request use 0xFF */
000004  6805              LDR      r5,[r0,#0]
;;;1207           buf[1] = 0x10 |(T & 0x0f);                                      /* PPS0: PPS1 will be transmited + T transmission protocol */
000006  071b              LSLS     r3,r3,#28
000008  27ff              MOVS     r7,#0xff              ;1206
00000a  4668              MOV      r0,sp                 ;1206
00000c  0f1b              LSRS     r3,r3,#28
00000e  7107              STRB     r7,[r0,#4]            ;1206
000010  3310              ADDS     r3,r3,#0x10
000012  7143              STRB     r3,[r0,#5]
;;;1208           buf[2] = ((Fi<<4)&0xf0) | (Di & 0x0f);     /* PPS1: */
000014  0108              LSLS     r0,r1,#4
000016  0711              LSLS     r1,r2,#28
000018  0f09              LSRS     r1,r1,#28
00001a  4308              ORRS     r0,r0,r1
00001c  4669              MOV      r1,sp
;;;1209           buf[3] = (buf[0] ^ buf[1] ^ buf[2]);            /* PCK */
00001e  405f              EORS     r7,r7,r3
000020  7188              STRB     r0,[r1,#6]            ;1208
000022  4047              EORS     r7,r7,r0
000024  2604              MOVS     r6,#4                 ;1201
000026  71cf              STRB     r7,[r1,#7]
;;;1210   
;;;1211           SMARTCARD_ClearFIFO(dev);  // clear FIFO
000028  4620              MOV      r0,r4
00002a  f7fffffe          BL       SMARTCARD_ClearFIFO
;;;1212   
;;;1213           printf("Sending PPS : %02x %02x %02x %02x\n",
00002e  4669              MOV      r1,sp
000030  79c8              LDRB     r0,[r1,#7]
000032  9000              STR      r0,[sp,#0]
000034  798b              LDRB     r3,[r1,#6]
000036  794a              LDRB     r2,[r1,#5]
000038  7909              LDRB     r1,[r1,#4]
00003a  a03d              ADR      r0,|L16.304|
00003c  f7fffffe          BL       __2printf
;;;1214                  buf[0], buf[1], buf[2], buf[3]);
;;;1215   
;;;1216           SMARTCARD_TimerStop(dev, (E_SC_TIMER)(SC_TIMER0 | SC_TIMER1 |SC_TIMER2));   // stop timer0-2
000040  2138              MOVS     r1,#0x38
000042  4620              MOV      r0,r4
000044  f7fffffe          BL       SMARTCARD_TimerStop
;;;1217   
;;;1218   
;;;1219           // Waiting time check
;;;1220           // the waiting time of PPS is fixed at 9600 ETUs
;;;1221           SMARTCARD_TimerCountSet(dev, SC_TIMER0, SC_TMR_MODE_DC_RELOAD_S_S, 9600);
000048  234b              MOVS     r3,#0x4b
00004a  2207              MOVS     r2,#7
00004c  01db              LSLS     r3,r3,#7
00004e  0612              LSLS     r2,r2,#24
000050  2108              MOVS     r1,#8
000052  4620              MOV      r0,r4
000054  f7fffffe          BL       SMARTCARD_TimerCountSet
;;;1222           SMARTCARD_TimerStart(dev, SC_TIMER0);
000058  2108              MOVS     r1,#8
00005a  4620              MOV      r0,r4
00005c  f7fffffe          BL       SMARTCARD_TimerStart
;;;1223   
;;;1224   
;;;1225           /* Start to do PPS exchange */
;;;1226           dev->errno = 0;
000060  2300              MOVS     r3,#0
;;;1227           dev->snd_buf = buf;
000062  4621              MOV      r1,r4
000064  3180              ADDS     r1,r1,#0x80
000066  60a3              STR      r3,[r4,#8]
;;;1228           dev->snd_len = len;
;;;1229           dev->snd_pos = 0;
;;;1230           dev->op_state = SC_OP_WRITE;
000068  638e              STR      r6,[r1,#0x38]
00006a  a801              ADD      r0,sp,#4              ;1227
00006c  634b              STR      r3,[r1,#0x34]
00006e  62c8              STR      r0,[r1,#0x2c]
000070  2003              MOVS     r0,#3
000072  6060              STR      r0,[r4,#4]
;;;1231           SC->IER  |= SC_IER_TBE_IE;
000074  69a8              LDR      r0,[r5,#0x18]
000076  2702              MOVS     r7,#2
000078  4338              ORRS     r0,r0,r7
00007a  61a8              STR      r0,[r5,#0x18]
00007c  68a0              LDR      r0,[r4,#8]            ;1198
                  |L16.126|
;;;1232           while(dev->op_state == SC_OP_WRITE && !(dev->errno));
00007e  6862              LDR      r2,[r4,#4]
000080  2a03              CMP      r2,#3
000082  d101              BNE      |L16.136|
000084  2800              CMP      r0,#0
000086  d0fa              BEQ      |L16.126|
                  |L16.136|
;;;1233           dev->snd_buf = NULL;
;;;1234   
;;;1235           if(dev->errno != 0) {
000088  62cb              STR      r3,[r1,#0x2c]
00008a  2800              CMP      r0,#0
00008c  d004              BEQ      |L16.152|
;;;1236                   printf("SMARTCARD_DoPPS:: PPS Write..Error Msg:%s \n", SMARTCARD_ERRMSG(dev->errno));
00008e  f7fffffe          BL       SMARTCARD_ERRMSG
000092  4601              MOV      r1,r0
000094  a02f              ADR      r0,|L16.340|
;;;1237                   return dev->errno;
000096  e019              B        |L16.204|
                  |L16.152|
;;;1238           }
;;;1239   
;;;1240           /* Read Procedure bytes */
;;;1241           dev->errno = 0;
;;;1242           rbuf = dev->rcv_buf;
;;;1243           dev->rcv_pos = 0;
000098  4622              MOV      r2,r4
00009a  32c0              ADDS     r2,r2,#0xc0
00009c  6b0d              LDR      r5,[r1,#0x30]
;;;1244           dev->rcv_len = len;
00009e  6013              STR      r3,[r2,#0]
;;;1245           dev->rcv_cnt = 0;
0000a0  63ce              STR      r6,[r1,#0x3c]
;;;1246           dev->op_state = SC_OP_READ;
0000a2  6053              STR      r3,[r2,#4]
0000a4  6067              STR      r7,[r4,#4]
                  |L16.166|
;;;1247           while(dev->op_state == SC_OP_READ && (dev->bCardRemoved == SCARD_PRESENT) && !(dev->errno));
0000a6  6861              LDR      r1,[r4,#4]
0000a8  2902              CMP      r1,#2
0000aa  d104              BNE      |L16.182|
0000ac  6891              LDR      r1,[r2,#8]
0000ae  2904              CMP      r1,#4
0000b0  d101              BNE      |L16.182|
0000b2  2800              CMP      r0,#0
0000b4  d0f7              BEQ      |L16.166|
                  |L16.182|
;;;1248   
;;;1249           SMARTCARD_TimerStop(dev, SC_TIMER0);    // Stop timer
0000b6  2108              MOVS     r1,#8
0000b8  4620              MOV      r0,r4
0000ba  f7fffffe          BL       SMARTCARD_TimerStop
;;;1250   
;;;1251           if(dev->errno != 0) {
0000be  68a0              LDR      r0,[r4,#8]
0000c0  2800              CMP      r0,#0
0000c2  d007              BEQ      |L16.212|
;;;1252                   printf("SMARTCARD_DoPPS:: PPS Read..Error Msg:%s \n", SMARTCARD_ERRMSG(dev->errno));
0000c4  f7fffffe          BL       SMARTCARD_ERRMSG
0000c8  4601              MOV      r1,r0
0000ca  a02d              ADR      r0,|L16.384|
                  |L16.204|
0000cc  f7fffffe          BL       __2printf
;;;1253                   return dev->errno;
0000d0  68a0              LDR      r0,[r4,#8]
;;;1254           }
;;;1255   
;;;1256           printf("Received PPS : %02x %02x %02x %02x\n",
;;;1257                  rbuf[0], rbuf[1], rbuf[2], rbuf[3]);
;;;1258   
;;;1259           if(rbuf[0] != buf[0])   /* PPSS */
;;;1260                   return PROTOCOL_PPS_INVALID;
;;;1261   
;;;1262           rPck = rbuf[0];
;;;1263           if( (rbuf[1]&0x0f) == (buf[1] &0x0f) &&         /* success */  /* PPS0 */
;;;1264                           ((rbuf[1] & 0xf0) == 0x10 ||(rbuf[1] & 0xf0) == 0x00)) {
;;;1265                   rPck ^= rbuf[1];
;;;1266   
;;;1267                   printf("PPS Request Success, \n"/*now baudrate is %d\n", 9600 * Dtab[Di]*/);
;;;1268           } else
;;;1269                   return PROTOCOL_PPS_INVALID;
;;;1270   
;;;1271           if (rbuf[2] == buf[2])  /* PPS1 */
;;;1272                   rPck ^= rbuf[2];
;;;1273           else
;;;1274                   return PROTOCOL_PPS_INVALID;
;;;1275   
;;;1276           if (rbuf[3] != rPck)  /* PCK */
;;;1277                   return PROTOCOL_PPS_INVALID;
;;;1278   
;;;1279   
;;;1280           LEAVE();
;;;1281           return SC_STATUS_SUCCESS;
;;;1282   }
0000d2  bdfe              POP      {r1-r7,pc}
                  |L16.212|
0000d4  78e8              LDRB     r0,[r5,#3]            ;1256
0000d6  9000              STR      r0,[sp,#0]            ;1256
0000d8  78ab              LDRB     r3,[r5,#2]            ;1256
0000da  786a              LDRB     r2,[r5,#1]            ;1256
0000dc  7829              LDRB     r1,[r5,#0]            ;1256
0000de  a033              ADR      r0,|L16.428|
0000e0  f7fffffe          BL       __2printf
0000e4  4669              MOV      r1,sp                 ;1259
0000e6  7828              LDRB     r0,[r5,#0]            ;1259
0000e8  7909              LDRB     r1,[r1,#4]            ;1259
0000ea  2692              MOVS     r6,#0x92              ;1260
0000ec  43f6              MVNS     r6,r6                 ;1260
0000ee  4288              CMP      r0,r1                 ;1259
0000f0  d11a              BNE      |L16.296|
0000f2  466a              MOV      r2,sp                 ;1263
0000f4  786c              LDRB     r4,[r5,#1]            ;1263
0000f6  7952              LDRB     r2,[r2,#5]            ;1263
0000f8  0721              LSLS     r1,r4,#28             ;1263
0000fa  0712              LSLS     r2,r2,#28             ;1263
0000fc  0f09              LSRS     r1,r1,#28             ;1263
0000fe  0f12              LSRS     r2,r2,#28             ;1263
000100  4291              CMP      r1,r2                 ;1263
000102  d111              BNE      |L16.296|
000104  0921              LSRS     r1,r4,#4              ;1264
000106  2901              CMP      r1,#1                 ;1264
000108  d001              BEQ      |L16.270|
00010a  0921              LSRS     r1,r4,#4              ;1264
00010c  d10c              BNE      |L16.296|
                  |L16.270|
00010e  4044              EORS     r4,r4,r0              ;1265
000110  a02f              ADR      r0,|L16.464|
000112  f7fffffe          BL       __2printf
000116  4669              MOV      r1,sp                 ;1271
000118  78a8              LDRB     r0,[r5,#2]            ;1271
00011a  7989              LDRB     r1,[r1,#6]            ;1271
00011c  4288              CMP      r0,r1                 ;1271
00011e  d103              BNE      |L16.296|
000120  78e9              LDRB     r1,[r5,#3]            ;1276
000122  4060              EORS     r0,r0,r4              ;1272
000124  4281              CMP      r1,r0                 ;1276
000126  d001              BEQ      |L16.300|
                  |L16.296|
000128  4630              MOV      r0,r6                 ;1277
00012a  bdfe              POP      {r1-r7,pc}
                  |L16.300|
00012c  2000              MOVS     r0,#0                 ;1281
00012e  bdfe              POP      {r1-r7,pc}
;;;1283   
                          ENDP

                  |L16.304|
000130  53656e64          DCB      "Sending PPS : %02x %02x %02x %02x\n",0
000134  696e6720
000138  50505320
00013c  3a202530
000140  32782025
000144  30327820
000148  25303278
00014c  20253032
000150  780a00  
000153  00                DCB      0
                  |L16.340|
000154  534d4152          DCB      "SMARTCARD_DoPPS:: PPS Write..Error Msg:%s \n",0
000158  54434152
00015c  445f446f
000160  5050533a
000164  3a205050
000168  53205772
00016c  6974652e
000170  2e457272
000174  6f72204d
000178  73673a25
00017c  73200a00
                  |L16.384|
000180  534d4152          DCB      "SMARTCARD_DoPPS:: PPS Read..Error Msg:%s \n",0
000184  54434152
000188  445f446f
00018c  5050533a
000190  3a205050
000194  53205265
000198  61642e2e
00019c  4572726f
0001a0  72204d73
0001a4  673a2573
0001a8  200a00  
0001ab  00                DCB      0
                  |L16.428|
0001ac  52656365          DCB      "Received PPS : %02x %02x %02x %02x\n",0
0001b0  69766564
0001b4  20505053
0001b8  203a2025
0001bc  30327820
0001c0  25303278
0001c4  20253032
0001c8  78202530
0001cc  32780a00
                  |L16.464|
0001d0  50505320          DCB      "PPS Request Success, \n",0
0001d4  52657175
0001d8  65737420
0001dc  53756363
0001e0  6573732c
0001e4  200a00  
0001e7  00                DCB      0

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

                  SMARTCARD_ERRMSG PROC
;;;74       */
;;;75     uint8_t * SMARTCARD_ERRMSG(long errno)
000000  4601              MOV      r1,r0
;;;76     {
;;;77             if(errno == SC_ERR_CARD_REMOVED)
000002  3178              ADDS     r1,r1,#0x78
000004  d01a              BEQ      |L17.60|
;;;78                     return "SC_ERR_CARD_REMOVED";
;;;79             if(errno == SC_ERR_OVER_RUN)
000006  1e49              SUBS     r1,r1,#1
000008  d01a              BEQ      |L17.64|
;;;80                     return "SC_ERR_OVER_RUN";
;;;81             if(errno == SC_ERR_PARITY_ERROR)
00000a  1e49              SUBS     r1,r1,#1
00000c  d01a              BEQ      |L17.68|
;;;82                     return "SC_ERR_PARITY_ERROR";
;;;83             if(errno == SC_ERR_NO_STOP)
00000e  1e49              SUBS     r1,r1,#1
000010  d01a              BEQ      |L17.72|
;;;84                     return "SC_ERR_NO_STOP";
;;;85             if(errno == SC_ERR_SILENT_BYTE)
000012  1e49              SUBS     r1,r1,#1
000014  d01a              BEQ      |L17.76|
;;;86                     return "SC_ERR_SILENT_BYTE";
;;;87             if(errno == SC_ERR_CMD)
000016  1e49              SUBS     r1,r1,#1
000018  d01a              BEQ      |L17.80|
;;;88                     return "SC_ERR_CMD";
;;;89             if(errno == SC_ERR_UNSUPPORTEDCARD)
00001a  1e49              SUBS     r1,r1,#1
00001c  d01a              BEQ      |L17.84|
;;;90                     return "SC_ERR_UNSUPPORTEDCARD";
;;;91             if(errno == SC_ERR_READ)
00001e  1e49              SUBS     r1,r1,#1
000020  d01a              BEQ      |L17.88|
;;;92                     return "SC_ERR_READ";
;;;93             if(errno == SC_ERR_WRITE)
000022  1e49              SUBS     r1,r1,#1
000024  d01a              BEQ      |L17.92|
;;;94                     return "SC_ERR_WRITE";
;;;95             if(errno == SC_ERR_TIME0OUT)
000026  1e49              SUBS     r1,r1,#1
000028  d01a              BEQ      |L17.96|
;;;96                     return "SC_ERR_TIME0OUT";
;;;97             if(errno == SC_ERR_TIME1OUT)
00002a  1e49              SUBS     r1,r1,#1
00002c  d01a              BEQ      |L17.100|
;;;98                     return "SC_ERR_TIME1OUT";
;;;99             if(errno == SC_ERR_TIME2OUT)
00002e  1e49              SUBS     r1,r1,#1
000030  d01a              BEQ      |L17.104|
;;;100                    return "SC_ERR_TIME2OUT";
;;;101            if(errno == PROTOCOL_T0_ERROR)
000032  491e              LDR      r1,|L17.172|
000034  4288              CMP      r0,r1
000036  d119              BNE      |L17.108|
;;;102                    return "PROTOCOL_T0_ERROR";
000038  a01d              ADR      r0,|L17.176|
;;;103            if(errno == SC_ERR_AUTOCONVENTION)
;;;104                    return "SC_ERR_AUTOCONVENTION";
;;;105            if(errno == SC_ERR_BGTIMEOUT)
;;;106                    return "SC_ERR_BGTIMEOUT";
;;;107            if(errno == SC_EPROTOCOL)
;;;108                    return "SC_EPROTOCOL";
;;;109            if(errno == T1_ERROR_CHKSUM)
;;;110                    return "T1_ERROR_CHKSUM";
;;;111            if(errno == PROTOCOL_T1_ERROR)
;;;112                    return "PROTOCOL_T1_ERROR";
;;;113            if(errno == ATR_ERR_INVALID_PARAMETER)
;;;114                    return "ATR_ERR_INVALID_PARAMETER";
;;;115    
;;;116            return "No Such Error Messages";
;;;117    }
00003a  4770              BX       lr
                  |L17.60|
00003c  a021              ADR      r0,|L17.196|
00003e  4770              BX       lr
                  |L17.64|
000040  a025              ADR      r0,|L17.216|
000042  4770              BX       lr
                  |L17.68|
000044  a028              ADR      r0,|L17.232|
000046  4770              BX       lr
                  |L17.72|
000048  a02c              ADR      r0,|L17.252|
00004a  4770              BX       lr
                  |L17.76|
00004c  a02f              ADR      r0,|L17.268|
00004e  4770              BX       lr
                  |L17.80|
000050  a033              ADR      r0,|L17.288|
000052  4770              BX       lr
                  |L17.84|
000054  a035              ADR      r0,|L17.300|
000056  4770              BX       lr
                  |L17.88|
000058  a03a              ADR      r0,|L17.324|
00005a  4770              BX       lr
                  |L17.92|
00005c  a03c              ADR      r0,|L17.336|
00005e  4770              BX       lr
                  |L17.96|
000060  a03f              ADR      r0,|L17.352|
000062  4770              BX       lr
                  |L17.100|
000064  a042              ADR      r0,|L17.368|
000066  4770              BX       lr
                  |L17.104|
000068  a045              ADR      r0,|L17.384|
00006a  4770              BX       lr
                  |L17.108|
00006c  4601              MOV      r1,r0                 ;103
00006e  316c              ADDS     r1,r1,#0x6c           ;103
000070  d006              BEQ      |L17.128|
000072  1e49              SUBS     r1,r1,#1              ;105
000074  d006              BEQ      |L17.132|
000076  4946              LDR      r1,|L17.400|
000078  4288              CMP      r0,r1                 ;107
00007a  d105              BNE      |L17.136|
00007c  a045              ADR      r0,|L17.404|
00007e  4770              BX       lr
                  |L17.128|
000080  a048              ADR      r0,|L17.420|
000082  4770              BX       lr
                  |L17.132|
000084  a04d              ADR      r0,|L17.444|
000086  4770              BX       lr
                  |L17.136|
000088  4908              LDR      r1,|L17.172|
00008a  1e49              SUBS     r1,r1,#1              ;109
00008c  4288              CMP      r0,r1                 ;109
00008e  d101              BNE      |L17.148|
000090  a04f              ADR      r0,|L17.464|
000092  4770              BX       lr
                  |L17.148|
000094  4952              LDR      r1,|L17.480|
000096  4288              CMP      r0,r1                 ;111
000098  d101              BNE      |L17.158|
00009a  a052              ADR      r0,|L17.484|
00009c  4770              BX       lr
                  |L17.158|
00009e  3095              ADDS     r0,r0,#0x95           ;113
0000a0  d001              BEQ      |L17.166|
0000a2  a055              ADR      r0,|L17.504|
0000a4  4770              BX       lr
                  |L17.166|
0000a6  a05a              ADR      r0,|L17.528|
0000a8  4770              BX       lr
;;;118    
                          ENDP

0000aa  0000              DCW      0x0000
                  |L17.172|
                          DCD      0xfffffc17
                  |L17.176|
0000b0  50524f54          DCB      "PROTOCOL_T0_ERROR",0
0000b4  4f434f4c
0000b8  5f54305f
0000bc  4552524f
0000c0  5200    
0000c2  00                DCB      0
0000c3  00                DCB      0
                  |L17.196|
0000c4  53435f45          DCB      "SC_ERR_CARD_REMOVED",0
0000c8  52525f43
0000cc  4152445f
0000d0  52454d4f
0000d4  56454400
                  |L17.216|
0000d8  53435f45          DCB      "SC_ERR_OVER_RUN",0
0000dc  52525f4f
0000e0  5645525f
0000e4  52554e00
                  |L17.232|
0000e8  53435f45          DCB      "SC_ERR_PARITY_ERROR",0
0000ec  52525f50
0000f0  41524954
0000f4  595f4552
0000f8  524f5200
                  |L17.252|
0000fc  53435f45          DCB      "SC_ERR_NO_STOP",0
000100  52525f4e
000104  4f5f5354
000108  4f5000  
00010b  00                DCB      0
                  |L17.268|
00010c  53435f45          DCB      "SC_ERR_SILENT_BYTE",0
000110  52525f53
000114  494c454e
000118  545f4259
00011c  544500  
00011f  00                DCB      0
                  |L17.288|
000120  53435f45          DCB      "SC_ERR_CMD",0
000124  52525f43
000128  4d4400  
00012b  00                DCB      0
                  |L17.300|
00012c  53435f45          DCB      "SC_ERR_UNSUPPORTEDCARD",0
000130  52525f55
000134  4e535550
000138  504f5254
00013c  45444341
000140  524400  
000143  00                DCB      0
                  |L17.324|
000144  53435f45          DCB      "SC_ERR_READ",0
000148  52525f52
00014c  45414400
                  |L17.336|
000150  53435f45          DCB      "SC_ERR_WRITE",0
000154  52525f57
000158  52495445
00015c  00      
00015d  00                DCB      0
00015e  00                DCB      0
00015f  00                DCB      0
                  |L17.352|
000160  53435f45          DCB      "SC_ERR_TIME0OUT",0
000164  52525f54
000168  494d4530
00016c  4f555400
                  |L17.368|
000170  53435f45          DCB      "SC_ERR_TIME1OUT",0
000174  52525f54
000178  494d4531
00017c  4f555400
                  |L17.384|
000180  53435f45          DCB      "SC_ERR_TIME2OUT",0
000184  52525f54
000188  494d4532
00018c  4f555400
                  |L17.400|
                          DCD      0xffff2006
                  |L17.404|
000194  53435f45          DCB      "SC_EPROTOCOL",0
000198  50524f54
00019c  4f434f4c
0001a0  00      
0001a1  00                DCB      0
0001a2  00                DCB      0
0001a3  00                DCB      0
                  |L17.420|
0001a4  53435f45          DCB      "SC_ERR_AUTOCONVENTION",0
0001a8  52525f41
0001ac  55544f43
0001b0  4f4e5645
0001b4  4e54494f
0001b8  4e00    
0001ba  00                DCB      0
0001bb  00                DCB      0
                  |L17.444|
0001bc  53435f45          DCB      "SC_ERR_BGTIMEOUT",0
0001c0  52525f42
0001c4  4754494d
0001c8  454f5554
0001cc  00      
0001cd  00                DCB      0
0001ce  00                DCB      0
0001cf  00                DCB      0
                  |L17.464|
0001d0  54315f45          DCB      "T1_ERROR_CHKSUM",0
0001d4  52524f52
0001d8  5f43484b
0001dc  53554d00
                  |L17.480|
                          DCD      0xfffff82f
                  |L17.484|
0001e4  50524f54          DCB      "PROTOCOL_T1_ERROR",0
0001e8  4f434f4c
0001ec  5f54315f
0001f0  4552524f
0001f4  5200    
0001f6  00                DCB      0
0001f7  00                DCB      0
                  |L17.504|
0001f8  4e6f2053          DCB      "No Such Error Messages",0
0001fc  75636820
000200  4572726f
000204  72204d65
000208  73736167
00020c  657300  
00020f  00                DCB      0
                  |L17.528|
000210  4154525f          DCB      "ATR_ERR_INVALID_PARAMETER",0
000214  4552525f
000218  494e5641
00021c  4c49445f
000220  50415241
000224  4d455445
000228  5200    
00022a  00                DCB      0
00022b  00                DCB      0

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

                  SMARTCARD_GetATRBuffer PROC
;;;1291     */
;;;1292   int32_t SMARTCARD_GetATRBuffer(SC_TypeDef *portno, uint8_t *buf, int16_t length)
000000  b570              PUSH     {r4-r6,lr}
;;;1293   {
000002  460d              MOV      r5,r1
000004  4603              MOV      r3,r0
;;;1294           S_SC_DEV_T *dev;
;;;1295           int32_t port = 0;
;;;1296   
;;;1297           assert_param(CHECK_SC_PORT(portno));
;;;1298   
;;;1299           if(portno==SC0)
000006  4910              LDR      r1,|L18.72|
000008  2000              MOVS     r0,#0                 ;1295
00000a  428b              CMP      r3,r1
00000c  d008              BEQ      |L18.32|
;;;1300                   port = 0;
;;;1301           else if(portno==SC1)
00000e  490f              LDR      r1,|L18.76|
000010  428b              CMP      r3,r1
000012  d101              BNE      |L18.24|
;;;1302                   port = 1;
000014  2001              MOVS     r0,#1
000016  e003              B        |L18.32|
                  |L18.24|
;;;1303           else if(portno==SC2)
000018  490d              LDR      r1,|L18.80|
00001a  428b              CMP      r3,r1
00001c  d100              BNE      |L18.32|
;;;1304                   port = 2;
00001e  2002              MOVS     r0,#2
                  |L18.32|
;;;1305   
;;;1306           dev =  (S_SC_DEV_T *)((uint32_t)&sc_device[port]);
000020  21e0              MOVS     r1,#0xe0
000022  4348              MULS     r0,r1,r0
000024  490b              LDR      r1,|L18.84|
000026  1841              ADDS     r1,r0,r1
;;;1307   
;;;1308           if(dev->openflag == 0)
000028  68c8              LDR      r0,[r1,#0xc]
00002a  2800              CMP      r0,#0
00002c  d00a              BEQ      |L18.68|
;;;1309                   return(/*SC_EIO*/ 0);    // upper layer could get confused between length and error code, so return 0 instead.
;;;1310   
;;;1311           memcpy(buf, dev->CardCapabilities.ATR.Buffer,
00002e  460c              MOV      r4,r1
000030  3460              ADDS     r4,r4,#0x60
000032  7b20              LDRB     r0,[r4,#0xc]
000034  4290              CMP      r0,r2
000036  dc00              BGT      |L18.58|
;;;1312                  (length<dev->CardCapabilities.ATR.Length)?length:dev->CardCapabilities.ATR.Length);
000038  4602              MOV      r2,r0
                  |L18.58|
00003a  312c              ADDS     r1,r1,#0x2c
00003c  4628              MOV      r0,r5
00003e  f7fffffe          BL       __aeabi_memcpy
;;;1313   
;;;1314           return dev->CardCapabilities.ATR.Length;
000042  7b20              LDRB     r0,[r4,#0xc]
                  |L18.68|
;;;1315   }
000044  bd70              POP      {r4-r6,pc}
;;;1316   
                          ENDP

000046  0000              DCW      0x0000
                  |L18.72|
                          DCD      0x40190000
                  |L18.76|
                          DCD      0x401b0000
                  |L18.80|
                          DCD      0x401c0000
                  |L18.84|
                          DCD      ||.bss||+0x65c

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

                  SMARTCARD_IgnoreCardAbsent PROC
;;;148      */
;;;149    void SMARTCARD_IgnoreCardAbsent(SC_TypeDef *portno)
000000  4a0a              LDR      r2,|L19.44|
;;;150    {
;;;151            S_SC_DEV_T *dev;
;;;152            int32_t port = 0;
000002  2100              MOVS     r1,#0
;;;153    
;;;154    
;;;155            if(portno==SC0)
000004  4290              CMP      r0,r2
000006  d008              BEQ      |L19.26|
;;;156                    port = 0;
;;;157            else if(portno==SC1)
000008  4a09              LDR      r2,|L19.48|
00000a  4290              CMP      r0,r2
00000c  d101              BNE      |L19.18|
;;;158                    port = 1;
00000e  2101              MOVS     r1,#1
000010  e003              B        |L19.26|
                  |L19.18|
;;;159            else if(portno==SC2)
000012  4a08              LDR      r2,|L19.52|
000014  4290              CMP      r0,r2
000016  d100              BNE      |L19.26|
;;;160                    port = 2;
000018  2102              MOVS     r1,#2
                  |L19.26|
;;;161    
;;;162            dev= (S_SC_DEV_T *)(uint32_t)&sc_device[port];
00001a  20e0              MOVS     r0,#0xe0
00001c  4341              MULS     r1,r0,r1
00001e  4806              LDR      r0,|L19.56|
000020  1808              ADDS     r0,r1,r0
;;;163    
;;;164            dev->bCardRemoved = SCARD_PRESENT;
000022  2104              MOVS     r1,#4
000024  30c0              ADDS     r0,r0,#0xc0
000026  6081              STR      r1,[r0,#8]
;;;165    
;;;166    }
000028  4770              BX       lr
;;;167    
                          ENDP

00002a  0000              DCW      0x0000
                  |L19.44|
                          DCD      0x40190000
                  |L19.48|
                          DCD      0x401b0000
                  |L19.52|
                          DCD      0x401c0000
                  |L19.56|
                          DCD      ||.bss||+0x65c

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

                          REQUIRE _printf_percent
                          REQUIRE _printf_d
                          REQUIRE _printf_s
                          REQUIRE _printf_int_dec
                          REQUIRE _printf_str
                  SMARTCARD_Init PROC
;;;1572     */
;;;1573   void SMARTCARD_Init(SC_TypeDef *portno, int8_t edge)
000000  b5f3              PUSH     {r0,r1,r4-r7,lr}
;;;1574   {
;;;1575           S_SC_DEV_T *dev;
;;;1576           SC_TypeDef *SC;
;;;1577           IRQn_Type SC_IRQn;
;;;1578           int32_t port = 0;
;;;1579   
;;;1580           assert_param(CHECK_SC_PORT(portno));
;;;1581   
;;;1582           SC = portno;
;;;1583           SC_IRQn = (portno==SC0)?SC0_IRQn:((portno==SC1)?SC1_IRQn:SC2_IRQn);
000002  492b              LDR      r1,|L20.176|
000004  2500              MOVS     r5,#0                 ;1578
000006  4f2b              LDR      r7,|L20.180|
000008  b081              SUB      sp,sp,#4              ;1574
00000a  4604              MOV      r4,r0                 ;1574
00000c  4288              CMP      r0,r1
00000e  d101              BNE      |L20.20|
000010  2015              MOVS     r0,#0x15
000012  e004              B        |L20.30|
                  |L20.20|
000014  42bc              CMP      r4,r7
000016  d101              BNE      |L20.28|
000018  2016              MOVS     r0,#0x16
00001a  e000              B        |L20.30|
                  |L20.28|
00001c  2014              MOVS     r0,#0x14
                  |L20.30|
;;;1584   
;;;1585           if(portno==SC0)
00001e  4924              LDR      r1,|L20.176|
000020  9000              STR      r0,[sp,#0]
000022  428c              CMP      r4,r1
000024  d007              BEQ      |L20.54|
;;;1586                   port = 0;
;;;1587           else if(portno==SC1)
000026  42bc              CMP      r4,r7
000028  d101              BNE      |L20.46|
;;;1588                   port = 1;
00002a  2501              MOVS     r5,#1
00002c  e003              B        |L20.54|
                  |L20.46|
;;;1589           else if(portno==SC2)
00002e  4822              LDR      r0,|L20.184|
000030  4284              CMP      r4,r0
000032  d100              BNE      |L20.54|
;;;1590                   port = 2;
000034  2502              MOVS     r5,#2
                  |L20.54|
;;;1591   
;;;1592   
;;;1593           dev = (S_SC_DEV_T *)((uint32_t)&sc_device[port]);
000036  20e0              MOVS     r0,#0xe0
000038  4920              LDR      r1,|L20.188|
00003a  4368              MULS     r0,r5,r0
00003c  1846              ADDS     r6,r0,r1
;;;1594           memset(dev, 0, sizeof(S_SC_DEV_T));
00003e  21e0              MOVS     r1,#0xe0
000040  4630              MOV      r0,r6
000042  f7fffffe          BL       __aeabi_memclr4
;;;1595           dev->base = portno;     //ya
;;;1596   
;;;1597           if(portno==SC0)
000046  491a              LDR      r1,|L20.176|
;;;1598                   CLK->APBCLK |= CLK_APBCLK_SC0_EN;
000048  481d              LDR      r0,|L20.192|
;;;1599           else if(portno==SC1)
;;;1600                   CLK->APBCLK |= CLK_APBCLK_SC1_EN;
;;;1601           else if(portno==SC2)
;;;1602                   CLK->APBCLK |= CLK_APBCLK_SC2_EN;
00004a  2380              MOVS     r3,#0x80
00004c  6034              STR      r4,[r6,#0]            ;1597
00004e  428c              CMP      r4,r1                 ;1597
000050  d102              BNE      |L20.88|
000052  6881              LDR      r1,[r0,#8]            ;1598
000054  0542              LSLS     r2,r0,#21             ;1598
000056  e004              B        |L20.98|
                  |L20.88|
000058  42bc              CMP      r4,r7                 ;1599
00005a  d104              BNE      |L20.102|
00005c  6881              LDR      r1,[r0,#8]            ;1600
00005e  2201              MOVS     r2,#1                 ;1600
000060  07d2              LSLS     r2,r2,#31             ;1600
                  |L20.98|
000062  4311              ORRS     r1,r1,r2              ;1598
000064  e004              B        |L20.112|
                  |L20.102|
000066  4914              LDR      r1,|L20.184|
000068  428c              CMP      r4,r1                 ;1601
00006a  d102              BNE      |L20.114|
00006c  6881              LDR      r1,[r0,#8]
00006e  4319              ORRS     r1,r1,r3
                  |L20.112|
000070  6081              STR      r1,[r0,#8]
                  |L20.114|
;;;1603   
;;;1604           /* Card is Absent in default */
;;;1605           dev->bCardRemoved = SCARD_ABSENT;
000072  2002              MOVS     r0,#2
000074  36c0              ADDS     r6,r6,#0xc0
;;;1606   
;;;1607           if(edge)
000076  60b0              STR      r0,[r6,#8]
000078  9902              LDR      r1,[sp,#8]
;;;1608                   portno->PINCSR |= SC_PINCSR_CD_LEV;             // this must be set before enable engine
00007a  0240              LSLS     r0,r0,#9
00007c  2900              CMP      r1,#0                 ;1607
;;;1609           else
;;;1610                   portno->PINCSR &= ~SC_PINCSR_CD_LEV;
00007e  6a61              LDR      r1,[r4,#0x24]
000080  d001              BEQ      |L20.134|
000082  4301              ORRS     r1,r1,r0              ;1608
000084  e000              B        |L20.136|
                  |L20.134|
000086  4381              BICS     r1,r1,r0
                  |L20.136|
000088  6261              STR      r1,[r4,#0x24]
;;;1611   
;;;1612           // enable smartcard engine
;;;1613           SC->CTL |= SC_CTL_SC_CEN;
00008a  6860              LDR      r0,[r4,#4]
00008c  2101              MOVS     r1,#1
00008e  4308              ORRS     r0,r0,r1
000090  6060              STR      r0,[r4,#4]
000092  9800              LDR      r0,[sp,#0]
000094  06c0              LSLS     r0,r0,#27
000096  0ec0              LSRS     r0,r0,#27
000098  4081              LSLS     r1,r1,r0
00009a  480a              LDR      r0,|L20.196|
00009c  6001              STR      r1,[r0,#0]
;;;1614   
;;;1615           /* enable SmartCard INT NVIC */
;;;1616           NVIC_EnableIRQ(SC_IRQn);
;;;1617   
;;;1618           // enable card detection interrupt
;;;1619           SC->IER |= SC_IER_CD_IE;
00009e  69a0              LDR      r0,[r4,#0x18]
0000a0  4318              ORRS     r0,r0,r3
0000a2  61a0              STR      r0,[r4,#0x18]
;;;1620   
;;;1621           printf("\n[%s] : SC%d Init...\n", __func__, port);
0000a4  462a              MOV      r2,r5
0000a6  4908              LDR      r1,|L20.200|
0000a8  a008              ADR      r0,|L20.204|
0000aa  f7fffffe          BL       __2printf
;;;1622   
;;;1623   
;;;1624   }
0000ae  bdfe              POP      {r1-r7,pc}
;;;1625   
                          ENDP

                  |L20.176|
                          DCD      0x40190000
                  |L20.180|
                          DCD      0x401b0000
                  |L20.184|
                          DCD      0x401c0000
                  |L20.188|
                          DCD      ||.bss||+0x65c
                  |L20.192|
                          DCD      0x50000200
                  |L20.196|
                          DCD      0xe000e100
                  |L20.200|
                          DCD      ||.constdata||
                  |L20.204|
0000cc  0a5b2573          DCB      "\n[%s] : SC%d Init...\n",0
0000d0  5d203a20
0000d4  53432564
0000d8  20496e69
0000dc  742e2e2e
0000e0  0a00    
0000e2  00                DCB      0
0000e3  00                DCB      0

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

                  SMARTCARD_MatchReader PROC
;;;522      */
;;;523    static int32_t SMARTCARD_MatchReader(int32_t fi, int32_t di)
000000  b510              PUSH     {r4,lr}
;;;524    {
;;;525            int32_t i;
;;;526    
;;;527            i = fi/di;
000002  f7fffffe          BL       __aeabi_idivmod
000006  4604              MOV      r4,r0
;;;528    
;;;529            if( (i % 31) == 0)
000008  211f              MOVS     r1,#0x1f
00000a  f7fffffe          BL       __aeabi_idivmod
00000e  2900              CMP      r1,#0
000010  d004              BEQ      |L21.28|
;;;530                    return SC_STATUS_SUCCESS;
;;;531            else if( (i % 32) == 0)
000012  06e0              LSLS     r0,r4,#27
000014  d001              BEQ      |L21.26|
;;;532                    return SC_STATUS_SUCCESS;
;;;533            else
;;;534                    return ATR_ERR_INVALID_PARAMETER;
000016  2094              MOVS     r0,#0x94
000018  43c0              MVNS     r0,r0
                  |L21.26|
;;;535    
;;;536            // TODO: Maybe do more things here...
;;;537            //...
;;;538    }
00001a  bd10              POP      {r4,pc}
                  |L21.28|
00001c  2000              MOVS     r0,#0                 ;530
00001e  bd10              POP      {r4,pc}
;;;539    
                          ENDP


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

                  SMARTCARD_Open PROC
;;;1433     */
;;;1434   int32_t SMARTCARD_Open(SC_TypeDef *portno)
000000  b5f8              PUSH     {r3-r7,lr}
;;;1435   {
000002  4606              MOV      r6,r0
;;;1436           int32_t retval = SC_STATUS_SUCCESS, i, port = 0;
;;;1437           S_SC_DEV_T *dev;
;;;1438           SC_TypeDef *SC;
;;;1439           //IRQn_Type SC_IRQn;
;;;1440   
;;;1441           ENTER();
;;;1442   
;;;1443           assert_param(CHECK_SC_PORT(portno));
;;;1444   
;;;1445           if(portno==SC0)
000004  4d30              LDR      r5,|L22.200|
000006  2000              MOVS     r0,#0                 ;1436
;;;1446                   port = 0;
;;;1447           else if(portno==SC1)
000008  4f30              LDR      r7,|L22.204|
00000a  42ae              CMP      r6,r5                 ;1445
00000c  d007              BEQ      |L22.30|
00000e  42be              CMP      r6,r7
000010  d101              BNE      |L22.22|
;;;1448                   port = 1;
000012  2001              MOVS     r0,#1
000014  e003              B        |L22.30|
                  |L22.22|
;;;1449           else if(portno==SC2)
000016  492e              LDR      r1,|L22.208|
000018  428e              CMP      r6,r1
00001a  d100              BNE      |L22.30|
;;;1450                   port = 2;
00001c  2002              MOVS     r0,#2
                  |L22.30|
;;;1451   
;;;1452           dev = (S_SC_DEV_T *)((uint32_t)&sc_device[port]);
00001e  21e0              MOVS     r1,#0xe0
000020  4348              MULS     r0,r1,r0
000022  492c              LDR      r1,|L22.212|
000024  1844              ADDS     r4,r0,r1
;;;1453   
;;;1454           if( dev->openflag != 0 )                /* a card slot can open only once */
000026  68e0              LDR      r0,[r4,#0xc]
000028  2800              CMP      r0,#0
00002a  d001              BEQ      |L22.48|
;;;1455                   return(SC_EBUSY);
00002c  482a              LDR      r0,|L22.216|
;;;1456   
;;;1457           dev->base = portno;
;;;1458   
;;;1459           SC = portno;
;;;1460           //SC_IRQn = (portno==0)?SC0_IRQn:SC0_IRQn;
;;;1461   
;;;1462           SMARTCARD_ResetReader(dev);             // initiate some parameters
;;;1463   
;;;1464           /* point to receive buffer */
;;;1465           if(portno == SC0) {
;;;1466                   dev->rcv_buf = (uint8_t *)&g_Port0_RxBUF;//(uint8_t *)malloc(MAX_BUF_LEN * sizeof(uint8_t));
;;;1467                   dev->snd_buf = (uint8_t *)&g_Port0_TxBUF;
;;;1468           } else if(portno == SC1) {
;;;1469                   dev->rcv_buf = (uint8_t *)&g_Port1_RxBUF;//(uint8_t *)malloc(MAX_BUF_LEN * sizeof(uint8_t));
;;;1470                   dev->snd_buf = (uint8_t *)&g_Port1_TxBUF;
;;;1471           } else if(portno == SC2) {
;;;1472                   dev->rcv_buf = (uint8_t *)&g_Port2_RxBUF;//(uint8_t *)malloc(MAX_BUF_LEN * sizeof(uint8_t));
;;;1473                   dev->snd_buf = (uint8_t *)&g_Port2_TxBUF;
;;;1474           }
;;;1475   
;;;1476           if((dev->bCardRemoved==SCARD_ABSENT) || (dev->bCardRemoved==SCARD_UNKNOWN)) {
;;;1477                   printf("Card missing\n");
;;;1478                   retval = SC_EIO;
;;;1479                   goto _exit_open;
;;;1480           } else {
;;;1481                   /* default: 1.8V start */
;;;1482                   dev->voltage = SC_ISO_OPERATIONCLASS_C;
;;;1483   
;;;1484                   for( i = 0; i < 1/*3*/; i++) {
;;;1485                           if((retval = SMARTCARD_ColdReset(dev)) != 0) {
;;;1486                                   if(i==1)
;;;1487                                           dev->voltage = SC_ISO_OPERATIONCLASS_B;  // 1.8V failed, use 3V
;;;1488                                   if(i==2)
;;;1489                                           dev->voltage = SC_ISO_OPERATIONCLASS_A;  // 3V failed, use 5V
;;;1490                                   continue;
;;;1491                           }
;;;1492                           break;
;;;1493                   }
;;;1494   
;;;1495                   if(retval != 0) {
;;;1496                           // TODO: disable Group mask
;;;1497                           printf("Cold-Reset is failed...\n");
;;;1498                           SC->IER = SC_IER_CD_IE;         // Keep the card detection interrupt. Modified by SM
;;;1499   
;;;1500                   }
;;;1501           }
;;;1502   
;;;1503   _exit_open:
;;;1504           dev->openflag = 1;
;;;1505           dev->errno = 0;  // clear error code happened during cold reset
;;;1506   
;;;1507           printf("Open Done\n");
;;;1508   
;;;1509           LEAVE();
;;;1510   
;;;1511           return retval;
;;;1512   
;;;1513   }
00002e  bdf8              POP      {r3-r7,pc}
                  |L22.48|
000030  4620              MOV      r0,r4                 ;1462
000032  6026              STR      r6,[r4,#0]            ;1462
000034  f7fffffe          BL       SMARTCARD_ResetReader
000038  42ae              CMP      r6,r5                 ;1465
00003a  d105              BNE      |L22.72|
00003c  4620              MOV      r0,r4                 ;1466
00003e  4927              LDR      r1,|L22.220|
000040  3080              ADDS     r0,r0,#0x80           ;1466
000042  6301              STR      r1,[r0,#0x30]         ;1467
000044  4926              LDR      r1,|L22.224|
000046  e00f              B        |L22.104|
                  |L22.72|
000048  42be              CMP      r6,r7                 ;1468
00004a  d105              BNE      |L22.88|
00004c  4620              MOV      r0,r4                 ;1469
00004e  4925              LDR      r1,|L22.228|
000050  3080              ADDS     r0,r0,#0x80           ;1469
000052  6301              STR      r1,[r0,#0x30]         ;1470
000054  4924              LDR      r1,|L22.232|
000056  e007              B        |L22.104|
                  |L22.88|
000058  491d              LDR      r1,|L22.208|
00005a  428e              CMP      r6,r1                 ;1471
00005c  d105              BNE      |L22.106|
00005e  4620              MOV      r0,r4                 ;1472
000060  4922              LDR      r1,|L22.236|
000062  3080              ADDS     r0,r0,#0x80           ;1472
000064  6301              STR      r1,[r0,#0x30]         ;1473
000066  4922              LDR      r1,|L22.240|
                  |L22.104|
000068  62c1              STR      r1,[r0,#0x2c]         ;1473
                  |L22.106|
00006a  20c8              MOVS     r0,#0xc8              ;1476
00006c  5900              LDR      r0,[r0,r4]            ;1476
00006e  2802              CMP      r0,#2                 ;1476
000070  d00e              BEQ      |L22.144|
000072  2801              CMP      r0,#1                 ;1476
000074  d00c              BEQ      |L22.144|
000076  2003              MOVS     r0,#3                 ;1482
000078  2500              MOVS     r5,#0                 ;1484
00007a  61e0              STR      r0,[r4,#0x1c]         ;1484
                  |L22.124|
00007c  4620              MOV      r0,r4                 ;1485
00007e  f7fffffe          BL       SMARTCARD_ColdReset
000082  0007              MOVS     r7,r0                 ;1485
000084  d016              BEQ      |L22.180|
000086  2d01              CMP      r5,#1                 ;1486
000088  d008              BEQ      |L22.156|
00008a  2d02              CMP      r5,#2                 ;1488
00008c  d008              BEQ      |L22.160|
00008e  e009              B        |L22.164|
                  |L22.144|
000090  a018              ADR      r0,|L22.244|
000092  f7fffffe          BL       __2printf
000096  4f10              LDR      r7,|L22.216|
000098  1eff              SUBS     r7,r7,#3              ;1478
00009a  e00b              B        |L22.180|
                  |L22.156|
00009c  2002              MOVS     r0,#2                 ;1487
00009e  e000              B        |L22.162|
                  |L22.160|
0000a0  2001              MOVS     r0,#1                 ;1489
                  |L22.162|
0000a2  61e0              STR      r0,[r4,#0x1c]         ;1487
                  |L22.164|
0000a4  1c6d              ADDS     r5,r5,#1              ;1484
0000a6  2d01              CMP      r5,#1                 ;1484
0000a8  dbe8              BLT      |L22.124|
0000aa  a016              ADR      r0,|L22.260|
0000ac  f7fffffe          BL       __2printf
0000b0  2080              MOVS     r0,#0x80              ;1498
0000b2  61b0              STR      r0,[r6,#0x18]         ;1498
                  |L22.180|
0000b4  2001              MOVS     r0,#1                 ;1504
0000b6  60e0              STR      r0,[r4,#0xc]          ;1505
0000b8  2000              MOVS     r0,#0                 ;1505
0000ba  60a0              STR      r0,[r4,#8]            ;1507
0000bc  a018              ADR      r0,|L22.288|
0000be  f7fffffe          BL       __2printf
0000c2  4638              MOV      r0,r7                 ;1511
0000c4  bdf8              POP      {r3-r7,pc}
;;;1514   
                          ENDP

0000c6  0000              DCW      0x0000
                  |L22.200|
                          DCD      0x40190000
                  |L22.204|
                          DCD      0x401b0000
                  |L22.208|
                          DCD      0x401c0000
                  |L22.212|
                          DCD      ||.bss||+0x65c
                  |L22.216|
                          DCD      0xffff2004
                  |L22.220|
                          DCD      ||.bss||
                  |L22.224|
                          DCD      ||.bss||+0x32d
                  |L22.228|
                          DCD      ||.bss||+0x10f
                  |L22.232|
                          DCD      ||.bss||+0x43c
                  |L22.236|
                          DCD      ||.bss||+0x21e
                  |L22.240|
                          DCD      ||.bss||+0x54b
                  |L22.244|
0000f4  43617264          DCB      "Card missing\n",0
0000f8  206d6973
0000fc  73696e67
000100  0a00    
000102  00                DCB      0
000103  00                DCB      0
                  |L22.260|
000104  436f6c64          DCB      "Cold-Reset is failed...\n",0
000108  2d526573
00010c  65742069
000110  73206661
000114  696c6564
000118  2e2e2e0a
00011c  00      
00011d  00                DCB      0
00011e  00                DCB      0
00011f  00                DCB      0
                  |L22.288|
000120  4f70656e          DCB      "Open Done\n",0
000124  20446f6e
000128  650a00  
00012b  00                DCB      0

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

                  SMARTCARD_ParseATR PROC
;;;864      */
;;;865    static int32_t SMARTCARD_ParseATR(S_SC_DEV_T * dev, int resettype)
000000  b5f0              PUSH     {r4-r7,lr}
;;;866    {
;;;867            int32_t i, retval;
;;;868            uint8_t td;
;;;869            uint8_t *atr = dev->CardCapabilities.ATR.Buffer;
000002  4604              MOV      r4,r0
000004  b089              SUB      sp,sp,#0x24           ;866
000006  4607              MOV      r7,r0                 ;866
000008  342c              ADDS     r4,r4,#0x2c
;;;870            uint8_t /*N,*/ T, Fi, Di;
;;;871            unsigned long protocolTypes = 0;
;;;872    
;;;873            struct {
;;;874                    uint8_t data;
;;;875                    uint8_t present;
;;;876            } ibyte[4][4];
;;;877    
;;;878            ENTER();
;;;879    
;;;880            memset(&ibyte, 0, sizeof(ibyte));
00000a  2120              MOVS     r1,#0x20
00000c  4668              MOV      r0,sp
00000e  f7fffffe          BL       __aeabi_memclr4
;;;881    
;;;882            atr++;  // skip: TS->T0
;;;883            td = *atr++;
000012  7861              LDRB     r1,[r4,#1]
000014  1ca4              ADDS     r4,r4,#2
;;;884    
;;;885            i = 0;
000016  2000              MOVS     r0,#0
000018  466b              MOV      r3,sp                 ;876
;;;886    
;;;887            while(1) {
;;;888    
;;;889                    /* TAi present */
;;;890                    if( td & 0x10) {
;;;891                            ibyte[i][ATR_INTERFACE_BYTE_TA].data = *atr++;
;;;892                            ibyte[i][ATR_INTERFACE_BYTE_TA].present = 1;
00001a  2501              MOVS     r5,#1
                  |L23.28|
00001c  06ca              LSLS     r2,r1,#27             ;890
00001e  d505              BPL      |L23.44|
000020  7826              LDRB     r6,[r4,#0]            ;891
000022  00c2              LSLS     r2,r0,#3              ;891
000024  1c64              ADDS     r4,r4,#1              ;891
000026  549e              STRB     r6,[r3,r2]            ;891
000028  18d2              ADDS     r2,r2,r3
00002a  7055              STRB     r5,[r2,#1]
                  |L23.44|
;;;893                    }
;;;894    
;;;895                    /* TBi present */
;;;896                    if( td & 0x20) {
00002c  068a              LSLS     r2,r1,#26
00002e  d505              BPL      |L23.60|
;;;897                            ibyte[i][ATR_INTERFACE_BYTE_TB].data = *atr++;
000030  7826              LDRB     r6,[r4,#0]
000032  1c64              ADDS     r4,r4,#1
000034  00c2              LSLS     r2,r0,#3
000036  18d2              ADDS     r2,r2,r3
000038  7096              STRB     r6,[r2,#2]
;;;898                            ibyte[i][ATR_INTERFACE_BYTE_TB].present = 1;
00003a  70d5              STRB     r5,[r2,#3]
                  |L23.60|
;;;899                    }
;;;900    
;;;901                    /* TCi present */
;;;902                    if( td & 0x40) {
00003c  064a              LSLS     r2,r1,#25
00003e  d505              BPL      |L23.76|
;;;903                            ibyte[i][ATR_INTERFACE_BYTE_TC].data = *atr++;
000040  7826              LDRB     r6,[r4,#0]
000042  1c64              ADDS     r4,r4,#1
000044  00c2              LSLS     r2,r0,#3
000046  18d2              ADDS     r2,r2,r3
000048  7116              STRB     r6,[r2,#4]
;;;904                            ibyte[i][ATR_INTERFACE_BYTE_TC].present = 1;
00004a  7155              STRB     r5,[r2,#5]
                  |L23.76|
;;;905                    }
;;;906    
;;;907                    /* TDi present */
;;;908                    if( td & 0x80) {
00004c  0609              LSLS     r1,r1,#24
00004e  d507              BPL      |L23.96|
;;;909                            ibyte[i][ATR_INTERFACE_BYTE_TD].data = *atr++;
000050  7821              LDRB     r1,[r4,#0]
000052  00c2              LSLS     r2,r0,#3
000054  18d2              ADDS     r2,r2,r3
000056  1c64              ADDS     r4,r4,#1
000058  7191              STRB     r1,[r2,#6]
;;;910                            ibyte[i][ATR_INTERFACE_BYTE_TD].present = 1;
00005a  71d5              STRB     r5,[r2,#7]
;;;911                            td = ibyte[i][ATR_INTERFACE_BYTE_TD].data;
;;;912                            protocolTypes |= 1 << (td & 0x0F);
;;;913                            i++;
00005c  1c40              ADDS     r0,r0,#1
00005e  e7dd              B        |L23.28|
                  |L23.96|
;;;914                    } else
;;;915                            break;
;;;916    
;;;917            }
;;;918    
;;;919    
;;;920    #if EMV_ATR_CHECK
;;;921            /**********************************************************************************************************************/
;;;922            /* Checking the integrity of ATR, this process meets EMV 4.2 specification */
;;;923            /* Reject ATR if TA1 is not int the range '11' to '13' */
;;;924            if(ibyte[0][ATR_INTERFACE_BYTE_TA].present == 1) {
;;;925                    if(ibyte[0][ATR_INTERFACE_BYTE_TA].data < 0x11 || ibyte[0][ATR_INTERFACE_BYTE_TA].data > 0x13)
;;;926                            return ATR_ERR_INVALID_PARAMETER;
;;;927            }
;;;928    
;;;929            /* In response to the cold-reset, TB1 only could be 0x00 */
;;;930            if(resettype == SC_COLDRESET) {
;;;931                    if(ibyte[0][ATR_INTERFACE_BYTE_TB].present == 1)
;;;932                            if(ibyte[0][ATR_INTERFACE_BYTE_TB].data != 0x00)
;;;933                                    return ATR_ERR_INVALID_PARAMETER;
;;;934                    if(ibyte[0][ATR_INTERFACE_BYTE_TB].present == 0)
;;;935                            return ATR_ERR_INVALID_PARAMETER;
;;;936            }
;;;937    
;;;938            /* Reject ATR containing TB2 */
;;;939            if(ibyte[1][ATR_INTERFACE_BYTE_TB].present == 1)
;;;940                    return ATR_ERR_INVALID_PARAMETER;
;;;941    
;;;942    
;;;943            /* ATR must contain TB3 in T=1 */
;;;944            if(dev->CardCapabilities.Protocol.Selected == SCARD_PROTOCOL_T1) {
;;;945                    if(ibyte[2][ATR_INTERFACE_BYTE_TB].present == 0)
;;;946                            return ATR_ERR_INVALID_PARAMETER;
;;;947            }
;;;948    
;;;949            /* Bit [5] of TA2 must be equal to 0x0 */
;;;950            if(ibyte[1][ATR_INTERFACE_BYTE_TA].present == 1) {
;;;951                    if((ibyte[1][ATR_INTERFACE_BYTE_TA].data&0x10) == 0x10)
;;;952                            return ATR_ERR_INVALID_PARAMETER;
;;;953            }
;;;954    
;;;955            /* Reject an ATR that TC2 is equal to 0x00 */
;;;956            if(ibyte[1][ATR_INTERFACE_BYTE_TC].present == 1 && ibyte[1][ATR_INTERFACE_BYTE_TC].data == 0x00)
;;;957                    return ATR_ERR_INVALID_PARAMETER;
;;;958    
;;;959    
;;;960            /* TD1's l.s. nibble must be 0x0 or 0x1 */
;;;961            if(ibyte[0][ATR_INTERFACE_BYTE_TD].present == 1) {
;;;962                    if((ibyte[0][ATR_INTERFACE_BYTE_TD].data&0xF) > 0x1) {
;;;963                            return ATR_ERR_INVALID_PARAMETER;
;;;964                    }
;;;965            }
;;;966    
;;;967            /* TD2's l.s. nibble must be 0x1 or 0xE if TD1's l.s. nibble is 0x0 */
;;;968            if(ibyte[1][ATR_INTERFACE_BYTE_TD].present == 1) {
;;;969                    if((ibyte[1][ATR_INTERFACE_BYTE_TD].data&0xF)!=0x1 && (ibyte[1][ATR_INTERFACE_BYTE_TD].data&0xF)!=0xE)
;;;970                            return ATR_ERR_INVALID_PARAMETER;
;;;971    
;;;972                    if((ibyte[1][ATR_INTERFACE_BYTE_TD].data&0xF) == 0xE) {
;;;973                            if((ibyte[0][ATR_INTERFACE_BYTE_TD].data&0xF) != 0x0)
;;;974                                    return ATR_ERR_INVALID_PARAMETER;
;;;975                    }
;;;976            }
;;;977    
;;;978            /* Reject TA3 having a value in the range 0x0~0xF or 0xFF */
;;;979            if(ibyte[2][ATR_INTERFACE_BYTE_TA].present == 1) {
;;;980                    if(ibyte[2][ATR_INTERFACE_BYTE_TA].data >= 0x0 &&
;;;981                                    ibyte[2][ATR_INTERFACE_BYTE_TA].data <= 0xF) {
;;;982                            return ATR_ERR_INVALID_PARAMETER;
;;;983                    }
;;;984                    if(ibyte[2][ATR_INTERFACE_BYTE_TA].data == 0xFF) {
;;;985                            return ATR_ERR_INVALID_PARAMETER;
;;;986                    }
;;;987            }
;;;988    
;;;989            /* Reject ATR not containing TB3 or BWI greater than 4 or CWI greater than 5 */
;;;990            /* And reject ATR if fitting the formula : 2 to the power of CWI is equal or less than (N+1) */
;;;991            if(dev->CardCapabilities.Protocol.Selected == SCARD_PROTOCOL_T1) {
;;;992                    if(ibyte[2][ATR_INTERFACE_BYTE_TB].present == 1) {
;;;993                            if(((ibyte[2][ATR_INTERFACE_BYTE_TB].data&0xF0)>>4) > 0x4)
;;;994                                    return ATR_ERR_INVALID_PARAMETER;
;;;995    
;;;996                            if((ibyte[2][ATR_INTERFACE_BYTE_TB].data&0xF) > 0x5)
;;;997                                    return ATR_ERR_INVALID_PARAMETER;
;;;998    
;;;999                            i = 1;
;;;1000                           retval = (ibyte[2][ATR_INTERFACE_BYTE_TB].data&0xF);
;;;1001                           while(retval--)
;;;1002                                   i *= 2;
;;;1003                           /* if TC1 is equal to 0xFF, N as -1 that is always valid */
;;;1004                           if(ibyte[0][ATR_INTERFACE_BYTE_TC].data!=0xFF)
;;;1005                                   if( i <= (ibyte[0][ATR_INTERFACE_BYTE_TC].data+1))
;;;1006                                           return ATR_ERR_INVALID_PARAMETER;
;;;1007   
;;;1008                   } else return ATR_ERR_INVALID_PARAMETER;
;;;1009           }
;;;1010   
;;;1011           /* Reject ATR if TC3 is not equal to 0x00 */
;;;1012           if(ibyte[2][ATR_INTERFACE_BYTE_TC].present == 1) {
;;;1013                   if(ibyte[2][ATR_INTERFACE_BYTE_TC].data != 0x00) {
;;;1014                           return ATR_ERR_INVALID_PARAMETER;
;;;1015                   }
;;;1016           }
;;;1017           /* End of checking the integrity of ATR */
;;;1018           /**********************************************************************************************************************/
;;;1019   #endif
;;;1020   
;;;1021           Fi = Di = 1;
000060  2101              MOVS     r1,#1
;;;1022   
;;;1023           /* set Fi and Di if TA1 present */
;;;1024           if(ibyte[0][ATR_INTERFACE_BYTE_TA].present) {
000062  7858              LDRB     r0,[r3,#1]
000064  460a              MOV      r2,r1                 ;1021
000066  2800              CMP      r0,#0
000068  d003              BEQ      |L23.114|
;;;1025                   Fi = (ibyte[0][ATR_INTERFACE_BYTE_TA].data >> 4) & 0x0f;
00006a  7818              LDRB     r0,[r3,#0]
00006c  0901              LSRS     r1,r0,#4
;;;1026                   Di = ibyte[0][ATR_INTERFACE_BYTE_TA].data  & 0x0f;
00006e  0702              LSLS     r2,r0,#28
000070  0f12              LSRS     r2,r2,#28
                  |L23.114|
;;;1027           }
;;;1028   
;;;1029           //N = 0;
;;;1030   
;;;1031           //if(ibyte[0][ATR_INTERFACE_BYTE_TC].present)
;;;1032           //      N = ibyte[0][ATR_INTERFACE_BYTE_TC].data;
;;;1033   
;;;1034           T = 0;
;;;1035   
;;;1036           /* check TA2 indicates which mode in the card */
;;;1037           /* in specific mode */
;;;1038           if(dev->CurrentState == SCARD_SPECIFIC) {
;;;1039                   T = ibyte[1][ATR_INTERFACE_BYTE_TA].data & 0x0f;
;;;1040   
;;;1041                   if(ibyte[1][ATR_INTERFACE_BYTE_TA].data & 0x10) { /* Bit5 = 1, using default value */
;;;1042                           Fi = 1;
;;;1043                           Di= 1;          /* default value */
;;;1044                   }
;;;1045   
;;;1046                   if(SMARTCARD_MatchReader(ClockRateConversion[Fi].F, BitRateAdjustment[Di].DNumerator) == 0) {   /* reader supported mode? */
000072  4e29              LDR      r6,|L23.280|
000074  20a8              MOVS     r0,#0xa8              ;1038
000076  59c0              LDR      r0,[r0,r7]            ;1038
000078  4634              MOV      r4,r6
00007a  2300              MOVS     r3,#0                 ;1034
00007c  3c80              SUBS     r4,r4,#0x80
00007e  2840              CMP      r0,#0x40              ;1038
000080  d002              BEQ      |L23.136|
;;;1047                           /* do nothing, */
;;;1048                           /* Match, reader is ready to work */
;;;1049                           ;
;;;1050                   } else {
;;;1051                           if(!(ibyte[1][ATR_INTERFACE_BYTE_TA].data & 0x80)) {    /* Bit8 indicate if being capable to change mode */
;;;1052                                   retval = SMARTCARD_WarmReset(dev);      /* change to negotiable mode */
;;;1053                                   if(retval != 0)
;;;1054                                           return retval;
;;;1055                                   //Fi = 1; Di = 1; T = 0;
;;;1056                                   //retval = SMARTCARD_DoPPS(dev, Fi, Di, T);     /* parameter and protocol select */
;;;1057                                   //if(retval != 0)
;;;1058                                   //      return retval;
;;;1059                           }
;;;1060                           //else          // mask for APDU test card
;;;1061                           //      return SC_ERR_UNSUPPORTEDCARD;
;;;1062                   }
;;;1063   
;;;1064           }
;;;1065   
;;;1066           /* in negotiable mode */
;;;1067           else if(dev->CurrentState == SCARD_NEGOTIABLE) {
000082  2820              CMP      r0,#0x20
000084  d019              BEQ      |L23.186|
000086  e041              B        |L23.268|
                  |L23.136|
000088  4668              MOV      r0,sp                 ;1039
00008a  7a00              LDRB     r0,[r0,#8]            ;1039
00008c  06c0              LSLS     r0,r0,#27             ;1041
00008e  d501              BPL      |L23.148|
000090  2101              MOVS     r1,#1                 ;1042
000092  460a              MOV      r2,r1                 ;1043
                  |L23.148|
000094  00d0              LSLS     r0,r2,#3              ;1046
000096  5832              LDR      r2,[r6,r0]            ;1046
000098  00c8              LSLS     r0,r1,#3              ;1046
00009a  5820              LDR      r0,[r4,r0]            ;1046
00009c  4611              MOV      r1,r2                 ;1046
00009e  f7fffffe          BL       SMARTCARD_MatchReader
0000a2  2800              CMP      r0,#0                 ;1046
0000a4  d032              BEQ      |L23.268|
0000a6  4668              MOV      r0,sp                 ;1051
0000a8  7a00              LDRB     r0,[r0,#8]            ;1051
0000aa  0600              LSLS     r0,r0,#24             ;1051
0000ac  d42e              BMI      |L23.268|
0000ae  4638              MOV      r0,r7                 ;1052
0000b0  f7fffffe          BL       SMARTCARD_WarmReset
0000b4  2800              CMP      r0,#0                 ;1053
0000b6  d11f              BNE      |L23.248|
0000b8  e028              B        |L23.268|
                  |L23.186|
;;;1068                   if (ibyte[0][ATR_INTERFACE_BYTE_TD].present)     // use "first offered transmission protocol"
0000ba  4668              MOV      r0,sp
0000bc  79c0              LDRB     r0,[r0,#7]
0000be  2800              CMP      r0,#0
0000c0  d003              BEQ      |L23.202|
;;;1069                           T = ibyte[0][ATR_INTERFACE_BYTE_TD].data & 0x0f;
0000c2  4668              MOV      r0,sp
0000c4  7980              LDRB     r0,[r0,#6]
0000c6  0703              LSLS     r3,r0,#28
0000c8  0f1b              LSRS     r3,r3,#28
                  |L23.202|
;;;1070                   else
;;;1071                           T = 0;          // means protocol T=0
;;;1072   
;;;1073                   /* if the values are the default, no PPS should be done */
;;;1074                   if( (Fi==0) && (Di==1) ) {
0000ca  2900              CMP      r1,#0
0000cc  d101              BNE      |L23.210|
0000ce  2a01              CMP      r2,#1
0000d0  d00a              BEQ      |L23.232|
                  |L23.210|
;;;1075                           if(SMARTCARD_MatchReader(ClockRateConversion[Fi].F, BitRateAdjustment[Di].DNumerator) == 0) {   /* reader supported mode? */
;;;1076                                   /* do nothing, */
;;;1077                                   /* Match, reader is ready to work */
;;;1078                                   ;
;;;1079                           } else return SC_ERR_UNSUPPORTEDCARD;
;;;1080                   } else {
;;;1081   
;;;1082                           retval = SMARTCARD_DoPPS(dev, Fi, Di, T);               /* parameter and protocol select */
0000d2  4638              MOV      r0,r7
0000d4  f7fffffe          BL       SMARTCARD_DoPPS
0000d8  1e04              SUBS     r4,r0,#0
;;;1083                           if(retval < 0) {
0000da  da12              BGE      |L23.258|
;;;1084                                   /* PPS failed */
;;;1085                                   printf("DoPPS is failed!!\n");
0000dc  a00f              ADR      r0,|L23.284|
0000de  f7fffffe          BL       __2printf
;;;1086                                   if(retval == SC_ERR_CARD_REMOVED)
0000e2  3478              ADDS     r4,r4,#0x78
0000e4  d00a              BEQ      |L23.252|
0000e6  e011              B        |L23.268|
                  |L23.232|
0000e8  68b1              LDR      r1,[r6,#8]            ;1075
0000ea  6820              LDR      r0,[r4,#0]            ;1075
0000ec  f7fffffe          BL       SMARTCARD_MatchReader
0000f0  2800              CMP      r0,#0                 ;1075
0000f2  d00b              BEQ      |L23.268|
0000f4  2071              MOVS     r0,#0x71              ;1079
0000f6  43c0              MVNS     r0,r0                 ;1079
                  |L23.248|
;;;1087                                           return(SC_ERR_CARD_REMOVED);
;;;1088                           } else {
;;;1089                                   dev->pps_complete = 1;
;;;1090                                   SmartcardUpdateCardCapabilities(dev);
;;;1091                           }
;;;1092   
;;;1093                   }
;;;1094   
;;;1095           }
;;;1096   
;;;1097           SMARTCARD_SetReaderParameter(dev);
;;;1098   
;;;1099   
;;;1100           LEAVE();
;;;1101   
;;;1102           return SC_STATUS_SUCCESS;
;;;1103   }
0000f8  b009              ADD      sp,sp,#0x24
0000fa  bdf0              POP      {r4-r7,pc}
                  |L23.252|
0000fc  2077              MOVS     r0,#0x77              ;1087
0000fe  43c0              MVNS     r0,r0                 ;1087
000100  e7fa              B        |L23.248|
                  |L23.258|
000102  20cc              MOVS     r0,#0xcc              ;1089
000104  55c5              STRB     r5,[r0,r7]            ;1089
000106  4638              MOV      r0,r7                 ;1090
000108  f7fffffe          BL       SmartcardUpdateCardCapabilities
                  |L23.268|
00010c  4638              MOV      r0,r7                 ;1097
00010e  f7fffffe          BL       SMARTCARD_SetReaderParameter
000112  2000              MOVS     r0,#0                 ;1102
000114  e7f0              B        |L23.248|
;;;1104   
                          ENDP

000116  0000              DCW      0x0000
                  |L23.280|
                          DCD      ||.data||+0xf8
                  |L23.284|
00011c  446f5050          DCB      "DoPPS is failed!!\n",0
000120  53206973
000124  20666169
000128  6c656421
00012c  210a00  
00012f  00                DCB      0

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

                  SMARTCARD_PowerActiveLevel PROC
;;;295      */
;;;296    void SMARTCARD_PowerActiveLevel(SC_TypeDef *portno, int8_t active)
000000  4b18              LDR      r3,|L24.100|
;;;297    {
000002  b510              PUSH     {r4,lr}
;;;298    #ifdef SC_SEQ_MANUAL
;;;299            S_SC_DEV_T *dev;
;;;300            int32_t port = 0;
000004  2200              MOVS     r2,#0
;;;301    
;;;302            if(portno==SC0)
000006  4298              CMP      r0,r3
000008  d008              BEQ      |L24.28|
;;;303                    port = 0;
;;;304            else if(portno==SC1)
00000a  4b17              LDR      r3,|L24.104|
00000c  4298              CMP      r0,r3
00000e  d101              BNE      |L24.20|
;;;305                    port = 1;
000010  2201              MOVS     r2,#1
000012  e003              B        |L24.28|
                  |L24.20|
;;;306            else if(portno==SC2)
000014  4b15              LDR      r3,|L24.108|
000016  4298              CMP      r0,r3
000018  d100              BNE      |L24.28|
;;;307                    port = 2;
00001a  2202              MOVS     r2,#2
                  |L24.28|
;;;308    
;;;309            dev = (S_SC_DEV_T *)((uint32_t)&sc_device[port]);
00001c  23e0              MOVS     r3,#0xe0
00001e  435a              MULS     r2,r3,r2
000020  4b13              LDR      r3,|L24.112|
000022  18d2              ADDS     r2,r2,r3
;;;310    
;;;311            portno->CTL &= ~SC_CTL_SC_CEN;
000024  6843              LDR      r3,[r0,#4]
000026  085b              LSRS     r3,r3,#1
000028  005b              LSLS     r3,r3,#1
00002a  6043              STR      r3,[r0,#4]
;;;312            portno->PINCSR &= ~SC_PINCSR_POW_INV;
00002c  6a43              LDR      r3,[r0,#0x24]
00002e  2401              MOVS     r4,#1
000030  02e4              LSLS     r4,r4,#11
000032  43a3              BICS     r3,r3,r4
000034  6243              STR      r3,[r0,#0x24]
;;;313    
;;;314            portno->CTL |= SC_CTL_SC_CEN;
000036  6844              LDR      r4,[r0,#4]
000038  2301              MOVS     r3,#1
00003a  431c              ORRS     r4,r4,r3
00003c  6044              STR      r4,[r0,#4]
;;;315            if(active==1) {
00003e  2901              CMP      r1,#1
000040  d008              BEQ      |L24.84|
;;;316                    portno->PINCSR &= ~SC_PINCSR_POW_EN;    // power pin low in default
;;;317                    dev->ActivePowerPin = 1;
;;;318            } else if(active==0) {
000042  2900              CMP      r1,#0
000044  d105              BNE      |L24.82|
;;;319                    portno->PINCSR |= SC_PINCSR_POW_EN;     // power pin high in default
000046  6a41              LDR      r1,[r0,#0x24]
000048  4319              ORRS     r1,r1,r3
00004a  6241              STR      r1,[r0,#0x24]
;;;320                    dev->ActivePowerPin = 0;
00004c  2000              MOVS     r0,#0
00004e  3220              ADDS     r2,r2,#0x20
000050  7010              STRB     r0,[r2,#0]
                  |L24.82|
;;;321            }
;;;322    #else
;;;323    
;;;324            portno->CTL &= ~SC_CTL_SC_CEN;
;;;325            portno->CTL |= SC_CTL_SC_CEN;
;;;326    #endif
;;;327    
;;;328    }
000052  bd10              POP      {r4,pc}
                  |L24.84|
000054  6a41              LDR      r1,[r0,#0x24]         ;316
000056  0849              LSRS     r1,r1,#1              ;316
000058  0049              LSLS     r1,r1,#1              ;316
00005a  6241              STR      r1,[r0,#0x24]         ;316
00005c  3220              ADDS     r2,r2,#0x20           ;317
00005e  7013              STRB     r3,[r2,#0]            ;317
000060  bd10              POP      {r4,pc}
;;;329    
                          ENDP

000062  0000              DCW      0x0000
                  |L24.100|
                          DCD      0x40190000
                  |L24.104|
                          DCD      0x401b0000
                  |L24.108|
                          DCD      0x401c0000
                  |L24.112|
                          DCD      ||.bss||+0x65c

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

                  SMARTCARD_ResetReader PROC
;;;627      */
;;;628    void SMARTCARD_ResetReader(S_SC_DEV_T *dev)
000000  b5f8              PUSH     {r3-r7,lr}
;;;629    {
000002  4604              MOV      r4,r0
;;;630            SC_TypeDef *SC = dev->base;
;;;631            IRQn_Type SC_IRQn = (dev->base==SC0)?SC0_IRQn:((dev->base==SC1)?SC1_IRQn:SC2_IRQn);
000004  6805              LDR      r5,[r0,#0]
000006  483a              LDR      r0,|L25.240|
000008  4285              CMP      r5,r0
00000a  d101              BNE      |L25.16|
00000c  2715              MOVS     r7,#0x15
00000e  e005              B        |L25.28|
                  |L25.16|
000010  4938              LDR      r1,|L25.244|
000012  428d              CMP      r5,r1
000014  d101              BNE      |L25.26|
000016  2716              MOVS     r7,#0x16
000018  e000              B        |L25.28|
                  |L25.26|
00001a  2714              MOVS     r7,#0x14
                  |L25.28|
;;;632    
;;;633            ENTER();
;;;634    
;;;635            // TODO: Set basic HW settings & protocol default value
;;;636    
;;;637            /* Software Reset Tx & Rx transition */
;;;638            SMARTCARD_ClearFIFO(dev);
00001c  4620              MOV      r0,r4
00001e  f7fffffe          BL       SMARTCARD_ClearFIFO
;;;639    
;;;640            /* Rx FIFO threshold */
;;;641            //SC->CTL = (SC->CTL & ~SC_CTL_RX_FTRI_LEV_MASK) | SC_CTL_RX_FTRI_LEV_3BYTE;      // trigger level 3 bytes
;;;642            SC->CTL = (SC->CTL & ~SC_CTL_RX_FTRI_LEV_MASK) | SC_CTL_RX_FTRI_LEV_1BYTE;         // trigger level 1 bytes
000022  6868              LDR      r0,[r5,#4]
000024  21c0              MOVS     r1,#0xc0
000026  4388              BICS     r0,r0,r1
000028  6068              STR      r0,[r5,#4]
;;;643    
;;;644            /* Rx Time-out setting */
;;;645            SC->RFTMR = 0;          // disable Rx FIFO time-out function
00002a  2000              MOVS     r0,#0
00002c  6128              STR      r0,[r5,#0x10]
;;;646    
;;;647            /* Card detect de-bounce setting */
;;;648            SC->CTL &= ~SC_CTL_CD_DEB_SEL_MASK;
00002e  6868              LDR      r0,[r5,#4]
000030  0489              LSLS     r1,r1,#18
000032  4388              BICS     r0,r0,r1
000034  6068              STR      r0,[r5,#4]
;;;649    
;;;650            /* in default, guard time = 12 etu */
;;;651            dev->CardCapabilities.GT = 12;
000036  4626              MOV      r6,r4
000038  200c              MOVS     r0,#0xc
00003a  3680              ADDS     r6,r6,#0x80
;;;652            SMARTCARD_SetGuardTime( dev );
00003c  6070              STR      r0,[r6,#4]
00003e  4620              MOV      r0,r4
000040  f7fffffe          BL       SMARTCARD_SetGuardTime
;;;653    
;;;654            /* initial end sequence timing setting */
;;;655            SC->ALTCTL |= SC_ALTCTL_INIT_SEL_MASK;
000044  68a8              LDR      r0,[r5,#8]
000046  2103              MOVS     r1,#3
000048  0209              LSLS     r1,r1,#8
00004a  4308              ORRS     r0,r0,r1
00004c  60a8              STR      r0,[r5,#8]
;;;656    
;;;657            /* Tx & Rx Error Retry Settings */
;;;658            /* [ISO 7816-3] */
;;;659            //SMARTCARD_SetTxRetry(dev, 8);         // Tx retry 8 times
;;;660            //SMARTCARD_SetRxRetry(dev, 8);         // Rx retry 8 times
;;;661    
;;;662            /*
;;;663             * Tx & Rx Error Retry Settings
;;;664             * [EMV 2000]
;;;665             * EMV 2000 does NOT use ERROR retry function during ATR
;;;666             */
;;;667            SMARTCARD_SetTxRetry(dev, 0);           // Tx retry 0 times
00004e  2100              MOVS     r1,#0
000050  4620              MOV      r0,r4
000052  f7fffffe          BL       SMARTCARD_SetTxRetry
;;;668            SMARTCARD_SetRxRetry(dev, 0);           // Rx retry 0 times
000056  2100              MOVS     r1,#0
000058  4620              MOV      r0,r4
00005a  f7fffffe          BL       SMARTCARD_SetRxRetry
;;;669    
;;;670            // clear any error status
;;;671            // ...
;;;672    
;;;673            /* enable auto de-activation sequence */
;;;674    #ifndef SC_SEQ_MANUAL
;;;675            SC->PINCSR |= SC_PINCSR_ADAC_CD_EN;     // auto de-activation when card removal
;;;676    #endif
;;;677    
;;;678            /* enable auto convention */
;;;679            SC->CTL |= SC_CTL_AUTO_CON_EN;
00005e  6868              LDR      r0,[r5,#4]
000060  2108              MOVS     r1,#8
000062  4308              ORRS     r0,r0,r1
000064  6068              STR      r0,[r5,#4]
;;;680            /* enable interrupt  */
;;;681            SC->IER |= (SC_IER_RDA_IE |
000066  69a8              LDR      r0,[r5,#0x18]
000068  4923              LDR      r1,|L25.248|
00006a  4308              ORRS     r0,r0,r1
00006c  61a8              STR      r0,[r5,#0x18]
;;;682                    SC_IER_TERR_IE |
;;;683                    SC_IER_TMR0_IE |
;;;684                    SC_IER_TMR1_IE |
;;;685                    SC_IER_TMR2_IE |
;;;686                    SC_IER_BGT_IE |
;;;687                    SC_IER_CD_IE |
;;;688                    SC_IER_INIT_IE |
;;;689                    SC_IER_RTMR_IE |
;;;690                    SC_IER_ACON_ERR_IE);
;;;691    
;;;692    
;;;693            NVIC_DisableIRQ(SC_IRQn);
00006e  4638              MOV      r0,r7
000070  f7fffffe          BL       NVIC_DisableIRQ
;;;694            dev->errno = 0;
000074  2000              MOVS     r0,#0
000076  06f9              LSLS     r1,r7,#27
000078  2501              MOVS     r5,#1
00007a  60a0              STR      r0,[r4,#8]
00007c  0ec9              LSRS     r1,r1,#27
00007e  4628              MOV      r0,r5
000080  4088              LSLS     r0,r0,r1
000082  491e              LDR      r1,|L25.252|
000084  6008              STR      r0,[r1,#0]
;;;695            /* enable SmartCard INT NVIC */
;;;696            NVIC_EnableIRQ(SC_IRQn);
;;;697    
;;;698            /* in defalut, all timer 24 or 8 or 8 turn on */
;;;699            SMARTCARD_TimerSelect(dev, SC_CTL_TMR_SEL_24_8_8_BITS);
000086  2103              MOVS     r1,#3
000088  0349              LSLS     r1,r1,#13
00008a  4620              MOV      r0,r4
00008c  f7fffffe          BL       SMARTCARD_TimerSelect
;;;700    
;;;701    
;;;702            //dev->CardCapabilities.etu = 93;                       // for APDU test card
;;;703            //dev->CardCapabilities.GT = 12;                        // for APDU test card
;;;704            //dev->CardCapabilities.Protocol.Selected = SCARD_PROTOCOL_RAW; // for APDU test card
;;;705    
;;;706            /* Get SC clock */
;;;707            if( (CLK->CLKSEL2 & CLK_CLKSEL2_SC_MASK) == CLK_CLKSEL2_SC_HXT )  // form HXT
000090  481b              LDR      r0,|L25.256|
000092  6981              LDR      r1,[r0,#0x18]
000094  0309              LSLS     r1,r1,#12
000096  0f8a              LSRS     r2,r1,#30
;;;708                    dev->clock = (__XTAL/1000);
000098  491a              LDR      r1,|L25.260|
00009a  d006              BEQ      |L25.170|
;;;709            //else if( (CLK->CLKSEL2 & CLK_CLKSEL2_SC_MASK) == CLK_CLKSEL2_SC_PLL )     // form PLL... why would anyone use PLL as clk source?
;;;710            //        dev->clock = CHECK_PLLOUT_CLK()/1000;
;;;711            else if( (CLK->CLKSEL2 & CLK_CLKSEL2_SC_MASK) >= CLK_CLKSEL2_SC_HIRC )    // form HIRC
00009c  6982              LDR      r2,[r0,#0x18]
00009e  2303              MOVS     r3,#3
0000a0  049b              LSLS     r3,r3,#18
0000a2  401a              ANDS     r2,r2,r3
0000a4  0283              LSLS     r3,r0,#10
0000a6  429a              CMP      r2,r3
0000a8  d300              BCC      |L25.172|
                  |L25.170|
;;;712                    dev->clock = __IRC12M/1000;
0000aa  6121              STR      r1,[r4,#0x10]
                  |L25.172|
;;;713    
;;;714            if(dev->base==SC0)
0000ac  4a10              LDR      r2,|L25.240|
0000ae  6821              LDR      r1,[r4,#0]
0000b0  4291              CMP      r1,r2
0000b2  d102              BNE      |L25.186|
;;;715                    dev->clock /= ((CLK->CLKDIV0 >> 28) + 1);
0000b4  69c0              LDR      r0,[r0,#0x1c]
0000b6  0f01              LSRS     r1,r0,#28
0000b8  e007              B        |L25.202|
                  |L25.186|
;;;716            else if(dev->base==SC1)
0000ba  4a0e              LDR      r2,|L25.244|
;;;717                    dev->clock /= ((CLK->CLKDIV1 & CLK_CLKDIV1_SC1_MASK) + 1);
;;;718            else
;;;719                    dev->clock /= ((CLK->CLKDIV1 >> 4) + 1);
0000bc  6a00              LDR      r0,[r0,#0x20]
0000be  4291              CMP      r1,r2                 ;716
0000c0  d102              BNE      |L25.200|
0000c2  0701              LSLS     r1,r0,#28             ;717
0000c4  0f09              LSRS     r1,r1,#28             ;717
0000c6  e000              B        |L25.202|
                  |L25.200|
0000c8  0901              LSRS     r1,r0,#4
                  |L25.202|
0000ca  1c49              ADDS     r1,r1,#1              ;717
0000cc  6920              LDR      r0,[r4,#0x10]         ;717
0000ce  f7fffffe          BL       __aeabi_uidivmod
;;;720    
;;;721            //printf("SC clock      = %d KHz \n", dev->clock);
;;;722            //dev->clock = 6000;    // 6 Mhz
;;;723            //dev->clock = 4000;    // 4 Mhz
;;;724            //dev->clock = 3375;    // 3.375 Mhz
;;;725            //dev->clock = 2000;    // 2 Mhz
;;;726            dev->CardCapabilities.Fl = 1;
0000d2  6120              STR      r0,[r4,#0x10]
0000d4  3460              ADDS     r4,r4,#0x60
0000d6  77a5              STRB     r5,[r4,#0x1e]
;;;727            dev->CardCapabilities.Dl = 1;
0000d8  77e5              STRB     r5,[r4,#0x1f]
;;;728            dev->CardCapabilities.N = 0;
0000da  2000              MOVS     r0,#0
0000dc  70b0              STRB     r0,[r6,#2]
;;;729    
;;;730            dev->CardCapabilities.T0.WI = 10;
0000de  200a              MOVS     r0,#0xa
0000e0  7430              STRB     r0,[r6,#0x10]
;;;731    
;;;732            dev->CardCapabilities.T1.IFSC = 32;
0000e2  2020              MOVS     r0,#0x20
0000e4  7630              STRB     r0,[r6,#0x18]
;;;733            dev->CardCapabilities.T1.CWI = T1_CWI_DEFAULT;
0000e6  200d              MOVS     r0,#0xd
0000e8  7670              STRB     r0,[r6,#0x19]
;;;734            dev->CardCapabilities.T1.BWI = T1_BWI_DEFAULT;
0000ea  2004              MOVS     r0,#4
0000ec  76b0              STRB     r0,[r6,#0x1a]
;;;735    
;;;736    
;;;737            LEAVE();
;;;738    
;;;739    }
0000ee  bdf8              POP      {r3-r7,pc}
;;;740    
                          ENDP

                  |L25.240|
                          DCD      0x40190000
                  |L25.244|
                          DCD      0x401b0000
                  |L25.248|
                          DCD      0x000007fd
                  |L25.252|
                          DCD      0xe000e100
                  |L25.256|
                          DCD      0x50000200
                  |L25.260|
                          DCD      0x00002ee0

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

                  SMARTCARD_SetBaudrate PROC
;;;547      */
;;;548    static void SMARTCARD_SetBaudrate(S_SC_DEV_T *dev, int32_t fi, int32_t di)
000000  b5f8              PUSH     {r3-r7,lr}
;;;549    {
;;;550            uint32_t etudiv;
;;;551            /*double*/uint32_t fi_val, di_val,/* tmp, tmp2,*/ remainder;
;;;552            SC_TypeDef *SC = dev->base;
;;;553    
;;;554            fi_val = ClockRateConversion[fi].F;
000002  6804              LDR      r4,[r0,#0]
000004  4817              LDR      r0,|L26.100|
000006  00c9              LSLS     r1,r1,#3
000008  5840              LDR      r0,[r0,r1]
;;;555            di_val = BitRateAdjustment[di].DNumerator;
00000a  4916              LDR      r1,|L26.100|
00000c  00d2              LSLS     r2,r2,#3
00000e  3180              ADDS     r1,r1,#0x80
000010  588e              LDR      r6,[r1,r2]
000012  4607              MOV      r7,r0                 ;554
;;;556            remainder = ((fi_val * 10) / di_val) % 10;
000014  210a              MOVS     r1,#0xa
000016  4348              MULS     r0,r1,r0
000018  4631              MOV      r1,r6
00001a  f7fffffe          BL       __aeabi_uidivmod
00001e  210a              MOVS     r1,#0xa
000020  f7fffffe          BL       __aeabi_uidivmod
000024  460d              MOV      r5,r1
000026  4638              MOV      r0,r7
000028  4631              MOV      r1,r6
;;;557            //tmp = fi_val/di_val;
;;;558            //remainder = modf(tmp, &tmp2) * 10;
;;;559    
;;;560            // if the first decimal point of etu divider is greater than 5,
;;;561            // HW enable the compensation function
;;;562            if(remainder >= 5) {
;;;563                    etudiv = (ClockRateConversion[fi].F / BitRateAdjustment[di].DNumerator);
00002a  f7fffffe          BL       __aeabi_uidivmod
00002e  2d05              CMP      r5,#5                 ;562
000030  d304              BCC      |L26.60|
;;;564                    SC->ETUCR = SC_ETUCR_COMPEN_EN | etudiv;
000032  2101              MOVS     r1,#1
000034  03c9              LSLS     r1,r1,#15
000036  4301              ORRS     r1,r1,r0
000038  6161              STR      r1,[r4,#0x14]
00003a  e001              B        |L26.64|
                  |L26.60|
;;;565            } else {
;;;566                    etudiv = (ClockRateConversion[fi].F / BitRateAdjustment[di].DNumerator) - 1;
00003c  1e40              SUBS     r0,r0,#1
;;;567                    SC->ETUCR = etudiv;
00003e  6160              STR      r0,[r4,#0x14]
                  |L26.64|
;;;568            }
;;;569    
;;;570            if(SC==SC0)
;;;571                    g_SC0ETUDivider = etudiv;
000040  4908              LDR      r1,|L26.100|
000042  4a09              LDR      r2,|L26.104|
000044  3978              SUBS     r1,r1,#0x78
000046  4294              CMP      r4,r2                 ;570
000048  d101              BNE      |L26.78|
00004a  66c8              STR      r0,[r1,#0x6c]  ; g_SC0ETUDivider
;;;572            else if(SC==SC1)
;;;573                    g_SC1ETUDivider = etudiv;
;;;574            else if(SC==SC2)
;;;575                    g_SC2ETUDivider = etudiv;
;;;576    
;;;577    }
00004c  bdf8              POP      {r3-r7,pc}
                  |L26.78|
00004e  4a07              LDR      r2,|L26.108|
000050  4294              CMP      r4,r2                 ;572
000052  d101              BNE      |L26.88|
000054  6708              STR      r0,[r1,#0x70]         ;573  ; g_SC1ETUDivider
                  |L26.86|
000056  bdf8              POP      {r3-r7,pc}
                  |L26.88|
000058  4a05              LDR      r2,|L26.112|
00005a  4294              CMP      r4,r2                 ;574
00005c  d1fb              BNE      |L26.86|
00005e  6748              STR      r0,[r1,#0x74]         ;575  ; g_SC2ETUDivider
000060  bdf8              POP      {r3-r7,pc}
;;;578    
                          ENDP

000062  0000              DCW      0x0000
                  |L26.100|
                          DCD      ||.data||+0x78
                  |L26.104|
                          DCD      0x40190000
                  |L26.108|
                          DCD      0x401b0000
                  |L26.112|
                          DCD      0x401c0000

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

                  SMARTCARD_SetBlockGuardTime PROC
;;;483      */
;;;484    static void SMARTCARD_SetBlockGuardTime(S_SC_DEV_T *dev, uint32_t bgt)
000000  6800              LDR      r0,[r0,#0]
;;;485    {
;;;486            SC_TypeDef *SC = dev->base;
;;;487    
;;;488            assert_param( !(bgt<1 || bgt>32) );
;;;489    
;;;490            SC->CTL = (SC->CTL & ~SC_CTL_BGT_MASK) | ((bgt - 1) << 8);
000002  6842              LDR      r2,[r0,#4]
000004  231f              MOVS     r3,#0x1f
000006  021b              LSLS     r3,r3,#8
000008  0209              LSLS     r1,r1,#8
00000a  39ff              SUBS     r1,r1,#0xff
00000c  439a              BICS     r2,r2,r3
00000e  3901              SUBS     r1,#1
000010  430a              ORRS     r2,r2,r1
000012  6042              STR      r2,[r0,#4]
;;;491    }
000014  4770              BX       lr
;;;492    
                          ENDP


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

                  SMARTCARD_SetClockState PROC
;;;174      */
;;;175    void SMARTCARD_SetClockState(S_SC_DEV_T *dev, int8_t onoff)
000000  6800              LDR      r0,[r0,#0]
;;;176    {
;;;177            SC_TypeDef *SC = dev->base;
;;;178    
;;;179            assert_param((onoff==0) || (onoff==1));
;;;180    
;;;181            if ( onoff == 1 )
;;;182                    SC->PINCSR |= SC_PINCSR_CLK_KEEP;
000002  2240              MOVS     r2,#0x40
000004  2901              CMP      r1,#1                 ;181
;;;183            else
;;;184                    SC->PINCSR &= ~SC_PINCSR_CLK_KEEP;
000006  6a41              LDR      r1,[r0,#0x24]
000008  d002              BEQ      |L28.16|
00000a  4391              BICS     r1,r1,r2
                  |L28.12|
00000c  6241              STR      r1,[r0,#0x24]         ;182
;;;185    }
00000e  4770              BX       lr
                  |L28.16|
000010  4311              ORRS     r1,r1,r2              ;182
000012  e7fb              B        |L28.12|
;;;186    
                          ENDP


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

                  SMARTCARD_SetGuardTime PROC
;;;450      */
;;;451    static void SMARTCARD_SetGuardTime(S_SC_DEV_T *dev)
000000  b530              PUSH     {r4,r5,lr}
;;;452    {
;;;453            SC_TypeDef *SC = dev->base;
000002  6801              LDR      r1,[r0,#0]
000004  3080              ADDS     r0,r0,#0x80
;;;454            uint32_t gt = dev->CardCapabilities.GT;
;;;455    
;;;456            assert_param( !(gt<11 || gt>267) );
;;;457    
;;;458            /* [EMV 2000] EMV in T=0, minmun GT is 12 */
;;;459            if(dev->CardCapabilities.Protocol.Selected == SCARD_PROTOCOL_T0) {
;;;460                    if(gt==11)
;;;461                            gt = 12;
;;;462                    else {
;;;463                            SC->CTL &= ~SC_CTL_SLEN;        // 2 EUT stop bit
000006  2301              MOVS     r3,#1
000008  68c4              LDR      r4,[r0,#0xc]          ;459
00000a  03db              LSLS     r3,r3,#15
00000c  6842              LDR      r2,[r0,#4]            ;459
00000e  2c01              CMP      r4,#1                 ;459
000010  d10b              BNE      |L29.42|
000012  2a0b              CMP      r2,#0xb               ;460
000014  d017              BEQ      |L29.70|
000016  684c              LDR      r4,[r1,#4]
000018  439c              BICS     r4,r4,r3
00001a  604c              STR      r4,[r1,#4]
;;;464                            SC->EGTR = (SC->EGTR&~(0xFF)) | (gt-12);
00001c  68cc              LDR      r4,[r1,#0xc]
00001e  4615              MOV      r5,r2
000020  0a24              LSRS     r4,r4,#8
000022  0224              LSLS     r4,r4,#8
000024  3d0c              SUBS     r5,r5,#0xc
000026  432c              ORRS     r4,r4,r5
000028  60cc              STR      r4,[r1,#0xc]
                  |L29.42|
;;;465                    }
;;;466            }
;;;467    
;;;468            if(dev->CardCapabilities.Protocol.Selected == SCARD_PROTOCOL_T1) {
00002a  68c0              LDR      r0,[r0,#0xc]
00002c  2802              CMP      r0,#2
00002e  d10a              BNE      |L29.70|
;;;469                    if(gt==11) {
;;;470                            SC->CTL |= SC_CTL_SLEN; // 1 EUT stop bit
;;;471                            SC->EGTR = (SC->EGTR&~(0xFF));
;;;472                    } else {
;;;473                            SC->CTL |= SC_CTL_SLEN; // 1 EUT stop bit
000030  6848              LDR      r0,[r1,#4]
000032  2a0b              CMP      r2,#0xb               ;469
000034  d008              BEQ      |L29.72|
000036  4318              ORRS     r0,r0,r3
000038  6048              STR      r0,[r1,#4]
;;;474                            SC->EGTR = (SC->EGTR&~(0xFF)) | (gt-11);
00003a  68c8              LDR      r0,[r1,#0xc]
00003c  0a00              LSRS     r0,r0,#8
00003e  0200              LSLS     r0,r0,#8
000040  3a0b              SUBS     r2,r2,#0xb
000042  4310              ORRS     r0,r0,r2
                  |L29.68|
000044  60c8              STR      r0,[r1,#0xc]
                  |L29.70|
;;;475                    }
;;;476            }
;;;477    }
000046  bd30              POP      {r4,r5,pc}
                  |L29.72|
000048  4318              ORRS     r0,r0,r3              ;470
00004a  6048              STR      r0,[r1,#4]            ;470
00004c  68c8              LDR      r0,[r1,#0xc]          ;471
00004e  0a00              LSRS     r0,r0,#8              ;471
000050  0200              LSLS     r0,r0,#8              ;471
000052  e7f7              B        |L29.68|
;;;478    /**
                          ENDP


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

                  SMARTCARD_SetReaderParameter PROC
;;;584      */
;;;585    void SMARTCARD_SetReaderParameter(S_SC_DEV_T *dev)
000000  b570              PUSH     {r4-r6,lr}
;;;586    {
000002  4604              MOV      r4,r0
;;;587            /* set reader baud rate and update dev->clock , so we can calcute etu */
;;;588            ENTER();
;;;589    
;;;590            SMARTCARD_SetBaudrate(dev, dev->CardCapabilities.Fl, dev->CardCapabilities.Dl);
000004  3060              ADDS     r0,r0,#0x60
000006  7fc2              LDRB     r2,[r0,#0x1f]
000008  7f81              LDRB     r1,[r0,#0x1e]
00000a  4620              MOV      r0,r4
00000c  f7fffffe          BL       SMARTCARD_SetBaudrate
000010  7d21              LDRB     r1,[r4,#0x14]
000012  2220              MOVS     r2,#0x20
000014  6820              LDR      r0,[r4,#0]
000016  2901              CMP      r1,#1
000018  d002              BEQ      |L30.32|
00001a  2902              CMP      r1,#2
00001c  d003              BEQ      |L30.38|
00001e  e005              B        |L30.44|
                  |L30.32|
000020  6a41              LDR      r1,[r0,#0x24]
000022  4391              BICS     r1,r1,r2
000024  e001              B        |L30.42|
                  |L30.38|
000026  6a41              LDR      r1,[r0,#0x24]
000028  4311              ORRS     r1,r1,r2
                  |L30.42|
00002a  6241              STR      r1,[r0,#0x24]
                  |L30.44|
;;;591    
;;;592            // TODO: set GT, BGT, clock stop level or apply the new settings
;;;593    
;;;594            SMARTCARD_ClockStopLevel( dev );
;;;595    
;;;596            SMARTCARD_SetGuardTime( dev );
00002c  4620              MOV      r0,r4
00002e  f7fffffe          BL       SMARTCARD_SetGuardTime
;;;597    
;;;598            if(dev->CardCapabilities.Protocol.Selected == SCARD_PROTOCOL_T0) {
000032  4625              MOV      r5,r4
000034  3580              ADDS     r5,r5,#0x80
000036  68e8              LDR      r0,[r5,#0xc]
000038  2801              CMP      r0,#1
00003a  d018              BEQ      |L30.110|
;;;599                    SMARTCARD_SetBlockGuardTime(dev, 16);   //BGT = 16
;;;600            } else if(dev->CardCapabilities.Protocol.Selected == SCARD_PROTOCOL_T1) {
00003c  2802              CMP      r0,#2
00003e  d115              BNE      |L30.108|
;;;601                    SMARTCARD_SetBlockGuardTime(dev, 22);   //BGT = 22
000040  2116              MOVS     r1,#0x16
000042  4620              MOV      r0,r4
000044  f7fffffe          BL       SMARTCARD_SetBlockGuardTime
;;;602                    /* set send-sequence & more-data bit */
;;;603                    dev->T1.SSN = 1;        // default value
000048  4620              MOV      r0,r4
00004a  2101              MOVS     r1,#1
00004c  30c0              ADDS     r0,r0,#0xc0
00004e  7701              STRB     r1,[r0,#0x1c]
;;;604                    dev->T1.RSN = 0;        // defalut value
000050  2100              MOVS     r1,#0
000052  76c1              STRB     r1,[r0,#0x1b]
;;;605                    dev->T1.IBLOCK_REC = 0; // default value
000054  7681              STRB     r1,[r0,#0x1a]
                  |L30.86|
;;;606            }
;;;607    
;;;608            /* Tx & Rx Error Retry Settings */
;;;609            /* [EMV 2000] */
;;;610            if(dev->CardCapabilities.Protocol.Selected == SCARD_PROTOCOL_T0) {
000056  68e8              LDR      r0,[r5,#0xc]
000058  2801              CMP      r0,#1
00005a  d107              BNE      |L30.108|
;;;611                    SMARTCARD_SetTxRetry(dev, 4);           // Tx retry 4 times
00005c  2104              MOVS     r1,#4
00005e  4620              MOV      r0,r4
000060  f7fffffe          BL       SMARTCARD_SetTxRetry
;;;612                    //SMARTCARD_SetRxRetry(dev, 8);         // Rx retry 8 times
;;;613                    // [2011.11.25 night]
;;;614                    /* EMV Certification */
;;;615                    SMARTCARD_SetRxRetry(dev, 4);           // Rx retry 4 times
000064  2104              MOVS     r1,#4
000066  4620              MOV      r0,r4
000068  f7fffffe          BL       SMARTCARD_SetRxRetry
                  |L30.108|
;;;616            }
;;;617    
;;;618            LEAVE();
;;;619    
;;;620    }
00006c  bd70              POP      {r4-r6,pc}
                  |L30.110|
00006e  2110              MOVS     r1,#0x10              ;599
000070  4620              MOV      r0,r4                 ;599
000072  f7fffffe          BL       SMARTCARD_SetBlockGuardTime
000076  e7ee              B        |L30.86|
;;;621    
                          ENDP


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

                  SMARTCARD_SetRxRetry PROC
;;;230      */
;;;231    static void SMARTCARD_SetRxRetry(S_SC_DEV_T *dev, uint32_t errNum)
000000  6800              LDR      r0,[r0,#0]
;;;232    {
;;;233            SC_TypeDef *SC = dev->base;
;;;234    
;;;235            assert_param( errNum<9 );
;;;236    
;;;237            if(errNum == 0) {       // disable Rx error retry
000002  2900              CMP      r1,#0
000004  d007              BEQ      |L31.22|
;;;238                    SC->CTL &= ~(SC_CTL_RX_ERETRY_MASK | SC_CTL_RX_ERETRY_EN);
;;;239            } else {
;;;240                    SC->CTL |= (errNum - 1) | SC_CTL_RX_ERETRY_EN;
000006  6842              LDR      r2,[r0,#4]
000008  1e49              SUBS     r1,r1,#1
00000a  2301              MOVS     r3,#1
00000c  04db              LSLS     r3,r3,#19
00000e  4319              ORRS     r1,r1,r3
000010  430a              ORRS     r2,r2,r1
000012  6042              STR      r2,[r0,#4]
;;;241            }
;;;242    }
000014  4770              BX       lr
                  |L31.22|
000016  6841              LDR      r1,[r0,#4]            ;238
000018  220f              MOVS     r2,#0xf               ;238
00001a  0412              LSLS     r2,r2,#16             ;238
00001c  4391              BICS     r1,r1,r2              ;238
00001e  6041              STR      r1,[r0,#4]            ;238
000020  4770              BX       lr
;;;243    
                          ENDP


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

                  SMARTCARD_SetTxRetry PROC
;;;209      */
;;;210    static void SMARTCARD_SetTxRetry(S_SC_DEV_T *dev, uint32_t errNum)
000000  6800              LDR      r0,[r0,#0]
;;;211    {
;;;212            SC_TypeDef *SC = dev->base;
;;;213    
;;;214            assert_param( errNum<9 );
;;;215    
;;;216            if(errNum == 0) {       // disable Tx error retry
000002  2900              CMP      r1,#0
000004  d007              BEQ      |L32.22|
;;;217                    SC->CTL &= ~(SC_CTL_TX_ERETRY_MASK | SC_CTL_TX_ERETRY_EN);
;;;218            } else {
;;;219                    SC->CTL |= (errNum - 1) | SC_CTL_TX_ERETRY_EN;
000006  6842              LDR      r2,[r0,#4]
000008  1e49              SUBS     r1,r1,#1
00000a  2301              MOVS     r3,#1
00000c  05db              LSLS     r3,r3,#23
00000e  4319              ORRS     r1,r1,r3
000010  430a              ORRS     r2,r2,r1
000012  6042              STR      r2,[r0,#4]
;;;220            }
;;;221    
;;;222    }
000014  4770              BX       lr
                  |L32.22|
000016  6841              LDR      r1,[r0,#4]            ;217
000018  220f              MOVS     r2,#0xf               ;217
00001a  0512              LSLS     r2,r2,#20             ;217
00001c  4391              BICS     r1,r1,r2              ;217
00001e  6041              STR      r1,[r0,#4]            ;217
000020  4770              BX       lr
;;;223    
                          ENDP


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

                  SMARTCARD_StartBlockGuardTime PROC
;;;497      */
;;;498    void SMARTCARD_StartBlockGuardTime( S_SC_DEV_T *dev )
000000  6800              LDR      r0,[r0,#0]
;;;499    {
;;;500            SC_TypeDef *SC = dev->base;
;;;501            SC->ALTCTL |= SC_ALTCTL_RX_BGT_EN;
000002  6881              LDR      r1,[r0,#8]
000004  2201              MOVS     r2,#1
000006  0312              LSLS     r2,r2,#12
000008  4311              ORRS     r1,r1,r2
00000a  6081              STR      r1,[r0,#8]
;;;502    }
00000c  4770              BX       lr
;;;503    
                          ENDP


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

                  SMARTCARD_StopBlockGuardTime PROC
;;;508      */
;;;509    void SMARTCARD_StopBlockGuardTime( S_SC_DEV_T *dev )
000000  6800              LDR      r0,[r0,#0]
;;;510    {
;;;511            SC_TypeDef *SC = dev->base;
;;;512            SC->ALTCTL &= ~SC_ALTCTL_RX_BGT_EN;
000002  6881              LDR      r1,[r0,#8]
000004  2201              MOVS     r2,#1
000006  0312              LSLS     r2,r2,#12
000008  4391              BICS     r1,r1,r2
00000a  6081              STR      r1,[r0,#8]
;;;513    }
00000c  4770              BX       lr
;;;514    
                          ENDP


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

                  SMARTCARD_TimerAllStop PROC
;;;1728     */
;;;1729   void SMARTCARD_TimerAllStop( S_SC_DEV_T *dev )
000000  6800              LDR      r0,[r0,#0]
;;;1730   {
;;;1731           SC_TypeDef *SC = dev->base;
;;;1732           // disable all internal timer function
;;;1733   
;;;1734           SC->ALTCTL &= ~(SC_ALTCTL_TMR0_SEN | SC_ALTCTL_TMR1_SEN | SC_ALTCTL_TMR2_SEN);
000002  6881              LDR      r1,[r0,#8]
000004  22e0              MOVS     r2,#0xe0
000006  4391              BICS     r1,r1,r2
000008  6081              STR      r1,[r0,#8]
;;;1735   
;;;1736   }
00000a  4770              BX       lr
;;;1737   
                          ENDP


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

                  SMARTCARD_TimerCountSet PROC
;;;1745     */
;;;1746   void SMARTCARD_TimerCountSet(S_SC_DEV_T *dev, E_SC_TIMER no, uint32_t op_mode, uint32_t cnt)
000000  b510              PUSH     {r4,lr}
;;;1747   {
;;;1748           SC_TypeDef *SC = dev->base;
;;;1749           uint32_t reg = op_mode | (0xFFFFFF & (cnt-1));
000002  1e5b              SUBS     r3,r3,#1
000004  6804              LDR      r4,[r0,#0]
000006  0218              LSLS     r0,r3,#8
000008  0a00              LSRS     r0,r0,#8
00000a  4310              ORRS     r0,r0,r2
;;;1750   
;;;1751           if(no == SC_TIMER0) {
00000c  2908              CMP      r1,#8
00000e  d005              BEQ      |L36.28|
;;;1752                   SC->TMR0 = reg;
;;;1753           } else if(no == SC_TIMER1) {
000010  2910              CMP      r1,#0x10
000012  d005              BEQ      |L36.32|
;;;1754                   SC->TMR1 = reg;
;;;1755           } else if(no == SC_TIMER2) {
000014  2920              CMP      r1,#0x20
000016  d100              BNE      |L36.26|
;;;1756                   SC->TMR2 = reg;
000018  6320              STR      r0,[r4,#0x30]
                  |L36.26|
;;;1757           }
;;;1758   }
00001a  bd10              POP      {r4,pc}
                  |L36.28|
00001c  62a0              STR      r0,[r4,#0x28]         ;1752
00001e  bd10              POP      {r4,pc}
                  |L36.32|
000020  62e0              STR      r0,[r4,#0x2c]         ;1754
000022  bd10              POP      {r4,pc}
;;;1759   
                          ENDP


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

                  SMARTCARD_TimerINTDisable PROC
;;;1663     */
;;;1664   void SMARTCARD_TimerINTDisable(S_SC_DEV_T *dev, E_SC_TIMER no)
000000  6800              LDR      r0,[r0,#0]
;;;1665   {
;;;1666           SC_TypeDef *SC = dev->base;
;;;1667           if( no & SC_TIMER0) SC->IER &= ~SC_IER_TMR0_IE;
000002  070a              LSLS     r2,r1,#28
000004  d503              BPL      |L37.14|
000006  6982              LDR      r2,[r0,#0x18]
000008  2308              MOVS     r3,#8
00000a  439a              BICS     r2,r2,r3
00000c  6182              STR      r2,[r0,#0x18]
                  |L37.14|
;;;1668           if( no & SC_TIMER1) SC->IER &= ~SC_IER_TMR1_IE;
00000e  06ca              LSLS     r2,r1,#27
000010  d503              BPL      |L37.26|
000012  6982              LDR      r2,[r0,#0x18]
000014  2310              MOVS     r3,#0x10
000016  439a              BICS     r2,r2,r3
000018  6182              STR      r2,[r0,#0x18]
                  |L37.26|
;;;1669           if( no & SC_TIMER2) SC->IER &= ~SC_IER_TMR2_IE;
00001a  0689              LSLS     r1,r1,#26
00001c  d503              BPL      |L37.38|
00001e  6981              LDR      r1,[r0,#0x18]
000020  2220              MOVS     r2,#0x20
000022  4391              BICS     r1,r1,r2
000024  6181              STR      r1,[r0,#0x18]
                  |L37.38|
;;;1670   }
000026  4770              BX       lr
;;;1671   
                          ENDP


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

                  SMARTCARD_TimerINTEnable PROC
;;;1649     */
;;;1650   void SMARTCARD_TimerINTEnable(S_SC_DEV_T *dev, E_SC_TIMER no)
000000  6800              LDR      r0,[r0,#0]
;;;1651   {
;;;1652           SC_TypeDef *SC = dev->base;
;;;1653           if( no & SC_TIMER0) SC->IER |= SC_IER_TMR0_IE;
000002  070a              LSLS     r2,r1,#28
000004  d503              BPL      |L38.14|
000006  6982              LDR      r2,[r0,#0x18]
000008  2308              MOVS     r3,#8
00000a  431a              ORRS     r2,r2,r3
00000c  6182              STR      r2,[r0,#0x18]
                  |L38.14|
;;;1654           if( no & SC_TIMER1) SC->IER |= SC_IER_TMR1_IE;
00000e  06ca              LSLS     r2,r1,#27
000010  d503              BPL      |L38.26|
000012  6982              LDR      r2,[r0,#0x18]
000014  2310              MOVS     r3,#0x10
000016  431a              ORRS     r2,r2,r3
000018  6182              STR      r2,[r0,#0x18]
                  |L38.26|
;;;1655           if( no & SC_TIMER2) SC->IER |= SC_IER_TMR2_IE;
00001a  0689              LSLS     r1,r1,#26
00001c  d503              BPL      |L38.38|
00001e  6981              LDR      r1,[r0,#0x18]
000020  2220              MOVS     r2,#0x20
000022  4311              ORRS     r1,r1,r2
000024  6181              STR      r1,[r0,#0x18]
                  |L38.38|
;;;1656   }
000026  4770              BX       lr
;;;1657   
                          ENDP


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

                  SMARTCARD_TimerSelect PROC
;;;1677     */
;;;1678   void SMARTCARD_TimerSelect(S_SC_DEV_T *dev, uint32_t type)
000000  6800              LDR      r0,[r0,#0]
;;;1679   {
;;;1680           SC_TypeDef *SC = dev->base;
;;;1681           SC->CTL = (SC->CTL & ~SC_CTL_TMR_SEL_MASK) | type;
000002  6842              LDR      r2,[r0,#4]
000004  2303              MOVS     r3,#3
000006  035b              LSLS     r3,r3,#13
000008  439a              BICS     r2,r2,r3
00000a  430a              ORRS     r2,r2,r1
00000c  6042              STR      r2,[r0,#4]
;;;1682   }
00000e  4770              BX       lr
;;;1683   
                          ENDP


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

                  SMARTCARD_TimerStart PROC
;;;1689     */
;;;1690   void SMARTCARD_TimerStart(S_SC_DEV_T *dev, E_SC_TIMER no)
000000  b510              PUSH     {r4,lr}
;;;1691   {
;;;1692           SC_TypeDef *SC = dev->base;
000002  6800              LDR      r0,[r0,#0]
;;;1693           if(no & SC_TIMER0) {
000004  070b              LSLS     r3,r1,#28
;;;1694                   SC->ISR = SC_ISR_TMR0_IS;
;;;1695                   SC->ALTCTL |= SC_ALTCTL_TMR0_SEN;
000006  2220              MOVS     r2,#0x20
000008  2b00              CMP      r3,#0                 ;1693
00000a  da04              BGE      |L40.22|
00000c  2308              MOVS     r3,#8                 ;1694
00000e  61c3              STR      r3,[r0,#0x1c]         ;1694
000010  6883              LDR      r3,[r0,#8]
000012  4313              ORRS     r3,r3,r2
000014  6083              STR      r3,[r0,#8]
                  |L40.22|
;;;1696           }
;;;1697           if(no & SC_TIMER1) {
000016  06cb              LSLS     r3,r1,#27
000018  d505              BPL      |L40.38|
;;;1698                   SC->ISR = SC_ISR_TMR1_IS;
00001a  2310              MOVS     r3,#0x10
00001c  61c3              STR      r3,[r0,#0x1c]
;;;1699                   SC->ALTCTL |= SC_ALTCTL_TMR1_SEN;
00001e  6883              LDR      r3,[r0,#8]
000020  2440              MOVS     r4,#0x40
000022  4323              ORRS     r3,r3,r4
000024  6083              STR      r3,[r0,#8]
                  |L40.38|
;;;1700           }
;;;1701           if(no & SC_TIMER2) {
000026  0689              LSLS     r1,r1,#26
000028  d504              BPL      |L40.52|
;;;1702                   SC->ISR = SC_ISR_TMR2_IS;
00002a  61c2              STR      r2,[r0,#0x1c]
;;;1703                   SC->ALTCTL |= SC_ALTCTL_TMR2_SEN;
00002c  6881              LDR      r1,[r0,#8]
00002e  2280              MOVS     r2,#0x80
000030  4311              ORRS     r1,r1,r2
000032  6081              STR      r1,[r0,#8]
                  |L40.52|
;;;1704           }
;;;1705   }
000034  bd10              POP      {r4,pc}
;;;1706   
                          ENDP


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

                  SMARTCARD_TimerStop PROC
;;;1712     */
;;;1713   void SMARTCARD_TimerStop(S_SC_DEV_T *dev, E_SC_TIMER no)
000000  6800              LDR      r0,[r0,#0]
;;;1714   {
;;;1715           SC_TypeDef *SC = dev->base;
;;;1716           if(no & SC_TIMER0)
000002  070a              LSLS     r2,r1,#28
000004  d503              BPL      |L41.14|
;;;1717                   SC->ALTCTL &= ~SC_ALTCTL_TMR0_SEN;
000006  6882              LDR      r2,[r0,#8]
000008  2320              MOVS     r3,#0x20
00000a  439a              BICS     r2,r2,r3
00000c  6082              STR      r2,[r0,#8]
                  |L41.14|
;;;1718           if(no & SC_TIMER1)
00000e  06ca              LSLS     r2,r1,#27
000010  d503              BPL      |L41.26|
;;;1719                   SC->ALTCTL &= ~SC_ALTCTL_TMR1_SEN;
000012  6882              LDR      r2,[r0,#8]
000014  2340              MOVS     r3,#0x40
000016  439a              BICS     r2,r2,r3
000018  6082              STR      r2,[r0,#8]
                  |L41.26|
;;;1720           if(no & SC_TIMER2)
00001a  0689              LSLS     r1,r1,#26
00001c  d503              BPL      |L41.38|
;;;1721                   SC->ALTCTL &= ~SC_ALTCTL_TMR2_SEN;
00001e  6881              LDR      r1,[r0,#8]
000020  2280              MOVS     r2,#0x80
000022  4391              BICS     r1,r1,r2
000024  6081              STR      r1,[r0,#8]
                  |L41.38|
;;;1722   }
000026  4770              BX       lr
;;;1723   
                          ENDP


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

                  SMARTCARD_VoltageConfig PROC
;;;266      */
;;;267    void SMARTCARD_VoltageConfig(S_SC_DEV_T *dev)
000000  4770              BX       lr
;;;268    {
;;;269    
;;;270            /* select power supply */
;;;271            switch(dev->voltage) {
;;;272            case SC_ISO_OPERATIONCLASS_A:           /* 5v */
;;;273                    // TODO: configure VCC to 5V according to hardware design
;;;274    
;;;275                    break;
;;;276    
;;;277            case SC_ISO_OPERATIONCLASS_B:           /* 3v */
;;;278                    // TODO: configure VCC to 3V according to hardware design
;;;279    
;;;280                    break;
;;;281            default:
;;;282            case SC_ISO_OPERATIONCLASS_C:           /* 1.8v */
;;;283                    // TODO: configure VCC to 1.8V according to hardware design
;;;284    
;;;285                    break;
;;;286            }
;;;287    
;;;288    }
;;;289    
                          ENDP


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

                  SMARTCARD_WaitFirstReceivedData PROC
;;;1768     */
;;;1769   void SMARTCARD_WaitFirstReceivedData(S_SC_DEV_T *dev, E_SC_TIMER no, uint32_t op_mode, uint32_t cnt)
000000  b5ff              PUSH     {r0-r7,lr}
;;;1770   {
000002  b081              SUB      sp,sp,#4
000004  4605              MOV      r5,r0
;;;1771           int32_t timeOutCount = 0, remainderCount = 0;
;;;1772           int32_t errorflag = 0;
;;;1773   
;;;1774           /* Because TIMER1 or TIMER2 Max. ETU count is 256 */
;;;1775           if(no != SC_TIMER0) {
000006  9802              LDR      r0,[sp,#8]
000008  2400              MOVS     r4,#0                 ;1772
00000a  2808              CMP      r0,#8
00000c  d00a              BEQ      |L43.36|
;;;1776                   timeOutCount = cnt / 256;
;;;1777                   remainderCount = cnt % 256;
00000e  b2d8              UXTB     r0,r3
;;;1778           }
;;;1779   
;;;1780           if(no == SC_TIMER0)
;;;1781                   errorflag = SC_ERR_TIME0OUT;
;;;1782           else if(no == SC_TIMER1)
000010  9000              STR      r0,[sp,#0]
;;;1783                   errorflag = SC_ERR_TIME1OUT;
;;;1784           else if(no == SC_TIMER2)
;;;1785                   errorflag = SC_ERR_TIME2OUT;
;;;1786   
;;;1787           while(timeOutCount) {
;;;1788                   dev->errno = 0;
;;;1789                   SMARTCARD_TimerCountSet(dev, no, op_mode, 256);
;;;1790                   SMARTCARD_TimerStart(dev, no);
;;;1791   
;;;1792                   while( !(dev->errno) ) {
;;;1793                           if(dev->errno == errorflag)
;;;1794                                   break;
;;;1795                           else {
;;;1796                                   // if received the first data ?
;;;1797                                   if(dev->rcv_cnt > 0) {
000012  462f              MOV      r7,r5
000014  9802              LDR      r0,[sp,#8]            ;1782
000016  0a1e              LSRS     r6,r3,#8              ;1776
000018  37c0              ADDS     r7,r7,#0xc0
00001a  2810              CMP      r0,#0x10              ;1782
00001c  d005              BEQ      |L43.42|
00001e  2820              CMP      r0,#0x20              ;1784
000020  d006              BEQ      |L43.48|
000022  e022              B        |L43.106|
                  |L43.36|
000024  246e              MOVS     r4,#0x6e              ;1781
000026  43e4              MVNS     r4,r4                 ;1781
000028  e040              B        |L43.172|
                  |L43.42|
00002a  246d              MOVS     r4,#0x6d              ;1783
00002c  43e4              MVNS     r4,r4                 ;1783
00002e  e01c              B        |L43.106|
                  |L43.48|
000030  246c              MOVS     r4,#0x6c              ;1785
000032  43e4              MVNS     r4,r4                 ;1785
000034  e019              B        |L43.106|
                  |L43.54|
000036  2000              MOVS     r0,#0                 ;1788
000038  60a8              STR      r0,[r5,#8]            ;1789
00003a  23ff              MOVS     r3,#0xff              ;1789
00003c  3301              ADDS     r3,#1                 ;1789
00003e  4628              MOV      r0,r5                 ;1789
000040  9a03              LDR      r2,[sp,#0xc]          ;1789
000042  9902              LDR      r1,[sp,#8]            ;1789
000044  f7fffffe          BL       SMARTCARD_TimerCountSet
000048  4628              MOV      r0,r5                 ;1790
00004a  9902              LDR      r1,[sp,#8]            ;1790
00004c  f7fffffe          BL       SMARTCARD_TimerStart
000050  68a8              LDR      r0,[r5,#8]            ;1792
000052  2800              CMP      r0,#0                 ;1792
000054  d108              BNE      |L43.104|
                  |L43.86|
000056  42a0              CMP      r0,r4                 ;1793
000058  d006              BEQ      |L43.104|
00005a  6879              LDR      r1,[r7,#4]
00005c  2900              CMP      r1,#0
00005e  dc1d              BGT      |L43.156|
;;;1798                                           SMARTCARD_TimerStop(dev, no);
;;;1799                                           return ;
;;;1800                                   }
;;;1801   
;;;1802                                   // if had any other errors ?
;;;1803                                   if( (dev->errno!=errorflag) && (dev->errno!=0))
000060  2800              CMP      r0,#0
000062  d0f8              BEQ      |L43.86|
                  |L43.100|
;;;1804                                           return ;
;;;1805                           }
;;;1806                   }
;;;1807                   timeOutCount--;
;;;1808           }
;;;1809   
;;;1810           if(remainderCount) {
;;;1811                   dev->errno = 0;
;;;1812                   SMARTCARD_TimerCountSet(dev, no, op_mode, remainderCount);
;;;1813                   SMARTCARD_TimerStart(dev, no);
;;;1814   
;;;1815                   while( !(dev->errno) ) {
;;;1816                           if(dev->errno == errorflag)
;;;1817                                   break;
;;;1818                           else {
;;;1819                                   // if received the first data ?
;;;1820                                   if(dev->rcv_cnt > 0) {
;;;1821                                           SMARTCARD_TimerStop(dev, no);
;;;1822                                           return ;
;;;1823                                   }
;;;1824   
;;;1825                                   // if had any other errors ?
;;;1826                                   if( (dev->errno!=errorflag) && (dev->errno!=0))
;;;1827                                           return ;
;;;1828                           }
;;;1829                   }
;;;1830           }
;;;1831           /* really time-out happened on first byte */
;;;1832           dev->op_state = SC_OP_NOP;
;;;1833           dev->errno = errorflag;
;;;1834   
;;;1835   }
000064  b005              ADD      sp,sp,#0x14
000066  bdf0              POP      {r4-r7,pc}
                  |L43.104|
000068  1e76              SUBS     r6,r6,#1              ;1807
                  |L43.106|
00006a  2e00              CMP      r6,#0                 ;1787
00006c  d1e3              BNE      |L43.54|
00006e  9800              LDR      r0,[sp,#0]            ;1810
000070  2800              CMP      r0,#0                 ;1810
000072  d01b              BEQ      |L43.172|
000074  2000              MOVS     r0,#0                 ;1811
000076  60a8              STR      r0,[r5,#8]            ;1812
000078  4628              MOV      r0,r5                 ;1812
00007a  9b00              LDR      r3,[sp,#0]            ;1812
00007c  9a03              LDR      r2,[sp,#0xc]          ;1812
00007e  9902              LDR      r1,[sp,#8]            ;1812
000080  f7fffffe          BL       SMARTCARD_TimerCountSet
000084  4628              MOV      r0,r5                 ;1813
000086  9902              LDR      r1,[sp,#8]            ;1813
000088  f7fffffe          BL       SMARTCARD_TimerStart
00008c  68a8              LDR      r0,[r5,#8]            ;1815
00008e  2800              CMP      r0,#0                 ;1815
000090  d10c              BNE      |L43.172|
                  |L43.146|
000092  42a0              CMP      r0,r4                 ;1816
000094  d00a              BEQ      |L43.172|
000096  6879              LDR      r1,[r7,#4]            ;1820
000098  2900              CMP      r1,#0                 ;1820
00009a  dd04              BLE      |L43.166|
                  |L43.156|
00009c  4628              MOV      r0,r5                 ;1821
00009e  9902              LDR      r1,[sp,#8]            ;1821
0000a0  f7fffffe          BL       SMARTCARD_TimerStop
0000a4  e7de              B        |L43.100|
                  |L43.166|
0000a6  2800              CMP      r0,#0                 ;1826
0000a8  d0f3              BEQ      |L43.146|
0000aa  e7db              B        |L43.100|
                  |L43.172|
0000ac  2000              MOVS     r0,#0                 ;1832
0000ae  6068              STR      r0,[r5,#4]            ;1832
0000b0  60ac              STR      r4,[r5,#8]            ;1833
0000b2  e7d7              B        |L43.100|
;;;1836   
                          ENDP


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

                          REQUIRE _printf_percent
                          REQUIRE _printf_s
                          REQUIRE _printf_str
                  SMARTCARD_WarmReset PROC
;;;1161     */
;;;1162   int32_t SMARTCARD_WarmReset(S_SC_DEV_T *dev)
000000  b510              PUSH     {r4,lr}
;;;1163   {
000002  4604              MOV      r4,r0
;;;1164   
;;;1165           ENTER();
;;;1166   
;;;1167           dev->errno = SMARTCARD_ActivateCard(dev, SC_WARMRESET);
000004  2102              MOVS     r1,#2
000006  f7fffffe          BL       SMARTCARD_ActivateCard
;;;1168   
;;;1169           if(dev->errno != 0)
00000a  60a0              STR      r0,[r4,#8]
00000c  2800              CMP      r0,#0
00000e  d116              BNE      |L44.62|
;;;1170                   return (dev->errno);
;;;1171   
;;;1172           dev->pps_complete = 0;
000010  2100              MOVS     r1,#0
000012  20cc              MOVS     r0,#0xcc
000014  5501              STRB     r1,[r0,r4]
;;;1173           dev->errno = SmartcardUpdateCardCapabilities(dev);
000016  4620              MOV      r0,r4
000018  f7fffffe          BL       SmartcardUpdateCardCapabilities
;;;1174   
;;;1175           if(dev->errno != 0)
00001c  60a0              STR      r0,[r4,#8]
00001e  2800              CMP      r0,#0
000020  d10d              BNE      |L44.62|
;;;1176                   return (dev->errno);
;;;1177   
;;;1178           dev->errno = SMARTCARD_ParseATR(dev, SC_WARMRESET);
000022  2102              MOVS     r1,#2
000024  4620              MOV      r0,r4
000026  f7fffffe          BL       SMARTCARD_ParseATR
;;;1179   
;;;1180           if(dev->errno != 0)
00002a  60a0              STR      r0,[r4,#8]
00002c  2800              CMP      r0,#0
00002e  d005              BEQ      |L44.60|
;;;1181                   printf("SMARTCARD_WarmReset:: ParseATR..Error Msg:%s \n", SMARTCARD_ERRMSG(dev->errno));
000030  f7fffffe          BL       SMARTCARD_ERRMSG
000034  4601              MOV      r1,r0
000036  a002              ADR      r0,|L44.64|
000038  f7fffffe          BL       __2printf
                  |L44.60|
;;;1182   
;;;1183           LEAVE();
;;;1184           return (dev->errno);
00003c  68a0              LDR      r0,[r4,#8]
                  |L44.62|
;;;1185   
;;;1186   }
00003e  bd10              POP      {r4,pc}
;;;1187   
                          ENDP

                  |L44.64|
000040  534d4152          DCB      "SMARTCARD_WarmReset:: ParseATR..Error Msg:%s \n",0
000044  54434152
000048  445f5761
00004c  726d5265
000050  7365743a
000054  3a205061
000058  72736541
00005c  54522e2e
000060  4572726f
000064  72204d73
000068  673a2573
00006c  200a00  
00006f  00                DCB      0

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

                  SMARTCARD_WarmResetCmd PROC
;;;411      */
;;;412    void SMARTCARD_WarmResetCmd(S_SC_DEV_T *dev)
000000  b5f8              PUSH     {r3-r7,lr}
;;;413    {
000002  4606              MOV      r6,r0
;;;414            SC_TypeDef *SC = dev->base;
;;;415    
;;;416    #ifdef  SC_SEQ_MANUAL
;;;417            int32_t cardno = 0;
000004  6804              LDR      r4,[r0,#0]
;;;418            if(dev->base==SC0)
000006  4928              LDR      r1,|L45.168|
000008  2000              MOVS     r0,#0                 ;417
00000a  428c              CMP      r4,r1
00000c  d008              BEQ      |L45.32|
;;;419                    cardno = 0;
;;;420            else if(dev->base==SC1)
00000e  4a27              LDR      r2,|L45.172|
000010  4294              CMP      r4,r2
000012  d101              BNE      |L45.24|
;;;421                    cardno = 1;
000014  2001              MOVS     r0,#1
000016  e003              B        |L45.32|
                  |L45.24|
;;;422            else if(dev->base==SC2)
000018  4a25              LDR      r2,|L45.176|
00001a  4294              CMP      r4,r2
00001c  d100              BNE      |L45.32|
;;;423                    cardno = 2;
00001e  2002              MOVS     r0,#2
                  |L45.32|
;;;424    
;;;425            // Wait for Tx & Rx get into idle mode
;;;426            while((!(SC->TRSR & SC_TRSR_TX_EMPTY_F)) || (SC->TRSR & SC_TRSR_TX_ATV)) ;
;;;427            while((!(SC->TRSR & SC_TRSR_RX_EMPTY_F)) || (SC->TRSR & SC_TRSR_RX_ATV)) ;
;;;428            // Reset
;;;429            while(sc_device[cardno].op_state != SC_OP_NOP) ;                // wait for idle mode
000020  4924              LDR      r1,|L45.180|
                  |L45.34|
000022  6a22              LDR      r2,[r4,#0x20]         ;426
000024  0592              LSLS     r2,r2,#22             ;426
000026  d5fc              BPL      |L45.34|
000028  6a22              LDR      r2,[r4,#0x20]         ;426
00002a  2a00              CMP      r2,#0                 ;426
00002c  dbf9              BLT      |L45.34|
                  |L45.46|
00002e  6a22              LDR      r2,[r4,#0x20]         ;427
000030  0792              LSLS     r2,r2,#30             ;427
000032  d5fc              BPL      |L45.46|
000034  6a22              LDR      r2,[r4,#0x20]         ;427
000036  0212              LSLS     r2,r2,#8              ;427
000038  d4f9              BMI      |L45.46|
00003a  22e0              MOVS     r2,#0xe0
00003c  4350              MULS     r0,r2,r0
00003e  1847              ADDS     r7,r0,r1
                  |L45.64|
000040  6878              LDR      r0,[r7,#4]
000042  2800              CMP      r0,#0
000044  d1fc              BNE      |L45.64|
;;;430            SC->CTL |= SC_CTL_DIS_RX;                               // disable RX before RST falls
000046  6860              LDR      r0,[r4,#4]
000048  2502              MOVS     r5,#2
00004a  4328              ORRS     r0,r0,r5
00004c  6060              STR      r0,[r4,#4]
;;;431            SC->PINCSR &= ~SC_PINCSR_SC_RST;
00004e  6a60              LDR      r0,[r4,#0x24]
000050  43a8              BICS     r0,r0,r5
000052  6260              STR      r0,[r4,#0x24]
;;;432            sc_device[cardno].errno = 0;
000054  2000              MOVS     r0,#0
;;;433            SMARTCARD_TimerCountSet(dev, SC_TIMER1, SC_TMR_MODE_DC, (40000/(SC->ETUCR & SC_ETUCR_ETU_RDIV_MASK))+1);     // exceeds 40000 clocks
000056  60b8              STR      r0,[r7,#8]
000058  6960              LDR      r0,[r4,#0x14]
00005a  0501              LSLS     r1,r0,#20
00005c  0d09              LSRS     r1,r1,#20
00005e  4816              LDR      r0,|L45.184|
000060  f7fffffe          BL       __aeabi_uidivmod
000064  1c43              ADDS     r3,r0,#1
000066  2200              MOVS     r2,#0
000068  2110              MOVS     r1,#0x10
00006a  4630              MOV      r0,r6
00006c  f7fffffe          BL       SMARTCARD_TimerCountSet
;;;434            SMARTCARD_TimerStart(dev, SC_TIMER1);
000070  2110              MOVS     r1,#0x10
000072  4630              MOV      r0,r6
000074  f7fffffe          BL       SMARTCARD_TimerStart
000078  68b8              LDR      r0,[r7,#8]            ;429
                  |L45.122|
;;;435            while(sc_device[cardno].errno != SC_ERR_TIME1OUT && sc_device[cardno].errno != SC_ERR_CARD_REMOVED) ;
00007a  4601              MOV      r1,r0
00007c  316e              ADDS     r1,r1,#0x6e
00007e  d001              BEQ      |L45.132|
000080  310a              ADDS     r1,r1,#0xa
000082  d1fa              BNE      |L45.122|
                  |L45.132|
;;;436            SC->PINCSR |= SC_PINCSR_SC_RST;
000084  6a60              LDR      r0,[r4,#0x24]
000086  4328              ORRS     r0,r0,r5
000088  6260              STR      r0,[r4,#0x24]
;;;437            SC->CTL &= ~SC_CTL_DIS_RX;                              // enable RX after RST rises
00008a  6860              LDR      r0,[r4,#4]
00008c  43a8              BICS     r0,r0,r5
00008e  6060              STR      r0,[r4,#4]
;;;438    
;;;439            // wait 42036 clock for ATR
;;;440            SMARTCARD_TimerCountSet(dev, SC_TIMER0, SC_TMR_MODE_DC, (42000/372) + 13);
000090  237d              MOVS     r3,#0x7d
000092  2200              MOVS     r2,#0
000094  2108              MOVS     r1,#8
000096  4630              MOV      r0,r6
000098  f7fffffe          BL       SMARTCARD_TimerCountSet
;;;441            SMARTCARD_TimerStart(dev, SC_TIMER0);
00009c  2108              MOVS     r1,#8
00009e  4630              MOV      r0,r6
0000a0  f7fffffe          BL       SMARTCARD_TimerStart
;;;442    #else
;;;443            SC->ALTCTL |= SC_ALTCTL_WARST_EN;
;;;444    #endif
;;;445    }
0000a4  bdf8              POP      {r3-r7,pc}
;;;446    /**
                          ENDP

0000a6  0000              DCW      0x0000
                  |L45.168|
                          DCD      0x40190000
                  |L45.172|
                          DCD      0x401b0000
                  |L45.176|
                          DCD      0x401c0000
                  |L45.180|
                          DCD      ||.bss||+0x65c
                  |L45.184|
                          DCD      0x00009c40

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

                          REQUIRE _printf_percent
                          REQUIRE _printf_s
                          REQUIRE _printf_str
                  SMARTCARD_Write PROC
;;;1330     */
;;;1331   int32_t SMARTCARD_Write(SC_TypeDef *portno, uint8_t *buf, uint32_t len, uint8_t *outbuf, uint32_t *outlen )
000000  b5ff              PUSH     {r0-r7,lr}
;;;1332   {
000002  4604              MOV      r4,r0
;;;1333           S_SC_DEV_T *dev;
;;;1334           int32_t ret = SC_STATUS_SUCCESS, port = 0;
000004  2700              MOVS     r7,#0
;;;1335   
;;;1336           ENTER();
;;;1337   
;;;1338           assert_param(CHECK_SC_PORT(portno));
;;;1339           assert_param( len!=0 );
;;;1340   
;;;1341           if(portno==SC0)
000006  4b4c              LDR      r3,|L46.312|
000008  b081              SUB      sp,sp,#4              ;1332
00000a  4638              MOV      r0,r7                 ;1334
00000c  429c              CMP      r4,r3
00000e  d008              BEQ      |L46.34|
;;;1342                   port = 0;
;;;1343           else if(portno==SC1)
000010  494a              LDR      r1,|L46.316|
000012  428c              CMP      r4,r1
000014  d101              BNE      |L46.26|
;;;1344                   port = 1;
000016  2001              MOVS     r0,#1
000018  e003              B        |L46.34|
                  |L46.26|
;;;1345           else if(portno==SC2)
00001a  4949              LDR      r1,|L46.320|
00001c  428c              CMP      r4,r1
00001e  d100              BNE      |L46.34|
;;;1346                   port = 2;
000020  2002              MOVS     r0,#2
                  |L46.34|
;;;1347   
;;;1348           dev =  (S_SC_DEV_T *)((uint32_t)&sc_device[port]);
000022  21e0              MOVS     r1,#0xe0
000024  4348              MULS     r0,r1,r0
000026  4947              LDR      r1,|L46.324|
000028  1846              ADDS     r6,r0,r1
;;;1349   
;;;1350           if(dev->op_state)       // card busy
00002a  6870              LDR      r0,[r6,#4]
00002c  2800              CMP      r0,#0
00002e  d002              BEQ      |L46.54|
;;;1351                   return SC_EBUSY;
000030  4845              LDR      r0,|L46.328|
                  |L46.50|
;;;1352   
;;;1353           if(SMARTCARD_CheckCardPresent(portno) != SCARD_PRESENT)
;;;1354                   return SC_EIO;
;;;1355   
;;;1356           if(dev->openflag == 0)
;;;1357                   return(SC_EIO);
;;;1358   
;;;1359           if(len > MAX_BUF_LEN)
;;;1360                   len = MAX_BUF_LEN;
;;;1361   
;;;1362           // Call write means we give up data remain in dev->buf
;;;1363           dev->snd_pos = 0;
;;;1364           dev->rcv_pos = 0;
;;;1365   
;;;1366           if(portno == SC0)
;;;1367                   memset(&g_Port0_RxBUF[0], 0x00, sizeof(g_Port0_RxBUF));
;;;1368           else if(portno == SC1)
;;;1369                   memset(&g_Port1_RxBUF[0], 0x00, sizeof(g_Port1_RxBUF));
;;;1370           else if(portno == SC2)
;;;1371                   memset(&g_Port2_RxBUF[0], 0x00, sizeof(g_Port2_RxBUF));
;;;1372   
;;;1373           //      dispatch on the selected protocol
;;;1374           switch( dev->CardCapabilities.Protocol.Selected ) {
;;;1375           case SCARD_PROTOCOL_T0:
;;;1376                   ret = CBT0Transmit( dev, buf, len, outbuf, outlen );
;;;1377                   break;
;;;1378   
;;;1379           case SCARD_PROTOCOL_T1:
;;;1380                   if(portno == SC0) {
;;;1381                           memset(g_Port0_TxBUF, 0x00, sizeof(g_Port0_TxBUF));
;;;1382                           dev->snd_buf = &g_Port0_TxBUF[0];
;;;1383                           dev->rcv_buf = &g_Port0_RxBUF[0];
;;;1384                   } else if(portno == SC1) {
;;;1385                           memset(g_Port1_TxBUF, 0x00, sizeof(g_Port1_TxBUF));
;;;1386                           dev->snd_buf = &g_Port1_TxBUF[0];
;;;1387                           dev->rcv_buf = &g_Port1_RxBUF[0];
;;;1388                   } else if(portno == SC2) {
;;;1389                           memset(g_Port2_TxBUF, 0x00, sizeof(g_Port2_TxBUF));
;;;1390                           dev->snd_buf = &g_Port2_TxBUF[0];
;;;1391                           dev->rcv_buf = &g_Port2_RxBUF[0];
;;;1392                   }
;;;1393   
;;;1394                   ret = CBT1Transmit( dev, buf, len, outbuf, outlen );
;;;1395                   break;
;;;1396   
;;;1397           case SCARD_PROTOCOL_RAW:
;;;1398                   //ret = CBRawTransmit( dev, buf, len, len, outbuf, outlen);
;;;1399                   break;
;;;1400   
;;;1401           default:
;;;1402                   ret = SC_EPROTOCOL;
;;;1403                   break;
;;;1404           }
;;;1405   
;;;1406           if(ret != SC_STATUS_SUCCESS) {
;;;1407                   /* stop all */
;;;1408                   SMARTCARD_StopBlockGuardTime( dev );            // stop block guard time
;;;1409                   SMARTCARD_TimerStop(dev, (E_SC_TIMER)(SC_TIMER0 | SC_TIMER1 |SC_TIMER2));   // stop timer0-2
;;;1410                   printf("Failed to Transfer T=0..Error Msg:%s \n", SMARTCARD_ERRMSG(ret));
;;;1411           }
;;;1412   
;;;1413           LEAVE();
;;;1414   
;;;1415           return ret;
;;;1416   
;;;1417   }
000032  b005              ADD      sp,sp,#0x14
000034  bdf0              POP      {r4-r7,pc}
                  |L46.54|
000036  4620              MOV      r0,r4                 ;1353
000038  f7fffffe          BL       SMARTCARD_CheckCardPresent
00003c  4942              LDR      r1,|L46.328|
00003e  1ec9              SUBS     r1,r1,#3              ;1354
000040  2804              CMP      r0,#4                 ;1353
000042  d117              BNE      |L46.116|
000044  68f0              LDR      r0,[r6,#0xc]          ;1356
000046  2800              CMP      r0,#0                 ;1356
000048  d014              BEQ      |L46.116|
00004a  20ff              MOVS     r0,#0xff              ;1359
00004c  9903              LDR      r1,[sp,#0xc]          ;1359
00004e  30f5              ADDS     r0,r0,#0xf5           ;1359
000050  4281              CMP      r1,r0                 ;1359
000052  d900              BLS      |L46.86|
000054  9003              STR      r0,[sp,#0xc]          ;1360
                  |L46.86|
000056  4635              MOV      r5,r6                 ;1363
000058  2000              MOVS     r0,#0                 ;1363
00005a  3580              ADDS     r5,r5,#0x80           ;1363
00005c  21c0              MOVS     r1,#0xc0              ;1364
00005e  6368              STR      r0,[r5,#0x34]         ;1364
000060  5188              STR      r0,[r1,r6]            ;1364
000062  4835              LDR      r0,|L46.312|
000064  4284              CMP      r4,r0                 ;1366
000066  d107              BNE      |L46.120|
000068  21ff              MOVS     r1,#0xff              ;1367
00006a  3110              ADDS     r1,r1,#0x10           ;1367
00006c  4837              LDR      r0,|L46.332|
00006e  f7fffffe          BL       __aeabi_memclr4
000072  e010              B        |L46.150|
                  |L46.116|
000074  4608              MOV      r0,r1                 ;1357
000076  e7dc              B        |L46.50|
                  |L46.120|
000078  4830              LDR      r0,|L46.316|
00007a  4284              CMP      r4,r0                 ;1368
00007c  d103              BNE      |L46.134|
00007e  21ff              MOVS     r1,#0xff              ;1369
000080  3110              ADDS     r1,r1,#0x10           ;1369
000082  4833              LDR      r0,|L46.336|
000084  e005              B        |L46.146|
                  |L46.134|
000086  482e              LDR      r0,|L46.320|
000088  4284              CMP      r4,r0                 ;1370
00008a  d104              BNE      |L46.150|
00008c  21ff              MOVS     r1,#0xff              ;1371
00008e  3110              ADDS     r1,r1,#0x10           ;1371
000090  4830              LDR      r0,|L46.340|
                  |L46.146|
000092  f7fffffe          BL       __aeabi_memclr
                  |L46.150|
000096  68e8              LDR      r0,[r5,#0xc]          ;1374
000098  2801              CMP      r0,#1                 ;1374
00009a  d017              BEQ      |L46.204|
00009c  2802              CMP      r0,#2                 ;1374
00009e  d01d              BEQ      |L46.220|
0000a0  2101              MOVS     r1,#1                 ;1374
0000a2  0409              LSLS     r1,r1,#16             ;1374
0000a4  1a40              SUBS     r0,r0,r1              ;1374
0000a6  d00f              BEQ      |L46.200|
0000a8  4f27              LDR      r7,|L46.328|
0000aa  1cbf              ADDS     r7,r7,#2              ;1402
                  |L46.172|
0000ac  4630              MOV      r0,r6                 ;1408
0000ae  f7fffffe          BL       SMARTCARD_StopBlockGuardTime
0000b2  2138              MOVS     r1,#0x38              ;1409
0000b4  4630              MOV      r0,r6                 ;1409
0000b6  f7fffffe          BL       SMARTCARD_TimerStop
0000ba  4638              MOV      r0,r7                 ;1410
0000bc  f7fffffe          BL       SMARTCARD_ERRMSG
0000c0  4601              MOV      r1,r0                 ;1410
0000c2  a025              ADR      r0,|L46.344|
0000c4  f7fffffe          BL       __2printf
                  |L46.200|
0000c8  4638              MOV      r0,r7                 ;1415
0000ca  e7b2              B        |L46.50|
                  |L46.204|
0000cc  980a              LDR      r0,[sp,#0x28]         ;1376
0000ce  9000              STR      r0,[sp,#0]            ;1376
0000d0  a902              ADD      r1,sp,#8              ;1376
0000d2  c90e              LDM      r1,{r1-r3}            ;1376
0000d4  4630              MOV      r0,r6                 ;1376
0000d6  f7fffffe          BL       CBT0Transmit
0000da  e02a              B        |L46.306|
                  |L46.220|
0000dc  4816              LDR      r0,|L46.312|
0000de  4284              CMP      r4,r0                 ;1380
0000e0  d108              BNE      |L46.244|
0000e2  21ff              MOVS     r1,#0xff              ;1381
0000e4  3110              ADDS     r1,r1,#0x10           ;1381
0000e6  4826              LDR      r0,|L46.384|
0000e8  f7fffffe          BL       __aeabi_memclr
0000ec  4824              LDR      r0,|L46.384|
0000ee  62e8              STR      r0,[r5,#0x2c]         ;1383
0000f0  4816              LDR      r0,|L46.332|
0000f2  e016              B        |L46.290|
                  |L46.244|
0000f4  4811              LDR      r0,|L46.316|
0000f6  4284              CMP      r4,r0                 ;1384
0000f8  d108              BNE      |L46.268|
0000fa  21ff              MOVS     r1,#0xff              ;1385
0000fc  3110              ADDS     r1,r1,#0x10           ;1385
0000fe  4821              LDR      r0,|L46.388|
000100  f7fffffe          BL       __aeabi_memclr4
000104  481f              LDR      r0,|L46.388|
000106  62e8              STR      r0,[r5,#0x2c]         ;1387
000108  4811              LDR      r0,|L46.336|
00010a  e00a              B        |L46.290|
                  |L46.268|
00010c  480c              LDR      r0,|L46.320|
00010e  4284              CMP      r4,r0                 ;1388
000110  d108              BNE      |L46.292|
000112  21ff              MOVS     r1,#0xff              ;1389
000114  3110              ADDS     r1,r1,#0x10           ;1389
000116  481c              LDR      r0,|L46.392|
000118  f7fffffe          BL       __aeabi_memclr
00011c  481a              LDR      r0,|L46.392|
00011e  62e8              STR      r0,[r5,#0x2c]         ;1391
000120  480c              LDR      r0,|L46.340|
                  |L46.290|
000122  6328              STR      r0,[r5,#0x30]         ;1391
                  |L46.292|
000124  980a              LDR      r0,[sp,#0x28]         ;1394
000126  9000              STR      r0,[sp,#0]            ;1394
000128  a902              ADD      r1,sp,#8              ;1394
00012a  c90e              LDM      r1,{r1-r3}            ;1394
00012c  4630              MOV      r0,r6                 ;1394
00012e  f7fffffe          BL       CBT1Transmit
                  |L46.306|
000132  0007              MOVS     r7,r0                 ;1376
000134  d1ba              BNE      |L46.172|
000136  e7c7              B        |L46.200|
;;;1418   
                          ENDP

                  |L46.312|
                          DCD      0x40190000
                  |L46.316|
                          DCD      0x401b0000
                  |L46.320|
                          DCD      0x401c0000
                  |L46.324|
                          DCD      ||.bss||+0x65c
                  |L46.328|
                          DCD      0xffff2004
                  |L46.332|
                          DCD      ||.bss||
                  |L46.336|
                          DCD      ||.bss||+0x10f
                  |L46.340|
                          DCD      ||.bss||+0x21e
                  |L46.344|
000158  4661696c          DCB      "Failed to Transfer T=0..Error Msg:%s \n",0
00015c  65642074
000160  6f205472
000164  616e7366
000168  65722054
00016c  3d302e2e
000170  4572726f
000174  72204d73
000178  673a2573
00017c  200a00  
00017f  00                DCB      0
                  |L46.384|
                          DCD      ||.bss||+0x32d
                  |L46.388|
                          DCD      ||.bss||+0x43c
                  |L46.392|
                          DCD      ||.bss||+0x54b

                          AREA ||.bss||, DATA, NOINIT, ALIGN=2

                  g_Port0_RxBUF
                          %        271
                  g_Port1_RxBUF
                          %        271
                  g_Port2_RxBUF
                          %        271
                  g_Port0_TxBUF
                          %        271
                  g_Port1_TxBUF
                          %        271
                  g_Port2_TxBUF
                          %        273
                  sc_device
                          %        672

                          AREA ||area_number.49||, DATA, NOINIT, ALIGN=0

                          EXPORTAS ||area_number.49||, ||.bss||
                  g_SC0UnexpectedInBuf
                          %        271

                          AREA ||area_number.50||, DATA, NOINIT, ALIGN=0

                          EXPORTAS ||area_number.50||, ||.bss||
                  g_SC1UnexpectedInBuf
                          %        271

                          AREA ||area_number.51||, DATA, NOINIT, ALIGN=0

                          EXPORTAS ||area_number.51||, ||.bss||
                  g_SC2UnexpectedInBuf
                          %        271

                          AREA ||.constdata||, DATA, READONLY, ALIGN=0

                  __func__
000000  534d4152          DCB      0x53,0x4d,0x41,0x52
000004  54434152          DCB      0x54,0x43,0x41,0x52
000008  445f496e          DCB      0x44,0x5f,0x49,0x6e
00000c  697400            DCB      0x69,0x74,0x00

                          AREA ||.data||, DATA, ALIGN=2

                  atr_len0
                          DCD      0x00000000
                  atr_remain0
                          DCD      0x00000002
                  ifbyte_flag0
                          DCD      0xffffffff
                  tck0
                          DCD      0x00000000
                  ifcount0
                          DCD      0x00000000
                  atr_len1
                          DCD      0x00000000
                  atr_remain1
                          DCD      0x00000002
                  ifbyte_flag1
                          DCD      0xffffffff
                  tck1
                          DCD      0x00000000
                  ifcount1
                          DCD      0x00000000
                  atr_len2
                          DCD      0x00000000
                  atr_remain2
                          DCD      0x00000002
                  ifbyte_flag2
                          DCD      0xffffffff
                  tck2
                          DCD      0x00000000
                  ifcount2
                          DCD      0x00000000
                  atr_time0
                          DCD      0x00004e52
                  atr_time1
                          DCD      0x00004e52
                  atr_time2
                          DCD      0x00004e52
                  atr_check_time0
                          DCD      0x00000000
                  atr_check_time1
                          DCD      0x00000000
                  atr_check_time2
                          DCD      0x00000000
                  atr_total_time_start_flag0
                          DCD      0x00000000
                  atr_total_time_start_flag1
                          DCD      0x00000000
                  atr_total_time_start_flag2
                          DCD      0x00000000
                  atr_final_chk0
                          DCD      0x00000000
                  atr_final_chk1
                          DCD      0x00000000
                  atr_final_chk2
                          DCD      0x00000000
                  g_SC0ETUDivider
                          DCD      0x00000174
                  g_SC1ETUDivider
                          DCD      0x00000174
                  g_SC2ETUDivider
                          DCD      0x00000174
                  ClockRateConversion
                          DCD      0x00000174
                          DCD      0x003d0900
                          DCD      0x00000174
                          DCD      0x004c4b40
                          DCD      0x0000022e
                          DCD      0x005b8d80
                          DCD      0x000002e8
                          DCD      0x007a1200
                          DCD      0x0000045c
                          DCD      0x00b71b00
                          DCD      0x000005d0
                          DCD      0x00f42400
                          DCD      0x00000744
                          DCD      0x01312d00
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000200
                          DCD      0x004c4b40
                          DCD      0x00000300
                          DCD      0x007270e0
                          DCD      0x00000400
                          DCD      0x00989680
                          DCD      0x00000600
                          DCD      0x00e4e1c0
                          DCD      0x00000800
                          DCD      0x01312d00
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                  BitRateAdjustment
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000001
                          DCD      0x00000001
                          DCD      0x00000002
                          DCD      0x00000001
                          DCD      0x00000004
                          DCD      0x00000001
                          DCD      0x00000008
                          DCD      0x00000001
                          DCD      0x00000010
                          DCD      0x00000001
                          DCD      0x00000020
                          DCD      0x00000001
                          DCD      0x00000040
                          DCD      0x00000001
                          DCD      0x0000000c
                          DCD      0x00000001
                          DCD      0x00000014
                          DCD      0x00000001
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000

                          AREA ||area_number.55||, DATA, ALIGN=0

                          EXPORTAS ||area_number.55||, ||.data||
                  g_SC0UnexpectedBufLen
000000  00                DCB      0x00

                          AREA ||area_number.56||, DATA, ALIGN=0

                          EXPORTAS ||area_number.56||, ||.data||
                  g_SC1UnexpectedBufLen
000000  00                DCB      0x00

                          AREA ||area_number.57||, DATA, ALIGN=0

                          EXPORTAS ||area_number.57||, ||.data||
                  g_SC2UnexpectedBufLen
000000  00                DCB      0x00

;*** Start embedded assembler ***

#line 1 "..\\bsp\\Driver\\nano1xx_smartcard.c"
	AREA ||.rev16_text||, CODE, READONLY
	THUMB
	EXPORT |__asm___19_nano1xx_smartcard_c_atr_len0____REV16|
#line 115 "C:\\Keil\\ARM\\CMSIS\\Include\\core_cmInstr.h"
|__asm___19_nano1xx_smartcard_c_atr_len0____REV16| PROC
#line 116

 rev16 r0, r0
 bx lr
	ENDP
	AREA ||.revsh_text||, CODE, READONLY
	THUMB
	EXPORT |__asm___19_nano1xx_smartcard_c_atr_len0____REVSH|
#line 130
|__asm___19_nano1xx_smartcard_c_atr_len0____REVSH| PROC
#line 131

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
