[sdl_omap.git] / src / video / fbcon / SDL_fbelo.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 Sam Lantinga

    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

    Sam Lantinga
    slouken@libsdl.org
*/
#include "SDL_config.h"

#include <unistd.h>
#include <sys/time.h>
#include <ctype.h>

#include "SDL_stdinc.h"
#include "SDL_fbvideo.h"
#include "SDL_fbelo.h"

/*
	calibration default values
	values are read from the following environment variables:

	SDL_ELO_MIN_X
	SDL_ELO_MAX_X
	SDL_ELO_MIN_Y
	SDL_ELO_MAX_Y
*/

static int ELO_MIN_X = 400;
static int ELO_MAX_X = 3670;
static int ELO_MIN_Y = 500;
static int ELO_MAX_Y = 3540;

#define ELO_SNAP_SIZE 6
#define ELO_TOUCH_BYTE		'T'	
#define ELO_ID			'I'
#define ELO_MODE		'M'
#define ELO_PARAMETER		'P'
#define ELO_REPORT		'B'
#define ELO_ACK			'A'	

#define ELO_INIT_CHECKSUM	0xAA

#define ELO_BTN_PRESS		0x01	
#define ELO_STREAM		0x02
#define ELO_BTN_RELEASE		0x04

#define ELO_TOUCH_MODE		0x01
#define ELO_STREAM_MODE		0x02
#define ELO_UNTOUCH_MODE	0x04
#define ELO_RANGE_CHECK_MODE	0x40
#define ELO_TRIM_MODE		0x02
#define ELO_CALIB_MODE		0x04
#define ELO_SCALING_MODE	0x08
#define ELO_TRACKING_MODE	0x40

#define ELO_SERIAL_MASK		0xF8

#define ELO_SERIAL_IO		'0'

#define ELO_MAX_TRIALS	3
#define ELO_MAX_WAIT		100000
#define ELO_UNTOUCH_DELAY	5
#define ELO_REPORT_DELAY	1

/*	eloParsePacket
*/
int eloParsePacket(unsigned char* mousebuf, int* dx, int* dy, int* button_state) {
	static int elo_button = 0;
	static int last_x = 0;
	static int last_y = 0;
	int x,y;

	/* Check if we have a touch packet */
	if (mousebuf[1] != ELO_TOUCH_BYTE) {
		return 0;
	}

	x = ((mousebuf[4] << 8) | mousebuf[3]);
	y = ((mousebuf[6] << 8) | mousebuf[5]);

	if((SDL_abs(x - last_x) > ELO_SNAP_SIZE) || (SDL_abs(y - last_y) > ELO_SNAP_SIZE)) {
		*dx = ((mousebuf[4] << 8) | mousebuf[3]);
		*dy = ((mousebuf[6] << 8) | mousebuf[5]);
	}
	else {
		*dx = last_x;
		*dy = last_y;
	}

	last_x = *dx;
	last_y = *dy;

	if ( (mousebuf[2] & 0x07) == ELO_BTN_PRESS ) {
		elo_button = 1;
	}
	if ( (mousebuf[2] & 0x07) == ELO_BTN_RELEASE ) {
		elo_button = 0;
	}

	*button_state = elo_button;
	return 1;
}

/*	Convert the raw coordinates from the ELO controller
	to a screen position.
*/
void eloConvertXY(_THIS, int *dx,  int *dy) {
	int input_x = *dx;
	int input_y = *dy;
	int width = ELO_MAX_X - ELO_MIN_X;
	int height = ELO_MAX_Y - ELO_MIN_Y;

	*dx = ((int)cache_vinfo.xres - ((int)cache_vinfo.xres * (input_x - ELO_MIN_X)) / width);
	*dy = (cache_vinfo.yres * (input_y - ELO_MIN_Y)) / height;
}


