NetBSD/usr.sbin/tpctl/main.c

410 lines
9.8 KiB
C

/* $NetBSD: main.c,v 1.1 2002/08/27 14:12:17 takemura Exp $ */
/*-
* Copyright (c) 2002 TAKEMRUA Shin
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of The NetBSD Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <strings.h>
#include <stdlib.h>
#include <unistd.h>
#include <err.h>
#include <errno.h>
#include <time.h>
#include <termios.h>
#include <sys/fcntl.h>
#include <sys/mman.h>
#ifdef __STDC__
#include <stdarg.h>
#else
#include <varargs.h>
#endif
#include "tpctl.h"
#ifndef lint
#include <sys/cdefs.h>
__RCSID("$NetBSD: main.c,v 1.1 2002/08/27 14:12:17 takemura Exp $");
#endif /* not lint */
void load_data(char *data_file, struct tpctl_data *);
void save_data(char *data_file, struct tpctl_data *);
int do_calibration(char *, struct tp *, struct wsmouse_calibcoords *);
void drawcross(struct fb *, int, int, int, fb_pixel_t);
int check_esc(void *);
int opt_verbose;
int opt_noupdate;
int opt_forceupdate;
static void
usage(void)
{
fprintf(stderr, "usage: %s [-D dispdev] [-d dev] [-f file] [-hnuv]\n",
getprogname());
exit(EXIT_FAILURE);
/* NOTREACHED */
}
int
main(int argc, char *argv[])
{
int tpfd, ch;
struct tp tp;
struct wsmouse_calibcoords *pref;
struct tpctl_data data;
char *data_file;
char *dev_name;
char *dispdev_name;
/* set default values */
opt_verbose = 0;
opt_noupdate = 0;
opt_forceupdate = 0;
dev_name = TPCTL_TP_DEVICE;
dispdev_name = TPCTL_FB_DEVICE;
data_file = TPCTL_DB_FILENAME;
/* parse command line */
while ((ch = getopt(argc, argv, "d:D:f:hnuv")) != -1) {
switch (ch) {
case 'D':
dispdev_name = optarg;
break;
case 'd':
dev_name = optarg;
break;
case 'f':
data_file = optarg;
break;
case 'h':
usage();
/* NOTREACHED */
case 'n':
opt_noupdate = 1;
break;
case 'u':
opt_forceupdate = 1;
break;
case 'v':
opt_verbose = 1;
break;
default:
usage();
/* NOTREACHED */
}
}
if (argv[optind] != NULL) {
usage();
/* NOTREACHED */
}
/* load calibrarion parameters from specified file */
load_data(data_file, &data);
/* open touch panel device and initialize touch panel routines */
if ((tpfd = open(dev_name, O_RDWR)) < 0)
errx(EXIT_FAILURE, "can't open touch panel");
if (tp_init(&tp, tpfd) < 0)
errx(EXIT_FAILURE, "can't initialize touch panel");
/* find out saved parameters for the touch panel */
pref = search_data(&data, tp.id);
if (opt_forceupdate || pref == NULL) {
/* if the parameters wasn't found or '-f' options was
specified, do 'calibrarion' */
struct wsmouse_calibcoords coords;
/* draw cursors and collect samples */
if (do_calibration(dispdev_name, &tp, &coords) < 0) {
/* ESC key was pressed to abort */
exit(EXIT_FAILURE);
}
/* update parameters with new one */
replace_data(&data, tp.id, &coords);
pref = search_data(&data, tp.id);
} else {
/* nothing is updated,
so you don't have to write back the data */
opt_noupdate = 1;
}
if (opt_verbose)
write_coords(stdout, tp.id, pref);
/* set calibration parameters into touch panel device */
if (tp_setcalibcoords(&tp, pref) < 0)
errx(EXIT_FAILURE, "can't set samples");
/* save calibrarion parameters from specified file */
if (!opt_noupdate)
save_data(data_file, &data);
/* dispose data */
free_data(&data);
exit(EXIT_SUCCESS);
/* NOTREACHED */
}
/*
* load calibrarion parameters from specified file
*
* return: none (it won't return if some error occurs)
*/
void
load_data(char *data_file, struct tpctl_data *data)
{
int err;
init_data(data);
err = read_data(data_file, data);
switch (err) {
case ERR_NONE:
break;
case ERR_NOFILE:
fprintf(stderr, "%s: can't open %s\n", getprogname(),
data_file);
/* it might be OK... */
break;
case ERR_IO:
fprintf(stderr, "%s: I/O error on %s\n", getprogname(),
data_file);
exit(EXIT_FAILURE);
break;
case ERR_SYNTAX:
fprintf(stderr, "%s: format error at %s, line %d\n",
getprogname(), data_file, data->lineno);
exit(EXIT_FAILURE);
break;
case ERR_DUPNAME:
fprintf(stderr, "%s: duplicate entry at %s, line %d\n",
getprogname(), data_file, data->lineno);
exit(EXIT_FAILURE);
break;
default:
fprintf(stderr, "%s: internal error\n", getprogname());
exit(EXIT_FAILURE);
break;
}
}
/*
* save calibrarion parameters to specified file
*
* return: none (it won't return if some error occurs)
*/
void
save_data(char *data_file, struct tpctl_data *data)
{
int err;
err = write_data(data_file, data);
switch (err) {
case ERR_NONE:
break;
case ERR_NOFILE:
fprintf(stderr, "%s: can't open %s\n", getprogname(),
data_file);
exit(EXIT_FAILURE);
break;
case ERR_IO:
fprintf(stderr, "%s: I/O error on %s\n", getprogname(),
data_file);
exit(EXIT_FAILURE);
break;
default:
fprintf(stderr, "%s: internal error\n", getprogname());
exit(EXIT_FAILURE);
break;
}
}
/*
* draw cursors on frame buffer and collect samples in
* wamouse_calibcoords structure.
*
* return: 0 succeeded
* -1 aborted by user (ESC key was pressed)
* (it won't return if some error occurs)
*/
int
do_calibration(char *dev, struct tp *tp, struct wsmouse_calibcoords *coords)
{
int fbfd;
struct fb fb;
int i, x, y, xm, ym, cursize, err, res;
/* open frame buffer device and initialize frame buffer routine */
if ((fbfd = open(dev, O_RDWR)) < 0)
errx(EXIT_FAILURE, "can't open frame buffer");
if (fb_init(&fb, fbfd) < 0)
errx(EXIT_FAILURE, "can't map frame buffer");
memset(coords, 0, sizeof(*coords));
coords->minx = 0;
coords->miny = 0;
coords->maxx = fb.conf.hf_width - 1;
coords->maxy = fb.conf.hf_height - 1;
coords->samplelen = 5;
cursize = 20;
xm = fb.conf.hf_width/10;
ym = fb.conf.hf_height/10;
/* center */
coords->samples[0].x = fb.conf.hf_width/2;
coords->samples[0].y = fb.conf.hf_height/2;
/* top left */
coords->samples[1].x = xm;
coords->samples[1].y = ym;
/* bottom left */
coords->samples[2].x = xm;
coords->samples[2].y = fb.conf.hf_height - ym;
/* bottom right */
coords->samples[3].x = fb.conf.hf_width - xm;
coords->samples[3].y = fb.conf.hf_height - ym;
/* top right */
coords->samples[4].x = fb.conf.hf_width - xm;
coords->samples[4].y = ym;
tp_setrawmode(tp);
err = 0;
for (i = 0; i < coords->samplelen; i++) {
drawcross(&fb,
coords->samples[i].x,
coords->samples[i].y,
cursize, fb.white);
fb_flush(&fb);
tp_flush(tp);
res = tp_get(tp, &x, &y, check_esc, 0 /* stdin */);
if (res < 0) {
err = errno;
break;
}
if (0 < res) {
fb_dispmode(&fb, WSDISPLAYIO_MODE_EMUL);
return (-1); /* aborted by user */
}
coords->samples[i].rawx = x;
coords->samples[i].rawy = y;
drawcross(&fb,
coords->samples[i].x,
coords->samples[i].y,
cursize, fb.black);
fb_flush(&fb);
tp_waitup(tp, 200, check_esc, 0 /* stdin */);
}
fb_dispmode(&fb, WSDISPLAYIO_MODE_EMUL);
close(fbfd);
if (opt_verbose) {
printf("%s: %dx%d (%dbytes/line) %dbit offset=0x%lx\n",
getprogname(),
fb.conf.hf_width,
fb.conf.hf_height,
fb.conf.hf_bytes_per_line,
fb.conf.hf_pixel_width,
fb.conf.hf_offset);
}
if (err) {
errno = err;
errx(EXIT_FAILURE, "can't get samples");
}
return (0);
}
/*
* draw corss cursor on frame buffer
*
* return: none
*/
void
drawcross(struct fb *fb, int x, int y, int size, fb_pixel_t pixel)
{
size /= 2;
fb_drawline(fb, x, y - size + 1, x, y - 1, pixel);
fb_drawline(fb, x + 1, y - size + 1, x + 1, y - 1, pixel);
fb_drawline(fb, x, y + 2, x, y + size, pixel);
fb_drawline(fb, x + 1, y + 2, x + 1, y + size, pixel);
fb_drawline(fb, x - size + 1, y, x - 1, y, pixel);
fb_drawline(fb, x - size + 1, y + 1, x - 1, y + 1, pixel);
fb_drawline(fb, x + 2, y, x + size, y, pixel);
fb_drawline(fb, x + 2, y + 1, x + size, y + 1, pixel);
}
/*
* check ESC key
*
* date: input file descriptor
*
* return: 0 nothing has been occured
* 1 ESC key was pressed
* -1 error
*/
int
check_esc(void *data)
{
int fd = (int)data;
int flg, n, err;
char buf[1];
struct termios tm, raw;
if (tcgetattr(fd, &tm) < 0)
return (-1);
raw = tm;
cfmakeraw(&raw);
if (tcsetattr(fd, TCSANOW, &raw) < 0)
return (-1);
if ((flg = fcntl(fd, F_GETFL)) == -1)
return (-1);
if (fcntl(fd, F_SETFL, flg | O_NONBLOCK) == -1)
return (-1);
n = read(fd, buf, 1);
err = errno;
fcntl(fd, F_SETFL, flg);
tcsetattr(fd, TCSANOW, &tm);
if (n < 0)
return (err == EWOULDBLOCK ? 0 : -1);
if (n == 0)
return (0); /* EOF */
if (*buf == 0x1b)
return (1); /* ESC */
return (0);
}