Subversion Repositories or1k

/*
 * drivers/mou_tp.c
 *
 * Touch-panel driver
 *
 * Designed for for use with the Linux-VR project touch-panel kernel driver.
 * This includes the VTech Helio.
 * Also runs with Embedded Planet's PowerPC LinuxPlanet.
 * Also runs with Yopy (untested, can use mou_yopy.c also)
 *
 * Requires /dev/tpanel kernel driver (char special 10,11)
 *
 * Copyright (C) 1999 Bradley D. LaRonde <brad@ltc.com>
 * Portions Copyright (c) 2001 Kevin Oh <webmaster@prg-lib.net>
 * Portions Copyright (c) 1999, 2000 Greg Haerr <greg@censoft.com>
 * Portions Copyright (c) 1991 David I. Bell
 *
 * Permission is granted to use, distribute, or modify this source,
 * provided that this copyright notice remains intact.
 *
 * This program is free software; you may 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 <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <math.h>
#include <sys/ioctl.h>
#if !defined(TPHELIO) && !defined(YOPY)
#include <linux/tpanel.h>
#endif
#include "device.h"
#include "mou_tp.h"
 
#define EMBEDDEDPLANET	0	/* =1 for embeddedplanet ppc framebuffer*/
#if EMBEDDEDPLANET
#define DATACHANGELIMIT	50
#else
#define DATACHANGELIMIT	100
#endif
 
/*
 * Enable absolute coordinate transformation.
 * Normally this should be left at 1.
 * To disable transformation, set it to 0 before calling MwMain().
 * This is done by the pointer calibration utility since it's used
 * to produce the pointer calibration data file.
 */
int enable_pointing_coordinate_transform = 1;
 
static TRANSFORMATION_COEFFICIENTS tc;
 
/* file descriptor for touch panel */
static int pd_fd;
 
int GetPointerCalibrationData(void)
{
	/*
	 * Read the calibration data from the calibration file.
	 * Calibration file format is seven coefficients separated by spaces.
	 */
 
	/* Get pointer calibration data from this file */
	const char cal_filename[] = "/etc/pointercal";
 
	int items;
 
	FILE* f = fopen(cal_filename, "r");
	if ( f == NULL )
	{
		EPRINTF("Error %d opening pointer calibration file %s.\n",
			errno, cal_filename);
		return -1;
	}
 
	items = fscanf(f, "%d %d %d %d %d %d %d",
		&tc.a, &tc.b, &tc.c, &tc.d, &tc.e, &tc.f, &tc.s);
	if ( items != 7 )
	{
		EPRINTF("Improperly formatted pointer calibration file %s.\n",
			cal_filename);
		return -1;
	}
 
#if TEST
		EPRINTF("a=%d b=%d c=%d d=%d e=%d f=%d s=%d\n",
			tc.a, tc.b, tc.c, tc.d, tc.e, tc.f, tc.s);
#endif
 
	return 0;
}
 
inline MWPOINT DeviceToScreen(MWPOINT p)
{
	/*
	 * Transform device coordinates to screen coordinates.
	 * Take a point p in device coordinates and return the corresponding
	 * point in screen coodinates.
	 * This can scale, translate, rotate and/or skew, based on the
	 * coefficients calculated above based on the list of screen
	 * vs. device coordinates.
	 */
 
	static MWPOINT prev;
	/* set slop at 3/4 pixel */
	const short slop = TRANSFORMATION_UNITS_PER_PIXEL * 3 / 4;
	MWPOINT new, out;
 
	/* transform */
	new.x = (tc.a * p.x + tc.b * p.y + tc.c) / tc.s;
	new.y = (tc.d * p.x + tc.e * p.y + tc.f) / tc.s;
 
	/* hysteresis (thanks to John Siau) */
	if ( abs(new.x - prev.x) >= slop )
		out.x = (new.x | 0x3) ^ 0x3;
	else
		out.x = prev.x;
 
	if ( abs(new.y - prev.y) >= slop )
		out.y = (new.y | 0x3) ^ 0x3;
	else
		out.y = prev.y;
 
	prev = out;
 
	return out;
}
 