/*	eloGetPacket
*/
int eloGetPacket(unsigned char* buffer, int* buffer_p, int* checksum, int fd) {
	int num_bytes;
	int ok;

	if(fd == 0) {
		num_bytes = ELO_PACKET_SIZE;
	}
	else {
		num_bytes = read(fd,
			(char *) (buffer + *buffer_p),
			ELO_PACKET_SIZE - *buffer_p);
	}

	if (num_bytes < 0) {
#ifdef DEBUG_MOUSE
		fprintf(stderr, "System error while reading from Elographics touchscreen.\n");
#endif
		return 0;
	}

	while (num_bytes) {
		if ((*buffer_p == 0) && (buffer[0] != ELO_START_BYTE)) {
			SDL_memcpy(&buffer[0], &buffer[1], num_bytes-1);
		}
		else {
			if (*buffer_p < ELO_PACKET_SIZE-1) {
				*checksum = *checksum + buffer[*buffer_p];
				*checksum = *checksum % 256;
			}
			(*buffer_p)++;
		}
		num_bytes--;
	}

	if (*buffer_p == ELO_PACKET_SIZE) {
		ok = (*checksum == buffer[ELO_PACKET_SIZE-1]);
		*checksum = ELO_INIT_CHECKSUM;
		*buffer_p = 0;

		if (!ok) {
			return 0;
		}

		return 1;
	}
	else {
		return 0;
	}
}

/* eloSendPacket
*/

int eloSendPacket(unsigned char* packet, int fd)
{
	int i, result;
	int sum = ELO_INIT_CHECKSUM;

	packet[0] = ELO_START_BYTE;
	for (i = 0; i < ELO_PACKET_SIZE-1; i++) {
		sum += packet[i];
		sum &= 0xFF;
	}
	packet[ELO_PACKET_SIZE-1] = sum;

	result = write(fd, packet, ELO_PACKET_SIZE);

	if (result != ELO_PACKET_SIZE) {
#ifdef DEBUG_MOUSE
		printf("System error while sending to Elographics touchscreen.\n");
#endif
		return 0;
	}
	else {
		return 1;
	}
}


/*	eloWaitForInput
 */
int eloWaitForInput(int fd, int timeout)
{
	fd_set readfds;
	struct timeval to;
	int r;

	FD_ZERO(&readfds);
	FD_SET(fd, &readfds);
	to.tv_sec = 0;
	to.tv_usec = timeout;

	r = select(FD_SETSIZE, &readfds, NULL, NULL, &to);
	return r;
}

/*	eloWaitReply
 */
int eloWaitReply(unsigned char type, unsigned char *reply, int fd) {
	int ok;
	int i, result;
	int reply_p = 0;
	int sum = ELO_INIT_CHECKSUM;

	i = ELO_MAX_TRIALS;
	do {
		ok = 0;

		result = eloWaitForInput(fd, ELO_MAX_WAIT);

		if (result > 0) {
			ok = eloGetPacket(reply, &reply_p, &sum, fd);

			if (ok && reply[1] != type && type != ELO_PARAMETER) {
#ifdef DEBUG_MOUSE
				fprintf(stderr, "Wrong reply received\n");
#endif
				ok = 0;
			}
		}
		else {
#ifdef DEBUG_MOUSE
			fprintf(stderr, "No input!\n");
#endif
		}

		if (result == 0) {
			i--;
		}
	} while(!ok && (i>0));

	return ok;
}


/*	eloWaitAck
 */

int eloWaitAck(int fd) {
	unsigned char packet[ELO_PACKET_SIZE];
	int i, nb_errors;

	if (eloWaitReply(ELO_ACK, packet, fd)) {
		for (i = 0, nb_errors = 0; i < 4; i++) {
			if (packet[2 + i] != '0') {
				nb_errors++;
			}
		}

		if (nb_errors != 0) {
#ifdef DEBUG_MOUSE
			fprintf(stderr, "Elographics acknowledge packet reports %d errors\n", nb_errors);
#endif
		}
		return 1;
	}
	else {
		return 0;
	}
}


/*	eloSendQuery --
*/
int eloSendQuery(unsigned char *request, unsigned char* reply, int fd) {
	int ok;

	if (eloSendPacket(request, fd)) {
		ok = eloWaitReply(toupper(request[1]), reply, fd);
		if (ok) {
			ok = eloWaitAck(fd);
		}
		return ok;
	}
	else {
		return 0;
	}
}


/*	eloSendControl
*/
int eloSendControl(unsigned char* control, int fd) {
	if (eloSendPacket(control, fd)) {
		return eloWaitAck(fd);
	}
	else {
		return 0;
	}
}

