Home | History | Annotate | Download | only in fbcon
      1 /*
      2     SDL - Simple DirectMedia Layer
      3     Copyright (C) 1997-2006 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 (at) 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 }
    443