/*
 * Copyright (c) 2014 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Matthew Dillon <dillon@backplane.com>
 *
 * 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 DragonFly Project 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 COPYRIGHT HOLDERS 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
 * COPYRIGHT HOLDERS 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.
 */
/*
 * ATMEL_MXT - Atmel MXT touchscreen driver
 *
 *      PRELIMINARY DRIVER PRELIMINARY DRIVER PRELIMINARY DRIVERE
 *
 * (everything is pretty much hardwired and we assume the device is already
 *  operational, which it appears to be.  ONLY TESTED ON ACER C720).
 *
 * This driver attaches to Acer TouchScreen MXT chipsets and currently
 * emulates the ELO touchscreen serial protocol "elographics" for X:
 *
 *      Section "InputDevice"
 *              Identifier  "TouchScreen0"
 *              Driver      "elographics"
 *              Option      "Device" "/dev/atmel1-4a"
 *      EndSection
 *
 * The MXT chipsets typically attach on haswell chromebooks on one of the I2C
 * busses at address 0x4A.  On my Acer C720 it attaches to the ig4 driver's
 * I2C bus #1 at 0x4A.  kldload ig4; kldload atmel_mxt.
 *
 * The kernel driver and test code is written from scratch, but some code has
 * been snarfed (in separate files) from linux development as referenced
 * here:
 *
 * www.atmel.com/products/touchsolutions/touchscreens/unlimited_touch.aspx
 * git://github.com/atmel-maxtouch/obp-utils.git
 *
 * The linux driver was also consulted, but not used.  Note that the linux
 * driver appears to be GPL'd but uses code from obp-utils.git on github
 * which is (c)Copyright by Atmel and uses more of a BSD-like license.  The
 * obp-* source files contain the snarfed code and include this license.
 *
 * The ELO touchscreen serial protocol uses 10-byte fixed-length packets:
 *
 *      Byte 0:     ELO_SYNC_BYTE ('U')
 *      Byte 1-8:   Packet data
 *      Byte 9:     checksum of bytes 0 to 8
 *
 * Our interface reads and writes only whole packets and does not do any
 * buffer stitching.  It is compatible with Xorg.
 *
 * Control Commands sent from Userland (only an Ack packet is returned)
 *
 *      Byte 0:     ELO_SYNC_BYTE ('U')
 *      Byte 1:     ELO_MODE ('m')
 *      Byte 2:     Flags
 *          0x80 -
 *          0x40 Tracking mode
 *          0x20 -
 *          0x10 -
 *          0x08 Scaling mode
 *          0x04 Untouch mode
 *          0x02 Streaming mode
 *          0x01 Touch mode
 *
 *      Byte 0:     ELO_SYNC_BYTE ('U')
 *      Byte 1:     ELO_REPORT ('r')
 *
 * Query Command sent from Userland: (expect response packet and Ack packet)
 *
 *      Byte 0:     ELO_SYNC_BYTE ('U')         Request ID
 *      Byte 1:     ELO_ID ('i')
 *
 *      Byte 0:     ELO_SYNC_BYTE ('U')`        Request Owner
 *      Byte 1:     ELO_OWNER ('o')
 *
 * Streaming packets sent from the driver to userland
 *
 *      Byte 0:     ELO_SYNC_BYTE ('U')
 *      Byte 1:     ELO_TOUCH ('T')
 *      Byte 2:     Packet type
 *        Bit 2 : Pen Up        (Release)       0x04
 *        Bit 1 : Position      (Stream)        0x02
 *        Bit 0 : Pen Down      (Press)         0x01
 *      Byte 3:     X coordinate lsb
 *      Byte 4:     X coordinate msb
 *      Byte 5:     Y coordinate lsb
 *      Byte 6:     Y coordinate msb
 *      Byte 7:     Z coordinate lsb
 *      Byte 8:     Z coordinate msb
 *
 * Responses to commands: (one or two packets returned)
 *
 *      Byte 0:     ELO_SYNC_BYTE ('U')         (if in response to query)
 *      Byte 1:     toupper(command_byte)       (control commands have no
 *      Byte 2-8:   ... depends ....             response)
 *
 *      Byte 0:     ELO_SYNC_BYTE ('U')         (unconditional ack)
 *      Byte 1:     'A'ck
 *      Byte 2-8:   ... depends ....
 *
 * NOTE!  For the most part we ignore commands other than doing the handwaving
 *        to send a dummied-up response and ack as assumed by the X driver.
 *        Also, the read() and write() support only reads and writes whole
 *        packets.  There is NO byte-partial buffering.  The X driver appears
 *        to be compatible with these restrictions.
 *
 * figure out the bootstrapping and commands.
 *
 * Unable to locate any datasheet for the device.
 *
 *                                  FEATURES
 *
 * Currently no features.  Only one finger is supported by this attachment
 * for now and I haven't written any de-jitter and finger-transfer code.
 * This is good enough for moving and resizing windows (given big enough
 * widgets), and hitting browser buttons and hotlinks.
 *
 * Currently no scrolling control or other features.  We would need to
 * basically implement either the linux general input even infrastructure
 * which is a LOT of code, or a mouse emulator to handle scrolling emulation.
 */
