/*      $NetBSD: adb_ktm.c,v 1.9 2025/06/16 07:51:16 macallan Exp $     */

/*-
* Copyright (c) 2019 Michael Lorenz
* 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.
*
* 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 <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: adb_ktm.c,v 1.9 2025/06/16 07:51:16 macallan Exp $");

#include <sys/param.h>
#include <sys/device.h>
#include <sys/sysctl.h>
#include <sys/condvar.h>

#include <machine/autoconf.h>

#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wsmousevar.h>

#include <dev/adb/adbvar.h>

#include "adbdebug.h"

#ifdef KTM_DEBUG
#define DPRINTF printf
#else
#define DPRINTF while (0) printf
#endif

/*
* State info, per mouse instance.
*/
struct ktm_softc {
       device_t        sc_dev;
       struct adb_device *sc_adbdev;
       struct adb_bus_accessops *sc_ops;

       uint8_t         sc_us;          /* cmd to watch for */
       device_t        sc_wsmousedev;
       /* buffers */
       uint8_t         sc_config[8];
       int             sc_left;
       int             sc_right;
       int             sc_poll;
       int             sc_msg_len;
       kcondvar_t      sc_event;
       kmutex_t        sc_interlock;
       uint8_t         sc_buffer[16];
};

/*
* Function declarations.
*/
static int      ktm_match(device_t, cfdata_t, void *);
static void     ktm_attach(device_t, device_t, void *);
static void     ktm_init(struct ktm_softc *);
static void     ktm_write_config(struct ktm_softc *);
static void     ktm_buttons(struct ktm_softc *);
static void     ktm_process_event(struct ktm_softc *, int, uint8_t *);
static int      ktm_send_sync(struct ktm_softc *, uint8_t, int, uint8_t *);

/* Driver definition. */
CFATTACH_DECL_NEW(ktm, sizeof(struct ktm_softc),
   ktm_match, ktm_attach, NULL, NULL);

static int ktm_enable(void *);
static int ktm_ioctl(void *, u_long, void *, int, struct lwp *);
static void ktm_disable(void *);

static void ktm_handler(void *, int, uint8_t *);
static int  ktm_wait(struct ktm_softc *, int);
static int  sysctl_ktm_left(SYSCTLFN_ARGS);
static int  sysctl_ktm_right(SYSCTLFN_ARGS);

const struct wsmouse_accessops ktm_accessops = {
       ktm_enable,
       ktm_ioctl,
       ktm_disable,
};

static int
ktm_match(device_t parent, cfdata_t cf, void *aux)
{
       struct adb_attach_args *aaa = aux;
       if ((aaa->dev->original_addr == ADBADDR_MS) &&
           (aaa->dev->handler_id == ADBMS_TURBO))
               return 50;      /* beat out adbms */
       else
               return 0;
}

static void
ktm_attach(device_t parent, device_t self, void *aux)
{
       struct ktm_softc *sc = device_private(self);
       struct adb_attach_args *aaa = aux;
       struct wsmousedev_attach_args a;

       sc->sc_dev = self;
       sc->sc_ops = aaa->ops;
       sc->sc_adbdev = aaa->dev;
       sc->sc_adbdev->cookie = sc;
       sc->sc_adbdev->handler = ktm_handler;
       mutex_init(&sc->sc_interlock, MUTEX_DEFAULT, IPL_NONE);
       cv_init(&sc->sc_event, "ktm");
       sc->sc_us = ADBTALK(sc->sc_adbdev->current_addr, 0);
       printf(" addr %d: Kensington Turbo Mouse\n",
           sc->sc_adbdev->current_addr);

       sc->sc_poll = 0;
       sc->sc_msg_len = 0;

       ktm_init(sc);

       a.accessops = &ktm_accessops;
       a.accesscookie = sc;
       sc->sc_wsmousedev = config_found(self, &a, wsmousedevprint, CFARGS_NONE);
}

static int
ktm_turbo_csum(uint8_t *d)
{
       int i = 0, sum = 0;

       for (i = 0; i < 7; i++)
               sum ^= d[i];
       return (sum ^ 0xff);
}

static void
ktm_write_config(struct ktm_softc *sc)
{
       uint8_t addr = sc->sc_adbdev->current_addr;

       ktm_send_sync(sc, ADBFLUSH(addr), 0, NULL);
       sc->sc_config[7] = ktm_turbo_csum(sc->sc_config);
       ktm_send_sync(sc, ADBLISTEN(addr, 2), 8, sc->sc_config);
}

static uint8_t button_to_reg[] = {0, 1, 4, 6};

static void ktm_buttons(struct ktm_softc *sc)
{
       uint8_t reg;

       reg = button_to_reg[sc->sc_right] |
             (button_to_reg[sc->sc_left] << 3);
       sc->sc_config[1] = reg;
}

