
scsiport.nostrip.sys:     file format pei-i386

Disassembly of section .text:

00011000 <_DriverEntry@8>:

NTSTATUS STDCALL
DriverEntry(IN PDRIVER_OBJECT DriverObject,
	    IN PUNICODE_STRING RegistryPath)
{
   11000:	55                   	push   %ebp
  DPRINT("ScsiPort Driver %s\n", VERSION);
  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 <_ScsiDebugPrint>:


/**********************************************************************
 * NAME							EXPORTED
 *	ScsiDebugPrint
 *
 * DESCRIPTION
 *	Prints debugging messages.
 *
 * RUN LEVEL
 *	PASSIVE_LEVEL
 *
 * ARGUMENTS
 *	DebugPrintLevel
 *		Debug level of the given message.
 *
 *	DebugMessage
 *		Pointer to printf()-compatible format string.
 *
 *	...
  		Additional output data (see printf()).
 *
 * RETURN VALUE
 * 	None.
 *
 * @implemented
 */

VOID
ScsiDebugPrint(IN ULONG DebugPrintLevel,
	       IN PCHAR DebugMessage,
	       ...)
{
   11010:	55                   	push   %ebp
   11011:	89 e5                	mov    %esp,%ebp
   11013:	53                   	push   %ebx
   11014:	81 ec 04 01 00 00    	sub    $0x104,%esp
  char Buffer[256];
  va_list ap;

  if (DebugPrintLevel >= InternalDebugLevel)
   1101a:	a1 00 60 01 00       	mov    0x16000,%eax
   1101f:	39 45 08             	cmp    %eax,0x8(%ebp)
   11022:	72 0c                	jb     11030 <_ScsiDebugPrint+0x20>
    return;

  va_start(ap, DebugMessage);
  vsprintf(Buffer, DebugMessage, ap);
  va_end(ap);

  DbgPrint(Buffer);
}
   11024:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11027:	c9                   	leave  
   11028:	c3                   	ret    
   11029:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   11030:	8d 45 10             	lea    0x10(%ebp),%eax
   11033:	52                   	push   %edx
   11034:	50                   	push   %eax
   11035:	8b 45 0c             	mov    0xc(%ebp),%eax
   11038:	8d 9d f8 fe ff ff    	lea    0xfffffef8(%ebp),%ebx
   1103e:	50                   	push   %eax
   1103f:	53                   	push   %ebx
   11040:	e8 5b 32 00 00       	call   142a0 <_vsprintf>
   11045:	89 1c 24             	mov    %ebx,(%esp)
   11048:	e8 43 32 00 00       	call   14290 <_DbgPrint>
   1104d:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11050:	c9                   	leave  
   11051:	c3                   	ret    
   11052:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   11059:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011060 <_ScsiPortConvertPhysicalAddressToUlong@8>:


/*
 * @unimplemented
 */
VOID STDCALL
ScsiPortCompleteRequest(IN PVOID HwDeviceExtension,
			IN UCHAR PathId,
			IN UCHAR TargetId,
			IN UCHAR Lun,
			IN UCHAR SrbStatus)
{
  PSCSI_PORT_DEVICE_EXTENSION DeviceExtension;
  PSCSI_PORT_LUN_EXTENSION LunExtension;
  PLIST_ENTRY Entry;
  PIRP Irp;
  PSCSI_REQUEST_BLOCK Srb;

  DPRINT("ScsiPortCompleteRequest(HwDeviceExtension %x, PathId %d, TargetId %d, Lun %d, SrbStatus %x)\n",
         HwDeviceExtension, PathId, TargetId, Lun, SrbStatus);

  DeviceExtension = CONTAINING_RECORD(HwDeviceExtension,
				      SCSI_PORT_DEVICE_EXTENSION,
				      MiniPortDeviceExtension);

  Entry = DeviceExtension->LunExtensionListHead.Flink;
  while (Entry != &DeviceExtension->LunExtensionListHead)
    {
      LunExtension = CONTAINING_RECORD(Entry,
				       SCSI_PORT_LUN_EXTENSION,
				       List);



      if (PathId == (UCHAR)SP_UNTAGGED || 
	  (PathId == LunExtension->PathId && TargetId == (UCHAR)SP_UNTAGGED) ||
          (PathId == LunExtension->PathId && TargetId == LunExtension->TargetId && Lun == (UCHAR)SP_UNTAGGED) ||
          (PathId == LunExtension->PathId && TargetId == LunExtension->TargetId && Lun == LunExtension->Lun))
        {
	  Irp = LunExtension->NextIrp;
	  while (Irp)
	    {
	      Srb = (PSCSI_REQUEST_BLOCK)Irp->Tail.Overlay.DriverContext[3];
	      if (Srb->SrbFlags & SRB_FLAGS_IS_ACTIVE)
	        {
		  Srb->SrbStatus = SrbStatus;
		  ScsiPortNotification(RequestComplete,
		                       HwDeviceExtension,
				       Srb);
		}
              Irp = Irp->Tail.Overlay.DriverContext[1];
	    }
	}
      Entry = Entry->Flink;
    }
}


/*
 * @implemented
 */
ULONG STDCALL
ScsiPortConvertPhysicalAddressToUlong(IN SCSI_PHYSICAL_ADDRESS Address)
{
   11060:	55                   	push   %ebp
   11061:	89 e5                	mov    %esp,%ebp
  DPRINT("ScsiPortConvertPhysicalAddressToUlong()\n");
  return(Address.u.LowPart);
}
   11063:	8b 45 08             	mov    0x8(%ebp),%eax
   11066:	5d                   	pop    %ebp
   11067:	c2 08 00             	ret    $0x8
   1106a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00011070 <_ScsiPortFlushDma@4>:


/*
 * @unimplemented
 */
VOID STDCALL
ScsiPortFlushDma(IN PVOID HwDeviceExtension)
{
   11070:	55                   	push   %ebp
   11071:	89 e5                	mov    %esp,%ebp
   11073:	51                   	push   %ecx
   11074:	51                   	push   %ecx
  DPRINT("ScsiPortFlushDma()\n");
  UNIMPLEMENTED;
   11075:	68 24 01 00 00       	push   $0x124
   1107a:	68 11 50 01 00       	push   $0x15011
   1107f:	68 00 50 01 00       	push   $0x15000
   11084:	68 1c 50 01 00       	push   $0x1501c
   11089:	e8 02 32 00 00       	call   14290 <_DbgPrint>
   1108e:	c9                   	leave  
   1108f:	c2 04 00             	ret    $0x4
   11092:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   11099:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000110a0 <_ScsiPortFreeDeviceBase@8>:
}


/*
 * @implemented
 */
VOID STDCALL
ScsiPortFreeDeviceBase(IN PVOID HwDeviceExtension,
		       IN PVOID MappedAddress)
{
   110a0:	55                   	push   %ebp
   110a1:	89 e5                	mov    %esp,%ebp
   110a3:	56                   	push   %esi
   110a4:	53                   	push   %ebx
   110a5:	8b 45 08             	mov    0x8(%ebp),%eax
   110a8:	8b 75 0c             	mov    0xc(%ebp),%esi
  PSCSI_PORT_DEVICE_EXTENSION DeviceExtension;
  PSCSI_PORT_DEVICE_BASE DeviceBase;
  PLIST_ENTRY Entry;

  DPRINT("ScsiPortFreeDeviceBase() called\n");

  DeviceExtension = CONTAINING_RECORD(HwDeviceExtension,
   110ab:	8d 88 74 ff ff ff    	lea    0xffffff74(%eax),%ecx
				      SCSI_PORT_DEVICE_EXTENSION,
				      MiniPortDeviceExtension);
  if (IsListEmpty(&DeviceExtension->DeviceBaseListHead))
   110b1:	83 e8 68             	sub    $0x68,%eax
   110b4:	8b 51 24             	mov    0x24(%ecx),%edx
   110b7:	39 c2                	cmp    %eax,%edx
   110b9:	74 13                	je     110ce <_ScsiPortFreeDeviceBase@8+0x2e>
    return;

  Entry = DeviceExtension->DeviceBaseListHead.Flink;
   110bb:	89 d3                	mov    %edx,%ebx
   110bd:	eb 0b                	jmp    110ca <_ScsiPortFreeDeviceBase@8+0x2a>
   110bf:	90                   	nop    
  while (Entry != &DeviceExtension->DeviceBaseListHead)
    {
      DeviceBase = CONTAINING_RECORD(Entry,
				     SCSI_PORT_DEVICE_BASE,
				     List);
      if (DeviceBase->MappedAddress == MappedAddress)
   110c0:	39 73 08             	cmp    %esi,0x8(%ebx)
   110c3:	74 12                	je     110d7 <_ScsiPortFreeDeviceBase@8+0x37>
	{
	  MmUnmapIoSpace(DeviceBase->MappedAddress,
			 DeviceBase->NumberOfBytes);
	  RemoveEntryList(Entry);
	  ExFreePool(DeviceBase);

	  return;
	}

      Entry = Entry->Flink;
   110c5:	8b 1b                	mov    (%ebx),%ebx
   110c7:	8d 41 24             	lea    0x24(%ecx),%eax
   110ca:	39 d8                	cmp    %ebx,%eax
   110cc:	75 f2                	jne    110c0 <_ScsiPortFreeDeviceBase@8+0x20>
    }
}
   110ce:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   110d1:	5b                   	pop    %ebx
   110d2:	5e                   	pop    %esi
   110d3:	5d                   	pop    %ebp
   110d4:	c2 08 00             	ret    $0x8
   110d7:	50                   	push   %eax
   110d8:	50                   	push   %eax
   110d9:	8b 43 0c             	mov    0xc(%ebx),%eax
   110dc:	50                   	push   %eax
   110dd:	8b 43 08             	mov    0x8(%ebx),%eax
   110e0:	50                   	push   %eax
   110e1:	e8 ca 2e 00 00       	call   13fb0 <_MmUnmapIoSpace@8>
 */
static __inline BOOLEAN
RemoveEntryList(
  IN PLIST_ENTRY  Entry)
{
   110e6:	56                   	push   %esi
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
   110e7:	8b 13                	mov    (%ebx),%edx
  OldBlink = Entry->Blink;
   110e9:	8b 43 04             	mov    0x4(%ebx),%eax
  OldFlink->Blink = OldBlink;
   110ec:	89 42 04             	mov    %eax,0x4(%edx)
  OldBlink->Flink = OldFlink;
   110ef:	89 10                	mov    %edx,(%eax)
	{
	  MmUnmapIoSpace(DeviceBase->MappedAddress,
			 DeviceBase->NumberOfBytes);
	  RemoveEntryList(Entry);
	  ExFreePool(DeviceBase);
   110f1:	53                   	push   %ebx
   110f2:	e8 c9 2e 00 00       	call   13fc0 <_ExFreePool@4>

	  return;
	}

      Entry = Entry->Flink;
    }
}
   110f7:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   110fa:	5b                   	pop    %ebx
   110fb:	5e                   	pop    %esi
   110fc:	5d                   	pop    %ebp
   110fd:	c2 08 00             	ret    $0x8

00011100 <_ScsiPortGetBusData@24>:


/*
 * @implemented
 */
ULONG STDCALL
ScsiPortGetBusData(IN PVOID DeviceExtension,
		   IN ULONG BusDataType,
		   IN ULONG SystemIoBusNumber,
		   IN ULONG SlotNumber,
		   IN PVOID Buffer,
		   IN ULONG Length)
{
   11100:	55                   	push   %ebp
   11101:	89 e5                	mov    %esp,%ebp
   11103:	83 ec 14             	sub    $0x14,%esp
  return(HalGetBusData(BusDataType,
   11106:	8b 45 14             	mov    0x14(%ebp),%eax
   11109:	8b 4d 1c             	mov    0x1c(%ebp),%ecx
   1110c:	8b 55 18             	mov    0x18(%ebp),%edx
   1110f:	51                   	push   %ecx
   11110:	52                   	push   %edx
   11111:	50                   	push   %eax
   11112:	8b 45 10             	mov    0x10(%ebp),%eax
   11115:	50                   	push   %eax
   11116:	8b 45 0c             	mov    0xc(%ebp),%eax
   11119:	50                   	push   %eax
   1111a:	e8 a1 31 00 00       	call   142c0 <_HalGetBusData@20>
		       SystemIoBusNumber,
		       SlotNumber,
		       Buffer,
		       Length));
}
   1111f:	c9                   	leave  
   11120:	c2 18 00             	ret    $0x18
   11123:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11129:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011130 <_ScsiPortGetDeviceBase@28>:


/*
 * @implemented
 */
PVOID STDCALL
ScsiPortGetDeviceBase(IN PVOID HwDeviceExtension,
		      IN INTERFACE_TYPE BusType,
		      IN ULONG SystemIoBusNumber,
		      IN SCSI_PHYSICAL_ADDRESS IoAddress,
		      IN ULONG NumberOfBytes,
		      IN BOOLEAN InIoSpace)
{
   11130:	55                   	push   %ebp
  PSCSI_PORT_DEVICE_EXTENSION DeviceExtension;
  PHYSICAL_ADDRESS TranslatedAddress;
  PSCSI_PORT_DEVICE_BASE DeviceBase;
  ULONG AddressSpace;
  PVOID MappedAddress;

  DPRINT ("ScsiPortGetDeviceBase() called\n");

  AddressSpace = (ULONG)InIoSpace;
   11131:	31 c0                	xor    %eax,%eax
   11133:	89 e5                	mov    %esp,%ebp
   11135:	57                   	push   %edi
   11136:	56                   	push   %esi
   11137:	53                   	push   %ebx
   11138:	83 ec 24             	sub    $0x24,%esp
   1113b:	8a 45 20             	mov    0x20(%ebp),%al
   1113e:	8b 75 14             	mov    0x14(%ebp),%esi
   11141:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
  if (HalTranslateBusAddress(BusType,
   11144:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
   11147:	8b 7d 18             	mov    0x18(%ebp),%edi
   1114a:	50                   	push   %eax
   1114b:	8d 45 e4             	lea    0xffffffe4(%ebp),%eax
   1114e:	50                   	push   %eax
   1114f:	57                   	push   %edi
   11150:	8b 45 10             	mov    0x10(%ebp),%eax
   11153:	56                   	push   %esi
   11154:	50                   	push   %eax
   11155:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   11158:	53                   	push   %ebx
   11159:	e8 72 31 00 00       	call   142d0 <_HalTranslateBusAddress@24>
   1115e:	5a                   	pop    %edx
			     SystemIoBusNumber,
			     IoAddress,
			     &AddressSpace,
			     &TranslatedAddress) == FALSE)
    return NULL;
   1115f:	31 d2                	xor    %edx,%edx
   11161:	59                   	pop    %ecx
   11162:	84 c0                	test   %al,%al
   11164:	74 0a                	je     11170 <_ScsiPortGetDeviceBase@28+0x40>

  /* i/o space */
  if (AddressSpace != 0)
   11166:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   11169:	85 c0                	test   %eax,%eax
   1116b:	74 13                	je     11180 <_ScsiPortGetDeviceBase@28+0x50>
    return((PVOID)TranslatedAddress.u.LowPart);
   1116d:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx

  MappedAddress = MmMapIoSpace(TranslatedAddress,
			       NumberOfBytes,
			       MmNonCached);

  DeviceBase = ExAllocatePool(NonPagedPool,
			      sizeof(SCSI_PORT_DEVICE_BASE));
  if (DeviceBase == NULL)
    return(MappedAddress);

  DeviceBase->MappedAddress = MappedAddress;
  DeviceBase->NumberOfBytes = NumberOfBytes;
  DeviceBase->IoAddress = IoAddress;
  DeviceBase->SystemIoBusNumber = SystemIoBusNumber;

  DeviceExtension = CONTAINING_RECORD(HwDeviceExtension,
				      SCSI_PORT_DEVICE_EXTENSION,
				      MiniPortDeviceExtension);

  InsertHeadList(&DeviceExtension->DeviceBaseListHead,
		 &DeviceBase->List);

  return(MappedAddress);
}
   11170:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11173:	89 d0                	mov    %edx,%eax
   11175:	5b                   	pop    %ebx
   11176:	5e                   	pop    %esi
   11177:	5f                   	pop    %edi
   11178:	5d                   	pop    %ebp
   11179:	c2 1c 00             	ret    $0x1c
   1117c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11180:	6a 00                	push   $0x0
   11182:	8b 45 1c             	mov    0x1c(%ebp),%eax
   11185:	50                   	push   %eax
   11186:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11189:	50                   	push   %eax
   1118a:	8b 5d e8             	mov    0xffffffe8(%ebp),%ebx
   1118d:	53                   	push   %ebx
   1118e:	e8 3d 2e 00 00       	call   13fd0 <_MmMapIoSpace@16>
   11193:	89 c3                	mov    %eax,%ebx
   11195:	51                   	push   %ecx
   11196:	51                   	push   %ecx
   11197:	6a 20                	push   $0x20
   11199:	6a 00                	push   $0x0
   1119b:	e8 40 2e 00 00       	call   13fe0 <_ExAllocatePool@8>
   111a0:	89 c1                	mov    %eax,%ecx
   111a2:	58                   	pop    %eax
   111a3:	85 c9                	test   %ecx,%ecx
   111a5:	5a                   	pop    %edx
   111a6:	89 da                	mov    %ebx,%edx
   111a8:	74 c6                	je     11170 <_ScsiPortGetDeviceBase@28+0x40>
   111aa:	8b 45 1c             	mov    0x1c(%ebp),%eax
   111ad:	89 71 10             	mov    %esi,0x10(%ecx)
   111b0:	8b 75 10             	mov    0x10(%ebp),%esi
static __inline VOID
InsertHeadList(
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
   111b3:	8b 55 08             	mov    0x8(%ebp),%edx
   111b6:	89 71 18             	mov    %esi,0x18(%ecx)
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldFlink;
	OldFlink = ListHead->Flink;
   111b9:	8b 75 08             	mov    0x8(%ebp),%esi
   111bc:	89 41 0c             	mov    %eax,0xc(%ecx)
static __inline VOID
InsertHeadList(
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
   111bf:	83 ea 68             	sub    $0x68,%edx
	PLIST_ENTRY OldFlink;
	OldFlink = ListHead->Flink;
   111c2:	8b 46 98             	mov    0xffffff98(%esi),%eax
	Entry->Flink = OldFlink;
	Entry->Blink = ListHead;
   111c5:	89 51 04             	mov    %edx,0x4(%ecx)
   111c8:	89 da                	mov    %ebx,%edx
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldFlink;
	OldFlink = ListHead->Flink;
	Entry->Flink = OldFlink;
   111ca:	89 01                	mov    %eax,(%ecx)
	Entry->Blink = ListHead;
	OldFlink->Blink = Entry;
   111cc:	89 48 04             	mov    %ecx,0x4(%eax)
   111cf:	89 59 08             	mov    %ebx,0x8(%ecx)
   111d2:	89 79 14             	mov    %edi,0x14(%ecx)
	OldFlink = ListHead->Flink;
	Entry->Flink = OldFlink;
	Entry->Blink = ListHead;
	OldFlink->Blink = Entry;
	ListHead->Flink = Entry;
   111d5:	89 4e 98             	mov    %ecx,0xffffff98(%esi)
   111d8:	89 d0                	mov    %edx,%eax
   111da:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   111dd:	5b                   	pop    %ebx
   111de:	5e                   	pop    %esi
   111df:	5f                   	pop    %edi
   111e0:	5d                   	pop    %ebp
   111e1:	c2 1c 00             	ret    $0x1c
   111e4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   111ea:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

000111f0 <_ScsiPortGetLogicalUnit@16>:


/*
 * @implemented
 */
PVOID STDCALL
ScsiPortGetLogicalUnit(IN PVOID HwDeviceExtension,
		       IN UCHAR PathId,
		       IN UCHAR TargetId,
		       IN UCHAR Lun)
{
   111f0:	55                   	push   %ebp
   111f1:	89 e5                	mov    %esp,%ebp
   111f3:	56                   	push   %esi
   111f4:	53                   	push   %ebx
   111f5:	51                   	push   %ecx
   111f6:	8b 75 08             	mov    0x8(%ebp),%esi
   111f9:	8a 45 10             	mov    0x10(%ebp),%al
   111fc:	8a 5d 14             	mov    0x14(%ebp),%bl
   111ff:	88 45 f7             	mov    %al,0xfffffff7(%ebp)
   11202:	88 5d f6             	mov    %bl,0xfffffff6(%ebp)
  PSCSI_PORT_DEVICE_EXTENSION DeviceExtension;
  PSCSI_PORT_LUN_EXTENSION LunExtension;
  PLIST_ENTRY Entry;

  DPRINT("ScsiPortGetLogicalUnit() called\n");

  DeviceExtension = CONTAINING_RECORD(HwDeviceExtension,
				      SCSI_PORT_DEVICE_EXTENSION,
				      MiniPortDeviceExtension);
  if (IsListEmpty(&DeviceExtension->LunExtensionListHead))
   11205:	8b 46 a4             	mov    0xffffffa4(%esi),%eax
   11208:	8d 5e a4             	lea    0xffffffa4(%esi),%ebx
    return NULL;
   1120b:	31 d2                	xor    %edx,%edx
   1120d:	8a 4d 0c             	mov    0xc(%ebp),%cl
   11210:	39 d8                	cmp    %ebx,%eax
   11212:	74 2d                	je     11241 <_ScsiPortGetLogicalUnit@16+0x51>

  Entry = DeviceExtension->LunExtensionListHead.Flink;
  while (Entry != &DeviceExtension->LunExtensionListHead)
    {
      LunExtension = CONTAINING_RECORD(Entry,
				       SCSI_PORT_LUN_EXTENSION,
				       List);
      if (LunExtension->PathId == PathId &&
	  LunExtension->TargetId == TargetId &&
	  LunExtension->Lun == Lun)
	{
	  return (PVOID)&LunExtension->MiniportLunExtension;
	}

      Entry = Entry->Flink;
   11214:	39 c3                	cmp    %eax,%ebx
   11216:	74 38                	je     11250 <_ScsiPortGetLogicalUnit@16+0x60>
   11218:	8d 56 a4             	lea    0xffffffa4(%esi),%edx
   1121b:	eb 09                	jmp    11226 <_ScsiPortGetLogicalUnit@16+0x36>
   1121d:	8d 76 00             	lea    0x0(%esi),%esi
   11220:	8b 00                	mov    (%eax),%eax
   11222:	39 c2                	cmp    %eax,%edx
   11224:	74 2a                	je     11250 <_ScsiPortGetLogicalUnit@16+0x60>
   11226:	38 48 08             	cmp    %cl,0x8(%eax)
   11229:	75 f5                	jne    11220 <_ScsiPortGetLogicalUnit@16+0x30>
   1122b:	8a 5d f7             	mov    0xfffffff7(%ebp),%bl
   1122e:	38 58 09             	cmp    %bl,0x9(%eax)
   11231:	75 ed                	jne    11220 <_ScsiPortGetLogicalUnit@16+0x30>
   11233:	8a 5d f6             	mov    0xfffffff6(%ebp),%bl
   11236:	38 58 0a             	cmp    %bl,0xa(%eax)
   11239:	75 e5                	jne    11220 <_ScsiPortGetLogicalUnit@16+0x30>
   1123b:	8d 90 80 00 00 00    	lea    0x80(%eax),%edx
    }

  return NULL;
}
   11241:	89 d0                	mov    %edx,%eax
   11243:	5a                   	pop    %edx
   11244:	5b                   	pop    %ebx
   11245:	5e                   	pop    %esi
   11246:	5d                   	pop    %ebp
   11247:	c2 10 00             	ret    $0x10
   1124a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11250:	31 d2                	xor    %edx,%edx
   11252:	89 d0                	mov    %edx,%eax
   11254:	5a                   	pop    %edx
   11255:	5b                   	pop    %ebx
   11256:	5e                   	pop    %esi
   11257:	5d                   	pop    %ebp
   11258:	c2 10 00             	ret    $0x10
   1125b:	90                   	nop    
   1125c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011260 <_ScsiPortGetPhysicalAddress@16>:


/*
 * @unimplemented
 */
SCSI_PHYSICAL_ADDRESS STDCALL
ScsiPortGetPhysicalAddress(IN PVOID HwDeviceExtension,
			   IN PSCSI_REQUEST_BLOCK Srb OPTIONAL,
			   IN PVOID VirtualAddress,
			   OUT ULONG *Length)
{
   11260:	55                   	push   %ebp
   11261:	89 e5                	mov    %esp,%ebp
   11263:	57                   	push   %edi
   11264:	56                   	push   %esi
   11265:	53                   	push   %ebx
   11266:	83 ec 1c             	sub    $0x1c,%esp
  PSCSI_PORT_DEVICE_EXTENSION DeviceExtension;
  SCSI_PHYSICAL_ADDRESS PhysicalAddress;
  SCSI_PHYSICAL_ADDRESS NextPhysicalAddress;
  ULONG BufferLength = 0;
  ULONG Offset;
  PVOID EndAddress;

  DPRINT("ScsiPortGetPhysicalAddress(%p %p %p %p)\n",
	 HwDeviceExtension, Srb, VirtualAddress, Length);

  DeviceExtension = CONTAINING_RECORD(HwDeviceExtension,
   11269:	8b 75 08             	mov    0x8(%ebp),%esi
				      SCSI_PORT_DEVICE_EXTENSION,
				      MiniPortDeviceExtension);

  if (Length != NULL)
   1126c:	8b 5d 14             	mov    0x14(%ebp),%ebx
   1126f:	81 ee 8c 00 00 00    	sub    $0x8c,%esi
   11275:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   11278:	85 db                	test   %ebx,%ebx
   1127a:	74 09                	je     11285 <_ScsiPortGetPhysicalAddress@16+0x25>
    {
      *Length = 0;
   1127c:	8b 45 14             	mov    0x14(%ebp),%eax
   1127f:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
    }
  if (Srb == NULL)
   11285:	85 c9                	test   %ecx,%ecx
   11287:	0f 84 13 01 00 00    	je     113a0 <_ScsiPortGetPhysicalAddress@16+0x140>
    {
      EndAddress = DeviceExtension->VirtualAddress + DeviceExtension->CommonBufferLength;
      if (VirtualAddress >= DeviceExtension->VirtualAddress && VirtualAddress < EndAddress)
        {
	  Offset = (ULONG_PTR)VirtualAddress - (ULONG_PTR)DeviceExtension->VirtualAddress;
	  PhysicalAddress.QuadPart = DeviceExtension->PhysicalAddress.QuadPart + Offset;
          BufferLength = (ULONG_PTR)EndAddress - (ULONG_PTR)VirtualAddress;
	}
      else
        {
	  /*
	   * The given virtual address is not within the range 
	   * of the drivers uncached extension or srb extension.
	   */
	  /*
	   * FIXME: 
	   *   Check if the address is a sense info buffer of an active srb.
	   */
	  PhysicalAddress = MmGetPhysicalAddress(VirtualAddress);
	  if (PhysicalAddress.QuadPart == 0LL)
	    {
	      CHECKPOINT;
	      return PhysicalAddress;
	    }
	  BufferLength = PAGE_SIZE - PhysicalAddress.u.LowPart % PAGE_SIZE;
	}
    }
  else
    {
      EndAddress = Srb->DataBuffer + Srb->DataTransferLength;
   1128d:	8b 41 18             	mov    0x18(%ecx),%eax
   11290:	8b 51 10             	mov    0x10(%ecx),%edx
   11293:	01 c2                	add    %eax,%edx
   11295:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
      if (VirtualAddress == NULL)
   11298:	8b 55 10             	mov    0x10(%ebp),%edx
   1129b:	85 d2                	test   %edx,%edx
   1129d:	0f 84 40 01 00 00    	je     113e3 <_ScsiPortGetPhysicalAddress@16+0x183>
	{
	  VirtualAddress = Srb->DataBuffer;
	}
      else if (VirtualAddress < Srb->DataBuffer || VirtualAddress >= EndAddress)
   112a3:	3b 45 10             	cmp    0x10(%ebp),%eax
   112a6:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   112a9:	0f 97 c2             	seta   %dl
   112ac:	39 45 10             	cmp    %eax,0x10(%ebp)
   112af:	0f 93 c0             	setae  %al
   112b2:	09 d0                	or     %edx,%eax
   112b4:	a8 01                	test   $0x1,%al
   112b6:	0f 85 a8 00 00 00    	jne    11364 <_ScsiPortGetPhysicalAddress@16+0x104>
	{
	  EndAddress = Srb->SenseInfoBuffer + Srb->SenseInfoBufferLength;
	  if (VirtualAddress < Srb->SenseInfoBuffer || VirtualAddress >= EndAddress)
	    {
	      PhysicalAddress.QuadPart = 0LL;
	      CHECKPOINT;
	      return PhysicalAddress;
	    }
	}

      PhysicalAddress = MmGetPhysicalAddress(VirtualAddress);
   112bc:	83 ec 0c             	sub    $0xc,%esp
   112bf:	8b 45 10             	mov    0x10(%ebp),%eax
   112c2:	50                   	push   %eax
   112c3:	e8 28 2d 00 00       	call   13ff0 <_MmGetPhysicalAddress@4>
      if (PhysicalAddress.QuadPart == 0LL)
	{
	  CHECKPOINT;
	  return PhysicalAddress;
   112c8:	89 d1                	mov    %edx,%ecx
   112ca:	83 c4 0c             	add    $0xc,%esp
   112cd:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
   112d0:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   112d3:	89 c2                	mov    %eax,%edx
   112d5:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   112d8:	0b 45 e8             	or     0xffffffe8(%ebp),%eax
   112db:	74 79                	je     11356 <_ScsiPortGetPhysicalAddress@16+0xf6>
	}

      BufferLength = PAGE_SIZE - (ULONG_PTR)VirtualAddress % PAGE_SIZE;
   112dd:	8b 45 10             	mov    0x10(%ebp),%eax
   112e0:	bf 00 10 00 00       	mov    $0x1000,%edi
   112e5:	25 ff 0f 00 00       	and    $0xfff,%eax
      while (VirtualAddress + BufferLength < EndAddress)
	{
	  NextPhysicalAddress = MmGetPhysicalAddress(VirtualAddress + BufferLength);
	  if (PhysicalAddress.QuadPart + BufferLength != NextPhysicalAddress.QuadPart)
	    {
	      break;
	    }
	  BufferLength += PAGE_SIZE;
   112ea:	8b 55 10             	mov    0x10(%ebp),%edx
   112ed:	29 c7                	sub    %eax,%edi
   112ef:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   112f2:	01 fa                	add    %edi,%edx
   112f4:	89 55 e0             	mov    %edx,0xffffffe0(%ebp)
   112f7:	39 c2                	cmp    %eax,%edx
   112f9:	73 41                	jae    1133c <_ScsiPortGetPhysicalAddress@16+0xdc>
   112fb:	90                   	nop    
   112fc:	8d 74 26 00          	lea    0x0(%esi),%esi
   11300:	83 ec 0c             	sub    $0xc,%esp
   11303:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   11306:	31 db                	xor    %ebx,%ebx
   11308:	50                   	push   %eax
   11309:	e8 e2 2c 00 00       	call   13ff0 <_MmGetPhysicalAddress@4>
   1130e:	89 f9                	mov    %edi,%ecx
   11310:	03 4d e8             	add    0xffffffe8(%ebp),%ecx
   11313:	13 5d ec             	adc    0xffffffec(%ebp),%ebx
   11316:	31 c8                	xor    %ecx,%eax
   11318:	89 de                	mov    %ebx,%esi
   1131a:	83 c4 0c             	add    $0xc,%esp
   1131d:	31 d6                	xor    %edx,%esi
   1131f:	09 c6                	or     %eax,%esi
   11321:	0f 85 fd 00 00 00    	jne    11424 <_ScsiPortGetPhysicalAddress@16+0x1c4>
   11327:	81 c7 00 10 00 00    	add    $0x1000,%edi
   1132d:	8b 55 10             	mov    0x10(%ebp),%edx
   11330:	01 fa                	add    %edi,%edx
   11332:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   11335:	89 55 e0             	mov    %edx,0xffffffe0(%ebp)
   11338:	39 c2                	cmp    %eax,%edx
   1133a:	72 c4                	jb     11300 <_ScsiPortGetPhysicalAddress@16+0xa0>
	}
      if (VirtualAddress + BufferLength >= EndAddress)
	{
	  BufferLength = EndAddress - VirtualAddress;
   1133c:	8b 7d e4             	mov    0xffffffe4(%ebp),%edi
   1133f:	8b 75 10             	mov    0x10(%ebp),%esi
   11342:	29 f7                	sub    %esi,%edi
	}
    }
  if (Length != NULL)
   11344:	8b 5d 14             	mov    0x14(%ebp),%ebx
   11347:	85 db                	test   %ebx,%ebx
   11349:	74 05                	je     11350 <_ScsiPortGetPhysicalAddress@16+0xf0>
    {
      *Length = BufferLength;
   1134b:	8b 45 14             	mov    0x14(%ebp),%eax
   1134e:	89 38                	mov    %edi,(%eax)
    }
  DPRINT("Address %I64x, Length %d\n", PhysicalAddress.QuadPart, BufferLength);
  return PhysicalAddress;
   11350:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   11353:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
}
   11356:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11359:	89 d0                	mov    %edx,%eax
   1135b:	89 ca                	mov    %ecx,%edx
   1135d:	5b                   	pop    %ebx
   1135e:	5e                   	pop    %esi
   1135f:	5f                   	pop    %edi
   11360:	5d                   	pop    %ebp
   11361:	c2 10 00             	ret    $0x10
   11364:	31 d2                	xor    %edx,%edx
   11366:	8b 41 1c             	mov    0x1c(%ecx),%eax
   11369:	8a 51 0b             	mov    0xb(%ecx),%dl
   1136c:	3b 45 10             	cmp    0x10(%ebp),%eax
   1136f:	8d 14 10             	lea    (%eax,%edx,1),%edx
   11372:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
   11375:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   11378:	0f 97 c2             	seta   %dl
   1137b:	39 45 10             	cmp    %eax,0x10(%ebp)
   1137e:	0f 93 c0             	setae  %al
   11381:	09 d0                	or     %edx,%eax
   11383:	31 c9                	xor    %ecx,%ecx
   11385:	31 d2                	xor    %edx,%edx
   11387:	a8 01                	test   $0x1,%al
   11389:	0f 84 2d ff ff ff    	je     112bc <_ScsiPortGetPhysicalAddress@16+0x5c>
   1138f:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11392:	89 d0                	mov    %edx,%eax
   11394:	89 ca                	mov    %ecx,%edx
   11396:	5b                   	pop    %ebx
   11397:	5e                   	pop    %esi
   11398:	5f                   	pop    %edi
   11399:	5d                   	pop    %ebp
   1139a:	c2 10 00             	ret    $0x10
   1139d:	8d 76 00             	lea    0x0(%esi),%esi
   113a0:	8b 4e 60             	mov    0x60(%esi),%ecx
   113a3:	8b 56 74             	mov    0x74(%esi),%edx
   113a6:	01 ca                	add    %ecx,%edx
   113a8:	3b 4d 10             	cmp    0x10(%ebp),%ecx
   113ab:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
   113ae:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   113b1:	0f 96 c2             	setbe  %dl
   113b4:	39 45 10             	cmp    %eax,0x10(%ebp)
   113b7:	0f 92 c0             	setb   %al
   113ba:	25 ff 00 00 00       	and    $0xff,%eax
   113bf:	85 c2                	test   %eax,%edx
   113c1:	74 28                	je     113eb <_ScsiPortGetPhysicalAddress@16+0x18b>
   113c3:	8b 45 10             	mov    0x10(%ebp),%eax
   113c6:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
   113cd:	29 c8                	sub    %ecx,%eax
   113cf:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   113d2:	8b 46 58             	mov    0x58(%esi),%eax
   113d5:	8b 56 5c             	mov    0x5c(%esi),%edx
   113d8:	01 45 e8             	add    %eax,0xffffffe8(%ebp)
   113db:	11 55 ec             	adc    %edx,0xffffffec(%ebp)
   113de:	e9 59 ff ff ff       	jmp    1133c <_ScsiPortGetPhysicalAddress@16+0xdc>
   113e3:	89 45 10             	mov    %eax,0x10(%ebp)
   113e6:	e9 d1 fe ff ff       	jmp    112bc <_ScsiPortGetPhysicalAddress@16+0x5c>
   113eb:	83 ec 0c             	sub    $0xc,%esp
   113ee:	8b 4d 10             	mov    0x10(%ebp),%ecx
   113f1:	51                   	push   %ecx
   113f2:	e8 f9 2b 00 00       	call   13ff0 <_MmGetPhysicalAddress@4>
   113f7:	89 d1                	mov    %edx,%ecx
   113f9:	83 c4 0c             	add    $0xc,%esp
   113fc:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
   113ff:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   11402:	89 c2                	mov    %eax,%edx
   11404:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11407:	0b 45 e8             	or     0xffffffe8(%ebp),%eax
   1140a:	0f 84 46 ff ff ff    	je     11356 <_ScsiPortGetPhysicalAddress@16+0xf6>
   11410:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11413:	bf 00 10 00 00       	mov    $0x1000,%edi
   11418:	25 ff 0f 00 00       	and    $0xfff,%eax
   1141d:	29 c7                	sub    %eax,%edi
   1141f:	e9 20 ff ff ff       	jmp    11344 <_ScsiPortGetPhysicalAddress@16+0xe4>
   11424:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
   11427:	39 55 e0             	cmp    %edx,0xffffffe0(%ebp)
   1142a:	0f 82 14 ff ff ff    	jb     11344 <_ScsiPortGetPhysicalAddress@16+0xe4>
   11430:	e9 07 ff ff ff       	jmp    1133c <_ScsiPortGetPhysicalAddress@16+0xdc>
   11435:	8d 74 26 00          	lea    0x0(%esi),%esi
   11439:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011440 <_ScsiPortGetSrb@20>:


/*
 * @unimplemented
 */
PSCSI_REQUEST_BLOCK STDCALL
ScsiPortGetSrb(IN PVOID HwDeviceExtension,
	       IN UCHAR PathId,
	       IN UCHAR TargetId,
	       IN UCHAR Lun,
	       IN LONG QueueTag)
{
   11440:	55                   	push   %ebp
   11441:	89 e5                	mov    %esp,%ebp
   11443:	83 ec 0c             	sub    $0xc,%esp
  DPRINT1("ScsiPortGetSrb() unimplemented\n");
   11446:	68 36 02 00 00       	push   $0x236
   1144b:	68 11 50 01 00       	push   $0x15011
   11450:	68 54 50 01 00       	push   $0x15054
   11455:	e8 36 2e 00 00       	call   14290 <_DbgPrint>
   1145a:	c7 04 24 60 50 01 00 	movl   $0x15060,(%esp)
   11461:	e8 2a 2e 00 00       	call   14290 <_DbgPrint>
  UNIMPLEMENTED;
   11466:	68 37 02 00 00       	push   $0x237
   1146b:	68 11 50 01 00       	push   $0x15011
   11470:	68 45 50 01 00       	push   $0x15045
   11475:	68 1c 50 01 00       	push   $0x1501c
   1147a:	e8 11 2e 00 00       	call   14290 <_DbgPrint>
  return NULL;
}
   1147f:	31 c0                	xor    %eax,%eax
   11481:	c9                   	leave  
   11482:	c2 14 00             	ret    $0x14
   11485:	8d 74 26 00          	lea    0x0(%esi),%esi
   11489:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011490 <_ScsiPortGetUncachedExtension@12>:


/*
 * @implemented
 */
PVOID STDCALL
ScsiPortGetUncachedExtension(IN PVOID HwDeviceExtension,
			     IN PPORT_CONFIGURATION_INFORMATION ConfigInfo,
			     IN ULONG NumberOfBytes)
{
   11490:	55                   	push   %ebp
   11491:	89 e5                	mov    %esp,%ebp
   11493:	57                   	push   %edi
   11494:	56                   	push   %esi
   11495:	53                   	push   %ebx
   11496:	83 ec 3c             	sub    $0x3c,%esp
  PSCSI_PORT_DEVICE_EXTENSION DeviceExtension;
  DEVICE_DESCRIPTION DeviceDescription;

  DPRINT("ScsiPortGetUncachedExtension(%p %p %lu)\n",
	 HwDeviceExtension, ConfigInfo, NumberOfBytes);

  DeviceExtension = CONTAINING_RECORD(HwDeviceExtension,
   11499:	8b 75 08             	mov    0x8(%ebp),%esi
   1149c:	8b 7d 0c             	mov    0xc(%ebp),%edi
   1149f:	81 ee 8c 00 00 00    	sub    $0x8c,%esi
				      SCSI_PORT_DEVICE_EXTENSION,
				      MiniPortDeviceExtension);

  /* Check for allocated common DMA buffer */
  if (DeviceExtension->VirtualAddress != NULL)
   114a5:	8b 46 60             	mov    0x60(%esi),%eax
   114a8:	85 c0                	test   %eax,%eax
   114aa:	0f 85 9d 01 00 00    	jne    1164d <_ScsiPortGetUncachedExtension@12+0x1bd>
    {
      DPRINT1("The HBA has already got a common DMA buffer!\n");
      return NULL;
    }

  /* Check for DMA adapter object */
  if (DeviceExtension->AdapterObject == NULL)
   114b0:	8b 5e 50             	mov    0x50(%esi),%ebx
   114b3:	85 db                	test   %ebx,%ebx
   114b5:	0f 84 f5 00 00 00    	je     115b0 <_ScsiPortGetUncachedExtension@12+0x120>
    {
      /* Initialize DMA adapter description */
      RtlZeroMemory(&DeviceDescription,
		    sizeof(DEVICE_DESCRIPTION));
      DeviceDescription.Version = DEVICE_DESCRIPTION_VERSION;
      DeviceDescription.Master = ConfigInfo->Master;
      DeviceDescription.ScatterGather = ConfigInfo->ScatterGather;
      DeviceDescription.DemandMode = ConfigInfo->DemandMode;
      DeviceDescription.Dma32BitAddresses = ConfigInfo->Dma32BitAddresses;
      DeviceDescription.BusNumber = ConfigInfo->SystemIoBusNumber;
      DeviceDescription.DmaChannel = ConfigInfo->DmaChannel;
      DeviceDescription.InterfaceType = ConfigInfo->AdapterInterfaceType;
      DeviceDescription.DmaWidth = ConfigInfo->DmaWidth;
      DeviceDescription.DmaSpeed = ConfigInfo->DmaSpeed;
      DeviceDescription.MaximumLength = ConfigInfo->MaximumTransferLength;
      DeviceDescription.DmaPort = ConfigInfo->DmaPort;

      /* Get a DMA adapter object */
      DeviceExtension->AdapterObject = HalGetAdapter(&DeviceDescription,
						     &DeviceExtension->MapRegisterCount);
      if (DeviceExtension->AdapterObject == NULL)
	{
	  DPRINT1("HalGetAdapter() failed\n");
	  return NULL;
	}
    }
  if (DeviceExtension->SrbExtensionSize > 0)
   114bb:	8b 46 38             	mov    0x38(%esi),%eax
   114be:	85 c0                	test   %eax,%eax
   114c0:	75 6e                	jne    11530 <_ScsiPortGetUncachedExtension@12+0xa0>
    {
      PVOID Buffer;
      DeviceExtension->CurrentSrbExtensions = 0;
      if (DeviceExtension->PortConfig->MultipleRequestPerLu)
        {
          DeviceExtension->MaxSrbExtensions = 1024;
	}
      else
        {
	  DeviceExtension->MaxSrbExtensions = 32;
	}
      Buffer = ExAllocatePool(NonPagedPool, ROUND_UP(DeviceExtension->MaxSrbExtensions / 8, sizeof(ULONG)));
      if (Buffer == NULL)
        {
          KEBUGCHECK(0);
          return NULL;
        }
      RtlInitializeBitMap(&DeviceExtension->SrbExtensionAllocMap, Buffer, DeviceExtension->MaxSrbExtensions);
      RtlClearAllBits(&DeviceExtension->SrbExtensionAllocMap);
    }

  /* Allocate a common DMA buffer */
  DeviceExtension->CommonBufferLength =
   114c2:	8b 56 6c             	mov    0x6c(%esi),%edx
   114c5:	0f af c2             	imul   %edx,%eax
   114c8:	a9 ff 0f 00 00       	test   $0xfff,%eax
   114cd:	0f 84 c0 00 00 00    	je     11593 <_ScsiPortGetUncachedExtension@12+0x103>
   114d3:	25 00 f0 ff ff       	and    $0xfffff000,%eax
   114d8:	8b 4d 10             	mov    0x10(%ebp),%ecx
   114db:	8d 94 08 00 10 00 00 	lea    0x1000(%eax,%ecx,1),%edx
    NumberOfBytes + PAGE_ROUND_UP(DeviceExtension->SrbExtensionSize * DeviceExtension->MaxSrbExtensions);
  DeviceExtension->VirtualAddress =
   114e2:	8d 46 58             	lea    0x58(%esi),%eax
   114e5:	89 56 74             	mov    %edx,0x74(%esi)
   114e8:	6a 00                	push   $0x0
   114ea:	50                   	push   %eax
   114eb:	52                   	push   %edx
   114ec:	8b 46 50             	mov    0x50(%esi),%eax
   114ef:	50                   	push   %eax
   114f0:	e8 eb 2d 00 00       	call   142e0 <_HalAllocateCommonBuffer@16>
   114f5:	89 c2                	mov    %eax,%edx
    HalAllocateCommonBuffer(DeviceExtension->AdapterObject,
			    DeviceExtension->CommonBufferLength,
			    &DeviceExtension->PhysicalAddress,
			    FALSE);
  if (DeviceExtension->VirtualAddress == NULL)
   114f7:	85 c0                	test   %eax,%eax
   114f9:	89 46 60             	mov    %eax,0x60(%esi)
   114fc:	0f 84 6e 01 00 00    	je     11670 <_ScsiPortGetUncachedExtension@12+0x1e0>
    {
      DPRINT1("HalAllocateCommonBuffer() failed!\n");
      DeviceExtension->CommonBufferLength = 0;
      return NULL;
    }

  return (PVOID)((ULONG_PTR)DeviceExtension->VirtualAddress +
   11502:	8b 46 6c             	mov    0x6c(%esi),%eax
   11505:	8b 7e 38             	mov    0x38(%esi),%edi
   11508:	0f af c7             	imul   %edi,%eax
   1150b:	a9 ff 0f 00 00       	test   $0xfff,%eax
   11510:	0f 84 8a 00 00 00    	je     115a0 <_ScsiPortGetUncachedExtension@12+0x110>
   11516:	25 00 f0 ff ff       	and    $0xfffff000,%eax
                 PAGE_ROUND_UP(DeviceExtension->SrbExtensionSize * DeviceExtension->MaxSrbExtensions));
}
   1151b:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1151e:	5b                   	pop    %ebx
   1151f:	5e                   	pop    %esi
   11520:	8d 84 02 00 10 00 00 	lea    0x1000(%edx,%eax,1),%eax
   11527:	5f                   	pop    %edi
   11528:	5d                   	pop    %ebp
   11529:	c2 0c 00             	ret    $0xc
   1152c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11530:	8b 46 08             	mov    0x8(%esi),%eax
   11533:	c7 46 70 00 00 00 00 	movl   $0x0,0x70(%esi)
   1153a:	8a 40 55             	mov    0x55(%eax),%al
   1153d:	3c 01                	cmp    $0x1,%al
   1153f:	19 c0                	sbb    %eax,%eax
   11541:	25 20 fc ff ff       	and    $0xfffffc20,%eax
   11546:	05 00 04 00 00       	add    $0x400,%eax
   1154b:	89 46 6c             	mov    %eax,0x6c(%esi)
   1154e:	53                   	push   %ebx
   1154f:	c1 e8 03             	shr    $0x3,%eax
   11552:	53                   	push   %ebx
   11553:	50                   	push   %eax
   11554:	6a 00                	push   $0x0
   11556:	e8 85 2a 00 00       	call   13fe0 <_ExAllocatePool@8>
   1155b:	5a                   	pop    %edx
   1155c:	85 c0                	test   %eax,%eax
   1155e:	59                   	pop    %ecx
   1155f:	0f 84 37 01 00 00    	je     1169c <_ScsiPortGetUncachedExtension@12+0x20c>
   11565:	57                   	push   %edi
   11566:	8b 5e 6c             	mov    0x6c(%esi),%ebx
   11569:	53                   	push   %ebx
   1156a:	8d 5e 64             	lea    0x64(%esi),%ebx
   1156d:	50                   	push   %eax
   1156e:	53                   	push   %ebx
   1156f:	e8 8c 2a 00 00       	call   14000 <_RtlInitializeBitMap@12>
   11574:	51                   	push   %ecx
   11575:	51                   	push   %ecx
   11576:	53                   	push   %ebx
   11577:	e8 94 2a 00 00       	call   14010 <_RtlClearAllBits@4>
   1157c:	8b 46 38             	mov    0x38(%esi),%eax
   1157f:	8b 56 6c             	mov    0x6c(%esi),%edx
   11582:	0f af c2             	imul   %edx,%eax
   11585:	83 c4 0c             	add    $0xc,%esp
   11588:	a9 ff 0f 00 00       	test   $0xfff,%eax
   1158d:	0f 85 40 ff ff ff    	jne    114d3 <_ScsiPortGetUncachedExtension@12+0x43>
   11593:	8b 4d 10             	mov    0x10(%ebp),%ecx
   11596:	8d 14 08             	lea    (%eax,%ecx,1),%edx
   11599:	e9 44 ff ff ff       	jmp    114e2 <_ScsiPortGetUncachedExtension@12+0x52>
   1159e:	89 f6                	mov    %esi,%esi
   115a0:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   115a3:	8d 04 02             	lea    (%edx,%eax,1),%eax
   115a6:	5b                   	pop    %ebx
   115a7:	5e                   	pop    %esi
   115a8:	5f                   	pop    %edi
   115a9:	5d                   	pop    %ebp
   115aa:	c2 0c 00             	ret    $0xc
   115ad:	8d 76 00             	lea    0x0(%esi),%esi
   115b0:	8d 5d b8             	lea    0xffffffb8(%ebp),%ebx
   115b3:	51                   	push   %ecx
   115b4:	51                   	push   %ecx
   115b5:	6a 28                	push   $0x28
   115b7:	53                   	push   %ebx
   115b8:	e8 63 2a 00 00       	call   14020 <_RtlZeroMemory@8>
   115bd:	c7 45 b8 00 00 00 00 	movl   $0x0,0xffffffb8(%ebp)
   115c4:	8a 47 4a             	mov    0x4a(%edi),%al
   115c7:	88 45 bc             	mov    %al,0xffffffbc(%ebp)
   115ca:	8a 47 49             	mov    0x49(%edi),%al
   115cd:	88 45 bd             	mov    %al,0xffffffbd(%ebp)
   115d0:	8a 47 50             	mov    0x50(%edi),%al
   115d3:	88 45 be             	mov    %al,0xffffffbe(%ebp)
   115d6:	8a 47 4f             	mov    0x4f(%edi),%al
   115d9:	88 45 c0             	mov    %al,0xffffffc0(%ebp)
   115dc:	8b 47 04             	mov    0x4(%edi),%eax
   115df:	89 45 c4             	mov    %eax,0xffffffc4(%ebp)
   115e2:	8b 47 20             	mov    0x20(%edi),%eax
   115e5:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)
   115e8:	8b 47 08             	mov    0x8(%edi),%eax
   115eb:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
   115ee:	8b 47 28             	mov    0x28(%edi),%eax
   115f1:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
   115f4:	8b 47 2c             	mov    0x2c(%edi),%eax
   115f7:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
   115fa:	8b 47 18             	mov    0x18(%edi),%eax
   115fd:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
   11600:	8b 47 24             	mov    0x24(%edi),%eax
   11603:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
   11606:	8b 45 08             	mov    0x8(%ebp),%eax
   11609:	83 e8 38             	sub    $0x38,%eax
   1160c:	50                   	push   %eax
   1160d:	53                   	push   %ebx
   1160e:	e8 dd 2c 00 00       	call   142f0 <_HalGetAdapter@8>
   11613:	85 c0                	test   %eax,%eax
   11615:	89 46 50             	mov    %eax,0x50(%esi)
   11618:	5f                   	pop    %edi
   11619:	5a                   	pop    %edx
   1161a:	0f 85 9b fe ff ff    	jne    114bb <_ScsiPortGetUncachedExtension@12+0x2b>
   11620:	56                   	push   %esi
   11621:	68 6d 02 00 00       	push   $0x26d
   11626:	68 11 50 01 00       	push   $0x15011
   1162b:	68 54 50 01 00       	push   $0x15054
   11630:	e8 5b 2c 00 00       	call   14290 <_DbgPrint>
   11635:	c7 04 24 80 50 01 00 	movl   $0x15080,(%esp)
   1163c:	e8 4f 2c 00 00       	call   14290 <_DbgPrint>
   11641:	31 c0                	xor    %eax,%eax
   11643:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11646:	5b                   	pop    %ebx
   11647:	5e                   	pop    %esi
   11648:	5f                   	pop    %edi
   11649:	5d                   	pop    %ebp
   1164a:	c2 0c 00             	ret    $0xc
   1164d:	56                   	push   %esi
   1164e:	68 51 02 00 00       	push   $0x251
   11653:	68 11 50 01 00       	push   $0x15011
   11658:	68 54 50 01 00       	push   $0x15054
   1165d:	e8 2e 2c 00 00       	call   14290 <_DbgPrint>
   11662:	c7 04 24 98 50 01 00 	movl   $0x15098,(%esp)
   11669:	e8 22 2c 00 00       	call   14290 <_DbgPrint>
   1166e:	eb d1                	jmp    11641 <_ScsiPortGetUncachedExtension@12+0x1b1>
   11670:	50                   	push   %eax
   11671:	68 91 02 00 00       	push   $0x291
   11676:	68 11 50 01 00       	push   $0x15011
   1167b:	68 54 50 01 00       	push   $0x15054
   11680:	e8 0b 2c 00 00       	call   14290 <_DbgPrint>
   11685:	c7 04 24 c8 50 01 00 	movl   $0x150c8,(%esp)
   1168c:	e8 ff 2b 00 00       	call   14290 <_DbgPrint>
   11691:	31 c0                	xor    %eax,%eax
   11693:	c7 46 74 00 00 00 00 	movl   $0x0,0x74(%esi)
   1169a:	eb a7                	jmp    11643 <_ScsiPortGetUncachedExtension@12+0x1b3>
   1169c:	50                   	push   %eax
   1169d:	68 80 02 00 00       	push   $0x280
   116a2:	68 11 50 01 00       	push   $0x15011
   116a7:	68 eb 50 01 00       	push   $0x150eb
   116ac:	e8 df 2b 00 00       	call   14290 <_DbgPrint>
   116b1:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   116b8:	e8 73 29 00 00       	call   14030 <_KeBugCheck@4>
   116bd:	31 c0                	xor    %eax,%eax
   116bf:	eb 82                	jmp    11643 <_ScsiPortGetUncachedExtension@12+0x1b3>
   116c1:	eb 0d                	jmp    116d0 <_ScsiPortGetVirtualAddress@12>
   116c3:	90                   	nop    
   116c4:	90                   	nop    
   116c5:	90                   	nop    
   116c6:	90                   	nop    
   116c7:	90                   	nop    
   116c8:	90                   	nop    
   116c9:	90                   	nop    
   116ca:	90                   	nop    
   116cb:	90                   	nop    
   116cc:	90                   	nop    
   116cd:	90                   	nop    
   116ce:	90                   	nop    
   116cf:	90                   	nop    

000116d0 <_ScsiPortGetVirtualAddress@12>:


/*
 * @implemented
 */
PVOID STDCALL
ScsiPortGetVirtualAddress(IN PVOID HwDeviceExtension,
			  IN SCSI_PHYSICAL_ADDRESS PhysicalAddress)
{
   116d0:	55                   	push   %ebp
   116d1:	89 e5                	mov    %esp,%ebp
   116d3:	56                   	push   %esi
   116d4:	53                   	push   %ebx
  PSCSI_PORT_DEVICE_EXTENSION DeviceExtension;
  ULONG Offset;

  DPRINT("ScsiPortGetVirtualAddress(%p %I64x)\n",
	 HwDeviceExtension, PhysicalAddress.QuadPart);

  DeviceExtension = CONTAINING_RECORD(HwDeviceExtension,
   116d5:	8b 75 08             	mov    0x8(%ebp),%esi
   116d8:	8b 5d 10             	mov    0x10(%ebp),%ebx
   116db:	81 ee 8c 00 00 00    	sub    $0x8c,%esi
   116e1:	8b 4d 0c             	mov    0xc(%ebp),%ecx
				      SCSI_PORT_DEVICE_EXTENSION,
				      MiniPortDeviceExtension);

  if (DeviceExtension->PhysicalAddress.QuadPart > PhysicalAddress.QuadPart)
   116e4:	8b 56 5c             	mov    0x5c(%esi),%edx
   116e7:	8b 46 58             	mov    0x58(%esi),%eax
   116ea:	39 da                	cmp    %ebx,%edx
   116ec:	7c 06                	jl     116f4 <_ScsiPortGetVirtualAddress@12+0x24>
   116ee:	7f 20                	jg     11710 <_ScsiPortGetVirtualAddress@12+0x40>
   116f0:	39 c8                	cmp    %ecx,%eax
   116f2:	77 1c                	ja     11710 <_ScsiPortGetVirtualAddress@12+0x40>
    return NULL;

  Offset = (ULONG)(PhysicalAddress.QuadPart - DeviceExtension->PhysicalAddress.QuadPart);
   116f4:	8b 46 58             	mov    0x58(%esi),%eax
   116f7:	89 ca                	mov    %ecx,%edx
   116f9:	29 c2                	sub    %eax,%edx
  if (Offset >= DeviceExtension->CommonBufferLength)
    return NULL;
   116fb:	31 c0                	xor    %eax,%eax
   116fd:	39 56 74             	cmp    %edx,0x74(%esi)
   11700:	76 05                	jbe    11707 <_ScsiPortGetVirtualAddress@12+0x37>

  return (PVOID)((ULONG_PTR)DeviceExtension->VirtualAddress + Offset);
   11702:	8b 46 60             	mov    0x60(%esi),%eax
   11705:	01 d0                	add    %edx,%eax
}
   11707:	5b                   	pop    %ebx
   11708:	5e                   	pop    %esi
   11709:	5d                   	pop    %ebp
   1170a:	c2 0c 00             	ret    $0xc
   1170d:	8d 76 00             	lea    0x0(%esi),%esi
   11710:	31 c0                	xor    %eax,%eax
   11712:	5b                   	pop    %ebx
   11713:	5e                   	pop    %esi
   11714:	5d                   	pop    %ebp
   11715:	c2 0c 00             	ret    $0xc
   11718:	90                   	nop    
   11719:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011720 <_ScsiPortIoMapTransfer@16>:


/**********************************************************************
 * NAME							EXPORTED
 *	ScsiPortInitialize
 *
 * DESCRIPTION
 *	Initializes SCSI port driver specific data.
 *
 * RUN LEVEL
 *	PASSIVE_LEVEL
 *
 * ARGUMENTS
 *	Argument1
 *		Pointer to the miniport driver's driver object.
 *
 *	Argument2
 *		Pointer to the miniport driver's registry path.
 *
 *	HwInitializationData
 *		Pointer to port driver specific configuration data.
 *
 *	HwContext
  		Miniport driver specific context.
 *
 * RETURN VALUE
 * 	Status.
 *
 * @implemented
 */

ULONG STDCALL
ScsiPortInitialize(IN PVOID Argument1,
		   IN PVOID Argument2,
		   IN struct _HW_INITIALIZATION_DATA *HwInitializationData,
		   IN PVOID HwContext)
{
  PDRIVER_OBJECT DriverObject = (PDRIVER_OBJECT)Argument1;
//  PUNICODE_STRING RegistryPath = (PUNICODE_STRING)Argument2;
  PSCSI_PORT_DEVICE_EXTENSION DeviceExtension;
  PCONFIGURATION_INFORMATION SystemConfig;
  PPORT_CONFIGURATION_INFORMATION PortConfig;
  ULONG DeviceExtensionSize;
  ULONG PortConfigSize;
  BOOLEAN Again;
  BOOLEAN DeviceFound = FALSE;
  ULONG i;
  ULONG Result;
  NTSTATUS Status;
  ULONG MaxBus;
  ULONG BusNumber;
  PCI_SLOT_NUMBER SlotNumber;

  PDEVICE_OBJECT PortDeviceObject;
  WCHAR NameBuffer[80];
  UNICODE_STRING DeviceName;
  WCHAR DosNameBuffer[80];
  UNICODE_STRING DosDeviceName;
  PIO_SCSI_CAPABILITIES PortCapabilities;
  ULONG MappedIrq;
  KIRQL Dirql;
  KAFFINITY Affinity;


  DPRINT ("ScsiPortInitialize() called!\n");
#if 0
  DPRINT1("HwInitializationDataSize: %d\n", HwInitializationData->HwInitializationDataSize);
  DPRINT1("AdapterInterfaceType:     %d\n", HwInitializationData->AdapterInterfaceType);
  DPRINT1("HwInitialize:             %x\n", HwInitializationData->HwInitialize);
  DPRINT1("HwStartIo:                %x\n", HwInitializationData->HwStartIo);
  DPRINT1("HwInterrupt:              %x\n", HwInitializationData->HwInterrupt);
  DPRINT1("HwFindAdapter:            %x\n", HwInitializationData->HwFindAdapter);
  DPRINT1("HwResetBus:               %x\n", HwInitializationData->HwResetBus);
  DPRINT1("HwDmaStarted:             %x\n", HwInitializationData->HwDmaStarted);
  DPRINT1("HwAdapterState:           %x\n", HwInitializationData->HwAdapterState);
  DPRINT1("DeviceExtensionSize:      %d\n", HwInitializationData->DeviceExtensionSize);
  DPRINT1("SpecificLuExtensionSize:  %d\n", HwInitializationData->SpecificLuExtensionSize);
  DPRINT1("SrbExtensionSize:         %d\n", HwInitializationData->SrbExtensionSize);
  DPRINT1("NumberOfAccessRanges:     %d\n", HwInitializationData->NumberOfAccessRanges);
  DPRINT1("Reserved:                 %x\n", HwInitializationData->Reserved);
  DPRINT1("MapBuffers:               %d\n", HwInitializationData->MapBuffers);
  DPRINT1("NeedPhysicalAddresses:    %d\n", HwInitializationData->NeedPhysicalAddresses);
  DPRINT1("TaggedQueueing:           %d\n", HwInitializationData->TaggedQueueing);
  DPRINT1("AutoRequestSense:         %d\n", HwInitializationData->AutoRequestSense);
  DPRINT1("MultipleRequestPerLu:     %d\n", HwInitializationData->MultipleRequestPerLu);
  DPRINT1("ReceiveEvent:             %d\n", HwInitializationData->ReceiveEvent);
  DPRINT1("VendorIdLength:           %d\n", HwInitializationData->VendorIdLength);
  DPRINT1("VendorId:                 %x\n", HwInitializationData->VendorId);
  DPRINT1("ReservedUshort:           %d\n", HwInitializationData->ReservedUshort);
  DPRINT1("DeviceIdLength:           %d\n", HwInitializationData->DeviceIdLength);
  DPRINT1("DeviceId:                 %x\n", HwInitializationData->DeviceId);
#endif
  if ((HwInitializationData->HwInitialize == NULL) ||
      (HwInitializationData->HwStartIo == NULL) ||
      (HwInitializationData->HwInterrupt == NULL) ||
      (HwInitializationData->HwFindAdapter == NULL) ||
      (HwInitializationData->HwResetBus == NULL))
    return(STATUS_INVALID_PARAMETER);

  DriverObject->DriverStartIo = NULL;
  DriverObject->MajorFunction[IRP_MJ_CREATE] = ScsiPortCreateClose;
  DriverObject->MajorFunction[IRP_MJ_CLOSE] = ScsiPortCreateClose;
  DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ScsiPortDeviceControl;
  DriverObject->MajorFunction[IRP_MJ_SCSI] = ScsiPortDispatchScsi;

  SystemConfig = IoGetConfigurationInformation();

  DeviceExtensionSize = sizeof(SCSI_PORT_DEVICE_EXTENSION) +
    HwInitializationData->DeviceExtensionSize;
  PortConfigSize = sizeof(PORT_CONFIGURATION_INFORMATION) + 
    HwInitializationData->NumberOfAccessRanges * sizeof(ACCESS_RANGE);


  MaxBus = (HwInitializationData->AdapterInterfaceType == PCIBus) ? 8 : 1;
  DPRINT("MaxBus: %lu\n", MaxBus);

  PortDeviceObject = NULL;
  BusNumber = 0;
  SlotNumber.u.AsULONG = 0;
  while (TRUE)
    {
      /* Create a unicode device name */
      swprintf (NameBuffer,
		L"\\Device\\ScsiPort%lu",
		SystemConfig->ScsiPortCount);
      RtlInitUnicodeString (&DeviceName,
			    NameBuffer);

      DPRINT("Creating device: %wZ\n", &DeviceName);

      /* Create the port device */
      Status = IoCreateDevice (DriverObject,
			       DeviceExtensionSize,
			       &DeviceName,
			       FILE_DEVICE_CONTROLLER,
			       0,
			       FALSE,
			       &PortDeviceObject);
      if (!NT_SUCCESS(Status))
	{
	  DbgPrint ("IoCreateDevice call failed! (Status 0x%lX)\n", Status);
	  PortDeviceObject = NULL;
	  goto ByeBye;
	}

      DPRINT ("Created device: %wZ (%p)\n", &DeviceName, PortDeviceObject);

      /* Set the buffering strategy here... */
      PortDeviceObject->Flags |= DO_DIRECT_IO;
      PortDeviceObject->AlignmentRequirement = FILE_WORD_ALIGNMENT;

      DeviceExtension = PortDeviceObject->DeviceExtension;
      RtlZeroMemory(DeviceExtension, DeviceExtensionSize);
      DeviceExtension->Length = DeviceExtensionSize;
      DeviceExtension->DeviceObject = PortDeviceObject;
      DeviceExtension->PortNumber = SystemConfig->ScsiPortCount;

      DeviceExtension->MiniPortExtensionSize = HwInitializationData->DeviceExtensionSize;
      DeviceExtension->LunExtensionSize = HwInitializationData->SpecificLuExtensionSize;
      DeviceExtension->SrbExtensionSize = HwInitializationData->SrbExtensionSize;
      DeviceExtension->HwStartIo = HwInitializationData->HwStartIo;
      DeviceExtension->HwInterrupt = HwInitializationData->HwInterrupt;

      DeviceExtension->AdapterObject = NULL;
      DeviceExtension->MapRegisterCount = 0;
      DeviceExtension->PhysicalAddress.QuadPart = 0ULL;
      DeviceExtension->VirtualAddress = NULL;
      DeviceExtension->CommonBufferLength = 0;

      /* Initialize the device base list */
      InitializeListHead (&DeviceExtension->DeviceBaseListHead);

      /* Initialize the irp lists */
      InitializeListHead (&DeviceExtension->PendingIrpListHead);
      DeviceExtension->NextIrp = NULL;
      DeviceExtension->PendingIrpCount = 0;
      DeviceExtension->ActiveIrpCount = 0;

      /* Initialize LUN-Extension list */
      InitializeListHead (&DeviceExtension->LunExtensionListHead);

      /* Initialize the spin lock in the controller extension */
      KeInitializeSpinLock (&DeviceExtension->Lock);

      /* Initialize the DPC object */
      IoInitializeDpcRequest (PortDeviceObject,
			      ScsiPortDpc);

      /* Initialize the device timer */
      DeviceExtension->TimerState = IDETimerIdle;
      DeviceExtension->TimerCount = 0;
      IoInitializeTimer (PortDeviceObject,
			 ScsiPortIoTimer,
			 DeviceExtension);

      /* Allocate and initialize port configuration info */
      DeviceExtension->PortConfig = ExAllocatePool (NonPagedPool,
						    PortConfigSize);
      if (DeviceExtension->PortConfig == NULL)
	{
	  Status = STATUS_INSUFFICIENT_RESOURCES;
	  goto ByeBye;
	}
      RtlZeroMemory (DeviceExtension->PortConfig,
		     PortConfigSize);

      PortConfig = DeviceExtension->PortConfig;
      PortConfig->Length = sizeof(PORT_CONFIGURATION_INFORMATION);
      PortConfig->SystemIoBusNumber = BusNumber;
      PortConfig->AdapterInterfaceType = HwInitializationData->AdapterInterfaceType;
      PortConfig->InterruptMode =
	(PortConfig->AdapterInterfaceType == PCIBus) ? LevelSensitive : Latched;
      PortConfig->MaximumTransferLength = SP_UNINITIALIZED_VALUE;
      PortConfig->NumberOfPhysicalBreaks = SP_UNINITIALIZED_VALUE;
      PortConfig->DmaChannel = SP_UNINITIALIZED_VALUE;
      PortConfig->DmaPort = SP_UNINITIALIZED_VALUE;
      PortConfig->DmaWidth = 0;
      PortConfig->DmaSpeed = Compatible;
      PortConfig->AlignmentMask = 0;
      PortConfig->NumberOfAccessRanges = HwInitializationData->NumberOfAccessRanges;
      PortConfig->NumberOfBuses = 0;

      for (i = 0; i < SCSI_MAXIMUM_BUSES; i++)
	PortConfig->InitiatorBusId[i] = 255;

      PortConfig->ScatterGather = FALSE;
      PortConfig->Master = FALSE;
      PortConfig->CachesData = FALSE;
      PortConfig->AdapterScansDown = FALSE;
      PortConfig->AtdiskPrimaryClaimed = SystemConfig->AtDiskPrimaryAddressClaimed;
      PortConfig->AtdiskSecondaryClaimed = SystemConfig->AtDiskSecondaryAddressClaimed;
      PortConfig->Dma32BitAddresses = FALSE;
      PortConfig->DemandMode = FALSE;
      PortConfig->MapBuffers = HwInitializationData->MapBuffers;
      PortConfig->NeedPhysicalAddresses = HwInitializationData->NeedPhysicalAddresses;
      PortConfig->TaggedQueuing = HwInitializationData->TaggedQueueing;
      PortConfig->AutoRequestSense = HwInitializationData->AutoRequestSense;
      PortConfig->MultipleRequestPerLu = HwInitializationData->MultipleRequestPerLu;
      PortConfig->ReceiveEvent = HwInitializationData->ReceiveEvent;
      PortConfig->RealModeInitialized = FALSE;
      PortConfig->BufferAccessScsiPortControlled = FALSE;
      PortConfig->MaximumNumberOfTargets = SCSI_MAXIMUM_TARGETS;
//      PortConfig->MaximumNumberOfLogicalUnits = SCSI_MAXIMUM_LOGICAL_UNITS;

      PortConfig->SrbExtensionSize = HwInitializationData->SrbExtensionSize;
      PortConfig->SpecificLuExtensionSize = HwInitializationData->SpecificLuExtensionSize;

      PortConfig->AccessRanges = (PACCESS_RANGE)(PortConfig + 1);

      /* Search for matching PCI device */
      if ((HwInitializationData->AdapterInterfaceType == PCIBus) &&
	  (HwInitializationData->VendorIdLength > 0) &&
	  (HwInitializationData->VendorId != NULL) &&
	  (HwInitializationData->DeviceIdLength > 0) &&
	  (HwInitializationData->DeviceId != NULL))
	{
	  /* Get PCI device data */
	  DPRINT("VendorId '%.*s'  DeviceId '%.*s'\n",
		 HwInitializationData->VendorIdLength,
		 HwInitializationData->VendorId,
		 HwInitializationData->DeviceIdLength,
		 HwInitializationData->DeviceId);

	  if (!SpiGetPciConfigData (HwInitializationData,
				    PortConfig,
				    BusNumber,
				    &SlotNumber))
	    {
	      Status = STATUS_UNSUCCESSFUL;
	      goto ByeBye;
	    }
	}

      /* Note: HwFindAdapter is called once for each bus */
      Again = FALSE;
      DPRINT("Calling HwFindAdapter() for Bus %lu\n", PortConfig->SystemIoBusNumber);
      Result = (HwInitializationData->HwFindAdapter)(&DeviceExtension->MiniPortDeviceExtension,
						     HwContext,
						     0,  /* BusInformation */
						     "", /* ArgumentString */
						     PortConfig,
						     &Again);
      DPRINT("HwFindAdapter() Result: %lu  Again: %s\n",
	     Result, (Again) ? "True" : "False");

      if (Result == SP_RETURN_FOUND)
	{
	  DPRINT("ScsiPortInitialize(): Found HBA! (%x)\n", PortConfig->BusInterruptVector);

#if 0
	  DPRINT1("SystemIoBusNumber:               %x\n", PortConfig->SystemIoBusNumber);
	  DPRINT1("AdapterInterfaceType:            %x\n", PortConfig->AdapterInterfaceType);
	  DPRINT1("BusInterruptLevel:               %x\n", PortConfig->BusInterruptLevel);
	  DPRINT1("BusInterruptVector:              %x\n", PortConfig->BusInterruptVector);
	  DPRINT1("InterruptMode:                   %x\n", PortConfig->InterruptMode);
	  DPRINT1("MaximumTransferLength:           %x\n", PortConfig->MaximumTransferLength);
	  DPRINT1("NumberOfPhysicalBreaks:          %x\n", PortConfig->NumberOfPhysicalBreaks);
	  DPRINT1("DmaChannel:                      %x\n", PortConfig->DmaChannel);
	  DPRINT1("DmaPort:                         %d\n", PortConfig->DmaPort);
	  DPRINT1("DmaWidth:                        %d\n", PortConfig->DmaWidth);
	  DPRINT1("DmaSpeed:                        %d\n", PortConfig->DmaSpeed);
	  DPRINT1("AlignmentMask:                   %d\n", PortConfig->AlignmentMask);
	  DPRINT1("NumberOfAccessRanges:            %d\n", PortConfig->NumberOfAccessRanges);
	  DPRINT1("NumberOfBuses:                   %d\n", PortConfig->NumberOfBuses);
	  DPRINT1("ScatterGather:                   %d\n", PortConfig->ScatterGather);
	  DPRINT1("Master:                          %d\n", PortConfig->Master);
	  DPRINT1("CachesData:                      %d\n", PortConfig->CachesData);
	  DPRINT1("AdapterScansDown:                %d\n", PortConfig->AdapterScansDown);
	  DPRINT1("AtdiskPrimaryClaimed:            %d\n", PortConfig->AtdiskPrimaryClaimed);
	  DPRINT1("AtdiskSecondaryClaimed:          %d\n", PortConfig->AtdiskSecondaryClaimed);
	  DPRINT1("Dma32BitAddresses:               %d\n", PortConfig->Dma32BitAddresses);
	  DPRINT1("DemandMode:                      %d\n", PortConfig->DemandMode);
	  DPRINT1("MapBuffers:                      %d\n", PortConfig->MapBuffers);
	  DPRINT1("NeedPhysicalAddresses:           %d\n", PortConfig->NeedPhysicalAddresses);
	  DPRINT1("TaggedQueuing:                   %d\n", PortConfig->TaggedQueuing);
	  DPRINT1("AutoRequestSense:                %d\n", PortConfig->AutoRequestSense);
	  DPRINT1("MultipleRequestPerLu:            %d\n", PortConfig->MultipleRequestPerLu);
	  DPRINT1("ReceiveEvent:                    %d\n", PortConfig->ReceiveEvent);
	  DPRINT1("RealModeInitialized:             %d\n", PortConfig->RealModeInitialized);
	  DPRINT1("BufferAccessScsiPortControlled:  %d\n", PortConfig->BufferAccessScsiPortControlled);
	  DPRINT1("MaximumNumberOfTargets:          %d\n", PortConfig->MaximumNumberOfTargets);
	  DPRINT1("SlotNumber:                      %d\n", PortConfig->SlotNumber);
	  DPRINT1("BusInterruptLevel2:              %x\n", PortConfig->BusInterruptLevel2);
	  DPRINT1("BusInterruptVector2:             %x\n", PortConfig->BusInterruptVector2);
	  DPRINT1("InterruptMode2:                  %x\n", PortConfig->InterruptMode2);
	  DPRINT1("DmaChannel2:                     %d\n", PortConfig->DmaChannel2);
	  DPRINT1("DmaPort2:                        %d\n", PortConfig->DmaPort2);
	  DPRINT1("DmaWidth2:                       %d\n", PortConfig->DmaWidth2);
	  DPRINT1("DmaSpeed2:                       %d\n", PortConfig->DmaSpeed2);
	  DPRINT1("DeviceExtensionSize:             %d\n", PortConfig->DeviceExtensionSize);
	  DPRINT1("SpecificLuExtensionSize:         %d\n", PortConfig->SpecificLuExtensionSize);
	  DPRINT1("SrbExtensionSize:                %d\n", PortConfig->SrbExtensionSize);

#endif

          if (DeviceExtension->VirtualAddress == NULL && DeviceExtension->SrbExtensionSize)
	    {
	      ScsiPortGetUncachedExtension(&DeviceExtension->MiniPortDeviceExtension,
		                           PortConfig,
					   0);
	    }
	      
	  /* Register an interrupt handler for this device */
	  MappedIrq = HalGetInterruptVector(PortConfig->AdapterInterfaceType,
					    PortConfig->SystemIoBusNumber,
					    PortConfig->BusInterruptLevel,
#if 1
/* 
 * FIXME:
 *   Something is wrong in our interrupt conecting code. 
 *   The promise Ultra100TX driver returns 0 for BusInterruptVector
 *   and a nonzero value for BusInterruptLevel. The driver does only 
 *   work with this fix.
 */
					    PortConfig->BusInterruptLevel,
#else
					    PortConfig->BusInterruptVector,
#endif
					    &Dirql,
					    &Affinity);
	  DPRINT("AdapterInterfaceType %x, SystemIoBusNumber %x, BusInterruptLevel %x, BusInterruptVector %x\n",
	          PortConfig->AdapterInterfaceType, PortConfig->SystemIoBusNumber, 
		  PortConfig->BusInterruptLevel, PortConfig->BusInterruptVector); 
	  Status = IoConnectInterrupt(&DeviceExtension->Interrupt,
				      ScsiPortIsr,
				      DeviceExtension,
				      NULL,
				      MappedIrq,
				      Dirql,
				      Dirql,
				      PortConfig->InterruptMode,
				      TRUE,
				      Affinity,
				      FALSE);
	  if (!NT_SUCCESS(Status))
	    {
	      DbgPrint("Could not connect interrupt %d\n",
		       PortConfig->BusInterruptVector);
	      goto ByeBye;
	    }

	  if (!(HwInitializationData->HwInitialize)(&DeviceExtension->MiniPortDeviceExtension))
	    {
	      DbgPrint("HwInitialize() failed!");
	      Status = STATUS_UNSUCCESSFUL;
	      goto ByeBye;
	    }

	  /* Initialize port capabilities */
	  DeviceExtension->PortCapabilities = ExAllocatePool(NonPagedPool,
							     sizeof(IO_SCSI_CAPABILITIES));
	  if (DeviceExtension->PortCapabilities == NULL)
	    {
	      DbgPrint("Failed to allocate port capabilities!\n");
	      Status = STATUS_INSUFFICIENT_RESOURCES;
	      goto ByeBye;
	    }

	  PortCapabilities = DeviceExtension->PortCapabilities;
	  PortCapabilities->Length = sizeof(IO_SCSI_CAPABILITIES);
          if (PortConfig->ScatterGather == FALSE ||
	      PortConfig->NumberOfPhysicalBreaks >= (0x100000000LL >> PAGE_SHIFT) ||
	      PortConfig->MaximumTransferLength < PortConfig->NumberOfPhysicalBreaks * PAGE_SIZE)
	    {
	      PortCapabilities->MaximumTransferLength =
	        PortConfig->MaximumTransferLength;
	    }
	  else
	    {
	      PortCapabilities->MaximumTransferLength =
	        PortConfig->NumberOfPhysicalBreaks * PAGE_SIZE;
	    }
      
	  PortCapabilities->MaximumPhysicalPages =
	    PortCapabilities->MaximumTransferLength / PAGE_SIZE;
	  PortCapabilities->SupportedAsynchronousEvents = 0; /* FIXME */
	  PortCapabilities->AlignmentMask =
	    PortConfig->AlignmentMask;
	  PortCapabilities->TaggedQueuing =
	    PortConfig->TaggedQueuing;
	  PortCapabilities->AdapterScansDown =
	    PortConfig->AdapterScansDown;
	  PortCapabilities->AdapterUsesPio = TRUE; /* FIXME */

	  /* Scan the adapter for devices */
	  SpiScanAdapter (DeviceExtension);

	  /* Build the registry device map */
	  SpiBuildDeviceMap (DeviceExtension,
			     (PUNICODE_STRING)Argument2);

	  /* Create the dos device link */
	  swprintf(DosNameBuffer,
		   L"\\??\\Scsi%lu:",
		   SystemConfig->ScsiPortCount);
	  RtlInitUnicodeString(&DosDeviceName,
			       DosNameBuffer);
	  IoCreateSymbolicLink(&DosDeviceName,
			       &DeviceName);

	  /* Update the system configuration info */
	  if (PortConfig->AtdiskPrimaryClaimed == TRUE)
	    SystemConfig->AtDiskPrimaryAddressClaimed = TRUE;
	  if (PortConfig->AtdiskSecondaryClaimed == TRUE)
	    SystemConfig->AtDiskSecondaryAddressClaimed = TRUE;

	  SystemConfig->ScsiPortCount++;
	  PortDeviceObject = NULL;
	  DeviceFound = TRUE;
	}
      else
	{
	  DPRINT("HwFindAdapter() Result: %lu\n", Result);

	  ExFreePool (PortConfig);
	  IoDeleteDevice (PortDeviceObject);
	  PortDeviceObject = NULL;
	}

      DPRINT("Bus: %lu  MaxBus: %lu\n", BusNumber, MaxBus);
      if (BusNumber >= MaxBus)
	{
	  DPRINT("Scanned all buses!\n");
	  Status = STATUS_SUCCESS;
	  goto ByeBye;
	}

      if (Again == FALSE)
	{
	  BusNumber++;
	  SlotNumber.u.AsULONG = 0;
	}
    }

ByeBye:
  /* Clean up the mess */
  if (PortDeviceObject != NULL)
    {
      DPRINT("Delete device: %p\n", PortDeviceObject);

      DeviceExtension = PortDeviceObject->DeviceExtension;

      if (DeviceExtension->PortCapabilities != NULL)
	{
	  IoDisconnectInterrupt (DeviceExtension->Interrupt);
	  ExFreePool (DeviceExtension->PortCapabilities);
	}

      if (DeviceExtension->PortConfig != NULL)
	{
	  ExFreePool (DeviceExtension->PortConfig);
	}

      IoDeleteDevice (PortDeviceObject);
    }

  DPRINT("ScsiPortInitialize() done!\n");

  return (DeviceFound == FALSE) ? Status : STATUS_SUCCESS;
}


/*
 * @unimplemented
 */
VOID STDCALL
ScsiPortIoMapTransfer(IN PVOID HwDeviceExtension,
		      IN PSCSI_REQUEST_BLOCK Srb,
		      IN ULONG LogicalAddress,
		      IN ULONG Length)
{
   11720:	55                   	push   %ebp
   11721:	89 e5                	mov    %esp,%ebp
   11723:	83 ec 0c             	sub    $0xc,%esp
  DPRINT1("ScsiPortIoMapTransfer()\n");
   11726:	68 b4 04 00 00       	push   $0x4b4
   1172b:	68 11 50 01 00       	push   $0x15011
   11730:	68 54 50 01 00       	push   $0x15054
   11735:	e8 56 2b 00 00       	call   14290 <_DbgPrint>
   1173a:	c7 04 24 16 51 01 00 	movl   $0x15116,(%esp)
   11741:	e8 4a 2b 00 00       	call   14290 <_DbgPrint>
  UNIMPLEMENTED;
   11746:	68 b5 04 00 00       	push   $0x4b5
   1174b:	68 11 50 01 00       	push   $0x15011
   11750:	68 00 51 01 00       	push   $0x15100
   11755:	68 1c 50 01 00       	push   $0x1501c
   1175a:	e8 31 2b 00 00       	call   14290 <_DbgPrint>
   1175f:	c9                   	leave  
   11760:	c2 10 00             	ret    $0x10
   11763:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11769:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011770 <_ScsiPortLogError@28>:
}


/*
 * @unimplemented
 */
VOID STDCALL
ScsiPortLogError(IN PVOID HwDeviceExtension,
		 IN PSCSI_REQUEST_BLOCK Srb OPTIONAL,
		 IN UCHAR PathId,
		 IN UCHAR TargetId,
		 IN UCHAR Lun,
		 IN ULONG ErrorCode,
		 IN ULONG UniqueId)
{
   11770:	55                   	push   %ebp
   11771:	89 e5                	mov    %esp,%ebp
   11773:	57                   	push   %edi
   11774:	56                   	push   %esi
   11775:	53                   	push   %ebx
   11776:	83 ec 10             	sub    $0x10,%esp
   11779:	0f b6 7d 10          	movzbl 0x10(%ebp),%edi
  PSCSI_PORT_DEVICE_EXTENSION DeviceExtension;

  DPRINT1("ScsiPortLogError() called\n");
   1177d:	68 c7 04 00 00       	push   $0x4c7
   11782:	68 11 50 01 00       	push   $0x15011
   11787:	68 54 50 01 00       	push   $0x15054
   1178c:	8a 5d 18             	mov    0x18(%ebp),%bl
   1178f:	0f b6 75 14          	movzbl 0x14(%ebp),%esi
   11793:	e8 f8 2a 00 00       	call   14290 <_DbgPrint>
   11798:	c7 04 24 2f 51 01 00 	movl   $0x1512f,(%esp)
   1179f:	e8 ec 2a 00 00       	call   14290 <_DbgPrint>
  DPRINT1("Srb %x, PathId %d, TargetId %d, Lun %d, ErrorCode %x, UniqueId %x\n",
   117a4:	83 c4 0c             	add    $0xc,%esp
   117a7:	68 c8 04 00 00       	push   $0x4c8
   117ac:	68 11 50 01 00       	push   $0x15011
   117b1:	68 54 50 01 00       	push   $0x15054
   117b6:	e8 d5 2a 00 00       	call   14290 <_DbgPrint>
   117bb:	83 c4 0c             	add    $0xc,%esp
   117be:	8b 45 20             	mov    0x20(%ebp),%eax
   117c1:	81 e3 ff 00 00 00    	and    $0xff,%ebx
   117c7:	50                   	push   %eax
   117c8:	8b 45 1c             	mov    0x1c(%ebp),%eax
   117cb:	50                   	push   %eax
   117cc:	89 f0                	mov    %esi,%eax
   117ce:	25 ff 00 00 00       	and    $0xff,%eax
   117d3:	53                   	push   %ebx
   117d4:	50                   	push   %eax
   117d5:	89 f8                	mov    %edi,%eax
   117d7:	25 ff 00 00 00       	and    $0xff,%eax
   117dc:	50                   	push   %eax
   117dd:	8b 45 0c             	mov    0xc(%ebp),%eax
   117e0:	50                   	push   %eax
   117e1:	68 4c 51 01 00       	push   $0x1514c
   117e6:	e8 a5 2a 00 00       	call   14290 <_DbgPrint>
          Srb, PathId, TargetId, Lun, ErrorCode, UniqueId);

  DeviceExtension = CONTAINING_RECORD(HwDeviceExtension,
   117eb:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   117ee:	5b                   	pop    %ebx
   117ef:	5e                   	pop    %esi
   117f0:	5f                   	pop    %edi
   117f1:	5d                   	pop    %ebp
   117f2:	c2 1c 00             	ret    $0x1c
   117f5:	8d 74 26 00          	lea    0x0(%esi),%esi
   117f9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011800 <_ScsiPortMoveMemory@12>:
				      SCSI_PORT_DEVICE_EXTENSION,
				      MiniPortDeviceExtension);


  DPRINT("ScsiPortLogError() done\n");
}


/*
 * @implemented
 */
VOID STDCALL
ScsiPortMoveMemory(OUT PVOID Destination,
		   IN PVOID Source,
		   IN ULONG Length)
{
   11800:	55                   	push   %ebp
   11801:	89 e5                	mov    %esp,%ebp
  RtlMoveMemory(Destination,
   11803:	c9                   	leave  
   11804:	e9 37 28 00 00       	jmp    14040 <_RtlMoveMemory@12>
   11809:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011810 <_SpiGetLunExtension>:
		Source,
		Length);
}


/*
 * @implemented
 */
VOID
ScsiPortNotification(IN SCSI_NOTIFICATION_TYPE NotificationType,
		     IN PVOID HwDeviceExtension,
		     ...)
{
  PSCSI_PORT_DEVICE_EXTENSION DeviceExtension;
  va_list ap;

  DPRINT("ScsiPortNotification() called\n");

  DeviceExtension = CONTAINING_RECORD(HwDeviceExtension,
				      SCSI_PORT_DEVICE_EXTENSION,
				      MiniPortDeviceExtension);

  DPRINT("DeviceExtension %p\n", DeviceExtension);

  va_start(ap, HwDeviceExtension);

  switch (NotificationType)
    {
      case RequestComplete:
	{
	  PSCSI_REQUEST_BLOCK Srb;

	  Srb = (PSCSI_REQUEST_BLOCK) va_arg (ap, PSCSI_REQUEST_BLOCK);

	  DPRINT("Notify: RequestComplete (Srb %p)\n", Srb);
	  DeviceExtension->Flags |= IRP_FLAG_COMPLETE;
	  Srb->SrbFlags &= ~SRB_FLAGS_IS_ACTIVE;
	}
	break;

      case NextRequest:
	DPRINT("Notify: NextRequest\n");
	DeviceExtension->Flags |= IRP_FLAG_NEXT;
	break;

      case NextLuRequest:
	{
	  UCHAR PathId;
	  UCHAR TargetId;
	  UCHAR Lun;
          PSCSI_PORT_LUN_EXTENSION LunExtension;

	  PathId = (UCHAR) va_arg (ap, int);
	  TargetId = (UCHAR) va_arg (ap, int);
	  Lun = (UCHAR) va_arg (ap, int);

	  DPRINT ("Notify: NextLuRequest(PathId %u  TargetId %u  Lun %u)\n",
		   PathId, TargetId, Lun);

          LunExtension = SpiGetLunExtension(DeviceExtension,
				            PathId,
				            TargetId,
				            Lun);
	  if (LunExtension)
	    {
	      DeviceExtension->Flags |= IRP_FLAG_NEXT_LU;
	      LunExtension->Flags |= IRP_FLAG_NEXT_LU;
	    }
	}
	break;

      case ResetDetected:
	DPRINT1("Notify: ResetDetected\n");
	/* FIXME: ??? */
	break;

      default:
	DPRINT1 ("Unsupported notification %lu\n", NotificationType);
	break;
    }
  if (KeGetCurrentIrql() >= DISPATCH_LEVEL)
    {
      IoRequestDpc(DeviceExtension->DeviceObject,
                   NULL,
		   DeviceExtension);
    }
  else
    {
      SpiProcessRequests(DeviceExtension, NULL);
    }

  va_end(ap);
}


/*
 * @implemented
 */
ULONG STDCALL
ScsiPortSetBusDataByOffset(IN PVOID DeviceExtension,
			   IN ULONG BusDataType,
			   IN ULONG SystemIoBusNumber,
			   IN ULONG SlotNumber,
			   IN PVOID Buffer,
			   IN ULONG Offset,
			   IN ULONG Length)
{
  DPRINT("ScsiPortSetBusDataByOffset()\n");
  return(HalSetBusDataByOffset(BusDataType,
			       SystemIoBusNumber,
			       SlotNumber,
			       Buffer,
			       Offset,
			       Length));
}


/*
 * @implemented
 */
BOOLEAN STDCALL
ScsiPortValidateRange(IN PVOID HwDeviceExtension,
		      IN INTERFACE_TYPE BusType,
		      IN ULONG SystemIoBusNumber,
		      IN SCSI_PHYSICAL_ADDRESS IoAddress,
		      IN ULONG NumberOfBytes,
		      IN BOOLEAN InIoSpace)
{
  DPRINT("ScsiPortValidateRange()\n");
  return(TRUE);
}


/* INTERNAL FUNCTIONS ********************************************************/


static BOOLEAN
SpiGetPciConfigData (IN struct _HW_INITIALIZATION_DATA *HwInitializationData,
		     IN OUT PPORT_CONFIGURATION_INFORMATION PortConfig,
		     IN ULONG BusNumber,
		     IN OUT PPCI_SLOT_NUMBER NextSlotNumber)
{
  PCI_COMMON_CONFIG PciConfig;
  PCI_SLOT_NUMBER SlotNumber;
  ULONG DataSize;
  ULONG DeviceNumber;
  ULONG FunctionNumber;
  CHAR VendorIdString[8];
  CHAR DeviceIdString[8];
  ULONG i;
  ULONG RangeLength;

  DPRINT ("SpiGetPciConfiguration() called\n");

  if (NextSlotNumber->u.bits.FunctionNumber >= PCI_MAX_FUNCTION)
    {
      NextSlotNumber->u.bits.FunctionNumber = 0;
      NextSlotNumber->u.bits.DeviceNumber++;
    }

  if (NextSlotNumber->u.bits.DeviceNumber >= PCI_MAX_DEVICES)
    {
      NextSlotNumber->u.bits.DeviceNumber = 0;
      return FALSE;
    }

  for (DeviceNumber = NextSlotNumber->u.bits.DeviceNumber; DeviceNumber < PCI_MAX_DEVICES; DeviceNumber++)
    {
      SlotNumber.u.bits.DeviceNumber = DeviceNumber;

      for (FunctionNumber = NextSlotNumber->u.bits.FunctionNumber; FunctionNumber < PCI_MAX_FUNCTION; FunctionNumber++)
	{
	  SlotNumber.u.bits.FunctionNumber = FunctionNumber;

	  DataSize = HalGetBusData (PCIConfiguration,
				    BusNumber,
				    SlotNumber.u.AsULONG,
				    &PciConfig,
				    PCI_COMMON_HDR_LENGTH);
	  if (DataSize != PCI_COMMON_HDR_LENGTH)
	    {
	      if (FunctionNumber == 0)
		{
		  break;
		}
	      else
		{
		  continue;
		}
	    }

	  sprintf (VendorIdString, "%04hx", PciConfig.VendorID);
	  sprintf (DeviceIdString, "%04hx", PciConfig.DeviceID);

	  if (!_strnicmp(VendorIdString, HwInitializationData->VendorId, HwInitializationData->VendorIdLength) &&
	      !_strnicmp(DeviceIdString, HwInitializationData->DeviceId, HwInitializationData->DeviceIdLength))
	    {
	      DPRINT ("Found device 0x%04hx 0x%04hx at %1lu %2lu %1lu\n",
		      PciConfig.VendorID,
		      PciConfig.DeviceID,
		      BusNumber,
		      SlotNumber.u.bits.DeviceNumber,
		      SlotNumber.u.bits.FunctionNumber);

	      PortConfig->BusInterruptLevel =
	      PortConfig->BusInterruptVector = PciConfig.u.type0.InterruptLine;
	      PortConfig->SlotNumber = SlotNumber.u.AsULONG;

	      /* Initialize access ranges */
	      if (PortConfig->NumberOfAccessRanges > 0)
		{
		  if (PortConfig->NumberOfAccessRanges > PCI_TYPE0_ADDRESSES)
		    PortConfig->NumberOfAccessRanges = PCI_TYPE0_ADDRESSES;

		  for (i = 0; i < PortConfig->NumberOfAccessRanges; i++)
		    {
		      PortConfig->AccessRanges[i].RangeStart.QuadPart =
			PciConfig.u.type0.BaseAddresses[i] & PCI_ADDRESS_IO_ADDRESS_MASK;
		      if (PortConfig->AccessRanges[i].RangeStart.QuadPart != 0)
			{
			  RangeLength = (ULONG)-1;
			  HalSetBusDataByOffset (PCIConfiguration,
						 BusNumber,
						 SlotNumber.u.AsULONG,
						 (PVOID)&RangeLength,
						 0x10 + (i * sizeof(ULONG)),
						 sizeof(ULONG));

			  HalGetBusDataByOffset (PCIConfiguration,
						 BusNumber,
						 SlotNumber.u.AsULONG,
						 (PVOID)&RangeLength,
						 0x10 + (i * sizeof(ULONG)),
						 sizeof(ULONG));

			  HalSetBusDataByOffset (PCIConfiguration,
						 BusNumber,
						 SlotNumber.u.AsULONG,
						 (PVOID)&PciConfig.u.type0.BaseAddresses[i],
						 0x10 + (i * sizeof(ULONG)),
						 sizeof(ULONG));
			  if (RangeLength != 0)
			    {
			      PortConfig->AccessRanges[i].RangeLength =
			        -(RangeLength & PCI_ADDRESS_IO_ADDRESS_MASK);
			      PortConfig->AccessRanges[i].RangeInMemory =
				!(PciConfig.u.type0.BaseAddresses[i] & PCI_ADDRESS_IO_SPACE);

			      DPRINT("RangeStart 0x%lX  RangeLength 0x%lX  RangeInMemory %s\n",
				     PciConfig.u.type0.BaseAddresses[i] & PCI_ADDRESS_IO_ADDRESS_MASK,
				     -(RangeLength & PCI_ADDRESS_IO_ADDRESS_MASK),
				     (PciConfig.u.type0.BaseAddresses[i] & PCI_ADDRESS_IO_SPACE)?"FALSE":"TRUE");
			    }
			}
		    }
		}

	      NextSlotNumber->u.bits.DeviceNumber = DeviceNumber;
	      NextSlotNumber->u.bits.FunctionNumber = FunctionNumber;

              PortConfig->SlotNumber = NextSlotNumber->u.AsULONG;

	      NextSlotNumber->u.bits.FunctionNumber += 1;

	      return TRUE;
	    }


	  if (FunctionNumber == 0 && !(PciConfig.HeaderType & PCI_MULTIFUNCTION))
	    {
	      break;
	    }
	}
       NextSlotNumber->u.bits.FunctionNumber = 0;
    }

  DPRINT ("No device found\n");

  return FALSE;
}



/**********************************************************************
 * NAME							INTERNAL
 *	ScsiPortCreateClose
 *
 * DESCRIPTION
 *	Answer requests for Create/Close calls: a null operation.
 *
 * RUN LEVEL
 *	PASSIVE_LEVEL
 *
 * ARGUMENTS
 *	DeviceObject
 *		Pointer to a device object.
 *
 *	Irp
 *		Pointer to an IRP.
 *
 * RETURN VALUE
 * 	Status.
 */

static NTSTATUS STDCALL
ScsiPortCreateClose(IN PDEVICE_OBJECT DeviceObject,
		    IN PIRP Irp)
{
  DPRINT("ScsiPortCreateClose()\n");

  Irp->IoStatus.Status = STATUS_SUCCESS;
  Irp->IoStatus.Information = FILE_OPENED;

  IoCompleteRequest(Irp, IO_NO_INCREMENT);

  return(STATUS_SUCCESS);
}


/**********************************************************************
 * NAME							INTERNAL
 *	ScsiPortDispatchScsi
 *
 * DESCRIPTION
 *	Answer requests for SCSI calls
 *
 * RUN LEVEL
 *	PASSIVE_LEVEL
 *
 * ARGUMENTS
 *	Standard dispatch arguments
 *
 * RETURNS
 *	NTSTATUS
 */

static NTSTATUS STDCALL
ScsiPortDispatchScsi(IN PDEVICE_OBJECT DeviceObject,
		     IN PIRP Irp)
{
  PSCSI_PORT_DEVICE_EXTENSION DeviceExtension;
  PSCSI_PORT_LUN_EXTENSION LunExtension;
  PIO_STACK_LOCATION Stack;
  PSCSI_REQUEST_BLOCK Srb;
  NTSTATUS Status = STATUS_SUCCESS;
  ULONG DataSize = 0;

  DPRINT("ScsiPortDispatchScsi(DeviceObject %p  Irp %p)\n",
	 DeviceObject, Irp);

  DeviceExtension = DeviceObject->DeviceExtension;
  Stack = IoGetCurrentIrpStackLocation(Irp);

  Srb = Stack->Parameters.Scsi.Srb;
  if (Srb == NULL)
    {
      Status = STATUS_UNSUCCESSFUL;

      Irp->IoStatus.Status = Status;
      Irp->IoStatus.Information = 0;

      IoCompleteRequest(Irp, IO_NO_INCREMENT);

      return(Status);
    }

  DPRINT("Srb: %p\n", Srb);
  DPRINT("Srb->Function: %lu\n", Srb->Function);
  DPRINT("PathId: %lu  TargetId: %lu  Lun: %lu\n", Srb->PathId, Srb->TargetId, Srb->Lun);

  LunExtension = SpiGetLunExtension(DeviceExtension,
				    Srb->PathId,
				    Srb->TargetId,
				    Srb->Lun);
  if (LunExtension == NULL)
    {
      Status = STATUS_NO_SUCH_DEVICE;

      Srb->SrbStatus = SRB_STATUS_NO_DEVICE;
      Irp->IoStatus.Status = Status;
      Irp->IoStatus.Information = 0;

      IoCompleteRequest(Irp, IO_NO_INCREMENT);

      return(Status);
    }

  switch (Srb->Function)
    {
      case SRB_FUNCTION_EXECUTE_SCSI:
      case SRB_FUNCTION_IO_CONTROL:
        IoMarkIrpPending(Irp);
	Srb->OriginalRequest = LunExtension;
        Irp->Tail.Overlay.DriverContext[3] = Srb;
	SpiProcessRequests(DeviceExtension, Irp);
	return(STATUS_PENDING);

      case SRB_FUNCTION_SHUTDOWN:
      case SRB_FUNCTION_FLUSH:
	if (DeviceExtension->PortConfig->CachesData == TRUE)
	  {
            IoMarkIrpPending(Irp);
	    Srb->OriginalRequest = LunExtension;
            Irp->Tail.Overlay.DriverContext[3] = Srb;
	    SpiProcessRequests(DeviceExtension, Irp);
	    return(STATUS_PENDING);
	  }
	break;

      case SRB_FUNCTION_CLAIM_DEVICE:
	DPRINT ("  SRB_FUNCTION_CLAIM_DEVICE\n");

	/* Reference device object and keep the device object */
	ObReferenceObject(DeviceObject);
	LunExtension->DeviceObject = DeviceObject;
	LunExtension->DeviceClaimed = TRUE;
	Srb->DataBuffer = DeviceObject;
	break;

      case SRB_FUNCTION_RELEASE_DEVICE:
	DPRINT ("  SRB_FUNCTION_RELEASE_DEVICE\n");
	DPRINT ("PathId: %lu  TargetId: %lu  Lun: %lu\n",
		Srb->PathId, Srb->TargetId, Srb->Lun);

	/* Dereference device object and clear the device object */
	ObDereferenceObject(LunExtension->DeviceObject);
	LunExtension->DeviceObject = NULL;
	LunExtension->DeviceClaimed = FALSE;
	break;

      default:
	DPRINT1("SRB function not implemented (Function %lu)\n", Srb->Function);
	Status = STATUS_NOT_IMPLEMENTED;
	break;
    }

  Irp->IoStatus.Status = Status;
  Irp->IoStatus.Information = DataSize;

  IoCompleteRequest(Irp, IO_NO_INCREMENT);

  return(Status);
}


/**********************************************************************
 * NAME							INTERNAL
 *	ScsiPortDeviceControl
 *
 * DESCRIPTION
 *	Answer requests for device control calls
 *
 * RUN LEVEL
 *	PASSIVE_LEVEL
 *
 * ARGUMENTS
 *	Standard dispatch arguments
 *
 * RETURNS
 *	NTSTATUS
 */

static NTSTATUS STDCALL
ScsiPortDeviceControl(IN PDEVICE_OBJECT DeviceObject,
		      IN PIRP Irp)
{
  PIO_STACK_LOCATION Stack;
  PSCSI_PORT_DEVICE_EXTENSION DeviceExtension;

  DPRINT("ScsiPortDeviceControl()\n");

  Irp->IoStatus.Status = STATUS_SUCCESS;
  Irp->IoStatus.Information = 0;


  Stack = IoGetCurrentIrpStackLocation(Irp);
  DeviceExtension = DeviceObject->DeviceExtension;

  switch (Stack->Parameters.DeviceIoControl.IoControlCode)
    {
      case IOCTL_SCSI_GET_DUMP_POINTERS:
	{
	  PDUMP_POINTERS DumpPointers;
	  DPRINT("  IOCTL_SCSI_GET_DUMP_POINTERS\n");
	  DumpPointers = (PDUMP_POINTERS)Irp->AssociatedIrp.SystemBuffer;
	  DumpPointers->DeviceObject = DeviceObject;
	  
	  Irp->IoStatus.Information = sizeof(DUMP_POINTERS);
	}
	break;

      case IOCTL_SCSI_GET_CAPABILITIES:
	{
	  DPRINT("  IOCTL_SCSI_GET_CAPABILITIES\n");

	  *((PIO_SCSI_CAPABILITIES *)Irp->AssociatedIrp.SystemBuffer) =
	    DeviceExtension->PortCapabilities;

	  Irp->IoStatus.Information = sizeof(PIO_SCSI_CAPABILITIES);
	}
	break;

      case IOCTL_SCSI_GET_INQUIRY_DATA:
	{
	  DPRINT("  IOCTL_SCSI_GET_INQUIRY_DATA\n");

	  /* Copy inquiry data to the port device extension */
	  Irp->IoStatus.Information =
	    SpiGetInquiryData(DeviceExtension,
			      Irp->AssociatedIrp.SystemBuffer);
	  DPRINT("Inquiry data size: %lu\n", Irp->IoStatus.Information);
	}
	break;

      default:
	DPRINT1("  unknown ioctl code: 0x%lX\n",
	       Stack->Parameters.DeviceIoControl.IoControlCode);
	break;
    }

  IoCompleteRequest(Irp, IO_NO_INCREMENT);

  return(STATUS_SUCCESS);
}

static VOID 
SpiAllocateSrbExtension(PSCSI_PORT_DEVICE_EXTENSION DeviceExtension,
			PSCSI_REQUEST_BLOCK Srb)
{
  ULONG index;

  DPRINT("SpiAllocateSrbExtension\n");

  DPRINT("DeviceExtension->VirtualAddress %x, DeviceExtension->SrbExtensionSize %x\n", 
         DeviceExtension->VirtualAddress, DeviceExtension->SrbExtensionSize);

  Srb->SrbExtension = NULL;
  if (DeviceExtension->VirtualAddress != NULL &&
      DeviceExtension->SrbExtensionSize > 0)
    {
      index = RtlFindClearBitsAndSet(&DeviceExtension->SrbExtensionAllocMap, 1, 0); 
      if (index != 0xffffffff)
        {
	  DeviceExtension->CurrentSrbExtensions++;  
          Srb->SrbExtension = DeviceExtension->VirtualAddress + index * DeviceExtension->SrbExtensionSize;
	}
    }
  DPRINT("%x\n", Srb->SrbExtension);
}

static VOID
SpiFreeSrbExtension(PSCSI_PORT_DEVICE_EXTENSION DeviceExtension,
		    PSCSI_REQUEST_BLOCK Srb)
{
  ULONG index;

  if (DeviceExtension->VirtualAddress != NULL &&
      DeviceExtension->SrbExtensionSize > 0 &&
      Srb->SrbExtension != NULL)
    {
      index = ((ULONG_PTR)Srb->SrbExtension - (ULONG_PTR)DeviceExtension->VirtualAddress) / DeviceExtension->SrbExtensionSize;
      RtlClearBits(&DeviceExtension->SrbExtensionAllocMap, index, 1);
      DeviceExtension->CurrentSrbExtensions--;
    }
  Srb->SrbExtension = NULL;
}


static BOOLEAN STDCALL
ScsiPortStartPacket(IN OUT PVOID Context)
{
  PSCSI_PORT_DEVICE_EXTENSION DeviceExtension;
  PSCSI_REQUEST_BLOCK Srb;
  PIRP Irp;
  PIO_STACK_LOCATION IrpStack;

  DPRINT("ScsiPortStartPacket(Context %x) called\n", Context);
    
  Srb = (PSCSI_REQUEST_BLOCK)Context;
  Irp = (PIRP)Srb->OriginalRequest;
  IrpStack = IoGetCurrentIrpStackLocation(Irp);
  DeviceExtension = IrpStack->DeviceObject->DeviceExtension;

  return(DeviceExtension->HwStartIo(&DeviceExtension->MiniPortDeviceExtension,
				    Srb));
}


static PSCSI_PORT_LUN_EXTENSION
SpiAllocateLunExtension (IN PSCSI_PORT_DEVICE_EXTENSION DeviceExtension,
			 IN UCHAR PathId,
			 IN UCHAR TargetId,
			 IN UCHAR Lun)
{
  PSCSI_PORT_LUN_EXTENSION LunExtension;
  ULONG LunExtensionSize;

  DPRINT("SpiAllocateLunExtension (%p %u %u %u)\n",
	 DeviceExtension, PathId, TargetId, Lun);

  LunExtensionSize =
    sizeof(SCSI_PORT_LUN_EXTENSION) + DeviceExtension->LunExtensionSize;
  DPRINT("LunExtensionSize %lu\n", LunExtensionSize);

  LunExtension = ExAllocatePool(NonPagedPool,
				LunExtensionSize);
  if (LunExtension == NULL)
    {
      return NULL;
    }

  RtlZeroMemory(LunExtension,
		LunExtensionSize);

  InsertTailList(&DeviceExtension->LunExtensionListHead,
		 &LunExtension->List);

  LunExtension->PathId = PathId;
  LunExtension->TargetId = TargetId;
  LunExtension->Lun = Lun;

  LunExtension->PendingIrpCount = 0;
  LunExtension->ActiveIrpCount = 0;

  LunExtension->NextIrp = NULL;

  return LunExtension;
}


static VOID
SpiRemoveLunExtension (IN PSCSI_PORT_LUN_EXTENSION LunExtension)
{
  DPRINT("SpiRemoveLunExtension(%p) called\n",
	 LunExtension);

  if (LunExtension == NULL)
    return;

  RemoveEntryList (&LunExtension->List);


  /* Release LUN extersion data */


  ExFreePool (LunExtension);

  return;
}


static PSCSI_PORT_LUN_EXTENSION
SpiGetLunExtension (IN PSCSI_PORT_DEVICE_EXTENSION DeviceExtension,
		    IN UCHAR PathId,
		    IN UCHAR TargetId,
		    IN UCHAR Lun)
{
   11810:	55                   	push   %ebp
   11811:	89 e5                	mov    %esp,%ebp
   11813:	53                   	push   %ebx
   11814:	51                   	push   %ecx
   11815:	8a 4d 08             	mov    0x8(%ebp),%cl
   11818:	8a 5d 0c             	mov    0xc(%ebp),%bl
   1181b:	88 4d fb             	mov    %cl,0xfffffffb(%ebp)
  PSCSI_PORT_LUN_EXTENSION LunExtension;
  PLIST_ENTRY Entry;

  DPRINT("SpiGetLunExtension(%p %u %u %u) called\n",
	 DeviceExtension, PathId, TargetId, Lun);

  if (IsListEmpty(&DeviceExtension->LunExtensionListHead))
   1181e:	8d 48 30             	lea    0x30(%eax),%ecx
   11821:	8b 40 30             	mov    0x30(%eax),%eax
   11824:	88 5d fa             	mov    %bl,0xfffffffa(%ebp)
    return NULL;
   11827:	31 db                	xor    %ebx,%ebx
   11829:	39 c8                	cmp    %ecx,%eax
   1182b:	74 11                	je     1183e <_SpiGetLunExtension+0x2e>

  Entry = DeviceExtension->LunExtensionListHead.Flink;
  while (Entry != &DeviceExtension->LunExtensionListHead)
    {
      LunExtension = CONTAINING_RECORD(Entry,
				       SCSI_PORT_LUN_EXTENSION,
				       List);
      if (LunExtension->PathId == PathId &&
	  LunExtension->TargetId == TargetId &&
	  LunExtension->Lun == Lun)
	{
	  return LunExtension;
	}

      Entry = Entry->Flink;
   1182d:	39 c1                	cmp    %eax,%ecx
   1182f:	74 0b                	je     1183c <_SpiGetLunExtension+0x2c>
   11831:	38 50 08             	cmp    %dl,0x8(%eax)
   11834:	74 0e                	je     11844 <_SpiGetLunExtension+0x34>
   11836:	8b 00                	mov    (%eax),%eax
   11838:	39 c1                	cmp    %eax,%ecx
   1183a:	75 f5                	jne    11831 <_SpiGetLunExtension+0x21>
    }

  return NULL;
   1183c:	31 db                	xor    %ebx,%ebx
}
   1183e:	89 d8                	mov    %ebx,%eax
   11840:	5a                   	pop    %edx
   11841:	5b                   	pop    %ebx
   11842:	5d                   	pop    %ebp
   11843:	c3                   	ret    
   11844:	8a 5d fb             	mov    0xfffffffb(%ebp),%bl
   11847:	38 58 09             	cmp    %bl,0x9(%eax)
   1184a:	75 ea                	jne    11836 <_SpiGetLunExtension+0x26>
   1184c:	8a 5d fa             	mov    0xfffffffa(%ebp),%bl
   1184f:	38 58 0a             	cmp    %bl,0xa(%eax)
   11852:	75 e2                	jne    11836 <_SpiGetLunExtension+0x26>
   11854:	89 c3                	mov    %eax,%ebx
   11856:	eb e6                	jmp    1183e <_SpiGetLunExtension+0x2e>
   11858:	90                   	nop    
   11859:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00011860 <_ScsiPortSetBusDataByOffset@28>:
   11860:	55                   	push   %ebp
   11861:	89 e5                	mov    %esp,%ebp
   11863:	83 ec 10             	sub    $0x10,%esp
   11866:	8b 45 20             	mov    0x20(%ebp),%eax
   11869:	50                   	push   %eax
   1186a:	8b 45 1c             	mov    0x1c(%ebp),%eax
   1186d:	50                   	push   %eax
   1186e:	8b 45 18             	mov    0x18(%ebp),%eax
   11871:	50                   	push   %eax
   11872:	8b 45 14             	mov    0x14(%ebp),%eax
   11875:	50                   	push   %eax
   11876:	8b 45 10             	mov    0x10(%ebp),%eax
   11879:	50                   	push   %eax
   1187a:	8b 45 0c             	mov    0xc(%ebp),%eax
   1187d:	50                   	push   %eax
   1187e:	e8 7d 2a 00 00       	call   14300 <_HalSetBusDataByOffset@24>
   11883:	c9                   	leave  
   11884:	c2 1c 00             	ret    $0x1c
   11887:	89 f6                	mov    %esi,%esi
   11889:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011890 <_ScsiPortValidateRange@28>:
   11890:	55                   	push   %ebp
   11891:	b8 01 00 00 00       	mov    $0x1,%eax
   11896:	89 e5                	mov    %esp,%ebp
   11898:	5d                   	pop    %ebp
   11899:	c2 1c 00             	ret    $0x1c
   1189c:	8d 74 26 00          	lea    0x0(%esi),%esi

000118a0 <_ScsiPortCreateClose@8>:
   118a0:	55                   	push   %ebp
   118a1:	89 e5                	mov    %esp,%ebp
   118a3:	83 ec 10             	sub    $0x10,%esp
   118a6:	8b 45 0c             	mov    0xc(%ebp),%eax
   118a9:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
   118b0:	c7 40 1c 01 00 00 00 	movl   $0x1,0x1c(%eax)
   118b7:	6a 00                	push   $0x0
   118b9:	50                   	push   %eax
   118ba:	e8 91 27 00 00       	call   14050 <_IoCompleteRequest@8>
   118bf:	31 c0                	xor    %eax,%eax
   118c1:	c9                   	leave  
   118c2:	c2 08 00             	ret    $0x8
   118c5:	8d 74 26 00          	lea    0x0(%esi),%esi
   118c9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000118d0 <_SpiAllocateSrbExtension>:
   118d0:	55                   	push   %ebp
   118d1:	89 e5                	mov    %esp,%ebp
   118d3:	56                   	push   %esi
   118d4:	53                   	push   %ebx
   118d5:	c7 42 28 00 00 00 00 	movl   $0x0,0x28(%edx)
   118dc:	89 c3                	mov    %eax,%ebx
   118de:	8b 40 60             	mov    0x60(%eax),%eax
   118e1:	89 d6                	mov    %edx,%esi
   118e3:	85 c0                	test   %eax,%eax
   118e5:	74 07                	je     118ee <_SpiAllocateSrbExtension+0x1e>
   118e7:	8b 43 38             	mov    0x38(%ebx),%eax
   118ea:	85 c0                	test   %eax,%eax
   118ec:	75 07                	jne    118f5 <_SpiAllocateSrbExtension+0x25>
   118ee:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   118f1:	5b                   	pop    %ebx
   118f2:	5e                   	pop    %esi
   118f3:	5d                   	pop    %ebp
   118f4:	c3                   	ret    
   118f5:	50                   	push   %eax
   118f6:	8d 43 64             	lea    0x64(%ebx),%eax
   118f9:	6a 00                	push   $0x0
   118fb:	6a 01                	push   $0x1
   118fd:	50                   	push   %eax
   118fe:	e8 5d 27 00 00       	call   14060 <_RtlFindClearBitsAndSet@12>
   11903:	59                   	pop    %ecx
   11904:	83 f8 ff             	cmp    $0xffffffff,%eax
   11907:	74 e5                	je     118ee <_SpiAllocateSrbExtension+0x1e>
   11909:	8b 4b 38             	mov    0x38(%ebx),%ecx
   1190c:	8b 53 70             	mov    0x70(%ebx),%edx
   1190f:	0f af c1             	imul   %ecx,%eax
   11912:	42                   	inc    %edx
   11913:	89 53 70             	mov    %edx,0x70(%ebx)
   11916:	8b 53 60             	mov    0x60(%ebx),%edx
   11919:	01 d0                	add    %edx,%eax
   1191b:	89 46 28             	mov    %eax,0x28(%esi)
   1191e:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11921:	5b                   	pop    %ebx
   11922:	5e                   	pop    %esi
   11923:	5d                   	pop    %ebp
   11924:	c3                   	ret    
   11925:	8d 74 26 00          	lea    0x0(%esi),%esi
   11929:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011930 <_SpiFreeSrbExtension>:
   11930:	55                   	push   %ebp
   11931:	89 e5                	mov    %esp,%ebp
   11933:	57                   	push   %edi
   11934:	56                   	push   %esi
   11935:	53                   	push   %ebx
   11936:	83 ec 0c             	sub    $0xc,%esp
   11939:	89 c3                	mov    %eax,%ebx
   1193b:	8b 48 60             	mov    0x60(%eax),%ecx
   1193e:	89 d6                	mov    %edx,%esi
   11940:	85 c9                	test   %ecx,%ecx
   11942:	74 0e                	je     11952 <_SpiFreeSrbExtension+0x22>
   11944:	8b 78 38             	mov    0x38(%eax),%edi
   11947:	85 ff                	test   %edi,%edi
   11949:	74 07                	je     11952 <_SpiFreeSrbExtension+0x22>
   1194b:	8b 52 28             	mov    0x28(%edx),%edx
   1194e:	85 d2                	test   %edx,%edx
   11950:	75 0f                	jne    11961 <_SpiFreeSrbExtension+0x31>
   11952:	c7 46 28 00 00 00 00 	movl   $0x0,0x28(%esi)
   11959:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1195c:	5b                   	pop    %ebx
   1195d:	5e                   	pop    %esi
   1195e:	5f                   	pop    %edi
   1195f:	5d                   	pop    %ebp
   11960:	c3                   	ret    
   11961:	29 ca                	sub    %ecx,%edx
   11963:	89 d0                	mov    %edx,%eax
   11965:	31 d2                	xor    %edx,%edx
   11967:	f7 f7                	div    %edi
   11969:	89 c1                	mov    %eax,%ecx
   1196b:	50                   	push   %eax
   1196c:	8d 43 64             	lea    0x64(%ebx),%eax
   1196f:	6a 01                	push   $0x1
   11971:	51                   	push   %ecx
   11972:	50                   	push   %eax
   11973:	e8 f8 26 00 00       	call   14070 <_RtlClearBits@12>
   11978:	8b 43 70             	mov    0x70(%ebx),%eax
   1197b:	48                   	dec    %eax
   1197c:	89 43 70             	mov    %eax,0x70(%ebx)
   1197f:	58                   	pop    %eax
   11980:	eb d0                	jmp    11952 <_SpiFreeSrbExtension+0x22>
   11982:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   11989:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011990 <_ScsiPortStartPacket@4>:
   11990:	55                   	push   %ebp
   11991:	89 e5                	mov    %esp,%ebp
   11993:	83 ec 10             	sub    $0x10,%esp
   11996:	8b 4d 08             	mov    0x8(%ebp),%ecx
   11999:	8b 41 24             	mov    0x24(%ecx),%eax
   1199c:	8b 40 60             	mov    0x60(%eax),%eax
   1199f:	8b 40 14             	mov    0x14(%eax),%eax
   119a2:	8b 50 28             	mov    0x28(%eax),%edx
   119a5:	51                   	push   %ecx
   119a6:	8d 82 8c 00 00 00    	lea    0x8c(%edx),%eax
   119ac:	50                   	push   %eax
   119ad:	ff 52 48             	call   *0x48(%edx)
   119b0:	25 ff 00 00 00       	and    $0xff,%eax
   119b5:	c9                   	leave  
   119b6:	c2 04 00             	ret    $0x4
   119b9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

000119c0 <_ScsiPortDeviceControl@8>:
   119c0:	55                   	push   %ebp
   119c1:	89 e5                	mov    %esp,%ebp
   119c3:	57                   	push   %edi
   119c4:	56                   	push   %esi
   119c5:	53                   	push   %ebx
   119c6:	83 ec 1c             	sub    $0x1c,%esp
   119c9:	8b 45 0c             	mov    0xc(%ebp),%eax
   119cc:	8b 55 08             	mov    0x8(%ebp),%edx
   119cf:	8b 58 60             	mov    0x60(%eax),%ebx
   119d2:	8b 4a 28             	mov    0x28(%edx),%ecx
   119d5:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
   119dc:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   119e3:	89 4d f0             	mov    %ecx,0xfffffff0(%ebp)
   119e6:	8b 43 0c             	mov    0xc(%ebx),%eax
   119e9:	3d 10 10 04 00       	cmp    $0x41010,%eax
   119ee:	0f 84 d5 01 00 00    	je     11bc9 <_ScsiPortDeviceControl@8+0x209>
   119f4:	76 4c                	jbe    11a42 <_ScsiPortDeviceControl@8+0x82>
   119f6:	3d 20 10 04 00       	cmp    $0x41020,%eax
   119fb:	0f 84 f9 01 00 00    	je     11bfa <_ScsiPortDeviceControl@8+0x23a>
   11a01:	50                   	push   %eax
   11a02:	68 e0 06 00 00       	push   $0x6e0
   11a07:	68 11 50 01 00       	push   $0x15011
   11a0c:	68 54 50 01 00       	push   $0x15054
   11a11:	e8 7a 28 00 00       	call   14290 <_DbgPrint>
   11a16:	8b 5b 0c             	mov    0xc(%ebx),%ebx
   11a19:	5e                   	pop    %esi
   11a1a:	5f                   	pop    %edi
   11a1b:	53                   	push   %ebx
   11a1c:	68 8f 51 01 00       	push   $0x1518f
   11a21:	e8 6a 28 00 00       	call   14290 <_DbgPrint>
   11a26:	83 c4 10             	add    $0x10,%esp
   11a29:	51                   	push   %ecx
   11a2a:	51                   	push   %ecx
   11a2b:	6a 00                	push   $0x0
   11a2d:	8b 55 0c             	mov    0xc(%ebp),%edx
   11a30:	52                   	push   %edx
   11a31:	e8 1a 26 00 00       	call   14050 <_IoCompleteRequest@8>
   11a36:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11a39:	31 c0                	xor    %eax,%eax
   11a3b:	5b                   	pop    %ebx
   11a3c:	5e                   	pop    %esi
   11a3d:	5f                   	pop    %edi
   11a3e:	5d                   	pop    %ebp
   11a3f:	c2 08 00             	ret    $0x8
   11a42:	3d 0c 10 04 00       	cmp    $0x4100c,%eax
   11a47:	75 b8                	jne    11a01 <_ScsiPortDeviceControl@8+0x41>


static NTSTATUS
SpiSendInquiry (IN PDEVICE_OBJECT DeviceObject,
		IN OUT PSCSI_REQUEST_BLOCK Srb,
		IN OUT PIO_STATUS_BLOCK IoStatusBlock,
		IN OUT PKEVENT Event)
{
  PIO_STACK_LOCATION IrpStack;
  PIRP Irp;
  NTSTATUS Status;

  DPRINT ("SpiSendInquiry() called\n");


  KeInitializeEvent (Event,
		     NotificationEvent,
		     FALSE);

  Irp = IoBuildDeviceIoControlRequest (IOCTL_SCSI_EXECUTE_OUT,
				       DeviceObject,
				       NULL,
				       0,
				       Srb->DataBuffer,
				       Srb->DataTransferLength,
				       TRUE,
				       Event,
				       IoStatusBlock);
  if (Irp == NULL)
    {
      DPRINT("IoBuildDeviceIoControlRequest() failed\n");
      return STATUS_INSUFFICIENT_RESOURCES;
    }

  /* Attach Srb to the Irp */
  IrpStack = IoGetNextIrpStackLocation (Irp);
  IrpStack->Parameters.Scsi.Srb = Srb;
  Srb->OriginalRequest = Irp;

  /* Call the driver */
  Status = IoCallDriver (DeviceObject,
			 Irp);

  return Status;
}

static VOID
SpiScanAdapter (IN PSCSI_PORT_DEVICE_EXTENSION DeviceExtension)
{
  PSCSI_REQUEST_BLOCK Srb;
  PCDB Cdb;
  ULONG Bus;
  ULONG Target;
  PSCSI_PORT_SCAN_ADAPTER ScanDataArray;
  PSCSI_PORT_SCAN_ADAPTER ScanData;
  ULONG i;
  ULONG MaxCount;
  ULONG WaitCount;
  ULONG ActiveCount;
  PVOID* EventArray;
  PKWAIT_BLOCK WaitBlockArray;
  
  DPRINT ("SpiScanAdapter() called\n");

  MaxCount = DeviceExtension->PortConfig->NumberOfBuses * 
               DeviceExtension->PortConfig->MaximumNumberOfTargets;

  ScanDataArray = ExAllocatePool(NonPagedPool, MaxCount * (sizeof(SCSI_PORT_SCAN_ADAPTER) + sizeof(PVOID) + sizeof(KWAIT_BLOCK)));
  if (ScanDataArray == NULL)
    {
      return;
    }
  EventArray = (PVOID*)((PUCHAR)ScanDataArray + MaxCount * sizeof(SCSI_PORT_SCAN_ADAPTER));
  WaitBlockArray = (PKWAIT_BLOCK)((PUCHAR)EventArray + MaxCount * sizeof(PVOID));

  for (Bus = 0; Bus < DeviceExtension->PortConfig->NumberOfBuses; Bus++)
    {
      for (Target = 0; Target < DeviceExtension->PortConfig->MaximumNumberOfTargets; Target++)
	{
	  ScanData = &ScanDataArray[Bus * DeviceExtension->PortConfig->MaximumNumberOfTargets + Target];
	  ScanData->Bus = Bus;
	  ScanData->Target = Target;
	  ScanData->Lun = 0;
	  ScanData->Active = FALSE;
	}
    }
  do
    {
      ActiveCount = 0;
      WaitCount = 0;
      for (i = 0; i < MaxCount; i++)
        {
          ScanData = &ScanDataArray[i];
	  Srb = &ScanData->Srb;
          if (ScanData->Active)
            {
	      if (ScanData->Status == STATUS_PENDING &&
		  0 == KeReadStateEvent(&ScanData->Event))
	        {
		  ActiveCount++;
		  continue;
		}
	      else
	        {
                  ScanData->Status = ScanData->IoStatusBlock.Status;
	        }
	      ScanData->Active = FALSE;
	      DPRINT ("Target %lu  Lun %lu\n", ScanData->Target, ScanData->Lun);
	      DPRINT ("Status %lx  Srb.SrbStatus %x\n", ScanData->Status, Srb->SrbStatus);
	      DPRINT ("DeviceTypeQualifier %x\n", ((PINQUIRYDATA)Srb->DataBuffer)->DeviceTypeQualifier);

	      if (NT_SUCCESS(ScanData->Status) &&
		  (Srb->SrbStatus == SRB_STATUS_SUCCESS || 
		   (Srb->SrbStatus == SRB_STATUS_DATA_OVERRUN && 
		   /*
		    * FIXME: 
		    *   The NT 4.0 driver from an inic950 based scsi controller 
		    *   returns only 4 byte of inquiry data, but the device name 
		    *   is visible on NT 4.0. We must implement an other way 
		    *   to get the complete inquiry data. 
		    */
		    Srb->DataTransferLength >= /*INQUIRYDATABUFFERSIZE*/4)) &&
		  ((PINQUIRYDATA)Srb->DataBuffer)->DeviceTypeQualifier == 0)
		{
		  /* Copy inquiry data */
		  RtlCopyMemory (&ScanData->LunExtension->InquiryData,
				 Srb->DataBuffer,
				 min(sizeof(INQUIRYDATA), Srb->DataTransferLength));
	          ScanData->Lun++;
		}
	      else
		{
		  SpiRemoveLunExtension (ScanData->LunExtension);
		  ScanData->Lun = SCSI_MAXIMUM_LOGICAL_UNITS;
		}
	    }
          if (ScanData->Lun >= SCSI_MAXIMUM_LOGICAL_UNITS)
            {
	      continue;
	    }
          RtlZeroMemory(Srb, sizeof(SCSI_REQUEST_BLOCK));
          Srb->SrbFlags = SRB_FLAGS_DATA_IN;
          Srb->DataBuffer = ScanData->DataBuffer;
          Srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
          Srb->DataTransferLength = 255; //256;
          Srb->CdbLength = 6;
          Srb->Lun = ScanData->Lun;
          Srb->PathId = ScanData->Bus;
          Srb->TargetId = ScanData->Target;
          Srb->SrbStatus = SRB_STATUS_SUCCESS;
	  Srb->TimeOutValue = 2;
          Cdb = (PCDB) &Srb->Cdb;

          Cdb->CDB6INQUIRY.OperationCode = SCSIOP_INQUIRY;
          Cdb->CDB6INQUIRY.AllocationLength = 255;
          Cdb->CDB6INQUIRY.LogicalUnitNumber = ScanData->Lun;

          RtlZeroMemory(Srb->DataBuffer, 256);

          ScanData->LunExtension = SpiAllocateLunExtension (DeviceExtension,
						            ScanData->Bus,
						            ScanData->Target,
						            ScanData->Lun);
          if (ScanData->LunExtension == NULL)
	    {
	      DPRINT1("Failed to allocate the LUN extension!\n");
	      ScanData->Lun = SCSI_MAXIMUM_LOGICAL_UNITS;
	      continue;
	    }
          ScanData->Status = SpiSendInquiry (DeviceExtension->DeviceObject,
				             Srb,
				             &ScanData->IoStatusBlock,
				             &ScanData->Event);
	  ScanData->Active = TRUE;
	  ActiveCount++;
	  if (ScanData->Status == STATUS_PENDING)
	    {
              EventArray[WaitCount] = &ScanData->Event;
              WaitCount++;
            }
	}
      if (WaitCount > 0 && WaitCount == ActiveCount)
        {
          KeWaitForMultipleObjects(WaitCount,
                                   EventArray,
				   WaitAny,
				   Executive,
				   KernelMode,
				   FALSE,
				   NULL,
				   WaitBlockArray);
	}
    } 
  while (ActiveCount > 0);

  ExFreePool(ScanDataArray);
 
  DPRINT ("SpiScanAdapter() done\n");
}


static ULONG
SpiGetInquiryData(IN PSCSI_PORT_DEVICE_EXTENSION DeviceExtension,
		  OUT PSCSI_ADAPTER_BUS_INFO AdapterBusInfo)
{
   11a49:	8b 55 0c             	mov    0xc(%ebp),%edx
  PSCSI_PORT_LUN_EXTENSION LunExtension;
  PSCSI_INQUIRY_DATA UnitInfo, PrevUnit;
  ULONG Bus;
  ULONG Target;
  ULONG Lun;
  ULONG UnitCount;

  DPRINT("SpiGetInquiryData() called\n");

  /* Copy inquiry data to the port device extension */
  AdapterBusInfo->NumberOfBuses = DeviceExtension->PortConfig->NumberOfBuses;
   11a4c:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   11a4f:	8b 52 0c             	mov    0xc(%edx),%edx
   11a52:	8b 41 08             	mov    0x8(%ecx),%eax
   11a55:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
   11a58:	8a 40 40             	mov    0x40(%eax),%al
   11a5b:	88 02                	mov    %al,(%edx)

  UnitInfo = (PSCSI_INQUIRY_DATA)
   11a5d:	25 ff 00 00 00       	and    $0xff,%eax
	((PUCHAR)AdapterBusInfo + sizeof(SCSI_ADAPTER_BUS_INFO) +
	 (sizeof(SCSI_BUS_DATA) * (AdapterBusInfo->NumberOfBuses - 1)));

  for (Bus = 0; Bus < AdapterBusInfo->NumberOfBuses; Bus++)
   11a62:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
   11a69:	83 f8 00             	cmp    $0x0,%eax
   11a6c:	8d 5c c2 04          	lea    0x4(%edx,%eax,8),%ebx
   11a70:	0f 86 2f 01 00 00    	jbe    11ba5 <_ScsiPortDeviceControl@8+0x1e5>
    {
      AdapterBusInfo->BusData[Bus].InitiatorBusId =
   11a76:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   11a79:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
	DeviceExtension->PortConfig->InitiatorBusId[Bus];
      AdapterBusInfo->BusData[Bus].InquiryDataOffset =
	(ULONG)((PUCHAR)UnitInfo - (PUCHAR)AdapterBusInfo);

      PrevUnit = NULL;
   11a7c:	31 ff                	xor    %edi,%edi
   11a7e:	8b 42 08             	mov    0x8(%edx),%eax
   11a81:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   11a84:	8a 44 08 41          	mov    0x41(%eax,%ecx,1),%al
   11a88:	88 44 ca 05          	mov    %al,0x5(%edx,%ecx,8)
   11a8c:	89 d8                	mov    %ebx,%eax
   11a8e:	29 d0                	sub    %edx,%eax
      UnitCount = 0;
   11a90:	c7 45 e0 00 00 00 00 	movl   $0x0,0xffffffe0(%ebp)
   11a97:	89 44 ca 08          	mov    %eax,0x8(%edx,%ecx,8)

      for (Target = 0; Target < DeviceExtension->PortConfig->MaximumNumberOfTargets; Target++)
   11a9b:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   11a9e:	c7 45 e4 00 00 00 00 	movl   $0x0,0xffffffe4(%ebp)
   11aa5:	8b 41 08             	mov    0x8(%ecx),%eax
   11aa8:	80 78 59 00          	cmpb   $0x0,0x59(%eax)
   11aac:	0f 84 c0 00 00 00    	je     11b72 <_ScsiPortDeviceControl@8+0x1b2>
   11ab2:	8a 45 e8             	mov    0xffffffe8(%ebp),%al
   11ab5:	25 ff 00 00 00       	and    $0xff,%eax
   11aba:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
   11abd:	8d 76 00             	lea    0x0(%esi),%esi
	{
	  for (Lun = 0; Lun < SCSI_MAXIMUM_LOGICAL_UNITS; Lun++)
   11ac0:	31 f6                	xor    %esi,%esi
	    {
	      LunExtension = SpiGetLunExtension(DeviceExtension,
   11ac2:	89 f0                	mov    %esi,%eax
   11ac4:	25 ff 00 00 00       	and    $0xff,%eax
   11ac9:	50                   	push   %eax
   11aca:	31 c0                	xor    %eax,%eax
   11acc:	8a 45 e4             	mov    0xffffffe4(%ebp),%al
   11acf:	50                   	push   %eax
   11ad0:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   11ad3:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11ad6:	e8 35 fd ff ff       	call   11810 <_SpiGetLunExtension>
   11adb:	59                   	pop    %ecx
						Bus,
						Target,
						Lun);
	      if (LunExtension != NULL)
   11adc:	85 c0                	test   %eax,%eax
   11ade:	5a                   	pop    %edx
   11adf:	89 c2                	mov    %eax,%edx
   11ae1:	74 67                	je     11b4a <_ScsiPortDeviceControl@8+0x18a>
		{
		  DPRINT("(Bus %lu Target %lu Lun %lu)\n",
			 Bus, Target, Lun);

		  UnitInfo->PathId = Bus;
   11ae3:	8a 4d e8             	mov    0xffffffe8(%ebp),%cl
		  UnitInfo->TargetId = Target;
		  UnitInfo->Lun = Lun;
		  UnitInfo->InquiryDataLength = INQUIRYDATABUFFERSIZE;
   11ae6:	c7 43 04 24 00 00 00 	movl   $0x24,0x4(%ebx)
   11aed:	88 0b                	mov    %cl,(%ebx)
   11aef:	89 f1                	mov    %esi,%ecx
   11af1:	8a 45 e4             	mov    0xffffffe4(%ebp),%al
   11af4:	88 4b 02             	mov    %cl,0x2(%ebx)
   11af7:	88 43 01             	mov    %al,0x1(%ebx)
		  RtlCopyMemory (&UnitInfo->InquiryData,
				 &LunExtension->InquiryData,
				 INQUIRYDATABUFFERSIZE);
		  if (PrevUnit != NULL)
   11afa:	85 ff                	test   %edi,%edi
   11afc:	8b 42 10             	mov    0x10(%edx),%eax
   11aff:	89 43 0c             	mov    %eax,0xc(%ebx)
   11b02:	8b 42 14             	mov    0x14(%edx),%eax
   11b05:	89 43 10             	mov    %eax,0x10(%ebx)
   11b08:	8b 42 18             	mov    0x18(%edx),%eax
   11b0b:	89 43 14             	mov    %eax,0x14(%ebx)
   11b0e:	8b 42 1c             	mov    0x1c(%edx),%eax
   11b11:	89 43 18             	mov    %eax,0x18(%ebx)
   11b14:	8b 42 20             	mov    0x20(%edx),%eax
   11b17:	89 43 1c             	mov    %eax,0x1c(%ebx)
   11b1a:	8b 42 24             	mov    0x24(%edx),%eax
   11b1d:	89 43 20             	mov    %eax,0x20(%ebx)
   11b20:	8b 42 28             	mov    0x28(%edx),%eax
   11b23:	89 43 24             	mov    %eax,0x24(%ebx)
   11b26:	8b 42 2c             	mov    0x2c(%edx),%eax
   11b29:	89 43 28             	mov    %eax,0x28(%ebx)
   11b2c:	8b 42 30             	mov    0x30(%edx),%eax
   11b2f:	89 43 2c             	mov    %eax,0x2c(%ebx)
   11b32:	74 0a                	je     11b3e <_ScsiPortDeviceControl@8+0x17e>
		    {
		      PrevUnit->NextInquiryDataOffset =
   11b34:	89 d8                	mov    %ebx,%eax
   11b36:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   11b39:	29 d0                	sub    %edx,%eax
   11b3b:	89 47 08             	mov    %eax,0x8(%edi)
			(ULONG)((ULONG_PTR)UnitInfo-(ULONG_PTR)AdapterBusInfo);
		    }
		  PrevUnit = UnitInfo;
		  UnitInfo = (PSCSI_INQUIRY_DATA)((PUCHAR)UnitInfo + sizeof(SCSI_INQUIRY_DATA)+INQUIRYDATABUFFERSIZE-1);
		  UnitCount++;
   11b3e:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   11b41:	89 df                	mov    %ebx,%edi
   11b43:	40                   	inc    %eax
   11b44:	83 c3 33             	add    $0x33,%ebx
   11b47:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   11b4a:	46                   	inc    %esi
   11b4b:	83 fe 07             	cmp    $0x7,%esi
   11b4e:	0f 86 6e ff ff ff    	jbe    11ac2 <_ScsiPortDeviceControl@8+0x102>
   11b54:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   11b57:	8b 75 e4             	mov    0xffffffe4(%ebp),%esi
   11b5a:	46                   	inc    %esi
   11b5b:	8b 42 08             	mov    0x8(%edx),%eax
   11b5e:	89 75 e4             	mov    %esi,0xffffffe4(%ebp)
   11b61:	8a 40 59             	mov    0x59(%eax),%al
   11b64:	25 ff 00 00 00       	and    $0xff,%eax
   11b69:	3b 45 e4             	cmp    0xffffffe4(%ebp),%eax
   11b6c:	0f 87 4e ff ff ff    	ja     11ac0 <_ScsiPortDeviceControl@8+0x100>
		}
	    }
	}
      DPRINT("UnitCount: %lu\n", UnitCount);
      AdapterBusInfo->BusData[Bus].NumberOfLogicalUnits = UnitCount;
   11b72:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11b75:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   11b78:	8a 4d e0             	mov    0xffffffe0(%ebp),%cl
   11b7b:	88 4c c2 04          	mov    %cl,0x4(%edx,%eax,8)
      if (UnitCount == 0)
   11b7f:	8b 4d e0             	mov    0xffffffe0(%ebp),%ecx
   11b82:	85 c9                	test   %ecx,%ecx
   11b84:	75 08                	jne    11b8e <_ScsiPortDeviceControl@8+0x1ce>
	{
	  AdapterBusInfo->BusData[Bus].InquiryDataOffset = 0;
   11b86:	c7 44 c2 08 00 00 00 	movl   $0x0,0x8(%edx,%eax,8)
   11b8d:	00 
   11b8e:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   11b91:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   11b94:	40                   	inc    %eax
   11b95:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   11b98:	31 c0                	xor    %eax,%eax
   11b9a:	8a 01                	mov    (%ecx),%al
   11b9c:	3b 45 e8             	cmp    0xffffffe8(%ebp),%eax
   11b9f:	0f 87 d1 fe ff ff    	ja     11a76 <_ScsiPortDeviceControl@8+0xb6>
	}
    }
   11ba5:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11ba8:	29 c3                	sub    %eax,%ebx
   11baa:	8b 45 0c             	mov    0xc(%ebp),%eax
   11bad:	89 58 1c             	mov    %ebx,0x1c(%eax)
   11bb0:	51                   	push   %ecx
   11bb1:	51                   	push   %ecx
   11bb2:	6a 00                	push   $0x0
   11bb4:	8b 55 0c             	mov    0xc(%ebp),%edx
   11bb7:	52                   	push   %edx
   11bb8:	e8 93 24 00 00       	call   14050 <_IoCompleteRequest@8>
   11bbd:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11bc0:	31 c0                	xor    %eax,%eax
   11bc2:	5b                   	pop    %ebx
   11bc3:	5e                   	pop    %esi
   11bc4:	5f                   	pop    %edi
   11bc5:	5d                   	pop    %ebp
   11bc6:	c2 08 00             	ret    $0x8
   11bc9:	8b 45 0c             	mov    0xc(%ebp),%eax
   11bcc:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   11bcf:	8b 50 0c             	mov    0xc(%eax),%edx
   11bd2:	8b 41 3c             	mov    0x3c(%ecx),%eax
   11bd5:	89 02                	mov    %eax,(%edx)
   11bd7:	8b 45 0c             	mov    0xc(%ebp),%eax
   11bda:	c7 40 1c 04 00 00 00 	movl   $0x4,0x1c(%eax)
   11be1:	51                   	push   %ecx
   11be2:	51                   	push   %ecx
   11be3:	6a 00                	push   $0x0
   11be5:	8b 55 0c             	mov    0xc(%ebp),%edx
   11be8:	52                   	push   %edx
   11be9:	e8 62 24 00 00       	call   14050 <_IoCompleteRequest@8>
   11bee:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11bf1:	31 c0                	xor    %eax,%eax
   11bf3:	5b                   	pop    %ebx
   11bf4:	5e                   	pop    %esi
   11bf5:	5f                   	pop    %edi
   11bf6:	5d                   	pop    %ebp
   11bf7:	c2 08 00             	ret    $0x8
   11bfa:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   11bfd:	8b 41 0c             	mov    0xc(%ecx),%eax
   11c00:	c7 41 1c 24 00 00 00 	movl   $0x24,0x1c(%ecx)
   11c07:	89 50 20             	mov    %edx,0x20(%eax)
   11c0a:	51                   	push   %ecx
   11c0b:	51                   	push   %ecx
   11c0c:	6a 00                	push   $0x0
   11c0e:	8b 55 0c             	mov    0xc(%ebp),%edx
   11c11:	52                   	push   %edx
   11c12:	e8 39 24 00 00       	call   14050 <_IoCompleteRequest@8>
   11c17:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11c1a:	31 c0                	xor    %eax,%eax
   11c1c:	5b                   	pop    %ebx
   11c1d:	5e                   	pop    %esi
   11c1e:	5f                   	pop    %edi
   11c1f:	5d                   	pop    %ebp
   11c20:	c2 08 00             	ret    $0x8
   11c23:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   11c29:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011c30 <_ScsiPortIsr@8>:

  DPRINT("Data size: %lu\n", (ULONG)UnitInfo - (ULONG)AdapterBusInfo);

  return (ULONG)((PUCHAR)UnitInfo-(PUCHAR)AdapterBusInfo);
}


static BOOLEAN STDCALL
ScsiPortIsr(IN PKINTERRUPT Interrupt,
	    IN PVOID ServiceContext)
{
   11c30:	55                   	push   %ebp
   11c31:	89 e5                	mov    %esp,%ebp
   11c33:	83 ec 14             	sub    $0x14,%esp
   11c36:	8b 55 0c             	mov    0xc(%ebp),%edx
  PSCSI_PORT_DEVICE_EXTENSION DeviceExtension;

  DPRINT("ScsiPortIsr() called!\n");

  DeviceExtension = (PSCSI_PORT_DEVICE_EXTENSION)ServiceContext;

  return DeviceExtension->HwInterrupt(&DeviceExtension->MiniPortDeviceExtension);
   11c39:	8d 82 8c 00 00 00    	lea    0x8c(%edx),%eax
   11c3f:	50                   	push   %eax
   11c40:	ff 52 4c             	call   *0x4c(%edx)
   11c43:	25 ff 00 00 00       	and    $0xff,%eax
}
   11c48:	c9                   	leave  
   11c49:	c2 08 00             	ret    $0x8
   11c4c:	8d 74 26 00          	lea    0x0(%esi),%esi

00011c50 <_ScsiPortIoTimer@8>:


//    ScsiPortDpc
//  DESCRIPTION:
//
//  RUN LEVEL:
//
//  ARGUMENTS:
//    IN PKDPC          Dpc
//    IN PDEVICE_OBJECT DpcDeviceObject
//    IN PIRP           DpcIrp
//    IN PVOID          DpcContext
//
static VOID STDCALL
ScsiPortDpc(IN PKDPC Dpc,
	    IN PDEVICE_OBJECT DpcDeviceObject,
	    IN PIRP DpcIrp,
	    IN PVOID DpcContext)
{
  PSCSI_PORT_DEVICE_EXTENSION DeviceExtension;

  DPRINT("ScsiPortDpc(Dpc %p  DpcDeviceObject %p  DpcIrp %p  DpcContext %p)\n",
	 Dpc, DpcDeviceObject, DpcIrp, DpcContext);

  DeviceExtension = (PSCSI_PORT_DEVICE_EXTENSION)DpcContext;

  SpiProcessRequests(DeviceExtension, NULL);

  DPRINT("ScsiPortDpc() done\n");
}


//    ScsiPortIoTimer
//  DESCRIPTION:
//    This function handles timeouts and other time delayed processing
//
//  RUN LEVEL:
//
//  ARGUMENTS:
//    IN  PDEVICE_OBJECT  DeviceObject  Device object registered with timer
//    IN  PVOID           Context       the Controller extension for the
//                                      controller the device is on
//
static VOID STDCALL
ScsiPortIoTimer(PDEVICE_OBJECT DeviceObject,
		PVOID Context)
{
   11c50:	55                   	push   %ebp
   11c51:	89 e5                	mov    %esp,%ebp
   11c53:	83 ec 0c             	sub    $0xc,%esp
  DPRINT1("ScsiPortIoTimer()\n");
   11c56:	68 d8 08 00 00       	push   $0x8d8
   11c5b:	68 11 50 01 00       	push   $0x15011
   11c60:	68 54 50 01 00       	push   $0x15054
   11c65:	e8 26 26 00 00       	call   14290 <_DbgPrint>
   11c6a:	c7 04 24 ac 51 01 00 	movl   $0x151ac,(%esp)
   11c71:	e8 1a 26 00 00       	call   14290 <_DbgPrint>
   11c76:	c9                   	leave  
   11c77:	c2 08 00             	ret    $0x8
   11c7a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

00011c80 <_ScsiPortInitialize@16>:
   11c80:	55                   	push   %ebp
   11c81:	89 e5                	mov    %esp,%ebp
   11c83:	57                   	push   %edi
   11c84:	56                   	push   %esi
   11c85:	53                   	push   %ebx
   11c86:	81 ec dc 03 00 00    	sub    $0x3dc,%esp
   11c8c:	c6 85 83 fc ff ff 00 	movb   $0x0,0xfffffc83(%ebp)
   11c93:	8b 45 10             	mov    0x10(%ebp),%eax
   11c96:	8b 70 08             	mov    0x8(%eax),%esi
   11c99:	85 f6                	test   %esi,%esi
   11c9b:	74 15                	je     11cb2 <_ScsiPortInitialize@16+0x32>
   11c9d:	8b 58 0c             	mov    0xc(%eax),%ebx
   11ca0:	85 db                	test   %ebx,%ebx
   11ca2:	74 0e                	je     11cb2 <_ScsiPortInitialize@16+0x32>
   11ca4:	8b 48 10             	mov    0x10(%eax),%ecx
   11ca7:	85 c9                	test   %ecx,%ecx
   11ca9:	74 07                	je     11cb2 <_ScsiPortInitialize@16+0x32>
   11cab:	8b 50 14             	mov    0x14(%eax),%edx
   11cae:	85 d2                	test   %edx,%edx
   11cb0:	75 0f                	jne    11cc1 <_ScsiPortInitialize@16+0x41>
   11cb2:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
   11cb7:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11cba:	5b                   	pop    %ebx
   11cbb:	5e                   	pop    %esi
   11cbc:	5f                   	pop    %edi
   11cbd:	5d                   	pop    %ebp
   11cbe:	c2 10 00             	ret    $0x10
   11cc1:	8b 40 18             	mov    0x18(%eax),%eax
   11cc4:	85 c0                	test   %eax,%eax
   11cc6:	74 ea                	je     11cb2 <_ScsiPortInitialize@16+0x32>
   11cc8:	8b 55 08             	mov    0x8(%ebp),%edx
   11ccb:	c7 42 30 00 00 00 00 	movl   $0x0,0x30(%edx)
   11cd2:	c7 42 38 a0 18 01 00 	movl   $0x118a0,0x38(%edx)
   11cd9:	c7 42 40 a0 18 01 00 	movl   $0x118a0,0x40(%edx)
   11ce0:	c7 42 70 c0 19 01 00 	movl   $0x119c0,0x70(%edx)
   11ce7:	c7 42 74 40 3e 01 00 	movl   $0x13e40,0x74(%edx)
   11cee:	e8 8d 23 00 00       	call   14080 <_IoGetConfigurationInformation@0>
   11cf3:	8b 4d 10             	mov    0x10(%ebp),%ecx
   11cf6:	8b 59 24             	mov    0x24(%ecx),%ebx
   11cf9:	c7 85 7c fc ff ff 08 	movl   $0x8,0xfffffc7c(%ebp)
   11d00:	00 00 00 
   11d03:	89 85 90 fc ff ff    	mov    %eax,0xfffffc90(%ebp)
   11d09:	8b 41 30             	mov    0x30(%ecx),%eax
   11d0c:	c1 e0 04             	shl    $0x4,%eax
   11d0f:	81 c3 90 00 00 00    	add    $0x90,%ebx
   11d15:	05 88 00 00 00       	add    $0x88,%eax
   11d1a:	89 9d 88 fc ff ff    	mov    %ebx,0xfffffc88(%ebp)
   11d20:	89 85 84 fc ff ff    	mov    %eax,0xfffffc84(%ebp)
   11d26:	83 79 04 05          	cmpl   $0x5,0x4(%ecx)
   11d2a:	74 0a                	je     11d36 <_ScsiPortInitialize@16+0xb6>
   11d2c:	c7 85 7c fc ff ff 01 	movl   $0x1,0xfffffc7c(%ebp)
   11d33:	00 00 00 
   11d36:	c7 85 fc fc ff ff 00 	movl   $0x0,0xfffffcfc(%ebp)
   11d3d:	00 00 00 
   11d40:	c7 85 78 fc ff ff 00 	movl   $0x0,0xfffffc78(%ebp)
   11d47:	00 00 00 
   11d4a:	c7 85 f8 fc ff ff 00 	movl   $0x0,0xfffffcf8(%ebp)
   11d51:	00 00 00 
   11d54:	8b 95 90 fc ff ff    	mov    0xfffffc90(%ebp),%edx
   11d5a:	53                   	push   %ebx
   11d5b:	8d 9d 48 ff ff ff    	lea    0xffffff48(%ebp),%ebx
   11d61:	8b 4a 10             	mov    0x10(%edx),%ecx
   11d64:	51                   	push   %ecx
   11d65:	8d 8d 48 ff ff ff    	lea    0xffffff48(%ebp),%ecx
   11d6b:	68 c0 51 01 00       	push   $0x151c0
   11d70:	51                   	push   %ecx
   11d71:	e8 0a 25 00 00       	call   14280 <_swprintf>
   11d76:	58                   	pop    %eax
   11d77:	8d 85 00 fd ff ff    	lea    0xfffffd00(%ebp),%eax
   11d7d:	5a                   	pop    %edx
   11d7e:	53                   	push   %ebx
   11d7f:	50                   	push   %eax
   11d80:	e8 0b 23 00 00       	call   14090 <_RtlInitUnicodeString@8>
   11d85:	8b 85 88 fc ff ff    	mov    0xfffffc88(%ebp),%eax
   11d8b:	8d 95 fc fc ff ff    	lea    0xfffffcfc(%ebp),%edx
   11d91:	8d 8d 00 fd ff ff    	lea    0xfffffd00(%ebp),%ecx
   11d97:	89 14 24             	mov    %edx,(%esp)
   11d9a:	6a 00                	push   $0x0
   11d9c:	6a 00                	push   $0x0
   11d9e:	6a 04                	push   $0x4
   11da0:	51                   	push   %ecx
   11da1:	50                   	push   %eax
   11da2:	8b 45 08             	mov    0x8(%ebp),%eax
   11da5:	50                   	push   %eax
   11da6:	e8 f5 22 00 00       	call   140a0 <_IoCreateDevice@28>
   11dab:	89 c6                	mov    %eax,%esi
   11dad:	58                   	pop    %eax
   11dae:	85 f6                	test   %esi,%esi
   11db0:	0f 88 d3 13 00 00    	js     13189 <_ScsiPortInitialize@16+0x1509>
   11db6:	8b 85 fc fc ff ff    	mov    0xfffffcfc(%ebp),%eax
   11dbc:	8b 9d 88 fc ff ff    	mov    0xfffffc88(%ebp),%ebx
   11dc2:	8b 78 1c             	mov    0x1c(%eax),%edi
   11dc5:	c7 40 5c 01 00 00 00 	movl   $0x1,0x5c(%eax)
   11dcc:	83 cf 10             	or     $0x10,%edi
   11dcf:	89 78 1c             	mov    %edi,0x1c(%eax)
   11dd2:	8b 40 28             	mov    0x28(%eax),%eax
   11dd5:	89 85 94 fc ff ff    	mov    %eax,0xfffffc94(%ebp)
   11ddb:	56                   	push   %esi
   11ddc:	56                   	push   %esi
   11ddd:	53                   	push   %ebx
   11dde:	50                   	push   %eax
   11ddf:	e8 3c 22 00 00       	call   14020 <_RtlZeroMemory@8>
   11de4:	8b 9d 94 fc ff ff    	mov    0xfffffc94(%ebp),%ebx
   11dea:	8b 95 90 fc ff ff    	mov    0xfffffc90(%ebp),%edx
   11df0:	8b 85 88 fc ff ff    	mov    0xfffffc88(%ebp),%eax
   11df6:	8b 4d 10             	mov    0x10(%ebp),%ecx
   11df9:	89 03                	mov    %eax,(%ebx)
   11dfb:	8b 85 fc fc ff ff    	mov    0xfffffcfc(%ebp),%eax
   11e01:	89 43 40             	mov    %eax,0x40(%ebx)
   11e04:	8b 42 10             	mov    0x10(%edx),%eax
   11e07:	89 43 0c             	mov    %eax,0xc(%ebx)
   11e0a:	c7 43 50 00 00 00 00 	movl   $0x0,0x50(%ebx)
   11e11:	8b 41 24             	mov    0x24(%ecx),%eax
   11e14:	c7 43 60 00 00 00 00 	movl   $0x0,0x60(%ebx)
   11e1b:	89 43 04             	mov    %eax,0x4(%ebx)
   11e1e:	8b 41 28             	mov    0x28(%ecx),%eax
   11e21:	89 43 2c             	mov    %eax,0x2c(%ebx)
   11e24:	8b 41 2c             	mov    0x2c(%ecx),%eax
   11e27:	c7 43 54 00 00 00 00 	movl   $0x0,0x54(%ebx)
   11e2e:	89 43 38             	mov    %eax,0x38(%ebx)
   11e31:	8b 41 0c             	mov    0xc(%ecx),%eax
   11e34:	89 43 48             	mov    %eax,0x48(%ebx)
   11e37:	8b 41 10             	mov    0x10(%ecx),%eax
   11e3a:	89 43 4c             	mov    %eax,0x4c(%ebx)
 */
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
   11e3d:	89 d8                	mov    %ebx,%eax
   11e3f:	83 c0 24             	add    $0x24,%eax
   11e42:	c7 43 58 00 00 00 00 	movl   $0x0,0x58(%ebx)
   11e49:	c7 43 5c 00 00 00 00 	movl   $0x0,0x5c(%ebx)
   11e50:	c7 43 74 00 00 00 00 	movl   $0x0,0x74(%ebx)
 */
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
   11e57:	51                   	push   %ecx
	ListHead->Flink = ListHead->Blink = ListHead;
   11e58:	89 40 04             	mov    %eax,0x4(%eax)
   11e5b:	89 43 24             	mov    %eax,0x24(%ebx)
   11e5e:	83 c0 54             	add    $0x54,%eax
   11e61:	c7 83 80 00 00 00 00 	movl   $0x0,0x80(%ebx)
   11e68:	00 00 00 
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
	ListHead->Flink = ListHead->Blink = ListHead;
   11e6b:	89 43 78             	mov    %eax,0x78(%ebx)
   11e6e:	c7 83 84 00 00 00 00 	movl   $0x0,0x84(%ebx)
   11e75:	00 00 00 
   11e78:	c7 83 88 00 00 00 00 	movl   $0x0,0x88(%ebx)
   11e7f:	00 00 00 
 */
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
   11e82:	83 c3 30             	add    $0x30,%ebx
	ListHead->Flink = ListHead->Blink = ListHead;
   11e85:	89 40 04             	mov    %eax,0x4(%eax)
   11e88:	89 9d 34 fc ff ff    	mov    %ebx,0xfffffc34(%ebp)
   11e8e:	8b 85 94 fc ff ff    	mov    0xfffffc94(%ebp),%eax
   11e94:	89 5b 04             	mov    %ebx,0x4(%ebx)
   11e97:	89 58 30             	mov    %ebx,0x30(%eax)
   11e9a:	83 c0 10             	add    $0x10,%eax
   11e9d:	50                   	push   %eax
   11e9e:	e8 0d 22 00 00       	call   140b0 <_KeInitializeSpinLock@4>
   11ea3:	58                   	pop    %eax
   11ea4:	8b 85 fc fc ff ff    	mov    0xfffffcfc(%ebp),%eax
   11eaa:	5a                   	pop    %edx
   11eab:	50                   	push   %eax
   11eac:	8b 85 fc fc ff ff    	mov    0xfffffcfc(%ebp),%eax
   11eb2:	83 c0 74             	add    $0x74,%eax
   11eb5:	68 20 3e 01 00       	push   $0x13e20
   11eba:	50                   	push   %eax
   11ebb:	e8 00 22 00 00       	call   140c0 <_KeInitializeDpc@12>
   11ec0:	8b 95 94 fc ff ff    	mov    0xfffffc94(%ebp),%edx
   11ec6:	8b 85 fc fc ff ff    	mov    0xfffffcfc(%ebp),%eax
   11ecc:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)
   11ed3:	c7 42 20 00 00 00 00 	movl   $0x0,0x20(%edx)
   11eda:	52                   	push   %edx
   11edb:	68 50 1c 01 00       	push   $0x11c50
   11ee0:	50                   	push   %eax
   11ee1:	e8 ea 21 00 00       	call   140d0 <_IoInitializeTimer@12>
   11ee6:	8b b5 84 fc ff ff    	mov    0xfffffc84(%ebp),%esi
   11eec:	57                   	push   %edi
   11eed:	56                   	push   %esi
   11eee:	6a 00                	push   $0x0
   11ef0:	e8 eb 20 00 00       	call   13fe0 <_ExAllocatePool@8>
   11ef5:	8b 8d 94 fc ff ff    	mov    0xfffffc94(%ebp),%ecx
   11efb:	85 c0                	test   %eax,%eax
   11efd:	89 41 08             	mov    %eax,0x8(%ecx)
   11f00:	5a                   	pop    %edx
   11f01:	5b                   	pop    %ebx
   11f02:	0f 84 7a 12 00 00    	je     13182 <_ScsiPortInitialize@16+0x1502>
   11f08:	8b b5 84 fc ff ff    	mov    0xfffffc84(%ebp),%esi
   11f0e:	57                   	push   %edi
   11f0f:	57                   	push   %edi
   11f10:	56                   	push   %esi
   11f11:	8b 59 08             	mov    0x8(%ecx),%ebx
   11f14:	53                   	push   %ebx
   11f15:	e8 06 21 00 00       	call   14020 <_RtlZeroMemory@8>
   11f1a:	8b 9d 94 fc ff ff    	mov    0xfffffc94(%ebp),%ebx
   11f20:	8b 55 10             	mov    0x10(%ebp),%edx
   11f23:	8b 85 78 fc ff ff    	mov    0xfffffc78(%ebp),%eax
   11f29:	8b 5b 08             	mov    0x8(%ebx),%ebx
   11f2c:	89 9d 8c fc ff ff    	mov    %ebx,0xfffffc8c(%ebp)
   11f32:	89 43 04             	mov    %eax,0x4(%ebx)
   11f35:	8b 42 04             	mov    0x4(%edx),%eax
   11f38:	c7 03 88 00 00 00    	movl   $0x88,(%ebx)
   11f3e:	89 43 08             	mov    %eax,0x8(%ebx)
   11f41:	83 f8 05             	cmp    $0x5,%eax
   11f44:	5f                   	pop    %edi
   11f45:	0f 95 c0             	setne  %al
   11f48:	59                   	pop    %ecx
   11f49:	25 ff 00 00 00       	and    $0xff,%eax
   11f4e:	c7 43 18 ff ff ff ff 	movl   $0xffffffff,0x18(%ebx)
   11f55:	c7 43 1c ff ff ff ff 	movl   $0xffffffff,0x1c(%ebx)
   11f5c:	c7 43 20 ff ff ff ff 	movl   $0xffffffff,0x20(%ebx)
   11f63:	c7 43 24 ff ff ff ff 	movl   $0xffffffff,0x24(%ebx)
   11f6a:	c7 43 30 00 00 00 00 	movl   $0x0,0x30(%ebx)
   11f71:	89 43 14             	mov    %eax,0x14(%ebx)
   11f74:	8b 42 30             	mov    0x30(%edx),%eax
   11f77:	c7 43 28 00 00 00 00 	movl   $0x0,0x28(%ebx)
   11f7e:	89 43 34             	mov    %eax,0x34(%ebx)
   11f81:	c7 43 2c 00 00 00 00 	movl   $0x0,0x2c(%ebx)
   11f88:	c6 43 40 00          	movb   $0x0,0x40(%ebx)
   11f8c:	31 c0                	xor    %eax,%eax
   11f8e:	89 f6                	mov    %esi,%esi
   11f90:	8b 8d 8c fc ff ff    	mov    0xfffffc8c(%ebp),%ecx
   11f96:	c6 44 01 41 ff       	movb   $0xff,0x41(%ecx,%eax,1)
   11f9b:	40                   	inc    %eax
   11f9c:	83 f8 07             	cmp    $0x7,%eax
   11f9f:	76 ef                	jbe    11f90 <_ScsiPortInitialize@16+0x310>
   11fa1:	c6 41 49 00          	movb   $0x0,0x49(%ecx)
   11fa5:	c6 41 4a 00          	movb   $0x0,0x4a(%ecx)
   11fa9:	c6 41 4b 00          	movb   $0x0,0x4b(%ecx)
   11fad:	c6 41 4c 00          	movb   $0x0,0x4c(%ecx)
   11fb1:	8b 9d 90 fc ff ff    	mov    0xfffffc90(%ebp),%ebx
   11fb7:	8a 43 1c             	mov    0x1c(%ebx),%al
   11fba:	88 41 4d             	mov    %al,0x4d(%ecx)
   11fbd:	8a 43 1d             	mov    0x1d(%ebx),%al
   11fc0:	c6 41 4f 00          	movb   $0x0,0x4f(%ecx)
   11fc4:	88 41 4e             	mov    %al,0x4e(%ecx)
   11fc7:	c6 41 50 00          	movb   $0x0,0x50(%ecx)
   11fcb:	8b 55 10             	mov    0x10(%ebp),%edx
   11fce:	8a 42 38             	mov    0x38(%edx),%al
   11fd1:	88 41 51             	mov    %al,0x51(%ecx)
   11fd4:	8a 42 39             	mov    0x39(%edx),%al
   11fd7:	88 41 52             	mov    %al,0x52(%ecx)
   11fda:	8a 42 3a             	mov    0x3a(%edx),%al
   11fdd:	88 41 53             	mov    %al,0x53(%ecx)
   11fe0:	8a 42 3b             	mov    0x3b(%edx),%al
   11fe3:	88 41 54             	mov    %al,0x54(%ecx)
   11fe6:	8a 42 3c             	mov    0x3c(%edx),%al
   11fe9:	88 41 55             	mov    %al,0x55(%ecx)
   11fec:	8a 42 3d             	mov    0x3d(%edx),%al
   11fef:	c6 41 57 00          	movb   $0x0,0x57(%ecx)
   11ff3:	88 41 56             	mov    %al,0x56(%ecx)
   11ff6:	c6 41 58 00          	movb   $0x0,0x58(%ecx)
   11ffa:	c6 41 59 08          	movb   $0x8,0x59(%ecx)
   11ffe:	8b 42 2c             	mov    0x2c(%edx),%eax
   12001:	89 81 84 00 00 00    	mov    %eax,0x84(%ecx)
   12007:	8b 42 28             	mov    0x28(%edx),%eax
   1200a:	89 81 80 00 00 00    	mov    %eax,0x80(%ecx)
   12010:	89 c8                	mov    %ecx,%eax
   12012:	05 88 00 00 00       	add    $0x88,%eax
   12017:	89 41 38             	mov    %eax,0x38(%ecx)
   1201a:	83 7a 04 05          	cmpl   $0x5,0x4(%edx)
   1201e:	0f 85 8b 00 00 00    	jne    120af <_ScsiPortInitialize@16+0x42f>
   12024:	66 83 7a 3e 00       	cmpw   $0x0,0x3e(%edx)
   12029:	0f 84 80 00 00 00    	je     120af <_ScsiPortInitialize@16+0x42f>
   1202f:	8b 72 40             	mov    0x40(%edx),%esi
   12032:	85 f6                	test   %esi,%esi
   12034:	74 79                	je     120af <_ScsiPortInitialize@16+0x42f>
   12036:	66 83 7a 46 00       	cmpw   $0x0,0x46(%edx)
   1203b:	74 72                	je     120af <_ScsiPortInitialize@16+0x42f>
   1203d:	8b 5a 48             	mov    0x48(%edx),%ebx
   12040:	85 db                	test   %ebx,%ebx
   12042:	74 6b                	je     120af <_ScsiPortInitialize@16+0x42f>
   12044:	8a 95 f8 fc ff ff    	mov    0xfffffcf8(%ebp),%dl
   1204a:	88 d0                	mov    %dl,%al
   1204c:	c0 e8 05             	shr    $0x5,%al
   1204f:	25 ff 00 00 00       	and    $0xff,%eax
   12054:	83 f8 07             	cmp    $0x7,%eax
   12057:	7e 2f                	jle    12088 <_ScsiPortInitialize@16+0x408>
   12059:	8b 95 f8 fc ff ff    	mov    0xfffffcf8(%ebp),%edx
   1205f:	31 c0                	xor    %eax,%eax
   12061:	80 e2 1f             	and    $0x1f,%dl
   12064:	89 95 f8 fc ff ff    	mov    %edx,0xfffffcf8(%ebp)
   1206a:	83 e2 e0             	and    $0xffffffe0,%edx
   1206d:	8a 85 f8 fc ff ff    	mov    0xfffffcf8(%ebp),%al
   12073:	83 e0 1f             	and    $0x1f,%eax
   12076:	40                   	inc    %eax
   12077:	83 e0 1f             	and    $0x1f,%eax
   1207a:	09 c2                	or     %eax,%edx
   1207c:	89 95 f8 fc ff ff    	mov    %edx,0xfffffcf8(%ebp)
   12082:	8a 95 f8 fc ff ff    	mov    0xfffffcf8(%ebp),%dl
   12088:	89 d0                	mov    %edx,%eax
   1208a:	83 e0 1f             	and    $0x1f,%eax
   1208d:	83 f8 1f             	cmp    $0x1f,%eax
   12090:	0f 8e 67 0f 00 00    	jle    12ffd <_ScsiPortInitialize@16+0x137d>
   12096:	8b 8d f8 fc ff ff    	mov    0xfffffcf8(%ebp),%ecx
   1209c:	83 e1 e0             	and    $0xffffffe0,%ecx
   1209f:	89 8d f8 fc ff ff    	mov    %ecx,0xfffffcf8(%ebp)
   120a5:	31 c0                	xor    %eax,%eax
   120a7:	85 c0                	test   %eax,%eax
   120a9:	0f 84 50 13 00 00    	je     133ff <_ScsiPortInitialize@16+0x177f>
   120af:	8b 5d 14             	mov    0x14(%ebp),%ebx
   120b2:	8d 85 e3 fc ff ff    	lea    0xfffffce3(%ebp),%eax
   120b8:	8b b5 8c fc ff ff    	mov    0xfffffc8c(%ebp),%esi
   120be:	8b 55 10             	mov    0x10(%ebp),%edx
   120c1:	57                   	push   %edi
   120c2:	57                   	push   %edi
   120c3:	50                   	push   %eax
   120c4:	56                   	push   %esi
   120c5:	68 e8 51 01 00       	push   $0x151e8
   120ca:	6a 00                	push   $0x0
   120cc:	53                   	push   %ebx
   120cd:	8b 9d 94 fc ff ff    	mov    0xfffffc94(%ebp),%ebx
   120d3:	c6 85 e3 fc ff ff 00 	movb   $0x0,0xfffffce3(%ebp)
   120da:	81 c3 8c 00 00 00    	add    $0x8c,%ebx
   120e0:	53                   	push   %ebx
   120e1:	ff 52 14             	call   *0x14(%edx)
   120e4:	5a                   	pop    %edx
   120e5:	48                   	dec    %eax
   120e6:	59                   	pop    %ecx
   120e7:	0f 85 99 06 00 00    	jne    12786 <_ScsiPortInitialize@16+0xb06>
   120ed:	8b 8d 94 fc ff ff    	mov    0xfffffc94(%ebp),%ecx
   120f3:	8b 41 60             	mov    0x60(%ecx),%eax
   120f6:	85 c0                	test   %eax,%eax
   120f8:	75 0b                	jne    12105 <_ScsiPortInitialize@16+0x485>
   120fa:	8b 41 38             	mov    0x38(%ecx),%eax
   120fd:	85 c0                	test   %eax,%eax
   120ff:	0f 85 d4 0e 00 00    	jne    12fd9 <_ScsiPortInitialize@16+0x1359>
   12105:	8d 85 dc fc ff ff    	lea    0xfffffcdc(%ebp),%eax
   1210b:	56                   	push   %esi
   1210c:	56                   	push   %esi
   1210d:	50                   	push   %eax
   1210e:	8d 85 db fc ff ff    	lea    0xfffffcdb(%ebp),%eax
   12114:	50                   	push   %eax
   12115:	8b 85 8c fc ff ff    	mov    0xfffffc8c(%ebp),%eax
   1211b:	8b 48 0c             	mov    0xc(%eax),%ecx
   1211e:	51                   	push   %ecx
   1211f:	8b 50 0c             	mov    0xc(%eax),%edx
   12122:	52                   	push   %edx
   12123:	8b 78 04             	mov    0x4(%eax),%edi
   12126:	57                   	push   %edi
   12127:	8b 70 08             	mov    0x8(%eax),%esi
   1212a:	56                   	push   %esi
   1212b:	e8 e0 21 00 00       	call   14310 <_HalGetInterruptVector@24>
   12130:	8b 8d dc fc ff ff    	mov    0xfffffcdc(%ebp),%ecx
   12136:	8b 95 8c fc ff ff    	mov    0xfffffc8c(%ebp),%edx
   1213c:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   12143:	51                   	push   %ecx
   12144:	6a 01                	push   $0x1
   12146:	8b 52 14             	mov    0x14(%edx),%edx
   12149:	52                   	push   %edx
   1214a:	31 d2                	xor    %edx,%edx
   1214c:	8a 95 db fc ff ff    	mov    0xfffffcdb(%ebp),%dl
   12152:	52                   	push   %edx
   12153:	52                   	push   %edx
   12154:	50                   	push   %eax
   12155:	8b 85 94 fc ff ff    	mov    0xfffffc94(%ebp),%eax
   1215b:	6a 00                	push   $0x0
   1215d:	50                   	push   %eax
   1215e:	8b 85 94 fc ff ff    	mov    0xfffffc94(%ebp),%eax
   12164:	68 30 1c 01 00       	push   $0x11c30
   12169:	83 c0 18             	add    $0x18,%eax
   1216c:	50                   	push   %eax
   1216d:	e8 6e 1f 00 00       	call   140e0 <_IoConnectInterrupt@44>
   12172:	89 c6                	mov    %eax,%esi
   12174:	5f                   	pop    %edi
   12175:	85 c0                	test   %eax,%eax
   12177:	0f 88 d5 10 00 00    	js     13252 <_ScsiPortInitialize@16+0x15d2>
   1217d:	83 ec 0c             	sub    $0xc,%esp
   12180:	8b 4d 10             	mov    0x10(%ebp),%ecx
   12183:	53                   	push   %ebx
   12184:	ff 51 08             	call   *0x8(%ecx)
   12187:	83 c4 0c             	add    $0xc,%esp
   1218a:	84 c0                	test   %al,%al
   1218c:	0f 84 a6 10 00 00    	je     13238 <_ScsiPortInitialize@16+0x15b8>
   12192:	56                   	push   %esi
   12193:	56                   	push   %esi
   12194:	6a 18                	push   $0x18
   12196:	6a 00                	push   $0x0
   12198:	e8 43 1e 00 00       	call   13fe0 <_ExAllocatePool@8>
   1219d:	8b 9d 94 fc ff ff    	mov    0xfffffc94(%ebp),%ebx
   121a3:	89 c2                	mov    %eax,%edx
   121a5:	85 c0                	test   %eax,%eax
   121a7:	89 43 3c             	mov    %eax,0x3c(%ebx)
   121aa:	59                   	pop    %ecx
   121ab:	5b                   	pop    %ebx
   121ac:	0f 84 be 10 00 00    	je     13270 <_ScsiPortInitialize@16+0x15f0>
   121b2:	c7 00 18 00 00 00    	movl   $0x18,(%eax)
   121b8:	8b 85 8c fc ff ff    	mov    0xfffffc8c(%ebp),%eax
   121be:	80 78 49 00          	cmpb   $0x0,0x49(%eax)
   121c2:	0f 84 eb 05 00 00    	je     127b3 <_ScsiPortInitialize@16+0xb33>
   121c8:	8b 40 1c             	mov    0x1c(%eax),%eax
   121cb:	3d ff ff 0f 00       	cmp    $0xfffff,%eax
   121d0:	0f 87 da 0d 00 00    	ja     12fb0 <_ScsiPortInitialize@16+0x1330>
   121d6:	8b 9d 8c fc ff ff    	mov    0xfffffc8c(%ebp),%ebx
   121dc:	89 c1                	mov    %eax,%ecx
   121de:	c1 e1 0c             	shl    $0xc,%ecx
   121e1:	8b 43 18             	mov    0x18(%ebx),%eax
   121e4:	39 c8                	cmp    %ecx,%eax
   121e6:	72 02                	jb     121ea <_ScsiPortInitialize@16+0x56a>
   121e8:	89 c8                	mov    %ecx,%eax
   121ea:	89 42 04             	mov    %eax,0x4(%edx)
   121ed:	8b 8d 8c fc ff ff    	mov    0xfffffc8c(%ebp),%ecx
   121f3:	c1 e8 0c             	shr    $0xc,%eax
   121f6:	c7 42 0c 00 00 00 00 	movl   $0x0,0xc(%edx)
   121fd:	89 42 08             	mov    %eax,0x8(%edx)
   12200:	8b 41 30             	mov    0x30(%ecx),%eax
   12203:	89 42 10             	mov    %eax,0x10(%edx)
   12206:	8a 41 53             	mov    0x53(%ecx),%al
   12209:	88 42 14             	mov    %al,0x14(%edx)
   1220c:	8a 41 4c             	mov    0x4c(%ecx),%al
   1220f:	c6 42 16 01          	movb   $0x1,0x16(%edx)
   12213:	88 42 15             	mov    %al,0x15(%edx)
   12216:	31 d2                	xor    %edx,%edx
   12218:	8b 9d 94 fc ff ff    	mov    0xfffffc94(%ebp),%ebx
   1221e:	8b 43 08             	mov    0x8(%ebx),%eax
   12221:	8a 50 40             	mov    0x40(%eax),%dl
   12224:	8a 40 59             	mov    0x59(%eax),%al
   12227:	25 ff 00 00 00       	and    $0xff,%eax
   1222c:	0f af c2             	imul   %edx,%eax
   1222f:	89 85 60 fc ff ff    	mov    %eax,0xfffffc60(%ebp)
   12235:	52                   	push   %edx
   12236:	8d 1c 40             	lea    (%eax,%eax,2),%ebx
   12239:	52                   	push   %edx
   1223a:	89 d8                	mov    %ebx,%eax
   1223c:	c1 e0 05             	shl    $0x5,%eax
   1223f:	8d 04 03             	lea    (%ebx,%eax,1),%eax
   12242:	c1 e0 02             	shl    $0x2,%eax
   12245:	50                   	push   %eax
   12246:	6a 00                	push   $0x0
   12248:	e8 93 1d 00 00       	call   13fe0 <_ExAllocatePool@8>
   1224d:	5e                   	pop    %esi
   1224e:	85 c0                	test   %eax,%eax
   12250:	5f                   	pop    %edi
   12251:	89 85 68 fc ff ff    	mov    %eax,0xfffffc68(%ebp)
   12257:	0f 84 4a 03 00 00    	je     125a7 <_ScsiPortInitialize@16+0x927>
   1225d:	8d 04 dd 00 00 00 00 	lea    0x0(,%ebx,8),%eax
   12264:	8b 8d 60 fc ff ff    	mov    0xfffffc60(%ebp),%ecx
   1226a:	29 c8                	sub    %ecx,%eax
   1226c:	8b 95 68 fc ff ff    	mov    0xfffffc68(%ebp),%edx
   12272:	c1 e0 04             	shl    $0x4,%eax
   12275:	8b 8d 60 fc ff ff    	mov    0xfffffc60(%ebp),%ecx
   1227b:	01 d0                	add    %edx,%eax
   1227d:	31 f6                	xor    %esi,%esi
   1227f:	89 85 54 fc ff ff    	mov    %eax,0xfffffc54(%ebp)
   12285:	8d 0c 88             	lea    (%eax,%ecx,4),%ecx
   12288:	8b 85 94 fc ff ff    	mov    0xfffffc94(%ebp),%eax
   1228e:	89 8d 50 fc ff ff    	mov    %ecx,0xfffffc50(%ebp)
   12294:	8b 58 08             	mov    0x8(%eax),%ebx
   12297:	80 7b 40 00          	cmpb   $0x0,0x40(%ebx)
   1229b:	74 53                	je     122f0 <_ScsiPortInitialize@16+0x670>
   1229d:	8d 76 00             	lea    0x0(%esi),%esi
   122a0:	31 c9                	xor    %ecx,%ecx
   122a2:	80 7b 59 00          	cmpb   $0x0,0x59(%ebx)
   122a6:	74 3e                	je     122e6 <_ScsiPortInitialize@16+0x666>
   122a8:	31 c0                	xor    %eax,%eax
   122aa:	8a 43 59             	mov    0x59(%ebx),%al
   122ad:	0f af c6             	imul   %esi,%eax
   122b0:	01 c8                	add    %ecx,%eax
   122b2:	8d 14 40             	lea    (%eax,%eax,2),%edx
   122b5:	c1 e2 03             	shl    $0x3,%edx
   122b8:	29 c2                	sub    %eax,%edx
   122ba:	8b 85 68 fc ff ff    	mov    0xfffffc68(%ebp),%eax
   122c0:	c1 e2 04             	shl    $0x4,%edx
   122c3:	01 c2                	add    %eax,%edx
   122c5:	31 c0                	xor    %eax,%eax
   122c7:	89 4a 28             	mov    %ecx,0x28(%edx)
   122ca:	89 72 24             	mov    %esi,0x24(%edx)
   122cd:	c7 42 20 00 00 00 00 	movl   $0x0,0x20(%edx)
   122d4:	c7 82 6c 01 00 00 00 	movl   $0x0,0x16c(%edx)
   122db:	00 00 00 
   122de:	41                   	inc    %ecx
   122df:	8a 43 59             	mov    0x59(%ebx),%al
   122e2:	39 c8                	cmp    %ecx,%eax
   122e4:	77 c2                	ja     122a8 <_ScsiPortInitialize@16+0x628>
   122e6:	31 c0                	xor    %eax,%eax
   122e8:	46                   	inc    %esi
   122e9:	8a 43 40             	mov    0x40(%ebx),%al
   122ec:	39 f0                	cmp    %esi,%eax
   122ee:	77 b0                	ja     122a0 <_ScsiPortInitialize@16+0x620>
   122f0:	c7 85 58 fc ff ff 00 	movl   $0x0,0xfffffc58(%ebp)
   122f7:	00 00 00 
   122fa:	8b 95 60 fc ff ff    	mov    0xfffffc60(%ebp),%edx
   12300:	c7 85 5c fc ff ff 00 	movl   $0x0,0xfffffc5c(%ebp)
   12307:	00 00 00 
   1230a:	39 95 58 fc ff ff    	cmp    %edx,0xfffffc58(%ebp)
   12310:	0f 83 4a 02 00 00    	jae    12560 <_ScsiPortInitialize@16+0x8e0>
   12316:	8b b5 68 fc ff ff    	mov    0xfffffc68(%ebp),%esi
   1231c:	89 95 64 fc ff ff    	mov    %edx,0xfffffc64(%ebp)
   12322:	eb 12                	jmp    12336 <_ScsiPortInitialize@16+0x6b6>
   12324:	81 c6 70 01 00 00    	add    $0x170,%esi
   1232a:	ff 8d 64 fc ff ff    	decl   0xfffffc64(%ebp)
   12330:	0f 84 2a 02 00 00    	je     12560 <_ScsiPortInitialize@16+0x8e0>
   12336:	8d 4e 2c             	lea    0x2c(%esi),%ecx
   12339:	8b 86 6c 01 00 00    	mov    0x16c(%esi),%eax
   1233f:	89 8d 6c fc ff ff    	mov    %ecx,0xfffffc6c(%ebp)
   12345:	85 c0                	test   %eax,%eax
   12347:	74 58                	je     123a1 <_ScsiPortInitialize@16+0x721>
   12349:	81 7e 18 03 01 00 00 	cmpl   $0x103,0x18(%esi)
   12350:	0f 84 b1 03 00 00    	je     12707 <_ScsiPortInitialize@16+0xa87>
   12356:	8b 46 10             	mov    0x10(%esi),%eax
   12359:	c7 86 6c 01 00 00 00 	movl   $0x0,0x16c(%esi)
   12360:	00 00 00 
   12363:	89 46 18             	mov    %eax,0x18(%esi)
   12366:	85 c0                	test   %eax,%eax
   12368:	78 13                	js     1237d <_ScsiPortInitialize@16+0x6fd>
   1236a:	8a 46 2f             	mov    0x2f(%esi),%al
   1236d:	3c 01                	cmp    $0x1,%al
   1236f:	0f 84 5b 03 00 00    	je     126d0 <_ScsiPortInitialize@16+0xa50>
   12375:	3c 12                	cmp    $0x12,%al
   12377:	0f 84 46 03 00 00    	je     126c3 <_ScsiPortInitialize@16+0xa43>
   1237d:	8b 4e 1c             	mov    0x1c(%esi),%ecx
   12380:	85 c9                	test   %ecx,%ecx
   12382:	74 16                	je     1239a <_ScsiPortInitialize@16+0x71a>
{
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
   12384:	8b 11                	mov    (%ecx),%edx
  OldBlink = Entry->Blink;
   12386:	8b 41 04             	mov    0x4(%ecx),%eax
   12389:	83 ec 0c             	sub    $0xc,%esp
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
  OldBlink = Entry->Blink;
  OldFlink->Blink = OldBlink;
   1238c:	89 42 04             	mov    %eax,0x4(%edx)
  OldBlink->Flink = OldFlink;
   1238f:	89 10                	mov    %edx,(%eax)
   12391:	51                   	push   %ecx
   12392:	e8 29 1c 00 00       	call   13fc0 <_ExFreePool@4>
   12397:	83 c4 0c             	add    $0xc,%esp
   1239a:	c7 46 20 08 00 00 00 	movl   $0x8,0x20(%esi)
   123a1:	83 7e 20 07          	cmpl   $0x7,0x20(%esi)
   123a5:	0f 87 79 ff ff ff    	ja     12324 <_ScsiPortInitialize@16+0x6a4>
   123ab:	8b bd 6c fc ff ff    	mov    0xfffffc6c(%ebp),%edi
   123b1:	50                   	push   %eax
   123b2:	50                   	push   %eax
   123b3:	6a 40                	push   $0x40
   123b5:	57                   	push   %edi
   123b6:	e8 65 1c 00 00       	call   14020 <_RtlZeroMemory@8>
   123bb:	8d 46 6c             	lea    0x6c(%esi),%eax
   123be:	89 46 44             	mov    %eax,0x44(%esi)
   123c1:	8b 46 24             	mov    0x24(%esi),%eax
   123c4:	88 46 31             	mov    %al,0x31(%esi)
   123c7:	8b 46 28             	mov    0x28(%esi),%eax
   123ca:	8b 56 20             	mov    0x20(%esi),%edx
   123cd:	88 46 32             	mov    %al,0x32(%esi)
   123d0:	8a 46 5d             	mov    0x5d(%esi),%al
   123d3:	88 56 33             	mov    %dl,0x33(%esi)
   123d6:	83 e0 1f             	and    $0x1f,%eax
   123d9:	c7 46 38 40 00 00 00 	movl   $0x40,0x38(%esi)
   123e0:	c1 e2 05             	shl    $0x5,%edx
   123e3:	c6 46 2e 00          	movb   $0x0,0x2e(%esi)
   123e7:	09 d0                	or     %edx,%eax
   123e9:	c7 46 3c ff 00 00 00 	movl   $0xff,0x3c(%esi)
   123f0:	88 46 5d             	mov    %al,0x5d(%esi)
   123f3:	c6 46 36 06          	movb   $0x6,0x36(%esi)
   123f7:	c6 46 2f 01          	movb   $0x1,0x2f(%esi)
   123fb:	c7 46 40 02 00 00 00 	movl   $0x2,0x40(%esi)
   12402:	c6 46 5c 12          	movb   $0x12,0x5c(%esi)
   12406:	c6 46 60 ff          	movb   $0xff,0x60(%esi)
   1240a:	68 00 01 00 00       	push   $0x100
   1240f:	8b 5e 44             	mov    0x44(%esi),%ebx
   12412:	53                   	push   %ebx
   12413:	e8 08 1c 00 00       	call   14020 <_RtlZeroMemory@8>
   12418:	8b 8d 94 fc ff ff    	mov    0xfffffc94(%ebp),%ecx
   1241e:	8b 5e 24             	mov    0x24(%esi),%ebx
   12421:	8b 56 20             	mov    0x20(%esi),%edx
   12424:	8b 46 28             	mov    0x28(%esi),%eax
   12427:	8b 79 2c             	mov    0x2c(%ecx),%edi
   1242a:	89 9d 4c fc ff ff    	mov    %ebx,0xfffffc4c(%ebp)
   12430:	81 c7 84 00 00 00    	add    $0x84,%edi
   12436:	89 95 44 fc ff ff    	mov    %edx,0xfffffc44(%ebp)
   1243c:	57                   	push   %edi
   1243d:	89 85 48 fc ff ff    	mov    %eax,0xfffffc48(%ebp)
   12443:	6a 00                	push   $0x0
   12445:	e8 96 1b 00 00       	call   13fe0 <_ExAllocatePool@8>
   1244a:	89 c3                	mov    %eax,%ebx
   1244c:	5a                   	pop    %edx
   1244d:	31 c0                	xor    %eax,%eax
   1244f:	59                   	pop    %ecx
   12450:	85 db                	test   %ebx,%ebx
   12452:	74 50                	je     124a4 <_ScsiPortInitialize@16+0x824>
   12454:	50                   	push   %eax
   12455:	50                   	push   %eax
   12456:	57                   	push   %edi
   12457:	53                   	push   %ebx
   12458:	e8 c3 1b 00 00       	call   14020 <_RtlZeroMemory@8>
   1245d:	5a                   	pop    %edx
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
   1245e:	8b 95 34 fc ff ff    	mov    0xfffffc34(%ebp),%edx
   12464:	59                   	pop    %ecx
   12465:	8a 8d 4c fc ff ff    	mov    0xfffffc4c(%ebp),%cl
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
   1246b:	8b 42 04             	mov    0x4(%edx),%eax
	Entry->Flink = ListHead;
   1246e:	89 13                	mov    %edx,(%ebx)
	Entry->Blink = OldBlink;
   12470:	89 43 04             	mov    %eax,0x4(%ebx)
	OldBlink->Flink = Entry;
	ListHead->Blink = Entry;
   12473:	89 5a 04             	mov    %ebx,0x4(%edx)
   12476:	89 18                	mov    %ebx,(%eax)
   12478:	88 4b 08             	mov    %cl,0x8(%ebx)
   1247b:	8a 85 48 fc ff ff    	mov    0xfffffc48(%ebp),%al
   12481:	c7 43 70 00 00 00 00 	movl   $0x0,0x70(%ebx)
   12488:	88 43 09             	mov    %al,0x9(%ebx)
   1248b:	c7 43 74 00 00 00 00 	movl   $0x0,0x74(%ebx)
   12492:	8a 95 44 fc ff ff    	mov    0xfffffc44(%ebp),%dl
   12498:	c7 43 78 00 00 00 00 	movl   $0x0,0x78(%ebx)
   1249f:	88 53 0a             	mov    %dl,0xa(%ebx)
   124a2:	89 d8                	mov    %ebx,%eax
   124a4:	89 46 1c             	mov    %eax,0x1c(%esi)
   124a7:	85 c0                	test   %eax,%eax
   124a9:	0f 84 7e 02 00 00    	je     1272d <_ScsiPortInitialize@16+0xaad>
   124af:	8b 8d 94 fc ff ff    	mov    0xfffffc94(%ebp),%ecx
   124b5:	8d 5e 10             	lea    0x10(%esi),%ebx
   124b8:	8b 79 40             	mov    0x40(%ecx),%edi
   124bb:	50                   	push   %eax
   124bc:	6a 00                	push   $0x0
   124be:	6a 00                	push   $0x0
   124c0:	56                   	push   %esi
   124c1:	e8 2a 1c 00 00       	call   140f0 <_KeInitializeEvent@12>
   124c6:	50                   	push   %eax
   124c7:	50                   	push   %eax
   124c8:	53                   	push   %ebx
   124c9:	56                   	push   %esi
   124ca:	6a 01                	push   $0x1
   124cc:	8b 46 3c             	mov    0x3c(%esi),%eax
   124cf:	50                   	push   %eax
   124d0:	8b 46 44             	mov    0x44(%esi),%eax
   124d3:	50                   	push   %eax
   124d4:	6a 00                	push   $0x0
   124d6:	6a 00                	push   $0x0
   124d8:	57                   	push   %edi
   124d9:	68 12 00 1b 00       	push   $0x1b0012
   124de:	e8 1d 1c 00 00       	call   14100 <_IoBuildDeviceIoControlRequest@36>
   124e3:	89 c2                	mov    %eax,%edx
   124e5:	83 c4 0c             	add    $0xc,%esp
   124e8:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
   124ed:	85 d2                	test   %edx,%edx
   124ef:	74 1d                	je     1250e <_ScsiPortInitialize@16+0x88e>
   124f1:	8b 42 60             	mov    0x60(%edx),%eax
   124f4:	8b 9d 6c fc ff ff    	mov    0xfffffc6c(%ebp),%ebx
   124fa:	83 e8 24             	sub    $0x24,%eax
   124fd:	89 58 04             	mov    %ebx,0x4(%eax)
   12500:	89 56 50             	mov    %edx,0x50(%esi)
   12503:	50                   	push   %eax
   12504:	50                   	push   %eax
   12505:	52                   	push   %edx
   12506:	57                   	push   %edi
   12507:	e8 04 1c 00 00       	call   14110 <_IoCallDriver@8>
   1250c:	59                   	pop    %ecx
   1250d:	5b                   	pop    %ebx
   1250e:	8b 95 58 fc ff ff    	mov    0xfffffc58(%ebp),%edx
   12514:	89 46 18             	mov    %eax,0x18(%esi)
   12517:	42                   	inc    %edx
   12518:	c7 86 6c 01 00 00 01 	movl   $0x1,0x16c(%esi)
   1251f:	00 00 00 
   12522:	89 95 58 fc ff ff    	mov    %edx,0xfffffc58(%ebp)
   12528:	3d 03 01 00 00       	cmp    $0x103,%eax
   1252d:	0f 85 f1 fd ff ff    	jne    12324 <_ScsiPortInitialize@16+0x6a4>
   12533:	8b 85 5c fc ff ff    	mov    0xfffffc5c(%ebp),%eax
   12539:	8b 95 54 fc ff ff    	mov    0xfffffc54(%ebp),%edx
   1253f:	89 34 82             	mov    %esi,(%edx,%eax,4)
   12542:	40                   	inc    %eax
   12543:	81 c6 70 01 00 00    	add    $0x170,%esi
   12549:	ff 8d 64 fc ff ff    	decl   0xfffffc64(%ebp)
   1254f:	89 85 5c fc ff ff    	mov    %eax,0xfffffc5c(%ebp)
   12555:	0f 85 db fd ff ff    	jne    12336 <_ScsiPortInitialize@16+0x6b6>
   1255b:	90                   	nop    
   1255c:	8d 74 26 00          	lea    0x0(%esi),%esi
   12560:	8b 85 5c fc ff ff    	mov    0xfffffc5c(%ebp),%eax
   12566:	8b 8d 58 fc ff ff    	mov    0xfffffc58(%ebp),%ecx
   1256c:	85 c0                	test   %eax,%eax
   1256e:	0f 95 c2             	setne  %dl
   12571:	39 8d 5c fc ff ff    	cmp    %ecx,0xfffffc5c(%ebp)
   12577:	0f 94 c0             	sete   %al
   1257a:	25 ff 00 00 00       	and    $0xff,%eax
   1257f:	85 c2                	test   %eax,%edx
   12581:	0f 85 d6 01 00 00    	jne    1275d <_ScsiPortInitialize@16+0xadd>
   12587:	8b 85 58 fc ff ff    	mov    0xfffffc58(%ebp),%eax
   1258d:	85 c0                	test   %eax,%eax
   1258f:	0f 85 5b fd ff ff    	jne    122f0 <_ScsiPortInitialize@16+0x670>
   12595:	83 ec 0c             	sub    $0xc,%esp
   12598:	8b 85 68 fc ff ff    	mov    0xfffffc68(%ebp),%eax
   1259e:	50                   	push   %eax
   1259f:	e8 1c 1a 00 00       	call   13fc0 <_ExFreePool@4>
   125a4:	83 c4 0c             	add    $0xc,%esp
}


static PSCSI_REQUEST_BLOCK
ScsiPortInitSenseRequestSrb(PSCSI_REQUEST_BLOCK OriginalSrb)
{
  PSCSI_REQUEST_BLOCK Srb;
  ULONG Length;
  PCDB Cdb;

  Length = sizeof(SCSI_REQUEST_BLOCK) + sizeof(SENSE_DATA) + 32;
  Srb = ExAllocatePoolWithTag(NonPagedPool, 
                              Length,
		              TAG('S', 'S', 'r', 'b'));
  if (Srb == NULL)
    {
      return NULL;
    }

  RtlZeroMemory(Srb, Length);

  Srb->PathId = OriginalSrb->PathId;
  Srb->TargetId = OriginalSrb->TargetId;
  Srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
  Srb->Length = sizeof(SCSI_REQUEST_BLOCK);
  Srb->SrbFlags = SRB_FLAGS_DATA_IN | SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
  Srb->OriginalRequest = OriginalSrb->OriginalRequest;

  Srb->TimeOutValue = 4;

  Srb->CdbLength = 6;
  /* The DataBuffer must be located in contiguous physical memory if 
   * the miniport driver uses dma for the sense info. The size of 
   * the sense data is 18 byte. If the buffer starts at a 32 byte 
   * boundary than is the buffer always in one memory page. 
   */
  Srb->DataBuffer = (PVOID)ROUND_UP((ULONG_PTR)(Srb + 1), 32);
  Srb->DataTransferLength = sizeof(SENSE_DATA);

  Cdb = (PCDB)Srb->Cdb;
  Cdb->CDB6INQUIRY.OperationCode = SCSIOP_REQUEST_SENSE;
  Cdb->CDB6INQUIRY.AllocationLength = sizeof(SENSE_DATA);

  return(Srb);
}

/**********************************************************************
 * NAME							INTERNAL
 *	SpiBuildDeviceMap
 *
 * DESCRIPTION
 *	Builds the registry device map of all device which are attached
 *	to the given SCSI HBA port. The device map is located at:
 *	  \Registry\Machine\DeviceMap\Scsi
 *
 * RUN LEVEL
 *	PASSIVE_LEVEL
 *
 * ARGUMENTS
 *	DeviceExtension
 *		...
 *
 *	RegistryPath
 *		Name of registry driver service key.
 *
 * RETURNS
 *	NTSTATUS
 */

static NTSTATUS
SpiBuildDeviceMap (PSCSI_PORT_DEVICE_EXTENSION DeviceExtension,
		   PUNICODE_STRING RegistryPath)
{
  PSCSI_PORT_LUN_EXTENSION LunExtension;
  OBJECT_ATTRIBUTES ObjectAttributes;
  UNICODE_STRING KeyName;
  UNICODE_STRING ValueName;
  WCHAR NameBuffer[64];
  ULONG Disposition;
  HANDLE ScsiKey;
  HANDLE ScsiPortKey = NULL;
  HANDLE ScsiBusKey = NULL;
  HANDLE ScsiInitiatorKey = NULL;
  HANDLE ScsiTargetKey = NULL;
  HANDLE ScsiLunKey = NULL;
  ULONG BusNumber;
  ULONG Target;
  ULONG CurrentTarget;
  ULONG Lun;
  PWCHAR DriverName;
  ULONG UlongData;
  PWCHAR TypeName;
  NTSTATUS Status;

  DPRINT("SpiBuildDeviceMap() called\n");

  if (DeviceExtension == NULL || RegistryPath == NULL)
   125a7:	8b bd 94 fc ff ff    	mov    0xfffffc94(%ebp),%edi
   125ad:	8b 75 0c             	mov    0xc(%ebp),%esi
   125b0:	85 ff                	test   %edi,%edi
   125b2:	c7 85 c4 fc ff ff 00 	movl   $0x0,0xfffffcc4(%ebp)
   125b9:	00 00 00 
   125bc:	0f 94 c2             	sete   %dl
   125bf:	85 f6                	test   %esi,%esi
   125c1:	c7 85 b0 fc ff ff 00 	movl   $0x0,0xfffffcb0(%ebp)
   125c8:	00 00 00 
   125cb:	0f 94 c0             	sete   %al
   125ce:	09 d0                	or     %edx,%eax
   125d0:	c7 85 ac fc ff ff 00 	movl   $0x0,0xfffffcac(%ebp)
   125d7:	00 00 00 
   125da:	c7 85 a8 fc ff ff 00 	movl   $0x0,0xfffffca8(%ebp)
   125e1:	00 00 00 
   125e4:	c7 85 a4 fc ff ff 00 	movl   $0x0,0xfffffca4(%ebp)
   125eb:	00 00 00 
   125ee:	a8 01                	test   $0x1,%al
   125f0:	0f 84 cb 01 00 00    	je     127c1 <_ScsiPortInitialize@16+0xb41>
    {
      DPRINT1("Invalid parameter\n");
   125f6:	53                   	push   %ebx
   125f7:	68 3b 09 00 00       	push   $0x93b
   125fc:	68 11 50 01 00       	push   $0x15011
   12601:	68 54 50 01 00       	push   $0x15054
   12606:	e8 85 1c 00 00       	call   14290 <_DbgPrint>
   1260b:	c7 04 24 e9 51 01 00 	movl   $0x151e9,(%esp)
   12612:	e8 79 1c 00 00       	call   14290 <_DbgPrint>
   12617:	83 c4 10             	add    $0x10,%esp
   1261a:	8b 9d 90 fc ff ff    	mov    0xfffffc90(%ebp),%ebx
   12620:	50                   	push   %eax
   12621:	8b 7b 10             	mov    0x10(%ebx),%edi
   12624:	8d 9d a8 fe ff ff    	lea    0xfffffea8(%ebp),%ebx
   1262a:	57                   	push   %edi
   1262b:	68 fc 51 01 00       	push   $0x151fc
   12630:	53                   	push   %ebx
   12631:	e8 4a 1c 00 00       	call   14280 <_swprintf>
   12636:	59                   	pop    %ecx
   12637:	5e                   	pop    %esi
   12638:	53                   	push   %ebx
   12639:	8d 9d 98 fc ff ff    	lea    0xfffffc98(%ebp),%ebx
   1263f:	53                   	push   %ebx
   12640:	e8 4b 1a 00 00       	call   14090 <_RtlInitUnicodeString@8>
   12645:	8d 85 00 fd ff ff    	lea    0xfffffd00(%ebp),%eax
   1264b:	50                   	push   %eax
   1264c:	53                   	push   %ebx
   1264d:	e8 ce 1a 00 00       	call   14120 <_IoCreateSymbolicLink@8>
   12652:	58                   	pop    %eax
   12653:	5a                   	pop    %edx
   12654:	8b 95 8c fc ff ff    	mov    0xfffffc8c(%ebp),%edx
   1265a:	80 7a 4d 01          	cmpb   $0x1,0x4d(%edx)
   1265e:	0f 84 2e 09 00 00    	je     12f92 <_ScsiPortInitialize@16+0x1312>
   12664:	8b 9d 8c fc ff ff    	mov    0xfffffc8c(%ebp),%ebx
   1266a:	80 7b 4e 01          	cmpb   $0x1,0x4e(%ebx)
   1266e:	0f 84 2d 09 00 00    	je     12fa1 <_ScsiPortInitialize@16+0x1321>
   12674:	8b 95 90 fc ff ff    	mov    0xfffffc90(%ebp),%edx
   1267a:	c7 85 fc fc ff ff 00 	movl   $0x0,0xfffffcfc(%ebp)
   12681:	00 00 00 
   12684:	c6 85 83 fc ff ff 01 	movb   $0x1,0xfffffc83(%ebp)
   1268b:	8b 7a 10             	mov    0x10(%edx),%edi
   1268e:	47                   	inc    %edi
   1268f:	89 7a 10             	mov    %edi,0x10(%edx)
   12692:	8b 8d 7c fc ff ff    	mov    0xfffffc7c(%ebp),%ecx
   12698:	39 8d 78 fc ff ff    	cmp    %ecx,0xfffffc78(%ebp)
   1269e:	0f 83 85 0a 00 00    	jae    13129 <_ScsiPortInitialize@16+0x14a9>
   126a4:	80 bd e3 fc ff ff 00 	cmpb   $0x0,0xfffffce3(%ebp)
   126ab:	0f 85 a3 f6 ff ff    	jne    11d54 <_ScsiPortInitialize@16+0xd4>
   126b1:	8b 8d 78 fc ff ff    	mov    0xfffffc78(%ebp),%ecx
   126b7:	41                   	inc    %ecx
   126b8:	89 8d 78 fc ff ff    	mov    %ecx,0xfffffc78(%ebp)
   126be:	e9 87 f6 ff ff       	jmp    11d4a <_ScsiPortInitialize@16+0xca>
   126c3:	83 7e 3c 03          	cmpl   $0x3,0x3c(%esi)
   126c7:	0f 86 b0 fc ff ff    	jbe    1237d <_ScsiPortInitialize@16+0x6fd>
   126cd:	8d 76 00             	lea    0x0(%esi),%esi
   126d0:	8b 4e 44             	mov    0x44(%esi),%ecx
   126d3:	f6 01 e0             	testb  $0xe0,(%ecx)
   126d6:	0f 85 a1 fc ff ff    	jne    1237d <_ScsiPortInitialize@16+0x6fd>
   126dc:	8b 56 3c             	mov    0x3c(%esi),%edx
   126df:	8b 46 1c             	mov    0x1c(%esi),%eax
   126e2:	83 fa 60             	cmp    $0x60,%edx
   126e5:	76 05                	jbe    126ec <_ScsiPortInitialize@16+0xa6c>
   126e7:	ba 60 00 00 00       	mov    $0x60,%edx
   126ec:	83 c0 10             	add    $0x10,%eax
   126ef:	53                   	push   %ebx
   126f0:	52                   	push   %edx
   126f1:	51                   	push   %ecx
   126f2:	50                   	push   %eax
   126f3:	e8 48 1b 00 00       	call   14240 <_memcpy>
   126f8:	8b 46 20             	mov    0x20(%esi),%eax
   126fb:	40                   	inc    %eax
   126fc:	83 c4 10             	add    $0x10,%esp
   126ff:	89 46 20             	mov    %eax,0x20(%esi)
   12702:	e9 9a fc ff ff       	jmp    123a1 <_ScsiPortInitialize@16+0x721>
   12707:	83 ec 0c             	sub    $0xc,%esp
   1270a:	56                   	push   %esi
   1270b:	e8 20 1a 00 00       	call   14130 <_KeReadStateEvent@4>
   12710:	83 c4 0c             	add    $0xc,%esp
   12713:	85 c0                	test   %eax,%eax
   12715:	0f 85 3b fc ff ff    	jne    12356 <_ScsiPortInitialize@16+0x6d6>
   1271b:	8b bd 58 fc ff ff    	mov    0xfffffc58(%ebp),%edi
   12721:	47                   	inc    %edi
   12722:	89 bd 58 fc ff ff    	mov    %edi,0xfffffc58(%ebp)
   12728:	e9 f7 fb ff ff       	jmp    12324 <_ScsiPortInitialize@16+0x6a4>
   1272d:	50                   	push   %eax
   1272e:	68 2e 08 00 00       	push   $0x82e
   12733:	68 11 50 01 00       	push   $0x15011
   12738:	68 54 50 01 00       	push   $0x15054
   1273d:	e8 4e 1b 00 00       	call   14290 <_DbgPrint>
   12742:	c7 04 24 18 52 01 00 	movl   $0x15218,(%esp)
   12749:	e8 42 1b 00 00       	call   14290 <_DbgPrint>
   1274e:	83 c4 10             	add    $0x10,%esp
   12751:	c7 46 20 08 00 00 00 	movl   $0x8,0x20(%esi)
   12758:	e9 c7 fb ff ff       	jmp    12324 <_ScsiPortInitialize@16+0x6a4>
   1275d:	8b 85 50 fc ff ff    	mov    0xfffffc50(%ebp),%eax
   12763:	50                   	push   %eax
   12764:	8b 85 54 fc ff ff    	mov    0xfffffc54(%ebp),%eax
   1276a:	6a 00                	push   $0x0
   1276c:	6a 00                	push   $0x0
   1276e:	6a 00                	push   $0x0
   12770:	6a 00                	push   $0x0
   12772:	6a 01                	push   $0x1
   12774:	50                   	push   %eax
   12775:	8b 85 5c fc ff ff    	mov    0xfffffc5c(%ebp),%eax
   1277b:	50                   	push   %eax
   1277c:	e8 bf 19 00 00       	call   14140 <_KeWaitForMultipleObjects@32>
   12781:	e9 01 fe ff ff       	jmp    12587 <_ScsiPortInitialize@16+0x907>
   12786:	83 ec 0c             	sub    $0xc,%esp
   12789:	8b b5 8c fc ff ff    	mov    0xfffffc8c(%ebp),%esi
   1278f:	56                   	push   %esi
   12790:	e8 2b 18 00 00       	call   13fc0 <_ExFreePool@4>
   12795:	8b 9d fc fc ff ff    	mov    0xfffffcfc(%ebp),%ebx
   1279b:	53                   	push   %ebx
   1279c:	e8 af 19 00 00       	call   14150 <_IoDeleteDevice@4>
   127a1:	83 c4 0c             	add    $0xc,%esp
   127a4:	c7 85 fc fc ff ff 00 	movl   $0x0,0xfffffcfc(%ebp)
   127ab:	00 00 00 
   127ae:	e9 df fe ff ff       	jmp    12692 <_ScsiPortInitialize@16+0xa12>
   127b3:	8b 8d 8c fc ff ff    	mov    0xfffffc8c(%ebp),%ecx
   127b9:	8b 41 18             	mov    0x18(%ecx),%eax
   127bc:	e9 29 fa ff ff       	jmp    121ea <_ScsiPortInitialize@16+0x56a>
      return(STATUS_INVALID_PARAMETER);
    }

  /* Open or create the 'Scsi' subkey */
  RtlRosInitUnicodeStringFromLiteral(&KeyName,
				  L"\\Registry\\Machine\\Hardware\\DeviceMap\\Scsi");
  InitializeObjectAttributes(&ObjectAttributes,
			     &KeyName,
			     OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
			     0,
			     NULL);
  Status = ZwCreateKey(&ScsiKey,
   127c1:	8d 85 cc fc ff ff    	lea    0xfffffccc(%ebp),%eax
   127c7:	8d 95 88 fd ff ff    	lea    0xfffffd88(%ebp),%edx
   127cd:	8d 9d d0 fc ff ff    	lea    0xfffffcd0(%ebp),%ebx
   127d3:	51                   	push   %ecx
   127d4:	50                   	push   %eax
   127d5:	8d 85 c8 fc ff ff    	lea    0xfffffcc8(%ebp),%eax
   127db:	6a 01                	push   $0x1
   127dd:	66 c7 85 d0 fc ff ff 	movw   $0x52,0xfffffcd0(%ebp)
   127e4:	52 00 
   127e6:	6a 00                	push   $0x0
   127e8:	66 c7 85 d2 fc ff ff 	movw   $0x54,0xfffffcd2(%ebp)
   127ef:	54 00 
   127f1:	6a 00                	push   $0x0
   127f3:	c7 85 d4 fc ff ff 40 	movl   $0x15240,0xfffffcd4(%ebp)
   127fa:	52 01 00 
   127fd:	52                   	push   %edx
   127fe:	c7 85 88 fd ff ff 18 	movl   $0x18,0xfffffd88(%ebp)
   12805:	00 00 00 
   12808:	68 3f 00 0f 00       	push   $0xf003f
   1280d:	89 9d 90 fd ff ff    	mov    %ebx,0xfffffd90(%ebp)
   12813:	c7 85 94 fd ff ff c0 	movl   $0xc0,0xfffffd94(%ebp)
   1281a:	00 00 00 
   1281d:	c7 85 8c fd ff ff 00 	movl   $0x0,0xfffffd8c(%ebp)
   12824:	00 00 00 
   12827:	c7 85 98 fd ff ff 00 	movl   $0x0,0xfffffd98(%ebp)
   1282e:	00 00 00 
   12831:	c7 85 9c fd ff ff 00 	movl   $0x0,0xfffffd9c(%ebp)
   12838:	00 00 00 
   1283b:	50                   	push   %eax
   1283c:	e8 1f 19 00 00       	call   14160 <_ZwCreateKey@28>
   12841:	5a                   	pop    %edx
		       KEY_ALL_ACCESS,
		       &ObjectAttributes,
		       0,
		       NULL,
		       REG_OPTION_VOLATILE,
		       &Disposition);
  if (!NT_SUCCESS(Status))
   12842:	85 c0                	test   %eax,%eax
   12844:	0f 88 d0 fd ff ff    	js     1261a <_ScsiPortInitialize@16+0x99a>
    {
      DPRINT("ZwCreateKey() failed (Status %lx)\n", Status);
      return(Status);
    }

  /* Create new 'Scsi Port X' subkey */
  DPRINT("Scsi Port %lu\n",
	 DeviceExtension->PortNumber);

  swprintf(NameBuffer,
   1284a:	8b 8d 94 fc ff ff    	mov    0xfffffc94(%ebp),%ecx
   12850:	50                   	push   %eax
   12851:	8d 9d 08 fd ff ff    	lea    0xfffffd08(%ebp),%ebx
   12857:	8b 79 0c             	mov    0xc(%ecx),%edi
   1285a:	57                   	push   %edi
   1285b:	68 94 52 01 00       	push   $0x15294
   12860:	53                   	push   %ebx
   12861:	e8 1a 1a 00 00       	call   14280 <_swprintf>
	   L"Scsi Port %lu",
	   DeviceExtension->PortNumber);
  RtlInitUnicodeString(&KeyName,
   12866:	8d 95 d0 fc ff ff    	lea    0xfffffcd0(%ebp),%edx
   1286c:	59                   	pop    %ecx
   1286d:	5e                   	pop    %esi
   1286e:	53                   	push   %ebx
   1286f:	52                   	push   %edx
   12870:	e8 1b 18 00 00       	call   14090 <_RtlInitUnicodeString@8>
		       NameBuffer);
  InitializeObjectAttributes(&ObjectAttributes,
   12875:	8b 85 c8 fc ff ff    	mov    0xfffffcc8(%ebp),%eax
   1287b:	89 85 8c fd ff ff    	mov    %eax,0xfffffd8c(%ebp)
			     &KeyName,
			     0,
			     ScsiKey,
			     NULL);
  Status = ZwCreateKey(&ScsiPortKey,
   12881:	8d 9d cc fc ff ff    	lea    0xfffffccc(%ebp),%ebx
   12887:	8d 85 88 fd ff ff    	lea    0xfffffd88(%ebp),%eax
   1288d:	89 1c 24             	mov    %ebx,(%esp)
   12890:	8d 8d d0 fc ff ff    	lea    0xfffffcd0(%ebp),%ecx
   12896:	6a 01                	push   $0x1
   12898:	6a 00                	push   $0x0
   1289a:	6a 00                	push   $0x0
   1289c:	50                   	push   %eax
   1289d:	8d 85 c4 fc ff ff    	lea    0xfffffcc4(%ebp),%eax
   128a3:	89 8d 90 fd ff ff    	mov    %ecx,0xfffffd90(%ebp)
   128a9:	68 3f 00 0f 00       	push   $0xf003f
   128ae:	c7 85 88 fd ff ff 18 	movl   $0x18,0xfffffd88(%ebp)
   128b5:	00 00 00 
   128b8:	c7 85 94 fd ff ff 00 	movl   $0x0,0xfffffd94(%ebp)
   128bf:	00 00 00 
   128c2:	c7 85 98 fd ff ff 00 	movl   $0x0,0xfffffd98(%ebp)
   128c9:	00 00 00 
   128cc:	c7 85 9c fd ff ff 00 	movl   $0x0,0xfffffd9c(%ebp)
   128d3:	00 00 00 
   128d6:	50                   	push   %eax
   128d7:	e8 84 18 00 00       	call   14160 <_ZwCreateKey@28>
		       KEY_ALL_ACCESS,
		       &ObjectAttributes,
		       0,
		       NULL,
		       REG_OPTION_VOLATILE,
		       &Disposition);
  ZwClose(ScsiKey);
   128dc:	8b bd c8 fc ff ff    	mov    0xfffffcc8(%ebp),%edi
   128e2:	89 c6                	mov    %eax,%esi
   128e4:	52                   	push   %edx
   128e5:	52                   	push   %edx
   128e6:	57                   	push   %edi
   128e7:	e8 84 18 00 00       	call   14170 <_ZwClose@4>
   128ec:	83 c4 0c             	add    $0xc,%esp
  if (!NT_SUCCESS(Status))
   128ef:	85 f6                	test   %esi,%esi
   128f1:	0f 88 23 fd ff ff    	js     1261a <_ScsiPortInitialize@16+0x99a>
    {
      DPRINT("ZwCreateKey() failed (Status %lx)\n", Status);
      return(Status);
    }

  /*
   * Create port-specific values
   */

  /* Set 'DMA Enabled' (REG_DWORD) value */
  UlongData = (ULONG)!DeviceExtension->PortCapabilities->AdapterUsesPio;
   128f7:	8b 95 94 fc ff ff    	mov    0xfffffc94(%ebp),%edx
  DPRINT("  DMA Enabled = %s\n", (UlongData) ? "TRUE" : "FALSE");
  RtlInitUnicodeString(&ValueName,
		       L"DMA Enabled");
  Status = ZwSetValueKey(ScsiPortKey,
   128fd:	8d bd b4 fc ff ff    	lea    0xfffffcb4(%ebp),%edi
   12903:	8b 42 3c             	mov    0x3c(%edx),%eax
   12906:	80 78 16 00          	cmpb   $0x0,0x16(%eax)
   1290a:	0f 94 c0             	sete   %al
   1290d:	53                   	push   %ebx
   1290e:	25 ff 00 00 00       	and    $0xff,%eax
   12913:	53                   	push   %ebx
   12914:	8d 9d b8 fc ff ff    	lea    0xfffffcb8(%ebp),%ebx
   1291a:	89 85 b4 fc ff ff    	mov    %eax,0xfffffcb4(%ebp)
   12920:	68 b0 52 01 00       	push   $0x152b0
   12925:	53                   	push   %ebx
   12926:	e8 65 17 00 00       	call   14090 <_RtlInitUnicodeString@8>
   1292b:	8b 8d c4 fc ff ff    	mov    0xfffffcc4(%ebp),%ecx
   12931:	6a 04                	push   $0x4
   12933:	57                   	push   %edi
   12934:	6a 04                	push   $0x4
   12936:	6a 00                	push   $0x0
   12938:	53                   	push   %ebx
   12939:	51                   	push   %ecx
   1293a:	e8 41 18 00 00       	call   14180 <_ZwSetValueKey@24>
   1293f:	5e                   	pop    %esi
			 &ValueName,
			 0,
			 REG_DWORD,
			 &UlongData,
			 sizeof(ULONG));
  if (!NT_SUCCESS(Status))
   12940:	85 c0                	test   %eax,%eax
   12942:	5a                   	pop    %edx
   12943:	0f 88 a6 06 00 00    	js     12fef <_ScsiPortInitialize@16+0x136f>
    {
      DPRINT("ZwSetValueKey('DMA Enabled') failed (Status %lx)\n", Status);
      ZwClose(ScsiPortKey);
      return(Status);
    }

  /* Set 'Driver' (REG_SZ) value */
  DriverName = wcsrchr(RegistryPath->Buffer, L'\\') + 1;
   12949:	53                   	push   %ebx
   1294a:	53                   	push   %ebx
   1294b:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   1294e:	6a 5c                	push   $0x5c
   12950:	8b 4b 04             	mov    0x4(%ebx),%ecx
   12953:	51                   	push   %ecx
   12954:	e8 07 19 00 00       	call   14260 <_wcsrchr>
   12959:	5e                   	pop    %esi
   1295a:	5a                   	pop    %edx
   1295b:	8d 70 02             	lea    0x2(%eax),%esi
  RtlInitUnicodeString(&ValueName,
   1295e:	8d 85 b8 fc ff ff    	lea    0xfffffcb8(%ebp),%eax
   12964:	68 c8 52 01 00       	push   $0x152c8
   12969:	50                   	push   %eax
   1296a:	e8 21 17 00 00       	call   14090 <_RtlInitUnicodeString@8>
   1296f:	53                   	push   %ebx
		       L"Driver");
  Status = ZwSetValueKey(ScsiPortKey,
   12970:	56                   	push   %esi
   12971:	e8 da 18 00 00       	call   14250 <_wcslen>
   12976:	5a                   	pop    %edx
   12977:	8b 9d c4 fc ff ff    	mov    0xfffffcc4(%ebp),%ebx
   1297d:	59                   	pop    %ecx
   1297e:	8d 95 b8 fc ff ff    	lea    0xfffffcb8(%ebp),%edx
   12984:	8d 44 00 02          	lea    0x2(%eax,%eax,1),%eax
   12988:	50                   	push   %eax
   12989:	56                   	push   %esi
   1298a:	6a 01                	push   $0x1
   1298c:	6a 00                	push   $0x0
   1298e:	52                   	push   %edx
   1298f:	53                   	push   %ebx
   12990:	e8 eb 17 00 00       	call   14180 <_ZwSetValueKey@24>
   12995:	5a                   	pop    %edx
			 &ValueName,
			 0,
			 REG_SZ,
			 DriverName,
			 (wcslen(DriverName) + 1) * sizeof(WCHAR));
  if (!NT_SUCCESS(Status))
   12996:	85 c0                	test   %eax,%eax
   12998:	59                   	pop    %ecx
   12999:	0f 88 50 06 00 00    	js     12fef <_ScsiPortInitialize@16+0x136f>
    {
      DPRINT("ZwSetValueKey('Driver') failed (Status %lx)\n", Status);
      ZwClose(ScsiPortKey);
      return(Status);
    }

  /* Set 'Interrupt' (REG_DWORD) value (NT4 only) */
  UlongData = (ULONG)DeviceExtension->PortConfig->BusInterruptLevel;
   1299f:	8b 8d 94 fc ff ff    	mov    0xfffffc94(%ebp),%ecx
  DPRINT("  Interrupt = %lu\n", UlongData);
  RtlInitUnicodeString(&ValueName,
   129a5:	8d 9d b8 fc ff ff    	lea    0xfffffcb8(%ebp),%ebx
   129ab:	8b 41 08             	mov    0x8(%ecx),%eax
   129ae:	8b 40 0c             	mov    0xc(%eax),%eax
   129b1:	89 85 b4 fc ff ff    	mov    %eax,0xfffffcb4(%ebp)
   129b7:	50                   	push   %eax
   129b8:	50                   	push   %eax
   129b9:	68 d6 52 01 00       	push   $0x152d6
   129be:	53                   	push   %ebx
   129bf:	e8 cc 16 00 00       	call   14090 <_RtlInitUnicodeString@8>
		       L"Interrupt");
  Status = ZwSetValueKey(ScsiPortKey,
   129c4:	8b b5 c4 fc ff ff    	mov    0xfffffcc4(%ebp),%esi
   129ca:	6a 04                	push   $0x4
   129cc:	57                   	push   %edi
   129cd:	6a 04                	push   $0x4
   129cf:	6a 00                	push   $0x0
   129d1:	53                   	push   %ebx
   129d2:	56                   	push   %esi
   129d3:	e8 a8 17 00 00       	call   14180 <_ZwSetValueKey@24>
   129d8:	59                   	pop    %ecx
			 &ValueName,
			 0,
			 REG_DWORD,
			 &UlongData,
			 sizeof(ULONG));
  if (!NT_SUCCESS(Status))
   129d9:	85 c0                	test   %eax,%eax
   129db:	5b                   	pop    %ebx
   129dc:	0f 88 0d 06 00 00    	js     12fef <_ScsiPortInitialize@16+0x136f>
    {
      DPRINT("ZwSetValueKey('Interrupt') failed (Status %lx)\n", Status);
      ZwClose(ScsiPortKey);
      return(Status);
    }

  /* Set 'IOAddress' (REG_DWORD) value (NT4 only) */
  UlongData = ScsiPortConvertPhysicalAddressToUlong(DeviceExtension->PortConfig->AccessRanges[0].RangeStart);
   129e2:	8b 95 94 fc ff ff    	mov    0xfffffc94(%ebp),%edx
  DPRINT("  IOAddress = %lx\n", UlongData);
  RtlInitUnicodeString(&ValueName,
		       L"IOAddress");
  Status = ZwSetValueKey(ScsiPortKey,
   129e8:	8d 9d b8 fc ff ff    	lea    0xfffffcb8(%ebp),%ebx
   129ee:	8b 42 08             	mov    0x8(%edx),%eax
   129f1:	8b 40 38             	mov    0x38(%eax),%eax
   129f4:	8b 50 04             	mov    0x4(%eax),%edx
   129f7:	52                   	push   %edx
   129f8:	8b 00                	mov    (%eax),%eax
   129fa:	50                   	push   %eax
   129fb:	e8 60 e6 ff ff       	call   11060 <_ScsiPortConvertPhysicalAddressToUlong@8>
   12a00:	8d 8d b8 fc ff ff    	lea    0xfffffcb8(%ebp),%ecx
   12a06:	56                   	push   %esi
   12a07:	89 85 b4 fc ff ff    	mov    %eax,0xfffffcb4(%ebp)
   12a0d:	56                   	push   %esi
   12a0e:	68 ea 52 01 00       	push   $0x152ea
   12a13:	51                   	push   %ecx
   12a14:	e8 77 16 00 00       	call   14090 <_RtlInitUnicodeString@8>
   12a19:	6a 04                	push   $0x4
   12a1b:	57                   	push   %edi
   12a1c:	6a 04                	push   $0x4
   12a1e:	6a 00                	push   $0x0
   12a20:	53                   	push   %ebx
   12a21:	8b 9d c4 fc ff ff    	mov    0xfffffcc4(%ebp),%ebx
   12a27:	53                   	push   %ebx
   12a28:	e8 53 17 00 00       	call   14180 <_ZwSetValueKey@24>
   12a2d:	5a                   	pop    %edx
			 &ValueName,
			 0,
			 REG_DWORD,
			 &UlongData,
			 sizeof(ULONG));
  if (!NT_SUCCESS(Status))
   12a2e:	85 c0                	test   %eax,%eax
   12a30:	59                   	pop    %ecx
   12a31:	0f 88 b8 05 00 00    	js     12fef <_ScsiPortInitialize@16+0x136f>
    {
      DPRINT("ZwSetValueKey('IOAddress') failed (Status %lx)\n", Status);
      ZwClose(ScsiPortKey);
      return(Status);
    }

  /* Enumerate buses */
  for (BusNumber = 0; BusNumber < DeviceExtension->PortConfig->NumberOfBuses; BusNumber++)
   12a37:	8b 95 94 fc ff ff    	mov    0xfffffc94(%ebp),%edx
   12a3d:	c7 85 40 fc ff ff 00 	movl   $0x0,0xfffffc40(%ebp)
   12a44:	00 00 00 
   12a47:	8b 42 08             	mov    0x8(%edx),%eax
   12a4a:	80 78 40 00          	cmpb   $0x0,0x40(%eax)
   12a4e:	0f 84 8d 04 00 00    	je     12ee1 <_ScsiPortInitialize@16+0x1261>
    {
      /* Create 'Scsi Bus X' key */
      DPRINT("    Scsi Bus %lu\n", BusNumber);
      swprintf(NameBuffer,
   12a54:	8d 8d 08 fd ff ff    	lea    0xfffffd08(%ebp),%ecx
   12a5a:	8b b5 40 fc ff ff    	mov    0xfffffc40(%ebp),%esi
   12a60:	57                   	push   %edi
   12a61:	56                   	push   %esi
   12a62:	68 fe 52 01 00       	push   $0x152fe
   12a67:	51                   	push   %ecx
   12a68:	e8 13 18 00 00       	call   14280 <_swprintf>
   12a6d:	59                   	pop    %ecx
	       L"Scsi Bus %lu",
	       BusNumber);
      RtlInitUnicodeString(&KeyName,
   12a6e:	8d 85 d0 fc ff ff    	lea    0xfffffcd0(%ebp),%eax
   12a74:	5b                   	pop    %ebx
   12a75:	8d 9d 08 fd ff ff    	lea    0xfffffd08(%ebp),%ebx
   12a7b:	53                   	push   %ebx
   12a7c:	50                   	push   %eax
   12a7d:	e8 0e 16 00 00       	call   14090 <_RtlInitUnicodeString@8>
			   NameBuffer);
      InitializeObjectAttributes(&ObjectAttributes,
   12a82:	8b 85 c4 fc ff ff    	mov    0xfffffcc4(%ebp),%eax
   12a88:	8d 95 d0 fc ff ff    	lea    0xfffffcd0(%ebp),%edx
   12a8e:	89 85 8c fd ff ff    	mov    %eax,0xfffffd8c(%ebp)
				 &KeyName,
				 0,
				 ScsiPortKey,
				 NULL);
      Status = ZwCreateKey(&ScsiBusKey,
   12a94:	8d 8d cc fc ff ff    	lea    0xfffffccc(%ebp),%ecx
   12a9a:	8d 85 b0 fc ff ff    	lea    0xfffffcb0(%ebp),%eax
   12aa0:	8d 9d 88 fd ff ff    	lea    0xfffffd88(%ebp),%ebx
   12aa6:	89 0c 24             	mov    %ecx,(%esp)
   12aa9:	89 95 90 fd ff ff    	mov    %edx,0xfffffd90(%ebp)
   12aaf:	6a 01                	push   $0x1
   12ab1:	c7 85 88 fd ff ff 18 	movl   $0x18,0xfffffd88(%ebp)
   12ab8:	00 00 00 
   12abb:	6a 00                	push   $0x0
   12abd:	c7 85 94 fd ff ff 00 	movl   $0x0,0xfffffd94(%ebp)
   12ac4:	00 00 00 
   12ac7:	6a 00                	push   $0x0
   12ac9:	c7 85 98 fd ff ff 00 	movl   $0x0,0xfffffd98(%ebp)
   12ad0:	00 00 00 
   12ad3:	53                   	push   %ebx
   12ad4:	c7 85 9c fd ff ff 00 	movl   $0x0,0xfffffd9c(%ebp)
   12adb:	00 00 00 
   12ade:	68 3f 00 0f 00       	push   $0xf003f
   12ae3:	50                   	push   %eax
   12ae4:	e8 77 16 00 00       	call   14160 <_ZwCreateKey@28>
   12ae9:	5a                   	pop    %edx
			   KEY_ALL_ACCESS,
			   &ObjectAttributes,
			   0,
			   NULL,
			   REG_OPTION_VOLATILE,
			   &Disposition);
      if (!NT_SUCCESS(Status))
   12aea:	85 c0                	test   %eax,%eax
   12aec:	0f 88 ef 03 00 00    	js     12ee1 <_ScsiPortInitialize@16+0x1261>
	{
	  DPRINT("ZwCreateKey() failed (Status %lx)\n", Status);
	  goto ByeBye;
	}

      /* Create 'Initiator Id X' key */
      DPRINT("      Initiator Id %u\n",
	      DeviceExtension->PortConfig->InitiatorBusId[BusNumber]);
      swprintf(NameBuffer,
   12af2:	8b 95 94 fc ff ff    	mov    0xfffffc94(%ebp),%edx
   12af8:	50                   	push   %eax
   12af9:	8b 8d 40 fc ff ff    	mov    0xfffffc40(%ebp),%ecx
   12aff:	8b 42 08             	mov    0x8(%edx),%eax
   12b02:	8d 9d 08 fd ff ff    	lea    0xfffffd08(%ebp),%ebx
   12b08:	8a 44 08 41          	mov    0x41(%eax,%ecx,1),%al
   12b0c:	25 ff 00 00 00       	and    $0xff,%eax
   12b11:	50                   	push   %eax
   12b12:	68 18 53 01 00       	push   $0x15318
   12b17:	53                   	push   %ebx
   12b18:	e8 63 17 00 00       	call   14280 <_swprintf>
	       L"Initiator Id %u",
	       (unsigned int)(UCHAR)DeviceExtension->PortConfig->InitiatorBusId[BusNumber]);
      RtlInitUnicodeString(&KeyName,
   12b1d:	8d 95 d0 fc ff ff    	lea    0xfffffcd0(%ebp),%edx
   12b23:	5f                   	pop    %edi
   12b24:	58                   	pop    %eax
   12b25:	53                   	push   %ebx
   12b26:	52                   	push   %edx
   12b27:	e8 64 15 00 00       	call   14090 <_RtlInitUnicodeString@8>
			   NameBuffer);
      InitializeObjectAttributes(&ObjectAttributes,
   12b2c:	8b 85 b0 fc ff ff    	mov    0xfffffcb0(%ebp),%eax
   12b32:	89 85 8c fd ff ff    	mov    %eax,0xfffffd8c(%ebp)
				 &KeyName,
				 0,
				 ScsiBusKey,
				 NULL);
      Status = ZwCreateKey(&ScsiInitiatorKey,
   12b38:	8d 9d cc fc ff ff    	lea    0xfffffccc(%ebp),%ebx
   12b3e:	8d 85 88 fd ff ff    	lea    0xfffffd88(%ebp),%eax
   12b44:	89 1c 24             	mov    %ebx,(%esp)
   12b47:	8d 8d d0 fc ff ff    	lea    0xfffffcd0(%ebp),%ecx
   12b4d:	6a 01                	push   $0x1
   12b4f:	6a 00                	push   $0x0
   12b51:	6a 00                	push   $0x0
   12b53:	50                   	push   %eax
   12b54:	8d 85 ac fc ff ff    	lea    0xfffffcac(%ebp),%eax
   12b5a:	68 3f 00 0f 00       	push   $0xf003f
   12b5f:	c7 85 88 fd ff ff 18 	movl   $0x18,0xfffffd88(%ebp)
   12b66:	00 00 00 
   12b69:	89 8d 90 fd ff ff    	mov    %ecx,0xfffffd90(%ebp)
   12b6f:	c7 85 94 fd ff ff 00 	movl   $0x0,0xfffffd94(%ebp)
   12b76:	00 00 00 
   12b79:	c7 85 98 fd ff ff 00 	movl   $0x0,0xfffffd98(%ebp)
   12b80:	00 00 00 
   12b83:	c7 85 9c fd ff ff 00 	movl   $0x0,0xfffffd9c(%ebp)
   12b8a:	00 00 00 
   12b8d:	50                   	push   %eax
   12b8e:	e8 cd 15 00 00       	call   14160 <_ZwCreateKey@28>
   12b93:	5e                   	pop    %esi
			   KEY_ALL_ACCESS,
			   &ObjectAttributes,
			   0,
			   NULL,
			   REG_OPTION_VOLATILE,
			   &Disposition);
      if (!NT_SUCCESS(Status))
   12b94:	85 c0                	test   %eax,%eax
   12b96:	0f 88 45 03 00 00    	js     12ee1 <_ScsiPortInitialize@16+0x1261>
	{
	  DPRINT("ZwCreateKey() failed (Status %lx)\n", Status);
	  goto ByeBye;
	}

      /* FIXME: Are there any initiator values (??) */

      ZwClose(ScsiInitiatorKey);
   12b9c:	83 ec 0c             	sub    $0xc,%esp
   12b9f:	8b 9d ac fc ff ff    	mov    0xfffffcac(%ebp),%ebx
   12ba5:	53                   	push   %ebx
   12ba6:	e8 c5 15 00 00       	call   14170 <_ZwClose@4>
      ScsiInitiatorKey = NULL;


      /* Enumerate targets */
      CurrentTarget = (ULONG)-1;
      ScsiTargetKey = NULL;
      for (Target = 0; Target < DeviceExtension->PortConfig->MaximumNumberOfTargets; Target++)
   12bab:	8b 95 94 fc ff ff    	mov    0xfffffc94(%ebp),%edx
   12bb1:	c7 85 3c fc ff ff ff 	movl   $0xffffffff,0xfffffc3c(%ebp)
   12bb8:	ff ff ff 
   12bbb:	83 c4 0c             	add    $0xc,%esp
   12bbe:	31 db                	xor    %ebx,%ebx
   12bc0:	8b 42 08             	mov    0x8(%edx),%eax
   12bc3:	c7 85 ac fc ff ff 00 	movl   $0x0,0xfffffcac(%ebp)
   12bca:	00 00 00 
   12bcd:	c7 85 a8 fc ff ff 00 	movl   $0x0,0xfffffca8(%ebp)
   12bd4:	00 00 00 
   12bd7:	80 78 59 00          	cmpb   $0x0,0x59(%eax)
   12bdb:	0f 84 ba 02 00 00    	je     12e9b <_ScsiPortInitialize@16+0x121b>
	{
	  for (Lun = 0; Lun < SCSI_MAXIMUM_LOGICAL_UNITS; Lun++)
   12be1:	c7 85 38 fc ff ff 00 	movl   $0x0,0xfffffc38(%ebp)
   12be8:	00 00 00 
	    {
	      LunExtension = SpiGetLunExtension(DeviceExtension,
   12beb:	31 c0                	xor    %eax,%eax
   12bed:	31 d2                	xor    %edx,%edx
   12bef:	8a 85 38 fc ff ff    	mov    0xfffffc38(%ebp),%al
   12bf5:	8a 95 40 fc ff ff    	mov    0xfffffc40(%ebp),%dl
   12bfb:	50                   	push   %eax
   12bfc:	31 c0                	xor    %eax,%eax
   12bfe:	88 d8                	mov    %bl,%al
   12c00:	50                   	push   %eax
   12c01:	8b 85 94 fc ff ff    	mov    0xfffffc94(%ebp),%eax
   12c07:	e8 04 ec ff ff       	call   11810 <_SpiGetLunExtension>
   12c0c:	5a                   	pop    %edx
   12c0d:	89 c7                	mov    %eax,%edi
   12c0f:	59                   	pop    %ecx
						BusNumber,
						Target,
						Lun);
	      if (LunExtension != NULL)
   12c10:	85 c0                	test   %eax,%eax
   12c12:	0f 84 41 02 00 00    	je     12e59 <_ScsiPortInitialize@16+0x11d9>
		{
		  if (Target != CurrentTarget)
   12c18:	3b 9d 3c fc ff ff    	cmp    0xfffffc3c(%ebp),%ebx
   12c1e:	0f 84 ac 00 00 00    	je     12cd0 <_ScsiPortInitialize@16+0x1050>
		    {
		      /* Close old target key */
		      if (ScsiTargetKey != NULL)
   12c24:	8b 85 a8 fc ff ff    	mov    0xfffffca8(%ebp),%eax
   12c2a:	85 c0                	test   %eax,%eax
   12c2c:	0f 85 8c 03 00 00    	jne    12fbe <_ScsiPortInitialize@16+0x133e>
			{
			  ZwClose(ScsiTargetKey);
			  ScsiTargetKey = NULL;
			}

		      /* Create 'Target Id X' key */
		      DPRINT("      Target Id %lu\n", Target);
		      swprintf(NameBuffer,
   12c32:	8d 8d 08 fd ff ff    	lea    0xfffffd08(%ebp),%ecx
   12c38:	50                   	push   %eax
   12c39:	53                   	push   %ebx
   12c3a:	68 38 53 01 00       	push   $0x15338
   12c3f:	51                   	push   %ecx
   12c40:	e8 3b 16 00 00       	call   14280 <_swprintf>
   12c45:	59                   	pop    %ecx
			       L"Target Id %lu",
			       Target);
		      RtlInitUnicodeString(&KeyName,
   12c46:	8d 85 08 fd ff ff    	lea    0xfffffd08(%ebp),%eax
   12c4c:	5e                   	pop    %esi
   12c4d:	8d 95 d0 fc ff ff    	lea    0xfffffcd0(%ebp),%edx
   12c53:	50                   	push   %eax
   12c54:	52                   	push   %edx
   12c55:	e8 36 14 00 00       	call   14090 <_RtlInitUnicodeString@8>
					   NameBuffer);
		      InitializeObjectAttributes(&ObjectAttributes,
   12c5a:	8b 85 b0 fc ff ff    	mov    0xfffffcb0(%ebp),%eax
						 &KeyName,
						 0,
						 ScsiBusKey,
						 NULL);
		      Status = ZwCreateKey(&ScsiTargetKey,
   12c60:	8d 95 88 fd ff ff    	lea    0xfffffd88(%ebp),%edx
   12c66:	89 85 8c fd ff ff    	mov    %eax,0xfffffd8c(%ebp)
   12c6c:	8d 85 cc fc ff ff    	lea    0xfffffccc(%ebp),%eax
   12c72:	89 04 24             	mov    %eax,(%esp)
   12c75:	8d 8d d0 fc ff ff    	lea    0xfffffcd0(%ebp),%ecx
   12c7b:	8d 85 a8 fc ff ff    	lea    0xfffffca8(%ebp),%eax
   12c81:	6a 01                	push   $0x1
   12c83:	c7 85 88 fd ff ff 18 	movl   $0x18,0xfffffd88(%ebp)
   12c8a:	00 00 00 
   12c8d:	6a 00                	push   $0x0
   12c8f:	89 8d 90 fd ff ff    	mov    %ecx,0xfffffd90(%ebp)
   12c95:	6a 00                	push   $0x0
   12c97:	c7 85 94 fd ff ff 00 	movl   $0x0,0xfffffd94(%ebp)
   12c9e:	00 00 00 
   12ca1:	52                   	push   %edx
   12ca2:	c7 85 98 fd ff ff 00 	movl   $0x0,0xfffffd98(%ebp)
   12ca9:	00 00 00 
   12cac:	68 3f 00 0f 00       	push   $0xf003f
   12cb1:	c7 85 9c fd ff ff 00 	movl   $0x0,0xfffffd9c(%ebp)
   12cb8:	00 00 00 
   12cbb:	50                   	push   %eax
   12cbc:	e8 9f 14 00 00       	call   14160 <_ZwCreateKey@28>
   12cc1:	5a                   	pop    %edx
					   KEY_ALL_ACCESS,
					   &ObjectAttributes,
					   0,
					   NULL,
					   REG_OPTION_VOLATILE,
					   &Disposition);
		      if (!NT_SUCCESS(Status))
   12cc2:	85 c0                	test   %eax,%eax
   12cc4:	0f 88 17 02 00 00    	js     12ee1 <_ScsiPortInitialize@16+0x1261>
			{
			  DPRINT("ZwCreateKey() failed (Status %lx)\n", Status);
			  goto ByeBye;
			}

		      CurrentTarget = Target;
   12cca:	89 9d 3c fc ff ff    	mov    %ebx,0xfffffc3c(%ebp)
		    }

		  /* Create 'Logical Unit Id X' key */
		  DPRINT("        Logical Unit Id %lu\n", Lun);
		  swprintf(NameBuffer,
   12cd0:	8d 8d 08 fd ff ff    	lea    0xfffffd08(%ebp),%ecx
   12cd6:	50                   	push   %eax
   12cd7:	8b 85 38 fc ff ff    	mov    0xfffffc38(%ebp),%eax
   12cdd:	50                   	push   %eax
   12cde:	68 54 53 01 00       	push   $0x15354
   12ce3:	51                   	push   %ecx
   12ce4:	e8 97 15 00 00       	call   14280 <_swprintf>
   12ce9:	59                   	pop    %ecx
			   L"Logical Unit Id %lu",
			   Lun);
		  RtlInitUnicodeString(&KeyName,
   12cea:	8d 85 08 fd ff ff    	lea    0xfffffd08(%ebp),%eax
   12cf0:	5e                   	pop    %esi
   12cf1:	8d 95 d0 fc ff ff    	lea    0xfffffcd0(%ebp),%edx
   12cf7:	50                   	push   %eax
   12cf8:	52                   	push   %edx
   12cf9:	e8 92 13 00 00       	call   14090 <_RtlInitUnicodeString@8>
				       NameBuffer);
		  InitializeObjectAttributes(&ObjectAttributes,
   12cfe:	8b 85 a8 fc ff ff    	mov    0xfffffca8(%ebp),%eax
   12d04:	89 85 8c fd ff ff    	mov    %eax,0xfffffd8c(%ebp)
					     &KeyName,
					     0,
					     ScsiTargetKey,
					     NULL);
		  Status = ZwCreateKey(&ScsiLunKey,
   12d0a:	8d 85 cc fc ff ff    	lea    0xfffffccc(%ebp),%eax
   12d10:	89 04 24             	mov    %eax,(%esp)
   12d13:	8d 95 88 fd ff ff    	lea    0xfffffd88(%ebp),%edx
   12d19:	8d 8d d0 fc ff ff    	lea    0xfffffcd0(%ebp),%ecx
   12d1f:	8d 85 a4 fc ff ff    	lea    0xfffffca4(%ebp),%eax
   12d25:	6a 01                	push   $0x1
   12d27:	c7 85 88 fd ff ff 18 	movl   $0x18,0xfffffd88(%ebp)
   12d2e:	00 00 00 
   12d31:	6a 00                	push   $0x0
   12d33:	89 8d 90 fd ff ff    	mov    %ecx,0xfffffd90(%ebp)
   12d39:	6a 00                	push   $0x0
   12d3b:	c7 85 94 fd ff ff 00 	movl   $0x0,0xfffffd94(%ebp)
   12d42:	00 00 00 
   12d45:	52                   	push   %edx
   12d46:	c7 85 98 fd ff ff 00 	movl   $0x0,0xfffffd98(%ebp)
   12d4d:	00 00 00 
   12d50:	68 3f 00 0f 00       	push   $0xf003f
   12d55:	c7 85 9c fd ff ff 00 	movl   $0x0,0xfffffd9c(%ebp)
   12d5c:	00 00 00 
   12d5f:	50                   	push   %eax
   12d60:	e8 fb 13 00 00       	call   14160 <_ZwCreateKey@28>
   12d65:	5a                   	pop    %edx
				       KEY_ALL_ACCESS,
				       &ObjectAttributes,
				       0,
				       NULL,
				       REG_OPTION_VOLATILE,
				       &Disposition);
		  if (!NT_SUCCESS(Status))
   12d66:	85 c0                	test   %eax,%eax
   12d68:	0f 88 73 01 00 00    	js     12ee1 <_ScsiPortInitialize@16+0x1261>
		    {
		      DPRINT("ZwCreateKey() failed (Status %lx)\n", Status);
		      goto ByeBye;
		    }

		  /* Set 'Identifier' (REG_SZ) value */
		  swprintf(NameBuffer,
   12d6e:	83 ec 0c             	sub    $0xc,%esp
   12d71:	8d 47 30             	lea    0x30(%edi),%eax
   12d74:	8d 8d 08 fd ff ff    	lea    0xfffffd08(%ebp),%ecx
   12d7a:	50                   	push   %eax
   12d7b:	8d 47 20             	lea    0x20(%edi),%eax
   12d7e:	50                   	push   %eax
   12d7f:	8d 47 18             	lea    0x18(%edi),%eax
   12d82:	50                   	push   %eax
   12d83:	68 7c 53 01 00       	push   $0x1537c
   12d88:	51                   	push   %ecx
   12d89:	e8 f2 14 00 00       	call   14280 <_swprintf>
   12d8e:	83 c4 18             	add    $0x18,%esp
			   L"%.8S%.16S%.4S",
			   LunExtension->InquiryData.VendorId,
			   LunExtension->InquiryData.ProductId,
			   LunExtension->InquiryData.ProductRevisionLevel);
		  DPRINT("          Identifier = '%S'\n", NameBuffer);
		  RtlInitUnicodeString(&ValueName,
   12d91:	8d 85 b8 fc ff ff    	lea    0xfffffcb8(%ebp),%eax
   12d97:	68 98 53 01 00       	push   $0x15398
   12d9c:	50                   	push   %eax
   12d9d:	e8 ee 12 00 00       	call   14090 <_RtlInitUnicodeString@8>
				       L"Identifier");
		  Status = ZwSetValueKey(ScsiLunKey,
   12da2:	8d 95 08 fd ff ff    	lea    0xfffffd08(%ebp),%edx
   12da8:	56                   	push   %esi
   12da9:	52                   	push   %edx
   12daa:	e8 a1 14 00 00       	call   14250 <_wcslen>
   12daf:	5a                   	pop    %edx
   12db0:	59                   	pop    %ecx
   12db1:	8b b5 a4 fc ff ff    	mov    0xfffffca4(%ebp),%esi
   12db7:	8d 44 00 02          	lea    0x2(%eax,%eax,1),%eax
   12dbb:	8d 8d 08 fd ff ff    	lea    0xfffffd08(%ebp),%ecx
   12dc1:	50                   	push   %eax
   12dc2:	8d 85 b8 fc ff ff    	lea    0xfffffcb8(%ebp),%eax
   12dc8:	51                   	push   %ecx
   12dc9:	6a 01                	push   $0x1
   12dcb:	6a 00                	push   $0x0
   12dcd:	50                   	push   %eax
   12dce:	56                   	push   %esi
   12dcf:	e8 ac 13 00 00       	call   14180 <_ZwSetValueKey@24>
   12dd4:	5a                   	pop    %edx
					 &ValueName,
					 0,
					 REG_SZ,
					 NameBuffer,
					 (wcslen(NameBuffer) + 1) * sizeof(WCHAR));
		  if (!NT_SUCCESS(Status))
   12dd5:	85 c0                	test   %eax,%eax
   12dd7:	59                   	pop    %ecx
   12dd8:	0f 88 03 01 00 00    	js     12ee1 <_ScsiPortInitialize@16+0x1261>
		    {
		      DPRINT("ZwSetValueKey('Identifier') failed (Status %lx)\n", Status);
		      goto ByeBye;
		    }

		  /* Set 'Type' (REG_SZ) value */
		  switch (LunExtension->InquiryData.DeviceType)
   12dde:	8a 47 10             	mov    0x10(%edi),%al
   12de1:	83 e0 1f             	and    $0x1f,%eax
   12de4:	25 ff 00 00 00       	and    $0xff,%eax
   12de9:	83 f8 09             	cmp    $0x9,%eax
   12dec:	77 07                	ja     12df5 <_ScsiPortInitialize@16+0x1175>
   12dee:	ff 24 85 c0 55 01 00 	jmp    *0x155c0(,%eax,4)
		    {
		      case 0:
			TypeName = L"DiskPeripheral";
			break;
		      case 1:
			TypeName = L"TapePeripheral";
			break;
		      case 2:
			TypeName = L"PrinterPeripheral";
			break;
		      case 4:
			TypeName = L"WormPeripheral";
			break;
		      case 5:
			TypeName = L"CdRomPeripheral";
			break;
		      case 6:
			TypeName = L"ScannerPeripheral";
			break;
		      case 7:
			TypeName = L"OpticalDiskPeripheral";
			break;
		      case 8:
			TypeName = L"MediumChangerPeripheral";
			break;
		      case 9:
			TypeName = L"CommunicationPeripheral";
			break;
		      default:
			TypeName = L"OtherPeripheral";
   12df5:	be b0 53 01 00       	mov    $0x153b0,%esi
			break;
		    }
		  DPRINT("          Type = '%S'\n", TypeName);
		  RtlInitUnicodeString(&ValueName,
   12dfa:	8d 95 b8 fc ff ff    	lea    0xfffffcb8(%ebp),%edx
   12e00:	57                   	push   %edi
   12e01:	57                   	push   %edi
   12e02:	68 d0 53 01 00       	push   $0x153d0
   12e07:	52                   	push   %edx
   12e08:	e8 83 12 00 00       	call   14090 <_RtlInitUnicodeString@8>
   12e0d:	51                   	push   %ecx
				       L"Type");
		  Status = ZwSetValueKey(ScsiLunKey,
   12e0e:	56                   	push   %esi
   12e0f:	e8 3c 14 00 00       	call   14250 <_wcslen>
   12e14:	5f                   	pop    %edi
   12e15:	5a                   	pop    %edx
   12e16:	8d 8d b8 fc ff ff    	lea    0xfffffcb8(%ebp),%ecx
   12e1c:	8d 44 00 02          	lea    0x2(%eax,%eax,1),%eax
   12e20:	50                   	push   %eax
   12e21:	56                   	push   %esi
   12e22:	8b b5 a4 fc ff ff    	mov    0xfffffca4(%ebp),%esi
   12e28:	6a 01                	push   $0x1
   12e2a:	6a 00                	push   $0x0
   12e2c:	51                   	push   %ecx
   12e2d:	56                   	push   %esi
   12e2e:	e8 4d 13 00 00       	call   14180 <_ZwSetValueKey@24>
   12e33:	5a                   	pop    %edx
					 &ValueName,
					 0,
					 REG_SZ,
					 TypeName,
					 (wcslen(TypeName) + 1) * sizeof(WCHAR));
		  if (!NT_SUCCESS(Status))
   12e34:	85 c0                	test   %eax,%eax
   12e36:	59                   	pop    %ecx
   12e37:	0f 88 a4 00 00 00    	js     12ee1 <_ScsiPortInitialize@16+0x1261>
		    {
		      DPRINT("ZwSetValueKey('Type') failed (Status %lx)\n", Status);
		      goto ByeBye;
		    }

		  ZwClose(ScsiLunKey);
   12e3d:	83 ec 0c             	sub    $0xc,%esp
   12e40:	8b 85 a4 fc ff ff    	mov    0xfffffca4(%ebp),%eax
   12e46:	50                   	push   %eax
   12e47:	e8 24 13 00 00       	call   14170 <_ZwClose@4>
		  ScsiLunKey = NULL;
   12e4c:	c7 85 a4 fc ff ff 00 	movl   $0x0,0xfffffca4(%ebp)
   12e53:	00 00 00 
   12e56:	83 c4 0c             	add    $0xc,%esp
   12e59:	8b 85 38 fc ff ff    	mov    0xfffffc38(%ebp),%eax
   12e5f:	40                   	inc    %eax
   12e60:	89 85 38 fc ff ff    	mov    %eax,0xfffffc38(%ebp)
   12e66:	83 bd 38 fc ff ff 07 	cmpl   $0x7,0xfffffc38(%ebp)
   12e6d:	0f 86 78 fd ff ff    	jbe    12beb <_ScsiPortInitialize@16+0xf6b>
		}
	    }

	  /* Close old target key */
	  if (ScsiTargetKey != NULL)
   12e73:	8b 85 a8 fc ff ff    	mov    0xfffffca8(%ebp),%eax
   12e79:	85 c0                	test   %eax,%eax
   12e7b:	0f 85 24 03 00 00    	jne    131a5 <_ScsiPortInitialize@16+0x1525>
   12e81:	8b 95 94 fc ff ff    	mov    0xfffffc94(%ebp),%edx
   12e87:	43                   	inc    %ebx
   12e88:	8b 42 08             	mov    0x8(%edx),%eax
   12e8b:	8a 40 59             	mov    0x59(%eax),%al
   12e8e:	25 ff 00 00 00       	and    $0xff,%eax
   12e93:	39 d8                	cmp    %ebx,%eax
   12e95:	0f 87 46 fd ff ff    	ja     12be1 <_ScsiPortInitialize@16+0xf61>
	    {
	      ZwClose(ScsiTargetKey);
	      ScsiTargetKey = NULL;
	    }
	}

      ZwClose(ScsiBusKey);
   12e9b:	83 ec 0c             	sub    $0xc,%esp
   12e9e:	8b 85 b0 fc ff ff    	mov    0xfffffcb0(%ebp),%eax
   12ea4:	50                   	push   %eax
   12ea5:	e8 c6 12 00 00       	call   14170 <_ZwClose@4>
   12eaa:	8b 85 40 fc ff ff    	mov    0xfffffc40(%ebp),%eax
   12eb0:	8b 8d 94 fc ff ff    	mov    0xfffffc94(%ebp),%ecx
   12eb6:	40                   	inc    %eax
   12eb7:	83 c4 0c             	add    $0xc,%esp
   12eba:	89 85 40 fc ff ff    	mov    %eax,0xfffffc40(%ebp)
   12ec0:	8b 41 08             	mov    0x8(%ecx),%eax
      ScsiBusKey = NULL;
   12ec3:	c7 85 b0 fc ff ff 00 	movl   $0x0,0xfffffcb0(%ebp)
   12eca:	00 00 00 
   12ecd:	8a 40 40             	mov    0x40(%eax),%al
   12ed0:	25 ff 00 00 00       	and    $0xff,%eax
   12ed5:	3b 85 40 fc ff ff    	cmp    0xfffffc40(%ebp),%eax
   12edb:	0f 87 73 fb ff ff    	ja     12a54 <_ScsiPortInitialize@16+0xdd4>
    }

ByeBye:
  if (ScsiLunKey != NULL)
   12ee1:	8b 85 a4 fc ff ff    	mov    0xfffffca4(%ebp),%eax
   12ee7:	85 c0                	test   %eax,%eax
   12ee9:	0f 85 04 03 00 00    	jne    131f3 <_ScsiPortInitialize@16+0x1573>
    ZwClose (ScsiLunKey);

  if (ScsiInitiatorKey != NULL)
   12eef:	8b 85 ac fc ff ff    	mov    0xfffffcac(%ebp),%eax
   12ef5:	85 c0                	test   %eax,%eax
   12ef7:	0f 85 e5 02 00 00    	jne    131e2 <_ScsiPortInitialize@16+0x1562>
    ZwClose (ScsiInitiatorKey);

  if (ScsiTargetKey != NULL)
   12efd:	8b 85 a8 fc ff ff    	mov    0xfffffca8(%ebp),%eax
   12f03:	85 c0                	test   %eax,%eax
   12f05:	0f 85 c6 02 00 00    	jne    131d1 <_ScsiPortInitialize@16+0x1551>
    ZwClose (ScsiTargetKey);

  if (ScsiBusKey != NULL)
   12f0b:	8b 85 b0 fc ff ff    	mov    0xfffffcb0(%ebp),%eax
   12f11:	85 c0                	test   %eax,%eax
   12f13:	0f 85 a7 02 00 00    	jne    131c0 <_ScsiPortInitialize@16+0x1540>
    ZwClose (ScsiBusKey);

  if (ScsiPortKey != NULL)
   12f19:	8b 85 c4 fc ff ff    	mov    0xfffffcc4(%ebp),%eax
   12f1f:	85 c0                	test   %eax,%eax
   12f21:	0f 84 f3 f6 ff ff    	je     1261a <_ScsiPortInitialize@16+0x99a>
    ZwClose (ScsiPortKey);
   12f27:	83 ec 0c             	sub    $0xc,%esp
   12f2a:	50                   	push   %eax
   12f2b:	e8 40 12 00 00       	call   14170 <_ZwClose@4>
   12f30:	83 c4 0c             	add    $0xc,%esp
   12f33:	e9 e2 f6 ff ff       	jmp    1261a <_ScsiPortInitialize@16+0x99a>
   12f38:	be dc 53 01 00       	mov    $0x153dc,%esi
   12f3d:	e9 b8 fe ff ff       	jmp    12dfa <_ScsiPortInitialize@16+0x117a>
   12f42:	be 0c 54 01 00       	mov    $0x1540c,%esi
   12f47:	e9 ae fe ff ff       	jmp    12dfa <_ScsiPortInitialize@16+0x117a>
   12f4c:	be 3c 54 01 00       	mov    $0x1543c,%esi
   12f51:	e9 a4 fe ff ff       	jmp    12dfa <_ScsiPortInitialize@16+0x117a>
   12f56:	be 68 54 01 00       	mov    $0x15468,%esi
   12f5b:	e9 9a fe ff ff       	jmp    12dfa <_ScsiPortInitialize@16+0x117a>
   12f60:	be 8c 54 01 00       	mov    $0x1548c,%esi
   12f65:	e9 90 fe ff ff       	jmp    12dfa <_ScsiPortInitialize@16+0x117a>
   12f6a:	be ac 54 01 00       	mov    $0x154ac,%esi
   12f6f:	e9 86 fe ff ff       	jmp    12dfa <_ScsiPortInitialize@16+0x117a>
   12f74:	be cc 54 01 00       	mov    $0x154cc,%esi
   12f79:	e9 7c fe ff ff       	jmp    12dfa <_ScsiPortInitialize@16+0x117a>
   12f7e:	be f0 54 01 00       	mov    $0x154f0,%esi
   12f83:	e9 72 fe ff ff       	jmp    12dfa <_ScsiPortInitialize@16+0x117a>
   12f88:	be 0e 55 01 00       	mov    $0x1550e,%esi
   12f8d:	e9 68 fe ff ff       	jmp    12dfa <_ScsiPortInitialize@16+0x117a>
   12f92:	8b 8d 90 fc ff ff    	mov    0xfffffc90(%ebp),%ecx
   12f98:	c6 41 1c 01          	movb   $0x1,0x1c(%ecx)
   12f9c:	e9 c3 f6 ff ff       	jmp    12664 <_ScsiPortInitialize@16+0x9e4>
   12fa1:	8b 85 90 fc ff ff    	mov    0xfffffc90(%ebp),%eax
   12fa7:	c6 40 1d 01          	movb   $0x1,0x1d(%eax)
   12fab:	e9 c4 f6 ff ff       	jmp    12674 <_ScsiPortInitialize@16+0x9f4>
   12fb0:	8b 9d 8c fc ff ff    	mov    0xfffffc8c(%ebp),%ebx
   12fb6:	8b 43 18             	mov    0x18(%ebx),%eax
   12fb9:	e9 2c f2 ff ff       	jmp    121ea <_ScsiPortInitialize@16+0x56a>
   12fbe:	83 ec 0c             	sub    $0xc,%esp
   12fc1:	50                   	push   %eax
   12fc2:	e8 a9 11 00 00       	call   14170 <_ZwClose@4>
   12fc7:	83 c4 0c             	add    $0xc,%esp
   12fca:	c7 85 a8 fc ff ff 00 	movl   $0x0,0xfffffca8(%ebp)
   12fd1:	00 00 00 
   12fd4:	e9 59 fc ff ff       	jmp    12c32 <_ScsiPortInitialize@16+0xfb2>
   12fd9:	50                   	push   %eax
   12fda:	8b 85 8c fc ff ff    	mov    0xfffffc8c(%ebp),%eax
   12fe0:	6a 00                	push   $0x0
   12fe2:	50                   	push   %eax
   12fe3:	53                   	push   %ebx
   12fe4:	e8 a7 e4 ff ff       	call   11490 <_ScsiPortGetUncachedExtension@12>
   12fe9:	5f                   	pop    %edi
   12fea:	e9 16 f1 ff ff       	jmp    12105 <_ScsiPortInitialize@16+0x485>
   12fef:	83 ec 0c             	sub    $0xc,%esp
   12ff2:	8b 85 c4 fc ff ff    	mov    0xfffffcc4(%ebp),%eax
   12ff8:	e9 2d ff ff ff       	jmp    12f2a <_ScsiPortInitialize@16+0x12aa>
   12ffd:	89 c6                	mov    %eax,%esi
   12fff:	83 f8 1f             	cmp    $0x1f,%eax
   13002:	0f 87 9d f0 ff ff    	ja     120a5 <_ScsiPortInitialize@16+0x425>
   13008:	8d bd a8 fd ff ff    	lea    0xfffffda8(%ebp),%edi
   1300e:	8b 95 74 fc ff ff    	mov    0xfffffc74(%ebp),%edx
   13014:	89 f0                	mov    %esi,%eax
   13016:	83 e2 e0             	and    $0xffffffe0,%edx
   13019:	83 e0 1f             	and    $0x1f,%eax
   1301c:	89 95 74 fc ff ff    	mov    %edx,0xfffffc74(%ebp)
   13022:	8b 9d 74 fc ff ff    	mov    0xfffffc74(%ebp),%ebx
   13028:	09 c3                	or     %eax,%ebx
   1302a:	8a 85 f8 fc ff ff    	mov    0xfffffcf8(%ebp),%al
   13030:	c0 e8 05             	shr    $0x5,%al
   13033:	89 9d 74 fc ff ff    	mov    %ebx,0xfffffc74(%ebp)
   13039:	31 db                	xor    %ebx,%ebx
   1303b:	88 c3                	mov    %al,%bl
   1303d:	83 fb 07             	cmp    $0x7,%ebx
   13040:	0f 87 c6 00 00 00    	ja     1310c <_ScsiPortInitialize@16+0x148c>
   13046:	8b 8d 74 fc ff ff    	mov    0xfffffc74(%ebp),%ecx
   1304c:	89 d8                	mov    %ebx,%eax
   1304e:	80 e1 1f             	and    $0x1f,%cl
   13051:	83 e0 07             	and    $0x7,%eax
   13054:	89 8d 74 fc ff ff    	mov    %ecx,0xfffffc74(%ebp)
   1305a:	83 ec 0c             	sub    $0xc,%esp
   1305d:	c1 e0 05             	shl    $0x5,%eax
   13060:	8b 95 74 fc ff ff    	mov    0xfffffc74(%ebp),%edx
   13066:	09 c2                	or     %eax,%edx
   13068:	6a 40                	push   $0x40
   1306a:	89 95 74 fc ff ff    	mov    %edx,0xfffffc74(%ebp)
   13070:	8b 95 78 fc ff ff    	mov    0xfffffc78(%ebp),%edx
   13076:	8b 8d 74 fc ff ff    	mov    0xfffffc74(%ebp),%ecx
   1307c:	57                   	push   %edi
   1307d:	51                   	push   %ecx
   1307e:	52                   	push   %edx
   1307f:	6a 04                	push   $0x4
   13081:	e8 3a 12 00 00       	call   142c0 <_HalGetBusData@20>
   13086:	83 c4 0c             	add    $0xc,%esp
   13089:	83 f8 40             	cmp    $0x40,%eax
   1308c:	74 07                	je     13095 <_ScsiPortInitialize@16+0x1415>
   1308e:	85 db                	test   %ebx,%ebx
   13090:	74 7a                	je     1310c <_ScsiPortInitialize@16+0x148c>
   13092:	43                   	inc    %ebx
   13093:	eb a8                	jmp    1303d <_ScsiPortInitialize@16+0x13bd>
   13095:	50                   	push   %eax
   13096:	8b 85 a8 fd ff ff    	mov    0xfffffda8(%ebp),%eax
   1309c:	8d 8d f0 fc ff ff    	lea    0xfffffcf0(%ebp),%ecx
   130a2:	25 ff ff 00 00       	and    $0xffff,%eax
   130a7:	50                   	push   %eax
   130a8:	68 2c 55 01 00       	push   $0x1552c
   130ad:	51                   	push   %ecx
   130ae:	e8 bd 11 00 00       	call   14270 <_sprintf>
   130b3:	83 c4 0c             	add    $0xc,%esp
   130b6:	66 8b 85 aa fd ff ff 	mov    0xfffffdaa(%ebp),%ax
   130bd:	25 ff ff 00 00       	and    $0xffff,%eax
   130c2:	50                   	push   %eax
   130c3:	8d 85 e8 fc ff ff    	lea    0xfffffce8(%ebp),%eax
   130c9:	68 2c 55 01 00       	push   $0x1552c
   130ce:	50                   	push   %eax
   130cf:	e8 9c 11 00 00       	call   14270 <_sprintf>
   130d4:	8b 55 10             	mov    0x10(%ebp),%edx
   130d7:	83 c4 0c             	add    $0xc,%esp
   130da:	66 8b 42 3e          	mov    0x3e(%edx),%ax
   130de:	25 ff ff 00 00       	and    $0xffff,%eax
   130e3:	8d 8d f0 fc ff ff    	lea    0xfffffcf0(%ebp),%ecx
   130e9:	50                   	push   %eax
   130ea:	8b 42 40             	mov    0x40(%edx),%eax
   130ed:	50                   	push   %eax
   130ee:	51                   	push   %ecx
   130ef:	e8 bc 11 00 00       	call   142b0 <__strnicmp>
   130f4:	83 c4 10             	add    $0x10,%esp
   130f7:	85 c0                	test   %eax,%eax
   130f9:	0f 84 8b 01 00 00    	je     1328a <_ScsiPortInitialize@16+0x160a>
   130ff:	85 db                	test   %ebx,%ebx
   13101:	75 8f                	jne    13092 <_ScsiPortInitialize@16+0x1412>
   13103:	80 bd b6 fd ff ff 00 	cmpb   $0x0,0xfffffdb6(%ebp)
   1310a:	78 86                	js     13092 <_ScsiPortInitialize@16+0x1412>
   1310c:	8b 85 f8 fc ff ff    	mov    0xfffffcf8(%ebp),%eax
   13112:	46                   	inc    %esi
   13113:	24 1f                	and    $0x1f,%al
   13115:	83 fe 1f             	cmp    $0x1f,%esi
   13118:	89 85 f8 fc ff ff    	mov    %eax,0xfffffcf8(%ebp)
   1311e:	0f 86 ea fe ff ff    	jbe    1300e <_ScsiPortInitialize@16+0x138e>
   13124:	e9 7c ef ff ff       	jmp    120a5 <_ScsiPortInitialize@16+0x425>
   13129:	31 f6                	xor    %esi,%esi
   1312b:	8b 85 fc fc ff ff    	mov    0xfffffcfc(%ebp),%eax
   13131:	85 c0                	test   %eax,%eax
   13133:	74 37                	je     1316c <_ScsiPortInitialize@16+0x14ec>
   13135:	8b 40 28             	mov    0x28(%eax),%eax
   13138:	89 85 94 fc ff ff    	mov    %eax,0xfffffc94(%ebp)
   1313e:	8b 50 3c             	mov    0x3c(%eax),%edx
   13141:	85 d2                	test   %edx,%edx
   13143:	0f 85 cc 00 00 00    	jne    13215 <_ScsiPortInitialize@16+0x1595>
   13149:	8b 95 94 fc ff ff    	mov    0xfffffc94(%ebp),%edx
   1314f:	8b 42 08             	mov    0x8(%edx),%eax
   13152:	85 c0                	test   %eax,%eax
   13154:	0f 85 aa 00 00 00    	jne    13204 <_ScsiPortInitialize@16+0x1584>
   1315a:	83 ec 0c             	sub    $0xc,%esp
   1315d:	8b 8d fc fc ff ff    	mov    0xfffffcfc(%ebp),%ecx
   13163:	51                   	push   %ecx
   13164:	e8 e7 0f 00 00       	call   14150 <_IoDeleteDevice@4>
   13169:	83 c4 0c             	add    $0xc,%esp
   1316c:	89 f0                	mov    %esi,%eax
   1316e:	80 bd 83 fc ff ff 00 	cmpb   $0x0,0xfffffc83(%ebp)
   13175:	0f 84 3c eb ff ff    	je     11cb7 <_ScsiPortInitialize@16+0x37>
   1317b:	31 c0                	xor    %eax,%eax
   1317d:	e9 35 eb ff ff       	jmp    11cb7 <_ScsiPortInitialize@16+0x37>
   13182:	be 9a 00 00 c0       	mov    $0xc000009a,%esi
   13187:	eb a2                	jmp    1312b <_ScsiPortInitialize@16+0x14ab>
   13189:	50                   	push   %eax
   1318a:	50                   	push   %eax
   1318b:	56                   	push   %esi
   1318c:	68 34 55 01 00       	push   $0x15534
   13191:	e8 fa 10 00 00       	call   14290 <_DbgPrint>
   13196:	83 c4 10             	add    $0x10,%esp
   13199:	c7 85 fc fc ff ff 00 	movl   $0x0,0xfffffcfc(%ebp)
   131a0:	00 00 00 
   131a3:	eb 86                	jmp    1312b <_ScsiPortInitialize@16+0x14ab>
   131a5:	83 ec 0c             	sub    $0xc,%esp
   131a8:	50                   	push   %eax
   131a9:	e8 c2 0f 00 00       	call   14170 <_ZwClose@4>
   131ae:	83 c4 0c             	add    $0xc,%esp
   131b1:	c7 85 a8 fc ff ff 00 	movl   $0x0,0xfffffca8(%ebp)
   131b8:	00 00 00 
   131bb:	e9 c1 fc ff ff       	jmp    12e81 <_ScsiPortInitialize@16+0x1201>
   131c0:	83 ec 0c             	sub    $0xc,%esp
   131c3:	50                   	push   %eax
   131c4:	e8 a7 0f 00 00       	call   14170 <_ZwClose@4>
   131c9:	83 c4 0c             	add    $0xc,%esp
   131cc:	e9 48 fd ff ff       	jmp    12f19 <_ScsiPortInitialize@16+0x1299>
   131d1:	83 ec 0c             	sub    $0xc,%esp
   131d4:	50                   	push   %eax
   131d5:	e8 96 0f 00 00       	call   14170 <_ZwClose@4>
   131da:	83 c4 0c             	add    $0xc,%esp
   131dd:	e9 29 fd ff ff       	jmp    12f0b <_ScsiPortInitialize@16+0x128b>
   131e2:	83 ec 0c             	sub    $0xc,%esp
   131e5:	50                   	push   %eax
   131e6:	e8 85 0f 00 00       	call   14170 <_ZwClose@4>
   131eb:	83 c4 0c             	add    $0xc,%esp
   131ee:	e9 0a fd ff ff       	jmp    12efd <_ScsiPortInitialize@16+0x127d>
   131f3:	83 ec 0c             	sub    $0xc,%esp
   131f6:	50                   	push   %eax
   131f7:	e8 74 0f 00 00       	call   14170 <_ZwClose@4>
   131fc:	83 c4 0c             	add    $0xc,%esp
   131ff:	e9 eb fc ff ff       	jmp    12eef <_ScsiPortInitialize@16+0x126f>
   13204:	83 ec 0c             	sub    $0xc,%esp
   13207:	50                   	push   %eax
   13208:	e8 b3 0d 00 00       	call   13fc0 <_ExFreePool@4>
   1320d:	83 c4 0c             	add    $0xc,%esp
   13210:	e9 45 ff ff ff       	jmp    1315a <_ScsiPortInitialize@16+0x14da>
   13215:	83 ec 0c             	sub    $0xc,%esp
   13218:	8b 78 18             	mov    0x18(%eax),%edi
   1321b:	57                   	push   %edi
   1321c:	e8 6f 0f 00 00       	call   14190 <_IoDisconnectInterrupt@4>
   13221:	8b 9d 94 fc ff ff    	mov    0xfffffc94(%ebp),%ebx
   13227:	8b 5b 3c             	mov    0x3c(%ebx),%ebx
   1322a:	53                   	push   %ebx
   1322b:	e8 90 0d 00 00       	call   13fc0 <_ExFreePool@4>
   13230:	83 c4 0c             	add    $0xc,%esp
   13233:	e9 11 ff ff ff       	jmp    13149 <_ScsiPortInitialize@16+0x14c9>
   13238:	83 ec 0c             	sub    $0xc,%esp
   1323b:	be 01 00 00 c0       	mov    $0xc0000001,%esi
   13240:	68 60 55 01 00       	push   $0x15560
   13245:	e8 46 10 00 00       	call   14290 <_DbgPrint>
   1324a:	83 c4 10             	add    $0x10,%esp
   1324d:	e9 d9 fe ff ff       	jmp    1312b <_ScsiPortInitialize@16+0x14ab>
   13252:	50                   	push   %eax
   13253:	50                   	push   %eax
   13254:	8b 85 8c fc ff ff    	mov    0xfffffc8c(%ebp),%eax
   1325a:	8b 78 10             	mov    0x10(%eax),%edi
   1325d:	57                   	push   %edi
   1325e:	68 78 55 01 00       	push   $0x15578
   13263:	e8 28 10 00 00       	call   14290 <_DbgPrint>
   13268:	83 c4 10             	add    $0x10,%esp
   1326b:	e9 bb fe ff ff       	jmp    1312b <_ScsiPortInitialize@16+0x14ab>
   13270:	83 ec 0c             	sub    $0xc,%esp
   13273:	be 9a 00 00 c0       	mov    $0xc000009a,%esi
   13278:	68 98 55 01 00       	push   $0x15598
   1327d:	e8 0e 10 00 00       	call   14290 <_DbgPrint>
   13282:	83 c4 10             	add    $0x10,%esp
   13285:	e9 a1 fe ff ff       	jmp    1312b <_ScsiPortInitialize@16+0x14ab>
   1328a:	8b 55 10             	mov    0x10(%ebp),%edx
   1328d:	50                   	push   %eax
   1328e:	8d 8d e8 fc ff ff    	lea    0xfffffce8(%ebp),%ecx
   13294:	66 8b 42 46          	mov    0x46(%edx),%ax
   13298:	25 ff ff 00 00       	and    $0xffff,%eax
   1329d:	50                   	push   %eax
   1329e:	8b 42 48             	mov    0x48(%edx),%eax
   132a1:	50                   	push   %eax
   132a2:	51                   	push   %ecx
   132a3:	e8 08 10 00 00       	call   142b0 <__strnicmp>
   132a8:	83 c4 10             	add    $0x10,%esp
   132ab:	85 c0                	test   %eax,%eax
   132ad:	0f 85 4c fe ff ff    	jne    130ff <_ScsiPortInitialize@16+0x147f>
   132b3:	8b 95 8c fc ff ff    	mov    0xfffffc8c(%ebp),%edx
   132b9:	31 c0                	xor    %eax,%eax
   132bb:	8a 85 e4 fd ff ff    	mov    0xfffffde4(%ebp),%al
   132c1:	8b 8d 74 fc ff ff    	mov    0xfffffc74(%ebp),%ecx
   132c7:	89 42 10             	mov    %eax,0x10(%edx)
   132ca:	89 42 0c             	mov    %eax,0xc(%edx)
   132cd:	8b 42 34             	mov    0x34(%edx),%eax
   132d0:	89 4a 5c             	mov    %ecx,0x5c(%edx)
   132d3:	85 c0                	test   %eax,%eax
   132d5:	0f 84 d0 00 00 00    	je     133ab <_ScsiPortInitialize@16+0x172b>
   132db:	83 f8 06             	cmp    $0x6,%eax
   132de:	76 0c                	jbe    132ec <_ScsiPortInitialize@16+0x166c>
   132e0:	c7 42 34 06 00 00 00 	movl   $0x6,0x34(%edx)
   132e7:	b8 06 00 00 00       	mov    $0x6,%eax
   132ec:	c7 85 70 fc ff ff 00 	movl   $0x0,0xfffffc70(%ebp)
   132f3:	00 00 00 
   132f6:	83 f8 00             	cmp    $0x0,%eax
   132f9:	0f 86 ac 00 00 00    	jbe    133ab <_ScsiPortInitialize@16+0x172b>
   132ff:	83 c7 10             	add    $0x10,%edi
   13302:	c7 85 2c fc ff ff 10 	movl   $0x10,0xfffffc2c(%ebp)
   13309:	00 00 00 
   1330c:	89 bd 30 fc ff ff    	mov    %edi,0xfffffc30(%ebp)
   13312:	8b 85 8c fc ff ff    	mov    0xfffffc8c(%ebp),%eax
   13318:	8b 95 2c fc ff ff    	mov    0xfffffc2c(%ebp),%edx
   1331e:	8b bd 70 fc ff ff    	mov    0xfffffc70(%ebp),%edi
   13324:	c1 e7 04             	shl    $0x4,%edi
   13327:	8b 48 38             	mov    0x38(%eax),%ecx
   1332a:	8b 84 2a a8 fd ff ff 	mov    0xfffffda8(%edx,%ebp,1),%eax
   13331:	31 d2                	xor    %edx,%edx
   13333:	89 85 20 fc ff ff    	mov    %eax,0xfffffc20(%ebp)
   13339:	89 95 24 fc ff ff    	mov    %edx,0xfffffc24(%ebp)
   1333f:	8b 85 20 fc ff ff    	mov    0xfffffc20(%ebp),%eax
   13345:	31 d2                	xor    %edx,%edx
   13347:	83 e0 fc             	and    $0xfffffffc,%eax
   1334a:	89 54 0f 04          	mov    %edx,0x4(%edi,%ecx,1)
   1334e:	89 04 0f             	mov    %eax,(%edi,%ecx,1)
   13351:	8b 8d 8c fc ff ff    	mov    0xfffffc8c(%ebp),%ecx
   13357:	8b 41 38             	mov    0x38(%ecx),%eax
   1335a:	8b 54 07 04          	mov    0x4(%edi,%eax,1),%edx
   1335e:	8b 04 07             	mov    (%edi,%eax,1),%eax
   13361:	89 d1                	mov    %edx,%ecx
   13363:	09 c1                	or     %eax,%ecx
   13365:	0f 85 9e 00 00 00    	jne    13409 <_ScsiPortInitialize@16+0x1789>
   1336b:	8b 85 70 fc ff ff    	mov    0xfffffc70(%ebp),%eax
   13371:	40                   	inc    %eax
   13372:	89 85 70 fc ff ff    	mov    %eax,0xfffffc70(%ebp)
   13378:	8b 85 2c fc ff ff    	mov    0xfffffc2c(%ebp),%eax
   1337e:	83 c0 04             	add    $0x4,%eax
   13381:	8b 95 70 fc ff ff    	mov    0xfffffc70(%ebp),%edx
   13387:	89 85 2c fc ff ff    	mov    %eax,0xfffffc2c(%ebp)
   1338d:	8b 85 30 fc ff ff    	mov    0xfffffc30(%ebp),%eax
   13393:	83 c0 04             	add    $0x4,%eax
   13396:	89 85 30 fc ff ff    	mov    %eax,0xfffffc30(%ebp)
   1339c:	8b 85 8c fc ff ff    	mov    0xfffffc8c(%ebp),%eax
   133a2:	39 50 34             	cmp    %edx,0x34(%eax)
   133a5:	0f 87 67 ff ff ff    	ja     13312 <_ScsiPortInitialize@16+0x1692>
   133ab:	8b 85 f8 fc ff ff    	mov    0xfffffcf8(%ebp),%eax
   133b1:	83 e6 1f             	and    $0x1f,%esi
   133b4:	30 c0                	xor    %al,%al
   133b6:	83 e3 07             	and    $0x7,%ebx
   133b9:	c1 e3 05             	shl    $0x5,%ebx
   133bc:	09 f0                	or     %esi,%eax
   133be:	8b 8d 8c fc ff ff    	mov    0xfffffc8c(%ebp),%ecx
   133c4:	09 d8                	or     %ebx,%eax
   133c6:	89 85 f8 fc ff ff    	mov    %eax,0xfffffcf8(%ebp)
   133cc:	89 41 5c             	mov    %eax,0x5c(%ecx)
   133cf:	8a 85 f8 fc ff ff    	mov    0xfffffcf8(%ebp),%al
   133d5:	8b 95 f8 fc ff ff    	mov    0xfffffcf8(%ebp),%edx
   133db:	c0 e8 05             	shr    $0x5,%al
   133de:	80 e2 1f             	and    $0x1f,%dl
   133e1:	25 ff 00 00 00       	and    $0xff,%eax
   133e6:	40                   	inc    %eax
   133e7:	83 e0 07             	and    $0x7,%eax
   133ea:	c1 e0 05             	shl    $0x5,%eax
   133ed:	09 c2                	or     %eax,%edx
   133ef:	b8 01 00 00 00       	mov    $0x1,%eax
   133f4:	89 95 f8 fc ff ff    	mov    %edx,0xfffffcf8(%ebp)
   133fa:	e9 a8 ec ff ff       	jmp    120a7 <_ScsiPortInitialize@16+0x427>
   133ff:	be 01 00 00 c0       	mov    $0xc0000001,%esi
   13404:	e9 22 fd ff ff       	jmp    1312b <_ScsiPortInitialize@16+0x14ab>
   13409:	50                   	push   %eax
   1340a:	50                   	push   %eax
   1340b:	8b 85 2c fc ff ff    	mov    0xfffffc2c(%ebp),%eax
   13411:	6a 04                	push   $0x4
   13413:	8b 8d 74 fc ff ff    	mov    0xfffffc74(%ebp),%ecx
   13419:	50                   	push   %eax
   1341a:	8b 95 78 fc ff ff    	mov    0xfffffc78(%ebp),%edx
   13420:	8d 85 e4 fc ff ff    	lea    0xfffffce4(%ebp),%eax
   13426:	c7 85 e4 fc ff ff ff 	movl   $0xffffffff,0xfffffce4(%ebp)
   1342d:	ff ff ff 
   13430:	50                   	push   %eax
   13431:	51                   	push   %ecx
   13432:	52                   	push   %edx
   13433:	6a 04                	push   $0x4
   13435:	e8 c6 0e 00 00       	call   14300 <_HalSetBusDataByOffset@24>
   1343a:	8b 85 2c fc ff ff    	mov    0xfffffc2c(%ebp),%eax
   13440:	8d 95 e4 fc ff ff    	lea    0xfffffce4(%ebp),%edx
   13446:	6a 04                	push   $0x4
   13448:	50                   	push   %eax
   13449:	8b 85 74 fc ff ff    	mov    0xfffffc74(%ebp),%eax
   1344f:	52                   	push   %edx
   13450:	50                   	push   %eax
   13451:	8b 85 78 fc ff ff    	mov    0xfffffc78(%ebp),%eax
   13457:	50                   	push   %eax
   13458:	6a 04                	push   $0x4
   1345a:	e8 c1 0e 00 00       	call   14320 <_HalGetBusDataByOffset@24>
   1345f:	8b 85 2c fc ff ff    	mov    0xfffffc2c(%ebp),%eax
   13465:	8b 8d 78 fc ff ff    	mov    0xfffffc78(%ebp),%ecx
   1346b:	6a 04                	push   $0x4
   1346d:	50                   	push   %eax
   1346e:	8b 85 30 fc ff ff    	mov    0xfffffc30(%ebp),%eax
   13474:	50                   	push   %eax
   13475:	8b 85 74 fc ff ff    	mov    0xfffffc74(%ebp),%eax
   1347b:	50                   	push   %eax
   1347c:	51                   	push   %ecx
   1347d:	6a 04                	push   $0x4
   1347f:	e8 7c 0e 00 00       	call   14300 <_HalSetBusDataByOffset@24>
   13484:	58                   	pop    %eax
   13485:	8b 85 e4 fc ff ff    	mov    0xfffffce4(%ebp),%eax
   1348b:	5a                   	pop    %edx
   1348c:	85 c0                	test   %eax,%eax
   1348e:	0f 84 d7 fe ff ff    	je     1336b <_ScsiPortInitialize@16+0x16eb>
   13494:	8b 8d 8c fc ff ff    	mov    0xfffffc8c(%ebp),%ecx
   1349a:	83 e0 fc             	and    $0xfffffffc,%eax
   1349d:	f7 d8                	neg    %eax
   1349f:	8b 51 38             	mov    0x38(%ecx),%edx
   134a2:	8b 8d 2c fc ff ff    	mov    0xfffffc2c(%ebp),%ecx
   134a8:	89 44 17 08          	mov    %eax,0x8(%edi,%edx,1)
   134ac:	8b 84 29 a8 fd ff ff 	mov    0xfffffda8(%ecx,%ebp,1),%eax
   134b3:	83 f0 01             	xor    $0x1,%eax
   134b6:	83 e0 01             	and    $0x1,%eax
   134b9:	88 44 17 0c          	mov    %al,0xc(%edi,%edx,1)
   134bd:	e9 a9 fe ff ff       	jmp    1336b <_ScsiPortInitialize@16+0x16eb>
   134c2:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   134c9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000134d0 <_SpiRemoveActiveIrp>:

  DPRINT("SpiBuildDeviceMap() done\n");

  return Status;
}

static VOID 
SpiRemoveActiveIrp(PSCSI_PORT_DEVICE_EXTENSION DeviceExtension, 
	           PIRP Irp,
	           PIRP PrevIrp)
{
   134d0:	55                   	push   %ebp
   134d1:	89 e5                	mov    %esp,%ebp
   134d3:	57                   	push   %edi
   134d4:	56                   	push   %esi
   134d5:	53                   	push   %ebx
   134d6:	83 ec 0c             	sub    $0xc,%esp
   134d9:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
  PSCSI_PORT_LUN_EXTENSION LunExtension;
  PIRP CurrentIrp;
  LunExtension = Irp->Tail.Overlay.DriverContext[2];
   134dc:	8b 72 48             	mov    0x48(%edx),%esi
   134df:	89 d3                	mov    %edx,%ebx
   134e1:	8b 7d 08             	mov    0x8(%ebp),%edi
  InterlockedDecrement((PLONG)&LunExtension->ActiveIrpCount);
   134e4:	8d 4e 74             	lea    0x74(%esi),%ecx
   134e7:	e8 b4 0c 00 00       	call   141a0 <@InterlockedDecrement@4>
  InterlockedDecrement((PLONG)&DeviceExtension->ActiveIrpCount);
   134ec:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   134ef:	81 c1 88 00 00 00    	add    $0x88,%ecx
   134f5:	e8 a6 0c 00 00       	call   141a0 <@InterlockedDecrement@4>
  if (PrevIrp)
   134fa:	85 ff                	test   %edi,%edi
   134fc:	74 5f                	je     1355d <_SpiRemoveActiveIrp+0x8d>
    {
      InterlockedExchangePointer(&PrevIrp->Tail.Overlay.DriverContext[0], 
   134fe:	8b 53 40             	mov    0x40(%ebx),%edx
   13501:	8d 4f 40             	lea    0x40(%edi),%ecx
	                         Irp->Tail.Overlay.DriverContext[0]);
    }
  else
    {
      InterlockedExchangePointer(&DeviceExtension->NextIrp,
   13504:	e8 a7 0c 00 00       	call   141b0 <@InterlockedExchange@8>
	                         Irp->Tail.Overlay.DriverContext[0]);
    }
  if (LunExtension->NextIrp == Irp)
   13509:	8b 46 78             	mov    0x78(%esi),%eax
   1350c:	39 d8                	cmp    %ebx,%eax
   1350e:	75 09                	jne    13519 <_SpiRemoveActiveIrp+0x49>
   13510:	eb 60                	jmp    13572 <_SpiRemoveActiveIrp+0xa2>
    {
      InterlockedExchangePointer(&LunExtension->NextIrp,
	                         Irp->Tail.Overlay.DriverContext[1]);
      return;
    }
  else
    {
      CurrentIrp = LunExtension->NextIrp;
      while (CurrentIrp)
        {
	  if (CurrentIrp->Tail.Overlay.DriverContext[1] == Irp)
   13512:	8b 40 44             	mov    0x44(%eax),%eax
   13515:	39 d8                	cmp    %ebx,%eax
   13517:	74 32                	je     1354b <_SpiRemoveActiveIrp+0x7b>
   13519:	89 c1                	mov    %eax,%ecx
	    {
	      InterlockedExchangePointer(&CurrentIrp->Tail.Overlay.DriverContext[1],
		                         Irp->Tail.Overlay.DriverContext[1]);
	      return;
	    }
          CurrentIrp = CurrentIrp->Tail.Overlay.DriverContext[1];
   1351b:	85 c0                	test   %eax,%eax
   1351d:	75 f3                	jne    13512 <_SpiRemoveActiveIrp+0x42>
	}
      KEBUGCHECK(0);
   1351f:	57                   	push   %edi
   13520:	68 d5 0a 00 00       	push   $0xad5
   13525:	68 11 50 01 00       	push   $0x15011
   1352a:	68 eb 50 01 00       	push   $0x150eb
   1352f:	e8 5c 0d 00 00       	call   14290 <_DbgPrint>
   13534:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1353b:	e8 f0 0a 00 00       	call   14030 <_KeBugCheck@4>
   13540:	83 c4 0c             	add    $0xc,%esp
    }
}
   13543:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13546:	5b                   	pop    %ebx
   13547:	5e                   	pop    %esi
   13548:	5f                   	pop    %edi
   13549:	5d                   	pop    %ebp
   1354a:	c3                   	ret    
   1354b:	8b 50 44             	mov    0x44(%eax),%edx
   1354e:	83 c1 44             	add    $0x44,%ecx
   13551:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13554:	5b                   	pop    %ebx
   13555:	5e                   	pop    %esi
   13556:	5f                   	pop    %edi
   13557:	5d                   	pop    %ebp
   13558:	e9 53 0c 00 00       	jmp    141b0 <@InterlockedExchange@8>
   1355d:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   13560:	8b 53 40             	mov    0x40(%ebx),%edx
   13563:	83 e9 80             	sub    $0xffffff80,%ecx
   13566:	e8 45 0c 00 00       	call   141b0 <@InterlockedExchange@8>
   1356b:	8b 46 78             	mov    0x78(%esi),%eax
   1356e:	39 d8                	cmp    %ebx,%eax
   13570:	75 a7                	jne    13519 <_SpiRemoveActiveIrp+0x49>
   13572:	8b 53 44             	mov    0x44(%ebx),%edx
   13575:	8d 4e 78             	lea    0x78(%esi),%ecx
   13578:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1357b:	5b                   	pop    %ebx
   1357c:	5e                   	pop    %esi
   1357d:	5f                   	pop    %edi
   1357e:	5d                   	pop    %ebp
   1357f:	e9 2c 0c 00 00       	jmp    141b0 <@InterlockedExchange@8>
   13584:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   1358a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00013590 <_SpiStartIo>:

static VOID
SpiAddActiveIrp(PSCSI_PORT_DEVICE_EXTENSION DeviceExtension,
		PIRP Irp)
{
  PSCSI_PORT_LUN_EXTENSION LunExtension;
  PSCSI_REQUEST_BLOCK Srb;
  LunExtension = Irp->Tail.Overlay.DriverContext[2];
  Srb = Irp->Tail.Overlay.DriverContext[3];
  Irp->Tail.Overlay.DriverContext[0] = (PVOID)DeviceExtension->NextIrp;
  InterlockedExchangePointer(&DeviceExtension->NextIrp, Irp);
  Irp->Tail.Overlay.DriverContext[1] = (PVOID)LunExtension->NextIrp;
  InterlockedExchangePointer(&LunExtension->NextIrp, Irp);
}

static VOID
SpiProcessRequests(IN PSCSI_PORT_DEVICE_EXTENSION DeviceExtension, 
	           IN PIRP NextIrp)
{
  /*
   * Using of some fields from Srb and Irp while processing requests:
   *
   * NextIrp on entry:
   *   Srb->OriginalRequest -> LunExtension
   *   Irp->Tail.Overlay.DriverContext[3] -> original Srb
   *   IoStack->Parameters.Scsi.Srb -> original Srb
   *
   * Irp is within the pending irp list:
   *   Srb->OriginalRequest -> LunExtension
   *   Irp->Tail.Overlay.DriverContext[0] and DriverContext[1] -> ListEntry for queue
   *   Irp->Tail.Overlay.DriverContext[2] -> sort key (from Srb->QueueSortKey)
   *   Irp->Tail.Overlay.DriverContext[3] -> current Srb (original or sense request)
   *   IoStack->Parameters.Scsi.Srb -> original Srb
   *   
   * Irp is within the active irp list or while other processing:
   *   Srb->OriginalRequest -> Irp
   *   Irp->Tail.Overlay.DriverContext[0] -> next irp, DeviceExtension->NextIrp is head.
   *   Irp->Tail.Overlay.DriverContext[1] -> next irp, LunExtension->NextIrp is head.
   *   Irp->Tail.Overlay.DriverContext[2] -> LunExtension
   *   Irp->Tail.Overlay.DriverContext[3] -> current Srb (original or sense request)
   *   IoStack->Parameters.Scsi.Srb -> original Srb
   */
  PIO_STACK_LOCATION IrpStack;
  PSCSI_PORT_LUN_EXTENSION LunExtension;
  PLIST_ENTRY ListEntry;
  KIRQL oldIrql;
  PIRP Irp;
  LIST_ENTRY NextIrpListHead;
  LIST_ENTRY CompleteIrpListHead;
  PSCSI_REQUEST_BLOCK Srb;
  PSCSI_REQUEST_BLOCK OriginalSrb;
  PIRP PrevIrp;

  DPRINT("SpiProcessRequests() called\n");

  InitializeListHead(&NextIrpListHead);
  InitializeListHead(&CompleteIrpListHead);

  KeAcquireSpinLock(&DeviceExtension->Lock, &oldIrql);

  if (NextIrp)
    {
      Srb = NextIrp->Tail.Overlay.DriverContext[3];
      /* 
       * FIXME:
       *   Is this the right place to set this flag ?
       */
      NextIrp->Tail.Overlay.DriverContext[2] = (PVOID)Srb->QueueSortKey;
      LunExtension = Srb->OriginalRequest;

      ListEntry = DeviceExtension->PendingIrpListHead.Flink;
      while (ListEntry != &DeviceExtension->PendingIrpListHead)
        {
          Irp = CONTAINING_RECORD(ListEntry, IRP, Tail.Overlay.DriverContext[0]);
          if ((ULONG)Irp->Tail.Overlay.DriverContext[2] > Srb->QueueSortKey)
            {
              break;
	    }
          ListEntry = ListEntry->Flink;
	}
      InsertTailList(ListEntry, (PLIST_ENTRY)&NextIrp->Tail.Overlay.DriverContext[0]);
      DeviceExtension->PendingIrpCount++;
      LunExtension->PendingIrpCount++;
    }

  while (DeviceExtension->Flags & IRP_FLAG_COMPLETE ||
         (((DeviceExtension->SrbExtensionSize == 0 || DeviceExtension->CurrentSrbExtensions < DeviceExtension->MaxSrbExtensions) && 
	  DeviceExtension->PendingIrpCount > 0 &&
	  (DeviceExtension->Flags & (IRP_FLAG_NEXT|IRP_FLAG_NEXT_LU) || DeviceExtension->NextIrp == NULL))))
    {
      DPRINT ("RequestComplete %d, NextRequest %d, NextLuRequest %d, PendingIrpCount %d, ActiveIrpCount %d\n", 
	      DeviceExtension->Flags & IRP_FLAG_COMPLETE ? 1 : 0, 
	      DeviceExtension->Flags & IRP_FLAG_NEXT ? 1 : 0,
	      DeviceExtension->Flags & IRP_FLAG_NEXT_LU ? 1 : 0, 
	      DeviceExtension->PendingIrpCount, 
	      DeviceExtension->ActiveIrpCount);


      if (DeviceExtension->Flags & IRP_FLAG_COMPLETE)
        {
	  DeviceExtension->Flags &= ~IRP_FLAG_COMPLETE;
	  PrevIrp = NULL;
	  Irp = DeviceExtension->NextIrp;
	  while (Irp)
	    {
	      NextIrp = (PIRP)Irp->Tail.Overlay.DriverContext[0];
	      Srb = Irp->Tail.Overlay.DriverContext[3];
              if (!(Srb->SrbFlags & SRB_FLAGS_IS_ACTIVE))
	        {
                  BOOLEAN CompleteThisRequest;
                  LunExtension = Irp->Tail.Overlay.DriverContext[2];
		  IrpStack = IoGetCurrentIrpStackLocation(Irp);
		  OriginalSrb = IrpStack->Parameters.Scsi.Srb;

		  if (Srb->SrbStatus == SRB_STATUS_BUSY)
		    {
		      SpiRemoveActiveIrp(DeviceExtension, Irp, PrevIrp);
                      SpiFreeSrbExtension(DeviceExtension, OriginalSrb);
		      InsertHeadList(&DeviceExtension->PendingIrpListHead, (PLIST_ENTRY)&Irp->Tail.Overlay.DriverContext[0]);
		      DeviceExtension->PendingIrpCount++;
		      LunExtension->PendingIrpCount++;
		      Irp = NextIrp;
		      continue;
		    }

                  if (OriginalSrb != Srb)
	            {
	              SENSE_DATA* SenseInfoBuffer;

		      SenseInfoBuffer = Srb->DataBuffer;

	              DPRINT("Got sense data!\n");

	              DPRINT("Valid: %x\n", SenseInfoBuffer->Valid);
	              DPRINT("ErrorCode: %x\n", SenseInfoBuffer->ErrorCode);
	              DPRINT("SenseKey: %x\n", SenseInfoBuffer->SenseKey);
	              DPRINT("SenseCode: %x\n", SenseInfoBuffer->AdditionalSenseCode);
	      
	              /* Copy sense data */
                      RtlCopyMemory(OriginalSrb->SenseInfoBuffer,
		                    SenseInfoBuffer,
		                    sizeof(SENSE_DATA));
	              OriginalSrb->SrbStatus |= SRB_STATUS_AUTOSENSE_VALID;
		      ExFreePool(Srb);
		      CompleteThisRequest = TRUE;
		    }
		  else if (SRB_STATUS(Srb->SrbStatus) != SRB_STATUS_SUCCESS &&
	                   Srb->ScsiStatus == SCSISTAT_CHECK_CONDITION &&
	                   Srb->SenseInfoBuffer != NULL &&
	                   Srb->SenseInfoBufferLength >= sizeof(SENSE_DATA) &&
	                   !(Srb->SrbStatus & SRB_STATUS_AUTOSENSE_VALID))
	            {
	              DPRINT("SCSIOP_REQUEST_SENSE required!\n");

       	              Srb = ScsiPortInitSenseRequestSrb(OriginalSrb);

	              if (Srb)
	                {
			  CompleteThisRequest = FALSE;
			  Irp->Tail.Overlay.DriverContext[3] = Srb;
			  SpiRemoveActiveIrp(DeviceExtension, Irp, PrevIrp);
	                  SpiFreeSrbExtension(DeviceExtension, Srb);

                          Srb->OriginalRequest = LunExtension;
                          Irp->Tail.Overlay.DriverContext[2] = 0;

			  InsertHeadList(&DeviceExtension->PendingIrpListHead, (PLIST_ENTRY)&Irp->Tail.Overlay.DriverContext[0]);
			  DeviceExtension->PendingIrpCount++;
			  LunExtension->PendingIrpCount++;
			  Irp = NextIrp;
			  continue;
			}
		      else
		        {
			  CompleteThisRequest = TRUE;
			}
		    }
		  else
		    {
	              DPRINT("Complete Request\n");
		      CompleteThisRequest = TRUE;
		    }
		  if (CompleteThisRequest)
		    {
		      SpiRemoveActiveIrp(DeviceExtension, Irp, PrevIrp);
	              InsertHeadList(&CompleteIrpListHead, (PLIST_ENTRY)&Irp->Tail.Overlay.DriverContext[0]);
                      SpiFreeSrbExtension(DeviceExtension, OriginalSrb);
		    }
		  else
		    {
		      PrevIrp = Irp;
		    }
		  Irp = NextIrp;
		  continue;
		}	     
	      PrevIrp = Irp;
	      Irp = NextIrp;
	    }
	}
      if (!IsListEmpty(&CompleteIrpListHead))
        {
          KeReleaseSpinLockFromDpcLevel(&DeviceExtension->Lock);
	  while (!IsListEmpty(&CompleteIrpListHead))
	    {
	      ListEntry = RemoveTailList(&CompleteIrpListHead);
	      Irp = CONTAINING_RECORD(ListEntry, IRP, Tail.Overlay.DriverContext[0]);
	      IoCompleteRequest(Irp, IO_NO_INCREMENT);
	    }
	  KeAcquireSpinLockAtDpcLevel(&DeviceExtension->Lock);
        }
      if (DeviceExtension->Flags & (IRP_FLAG_NEXT|IRP_FLAG_NEXT_LU) &&
          (DeviceExtension->SrbExtensionSize == 0 || DeviceExtension->CurrentSrbExtensions < DeviceExtension->MaxSrbExtensions)) 
        {
	  BOOLEAN StartThisRequest;
	  ListEntry = DeviceExtension->PendingIrpListHead.Flink;
	  while (ListEntry != &DeviceExtension->PendingIrpListHead)
	    {
	      Irp = CONTAINING_RECORD(ListEntry, IRP, Tail.Overlay.DriverContext[0]);
	      ListEntry = ListEntry->Flink;
	      Srb = Irp->Tail.Overlay.DriverContext[3];
	      LunExtension = Srb->OriginalRequest;
	      if (DeviceExtension->SrbExtensionSize > 0 &&
		  DeviceExtension->CurrentSrbExtensions >= DeviceExtension->MaxSrbExtensions)
	        {
		  break;
		}
	      if (LunExtension->Flags & IRP_FLAG_NEXT_LU)
                {
		  StartThisRequest = TRUE;
		  LunExtension->Flags &= ~IRP_FLAG_NEXT_LU;
                  DeviceExtension->Flags &= ~IRP_FLAG_NEXT_LU;
		}
	      else if (DeviceExtension->Flags & IRP_FLAG_NEXT && 
		       LunExtension->ActiveIrpCount == 0)
	        {
		  StartThisRequest = TRUE;
                  DeviceExtension->Flags &= ~IRP_FLAG_NEXT;
		}
	      else
	        {
		  StartThisRequest = FALSE;
		}
	      if (StartThisRequest)
	        {
		  LunExtension->PendingIrpCount--;
		  DeviceExtension->PendingIrpCount--;
		  Srb->SrbFlags |= SRB_FLAGS_IS_ACTIVE;
                  LunExtension->ActiveIrpCount++;
                  DeviceExtension->ActiveIrpCount++;

                  RemoveEntryList((PLIST_ENTRY)&Irp->Tail.Overlay.DriverContext[0]);
		  Irp->Tail.Overlay.DriverContext[2] = LunExtension;
		  Srb->OriginalRequest = Irp;
		  SpiAllocateSrbExtension(DeviceExtension, Srb);

                  InsertHeadList(&NextIrpListHead, (PLIST_ENTRY)&Irp->Tail.Overlay.DriverContext[0]);		   
		}
	    }
	}

      if (!IsListEmpty(&NextIrpListHead))
        {
	  while (!IsListEmpty(&NextIrpListHead))
	    {
	      ListEntry = RemoveTailList(&NextIrpListHead);
	      Irp = CONTAINING_RECORD(ListEntry, IRP, Tail.Overlay.DriverContext[0]);
	      KeReleaseSpinLockFromDpcLevel(&DeviceExtension->Lock);

	      // Start this Irp
	      SpiStartIo(DeviceExtension, Irp);
	      KeAcquireSpinLockAtDpcLevel(&DeviceExtension->Lock);
	    }
	}

      if (!IsListEmpty(&DeviceExtension->PendingIrpListHead) &&
	  DeviceExtension->NextIrp == NULL &&
	  (DeviceExtension->SrbExtensionSize == 0 || DeviceExtension->CurrentSrbExtensions < DeviceExtension->MaxSrbExtensions))
        {
	  ListEntry = RemoveHeadList(&DeviceExtension->PendingIrpListHead);
          Irp = CONTAINING_RECORD(ListEntry, IRP, Tail.Overlay.DriverContext[0]);
          Srb = Irp->Tail.Overlay.DriverContext[3];
	  LunExtension = Srb->OriginalRequest;
	  Irp->Tail.Overlay.DriverContext[2] = LunExtension;
	  Srb->OriginalRequest = Irp;

	  LunExtension->PendingIrpCount--;
	  DeviceExtension->PendingIrpCount--;
          Srb->SrbFlags |= SRB_FLAGS_IS_ACTIVE;
	  LunExtension->ActiveIrpCount++;
          DeviceExtension->ActiveIrpCount++;

	  SpiAllocateSrbExtension(DeviceExtension, Srb);
          KeReleaseSpinLockFromDpcLevel(&DeviceExtension->Lock);

          /* Start this irp */
          SpiStartIo(DeviceExtension, Irp);
	  KeAcquireSpinLockAtDpcLevel(&DeviceExtension->Lock);
        }
     }
   KeReleaseSpinLock(&DeviceExtension->Lock, oldIrql);

   DPRINT("SpiProcessRequests() done\n");
 }

static VOID
SpiStartIo(IN PSCSI_PORT_DEVICE_EXTENSION DeviceExtension,
	   IN PIRP Irp)
{
   13590:	55                   	push   %ebp
   13591:	89 e5                	mov    %esp,%ebp
   13593:	57                   	push   %edi
   13594:	56                   	push   %esi
   13595:	53                   	push   %ebx
   13596:	83 ec 0c             	sub    $0xc,%esp
   13599:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   1359c:	89 d3                	mov    %edx,%ebx
  PSCSI_PORT_LUN_EXTENSION LunExtension;
  PSCSI_REQUEST_BLOCK Srb;

  DPRINT("SpiStartIo() called!\n");

  assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
   1359e:	e8 8d 0d 00 00       	call   14330 <_KeGetCurrentIrql@0>
   135a3:	3c 02                	cmp    $0x2,%al
   135a5:	74 19                	je     135c0 <_SpiStartIo+0x30>
   135a7:	68 e8 51 01 00       	push   $0x151e8
   135ac:	68 11 0c 00 00       	push   $0xc11
   135b1:	68 11 50 01 00       	push   $0x15011
   135b6:	68 e8 55 01 00       	push   $0x155e8
   135bb:	e8 00 0c 00 00       	call   141c0 <_RtlAssert@16>

  Srb = Irp->Tail.Overlay.DriverContext[3];
   135c0:	8b 7b 4c             	mov    0x4c(%ebx),%edi
   135c3:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
  LunExtension = Irp->Tail.Overlay.DriverContext[2];

  Irp->IoStatus.Status = STATUS_SUCCESS;
   135c6:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
   135cd:	8b 73 48             	mov    0x48(%ebx),%esi
  Irp->IoStatus.Information = Srb->DataTransferLength;
   135d0:	8b 47 10             	mov    0x10(%edi),%eax
   135d3:	89 d1                	mov    %edx,%ecx
   135d5:	89 43 1c             	mov    %eax,0x1c(%ebx)
   135d8:	8b 82 80 00 00 00    	mov    0x80(%edx),%eax
   135de:	83 e9 80             	sub    $0xffffff80,%ecx
   135e1:	89 da                	mov    %ebx,%edx
   135e3:	89 43 40             	mov    %eax,0x40(%ebx)
   135e6:	e8 c5 0b 00 00       	call   141b0 <@InterlockedExchange@8>
   135eb:	8b 46 78             	mov    0x78(%esi),%eax
   135ee:	8d 4e 78             	lea    0x78(%esi),%ecx
   135f1:	89 da                	mov    %ebx,%edx
   135f3:	89 43 44             	mov    %eax,0x44(%ebx)
   135f6:	e8 b5 0b 00 00       	call   141b0 <@InterlockedExchange@8>

  SpiAddActiveIrp(DeviceExtension, Irp);

  if (!KeSynchronizeExecution(DeviceExtension->Interrupt,
   135fb:	56                   	push   %esi
   135fc:	57                   	push   %edi
   135fd:	68 90 19 01 00       	push   $0x11990
   13602:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   13605:	8b 48 18             	mov    0x18(%eax),%ecx
   13608:	51                   	push   %ecx
   13609:	e8 c2 0b 00 00       	call   141d0 <_KeSynchronizeExecution@12>
   1360e:	5a                   	pop    %edx
   1360f:	84 c0                	test   %al,%al
   13611:	74 0d                	je     13620 <_SpiStartIo+0x90>
			      ScsiPortStartPacket,
                              Srb))
    {
      DPRINT1("Synchronization failed!\n");
      DPRINT1("Irp %x, Srb->Function %02x, Srb->Cdb[0] %02x, Srb->SrbStatus %02x\n", Irp, Srb->Function, Srb->Cdb[0], Srb->SrbStatus);
      ScsiPortNotification(RequestComplete,
	                   &DeviceExtension->MiniPortDeviceExtension, 
			   Srb);
    }

  DPRINT("SpiStartIo() done\n");
}
   13613:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13616:	5b                   	pop    %ebx
   13617:	5e                   	pop    %esi
   13618:	5f                   	pop    %edi
   13619:	5d                   	pop    %ebp
   1361a:	c3                   	ret    
   1361b:	90                   	nop    
   1361c:	8d 74 26 00          	lea    0x0(%esi),%esi
   13620:	50                   	push   %eax
   13621:	68 1f 0c 00 00       	push   $0xc1f
   13626:	68 11 50 01 00       	push   $0x15011
   1362b:	68 54 50 01 00       	push   $0x15054
   13630:	e8 5b 0c 00 00       	call   14290 <_DbgPrint>
   13635:	c7 04 24 eb 55 01 00 	movl   $0x155eb,(%esp)
   1363c:	e8 4f 0c 00 00       	call   14290 <_DbgPrint>
   13641:	83 c4 0c             	add    $0xc,%esp
   13644:	68 20 0c 00 00       	push   $0xc20
   13649:	68 11 50 01 00       	push   $0x15011
   1364e:	68 54 50 01 00       	push   $0x15054
   13653:	e8 38 0c 00 00       	call   14290 <_DbgPrint>
   13658:	31 c0                	xor    %eax,%eax
   1365a:	8a 47 03             	mov    0x3(%edi),%al
   1365d:	89 04 24             	mov    %eax,(%esp)
   13660:	31 c0                	xor    %eax,%eax
   13662:	8a 47 30             	mov    0x30(%edi),%al
   13665:	50                   	push   %eax
   13666:	31 c0                	xor    %eax,%eax
   13668:	8a 47 02             	mov    0x2(%edi),%al
   1366b:	50                   	push   %eax
   1366c:	53                   	push   %ebx
   1366d:	68 04 56 01 00       	push   $0x15604
   13672:	e8 19 0c 00 00       	call   14290 <_DbgPrint>
   13677:	83 c4 1c             	add    $0x1c,%esp
   1367a:	57                   	push   %edi
   1367b:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   1367e:	05 8c 00 00 00       	add    $0x8c,%eax
   13683:	50                   	push   %eax
   13684:	6a 00                	push   $0x0
   13686:	e8 c5 05 00 00       	call   13c50 <_ScsiPortNotification>
   1368b:	83 c4 10             	add    $0x10,%esp
   1368e:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13691:	5b                   	pop    %ebx
   13692:	5e                   	pop    %esi
   13693:	5f                   	pop    %edi
   13694:	5d                   	pop    %ebp
   13695:	c3                   	ret    
   13696:	8d 76 00             	lea    0x0(%esi),%esi
   13699:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000136a0 <_SpiProcessRequests>:
   136a0:	55                   	push   %ebp
   136a1:	89 e5                	mov    %esp,%ebp
   136a3:	57                   	push   %edi
   136a4:	56                   	push   %esi
   136a5:	53                   	push   %ebx
   136a6:	83 ec 54             	sub    $0x54,%esp
   136a9:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
   136ac:	8b 4d d8             	mov    0xffffffd8(%ebp),%ecx
 */
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
   136af:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
   136b2:	83 c1 10             	add    $0x10,%ecx
   136b5:	89 d3                	mov    %edx,%ebx
 */
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
   136b7:	89 45 b4             	mov    %eax,0xffffffb4(%ebp)
   136ba:	8d 55 e0             	lea    0xffffffe0(%ebp),%edx
	ListHead->Flink = ListHead->Blink = ListHead;
   136bd:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   136c0:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   136c3:	8d 45 df             	lea    0xffffffdf(%ebp),%eax
   136c6:	89 4d bc             	mov    %ecx,0xffffffbc(%ebp)
   136c9:	50                   	push   %eax
 */
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
   136ca:	89 55 b8             	mov    %edx,0xffffffb8(%ebp)
   136cd:	51                   	push   %ecx
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
	ListHead->Flink = ListHead->Blink = ListHead;
   136ce:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
   136d1:	89 55 e0             	mov    %edx,0xffffffe0(%ebp)
   136d4:	e8 67 0c 00 00       	call   14340 <_KeAcquireSpinLock@8>
   136d9:	85 db                	test   %ebx,%ebx
   136db:	59                   	pop    %ecx
   136dc:	5e                   	pop    %esi
   136dd:	74 68                	je     13747 <_SpiProcessRequests+0xa7>
   136df:	8b 7b 4c             	mov    0x4c(%ebx),%edi
   136e2:	8b 47 2c             	mov    0x2c(%edi),%eax
   136e5:	89 43 48             	mov    %eax,0x48(%ebx)
   136e8:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
   136eb:	8b 4d d8             	mov    0xffffffd8(%ebp),%ecx
   136ee:	83 c1 78             	add    $0x78,%ecx
   136f1:	8b 47 24             	mov    0x24(%edi),%eax
   136f4:	8b 52 78             	mov    0x78(%edx),%edx
   136f7:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
   136fa:	89 55 d0             	mov    %edx,0xffffffd0(%ebp)
   136fd:	89 4d c0             	mov    %ecx,0xffffffc0(%ebp)
   13700:	39 d1                	cmp    %edx,%ecx
   13702:	74 15                	je     13719 <_SpiProcessRequests+0x79>
   13704:	8b 47 2c             	mov    0x2c(%edi),%eax
   13707:	8b 55 d0             	mov    0xffffffd0(%ebp),%edx
   1370a:	39 42 08             	cmp    %eax,0x8(%edx)
   1370d:	77 0a                	ja     13719 <_SpiProcessRequests+0x79>
   1370f:	8b 0a                	mov    (%edx),%ecx
   13711:	89 4d d0             	mov    %ecx,0xffffffd0(%ebp)
   13714:	39 4d c0             	cmp    %ecx,0xffffffc0(%ebp)
   13717:	75 ee                	jne    13707 <_SpiProcessRequests+0x67>
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
   13719:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
   1371c:	8d 43 40             	lea    0x40(%ebx),%eax
	Entry->Flink = ListHead;
   1371f:	89 4b 40             	mov    %ecx,0x40(%ebx)
   13722:	8b 51 04             	mov    0x4(%ecx),%edx
	Entry->Blink = OldBlink;
   13725:	89 50 04             	mov    %edx,0x4(%eax)
	OldBlink->Flink = Entry;
	ListHead->Blink = Entry;
   13728:	89 41 04             	mov    %eax,0x4(%ecx)
   1372b:	89 02                	mov    %eax,(%edx)
   1372d:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   13730:	8b 90 84 00 00 00    	mov    0x84(%eax),%edx
   13736:	42                   	inc    %edx
   13737:	89 90 84 00 00 00    	mov    %edx,0x84(%eax)
   1373d:	8b 55 d4             	mov    0xffffffd4(%ebp),%edx
   13740:	8b 42 70             	mov    0x70(%edx),%eax
   13743:	40                   	inc    %eax
   13744:	89 42 70             	mov    %eax,0x70(%edx)
   13747:	8b 4d d8             	mov    0xffffffd8(%ebp),%ecx
   1374a:	8b 51 14             	mov    0x14(%ecx),%edx
   1374d:	f6 c2 01             	test   $0x1,%dl
   13750:	75 3e                	jne    13790 <_SpiProcessRequests+0xf0>
   13752:	8b 59 38             	mov    0x38(%ecx),%ebx
   13755:	85 db                	test   %ebx,%ebx
   13757:	74 0c                	je     13765 <_SpiProcessRequests+0xc5>
   13759:	8b 41 6c             	mov    0x6c(%ecx),%eax
   1375c:	39 41 70             	cmp    %eax,0x70(%ecx)
   1375f:	0f 83 d1 04 00 00    	jae    13c36 <_SpiProcessRequests+0x596>
   13765:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   13768:	8b 88 84 00 00 00    	mov    0x84(%eax),%ecx
   1376e:	85 c9                	test   %ecx,%ecx
   13770:	0f 84 c0 04 00 00    	je     13c36 <_SpiProcessRequests+0x596>
   13776:	f6 c2 06             	test   $0x6,%dl
   13779:	75 15                	jne    13790 <_SpiProcessRequests+0xf0>
   1377b:	8b 80 80 00 00 00    	mov    0x80(%eax),%eax
   13781:	85 c0                	test   %eax,%eax
   13783:	0f 85 ad 04 00 00    	jne    13c36 <_SpiProcessRequests+0x596>
   13789:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   13790:	8b 4d d8             	mov    0xffffffd8(%ebp),%ecx
   13793:	83 c1 78             	add    $0x78,%ecx
   13796:	89 4d c0             	mov    %ecx,0xffffffc0(%ebp)
   13799:	f6 c2 01             	test   $0x1,%dl
   1379c:	0f 84 ca 00 00 00    	je     1386c <_SpiProcessRequests+0x1cc>
   137a2:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   137a5:	83 e2 fe             	and    $0xfffffffe,%edx
   137a8:	c7 45 c8 00 00 00 00 	movl   $0x0,0xffffffc8(%ebp)
   137af:	8b b0 80 00 00 00    	mov    0x80(%eax),%esi
   137b5:	89 50 14             	mov    %edx,0x14(%eax)
   137b8:	85 f6                	test   %esi,%esi
   137ba:	0f 84 ac 00 00 00    	je     1386c <_SpiProcessRequests+0x1cc>
   137c0:	8b 7e 4c             	mov    0x4c(%esi),%edi
   137c3:	8b 5e 40             	mov    0x40(%esi),%ebx
   137c6:	f6 47 0e 01          	testb  $0x1,0xe(%edi)
   137ca:	0f 85 10 02 00 00    	jne    139e0 <_SpiProcessRequests+0x340>
   137d0:	8b 46 48             	mov    0x48(%esi),%eax
   137d3:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
   137d6:	8b 46 60             	mov    0x60(%esi),%eax
   137d9:	8b 40 04             	mov    0x4(%eax),%eax
   137dc:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
   137df:	8a 57 03             	mov    0x3(%edi),%dl
   137e2:	80 fa 05             	cmp    $0x5,%dl
   137e5:	0f 84 2d 04 00 00    	je     13c18 <_SpiProcessRequests+0x578>
   137eb:	39 7d cc             	cmp    %edi,0xffffffcc(%ebp)
   137ee:	0f 84 0d 03 00 00    	je     13b01 <_SpiProcessRequests+0x461>
   137f4:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
   137f7:	8b 57 18             	mov    0x18(%edi),%edx
   137fa:	83 ec 0c             	sub    $0xc,%esp
   137fd:	8b 48 1c             	mov    0x1c(%eax),%ecx
   13800:	8b 02                	mov    (%edx),%eax
   13802:	89 01                	mov    %eax,(%ecx)
   13804:	8b 42 04             	mov    0x4(%edx),%eax
   13807:	89 41 04             	mov    %eax,0x4(%ecx)
   1380a:	8b 42 08             	mov    0x8(%edx),%eax
   1380d:	89 41 08             	mov    %eax,0x8(%ecx)
   13810:	8b 42 0c             	mov    0xc(%edx),%eax
   13813:	89 41 0c             	mov    %eax,0xc(%ecx)
   13816:	66 8b 42 10          	mov    0x10(%edx),%ax
   1381a:	66 89 41 10          	mov    %ax,0x10(%ecx)
   1381e:	8b 55 cc             	mov    0xffffffcc(%ebp),%edx
   13821:	80 4a 03 80          	orb    $0x80,0x3(%edx)
   13825:	57                   	push   %edi
   13826:	e8 95 07 00 00       	call   13fc0 <_ExFreePool@4>
   1382b:	83 c4 0c             	add    $0xc,%esp
   1382e:	83 ec 0c             	sub    $0xc,%esp
   13831:	8b 45 c8             	mov    0xffffffc8(%ebp),%eax
   13834:	89 f2                	mov    %esi,%edx
   13836:	50                   	push   %eax
   13837:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   1383a:	e8 91 fc ff ff       	call   134d0 <_SpiRemoveActiveIrp>
static __inline VOID
InsertHeadList(
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
   1383f:	8d 46 40             	lea    0x40(%esi),%eax
	PLIST_ENTRY OldFlink;
	OldFlink = ListHead->Flink;
   13842:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
	Entry->Flink = OldFlink;
	Entry->Blink = ListHead;
   13845:	8b 4d b8             	mov    0xffffffb8(%ebp),%ecx
   13848:	89 56 40             	mov    %edx,0x40(%esi)
   1384b:	89 48 04             	mov    %ecx,0x4(%eax)
   1384e:	83 c4 10             	add    $0x10,%esp
	OldFlink->Blink = Entry;
   13851:	89 42 04             	mov    %eax,0x4(%edx)
	ListHead->Flink = Entry;
   13854:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   13857:	8b 55 cc             	mov    0xffffffcc(%ebp),%edx
   1385a:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   1385d:	89 de                	mov    %ebx,%esi
   1385f:	e8 cc e0 ff ff       	call   11930 <_SpiFreeSrbExtension>
   13864:	85 db                	test   %ebx,%ebx
   13866:	0f 85 54 ff ff ff    	jne    137c0 <_SpiProcessRequests+0x120>
   1386c:	8b 45 b8             	mov    0xffffffb8(%ebp),%eax
   1386f:	39 45 e0             	cmp    %eax,0xffffffe0(%ebp)
   13872:	74 50                	je     138c4 <_SpiProcessRequests+0x224>
   13874:	83 ec 0c             	sub    $0xc,%esp
   13877:	8b 45 bc             	mov    0xffffffbc(%ebp),%eax
   1387a:	50                   	push   %eax
   1387b:	e8 60 09 00 00       	call   141e0 <_KeReleaseSpinLockFromDpcLevel@4>
   13880:	8b 55 b8             	mov    0xffffffb8(%ebp),%edx
   13883:	83 c4 0c             	add    $0xc,%esp
   13886:	39 55 e0             	cmp    %edx,0xffffffe0(%ebp)
   13889:	74 2a                	je     138b5 <_SpiProcessRequests+0x215>
   1388b:	8d 5d e0             	lea    0xffffffe0(%ebp),%ebx
   1388e:	89 f6                	mov    %esi,%esi
{
  PLIST_ENTRY Blink;
  PLIST_ENTRY Entry;

  Entry = ListHead->Blink;
   13890:	8b 4d b8             	mov    0xffffffb8(%ebp),%ecx
   13893:	8b 51 04             	mov    0x4(%ecx),%edx
  Blink = Entry->Blink;
   13896:	8b 42 04             	mov    0x4(%edx),%eax
   13899:	8d 72 c0             	lea    0xffffffc0(%edx),%esi
  PLIST_ENTRY Entry;

  Entry = ListHead->Blink;
  Blink = Entry->Blink;
  ListHead->Blink = Blink;
   1389c:	89 41 04             	mov    %eax,0x4(%ecx)
  Blink->Flink = ListHead;
   1389f:	89 08                	mov    %ecx,(%eax)
   138a1:	50                   	push   %eax
   138a2:	50                   	push   %eax
   138a3:	6a 00                	push   $0x0
   138a5:	56                   	push   %esi
   138a6:	e8 a5 07 00 00       	call   14050 <_IoCompleteRequest@8>
   138ab:	89 5d b8             	mov    %ebx,0xffffffb8(%ebp)
   138ae:	5f                   	pop    %edi
   138af:	39 5d e0             	cmp    %ebx,0xffffffe0(%ebp)
   138b2:	58                   	pop    %eax
   138b3:	75 db                	jne    13890 <_SpiProcessRequests+0x1f0>
   138b5:	83 ec 0c             	sub    $0xc,%esp
   138b8:	8b 75 bc             	mov    0xffffffbc(%ebp),%esi
   138bb:	56                   	push   %esi
   138bc:	e8 2f 09 00 00       	call   141f0 <_KeAcquireSpinLockAtDpcLevel@4>
   138c1:	83 c4 0c             	add    $0xc,%esp
   138c4:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   138c7:	f6 40 14 06          	testb  $0x6,0x14(%eax)
   138cb:	0f 84 1f 01 00 00    	je     139f0 <_SpiProcessRequests+0x350>
   138d1:	8b 50 38             	mov    0x38(%eax),%edx
   138d4:	85 d2                	test   %edx,%edx
   138d6:	74 0e                	je     138e6 <_SpiProcessRequests+0x246>
   138d8:	89 c1                	mov    %eax,%ecx
   138da:	8b 40 6c             	mov    0x6c(%eax),%eax
   138dd:	39 41 70             	cmp    %eax,0x70(%ecx)
   138e0:	0f 83 0a 01 00 00    	jae    139f0 <_SpiProcessRequests+0x350>
   138e6:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   138e9:	8b 40 78             	mov    0x78(%eax),%eax
   138ec:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
	OldFlink = ListHead->Flink;
	Entry->Flink = OldFlink;
	Entry->Blink = ListHead;
	OldFlink->Blink = Entry;
	ListHead->Flink = Entry;
   138ef:	39 45 c0             	cmp    %eax,0xffffffc0(%ebp)
   138f2:	0f 85 95 00 00 00    	jne    1398d <_SpiProcessRequests+0x2ed>
   138f8:	e9 f3 00 00 00       	jmp    139f0 <_SpiProcessRequests+0x350>
   138fd:	8d 76 00             	lea    0x0(%esi),%esi
   13900:	83 e0 fb             	and    $0xfffffffb,%eax
   13903:	89 41 7c             	mov    %eax,0x7c(%ecx)
   13906:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   13909:	8b 58 14             	mov    0x14(%eax),%ebx
   1390c:	83 e3 fb             	and    $0xfffffffb,%ebx
   1390f:	89 58 14             	mov    %ebx,0x14(%eax)
   13912:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
   13915:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
   13918:	8b 58 70             	mov    0x70(%eax),%ebx
   1391b:	4b                   	dec    %ebx
   1391c:	89 58 70             	mov    %ebx,0x70(%eax)
   1391f:	8b 8a 84 00 00 00    	mov    0x84(%edx),%ecx
   13925:	49                   	dec    %ecx
   13926:	89 8a 84 00 00 00    	mov    %ecx,0x84(%edx)
   1392c:	8b 5f 0c             	mov    0xc(%edi),%ebx
   1392f:	81 cb 00 00 01 00    	or     $0x10000,%ebx
   13935:	89 5f 0c             	mov    %ebx,0xc(%edi)
 */
static __inline BOOLEAN
RemoveEntryList(
  IN PLIST_ENTRY  Entry)
{
   13938:	8d 5e 40             	lea    0x40(%esi),%ebx
   1393b:	8b 48 74             	mov    0x74(%eax),%ecx
   1393e:	41                   	inc    %ecx
   1393f:	89 48 74             	mov    %ecx,0x74(%eax)
   13942:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
   13945:	8b 82 88 00 00 00    	mov    0x88(%edx),%eax
   1394b:	40                   	inc    %eax
   1394c:	89 82 88 00 00 00    	mov    %eax,0x88(%edx)
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
  OldBlink = Entry->Blink;
   13952:	8b 43 04             	mov    0x4(%ebx),%eax
   13955:	8b 56 40             	mov    0x40(%esi),%edx
  OldFlink->Blink = OldBlink;
  OldBlink->Flink = OldFlink;
   13958:	89 10                	mov    %edx,(%eax)
   1395a:	89 42 04             	mov    %eax,0x4(%edx)
   1395d:	89 4e 48             	mov    %ecx,0x48(%esi)
   13960:	89 fa                	mov    %edi,%edx
   13962:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   13965:	89 77 24             	mov    %esi,0x24(%edi)
   13968:	e8 63 df ff ff       	call   118d0 <_SpiAllocateSrbExtension>
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldFlink;
	OldFlink = ListHead->Flink;
   1396d:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
	Entry->Flink = OldFlink;
	Entry->Blink = ListHead;
   13970:	8b 55 b4             	mov    0xffffffb4(%ebp),%edx
   13973:	89 46 40             	mov    %eax,0x40(%esi)
   13976:	89 53 04             	mov    %edx,0x4(%ebx)
	OldFlink->Blink = Entry;
	ListHead->Flink = Entry;
   13979:	89 5d e8             	mov    %ebx,0xffffffe8(%ebp)
   1397c:	89 58 04             	mov    %ebx,0x4(%eax)
   1397f:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
   13982:	39 4d c0             	cmp    %ecx,0xffffffc0(%ebp)
   13985:	74 69                	je     139f0 <_SpiProcessRequests+0x350>
   13987:	8b 4d d8             	mov    0xffffffd8(%ebp),%ecx
   1398a:	8b 51 38             	mov    0x38(%ecx),%edx
   1398d:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
   13990:	8b 75 d0             	mov    0xffffffd0(%ebp),%esi
   13993:	83 ee 40             	sub    $0x40,%esi
   13996:	85 d2                	test   %edx,%edx
   13998:	8b 00                	mov    (%eax),%eax
   1399a:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
   1399d:	8b 7e 4c             	mov    0x4c(%esi),%edi
   139a0:	8b 4f 24             	mov    0x24(%edi),%ecx
   139a3:	89 4d d4             	mov    %ecx,0xffffffd4(%ebp)
   139a6:	74 0b                	je     139b3 <_SpiProcessRequests+0x313>
   139a8:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
   139ab:	8b 42 6c             	mov    0x6c(%edx),%eax
   139ae:	39 42 70             	cmp    %eax,0x70(%edx)
   139b1:	73 3d                	jae    139f0 <_SpiProcessRequests+0x350>
   139b3:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
   139b6:	8b 41 7c             	mov    0x7c(%ecx),%eax
   139b9:	a8 04                	test   $0x4,%al
   139bb:	0f 85 3f ff ff ff    	jne    13900 <_SpiProcessRequests+0x260>
   139c1:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
   139c4:	8b 42 14             	mov    0x14(%edx),%eax
   139c7:	a8 02                	test   $0x2,%al
   139c9:	74 b4                	je     1397f <_SpiProcessRequests+0x2df>
   139cb:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
   139ce:	8b 49 74             	mov    0x74(%ecx),%ecx
   139d1:	85 c9                	test   %ecx,%ecx
   139d3:	75 aa                	jne    1397f <_SpiProcessRequests+0x2df>
   139d5:	83 e0 fd             	and    $0xfffffffd,%eax
   139d8:	89 42 14             	mov    %eax,0x14(%edx)
   139db:	e9 32 ff ff ff       	jmp    13912 <_SpiProcessRequests+0x272>
   139e0:	89 75 c8             	mov    %esi,0xffffffc8(%ebp)
   139e3:	85 db                	test   %ebx,%ebx
   139e5:	89 de                	mov    %ebx,%esi
   139e7:	e9 7a fe ff ff       	jmp    13866 <_SpiProcessRequests+0x1c6>
   139ec:	8d 74 26 00          	lea    0x0(%esi),%esi
   139f0:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
   139f3:	39 45 e8             	cmp    %eax,0xffffffe8(%ebp)
   139f6:	74 49                	je     13a41 <_SpiProcessRequests+0x3a1>
   139f8:	8d 5d e8             	lea    0xffffffe8(%ebp),%ebx
   139fb:	90                   	nop    
   139fc:	8d 74 26 00          	lea    0x0(%esi),%esi
{
  PLIST_ENTRY Blink;
  PLIST_ENTRY Entry;

  Entry = ListHead->Blink;
   13a00:	8b 4d b4             	mov    0xffffffb4(%ebp),%ecx
   13a03:	83 ec 0c             	sub    $0xc,%esp
{
  PLIST_ENTRY Blink;
  PLIST_ENTRY Entry;

  Entry = ListHead->Blink;
   13a06:	8b 51 04             	mov    0x4(%ecx),%edx
  Blink = Entry->Blink;
   13a09:	8b 42 04             	mov    0x4(%edx),%eax
   13a0c:	8d 72 c0             	lea    0xffffffc0(%edx),%esi
  PLIST_ENTRY Entry;

  Entry = ListHead->Blink;
  Blink = Entry->Blink;
  ListHead->Blink = Blink;
   13a0f:	89 41 04             	mov    %eax,0x4(%ecx)
  Blink->Flink = ListHead;
   13a12:	89 08                	mov    %ecx,(%eax)
   13a14:	8b 45 bc             	mov    0xffffffbc(%ebp),%eax
   13a17:	50                   	push   %eax
   13a18:	e8 c3 07 00 00       	call   141e0 <_KeReleaseSpinLockFromDpcLevel@4>
   13a1d:	89 f2                	mov    %esi,%edx
   13a1f:	83 c4 0c             	add    $0xc,%esp
   13a22:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   13a25:	e8 66 fb ff ff       	call   13590 <_SpiStartIo>
   13a2a:	83 ec 0c             	sub    $0xc,%esp
   13a2d:	8b 45 bc             	mov    0xffffffbc(%ebp),%eax
   13a30:	50                   	push   %eax
   13a31:	e8 ba 07 00 00       	call   141f0 <_KeAcquireSpinLockAtDpcLevel@4>
   13a36:	89 5d b4             	mov    %ebx,0xffffffb4(%ebp)
   13a39:	83 c4 0c             	add    $0xc,%esp
   13a3c:	39 5d e8             	cmp    %ebx,0xffffffe8(%ebp)
   13a3f:	75 bf                	jne    13a00 <_SpiProcessRequests+0x360>
   13a41:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   13a44:	8b 50 78             	mov    0x78(%eax),%edx
   13a47:	3b 55 c0             	cmp    0xffffffc0(%ebp),%edx
   13a4a:	0f 84 f7 fc ff ff    	je     13747 <_SpiProcessRequests+0xa7>
   13a50:	8b b8 80 00 00 00    	mov    0x80(%eax),%edi
   13a56:	85 ff                	test   %edi,%edi
   13a58:	0f 85 e9 fc ff ff    	jne    13747 <_SpiProcessRequests+0xa7>
   13a5e:	8b 70 38             	mov    0x38(%eax),%esi
   13a61:	85 f6                	test   %esi,%esi
   13a63:	74 0e                	je     13a73 <_SpiProcessRequests+0x3d3>
   13a65:	89 c1                	mov    %eax,%ecx
   13a67:	8b 40 6c             	mov    0x6c(%eax),%eax
   13a6a:	39 41 70             	cmp    %eax,0x70(%ecx)
   13a6d:	0f 83 d4 fc ff ff    	jae    13747 <_SpiProcessRequests+0xa7>
  PLIST_ENTRY Entry;

  Entry = ListHead->Flink;
  Flink = Entry->Flink;
  ListHead->Flink = Flink;
   13a73:	8b 4d d8             	mov    0xffffffd8(%ebp),%ecx
   13a76:	8b 02                	mov    (%edx),%eax
   13a78:	8d 72 c0             	lea    0xffffffc0(%edx),%esi
  PLIST_ENTRY Entry;

  Entry = ListHead->Flink;
  Flink = Entry->Flink;
  ListHead->Flink = Flink;
   13a7b:	89 41 78             	mov    %eax,0x78(%ecx)
  Flink->Blink = ListHead;
   13a7e:	8b 4d c0             	mov    0xffffffc0(%ebp),%ecx
   13a81:	89 48 04             	mov    %ecx,0x4(%eax)
   13a84:	8b 7e 4c             	mov    0x4c(%esi),%edi
   13a87:	8b 47 24             	mov    0x24(%edi),%eax
   13a8a:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
   13a8d:	89 46 48             	mov    %eax,0x48(%esi)
   13a90:	8b 58 70             	mov    0x70(%eax),%ebx
   13a93:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
   13a96:	4b                   	dec    %ebx
   13a97:	89 77 24             	mov    %esi,0x24(%edi)
   13a9a:	89 58 70             	mov    %ebx,0x70(%eax)
   13a9d:	8b 8a 84 00 00 00    	mov    0x84(%edx),%ecx
   13aa3:	49                   	dec    %ecx
   13aa4:	89 8a 84 00 00 00    	mov    %ecx,0x84(%edx)
   13aaa:	8b 5f 0c             	mov    0xc(%edi),%ebx
   13aad:	81 cb 00 00 01 00    	or     $0x10000,%ebx
   13ab3:	89 5f 0c             	mov    %ebx,0xc(%edi)
   13ab6:	8b 48 74             	mov    0x74(%eax),%ecx
   13ab9:	41                   	inc    %ecx
   13aba:	89 48 74             	mov    %ecx,0x74(%eax)
   13abd:	8b 82 88 00 00 00    	mov    0x88(%edx),%eax
   13ac3:	40                   	inc    %eax
   13ac4:	89 82 88 00 00 00    	mov    %eax,0x88(%edx)
   13aca:	89 fa                	mov    %edi,%edx
   13acc:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   13acf:	e8 fc dd ff ff       	call   118d0 <_SpiAllocateSrbExtension>
   13ad4:	83 ec 0c             	sub    $0xc,%esp
   13ad7:	8b 7d bc             	mov    0xffffffbc(%ebp),%edi
   13ada:	57                   	push   %edi
   13adb:	e8 00 07 00 00       	call   141e0 <_KeReleaseSpinLockFromDpcLevel@4>
   13ae0:	89 f2                	mov    %esi,%edx
   13ae2:	83 c4 0c             	add    $0xc,%esp
   13ae5:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   13ae8:	e8 a3 fa ff ff       	call   13590 <_SpiStartIo>
   13aed:	83 ec 0c             	sub    $0xc,%esp
   13af0:	8b 75 bc             	mov    0xffffffbc(%ebp),%esi
   13af3:	56                   	push   %esi
   13af4:	e8 f7 06 00 00       	call   141f0 <_KeAcquireSpinLockAtDpcLevel@4>
   13af9:	83 c4 0c             	add    $0xc,%esp
   13afc:	e9 46 fc ff ff       	jmp    13747 <_SpiProcessRequests+0xa7>
   13b01:	89 d0                	mov    %edx,%eax
   13b03:	83 e0 3f             	and    $0x3f,%eax
   13b06:	48                   	dec    %eax
   13b07:	0f 84 21 fd ff ff    	je     1382e <_SpiProcessRequests+0x18e>
   13b0d:	80 7f 04 02          	cmpb   $0x2,0x4(%edi)
   13b11:	0f 85 17 fd ff ff    	jne    1382e <_SpiProcessRequests+0x18e>
   13b17:	8b 47 1c             	mov    0x1c(%edi),%eax
   13b1a:	85 c0                	test   %eax,%eax
   13b1c:	0f 84 0c fd ff ff    	je     1382e <_SpiProcessRequests+0x18e>
   13b22:	80 7f 0b 11          	cmpb   $0x11,0xb(%edi)
   13b26:	0f 86 02 fd ff ff    	jbe    1382e <_SpiProcessRequests+0x18e>
   13b2c:	84 d2                	test   %dl,%dl
   13b2e:	0f 88 fa fc ff ff    	js     1382e <_SpiProcessRequests+0x18e>
   13b34:	50                   	push   %eax
   13b35:	68 53 53 72 62       	push   $0x62725353
   13b3a:	6a 72                	push   $0x72
   13b3c:	6a 00                	push   $0x0
   13b3e:	e8 bd 06 00 00       	call   14200 <_ExAllocatePoolWithTag@12>
   13b43:	31 d2                	xor    %edx,%edx
   13b45:	59                   	pop    %ecx
   13b46:	89 45 c4             	mov    %eax,0xffffffc4(%ebp)
   13b49:	85 c0                	test   %eax,%eax
   13b4b:	74 58                	je     13ba5 <_SpiProcessRequests+0x505>
   13b4d:	52                   	push   %edx
   13b4e:	52                   	push   %edx
   13b4f:	6a 72                	push   $0x72
   13b51:	50                   	push   %eax
   13b52:	e8 c9 04 00 00       	call   14020 <_RtlZeroMemory@8>
   13b57:	59                   	pop    %ecx
   13b58:	8b 4d c4             	mov    0xffffffc4(%ebp),%ecx
   13b5b:	58                   	pop    %eax
   13b5c:	8a 47 05             	mov    0x5(%edi),%al
   13b5f:	88 41 05             	mov    %al,0x5(%ecx)
   13b62:	8a 47 06             	mov    0x6(%edi),%al
   13b65:	88 41 06             	mov    %al,0x6(%ecx)
   13b68:	8b 47 24             	mov    0x24(%edi),%eax
   13b6b:	89 41 24             	mov    %eax,0x24(%ecx)
   13b6e:	89 c8                	mov    %ecx,%eax
   13b70:	83 c0 5f             	add    $0x5f,%eax
   13b73:	c6 41 02 00          	movb   $0x0,0x2(%ecx)
   13b77:	83 e0 e0             	and    $0xffffffe0,%eax
   13b7a:	66 c7 01 40 00       	movw   $0x40,(%ecx)
   13b7f:	c7 41 0c 48 00 00 00 	movl   $0x48,0xc(%ecx)
   13b86:	c7 41 14 04 00 00 00 	movl   $0x4,0x14(%ecx)
   13b8d:	c6 41 0a 06          	movb   $0x6,0xa(%ecx)
   13b91:	89 41 18             	mov    %eax,0x18(%ecx)
   13b94:	c7 41 10 12 00 00 00 	movl   $0x12,0x10(%ecx)
   13b9b:	c6 41 30 03          	movb   $0x3,0x30(%ecx)
   13b9f:	c6 41 34 12          	movb   $0x12,0x34(%ecx)
   13ba3:	89 ca                	mov    %ecx,%edx
   13ba5:	89 d7                	mov    %edx,%edi
   13ba7:	85 d2                	test   %edx,%edx
   13ba9:	0f 84 7f fc ff ff    	je     1382e <_SpiProcessRequests+0x18e>
   13baf:	89 56 4c             	mov    %edx,0x4c(%esi)
   13bb2:	83 ec 0c             	sub    $0xc,%esp
   13bb5:	8b 55 c8             	mov    0xffffffc8(%ebp),%edx
   13bb8:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   13bbb:	52                   	push   %edx
   13bbc:	89 f2                	mov    %esi,%edx
   13bbe:	e8 0d f9 ff ff       	call   134d0 <_SpiRemoveActiveIrp>
   13bc3:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   13bc6:	89 fa                	mov    %edi,%edx
   13bc8:	e8 63 dd ff ff       	call   11930 <_SpiFreeSrbExtension>
   13bcd:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
   13bd0:	89 47 24             	mov    %eax,0x24(%edi)
   13bd3:	c7 46 48 00 00 00 00 	movl   $0x0,0x48(%esi)
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldFlink;
	OldFlink = ListHead->Flink;
   13bda:	8b 4d d8             	mov    0xffffffd8(%ebp),%ecx
   13bdd:	8d 46 40             	lea    0x40(%esi),%eax
   13be0:	83 c4 10             	add    $0x10,%esp
   13be3:	8b 51 78             	mov    0x78(%ecx),%edx
	Entry->Flink = OldFlink;
	Entry->Blink = ListHead;
   13be6:	8b 4d c0             	mov    0xffffffc0(%ebp),%ecx
   13be9:	89 56 40             	mov    %edx,0x40(%esi)
   13bec:	89 48 04             	mov    %ecx,0x4(%eax)
	OldFlink->Blink = Entry;
   13bef:	89 42 04             	mov    %eax,0x4(%edx)
	ListHead->Flink = Entry;
   13bf2:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
   13bf5:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
   13bf8:	89 de                	mov    %ebx,%esi
	OldFlink = ListHead->Flink;
	Entry->Flink = OldFlink;
	Entry->Blink = ListHead;
	OldFlink->Blink = Entry;
	ListHead->Flink = Entry;
   13bfa:	89 42 78             	mov    %eax,0x78(%edx)
   13bfd:	8b 82 84 00 00 00    	mov    0x84(%edx),%eax
   13c03:	40                   	inc    %eax
   13c04:	89 82 84 00 00 00    	mov    %eax,0x84(%edx)
   13c0a:	8b 41 70             	mov    0x70(%ecx),%eax
   13c0d:	40                   	inc    %eax
   13c0e:	85 db                	test   %ebx,%ebx
   13c10:	89 41 70             	mov    %eax,0x70(%ecx)
   13c13:	e9 4e fc ff ff       	jmp    13866 <_SpiProcessRequests+0x1c6>
   13c18:	83 ec 0c             	sub    $0xc,%esp
   13c1b:	8b 45 c8             	mov    0xffffffc8(%ebp),%eax
   13c1e:	89 f2                	mov    %esi,%edx
   13c20:	50                   	push   %eax
   13c21:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   13c24:	e8 a7 f8 ff ff       	call   134d0 <_SpiRemoveActiveIrp>
   13c29:	8b 55 cc             	mov    0xffffffcc(%ebp),%edx
   13c2c:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   13c2f:	e8 fc dc ff ff       	call   11930 <_SpiFreeSrbExtension>
   13c34:	eb a4                	jmp    13bda <_SpiProcessRequests+0x53a>
   13c36:	50                   	push   %eax
   13c37:	50                   	push   %eax
   13c38:	31 c0                	xor    %eax,%eax
   13c3a:	8b 7d bc             	mov    0xffffffbc(%ebp),%edi
   13c3d:	8a 45 df             	mov    0xffffffdf(%ebp),%al
   13c40:	50                   	push   %eax
   13c41:	57                   	push   %edi
   13c42:	e8 09 07 00 00       	call   14350 <_KeReleaseSpinLock@8>
   13c47:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13c4a:	5b                   	pop    %ebx
   13c4b:	5e                   	pop    %esi
   13c4c:	5f                   	pop    %edi
   13c4d:	5d                   	pop    %ebp
   13c4e:	c3                   	ret    
   13c4f:	90                   	nop    

00013c50 <_ScsiPortNotification>:
   13c50:	55                   	push   %ebp
   13c51:	89 e5                	mov    %esp,%ebp
   13c53:	56                   	push   %esi
   13c54:	53                   	push   %ebx
   13c55:	8b 75 08             	mov    0x8(%ebp),%esi
   13c58:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   13c5b:	81 eb 8c 00 00 00    	sub    $0x8c,%ebx
   13c61:	83 fe 01             	cmp    $0x1,%esi
   13c64:	0f 84 96 00 00 00    	je     13d00 <_ScsiPortNotification+0xb0>
   13c6a:	72 54                	jb     13cc0 <_ScsiPortNotification+0x70>
   13c6c:	83 fe 02             	cmp    $0x2,%esi
   13c6f:	0f 84 96 00 00 00    	je     13d0b <_ScsiPortNotification+0xbb>
   13c75:	83 fe 03             	cmp    $0x3,%esi
   13c78:	0f 84 bf 00 00 00    	je     13d3d <_ScsiPortNotification+0xed>
   13c7e:	51                   	push   %ecx
   13c7f:	68 2a 05 00 00       	push   $0x52a
   13c84:	68 11 50 01 00       	push   $0x15011
   13c89:	68 54 50 01 00       	push   $0x15054
   13c8e:	e8 fd 05 00 00       	call   14290 <_DbgPrint>
   13c93:	58                   	pop    %eax
   13c94:	5a                   	pop    %edx
   13c95:	56                   	push   %esi
   13c96:	68 47 56 01 00       	push   $0x15647
   13c9b:	e8 f0 05 00 00       	call   14290 <_DbgPrint>
   13ca0:	83 c4 10             	add    $0x10,%esp
   13ca3:	e8 88 06 00 00       	call   14330 <_KeGetCurrentIrql@0>
   13ca8:	3c 01                	cmp    $0x1,%al
   13caa:	77 35                	ja     13ce1 <_ScsiPortNotification+0x91>
   13cac:	8d 74 26 00          	lea    0x0(%esi),%esi
   13cb0:	89 d8                	mov    %ebx,%eax
   13cb2:	31 d2                	xor    %edx,%edx
   13cb4:	e8 e7 f9 ff ff       	call   136a0 <_SpiProcessRequests>
   13cb9:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   13cbc:	5b                   	pop    %ebx
   13cbd:	5e                   	pop    %esi
   13cbe:	5d                   	pop    %ebp
   13cbf:	c3                   	ret    
   13cc0:	8b 53 14             	mov    0x14(%ebx),%edx
   13cc3:	8b 45 10             	mov    0x10(%ebp),%eax
   13cc6:	83 ca 01             	or     $0x1,%edx
   13cc9:	89 53 14             	mov    %edx,0x14(%ebx)
   13ccc:	8b 70 0c             	mov    0xc(%eax),%esi
   13ccf:	81 e6 ff ff fe ff    	and    $0xfffeffff,%esi
   13cd5:	89 70 0c             	mov    %esi,0xc(%eax)
   13cd8:	e8 53 06 00 00       	call   14330 <_KeGetCurrentIrql@0>
   13cdd:	3c 01                	cmp    $0x1,%al
   13cdf:	76 cf                	jbe    13cb0 <_ScsiPortNotification+0x60>
   13ce1:	50                   	push   %eax
   13ce2:	53                   	push   %ebx
   13ce3:	6a 00                	push   $0x0
   13ce5:	8b 43 40             	mov    0x40(%ebx),%eax
   13ce8:	83 c0 74             	add    $0x74,%eax
   13ceb:	50                   	push   %eax
   13cec:	e8 1f 05 00 00       	call   14210 <_KeInsertQueueDpc@12>
   13cf1:	58                   	pop    %eax
   13cf2:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   13cf5:	5b                   	pop    %ebx
   13cf6:	5e                   	pop    %esi
   13cf7:	5d                   	pop    %ebp
   13cf8:	c3                   	ret    
   13cf9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
   13d00:	8b 4b 14             	mov    0x14(%ebx),%ecx
   13d03:	83 c9 02             	or     $0x2,%ecx
   13d06:	89 4b 14             	mov    %ecx,0x14(%ebx)
   13d09:	eb cd                	jmp    13cd8 <_ScsiPortNotification+0x88>
   13d0b:	31 c0                	xor    %eax,%eax
   13d0d:	31 d2                	xor    %edx,%edx
   13d0f:	8a 45 18             	mov    0x18(%ebp),%al
   13d12:	8a 55 10             	mov    0x10(%ebp),%dl
   13d15:	50                   	push   %eax
   13d16:	31 c0                	xor    %eax,%eax
   13d18:	8a 45 14             	mov    0x14(%ebp),%al
   13d1b:	50                   	push   %eax
   13d1c:	89 d8                	mov    %ebx,%eax
   13d1e:	e8 ed da ff ff       	call   11810 <_SpiGetLunExtension>
   13d23:	5e                   	pop    %esi
   13d24:	85 c0                	test   %eax,%eax
   13d26:	5a                   	pop    %edx
   13d27:	74 af                	je     13cd8 <_ScsiPortNotification+0x88>
   13d29:	8b 4b 14             	mov    0x14(%ebx),%ecx
   13d2c:	83 c9 04             	or     $0x4,%ecx
   13d2f:	89 4b 14             	mov    %ecx,0x14(%ebx)
   13d32:	8b 50 7c             	mov    0x7c(%eax),%edx
   13d35:	83 ca 04             	or     $0x4,%edx
   13d38:	89 50 7c             	mov    %edx,0x7c(%eax)
   13d3b:	eb 9b                	jmp    13cd8 <_ScsiPortNotification+0x88>
   13d3d:	56                   	push   %esi
   13d3e:	68 25 05 00 00       	push   $0x525
   13d43:	68 11 50 01 00       	push   $0x15011
   13d48:	68 54 50 01 00       	push   $0x15054
   13d4d:	e8 3e 05 00 00       	call   14290 <_DbgPrint>
   13d52:	c7 04 24 65 56 01 00 	movl   $0x15665,(%esp)
   13d59:	e9 3d ff ff ff       	jmp    13c9b <_ScsiPortNotification+0x4b>
   13d5e:	89 f6                	mov    %esi,%esi

00013d60 <_ScsiPortCompleteRequest@20>:
   13d60:	55                   	push   %ebp
   13d61:	89 e5                	mov    %esp,%ebp
   13d63:	57                   	push   %edi
   13d64:	56                   	push   %esi
   13d65:	53                   	push   %ebx
   13d66:	83 ec 0c             	sub    $0xc,%esp
   13d69:	8b 7d 08             	mov    0x8(%ebp),%edi
   13d6c:	8a 45 0c             	mov    0xc(%ebp),%al
   13d6f:	8a 55 10             	mov    0x10(%ebp),%dl
   13d72:	88 45 f3             	mov    %al,0xfffffff3(%ebp)
   13d75:	8a 45 14             	mov    0x14(%ebp),%al
   13d78:	88 55 f2             	mov    %dl,0xfffffff2(%ebp)
   13d7b:	88 45 f1             	mov    %al,0xfffffff1(%ebp)
   13d7e:	8a 55 18             	mov    0x18(%ebp),%dl
   13d81:	8d 47 a4             	lea    0xffffffa4(%edi),%eax
   13d84:	8b 77 a4             	mov    0xffffffa4(%edi),%esi
   13d87:	88 55 f0             	mov    %dl,0xfffffff0(%ebp)
   13d8a:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   13d8d:	39 f0                	cmp    %esi,%eax
   13d8f:	74 2b                	je     13dbc <_ScsiPortCompleteRequest@20+0x5c>
   13d91:	80 7d f3 ff          	cmpb   $0xff,0xfffffff3(%ebp)
   13d95:	74 59                	je     13df0 <_ScsiPortCompleteRequest@20+0x90>
   13d97:	8a 4e 08             	mov    0x8(%esi),%cl
   13d9a:	3a 4d f3             	cmp    0xfffffff3(%ebp),%cl
   13d9d:	0f 94 c2             	sete   %dl
   13da0:	80 7d f2 ff          	cmpb   $0xff,0xfffffff2(%ebp)
   13da4:	0f 94 c0             	sete   %al
   13da7:	25 ff 00 00 00       	and    $0xff,%eax
   13dac:	85 c2                	test   %eax,%edx
   13dae:	75 40                	jne    13df0 <_ScsiPortCompleteRequest@20+0x90>
   13db0:	3a 4d f3             	cmp    0xfffffff3(%ebp),%cl
   13db3:	74 11                	je     13dc6 <_ScsiPortCompleteRequest@20+0x66>
   13db5:	8b 36                	mov    (%esi),%esi
   13db7:	39 75 ec             	cmp    %esi,0xffffffec(%ebp)
   13dba:	75 d5                	jne    13d91 <_ScsiPortCompleteRequest@20+0x31>
   13dbc:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13dbf:	5b                   	pop    %ebx
   13dc0:	5e                   	pop    %esi
   13dc1:	5f                   	pop    %edi
   13dc2:	5d                   	pop    %ebp
   13dc3:	c2 14 00             	ret    $0x14
   13dc6:	8a 4e 09             	mov    0x9(%esi),%cl
   13dc9:	3a 4d f2             	cmp    0xfffffff2(%ebp),%cl
   13dcc:	0f 94 c2             	sete   %dl
   13dcf:	80 7d f1 ff          	cmpb   $0xff,0xfffffff1(%ebp)
   13dd3:	0f 94 c0             	sete   %al
   13dd6:	25 ff 00 00 00       	and    $0xff,%eax
   13ddb:	85 c2                	test   %eax,%edx
   13ddd:	75 11                	jne    13df0 <_ScsiPortCompleteRequest@20+0x90>
   13ddf:	3a 4d f2             	cmp    0xfffffff2(%ebp),%cl
   13de2:	75 d1                	jne    13db5 <_ScsiPortCompleteRequest@20+0x55>
   13de4:	8a 55 f1             	mov    0xfffffff1(%ebp),%dl
   13de7:	38 56 0a             	cmp    %dl,0xa(%esi)
   13dea:	75 c9                	jne    13db5 <_ScsiPortCompleteRequest@20+0x55>
   13dec:	8d 74 26 00          	lea    0x0(%esi),%esi
   13df0:	8b 5e 78             	mov    0x78(%esi),%ebx
   13df3:	85 db                	test   %ebx,%ebx
   13df5:	74 be                	je     13db5 <_ScsiPortCompleteRequest@20+0x55>
   13df7:	8b 43 4c             	mov    0x4c(%ebx),%eax
   13dfa:	f6 40 0e 01          	testb  $0x1,0xe(%eax)
   13dfe:	75 05                	jne    13e05 <_ScsiPortCompleteRequest@20+0xa5>
   13e00:	8b 5b 44             	mov    0x44(%ebx),%ebx
   13e03:	eb ee                	jmp    13df3 <_ScsiPortCompleteRequest@20+0x93>
   13e05:	8a 55 f0             	mov    0xfffffff0(%ebp),%dl
   13e08:	88 50 03             	mov    %dl,0x3(%eax)
   13e0b:	51                   	push   %ecx
   13e0c:	50                   	push   %eax
   13e0d:	57                   	push   %edi
   13e0e:	6a 00                	push   $0x0
   13e10:	e8 3b fe ff ff       	call   13c50 <_ScsiPortNotification>
   13e15:	83 c4 10             	add    $0x10,%esp
   13e18:	8b 5b 44             	mov    0x44(%ebx),%ebx
   13e1b:	eb d6                	jmp    13df3 <_ScsiPortCompleteRequest@20+0x93>
   13e1d:	8d 76 00             	lea    0x0(%esi),%esi

00013e20 <_ScsiPortDpc@16>:
   13e20:	55                   	push   %ebp
   13e21:	89 e5                	mov    %esp,%ebp
   13e23:	50                   	push   %eax
   13e24:	50                   	push   %eax
   13e25:	31 d2                	xor    %edx,%edx
   13e27:	8b 45 14             	mov    0x14(%ebp),%eax
   13e2a:	e8 71 f8 ff ff       	call   136a0 <_SpiProcessRequests>
   13e2f:	c9                   	leave  
   13e30:	c2 10 00             	ret    $0x10
   13e33:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   13e39:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00013e40 <_ScsiPortDispatchScsi@8>:
   13e40:	55                   	push   %ebp
   13e41:	89 e5                	mov    %esp,%ebp
   13e43:	57                   	push   %edi
   13e44:	56                   	push   %esi
   13e45:	53                   	push   %ebx
   13e46:	83 ec 0c             	sub    $0xc,%esp
   13e49:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
   13e50:	8b 45 08             	mov    0x8(%ebp),%eax
   13e53:	8b 75 0c             	mov    0xc(%ebp),%esi
   13e56:	8b 40 28             	mov    0x28(%eax),%eax
   13e59:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   13e5c:	8b 46 60             	mov    0x60(%esi),%eax
   13e5f:	8b 58 04             	mov    0x4(%eax),%ebx
   13e62:	85 db                	test   %ebx,%ebx
   13e64:	0f 84 f6 00 00 00    	je     13f60 <_ScsiPortDispatchScsi@8+0x120>
   13e6a:	31 c0                	xor    %eax,%eax
   13e6c:	31 d2                	xor    %edx,%edx
   13e6e:	8a 43 07             	mov    0x7(%ebx),%al
   13e71:	8a 53 05             	mov    0x5(%ebx),%dl
   13e74:	50                   	push   %eax
   13e75:	31 c0                	xor    %eax,%eax
   13e77:	8a 43 06             	mov    0x6(%ebx),%al
   13e7a:	50                   	push   %eax
   13e7b:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   13e7e:	e8 8d d9 ff ff       	call   11810 <_SpiGetLunExtension>
   13e83:	89 c7                	mov    %eax,%edi
   13e85:	58                   	pop    %eax
   13e86:	85 ff                	test   %edi,%edi
   13e88:	5a                   	pop    %edx
   13e89:	0f 84 f8 00 00 00    	je     13f87 <_ScsiPortDispatchScsi@8+0x147>
   13e8f:	31 c0                	xor    %eax,%eax
   13e91:	8a 43 02             	mov    0x2(%ebx),%al
   13e94:	83 f8 08             	cmp    $0x8,%eax
   13e97:	77 07                	ja     13ea0 <_ScsiPortDispatchScsi@8+0x60>
   13e99:	ff 24 85 ac 56 01 00 	jmp    *0x156ac(,%eax,4)
   13ea0:	51                   	push   %ecx
   13ea1:	68 8c 06 00 00       	push   $0x68c
   13ea6:	68 11 50 01 00       	push   $0x15011
   13eab:	68 54 50 01 00       	push   $0x15054
   13eb0:	e8 db 03 00 00       	call   14290 <_DbgPrint>
   13eb5:	58                   	pop    %eax
   13eb6:	31 c0                	xor    %eax,%eax
   13eb8:	5a                   	pop    %edx
   13eb9:	8a 43 02             	mov    0x2(%ebx),%al
   13ebc:	50                   	push   %eax
   13ebd:	68 7c 56 01 00       	push   $0x1567c
   13ec2:	e8 c9 03 00 00       	call   14290 <_DbgPrint>
   13ec7:	c7 45 ec 02 00 00 c0 	movl   $0xc0000002,0xffffffec(%ebp)
   13ece:	83 c4 10             	add    $0x10,%esp
   13ed1:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   13ed4:	c7 46 1c 00 00 00 00 	movl   $0x0,0x1c(%esi)
   13edb:	89 56 18             	mov    %edx,0x18(%esi)
   13ede:	50                   	push   %eax
   13edf:	50                   	push   %eax
   13ee0:	6a 00                	push   $0x0
   13ee2:	56                   	push   %esi
   13ee3:	e8 68 01 00 00       	call   14050 <_IoCompleteRequest@8>
   13ee8:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   13eeb:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13eee:	5b                   	pop    %ebx
   13eef:	5e                   	pop    %esi
   13ef0:	5f                   	pop    %edi
   13ef1:	5d                   	pop    %ebp
   13ef2:	c2 08 00             	ret    $0x8
   13ef5:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   13ef8:	8b 42 08             	mov    0x8(%edx),%eax
   13efb:	80 78 4b 01          	cmpb   $0x1,0x4b(%eax)
   13eff:	75 d0                	jne    13ed1 <_ScsiPortDispatchScsi@8+0x91>
   13f01:	8b 46 60             	mov    0x60(%esi),%eax
   13f04:	89 f2                	mov    %esi,%edx
   13f06:	80 48 03 01          	orb    $0x1,0x3(%eax)
   13f0a:	89 7b 24             	mov    %edi,0x24(%ebx)
   13f0d:	89 5e 4c             	mov    %ebx,0x4c(%esi)
   13f10:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   13f13:	e8 88 f7 ff ff       	call   136a0 <_SpiProcessRequests>
   13f18:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13f1b:	b8 03 01 00 00       	mov    $0x103,%eax
   13f20:	5b                   	pop    %ebx
   13f21:	5e                   	pop    %esi
   13f22:	5f                   	pop    %edi
   13f23:	5d                   	pop    %ebp
   13f24:	c2 08 00             	ret    $0x8
   13f27:	8b 4f 0c             	mov    0xc(%edi),%ecx
   13f2a:	e8 f1 02 00 00       	call   14220 <@ObfDereferenceObject@4>
   13f2f:	c7 47 0c 00 00 00 00 	movl   $0x0,0xc(%edi)
   13f36:	c6 47 0b 00          	movb   $0x0,0xb(%edi)
   13f3a:	eb 95                	jmp    13ed1 <_ScsiPortDispatchScsi@8+0x91>
   13f3c:	8d 74 26 00          	lea    0x0(%esi),%esi
   13f40:	8b 4d 08             	mov    0x8(%ebp),%ecx
   13f43:	e8 e8 02 00 00       	call   14230 <@ObfReferenceObject@4>
   13f48:	8b 45 08             	mov    0x8(%ebp),%eax
   13f4b:	89 47 0c             	mov    %eax,0xc(%edi)
   13f4e:	c6 47 0b 01          	movb   $0x1,0xb(%edi)
   13f52:	89 43 18             	mov    %eax,0x18(%ebx)
   13f55:	e9 77 ff ff ff       	jmp    13ed1 <_ScsiPortDispatchScsi@8+0x91>
   13f5a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   13f60:	c7 46 18 01 00 00 c0 	movl   $0xc0000001,0x18(%esi)
   13f67:	c7 46 1c 00 00 00 00 	movl   $0x0,0x1c(%esi)
   13f6e:	51                   	push   %ecx
   13f6f:	51                   	push   %ecx
   13f70:	6a 00                	push   $0x0
   13f72:	56                   	push   %esi
   13f73:	e8 d8 00 00 00       	call   14050 <_IoCompleteRequest@8>
   13f78:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   13f7b:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   13f80:	5b                   	pop    %ebx
   13f81:	5e                   	pop    %esi
   13f82:	5f                   	pop    %edi
   13f83:	5d                   	pop    %ebp
   13f84:	c2 08 00             	ret    $0x8
   13f87:	c6 43 03 08          	movb   $0x8,0x3(%ebx)
   13f8b:	c7 46 18 0e 00 00 c0 	movl   $0xc000000e,0x18(%esi)
   13f92:	c7 46 1c 00 00 00 00 	movl   $0x0,0x1c(%esi)
   13f99:	53                   	push   %ebx
   13f9a:	53                   	push   %ebx
   13f9b:	6a 00                	push   $0x0
   13f9d:	56                   	push   %esi
   13f9e:	e8 ad 00 00 00       	call   14050 <_IoCompleteRequest@8>
   13fa3:	b8 0e 00 00 c0       	mov    $0xc000000e,%eax
   13fa8:	e9 3e ff ff ff       	jmp    13eeb <_ScsiPortDispatchScsi@8+0xab>
   13fad:	90                   	nop    
   13fae:	90                   	nop    
   13faf:	90                   	nop    

00013fb0 <_MmUnmapIoSpace@8>:
   13fb0:	ff 25 e4 81 01 00    	jmp    *0x181e4
   13fb6:	90                   	nop    
   13fb7:	90                   	nop    
	...

00013fc0 <_ExFreePool@4>:
   13fc0:	ff 25 88 81 01 00    	jmp    *0x18188
   13fc6:	90                   	nop    
   13fc7:	90                   	nop    
	...

00013fd0 <_MmMapIoSpace@16>:
   13fd0:	ff 25 e0 81 01 00    	jmp    *0x181e0
   13fd6:	90                   	nop    
   13fd7:	90                   	nop    
	...

00013fe0 <_ExAllocatePool@8>:
   13fe0:	ff 25 80 81 01 00    	jmp    *0x18180
   13fe6:	90                   	nop    
   13fe7:	90                   	nop    
	...

00013ff0 <_MmGetPhysicalAddress@4>:
   13ff0:	ff 25 dc 81 01 00    	jmp    *0x181dc
   13ff6:	90                   	nop    
   13ff7:	90                   	nop    
	...

00014000 <_RtlInitializeBitMap@12>:
   14000:	ff 25 fc 81 01 00    	jmp    *0x181fc
   14006:	90                   	nop    
   14007:	90                   	nop    
	...

00014010 <_RtlClearAllBits@4>:
   14010:	ff 25 ec 81 01 00    	jmp    *0x181ec
   14016:	90                   	nop    
   14017:	90                   	nop    
	...

00014020 <_RtlZeroMemory@8>:
   14020:	ff 25 04 82 01 00    	jmp    *0x18204
   14026:	90                   	nop    
   14027:	90                   	nop    
	...

00014030 <_KeBugCheck@4>:
   14030:	ff 25 b8 81 01 00    	jmp    *0x181b8
   14036:	90                   	nop    
   14037:	90                   	nop    
	...

00014040 <_RtlMoveMemory@12>:
   14040:	ff 25 00 82 01 00    	jmp    *0x18200
   14046:	90                   	nop    
   14047:	90                   	nop    
	...

00014050 <_IoCompleteRequest@8>:
   14050:	ff 25 94 81 01 00    	jmp    *0x18194
   14056:	90                   	nop    
   14057:	90                   	nop    
	...

00014060 <_RtlFindClearBitsAndSet@12>:
   14060:	ff 25 f4 81 01 00    	jmp    *0x181f4
   14066:	90                   	nop    
   14067:	90                   	nop    
	...

00014070 <_RtlClearBits@12>:
   14070:	ff 25 f0 81 01 00    	jmp    *0x181f0
   14076:	90                   	nop    
   14077:	90                   	nop    
	...

00014080 <_IoGetConfigurationInformation@0>:
   14080:	ff 25 ac 81 01 00    	jmp    *0x181ac
   14086:	90                   	nop    
   14087:	90                   	nop    
	...

00014090 <_RtlInitUnicodeString@8>:
   14090:	ff 25 f8 81 01 00    	jmp    *0x181f8
   14096:	90                   	nop    
   14097:	90                   	nop    
	...

000140a0 <_IoCreateDevice@28>:
   140a0:	ff 25 9c 81 01 00    	jmp    *0x1819c
   140a6:	90                   	nop    
   140a7:	90                   	nop    
	...

000140b0 <_KeInitializeSpinLock@4>:
   140b0:	ff 25 c4 81 01 00    	jmp    *0x181c4
   140b6:	90                   	nop    
   140b7:	90                   	nop    
	...

000140c0 <_KeInitializeDpc@12>:
   140c0:	ff 25 bc 81 01 00    	jmp    *0x181bc
   140c6:	90                   	nop    
   140c7:	90                   	nop    
	...

000140d0 <_IoInitializeTimer@12>:
   140d0:	ff 25 b0 81 01 00    	jmp    *0x181b0
   140d6:	90                   	nop    
   140d7:	90                   	nop    
	...

000140e0 <_IoConnectInterrupt@44>:
   140e0:	ff 25 98 81 01 00    	jmp    *0x18198
   140e6:	90                   	nop    
   140e7:	90                   	nop    
	...

000140f0 <_KeInitializeEvent@12>:
   140f0:	ff 25 c0 81 01 00    	jmp    *0x181c0
   140f6:	90                   	nop    
   140f7:	90                   	nop    
	...

00014100 <_IoBuildDeviceIoControlRequest@36>:
   14100:	ff 25 8c 81 01 00    	jmp    *0x1818c
   14106:	90                   	nop    
   14107:	90                   	nop    
	...

00014110 <_IoCallDriver@8>:
   14110:	ff 25 90 81 01 00    	jmp    *0x18190
   14116:	90                   	nop    
   14117:	90                   	nop    
	...

00014120 <_IoCreateSymbolicLink@8>:
   14120:	ff 25 a0 81 01 00    	jmp    *0x181a0
   14126:	90                   	nop    
   14127:	90                   	nop    
	...

00014130 <_KeReadStateEvent@4>:
   14130:	ff 25 cc 81 01 00    	jmp    *0x181cc
   14136:	90                   	nop    
   14137:	90                   	nop    
	...

00014140 <_KeWaitForMultipleObjects@32>:
   14140:	ff 25 d8 81 01 00    	jmp    *0x181d8
   14146:	90                   	nop    
   14147:	90                   	nop    
	...

00014150 <_IoDeleteDevice@4>:
   14150:	ff 25 a4 81 01 00    	jmp    *0x181a4
   14156:	90                   	nop    
   14157:	90                   	nop    
	...

00014160 <_ZwCreateKey@28>:
   14160:	ff 25 0c 82 01 00    	jmp    *0x1820c
   14166:	90                   	nop    
   14167:	90                   	nop    
	...

00014170 <_ZwClose@4>:
   14170:	ff 25 08 82 01 00    	jmp    *0x18208
   14176:	90                   	nop    
   14177:	90                   	nop    
	...

00014180 <_ZwSetValueKey@24>:
   14180:	ff 25 10 82 01 00    	jmp    *0x18210
   14186:	90                   	nop    
   14187:	90                   	nop    
	...

00014190 <_IoDisconnectInterrupt@4>:
   14190:	ff 25 a8 81 01 00    	jmp    *0x181a8
   14196:	90                   	nop    
   14197:	90                   	nop    
	...

000141a0 <@InterlockedDecrement@4>:
   141a0:	ff 25 6c 81 01 00    	jmp    *0x1816c
   141a6:	90                   	nop    
   141a7:	90                   	nop    
	...

000141b0 <@InterlockedExchange@8>:
   141b0:	ff 25 70 81 01 00    	jmp    *0x18170
   141b6:	90                   	nop    
   141b7:	90                   	nop    
	...

000141c0 <_RtlAssert@16>:
   141c0:	ff 25 e8 81 01 00    	jmp    *0x181e8
   141c6:	90                   	nop    
   141c7:	90                   	nop    
	...

000141d0 <_KeSynchronizeExecution@12>:
   141d0:	ff 25 d4 81 01 00    	jmp    *0x181d4
   141d6:	90                   	nop    
   141d7:	90                   	nop    
	...

000141e0 <_KeReleaseSpinLockFromDpcLevel@4>:
   141e0:	ff 25 d0 81 01 00    	jmp    *0x181d0
   141e6:	90                   	nop    
   141e7:	90                   	nop    
	...

000141f0 <_KeAcquireSpinLockAtDpcLevel@4>:
   141f0:	ff 25 b4 81 01 00    	jmp    *0x181b4
   141f6:	90                   	nop    
   141f7:	90                   	nop    
	...

00014200 <_ExAllocatePoolWithTag@12>:
   14200:	ff 25 84 81 01 00    	jmp    *0x18184
   14206:	90                   	nop    
   14207:	90                   	nop    
	...

00014210 <_KeInsertQueueDpc@12>:
   14210:	ff 25 c8 81 01 00    	jmp    *0x181c8
   14216:	90                   	nop    
   14217:	90                   	nop    
	...

00014220 <@ObfDereferenceObject@4>:
   14220:	ff 25 74 81 01 00    	jmp    *0x18174
   14226:	90                   	nop    
   14227:	90                   	nop    
	...

00014230 <@ObfReferenceObject@4>:
   14230:	ff 25 78 81 01 00    	jmp    *0x18178
   14236:	90                   	nop    
   14237:	90                   	nop    
	...

00014240 <_memcpy>:
   14240:	ff 25 18 82 01 00    	jmp    *0x18218
   14246:	90                   	nop    
   14247:	90                   	nop    
	...

00014250 <_wcslen>:
   14250:	ff 25 28 82 01 00    	jmp    *0x18228
   14256:	90                   	nop    
   14257:	90                   	nop    
	...

00014260 <_wcsrchr>:
   14260:	ff 25 2c 82 01 00    	jmp    *0x1822c
   14266:	90                   	nop    
   14267:	90                   	nop    
	...

00014270 <_sprintf>:
   14270:	ff 25 1c 82 01 00    	jmp    *0x1821c
   14276:	90                   	nop    
   14277:	90                   	nop    
	...

00014280 <_swprintf>:
   14280:	ff 25 20 82 01 00    	jmp    *0x18220
   14286:	90                   	nop    
   14287:	90                   	nop    
	...

00014290 <_DbgPrint>:
   14290:	ff 25 7c 81 01 00    	jmp    *0x1817c
   14296:	90                   	nop    
   14297:	90                   	nop    
	...

000142a0 <_vsprintf>:
   142a0:	ff 25 24 82 01 00    	jmp    *0x18224
   142a6:	90                   	nop    
   142a7:	90                   	nop    
	...

000142b0 <__strnicmp>:
   142b0:	ff 25 14 82 01 00    	jmp    *0x18214
   142b6:	90                   	nop    
   142b7:	90                   	nop    
	...

000142c0 <_HalGetBusData@20>:
   142c0:	ff 25 44 81 01 00    	jmp    *0x18144
   142c6:	90                   	nop    
   142c7:	90                   	nop    
	...

000142d0 <_HalTranslateBusAddress@24>:
   142d0:	ff 25 54 81 01 00    	jmp    *0x18154
   142d6:	90                   	nop    
   142d7:	90                   	nop    
	...

000142e0 <_HalAllocateCommonBuffer@16>:
   142e0:	ff 25 3c 81 01 00    	jmp    *0x1813c
   142e6:	90                   	nop    
   142e7:	90                   	nop    
	...

000142f0 <_HalGetAdapter@8>:
   142f0:	ff 25 40 81 01 00    	jmp    *0x18140
   142f6:	90                   	nop    
   142f7:	90                   	nop    
	...

00014300 <_HalSetBusDataByOffset@24>:
   14300:	ff 25 50 81 01 00    	jmp    *0x18150
   14306:	90                   	nop    
   14307:	90                   	nop    
	...

00014310 <_HalGetInterruptVector@24>:
   14310:	ff 25 4c 81 01 00    	jmp    *0x1814c
   14316:	90                   	nop    
   14317:	90                   	nop    
	...

00014320 <_HalGetBusDataByOffset@24>:
   14320:	ff 25 48 81 01 00    	jmp    *0x18148
   14326:	90                   	nop    
   14327:	90                   	nop    
	...

00014330 <_KeGetCurrentIrql@0>:
   14330:	ff 25 5c 81 01 00    	jmp    *0x1815c
   14336:	90                   	nop    
   14337:	90                   	nop    
	...

00014340 <_KeAcquireSpinLock@8>:
   14340:	ff 25 58 81 01 00    	jmp    *0x18158
   14346:	90                   	nop    
   14347:	90                   	nop    
	...

00014350 <_KeReleaseSpinLock@8>:
   14350:	ff 25 60 81 01 00    	jmp    *0x18160
   14356:	90                   	nop    
   14357:	90                   	nop    
	...

00014360 <__CTOR_LIST__>:
   14360:	ff                   	(bad)  
   14361:	ff                   	(bad)  
   14362:	ff                   	(bad)  
   14363:	ff 00                	incl   (%eax)
   14365:	00 00                	add    %al,(%eax)
	...

00014368 <__DTOR_LIST__>:
   14368:	ff                   	(bad)  
   14369:	ff                   	(bad)  
   1436a:	ff                   	(bad)  
   1436b:	ff 00                	incl   (%eax)
   1436d:	00 00                	add    %al,(%eax)
	...
