/* DirectInput Linux Event Device Effect * * Copyright 2005 Daniel Remenak * * Thanks to Google's Summer of Code Program (2005) * * 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" #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION #include #include #ifdef HAVE_LINUX_INPUT_H # include # undef SW_MAX #endif #include #include #ifdef HAVE_UNISTD_H # include #endif #include #include "wine/debug.h" #include "wine/unicode.h" #include "windef.h" #include "winbase.h" #include "winerror.h" #include "dinput.h" #include "device_private.h" #include "joystick_private.h" WINE_DEFAULT_DEBUG_CHANNEL(dinput); static const IDirectInputEffectVtbl LinuxInputEffectVtbl; typedef struct LinuxInputEffectImpl LinuxInputEffectImpl; struct LinuxInputEffectImpl { IDirectInputEffect IDirectInputEffect_iface; LONG ref; GUID guid; struct ff_effect effect; /* Effect data */ int gain; /* Effect gain */ BOOL first_axis_is_x; int* fd; /* Parent device */ struct list *entry; /* Entry into the parent's list of effects */ }; static inline LinuxInputEffectImpl *impl_from_IDirectInputEffect(IDirectInputEffect *iface) { return CONTAINING_RECORD(iface, LinuxInputEffectImpl, IDirectInputEffect_iface); } static double ff_effect_direction_to_rad(unsigned int dir) { return (dir & 0xffff) * M_PI / 0x8000; } static void ff_dump_effect(struct ff_effect *effect) { const char *type = "(Unknown)", *length = "INFINITE"; struct ff_envelope *env = NULL; double angle; #define FE(x) case x: type = #x; break switch (effect->type) { FE(FF_RUMBLE); FE(FF_PERIODIC); FE(FF_CONSTANT); FE(FF_SPRING); FE(FF_FRICTION); FE(FF_DAMPER); FE(FF_INERTIA); FE(FF_RAMP); } #undef FE /* rotate so 0 points right */ angle = 360 - ff_effect_direction_to_rad(effect->direction + 0xc000) * 180 / M_PI; if (effect->replay.length) length = wine_dbg_sprintf("%u ms", effect->replay.length); TRACE("type 0x%x %s, id %d, direction 0x%x (source angle %.2f), time length %s, start delay %u ms\n", effect->type, type, effect->id, effect->direction, angle, length, effect->replay.delay); if (effect->trigger.button || effect->trigger.interval) TRACE(" -> trigger button %u, re-trigger interval %u ms\n", effect->trigger.button, effect->trigger.interval); if (effect->type == FF_PERIODIC) { struct ff_periodic_effect *per = &effect->u.periodic; const char *wave = "(Unknown)"; #define FE(x) case x: wave = #x; break switch (per->waveform) { FE(FF_SQUARE); FE(FF_TRIANGLE); FE(FF_SINE); FE(FF_SAW_UP); FE(FF_SAW_DOWN); FE(FF_CUSTOM); } #undef FE angle = ff_effect_direction_to_rad(per->phase) * 180 / M_PI; TRACE(" -> waveform 0x%x %s, period %u ms, magnitude %d, offset %d, phase 0x%x (angle %.2f), custom len %d\n", per->waveform, wave, per->period, per->magnitude, per->offset, per->phase, angle, per->custom_len); env = &per->envelope; } else if (effect->type == FF_CONSTANT) { struct ff_constant_effect *cons = &effect->u.constant; TRACE(" -> level %d\n", cons->level); env = &cons->envelope; } else if (effect->type == FF_RAMP) { struct ff_ramp_effect *ramp = &effect->u.ramp; TRACE(" -> start/end level %d/%d\n", ramp->start_level, ramp->end_level); env = &ramp->envelope; } else if (effect->type == FF_RUMBLE) { struct ff_rumble_effect *rumble = &effect->u.rumble; TRACE(" -> strong/weak magnitude %u/%u\n", rumble->strong_magnitude, rumble->weak_magnitude); } else if (effect->type == FF_SPRING || effect->type == FF_FRICTION || effect->type == FF_DAMPER || effect->type == FF_INERTIA) { struct ff_condition_effect *cond = effect->u.condition; int i; for (i = 0; i < 2; i++) { /* format numbers here to make them align correctly */ TRACE(" -> [%d] right/left saturation %5u/%5u, right/left coefficient %5d/%5d," " deadband %5u, center %5d\n", i, cond[i].right_saturation, cond[i].left_saturation, cond[i].right_coeff, cond[i].left_coeff, cond[i].deadband, cond[i].center); } } if (env) TRACE(" -> envelope attack length(ms)/level %u/%u, fade length(ms)/level %u/%u\n", env->attack_length, env->attack_level, env->fade_length, env->fade_level); } /****************************************************************************** * LinuxInputEffectImpl */ static ULONG WINAPI LinuxInputEffectImpl_AddRef( LPDIRECTINPUTEFFECT iface) { LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface); return InterlockedIncrement(&(This->ref)); } static HRESULT WINAPI LinuxInputEffectImpl_Download( LPDIRECTINPUTEFFECT iface) { LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface); int ret, old_effect_id; TRACE("(this=%p)\n", This); ff_dump_effect(&This->effect); old_effect_id = This->effect.id; if (ioctl(*(This->fd), EVIOCSFF, &This->effect) != -1) return DI_OK; /* Linux kernel < 3.14 has a bug that incorrectly assigns an effect ID even * on error, restore it here if that is the case. */ This->effect.id = old_effect_id; switch (errno) { case EINVAL: ret = DIERR_INVALIDPARAM; break; case ENOSPC: ret = DIERR_DEVICEFULL; break; case ENOMEM: ret = DIERR_OUTOFMEMORY; break; default: ret = DIERR_INPUTLOST; break; } TRACE("Could not upload effect to fd %d, errno %d \"%s\", returning 0x%x.\n", *This->fd, errno, strerror(errno), ret); return ret; } static HRESULT WINAPI LinuxInputEffectImpl_Escape( LPDIRECTINPUTEFFECT iface, LPDIEFFESCAPE pesc) { WARN("(this=%p,%p): invalid: no hardware-specific escape codes in this" " driver!\n", iface, pesc); return DI_OK; } static HRESULT WINAPI LinuxInputEffectImpl_GetEffectGuid( LPDIRECTINPUTEFFECT iface, LPGUID pguid) { LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface); TRACE("(this=%p,%p)\n", This, pguid); *pguid = This->guid; return DI_OK; } static HRESULT WINAPI LinuxInputEffectImpl_GetEffectStatus( LPDIRECTINPUTEFFECT iface, LPDWORD pdwFlags) { LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface); TRACE("(this=%p,%p)\n", This, pdwFlags); if (!pdwFlags) return E_POINTER; if (This->effect.id == -1) return DIERR_NOTDOWNLOADED; /* linux sends the effect status through an event. * that event is trapped by our parent joystick driver * and there is no clean way to pass it back to us. */ FIXME("Not enough information to provide a status.\n"); (*pdwFlags) = 0; return DI_OK; } static HRESULT WINAPI LinuxInputEffectImpl_GetParameters( LPDIRECTINPUTEFFECT iface, LPDIEFFECT peff, DWORD dwFlags) { HRESULT diErr = DI_OK; LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface); TRACE("(this=%p,%p,%d)\n", This, peff, dwFlags); /* Major conversion factors are: * times: millisecond (linux) -> microsecond (windows) (x * 1000) * forces: scale 0x7FFF (linux) -> scale 10000 (windows) approx ((x / 33) * 10) * angles: scale 0x7FFF (linux) -> scale 35999 (windows) approx ((x / 33) * 36) * angle bases: 0 -> -y (down) (linux) -> 0 -> +x (right) (windows) */ if (dwFlags & DIEP_AXES) { if (peff->cAxes < 2 /* linuxinput effects always use 2 axes, x and y */) diErr = DIERR_MOREDATA; peff->cAxes = 2; if (diErr) return diErr; else { peff->rgdwAxes[0] = DIJOFS_X; peff->rgdwAxes[1] = DIJOFS_Y; } } if (dwFlags & DIEP_DIRECTION) { if (peff->cAxes < 2) diErr = DIERR_MOREDATA; peff->cAxes = 2; if (diErr) return diErr; else { if (peff->dwFlags & DIEFF_CARTESIAN) { /* rotate so 0 points right */ double angle = ff_effect_direction_to_rad(This->effect.direction + 0xc000); peff->rglDirection[0] = sin(angle) * 1000; peff->rglDirection[1] = -cos(angle) * 1000; } else { /* Polar and spherical coordinates are the same for two or less * axes. * Note that we also use this case if NO flags are marked. * According to MSDN, we should return the direction in the * format that it was specified in, if no flags are marked. */ peff->rglDirection[0] = (This->effect.direction / 33) * 36 + 9000; if (peff->rglDirection[0] > 35999) peff->rglDirection[0] -= 35999; } } } if (dwFlags & DIEP_DURATION) { if (!This->effect.replay.length) /* infinite for the linux driver */ peff->dwDuration = INFINITE; else peff->dwDuration = (DWORD)This->effect.replay.length * 1000; } if (dwFlags & DIEP_ENVELOPE) { struct ff_envelope* env; if (This->effect.type == FF_CONSTANT) env = &This->effect.u.constant.envelope; else if (This->effect.type == FF_PERIODIC) env = &This->effect.u.periodic.envelope; else if (This->effect.type == FF_RAMP) env = &This->effect.u.ramp.envelope; else env = NULL; if (env == NULL) { peff->lpEnvelope = NULL; } else if (peff->lpEnvelope == NULL) { return DIERR_INVALIDPARAM; } else { peff->lpEnvelope->dwAttackLevel = (env->attack_level / 33) * 10; peff->lpEnvelope->dwAttackTime = env->attack_length * 1000; peff->lpEnvelope->dwFadeLevel = (env->fade_level / 33) * 10; peff->lpEnvelope->dwFadeTime = env->fade_length * 1000; } } if (dwFlags & DIEP_GAIN) { peff->dwGain = This->gain * 10000 / 0xFFFF; } if (dwFlags & DIEP_SAMPLEPERIOD) { /* the linux input ff driver has no support for setting * the playback sample period. 0 means default. */ peff->dwSamplePeriod = 0; } if ((dwFlags & DIEP_STARTDELAY) && peff->dwSize > sizeof(DIEFFECT_DX5)) peff->dwStartDelay = This->effect.replay.delay * 1000; if (dwFlags & DIEP_TRIGGERBUTTON) { FIXME("LinuxInput button mapping needs redoing; for now, assuming we're using an actual joystick.\n"); peff->dwTriggerButton = DIJOFS_BUTTON(This->effect.trigger.button - BTN_JOYSTICK); } if (dwFlags & DIEP_TRIGGERREPEATINTERVAL) { peff->dwTriggerRepeatInterval = This->effect.trigger.interval * 1000; } if (dwFlags & DIEP_TYPESPECIFICPARAMS) { DWORD expectedsize = 0; if (This->effect.type == FF_PERIODIC) { expectedsize = sizeof(DIPERIODIC); } else if (This->effect.type == FF_CONSTANT) { expectedsize = sizeof(DICONSTANTFORCE); } else if (This->effect.type == FF_SPRING || This->effect.type == FF_FRICTION || This->effect.type == FF_INERTIA || This->effect.type == FF_DAMPER) { expectedsize = sizeof(DICONDITION) * 2; } else if (This->effect.type == FF_RAMP) { expectedsize = sizeof(DIRAMPFORCE); } if (expectedsize > peff->cbTypeSpecificParams) diErr = DIERR_MOREDATA; peff->cbTypeSpecificParams = expectedsize; if (diErr) return diErr; else { if (This->effect.type == FF_PERIODIC) { LPDIPERIODIC tsp = peff->lpvTypeSpecificParams; tsp->dwMagnitude = (This->effect.u.periodic.magnitude / 33) * 10; tsp->lOffset = (This->effect.u.periodic.offset / 33) * 10; tsp->dwPhase = (This->effect.u.periodic.phase / 33) * 36; tsp->dwPeriod = (This->effect.u.periodic.period * 1000); } else if (This->effect.type == FF_CONSTANT) { LPDICONSTANTFORCE tsp = peff->lpvTypeSpecificParams; tsp->lMagnitude = (This->effect.u.constant.level / 33) * 10; } else if (This->effect.type == FF_SPRING || This->effect.type == FF_FRICTION || This->effect.type == FF_INERTIA || This->effect.type == FF_DAMPER) { LPDICONDITION tsp = peff->lpvTypeSpecificParams; int i; for (i = 0; i < 2; ++i) { tsp[i].lOffset = (This->effect.u.condition[i].center / 33) * 10; tsp[i].lPositiveCoefficient = (This->effect.u.condition[i].right_coeff / 33) * 10; tsp[i].lNegativeCoefficient = (This->effect.u.condition[i].left_coeff / 33) * 10; tsp[i].dwPositiveSaturation = (This->effect.u.condition[i].right_saturation / 33) * 10; tsp[i].dwNegativeSaturation = (This->effect.u.condition[i].left_saturation / 33) * 10; tsp[i].lDeadBand = (This->effect.u.condition[i].deadband / 33) * 10; } } else if (This->effect.type == FF_RAMP) { LPDIRAMPFORCE tsp = peff->lpvTypeSpecificParams; tsp->lStart = (This->effect.u.ramp.start_level / 33) * 10; tsp->lEnd = (This->effect.u.ramp.end_level / 33) * 10; } } } return diErr; } static HRESULT WINAPI LinuxInputEffectImpl_Initialize( LPDIRECTINPUTEFFECT iface, HINSTANCE hinst, DWORD dwVersion, REFGUID rguid) { FIXME("(this=%p,%p,%d,%s): stub!\n", iface, hinst, dwVersion, debugstr_guid(rguid)); return DI_OK; } static HRESULT WINAPI LinuxInputEffectImpl_QueryInterface( LPDIRECTINPUTEFFECT iface, REFIID riid, void **ppvObject) { LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface); TRACE("(this=%p,%s,%p)\n", This, debugstr_guid(riid), ppvObject); if (IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IDirectInputEffect, riid)) { LinuxInputEffectImpl_AddRef(iface); *ppvObject = This; return 0; } TRACE("Unsupported interface!\n"); return E_FAIL; } static HRESULT WINAPI LinuxInputEffectImpl_Start( LPDIRECTINPUTEFFECT iface, DWORD dwIterations, DWORD dwFlags) { struct input_event event; LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface); TRACE("(this=%p,%d,%d)\n", This, dwIterations, dwFlags); if (!(dwFlags & DIES_NODOWNLOAD)) { /* Download the effect if necessary */ if (This->effect.id == -1) { HRESULT res = LinuxInputEffectImpl_Download(iface); if (res != DI_OK) return res; } } if (dwFlags & DIES_SOLO) { FIXME("Solo mode requested: should be stopping all effects here!\n"); } event.type = EV_FF; event.code = This->effect.id; event.value = min( dwIterations, INT_MAX ); if (write(*(This->fd), &event, sizeof(event)) == -1) { FIXME("Unable to write event. Assuming device disconnected.\n"); return DIERR_INPUTLOST; } return DI_OK; } static HRESULT WINAPI LinuxInputEffectImpl_SetParameters( LPDIRECTINPUTEFFECT iface, LPCDIEFFECT peff, DWORD dwFlags) { LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface); DWORD type = typeFromGUID(&This->guid); HRESULT retval = DI_OK; TRACE("(this=%p,%p,%d)\n", This, peff, dwFlags); dump_DIEFFECT(peff, &This->guid, dwFlags); if ((dwFlags & ~DIEP_NORESTART & ~DIEP_NODOWNLOAD & ~DIEP_START) == 0) { /* set everything */ dwFlags = DIEP_AXES | DIEP_DIRECTION | DIEP_DURATION | DIEP_ENVELOPE | DIEP_GAIN | DIEP_SAMPLEPERIOD | DIEP_STARTDELAY | DIEP_TRIGGERBUTTON | DIEP_TRIGGERREPEATINTERVAL | DIEP_TYPESPECIFICPARAMS; } if (dwFlags & DIEP_AXES) { /* the linux input effect system only supports one or two axes */ if (peff->cAxes > 2) return DIERR_INVALIDPARAM; else if (peff->cAxes < 1) return DIERR_INCOMPLETEEFFECT; This->first_axis_is_x = peff->rgdwAxes[0] == DIJOFS_X; } /* some of this may look funky, but it's 'cause the linux driver and directx have * different opinions about which way direction "0" is. directx has 0 along the x * axis (left), linux has it along the y axis (down). */ if (dwFlags & DIEP_DIRECTION) { if (peff->cAxes == 1) { if (peff->dwFlags & DIEFF_CARTESIAN) { if (dwFlags & DIEP_AXES) { if (peff->rgdwAxes[0] == DIJOFS_X && peff->rglDirection[0] >= 0) This->effect.direction = 0x4000; else if (peff->rgdwAxes[0] == DIJOFS_X && peff->rglDirection[0] < 0) This->effect.direction = 0xC000; else if (peff->rgdwAxes[0] == DIJOFS_Y && peff->rglDirection[0] >= 0) This->effect.direction = 0; else if (peff->rgdwAxes[0] == DIJOFS_Y && peff->rglDirection[0] < 0) This->effect.direction = 0x8000; } } else { /* one-axis effects must use cartesian coords */ return DIERR_INVALIDPARAM; } } /* two axes */ else { if (peff->dwFlags & DIEFF_CARTESIAN) { LONG x, y; if (This->first_axis_is_x) { x = peff->rglDirection[0]; y = peff->rglDirection[1]; } else { x = peff->rglDirection[1]; y = peff->rglDirection[0]; } This->effect.direction = (unsigned int)((M_PI / 2 + atan2(y, x)) * 0x8000 / M_PI); } else { /* Polar and spherical are the same for 2 axes */ /* Precision is important here, so we do double math with exact constants */ This->effect.direction = (unsigned int)(((double)peff->rglDirection[0] / 18000) * 0x8000); } } } if (dwFlags & DIEP_DURATION) { if (peff->dwDuration == INFINITE) This->effect.replay.length = 0; /* infinite for the linux driver */ else if(peff->dwDuration > 1000) This->effect.replay.length = peff->dwDuration / 1000; else This->effect.replay.length = 1; } if (dwFlags & DIEP_ENVELOPE) { struct ff_envelope* env; if (This->effect.type == FF_CONSTANT) env = &This->effect.u.constant.envelope; else if (This->effect.type == FF_PERIODIC) env = &This->effect.u.periodic.envelope; else if (This->effect.type == FF_RAMP) env = &This->effect.u.ramp.envelope; else env = NULL; /* copy the envelope if it is present and the linux effect supports it */ if (peff->lpEnvelope && env) { env->attack_length = peff->lpEnvelope->dwAttackTime / 1000; env->attack_level = (peff->lpEnvelope->dwAttackLevel / 10) * 32; env->fade_length = peff->lpEnvelope->dwFadeTime / 1000; env->fade_level = (peff->lpEnvelope->dwFadeLevel / 10) * 32; } /* if the dinput envelope is NULL we will clear the linux envelope */ else if (env) { env->attack_length = 0; env->attack_level = 0; env->fade_length = 0; env->fade_level = 0; } else if(peff->lpEnvelope) { if(peff->lpEnvelope->dwAttackTime || peff->lpEnvelope->dwAttackLevel || peff->lpEnvelope->dwFadeTime || peff->lpEnvelope->dwFadeLevel) WARN("Ignoring dinput envelope not supported in the linux effect\n"); } } /* Gain and Sample Period settings are not supported by the linux * event system */ if (dwFlags & DIEP_GAIN) { This->gain = 0xFFFF * peff->dwGain / 10000; TRACE("Effect gain requested but no effect gain functionality present.\n"); } if (dwFlags & DIEP_SAMPLEPERIOD) TRACE("Sample period requested but no sample period functionality present.\n"); if (dwFlags & DIEP_STARTDELAY) if ((dwFlags & DIEP_STARTDELAY) && peff->dwSize > sizeof(DIEFFECT_DX5)) This->effect.replay.delay = peff->dwStartDelay / 1000; if (dwFlags & DIEP_TRIGGERBUTTON) { if (peff->dwTriggerButton != -1) { FIXME("Linuxinput button mapping needs redoing, assuming we're using a joystick.\n"); FIXME("Trigger button translation not yet implemented!\n"); } This->effect.trigger.button = 0; } if (dwFlags & DIEP_TRIGGERREPEATINTERVAL) This->effect.trigger.interval = peff->dwTriggerRepeatInterval / 1000; if (dwFlags & DIEP_TYPESPECIFICPARAMS) { if (!(peff->lpvTypeSpecificParams)) return DIERR_INCOMPLETEEFFECT; if (type == DIEFT_PERIODIC) { DIPERIODIC *tsp; if (peff->cbTypeSpecificParams != sizeof(DIPERIODIC)) return DIERR_INVALIDPARAM; tsp = peff->lpvTypeSpecificParams; This->effect.u.periodic.magnitude = (tsp->dwMagnitude / 10) * 32; This->effect.u.periodic.offset = (tsp->lOffset / 10) * 32; /* phase ranges from 0 - 35999 in dinput and 0 - 65535 on Linux */ This->effect.u.periodic.phase = (tsp->dwPhase / 36) * 65; /* dinput uses microseconds, Linux uses milliseconds */ if (tsp->dwPeriod <= 1000) This->effect.u.periodic.period = 1; else This->effect.u.periodic.period = tsp->dwPeriod / 1000; } else if (type == DIEFT_CONSTANTFORCE) { LPCDICONSTANTFORCE tsp; if (peff->cbTypeSpecificParams != sizeof(DICONSTANTFORCE)) return DIERR_INVALIDPARAM; tsp = peff->lpvTypeSpecificParams; This->effect.u.constant.level = (max(min(tsp->lMagnitude, 10000), -10000) / 10) * 32; } else if (type == DIEFT_RAMPFORCE) { LPCDIRAMPFORCE tsp; if (peff->cbTypeSpecificParams != sizeof(DIRAMPFORCE)) return DIERR_INVALIDPARAM; tsp = peff->lpvTypeSpecificParams; This->effect.u.ramp.start_level = (tsp->lStart / 10) * 32; This->effect.u.ramp.end_level = (tsp->lEnd / 10) * 32; } else if (type == DIEFT_CONDITION) { DICONDITION *tsp = peff->lpvTypeSpecificParams; struct ff_condition_effect *cond = This->effect.u.condition; int i, j, sources; double factor[2]; if (peff->cbTypeSpecificParams == sizeof(DICONDITION)) { /* One condition block. This needs to be rotated to direction, * and expanded to separate x and y conditions. Ensures 0 points right */ double angle = ff_effect_direction_to_rad(This->effect.direction + 0xc000); factor[0] = sin(angle); factor[1] = -cos(angle); sources = 1; } else if (peff->cbTypeSpecificParams == 2 * sizeof(DICONDITION)) { /* Direct parameter copy without changes */ factor[0] = factor[1] = 1; sources = 2; } else return DIERR_INVALIDPARAM; for (i = j = 0; i < 2; ++i) { cond[i].center = (int)(factor[i] * (tsp[j].lOffset / 10) * 32); cond[i].right_coeff = (int)(factor[i] * (tsp[j].lPositiveCoefficient / 10) * 32); cond[i].left_coeff = (int)(factor[i] * (tsp[j].lNegativeCoefficient / 10) * 32); cond[i].right_saturation = (int)(factor[i] * (tsp[j].dwPositiveSaturation / 10) * 65); cond[i].left_saturation = (int)(factor[i] * (tsp[j].dwNegativeSaturation / 10) * 65); cond[i].deadband = (int)(factor[i] * (tsp[j].lDeadBand / 10) * 32); if (sources == 2) j++; } } else { FIXME("Custom force types are not supported\n"); return DIERR_INVALIDPARAM; } } if (!(dwFlags & DIEP_NODOWNLOAD)) retval = LinuxInputEffectImpl_Download(iface); if (retval != DI_OK) return DI_DOWNLOADSKIPPED; if (dwFlags & DIEP_NORESTART) TRACE("DIEP_NORESTART: not handled (we have no control of that).\n"); if (dwFlags & DIEP_START) retval = LinuxInputEffectImpl_Start(iface, 1, 0); if (retval != DI_OK) return retval; return DI_OK; } static HRESULT WINAPI LinuxInputEffectImpl_Stop( LPDIRECTINPUTEFFECT iface) { struct input_event event; LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface); TRACE("(this=%p)\n", This); event.type = EV_FF; event.code = This->effect.id; event.value = 0; /* we don't care about the success or failure of this call */ write(*(This->fd), &event, sizeof(event)); return DI_OK; } static HRESULT WINAPI LinuxInputEffectImpl_Unload( LPDIRECTINPUTEFFECT iface) { LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface); TRACE("(this=%p)\n", This); /* Erase the downloaded effect */ if (ioctl(*(This->fd), EVIOCRMFF, This->effect.id) == -1) return DIERR_INVALIDPARAM; /* Mark the effect as deallocated */ This->effect.id = -1; return DI_OK; } static ULONG WINAPI LinuxInputEffectImpl_Release(LPDIRECTINPUTEFFECT iface) { LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface); ULONG ref = InterlockedDecrement(&(This->ref)); if (ref == 0) { LinuxInputEffectImpl_Stop(iface); LinuxInputEffectImpl_Unload(iface); list_remove(This->entry); HeapFree(GetProcessHeap(), 0, LIST_ENTRY(This->entry, effect_list_item, entry)); HeapFree(GetProcessHeap(), 0, This); } return ref; } /****************************************************************************** * LinuxInputEffect */ DECLSPEC_HIDDEN HRESULT linuxinput_create_effect( int* fd, REFGUID rguid, struct list *parent_list_entry, LPDIRECTINPUTEFFECT* peff) { LinuxInputEffectImpl* newEffect = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LinuxInputEffectImpl)); DWORD type = typeFromGUID(rguid); newEffect->IDirectInputEffect_iface.lpVtbl = &LinuxInputEffectVtbl; newEffect->ref = 1; newEffect->guid = *rguid; newEffect->fd = fd; newEffect->gain = 0xFFFF; /* set the type. this cannot be changed over the effect's life. */ switch (type) { case DIEFT_PERIODIC: newEffect->effect.type = FF_PERIODIC; if (IsEqualGUID(rguid, &GUID_Sine)) { newEffect->effect.u.periodic.waveform = FF_SINE; } else if (IsEqualGUID(rguid, &GUID_Triangle)) { newEffect->effect.u.periodic.waveform = FF_TRIANGLE; } else if (IsEqualGUID(rguid, &GUID_Square)) { newEffect->effect.u.periodic.waveform = FF_SQUARE; } else if (IsEqualGUID(rguid, &GUID_SawtoothUp)) { newEffect->effect.u.periodic.waveform = FF_SAW_UP; } else if (IsEqualGUID(rguid, &GUID_SawtoothDown)) { newEffect->effect.u.periodic.waveform = FF_SAW_DOWN; } break; case DIEFT_CONSTANTFORCE: newEffect->effect.type = FF_CONSTANT; break; case DIEFT_RAMPFORCE: newEffect->effect.type = FF_RAMP; break; case DIEFT_CONDITION: if (IsEqualGUID(rguid, &GUID_Spring)) { newEffect->effect.type = FF_SPRING; } else if (IsEqualGUID(rguid, &GUID_Friction)) { newEffect->effect.type = FF_FRICTION; } else if (IsEqualGUID(rguid, &GUID_Inertia)) { newEffect->effect.type = FF_INERTIA; } else if (IsEqualGUID(rguid, &GUID_Damper)) { newEffect->effect.type = FF_DAMPER; } break; case DIEFT_CUSTOMFORCE: FIXME("Custom forces are not supported.\n"); HeapFree(GetProcessHeap(), 0, newEffect); return DIERR_INVALIDPARAM; default: FIXME("Unknown force type 0x%x.\n", type); HeapFree(GetProcessHeap(), 0, newEffect); return DIERR_INVALIDPARAM; } /* mark as non-uploaded */ newEffect->effect.id = -1; newEffect->entry = parent_list_entry; *peff = &newEffect->IDirectInputEffect_iface; TRACE("Creating linux input system effect (%p) with guid %s\n", *peff, _dump_dinput_GUID(rguid)); return DI_OK; } DECLSPEC_HIDDEN HRESULT linuxinput_get_info_A( int fd, REFGUID rguid, LPDIEFFECTINFOA info) { DWORD type = typeFromGUID(rguid); TRACE("(%d, %s, %p) type=%d\n", fd, _dump_dinput_GUID(rguid), info, type); if (!info) return E_POINTER; if (info->dwSize != sizeof(DIEFFECTINFOA)) return DIERR_INVALIDPARAM; info->guid = *rguid; info->dwEffType = type; /* the event device API does not support querying for all these things * therefore we assume that we have support for them * that's not as dangerous as it sounds, since drivers are allowed to * ignore parameters they claim to support anyway */ info->dwEffType |= DIEFT_DEADBAND | DIEFT_FFATTACK | DIEFT_FFFADE | DIEFT_POSNEGCOEFFICIENTS | DIEFT_POSNEGSATURATION | DIEFT_SATURATION | DIEFT_STARTDELAY; /* again, assume we have support for everything */ info->dwStaticParams = DIEP_ALLPARAMS; info->dwDynamicParams = info->dwStaticParams; /* yes, this is windows behavior (print the GUID_Name for name) */ strcpy(info->tszName, _dump_dinput_GUID(rguid)); return DI_OK; } DECLSPEC_HIDDEN HRESULT linuxinput_get_info_W( int fd, REFGUID rguid, LPDIEFFECTINFOW info) { DWORD type = typeFromGUID(rguid); TRACE("(%d, %s, %p) type=%d\n", fd, _dump_dinput_GUID(rguid), info, type); if (!info) return E_POINTER; if (info->dwSize != sizeof(DIEFFECTINFOW)) return DIERR_INVALIDPARAM; info->guid = *rguid; info->dwEffType = type; /* the event device API does not support querying for all these things * therefore we assume that we have support for them * that's not as dangerous as it sounds, since drivers are allowed to * ignore parameters they claim to support anyway */ info->dwEffType |= DIEFT_DEADBAND | DIEFT_FFATTACK | DIEFT_FFFADE | DIEFT_POSNEGCOEFFICIENTS | DIEFT_POSNEGSATURATION | DIEFT_SATURATION | DIEFT_STARTDELAY; /* again, assume we have support for everything */ info->dwStaticParams = DIEP_ALLPARAMS; info->dwDynamicParams = info->dwStaticParams; /* yes, this is windows behavior (print the GUID_Name for name) */ MultiByteToWideChar(CP_ACP, 0, _dump_dinput_GUID(rguid), -1, info->tszName, MAX_PATH); return DI_OK; } static const IDirectInputEffectVtbl LinuxInputEffectVtbl = { LinuxInputEffectImpl_QueryInterface, LinuxInputEffectImpl_AddRef, LinuxInputEffectImpl_Release, LinuxInputEffectImpl_Initialize, LinuxInputEffectImpl_GetEffectGuid, LinuxInputEffectImpl_GetParameters, LinuxInputEffectImpl_SetParameters, LinuxInputEffectImpl_Start, LinuxInputEffectImpl_Stop, LinuxInputEffectImpl_GetEffectStatus, LinuxInputEffectImpl_Download, LinuxInputEffectImpl_Unload, LinuxInputEffectImpl_Escape }; #endif /* HAVE_STRUCT_FF_EFFECT_DIRECTION */