
usbd.nostrip.sys:     file format pei-i386

Disassembly of section .text:

00011000 <_DriverEntry@8>:

NTSTATUS STDCALL
DriverEntry(PDRIVER_OBJECT DriverObject,
            PUNICODE_STRING RegistryPath)
{
   11000:	55                   	push   %ebp
    return STATUS_SUCCESS;
}
   11001:	31 c0                	xor    %eax,%eax
   11003:	89 e5                	mov    %esp,%ebp
   11005:	5d                   	pop    %ebp
   11006:	c2 08 00             	ret    $0x8
   11009:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011010 <_DllInitialize@4>:

/*
 * @implemented
 */
DWORD STDCALL
DllInitialize(DWORD Unknown)
{
   11010:	55                   	push   %ebp
    return 0;
}
   11011:	31 c0                	xor    %eax,%eax
   11013:	89 e5                	mov    %esp,%ebp
   11015:	5d                   	pop    %ebp
   11016:	c2 04 00             	ret    $0x4
   11019:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011020 <_DllUnload@0>:

/*
 * @implemented
 */
DWORD STDCALL
DllUnload(VOID)
{
   11020:	55                   	push   %ebp
    return 0;
}
   11021:	31 c0                	xor    %eax,%eax
   11023:	89 e5                	mov    %esp,%ebp
   11025:	5d                   	pop    %ebp
   11026:	c3                   	ret    
   11027:	89 f6                	mov    %esi,%esi
   11029:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011030 <_USBD_Debug_GetHeap@16>:

/*
 * @implemented
 */
PVOID STDCALL
USBD_Debug_GetHeap(DWORD Unknown1, POOL_TYPE PoolType, ULONG NumberOfBytes,
	ULONG Tag)
{
   11030:	55                   	push   %ebp
   11031:	89 e5                	mov    %esp,%ebp
   11033:	83 ec 0c             	sub    $0xc,%esp
    return ExAllocatePoolWithTag(PoolType, NumberOfBytes, Tag);
   11036:	8b 4d 14             	mov    0x14(%ebp),%ecx
   11039:	8b 55 10             	mov    0x10(%ebp),%edx
   1103c:	8b 45 0c             	mov    0xc(%ebp),%eax
   1103f:	51                   	push   %ecx
   11040:	52                   	push   %edx
   11041:	50                   	push   %eax
   11042:	ff 15 58 30 01 00    	call   *0x13058
}
   11048:	c9                   	leave  
   11049:	c2 10 00             	ret    $0x10
   1104c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011050 <_USBD_Debug_RetHeap@12>:

/*
 * @implemented
 */
VOID STDCALL
USBD_Debug_RetHeap(PVOID Heap, DWORD Unknown2, DWORD Unknown3)
{
   11050:	55                   	push   %ebp
   11051:	89 e5                	mov    %esp,%ebp
   11053:	83 ec 14             	sub    $0x14,%esp
    ExFreePool(Heap);
   11056:	8b 45 08             	mov    0x8(%ebp),%eax
   11059:	50                   	push   %eax
   1105a:	ff 15 5c 30 01 00    	call   *0x1305c
   11060:	c9                   	leave  
   11061:	c2 0c 00             	ret    $0xc
   11064:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   1106a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00011070 <_USBD_Debug_LogEntry@16>:
}

/*
 * @implemented
 */
VOID STDCALL
USBD_Debug_LogEntry(PCHAR Name, ULONG_PTR Info1, ULONG_PTR Info2,
    ULONG_PTR Info3)
{
   11070:	55                   	push   %ebp
   11071:	89 e5                	mov    %esp,%ebp
   11073:	5d                   	pop    %ebp
   11074:	c2 10 00             	ret    $0x10
   11077:	89 f6                	mov    %esi,%esi
   11079:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011080 <_USBD_AllocateDeviceName@4>:
}

/*
 * @implemented
 */
PVOID STDCALL
USBD_AllocateDeviceName(DWORD Unknown)
{
   11080:	55                   	push   %ebp
    return NULL;
}
   11081:	31 c0                	xor    %eax,%eax
   11083:	89 e5                	mov    %esp,%ebp
   11085:	5d                   	pop    %ebp
   11086:	c2 04 00             	ret    $0x4
   11089:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011090 <_USBD_CalculateUsbBandwidth@12>:

/*
 * @implemented
 */
