vuidmice, vuidm3p, vuidm4p, vuidm5p,  vuid2ps2,  vuid3ps2  -
     converts mouse protocol to Firm Events


     #include <sys/stream.h>

     #include <sys/vuid_event.h>

     #include <sys/vuid_wheel.h>

     int ioctl(fd, I_PUSH, vuidm3p);

     int ioctl(fd, I_PUSH, vuidm4p);

     int ioctl(fd, I_PUSH, vuidm5p);

     int ioctl(fd, I_PUSH, vuid2ps2);

     int ioctl(fd, I_PUSH, vuid3ps2);


     The  STREAMS modules vuidm3p,  vuidm4p,  vuidm5p,  vuid2ps2,
     and  vuid3ps2  convert  mouse  protocols to Firm events. The
     Firm event structure is  described  in   <sys/vuid_event.h>.
     Pushing  a   STREAMS  module  does  not automatically enable
     mouse protocol conversion to Firm events.

     The  STREAMS  module  state  is  initially  set  to  raw  or
     VUID_NATIVE  mode which performs  no message processing. You
     must change the state to VUID_FIRM_EVENT  mode  to  initiate
     mouse  protocol  conversion  to  Firm  events.   This can be
     accomplished by the following code:

     int format;
     format = VUID_FIRM_EVENT;
     ioctl(fd, VUIDSFORMAT, &format);

     You can also query the state of the  STREAMS module by using
     the VUIDGFORMAT option:

     int format;
     int fd;   /* file descriptor */
     ioctl(fd, VUIDGFORMAT, &format);
     if ( format == VUID_NATIVE );
          /* The state of the module is in raw mode.
           * Message processing is not enabled.
     if ( format == VUID_FIRM_EVENT );
          /* Message processing is enabled.
           * Mouse protocol conversion to Firm events
           * are performed.

     The remainder of this section describes  the  processing  of
     STREAMS messages on the read- and write-side.

  Read Side Behavior
           Incoming messages are queued  and  converted  to  Firm

           The read queue of the module is  flushed  of  all  its
           data messages and all data in the record being accumu-
           lated  are  also  flushed.  The  message   is   passed

  Write Side Behavior
           Messages sent downstream as a result  of  an  ioctl(2)
           system call.  The two valid ioctl options processed by
           the vuidmice modules are VUIDGFORMAT and VUIDSFORMAT.

           This option returns the current state of the   STREAMS
           module.  The  state of the vuidmice STREAMS module may
           either  be  VUID_NATIVE  (no  message  processing)  or
           VUID_FIRM_EVENT (convert to Firm events).

           This option sets the state of the  STREAMS  module  to
           VUID_FIRM_EVENT. If the state of the STREAMS module is
           already  in  VUID_FIRM_EVENT,  this  option  is   non-
           operational. It is not possible  to set the state back
           to     VUID_NATIVE    once    the    state     becomes
           VUID_FIRM_EVENT.  To  disable  message processing, pop
           the STREAMS module out by  calling  ioctl(fd,  1I_POP,

           The write queue of the module is flushed  of  all  its
           data messages and the message is passed downstream.

     The following wheel support  ioctls  are  defined  for  PS/2
     mouse only:

           This ioctl takes a pointer to an integer  as  argument
           and  sets  the  value  of the integer to the number of
           wheels available on this device on return.

           This command returns static information    about   the
           wheel that does not  change while a  device is in use.
           Currently  the   only  information  defined   is   the
           wheel                                      orientation
           which   is   either   VUID_WHEEL_FORMAT_VERTICAL    or

        typedef struct {
                int     vers;
                int     id;
                int     format;
        } wheel_info;

          The  ioctl  takes a pointer to  "wheel_info"  structure
          with  the  "vers"  set  to  the  current version of the
          "wheel_info" structure and "id" set to the  id  of  the
          wheel for which the information is desired.


           VUIDSWHEELSTATE sets the state of the  wheel  to  that
           specified  in  the stateflags. VUIDGWHEELSTATE returns
           the current state settings in the stateflags field.

           stateflags is an  OR'ed  set of  flag bits.  The  only
           flag currently defined is VUID_WHEEL_STATE_ENABLED.

           When stateflags is set to VUID_WHEEL_STATE_ENABLED the
           module  converts   motion  of the specified wheel into
           VUID events and sends those up  stream.

           Wheel events are disabled by default.

           Applications that  want  to   change  a  flag   should
           first  get  the current flags and then change only the
           bit they want.

        typedef struct {
                int             vers;
                int            id;
                uint32_t       stateflags;
         } wheel_state;

          These ioctls take pointer to 'wheel_state' as an  argu-
          ment  with the 'vers' and 'id' members filled up. These
          members have the same meaning as that for  'VUIDGWHEEL-
          INFO' ioctl.

  Mouse Configurations
    | Module      |  Protocol Type            |  Device            |
    | vuidm3p     |  3-Byte Protocol Microsoft|  /dev/tty*         |
    |             |  2 Button Serial Mouse    |                    |
    | vuidm4p     |  4-Byte Protocol  Logitech|  /dev/tty*         |
    |             |  3 Button Mouseman        |                    |
    | vuidm5p     |  Logitech  3  Button   Bus|  /dev/logi/ dev/msm|
    |             |  Mouse Microsoft Bus Mouse|                    |
    | vuid2ps2    |  PS/2  Protocol  2  Button|  /dev/kdmouse      |
    |             |  PS/2 Compatible Mouse    |                    |
    | vuid3ps2    |  PS/2  Protocol  3  Button|  /dev/kdmouse      |
    |             |  PS/2 Compatible Mouse    |                    |


     See attributes(5) for descriptions of the  following  attri-

    |       ATTRIBUTE TYPE        |       ATTRIBUTE VALUE       |
    | Architecture                | x86                         |



     STREAMS Programming Guide

Man(1) output converted with man2html