/*      $NetBSD: ams.c,v 1.28 2024/12/16 03:45:52 nat Exp $     */

/*
* Copyright (C) 1998   Colin Wood
* 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. All advertising materials mentioning features or use of this software
*    must display the following acknowledgement:
*      This product includes software developed by Colin Wood.
* 4. The name of the author may not be used to endorse or promote products
*    derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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: ams.c,v 1.28 2024/12/16 03:45:52 nat Exp $");

#include <sys/param.h>
#include <sys/device.h>
#include <sys/fcntl.h>
#include <sys/poll.h>
#include <sys/select.h>
#include <sys/proc.h>
#include <sys/signalvar.h>
#include <sys/systm.h>

#include "aed.h"
#include "wsmouse.h"

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

#include <machine/autoconf.h>
#include <machine/keyboard.h>

#include <mac68k/mac68k/macrom.h>
#include <mac68k/dev/adbvar.h>
#include <mac68k/dev/aedvar.h>
#include <mac68k/dev/amsvar.h>

/*
* Function declarations.
*/
static int      amsmatch(device_t, cfdata_t, void *);
static void     amsattach(device_t, device_t, void *);
static void     ems_init(struct ams_softc *);
static void     ms_processevent(adb_event_t *, struct ams_softc *);

/*
* Global variables.
*/
extern int      kbd_polling; /* Are we polling (Debugger mode)? from kbd.c */

/*
* Local variables.
*/

/* Driver definition. */
CFATTACH_DECL_NEW(ams, sizeof(struct ams_softc),
   amsmatch, amsattach, NULL, NULL);

extern struct cfdriver ams_cd;

int ams_enable(void *);
int ams_ioctl(void *, u_long, void *, int, struct lwp *);
void ams_disable(void *);

const struct wsmouse_accessops ams_accessops = {
       ams_enable,
       ams_ioctl,
       ams_disable,
};

static int
amsmatch(device_t parent, cfdata_t cf, void *aux)
{
       struct adb_attach_args * aa_args = (struct adb_attach_args *)aux;

       if (aa_args->origaddr == ADBADDR_MS)
               return 1;
       else
               return 0;
}

static void
amsattach(device_t parent, device_t self, void *aux)
{
       ADBSetInfoBlock adbinfo;
       struct ams_softc *sc = device_private(self);
       struct adb_attach_args * aa_args = (struct adb_attach_args *)aux;
       int error __unused;
#if NWSMOUSE > 0
       struct wsmousedev_attach_args a;
#endif

       sc->origaddr = aa_args->origaddr;
       sc->adbaddr = aa_args->adbaddr;
       sc->handler_id = aa_args->handler_id;

       sc->sc_class = MSCLASS_MOUSE;
       sc->sc_buttons = 1;
       sc->sc_res = 100;
       sc->sc_devid[0] = 0;
       sc->sc_devid[4] = 0;

       adbinfo.siServiceRtPtr = (Ptr)adb_ms_asmcomplete;
       adbinfo.siDataAreaAddr = (void *)sc;

       ems_init(sc);

       if (mac68k_machine.machineid == MACH_MACPB500 &&
           sc->sc_class == MSCLASS_MOUSE && sc->sc_devid[0] == '\0')
               sc->handler_id = ADBMS_200DPI;

       /* print out the type of mouse we have */
       switch (sc->handler_id) {
       case ADBMS_100DPI:
               printf("%d-button, %d dpi mouse\n", sc->sc_buttons,
                   (int)(sc->sc_res));
               break;
       case ADBMS_200DPI:
               sc->sc_res = 200;
               printf("%d-button, %d dpi mouse\n", sc->sc_buttons,
                   (int)(sc->sc_res));
               break;
       case ADBMS_MSA3:
               printf("Mouse Systems A3 mouse, %d-button, %d dpi\n",
                   sc->sc_buttons, (int)(sc->sc_res));
               break;
       case ADBMS_USPEED:
               printf("MicroSpeed mouse, default parameters\n");
               break;
       case ADBMS_UCONTOUR:
               printf("Contour mouse, default parameters\n");
               break;
       case ADBMS_EXTENDED:
               if (sc->sc_devid[0] == '\0') {
                       printf("Logitech ");
                       switch (sc->sc_class) {
                       case MSCLASS_MOUSE:
                               printf("MouseMan (non-EMP) mouse");
                               break;
                       case MSCLASS_TRACKBALL:
                               printf("TrackMan (non-EMP) trackball");
                               break;
                       default:
                               printf("non-EMP relative positioning device");
                               break;
                       }
                       printf("\n");
               } else {
                       printf("EMP ");
                       switch (sc->sc_class) {
                       case MSCLASS_TABLET:
                               printf("tablet");
                               break;
                       case MSCLASS_MOUSE:
                               printf("mouse");
                               break;
                       case MSCLASS_TRACKBALL:
                               printf("trackball");
                               break;
                       default:
                               printf("unknown device");
                               break;
                       }
                       printf(" <%s> %d-button, %d dpi\n", sc->sc_devid,
                           sc->sc_buttons, (int)(sc->sc_res));
               }
               break;
       default:
               printf("relative positioning device (mouse?) (%d)\n",
                       sc->handler_id);
               break;
       }
       error = SetADBInfo(&adbinfo, sc->adbaddr);
#ifdef ADB_DEBUG
       if (adb_debug)
               printf("ams: returned %d from SetADBInfo\n", error);
#endif

#if NWSMOUSE > 0
       a.accessops = &ams_accessops;
       a.accesscookie = sc;
       sc->sc_wsmousedev = config_found(self, &a, wsmousedevprint, CFARGS_NONE);
#endif
}