DWORD STDCALL
USBD_CalculateUsbBandwidth(
    ULONG MaxPacketSize,
    UCHAR EndpointType,
    BOOLEAN LowSpeed
    )
{
   11090:	55                   	push   %ebp
    DWORD OverheadTable[] = {
            0x00, /* UsbdPipeTypeControl */
            0x09, /* UsbdPipeTypeIsochronous */
            0x00, /* UsbdPipeTypeBulk */
            0x0d  /* UsbdPipeTypeInterrupt */
        };
    DWORD Result;
    
    if (OverheadTable[EndpointType] != 0)
   11091:	31 c0                	xor    %eax,%eax
   11093:	89 e5                	mov    %esp,%ebp
   11095:	53                   	push   %ebx
   11096:	83 ec 14             	sub    $0x14,%esp
    {
        Result = ((MaxPacketSize + OverheadTable[EndpointType]) * 8 * 7) / 6;
        if (LowSpeed)
           return Result << 3;
        return Result;
    }
    return 0;
   11099:	31 c9                	xor    %ecx,%ecx
   1109b:	8a 45 0c             	mov    0xc(%ebp),%al
   1109e:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
   110a5:	c7 45 ec 09 00 00 00 	movl   $0x9,0xffffffec(%ebp)
   110ac:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
   110b3:	c7 45 f4 0d 00 00 00 	movl   $0xd,0xfffffff4(%ebp)
   110ba:	8a 5d 10             	mov    0x10(%ebp),%bl
   110bd:	8b 44 85 e8          	mov    0xffffffe8(%ebp,%eax,4),%eax
   110c1:	85 c0                	test   %eax,%eax
   110c3:	74 2b                	je     110f0 <_USBD_CalculateUsbBandwidth@12+0x60>
   110c5:	8b 55 08             	mov    0x8(%ebp),%edx
   110c8:	01 d0                	add    %edx,%eax
   110ca:	8d 14 c5 00 00 00 00 	lea    0x0(,%eax,8),%edx
   110d1:	29 c2                	sub    %eax,%edx
   110d3:	b8 ab aa aa aa       	mov    $0xaaaaaaab,%eax
   110d8:	c1 e2 03             	shl    $0x3,%edx
   110db:	f7 e2                	mul    %edx
   110dd:	c1 ea 02             	shr    $0x2,%edx
   110e0:	84 db                	test   %bl,%bl
   110e2:	89 d1                	mov    %edx,%ecx
   110e4:	74 0a                	je     110f0 <_USBD_CalculateUsbBandwidth@12+0x60>
   110e6:	8d 0c d5 00 00 00 00 	lea    0x0(,%edx,8),%ecx
   110ed:	8d 76 00             	lea    0x0(%esi),%esi
}
   110f0:	83 c4 14             	add    $0x14,%esp
   110f3:	89 c8                	mov    %ecx,%eax
   110f5:	5b                   	pop    %ebx
   110f6:	5d                   	pop    %ebp
   110f7:	c2 0c 00             	ret    $0xc
   110fa:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00011100 <_USBD_Dispatch@16>:

/*
 * @implemented
 */
DWORD STDCALL
USBD_Dispatch(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3, DWORD Unknown4)
{
   11100:	55                   	push   %ebp
    return 1;
}
   11101:	b8 01 00 00 00       	mov    $0x1,%eax
   11106:	89 e5                	mov    %esp,%ebp
   11108:	5d                   	pop    %ebp
   11109:	c2 10 00             	ret    $0x10
   1110c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011110 <_USBD_FreeDeviceMutex@4>:

/*
 * @implemented
 */
VOID STDCALL
USBD_FreeDeviceMutex(PVOID Unknown)
{
   11110:	55                   	push   %ebp
   11111:	89 e5                	mov    %esp,%ebp
   11113:	5d                   	pop    %ebp
   11114:	c2 04 00             	ret    $0x4
   11117:	89 f6                	mov    %esi,%esi
   11119:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011120 <_USBD_FreeDeviceName@4>:
}

/*
 * @implemented
 */
VOID STDCALL
USBD_FreeDeviceName(PVOID Unknown)
{
   11120:	55                   	push   %ebp
   11121:	89 e5                	mov    %esp,%ebp
   11123:	5d                   	pop    %ebp
   11124:	c2 04 00             	ret    $0x4
   11127:	89 f6                	mov    %esi,%esi
   11129:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011130 <_USBD_WaitDeviceMutex@4>:
}

/*
 * @implemented
 */