#ifndef	YOPY
static int PD_Open(MOUSEDEVICE *pmd)
{
 	/*
	 * open up the touch-panel device.
	 * Return the fd if successful, or negative if unsuccessful.
	 */
#ifndef TPHELIO
	struct scanparam s;
	int settle_upper_limit;
	int result;
#endif
 
	pd_fd = open("/dev/tpanel", O_NONBLOCK);
	if (pd_fd < 0) {
		EPRINTF("Error %d opening touch panel\n", errno);
		return -1;
	}
 
#ifndef TPHELIO
	/* set interval to 5000us (200Hz) */
	s.interval = 5000;
	/*
	 * Upper limit on settle time is approximately (scan_interval / 5) - 60
	 * (5 conversions and some fixed overhead)
	 * The opmtimal value is the lowest that doesn't cause significant
	 * distortion.
	 * 50% of upper limit works well on my Clio.  25% gets into distortion.
	 */
	settle_upper_limit = (s.interval / 5) - 60;
	s.settletime = settle_upper_limit * 50 / 100;
	result = ioctl(pd_fd, TPSETSCANPARM, &s);
	if ( result < 0 )
		EPRINTF("Error %d, result %d setting scan parameters.\n",
			result, errno);
#endif
 
	if (enable_pointing_coordinate_transform)
	{ 
		if (GetPointerCalibrationData() < 0)
		{
			close(pd_fd);
			return -1;
		}
	}
 
	return pd_fd;
}
#else	/* ifndef YOPY */
 
static TRANSFORMATION_COEFFICIENTS default_tc = {
	68339, 328, -3042464, -508, 91638, -4339545, 65536
};
 
static int PD_Open(MOUSEDEVICE *pmd)
 
{
 	/*
	 * open up the touch-panel device.
	 * Return the fd if successful, or negative if unsuccessful.
	 */
 
	pd_fd = open("/dev/yopy-ts", O_NONBLOCK);
	if (pd_fd < 0) {
		EPRINTF("Error %d opening touch panel\n", errno);
		return -1;
	}
 
	if (enable_pointing_coordinate_transform)
	{ 
		if (GetPointerCalibrationData() < 0)
		{
			//close(pd_fd);
			//return -1;
			memcpy( &tc, &default_tc, sizeof(TRANSFORMATION_COEFFICIENTS) );
		}
	}
 
#if 0
		EPRINTF("a=%d b=%d c=%d d=%d e=%d f=%d s=%d\n",
			tc.a, tc.b, tc.c, tc.d, tc.e, tc.f, tc.s);
#endif
 
	return pd_fd;
}
#endif
 
static void PD_Close(void)
{
 	/* Close the touch panel device. */
	if (pd_fd > 0)
		close(pd_fd);
	pd_fd = 0;
}
 
static int PD_GetButtonInfo(void)
{
 	/* get "mouse" buttons supported */
	return MWBUTTON_L;
}
 
static void PD_GetDefaultAccel(int *pscale,int *pthresh)
{
	/*
	 * Get default mouse acceleration settings
	 * This doesn't make sense for a touch panel.
	 * Just return something inconspicuous for now.
	 */
	*pscale = 3;
	*pthresh = 5;
}
 