/*
* Initialize extended mouse support -- probes devices as described
* in Inside Macintosh: Devices, Chapter 5 "ADB Manager".
*
* Extended Mouse Protocol is documented in TechNote HW1:
*      "ADB - The Untold Story:  Space Aliens Ate My Mouse"
*
* Supports: Extended Mouse Protocol, MicroSpeed Mouse Deluxe,
*           Mouse Systems A^3 Mouse, Logitech non-EMP MouseMan
*/
void
ems_init(struct ams_softc *sc)
{
       int adbaddr;
       short cmd;
       u_char buffer[9];

       adbaddr = sc->adbaddr;
       if (sc->origaddr != ADBADDR_MS)
               return;
       if (sc->handler_id == ADBMS_USPEED ||
           sc->handler_id == ADBMS_UCONTOUR) {
               /* Found MicroSpeed Mouse Deluxe Mac or Contour Mouse */
               cmd = ADBLISTEN(adbaddr, 1);

               /*
                * To setup the MicroSpeed or the Contour, it appears
                * that we can send the following command to the mouse
                * and then expect data back in the form:
                *  buffer[0] = 4 (bytes)
                *  buffer[1], buffer[2] as std. mouse
                *  buffer[3] = buffer[4] = 0xff when no buttons
                *   are down.  When button N down, bit N is clear.
                * buffer[4]'s locking mask enables a
                * click to toggle the button down state--sort of
                * like the "Easy Access" shift/control/etc. keys.
                * buffer[3]'s alternative speed mask enables using
                * different speed when the corr. button is down
                */
               buffer[0] = 4;
               buffer[1] = 0x00;       /* Alternative speed */
               buffer[2] = 0x00;       /* speed = maximum */
               buffer[3] = 0x10;       /* enable extended protocol,
                                        * lower bits = alt. speed mask
                                        *            = 0000b
                                        */
               buffer[4] = 0x07;       /* Locking mask = 0000b,
                                        * enable buttons = 0111b
                                        */
               adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd);

               sc->sc_buttons = 3;
               sc->sc_res = 200;
               return;
       }
       if ((sc->handler_id == ADBMS_100DPI) ||
           (sc->handler_id == ADBMS_200DPI)) {
               /* found a mouse */
               cmd = ADBTALK(adbaddr, 3);
               if (adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd)) {
#ifdef ADB_DEBUG
                       if (adb_debug)
                               printf("adb: ems_init timed out\n");
#endif
                       return;
               }

               /* Attempt to initialize Extended Mouse Protocol */
               buffer[2] = 4; /* make handler ID 4 */
               cmd = ADBLISTEN(adbaddr, 3);
               if (adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd)) {
#ifdef ADB_DEBUG
                       if (adb_debug)
                               printf("adb: ems_init timed out\n");
#endif
                       return;
               }

               /*
                * Check to see if successful, if not
                * try to initialize it as other types
                */
               cmd = ADBTALK(adbaddr, 3);
               if (adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd) == 0 &&
                   buffer[2] == ADBMS_EXTENDED) {
                       sc->handler_id = ADBMS_EXTENDED;
                       cmd = ADBTALK(adbaddr, 1);
                       if (adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd)) {
#ifdef ADB_DEBUG
                               if (adb_debug)
                                       printf("adb: ems_init timed out\n");
#endif
                       } else if (buffer[0] == 8) {
                               /* we have a true EMP device */
                               sc->sc_class = buffer[7];
                               sc->sc_buttons = buffer[8];
                               sc->sc_res = (int)*(short *)&buffer[5];
                               memcpy(sc->sc_devid, &(buffer[1]), 4);
                       } else if (buffer[1] == 0x9a &&
                           ((buffer[2] == 0x20) || (buffer[2] == 0x21))) {
                               /*
                                * Set up non-EMP Mouseman/Trackman to put
                                * button bits in 3rd byte instead of sending
                                * via pseudo keyboard device.
                                */
                               cmd = ADBLISTEN(adbaddr, 1);
                               buffer[0]=2;
                               buffer[1]=0x00;
                               buffer[2]=0x81;
                               adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd);

                               cmd = ADBLISTEN(adbaddr, 1);
                               buffer[0]=2;
                               buffer[1]=0x01;
                               buffer[2]=0x81;
                               adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd);

                               cmd = ADBLISTEN(adbaddr, 1);
                               buffer[0]=2;
                               buffer[1]=0x02;
                               buffer[2]=0x81;
                               adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd);

                               cmd = ADBLISTEN(adbaddr, 1);
                               buffer[0]=2;
                               buffer[1]=0x03;
                               buffer[2]=0x38;
                               adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd);

                               sc->sc_buttons = 3;
                               sc->sc_res = 400;
                               if (buffer[2] == 0x21)
                                       sc->sc_class = MSCLASS_TRACKBALL;
                               else
                                       sc->sc_class = MSCLASS_MOUSE;
                       } else
                               /* unknown device? */;
               } else {
                       /* Attempt to initialize as an A3 mouse */
                       buffer[2] = 0x03; /* make handler ID 3 */
                       cmd = ADBLISTEN(adbaddr, 3);
                       if (adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd)) {
#ifdef ADB_DEBUG
                               if (adb_debug)
                                       printf("adb: ems_init timed out\n");
#endif
                               return;
                       }

                       /*
                        * Check to see if successful, if not
                        * try to initialize it as other types
                        */
                       cmd = ADBTALK(adbaddr, 3);
                       if (adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd) == 0
                           && buffer[2] == ADBMS_MSA3) {
                               sc->handler_id = ADBMS_MSA3;
                               /* Initialize as above */
                               cmd = ADBLISTEN(adbaddr, 2);
                               /* listen 2 */
                               buffer[0] = 3;
                               buffer[1] = 0x00;
                               /* Irrelevant, buffer has 0x77 */
                               buffer[2] = 0x07;
                               /*
                                * enable 3 button mode = 0111b,
                                * speed = normal
                                */
                               adb_op_sync((Ptr)buffer, (Ptr)0, (Ptr)0, cmd);
                               sc->sc_buttons = 3;
                               sc->sc_res = 300;
                       } else {
                               /* No special support for this mouse */
                       }
               }
       }
}

