src/video/fbcon/SDL_fbelo.c

   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 }