#include <sys/kernel.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/malloc.h>
#include <sys/module.h>
#include <sys/bus.h>
#include <sys/conf.h>
#include <sys/uio.h>
#include <sys/fcntl.h>
#include <sys/vnode.h>
#include <sys/sysctl.h>
#include <sys/event.h>
#include <sys/devfs.h>

#include <bus/smbus/smbconf.h>
#include <bus/smbus/smbus.h>
#include "atmel_mxt.h"

#include "smbus_if.h"

struct elopacket {
        uint8_t sync;
        uint8_t cmd;
        uint8_t byte2;
        uint8_t byte3;
        uint8_t byte4;
        uint8_t byte5;
        uint8_t byte6;
        uint8_t byte7;
        uint8_t byte8;
        uint8_t csum;
} __packed;

typedef struct elopacket elopacket_t;

typedef struct atmel_track {
        uint16_t x;
        uint16_t y;
        uint16_t pressure;
        int     status;
        int     report;         /* what we have to report */
} atmel_track_t;

#define ATMEL_TRACK_RELEASED            0
#define ATMEL_TRACK_PRESSED             1

#define ATMEL_REPORT_PRESS      0x0001
#define ATMEL_REPORT_MOVE       0x0002
#define ATMEL_REPORT_RELEASE    0x0004

#define ATMEL_MAXTRACK          10

struct atmel_mxt_softc {
        device_t dev;
        int     count;                  /* >0 if device opened */
        int     unit;
        int     addr;
        cdev_t  devnode;
        struct kqinfo kqinfo;
        struct lock lk;

        int     poll_flags;
        thread_t poll_td;

        /*
         * Hardware state
         */
        struct mxt_rollup       core;
        struct mxt_object       *msgprocobj;
        struct mxt_object       *cmdprocobj;

        /*
         * Capabilities
         */
        short   cap_resx;
        short   cap_resy;

        /*
         * Emulation
         */
        atmel_track_t track[ATMEL_MAXTRACK];
        int     tracking;
        int     track_fingers;

        elopacket_t pend_rep;           /* pending reply to command */
        int     pend_ack;               /* pending reply mode */

        int     last_active_tick;
        int     last_calibrate_tick;
        int     data_signal;            /* something ready to read */
        int     blocked;                /* someone is blocking */
        int     reporting_mode;
        int     sample_rate;            /* samples/sec */
        int     poll_ticks;
};

typedef struct atmel_mxt_softc atmel_mxt_softc_t;

#define ATMEL_POLL_SHUTDOWN     0x0001

#define PEND_ACK_NONE           0       /* no reply to command pending */
#define PEND_ACK_RESPOND        1       /* reply w/response and ack */
#define PEND_ACK_ACK            2       /* reply w/ack only */

#define REPORT_NONE             0x0000
#define REPORT_ALL              0x0001

/*
 * Async debug variable commands are executed by the poller and will
 * auto-clear.
 */
static int atmel_mxt_idle_freq = 1;
SYSCTL_INT(_debug, OID_AUTO, atmel_mxt_idle_freq, CTLFLAG_RW,
                &atmel_mxt_idle_freq, 0, "");
static int atmel_mxt_slow_freq = 20;
SYSCTL_INT(_debug, OID_AUTO, atmel_mxt_slow_freq, CTLFLAG_RW,
                &atmel_mxt_slow_freq, 0, "");
static int atmel_mxt_norm_freq = 100;
SYSCTL_INT(_debug, OID_AUTO, atmel_mxt_norm_freq, CTLFLAG_RW,
                &atmel_mxt_norm_freq, 0, "");
static int atmel_mxt_minpressure = 16;
SYSCTL_INT(_debug, OID_AUTO, atmel_mxt_minpressure, CTLFLAG_RW,
                &atmel_mxt_minpressure, 0, "");
static int atmel_mxt_reset = 0;
SYSCTL_INT(_debug, OID_AUTO, atmel_mxt_reset, CTLFLAG_RW,
                &atmel_mxt_reset, 0, "");

/*
 * Run a calibration command every N seconds only when idle.  0 to disable.
 * Default every 30 seconds.
 */
static int atmel_mxt_autocalibrate = 30;
SYSCTL_INT(_debug, OID_AUTO, atmel_mxt_autocalibrate, CTLFLAG_RW,
                &atmel_mxt_autocalibrate, 0, "");

/*
 * run a calibration on module startup.
 */
static int atmel_mxt_debug = 0;
SYSCTL_INT(_debug, OID_AUTO, atmel_mxt_debug, CTLFLAG_RW,
                &atmel_mxt_debug, 0, "");