/*
* Handle putting the mouse data received from the ADB into
* an ADB event record.
*/
void
ms_adbcomplete(void *buffer, void *data_area, int adb_command)
{
       adb_event_t event;
       struct ams_softc *amsc;
       uint8_t *buf = (uint8_t*)buffer;
       int adbaddr;
#ifdef ADB_DEBUG
       int i;

       if (adb_debug)
               printf("adb: transaction completion\n");
#endif

       adbaddr = ADB_CMDADDR(adb_command);
       amsc = (struct ams_softc *)data_area;

       if ((amsc->handler_id == ADBMS_EXTENDED) && (amsc->sc_devid[0] == 0)) {
               /* massage the data to look like EMP data */
               if ((buf[3] & 0x04) == 0x04)
                       buf[1] &= 0x7f;
               else
                       buf[1] |= 0x80;
               if ((buf[3] & 0x02) == 0x02)
                       buf[2] &= 0x7f;
               else
                       buf[2] |= 0x80;
               if ((buf[3] & 0x01) == 0x01)
                       buf[3] = 0x00;
               else
                       buf[3] = 0x80;
       }

       event.addr = adbaddr;
       event.hand_id = amsc->handler_id;
       event.def_addr = amsc->origaddr;
       event.byte_count = buf[0];
       memcpy(event.bytes, buf + 1, event.byte_count);

#ifdef ADB_DEBUG
       if (adb_debug) {
               printf("ams: from %d at %d (org %d) %u:", event.addr,
                   event.hand_id, event.def_addr, buf[0]);
               for (i = 1; i <= buf[0]; i++)
                       printf(" %x", buf[i]);
               printf("\n");
       }
#endif

       microtime(&event.timestamp);

       ms_processevent(&event, amsc);
}

