![[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: }