static void atmel_mxt_poll_thread(void *arg);
static void atmel_find_active_state(atmel_mxt_softc_t *sc);
static int atmel_mxt_raw_input(atmel_mxt_softc_t *sc, mxt_message_t *msg);
static struct mxt_object *mxt_findobject(struct mxt_rollup *core, int type);
static int mxt_read_reg(atmel_mxt_softc_t *sc, uint16_t reg,
                        void *rbuf, int bytes);
static int mxt_write_reg_buf(atmel_mxt_softc_t *sc, uint16_t reg,
                        void *xbuf, int bytes);
static int mxt_write_reg(atmel_mxt_softc_t *sc, uint16_t reg, uint8_t val);
static int mxt_read_object(atmel_mxt_softc_t *sc, struct mxt_object *obj,
                        void *rbuf, int rbytes);
static int mxt_write_object_off(atmel_mxt_softc_t *sc, struct mxt_object *obj,
                        int offset, uint8_t val);
static void atmel_reset_device(atmel_mxt_softc_t *sc);

static
const char *
msgflagsstr(uint8_t flags)
{
        static char buf[9];

        buf[0] = (flags & MXT_MSGF_DETECT) ? 'D' : '.';
        buf[1] = (flags & MXT_MSGF_PRESS) ? 'P' : '.';
        buf[2] = (flags & MXT_MSGF_RELEASE) ? 'R' : '.';
        buf[3] = (flags & MXT_MSGF_MOVE) ? 'M' : '.';
        buf[4] = (flags & MXT_MSGF_VECTOR) ? 'V' : '.';
        buf[5] = (flags & MXT_MSGF_AMP) ? 'A' : '.';
        buf[6] = (flags & MXT_MSGF_SUPPRESS) ? 'S' : '.';
        buf[7] = (flags & MXT_MSGF_UNGRIP) ? 'U' : '.';

        return buf;
}

static
void
atmel_mxt_lock(atmel_mxt_softc_t *sc)
{
        lockmgr(&sc->lk, LK_EXCLUSIVE);
}

static
void
atmel_mxt_unlock(atmel_mxt_softc_t *sc)
{
        lockmgr(&sc->lk, LK_RELEASE);
}

/*
 * Notify if possible receive data ready.  Must be called
 * without the lock held to avoid deadlocking in kqueue.
 */
static
void
atmel_mxt_notify(atmel_mxt_softc_t *sc)
{
        if (sc->data_signal) {
                KNOTE(&sc->kqinfo.ki_note, 0);
                atmel_mxt_lock(sc);
                if (sc->blocked) {
                        sc->blocked = 0;
                        wakeup(&sc->blocked);
                }
                atmel_mxt_unlock(sc);
        }
}

/*
 * Initialize the device
 */
static
int
init_device(atmel_mxt_softc_t *sc, int probe)
{
        int blksize;
        int totsize;
        uint32_t crc;

        if (mxt_read_reg(sc, 0, &sc->core.info, sizeof(sc->core.info))) {
                device_printf(sc->dev, "init_device read-reg failed\n");
                return ENXIO;
        }
        sc->core.nobjs = sc->core.info.num_objects;
        if (!probe) {
                device_printf(sc->dev,
                              "%d configuration objects\n",
                              sc->core.info.num_objects);
        }
        if (sc->core.nobjs < 0 || sc->core.nobjs > 1024) {
                device_printf(sc->dev,
                              "init_device nobjs (%d) out of bounds\n",
                              sc->core.nobjs);
                return ENXIO;
        }
        blksize = sizeof(sc->core.info) +
                  sc->core.nobjs * sizeof(struct mxt_object);
        totsize = blksize + sizeof(struct mxt_raw_crc);

        sc->core.buf = kmalloc(totsize, M_DEVBUF, M_WAITOK | M_ZERO);
        if (mxt_read_reg(sc, 0, sc->core.buf, totsize)) {
                device_printf(sc->dev,
                              "init_device cannot read configuration space\n");
                goto done;
        }
        kprintf("COREBUF %p %d\n", sc->core.buf, blksize);
        crc = obp_convert_crc((void *)((uint8_t *)sc->core.buf + blksize));
        if (obp_crc24(sc->core.buf, blksize) != crc) {
                device_printf(sc->dev,
                              "init_device: configuration space "
                              "crc mismatch %08x/%08x\n",
                              crc, obp_crc24(sc->core.buf, blksize));
                /*goto done;*/
        }
        {
                int i;

                kprintf("info:   ");
                for (i = 0; i < sizeof(sc->core.info); ++i)
                        kprintf(" %02x", sc->core.buf[i]);
                kprintf("\nconfig: ");
                while (i < blksize) {
                        kprintf(" %02x", sc->core.buf[i]);
                        ++i;
                }
                kprintf("\n");
        }
        sc->core.objs = (void *)((uint8_t *)sc->core.buf +
                                 sizeof(sc->core.info));
        sc->msgprocobj = mxt_findobject(&sc->core, MXT_GEN_MESSAGEPROCESSOR);
        sc->cmdprocobj = mxt_findobject(&sc->core, MXT_GEN_COMMANDPROCESSOR);
        if (sc->msgprocobj == NULL) {
                device_printf(sc->dev,
                              "init_device: cannot find msgproc config\n");
                goto done;
        }

done:
        if (sc->msgprocobj == NULL) {
                if (sc->core.buf) {
                        kfree(sc->core.buf, M_DEVBUF);
                        sc->core.buf = NULL;
                }
                return ENXIO;
        } else {
                if (probe) {
                        kfree(sc->core.buf, M_DEVBUF);
                        sc->core.buf = NULL;
                } else {
                        atmel_reset_device(sc);
                }
                return 0;
        }
}

