Subversion Repositories openrisc_me

/* Dynapro SC3 touchscreen driver

   Written by Jordan Crouse, September 5, 2001

   Copyright 2001, Century Embedded Technologies

*/

/* TODO:

   Add support for rotated displays

*/

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <errno.h>

#include <fcntl.h>

#include <math.h>

#include <sys/ioctl.h>

#include <sys/termios.h>

#include "device.h"

/* The current and saved termios */

static struct termios ios_saved, ios_current;

/* The file descriptor for the mouse device */

static int mouFd = 0;

/* The calibration data */

/* We plug in some generic default data here, so if */

/* all else fails, the pointer should still work    */

unsigned short calData[4] = { 73, 956, 883, 167 };

/* Flags to indicate if we should invert the values on the X and Y axis */

/* This does not mean rotation, just a backwards TS                     */

static int invX = 0, invY = 0;

extern SCREENDEVICE scrdev;

static int initSerial(char *dev) {

  /* Open up the serial port */

  int fd = open(dev, O_NONBLOCK);

  if (fd <= 0) {

    EPRINTF("Error opening %s\n", dev);

    return(-1);

  }

  /* Save the previous IO settings */

  tcgetattr(fd, &ios_saved);

  ios_current = ios_saved;

  cfmakeraw(&ios_current);

  /* Set the baud rate */

  cfsetispeed(&ios_current, B2400);

  cfsetospeed(&ios_current, B2400);

  /* Set the data bits and remove the parity */

  ios_current.c_cflag &= ~(CSIZE | PARENB);

  ios_current.c_cflag |= CS8;

  ios_current.c_cc[VMIN] = 3;

  ios_current.c_cc[VTIME] = 1;

  tcsetattr(fd, TCSANOW, &ios_current);

  tcflush(fd, TCIOFLUSH);

  return(fd);

}

static void closeSerial(int fd) {

  /* Restore the saved settings */

  tcsetattr(fd, TCSANOW, &ios_saved);

  tcflush(fd, TCIOFLUSH);

  close(fd);

}

/* Read a byte from the fd */

static int readSerial(int fd) {

  unsigned char f;

  int val = read(fd, &f, sizeof(f));

  if (val <= 0) return(val);

  return((int) f);

}

/* Get some data points from the device */

static int getInput(int fd, int *data) {

  int count = 0;

  int state = 0;

  /* Read the data coming in off the line */

  while(1) {

    int c;

    c = readSerial(fd);

    if (c < 0) {

      if (errno == EAGAIN || errno == EINTR) return(0);

      else return(-1);

    }

    if (count++ > 150) return(0);

    switch(state) {

    case 0:

      if (c & 0x80) {

        data[0] = (unsigned char) c;

        state = 1;

      }

      /* This is a useless warning */

#ifdef NOTUSED

      else

        fprintf(stderr, "Non start byte recieved (%2.2x)\n", c);

#endif

      break;

    case 1:

      if (!(c & 0x80)) {

        data[1] = (unsigned char) c;

        state = 2;

      }

      else {

#ifdef NOTUSED

        fprintf(stderr, "Got a start byte in the middle of the packet\n");

#endif

        data[0] = (unsigned char) c;

        state = 0;

      }

      break;

    case 2:

      if (!(c & 0x80)) {

        data[2] = (unsigned char) c;

        return(1);

      }

      else {

#ifdef NOTUSED

        fprintf(stderr, "Got a start byte in the middle of the packet\n");

#endif

        data[0] = (unsigned char) c;

        state = 0;

      }

      break;

    }

  }

  return(1);

}

/* Read calibration from a file */

static int readCalibration(char *filename) {

  char buffer[128];

  int calfd = open(filename, O_RDONLY);

  /* If the file doesn't exist, then just use the default values */

  if (calfd < 0)  return(0);

  /* The data will be formated as 4 values:

     xmin xmax ymin ymax

  */

  if (read(calfd, buffer, sizeof(buffer)) <= 0) {

    close(calfd);

    return(0);

  }

  sscanf(buffer, "%d %d %d %d\n", &calData[0], &calData[1], &calData[2], &calData[3]);

  close(calfd);

  /* Check the calibration values, and reverse them if we have to */

  if (calData[1] < calData[0]) {

    int  tmp = calData[1];

    calData[1] = calData[0];

    calData[0] = tmp;

    invX = 1;

  }

  if (calData[3] < calData[2]) {

    int tmp = calData[3];

    calData[3] = calData[2];

    calData[2] = tmp;

    invY = 1;

  }

  return(0);

}

static void doScale(int x, int y, int *dx, int *dy) {

  /* Scale the data appropriately to the screen */

  *dx = ((x - calData[0]) * scrdev.xres) / (calData[1] - calData[0]);

  *dy = ((y - calData[2]) * scrdev.yres) / (calData[3] - calData[2]);

}

static int MOU_Open(MOUSEDEVICE *pmd) {

  int calfd;

  mouFd = initSerial("/dev/ttyS1");

  if (mouFd == -1) {

    EPRINTF("Unable to open /dev/ttyS1 for reading\n");

    return(-1);

  }

  if (readCalibration("/etc/caldata") == -1) {

    closeSerial(mouFd);

    EPRINTF("Unable to get the calibration data\n");

    return(-1);

  }

  /* success */

  GdHideCursor(&scrdev);

  return(mouFd);

}

static int MOU_GetButtonInfo(void) {

  return(MWBUTTON_L);

}

static void MOU_GetDefaultAccel(int *pscale, int *pthresh) {

  *pscale = 3;

  *pthresh = 5;

}

static void MOU_Close(void) {

  if (mouFd >= 0)

    closeSerial(mouFd);

  mouFd = -1;

}

static int MOU_Read(MWCOORD *px, MWCOORD *py, MWCOORD *pz, int *pb) {

  int i;

  int totalx = 0, totaly = 0;

  int data[4];

  /* For now, only grab one reading, this touchscreen is pretty */

  /* good, so jitter isn't a problem                            */

  for(i = 0; i < 1; i++) {

    int x, y, sx, sy;

    int val;

    val = getInput(mouFd, data);

    if (val == -1) return(0);

    else if (val == 0) break;

    x = data[1] | ((data[0] & 0x38) << 4);

    y = data[2] | ((data[0] & 0x07) << 7);

    /* Send the data in for calibration */

    doScale(x, y, &sx, &sy);

    /* Inver the axii if needed */

    if (invX)

      sx = scrdev.xres - sx;

    if (invY)

      sy = scrdev.yres - sy;

    totalx += sx;

    totaly += sy;

  }

  if (i == 0) return(0);

  *px = totalx / (i);

  *py = totaly / (i);

  /* Record the last state of the mouse */

  *pb = ( (data[0] & 0x40) ? MWBUTTON_L : 0 );

  *pz = 0;

  if (!*pb) return(3); else return(2);

}

MOUSEDEVICE mousedev = {

  MOU_Open,

  MOU_Close,

  MOU_GetButtonInfo,

  MOU_GetDefaultAccel,

  MOU_Read,

  NULL

};