static void
ktm_init(struct ktm_softc *sc)
{
       const struct sysctlnode *me = NULL, *node = NULL;
       int ret;

       /* Found Kensington Turbo Mouse */

/*
* byte 0
- 0x80 enables EMP output
- 0x08 seems to map both buttons together
- 0x04 enables the 2nd button
- initialized to 0x20 on power up, no idea what that does

* byte 1 assigns what which button does
- 0x08 - button 1 - 1, button 2 - nothing
- 0x09 - both buttons - 1
- 0x0a - button 1 - 1, button 2 - toggle 1
- 0x0b - button 1 - 1, button 2 - nothing
- 0x0c - button 1 - 1, button 2 - 2
- 0x0e - button 1 - 1, button 2 - 3
- 0x0f - button 1 - 1, button 2 - toggle 3
- 0x10 - button 1 toggle 1, button 2 nothing
- 0x11 - button 1 - toggle 1, button 2 - 1
- 0x12 - both toggle 1
- 0x14 - button 1 toggle 1, button 2 - 2
- 0x21 - button 1 - 2, button 2 - 1
- 0x31 - button 1 - 3, button 2 - 1

* byte 2 - 0x40 on powerup, seems to do nothing
* byte 3 - 0x01 on powerup, seems to do nothing
* byte 4 programs a delay for button presses, apparently in 1/100 seconds
* byte 5 and 6 init to 0xff
* byte 7 is a simple XOR checksum, writes will only stick if it's valid
         as in, b[7] = (b[0] ^ b[1] ^ ... ^ b[6]) ^ 0xff
*/

       /* this seems to be the most reasonable default */
       uint8_t data[8] = { 0xa5, 0x0e, 0, 0, 1, 0xff, 0xff, 0 };

       memcpy(sc->sc_config, data, sizeof(data));

       sc->sc_left = 1;
       sc->sc_right = 3;

       ktm_buttons(sc);

#ifdef KTM_DEBUG
       int addr = sc->sc_adbdev->current_addr;
       {
               int i;
               ktm_send_sync(sc, ADBTALK(addr, 2), 0, NULL);
               printf("reg *");
               for (i = 0; i < sc->sc_msg_len; i++)
                       printf(" %02x", sc->sc_buffer[i]);
               printf("\n");
       }
#endif

       ktm_write_config(sc);

#ifdef KTM_DEBUG
       int i, reg;
       for (reg = 1; reg < 4; reg++) {
               ktm_send_sync(sc, ADBTALK(addr, reg), 0, NULL);
               printf("reg %d", reg);
               for (i = 0; i < sc->sc_msg_len; i++)
                       printf(" %02x", sc->sc_buffer[i]);
               printf("\n");
       }
#endif
       ret = sysctl_createv(NULL, 0, NULL, &me,
           CTLFLAG_READWRITE,
           CTLTYPE_NODE, device_xname(sc->sc_dev), NULL,
           NULL, 0, NULL, 0,
           CTL_MACHDEP, CTL_CREATE, CTL_EOL);

       ret = sysctl_createv(NULL, 0, NULL, &node,
           CTLFLAG_READWRITE | CTLFLAG_OWNDESC,
           CTLTYPE_INT, "left", "left button assignment",
           sysctl_ktm_left, 1, (void *)sc, 0,
           CTL_MACHDEP, me->sysctl_num, CTL_CREATE, CTL_EOL);

       ret = sysctl_createv(NULL, 0, NULL, &node,
           CTLFLAG_READWRITE | CTLFLAG_OWNDESC,
           CTLTYPE_INT, "right", "right button assignment",
           sysctl_ktm_right, 1, (void *)sc, 0,
           CTL_MACHDEP, me->sysctl_num, CTL_CREATE, CTL_EOL);
       __USE(ret);
}

static void
ktm_handler(void *cookie, int len, uint8_t *data)
{
       struct ktm_softc *sc = cookie;

#ifdef KTM_DEBUG
       int i;
       printf("%s: %02x - ", device_xname(sc->sc_dev), sc->sc_us);
       for (i = 0; i < len; i++) {
               printf(" %02x", data[i]);
       }
       printf("\n");
#endif
       if (len >= 2) {
               memcpy(sc->sc_buffer, &data[2], len - 2);
               sc->sc_msg_len = len - 2;
               if (data[1] == sc->sc_us) {
                       /* make sense of the mouse message */
                       ktm_process_event(sc, sc->sc_msg_len, sc->sc_buffer);
                       return;
               }
               cv_signal(&sc->sc_event);
       } else {
               DPRINTF("bogus message\n");
       }
}