#ifndef	YOPY
static int PD_Read(MWCOORD *px, MWCOORD *py, MWCOORD *pz, int *pb)
{
	/*
	 * Read the tpanel state and position.
         * Returns the position data in x, y, and button data in b.
	 * Returns -1 on error.
	 * Returns 0 if no new data is available.
	 * Returns 1 if position data is relative (i.e. mice).
	 * Returns 2 if position data is absolute (i.e. touch panels).
	 * Returns 3 if position data is not available, but button data is.
	 * This routine does not block.
	 *
	 * Unlike a mouse, this driver returns absolute postions, not deltas.
	 */
 
	/* If z is below this value, ignore the data. */
	/* const int low_z_limit = 900; EVEREX*/
#ifndef TPHELIO
	const int low_z_limit = 815;
#endif
	/*
	 * I do some error masking by tossing out really wild data points.
	 * Lower data_change_limit value means pointer get's "left behind"
	 * more easily.  Higher value means less errors caught.
	 * The right setting of this value is just slightly higher than
	 * the number of units traversed per sample during a "quick" stroke.
	 */
#ifndef TPHELIO
	const int data_change_limit = DATACHANGELIMIT;
#endif
	static int have_last_data = 0;
	static int last_data_x = 0;
	static int last_data_y = 0;
 
	/*
	 * Thanks to John Siau <jsiau@benchmarkmedia.com> for help with the
	 * noise filter.  I use an infinite impulse response low-pass filter
	 * on the data to filter out high-frequency noise.  Results look
	 * better than a finite impulse response filter.
	 * If I understand it right, the nice thing is that the noise now
	 * acts as a dither signal that effectively increases the resolution
	 * of the a/d converter by a few bits and drops the noise level by
	 * about 10db.
	 * Please don't quote me on those db numbers however. :-)
	 * The end result is that the pointer goes from very fuzzy to much
	 * more steady.  Hysteresis really calms it down in the end (elsewhere).
	 *
	 * iir_shift_bits effectively sets the number of samples used by
	 * the filter * (number of samples is 2^iir_shift_bits).
	 * Lower iir_width means less pointer lag, higher iir_width means
	 * steadier pointer.
	 */
	const int iir_shift_bits = 3;
	const int iir_sample_depth = (1 << iir_shift_bits);
	static int iir_accum_x = 0;
	static int iir_accum_y = 0;
	static int iir_accum_z = 0;
	static int iir_count = 0;
	int data_x, data_y, data_z;
 
	/* read a data point */
#if TPHELIO
	short data[3];
#else
	short data[6];
#endif
	int bytes_read;
	bytes_read = read(pd_fd, data, sizeof(data));
	if (bytes_read != sizeof(data)) {
		if (errno == EINTR || errno == EAGAIN) {
			return 0;
		}
		return -1;
	}
#ifndef TPHELIO
	/* did we lose any data? */
	if ( (data[0] & 0x2000) )
		EPRINTF("Lost touch panel data\n");
 
	/* do we only have contact state data (no position data)? */
	if ( (data[0] & 0x8000) == 0 )
	{
		/* is it a pen-release? */
		if ( (data[0] & 0x4000) == 0 )
		{
			/* reset the limiter */
			have_last_data = 0;
 
			/* reset the filter */
			iir_count = 0;
			iir_accum_x = 0;
			iir_accum_y = 0;
			iir_accum_z = 0;
 
			/* return the pen (button) state only, */
			/* indicating that the pen is up (no buttons are down)*/
			*pb = 0;
			return 3;
		}
 
		/* ignore pen-down since we don't know where it is */
		return 0;
	}
#endif
	/* we have position data */
#if TPHELIO
        data_x = data[1];
        data_y = data[2];
	data_z = data[0] ? 2000 : 0;
#else
	/*
	 * Combine the complementary panel readings into one value (except z)
	 * This effectively doubles the sampling freqency, reducing noise
	 * by approx 3db.
	 * Again, please don't quote the 3db figure.  I think it also
	 * cancels out changes in the overall resistance of the panel
	 * such as may be caused by changes in panel temperature.
	 */
	data_x = data[2] - data[1];
	data_y = data[4] - data[3];
	data_z = data[5];
 
	/* isn't z big enough for valid position data? */
	if ( data_z <= low_z_limit ) {
		return 0;
	}
 
	/* has the position changed more than we will allow? */
	if ( have_last_data )
		if ( (abs(data_x - last_data_x) > data_change_limit)
			|| ( abs(data_y - last_data_y) > data_change_limit ) ) {
			return 0;
		}
#endif
 
	/* save last position */
	last_data_x = data_x;
	last_data_y = data_y;
	have_last_data = 1;
 
	/* is filter ready? */
	if ( iir_count == iir_sample_depth )
	{
#if TPHELIO
                if (enable_pointing_coordinate_transform) {
			MWPOINT transformed = {data_x, data_y};
			transformed = DeviceToScreen(transformed);
 
			*px = transformed.x >> 2;
			*py = transformed.y >> 2;
		} else {
			*px = data_x;
			*py = data_y;
		}
		*pb = data[0] ? MWBUTTON_L : 0;
#else
		/* make room for new sample */
		iir_accum_x -= iir_accum_x >> iir_shift_bits;
		iir_accum_y -= iir_accum_y >> iir_shift_bits;
		iir_accum_z -= iir_accum_z >> iir_shift_bits;
 
		/* feed new sample to filter */
		iir_accum_x += data_x;
		iir_accum_y += data_y;
		iir_accum_z += data_z;
 
		/* transformation enabled? */
		if (enable_pointing_coordinate_transform)
		{
			/* transform x,y to screen coords */
			MWPOINT transformed = {iir_accum_x, iir_accum_y};
			transformed = DeviceToScreen(transformed);
			/*
			 * HACK: move this from quarter pixels to whole
			 * pixels for now at least until I decide on the
			 * right interface to get the quarter-pixel data
			 * up to the next layer.
			 */
			*px = transformed.x >> 2;
			*py = transformed.y >> 2;
		}
		else
		{
			/* return untransformed coords (for calibration) */
			*px = iir_accum_x;
			*py = iir_accum_y;
		}
		*pb = MWBUTTON_L;
#endif
		/* return filtered pressure */
		*pz = iir_accum_z;
 
#ifdef TEST
		EPRINTF("In: %hd, %hd, %hd  Filtered: %d %d %d  Out: %d, %d, %d\n",
			data_x, data_y, data_z, iir_accum_x, iir_accum_y,
			iir_accum_z, *px, *py, *pz);
#endif
		return 2;
	}
 
	/* prime the filter */
	iir_accum_x += data_x;
	iir_accum_y += data_y;
	iir_accum_z += data_z;
	iir_count += 1;
 
	return 0;
}
#else	/* ifdef YOPY */
static int PD_Read(MWCOORD *px, MWCOORD *py, MWCOORD *pz, int *pb)
{
	/*
	 * Read the tpanel state and position.
         * Returns the position data in x, y, and button data in b.
	 * Returns -1 on error.
	 * Returns 0 if no new data is available.
	 * Returns 1 if position data is relative (i.e. mice).
	 * Returns 2 if position data is absolute (i.e. touch panels).
	 * Returns 3 if position data is not available, but button data is.
	 * This routine does not block.
	 *
	 * Unlike a mouse, this driver returns absolute postions, not deltas.
	 */
 
	/* If z is below this value, ignore the data. */
	/* const int low_z_limit = 900; EVEREX*/
 
	/*
	 * I do some error masking by tossing out really wild data points.
	 * Lower data_change_limit value means pointer get's "left behind"
	 * more easily.  Higher value means less errors caught.
	 * The right setting of this value is just slightly higher than
	 * the number of units traversed per sample during a "quick" stroke.
	 */
 
	int data_x, data_y;
 
	/* read a data point */
	int bytes_read;
	int	mou_data;
 
	bytes_read = read(pd_fd, &mou_data, sizeof(mou_data));
	if (bytes_read != sizeof(mou_data)) {
		if (errno == EINTR || errno == EAGAIN) {
			return 0;
		}
		return -1;
	}
 
	data_x = ((MWCOORD)(mou_data & 0x3ff));
	data_y = (MWCOORD)(( mou_data>>10 ) & 0x3ff );
 
	/* transformation enabled? */
	if (enable_pointing_coordinate_transform)
	{
		/* transform x,y to screen coords */
		MWPOINT transformed = {data_x, data_y};
		transformed = DeviceToScreen(transformed);
		/*
		 * HACK: move this from quarter pixels to whole
		 * pixels for now at least until I decide on the
		 * right interface to get the quarter-pixel data
		 * up to the next layer.
		 */
		*px = transformed.x >> 2;
		*py = transformed.y >> 2;
	}
	else
	{
		/* return untransformed coords (for calibration) */
		*px = data_x;
		*py = data_y;
	}
 
	*pz = 0;
	*pb = ( mou_data & (1<<31) )? MWBUTTON_L: 0;
 
	if ( ! *pb )
		return 3;
	else
		return 2;
}
#endif
 
MOUSEDEVICE mousedev = {
	PD_Open,
	PD_Close,
	PD_GetButtonInfo,
	PD_GetDefaultAccel,
	PD_Read,
	NULL
};
 
#ifdef TEST
int main()
{
	MWCOORD x, y, z;
	int	b;
	int result;
 
	enable_pointing_coordinate_transform = 1;
 
	DPRINTF("Opening touch panel...\n");
 
	if((result=PD_Open(0)) < 0)
		DPRINTF("Error %d, result %d opening touch-panel\n", errno, result);
 
	DPRINTF("Reading touch panel...\n");
 
	while(1) {
		result = PD_Read(&x, &y, &z, &b);
		if( result > 0) {
			/* DPRINTF("%d,%d,%d,%d,%d\n", result, x, y, z, b); */
		}
	}
}
#endif