![[BACK]](/icons/back.gif){kind=icon}
Return to ams.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / adb|
Return to ams.c CVS log | Up to [local] / sys / dev / adb |
1.1 ! nbrk 1: /* $OpenBSD: ams.c,v 1.5 2007/04/10 22:37:17 miod Exp $ */
! 2: /* $NetBSD: ams.c,v 1.11 2000/12/19 03:13:40 tsubai Exp $ */
! 3:
! 4: /*
! 5: * Copyright (C) 1998 Colin Wood
! 6: * All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: * 3. All advertising materials mentioning features or use of this software
! 17: * must display the following acknowledgement:
! 18: * This product includes software developed by Colin Wood.
! 19: * 4. The name of the author may not be used to endorse or promote products
! 20: * derived from this software without specific prior written permission.
! 21: *
! 22: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 23: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 24: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 25: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 26: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 27: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 28: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 29: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 30: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
! 31: * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 32: */
! 33:
! 34: #include <sys/param.h>
! 35: #include <sys/device.h>
! 36: #include <sys/systm.h>
! 37:
! 38: #include <machine/autoconf.h>
! 39:
! 40: #include <dev/wscons/wsconsio.h>
! 41: #include <dev/wscons/wsmousevar.h>
! 42:
! 43: #include <dev/adb/adb.h>
! 44: #include <dev/adb/amsvar.h>
! 45:
! 46: /*
! 47: * Function declarations.
! 48: */
! 49: int amsmatch(struct device *, void *, void *);
! 50: void amsattach(struct device *, struct device *, void *);
! 51:
! 52: /* Driver definition. */
! 53: struct cfattach ams_ca = {
! 54: sizeof(struct ams_softc), amsmatch, amsattach
! 55: };
! 56: /* Driver definition. */
! 57: struct cfdriver ams_cd = {
! 58: NULL, "ams", DV_DULL
! 59: };
! 60:
! 61: int ams_enable(void *);
! 62: int ams_ioctl(void *, u_long, caddr_t, int, struct proc *);
! 63: void ams_disable(void *);
! 64:
! 65: const struct wsmouse_accessops ams_accessops = {
! 66: ams_enable,
! 67: ams_ioctl,
! 68: ams_disable,
! 69: };
! 70:
! 71: void ems_init(struct ams_softc *);
! 72: void ms_adbcomplete(caddr_t buffer, caddr_t data_area, int adb_command);
! 73: void ms_handoff(adb_event_t *event, struct ams_softc *);
! 74: void ms_processevent(adb_event_t *event, struct ams_softc *);
! 75:
! 76: int
! 77: amsmatch(struct device *parent, void *cf, void *aux)
! 78: {
! 79: struct adb_attach_args *aa_args = aux;
! 80:
! 81: if (aa_args->origaddr == ADBADDR_MS)
! 82: return 1;
! 83: else
! 84: return 0;
! 85: }
! 86:
! 87: void
! 88: amsattach(struct device *parent, struct device *self, void *aux)
! 89: {
! 90: ADBSetInfoBlock adbinfo;
! 91: struct ams_softc *sc = (struct ams_softc *)self;
! 92: struct adb_attach_args *aa_args = aux;
! 93: int error;
! 94: struct wsmousedev_attach_args a;
! 95:
! 96: sc->origaddr = aa_args->origaddr;
! 97: sc->adbaddr = aa_args->adbaddr;
! 98: sc->handler_id = aa_args->handler_id;
! 99:
! 100: sc->sc_class = MSCLASS_MOUSE;
! 101: sc->sc_buttons = 1;
! 102: sc->sc_res = 100;
! 103: sc->sc_devid[0] = 0;
! 104: sc->sc_devid[4] = 0;
! 105:
! 106: adbinfo.siServiceRtPtr = (Ptr)ms_adbcomplete;
! 107: adbinfo.siDataAreaAddr = (caddr_t)sc;
! 108:
! 109: ems_init(sc);
! 110:
! 111: /* print out the type of mouse we have */
! 112: printf(": ");
! 113: switch (sc->handler_id) {
! 114: case ADBMS_200DPI:
! 115: sc->sc_res = 200;
! 116: /* FALLTHROUGH */
! 117: case ADBMS_100DPI:
! 118: printf("%d-button, %d dpi mouse\n", sc->sc_buttons,
! 119: (int)(sc->sc_res));
! 120: break;
! 121: case ADBMS_MSA3:
! 122: printf("Mouse Systems A3 mouse, %d-button, %d dpi\n",
! 123: sc->sc_buttons, (int)(sc->sc_res));
! 124: break;
! 125: case ADBMS_USPEED:
! 126: printf("MicroSpeed mouse, default parameters\n");
! 127: break;
! 128: case ADBMS_UCONTOUR:
! 129: printf("Contour mouse, default parameters\n");
! 130: break;
! 131: case ADBMS_TURBO:
! 132: printf("Kensington Turbo Mouse\n");
! 133: break;
! 134: case ADBMS_EXTENDED:
! 135: if (sc->sc_devid[0] == '\0') {
! 136: printf("Logitech ");
! 137: switch (sc->sc_class) {
! 138: case MSCLASS_MOUSE:
! 139: printf("MouseMan (non-EMP) mouse");
! 140: break;
! 141: case MSCLASS_TRACKBALL:
! 142: printf("TrackMan (non-EMP) trackball");
! 143: break;
! 144: default:
! 145: printf("non-EMP relative positioning device");
! 146: break;
! 147: }
! 148: printf("\n");
! 149: } else {
! 150: printf("EMP ");
! 151: switch (sc->sc_class) {
! 152: case MSCLASS_TABLET:
! 153: printf("tablet");
! 154: break;
! 155: case MSCLASS_MOUSE:
! 156: printf("mouse");
! 157: break;
! 158: case MSCLASS_TRACKBALL:
! 159: printf("trackball");
! 160: break;
! 161: case MSCLASS_TRACKPAD:
! 162: printf("trackpad");
! 163: break;
! 164: default:
! 165: printf("unknown device");
! 166: break;
! 167: }
! 168: printf(" <%s> %d-button, %d dpi\n", sc->sc_devid,
! 169: sc->sc_buttons, (int)(sc->sc_res));
! 170: }
! 171: break;
! 172: default:
! 173: printf("relative positioning device (mouse?) (%d)\n",
! 174: sc->handler_id);
! 175: break;
! 176: }
! 177: error = set_adb_info(&adbinfo, sc->adbaddr);
! 178: #ifdef ADB_DEBUG
! 179: if (adb_debug)
! 180: printf("ams: returned %d from set_adb_info\n", error);
! 181: #endif
! 182:
! 183: a.accessops = &ams_accessops;
! 184: a.accesscookie = sc;
! 185: sc->sc_wsmousedev = config_found(self, &a, wsmousedevprint);
! 186: }
! 187:
! 188:
! 189: /*
! 190: * Initialize extended mouse support -- probes devices as described
! 191: * in Inside Macintosh: Devices, Chapter 5 "ADB Manager".
! 192: *
! 193: * Extended Mouse Protocol is documented in TechNote HW1:
! 194: * "ADB - The Untold Story: Space Aliens Ate My Mouse"
! 195: *
! 196: * Supports: Extended Mouse Protocol, MicroSpeed Mouse Deluxe,
! 197: * Mouse Systems A^3 Mouse, Logitech non-EMP MouseMan
! 198: */
! 199: void
! 200: ems_init(struct ams_softc *sc)
! 201: {
! 202: int adbaddr;
! 203: short cmd;
! 204: u_char buffer[9];
! 205:
! 206: adbaddr = sc->adbaddr;
! 207: if (sc->origaddr != ADBADDR_MS)
! 208: return;
! 209: if (sc->handler_id == ADBMS_USPEED ||
! 210: sc->handler_id == ADBMS_UCONTOUR) {
! 211: /* Found MicroSpeed Mouse Deluxe Mac or Contour Mouse */
! 212: cmd = ADBLISTEN(adbaddr, 1);
! 213:
! 214: /*
! 215: * To setup the MicroSpeed or the Contour, it appears
! 216: * that we can send the following command to the mouse
! 217: * and then expect data back in the form:
! 218: * buffer[0] = 4 (bytes)
! 219: * buffer[1], buffer[2] as std. mouse
! 220: * buffer[3] = buffer[4] = 0xff when no buttons
! 221: * are down. When button N down, bit N is clear.
! 222: * buffer[4]'s locking mask enables a
! 223: * click to toggle the button down state--sort of
! 224: * like the "Easy Access" shift/control/etc. keys.
! 225: * buffer[3]'s alternative speed mask enables using
! 226: * different speed when the corr. button is down
! 227: */
! 228: buffer[0] = 4;
! 229: buffer[1] = 0x00; /* Alternative speed */
! 230: buffer[2] = 0x00; /* speed = maximum */
! 231: buffer[3] = 0x10; /* enable extended protocol,
! 232: * lower bits = alt. speed mask
! 233: * = 0000b
! 234: */
! 235: buffer[4] = 0x07; /* Locking mask = 0000b,
! 236: * enable buttons = 0111b
! 237: */
! 238: adb_op_sync((Ptr)buffer, cmd);
! 239:
! 240: sc->sc_buttons = 3;
! 241: sc->sc_res = 200;
! 242: return;
! 243: }
! 244: if (sc->handler_id == ADBMS_TURBO) {
! 245: /* Found Kensington Turbo Mouse */
! 246: static u_char data1[] =
! 247: { 8, 0xe7, 0x8c, 0, 0, 0, 0xff, 0xff, 0x94 };
! 248: static u_char data2[] =
! 249: { 8, 0xa5, 0x14, 0, 0, 0x69, 0xff, 0xff, 0x27 };
! 250:
! 251: buffer[0] = 0;
! 252: adb_op_sync((Ptr)buffer, ADBFLUSH(adbaddr));
! 253:
! 254: adb_op_sync((Ptr)data1, ADBLISTEN(adbaddr, 2));
! 255:
! 256: buffer[0] = 0;
! 257: adb_op_sync((Ptr)buffer, ADBFLUSH(adbaddr));
! 258:
! 259: adb_op_sync((Ptr)data2, ADBLISTEN(adbaddr, 2));
! 260: return;
! 261: }
! 262: if ((sc->handler_id == ADBMS_100DPI) ||
! 263: (sc->handler_id == ADBMS_200DPI)) {
! 264: /* found a mouse */
! 265: cmd = ADBTALK(adbaddr, 3);
! 266: if (adb_op_sync((Ptr)buffer, cmd)) {
! 267: #ifdef ADB_DEBUG
! 268: if (adb_debug)
! 269: printf("adb: ems_init timed out\n");
! 270: #endif
! 271: return;
! 272: }
! 273:
! 274: /* Attempt to initialize Extended Mouse Protocol */
! 275: buffer[2] = 4; /* make handler ID 4 */
! 276: cmd = ADBLISTEN(adbaddr, 3);
! 277: if (adb_op_sync((Ptr)buffer, cmd)) {
! 278: #ifdef ADB_DEBUG
! 279: if (adb_debug)
! 280: printf("adb: ems_init timed out\n");
! 281: #endif
! 282: return;
! 283: }
! 284:
! 285: /*
! 286: * Check to see if successful, if not
! 287: * try to initialize it as other types
! 288: */
! 289: cmd = ADBTALK(adbaddr, 3);
! 290: if (adb_op_sync((Ptr)buffer, cmd) == 0 &&
! 291: buffer[2] == ADBMS_EXTENDED) {
! 292: sc->handler_id = ADBMS_EXTENDED;
! 293: cmd = ADBTALK(adbaddr, 1);
! 294: if (adb_op_sync((Ptr)buffer, cmd)) {
! 295: #ifdef ADB_DEBUG
! 296: if (adb_debug)
! 297: printf("adb: ems_init timed out\n");
! 298: #endif
! 299: } else if (buffer[0] == 8) {
! 300: /* we have a true EMP device */
! 301: sc->sc_class = buffer[7];
! 302: sc->sc_buttons = buffer[8];
! 303: sc->sc_res = (int)*(short *)&buffer[5];
! 304: bcopy(&(buffer[1]), sc->sc_devid, 4);
! 305: } else if (buffer[1] == 0x9a &&
! 306: ((buffer[2] == 0x20) || (buffer[2] == 0x21))) {
! 307: /*
! 308: * Set up non-EMP Mouseman/Trackman to put
! 309: * button bits in 3rd byte instead of sending
! 310: * via pseudo keyboard device.
! 311: */
! 312: cmd = ADBLISTEN(adbaddr, 1);
! 313: buffer[0]=2;
! 314: buffer[1]=0x00;
! 315: buffer[2]=0x81;
! 316: adb_op_sync((Ptr)buffer, cmd);
! 317:
! 318: cmd = ADBLISTEN(adbaddr, 1);
! 319: buffer[0]=2;
! 320: buffer[1]=0x01;
! 321: buffer[2]=0x81;
! 322: adb_op_sync((Ptr)buffer, cmd);
! 323:
! 324: cmd = ADBLISTEN(adbaddr, 1);
! 325: buffer[0]=2;
! 326: buffer[1]=0x02;
! 327: buffer[2]=0x81;
! 328: adb_op_sync((Ptr)buffer, cmd);
! 329:
! 330: cmd = ADBLISTEN(adbaddr, 1);
! 331: buffer[0]=2;
! 332: buffer[1]=0x03;
! 333: buffer[2]=0x38;
! 334: adb_op_sync((Ptr)buffer, cmd);
! 335:
! 336: sc->sc_buttons = 3;
! 337: sc->sc_res = 400;
! 338: if (buffer[2] == 0x21)
! 339: sc->sc_class = MSCLASS_TRACKBALL;
! 340: else
! 341: sc->sc_class = MSCLASS_MOUSE;
! 342: } else
! 343: /* unknown device? */;
! 344: } else {
! 345: /* Attempt to initialize as an A3 mouse */
! 346: buffer[2] = 0x03; /* make handler ID 3 */
! 347: cmd = ADBLISTEN(adbaddr, 3);
! 348: if (adb_op_sync((Ptr)buffer, cmd)) {
! 349: #ifdef ADB_DEBUG
! 350: if (adb_debug)
! 351: printf("adb: ems_init timed out\n");
! 352: #endif
! 353: return;
! 354: }
! 355:
! 356: /*
! 357: * Check to see if successful, if not
! 358: * try to initialize it as other types
! 359: */
! 360: cmd = ADBTALK(adbaddr, 3);
! 361: if (adb_op_sync((Ptr)buffer, cmd) == 0
! 362: && buffer[2] == ADBMS_MSA3) {
! 363: sc->handler_id = ADBMS_MSA3;
! 364: /* Initialize as above */
! 365: cmd = ADBLISTEN(adbaddr, 2);
! 366: /* listen 2 */
! 367: buffer[0] = 3;
! 368: buffer[1] = 0x00;
! 369: /* Irrelevant, buffer has 0x77 */
! 370: buffer[2] = 0x07;
! 371: /*
! 372: * enable 3 button mode = 0111b,
! 373: * speed = normal
! 374: */
! 375: adb_op_sync((Ptr)buffer, cmd);
! 376: sc->sc_buttons = 3;
! 377: sc->sc_res = 300;
! 378: } else {
! 379: /* No special support for this mouse */
! 380: }
! 381: }
! 382: }
! 383: }
! 384:
! 385: /*
! 386: * Handle putting the mouse data received from the ADB into
! 387: * an ADB event record.
! 388: */
! 389: void
! 390: ms_adbcomplete(caddr_t buffer, caddr_t data_area, int adb_command)
! 391: {
! 392: adb_event_t event;
! 393: struct ams_softc *sc;
! 394: int adbaddr;
! 395: #ifdef ADB_DEBUG
! 396: int i;
! 397:
! 398: if (adb_debug)
! 399: printf("adb: transaction completion\n");
! 400: #endif
! 401:
! 402: adbaddr = ADB_CMDADDR(adb_command);
! 403: sc = (struct ams_softc *)data_area;
! 404:
! 405: if ((sc->handler_id == ADBMS_EXTENDED) && (sc->sc_devid[0] == 0)) {
! 406: /* massage the data to look like EMP data */
! 407: if ((buffer[3] & 0x04) == 0x04)
! 408: buffer[1] &= 0x7f;
! 409: else
! 410: buffer[1] |= 0x80;
! 411: if ((buffer[3] & 0x02) == 0x02)
! 412: buffer[2] &= 0x7f;
! 413: else
! 414: buffer[2] |= 0x80;
! 415: if ((buffer[3] & 0x01) == 0x01)
! 416: buffer[3] = 0x00;
! 417: else
! 418: buffer[3] = 0x80;
! 419: }
! 420:
! 421: event.byte_count = buffer[0];
! 422: memcpy(event.bytes, buffer + 1, event.byte_count);
! 423:
! 424: #ifdef ADB_DEBUG
! 425: if (adb_debug) {
! 426: printf("ams: from %d at %d (org %d) %d:", adbaddr,
! 427: sc->handler_id, sc->origaddr, buffer[0]);
! 428: for (i = 1; i <= buffer[0]; i++)
! 429: printf(" %x", buffer[i]);
! 430: printf("\n");
! 431: }
! 432: #endif
! 433:
! 434: ms_processevent(&event, sc);
! 435: }
! 436:
! 437: /*
! 438: * Given a mouse ADB event, record the button settings, calculate the
! 439: * x- and y-axis motion, and handoff the event to the appropriate subsystem.
! 440: */
! 441: void
! 442: ms_processevent(adb_event_t *event, struct ams_softc *sc)
! 443: {
! 444: int i, button_bit, max_byte, mask;
! 445: int dx, dy, buttons;
! 446:
! 447: buttons = 0;
! 448:
! 449: /*
! 450: * This should handle both plain ol' Apple mice and mice
! 451: * that claim to support the Extended Apple Mouse Protocol.
! 452: */
! 453: max_byte = event->byte_count;
! 454: button_bit = 1;
! 455: switch (sc->handler_id) {
! 456: case ADBMS_USPEED:
! 457: case ADBMS_UCONTOUR:
! 458: /* MicroSpeed mouse and Contour mouse */
! 459: if (max_byte == 4)
! 460: buttons = (~event->bytes[2]) & 0xff;
! 461: else
! 462: buttons = (event->bytes[0] & 0x80) ? 0 : 1;
! 463: break;
! 464: case ADBMS_MSA3:
! 465: /* Mouse Systems A3 mouse */
! 466: if (max_byte == 3)
! 467: buttons = (~event->bytes[2]) & 0x07;
! 468: else
! 469: buttons = (event->bytes[0] & 0x80) ? 0 : 1;
! 470: break;
! 471: default:
! 472: /* Classic Mouse Protocol (up to 2 buttons) */
! 473: for (i = 0; i < 2; i++, button_bit <<= 1)
! 474: /* 0 when button down */
! 475: if (!(event->bytes[i] & 0x80))
! 476: buttons |= button_bit;
! 477: else
! 478: buttons &= ~button_bit;
! 479: /* Extended Protocol (up to 6 more buttons) */
! 480: if (sc->sc_class == MSCLASS_MOUSE)
! 481: for (mask = 0x80; i < max_byte;
! 482: i += (mask == 0x80), button_bit <<= 1) {
! 483: /* 0 when button down */
! 484: if (!(event->bytes[i] & mask))
! 485: buttons |= button_bit;
! 486: else
! 487: buttons &= ~button_bit;
! 488: mask = ((mask >> 4) & 0xf)
! 489: | ((mask & 0xf) << 4);
! 490: }
! 491: break;
! 492: }
! 493:
! 494: buttons |= sc->sc_mb;
! 495: dx = ((signed int) (event->bytes[1] & 0x3f)) -
! 496: ((event->bytes[1] & 0x40) ? 64 : 0);
! 497: dy = ((signed int) (event->bytes[0] & 0x3f)) -
! 498: ((event->bytes[0] & 0x40) ? 64 : 0);
! 499:
! 500: if (sc->sc_wsmousedev)
! 501: wsmouse_input(sc->sc_wsmousedev, buttons, dx, -dy, 0, 0,
! 502: WSMOUSE_INPUT_DELTA);
! 503: }
! 504:
! 505: int
! 506: ams_enable(void *v)
! 507: {
! 508: return 0;
! 509: }
! 510:
! 511: int
! 512: ams_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p)
! 513: {
! 514: switch (cmd) {
! 515: case WSMOUSEIO_GTYPE:
! 516: *(u_int *)data = WSMOUSE_TYPE_ADB;
! 517: return (0);
! 518: }
! 519:
! 520: return -1;
! 521: }
! 522:
! 523: void
! 524: ams_disable(void *v)
! 525: {
! 526: }