421 lines
14 KiB
C
421 lines
14 KiB
C
/*
|
|
* HIDClass device functions
|
|
*
|
|
* Copyright (C) 2015 Aric Stewart
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdarg.h>
|
|
#define NONAMELESSUNION
|
|
#include "hid.h"
|
|
#include "wine/unicode.h"
|
|
#include "winreg.h"
|
|
#include "winuser.h"
|
|
#include "setupapi.h"
|
|
|
|
#include "wine/debug.h"
|
|
#include "ddk/hidsdi.h"
|
|
#include "ddk/hidtypes.h"
|
|
|
|
#include "initguid.h"
|
|
#include "devguid.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(hid);
|
|
WINE_DECLARE_DEBUG_CHANNEL(hid_report);
|
|
|
|
static const WCHAR device_name_fmtW[] = {'\\','D','e','v','i','c','e',
|
|
'\\','H','I','D','#','%','p','&','%','p',0};
|
|
static const WCHAR device_regname_fmtW[] = {'H','I','D','\\',
|
|
'v','i','d','_','%','0','4','x','&','p','i','d','_','%',
|
|
'0','4','x','&','%','s','\\','%','i','&','%','s',0};
|
|
static const WCHAR device_link_fmtW[] = {'\\','?','?','\\','h','i','d','#',
|
|
'v','i','d','_','%','0','4','x','&','p','i','d','_','%',
|
|
'0','4','x','&','%','s','#','%','i','&','%','s','#','%','s',0};
|
|
/* GUID_DEVINTERFACE_HID */
|
|
static const WCHAR class_guid[] = {'{','4','D','1','E','5','5','B','2',
|
|
'-','F','1','6','F','-','1','1','C','F','-','8','8','C','B','-','0','0',
|
|
'1','1','1','1','0','0','0','0','3','0','}',0};
|
|
|
|
|
|
NTSTATUS HID_CreateDevice(DEVICE_OBJECT *native_device, HID_MINIDRIVER_REGISTRATION *driver, DEVICE_OBJECT **device)
|
|
{
|
|
WCHAR dev_name[255];
|
|
UNICODE_STRING nameW;
|
|
NTSTATUS status;
|
|
BASE_DEVICE_EXTENSION *ext;
|
|
|
|
sprintfW(dev_name, device_name_fmtW, driver->DriverObject, native_device);
|
|
RtlInitUnicodeString( &nameW, dev_name );
|
|
|
|
TRACE("Create base hid device %s\n", debugstr_w(dev_name));
|
|
|
|
status = IoCreateDevice(driver->DriverObject, driver->DeviceExtensionSize + sizeof(BASE_DEVICE_EXTENSION), &nameW, 0, 0, FALSE, device);
|
|
if (status)
|
|
{
|
|
FIXME( "failed to create device error %x\n", status );
|
|
return status;
|
|
}
|
|
|
|
ext = (*device)->DeviceExtension;
|
|
|
|
ext->deviceExtension.MiniDeviceExtension = ext + 1;
|
|
ext->deviceExtension.PhysicalDeviceObject = *device;
|
|
ext->deviceExtension.NextDeviceObject = native_device;
|
|
ext->device_name = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(dev_name) + 1) * sizeof(WCHAR));
|
|
lstrcpyW(ext->device_name, dev_name);
|
|
ext->link_name = NULL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
NTSTATUS HID_LinkDevice(DEVICE_OBJECT *device, LPCWSTR serial, LPCWSTR index)
|
|
{
|
|
WCHAR regname[255];
|
|
WCHAR dev_link[255];
|
|
SP_DEVINFO_DATA Data;
|
|
UNICODE_STRING nameW, linkW;
|
|
NTSTATUS status;
|
|
HDEVINFO devinfo;
|
|
GUID hidGuid;
|
|
BASE_DEVICE_EXTENSION *ext;
|
|
|
|
HidD_GetHidGuid(&hidGuid);
|
|
ext = device->DeviceExtension;
|
|
|
|
sprintfW(dev_link, device_link_fmtW, ext->information.VendorID,
|
|
ext->information.ProductID, index, ext->information.VersionNumber, serial,
|
|
class_guid);
|
|
struprW(dev_link);
|
|
|
|
RtlInitUnicodeString( &nameW, ext->device_name);
|
|
RtlInitUnicodeString( &linkW, dev_link );
|
|
|
|
TRACE("Create link %s\n", debugstr_w(dev_link));
|
|
|
|
ext->link_name = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * (lstrlenW(dev_link) + 1));
|
|
lstrcpyW(ext->link_name, dev_link);
|
|
|
|
status = IoCreateSymbolicLink( &linkW, &nameW );
|
|
if (status)
|
|
{
|
|
FIXME( "failed to create link error %x\n", status );
|
|
return status;
|
|
}
|
|
|
|
sprintfW(regname, device_regname_fmtW, ext->information.VendorID, ext->information.ProductID, index, ext->information.VersionNumber, serial);
|
|
|
|
devinfo = SetupDiGetClassDevsW(&GUID_DEVCLASS_HIDCLASS, NULL, NULL, DIGCF_DEVICEINTERFACE);
|
|
if (!devinfo)
|
|
{
|
|
FIXME( "failed to get ClassDevs %x\n", GetLastError());
|
|
return GetLastError();
|
|
}
|
|
Data.cbSize = sizeof(Data);
|
|
if (!SetupDiCreateDeviceInfoW(devinfo, regname, &GUID_DEVCLASS_HIDCLASS, NULL, NULL, DICD_INHERIT_CLASSDRVS, &Data))
|
|
{
|
|
if (GetLastError() == ERROR_DEVINST_ALREADY_EXISTS)
|
|
{
|
|
SetupDiDestroyDeviceInfoList(devinfo);
|
|
return ERROR_SUCCESS;
|
|
}
|
|
FIXME( "failed to Create Device Info %x\n", GetLastError());
|
|
return GetLastError();
|
|
}
|
|
if (!SetupDiRegisterDeviceInfo( devinfo, &Data, 0, NULL, NULL, NULL ))
|
|
{
|
|
FIXME( "failed to Register Device Info %x\n", GetLastError());
|
|
return GetLastError();
|
|
}
|
|
if (!SetupDiCreateDeviceInterfaceW( devinfo, &Data, &hidGuid, NULL, 0, NULL))
|
|
{
|
|
FIXME( "failed to Create Device Interface %x\n", GetLastError());
|
|
return GetLastError();
|
|
}
|
|
SetupDiDestroyDeviceInfoList(devinfo);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
void HID_DeleteDevice(HID_MINIDRIVER_REGISTRATION *driver, DEVICE_OBJECT *device)
|
|
{
|
|
NTSTATUS status;
|
|
BASE_DEVICE_EXTENSION *ext;
|
|
UNICODE_STRING linkW;
|
|
LIST_ENTRY *entry;
|
|
IRP *irp;
|
|
|
|
ext = device->DeviceExtension;
|
|
|
|
if (ext->link_name)
|
|
{
|
|
TRACE("Delete link %s\n", debugstr_w(ext->link_name));
|
|
RtlInitUnicodeString(&linkW, ext->link_name);
|
|
|
|
status = IoDeleteSymbolicLink(&linkW);
|
|
if (status != STATUS_SUCCESS)
|
|
ERR("Delete Symbolic Link failed (%x)\n",status);
|
|
}
|
|
|
|
if (ext->thread)
|
|
{
|
|
SetEvent(ext->halt_event);
|
|
WaitForSingleObject(ext->thread, INFINITE);
|
|
}
|
|
CloseHandle(ext->halt_event);
|
|
|
|
HeapFree(GetProcessHeap(), 0, ext->preparseData);
|
|
if (ext->ring_buffer)
|
|
RingBuffer_Destroy(ext->ring_buffer);
|
|
|
|
entry = RemoveHeadList(&ext->irp_queue);
|
|
while(entry != &ext->irp_queue)
|
|
{
|
|
irp = CONTAINING_RECORD(entry, IRP, Tail.Overlay.ListEntry);
|
|
irp->IoStatus.u.Status = STATUS_DEVICE_REMOVED;
|
|
IoCompleteRequest(irp, IO_NO_INCREMENT);
|
|
entry = RemoveHeadList(&ext->irp_queue);
|
|
}
|
|
|
|
TRACE("Delete device(%p) %s\n", device, debugstr_w(ext->device_name));
|
|
HeapFree(GetProcessHeap(), 0, ext->device_name);
|
|
HeapFree(GetProcessHeap(), 0, ext->link_name);
|
|
|
|
IoDeleteDevice(device);
|
|
}
|
|
|
|
static NTSTATUS handle_IOCTL_HID_GET_COLLECTION_INFORMATION(IRP *irp, BASE_DEVICE_EXTENSION *base)
|
|
{
|
|
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
|
|
if (irpsp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(HID_COLLECTION_INFORMATION))
|
|
{
|
|
irp->IoStatus.u.Status = STATUS_BUFFER_OVERFLOW;
|
|
irp->IoStatus.Information = 0;
|
|
}
|
|
else
|
|
{
|
|
memcpy(irp->AssociatedIrp.SystemBuffer, &base->information, sizeof(HID_COLLECTION_INFORMATION));
|
|
irp->IoStatus.Information = sizeof(HID_COLLECTION_INFORMATION);
|
|
irp->IoStatus.u.Status = STATUS_SUCCESS;
|
|
}
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
static NTSTATUS handle_IOCTL_HID_GET_COLLECTION_DESCRIPTOR(IRP *irp, BASE_DEVICE_EXTENSION *base)
|
|
{
|
|
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
|
|
|
|
if (irpsp->Parameters.DeviceIoControl.OutputBufferLength < base->preparseData->dwSize)
|
|
{
|
|
irp->IoStatus.u.Status = STATUS_INVALID_BUFFER_SIZE;
|
|
irp->IoStatus.Information = 0;
|
|
}
|
|
else
|
|
{
|
|
memcpy(irp->UserBuffer, base->preparseData, base->preparseData->dwSize);
|
|
irp->IoStatus.Information = base->preparseData->dwSize;
|
|
irp->IoStatus.u.Status = STATUS_SUCCESS;
|
|
}
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
static NTSTATUS handle_minidriver_string(DEVICE_OBJECT *device, IRP *irp, SHORT index)
|
|
{
|
|
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
|
|
WCHAR buffer[127];
|
|
NTSTATUS status;
|
|
ULONG InputBuffer;
|
|
|
|
InputBuffer = MAKELONG(index, 0);
|
|
status = call_minidriver(IOCTL_HID_GET_STRING, device, ULongToPtr(InputBuffer), sizeof(InputBuffer), buffer, sizeof(buffer));
|
|
|
|
if (status == STATUS_SUCCESS)
|
|
{
|
|
WCHAR *out_buffer = (WCHAR*)(((BYTE*)irp->MdlAddress->StartVa) + irp->MdlAddress->ByteOffset);
|
|
int length = irpsp->Parameters.DeviceIoControl.OutputBufferLength/sizeof(WCHAR);
|
|
TRACE("got string %s from minidriver\n",debugstr_w(buffer));
|
|
lstrcpynW(out_buffer, buffer, length);
|
|
irp->IoStatus.Information = (lstrlenW(buffer)+1) * sizeof(WCHAR);
|
|
}
|
|
irp->IoStatus.u.Status = status;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS WINAPI HID_Device_ioctl(DEVICE_OBJECT *device, IRP *irp)
|
|
{
|
|
NTSTATUS rc = STATUS_SUCCESS;
|
|
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
|
|
BASE_DEVICE_EXTENSION *extension = device->DeviceExtension;
|
|
|
|
irp->IoStatus.Information = 0;
|
|
|
|
TRACE("device %p ioctl(%x)\n", device, irpsp->Parameters.DeviceIoControl.IoControlCode);
|
|
|
|
switch (irpsp->Parameters.DeviceIoControl.IoControlCode)
|
|
{
|
|
case IOCTL_HID_GET_POLL_FREQUENCY_MSEC:
|
|
TRACE("IOCTL_HID_GET_POLL_FREQUENCY_MSEC\n");
|
|
if (irpsp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG))
|
|
{
|
|
irp->IoStatus.u.Status = STATUS_BUFFER_OVERFLOW;
|
|
irp->IoStatus.Information = 0;
|
|
break;
|
|
}
|
|
*((ULONG*)irp->AssociatedIrp.SystemBuffer) = extension->poll_interval;
|
|
irp->IoStatus.Information = sizeof(ULONG);
|
|
irp->IoStatus.u.Status = STATUS_SUCCESS;
|
|
break;
|
|
case IOCTL_HID_SET_POLL_FREQUENCY_MSEC:
|
|
{
|
|
ULONG poll_interval;
|
|
TRACE("IOCTL_HID_SET_POLL_FREQUENCY_MSEC\n");
|
|
if (irpsp->Parameters.DeviceIoControl.InputBufferLength < sizeof(ULONG))
|
|
{
|
|
irp->IoStatus.u.Status = STATUS_BUFFER_TOO_SMALL;
|
|
break;
|
|
}
|
|
poll_interval = *(ULONG *)irp->AssociatedIrp.SystemBuffer;
|
|
if (poll_interval == 0)
|
|
FIXME("Handle opportunistic reads\n");
|
|
else if (poll_interval <= MAX_POLL_INTERVAL_MSEC)
|
|
{
|
|
extension->poll_interval = poll_interval;
|
|
irp->IoStatus.u.Status = STATUS_SUCCESS;
|
|
}
|
|
else
|
|
irp->IoStatus.u.Status = STATUS_INVALID_PARAMETER;
|
|
break;
|
|
}
|
|
case IOCTL_HID_GET_PRODUCT_STRING:
|
|
{
|
|
rc = handle_minidriver_string(device, irp, HID_STRING_ID_IPRODUCT);
|
|
break;
|
|
}
|
|
case IOCTL_HID_GET_MANUFACTURER_STRING:
|
|
{
|
|
rc = handle_minidriver_string(device, irp, HID_STRING_ID_IMANUFACTURER);
|
|
break;
|
|
}
|
|
case IOCTL_HID_GET_COLLECTION_INFORMATION:
|
|
{
|
|
rc = handle_IOCTL_HID_GET_COLLECTION_INFORMATION(irp, extension);
|
|
break;
|
|
}
|
|
case IOCTL_HID_GET_COLLECTION_DESCRIPTOR:
|
|
{
|
|
rc = handle_IOCTL_HID_GET_COLLECTION_DESCRIPTOR(irp, extension);
|
|
break;
|
|
}
|
|
case IOCTL_HID_GET_INPUT_REPORT:
|
|
{
|
|
HID_XFER_PACKET packet;
|
|
BYTE* buffer = ((BYTE*)irp->MdlAddress->StartVa) + irp->MdlAddress->ByteOffset;
|
|
|
|
if (extension->preparseData->InputReports[0].reportID)
|
|
packet.reportId = buffer[0];
|
|
else
|
|
packet.reportId = 0;
|
|
packet.reportBuffer = buffer;
|
|
packet.reportBufferLen = irpsp->Parameters.DeviceIoControl.OutputBufferLength;
|
|
|
|
call_minidriver(IOCTL_HID_GET_INPUT_REPORT, device, NULL, 0, &packet, sizeof(packet));
|
|
irp->IoStatus.Information = packet.reportBufferLen;
|
|
irp->IoStatus.u.Status = STATUS_SUCCESS;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
ULONG code = irpsp->Parameters.DeviceIoControl.IoControlCode;
|
|
FIXME("Unsupported ioctl %x (device=%x access=%x func=%x method=%x)\n",
|
|
code, code >> 16, (code >> 14) & 3, (code >> 2) & 0xfff, code & 3);
|
|
irp->IoStatus.u.Status = STATUS_NOT_SUPPORTED;
|
|
rc = STATUS_UNSUCCESSFUL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (rc != STATUS_PENDING)
|
|
IoCompleteRequest( irp, IO_NO_INCREMENT );
|
|
|
|
return rc;
|
|
}
|
|
|
|
NTSTATUS WINAPI HID_Device_read(DEVICE_OBJECT *device, IRP *irp)
|
|
{
|
|
HID_XFER_PACKET *packet;
|
|
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
|
|
UINT buffer_size = RingBuffer_GetBufferSize(ext->ring_buffer);
|
|
NTSTATUS rc = STATUS_SUCCESS;
|
|
int ptr = -1;
|
|
|
|
packet = HeapAlloc(GetProcessHeap(), 0, buffer_size);
|
|
ptr = PtrToUlong( irp->Tail.Overlay.OriginalFileObject->FsContext );
|
|
|
|
irp->IoStatus.Information = 0;
|
|
RingBuffer_Read(ext->ring_buffer, ptr, packet, &buffer_size);
|
|
|
|
if (buffer_size)
|
|
{
|
|
IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
|
|
TRACE_(hid_report)("Got Packet %p %i\n", packet->reportBuffer, packet->reportBufferLen);
|
|
if (irpsp->Parameters.Read.Length >= packet->reportBufferLen)
|
|
{
|
|
memcpy(irp->AssociatedIrp.SystemBuffer, packet->reportBuffer, packet->reportBufferLen);
|
|
irp->IoStatus.Information = packet->reportBufferLen;
|
|
irp->IoStatus.u.Status = STATUS_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
irp->IoStatus.Information = 0;
|
|
irp->IoStatus.u.Status = STATUS_BUFFER_OVERFLOW;
|
|
}
|
|
IoCompleteRequest( irp, IO_NO_INCREMENT );
|
|
}
|
|
else
|
|
{
|
|
TRACE_(hid_report)("Queue irp\n");
|
|
InsertTailList(&ext->irp_queue, &irp->Tail.Overlay.ListEntry);
|
|
rc = STATUS_PENDING;
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, packet);
|
|
|
|
return rc;
|
|
}
|
|
|
|
NTSTATUS WINAPI HID_Device_create(DEVICE_OBJECT *device, IRP *irp)
|
|
{
|
|
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
|
|
|
|
TRACE("Open handle on device %p\n", device);
|
|
irp->Tail.Overlay.OriginalFileObject->FsContext = UlongToPtr(RingBuffer_AddPointer(ext->ring_buffer));
|
|
irp->IoStatus.u.Status = STATUS_SUCCESS;
|
|
IoCompleteRequest( irp, IO_NO_INCREMENT );
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS WINAPI HID_Device_close(DEVICE_OBJECT *device, IRP *irp)
|
|
{
|
|
BASE_DEVICE_EXTENSION *ext = device->DeviceExtension;
|
|
int ptr = PtrToUlong(irp->Tail.Overlay.OriginalFileObject->FsContext);
|
|
TRACE("Close handle on device %p\n", device);
|
|
RingBuffer_RemovePointer(ext->ring_buffer, ptr);
|
|
irp->IoStatus.u.Status = STATUS_SUCCESS;
|
|
IoCompleteRequest( irp, IO_NO_INCREMENT );
|
|
return STATUS_SUCCESS;
|
|
}
|