Annotation of sys/dev/wscons/wskbd.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: wskbd.c,v 1.56 2007/06/02 07:19:28 tedu Exp $ */
2: /* $NetBSD: wskbd.c,v 1.80 2005/05/04 01:52:16 augustss Exp $ */
3:
4: /*
5: * Copyright (c) 1996, 1997 Christopher G. Demetriou. All rights reserved.
6: *
7: * Keysym translator:
8: * Contributed to The NetBSD Foundation by Juergen Hannken-Illjes.
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: * 2. Redistributions in binary form must reproduce the above copyright
16: * notice, this list of conditions and the following disclaimer in the
17: * documentation and/or other materials provided with the distribution.
18: * 3. All advertising materials mentioning features or use of this software
19: * must display the following acknowledgement:
20: * This product includes software developed by Christopher G. Demetriou
21: * for the NetBSD Project.
22: * 4. The name of the author may not be used to endorse or promote products
23: * derived from this software without specific prior written permission
24: *
25: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
26: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
27: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
28: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
29: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
30: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
34: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35: */
36:
37: /*
38: * Copyright (c) 1992, 1993
39: * The Regents of the University of California. All rights reserved.
40: *
41: * This software was developed by the Computer Systems Engineering group
42: * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
43: * contributed to Berkeley.
44: *
45: * All advertising materials mentioning features or use of this software
46: * must display the following acknowledgement:
47: * This product includes software developed by the University of
48: * California, Lawrence Berkeley Laboratory.
49: *
50: * Redistribution and use in source and binary forms, with or without
51: * modification, are permitted provided that the following conditions
52: * are met:
53: * 1. Redistributions of source code must retain the above copyright
54: * notice, this list of conditions and the following disclaimer.
55: * 2. Redistributions in binary form must reproduce the above copyright
56: * notice, this list of conditions and the following disclaimer in the
57: * documentation and/or other materials provided with the distribution.
58: * 3. Neither the name of the University nor the names of its contributors
59: * may be used to endorse or promote products derived from this software
60: * without specific prior written permission.
61: *
62: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
63: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
64: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
65: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
66: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
67: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
68: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
69: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
70: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
71: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
72: * SUCH DAMAGE.
73: *
74: * @(#)kbd.c 8.2 (Berkeley) 10/30/93
75: */
76:
77: /*
78: * Keyboard driver (/dev/wskbd*). Translates incoming bytes to ASCII or
79: * to `wscons_events' and passes them up to the appropriate reader.
80: */
81:
82: #include <sys/param.h>
83: #include <sys/conf.h>
84: #include <sys/device.h>
85: #include <sys/ioctl.h>
86: #include <sys/kernel.h>
87: #include <sys/proc.h>
88: #include <sys/syslog.h>
89: #include <sys/systm.h>
90: #include <sys/timeout.h>
91: #include <sys/malloc.h>
92: #include <sys/tty.h>
93: #include <sys/signalvar.h>
94: #include <sys/errno.h>
95: #include <sys/fcntl.h>
96: #include <sys/vnode.h>
97: #include <sys/poll.h>
98: #include <sys/workq.h>
99:
100: #include <ddb/db_var.h>
101:
102: #include <dev/wscons/wsconsio.h>
103: #include <dev/wscons/wskbdvar.h>
104: #include <dev/wscons/wsksymdef.h>
105: #include <dev/wscons/wsksymvar.h>
106: #include <dev/wscons/wsdisplayvar.h>
107: #include <dev/wscons/wseventvar.h>
108: #include <dev/wscons/wscons_callbacks.h>
109:
110: #include "audio.h" /* NAUDIO (mixer tuning) */
111: #include "wsdisplay.h"
112: #include "wskbd.h"
113: #include "wsmux.h"
114:
115: #ifndef SMALL_KERNEL
116: #define BURNER_SUPPORT
117: #define SCROLLBACK_SUPPORT
118: #endif
119:
120: #ifdef WSKBD_DEBUG
121: #define DPRINTF(x) if (wskbddebug) printf x
122: int wskbddebug = 0;
123: #else
124: #define DPRINTF(x)
125: #endif
126:
127: #include <dev/wscons/wsmuxvar.h>
128:
129: struct wskbd_internal {
130: const struct wskbd_mapdata *t_keymap;
131:
132: const struct wskbd_consops *t_consops;
133: void *t_consaccesscookie;
134:
135: int t_modifiers;
136: int t_composelen; /* remaining entries in t_composebuf */
137: keysym_t t_composebuf[2];
138:
139: int t_flags;
140: #define WSKFL_METAESC 1
141:
142: #define MAXKEYSYMSPERKEY 2 /* ESC <key> at max */
143: keysym_t t_symbols[MAXKEYSYMSPERKEY];
144:
145: struct wskbd_softc *t_sc; /* back pointer */
146: };
147:
148: struct wskbd_softc {
149: struct wsevsrc sc_base;
150:
151: struct wskbd_internal *id;
152:
153: const struct wskbd_accessops *sc_accessops;
154: void *sc_accesscookie;
155:
156: int sc_ledstate;
157:
158: int sc_isconsole;
159:
160: struct wskbd_bell_data sc_bell_data;
161: struct wskbd_keyrepeat_data sc_keyrepeat_data;
162:
163: int sc_repeating; /* we've called timeout() */
164: int sc_repkey;
165: struct timeout sc_repeat_ch;
166: u_int sc_repeat_type;
167: int sc_repeat_value;
168:
169: int sc_translating; /* xlate to chars for emulation */
170:
171: int sc_maplen; /* number of entries in sc_map */
172: struct wscons_keymap *sc_map; /* current translation map */
173: kbd_t sc_layout; /* current layout */
174:
175: int sc_refcnt;
176: u_char sc_dying; /* device is being detached */
177: };
178:
179: #define MOD_SHIFT_L (1 << 0)
180: #define MOD_SHIFT_R (1 << 1)
181: #define MOD_SHIFTLOCK (1 << 2)
182: #define MOD_CAPSLOCK (1 << 3)
183: #define MOD_CONTROL_L (1 << 4)
184: #define MOD_CONTROL_R (1 << 5)
185: #define MOD_META_L (1 << 6)
186: #define MOD_META_R (1 << 7)
187: #define MOD_MODESHIFT (1 << 8)
188: #define MOD_NUMLOCK (1 << 9)
189: #define MOD_COMPOSE (1 << 10)
190: #define MOD_HOLDSCREEN (1 << 11)
191: #define MOD_COMMAND (1 << 12)
192: #define MOD_COMMAND1 (1 << 13)
193: #define MOD_COMMAND2 (1 << 14)
194: #define MOD_MODELOCK (1 << 15)
195:
196: #define MOD_ANYSHIFT (MOD_SHIFT_L | MOD_SHIFT_R | MOD_SHIFTLOCK)
197: #define MOD_ANYCONTROL (MOD_CONTROL_L | MOD_CONTROL_R)
198: #define MOD_ANYMETA (MOD_META_L | MOD_META_R)
199:
200: #define MOD_ONESET(id, mask) (((id)->t_modifiers & (mask)) != 0)
201: #define MOD_ALLSET(id, mask) (((id)->t_modifiers & (mask)) == (mask))
202:
203: keysym_t ksym_upcase(keysym_t);
204:
205: int wskbd_match(struct device *, void *, void *);
206: void wskbd_attach(struct device *, struct device *, void *);
207: int wskbd_detach(struct device *, int);
208: int wskbd_activate(struct device *, enum devact);
209:
210: int wskbd_displayioctl(struct device *, u_long, caddr_t, int, struct proc *);
211:
212: void update_leds(struct wskbd_internal *);
213: void update_modifier(struct wskbd_internal *, u_int, int, int);
214: int internal_command(struct wskbd_softc *, u_int *, keysym_t, keysym_t);
215: int wskbd_translate(struct wskbd_internal *, u_int, int);
216: int wskbd_enable(struct wskbd_softc *, int);
217: #if NWSDISPLAY > 0
218: void change_displayparam(struct wskbd_softc *, int, int, int);
219: void wskbd_holdscreen(struct wskbd_softc *, int);
220: #endif
221:
222: int wskbd_do_ioctl_sc(struct wskbd_softc *, u_long, caddr_t, int,
223: struct proc *);
224: void wskbd_deliver_event(struct wskbd_softc *sc, u_int type, int value);
225:
226: #if NWSMUX > 0
227: int wskbd_mux_open(struct wsevsrc *, struct wseventvar *);
228: int wskbd_mux_close(struct wsevsrc *);
229: #else
230: #define wskbd_mux_open NULL
231: #define wskbd_mux_close NULL
232: #endif
233:
234: int wskbd_do_open(struct wskbd_softc *, struct wseventvar *);
235: int wskbd_do_ioctl(struct device *, u_long, caddr_t, int, struct proc *);
236:
237: struct cfdriver wskbd_cd = {
238: NULL, "wskbd", DV_TTY
239: };
240:
241: struct cfattach wskbd_ca = {
242: sizeof (struct wskbd_softc), wskbd_match, wskbd_attach,
243: wskbd_detach, wskbd_activate
244: };
245:
246: extern int kbd_reset;
247:
248: #ifndef WSKBD_DEFAULT_BELL_PITCH
249: #define WSKBD_DEFAULT_BELL_PITCH 400 /* 400Hz */
250: #endif
251: #ifndef WSKBD_DEFAULT_BELL_PERIOD
252: #define WSKBD_DEFAULT_BELL_PERIOD 100 /* 100ms */
253: #endif
254: #ifndef WSKBD_DEFAULT_BELL_VOLUME
255: #define WSKBD_DEFAULT_BELL_VOLUME 50 /* 50% volume */
256: #endif
257:
258: struct wskbd_bell_data wskbd_default_bell_data = {
259: WSKBD_BELL_DOALL,
260: WSKBD_DEFAULT_BELL_PITCH,
261: WSKBD_DEFAULT_BELL_PERIOD,
262: WSKBD_DEFAULT_BELL_VOLUME,
263: };
264:
265: #ifndef WSKBD_DEFAULT_KEYREPEAT_DEL1
266: #define WSKBD_DEFAULT_KEYREPEAT_DEL1 400 /* 400ms to start repeating */
267: #endif
268: #ifndef WSKBD_DEFAULT_KEYREPEAT_DELN
269: #define WSKBD_DEFAULT_KEYREPEAT_DELN 100 /* 100ms to between repeats */
270: #endif
271:
272: struct wskbd_keyrepeat_data wskbd_default_keyrepeat_data = {
273: WSKBD_KEYREPEAT_DOALL,
274: WSKBD_DEFAULT_KEYREPEAT_DEL1,
275: WSKBD_DEFAULT_KEYREPEAT_DELN,
276: };
277:
278: #if NWSMUX > 0 || NWSDISPLAY > 0
279: struct wssrcops wskbd_srcops = {
280: WSMUX_KBD,
281: wskbd_mux_open, wskbd_mux_close, wskbd_do_ioctl,
282: wskbd_displayioctl,
283: #if NWSDISPLAY > 0
284: wskbd_set_display
285: #else
286: NULL
287: #endif
288: };
289: #endif
290:
291: #if NWSDISPLAY > 0
292: void wskbd_repeat(void *v);
293: #endif
294:
295: static int wskbd_console_initted;
296: static struct wskbd_softc *wskbd_console_device;
297: static struct wskbd_internal wskbd_console_data;
298:
299: void wskbd_update_layout(struct wskbd_internal *, kbd_t);
300:
301: #if NAUDIO > 0
302: extern int wskbd_set_mixervolume(long dir);
303: #endif
304:
305: void
306: wskbd_update_layout(struct wskbd_internal *id, kbd_t enc)
307: {
308: if (enc & KB_METAESC)
309: id->t_flags |= WSKFL_METAESC;
310: else
311: id->t_flags &= ~WSKFL_METAESC;
312: }
313:
314: /*
315: * Print function (for parent devices).
316: */
317: int
318: wskbddevprint(void *aux, const char *pnp)
319: {
320: #if 0
321: struct wskbddev_attach_args *ap = aux;
322: #endif
323:
324: if (pnp)
325: printf("wskbd at %s", pnp);
326: #if 0
327: printf(" console %d", ap->console);
328: #endif
329:
330: return (UNCONF);
331: }
332:
333: int
334: wskbd_match(struct device *parent, void *match, void *aux)
335: {
336: struct cfdata *cf = match;
337: struct wskbddev_attach_args *ap = aux;
338:
339: if (cf->wskbddevcf_console != WSKBDDEVCF_CONSOLE_UNK) {
340: /*
341: * If console-ness of device specified, either match
342: * exactly (at high priority), or fail.
343: */
344: if (cf->wskbddevcf_console != 0 && ap->console != 0)
345: return (10);
346: else
347: return (0);
348: }
349:
350: /* If console-ness unspecified, it wins. */
351: return (1);
352: }
353:
354: void
355: wskbd_attach(struct device *parent, struct device *self, void *aux)
356: {
357: struct wskbd_softc *sc = (struct wskbd_softc *)self;
358: struct wskbddev_attach_args *ap = aux;
359: #if NWSMUX > 0
360: int mux, error;
361: #endif
362:
363: sc->sc_isconsole = ap->console;
364:
365: #if NWSMUX > 0 || NWSDISPLAY > 0
366: sc->sc_base.me_ops = &wskbd_srcops;
367: #endif
368: #if NWSMUX > 0
369: mux = sc->sc_base.me_dv.dv_cfdata->wskbddevcf_mux;
370: if (ap->console) {
371: /* Ignore mux for console; it always goes to the console mux. */
372: /* printf(" (mux %d ignored for console)", mux); */
373: mux = -1;
374: }
375: if (mux >= 0)
376: printf(" mux %d", mux);
377: #else
378: #if 0 /* not worth keeping, especially since the default value is not -1... */
379: if (sc->sc_base.me_dv.dv_cfdata->wskbddevcf_mux >= 0)
380: printf(" (mux ignored)");
381: #endif
382: #endif /* NWSMUX > 0 */
383:
384: if (ap->console) {
385: sc->id = &wskbd_console_data;
386: } else {
387: sc->id = malloc(sizeof(struct wskbd_internal),
388: M_DEVBUF, M_WAITOK);
389: bzero(sc->id, sizeof(struct wskbd_internal));
390: sc->id->t_keymap = ap->keymap;
391: wskbd_update_layout(sc->id, ap->keymap->layout);
392: }
393:
394: #if NWSDISPLAY > 0
395: timeout_set(&sc->sc_repeat_ch, wskbd_repeat, sc);
396: #endif
397:
398: sc->id->t_sc = sc;
399:
400: sc->sc_accessops = ap->accessops;
401: sc->sc_accesscookie = ap->accesscookie;
402: sc->sc_repeating = 0;
403: sc->sc_translating = 1;
404: sc->sc_ledstate = -1; /* force update */
405:
406: if (wskbd_load_keymap(sc->id->t_keymap,
407: &sc->sc_map, &sc->sc_maplen) != 0)
408: panic("cannot load keymap");
409:
410: sc->sc_layout = sc->id->t_keymap->layout;
411:
412: /* set default bell and key repeat data */
413: sc->sc_bell_data = wskbd_default_bell_data;
414: sc->sc_keyrepeat_data = wskbd_default_keyrepeat_data;
415:
416: if (ap->console) {
417: KASSERT(wskbd_console_initted);
418: KASSERT(wskbd_console_device == NULL);
419:
420: wskbd_console_device = sc;
421:
422: printf(": console keyboard");
423:
424: #if NWSDISPLAY > 0
425: wsdisplay_set_console_kbd(&sc->sc_base); /* sets me_dispdv */
426: if (sc->sc_displaydv != NULL)
427: printf(", using %s", sc->sc_displaydv->dv_xname);
428: #endif
429: }
430: printf("\n");
431:
432: #if NWSMUX > 0
433: if (mux >= 0) {
434: error = wsmux_attach_sc(wsmux_getmux(mux), &sc->sc_base);
435: if (error)
436: printf("%s: attach error=%d\n",
437: sc->sc_base.me_dv.dv_xname, error);
438: }
439: #endif
440:
441: #if WSDISPLAY > 0 && NWSMUX == 0
442: if (ap->console == 0) {
443: /*
444: * In the non-wsmux world, always connect wskbd0 and wsdisplay0
445: * together.
446: */
447: extern struct cfdriver wsdisplay_cd;
448:
449: if (wsdisplay_cd.cd_ndevs != 0 && self->dv_unit == 0) {
450: if (wskbd_set_display(self,
451: wsdisplay_cd.cd_devs[0]) == 0)
452: wsdisplay_set_kbd(wsdisplay_cd.cd_devs[0],
453: (struct wsevsrc *)sc);
454: }
455: }
456: #endif
457:
458: }
459:
460: void
461: wskbd_cnattach(const struct wskbd_consops *consops, void *conscookie,
462: const struct wskbd_mapdata *mapdata)
463: {
464:
465: KASSERT(!wskbd_console_initted);
466:
467: wskbd_console_data.t_keymap = mapdata;
468: wskbd_update_layout(&wskbd_console_data, mapdata->layout);
469:
470: wskbd_console_data.t_consops = consops;
471: wskbd_console_data.t_consaccesscookie = conscookie;
472:
473: #if NWSDISPLAY > 0
474: wsdisplay_set_cons_kbd(wskbd_cngetc, wskbd_cnpollc, wskbd_cnbell);
475: #endif
476:
477: wskbd_console_initted = 1;
478: }
479:
480: void
481: wskbd_cndetach()
482: {
483: KASSERT(wskbd_console_initted);
484:
485: wskbd_console_data.t_keymap = 0;
486:
487: wskbd_console_data.t_consops = 0;
488: wskbd_console_data.t_consaccesscookie = 0;
489:
490: #if NWSDISPLAY > 0
491: wsdisplay_unset_cons_kbd();
492: #endif
493:
494: wskbd_console_initted = 0;
495: }
496:
497: #if NWSDISPLAY > 0
498: void
499: wskbd_repeat(void *v)
500: {
501: struct wskbd_softc *sc = (struct wskbd_softc *)v;
502: int s = spltty();
503:
504: if (!sc->sc_repeating) {
505: /*
506: * race condition: a "key up" event came in when wskbd_repeat()
507: * was already called but not yet spltty()'d
508: */
509: splx(s);
510: return;
511: }
512: if (sc->sc_translating) {
513: /* deliver keys */
514: if (sc->sc_base.me_dispdv != NULL) {
515: int i;
516: for (i = 0; i < sc->sc_repeating; i++)
517: wsdisplay_kbdinput(sc->sc_base.me_dispdv,
518: sc->id->t_symbols[i]);
519: }
520: } else {
521: /* queue event */
522: wskbd_deliver_event(sc, sc->sc_repeat_type,
523: sc->sc_repeat_value);
524: }
525: if (sc->sc_keyrepeat_data.delN != 0)
526: timeout_add(&sc->sc_repeat_ch,
527: (hz * sc->sc_keyrepeat_data.delN) / 1000);
528: splx(s);
529: }
530: #endif
531:
532: int
533: wskbd_activate(struct device *self, enum devact act)
534: {
535: struct wskbd_softc *sc = (struct wskbd_softc *)self;
536:
537: if (act == DVACT_DEACTIVATE)
538: sc->sc_dying = 1;
539: return (0);
540: }
541:
542: /*
543: * Detach a keyboard. To keep track of users of the softc we keep
544: * a reference count that's incremented while inside, e.g., read.
545: * If the keyboard is active and the reference count is > 0 (0 is the
546: * normal state) we post an event and then wait for the process
547: * that had the reference to wake us up again. Then we blow away the
548: * vnode and return (which will deallocate the softc).
549: */
550: int
551: wskbd_detach(struct device *self, int flags)
552: {
553: struct wskbd_softc *sc = (struct wskbd_softc *)self;
554: struct wseventvar *evar;
555: int maj, mn;
556: int s;
557:
558: #if NWSMUX > 0
559: /* Tell parent mux we're leaving. */
560: if (sc->sc_base.me_parent != NULL)
561: wsmux_detach_sc(&sc->sc_base);
562: #endif
563:
564: #if NWSDISPLAY > 0
565: if (sc->sc_repeating) {
566: sc->sc_repeating = 0;
567: timeout_del(&sc->sc_repeat_ch);
568: }
569: #endif
570:
571: if (sc->sc_isconsole) {
572: KASSERT(wskbd_console_device == sc);
573: wskbd_console_device = NULL;
574: }
575:
576: evar = sc->sc_base.me_evp;
577: if (evar != NULL && evar->io != NULL) {
578: s = spltty();
579: if (--sc->sc_refcnt >= 0) {
580: /* Wake everyone by generating a dummy event. */
581: if (++evar->put >= WSEVENT_QSIZE)
582: evar->put = 0;
583: WSEVENT_WAKEUP(evar);
584: /* Wait for processes to go away. */
585: if (tsleep(sc, PZERO, "wskdet", hz * 60))
586: printf("wskbd_detach: %s didn't detach\n",
587: sc->sc_base.me_dv.dv_xname);
588: }
589: splx(s);
590: }
591:
592: /* locate the major number */
593: for (maj = 0; maj < nchrdev; maj++)
594: if (cdevsw[maj].d_open == wskbdopen)
595: break;
596:
597: /* Nuke the vnodes for any open instances. */
598: mn = self->dv_unit;
599: vdevgone(maj, mn, mn, VCHR);
600:
601: return (0);
602: }
603:
604: void
605: wskbd_input(struct device *dev, u_int type, int value)
606: {
607: struct wskbd_softc *sc = (struct wskbd_softc *)dev;
608: #if NWSDISPLAY > 0
609: int num, i;
610: #endif
611:
612: #if NWSDISPLAY > 0
613: if (sc->sc_repeating) {
614: sc->sc_repeating = 0;
615: timeout_del(&sc->sc_repeat_ch);
616: }
617:
618: /*
619: * If /dev/wskbdN is not connected in event mode translate and
620: * send upstream.
621: */
622: if (sc->sc_translating) {
623: #ifdef BURNER_SUPPORT
624: if (type == WSCONS_EVENT_KEY_DOWN && sc->sc_displaydv != NULL)
625: wsdisplay_burn(sc->sc_displaydv, WSDISPLAY_BURN_KBD);
626: #endif
627: num = wskbd_translate(sc->id, type, value);
628: if (num > 0) {
629: if (sc->sc_base.me_dispdv != NULL) {
630: #ifdef SCROLLBACK_SUPPORT
631: /* XXX - Shift_R+PGUP(release) emits PrtSc */
632: if (sc->id->t_symbols[0] != KS_Print_Screen) {
633: wsscrollback(sc->sc_base.me_dispdv,
634: WSDISPLAY_SCROLL_RESET);
635: }
636: #endif
637: for (i = 0; i < num; i++) {
638: wsdisplay_kbdinput(sc->sc_base.me_dispdv,
639: sc->id->t_symbols[i]);
640: }
641: }
642:
643: if (sc->sc_keyrepeat_data.del1 != 0) {
644: sc->sc_repeating = num;
645: timeout_add(&sc->sc_repeat_ch,
646: (hz * sc->sc_keyrepeat_data.del1) / 1000);
647: }
648: }
649: return;
650: }
651: #endif
652:
653: wskbd_deliver_event(sc, type, value);
654:
655: #if NWSDISPLAY > 0
656: /* Repeat key presses if enabled. */
657: if (type == WSCONS_EVENT_KEY_DOWN && sc->sc_keyrepeat_data.del1 != 0) {
658: sc->sc_repeat_type = type;
659: sc->sc_repeat_value = value;
660: sc->sc_repeating = 1;
661: timeout_add(&sc->sc_repeat_ch,
662: (hz * sc->sc_keyrepeat_data.del1) / 1000);
663: }
664: #endif
665: }
666:
667: /*
668: * Keyboard is generating events. Turn this keystroke into an
669: * event and put it in the queue. If the queue is full, the
670: * keystroke is lost (sorry!).
671: */
672: void
673: wskbd_deliver_event(struct wskbd_softc *sc, u_int type, int value)
674: {
675: struct wseventvar *evar;
676: struct wscons_event *ev;
677: int put;
678:
679: evar = sc->sc_base.me_evp;
680:
681: if (evar == NULL) {
682: DPRINTF(("wskbd_input: not open\n"));
683: return;
684: }
685:
686: #ifdef DIAGNOSTIC
687: if (evar->q == NULL) {
688: printf("wskbd_input: evar->q=NULL\n");
689: return;
690: }
691: #endif
692:
693: put = evar->put;
694: ev = &evar->q[put];
695: put = (put + 1) % WSEVENT_QSIZE;
696: if (put == evar->get) {
697: log(LOG_WARNING, "%s: event queue overflow\n",
698: sc->sc_base.me_dv.dv_xname);
699: return;
700: }
701: ev->type = type;
702: ev->value = value;
703: nanotime(&ev->time);
704: evar->put = put;
705: WSEVENT_WAKEUP(evar);
706: }
707:
708: #ifdef WSDISPLAY_COMPAT_RAWKBD
709: void
710: wskbd_rawinput(struct device *dev, u_char *buf, int len)
711: {
712: #if NWSDISPLAY > 0
713: struct wskbd_softc *sc = (struct wskbd_softc *)dev;
714: int i;
715:
716: if (sc->sc_base.me_dispdv != NULL)
717: for (i = 0; i < len; i++)
718: wsdisplay_kbdinput(sc->sc_base.me_dispdv, buf[i]);
719: /* this is KS_GROUP_Ascii */
720: #endif
721: }
722: #endif /* WSDISPLAY_COMPAT_RAWKBD */
723:
724: #if NWSDISPLAY > 0
725: void
726: wskbd_holdscreen(struct wskbd_softc *sc, int hold)
727: {
728: int new_state;
729:
730: if (sc->sc_base.me_dispdv != NULL) {
731: wsdisplay_kbdholdscreen(sc->sc_base.me_dispdv, hold);
732: new_state = sc->sc_ledstate;
733: if (hold)
734: new_state |= WSKBD_LED_SCROLL;
735: else
736: new_state &= ~WSKBD_LED_SCROLL;
737: if (new_state != sc->sc_ledstate) {
738: (*sc->sc_accessops->set_leds)(sc->sc_accesscookie,
739: new_state);
740: sc->sc_ledstate = new_state;
741: }
742: }
743: }
744: #endif
745:
746: int
747: wskbd_enable(struct wskbd_softc *sc, int on)
748: {
749: int error;
750:
751: #if NWSDISPLAY > 0
752: if (sc->sc_base.me_dispdv != NULL)
753: return (0);
754:
755: /* Always cancel auto repeat when fiddling with the kbd. */
756: if (sc->sc_repeating) {
757: sc->sc_repeating = 0;
758: timeout_del(&sc->sc_repeat_ch);
759: }
760: #endif
761:
762: error = (*sc->sc_accessops->enable)(sc->sc_accesscookie, on);
763: DPRINTF(("wskbd_enable: sc=%p on=%d res=%d\n", sc, on, error));
764: return (error);
765: }
766:
767: #if NWSMUX > 0
768: int
769: wskbd_mux_open(struct wsevsrc *me, struct wseventvar *evp)
770: {
771: struct wskbd_softc *sc = (struct wskbd_softc *)me;
772:
773: if (sc->sc_dying)
774: return (EIO);
775:
776: if (sc->sc_base.me_evp != NULL)
777: return (EBUSY);
778:
779: return (wskbd_do_open(sc, evp));
780: }
781: #endif
782:
783: int
784: wskbdopen(dev_t dev, int flags, int mode, struct proc *p)
785: {
786: struct wskbd_softc *sc;
787: struct wseventvar *evar;
788: int unit, error;
789:
790: unit = minor(dev);
791: if (unit >= wskbd_cd.cd_ndevs || /* make sure it was attached */
792: (sc = wskbd_cd.cd_devs[unit]) == NULL)
793: return (ENXIO);
794:
795: #if NWSMUX > 0
796: DPRINTF(("wskbdopen: %s mux=%p p=%p\n", sc->sc_base.me_dv.dv_xname,
797: sc->sc_base.me_parent, p));
798: #endif
799:
800: if (sc->sc_dying)
801: return (EIO);
802:
803: if ((flags & (FREAD | FWRITE)) == FWRITE) {
804: /* Not opening for read, only ioctl is available. */
805: return (0);
806: }
807:
808: #if NWSMUX > 0
809: if (sc->sc_base.me_parent != NULL) {
810: /* Grab the keyboard out of the greedy hands of the mux. */
811: DPRINTF(("wskbdopen: detach\n"));
812: wsmux_detach_sc(&sc->sc_base);
813: }
814: #endif
815:
816: if (sc->sc_base.me_evp != NULL)
817: return (EBUSY);
818:
819: evar = &sc->sc_base.me_evar;
820: wsevent_init(evar);
821: evar->io = p;
822:
823: error = wskbd_do_open(sc, evar);
824: if (error) {
825: DPRINTF(("wskbdopen: %s open failed\n",
826: sc->sc_base.me_dv.dv_xname));
827: sc->sc_base.me_evp = NULL;
828: wsevent_fini(evar);
829: }
830: return (error);
831: }
832:
833: int
834: wskbd_do_open(struct wskbd_softc *sc, struct wseventvar *evp)
835: {
836: sc->sc_base.me_evp = evp;
837: sc->sc_translating = 0;
838:
839: return (wskbd_enable(sc, 1));
840: }
841:
842: int
843: wskbdclose(dev_t dev, int flags, int mode, struct proc *p)
844: {
845: struct wskbd_softc *sc =
846: (struct wskbd_softc *)wskbd_cd.cd_devs[minor(dev)];
847: struct wseventvar *evar = sc->sc_base.me_evp;
848:
849: if (evar == NULL)
850: /* not open for read */
851: return (0);
852:
853: sc->sc_base.me_evp = NULL;
854: sc->sc_translating = 1;
855: (void)wskbd_enable(sc, 0);
856: wsevent_fini(evar);
857:
858: return (0);
859: }
860:
861: #if NWSMUX > 0
862: int
863: wskbd_mux_close(struct wsevsrc *me)
864: {
865: struct wskbd_softc *sc = (struct wskbd_softc *)me;
866:
867: sc->sc_base.me_evp = NULL;
868: sc->sc_translating = 1;
869: (void)wskbd_enable(sc, 0);
870:
871: return (0);
872: }
873: #endif
874:
875: int
876: wskbdread(dev_t dev, struct uio *uio, int flags)
877: {
878: struct wskbd_softc *sc = wskbd_cd.cd_devs[minor(dev)];
879: int error;
880:
881: if (sc->sc_dying)
882: return (EIO);
883:
884: #ifdef DIAGNOSTIC
885: if (sc->sc_base.me_evp == NULL) {
886: printf("wskbdread: evp == NULL\n");
887: return (EINVAL);
888: }
889: #endif
890:
891: sc->sc_refcnt++;
892: error = wsevent_read(&sc->sc_base.me_evar, uio, flags);
893: if (--sc->sc_refcnt < 0) {
894: wakeup(sc);
895: error = EIO;
896: }
897: return (error);
898: }
899:
900: int
901: wskbdioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
902: {
903: return (wskbd_do_ioctl(wskbd_cd.cd_devs[minor(dev)], cmd, data, flag,p));
904: }
905:
906: /* A wrapper around the ioctl() workhorse to make reference counting easy. */
907: int
908: wskbd_do_ioctl(struct device *dv, u_long cmd, caddr_t data, int flag,
909: struct proc *p)
910: {
911: struct wskbd_softc *sc = (struct wskbd_softc *)dv;
912: int error;
913:
914: sc->sc_refcnt++;
915: error = wskbd_do_ioctl_sc(sc, cmd, data, flag, p);
916: if (--sc->sc_refcnt < 0)
917: wakeup(sc);
918: return (error);
919: }
920:
921: int
922: wskbd_do_ioctl_sc(struct wskbd_softc *sc, u_long cmd, caddr_t data, int flag,
923: struct proc *p)
924: {
925: int error;
926:
927: /*
928: * Try the generic ioctls that the wskbd interface supports.
929: */
930: switch (cmd) {
931: case FIONBIO: /* we will remove this someday (soon???) */
932: return (0);
933:
934: case FIOASYNC:
935: if (sc->sc_base.me_evp == NULL)
936: return (EINVAL);
937: sc->sc_base.me_evp->async = *(int *)data != 0;
938: return (0);
939:
940: case FIOSETOWN:
941: if (sc->sc_base.me_evp == NULL)
942: return (EINVAL);
943: if (-*(int *)data != sc->sc_base.me_evp->io->p_pgid &&
944: *(int *)data != sc->sc_base.me_evp->io->p_pid)
945: return (EPERM);
946: return (0);
947:
948: case TIOCSPGRP:
949: if (sc->sc_base.me_evp == NULL)
950: return (EINVAL);
951: if (*(int *)data != sc->sc_base.me_evp->io->p_pgid)
952: return (EPERM);
953: return (0);
954: }
955:
956: /*
957: * Try the keyboard driver for WSKBDIO ioctls. It returns -1
958: * if it didn't recognize the request.
959: */
960: error = wskbd_displayioctl(&sc->sc_base.me_dv, cmd, data, flag, p);
961: return (error != -1 ? error : ENOTTY);
962: }
963:
964: /*
965: * WSKBDIO ioctls, handled in both emulation mode and in ``raw'' mode.
966: * Some of these have no real effect in raw mode, however.
967: */
968: int
969: wskbd_displayioctl(struct device *dev, u_long cmd, caddr_t data, int flag,
970: struct proc *p)
971: {
972: struct wskbd_softc *sc = (struct wskbd_softc *)dev;
973: struct wskbd_bell_data *ubdp, *kbdp;
974: struct wskbd_keyrepeat_data *ukdp, *kkdp;
975: struct wskbd_map_data *umdp;
976: struct wskbd_mapdata md;
977: kbd_t enc;
978: void *buf;
979: int len, error;
980:
981: switch (cmd) {
982: case WSKBDIO_BELL:
983: case WSKBDIO_COMPLEXBELL:
984: case WSKBDIO_SETBELL:
985: case WSKBDIO_SETKEYREPEAT:
986: case WSKBDIO_SETDEFAULTKEYREPEAT:
987: case WSKBDIO_SETMAP:
988: case WSKBDIO_SETENCODING:
989: if ((flag & FWRITE) == 0)
990: return (EACCES);
991: }
992:
993: switch (cmd) {
994: #define SETBELL(dstp, srcp, dfltp) \
995: do { \
996: (dstp)->pitch = ((srcp)->which & WSKBD_BELL_DOPITCH) ? \
997: (srcp)->pitch : (dfltp)->pitch; \
998: (dstp)->period = ((srcp)->which & WSKBD_BELL_DOPERIOD) ? \
999: (srcp)->period : (dfltp)->period; \
1000: (dstp)->volume = ((srcp)->which & WSKBD_BELL_DOVOLUME) ? \
1001: (srcp)->volume : (dfltp)->volume; \
1002: (dstp)->which = WSKBD_BELL_DOALL; \
1003: } while (0)
1004:
1005: case WSKBDIO_BELL:
1006: return ((*sc->sc_accessops->ioctl)(sc->sc_accesscookie,
1007: WSKBDIO_COMPLEXBELL, (caddr_t)&sc->sc_bell_data, flag, p));
1008:
1009: case WSKBDIO_COMPLEXBELL:
1010: ubdp = (struct wskbd_bell_data *)data;
1011: SETBELL(ubdp, ubdp, &sc->sc_bell_data);
1012: return ((*sc->sc_accessops->ioctl)(sc->sc_accesscookie,
1013: WSKBDIO_COMPLEXBELL, (caddr_t)ubdp, flag, p));
1014:
1015: case WSKBDIO_SETBELL:
1016: kbdp = &sc->sc_bell_data;
1017: setbell:
1018: ubdp = (struct wskbd_bell_data *)data;
1019: SETBELL(kbdp, ubdp, kbdp);
1020: return (0);
1021:
1022: case WSKBDIO_GETBELL:
1023: kbdp = &sc->sc_bell_data;
1024: getbell:
1025: ubdp = (struct wskbd_bell_data *)data;
1026: SETBELL(ubdp, kbdp, kbdp);
1027: return (0);
1028:
1029: case WSKBDIO_SETDEFAULTBELL:
1030: if ((error = suser(p, 0)) != 0)
1031: return (error);
1032: kbdp = &wskbd_default_bell_data;
1033: goto setbell;
1034:
1035:
1036: case WSKBDIO_GETDEFAULTBELL:
1037: kbdp = &wskbd_default_bell_data;
1038: goto getbell;
1039:
1040: #undef SETBELL
1041:
1042: #define SETKEYREPEAT(dstp, srcp, dfltp) \
1043: do { \
1044: (dstp)->del1 = ((srcp)->which & WSKBD_KEYREPEAT_DODEL1) ? \
1045: (srcp)->del1 : (dfltp)->del1; \
1046: (dstp)->delN = ((srcp)->which & WSKBD_KEYREPEAT_DODELN) ? \
1047: (srcp)->delN : (dfltp)->delN; \
1048: (dstp)->which = WSKBD_KEYREPEAT_DOALL; \
1049: } while (0)
1050:
1051: case WSKBDIO_SETKEYREPEAT:
1052: kkdp = &sc->sc_keyrepeat_data;
1053: setkeyrepeat:
1054: ukdp = (struct wskbd_keyrepeat_data *)data;
1055: SETKEYREPEAT(kkdp, ukdp, kkdp);
1056: return (0);
1057:
1058: case WSKBDIO_GETKEYREPEAT:
1059: kkdp = &sc->sc_keyrepeat_data;
1060: getkeyrepeat:
1061: ukdp = (struct wskbd_keyrepeat_data *)data;
1062: SETKEYREPEAT(ukdp, kkdp, kkdp);
1063: return (0);
1064:
1065: case WSKBDIO_SETDEFAULTKEYREPEAT:
1066: if ((error = suser(p, 0)) != 0)
1067: return (error);
1068: kkdp = &wskbd_default_keyrepeat_data;
1069: goto setkeyrepeat;
1070:
1071:
1072: case WSKBDIO_GETDEFAULTKEYREPEAT:
1073: kkdp = &wskbd_default_keyrepeat_data;
1074: goto getkeyrepeat;
1075:
1076: #undef SETKEYREPEAT
1077:
1078: case WSKBDIO_SETMAP:
1079: umdp = (struct wskbd_map_data *)data;
1080: if (umdp->maplen > WSKBDIO_MAXMAPLEN)
1081: return (EINVAL);
1082:
1083: len = umdp->maplen * sizeof(struct wscons_keymap);
1084: buf = malloc(len, M_TEMP, M_WAITOK);
1085: error = copyin(umdp->map, buf, len);
1086: if (error == 0) {
1087: wskbd_init_keymap(umdp->maplen,
1088: &sc->sc_map, &sc->sc_maplen);
1089: memcpy(sc->sc_map, buf, len);
1090: /* drop the variant bits handled by the map */
1091: sc->sc_layout = KB_USER |
1092: (KB_VARIANT(sc->sc_layout) & KB_HANDLEDBYWSKBD);
1093: wskbd_update_layout(sc->id, sc->sc_layout);
1094: }
1095: free(buf, M_TEMP);
1096: return(error);
1097:
1098: case WSKBDIO_GETMAP:
1099: umdp = (struct wskbd_map_data *)data;
1100: if (umdp->maplen > sc->sc_maplen)
1101: umdp->maplen = sc->sc_maplen;
1102: error = copyout(sc->sc_map, umdp->map,
1103: umdp->maplen*sizeof(struct wscons_keymap));
1104: return(error);
1105:
1106: case WSKBDIO_GETENCODING:
1107: *((kbd_t *) data) = sc->sc_layout;
1108: return(0);
1109:
1110: case WSKBDIO_SETENCODING:
1111: enc = *((kbd_t *)data);
1112: if (KB_ENCODING(enc) == KB_USER) {
1113: /* user map must already be loaded */
1114: if (KB_ENCODING(sc->sc_layout) != KB_USER)
1115: return (EINVAL);
1116: /* map variants make no sense */
1117: if (KB_VARIANT(enc) & ~KB_HANDLEDBYWSKBD)
1118: return (EINVAL);
1119: } else {
1120: md = *(sc->id->t_keymap); /* structure assignment */
1121: md.layout = enc;
1122: error = wskbd_load_keymap(&md, &sc->sc_map,
1123: &sc->sc_maplen);
1124: if (error)
1125: return(error);
1126: }
1127: sc->sc_layout = enc;
1128: wskbd_update_layout(sc->id, enc);
1129: return (0);
1130: }
1131:
1132: /*
1133: * Try the keyboard driver for WSKBDIO ioctls. It returns -1
1134: * if it didn't recognize the request, and in turn we return
1135: * -1 if we didn't recognize the request.
1136: */
1137: /* printf("kbdaccess\n"); */
1138: error = (*sc->sc_accessops->ioctl)(sc->sc_accesscookie, cmd, data,
1139: flag, p);
1140: #ifdef WSDISPLAY_COMPAT_RAWKBD
1141: if (!error && cmd == WSKBDIO_SETMODE && *(int *)data == WSKBD_RAW) {
1142: int s = spltty();
1143: sc->id->t_modifiers &= ~(MOD_SHIFT_L | MOD_SHIFT_R
1144: | MOD_CONTROL_L | MOD_CONTROL_R
1145: | MOD_META_L | MOD_META_R
1146: | MOD_COMMAND
1147: | MOD_COMMAND1 | MOD_COMMAND2);
1148: #if NWSDISPLAY > 0
1149: if (sc->sc_repeating) {
1150: sc->sc_repeating = 0;
1151: timeout_del(&sc->sc_repeat_ch);
1152: }
1153: #endif
1154: splx(s);
1155: }
1156: #endif
1157: return (error);
1158: }
1159:
1160: int
1161: wskbdpoll(dev_t dev, int events, struct proc *p)
1162: {
1163: struct wskbd_softc *sc = wskbd_cd.cd_devs[minor(dev)];
1164:
1165: if (sc->sc_base.me_evp == NULL)
1166: return (POLLERR);
1167: return (wsevent_poll(sc->sc_base.me_evp, events, p));
1168: }
1169:
1170: #if NWSDISPLAY > 0
1171:
1172: int
1173: wskbd_pickfree()
1174: {
1175: int i;
1176: struct wskbd_softc *sc;
1177:
1178: for (i = 0; i < wskbd_cd.cd_ndevs; i++) {
1179: if ((sc = wskbd_cd.cd_devs[i]) == NULL)
1180: continue;
1181: if (sc->sc_displaydv == NULL)
1182: return (i);
1183: }
1184: return (-1);
1185: }
1186:
1187: struct wsevsrc *
1188: wskbd_set_console_display(struct device *displaydv, struct wsevsrc *me)
1189: {
1190: struct wskbd_softc *sc = wskbd_console_device;
1191:
1192: if (sc == NULL)
1193: return (NULL);
1194: sc->sc_base.me_dispdv = displaydv;
1195: #if NWSMUX > 0
1196: (void)wsmux_attach_sc((struct wsmux_softc *)me, &sc->sc_base);
1197: #endif
1198: return (&sc->sc_base);
1199: }
1200:
1201: int
1202: wskbd_set_display(struct device *dv, struct device *displaydv)
1203: {
1204: struct wskbd_softc *sc = (struct wskbd_softc *)dv;
1205: struct device *odisplaydv;
1206: int error;
1207:
1208: DPRINTF(("wskbd_set_display: %s odisp=%p disp=%p cons=%d\n",
1209: dv->dv_xname, sc->sc_base.me_dispdv, displaydv,
1210: sc->sc_isconsole));
1211:
1212: if (sc->sc_isconsole)
1213: return (EBUSY);
1214:
1215: if (displaydv != NULL) {
1216: if (sc->sc_base.me_dispdv != NULL)
1217: return (EBUSY);
1218: } else {
1219: if (sc->sc_base.me_dispdv == NULL)
1220: return (ENXIO);
1221: }
1222:
1223: odisplaydv = sc->sc_base.me_dispdv;
1224: sc->sc_base.me_dispdv = NULL;
1225: error = wskbd_enable(sc, displaydv != NULL);
1226: sc->sc_base.me_dispdv = displaydv;
1227: if (error) {
1228: sc->sc_base.me_dispdv = odisplaydv;
1229: return (error);
1230: }
1231:
1232: if (displaydv)
1233: printf("%s: connecting to %s\n",
1234: sc->sc_base.me_dv.dv_xname, displaydv->dv_xname);
1235: else
1236: printf("%s: disconnecting from %s\n",
1237: sc->sc_base.me_dv.dv_xname, odisplaydv->dv_xname);
1238:
1239: return (0);
1240: }
1241:
1242: #endif /* NWSDISPLAY > 0 */
1243:
1244: #if NWSMUX > 0
1245: int
1246: wskbd_add_mux(int unit, struct wsmux_softc *muxsc)
1247: {
1248: struct wskbd_softc *sc;
1249:
1250: if (unit < 0 || unit >= wskbd_cd.cd_ndevs ||
1251: (sc = wskbd_cd.cd_devs[unit]) == NULL)
1252: return (ENXIO);
1253:
1254: if (sc->sc_base.me_parent != NULL || sc->sc_base.me_evp != NULL)
1255: return (EBUSY);
1256:
1257: return (wsmux_attach_sc(muxsc, &sc->sc_base));
1258: }
1259: #endif
1260:
1261: /*
1262: * Console interface.
1263: */
1264: int
1265: wskbd_cngetc(dev_t dev)
1266: {
1267: static int num = 0;
1268: static int pos;
1269: u_int type;
1270: int data;
1271: keysym_t ks;
1272:
1273: if (!wskbd_console_initted)
1274: return 0;
1275:
1276: if (wskbd_console_device != NULL &&
1277: !wskbd_console_device->sc_translating)
1278: return 0;
1279:
1280: for(;;) {
1281: if (num-- > 0) {
1282: ks = wskbd_console_data.t_symbols[pos++];
1283: if (KS_GROUP(ks) == KS_GROUP_Ascii)
1284: return (KS_VALUE(ks));
1285: } else {
1286: (*wskbd_console_data.t_consops->getc)
1287: (wskbd_console_data.t_consaccesscookie,
1288: &type, &data);
1289: num = wskbd_translate(&wskbd_console_data, type, data);
1290: pos = 0;
1291: }
1292: }
1293: }
1294:
1295: void
1296: wskbd_cnpollc(dev_t dev, int poll)
1297: {
1298:
1299: if (!wskbd_console_initted)
1300: return;
1301:
1302: if (wskbd_console_device != NULL &&
1303: !wskbd_console_device->sc_translating)
1304: return;
1305:
1306: (*wskbd_console_data.t_consops->pollc)
1307: (wskbd_console_data.t_consaccesscookie, poll);
1308: }
1309:
1310: void
1311: wskbd_cnbell(dev_t dev, u_int pitch, u_int period, u_int volume)
1312: {
1313: if (!wskbd_console_initted)
1314: return;
1315:
1316: if (wskbd_console_data.t_consops->bell != NULL)
1317: (*wskbd_console_data.t_consops->bell)
1318: (wskbd_console_data.t_consaccesscookie, pitch, period,
1319: volume);
1320: }
1321:
1322: void
1323: update_leds(struct wskbd_internal *id)
1324: {
1325: int new_state;
1326:
1327: new_state = 0;
1328: if (id->t_modifiers & (MOD_SHIFTLOCK | MOD_CAPSLOCK))
1329: new_state |= WSKBD_LED_CAPS;
1330: if (id->t_modifiers & MOD_NUMLOCK)
1331: new_state |= WSKBD_LED_NUM;
1332: if (id->t_modifiers & MOD_COMPOSE)
1333: new_state |= WSKBD_LED_COMPOSE;
1334: if (id->t_modifiers & MOD_HOLDSCREEN)
1335: new_state |= WSKBD_LED_SCROLL;
1336:
1337: if (id->t_sc && new_state != id->t_sc->sc_ledstate) {
1338: (*id->t_sc->sc_accessops->set_leds)
1339: (id->t_sc->sc_accesscookie, new_state);
1340: id->t_sc->sc_ledstate = new_state;
1341: }
1342: }
1343:
1344: void
1345: update_modifier(struct wskbd_internal *id, u_int type, int toggle, int mask)
1346: {
1347: if (toggle) {
1348: if (type == WSCONS_EVENT_KEY_DOWN)
1349: id->t_modifiers ^= mask;
1350: } else {
1351: if (type == WSCONS_EVENT_KEY_DOWN)
1352: id->t_modifiers |= mask;
1353: else
1354: id->t_modifiers &= ~mask;
1355: }
1356: }
1357:
1358: #if NWSDISPLAY > 0
1359: void
1360: change_displayparam(struct wskbd_softc *sc, int param, int updown,
1361: int wraparound)
1362: {
1363: int res;
1364: struct wsdisplay_param dp;
1365:
1366: dp.param = param;
1367: res = wsdisplay_param(sc->sc_base.me_dispdv, WSDISPLAYIO_GETPARAM, &dp);
1368:
1369: if (res == EINVAL)
1370: return; /* no such parameter */
1371:
1372: dp.curval += updown;
1373: if (dp.max < dp.curval)
1374: dp.curval = wraparound ? dp.min : dp.max;
1375: else
1376: if (dp.curval < dp.min)
1377: dp.curval = wraparound ? dp.max : dp.min;
1378: wsdisplay_param(sc->sc_base.me_dispdv, WSDISPLAYIO_SETPARAM, &dp);
1379: }
1380: #endif
1381:
1382: int
1383: internal_command(struct wskbd_softc *sc, u_int *type, keysym_t ksym,
1384: keysym_t ksym2)
1385: {
1386: switch (ksym) {
1387: case KS_Cmd:
1388: update_modifier(sc->id, *type, 0, MOD_COMMAND);
1389: ksym = ksym2;
1390: break;
1391:
1392: case KS_Cmd1:
1393: update_modifier(sc->id, *type, 0, MOD_COMMAND1);
1394: break;
1395:
1396: case KS_Cmd2:
1397: update_modifier(sc->id, *type, 0, MOD_COMMAND2);
1398: break;
1399: }
1400:
1401: if (*type != WSCONS_EVENT_KEY_DOWN)
1402: return (0);
1403:
1404: #ifdef SCROLLBACK_SUPPORT
1405: #if NWSDISPLAY > 0
1406: switch (ksym) {
1407: case KS_Cmd_ScrollBack:
1408: if (MOD_ONESET(sc->id, MOD_ANYSHIFT)) {
1409: if (sc->sc_displaydv != NULL)
1410: wsscrollback(sc->sc_displaydv,
1411: WSDISPLAY_SCROLL_BACKWARD);
1412: return (1);
1413: }
1414: break;
1415:
1416: case KS_Cmd_ScrollFwd:
1417: if (MOD_ONESET(sc->id, MOD_ANYSHIFT)) {
1418: if (sc->sc_displaydv != NULL)
1419: wsscrollback(sc->sc_displaydv,
1420: WSDISPLAY_SCROLL_FORWARD);
1421: return (1);
1422: }
1423: break;
1424: }
1425: #endif
1426: #endif
1427:
1428: if (!MOD_ONESET(sc->id, MOD_COMMAND) &&
1429: !MOD_ALLSET(sc->id, MOD_COMMAND1 | MOD_COMMAND2))
1430: return (0);
1431:
1432: #ifdef DDB
1433: if (ksym == KS_Cmd_Debugger) {
1434: if (sc->sc_isconsole && db_console)
1435: Debugger();
1436: /* discard this key (ddb discarded command modifiers) */
1437: *type = WSCONS_EVENT_KEY_UP;
1438: return (1);
1439: }
1440: #endif
1441:
1442: #if NWSDISPLAY > 0
1443: if (sc->sc_base.me_dispdv == NULL)
1444: return (0);
1445:
1446: switch (ksym) {
1447: case KS_Cmd_Screen0:
1448: case KS_Cmd_Screen1:
1449: case KS_Cmd_Screen2:
1450: case KS_Cmd_Screen3:
1451: case KS_Cmd_Screen4:
1452: case KS_Cmd_Screen5:
1453: case KS_Cmd_Screen6:
1454: case KS_Cmd_Screen7:
1455: case KS_Cmd_Screen8:
1456: case KS_Cmd_Screen9:
1457: case KS_Cmd_Screen10:
1458: case KS_Cmd_Screen11:
1459: wsdisplay_switch(sc->sc_displaydv, ksym - KS_Cmd_Screen0, 0);
1460: return (1);
1461: case KS_Cmd_ResetEmul:
1462: wsdisplay_reset(sc->sc_displaydv, WSDISPLAY_RESETEMUL);
1463: return (1);
1464: case KS_Cmd_ResetClose:
1465: wsdisplay_reset(sc->sc_displaydv, WSDISPLAY_RESETCLOSE);
1466: return (1);
1467: #if defined(__i386__) || defined(__amd64__)
1468: case KS_Cmd_KbdReset:
1469: if (kbd_reset == 1) {
1470: kbd_reset = 0;
1471: psignal(initproc, SIGUSR1);
1472: }
1473: return (1);
1474: #endif
1475: case KS_Cmd_BacklightOn:
1476: case KS_Cmd_BacklightOff:
1477: case KS_Cmd_BacklightToggle:
1478: change_displayparam(sc, WSDISPLAYIO_PARAM_BACKLIGHT,
1479: ksym == KS_Cmd_BacklightOff ? -1 : 1,
1480: ksym == KS_Cmd_BacklightToggle ? 1 : 0);
1481: return (1);
1482: case KS_Cmd_BrightnessUp:
1483: case KS_Cmd_BrightnessDown:
1484: case KS_Cmd_BrightnessRotate:
1485: change_displayparam(sc, WSDISPLAYIO_PARAM_BRIGHTNESS,
1486: ksym == KS_Cmd_BrightnessDown ? -1 : 1,
1487: ksym == KS_Cmd_BrightnessRotate ? 1 : 0);
1488: return (1);
1489: case KS_Cmd_ContrastUp:
1490: case KS_Cmd_ContrastDown:
1491: case KS_Cmd_ContrastRotate:
1492: change_displayparam(sc, WSDISPLAYIO_PARAM_CONTRAST,
1493: ksym == KS_Cmd_ContrastDown ? -1 : 1,
1494: ksym == KS_Cmd_ContrastRotate ? 1 : 0);
1495: return (1);
1496: }
1497: #endif
1498: return (0);
1499: }
1500:
1501: int
1502: wskbd_translate(struct wskbd_internal *id, u_int type, int value)
1503: {
1504: struct wskbd_softc *sc = id->t_sc;
1505: keysym_t ksym, res, *group;
1506: struct wscons_keymap kpbuf, *kp;
1507: int gindex, iscommand = 0;
1508:
1509: if (type == WSCONS_EVENT_ALL_KEYS_UP) {
1510: #if NWSDISPLAY > 0
1511: if (sc != NULL && sc->sc_repeating) {
1512: sc->sc_repeating = 0;
1513: timeout_del(&sc->sc_repeat_ch);
1514: }
1515: #endif
1516: id->t_modifiers &= ~(MOD_SHIFT_L | MOD_SHIFT_R |
1517: MOD_CONTROL_L | MOD_CONTROL_R |
1518: MOD_META_L | MOD_META_R |
1519: MOD_MODESHIFT | MOD_MODELOCK |
1520: MOD_COMMAND | MOD_COMMAND1 | MOD_COMMAND2);
1521: update_leds(id);
1522: return (0);
1523: }
1524:
1525: if (sc != NULL) {
1526: if (value < 0 || value >= sc->sc_maplen) {
1527: #ifdef DEBUG
1528: printf("wskbd_translate: keycode %d out of range\n",
1529: value);
1530: #endif
1531: return (0);
1532: }
1533: kp = sc->sc_map + value;
1534: } else {
1535: kp = &kpbuf;
1536: wskbd_get_mapentry(id->t_keymap, value, kp);
1537: }
1538:
1539: /* if this key has a command, process it first */
1540: if (sc != NULL && kp->command != KS_voidSymbol)
1541: iscommand = internal_command(sc, &type, kp->command,
1542: kp->group1[0]);
1543:
1544: /* Now update modifiers */
1545: switch (kp->group1[0]) {
1546: case KS_Shift_L:
1547: update_modifier(id, type, 0, MOD_SHIFT_L);
1548: break;
1549:
1550: case KS_Shift_R:
1551: update_modifier(id, type, 0, MOD_SHIFT_R);
1552: break;
1553:
1554: case KS_Shift_Lock:
1555: update_modifier(id, type, 1, MOD_SHIFTLOCK);
1556: break;
1557:
1558: case KS_Caps_Lock:
1559: update_modifier(id, type, 1, MOD_CAPSLOCK);
1560: break;
1561:
1562: case KS_Control_L:
1563: update_modifier(id, type, 0, MOD_CONTROL_L);
1564: break;
1565:
1566: case KS_Control_R:
1567: update_modifier(id, type, 0, MOD_CONTROL_R);
1568: break;
1569:
1570: case KS_Alt_L:
1571: update_modifier(id, type, 0, MOD_META_L);
1572: break;
1573:
1574: case KS_Alt_R:
1575: update_modifier(id, type, 0, MOD_META_R);
1576: break;
1577:
1578: case KS_Mode_switch:
1579: update_modifier(id, type, 0, MOD_MODESHIFT);
1580: break;
1581:
1582: case KS_Mode_Lock:
1583: update_modifier(id, type, 1, MOD_MODELOCK);
1584: break;
1585:
1586: case KS_Num_Lock:
1587: update_modifier(id, type, 1, MOD_NUMLOCK);
1588: break;
1589:
1590: #if NWSDISPLAY > 0
1591: case KS_Hold_Screen:
1592: if (sc != NULL) {
1593: update_modifier(id, type, 1, MOD_HOLDSCREEN);
1594: wskbd_holdscreen(sc, id->t_modifiers & MOD_HOLDSCREEN);
1595: }
1596: break;
1597:
1598: default:
1599: if (sc != NULL && sc->sc_repeating &&
1600: ((type == WSCONS_EVENT_KEY_UP && value != sc->sc_repkey) ||
1601: (type == WSCONS_EVENT_KEY_DOWN && value == sc->sc_repkey)))
1602: return (0);
1603: break;
1604: #endif
1605: }
1606:
1607: #if NWSDISPLAY > 0
1608: if (sc != NULL) {
1609: if (sc->sc_repeating) {
1610: sc->sc_repeating = 0;
1611: timeout_del(&sc->sc_repeat_ch);
1612: }
1613: sc->sc_repkey = value;
1614: }
1615: #endif
1616:
1617: /* If this is a key release or we are in command mode, we are done */
1618: if (type != WSCONS_EVENT_KEY_DOWN || iscommand) {
1619: update_leds(id);
1620: return (0);
1621: }
1622:
1623: /* Get the keysym */
1624: if (id->t_modifiers & (MOD_MODESHIFT|MOD_MODELOCK) &&
1625: !MOD_ONESET(id, MOD_ANYCONTROL))
1626: group = & kp->group2[0];
1627: else
1628: group = & kp->group1[0];
1629:
1630: if ((id->t_modifiers & MOD_NUMLOCK) &&
1631: KS_GROUP(group[1]) == KS_GROUP_Keypad) {
1632: gindex = !MOD_ONESET(id, MOD_ANYSHIFT);
1633: ksym = group[gindex];
1634: } else {
1635: /* CAPS alone should only affect letter keys */
1636: if ((id->t_modifiers & (MOD_CAPSLOCK | MOD_ANYSHIFT)) ==
1637: MOD_CAPSLOCK) {
1638: gindex = 0;
1639: ksym = ksym_upcase(group[0]);
1640: } else {
1641: gindex = MOD_ONESET(id, MOD_ANYSHIFT);
1642: ksym = group[gindex];
1643: }
1644: }
1645:
1646: /* Submit Audio keys for hotkey processing */
1647: if (KS_GROUP(ksym) == KS_GROUP_Function) {
1648: switch (ksym) {
1649: #if NAUDIO > 0
1650: case KS_AudioMute:
1651: workq_add_task(NULL, 0, (workq_fn)wskbd_set_mixervolume,
1652: (void *)(long)0, NULL);
1653: break;
1654: case KS_AudioLower:
1655: workq_add_task(NULL, 0, (workq_fn)wskbd_set_mixervolume,
1656: (void *)(long)-1, NULL);
1657: break;
1658: case KS_AudioRaise:
1659: workq_add_task(NULL, 0, (workq_fn)wskbd_set_mixervolume,
1660: (void *)(long)1, NULL);
1661: return (0);
1662: #endif
1663: default:
1664: break;
1665: }
1666: }
1667:
1668: /* Process compose sequence and dead accents */
1669: res = KS_voidSymbol;
1670:
1671: switch (KS_GROUP(ksym)) {
1672: case KS_GROUP_Ascii:
1673: case KS_GROUP_Keypad:
1674: case KS_GROUP_Function:
1675: res = ksym;
1676: break;
1677:
1678: case KS_GROUP_Mod:
1679: if (ksym == KS_Multi_key) {
1680: update_modifier(id, 1, 0, MOD_COMPOSE);
1681: id->t_composelen = 2;
1682: }
1683: break;
1684:
1685: case KS_GROUP_Dead:
1686: if (id->t_composelen == 0) {
1687: update_modifier(id, 1, 0, MOD_COMPOSE);
1688: id->t_composelen = 1;
1689: id->t_composebuf[0] = ksym;
1690: } else
1691: res = ksym;
1692: break;
1693: }
1694:
1695: if (res == KS_voidSymbol) {
1696: update_leds(id);
1697: return (0);
1698: }
1699:
1700: if (id->t_composelen > 0) {
1701: /*
1702: * If the compose key also serves as AltGr (i.e. set to both
1703: * KS_Multi_key and KS_Mode_switch), and would provide a valid,
1704: * distinct combination as AltGr, leave compose mode.
1705: */
1706: if (id->t_composelen == 2 && group == &kp->group2[0]) {
1707: if (kp->group1[gindex] != kp->group2[gindex])
1708: id->t_composelen = 0;
1709: }
1710:
1711: if (id->t_composelen != 0) {
1712: id->t_composebuf[2 - id->t_composelen] = res;
1713: if (--id->t_composelen == 0) {
1714: res = wskbd_compose_value(id->t_composebuf);
1715: update_modifier(id, 0, 0, MOD_COMPOSE);
1716: } else {
1717: return (0);
1718: }
1719: }
1720: }
1721:
1722: update_leds(id);
1723:
1724: /* We are done, return the symbol */
1725: if (KS_GROUP(res) == KS_GROUP_Ascii) {
1726: if (MOD_ONESET(id, MOD_ANYCONTROL)) {
1727: if ((res >= KS_at && res <= KS_z) || res == KS_space)
1728: res = res & 0x1f;
1729: else if (res == KS_2)
1730: res = 0x00;
1731: else if (res >= KS_3 && res <= KS_7)
1732: res = KS_Escape + (res - KS_3);
1733: else if (res == KS_8)
1734: res = KS_Delete;
1735: }
1736: if (MOD_ONESET(id, MOD_ANYMETA)) {
1737: if (id->t_flags & WSKFL_METAESC) {
1738: id->t_symbols[0] = KS_Escape;
1739: id->t_symbols[1] = res;
1740: return (2);
1741: } else
1742: res |= 0x80;
1743: }
1744: }
1745:
1746: id->t_symbols[0] = res;
1747: return (1);
1748: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to wskbd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / wscons