/*      $NetBSD: tp.c,v 1.9 2009/04/28 10:57:24 nonaka Exp $    */

/*-
 * Copyright (c) 2002, 2003 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 <string.h>
#include <sys/ioctl.h>
#include <sys/fcntl.h>
#include <sys/mman.h>
#include <errno.h>
#include <unistd.h>

#include "tpctl.h"

#define MIN(a, b)       ((a) < (b) ? (a) : (b))

#ifndef lint
#include <sys/cdefs.h>
__RCSID("$NetBSD: tp.c,v 1.9 2009/04/28 10:57:24 nonaka Exp $");
#endif /* not lint */

int
tp_init(struct tp *tp, int fd)
{
        u_int flags;
        struct wsmouse_calibcoords calibcoords;
        struct wsmouse_id id;
#ifdef WSMOUSEIO_SETVERSION
        int version = WSMOUSE_EVENT_VERSION;

        if (ioctl(fd, WSMOUSEIO_SETVERSION, &version) == -1) {
            return (-1);
        }
#endif

        tp->fd = fd;

#if 0
        if (ioctl(tp->fd, WSMOUSEIO_GTYPE, &type) < 0)
                return (-1);
        if (type != WSMOUSE_TYPE_TPANEL) {
                errno = EINVAL;
                return (-1);
        }
#else
        if (ioctl(tp->fd, WSMOUSEIO_GCALIBCOORDS, &calibcoords) < 0)
                return (-1);
#endif
        flags = fcntl(tp->fd, F_GETFL);
        if (flags == (u_int)-1)
                return (-1);
        flags |= O_NONBLOCK;
        if (fcntl(tp->fd, F_SETFL, flags) < 0)
                return (-1);

        id.type = WSMOUSE_ID_TYPE_UIDSTR;
        if (ioctl(tp->fd, WSMOUSEIO_GETID, &id) == 0) {
                (void)strlcpy(tp->id, (char *)id.data,
                              MIN(sizeof(tp->id), id.length));
        } else {
                tp->id[0] = '*';
                tp->id[1] = '\0';
        }

        return (0);
}

int
tp_setrawmode(struct tp *tp)
{
        struct wsmouse_calibcoords raw;

        memset(&raw, 0, sizeof(raw));
        raw.samplelen = WSMOUSE_CALIBCOORDS_RESET;

        return ioctl(tp->fd, WSMOUSEIO_SCALIBCOORDS, &raw);
}

int
tp_setcalibcoords(struct tp *tp, struct wsmouse_calibcoords *calibcoords)
{
        return ioctl(tp->fd, WSMOUSEIO_SCALIBCOORDS, calibcoords);
}

int
tp_flush(struct tp *tp)
{
        struct wscons_event ev;
        int count;

        count = 0;
        while (read(tp->fd, &ev, sizeof(ev)) == sizeof(ev)) {
                switch (ev.type) {
                case WSCONS_EVENT_MOUSE_UP:
                case WSCONS_EVENT_MOUSE_DOWN:
                case WSCONS_EVENT_MOUSE_DELTA_X:
                case WSCONS_EVENT_MOUSE_DELTA_Y:
                case WSCONS_EVENT_MOUSE_ABSOLUTE_X:
                case WSCONS_EVENT_MOUSE_ABSOLUTE_Y:
                case WSCONS_EVENT_MOUSE_DELTA_Z:
                case WSCONS_EVENT_MOUSE_ABSOLUTE_Z:
                        count++;
                        break;

                default:
                        break;
                }
        }

        return (count);
}

int
tp_get(struct tp *tp, int *x, int *y, int (*cancel)(void *), void *data)
{
        struct wscons_event ev;
        int x_done, y_done, res;

        x_done = y_done = 0;
        while (1) {
                if (cancel != NULL && (res = (*cancel)(data)) != 0)
                        return (res);
                if ((res = read(tp->fd, &ev, sizeof(ev))) < 0) {
                        if (errno != EWOULDBLOCK)
                                return (-1);
                        continue;
                }
                if (res != sizeof(ev)) {
                        errno = EINVAL;
                        return (-1);
                }
                switch (ev.type) {
                case WSCONS_EVENT_MOUSE_ABSOLUTE_X:
                        *x = ev.value;
                        if (y_done)
                                return (0);
                        x_done = 1;
                        break;

                case WSCONS_EVENT_MOUSE_ABSOLUTE_Y:
                        *y = ev.value;
                        if (x_done)
                                return (0);
                        y_done = 1;
                        break;

                default:
                        break;
                }
        }
}

int
tp_waitup(struct tp *tp, int msec, int (*cancel)(void*), void *data)
{
        int res;

        while (1) {
                if (cancel != NULL && (res = (*cancel)(data)) != 0)
                        return (res);
                usleep(msec * 1000);
                if (tp_flush(tp) == 0)
                        break;
        }

        return (0);
}