sys/arch/next68k/dev/nextkbd.c

   1 /* $NetBSD: nextkbd.c,v 1.12 2007/03/04 06:00:27 christos Exp $ */
   2 /*
   3  * Copyright (c) 1998 Matt DeBergalis
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. All advertising materials mentioning features or use of this software
  15  *    must display the following acknowledgement:
  16  *      This product includes software developed by Matt DeBergalis
  17  * 4. The name of the author may not be used to endorse or promote products
  18  *    derived from this software without specific prior written permission
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __KERNEL_RCSID(0, "$NetBSD: nextkbd.c,v 1.12 2007/03/04 06:00:27 christos Exp $");
  34
  35 #include <sys/cdefs.h>                  /* RCS ID & Copyright macro defns */
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/kernel.h>
  40 #include <sys/proc.h>
  41 #include <sys/device.h>
  42 #include <sys/malloc.h>
  43 #include <sys/errno.h>
  44 #include <sys/queue.h>
  45 #include <sys/bus.h>
  46 #include <sys/cpu.h>
  47 #include <sys/intr.h>
  48
  49 #include <machine/autoconf.h>
  50
  51 #include <dev/wscons/wsconsio.h>
  52 #include <dev/wscons/wskbdvar.h>
  53 #include <dev/wscons/wsksymdef.h>
  54 #include <dev/wscons/wsksymvar.h>
  55
  56 #include <next68k/dev/nextkbdvar.h>
  57 #include <next68k/dev/wskbdmap_next.h>
  58
  59 #include <next68k/next68k/isr.h>
  60
  61 #include <next68k/dev/intiovar.h>
  62
  63 struct nextkbd_internal {
  64         int num_ints; /* interrupt total */
  65         int polling;
  66         int isconsole;
  67
  68         bus_space_tag_t iot;
  69         bus_space_handle_t ioh;
  70         struct nextkbd_softc *t_sc; /* back pointer */
  71         u_int32_t mods;
  72 };
  73
  74 struct mon_regs {
  75         u_int32_t mon_csr;
  76         u_int32_t mon_1;
  77         u_int32_t mon_data;
  78 };
  79
  80 static int attached = 0;
  81
  82 int nextkbd_match(struct device *, struct cfdata *, void *);
  83 void nextkbd_attach(struct device *, struct device *, void *);
  84
  85 int nextkbc_cnattach(bus_space_tag_t);
  86
  87 CFATTACH_DECL(nextkbd, sizeof(struct nextkbd_softc),
  88     nextkbd_match, nextkbd_attach, NULL, NULL);
  89
  90 int     nextkbd_enable(void *, int);
  91 void    nextkbd_set_leds(void *, int);
  92 int     nextkbd_ioctl(void *, u_long, void *, int, struct lwp *);
  93
  94 const struct wskbd_accessops nextkbd_accessops = {
  95         nextkbd_enable,
  96         nextkbd_set_leds,
  97         nextkbd_ioctl,
  98 };
  99
 100 void    nextkbd_cngetc(void *, u_int *, int *);
 101 void    nextkbd_cnpollc(void *, int);
 102
 103 const struct wskbd_consops nextkbd_consops = {
 104         nextkbd_cngetc,
 105         nextkbd_cnpollc,
 106 };
 107
 108 const struct wskbd_mapdata nextkbd_keymapdata = {
 109         nextkbd_keydesctab,
 110         KB_US,
 111 };
 112
 113 static int nextkbd_read_data(struct nextkbd_internal *);
 114 static int nextkbd_decode(struct nextkbd_internal *, int, u_int *, int *);
 115
 116 static struct nextkbd_internal nextkbd_consdata;
 117 static int nextkbd_is_console(bus_space_tag_t);
 118
 119 int nextkbdhard(void *);
 120
 121 static int
 122 nextkbd_is_console(bus_space_tag_t bst)
 123 {
 124         return (nextkbd_consdata.isconsole && (bst == nextkbd_consdata.iot));
 125 }
 126
 127 int
 128 nextkbd_match(struct device *parent, struct cfdata *match, void *aux)
 129 {
 130         struct intio_attach_args *ia = (struct intio_attach_args *)aux;
 131
 132         if (attached)
 133                 return(0);
 134
 135         ia->ia_addr = (void *)NEXT_P_MON;
 136
 137         return(1);
 138 }
 139
 140 void
 141 nextkbd_attach(struct device *parent, struct device *self, void *aux)
 142 {
 143         struct nextkbd_softc *sc = (struct nextkbd_softc *)self;
 144         struct intio_attach_args *ia = (struct intio_attach_args *)aux;
 145         int isconsole;
 146         struct wskbddev_attach_args a;
 147
 148         printf("\n");
 149
 150         isconsole = nextkbd_is_console(ia->ia_bst); /* XXX */
 151
 152         if (isconsole) {
 153                 sc->id = &nextkbd_consdata;
 154         } else {
 155                 sc->id = malloc(sizeof(struct nextkbd_internal),
 156                                 M_DEVBUF, M_WAITOK);
 157
 158                 memset(sc->id, 0, sizeof(struct nextkbd_internal));
 159                 sc->id->iot = ia->ia_bst;
 160                 if (bus_space_map(sc->id->iot, NEXT_P_MON,
 161                                 sizeof(struct mon_regs),
 162                                 0, &sc->id->ioh)) {
 163                         printf("%s: can't map mon status control register\n",
 164                                         sc->sc_dev.dv_xname);
 165                         return;
 166                 }
 167         }
 168
 169         sc->id->t_sc = sc; /* set back pointer */
 170
 171         isrlink_autovec(nextkbdhard, sc, NEXT_I_IPL(NEXT_I_KYBD_MOUSE), 0, NULL);
 172
 173         INTR_ENABLE(NEXT_I_KYBD_MOUSE);
 174
 175         a.console = isconsole;
 176         a.keymap = &nextkbd_keymapdata;
 177         a.accessops = &nextkbd_accessops;
 178         a.accesscookie = sc;
 179
 180         /*
 181          * Attach the wskbd, saving a handle to it.
 182          * XXX XXX XXX
 183          */
 184         sc->sc_wskbddev = config_found(self, &a, wskbddevprint);
 185
 186         attached = 1;
 187 }
 188
 189 int
 190 nextkbd_enable(void *v, int on)
 191 {
 192         /* XXX not sure if this should do anything */
 193         /* printf("nextkbd_enable %d\n", on); */
 194         return 0;
 195 }
 196
 197 void
 198 nextkbd_set_leds(void *v, int leds)
 199 {
 200         struct nextkbd_softc *sc = v;
 201         uint32_t hw_leds = 0;
 202         int s;
 203
 204         sc->sc_leds &= ~ NEXT_WSKBD_LEDS;
 205         sc->sc_leds |= (leds & NEXT_WSKBD_LEDS);
 206
 207         if (sc->sc_leds & WSKBD_LED_CAPS) {
 208                 hw_leds |= 0x30000;
 209         }
 210
 211         s = spltty();
 212         bus_space_write_1(sc->id->iot, sc->id->ioh, 3, 0xc5);
 213         /* @@@ need to add:
 214            if bit 7 of @ioh+0 set:
 215              repeat 2
 216                wait until bit 6 of @ioh+2 clears
 217         */
 218         bus_space_write_4(sc->id->iot, sc->id->ioh, 4, hw_leds);
 219         /* @@@ need to add:
 220            wait until bit 4 of @ioh+0 (@ioh+2 if bit 7 was set above)
 221              clears
 222         */
 223         splx(s);
 224
 225         return;
 226 }
 227
 228 int
 229 nextkbd_ioctl(void *v, u_long cmd, void *data, int flag, struct lwp *l)
 230 {
 231         struct nextkbd_softc *sc = v;
 232
 233         switch (cmd) {
 234         case WSKBDIO_GTYPE:
 235                 /* XXX */
 236                 *(int *)data = WSKBD_TYPE_NEXT;
 237                 return (0);
 238         case WSKBDIO_SETLEDS:
 239                 nextkbd_set_leds (sc, *(int *)data);
 240                 return (0);
 241         case WSKBDIO_GETLEDS:
 242                 *(int *)data = sc->sc_leds & NEXT_WSKBD_LEDS;
 243                 return (0);
 244         case WSKBDIO_COMPLEXBELL:
 245                 return (0);
 246         }
 247         return EPASSTHROUGH;
 248 }
 249
 250 int
 251 nextkbdhard(void *arg)
 252 {
 253         struct nextkbd_softc *sc = arg;
 254         int type, key, val;
 255
 256         if (!INTR_OCCURRED(NEXT_I_KYBD_MOUSE)) return 0;
 257
 258 #define CSR_INT 0x00800000
 259 #define CSR_DATA 0x00400000
 260
 261 #define KD_KEYMASK                      0x007f
 262 #define KD_DIRECTION            0x0080 /* pressed or released */
 263 #define KD_CNTL                                 0x0100
 264 #define KD_LSHIFT                               0x0200
 265 #define KD_RSHIFT                               0x0400
 266 #define KD_LCOMM                                0x0800
 267 #define KD_RCOMM                                0x1000
 268 #define KD_LALT                                 0x2000
 269 #define KD_RALT                                 0x4000
 270 #define KD_VALID                                0x8000 /* only set for scancode keys ? */
 271 #define KD_MODS                                 0x4f00
 272
 273         val = nextkbd_read_data(sc->id);
 274         if ((val != -1) && nextkbd_decode(sc->id, val, &type, &key)) {
 275                 wskbd_input(sc->sc_wskbddev, type, key);
 276         }
 277         return(1);
 278 }
 279
 280 int
 281 nextkbd_cnattach(bus_space_tag_t bst)
 282 {
 283         bus_space_handle_t bsh;
 284
 285         if (bus_space_map(bst, NEXT_P_MON, sizeof(struct mon_regs),
 286                         0, &bsh))
 287                 return (ENXIO);
 288
 289         memset(&nextkbd_consdata, 0, sizeof(nextkbd_consdata));
 290
 291         nextkbd_consdata.iot = bst;
 292         nextkbd_consdata.ioh = bsh;
 293         nextkbd_consdata.isconsole = 1;
 294
 295         wskbd_cnattach(&nextkbd_consops, &nextkbd_consdata,
 296                         &nextkbd_keymapdata);
 297
 298         return (0);
 299 }
 300
 301 void
 302 nextkbd_cngetc(void *v, u_int *type, int *data)
 303 {
 304         struct nextkbd_internal *t = v;
 305         int val;
 306
 307         for (;;) {
 308                 if (INTR_OCCURRED(NEXT_I_KYBD_MOUSE)) {
 309                         val = nextkbd_read_data(t);
 310                         if ((val != -1) && nextkbd_decode(t, val, type, data))
 311                                 return;
 312                 }
 313         }
 314 }
 315
 316 void
 317 nextkbd_cnpollc(void *v, int on)
 318 {
 319         struct nextkbd_internal *t = v;
 320
 321         t->polling = on;
 322         if (on) {
 323                 INTR_DISABLE(NEXT_I_KYBD_MOUSE);
 324         } else {
 325                 INTR_ENABLE(NEXT_I_KYBD_MOUSE);
 326         }
 327
 328 }
 329
 330 static int
 331 nextkbd_read_data(struct nextkbd_internal *id)
 332 {
 333         unsigned char device;
 334         struct mon_regs stat;
 335
 336         bus_space_read_region_4(id->iot, id->ioh, 0, &stat, 3);
 337         if ((stat.mon_csr & CSR_INT) && (stat.mon_csr & CSR_DATA)) {
 338                 stat.mon_csr &= ~CSR_INT;
 339                 id->num_ints++;
 340                 bus_space_write_4(id->iot, id->ioh, 0, stat.mon_csr);
 341                 device = stat.mon_data >> 28;
 342                 if (device != 1) return (-1); /* XXX: mouse */
 343                 return (stat.mon_data & 0xffff);
 344         }
 345         return (-1);
 346 }
 347
 348 static int
 349 nextkbd_decode(struct nextkbd_internal *id, int datain, u_int *type,
 350     int *dataout)
 351 {
 352         /* printf("datain %08x mods %08x\n", datain, id->mods); */
 353
 354         if ((datain ^ id->mods) & KD_LSHIFT) {
 355                 id->mods ^= KD_LSHIFT;
 356                 *dataout = 90;
 357                 if (datain & KD_LSHIFT)
 358                         *type = WSCONS_EVENT_KEY_DOWN;
 359                 else
 360                         *type = WSCONS_EVENT_KEY_UP;
 361         } else if ((datain ^ id->mods) & KD_RSHIFT) {
 362                 id->mods ^= KD_RSHIFT;
 363                 *dataout = 91;
 364                 if (datain & KD_RSHIFT)
 365                         *type = WSCONS_EVENT_KEY_DOWN;
 366                 else
 367                         *type = WSCONS_EVENT_KEY_UP;
 368         } else if ((datain ^ id->mods) & KD_LALT) {
 369                 id->mods ^= KD_LALT;
 370                 *dataout = 92;
 371                 if (datain & KD_LALT)
 372                         *type = WSCONS_EVENT_KEY_DOWN;
 373                 else
 374                         *type = WSCONS_EVENT_KEY_UP;
 375         } else if ((datain ^ id->mods) & KD_RALT) {
 376                 id->mods ^= KD_RALT;
 377                 *dataout = 93;
 378                 if (datain & KD_RALT)
 379                         *type = WSCONS_EVENT_KEY_DOWN;
 380                 else
 381                         *type = WSCONS_EVENT_KEY_UP;
 382         } else if ((datain ^ id->mods) & KD_CNTL) {
 383                 id->mods ^= KD_CNTL;
 384                 *dataout = 94;
 385                 if (datain & KD_CNTL)
 386                         *type = WSCONS_EVENT_KEY_DOWN;
 387                 else
 388                         *type = WSCONS_EVENT_KEY_UP;
 389         } else if ((datain ^ id->mods) & KD_LCOMM) {
 390                 id->mods ^= KD_LCOMM;
 391                 *dataout = 95;
 392                 if (datain & KD_LCOMM)
 393                         *type = WSCONS_EVENT_KEY_DOWN;
 394                 else
 395                         *type = WSCONS_EVENT_KEY_UP;
 396         } else if ((datain ^ id->mods) & KD_RCOMM) {
 397                 id->mods ^= KD_RCOMM;
 398                 *dataout = 96;
 399                 if (datain & KD_RCOMM)
 400                         *type = WSCONS_EVENT_KEY_DOWN;
 401                 else
 402                         *type = WSCONS_EVENT_KEY_UP;
 403         } else if (datain & KD_KEYMASK) {
 404                 if (datain & KD_DIRECTION)
 405                         *type = WSCONS_EVENT_KEY_UP;
 406                 else
 407                         *type = WSCONS_EVENT_KEY_DOWN;
 408
 409                 *dataout = (datain & KD_KEYMASK);
 410         } else {
 411                 *dataout = 0;
 412         }
 413
 414         return 1;
 415 }