/*
 * Device infrastructure
 */
#define ATMEL_SOFTC(unit) \
        ((atmel_mxt_softc_t *)devclass_get_softc(atmel_mxt_devclass, (unit)))

static void atmel_mxt_identify(driver_t *driver, device_t parent);
static int atmel_mxt_probe(device_t);
static int atmel_mxt_attach(device_t);
static int atmel_mxt_detach(device_t);

static devclass_t atmel_mxt_devclass;

static device_method_t atmel_mxt_methods[] = {
        /* device interface */
        DEVMETHOD(device_identify,      atmel_mxt_identify),
        DEVMETHOD(device_probe,         atmel_mxt_probe),
        DEVMETHOD(device_attach,        atmel_mxt_attach),
        DEVMETHOD(device_detach,        atmel_mxt_detach),

#if 0
        /* smbus interface */
        DEVMETHOD(smbus_intr,           smbus_generic_intr),
#endif

        DEVMETHOD_END
};

static driver_t atmel_mxt_driver = {
        "atmel_mxt",
        atmel_mxt_methods,
        sizeof(atmel_mxt_softc_t),
};

static  d_open_t        atmel_mxtopen;
static  d_close_t       atmel_mxtclose;
static  d_ioctl_t       atmel_mxtioctl;
static  d_read_t        atmel_mxtread;
static  d_write_t       atmel_mxtwrite;
static  d_kqfilter_t    atmel_mxtkqfilter;

static struct dev_ops atmel_mxt_ops = {
        { "atmel_mxt", 0, 0 },
        .d_open =       atmel_mxtopen,
        .d_close =      atmel_mxtclose,
        .d_ioctl =      atmel_mxtioctl,
        .d_read =       atmel_mxtread,
        .d_write =      atmel_mxtwrite,
        .d_kqfilter =   atmel_mxtkqfilter,
};

static void
atmel_mxt_identify(driver_t *driver, device_t parent)
{
        if (device_find_child(parent, "atmel_mxt", -1) == NULL)
                BUS_ADD_CHILD(parent, parent, 0, "atmel_mxt", -1);
}

static int
atmel_mxt_probe(device_t dev)
{
        atmel_mxt_softc_t sc;
        int error;

        bzero(&sc, sizeof(sc));
        sc.dev = dev;
        sc.unit = device_get_unit(dev);

        /*
         * Only match against specific addresses to avoid blowing up
         * other I2C devices (?).  At least for now.
         *
         * 0x400 (from smbus) - means specific device address probe,
         *                      rather than generic.
         *
         * 0x4A - cypress trackpad on the acer c720.
         */
        if ((sc.unit & 0x04FF) != (0x0400 | 0x04A))
                return ENXIO;
        sc.addr = sc.unit & 0x3FF;
        error = init_device(&sc, 1);
        if (error)
                return ENXIO;

        device_set_desc(dev, "Atmel MXT TouchScreen");

        return (BUS_PROBE_VENDOR);
}

static int
atmel_mxt_attach(device_t dev)
{
        atmel_mxt_softc_t *sc;

        sc = (atmel_mxt_softc_t *)device_get_softc(dev);
        if (!sc)
                return ENOMEM;

        bzero(sc, sizeof(*sc));

        lockinit(&sc->lk, "atmel_mxt", 0, 0);
        sc->reporting_mode = 1;

        sc->dev = dev;
        sc->unit = device_get_unit(dev);
        if ((sc->unit & 0x04FF) != (0x0400 | 0x04A))
                return ENXIO;
        sc->addr = sc->unit & 0x3FF;
        sc->last_active_tick = ticks;
        sc->last_calibrate_tick = ticks - atmel_mxt_autocalibrate * hz;

        if (init_device(sc, 0))
                return ENXIO;

        if (sc->unit & 0x0400) {
                sc->devnode = make_dev(&atmel_mxt_ops, sc->unit,
                                UID_ROOT, GID_WHEEL, 0600,
                                "atmel%d-%02x",
                                sc->unit >> 11, sc->unit & 1023);
        } else {
                sc->devnode = make_dev(&atmel_mxt_ops, sc->unit,
                                UID_ROOT, GID_WHEEL, 0600, "atmel%d", sc->unit);
        }
        device_printf(dev, "atmel mxt touchscreen driver attached\n");
        /* device_printf(dev, "...."); */

        /*
         * Start the polling thread.
         */
        lwkt_create(atmel_mxt_poll_thread, sc,
                    &sc->poll_td, NULL, 0, -1, "atmel_mxt-poll");

        return (0);
}