VOID STDCALL
USBD_WaitDeviceMutex(PVOID Unknown)
{
   11130:	55                   	push   %ebp
   11131:	89 e5                	mov    %esp,%ebp
   11133:	5d                   	pop    %ebp
   11134:	c2 04 00             	ret    $0x4
   11137:	89 f6                	mov    %esi,%esi
   11139:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011140 <_USBD_GetSuspendPowerState@4>:
}

/*
 * @implemented
 */
DWORD STDCALL
USBD_GetSuspendPowerState(DWORD Unknown1)
{
   11140:	55                   	push   %ebp
    return 0;
}
   11141:	31 c0                	xor    %eax,%eax
   11143:	89 e5                	mov    %esp,%ebp
   11145:	5d                   	pop    %ebp
   11146:	c2 04 00             	ret    $0x4
   11149:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011150 <_USBD_InitializeDevice@24>:

/*
 * @implemented
 */
NTSTATUS STDCALL
USBD_InitializeDevice(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3,
    DWORD Unknown4, DWORD Unknown5, DWORD Unknown6)
{
   11150:	55                   	push   %ebp
    return STATUS_NOT_SUPPORTED;
}
   11151:	b8 bb 00 00 c0       	mov    $0xc00000bb,%eax
   11156:	89 e5                	mov    %esp,%ebp
   11158:	5d                   	pop    %ebp
   11159:	c2 18 00             	ret    $0x18
   1115c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011160 <_USBD_RegisterHostController@40>:

/*
 * @implemented
 */
NTSTATUS STDCALL
USBD_RegisterHostController(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3,
    DWORD Unknown4, DWORD Unknown5, DWORD Unknown6, DWORD Unknown7,
    DWORD Unknown8, DWORD Unknown9, DWORD Unknown10)
{
   11160:	55                   	push   %ebp
    return STATUS_NOT_SUPPORTED;
}
   11161:	b8 bb 00 00 c0       	mov    $0xc00000bb,%eax
   11166:	89 e5                	mov    %esp,%ebp
   11168:	5d                   	pop    %ebp
   11169:	c2 28 00             	ret    $0x28
   1116c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011170 <_USBD_GetDeviceInformation@12>:

/*
 * @implemented
 */
NTSTATUS STDCALL
USBD_GetDeviceInformation(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3)
{
   11170:	55                   	push   %ebp
    return STATUS_NOT_SUPPORTED;
}
   11171:	b8 bb 00 00 c0       	mov    $0xc00000bb,%eax
   11176:	89 e5                	mov    %esp,%ebp
   11178:	5d                   	pop    %ebp
   11179:	c2 0c 00             	ret    $0xc
   1117c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011180 <_USBD_CreateDevice@20>:

/*
 * @implemented
 */
NTSTATUS STDCALL
USBD_CreateDevice(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3,
    DWORD Unknown4, DWORD Unknown5)
{
   11180:	55                   	push   %ebp
    return STATUS_NOT_SUPPORTED;
}
   11181:	b8 bb 00 00 c0       	mov    $0xc00000bb,%eax
   11186:	89 e5                	mov    %esp,%ebp
   11188:	5d                   	pop    %ebp
   11189:	c2 14 00             	ret    $0x14
   1118c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011190 <_USBD_RemoveDevice@12>:

/*
 * @implemented
 */
NTSTATUS STDCALL
USBD_RemoveDevice(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3)
{
   11190:	55                   	push   %ebp
    return STATUS_NOT_SUPPORTED;
}
   11191:	b8 bb 00 00 c0       	mov    $0xc00000bb,%eax
   11196:	89 e5                	mov    %esp,%ebp
   11198:	5d                   	pop    %ebp
   11199:	c2 0c 00             	ret    $0xc
   1119c:	8d 74 26 00          	lea    0x0(%esi),%esi

000111a0 <_USBD_CompleteRequest@8>:

/*
 * @implemented
 */
VOID STDCALL
USBD_CompleteRequest(DWORD Unknown1, DWORD Unknown2)
{
   111a0:	55                   	push   %ebp
   111a1:	89 e5                	mov    %esp,%ebp
   111a3:	5d                   	pop    %ebp
   111a4:	c2 08 00             	ret    $0x8
   111a7:	89 f6                	mov    %esi,%esi
   111a9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000111b0 <_USBD_RegisterHcFilter@8>:
}

/*
 * @implemented
 */
VOID STDCALL
USBD_RegisterHcFilter(
    PDEVICE_OBJECT DeviceObject, 
    PDEVICE_OBJECT FilterDeviceObject
    )
{
   111b0:	55                   	push   %ebp
   111b1:	89 e5                	mov    %esp,%ebp
   111b3:	5d                   	pop    %ebp
   111b4:	c2 08 00             	ret    $0x8
   111b7:	89 f6                	mov    %esi,%esi
   111b9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000111c0 <_USBD_SetSuspendPowerState@8>:
}