/*	eloInitController
*/
int eloInitController(int fd) {
	unsigned char req[ELO_PACKET_SIZE];
	unsigned char reply[ELO_PACKET_SIZE];
	const char *buffer = NULL;
	int result = 0;

	struct termios mouse_termios;

	/* try to read the calibration values */
	buffer = SDL_getenv("SDL_ELO_MIN_X");
	if(buffer) {
		ELO_MIN_X = SDL_atoi(buffer);
	}
	buffer = SDL_getenv("SDL_ELO_MAX_X");
	if(buffer) {
		ELO_MAX_X = SDL_atoi(buffer);
	}
	buffer = SDL_getenv("SDL_ELO_MIN_Y");
	if(buffer) {
		ELO_MIN_Y = SDL_atoi(buffer);
	}
	buffer = SDL_getenv("SDL_ELO_MAX_Y");
	if(buffer) {
		ELO_MAX_Y = SDL_atoi(buffer);
	}

#ifdef DEBUG_MOUSE
	fprintf( stderr, "ELO calibration values:\nmin_x: %i\nmax_x: %i\nmin_y: %i\nmax_y: %i\n",
		ELO_MIN_X,
		ELO_MAX_X,
		ELO_MIN_Y,
		ELO_MAX_Y);
#endif

	/* set comm params */
	SDL_memset(&mouse_termios, 0, sizeof(mouse_termios));
	mouse_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
	mouse_termios.c_cc[VMIN] = 1;
	result = tcsetattr(fd, TCSANOW, &mouse_termios);

	if (result < 0) {
#ifdef DEBUG_MOUSE
		fprintf( stderr, "Unable to configure Elographics touchscreen port\n");
#endif
		return 0;
	}

	SDL_memset(req, 0, ELO_PACKET_SIZE);
	req[1] = tolower(ELO_PARAMETER);
	if (!eloSendQuery(req, reply, fd)) {
#ifdef DEBUG_MOUSE
		fprintf( stderr, "Not at the specified rate or model 2310, will continue\n");
#endif
	}

	SDL_memset(req, 0, ELO_PACKET_SIZE);
	req[1] = tolower(ELO_ID);
	if (eloSendQuery(req, reply, fd)) {
#ifdef DEBUG_MOUSE
		fprintf(stderr, "Ok, controller configured!\n");
#endif
	}
	else {
#ifdef DEBUG_MOUSE
		fprintf( stderr, "Unable to ask Elographics touchscreen identification\n");
#endif
		return 0;
	}

	SDL_memset(req, 0, ELO_PACKET_SIZE);
	req[1] = ELO_MODE;
	req[3] = ELO_TOUCH_MODE | ELO_STREAM_MODE | ELO_UNTOUCH_MODE;
	req[4] = ELO_TRACKING_MODE;
	if (!eloSendControl(req, fd)) {
#ifdef DEBUG_MOUSE
		fprintf( stderr, "Unable to change Elographics touchscreen operating mode\n");
#endif
		return 0;
	}

	SDL_memset(req, 0, ELO_PACKET_SIZE);
	req[1] = ELO_REPORT;
	req[2] = ELO_UNTOUCH_DELAY;
	req[3] = ELO_REPORT_DELAY;
	if (!eloSendControl(req, fd)) {
#ifdef DEBUG_MOUSE
		fprintf( stderr, "Unable to change Elographics touchscreen reports timings\n");
#endif
		return 0;
	}

	return 1;
}

int eloReadPosition(_THIS, int fd, int* x, int* y, int* button_state, int* realx, int* realy) {
        unsigned char buffer[ELO_PACKET_SIZE];
        int pointer = 0;
        int checksum = ELO_INIT_CHECKSUM;

        while(pointer < ELO_PACKET_SIZE) {
                if(eloGetPacket(buffer, &pointer, &checksum, fd)) {
                        break;
                }
        }

        if(!eloParsePacket(buffer, realx, realy, button_state)) {
                return 0;
        }

        *x = *realx;
        *y = *realy;

        eloConvertXY(this, x, y);
	
	return 1;
}
Commit	Line	Data
e14743d1	1	/*
	2	SDL - Simple DirectMedia Layer
	3	Copyright (C) 1997-2009 Sam Lantinga
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	This library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with this library; if not, write to the Free Software
	17	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18
	19	Sam Lantinga
	20	slouken@libsdl.org
	21	*/
	22	#include "SDL_config.h"
	23
	24	#include <unistd.h>
	25	#include <sys/time.h>
	26	#include <ctype.h>
	27
	28	#include "SDL_stdinc.h"
	29	#include "SDL_fbvideo.h"
	30	#include "SDL_fbelo.h"
	31
	32	/*
	33	calibration default values
	34	values are read from the following environment variables:
	35
	36	SDL_ELO_MIN_X
	37	SDL_ELO_MAX_X
	38	SDL_ELO_MIN_Y
	39	SDL_ELO_MAX_Y
	40	*/
	41
	42	static int ELO_MIN_X = 400;
	43	static int ELO_MAX_X = 3670;
	44	static int ELO_MIN_Y = 500;
	45	static int ELO_MAX_Y = 3540;
	46
	47	#define ELO_SNAP_SIZE 6
	48	#define ELO_TOUCH_BYTE 'T'
	49	#define ELO_ID 'I'
	50	#define ELO_MODE 'M'
	51	#define ELO_PARAMETER 'P'
	52	#define ELO_REPORT 'B'
	53	#define ELO_ACK 'A'
	54
	55	#define ELO_INIT_CHECKSUM 0xAA
	56
	57	#define ELO_BTN_PRESS 0x01
	58	#define ELO_STREAM 0x02
	59	#define ELO_BTN_RELEASE 0x04
	60
	61	#define ELO_TOUCH_MODE 0x01
	62	#define ELO_STREAM_MODE 0x02
	63	#define ELO_UNTOUCH_MODE 0x04
	64	#define ELO_RANGE_CHECK_MODE 0x40
