/*****************************************************************************
 *
 * mtdev - Multitouch Protocol Translation Library (MIT license)
 *
 * Copyright (C) 2010 Henrik Rydberg <rydberg@euromail.se>
 * Copyright (C) 2010 Canonical Ltd.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 ****************************************************************************/

#include "state.h"

static const int SN_COORD = 250;	/* coordinate signal-to-noise ratio */
static const int SN_WIDTH = 100;	/* width signal-to-noise ratio */
static const int SN_ORIENT = 10;	/* orientation signal-to-noise ratio */

static const int bits_per_long = 8 * sizeof(long);

static inline int nlongs(int nbit)
{
	return (nbit + bits_per_long - 1) / bits_per_long;
}

static inline int getbit(const unsigned long *map, int key)
{
	return (map[key / bits_per_long] >> (key % bits_per_long)) & 0x01;
}

static int getabs(struct input_absinfo *abs, int key, int fd)
{
	int rc;
	SYSCALL(rc = ioctl(fd, EVIOCGABS(key), abs));
	return rc >= 0;
}

static struct input_absinfo *get_info(struct mtdev *dev, int code)
{
	int ix;

	if (code == ABS_MT_SLOT)
		return &dev->slot;
	if (!mtdev_is_absmt(code))
		return NULL;

	ix = mtdev_abs2mt(code);
	if (ix < LEGACY_API_NUM_MT_AXES)
		return &dev->abs[ix];
	else
		return &dev->state->ext_abs[ix - LEGACY_API_NUM_MT_AXES];
}

static void set_info(struct mtdev *dev, int code,
		     const unsigned long *bits, int fd)
{
	int has = getbit(bits, code) && getabs(get_info(dev, code), code, fd);
	mtdev_set_mt_event(dev, code, has);
}

static void default_fuzz(struct mtdev *dev, int code, int sn)
{
	struct input_absinfo *abs = get_info(dev, code);
	if (!mtdev_has_mt_event(dev, code) || abs->fuzz)
		return;
	abs->fuzz = (abs->maximum - abs->minimum) / sn;
}

int mtdev_set_slots(struct mtdev *dev, int fd)
{
	struct { unsigned code; int values[DIM_FINGER]; } req;
	struct mtdev_state *state = dev->state;
	int rc, i, s, nslot;

	nslot = mtdev_get_abs_maximum(dev, ABS_MT_SLOT) + 1;

	for (i = 0; i < MT_ABS_SIZE; i++) {
		req.code = mtdev_mt2abs(i);
		if (!mtdev_has_mt_event(dev, req.code))
			continue;
		SYSCALL(rc = ioctl(fd, EVIOCGMTSLOTS(sizeof(req)), &req));
		if (rc < 0)
			return rc;
		for (s = 0; s < DIM_FINGER && s < nslot; s++)
			set_sval(&state->data[s], i, req.values[s]);
	}

	return 0;
}

