sys/arch/arc/dev/opms.c

   1 /*      $NetBSD: opms.c,v 1.17 2008/03/01 14:16:49 rmind Exp $  */
   2 /*      $OpenBSD: pccons.c,v 1.22 1999/01/30 22:39:37 imp Exp $ */
   3 /*      NetBSD: pms.c,v 1.21 1995/04/18 02:25:18 mycroft Exp    */
   4
   5 /*-
   6  * Copyright (c) 1990 The Regents of the University of California.
   7  * All rights reserved.
   8  *
   9  * This code is derived from software contributed to Berkeley by
  10  * William Jolitz and Don Ahn.
  11  *
  12  * Copyright (c) 1994 Charles M. Hannum.
  13  * Copyright (c) 1992, 1993 Erik Forsberg.
  14  *
  15  * Redistribution and use in source and binary forms, with or without
  16  * modification, are permitted provided that the following conditions
  17  * are met:
  18  * 1. Redistributions of source code must retain the above copyright
  19  *    notice, this list of conditions and the following disclaimer.
  20  * 2. Redistributions in binary form must reproduce the above copyright
  21  *    notice, this list of conditions and the following disclaimer in the
  22  *    documentation and/or other materials provided with the distribution.
  23  * 3. Neither the name of the University nor the names of its contributors
  24  *    may be used to endorse or promote products derived from this software
  25  *    without specific prior written permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37  * SUCH DAMAGE.
  38  *
  39  *      @(#)pccons.c    5.11 (Berkeley) 5/21/91
  40  */
  41
  42 /*-
  43  * Copyright (c) 1993, 1994, 1995 Charles M. Hannum.  All rights reserved.
  44  *
  45  * This code is derived from software contributed to Berkeley by
  46  * William Jolitz and Don Ahn.
  47  *
  48  * Copyright (c) 1994 Charles M. Hannum.
  49  * Copyright (c) 1992, 1993 Erik Forsberg.
  50  *
  51  * Redistribution and use in source and binary forms, with or without
  52  * modification, are permitted provided that the following conditions
  53  * are met:
  54  * 1. Redistributions of source code must retain the above copyright
  55  *    notice, this list of conditions and the following disclaimer.
  56  * 2. Redistributions in binary form must reproduce the above copyright
  57  *    notice, this list of conditions and the following disclaimer in the
  58  *    documentation and/or other materials provided with the distribution.
  59  * 3. All advertising materials mentioning features or use of this software
  60  *    must display the following acknowledgement:
  61  *      This product includes software developed by the University of
  62  *      California, Berkeley and its contributors.
  63  * 4. Neither the name of the University nor the names of its contributors
  64  *    may be used to endorse or promote products derived from this software
  65  *    without specific prior written permission.
  66  *
  67  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  68  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  69  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  70  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  71  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  72  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  73  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  74  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  75  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  76  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  77  * SUCH DAMAGE.
  78  *
  79  *      @(#)pccons.c    5.11 (Berkeley) 5/21/91
  80  */
  81
  82 #include <sys/cdefs.h>
  83 __KERNEL_RCSID(0, "$NetBSD: opms.c,v 1.17 2008/03/01 14:16:49 rmind Exp $");
  84
  85 #include <sys/param.h>
  86 #include <sys/systm.h>
  87 #include <sys/vnode.h>
  88 #include <sys/poll.h>
  89 #include <sys/tty.h>
  90 #include <sys/device.h>
  91 #include <sys/proc.h>
  92 #include <sys/conf.h>
  93
  94 #include <machine/bus.h>
  95 #include <machine/kbdreg.h>
  96 #include <machine/mouse.h>
  97
  98 #include <arc/dev/pcconsvar.h>
  99 #include <arc/dev/opmsvar.h>
 100
 101 #include "ioconf.h"
 102
 103 #define PMSUNIT(dev)    (minor(dev))
 104
 105 /* status bits */
 106 #define PMS_OBUF_FULL   0x01
 107 #define PMS_IBUF_FULL   0x02
 108
 109 /* controller commands */
 110 #define PMS_INT_ENABLE  0x47    /* enable controller interrupts */
 111 #define PMS_INT_DISABLE 0x65    /* disable controller interrupts */
 112 #define PMS_AUX_ENABLE  0xa7    /* enable auxiliary port */
 113 #define PMS_AUX_DISABLE 0xa8    /* disable auxiliary port */
 114 #define PMS_MAGIC_1     0xa9    /* XXX */
 115
 116 #define PMS_8042_CMD    0x65
 117
 118 /* mouse commands */
 119 #define PMS_SET_SCALE11 0xe6    /* set scaling 1:1 */
 120 #define PMS_SET_SCALE21 0xe7    /* set scaling 2:1 */
 121 #define PMS_SET_RES     0xe8    /* set resolution */
 122 #define PMS_GET_SCALE   0xe9    /* get scaling factor */
 123 #define PMS_SET_STREAM  0xea    /* set streaming mode */
 124 #define PMS_SET_SAMPLE  0xf3    /* set sampling rate */
 125 #define PMS_DEV_ENABLE  0xf4    /* mouse on */
 126 #define PMS_DEV_DISABLE 0xf5    /* mouse off */
 127 #define PMS_RESET       0xff    /* reset */
 128
 129 #define PMS_CHUNK       128     /* chunk size for read */
 130 #define PMS_BSIZE       1020    /* buffer size */
 131
 132 #define FLUSHQ(q) { if((q)->c_cc) ndflush(q, (q)->c_cc); }
 133
 134 dev_type_open(opmsopen);
 135 dev_type_close(opmsclose);
 136 dev_type_read(opmsread);
 137 dev_type_ioctl(opmsioctl);
 138 dev_type_poll(opmspoll);
 139 dev_type_kqfilter(opmskqfilter);
 140
 141 const struct cdevsw opms_cdevsw = {
 142         opmsopen, opmsclose, opmsread, nowrite, opmsioctl,
 143         nostop, notty, opmspoll, nommap, opmskqfilter,
 144 };
 145
 146 static inline void pms_dev_cmd(uint8_t);
 147 static inline void pms_aux_cmd(uint8_t);
 148 static inline void pms_pit_cmd(uint8_t);
 149
 150 static inline void
 151 pms_dev_cmd(uint8_t value)
 152 {
 153
 154         kbd_flush_input();
 155         kbd_cmd_write_1(0xd4);
 156         kbd_flush_input();
 157         kbd_data_write_1(value);
 158 }
 159
 160 static inline void
 161 pms_aux_cmd(uint8_t value)
 162 {
 163
 164         kbd_flush_input();
 165         kbd_cmd_write_1(value);
 166 }
 167
 168 static inline void
 169 pms_pit_cmd(uint8_t value)
 170 {
 171
 172         kbd_flush_input();
 173         kbd_cmd_write_1(0x60);
 174         kbd_flush_input();
 175         kbd_data_write_1(value);
 176 }
 177
 178 int opms_common_match(bus_space_tag_t kbd_iot, struct pccons_config *config)
 179 {
 180         uint8_t x;
 181
 182         kbd_context_init(kbd_iot, config);
 183
 184         pms_dev_cmd(KBC_RESET);
 185         pms_aux_cmd(PMS_MAGIC_1);
 186         delay(10000);
 187         x = kbd_data_read_1();
 188         pms_pit_cmd(PMS_INT_DISABLE);
 189         if (x & 0x04)
 190                 return 0;
 191
 192         return 1;
 193 }
 194
 195 void
 196 opms_common_attach(struct opms_softc *sc, bus_space_tag_t opms_iot,
 197     struct pccons_config *config)
 198 {
 199
 200         kbd_context_init(opms_iot, config);
 201         selinit(&sc->sc_rsel);
 202
 203         /* Other initialization was done by opmsprobe. */
 204         sc->sc_state = 0;
 205 }
 206
 207 int
 208 opmsopen(dev_t dev, int flag, int mode, struct lwp *l)
 209 {
 210         struct opms_softc *sc;
 211
 212         sc = device_lookup_private(&opms_cd, PMSUNIT(dev));
 213         if (!sc)
 214                 return ENXIO;
 215
 216         if (sc->sc_state & PMS_OPEN)
 217                 return EBUSY;
 218
 219         if (clalloc(&sc->sc_q, PMS_BSIZE, 0) == -1)
 220                 return ENOMEM;
 221
 222         sc->sc_state |= PMS_OPEN;
 223         sc->sc_status = 0;
 224         sc->sc_x = sc->sc_y = 0;
 225
 226         /* Enable interrupts. */
 227         pms_dev_cmd(PMS_DEV_ENABLE);
 228         pms_aux_cmd(PMS_AUX_ENABLE);
 229         pms_dev_cmd(PMS_SET_RES);
 230         pms_dev_cmd(3);         /* 8 counts/mm */
 231         pms_dev_cmd(PMS_SET_SCALE21);
 232 #if 0
 233         pms_dev_cmd(PMS_SET_SAMPLE);
 234         pms_dev_cmd(100);       /* 100 samples/sec */
 235         pms_dev_cmd(PMS_SET_STREAM);
 236 #endif
 237         pms_pit_cmd(PMS_INT_ENABLE);
 238
 239         return 0;
 240 }
 241
 242 int
 243 opmsclose(dev_t dev, int flag, int mode, struct lwp *l)
 244 {
 245         struct opms_softc *sc = device_lookup_private(&opms_cd, PMSUNIT(dev));
 246
 247         /* Disable interrupts. */
 248         pms_dev_cmd(PMS_DEV_DISABLE);
 249         pms_pit_cmd(PMS_INT_DISABLE);
 250         pms_aux_cmd(PMS_AUX_DISABLE);
 251
 252         sc->sc_state &= ~PMS_OPEN;
 253
 254         clfree(&sc->sc_q);
 255
 256         return 0;
 257 }
 258
 259 int
 260 opmsread(dev_t dev, struct uio *uio, int flag)
 261 {
 262         struct opms_softc *sc = device_lookup_private(&opms_cd, PMSUNIT(dev));
 263         int s;
 264         int error = 0;
 265         size_t length;
 266         u_char buffer[PMS_CHUNK];
 267
 268         /* Block until mouse activity occurred. */
 269
 270         s = spltty();
 271         while (sc->sc_q.c_cc == 0) {
 272                 if (flag & IO_NDELAY) {
 273                         splx(s);
 274                         return EWOULDBLOCK;
 275                 }
 276                 sc->sc_state |= PMS_ASLP;
 277                 error = tsleep((void *)sc, PZERO | PCATCH, "pmsrea", 0);
 278                 if (error) {
 279                         sc->sc_state &= ~PMS_ASLP;
 280                         splx(s);
 281                         return error;
 282                 }
 283         }
 284         splx(s);
 285
 286         /* Transfer as many chunks as possible. */
 287
 288         while (sc->sc_q.c_cc > 0 && uio->uio_resid > 0) {
 289                 length = min(sc->sc_q.c_cc, uio->uio_resid);
 290                 if (length > sizeof(buffer))
 291                         length = sizeof(buffer);
 292
 293                 /* Remove a small chunk from the input queue. */
 294                 (void) q_to_b(&sc->sc_q, buffer, length);
 295
 296                 /* Copy the data to the user process. */
 297                 error = uiomove(buffer, length, uio);
 298                 if (error)
 299                         break;
 300         }
 301
 302         return error;
 303 }
 304
 305 int
 306 opmsioctl(dev_t dev, u_long cmd, void *addr, int flag, struct lwp *l)
 307 {
 308         struct opms_softc *sc = device_lookup_private(&opms_cd, PMSUNIT(dev));
 309         struct mouseinfo info;
 310         int s;
 311         int error;
 312
 313         switch (cmd) {
 314         case MOUSEIOCREAD:
 315                 s = spltty();
 316
 317                 info.status = sc->sc_status;
 318                 if (sc->sc_x || sc->sc_y)
 319                         info.status |= MOVEMENT;
 320
 321                 if (sc->sc_x > 127)
 322                         info.xmotion = 127;
 323                 else if (sc->sc_x < -127)
 324                         /* Bounding at -127 avoids a bug in XFree86. */
 325                         info.xmotion = -127;
 326                 else
 327                         info.xmotion = sc->sc_x;
 328
 329                 if (sc->sc_y > 127)
 330                         info.ymotion = 127;
 331                 else if (sc->sc_y < -127)
 332                         info.ymotion = -127;
 333                 else
 334                         info.ymotion = sc->sc_y;
 335
 336                 /* Reset historical information. */
 337                 sc->sc_x = sc->sc_y = 0;
 338                 sc->sc_status &= ~BUTCHNGMASK;
 339                 ndflush(&sc->sc_q, sc->sc_q.c_cc);
 340
 341                 splx(s);
 342                 error = copyout(&info, addr, sizeof(struct mouseinfo));
 343                 break;
 344         default:
 345                 error = EINVAL;
 346                 break;
 347         }
 348
 349         return error;
 350 }
 351
 352 /* Masks for the first byte of a packet */
 353 #define PS2LBUTMASK 0x01
 354 #define PS2RBUTMASK 0x02
 355 #define PS2MBUTMASK 0x04
 356
 357 int
 358 opmsintr(void *arg)
 359 {
 360         struct opms_softc *sc = arg;
 361         static int state = 0;
 362         static u_char buttons;
 363         u_char changed;
 364         static char dx, dy;
 365         u_char buffer[5];
 366
 367         if ((sc->sc_state & PMS_OPEN) == 0) {
 368                 /* Interrupts are not expected.  Discard the byte. */
 369                 kbd_flush_input();
 370                 return 0;
 371         }
 372
 373         switch (state) {
 374
 375         case 0:
 376                 buttons = kbd_data_read_1();
 377                 if ((buttons & 0xc0) == 0)
 378                         ++state;
 379                 break;
 380
 381         case 1:
 382                 dx = kbd_data_read_1();
 383                 /* Bounding at -127 avoids a bug in XFree86. */
 384                 dx = (dx == -128) ? -127 : dx;
 385                 ++state;
 386                 break;
 387
 388         case 2:
 389                 dy = kbd_data_read_1();
 390                 dy = (dy == -128) ? -127 : dy;
 391                 state = 0;
 392
 393                 buttons = ((buttons & PS2LBUTMASK) << 2) |
 394                     ((buttons & (PS2RBUTMASK | PS2MBUTMASK)) >> 1);
 395                 changed = ((buttons ^ sc->sc_status) & BUTSTATMASK) << 3;
 396                 sc->sc_status = buttons | (sc->sc_status & ~BUTSTATMASK) |
 397                     changed;
 398
 399                 if (dx || dy || changed) {
 400                         /* Update accumulated movements. */
 401                         sc->sc_x += dx;
 402                         sc->sc_y += dy;
 403
 404                         /* Add this event to the queue. */
 405                         buffer[0] = 0x80 | (buttons & BUTSTATMASK);
 406                         if(dx < 0)
 407                                 buffer[0] |= 0x10;
 408                         buffer[1] = dx & 0x7f;
 409                         if(dy < 0)
 410                                 buffer[0] |= 0x20;
 411                         buffer[2] = dy & 0x7f;
 412                         buffer[3] = buffer[4] = 0;
 413                         (void) b_to_q(buffer, sizeof buffer, &sc->sc_q);
 414
 415                         if (sc->sc_state & PMS_ASLP) {
 416                                 sc->sc_state &= ~PMS_ASLP;
 417                                 wakeup((void *)sc);
 418                         }
 419                         selnotify(&sc->sc_rsel, 0, 0);
 420                 }
 421
 422                 break;
 423         }
 424         return -1;
 425 }
 426
 427 int
 428 opmspoll(dev_t dev, int events, struct lwp *l)
 429 {
 430         struct opms_softc *sc = device_lookup_private(&opms_cd, PMSUNIT(dev));
 431         int revents = 0;
 432         int s = spltty();
 433
 434         if (events & (POLLIN | POLLRDNORM)) {
 435                 if (sc->sc_q.c_cc > 0)
 436                         revents |= events & (POLLIN | POLLRDNORM);
 437                 else
 438                         selrecord(l, &sc->sc_rsel);
 439         }
 440
 441         splx(s);
 442         return revents;
 443 }
 444
 445 static void
 446 filt_opmsrdetach(struct knote *kn)
 447 {
 448         struct opms_softc *sc = kn->kn_hook;
 449         int s;
 450
 451         s = spltty();
 452         SLIST_REMOVE(&sc->sc_rsel.sel_klist, kn, knote, kn_selnext);
 453         splx(s);
 454 }
 455
 456 static int
 457 filt_opmsread(struct knote *kn, long hint)
 458 {
 459         struct opms_softc *sc = kn->kn_hook;
 460
 461         kn->kn_data = sc->sc_q.c_cc;
 462         return kn->kn_data > 0;
 463 }
 464
 465 static const struct filterops opmsread_filtops =
 466         { 1, NULL, filt_opmsrdetach, filt_opmsread };
 467
 468 int
 469 opmskqfilter(dev_t dev, struct knote *kn)
 470 {
 471         struct opms_softc *sc = device_lookup_private(&opms_cd, PMSUNIT(dev));
 472         struct klist *klist;
 473         int s;
 474
 475         switch (kn->kn_filter) {
 476         case EVFILT_READ:
 477                 klist = &sc->sc_rsel.sel_klist;
 478                 kn->kn_fop = &opmsread_filtops;
 479                 break;
 480
 481         default:
 482                 return 1;
 483         }
 484
 485         kn->kn_hook = sc;
 486
 487         s = spltty();
 488         SLIST_INSERT_HEAD(klist, kn, kn_selnext);
 489         splx(s);
 490
 491         return 0;
 492 }