65	#define ELO_TRIM_MODE 0x02
66	#define ELO_CALIB_MODE 0x04
67	#define ELO_SCALING_MODE 0x08
68	#define ELO_TRACKING_MODE 0x40
69
70	#define ELO_SERIAL_MASK 0xF8
71
72	#define ELO_SERIAL_IO '0'
73
74	#define ELO_MAX_TRIALS 3
75	#define ELO_MAX_WAIT 100000
76	#define ELO_UNTOUCH_DELAY 5
77	#define ELO_REPORT_DELAY 1
78
79	/* eloParsePacket
80	*/
81	int eloParsePacket(unsigned char* mousebuf, int* dx, int* dy, int* button_state) {
82	static int elo_button = 0;
83	static int last_x = 0;
84	static int last_y = 0;
85	int x,y;
86
87	/* Check if we have a touch packet */
88	if (mousebuf[1] != ELO_TOUCH_BYTE) {
89	return 0;
90	}
91
92	x = ((mousebuf[4] << 8) \| mousebuf[3]);
93	y = ((mousebuf[6] << 8) \| mousebuf[5]);
94
95	if((SDL_abs(x - last_x) > ELO_SNAP_SIZE) \|\| (SDL_abs(y - last_y) > ELO_SNAP_SIZE)) {
96	*dx = ((mousebuf[4] << 8) \| mousebuf[3]);
97	*dy = ((mousebuf[6] << 8) \| mousebuf[5]);
98	}
99	else {
100	*dx = last_x;
101	*dy = last_y;
102	}
103
104	last_x = *dx;
105	last_y = *dy;
106
107	if ( (mousebuf[2] & 0x07) == ELO_BTN_PRESS ) {
108	elo_button = 1;
109	}
110	if ( (mousebuf[2] & 0x07) == ELO_BTN_RELEASE ) {
111	elo_button = 0;
112	}
113
114	*button_state = elo_button;
115	return 1;
116	}
117
118	/* Convert the raw coordinates from the ELO controller
119	to a screen position.
120	*/
121	void eloConvertXY(_THIS, int dx, int dy) {
122	int input_x = *dx;
123	int input_y = *dy;
124	int width = ELO_MAX_X - ELO_MIN_X;
125	int height = ELO_MAX_Y - ELO_MIN_Y;
126
127	dx = ((int)cache_vinfo.xres - ((int)cache_vinfo.xres (input_x - ELO_MIN_X)) / width);
128	dy = (cache_vinfo.yres (input_y - ELO_MIN_Y)) / height;
129	}
130
131
132	/* eloGetPacket
133	*/
134	int eloGetPacket(unsigned char* buffer, int* buffer_p, int* checksum, int fd) {
135	int num_bytes;
136	int ok;
137
138	if(fd == 0) {
139	num_bytes = ELO_PACKET_SIZE;
140	}
141	else {
142	num_bytes = read(fd,
143	(char ) (buffer + buffer_p),
144	ELO_PACKET_SIZE - *buffer_p);
145	}
146
147	if (num_bytes < 0) {
148	#ifdef DEBUG_MOUSE
149	fprintf(stderr, "System error while reading from Elographics touchscreen.\n");
150	#endif
151	return 0;
152	}
153
154	while (num_bytes) {
155	if ((*buffer_p == 0) && (buffer[0] != ELO_START_BYTE)) {
156	SDL_memcpy(&buffer[0], &buffer[1], num_bytes-1);
157	}
158	else {
159	if (*buffer_p < ELO_PACKET_SIZE-1) {
160	checksum = checksum + buffer[*buffer_p];
161	checksum = checksum % 256;
162	}
163	(*buffer_p)++;
164	}
165	num_bytes--;
166	}
167
168	if (*buffer_p == ELO_PACKET_SIZE) {
169	ok = (*checksum == buffer[ELO_PACKET_SIZE-1]);
170	*checksum = ELO_INIT_CHECKSUM;
171	*buffer_p = 0;
172
173	if (!ok) {
174	return 0;
175	}
176
177	return 1;
178	}
179	else {
180	return 0;
181	}
182	}
183
184	/* eloSendPacket
185	*/
186
187	int eloSendPacket(unsigned char* packet, int fd)
188	{
189	int i, result;
190	int sum = ELO_INIT_CHECKSUM;
191
192	packet[0] = ELO_START_BYTE;
193	for (i = 0; i < ELO_PACKET_SIZE-1; i++) {
194	sum += packet[i];
195	sum &= 0xFF;
196	}
197	packet[ELO_PACKET_SIZE-1] = sum;
198
199	result = write(fd, packet, ELO_PACKET_SIZE);
200
201	if (result != ELO_PACKET_SIZE) {
202	#ifdef DEBUG_MOUSE
203	printf("System error while sending to Elographics touchscreen.\n");
204	#endif
205	return 0;
206	}
207	else {
208	return 1;
209	}
210	}
211
212
213	/* eloWaitForInput
214	*/
215	int eloWaitForInput(int fd, int timeout)
216	{
217	fd_set readfds;
218	struct timeval to;
219	int r;
220
221	FD_ZERO(&readfds);
222	FD_SET(fd, &readfds);
223	to.tv_sec = 0;
224	to.tv_usec = timeout;
225
226	r = select(FD_SETSIZE, &readfds, NULL, NULL, &to);
227	return r;
228	}
229
230	/* eloWaitReply
231	*/
232	int eloWaitReply(unsigned char type, unsigned char *reply, int fd) {
233	int ok;
234	int i, result;
235	int reply_p = 0;
236	int sum = ELO_INIT_CHECKSUM;
237
238	i = ELO_MAX_TRIALS;
239	do {
240	ok = 0;
241
242	result = eloWaitForInput(fd, ELO_MAX_WAIT);
243
244	if (result > 0) {
245	ok = eloGetPacket(reply, &reply_p, &sum, fd);
246
247	if (ok && reply[1] != type && type != ELO_PARAMETER) {
248	#ifdef DEBUG_MOUSE
249	fprintf(stderr, "Wrong reply received\n");
250	#endif
251	ok = 0;
252	}
253	}
254	else {
255	#ifdef DEBUG_MOUSE
256	fprintf(stderr, "No input!\n");
257	#endif
258	}
259
260	if (result == 0) {
261	i--;
262	}
263	} while(!ok && (i>0));
264
265	return ok;
266	}
267
268
269	/* eloWaitAck
270	*/
271
272	int eloWaitAck(int fd) {
273	unsigned char packet[ELO_PACKET_SIZE];
274	int i, nb_errors;
275
276	if (eloWaitReply(ELO_ACK, packet, fd)) {
277	for (i = 0, nb_errors = 0; i < 4; i++) {
278	if (packet[2 + i] != '0') {
279	nb_errors++;
280	}
281	}
282
283	if (nb_errors != 0) {
284	#ifdef DEBUG_MOUSE
285	fprintf(stderr, "Elographics acknowledge packet reports %d errors\n", nb_errors);
286	#endif
287	}
288	return 1;
289	}
290	else {
291	return 0;
292	}
293	}
294
295
296	/* eloSendQuery --
297	*/
298	int eloSendQuery(unsigned char request, unsigned char reply, int fd) {
299	int ok;
300
301	if (eloSendPacket(request, fd)) {
302	ok = eloWaitReply(toupper(request[1]), reply, fd);
303	if (ok) {
304	ok = eloWaitAck(fd);
305	}
306	return ok;
307	}
308	else {
309	return 0;
310	}
311	}
312
313
314	/* eloSendControl
315	*/
316	int eloSendControl(unsigned char* control, int fd) {
317	if (eloSendPacket(control, fd)) {
318	return eloWaitAck(fd);
319	}
320	else {
321	return 0;
322	}
323	}
324
325	/* eloInitController
326	*/
327	int eloInitController(int fd) {
328	unsigned char req[ELO_PACKET_SIZE];
329	unsigned char reply[ELO_PACKET_SIZE];
330	const char *buffer = NULL;
331	int result = 0;
332
333	struct termios mouse_termios;
334
335	/* try to read the calibration values */
336	buffer = SDL_getenv("SDL_ELO_MIN_X");
337	if(buffer) {
338	ELO_MIN_X = SDL_atoi(buffer);
339	}
340	buffer = SDL_getenv("SDL_ELO_MAX_X");
341	if(buffer) {
342	ELO_MAX_X = SDL_atoi(buffer);
343	}
344	buffer = SDL_getenv("SDL_ELO_MIN_Y");
345	if(buffer) {
346	ELO_MIN_Y = SDL_atoi(buffer);
347	}
348	buffer = SDL_getenv("SDL_ELO_MAX_Y");
349	if(buffer) {
350	ELO_MAX_Y = SDL_atoi(buffer);
351	}
352
353	#ifdef DEBUG_MOUSE
354	fprintf( stderr, "ELO calibration values:\nmin_x: %i\nmax_x: %i\nmin_y: %i\nmax_y: %i\n",
355	ELO_MIN_X,
356	ELO_MAX_X,
357	ELO_MIN_Y,
358	ELO_MAX_Y);
359	#endif
360
361	/* set comm params */
362	SDL_memset(&mouse_termios, 0, sizeof(mouse_termios));
363	mouse_termios.c_cflag = B9600 \| CS8 \| CREAD \| CLOCAL;
364	mouse_termios.c_cc[VMIN] = 1;
365	result = tcsetattr(fd, TCSANOW, &mouse_termios);
366
367	if (result < 0) {
368	#ifdef DEBUG_MOUSE
369	fprintf( stderr, "Unable to configure Elographics touchscreen port\n");
370	#endif
371	return 0;
372	}
373
374	SDL_memset(req, 0, ELO_PACKET_SIZE);
375	req[1] = tolower(ELO_PARAMETER);
376	if (!eloSendQuery(req, reply, fd)) {
377	#ifdef DEBUG_MOUSE
378	fprintf( stderr, "Not at the specified rate or model 2310, will continue\n");
379	#endif
380	}
381
382	SDL_memset(req, 0, ELO_PACKET_SIZE);
383	req[1] = tolower(ELO_ID);
384	if (eloSendQuery(req, reply, fd)) {
385	#ifdef DEBUG_MOUSE
386	fprintf(stderr, "Ok, controller configured!\n");
387	#endif
388	}
389	else {
390	#ifdef DEBUG_MOUSE
391	fprintf( stderr, "Unable to ask Elographics touchscreen identification\n");
392	#endif
393	return 0;
394	}
395
396	SDL_memset(req, 0, ELO_PACKET_SIZE);
397	req[1] = ELO_MODE;
398	req[3] = ELO_TOUCH_MODE \| ELO_STREAM_MODE \| ELO_UNTOUCH_MODE;
399	req[4] = ELO_TRACKING_MODE;
400	if (!eloSendControl(req, fd)) {
401	#ifdef DEBUG_MOUSE
402	fprintf( stderr, "Unable to change Elographics touchscreen operating mode\n");
403	#endif
404	return 0;
405	}
406
407	SDL_memset(req, 0, ELO_PACKET_SIZE);
408	req[1] = ELO_REPORT;
409	req[2] = ELO_UNTOUCH_DELAY;
410	req[3] = ELO_REPORT_DELAY;
411	if (!eloSendControl(req, fd)) {
412	#ifdef DEBUG_MOUSE
413	fprintf( stderr, "Unable to change Elographics touchscreen reports timings\n");
414	#endif
415	return 0;
416	}
417
418	return 1;
419	}
420
421	int eloReadPosition(_THIS, int fd, int* x, int* y, int* button_state, int* realx, int* realy) {
422	unsigned char buffer[ELO_PACKET_SIZE];
423	int pointer = 0;
424	int checksum = ELO_INIT_CHECKSUM;
425
426	while(pointer < ELO_PACKET_SIZE) {
427	if(eloGetPacket(buffer, &pointer, &checksum, fd)) {
428	break;
429	}
430	}
431
432	if(!eloParsePacket(buffer, realx, realy, button_state)) {
433	return 0;
434	}
435
436	x = realx;
437	y = realy;
438
439	eloConvertXY(this, x, y);
440
441	return 1;
442	}