static int
atmel_mxt_detach(device_t dev)
{
        atmel_mxt_softc_t *sc;

        sc = (atmel_mxt_softc_t *)device_get_softc(dev);

        /*
         * Cleanup our poller thread
         */
        atomic_set_int(&sc->poll_flags, ATMEL_POLL_SHUTDOWN);
        while (sc->poll_td) {
                wakeup(&sc->poll_flags);
                tsleep(&sc->poll_td, 0, "atmel_mxtdet", hz);
        }

        if (sc->devnode)
                dev_ops_remove_minor(&atmel_mxt_ops, device_get_unit(dev));
        if (sc->devnode)
                devfs_assume_knotes(sc->devnode, &sc->kqinfo);
        if (sc->core.buf) {
                kfree(sc->core.buf, M_DEVBUF);
                sc->core.buf = NULL;
        }
        sc->msgprocobj = NULL;
        sc->cmdprocobj = NULL;

        return (0);
}

/*
 * USER DEVICE I/O FUNCTIONS
 */
static int
atmel_mxtopen (struct dev_open_args *ap)
{
        cdev_t dev = ap->a_head.a_dev;
        atmel_mxt_softc_t *sc = ATMEL_SOFTC(minor(dev));

        if (sc == NULL)
                return (ENXIO);

        if (sc->count != 0)
                return (EBUSY);

        sc->count++;

        return (0);
}

static int
atmel_mxtclose(struct dev_close_args *ap)
{
        cdev_t dev = ap->a_head.a_dev;
        atmel_mxt_softc_t *sc = ATMEL_SOFTC(minor(dev));

        if (sc == NULL)
                return (ENXIO);

        if (sc->count == 0) {
                /* This is not supposed to happen. */
                return (0);
        }

        if (sc->count-- == 0) {
                sc->reporting_mode = 0;
        }

        return (0);
}

static int
atmel_mxtread(struct dev_read_args *ap)
{
        cdev_t dev = ap->a_head.a_dev;
        atmel_mxt_softc_t *sc = ATMEL_SOFTC(minor(dev));
        int error;
        struct uio *uio = ap->a_uio;
        int ioflag = ap->a_ioflag;
        size_t n;
        elopacket_t pkt;
        atmel_track_t *track;

        /*
         * Load next ready event, block if necessary.
         */
        atmel_mxt_lock(sc);
        for (;;) {
                error = 0;

                switch(sc->pend_ack) {
                case PEND_ACK_NONE:
                        if (sc->tracking && sc->track[sc->tracking].report) {
                                /*
                                 * Report ready
                                 */
                                track = &sc->track[sc->tracking];
                                bzero(&pkt, sizeof(pkt));
                                pkt.cmd = 'T';
                                if (track->report & ATMEL_REPORT_PRESS) {
                                        pkt.byte2 |= 0x01;
                                        track->report &= ~ATMEL_REPORT_PRESS;
                                } else if (track->report & ATMEL_REPORT_MOVE) {
                                        pkt.byte2 |= 0x02;
                                        track->report &= ~ATMEL_REPORT_MOVE;
                                } else if (track->report &
                                           ATMEL_REPORT_RELEASE) {
                                        pkt.byte2 |= 0x04;
                                        track->report &= ~ATMEL_REPORT_RELEASE;
                                }
                                pkt.byte3 = track->x & 0xFF;
                                pkt.byte4 = track->x >> 8;
                                pkt.byte5 = track->y & 0xFF;
                                pkt.byte6 = track->y >> 8;
                                pkt.byte7 = track->pressure & 0xFF;
                                pkt.byte8 = track->pressure >> 8;
                        } else if (ioflag & IO_NDELAY) {
                                /*
                                 * Non-blocking, nothing ready
                                 */
                                error = EWOULDBLOCK;
                        } else {
                                /*
                                 * Blocking, nothing ready
                                 */
                                sc->data_signal = 0;
                                sc->blocked = 1;
                                error = lksleep(&sc->blocked, &sc->lk,
                                                PCATCH, "atmelw", 0);
                                if (error == 0)
                                        continue;
                        }
                        break;
                case PEND_ACK_RESPOND:
                        pkt = sc->pend_rep;
                        sc->pend_ack = PEND_ACK_ACK;
                        break;
                case PEND_ACK_ACK:
                        bzero(&pkt, sizeof(pkt));
                        pkt.cmd = 'A';
                        sc->pend_ack = PEND_ACK_NONE;
                        break;
                }
                atmel_find_active_state(sc);
                break;
        }
        atmel_mxt_unlock(sc);

        /*
         * If no error we can return the event loaded into pkt.
         */
        if (error == 0) {
                uint8_t csum = 0xAA;
                int i;

                pkt.sync = 'U';
                for (i = 0; i < sizeof(pkt) - 1; ++i)
                        csum += ((uint8_t *)&pkt)[i];
                pkt.csum = csum;
                n = uio->uio_resid;
                if (n > sizeof(pkt))
                        n = sizeof(pkt);
                error = uiomove((void *)&pkt, n, uio);
        }

        return error;
}

