NTSTATUS NTAPI
PciIdeXInitialize(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath,
IN PCONTROLLER_PROPERTIES HwGetControllerProperties,
IN ULONG ExtensionSize)
{
ULONG i;
PPCIIDEX_DRIVER_EXTENSION DriverExtension;
NTSTATUS Status;
DPRINT("PciIdeXInitialize(%p '%wZ' %p 0x%lx)\n",
DriverObject, RegistryPath, HwGetControllerProperties, ExtensionSize);
Status = IoAllocateDriverObjectExtension(
DriverObject,
DriverObject,
sizeof(PCIIDEX_DRIVER_EXTENSION),
(PVOID*)&DriverExtension);
if (!NT_SUCCESS(Status))
return Status;
RtlZeroMemory(DriverExtension, sizeof(PCIIDEX_DRIVER_EXTENSION));
DriverExtension->MiniControllerExtensionSize = ExtensionSize;
DriverExtension->HwGetControllerProperties = HwGetControllerProperties;
DriverObject->DriverExtension->AddDevice = PciIdeXAddDevice;
for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
DriverObject->MajorFunction[i] = PciIdeXForwardOrIgnore;
DriverObject->MajorFunction[IRP_MJ_PNP] = PciIdeXPnpDispatch;
return STATUS_SUCCESS;
}
NTSTATUS
NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
NTSTATUS Status;
UNREFERENCED_PARAMETER(RegistryPath);
DPRINT("Peripheral Component Interconnect Bus Driver\n");
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = PciDispatchDeviceControl;
DriverObject->MajorFunction[IRP_MJ_PNP] = PciPnpControl;
DriverObject->MajorFunction[IRP_MJ_POWER] = PciPowerControl;
DriverObject->DriverExtension->AddDevice = PciAddDevice;
DriverObject->DriverUnload = PciUnload;
Status = IoAllocateDriverObjectExtension(
DriverObject,
DriverObject,
sizeof(PCI_DRIVER_EXTENSION),
(PVOID*)&DriverExtension);
if (!NT_SUCCESS(Status))
return Status;
RtlZeroMemory(DriverExtension, sizeof(PCI_DRIVER_EXTENSION));
InitializeListHead(&DriverExtension->BusListHead);
KeInitializeSpinLock(&DriverExtension->BusListLock);
return STATUS_SUCCESS;
}
/*
* Standard DriverEntry method.
*/
NTSTATUS NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
PGREEN_DRIVER_EXTENSION DriverExtension;
ULONG i;
NTSTATUS Status;
Status = IoAllocateDriverObjectExtension(
DriverObject,
DriverObject,
sizeof(GREEN_DRIVER_EXTENSION),
(PVOID*)&DriverExtension);
if (!NT_SUCCESS(Status))
{
DPRINT("IoAllocateDriverObjectExtension() failed with status 0x%08lx\n", Status);
return Status;
}
RtlZeroMemory(DriverExtension, sizeof(GREEN_DRIVER_EXTENSION));
Status = GreenDuplicateUnicodeString(
0,
RegistryPath,
&DriverExtension->RegistryPath);
if (!NT_SUCCESS(Status))
{
DPRINT("GreenDuplicateUnicodeString() failed with status 0x%08lx\n", Status);
return Status;
}
Status = ReadRegistryEntries(RegistryPath, DriverExtension);
if (!NT_SUCCESS(Status))
{
DPRINT("ReadRegistryEntries() failed with status 0x%08lx\n", Status);
return Status;
}
DriverObject->DriverUnload = DriverUnload;
DriverObject->DriverExtension->AddDevice = GreenAddDevice;
for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
DriverObject->MajorFunction[i] = GreenDispatch;
return STATUS_SUCCESS;
}
NTSTATUS NTAPI
DriverEntry(IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
NTSTATUS Status;
USHORT i;
PCONDRV_DRIVER DriverExtension = NULL;
DPRINT1("Loading ReactOS Console Driver v0.0.1...\n");
DriverObject->DriverUnload = ConDrvUnload;
/* Initialize the different callback function pointers */
for (i = 0 ; i <= IRP_MJ_MAXIMUM_FUNCTION ; ++i)
DriverObject->MajorFunction[i] = ConDrvDispatch;
#if 0
DriverObject->MajorFunction[IRP_MJ_CREATE] = ConDrvCreate;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = ConDrvClose;
/* temporary deactivated...
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = ConDrvCleanup;
*/
DriverObject->MajorFunction[IRP_MJ_READ] = ConDrvRead;
DriverObject->MajorFunction[IRP_MJ_WRITE] = ConDrvWrite;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ConDrvIoControl;
#endif
Status = IoAllocateDriverObjectExtension(DriverObject,
DriverObject, // Unique ID for the driver object extension ==> gives it its address !
sizeof(CONDRV_DRIVER),
(PVOID*)&DriverExtension);
if (!NT_SUCCESS(Status))
{
DPRINT1("IoAllocateDriverObjectExtension() failed with status 0x%08lx\n", Status);
return Status;
}
RtlZeroMemory(DriverExtension, sizeof(CONDRV_DRIVER));
Status = ConDrvCreateController(DriverObject, RegistryPath);
DPRINT1("Done, Status = 0x%08lx\n", Status);
return Status;
}
/*
*@implemented
*/
NTSTATUS
STREAMAPI
StreamClassRegisterAdapter(
IN PVOID Argument1,
IN PVOID Argument2,
IN PHW_INITIALIZATION_DATA HwInitializationData)
{
NTSTATUS Status;
PSTREAM_CLASS_DRIVER_EXTENSION DriverObjectExtension;
PDRIVER_OBJECT DriverObject = (PDRIVER_OBJECT)Argument1;
/* Allocate driver extension */
Status = IoAllocateDriverObjectExtension(DriverObject, (PVOID)StreamClassAddDevice, sizeof(STREAM_CLASS_DRIVER_EXTENSION), (PVOID*)&DriverObjectExtension);
if (!NT_SUCCESS(Status))
{
/* Failed to allocate */
return STATUS_INSUFFICIENT_RESOURCES;
}
/* Zero driver object extension */
RtlZeroMemory(DriverObjectExtension, sizeof(STREAM_CLASS_DRIVER_EXTENSION));
/* copy HwInitializationData */
RtlCopyMemory(&DriverObjectExtension->Data, HwInitializationData, sizeof(HW_INITIALIZATION_DATA));
/* Setup device init methods */
DriverObject->DriverExtension->AddDevice = StreamClassAddDevice;
DriverObject->DriverUnload = KsNullDriverUnload;
/* Setup irp handlers */
DriverObject->MajorFunction[IRP_MJ_PNP] = StreamClassPnp;
DriverObject->MajorFunction[IRP_MJ_POWER] = StreamClassPower;
DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = StreamClassSystemControl;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = StreamClassCleanup;
DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = StreamClassFlushBuffers;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = StreamClassDeviceControl;
/* Let Ks handle these */
KsSetMajorFunctionHandler(DriverObject, IRP_MJ_CREATE);
KsSetMajorFunctionHandler(DriverObject, IRP_MJ_CLOSE);
return STATUS_SUCCESS;
}
NTSTATUS NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
PI8042_DRIVER_EXTENSION DriverExtension;
ULONG i;
NTSTATUS Status;
/* ROS Hack: ideally, we shouldn't have to initialize debug level this way,
but since the only way is to change it via KDBG, it's better to leave
it here too. */
#if 0
DbgSetDebugFilterState(
DPFLTR_I8042PRT_ID,
(1 << DPFLTR_ERROR_LEVEL) | (1 << DPFLTR_WARNING_LEVEL) |
(1 << DPFLTR_TRACE_LEVEL) /*| (1 << DPFLTR_INFO_LEVEL)*/ | DPFLTR_MASK,
TRUE);
#endif
Status = IoAllocateDriverObjectExtension(
DriverObject,
DriverObject,
sizeof(I8042_DRIVER_EXTENSION),
(PVOID*)&DriverExtension);
if (!NT_SUCCESS(Status))
{
WARN_(I8042PRT, "IoAllocateDriverObjectExtension() failed with status 0x%08lx\n", Status);
return Status;
}
RtlZeroMemory(DriverExtension, sizeof(I8042_DRIVER_EXTENSION));
KeInitializeSpinLock(&DriverExtension->Port.SpinLock);
InitializeListHead(&DriverExtension->DeviceListHead);
KeInitializeSpinLock(&DriverExtension->DeviceListLock);
Status = DuplicateUnicodeString(
RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
RegistryPath,
&DriverExtension->RegistryPath);
if (!NT_SUCCESS(Status))
{
WARN_(I8042PRT, "DuplicateUnicodeString() failed with status 0x%08lx\n", Status);
return Status;
}
Status = ReadRegistryEntries(RegistryPath, &DriverExtension->Port.Settings);
if (!NT_SUCCESS(Status))
{
WARN_(I8042PRT, "ReadRegistryEntries() failed with status 0x%08lx\n", Status);
return Status;
}
DriverObject->DriverExtension->AddDevice = i8042AddDevice;
DriverObject->DriverStartIo = i8042StartIo;
for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
DriverObject->MajorFunction[i] = IrpStub;
DriverObject->MajorFunction[IRP_MJ_CREATE] = i8042Create;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = i8042Cleanup;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = i8042Close;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = i8042DeviceControl;
DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = i8042InternalDeviceControl;
DriverObject->MajorFunction[IRP_MJ_PNP] = i8042Pnp;
if (IsFirstStageSetup())
return i8042AddLegacyKeyboard(DriverObject, RegistryPath);
return STATUS_SUCCESS;
}
NTSTATUS
DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
ULONG Status;
HW_INITIALIZATION_DATA HwInitializationData;
PVOID driver_extension;
PUCHAR ptr;
FUNCTION_ENTER();
KdPrint((__DRIVER_NAME " IRQL = %d\n", KeGetCurrentIrql()));
IoAllocateDriverObjectExtension(DriverObject, UlongToPtr(XEN_INIT_DRIVER_EXTENSION_MAGIC), PAGE_SIZE, &driver_extension);
ptr = driver_extension;
ADD_XEN_INIT_REQ(&ptr, XEN_INIT_TYPE_RING, "ring-ref", NULL, NULL);
ADD_XEN_INIT_REQ(&ptr, XEN_INIT_TYPE_EVENT_CHANNEL_IRQ, "event-channel", NULL, NULL);
ADD_XEN_INIT_REQ(&ptr, XEN_INIT_TYPE_GRANT_ENTRIES, UlongToPtr((ULONG)'SCSI'), UlongToPtr(144), NULL);
ADD_XEN_INIT_REQ(&ptr, XEN_INIT_TYPE_XB_STATE_MAP_PRE_CONNECT, NULL, NULL, NULL);
__ADD_XEN_INIT_UCHAR(&ptr, XenbusStateInitialised);
__ADD_XEN_INIT_UCHAR(&ptr, XenbusStateConnected);
__ADD_XEN_INIT_UCHAR(&ptr, 20);
__ADD_XEN_INIT_UCHAR(&ptr, 0);
ADD_XEN_INIT_REQ(&ptr, XEN_INIT_TYPE_XB_STATE_MAP_POST_CONNECT, NULL, NULL, NULL);
__ADD_XEN_INIT_UCHAR(&ptr, XenbusStateConnected);
__ADD_XEN_INIT_UCHAR(&ptr, XenbusStateConnected);
__ADD_XEN_INIT_UCHAR(&ptr, 20);
__ADD_XEN_INIT_UCHAR(&ptr, 0);
ADD_XEN_INIT_REQ(&ptr, XEN_INIT_TYPE_XB_STATE_MAP_SHUTDOWN, NULL, NULL, NULL);
__ADD_XEN_INIT_UCHAR(&ptr, XenbusStateClosing);
__ADD_XEN_INIT_UCHAR(&ptr, XenbusStateClosing);
__ADD_XEN_INIT_UCHAR(&ptr, 50);
__ADD_XEN_INIT_UCHAR(&ptr, XenbusStateClosed);
__ADD_XEN_INIT_UCHAR(&ptr, XenbusStateClosed);
__ADD_XEN_INIT_UCHAR(&ptr, 50);
//__ADD_XEN_INIT_UCHAR(&ptr, XenbusStateInitWait); //ialising);
//__ADD_XEN_INIT_UCHAR(&ptr, XenbusStateInitWait);
//__ADD_XEN_INIT_UCHAR(&ptr, 50);
__ADD_XEN_INIT_UCHAR(&ptr, 0);
ADD_XEN_INIT_REQ(&ptr, XEN_INIT_TYPE_END, NULL, NULL, NULL);
/* RegistryPath == NULL when we are invoked as a crash dump driver */
if (!RegistryPath)
{
dump_mode = TRUE;
}
RtlZeroMemory(&HwInitializationData, sizeof(HW_INITIALIZATION_DATA));
HwInitializationData.HwInitializationDataSize = sizeof(HW_INITIALIZATION_DATA);
HwInitializationData.AdapterInterfaceType = PNPBus;
HwInitializationData.DeviceExtensionSize = sizeof(XENSCSI_DEVICE_DATA);
HwInitializationData.SpecificLuExtensionSize = sizeof(XENSCSI_LU_DATA);
HwInitializationData.SrbExtensionSize = 0;
HwInitializationData.NumberOfAccessRanges = 1;
HwInitializationData.MapBuffers = TRUE;
HwInitializationData.NeedPhysicalAddresses = FALSE;
HwInitializationData.TaggedQueuing = TRUE;
HwInitializationData.AutoRequestSense = TRUE;
HwInitializationData.MultipleRequestPerLu = TRUE;
HwInitializationData.HwInitialize = XenScsi_HwScsiInitialize;
HwInitializationData.HwStartIo = XenScsi_HwScsiStartIo;
HwInitializationData.HwInterrupt = XenScsi_HwScsiInterrupt;
HwInitializationData.HwFindAdapter = XenScsi_HwScsiFindAdapter;
HwInitializationData.HwResetBus = XenScsi_HwScsiResetBus;
HwInitializationData.HwAdapterControl = XenScsi_HwScsiAdapterControl;
Status = ScsiPortInitialize(DriverObject, RegistryPath, &HwInitializationData, NULL);
if(!NT_SUCCESS(Status))
{
KdPrint((__DRIVER_NAME " ScsiPortInitialize failed with status 0x%08x\n", Status));
}
FUNCTION_EXIT();
return Status;
}
