wsdisplay.c revision 1.63.2.1 1 /* $NetBSD: wsdisplay.c,v 1.63.2.1 2002/05/16 04:54:51 gehenna Exp $ */
2
3 /*
4 * Copyright (c) 1996, 1997 Christopher G. Demetriou. 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 Christopher G. Demetriou
17 * for the NetBSD Project.
18 * 4. The name of the author may not be used to endorse or promote products
19 * derived from this software without specific prior written permission
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 #include <sys/cdefs.h>
34 __KERNEL_RCSID(0, "$NetBSD: wsdisplay.c,v 1.63.2.1 2002/05/16 04:54:51 gehenna Exp $");
35
36 #include "opt_wsdisplay_compat.h"
37 #include "opt_compat_netbsd.h"
38 #include "wskbd.h"
39 #include "wsmux.h"
40 #include "wsdisplay.h"
41
42 #include <sys/param.h>
43 #include <sys/conf.h>
44 #include <sys/device.h>
45 #include <sys/ioctl.h>
46 #include <sys/kernel.h>
47 #include <sys/proc.h>
48 #include <sys/malloc.h>
49 #include <sys/syslog.h>
50 #include <sys/systm.h>
51 #include <sys/tty.h>
52 #include <sys/signalvar.h>
53 #include <sys/errno.h>
54 #include <sys/fcntl.h>
55 #include <sys/vnode.h>
56
57 #include <dev/wscons/wseventvar.h>
58 #include <dev/wscons/wsmuxvar.h>
59 #include <dev/wscons/wsconsio.h>
60 #include <dev/wscons/wsdisplayvar.h>
61 #include <dev/wscons/wsksymvar.h>
62 #include <dev/wscons/wsksymdef.h>
63 #include <dev/wscons/wsemulvar.h>
64 #include <dev/wscons/wscons_callbacks.h>
65 #include <dev/cons.h>
66
67 struct wsscreen_internal {
68 const struct wsdisplay_emulops *emulops;
69 void *emulcookie;
70
71 const struct wsscreen_descr *scrdata;
72
73 const struct wsemul_ops *wsemul;
74 void *wsemulcookie;
75 };
76
77 struct wsscreen {
78 struct wsscreen_internal *scr_dconf;
79
80 struct tty *scr_tty;
81 int scr_hold_screen; /* hold tty output */
82
83 int scr_flags;
84 #define SCR_OPEN 1 /* is it open? */
85 #define SCR_WAITACTIVE 2 /* someone waiting on activation */
86 #define SCR_GRAPHICS 4 /* graphics mode, no text (emulation) output */
87 const struct wscons_syncops *scr_syncops;
88 void *scr_synccookie;
89
90 #ifdef WSDISPLAY_COMPAT_RAWKBD
91 int scr_rawkbd;
92 #endif
93
94 struct wsdisplay_softc *sc;
95 };
96
97 struct wsscreen *wsscreen_attach(struct wsdisplay_softc *, int,
98 const char *,
99 const struct wsscreen_descr *, void *,
100 int, int, long);
101 void wsscreen_detach(struct wsscreen *);
102 int wsdisplay_addscreen(struct wsdisplay_softc *, int, const char *, const char *);
103 static void wsdisplay_shutdownhook(void *);
104 static void wsdisplay_addscreen_print(struct wsdisplay_softc *, int, int);
105 static void wsdisplay_closescreen(struct wsdisplay_softc *, struct wsscreen *);
106 int wsdisplay_delscreen(struct wsdisplay_softc *, int, int);
107
108 #define WSDISPLAY_MAXSCREEN 8
109
110 struct wsdisplay_softc {
111 struct device sc_dv;
112
113 const struct wsdisplay_accessops *sc_accessops;
114 void *sc_accesscookie;
115
116 const struct wsscreen_list *sc_scrdata;
117
118 struct wsscreen *sc_scr[WSDISPLAY_MAXSCREEN];
119 int sc_focusidx; /* available only if sc_focus isn't null */
120 struct wsscreen *sc_focus;
121
122 int sc_isconsole;
123
124 int sc_flags;
125 #define SC_SWITCHPENDING 1
126 int sc_screenwanted, sc_oldscreen; /* valid with SC_SWITCHPENDING */
127
128 #if NWSKBD > 0
129 struct wsevsrc *sc_input;
130 #ifdef WSDISPLAY_COMPAT_RAWKBD
131 int sc_rawkbd;
132 #endif
133 #endif /* NWSKBD > 0 */
134 };
135
136 extern struct cfdriver wsdisplay_cd;
137
138 /* Autoconfiguration definitions. */
139 static int wsdisplay_emul_match(struct device *, struct cfdata *, void *);
140 static void wsdisplay_emul_attach(struct device *, struct device *, void *);
141 static int wsdisplay_noemul_match(struct device *, struct cfdata *, void *);
142 static void wsdisplay_noemul_attach(struct device *, struct device *, void *);
143
144 struct cfattach wsdisplay_emul_ca = {
145 sizeof (struct wsdisplay_softc),
146 wsdisplay_emul_match,
147 wsdisplay_emul_attach,
148 };
149
150 struct cfattach wsdisplay_noemul_ca = {
151 sizeof (struct wsdisplay_softc),
152 wsdisplay_noemul_match,
153 wsdisplay_noemul_attach,
154 };
155
156 dev_type_open(wsdisplayopen);
157 dev_type_close(wsdisplayclose);
158 dev_type_read(wsdisplayread);
159 dev_type_write(wsdisplaywrite);
160 dev_type_ioctl(wsdisplayioctl);
161 dev_type_stop(wsdisplaystop);
162 dev_type_tty(wsdisplaytty);
163 dev_type_poll(wsdisplaypoll);
164 dev_type_mmap(wsdisplaymmap);
165
166 const struct cdevsw wsdisplay_cdevsw = {
167 wsdisplayopen, wsdisplayclose, wsdisplayread, wsdisplaywrite,
168 wsdisplayioctl, wsdisplaystop, wsdisplaytty, wsdisplaypoll,
169 wsdisplaymmap, D_TTY
170 };
171
172 /* Exported tty- functions. */
173 static void wsdisplaystart(struct tty *);
174 static int wsdisplayparam(struct tty *, struct termios *);
175
176
177 /* Internal macros, functions, and variables. */
178 #define SET(t, f) (t) |= (f)
179 #define CLR(t, f) (t) &= ~(f)
180 #define ISSET(t, f) ((t) & (f))
181
182 #define WSDISPLAYUNIT(dev) (minor(dev) >> 8)
183 #define WSDISPLAYSCREEN(dev) (minor(dev) & 0xff)
184 #define ISWSDISPLAYCTL(dev) (WSDISPLAYSCREEN(dev) == 255)
185 #define WSDISPLAYMINOR(unit, screen) (((unit) << 8) | (screen))
186
187 #define WSSCREEN_HAS_EMULATOR(scr) ((scr)->scr_dconf->wsemul != NULL)
188 #define WSSCREEN_HAS_TTY(scr) ((scr)->scr_tty != NULL)
189
190 static void wsdisplay_common_attach(struct wsdisplay_softc *sc,
191 int console, int kbdmux, const struct wsscreen_list *,
192 const struct wsdisplay_accessops *accessops,
193 void *accesscookie);
194
195 #ifdef WSDISPLAY_COMPAT_RAWKBD
196 int wsdisplay_update_rawkbd(struct wsdisplay_softc *,
197 struct wsscreen *);
198 #endif
199
200 static int wsdisplay_console_initted;
201 static struct wsdisplay_softc *wsdisplay_console_device;
202 static struct wsscreen_internal wsdisplay_console_conf;
203
204 static int wsdisplay_getc_dummy(dev_t);
205 static void wsdisplay_pollc(dev_t, int);
206
207 static int wsdisplay_cons_pollmode;
208 static void (*wsdisplay_cons_kbd_pollc)(dev_t, int);
209
210 static struct consdev wsdisplay_cons = {
211 NULL, NULL, wsdisplay_getc_dummy, wsdisplay_cnputc,
212 wsdisplay_pollc, NULL, NODEV, CN_NORMAL
213 };
214
215 #ifndef WSDISPLAY_DEFAULTSCREENS
216 # define WSDISPLAY_DEFAULTSCREENS 0
217 #endif
218 int wsdisplay_defaultscreens = WSDISPLAY_DEFAULTSCREENS;
219
220 int wsdisplay_switch1(void *, int, int);
221 int wsdisplay_switch2(void *, int, int);
222 int wsdisplay_switch3(void *, int, int);
223
224 int wsdisplay_clearonclose;
225
226 struct wsscreen *
227 wsscreen_attach(struct wsdisplay_softc *sc, int console, const char *emul,
228 const struct wsscreen_descr *type, void *cookie, int ccol,
229 int crow, long defattr)
230 {
231 struct wsscreen_internal *dconf;
232 struct wsscreen *scr;
233
234 scr = malloc(sizeof(struct wsscreen), M_DEVBUF, M_WAITOK);
235 if (!scr)
236 return (NULL);
237
238 if (console) {
239 dconf = &wsdisplay_console_conf;
240 /*
241 * If there's an emulation, tell it about the callback argument.
242 * The other stuff is already there.
243 */
244 if (dconf->wsemul != NULL)
245 (*dconf->wsemul->attach)(1, 0, 0, 0, 0, scr, 0);
246 } else { /* not console */
247 dconf = malloc(sizeof(struct wsscreen_internal),
248 M_DEVBUF, M_NOWAIT);
249 dconf->emulops = type->textops;
250 dconf->emulcookie = cookie;
251 if (dconf->emulops) {
252 dconf->wsemul = wsemul_pick(emul);
253 if (dconf->wsemul == NULL) {
254 free(dconf, M_DEVBUF);
255 free(scr, M_DEVBUF);
256 return (NULL);
257 }
258 dconf->wsemulcookie =
259 (*dconf->wsemul->attach)(0, type, cookie,
260 ccol, crow, scr, defattr);
261 } else
262 dconf->wsemul = NULL;
263 dconf->scrdata = type;
264 }
265
266 scr->scr_dconf = dconf;
267
268 scr->scr_tty = ttymalloc();
269 tty_attach(scr->scr_tty);
270 scr->scr_hold_screen = 0;
271 if (WSSCREEN_HAS_EMULATOR(scr))
272 scr->scr_flags = 0;
273 else
274 scr->scr_flags = SCR_GRAPHICS;
275
276 scr->scr_syncops = 0;
277 scr->sc = sc;
278 #ifdef WSDISPLAY_COMPAT_RAWKBD
279 scr->scr_rawkbd = 0;
280 #endif
281 return (scr);
282 }
283
284 void
285 wsscreen_detach(struct wsscreen *scr)
286 {
287 int ccol, crow; /* XXX */
288
289 if (WSSCREEN_HAS_TTY(scr)) {
290 tty_detach(scr->scr_tty);
291 ttyfree(scr->scr_tty);
292 }
293 if (WSSCREEN_HAS_EMULATOR(scr))
294 (*scr->scr_dconf->wsemul->detach)(scr->scr_dconf->wsemulcookie,
295 &ccol, &crow);
296 free(scr->scr_dconf, M_DEVBUF);
297 free(scr, M_DEVBUF);
298 }
299
300 const struct wsscreen_descr *
301 wsdisplay_screentype_pick(const struct wsscreen_list *scrdata, const char *name)
302 {
303 int i;
304 const struct wsscreen_descr *scr;
305
306 KASSERT(scrdata->nscreens > 0);
307
308 if (name == NULL)
309 return (scrdata->screens[0]);
310
311 for (i = 0; i < scrdata->nscreens; i++) {
312 scr = scrdata->screens[i];
313 if (!strcmp(name, scr->name))
314 return (scr);
315 }
316
317 return (0);
318 }
319
320 /*
321 * print info about attached screen
322 */
323 static void
324 wsdisplay_addscreen_print(struct wsdisplay_softc *sc, int idx, int count)
325 {
326 printf("%s: screen %d", sc->sc_dv.dv_xname, idx);
327 if (count > 1)
328 printf("-%d", idx + (count-1));
329 printf(" added (%s", sc->sc_scr[idx]->scr_dconf->scrdata->name);
330 if (WSSCREEN_HAS_EMULATOR(sc->sc_scr[idx])) {
331 printf(", %s emulation",
332 sc->sc_scr[idx]->scr_dconf->wsemul->name);
333 }
334 printf(")\n");
335 }
336
337 int
338 wsdisplay_addscreen(struct wsdisplay_softc *sc, int idx,
339 const char *screentype, const char *emul)
340 {
341 const struct wsscreen_descr *scrdesc;
342 int error;
343 void *cookie;
344 int ccol, crow;
345 long defattr;
346 struct wsscreen *scr;
347 int s;
348
349 if (idx < 0 || idx >= WSDISPLAY_MAXSCREEN)
350 return (EINVAL);
351 if (sc->sc_scr[idx] != NULL)
352 return (EBUSY);
353
354 scrdesc = wsdisplay_screentype_pick(sc->sc_scrdata, screentype);
355 if (!scrdesc)
356 return (ENXIO);
357 error = (*sc->sc_accessops->alloc_screen)(sc->sc_accesscookie,
358 scrdesc, &cookie, &ccol, &crow, &defattr);
359 if (error)
360 return (error);
361
362 scr = wsscreen_attach(sc, 0, emul, scrdesc,
363 cookie, ccol, crow, defattr);
364 if (scr == NULL) {
365 (*sc->sc_accessops->free_screen)(sc->sc_accesscookie,
366 cookie);
367 return (ENXIO);
368 }
369
370 sc->sc_scr[idx] = scr;
371
372 /* if no screen has focus yet, activate the first we get */
373 s = spltty();
374 if (!sc->sc_focus) {
375 (*sc->sc_accessops->show_screen)(sc->sc_accesscookie,
376 scr->scr_dconf->emulcookie,
377 0, 0, 0);
378 sc->sc_focusidx = idx;
379 sc->sc_focus = scr;
380 }
381 splx(s);
382 return (0);
383 }
384
385 static void
386 wsdisplay_closescreen(struct wsdisplay_softc *sc, struct wsscreen *scr)
387 {
388 int maj, mn, idx;
389
390 /* hangup */
391 if (WSSCREEN_HAS_TTY(scr)) {
392 struct tty *tp = scr->scr_tty;
393 (*tp->t_linesw->l_modem)(tp, 0);
394 }
395
396 /* locate the major number */
397 maj = cdevsw_lookup_major(&wsdisplay_cdevsw);
398 /* locate the screen index */
399 for (idx = 0; idx < WSDISPLAY_MAXSCREEN; idx++)
400 if (scr == sc->sc_scr[idx])
401 break;
402 #ifdef DIAGNOSTIC
403 if (idx == WSDISPLAY_MAXSCREEN)
404 panic("wsdisplay_forceclose: bad screen");
405 #endif
406
407 /* nuke the vnodes */
408 mn = WSDISPLAYMINOR(sc->sc_dv.dv_unit, idx);
409 vdevgone(maj, mn, mn, VCHR);
410 }
411
412 int
413 wsdisplay_delscreen(struct wsdisplay_softc *sc, int idx, int flags)
414 {
415 struct wsscreen *scr;
416 int s;
417 void *cookie;
418
419 if (idx < 0 || idx >= WSDISPLAY_MAXSCREEN)
420 return (EINVAL);
421 scr = sc->sc_scr[idx];
422 if (!scr)
423 return (ENXIO);
424
425 if (scr->scr_dconf == &wsdisplay_console_conf ||
426 scr->scr_syncops ||
427 ((scr->scr_flags & SCR_OPEN) && !(flags & WSDISPLAY_DELSCR_FORCE)))
428 return(EBUSY);
429
430 wsdisplay_closescreen(sc, scr);
431
432 /*
433 * delete pointers, so neither device entries
434 * nor keyboard input can reference it anymore
435 */
436 s = spltty();
437 if (sc->sc_focus == scr) {
438 sc->sc_focus = 0;
439 #ifdef WSDISPLAY_COMPAT_RAWKBD
440 wsdisplay_update_rawkbd(sc, 0);
441 #endif
442 }
443 sc->sc_scr[idx] = 0;
444 splx(s);
445
446 /*
447 * Wake up processes waiting for the screen to
448 * be activated. Sleepers must check whether
449 * the screen still exists.
450 */
451 if (scr->scr_flags & SCR_WAITACTIVE)
452 wakeup(scr);
453
454 /* save a reference to the graphics screen */
455 cookie = scr->scr_dconf->emulcookie;
456
457 wsscreen_detach(scr);
458
459 (*sc->sc_accessops->free_screen)(sc->sc_accesscookie,
460 cookie);
461
462 printf("%s: screen %d deleted\n", sc->sc_dv.dv_xname, idx);
463 return (0);
464 }
465
466 /*
467 * Autoconfiguration functions.
468 */
469 int
470 wsdisplay_emul_match(struct device *parent, struct cfdata *match, void *aux)
471 {
472 struct wsemuldisplaydev_attach_args *ap = aux;
473
474 if (match->wsemuldisplaydevcf_console !=
475 WSEMULDISPLAYDEVCF_CONSOLE_UNK) {
476 /*
477 * If console-ness of device specified, either match
478 * exactly (at high priority), or fail.
479 */
480 if (match->wsemuldisplaydevcf_console != 0 &&
481 ap->console != 0)
482 return (10);
483 else
484 return (0);
485 }
486
487 /* If console-ness unspecified, it wins. */
488 return (1);
489 }
490
491 void
492 wsdisplay_emul_attach(struct device *parent, struct device *self, void *aux)
493 {
494 struct wsdisplay_softc *sc = (struct wsdisplay_softc *)self;
495 struct wsemuldisplaydev_attach_args *ap = aux;
496
497 wsdisplay_common_attach(sc, ap->console,
498 sc->sc_dv.dv_cfdata->wsemuldisplaydevcf_kbdmux, ap->scrdata,
499 ap->accessops, ap->accesscookie);
500
501 if (ap->console) {
502 int maj;
503
504 /* locate the major number */
505 maj = cdevsw_lookup_major(&wsdisplay_cdevsw);
506
507 cn_tab->cn_dev = makedev(maj, WSDISPLAYMINOR(self->dv_unit, 0));
508 }
509 }
510
511 /* Print function (for parent devices). */
512 int
513 wsemuldisplaydevprint(void *aux, const char *pnp)
514 {
515 #if 0 /* -Wunused */
516 struct wsemuldisplaydev_attach_args *ap = aux;
517 #endif
518
519 if (pnp)
520 printf("wsdisplay at %s", pnp);
521 #if 0 /* don't bother; it's ugly */
522 printf(" console %d", ap->console);
523 #endif
524
525 return (UNCONF);
526 }
527
528 int
529 wsdisplay_noemul_match(struct device *parent, struct cfdata *match, void *aux)
530 {
531 #if 0 /* -Wunused */
532 struct wsdisplaydev_attach_args *ap = aux;
533 #endif
534
535 /* Always match. */
536 return (1);
537 }
538
539 void
540 wsdisplay_noemul_attach(struct device *parent, struct device *self, void *aux)
541 {
542 struct wsdisplay_softc *sc = (struct wsdisplay_softc *)self;
543 struct wsdisplaydev_attach_args *ap = aux;
544
545 wsdisplay_common_attach(sc, 0,
546 sc->sc_dv.dv_cfdata->wsemuldisplaydevcf_kbdmux, NULL,
547 ap->accessops, ap->accesscookie);
548 }
549
550 /* Print function (for parent devices). */
551 int
552 wsdisplaydevprint(void *aux, const char *pnp)
553 {
554 #if 0 /* -Wunused */
555 struct wsdisplaydev_attach_args *ap = aux;
556 #endif
557
558 if (pnp)
559 printf("wsdisplay at %s", pnp);
560
561 return (UNCONF);
562 }
563
564 static void
565 wsdisplay_common_attach(struct wsdisplay_softc *sc, int console, int kbdmux,
566 const struct wsscreen_list *scrdata,
567 const struct wsdisplay_accessops *accessops,
568 void *accesscookie)
569 {
570 static int hookset;
571 int i, start=0;
572 #if NWSKBD > 0
573 struct wsevsrc *kme;
574 #if NWSMUX > 0
575 struct wsmux_softc *mux;
576
577 if (kbdmux >= 0)
578 mux = wsmux_getmux(kbdmux);
579 else
580 mux = wsmux_create("dmux", sc->sc_dv.dv_unit);
581 /* XXX panic()ing isn't nice, but attach cannot fail */
582 if (mux == NULL)
583 panic("wsdisplay_common_attach: no memory\n");
584 sc->sc_input = &mux->sc_base;
585 mux->sc_base.me_dispdv = &sc->sc_dv;
586 printf(" kbdmux %d", kbdmux);
587 #else
588 if (kbdmux >= 0)
589 printf(" (kbdmux ignored)");
590 #endif
591 #endif
592
593 sc->sc_isconsole = console;
594
595 if (console) {
596 KASSERT(wsdisplay_console_initted);
597 KASSERT(wsdisplay_console_device == NULL);
598
599 sc->sc_scr[0] = wsscreen_attach(sc, 1, 0, 0, 0, 0, 0, 0);
600 wsdisplay_console_device = sc;
601
602 printf(": console (%s, %s emulation)",
603 wsdisplay_console_conf.scrdata->name,
604 wsdisplay_console_conf.wsemul->name);
605
606 #if NWSKBD > 0
607 kme = wskbd_set_console_display(&sc->sc_dv, sc->sc_input);
608 if (kme != NULL)
609 printf(", using %s", kme->me_dv.dv_xname);
610 #if NWSMUX == 0
611 sc->sc_input = kme;
612 #endif
613 #endif
614
615 sc->sc_focusidx = 0;
616 sc->sc_focus = sc->sc_scr[0];
617 start = 1;
618 }
619 printf("\n");
620
621 #if NWSKBD > 0 && NWSMUX > 0
622 wsmux_set_display(mux, &sc->sc_dv);
623 #endif
624
625 sc->sc_accessops = accessops;
626 sc->sc_accesscookie = accesscookie;
627 sc->sc_scrdata = scrdata;
628
629 /*
630 * Set up a number of virtual screens if wanted. The
631 * WSDISPLAYIO_ADDSCREEN ioctl is more flexible, so this code
632 * is for special cases like installation kernels.
633 */
634 for (i = start; i < wsdisplay_defaultscreens; i++) {
635 if (wsdisplay_addscreen(sc, i, 0, 0))
636 break;
637 }
638
639 if (i > start)
640 wsdisplay_addscreen_print(sc, start, i-start);
641
642 if (hookset == 0)
643 shutdownhook_establish(wsdisplay_shutdownhook, NULL);
644 hookset = 1;
645 }
646
647 void
648 wsdisplay_cnattach(const struct wsscreen_descr *type, void *cookie,
649 int ccol, int crow, long defattr)
650 {
651 const struct wsemul_ops *wsemul;
652
653 KASSERT(!wsdisplay_console_initted);
654 KASSERT(type->nrows > 0);
655 KASSERT(type->ncols > 0);
656 KASSERT(crow < type->nrows);
657 KASSERT(ccol < type->ncols);
658
659 wsdisplay_console_conf.emulops = type->textops;
660 wsdisplay_console_conf.emulcookie = cookie;
661 wsdisplay_console_conf.scrdata = type;
662
663 wsemul = wsemul_pick(0); /* default */
664 wsdisplay_console_conf.wsemul = wsemul;
665 wsdisplay_console_conf.wsemulcookie = (*wsemul->cnattach)(type, cookie,
666 ccol, crow,
667 defattr);
668
669 cn_tab = &wsdisplay_cons;
670 wsdisplay_console_initted = 1;
671 }
672
673 /*
674 * Tty and cdevsw functions.
675 */
676 int
677 wsdisplayopen(dev_t dev, int flag, int mode, struct proc *p)
678 {
679 struct wsdisplay_softc *sc;
680 struct tty *tp;
681 int newopen, error;
682 struct wsscreen *scr;
683
684 sc = device_lookup(&wsdisplay_cd, WSDISPLAYUNIT(dev));
685 if (sc == NULL) /* make sure it was attached */
686 return (ENXIO);
687
688 if (ISWSDISPLAYCTL(dev))
689 return (0);
690
691 if (WSDISPLAYSCREEN(dev) >= WSDISPLAY_MAXSCREEN)
692 return (ENXIO);
693 scr = sc->sc_scr[WSDISPLAYSCREEN(dev)];
694 if (!scr)
695 return (ENXIO);
696
697 if (WSSCREEN_HAS_TTY(scr)) {
698 tp = scr->scr_tty;
699 tp->t_oproc = wsdisplaystart;
700 tp->t_param = wsdisplayparam;
701 tp->t_dev = dev;
702 newopen = (tp->t_state & TS_ISOPEN) == 0;
703 if (newopen) {
704 ttychars(tp);
705 tp->t_iflag = TTYDEF_IFLAG;
706 tp->t_oflag = TTYDEF_OFLAG;
707 tp->t_cflag = TTYDEF_CFLAG;
708 tp->t_lflag = TTYDEF_LFLAG;
709 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
710 wsdisplayparam(tp, &tp->t_termios);
711 ttsetwater(tp);
712 } else if ((tp->t_state & TS_XCLUDE) != 0 &&
713 p->p_ucred->cr_uid != 0)
714 return EBUSY;
715 tp->t_state |= TS_CARR_ON;
716
717 error = ((*tp->t_linesw->l_open)(dev, tp));
718 if (error)
719 return (error);
720
721 if (newopen && WSSCREEN_HAS_EMULATOR(scr)) {
722 /* set window sizes as appropriate, and reset
723 the emulation */
724 tp->t_winsize.ws_row = scr->scr_dconf->scrdata->nrows;
725 tp->t_winsize.ws_col = scr->scr_dconf->scrdata->ncols;
726
727 /* wsdisplay_set_emulation() */
728 }
729 }
730
731 scr->scr_flags |= SCR_OPEN;
732 return (0);
733 }
734
735 int
736 wsdisplayclose(dev_t dev, int flag, int mode, struct proc *p)
737 {
738 struct wsdisplay_softc *sc;
739 struct tty *tp;
740 struct wsscreen *scr;
741
742 sc = device_lookup(&wsdisplay_cd, WSDISPLAYUNIT(dev));
743
744 if (ISWSDISPLAYCTL(dev))
745 return (0);
746
747 scr = sc->sc_scr[WSDISPLAYSCREEN(dev)];
748
749 if (WSSCREEN_HAS_TTY(scr)) {
750 if (scr->scr_hold_screen) {
751 int s;
752
753 /* XXX RESET KEYBOARD LEDS, etc. */
754 s = spltty(); /* avoid conflict with keyboard */
755 wsdisplay_kbdholdscreen((struct device *)sc, 0);
756 splx(s);
757 }
758 tp = scr->scr_tty;
759 (*tp->t_linesw->l_close)(tp, flag);
760 ttyclose(tp);
761 }
762
763 if (scr->scr_syncops)
764 (*scr->scr_syncops->destroy)(scr->scr_synccookie);
765
766 if (WSSCREEN_HAS_EMULATOR(scr)) {
767 scr->scr_flags &= ~SCR_GRAPHICS;
768 (*scr->scr_dconf->wsemul->reset)(scr->scr_dconf->wsemulcookie,
769 WSEMUL_RESET);
770 if (wsdisplay_clearonclose)
771 (*scr->scr_dconf->wsemul->reset)
772 (scr->scr_dconf->wsemulcookie,
773 WSEMUL_CLEARSCREEN);
774 }
775
776 #ifdef WSDISPLAY_COMPAT_RAWKBD
777 if (scr->scr_rawkbd) {
778 int kbmode = WSKBD_TRANSLATED;
779 (void)wsdisplay_internal_ioctl(sc, scr, WSKBDIO_SETMODE,
780 (caddr_t)&kbmode, 0, p);
781 }
782 #endif
783
784 scr->scr_flags &= ~SCR_OPEN;
785
786 return (0);
787 }
788
789 int
790 wsdisplayread(dev_t dev, struct uio *uio, int flag)
791 {
792 struct wsdisplay_softc *sc;
793 struct tty *tp;
794 struct wsscreen *scr;
795
796 sc = device_lookup(&wsdisplay_cd, WSDISPLAYUNIT(dev));
797
798 if (ISWSDISPLAYCTL(dev))
799 return (0);
800
801 scr = sc->sc_scr[WSDISPLAYSCREEN(dev)];
802
803 if (!WSSCREEN_HAS_TTY(scr))
804 return (ENODEV);
805
806 tp = scr->scr_tty;
807 return ((*tp->t_linesw->l_read)(tp, uio, flag));
808 }
809
810 int
811 wsdisplaywrite(dev_t dev, struct uio *uio, int flag)
812 {
813 struct wsdisplay_softc *sc;
814 struct tty *tp;
815 struct wsscreen *scr;
816
817 sc = device_lookup(&wsdisplay_cd, WSDISPLAYUNIT(dev));
818
819 if (ISWSDISPLAYCTL(dev))
820 return (0);
821
822 scr = sc->sc_scr[WSDISPLAYSCREEN(dev)];
823
824 if (!WSSCREEN_HAS_TTY(scr))
825 return (ENODEV);
826
827 tp = scr->scr_tty;
828 return ((*tp->t_linesw->l_write)(tp, uio, flag));
829 }
830
831 int
832 wsdisplaypoll(dev_t dev, int events, struct proc *p)
833 {
834 struct wsdisplay_softc *sc;
835 struct tty *tp;
836 struct wsscreen *scr;
837
838 sc = device_lookup(&wsdisplay_cd, WSDISPLAYUNIT(dev));
839
840 if (ISWSDISPLAYCTL(dev))
841 return (0);
842
843 scr = sc->sc_scr[WSDISPLAYSCREEN(dev)];
844
845 if (!WSSCREEN_HAS_TTY(scr))
846 return (ENODEV);
847
848 tp = scr->scr_tty;
849 return ((*tp->t_linesw->l_poll)(tp, events, p));
850 }
851
852 struct tty *
853 wsdisplaytty(dev_t dev)
854 {
855 struct wsdisplay_softc *sc;
856 struct wsscreen *scr;
857
858 sc = device_lookup(&wsdisplay_cd, WSDISPLAYUNIT(dev));
859
860 if (ISWSDISPLAYCTL(dev))
861 panic("wsdisplaytty() on ctl device");
862
863 scr = sc->sc_scr[WSDISPLAYSCREEN(dev)];
864
865 return (scr->scr_tty);
866 }
867
868 int
869 wsdisplayioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
870 {
871 struct wsdisplay_softc *sc;
872 struct tty *tp;
873 int error;
874 struct wsscreen *scr;
875
876 sc = device_lookup(&wsdisplay_cd, WSDISPLAYUNIT(dev));
877
878 #ifdef WSDISPLAY_COMPAT_USL
879 error = wsdisplay_usl_ioctl1(sc, cmd, data, flag, p);
880 if (error != EPASSTHROUGH)
881 return (error);
882 #endif
883
884 if (ISWSDISPLAYCTL(dev))
885 return (wsdisplay_cfg_ioctl(sc, cmd, data, flag, p));
886
887 scr = sc->sc_scr[WSDISPLAYSCREEN(dev)];
888
889 if (WSSCREEN_HAS_TTY(scr)) {
890 tp = scr->scr_tty;
891
892 /* printf("disc\n"); */
893 /* do the line discipline ioctls first */
894 error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, p);
895 if (error != EPASSTHROUGH)
896 return (error);
897
898 /* printf("tty\n"); */
899 /* then the tty ioctls */
900 error = ttioctl(tp, cmd, data, flag, p);
901 if (error != EPASSTHROUGH)
902 return (error);
903 }
904
905 #ifdef WSDISPLAY_COMPAT_USL
906 error = wsdisplay_usl_ioctl2(sc, scr, cmd, data, flag, p);
907 if (error != EPASSTHROUGH)
908 return (error);
909 #endif
910
911 return (wsdisplay_internal_ioctl(sc, scr, cmd, data, flag, p));
912 }
913
914 int
915 wsdisplay_param(struct device *dev, u_long cmd, struct wsdisplay_param *dp)
916 {
917 struct wsdisplay_softc *sc = (struct wsdisplay_softc *)dev;
918 return ((*sc->sc_accessops->ioctl)(sc->sc_accesscookie, cmd,
919 (caddr_t)dp, 0, NULL));
920 }
921
922 int
923 wsdisplay_internal_ioctl(struct wsdisplay_softc *sc, struct wsscreen *scr,
924 u_long cmd, caddr_t data, int flag, struct proc *p)
925 {
926 int error;
927 char namebuf[16];
928 struct wsdisplay_font fd;
929
930 #if NWSKBD > 0
931 struct wsevsrc *inp;
932
933 #ifdef WSDISPLAY_COMPAT_RAWKBD
934 switch (cmd) {
935 case WSKBDIO_SETMODE:
936 scr->scr_rawkbd = (*(int *)data == WSKBD_RAW);
937 return (wsdisplay_update_rawkbd(sc, scr));
938 case WSKBDIO_GETMODE:
939 *(int *)data = (scr->scr_rawkbd ?
940 WSKBD_RAW : WSKBD_TRANSLATED);
941 return (0);
942 }
943 #endif
944 inp = sc->sc_input;
945 if (inp == NULL)
946 return (ENXIO);
947 error = wsevsrc_display_ioctl(inp, cmd, data, flag, p);
948 if (error != EPASSTHROUGH)
949 return (error);
950 #endif /* NWSKBD > 0 */
951
952 switch (cmd) {
953 case WSDISPLAYIO_GMODE:
954 *(u_int *)data = (scr->scr_flags & SCR_GRAPHICS ?
955 WSDISPLAYIO_MODE_MAPPED :
956 WSDISPLAYIO_MODE_EMUL);
957 return (0);
958
959 case WSDISPLAYIO_SMODE:
960 #define d (*(int *)data)
961 if (d != WSDISPLAYIO_MODE_EMUL &&
962 d != WSDISPLAYIO_MODE_MAPPED)
963 return (EINVAL);
964
965 if (WSSCREEN_HAS_EMULATOR(scr)) {
966 scr->scr_flags &= ~SCR_GRAPHICS;
967 if (d == WSDISPLAYIO_MODE_MAPPED)
968 scr->scr_flags |= SCR_GRAPHICS;
969 } else if (d == WSDISPLAYIO_MODE_EMUL)
970 return (EINVAL);
971
972 (void)(*sc->sc_accessops->ioctl)(sc->sc_accesscookie, cmd, data,
973 flag, p);
974
975 return (0);
976 #undef d
977
978 case WSDISPLAYIO_SFONT:
979 #define d ((struct wsdisplay_usefontdata *)data)
980 if (!sc->sc_accessops->load_font)
981 return (EINVAL);
982 if (d->name) {
983 error = copyinstr(d->name, namebuf, sizeof(namebuf), 0);
984 if (error)
985 return (error);
986 fd.name = namebuf;
987 } else
988 fd.name = 0;
989 fd.data = 0;
990 error = (*sc->sc_accessops->load_font)(sc->sc_accesscookie,
991 scr->scr_dconf->emulcookie, &fd);
992 if (!error && WSSCREEN_HAS_EMULATOR(scr))
993 (*scr->scr_dconf->wsemul->reset)
994 (scr->scr_dconf->wsemulcookie, WSEMUL_SYNCFONT);
995 return (error);
996 #undef d
997 }
998
999 /* check ioctls for display */
1000 return ((*sc->sc_accessops->ioctl)(sc->sc_accesscookie, cmd, data,
1001 flag, p));
1002 }
1003
1004 int
1005 wsdisplay_cfg_ioctl(struct wsdisplay_softc *sc, u_long cmd, caddr_t data,
1006 int flag, struct proc *p)
1007 {
1008 int error;
1009 char *type, typebuf[16], *emul, emulbuf[16];
1010 void *buf;
1011 u_int fontsz;
1012 #if defined(COMPAT_14) && NWSKBD > 0
1013 struct wsmux_device wsmuxdata;
1014 #endif
1015 #if NWSKBD > 0
1016 struct wsevsrc *inp;
1017 #endif
1018
1019 switch (cmd) {
1020 case WSDISPLAYIO_ADDSCREEN:
1021 #define d ((struct wsdisplay_addscreendata *)data)
1022 if (d->screentype) {
1023 error = copyinstr(d->screentype, typebuf,
1024 sizeof(typebuf), 0);
1025 if (error)
1026 return (error);
1027 type = typebuf;
1028 } else
1029 type = 0;
1030 if (d->emul) {
1031 error = copyinstr(d->emul, emulbuf, sizeof(emulbuf),0);
1032 if (error)
1033 return (error);
1034 emul = emulbuf;
1035 } else
1036 emul = 0;
1037
1038 if ((error = wsdisplay_addscreen(sc, d->idx, type, emul)) == 0)
1039 wsdisplay_addscreen_print(sc, d->idx, 0);
1040 return (error);
1041 #undef d
1042 case WSDISPLAYIO_DELSCREEN:
1043 #define d ((struct wsdisplay_delscreendata *)data)
1044 return (wsdisplay_delscreen(sc, d->idx, d->flags));
1045 #undef d
1046 case WSDISPLAYIO_LDFONT:
1047 #define d ((struct wsdisplay_font *)data)
1048 if (!sc->sc_accessops->load_font)
1049 return (EINVAL);
1050 if (d->name) {
1051 error = copyinstr(d->name, typebuf, sizeof(typebuf), 0);
1052 if (error)
1053 return (error);
1054 d->name = typebuf;
1055 } else
1056 d->name = "loaded"; /* ??? */
1057 fontsz = d->fontheight * d->stride * d->numchars;
1058 if (fontsz > WSDISPLAY_MAXFONTSZ)
1059 return (EINVAL);
1060
1061 buf = malloc(fontsz, M_DEVBUF, M_WAITOK);
1062 error = copyin(d->data, buf, fontsz);
1063 if (error) {
1064 free(buf, M_DEVBUF);
1065 return (error);
1066 }
1067 d->data = buf;
1068 error =
1069 (*sc->sc_accessops->load_font)(sc->sc_accesscookie, 0, d);
1070 free(buf, M_DEVBUF);
1071 #undef d
1072 return (error);
1073
1074 #if NWSKBD > 0
1075 #ifdef COMPAT_14
1076 case _O_WSDISPLAYIO_SETKEYBOARD:
1077 #define d ((struct wsdisplay_kbddata *)data)
1078 inp = sc->sc_input;
1079 if (inp == NULL)
1080 return (ENXIO);
1081 switch (d->op) {
1082 case _O_WSDISPLAY_KBD_ADD:
1083 if (d->idx == -1) {
1084 d->idx = wskbd_pickfree();
1085 if (d->idx == -1)
1086 return (ENXIO);
1087 }
1088 wsmuxdata.type = WSMUX_KBD;
1089 wsmuxdata.idx = d->idx;
1090 return (wsevsrc_ioctl(inp, WSMUX_ADD_DEVICE,
1091 &wsmuxdata, flag, p));
1092 case _O_WSDISPLAY_KBD_DEL:
1093 wsmuxdata.type = WSMUX_KBD;
1094 wsmuxdata.idx = d->idx;
1095 return (wsevsrc_ioctl(inp, WSMUX_REMOVE_DEVICE,
1096 &wsmuxdata, flag, p));
1097 default:
1098 return (EINVAL);
1099 }
1100 #undef d
1101 #endif
1102
1103 case WSMUXIO_ADD_DEVICE:
1104 #define d ((struct wsmux_device *)data)
1105 if (d->idx == -1 && d->type == WSMUX_KBD)
1106 d->idx = wskbd_pickfree();
1107 #undef d
1108 /* fall into */
1109 case WSMUXIO_INJECTEVENT:
1110 case WSMUXIO_REMOVE_DEVICE:
1111 case WSMUXIO_LIST_DEVICES:
1112 inp = sc->sc_input;
1113 if (inp == NULL)
1114 return (ENXIO);
1115 return (wsevsrc_ioctl(inp, cmd, data, flag, p));
1116 #endif /* NWSKBD > 0 */
1117
1118 }
1119 return (EPASSTHROUGH);
1120 }
1121
1122 paddr_t
1123 wsdisplaymmap(dev_t dev, off_t offset, int prot)
1124 {
1125 struct wsdisplay_softc *sc =
1126 device_lookup(&wsdisplay_cd, WSDISPLAYUNIT(dev));
1127 struct wsscreen *scr;
1128
1129 if (ISWSDISPLAYCTL(dev))
1130 return (-1);
1131
1132 scr = sc->sc_scr[WSDISPLAYSCREEN(dev)];
1133
1134 if (!(scr->scr_flags & SCR_GRAPHICS))
1135 return (-1);
1136
1137 /* pass mmap to display */
1138 return ((*sc->sc_accessops->mmap)(sc->sc_accesscookie, offset, prot));
1139 }
1140
1141 void
1142 wsdisplaystart(struct tty *tp)
1143 {
1144 struct wsdisplay_softc *sc;
1145 struct wsscreen *scr;
1146 int s, n;
1147 u_char *buf;
1148
1149 s = spltty();
1150 if (tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP)) {
1151 splx(s);
1152 return;
1153 }
1154 sc = device_lookup(&wsdisplay_cd, WSDISPLAYUNIT(tp->t_dev));
1155 scr = sc->sc_scr[WSDISPLAYSCREEN(tp->t_dev)];
1156 if (scr->scr_hold_screen) {
1157 tp->t_state |= TS_TIMEOUT;
1158 splx(s);
1159 return;
1160 }
1161 tp->t_state |= TS_BUSY;
1162 splx(s);
1163
1164 /*
1165 * Drain output from ring buffer.
1166 * The output will normally be in one contiguous chunk, but when the
1167 * ring wraps, it will be in two pieces.. one at the end of the ring,
1168 * the other at the start. For performance, rather than loop here,
1169 * we output one chunk, see if there's another one, and if so, output
1170 * it too.
1171 */
1172
1173 n = ndqb(&tp->t_outq, 0);
1174 buf = tp->t_outq.c_cf;
1175
1176 if (!(scr->scr_flags & SCR_GRAPHICS)) {
1177 KASSERT(WSSCREEN_HAS_EMULATOR(scr));
1178 (*scr->scr_dconf->wsemul->output)(scr->scr_dconf->wsemulcookie,
1179 buf, n, 0);
1180 }
1181 ndflush(&tp->t_outq, n);
1182
1183 if ((n = ndqb(&tp->t_outq, 0)) > 0) {
1184 buf = tp->t_outq.c_cf;
1185
1186 if (!(scr->scr_flags & SCR_GRAPHICS)) {
1187 KASSERT(WSSCREEN_HAS_EMULATOR(scr));
1188 (*scr->scr_dconf->wsemul->output)(scr->scr_dconf->wsemulcookie,
1189 buf, n, 0);
1190 }
1191 ndflush(&tp->t_outq, n);
1192 }
1193
1194 s = spltty();
1195 tp->t_state &= ~TS_BUSY;
1196 /* Come back if there's more to do */
1197 if (tp->t_outq.c_cc) {
1198 tp->t_state |= TS_TIMEOUT;
1199 callout_reset(&tp->t_rstrt_ch, (hz > 128) ? (hz / 128) : 1,
1200 ttrstrt, tp);
1201 }
1202 if (tp->t_outq.c_cc <= tp->t_lowat) {
1203 if (tp->t_state&TS_ASLEEP) {
1204 tp->t_state &= ~TS_ASLEEP;
1205 wakeup(&tp->t_outq);
1206 }
1207 selwakeup(&tp->t_wsel);
1208 }
1209 splx(s);
1210 }
1211
1212 void
1213 wsdisplaystop(struct tty *tp, int flag)
1214 {
1215 int s;
1216
1217 s = spltty();
1218 if (ISSET(tp->t_state, TS_BUSY))
1219 if (!ISSET(tp->t_state, TS_TTSTOP))
1220 SET(tp->t_state, TS_FLUSH);
1221 splx(s);
1222 }
1223
1224 /* Set line parameters. */
1225 int
1226 wsdisplayparam(struct tty *tp, struct termios *t)
1227 {
1228
1229 tp->t_ispeed = t->c_ispeed;
1230 tp->t_ospeed = t->c_ospeed;
1231 tp->t_cflag = t->c_cflag;
1232 return 0;
1233 }
1234
1235 /*
1236 * Callbacks for the emulation code.
1237 */
1238 void
1239 wsdisplay_emulbell(void *v)
1240 {
1241 struct wsscreen *scr = v;
1242
1243 if (scr == NULL) /* console, before real attach */
1244 return;
1245
1246 if (scr->scr_flags & SCR_GRAPHICS) /* can this happen? */
1247 return;
1248
1249 (void) wsdisplay_internal_ioctl(scr->sc, scr, WSKBDIO_BELL, NULL,
1250 FWRITE, NULL);
1251 }
1252
1253 void
1254 wsdisplay_emulinput(void *v, const u_char *data, u_int count)
1255 {
1256 struct wsscreen *scr = v;
1257 struct tty *tp;
1258
1259 if (v == NULL) /* console, before real attach */
1260 return;
1261
1262 if (scr->scr_flags & SCR_GRAPHICS) /* XXX can't happen */
1263 return;
1264 if (!WSSCREEN_HAS_TTY(scr))
1265 return;
1266
1267 tp = scr->scr_tty;
1268 while (count-- > 0)
1269 (*tp->t_linesw->l_rint)(*data++, tp);
1270 };
1271
1272 /*
1273 * Calls from the keyboard interface.
1274 */
1275 void
1276 wsdisplay_kbdinput(struct device *dev, keysym_t ks)
1277 {
1278 struct wsdisplay_softc *sc = (struct wsdisplay_softc *)dev;
1279 struct wsscreen *scr;
1280 char *dp;
1281 int count;
1282 struct tty *tp;
1283
1284 KASSERT(sc != NULL);
1285
1286 scr = sc->sc_focus;
1287
1288 if (!scr || !WSSCREEN_HAS_TTY(scr))
1289 return;
1290
1291 tp = scr->scr_tty;
1292
1293 if (KS_GROUP(ks) == KS_GROUP_Ascii)
1294 (*tp->t_linesw->l_rint)(KS_VALUE(ks), tp);
1295 else if (WSSCREEN_HAS_EMULATOR(scr)) {
1296 count = (*scr->scr_dconf->wsemul->translate)
1297 (scr->scr_dconf->wsemulcookie, ks, &dp);
1298 while (count-- > 0)
1299 (*tp->t_linesw->l_rint)(*dp++, tp);
1300 }
1301 }
1302
1303 #if defined(WSDISPLAY_COMPAT_RAWKBD)
1304 int
1305 wsdisplay_update_rawkbd(struct wsdisplay_softc *sc, struct wsscreen *scr)
1306 {
1307 #if NWSKBD > 0
1308 int s, raw, data, error;
1309 struct wsevsrc *inp;
1310
1311 s = spltty();
1312
1313 raw = (scr ? scr->scr_rawkbd : 0);
1314
1315 if (scr != sc->sc_focus ||
1316 sc->sc_rawkbd == raw) {
1317 splx(s);
1318 return (0);
1319 }
1320
1321 data = raw ? WSKBD_RAW : WSKBD_TRANSLATED;
1322 inp = sc->sc_input;
1323 if (inp == NULL)
1324 return (ENXIO);
1325 error = wsevsrc_display_ioctl(inp, WSKBDIO_SETMODE, &data, 0, 0);
1326 if (!error)
1327 sc->sc_rawkbd = raw;
1328 splx(s);
1329 return (error);
1330 #else
1331 return (0);
1332 #endif
1333 }
1334 #endif
1335
1336 int
1337 wsdisplay_switch3(void *arg, int error, int waitok)
1338 {
1339 struct wsdisplay_softc *sc = arg;
1340 int no;
1341 struct wsscreen *scr;
1342
1343 if (!(sc->sc_flags & SC_SWITCHPENDING)) {
1344 printf("wsdisplay_switch3: not switching\n");
1345 return (EINVAL);
1346 }
1347
1348 no = sc->sc_screenwanted;
1349 if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
1350 panic("wsdisplay_switch3: invalid screen %d", no);
1351 scr = sc->sc_scr[no];
1352 if (!scr) {
1353 printf("wsdisplay_switch3: screen %d disappeared\n", no);
1354 error = ENXIO;
1355 }
1356
1357 if (error) {
1358 /* try to recover, avoid recursion */
1359
1360 if (sc->sc_oldscreen == WSDISPLAY_NULLSCREEN) {
1361 printf("wsdisplay_switch3: giving up\n");
1362 sc->sc_focus = 0;
1363 #ifdef WSDISPLAY_COMPAT_RAWKBD
1364 wsdisplay_update_rawkbd(sc, 0);
1365 #endif
1366 sc->sc_flags &= ~SC_SWITCHPENDING;
1367 return (error);
1368 }
1369
1370 sc->sc_screenwanted = sc->sc_oldscreen;
1371 sc->sc_oldscreen = WSDISPLAY_NULLSCREEN;
1372 return (wsdisplay_switch1(arg, 0, waitok));
1373 }
1374
1375 sc->sc_flags &= ~SC_SWITCHPENDING;
1376
1377 if (!error && (scr->scr_flags & SCR_WAITACTIVE))
1378 wakeup(scr);
1379 return (error);
1380 }
1381
1382 int
1383 wsdisplay_switch2(void *arg, int error, int waitok)
1384 {
1385 struct wsdisplay_softc *sc = arg;
1386 int no;
1387 struct wsscreen *scr;
1388
1389 if (!(sc->sc_flags & SC_SWITCHPENDING)) {
1390 printf("wsdisplay_switch2: not switching\n");
1391 return (EINVAL);
1392 }
1393
1394 no = sc->sc_screenwanted;
1395 if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
1396 panic("wsdisplay_switch2: invalid screen %d", no);
1397 scr = sc->sc_scr[no];
1398 if (!scr) {
1399 printf("wsdisplay_switch2: screen %d disappeared\n", no);
1400 error = ENXIO;
1401 }
1402
1403 if (error) {
1404 /* try to recover, avoid recursion */
1405
1406 if (sc->sc_oldscreen == WSDISPLAY_NULLSCREEN) {
1407 printf("wsdisplay_switch2: giving up\n");
1408 sc->sc_focus = 0;
1409 sc->sc_flags &= ~SC_SWITCHPENDING;
1410 return (error);
1411 }
1412
1413 sc->sc_screenwanted = sc->sc_oldscreen;
1414 sc->sc_oldscreen = WSDISPLAY_NULLSCREEN;
1415 return (wsdisplay_switch1(arg, 0, waitok));
1416 }
1417
1418 sc->sc_focusidx = no;
1419 sc->sc_focus = scr;
1420
1421 #ifdef WSDISPLAY_COMPAT_RAWKBD
1422 (void) wsdisplay_update_rawkbd(sc, scr);
1423 #endif
1424 /* keyboard map??? */
1425
1426 #define wsswitch_cb3 ((void (*)(void *, int, int))wsdisplay_switch3)
1427 if (scr->scr_syncops) {
1428 error = (*scr->scr_syncops->attach)(scr->scr_synccookie, waitok,
1429 sc->sc_isconsole && wsdisplay_cons_pollmode ? 0 : wsswitch_cb3, sc);
1430 if (error == EAGAIN) {
1431 /* switch will be done asynchronously */
1432 return (0);
1433 }
1434 }
1435
1436 return (wsdisplay_switch3(sc, error, waitok));
1437 }
1438
1439 int
1440 wsdisplay_switch1(void *arg, int error, int waitok)
1441 {
1442 struct wsdisplay_softc *sc = arg;
1443 int no;
1444 struct wsscreen *scr;
1445
1446 if (!(sc->sc_flags & SC_SWITCHPENDING)) {
1447 printf("wsdisplay_switch1: not switching\n");
1448 return (EINVAL);
1449 }
1450
1451 no = sc->sc_screenwanted;
1452 if (no == WSDISPLAY_NULLSCREEN) {
1453 sc->sc_flags &= ~SC_SWITCHPENDING;
1454 if (!error) {
1455 sc->sc_focus = 0;
1456 }
1457 wakeup(sc);
1458 return (error);
1459 }
1460 if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
1461 panic("wsdisplay_switch1: invalid screen %d", no);
1462 scr = sc->sc_scr[no];
1463 if (!scr) {
1464 printf("wsdisplay_switch1: screen %d disappeared\n", no);
1465 error = ENXIO;
1466 }
1467
1468 if (error) {
1469 sc->sc_flags &= ~SC_SWITCHPENDING;
1470 return (error);
1471 }
1472
1473 #define wsswitch_cb2 ((void (*)(void *, int, int))wsdisplay_switch2)
1474 error = (*sc->sc_accessops->show_screen)(sc->sc_accesscookie,
1475 scr->scr_dconf->emulcookie,
1476 waitok,
1477 sc->sc_isconsole && wsdisplay_cons_pollmode ? 0 : wsswitch_cb2, sc);
1478 if (error == EAGAIN) {
1479 /* switch will be done asynchronously */
1480 return (0);
1481 }
1482
1483 return (wsdisplay_switch2(sc, error, waitok));
1484 }
1485
1486 int
1487 wsdisplay_switch(struct device *dev, int no, int waitok)
1488 {
1489 struct wsdisplay_softc *sc = (struct wsdisplay_softc *)dev;
1490 int s, res = 0;
1491 struct wsscreen *scr;
1492
1493 if (no != WSDISPLAY_NULLSCREEN &&
1494 (no < 0 || no >= WSDISPLAY_MAXSCREEN || !sc->sc_scr[no]))
1495 return (ENXIO);
1496
1497 s = spltty();
1498
1499 if ((sc->sc_focus && no == sc->sc_focusidx) ||
1500 (sc->sc_focus == NULL && no == WSDISPLAY_NULLSCREEN)) {
1501 splx(s);
1502 return (0);
1503 }
1504
1505 if (sc->sc_flags & SC_SWITCHPENDING) {
1506 splx(s);
1507 return (EBUSY);
1508 }
1509
1510 sc->sc_flags |= SC_SWITCHPENDING;
1511 sc->sc_screenwanted = no;
1512
1513 splx(s);
1514
1515 scr = sc->sc_focus;
1516 if (!scr) {
1517 sc->sc_oldscreen = WSDISPLAY_NULLSCREEN;
1518 return (wsdisplay_switch1(sc, 0, waitok));
1519 } else
1520 sc->sc_oldscreen = sc->sc_focusidx;
1521
1522 #define wsswitch_cb1 ((void (*)(void *, int, int))wsdisplay_switch1)
1523 if (scr->scr_syncops) {
1524 res = (*scr->scr_syncops->detach)(scr->scr_synccookie, waitok,
1525 sc->sc_isconsole && wsdisplay_cons_pollmode ? 0 : wsswitch_cb1, sc);
1526 if (res == EAGAIN) {
1527 /* switch will be done asynchronously */
1528 return (0);
1529 }
1530 } else if (scr->scr_flags & SCR_GRAPHICS) {
1531 /* no way to save state */
1532 res = EBUSY;
1533 }
1534
1535 return (wsdisplay_switch1(sc, res, waitok));
1536 }
1537
1538 void
1539 wsdisplay_reset(struct device *dev, enum wsdisplay_resetops op)
1540 {
1541 struct wsdisplay_softc *sc = (struct wsdisplay_softc *)dev;
1542 struct wsscreen *scr;
1543
1544 KASSERT(sc != NULL);
1545 scr = sc->sc_focus;
1546
1547 if (!scr)
1548 return;
1549
1550 switch (op) {
1551 case WSDISPLAY_RESETEMUL:
1552 if (!WSSCREEN_HAS_EMULATOR(scr))
1553 break;
1554 (*scr->scr_dconf->wsemul->reset)(scr->scr_dconf->wsemulcookie,
1555 WSEMUL_RESET);
1556 break;
1557 case WSDISPLAY_RESETCLOSE:
1558 wsdisplay_closescreen(sc, scr);
1559 break;
1560 }
1561 }
1562
1563 /*
1564 * Interface for (external) VT switch / process synchronization code
1565 */
1566 int
1567 wsscreen_attach_sync(struct wsscreen *scr, const struct wscons_syncops *ops,
1568 void *cookie)
1569 {
1570 if (scr->scr_syncops) {
1571 /*
1572 * The screen is already claimed.
1573 * Check if the owner is still alive.
1574 */
1575 if ((*scr->scr_syncops->check)(scr->scr_synccookie))
1576 return (EBUSY);
1577 }
1578 scr->scr_syncops = ops;
1579 scr->scr_synccookie = cookie;
1580 return (0);
1581 }
1582
1583 int
1584 wsscreen_detach_sync(struct wsscreen *scr)
1585 {
1586 if (!scr->scr_syncops)
1587 return (EINVAL);
1588 scr->scr_syncops = 0;
1589 return (0);
1590 }
1591
1592 int
1593 wsscreen_lookup_sync(struct wsscreen *scr,
1594 const struct wscons_syncops *ops, /* used as ID */
1595 void **cookiep)
1596 {
1597 if (!scr->scr_syncops || ops != scr->scr_syncops)
1598 return (EINVAL);
1599 *cookiep = scr->scr_synccookie;
1600 return (0);
1601 }
1602
1603 /*
1604 * Interface to virtual screen stuff
1605 */
1606 int
1607 wsdisplay_maxscreenidx(struct wsdisplay_softc *sc)
1608 {
1609 return (WSDISPLAY_MAXSCREEN - 1);
1610 }
1611
1612 int
1613 wsdisplay_screenstate(struct wsdisplay_softc *sc, int idx)
1614 {
1615 if (idx < 0 || idx >= WSDISPLAY_MAXSCREEN)
1616 return (EINVAL);
1617 if (!sc->sc_scr[idx])
1618 return (ENXIO);
1619 return ((sc->sc_scr[idx]->scr_flags & SCR_OPEN) ? EBUSY : 0);
1620 }
1621
1622 int
1623 wsdisplay_getactivescreen(struct wsdisplay_softc *sc)
1624 {
1625 return (sc->sc_focus ? sc->sc_focusidx : WSDISPLAY_NULLSCREEN);
1626 }
1627
1628 int
1629 wsscreen_switchwait(struct wsdisplay_softc *sc, int no)
1630 {
1631 struct wsscreen *scr;
1632 int s, res = 0;
1633
1634 if (no == WSDISPLAY_NULLSCREEN) {
1635 s = spltty();
1636 while (sc->sc_focus && res == 0) {
1637 res = tsleep(sc, PCATCH, "wswait", 0);
1638 }
1639 splx(s);
1640 return (res);
1641 }
1642
1643 if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
1644 return (ENXIO);
1645 scr = sc->sc_scr[no];
1646 if (!scr)
1647 return (ENXIO);
1648
1649 s = spltty();
1650 if (scr != sc->sc_focus) {
1651 scr->scr_flags |= SCR_WAITACTIVE;
1652 res = tsleep(scr, PCATCH, "wswait", 0);
1653 if (scr != sc->sc_scr[no])
1654 res = ENXIO; /* disappeared in the meantime */
1655 else
1656 scr->scr_flags &= ~SCR_WAITACTIVE;
1657 }
1658 splx(s);
1659 return (res);
1660 }
1661
1662 void
1663 wsdisplay_kbdholdscreen(struct device *dev, int hold)
1664 {
1665 struct wsdisplay_softc *sc = (struct wsdisplay_softc *)dev;
1666 struct wsscreen *scr;
1667
1668 scr = sc->sc_focus;
1669
1670 if (hold)
1671 scr->scr_hold_screen = 1;
1672 else {
1673 scr->scr_hold_screen = 0;
1674 callout_reset(&scr->scr_tty->t_rstrt_ch, 0,
1675 ttrstrt, scr->scr_tty); /* "immediate" */
1676 }
1677 }
1678
1679 #if NWSKBD > 0
1680 void
1681 wsdisplay_set_console_kbd(struct wsevsrc *src)
1682 {
1683 if (wsdisplay_console_device == NULL) {
1684 src->me_dispdv = NULL;
1685 return;
1686 }
1687 #if NWSMUX > 0
1688 if (wsmux_attach_sc((struct wsmux_softc *)
1689 wsdisplay_console_device->sc_input, src)) {
1690 src->me_dispdv = NULL;
1691 return;
1692 }
1693 #else
1694 wsdisplay_console_device->sc_input = src;
1695 #endif
1696 src->me_dispdv = &wsdisplay_console_device->sc_dv;
1697 }
1698 #endif /* NWSKBD > 0 */
1699
1700 /*
1701 * Console interface.
1702 */
1703 void
1704 wsdisplay_cnputc(dev_t dev, int i)
1705 {
1706 struct wsscreen_internal *dc;
1707 char c = i;
1708
1709 if (!wsdisplay_console_initted)
1710 return;
1711
1712 if (wsdisplay_console_device != NULL &&
1713 (wsdisplay_console_device->sc_scr[0]->scr_flags & SCR_GRAPHICS))
1714 return;
1715
1716 dc = &wsdisplay_console_conf;
1717 (*dc->wsemul->output)(dc->wsemulcookie, &c, 1, 1);
1718 }
1719
1720 static int
1721 wsdisplay_getc_dummy(dev_t dev)
1722 {
1723 /* panic? */
1724 return (0);
1725 }
1726
1727 static void
1728 wsdisplay_pollc(dev_t dev, int on)
1729 {
1730
1731 wsdisplay_cons_pollmode = on;
1732
1733 /* notify to fb drivers */
1734 if (wsdisplay_console_device != NULL &&
1735 wsdisplay_console_device->sc_accessops->pollc != NULL)
1736 (*wsdisplay_console_device->sc_accessops->pollc)
1737 (wsdisplay_console_device->sc_accesscookie, on);
1738
1739 /* notify to kbd drivers */
1740 if (wsdisplay_cons_kbd_pollc)
1741 (*wsdisplay_cons_kbd_pollc)(NODEV, on);
1742 }
1743
1744 void
1745 wsdisplay_set_cons_kbd(int (*get)(dev_t), void (*poll)(dev_t, int),
1746 void (*bell)(dev_t, u_int, u_int, u_int))
1747 {
1748 wsdisplay_cons.cn_getc = get;
1749 wsdisplay_cons.cn_bell = bell;
1750 wsdisplay_cons_kbd_pollc = poll;
1751 }
1752
1753 void
1754 wsdisplay_unset_cons_kbd(void)
1755 {
1756 wsdisplay_cons.cn_getc = wsdisplay_getc_dummy;
1757 wsdisplay_cons.cn_bell = NULL;
1758 wsdisplay_cons_kbd_pollc = 0;
1759 }
1760
1761 /*
1762 * Switch the console display to it's first screen.
1763 */
1764 void
1765 wsdisplay_switchtoconsole(void)
1766 {
1767 struct wsdisplay_softc *sc;
1768 struct wsscreen *scr;
1769
1770 if (wsdisplay_console_device != NULL) {
1771 sc = wsdisplay_console_device;
1772 scr = sc->sc_scr[0];
1773 (*sc->sc_accessops->show_screen)(sc->sc_accesscookie,
1774 scr->scr_dconf->emulcookie,
1775 0, NULL, NULL);
1776 }
1777 }
1778
1779 /*
1780 * Switch the console at shutdown.
1781 */
1782 static void
1783 wsdisplay_shutdownhook(void *arg)
1784 {
1785
1786 wsdisplay_switchtoconsole();
1787 }
1788