[dinput] initial support for BSD's usbhid joysticks
Christoph Frick
frick at sc-networks.de
Fri Apr 25 19:52:48 CDT 2008
From 7618ceb6941c0dffac9c48c1fa1aeb7e821673a2 Mon Sep 17 00:00:00 2001
From: Christoph Frick <frick at sc-networks.com>
Date: Sat, 26 Apr 2008 02:50:01 +0200
Subject: [PATCH] Initial support for BSD's usbhid joysticks
Please consider this a tracer bullet. I had only time to test it with a
4-axis/4-button wheel in LFS in FreeBSD 7.0. I will take further tests using a
flight stick and other games soon. But for now i just want to see, what others
have to say about it.
---
configure.ac | 7 +
dlls/dinput/Makefile.in | 3 +-
dlls/dinput/dinput_main.c | 3 +-
dlls/dinput/dinput_private.h | 1 +
dlls/dinput/joystick_bsduhid.c | 937 ++++++++++++++++++++++++++++++++++++++++
5 files changed, 949 insertions(+), 2 deletions(-)
create mode 100644 dlls/dinput/joystick_bsduhid.c
diff --git a/configure.ac b/configure.ac
index da31303..70ab903 100644
--- a/configure.ac
+++ b/configure.ac
@@ -331,6 +331,7 @@ AC_CHECK_HEADERS(\
syscall.h \
termios.h \
unistd.h \
+ usbhid.h \
utime.h \
valgrind/memcheck.h
)
@@ -1513,6 +1514,12 @@ then
fi
fi
+AC_SUBST(LIBUSBHID,"")
+if test "$ac_cv_header_usbhid_h" = "yes"
+then
+ AC_CHECK_LIB(usbhid,hid_get_report_desc,[AC_DEFINE(HAVE_USBHID,1,[Define if usbhid is there (only BSDs)]) AC_SUBST(LIBUSBHID,"-lusbhid")])
+fi
+
dnl **** FIXME: what about mixed cases, where we need two of them? ***
dnl Check for statfs members
diff --git a/dlls/dinput/Makefile.in b/dlls/dinput/Makefile.in
index 3843677..c5eaa66 100644
--- a/dlls/dinput/Makefile.in
+++ b/dlls/dinput/Makefile.in
@@ -5,7 +5,7 @@ VPATH = @srcdir@
MODULE = dinput.dll
IMPORTLIB = dinput
IMPORTS = ole32 user32 advapi32 kernel32
-EXTRALIBS = -ldxguid -luuid
+EXTRALIBS = -ldxguid -luuid @LIBUSBHID@
C_SRCS = \
data_formats.c \
@@ -14,6 +14,7 @@ C_SRCS = \
effect_linuxinput.c \
joystick_linux.c \
joystick_linuxinput.c \
+ joystick_bsduhid.c \
keyboard.c \
mouse.c \
regsvr.c
diff --git a/dlls/dinput/dinput_main.c b/dlls/dinput/dinput_main.c
index 5fa21f0..f893eab 100644
--- a/dlls/dinput/dinput_main.c
+++ b/dlls/dinput/dinput_main.c
@@ -79,7 +79,8 @@ static const struct dinput_device *dinput_devices[] =
&mouse_device,
&keyboard_device,
&joystick_linuxinput_device,
- &joystick_linux_device
+ &joystick_linux_device,
+ &joystick_bsduhid_device
};
#define NB_DINPUT_DEVICES (sizeof(dinput_devices)/sizeof(dinput_devices[0]))
diff --git a/dlls/dinput/dinput_private.h b/dlls/dinput/dinput_private.h
index 15783e2..57d10dc 100644
--- a/dlls/dinput/dinput_private.h
+++ b/dlls/dinput/dinput_private.h
@@ -58,6 +58,7 @@ extern const struct dinput_device mouse_device;
extern const struct dinput_device keyboard_device;
extern const struct dinput_device joystick_linux_device;
extern const struct dinput_device joystick_linuxinput_device;
+extern const struct dinput_device joystick_bsduhid_device;
extern void check_dinput_hooks(LPDIRECTINPUTDEVICE8A);
typedef void (*DI_EVENT_PROC)(LPDIRECTINPUTDEVICE8A, WPARAM, LPARAM);
diff --git a/dlls/dinput/joystick_bsduhid.c b/dlls/dinput/joystick_bsduhid.c
new file mode 100644
index 0000000..bda0dfb
--- /dev/null
+++ b/dlls/dinput/joystick_bsduhid.c
@@ -0,0 +1,937 @@
+/*
+ * DirectInput Joystick device For BSD's uhid(4) interface
+ *
+ * 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 "wine/port.h"
+#include <errno.h>
+#include <stdio.h>
+#include <time.h>
+#ifdef HAVE_SYS_TIME_H
+# include <sys/time.h>
+#endif
+#ifdef HAVE_SYS_ERRNO_H
+#include <sys/errno.h>
+#endif
+#ifdef HAVE_SYS_IOCTL_H
+# include <sys/ioctl.h>
+#endif
+#ifdef HAVE_SYS_POLL_H
+# include <sys/poll.h>
+#endif
+
+#include "wine/debug.h"
+#include "wine/unicode.h"
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+#include "winreg.h"
+#include "dinput.h"
+
+#include "dinput_private.h"
+#include "device_private.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(dinput);
+
+#ifdef HAVE_USBHID
+
+#include <usbhid.h>
+#include <dev/usb/usb.h>
+#include <dev/usb/usbhid.h>
+
+#define FMT_UHIDDEVS "/dev/uhid%d"
+#define MAX_UHIDDEVS 64
+
+/* FIXME: these are offsets in c_dfDIJoystick2 */
+#define WINE_JOYSTICK_MAX_AXES 8
+#define WINE_JOYSTICK_MAX_POVS 4
+#define WINE_JOYSTICK_MAX_BUTTONS 128
+
+typedef struct JoystickImpl JoystickImpl;
+static const IDirectInputDevice8AVtbl JoystickAvt;
+static const IDirectInputDevice8WVtbl JoystickWvt;
+
+struct JoyDev {
+ char *device;
+ char *name;
+ GUID guid;
+
+ int num_axes;
+ int num_buttons;
+
+ struct hid_item axes[WINE_JOYSTICK_MAX_AXES];
+ struct hid_item buttons[WINE_JOYSTICK_MAX_BUTTONS];
+
+ int axis_values[WINE_JOYSTICK_MAX_AXES];
+ int button_values[WINE_JOYSTICK_MAX_BUTTONS];
+
+ size_t len_data;
+ char *data;
+};
+
+struct JoystickImpl {
+ struct IDirectInputDevice2AImpl base;
+ struct JoyDev *joydev;
+ DIJOYSTATE2 js;
+ ObjProps props [WINE_JOYSTICK_MAX_AXES];
+ int joyfd;
+};
+
+static const GUID DInput_Wine_Joystick_Base_GUID = { /* 9e573edb-7734-11d2-8d4
+ * a-23903fb6bdf7 */
+ 0x9e573edb,
+ 0x7734,
+ 0x11d2,
+ {0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf7}
+};
+
+static int have_joy_devs = -1;
+static struct JoyDev *joy_devs = NULL;
+
+static void
+find_joy_devs(void)
+{
+ int i;
+
+ if (have_joy_devs >= 0) {
+ return;
+ }
+ have_joy_devs = 0;
+
+ for (i = 0; i < MAX_UHIDDEVS; i++) {
+ int usb_report_id, is_joystick = 0;
+ char buf [MAX_PATH];
+ int fd;
+ struct JoyDev joydev = {0};
+ report_desc_t rdesc;
+
+ snprintf(buf, MAX_PATH, FMT_UHIDDEVS, i);
+ buf[MAX_PATH - 1] = 0;
+
+ if ((fd = open(buf, O_RDWR | O_NDELAY, 0)) == -1) {
+ TRACE("Unable to open %s read/write: %s\n", buf, strerror(errno));
+ continue;
+ }
+ if ((rdesc = hid_get_report_desc(fd)) == 0) {
+ TRACE("%s: unable to get report descriptor: %s\n", buf, strerror(errno));
+ close(fd);
+ continue;
+ }
+ if (ioctl(fd, USB_GET_REPORT_ID, &usb_report_id) < 0) {
+ TRACE("%s: unable to get USB report id: %s\n", buf, strerror(errno));
+ hid_dispose_report_desc(rdesc);
+ close(fd);
+ continue;
+ }
+ joydev.len_data = hid_report_size(rdesc, hid_input, usb_report_id);
+ joydev.data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(char) * joydev.len_data);
+
+ {
+ struct hid_data *hdata;
+ struct hid_item hitem;
+ hdata = hid_start_parse(rdesc, 1 << hid_input, usb_report_id);
+ do {
+ int page = HID_PAGE(hitem.usage);
+ int usage = HID_USAGE(hitem.usage);
+
+ is_joystick |= hitem.kind == hid_collection && page == HUP_GENERIC_DESKTOP && (usage == HUG_JOYSTICK || usage == HUG_GAME_PAD);
+ if (hitem.kind != hid_input) {
+ continue;
+ }
+ if (!is_joystick) {
+ continue;
+ }
+ if (page == HUP_GENERIC_DESKTOP) {
+ if (usage != HUG_HAT_SWITCH) {
+ if (joydev.num_axes < WINE_JOYSTICK_MAX_AXES) {
+ joydev.axes[joydev.num_axes++] = hitem;
+ }
+ }
+ } else if (page == HUP_BUTTON) {
+ if (joydev.num_buttons < WINE_JOYSTICK_MAX_BUTTONS) {
+ joydev.buttons[joydev.num_buttons++] = hitem;
+ }
+ }
+ } while (hid_get_item(hdata, &hitem));
+ hid_end_parse(hdata);
+ }
+
+ if (!is_joystick) {
+ TRACE("%s: looks not like a joystick\n", buf);
+ HeapFree(GetProcessHeap(), 0, joydev.data);
+ hid_dispose_report_desc(rdesc);
+ close(fd);
+ continue;
+ }
+ joydev.device = strdup(buf);
+ joydev.name = strdup(buf); /* TODO */
+ joydev.guid = DInput_Wine_Joystick_Base_GUID;
+ joydev.guid.Data3 += have_joy_devs;
+
+ TRACE("Found a joystick on %s: %s (%s)\n", joydev.device, joydev.name, debugstr_guid(&joydev.guid));
+
+ if (have_joy_devs == 0) {
+ joy_devs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct JoyDev));
+ } else {
+ HeapReAlloc(GetProcessHeap(), 0, joy_devs, (1 + have_joy_devs) * sizeof(struct JoyDev));
+ }
+ joy_devs[have_joy_devs++] = joydev;
+
+ hid_dispose_report_desc(rdesc);
+ close(fd);
+ }
+}
+
+#define CENTER_AXIS(a) (a < ji->joydev->num_axes ? joystick_map_axis( &ji->props[a], ji->joydev->axis_values[a]) : 0)
+static void fake_current_js_state(JoystickImpl *ji)
+{
+ ji->js.lX = CENTER_AXIS(0);
+ ji->js.lY = CENTER_AXIS(1);
+ ji->js.lZ = CENTER_AXIS(2);
+ ji->js.lRx = CENTER_AXIS(3);
+ ji->js.lRy = CENTER_AXIS(4);
+ ji->js.lRz = CENTER_AXIS(5);
+ ji->js.rglSlider[0] = CENTER_AXIS(6);
+ ji->js.rglSlider[1] = CENTER_AXIS(7);
+}
+#undef CENTER_AXIS
+
+/* FIXME: duplication */
+static void
+fill_joystick_dideviceinstanceA(LPDIDEVICEINSTANCEA lpddi, DWORD version, int id)
+{
+ DWORD dwSize = lpddi->dwSize;
+
+ TRACE("%d %p\n", dwSize, lpddi);
+ memset(lpddi, 0, dwSize);
+
+ lpddi->dwSize = dwSize;
+ lpddi->guidInstance = joy_devs[id].guid;
+ lpddi->guidProduct = DInput_Wine_Joystick_Base_GUID;
+ lpddi->guidFFDriver = GUID_NULL;
+
+ if (version >= 0x0800)
+ lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
+ else
+ lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
+
+ strcpy(lpddi->tszInstanceName, joy_devs[id].name);
+ strcpy(lpddi->tszProductName, joy_devs[id].device);
+}
+
+/* FIXME: duplication */
+static void
+fill_joystick_dideviceinstanceW(LPDIDEVICEINSTANCEW lpddi, DWORD version, int id)
+{
+ DWORD dwSize = lpddi->dwSize;
+
+ TRACE("%d %p\n", dwSize, lpddi);
+ memset(lpddi, 0, dwSize);
+
+ lpddi->dwSize = dwSize;
+ lpddi->guidInstance = joy_devs[id].guid;
+ lpddi->guidProduct = DInput_Wine_Joystick_Base_GUID;
+ lpddi->guidFFDriver = GUID_NULL;
+
+ if (version >= 0x0800)
+ lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
+ else
+ lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
+
+ MultiByteToWideChar(CP_ACP, 0, joy_devs[id].name, -1, lpddi->tszInstanceName, MAX_PATH);
+ MultiByteToWideChar(CP_ACP, 0, joy_devs[id].device, -1, lpddi->tszProductName, MAX_PATH);
+}
+
+/* FIXME: duplication */
+static BOOL
+joydev_enum_deviceA(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEA lpddi, DWORD version, int id)
+{
+ find_joy_devs();
+
+ if (id >= have_joy_devs) {
+ return FALSE;
+ }
+ if (!((dwDevType == 0) ||
+ ((dwDevType == DIDEVTYPE_JOYSTICK) && (version > 0x0300 && version < 0x0800)) ||
+ (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))))
+ return FALSE;
+
+ fill_joystick_dideviceinstanceA(lpddi, version, id);
+ return TRUE;
+}
+
+/* FIXME: duplication */
+static BOOL
+joydev_enum_deviceW(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEW lpddi, DWORD version, int id)
+{
+ find_joy_devs();
+
+ if (id >= have_joy_devs) {
+ return FALSE;
+ }
+ if (!((dwDevType == 0) ||
+ ((dwDevType == DIDEVTYPE_JOYSTICK) && (version > 0x0300 && version < 0x0800)) ||
+ (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))))
+ return FALSE;
+
+ fill_joystick_dideviceinstanceW(lpddi, version, id);
+ return TRUE;
+}
+
+/* FIXME: duplication */
+static JoystickImpl *alloc_device(REFGUID rguid, const void *jvt, IDirectInputImpl *dinput, unsigned short index)
+{
+ JoystickImpl* newDevice;
+ LPDIDATAFORMAT df = NULL;
+ int i, idx=0;
+ char buffer[MAX_PATH+16];
+ HKEY hkey, appkey;
+ LONG def_deadzone = 0;
+
+ newDevice = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(JoystickImpl));
+ if (!newDevice) return NULL;
+
+ newDevice->base.lpVtbl = jvt;
+ newDevice->base.ref = 1;
+ newDevice->base.guid = *rguid;
+ newDevice->base.dinput = dinput;
+ newDevice->joyfd = -1;
+ newDevice->joydev = &joy_devs[index];
+ InitializeCriticalSection(&newDevice->base.crit);
+ newDevice->base.crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": JoystickImpl*->base.crit");
+
+ /* get options */
+ get_app_key(&hkey, &appkey);
+
+ if (!get_config_key(hkey, appkey, "DefaultDeadZone", buffer, MAX_PATH))
+ {
+ def_deadzone = atoi(buffer);
+ TRACE("setting default deadzone to: %d\n", def_deadzone);
+ }
+ if (appkey) RegCloseKey(appkey);
+ if (hkey) RegCloseKey(hkey);
+
+ /* Create copy of default data format */
+ if (!(df = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, c_dfDIJoystick2.dwSize))) goto failed;
+ memcpy(df, &c_dfDIJoystick2, c_dfDIJoystick2.dwSize);
+ if (!(df->rgodf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, df->dwNumObjs * df->dwObjSize))) goto failed;
+
+ /* Supported Axis & POVs should map 1-to-1 */
+ for (i = 0; i < newDevice->joydev->num_axes; i++) {
+ memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[i], df->dwObjSize);
+ newDevice->props[idx].lDevMin = newDevice->joydev->axes[i].logical_minimum;
+ newDevice->props[idx].lDevMax = newDevice->joydev->axes[i].logical_maximum;
+ newDevice->props[idx].lMin = 0;
+ newDevice->props[idx].lMax = 0xffff;
+ newDevice->props[idx].lSaturation = 0;
+ newDevice->props[idx].lDeadZone = def_deadzone;
+ df->rgodf[idx].dwType = DIDFT_MAKEINSTANCE(i) | DIDFT_ABSAXIS;
+ idx ++;
+ }
+
+ for (i = 0; i < newDevice->joydev->num_buttons; i++) {
+ memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[WINE_JOYSTICK_MAX_AXES + WINE_JOYSTICK_MAX_POVS + i], df->dwObjSize);
+ df->rgodf[idx ].pguid = &GUID_Button;
+ df->rgodf[idx].dwType = DIDFT_MAKEINSTANCE(i) | DIDFT_PSHBUTTON;
+ idx ++;
+ }
+ df->dwNumObjs = idx;
+
+ fake_current_js_state(newDevice);
+
+ newDevice->base.data_format.wine_df = df;
+ IDirectInput_AddRef((LPDIRECTINPUTDEVICE8A)newDevice->base.dinput);
+ return newDevice;
+
+failed:
+ if (df) HeapFree(GetProcessHeap(), 0, df->rgodf);
+ HeapFree(GetProcessHeap(), 0, df);
+ HeapFree(GetProcessHeap(), 0, newDevice);
+ return NULL;
+}
+
+/* FIXME: duplication */
+/******************************************************************************
+ * get_joystick_index : Get the joystick index from a given GUID
+ */
+static unsigned short get_joystick_index(REFGUID guid)
+{
+ GUID wine_joystick = DInput_Wine_Joystick_Base_GUID;
+ GUID dev_guid = *guid;
+
+ wine_joystick.Data3 = 0;
+ dev_guid.Data3 = 0;
+
+ /* for the standard joystick GUID use index 0 */
+ if(IsEqualGUID(&GUID_Joystick,guid)) return 0;
+
+ /* for the wine joystick GUIDs use the index stored in Data3 */
+ if(IsEqualGUID(&wine_joystick, &dev_guid)) return guid->Data3 - DInput_Wine_Joystick_Base_GUID.Data3;
+
+ return MAX_UHIDDEVS;
+}
+
+/* FIXME: duplication */
+static HRESULT joydev_create_deviceA(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEA* pdev)
+{
+ unsigned short index;
+
+ find_joy_devs();
+
+ if ((index = get_joystick_index(rguid)) < MAX_UHIDDEVS && have_joy_devs && index < have_joy_devs) {
+ if ((riid == NULL) ||
+ IsEqualGUID(&IID_IDirectInputDeviceA, riid) ||
+ IsEqualGUID(&IID_IDirectInputDevice2A, riid) ||
+ IsEqualGUID(&IID_IDirectInputDevice7A, riid) ||
+ IsEqualGUID(&IID_IDirectInputDevice8A, riid))
+ {
+ *pdev = (IDirectInputDeviceA*) alloc_device(rguid, &JoystickAvt, dinput, index);
+ TRACE("Created a Joystick device (%p)\n", *pdev);
+
+ if (*pdev == NULL) {
+ ERR("out of memory\n");
+ return DIERR_OUTOFMEMORY;
+ }
+ return DI_OK;
+ }
+
+ WARN("no interface\n");
+ return DIERR_NOINTERFACE;
+ }
+
+ return DIERR_DEVICENOTREG;
+}
+
+
+/* FIXME: duplication */
+static HRESULT joydev_create_deviceW(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEW* pdev)
+{
+ unsigned short index;
+
+ find_joy_devs();
+
+ if ((index = get_joystick_index(rguid)) < MAX_UHIDDEVS && have_joy_devs && index < have_joy_devs)
+ {
+ if ((riid == NULL) ||
+ IsEqualGUID(&IID_IDirectInputDeviceW, riid) ||
+ IsEqualGUID(&IID_IDirectInputDevice2W, riid) ||
+ IsEqualGUID(&IID_IDirectInputDevice7W, riid) ||
+ IsEqualGUID(&IID_IDirectInputDevice8W, riid))
+ {
+ *pdev = (IDirectInputDeviceW*) alloc_device(rguid, &JoystickWvt, dinput, index);
+ TRACE("Created a Joystick device (%p)\n", *pdev);
+
+ if (*pdev == NULL)
+ {
+ ERR("out of memory\n");
+ return DIERR_OUTOFMEMORY;
+ }
+ return DI_OK;
+ }
+ WARN("no interface\n");
+ return DIERR_NOINTERFACE;
+ }
+
+ WARN("invalid device GUID\n");
+ return DIERR_DEVICENOTREG;
+}
+
+
+const struct dinput_device joystick_bsduhid_device = {
+ "Wine BSD uhid joystick driver",
+ joydev_enum_deviceA,
+ joydev_enum_deviceW,
+ joydev_create_deviceA,
+ joydev_create_deviceW
+};
+
+/******************************************************************************
+ * Acquire : gets exclusive control of the joystick
+ */
+static HRESULT WINAPI JoystickAImpl_Acquire(LPDIRECTINPUTDEVICE8A iface)
+{
+ JoystickImpl *This = (JoystickImpl *)iface;
+ HRESULT res;
+
+ TRACE("(this=%p)\n",This);
+
+ res = IDirectInputDevice2AImpl_Acquire(iface);
+ if (res==DI_OK) {
+ if ((This->joyfd=open(This->joydev->device,O_RDWR|O_NDELAY,0))==-1) {
+ /* Couldn't open in r/w but opened in read-only. */
+ WARN("Could not open %s in read-write mode: %s\n", This->joydev->device, strerror(errno));
+ }
+ }
+ return res;
+}
+
+/******************************************************************************
+ * Unacquire : frees the joystick
+ */
+static HRESULT WINAPI JoystickAImpl_Unacquire(LPDIRECTINPUTDEVICE8A iface)
+{
+ JoystickImpl *This = (JoystickImpl *)iface;
+ HRESULT res;
+
+ TRACE("(this=%p)\n",This);
+ res = IDirectInputDevice2AImpl_Unacquire(iface);
+ if (res==DI_OK && This->joyfd!=-1) {
+ close(This->joyfd);
+ This->joyfd = -1;
+ }
+ return res;
+}
+
+/* convert wine format offset to user format object index */
+static void joy_polldev(JoystickImpl *This)
+{
+ int i;
+ LONG value = 0;
+ int inst_id = -1;
+ struct pollfd plfd;
+ struct timeval time;
+
+ if (This->joyfd==-1)
+ return;
+
+ plfd.fd = This->joyfd;
+ plfd.events = POLLIN;
+
+ if (poll(&plfd,1,0) != 1)
+ return;
+
+ /* we have one event, so we can read */
+ if (This->joydev->len_data!=read(This->joyfd,This->joydev->data,This->joydev->len_data)) {
+ return;
+ }
+
+ gettimeofday(&time, NULL);
+
+ for (i=0; i<This->joydev->num_axes; i++) {
+ value = hid_get_data(This->joydev->data, &This->joydev->axes[i]);
+ TRACE("%d: %d\n", i, value);
+ if (value != This->joydev->axis_values[i]) {
+ This->joydev->axis_values[i] = value;
+ inst_id = DIDFT_MAKEINSTANCE(i) | DIDFT_ABSAXIS;
+ value = joystick_map_axis(&This->props[id_to_object(This->base.data_format.wine_df, inst_id)], value);
+ switch (i) {
+ case 0: This->js.lX = value; break;
+ case 1: This->js.lY = value; break;
+ case 2: This->js.lZ = value; break;
+ case 3: This->js.lRx = value; break;
+ case 4: This->js.lRy = value; break;
+ case 5: This->js.lRz = value; break;
+ case 6: This->js.rglSlider[0] = value; break;
+ case 7: This->js.rglSlider[1] = value; break;
+ }
+ queue_event((LPDIRECTINPUTDEVICE8A)This, id_to_offset(&This->base.data_format, inst_id), value, time.tv_usec, This->base.dinput->evsequence++);
+ }
+ }
+
+ for (i=0; i<This->joydev->num_buttons; i++) {
+ value = hid_get_data(This->joydev->data, &This->joydev->buttons[i]);
+ if (value != This->joydev->button_values[i]) {
+ This->joydev->button_values[i] = value;
+ inst_id = DIDFT_MAKEINSTANCE(i) | DIDFT_PSHBUTTON;
+ This->js.rgbButtons[i] = value == This->joydev->buttons[i].logical_minimum ? 0x00 : 0x80;
+ queue_event((LPDIRECTINPUTDEVICE8A)This, id_to_offset(&This->base.data_format, inst_id), value, time.tv_usec, This->base.dinput->evsequence++);
+ }
+ }
+}
+
+/* FIXME: duplication */
+/******************************************************************************
+ * GetDeviceState : returns the "state" of the joystick.
+ *
+ */
+static HRESULT WINAPI JoystickAImpl_GetDeviceState(
+ LPDIRECTINPUTDEVICE8A iface,DWORD len,LPVOID ptr
+) {
+ JoystickImpl *This = (JoystickImpl *)iface;
+
+ TRACE("(this=%p,0x%08x,%p)\n", This, len, ptr);
+
+ if (!This->base.acquired)
+ {
+ WARN("not acquired\n");
+ return DIERR_NOTACQUIRED;
+ }
+
+ joy_polldev(This);
+
+ /* convert and copy data to user supplied buffer */
+ fill_DataFormat(ptr, &This->js, &This->base.data_format);
+
+ return DI_OK;
+}
+
+/* FIXME: duplication */
+/******************************************************************************
+ * SetProperty : change input device properties
+ */
+static HRESULT WINAPI JoystickAImpl_SetProperty(LPDIRECTINPUTDEVICE8A iface,
+ REFGUID rguid,
+ LPCDIPROPHEADER ph)
+{
+ JoystickImpl *This = (JoystickImpl *)iface;
+
+ if (!ph) {
+ WARN("invalid argument\n");
+ return DIERR_INVALIDPARAM;
+ }
+
+ TRACE("(this=%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
+ TRACE("ph.dwSize = %d, ph.dwHeaderSize =%d, ph.dwObj = %d, ph.dwHow= %d\n",
+ ph->dwSize, ph->dwHeaderSize, ph->dwObj, ph->dwHow);
+
+ if (!HIWORD(rguid)) {
+ switch (LOWORD(rguid)) {
+ case (DWORD)DIPROP_RANGE: {
+ LPCDIPROPRANGE pr = (LPCDIPROPRANGE)ph;
+
+ if (ph->dwHow == DIPH_DEVICE) {
+ int i;
+ TRACE("proprange(%d,%d) all\n", pr->lMin, pr->lMax);
+ for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++) {
+ /* Scale dead-zone */
+ This->props[i].lDeadZone = MulDiv(This->props[i].lDeadZone, pr->lMax - pr->lMin,
+ This->props[i].lMax - This->props[i].lMin);
+ This->props[i].lMin = pr->lMin;
+ This->props[i].lMax = pr->lMax;
+ }
+ } else {
+ int obj = find_property(&This->base.data_format, ph);
+
+ TRACE("proprange(%d,%d) obj=%d\n", pr->lMin, pr->lMax, obj);
+ if (obj >= 0) {
+ /* Scale dead-zone */
+ This->props[obj].lDeadZone = MulDiv(This->props[obj].lDeadZone, pr->lMax - pr->lMin,
+ This->props[obj].lMax - This->props[obj].lMin);
+ This->props[obj].lMin = pr->lMin;
+ This->props[obj].lMax = pr->lMax;
+ }
+ }
+ fake_current_js_state(This);
+ break;
+ }
+ case (DWORD)DIPROP_DEADZONE: {
+ LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
+ if (ph->dwHow == DIPH_DEVICE) {
+ int i;
+ TRACE("deadzone(%d) all\n", pd->dwData);
+ for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++) {
+ This->props[i].lDeadZone = pd->dwData;
+ }
+ } else {
+ int obj = find_property(&This->base.data_format, ph);
+
+ TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
+ if (obj >= 0) {
+ This->props[obj].lDeadZone = pd->dwData;
+ }
+ }
+ fake_current_js_state(This);
+ break;
+ }
+ case (DWORD)DIPROP_CALIBRATIONMODE: {
+ LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
+ FIXME("DIPROP_CALIBRATIONMODE(%d)\n", pd->dwData);
+ break;
+ }
+ case (DWORD)DIPROP_AUTOCENTER: {
+ LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
+
+ FIXME("DIPROP_AUTOCENTER(%d)\n", pd->dwData);
+ break;
+ }
+ default:
+ return IDirectInputDevice2AImpl_SetProperty(iface, rguid, ph);
+ }
+ }
+ return DI_OK;
+}
+
+/* FIXME: duplication */
+static HRESULT WINAPI JoystickAImpl_GetCapabilities(
+ LPDIRECTINPUTDEVICE8A iface,
+ LPDIDEVCAPS lpDIDevCaps)
+{
+ JoystickImpl *This = (JoystickImpl *)iface;
+
+ TRACE("%p->(%p)\n",iface,lpDIDevCaps);
+
+ if (!lpDIDevCaps) {
+ WARN("invalid pointer\n");
+ return E_POINTER;
+ }
+
+ if (lpDIDevCaps->dwSize != sizeof(DIDEVCAPS)) {
+ WARN("invalid argument\n");
+ return DIERR_INVALIDPARAM;
+ }
+
+ lpDIDevCaps->dwFlags = DIDC_ATTACHED;
+ if (This->base.dinput->dwVersion >= 0x0800)
+ lpDIDevCaps->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
+ else
+ lpDIDevCaps->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
+
+ lpDIDevCaps->dwAxes = This->joydev->num_axes;
+ lpDIDevCaps->dwButtons = This->joydev->num_buttons;
+ lpDIDevCaps->dwPOVs = 0;
+
+ return DI_OK;
+}
+
+/* FIXME: duplication */
+static HRESULT WINAPI JoystickAImpl_Poll(LPDIRECTINPUTDEVICE8A iface)
+{
+ JoystickImpl *This = (JoystickImpl *)iface;
+
+ TRACE("(%p)\n",This);
+
+ if (!This->base.acquired)
+ return DIERR_NOTACQUIRED;
+
+ joy_polldev(This);
+ return DI_OK;
+}
+
+/* FIXME: duplication */
+/******************************************************************************
+ * GetProperty : get input device properties
+ */
+static HRESULT WINAPI JoystickAImpl_GetProperty(LPDIRECTINPUTDEVICE8A iface,
+ REFGUID rguid,
+ LPDIPROPHEADER pdiph)
+{
+ JoystickImpl *This = (JoystickImpl *)iface;
+
+ TRACE("(this=%p,%s,%p)\n", iface, debugstr_guid(rguid), pdiph);
+ _dump_DIPROPHEADER(pdiph);
+
+ if (HIWORD(rguid)) return DI_OK;
+
+ switch (LOWORD(rguid)) {
+ case (DWORD) DIPROP_RANGE:
+ {
+ LPDIPROPRANGE pr = (LPDIPROPRANGE) pdiph;
+ int obj = find_property(&This->base.data_format, pdiph);
+
+ if (obj < 0) return DIERR_OBJECTNOTFOUND;
+
+ pr->lMin = This->props[obj].lMin;
+ pr->lMax = This->props[obj].lMax;
+ TRACE("range(%d, %d) obj=%d\n", pr->lMin, pr->lMax, obj);
+ break;
+ }
+ case (DWORD) DIPROP_DEADZONE:
+ {
+ LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
+ int obj = find_property(&This->base.data_format, pdiph);
+
+ if (obj < 0) return DIERR_OBJECTNOTFOUND;
+
+ pd->dwData = This->props[obj].lDeadZone;
+ TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
+ break;
+ }
+
+ default:
+ return IDirectInputDevice2AImpl_GetProperty(iface, rguid, pdiph);
+ }
+
+ return DI_OK;
+}
+
+/* FIXME: duplication */
+/******************************************************************************
+ * GetObjectInfo : get information about a device object such as a button
+ * or axis
+ */
+static HRESULT WINAPI JoystickWImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8W iface,
+ LPDIDEVICEOBJECTINSTANCEW pdidoi, DWORD dwObj, DWORD dwHow)
+{
+ static const WCHAR axisW[] = {'A','x','i','s',' ','%','d',0};
+ static const WCHAR povW[] = {'P','O','V',' ','%','d',0};
+ static const WCHAR buttonW[] = {'B','u','t','t','o','n',' ','%','d',0};
+ HRESULT res;
+
+ res = IDirectInputDevice2WImpl_GetObjectInfo(iface, pdidoi, dwObj, dwHow);
+ if (res != DI_OK) return res;
+
+ if (pdidoi->dwType & DIDFT_AXIS)
+ sprintfW(pdidoi->tszName, axisW, DIDFT_GETINSTANCE(pdidoi->dwType));
+ else if (pdidoi->dwType & DIDFT_POV)
+ sprintfW(pdidoi->tszName, povW, DIDFT_GETINSTANCE(pdidoi->dwType));
+ else if (pdidoi->dwType & DIDFT_BUTTON)
+ sprintfW(pdidoi->tszName, buttonW, DIDFT_GETINSTANCE(pdidoi->dwType));
+
+ _dump_OBJECTINSTANCEW(pdidoi);
+ return res;
+}
+
+/* FIXME: duplication */
+static HRESULT WINAPI JoystickAImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8A iface,
+ LPDIDEVICEOBJECTINSTANCEA pdidoi, DWORD dwObj, DWORD dwHow)
+{
+ HRESULT res;
+ DIDEVICEOBJECTINSTANCEW didoiW;
+ DWORD dwSize = pdidoi->dwSize;
+
+ didoiW.dwSize = sizeof(didoiW);
+ res = JoystickWImpl_GetObjectInfo((LPDIRECTINPUTDEVICE8W)iface, &didoiW, dwObj, dwHow);
+ if (res != DI_OK) return res;
+
+ memset(pdidoi, 0, pdidoi->dwSize);
+ memcpy(pdidoi, &didoiW, FIELD_OFFSET(DIDEVICEOBJECTINSTANCEW, tszName));
+ pdidoi->dwSize = dwSize;
+ WideCharToMultiByte(CP_ACP, 0, didoiW.tszName, -1, pdidoi->tszName,
+ sizeof(pdidoi->tszName), NULL, NULL);
+
+ return res;
+}
+
+/* FIXME: duplication */
+/******************************************************************************
+ * GetDeviceInfo : get information about a device's identity
+ */
+static HRESULT WINAPI JoystickAImpl_GetDeviceInfo(LPDIRECTINPUTDEVICE8A iface,
+ LPDIDEVICEINSTANCEA pdidi)
+{
+ JoystickImpl *This = (JoystickImpl *)iface;
+
+ TRACE("(%p) %p\n", This, pdidi);
+
+ if (pdidi == NULL) return E_POINTER;
+ if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3A)) &&
+ (pdidi->dwSize != sizeof(DIDEVICEINSTANCEA)))
+ return DIERR_INVALIDPARAM;
+
+ fill_joystick_dideviceinstanceA(pdidi, This->base.dinput->dwVersion,
+ get_joystick_index(&This->base.guid));
+ return DI_OK;
+}
+
+/* FIXME: duplication */
+static HRESULT WINAPI JoystickWImpl_GetDeviceInfo(LPDIRECTINPUTDEVICE8W iface,
+ LPDIDEVICEINSTANCEW pdidi)
+{
+ JoystickImpl *This = (JoystickImpl *)iface;
+
+ TRACE("(%p) %p\n", This, pdidi);
+
+ if (pdidi == NULL) return E_POINTER;
+ if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3W)) &&
+ (pdidi->dwSize != sizeof(DIDEVICEINSTANCEW)))
+ return DIERR_INVALIDPARAM;
+
+ fill_joystick_dideviceinstanceW(pdidi, This->base.dinput->dwVersion,
+ get_joystick_index(&This->base.guid));
+ return DI_OK;
+}
+
+static const IDirectInputDevice8AVtbl JoystickAvt =
+{
+ IDirectInputDevice2AImpl_QueryInterface,
+ IDirectInputDevice2AImpl_AddRef,
+ IDirectInputDevice2AImpl_Release,
+ JoystickAImpl_GetCapabilities,
+ IDirectInputDevice2AImpl_EnumObjects,
+ JoystickAImpl_GetProperty,
+ JoystickAImpl_SetProperty,
+ JoystickAImpl_Acquire,
+ JoystickAImpl_Unacquire,
+ JoystickAImpl_GetDeviceState,
+ IDirectInputDevice2AImpl_GetDeviceData,
+ IDirectInputDevice2AImpl_SetDataFormat,
+ IDirectInputDevice2AImpl_SetEventNotification,
+ IDirectInputDevice2AImpl_SetCooperativeLevel,
+ JoystickAImpl_GetObjectInfo,
+ JoystickAImpl_GetDeviceInfo,
+ IDirectInputDevice2AImpl_RunControlPanel,
+ IDirectInputDevice2AImpl_Initialize,
+ IDirectInputDevice2AImpl_CreateEffect,
+ IDirectInputDevice2AImpl_EnumEffects,
+ IDirectInputDevice2AImpl_GetEffectInfo,
+ IDirectInputDevice2AImpl_GetForceFeedbackState,
+ IDirectInputDevice2AImpl_SendForceFeedbackCommand,
+ IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
+ IDirectInputDevice2AImpl_Escape,
+ JoystickAImpl_Poll,
+ IDirectInputDevice2AImpl_SendDeviceData,
+ IDirectInputDevice7AImpl_EnumEffectsInFile,
+ IDirectInputDevice7AImpl_WriteEffectToFile,
+ IDirectInputDevice8AImpl_BuildActionMap,
+ IDirectInputDevice8AImpl_SetActionMap,
+ IDirectInputDevice8AImpl_GetImageInfo
+};
+
+#if !defined(__STRICT_ANSI__) && defined(__GNUC__)
+# define XCAST(fun) (typeof(JoystickWvt.fun))
+#else
+# define XCAST(fun) (void*)
+#endif
+
+static const IDirectInputDevice8WVtbl JoystickWvt =
+{
+ IDirectInputDevice2WImpl_QueryInterface,
+ XCAST(AddRef)IDirectInputDevice2AImpl_AddRef,
+ XCAST(Release)IDirectInputDevice2AImpl_Release,
+ XCAST(GetCapabilities)JoystickAImpl_GetCapabilities,
+ IDirectInputDevice2WImpl_EnumObjects,
+ XCAST(GetProperty)JoystickAImpl_GetProperty,
+ XCAST(SetProperty)JoystickAImpl_SetProperty,
+ XCAST(Acquire)JoystickAImpl_Acquire,
+ XCAST(Unacquire)JoystickAImpl_Unacquire,
+ XCAST(GetDeviceState)JoystickAImpl_GetDeviceState,
+ XCAST(GetDeviceData)IDirectInputDevice2AImpl_GetDeviceData,
+ XCAST(SetDataFormat)IDirectInputDevice2AImpl_SetDataFormat,
+ XCAST(SetEventNotification)IDirectInputDevice2AImpl_SetEventNotification,
+ XCAST(SetCooperativeLevel)IDirectInputDevice2AImpl_SetCooperativeLevel,
+ JoystickWImpl_GetObjectInfo,
+ JoystickWImpl_GetDeviceInfo,
+ XCAST(RunControlPanel)IDirectInputDevice2AImpl_RunControlPanel,
+ XCAST(Initialize)IDirectInputDevice2AImpl_Initialize,
+ XCAST(CreateEffect)IDirectInputDevice2AImpl_CreateEffect,
+ XCAST(EnumEffects)IDirectInputDevice2AImpl_EnumEffects,
+ XCAST(GetEffectInfo)IDirectInputDevice2AImpl_GetEffectInfo,
+ XCAST(GetForceFeedbackState)IDirectInputDevice2AImpl_GetForceFeedbackState,
+ XCAST(SendForceFeedbackCommand)IDirectInputDevice2AImpl_SendForceFeedbackCommand,
+ XCAST(EnumCreatedEffectObjects)IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
+ XCAST(Escape)IDirectInputDevice2AImpl_Escape,
+ XCAST(Poll)JoystickAImpl_Poll,
+ XCAST(SendDeviceData)IDirectInputDevice2AImpl_SendDeviceData,
+ IDirectInputDevice7WImpl_EnumEffectsInFile,
+ IDirectInputDevice7WImpl_WriteEffectToFile,
+ IDirectInputDevice8WImpl_BuildActionMap,
+ IDirectInputDevice8WImpl_SetActionMap,
+ IDirectInputDevice8WImpl_GetImageInfo
+};
+#undef XCAST
+
+#else /* HAVE_USBHID */
+
+const struct dinput_device joystick_bsduhid_device = {
+ "Wine BSD uhid joystick driver",
+ NULL,
+ NULL,
+ NULL,
+ NULL
+};
+
+#endif /* HAVE_USBHID */
--
1.5.5
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 163 bytes
Desc: not available
Url : http://www.winehq.org/pipermail/wine-patches/attachments/20080426/813328dc/attachment-0001.pgp
More information about the wine-patches
mailing list