Sweden-Number/dlls/winebus.sys/bus_udev.c

193 lines
5.4 KiB
C
Raw Normal View History

/*
* Plug and Play support for hid devices found through udev
*
* Copyright 2016 CodeWeavers, 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 <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdlib.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#ifdef HAVE_LIBUDEV_H
# include <libudev.h>
#endif
#define NONAMELESSUNION
#include "ntstatus.h"
#define WIN32_NO_STATUS
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "winternl.h"
#include "ddk/wdm.h"
#include "wine/debug.h"
#include "bus.h"
WINE_DEFAULT_DEBUG_CHANNEL(plugplay);
#ifdef HAVE_UDEV
static struct udev *udev_context = NULL;
static DRIVER_OBJECT *udev_driver_obj = NULL;
static const WCHAR hidraw_busidW[] = {'H','I','D','R','A','W',0};
#include "initguid.h"
DEFINE_GUID(GUID_DEVCLASS_HIDRAW, 0x3def44ad,0x242e,0x46e5,0x82,0x6d,0x70,0x72,0x13,0xf3,0xaa,0x81);
static DWORD get_sysattr_dword(struct udev_device *dev, const char *sysattr, int base)
{
const char *attr = udev_device_get_sysattr_value(dev, sysattr);
if (!attr)
{
WARN("Could not get %s from device\n", sysattr);
return 0;
}
return strtol(attr, NULL, base);
}
static WCHAR *get_sysattr_string(struct udev_device *dev, const char *sysattr)
{
const char *attr = udev_device_get_sysattr_value(dev, sysattr);
WCHAR *dst;
DWORD len;
if (!attr)
{
WARN("Could not get %s from device\n", sysattr);
return NULL;
}
len = MultiByteToWideChar(CP_UNIXCP, 0, attr, -1, NULL, 0);
if ((dst = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
MultiByteToWideChar(CP_UNIXCP, 0, attr, -1, dst, len);
return dst;
}
static void try_add_device(struct udev_device *dev)
{
DWORD vid = 0, pid = 0, version = 0;
struct udev_device *usbdev;
DEVICE_OBJECT *device = NULL;
const char *subsystem;
const char *devnode;
WCHAR *serial = NULL;
int fd;
if (!(devnode = udev_device_get_devnode(dev)))
return;
if ((fd = open(devnode, O_RDWR)) == -1)
{
WARN("Unable to open udev device %s: %s\n", debugstr_a(devnode), strerror(errno));
return;
}
close(fd);
usbdev = udev_device_get_parent_with_subsystem_devtype(dev, "usb", "usb_device");
if (usbdev)
{
vid = get_sysattr_dword(usbdev, "idVendor", 16);
pid = get_sysattr_dword(usbdev, "idProduct", 16);
version = get_sysattr_dword(usbdev, "version", 10);
serial = get_sysattr_string(usbdev, "serial");
}
TRACE("Found udev device %s (vid %04x, pid %04x, version %u, serial %s)\n",
debugstr_a(devnode), vid, pid, version, debugstr_w(serial));
subsystem = udev_device_get_subsystem(dev);
if (strcmp(subsystem, "hidraw") == 0)
{
device = bus_create_hid_device(udev_driver_obj, hidraw_busidW, dev, vid, pid,
version, 0, serial, FALSE, &GUID_DEVCLASS_HIDRAW);
}
if (device)
udev_device_ref(dev);
else
WARN("Ignoring device %s with subsystem %s\n", debugstr_a(devnode), subsystem);
HeapFree(GetProcessHeap(), 0, serial);
}
static void build_initial_deviceset(void)
{
struct udev_enumerate *enumerate;
struct udev_list_entry *devices, *dev_list_entry;
enumerate = udev_enumerate_new(udev_context);
if (!enumerate)
{
WARN("Unable to create udev enumeration object\n");
return;
}
if (udev_enumerate_add_match_subsystem(enumerate, "hidraw") < 0)
WARN("Failed to add subsystem 'hidraw' to enumeration\n");
if (udev_enumerate_scan_devices(enumerate) < 0)
WARN("Enumeration scan failed\n");
devices = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(dev_list_entry, devices)
{
struct udev_device *dev;
const char *path;
path = udev_list_entry_get_name(dev_list_entry);
if ((dev = udev_device_new_from_syspath(udev_context, path)))
{
try_add_device(dev);
udev_device_unref(dev);
}
}
udev_enumerate_unref(enumerate);
}
NTSTATUS WINAPI udev_driver_init(DRIVER_OBJECT *driver, UNICODE_STRING *registry_path)
{
TRACE("(%p, %s)\n", driver, debugstr_w(registry_path->Buffer));
if (!(udev_context = udev_new()))
{
ERR("Can't create udev object\n");
return STATUS_UNSUCCESSFUL;
}
udev_driver_obj = driver;
driver->MajorFunction[IRP_MJ_PNP] = common_pnp_dispatch;
build_initial_deviceset();
return STATUS_SUCCESS;
}
#else
NTSTATUS WINAPI udev_driver_init(DRIVER_OBJECT *driver, UNICODE_STRING *registry_path)
{
WARN("Wine was compiled without UDEV support\n");
return STATUS_NOT_IMPLEMENTED;
}
#endif /* HAVE_UDEV */