/* * Force feedback support for various HID compliant devices by ThrustMaster: *    ThrustMaster FireStorm Dual Power 2 * and possibly others whose device ids haven't been added. * *  Modified to support ThrustMaster devices by Zinx Verituse *  on 2003-01-25 from the Logitech force feedback driver, *  which is by Johann Deneux. * *  Copyright (c) 2003 Zinx Verituse <zinx@epicsol.org> *  Copyright (c) 2002 Johann Deneux *//* * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */#include <linux/input.h>#include <linux/sched.h>#undef DEBUG#include <linux/usb.h>#include <linux/circ_buf.h>#include "hid.h"#include "fixp-arith.h"/* Usages for thrustmaster devices I know about */#define THRUSTMASTER_USAGE_RUMBLE_LR	(HID_UP_GENDESK | 0xbb)#define DELAY_CALC(t,delay)		((t) + (delay)*HZ/1000)/* Effect status */#define EFFECT_STARTED 0	/* Effect is going to play after some time */#define EFFECT_PLAYING 1	/* Effect is playing */#define EFFECT_USED    2/* For tmff_device::flags */#define DEVICE_CLOSING 0	/* The driver is being unitialised *//* Check that the current process can access an effect */#define CHECK_OWNERSHIP(effect) (current->pid == 0 \        || effect.owner == current->pid)#define TMFF_CHECK_ID(id)	((id) >= 0 && (id) < TMFF_EFFECTS)#define TMFF_CHECK_OWNERSHIP(i, l) \        (test_bit(EFFECT_USED, l->effects[i].flags) \        && CHECK_OWNERSHIP(l->effects[i]))#define TMFF_EFFECTS 8struct tmff_effect {	pid_t owner;	struct ff_effect effect;	unsigned long flags[1];	unsigned int count;             /* Number of times left to play */	unsigned long play_at;          /* When the effect starts to play */	unsigned long stop_at;		/* When the effect ends */};struct tmff_device {	struct hid_device *hid;	struct hid_report *report;	struct hid_field *rumble;	unsigned int effects_playing;	struct tmff_effect effects[TMFF_EFFECTS];	spinlock_t lock;             /* device-level lock. Having locks on					a per-effect basis could be nice, but					isn't really necessary */	unsigned long flags[1];      /* Contains various information about the					state of the driver for this device */	struct timer_list timer;};/* Callbacks */static void hid_tmff_exit(struct hid_device *hid);static int hid_tmff_event(struct hid_device *hid, struct input_dev *input,			  unsigned int type, unsigned int code, int value);static int hid_tmff_flush(struct input_dev *input, struct file *file);static int hid_tmff_upload_effect(struct input_dev *input,				  struct ff_effect *effect);static int hid_tmff_erase(struct input_dev *input, int id);/* Local functions */static void hid_tmff_recalculate_timer(struct tmff_device *tmff);static void hid_tmff_timer(unsigned long timer_data);int hid_tmff_init(struct hid_device *hid){	struct tmff_device *private;	struct list_head *pos;	struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);	private = kmalloc(sizeof(struct tmff_device), GFP_KERNEL);	if (!private)		return -ENOMEM;	memset(private, 0, sizeof(struct tmff_device));	hid->ff_private = private;	/* Find the report to use */	__list_for_each(pos, &hid->report_enum[HID_OUTPUT_REPORT].report_list) {		struct hid_report *report = (struct hid_report *)pos;		int fieldnum;		for (fieldnum = 0; fieldnum < report->maxfield; ++fieldnum) {			struct hid_field *field = report->field[fieldnum];			if (field->maxusage <= 0)				continue;			switch (field->usage[0].hid) {				case THRUSTMASTER_USAGE_RUMBLE_LR:					if (field->report_count < 2) {						warn("ignoring THRUSTMASTER_USAGE_RUMBLE_LR with report_count < 2");						continue;					}					if (field->logical_maximum == field->logical_minimum) {						warn("ignoring THRUSTMASTER_USAGE_RUMBLE_LR with logical_maximum == logical_minimum");						continue;					}					if (private->report && private->report != report) {						warn("ignoring THRUSTMASTER_USAGE_RUMBLE_LR in other report");						continue;					}					if (private->rumble && private->rumble != field) {						warn("ignoring duplicate THRUSTMASTER_USAGE_RUMBLE_LR");						continue;					}					private->report = report;					private->rumble = field;					set_bit(FF_RUMBLE, hidinput->input.ffbit);					break;				default:					warn("ignoring unknown output usage %08x", field->usage[0].hid);					continue;			}			/* Fallthrough to here only when a valid usage is found */			hidinput->input.upload_effect = hid_tmff_upload_effect;			hidinput->input.flush = hid_tmff_flush;			set_bit(EV_FF, hidinput->input.evbit);			hidinput->input.ff_effects_max = TMFF_EFFECTS;		}	}	private->hid = hid;	spin_lock_init(&private->lock);	init_timer(&private->timer);	private->timer.data = (unsigned long)private;	private->timer.function = hid_tmff_timer;	/* Event and exit callbacks */	hid->ff_exit = hid_tmff_exit;	hid->ff_event = hid_tmff_event;	info("Force feedback for ThrustMaster rumble pad devices by Zinx Verituse <zinx@epicsol.org>");	return 0;}static void hid_tmff_exit(struct hid_device *hid){	struct tmff_device *tmff = hid->ff_private;	unsigned long flags;	spin_lock_irqsave(&tmff->lock, flags);	set_bit(DEVICE_CLOSING, tmff->flags);	del_timer_sync(&tmff->timer);	spin_unlock_irqrestore(&tmff->lock, flags);	kfree(tmff);}static int hid_tmff_event(struct hid_device *hid, struct input_dev *input,			  unsigned int type, unsigned int code, int value){	struct tmff_device *tmff = hid->ff_private;	struct tmff_effect *effect = &tmff->effects[code];	unsigned long flags;	if (type != EV_FF)		return -EINVAL;	if (!TMFF_CHECK_ID(code))		return -EINVAL;	if (!TMFF_CHECK_OWNERSHIP(code, tmff))		return -EACCES;	if (value < 0)		return -EINVAL;	spin_lock_irqsave(&tmff->lock, flags);	if (value > 0) {		set_bit(EFFECT_STARTED, effect->flags);		clear_bit(EFFECT_PLAYING, effect->flags);		effect->count = value;		effect->play_at = DELAY_CALC(jiffies, effect->effect.replay.delay);	} else {		clear_bit(EFFECT_STARTED, effect->flags);		clear_bit(EFFECT_PLAYING, effect->flags);	}	hid_tmff_recalculate_timer(tmff);	spin_unlock_irqrestore(&tmff->lock, flags);	return 0;}/* Erase all effects this process owns */static int hid_tmff_flush(struct input_dev *dev, struct file *file){	struct hid_device *hid = dev->private;	struct tmff_device *tmff = hid->ff_private;	int i;	for (i=0; i<dev->ff_effects_max; ++i)	     /* NOTE: no need to lock here. The only times EFFECT_USED is		modified is when effects are uploaded or when an effect is		erased. But a process cannot close its dev/input/eventX fd		and perform ioctls on the same fd all at the same time */		if (current->pid == tmff->effects[i].owner		     && test_bit(EFFECT_USED, tmff->effects[i].flags))			if (hid_tmff_erase(dev, i))				warn("erase effect %d failed", i);	return 0;}static int hid_tmff_erase(struct input_dev *dev, int id){	struct hid_device *hid = dev->private;	struct tmff_device *tmff = hid->ff_private;	unsigned long flags;	if (!TMFF_CHECK_ID(id))		return -EINVAL;	if (!TMFF_CHECK_OWNERSHIP(id, tmff))		return -EACCES;	spin_lock_irqsave(&tmff->lock, flags);	tmff->effects[id].flags[0] = 0;	hid_tmff_recalculate_timer(tmff);	spin_unlock_irqrestore(&tmff->lock, flags);	return 0;}static int hid_tmff_upload_effect(struct input_dev *input,				  struct ff_effect *effect){	struct hid_device *hid = input->private;	struct tmff_device *tmff = hid->ff_private;	int id;	unsigned long flags;	if (!test_bit(effect->type, input->ffbit))		return -EINVAL;	if (effect->id != -1 && !TMFF_CHECK_ID(effect->id))		return -EINVAL;	spin_lock_irqsave(&tmff->lock, flags);	if (effect->id == -1) {		/* Find a free effect */		for (id = 0; id < TMFF_EFFECTS && test_bit(EFFECT_USED, tmff->effects[id].flags); ++id);		if (id >= TMFF_EFFECTS) {			spin_unlock_irqrestore(&tmff->lock, flags);			return -ENOSPC;		}		effect->id = id;		tmff->effects[id].owner = current->pid;		tmff->effects[id].flags[0] = 0;		set_bit(EFFECT_USED, tmff->effects[id].flags);	} else {		/* Re-uploading an owned effect, to change parameters */		id = effect->id;		clear_bit(EFFECT_PLAYING, tmff->effects[id].flags);	}	tmff->effects[id].effect = *effect;	hid_tmff_recalculate_timer(tmff);	spin_unlock_irqrestore(&tmff->lock, flags);	return 0;}/* Start the timer for the next start/stop/delay *//* Always call this while tmff->lock is locked */static void hid_tmff_recalculate_timer(struct tmff_device *tmff){	int i;	int events = 0;	unsigned long next_time;	next_time = 0;	/* Shut up compiler's incorrect warning */	/* Find the next change in an effect's status */	for (i = 0; i < TMFF_EFFECTS; ++i) {		struct tmff_effect *effect = &tmff->effects[i];		unsigned long play_time;		if (!test_bit(EFFECT_STARTED, effect->flags))			continue;		effect->stop_at = DELAY_CALC(effect->play_at, effect->effect.replay.length);		if (!test_bit(EFFECT_PLAYING, effect->flags))			play_time = effect->play_at;		else			play_time = effect->stop_at;		events++;		if (time_after(jiffies, play_time))			play_time = jiffies;		if (events == 1)			next_time = play_time;		else {			if (time_after(next_time, play_time))				next_time = play_time;		}	}	if (!events && tmff->effects_playing) {		/* Treat all effects turning off as an event */		events = 1;		next_time = jiffies;	}	if (!events) {		/* No events, no time, no need for a timer. */		del_timer_sync(&tmff->timer);		return;	}	mod_timer(&tmff->timer, next_time);}/* Changes values from 0 to 0xffff into values from minimum to maximum */static inline int hid_tmff_scale(unsigned int in, int minimum, int maximum){	int ret;	ret = (in * (maximum - minimum) / 0xffff) + minimum;	if (ret < minimum)		return minimum;	if (ret > maximum)		return maximum;	return ret;}static void hid_tmff_timer(unsigned long timer_data){	struct tmff_device *tmff = (struct tmff_device *) timer_data;	struct hid_device *hid = tmff->hid;	unsigned long flags;	int left = 0, right = 0;	/* Rumbling */	int i;	spin_lock_irqsave(&tmff->lock, flags);	tmff->effects_playing = 0;	for (i = 0; i < TMFF_EFFECTS; ++i) {		struct tmff_effect *effect = &tmff->effects[i];		if (!test_bit(EFFECT_STARTED, effect->flags))			continue;		if (!time_after(jiffies, effect->play_at))			continue;		if (time_after(jiffies, effect->stop_at)) {			dbg("Finished playing once %d", i);			clear_bit(EFFECT_PLAYING, effect->flags);			if (--effect->count <= 0) {				dbg("Stopped %d", i);				clear_bit(EFFECT_STARTED, effect->flags);				continue;			} else {				dbg("Start again %d", i);				effect->play_at = DELAY_CALC(jiffies, effect->effect.replay.delay);				continue;			}		}		++tmff->effects_playing;		set_bit(EFFECT_PLAYING, effect->flags);		switch (effect->effect.type) {			case FF_RUMBLE:				right += effect->effect.u.rumble.strong_magnitude;				left += effect->effect.u.rumble.weak_magnitude;				break;			default:				BUG();				break;		}	}	left = hid_tmff_scale(left, tmff->rumble->logical_minimum, tmff->rumble->logical_maximum);	right = hid_tmff_scale(right, tmff->rumble->logical_minimum, tmff->rumble->logical_maximum);	if (left != tmff->rumble->value[0] || right != tmff->rumble->value[1]) {		tmff->rumble->value[0] = left;		tmff->rumble->value[1] = right;		dbg("(left,right)=(%08x, %08x)", left, right);		hid_submit_report(hid, tmff->report, USB_DIR_OUT);	}	if (!test_bit(DEVICE_CLOSING, tmff->flags))		hid_tmff_recalculate_timer(tmff);	spin_unlock_irqrestore(&tmff->lock, flags);}