static int
atmel_mxtwrite(struct dev_write_args *ap)
{
        cdev_t dev = ap->a_head.a_dev;
        atmel_mxt_softc_t *sc = ATMEL_SOFTC(minor(dev));
        struct uio *uio = ap->a_uio;
        elopacket_t pkt;
        int error;
        size_t n;

        error = 0;

        while (uio->uio_resid) {
                bzero(&pkt, sizeof(pkt));
                n = uio->uio_resid;
                if (n > sizeof(pkt))
                        n = sizeof(pkt);
                error = uiomove((void *)&pkt, n, uio);
                if (error)
                        break;
                atmel_mxt_lock(sc);
                switch(pkt.cmd) {
                case 'i':
                        /*
                         * ELO_ID request id
                         */
                        bzero(&sc->pend_rep, sizeof(sc->pend_rep));
                        sc->pend_rep.cmd = 'I';
                        sc->pend_ack = PEND_ACK_RESPOND;
                        break;
                case 'o':
                        /*
                         * ELO_OWNER request owner
                         */
                        bzero(&sc->pend_rep, sizeof(sc->pend_rep));
                        sc->pend_rep.cmd = 'O';
                        sc->pend_ack = PEND_ACK_RESPOND;
                        break;
                case 'm':
                        /*
                         * ELO_MODE control packet
                         */
                        sc->pend_ack = PEND_ACK_ACK;
                        break;
                case 'r':
                        /*
                         * ELO_REPORT control packet
                         */
                        sc->pend_ack = PEND_ACK_ACK;
                        break;
                }
                atmel_mxt_unlock(sc);
        }
        return error;
}

static void atmel_mxt_filt_detach(struct knote *);
static int atmel_mxt_filt(struct knote *, long);

static struct filterops atmel_mxt_filtops =
        { FILTEROP_ISFD, NULL, atmel_mxt_filt_detach, atmel_mxt_filt };

static int
atmel_mxtkqfilter(struct dev_kqfilter_args *ap)
{
        cdev_t dev = ap->a_head.a_dev;
        atmel_mxt_softc_t *sc = ATMEL_SOFTC(minor(dev));
        struct knote *kn = ap->a_kn;
        struct klist *klist;

        switch(kn->kn_filter) {
        case EVFILT_READ:
                kn->kn_fop = &atmel_mxt_filtops;
                kn->kn_hook = (void *)sc;
                ap->a_result = 0;
                break;
        default:
                ap->a_result = EOPNOTSUPP;
                return (0);
        }
        klist = &sc->kqinfo.ki_note;
        knote_insert(klist, kn);

        return (0);
}

static void
atmel_mxt_filt_detach(struct knote *kn)
{
        atmel_mxt_softc_t *sc = (atmel_mxt_softc_t *)kn->kn_hook;
        struct klist *klist;

        klist = &sc->kqinfo.ki_note;
        knote_remove(klist, kn);
}

static int
atmel_mxt_filt(struct knote *kn, long hint)
{
        atmel_mxt_softc_t *sc = (atmel_mxt_softc_t *)kn->kn_hook;
        int ready;

        atmel_mxt_lock(sc);
        if (sc->data_signal)
                ready = 1;
        else
                ready = 0;
        atmel_mxt_unlock(sc);

        return (ready);
}

static int
atmel_mxtioctl(struct dev_ioctl_args *ap)
{
        cdev_t dev = ap->a_head.a_dev;
        device_t bus;           /* smbbus */
        /*struct atmel_mxtcmd *s = (struct atmel_mxtcmd *)ap->a_data;*/
        void *s = NULL;
        atmel_mxt_softc_t *sc = ATMEL_SOFTC(minor(dev));
        int error;

        if (sc == NULL)
                return (ENXIO);
        if (s == NULL)
                return (EINVAL);

        /*
         * NOTE: smbus_*() functions automatically recurse the parent to
         *       get to the actual device driver.
         */
        bus = device_get_parent(sc->dev);       /* smbus */

        /* Allocate the bus. */
        if ((error = smbus_request_bus(bus, sc->dev,
                        (ap->a_fflag & O_NONBLOCK) ?
                        SMB_DONTWAIT : (SMB_WAIT | SMB_INTR))))
                return (error);

        switch (ap->a_cmd) {
        default:
#if 0
                error = inputev_ioctl(&sc->iev, ap->a_cmd, ap->a_data);
#endif
                error = ENOTTY;
                break;
        }

        smbus_release_bus(bus, sc->dev);

        return (error);
}

