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

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

                  HID_Close PROC
;;;145    
;;;146    void HID_Close(void)
000000  4770              BX       lr
;;;147    {
;;;148    
;;;149    }
;;;150    
                          ENDP


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

                  HID_CtrlGetDescriptorIn PROC
;;;515    
;;;516    void HID_CtrlGetDescriptorIn(void * pVoid)
000000  b570              PUSH     {r4-r6,lr}
;;;517    {
000002  4605              MOV      r5,r0
;;;518        uint32_t u32Len;
;;;519    
;;;520    
;;;521        DBG_PRINTF(" >>> 0x%08x %d size.\n", gpu8UsbBuf, gu32BytesInUsbBuf);
;;;522    	
;;;523        if(gpu8UsbBuf)
000004  481e              LDR      r0,|L2.128|
000006  6800              LDR      r0,[r0,#0]  ; gpu8UsbBuf
000008  2800              CMP      r0,#0
00000a  d034              BEQ      |L2.118|
;;;524        {
;;;525    
;;;526            if(gu32BytesInUsbBuf == 0)
00000c  481d              LDR      r0,|L2.132|
00000e  6800              LDR      r0,[r0,#0]  ; gu32BytesInUsbBuf
000010  2800              CMP      r0,#0
000012  d109              BNE      |L2.40|
;;;527            {
;;;528                /* Zero packet */
;;;529        		DrvUSB_DataIn(0, gpu8UsbBuf, 0);
000014  2200              MOVS     r2,#0
000016  481a              LDR      r0,|L2.128|
000018  6801              LDR      r1,[r0,#0]  ; gpu8UsbBuf
00001a  4610              MOV      r0,r2
00001c  f7fffffe          BL       DrvUSB_DataIn
;;;530        		gpu8UsbBuf = 0;
000020  2000              MOVS     r0,#0
000022  4917              LDR      r1,|L2.128|
000024  6008              STR      r0,[r1,#0]  ; gpu8UsbBuf
000026  e029              B        |L2.124|
                  |L2.40|
;;;531            }
;;;532            else
;;;533            {
;;;534                u32Len = Minimum(gu32BytesInUsbBuf, HID_MAX_PACKET_SIZE_CTRL);
000028  4916              LDR      r1,|L2.132|
00002a  6809              LDR      r1,[r1,#0]  ; gu32BytesInUsbBuf
00002c  b288              UXTH     r0,r1
00002e  2108              MOVS     r1,#8
000030  f7fffffe          BL       Minimum
000034  4604              MOV      r4,r0
;;;535        		DrvUSB_DataIn(0, gpu8UsbBuf, u32Len);
000036  4622              MOV      r2,r4
000038  4811              LDR      r0,|L2.128|
00003a  6801              LDR      r1,[r0,#0]  ; gpu8UsbBuf
00003c  2000              MOVS     r0,#0
00003e  f7fffffe          BL       DrvUSB_DataIn
;;;536        		gpu8UsbBuf += u32Len;
000042  480f              LDR      r0,|L2.128|
000044  6800              LDR      r0,[r0,#0]  ; gpu8UsbBuf
000046  1900              ADDS     r0,r0,r4
000048  490d              LDR      r1,|L2.128|
00004a  6008              STR      r0,[r1,#0]  ; gpu8UsbBuf
;;;537        		gu32BytesInUsbBuf -= u32Len;
00004c  480d              LDR      r0,|L2.132|
00004e  6800              LDR      r0,[r0,#0]  ; gu32BytesInUsbBuf
000050  1b00              SUBS     r0,r0,r4
000052  490c              LDR      r1,|L2.132|
000054  6008              STR      r0,[r1,#0]  ; gu32BytesInUsbBuf
;;;538        		
;;;539        		if(gu32BytesInUsbBuf == 0)
000056  4608              MOV      r0,r1
000058  6800              LDR      r0,[r0,#0]  ; gu32BytesInUsbBuf
00005a  2800              CMP      r0,#0
00005c  d10e              BNE      |L2.124|
;;;540        		{
;;;541                    if(u32Len < HID_MAX_PACKET_SIZE_CTRL)
00005e  2c08              CMP      r4,#8
000060  d202              BCS      |L2.104|
;;;542                    {
;;;543                        /* This should be last IN packet due to it is less than UAC_MAX_PACKET_SIZE_EP0 */
;;;544                        gpu8UsbBuf = 0;
000062  4907              LDR      r1,|L2.128|
000064  6008              STR      r0,[r1,#0]  ; gpu8UsbBuf
000066  e009              B        |L2.124|
                  |L2.104|
;;;545                    }
;;;546                    else
;;;547                    {
;;;548                        if(!gIsOverRequest)
000068  4807              LDR      r0,|L2.136|
00006a  7800              LDRB     r0,[r0,#0]  ; gIsOverRequest
00006c  2800              CMP      r0,#0
00006e  d105              BNE      |L2.124|
;;;549                        {
;;;550        		            /* This should be the last IN packet because there is no more data to 
;;;551                               transfer and it is not over request transfer */
;;;552                            gpu8UsbBuf = 0;
000070  4903              LDR      r1,|L2.128|
000072  6008              STR      r0,[r1,#0]  ; gpu8UsbBuf
000074  e002              B        |L2.124|
                  |L2.118|
;;;553                        }
;;;554                     }
;;;555                }
;;;556        		
;;;557            }
;;;558        }
;;;559        else
;;;560        {
;;;561      	    /* The EP id 1 should always be used as control (OUT) endpoint */
;;;562    		_DRVUSB_TRIG_EP(1,0x00);
000076  2000              MOVS     r0,#0
000078  4904              LDR      r1,|L2.140|
00007a  6348              STR      r0,[r1,#0x34]
                  |L2.124|
;;;563        }
;;;564    }
00007c  bd70              POP      {r4-r6,pc}
;;;565    
                          ENDP

00007e  0000              DCW      0x0000
                  |L2.128|
                          DCD      gpu8UsbBuf
                  |L2.132|
                          DCD      gu32BytesInUsbBuf
                  |L2.136|
                          DCD      gIsOverRequest
                  |L2.140|
                          DCD      0x40060000

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

                  HID_CtrlGetDescriptorOut PROC
;;;508    
;;;509    void HID_CtrlGetDescriptorOut(void * pVoid)
000000  2100              MOVS     r1,#0
;;;510    {
;;;511        gu32BytesInUsbBuf = 0;
000002  4a03              LDR      r2,|L3.16|
000004  6011              STR      r1,[r2,#0]  ; gu32BytesInUsbBuf
;;;512        gpu8UsbBuf = 0;
000006  4a03              LDR      r2,|L3.20|
000008  6011              STR      r1,[r2,#0]  ; gpu8UsbBuf
;;;513        gIsOverRequest = 0;
00000a  4a03              LDR      r2,|L3.24|
00000c  7011              STRB     r1,[r2,#0]
;;;514    }
00000e  4770              BX       lr
;;;515    
                          ENDP

                  |L3.16|
                          DCD      gu32BytesInUsbBuf
                  |L3.20|
                          DCD      gpu8UsbBuf
                  |L3.24|
                          DCD      gIsOverRequest

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

                  HID_CtrlSetupGetDescriptor PROC
;;;582    /*************************************************************************/
;;;583    void HID_CtrlSetupGetDescriptor(void * pVoid)
000000  b5f8              PUSH     {r3-r7,lr}
;;;584    {
000002  4605              MOV      r5,r0
;;;585    	S_HID_DEVICE *psDevice = (S_HID_DEVICE *) pVoid;
000004  462f              MOV      r7,r5
;;;586    	S_DRVUSB_DEVICE *pUsbDevice = (S_DRVUSB_DEVICE *)psDevice->device;
000006  6b3c              LDR      r4,[r7,#0x30]
;;;587    	uint16_t u16Len;
;;;588    
;;;589    	u16Len = 0;
000008  2600              MOVS     r6,#0
;;;590    	u16Len = pUsbDevice->au8Setup[7];
00000a  20b7              MOVS     r0,#0xb7
00000c  5d06              LDRB     r6,[r0,r4]
;;;591    	u16Len <<= 8;
00000e  0236              LSLS     r6,r6,#8
;;;592    	u16Len += pUsbDevice->au8Setup[6];
000010  20b6              MOVS     r0,#0xb6
000012  5d00              LDRB     r0,[r0,r4]
000014  1980              ADDS     r0,r0,r6
000016  b286              UXTH     r6,r0
;;;593    	
;;;594    	gIsOverRequest = 0;
000018  2000              MOVS     r0,#0
00001a  4939              LDR      r1,|L4.256|
00001c  7008              STRB     r0,[r1,#0]
;;;595    	gu32BytesInUsbBuf = 0;
00001e  4939              LDR      r1,|L4.260|
000020  6008              STR      r0,[r1,#0]  ; gu32BytesInUsbBuf
;;;596    	gpu8UsbBuf = 0;
000022  4939              LDR      r1,|L4.264|
000024  6008              STR      r0,[r1,#0]  ; gpu8UsbBuf
;;;597    	switch (pUsbDevice->au8Setup[3])
000026  20b3              MOVS     r0,#0xb3
000028  5d00              LDRB     r0,[r0,r4]
00002a  2803              CMP      r0,#3
00002c  d02e              BEQ      |L4.140|
00002e  dc04              BGT      |L4.58|
000030  2801              CMP      r0,#1
000032  d007              BEQ      |L4.68|
000034  2802              CMP      r0,#2
000036  d15d              BNE      |L4.244|
000038  e00f              B        |L4.90|
                  |L4.58|
00003a  2821              CMP      r0,#0x21
00003c  d016              BEQ      |L4.108|
00003e  2822              CMP      r0,#0x22
000040  d158              BNE      |L4.244|
000042  e01b              B        |L4.124|
                  |L4.68|
;;;598    	{
;;;599    		// Get Device Descriptor
;;;600    	case DESC_DEVICE:
;;;601    	{
;;;602            HID_PrepareDescriptors(g_HID_sDevice.au8DeviceDescriptor, LEN_DEVICE, u16Len, HID_MAX_PACKET_SIZE_CTRL);
000044  4931              LDR      r1,|L4.268|
000046  2308              MOVS     r3,#8
000048  4632              MOV      r2,r6
00004a  68c8              LDR      r0,[r1,#0xc]  ; g_HID_sDevice
00004c  2112              MOVS     r1,#0x12
00004e  f7fffffe          BL       HID_PrepareDescriptors
;;;603    
;;;604    	    /* Prepare the OUT to avoid HOST stop data phase without all data transfered. */
;;;605    		_DRVUSB_TRIG_EP(1,0x00);
000052  2000              MOVS     r0,#0
000054  492e              LDR      r1,|L4.272|
000056  6348              STR      r0,[r1,#0x34]
;;;606    
;;;607    		break;
000058  e04f              B        |L4.250|
                  |L4.90|
;;;608    	}
;;;609    
;;;610    	// Get Configuration Descriptor
;;;611    	case DESC_CONFIG:
;;;612    	{	
;;;613            HID_PrepareDescriptors(g_HID_sDevice.au8ConfigDescriptor, g_HID_au8ConfigDescriptor[2], u16Len, HID_MAX_PACKET_SIZE_CTRL);
00005a  4a2e              LDR      r2,|L4.276|
00005c  7891              LDRB     r1,[r2,#2]  ; g_HID_au8ConfigDescriptor
00005e  4a2b              LDR      r2,|L4.268|
000060  2308              MOVS     r3,#8
000062  6910              LDR      r0,[r2,#0x10]  ; g_HID_sDevice
000064  4632              MOV      r2,r6
000066  f7fffffe          BL       HID_PrepareDescriptors
;;;614    		break;
00006a  e046              B        |L4.250|
                  |L4.108|
;;;615        }
;;;616    		// Get HID Descriptor
;;;617    	case DESC_HID:
;;;618        {
;;;619            HID_PrepareDescriptors(g_HID_sDevice.pu8HIDDescriptor, LEN_HID, u16Len, HID_MAX_PACKET_SIZE_CTRL);
00006c  4927              LDR      r1,|L4.268|
00006e  2308              MOVS     r3,#8
000070  4632              MOV      r2,r6
000072  6a08              LDR      r0,[r1,#0x20]  ; g_HID_sDevice
000074  2109              MOVS     r1,#9
000076  f7fffffe          BL       HID_PrepareDescriptors
;;;620    		break;
00007a  e03e              B        |L4.250|
                  |L4.124|
;;;621        }
;;;622    		// Get Report Descriptor
;;;623    	case DESC_HID_RPT:
;;;624    	{
;;;625            HID_PrepareDescriptors(g_HID_sDevice.pu8ReportDescriptor, g_HID_sDevice.u32ReportDescriptorSize, u16Len, HID_MAX_PACKET_SIZE_CTRL);
00007c  4a23              LDR      r2,|L4.268|
00007e  69d1              LDR      r1,[r2,#0x1c]  ; g_HID_sDevice
000080  2308              MOVS     r3,#8
000082  6990              LDR      r0,[r2,#0x18]  ; g_HID_sDevice
000084  4632              MOV      r2,r6
000086  f7fffffe          BL       HID_PrepareDescriptors
;;;626    		break;
00008a  e036              B        |L4.250|
                  |L4.140|
;;;627        }
;;;628    		// Get String Descriptor
;;;629    	case DESC_STRING:
;;;630    	{
;;;631    		// Get Language
;;;632    		if (pUsbDevice->au8Setup[2] == 0)
00008c  20b2              MOVS     r0,#0xb2
00008e  5d00              LDRB     r0,[r0,r4]
000090  2800              CMP      r0,#0
000092  d106              BNE      |L4.162|
;;;633    		{
;;;634                HID_PrepareDescriptors(g_HID_au8StringLang, 4, u16Len, HID_MAX_PACKET_SIZE_CTRL);
000094  2308              MOVS     r3,#8
000096  4632              MOV      r2,r6
000098  2104              MOVS     r1,#4
00009a  481f              LDR      r0,|L4.280|
00009c  f7fffffe          BL       HID_PrepareDescriptors
0000a0  e027              B        |L4.242|
                  |L4.162|
;;;635    		}
;;;636    		else
;;;637    		{
;;;638    			// Get String Descriptor
;;;639    			switch (pUsbDevice->au8Setup[2])
0000a2  20b2              MOVS     r0,#0xb2
0000a4  5d00              LDRB     r0,[r0,r4]
0000a6  2801              CMP      r0,#1
0000a8  d004              BEQ      |L4.180|
0000aa  2802              CMP      r0,#2
0000ac  d00c              BEQ      |L4.200|
0000ae  2803              CMP      r0,#3
0000b0  d11b              BNE      |L4.234|
0000b2  e013              B        |L4.220|
                  |L4.180|
;;;640    			{
;;;641    			case 1:
;;;642                    HID_PrepareDescriptors((const uint8_t *)g_HID_sDevice.sVendorInfo.psVendorStringDesc, g_HID_sDevice.sVendorInfo.psVendorStringDesc->byLength, u16Len, HID_MAX_PACKET_SIZE_CTRL);
0000b4  4a15              LDR      r2,|L4.268|
0000b6  6852              LDR      r2,[r2,#4]  ; g_HID_sDevice
0000b8  7811              LDRB     r1,[r2,#0]
0000ba  4a14              LDR      r2,|L4.268|
0000bc  2308              MOVS     r3,#8
0000be  6850              LDR      r0,[r2,#4]  ; g_HID_sDevice
0000c0  4632              MOV      r2,r6
0000c2  f7fffffe          BL       HID_PrepareDescriptors
;;;643    				break;
0000c6  e013              B        |L4.240|
                  |L4.200|
;;;644    
;;;645    			case 2:
;;;646                    HID_PrepareDescriptors((const uint8_t *)g_HID_sDevice.sVendorInfo.psProductStringDesc, g_HID_sDevice.sVendorInfo.psProductStringDesc->byLength, u16Len, HID_MAX_PACKET_SIZE_CTRL);
0000c8  4a10              LDR      r2,|L4.268|
0000ca  6892              LDR      r2,[r2,#8]  ; g_HID_sDevice
0000cc  7811              LDRB     r1,[r2,#0]
0000ce  4a0f              LDR      r2,|L4.268|
0000d0  2308              MOVS     r3,#8
0000d2  6890              LDR      r0,[r2,#8]  ; g_HID_sDevice
0000d4  4632              MOV      r2,r6
0000d6  f7fffffe          BL       HID_PrepareDescriptors
;;;647                   
;;;648     				break;
0000da  e009              B        |L4.240|
                  |L4.220|
;;;649    
;;;650    			case 3:
;;;651                    HID_PrepareDescriptors(g_HID_au8StringSerial, g_HID_au8StringSerial[0], u16Len, HID_MAX_PACKET_SIZE_CTRL);
0000dc  480f              LDR      r0,|L4.284|
0000de  7801              LDRB     r1,[r0,#0]  ; g_HID_au8StringSerial
0000e0  2308              MOVS     r3,#8
0000e2  4632              MOV      r2,r6
0000e4  f7fffffe          BL       HID_PrepareDescriptors
;;;652    				break;
0000e8  e002              B        |L4.240|
                  |L4.234|
;;;653    
;;;654    			default:
;;;655    				/* Not support. Reply STALL. */
;;;656    				DrvUSB_ClrCtrlReadyAndTrigStall();
0000ea  f7fffffe          BL       DrvUSB_ClrCtrlReadyAndTrigStall
0000ee  bf00              NOP                            ;639
                  |L4.240|
0000f0  bf00              NOP                            ;643
                  |L4.242|
;;;657    			}
;;;658    		}
;;;659    
;;;660    		break;
0000f2  e002              B        |L4.250|
                  |L4.244|
;;;661    	}
;;;662    	default:
;;;663    		/* Not support. Reply STALL. */
;;;664    		DrvUSB_ClrCtrlReadyAndTrigStall();
0000f4  f7fffffe          BL       DrvUSB_ClrCtrlReadyAndTrigStall
0000f8  bf00              NOP                            ;597
                  |L4.250|
0000fa  bf00              NOP                            ;607
;;;665    	}
;;;666    }
0000fc  bdf8              POP      {r3-r7,pc}
;;;667    
                          ENDP

0000fe  0000              DCW      0x0000
                  |L4.256|
                          DCD      gIsOverRequest
                  |L4.260|
                          DCD      gu32BytesInUsbBuf
                  |L4.264|
                          DCD      gpu8UsbBuf
                  |L4.268|
                          DCD      g_HID_sDevice
                  |L4.272|
                          DCD      0x40060000
                  |L4.276|
                          DCD      g_HID_au8ConfigDescriptor
                  |L4.280|
                          DCD      g_HID_au8StringLang
                  |L4.284|
                          DCD      g_HID_au8StringSerial

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

                  HID_CtrlSetupGetProtocol PROC
;;;461    /*************************************************************************/
;;;462    void HID_CtrlSetupGetProtocol(void * pVoid)
000000  b570              PUSH     {r4-r6,lr}
;;;463    {
000002  4604              MOV      r4,r0
;;;464    	S_HID_DEVICE *psDevice = (S_HID_DEVICE *) pVoid;
000004  4625              MOV      r5,r4
;;;465    	
;;;466    	DrvUSB_DataIn(0, (const uint8_t *)&psDevice->isReportProtocol, 1);
000006  2201              MOVS     r2,#1
000008  4629              MOV      r1,r5
00000a  312d              ADDS     r1,r1,#0x2d
00000c  2000              MOVS     r0,#0
00000e  f7fffffe          BL       DrvUSB_DataIn
;;;467    }
000012  bd70              POP      {r4-r6,pc}
;;;468    
                          ENDP


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

                  HID_CtrlSetupSetIdle PROC
;;;410    /*************************************************************************/
;;;411    void HID_CtrlSetupSetIdle(void * pVoid)
000000  4904              LDR      r1,|L6.20|
;;;412    {
;;;413    	_DRVUSB_SET_EP_TOG_BIT(0, 0);
000002  6a89              LDR      r1,[r1,#0x28]
000004  2280              MOVS     r2,#0x80
000006  4311              ORRS     r1,r1,r2
000008  4a02              LDR      r2,|L6.20|
00000a  6291              STR      r1,[r2,#0x28]
;;;414    	_DRVUSB_TRIG_EP(0,0x00);
00000c  2100              MOVS     r1,#0
00000e  6251              STR      r1,[r2,#0x24]
;;;415        
;;;416    	//DBG_PRINTF("Set idle\n");
;;;417    }
000010  4770              BX       lr
;;;418    
                          ENDP

000012  0000              DCW      0x0000
                  |L6.20|
                          DCD      0x40060000

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

                  HID_CtrlSetupSetProtocol PROC
;;;433    /*************************************************************************/
;;;434    void HID_CtrlSetupSetProtocol(void * pVoid)
000000  b510              PUSH     {r4,lr}
;;;435    {
;;;436    	S_HID_DEVICE *psDevice = (S_HID_DEVICE *) pVoid;
000002  4601              MOV      r1,r0
;;;437    	S_DRVUSB_DEVICE *pUsbDevice = (S_DRVUSB_DEVICE *)psDevice->device;
000004  6b0a              LDR      r2,[r1,#0x30]
;;;438    	
;;;439    	psDevice->isReportProtocol = pUsbDevice->au8Setup[2];
000006  23b2              MOVS     r3,#0xb2
000008  5c9b              LDRB     r3,[r3,r2]
00000a  b25c              SXTB     r4,r3
00000c  232d              MOVS     r3,#0x2d
00000e  545c              STRB     r4,[r3,r1]
;;;440    
;;;441    	_DRVUSB_SET_EP_TOG_BIT(0,0);
000010  4b04              LDR      r3,|L7.36|
000012  6a9b              LDR      r3,[r3,#0x28]
000014  2480              MOVS     r4,#0x80
000016  4323              ORRS     r3,r3,r4
000018  4c02              LDR      r4,|L7.36|
00001a  62a3              STR      r3,[r4,#0x28]
;;;442    	_DRVUSB_TRIG_EP(0,0x00);
00001c  2300              MOVS     r3,#0
00001e  6263              STR      r3,[r4,#0x24]
;;;443    }
000020  bd10              POP      {r4,pc}
;;;444    
                          ENDP

000022  0000              DCW      0x0000
                  |L7.36|
                          DCD      0x40060000

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

                  HID_CtrlSetupSetReport PROC
;;;356    /*************************************************************************/
;;;357    void HID_CtrlSetupSetReport(void * pVoid)
000000  4601              MOV      r1,r0
;;;358    {
;;;359    	S_DRVUSB_DEVICE *psDevice = (S_DRVUSB_DEVICE *)((S_HID_DEVICE *)pVoid)->device;
000002  6b08              LDR      r0,[r1,#0x30]
;;;360    
;;;361        //DBG_PRINTF("HID - Set Report");
;;;362    	if(psDevice->au8Setup[3] == 1)
000004  22b3              MOVS     r2,#0xb3
000006  5c12              LDRB     r2,[r2,r0]
000008  2a01              CMP      r2,#1
00000a  d108              BNE      |L8.30|
;;;363    	{
;;;364            /* Report Type = input */
;;;365    
;;;366    		// Trigger next Control Out DATA1 Transaction.
;;;367    		_DRVUSB_SET_EP_TOG_BIT(1,0);
00000c  4a1a              LDR      r2,|L8.120|
00000e  6b92              LDR      r2,[r2,#0x38]
000010  2380              MOVS     r3,#0x80
000012  431a              ORRS     r2,r2,r3
000014  4b18              LDR      r3,|L8.120|
000016  639a              STR      r2,[r3,#0x38]
;;;368    		_DRVUSB_TRIG_EP(1, 0);
000018  2200              MOVS     r2,#0
00001a  635a              STR      r2,[r3,#0x34]
00001c  e02a              B        |L8.116|
                  |L8.30|
;;;369    
;;;370            //DBG_PRINTF(" - Input\n");
;;;371    	}
;;;372    	else if (psDevice->au8Setup[3] == 2)
00001e  22b3              MOVS     r2,#0xb3
000020  5c12              LDRB     r2,[r2,r0]
000022  2a02              CMP      r2,#2
000024  d108              BNE      |L8.56|
;;;373    	{
;;;374    		_DRVUSB_SET_EP_TOG_BIT(1, 0);
000026  4a14              LDR      r2,|L8.120|
000028  6b92              LDR      r2,[r2,#0x38]
00002a  2380              MOVS     r3,#0x80
00002c  431a              ORRS     r2,r2,r3
00002e  4b12              LDR      r3,|L8.120|
000030  639a              STR      r2,[r3,#0x38]
;;;375    		_DRVUSB_TRIG_EP(1, 0x00);
000032  2200              MOVS     r2,#0
000034  635a              STR      r2,[r3,#0x34]
000036  e01d              B        |L8.116|
                  |L8.56|
;;;376    
;;;377            //DBG_PRINTF(" - Output\n");
;;;378    	}
;;;379    	else if (psDevice->au8Setup[3] == 3)
000038  22b3              MOVS     r2,#0xb3
00003a  5c12              LDRB     r2,[r2,r0]
00003c  2a03              CMP      r2,#3
00003e  d108              BNE      |L8.82|
;;;380    	{
;;;381            /* Request Type = Feature */
;;;382    		_DRVUSB_SET_EP_TOG_BIT(1,0);
000040  4a0d              LDR      r2,|L8.120|
000042  6b92              LDR      r2,[r2,#0x38]
000044  2380              MOVS     r3,#0x80
000046  431a              ORRS     r2,r2,r3
000048  4b0b              LDR      r3,|L8.120|
00004a  639a              STR      r2,[r3,#0x38]
;;;383    		_DRVUSB_TRIG_EP(1,0x00);
00004c  2200              MOVS     r2,#0
00004e  635a              STR      r2,[r3,#0x34]
000050  e010              B        |L8.116|
                  |L8.82|
;;;384    
;;;385            //DBG_PRINTF(" - Feature\n");
;;;386    	}
;;;387    	else
;;;388    	{
;;;389    		// Not support. Reply STALL.       
;;;390            //DBG_PRINTF(" - Unknown\n");
;;;391    		_HID_CLR_CTRL_READY_AND_TRIG_STALL();
000052  bf00              NOP      
000054  4a08              LDR      r2,|L8.120|
000056  6a92              LDR      r2,[r2,#0x28]
000058  2341              MOVS     r3,#0x41
00005a  025b              LSLS     r3,r3,#9
00005c  431a              ORRS     r2,r2,r3
00005e  4b06              LDR      r3,|L8.120|
000060  629a              STR      r2,[r3,#0x28]
000062  461a              MOV      r2,r3
000064  6b92              LDR      r2,[r2,#0x38]
000066  2341              MOVS     r3,#0x41
000068  025b              LSLS     r3,r3,#9
00006a  431a              ORRS     r2,r2,r3
00006c  4b02              LDR      r3,|L8.120|
00006e  639a              STR      r2,[r3,#0x38]
000070  bf00              NOP      
000072  bf00              NOP      
                  |L8.116|
;;;392    	}
;;;393    }
000074  4770              BX       lr
;;;394    
                          ENDP

000076  0000              DCW      0x0000
                  |L8.120|
                          DCD      0x40060000

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

                  HID_GetVendorInfo PROC
;;;199    
;;;200    int32_t HID_GetVendorInfo(S_VENDOR_INFO *psVendorInfo)
000000  4601              MOV      r1,r0
;;;201    {
;;;202    	if (! psVendorInfo)
000002  2900              CMP      r1,#0
000004  d101              BNE      |L9.10|
;;;203    	{
;;;204    		//return (E_HID_NULL_POINTER);
;;;205    		return -1;
000006  1e40              SUBS     r0,r0,#1
                  |L9.8|
;;;206    	}
;;;207    
;;;208    	psVendorInfo->u16VendorId = g_HID_sDevice.sVendorInfo.u16VendorId;
;;;209    	psVendorInfo->u16ProductId = g_HID_sDevice.sVendorInfo.u16ProductId;
;;;210    	psVendorInfo->psVendorStringDesc = g_HID_sDevice.sVendorInfo.psVendorStringDesc;
;;;211    	psVendorInfo->psProductStringDesc = g_HID_sDevice.sVendorInfo.psProductStringDesc;
;;;212    	
;;;213    	return 0;
;;;214    }
000008  4770              BX       lr
                  |L9.10|
00000a  4807              LDR      r0,|L9.40|
00000c  8800              LDRH     r0,[r0,#0]            ;208  ; g_HID_sDevice
00000e  8008              STRH     r0,[r1,#0]            ;208
000010  4805              LDR      r0,|L9.40|
000012  8840              LDRH     r0,[r0,#2]            ;209  ; g_HID_sDevice
000014  8048              STRH     r0,[r1,#2]            ;209
000016  4804              LDR      r0,|L9.40|
000018  6840              LDR      r0,[r0,#4]            ;210  ; g_HID_sDevice
00001a  6048              STR      r0,[r1,#4]            ;210
00001c  4802              LDR      r0,|L9.40|
00001e  6880              LDR      r0,[r0,#8]            ;211  ; g_HID_sDevice
000020  6088              STR      r0,[r1,#8]            ;211
000022  2000              MOVS     r0,#0                 ;213
000024  e7f0              B        |L9.8|
;;;215    
                          ENDP

000026  0000              DCW      0x0000
                  |L9.40|
                          DCD      g_HID_sDevice

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

                  HID_IntInCallback PROC
;;;192    /*************************************************************************/
;;;193    void HID_IntInCallback(void * pVoid)
000000  4601              MOV      r1,r0
;;;194    {
;;;195        S_HID_DEVICE* psDevice = (S_HID_DEVICE*) pVoid;
;;;196    	
;;;197    	psDevice->isReportReady = 0;
000002  2300              MOVS     r3,#0
000004  222c              MOVS     r2,#0x2c
000006  5453              STRB     r3,[r2,r1]
;;;198    }
000008  4770              BX       lr
;;;199    
                          ENDP


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

                  HID_IsConfigureValue PROC
;;;334    /*************************************************************************/
;;;335    static int32_t HID_IsConfigureValue(uint8_t u8ConfigureValue)
000000  4601              MOV      r1,r0
;;;336    {
;;;337    	return (u8ConfigureValue == g_HID_au8ConfigDescriptor[5]);
000002  4804              LDR      r0,|L11.20|
000004  7940              LDRB     r0,[r0,#5]  ; g_HID_au8ConfigDescriptor
000006  4288              CMP      r0,r1
000008  d101              BNE      |L11.14|
00000a  2001              MOVS     r0,#1
                  |L11.12|
;;;338    }
00000c  4770              BX       lr
                  |L11.14|
00000e  2000              MOVS     r0,#0                 ;337
000010  e7fc              B        |L11.12|
;;;339    
                          ENDP

000012  0000              DCW      0x0000
                  |L11.20|
                          DCD      g_HID_au8ConfigDescriptor

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

                  HID_Open PROC
;;;118    /*************************************************************************/
;;;119    int32_t HID_Open(void)
000000  b510              PUSH     {r4,lr}
;;;120    {
;;;121    	int32_t i32Ret = 0;
000002  2400              MOVS     r4,#0
;;;122    	
;;;123    	g_HID_sDevice.isReportProtocol = 1;
000004  2101              MOVS     r1,#1
000006  4814              LDR      r0,|L12.88|
000008  7341              STRB     r1,[r0,#0xd]
;;;124    
;;;125    	g_HID_sDevice.device = (void *)DrvUSB_InstallClassDevice(&sHidUsbClass);
00000a  4814              LDR      r0,|L12.92|
00000c  f7fffffe          BL       DrvUSB_InstallClassDevice
000010  4911              LDR      r1,|L12.88|
000012  3920              SUBS     r1,r1,#0x20
000014  6308              STR      r0,[r1,#0x30]  ; g_HID_sDevice
;;;126    	
;;;127    	g_HID_sDevice.au8DeviceDescriptor = g_HID_au8DeviceDescriptor;
000016  4812              LDR      r0,|L12.96|
000018  60c8              STR      r0,[r1,#0xc]  ; g_HID_sDevice
;;;128    	g_HID_sDevice.au8ConfigDescriptor = g_HID_au8ConfigDescriptor;
00001a  4812              LDR      r0,|L12.100|
00001c  6108              STR      r0,[r1,#0x10]  ; g_HID_sDevice
;;;129    	
;;;130    	g_HID_sDevice.pu8HIDDescriptor = g_HID_sDevice.au8ConfigDescriptor + LEN_CONFIG + LEN_INTERFACE;	
00001e  4608              MOV      r0,r1
000020  6900              LDR      r0,[r0,#0x10]  ; g_HID_sDevice
000022  3012              ADDS     r0,r0,#0x12
000024  6208              STR      r0,[r1,#0x20]  ; g_HID_sDevice
;;;131    	g_HID_sDevice.pu8IntInEPDescriptor = g_HID_sDevice.au8ConfigDescriptor + LEN_CONFIG + LEN_INTERFACE + LEN_HID;
000026  4608              MOV      r0,r1
000028  6900              LDR      r0,[r0,#0x10]  ; g_HID_sDevice
00002a  301b              ADDS     r0,r0,#0x1b
00002c  6148              STR      r0,[r1,#0x14]  ; g_HID_sDevice
;;;132    	
;;;133    	g_HID_sDevice.sVendorInfo.psVendorStringDesc = &g_HID_sVendorStringDesc;
00002e  480e              LDR      r0,|L12.104|
000030  6048              STR      r0,[r1,#4]  ; g_HID_sDevice
;;;134    	g_HID_sDevice.sVendorInfo.psProductStringDesc = &g_HID_sProductStringDesc;
000032  480e              LDR      r0,|L12.108|
000034  6088              STR      r0,[r1,#8]  ; g_HID_sDevice
;;;135    	g_HID_sDevice.sVendorInfo.u16VendorId = *(uint16_t *)&g_HID_sDevice.au8DeviceDescriptor[8];
000036  4608              MOV      r0,r1
000038  68c0              LDR      r0,[r0,#0xc]  ; g_HID_sDevice
00003a  8900              LDRH     r0,[r0,#8]
00003c  8008              STRH     r0,[r1,#0]
;;;136    	g_HID_sDevice.sVendorInfo.u16ProductId = *(uint16_t *)&g_HID_sDevice.au8DeviceDescriptor[10];
00003e  4608              MOV      r0,r1
000040  68c0              LDR      r0,[r0,#0xc]  ; g_HID_sDevice
000042  8940              LDRH     r0,[r0,#0xa]
000044  8048              STRH     r0,[r1,#2]
;;;137    
;;;138    	i32Ret = DrvUSB_InstallCtrlHandler(g_HID_sDevice.device, g_asCtrlCallbackEntry, 
000046  220d              MOVS     r2,#0xd
000048  6b08              LDR      r0,[r1,#0x30]  ; g_HID_sDevice
00004a  4909              LDR      r1,|L12.112|
00004c  f7fffffe          BL       DrvUSB_InstallCtrlHandler
000050  4604              MOV      r4,r0
;;;139    					sizeof(g_asCtrlCallbackEntry) / sizeof(g_asCtrlCallbackEntry[0]));
;;;140    
;;;141    
;;;142    
;;;143    	return i32Ret;
000052  4620              MOV      r0,r4
;;;144    }
000054  bd10              POP      {r4,pc}
;;;145    
                          ENDP

000056  0000              DCW      0x0000
                  |L12.88|
                          DCD      g_HID_sDevice+0x20
                  |L12.92|
                          DCD      sHidUsbClass
                  |L12.96|
                          DCD      g_HID_au8DeviceDescriptor
                  |L12.100|
                          DCD      g_HID_au8ConfigDescriptor
                  |L12.104|
                          DCD      g_HID_sVendorStringDesc
                  |L12.108|
                          DCD      g_HID_sProductStringDesc
                  |L12.112|
                          DCD      g_asCtrlCallbackEntry

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

                  HID_PrepareDescriptors PROC
;;;479    
;;;480    void HID_PrepareDescriptors(const uint8_t *pu8Descriptor, uint32_t u32DescriptorSize, uint32_t u32RequestSize, uint32_t u32MaxPacketSize)
000000  b5f8              PUSH     {r3-r7,lr}
;;;481    {
000002  4607              MOV      r7,r0
000004  460d              MOV      r5,r1
000006  4616              MOV      r6,r2
000008  461c              MOV      r4,r3
;;;482        
;;;483        gu32BytesInUsbBuf = u32RequestSize;
00000a  4816              LDR      r0,|L13.100|
00000c  6006              STR      r6,[r0,#0]  ; gu32BytesInUsbBuf
;;;484        if(u32RequestSize > u32DescriptorSize)
00000e  42ae              CMP      r6,r5
000010  d903              BLS      |L13.26|
;;;485        {
;;;486            gu32BytesInUsbBuf = u32DescriptorSize;
000012  6005              STR      r5,[r0,#0]  ; gu32BytesInUsbBuf
;;;487            gIsOverRequest = 1;
000014  2001              MOVS     r0,#1
000016  4914              LDR      r1,|L13.104|
000018  7008              STRB     r0,[r1,#0]
                  |L13.26|
;;;488        }
;;;489        gpu8UsbBuf = pu8Descriptor;
00001a  4814              LDR      r0,|L13.108|
00001c  6007              STR      r7,[r0,#0]  ; gpu8UsbBuf
;;;490    
;;;491        DBG_PRINTF("Get descriptor 0x%08x %d size.\n", pu8Descriptor, u32DescriptorSize);
;;;492    
;;;493    	if(gu32BytesInUsbBuf < u32MaxPacketSize)
00001e  4811              LDR      r0,|L13.100|
000020  6800              LDR      r0,[r0,#0]  ; gu32BytesInUsbBuf
000022  42a0              CMP      r0,r4
000024  d20c              BCS      |L13.64|
;;;494    	{
;;;495    	    DrvUSB_DataIn(0, gpu8UsbBuf, gu32BytesInUsbBuf); 
000026  480f              LDR      r0,|L13.100|
000028  6802              LDR      r2,[r0,#0]  ; gu32BytesInUsbBuf
00002a  4810              LDR      r0,|L13.108|
00002c  6801              LDR      r1,[r0,#0]  ; gpu8UsbBuf
00002e  2000              MOVS     r0,#0
000030  f7fffffe          BL       DrvUSB_DataIn
;;;496    	    gpu8UsbBuf = 0;
000034  2000              MOVS     r0,#0
000036  490d              LDR      r1,|L13.108|
000038  6008              STR      r0,[r1,#0]  ; gpu8UsbBuf
;;;497    	    gu32BytesInUsbBuf = 0;   
00003a  490a              LDR      r1,|L13.100|
00003c  6008              STR      r0,[r1,#0]  ; gu32BytesInUsbBuf
00003e  e00f              B        |L13.96|
                  |L13.64|
;;;498    	}
;;;499    	else
;;;500    	{
;;;501    		DrvUSB_DataIn(0, gpu8UsbBuf, u32MaxPacketSize);
000040  4622              MOV      r2,r4
000042  480a              LDR      r0,|L13.108|
000044  6801              LDR      r1,[r0,#0]  ; gpu8UsbBuf
000046  2000              MOVS     r0,#0
000048  f7fffffe          BL       DrvUSB_DataIn
;;;502    		gpu8UsbBuf += u32MaxPacketSize;
00004c  4807              LDR      r0,|L13.108|
00004e  6800              LDR      r0,[r0,#0]  ; gpu8UsbBuf
000050  1900              ADDS     r0,r0,r4
000052  4906              LDR      r1,|L13.108|
000054  6008              STR      r0,[r1,#0]  ; gpu8UsbBuf
;;;503    		gu32BytesInUsbBuf -= u32MaxPacketSize;
000056  4803              LDR      r0,|L13.100|
000058  6800              LDR      r0,[r0,#0]  ; gu32BytesInUsbBuf
00005a  1b00              SUBS     r0,r0,r4
00005c  4901              LDR      r1,|L13.100|
00005e  6008              STR      r0,[r1,#0]  ; gu32BytesInUsbBuf
                  |L13.96|
;;;504        }
;;;505    
;;;506    }
000060  bdf8              POP      {r3-r7,pc}
;;;507    
                          ENDP

000062  0000              DCW      0x0000
                  |L13.100|
                          DCD      gu32BytesInUsbBuf
                  |L13.104|
                          DCD      gIsOverRequest
                  |L13.108|
                          DCD      gpu8UsbBuf

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

                  HID_Reset PROC
;;;156    
;;;157    static void HID_Reset(S_HID_DEVICE *psDevice)
000000  b510              PUSH     {r4,lr}
;;;158    {	
000002  4604              MOV      r4,r0
;;;159    	DrvUSB_Reset(1);
000004  2001              MOVS     r0,#1
000006  f7fffffe          BL       DrvUSB_Reset
;;;160    }
00000a  bd10              POP      {r4,pc}
;;;161    
                          ENDP


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

                  HID_SetReportBuf PROC
;;;299    /*************************************************************************/
;;;300    int32_t HID_SetReportBuf(uint8_t* pu8Report, uint32_t u32ReportSize)
000000  4602              MOV      r2,r0
;;;301    {
;;;302    	if (pu8Report == NULL)
000002  2a00              CMP      r2,#0
000004  d101              BNE      |L15.10|
;;;303    	{
;;;304    		return -1;
000006  1e40              SUBS     r0,r0,#1
                  |L15.8|
;;;305    	}
;;;306    	if (u32ReportSize > HID_MAX_PACKET_SIZE_INT_IN)
;;;307    	{
;;;308    		return -1;
;;;309    	}
;;;310    
;;;311    	g_HID_sDevice.pu8Report = pu8Report;
;;;312    	g_HID_sDevice.u32ReportSize = u32ReportSize;
;;;313        g_HID_sDevice.isReportReady = 0;
;;;314    
;;;315    	return 0;
;;;316    }
000008  4770              BX       lr
                  |L15.10|
00000a  2940              CMP      r1,#0x40              ;306
00000c  d902              BLS      |L15.20|
00000e  2000              MOVS     r0,#0                 ;308
000010  43c0              MVNS     r0,r0                 ;308
000012  e7f9              B        |L15.8|
                  |L15.20|
000014  4803              LDR      r0,|L15.36|
000016  6242              STR      r2,[r0,#0x24]         ;311  ; g_HID_sDevice
000018  6281              STR      r1,[r0,#0x28]         ;312  ; g_HID_sDevice
00001a  2300              MOVS     r3,#0                 ;313
00001c  3020              ADDS     r0,r0,#0x20           ;313
00001e  7303              STRB     r3,[r0,#0xc]          ;313
000020  2000              MOVS     r0,#0                 ;315
000022  e7f1              B        |L15.8|
;;;317    
                          ENDP

                  |L15.36|
                          DCD      g_HID_sDevice

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

                  HID_SetReportDescriptor PROC
;;;268    /*************************************************************************/
;;;269    int32_t HID_SetReportDescriptor(const uint8_t* pu8ReportDescriptor, uint32_t u32ReportDescriptorSize)
000000  4602              MOV      r2,r0
;;;270    {
;;;271    	if (pu8ReportDescriptor == NULL)
000002  2a00              CMP      r2,#0
000004  d101              BNE      |L16.10|
;;;272    	{
;;;273    		return -1;
000006  1e40              SUBS     r0,r0,#1
                  |L16.8|
;;;274    	}
;;;275    
;;;276    	g_HID_sDevice.pu8ReportDescriptor = pu8ReportDescriptor;
;;;277    	g_HID_sDevice.u32ReportDescriptorSize = u32ReportDescriptorSize;
;;;278    	
;;;279    	return 0;
;;;280    }
000008  4770              BX       lr
                  |L16.10|
00000a  4802              LDR      r0,|L16.20|
00000c  6182              STR      r2,[r0,#0x18]         ;276  ; g_HID_sDevice
00000e  61c1              STR      r1,[r0,#0x1c]         ;277  ; g_HID_sDevice
000010  2000              MOVS     r0,#0                 ;279
000012  e7f9              B        |L16.8|
;;;281    
                          ENDP

                  |L16.20|
                          DCD      g_HID_sDevice

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

                  HID_SetVendorInfo PROC
;;;231    /*************************************************************************/
;;;232    int32_t HID_SetVendorInfo(const S_VENDOR_INFO *psVendorInfo)
000000  4601              MOV      r1,r0
;;;233    {
;;;234    	if (! psVendorInfo ||
000002  2900              CMP      r1,#0
000004  d005              BEQ      |L17.18|
;;;235    	        ! psVendorInfo->psVendorStringDesc ||
000006  6848              LDR      r0,[r1,#4]
000008  2800              CMP      r0,#0
00000a  d002              BEQ      |L17.18|
;;;236    	        ! psVendorInfo->psProductStringDesc)
00000c  6888              LDR      r0,[r1,#8]
00000e  2800              CMP      r0,#0
000010  d102              BNE      |L17.24|
                  |L17.18|
;;;237    	{
;;;238    		//return (E_HID_NULL_POINTER);
;;;239    		return -1;
000012  2000              MOVS     r0,#0
000014  43c0              MVNS     r0,r0
                  |L17.22|
;;;240    	}
;;;241    
;;;242    	g_HID_sDevice.sVendorInfo.u16VendorId = psVendorInfo->u16VendorId;
;;;243    	g_HID_sDevice.sVendorInfo.u16ProductId = psVendorInfo->u16ProductId;
;;;244    	g_HID_sDevice.sVendorInfo.psVendorStringDesc = psVendorInfo->psVendorStringDesc;
;;;245    	g_HID_sDevice.sVendorInfo.psProductStringDesc = psVendorInfo->psProductStringDesc;
;;;246    
;;;247    	return 0;
;;;248    }
000016  4770              BX       lr
                  |L17.24|
000018  8808              LDRH     r0,[r1,#0]            ;242
00001a  4a05              LDR      r2,|L17.48|
00001c  8010              STRH     r0,[r2,#0]            ;242
00001e  8848              LDRH     r0,[r1,#2]            ;243
000020  8050              STRH     r0,[r2,#2]            ;243
000022  6848              LDR      r0,[r1,#4]            ;244
000024  6050              STR      r0,[r2,#4]            ;244  ; g_HID_sDevice
000026  6888              LDR      r0,[r1,#8]            ;245
000028  6090              STR      r0,[r2,#8]            ;245  ; g_HID_sDevice
00002a  2000              MOVS     r0,#0                 ;247
00002c  e7f3              B        |L17.22|
;;;249    
                          ENDP

00002e  0000              DCW      0x0000
                  |L17.48|
                          DCD      g_HID_sDevice

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

                  HID_Start PROC
;;;161    
;;;162    static void HID_Start(S_HID_DEVICE *psDevice)
000000  b510              PUSH     {r4,lr}
;;;163    {
000002  4604              MOV      r4,r0
;;;164        __weak extern void HID_SetFirstOutReport(void);
;;;165        __weak extern void HID_SetFirstInReport(void);
;;;166    
;;;167        /* To prepare the first IN report if it is necessary */
;;;168        if((uint32_t)HID_SetFirstInReport)
000004  4805              LDR      r0,|L18.28|
000006  2800              CMP      r0,#0
000008  d001              BEQ      |L18.14|
;;;169            HID_SetFirstInReport();
00000a  f7fffffe          BL       HID_SetFirstInReport
                  |L18.14|
;;;170    
;;;171    
;;;172        /* To prepare the first OUT report if it is necessary */
;;;173        if((uint32_t)HID_SetFirstOutReport)
00000e  4804              LDR      r0,|L18.32|
000010  2800              CMP      r0,#0
000012  d001              BEQ      |L18.24|
;;;174            HID_SetFirstOutReport();
000014  f7fffffe          BL       HID_SetFirstOutReport
                  |L18.24|
;;;175    }
000018  bd10              POP      {r4,pc}
;;;176    
                          ENDP

00001a  0000              DCW      0x0000
                  |L18.28|
                          DCD      HID_SetFirstInReport
                  |L18.32|
                          DCD      HID_SetFirstOutReport

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

                  HID_UsbStartCallBack PROC
;;;150    
;;;151    static void HID_UsbStartCallBack(void * pVoid)
000000  b510              PUSH     {r4,lr}
;;;152    {
000002  4604              MOV      r4,r0
;;;153    	HID_Reset((S_HID_DEVICE *)pVoid);
000004  4620              MOV      r0,r4
000006  f7fffffe          BL       HID_Reset
;;;154    	HID_Start((S_HID_DEVICE *)pVoid);
00000a  4620              MOV      r0,r4
00000c  f7fffffe          BL       HID_Start
;;;155    }
000010  bd10              POP      {r4,pc}
;;;156    
                          ENDP


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

                  Minimum PROC
;;;469    
;;;470    static uint16_t Minimum(uint16_t a, uint16_t b)
000000  4602              MOV      r2,r0
;;;471    {
;;;472    	if (a > b)
000002  428a              CMP      r2,r1
000004  dd01              BLE      |L20.10|
;;;473    		return b;
000006  4608              MOV      r0,r1
                  |L20.8|
;;;474    	else
;;;475    		return a;
;;;476    }
000008  4770              BX       lr
                  |L20.10|
00000a  4610              MOV      r0,r2                 ;475
00000c  e7fc              B        |L20.8|
;;;477    
                          ENDP


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

                  g_HID_sDevice
                          %        52

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

                  sEpDescription
                          DCD      0x00000080
                          DCD      0x00000008
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000008
                          DCD      0x00000000
                          DCD      0x00000081
                          DCD      0x00000040
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                  g_sBusOps
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      DrvUSB_BusResetCallback
                          DCD      g_HID_sDevice
                          DCD      DrvUSB_BusSuspendCallback
                          DCD      g_HID_sDevice
                          DCD      DrvUSB_BusResumeCallback
                          DCD      g_HID_sDevice
                          DCD      DrvUSB_CtrlSetupAck
                          DCD      g_HID_sDevice
                  g_sUsbOps
                          DCD      DrvUSB_CtrlDataInAck
                          DCD      g_HID_sDevice
                          DCD      DrvUSB_CtrlDataOutAck
                          DCD      g_HID_sDevice
                          DCD      HID_IntInCallback
                          DCD      g_HID_sDevice
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                  g_asCtrlCallbackEntry
0000c0  00050000          DCB      0x00,0x05,0x00,0x00
                          DCD      DrvUSB_CtrlSetupSetAddress
                          DCD      DrvUSB_CtrlDataInSetAddress
                          DCD      0x00000000
                          DCD      g_HID_sDevice
0000d4  00010000          DCB      0x00,0x01,0x00,0x00
                          DCD      DrvUSB_CtrlSetupClearSetFeature
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      g_HID_sDevice
0000e8  00030000          DCB      0x00,0x03,0x00,0x00
                          DCD      DrvUSB_CtrlSetupClearSetFeature
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      g_HID_sDevice
0000fc  00080000          DCB      0x00,0x08,0x00,0x00
                          DCD      DrvUSB_CtrlSetupGetConfiguration
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      g_HID_sDevice
000110  00000000          DCB      0x00,0x00,0x00,0x00
                          DCD      DrvUSB_CtrlSetupGetStatus
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      g_HID_sDevice
000124  000a0000          DCB      0x00,0x0a,0x00,0x00
                          DCD      DrvUSB_CtrlSetupGetInterface
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      g_HID_sDevice
000138  000b0000          DCB      0x00,0x0b,0x00,0x00
                          DCD      DrvUSB_CtrlSetupSetInterface
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      g_HID_sDevice
00014c  00060000          DCB      0x00,0x06,0x00,0x00
                          DCD      HID_CtrlSetupGetDescriptor
                          DCD      HID_CtrlGetDescriptorIn
                          DCD      0x00000000
                          DCD      g_HID_sDevice
000160  00090000          DCB      0x00,0x09,0x00,0x00
                          DCD      DrvUSB_CtrlSetupSetConfiguration
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      g_HID_sDevice
000174  20090000          DCB      0x20,0x09,0x00,0x00
                          DCD      HID_CtrlSetupSetReport
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      g_HID_sDevice
000188  200a0000          DCB      0x20,0x0a,0x00,0x00
                          DCD      HID_CtrlSetupSetIdle
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      g_HID_sDevice
00019c  200b0000          DCB      0x20,0x0b,0x00,0x00
                          DCD      HID_CtrlSetupSetProtocol
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      g_HID_sDevice
0001b0  20030000          DCB      0x20,0x03,0x00,0x00
                          DCD      HID_CtrlSetupGetProtocol
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      g_HID_sDevice
                  sHidUsbClass
                          DCD      g_HID_sDevice
                          DCD      HID_UsbStartCallBack
                          DCD      HID_IsConfigureValue
                          DCD      0x00000000
                  gpu8UsbBuf
                          DCD      0x00000000
                  gu32BytesInUsbBuf
                          DCD      0x00000000
                  gIsOverRequest
0001dc  00                DCB      0x00
