; generated by Component: ARM Compiler 5.06 update 6 (build 750) Tool: ArmCC [4d3637]
; commandline ArmCC [--c99 --list --split_sections --debug -c --asm --interleave --gnu -o.\objects\app_tp_transfer.o --asm_dir=.\Listings\ --list_dir=.\Listings\ --depend=.\objects\app_tp_transfer.d --cpu=Cortex-M0 --apcs=interwork -O0 --diag_suppress=9931 -I..\..\src -I..\..\src\board -I..\..\src\common -I..\..\src\sdk\include -I..\..\src\app\demo -I..\..\src\sdk\include\M0 -I..\..\src\app -I..\..\src\app\module_demo -I..\..\src\app\touch -I..\..\src\app\S8 -I..\..\src\app\S9 -I..\CVWL368 -I..\..\src\app\ap_demo -I.\RTE\_ISP_368 -IC:\Keil_v5\ARM\PACK\ARM\CMSIS\5.5.1\CMSIS\Core\Include -IC:\Keil_v5\ARM\PACK\ARM\CMSIS\5.5.1\Device\ARM\ARMCM0\Include -D__MICROLIB -D__UVISION_VERSION=528 -D_RTE_ -DARMCM0 -DISP_368 --omf_browse=.\objects\app_tp_transfer.crf ..\..\src\app\ap_demo\app_tp_transfer.c]
                          THUMB

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

                  ap_tp_scan_point_init PROC