/*
* Given a mouse ADB event, record the button settings, calculate the
* x- and y-axis motion, and handoff the event to the appropriate subsystem.
*/
static void
ms_processevent(adb_event_t *event, struct ams_softc *amsc)
{
       adb_event_t new_event;
       int i, button_bit, max_byte, mask, buttons;

       new_event = *event;
       buttons = 0;

       /*
        * This should handle both plain ol' Apple mice and mice
        * that claim to support the Extended Apple Mouse Protocol.
        */
       max_byte = event->byte_count;
       button_bit = 1;
       switch (event->hand_id) {
       case ADBMS_USPEED:
       case ADBMS_UCONTOUR:
               /* MicroSpeed mouse and Contour mouse */
               if (max_byte == 4)
                       buttons = (~event->bytes[2]) & 0xff;
               else
                       buttons = (event->bytes[0] & 0x80) ? 0 : 1;
               break;
       case ADBMS_MSA3:
               /* Mouse Systems A3 mouse */
               if (max_byte == 3)
                       buttons = (~event->bytes[2]) & 0x07;
               else
                       buttons = (event->bytes[0] & 0x80) ? 0 : 1;
               break;
       default:
               /* Classic Mouse Protocol (up to 2 buttons) */
               for (i = 0; i < 2; i++, button_bit <<= 1)
                       /* 0 when button down */
                       if (!(event->bytes[i] & 0x80))
                               buttons |= button_bit;
                       else
                               buttons &= ~button_bit;
               /* Extended Protocol (up to 6 more buttons) */
               for (mask = 0x80; i < max_byte;
                    i += (mask == 0x80), button_bit <<= 1) {
                       /* 0 when button down */
                       if (!(event->bytes[i] & mask))
                               buttons |= button_bit;
                       else
                               buttons &= ~button_bit;
                       mask = ((mask >> 4) & 0xf)
                               | ((mask & 0xf) << 4);
               }
               break;
       }
       new_event.u.m.buttons = amsc->sc_mb | buttons;
       new_event.u.m.dx = ((signed int) (event->bytes[1] & 0x3f)) -
                               ((event->bytes[1] & 0x40) ? 64 : 0);
       new_event.u.m.dy = ((signed int) (event->bytes[0] & 0x3f)) -
                               ((event->bytes[0] & 0x40) ? 64 : 0);

       int phys_buttons = new_event.u.m.buttons;
#if NAED > 0
       if (!aed_input(&new_event))
#endif
#if NWSMOUSE > 0
               if (amsc->sc_wsmousedev != NULL)  { /* wsmouse is attached? */
                       if ((phys_buttons != new_event.u.m.buttons) &&
                                                           (phys_buttons & 1))
                               amsc->sc_oldbuttons =
                                   new_event.u.m.buttons & ~1;
                       else if ((phys_buttons == new_event.u.m.buttons) &&
                                                   (amsc->sc_oldbuttons == 0))
                               amsc->sc_oldbuttons = phys_buttons;

                       if (phys_buttons == 0)
                               amsc->sc_oldbuttons = 0;
                       wsmouse_input(amsc->sc_wsmousedev,
                           amsc->sc_oldbuttons,
                           new_event.u.m.dx, -new_event.u.m.dy, 0, 0,
                           WSMOUSE_INPUT_DELTA);
               }
#else
               /* do nothing */ ;
#endif
}

int
ams_enable(void *v)
{
       return 0;
}

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

       switch (cmd) {
       case WSMOUSEIO_GTYPE:
               *(u_int *)data = WSMOUSE_TYPE_ADB;
               return 0;
       }
       return EPASSTHROUGH;
}

void
ams_disable(void *v)
{
}

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.