/*************************************************************************** Copyright (c) 1998 Microsoft Corporation Module Name: USBSER.C Abstract: Main entry points for Legacy USB Modem Driver. All driver entry points here are called at IRQL = PASSIVE_LEVEL Environment: kernel mode only Notes: THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. Copyright (c) 1998 Microsoft Corporation. All Rights Reserved. Revision History: 12/23/97 : created Authors: Tom Green ****************************************************************************/ #include #include #include #include #include #include #include #include #ifdef WMI_SUPPORT #include #include #include #endif #include "usbser.h" #include "usbserpw.h" #include "serioctl.h" #include "utils.h" #include "debugwdm.h" #ifdef ALLOC_PRAGMA // // INIT - only needed during init and then can be disposed // PAGEUBS0 - always paged / never locked // PAGEUSBS - must be locked when a device is open, else paged // // // INIT is used for DriverEntry() specific code // // PAGEUBS0 is used for code that is not often called and has nothing // to do with I/O performance. An example, IRP_MJ_PNP/IRP_MN_START_DEVICE // support functions // // PAGEUSBS is used for code that needs to be locked after an open for both // performance and IRQL reasons. // #pragma alloc_text(INIT, DriverEntry) #pragma alloc_text(PAGEUSBS0, UsbSer_Unload) #pragma alloc_text(PAGEUSBS0, UsbSer_PnPAddDevice) #pragma alloc_text(PAGEUSBS0, UsbSer_PnP) #pragma alloc_text(PAGEUSBS0, UsbSerMajorNotSupported) #ifdef WMI_SUPPORT #pragma alloc_text(PAGEUSBS0, UsbSerSystemControlDispatch) #pragma alloc_text(PAGEUSBS0, UsbSerTossWMIRequest) #pragma alloc_text(PAGEUSBS0, UsbSerSetWmiDataItem) #pragma alloc_text(PAGEUSBS0, UsbSerSetWmiDataBlock) #pragma alloc_text(PAGEUSBS0, UsbSerQueryWmiDataBlock) #pragma alloc_text(PAGEUSBS0, UsbSerQueryWmiRegInfo) #else #pragma alloc_text(PAGEUSBS0, UsbSer_SystemControl) #endif // // PAGEUSBS is keyed off of UsbSer_Read, so UsbSer_Read must // remain in PAGEUSBS for things to work properly // #pragma alloc_text(PAGEUSBS, UsbSer_Cleanup) #pragma alloc_text(PAGEUSBS, UsbSer_Dispatch) #pragma alloc_text(PAGEUSBS, UsbSer_Create) #pragma alloc_text(PAGEUSBS, UsbSer_Close) #endif // ALLOC_PRAGMA UNICODE_STRING GlobalRegistryPath; #ifdef WMI_SUPPORT #define SERIAL_WMI_GUID_LIST_SIZE 1 #define WMI_SERIAL_PORT_NAME_INFORMATION 0 GUID SerialPortNameGuid = SERIAL_PORT_WMI_NAME_GUID; WMIGUIDREGINFO SerialWmiGuidList[SERIAL_WMI_GUID_LIST_SIZE] = { { &SerialPortNameGuid, 1, 0 } }; #endif /************************************************************************/ /* DriverEntry */ /************************************************************************/ /* */ /* Routine Description: */ /* */ /* Installable driver initialization entry point. */ /* This entry point is called directly by the I/O system. */ /* */ /* Arguments: */ /* */ /* DriverObject - pointer to the driver object */ /* */ /* RegistryPath - pointer to a unicode string representing the */ /* path to driver-specific key in the registry */ /* */ /* Return Value: */ /* */ /* NTSTATUS */ /* */ /************************************************************************/ NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath) { NTSTATUS NtStatus; PVOID lockPtr = MmLockPagableCodeSection(UsbSer_Read); PAGED_CODE(); // setup debug trace level #if 0 Usbser_Debug_Trace_Level = 0; #else Usbser_Debug_Trace_Level = 0; #endif // // Serial portion #if DBG UsbSerSerialDebugLevel = 0x00000000; PAGEUSBSER_Count = 0; #else UsbSerSerialDebugLevel = 0; #endif PAGEUSBSER_Handle = lockPtr; PAGEUSBSER_Function = UsbSer_Read; // Create dispatch points for device control, create, close, etc. DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = UsbSer_Dispatch; DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = UsbSer_Dispatch; DriverObject->MajorFunction[IRP_MJ_CREATE] = UsbSer_Create; DriverObject->MajorFunction[IRP_MJ_CLOSE] = UsbSer_Close; DriverObject->MajorFunction[IRP_MJ_WRITE] = UsbSer_Write; DriverObject->MajorFunction[IRP_MJ_READ] = UsbSer_Read; DriverObject->MajorFunction[IRP_MJ_CLEANUP] = UsbSer_Cleanup; DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = UsbSerMajorNotSupported; DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = UsbSerMajorNotSupported; #ifdef WMI_SUPPORT DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = UsbSerSystemControlDispatch; #else DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = UsbSer_SystemControl; #endif DriverObject->MajorFunction[IRP_MJ_PNP] = UsbSer_PnP; DriverObject->MajorFunction[IRP_MJ_POWER] = UsbSer_ProcessPowerIrp; DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = UsbSerFlush; DriverObject->DriverExtension->AddDevice = UsbSer_PnPAddDevice; DriverObject->DriverUnload = UsbSer_Unload; KeInitializeSpinLock(&GlobalSpinLock); GlobalRegistryPath.MaximumLength = RegistryPath->MaximumLength; GlobalRegistryPath.Length = RegistryPath->Length; GlobalRegistryPath.Buffer = DEBUG_MEMALLOC(PagedPool, GlobalRegistryPath.MaximumLength); if (GlobalRegistryPath.Buffer == NULL) { MmUnlockPagableImageSection(lockPtr); return STATUS_INSUFFICIENT_RESOURCES; } RtlZeroMemory(GlobalRegistryPath.Buffer, GlobalRegistryPath.MaximumLength); RtlMoveMemory(GlobalRegistryPath.Buffer, RegistryPath->Buffer, RegistryPath->Length); // initialize diagnostic stuff (history, tracing, error logging) DriverName = "USBSER"; DriverVersion = "0.99"; NtStatus = DEBUG_OPEN(); // log an error if we got one DEBUG_LOG_ERROR(NtStatus); DEBUG_LOG_PATH("exit DriverEntry"); DEBUG_TRACE3(("status (%08X)\n", NtStatus)); // // Unlock pageable text // MmUnlockPagableImageSection(lockPtr); return NtStatus; } // DriverEntry /************************************************************************/ /* UsbSer_Dispatch */ /************************************************************************/ /* */ /* Routine Description: */ /* */ /* Process the IRPs sent to this device. In this case IOCTLs and */ /* PNP IOCTLs */ /* */ /* Arguments: */ /* */ /* DeviceObject - pointer to a device object */ /* Irp - pointer to an I/O Request Packet */ /* */ /* Return Value: */ /* */ /* NTSTATUS */ /* */ /************************************************************************/ NTSTATUS UsbSer_Dispatch(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) { NTSTATUS NtStatus; PIO_STACK_LOCATION IrpStack; PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension; PVOID IoBuffer; ULONG InputBufferLength; ULONG OutputBufferLength; ULONG IoControlCode; BOOLEAN NeedCompletion = TRUE; KIRQL oldIrql; USBSER_LOCKED_PAGED_CODE(); DEBUG_LOG_PATH("enter UsbSer_Dispatch"); // set return values to something known NtStatus = Irp->IoStatus.Status = STATUS_SUCCESS; Irp->IoStatus.Information = 0; ACQUIRE_SPINLOCK(DeviceExtension, &DeviceExtension->ControlLock, &oldIrql); if (DeviceExtension->CurrentDevicePowerState != PowerDeviceD0) { RELEASE_SPINLOCK(DeviceExtension, &DeviceExtension->ControlLock, oldIrql); NtStatus = Irp->IoStatus.Status = STATUS_UNSUCCESSFUL; IoCompleteRequest(Irp, IO_NO_INCREMENT); goto UsbSer_DispatchErr; } RELEASE_SPINLOCK(DeviceExtension, &DeviceExtension->ControlLock, oldIrql); // Get a pointer to the current location in the Irp. This is where // the function codes and parameters are located. IrpStack = IoGetCurrentIrpStackLocation(Irp); // Get the pointer to the input/output buffer and it's length IoBuffer = Irp->AssociatedIrp.SystemBuffer; InputBufferLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength; OutputBufferLength = IrpStack->Parameters.DeviceIoControl.OutputBufferLength; // make entry in IRP history table DEBUG_LOG_IRP_HIST(DeviceObject, Irp, IrpStack->MajorFunction, IoBuffer, InputBufferLength); switch (IrpStack->MajorFunction) { case IRP_MJ_DEVICE_CONTROL: DEBUG_LOG_PATH("IRP_MJ_DEVICE_CONTROL"); IoControlCode = IrpStack->Parameters.DeviceIoControl.IoControlCode; switch (IoControlCode) { #ifdef PROFILING_ENABLED case GET_DRIVER_LOG: DEBUG_LOG_PATH("GET_DRIVER_LOG"); // make sure we have a buffer length and a buffer if (!OutputBufferLength || !IoBuffer) NtStatus = STATUS_BUFFER_TOO_SMALL; else { // make sure buffer contains null terminator ((PCHAR) IoBuffer)[0] = '\0'; Irp->IoStatus.Information = Debug_DumpDriverLog(DeviceObject, IoBuffer, OutputBufferLength); } break; case GET_IRP_HIST: DEBUG_LOG_PATH("GET_IRP_HIST"); // make sure we have a buffer length and a buffer if (!OutputBufferLength || !IoBuffer) NtStatus = STATUS_BUFFER_TOO_SMALL; else { // make sure buffer contains null terminator ((PCHAR) IoBuffer)[0] = '\0'; Irp->IoStatus.Information = Debug_ExtractIRPHist(IoBuffer, OutputBufferLength); } break; case GET_PATH_HIST: DEBUG_LOG_PATH("GET_PATH_HIST"); // make sure we have a buffer length and a buffer if (!OutputBufferLength || !IoBuffer) NtStatus = STATUS_BUFFER_TOO_SMALL; else { // make sure buffer contains null terminator ((PCHAR) IoBuffer)[0] = '\0'; Irp->IoStatus.Information = Debug_ExtractPathHist(IoBuffer, OutputBufferLength); } break; case GET_ERROR_LOG: DEBUG_LOG_PATH("GET_ERROR_LOG"); // make sure we have a buffer length and a buffer if (!OutputBufferLength || !IoBuffer) NtStatus = STATUS_BUFFER_TOO_SMALL; else { // make sure buffer contains null terminator ((PCHAR) IoBuffer)[0] = '\0'; Irp->IoStatus.Information = Debug_ExtractErrorLog(IoBuffer, OutputBufferLength); } break; case GET_ATTACHED_DEVICES: DEBUG_LOG_PATH("GET_ATTACHED_DEVICES"); // make sure we have a buffer length and a buffer if (!OutputBufferLength || !IoBuffer) NtStatus = STATUS_BUFFER_TOO_SMALL; else { // make sure buffer contains null terminator ((PCHAR) IoBuffer)[0] = '\0'; Irp->IoStatus.Information = Debug_ExtractAttachedDevices(DeviceObject->DriverObject, IoBuffer, OutputBufferLength); } break; case GET_DRIVER_INFO: DEBUG_LOG_PATH("GET_DRIVER_INFO"); // make sure we have a buffer length and a buffer if (!OutputBufferLength || !IoBuffer) NtStatus = STATUS_BUFFER_TOO_SMALL; else { // make sure buffer contains null terminator ((PCHAR) IoBuffer)[0] = '\0'; Irp->IoStatus.Information = Debug_GetDriverInfo(IoBuffer, OutputBufferLength); } break; case SET_IRP_HIST_SIZE: DEBUG_LOG_PATH("SET_IRP_HIST_SIZE"); // make sure we have a correct buffer length and a buffer if (InputBufferLength != sizeof(ULONG) || !IoBuffer) NtStatus = STATUS_BUFFER_TOO_SMALL; else NtStatus = Debug_SizeIRPHistoryTable(*((ULONG *) IoBuffer)); break; case SET_PATH_HIST_SIZE: DEBUG_LOG_PATH("SET_PATH_HIST_SIZE"); // make sure we have a correct buffer length and a buffer if (InputBufferLength != sizeof(ULONG) || !IoBuffer) NtStatus = STATUS_BUFFER_TOO_SMALL; else NtStatus = Debug_SizeDebugPathHist(*((ULONG *) IoBuffer)); break; case SET_ERROR_LOG_SIZE: DEBUG_LOG_PATH("SET_ERROR_LOG_SIZE"); // make sure we have a correct buffer length and a buffer if (InputBufferLength != sizeof(long) || !IoBuffer) NtStatus = STATUS_BUFFER_TOO_SMALL; else NtStatus = Debug_SizeErrorLog(*((ULONG *) IoBuffer)); break; #endif // PROFILING_ENABLED case ENABLE_PERF_TIMING: DEBUG_LOG_PATH("ENABLE_PERF_TIMING"); // enable perf timing DeviceExtension->PerfTimerEnabled = TRUE; // reset BytesXfered, ElapsedTime and TimerStart DeviceExtension->BytesXfered = RtlConvertUlongToLargeInteger(0L); DeviceExtension->ElapsedTime = RtlConvertUlongToLargeInteger(0L); DeviceExtension->TimerStart = RtlConvertUlongToLargeInteger(0L); break; case DISABLE_PERF_TIMING: DEBUG_LOG_PATH("DISABLE_PERF_TIMING"); // disable perf timing DeviceExtension->PerfTimerEnabled = FALSE; break; case GET_PERF_DATA: DEBUG_LOG_PATH("GET_PERF_DATA"); // make sure we have enough space to return perf info if (OutputBufferLength < sizeof(PERF_INFO) || !IoBuffer) NtStatus = Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; else { PPERF_INFO Perf = (PPERF_INFO) IoBuffer; Perf->PerfModeEnabled = DeviceExtension->PerfTimerEnabled; Perf->BytesPerSecond = BytesPerSecond(DeviceExtension); Irp->IoStatus.Information = sizeof(PERF_INFO); } break; case SET_DEBUG_TRACE_LEVEL: // make sure we have a correct buffer length and a buffer if (InputBufferLength != sizeof(long) || !IoBuffer) NtStatus = STATUS_BUFFER_TOO_SMALL; else Usbser_Debug_Trace_Level = *((ULONG *) IoBuffer); break; // handle IOCTLs for a "serial" device case IOCTL_SERIAL_SET_BAUD_RATE: DEBUG_LOG_PATH("IOCTL_SERIAL_SET_BAUD_RATE"); NtStatus = SetBaudRate(Irp, DeviceObject); break; case IOCTL_SERIAL_GET_BAUD_RATE: DEBUG_LOG_PATH("IOCTL_SERIAL_GET_BAUD_RATE"); NtStatus = GetBaudRate(Irp, DeviceObject); break; case IOCTL_SERIAL_SET_LINE_CONTROL: DEBUG_LOG_PATH("IOCTL_SERIAL_SET_LINE_CONTROL"); NtStatus = SetLineControl(Irp, DeviceObject); break; case IOCTL_SERIAL_GET_LINE_CONTROL: DEBUG_LOG_PATH("IOCTL_SERIAL_GET_LINE_CONTROL"); NtStatus = GetLineControl(Irp, DeviceObject); break; case IOCTL_SERIAL_SET_TIMEOUTS: DEBUG_LOG_PATH("IOCTL_SERIAL_SET_TIMEOUTS"); NtStatus = SetTimeouts(Irp, DeviceExtension); break; case IOCTL_SERIAL_GET_TIMEOUTS: DEBUG_LOG_PATH("IOCTL_SERIAL_GET_TIMEOUTS"); NtStatus = GetTimeouts(Irp, DeviceExtension); break; case IOCTL_SERIAL_SET_CHARS: DEBUG_LOG_PATH("IOCTL_SERIAL_SET_CHARS"); NtStatus = SetChars(Irp, DeviceExtension); break; case IOCTL_SERIAL_GET_CHARS: DEBUG_LOG_PATH("IOCTL_SERIAL_GET_CHARS"); NtStatus = GetChars(Irp, DeviceExtension); break; case IOCTL_SERIAL_SET_DTR: DEBUG_LOG_PATH("IOCTL_SERIAL_SET_DTR"); NtStatus = SetClrDtr(DeviceObject, TRUE); break; case IOCTL_SERIAL_CLR_DTR: DEBUG_LOG_PATH("IOCTL_SERIAL_CLR_DTR"); NtStatus = SetClrDtr(DeviceObject, FALSE); break; case IOCTL_SERIAL_RESET_DEVICE: DEBUG_LOG_PATH("IOCTL_SERIAL_RESET_DEVICE"); NtStatus = ResetDevice(Irp, DeviceObject); break; case IOCTL_SERIAL_SET_RTS: DEBUG_LOG_PATH("IOCTL_SERIAL_SET_RTS"); NtStatus = SetRts(Irp, DeviceExtension); break; case IOCTL_SERIAL_CLR_RTS: DEBUG_LOG_PATH("IOCTL_SERIAL_CLR_RTS"); NtStatus = ClrRts(Irp, DeviceExtension); break; case IOCTL_SERIAL_SET_BREAK_ON: DEBUG_LOG_PATH("IOCTL_SERIAL_SET_BREAK_ON"); NtStatus = SetBreak(Irp, DeviceObject, 0xFFFF); break; case IOCTL_SERIAL_SET_BREAK_OFF: DEBUG_LOG_PATH("IOCTL_SERIAL_SET_BREAK_OFF"); NtStatus = SetBreak(Irp, DeviceObject, 0); break; case IOCTL_SERIAL_SET_QUEUE_SIZE: DEBUG_LOG_PATH("IOCTL_SERIAL_SET_QUEUE_SIZE"); NtStatus = SetQueueSize(Irp, DeviceExtension); break; case IOCTL_SERIAL_GET_WAIT_MASK: DEBUG_LOG_PATH("IOCTL_SERIAL_GET_WAIT_MASK"); NtStatus = GetWaitMask(Irp, DeviceExtension); break; case IOCTL_SERIAL_SET_WAIT_MASK: DEBUG_LOG_PATH("IOCTL_SERIAL_SET_WAIT_MASK"); NtStatus = SetWaitMask(Irp, DeviceExtension); break; case IOCTL_SERIAL_WAIT_ON_MASK: DEBUG_LOG_PATH("IOCTL_SERIAL_WAIT_ON_MASK"); NtStatus = WaitOnMask(Irp, DeviceExtension); break; case IOCTL_SERIAL_IMMEDIATE_CHAR: DEBUG_LOG_PATH("IOCTL_SERIAL_IMMEDIATE_CHAR"); NeedCompletion = FALSE; NtStatus = ImmediateChar(Irp, DeviceObject); if(NtStatus == STATUS_BUFFER_TOO_SMALL) NeedCompletion = TRUE; break; case IOCTL_SERIAL_PURGE: DEBUG_LOG_PATH("IOCTL_SERIAL_PURGE"); NtStatus = Purge(DeviceObject, Irp, DeviceExtension); break; case IOCTL_SERIAL_GET_HANDFLOW: DEBUG_LOG_PATH("IOCTL_SERIAL_GET_HANDFLOW"); NtStatus = GetHandflow(Irp, DeviceExtension); break; case IOCTL_SERIAL_SET_HANDFLOW: DEBUG_LOG_PATH("IOCTL_SERIAL_SET_HANDFLOW"); NtStatus = SetHandflow(Irp, DeviceExtension); break; case IOCTL_SERIAL_GET_MODEMSTATUS: DEBUG_LOG_PATH("IOCTL_SERIAL_GET_MODEMSTATUS"); NtStatus = GetModemStatus(Irp, DeviceExtension); break; case IOCTL_SERIAL_GET_DTRRTS: DEBUG_LOG_PATH("IOCTL_SERIAL_GET_DTRRTS"); NtStatus = GetDtrRts(Irp, DeviceExtension); break; case IOCTL_SERIAL_GET_COMMSTATUS: DEBUG_LOG_PATH("IOCTL_SERIAL_GET_COMMSTATUS"); NtStatus = GetCommStatus(Irp, DeviceExtension); break; case IOCTL_SERIAL_GET_PROPERTIES: DEBUG_LOG_PATH("IOCTL_SERIAL_GET_PROPERTIES"); NtStatus = GetProperties(Irp, DeviceExtension); break; case IOCTL_SERIAL_LSRMST_INSERT: DEBUG_LOG_PATH("IOCTL_SERIAL_LSRMST_INSERT"); NtStatus = LsrmstInsert(Irp, DeviceExtension); break; case IOCTL_SERIAL_CONFIG_SIZE: DEBUG_LOG_PATH("IOCTL_SERIAL_CONFIG_SIZE"); NtStatus = ConfigSize(Irp, DeviceExtension); break; case IOCTL_SERIAL_GET_STATS: DEBUG_LOG_PATH("IOCTL_SERIAL_GET_STATS"); NtStatus = GetStats(Irp, DeviceExtension); break; case IOCTL_SERIAL_CLEAR_STATS: DEBUG_LOG_PATH("IOCTL_SERIAL_CLEAR_STATS"); NtStatus = ClearStats(Irp, DeviceExtension); break; default: NtStatus = STATUS_INVALID_PARAMETER; } break; // breaking out here will complete the Irp case IRP_MJ_INTERNAL_DEVICE_CONTROL: DEBUG_TRACE1(("IRP_MJ_INTERNAL_DEVICE_CONTROL\n")); switch (IrpStack->Parameters.DeviceIoControl.IoControlCode) { case IOCTL_SERIAL_INTERNAL_DO_WAIT_WAKE: DEBUG_TRACE1(("IOCTL_SERIAL_INTERNAL_DO_WAIT_WAKE\n")); DeviceExtension->SendWaitWake = TRUE; NtStatus = STATUS_SUCCESS; break; case IOCTL_SERIAL_INTERNAL_CANCEL_WAIT_WAKE: DEBUG_TRACE1(("IOCTL_SERIAL_INTERNAL_CANCEL_WAIT_WAKE\n")); DeviceExtension->SendWaitWake = FALSE; if (DeviceExtension->PendingWakeIrp != NULL) { IoCancelIrp(DeviceExtension->PendingWakeIrp); } NtStatus = STATUS_SUCCESS; break; default: // pass through to driver below DEBUG_LOG_PATH("IRP_MJ_INTERNAL_DEVICE_CONTROL"); // since I dont have a completion routine use // IoCopyCurrentIrp IoCopyCurrentIrpStackLocationToNext(Irp); IoMarkIrpPending(Irp); NtStatus = IoCallDriver(DeviceExtension->StackDeviceObject, Irp); DEBUG_TRACE3(("Passed PnP Irp down, NtStatus = %08X\n", NtStatus)); NeedCompletion = FALSE; break; } default: DEBUG_LOG_PATH("MAJOR IOCTL not handled"); Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; break; } if (NeedCompletion && NtStatus != STATUS_PENDING) { Irp->IoStatus.Status = NtStatus; CompleteIO(DeviceObject, Irp, IrpStack->MajorFunction, IoBuffer, Irp->IoStatus.Information); } UsbSer_DispatchErr:; // log an error if we got one DEBUG_LOG_ERROR(NtStatus); DEBUG_LOG_PATH("exit UsbSer_Dispatch"); DEBUG_TRACE3(("status (%08X)\n", NtStatus)); return NtStatus; } // UsbSer_Dispatch /************************************************************************/ /* UsbSer_Create */ /************************************************************************/ /* */ /* Routine Description: */ /* */ /* Process the IRPs sent to this device for Create calls */ /* */ /* Arguments: */ /* */ /* DeviceObject - pointer to a device object */ /* Irp - pointer to an I/O Request Packet */ /* */ /* Return Value: */ /* */ /* NTSTATUS */ /* */ /************************************************************************/ NTSTATUS UsbSer_Create(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) { NTSTATUS NtStatus; PIO_STACK_LOCATION IrpStack; PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension; PVOID IoBuffer; ULONG InputBufferLength; KIRQL OldIrql; USBSER_LOCKED_PAGED_CODE(); DEBUG_LOG_PATH("enter UsbSer_Create"); DEBUG_TRACE1(("Open\n")); UsbSerSerialDump(USBSERTRACEOTH, (">UsbSer_Create(%08X)\n", Irp)); // wakeup device from previous idle // UsbSerFdoRequestWake(DeviceExtension); // set return values to something known NtStatus = Irp->IoStatus.Status = STATUS_SUCCESS; Irp->IoStatus.Information = 0; // Get a pointer to the current location in the Irp. This is where // the function codes and parameters are located. IrpStack = IoGetCurrentIrpStackLocation(Irp); // Get the pointer to the input/output buffer and it's length IoBuffer = Irp->AssociatedIrp.SystemBuffer; InputBufferLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength; // make entry in IRP history table DEBUG_LOG_IRP_HIST(DeviceObject, Irp, IrpStack->MajorFunction, IoBuffer, 0); // // Serial devices do not allow multiple concurrent opens // if (InterlockedIncrement(&DeviceExtension->OpenCnt) != 1) { InterlockedDecrement(&DeviceExtension->OpenCnt); NtStatus = Irp->IoStatus.Status = STATUS_ACCESS_DENIED; goto UsbSer_CreateErr; } // // Before we do anything, let's make sure they aren't trying // to create a directory. // if (IrpStack->Parameters.Create.Options & FILE_DIRECTORY_FILE) { InterlockedDecrement(&DeviceExtension->OpenCnt); NtStatus = Irp->IoStatus.Status = STATUS_NOT_A_DIRECTORY; Irp->IoStatus.Information = 0; goto UsbSer_CreateErr; } // // Lock down our code pages // PAGEUSBSER_Handle = UsbSerLockPagableCodeSection(UsbSer_Read); ASSERT(DeviceExtension->IsDevice); ACQUIRE_SPINLOCK(DeviceExtension, &DeviceExtension->ControlLock, &OldIrql); DeviceExtension->IsrWaitMask = 0; DeviceExtension->EscapeChar = 0; RtlZeroMemory(&DeviceExtension->PerfStats, sizeof(SERIALPERF_STATS)); // // Purge the RX buffer // DeviceExtension->CharsInReadBuff = 0; DeviceExtension->CurrentReadBuffPtr = 0; DeviceExtension->HistoryMask = 0; DeviceExtension->EscapeChar = 0; DeviceExtension->SendWaitWake = FALSE; RELEASE_SPINLOCK(DeviceExtension, &DeviceExtension->ControlLock, OldIrql); // // Restart the read // RestartRead(DeviceExtension); UsbSer_CreateErr:; CompleteIO(DeviceObject, Irp, IrpStack->MajorFunction, IoBuffer, Irp->IoStatus.Information); // log an error if we got one DEBUG_LOG_ERROR(NtStatus); DEBUG_LOG_PATH("exit UsbSer_Create"); DEBUG_TRACE3(("status (%08X)\n", NtStatus)); UsbSerSerialDump(USBSERTRACEOTH, ("DeviceExtension; PIO_STACK_LOCATION IrpStack; PVOID IoBuffer; ULONG InputBufferLength; ULONG openCount; PAGED_CODE(); DEBUG_LOG_PATH("enter UsbSer_Close"); DEBUG_TRACE1(("Close\n")); UsbSerSerialDump(USBSERTRACEOTH, (">UsbSer_Close(%08X)\n", Irp)); // set return values to something known NtStatus = Irp->IoStatus.Status = STATUS_SUCCESS; Irp->IoStatus.Information = 0; // Get a pointer to the current location in the Irp. This is where // the function codes and parameters are located. IrpStack = IoGetCurrentIrpStackLocation(Irp); // Get the pointer to the input/output buffer and it's length IoBuffer = Irp->AssociatedIrp.SystemBuffer; InputBufferLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength; // clear DTR, this is what the serial driver does SetClrDtr(DeviceObject, FALSE); // // Stop waiting for wakeup // DeviceExtension->SendWaitWake = FALSE; if (DeviceExtension->PendingWakeIrp != NULL) { IoCancelIrp(DeviceExtension->PendingWakeIrp); } // make entry in IRP history table DEBUG_LOG_IRP_HIST(DeviceObject, Irp, IrpStack->MajorFunction, IoBuffer, 0); ASSERT(DeviceExtension->IsDevice); openCount = InterlockedDecrement(&DeviceExtension->OpenCnt); ASSERT(openCount == 0); CompleteIO(DeviceObject, Irp, IrpStack->MajorFunction, IoBuffer, Irp->IoStatus.Information); // try and idle the modem // UsbSerFdoSubmitIdleRequestIrp(DeviceExtension); // log an error if we got one DEBUG_LOG_ERROR(NtStatus); DEBUG_LOG_PATH("exit UsbSer_Close"); DEBUG_TRACE3(("status (%08X)\n", NtStatus)); UsbSerSerialDump(USBSERTRACEOTH, ("DeviceExtension; // Attach to the PDO DeviceExtension->StackDeviceObject = IoAttachDeviceToDeviceStack(DeviceObject, PhysicalDeviceObject); DEBUG_TRACE3(("StackDeviceObject (%08X)\n", DeviceExtension->StackDeviceObject)); // if we don't have a stack device object to attach to, bong it if (!DeviceExtension->StackDeviceObject) { IoDeleteDevice(DeviceObject); NtStatus = STATUS_NO_SUCH_DEVICE; } else { // do some device extension house keeping DeviceExtension->PerfTimerEnabled = FALSE; DeviceExtension->PhysDeviceObject = PhysicalDeviceObject; DeviceExtension->BytesXfered = RtlConvertUlongToLargeInteger(0L); DeviceExtension->ElapsedTime = RtlConvertUlongToLargeInteger(0L); DeviceExtension->TimerStart = RtlConvertUlongToLargeInteger(0L); DeviceExtension->CurrentDevicePowerState = PowerDeviceD0; // init selective suspend stuff DeviceExtension->PendingIdleIrp = NULL; DeviceExtension->IdleCallbackInfo = NULL; DeviceObject->StackSize = DeviceExtension->StackDeviceObject->StackSize + 1; // we support buffered io for read/write DeviceObject->Flags |= DO_BUFFERED_IO; // power mangement DeviceObject->Flags |= DO_POWER_PAGABLE; // we are done initializing the device object, so say so DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING; // get device capabilities UsbSerQueryCapabilities(DeviceExtension->StackDeviceObject, &DeviceExtension->DeviceCapabilities); // We want to determine what level to auto-powerdown to; This is the // lowest sleeping level that is LESS than D3; // If all are set to D3, auto powerdown/powerup will be disabled. // init to disabled DeviceExtension->PowerDownLevel = PowerDeviceUnspecified; for (Index = PowerSystemSleeping1; Index <= PowerSystemSleeping3; Index++) { if (DeviceExtension->DeviceCapabilities.DeviceState[Index] < PowerDeviceD3) DeviceExtension->PowerDownLevel = DeviceExtension->DeviceCapabilities.DeviceState[Index]; } #ifdef WMI_SUPPORT // // Register for WMI // DeviceExtension->WmiLibInfo.GuidCount = sizeof(SerialWmiGuidList) / sizeof(WMIGUIDREGINFO); DeviceExtension->WmiLibInfo.GuidList = SerialWmiGuidList; DeviceExtension->WmiLibInfo.QueryWmiRegInfo = UsbSerQueryWmiRegInfo; DeviceExtension->WmiLibInfo.QueryWmiDataBlock = UsbSerQueryWmiDataBlock; DeviceExtension->WmiLibInfo.SetWmiDataBlock = UsbSerSetWmiDataBlock; DeviceExtension->WmiLibInfo.SetWmiDataItem = UsbSerSetWmiDataItem; DeviceExtension->WmiLibInfo.ExecuteWmiMethod = NULL; DeviceExtension->WmiLibInfo.WmiFunctionControl = NULL; IoWMIRegistrationControl(DeviceObject, WMIREG_ACTION_REGISTER); #endif } } // log an error if we got one DEBUG_LOG_ERROR(NtStatus); // init to disabled DEBUG_LOG_PATH("exit UsbSer_PnPAddDevice"); DEBUG_TRACE3(("status (%08X)\n", NtStatus)); return NtStatus; } // UsbSer_PnPAddDevice /************************************************************************/ /* UsbSer_PnP */ /************************************************************************/ /* */ /* Routine Description: */ /* */ /* This routine will receive the various Plug N Play messages. It */ /* is here that we start our device, stop it, etc. */ /* */ /* Arguments: */ /* */ /* DeviceObject - pointer to a device object */ /* Irp - pointer to an I/O Request Packet */ /* */ /* Return Value: */ /* */ /* NTSTATUS */ /* */ /************************************************************************/ NTSTATUS UsbSer_PnP(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) { NTSTATUS NtStatus = STATUS_SUCCESS; PIO_STACK_LOCATION IrpStack; PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension; PVOID IoBuffer; ULONG InputBufferLength; BOOLEAN PassDown = TRUE; PAGED_CODE(); DEBUG_LOG_PATH("enter UsbSer_PnP"); // Get a pointer to the current location in the Irp. This is where // the function codes and parameters are located. IrpStack = IoGetCurrentIrpStackLocation(Irp); // Get the pointer to the input/output buffer and it's length IoBuffer = Irp->AssociatedIrp.SystemBuffer; InputBufferLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength; // make entry in IRP history table DEBUG_LOG_IRP_HIST(DeviceObject, Irp, IrpStack->MajorFunction, IoBuffer, InputBufferLength); switch (IrpStack->MinorFunction) { case IRP_MN_START_DEVICE: DEBUG_LOG_PATH("IRP_MN_START_DEVICE"); NtStatus = StartDevice(DeviceObject, Irp); // passed Irp to driver below and completed in start device routine PassDown = FALSE; break; case IRP_MN_QUERY_REMOVE_DEVICE: DEBUG_LOG_PATH("IRP_MN_QUERY_REMOVE_DEVICE"); break; case IRP_MN_REMOVE_DEVICE: DEBUG_LOG_PATH("IRP_MN_REMOVE_DEVICE"); #ifdef WMI_SUPPORT IoWMIRegistrationControl(DeviceObject, WMIREG_ACTION_DEREGISTER); #endif NtStatus = RemoveDevice(DeviceObject, Irp); PassDown = FALSE; break; case IRP_MN_CANCEL_REMOVE_DEVICE: DEBUG_LOG_PATH("IRP_MN_CANCEL_REMOVE_DEVICE"); break; case IRP_MN_STOP_DEVICE: DEBUG_LOG_PATH("IRP_MN_STOP_DEVICE"); NtStatus = StopDevice(DeviceObject, Irp); break; case IRP_MN_QUERY_STOP_DEVICE: DEBUG_LOG_PATH("IRP_MN_QUERY_STOP_DEVICE"); break; case IRP_MN_CANCEL_STOP_DEVICE: DEBUG_LOG_PATH("IRP_MN_CANCEL_STOP_DEVICE"); break; case IRP_MN_QUERY_DEVICE_RELATIONS: DEBUG_LOG_PATH("IRP_MN_QUERY_DEVICE_RELATIONS"); break; case IRP_MN_QUERY_INTERFACE: DEBUG_LOG_PATH("IRP_MN_QUERY_INTERFACE"); break; case IRP_MN_QUERY_CAPABILITIES: DEBUG_TRACE2(("IRP_MN_QUERY_CAPABILITIES\n")); { PKEVENT pQueryCapsEvent; PDEVICE_CAPABILITIES pDevCaps; pQueryCapsEvent = ExAllocatePool(NonPagedPool, sizeof(KEVENT)); if (pQueryCapsEvent == NULL) { Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; IoCompleteRequest(Irp, IO_NO_INCREMENT); return STATUS_INSUFFICIENT_RESOURCES; } KeInitializeEvent(pQueryCapsEvent, SynchronizationEvent, FALSE); IoCopyCurrentIrpStackLocationToNext(Irp); IoSetCompletionRoutine(Irp, UsbSerSyncCompletion, pQueryCapsEvent, TRUE, TRUE, TRUE); NtStatus = IoCallDriver(DeviceExtension->StackDeviceObject, Irp); // // Wait for lower drivers to be done with the Irp // if (NtStatus == STATUS_PENDING) { KeWaitForSingleObject(pQueryCapsEvent, Executive, KernelMode, FALSE, NULL); } ExFreePool(pQueryCapsEvent); NtStatus = Irp->IoStatus.Status; if (IrpStack->Parameters.DeviceCapabilities.Capabilities == NULL) { goto errQueryCaps; } // // Save off their power capabilities // IrpStack = IoGetCurrentIrpStackLocation(Irp); pDevCaps = IrpStack->Parameters.DeviceCapabilities.Capabilities; pDevCaps->SurpriseRemovalOK = TRUE; DeviceExtension->SystemWake = pDevCaps->SystemWake; DeviceExtension->DeviceWake = pDevCaps->DeviceWake; UsbSerSerialDump(USBSERTRACEPW, ("IRP_MN_QUERY_CAPS: SystemWake %08X " "DeviceWake %08X\n", DeviceExtension->SystemWake, DeviceExtension->DeviceWake)); errQueryCaps:; IoCompleteRequest(Irp, IO_NO_INCREMENT); return NtStatus; } case IRP_MN_QUERY_RESOURCES: DEBUG_LOG_PATH("IRP_MN_QUERY_RESOURCES"); break; case IRP_MN_QUERY_RESOURCE_REQUIREMENTS: DEBUG_LOG_PATH("IRP_MN_QUERY_RESOURCE_REQUIREMENTS"); break; case IRP_MN_QUERY_DEVICE_TEXT: DEBUG_LOG_PATH("IRP_MN_QUERY_DEVICE_TEXT"); break; case IRP_MN_READ_CONFIG: DEBUG_LOG_PATH("IRP_MN_READ_CONFIG"); break; case IRP_MN_WRITE_CONFIG: DEBUG_LOG_PATH("IRP_MN_WRITE_CONFIG"); break; case IRP_MN_EJECT: DEBUG_LOG_PATH("IRP_MN_EJECT"); break; case IRP_MN_SET_LOCK: DEBUG_LOG_PATH("IRP_MN_SET_LOCK"); break; case IRP_MN_QUERY_ID: DEBUG_LOG_PATH("IRP_MN_QUERY_ID"); break; case IRP_MN_QUERY_PNP_DEVICE_STATE: DEBUG_LOG_PATH("IRP_MN_QUERY_PNP_DEVICE_STATE"); break; case IRP_MN_QUERY_BUS_INFORMATION: DEBUG_LOG_PATH("IRP_MN_QUERY_BUS_INFORMATION"); break; case IRP_MN_SURPRISE_REMOVAL: { PIRP CurrentMaskIrp; KIRQL CancelIrql; DEBUG_TRACE2(("IRP_MN_SURPRISE_REMOVAL\n")); ACQUIRE_CANCEL_SPINLOCK(DeviceExtension, &CancelIrql); // surprise removal, so stop accepting requests UsbSerFetchBooleanLocked(&DeviceExtension->AcceptingRequests, FALSE, &DeviceExtension->ControlLock); // let's see if we have any events to signal CurrentMaskIrp = DeviceExtension->CurrentMaskIrp; // complete the queued IRP if needed if(CurrentMaskIrp) { // indicate to upper layers that CD dropped if needed if((DeviceExtension->IsrWaitMask & SERIAL_EV_RLSD) && (DeviceExtension->FakeModemStatus & SERIAL_MSR_DCD)) { DEBUG_TRACE2(("Sending up a CD dropped event\n")); DeviceExtension->FakeModemStatus &= ~SERIAL_MSR_DCD; DeviceExtension->HistoryMask |= SERIAL_EV_RLSD; CurrentMaskIrp->IoStatus.Status = STATUS_SUCCESS; CurrentMaskIrp->IoStatus.Information = sizeof(ULONG); DeviceExtension->CurrentMaskIrp = NULL; *(PULONG) (CurrentMaskIrp->AssociatedIrp.SystemBuffer) = DeviceExtension->HistoryMask; DeviceExtension->HistoryMask = 0; IoSetCancelRoutine(CurrentMaskIrp, NULL); RELEASE_CANCEL_SPINLOCK(DeviceExtension, CancelIrql); IoCompleteRequest(CurrentMaskIrp, IO_NO_INCREMENT); } else { RELEASE_CANCEL_SPINLOCK(DeviceExtension, CancelIrql); } } else { RELEASE_CANCEL_SPINLOCK(DeviceExtension, CancelIrql); } Irp->IoStatus.Status = STATUS_SUCCESS; break; } default: DEBUG_LOG_PATH("PnP IOCTL not handled"); DEBUG_TRACE3(("IOCTL (%08X)\n", IrpStack->MinorFunction)); break; } // case of IRP_MJ_PNP // All PNP POWER messages get passed to StackDeviceObject. if (PassDown) { DEBUG_TRACE3(("Passing PnP Irp down, status (%08X)\n", NtStatus)); IoCopyCurrentIrpStackLocationToNext(Irp); DEBUG_LOG_PATH("Passing PnP Irp down stack"); NtStatus = IoCallDriver(DeviceExtension->StackDeviceObject, Irp); } // log an error if we got one DEBUG_LOG_ERROR(NtStatus); DEBUG_LOG_PATH("exit UsbSer_PnP"); DEBUG_TRACE3(("status (%08X)\n", NtStatus)); return NtStatus; } // UsbSer_PnP #ifndef WMI_SUPPORT /************************************************************************/ /* UsbSer_SystemControl */ /************************************************************************/ /* */ /* Routine Description: */ /* */ /* This routine will receive the various system control messages. */ /* */ /* Arguments: */ /* */ /* DeviceObject - pointer to a device object */ /* Irp - pointer to an I/O Request Packet */ /* */ /* Return Value: */ /* */ /* NTSTATUS */ /* */ /************************************************************************/ NTSTATUS UsbSer_SystemControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) { NTSTATUS NtStatus = STATUS_SUCCESS; PIO_STACK_LOCATION IrpStack; PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension; PVOID IoBuffer; ULONG InputBufferLength; PAGED_CODE(); DEBUG_LOG_PATH("enter UsbSer_SystemControl"); // Get a pointer to the current location in the Irp. This is where // the function codes and parameters are located. IrpStack = IoGetCurrentIrpStackLocation(Irp); // Get the pointer to the input/output buffer and it's length IoBuffer = Irp->AssociatedIrp.SystemBuffer; InputBufferLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength; // make entry in IRP history table DEBUG_LOG_IRP_HIST(DeviceObject, Irp, IrpStack->MajorFunction, IoBuffer, InputBufferLength); // All System Control messages get passed to StackDeviceObject. IoCopyCurrentIrpStackLocationToNext(Irp); NtStatus = IoCallDriver(DeviceExtension->StackDeviceObject, Irp); // log an error if we got one DEBUG_LOG_ERROR(NtStatus); DEBUG_LOG_PATH("exit UsbSer_SystemControl"); DEBUG_TRACE3(("status (%08X)\n", NtStatus)); return NtStatus; } // UsbSer_SystemControl #endif /************************************************************************/ /* UsbSer_Cleanup */ /************************************************************************/ /* */ /* Routine Description: */ /* */ /* Arguments: */ /* */ /* DeviceObject - pointer to a device object */ /* Irp - pointer to an I/O Request Packet */ /* */ /* Return Value: */ /* */ /* NTSTATUS */ /* */ /************************************************************************/ NTSTATUS UsbSer_Cleanup(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) { NTSTATUS NtStatus = STATUS_SUCCESS; USBSER_LOCKED_PAGED_CODE(); DEBUG_LOG_PATH("enter UsbSer_Cleanup"); UsbSerSerialDump(USBSERTRACEOTH, (">UsbSer_Cleanup(%08X)\n", Irp)); Irp->IoStatus.Status = STATUS_SUCCESS; Irp->IoStatus.Information = 0; UsbSerKillPendingIrps(DeviceObject); IoCompleteRequest(Irp, IO_NO_INCREMENT); // log an error if we got one DEBUG_LOG_ERROR(NtStatus); DEBUG_LOG_PATH("exit UsbSer_Cleanup"); DEBUG_TRACE3(("status (%08X)\n", NtStatus)); UsbSerSerialDump(USBSERTRACEOTH, ("MajorFunction)); Irp->IoStatus.Status = STATUS_NOT_SUPPORTED; // log an error if we got one DEBUG_LOG_ERROR(STATUS_NOT_SUPPORTED); DEBUG_LOG_PATH("exit UsbSerMajorNotSupported"); DEBUG_TRACE3(("status (%08X)\n", STATUS_NOT_SUPPORTED)); IoCompleteRequest(Irp, IO_NO_INCREMENT); return STATUS_NOT_SUPPORTED; } // UsbSerMajorNotSupported #ifdef WMI_SUPPORT NTSTATUS UsbSerSystemControlDispatch(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) { SYSCTL_IRP_DISPOSITION disposition; NTSTATUS status; PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension; PAGED_CODE(); status = WmiSystemControl( &pDevExt->WmiLibInfo, DeviceObject, Irp, &disposition); switch(disposition) { case IrpProcessed: { // // This irp has been processed and may be completed or pending. break; } case IrpNotCompleted: { // // This irp has not been completed, but has been fully processed. // we will complete it now IoCompleteRequest(Irp, IO_NO_INCREMENT); break; } case IrpForward: case IrpNotWmi: { // // This irp is either not a WMI irp or is a WMI irp targetted // at a device lower in the stack. IoSkipCurrentIrpStackLocation(Irp); status = IoCallDriver(pDevExt->StackDeviceObject, Irp); break; } default: { // // We really should never get here, but if we do just forward.... ASSERT(FALSE); IoSkipCurrentIrpStackLocation(Irp); status = IoCallDriver(pDevExt->StackDeviceObject, Irp); break; } } return(status); } // // WMI System Call back functions // NTSTATUS UsbSerTossWMIRequest(IN PDEVICE_OBJECT PDevObj, IN PIRP PIrp, IN ULONG GuidIndex) { PDEVICE_EXTENSION pDevExt; NTSTATUS status; PAGED_CODE(); pDevExt = (PDEVICE_EXTENSION)PDevObj->DeviceExtension; switch (GuidIndex) { case WMI_SERIAL_PORT_NAME_INFORMATION: status = STATUS_INVALID_DEVICE_REQUEST; break; default: status = STATUS_WMI_GUID_NOT_FOUND; break; } status = WmiCompleteRequest(PDevObj, PIrp, status, 0, IO_NO_INCREMENT); return status; } NTSTATUS UsbSerSetWmiDataItem(IN PDEVICE_OBJECT PDevObj, IN PIRP PIrp, IN ULONG GuidIndex, IN ULONG InstanceIndex, IN ULONG DataItemId, IN ULONG BufferSize, IN PUCHAR PBuffer) /*++ Routine Description: This routine is a callback into the driver to set for the contents of a data block. When the driver has finished filling the data block it must call ClassWmiCompleteRequest to complete the irp. The driver can return STATUS_PENDING if the irp cannot be completed immediately. Arguments: PDevObj is the device whose data block is being queried PIrp is the Irp that makes this request GuidIndex is the index into the list of guids provided when the device registered InstanceIndex is the index that denotes which instance of the data block is being queried. DataItemId has the id of the data item being set BufferSize has the size of the data item passed PBuffer has the new values for the data item Return Value: status --*/ { PAGED_CODE(); // // Toss this request -- we don't support anything for it // return UsbSerTossWMIRequest(PDevObj, PIrp, GuidIndex); } NTSTATUS UsbSerSetWmiDataBlock(IN PDEVICE_OBJECT PDevObj, IN PIRP PIrp, IN ULONG GuidIndex, IN ULONG InstanceIndex, IN ULONG BufferSize, IN PUCHAR PBuffer) /*++ Routine Description: This routine is a callback into the driver to set the contents of a data block. When the driver has finished filling the data block it must call ClassWmiCompleteRequest to complete the irp. The driver can return STATUS_PENDING if the irp cannot be completed immediately. Arguments: PDevObj is the device whose data block is being queried PIrp is the Irp that makes this request GuidIndex is the index into the list of guids provided when the device registered InstanceIndex is the index that denotes which instance of the data block is being queried. BufferSize has the size of the data block passed PBuffer has the new values for the data block Return Value: status --*/ { PAGED_CODE(); // // Toss this request -- we don't support anything for it // return UsbSerTossWMIRequest(PDevObj, PIrp, GuidIndex); } NTSTATUS UsbSerQueryWmiDataBlock(IN PDEVICE_OBJECT PDevObj, IN PIRP PIrp, IN ULONG GuidIndex, IN ULONG InstanceIndex, IN ULONG InstanceCount, IN OUT PULONG InstanceLengthArray, IN ULONG OutBufferSize, OUT PUCHAR PBuffer) /*++ Routine Description: This routine is a callback into the driver to query for the contents of a data block. When the driver has finished filling the data block it must call ClassWmiCompleteRequest to complete the irp. The driver can return STATUS_PENDING if the irp cannot be completed immediately. Arguments: PDevObj is the device whose data block is being queried PIrp is the Irp that makes this request GuidIndex is the index into the list of guids provided when the device registered InstanceIndex is the index that denotes which instance of the data block is being queried. InstanceCount is the number of instnaces expected to be returned for the data block. InstanceLengthArray is a pointer to an array of ULONG that returns the lengths of each instance of the data block. If this is NULL then there was not enough space in the output buffer to fufill the request so the irp should be completed with the buffer needed. BufferAvail on has the maximum size available to write the data block. PBuffer on return is filled with the returned data block Return Value: status --*/ { NTSTATUS status; ULONG size = 0; PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)PDevObj->DeviceExtension; PAGED_CODE(); switch (GuidIndex) { case WMI_SERIAL_PORT_NAME_INFORMATION: size = pDevExt->WmiIdentifier.Length; if (OutBufferSize < (size + sizeof(USHORT))) { size += sizeof(USHORT); status = STATUS_BUFFER_TOO_SMALL; break; } if (pDevExt->WmiIdentifier.Buffer == NULL) { status = STATUS_INSUFFICIENT_RESOURCES; break; } // // First, copy the string over containing our identifier // *(USHORT *)PBuffer = (USHORT)size; (UCHAR *)PBuffer += sizeof(USHORT); RtlCopyMemory(PBuffer, pDevExt->WmiIdentifier.Buffer, size); // // Increment total size to include the WORD containing our len // size += sizeof(USHORT); *InstanceLengthArray = size; status = STATUS_SUCCESS; break; default: status = STATUS_WMI_GUID_NOT_FOUND; break; } status = WmiCompleteRequest( PDevObj, PIrp, status, size, IO_NO_INCREMENT); return status; } NTSTATUS UsbSerQueryWmiRegInfo(IN PDEVICE_OBJECT PDevObj, OUT PULONG PRegFlags, OUT PUNICODE_STRING PInstanceName, OUT PUNICODE_STRING *PRegistryPath, OUT PUNICODE_STRING MofResourceName, OUT PDEVICE_OBJECT *Pdo) /*++ Routine Description: This routine is a callback into the driver to retrieve information about the guids being registered. Implementations of this routine may be in paged memory Arguments: DeviceObject is the device whose registration information is needed *RegFlags returns with a set of flags that describe all of the guids being registered for this device. If the device wants enable and disable collection callbacks before receiving queries for the registered guids then it should return the WMIREG_FLAG_EXPENSIVE flag. Also the returned flags may specify WMIREG_FLAG_INSTANCE_PDO in which case the instance name is determined from the PDO associated with the device object. Note that the PDO must have an associated devnode. If WMIREG_FLAG_INSTANCE_PDO is not set then Name must return a unique name for the device. These flags are ORed into the flags specified by the GUIDREGINFO for each guid. InstanceName returns with the instance name for the guids if WMIREG_FLAG_INSTANCE_PDO is not set in the returned *RegFlags. The caller will call ExFreePool with the buffer returned. *RegistryPath returns with the registry path of the driver. This is required *MofResourceName returns with the name of the MOF resource attached to the binary file. If the driver does not have a mof resource attached then this can be returned as NULL. *Pdo returns with the device object for the PDO associated with this device if the WMIREG_FLAG_INSTANCE_PDO flag is retured in *RegFlags. Return Value: status --*/ { PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)PDevObj->DeviceExtension; PAGED_CODE(); *PRegFlags = WMIREG_FLAG_INSTANCE_PDO; *PRegistryPath = &GlobalRegistryPath; *Pdo = pDevExt->PhysDeviceObject; return STATUS_SUCCESS; } #endif