/*
 * MAJOR SUPPORT FUNCTIONS
 */
static
void
atmel_mxt_poll_thread(void *arg)
{
        atmel_mxt_softc_t *sc = arg;
        int error;
        int freq = atmel_mxt_norm_freq;
        int isidle = 0;

        while ((sc->poll_flags & ATMEL_POLL_SHUTDOWN) == 0) {
                if (sc->msgprocobj)
                        error = 0;
                else
                        error = ENXIO;
                if (error == 0) {
                        mxt_message_t msg;

                        error = mxt_read_object(sc, sc->msgprocobj,
                                            &msg, sizeof(msg));
                        if (error == 0)
                                isidle = atmel_mxt_raw_input(sc, &msg);
                        else
                                isidle = 1;
                }

                /*
                 * don't let the last_active_tick or last_calibrate_tick
                 * delta calculation overflow.
                 */
                if ((ticks - sc->last_active_tick) > 1000 * hz)
                        sc->last_active_tick = ticks - 1000 * hz;
                if ((ticks - sc->last_calibrate_tick) > 1000 * hz)
                        sc->last_calibrate_tick = ticks - 1000 * hz;

                /*
                 * Reset if requested
                 */
                if (atmel_mxt_reset) {
                        atmel_mxt_reset = 0;
                        atmel_reset_device(sc);
                }

                /*
                 * Automatically calibrate when the touchpad has been
                 * idle atmel_mxt_autocalibrate seconds, and recalibrate
                 * on the same interval while it remains idle.
                 *
                 * If we don't do this the touchscreen can get really out
                 * of whack over time and basically stop functioning properly.
                 * It's unclear why the device does not do this automatically.
                 *
                 * Response occurs in the message stream (which we just
                 * ignore).
                 */
                if (sc->cmdprocobj && atmel_mxt_autocalibrate &&
                    ((ticks - sc->last_calibrate_tick) >
                     atmel_mxt_autocalibrate * hz) &&
                    ((ticks - sc->last_active_tick) >
                     atmel_mxt_autocalibrate * hz)) {
                        sc->last_calibrate_tick = ticks;
                        mxt_write_object_off(sc, sc->cmdprocobj,
                                         MXT_CMDPROC_CALIBRATE_OFF, 1);
                }
                tsleep(&sc->poll_flags, 0, "atmpol", (hz + freq - 1) / freq);
                ++sc->poll_ticks;
                if (sc->count == 0)
                        freq = atmel_mxt_idle_freq;
                else if (isidle)
                        freq = atmel_mxt_slow_freq;
                else
                        freq = atmel_mxt_norm_freq;
        }
        sc->poll_td = NULL;
        wakeup(&sc->poll_td);
}

static
void
atmel_reset_device(atmel_mxt_softc_t *sc)
{
        int dummy;
        mxt_write_object_off(sc, sc->cmdprocobj, MXT_CMDPROC_RESET_OFF, 1);
        tsleep(&dummy, 0, "atmel_reset", hz * 2);
}

/*
 * Calculate currently active state, if any
 */
static
void
atmel_find_active_state(atmel_mxt_softc_t *sc)
{
        atmel_track_t *track;
        int i;

        track = &sc->track[sc->tracking];
        if (track->report == 0) {
                for (i = 0; i < ATMEL_MAXTRACK; ++i) {
                        track = &sc->track[i];
                        if (track->report) {
                                sc->tracking = i;
                                break;
                        }
                }
        }
        if (track->report == 0 && sc->pend_ack == PEND_ACK_NONE) {
                sc->data_signal = 0;
        } else {
                sc->data_signal = 1;
        }
}

/*
 * Return non-zero if we are idle
 */