/*
 * @implemented
 */
VOID STDCALL
USBD_SetSuspendPowerState(DWORD Unknown1, DWORD Unknown2)
{
   111c0:	55                   	push   %ebp
   111c1:	89 e5                	mov    %esp,%ebp
   111c3:	5d                   	pop    %ebp
   111c4:	c2 08 00             	ret    $0x8
   111c7:	89 f6                	mov    %esi,%esi
   111c9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000111d0 <_USBD_MakePdoName@8>:
}

/*
 * @implemented
 */
NTSTATUS STDCALL
USBD_MakePdoName(DWORD Unknown1, DWORD Unknown2)
{
   111d0:	55                   	push   %ebp
    return STATUS_NOT_SUPPORTED;
}
   111d1:	b8 bb 00 00 c0       	mov    $0xc00000bb,%eax
   111d6:	89 e5                	mov    %esp,%ebp
   111d8:	5d                   	pop    %ebp
   111d9:	c2 08 00             	ret    $0x8
   111dc:	8d 74 26 00          	lea    0x0(%esi),%esi

000111e0 <_USBD_QueryBusTime@8>:

/*
 * @implemented
 */
NTSTATUS STDCALL
USBD_QueryBusTime(
    PDEVICE_OBJECT RootHubPdo,
    PULONG CurrentFrame
    )
{
   111e0:	55                   	push   %ebp
    return STATUS_NOT_SUPPORTED;
}
   111e1:	b8 bb 00 00 c0       	mov    $0xc00000bb,%eax
   111e6:	89 e5                	mov    %esp,%ebp
   111e8:	5d                   	pop    %ebp
   111e9:	c2 08 00             	ret    $0x8
   111ec:	8d 74 26 00          	lea    0x0(%esi),%esi

000111f0 <_USBD_GetUSBDIVersion@4>:

/*
 * @implemented
 */
VOID STDCALL
USBD_GetUSBDIVersion(
    PUSBD_VERSION_INFORMATION Version
    )
{
   111f0:	55                   	push   %ebp
   111f1:	89 e5                	mov    %esp,%ebp
   111f3:	8b 45 08             	mov    0x8(%ebp),%eax
    if (Version != NULL)
   111f6:	85 c0                	test   %eax,%eax
   111f8:	74 0d                	je     11207 <_USBD_GetUSBDIVersion@4+0x17>
    {
        Version->USBDI_Version = USBDI_VERSION;
   111fa:	c7 00 00 03 00 00    	movl   $0x300,(%eax)
        Version->Supported_USB_Version = 0x100;
   11200:	c7 40 04 00 01 00 00 	movl   $0x100,0x4(%eax)
    }
}
   11207:	5d                   	pop    %ebp
   11208:	c2 04 00             	ret    $0x4
   1120b:	90                   	nop    
   1120c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011210 <_USBD_RestoreDevice@12>:

/*
 * @implemented
 */
NTSTATUS STDCALL
USBD_RestoreDevice(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3)
{
   11210:	55                   	push   %ebp
    return STATUS_NOT_SUPPORTED;
}
   11211:	b8 bb 00 00 c0       	mov    $0xc00000bb,%eax
   11216:	89 e5                	mov    %esp,%ebp
   11218:	5d                   	pop    %ebp
   11219:	c2 0c 00             	ret    $0xc
   1121c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011220 <_USBD_RegisterHcDeviceCapabilities@12>:

/*
 * @implemented
 */
VOID STDCALL
USBD_RegisterHcDeviceCapabilities(DWORD Unknown1, DWORD Unknown2,
    DWORD Unknown3)
{
   11220:	55                   	push   %ebp
   11221:	89 e5                	mov    %esp,%ebp
   11223:	5d                   	pop    %ebp
   11224:	c2 0c 00             	ret    $0xc
   11227:	89 f6                	mov    %esi,%esi
   11229:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011230 <_USBD_CreateConfigurationRequestEx@8>:
}

/*
 * @implemented
 * FIXME: Test
 */