;;;725    
;;;726    void ap_tp_scan_point_init(void)
000000  2000              MOVS     r0,#0
;;;727    {
;;;728    	uint8_t i=0;
;;;729    	
;;;730    	for(i=0;i<ST_TP_SCAN_POINT_NUMBER_MAX;i++)
000002  bf00              NOP      
000004  e004              B        |L1.16|
                  |L1.6|
;;;731    	tp_scan_data.tp_point_buffer[i] = 0;
000006  2100              MOVS     r1,#0
000008  4a05              LDR      r2,|L1.32|
00000a  5411              STRB     r1,[r2,r0]
00000c  1c41              ADDS     r1,r0,#1              ;730
00000e  b2c8              UXTB     r0,r1                 ;730
                  |L1.16|
000010  2806              CMP      r0,#6                 ;730
000012  dbf8              BLT      |L1.6|
;;;732    	tp_scan_data.tp_point_up_error_flag = 0;
000014  2100              MOVS     r1,#0
000016  4a02              LDR      r2,|L1.32|
000018  71d1              STRB     r1,[r2,#7]
;;;733    	tp_scan_data.tp_read_point_counter = 0;
00001a  7191              STRB     r1,[r2,#6]
;;;734    	tp_scan_data.tp_point_error_time_counter = 0;
00001c  6091              STR      r1,[r2,#8]  ; tp_scan_data
;;;735    }
00001e  4770              BX       lr
;;;736    
                          ENDP

                  |L1.32|
                          DCD      tp_scan_data

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

                          REQUIRE _printf_pre_padding
                          REQUIRE _printf_percent
                          REQUIRE _printf_widthprec
                          REQUIRE _printf_d
                          REQUIRE _printf_int_dec
                  ap_tp_scan_point_record_event_exec PROC
;;;736    
;;;737    void ap_tp_scan_point_record_event_exec(void)
000000  b510              PUSH     {r4,lr}
;;;738    {
;;;739    	if(tp_scan_data.tp_point_up_error_flag == 1)
000002  480f              LDR      r0,|L2.64|
000004  79c0              LDRB     r0,[r0,#7]  ; tp_scan_data
000006  2801              CMP      r0,#1
000008  d118              BNE      |L2.60|
;;;740    	{
;;;741    		if(tp_scan_data.tp_point_error_time_counter < (65536/10))  // 65536*3 = 900ms  65536/10 = 30ms
00000a  480d              LDR      r0,|L2.64|
00000c  6880              LDR      r0,[r0,#8]  ; tp_scan_data
00000e  490d              LDR      r1,|L2.68|
000010  4288              CMP      r0,r1
000012  d205              BCS      |L2.32|
;;;742    		{
;;;743    	        tp_scan_data.tp_point_error_time_counter ++;
000014  480a              LDR      r0,|L2.64|
000016  6880              LDR      r0,[r0,#8]  ; tp_scan_data
000018  1c40              ADDS     r0,r0,#1
00001a  4909              LDR      r1,|L2.64|
00001c  6088              STR      r0,[r1,#8]  ; tp_scan_data
00001e  e00d              B        |L2.60|
                  |L2.32|
;;;744    	    }
;;;745    		else	// 没有收到move 或者release 时间超时
;;;746    		{
;;;747    //			tp_scan_data.tp_point_up_error_flag = 0;
;;;748    //			tp_scan_data.tp_point_error_time_counter = 0;
;;;749    			if(tp_scan_data.tp_read_point_counter>0)	// 有残留点
000020  4807              LDR      r0,|L2.64|
000022  7980              LDRB     r0,[r0,#6]  ; tp_scan_data
000024  2800              CMP      r0,#0
000026  dd07              BLE      |L2.56|
;;;750    			{
;;;751    				printf("release finger %2d\n",tp_scan_data.tp_read_point_counter);
000028  4805              LDR      r0,|L2.64|
00002a  7981              LDRB     r1,[r0,#6]  ; tp_scan_data
00002c  a006              ADR      r0,|L2.72|
00002e  f7fffffe          BL       __2printf
;;;752    		        tp_scan_data.tp_read_point_counter = 0;
000032  2000              MOVS     r0,#0
000034  4902              LDR      r1,|L2.64|
000036  7188              STRB     r0,[r1,#6]
                  |L2.56|
;;;753    	//			ap_tp_simulate_finger_release_event();
;;;754    			}
;;;755    
;;;756    			ap_tp_scan_point_init();
000038  f7fffffe          BL       ap_tp_scan_point_init
                  |L2.60|
;;;757    	    }
;;;758    	}
;;;759    	
;;;760    }
00003c  bd10              POP      {r4,pc}
;;;761    
                          ENDP

00003e  0000              DCW      0x0000
                  |L2.64|
                          DCD      tp_scan_data
                  |L2.68|
                          DCD      0x00001999
                  |L2.72|
000048  72656c65          DCB      "release finger %2d\n",0
00004c  61736520
000050  66696e67
000054  65722025
000058  32640a00

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

                  app_tp_i2cs_callback PROC
;;;337    #if PHONE_SLAVE_TRANSFER_I2C                //消除warning
;;;338    static void app_tp_i2cs_callback(e_i2c_s_int_status int_status, size_t recieve_num)
000000  b570              PUSH     {r4-r6,lr}
;;;339    {
000002  4604              MOV      r4,r0
000004  460d              MOV      r5,r1
;;;340        static bool i2cs_transfer = true;       //确保一次通信只解析一次
;;;341        if (i2cs_transfer)
000006  480c              LDR      r0,|L3.56|
000008  7800              LDRB     r0,[r0,#0]  ; i2cs_transfer
00000a  2800              CMP      r0,#0
00000c  d005              BEQ      |L3.26|
;;;342        {
;;;343            i2cs_transfer = false;
00000e  2000              MOVS     r0,#0
000010  4909              LDR      r1,|L3.56|
000012  7008              STRB     r0,[r1,#0]
;;;344            app_tp_transfer_phone(recieve_num);
000014  4628              MOV      r0,r5
000016  f7fffffe          BL       app_tp_transfer_phone
                  |L3.26|
;;;345        }
;;;346        if (int_status == I2C_S_INT_READ)
00001a  2c00              CMP      r4,#0
00001c  d106              BNE      |L3.44|
;;;347        {
;;;348            app_tp_s_write(s_slave_txbuffer, s_slave_txbuffer_size);
00001e  4807              LDR      r0,|L3.60|
000020  6801              LDR      r1,[r0,#0]  ; s_slave_txbuffer_size
000022  4807              LDR      r0,|L3.64|
000024  6800              LDR      r0,[r0,#0]  ; s_slave_txbuffer
000026  f7fffffe          BL       app_tp_s_write
00002a  e004              B        |L3.54|
                  |L3.44|
;;;349        }
;;;350        else if (int_status == I2C_S_INT_STOP)
00002c  2c02              CMP      r4,#2
00002e  d102              BNE      |L3.54|
;;;351        {
;;;352            i2cs_transfer = true;
000030  2001              MOVS     r0,#1
000032  4901              LDR      r1,|L3.56|
000034  7008              STRB     r0,[r1,#0]
                  |L3.54|
;;;353        }
;;;354    }
000036  bd70              POP      {r4-r6,pc}
;;;355    #endif
                          ENDP

                  |L3.56|
                          DCD      i2cs_transfer
                  |L3.60|
                          DCD      s_slave_txbuffer_size
                  |L3.64|
                          DCD      s_slave_txbuffer

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

                  app_tp_init PROC
;;;142    **************************************************************************/
;;;143    void app_tp_init(void)
000000  b510              PUSH     {r4,lr}
;;;144    {
;;;145    #ifdef ADD_MCU_BD826
;;;146    	hal_gpio_init_output(IO_PAD_TD_SPIM_MOSI, IO_LVL_HIGH); 	   //初始化TP_reset,并将其拉高	
;;;147    	hal_gpio_init_input(IO_PAD_TD_SPIM_MISO);		
;;;148    #endif
;;;149    
;;;150    #ifdef DISABLE_TDDI_I2C_FUNCTION
;;;151    	hal_gpio_set_mode(IO_PAD_TD_SPIM_CLK,IO_MODE_I2C1_SCL);
;;;152    	hal_gpio_set_mode(IO_PAD_TD_SPIM_CSN,IO_MODE_I2C1_SDA);
;;;153    
;;;154    	return;
;;;155    #else	
;;;156    	hal_gpio_set_pull_state(IO_PAD_TD_SPIM_CLK, ENABLE, DISABLE);
000002  2200              MOVS     r2,#0
000004  2101              MOVS     r1,#1
000006  2018              MOVS     r0,#0x18
000008  f7fffffe          BL       hal_gpio_set_pull_state
;;;157    	hal_gpio_set_pull_state(IO_PAD_TD_SPIM_CSN, ENABLE, DISABLE);	
00000c  2200              MOVS     r2,#0
00000e  2101              MOVS     r1,#1
000010  2019              MOVS     r0,#0x19
000012  f7fffffe          BL       hal_gpio_set_pull_state
;;;158    #endif
;;;159    
;;;160        //app_tp_phone_reset_init();                                        //初始化手机复位的IO口
;;;161        app_tp_screen_int_init();                                         //配置screen中断输入引脚
000016  f7fffffe          BL       app_tp_screen_int_init
;;;162    #ifdef G_PHONE_INT_DEFAULT_LOW
;;;163    	hal_gpio_init_output(g_phone_output_int_pad, IO_LVL_LOW);	  //配置phone报点输出中断IO口
;;;164    #else
;;;165        hal_gpio_init_output(g_phone_output_int_pad, IO_LVL_HIGH);    //配置phone报点输出中断IO口
00001a  2101              MOVS     r1,#1
00001c  480c              LDR      r0,|L4.80|
00001e  7800              LDRB     r0,[r0,#0]  ; g_phone_output_int_pad
000020  f7fffffe          BL       hal_gpio_init_output
;;;166    #endif 
;;;167        hal_gpio_init_output(g_screen_input_rst_pad, IO_LVL_HIGH);	 //配置模组TP RESET
000024  2101              MOVS     r1,#1
000026  480b              LDR      r0,|L4.84|
000028  7800              LDRB     r0,[r0,#0]  ; g_screen_input_rst_pad
00002a  f7fffffe          BL       hal_gpio_init_output
;;;168    
;;;169    #if SCREEN_MASTER_TRANSFER_I2C
;;;170        hal_i2c_m_dma_init(SCREEN_I2C_ADDRESS, SCREEN_I2C_ADDR_BITS, I2C_MASTER_SPEED);
00002e  4a0a              LDR      r2,|L4.88|
000030  2107              MOVS     r1,#7
000032  2038              MOVS     r0,#0x38
000034  f7fffffe          BL       hal_i2c_m_dma_init
;;;171    #elif SCREEN_MASTER_TRANSFER_SPI
;;;172        hal_spi_m_dma_init(SPI_MASTER_SPEED, SCREEN_SPI_CPHA, SCREEN_SPI_CPOL);
;;;173    #endif
;;;174    
;;;175    #if PHONE_SLAVE_TRANSFER_I2C
;;;176        hal_i2c_s_init(CHIP_I2C_ADDRESS, CHIP_I2C_ADDR_BITS);
000038  2107              MOVS     r1,#7
00003a  2049              MOVS     r0,#0x49
00003c  f7fffffe          BL       hal_i2c_s_init
;;;177        hal_i2c_s_set_transfer(app_tp_i2cs_callback);
000040  4806              LDR      r0,|L4.92|
000042  f7fffffe          BL       hal_i2c_s_set_transfer
;;;178        hal_i2c_s_nonblocking_read(s_phone_read_buffer, BUFFER_SIZE_MAX); //先配置接收 buffer
000046  21c8              MOVS     r1,#0xc8
000048  4805              LDR      r0,|L4.96|
00004a  f7fffffe          BL       hal_i2c_s_nonblocking_read
;;;179    #elif PHONE_SLAVE_TRANSFER_SPI
;;;180        hal_spi_slave_init(PHONE_SPI_CPHA, PHONE_SPI_CPOL, true);                                   // 初始化spi以及dma
;;;181        hal_spi_slave_register_callback(app_tp_spis_callback);            // 注册回调
;;;182        hal_spi_slave_auto_transfer_abort();                              // 停止传输
;;;183        hal_spi_slave_flush_fifo();                                       // Flush FIFO
;;;184    
;;;185        /* 每个packet自动接收, circle       mode 为false, 即收到buffer     max size数据后buffer不再更新, packet完成后调用回调    */
;;;186        hal_spi_slave_set_auto_rx_buffer(s_phone_read_buffer, BUFFER_SIZE_MAX, false); // 设置auto   rx buffer
;;;187        hal_spi_slave_set_auto_tx_buffer(phone_reg_const_data[0].write_back, phone_reg_const_data[0].write_back_size, false);   // 配置TX BUFFER
;;;188    
;;;189        hal_spi_slave_enable();                                           // 启动spis
;;;190        hal_spi_slave_auto_transfer_start();                              // 启动rx自动接收
;;;191    #endif
;;;192    
;;;193    }
00004e  bd10              POP      {r4,pc}
;;;194    
                          ENDP

                  |L4.80|
                          DCD      g_phone_output_int_pad
                  |L4.84|
                          DCD      g_screen_input_rst_pad
                  |L4.88|
                          DCD      0x00061a80
                  |L4.92|
                          DCD      app_tp_i2cs_callback
                  |L4.96|
                          DCD      s_phone_read_buffer

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

                  app_tp_m_read PROC
;;;258    **************************************************************************/
;;;259    static void app_tp_m_read(const uint8_t *cmd, size_t cmd_size, uint8_t *data_buffer, size_t data_size)
000000  b5ff              PUSH     {r0-r7,lr}
;;;260    {
000002  b081              SUB      sp,sp,#4
000004  4605              MOV      r5,r0
000006  460e              MOV      r6,r1
;;;261    #if SCREEN_MASTER_TRANSFER_I2C
;;;262        uint8_t i = 0;
000008  2400              MOVS     r4,#0
;;;263        uint32_t address = 0;
00000a  2700              MOVS     r7,#0
;;;264    
;;;265        for (i = 0; i < cmd_size; i++)                          //先将要发送的数据整合到 address
00000c  bf00              NOP      
00000e  e005              B        |L5.28|
                  |L5.16|
;;;266        {
;;;267            address |= (uint32_t)cmd[i] << i * 8;
000010  5d28              LDRB     r0,[r5,r4]
000012  00e1              LSLS     r1,r4,#3
000014  4088              LSLS     r0,r0,r1
000016  4307              ORRS     r7,r7,r0
000018  1c60              ADDS     r0,r4,#1              ;265
00001a  b2c4              UXTB     r4,r0                 ;265
                  |L5.28|
00001c  42b4              CMP      r4,r6                 ;265
00001e  d3f7              BCC      |L5.16|
;;;268        }
;;;269        hal_i2c_m_dma_read(address, cmd_size, data_buffer, data_size);
000020  4631              MOV      r1,r6
000022  4638              MOV      r0,r7
000024  9b04              LDR      r3,[sp,#0x10]
000026  9a03              LDR      r2,[sp,#0xc]
000028  f7fffffe          BL       hal_i2c_m_dma_read
;;;270    #elif SCREEN_MASTER_TRANSFER_SPI
;;;271        hal_spi_m_dma_read(cmd, cmd_size, data_buffer, data_size);
;;;272    #endif
;;;273    }
00002c  b005              ADD      sp,sp,#0x14
00002e  bdf0              POP      {r4-r7,pc}
;;;274    
                          ENDP


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

                  app_tp_m_transfer_complate PROC
;;;201    **************************************************************************/
;;;202    bool app_tp_m_transfer_complate(void)
000000  b510              PUSH     {r4,lr}
;;;203    {
;;;204    #if SCREEN_MASTER_TRANSFER_I2C
;;;205        return hal_i2c_m_transfer_complate();
000002  f7fffffe          BL       hal_i2c_m_transfer_complate
;;;206    #elif SCREEN_MASTER_TRANSFER_SPI
;;;207        return hal_spi_m_get_transfer_complate();
;;;208    #else
;;;209        return true;
;;;210    #endif
;;;211    }
000006  bd10              POP      {r4,pc}
;;;212    
                          ENDP


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

                  app_tp_m_write PROC
;;;238    **************************************************************************/
;;;239    static void app_tp_m_write(const uint8_t *txbuffer, size_t buffer_size)
000000  b570              PUSH     {r4-r6,lr}
;;;240    {
000002  4604              MOV      r4,r0
000004  460d              MOV      r5,r1
;;;241    #if SCREEN_MASTER_TRANSFER_I2C
;;;242        hal_i2c_m_dma_write(txbuffer, buffer_size);
000006  4629              MOV      r1,r5
000008  4620              MOV      r0,r4
00000a  f7fffffe          BL       hal_i2c_m_dma_write
;;;243    #elif SCREEN_MASTER_TRANSFER_SPI
;;;244        hal_spi_m_dma_write(txbuffer, buffer_size);
;;;245        s_spim_write = true;
;;;246    #endif
;;;247    }
00000e  bd70              POP      {r4-r6,pc}
;;;248    
                          ENDP


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

                  app_tp_phone_clear_reset_on PROC
;;;781    **************************************************************************/
;;;782    void app_tp_phone_clear_reset_on(void)
000000  2000              MOVS     r0,#0
;;;783    {
;;;784        s_phone_reset_flag = false;
000002  4901              LDR      r1,|L8.8|
000004  7008              STRB     r0,[r1,#0]
;;;785    }
000006  4770              BX       lr
;;;786    
                          ENDP

                  |L8.8|
                          DCD      s_phone_reset_flag

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

                  app_tp_phone_reset_on PROC
;;;769    **************************************************************************/
;;;770    bool app_tp_phone_reset_on(void)
000000  4801              LDR      r0,|L9.8|
;;;771    {
;;;772        return s_phone_reset_flag;
000002  7800              LDRB     r0,[r0,#0]  ; s_phone_reset_flag
;;;773    }
000004  4770              BX       lr
;;;774    
                          ENDP

000006  0000              DCW      0x0000
                  |L9.8|
                          DCD      s_phone_reset_flag

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

                  app_tp_s_read PROC
;;;303    **************************************************************************/
;;;304    void app_tp_s_read(void *rxBuffer, size_t data_size)
000000  b570              PUSH     {r4-r6,lr}
;;;305    {
000002  4604              MOV      r4,r0
000004  460d              MOV      r5,r1
;;;306    #if PHONE_SLAVE_TRANSFER_I2C
;;;307        hal_i2c_s_nonblocking_read(rxBuffer, data_size);
000006  4629              MOV      r1,r5
000008  4620              MOV      r0,r4
00000a  f7fffffe          BL       hal_i2c_s_nonblocking_read
;;;308    #endif
;;;309    }
00000e  bd70              POP      {r4-r6,pc}
;;;310    
                          ENDP


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

                  app_tp_s_transfer_complate PROC
;;;219    **************************************************************************/
;;;220    bool app_tp_s_transfer_complate(void)
000000  b510              PUSH     {r4,lr}
;;;221    {
;;;222    #if SCREEN_MASTER_TRANSFER_I2C
;;;223        return hal_i2c_s_write_complate() && hal_i2c_s_read_complate();
000002  f7fffffe          BL       hal_i2c_s_write_complate
000006  2800              CMP      r0,#0
000008  d005              BEQ      |L11.22|
00000a  f7fffffe          BL       hal_i2c_s_read_complate
00000e  2800              CMP      r0,#0
000010  d001              BEQ      |L11.22|
000012  2001              MOVS     r0,#1
                  |L11.20|
;;;224    #elif SCREEN_MASTER_TRANSFER_SPI
;;;225        return !hal_spi_slave_busy();
;;;226    #else
;;;227        return true;
;;;228    #endif
;;;229    }
000014  bd10              POP      {r4,pc}
                  |L11.22|
000016  2000              MOVS     r0,#0                 ;223
000018  e7fc              B        |L11.20|
;;;230    
                          ENDP


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

                  app_tp_s_write PROC
;;;282    **************************************************************************/
;;;283    void app_tp_s_write(const uint8_t *txbuffer, size_t buffer_size)
000000  b570              PUSH     {r4-r6,lr}
;;;284    {
000002  4604              MOV      r4,r0
000004  460d              MOV      r5,r1
;;;285    #if PHONE_SLAVE_TRANSFER_I2C
;;;286        hal_i2c_s_dma_write(txbuffer, buffer_size);
000006  4629              MOV      r1,r5
000008  4620              MOV      r0,r4
00000a  f7fffffe          BL       hal_i2c_s_dma_write
;;;287    #elif PHONE_SLAVE_TRANSFER_SPI
;;;288        //while (hal_spi_slave_busy());
;;;289        hal_spi_slave_auto_transfer_abort();
;;;290        hal_spi_slave_flush_fifo();
;;;291        hal_spi_slave_set_auto_tx_buffer(txbuffer, buffer_size, true);
;;;292        hal_spi_slave_auto_transfer_start();
;;;293    #endif
;;;294    }
00000e  bd70              POP      {r4-r6,pc}
;;;295    
                          ENDP


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

                  app_tp_screen_init PROC
;;;126    **************************************************************************/
;;;127    void app_tp_screen_init(void)
000000  b510              PUSH     {r4,lr}
;;;128    {
;;;129        hal_gpio_init_output(g_screen_input_rst_pad, IO_LVL_HIGH);
000002  2101              MOVS     r1,#1
000004  480a              LDR      r0,|L13.48|
000006  7800              LDRB     r0,[r0,#0]  ; g_screen_input_rst_pad
000008  f7fffffe          BL       hal_gpio_init_output
;;;130        delayUs(200);
00000c  20c8              MOVS     r0,#0xc8
00000e  f7fffffe          BL       delayUs
;;;131        hal_gpio_set_output_data(g_screen_input_rst_pad, IO_LVL_LOW);
000012  2100              MOVS     r1,#0
000014  4806              LDR      r0,|L13.48|
000016  7800              LDRB     r0,[r0,#0]  ; g_screen_input_rst_pad
000018  f7fffffe          BL       hal_gpio_set_output_data
;;;132        delayUs(200);
00001c  20c8              MOVS     r0,#0xc8
00001e  f7fffffe          BL       delayUs
;;;133        hal_gpio_set_output_data(g_screen_input_rst_pad, IO_LVL_HIGH);
000022  2101              MOVS     r1,#1
000024  4802              LDR      r0,|L13.48|
000026  7800              LDRB     r0,[r0,#0]  ; g_screen_input_rst_pad
000028  f7fffffe          BL       hal_gpio_set_output_data
;;;134    }
00002c  bd10              POP      {r4,pc}
;;;135    
                          ENDP

00002e  0000              DCW      0x0000
                  |L13.48|
                          DCD      g_screen_input_rst_pad

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

                  app_tp_screen_int_callback PROC
;;;57     **************************************************************************/
;;;58     static void app_tp_screen_int_callback(void *data)
000000  2101              MOVS     r1,#1
;;;59     {
;;;60         s_screen_int_flag = true;
000002  4a01              LDR      r2,|L14.8|
000004  7011              STRB     r1,[r2,#0]
;;;61     }
000006  4770              BX       lr
;;;62     
                          ENDP

                  |L14.8|
                          DCD      s_screen_int_flag

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

                  app_tp_screen_int_init PROC
;;;87     **************************************************************************/
;;;88     static void app_tp_screen_int_init(void)
000000  b510              PUSH     {r4,lr}
;;;89     {
;;;90         hal_gpio_set_pull_state(g_screen_input_int_pad, ENABLE, DISABLE);         // 1.配置上拉
000002  2200              MOVS     r2,#0
000004  2101              MOVS     r1,#1
000006  480c              LDR      r0,|L15.56|
000008  7800              LDRB     r0,[r0,#0]  ; g_screen_input_int_pad
00000a  f7fffffe          BL       hal_gpio_set_pull_state
;;;91         hal_gpio_ctrl_eint(g_screen_input_int_pad, DISABLE);                      // 2.关闭中断
00000e  2100              MOVS     r1,#0
000010  4809              LDR      r0,|L15.56|
000012  7800              LDRB     r0,[r0,#0]  ; g_screen_input_int_pad
000014  f7fffffe          BL       hal_gpio_ctrl_eint
;;;92         hal_gpio_init_eint(g_screen_input_int_pad, DETECT_FALLING_EDGE);          // 3.中断初始化,TP一般都是下降沿触发中断
000018  2103              MOVS     r1,#3
00001a  4807              LDR      r0,|L15.56|
00001c  7800              LDRB     r0,[r0,#0]  ; g_screen_input_int_pad
00001e  f7fffffe          BL       hal_gpio_init_eint
;;;93         hal_gpio_reg_eint_cb(g_screen_input_int_pad, app_tp_screen_int_callback); // 4.注册回调
000022  4906              LDR      r1,|L15.60|
000024  4804              LDR      r0,|L15.56|
000026  7800              LDRB     r0,[r0,#0]  ; g_screen_input_int_pad
000028  f7fffffe          BL       hal_gpio_reg_eint_cb
;;;94         hal_gpio_ctrl_eint(g_screen_input_int_pad, ENABLE);                       // 5.使能中断
00002c  2101              MOVS     r1,#1
00002e  4802              LDR      r0,|L15.56|
000030  7800              LDRB     r0,[r0,#0]  ; g_screen_input_int_pad
000032  f7fffffe          BL       hal_gpio_ctrl_eint
;;;95     }
000036  bd10              POP      {r4,pc}
;;;96     
                          ENDP

                  |L15.56|
                          DCD      g_screen_input_int_pad
                  |L15.60|
                          DCD      app_tp_screen_int_callback

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

                  app_tp_screen_int_lvl_low PROC
;;;69     **************************************************************************/
;;;70     static bool app_tp_screen_int_lvl_low(void)
000000  2000              MOVS     r0,#0
;;;71     {
;;;72     #if SCREEN_MASTER_TRANSFER_I2C
;;;73         return false;
;;;74     #elif SCREEN_MASTER_TRANSFER_SPI
;;;75         return !hal_gpio_get_input_data(g_screen_input_int_pad); //应对SPI主机通信过程中偶尔突然拉低CS 导致通信异常
;;;76     #else
;;;77         return false;
;;;78     #endif
;;;79     }
000002  4770              BX       lr
;;;80     
                          ENDP


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

                  app_tp_transfer_phone PROC
;;;700    **************************************************************************/
;;;701    static void app_tp_transfer_phone(size_t recieve_num)
000000  b510              PUSH     {r4,lr}
;;;702    {
000002  4604              MOV      r4,r0
;;;703     //   const uint8_t *phone_write_buffer;
;;;704     //   size_t phone_write_buffer_size = 0;
;;;705        /* 数据解析，判断是否需要答复以及答复的buffer指针 */
;;;706        if (recieve_num > 0)
000004  2c00              CMP      r4,#0
000006  d006              BEQ      |L17.22|
;;;707        {
;;;708        #if 0// 1: test
;;;709    		s_phone_read_buffer[3]=recieve_num;
;;;710    		app_tp_m_write(s_phone_read_buffer, 4);
;;;711    	#endif
;;;712       //     app_tp_phone_analysis_data(s_phone_read_buffer, recieve_num, &phone_write_buffer, &phone_write_buffer_size);
;;;713    //		app_tp_phone_analysis_data(s_phone_read_buffer, recieve_num, &s_slave_txbuffer, &s_slave_txbuffer_size);
;;;714    		app_tp_phone_analysis_data_custom(s_phone_read_buffer, recieve_num, s_slave_txbuffer, &s_slave_txbuffer_size);
000008  4b05              LDR      r3,|L17.32|
00000a  4806              LDR      r0,|L17.36|
00000c  4621              MOV      r1,r4
00000e  6802              LDR      r2,[r0,#0]  ; s_slave_txbuffer
000010  4805              LDR      r0,|L17.40|
000012  f7fffffe          BL       app_tp_phone_analysis_data_custom
                  |L17.22|
;;;715    	//	printf("222    %p %x \n",*s_slave_txbuffer,s_slave_txbuffer_size);
;;;716        }
;;;717    
;;;718        app_tp_s_read(s_phone_read_buffer, BUFFER_SIZE_MAX);
000016  21c8              MOVS     r1,#0xc8
000018  4803              LDR      r0,|L17.40|
00001a  f7fffffe          BL       app_tp_s_read
;;;719     /*   if (phone_write_buffer_size)                                      //大于0表示需要答复手机，配置发送buffer
;;;720        {
;;;721            app_tp_s_write(phone_write_buffer, phone_write_buffer_size);
;;;722        }
;;;723     */
;;;724    }
00001e  bd10              POP      {r4,pc}
;;;725    
                          ENDP

                  |L17.32|
                          DCD      s_slave_txbuffer_size
                  |L17.36|
                          DCD      s_slave_txbuffer
                  |L17.40|
                          DCD      s_phone_read_buffer

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

                  app_tp_transfer_screen_const PROC
;;;399    **************************************************************************/
;;;400    static void app_tp_transfer_screen_const(void)
000000  b510              PUSH     {r4,lr}
;;;401    {
;;;402    //    static bool    screen_const_transfer_buffer_ready = true;            //发送 buffer 是否已准备好
;;;403    	uint8_t ii;
;;;404    
;;;405        /**** 1. 判断当前状态通信已结束, 状态通信已结束，并且开机初始化流程还未走完****/
;;;406    #if 0 // test
;;;407    	uint8_t test_master_read_buffer[10] = {0x08, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19};
;;;408    	uint8_t write_buffer[10] = {0x04, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19};
;;;409    
;;;410    //	for (ii =0x20; ii<0x7F; ii++)
;;;411    	{
;;;412    		//hal_i2c_m_dma_init(ii, SCREEN_I2C_ADDR_BITS);
;;;413    		//delayMs(100);
;;;414    		if (hal_i2c_m_dma_write(write_buffer, 1))
;;;415    		{
;;;416    			//break;
;;;417    		}
;;;418    		while(!hal_i2c_m_transfer_complate());
;;;419    		hal_i2c_m_dma_read(test_master_read_buffer, 1, test_master_read_buffer, 2);
;;;420    	}
;;;421    #endif
;;;422    
;;;423    
;;;424        if (app_tp_m_transfer_complate() && (s_screen_const_transfer_count < screen_reg_start_data_size))
000002  f7fffffe          BL       app_tp_m_transfer_complate
000006  2800              CMP      r0,#0
000008  d014              BEQ      |L18.52|
00000a  480b              LDR      r0,|L18.56|
00000c  7800              LDRB     r0,[r0,#0]  ; s_screen_const_transfer_count
00000e  490b              LDR      r1,|L18.60|
000010  7809              LDRB     r1,[r1,#0]  ; screen_reg_start_data_size
000012  4288              CMP      r0,r1
000014  da0e              BGE      |L18.52|
;;;425        {
;;;426            if (s_spim_write)                                                //SPI 写数据后需要把接收FIFO的数据读出，不然会影响下一次读取
000016  480a              LDR      r0,|L18.64|
000018  7800              LDRB     r0,[r0,#0]  ; s_spim_write
00001a  2800              CMP      r0,#0
00001c  d004              BEQ      |L18.40|
;;;427            {
;;;428                hal_spi_m_clear_rxfifo();
00001e  f7fffffe          BL       hal_spi_m_clear_rxfifo
;;;429                s_spim_write = false;
000022  2000              MOVS     r0,#0
000024  4906              LDR      r1,|L18.64|
000026  7008              STRB     r0,[r1,#0]
                  |L18.40|
;;;430            }
;;;431    
;;;432    	#if 1
;;;433    		
;;;434    		#ifndef USE_FOR_SUMSUNG_S10
;;;435    		for (ii =0; ii<screen_reg_start_data_size; ii++)
;;;436    		{
;;;437                if (!screen_reg_start_data[ii].read_flag)     //当前通信不需要读回，直接写
;;;438                {
;;;439                    app_tp_m_write(screen_reg_start_data[ii].buffer, screen_reg_start_data[ii].txbuffer_size);
;;;440                }
;;;441                else                                             //当前通信需要读回，先写再读
;;;442                {
;;;443                    app_tp_m_read(screen_reg_start_data[ii].buffer, screen_reg_start_data[ii].txbuffer_size, \
;;;444                                  s_screen_read_bak, screen_reg_start_data[ii].rxbuffer_size);
;;;445                }
;;;446    			while(!hal_i2c_m_transfer_complate());
;;;447    		}
;;;448    		#endif
;;;449    		#if 0//
;;;450    		delayMs(100);
;;;451    		app_tp_m_read(screen_reg_int_data[0].buffer, screen_reg_int_data[0].txbuffer_size, s_screen_number, screen_reg_int_data[0].rxbuffer_size);
;;;452    		while(!hal_i2c_m_transfer_complate());
;;;453    		#endif
;;;454    		s_screen_init_complate = true;
000028  2001              MOVS     r0,#1
00002a  4906              LDR      r1,|L18.68|
00002c  7008              STRB     r0,[r1,#0]
;;;455            printf("tp done\n");
00002e  a006              ADR      r0,|L18.72|
000030  f7fffffe          BL       __2printf
                  |L18.52|
;;;456    
;;;457    	#else
;;;458            /**** 2. 发送或读取从机数据 ****/
;;;459            if (screen_const_transfer_buffer_ready)
;;;460            {
;;;461                screen_const_transfer_buffer_ready = false;
;;;462                if (!screen_reg_start_data[s_screen_const_transfer_count].read_flag)     //当前通信不需要读回，直接写
;;;463                {
;;;464                    app_tp_m_write(screen_reg_start_data[s_screen_const_transfer_count].buffer, screen_reg_start_data[s_screen_const_transfer_count].txbuffer_size);
;;;465                }
;;;466                else                                                             //当前通信需要读回，先写再读
;;;467                {
;;;468                    app_tp_m_read(screen_reg_start_data[s_screen_const_transfer_count].buffer, screen_reg_start_data[s_screen_const_transfer_count].txbuffer_size, \
;;;469                                  s_screen_number, screen_reg_start_data[s_screen_const_transfer_count].rxbuffer_size);
;;;470                }
;;;471    			s_screen_init_complate = true;
;;;472            }
;;;473            /**** 3. 解析本次通信数据，并准备下一次通信的buffer ****/
;;;474            else
;;;475            {
;;;476                screen_const_transfer_buffer_ready = true;
;;;477                s_screen_const_transfer_count = app_tp_screen_analysis_const(s_screen_const_transfer_count, s_screen_number, \
;;;478                                                screen_reg_start_data[s_screen_const_transfer_count].rxbuffer_size);
;;;479    
;;;480                if (s_screen_const_transfer_count >= screen_reg_start_data_size)
;;;481                {
;;;482                    s_screen_init_complate = true;
;;;483                }
;;;484            }
;;;485    	#endif	
;;;486        }
;;;487    }
000034  bd10              POP      {r4,pc}
;;;488    
                          ENDP

000036  0000              DCW      0x0000
                  |L18.56|
                          DCD      s_screen_const_transfer_count
                  |L18.60|
                          DCD      screen_reg_start_data_size
                  |L18.64|
                          DCD      s_spim_write
                  |L18.68|
                          DCD      s_screen_init_complate
                  |L18.72|
000048  74702064          DCB      "tp done\n",0
00004c  6f6e650a
000050  00      
000051  00                DCB      0
000052  00                DCB      0
000053  00                DCB      0

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

                  app_tp_transfer_screen_int PROC
;;;515    **************************************************************************/
;;;516    void app_tp_transfer_screen_int(void)
000000  b510              PUSH     {r4,lr}
;;;517    {
;;;518        bool screen_gpio_int = false;
000002  2400              MOVS     r4,#0
;;;519        static uint8_t screen_int_transfer_count = 0;            //记录当前通信到哪一步
;;;520        static bool    screen_int_transfer_buffer_ready = true;  //发送 buffer 是否已准备好
;;;521    //    static uint8_t test_flag = 0;
;;;522    	
;;;523        if (!s_screen_init_complate)                             //TP 初始化还未完成，则先进行初始化操作
000004  482a              LDR      r0,|L19.176|
000006  7800              LDRB     r0,[r0,#0]  ; s_screen_init_complate
000008  2800              CMP      r0,#0
00000a  d102              BNE      |L19.18|
;;;524        {
;;;525            app_tp_transfer_screen_const();
00000c  f7fffffe          BL       app_tp_transfer_screen_const
                  |L19.16|
;;;526            return;
;;;527        }
;;;528    
;;;529    #if 0 //test
;;;530    	test_flag++;
;;;531    	if (test_flag >1000000)
;;;532    	{
;;;533    		test_flag =0;
;;;534    		//TAU_LOGD("Run ok!!\n");
;;;535    		//app_tp_m_read(screen_reg_int_data[0].buffer, screen_reg_int_data[0].txbuffer_size, s_screen_number, screen_reg_int_data[0].rxbuffer_size);
;;;536    		//while(!hal_i2c_m_transfer_complate());
;;;537    	}
;;;538    #endif
;;;539    
;;;540        /**** 1. 判断 screen 是否发出中断信号 ****/
;;;541        // s_screen_int_flag:           中断信号标志位
;;;542        // app_tp_screen_int_lvl_low :  SPI 长时间通信时，偶尔会出现cs拉高导致通信异常卡死，该标志位用于解决卡死的问题
;;;543        screen_gpio_int = s_screen_int_flag || app_tp_screen_int_lvl_low();
;;;544        if (((screen_gpio_int) || (s_screen_int_transfer_status)) && app_tp_m_transfer_complate()) //判断当前不处于通信状态，并且准备通信
;;;545        {
;;;546     //   	TAU_LOGD("touch ok!!\n");
;;;547            s_screen_int_flag = false;
;;;548            if (s_spim_write)                                    //SPI 写数据后需要把接收FIFO的数据读出，不然会影响下一次读取
;;;549            {
;;;550                hal_spi_m_clear_rxfifo();
;;;551                s_spim_write = false;
;;;552            }
;;;553    
;;;554            /**** 2. 发送或读取从机数据 ****/
;;;555            if (screen_int_transfer_buffer_ready)
;;;556            {
;;;557    		#ifndef READ_MODULE_TP_ONE_BY_ONE
;;;558    			screen_int_transfer_buffer_ready = false;
;;;559    			s_screen_int_transfer_status = true;
;;;560    		#ifdef USE_FOR_SUMSUNG_S10
;;;561    			app_tp_m_read(screen_reg_int_data[2].buffer, 1, s_screen_read_buffer, 64);
;;;562    	//		app_tp_m_read(screen_reg_int_data[2].buffer, 1, s_screen_read_buffer, 8);
;;;563    			while(!hal_i2c_m_transfer_complate());
;;;564    			
;;;565    		#else		
;;;566    			app_tp_m_read(screen_reg_int_data[0].buffer, screen_reg_int_data[0].txbuffer_size, s_screen_temp, screen_reg_int_data[0].rxbuffer_size);
;;;567    			while(!hal_i2c_m_transfer_complate());
;;;568    			app_tp_m_read(screen_reg_int_data[1].buffer, screen_reg_int_data[1].txbuffer_size, s_screen_number, screen_reg_int_data[1].rxbuffer_size);
;;;569    			while(!hal_i2c_m_transfer_complate());
;;;570    			//TAU_LOGD("s_screen_number[%4x], size[%4x]", ((s_screen_number[1]<<8)|s_screen_number[0]), ((s_screen_temp[1]<<8)|s_screen_temp[0]));
;;;571    			
;;;572    			if(s_screen_number[1])
;;;573    			{
;;;574    				if (s_screen_number[1]>3)
;;;575    				{
;;;576    					read_point =1;
;;;577    					s_screen_int_transfer_status = false;
;;;578    				}
;;;579    				else if (s_screen_number[1] &0x02)
;;;580    					read_point =10;
;;;581    				else
;;;582    					read_point =9;
;;;583    			}
;;;584    			else
;;;585    			{
;;;586    				if(s_screen_number[0] &0x80)
;;;587    					read_point =8;
;;;588    				else if(s_screen_number[0] &0x40)
;;;589    					read_point =7;
;;;590    				else if(s_screen_number[0] &0x20)
;;;591    					read_point =6;
;;;592    				else if(s_screen_number[0] &0x10)
;;;593    					read_point =5;
;;;594    				else if(s_screen_number[0] &0x08)
;;;595    					read_point =4;
;;;596    				else if(s_screen_number[0] &0x04)
;;;597    					read_point =3;
;;;598    				else if(s_screen_number[0] &0x02)
;;;599    					read_point =2;
;;;600    				else
;;;601    					read_point =1;
;;;602    			}
;;;603    			read_point =8*read_point;
;;;604    			app_tp_m_read(screen_reg_int_data[2].buffer, screen_reg_int_data[2].txbuffer_size, s_screen_read_buffer, read_point);
;;;605    			while(!hal_i2c_m_transfer_complate());
;;;606    		#endif	
;;;607    		#else
;;;608                if (!screen_reg_int_data[screen_int_transfer_count].read_flag)  //当前通信不需要读回，直接写
;;;609                {
;;;610                    app_tp_m_write(screen_reg_int_data[screen_int_transfer_count].buffer, screen_reg_int_data[screen_int_transfer_count].txbuffer_size);
;;;611                }
;;;612                else                                                            //当前通信需要读回，先写再读
;;;613                {
;;;614    				s_screen_int_transfer_status = true;
;;;615                	if (screen_int_transfer_count==0)
;;;616                	{
;;;617    	                app_tp_m_read(screen_reg_int_data[screen_int_transfer_count].buffer, screen_reg_int_data[screen_int_transfer_count].txbuffer_size, \
;;;618    	                              s_screen_temp, screen_reg_int_data[screen_int_transfer_count].rxbuffer_size);
;;;619    					screen_int_transfer_count =1;
;;;620                	}
;;;621                	else if (screen_int_transfer_count==1)
;;;622                	{
;;;623    	                app_tp_m_read(screen_reg_int_data[screen_int_transfer_count].buffer, screen_reg_int_data[screen_int_transfer_count].txbuffer_size, \
;;;624    	                              s_screen_number, screen_reg_int_data[screen_int_transfer_count].rxbuffer_size);
;;;625    					screen_int_transfer_count =2;
;;;626                	}
;;;627                	else if (screen_int_transfer_count==2)
;;;628                	{
;;;629    					if(s_screen_number[1])
;;;630    					{
;;;631    						TAU_LOGD("s_screen_number[%4x], size[%4x]", ((s_screen_number[1]<<8)|s_screen_number[0]), ((s_screen_temp[1]<<8)|s_screen_temp[0]));
;;;632    						if (s_screen_number[1] &0x02)
;;;633    							read_point =10;
;;;634    						else
;;;635    							read_point =9;
;;;636    					}
;;;637    					else
;;;638    					{
;;;639    						if(s_screen_number[0] &0x80)
;;;640    							read_point =8;
;;;641    						else if(s_screen_number[0] &0x40)
;;;642    							read_point =7;
;;;643    						else if(s_screen_number[0] &0x20)
;;;644    							read_point =6;
;;;645    						else if(s_screen_number[0] &0x10)
;;;646    							read_point =5;
;;;647    						else if(s_screen_number[0] &0x08)
;;;648    							read_point =4;
;;;649    						else if(s_screen_number[0] &0x04)
;;;650    							read_point =3;
;;;651    						else if(s_screen_number[0] &0x02)
;;;652    							read_point =2;
;;;653    						else
;;;654    							read_point =1;
;;;655    					}
;;;656    					read_point =8*read_point;
;;;657    					
;;;658    	                app_tp_m_read(screen_reg_int_data[screen_int_transfer_count].buffer, screen_reg_int_data[screen_int_transfer_count].txbuffer_size, \
;;;659    	                              s_screen_read_buffer, read_point);
;;;660    					screen_int_transfer_count =0;
;;;661    					screen_int_transfer_buffer_ready = false;
;;;662                	}
;;;663                }
;;;664    		#endif	
;;;665            }
;;;666            /**** 3. 解析本次通信数据，并准备下一次通信的buffer ****/
;;;667            else
;;;668            {
;;;669            #if 1
;;;670    			#ifdef USE_FOR_SUMSUNG_S10
;;;671    			u16TouchID=0x0000;
;;;672    			#endif	
;;;673    			screen_int_transfer_buffer_ready = true;
;;;674    			screen_int_transfer_count = app_tp_screen_analysis_int(screen_int_transfer_count, s_screen_read_buffer,screen_reg_int_data[2].rxbuffer_size);
;;;675    			screen_int_transfer_count = 0;
;;;676    			s_screen_int_transfer_status = false;
;;;677    
;;;678    		#else
;;;679                screen_int_transfer_buffer_ready = true;
;;;680                screen_int_transfer_count = app_tp_screen_analysis_int(screen_int_transfer_count, s_screen_read_buffer, \
;;;681                                            screen_reg_int_data[screen_int_transfer_count].rxbuffer_size);
;;;682    
;;;683                if (screen_int_transfer_count > screen_reg_int_data_size)       //解析需要等最后一次通信结束，最后一次数据解析后，停止通信
;;;684                {
;;;685                    screen_int_transfer_count = 0;
;;;686                    s_screen_int_transfer_status = false;
;;;687                    return;
;;;688                }
;;;689    		#endif	
;;;690            }
;;;691        }
;;;692    }
000010  bd10              POP      {r4,pc}
                  |L19.18|
000012  4828              LDR      r0,|L19.180|
000014  7800              LDRB     r0,[r0,#0]            ;543  ; s_screen_int_flag
000016  2800              CMP      r0,#0                 ;543
000018  d103              BNE      |L19.34|
00001a  f7fffffe          BL       app_tp_screen_int_lvl_low
00001e  2800              CMP      r0,#0                 ;543
000020  d001              BEQ      |L19.38|
                  |L19.34|
000022  2001              MOVS     r0,#1                 ;543
000024  e000              B        |L19.40|
                  |L19.38|
000026  2000              MOVS     r0,#0                 ;543
                  |L19.40|
000028  4604              MOV      r4,r0                 ;543
00002a  2c00              CMP      r4,#0                 ;544
00002c  d103              BNE      |L19.54|
00002e  4822              LDR      r0,|L19.184|
000030  7800              LDRB     r0,[r0,#0]            ;544  ; s_screen_int_transfer_status
000032  2800              CMP      r0,#0                 ;544
000034  d039              BEQ      |L19.170|
                  |L19.54|
000036  f7fffffe          BL       app_tp_m_transfer_complate
00003a  2800              CMP      r0,#0                 ;544
00003c  d035              BEQ      |L19.170|
00003e  2000              MOVS     r0,#0                 ;547
000040  491c              LDR      r1,|L19.180|
000042  7008              STRB     r0,[r1,#0]            ;547
000044  481d              LDR      r0,|L19.188|
000046  7800              LDRB     r0,[r0,#0]            ;548  ; s_spim_write
000048  2800              CMP      r0,#0                 ;548
00004a  d004              BEQ      |L19.86|
00004c  f7fffffe          BL       hal_spi_m_clear_rxfifo
000050  2000              MOVS     r0,#0                 ;551
000052  491a              LDR      r1,|L19.188|
000054  7008              STRB     r0,[r1,#0]            ;551
                  |L19.86|
000056  481a              LDR      r0,|L19.192|
000058  7800              LDRB     r0,[r0,#0]            ;555  ; screen_int_transfer_buffer_ready
00005a  2800              CMP      r0,#0                 ;555
00005c  d012              BEQ      |L19.132|
00005e  2000              MOVS     r0,#0                 ;558
000060  4917              LDR      r1,|L19.192|
000062  7008              STRB     r0,[r1,#0]            ;558
000064  2001              MOVS     r0,#1                 ;559
000066  4914              LDR      r1,|L19.184|
000068  7008              STRB     r0,[r1,#0]            ;559
00006a  4916              LDR      r1,|L19.196|
00006c  2340              MOVS     r3,#0x40              ;561
00006e  4a16              LDR      r2,|L19.200|
000070  6a08              LDR      r0,[r1,#0x20]         ;561  ; screen_reg_int_data
000072  2101              MOVS     r1,#1                 ;561
000074  f7fffffe          BL       app_tp_m_read
000078  bf00              NOP                            ;563
                  |L19.122|
00007a  f7fffffe          BL       hal_i2c_m_transfer_complate
00007e  2800              CMP      r0,#0                 ;563
000080  d0fb              BEQ      |L19.122|
000082  e012              B        |L19.170|
                  |L19.132|
000084  2000              MOVS     r0,#0                 ;671
000086  4911              LDR      r1,|L19.204|
000088  8008              STRH     r0,[r1,#0]            ;671
00008a  2001              MOVS     r0,#1                 ;673
00008c  490c              LDR      r1,|L19.192|
00008e  7008              STRB     r0,[r1,#0]            ;673
000090  480c              LDR      r0,|L19.196|
000092  490d              LDR      r1,|L19.200|
000094  6a82              LDR      r2,[r0,#0x28]         ;674
000096  480e              LDR      r0,|L19.208|
000098  7800              LDRB     r0,[r0,#0]            ;674  ; screen_int_transfer_count
00009a  f7fffffe          BL       app_tp_screen_analysis_int
00009e  490c              LDR      r1,|L19.208|
0000a0  7008              STRB     r0,[r1,#0]            ;674
0000a2  2000              MOVS     r0,#0                 ;675
0000a4  7008              STRB     r0,[r1,#0]            ;675
0000a6  4904              LDR      r1,|L19.184|
0000a8  7008              STRB     r0,[r1,#0]            ;676
                  |L19.170|
0000aa  bf00              NOP      
0000ac  e7b0              B        |L19.16|
;;;693    
                          ENDP

0000ae  0000              DCW      0x0000
                  |L19.176|
                          DCD      s_screen_init_complate
                  |L19.180|
                          DCD      s_screen_int_flag
                  |L19.184|
                          DCD      s_screen_int_transfer_status
                  |L19.188|
                          DCD      s_spim_write
                  |L19.192|
                          DCD      screen_int_transfer_buffer_ready
                  |L19.196|
                          DCD      screen_reg_int_data
                  |L19.200|
                          DCD      s_screen_read_buffer
                  |L19.204|
                          DCD      u16TouchID
                  |L19.208|
                          DCD      screen_int_transfer_count

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

                  app_tp_transfer_screen_start PROC
;;;495    **************************************************************************/
;;;496    void app_tp_transfer_screen_start(void)
000000  b510              PUSH     {r4,lr}
;;;497    {
;;;498        s_screen_init_complate = false;
000002  2000              MOVS     r0,#0
000004  4904              LDR      r1,|L20.24|
000006  7008              STRB     r0,[r1,#0]
;;;499        s_screen_const_transfer_count = 0;
000008  4904              LDR      r1,|L20.28|
00000a  7008              STRB     r0,[r1,#0]
;;;500        //app_tp_screen_init();
;;;501    #ifndef DISABLE_I2C_INIT_CODE    
;;;502        app_tp_transfer_screen_const();
00000c  f7fffffe          BL       app_tp_transfer_screen_const
;;;503    #endif
;;;504    	s_screen_int_flag = false;
000010  2000              MOVS     r0,#0
000012  4903              LDR      r1,|L20.32|
000014  7008              STRB     r0,[r1,#0]
;;;505    }
000016  bd10              POP      {r4,pc}
;;;506    
                          ENDP

                  |L20.24|
                          DCD      s_screen_init_complate
                  |L20.28|
                          DCD      s_screen_const_transfer_count
                  |L20.32|
                          DCD      s_screen_int_flag

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

                  s_screen_read_bak
                          %        80
                  s_screen_read_buffer
                          %        200
                  s_phone_read_buffer
                          %        200
                  tp_scan_data
                          %        12

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

                  read_point
000000  00                DCB      0x00
                  s_screen_number
000001  0000              DCB      0x00,0x00
                  s_screen_temp
000003  00                DCB      0x00
000004  00000000          DCB      0x00,0x00,0x00,0x00
                  s_slave_txbuffer
                          DCD      0x00000000
                  s_slave_txbuffer_size
                          DCD      0x00000000
                  s_spim_write
000010  00                DCB      0x00
                  s_screen_int_flag
000011  00                DCB      0x00
                  s_phone_reset_flag
000012  00                DCB      0x00
                  s_screen_int_transfer_status
000013  00                DCB      0x00
                  s_screen_init_complate
000014  00                DCB      0x00
                  s_screen_const_transfer_count
000015  ff                DCB      0xff
                  u16TouchID
000016  0000              DCB      0x00,0x00
                  i2cs_transfer
000018  01                DCB      0x01
                  screen_int_transfer_count
000019  00                DCB      0x00
                  screen_int_transfer_buffer_ready
00001a  01                DCB      0x01

;*** Start embedded assembler ***

#line 1 "..\\..\\src\\app\\ap_demo\\app_tp_transfer.c"
	AREA ||.rev16_text||, CODE
	THUMB
	EXPORT |__asm___17_app_tp_transfer_c_8a033719____REV16|
#line 467 "C:\\Keil_v5\\ARM\\PACK\\ARM\\CMSIS\\5.5.1\\CMSIS\\Core\\Include\\cmsis_armcc.h"
|__asm___17_app_tp_transfer_c_8a033719____REV16| PROC
#line 468

 rev16 r0, r0
 bx lr
	ENDP
	AREA ||.revsh_text||, CODE
	THUMB
	EXPORT |__asm___17_app_tp_transfer_c_8a033719____REVSH|
#line 482
|__asm___17_app_tp_transfer_c_8a033719____REVSH| PROC
#line 483

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