static
int
atmel_mxt_raw_input(atmel_mxt_softc_t *sc, mxt_message_t *msg)
{
        atmel_track_t *track;
        int donotify = 0;

        if (atmel_mxt_debug) {
                kprintf("track=%02x f=%s x=%-4d y=%-4d p=%d amp=%d\n",
                        msg->any.reportid,
                        msgflagsstr(msg->touch.flags),
                        (msg->touch.pos[0] << 4) |
                                ((msg->touch.pos[2] >> 4) & 0x0F),
                        (msg->touch.pos[1] << 4) |
                                ((msg->touch.pos[2]) & 0x0F),
                        msg->touch.area,
                        msg->touch.amplitude);
        }
        atmel_mxt_lock(sc);

        /*
         * If message buffer is empty and no fingers are currently pressed
         * return idle, else we are not idle.
         */
        if (msg->any.reportid == 0xFF)
                goto done;

        /*
         * Process message buffer.  For now ignore any messages with
         * reportids that we do not understand.
         *
         * note: reportid==1  typicallk acknowledges calibrations (?)
         */
        if (msg->any.reportid < 3 || msg->any.reportid >= ATMEL_MAXTRACK)
                goto done;

        sc->last_active_tick = ticks;

        track = &sc->track[msg->any.reportid];
        track->x = (msg->touch.pos[0] << 4) |
                   ((msg->touch.pos[2] >> 4) & 0x0F);
        track->y = (msg->touch.pos[1] << 4) |
                   (msg->touch.pos[2] & 0x0F);
        track->pressure = msg->touch.amplitude;

        track->x = track->x * 3000 / 1361;
        track->y = track->y * 3000 / 3064;

        if (msg->touch.flags & MXT_MSGF_DETECT) {
                track->status = ATMEL_TRACK_PRESSED;
                if (msg->touch.flags & MXT_MSGF_PRESS) {
                        track->report |= ATMEL_REPORT_PRESS;
                }
                if (msg->touch.flags & MXT_MSGF_MOVE) {
                        track->report |= ATMEL_REPORT_MOVE;
                }
        } else {
                track->status = ATMEL_TRACK_RELEASED;
                track->report |= ATMEL_REPORT_RELEASE;
        }
        atmel_find_active_state(sc);
        donotify = 1;
done:
        atmel_mxt_unlock(sc);
        if (donotify)
                atmel_mxt_notify(sc);
        if (sc->track_fingers)
                return 0;
        else
                return 1;
}

/*
 * Support functions
 */
static
struct mxt_object *
mxt_findobject(struct mxt_rollup *core, int type)
{
        int i;

        for (i = 0; i < core->nobjs; ++i) {
                if (core->objs[i].type == type)
                        return(&core->objs[i]);
        }
        return NULL;
}

static int
mxt_read_reg(atmel_mxt_softc_t *sc, uint16_t reg, void *rbuf, int bytes)
{
        uint8_t wreg[2];
        device_t bus;
        int error;
        int rbytes;

        wreg[0] = reg & 255;
        wreg[1] = reg >> 8;

        bus = device_get_parent(sc->dev);
        if ((error = smbus_request_bus(bus, sc->dev, SMB_WAIT | SMB_INTR)) != 0)
                return error;
        error = smbus_trans(bus, sc->addr, 0,
                            SMB_TRANS_NOCNT |
                            SMB_TRANS_NOCMD |
                            SMB_TRANS_7BIT,
                            wreg, 2,
                            rbuf, bytes, &rbytes);
        smbus_release_bus(bus, sc->dev);

        if (bytes != rbytes) {
                device_printf(sc->dev,
                              "smbus_trans reg %d short read %d/%d\n",
                              reg, bytes, rbytes);
                error = EINVAL;
        }

        return error;
}

static int
mxt_write_reg_buf(atmel_mxt_softc_t *sc, uint16_t reg, void *xbuf, int bytes)
{
        uint8_t wbuf[256];
        device_t bus;
        int error;

        KKASSERT(bytes < sizeof(wbuf) - 2);
        wbuf[0] = reg & 255;
        wbuf[1] = reg >> 8;
        bcopy(xbuf, wbuf + 2, bytes);

        bus = device_get_parent(sc->dev);
        if ((error = smbus_request_bus(bus, sc->dev, SMB_WAIT | SMB_INTR)) != 0)
                return error;
        error = smbus_trans(bus, sc->addr, 0,
                            SMB_TRANS_NOCNT |
                            SMB_TRANS_NOCMD |
                            SMB_TRANS_7BIT,
                            wbuf, bytes + 2,
                            NULL, 0, NULL);
        smbus_release_bus(bus, sc->dev);
        return error;
}

static int
mxt_write_reg(atmel_mxt_softc_t *sc, uint16_t reg, uint8_t val)
{
        return mxt_write_reg_buf(sc, reg, &val, 1);
}

static int
mxt_read_object(atmel_mxt_softc_t *sc, struct mxt_object *obj,
                void *rbuf, int rbytes)
{
        uint16_t reg = obj->start_pos_lsb + (obj->start_pos_msb << 8);
        int bytes = obj->size_minus_one + 1;

        if (bytes > rbytes)
                bytes = rbytes;
        return mxt_read_reg(sc, reg, rbuf, bytes);
}

static int
mxt_write_object_off(atmel_mxt_softc_t *sc, struct mxt_object *obj,
                 int offset, uint8_t val)
{
        uint16_t reg = obj->start_pos_lsb + (obj->start_pos_msb << 8);

        reg += offset;
        return mxt_write_reg(sc, reg, val);
}

DRIVER_MODULE(atmel_mxt, smbus, atmel_mxt_driver, atmel_mxt_devclass,
              NULL, NULL);
MODULE_DEPEND(atmel_mxt, smbus, SMBUS_MINVER, SMBUS_PREFVER, SMBUS_MAXVER);
MODULE_VERSION(atmel_mxt, 1);