From 5b659e1cfbc4b8fbbd2f2bf41dc716929976c77d Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Sat, 28 Aug 2021 01:19:18 -0400 Subject: add per-device configuration adds input and [in, out] cap for classic mode adds input cap for power mode change wrapper/input, now gets useful device names change (now dev specific) dpi to adjust sensitivity change y sensitivity to y/x ratio remove spaced LUTs grapher and convert do not build --- driver/driver.cpp | 299 +++++++++++++++++++++++++++++++++++++++++++++--------- driver/driver.h | 22 +++- 2 files changed, 267 insertions(+), 54 deletions(-) (limited to 'driver') diff --git a/driver/driver.cpp b/driver/driver.cpp index feace77..82a56c0 100644 --- a/driver/driver.cpp +++ b/driver/driver.cpp @@ -7,22 +7,37 @@ #ifdef ALLOC_PRAGMA #pragma alloc_text (INIT, DriverEntry) +#pragma alloc_text (INIT, RawaccelInit) +#pragma alloc_text (INIT, CreateControlDevice) #pragma alloc_text (PAGE, EvtDeviceAdd) #pragma alloc_text (PAGE, EvtIoInternalDeviceControl) #pragma alloc_text (PAGE, RawaccelControl) +#pragma alloc_text (PAGE, DeviceCleanup) +#pragma alloc_text (PAGE, DeviceSetup) +#pragma alloc_text (PAGE, WriteDelay) #endif using milliseconds = double; struct { - ra::settings args; + WDFCOLLECTION device_collection; + WDFWAITLOCK collection_lock; + ra::device_config default_dev_cfg; + unsigned device_data_size; + unsigned driver_data_size; + ra::device_settings* device_data; + ra::driver_settings* driver_data; milliseconds tick_interval; - vec2 invokers; - ra::mouse_modifier modifier; + ra::modifier modifier_data[ra::DRIVER_CAPACITY]; } global = {}; extern "C" PULONG InitSafeBootMode; +bool init_failed() +{ + return global.driver_data_size == 0; +}; + __declspec(guard(ignore)) VOID RawaccelCallback( @@ -58,26 +73,39 @@ Arguments: auto num_packets = InputDataEnd - InputDataStart; if (num_packets > 0 && - !(InputDataStart->Flags & MOUSE_MOVE_ABSOLUTE) && - (global.args.device_id[0] == 0 || - bool(wcsncmp(devExt->dev_id, global.args.device_id, ra::MAX_DEV_ID_LEN)) == - global.args.ignore)) { - counter_t now = KeQueryPerformanceCounter(NULL).QuadPart; - counter_t ticks = now - devExt->counter; - devExt->counter = now; - milliseconds raw_elapsed = ticks * global.tick_interval; - milliseconds time = ra::clampsd(raw_elapsed / num_packets, - global.args.time_min, - global.args.time_max); + !(InputDataStart->Flags & MOUSE_MOVE_ABSOLUTE) && + devExt->enable) { + + milliseconds time; + if (devExt->keep_time) { + counter_t now = KeQueryPerformanceCounter(NULL).QuadPart; + counter_t ticks = now - devExt->counter; + devExt->counter = now; + milliseconds raw = ticks * global.tick_interval / num_packets; + time = ra::clampsd(raw, devExt->clamp.min, devExt->clamp.max); + } + else { + time = devExt->clamp.min; + } + auto it = InputDataStart; do { + if (devExt->set_extra_info) { + union { + short input[2]; + ULONG data; + } u = { short(it->LastX), short(it->LastY) }; + + it->ExtraInformation = u.data; + } + if (it->LastX || it->LastY) { vec2d input = { static_cast(it->LastX), static_cast(it->LastY) }; - global.modifier.modify(input, global.invokers, time); + devExt->mod_ptr->modify(input, *devExt->drv_ptr, devExt->dpi_factor, time); double carried_result_x = input.x + devExt->carry.x; double carried_result_y = input.y + devExt->carry.y; @@ -89,8 +117,8 @@ Arguments: double carry_y = carried_result_y - out_y; if (!ra::infnan(carry_x + carry_y)) { - devExt->carry.x = carried_result_x - out_x; - devExt->carry.y = carried_result_y - out_y; + devExt->carry.x = carry_x; + devExt->carry.y = carry_y; it->LastX = out_x; it->LastY = out_y; } @@ -149,6 +177,11 @@ Return Value: DebugPrint(("Ioctl received into filter control object.\n")); + if (init_failed()) { + WdfRequestCompleteWithInformation(Request, STATUS_CANCELLED, 0); + return; + } + switch (IoControlCode) { case RA_READ: status = WdfRequestRetrieveOutputBuffer( @@ -161,10 +194,15 @@ Return Value: DebugPrint(("RetrieveOutputBuffer failed: 0x%x\n", status)); } else { - ra::io_t& output = *reinterpret_cast(buffer); + ra::io_t& output = *static_cast(buffer); - output.args = global.args; - output.mod = global.modifier; + output.default_dev_cfg = global.default_dev_cfg; + + output.device_data_size = global.device_data_size; + output.driver_data_size = global.driver_data_size; + + RtlCopyMemory(output.device_data, global.device_data, sizeof(output.device_data)); + RtlCopyMemory(output.driver_data, global.driver_data, sizeof(output.driver_data)); bytes_out = sizeof(ra::io_t); } @@ -180,16 +218,38 @@ Return Value: DebugPrint(("RetrieveInputBuffer failed: 0x%x\n", status)); } else { - LARGE_INTEGER interval; - interval.QuadPart = static_cast(ra::WRITE_DELAY) * -10000; - KeDelayExecutionThread(KernelMode, FALSE, &interval); + WriteDelay(); - ra::io_t& input = *reinterpret_cast(buffer); + ra::io_t& input = *static_cast(buffer); - global.args = input.args; - global.invokers = ra::invokers(input.args); - global.modifier = input.mod; + if (input.driver_data_size == 0) { + status = STATUS_CANCELLED; + break; + } + + WdfWaitLockAcquire(global.collection_lock, NULL); + + global.default_dev_cfg = input.default_dev_cfg; + + global.device_data_size = ra::min(input.device_data_size, ra::DEVICE_CAPACITY); + global.driver_data_size = ra::min(input.driver_data_size, ra::DRIVER_CAPACITY); + + RtlCopyMemory(global.device_data, input.device_data, sizeof(input.device_data)); + RtlCopyMemory(global.driver_data, input.driver_data, sizeof(input.driver_data)); + + for (auto i = 0u; i < global.driver_data_size; i++) { + global.modifier_data[i] = { global.driver_data[i] }; + } + + auto count = WdfCollectionGetCount(global.device_collection); + + for (auto i = 0u; i < count; i++) { + DeviceSetup(WdfCollectionGetItem(global.device_collection, i)); + } + + WdfWaitLockRelease(global.collection_lock); } + break; case RA_GET_VERSION: status = WdfRequestRetrieveOutputBuffer( @@ -202,7 +262,7 @@ Return Value: DebugPrint(("RetrieveOutputBuffer failed: 0x%x\n", status)); } else { - *reinterpret_cast(buffer) = ra::version; + *static_cast(buffer) = ra::version; bytes_out = sizeof(ra::version_t); } break; @@ -216,6 +276,135 @@ Return Value: } #pragma warning(pop) // enable 28118 again +VOID +RawaccelInit(WDFDRIVER driver) +{ + NTSTATUS status; + + if (*InitSafeBootMode > 0) return; + + status = CreateControlDevice(driver); + + if (!NT_SUCCESS(status)) { + DebugPrint(("CreateControlDevice failed with status 0x%x\n", status)); + return; + } + + status = WdfCollectionCreate( + WDF_NO_OBJECT_ATTRIBUTES, + &global.device_collection + ); + + if (!NT_SUCCESS(status)) { + DebugPrint(("WdfCollectionCreate failed with status 0x%x\n", status)); + return; + } + + status = WdfWaitLockCreate( + WDF_NO_OBJECT_ATTRIBUTES, + &global.collection_lock + ); + + if (!NT_SUCCESS(status)) { + DebugPrint(("WdfWaitLockCreate failed with status 0x%x\n", status)); + return; + } + + void* paged_p = ExAllocatePoolWithTag(PagedPool, ra::POOL_SIZE, 'g'); + if (paged_p) { + RtlZeroMemory(paged_p, ra::POOL_SIZE); + global.device_data = static_cast(paged_p); + } + else { + DebugPrint(("ExAllocatePoolWithTag (PagedPool) failed")); + return; + } + + void* nonpaged_p = ExAllocatePoolWithTag(NonPagedPool, ra::POOL_SIZE, 'g'); + if (nonpaged_p) { + RtlZeroMemory(nonpaged_p, ra::POOL_SIZE); + global.driver_data = static_cast(nonpaged_p); + *global.driver_data = {}; + *global.modifier_data = { *global.driver_data }; + global.driver_data_size = 1; + } + else { + DebugPrint(("ExAllocatePoolWithTag (NonPagedPool) failed")); + return; + } + + LARGE_INTEGER freq; + KeQueryPerformanceCounter(&freq); + global.tick_interval = 1e3 / freq.QuadPart; +} + +VOID +DeviceSetup(WDFOBJECT hDevice) +{ + auto* devExt = FilterGetData(hDevice); + + auto set_ext_from_cfg = [devExt](const ra::device_config& cfg) { + devExt->enable = !cfg.disable; + devExt->set_extra_info = cfg.set_extra_info; + devExt->keep_time = cfg.polling_rate <= 0; + devExt->dpi_factor = (cfg.dpi > 0) ? (1000.0 / cfg.dpi) : 1; + + if (devExt->keep_time) { + devExt->clamp = cfg.clamp; + } + else { + milliseconds interval = 1000.0 / cfg.polling_rate; + devExt->clamp = { interval, interval }; + } + }; + + set_ext_from_cfg(global.default_dev_cfg); + devExt->counter = 0; + devExt->carry = {}; + devExt->drv_ptr = global.driver_data; + devExt->mod_ptr = global.modifier_data; + + for (auto i = 0u; i < global.device_data_size; i++) { + auto& dev_settings = global.device_data[i]; + + if (wcsncmp(devExt->dev_id, dev_settings.id, ra::MAX_DEV_ID_LEN) == 0) { + set_ext_from_cfg(dev_settings.config); + + if (dev_settings.profile[0] != L'\0') { + for (auto j = 0u; j < global.driver_data_size; j++) { + auto& profile = global.driver_data[j].prof; + + if (wcsncmp(dev_settings.profile, profile.name, ra::MAX_NAME_LEN) == 0) { + devExt->drv_ptr = &global.driver_data[j]; + devExt->mod_ptr = &global.modifier_data[j]; + return; + } + } + } + + return; + } + } +} + +VOID +DeviceCleanup(WDFOBJECT hDevice) +{ + PAGED_CODE(); + DebugPrint(("Removing device from collection\n")); + + WdfWaitLockAcquire(global.collection_lock, NULL); + WdfCollectionRemove(global.device_collection, hDevice); + WdfWaitLockRelease(global.collection_lock); +} + +VOID +WriteDelay() +{ + LARGE_INTEGER interval; + interval.QuadPart = static_cast(ra::WRITE_DELAY) * -10000; + KeDelayExecutionThread(KernelMode, FALSE, &interval); +} NTSTATUS DriverEntry( @@ -259,14 +448,10 @@ Routine Description: WDF_NO_OBJECT_ATTRIBUTES, &config, &driver); - - if (NT_SUCCESS(status)) { - LARGE_INTEGER freq; - KeQueryPerformanceCounter(&freq); - global.tick_interval = 1e3 / freq.QuadPart; - CreateControlDevice(driver); + if (NT_SUCCESS(status)) { + RawaccelInit(driver); } else { DebugPrint(("WdfDriverCreate failed with status 0x%x\n", status)); @@ -276,8 +461,7 @@ Routine Description: } -inline -VOID +NTSTATUS CreateControlDevice(WDFDRIVER Driver) /*++ Routine Description: @@ -378,7 +562,7 @@ Return Value: // WdfControlFinishInitializing(controlDevice); - return; + return STATUS_SUCCESS; Error: @@ -393,8 +577,9 @@ Error: } DebugPrint(("CreateControlDevice failed with status code 0x%x\n", status)); -} + return status; +} NTSTATUS EvtDeviceAdd( @@ -437,7 +622,7 @@ Return Value: DebugPrint(("Enter FilterEvtDeviceAdd \n")); - if (*InitSafeBootMode > 0) { + if (init_failed()) { return STATUS_SUCCESS; } @@ -453,6 +638,7 @@ Return Value: WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&deviceAttributes, DEVICE_EXTENSION); + deviceAttributes.EvtCleanupCallback = DeviceCleanup; // // Create a framework device object. This call will in turn create @@ -469,7 +655,7 @@ Return Value: // get device id from bus driver // DEVICE_OBJECT* pdo = WdfDeviceWdmGetPhysicalDevice(hDevice); - + KEVENT ke; KeInitializeEvent(&ke, NotificationEvent, FALSE); IO_STATUS_BLOCK iosb = {}; @@ -480,18 +666,36 @@ Return Value: stack->MinorFunction = IRP_MN_QUERY_ID; stack->Parameters.QueryId.IdType = BusQueryDeviceID; - NTSTATUS nts = IoCallDriver(pdo, Irp); + NTSTATUS tmp = IoCallDriver(pdo, Irp); - if (nts == STATUS_PENDING) { + if (tmp == STATUS_PENDING) { KeWaitForSingleObject(&ke, Executive, KernelMode, FALSE, NULL); + tmp = iosb.Status; } - if (NT_SUCCESS(nts)) { - auto* id_ptr = reinterpret_cast(iosb.Information); - wcsncpy(FilterGetData(hDevice)->dev_id, id_ptr, ra::MAX_DEV_ID_LEN); - DebugPrint(("Device ID = %ws\n", id_ptr)); + auto* devExt = FilterGetData(hDevice); + + if (NT_SUCCESS(tmp)) { + auto* id_ptr = reinterpret_cast(iosb.Information); + wcsncpy(devExt->dev_id, id_ptr, ra::MAX_DEV_ID_LEN); ExFreePool(id_ptr); } + else { + DebugPrint(("IoCallDriver failed with status 0x%x\n", tmp)); + *devExt->dev_id = L'\0'; + } + + WdfWaitLockAcquire(global.collection_lock, NULL); + + DeviceSetup(hDevice); + + tmp = WdfCollectionAdd(global.device_collection, hDevice); + + if (!NT_SUCCESS(tmp)) { + DebugPrint(("WdfCollectionAdd failed with status 0x%x\n", tmp)); + } + + WdfWaitLockRelease(global.collection_lock); // // Configure the default queue to be Parallel. Do not use sequential queue @@ -597,8 +801,6 @@ Routine Description: break; } - devExt->counter = 0; - devExt->carry = {}; devExt->UpperConnectData = *connectData; // @@ -636,7 +838,6 @@ Routine Description: } -inline VOID DispatchPassThrough( _In_ WDFREQUEST Request, diff --git a/driver/driver.h b/driver/driver.h index 6184a69..4818367 100644 --- a/driver/driver.h +++ b/driver/driver.h @@ -1,6 +1,6 @@ #pragma once -#include "rawaccel-base.hpp" +#include "rawaccel.hpp" #include "rawaccel-io-def.h" #include @@ -19,7 +19,14 @@ using counter_t = long long; namespace ra = rawaccel; typedef struct _DEVICE_EXTENSION { + bool enable; + bool keep_time; + bool set_extra_info; + double dpi_factor; counter_t counter; + ra::time_clamp clamp; + ra::driver_settings* drv_ptr; + ra::modifier* mod_ptr; vec2d carry; CONNECT_DATA UpperConnectData; WCHAR dev_id[ra::MAX_DEV_ID_LEN]; @@ -30,9 +37,18 @@ WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(DEVICE_EXTENSION, FilterGetData) EXTERN_C_START DRIVER_INITIALIZE DriverEntry; + EVT_WDF_DRIVER_DEVICE_ADD EvtDeviceAdd; EVT_WDF_IO_QUEUE_IO_INTERNAL_DEVICE_CONTROL EvtIoInternalDeviceControl; EVT_WDF_IO_QUEUE_IO_DEVICE_CONTROL RawaccelControl; +EVT_WDF_OBJECT_CONTEXT_CLEANUP DeviceCleanup; + +VOID DeviceSetup(WDFOBJECT); +VOID WriteDelay(VOID); +VOID RawaccelInit(WDFDRIVER); +NTSTATUS CreateControlDevice(WDFDRIVER); + +EXTERN_C_END VOID RawaccelCallback( IN PDEVICE_OBJECT DeviceObject, @@ -41,10 +57,6 @@ VOID RawaccelCallback( IN OUT PULONG InputDataConsumed ); -EXTERN_C_END - -VOID CreateControlDevice(WDFDRIVER Driver); - VOID DispatchPassThrough( _In_ WDFREQUEST Request, _In_ WDFIOTARGET Target -- cgit v1.2.3 From 3dc64cc13a7a2a6da843fdd33e0791f154e8a2dc Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Fri, 3 Sep 2021 18:15:39 -0400 Subject: make ioctls constexpr --- driver/driver.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'driver') diff --git a/driver/driver.cpp b/driver/driver.cpp index 82a56c0..4cc0072 100644 --- a/driver/driver.cpp +++ b/driver/driver.cpp @@ -183,7 +183,7 @@ Return Value: } switch (IoControlCode) { - case RA_READ: + case ra::READ: status = WdfRequestRetrieveOutputBuffer( Request, sizeof(ra::io_t), @@ -207,7 +207,7 @@ Return Value: bytes_out = sizeof(ra::io_t); } break; - case RA_WRITE: + case ra::WRITE: status = WdfRequestRetrieveInputBuffer( Request, sizeof(ra::io_t), @@ -251,7 +251,7 @@ Return Value: } break; - case RA_GET_VERSION: + case ra::GET_VERSION: status = WdfRequestRetrieveOutputBuffer( Request, sizeof(ra::version_t), -- cgit v1.2.3 From bb575220aba8f81e31e5dc0b2e376ac54955a49d Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Sun, 5 Sep 2021 21:12:39 -0400 Subject: fix kernel bugcheck initializing the default driver_settings on driver entry blows up the stack size, causing stack check to fail the default modifier is initialized to noop anyway so it's fine to leave most vars zeroed --- driver/driver.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'driver') diff --git a/driver/driver.cpp b/driver/driver.cpp index 4cc0072..3096de8 100644 --- a/driver/driver.cpp +++ b/driver/driver.cpp @@ -324,8 +324,10 @@ RawaccelInit(WDFDRIVER driver) if (nonpaged_p) { RtlZeroMemory(nonpaged_p, ra::POOL_SIZE); global.driver_data = static_cast(nonpaged_p); - *global.driver_data = {}; - *global.modifier_data = { *global.driver_data }; + global.driver_data->prof.domain_weights = { 1, 1 }; + global.driver_data->prof.range_weights = { 1, 1 }; + global.driver_data->prof.sensitivity = 1; + global.driver_data->prof.yx_sens_ratio = 1; global.driver_data_size = 1; } else { -- cgit v1.2.3 From 8680805b267bf5280b8f446ed33ef07981ea5475 Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Mon, 6 Sep 2021 19:11:47 -0400 Subject: make profile count dynamic (unlimited) --- driver/driver.cpp | 173 ++++++++++++++++++++++++++++++------------------------ driver/driver.h | 4 +- 2 files changed, 98 insertions(+), 79 deletions(-) (limited to 'driver') diff --git a/driver/driver.cpp b/driver/driver.cpp index 3096de8..2a4f460 100644 --- a/driver/driver.cpp +++ b/driver/driver.cpp @@ -20,24 +20,17 @@ using milliseconds = double; struct { + bool initialized; WDFCOLLECTION device_collection; WDFWAITLOCK collection_lock; - ra::device_config default_dev_cfg; - unsigned device_data_size; - unsigned driver_data_size; - ra::device_settings* device_data; + ra::io_base base_data; ra::driver_settings* driver_data; + ra::device_settings* device_data; milliseconds tick_interval; - ra::modifier modifier_data[ra::DRIVER_CAPACITY]; } global = {}; extern "C" PULONG InitSafeBootMode; -bool init_failed() -{ - return global.driver_data_size == 0; -}; - __declspec(guard(ignore)) VOID RawaccelCallback( @@ -105,7 +98,7 @@ Arguments: static_cast(it->LastY) }; - devExt->mod_ptr->modify(input, *devExt->drv_ptr, devExt->dpi_factor, time); + devExt->mod.modify(input, devExt->drv_settings, devExt->dpi_factor, time); double carried_result_x = input.x + devExt->carry.x; double carried_result_y = input.y + devExt->carry.y; @@ -167,7 +160,7 @@ Return Value: { NTSTATUS status; void* buffer; - + size_t buffer_length; size_t bytes_out = 0; UNREFERENCED_PARAMETER(Queue); @@ -177,42 +170,50 @@ Return Value: DebugPrint(("Ioctl received into filter control object.\n")); - if (init_failed()) { + if (!global.initialized) { WdfRequestCompleteWithInformation(Request, STATUS_CANCELLED, 0); return; } + const auto SIZEOF_BASE = sizeof(ra::io_base); + switch (IoControlCode) { case ra::READ: status = WdfRequestRetrieveOutputBuffer( Request, - sizeof(ra::io_t), + SIZEOF_BASE, &buffer, - NULL + &buffer_length ); if (!NT_SUCCESS(status)) { DebugPrint(("RetrieveOutputBuffer failed: 0x%x\n", status)); } else { - ra::io_t& output = *static_cast(buffer); + *static_cast(buffer) = global.base_data; - output.default_dev_cfg = global.default_dev_cfg; + size_t driver_bytes = global.base_data.driver_data_size * sizeof(ra::driver_settings); + size_t device_bytes = global.base_data.device_data_size * sizeof(ra::device_settings); + size_t total_bytes = SIZEOF_BASE + driver_bytes + device_bytes; - output.device_data_size = global.device_data_size; - output.driver_data_size = global.driver_data_size; - - RtlCopyMemory(output.device_data, global.device_data, sizeof(output.device_data)); - RtlCopyMemory(output.driver_data, global.driver_data, sizeof(output.driver_data)); + if (buffer_length < total_bytes) { + bytes_out = SIZEOF_BASE; + } + else { + BYTE* output_ptr = static_cast(buffer) + SIZEOF_BASE; - bytes_out = sizeof(ra::io_t); + if (global.driver_data) RtlCopyMemory(output_ptr, global.driver_data, driver_bytes); + output_ptr += driver_bytes; + if (global.device_data) RtlCopyMemory(output_ptr, global.device_data, device_bytes); + bytes_out = total_bytes; + } } break; case ra::WRITE: status = WdfRequestRetrieveInputBuffer( Request, - sizeof(ra::io_t), + SIZEOF_BASE, &buffer, - NULL + &buffer_length ); if (!NT_SUCCESS(status)) { DebugPrint(("RetrieveInputBuffer failed: 0x%x\n", status)); @@ -220,36 +221,73 @@ Return Value: else { WriteDelay(); - ra::io_t& input = *static_cast(buffer); + ra::io_base& input = *static_cast(buffer); - if (input.driver_data_size == 0) { + auto driver_bytes = size_t(input.driver_data_size) * sizeof(ra::driver_settings); + auto device_bytes = size_t(input.device_data_size) * sizeof(ra::device_settings); + auto alloc_size = driver_bytes + device_bytes; + auto total_size = alloc_size + SIZEOF_BASE; + + auto max_u32 = unsigned(-1); + if (driver_bytes > max_u32 || device_bytes > max_u32 || total_size > max_u32) { status = STATUS_CANCELLED; break; } - WdfWaitLockAcquire(global.collection_lock, NULL); + if (input.driver_data_size == 0) { + // clear data and disable all devices + WdfWaitLockAcquire(global.collection_lock, NULL); + + global.base_data = {}; - global.default_dev_cfg = input.default_dev_cfg; + if (global.driver_data) { + ExFreePoolWithTag(global.driver_data, 'g'); + global.driver_data = NULL; + global.device_data = NULL; + } - global.device_data_size = ra::min(input.device_data_size, ra::DEVICE_CAPACITY); - global.driver_data_size = ra::min(input.driver_data_size, ra::DRIVER_CAPACITY); + auto count = WdfCollectionGetCount(global.device_collection); - RtlCopyMemory(global.device_data, input.device_data, sizeof(input.device_data)); - RtlCopyMemory(global.driver_data, input.driver_data, sizeof(input.driver_data)); + for (auto i = 0u; i < count; i++) { + DeviceSetup(WdfCollectionGetItem(global.device_collection, i)); + } - for (auto i = 0u; i < global.driver_data_size; i++) { - global.modifier_data[i] = { global.driver_data[i] }; + WdfWaitLockRelease(global.collection_lock); } + else if (buffer_length == total_size) { + void* pool = ExAllocatePoolWithTag(PagedPool, alloc_size, 'g'); + if (!pool) { + DebugPrint(("ExAllocatePoolWithTag (PagedPool) failed")); + status = STATUS_UNSUCCESSFUL; + break; + } + RtlCopyMemory(pool, static_cast(buffer) + SIZEOF_BASE, alloc_size); - auto count = WdfCollectionGetCount(global.device_collection); + WdfWaitLockAcquire(global.collection_lock, NULL); - for (auto i = 0u; i < count; i++) { - DeviceSetup(WdfCollectionGetItem(global.device_collection, i)); - } + if (global.driver_data) { + ExFreePoolWithTag(global.driver_data, 'g'); + } - WdfWaitLockRelease(global.collection_lock); - } + void* dev_data = static_cast(pool) + driver_bytes; + global.device_data = input.device_data_size > 0 ? + static_cast(dev_data) : + NULL; + global.driver_data = static_cast(pool); + global.base_data = input; + auto count = WdfCollectionGetCount(global.device_collection); + + for (auto i = 0u; i < count; i++) { + DeviceSetup(WdfCollectionGetItem(global.device_collection, i)); + } + + WdfWaitLockRelease(global.collection_lock); + } + else { + status = STATUS_CANCELLED; + } + } break; case ra::GET_VERSION: status = WdfRequestRetrieveOutputBuffer( @@ -310,34 +348,11 @@ RawaccelInit(WDFDRIVER driver) return; } - void* paged_p = ExAllocatePoolWithTag(PagedPool, ra::POOL_SIZE, 'g'); - if (paged_p) { - RtlZeroMemory(paged_p, ra::POOL_SIZE); - global.device_data = static_cast(paged_p); - } - else { - DebugPrint(("ExAllocatePoolWithTag (PagedPool) failed")); - return; - } - - void* nonpaged_p = ExAllocatePoolWithTag(NonPagedPool, ra::POOL_SIZE, 'g'); - if (nonpaged_p) { - RtlZeroMemory(nonpaged_p, ra::POOL_SIZE); - global.driver_data = static_cast(nonpaged_p); - global.driver_data->prof.domain_weights = { 1, 1 }; - global.driver_data->prof.range_weights = { 1, 1 }; - global.driver_data->prof.sensitivity = 1; - global.driver_data->prof.yx_sens_ratio = 1; - global.driver_data_size = 1; - } - else { - DebugPrint(("ExAllocatePoolWithTag (NonPagedPool) failed")); - return; - } - LARGE_INTEGER freq; KeQueryPerformanceCounter(&freq); global.tick_interval = 1e3 / freq.QuadPart; + + global.initialized = true; } VOID @@ -360,25 +375,29 @@ DeviceSetup(WDFOBJECT hDevice) } }; - set_ext_from_cfg(global.default_dev_cfg); - devExt->counter = 0; - devExt->carry = {}; - devExt->drv_ptr = global.driver_data; - devExt->mod_ptr = global.modifier_data; - - for (auto i = 0u; i < global.device_data_size; i++) { + if (!global.driver_data) { + devExt->enable = false; + devExt->mod = {}; + return; + } + + set_ext_from_cfg(global.base_data.default_dev_cfg); + devExt->drv_settings = *global.driver_data; + devExt->mod = { devExt->drv_settings }; + + for (auto i = 0u; i < global.base_data.device_data_size; i++) { auto& dev_settings = global.device_data[i]; if (wcsncmp(devExt->dev_id, dev_settings.id, ra::MAX_DEV_ID_LEN) == 0) { set_ext_from_cfg(dev_settings.config); if (dev_settings.profile[0] != L'\0') { - for (auto j = 0u; j < global.driver_data_size; j++) { + for (auto j = 0u; j < global.base_data.driver_data_size; j++) { auto& profile = global.driver_data[j].prof; if (wcsncmp(dev_settings.profile, profile.name, ra::MAX_NAME_LEN) == 0) { - devExt->drv_ptr = &global.driver_data[j]; - devExt->mod_ptr = &global.modifier_data[j]; + devExt->drv_settings = global.driver_data[j]; + devExt->mod = { devExt->drv_settings }; return; } } @@ -624,7 +643,7 @@ Return Value: DebugPrint(("Enter FilterEvtDeviceAdd \n")); - if (init_failed()) { + if (!global.initialized) { return STATUS_SUCCESS; } diff --git a/driver/driver.h b/driver/driver.h index 4818367..d8b3162 100644 --- a/driver/driver.h +++ b/driver/driver.h @@ -25,10 +25,10 @@ typedef struct _DEVICE_EXTENSION { double dpi_factor; counter_t counter; ra::time_clamp clamp; - ra::driver_settings* drv_ptr; - ra::modifier* mod_ptr; + ra::modifier mod; vec2d carry; CONNECT_DATA UpperConnectData; + ra::driver_settings drv_settings; WCHAR dev_id[ra::MAX_DEV_ID_LEN]; } DEVICE_EXTENSION, *PDEVICE_EXTENSION; -- cgit v1.2.3 From 170713f571cf875d22b42f9ba58261741cddb495 Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Mon, 6 Sep 2021 19:14:05 -0400 Subject: move safeboot check into DriverEntry --- driver/driver.cpp | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) (limited to 'driver') diff --git a/driver/driver.cpp b/driver/driver.cpp index 2a4f460..07b947f 100644 --- a/driver/driver.cpp +++ b/driver/driver.cpp @@ -319,8 +319,6 @@ RawaccelInit(WDFDRIVER driver) { NTSTATUS status; - if (*InitSafeBootMode > 0) return; - status = CreateControlDevice(driver); if (!NT_SUCCESS(status)) { @@ -472,7 +470,7 @@ Routine Description: if (NT_SUCCESS(status)) { - RawaccelInit(driver); + if (*InitSafeBootMode == 0) RawaccelInit(driver); } else { DebugPrint(("WdfDriverCreate failed with status 0x%x\n", status)); -- cgit v1.2.3 From 427a94bc4086c67a044ebbaed8bc789b1ed174c9 Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Wed, 8 Sep 2021 04:43:15 -0400 Subject: rename driver_settings found a better one refactor driver/DeviceSetup --- driver/driver.cpp | 64 +++++++++++++++++++++++++++++-------------------------- driver/driver.h | 2 +- 2 files changed, 35 insertions(+), 31 deletions(-) (limited to 'driver') diff --git a/driver/driver.cpp b/driver/driver.cpp index 07b947f..febf64f 100644 --- a/driver/driver.cpp +++ b/driver/driver.cpp @@ -24,7 +24,7 @@ struct { WDFCOLLECTION device_collection; WDFWAITLOCK collection_lock; ra::io_base base_data; - ra::driver_settings* driver_data; + ra::modifier_settings* modifier_data; ra::device_settings* device_data; milliseconds tick_interval; } global = {}; @@ -98,7 +98,7 @@ Arguments: static_cast(it->LastY) }; - devExt->mod.modify(input, devExt->drv_settings, devExt->dpi_factor, time); + devExt->mod.modify(input, devExt->mod_settings, devExt->dpi_factor, time); double carried_result_x = input.x + devExt->carry.x; double carried_result_y = input.y + devExt->carry.y; @@ -191,9 +191,9 @@ Return Value: else { *static_cast(buffer) = global.base_data; - size_t driver_bytes = global.base_data.driver_data_size * sizeof(ra::driver_settings); + size_t modifier_bytes = global.base_data.modifier_data_size * sizeof(ra::modifier_settings); size_t device_bytes = global.base_data.device_data_size * sizeof(ra::device_settings); - size_t total_bytes = SIZEOF_BASE + driver_bytes + device_bytes; + size_t total_bytes = SIZEOF_BASE + modifier_bytes + device_bytes; if (buffer_length < total_bytes) { bytes_out = SIZEOF_BASE; @@ -201,8 +201,8 @@ Return Value: else { BYTE* output_ptr = static_cast(buffer) + SIZEOF_BASE; - if (global.driver_data) RtlCopyMemory(output_ptr, global.driver_data, driver_bytes); - output_ptr += driver_bytes; + if (global.modifier_data) RtlCopyMemory(output_ptr, global.modifier_data, modifier_bytes); + output_ptr += modifier_bytes; if (global.device_data) RtlCopyMemory(output_ptr, global.device_data, device_bytes); bytes_out = total_bytes; } @@ -223,26 +223,26 @@ Return Value: ra::io_base& input = *static_cast(buffer); - auto driver_bytes = size_t(input.driver_data_size) * sizeof(ra::driver_settings); + auto modifier_bytes = size_t(input.modifier_data_size) * sizeof(ra::modifier_settings); auto device_bytes = size_t(input.device_data_size) * sizeof(ra::device_settings); - auto alloc_size = driver_bytes + device_bytes; + auto alloc_size = modifier_bytes + device_bytes; auto total_size = alloc_size + SIZEOF_BASE; auto max_u32 = unsigned(-1); - if (driver_bytes > max_u32 || device_bytes > max_u32 || total_size > max_u32) { + if (modifier_bytes > max_u32 || device_bytes > max_u32 || total_size > max_u32) { status = STATUS_CANCELLED; break; } - if (input.driver_data_size == 0) { + if (input.modifier_data_size == 0) { // clear data and disable all devices WdfWaitLockAcquire(global.collection_lock, NULL); global.base_data = {}; - if (global.driver_data) { - ExFreePoolWithTag(global.driver_data, 'g'); - global.driver_data = NULL; + if (global.modifier_data) { + ExFreePoolWithTag(global.modifier_data, 'g'); + global.modifier_data = NULL; global.device_data = NULL; } @@ -265,15 +265,15 @@ Return Value: WdfWaitLockAcquire(global.collection_lock, NULL); - if (global.driver_data) { - ExFreePoolWithTag(global.driver_data, 'g'); + if (global.modifier_data) { + ExFreePoolWithTag(global.modifier_data, 'g'); } - void* dev_data = static_cast(pool) + driver_bytes; + void* dev_data = static_cast(pool) + modifier_bytes; global.device_data = input.device_data_size > 0 ? static_cast(dev_data) : NULL; - global.driver_data = static_cast(pool); + global.modifier_data = static_cast(pool); global.base_data = input; auto count = WdfCollectionGetCount(global.device_collection); @@ -373,15 +373,27 @@ DeviceSetup(WDFOBJECT hDevice) } }; - if (!global.driver_data) { + auto set_mod_if_found = [devExt](auto* prof_name) { + for (auto i = 0u; i < global.base_data.modifier_data_size; i++) { + auto& profile = global.modifier_data[i].prof; + + if (wcsncmp(prof_name, profile.name, ra::MAX_NAME_LEN) == 0) { + devExt->mod_settings = global.modifier_data[i]; + devExt->mod = { devExt->mod_settings }; + return; + } + } + }; + + if (!global.modifier_data) { devExt->enable = false; devExt->mod = {}; return; } set_ext_from_cfg(global.base_data.default_dev_cfg); - devExt->drv_settings = *global.driver_data; - devExt->mod = { devExt->drv_settings }; + devExt->mod_settings = *global.modifier_data; + devExt->mod = { devExt->mod_settings }; for (auto i = 0u; i < global.base_data.device_data_size; i++) { auto& dev_settings = global.device_data[i]; @@ -390,18 +402,10 @@ DeviceSetup(WDFOBJECT hDevice) set_ext_from_cfg(dev_settings.config); if (dev_settings.profile[0] != L'\0') { - for (auto j = 0u; j < global.base_data.driver_data_size; j++) { - auto& profile = global.driver_data[j].prof; - - if (wcsncmp(dev_settings.profile, profile.name, ra::MAX_NAME_LEN) == 0) { - devExt->drv_settings = global.driver_data[j]; - devExt->mod = { devExt->drv_settings }; - return; - } - } + set_mod_if_found(dev_settings.profile); } - return; + break; } } } diff --git a/driver/driver.h b/driver/driver.h index d8b3162..c55afac 100644 --- a/driver/driver.h +++ b/driver/driver.h @@ -28,7 +28,7 @@ typedef struct _DEVICE_EXTENSION { ra::modifier mod; vec2d carry; CONNECT_DATA UpperConnectData; - ra::driver_settings drv_settings; + ra::modifier_settings mod_settings; WCHAR dev_id[ra::MAX_DEV_ID_LEN]; } DEVICE_EXTENSION, *PDEVICE_EXTENSION; -- cgit v1.2.3 From 73f3d08f995db4e8ebaef24556f28b63a9250675 Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Sat, 18 Sep 2021 07:01:08 -0400 Subject: bump version, target win10 --- driver/driver.vcxproj | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) (limited to 'driver') diff --git a/driver/driver.vcxproj b/driver/driver.vcxproj index c2e4629..dfc1fdb 100644 --- a/driver/driver.vcxproj +++ b/driver/driver.vcxproj @@ -22,9 +22,10 @@ - Windows7 + + False - Desktop + Universal KMDF WindowsKernelModeDriver10.0 Driver @@ -33,9 +34,10 @@ Spectre - Windows7 + + True - Desktop + Universal KMDF WindowsKernelModeDriver10.0 Driver -- cgit v1.2.3