int mtdev_configure(struct mtdev *dev, int fd)
{
	unsigned long absbits[nlongs(ABS_MAX)];
	int rc, i;

	SYSCALL(rc = ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbits)), absbits));
	if (rc < 0)
		return rc;

	set_info(dev, ABS_MT_SLOT, absbits, fd);
	for (i = 0; i < MT_ABS_SIZE; i++)
		set_info(dev, mtdev_mt2abs(i), absbits, fd);

	dev->has_mtdata = mtdev_has_mt_event(dev, ABS_MT_POSITION_X) &&
		mtdev_has_mt_event(dev, ABS_MT_POSITION_Y);

	if (!mtdev_has_mt_event(dev, ABS_MT_POSITION_X))
		getabs(get_info(dev, ABS_MT_POSITION_X), ABS_X, fd);
	if (!mtdev_has_mt_event(dev, ABS_MT_POSITION_Y))
		getabs(get_info(dev, ABS_MT_POSITION_Y), ABS_Y, fd);
	if (!mtdev_has_mt_event(dev, ABS_MT_PRESSURE))
		getabs(get_info(dev, ABS_MT_PRESSURE), ABS_PRESSURE, fd);

	if (!mtdev_has_mt_event(dev, ABS_MT_TRACKING_ID)) {
		mtdev_set_abs_minimum(dev, ABS_MT_TRACKING_ID, MT_ID_MIN);
		mtdev_set_abs_maximum(dev, ABS_MT_TRACKING_ID, MT_ID_MAX);
	}

	default_fuzz(dev, ABS_MT_POSITION_X, SN_COORD);
	default_fuzz(dev, ABS_MT_POSITION_Y, SN_COORD);
	default_fuzz(dev, ABS_MT_TOUCH_MAJOR, SN_WIDTH);
	default_fuzz(dev, ABS_MT_TOUCH_MINOR, SN_WIDTH);
	default_fuzz(dev, ABS_MT_WIDTH_MAJOR, SN_WIDTH);
	default_fuzz(dev, ABS_MT_WIDTH_MINOR, SN_WIDTH);
	default_fuzz(dev, ABS_MT_ORIENTATION, SN_ORIENT);

	if (dev->has_slot)
		mtdev_set_slots(dev, fd);

	return 0;
}

int mtdev_has_mt_event(const struct mtdev *dev, int code)
{
	int ix;

	if (code == ABS_MT_SLOT)
		return dev->has_slot;
	if (!mtdev_is_absmt(code))
		return 0;

	ix = mtdev_abs2mt(code);
	if (ix < LEGACY_API_NUM_MT_AXES)
		return dev->has_abs[ix];
	else
		return dev->state->has_ext_abs[ix - LEGACY_API_NUM_MT_AXES];
}

int mtdev_get_abs_minimum(const struct mtdev *dev, int code)
{
	const struct input_absinfo *abs = get_info((struct mtdev *)dev, code);
	return abs ? abs->minimum : 0;
}

int mtdev_get_abs_maximum(const struct mtdev *dev, int code)
{
	const struct input_absinfo *abs = get_info((struct mtdev *)dev, code);
	return abs ? abs->maximum : 0;
}

int mtdev_get_abs_fuzz(const struct mtdev *dev, int code)
{
	const struct input_absinfo *abs = get_info((struct mtdev *)dev, code);
	return abs ? abs->fuzz : 0;
}

int mtdev_get_abs_resolution(const struct mtdev *dev, int code)
{
	const struct input_absinfo *abs = get_info((struct mtdev *)dev, code);
	return abs ? abs->resolution : 0;
}

void mtdev_set_abs_minimum(struct mtdev *dev, int code, int value)
{
	struct input_absinfo *abs = get_info(dev, code);
	if (abs)
		abs->minimum = value;
}

void mtdev_set_mt_event(struct mtdev *dev, int code, int value)
{
	int ix;

	if (code == ABS_MT_SLOT)
		dev->has_slot = value;
	if (!mtdev_is_absmt(code))
		return;

	ix = mtdev_abs2mt(code);
	if (ix < LEGACY_API_NUM_MT_AXES)
		dev->has_abs[ix] = value;
	else
		dev->state->has_ext_abs[ix - LEGACY_API_NUM_MT_AXES] = value;
}

void mtdev_set_abs_maximum(struct mtdev *dev, int code, int value)
{
	struct input_absinfo *abs = get_info(dev, code);
	if (abs)
		abs->maximum = value;
}

void mtdev_set_abs_fuzz(struct mtdev *dev, int code, int value)
{
	struct input_absinfo *abs = get_info(dev, code);
	if (abs)
		abs->fuzz = value;
}

void mtdev_set_abs_resolution(struct mtdev *dev, int code, int value)
{
	struct input_absinfo *abs = get_info(dev, code);
	if (abs)
		abs->resolution = value;
}