; generated by ARM C/C++ Compiler, 4.1 [Build 894]
; commandline ArmCC [--list --split_sections --debug -c --asm --interleave -o.\obj\drvusb.o --asm_dir=.\lst\ --list_dir=.\lst\ --depend=.\obj\drvusb.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__LCDDISPLAY_BTL001_H --omf_browse=.\obj\drvusb.crf ..\bsp\Driver\DrvUSB.c]
                          THUMB

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

                  DrvUSB_BusResetCallback PROC
;;;525    /*---------------------------------------------------------------------------------------------------------*/
;;;526    void DrvUSB_BusResetCallback(void * pVoid)
000000  b5f0              PUSH     {r4-r7,lr}
;;;527    {
;;;528    	S_DRVUSB_DEVICE *psDevice =&gsUsbDevice;
;;;529    	int i;
;;;530    
;;;531        /* Reset function address of USB device */
;;;532    	_DRVUSB_SET_FADDR(0x00);
000002  4c1a              LDR      r4,|L1.108|
000004  4b18              LDR      r3,|L1.104|
000006  2500              MOVS     r5,#0
000008  6125              STR      r5,[r4,#0x10]
;;;533    	
;;;534    	/* Disable IN NAK Flag */
;;;535    	USBD->CTRL &= ~0x8000;
00000a  6820              LDR      r0,[r4,#0]
00000c  2101              MOVS     r1,#1
00000e  03c9              LSLS     r1,r1,#15
000010  4388              BICS     r0,r0,r1
000012  6020              STR      r0,[r4,#0]
;;;536    
;;;537    	_DRVUSB_SET_SETUP_BUF(USB_BUF_SETUP);
000014  f7fffffe          BL       DrvUSB_GetSetupBuffer
000018  4a15              LDR      r2,|L1.112|
00001a  1880              ADDS     r0,r0,r2
00001c  61a0              STR      r0,[r4,#0x18]
;;;538    	
;;;539        /* Initial USB EP according to EP description */	
;;;540    	i = 0;
00001e  2000              MOVS     r0,#0
;;;541    	while (sEpDescription[i].u32MaxPacketSize != 0)
;;;542    	{
;;;543    	    /* Write one to clear IN/OUT ready flag */
;;;544    		/* Initial USB EP CFG Setting */
;;;545    		_DRVUSB_SET_CFG(i, CFG_EP_SETTING[i]|EPTCFG_CLRRDY);
;;;546    		_DRVUSB_SET_EP_BUF(i, (uint32_t)sEpDescription[i].u8SramBuffer);
000020  4e14              LDR      r6,|L1.116|
000022  e010              B        |L1.70|
                  |L1.36|
000024  4910              LDR      r1,|L1.104|
000026  0087              LSLS     r7,r0,#2              ;545
000028  31cc              ADDS     r1,r1,#0xcc           ;545
00002a  59cf              LDR      r7,[r1,r7]            ;545
00002c  2101              MOVS     r1,#1                 ;545
00002e  03c9              LSLS     r1,r1,#15             ;545
000030  430f              ORRS     r7,r7,r1              ;545
000032  4911              LDR      r1,|L1.120|
000034  400f              ANDS     r7,r7,r1              ;545
000036  0101              LSLS     r1,r0,#4              ;545
000038  1909              ADDS     r1,r1,r4              ;545
00003a  628f              STR      r7,[r1,#0x28]         ;545
00003c  6897              LDR      r7,[r2,#8]
00003e  4a0c              LDR      r2,|L1.112|
000040  18ba              ADDS     r2,r7,r2
000042  620a              STR      r2,[r1,#0x20]
;;;547    		i++;
000044  1c40              ADDS     r0,r0,#1
                  |L1.70|
000046  210c              MOVS     r1,#0xc               ;541
000048  4341              MULS     r1,r0,r1              ;541
00004a  198a              ADDS     r2,r1,r6              ;541
00004c  6851              LDR      r1,[r2,#4]            ;541
00004e  2900              CMP      r1,#0                 ;541
000050  d1e8              BNE      |L1.36|
;;;548    	}
;;;549    
;;;550    	psDevice->u8UsbAddress = 0;
000052  4618              MOV      r0,r3
000054  30a0              ADDS     r0,r0,#0xa0
000056  7605              STRB     r5,[r0,#0x18]
;;;551    	psDevice->u8UsbConfiguration = 0;
000058  7645              STRB     r5,[r0,#0x19]
;;;552    	
;;;553    	if(psDevice->eUsbState > eDRVUSB_DEFAULT)
00005a  3380              ADDS     r3,r3,#0x80
00005c  6a18              LDR      r0,[r3,#0x20]
00005e  2807              CMP      r0,#7
000060  dd01              BLE      |L1.102|
;;;554    		psDevice->eUsbState = eDRVUSB_DEFAULT;
000062  2007              MOVS     r0,#7
000064  6218              STR      r0,[r3,#0x20]
                  |L1.102|
;;;555    }
000066  bdf0              POP      {r4-r7,pc}
;;;556    
                          ENDP

                  |L1.104|
                          DCD      ||.bss||
                  |L1.108|
                          DCD      0x40060000
                  |L1.112|
                          DCD      0xbff9ff00
                  |L1.116|
                          DCD      sEpDescription
                  |L1.120|
                          DCD      0x000083ff

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

                  DrvUSB_Close PROC
;;;325    /*---------------------------------------------------------------------------------------------------------*/
;;;326    void DrvUSB_Close(void)
000000  2001              MOVS     r0,#1
000002  4907              LDR      r1,|L2.32|
000004  05c0              LSLS     r0,r0,#23
000006  6008              STR      r0,[r1,#0]
000008  4806              LDR      r0,|L2.36|
00000a  6801              LDR      r1,[r0,#0]
00000c  0849              LSRS     r1,r1,#1
00000e  0049              LSLS     r1,r1,#1
000010  6001              STR      r1,[r0,#0]
000012  4805              LDR      r0,|L2.40|
000014  6881              LDR      r1,[r0,#8]
000016  0482              LSLS     r2,r0,#18
000018  4391              BICS     r1,r1,r2
00001a  6081              STR      r1,[r0,#8]
;;;327    {    
;;;328    	NVIC_DisableIRQ(USBD_IRQn);
;;;329        DrvUSB_UnInit();
;;;330    }
00001c  4770              BX       lr
;;;331    
                          ENDP

00001e  0000              DCW      0x0000
                  |L2.32|
                          DCD      0xe000e180
                  |L2.36|
                          DCD      0x40060000
                  |L2.40|
                          DCD      0x50000200

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

                  DrvUSB_ClrCtrlReady PROC
;;;851    /*---------------------------------------------------------------------------------------------------------*/
;;;852    void DrvUSB_ClrCtrlReady(void)
000000  b530              PUSH     {r4,r5,lr}
;;;853    {
;;;854    	uint32_t u32EpId;
;;;855    
;;;856    	u32EpId = DrvUSB_GetEpIdentity(0, EP_OUTPUT);
000002  2100              MOVS     r1,#0
000004  4608              MOV      r0,r1
000006  f7fffffe          BL       DrvUSB_GetEpIdentity
;;;857    	_DRVUSB_CLEAR_EP_READY(u32EpId);
00000a  4d09              LDR      r5,|L3.48|
00000c  0100              LSLS     r0,r0,#4
00000e  1940              ADDS     r0,r0,r5
000010  6a81              LDR      r1,[r0,#0x28]
000012  2401              MOVS     r4,#1
000014  03e4              LSLS     r4,r4,#15
000016  4321              ORRS     r1,r1,r4
000018  6281              STR      r1,[r0,#0x28]
;;;858    	u32EpId = DrvUSB_GetEpIdentity(0, EP_INPUT);
00001a  2180              MOVS     r1,#0x80
00001c  2000              MOVS     r0,#0
00001e  f7fffffe          BL       DrvUSB_GetEpIdentity
;;;859    	_DRVUSB_CLEAR_EP_READY(u32EpId);
000022  0100              LSLS     r0,r0,#4
000024  1940              ADDS     r0,r0,r5
000026  6a81              LDR      r1,[r0,#0x28]
000028  4321              ORRS     r1,r1,r4
00002a  6281              STR      r1,[r0,#0x28]
;;;860    }
00002c  bd30              POP      {r4,r5,pc}
;;;861    
                          ENDP

00002e  0000              DCW      0x0000
                  |L3.48|
                          DCD      0x40060000

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

                  DrvUSB_ClrCtrlReadyAndTrigStall PROC
;;;875    /*---------------------------------------------------------------------------------------------------------*/
;;;876    void DrvUSB_ClrCtrlReadyAndTrigStall(void)
000000  b530              PUSH     {r4,r5,lr}
;;;877    {
;;;878    	uint32_t u32EpId;
;;;879    
;;;880    	u32EpId = DrvUSB_GetEpIdentity(0, EP_OUTPUT);
000002  2100              MOVS     r1,#0
000004  4608              MOV      r0,r1
000006  f7fffffe          BL       DrvUSB_GetEpIdentity
;;;881    	_DRVUSB_CLEAR_EP_READY_AND_TRIG_STALL(u32EpId);
00000a  4d09              LDR      r5,|L4.48|
00000c  0100              LSLS     r0,r0,#4
00000e  1940              ADDS     r0,r0,r5
000010  6a81              LDR      r1,[r0,#0x28]
000012  2441              MOVS     r4,#0x41
000014  0264              LSLS     r4,r4,#9
000016  4321              ORRS     r1,r1,r4
000018  6281              STR      r1,[r0,#0x28]
;;;882    	u32EpId = DrvUSB_GetEpIdentity(0, EP_INPUT);
00001a  2180              MOVS     r1,#0x80
00001c  2000              MOVS     r0,#0
00001e  f7fffffe          BL       DrvUSB_GetEpIdentity
;;;883    	_DRVUSB_CLEAR_EP_READY_AND_TRIG_STALL(u32EpId);
000022  0100              LSLS     r0,r0,#4
000024  1940              ADDS     r0,r0,r5
000026  6a81              LDR      r1,[r0,#0x28]
000028  4321              ORRS     r1,r1,r4
00002a  6281              STR      r1,[r0,#0x28]
;;;884    }
00002c  bd30              POP      {r4,r5,pc}
;;;885    
                          ENDP

00002e  0000              DCW      0x0000
                  |L4.48|
                          DCD      0x40060000

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

                  DrvUSB_CtrlDataInAck PROC
;;;700    /*---------------------------------------------------------------------------------------------------------*/
;;;701    void DrvUSB_CtrlDataInAck(void * pArgu)
000000  b4f0              PUSH     {r4-r7}
;;;702    {
;;;703    	uint32_t i;
;;;704    	S_DRVUSB_CTRL_CALLBACK_ENTRY *psEntry = 0;
;;;705    	S_DRVUSB_DEVICE *psDevice = &gsUsbDevice;
000002  4b10              LDR      r3,|L5.68|
;;;706    
;;;707    	for (i = 0; i < psDevice->CtrlCallbackSize; i++)
000004  2000              MOVS     r0,#0
;;;708    	{
;;;709    		psEntry = psDevice->pCtrlCallback + i;
;;;710    		if (psEntry->pfnCtrlDataInCallback &&
;;;711    		    psEntry->u8RequestType == (psDevice->au8Setup[0] & 0x60) &&
000006  461a              MOV      r2,r3
000008  2560              MOVS     r5,#0x60
00000a  32a0              ADDS     r2,r2,#0xa0
00000c  3380              ADDS     r3,r3,#0x80           ;709
00000e  6adc              LDR      r4,[r3,#0x2c]         ;707
000010  e014              B        |L5.60|
                  |L5.18|
000012  2114              MOVS     r1,#0x14              ;709
000014  6a9e              LDR      r6,[r3,#0x28]         ;709
000016  4341              MULS     r1,r0,r1              ;709
000018  1871              ADDS     r1,r6,r1              ;709
00001a  688e              LDR      r6,[r1,#8]            ;710
00001c  2e00              CMP      r6,#0                 ;710
00001e  d00c              BEQ      |L5.58|
000020  7c16              LDRB     r6,[r2,#0x10]
000022  780f              LDRB     r7,[r1,#0]
000024  402e              ANDS     r6,r6,r5
000026  42b7              CMP      r7,r6
000028  d107              BNE      |L5.58|
;;;712    		    psEntry->u8Request == psDevice->au8Setup[1])
00002a  784e              LDRB     r6,[r1,#1]
00002c  7c57              LDRB     r7,[r2,#0x11]
00002e  42be              CMP      r6,r7
000030  d103              BNE      |L5.58|
;;;713    		{
;;;714    			psEntry->pfnCtrlDataInCallback(psEntry->pVoid);
000032  6908              LDR      r0,[r1,#0x10]
000034  6889              LDR      r1,[r1,#8]
000036  bcf0              POP      {r4-r7}
000038  4708              BX       r1
                  |L5.58|
00003a  1c40              ADDS     r0,r0,#1              ;707
                  |L5.60|
00003c  4284              CMP      r4,r0                 ;707
00003e  d8e8              BHI      |L5.18|
;;;715    			return;
;;;716    		}
;;;717    	}
;;;718    	return;
;;;719    }
000040  bcf0              POP      {r4-r7}
000042  4770              BX       lr
;;;720    
                          ENDP

                  |L5.68|
                          DCD      ||.bss||

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

                  DrvUSB_CtrlDataInDefault PROC
;;;770    /*---------------------------------------------------------------------------------------------------------*/
;;;771    void DrvUSB_CtrlDataInDefault(void * pVoid)
000000  4803              LDR      r0,|L6.16|
;;;772    {
;;;773    	S_DRVUSB_DEVICE *pInfraDevice = &gsUsbDevice;
;;;774    	
;;;775    	if (pInfraDevice->au8Setup[0] & 0x80)
000002  7c00              LDRB     r0,[r0,#0x10]
000004  0600              LSLS     r0,r0,#24
000006  d502              BPL      |L6.14|
;;;776    	{
;;;777    		_DRVUSB_TRIG_EP(1, 0x00);
000008  4902              LDR      r1,|L6.20|
00000a  2000              MOVS     r0,#0
00000c  6348              STR      r0,[r1,#0x34]
                  |L6.14|
;;;778    	}
;;;779    }
00000e  4770              BX       lr
;;;780    
                          ENDP

                  |L6.16|
                          DCD      ||.bss||+0xa0
                  |L6.20|
                          DCD      0x40060000

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

                  DrvUSB_CtrlDataInSetAddress PROC
;;;1770   /*---------------------------------------------------------------------------------------------------------*/
;;;1771   void DrvUSB_CtrlDataInSetAddress(void * pVoid)
000000  4806              LDR      r0,|L7.28|
;;;1772   {
;;;1773   	S_DRVUSB_DEVICE *pInfraDevice = &gsUsbDevice;
;;;1774   
;;;1775   	if (pInfraDevice->u8UsbAddress == 0x00)
000002  7e01              LDRB     r1,[r0,#0x18]
000004  3820              SUBS     r0,r0,#0x20           ;1773
000006  2900              CMP      r1,#0
000008  d004              BEQ      |L7.20|
;;;1776   	{
;;;1777   		DrvUSB_SetUsbState(eDRVUSB_DEFAULT);
;;;1778   	}
;;;1779   	else
;;;1780   	{
;;;1781   		DrvUSB_SetUsbState(eDRVUSB_ADDRESS);
00000a  220f              MOVS     r2,#0xf
;;;1782   		_DRVUSB_SET_FADDR(pInfraDevice->u8UsbAddress);
00000c  6202              STR      r2,[r0,#0x20]
00000e  4804              LDR      r0,|L7.32|
000010  6101              STR      r1,[r0,#0x10]
;;;1783   	}	
;;;1784   }
000012  4770              BX       lr
                  |L7.20|
000014  2107              MOVS     r1,#7                 ;1777
000016  6201              STR      r1,[r0,#0x20]         ;1777
000018  4770              BX       lr
;;;1785   
                          ENDP

00001a  0000              DCW      0x0000
                  |L7.28|
                          DCD      ||.bss||+0xa0
                  |L7.32|
                          DCD      0x40060000

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

                  DrvUSB_CtrlDataOutAck PROC
;;;736    /*---------------------------------------------------------------------------------------------------------*/
;;;737    void DrvUSB_CtrlDataOutAck(void * pArgu)
000000  b4f0              PUSH     {r4-r7}
;;;738    {
;;;739    	uint32_t i;
;;;740    	S_DRVUSB_CTRL_CALLBACK_ENTRY *psEntry = 0;
;;;741    	S_DRVUSB_DEVICE *psDevice = &gsUsbDevice;
000002  4b10              LDR      r3,|L8.68|
;;;742    
;;;743    	for (i = 0; i < psDevice->CtrlCallbackSize; i++)
000004  2000              MOVS     r0,#0
;;;744    	{
;;;745    		psEntry = psDevice->pCtrlCallback + i;
;;;746    		if (psEntry->pfnCtrlDataOutCallback &&
;;;747    		    psEntry->u8RequestType == (psDevice->au8Setup[0] & 0x60) &&
000006  461a              MOV      r2,r3
000008  2560              MOVS     r5,#0x60
00000a  32a0              ADDS     r2,r2,#0xa0
00000c  3380              ADDS     r3,r3,#0x80           ;745
00000e  6adc              LDR      r4,[r3,#0x2c]         ;743
000010  e014              B        |L8.60|
                  |L8.18|
000012  2114              MOVS     r1,#0x14              ;745
000014  6a9e              LDR      r6,[r3,#0x28]         ;745
000016  4341              MULS     r1,r0,r1              ;745
000018  1871              ADDS     r1,r6,r1              ;745
00001a  68ce              LDR      r6,[r1,#0xc]          ;746
00001c  2e00              CMP      r6,#0                 ;746
00001e  d00c              BEQ      |L8.58|
000020  7c16              LDRB     r6,[r2,#0x10]
000022  780f              LDRB     r7,[r1,#0]
000024  402e              ANDS     r6,r6,r5
000026  42b7              CMP      r7,r6
000028  d107              BNE      |L8.58|
;;;748    		    psEntry->u8Request == psDevice->au8Setup[1])
00002a  784e              LDRB     r6,[r1,#1]
00002c  7c57              LDRB     r7,[r2,#0x11]
00002e  42be              CMP      r6,r7
000030  d103              BNE      |L8.58|
;;;749    		{
;;;750    			psEntry->pfnCtrlDataOutCallback(psEntry->pVoid);
000032  6908              LDR      r0,[r1,#0x10]
000034  68c9              LDR      r1,[r1,#0xc]
000036  bcf0              POP      {r4-r7}
000038  4708              BX       r1
                  |L8.58|
00003a  1c40              ADDS     r0,r0,#1              ;743
                  |L8.60|
00003c  4284              CMP      r4,r0                 ;743
00003e  d8e8              BHI      |L8.18|
;;;751    			return;
;;;752    		}
;;;753    	}
;;;754    	return;
;;;755    }
000040  bcf0              POP      {r4-r7}
000042  4770              BX       lr
;;;756    
                          ENDP

                  |L8.68|
                          DCD      ||.bss||

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

                  DrvUSB_CtrlDataOutDefault PROC
;;;795    /*---------------------------------------------------------------------------------------------------------*/
;;;796    void DrvUSB_CtrlDataOutDefault(void * pVoid)
000000  b500              PUSH     {lr}
;;;797    {
;;;798    	S_DRVUSB_DEVICE *pInfraDevice = &gsUsbDevice;
000002  4805              LDR      r0,|L9.24|
;;;799    	
;;;800    	if ((pInfraDevice->au8Setup[0] & 0x80) == 0)
000004  7c00              LDRB     r0,[r0,#0x10]
000006  0600              LSLS     r0,r0,#24
000008  d404              BMI      |L9.20|
;;;801    	{
;;;802    		DrvUSB_DataIn(0, NULL, 0);
00000a  2200              MOVS     r2,#0
00000c  4611              MOV      r1,r2
00000e  4610              MOV      r0,r2
000010  f7fffffe          BL       DrvUSB_DataIn
                  |L9.20|
;;;803    	}
;;;804    }
000014  bd00              POP      {pc}
;;;805    
                          ENDP

000016  0000              DCW      0x0000
                  |L9.24|
                          DCD      ||.bss||+0xa0

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

                  DrvUSB_CtrlSetupAck PROC
;;;645    /*---------------------------------------------------------------------------------------------------------*/
;;;646    void DrvUSB_CtrlSetupAck(void * pArgu)
000000  b5f8              PUSH     {r3-r7,lr}
;;;647    {
;;;648    	uint32_t i;
;;;649    	E_DRVUSB_STATE eUsbState;
;;;650    	S_DRVUSB_CTRL_CALLBACK_ENTRY *psEntry = 0;
;;;651    	S_DRVUSB_DEVICE *psDevice = &gsUsbDevice;
000002  4c19              LDR      r4,|L10.104|
;;;652    	uint8_t * SetupBuffer;
;;;653    
;;;654    	DrvUSB_ClrCtrlReady();
000004  f7fffffe          BL       DrvUSB_ClrCtrlReady
;;;655    
;;;656    	/* check if after DEFAULT state (RESET)	*/
;;;657    	eUsbState = DrvUSB_GetUsbState();
000008  f7fffffe          BL       DrvUSB_GetUsbState
;;;658    	if (eUsbState < eDRVUSB_DEFAULT)
00000c  2807              CMP      r0,#7
00000e  d327              BCC      |L10.96|
;;;659    	{
;;;660    		DrvUSB_ClrCtrlReadyAndTrigStall();
;;;661    		return;
;;;662    	}
;;;663    	SetupBuffer = (uint8_t *)DrvUSB_GetSetupBuffer();
000010  f7fffffe          BL       DrvUSB_GetSetupBuffer
;;;664    	
;;;665    	for (i = 0; i < 8; i++)
000014  2100              MOVS     r1,#0
                  |L10.22|
;;;666    	{
;;;667    		psDevice->au8Setup[i] = SetupBuffer[i];
000016  1862              ADDS     r2,r4,r1
000018  5c43              LDRB     r3,[r0,r1]
00001a  32a0              ADDS     r2,r2,#0xa0
00001c  1c49              ADDS     r1,r1,#1              ;665
00001e  7413              STRB     r3,[r2,#0x10]
000020  2908              CMP      r1,#8                 ;665
000022  d3f8              BCC      |L10.22|
;;;668    	}
;;;669    	
;;;670    	for (i = 0; i < psDevice->CtrlCallbackSize; i++)
;;;671    	{
;;;672    		psEntry = psDevice->pCtrlCallback + i;
;;;673    		if (psEntry->pfnCtrlSetupCallback &&
;;;674    		    psEntry->u8RequestType == (psDevice->au8Setup[0] & 0x60) &&
000024  4622              MOV      r2,r4
000026  2000              MOVS     r0,#0                 ;670
000028  2360              MOVS     r3,#0x60
00002a  32a0              ADDS     r2,r2,#0xa0
00002c  3480              ADDS     r4,r4,#0x80           ;672
00002e  6ae5              LDR      r5,[r4,#0x2c]         ;670
000030  e014              B        |L10.92|
                  |L10.50|
000032  2114              MOVS     r1,#0x14              ;672
000034  6aa6              LDR      r6,[r4,#0x28]         ;672
000036  4341              MULS     r1,r0,r1              ;672
000038  1871              ADDS     r1,r6,r1              ;672
00003a  684e              LDR      r6,[r1,#4]            ;673
00003c  2e00              CMP      r6,#0                 ;673
00003e  d00c              BEQ      |L10.90|
000040  7c16              LDRB     r6,[r2,#0x10]
000042  780f              LDRB     r7,[r1,#0]
000044  401e              ANDS     r6,r6,r3
000046  42b7              CMP      r7,r6
000048  d107              BNE      |L10.90|
;;;675    		    psEntry->u8Request == psDevice->au8Setup[1])
00004a  784e              LDRB     r6,[r1,#1]
00004c  7c57              LDRB     r7,[r2,#0x11]
00004e  42be              CMP      r6,r7
000050  d103              BNE      |L10.90|
;;;676    		{
;;;677    			psEntry->pfnCtrlSetupCallback(psEntry->pVoid);
000052  6908              LDR      r0,[r1,#0x10]
000054  6849              LDR      r1,[r1,#4]
000056  4788              BLX      r1
;;;678    			return;
;;;679    		}
;;;680    	}
;;;681    	DrvUSB_ClrCtrlReadyAndTrigStall();
;;;682    	return;
;;;683    }
000058  bdf8              POP      {r3-r7,pc}
                  |L10.90|
00005a  1c40              ADDS     r0,r0,#1              ;670
                  |L10.92|
00005c  4285              CMP      r5,r0                 ;670
00005e  d8e8              BHI      |L10.50|
                  |L10.96|
000060  f7fffffe          BL       DrvUSB_ClrCtrlReadyAndTrigStall
000064  bdf8              POP      {r3-r7,pc}
;;;684    
                          ENDP

000066  0000              DCW      0x0000
                  |L10.104|
                          DCD      ||.bss||

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

                  DrvUSB_CtrlSetupClearSetFeature PROC
;;;1549   /*---------------------------------------------------------------------------------------------------------*/
;;;1550   void DrvUSB_CtrlSetupClearSetFeature(void * pVoid)
000000  b510              PUSH     {r4,lr}
;;;1551   {
;;;1552   	S_DRVUSB_DEVICE *pInfraDevice = &gsUsbDevice;
000002  4c1c              LDR      r4,|L11.116|
;;;1553   	uint32_t u32EpId;
;;;1554   	
;;;1555   	/* Device */
;;;1556   	if ((pInfraDevice->au8Setup[0] == 0x00) && (pInfraDevice->au8Setup[2] == FEATURE_DEVICE_REMOTE_WAKEUP))
000004  7c20              LDRB     r0,[r4,#0x10]
000006  7ca1              LDRB     r1,[r4,#0x12]
000008  2800              CMP      r0,#0
00000a  d004              BEQ      |L11.22|
;;;1557   	{
;;;1558   		if(pInfraDevice->au8Setup[1] == SET_FEATURE)
;;;1559   			DrvUSB_EnableRemoteWakeup();
;;;1560   		if(pInfraDevice->au8Setup[1] == CLEAR_FEATURE)
;;;1561   			DrvUSB_DisableRemoteWakeup();
;;;1562   	}
;;;1563   	/* Interface */
;;;1564   	else if (pInfraDevice->au8Setup[0] == 0x01);
00000c  2801              CMP      r0,#1
00000e  d02a              BEQ      |L11.102|
;;;1565   	
;;;1566   	/* Endpoint	*/
;;;1567   	else if ((pInfraDevice->au8Setup[0] == 0x02) && (pInfraDevice->au8Setup[2] == FEATURE_ENDPOINT_HALT))
000010  2802              CMP      r0,#2
000012  d00d              BEQ      |L11.48|
000014  e025              B        |L11.98|
                  |L11.22|
000016  2901              CMP      r1,#1                 ;1556
000018  d123              BNE      |L11.98|
00001a  7c60              LDRB     r0,[r4,#0x11]         ;1558
00001c  2803              CMP      r0,#3                 ;1558
00001e  d101              BNE      |L11.36|
000020  f7fffffe          BL       DrvUSB_EnableRemoteWakeup
                  |L11.36|
000024  7c60              LDRB     r0,[r4,#0x11]         ;1560
000026  2801              CMP      r0,#1                 ;1560
000028  d11d              BNE      |L11.102|
00002a  f7fffffe          BL       DrvUSB_DisableRemoteWakeup
00002e  e01a              B        |L11.102|
                  |L11.48|
000030  2900              CMP      r1,#0
000032  d116              BNE      |L11.98|
;;;1568   	{
;;;1569   		u32EpId = DrvUSB_GetEpId(pInfraDevice->au8Setup[4]);
000034  7d20              LDRB     r0,[r4,#0x14]
000036  f7fffffe          BL       DrvUSB_GetEpId
;;;1570   		
;;;1571   		if (u32EpId < MAX_EP_ID)
00003a  2808              CMP      r0,#8
00003c  d211              BCS      |L11.98|
;;;1572   		{
;;;1573   			_DRVUSB_CLEAR_EP_DSQ_SYNC(u32EpId);
00003e  0101              LSLS     r1,r0,#4
000040  480d              LDR      r0,|L11.120|
000042  1808              ADDS     r0,r1,r0
000044  6a81              LDR      r1,[r0,#0x28]
000046  2280              MOVS     r2,#0x80
000048  4391              BICS     r1,r1,r2
00004a  6281              STR      r1,[r0,#0x28]
;;;1574   			if (pInfraDevice->au8Setup[1] == CLEAR_FEATURE)
00004c  7c62              LDRB     r2,[r4,#0x11]
;;;1575   			{
;;;1576   				_DRVUSB_CLEAR_EP_STALL(u32EpId);
00004e  2101              MOVS     r1,#1
000050  0249              LSLS     r1,r1,#9
000052  2a01              CMP      r2,#1                 ;1574
;;;1577   			}
;;;1578   			else
;;;1579   			{
;;;1580   				_DRVUSB_TRIG_EP_STALL(u32EpId);
000054  6a82              LDR      r2,[r0,#0x28]
000056  d002              BEQ      |L11.94|
000058  430a              ORRS     r2,r2,r1
                  |L11.90|
00005a  6282              STR      r2,[r0,#0x28]         ;1576
00005c  e003              B        |L11.102|
                  |L11.94|
00005e  438a              BICS     r2,r2,r1              ;1576
000060  e7fb              B        |L11.90|
                  |L11.98|
;;;1581   			}
;;;1582   		}
;;;1583   		else
;;;1584   		{
;;;1585   			DrvUSB_ClrCtrlReadyAndTrigStall();
;;;1586   		}
;;;1587   	}
;;;1588   	else
;;;1589   	{
;;;1590   		DrvUSB_ClrCtrlReadyAndTrigStall();
000062  f7fffffe          BL       DrvUSB_ClrCtrlReadyAndTrigStall
                  |L11.102|
;;;1591   	}
;;;1592   
;;;1593   	DrvUSB_DataIn(0, NULL, 0);	
000066  2200              MOVS     r2,#0
000068  4611              MOV      r1,r2
00006a  4610              MOV      r0,r2
00006c  f7fffffe          BL       DrvUSB_DataIn
;;;1594   }
000070  bd10              POP      {r4,pc}
;;;1595   
                          ENDP

000072  0000              DCW      0x0000
                  |L11.116|
                          DCD      ||.bss||+0xa0
                  |L11.120|
                          DCD      0x40060000

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

                  DrvUSB_CtrlSetupGetConfiguration PROC
;;;1608   /*---------------------------------------------------------------------------------------------------------*/
;;;1609   void DrvUSB_CtrlSetupGetConfiguration(void * pVoid)
000000  b500              PUSH     {lr}
;;;1610   {
;;;1611   	DrvUSB_DataIn(0, &gsUsbDevice.u8UsbConfiguration, 1);	
000002  2201              MOVS     r2,#1
000004  4902              LDR      r1,|L12.16|
000006  2000              MOVS     r0,#0
000008  f7fffffe          BL       DrvUSB_DataIn
;;;1612   }
00000c  bd00              POP      {pc}
;;;1613   
                          ENDP

00000e  0000              DCW      0x0000
                  |L12.16|
                          DCD      ||.bss||+0xb9

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

                  DrvUSB_CtrlSetupGetInterface PROC
;;;1678   /*---------------------------------------------------------------------------------------------------------*/
;;;1679   void DrvUSB_CtrlSetupGetInterface(void * pVoid)
000000  b508              PUSH     {r3,lr}
;;;1680   {
;;;1681   	const uint8_t c = 0x00;
000002  2000              MOVS     r0,#0
000004  4669              MOV      r1,sp
000006  7008              STRB     r0,[r1,#0]
;;;1682   
;;;1683   	DrvUSB_DataIn(0, &c, 1);	
000008  2201              MOVS     r2,#1
00000a  f7fffffe          BL       DrvUSB_DataIn
;;;1684   }
00000e  bd08              POP      {r3,pc}
;;;1685   
                          ENDP


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

                  DrvUSB_CtrlSetupGetStatus PROC
;;;1626   /*---------------------------------------------------------------------------------------------------------*/
;;;1627   void DrvUSB_CtrlSetupGetStatus(void * pVoid)
000000  b538              PUSH     {r3-r5,lr}
;;;1628   {
;;;1629   	uint8_t au8Buf[4];
;;;1630   	S_DRVUSB_DEVICE *pInfraDevice = &gsUsbDevice;
000002  4c17              LDR      r4,|L14.96|
;;;1631   	uint32_t u32EpId;
;;;1632   	
;;;1633   	u32EpId = DrvUSB_GetEpId(pInfraDevice->au8Setup[4]);
000004  4625              MOV      r5,r4
000006  35a0              ADDS     r5,r5,#0xa0
000008  7d28              LDRB     r0,[r5,#0x14]
00000a  f7fffffe          BL       DrvUSB_GetEpId
;;;1634   
;;;1635   	if (pInfraDevice->au8Setup[0] == 0x80)
00000e  7c29              LDRB     r1,[r5,#0x10]
;;;1636   	{
;;;1637   		au8Buf[0] = pInfraDevice->bRemoteWakeup << 1 | pInfraDevice->bSelfPowered;
;;;1638   	}
;;;1639   	else if (pInfraDevice->au8Setup[0] == 0x81)
;;;1640   	{
;;;1641   		au8Buf[0] = 0x00;
000010  2200              MOVS     r2,#0
000012  2980              CMP      r1,#0x80              ;1635
000014  d004              BEQ      |L14.32|
000016  2981              CMP      r1,#0x81              ;1639
000018  d009              BEQ      |L14.46|
;;;1642   	}
;;;1643   	else if (pInfraDevice->au8Setup[0] == 0x82)
00001a  2982              CMP      r1,#0x82
00001c  d00a              BEQ      |L14.52|
00001e  e01b              B        |L14.88|
                  |L14.32|
000020  20c0              MOVS     r0,#0xc0              ;1637
000022  5900              LDR      r0,[r0,r4]            ;1637
000024  0040              LSLS     r0,r0,#1              ;1637
000026  3480              ADDS     r4,r4,#0x80           ;1637
000028  6be1              LDR      r1,[r4,#0x3c]         ;1637
00002a  4308              ORRS     r0,r0,r1              ;1637
00002c  e00a              B        |L14.68|
                  |L14.46|
00002e  4668              MOV      r0,sp                 ;1641
000030  7002              STRB     r2,[r0,#0]            ;1641
000032  e009              B        |L14.72|
                  |L14.52|
;;;1644   	{
;;;1645   		if (u32EpId < MAX_EP_ID)
000034  2808              CMP      r0,#8
000036  d20f              BCS      |L14.88|
;;;1646   		{
;;;1647   			/* Interrupt-In Endpoint */
;;;1648   			au8Buf[0] = (_DRVUSB_GET_CFG(u32EpId) & EPTCFG_SSTALL) ? 1 : 0;
000038  490a              LDR      r1,|L14.100|
00003a  0100              LSLS     r0,r0,#4
00003c  1840              ADDS     r0,r0,r1
00003e  6a80              LDR      r0,[r0,#0x28]
000040  0580              LSLS     r0,r0,#22
000042  0fc0              LSRS     r0,r0,#31
                  |L14.68|
000044  4669              MOV      r1,sp
000046  7008              STRB     r0,[r1,#0]
                  |L14.72|
;;;1649   		}
;;;1650   		else
;;;1651   		{
;;;1652   			DrvUSB_ClrCtrlReadyAndTrigStall();
;;;1653   			return;
;;;1654   		}
;;;1655   	}
;;;1656   	else
;;;1657   	{
;;;1658   		DrvUSB_ClrCtrlReadyAndTrigStall();
;;;1659   		return;
;;;1660   	}
;;;1661   	au8Buf[1] = 0x00;
000048  4668              MOV      r0,sp
00004a  7042              STRB     r2,[r0,#1]
;;;1662   
;;;1663   	DrvUSB_DataIn(0, au8Buf, 2);	
00004c  2202              MOVS     r2,#2
00004e  4669              MOV      r1,sp
000050  2000              MOVS     r0,#0
000052  f7fffffe          BL       DrvUSB_DataIn
;;;1664   }
000056  bd38              POP      {r3-r5,pc}
                  |L14.88|
000058  f7fffffe          BL       DrvUSB_ClrCtrlReadyAndTrigStall
00005c  bd38              POP      {r3-r5,pc}
;;;1665   
                          ENDP

00005e  0000              DCW      0x0000
                  |L14.96|
                          DCD      ||.bss||
                  |L14.100|
                          DCD      0x40060000

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

                  DrvUSB_CtrlSetupSetAddress PROC
;;;1517   /*---------------------------------------------------------------------------------------------------------*/
;;;1518   void DrvUSB_CtrlSetupSetAddress(void * pVoid)
000000  b500              PUSH     {lr}
;;;1519   {
;;;1520   	E_DRVUSB_STATE eUsbState;
;;;1521   	S_DRVUSB_DEVICE *pInfraDevice = &gsUsbDevice;	
000002  490b              LDR      r1,|L15.48|
;;;1522   
;;;1523   	eUsbState = DrvUSB_GetUsbState();
000004  f7fffffe          BL       DrvUSB_GetUsbState
;;;1524   	if (eUsbState == eDRVUSB_DEFAULT)
000008  2807              CMP      r0,#7
00000a  d002              BEQ      |L15.18|
;;;1525   	{
;;;1526   		pInfraDevice->u8UsbAddress = pInfraDevice->au8Setup[2];
;;;1527   		_DRVUSB_SET_EP_TOG_BIT(0, 0);
;;;1528   		_DRVUSB_TRIG_EP(0, 0);
;;;1529   		DrvUSB_SetUsbState(eDRVUSB_ADDRESS);
;;;1530   	}
;;;1531   	else
;;;1532   	{
;;;1533   		DrvUSB_ClrCtrlReadyAndTrigStall();
00000c  f7fffffe          BL       DrvUSB_ClrCtrlReadyAndTrigStall
;;;1534   	}
;;;1535   }
000010  bd00              POP      {pc}
                  |L15.18|
000012  31a0              ADDS     r1,r1,#0xa0           ;1526
000014  7c88              LDRB     r0,[r1,#0x12]         ;1526
000016  7608              STRB     r0,[r1,#0x18]         ;1526
000018  4806              LDR      r0,|L15.52|
00001a  6a81              LDR      r1,[r0,#0x28]         ;1527
00001c  2280              MOVS     r2,#0x80              ;1527
00001e  4311              ORRS     r1,r1,r2              ;1527
000020  6281              STR      r1,[r0,#0x28]         ;1527
000022  2100              MOVS     r1,#0                 ;1528
000024  6241              STR      r1,[r0,#0x24]         ;1528
000026  4902              LDR      r1,|L15.48|
000028  200f              MOVS     r0,#0xf               ;1529
00002a  3180              ADDS     r1,r1,#0x80           ;1529
00002c  6208              STR      r0,[r1,#0x20]         ;1529
00002e  bd00              POP      {pc}
;;;1536   
                          ENDP

                  |L15.48|
                          DCD      ||.bss||
                  |L15.52|
                          DCD      0x40060000

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

                  DrvUSB_CtrlSetupSetConfiguration PROC
;;;1722   /*---------------------------------------------------------------------------------------------------------*/
;;;1723   void DrvUSB_CtrlSetupSetConfiguration(void * pVoid)
000000  b570              PUSH     {r4-r6,lr}
;;;1724   {
000002  4606              MOV      r6,r0
;;;1725   	S_DRVUSB_DEVICE *pDrvDevice = &gsUsbDevice;
000004  4814              LDR      r0,|L16.88|
;;;1726   	S_DRVUSB_CLASS *psUsbClass = pDrvDevice->psUsbClass;
;;;1727   	int32_t bIsDeviceConfigure;
;;;1728   	
;;;1729   	bIsDeviceConfigure = psUsbClass->pfnCompare ? psUsbClass->pfnCompare(pDrvDevice->au8Setup[2]) : 1;
000006  6885              LDR      r5,[r0,#8]
000008  4604              MOV      r4,r0                 ;1725
00000a  68a9              LDR      r1,[r5,#8]
00000c  3c20              SUBS     r4,r4,#0x20           ;1725
00000e  2900              CMP      r1,#0
000010  d003              BEQ      |L16.26|
000012  7ca0              LDRB     r0,[r4,#0x12]
000014  4788              BLX      r1
000016  4601              MOV      r1,r0
000018  e000              B        |L16.28|
                  |L16.26|
00001a  2101              MOVS     r1,#1
                  |L16.28|
00001c  480e              LDR      r0,|L16.88|
;;;1730   	
;;;1731   	if (pDrvDevice->au8Setup[2] == 0)
00001e  7ca2              LDRB     r2,[r4,#0x12]
000020  3840              SUBS     r0,r0,#0x40           ;1725
000022  2a00              CMP      r2,#0
000024  d010              BEQ      |L16.72|
;;;1732   	{
;;;1733   		/* USB address state */
;;;1734   		DrvUSB_SetUsbState(eDRVUSB_ADDRESS);
;;;1735   		pDrvDevice->u8UsbConfiguration = pDrvDevice->au8Setup[2];
;;;1736   		DrvUSB_DataIn(0, NULL, 0);
;;;1737   	}
;;;1738   	else if (bIsDeviceConfigure)
000026  2900              CMP      r1,#0
000028  d012              BEQ      |L16.80|
;;;1739   	{
;;;1740   		/* USB configured state */
;;;1741   		DrvUSB_SetUsbState(eDRVUSB_CONFIGURED);
00002a  211f              MOVS     r1,#0x1f
;;;1742   
;;;1743   		/* Call USB class's start function */
;;;1744   		if(psUsbClass->pfnStart)
00002c  6201              STR      r1,[r0,#0x20]
00002e  6869              LDR      r1,[r5,#4]
000030  2900              CMP      r1,#0
000032  d001              BEQ      |L16.56|
;;;1745   			psUsbClass->pfnStart(pVoid);
000034  4630              MOV      r0,r6
000036  4788              BLX      r1
                  |L16.56|
;;;1746   
;;;1747   		pDrvDevice->u8UsbConfiguration = pDrvDevice->au8Setup[2];
000038  7ca0              LDRB     r0,[r4,#0x12]
00003a  7660              STRB     r0,[r4,#0x19]
                  |L16.60|
00003c  2200              MOVS     r2,#0                 ;1736
00003e  4611              MOV      r1,r2                 ;1736
000040  4610              MOV      r0,r2                 ;1736
000042  f7fffffe          BL       DrvUSB_DataIn
;;;1748   
;;;1749   		DrvUSB_DataIn(0, NULL, 0);
;;;1750   	}
;;;1751   	else
;;;1752   	{
;;;1753   		/* Not support. Reply STALL */
;;;1754   		DrvUSB_ClrCtrlReadyAndTrigStall();
;;;1755   	}	
;;;1756   }
000046  bd70              POP      {r4-r6,pc}
                  |L16.72|
000048  210f              MOVS     r1,#0xf               ;1734
00004a  6201              STR      r1,[r0,#0x20]         ;1735
00004c  7662              STRB     r2,[r4,#0x19]         ;1735
00004e  e7f5              B        |L16.60|
                  |L16.80|
000050  f7fffffe          BL       DrvUSB_ClrCtrlReadyAndTrigStall
000054  bd70              POP      {r4-r6,pc}
;;;1757   
                          ENDP

000056  0000              DCW      0x0000
                  |L16.88|
                          DCD      ||.bss||+0xc0

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

                  DrvUSB_CtrlSetupSetInterface PROC
;;;1698   /*---------------------------------------------------------------------------------------------------------*/
;;;1699   void DrvUSB_CtrlSetupSetInterface(void * pVoid)
000000  b510              PUSH     {r4,lr}
;;;1700   {
;;;1701   	S_DRVUSB_DEVICE *pDrvDevice = &gsUsbDevice;
000002  4906              LDR      r1,|L17.28|
;;;1702   	S_DRVUSB_CLASS *psUsbClass = pDrvDevice->psUsbClass;
000004  6889              LDR      r1,[r1,#8]
;;;1703   	
;;;1704   	if(psUsbClass->pfnStart)
000006  6849              LDR      r1,[r1,#4]
000008  2900              CMP      r1,#0
00000a  d000              BEQ      |L17.14|
;;;1705   		psUsbClass->pfnStart(pVoid);
00000c  4788              BLX      r1
                  |L17.14|
;;;1706   
;;;1707   	DrvUSB_DataIn(0, NULL, 0);
00000e  2200              MOVS     r2,#0
000010  4611              MOV      r1,r2
000012  4610              MOV      r0,r2
000014  f7fffffe          BL       DrvUSB_DataIn
;;;1708   }
000018  bd10              POP      {r4,pc}
;;;1709   
                          ENDP

00001a  0000              DCW      0x0000
                  |L17.28|
                          DCD      ||.bss||+0xc0

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

                  DrvUSB_DataIn PROC
;;;480    /*---------------------------------------------------------------------------------------------------------*/
;;;481    int32_t DrvUSB_DataIn(uint32_t u32EpNum, const uint8_t * u8Buffer, uint32_t u32Size)
000000  b5f7              PUSH     {r0-r2,r4-r7,lr}
;;;482    {
000002  4615              MOV      r5,r2
;;;483    	S_DRVUSB_DEVICE *psDevice = &gsUsbDevice;
000004  4e1d              LDR      r6,|L18.124|
;;;484    	uint32_t u32EpId;
;;;485    	
;;;486    	u32EpId = DrvUSB_GetEpIdentity(u32EpNum, EP_INPUT);
000006  2180              MOVS     r1,#0x80
000008  f7fffffe          BL       DrvUSB_GetEpIdentity
00000c  4604              MOV      r4,r0
;;;487    	
;;;488    	if (u32Size > psDevice->sEpCrl[u32EpId].u32MaxPacketSize)
00000e  200c              MOVS     r0,#0xc
000010  4360              MULS     r0,r4,r0
000012  1987              ADDS     r7,r0,r6
000014  6bb8              LDR      r0,[r7,#0x38]
000016  42a8              CMP      r0,r5
000018  d201              BCS      |L18.30|
;;;489    		return E_DRVUSB_SIZE_TOO_LONG;
00001a  4819              LDR      r0,|L18.128|
;;;490    
;;;491    	
;;;492    	if (u8Buffer && u32Size)
;;;493    	{
;;;494    		WordsCpy(psDevice->sEpCrl[u32EpId].u8SramBuffer, (void *)u8Buffer, u32Size);
;;;495    	}
;;;496    	
;;;497    	_DRVUSB_SET_EP_BUF(u32EpId, (uint32_t)psDevice->sEpCrl[u32EpId].u8SramBuffer);
;;;498    	
;;;499    	if (u8Buffer == NULL && u32Size == 0)
;;;500    		psDevice->abData0[u32EpId] = 0;
;;;501    	else
;;;502    		psDevice->abData0[u32EpId] = !psDevice->abData0[u32EpId];
;;;503    	
;;;504    	_DRVUSB_SET_EP_TOG_BIT(u32EpId, psDevice->abData0[u32EpId]);
;;;505    	_DRVUSB_TRIG_EP(u32EpId, u32Size);
;;;506    
;;;507    	return 0;
;;;508    }
00001c  bdfe              POP      {r1-r7,pc}
                  |L18.30|
00001e  9801              LDR      r0,[sp,#4]            ;492
000020  2800              CMP      r0,#0                 ;492
000022  d006              BEQ      |L18.50|
000024  2d00              CMP      r5,#0                 ;492
000026  d004              BEQ      |L18.50|
000028  462a              MOV      r2,r5                 ;494
00002a  6bf8              LDR      r0,[r7,#0x3c]         ;494
00002c  9901              LDR      r1,[sp,#4]            ;494
00002e  f7fffffe          BL       WordsCpy
                  |L18.50|
000032  4914              LDR      r1,|L18.132|
000034  6bf8              LDR      r0,[r7,#0x3c]         ;497
000036  0122              LSLS     r2,r4,#4              ;497
000038  1841              ADDS     r1,r0,r1              ;497
00003a  4813              LDR      r0,|L18.136|
00003c  1810              ADDS     r0,r2,r0              ;497
00003e  6201              STR      r1,[r0,#0x20]         ;497
000040  9901              LDR      r1,[sp,#4]            ;499
000042  4329              ORRS     r1,r1,r5              ;499
000044  d00c              BEQ      |L18.96|
000046  00a1              LSLS     r1,r4,#2              ;502
000048  198a              ADDS     r2,r1,r6              ;502
00004a  6951              LDR      r1,[r2,#0x14]         ;502
00004c  2900              CMP      r1,#0                 ;502
00004e  d012              BEQ      |L18.118|
000050  2100              MOVS     r1,#0                 ;502
                  |L18.82|
000052  6151              STR      r1,[r2,#0x14]         ;504
000054  2900              CMP      r1,#0                 ;504
000056  d007              BEQ      |L18.104|
000058  6a81              LDR      r1,[r0,#0x28]         ;504
00005a  4a0c              LDR      r2,|L18.140|
00005c  4011              ANDS     r1,r1,r2              ;504
00005e  e006              B        |L18.110|
                  |L18.96|
000060  2100              MOVS     r1,#0                 ;500
000062  00a2              LSLS     r2,r4,#2              ;500
000064  1992              ADDS     r2,r2,r6              ;500
000066  6151              STR      r1,[r2,#0x14]         ;500
                  |L18.104|
000068  6a81              LDR      r1,[r0,#0x28]         ;504
00006a  2280              MOVS     r2,#0x80              ;504
00006c  4311              ORRS     r1,r1,r2              ;504
                  |L18.110|
00006e  6281              STR      r1,[r0,#0x28]         ;504
000070  6245              STR      r5,[r0,#0x24]         ;505
000072  2000              MOVS     r0,#0                 ;507
000074  bdfe              POP      {r1-r7,pc}
                  |L18.118|
000076  2101              MOVS     r1,#1                 ;502
000078  e7eb              B        |L18.82|
;;;509    
                          ENDP

00007a  0000              DCW      0x0000
                  |L18.124|
                          DCD      ||.bss||
                  |L18.128|
                          DCD      0xffff9903
                  |L18.132|
                          DCD      0xbff9ff00
                  |L18.136|
                          DCD      0x40060000
                  |L18.140|
                          DCD      0x0000037f

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

                  DrvUSB_DataOutTrigger PROC
;;;416    /*---------------------------------------------------------------------------------------------------------*/
;;;417    int32_t DrvUSB_DataOutTrigger(uint32_t u32EpNum, uint32_t u32Size)
000000  b530              PUSH     {r4,r5,lr}
;;;418    {
000002  460c              MOV      r4,r1
;;;419    	uint32_t u32EpId;
;;;420    	S_DRVUSB_DEVICE *psDevice = &gsUsbDevice;
000004  4d0a              LDR      r5,|L19.48|
;;;421    	
;;;422    	u32EpId = DrvUSB_GetEpIdentity(u32EpNum, EP_OUTPUT);
000006  2100              MOVS     r1,#0
000008  f7fffffe          BL       DrvUSB_GetEpIdentity
;;;423    	
;;;424    	if (u32Size > psDevice->sEpCrl[u32EpId].u32MaxPacketSize)
00000c  210c              MOVS     r1,#0xc
00000e  4341              MULS     r1,r0,r1
000010  194a              ADDS     r2,r1,r5
000012  6b91              LDR      r1,[r2,#0x38]
000014  42a1              CMP      r1,r4
000016  d201              BCS      |L19.28|
;;;425    		return E_DRVUSB_SIZE_TOO_LONG;
000018  4806              LDR      r0,|L19.52|
;;;426    
;;;427    		
;;;428    	_DRVUSB_SET_EP_BUF(u32EpId, (uint32_t)psDevice->sEpCrl[u32EpId].u8SramBuffer);
;;;429    	_DRVUSB_TRIG_EP(u32EpId, u32Size);
;;;430    	
;;;431    	return 0;
;;;432    }
00001a  bd30              POP      {r4,r5,pc}
                  |L19.28|
00001c  6bd1              LDR      r1,[r2,#0x3c]         ;428
00001e  4a06              LDR      r2,|L19.56|
000020  1889              ADDS     r1,r1,r2              ;428
000022  0102              LSLS     r2,r0,#4              ;428
000024  4805              LDR      r0,|L19.60|
000026  1810              ADDS     r0,r2,r0              ;428
000028  6201              STR      r1,[r0,#0x20]         ;428
00002a  6244              STR      r4,[r0,#0x24]         ;429
00002c  2000              MOVS     r0,#0                 ;431
00002e  bd30              POP      {r4,r5,pc}
;;;433    
                          ENDP

                  |L19.48|
                          DCD      ||.bss||
                  |L19.52|
                          DCD      0xffff9903
                  |L19.56|
                          DCD      0xbff9ff00
                  |L19.60|
                          DCD      0x40060000

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

                  DrvUSB_DisableRemoteWakeup PROC
;;;1016   /*---------------------------------------------------------------------------------------------------------*/
;;;1017   void DrvUSB_DisableRemoteWakeup(void)
000000  4801              LDR      r0,|L20.8|
;;;1018   {	
;;;1019   	gsUsbDevice.bRemoteWakeup = 0;
000002  2100              MOVS     r1,#0
000004  6001              STR      r1,[r0,#0]
;;;1020   }
000006  4770              BX       lr
;;;1021   
                          ENDP

                  |L20.8|
                          DCD      ||.bss||+0xc0

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

                  DrvUSB_DisableSelfPower PROC
;;;958    /*---------------------------------------------------------------------------------------------------------*/
;;;959    void DrvUSB_DisableSelfPower(void)
000000  4801              LDR      r0,|L21.8|
;;;960    {	
;;;961    	gsUsbDevice.bSelfPowered = 0; 
000002  2100              MOVS     r1,#0
000004  63c1              STR      r1,[r0,#0x3c]
;;;962    }
000006  4770              BX       lr
;;;963    
                          ENDP

                  |L21.8|
                          DCD      ||.bss||+0x80

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

                  DrvUSB_DisableUsb PROC
;;;1123   /*---------------------------------------------------------------------------------------------------------*/
;;;1124   void DrvUSB_DisableUsb(S_DRVUSB_DEVICE *psDevice)
000000  4802              LDR      r0,|L22.12|
;;;1125   {
;;;1126   	_DRVUSB_DISABLE_USB();	/* disable USB & PHY */
000002  6801              LDR      r1,[r0,#0]
000004  0849              LSRS     r1,r1,#1
000006  0049              LSLS     r1,r1,#1
000008  6001              STR      r1,[r0,#0]
;;;1127   }
00000a  4770              BX       lr
;;;1128   
                          ENDP

                  |L22.12|
                          DCD      0x40060000

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

                  DrvUSB_DispatchEPEvent PROC
;;;1425   /*---------------------------------------------------------------------------------------------------------*/
;;;1426   void DrvUSB_DispatchEPEvent(S_DRVUSB_DEVICE *psDevice)
000000  b5f8              PUSH     {r3-r7,lr}
;;;1427   {
;;;1428       int32_t i;
;;;1429   
;;;1430   	for (i=0;i<16;i++)
000002  2400              MOVS     r4,#0
;;;1431   	{
;;;1432   	    if ((psDevice->u16EPEventFlags >> i)&1)
;;;1433   	    {
;;;1434       		psDevice->u16EPEventFlags &= ~(1 << i);
000004  2701              MOVS     r7,#1
;;;1435       		/* Call the corresponding event handler. */
;;;1436       		if (g_sUsbOps[i].apfnCallback != 0)
000006  4e0b              LDR      r6,|L23.52|
000008  4605              MOV      r5,r0                 ;1432
00000a  35a0              ADDS     r5,r5,#0xa0           ;1432
                  |L23.12|
00000c  88e8              LDRH     r0,[r5,#6]            ;1432
00000e  4601              MOV      r1,r0                 ;1432
000010  40e1              LSRS     r1,r1,r4              ;1432
000012  07c9              LSLS     r1,r1,#31             ;1432
000014  d00a              BEQ      |L23.44|
000016  4639              MOV      r1,r7                 ;1432
000018  40a1              LSLS     r1,r1,r4              ;1434
00001a  4388              BICS     r0,r0,r1              ;1434
00001c  80e8              STRH     r0,[r5,#6]            ;1434
00001e  00e0              LSLS     r0,r4,#3
000020  5831              LDR      r1,[r6,r0]
000022  2900              CMP      r1,#0
000024  d002              BEQ      |L23.44|
;;;1437       		{
;;;1438       			g_sUsbOps[i].apfnCallback(g_sUsbOps[i].apCallbackArgu);
000026  1980              ADDS     r0,r0,r6
000028  6840              LDR      r0,[r0,#4]
00002a  4788              BLX      r1
                  |L23.44|
00002c  1c64              ADDS     r4,r4,#1              ;1430
00002e  2c10              CMP      r4,#0x10              ;1430
000030  dbec              BLT      |L23.12|
;;;1439       		} 		
;;;1440   		}
;;;1441   	}
;;;1442   }
000032  bdf8              POP      {r3-r7,pc}
;;;1443   
                          ENDP

                  |L23.52|
                          DCD      g_sUsbOps

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

                  DrvUSB_DispatchEvent PROC
;;;237    /*---------------------------------------------------------------------------------------------------------*/
;;;238    void DrvUSB_DispatchEvent(void)
000000  b510              PUSH     {r4,lr}
;;;239    {
;;;240    	DrvUSB_DispatchMiscEvent(&gsUsbDevice);
000002  4803              LDR      r0,|L24.16|
000004  f7fffffe          BL       DrvUSB_DispatchMiscEvent
;;;241    	DrvUSB_DispatchEPEvent(&gsUsbDevice);
000008  4801              LDR      r0,|L24.16|
00000a  f7fffffe          BL       DrvUSB_DispatchEPEvent
;;;242    }
00000e  bd10              POP      {r4,pc}
;;;243    
                          ENDP

                  |L24.16|
                          DCD      ||.bss||

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

                  DrvUSB_DispatchMiscEvent PROC
;;;1390   /*---------------------------------------------------------------------------------------------------------*/
;;;1391   void DrvUSB_DispatchMiscEvent(S_DRVUSB_DEVICE *psDevice)
000000  b5f8              PUSH     {r3-r7,lr}
;;;1392   {
;;;1393   	uint16_t u16MiscEventFlags;
;;;1394   	int32_t i;
;;;1395   	
;;;1396       u16MiscEventFlags = psDevice->u16MiscEventFlags;
000002  4605              MOV      r5,r0
000004  35a0              ADDS     r5,r5,#0xa0
000006  88ae              LDRH     r6,[r5,#4]
;;;1397   	for (i=0;i<6;i++)
;;;1398   	{
;;;1399   	    if (u16MiscEventFlags & (1 << i))
;;;1400   	    {	        
;;;1401   	        psDevice->u16MiscEventFlags &= ~(1 << i);
;;;1402   	    
;;;1403       		if (g_sBusOps[i].apfnCallback != 0)
000008  4f0a              LDR      r7,|L25.52|
00000a  2400              MOVS     r4,#0                 ;1397
                  |L25.12|
00000c  2001              MOVS     r0,#1                 ;1399
00000e  40a0              LSLS     r0,r0,r4              ;1399
000010  4601              MOV      r1,r0                 ;1399
000012  4231              TST      r1,r6                 ;1399
000014  d009              BEQ      |L25.42|
000016  88a9              LDRH     r1,[r5,#4]            ;1401
000018  4381              BICS     r1,r1,r0              ;1401
00001a  80a9              STRH     r1,[r5,#4]            ;1401
00001c  00e0              LSLS     r0,r4,#3
00001e  5839              LDR      r1,[r7,r0]
000020  2900              CMP      r1,#0
000022  d002              BEQ      |L25.42|
;;;1404       		{
;;;1405       			g_sBusOps[i].apfnCallback(g_sBusOps[i].apCallbackArgu);
000024  19c0              ADDS     r0,r0,r7
000026  6840              LDR      r0,[r0,#4]
000028  4788              BLX      r1
                  |L25.42|
00002a  1c64              ADDS     r4,r4,#1              ;1397
00002c  2c06              CMP      r4,#6                 ;1397
00002e  dbed              BLT      |L25.12|
;;;1406       		}
;;;1407   		}
;;;1408   	}	
;;;1409   }
000030  bdf8              POP      {r3-r7,pc}
;;;1410   
                          ENDP

000032  0000              DCW      0x0000
                  |L25.52|
                          DCD      g_sBusOps

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

                  DrvUSB_DispatchWakeupEvent PROC
;;;1371   /*---------------------------------------------------------------------------------------------------------*/
;;;1372   void DrvUSB_DispatchWakeupEvent(S_DRVUSB_DEVICE *psDevice)
000000  4770              BX       lr
;;;1373   {
;;;1374   
;;;1375   }
;;;1376   
                          ENDP


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

                  DrvUSB_EnableRemoteWakeup PROC
;;;997    /*---------------------------------------------------------------------------------------------------------*/
;;;998    void DrvUSB_EnableRemoteWakeup(void)
000000  4801              LDR      r0,|L27.8|
;;;999    {	
;;;1000   	gsUsbDevice.bRemoteWakeup = 1;	
000002  2101              MOVS     r1,#1
000004  6001              STR      r1,[r0,#0]
;;;1001   }
000006  4770              BX       lr
;;;1002   
                          ENDP

                  |L27.8|
                          DCD      ||.bss||+0xc0

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

                  DrvUSB_EnableSelfPower PROC
;;;939    /*---------------------------------------------------------------------------------------------------------*/
;;;940    void DrvUSB_EnableSelfPower (void)
000000  4801              LDR      r0,|L28.8|
;;;941    {	
;;;942        gsUsbDevice.bSelfPowered = 1; 
000002  2101              MOVS     r1,#1
000004  63c1              STR      r1,[r0,#0x3c]
;;;943    }
000006  4770              BX       lr
;;;944    
                          ENDP

                  |L28.8|
                          DCD      ||.bss||+0x80

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

                  DrvUSB_EnableUsb PROC
;;;1104   /*---------------------------------------------------------------------------------------------------------*/
;;;1105   void DrvUSB_EnableUsb(S_DRVUSB_DEVICE *psDevice)
000000  4802              LDR      r0,|L29.12|
;;;1106   {
;;;1107   	_DRVUSB_ENABLE_USB();	/* enable USB & PHY	*/
000002  6801              LDR      r1,[r0,#0]
000004  220f              MOVS     r2,#0xf
000006  4311              ORRS     r1,r1,r2
000008  6001              STR      r1,[r0,#0]
;;;1108   }
00000a  4770              BX       lr
;;;1109   
                          ENDP

                  |L29.12|
                          DCD      0x40060000

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

                  DrvUSB_GetEpId PROC
;;;386    /*---------------------------------------------------------------------------------------------------------*/
;;;387    int32_t DrvUSB_GetEpId(uint32_t u32EpNum)
000000  4602              MOV      r2,r0
;;;388    {
;;;389    	uint32_t i;
;;;390    	S_DRVUSB_DEVICE *psDevice =&gsUsbDevice;
000002  4906              LDR      r1,|L30.28|
;;;391    	
;;;392    	for ( i = 0; i < MAX_EP_ID; i++)
000004  2000              MOVS     r0,#0
                  |L30.6|
;;;393    	{
;;;394    		if (psDevice->sEpCrl[i].u32EpNum == u32EpNum)
000006  230c              MOVS     r3,#0xc
000008  4343              MULS     r3,r0,r3
00000a  185b              ADDS     r3,r3,r1
00000c  6b5b              LDR      r3,[r3,#0x34]
00000e  4293              CMP      r3,r2
000010  d003              BEQ      |L30.26|
000012  1c40              ADDS     r0,r0,#1              ;392
000014  2808              CMP      r0,#8                 ;392
000016  d3f6              BCC      |L30.6|
;;;395    			return i;
;;;396    	}
;;;397    	
;;;398    	return E_DRVUSB_INVALID_EP_NUM;	
000018  4801              LDR      r0,|L30.32|
                  |L30.26|
;;;399    }
00001a  4770              BX       lr
;;;400    
                          ENDP

                  |L30.28|
                          DCD      ||.bss||
                  |L30.32|
                          DCD      0xffff9902

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

                  DrvUSB_GetEpIdentity PROC
;;;352    /*---------------------------------------------------------------------------------------------------------*/
;;;353    int32_t DrvUSB_GetEpIdentity(uint32_t u32EpNum, uint32_t u32EpAttr)
000000  4603              MOV      r3,r0
;;;354    {
;;;355    	uint32_t i;
;;;356    
;;;357    	S_DRVUSB_DEVICE *psDevice =&gsUsbDevice;
000002  4a07              LDR      r2,|L31.32|
;;;358    	
;;;359    	for ( i = 0; i < MAX_EP_ID; i++)
000004  2000              MOVS     r0,#0
;;;360    	{
;;;361    		if (psDevice->sEpCrl[i].u32EpNum == (u32EpNum | u32EpAttr))
000006  430b              ORRS     r3,r3,r1
                  |L31.8|
000008  210c              MOVS     r1,#0xc
00000a  4341              MULS     r1,r0,r1
00000c  1889              ADDS     r1,r1,r2
00000e  6b49              LDR      r1,[r1,#0x34]
000010  4299              CMP      r1,r3
000012  d003              BEQ      |L31.28|
000014  1c40              ADDS     r0,r0,#1              ;359
000016  2808              CMP      r0,#8                 ;359
000018  d3f6              BCC      |L31.8|
;;;362    			return i;
;;;363    	}
;;;364    	
;;;365    	return E_DRVUSB_INVALID_EP_NUM;
00001a  4802              LDR      r0,|L31.36|
                  |L31.28|
;;;366    
;;;367    }
00001c  4770              BX       lr
;;;368    
                          ENDP

00001e  0000              DCW      0x0000
                  |L31.32|
                          DCD      ||.bss||
                  |L31.36|
                          DCD      0xffff9902

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

                  DrvUSB_GetFreeSRAM PROC
;;;920    /*---------------------------------------------------------------------------------------------------------*/
;;;921    uint32_t DrvUSB_GetFreeSRAM(void)
000000  4801              LDR      r0,|L32.8|
;;;922    {
;;;923    	return (uint32_t)g_UsbSramBase;
000002  6840              LDR      r0,[r0,#4]  ; g_UsbSramBase
;;;924    }
000004  4770              BX       lr
;;;925    
                          ENDP

000006  0000              DCW      0x0000
                  |L32.8|
                          DCD      ||.data||

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

                  DrvUSB_GetMaxPower PROC
;;;1085   /*---------------------------------------------------------------------------------------------------------*/
;;;1086   int32_t DrvUSB_GetMaxPower(void)
000000  4801              LDR      r0,|L33.8|
;;;1087   {	
;;;1088   	return ((int32_t) gsUsbDevice.u8MaxPower);
000002  7900              LDRB     r0,[r0,#4]
;;;1089   }
000004  4770              BX       lr
;;;1090   
                          ENDP

000006  0000              DCW      0x0000
                  |L33.8|
                          DCD      ||.bss||+0xc0

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

                  DrvUSB_GetOutData PROC
;;;450    /*---------------------------------------------------------------------------------------------------------*/
;;;451    uint8_t * DrvUSB_GetOutData(uint32_t u32EpNum, uint32_t *u32Size)
000000  b510              PUSH     {r4,lr}
;;;452    {
000002  460c              MOV      r4,r1
;;;453    	uint32_t u32EpId;
;;;454    	
;;;455    	u32EpId = DrvUSB_GetEpIdentity(u32EpNum, EP_OUTPUT);
000004  2100              MOVS     r1,#0
000006  f7fffffe          BL       DrvUSB_GetEpIdentity
;;;456    	*u32Size = _DRVUSB_GET_EP_DATA_SIZE(u32EpId);
00000a  4a06              LDR      r2,|L34.36|
00000c  0101              LSLS     r1,r0,#4
00000e  1889              ADDS     r1,r1,r2
000010  6a49              LDR      r1,[r1,#0x24]
000012  05c9              LSLS     r1,r1,#23
000014  0dc9              LSRS     r1,r1,#23
;;;457    
;;;458    	return sEpDescription[u32EpId].u8SramBuffer;
000016  6021              STR      r1,[r4,#0]
000018  210c              MOVS     r1,#0xc
00001a  4348              MULS     r0,r1,r0
00001c  4902              LDR      r1,|L34.40|
00001e  1840              ADDS     r0,r0,r1
000020  6880              LDR      r0,[r0,#8]
;;;459    }
000022  bd10              POP      {r4,pc}
;;;460    
                          ENDP

                  |L34.36|
                          DCD      0x40060000
                  |L34.40|
                          DCD      sEpDescription

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

                  DrvUSB_GetSetupBuffer PROC
;;;899    /*---------------------------------------------------------------------------------------------------------*/
;;;900    uint32_t DrvUSB_GetSetupBuffer(void)
000000  4801              LDR      r0,|L35.8|
;;;901    {
;;;902    	return (uint32_t)gsUsbDevice.sEpCrl[MAX_EP_ID].u8SramBuffer;
000002  69c0              LDR      r0,[r0,#0x1c]
;;;903    }
000004  4770              BX       lr
;;;904    
                          ENDP

000006  0000              DCW      0x0000
                  |L35.8|
                          DCD      ||.bss||+0x80

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

                  DrvUSB_GetUsbState PROC
;;;287    /*---------------------------------------------------------------------------------------------------------*/
;;;288    E_DRVUSB_STATE DrvUSB_GetUsbState(void)
000000  4801              LDR      r0,|L36.8|
;;;289    {
;;;290    	return (E_DRVUSB_STATE)gsUsbDevice.eUsbState;
000002  6a00              LDR      r0,[r0,#0x20]
000004  b2c0              UXTB     r0,r0
;;;291    }
000006  4770              BX       lr
;;;292    
                          ENDP

                  |L36.8|
                          DCD      ||.bss||+0x80

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

                  DrvUSB_GetVersion PROC
;;;42     /*---------------------------------------------------------------------------------------------------------*/
;;;43     uint32_t DrvUSB_GetVersion(void)
000000  4800              LDR      r0,|L37.4|
;;;44     {
;;;45     	return DRVUSB_VERSION_NUM;
;;;46     }
000002  4770              BX       lr
;;;47     
                          ENDP

                  |L37.4|
                          DCD      0x00010001

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

                  DrvUSB_Init PROC
;;;1457   /*---------------------------------------------------------------------------------------------------------*/
;;;1458   static int32_t DrvUSB_Init(void)
000000  4815              LDR      r0,|L38.88|
;;;1459   {
;;;1460   	uint32_t temp;
;;;1461   	volatile int32_t delay;
;;;1462    
;;;1463       /* Enable USB Clock */
;;;1464   	CLK->APBCLK_BITS.USBD_EN = 1;
000002  6881              LDR      r1,[r0,#8]
000004  0483              LSLS     r3,r0,#18
000006  4319              ORRS     r1,r1,r3
000008  6081              STR      r1,[r0,#8]
;;;1465   
;;;1466       /* Reset USB */
;;;1467   	GCR->IPRST_CTL2_BITS.USBD_RST = 1;
00000a  2205              MOVS     r2,#5
00000c  0712              LSLS     r2,r2,#28
00000e  68d0              LDR      r0,[r2,#0xc]
000010  4318              ORRS     r0,r0,r3
000012  60d0              STR      r0,[r2,#0xc]
;;;1468   	delay = 500;
000014  21ff              MOVS     r1,#0xff
000016  31f5              ADDS     r1,r1,#0xf5
                  |L38.24|
;;;1469   	while(delay--);
000018  4608              MOV      r0,r1
00001a  1e49              SUBS     r1,r1,#1
00001c  2800              CMP      r0,#0
00001e  d1fb              BNE      |L38.24|
;;;1470   	GCR->IPRST_CTL2_BITS.USBD_RST = 0;
000020  68d0              LDR      r0,[r2,#0xc]
000022  4398              BICS     r0,r0,r3
000024  60d0              STR      r0,[r2,#0xc]
;;;1471   
;;;1472   	USBD->CTRL = (CTRL_WAKEUPEN|CTRL_DPPUEN|CTRL_DRVSE0|CTRL_PWRDB|CTRL_PHYEN|CTRL_USBEN);
000026  4a0e              LDR      r2,|L38.96|
000028  480c              LDR      r0,|L38.92|
00002a  6010              STR      r0,[r2,#0]
;;;1473   	USBD->PDMA_BITS.BYTEM = 1;
00002c  480c              LDR      r0,|L38.96|
00002e  3080              ADDS     r0,r0,#0x80
000030  6a41              LDR      r1,[r0,#0x24]
000032  2304              MOVS     r3,#4
000034  4319              ORRS     r1,r1,r3
000036  6241              STR      r1,[r0,#0x24]
;;;1474   	_DRVUSB_ENABLE_USB();
000038  6810              LDR      r0,[r2,#0]
00003a  210f              MOVS     r1,#0xf
00003c  4308              ORRS     r0,r0,r1
00003e  6010              STR      r0,[r2,#0]
;;;1475   	_DRVUSB_ENABLE_SE0();	
000040  6810              LDR      r0,[r2,#0]
000042  2310              MOVS     r3,#0x10
000044  4318              ORRS     r0,r0,r3
000046  6010              STR      r0,[r2,#0]
;;;1476       temp = 0x100;
000048  1590              ASRS     r0,r2,#22
                  |L38.74|
;;;1477       while(temp--);   
00004a  1e40              SUBS     r0,r0,#1
00004c  d2fd              BCS      |L38.74|
;;;1478   	_DRVUSB_DISABLE_SE0();
00004e  6810              LDR      r0,[r2,#0]
000050  4398              BICS     r0,r0,r3
000052  6010              STR      r0,[r2,#0]
;;;1479   	
;;;1480   	return 0;
000054  2000              MOVS     r0,#0
;;;1481   }
000056  4770              BX       lr
;;;1482   
                          ENDP

                  |L38.88|
                          DCD      0x50000200
                  |L38.92|
                          DCD      0x0000021f
                  |L38.96|
                          DCD      0x40060000

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

                  DrvUSB_InstallClassDevice PROC
;;;570    /*---------------------------------------------------------------------------------------------------------*/
;;;571    void * DrvUSB_InstallClassDevice(S_DRVUSB_CLASS *sUsbClass)
000000  4902              LDR      r1,|L39.12|
;;;572    {
;;;573    	gsUsbDevice.psUsbClass = sUsbClass;
;;;574    
;;;575    	return &gsUsbDevice;
000002  6088              STR      r0,[r1,#8]
000004  4608              MOV      r0,r1
000006  38c0              SUBS     r0,r0,#0xc0
;;;576    }
000008  4770              BX       lr
;;;577    
                          ENDP

00000a  0000              DCW      0x0000
                  |L39.12|
                          DCD      ||.bss||+0xc0

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

                  DrvUSB_InstallCtrlHandler PROC
;;;596    /*---------------------------------------------------------------------------------------------------------*/
;;;597    int32_t DrvUSB_InstallCtrlHandler(void * *device, 
000000  b570              PUSH     {r4-r6,lr}
;;;598    				S_DRVUSB_CTRL_CALLBACK_ENTRY *psCtrlCallbackEntry,uint32_t u32RegCnt)
;;;599    {
;;;600    	S_DRVUSB_DEVICE *pDevice = (S_DRVUSB_DEVICE *)device;
;;;601    	S_DRVUSB_CTRL_CALLBACK_ENTRY *psEntry;
;;;602    	int i;
;;;603    
;;;604    	if (u32RegCnt == 0)
000002  2a00              CMP      r2,#0
000004  d018              BEQ      |L40.56|
;;;605    	{
;;;606    		return 0;
;;;607    	}
;;;608    
;;;609    	if (psCtrlCallbackEntry == 0)
000006  2900              CMP      r1,#0
000008  d006              BEQ      |L40.24|
;;;610    	{
;;;611    		return E_DRVUSB_NULL_POINTER;
;;;612    	}
;;;613    	
;;;614    	pDevice->pCtrlCallback = psCtrlCallbackEntry;
00000a  3080              ADDS     r0,r0,#0x80
;;;615    	pDevice->CtrlCallbackSize = u32RegCnt;
;;;616    	
;;;617    	for (i = 0; i < u32RegCnt; i++)
00000c  62c2              STR      r2,[r0,#0x2c]
00000e  2300              MOVS     r3,#0
;;;618    	{
;;;619    		psEntry = psCtrlCallbackEntry + i;
;;;620    		
;;;621    		if (psEntry->pfnCtrlDataInCallback == NULL)
;;;622    			psEntry->pfnCtrlDataInCallback = DrvUSB_CtrlDataInDefault;
000010  4c0a              LDR      r4,|L40.60|
;;;623    		if (psEntry->pfnCtrlDataOutCallback == NULL)
;;;624    			psEntry->pfnCtrlDataOutCallback = DrvUSB_CtrlDataOutDefault;
000012  4d0b              LDR      r5,|L40.64|
000014  6281              STR      r1,[r0,#0x28]         ;617
000016  e00d              B        |L40.52|
                  |L40.24|
000018  480a              LDR      r0,|L40.68|
;;;625    	}
;;;626    
;;;627    	return 0;
;;;628    }
00001a  bd70              POP      {r4-r6,pc}
                  |L40.28|
00001c  2014              MOVS     r0,#0x14              ;619
00001e  4358              MULS     r0,r3,r0              ;619
000020  1840              ADDS     r0,r0,r1              ;619
000022  6886              LDR      r6,[r0,#8]            ;621
000024  2e00              CMP      r6,#0                 ;621
000026  d100              BNE      |L40.42|
000028  6084              STR      r4,[r0,#8]            ;622
                  |L40.42|
00002a  68c6              LDR      r6,[r0,#0xc]          ;623
00002c  2e00              CMP      r6,#0                 ;623
00002e  d100              BNE      |L40.50|
000030  60c5              STR      r5,[r0,#0xc]          ;624
                  |L40.50|
000032  1c5b              ADDS     r3,r3,#1              ;617
                  |L40.52|
000034  4293              CMP      r3,r2                 ;617
000036  d3f1              BCC      |L40.28|
                  |L40.56|
000038  2000              MOVS     r0,#0                 ;627
00003a  bd70              POP      {r4-r6,pc}
;;;629    
                          ENDP

                  |L40.60|
                          DCD      DrvUSB_CtrlDataInDefault
                  |L40.64|
                          DCD      DrvUSB_CtrlDataOutDefault
                  |L40.68|
                          DCD      0xffff9901

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

                  DrvUSB_IsData0 PROC
;;;257    /*---------------------------------------------------------------------------------------------------------*/
;;;258    int32_t DrvUSB_IsData0(uint32_t u32EpId)
000000  4601              MOV      r1,r0
;;;259    {
;;;260    	int32_t bData0 = 0;
000002  2000              MOVS     r0,#0
;;;261    
;;;262    	if (u32EpId >= MAX_EP_ID)
000004  2908              CMP      r1,#8
000006  d203              BCS      |L41.16|
;;;263    	{
;;;264    		bData0 = 0;
;;;265    	}
;;;266    	else
;;;267    	{
;;;268    		bData0 = gsUsbDevice.abData0[u32EpId];
000008  0088              LSLS     r0,r1,#2
00000a  4902              LDR      r1,|L41.20|
00000c  1840              ADDS     r0,r0,r1
00000e  6940              LDR      r0,[r0,#0x14]
                  |L41.16|
;;;269    	}
;;;270    
;;;271    	return bData0;
;;;272    }
000010  4770              BX       lr
;;;273    
                          ENDP

000012  0000              DCW      0x0000
                  |L41.20|
                          DCD      ||.bss||

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

                  DrvUSB_IsRemoteWakeupEnabled PROC
;;;1036   /*---------------------------------------------------------------------------------------------------------*/
;;;1037   int32_t DrvUSB_IsRemoteWakeupEnabled(void)
000000  4801              LDR      r0,|L42.8|
;;;1038   {
;;;1039   	return gsUsbDevice.bRemoteWakeup;
000002  6800              LDR      r0,[r0,#0]
;;;1040   }
000004  4770              BX       lr
;;;1041   
                          ENDP

000006  0000              DCW      0x0000
                  |L42.8|
                          DCD      ||.bss||+0xc0

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

                  DrvUSB_IsSelfPowerEnabled PROC
;;;978    /*---------------------------------------------------------------------------------------------------------*/
;;;979    int32_t DrvUSB_IsSelfPowerEnabled(void)
000000  4801              LDR      r0,|L43.8|
;;;980    {
;;;981    	return gsUsbDevice.bSelfPowered;
000002  6bc0              LDR      r0,[r0,#0x3c]
;;;982    }
000004  4770              BX       lr
;;;983    
                          ENDP

000006  0000              DCW      0x0000
                  |L43.8|
                          DCD      ||.bss||+0x80

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

                  DrvUSB_Open PROC
;;;84     /*---------------------------------------------------------------------------------------------------------*/
;;;85     int32_t DrvUSB_Open(void * pVoid)
000000  b5f8              PUSH     {r3-r7,lr}
;;;86     {
000002  4604              MOV      r4,r0
;;;87     	uint32_t i, j;
;;;88     	uint8_t *p;
;;;89     
;;;90     	DrvUSB_Init();
000004  f7fffffe          BL       DrvUSB_Init
;;;91     
;;;92     	if (pVoid != NULL)
000008  2c00              CMP      r4,#0
00000a  d001              BEQ      |L44.16|
;;;93     		g_FnIntCallBack = (PFN_DRVUSB_INTCALLBACK)pVoid;
00000c  483f              LDR      r0,|L44.268|
00000e  6004              STR      r4,[r0,#0]  ; g_FnIntCallBack
                  |L44.16|
;;;94     
;;;95     	gsUsbDevice.u16MiscEventFlags = 0;
000010  483f              LDR      r0,|L44.272|
000012  2100              MOVS     r1,#0
000014  8081              STRH     r1,[r0,#4]
;;;96     	gsUsbDevice.u16EPEventFlags = 0;
000016  80c1              STRH     r1,[r0,#6]
;;;97     
;;;98     	p = (uint8_t *)USBD_SRAM_BASE;
;;;99     
;;;100    	/* for setup packet */
;;;101    	gsUsbDevice.sEpCrl[MAX_EP_ID].u32EpNum = 0x0;
000018  3820              SUBS     r0,r0,#0x20
00001a  9000              STR      r0,[sp,#0]
;;;102    	gsUsbDevice.sEpCrl[MAX_EP_ID].u32MaxPacketSize = 8;
00001c  6141              STR      r1,[r0,#0x14]
00001e  9800              LDR      r0,[sp,#0]
000020  2108              MOVS     r1,#8
000022  6181              STR      r1,[r0,#0x18]
;;;103    	gsUsbDevice.sEpCrl[MAX_EP_ID].u8SramBuffer = p;
;;;104    	p += 8;
000024  4b3b              LDR      r3,|L44.276|
000026  9800              LDR      r0,[sp,#0]            ;103
000028  4a3a              LDR      r2,|L44.276|
00002a  3308              ADDS     r3,r3,#8
;;;105    
;;;106    	i = 0;
00002c  2100              MOVS     r1,#0
;;;107    	while (sEpDescription[i].u32MaxPacketSize != 0)
00002e  61c2              STR      r2,[r0,#0x1c]
000030  e043              B        |L44.186|
                  |L44.50|
;;;108    	{	    
;;;109    	    /* There may be some EPs which have the same EP address. We will find them out here in order to use same buffer. */
;;;110    		for (j = 0; j < i; j++)
;;;111    		{
;;;112    			if ((sEpDescription[i].u32EpNum & 0xF) == (gsUsbDevice.sEpCrl[j].u32EpNum & 0xF))
000032  4c39              LDR      r4,|L44.280|
000034  2000              MOVS     r0,#0                 ;110
000036  58a4              LDR      r4,[r4,r2]
000038  e00d              B        |L44.86|
                  |L44.58|
00003a  260c              MOVS     r6,#0xc
00003c  4605              MOV      r5,r0
00003e  4375              MULS     r5,r6,r5
000040  4e33              LDR      r6,|L44.272|
000042  0727              LSLS     r7,r4,#28
000044  3ea0              SUBS     r6,r6,#0xa0
000046  19ad              ADDS     r5,r5,r6
000048  6b6d              LDR      r5,[r5,#0x34]
00004a  0f3f              LSRS     r7,r7,#28
00004c  072d              LSLS     r5,r5,#28
00004e  0f2d              LSRS     r5,r5,#28
000050  42af              CMP      r7,r5
000052  d002              BEQ      |L44.90|
000054  1c40              ADDS     r0,r0,#1              ;110
                  |L44.86|
000056  4288              CMP      r0,r1                 ;110
000058  d3ef              BCC      |L44.58|
                  |L44.90|
;;;113    				break;
;;;114    		}
;;;115    
;;;116    		gsUsbDevice.sEpCrl[i].u32EpNum = sEpDescription[i].u32EpNum;
00005a  4e2d              LDR      r6,|L44.272|
00005c  4f2e              LDR      r7,|L44.280|
00005e  3ea0              SUBS     r6,r6,#0xa0
000060  1995              ADDS     r5,r2,r6
000062  636c              STR      r4,[r5,#0x34]
000064  4664              MOV      r4,r12
;;;117    		gsUsbDevice.sEpCrl[i].u32MaxPacketSize = sEpDescription[i].u32MaxPacketSize;
000066  63ac              STR      r4,[r5,#0x38]
000068  4674              MOV      r4,lr
;;;118    
;;;119            /* Assign the transfer buffer */
;;;120    		if (sEpDescription[i].u8SramBuffer == NULL)
00006a  68a4              LDR      r4,[r4,#8]
00006c  2c00              CMP      r4,#0
00006e  d10c              BNE      |L44.138|
;;;121    		{		        
;;;122    			if (j < i)
000070  4288              CMP      r0,r1
000072  d205              BCS      |L44.128|
;;;123    			{
;;;124    			    /* Use the same buffer if they have the same EP address */
;;;125    				gsUsbDevice.sEpCrl[i].u8SramBuffer = gsUsbDevice.sEpCrl[j].u8SramBuffer;
000074  240c              MOVS     r4,#0xc
000076  4360              MULS     r0,r4,r0
000078  1980              ADDS     r0,r0,r6
00007a  6bc0              LDR      r0,[r0,#0x3c]
00007c  63e8              STR      r0,[r5,#0x3c]
00007e  e001              B        |L44.132|
                  |L44.128|
;;;126    			}
;;;127    			else
;;;128    			{
;;;129    			    /* Assign a new buffer */
;;;130    				gsUsbDevice.sEpCrl[i].u8SramBuffer = p;
;;;131    				p += sEpDescription[i].u32MaxPacketSize;
000080  63eb              STR      r3,[r5,#0x3c]
000082  4463              ADD      r3,r3,r12
                  |L44.132|
;;;132    			}
;;;133    		    /* Write back the assigned buffer */
;;;134    			sEpDescription[i].u8SramBuffer = gsUsbDevice.sEpCrl[i].u8SramBuffer;
000084  4670              MOV      r0,lr
000086  6bec              LDR      r4,[r5,#0x3c]
000088  6084              STR      r4,[r0,#8]
                  |L44.138|
;;;135    		}
;;;136    
;;;137    		if ((sEpDescription[i].u32EpNum & 0x1f) == 0)
00008a  58b8              LDR      r0,[r7,r2]
00008c  06c2              LSLS     r2,r0,#27
00008e  d003              BEQ      |L44.152|
;;;138    		{
;;;139                /* Only ctrl EP needs to support STALL auto clear */
;;;140    			CFG_EP_SETTING[i] = (EPTCFG_CSTALL | 
;;;141    						((sEpDescription[i].u32EpNum&EP_INPUT)?EPTCFG_IN:EPTCFG_OUT) 
;;;142    						| (sEpDescription[i].u32EpNum&0x0F));
;;;143    		}
;;;144    		else
;;;145    		{
;;;146    			CFG_EP_SETTING[i] = ((sEpDescription[i].u32EpNum&EP_INPUT)?EPTCFG_IN:EPTCFG_OUT) 
000090  0602              LSLS     r2,r0,#24
000092  d509              BPL      |L44.168|
000094  2240              MOVS     r2,#0x40
000096  e008              B        |L44.170|
                  |L44.152|
000098  0602              LSLS     r2,r0,#24             ;140
00009a  d501              BPL      |L44.160|
00009c  2240              MOVS     r2,#0x40              ;141
00009e  e000              B        |L44.162|
                  |L44.160|
0000a0  2220              MOVS     r2,#0x20              ;141
                  |L44.162|
0000a2  32ff              ADDS     r2,r2,#0xff           ;141
0000a4  3201              ADDS     r2,#1                 ;141
0000a6  e000              B        |L44.170|
                  |L44.168|
0000a8  2220              MOVS     r2,#0x20
                  |L44.170|
0000aa  0700              LSLS     r0,r0,#28
0000ac  0f00              LSRS     r0,r0,#28
0000ae  4302              ORRS     r2,r2,r0
0000b0  4817              LDR      r0,|L44.272|
0000b2  008c              LSLS     r4,r1,#2
0000b4  302c              ADDS     r0,r0,#0x2c
0000b6  5102              STR      r2,[r0,r4]
;;;147    						| (sEpDescription[i].u32EpNum&0x0F);
;;;148    		}
;;;149    		i++;
0000b8  1c49              ADDS     r1,r1,#1
                  |L44.186|
0000ba  200c              MOVS     r0,#0xc               ;107
0000bc  460a              MOV      r2,r1                 ;107
0000be  4c16              LDR      r4,|L44.280|
0000c0  4342              MULS     r2,r0,r2              ;107
0000c2  1910              ADDS     r0,r2,r4              ;107
0000c4  4686              MOV      lr,r0                 ;107
0000c6  6840              LDR      r0,[r0,#4]            ;107
0000c8  4684              MOV      r12,r0                ;107
0000ca  2800              CMP      r0,#0                 ;107
0000cc  d1b1              BNE      |L44.50|
;;;150    	}
;;;151    	
;;;152    	/* Update the remind buffer base */
;;;153    	g_UsbSramBase = p;
0000ce  480f              LDR      r0,|L44.268|
;;;154    
;;;155    	gsUsbDevice.eUsbState = eDRVUSB_DETACHED;
0000d0  6043              STR      r3,[r0,#4]  ; g_UsbSramBase
0000d2  9900              LDR      r1,[sp,#0]
0000d4  2000              MOVS     r0,#0
;;;156    	gsUsbDevice.u32FLDET = USBD->BUSSTS_BITS.FLDET;
0000d6  6208              STR      r0,[r1,#0x20]
0000d8  4810              LDR      r0,|L44.284|
0000da  6840              LDR      r0,[r0,#4]
0000dc  06c0              LSLS     r0,r0,#27
0000de  0fc1              LSRS     r1,r0,#31
0000e0  480b              LDR      r0,|L44.272|
0000e2  38a0              SUBS     r0,r0,#0xa0
;;;157    	DrvUSB_PreDispatchFDTEvent(&gsUsbDevice);
0000e4  60c1              STR      r1,[r0,#0xc]  ; gsUsbDevice
0000e6  f7fffffe          BL       DrvUSB_PreDispatchFDTEvent
;;;158    	DrvUSB_DispatchMiscEvent(&gsUsbDevice);
0000ea  4809              LDR      r0,|L44.272|
0000ec  38a0              SUBS     r0,r0,#0xa0
0000ee  f7fffffe          BL       DrvUSB_DispatchMiscEvent
0000f2  480b              LDR      r0,|L44.288|
0000f4  6801              LDR      r1,[r0,#0]
0000f6  0209              LSLS     r1,r1,#8
0000f8  0a09              LSRS     r1,r1,#8
0000fa  0742              LSLS     r2,r0,#29
0000fc  4311              ORRS     r1,r1,r2
0000fe  6001              STR      r1,[r0,#0]
000100  4908              LDR      r1,|L44.292|
000102  0a10              LSRS     r0,r2,#8
000104  6008              STR      r0,[r1,#0]
;;;159    
;;;160    	NVIC_SetPriority (USBD_IRQn, (1<<__NVIC_PRIO_BITS) - 2);
;;;161    	NVIC_EnableIRQ(USBD_IRQn);
;;;162    
;;;163    	return 0;
000106  2000              MOVS     r0,#0
;;;164    }
000108  bdf8              POP      {r3-r7,pc}
;;;165    
                          ENDP

00010a  0000              DCW      0x0000
                  |L44.268|
                          DCD      ||.data||
                  |L44.272|
                          DCD      ||.bss||+0xa0
                  |L44.276|
                          DCD      0x40060100
                  |L44.280|
                          DCD      sEpDescription
                  |L44.284|
                          DCD      0x40060000
                  |L44.288|
                          DCD      0xe000e414
                  |L44.292|
                          DCD      0xe000e100

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

                  DrvUSB_PreDispatchBusEvent PROC
;;;1204   /*---------------------------------------------------------------------------------------------------------*/
;;;1205   void DrvUSB_PreDispatchBusEvent(S_DRVUSB_DEVICE *psDevice)
000000  b570              PUSH     {r4-r6,lr}
;;;1206   {
;;;1207   	uint32_t u32BUSSTS = psDevice->u32BUSSTS;
;;;1208   
;;;1209   	if (psDevice->eUsbState == eDRVUSB_DETACHED)
000002  4601              MOV      r1,r0
000004  3180              ADDS     r1,r1,#0x80
000006  6a0b              LDR      r3,[r1,#0x20]
000008  6802              LDR      r2,[r0,#0]
00000a  2b00              CMP      r3,#0
00000c  d01e              BEQ      |L45.76|
;;;1210   	{
;;;1211   	    /* There should be something wrong */
;;;1212   		return;
;;;1213   	}
;;;1214   
;;;1215   	if (u32BUSSTS & BUSSTS_RESET)
00000e  07d4              LSLS     r4,r2,#31
;;;1216   	{
;;;1217   		/* Bus reset */
;;;1218   		_DRVUSB_ENABLE_USB(); /* enable USB & PHY */
000010  4b15              LDR      r3,|L45.104|
000012  250f              MOVS     r5,#0xf
;;;1219   		psDevice->eUsbState = eDRVUSB_DEFAULT;
;;;1220   		psDevice->u16MiscEventFlags |= DRVUSB_EVENT_FLAG_BUS_RESET;
000014  30a0              ADDS     r0,r0,#0xa0
000016  2c00              CMP      r4,#0                 ;1215
000018  d007              BEQ      |L45.42|
00001a  681a              LDR      r2,[r3,#0]            ;1218
00001c  432a              ORRS     r2,r2,r5              ;1218
00001e  601a              STR      r2,[r3,#0]            ;1218
000020  2207              MOVS     r2,#7                 ;1219
000022  620a              STR      r2,[r1,#0x20]
000024  8881              LDRH     r1,[r0,#4]
000026  2204              MOVS     r2,#4
000028  e00e              B        |L45.72|
                  |L45.42|
;;;1221   	}
;;;1222   	else if (u32BUSSTS & BUSSTS_SUSPEND)
00002a  0796              LSLS     r6,r2,#30
;;;1223   	{
;;;1224   		/* Bus suspend */
;;;1225   		_DRVUSB_DISABLE_PHY(); /* disable PHY */
;;;1226   		if (psDevice->eUsbState >= eDRVUSB_ATTACHED)
;;;1227   		{
;;;1228   			psDevice->eUsbState |= eDRVUSB_SUSPENDED;
00002c  2420              MOVS     r4,#0x20
00002e  2e00              CMP      r6,#0                 ;1222
000030  da0d              BGE      |L45.78|
000032  681a              LDR      r2,[r3,#0]            ;1225
000034  2502              MOVS     r5,#2                 ;1225
000036  43aa              BICS     r2,r2,r5              ;1225
000038  601a              STR      r2,[r3,#0]            ;1225
00003a  6a0a              LDR      r2,[r1,#0x20]         ;1226
00003c  2a01              CMP      r2,#1                 ;1226
00003e  db01              BLT      |L45.68|
000040  4322              ORRS     r2,r2,r4
000042  620a              STR      r2,[r1,#0x20]
                  |L45.68|
;;;1229   		}
;;;1230   		psDevice->u16MiscEventFlags |= DRVUSB_EVENT_FLAG_BUS_SUSPEND;
000044  8881              LDRH     r1,[r0,#4]
000046  2208              MOVS     r2,#8
                  |L45.72|
000048  4311              ORRS     r1,r1,r2              ;1220
00004a  8081              STRH     r1,[r0,#4]            ;1220
                  |L45.76|
;;;1231   
;;;1232   	}
;;;1233   	else if (u32BUSSTS & BUSSTS_RESUME)
;;;1234   	{
;;;1235   		/* Bus resume */
;;;1236   		_DRVUSB_ENABLE_USB(); /* enable PHY */
;;;1237   		if (psDevice->eUsbState >= eDRVUSB_ATTACHED)
;;;1238   		{
;;;1239   			psDevice->eUsbState &= ~eDRVUSB_SUSPENDED;
;;;1240   		}
;;;1241   		psDevice->u16MiscEventFlags |= DRVUSB_EVENT_FLAG_BUS_RESUME;
;;;1242   	}
;;;1243   }
00004c  bd70              POP      {r4-r6,pc}
                  |L45.78|
00004e  0752              LSLS     r2,r2,#29             ;1233
000050  d5fc              BPL      |L45.76|
000052  681a              LDR      r2,[r3,#0]            ;1236
000054  432a              ORRS     r2,r2,r5              ;1236
000056  601a              STR      r2,[r3,#0]            ;1236
000058  6a0a              LDR      r2,[r1,#0x20]         ;1237
00005a  2a01              CMP      r2,#1                 ;1237
00005c  db01              BLT      |L45.98|
00005e  43a2              BICS     r2,r2,r4              ;1239
000060  620a              STR      r2,[r1,#0x20]         ;1239
                  |L45.98|
000062  8881              LDRH     r1,[r0,#4]            ;1241
000064  2210              MOVS     r2,#0x10              ;1241
000066  e7ef              B        |L45.72|
;;;1244   
                          ENDP

                  |L45.104|
                          DCD      0x40060000

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

                  DrvUSB_PreDispatchEPEvent PROC
;;;1260   /*---------------------------------------------------------------------------------------------------------*/
;;;1261   void DrvUSB_PreDispatchEPEvent(S_DRVUSB_DEVICE *psDevice)
000000  b5fe              PUSH     {r1-r7,lr}
;;;1262   {
000002  4605              MOV      r5,r0
;;;1263   	uint32_t u32EpNum;
;;;1264   	uint32_t u32EpId;
;;;1265   	uint32_t u32INTSTS = psDevice->u32INTSTS;
000004  6900              LDR      r0,[r0,#0x10]
;;;1266   	uint32_t u32EPSTS = psDevice->u32EPSTS;
000006  6869              LDR      r1,[r5,#4]
;;;1267   	uint32_t u32EPSTS2 = psDevice->u32EPSTS2;
000008  9101              STR      r1,[sp,#4]
00000a  68a9              LDR      r1,[r5,#8]
;;;1268   	uint32_t u32PacketType;
;;;1269   	uint32_t u32ISOPacketType;
;;;1270   	int32_t i;
;;;1271   		
;;;1272   	if (psDevice->eUsbState == eDRVUSB_DETACHED)
00000c  9102              STR      r1,[sp,#8]
00000e  21a0              MOVS     r1,#0xa0
000010  5949              LDR      r1,[r1,r5]
000012  2900              CMP      r1,#0
000014  d078              BEQ      |L46.264|
;;;1273   	{
;;;1274   	    /* There should be something wrong. */
;;;1275   		return;
;;;1276   	}
;;;1277   
;;;1278   	/* Only care EP events and Setup event */
;;;1279   	u32INTSTS &= (INTSTS_EPTF0|INTSTS_EPTF1|INTSTS_EPTF2|INTSTS_EPTF3|INTSTS_EPTF4|INTSTS_EPTF5|INTSTS_EPTF6|INTSTS_EPTF7|INTSTS_SETUP);
000016  493d              LDR      r1,|L46.268|
;;;1280   
;;;1281   	if (u32INTSTS & INTSTS_SETUP)
;;;1282   	{
;;;1283   	    /* Record the event to procee it later */
;;;1284   		psDevice->u16MiscEventFlags |= DRVUSB_EVENT_FLAG_SETUP;
000018  462c              MOV      r4,r5
00001a  4008              ANDS     r0,r0,r1              ;1279
;;;1285   		
;;;1286   		/* Clear setup event flag */
;;;1287   		_DRVUSB_SET_EVENT_FLAG(INTSTS_SETUP);
;;;1288   		
;;;1289   		/* Assign the toggle bit for data phase */
;;;1290   		psDevice->abData0[0] = 1;
00001c  2201              MOVS     r2,#1
00001e  493c              LDR      r1,|L46.272|
000020  34a0              ADDS     r4,r4,#0xa0           ;1284
000022  2800              CMP      r0,#0                 ;1281
000024  da06              BGE      |L46.52|
000026  88a0              LDRH     r0,[r4,#4]            ;1284
000028  2320              MOVS     r3,#0x20              ;1284
00002a  4318              ORRS     r0,r0,r3              ;1284
00002c  80a0              STRH     r0,[r4,#4]            ;1284
00002e  0388              LSLS     r0,r1,#14             ;1287
000030  60c8              STR      r0,[r1,#0xc]          ;1287
000032  616a              STR      r2,[r5,#0x14]
                  |L46.52|
;;;1291   	}
;;;1292       
;;;1293   	u32INTSTS = USBD->INTSTS;
000034  4836              LDR      r0,|L46.272|
000036  68c1              LDR      r1,[r0,#0xc]
;;;1294   	USBD->INTSTS = (u32INTSTS & 0x00FF0000UL);
000038  23ff              MOVS     r3,#0xff
00003a  041b              LSLS     r3,r3,#16
00003c  9100              STR      r1,[sp,#0]
00003e  4019              ANDS     r1,r1,r3
000040  60c1              STR      r1,[r0,#0xc]
;;;1295   
;;;1296   	for (i=16;i<16+MAX_EP_ID;i++)
000042  2610              MOVS     r6,#0x10
                  |L46.68|
;;;1297   	{
;;;1298   	    if (u32INTSTS & (1 << i))
000044  2301              MOVS     r3,#1
000046  4618              MOV      r0,r3
000048  9900              LDR      r1,[sp,#0]
00004a  40b0              LSLS     r0,r0,r6
00004c  4208              TST      r0,r1
00004e  d058              BEQ      |L46.258|
;;;1299   	    {
;;;1300       		u32EpId = i - 16;
;;;1301   
;;;1302               /* Get the address of EP */
;;;1303       		u32EpNum = (_DRVUSB_GET_CFG(u32EpId) & 0xF);	
;;;1304       		
;;;1305       		if (u32EpId < 6)
;;;1306       			u32PacketType = ((u32EPSTS >> (8 + u32EpId * 4)) & 0xF);
;;;1307       		else
;;;1308       			u32PacketType = ((u32EPSTS2 >> ((u32EpId - 6) * 4)) & 0xF);
;;;1309       		
;;;1310       		if (u32PacketType == EPSTS_IN_ACK)
;;;1311       		{
;;;1312       			/* Set this EP event as non-handled. */
;;;1313                   psDevice->u16EPEventFlags |= (1 << (u32EpNum*2));
;;;1314       		}
;;;1315       		else if(u32PacketType == EPSTS_OUT0_ACK)
;;;1316       		{
;;;1317       			/* Set this EP event as non-handled. */
;;;1318       			psDevice->u16EPEventFlags |= (1 << (u32EpNum*2 + 1));
;;;1319       			
;;;1320       			/* Assign the toggle bit of data packet */
;;;1321       			psDevice->abData0[u32EpId] = 1;
;;;1322       		}
;;;1323       		else if(u32PacketType == EPSTS_OUT1_ACK)
;;;1324       		{
;;;1325       			/* Set this EP event as non-handled. */
;;;1326       			psDevice->u16EPEventFlags |= (1 << (u32EpNum*2 + 1));
;;;1327       			
;;;1328       			/* Assign the toggle bit of data packet */
;;;1329       			psDevice->abData0[u32EpId] = 0;
;;;1330       		}
;;;1331       		else if(u32PacketType == EPSTS_ISO)
;;;1332       		{
;;;1333       			u32ISOPacketType = (_DRVUSB_GET_CFG(u32EpId) & 0x60);
;;;1334                   
;;;1335                   psDevice->abData0[u32EpId] = 0;
;;;1336                   
;;;1337       			if (u32ISOPacketType == 0x20)
;;;1338       			{
;;;1339       			    /* This is isochronous out translation end. Call relative handler */
;;;1340       				if(g_sUsbOps[u32EpNum*2 + 1].apfnCallback != 0)
;;;1341       				{
;;;1342       					g_sUsbOps[u32EpNum*2 + 1].apfnCallback(g_sUsbOps[u32EpNum*2 + 1].apCallbackArgu);
;;;1343       				}
;;;1344       			}
;;;1345       			else if(u32ISOPacketType == 0x40)
;;;1346       			{
;;;1347       			    /* This is isochronous in translation end. Call relative handler */
;;;1348       				if (g_sUsbOps[u32EpNum*2].apfnCallback != 0)
;;;1349       				{
;;;1350       					g_sUsbOps[u32EpNum*2].apfnCallback(g_sUsbOps[u32EpNum*2].apCallbackArgu);
;;;1351       				}
;;;1352       			}
;;;1353       		}		
;;;1354   		}
;;;1355   	}
;;;1356   }
000050  0130              LSLS     r0,r6,#4
000052  4631              MOV      r1,r6                 ;1300
000054  38ff              SUBS     r0,r0,#0xff
000056  4a2e              LDR      r2,|L46.272|
000058  3910              SUBS     r1,r1,#0x10           ;1300
00005a  3801              SUBS     r0,#1
00005c  1880              ADDS     r0,r0,r2              ;1303
00005e  6a80              LDR      r0,[r0,#0x28]         ;1303
000060  0700              LSLS     r0,r0,#28             ;1303
000062  0f00              LSRS     r0,r0,#28             ;1303
000064  2906              CMP      r1,#6                 ;1305
000066  d203              BCS      |L46.112|
000068  008f              LSLS     r7,r1,#2              ;1306
00006a  3708              ADDS     r7,r7,#8              ;1306
00006c  9a01              LDR      r2,[sp,#4]            ;1306
00006e  e002              B        |L46.118|
                  |L46.112|
000070  008f              LSLS     r7,r1,#2              ;1308
000072  9a02              LDR      r2,[sp,#8]            ;1308
000074  3f18              SUBS     r7,r7,#0x18           ;1308
                  |L46.118|
000076  40fa              LSRS     r2,r2,r7              ;1308
000078  0712              LSLS     r2,r2,#28             ;1308
00007a  0f12              LSRS     r2,r2,#28             ;1308
00007c  d006              BEQ      |L46.140|
00007e  2a02              CMP      r2,#2                 ;1315
000080  d00a              BEQ      |L46.152|
000082  2a06              CMP      r2,#6                 ;1323
000084  d013              BEQ      |L46.174|
000086  2a07              CMP      r2,#7                 ;1331
000088  d01c              BEQ      |L46.196|
00008a  e03a              B        |L46.258|
                  |L46.140|
00008c  88e1              LDRH     r1,[r4,#6]            ;1313
00008e  0040              LSLS     r0,r0,#1              ;1313
000090  4083              LSLS     r3,r3,r0              ;1313
000092  4319              ORRS     r1,r1,r3              ;1313
000094  80e1              STRH     r1,[r4,#6]            ;1313
000096  e034              B        |L46.258|
                  |L46.152|
000098  0040              LSLS     r0,r0,#1              ;1318
00009a  1c40              ADDS     r0,r0,#1              ;1318
00009c  461f              MOV      r7,r3                 ;1318
00009e  88e2              LDRH     r2,[r4,#6]            ;1318
0000a0  4087              LSLS     r7,r7,r0              ;1318
0000a2  433a              ORRS     r2,r2,r7              ;1318
0000a4  0088              LSLS     r0,r1,#2              ;1321
0000a6  80e2              STRH     r2,[r4,#6]            ;1318
0000a8  1940              ADDS     r0,r0,r5              ;1321
0000aa  6143              STR      r3,[r0,#0x14]         ;1321
0000ac  e029              B        |L46.258|
                  |L46.174|
0000ae  0040              LSLS     r0,r0,#1              ;1326
0000b0  1c40              ADDS     r0,r0,#1              ;1326
0000b2  4083              LSLS     r3,r3,r0              ;1326
0000b4  88e2              LDRH     r2,[r4,#6]            ;1326
0000b6  2000              MOVS     r0,#0                 ;1329
0000b8  431a              ORRS     r2,r2,r3              ;1326
0000ba  0089              LSLS     r1,r1,#2              ;1329
0000bc  80e2              STRH     r2,[r4,#6]            ;1326
0000be  1949              ADDS     r1,r1,r5              ;1329
0000c0  6148              STR      r0,[r1,#0x14]         ;1329
0000c2  e01e              B        |L46.258|
                  |L46.196|
0000c4  4a12              LDR      r2,|L46.272|
0000c6  010b              LSLS     r3,r1,#4              ;1333
0000c8  189a              ADDS     r2,r3,r2              ;1333
0000ca  6a92              LDR      r2,[r2,#0x28]         ;1333
0000cc  2360              MOVS     r3,#0x60              ;1333
0000ce  401a              ANDS     r2,r2,r3              ;1333
0000d0  0089              LSLS     r1,r1,#2              ;1335
0000d2  2300              MOVS     r3,#0                 ;1335
0000d4  1949              ADDS     r1,r1,r5              ;1335
0000d6  614b              STR      r3,[r1,#0x14]         ;1337
0000d8  2a20              CMP      r2,#0x20              ;1337
0000da  d002              BEQ      |L46.226|
0000dc  2a40              CMP      r2,#0x40              ;1345
0000de  d008              BEQ      |L46.242|
0000e0  e00f              B        |L46.258|
                  |L46.226|
0000e2  0101              LSLS     r1,r0,#4              ;1340
0000e4  480b              LDR      r0,|L46.276|
0000e6  1808              ADDS     r0,r1,r0              ;1340
0000e8  6881              LDR      r1,[r0,#8]            ;1340
0000ea  2900              CMP      r1,#0                 ;1340
0000ec  d009              BEQ      |L46.258|
0000ee  68c0              LDR      r0,[r0,#0xc]          ;1342
0000f0  e006              B        |L46.256|
                  |L46.242|
0000f2  4a08              LDR      r2,|L46.276|
0000f4  0100              LSLS     r0,r0,#4              ;1348
0000f6  5811              LDR      r1,[r2,r0]            ;1348
0000f8  2900              CMP      r1,#0                 ;1348
0000fa  d002              BEQ      |L46.258|
0000fc  1880              ADDS     r0,r0,r2              ;1350
0000fe  6840              LDR      r0,[r0,#4]            ;1350
                  |L46.256|
000100  4788              BLX      r1                    ;1350
                  |L46.258|
000102  1c76              ADDS     r6,r6,#1              ;1296
000104  2e18              CMP      r6,#0x18              ;1296
000106  db9d              BLT      |L46.68|
                  |L46.264|
000108  bdfe              POP      {r1-r7,pc}
;;;1357   
                          ENDP

00010a  0000              DCW      0x0000
                  |L46.268|
                          DCD      0x80ff0000
                  |L46.272|
                          DCD      0x40060000
                  |L46.276|
                          DCD      g_sUsbOps

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

                  DrvUSB_PreDispatchEvent PROC
;;;179    /*---------------------------------------------------------------------------------------------------------*/
;;;180    void DrvUSB_PreDispatchEvent(void)
000000  b510              PUSH     {r4,lr}
;;;181    {
;;;182    	gsUsbDevice.u32INTSTS = _DRVUSB_GET_EVENT_FLAG();
000002  4914              LDR      r1,|L47.84|
000004  68c8              LDR      r0,[r1,#0xc]
000006  4a14              LDR      r2,|L47.88|
;;;183    
;;;184    	if (gsUsbDevice.u32INTSTS & INTSTS_WAKEUP)
000008  0703              LSLS     r3,r0,#28
00000a  6110              STR      r0,[r2,#0x10]  ; gsUsbDevice
00000c  d502              BPL      |L47.20|
;;;185    	{
;;;186    		/* Clear wakeup event. write one clear */
;;;187    		_DRVUSB_SET_EVENT_FLAG(INTSTS_WAKEUP);
00000e  2008              MOVS     r0,#8
000010  60c8              STR      r0,[r1,#0xc]
;;;188    
;;;189    		/* Pre-dispatch wakeup event. */
;;;190    		DrvUSB_PreDispatchWakeupEvent(&gsUsbDevice);
;;;191    	}
;;;192    	else if (gsUsbDevice.u32INTSTS & INTSTS_FLD)
;;;193    	{
;;;194    		gsUsbDevice.u32FLDET = USBD->BUSSTS_BITS.FLDET;
;;;195    		/* Clear float-detection event. Write one clear */
;;;196    		_DRVUSB_SET_EVENT_FLAG(INTSTS_FLD);
;;;197    
;;;198    		/* Pre-dispatch float-detection event. */
;;;199    		DrvUSB_PreDispatchFDTEvent(&gsUsbDevice);
;;;200    	}
;;;201    	else if (gsUsbDevice.u32INTSTS & INTSTS_BUS)
;;;202    	{
;;;203    		gsUsbDevice.u32BUSSTS = USBD->BUSSTS;
;;;204    		/* Clear bus event. Write one clear */
;;;205    		_DRVUSB_SET_EVENT_FLAG(INTSTS_BUS);
;;;206    		
;;;207    		/* Pre-dispatch bus event. */
;;;208    		DrvUSB_PreDispatchBusEvent(&gsUsbDevice);
;;;209    	}
;;;210    	else if (gsUsbDevice.u32INTSTS & INTSTS_USB)
;;;211    	{
;;;212    		gsUsbDevice.u32EPSTS = _DRVUSB_GET_EPSTS();
;;;213    		gsUsbDevice.u32EPSTS2 = USBD->EPSTS2;
;;;214    		
;;;215    		/* Clear USB events individually instead of in total.
;;;216    		   Otherwise, incoming USB events may be cleared mistakenly.
;;;217    		   Pre-dispatch USB event. */
;;;218    		DrvUSB_PreDispatchEPEvent(&gsUsbDevice);
;;;219    	}
;;;220    }
000012  bd10              POP      {r4,pc}
                  |L47.20|
000014  0743              LSLS     r3,r0,#29             ;192
000016  d509              BPL      |L47.44|
000018  6848              LDR      r0,[r1,#4]            ;194
00001a  06c0              LSLS     r0,r0,#27             ;194
00001c  0fc0              LSRS     r0,r0,#31             ;194
00001e  60d0              STR      r0,[r2,#0xc]          ;196  ; gsUsbDevice
000020  2004              MOVS     r0,#4                 ;196
000022  60c8              STR      r0,[r1,#0xc]          ;196
000024  480c              LDR      r0,|L47.88|
000026  f7fffffe          BL       DrvUSB_PreDispatchFDTEvent
00002a  bd10              POP      {r4,pc}
                  |L47.44|
00002c  07c3              LSLS     r3,r0,#31             ;201
00002e  d007              BEQ      |L47.64|
000030  6848              LDR      r0,[r1,#4]            ;203
000032  6010              STR      r0,[r2,#0]            ;205  ; gsUsbDevice
000034  2001              MOVS     r0,#1                 ;205
000036  60c8              STR      r0,[r1,#0xc]          ;205
000038  4807              LDR      r0,|L47.88|
00003a  f7fffffe          BL       DrvUSB_PreDispatchBusEvent
                  |L47.62|
00003e  bd10              POP      {r4,pc}
                  |L47.64|
000040  0780              LSLS     r0,r0,#30             ;210
000042  d5fc              BPL      |L47.62|
000044  6948              LDR      r0,[r1,#0x14]         ;212
000046  6050              STR      r0,[r2,#4]            ;213  ; gsUsbDevice
000048  69c8              LDR      r0,[r1,#0x1c]         ;213
00004a  6090              STR      r0,[r2,#8]            ;218  ; gsUsbDevice
00004c  4802              LDR      r0,|L47.88|
00004e  f7fffffe          BL       DrvUSB_PreDispatchEPEvent
000052  bd10              POP      {r4,pc}
;;;221    
                          ENDP

                  |L47.84|
                          DCD      0x40060000
                  |L47.88|
                          DCD      ||.bss||

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

                  DrvUSB_PreDispatchFDTEvent PROC
;;;1161   /*---------------------------------------------------------------------------------------------------------*/
;;;1162   void DrvUSB_PreDispatchFDTEvent(S_DRVUSB_DEVICE *psDevice)
000000  b510              PUSH     {r4,lr}
;;;1163   {
;;;1164   	/* Clear all pending events on USB attach/detach to
;;;1165   	   handle the scenario that the time sequence of event happening
;;;1166   	   is different from that of event handling. */
;;;1167   
;;;1168   	uint32_t u32FLDET = psDevice->u32FLDET;
;;;1169   	
;;;1170   	if (u32FLDET & 1)
000002  68c1              LDR      r1,[r0,#0xc]
;;;1171   	{
;;;1172   		/* attached */
;;;1173   		if (psDevice->eUsbState == eDRVUSB_DETACHED)
;;;1174   		{
;;;1175   			psDevice->eUsbState = eDRVUSB_ATTACHED;
;;;1176   			DrvUSB_EnableUsb(psDevice);
;;;1177   		}
;;;1178   
;;;1179   		psDevice->u16MiscEventFlags |= DRVUSB_EVENT_FLAG_ATTACH;
000004  4603              MOV      r3,r0
000006  07ca              LSLS     r2,r1,#31             ;1170
000008  4601              MOV      r1,r0                 ;1173
00000a  3180              ADDS     r1,r1,#0x80           ;1173
00000c  33a0              ADDS     r3,r3,#0xa0
00000e  2a00              CMP      r2,#0                 ;1170
000010  d00a              BEQ      |L48.40|
000012  6a0a              LDR      r2,[r1,#0x20]         ;1173
000014  2401              MOVS     r4,#1                 ;1175
000016  2a00              CMP      r2,#0                 ;1173
000018  d102              BNE      |L48.32|
00001a  620c              STR      r4,[r1,#0x20]         ;1176
00001c  f7fffffe          BL       DrvUSB_EnableUsb
                  |L48.32|
000020  8898              LDRH     r0,[r3,#4]
000022  4320              ORRS     r0,r0,r4
                  |L48.36|
000024  8098              STRH     r0,[r3,#4]
;;;1180   	}
;;;1181   	else
;;;1182   	{
;;;1183   		/* detached */
;;;1184   		psDevice->eUsbState = eDRVUSB_DETACHED;
;;;1185   		DrvUSB_DisableUsb(psDevice);
;;;1186   
;;;1187   		psDevice->u16MiscEventFlags |= DRVUSB_EVENT_FLAG_DETACH;
;;;1188   	}
;;;1189   }
000026  bd10              POP      {r4,pc}
                  |L48.40|
000028  2200              MOVS     r2,#0                 ;1184
00002a  620a              STR      r2,[r1,#0x20]         ;1185
00002c  f7fffffe          BL       DrvUSB_DisableUsb
000030  8898              LDRH     r0,[r3,#4]            ;1187
000032  2102              MOVS     r1,#2                 ;1187
000034  4308              ORRS     r0,r0,r1              ;1187
000036  e7f5              B        |L48.36|
;;;1190   
                          ENDP


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

                  DrvUSB_PreDispatchWakeupEvent PROC
;;;1142   /*---------------------------------------------------------------------------------------------------------*/
;;;1143   void DrvUSB_PreDispatchWakeupEvent(S_DRVUSB_DEVICE *psDevice)
000000  4770              BX       lr
;;;1144   {
;;;1145   
;;;1146   }
;;;1147   
                          ENDP


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

                  DrvUSB_Reset PROC
;;;819    /*---------------------------------------------------------------------------------------------------------*/
;;;820    void DrvUSB_Reset(uint32_t u32EpNum)
000000  b5f1              PUSH     {r0,r4-r7,lr}
;;;821    {
;;;822    	uint32_t u32EpId;
;;;823    	u32EpId = DrvUSB_GetEpIdentity(u32EpNum, EP_INPUT);
000002  2180              MOVS     r1,#0x80
000004  9800              LDR      r0,[sp,#0]
000006  f7fffffe          BL       DrvUSB_GetEpIdentity
;;;824    	
;;;825        if(u32EpId != E_DRVUSB_INVALID_EP_NUM)
00000a  4c0f              LDR      r4,|L50.72|
;;;826        {
;;;827    	    _DRVUSB_SET_CFG(u32EpId,  CFG_EP_SETTING[u32EpId]|EPTCFG_CLRRDY);
00000c  2601              MOVS     r6,#1
00000e  4d0f              LDR      r5,|L50.76|
000010  03f6              LSLS     r6,r6,#15
000012  4f0f              LDR      r7,|L50.80|
000014  42a0              CMP      r0,r4                 ;825
000016  d007              BEQ      |L50.40|
000018  0081              LSLS     r1,r0,#2
00001a  5869              LDR      r1,[r5,r1]
00001c  0102              LSLS     r2,r0,#4
00001e  4331              ORRS     r1,r1,r6
000020  480c              LDR      r0,|L50.84|
000022  4039              ANDS     r1,r1,r7
000024  1810              ADDS     r0,r2,r0
000026  6281              STR      r1,[r0,#0x28]
                  |L50.40|
;;;828        }
;;;829    
;;;830    	u32EpId = DrvUSB_GetEpIdentity(u32EpNum, EP_OUTPUT);
000028  2100              MOVS     r1,#0
00002a  9800              LDR      r0,[sp,#0]
00002c  f7fffffe          BL       DrvUSB_GetEpIdentity
;;;831    	
;;;832        if(u32EpId != E_DRVUSB_INVALID_EP_NUM)
000030  42a0              CMP      r0,r4
000032  d007              BEQ      |L50.68|
;;;833        {
;;;834    	    _DRVUSB_SET_CFG(u32EpId,  CFG_EP_SETTING[u32EpId]|EPTCFG_CLRRDY);
000034  0081              LSLS     r1,r0,#2
000036  5869              LDR      r1,[r5,r1]
000038  0102              LSLS     r2,r0,#4
00003a  4331              ORRS     r1,r1,r6
00003c  4805              LDR      r0,|L50.84|
00003e  4039              ANDS     r1,r1,r7
000040  1810              ADDS     r0,r2,r0
000042  6281              STR      r1,[r0,#0x28]
                  |L50.68|
;;;835        }
;;;836    }
000044  bdf8              POP      {r3-r7,pc}
;;;837    
                          ENDP

000046  0000              DCW      0x0000
                  |L50.72|
                          DCD      0xffff9902
                  |L50.76|
                          DCD      ||.bss||+0xcc
                  |L50.80|
                          DCD      0x000083ff
                  |L50.84|
                          DCD      0x40060000

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

                  DrvUSB_SetMaxPower PROC
;;;1057   /*---------------------------------------------------------------------------------------------------------*/
;;;1058   int32_t DrvUSB_SetMaxPower(uint32_t u32MaxPower)
000000  28fa              CMP      r0,#0xfa
;;;1059   {	
;;;1060   	
;;;1061   	if (u32MaxPower > 0xFA)
000002  d901              BLS      |L51.8|
;;;1062   	{
;;;1063   		return E_DRVUSB_VALUE_INVALID;
000004  4802              LDR      r0,|L51.16|
;;;1064   	}
;;;1065   	
;;;1066   	gsUsbDevice.u8MaxPower = (uint8_t)u32MaxPower;
;;;1067   	
;;;1068   	return 0;
;;;1069   }
000006  4770              BX       lr
                  |L51.8|
000008  4902              LDR      r1,|L51.20|
00000a  7108              STRB     r0,[r1,#4]            ;1066
00000c  2000              MOVS     r0,#0                 ;1068
00000e  4770              BX       lr
;;;1070   
                          ENDP

                  |L51.16|
                          DCD      0xffff9904
                  |L51.20|
                          DCD      ||.bss||+0xc0

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

                  DrvUSB_SetUsbState PROC
;;;306    /*---------------------------------------------------------------------------------------------------------*/
;;;307    void DrvUSB_SetUsbState(E_DRVUSB_STATE eUsbState)
000000  4901              LDR      r1,|L52.8|
;;;308    {
;;;309    	gsUsbDevice.eUsbState = eUsbState;
000002  6208              STR      r0,[r1,#0x20]
;;;310    }
000004  4770              BX       lr
;;;311    
                          ENDP

000006  0000              DCW      0x0000
                  |L52.8|
                          DCD      ||.bss||+0x80

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

                  DrvUSB_memcpy PROC
;;;1799   /*---------------------------------------------------------------------------------------------------------*/
;;;1800   void DrvUSB_memcpy(uint8_t *pi8Dest, uint8_t *pi8Src, uint32_t u32Size)
000000  b510              PUSH     {r4,lr}
;;;1801   {
;;;1802       int32_t i;
;;;1803       
;;;1804       for(i=0;i<u32Size;i++)
000002  2300              MOVS     r3,#0
000004  e002              B        |L53.12|
                  |L53.6|
;;;1805       {
;;;1806           pi8Dest[i] = pi8Src[i];
000006  5ccc              LDRB     r4,[r1,r3]
000008  54c4              STRB     r4,[r0,r3]
00000a  1c5b              ADDS     r3,r3,#1              ;1804
                  |L53.12|
00000c  4293              CMP      r3,r2                 ;1804
00000e  d3fa              BCC      |L53.6|
;;;1807       }
;;;1808   
;;;1809   }
000010  bd10              POP      {r4,pc}
                          ENDP


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

                  USBD_IRQHandler PROC
;;;61     /*---------------------------------------------------------------------------------------------------------*/
;;;62     void USBD_IRQHandler(void)
000000  b510              PUSH     {r4,lr}
;;;63     {
;;;64          DrvUSB_PreDispatchEvent();
000002  f7fffffe          BL       DrvUSB_PreDispatchEvent
;;;65          if (g_FnIntCallBack)
000006  4803              LDR      r0,|L54.20|
000008  6801              LDR      r1,[r0,#0]  ; g_FnIntCallBack
00000a  2900              CMP      r1,#0
00000c  d001              BEQ      |L54.18|
;;;66          	 g_FnIntCallBack((void *)&gsUsbDevice);
00000e  4802              LDR      r0,|L54.24|
000010  4788              BLX      r1
                  |L54.18|
;;;67     }
000012  bd10              POP      {r4,pc}
;;;68     
                          ENDP

                  |L54.20|
                          DCD      ||.data||
                  |L54.24|
                          DCD      ||.bss||

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

                  WordsCpy PROC
;;;16     
;;;17     void WordsCpy(void *dest, void *src, int32_t size)
000000  b510              PUSH     {r4,lr}
;;;18     {
;;;19         uint8_t *pu8Src, *pu8Dest;
;;;20         int32_t i;
;;;21         
;;;22         pu8Dest = (uint8_t *)dest;
;;;23         pu8Src  = (uint8_t *)src;
;;;24         
;;;25         for(i=0;i<size;i++)
000002  2300              MOVS     r3,#0
000004  e002              B        |L55.12|
                  |L55.6|
;;;26             pu8Dest[i] = pu8Src[i]; 
000006  5ccc              LDRB     r4,[r1,r3]
000008  54c4              STRB     r4,[r0,r3]
00000a  1c5b              ADDS     r3,r3,#1              ;25
                  |L55.12|
00000c  4293              CMP      r3,r2                 ;25
00000e  dbfa              BLT      |L55.6|
;;;27     }
000010  bd10              POP      {r4,pc}
;;;28     
                          ENDP


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

                  gsUsbDevice
                          %        204
                  CFG_EP_SETTING
                          %        32

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

                  g_FnIntCallBack
                          DCD      0x00000000
                  g_UsbSramBase
                          DCD      0x00000000
