?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Expand PMF_FN_* macros.
[netbsd-mini2440.git] / sys / dev / wscons / wsdisplay.c
blob493a749a5ba7da6e91db40ee8e391e15f8889078
1 /* $NetBSD: wsdisplay.c,v 1.126 2009/01/22 20:40:20 drochner 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.126 2009/01/22 20:40:20 drochner Exp $");
35
36 #include "opt_wsdisplay_compat.h"
37 #include "opt_wsmsgattrs.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/poll.h>
47 #include <sys/kernel.h>
48 #include <sys/proc.h>
49 #include <sys/malloc.h>
50 #include <sys/syslog.h>
51 #include <sys/systm.h>
52 #include <sys/tty.h>
53 #include <sys/signalvar.h>
54 #include <sys/errno.h>
55 #include <sys/fcntl.h>
56 #include <sys/vnode.h>
57 #include <sys/kauth.h>
58
59 #include <dev/wscons/wsconsio.h>
60 #include <dev/wscons/wseventvar.h>
61 #include <dev/wscons/wsmuxvar.h>
62 #include <dev/wscons/wsdisplayvar.h>
63 #include <dev/wscons/wsksymvar.h>
64 #include <dev/wscons/wsksymdef.h>
65 #include <dev/wscons/wsemulvar.h>
66 #include <dev/wscons/wscons_callbacks.h>
67 #include <dev/cons.h>
68
69 struct wsscreen_internal {
70 const struct wsdisplay_emulops *emulops;
71 void *emulcookie;
72
73 const struct wsscreen_descr *scrdata;
74
75 const struct wsemul_ops *wsemul;
76 void *wsemulcookie;
77 };
78
79 struct wsscreen {
80 struct wsscreen_internal *scr_dconf;
81
82 struct tty *scr_tty;
83 int scr_hold_screen; /* hold tty output */
84
85 int scr_flags;
86 #define SCR_OPEN 1 /* is it open? */
87 #define SCR_WAITACTIVE 2 /* someone waiting on activation */
88 #define SCR_GRAPHICS 4 /* graphics mode, no text (emulation) output */
89 #define SCR_DUMBFB 8 /* in use as a dumb fb (iff SCR_GRAPHICS) */
90 const struct wscons_syncops *scr_syncops;
91 void *scr_synccookie;
92
93 #ifdef WSDISPLAY_COMPAT_RAWKBD
94 int scr_rawkbd;
95 #endif
96
97 struct wsdisplay_softc *sc;
98
99 #ifdef DIAGNOSTIC
100 /* XXX this is to support a hack in emulinput, see comment below */
101 int scr_in_ttyoutput;
102 #endif
103 };
104
105 struct wsscreen *wsscreen_attach(struct wsdisplay_softc *, int,
106 const char *,
107 const struct wsscreen_descr *, void *,
108 int, int, long);
109 void wsscreen_detach(struct wsscreen *);
110 int wsdisplay_addscreen(struct wsdisplay_softc *, int, const char *, const char *);
111 static void wsdisplay_addscreen_print(struct wsdisplay_softc *, int, int);
112 static void wsdisplay_closescreen(struct wsdisplay_softc *, struct wsscreen *);
113 int wsdisplay_delscreen(struct wsdisplay_softc *, int, int);
114
115 #define WSDISPLAY_MAXSCREEN 8
116
117 struct wsdisplay_softc {
118 device_t sc_dev;
119
120 const struct wsdisplay_accessops *sc_accessops;
121 void *sc_accesscookie;
122
123 const struct wsscreen_list *sc_scrdata;
124 #ifdef WSDISPLAY_SCROLLSUPPORT
125 struct wsdisplay_scroll_data sc_scroll_values;
126 #endif
127
128 struct wsscreen *sc_scr[WSDISPLAY_MAXSCREEN];
129 int sc_focusidx; /* available only if sc_focus isn't null */
130 struct wsscreen *sc_focus;
131
132 struct wseventvar evar;
133
134 int sc_isconsole;
135
136 int sc_flags;
137 #define SC_SWITCHPENDING 1
138 #define SC_SWITCHERROR 2
139 #define SC_XATTACHED 4 /* X server active */
140 kmutex_t sc_flagsmtx; /* for flags, might also be used for focus */
141 kcondvar_t sc_flagscv;
142
143 int sc_screenwanted, sc_oldscreen; /* valid with SC_SWITCHPENDING */
144
145 #if NWSKBD > 0
146 struct wsevsrc *sc_input;
147 #ifdef WSDISPLAY_COMPAT_RAWKBD
148 int sc_rawkbd;
149 #endif
150 #endif /* NWSKBD > 0 */
151 };
152
153 #ifdef WSDISPLAY_SCROLLSUPPORT
154
155 struct wsdisplay_scroll_data wsdisplay_default_scroll_values = {
156 WSDISPLAY_SCROLL_DOALL,
157 25,
158 2,
159 };
160 #endif
161
162 extern struct cfdriver wsdisplay_cd;
163
164 /* Autoconfiguration definitions. */
165 static int wsdisplay_emul_match(device_t , cfdata_t, void *);
166 static void wsdisplay_emul_attach(device_t, device_t, void *);
167 static int wsdisplay_noemul_match(device_t, cfdata_t, void *);
168 static void wsdisplay_noemul_attach(device_t, device_t, void *);
169 static bool wsdisplay_suspend(device_t, pmf_qual_t);
170
171 CFATTACH_DECL_NEW(wsdisplay_emul, sizeof (struct wsdisplay_softc),
172 wsdisplay_emul_match, wsdisplay_emul_attach, NULL, NULL);
173
174 CFATTACH_DECL_NEW(wsdisplay_noemul, sizeof (struct wsdisplay_softc),
175 wsdisplay_noemul_match, wsdisplay_noemul_attach, NULL, NULL);
176
177 dev_type_open(wsdisplayopen);
178 dev_type_close(wsdisplayclose);
179 dev_type_read(wsdisplayread);
180 dev_type_write(wsdisplaywrite);
181 dev_type_ioctl(wsdisplayioctl);
182 dev_type_stop(wsdisplaystop);
183 dev_type_tty(wsdisplaytty);
184 dev_type_poll(wsdisplaypoll);
185 dev_type_mmap(wsdisplaymmap);
186 dev_type_kqfilter(wsdisplaykqfilter);
187
188 const struct cdevsw wsdisplay_cdevsw = {
189 wsdisplayopen, wsdisplayclose, wsdisplayread, wsdisplaywrite,
190 wsdisplayioctl, wsdisplaystop, wsdisplaytty, wsdisplaypoll,
191 wsdisplaymmap, wsdisplaykqfilter, D_TTY
192 };
193
194 static void wsdisplaystart(struct tty *);
195 static int wsdisplayparam(struct tty *, struct termios *);
196
197
198 #define WSDISPLAYUNIT(dev) (minor(dev) >> 8)
199 #define WSDISPLAYSCREEN(dev) (minor(dev) & 0xff)
200 #define ISWSDISPLAYSTAT(dev) (WSDISPLAYSCREEN(dev) == 254)
201 #define ISWSDISPLAYCTL(dev) (WSDISPLAYSCREEN(dev) == 255)
202 #define WSDISPLAYMINOR(unit, screen) (((unit) << 8) | (screen))
203
204 #define WSSCREEN_HAS_EMULATOR(scr) ((scr)->scr_dconf->wsemul != NULL)
205 #define WSSCREEN_HAS_TTY(scr) ((scr)->scr_tty != NULL)
206
207 static void wsdisplay_common_attach(struct wsdisplay_softc *sc,
208 int console, int kbdmux, const struct wsscreen_list *,
209 const struct wsdisplay_accessops *accessops,
210 void *accesscookie);
211
212 #ifdef WSDISPLAY_COMPAT_RAWKBD
213 int wsdisplay_update_rawkbd(struct wsdisplay_softc *,
214 struct wsscreen *);
215 #endif
216
217 static int wsdisplay_console_initted;
218 static int wsdisplay_console_attached;
219 static struct wsdisplay_softc *wsdisplay_console_device;
220 static struct wsscreen_internal wsdisplay_console_conf;
221
222 static int wsdisplay_getc_dummy(dev_t);
223 static void wsdisplay_pollc(dev_t, int);
224
225 static int wsdisplay_cons_pollmode;
226 static void (*wsdisplay_cons_kbd_pollc)(dev_t, int);
227
228 static struct consdev wsdisplay_cons = {
229 NULL, NULL, wsdisplay_getc_dummy, wsdisplay_cnputc,
230 wsdisplay_pollc, NULL, NULL, NULL, NODEV, CN_NORMAL
231 };
232
233 #ifndef WSDISPLAY_DEFAULTSCREENS
234 # define WSDISPLAY_DEFAULTSCREENS 0
235 #endif
236 int wsdisplay_defaultscreens = WSDISPLAY_DEFAULTSCREENS;
237
238 static int wsdisplay_switch1(device_t, int, int);
239 static void wsdisplay_switch1_cb(void *, int, int);
240 static int wsdisplay_switch2(device_t, int, int);
241 static void wsdisplay_switch2_cb(void *, int, int);
242 static int wsdisplay_switch3(device_t, int, int);
243 static void wsdisplay_switch3_cb(void *, int, int);
244
245 int wsdisplay_clearonclose;
246
247 struct wsscreen *
248 wsscreen_attach(struct wsdisplay_softc *sc, int console, const char *emul,
249 const struct wsscreen_descr *type, void *cookie, int ccol,
250 int crow, long defattr)
251 {
252 struct wsscreen_internal *dconf;
253 struct wsscreen *scr;
254
255 scr = malloc(sizeof(struct wsscreen), M_DEVBUF, M_WAITOK);
256 if (!scr)
257 return (NULL);
258
259 if (console) {
260 dconf = &wsdisplay_console_conf;
261 /*
262 * If there's an emulation, tell it about the callback argument.
263 * The other stuff is already there.
264 */
265 if (dconf->wsemul != NULL)
266 (*dconf->wsemul->attach)(1, 0, 0, 0, 0, scr, 0);
267 } else { /* not console */
268 dconf = malloc(sizeof(struct wsscreen_internal),
269 M_DEVBUF, M_NOWAIT);
270 dconf->emulops = type->textops;
271 dconf->emulcookie = cookie;
272 if (dconf->emulops) {
273 dconf->wsemul = wsemul_pick(emul);
274 if (dconf->wsemul == NULL) {
275 free(dconf, M_DEVBUF);
276 free(scr, M_DEVBUF);
277 return (NULL);
278 }
279 dconf->wsemulcookie =
280 (*dconf->wsemul->attach)(0, type, cookie,
281 ccol, crow, scr, defattr);
282 } else
283 dconf->wsemul = NULL;
284 dconf->scrdata = type;
285 }
286
287 scr->scr_dconf = dconf;
288
289 scr->scr_tty = ttymalloc();
290 tty_attach(scr->scr_tty);
291 scr->scr_hold_screen = 0;
292 if (WSSCREEN_HAS_EMULATOR(scr))
293 scr->scr_flags = 0;
294 else
295 scr->scr_flags = SCR_GRAPHICS;
296
297 scr->scr_syncops = 0;
298 scr->sc = sc;
299 #ifdef WSDISPLAY_COMPAT_RAWKBD
300 scr->scr_rawkbd = 0;
301 #endif
302 return (scr);
303 }
304
305 void
306 wsscreen_detach(struct wsscreen *scr)
307 {
308 u_int ccol, crow; /* XXX */
309
310 if (WSSCREEN_HAS_TTY(scr)) {
311 tty_detach(scr->scr_tty);
312 ttyfree(scr->scr_tty);
313 }
314 if (WSSCREEN_HAS_EMULATOR(scr))
315 (*scr->scr_dconf->wsemul->detach)(scr->scr_dconf->wsemulcookie,
316 &ccol, &crow);
317 free(scr->scr_dconf, M_DEVBUF);
318 free(scr, M_DEVBUF);
319 }
320
321 const struct wsscreen_descr *
322 wsdisplay_screentype_pick(const struct wsscreen_list *scrdata, const char *name)
323 {
324 int i;
325 const struct wsscreen_descr *scr;
326
327 KASSERT(scrdata->nscreens > 0);
328
329 if (name == NULL)
330 return (scrdata->screens[0]);
331
332 for (i = 0; i < scrdata->nscreens; i++) {
333 scr = scrdata->screens[i];
334 if (!strcmp(name, scr->name))
335 return (scr);
336 }
337
338 return (0);
339 }
340
341 /*
342 * print info about attached screen
343 */
344 static void
345 wsdisplay_addscreen_print(struct wsdisplay_softc *sc, int idx, int count)
346 {
347 aprint_verbose_dev(sc->sc_dev, "screen %d", idx);
348 if (count > 1)
349 aprint_verbose("-%d", idx + (count-1));
350 aprint_verbose(" added (%s", sc->sc_scr[idx]->scr_dconf->scrdata->name);
351 if (WSSCREEN_HAS_EMULATOR(sc->sc_scr[idx])) {
352 aprint_verbose(", %s emulation",
353 sc->sc_scr[idx]->scr_dconf->wsemul->name);
354 }
355 aprint_verbose(")\n");
356 }
357
358 int
359 wsdisplay_addscreen(struct wsdisplay_softc *sc, int idx,
360 const char *screentype, const char *emul)
361 {
362 const struct wsscreen_descr *scrdesc;
363 int error;
364 void *cookie;
365 int ccol, crow;
366 long defattr;
367 struct wsscreen *scr;
368 int s;
369
370 if (idx < 0 || idx >= WSDISPLAY_MAXSCREEN)
371 return (EINVAL);
372 if (sc->sc_scr[idx] != NULL)
373 return (EBUSY);
374
375 scrdesc = wsdisplay_screentype_pick(sc->sc_scrdata, screentype);
376 if (!scrdesc)
377 return (ENXIO);
378 error = (*sc->sc_accessops->alloc_screen)(sc->sc_accesscookie,
379 scrdesc, &cookie, &ccol, &crow, &defattr);
380 if (error)
381 return (error);
382
383 scr = wsscreen_attach(sc, 0, emul, scrdesc,
384 cookie, ccol, crow, defattr);
385 if (scr == NULL) {
386 (*sc->sc_accessops->free_screen)(sc->sc_accesscookie,
387 cookie);
388 return (ENXIO);
389 }
390
391 sc->sc_scr[idx] = scr;
392
393 /* if no screen has focus yet, activate the first we get */
394 s = spltty();
395 if (!sc->sc_focus) {
396 (*sc->sc_accessops->show_screen)(sc->sc_accesscookie,
397 scr->scr_dconf->emulcookie,
398 0, 0, 0);
399 sc->sc_focusidx = idx;
400 sc->sc_focus = scr;
401 }
402 splx(s);
403 return (0);
404 }
405
406 static void
407 wsdisplay_closescreen(struct wsdisplay_softc *sc, struct wsscreen *scr)
408 {
409 int maj, mn, idx;
410
411 /* hangup */
412 if (WSSCREEN_HAS_TTY(scr)) {
413 struct tty *tp = scr->scr_tty;
414 (*tp->t_linesw->l_modem)(tp, 0);
415 }
416
417 /* locate the major number */
418 maj = cdevsw_lookup_major(&wsdisplay_cdevsw);
419 /* locate the screen index */
420 for (idx = 0; idx < WSDISPLAY_MAXSCREEN; idx++)
421 if (scr == sc->sc_scr[idx])
422 break;
423 #ifdef DIAGNOSTIC
424 if (idx == WSDISPLAY_MAXSCREEN)
425 panic("wsdisplay_forceclose: bad screen");
426 #endif
427
428 /* nuke the vnodes */
429 mn = WSDISPLAYMINOR(device_unit(sc->sc_dev), idx);
430 vdevgone(maj, mn, mn, VCHR);
431 }
432
433 #ifdef WSDISPLAY_SCROLLSUPPORT
434 void
435 wsdisplay_scroll(void *arg, int op)
436 {
437 device_t dv = arg;
438 struct wsdisplay_softc *sc = device_private(dv);
439 struct wsscreen *scr;
440 int lines;
441
442 scr = sc->sc_focus;
443
444 if (!scr)
445 return;
446
447 if (op == WSDISPLAY_SCROLL_RESET)
448 lines = 0;
449 else {
450 lines = (op & WSDISPLAY_SCROLL_LOW) ?
451 sc->sc_scroll_values.slowlines :
452 sc->sc_scroll_values.fastlines;
453 if (op & WSDISPLAY_SCROLL_BACKWARD)
454 lines = -(lines);
455 }
456
457 if (sc->sc_accessops->scroll) {
458 (*sc->sc_accessops->scroll)(sc->sc_accesscookie,
459 sc->sc_focus->scr_dconf->emulcookie, lines);
460 }
461 }
462 #endif
463
464 int
465 wsdisplay_delscreen(struct wsdisplay_softc *sc, int idx, int flags)
466 {
467 struct wsscreen *scr;
468 int s;
469 void *cookie;
470
471 if (idx < 0 || idx >= WSDISPLAY_MAXSCREEN)
472 return (EINVAL);
473 if ((scr = sc->sc_scr[idx]) == NULL)
474 return (ENXIO);
475
476 if (scr->scr_dconf == &wsdisplay_console_conf ||
477 scr->scr_syncops ||
478 ((scr->scr_flags & SCR_OPEN) && !(flags & WSDISPLAY_DELSCR_FORCE)))
479 return(EBUSY);
480
481 wsdisplay_closescreen(sc, scr);
482
483 /*
484 * delete pointers, so neither device entries
485 * nor keyboard input can reference it anymore
486 */
487 s = spltty();
488 if (sc->sc_focus == scr) {
489 sc->sc_focus = 0;
490 #ifdef WSDISPLAY_COMPAT_RAWKBD
491 wsdisplay_update_rawkbd(sc, 0);
492 #endif
493 }
494 sc->sc_scr[idx] = 0;
495 splx(s);
496
497 /*
498 * Wake up processes waiting for the screen to
499 * be activated. Sleepers must check whether
500 * the screen still exists.
501 */
502 if (scr->scr_flags & SCR_WAITACTIVE)
503 wakeup(scr);
504
505 /* save a reference to the graphics screen */
506 cookie = scr->scr_dconf->emulcookie;
507
508 wsscreen_detach(scr);
509
510 (*sc->sc_accessops->free_screen)(sc->sc_accesscookie,
511 cookie);
512
513 aprint_verbose_dev(sc->sc_dev, "screen %d deleted\n", idx);
514 return (0);
515 }
516
517 /*
518 * Autoconfiguration functions.
519 */
520 int
521 wsdisplay_emul_match(device_t parent, cfdata_t match, void *aux)
522 {
523 struct wsemuldisplaydev_attach_args *ap = aux;
524
525 if (match->wsemuldisplaydevcf_console !=
526 WSEMULDISPLAYDEVCF_CONSOLE_UNK) {
527 /*
528 * If console-ness of device specified, either match
529 * exactly (at high priority), or fail.
530 */
531 if (match->wsemuldisplaydevcf_console != 0 &&
532 ap->console != 0)
533 return (10);
534 else
535 return (0);
536 }
537
538 /* If console-ness unspecified, it wins. */
539 return (1);
540 }
541
542 void
543 wsdisplay_emul_attach(device_t parent, device_t self, void *aux)
544 {
545 struct wsdisplay_softc *sc = device_private(self);
546 struct wsemuldisplaydev_attach_args *ap = aux;
547
548 sc->sc_dev = self;
549
550 /* Don't allow more than one console to attach */
551 if (wsdisplay_console_attached && ap->console)
552 ap->console = 0;
553
554 wsdisplay_common_attach(sc, ap->console,
555 device_cfdata(self)->wsemuldisplaydevcf_kbdmux, ap->scrdata,
556 ap->accessops, ap->accesscookie);
557
558 if (ap->console) {
559 int maj;
560
561 /* locate the major number */
562 maj = cdevsw_lookup_major(&wsdisplay_cdevsw);
563
564 cn_tab->cn_dev = makedev(maj, WSDISPLAYMINOR(device_unit(self),
565 0));
566 }
567 }
568
569 /* Print function (for parent devices). */
570 int
571 wsemuldisplaydevprint(void *aux, const char *pnp)
572 {
573 #if 0 /* -Wunused */
574 struct wsemuldisplaydev_attach_args *ap = aux;
575 #endif
576
577 if (pnp)
578 aprint_normal("wsdisplay at %s", pnp);
579 #if 0 /* don't bother; it's ugly */
580 aprint_normal(" console %d", ap->console);
581 #endif
582
583 return (UNCONF);
584 }
585
586 int
587 wsdisplay_noemul_match(device_t parent, cfdata_t match, void *aux)
588 {
589 #if 0 /* -Wunused */
590 struct wsdisplaydev_attach_args *ap = aux;
591 #endif
592
593 /* Always match. */
594 return (1);
595 }
596
597 void
598 wsdisplay_noemul_attach(device_t parent, device_t self, void *aux)
599 {
600 struct wsdisplay_softc *sc = device_private(self);
601 struct wsdisplaydev_attach_args *ap = aux;
602
603 sc->sc_dev = self;
604
605 wsdisplay_common_attach(sc, 0,
606 device_cfdata(self)->wsemuldisplaydevcf_kbdmux, NULL,
607 ap->accessops, ap->accesscookie);
608 }
609
610 static void
611 wsdisplay_swdone_cb(void *arg, int error, int waitok)
612 {
613 struct wsdisplay_softc *sc = arg;
614
615 mutex_enter(&sc->sc_flagsmtx);
616 KASSERT(sc->sc_flags & SC_SWITCHPENDING);
617 if (error)
618 sc->sc_flags |= SC_SWITCHERROR;
619 sc->sc_flags &= ~SC_SWITCHPENDING;
620 cv_signal(&sc->sc_flagscv);
621 mutex_exit(&sc->sc_flagsmtx);
622 }
623
624 static int
625 wsdisplay_dosync(struct wsdisplay_softc *sc, int attach)
626 {
627 struct wsscreen *scr;
628 int (*op)(void *, int, void (*)(void *, int, int), void *);
629 int res;
630
631 scr = sc->sc_focus;
632 if (!scr || !scr->scr_syncops)
633 return 0; /* XXX check SCR_GRAPHICS? */
634
635 sc->sc_flags |= SC_SWITCHPENDING;
636 sc->sc_flags &= ~SC_SWITCHERROR;
637 if (attach)
638 op = scr->scr_syncops->attach;
639 else
640 op = scr->scr_syncops->detach;
641 res = (*op)(scr->scr_synccookie, 1, wsdisplay_swdone_cb, sc);
642 if (res == EAGAIN) {
643 /* wait for callback */
644 mutex_enter(&sc->sc_flagsmtx);
645 while (sc->sc_flags & SC_SWITCHPENDING)
646 cv_wait_sig(&sc->sc_flagscv, &sc->sc_flagsmtx);
647 mutex_exit(&sc->sc_flagsmtx);
648 if (sc->sc_flags & SC_SWITCHERROR)
649 return (EIO); /* XXX pass real error */
650 } else {
651 sc->sc_flags &= ~SC_SWITCHPENDING;
652 if (res)
653 return (res);
654 }
655 if (attach)
656 sc->sc_flags |= SC_XATTACHED;
657 else
658 sc->sc_flags &= ~SC_XATTACHED;
659 return 0;
660 }
661
662 int
663 wsdisplay_handlex(int resume)
664 {
665 int i, res;
666 device_t dv;
667
668 for (i = 0; i < wsdisplay_cd.cd_ndevs; i++) {
669 dv = device_lookup(&wsdisplay_cd, i);
670 if (!dv)
671 continue;
672 res = wsdisplay_dosync(device_private(dv), resume);
673 if (res)
674 return (res);
675 }
676 return (0);
677 }
678
679 static bool
680 wsdisplay_suspend(device_t dv, pmf_qual_t qual)
681 {
682 struct wsdisplay_softc *sc = device_private(dv);
683 #ifdef DIAGNOSTIC
684 struct wsscreen *scr = sc->sc_focus;
685 if (sc->sc_flags & SC_XATTACHED) {
686 KASSERT(scr && scr->scr_syncops);
687 }
688 #endif
689 #if 1
690 /*
691 * XXX X servers should have been detached earlier.
692 * pmf currently ignores our return value and suspends the system
693 * after device suspend failures. We try to avoid bigger damage
694 * and try to detach the X server here. This is not safe because
695 * other parts of the system which the X server deals with
696 * might already be suspended.
697 */
698 if (sc->sc_flags & SC_XATTACHED) {
699 printf("%s: emergency X server detach\n", device_xname(dv));
700 wsdisplay_dosync(sc, 0);
701 }
702 #endif
703 return (!(sc->sc_flags & SC_XATTACHED));
704 }
705
706 /* Print function (for parent devices). */
707 int
708 wsdisplaydevprint(void *aux, const char *pnp)
709 {
710 #if 0 /* -Wunused */
711 struct wsdisplaydev_attach_args *ap = aux;
712 #endif
713
714 if (pnp)
715 aprint_normal("wsdisplay at %s", pnp);
716
717 return (UNCONF);
718 }
719
720 static void
721 wsdisplay_common_attach(struct wsdisplay_softc *sc, int console, int kbdmux,
722 const struct wsscreen_list *scrdata,
723 const struct wsdisplay_accessops *accessops,
724 void *accesscookie)
725 {
726 int i, start=0;
727 #if NWSKBD > 0
728 struct wsevsrc *kme;
729 #if NWSMUX > 0
730 struct wsmux_softc *mux;
731
732 if (kbdmux >= 0)
733 mux = wsmux_getmux(kbdmux);
734 else
735 mux = wsmux_create("dmux", device_unit(sc->sc_dev));
736 /* XXX panic()ing isn't nice, but attach cannot fail */
737 if (mux == NULL)
738 panic("wsdisplay_common_attach: no memory");
739 sc->sc_input = &mux->sc_base;
740 mux->sc_base.me_dispdv = sc->sc_dev;
741 aprint_normal(" kbdmux %d", kbdmux);
742 #else
743 if (kbdmux >= 0)
744 aprint_normal(" (kbdmux ignored)");
745 #endif
746 #endif
747
748 sc->sc_isconsole = console;
749
750 if (console) {
751 KASSERT(wsdisplay_console_initted);
752 KASSERT(wsdisplay_console_device == NULL);
753
754 sc->sc_scr[0] = wsscreen_attach(sc, 1, 0, 0, 0, 0, 0, 0);
755 wsdisplay_console_device = sc;
756
757 aprint_normal(": console (%s, %s emulation)",
758 wsdisplay_console_conf.scrdata->name,
759 wsdisplay_console_conf.wsemul->name);
760
761 #if NWSKBD > 0
762 kme = wskbd_set_console_display(sc->sc_dev, sc->sc_input);
763 if (kme != NULL)
764 aprint_normal(", using %s", device_xname(kme->me_dv));
765 #if NWSMUX == 0
766 sc->sc_input = kme;
767 #endif
768 #endif
769
770 sc->sc_focusidx = 0;
771 sc->sc_focus = sc->sc_scr[0];
772 start = 1;
773
774 wsdisplay_console_attached = 1;
775 }
776 aprint_normal("\n");
777
778 #if NWSKBD > 0 && NWSMUX > 0
779 wsmux_set_display(mux, sc->sc_dev);
780 #endif
781
782 mutex_init(&sc->sc_flagsmtx, MUTEX_DEFAULT, IPL_NONE);
783 cv_init(&sc->sc_flagscv, "wssw");
784
785 sc->sc_accessops = accessops;
786 sc->sc_accesscookie = accesscookie;
787 sc->sc_scrdata = scrdata;
788
789 #ifdef WSDISPLAY_SCROLLSUPPORT
790 sc->sc_scroll_values = wsdisplay_default_scroll_values;
791 #endif
792
793 /*
794 * Set up a number of virtual screens if wanted. The
795 * WSDISPLAYIO_ADDSCREEN ioctl is more flexible, so this code
796 * is for special cases like installation kernels.
797 */
798 for (i = start; i < wsdisplay_defaultscreens; i++) {
799 if (wsdisplay_addscreen(sc, i, 0, 0))
800 break;
801 }
802
803 if (i > start)
804 wsdisplay_addscreen_print(sc, start, i-start);
805
806 if (!pmf_device_register(sc->sc_dev, wsdisplay_suspend, NULL))
807 aprint_error_dev(sc->sc_dev, "couldn't establish power handler\n");
808 }
809
810 void
811 wsdisplay_cnattach(const struct wsscreen_descr *type, void *cookie,
812 int ccol, int crow, long defattr)
813 {
814 const struct wsemul_ops *wsemul;
815
816 KASSERT(wsdisplay_console_initted < 2);
817 KASSERT(type->nrows > 0);
818 KASSERT(type->ncols > 0);
819 KASSERT(crow < type->nrows);
820 KASSERT(ccol < type->ncols);
821
822 wsdisplay_console_conf.emulops = type->textops;
823 wsdisplay_console_conf.emulcookie = cookie;
824 wsdisplay_console_conf.scrdata = type;
825
826 wsemul = wsemul_pick(0); /* default */
827 wsdisplay_console_conf.wsemul = wsemul;
828 wsdisplay_console_conf.wsemulcookie = (*wsemul->cnattach)(type, cookie,
829 ccol, crow,
830 defattr);
831
832 cn_tab = &wsdisplay_cons;
833 wsdisplay_console_initted = 2;
834 }
835
836 void
837 wsdisplay_preattach(const struct wsscreen_descr *type, void *cookie,
838 int ccol, int crow, long defattr)
839 {
840 const struct wsemul_ops *wsemul;
841
842 KASSERT(!wsdisplay_console_initted);
843 KASSERT(type->nrows > 0);
844 KASSERT(type->ncols > 0);
845 KASSERT(crow < type->nrows);
846 KASSERT(ccol < type->ncols);
847
848 wsdisplay_console_conf.emulops = type->textops;
849 wsdisplay_console_conf.emulcookie = cookie;
850 wsdisplay_console_conf.scrdata = type;
851
852 wsemul = wsemul_pick(0); /* default */
853 wsdisplay_console_conf.wsemul = wsemul;
854 wsdisplay_console_conf.wsemulcookie = (*wsemul->cnattach)(type, cookie,
855 ccol, crow,
856 defattr);
857
858 cn_tab = &wsdisplay_cons;
859 wsdisplay_console_initted = 1;
860 }
861
862 /*
863 * Tty and cdevsw functions.
864 */
865 int
866 wsdisplayopen(dev_t dev, int flag, int mode, struct lwp *l)
867 {
868 struct wsdisplay_softc *sc;
869 struct tty *tp;
870 int newopen, error;
871 struct wsscreen *scr;
872
873 sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
874 if (sc == NULL) /* make sure it was attached */
875 return (ENXIO);
876
877 if (ISWSDISPLAYSTAT(dev)) {
878 wsevent_init(&sc->evar, l->l_proc);
879 return (0);
880 }
881
882 if (ISWSDISPLAYCTL(dev))
883 return (0);
884
885 if (WSDISPLAYSCREEN(dev) >= WSDISPLAY_MAXSCREEN)
886 return (ENXIO);
887 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
888 return (ENXIO);
889
890 if (WSSCREEN_HAS_TTY(scr)) {
891 tp = scr->scr_tty;
892 tp->t_oproc = wsdisplaystart;
893 tp->t_param = wsdisplayparam;
894 tp->t_dev = dev;
895 newopen = (tp->t_state & TS_ISOPEN) == 0;
896
897 if (kauth_authorize_device_tty(l->l_cred,
898 KAUTH_DEVICE_TTY_OPEN, tp))
899 return (EBUSY);
900
901 if (newopen) {
902 ttychars(tp);
903 tp->t_iflag = TTYDEF_IFLAG;
904 tp->t_oflag = TTYDEF_OFLAG;
905 tp->t_cflag = TTYDEF_CFLAG;
906 tp->t_lflag = TTYDEF_LFLAG;
907 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
908 wsdisplayparam(tp, &tp->t_termios);
909 ttsetwater(tp);
910 }
911 tp->t_state |= TS_CARR_ON;
912
913 error = ((*tp->t_linesw->l_open)(dev, tp));
914 if (error)
915 return (error);
916
917 if (newopen && WSSCREEN_HAS_EMULATOR(scr)) {
918 /* set window sizes as appropriate, and reset
919 the emulation */
920 tp->t_winsize.ws_row = scr->scr_dconf->scrdata->nrows;
921 tp->t_winsize.ws_col = scr->scr_dconf->scrdata->ncols;
922
923 /* wsdisplay_set_emulation() */
924 }
925 }
926
927 scr->scr_flags |= SCR_OPEN;
928 return (0);
929 }
930
931 int
932 wsdisplayclose(dev_t dev, int flag, int mode, struct lwp *l)
933 {
934 device_t dv;
935 struct wsdisplay_softc *sc;
936 struct tty *tp;
937 struct wsscreen *scr;
938
939 dv = device_lookup(&wsdisplay_cd, WSDISPLAYUNIT(dev));
940 sc = device_private(dv);
941
942 if (ISWSDISPLAYSTAT(dev)) {
943 wsevent_fini(&sc->evar);
944 return (0);
945 }
946
947 if (ISWSDISPLAYCTL(dev))
948 return (0);
949
950 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
951 return (0);
952
953 if (WSSCREEN_HAS_TTY(scr)) {
954 if (scr->scr_hold_screen) {
955 int s;
956
957 /* XXX RESET KEYBOARD LEDS, etc. */
958 s = spltty(); /* avoid conflict with keyboard */
959 wsdisplay_kbdholdscreen(dv, 0);
960 splx(s);
961 }
962 tp = scr->scr_tty;
963 (*tp->t_linesw->l_close)(tp, flag);
964 ttyclose(tp);
965 }
966
967 if (scr->scr_syncops)
968 (*scr->scr_syncops->destroy)(scr->scr_synccookie);
969
970 if (WSSCREEN_HAS_EMULATOR(scr)) {
971 scr->scr_flags &= ~SCR_GRAPHICS;
972 (*scr->scr_dconf->wsemul->reset)(scr->scr_dconf->wsemulcookie,
973 WSEMUL_RESET);
974 if (wsdisplay_clearonclose)
975 (*scr->scr_dconf->wsemul->reset)
976 (scr->scr_dconf->wsemulcookie,
977 WSEMUL_CLEARSCREEN);
978 }
979
980 #ifdef WSDISPLAY_COMPAT_RAWKBD
981 if (scr->scr_rawkbd) {
982 int kbmode = WSKBD_TRANSLATED;
983 (void)wsdisplay_internal_ioctl(sc, scr, WSKBDIO_SETMODE,
984 (void *)&kbmode, 0, l);
985 }
986 #endif
987
988 scr->scr_flags &= ~SCR_OPEN;
989
990 return (0);
991 }
992
993 int
994 wsdisplayread(dev_t dev, struct uio *uio, int flag)
995 {
996 struct wsdisplay_softc *sc;
997 struct tty *tp;
998 struct wsscreen *scr;
999 int error;
1000
1001 sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
1002
1003 if (ISWSDISPLAYSTAT(dev)) {
1004 error = wsevent_read(&sc->evar, uio, flag);
1005 return (error);
1006 }
1007
1008 if (ISWSDISPLAYCTL(dev))
1009 return (0);
1010
1011 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
1012 return (ENXIO);
1013
1014 if (!WSSCREEN_HAS_TTY(scr))
1015 return (ENODEV);
1016
1017 tp = scr->scr_tty;
1018 return ((*tp->t_linesw->l_read)(tp, uio, flag));
1019 }
1020
1021 int
1022 wsdisplaywrite(dev_t dev, struct uio *uio, int flag)
1023 {
1024 struct wsdisplay_softc *sc;
1025 struct tty *tp;
1026 struct wsscreen *scr;
1027
1028 sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
1029
1030 if (ISWSDISPLAYSTAT(dev)) {
1031 return (0);
1032 }
1033
1034 if (ISWSDISPLAYCTL(dev))
1035 return (0);
1036
1037 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
1038 return (ENXIO);
1039
1040 if (!WSSCREEN_HAS_TTY(scr))
1041 return (ENODEV);
1042
1043 tp = scr->scr_tty;
1044 return ((*tp->t_linesw->l_write)(tp, uio, flag));
1045 }
1046
1047 int
1048 wsdisplaypoll(dev_t dev, int events, struct lwp *l)
1049 {
1050 struct wsdisplay_softc *sc;
1051 struct tty *tp;
1052 struct wsscreen *scr;
1053
1054 sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
1055
1056 if (ISWSDISPLAYSTAT(dev))
1057 return (wsevent_poll(&sc->evar, events, l));
1058
1059 if (ISWSDISPLAYCTL(dev))
1060 return (0);
1061
1062 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
1063 return (POLLHUP);
1064
1065 if (!WSSCREEN_HAS_TTY(scr))
1066 return (POLLERR);
1067
1068 tp = scr->scr_tty;
1069 return ((*tp->t_linesw->l_poll)(tp, events, l));
1070 }
1071
1072 int
1073 wsdisplaykqfilter(dev_t dev, struct knote *kn)
1074 {
1075 struct wsdisplay_softc *sc;
1076 struct wsscreen *scr;
1077
1078 sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
1079
1080 if (ISWSDISPLAYCTL(dev))
1081 return (1);
1082
1083 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
1084 return (1);
1085
1086
1087 if (WSSCREEN_HAS_TTY(scr))
1088 return (ttykqfilter(dev, kn));
1089 else
1090 return (1);
1091 }
1092
1093 struct tty *
1094 wsdisplaytty(dev_t dev)
1095 {
1096 struct wsdisplay_softc *sc;
1097 struct wsscreen *scr;
1098
1099 sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
1100
1101 if (ISWSDISPLAYSTAT(dev))
1102 panic("wsdisplaytty() on status device");
1103
1104 if (ISWSDISPLAYCTL(dev))
1105 panic("wsdisplaytty() on ctl device");
1106
1107 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
1108 return NULL;
1109
1110 return (scr->scr_tty);
1111 }
1112
1113 int
1114 wsdisplayioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
1115 {
1116 device_t dv;
1117 struct wsdisplay_softc *sc;
1118 struct tty *tp;
1119 int error;
1120 struct wsscreen *scr;
1121
1122 dv = device_lookup(&wsdisplay_cd, WSDISPLAYUNIT(dev));
1123 sc = device_private(dv);
1124
1125 #ifdef WSDISPLAY_COMPAT_USL
1126 error = wsdisplay_usl_ioctl1(dv, cmd, data, flag, l);
1127 if (error != EPASSTHROUGH)
1128 return (error);
1129 #endif
1130
1131 if (ISWSDISPLAYSTAT(dev))
1132 return (wsdisplay_stat_ioctl(sc, cmd, data, flag, l));
1133
1134 if (ISWSDISPLAYCTL(dev))
1135 return (wsdisplay_cfg_ioctl(sc, cmd, data, flag, l));
1136
1137 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
1138 return (ENXIO);
1139
1140 if (WSSCREEN_HAS_TTY(scr)) {
1141 tp = scr->scr_tty;
1142
1143 /* printf("disc\n"); */
1144 /* do the line discipline ioctls first */
1145 error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, l);
1146 if (error != EPASSTHROUGH)
1147 return (error);
1148
1149 /* printf("tty\n"); */
1150 /* then the tty ioctls */
1151 error = ttioctl(tp, cmd, data, flag, l);
1152 if (error != EPASSTHROUGH)
1153 return (error);
1154 }
1155
1156 #ifdef WSDISPLAY_COMPAT_USL
1157 error = wsdisplay_usl_ioctl2(sc, scr, cmd, data, flag, l);
1158 if (error != EPASSTHROUGH)
1159 return (error);
1160 #endif
1161
1162 return (wsdisplay_internal_ioctl(sc, scr, cmd, data, flag, l));
1163 }
1164
1165 int
1166 wsdisplay_param(device_t dv, u_long cmd, struct wsdisplay_param *dp)
1167 {
1168 struct wsdisplay_softc *sc = device_private(dv);
1169 return ((*sc->sc_accessops->ioctl)(sc->sc_accesscookie,
1170 sc->sc_focus->scr_dconf->emulcookie,
1171 cmd, (void *)dp, 0, NULL));
1172 }
1173
1174 int
1175 wsdisplay_internal_ioctl(struct wsdisplay_softc *sc, struct wsscreen *scr,
1176 u_long cmd, void *data, int flag, struct lwp *l)
1177 {
1178 int error;
1179 char namebuf[16];
1180 struct wsdisplay_font fd;
1181 #ifdef WSDISPLAY_SCROLLSUPPORT
1182 struct wsdisplay_scroll_data *ksdp, *usdp;
1183 #endif
1184
1185 #if NWSKBD > 0
1186 struct wsevsrc *inp;
1187
1188 #ifdef WSDISPLAY_COMPAT_RAWKBD
1189 switch (cmd) {
1190 case WSKBDIO_SETMODE:
1191 scr->scr_rawkbd = (*(int *)data == WSKBD_RAW);
1192 return (wsdisplay_update_rawkbd(sc, scr));
1193 case WSKBDIO_GETMODE:
1194 *(int *)data = (scr->scr_rawkbd ?
1195 WSKBD_RAW : WSKBD_TRANSLATED);
1196 return (0);
1197 }
1198 #endif
1199 inp = sc->sc_input;
1200 if (inp == NULL)
1201 return (ENXIO);
1202 error = wsevsrc_display_ioctl(inp, cmd, data, flag, l);
1203 if (error != EPASSTHROUGH)
1204 return (error);
1205 #endif /* NWSKBD > 0 */
1206
1207 switch (cmd) {
1208 case WSDISPLAYIO_GMODE:
1209 if (scr->scr_flags & SCR_GRAPHICS) {
1210 if (scr->scr_flags & SCR_DUMBFB)
1211 *(u_int *)data = WSDISPLAYIO_MODE_DUMBFB;
1212 else
1213 *(u_int *)data = WSDISPLAYIO_MODE_MAPPED;
1214 } else
1215 *(u_int *)data = WSDISPLAYIO_MODE_EMUL;
1216 return (0);
1217
1218 case WSDISPLAYIO_SMODE:
1219 #define d (*(int *)data)
1220 if (d != WSDISPLAYIO_MODE_EMUL &&
1221 d != WSDISPLAYIO_MODE_MAPPED &&
1222 d != WSDISPLAYIO_MODE_DUMBFB)
1223 return (EINVAL);
1224
1225 if (WSSCREEN_HAS_EMULATOR(scr)) {
1226 scr->scr_flags &= ~SCR_GRAPHICS;
1227 if (d == WSDISPLAYIO_MODE_MAPPED ||
1228 d == WSDISPLAYIO_MODE_DUMBFB)
1229 scr->scr_flags |= SCR_GRAPHICS |
1230 ((d == WSDISPLAYIO_MODE_DUMBFB) ? SCR_DUMBFB : 0);
1231 } else if (d == WSDISPLAYIO_MODE_EMUL)
1232 return (EINVAL);
1233
1234 (void)(*sc->sc_accessops->ioctl)(sc->sc_accesscookie,
1235 scr->scr_dconf->emulcookie, cmd, data, flag, l);
1236
1237 return (0);
1238 #undef d
1239
1240 #ifdef WSDISPLAY_SCROLLSUPPORT
1241 #define SETSCROLLLINES(dstp, srcp, dfltp) \
1242 do { \
1243 (dstp)->fastlines = ((srcp)->which & \
1244 WSDISPLAY_SCROLL_DOFASTLINES) ? \
1245 (srcp)->fastlines : (dfltp)->fastlines; \
1246 (dstp)->slowlines = ((srcp)->which & \
1247 WSDISPLAY_SCROLL_DOSLOWLINES) ? \
1248 (srcp)->slowlines : (dfltp)->slowlines; \
1249 (dstp)->which = WSDISPLAY_SCROLL_DOALL; \
1250 } while (0)
1251
1252
1253 case WSDISPLAYIO_DSSCROLL:
1254 usdp = (struct wsdisplay_scroll_data *)data;
1255 ksdp = &sc->sc_scroll_values;
1256 SETSCROLLLINES(ksdp, usdp, ksdp);
1257 return (0);
1258
1259 case WSDISPLAYIO_DGSCROLL:
1260 usdp = (struct wsdisplay_scroll_data *)data;
1261 ksdp = &sc->sc_scroll_values;
1262 SETSCROLLLINES(usdp, ksdp, ksdp);
1263 return (0);
1264 #else
1265 case WSDISPLAYIO_DSSCROLL:
1266 case WSDISPLAYIO_DGSCROLL:
1267 return ENODEV;
1268 #endif
1269
1270 case WSDISPLAYIO_SFONT:
1271 #define d ((struct wsdisplay_usefontdata *)data)
1272 if (!sc->sc_accessops->load_font)
1273 return (EINVAL);
1274 if (d->name) {
1275 error = copyinstr(d->name, namebuf, sizeof(namebuf), 0);
1276 if (error)
1277 return (error);
1278 fd.name = namebuf;
1279 } else
1280 fd.name = 0;
1281 fd.data = 0;
1282 error = (*sc->sc_accessops->load_font)(sc->sc_accesscookie,
1283 scr->scr_dconf->emulcookie, &fd);
1284 if (!error && WSSCREEN_HAS_EMULATOR(scr))
1285 (*scr->scr_dconf->wsemul->reset)
1286 (scr->scr_dconf->wsemulcookie, WSEMUL_SYNCFONT);
1287 return (error);
1288 #undef d
1289
1290 #ifdef WSDISPLAY_CUSTOM_OUTPUT
1291 case WSDISPLAYIO_GMSGATTRS:
1292 #define d ((struct wsdisplay_msgattrs *)data)
1293 (*scr->scr_dconf->wsemul->getmsgattrs)
1294 (scr->scr_dconf->wsemulcookie, d);
1295 return (0);
1296 #undef d
1297
1298 case WSDISPLAYIO_SMSGATTRS: {
1299 #define d ((struct wsdisplay_msgattrs *)data)
1300 int i;
1301 for (i = 0; i < WSDISPLAY_MAXSCREEN; i++)
1302 if (sc->sc_scr[i] != NULL)
1303 (*sc->sc_scr[i]->scr_dconf->wsemul->setmsgattrs)
1304 (sc->sc_scr[i]->scr_dconf->wsemulcookie,
1305 sc->sc_scr[i]->scr_dconf->scrdata,
1306 d);
1307 }
1308 return (0);
1309 #undef d
1310 #else
1311 case WSDISPLAYIO_GMSGATTRS:
1312 case WSDISPLAYIO_SMSGATTRS:
1313 return (ENODEV);
1314 #endif
1315 case WSDISPLAYIO_SETVERSION:
1316 return wsevent_setversion(&sc->evar, *(int *)data);
1317 }
1318
1319 /* check ioctls for display */
1320 return ((*sc->sc_accessops->ioctl)(sc->sc_accesscookie,
1321 scr->scr_dconf->emulcookie, cmd, data, flag, l));
1322 }
1323
1324 int
1325 wsdisplay_stat_ioctl(struct wsdisplay_softc *sc, u_long cmd, void *data,
1326 int flag, struct lwp *l)
1327 {
1328 switch (cmd) {
1329 case WSDISPLAYIO_GETACTIVESCREEN:
1330 *(int*)data = wsdisplay_getactivescreen(sc);
1331 return (0);
1332 }
1333
1334 return (EPASSTHROUGH);
1335 }
1336
1337 int
1338 wsdisplay_cfg_ioctl(struct wsdisplay_softc *sc, u_long cmd, void *data,
1339 int flag, struct lwp *l)
1340 {
1341 int error;
1342 char *type, typebuf[16], *emul, emulbuf[16];
1343 void *tbuf;
1344 u_int fontsz;
1345 #if defined(COMPAT_14) && NWSKBD > 0
1346 struct wsmux_device wsmuxdata;
1347 #endif
1348 #if NWSKBD > 0
1349 struct wsevsrc *inp;
1350 #endif
1351
1352 switch (cmd) {
1353 case WSDISPLAYIO_ADDSCREEN:
1354 #define d ((struct wsdisplay_addscreendata *)data)
1355 if (d->screentype) {
1356 error = copyinstr(d->screentype, typebuf,
1357 sizeof(typebuf), 0);
1358 if (error)
1359 return (error);
1360 type = typebuf;
1361 } else
1362 type = 0;
1363 if (d->emul) {
1364 error = copyinstr(d->emul, emulbuf, sizeof(emulbuf),0);
1365 if (error)
1366 return (error);
1367 emul = emulbuf;
1368 } else
1369 emul = 0;
1370
1371 if ((error = wsdisplay_addscreen(sc, d->idx, type, emul)) == 0)
1372 wsdisplay_addscreen_print(sc, d->idx, 0);
1373 return (error);
1374 #undef d
1375 case WSDISPLAYIO_DELSCREEN:
1376 #define d ((struct wsdisplay_delscreendata *)data)
1377 return (wsdisplay_delscreen(sc, d->idx, d->flags));
1378 #undef d
1379 case WSDISPLAYIO_LDFONT:
1380 #define d ((struct wsdisplay_font *)data)
1381 if (!sc->sc_accessops->load_font)
1382 return (EINVAL);
1383 if (d->name) {
1384 error = copyinstr(d->name, typebuf, sizeof(typebuf), 0);
1385 if (error)
1386 return (error);
1387 d->name = typebuf;
1388 } else
1389 d->name = "loaded"; /* ??? */
1390 fontsz = d->fontheight * d->stride * d->numchars;
1391 if (fontsz > WSDISPLAY_MAXFONTSZ)
1392 return (EINVAL);
1393
1394 tbuf = malloc(fontsz, M_DEVBUF, M_WAITOK);
1395 error = copyin(d->data, tbuf, fontsz);
1396 if (error) {
1397 free(tbuf, M_DEVBUF);
1398 return (error);
1399 }
1400 d->data = tbuf;
1401 error =
1402 (*sc->sc_accessops->load_font)(sc->sc_accesscookie, 0, d);
1403 free(tbuf, M_DEVBUF);
1404 #undef d
1405 return (error);
1406
1407 #if NWSKBD > 0
1408 #ifdef COMPAT_14
1409 case _O_WSDISPLAYIO_SETKEYBOARD:
1410 #define d ((struct wsdisplay_kbddata *)data)
1411 inp = sc->sc_input;
1412 if (inp == NULL)
1413 return (ENXIO);
1414 switch (d->op) {
1415 case _O_WSDISPLAY_KBD_ADD:
1416 if (d->idx == -1) {
1417 d->idx = wskbd_pickfree();
1418 if (d->idx == -1)
1419 return (ENXIO);
1420 }
1421 wsmuxdata.type = WSMUX_KBD;
1422 wsmuxdata.idx = d->idx;
1423 return (wsevsrc_ioctl(inp, WSMUX_ADD_DEVICE,
1424 &wsmuxdata, flag, l));
1425 case _O_WSDISPLAY_KBD_DEL:
1426 wsmuxdata.type = WSMUX_KBD;
1427 wsmuxdata.idx = d->idx;
1428 return (wsevsrc_ioctl(inp, WSMUX_REMOVE_DEVICE,
1429 &wsmuxdata, flag, l));
1430 default:
1431 return (EINVAL);
1432 }
1433 #undef d
1434 #endif
1435
1436 case WSMUXIO_ADD_DEVICE:
1437 #define d ((struct wsmux_device *)data)
1438 if (d->idx == -1 && d->type == WSMUX_KBD)
1439 d->idx = wskbd_pickfree();
1440 #undef d
1441 /* fall into */
1442 case WSMUXIO_INJECTEVENT:
1443 case WSMUXIO_REMOVE_DEVICE:
1444 case WSMUXIO_LIST_DEVICES:
1445 inp = sc->sc_input;
1446 if (inp == NULL)
1447 return (ENXIO);
1448 return (wsevsrc_ioctl(inp, cmd, data, flag, l));
1449 #endif /* NWSKBD > 0 */
1450
1451 }
1452 return (EPASSTHROUGH);
1453 }
1454
1455 int
1456 wsdisplay_stat_inject(device_t dv, u_int type, int value)
1457 {
1458 struct wsdisplay_softc *sc = device_private(dv);
1459 struct wseventvar *evar;
1460 struct wscons_event event;
1461
1462 evar = &sc->evar;
1463
1464 if (evar == NULL)
1465 return (0);
1466
1467 if (evar->q == NULL)
1468 return (1);
1469
1470 event.type = type;
1471 event.value = value;
1472 if (wsevent_inject(evar, &event, 1) != 0) {
1473 log(LOG_WARNING, "wsdisplay: event queue overflow\n");
1474 return (1);
1475 }
1476
1477 return (0);
1478 }
1479
1480 paddr_t
1481 wsdisplaymmap(dev_t dev, off_t offset, int prot)
1482 {
1483 struct wsdisplay_softc *sc;
1484 struct wsscreen *scr;
1485
1486 sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
1487
1488 if (ISWSDISPLAYSTAT(dev))
1489 return (-1);
1490
1491 if (ISWSDISPLAYCTL(dev))
1492 return (-1);
1493
1494 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
1495 return (-1);
1496
1497 if (!(scr->scr_flags & SCR_GRAPHICS))
1498 return (-1);
1499
1500 /* pass mmap to display */
1501 return ((*sc->sc_accessops->mmap)(sc->sc_accesscookie,
1502 scr->scr_dconf->emulcookie, offset, prot));
1503 }
1504
1505 void
1506 wsdisplaystart(struct tty *tp)
1507 {
1508 struct wsdisplay_softc *sc;
1509 struct wsscreen *scr;
1510 int s, n;
1511 u_char *tbuf;
1512
1513 s = spltty();
1514 if (tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP)) {
1515 splx(s);
1516 return;
1517 }
1518 sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(tp->t_dev));
1519 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(tp->t_dev)]) == NULL) {
1520 splx(s);
1521 return;
1522 }
1523
1524 if (scr->scr_hold_screen) {
1525 tp->t_state |= TS_TIMEOUT;
1526 splx(s);
1527 return;
1528 }
1529 tp->t_state |= TS_BUSY;
1530 splx(s);
1531
1532 #ifdef DIAGNOSTIC
1533 scr->scr_in_ttyoutput = 1;
1534 #endif
1535
1536 /*
1537 * Drain output from ring buffer.
1538 * The output will normally be in one contiguous chunk, but when the
1539 * ring wraps, it will be in two pieces.. one at the end of the ring,
1540 * the other at the start. For performance, rather than loop here,
1541 * we output one chunk, see if there's another one, and if so, output
1542 * it too.
1543 */
1544
1545 n = ndqb(&tp->t_outq, 0);
1546 tbuf = tp->t_outq.c_cf;
1547
1548 if (!(scr->scr_flags & SCR_GRAPHICS)) {
1549 KASSERT(WSSCREEN_HAS_EMULATOR(scr));
1550 (*scr->scr_dconf->wsemul->output)(scr->scr_dconf->wsemulcookie,
1551 tbuf, n, 0);
1552 }
1553 ndflush(&tp->t_outq, n);
1554
1555 if ((n = ndqb(&tp->t_outq, 0)) > 0) {
1556 tbuf = tp->t_outq.c_cf;
1557
1558 if (!(scr->scr_flags & SCR_GRAPHICS)) {
1559 KASSERT(WSSCREEN_HAS_EMULATOR(scr));
1560 (*scr->scr_dconf->wsemul->output)
1561 (scr->scr_dconf->wsemulcookie, tbuf, n, 0);
1562 }
1563 ndflush(&tp->t_outq, n);
1564 }
1565
1566 #ifdef DIAGNOSTIC
1567 scr->scr_in_ttyoutput = 0;
1568 #endif
1569
1570 s = spltty();
1571 tp->t_state &= ~TS_BUSY;
1572 /* Come back if there's more to do */
1573 if (ttypull(tp)) {
1574 tp->t_state |= TS_TIMEOUT;
1575 callout_schedule(&tp->t_rstrt_ch, (hz > 128) ? (hz / 128) : 1);
1576 }
1577 splx(s);
1578 }
1579
1580 void
1581 wsdisplaystop(struct tty *tp, int flag)
1582 {
1583 int s;
1584
1585 s = spltty();
1586 if (ISSET(tp->t_state, TS_BUSY))
1587 if (!ISSET(tp->t_state, TS_TTSTOP))
1588 SET(tp->t_state, TS_FLUSH);
1589 splx(s);
1590 }
1591
1592 /* Set line parameters. */
1593 int
1594 wsdisplayparam(struct tty *tp, struct termios *t)
1595 {
1596
1597 tp->t_ispeed = t->c_ispeed;
1598 tp->t_ospeed = t->c_ospeed;
1599 tp->t_cflag = t->c_cflag;
1600 return 0;
1601 }
1602
1603 /*
1604 * Callbacks for the emulation code.
1605 */
1606 void
1607 wsdisplay_emulbell(void *v)
1608 {
1609 struct wsscreen *scr = v;
1610
1611 if (scr == NULL) /* console, before real attach */
1612 return;
1613
1614 if (scr->scr_flags & SCR_GRAPHICS) /* can this happen? */
1615 return;
1616
1617 (void) wsdisplay_internal_ioctl(scr->sc, scr, WSKBDIO_BELL, NULL,
1618 FWRITE, NULL);
1619 }
1620
1621 void
1622 wsdisplay_emulinput(void *v, const u_char *data, u_int count)
1623 {
1624 struct wsscreen *scr = v;
1625 struct tty *tp;
1626 int (*ifcn)(int, struct tty *);
1627
1628 if (v == NULL) /* console, before real attach */
1629 return;
1630
1631 if (scr->scr_flags & SCR_GRAPHICS) /* XXX can't happen */
1632 return;
1633 if (!WSSCREEN_HAS_TTY(scr))
1634 return;
1635
1636 tp = scr->scr_tty;
1637
1638 /*
1639 * XXX bad hack to work around locking problems in tty.c:
1640 * ttyinput() will try to lock again, causing deadlock.
1641 * We assume that wsdisplay_emulinput() can only be called
1642 * from within wsdisplaystart(), and thus the tty lock
1643 * is already held. Use an entry point which doesn't lock.
1644 */
1645 KASSERT(scr->scr_in_ttyoutput);
1646 ifcn = tp->t_linesw->l_rint;
1647 if (ifcn == ttyinput)
1648 ifcn = ttyinput_wlock;
1649
1650 while (count-- > 0)
1651 (*ifcn)(*data++, tp);
1652 }
1653
1654 /*
1655 * Calls from the keyboard interface.
1656 */
1657 void
1658 wsdisplay_kbdinput(device_t dv, keysym_t ks)
1659 {
1660 struct wsdisplay_softc *sc = device_private(dv);
1661 struct wsscreen *scr;
1662 const char *dp;
1663 int count;
1664 struct tty *tp;
1665
1666 KASSERT(sc != NULL);
1667
1668 scr = sc->sc_focus;
1669
1670 if (!scr || !WSSCREEN_HAS_TTY(scr))
1671 return;
1672
1673 tp = scr->scr_tty;
1674
1675 if (KS_GROUP(ks) == KS_GROUP_Ascii)
1676 (*tp->t_linesw->l_rint)(KS_VALUE(ks), tp);
1677 else if (WSSCREEN_HAS_EMULATOR(scr)) {
1678 count = (*scr->scr_dconf->wsemul->translate)
1679 (scr->scr_dconf->wsemulcookie, ks, &dp);
1680 while (count-- > 0)
1681 (*tp->t_linesw->l_rint)(*dp++, tp);
1682 }
1683 }
1684
1685 #if defined(WSDISPLAY_COMPAT_RAWKBD)
1686 int
1687 wsdisplay_update_rawkbd(struct wsdisplay_softc *sc, struct wsscreen *scr)
1688 {
1689 #if NWSKBD > 0
1690 int s, raw, data, error;
1691 struct wsevsrc *inp;
1692
1693 s = spltty();
1694
1695 raw = (scr ? scr->scr_rawkbd : 0);
1696
1697 if (scr != sc->sc_focus ||
1698 sc->sc_rawkbd == raw) {
1699 splx(s);
1700 return (0);
1701 }
1702
1703 data = raw ? WSKBD_RAW : WSKBD_TRANSLATED;
1704 inp = sc->sc_input;
1705 if (inp == NULL) {
1706 splx(s);
1707 return (ENXIO);
1708 }
1709 error = wsevsrc_display_ioctl(inp, WSKBDIO_SETMODE, &data, 0, 0);
1710 if (!error)
1711 sc->sc_rawkbd = raw;
1712 splx(s);
1713 return (error);
1714 #else
1715 return (0);
1716 #endif
1717 }
1718 #endif
1719
1720 static void
1721 wsdisplay_switch3_cb(void *arg, int error, int waitok)
1722 {
1723 device_t dv = arg;
1724
1725 wsdisplay_switch3(dv, error, waitok);
1726 }
1727
1728 static int
1729 wsdisplay_switch3(device_t dv, int error, int waitok)
1730 {
1731 struct wsdisplay_softc *sc = device_private(dv);
1732 int no;
1733 struct wsscreen *scr;
1734
1735 if (!(sc->sc_flags & SC_SWITCHPENDING)) {
1736 aprint_error_dev(dv, "wsdisplay_switch3: not switching\n");
1737 return (EINVAL);
1738 }
1739
1740 no = sc->sc_screenwanted;
1741 if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
1742 panic("wsdisplay_switch3: invalid screen %d", no);
1743 scr = sc->sc_scr[no];
1744 if (!scr) {
1745 aprint_error_dev(dv,
1746 "wsdisplay_switch3: screen %d disappeared\n", no);
1747 error = ENXIO;
1748 }
1749
1750 if (error) {
1751 /* try to recover, avoid recursion */
1752
1753 if (sc->sc_oldscreen == WSDISPLAY_NULLSCREEN) {
1754 aprint_error_dev(dv, "wsdisplay_switch3: giving up\n");
1755 sc->sc_focus = 0;
1756 #ifdef WSDISPLAY_COMPAT_RAWKBD
1757 wsdisplay_update_rawkbd(sc, 0);
1758 #endif
1759 sc->sc_flags &= ~SC_SWITCHPENDING;
1760 return (error);
1761 }
1762
1763 sc->sc_screenwanted = sc->sc_oldscreen;
1764 sc->sc_oldscreen = WSDISPLAY_NULLSCREEN;
1765 return (wsdisplay_switch1(dv, 0, waitok));
1766 }
1767
1768 if (scr->scr_syncops && !error)
1769 sc->sc_flags |= SC_XATTACHED;
1770
1771 sc->sc_flags &= ~SC_SWITCHPENDING;
1772
1773 if (!error && (scr->scr_flags & SCR_WAITACTIVE))
1774 wakeup(scr);
1775 return (error);
1776 }
1777
1778 static void
1779 wsdisplay_switch2_cb(void *arg, int error, int waitok)
1780 {
1781 device_t dv = arg;
1782
1783 wsdisplay_switch2(dv, error, waitok);
1784 }
1785
1786 static int
1787 wsdisplay_switch2(device_t dv, int error, int waitok)
1788 {
1789 struct wsdisplay_softc *sc = device_private(dv);
1790 int no;
1791 struct wsscreen *scr;
1792
1793 if (!(sc->sc_flags & SC_SWITCHPENDING)) {
1794 aprint_error_dev(dv, "wsdisplay_switch2: not switching\n");
1795 return (EINVAL);
1796 }
1797
1798 no = sc->sc_screenwanted;
1799 if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
1800 panic("wsdisplay_switch2: invalid screen %d", no);
1801 scr = sc->sc_scr[no];
1802 if (!scr) {
1803 aprint_error_dev(dv,
1804 "wsdisplay_switch2: screen %d disappeared\n", no);
1805 error = ENXIO;
1806 }
1807
1808 if (error) {
1809 /* try to recover, avoid recursion */
1810
1811 if (sc->sc_oldscreen == WSDISPLAY_NULLSCREEN) {
1812 aprint_error_dev(dv, "wsdisplay_switch2: giving up\n");
1813 sc->sc_focus = 0;
1814 sc->sc_flags &= ~SC_SWITCHPENDING;
1815 return (error);
1816 }
1817
1818 sc->sc_screenwanted = sc->sc_oldscreen;
1819 sc->sc_oldscreen = WSDISPLAY_NULLSCREEN;
1820 return (wsdisplay_switch1(dv, 0, waitok));
1821 }
1822
1823 sc->sc_focusidx = no;
1824 sc->sc_focus = scr;
1825
1826 #ifdef WSDISPLAY_COMPAT_RAWKBD
1827 (void) wsdisplay_update_rawkbd(sc, scr);
1828 #endif
1829 /* keyboard map??? */
1830
1831 if (scr->scr_syncops &&
1832 !(sc->sc_isconsole && wsdisplay_cons_pollmode)) {
1833 error = (*scr->scr_syncops->attach)(scr->scr_synccookie, waitok,
1834 wsdisplay_switch3_cb, dv);
1835 if (error == EAGAIN) {
1836 /* switch will be done asynchronously */
1837 return (0);
1838 }
1839 }
1840
1841 return (wsdisplay_switch3(dv, error, waitok));
1842 }
1843
1844 static void
1845 wsdisplay_switch1_cb(void *arg, int error, int waitok)
1846 {
1847 device_t dv = arg;
1848
1849 wsdisplay_switch1(dv, error, waitok);
1850 }
1851
1852 static int
1853 wsdisplay_switch1(device_t dv, int error, int waitok)
1854 {
1855 struct wsdisplay_softc *sc = device_private(dv);
1856 int no;
1857 struct wsscreen *scr;
1858
1859 if (!(sc->sc_flags & SC_SWITCHPENDING)) {
1860 aprint_error_dev(dv, "wsdisplay_switch1: not switching\n");
1861 return (EINVAL);
1862 }
1863
1864 no = sc->sc_screenwanted;
1865 if (no == WSDISPLAY_NULLSCREEN) {
1866 sc->sc_flags &= ~SC_SWITCHPENDING;
1867 if (!error) {
1868 sc->sc_flags &= ~SC_XATTACHED;
1869 sc->sc_focus = 0;
1870 }
1871 wakeup(sc);
1872 return (error);
1873 }
1874 if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
1875 panic("wsdisplay_switch1: invalid screen %d", no);
1876 scr = sc->sc_scr[no];
1877 if (!scr) {
1878 aprint_error_dev(dv, "wsdisplay_switch1: screen %d disappeared\n", no);
1879 error = ENXIO;
1880 }
1881
1882 if (error) {
1883 sc->sc_flags &= ~SC_SWITCHPENDING;
1884 return (error);
1885 }
1886
1887 sc->sc_flags &= ~SC_XATTACHED;
1888
1889 error = (*sc->sc_accessops->show_screen)(sc->sc_accesscookie,
1890 scr->scr_dconf->emulcookie,
1891 waitok,
1892 sc->sc_isconsole && wsdisplay_cons_pollmode ? 0 : wsdisplay_switch2_cb, dv);
1893 if (error == EAGAIN) {
1894 /* switch will be done asynchronously */
1895 return (0);
1896 }
1897
1898 return (wsdisplay_switch2(dv, error, waitok));
1899 }
1900
1901 int
1902 wsdisplay_switch(device_t dv, int no, int waitok)
1903 {
1904 struct wsdisplay_softc *sc = device_private(dv);
1905 int s, res = 0;
1906 struct wsscreen *scr;
1907
1908 if (no != WSDISPLAY_NULLSCREEN) {
1909 if ((no < 0 || no >= WSDISPLAY_MAXSCREEN))
1910 return (EINVAL);
1911 if (sc->sc_scr[no] == NULL)
1912 return (ENXIO);
1913 }
1914
1915 wsdisplay_stat_inject(dv, WSCONS_EVENT_SCREEN_SWITCH, no);
1916
1917 s = spltty();
1918
1919 if ((sc->sc_focus && no == sc->sc_focusidx) ||
1920 (sc->sc_focus == NULL && no == WSDISPLAY_NULLSCREEN)) {
1921 splx(s);
1922 return (0);
1923 }
1924
1925 if (sc->sc_flags & SC_SWITCHPENDING) {
1926 splx(s);
1927 return (EBUSY);
1928 }
1929
1930 sc->sc_flags |= SC_SWITCHPENDING;
1931 sc->sc_screenwanted = no;
1932
1933 splx(s);
1934
1935 scr = sc->sc_focus;
1936 if (!scr) {
1937 sc->sc_oldscreen = WSDISPLAY_NULLSCREEN;
1938 return (wsdisplay_switch1(dv, 0, waitok));
1939 } else
1940 sc->sc_oldscreen = sc->sc_focusidx;
1941
1942 if (scr->scr_syncops) {
1943 if (!(sc->sc_flags & SC_XATTACHED) ||
1944 (sc->sc_isconsole && wsdisplay_cons_pollmode)) {
1945 /* nothing to do here */
1946 return (wsdisplay_switch1(dv, 0, waitok));
1947 }
1948 res = (*scr->scr_syncops->detach)(scr->scr_synccookie, waitok,
1949 wsdisplay_switch1_cb, dv);
1950 if (res == EAGAIN) {
1951 /* switch will be done asynchronously */
1952 return (0);
1953 }
1954 } else if (scr->scr_flags & SCR_GRAPHICS) {
1955 /* no way to save state */
1956 res = EBUSY;
1957 }
1958
1959 return (wsdisplay_switch1(dv, res, waitok));
1960 }
1961
1962 void
1963 wsdisplay_reset(device_t dv, enum wsdisplay_resetops op)
1964 {
1965 struct wsdisplay_softc *sc = device_private(dv);
1966 struct wsscreen *scr;
1967
1968 KASSERT(sc != NULL);
1969 scr = sc->sc_focus;
1970
1971 if (!scr)
1972 return;
1973
1974 switch (op) {
1975 case WSDISPLAY_RESETEMUL:
1976 if (!WSSCREEN_HAS_EMULATOR(scr))
1977 break;
1978 (*scr->scr_dconf->wsemul->reset)(scr->scr_dconf->wsemulcookie,
1979 WSEMUL_RESET);
1980 break;
1981 case WSDISPLAY_RESETCLOSE:
1982 wsdisplay_closescreen(sc, scr);
1983 break;
1984 }
1985 }
1986
1987 /*
1988 * Interface for (external) VT switch / process synchronization code
1989 */
1990 int
1991 wsscreen_attach_sync(struct wsscreen *scr, const struct wscons_syncops *ops,
1992 void *cookie)
1993 {
1994 if (scr->scr_syncops) {
1995 /*
1996 * The screen is already claimed.
1997 * Check if the owner is still alive.
1998 */
1999 if ((*scr->scr_syncops->check)(scr->scr_synccookie))
2000 return (EBUSY);
2001 }
2002 scr->scr_syncops = ops;
2003 scr->scr_synccookie = cookie;
2004 if (scr == scr->sc->sc_focus)
2005 scr->sc->sc_flags |= SC_XATTACHED;
2006 return (0);
2007 }
2008
2009 int
2010 wsscreen_detach_sync(struct wsscreen *scr)
2011 {
2012 if (!scr->scr_syncops)
2013 return (EINVAL);
2014 scr->scr_syncops = 0;
2015 if (scr == scr->sc->sc_focus)
2016 scr->sc->sc_flags &= ~SC_XATTACHED;
2017 return (0);
2018 }
2019
2020 int
2021 wsscreen_lookup_sync(struct wsscreen *scr,
2022 const struct wscons_syncops *ops, /* used as ID */
2023 void **cookiep)
2024 {
2025 if (!scr->scr_syncops || ops != scr->scr_syncops)
2026 return (EINVAL);
2027 *cookiep = scr->scr_synccookie;
2028 return (0);
2029 }
2030
2031 /*
2032 * Interface to virtual screen stuff
2033 */
2034 int
2035 wsdisplay_maxscreenidx(struct wsdisplay_softc *sc)
2036 {
2037 return (WSDISPLAY_MAXSCREEN - 1);
2038 }
2039
2040 int
2041 wsdisplay_screenstate(struct wsdisplay_softc *sc, int idx)
2042 {
2043 if (idx < 0 || idx >= WSDISPLAY_MAXSCREEN)
2044 return (EINVAL);
2045 if (!sc->sc_scr[idx])
2046 return (ENXIO);
2047 return ((sc->sc_scr[idx]->scr_flags & SCR_OPEN) ? EBUSY : 0);
2048 }
2049
2050 int
2051 wsdisplay_getactivescreen(struct wsdisplay_softc *sc)
2052 {
2053 return (sc->sc_focus ? sc->sc_focusidx : WSDISPLAY_NULLSCREEN);
2054 }
2055
2056 int
2057 wsscreen_switchwait(struct wsdisplay_softc *sc, int no)
2058 {
2059 struct wsscreen *scr;
2060 int s, res = 0;
2061
2062 if (no == WSDISPLAY_NULLSCREEN) {
2063 s = spltty();
2064 while (sc->sc_focus && res == 0) {
2065 res = tsleep(sc, PCATCH, "wswait", 0);
2066 }
2067 splx(s);
2068 return (res);
2069 }
2070
2071 if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
2072 return (ENXIO);
2073 scr = sc->sc_scr[no];
2074 if (!scr)
2075 return (ENXIO);
2076
2077 s = spltty();
2078 if (scr != sc->sc_focus) {
2079 scr->scr_flags |= SCR_WAITACTIVE;
2080 res = tsleep(scr, PCATCH, "wswait", 0);
2081 if (scr != sc->sc_scr[no])
2082 res = ENXIO; /* disappeared in the meantime */
2083 else
2084 scr->scr_flags &= ~SCR_WAITACTIVE;
2085 }
2086 splx(s);
2087 return (res);
2088 }
2089
2090 void
2091 wsdisplay_kbdholdscreen(device_t dv, int hold)
2092 {
2093 struct wsdisplay_softc *sc = device_private(dv);
2094 struct wsscreen *scr;
2095
2096 scr = sc->sc_focus;
2097
2098 if (!scr)
2099 return;
2100
2101 if (hold)
2102 scr->scr_hold_screen = 1;
2103 else {
2104 scr->scr_hold_screen = 0;
2105 callout_schedule(&scr->scr_tty->t_rstrt_ch, 0);
2106 }
2107 }
2108
2109 #if NWSKBD > 0
2110 void
2111 wsdisplay_set_console_kbd(struct wsevsrc *src)
2112 {
2113 if (wsdisplay_console_device == NULL) {
2114 src->me_dispdv = NULL;
2115 return;
2116 }
2117 #if NWSMUX > 0
2118 if (wsmux_attach_sc((struct wsmux_softc *)
2119 wsdisplay_console_device->sc_input, src)) {
2120 src->me_dispdv = NULL;
2121 return;
2122 }
2123 #else
2124 wsdisplay_console_device->sc_input = src;
2125 #endif
2126 src->me_dispdv = wsdisplay_console_device->sc_dev;
2127 }
2128 #endif /* NWSKBD > 0 */
2129
2130 /*
2131 * Console interface.
2132 */
2133 void
2134 wsdisplay_cnputc(dev_t dev, int i)
2135 {
2136 struct wsscreen_internal *dc;
2137 u_char c = i;
2138
2139 if (!wsdisplay_console_initted)
2140 return;
2141
2142 if ((wsdisplay_console_device != NULL) &&
2143 (wsdisplay_console_device->sc_scr[0] != NULL) &&
2144 (wsdisplay_console_device->sc_scr[0]->scr_flags & SCR_GRAPHICS))
2145 return;
2146
2147 dc = &wsdisplay_console_conf;
2148 (*dc->wsemul->output)(dc->wsemulcookie, &c, 1, 1);
2149 }
2150
2151 static int
2152 wsdisplay_getc_dummy(dev_t dev)
2153 {
2154 /* panic? */
2155 return (0);
2156 }
2157
2158 static void
2159 wsdisplay_pollc(dev_t dev, int on)
2160 {
2161
2162 wsdisplay_cons_pollmode = on;
2163
2164 /* notify to fb drivers */
2165 if (wsdisplay_console_device != NULL &&
2166 wsdisplay_console_device->sc_accessops->pollc != NULL)
2167 (*wsdisplay_console_device->sc_accessops->pollc)
2168 (wsdisplay_console_device->sc_accesscookie, on);
2169
2170 /* notify to kbd drivers */
2171 if (wsdisplay_cons_kbd_pollc)
2172 (*wsdisplay_cons_kbd_pollc)(NODEV, on);
2173 }
2174
2175 void
2176 wsdisplay_set_cons_kbd(int (*get)(dev_t), void (*poll)(dev_t, int),
2177 void (*bell)(dev_t, u_int, u_int, u_int))
2178 {
2179 wsdisplay_cons.cn_getc = get;
2180 wsdisplay_cons.cn_bell = bell;
2181 wsdisplay_cons_kbd_pollc = poll;
2182 }
2183
2184 void
2185 wsdisplay_unset_cons_kbd(void)
2186 {
2187 wsdisplay_cons.cn_getc = wsdisplay_getc_dummy;
2188 wsdisplay_cons.cn_bell = NULL;
2189 wsdisplay_cons_kbd_pollc = 0;
2190 }
NetBSD on the FriendlyARM MINI2440