mse_isa.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * Copyright (c) 2004 M. Warner Losh
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  *
   14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   24  * SUCH DAMAGE.
   25  *
   26  * $FreeBSD: releng/11.2/sys/dev/mse/mse_isa.c 331722 2018-03-29 02:50:57Z eadler $
   27  */
   28 
   29 /*-
   30  * Copyright 1992 by the University of Guelph
   31  *
   32  * Permission to use, copy and modify this
   33  * software and its documentation for any purpose and without
   34  * fee is hereby granted, provided that the above copyright
   35  * notice appear in all copies and that both that copyright
   36  * notice and this permission notice appear in supporting
   37  * documentation.
   38  * University of Guelph makes no representations about the suitability of
   39  * this software for any purpose.  It is provided "as is"
   40  * without express or implied warranty.
   41  */
   42 /*
   43  * Driver for the Logitech and ATI Inport Bus mice for use with 386bsd and
   44  * the X386 port, courtesy of
   45  * Rick Macklem, rick@snowhite.cis.uoguelph.ca
   46  * Caveats: The driver currently uses spltty(), but doesn't use any
   47  * generic tty code. It could use splmse() (that only masks off the
   48  * bus mouse interrupt, but that would require hacking in i386/isa/icu.s.
   49  * (This may be worth the effort, since the Logitech generates 30/60
   50  * interrupts/sec continuously while it is open.)
   51  * NB: The ATI has NOT been tested yet!
   52  */
   53 
   54 /*
   55  * Modification history:
   56  * Sep 6, 1994 -- Lars Fredriksen(fredriks@mcs.com)
   57  *   improved probe based on input from Logitech.
   58  *
   59  * Oct 19, 1992 -- E. Stark (stark@cs.sunysb.edu)
   60  *   fixes to make it work with Microsoft InPort busmouse
   61  *
   62  * Jan, 1993 -- E. Stark (stark@cs.sunysb.edu)
   63  *   added patches for new "select" interface
   64  *
   65  * May 4, 1993 -- E. Stark (stark@cs.sunysb.edu)
   66  *   changed position of some spl()'s in mseread
   67  *
   68  * October 8, 1993 -- E. Stark (stark@cs.sunysb.edu)
   69  *   limit maximum negative x/y value to -127 to work around XFree problem
   70  *   that causes spurious button pushes.
   71  */
   72 
   73 #include <sys/param.h>
   74 #include <sys/systm.h>
   75 #include <sys/conf.h>
   76 #include <sys/kernel.h>
   77 #include <sys/module.h>
   78 #include <sys/bus.h>
   79 #include <sys/poll.h>
   80 #include <sys/selinfo.h>
   81 #include <sys/uio.h>
   82 #include <sys/mouse.h>
   83 
   84 #include <machine/bus.h>
   85 #include <machine/resource.h>
   86 #include <sys/rman.h>
   87 
   88 #include <isa/isavar.h>
   89 
   90 #include <dev/mse/msevar.h>
   91 
   92 static  int             mse_isa_probe(device_t dev);
   93 static  int             mse_isa_attach(device_t dev);
   94 
   95 static  device_method_t mse_methods[] = {
   96         DEVMETHOD(device_probe,         mse_isa_probe),
   97         DEVMETHOD(device_attach,        mse_isa_attach),
   98         DEVMETHOD(device_detach,        mse_detach),
   99         { 0, 0 }
  100 };
  101 
  102 static  driver_t        mse_driver = {
  103         "mse",
  104         mse_methods,
  105         sizeof(mse_softc_t),
  106 };
  107 
  108 DRIVER_MODULE(mse, isa, mse_driver, mse_devclass, 0, 0);
  109 
  110 static struct isa_pnp_id mse_ids[] = {
  111         { 0x000fd041, "Bus mouse" },                    /* PNP0F00 */
  112         { 0x020fd041, "InPort mouse" },                 /* PNP0F02 */
  113         { 0x0d0fd041, "InPort mouse compatible" },      /* PNP0F0D */
  114         { 0x110fd041, "Bus mouse compatible" },         /* PNP0F11 */
  115         { 0x150fd041, "Logitech bus mouse" },           /* PNP0F15 */
  116         { 0x180fd041, "Logitech bus mouse compatible" },/* PNP0F18 */
  117         { 0 }
  118 };
  119 
  120 /*
  121  * Logitech bus mouse definitions
  122  */
  123 #define MSE_SETUP       0x91    /* What does this mean? */
  124                                 /* The definition for the control port */
  125                                 /* is as follows: */
  126 
  127                                 /* D7    =  Mode set flag (1 = active)  */
  128                                 /* D6,D5 =  Mode selection (port A)     */
  129                                 /*          00 = Mode 0 = Basic I/O     */
  130                                 /*          01 = Mode 1 = Strobed I/O   */
  131                                 /*          10 = Mode 2 = Bi-dir bus    */
  132                                 /* D4    =  Port A direction (1 = input)*/
  133                                 /* D3    =  Port C (upper 4 bits)       */
  134                                 /*          direction. (1 = input)      */
  135                                 /* D2    =  Mode selection (port B & C) */
  136                                 /*          0 = Mode 0 = Basic I/O      */
  137                                 /*          1 = Mode 1 = Strobed I/O    */
  138                                 /* D1    =  Port B direction (1 = input)*/
  139                                 /* D0    =  Port C (lower 4 bits)       */
  140                                 /*          direction. (1 = input)      */
  141 
  142                                 /* So 91 means Basic I/O on all 3 ports,*/
  143                                 /* Port A is an input port, B is an     */
  144                                 /* output port, C is split with upper   */
  145                                 /* 4 bits being an output port and lower*/
  146                                 /* 4 bits an input port, and enable the */
  147                                 /* sucker.                              */
  148                                 /* Courtesy Intel 8255 databook. Lars   */
  149 #define MSE_HOLD        0x80
  150 #define MSE_RXLOW       0x00
  151 #define MSE_RXHIGH      0x20
  152 #define MSE_RYLOW       0x40
  153 #define MSE_RYHIGH      0x60
  154 #define MSE_DISINTR     0x10
  155 #define MSE_INTREN      0x00
  156 
  157 static  int             mse_probelogi(device_t dev, mse_softc_t *sc);
  158 static  void            mse_disablelogi(struct resource *port);
  159 static  void            mse_getlogi(struct resource *port, int *dx, int *dy,
  160                             int *but);
  161 static  void            mse_enablelogi(struct resource *port);
  162 
  163 /*
  164  * ATI Inport mouse definitions
  165  */
  166 #define MSE_INPORT_RESET        0x80
  167 #define MSE_INPORT_STATUS       0x00
  168 #define MSE_INPORT_DX           0x01
  169 #define MSE_INPORT_DY           0x02
  170 #define MSE_INPORT_MODE         0x07
  171 #define MSE_INPORT_HOLD         0x20
  172 #define MSE_INPORT_INTREN       0x09
  173 
  174 static  int             mse_probeati(device_t dev, mse_softc_t *sc);
  175 static  void            mse_enableati(struct resource *port);
  176 static  void            mse_disableati(struct resource *port);
  177 static  void            mse_getati(struct resource *port, int *dx, int *dy,
  178                             int *but);
  179 
  180 static struct mse_types mse_types[] = {
  181         { MSE_ATIINPORT, 
  182           mse_probeati, mse_enableati, mse_disableati, mse_getati,
  183           { 2, MOUSE_IF_INPORT, MOUSE_MOUSE, MOUSE_MODEL_GENERIC, 0, },
  184           { MOUSE_PROTO_INPORT, -1, -1, 0, 0, MOUSE_MSC_PACKETSIZE, 
  185             { MOUSE_MSC_SYNCMASK, MOUSE_MSC_SYNC, }, }, },
  186         { MSE_LOGITECH, 
  187           mse_probelogi, mse_enablelogi, mse_disablelogi, mse_getlogi,
  188           { 2, MOUSE_IF_BUS, MOUSE_MOUSE, MOUSE_MODEL_GENERIC, 0, },
  189           { MOUSE_PROTO_BUS, -1, -1, 0, 0, MOUSE_MSC_PACKETSIZE, 
  190             { MOUSE_MSC_SYNCMASK, MOUSE_MSC_SYNC, }, }, },
  191         { 0, },
  192 };
  193 
  194 static  int
  195 mse_isa_probe(device_t dev)
  196 {
  197         mse_softc_t *sc;
  198         int error;
  199         int rid;
  200         int i;
  201 
  202         /* check PnP IDs */
  203         error = ISA_PNP_PROBE(device_get_parent(dev), dev, mse_ids);
  204         if (error == ENXIO)
  205                 return error;
  206 
  207         sc = device_get_softc(dev);
  208         rid = 0;
  209         sc->sc_port = bus_alloc_resource_anywhere(dev, SYS_RES_IOPORT, &rid,
  210                                                   MSE_IOSIZE, RF_ACTIVE);
  211         if (sc->sc_port == NULL)
  212                 return ENXIO;
  213 
  214         /*
  215          * Check for each mouse type in the table.
  216          */
  217         i = 0;
  218         while (mse_types[i].m_type) {
  219                 if ((*mse_types[i].m_probe)(dev, sc)) {
  220                         sc->sc_mousetype = mse_types[i].m_type;
  221                         sc->sc_enablemouse = mse_types[i].m_enable;
  222                         sc->sc_disablemouse = mse_types[i].m_disable;
  223                         sc->sc_getmouse = mse_types[i].m_get;
  224                         sc->hw = mse_types[i].m_hw;
  225                         sc->mode = mse_types[i].m_mode;
  226                         bus_release_resource(dev, SYS_RES_IOPORT, rid,
  227                                              sc->sc_port);
  228                         device_set_desc(dev, "Bus/InPort Mouse");
  229                         return 0;
  230                 }
  231                 i++;
  232         }
  233         bus_release_resource(dev, SYS_RES_IOPORT, rid, sc->sc_port);
  234         return ENXIO;
  235 }
  236 
  237 static  int
  238 mse_isa_attach(device_t dev)
  239 {
  240         mse_softc_t *sc;
  241         int rid;
  242 
  243         sc = device_get_softc(dev);
  244 
  245         rid = 0;
  246         sc->sc_port = bus_alloc_resource_anywhere(dev, SYS_RES_IOPORT, &rid,
  247                                                   MSE_IOSIZE, RF_ACTIVE);
  248         if (sc->sc_port == NULL)
  249                 return ENXIO;
  250 
  251         return (mse_common_attach(dev));
  252 }
  253 
  254 /*
  255  * Routines for the Logitech mouse.
  256  */
  257 /*
  258  * Test for a Logitech bus mouse and return 1 if it is.
  259  * (until I know how to use the signature port properly, just disable
  260  *  interrupts and return 1)
  261  */
  262 static int
  263 mse_probelogi(device_t dev, mse_softc_t *sc)
  264 {
  265 
  266         int sig;
  267 
  268         bus_write_1(sc->sc_port, MSE_PORTD, MSE_SETUP);
  269                 /* set the signature port */
  270         bus_write_1(sc->sc_port, MSE_PORTB, MSE_LOGI_SIG);
  271 
  272         DELAY(30000); /* 30 ms delay */
  273         sig = bus_read_1(sc->sc_port, MSE_PORTB) & 0xFF;
  274         if (sig == MSE_LOGI_SIG) {
  275                 bus_write_1(sc->sc_port, MSE_PORTC, MSE_DISINTR);
  276                 return(1);
  277         } else {
  278                 if (bootverbose)
  279                         device_printf(dev, "wrong signature %x\n", sig);
  280                 return(0);
  281         }
  282 }
  283 
  284 /*
  285  * Initialize Logitech mouse and enable interrupts.
  286  */
  287 static void
  288 mse_enablelogi(struct resource *port)
  289 {
  290         int dx, dy, but;
  291 
  292         bus_write_1(port, MSE_PORTD, MSE_SETUP);
  293         mse_getlogi(port, &dx, &dy, &but);
  294 }
  295 
  296 /*
  297  * Disable interrupts for Logitech mouse.
  298  */
  299 static void
  300 mse_disablelogi(struct resource *port)
  301 {
  302 
  303         bus_write_1(port, MSE_PORTC, MSE_DISINTR);
  304 }
  305 
  306 /*
  307  * Get the current dx, dy and button up/down state.
  308  */
  309 static void
  310 mse_getlogi(struct resource *port, int *dx, int *dy, int *but)
  311 {
  312         char x, y;
  313 
  314         bus_write_1(port, MSE_PORTC, MSE_HOLD | MSE_RXLOW);
  315         x = bus_read_1(port, MSE_PORTA);
  316         *but = (x >> 5) & MOUSE_MSC_BUTTONS;
  317         x &= 0xf;
  318         bus_write_1(port, MSE_PORTC, MSE_HOLD | MSE_RXHIGH);
  319         x |= (bus_read_1(port, MSE_PORTA) << 4);
  320         bus_write_1(port, MSE_PORTC, MSE_HOLD | MSE_RYLOW);
  321         y = (bus_read_1(port, MSE_PORTA) & 0xf);
  322         bus_write_1(port, MSE_PORTC, MSE_HOLD | MSE_RYHIGH);
  323         y |= (bus_read_1(port, MSE_PORTA) << 4);
  324         *dx = x;
  325         *dy = y;
  326         bus_write_1(port, MSE_PORTC, MSE_INTREN);
  327 }
  328 
  329 /*
  330  * Routines for the ATI Inport bus mouse.
  331  */
  332 /*
  333  * Test for an ATI Inport bus mouse and return 1 if it is.
  334  * (do not enable interrupts)
  335  */
  336 static int
  337 mse_probeati(device_t dev, mse_softc_t *sc)
  338 {
  339         int i;
  340 
  341         for (i = 0; i < 2; i++)
  342                 if (bus_read_1(sc->sc_port, MSE_PORTC) == 0xde)
  343                         return (1);
  344         return (0);
  345 }
  346 
  347 /*
  348  * Initialize ATI Inport mouse and enable interrupts.
  349  */
  350 static void
  351 mse_enableati(struct resource *port)
  352 {
  353 
  354         bus_write_1(port, MSE_PORTA, MSE_INPORT_RESET);
  355         bus_write_1(port, MSE_PORTA, MSE_INPORT_MODE);
  356         bus_write_1(port, MSE_PORTB, MSE_INPORT_INTREN);
  357 }
  358 
  359 /*
  360  * Disable interrupts for ATI Inport mouse.
  361  */
  362 static void
  363 mse_disableati(struct resource *port)
  364 {
  365 
  366         bus_write_1(port, MSE_PORTA, MSE_INPORT_MODE);
  367         bus_write_1(port, MSE_PORTB, 0);
  368 }
  369 
  370 /*
  371  * Get current dx, dy and up/down button state.
  372  */
  373 static void
  374 mse_getati(struct resource *port, int *dx, int *dy, int *but)
  375 {
  376         char byte;
  377 
  378         bus_write_1(port, MSE_PORTA, MSE_INPORT_MODE);
  379         bus_write_1(port, MSE_PORTB, MSE_INPORT_HOLD);
  380         bus_write_1(port, MSE_PORTA, MSE_INPORT_STATUS);
  381         *but = ~bus_read_1(port, MSE_PORTB) & MOUSE_MSC_BUTTONS;
  382         bus_write_1(port, MSE_PORTA, MSE_INPORT_DX);
  383         byte = bus_read_1(port, MSE_PORTB);
  384         *dx = byte;
  385         bus_write_1(port, MSE_PORTA, MSE_INPORT_DY);
  386         byte = bus_read_1(port, MSE_PORTB);
  387         *dy = byte;
  388         bus_write_1(port, MSE_PORTA, MSE_INPORT_MODE);
  389         bus_write_1(port, MSE_PORTB, MSE_INPORT_INTREN);
  390 }
Cache object: ff064766fae25b5f00cb8194173e1f92
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/mse/mse_isa.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/mse/mse_isa.c