PURB
STDCALL
USBD_CreateConfigurationRequestEx(
    PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor,
    PUSBD_INTERFACE_LIST_ENTRY InterfaceList
    )
{
   11230:	55                   	push   %ebp
    PURB Urb;
    DWORD UrbSize;
    DWORD InterfaceCount;

    for (InterfaceCount = 0;
   11231:	31 c0                	xor    %eax,%eax
   11233:	89 e5                	mov    %esp,%ebp
   11235:	57                   	push   %edi
   11236:	56                   	push   %esi
   11237:	53                   	push   %ebx
   11238:	83 ec 0c             	sub    $0xc,%esp
   1123b:	8b 75 0c             	mov    0xc(%ebp),%esi
   1123e:	8b 3e                	mov    (%esi),%edi
   11240:	85 ff                	test   %edi,%edi
   11242:	eb 06                	jmp    1124a <_USBD_CreateConfigurationRequestEx@8+0x1a>
   11244:	40                   	inc    %eax
   11245:	8b 1c c6             	mov    (%esi,%eax,8),%ebx
   11248:	85 db                	test   %ebx,%ebx
   1124a:	75 f8                	jne    11244 <_USBD_CreateConfigurationRequestEx@8+0x14>
         InterfaceList[InterfaceCount].InterfaceDescriptor != NULL;
         ++InterfaceCount)
       ;
    /* Include the NULL entry */
    ++InterfaceCount;

    UrbSize = sizeof(Urb->UrbSelectConfiguration) + 
   1124c:	8d 1c 85 04 00 00 00 	lea    0x4(,%eax,4),%ebx
       (InterfaceCount * sizeof(PUSBD_INTERFACE_LIST_ENTRY));
    Urb = ExAllocatePool(NonPagedPool, UrbSize);
   11253:	51                   	push   %ecx
   11254:	51                   	push   %ecx
   11255:	8d 43 3c             	lea    0x3c(%ebx),%eax
   11258:	50                   	push   %eax
   11259:	6a 00                	push   $0x0
   1125b:	ff 15 54 30 01 00    	call   *0x13054
    Urb->UrbSelectConfiguration.Hdr.Function =
        URB_FUNCTION_SELECT_CONFIGURATION;        
    Urb->UrbSelectConfiguration.Hdr.Length =
        sizeof(Urb->UrbSelectConfiguration);
    Urb->UrbSelectConfiguration.ConfigurationDescriptor = 
   11261:	8b 55 08             	mov    0x8(%ebp),%edx
       ConfigurationDescriptor;
    memcpy((PVOID)&Urb->UrbSelectConfiguration.Interface, (PVOID)InterfaceList,
   11264:	89 d9                	mov    %ebx,%ecx
   11266:	fc                   	cld    
   11267:	66 c7 40 02 00 00    	movw   $0x0,0x2(%eax)
   1126d:	66 c7 00 3c 00       	movw   $0x3c,(%eax)
   11272:	89 50 10             	mov    %edx,0x10(%eax)
   11275:	8d 78 18             	lea    0x18(%eax),%edi
   11278:	c1 e9 02             	shr    $0x2,%ecx
   1127b:	f3 a5                	repz movsl %ds:(%esi),%es:(%edi)
       InterfaceCount * sizeof(PUSBD_INTERFACE_LIST_ENTRY));

    return Urb;
}
   1127d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11280:	5b                   	pop    %ebx
   11281:	5e                   	pop    %esi
   11282:	5f                   	pop    %edi
   11283:	5d                   	pop    %ebp
   11284:	c2 08 00             	ret    $0x8
   11287:	89 f6                	mov    %esi,%esi
   11289:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011290 <_USBD_CreateConfigurationRequest@8>:

/*
 * @unimplemented
 */
PURB STDCALL
USBD_CreateConfigurationRequest(
    PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor,
    PUSHORT Size
    )
{
   11290:	55                   	push   %ebp
    return NULL;
}
   11291:	31 c0                	xor    %eax,%eax
   11293:	89 e5                	mov    %esp,%ebp
   11295:	5d                   	pop    %ebp
   11296:	c2 08 00             	ret    $0x8
   11299:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

000112a0 <_USBD_GetInterfaceLength@8>:

/*
 * @unimplemented
 */
