![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kd_mouse.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at|
Return to kd_mouse.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at |
1.1 ! root 1: /* ! 2: * Mach Operating System ! 3: * Copyright (c) 1991,1990,1989 Carnegie Mellon University ! 4: * All Rights Reserved. ! 5: * ! 6: * Permission to use, copy, modify and distribute this software and its ! 7: * documentation is hereby granted, provided that both the copyright ! 8: * notice and this permission notice appear in all copies of the ! 9: * software, derivative works or modified versions, and any portions ! 10: * thereof, and that both notices appear in supporting documentation. ! 11: * ! 12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" ! 13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR ! 14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. ! 15: * ! 16: * Carnegie Mellon requests users of this software to return to ! 17: * ! 18: * Software Distribution Coordinator or [email protected] ! 19: * School of Computer Science ! 20: * Carnegie Mellon University ! 21: * Pittsburgh PA 15213-3890 ! 22: * ! 23: * any improvements or extensions that they make and grant Carnegie Mellon ! 24: * the rights to redistribute these changes. ! 25: */ ! 26: /* ********************************************************************** ! 27: File: kd_mouse.c ! 28: Description: mouse driver as part of keyboard/display driver ! 29: ! 30: $ Header: $ ! 31: ! 32: Copyright Ing. C. Olivetti & C. S.p.A. 1989. ! 33: All rights reserved. ! 34: ********************************************************************** */ ! 35: /* ! 36: Copyright 1988, 1989 by Olivetti Advanced Technology Center, Inc., ! 37: Cupertino, California. ! 38: ! 39: All Rights Reserved ! 40: ! 41: Permission to use, copy, modify, and distribute this software and ! 42: its documentation for any purpose and without fee is hereby ! 43: granted, provided that the above copyright notice appears in all ! 44: copies and that both the copyright notice and this permission notice ! 45: appear in supporting documentation, and that the name of Olivetti ! 46: not be used in advertising or publicity pertaining to distribution ! 47: of the software without specific, written prior permission. ! 48: ! 49: OLIVETTI DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE ! 50: INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, ! 51: IN NO EVENT SHALL OLIVETTI BE LIABLE FOR ANY SPECIAL, INDIRECT, OR ! 52: CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM ! 53: LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT, ! 54: NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUR OF OR IN CONNECTION ! 55: WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ! 56: */ ! 57: ! 58: /* ! 59: * Hacked up support for serial mouse connected to COM1, using Mouse ! 60: * Systems 5-byte protocol at 1200 baud. This should work for ! 61: * Mouse Systems, SummaMouse, and Logitek C7 mice. ! 62: * ! 63: * The interface provided by /dev/mouse is a series of events as ! 64: * described in i386at/kd.h. ! 65: */ ! 66: ! 67: #include <mach/boolean.h> ! 68: #include <sys/types.h> ! 69: #ifdef MACH_KERNEL ! 70: #include <device/errno.h> ! 71: #include <device/io_req.h> ! 72: #else MACH_KERNEL ! 73: #include <sys/file.h> ! 74: #include <sys/errno.h> ! 75: #include <kern/thread.h> ! 76: #include <sys/user.h> ! 77: #include <sys/proc.h> ! 78: #include <sys/kernel.h> ! 79: #include <sys/ioctl.h> ! 80: #include <sys/tty.h> ! 81: #endif MACH_KERNEL ! 82: #include <i386/ipl.h> ! 83: #include <chips/busses.h> ! 84: #include <i386at/kd.h> ! 85: #include <i386at/kd_queue.h> ! 86: #include <i386at/i8250.h> ! 87: ! 88: static int (*oldvect)(); /* old interrupt vector */ ! 89: static int oldunit; ! 90: static spl_t oldspl; ! 91: extern struct bus_device *cominfo[]; ! 92: ! 93: kd_event_queue mouse_queue; /* queue of mouse events */ ! 94: boolean_t mouse_in_use = FALSE; ! 95: #ifdef MACH_KERNEL ! 96: queue_head_t mouse_read_queue = { &mouse_read_queue, &mouse_read_queue }; ! 97: #else MACH_KERNEL ! 98: struct proc *mouse_sel = 0; /* selecting process, if any */ ! 99: short mousepgrp = 0; /* process group leader when dev is open */ ! 100: #endif MACH_KERNEL ! 101: ! 102: #ifdef MACH_KERNEL ! 103: #else MACH_KERNEL ! 104: int mouseflag = 0; ! 105: #define MOUSE_COLL 1 /* select collision */ ! 106: #define MOUSE_ASYNC 2 /* user wants asynch notification */ ! 107: #define MOUSE_NBIO 4 /* user wants non-blocking I/O */ ! 108: #endif MACH_KERNEL ! 109: ! 110: /* ! 111: * The state of the 3 buttons is encoded in the low-order 3 bits (both ! 112: * here and in other variables in the driver). ! 113: */ ! 114: u_char lastbuttons; /* previous state of mouse buttons */ ! 115: #define MOUSE_UP 1 ! 116: #define MOUSE_DOWN 0 ! 117: #define MOUSE_ALL_UP 0x7 ! 118: ! 119: int mouseintr(); ! 120: void mouse_enqueue(); ! 121: int mouse_baud = BCNT1200; ! 122: ! 123: boolean_t mouse_char_cmd = FALSE; /* mouse response is to cmd */ ! 124: boolean_t mouse_char_wanted = FALSE; /* want mouse response */ ! 125: boolean_t mouse_char_in = FALSE; /* have mouse response */ ! 126: unsigned char mouse_char; /* mouse response */ ! 127: ! 128: ! 129: /* ! 130: * init_mouse_hw - initialize the serial port. ! 131: */ ! 132: init_mouse_hw(unit, mode) ! 133: { ! 134: caddr_t base_addr = (caddr_t)cominfo[unit]->address; ! 135: ! 136: outb(base_addr + RIE, 0); ! 137: outb(base_addr + RLC, LCDLAB); ! 138: outb(base_addr + RDLSB, mouse_baud & 0xff); ! 139: outb(base_addr + RDMSB, (mouse_baud >> 8) & 0xff); ! 140: outb(base_addr + RLC, mode); ! 141: outb(base_addr + RMC, MCDTR | MCRTS | MCOUT2); ! 142: outb(base_addr + RIE, IERD | IELS); ! 143: } ! 144: ! 145: ! 146: /* ! 147: * mouseopen - Verify that the request is read-only, initialize, ! 148: * and remember process group leader. ! 149: */ ! 150: /* ! 151: * Low 3 bits of minor are the com port #. ! 152: * The high 5 bits of minor are the mouse type ! 153: */ ! 154: #define MOUSE_SYSTEM_MOUSE 0 ! 155: #define MICROSOFT_MOUSE 1 ! 156: #define IBM_MOUSE 2 ! 157: #define NO_MOUSE 3 ! 158: #define LOGITECH_TRACKMAN 4 ! 159: #define MICROSOFT_MOUSE7 5 ! 160: static int mouse_type; ! 161: static int mousebufsize; ! 162: static int mousebufindex = 0; ! 163: int track_man[10]; ! 164: ! 165: /*ARGSUSED*/ ! 166: mouseopen(dev, flags) ! 167: dev_t dev; ! 168: int flags; ! 169: { ! 170: #ifdef MACH_KERNEL ! 171: #else MACH_KERNEL ! 172: if (flags & FWRITE) ! 173: return(ENODEV); ! 174: #endif MACH_KERNEL ! 175: if (mouse_in_use) ! 176: return(EBUSY); ! 177: mouse_in_use = TRUE; /* locking? */ ! 178: kdq_reset(&mouse_queue); ! 179: lastbuttons = MOUSE_ALL_UP; ! 180: #ifdef MACH_KERNEL ! 181: #else MACH_KERNEL ! 182: mousepgrp = u.u_procp->p_pgrp; ! 183: #endif MACH_KERNEL ! 184: ! 185: switch (mouse_type = ((minor(dev) & 0xf8) >> 3)) { ! 186: case MICROSOFT_MOUSE7: ! 187: mousebufsize = 3; ! 188: serial_mouse_open(dev); ! 189: init_mouse_hw(dev&7, LC7); ! 190: case MICROSOFT_MOUSE: ! 191: mousebufsize = 3; ! 192: serial_mouse_open(dev); ! 193: init_mouse_hw(dev&7, LC8); ! 194: break; ! 195: case MOUSE_SYSTEM_MOUSE: ! 196: mousebufsize = 5; ! 197: serial_mouse_open(dev); ! 198: init_mouse_hw(dev&7, LC8); ! 199: break; ! 200: case LOGITECH_TRACKMAN: ! 201: mousebufsize = 3; ! 202: serial_mouse_open(dev); ! 203: init_mouse_hw(dev&7, LC7); ! 204: track_man[0] = comgetc(dev&7); ! 205: track_man[1] = comgetc(dev&7); ! 206: if (track_man[0] != 0x4d && ! 207: track_man[1] != 0x33) { ! 208: printf("LOGITECH_TRACKMAN: NOT M3"); ! 209: } ! 210: break; ! 211: case IBM_MOUSE: ! 212: mousebufsize = 3; ! 213: kd_mouse_open(dev, 12); ! 214: ibm_ps2_mouse_open(dev); ! 215: break; ! 216: case NO_MOUSE: ! 217: break; ! 218: } ! 219: mousebufindex = 0; ! 220: return(0); ! 221: } ! 222: ! 223: serial_mouse_open(dev) ! 224: { ! 225: int unit = minor(dev) & 0x7; ! 226: int mouse_pic = cominfo[unit]->sysdep1; ! 227: ! 228: spl_t s = splhi(); /* disable interrupts */ ! 229: ! 230: oldvect = ivect[mouse_pic]; ! 231: ivect[mouse_pic] = mouseintr; ! 232: ! 233: oldunit = iunit[mouse_pic]; ! 234: iunit[mouse_pic] = unit; ! 235: ! 236: /* XXX other arrays to init? */ ! 237: splx(s); /* XXX - should come after init? */ ! 238: } ! 239: ! 240: int mouse_packets = 0; ! 241: kd_mouse_open(dev, mouse_pic) ! 242: { ! 243: spl_t s = splhi(); /* disable interrupts */ ! 244: extern int kdintr(); ! 245: ! 246: oldvect = ivect[mouse_pic]; ! 247: ivect[mouse_pic] = kdintr; ! 248: oldspl = intpri[mouse_pic]; ! 249: intpri[mouse_pic] = SPL6; ! 250: form_pic_mask(); ! 251: splx(s); ! 252: } ! 253: ! 254: /* ! 255: * mouseclose - Disable interrupts on the serial port, reset driver flags, ! 256: * and restore the serial port interrupt vector. ! 257: */ ! 258: mouseclose(dev, flags) ! 259: { ! 260: switch (mouse_type) { ! 261: case MICROSOFT_MOUSE: ! 262: case MICROSOFT_MOUSE7: ! 263: case MOUSE_SYSTEM_MOUSE: ! 264: case LOGITECH_TRACKMAN: ! 265: serial_mouse_close(dev); ! 266: break; ! 267: case IBM_MOUSE: ! 268: ibm_ps2_mouse_close(dev); ! 269: kd_mouse_close(dev, 12); ! 270: {int i = 20000; for (;i--;); } ! 271: kd_mouse_drain(); ! 272: break; ! 273: case NO_MOUSE: ! 274: break; ! 275: } ! 276: ! 277: kdq_reset(&mouse_queue); /* paranoia */ ! 278: mouse_in_use = FALSE; ! 279: #ifdef MACH_KERNEL ! 280: #else MACH_KERNEL ! 281: mousepgrp = 0; ! 282: mouseflag = 0; ! 283: mouse_sel = 0; ! 284: #endif MACH_KERNEL ! 285: } ! 286: ! 287: /*ARGSUSED*/ ! 288: serial_mouse_close(dev, flags) ! 289: dev_t dev; ! 290: int flags; ! 291: { ! 292: spl_t o_pri = splhi(); /* mutex with open() */ ! 293: int unit = minor(dev) & 0x7; ! 294: int mouse_pic = cominfo[unit]->sysdep1; ! 295: caddr_t base_addr = (caddr_t)cominfo[unit]->address; ! 296: ! 297: assert(ivect[mouse_pic] == mouseintr); ! 298: outb(base_addr + RIE, 0); /* disable serial port */ ! 299: outb(base_addr + RMC, 0); /* no rts */ ! 300: ivect[mouse_pic] = oldvect; ! 301: iunit[mouse_pic] = oldunit; ! 302: ! 303: (void)splx(o_pri); ! 304: } ! 305: ! 306: kd_mouse_close(dev, mouse_pic) ! 307: { ! 308: spl_t s = splhi(); ! 309: ! 310: ivect[mouse_pic] = oldvect; ! 311: intpri[mouse_pic] = oldspl; ! 312: form_pic_mask(); ! 313: splx(s); ! 314: } ! 315: ! 316: #ifdef MACH_KERNEL ! 317: #else MACH_KERNEL ! 318: /* ! 319: * mouseioctl - handling for asynch & non-blocking I/O. ! 320: */ ! 321: ! 322: /*ARGSUSED*/ ! 323: mouseioctl(dev, cmd, data, flag) ! 324: dev_t dev; ! 325: int cmd; ! 326: caddr_t data; ! 327: int flag; ! 328: { ! 329: int s = SPLKD(); ! 330: int err = 0; ! 331: ! 332: switch (cmd) { ! 333: case FIONBIO: ! 334: if (*(int *)data) ! 335: mouseflag |= MOUSE_NBIO; ! 336: else ! 337: mouseflag &= ~MOUSE_NBIO; ! 338: break; ! 339: case FIOASYNC: ! 340: if (*(int *)data) ! 341: mouseflag |= MOUSE_ASYNC; ! 342: else ! 343: mouseflag &= ~MOUSE_ASYNC; ! 344: break; ! 345: default: ! 346: err = ENOTTY; ! 347: break; ! 348: } ! 349: ! 350: splx(s); ! 351: return(err); ! 352: } ! 353: ! 354: ! 355: /* ! 356: * mouseselect - check for pending events, etc. ! 357: */ ! 358: ! 359: /*ARGSUSED*/ ! 360: mouseselect(dev, rw) ! 361: { ! 362: int s = SPLKD(); ! 363: ! 364: if (!kdq_empty(&mouse_queue)) { ! 365: splx(s); ! 366: return(1); ! 367: } ! 368: ! 369: if (mouse_sel) ! 370: mouseflag |= MOUSE_COLL; ! 371: else ! 372: mouse_sel = (struct proc *)current_thread(); ! 373: /* eeeyuck */ ! 374: ! 375: splx(s); ! 376: return(0); ! 377: } ! 378: #endif MACH_KERNEL ! 379: ! 380: /* ! 381: * mouseread - dequeue and return any queued events. ! 382: */ ! 383: #ifdef MACH_KERNEL ! 384: boolean_t mouse_read_done(); /* forward */ ! 385: ! 386: mouseread(dev, ior) ! 387: dev_t dev; ! 388: register io_req_t ior; ! 389: { ! 390: register int err, count; ! 391: register spl_t s; ! 392: ! 393: err = device_read_alloc(ior, (vm_size_t)ior->io_count); ! 394: if (err != KERN_SUCCESS) ! 395: return (err); ! 396: ! 397: s = SPLKD(); ! 398: if (kdq_empty(&mouse_queue)) { ! 399: if (ior->io_mode & D_NOWAIT) { ! 400: splx(s); ! 401: return (D_WOULD_BLOCK); ! 402: } ! 403: ior->io_done = mouse_read_done; ! 404: enqueue_tail(&mouse_read_queue, (queue_entry_t)ior); ! 405: splx(s); ! 406: return (D_IO_QUEUED); ! 407: } ! 408: count = 0; ! 409: while (!kdq_empty(&mouse_queue) && count < ior->io_count) { ! 410: register kd_event *ev; ! 411: ! 412: ev = kdq_get(&mouse_queue); ! 413: *(kd_event *)(&ior->io_data[count]) = *ev; ! 414: count += sizeof(kd_event); ! 415: } ! 416: splx(s); ! 417: ior->io_residual = ior->io_count - count; ! 418: return (D_SUCCESS); ! 419: } ! 420: ! 421: boolean_t mouse_read_done(ior) ! 422: register io_req_t ior; ! 423: { ! 424: register int count; ! 425: register spl_t s; ! 426: ! 427: s = SPLKD(); ! 428: if (kdq_empty(&mouse_queue)) { ! 429: ior->io_done = mouse_read_done; ! 430: enqueue_tail(&mouse_read_queue, (queue_entry_t)ior); ! 431: splx(s); ! 432: return (FALSE); ! 433: } ! 434: ! 435: count = 0; ! 436: while (!kdq_empty(&mouse_queue) && count < ior->io_count) { ! 437: register kd_event *ev; ! 438: ! 439: ev = kdq_get(&mouse_queue); ! 440: *(kd_event *)(&ior->io_data[count]) = *ev; ! 441: count += sizeof(kd_event); ! 442: } ! 443: splx(s); ! 444: ! 445: ior->io_residual = ior->io_count - count; ! 446: ds_read_done(ior); ! 447: ! 448: return (TRUE); ! 449: } ! 450: ! 451: #else MACH_KERNEL ! 452: /*ARGSUSED*/ ! 453: mouseread(dev, uio) ! 454: dev_t dev; ! 455: struct uio *uio; ! 456: { ! 457: int s = SPLKD(); ! 458: int err = 0; ! 459: kd_event *ev; ! 460: int i; ! 461: char *cp; ! 462: ! 463: if (kdq_empty(&mouse_queue)) ! 464: if (mouseflag & MOUSE_NBIO) { ! 465: err = EWOULDBLOCK; ! 466: goto done; ! 467: } else ! 468: while (kdq_empty(&mouse_queue)) { ! 469: splx(s); ! 470: sleep((caddr_t)&mouse_queue, TTIPRI); ! 471: s = SPLKD(); ! 472: } ! 473: ! 474: while (!kdq_empty(&mouse_queue) && uio->uio_resid >= sizeof(kd_event)) { ! 475: ev = kdq_get(&mouse_queue); ! 476: for (cp = (char *)ev, i = 0; i < sizeof(kd_event); ! 477: ++i, ++cp) { ! 478: err = ureadc(*cp, uio); ! 479: if (err) ! 480: goto done; ! 481: } ! 482: } ! 483: ! 484: done: ! 485: splx(s); ! 486: return(err); ! 487: } ! 488: #endif MACH_KERNEL ! 489: ! 490: ! 491: /* ! 492: * mouseintr - Get a byte and pass it up for handling. Called at SPLKD. ! 493: */ ! 494: mouseintr(unit) ! 495: { ! 496: caddr_t base_addr = (caddr_t)cominfo[unit]->address; ! 497: unsigned char id, ls; ! 498: ! 499: /* get reason for interrupt and line status */ ! 500: id = inb(base_addr + RID); ! 501: ls = inb(base_addr + RLS); ! 502: ! 503: /* handle status changes */ ! 504: if (id == IDLS) { ! 505: if (ls & LSDR) { ! 506: inb(base_addr + RDAT); /* flush bad character */ ! 507: } ! 508: return; /* ignore status change */ ! 509: } ! 510: ! 511: if (id & IDRD) { ! 512: mouse_handle_byte((u_char)(inb(base_addr + RDAT) & 0xff)); ! 513: } ! 514: } ! 515: ! 516: ! 517: /* ! 518: * handle_byte - Accumulate bytes until we have an entire packet. ! 519: * If the mouse has moved or any of the buttons have changed state (up ! 520: * or down), enqueue the corresponding events. ! 521: * Called at SPLKD. ! 522: * XXX - magic numbers. ! 523: */ ! 524: int show_mouse_byte = 0; ! 525: /* ! 526: X down; middle down; middle up; X up 50 0 0; 50 0 0 22; 50 0 0 02; 40 0 0 ! 527: X down; middle down; X up; middle up 50 0 0; 50 0 0 22; 40 0 0 22; 40 0 0 2 ! 528: * ! 529: * The trick here is that all the while the middle button is down you get 4 byte ! 530: * packets with the last byte 0x22. When the middle button goes up you get a ! 531: * last packet with 0x02. ! 532: */ ! 533: int lastgitech = 0x40; /* figure whether the first 3 bytes imply */ ! 534: /* its time to expect a fourth */ ! 535: int fourthgitech = 0; /* look for the 4th byte; we must process it */ ! 536: int middlegitech = 0; /* what should the middle button be */ ! 537: ! 538: #define MOUSEBUFSIZE 5 /* num bytes def'd by protocol */ ! 539: static u_char mousebuf[MOUSEBUFSIZE]; /* 5-byte packet from mouse */ ! 540: ! 541: mouse_handle_byte(ch) ! 542: u_char ch; ! 543: { ! 544: if (show_mouse_byte) { ! 545: printf("%x(%c) ", ch, ch); ! 546: } ! 547: ! 548: if (mouse_char_cmd) { ! 549: /* ! 550: * Mouse character is response to command ! 551: */ ! 552: mouse_char = ch; ! 553: mouse_char_in = TRUE; ! 554: if (mouse_char_wanted) { ! 555: mouse_char_wanted = FALSE; ! 556: wakeup(&mouse_char); ! 557: } ! 558: return; ! 559: } ! 560: ! 561: if (mousebufindex == 0) { ! 562: switch (mouse_type) { ! 563: case MICROSOFT_MOUSE7: ! 564: if ((ch & 0x40) != 0x40) ! 565: return; ! 566: break; ! 567: case MICROSOFT_MOUSE: ! 568: if ((ch & 0xc0) != 0xc0) ! 569: return; ! 570: break; ! 571: case MOUSE_SYSTEM_MOUSE: ! 572: if ((ch & 0xf8) != 0x80) ! 573: return; ! 574: break; ! 575: case LOGITECH_TRACKMAN: ! 576: if (fourthgitech == 1) { ! 577: fourthgitech = 0; ! 578: if (ch & 0xf0) ! 579: middlegitech = 0x4; ! 580: else ! 581: middlegitech = 0x0; ! 582: mouse_packet_microsoft_mouse(mousebuf); ! 583: return; ! 584: } else if ((ch & 0xc0) != 0x40) ! 585: return; ! 586: break; ! 587: case IBM_MOUSE: ! 588: break; ! 589: } ! 590: } ! 591: ! 592: mousebuf[mousebufindex++] = ch; ! 593: if (mousebufindex < mousebufsize) ! 594: return; ! 595: ! 596: /* got a packet */ ! 597: mousebufindex = 0; ! 598: ! 599: switch (mouse_type) { ! 600: case MICROSOFT_MOUSE7: ! 601: case MICROSOFT_MOUSE: ! 602: mouse_packet_microsoft_mouse(mousebuf); ! 603: break; ! 604: case MOUSE_SYSTEM_MOUSE: ! 605: mouse_packet_mouse_system_mouse(mousebuf); ! 606: break; ! 607: case LOGITECH_TRACKMAN: ! 608: if ( mousebuf[1] || mousebuf[2] || ! 609: mousebuf[0] != lastgitech) { ! 610: mouse_packet_microsoft_mouse(mousebuf); ! 611: lastgitech = mousebuf[0] & 0xf0; ! 612: } else { ! 613: fourthgitech = 1; ! 614: } ! 615: break; ! 616: case IBM_MOUSE: ! 617: mouse_packet_ibm_ps2_mouse(mousebuf); ! 618: break; ! 619: } ! 620: } ! 621: ! 622: mouse_packet_mouse_system_mouse(mousebuf) ! 623: u_char mousebuf[MOUSEBUFSIZE]; ! 624: { ! 625: u_char buttons, buttonchanges; ! 626: struct mouse_motion moved; ! 627: ! 628: buttons = mousebuf[0] & 0x7; /* get current state of buttons */ ! 629: buttonchanges = buttons ^ lastbuttons; ! 630: moved.mm_deltaX = (char)mousebuf[1] + (char)mousebuf[3]; ! 631: moved.mm_deltaY = (char)mousebuf[2] + (char)mousebuf[4]; ! 632: ! 633: if (moved.mm_deltaX != 0 || moved.mm_deltaY != 0) ! 634: mouse_moved(moved); ! 635: ! 636: if (buttonchanges != 0) { ! 637: lastbuttons = buttons; ! 638: if (buttonchanges & 1) ! 639: mouse_button(MOUSE_RIGHT, buttons & 1); ! 640: if (buttonchanges & 2) ! 641: mouse_button(MOUSE_MIDDLE, (buttons & 2) >> 1); ! 642: if (buttonchanges & 4) ! 643: mouse_button(MOUSE_LEFT, (buttons & 4) >> 2); ! 644: } ! 645: } ! 646: ! 647: /* same as above for microsoft mouse */ ! 648: /* ! 649: * 3 byte microsoft format used ! 650: * ! 651: * 7 6 5 4 3 2 1 0 ! 652: * 1 1 L R Y7 Y6 X7 X6 ! 653: * 1 0 X5 X4 X3 X3 X1 X0 ! 654: * 1 0 Y5 Y4 Y3 Y2 Y1 Y0 ! 655: * ! 656: */ ! 657: mouse_packet_microsoft_mouse(mousebuf) ! 658: u_char mousebuf[MOUSEBUFSIZE]; ! 659: { ! 660: u_char buttons, buttonchanges; ! 661: struct mouse_motion moved; ! 662: ! 663: buttons = ((mousebuf[0] & 0x30) >> 4); ! 664: buttons |= middlegitech; ! 665: /* get current state of buttons */ ! 666: #ifdef gross_hack ! 667: if (buttons == 0x03) /* both buttons down */ ! 668: buttons = 0x04; ! 669: #endif /* gross_hack */ ! 670: buttons = (~buttons) & 0x07; /* convert to not pressed */ ! 671: ! 672: buttonchanges = buttons ^ lastbuttons; ! 673: moved.mm_deltaX = ((mousebuf[0] & 0x03) << 6) | (mousebuf[1] & 0x3F); ! 674: moved.mm_deltaY = ((mousebuf[0] & 0x0c) << 4) | (mousebuf[2] & 0x3F); ! 675: if (moved.mm_deltaX & 0x80) /* negative, in fact */ ! 676: moved.mm_deltaX = moved.mm_deltaX - 0x100; ! 677: if (moved.mm_deltaY & 0x80) /* negative, in fact */ ! 678: moved.mm_deltaY = moved.mm_deltaY - 0x100; ! 679: /* and finally the Y orientation is different for the microsoft mouse */ ! 680: moved.mm_deltaY = -moved.mm_deltaY; ! 681: ! 682: if (moved.mm_deltaX != 0 || moved.mm_deltaY != 0) ! 683: mouse_moved(moved); ! 684: ! 685: if (buttonchanges != 0) { ! 686: lastbuttons = buttons; ! 687: if (buttonchanges & 1) ! 688: mouse_button(MOUSE_RIGHT, (buttons & 1) ? ! 689: MOUSE_UP : MOUSE_DOWN); ! 690: if (buttonchanges & 2) ! 691: mouse_button(MOUSE_LEFT, (buttons & 2) ? ! 692: MOUSE_UP : MOUSE_DOWN); ! 693: if (buttonchanges & 4) ! 694: mouse_button(MOUSE_MIDDLE, (buttons & 4) ? ! 695: MOUSE_UP : MOUSE_DOWN); ! 696: } ! 697: } ! 698: ! 699: /* ! 700: * AUX device (PS2) open/close ! 701: */ ! 702: ! 703: /* ! 704: * Write character to mouse. Called at spltty. ! 705: */ ! 706: void kd_mouse_write( ! 707: unsigned char ch) ! 708: { ! 709: while (inb(K_STATUS) & K_IBUF_FUL) ! 710: continue; /* wait for 'input' port empty */ ! 711: outb(K_CMD, 0xd4); /* send next character to mouse */ ! 712: ! 713: while (inb(K_STATUS) & K_IBUF_FUL) ! 714: continue; /* wait for 'input' port empty */ ! 715: outb(K_RDWR, ch); /* send command to mouse */ ! 716: } ! 717: ! 718: /* ! 719: * Read next character from mouse, waiting for interrupt ! 720: * to deliver it. Called at spltty. ! 721: */ ! 722: int kd_mouse_read(void) ! 723: { ! 724: int ch; ! 725: ! 726: while (!mouse_char_in) { ! 727: mouse_char_wanted = TRUE; ! 728: #ifdef MACH_KERNEL ! 729: assert_wait((event_t) &mouse_char, FALSE); ! 730: thread_block((void (*)()) 0); ! 731: #else MACH_KERNEL ! 732: sleep(&mouse_char, PZERO); ! 733: #endif MACH_KERNEL ! 734: } ! 735: ! 736: ch = mouse_char; ! 737: mouse_char_in = FALSE; ! 738: ! 739: return ch; ! 740: } ! 741: ! 742: ibm_ps2_mouse_open(dev) ! 743: { ! 744: spl_t s = spltty(); ! 745: ! 746: lastbuttons = 0; ! 747: mouse_char_cmd = TRUE; /* responses are to commands */ ! 748: ! 749: kd_sendcmd(0xa8); /* enable mouse in kbd */ ! 750: ! 751: kd_cmdreg_write(0x47); /* allow mouse interrupts */ ! 752: /* magic number for ibm? */ ! 753: ! 754: kd_mouse_write(0xff); /* reset mouse */ ! 755: if (kd_mouse_read() != 0xfa) { ! 756: splx(s); ! 757: return; /* need ACK */ ! 758: } ! 759: ! 760: (void) kd_mouse_read(); /* discard 2-character mouse ID */ ! 761: (void) kd_mouse_read(); ! 762: ! 763: kd_mouse_write(0xea); /* set stream mode */ ! 764: if (kd_mouse_read() != 0xfa) { ! 765: splx(s); ! 766: return; /* need ACK */ ! 767: } ! 768: ! 769: kd_mouse_write(0xf4); /* enable */ ! 770: if (kd_mouse_read() != 0xfa) { ! 771: splx(s); ! 772: return; /* need ACK */ ! 773: } ! 774: ! 775: mouse_char_cmd = FALSE; /* now we get mouse packets */ ! 776: ! 777: splx(s); ! 778: } ! 779: ! 780: ibm_ps2_mouse_close(dev) ! 781: { ! 782: spl_t s = spltty(); ! 783: ! 784: mouse_char_cmd = TRUE; /* responses are to commands */ ! 785: ! 786: kd_mouse_write(0xff); /* reset mouse */ ! 787: if (kd_mouse_read() == 0xfa) { ! 788: /* got ACK: discard 2-char mouse ID */ ! 789: (void) kd_mouse_read(); ! 790: (void) kd_mouse_read(); ! 791: } ! 792: ! 793: kd_sendcmd(0xa7); /* disable mouse in kbd */ ! 794: kd_cmdreg_write(0x65); /* disallow mouse interrupts */ ! 795: /* magic number for ibm? */ ! 796: ! 797: splx(s); ! 798: } ! 799: ! 800: /* ! 801: * 3 byte ibm ps2 format used ! 802: * ! 803: * 7 6 5 4 3 2 1 0 ! 804: * YO XO YS XS 1 M R L ! 805: * X7 X6 X5 X4 X3 X3 X1 X0 ! 806: * Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0 ! 807: * ! 808: */ ! 809: mouse_packet_ibm_ps2_mouse(mousebuf) ! 810: u_char mousebuf[MOUSEBUFSIZE]; ! 811: { ! 812: u_char buttons, buttonchanges; ! 813: struct mouse_motion moved; ! 814: ! 815: buttons = mousebuf[0] & 0x7; /* get current state of buttons */ ! 816: buttonchanges = buttons ^ lastbuttons; ! 817: moved.mm_deltaX = ((mousebuf[0]&0x10) ? 0xffffff00 : 0 ) | (u_char)mousebuf[1]; ! 818: moved.mm_deltaY = ((mousebuf[0]&0x20) ? 0xffffff00 : 0 ) | (u_char)mousebuf[2]; ! 819: if (mouse_packets) { ! 820: printf("(%x:%x:%x)", mousebuf[0], mousebuf[1], mousebuf[2]); ! 821: return; ! 822: } ! 823: ! 824: if (moved.mm_deltaX != 0 || moved.mm_deltaY != 0) ! 825: mouse_moved(moved); ! 826: ! 827: if (buttonchanges != 0) { ! 828: lastbuttons = buttons; ! 829: if (buttonchanges & 1) ! 830: mouse_button(MOUSE_LEFT, !(buttons & 1)); ! 831: if (buttonchanges & 2) ! 832: mouse_button(MOUSE_RIGHT, !((buttons & 2) >> 1)); ! 833: if (buttonchanges & 4) ! 834: mouse_button(MOUSE_MIDDLE, !((buttons & 4) >> 2)); ! 835: } ! 836: } ! 837: ! 838: /* ! 839: * Enqueue a mouse-motion event. Called at SPLKD. ! 840: */ ! 841: mouse_moved(where) ! 842: struct mouse_motion where; ! 843: { ! 844: kd_event ev; ! 845: ! 846: ev.type = MOUSE_MOTION; ! 847: ev.time = time; ! 848: ev.value.mmotion = where; ! 849: mouse_enqueue(&ev); ! 850: } ! 851: ! 852: ! 853: /* ! 854: * Enqueue an event for mouse button press or release. Called at SPLKD. ! 855: */ ! 856: mouse_button(which, direction) ! 857: kev_type which; ! 858: u_char direction; ! 859: { ! 860: kd_event ev; ! 861: ! 862: ev.type = which; ! 863: ev.time = time; ! 864: ev.value.up = (direction == MOUSE_UP) ? TRUE : FALSE; ! 865: mouse_enqueue(&ev); ! 866: } ! 867: ! 868: ! 869: /* ! 870: * mouse_enqueue - enqueue an event and wake up selecting processes, if ! 871: * any. Called at SPLKD. ! 872: */ ! 873: ! 874: void ! 875: mouse_enqueue(ev) ! 876: kd_event *ev; ! 877: { ! 878: if (kdq_full(&mouse_queue)) ! 879: printf("mouse: queue full\n"); ! 880: else ! 881: kdq_put(&mouse_queue, ev); ! 882: ! 883: #ifdef MACH_KERNEL ! 884: { ! 885: register io_req_t ior; ! 886: while ((ior = (io_req_t)dequeue_head(&mouse_read_queue)) != 0) ! 887: iodone(ior); ! 888: } ! 889: #else MACH_KERNEL ! 890: if (mouse_sel) { ! 891: selwakeup(mouse_sel, mouseflag & MOUSE_COLL); ! 892: mouse_sel = 0; ! 893: mouseflag &= ~MOUSE_COLL; ! 894: } ! 895: if (mouseflag & MOUSE_ASYNC) ! 896: gsignal(mousepgrp, SIGIO); ! 897: wakeup((caddr_t)&mouse_queue); ! 898: #endif MACH_KERNEL ! 899: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.