static void
ktm_process_event(struct ktm_softc *sc, int len, uint8_t *buffer)
{
       int buttons = 0, mask, dx, dy, i;
       int button_bit = 1;

       /* Classic Mouse Protocol (up to 2 buttons) */
       for (i = 0; i < 2; i++, button_bit <<= 1)
               /* 0 when button down */
               if (!(buffer[i] & 0x80))
                       buttons |= button_bit;
               else
                       buttons &= ~button_bit;
       /* Extended Protocol (up to 6 more buttons) */
       for (mask = 0x80; i < len;
            i += (mask == 0x80), button_bit <<= 1) {
               /* 0 when button down */
               if (!(buffer[i] & mask))
                       buttons |= button_bit;
               else
                       buttons &= ~button_bit;
               mask = ((mask >> 4) & 0xf) | ((mask & 0xf) << 4);
       }

       /* EMP crap, additional motion bits */
       int shift = 7, ddx, ddy, sign, smask;

#ifdef KTM_DEBUG
       printf("EMP packet:");
       for (i = 0; i < len; i++)
               printf(" %02x", buffer[i]);
       printf("\n");
#endif
       dx = (int)buffer[1] & 0x7f;
       dy = (int)buffer[0] & 0x7f;
       for (i = 2; i < len; i++) {
               ddx = (buffer[i] & 0x07);
               ddy = (buffer[i] & 0x70) >> 4;
               dx |= (ddx << shift);
               dy |= (ddy << shift);
               shift += 3;
       }
       sign = 1 << (shift - 1);
       smask = 0xffffffff << shift;
       if (dx & sign)
               dx |= smask;
       if (dy & sign)
               dy |= smask;
#ifdef KTM_DEBUG
       printf("%d %d %08x %d\n", dx, dy, smask, shift);
#endif

       if (sc->sc_wsmousedev)
               wsmouse_input(sc->sc_wsmousedev, buttons,
                             dx, -dy, 0, 0,
                             WSMOUSE_INPUT_DELTA);
}

static int
ktm_enable(void *v)
{
       return 0;
}

static int
ktm_ioctl(void *v, u_long cmd, void *data, int flag, struct lwp *l)
{

       switch (cmd) {
       case WSMOUSEIO_GTYPE:
               *(u_int *)data = WSMOUSE_TYPE_ADB;
               break;

       default:
               return EPASSTHROUGH;
       }
       return 0;
}

static void
ktm_disable(void *v)
{
}

static int
ktm_wait(struct ktm_softc *sc, int timeout)
{
       int cnt = 0;

       if (sc->sc_poll) {
               while (sc->sc_msg_len == -1) {
                       sc->sc_ops->poll(sc->sc_ops->cookie);
               }
       } else {
               mutex_enter(&sc->sc_interlock);
               while ((sc->sc_msg_len == -1) && (cnt < timeout)) {
                       cv_timedwait(&sc->sc_event, &sc->sc_interlock, hz);
                       cnt++;
               }
               mutex_exit(&sc->sc_interlock);
       }
       return (sc->sc_msg_len > 0);
}

static int
ktm_send_sync(struct ktm_softc *sc, uint8_t cmd, int len, uint8_t *msg)
{
       int i;

       sc->sc_msg_len = -1;
       DPRINTF("send: %02x", cmd);
       for (i = 0; i < len; i++)
               DPRINTF(" %02x", msg[i]);
       DPRINTF("\n");
       sc->sc_ops->send(sc->sc_ops->cookie, sc->sc_poll, cmd, len, msg);
       ktm_wait(sc, 3);
       return (sc->sc_msg_len != -1);
}

static int
sysctl_ktm_left(SYSCTLFN_ARGS)
{
       struct sysctlnode node = *rnode;
       struct ktm_softc *sc = node.sysctl_data;
       int reg = sc->sc_left;

       if (newp) {

               /* we're asked to write */
               node.sysctl_data = &reg;
               if (sysctl_lookup(SYSCTLFN_CALL(&node)) == 0) {

                       reg = *(int *)node.sysctl_data;
                       if ((reg != sc->sc_left) &&
                           (reg >= 0) &&
                           (reg < 4)) {
                               sc->sc_left = reg;
                               ktm_buttons(sc);
                               ktm_write_config(sc);
                       }
                       return 0;
               }
               return EINVAL;
       } else {

               node.sysctl_data = &reg;
               node.sysctl_size = 4;
               return (sysctl_lookup(SYSCTLFN_CALL(&node)));
       }

       return 0;
}

static int
sysctl_ktm_right(SYSCTLFN_ARGS)
{
       struct sysctlnode node = *rnode;
       struct ktm_softc *sc = node.sysctl_data;
       int reg = sc->sc_right;

       if (newp) {

               /* we're asked to write */
               node.sysctl_data = &reg;
               if (sysctl_lookup(SYSCTLFN_CALL(&node)) == 0) {

                       reg = *(int *)node.sysctl_data;
                       if ((reg != sc->sc_right) &&
                           (reg >= 0) &&
                           (reg < 4)) {
                               sc->sc_right = reg;
                               ktm_buttons(sc);
                               ktm_write_config(sc);
                       }
                       return 0;
               }
               return EINVAL;
       } else {

               node.sysctl_data = &reg;
               node.sysctl_size = 4;
               return (sysctl_lookup(SYSCTLFN_CALL(&node)));
       }

       return 0;
}

SYSCTL_SETUP(sysctl_ktm_setup, "sysctl ktm subtree setup")
{

       sysctl_createv(NULL, 0, NULL, NULL,
                      CTLFLAG_PERMANENT,
                      CTLTYPE_NODE, "machdep", NULL,
                      NULL, 0, NULL, 0,
                      CTL_MACHDEP, CTL_EOL);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.