ULONG STDCALL
USBD_GetInterfaceLength(
    PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor,
    PUCHAR BufferEnd
    )
{
   112a0:	55                   	push   %ebp
    PUSB_INTERFACE_DESCRIPTOR CurrentDescriptor = InterfaceDescriptor;
    DWORD Length = CurrentDescriptor->bLength;
   112a1:	31 c9                	xor    %ecx,%ecx
   112a3:	89 e5                	mov    %esp,%ebp
   112a5:	53                   	push   %ebx
   112a6:	8b 55 08             	mov    0x8(%ebp),%edx
   112a9:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   112ac:	8a 02                	mov    (%edx),%al
   112ae:	88 c1                	mov    %al,%cl

    // USB_ENDPOINT_DESCRIPTOR_TYPE
    if (CurrentDescriptor->bDescriptorType == USB_INTERFACE_DESCRIPTOR_TYPE)
   112b0:	80 7a 01 04          	cmpb   $0x4,0x1(%edx)
   112b4:	74 0a                	je     112c0 <_USBD_GetInterfaceLength@8+0x20>
    {
        for (;
             (PUCHAR)CurrentDescriptor < BufferEnd;
             (PVOID)CurrentDescriptor += CurrentDescriptor->bLength)
            Length += CurrentDescriptor->bLength;

    }
    return Length;
}
   112b6:	89 c8                	mov    %ecx,%eax
   112b8:	5b                   	pop    %ebx
   112b9:	5d                   	pop    %ebp
   112ba:	c2 08 00             	ret    $0x8
   112bd:	8d 76 00             	lea    0x0(%esi),%esi
   112c0:	39 da                	cmp    %ebx,%edx
   112c2:	73 f2                	jae    112b6 <_USBD_GetInterfaceLength@8+0x16>
   112c4:	25 ff 00 00 00       	and    $0xff,%eax
   112c9:	01 c2                	add    %eax,%edx
   112cb:	01 c1                	add    %eax,%ecx
   112cd:	39 da                	cmp    %ebx,%edx
   112cf:	73 e5                	jae    112b6 <_USBD_GetInterfaceLength@8+0x16>
   112d1:	8a 02                	mov    (%edx),%al
   112d3:	25 ff 00 00 00       	and    $0xff,%eax
   112d8:	01 c2                	add    %eax,%edx
   112da:	01 c1                	add    %eax,%ecx
   112dc:	39 da                	cmp    %ebx,%edx
   112de:	72 f1                	jb     112d1 <_USBD_GetInterfaceLength@8+0x31>
   112e0:	89 c8                	mov    %ecx,%eax
   112e2:	5b                   	pop    %ebx
   112e3:	5d                   	pop    %ebp
   112e4:	c2 08 00             	ret    $0x8
   112e7:	89 f6                	mov    %esi,%esi
   112e9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000112f0 <_USBD_ParseConfigurationDescriptorEx@28>:

/*
 * @unimplemented
 */
PUSB_INTERFACE_DESCRIPTOR STDCALL
USBD_ParseConfigurationDescriptorEx(
    PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor,
    PVOID StartPosition,
    LONG InterfaceNumber,
    LONG AlternateSetting,
    LONG InterfaceClass,
    LONG InterfaceSubClass,
    LONG InterfaceProtocol
    )
{
   112f0:	55                   	push   %ebp
    return NULL;
}
   112f1:	31 c0                	xor    %eax,%eax
   112f3:	89 e5                	mov    %esp,%ebp
   112f5:	5d                   	pop    %ebp
   112f6:	c2 1c 00             	ret    $0x1c
   112f9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011300 <_USBD_ParseConfigurationDescriptor@12>:

/*
 * @implemented
 */
PUSB_INTERFACE_DESCRIPTOR STDCALL
USBD_ParseConfigurationDescriptor(
    PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor,
    UCHAR InterfaceNumber,
    UCHAR AlternateSetting
    )
{
   11300:	55                   	push   %ebp
    return USBD_ParseConfigurationDescriptorEx(ConfigurationDescriptor,
   11301:	31 c0                	xor    %eax,%eax
   11303:	89 e5                	mov    %esp,%ebp
   11305:	31 d2                	xor    %edx,%edx
   11307:	6a ff                	push   $0xffffffff
   11309:	6a ff                	push   $0xffffffff
   1130b:	8b 4d 08             	mov    0x8(%ebp),%ecx
   1130e:	8a 45 10             	mov    0x10(%ebp),%al
   11311:	8a 55 0c             	mov    0xc(%ebp),%dl
   11314:	6a ff                	push   $0xffffffff
   11316:	50                   	push   %eax
   11317:	52                   	push   %edx
   11318:	51                   	push   %ecx
   11319:	51                   	push   %ecx
   1131a:	e8 d1 ff ff ff       	call   112f0 <_USBD_ParseConfigurationDescriptorEx@28>
        (PVOID)ConfigurationDescriptor, InterfaceNumber, AlternateSetting,
        -1, -1, -1);
}
   1131f:	c9                   	leave  
   11320:	c2 0c 00             	ret    $0xc
   11323:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11329:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011330 <_USBD_ParseDescriptors@16>:

/*
 * @unimplemented
 */
PUSB_COMMON_DESCRIPTOR STDCALL
USBD_ParseDescriptors(
    PVOID  DescriptorBuffer,
    ULONG  TotalLength,
    PVOID  StartPosition,
    LONG  DescriptorType
    )
{
   11330:	55                   	push   %ebp
    return NULL; 
}
   11331:	31 c0                	xor    %eax,%eax
   11333:	89 e5                	mov    %esp,%ebp
   11335:	5d                   	pop    %ebp
   11336:	c2 10 00             	ret    $0x10
   11339:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011340 <_USBD_GetPdoRegistryParameter@20>:

/*
 * @implemented
 */
DWORD STDCALL
USBD_GetPdoRegistryParameter(
    PDEVICE_OBJECT PhysicalDeviceObject,
    PVOID Parameter,
    ULONG ParameterLength,
    PWCHAR KeyName,
    ULONG KeyNameLength
    )
{
   11340:	55                   	push   %ebp
   11341:	89 e5                	mov    %esp,%ebp
   11343:	57                   	push   %edi
   11344:	56                   	push   %esi
   11345:	53                   	push   %ebx
   11346:	83 ec 1c             	sub    $0x1c,%esp
    NTSTATUS Status;
    HANDLE DevInstRegKey;

    Status = IoOpenDeviceRegistryKey(PhysicalDeviceObject,
   11349:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
   1134c:	8b 75 08             	mov    0x8(%ebp),%esi
   1134f:	50                   	push   %eax
   11350:	68 00 00 1f 00       	push   $0x1f0000
   11355:	6a 02                	push   $0x2
   11357:	56                   	push   %esi
   11358:	ff 15 60 30 01 00    	call   *0x13060
   1135e:	89 c3                	mov    %eax,%ebx
        PLUGPLAY_REGKEY_DRIVER, STANDARD_RIGHTS_ALL, &DevInstRegKey);
    if (NT_SUCCESS(Status))
   11360:	85 c0                	test   %eax,%eax
   11362:	0f 88 89 00 00 00    	js     113f1 <_USBD_GetPdoRegistryParameter@20+0xb1>
    {
        PKEY_VALUE_FULL_INFORMATION FullInfo;
        UNICODE_STRING ValueName;
        ULONG Length;

        RtlInitUnicodeString(&ValueName, KeyName);
   11368:	8b 4d 14             	mov    0x14(%ebp),%ecx
   1136b:	8d 7d e0             	lea    0xffffffe0(%ebp),%edi
   1136e:	53                   	push   %ebx
   1136f:	53                   	push   %ebx
   11370:	51                   	push   %ecx
   11371:	57                   	push   %edi
   11372:	ff 15 64 30 01 00    	call   *0x13064
        Length = ParameterLength + KeyNameLength + sizeof(KEY_VALUE_FULL_INFORMATION);
   11378:	8b 55 10             	mov    0x10(%ebp),%edx
   1137b:	8b 45 18             	mov    0x18(%ebp),%eax
        FullInfo = ExAllocatePool(PagedPool, Length);
        if (FullInfo)
        {
            Status = ZwQueryValueKey(DevInstRegKey, &ValueName,
                KeyValueFullInformation, FullInfo, Length, &Length);
            if (NT_SUCCESS(Status))
            {
                RtlCopyMemory(Parameter,
                    ((PUCHAR)FullInfo) + FullInfo->DataOffset,
                    ParameterLength /*FullInfo->DataLength*/);
            }
            ExFreePool(FullInfo);
        } else
            Status = STATUS_NO_MEMORY;
   1137e:	bb 17 00 00 c0       	mov    $0xc0000017,%ebx
   11383:	8d 44 02 18          	lea    0x18(%edx,%eax,1),%eax
   11387:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
   1138a:	50                   	push   %eax
   1138b:	6a 01                	push   $0x1
   1138d:	ff 15 54 30 01 00    	call   *0x13054
   11393:	89 c6                	mov    %eax,%esi
   11395:	58                   	pop    %eax
   11396:	85 f6                	test   %esi,%esi
   11398:	5a                   	pop    %edx
   11399:	74 46                	je     113e1 <_USBD_GetPdoRegistryParameter@20+0xa1>
   1139b:	8b 5d dc             	mov    0xffffffdc(%ebp),%ebx
   1139e:	50                   	push   %eax
   1139f:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   113a2:	50                   	push   %eax
   113a3:	8d 45 dc             	lea    0xffffffdc(%ebp),%eax
   113a6:	50                   	push   %eax
   113a7:	53                   	push   %ebx
   113a8:	56                   	push   %esi
   113a9:	6a 01                	push   $0x1
   113ab:	57                   	push   %edi
   113ac:	51                   	push   %ecx
   113ad:	ff 15 6c 30 01 00    	call   *0x1306c
   113b3:	89 c3                	mov    %eax,%ebx
   113b5:	58                   	pop    %eax
   113b6:	85 db                	test   %ebx,%ebx
   113b8:	5a                   	pop    %edx
   113b9:	78 19                	js     113d4 <_USBD_GetPdoRegistryParameter@20+0x94>
   113bb:	8b 7e 08             	mov    0x8(%esi),%edi
   113be:	89 f0                	mov    %esi,%eax
   113c0:	01 f8                	add    %edi,%eax
   113c2:	8b 55 10             	mov    0x10(%ebp),%edx
   113c5:	51                   	push   %ecx
   113c6:	52                   	push   %edx
   113c7:	50                   	push   %eax
   113c8:	8b 45 0c             	mov    0xc(%ebp),%eax
   113cb:	50                   	push   %eax
   113cc:	e8 9f 00 00 00       	call   11470 <_memcpy>
   113d1:	83 c4 10             	add    $0x10,%esp
   113d4:	83 ec 0c             	sub    $0xc,%esp
   113d7:	56                   	push   %esi
   113d8:	ff 15 5c 30 01 00    	call   *0x1305c
   113de:	83 c4 0c             	add    $0xc,%esp
        ZwClose(DevInstRegKey);
   113e1:	83 ec 0c             	sub    $0xc,%esp
   113e4:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   113e7:	50                   	push   %eax
   113e8:	ff 15 68 30 01 00    	call   *0x13068
   113ee:	83 c4 0c             	add    $0xc,%esp
    }
    return Status;
}
   113f1:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   113f4:	89 d8                	mov    %ebx,%eax
   113f6:	5b                   	pop    %ebx
   113f7:	5e                   	pop    %esi
   113f8:	5f                   	pop    %edi
   113f9:	5d                   	pop    %ebp
   113fa:	c2 14 00             	ret    $0x14
   113fd:	90                   	nop    
   113fe:	90                   	nop    
   113ff:	90                   	nop    

00011400 <_ExAllocatePoolWithTag@12>:
   11400:	ff 25 58 30 01 00    	jmp    *0x13058
   11406:	90                   	nop    
   11407:	90                   	nop    
	...

00011410 <_ExFreePool@4>:
   11410:	ff 25 5c 30 01 00    	jmp    *0x1305c
   11416:	90                   	nop    
   11417:	90                   	nop    
	...

00011420 <_ExAllocatePool@8>:
   11420:	ff 25 54 30 01 00    	jmp    *0x13054
   11426:	90                   	nop    
   11427:	90                   	nop    
	...

00011430 <_IoOpenDeviceRegistryKey@16>:
   11430:	ff 25 60 30 01 00    	jmp    *0x13060
   11436:	90                   	nop    
   11437:	90                   	nop    
	...

00011440 <_RtlInitUnicodeString@8>:
   11440:	ff 25 64 30 01 00    	jmp    *0x13064
   11446:	90                   	nop    
   11447:	90                   	nop    
	...

00011450 <_ZwQueryValueKey@24>:
   11450:	ff 25 6c 30 01 00    	jmp    *0x1306c
   11456:	90                   	nop    
   11457:	90                   	nop    
	...

00011460 <_ZwClose@4>:
   11460:	ff 25 68 30 01 00    	jmp    *0x13068
   11466:	90                   	nop    
   11467:	90                   	nop    
	...

00011470 <_memcpy>:
   11470:	ff 25 70 30 01 00    	jmp    *0x13070
   11476:	90                   	nop    
   11477:	90                   	nop    
	...

00011480 <__CTOR_LIST__>:
   11480:	ff                   	(bad)  
   11481:	ff                   	(bad)  
   11482:	ff                   	(bad)  
   11483:	ff 00                	incl   (%eax)
   11485:	00 00                	add    %al,(%eax)
	...

00011488 <__DTOR_LIST__>:
   11488:	ff                   	(bad)  
   11489:	ff                   	(bad)  
   1148a:	ff                   	(bad)  
   1148b:	ff 00                	incl   (%eax)
   1148d:	00 00                	add    %al,(%eax)
	...
