31
32#include "opt_syscons.h"
33#include "opt_splash.h"
34#include "opt_ddb.h"
35
36#include <sys/param.h>
37#include <sys/systm.h>
38#include <sys/conf.h>
39#include <sys/cons.h>
40#include <sys/consio.h>
41#include <sys/kdb.h>
42#include <sys/eventhandler.h>
43#include <sys/fbio.h>
44#include <sys/kbio.h>
45#include <sys/kernel.h>
46#include <sys/lock.h>
47#include <sys/malloc.h>
48#include <sys/mutex.h>
49#include <sys/proc.h>
50#include <sys/random.h>
51#include <sys/reboot.h>
52#include <sys/signalvar.h>
53#include <sys/sysctl.h>
54#include <sys/tty.h>
55#include <sys/power.h>
56
57#include <machine/clock.h>
58#if __sparc64__ || __powerpc__
59#include <machine/sc_machdep.h>
60#else
61#include <machine/pc/display.h>
62#endif
63#ifdef __i386__
64#include <machine/psl.h>
65#include <machine/apm_bios.h>
66#include <machine/frame.h>
67#endif
68
69#include <dev/kbd/kbdreg.h>
70#include <dev/fb/fbreg.h>
71#include <dev/fb/splashreg.h>
72#include <dev/syscons/syscons.h>
73
74#define COLD 0
75#define WARM 1
76
77#define DEFAULT_BLANKTIME (5*60) /* 5 minutes */
78#define MAX_BLANKTIME (7*24*60*60) /* 7 days!? */
79
80#define KEYCODE_BS 0x0e /* "<-- Backspace" key, XXX */
81
82typedef struct default_attr {
83 int std_color; /* normal hardware color */
84 int rev_color; /* reverse hardware color */
85} default_attr;
86
87static default_attr user_default = {
88 SC_NORM_ATTR,
89 SC_NORM_REV_ATTR,
90};
91
92static default_attr kernel_default = {
93 SC_KERNEL_CONS_ATTR,
94 SC_KERNEL_CONS_REV_ATTR,
95};
96
97static int sc_console_unit = -1;
98static int sc_saver_keyb_only = 1;
99static scr_stat *sc_console;
100static struct tty *sc_console_tty;
101static struct consdev *sc_consptr;
102static void *kernel_console_ts;
103static scr_stat main_console;
104static struct cdev *main_devs[MAXCONS];
105
106static char init_done = COLD;
107static char shutdown_in_progress = FALSE;
108static char sc_malloc = FALSE;
109
110static int saver_mode = CONS_NO_SAVER; /* LKM/user saver */
111static int run_scrn_saver = FALSE; /* should run the saver? */
112static int enable_bell = TRUE; /* enable beeper */
113static long scrn_blank_time = 0; /* screen saver timeout value */
114#ifdef DEV_SPLASH
115static int scrn_blanked; /* # of blanked screen */
116static int sticky_splash = FALSE;
117
118static void none_saver(sc_softc_t *sc, int blank) { }
119static void (*current_saver)(sc_softc_t *, int) = none_saver;
120#endif
121
122SYSCTL_NODE(_hw, OID_AUTO, syscons, CTLFLAG_RD, 0, "syscons");
123SYSCTL_NODE(_hw_syscons, OID_AUTO, saver, CTLFLAG_RD, 0, "saver");
124SYSCTL_INT(_hw_syscons_saver, OID_AUTO, keybonly, CTLFLAG_RW,
125 &sc_saver_keyb_only, 0, "screen saver interrupted by input only");
126SYSCTL_INT(_hw_syscons, OID_AUTO, bell, CTLFLAG_RW, &enable_bell,
127 0, "enable bell");
128#if !defined(SC_NO_FONT_LOADING) && defined(SC_DFLT_FONT)
129#include "font.h"
130#endif
131
132 d_ioctl_t *sc_user_ioctl;
133
134static bios_values_t bios_value;
135
136static int enable_panic_key;
137SYSCTL_INT(_machdep, OID_AUTO, enable_panic_key, CTLFLAG_RW, &enable_panic_key,
138 0, "");
139
140#define SC_CONSOLECTL 255
141
142#define VIRTUAL_TTY(sc, x) (SC_DEV((sc), (x)) != NULL ? \
143 SC_DEV((sc), (x))->si_tty : NULL)
144#define ISTTYOPEN(tp) ((tp) && ((tp)->t_state & TS_ISOPEN))
145
146static int debugger;
147
148/* prototypes */
149static int scvidprobe(int unit, int flags, int cons);
150static int sckbdprobe(int unit, int flags, int cons);
151static void scmeminit(void *arg);
152static int scdevtounit(struct cdev *dev);
153static kbd_callback_func_t sckbdevent;
154static int scparam(struct tty *tp, struct termios *t);
155static void scstart(struct tty *tp);
156static void scinit(int unit, int flags);
157static scr_stat *sc_get_stat(struct cdev *devptr);
158static void scterm(int unit, int flags);
159static void scshutdown(void *arg, int howto);
160static u_int scgetc(sc_softc_t *sc, u_int flags);
161#define SCGETC_CN 1
162#define SCGETC_NONBLOCK 2
163static int sccngetch(int flags);
164static void sccnupdate(scr_stat *scp);
165static scr_stat *alloc_scp(sc_softc_t *sc, int vty);
166static void init_scp(sc_softc_t *sc, int vty, scr_stat *scp);
167static timeout_t scrn_timer;
168static int and_region(int *s1, int *e1, int s2, int e2);
169static void scrn_update(scr_stat *scp, int show_cursor);
170
171#ifdef DEV_SPLASH
172static int scsplash_callback(int event, void *arg);
173static void scsplash_saver(sc_softc_t *sc, int show);
174static int add_scrn_saver(void (*this_saver)(sc_softc_t *, int));
175static int remove_scrn_saver(void (*this_saver)(sc_softc_t *, int));
176static int set_scrn_saver_mode(scr_stat *scp, int mode, u_char *pal, int border);
177static int restore_scrn_saver_mode(scr_stat *scp, int changemode);
178static void stop_scrn_saver(sc_softc_t *sc, void (*saver)(sc_softc_t *, int));
179static int wait_scrn_saver_stop(sc_softc_t *sc);
180#define scsplash_stick(stick) (sticky_splash = (stick))
181#else /* !DEV_SPLASH */
182#define scsplash_stick(stick)
183#endif /* DEV_SPLASH */
184
185static int do_switch_scr(sc_softc_t *sc, int s);
186static int vt_proc_alive(scr_stat *scp);
187static int signal_vt_rel(scr_stat *scp);
188static int signal_vt_acq(scr_stat *scp);
189static int finish_vt_rel(scr_stat *scp, int release, int *s);
190static int finish_vt_acq(scr_stat *scp);
191static void exchange_scr(sc_softc_t *sc);
192static void update_cursor_image(scr_stat *scp);
193static void change_cursor_shape(scr_stat *scp, int flags, int base, int height);
194static int save_kbd_state(scr_stat *scp);
195static int update_kbd_state(scr_stat *scp, int state, int mask);
196static int update_kbd_leds(scr_stat *scp, int which);
197static timeout_t blink_screen;
198
199static cn_probe_t sccnprobe;
200static cn_init_t sccninit;
201static cn_getc_t sccngetc;
202static cn_checkc_t sccncheckc;
203static cn_putc_t sccnputc;
204static cn_dbctl_t sccndbctl;
205static cn_term_t sccnterm;
206
207CONS_DRIVER(sc, sccnprobe, sccninit, sccnterm, sccngetc, sccncheckc, sccnputc,
208 sccndbctl);
209
210static d_open_t scopen;
211static d_close_t scclose;
212static d_read_t scread;
213static d_ioctl_t scioctl;
214static d_mmap_t scmmap;
215
216static struct cdevsw sc_cdevsw = {
217 .d_version = D_VERSION,
218 .d_open = scopen,
219 .d_close = scclose,
220 .d_read = scread,
221 .d_ioctl = scioctl,
222 .d_mmap = scmmap,
223 .d_name = "sc",
224 .d_flags = D_TTY | D_NEEDGIANT,
225};
226
227int
228sc_probe_unit(int unit, int flags)
229{
230 if (!scvidprobe(unit, flags, FALSE)) {
231 if (bootverbose)
232 printf("sc%d: no video adapter found.\n", unit);
233 return ENXIO;
234 }
235
236 /* syscons will be attached even when there is no keyboard */
237 sckbdprobe(unit, flags, FALSE);
238
239 return 0;
240}
241
242/* probe video adapters, return TRUE if found */
243static int
244scvidprobe(int unit, int flags, int cons)
245{
246 /*
247 * Access the video adapter driver through the back door!
248 * Video adapter drivers need to be configured before syscons.
249 * However, when syscons is being probed as the low-level console,
250 * they have not been initialized yet. We force them to initialize
251 * themselves here. XXX
252 */
253 vid_configure(cons ? VIO_PROBE_ONLY : 0);
254
255 return (vid_find_adapter("*", unit) >= 0);
256}
257
258/* probe the keyboard, return TRUE if found */
259static int
260sckbdprobe(int unit, int flags, int cons)
261{
262 /* access the keyboard driver through the backdoor! */
263 kbd_configure(cons ? KB_CONF_PROBE_ONLY : 0);
264
265 return (kbd_find_keyboard("*", unit) >= 0);
266}
267
268static char
269*adapter_name(video_adapter_t *adp)
270{
271 static struct {
272 int type;
273 char *name[2];
274 } names[] = {
275 { KD_MONO, { "MDA", "MDA" } },
276 { KD_HERCULES, { "Hercules", "Hercules" } },
277 { KD_CGA, { "CGA", "CGA" } },
278 { KD_EGA, { "EGA", "EGA (mono)" } },
279 { KD_VGA, { "VGA", "VGA (mono)" } },
280 { KD_PC98, { "PC-98x1", "PC-98x1" } },
281 { KD_TGA, { "TGA", "TGA" } },
282 { -1, { "Unknown", "Unknown" } },
283 };
284 int i;
285
286 for (i = 0; names[i].type != -1; ++i)
287 if (names[i].type == adp->va_type)
288 break;
289 return names[i].name[(adp->va_flags & V_ADP_COLOR) ? 0 : 1];
290}
291
292int
293sc_attach_unit(int unit, int flags)
294{
295 sc_softc_t *sc;
296 scr_stat *scp;
297#ifdef SC_PIXEL_MODE
298 video_info_t info;
299#endif
300 int vc;
301 struct cdev *dev;
302
303 flags &= ~SC_KERNEL_CONSOLE;
304
305 if (sc_console_unit == unit) {
306 /*
307 * If this unit is being used as the system console, we need to
308 * adjust some variables and buffers before and after scinit().
309 */
310 /* assert(sc_console != NULL) */
311 flags |= SC_KERNEL_CONSOLE;
312 scmeminit(NULL);
313
314 scinit(unit, flags);
315
316 if (sc_console->tsw->te_size > 0) {
317 /* assert(sc_console->ts != NULL); */
318 kernel_console_ts = sc_console->ts;
319 sc_console->ts = malloc(sc_console->tsw->te_size,
320 M_DEVBUF, M_WAITOK);
321 bcopy(kernel_console_ts, sc_console->ts, sc_console->tsw->te_size);
322 (*sc_console->tsw->te_default_attr)(sc_console,
323 user_default.std_color,
324 user_default.rev_color);
325 }
326 } else {
327 scinit(unit, flags);
328 }
329
330 sc = sc_get_softc(unit, flags & SC_KERNEL_CONSOLE);
331 sc->config = flags;
332 scp = sc_get_stat(sc->dev[0]);
333 if (sc_console == NULL) /* sc_console_unit < 0 */
334 sc_console = scp;
335
336#ifdef SC_PIXEL_MODE
337 if ((sc->config & SC_VESA800X600)
338 && ((*vidsw[sc->adapter]->get_info)(sc->adp, M_VESA_800x600, &info) == 0)) {
339#ifdef DEV_SPLASH
340 if (sc->flags & SC_SPLASH_SCRN)
341 splash_term(sc->adp);
342#endif
343 sc_set_graphics_mode(scp, NULL, M_VESA_800x600);
344 sc_set_pixel_mode(scp, NULL, COL, ROW, 16);
345 sc->initial_mode = M_VESA_800x600;
346#ifdef DEV_SPLASH
347 /* put up the splash again! */
348 if (sc->flags & SC_SPLASH_SCRN)
349 splash_init(sc->adp, scsplash_callback, sc);
350#endif
351 }
352#endif /* SC_PIXEL_MODE */
353
354 /* initialize cursor */
355 if (!ISGRAPHSC(scp))
356 update_cursor_image(scp);
357
358 /* get screen update going */
359 scrn_timer(sc);
360
361 /* set up the keyboard */
362 kbd_ioctl(sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
363 update_kbd_state(scp, scp->status, LOCK_MASK);
364
365 printf("sc%d: %s <%d virtual consoles, flags=0x%x>\n",
366 unit, adapter_name(sc->adp), sc->vtys, sc->config);
367 if (bootverbose) {
368 printf("sc%d:", unit);
369 if (sc->adapter >= 0)
370 printf(" fb%d", sc->adapter);
371 if (sc->keyboard >= 0)
372 printf(", kbd%d", sc->keyboard);
373 if (scp->tsw)
374 printf(", terminal emulator: %s (%s)",
375 scp->tsw->te_name, scp->tsw->te_desc);
376 printf("\n");
377 }
378
379 /* register a shutdown callback for the kernel console */
380 if (sc_console_unit == unit)
381 EVENTHANDLER_REGISTER(shutdown_pre_sync, scshutdown,
382 (void *)(uintptr_t)unit, SHUTDOWN_PRI_DEFAULT);
383
384 for (vc = 0; vc < sc->vtys; vc++) {
385 if (sc->dev[vc] == NULL) {
386 dev = make_dev(&sc_cdevsw, vc + unit * MAXCONS,
387 UID_ROOT, GID_WHEEL, 0600, "ttyv%r", vc + unit * MAXCONS);
388 sc->dev[vc] = dev;
389 sc->dev[vc]->si_tty = ttymalloc(sc->dev[vc]->si_tty);
390 if (vc == 0 && sc->dev == main_devs)
391 SC_STAT(sc->dev[0]) = &main_console;
392 }
393 /*
394 * The first vty already has struct tty and scr_stat initialized
395 * in scinit(). The other vtys will have these structs when
396 * first opened.
397 */
398 }
399
400 dev = make_dev(&sc_cdevsw, SC_CONSOLECTL,
401 UID_ROOT, GID_WHEEL, 0600, "consolectl");
402 dev->si_tty = sc_console_tty = ttymalloc(sc_console_tty);
403 SC_STAT(dev) = sc_console;
404
405 return 0;
406}
407
408static void
409scmeminit(void *arg)
410{
411 if (sc_malloc)
412 return;
413 sc_malloc = TRUE;
414
415 /*
416 * As soon as malloc() becomes functional, we had better allocate
417 * various buffers for the kernel console.
418 */
419
420 if (sc_console_unit < 0) /* sc_console == NULL */
421 return;
422
423 /* copy the temporary buffer to the final buffer */
424 sc_alloc_scr_buffer(sc_console, FALSE, FALSE);
425
426#ifndef SC_NO_CUTPASTE
427 sc_alloc_cut_buffer(sc_console, FALSE);
428#endif
429
430#ifndef SC_NO_HISTORY
431 /* initialize history buffer & pointers */
432 sc_alloc_history_buffer(sc_console, 0, 0, FALSE);
433#endif
434}
435
436/* XXX */
437SYSINIT(sc_mem, SI_SUB_KMEM, SI_ORDER_ANY, scmeminit, NULL);
438
439static int
440scdevtounit(struct cdev *dev)
441{
442 int vty = SC_VTY(dev);
443
444 if (vty == SC_CONSOLECTL)
445 return ((sc_console != NULL) ? sc_console->sc->unit : -1);
446 else if ((vty < 0) || (vty >= MAXCONS*sc_max_unit()))
447 return -1;
448 else
449 return vty/MAXCONS;
450}
451
452static int
453scopen(struct cdev *dev, int flag, int mode, struct thread *td)
454{
455 int unit = scdevtounit(dev);
456 sc_softc_t *sc;
457 struct tty *tp;
458 scr_stat *scp;
459#ifndef __sparc64__
460 keyarg_t key;
461#endif
462 int error;
463
464 DPRINTF(5, ("scopen: dev:%d,%d, unit:%d, vty:%d\n",
465 major(dev), minor(dev), unit, SC_VTY(dev)));
466
467 sc = sc_get_softc(unit, (sc_console_unit == unit) ? SC_KERNEL_CONSOLE : 0);
468 if (sc == NULL)
469 return ENXIO;
470
471 tp = dev->si_tty = ttymalloc(dev->si_tty);
472 tp->t_oproc = scstart;
473 tp->t_param = scparam;
474 tp->t_stop = nottystop;
475 tp->t_dev = dev;
476 if (!ISTTYOPEN(tp)) {
477 ttychars(tp);
478 /* Use the current setting of the <-- key as default VERASE. */
479 /* If the Delete key is preferable, an stty is necessary */
480#ifndef __sparc64__
481 if (sc->kbd != NULL) {
482 key.keynum = KEYCODE_BS;
483 kbd_ioctl(sc->kbd, GIO_KEYMAPENT, (caddr_t)&key);
484 tp->t_cc[VERASE] = key.key.map[0];
485 }
486#endif
487 tp->t_iflag = TTYDEF_IFLAG;
488 tp->t_oflag = TTYDEF_OFLAG;
489 tp->t_cflag = TTYDEF_CFLAG;
490 tp->t_lflag = TTYDEF_LFLAG;
491 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
492 scparam(tp, &tp->t_termios);
493 ttyld_modem(tp, 1);
494 }
495 else
496 if (tp->t_state & TS_XCLUDE && suser(td))
497 return(EBUSY);
498
499 error = ttyld_open(tp, dev);
500
501 scp = sc_get_stat(dev);
502 if (scp == NULL) {
503 scp = SC_STAT(dev) = alloc_scp(sc, SC_VTY(dev));
504 if (ISGRAPHSC(scp))
505 sc_set_pixel_mode(scp, NULL, COL, ROW, 16);
506 }
507 if (!tp->t_winsize.ws_col && !tp->t_winsize.ws_row) {
508 tp->t_winsize.ws_col = scp->xsize;
509 tp->t_winsize.ws_row = scp->ysize;
510 }
511
512 return error;
513}
514
515static int
516scclose(struct cdev *dev, int flag, int mode, struct thread *td)
517{
518 struct tty *tp = dev->si_tty;
519 scr_stat *scp;
520 int s;
521
522 if (SC_VTY(dev) != SC_CONSOLECTL) {
523 scp = sc_get_stat(tp->t_dev);
524 /* were we in the middle of the VT switching process? */
525 DPRINTF(5, ("sc%d: scclose(), ", scp->sc->unit));
526 s = spltty();
527 if ((scp == scp->sc->cur_scp) && (scp->sc->unit == sc_console_unit))
528 cnavailable(sc_consptr, TRUE);
529 if (finish_vt_rel(scp, TRUE, &s) == 0) /* force release */
530 DPRINTF(5, ("reset WAIT_REL, "));
531 if (finish_vt_acq(scp) == 0) /* force acknowledge */
532 DPRINTF(5, ("reset WAIT_ACQ, "));
533#if not_yet_done
534 if (scp == &main_console) {
535 scp->pid = 0;
536 scp->proc = NULL;
537 scp->smode.mode = VT_AUTO;
538 }
539 else {
540 sc_vtb_destroy(&scp->vtb);
541#ifndef __sparc64__
542 sc_vtb_destroy(&scp->scr);
543#endif
544 sc_free_history_buffer(scp, scp->ysize);
545 SC_STAT(dev) = NULL;
546 free(scp, M_DEVBUF);
547 }
548#else
549 scp->pid = 0;
550 scp->proc = NULL;
551 scp->smode.mode = VT_AUTO;
552#endif
553 scp->kbd_mode = K_XLATE;
554 if (scp == scp->sc->cur_scp)
555 kbd_ioctl(scp->sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
556 DPRINTF(5, ("done.\n"));
557 }
558 spltty();
559 ttyld_close(tp, flag);
| 31
32#include "opt_syscons.h"
33#include "opt_splash.h"
34#include "opt_ddb.h"
35
36#include <sys/param.h>
37#include <sys/systm.h>
38#include <sys/conf.h>
39#include <sys/cons.h>
40#include <sys/consio.h>
41#include <sys/kdb.h>
42#include <sys/eventhandler.h>
43#include <sys/fbio.h>
44#include <sys/kbio.h>
45#include <sys/kernel.h>
46#include <sys/lock.h>
47#include <sys/malloc.h>
48#include <sys/mutex.h>
49#include <sys/proc.h>
50#include <sys/random.h>
51#include <sys/reboot.h>
52#include <sys/signalvar.h>
53#include <sys/sysctl.h>
54#include <sys/tty.h>
55#include <sys/power.h>
56
57#include <machine/clock.h>
58#if __sparc64__ || __powerpc__
59#include <machine/sc_machdep.h>
60#else
61#include <machine/pc/display.h>
62#endif
63#ifdef __i386__
64#include <machine/psl.h>
65#include <machine/apm_bios.h>
66#include <machine/frame.h>
67#endif
68
69#include <dev/kbd/kbdreg.h>
70#include <dev/fb/fbreg.h>
71#include <dev/fb/splashreg.h>
72#include <dev/syscons/syscons.h>
73
74#define COLD 0
75#define WARM 1
76
77#define DEFAULT_BLANKTIME (5*60) /* 5 minutes */
78#define MAX_BLANKTIME (7*24*60*60) /* 7 days!? */
79
80#define KEYCODE_BS 0x0e /* "<-- Backspace" key, XXX */
81
82typedef struct default_attr {
83 int std_color; /* normal hardware color */
84 int rev_color; /* reverse hardware color */
85} default_attr;
86
87static default_attr user_default = {
88 SC_NORM_ATTR,
89 SC_NORM_REV_ATTR,
90};
91
92static default_attr kernel_default = {
93 SC_KERNEL_CONS_ATTR,
94 SC_KERNEL_CONS_REV_ATTR,
95};
96
97static int sc_console_unit = -1;
98static int sc_saver_keyb_only = 1;
99static scr_stat *sc_console;
100static struct tty *sc_console_tty;
101static struct consdev *sc_consptr;
102static void *kernel_console_ts;
103static scr_stat main_console;
104static struct cdev *main_devs[MAXCONS];
105
106static char init_done = COLD;
107static char shutdown_in_progress = FALSE;
108static char sc_malloc = FALSE;
109
110static int saver_mode = CONS_NO_SAVER; /* LKM/user saver */
111static int run_scrn_saver = FALSE; /* should run the saver? */
112static int enable_bell = TRUE; /* enable beeper */
113static long scrn_blank_time = 0; /* screen saver timeout value */
114#ifdef DEV_SPLASH
115static int scrn_blanked; /* # of blanked screen */
116static int sticky_splash = FALSE;
117
118static void none_saver(sc_softc_t *sc, int blank) { }
119static void (*current_saver)(sc_softc_t *, int) = none_saver;
120#endif
121
122SYSCTL_NODE(_hw, OID_AUTO, syscons, CTLFLAG_RD, 0, "syscons");
123SYSCTL_NODE(_hw_syscons, OID_AUTO, saver, CTLFLAG_RD, 0, "saver");
124SYSCTL_INT(_hw_syscons_saver, OID_AUTO, keybonly, CTLFLAG_RW,
125 &sc_saver_keyb_only, 0, "screen saver interrupted by input only");
126SYSCTL_INT(_hw_syscons, OID_AUTO, bell, CTLFLAG_RW, &enable_bell,
127 0, "enable bell");
128#if !defined(SC_NO_FONT_LOADING) && defined(SC_DFLT_FONT)
129#include "font.h"
130#endif
131
132 d_ioctl_t *sc_user_ioctl;
133
134static bios_values_t bios_value;
135
136static int enable_panic_key;
137SYSCTL_INT(_machdep, OID_AUTO, enable_panic_key, CTLFLAG_RW, &enable_panic_key,
138 0, "");
139
140#define SC_CONSOLECTL 255
141
142#define VIRTUAL_TTY(sc, x) (SC_DEV((sc), (x)) != NULL ? \
143 SC_DEV((sc), (x))->si_tty : NULL)
144#define ISTTYOPEN(tp) ((tp) && ((tp)->t_state & TS_ISOPEN))
145
146static int debugger;
147
148/* prototypes */
149static int scvidprobe(int unit, int flags, int cons);
150static int sckbdprobe(int unit, int flags, int cons);
151static void scmeminit(void *arg);
152static int scdevtounit(struct cdev *dev);
153static kbd_callback_func_t sckbdevent;
154static int scparam(struct tty *tp, struct termios *t);
155static void scstart(struct tty *tp);
156static void scinit(int unit, int flags);
157static scr_stat *sc_get_stat(struct cdev *devptr);
158static void scterm(int unit, int flags);
159static void scshutdown(void *arg, int howto);
160static u_int scgetc(sc_softc_t *sc, u_int flags);
161#define SCGETC_CN 1
162#define SCGETC_NONBLOCK 2
163static int sccngetch(int flags);
164static void sccnupdate(scr_stat *scp);
165static scr_stat *alloc_scp(sc_softc_t *sc, int vty);
166static void init_scp(sc_softc_t *sc, int vty, scr_stat *scp);
167static timeout_t scrn_timer;
168static int and_region(int *s1, int *e1, int s2, int e2);
169static void scrn_update(scr_stat *scp, int show_cursor);
170
171#ifdef DEV_SPLASH
172static int scsplash_callback(int event, void *arg);
173static void scsplash_saver(sc_softc_t *sc, int show);
174static int add_scrn_saver(void (*this_saver)(sc_softc_t *, int));
175static int remove_scrn_saver(void (*this_saver)(sc_softc_t *, int));
176static int set_scrn_saver_mode(scr_stat *scp, int mode, u_char *pal, int border);
177static int restore_scrn_saver_mode(scr_stat *scp, int changemode);
178static void stop_scrn_saver(sc_softc_t *sc, void (*saver)(sc_softc_t *, int));
179static int wait_scrn_saver_stop(sc_softc_t *sc);
180#define scsplash_stick(stick) (sticky_splash = (stick))
181#else /* !DEV_SPLASH */
182#define scsplash_stick(stick)
183#endif /* DEV_SPLASH */
184
185static int do_switch_scr(sc_softc_t *sc, int s);
186static int vt_proc_alive(scr_stat *scp);
187static int signal_vt_rel(scr_stat *scp);
188static int signal_vt_acq(scr_stat *scp);
189static int finish_vt_rel(scr_stat *scp, int release, int *s);
190static int finish_vt_acq(scr_stat *scp);
191static void exchange_scr(sc_softc_t *sc);
192static void update_cursor_image(scr_stat *scp);
193static void change_cursor_shape(scr_stat *scp, int flags, int base, int height);
194static int save_kbd_state(scr_stat *scp);
195static int update_kbd_state(scr_stat *scp, int state, int mask);
196static int update_kbd_leds(scr_stat *scp, int which);
197static timeout_t blink_screen;
198
199static cn_probe_t sccnprobe;
200static cn_init_t sccninit;
201static cn_getc_t sccngetc;
202static cn_checkc_t sccncheckc;
203static cn_putc_t sccnputc;
204static cn_dbctl_t sccndbctl;
205static cn_term_t sccnterm;
206
207CONS_DRIVER(sc, sccnprobe, sccninit, sccnterm, sccngetc, sccncheckc, sccnputc,
208 sccndbctl);
209
210static d_open_t scopen;
211static d_close_t scclose;
212static d_read_t scread;
213static d_ioctl_t scioctl;
214static d_mmap_t scmmap;
215
216static struct cdevsw sc_cdevsw = {
217 .d_version = D_VERSION,
218 .d_open = scopen,
219 .d_close = scclose,
220 .d_read = scread,
221 .d_ioctl = scioctl,
222 .d_mmap = scmmap,
223 .d_name = "sc",
224 .d_flags = D_TTY | D_NEEDGIANT,
225};
226
227int
228sc_probe_unit(int unit, int flags)
229{
230 if (!scvidprobe(unit, flags, FALSE)) {
231 if (bootverbose)
232 printf("sc%d: no video adapter found.\n", unit);
233 return ENXIO;
234 }
235
236 /* syscons will be attached even when there is no keyboard */
237 sckbdprobe(unit, flags, FALSE);
238
239 return 0;
240}
241
242/* probe video adapters, return TRUE if found */
243static int
244scvidprobe(int unit, int flags, int cons)
245{
246 /*
247 * Access the video adapter driver through the back door!
248 * Video adapter drivers need to be configured before syscons.
249 * However, when syscons is being probed as the low-level console,
250 * they have not been initialized yet. We force them to initialize
251 * themselves here. XXX
252 */
253 vid_configure(cons ? VIO_PROBE_ONLY : 0);
254
255 return (vid_find_adapter("*", unit) >= 0);
256}
257
258/* probe the keyboard, return TRUE if found */
259static int
260sckbdprobe(int unit, int flags, int cons)
261{
262 /* access the keyboard driver through the backdoor! */
263 kbd_configure(cons ? KB_CONF_PROBE_ONLY : 0);
264
265 return (kbd_find_keyboard("*", unit) >= 0);
266}
267
268static char
269*adapter_name(video_adapter_t *adp)
270{
271 static struct {
272 int type;
273 char *name[2];
274 } names[] = {
275 { KD_MONO, { "MDA", "MDA" } },
276 { KD_HERCULES, { "Hercules", "Hercules" } },
277 { KD_CGA, { "CGA", "CGA" } },
278 { KD_EGA, { "EGA", "EGA (mono)" } },
279 { KD_VGA, { "VGA", "VGA (mono)" } },
280 { KD_PC98, { "PC-98x1", "PC-98x1" } },
281 { KD_TGA, { "TGA", "TGA" } },
282 { -1, { "Unknown", "Unknown" } },
283 };
284 int i;
285
286 for (i = 0; names[i].type != -1; ++i)
287 if (names[i].type == adp->va_type)
288 break;
289 return names[i].name[(adp->va_flags & V_ADP_COLOR) ? 0 : 1];
290}
291
292int
293sc_attach_unit(int unit, int flags)
294{
295 sc_softc_t *sc;
296 scr_stat *scp;
297#ifdef SC_PIXEL_MODE
298 video_info_t info;
299#endif
300 int vc;
301 struct cdev *dev;
302
303 flags &= ~SC_KERNEL_CONSOLE;
304
305 if (sc_console_unit == unit) {
306 /*
307 * If this unit is being used as the system console, we need to
308 * adjust some variables and buffers before and after scinit().
309 */
310 /* assert(sc_console != NULL) */
311 flags |= SC_KERNEL_CONSOLE;
312 scmeminit(NULL);
313
314 scinit(unit, flags);
315
316 if (sc_console->tsw->te_size > 0) {
317 /* assert(sc_console->ts != NULL); */
318 kernel_console_ts = sc_console->ts;
319 sc_console->ts = malloc(sc_console->tsw->te_size,
320 M_DEVBUF, M_WAITOK);
321 bcopy(kernel_console_ts, sc_console->ts, sc_console->tsw->te_size);
322 (*sc_console->tsw->te_default_attr)(sc_console,
323 user_default.std_color,
324 user_default.rev_color);
325 }
326 } else {
327 scinit(unit, flags);
328 }
329
330 sc = sc_get_softc(unit, flags & SC_KERNEL_CONSOLE);
331 sc->config = flags;
332 scp = sc_get_stat(sc->dev[0]);
333 if (sc_console == NULL) /* sc_console_unit < 0 */
334 sc_console = scp;
335
336#ifdef SC_PIXEL_MODE
337 if ((sc->config & SC_VESA800X600)
338 && ((*vidsw[sc->adapter]->get_info)(sc->adp, M_VESA_800x600, &info) == 0)) {
339#ifdef DEV_SPLASH
340 if (sc->flags & SC_SPLASH_SCRN)
341 splash_term(sc->adp);
342#endif
343 sc_set_graphics_mode(scp, NULL, M_VESA_800x600);
344 sc_set_pixel_mode(scp, NULL, COL, ROW, 16);
345 sc->initial_mode = M_VESA_800x600;
346#ifdef DEV_SPLASH
347 /* put up the splash again! */
348 if (sc->flags & SC_SPLASH_SCRN)
349 splash_init(sc->adp, scsplash_callback, sc);
350#endif
351 }
352#endif /* SC_PIXEL_MODE */
353
354 /* initialize cursor */
355 if (!ISGRAPHSC(scp))
356 update_cursor_image(scp);
357
358 /* get screen update going */
359 scrn_timer(sc);
360
361 /* set up the keyboard */
362 kbd_ioctl(sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
363 update_kbd_state(scp, scp->status, LOCK_MASK);
364
365 printf("sc%d: %s <%d virtual consoles, flags=0x%x>\n",
366 unit, adapter_name(sc->adp), sc->vtys, sc->config);
367 if (bootverbose) {
368 printf("sc%d:", unit);
369 if (sc->adapter >= 0)
370 printf(" fb%d", sc->adapter);
371 if (sc->keyboard >= 0)
372 printf(", kbd%d", sc->keyboard);
373 if (scp->tsw)
374 printf(", terminal emulator: %s (%s)",
375 scp->tsw->te_name, scp->tsw->te_desc);
376 printf("\n");
377 }
378
379 /* register a shutdown callback for the kernel console */
380 if (sc_console_unit == unit)
381 EVENTHANDLER_REGISTER(shutdown_pre_sync, scshutdown,
382 (void *)(uintptr_t)unit, SHUTDOWN_PRI_DEFAULT);
383
384 for (vc = 0; vc < sc->vtys; vc++) {
385 if (sc->dev[vc] == NULL) {
386 dev = make_dev(&sc_cdevsw, vc + unit * MAXCONS,
387 UID_ROOT, GID_WHEEL, 0600, "ttyv%r", vc + unit * MAXCONS);
388 sc->dev[vc] = dev;
389 sc->dev[vc]->si_tty = ttymalloc(sc->dev[vc]->si_tty);
390 if (vc == 0 && sc->dev == main_devs)
391 SC_STAT(sc->dev[0]) = &main_console;
392 }
393 /*
394 * The first vty already has struct tty and scr_stat initialized
395 * in scinit(). The other vtys will have these structs when
396 * first opened.
397 */
398 }
399
400 dev = make_dev(&sc_cdevsw, SC_CONSOLECTL,
401 UID_ROOT, GID_WHEEL, 0600, "consolectl");
402 dev->si_tty = sc_console_tty = ttymalloc(sc_console_tty);
403 SC_STAT(dev) = sc_console;
404
405 return 0;
406}
407
408static void
409scmeminit(void *arg)
410{
411 if (sc_malloc)
412 return;
413 sc_malloc = TRUE;
414
415 /*
416 * As soon as malloc() becomes functional, we had better allocate
417 * various buffers for the kernel console.
418 */
419
420 if (sc_console_unit < 0) /* sc_console == NULL */
421 return;
422
423 /* copy the temporary buffer to the final buffer */
424 sc_alloc_scr_buffer(sc_console, FALSE, FALSE);
425
426#ifndef SC_NO_CUTPASTE
427 sc_alloc_cut_buffer(sc_console, FALSE);
428#endif
429
430#ifndef SC_NO_HISTORY
431 /* initialize history buffer & pointers */
432 sc_alloc_history_buffer(sc_console, 0, 0, FALSE);
433#endif
434}
435
436/* XXX */
437SYSINIT(sc_mem, SI_SUB_KMEM, SI_ORDER_ANY, scmeminit, NULL);
438
439static int
440scdevtounit(struct cdev *dev)
441{
442 int vty = SC_VTY(dev);
443
444 if (vty == SC_CONSOLECTL)
445 return ((sc_console != NULL) ? sc_console->sc->unit : -1);
446 else if ((vty < 0) || (vty >= MAXCONS*sc_max_unit()))
447 return -1;
448 else
449 return vty/MAXCONS;
450}
451
452static int
453scopen(struct cdev *dev, int flag, int mode, struct thread *td)
454{
455 int unit = scdevtounit(dev);
456 sc_softc_t *sc;
457 struct tty *tp;
458 scr_stat *scp;
459#ifndef __sparc64__
460 keyarg_t key;
461#endif
462 int error;
463
464 DPRINTF(5, ("scopen: dev:%d,%d, unit:%d, vty:%d\n",
465 major(dev), minor(dev), unit, SC_VTY(dev)));
466
467 sc = sc_get_softc(unit, (sc_console_unit == unit) ? SC_KERNEL_CONSOLE : 0);
468 if (sc == NULL)
469 return ENXIO;
470
471 tp = dev->si_tty = ttymalloc(dev->si_tty);
472 tp->t_oproc = scstart;
473 tp->t_param = scparam;
474 tp->t_stop = nottystop;
475 tp->t_dev = dev;
476 if (!ISTTYOPEN(tp)) {
477 ttychars(tp);
478 /* Use the current setting of the <-- key as default VERASE. */
479 /* If the Delete key is preferable, an stty is necessary */
480#ifndef __sparc64__
481 if (sc->kbd != NULL) {
482 key.keynum = KEYCODE_BS;
483 kbd_ioctl(sc->kbd, GIO_KEYMAPENT, (caddr_t)&key);
484 tp->t_cc[VERASE] = key.key.map[0];
485 }
486#endif
487 tp->t_iflag = TTYDEF_IFLAG;
488 tp->t_oflag = TTYDEF_OFLAG;
489 tp->t_cflag = TTYDEF_CFLAG;
490 tp->t_lflag = TTYDEF_LFLAG;
491 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
492 scparam(tp, &tp->t_termios);
493 ttyld_modem(tp, 1);
494 }
495 else
496 if (tp->t_state & TS_XCLUDE && suser(td))
497 return(EBUSY);
498
499 error = ttyld_open(tp, dev);
500
501 scp = sc_get_stat(dev);
502 if (scp == NULL) {
503 scp = SC_STAT(dev) = alloc_scp(sc, SC_VTY(dev));
504 if (ISGRAPHSC(scp))
505 sc_set_pixel_mode(scp, NULL, COL, ROW, 16);
506 }
507 if (!tp->t_winsize.ws_col && !tp->t_winsize.ws_row) {
508 tp->t_winsize.ws_col = scp->xsize;
509 tp->t_winsize.ws_row = scp->ysize;
510 }
511
512 return error;
513}
514
515static int
516scclose(struct cdev *dev, int flag, int mode, struct thread *td)
517{
518 struct tty *tp = dev->si_tty;
519 scr_stat *scp;
520 int s;
521
522 if (SC_VTY(dev) != SC_CONSOLECTL) {
523 scp = sc_get_stat(tp->t_dev);
524 /* were we in the middle of the VT switching process? */
525 DPRINTF(5, ("sc%d: scclose(), ", scp->sc->unit));
526 s = spltty();
527 if ((scp == scp->sc->cur_scp) && (scp->sc->unit == sc_console_unit))
528 cnavailable(sc_consptr, TRUE);
529 if (finish_vt_rel(scp, TRUE, &s) == 0) /* force release */
530 DPRINTF(5, ("reset WAIT_REL, "));
531 if (finish_vt_acq(scp) == 0) /* force acknowledge */
532 DPRINTF(5, ("reset WAIT_ACQ, "));
533#if not_yet_done
534 if (scp == &main_console) {
535 scp->pid = 0;
536 scp->proc = NULL;
537 scp->smode.mode = VT_AUTO;
538 }
539 else {
540 sc_vtb_destroy(&scp->vtb);
541#ifndef __sparc64__
542 sc_vtb_destroy(&scp->scr);
543#endif
544 sc_free_history_buffer(scp, scp->ysize);
545 SC_STAT(dev) = NULL;
546 free(scp, M_DEVBUF);
547 }
548#else
549 scp->pid = 0;
550 scp->proc = NULL;
551 scp->smode.mode = VT_AUTO;
552#endif
553 scp->kbd_mode = K_XLATE;
554 if (scp == scp->sc->cur_scp)
555 kbd_ioctl(scp->sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
556 DPRINTF(5, ("done.\n"));
557 }
558 spltty();
559 ttyld_close(tp, flag);
|
561 spl0();
562 return(0);
563}
564
565static int
566scread(struct cdev *dev, struct uio *uio, int flag)
567{
568 if (!sc_saver_keyb_only)
569 sc_touch_scrn_saver();
570 return ttyread(dev, uio, flag);
571}
572
573static int
574sckbdevent(keyboard_t *thiskbd, int event, void *arg)
575{
576 sc_softc_t *sc;
577 struct tty *cur_tty;
578 int c;
579 size_t len;
580 u_char *cp;
581
582 sc = (sc_softc_t *)arg;
583 /* assert(thiskbd == sc->kbd) */
584
585 switch (event) {
586 case KBDIO_KEYINPUT:
587 break;
588 case KBDIO_UNLOADING:
589 sc->kbd = NULL;
590 sc->keyboard = -1;
591 kbd_release(thiskbd, (void *)&sc->keyboard);
592 return 0;
593 default:
594 return EINVAL;
595 }
596
597 /*
598 * Loop while there is still input to get from the keyboard.
599 * I don't think this is nessesary, and it doesn't fix
600 * the Xaccel-2.1 keyboard hang, but it can't hurt. XXX
601 */
602 while ((c = scgetc(sc, SCGETC_NONBLOCK)) != NOKEY) {
603
604 cur_tty = VIRTUAL_TTY(sc, sc->cur_scp->index);
605 if (!ISTTYOPEN(cur_tty)) {
606 cur_tty = sc_console_tty;
607 if (!ISTTYOPEN(cur_tty))
608 continue;
609 }
610
611 if ((*sc->cur_scp->tsw->te_input)(sc->cur_scp, c, cur_tty))
612 continue;
613
614 switch (KEYFLAGS(c)) {
615 case 0x0000: /* normal key */
616 ttyld_rint(cur_tty, KEYCHAR(c));
617 break;
618 case FKEY: /* function key, return string */
619 cp = kbd_get_fkeystr(thiskbd, KEYCHAR(c), &len);
620 if (cp != NULL) {
621 while (len-- > 0)
622 ttyld_rint(cur_tty, *cp++);
623 }
624 break;
625 case MKEY: /* meta is active, prepend ESC */
626 ttyld_rint(cur_tty, 0x1b);
627 ttyld_rint(cur_tty, KEYCHAR(c));
628 break;
629 case BKEY: /* backtab fixed sequence (esc [ Z) */
630 ttyld_rint(cur_tty, 0x1b);
631 ttyld_rint(cur_tty, '[');
632 ttyld_rint(cur_tty, 'Z');
633 break;
634 }
635 }
636
637 sc->cur_scp->status |= MOUSE_HIDDEN;
638
639 return 0;
640}
641
642static int
643scparam(struct tty *tp, struct termios *t)
644{
645 tp->t_ispeed = t->c_ispeed;
646 tp->t_ospeed = t->c_ospeed;
647 tp->t_cflag = t->c_cflag;
648 return 0;
649}
650
651static int
652scioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td)
653{
654 int error;
655 int i;
656 struct tty *tp;
657 sc_softc_t *sc;
658 scr_stat *scp;
659 int s;
660
661 tp = dev->si_tty;
662
663 /* If there is a user_ioctl function call that first */
664 if (sc_user_ioctl) {
665 error = (*sc_user_ioctl)(dev, cmd, data, flag, td);
666 if (error != ENOIOCTL)
667 return error;
668 }
669
670 error = sc_vid_ioctl(tp, cmd, data, flag, td);
671 if (error != ENOIOCTL)
672 return error;
673
674#ifndef SC_NO_HISTORY
675 error = sc_hist_ioctl(tp, cmd, data, flag, td);
676 if (error != ENOIOCTL)
677 return error;
678#endif
679
680#ifndef SC_NO_SYSMOUSE
681 error = sc_mouse_ioctl(tp, cmd, data, flag, td);
682 if (error != ENOIOCTL)
683 return error;
684#endif
685
686 scp = sc_get_stat(tp->t_dev);
687 /* assert(scp != NULL) */
688 /* scp is sc_console, if SC_VTY(dev) == SC_CONSOLECTL. */
689 sc = scp->sc;
690
691 if (scp->tsw) {
692 error = (*scp->tsw->te_ioctl)(scp, tp, cmd, data, flag, td);
693 if (error != ENOIOCTL)
694 return error;
695 }
696
697 switch (cmd) { /* process console hardware related ioctl's */
698
699 case GIO_ATTR: /* get current attributes */
700 /* this ioctl is not processed here, but in the terminal emulator */
701 return ENOTTY;
702
703 case GIO_COLOR: /* is this a color console ? */
704 *(int *)data = (sc->adp->va_flags & V_ADP_COLOR) ? 1 : 0;
705 return 0;
706
707 case CONS_BLANKTIME: /* set screen saver timeout (0 = no saver) */
708 if (*(int *)data < 0 || *(int *)data > MAX_BLANKTIME)
709 return EINVAL;
710 s = spltty();
711 scrn_blank_time = *(int *)data;
712 run_scrn_saver = (scrn_blank_time != 0);
713 splx(s);
714 return 0;
715
716 case CONS_CURSORTYPE: /* set cursor type (obsolete) */
717 s = spltty();
718 *(int *)data &= CONS_CURSOR_ATTRS;
719 sc_change_cursor_shape(scp, *(int *)data, -1, -1);
720 splx(s);
721 return 0;
722
723 case CONS_GETCURSORSHAPE: /* get cursor shape (new interface) */
724 if (((int *)data)[0] & CONS_LOCAL_CURSOR) {
725 ((int *)data)[0] = scp->curr_curs_attr.flags;
726 ((int *)data)[1] = scp->curr_curs_attr.base;
727 ((int *)data)[2] = scp->curr_curs_attr.height;
728 } else {
729 ((int *)data)[0] = sc->curs_attr.flags;
730 ((int *)data)[1] = sc->curs_attr.base;
731 ((int *)data)[2] = sc->curs_attr.height;
732 }
733 return 0;
734
735 case CONS_SETCURSORSHAPE: /* set cursor shape (new interface) */
736 s = spltty();
737 sc_change_cursor_shape(scp, ((int *)data)[0],
738 ((int *)data)[1], ((int *)data)[2]);
739 splx(s);
740 return 0;
741
742 case CONS_BELLTYPE: /* set bell type sound/visual */
743 if ((*(int *)data) & 0x01)
744 sc->flags |= SC_VISUAL_BELL;
745 else
746 sc->flags &= ~SC_VISUAL_BELL;
747 if ((*(int *)data) & 0x02)
748 sc->flags |= SC_QUIET_BELL;
749 else
750 sc->flags &= ~SC_QUIET_BELL;
751 return 0;
752
753 case CONS_GETINFO: /* get current (virtual) console info */
754 {
755 vid_info_t *ptr = (vid_info_t*)data;
756 if (ptr->size == sizeof(struct vid_info)) {
757 ptr->m_num = sc->cur_scp->index;
758 ptr->font_size = scp->font_size;
759 ptr->mv_col = scp->xpos;
760 ptr->mv_row = scp->ypos;
761 ptr->mv_csz = scp->xsize;
762 ptr->mv_rsz = scp->ysize;
763 ptr->mv_hsz = (scp->history != NULL) ? scp->history->vtb_rows : 0;
764 /*
765 * The following fields are filled by the terminal emulator. XXX
766 *
767 * ptr->mv_norm.fore
768 * ptr->mv_norm.back
769 * ptr->mv_rev.fore
770 * ptr->mv_rev.back
771 */
772 ptr->mv_grfc.fore = 0; /* not supported */
773 ptr->mv_grfc.back = 0; /* not supported */
774 ptr->mv_ovscan = scp->border;
775 if (scp == sc->cur_scp)
776 save_kbd_state(scp);
777 ptr->mk_keylock = scp->status & LOCK_MASK;
778 return 0;
779 }
780 return EINVAL;
781 }
782
783 case CONS_GETVERS: /* get version number */
784 *(int*)data = 0x200; /* version 2.0 */
785 return 0;
786
787 case CONS_IDLE: /* see if the screen has been idle */
788 /*
789 * When the screen is in the GRAPHICS_MODE or UNKNOWN_MODE,
790 * the user process may have been writing something on the
791 * screen and syscons is not aware of it. Declare the screen
792 * is NOT idle if it is in one of these modes. But there is
793 * an exception to it; if a screen saver is running in the
794 * graphics mode in the current screen, we should say that the
795 * screen has been idle.
796 */
797 *(int *)data = (sc->flags & SC_SCRN_IDLE)
798 && (!ISGRAPHSC(sc->cur_scp)
799 || (sc->cur_scp->status & SAVER_RUNNING));
800 return 0;
801
802 case CONS_SAVERMODE: /* set saver mode */
803 switch(*(int *)data) {
804 case CONS_NO_SAVER:
805 case CONS_USR_SAVER:
806 /* if a LKM screen saver is running, stop it first. */
807 scsplash_stick(FALSE);
808 saver_mode = *(int *)data;
809 s = spltty();
810#ifdef DEV_SPLASH
811 if ((error = wait_scrn_saver_stop(NULL))) {
812 splx(s);
813 return error;
814 }
815#endif
816 run_scrn_saver = TRUE;
817 if (saver_mode == CONS_USR_SAVER)
818 scp->status |= SAVER_RUNNING;
819 else
820 scp->status &= ~SAVER_RUNNING;
821 scsplash_stick(TRUE);
822 splx(s);
823 break;
824 case CONS_LKM_SAVER:
825 s = spltty();
826 if ((saver_mode == CONS_USR_SAVER) && (scp->status & SAVER_RUNNING))
827 scp->status &= ~SAVER_RUNNING;
828 saver_mode = *(int *)data;
829 splx(s);
830 break;
831 default:
832 return EINVAL;
833 }
834 return 0;
835
836 case CONS_SAVERSTART: /* immediately start/stop the screen saver */
837 /*
838 * Note that this ioctl does not guarantee the screen saver
839 * actually starts or stops. It merely attempts to do so...
840 */
841 s = spltty();
842 run_scrn_saver = (*(int *)data != 0);
843 if (run_scrn_saver)
844 sc->scrn_time_stamp -= scrn_blank_time;
845 splx(s);
846 return 0;
847
848 case CONS_SCRSHOT: /* get a screen shot */
849 {
850 int retval, hist_rsz;
851 size_t lsize, csize;
852 vm_offset_t frbp, hstp;
853 unsigned lnum;
854 scrshot_t *ptr = (scrshot_t *)data;
855 void *outp = ptr->buf;
856
857 s = spltty();
858 if (ISGRAPHSC(scp)) {
859 splx(s);
860 return EOPNOTSUPP;
861 }
862 hist_rsz = (scp->history != NULL) ? scp->history->vtb_rows : 0;
863 if ((ptr->x + ptr->xsize) > scp->xsize ||
864 (ptr->y + ptr->ysize) > (scp->ysize + hist_rsz)) {
865 splx(s);
866 return EINVAL;
867 }
868
869 lsize = scp->xsize * sizeof(u_int16_t);
870 csize = ptr->xsize * sizeof(u_int16_t);
871 /* Pointer to the last line of framebuffer */
872 frbp = scp->vtb.vtb_buffer + scp->ysize * lsize + ptr->x *
873 sizeof(u_int16_t);
874 /* Pointer to the last line of target buffer */
875 (vm_offset_t)outp += ptr->ysize * csize;
876 /* Pointer to the last line of history buffer */
877 if (scp->history != NULL)
878 hstp = scp->history->vtb_buffer + sc_vtb_tail(scp->history) *
879 sizeof(u_int16_t) + ptr->x * sizeof(u_int16_t);
880 else
881 hstp = 0;
882
883 retval = 0;
884 for (lnum = 0; lnum < (ptr->y + ptr->ysize); lnum++) {
885 if (lnum < scp->ysize) {
886 frbp -= lsize;
887 } else {
888 hstp -= lsize;
889 if (hstp < scp->history->vtb_buffer)
890 hstp += scp->history->vtb_rows * lsize;
891 frbp = hstp;
892 }
893 if (lnum < ptr->y)
894 continue;
895 (vm_offset_t)outp -= csize;
896 retval = copyout((void *)frbp, outp, csize);
897 if (retval != 0)
898 break;
899 }
900 splx(s);
901 return retval;
902 }
903
904 case VT_SETMODE: /* set screen switcher mode */
905 {
906 struct vt_mode *mode;
907 struct proc *p1;
908
909 mode = (struct vt_mode *)data;
910 DPRINTF(5, ("sc%d: VT_SETMODE ", sc->unit));
911 if (scp->smode.mode == VT_PROCESS) {
912 p1 = pfind(scp->pid);
913 if (scp->proc == p1 && scp->proc != td->td_proc) {
914 if (p1)
915 PROC_UNLOCK(p1);
916 DPRINTF(5, ("error EPERM\n"));
917 return EPERM;
918 }
919 if (p1)
920 PROC_UNLOCK(p1);
921 }
922 s = spltty();
923 if (mode->mode == VT_AUTO) {
924 scp->smode.mode = VT_AUTO;
925 scp->proc = NULL;
926 scp->pid = 0;
927 DPRINTF(5, ("VT_AUTO, "));
928 if ((scp == sc->cur_scp) && (sc->unit == sc_console_unit))
929 cnavailable(sc_consptr, TRUE);
930 /* were we in the middle of the vty switching process? */
931 if (finish_vt_rel(scp, TRUE, &s) == 0)
932 DPRINTF(5, ("reset WAIT_REL, "));
933 if (finish_vt_acq(scp) == 0)
934 DPRINTF(5, ("reset WAIT_ACQ, "));
935 } else {
936 if (!ISSIGVALID(mode->relsig) || !ISSIGVALID(mode->acqsig)
937 || !ISSIGVALID(mode->frsig)) {
938 splx(s);
939 DPRINTF(5, ("error EINVAL\n"));
940 return EINVAL;
941 }
942 DPRINTF(5, ("VT_PROCESS %d, ", td->td_proc->p_pid));
943 bcopy(data, &scp->smode, sizeof(struct vt_mode));
944 scp->proc = td->td_proc;
945 scp->pid = scp->proc->p_pid;
946 if ((scp == sc->cur_scp) && (sc->unit == sc_console_unit))
947 cnavailable(sc_consptr, FALSE);
948 }
949 splx(s);
950 DPRINTF(5, ("\n"));
951 return 0;
952 }
953
954 case VT_GETMODE: /* get screen switcher mode */
955 bcopy(&scp->smode, data, sizeof(struct vt_mode));
956 return 0;
957
958 case VT_RELDISP: /* screen switcher ioctl */
959 s = spltty();
960 /*
961 * This must be the current vty which is in the VT_PROCESS
962 * switching mode...
963 */
964 if ((scp != sc->cur_scp) || (scp->smode.mode != VT_PROCESS)) {
965 splx(s);
966 return EINVAL;
967 }
968 /* ...and this process is controlling it. */
969 if (scp->proc != td->td_proc) {
970 splx(s);
971 return EPERM;
972 }
973 error = EINVAL;
974 switch(*(intptr_t *)data) {
975 case VT_FALSE: /* user refuses to release screen, abort */
976 if ((error = finish_vt_rel(scp, FALSE, &s)) == 0)
977 DPRINTF(5, ("sc%d: VT_FALSE\n", sc->unit));
978 break;
979 case VT_TRUE: /* user has released screen, go on */
980 if ((error = finish_vt_rel(scp, TRUE, &s)) == 0)
981 DPRINTF(5, ("sc%d: VT_TRUE\n", sc->unit));
982 break;
983 case VT_ACKACQ: /* acquire acknowledged, switch completed */
984 if ((error = finish_vt_acq(scp)) == 0)
985 DPRINTF(5, ("sc%d: VT_ACKACQ\n", sc->unit));
986 break;
987 default:
988 break;
989 }
990 splx(s);
991 return error;
992
993 case VT_OPENQRY: /* return free virtual console */
994 for (i = sc->first_vty; i < sc->first_vty + sc->vtys; i++) {
995 tp = VIRTUAL_TTY(sc, i);
996 if (!ISTTYOPEN(tp)) {
997 *(int *)data = i + 1;
998 return 0;
999 }
1000 }
1001 return EINVAL;
1002
1003 case VT_ACTIVATE: /* switch to screen *data */
1004 i = (*(intptr_t *)data == 0) ? scp->index : (*(intptr_t *)data - 1);
1005 s = spltty();
1006 sc_clean_up(sc->cur_scp);
1007 splx(s);
1008 return sc_switch_scr(sc, i);
1009
1010 case VT_WAITACTIVE: /* wait for switch to occur */
1011 i = (*(intptr_t *)data == 0) ? scp->index : (*(intptr_t *)data - 1);
1012 if ((i < sc->first_vty) || (i >= sc->first_vty + sc->vtys))
1013 return EINVAL;
1014 s = spltty();
1015 error = sc_clean_up(sc->cur_scp);
1016 splx(s);
1017 if (error)
1018 return error;
1019 scp = sc_get_stat(SC_DEV(sc, i));
1020 if (scp == scp->sc->cur_scp)
1021 return 0;
1022 while ((error=tsleep(&scp->smode, PZERO|PCATCH,
1023 "waitvt", 0)) == ERESTART) ;
1024 return error;
1025
1026 case VT_GETACTIVE: /* get active vty # */
1027 *(int *)data = sc->cur_scp->index + 1;
1028 return 0;
1029
1030 case VT_GETINDEX: /* get this vty # */
1031 *(int *)data = scp->index + 1;
1032 return 0;
1033
1034 case VT_LOCKSWITCH: /* prevent vty switching */
1035 if ((*(int *)data) & 0x01)
1036 sc->flags |= SC_SCRN_VTYLOCK;
1037 else
1038 sc->flags &= ~SC_SCRN_VTYLOCK;
1039 return 0;
1040
1041 case KDENABIO: /* allow io operations */
1042 error = suser(td);
1043 if (error != 0)
1044 return error;
1045 error = securelevel_gt(td->td_ucred, 0);
1046 if (error != 0)
1047 return error;
1048#ifdef __i386__
1049 td->td_frame->tf_eflags |= PSL_IOPL;
1050#endif
1051 return 0;
1052
1053 case KDDISABIO: /* disallow io operations (default) */
1054#ifdef __i386__
1055 td->td_frame->tf_eflags &= ~PSL_IOPL;
1056#endif
1057 return 0;
1058
1059 case KDSKBSTATE: /* set keyboard state (locks) */
1060 if (*(int *)data & ~LOCK_MASK)
1061 return EINVAL;
1062 scp->status &= ~LOCK_MASK;
1063 scp->status |= *(int *)data;
1064 if (scp == sc->cur_scp)
1065 update_kbd_state(scp, scp->status, LOCK_MASK);
1066 return 0;
1067
1068 case KDGKBSTATE: /* get keyboard state (locks) */
1069 if (scp == sc->cur_scp)
1070 save_kbd_state(scp);
1071 *(int *)data = scp->status & LOCK_MASK;
1072 return 0;
1073
1074 case KDGETREPEAT: /* get keyboard repeat & delay rates */
1075 case KDSETREPEAT: /* set keyboard repeat & delay rates (new) */
1076 error = kbd_ioctl(sc->kbd, cmd, data);
1077 if (error == ENOIOCTL)
1078 error = ENODEV;
1079 return error;
1080
1081 case KDSETRAD: /* set keyboard repeat & delay rates (old) */
1082 if (*(int *)data & ~0x7f)
1083 return EINVAL;
1084 error = kbd_ioctl(sc->kbd, cmd, data);
1085 if (error == ENOIOCTL)
1086 error = ENODEV;
1087 return error;
1088
1089 case KDSKBMODE: /* set keyboard mode */
1090 switch (*(int *)data) {
1091 case K_XLATE: /* switch to XLT ascii mode */
1092 case K_RAW: /* switch to RAW scancode mode */
1093 case K_CODE: /* switch to CODE mode */
1094 scp->kbd_mode = *(int *)data;
1095 if (scp == sc->cur_scp)
1096 kbd_ioctl(sc->kbd, cmd, data);
1097 return 0;
1098 default:
1099 return EINVAL;
1100 }
1101 /* NOT REACHED */
1102
1103 case KDGKBMODE: /* get keyboard mode */
1104 *(int *)data = scp->kbd_mode;
1105 return 0;
1106
1107 case KDGKBINFO:
1108 error = kbd_ioctl(sc->kbd, cmd, data);
1109 if (error == ENOIOCTL)
1110 error = ENODEV;
1111 return error;
1112
1113 case KDMKTONE: /* sound the bell */
1114 if (*(int*)data)
1115 sc_bell(scp, (*(int*)data)&0xffff,
1116 (((*(int*)data)>>16)&0xffff)*hz/1000);
1117 else
1118 sc_bell(scp, scp->bell_pitch, scp->bell_duration);
1119 return 0;
1120
1121 case KIOCSOUND: /* make tone (*data) hz */
1122 if (scp == sc->cur_scp) {
1123 if (*(int *)data)
1124 return sc_tone(*(int *)data);
1125 else
1126 return sc_tone(0);
1127 }
1128 return 0;
1129
1130 case KDGKBTYPE: /* get keyboard type */
1131 error = kbd_ioctl(sc->kbd, cmd, data);
1132 if (error == ENOIOCTL) {
1133 /* always return something? XXX */
1134 *(int *)data = 0;
1135 }
1136 return 0;
1137
1138 case KDSETLED: /* set keyboard LED status */
1139 if (*(int *)data & ~LED_MASK) /* FIXME: LOCK_MASK? */
1140 return EINVAL;
1141 scp->status &= ~LED_MASK;
1142 scp->status |= *(int *)data;
1143 if (scp == sc->cur_scp)
1144 update_kbd_leds(scp, scp->status);
1145 return 0;
1146
1147 case KDGETLED: /* get keyboard LED status */
1148 if (scp == sc->cur_scp)
1149 save_kbd_state(scp);
1150 *(int *)data = scp->status & LED_MASK;
1151 return 0;
1152
1153 case CONS_SETKBD: /* set the new keyboard */
1154 {
1155 keyboard_t *newkbd;
1156
1157 s = spltty();
1158 newkbd = kbd_get_keyboard(*(int *)data);
1159 if (newkbd == NULL) {
1160 splx(s);
1161 return EINVAL;
1162 }
1163 error = 0;
1164 if (sc->kbd != newkbd) {
1165 i = kbd_allocate(newkbd->kb_name, newkbd->kb_unit,
1166 (void *)&sc->keyboard, sckbdevent, sc);
1167 /* i == newkbd->kb_index */
1168 if (i >= 0) {
1169 if (sc->kbd != NULL) {
1170 save_kbd_state(sc->cur_scp);
1171 kbd_release(sc->kbd, (void *)&sc->keyboard);
1172 }
1173 sc->kbd = kbd_get_keyboard(i); /* sc->kbd == newkbd */
1174 sc->keyboard = i;
1175 kbd_ioctl(sc->kbd, KDSKBMODE,
1176 (caddr_t)&sc->cur_scp->kbd_mode);
1177 update_kbd_state(sc->cur_scp, sc->cur_scp->status,
1178 LOCK_MASK);
1179 } else {
1180 error = EPERM; /* XXX */
1181 }
1182 }
1183 splx(s);
1184 return error;
1185 }
1186
1187 case CONS_RELKBD: /* release the current keyboard */
1188 s = spltty();
1189 error = 0;
1190 if (sc->kbd != NULL) {
1191 save_kbd_state(sc->cur_scp);
1192 error = kbd_release(sc->kbd, (void *)&sc->keyboard);
1193 if (error == 0) {
1194 sc->kbd = NULL;
1195 sc->keyboard = -1;
1196 }
1197 }
1198 splx(s);
1199 return error;
1200
1201 case CONS_GETTERM: /* get the current terminal emulator info */
1202 {
1203 sc_term_sw_t *sw;
1204
1205 if (((term_info_t *)data)->ti_index == 0) {
1206 sw = scp->tsw;
1207 } else {
1208 sw = sc_term_match_by_number(((term_info_t *)data)->ti_index);
1209 }
1210 if (sw != NULL) {
1211 strncpy(((term_info_t *)data)->ti_name, sw->te_name,
1212 sizeof(((term_info_t *)data)->ti_name));
1213 strncpy(((term_info_t *)data)->ti_desc, sw->te_desc,
1214 sizeof(((term_info_t *)data)->ti_desc));
1215 ((term_info_t *)data)->ti_flags = 0;
1216 return 0;
1217 } else {
1218 ((term_info_t *)data)->ti_name[0] = '\0';
1219 ((term_info_t *)data)->ti_desc[0] = '\0';
1220 ((term_info_t *)data)->ti_flags = 0;
1221 return EINVAL;
1222 }
1223 }
1224
1225 case CONS_SETTERM: /* set the current terminal emulator */
1226 s = spltty();
1227 error = sc_init_emulator(scp, ((term_info_t *)data)->ti_name);
1228 /* FIXME: what if scp == sc_console! XXX */
1229 splx(s);
1230 return error;
1231
1232 case GIO_SCRNMAP: /* get output translation table */
1233 bcopy(&sc->scr_map, data, sizeof(sc->scr_map));
1234 return 0;
1235
1236 case PIO_SCRNMAP: /* set output translation table */
1237 bcopy(data, &sc->scr_map, sizeof(sc->scr_map));
1238 for (i=0; i<sizeof(sc->scr_map); i++) {
1239 sc->scr_rmap[sc->scr_map[i]] = i;
1240 }
1241 return 0;
1242
1243 case GIO_KEYMAP: /* get keyboard translation table */
1244 case PIO_KEYMAP: /* set keyboard translation table */
1245 case GIO_DEADKEYMAP: /* get accent key translation table */
1246 case PIO_DEADKEYMAP: /* set accent key translation table */
1247 case GETFKEY: /* get function key string */
1248 case SETFKEY: /* set function key string */
1249 error = kbd_ioctl(sc->kbd, cmd, data);
1250 if (error == ENOIOCTL)
1251 error = ENODEV;
1252 return error;
1253
1254#ifndef SC_NO_FONT_LOADING
1255
1256 case PIO_FONT8x8: /* set 8x8 dot font */
1257 if (!ISFONTAVAIL(sc->adp->va_flags))
1258 return ENXIO;
1259 bcopy(data, sc->font_8, 8*256);
1260 sc->fonts_loaded |= FONT_8;
1261 /*
1262 * FONT KLUDGE
1263 * Always use the font page #0. XXX
1264 * Don't load if the current font size is not 8x8.
1265 */
1266 if (ISTEXTSC(sc->cur_scp) && (sc->cur_scp->font_size < 14))
1267 sc_load_font(sc->cur_scp, 0, 8, sc->font_8, 0, 256);
1268 return 0;
1269
1270 case GIO_FONT8x8: /* get 8x8 dot font */
1271 if (!ISFONTAVAIL(sc->adp->va_flags))
1272 return ENXIO;
1273 if (sc->fonts_loaded & FONT_8) {
1274 bcopy(sc->font_8, data, 8*256);
1275 return 0;
1276 }
1277 else
1278 return ENXIO;
1279
1280 case PIO_FONT8x14: /* set 8x14 dot font */
1281 if (!ISFONTAVAIL(sc->adp->va_flags))
1282 return ENXIO;
1283 bcopy(data, sc->font_14, 14*256);
1284 sc->fonts_loaded |= FONT_14;
1285 /*
1286 * FONT KLUDGE
1287 * Always use the font page #0. XXX
1288 * Don't load if the current font size is not 8x14.
1289 */
1290 if (ISTEXTSC(sc->cur_scp)
1291 && (sc->cur_scp->font_size >= 14)
1292 && (sc->cur_scp->font_size < 16))
1293 sc_load_font(sc->cur_scp, 0, 14, sc->font_14, 0, 256);
1294 return 0;
1295
1296 case GIO_FONT8x14: /* get 8x14 dot font */
1297 if (!ISFONTAVAIL(sc->adp->va_flags))
1298 return ENXIO;
1299 if (sc->fonts_loaded & FONT_14) {
1300 bcopy(sc->font_14, data, 14*256);
1301 return 0;
1302 }
1303 else
1304 return ENXIO;
1305
1306 case PIO_FONT8x16: /* set 8x16 dot font */
1307 if (!ISFONTAVAIL(sc->adp->va_flags))
1308 return ENXIO;
1309 bcopy(data, sc->font_16, 16*256);
1310 sc->fonts_loaded |= FONT_16;
1311 /*
1312 * FONT KLUDGE
1313 * Always use the font page #0. XXX
1314 * Don't load if the current font size is not 8x16.
1315 */
1316 if (ISTEXTSC(sc->cur_scp) && (sc->cur_scp->font_size >= 16))
1317 sc_load_font(sc->cur_scp, 0, 16, sc->font_16, 0, 256);
1318 return 0;
1319
1320 case GIO_FONT8x16: /* get 8x16 dot font */
1321 if (!ISFONTAVAIL(sc->adp->va_flags))
1322 return ENXIO;
1323 if (sc->fonts_loaded & FONT_16) {
1324 bcopy(sc->font_16, data, 16*256);
1325 return 0;
1326 }
1327 else
1328 return ENXIO;
1329
1330#endif /* SC_NO_FONT_LOADING */
1331
1332#ifdef PC98
1333 case ADJUST_CLOCK: /* /dev/rtc for 98note resume */
1334 inittodr(0);
1335 return 0;
1336#endif
1337
1338 default:
1339 break;
1340 }
1341
1342 return (ttyioctl(dev, cmd, data, flag, td));
1343}
1344
1345static void
1346scstart(struct tty *tp)
1347{
1348 struct clist *rbp;
1349 int s, len;
1350 u_char buf[PCBURST];
1351 scr_stat *scp = sc_get_stat(tp->t_dev);
1352
1353 if (scp->status & SLKED ||
1354 (scp == scp->sc->cur_scp && scp->sc->blink_in_progress))
1355 return;
1356 s = spltty();
1357 if (!(tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP))) {
1358 tp->t_state |= TS_BUSY;
1359 rbp = &tp->t_outq;
1360 while (rbp->c_cc) {
1361 len = q_to_b(rbp, buf, PCBURST);
1362 splx(s);
1363 sc_puts(scp, buf, len);
1364 s = spltty();
1365 }
1366 tp->t_state &= ~TS_BUSY;
1367 ttwwakeup(tp);
1368 }
1369 splx(s);
1370}
1371
1372static void
1373sccnprobe(struct consdev *cp)
1374{
1375 int unit;
1376 int flags;
1377
1378 cp->cn_pri = sc_get_cons_priority(&unit, &flags);
1379
1380 /* a video card is always required */
1381 if (!scvidprobe(unit, flags, TRUE))
1382 cp->cn_pri = CN_DEAD;
1383
1384 /* syscons will become console even when there is no keyboard */
1385 sckbdprobe(unit, flags, TRUE);
1386
1387 if (cp->cn_pri == CN_DEAD)
1388 return;
1389
1390 /* initialize required fields */
1391 sprintf(cp->cn_name, "consolectl");
1392}
1393
1394static void
1395sccninit(struct consdev *cp)
1396{
1397 int unit;
1398 int flags;
1399
1400 sc_get_cons_priority(&unit, &flags);
1401 scinit(unit, flags | SC_KERNEL_CONSOLE);
1402 sc_console_unit = unit;
1403 sc_console = sc_get_stat(sc_get_softc(unit, SC_KERNEL_CONSOLE)->dev[0]);
1404 sc_consptr = cp;
1405}
1406
1407static void
1408sccnterm(struct consdev *cp)
1409{
1410 /* we are not the kernel console any more, release everything */
1411
1412 if (sc_console_unit < 0)
1413 return; /* shouldn't happen */
1414
1415#if 0 /* XXX */
1416 sc_clear_screen(sc_console);
1417 sccnupdate(sc_console);
1418#endif
1419
1420 scterm(sc_console_unit, SC_KERNEL_CONSOLE);
1421 sc_console_unit = -1;
1422 sc_console = NULL;
1423}
1424
1425static void
1426sccnputc(struct consdev *cd, int c)
1427{
1428 u_char buf[1];
1429 scr_stat *scp = sc_console;
1430 void *save;
1431#ifndef SC_NO_HISTORY
1432 struct tty *tp;
1433#endif /* !SC_NO_HISTORY */
1434 int s;
1435
1436 /* assert(sc_console != NULL) */
1437
1438#ifndef SC_NO_HISTORY
1439 if (scp == scp->sc->cur_scp && scp->status & SLKED) {
1440 scp->status &= ~SLKED;
1441 update_kbd_state(scp, scp->status, SLKED);
1442 if (scp->status & BUFFER_SAVED) {
1443 if (!sc_hist_restore(scp))
1444 sc_remove_cutmarking(scp);
1445 scp->status &= ~BUFFER_SAVED;
1446 scp->status |= CURSOR_ENABLED;
1447 sc_draw_cursor_image(scp);
1448 }
1449 tp = VIRTUAL_TTY(scp->sc, scp->index);
1450 if (ISTTYOPEN(tp))
1451 scstart(tp);
1452 }
1453#endif /* !SC_NO_HISTORY */
1454
1455 save = scp->ts;
1456 if (kernel_console_ts != NULL)
1457 scp->ts = kernel_console_ts;
1458 buf[0] = c;
1459 sc_puts(scp, buf, 1);
1460 scp->ts = save;
1461
1462 s = spltty(); /* block sckbdevent and scrn_timer */
1463 sccnupdate(scp);
1464 splx(s);
1465}
1466
1467static int
1468sccngetc(struct consdev *cd)
1469{
1470 return sccngetch(0);
1471}
1472
1473static int
1474sccncheckc(struct consdev *cd)
1475{
1476 return sccngetch(SCGETC_NONBLOCK);
1477}
1478
1479static void
1480sccndbctl(struct consdev *cd, int on)
1481{
1482 /* assert(sc_console_unit >= 0) */
1483 /* try to switch to the kernel console screen */
1484 if (on && debugger == 0) {
1485 /*
1486 * TRY to make sure the screen saver is stopped,
1487 * and the screen is updated before switching to
1488 * the vty0.
1489 */
1490 scrn_timer(NULL);
1491 if (!cold
1492 && sc_console->sc->cur_scp->smode.mode == VT_AUTO
1493 && sc_console->smode.mode == VT_AUTO) {
1494 sc_console->sc->cur_scp->status |= MOUSE_HIDDEN;
1495 ++debugger; /* XXX */
1496#ifdef DDB
1497 /* unlock vty switching */
1498 sc_console->sc->flags &= ~SC_SCRN_VTYLOCK;
1499#endif
1500 sc_switch_scr(sc_console->sc, sc_console->index);
1501 --debugger; /* XXX */
1502 }
1503 }
1504 if (on)
1505 ++debugger;
1506 else
1507 --debugger;
1508}
1509
1510static int
1511sccngetch(int flags)
1512{
1513 static struct fkeytab fkey;
1514 static int fkeycp;
1515 scr_stat *scp;
1516 u_char *p;
1517 int cur_mode;
1518 int s = spltty(); /* block sckbdevent and scrn_timer while we poll */
1519 int c;
1520
1521 /* assert(sc_console != NULL) */
1522
1523 /*
1524 * Stop the screen saver and update the screen if necessary.
1525 * What if we have been running in the screen saver code... XXX
1526 */
1527 sc_touch_scrn_saver();
1528 scp = sc_console->sc->cur_scp; /* XXX */
1529 sccnupdate(scp);
1530
1531 if (fkeycp < fkey.len) {
1532 splx(s);
1533 return fkey.str[fkeycp++];
1534 }
1535
1536 if (scp->sc->kbd == NULL) {
1537 splx(s);
1538 return -1;
1539 }
1540
1541 /*
1542 * Make sure the keyboard is accessible even when the kbd device
1543 * driver is disabled.
1544 */
1545 kbd_enable(scp->sc->kbd);
1546
1547 /* we shall always use the keyboard in the XLATE mode here */
1548 cur_mode = scp->kbd_mode;
1549 scp->kbd_mode = K_XLATE;
1550 kbd_ioctl(scp->sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
1551
1552 kbd_poll(scp->sc->kbd, TRUE);
1553 c = scgetc(scp->sc, SCGETC_CN | flags);
1554 kbd_poll(scp->sc->kbd, FALSE);
1555
1556 scp->kbd_mode = cur_mode;
1557 kbd_ioctl(scp->sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
1558 kbd_disable(scp->sc->kbd);
1559 splx(s);
1560
1561 switch (KEYFLAGS(c)) {
1562 case 0: /* normal char */
1563 return KEYCHAR(c);
1564 case FKEY: /* function key */
1565 p = kbd_get_fkeystr(scp->sc->kbd, KEYCHAR(c), (size_t *)&fkeycp);
1566 fkey.len = fkeycp;
1567 if ((p != NULL) && (fkey.len > 0)) {
1568 bcopy(p, fkey.str, fkey.len);
1569 fkeycp = 1;
1570 return fkey.str[0];
1571 }
1572 return c; /* XXX */
1573 case NOKEY:
1574 case ERRKEY:
1575 default:
1576 return -1;
1577 }
1578 /* NOT REACHED */
1579}
1580
1581static void
1582sccnupdate(scr_stat *scp)
1583{
1584 /* this is a cut-down version of scrn_timer()... */
1585
1586 if (scp->sc->font_loading_in_progress || scp->sc->videoio_in_progress)
1587 return;
1588
1589 if (debugger > 0 || panicstr || shutdown_in_progress) {
1590 sc_touch_scrn_saver();
1591 } else if (scp != scp->sc->cur_scp) {
1592 return;
1593 }
1594
1595 if (!run_scrn_saver)
1596 scp->sc->flags &= ~SC_SCRN_IDLE;
1597#ifdef DEV_SPLASH
1598 if ((saver_mode != CONS_LKM_SAVER) || !(scp->sc->flags & SC_SCRN_IDLE))
1599 if (scp->sc->flags & SC_SCRN_BLANKED)
1600 stop_scrn_saver(scp->sc, current_saver);
1601#endif
1602
1603 if (scp != scp->sc->cur_scp || scp->sc->blink_in_progress
1604 || scp->sc->switch_in_progress)
1605 return;
1606 /*
1607 * FIXME: unlike scrn_timer(), we call scrn_update() from here even
1608 * when write_in_progress is non-zero. XXX
1609 */
1610
1611 if (!ISGRAPHSC(scp) && !(scp->sc->flags & SC_SCRN_BLANKED))
1612 scrn_update(scp, TRUE);
1613}
1614
1615static void
1616scrn_timer(void *arg)
1617{
1618#ifndef PC98
1619 static int kbd_interval = 0;
1620#endif
1621 struct timeval tv;
1622 sc_softc_t *sc;
1623 scr_stat *scp;
1624 int again;
1625 int s;
1626
1627 again = (arg != NULL);
1628 if (arg != NULL)
1629 sc = (sc_softc_t *)arg;
1630 else if (sc_console != NULL)
1631 sc = sc_console->sc;
1632 else
1633 return;
1634
1635 /* don't do anything when we are performing some I/O operations */
1636 if (sc->font_loading_in_progress || sc->videoio_in_progress) {
1637 if (again)
1638 timeout(scrn_timer, sc, hz / 10);
1639 return;
1640 }
1641 s = spltty();
1642
1643#ifndef PC98
1644 if ((sc->kbd == NULL) && (sc->config & SC_AUTODETECT_KBD)) {
1645 /* try to allocate a keyboard automatically */
1646 if (++kbd_interval >= 25) {
1647 sc->keyboard = kbd_allocate("*", -1, (void *)&sc->keyboard,
1648 sckbdevent, sc);
1649 if (sc->keyboard >= 0) {
1650 sc->kbd = kbd_get_keyboard(sc->keyboard);
1651 kbd_ioctl(sc->kbd, KDSKBMODE,
1652 (caddr_t)&sc->cur_scp->kbd_mode);
1653 update_kbd_state(sc->cur_scp, sc->cur_scp->status,
1654 LOCK_MASK);
1655 }
1656 kbd_interval = 0;
1657 }
1658 }
1659#endif /* PC98 */
1660
1661 /* find the vty to update */
1662 scp = sc->cur_scp;
1663
1664 /* should we stop the screen saver? */
1665 getmicrouptime(&tv);
1666 if (debugger > 0 || panicstr || shutdown_in_progress)
1667 sc_touch_scrn_saver();
1668 if (run_scrn_saver) {
1669 if (tv.tv_sec > sc->scrn_time_stamp + scrn_blank_time)
1670 sc->flags |= SC_SCRN_IDLE;
1671 else
1672 sc->flags &= ~SC_SCRN_IDLE;
1673 } else {
1674 sc->scrn_time_stamp = tv.tv_sec;
1675 sc->flags &= ~SC_SCRN_IDLE;
1676 if (scrn_blank_time > 0)
1677 run_scrn_saver = TRUE;
1678 }
1679#ifdef DEV_SPLASH
1680 if ((saver_mode != CONS_LKM_SAVER) || !(sc->flags & SC_SCRN_IDLE))
1681 if (sc->flags & SC_SCRN_BLANKED)
1682 stop_scrn_saver(sc, current_saver);
1683#endif
1684
1685 /* should we just return ? */
1686 if (sc->blink_in_progress || sc->switch_in_progress
1687 || sc->write_in_progress) {
1688 if (again)
1689 timeout(scrn_timer, sc, hz / 10);
1690 splx(s);
1691 return;
1692 }
1693
1694 /* Update the screen */
1695 scp = sc->cur_scp; /* cur_scp may have changed... */
1696 if (!ISGRAPHSC(scp) && !(sc->flags & SC_SCRN_BLANKED))
1697 scrn_update(scp, TRUE);
1698
1699#ifdef DEV_SPLASH
1700 /* should we activate the screen saver? */
1701 if ((saver_mode == CONS_LKM_SAVER) && (sc->flags & SC_SCRN_IDLE))
1702 if (!ISGRAPHSC(scp) || (sc->flags & SC_SCRN_BLANKED))
1703 (*current_saver)(sc, TRUE);
1704#endif
1705
1706 if (again)
1707 timeout(scrn_timer, sc, hz / 25);
1708 splx(s);
1709}
1710
1711static int
1712and_region(int *s1, int *e1, int s2, int e2)
1713{
1714 if (*e1 < s2 || e2 < *s1)
1715 return FALSE;
1716 *s1 = imax(*s1, s2);
1717 *e1 = imin(*e1, e2);
1718 return TRUE;
1719}
1720
1721static void
1722scrn_update(scr_stat *scp, int show_cursor)
1723{
1724 int start;
1725 int end;
1726 int s;
1727 int e;
1728
1729 /* assert(scp == scp->sc->cur_scp) */
1730
1731 ++scp->sc->videoio_in_progress;
1732
1733#ifndef SC_NO_CUTPASTE
1734 /* remove the previous mouse pointer image if necessary */
1735 if (scp->status & MOUSE_VISIBLE) {
1736 s = scp->mouse_pos;
1737 e = scp->mouse_pos + scp->xsize + 1;
1738 if ((scp->status & (MOUSE_MOVED | MOUSE_HIDDEN))
1739 || and_region(&s, &e, scp->start, scp->end)
1740 || ((scp->status & CURSOR_ENABLED) &&
1741 (scp->cursor_pos != scp->cursor_oldpos) &&
1742 (and_region(&s, &e, scp->cursor_pos, scp->cursor_pos)
1743 || and_region(&s, &e, scp->cursor_oldpos, scp->cursor_oldpos)))) {
1744 sc_remove_mouse_image(scp);
1745 if (scp->end >= scp->xsize*scp->ysize)
1746 scp->end = scp->xsize*scp->ysize - 1;
1747 }
1748 }
1749#endif /* !SC_NO_CUTPASTE */
1750
1751#if 1
1752 /* debug: XXX */
1753 if (scp->end >= scp->xsize*scp->ysize) {
1754 printf("scrn_update(): scp->end %d > size_of_screen!!\n", scp->end);
1755 scp->end = scp->xsize*scp->ysize - 1;
1756 }
1757 if (scp->start < 0) {
1758 printf("scrn_update(): scp->start %d < 0\n", scp->start);
1759 scp->start = 0;
1760 }
1761#endif
1762
1763 /* update screen image */
1764 if (scp->start <= scp->end) {
1765 if (scp->mouse_cut_end >= 0) {
1766 /* there is a marked region for cut & paste */
1767 if (scp->mouse_cut_start <= scp->mouse_cut_end) {
1768 start = scp->mouse_cut_start;
1769 end = scp->mouse_cut_end;
1770 } else {
1771 start = scp->mouse_cut_end;
1772 end = scp->mouse_cut_start - 1;
1773 }
1774 s = start;
1775 e = end;
1776 /* does the cut-mark region overlap with the update region? */
1777 if (and_region(&s, &e, scp->start, scp->end)) {
1778 (*scp->rndr->draw)(scp, s, e - s + 1, TRUE);
1779 s = 0;
1780 e = start - 1;
1781 if (and_region(&s, &e, scp->start, scp->end))
1782 (*scp->rndr->draw)(scp, s, e - s + 1, FALSE);
1783 s = end + 1;
1784 e = scp->xsize*scp->ysize - 1;
1785 if (and_region(&s, &e, scp->start, scp->end))
1786 (*scp->rndr->draw)(scp, s, e - s + 1, FALSE);
1787 } else {
1788 (*scp->rndr->draw)(scp, scp->start,
1789 scp->end - scp->start + 1, FALSE);
1790 }
1791 } else {
1792 (*scp->rndr->draw)(scp, scp->start,
1793 scp->end - scp->start + 1, FALSE);
1794 }
1795 }
1796
1797 /* we are not to show the cursor and the mouse pointer... */
1798 if (!show_cursor) {
1799 scp->end = 0;
1800 scp->start = scp->xsize*scp->ysize - 1;
1801 --scp->sc->videoio_in_progress;
1802 return;
1803 }
1804
1805 /* update cursor image */
1806 if (scp->status & CURSOR_ENABLED) {
1807 s = scp->start;
1808 e = scp->end;
1809 /* did cursor move since last time ? */
1810 if (scp->cursor_pos != scp->cursor_oldpos) {
1811 /* do we need to remove old cursor image ? */
1812 if (!and_region(&s, &e, scp->cursor_oldpos, scp->cursor_oldpos))
1813 sc_remove_cursor_image(scp);
1814 sc_draw_cursor_image(scp);
1815 } else {
1816 if (and_region(&s, &e, scp->cursor_pos, scp->cursor_pos))
1817 /* cursor didn't move, but has been overwritten */
1818 sc_draw_cursor_image(scp);
1819 else if (scp->curs_attr.flags & CONS_BLINK_CURSOR)
1820 /* if it's a blinking cursor, update it */
1821 (*scp->rndr->blink_cursor)(scp, scp->cursor_pos,
1822 sc_inside_cutmark(scp,
1823 scp->cursor_pos));
1824 }
1825 }
1826
1827#ifndef SC_NO_CUTPASTE
1828 /* update "pseudo" mouse pointer image */
1829 if (scp->sc->flags & SC_MOUSE_ENABLED) {
1830 if (!(scp->status & (MOUSE_VISIBLE | MOUSE_HIDDEN))) {
1831 scp->status &= ~MOUSE_MOVED;
1832 sc_draw_mouse_image(scp);
1833 }
1834 }
1835#endif /* SC_NO_CUTPASTE */
1836
1837 scp->end = 0;
1838 scp->start = scp->xsize*scp->ysize - 1;
1839
1840 --scp->sc->videoio_in_progress;
1841}
1842
1843#ifdef DEV_SPLASH
1844static int
1845scsplash_callback(int event, void *arg)
1846{
1847 sc_softc_t *sc;
1848 int error;
1849
1850 sc = (sc_softc_t *)arg;
1851
1852 switch (event) {
1853 case SPLASH_INIT:
1854 if (add_scrn_saver(scsplash_saver) == 0) {
1855 sc->flags &= ~SC_SAVER_FAILED;
1856 run_scrn_saver = TRUE;
1857 if (cold && !(boothowto & (RB_VERBOSE | RB_CONFIG))) {
1858 scsplash_stick(TRUE);
1859 (*current_saver)(sc, TRUE);
1860 }
1861 }
1862 return 0;
1863
1864 case SPLASH_TERM:
1865 if (current_saver == scsplash_saver) {
1866 scsplash_stick(FALSE);
1867 error = remove_scrn_saver(scsplash_saver);
1868 if (error)
1869 return error;
1870 }
1871 return 0;
1872
1873 default:
1874 return EINVAL;
1875 }
1876}
1877
1878static void
1879scsplash_saver(sc_softc_t *sc, int show)
1880{
1881 static int busy = FALSE;
1882 scr_stat *scp;
1883
1884 if (busy)
1885 return;
1886 busy = TRUE;
1887
1888 scp = sc->cur_scp;
1889 if (show) {
1890 if (!(sc->flags & SC_SAVER_FAILED)) {
1891 if (!(sc->flags & SC_SCRN_BLANKED))
1892 set_scrn_saver_mode(scp, -1, NULL, 0);
1893 switch (splash(sc->adp, TRUE)) {
1894 case 0: /* succeeded */
1895 break;
1896 case EAGAIN: /* try later */
1897 restore_scrn_saver_mode(scp, FALSE);
1898 sc_touch_scrn_saver(); /* XXX */
1899 break;
1900 default:
1901 sc->flags |= SC_SAVER_FAILED;
1902 scsplash_stick(FALSE);
1903 restore_scrn_saver_mode(scp, TRUE);
1904 printf("scsplash_saver(): failed to put up the image\n");
1905 break;
1906 }
1907 }
1908 } else if (!sticky_splash) {
1909 if ((sc->flags & SC_SCRN_BLANKED) && (splash(sc->adp, FALSE) == 0))
1910 restore_scrn_saver_mode(scp, TRUE);
1911 }
1912 busy = FALSE;
1913}
1914
1915static int
1916add_scrn_saver(void (*this_saver)(sc_softc_t *, int))
1917{
1918#if 0
1919 int error;
1920
1921 if (current_saver != none_saver) {
1922 error = remove_scrn_saver(current_saver);
1923 if (error)
1924 return error;
1925 }
1926#endif
1927 if (current_saver != none_saver)
1928 return EBUSY;
1929
1930 run_scrn_saver = FALSE;
1931 saver_mode = CONS_LKM_SAVER;
1932 current_saver = this_saver;
1933 return 0;
1934}
1935
1936static int
1937remove_scrn_saver(void (*this_saver)(sc_softc_t *, int))
1938{
1939 if (current_saver != this_saver)
1940 return EINVAL;
1941
1942#if 0
1943 /*
1944 * In order to prevent `current_saver' from being called by
1945 * the timeout routine `scrn_timer()' while we manipulate
1946 * the saver list, we shall set `current_saver' to `none_saver'
1947 * before stopping the current saver, rather than blocking by `splXX()'.
1948 */
1949 current_saver = none_saver;
1950 if (scrn_blanked)
1951 stop_scrn_saver(this_saver);
1952#endif
1953
1954 /* unblank all blanked screens */
1955 wait_scrn_saver_stop(NULL);
1956 if (scrn_blanked)
1957 return EBUSY;
1958
1959 current_saver = none_saver;
1960 return 0;
1961}
1962
1963static int
1964set_scrn_saver_mode(scr_stat *scp, int mode, u_char *pal, int border)
1965{
1966 int s;
1967
1968 /* assert(scp == scp->sc->cur_scp) */
1969 s = spltty();
1970 if (!ISGRAPHSC(scp))
1971 sc_remove_cursor_image(scp);
1972 scp->splash_save_mode = scp->mode;
1973 scp->splash_save_status = scp->status & (GRAPHICS_MODE | PIXEL_MODE);
1974 scp->status &= ~(GRAPHICS_MODE | PIXEL_MODE);
1975 scp->status |= (UNKNOWN_MODE | SAVER_RUNNING);
1976 scp->sc->flags |= SC_SCRN_BLANKED;
1977 ++scrn_blanked;
1978 splx(s);
1979 if (mode < 0)
1980 return 0;
1981 scp->mode = mode;
1982 if (set_mode(scp) == 0) {
1983 if (scp->sc->adp->va_info.vi_flags & V_INFO_GRAPHICS)
1984 scp->status |= GRAPHICS_MODE;
1985#ifndef SC_NO_PALETTE_LOADING
1986 if (pal != NULL)
1987 load_palette(scp->sc->adp, pal);
1988#endif
1989 sc_set_border(scp, border);
1990 return 0;
1991 } else {
1992 s = spltty();
1993 scp->mode = scp->splash_save_mode;
1994 scp->status &= ~(UNKNOWN_MODE | SAVER_RUNNING);
1995 scp->status |= scp->splash_save_status;
1996 splx(s);
1997 return 1;
1998 }
1999}
2000
2001static int
2002restore_scrn_saver_mode(scr_stat *scp, int changemode)
2003{
2004 int mode;
2005 int status;
2006 int s;
2007
2008 /* assert(scp == scp->sc->cur_scp) */
2009 s = spltty();
2010 mode = scp->mode;
2011 status = scp->status;
2012 scp->mode = scp->splash_save_mode;
2013 scp->status &= ~(UNKNOWN_MODE | SAVER_RUNNING);
2014 scp->status |= scp->splash_save_status;
2015 scp->sc->flags &= ~SC_SCRN_BLANKED;
2016 if (!changemode) {
2017 if (!ISGRAPHSC(scp))
2018 sc_draw_cursor_image(scp);
2019 --scrn_blanked;
2020 splx(s);
2021 return 0;
2022 }
2023 if (set_mode(scp) == 0) {
2024#ifndef SC_NO_PALETTE_LOADING
2025 load_palette(scp->sc->adp, scp->sc->palette);
2026#endif
2027 --scrn_blanked;
2028 splx(s);
2029 return 0;
2030 } else {
2031 scp->mode = mode;
2032 scp->status = status;
2033 splx(s);
2034 return 1;
2035 }
2036}
2037
2038static void
2039stop_scrn_saver(sc_softc_t *sc, void (*saver)(sc_softc_t *, int))
2040{
2041 (*saver)(sc, FALSE);
2042 run_scrn_saver = FALSE;
2043 /* the screen saver may have chosen not to stop after all... */
2044 if (sc->flags & SC_SCRN_BLANKED)
2045 return;
2046
2047 mark_all(sc->cur_scp);
2048 if (sc->delayed_next_scr)
2049 sc_switch_scr(sc, sc->delayed_next_scr - 1);
2050 if (debugger == 0)
2051 wakeup(&scrn_blanked);
2052}
2053
2054static int
2055wait_scrn_saver_stop(sc_softc_t *sc)
2056{
2057 int error = 0;
2058
2059 while (scrn_blanked > 0) {
2060 run_scrn_saver = FALSE;
2061 if (sc && !(sc->flags & SC_SCRN_BLANKED)) {
2062 error = 0;
2063 break;
2064 }
2065 error = tsleep(&scrn_blanked, PZERO | PCATCH, "scrsav", 0);
2066 if ((error != 0) && (error != ERESTART))
2067 break;
2068 }
2069 run_scrn_saver = FALSE;
2070 return error;
2071}
2072#endif /* DEV_SPLASH */
2073
2074void
2075sc_touch_scrn_saver(void)
2076{
2077 scsplash_stick(FALSE);
2078 run_scrn_saver = FALSE;
2079}
2080
2081int
2082sc_switch_scr(sc_softc_t *sc, u_int next_scr)
2083{
2084 scr_stat *cur_scp;
2085 struct tty *tp;
2086 struct proc *p;
2087 int s;
2088
2089 DPRINTF(5, ("sc0: sc_switch_scr() %d ", next_scr + 1));
2090
2091 if (sc->cur_scp == NULL)
2092 return (0);
2093
2094 /* prevent switch if previously requested */
2095 if (sc->flags & SC_SCRN_VTYLOCK) {
2096 sc_bell(sc->cur_scp, sc->cur_scp->bell_pitch,
2097 sc->cur_scp->bell_duration);
2098 return EPERM;
2099 }
2100
2101 /* delay switch if the screen is blanked or being updated */
2102 if ((sc->flags & SC_SCRN_BLANKED) || sc->write_in_progress
2103 || sc->blink_in_progress || sc->videoio_in_progress) {
2104 sc->delayed_next_scr = next_scr + 1;
2105 sc_touch_scrn_saver();
2106 DPRINTF(5, ("switch delayed\n"));
2107 return 0;
2108 }
2109
2110 s = spltty();
2111 cur_scp = sc->cur_scp;
2112
2113 /* we are in the middle of the vty switching process... */
2114 if (sc->switch_in_progress
2115 && (cur_scp->smode.mode == VT_PROCESS)
2116 && cur_scp->proc) {
2117 p = pfind(cur_scp->pid);
2118 if (cur_scp->proc != p) {
2119 if (p)
2120 PROC_UNLOCK(p);
2121 /*
2122 * The controlling process has died!!. Do some clean up.
2123 * NOTE:`cur_scp->proc' and `cur_scp->smode.mode'
2124 * are not reset here yet; they will be cleared later.
2125 */
2126 DPRINTF(5, ("cur_scp controlling process %d died, ",
2127 cur_scp->pid));
2128 if (cur_scp->status & SWITCH_WAIT_REL) {
2129 /*
2130 * Force the previous switch to finish, but return now
2131 * with error.
2132 */
2133 DPRINTF(5, ("reset WAIT_REL, "));
2134 finish_vt_rel(cur_scp, TRUE, &s);
2135 splx(s);
2136 DPRINTF(5, ("finishing previous switch\n"));
2137 return EINVAL;
2138 } else if (cur_scp->status & SWITCH_WAIT_ACQ) {
2139 /* let's assume screen switch has been completed. */
2140 DPRINTF(5, ("reset WAIT_ACQ, "));
2141 finish_vt_acq(cur_scp);
2142 } else {
2143 /*
2144 * We are in between screen release and acquisition, and
2145 * reached here via scgetc() or scrn_timer() which has
2146 * interrupted exchange_scr(). Don't do anything stupid.
2147 */
2148 DPRINTF(5, ("waiting nothing, "));
2149 }
2150 } else {
2151 if (p)
2152 PROC_UNLOCK(p);
2153 /*
2154 * The controlling process is alive, but not responding...
2155 * It is either buggy or it may be just taking time.
2156 * The following code is a gross kludge to cope with this
2157 * problem for which there is no clean solution. XXX
2158 */
2159 if (cur_scp->status & SWITCH_WAIT_REL) {
2160 switch (sc->switch_in_progress++) {
2161 case 1:
2162 break;
2163 case 2:
2164 DPRINTF(5, ("sending relsig again, "));
2165 signal_vt_rel(cur_scp);
2166 break;
2167 case 3:
2168 break;
2169 case 4:
2170 default:
2171 /*
2172 * Act as if the controlling program returned
2173 * VT_FALSE.
2174 */
2175 DPRINTF(5, ("force reset WAIT_REL, "));
2176 finish_vt_rel(cur_scp, FALSE, &s);
2177 splx(s);
2178 DPRINTF(5, ("act as if VT_FALSE was seen\n"));
2179 return EINVAL;
2180 }
2181 } else if (cur_scp->status & SWITCH_WAIT_ACQ) {
2182 switch (sc->switch_in_progress++) {
2183 case 1:
2184 break;
2185 case 2:
2186 DPRINTF(5, ("sending acqsig again, "));
2187 signal_vt_acq(cur_scp);
2188 break;
2189 case 3:
2190 break;
2191 case 4:
2192 default:
2193 /* clear the flag and finish the previous switch */
2194 DPRINTF(5, ("force reset WAIT_ACQ, "));
2195 finish_vt_acq(cur_scp);
2196 break;
2197 }
2198 }
2199 }
2200 }
2201
2202 /*
2203 * Return error if an invalid argument is given, or vty switch
2204 * is still in progress.
2205 */
2206 if ((next_scr < sc->first_vty) || (next_scr >= sc->first_vty + sc->vtys)
2207 || sc->switch_in_progress) {
2208 splx(s);
2209 sc_bell(cur_scp, bios_value.bell_pitch, BELL_DURATION);
2210 DPRINTF(5, ("error 1\n"));
2211 return EINVAL;
2212 }
2213
2214 /*
2215 * Don't allow switching away from the graphics mode vty
2216 * if the switch mode is VT_AUTO, unless the next vty is the same
2217 * as the current or the current vty has been closed (but showing).
2218 */
2219 tp = VIRTUAL_TTY(sc, cur_scp->index);
2220 if ((cur_scp->index != next_scr)
2221 && ISTTYOPEN(tp)
2222 && (cur_scp->smode.mode == VT_AUTO)
2223 && ISGRAPHSC(cur_scp)) {
2224 splx(s);
2225 sc_bell(cur_scp, bios_value.bell_pitch, BELL_DURATION);
2226 DPRINTF(5, ("error, graphics mode\n"));
2227 return EINVAL;
2228 }
2229
2230 /*
2231 * Is the wanted vty open? Don't allow switching to a closed vty.
2232 * If we are in DDB, don't switch to a vty in the VT_PROCESS mode.
2233 * Note that we always allow the user to switch to the kernel
2234 * console even if it is closed.
2235 */
2236 if ((sc_console == NULL) || (next_scr != sc_console->index)) {
2237 tp = VIRTUAL_TTY(sc, next_scr);
2238 if (!ISTTYOPEN(tp)) {
2239 splx(s);
2240 sc_bell(cur_scp, bios_value.bell_pitch, BELL_DURATION);
2241 DPRINTF(5, ("error 2, requested vty isn't open!\n"));
2242 return EINVAL;
2243 }
2244 if ((debugger > 0) && (SC_STAT(tp->t_dev)->smode.mode == VT_PROCESS)) {
2245 splx(s);
2246 DPRINTF(5, ("error 3, requested vty is in the VT_PROCESS mode\n"));
2247 return EINVAL;
2248 }
2249 }
2250
2251 /* this is the start of vty switching process... */
2252 ++sc->switch_in_progress;
2253 sc->delayed_next_scr = 0;
2254 sc->old_scp = cur_scp;
2255 sc->new_scp = sc_get_stat(SC_DEV(sc, next_scr));
2256 if (sc->new_scp == sc->old_scp) {
2257 sc->switch_in_progress = 0;
2258 /*
2259 * XXX wakeup() calls mtx_lock(&sched_lock) which will hang if
2260 * sched_lock is in an in-between state, e.g., when we stop at
2261 * a breakpoint at fork_exit. It has always been wrong to call
2262 * wakeup() when the debugger is active. In RELENG_4, wakeup()
2263 * is supposed to be locked by splhigh(), but the debugger may
2264 * be invoked at splhigh().
2265 */
2266 if (debugger == 0)
2267 wakeup(&sc->new_scp->smode);
2268 splx(s);
2269 DPRINTF(5, ("switch done (new == old)\n"));
2270 return 0;
2271 }
2272
2273 /* has controlling process died? */
2274 vt_proc_alive(sc->old_scp);
2275 vt_proc_alive(sc->new_scp);
2276
2277 /* wait for the controlling process to release the screen, if necessary */
2278 if (signal_vt_rel(sc->old_scp)) {
2279 splx(s);
2280 return 0;
2281 }
2282
2283 /* go set up the new vty screen */
2284 splx(s);
2285 exchange_scr(sc);
2286 s = spltty();
2287
2288 /* wake up processes waiting for this vty */
2289 if (debugger == 0)
2290 wakeup(&sc->cur_scp->smode);
2291
2292 /* wait for the controlling process to acknowledge, if necessary */
2293 if (signal_vt_acq(sc->cur_scp)) {
2294 splx(s);
2295 return 0;
2296 }
2297
2298 sc->switch_in_progress = 0;
2299 if (sc->unit == sc_console_unit)
2300 cnavailable(sc_consptr, TRUE);
2301 splx(s);
2302 DPRINTF(5, ("switch done\n"));
2303
2304 return 0;
2305}
2306
2307static int
2308do_switch_scr(sc_softc_t *sc, int s)
2309{
2310 vt_proc_alive(sc->new_scp);
2311
2312 splx(s);
2313 exchange_scr(sc);
2314 s = spltty();
2315 /* sc->cur_scp == sc->new_scp */
2316 wakeup(&sc->cur_scp->smode);
2317
2318 /* wait for the controlling process to acknowledge, if necessary */
2319 if (!signal_vt_acq(sc->cur_scp)) {
2320 sc->switch_in_progress = 0;
2321 if (sc->unit == sc_console_unit)
2322 cnavailable(sc_consptr, TRUE);
2323 }
2324
2325 return s;
2326}
2327
2328static int
2329vt_proc_alive(scr_stat *scp)
2330{
2331 struct proc *p;
2332
2333 if (scp->proc) {
2334 if ((p = pfind(scp->pid)) != NULL)
2335 PROC_UNLOCK(p);
2336 if (scp->proc == p)
2337 return TRUE;
2338 scp->proc = NULL;
2339 scp->smode.mode = VT_AUTO;
2340 DPRINTF(5, ("vt controlling process %d died\n", scp->pid));
2341 }
2342 return FALSE;
2343}
2344
2345static int
2346signal_vt_rel(scr_stat *scp)
2347{
2348 if (scp->smode.mode != VT_PROCESS)
2349 return FALSE;
2350 scp->status |= SWITCH_WAIT_REL;
2351 PROC_LOCK(scp->proc);
2352 psignal(scp->proc, scp->smode.relsig);
2353 PROC_UNLOCK(scp->proc);
2354 DPRINTF(5, ("sending relsig to %d\n", scp->pid));
2355 return TRUE;
2356}
2357
2358static int
2359signal_vt_acq(scr_stat *scp)
2360{
2361 if (scp->smode.mode != VT_PROCESS)
2362 return FALSE;
2363 if (scp->sc->unit == sc_console_unit)
2364 cnavailable(sc_consptr, FALSE);
2365 scp->status |= SWITCH_WAIT_ACQ;
2366 PROC_LOCK(scp->proc);
2367 psignal(scp->proc, scp->smode.acqsig);
2368 PROC_UNLOCK(scp->proc);
2369 DPRINTF(5, ("sending acqsig to %d\n", scp->pid));
2370 return TRUE;
2371}
2372
2373static int
2374finish_vt_rel(scr_stat *scp, int release, int *s)
2375{
2376 if (scp == scp->sc->old_scp && scp->status & SWITCH_WAIT_REL) {
2377 scp->status &= ~SWITCH_WAIT_REL;
2378 if (release)
2379 *s = do_switch_scr(scp->sc, *s);
2380 else
2381 scp->sc->switch_in_progress = 0;
2382 return 0;
2383 }
2384 return EINVAL;
2385}
2386
2387static int
2388finish_vt_acq(scr_stat *scp)
2389{
2390 if (scp == scp->sc->new_scp && scp->status & SWITCH_WAIT_ACQ) {
2391 scp->status &= ~SWITCH_WAIT_ACQ;
2392 scp->sc->switch_in_progress = 0;
2393 return 0;
2394 }
2395 return EINVAL;
2396}
2397
2398static void
2399exchange_scr(sc_softc_t *sc)
2400{
2401 scr_stat *scp;
2402
2403 /* save the current state of video and keyboard */
2404 sc_move_cursor(sc->old_scp, sc->old_scp->xpos, sc->old_scp->ypos);
2405 if (!ISGRAPHSC(sc->old_scp))
2406 sc_remove_cursor_image(sc->old_scp);
2407 if (sc->old_scp->kbd_mode == K_XLATE)
2408 save_kbd_state(sc->old_scp);
2409
2410 /* set up the video for the new screen */
2411 scp = sc->cur_scp = sc->new_scp;
2412#ifdef PC98
2413 if (sc->old_scp->mode != scp->mode || ISUNKNOWNSC(sc->old_scp) || ISUNKNOWNSC(sc->new_scp))
2414#else
2415 if (sc->old_scp->mode != scp->mode || ISUNKNOWNSC(sc->old_scp))
2416#endif
2417 set_mode(scp);
2418#ifndef __sparc64__
2419 else
2420 sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, scp->xsize, scp->ysize,
2421 (void *)sc->adp->va_window, FALSE);
2422#endif
2423 scp->status |= MOUSE_HIDDEN;
2424 sc_move_cursor(scp, scp->xpos, scp->ypos);
2425 if (!ISGRAPHSC(scp))
2426 sc_set_cursor_image(scp);
2427#ifndef SC_NO_PALETTE_LOADING
2428 if (ISGRAPHSC(sc->old_scp))
2429 load_palette(sc->adp, sc->palette);
2430#endif
2431 sc_set_border(scp, scp->border);
2432
2433 /* set up the keyboard for the new screen */
2434 if (sc->old_scp->kbd_mode != scp->kbd_mode)
2435 kbd_ioctl(sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
2436 update_kbd_state(scp, scp->status, LOCK_MASK);
2437
2438 mark_all(scp);
2439}
2440
2441void
2442sc_puts(scr_stat *scp, u_char *buf, int len)
2443{
2444#ifdef DEV_SPLASH
2445 /* make screensaver happy */
2446 if (!sticky_splash && scp == scp->sc->cur_scp && !sc_saver_keyb_only)
2447 run_scrn_saver = FALSE;
2448#endif
2449
2450 if (scp->tsw)
2451 (*scp->tsw->te_puts)(scp, buf, len);
2452
2453 if (scp->sc->delayed_next_scr)
2454 sc_switch_scr(scp->sc, scp->sc->delayed_next_scr - 1);
2455}
2456
2457void
2458sc_draw_cursor_image(scr_stat *scp)
2459{
2460 /* assert(scp == scp->sc->cur_scp); */
2461 ++scp->sc->videoio_in_progress;
2462 (*scp->rndr->draw_cursor)(scp, scp->cursor_pos,
2463 scp->curs_attr.flags & CONS_BLINK_CURSOR, TRUE,
2464 sc_inside_cutmark(scp, scp->cursor_pos));
2465 scp->cursor_oldpos = scp->cursor_pos;
2466 --scp->sc->videoio_in_progress;
2467}
2468
2469void
2470sc_remove_cursor_image(scr_stat *scp)
2471{
2472 /* assert(scp == scp->sc->cur_scp); */
2473 ++scp->sc->videoio_in_progress;
2474 (*scp->rndr->draw_cursor)(scp, scp->cursor_oldpos,
2475 scp->curs_attr.flags & CONS_BLINK_CURSOR, FALSE,
2476 sc_inside_cutmark(scp, scp->cursor_oldpos));
2477 --scp->sc->videoio_in_progress;
2478}
2479
2480static void
2481update_cursor_image(scr_stat *scp)
2482{
2483 /* assert(scp == scp->sc->cur_scp); */
2484 sc_remove_cursor_image(scp);
2485 sc_set_cursor_image(scp);
2486 sc_draw_cursor_image(scp);
2487}
2488
2489void
2490sc_set_cursor_image(scr_stat *scp)
2491{
2492 scp->curs_attr.flags = scp->curr_curs_attr.flags;
2493 if (scp->curs_attr.flags & CONS_HIDDEN_CURSOR) {
2494 /* hidden cursor is internally represented as zero-height underline */
2495 scp->curs_attr.flags = CONS_CHAR_CURSOR;
2496 scp->curs_attr.base = scp->curs_attr.height = 0;
2497 } else if (scp->curs_attr.flags & CONS_CHAR_CURSOR) {
2498 scp->curs_attr.base = imin(scp->curr_curs_attr.base,
2499 scp->font_size - 1);
2500 scp->curs_attr.height = imin(scp->curr_curs_attr.height,
2501 scp->font_size - scp->curs_attr.base);
2502 } else { /* block cursor */
2503 scp->curs_attr.base = 0;
2504 scp->curs_attr.height = scp->font_size;
2505 }
2506
2507 /* assert(scp == scp->sc->cur_scp); */
2508 ++scp->sc->videoio_in_progress;
2509 (*scp->rndr->set_cursor)(scp, scp->curs_attr.base, scp->curs_attr.height,
2510 scp->curs_attr.flags & CONS_BLINK_CURSOR);
2511 --scp->sc->videoio_in_progress;
2512}
2513
2514static void
2515change_cursor_shape(scr_stat *scp, int flags, int base, int height)
2516{
2517 if ((scp == scp->sc->cur_scp) && !ISGRAPHSC(scp))
2518 sc_remove_cursor_image(scp);
2519
2520 if (base >= 0)
2521 scp->curr_curs_attr.base = base;
2522 if (height >= 0)
2523 scp->curr_curs_attr.height = height;
2524 if (flags & CONS_RESET_CURSOR)
2525 scp->curr_curs_attr = scp->dflt_curs_attr;
2526 else
2527 scp->curr_curs_attr.flags = flags & CONS_CURSOR_ATTRS;
2528
2529 if ((scp == scp->sc->cur_scp) && !ISGRAPHSC(scp)) {
2530 sc_set_cursor_image(scp);
2531 sc_draw_cursor_image(scp);
2532 }
2533}
2534
2535void
2536sc_change_cursor_shape(scr_stat *scp, int flags, int base, int height)
2537{
2538 sc_softc_t *sc;
2539 struct cdev *dev;
2540 int s;
2541 int i;
2542
2543 s = spltty();
2544 if ((flags != -1) && (flags & CONS_LOCAL_CURSOR)) {
2545 /* local (per vty) change */
2546 change_cursor_shape(scp, flags, base, height);
2547 splx(s);
2548 return;
2549 }
2550
2551 /* global change */
2552 sc = scp->sc;
2553 if (base >= 0)
2554 sc->curs_attr.base = base;
2555 if (height >= 0)
2556 sc->curs_attr.height = height;
2557 if (flags != -1) {
2558 if (flags & CONS_RESET_CURSOR)
2559 sc->curs_attr = sc->dflt_curs_attr;
2560 else
2561 sc->curs_attr.flags = flags & CONS_CURSOR_ATTRS;
2562 }
2563
2564 for (i = sc->first_vty; i < sc->first_vty + sc->vtys; ++i) {
2565 if ((dev = SC_DEV(sc, i)) == NULL)
2566 continue;
2567 if ((scp = sc_get_stat(dev)) == NULL)
2568 continue;
2569 scp->dflt_curs_attr = sc->curs_attr;
2570 change_cursor_shape(scp, CONS_RESET_CURSOR, -1, -1);
2571 }
2572 splx(s);
2573}
2574
2575static void
2576scinit(int unit, int flags)
2577{
2578 /*
2579 * When syscons is being initialized as the kernel console, malloc()
2580 * is not yet functional, because various kernel structures has not been
2581 * fully initialized yet. Therefore, we need to declare the following
2582 * static buffers for the console. This is less than ideal,
2583 * but is necessry evil for the time being. XXX
2584 */
2585#ifdef PC98
2586 static u_short sc_buffer[ROW*COL*2];/* XXX */
2587#else
2588 static u_short sc_buffer[ROW*COL]; /* XXX */
2589#endif
2590#ifndef SC_NO_FONT_LOADING
2591 static u_char font_8[256*8];
2592 static u_char font_14[256*14];
2593 static u_char font_16[256*16];
2594#endif
2595
2596 sc_softc_t *sc;
2597 scr_stat *scp;
2598 video_adapter_t *adp;
2599 int col;
2600 int row;
2601 int i;
2602
2603 /* one time initialization */
2604 if (init_done == COLD)
2605 sc_get_bios_values(&bios_value);
2606 init_done = WARM;
2607
2608 /*
2609 * Allocate resources. Even if we are being called for the second
2610 * time, we must allocate them again, because they might have
2611 * disappeared...
2612 */
2613 sc = sc_get_softc(unit, flags & SC_KERNEL_CONSOLE);
2614 adp = NULL;
2615 if (sc->adapter >= 0) {
2616 vid_release(sc->adp, (void *)&sc->adapter);
2617 adp = sc->adp;
2618 sc->adp = NULL;
2619 }
2620 if (sc->keyboard >= 0) {
2621 DPRINTF(5, ("sc%d: releasing kbd%d\n", unit, sc->keyboard));
2622 i = kbd_release(sc->kbd, (void *)&sc->keyboard);
2623 DPRINTF(5, ("sc%d: kbd_release returned %d\n", unit, i));
2624 if (sc->kbd != NULL) {
2625 DPRINTF(5, ("sc%d: kbd != NULL!, index:%d, unit:%d, flags:0x%x\n",
2626 unit, sc->kbd->kb_index, sc->kbd->kb_unit, sc->kbd->kb_flags));
2627 }
2628 sc->kbd = NULL;
2629 }
2630 sc->adapter = vid_allocate("*", unit, (void *)&sc->adapter);
2631 sc->adp = vid_get_adapter(sc->adapter);
2632 /* assert((sc->adapter >= 0) && (sc->adp != NULL)) */
2633 sc->keyboard = kbd_allocate("*", unit, (void *)&sc->keyboard,
2634 sckbdevent, sc);
2635 DPRINTF(1, ("sc%d: keyboard %d\n", unit, sc->keyboard));
2636 sc->kbd = kbd_get_keyboard(sc->keyboard);
2637 if (sc->kbd != NULL) {
2638 DPRINTF(1, ("sc%d: kbd index:%d, unit:%d, flags:0x%x\n",
2639 unit, sc->kbd->kb_index, sc->kbd->kb_unit, sc->kbd->kb_flags));
2640 }
2641
2642 if (!(sc->flags & SC_INIT_DONE) || (adp != sc->adp)) {
2643
2644 sc->initial_mode = sc->adp->va_initial_mode;
2645
2646#ifndef SC_NO_FONT_LOADING
2647 if (flags & SC_KERNEL_CONSOLE) {
2648 sc->font_8 = font_8;
2649 sc->font_14 = font_14;
2650 sc->font_16 = font_16;
2651 } else if (sc->font_8 == NULL) {
2652 /* assert(sc_malloc) */
2653 sc->font_8 = malloc(sizeof(font_8), M_DEVBUF, M_WAITOK);
2654 sc->font_14 = malloc(sizeof(font_14), M_DEVBUF, M_WAITOK);
2655 sc->font_16 = malloc(sizeof(font_16), M_DEVBUF, M_WAITOK);
2656 }
2657#endif
2658
2659 /* extract the hardware cursor location and hide the cursor for now */
2660 (*vidsw[sc->adapter]->read_hw_cursor)(sc->adp, &col, &row);
2661 (*vidsw[sc->adapter]->set_hw_cursor)(sc->adp, -1, -1);
2662
2663 /* set up the first console */
2664 sc->first_vty = unit*MAXCONS;
2665 sc->vtys = MAXCONS; /* XXX: should be configurable */
2666 if (flags & SC_KERNEL_CONSOLE) {
2667 /*
2668 * Set up devs structure but don't use it yet, calling make_dev()
2669 * might panic kernel. Wait for sc_attach_unit() to actually
2670 * create the devices.
2671 */
2672 sc->dev = main_devs;
2673 scp = &main_console;
2674 init_scp(sc, sc->first_vty, scp);
2675 sc_vtb_init(&scp->vtb, VTB_MEMORY, scp->xsize, scp->ysize,
2676 (void *)sc_buffer, FALSE);
2677 if (sc_init_emulator(scp, SC_DFLT_TERM))
2678 sc_init_emulator(scp, "*");
2679 (*scp->tsw->te_default_attr)(scp,
2680 kernel_default.std_color,
2681 kernel_default.rev_color);
2682 } else {
2683 /* assert(sc_malloc) */
2684 sc->dev = malloc(sizeof(struct cdev *)*sc->vtys, M_DEVBUF, M_WAITOK|M_ZERO);
2685 sc->dev[0] = make_dev(&sc_cdevsw, unit * MAXCONS,
2686 UID_ROOT, GID_WHEEL, 0600, "ttyv%r", unit * MAXCONS);
2687 sc->dev[0]->si_tty = ttymalloc(sc->dev[0]->si_tty);
2688 scp = alloc_scp(sc, sc->first_vty);
2689 SC_STAT(sc->dev[0]) = scp;
2690 }
2691 sc->cur_scp = scp;
2692
2693#ifndef __sparc64__
2694 /* copy screen to temporary buffer */
2695 sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, scp->xsize, scp->ysize,
2696 (void *)scp->sc->adp->va_window, FALSE);
2697 if (ISTEXTSC(scp))
2698 sc_vtb_copy(&scp->scr, 0, &scp->vtb, 0, scp->xsize*scp->ysize);
2699#endif
2700
2701 /* move cursors to the initial positions */
2702 if (col >= scp->xsize)
2703 col = 0;
2704 if (row >= scp->ysize)
2705 row = scp->ysize - 1;
2706 scp->xpos = col;
2707 scp->ypos = row;
2708 scp->cursor_pos = scp->cursor_oldpos = row*scp->xsize + col;
2709
2710 if (bios_value.cursor_end < scp->font_size)
2711 sc->dflt_curs_attr.base = scp->font_size -
2712 bios_value.cursor_end - 1;
2713 else
2714 sc->dflt_curs_attr.base = 0;
2715 i = bios_value.cursor_end - bios_value.cursor_start + 1;
2716 sc->dflt_curs_attr.height = imin(i, scp->font_size);
2717 sc->dflt_curs_attr.flags = 0;
2718 sc->curs_attr = sc->dflt_curs_attr;
2719 scp->curr_curs_attr = scp->dflt_curs_attr = sc->curs_attr;
2720
2721#ifndef SC_NO_SYSMOUSE
2722 sc_mouse_move(scp, scp->xpixel/2, scp->ypixel/2);
2723#endif
2724 if (!ISGRAPHSC(scp)) {
2725 sc_set_cursor_image(scp);
2726 sc_draw_cursor_image(scp);
2727 }
2728
2729 /* save font and palette */
2730#ifndef SC_NO_FONT_LOADING
2731 sc->fonts_loaded = 0;
2732 if (ISFONTAVAIL(sc->adp->va_flags)) {
2733#ifdef SC_DFLT_FONT
2734 bcopy(dflt_font_8, sc->font_8, sizeof(dflt_font_8));
2735 bcopy(dflt_font_14, sc->font_14, sizeof(dflt_font_14));
2736 bcopy(dflt_font_16, sc->font_16, sizeof(dflt_font_16));
2737 sc->fonts_loaded = FONT_16 | FONT_14 | FONT_8;
2738 if (scp->font_size < 14) {
2739 sc_load_font(scp, 0, 8, sc->font_8, 0, 256);
2740 } else if (scp->font_size >= 16) {
2741 sc_load_font(scp, 0, 16, sc->font_16, 0, 256);
2742 } else {
2743 sc_load_font(scp, 0, 14, sc->font_14, 0, 256);
2744 }
2745#else /* !SC_DFLT_FONT */
2746 if (scp->font_size < 14) {
2747 sc_save_font(scp, 0, 8, sc->font_8, 0, 256);
2748 sc->fonts_loaded = FONT_8;
2749 } else if (scp->font_size >= 16) {
2750 sc_save_font(scp, 0, 16, sc->font_16, 0, 256);
2751 sc->fonts_loaded = FONT_16;
2752 } else {
2753 sc_save_font(scp, 0, 14, sc->font_14, 0, 256);
2754 sc->fonts_loaded = FONT_14;
2755 }
2756#endif /* SC_DFLT_FONT */
2757 /* FONT KLUDGE: always use the font page #0. XXX */
2758 sc_show_font(scp, 0);
2759 }
2760#endif /* !SC_NO_FONT_LOADING */
2761
2762#ifndef SC_NO_PALETTE_LOADING
2763 save_palette(sc->adp, sc->palette);
2764#endif
2765
2766#ifdef DEV_SPLASH
2767 if (!(sc->flags & SC_SPLASH_SCRN) && (flags & SC_KERNEL_CONSOLE)) {
2768 /* we are ready to put up the splash image! */
2769 splash_init(sc->adp, scsplash_callback, sc);
2770 sc->flags |= SC_SPLASH_SCRN;
2771 }
2772#endif
2773 }
2774
2775 /* the rest is not necessary, if we have done it once */
2776 if (sc->flags & SC_INIT_DONE)
2777 return;
2778
2779 /* initialize mapscrn arrays to a one to one map */
2780 for (i = 0; i < sizeof(sc->scr_map); i++)
2781 sc->scr_map[i] = sc->scr_rmap[i] = i;
2782#ifdef PC98
2783 sc->scr_map[0x5c] = (u_char)0xfc; /* for backslash */
2784#endif
2785
2786 sc->flags |= SC_INIT_DONE;
2787}
2788
2789static void
2790scterm(int unit, int flags)
2791{
2792 sc_softc_t *sc;
2793 scr_stat *scp;
2794
2795 sc = sc_get_softc(unit, flags & SC_KERNEL_CONSOLE);
2796 if (sc == NULL)
2797 return; /* shouldn't happen */
2798
2799#ifdef DEV_SPLASH
2800 /* this console is no longer available for the splash screen */
2801 if (sc->flags & SC_SPLASH_SCRN) {
2802 splash_term(sc->adp);
2803 sc->flags &= ~SC_SPLASH_SCRN;
2804 }
2805#endif
2806
2807#if 0 /* XXX */
2808 /* move the hardware cursor to the upper-left corner */
2809 (*vidsw[sc->adapter]->set_hw_cursor)(sc->adp, 0, 0);
2810#endif
2811
2812 /* release the keyboard and the video card */
2813 if (sc->keyboard >= 0)
2814 kbd_release(sc->kbd, &sc->keyboard);
2815 if (sc->adapter >= 0)
2816 vid_release(sc->adp, &sc->adapter);
2817
2818 /* stop the terminal emulator, if any */
2819 scp = sc_get_stat(sc->dev[0]);
2820 if (scp->tsw)
2821 (*scp->tsw->te_term)(scp, &scp->ts);
2822 if (scp->ts != NULL)
2823 free(scp->ts, M_DEVBUF);
2824
2825 /* clear the structure */
2826 if (!(flags & SC_KERNEL_CONSOLE)) {
2827 /* XXX: We need delete_dev() for this */
2828 free(sc->dev, M_DEVBUF);
2829#if 0
2830 /* XXX: We need a ttyunregister for this */
2831 free(sc->tty, M_DEVBUF);
2832#endif
2833#ifndef SC_NO_FONT_LOADING
2834 free(sc->font_8, M_DEVBUF);
2835 free(sc->font_14, M_DEVBUF);
2836 free(sc->font_16, M_DEVBUF);
2837#endif
2838 /* XXX vtb, history */
2839 }
2840 bzero(sc, sizeof(*sc));
2841 sc->keyboard = -1;
2842 sc->adapter = -1;
2843}
2844
2845static void
2846scshutdown(void *arg, int howto)
2847{
2848 /* assert(sc_console != NULL) */
2849
2850 sc_touch_scrn_saver();
2851 if (!cold && sc_console
2852 && sc_console->sc->cur_scp->smode.mode == VT_AUTO
2853 && sc_console->smode.mode == VT_AUTO)
2854 sc_switch_scr(sc_console->sc, sc_console->index);
2855 shutdown_in_progress = TRUE;
2856}
2857
2858int
2859sc_clean_up(scr_stat *scp)
2860{
2861#ifdef DEV_SPLASH
2862 int error;
2863#endif
2864
2865 if (scp->sc->flags & SC_SCRN_BLANKED) {
2866 sc_touch_scrn_saver();
2867#ifdef DEV_SPLASH
2868 if ((error = wait_scrn_saver_stop(scp->sc)))
2869 return error;
2870#endif
2871 }
2872 scp->status |= MOUSE_HIDDEN;
2873 sc_remove_mouse_image(scp);
2874 sc_remove_cutmarking(scp);
2875 return 0;
2876}
2877
2878void
2879sc_alloc_scr_buffer(scr_stat *scp, int wait, int discard)
2880{
2881 sc_vtb_t new;
2882 sc_vtb_t old;
2883
2884 old = scp->vtb;
2885 sc_vtb_init(&new, VTB_MEMORY, scp->xsize, scp->ysize, NULL, wait);
2886 if (!discard && (old.vtb_flags & VTB_VALID)) {
2887 /* retain the current cursor position and buffer contants */
2888 scp->cursor_oldpos = scp->cursor_pos;
2889 /*
2890 * This works only if the old buffer has the same size as or larger
2891 * than the new one. XXX
2892 */
2893 sc_vtb_copy(&old, 0, &new, 0, scp->xsize*scp->ysize);
2894 scp->vtb = new;
2895 } else {
2896 scp->vtb = new;
2897 sc_vtb_destroy(&old);
2898 }
2899
2900#ifndef SC_NO_SYSMOUSE
2901 /* move the mouse cursor at the center of the screen */
2902 sc_mouse_move(scp, scp->xpixel / 2, scp->ypixel / 2);
2903#endif
2904}
2905
2906static scr_stat
2907*alloc_scp(sc_softc_t *sc, int vty)
2908{
2909 scr_stat *scp;
2910
2911 /* assert(sc_malloc) */
2912
2913 scp = (scr_stat *)malloc(sizeof(scr_stat), M_DEVBUF, M_WAITOK);
2914 init_scp(sc, vty, scp);
2915
2916 sc_alloc_scr_buffer(scp, TRUE, TRUE);
2917 if (sc_init_emulator(scp, SC_DFLT_TERM))
2918 sc_init_emulator(scp, "*");
2919
2920#ifndef SC_NO_CUTPASTE
2921 sc_alloc_cut_buffer(scp, TRUE);
2922#endif
2923
2924#ifndef SC_NO_HISTORY
2925 sc_alloc_history_buffer(scp, 0, 0, TRUE);
2926#endif
2927
2928 return scp;
2929}
2930
2931static void
2932init_scp(sc_softc_t *sc, int vty, scr_stat *scp)
2933{
2934 video_info_t info;
2935
2936 bzero(scp, sizeof(*scp));
2937
2938 scp->index = vty;
2939 scp->sc = sc;
2940 scp->status = 0;
2941 scp->mode = sc->initial_mode;
2942 (*vidsw[sc->adapter]->get_info)(sc->adp, scp->mode, &info);
2943 if (info.vi_flags & V_INFO_GRAPHICS) {
2944 scp->status |= GRAPHICS_MODE;
2945 scp->xpixel = info.vi_width;
2946 scp->ypixel = info.vi_height;
2947 scp->xsize = info.vi_width/info.vi_cwidth;
2948 scp->ysize = info.vi_height/info.vi_cheight;
2949 scp->font_size = 0;
2950 scp->font = NULL;
2951 } else {
2952 scp->xsize = info.vi_width;
2953 scp->ysize = info.vi_height;
2954 scp->xpixel = scp->xsize*info.vi_cwidth;
2955 scp->ypixel = scp->ysize*info.vi_cheight;
2956 scp->font_size = info.vi_cheight;
2957 scp->font_width = info.vi_cwidth;
2958 if (info.vi_cheight < 14) {
2959#ifndef SC_NO_FONT_LOADING
2960 scp->font = sc->font_8;
2961#else
2962 scp->font = NULL;
2963#endif
2964 } else if (info.vi_cheight >= 16) {
2965#ifndef SC_NO_FONT_LOADING
2966 scp->font = sc->font_16;
2967#else
2968 scp->font = NULL;
2969#endif
2970 } else {
2971#ifndef SC_NO_FONT_LOADING
2972 scp->font = sc->font_14;
2973#else
2974 scp->font = NULL;
2975#endif
2976 }
2977 }
2978 sc_vtb_init(&scp->vtb, VTB_MEMORY, 0, 0, NULL, FALSE);
2979#ifndef __sparc64__
2980 sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, 0, 0, NULL, FALSE);
2981#endif
2982 scp->xoff = scp->yoff = 0;
2983 scp->xpos = scp->ypos = 0;
2984 scp->start = scp->xsize * scp->ysize - 1;
2985 scp->end = 0;
2986 scp->tsw = NULL;
2987 scp->ts = NULL;
2988 scp->rndr = NULL;
2989 scp->border = BG_BLACK;
2990 scp->curr_curs_attr = scp->dflt_curs_attr = sc->curs_attr;
2991 scp->mouse_cut_start = scp->xsize*scp->ysize;
2992 scp->mouse_cut_end = -1;
2993 scp->mouse_signal = 0;
2994 scp->mouse_pid = 0;
2995 scp->mouse_proc = NULL;
2996 scp->kbd_mode = K_XLATE;
2997 scp->bell_pitch = bios_value.bell_pitch;
2998 scp->bell_duration = BELL_DURATION;
2999 scp->status |= (bios_value.shift_state & NLKED);
3000 scp->status |= CURSOR_ENABLED | MOUSE_HIDDEN;
3001 scp->pid = 0;
3002 scp->proc = NULL;
3003 scp->smode.mode = VT_AUTO;
3004 scp->history = NULL;
3005 scp->history_pos = 0;
3006 scp->history_size = 0;
3007}
3008
3009int
3010sc_init_emulator(scr_stat *scp, char *name)
3011{
3012 sc_term_sw_t *sw;
3013 sc_rndr_sw_t *rndr;
3014 void *p;
3015 int error;
3016
3017 if (name == NULL) /* if no name is given, use the current emulator */
3018 sw = scp->tsw;
3019 else /* ...otherwise find the named emulator */
3020 sw = sc_term_match(name);
3021 if (sw == NULL)
3022 return EINVAL;
3023
3024 rndr = NULL;
3025 if (strcmp(sw->te_renderer, "*") != 0) {
3026 rndr = sc_render_match(scp, sw->te_renderer,
3027 scp->status & (GRAPHICS_MODE | PIXEL_MODE));
3028 }
3029 if (rndr == NULL) {
3030 rndr = sc_render_match(scp, scp->sc->adp->va_name,
3031 scp->status & (GRAPHICS_MODE | PIXEL_MODE));
3032 if (rndr == NULL)
3033 return ENODEV;
3034 }
3035
3036 if (sw == scp->tsw) {
3037 error = (*sw->te_init)(scp, &scp->ts, SC_TE_WARM_INIT);
3038 scp->rndr = rndr;
3039 sc_clear_screen(scp);
3040 /* assert(error == 0); */
3041 return error;
3042 }
3043
3044 if (sc_malloc && (sw->te_size > 0))
3045 p = malloc(sw->te_size, M_DEVBUF, M_NOWAIT);
3046 else
3047 p = NULL;
3048 error = (*sw->te_init)(scp, &p, SC_TE_COLD_INIT);
3049 if (error)
3050 return error;
3051
3052 if (scp->tsw)
3053 (*scp->tsw->te_term)(scp, &scp->ts);
3054 if (scp->ts != NULL)
3055 free(scp->ts, M_DEVBUF);
3056 scp->tsw = sw;
3057 scp->ts = p;
3058 scp->rndr = rndr;
3059
3060 /* XXX */
3061 (*sw->te_default_attr)(scp, user_default.std_color, user_default.rev_color);
3062 sc_clear_screen(scp);
3063
3064 return 0;
3065}
3066
3067/*
3068 * scgetc(flags) - get character from keyboard.
3069 * If flags & SCGETC_CN, then avoid harmful side effects.
3070 * If flags & SCGETC_NONBLOCK, then wait until a key is pressed, else
3071 * return NOKEY if there is nothing there.
3072 */
3073static u_int
3074scgetc(sc_softc_t *sc, u_int flags)
3075{
3076 scr_stat *scp;
3077#ifndef SC_NO_HISTORY
3078 struct tty *tp;
3079#endif
3080 u_int c;
3081 int this_scr;
3082 int f;
3083 int i;
3084
3085 if (sc->kbd == NULL)
3086 return NOKEY;
3087
3088next_code:
3089#if 1
3090 /* I don't like this, but... XXX */
3091 if (flags & SCGETC_CN)
3092 sccnupdate(sc->cur_scp);
3093#endif
3094 scp = sc->cur_scp;
3095 /* first see if there is something in the keyboard port */
3096 for (;;) {
3097 c = kbd_read_char(sc->kbd, !(flags & SCGETC_NONBLOCK));
3098 if (c == ERRKEY) {
3099 if (!(flags & SCGETC_CN))
3100 sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3101 } else if (c == NOKEY)
3102 return c;
3103 else
3104 break;
3105 }
3106
3107 /* make screensaver happy */
3108 if (!(c & RELKEY))
3109 sc_touch_scrn_saver();
3110
3111 if (!(flags & SCGETC_CN))
3112 random_harvest(&c, sizeof(c), 1, 0, RANDOM_KEYBOARD);
3113
3114 if (scp->kbd_mode != K_XLATE)
3115 return KEYCHAR(c);
3116
3117 /* if scroll-lock pressed allow history browsing */
3118 if (!ISGRAPHSC(scp) && scp->history && scp->status & SLKED) {
3119
3120 scp->status &= ~CURSOR_ENABLED;
3121 sc_remove_cursor_image(scp);
3122
3123#ifndef SC_NO_HISTORY
3124 if (!(scp->status & BUFFER_SAVED)) {
3125 scp->status |= BUFFER_SAVED;
3126 sc_hist_save(scp);
3127 }
3128 switch (c) {
3129 /* FIXME: key codes */
3130 case SPCLKEY | FKEY | F(49): /* home key */
3131 sc_remove_cutmarking(scp);
3132 sc_hist_home(scp);
3133 goto next_code;
3134
3135 case SPCLKEY | FKEY | F(57): /* end key */
3136 sc_remove_cutmarking(scp);
3137 sc_hist_end(scp);
3138 goto next_code;
3139
3140 case SPCLKEY | FKEY | F(50): /* up arrow key */
3141 sc_remove_cutmarking(scp);
3142 if (sc_hist_up_line(scp))
3143 if (!(flags & SCGETC_CN))
3144 sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3145 goto next_code;
3146
3147 case SPCLKEY | FKEY | F(58): /* down arrow key */
3148 sc_remove_cutmarking(scp);
3149 if (sc_hist_down_line(scp))
3150 if (!(flags & SCGETC_CN))
3151 sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3152 goto next_code;
3153
3154 case SPCLKEY | FKEY | F(51): /* page up key */
3155 sc_remove_cutmarking(scp);
3156 for (i=0; i<scp->ysize; i++)
3157 if (sc_hist_up_line(scp)) {
3158 if (!(flags & SCGETC_CN))
3159 sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3160 break;
3161 }
3162 goto next_code;
3163
3164 case SPCLKEY | FKEY | F(59): /* page down key */
3165 sc_remove_cutmarking(scp);
3166 for (i=0; i<scp->ysize; i++)
3167 if (sc_hist_down_line(scp)) {
3168 if (!(flags & SCGETC_CN))
3169 sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3170 break;
3171 }
3172 goto next_code;
3173 }
3174#endif /* SC_NO_HISTORY */
3175 }
3176
3177 /*
3178 * Process and consume special keys here. Return a plain char code
3179 * or a char code with the META flag or a function key code.
3180 */
3181 if (c & RELKEY) {
3182 /* key released */
3183 /* goto next_code */
3184 } else {
3185 /* key pressed */
3186 if (c & SPCLKEY) {
3187 c &= ~SPCLKEY;
3188 switch (KEYCHAR(c)) {
3189 /* LOCKING KEYS */
3190 case NLK: case CLK: case ALK:
3191 break;
3192 case SLK:
3193 kbd_ioctl(sc->kbd, KDGKBSTATE, (caddr_t)&f);
3194 if (f & SLKED) {
3195 scp->status |= SLKED;
3196 } else {
3197 if (scp->status & SLKED) {
3198 scp->status &= ~SLKED;
3199#ifndef SC_NO_HISTORY
3200 if (scp->status & BUFFER_SAVED) {
3201 if (!sc_hist_restore(scp))
3202 sc_remove_cutmarking(scp);
3203 scp->status &= ~BUFFER_SAVED;
3204 scp->status |= CURSOR_ENABLED;
3205 sc_draw_cursor_image(scp);
3206 }
3207 tp = VIRTUAL_TTY(sc, scp->index);
3208 if (ISTTYOPEN(tp))
3209 scstart(tp);
3210#endif
3211 }
3212 }
3213 break;
3214
3215 case PASTE:
3216#ifndef SC_NO_CUTPASTE
3217 sc_mouse_paste(scp);
3218#endif
3219 break;
3220
3221 /* NON-LOCKING KEYS */
3222 case NOP:
3223 case LSH: case RSH: case LCTR: case RCTR:
3224 case LALT: case RALT: case ASH: case META:
3225 break;
3226
3227 case BTAB:
3228 if (!(sc->flags & SC_SCRN_BLANKED))
3229 return c;
3230 break;
3231
3232 case SPSC:
3233#ifdef DEV_SPLASH
3234 /* force activatation/deactivation of the screen saver */
3235 if (!(sc->flags & SC_SCRN_BLANKED)) {
3236 run_scrn_saver = TRUE;
3237 sc->scrn_time_stamp -= scrn_blank_time;
3238 }
3239 if (cold) {
3240 /*
3241 * While devices are being probed, the screen saver need
3242 * to be invoked explictly. XXX
3243 */
3244 if (sc->flags & SC_SCRN_BLANKED) {
3245 scsplash_stick(FALSE);
3246 stop_scrn_saver(sc, current_saver);
3247 } else {
3248 if (!ISGRAPHSC(scp)) {
3249 scsplash_stick(TRUE);
3250 (*current_saver)(sc, TRUE);
3251 }
3252 }
3253 }
3254#endif /* DEV_SPLASH */
3255 break;
3256
3257 case RBT:
3258#ifndef SC_DISABLE_REBOOT
3259 shutdown_nice(0);
3260#endif
3261 break;
3262
3263 case HALT:
3264#ifndef SC_DISABLE_REBOOT
3265 shutdown_nice(RB_HALT);
3266#endif
3267 break;
3268
3269 case PDWN:
3270#ifndef SC_DISABLE_REBOOT
3271 shutdown_nice(RB_HALT|RB_POWEROFF);
3272#endif
3273 break;
3274
3275 case SUSP:
3276 power_pm_suspend(POWER_SLEEP_STATE_SUSPEND);
3277 break;
3278 case STBY:
3279 power_pm_suspend(POWER_SLEEP_STATE_STANDBY);
3280 break;
3281
3282 case DBG:
3283#ifndef SC_DISABLE_KDBKEY
3284 kdb_enter("manual escape to debugger");
3285#endif
3286 break;
3287
3288 case PNC:
3289 if (enable_panic_key)
3290 panic("Forced by the panic key");
3291 break;
3292
3293 case NEXT:
3294 this_scr = scp->index;
3295 for (i = (this_scr - sc->first_vty + 1)%sc->vtys;
3296 sc->first_vty + i != this_scr;
3297 i = (i + 1)%sc->vtys) {
3298 struct tty *tp = VIRTUAL_TTY(sc, sc->first_vty + i);
3299 if (ISTTYOPEN(tp)) {
3300 sc_switch_scr(scp->sc, sc->first_vty + i);
3301 break;
3302 }
3303 }
3304 break;
3305
3306 case PREV:
3307 this_scr = scp->index;
3308 for (i = (this_scr - sc->first_vty + sc->vtys - 1)%sc->vtys;
3309 sc->first_vty + i != this_scr;
3310 i = (i + sc->vtys - 1)%sc->vtys) {
3311 struct tty *tp = VIRTUAL_TTY(sc, sc->first_vty + i);
3312 if (ISTTYOPEN(tp)) {
3313 sc_switch_scr(scp->sc, sc->first_vty + i);
3314 break;
3315 }
3316 }
3317 break;
3318
3319 default:
3320 if (KEYCHAR(c) >= F_SCR && KEYCHAR(c) <= L_SCR) {
3321 sc_switch_scr(scp->sc, sc->first_vty + KEYCHAR(c) - F_SCR);
3322 break;
3323 }
3324 /* assert(c & FKEY) */
3325 if (!(sc->flags & SC_SCRN_BLANKED))
3326 return c;
3327 break;
3328 }
3329 /* goto next_code */
3330 } else {
3331 /* regular keys (maybe MKEY is set) */
3332 if (!(sc->flags & SC_SCRN_BLANKED))
3333 return c;
3334 }
3335 }
3336
3337 goto next_code;
3338}
3339
3340static int
3341scmmap(struct cdev *dev, vm_offset_t offset, vm_paddr_t *paddr, int nprot)
3342{
3343 scr_stat *scp;
3344
3345 scp = sc_get_stat(dev);
3346 if (scp != scp->sc->cur_scp)
3347 return -1;
3348 return (*vidsw[scp->sc->adapter]->mmap)(scp->sc->adp, offset, paddr, nprot);
3349}
3350
3351static int
3352save_kbd_state(scr_stat *scp)
3353{
3354 int state;
3355 int error;
3356
3357 error = kbd_ioctl(scp->sc->kbd, KDGKBSTATE, (caddr_t)&state);
3358 if (error == ENOIOCTL)
3359 error = ENODEV;
3360 if (error == 0) {
3361 scp->status &= ~LOCK_MASK;
3362 scp->status |= state;
3363 }
3364 return error;
3365}
3366
3367static int
3368update_kbd_state(scr_stat *scp, int new_bits, int mask)
3369{
3370 int state;
3371 int error;
3372
3373 if (mask != LOCK_MASK) {
3374 error = kbd_ioctl(scp->sc->kbd, KDGKBSTATE, (caddr_t)&state);
3375 if (error == ENOIOCTL)
3376 error = ENODEV;
3377 if (error)
3378 return error;
3379 state &= ~mask;
3380 state |= new_bits & mask;
3381 } else {
3382 state = new_bits & LOCK_MASK;
3383 }
3384 error = kbd_ioctl(scp->sc->kbd, KDSKBSTATE, (caddr_t)&state);
3385 if (error == ENOIOCTL)
3386 error = ENODEV;
3387 return error;
3388}
3389
3390static int
3391update_kbd_leds(scr_stat *scp, int which)
3392{
3393 int error;
3394
3395 which &= LOCK_MASK;
3396 error = kbd_ioctl(scp->sc->kbd, KDSETLED, (caddr_t)&which);
3397 if (error == ENOIOCTL)
3398 error = ENODEV;
3399 return error;
3400}
3401
3402int
3403set_mode(scr_stat *scp)
3404{
3405 video_info_t info;
3406
3407 /* reject unsupported mode */
3408 if ((*vidsw[scp->sc->adapter]->get_info)(scp->sc->adp, scp->mode, &info))
3409 return 1;
3410
3411 /* if this vty is not currently showing, do nothing */
3412 if (scp != scp->sc->cur_scp)
3413 return 0;
3414
3415 /* setup video hardware for the given mode */
3416 (*vidsw[scp->sc->adapter]->set_mode)(scp->sc->adp, scp->mode);
3417#ifndef __sparc64__
3418 sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, scp->xsize, scp->ysize,
3419 (void *)scp->sc->adp->va_window, FALSE);
3420#endif
3421
3422#ifndef SC_NO_FONT_LOADING
3423 /* load appropriate font */
3424 if (!(scp->status & GRAPHICS_MODE)) {
3425 if (!(scp->status & PIXEL_MODE) && ISFONTAVAIL(scp->sc->adp->va_flags)) {
3426 if (scp->font_size < 14) {
3427 if (scp->sc->fonts_loaded & FONT_8)
3428 sc_load_font(scp, 0, 8, scp->sc->font_8, 0, 256);
3429 } else if (scp->font_size >= 16) {
3430 if (scp->sc->fonts_loaded & FONT_16)
3431 sc_load_font(scp, 0, 16, scp->sc->font_16, 0, 256);
3432 } else {
3433 if (scp->sc->fonts_loaded & FONT_14)
3434 sc_load_font(scp, 0, 14, scp->sc->font_14, 0, 256);
3435 }
3436 /*
3437 * FONT KLUDGE:
3438 * This is an interim kludge to display correct font.
3439 * Always use the font page #0 on the video plane 2.
3440 * Somehow we cannot show the font in other font pages on
3441 * some video cards... XXX
3442 */
3443 sc_show_font(scp, 0);
3444 }
3445 mark_all(scp);
3446 }
3447#endif /* !SC_NO_FONT_LOADING */
3448
3449 sc_set_border(scp, scp->border);
3450 sc_set_cursor_image(scp);
3451
3452 return 0;
3453}
3454
3455void
3456sc_set_border(scr_stat *scp, int color)
3457{
3458 ++scp->sc->videoio_in_progress;
3459 (*scp->rndr->draw_border)(scp, color);
3460 --scp->sc->videoio_in_progress;
3461}
3462
3463#ifndef SC_NO_FONT_LOADING
3464void
3465sc_load_font(scr_stat *scp, int page, int size, u_char *buf,
3466 int base, int count)
3467{
3468 sc_softc_t *sc;
3469
3470 sc = scp->sc;
3471 sc->font_loading_in_progress = TRUE;
3472 (*vidsw[sc->adapter]->load_font)(sc->adp, page, size, buf, base, count);
3473 sc->font_loading_in_progress = FALSE;
3474}
3475
3476void
3477sc_save_font(scr_stat *scp, int page, int size, u_char *buf,
3478 int base, int count)
3479{
3480 sc_softc_t *sc;
3481
3482 sc = scp->sc;
3483 sc->font_loading_in_progress = TRUE;
3484 (*vidsw[sc->adapter]->save_font)(sc->adp, page, size, buf, base, count);
3485 sc->font_loading_in_progress = FALSE;
3486}
3487
3488void
3489sc_show_font(scr_stat *scp, int page)
3490{
3491 (*vidsw[scp->sc->adapter]->show_font)(scp->sc->adp, page);
3492}
3493#endif /* !SC_NO_FONT_LOADING */
3494
3495void
3496sc_paste(scr_stat *scp, u_char *p, int count)
3497{
3498 struct tty *tp;
3499 u_char *rmap;
3500
3501 tp = VIRTUAL_TTY(scp->sc, scp->sc->cur_scp->index);
3502 if (!ISTTYOPEN(tp))
3503 return;
3504 rmap = scp->sc->scr_rmap;
3505 for (; count > 0; --count)
3506 ttyld_rint(tp, rmap[*p++]);
3507}
3508
3509void
3510sc_bell(scr_stat *scp, int pitch, int duration)
3511{
3512 if (cold || shutdown_in_progress || !enable_bell)
3513 return;
3514
3515 if (scp != scp->sc->cur_scp && (scp->sc->flags & SC_QUIET_BELL))
3516 return;
3517
3518 if (scp->sc->flags & SC_VISUAL_BELL) {
3519 if (scp->sc->blink_in_progress)
3520 return;
3521 scp->sc->blink_in_progress = 3;
3522 if (scp != scp->sc->cur_scp)
3523 scp->sc->blink_in_progress += 2;
3524 blink_screen(scp->sc->cur_scp);
3525 } else if (duration != 0 && pitch != 0) {
3526 if (scp != scp->sc->cur_scp)
3527 pitch *= 2;
3528 sysbeep(pitch, duration);
3529 }
3530}
3531
3532static void
3533blink_screen(void *arg)
3534{
3535 scr_stat *scp = arg;
3536 struct tty *tp;
3537
3538 if (ISGRAPHSC(scp) || (scp->sc->blink_in_progress <= 1)) {
3539 scp->sc->blink_in_progress = 0;
3540 mark_all(scp);
3541 tp = VIRTUAL_TTY(scp->sc, scp->index);
3542 if (ISTTYOPEN(tp))
3543 scstart(tp);
3544 if (scp->sc->delayed_next_scr)
3545 sc_switch_scr(scp->sc, scp->sc->delayed_next_scr - 1);
3546 }
3547 else {
3548 (*scp->rndr->draw)(scp, 0, scp->xsize*scp->ysize,
3549 scp->sc->blink_in_progress & 1);
3550 scp->sc->blink_in_progress--;
3551 timeout(blink_screen, scp, hz / 10);
3552 }
3553}
3554
3555/*
3556 * Until sc_attach_unit() gets called no dev structures will be available
3557 * to store the per-screen current status. This is the case when the
3558 * kernel is initially booting and needs access to its console. During
3559 * this early phase of booting the console's current status is kept in
3560 * one statically defined scr_stat structure, and any pointers to the
3561 * dev structures will be NULL.
3562 */
3563
3564static scr_stat *
3565sc_get_stat(struct cdev *devptr)
3566{
3567 if (devptr == NULL)
3568 return (&main_console);
3569 return (SC_STAT(devptr));
3570}
| 561 spl0();
562 return(0);
563}
564
565static int
566scread(struct cdev *dev, struct uio *uio, int flag)
567{
568 if (!sc_saver_keyb_only)
569 sc_touch_scrn_saver();
570 return ttyread(dev, uio, flag);
571}
572
573static int
574sckbdevent(keyboard_t *thiskbd, int event, void *arg)
575{
576 sc_softc_t *sc;
577 struct tty *cur_tty;
578 int c;
579 size_t len;
580 u_char *cp;
581
582 sc = (sc_softc_t *)arg;
583 /* assert(thiskbd == sc->kbd) */
584
585 switch (event) {
586 case KBDIO_KEYINPUT:
587 break;
588 case KBDIO_UNLOADING:
589 sc->kbd = NULL;
590 sc->keyboard = -1;
591 kbd_release(thiskbd, (void *)&sc->keyboard);
592 return 0;
593 default:
594 return EINVAL;
595 }
596
597 /*
598 * Loop while there is still input to get from the keyboard.
599 * I don't think this is nessesary, and it doesn't fix
600 * the Xaccel-2.1 keyboard hang, but it can't hurt. XXX
601 */
602 while ((c = scgetc(sc, SCGETC_NONBLOCK)) != NOKEY) {
603
604 cur_tty = VIRTUAL_TTY(sc, sc->cur_scp->index);
605 if (!ISTTYOPEN(cur_tty)) {
606 cur_tty = sc_console_tty;
607 if (!ISTTYOPEN(cur_tty))
608 continue;
609 }
610
611 if ((*sc->cur_scp->tsw->te_input)(sc->cur_scp, c, cur_tty))
612 continue;
613
614 switch (KEYFLAGS(c)) {
615 case 0x0000: /* normal key */
616 ttyld_rint(cur_tty, KEYCHAR(c));
617 break;
618 case FKEY: /* function key, return string */
619 cp = kbd_get_fkeystr(thiskbd, KEYCHAR(c), &len);
620 if (cp != NULL) {
621 while (len-- > 0)
622 ttyld_rint(cur_tty, *cp++);
623 }
624 break;
625 case MKEY: /* meta is active, prepend ESC */
626 ttyld_rint(cur_tty, 0x1b);
627 ttyld_rint(cur_tty, KEYCHAR(c));
628 break;
629 case BKEY: /* backtab fixed sequence (esc [ Z) */
630 ttyld_rint(cur_tty, 0x1b);
631 ttyld_rint(cur_tty, '[');
632 ttyld_rint(cur_tty, 'Z');
633 break;
634 }
635 }
636
637 sc->cur_scp->status |= MOUSE_HIDDEN;
638
639 return 0;
640}
641
642static int
643scparam(struct tty *tp, struct termios *t)
644{
645 tp->t_ispeed = t->c_ispeed;
646 tp->t_ospeed = t->c_ospeed;
647 tp->t_cflag = t->c_cflag;
648 return 0;
649}
650
651static int
652scioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td)
653{
654 int error;
655 int i;
656 struct tty *tp;
657 sc_softc_t *sc;
658 scr_stat *scp;
659 int s;
660
661 tp = dev->si_tty;
662
663 /* If there is a user_ioctl function call that first */
664 if (sc_user_ioctl) {
665 error = (*sc_user_ioctl)(dev, cmd, data, flag, td);
666 if (error != ENOIOCTL)
667 return error;
668 }
669
670 error = sc_vid_ioctl(tp, cmd, data, flag, td);
671 if (error != ENOIOCTL)
672 return error;
673
674#ifndef SC_NO_HISTORY
675 error = sc_hist_ioctl(tp, cmd, data, flag, td);
676 if (error != ENOIOCTL)
677 return error;
678#endif
679
680#ifndef SC_NO_SYSMOUSE
681 error = sc_mouse_ioctl(tp, cmd, data, flag, td);
682 if (error != ENOIOCTL)
683 return error;
684#endif
685
686 scp = sc_get_stat(tp->t_dev);
687 /* assert(scp != NULL) */
688 /* scp is sc_console, if SC_VTY(dev) == SC_CONSOLECTL. */
689 sc = scp->sc;
690
691 if (scp->tsw) {
692 error = (*scp->tsw->te_ioctl)(scp, tp, cmd, data, flag, td);
693 if (error != ENOIOCTL)
694 return error;
695 }
696
697 switch (cmd) { /* process console hardware related ioctl's */
698
699 case GIO_ATTR: /* get current attributes */
700 /* this ioctl is not processed here, but in the terminal emulator */
701 return ENOTTY;
702
703 case GIO_COLOR: /* is this a color console ? */
704 *(int *)data = (sc->adp->va_flags & V_ADP_COLOR) ? 1 : 0;
705 return 0;
706
707 case CONS_BLANKTIME: /* set screen saver timeout (0 = no saver) */
708 if (*(int *)data < 0 || *(int *)data > MAX_BLANKTIME)
709 return EINVAL;
710 s = spltty();
711 scrn_blank_time = *(int *)data;
712 run_scrn_saver = (scrn_blank_time != 0);
713 splx(s);
714 return 0;
715
716 case CONS_CURSORTYPE: /* set cursor type (obsolete) */
717 s = spltty();
718 *(int *)data &= CONS_CURSOR_ATTRS;
719 sc_change_cursor_shape(scp, *(int *)data, -1, -1);
720 splx(s);
721 return 0;
722
723 case CONS_GETCURSORSHAPE: /* get cursor shape (new interface) */
724 if (((int *)data)[0] & CONS_LOCAL_CURSOR) {
725 ((int *)data)[0] = scp->curr_curs_attr.flags;
726 ((int *)data)[1] = scp->curr_curs_attr.base;
727 ((int *)data)[2] = scp->curr_curs_attr.height;
728 } else {
729 ((int *)data)[0] = sc->curs_attr.flags;
730 ((int *)data)[1] = sc->curs_attr.base;
731 ((int *)data)[2] = sc->curs_attr.height;
732 }
733 return 0;
734
735 case CONS_SETCURSORSHAPE: /* set cursor shape (new interface) */
736 s = spltty();
737 sc_change_cursor_shape(scp, ((int *)data)[0],
738 ((int *)data)[1], ((int *)data)[2]);
739 splx(s);
740 return 0;
741
742 case CONS_BELLTYPE: /* set bell type sound/visual */
743 if ((*(int *)data) & 0x01)
744 sc->flags |= SC_VISUAL_BELL;
745 else
746 sc->flags &= ~SC_VISUAL_BELL;
747 if ((*(int *)data) & 0x02)
748 sc->flags |= SC_QUIET_BELL;
749 else
750 sc->flags &= ~SC_QUIET_BELL;
751 return 0;
752
753 case CONS_GETINFO: /* get current (virtual) console info */
754 {
755 vid_info_t *ptr = (vid_info_t*)data;
756 if (ptr->size == sizeof(struct vid_info)) {
757 ptr->m_num = sc->cur_scp->index;
758 ptr->font_size = scp->font_size;
759 ptr->mv_col = scp->xpos;
760 ptr->mv_row = scp->ypos;
761 ptr->mv_csz = scp->xsize;
762 ptr->mv_rsz = scp->ysize;
763 ptr->mv_hsz = (scp->history != NULL) ? scp->history->vtb_rows : 0;
764 /*
765 * The following fields are filled by the terminal emulator. XXX
766 *
767 * ptr->mv_norm.fore
768 * ptr->mv_norm.back
769 * ptr->mv_rev.fore
770 * ptr->mv_rev.back
771 */
772 ptr->mv_grfc.fore = 0; /* not supported */
773 ptr->mv_grfc.back = 0; /* not supported */
774 ptr->mv_ovscan = scp->border;
775 if (scp == sc->cur_scp)
776 save_kbd_state(scp);
777 ptr->mk_keylock = scp->status & LOCK_MASK;
778 return 0;
779 }
780 return EINVAL;
781 }
782
783 case CONS_GETVERS: /* get version number */
784 *(int*)data = 0x200; /* version 2.0 */
785 return 0;
786
787 case CONS_IDLE: /* see if the screen has been idle */
788 /*
789 * When the screen is in the GRAPHICS_MODE or UNKNOWN_MODE,
790 * the user process may have been writing something on the
791 * screen and syscons is not aware of it. Declare the screen
792 * is NOT idle if it is in one of these modes. But there is
793 * an exception to it; if a screen saver is running in the
794 * graphics mode in the current screen, we should say that the
795 * screen has been idle.
796 */
797 *(int *)data = (sc->flags & SC_SCRN_IDLE)
798 && (!ISGRAPHSC(sc->cur_scp)
799 || (sc->cur_scp->status & SAVER_RUNNING));
800 return 0;
801
802 case CONS_SAVERMODE: /* set saver mode */
803 switch(*(int *)data) {
804 case CONS_NO_SAVER:
805 case CONS_USR_SAVER:
806 /* if a LKM screen saver is running, stop it first. */
807 scsplash_stick(FALSE);
808 saver_mode = *(int *)data;
809 s = spltty();
810#ifdef DEV_SPLASH
811 if ((error = wait_scrn_saver_stop(NULL))) {
812 splx(s);
813 return error;
814 }
815#endif
816 run_scrn_saver = TRUE;
817 if (saver_mode == CONS_USR_SAVER)
818 scp->status |= SAVER_RUNNING;
819 else
820 scp->status &= ~SAVER_RUNNING;
821 scsplash_stick(TRUE);
822 splx(s);
823 break;
824 case CONS_LKM_SAVER:
825 s = spltty();
826 if ((saver_mode == CONS_USR_SAVER) && (scp->status & SAVER_RUNNING))
827 scp->status &= ~SAVER_RUNNING;
828 saver_mode = *(int *)data;
829 splx(s);
830 break;
831 default:
832 return EINVAL;
833 }
834 return 0;
835
836 case CONS_SAVERSTART: /* immediately start/stop the screen saver */
837 /*
838 * Note that this ioctl does not guarantee the screen saver
839 * actually starts or stops. It merely attempts to do so...
840 */
841 s = spltty();
842 run_scrn_saver = (*(int *)data != 0);
843 if (run_scrn_saver)
844 sc->scrn_time_stamp -= scrn_blank_time;
845 splx(s);
846 return 0;
847
848 case CONS_SCRSHOT: /* get a screen shot */
849 {
850 int retval, hist_rsz;
851 size_t lsize, csize;
852 vm_offset_t frbp, hstp;
853 unsigned lnum;
854 scrshot_t *ptr = (scrshot_t *)data;
855 void *outp = ptr->buf;
856
857 s = spltty();
858 if (ISGRAPHSC(scp)) {
859 splx(s);
860 return EOPNOTSUPP;
861 }
862 hist_rsz = (scp->history != NULL) ? scp->history->vtb_rows : 0;
863 if ((ptr->x + ptr->xsize) > scp->xsize ||
864 (ptr->y + ptr->ysize) > (scp->ysize + hist_rsz)) {
865 splx(s);
866 return EINVAL;
867 }
868
869 lsize = scp->xsize * sizeof(u_int16_t);
870 csize = ptr->xsize * sizeof(u_int16_t);
871 /* Pointer to the last line of framebuffer */
872 frbp = scp->vtb.vtb_buffer + scp->ysize * lsize + ptr->x *
873 sizeof(u_int16_t);
874 /* Pointer to the last line of target buffer */
875 (vm_offset_t)outp += ptr->ysize * csize;
876 /* Pointer to the last line of history buffer */
877 if (scp->history != NULL)
878 hstp = scp->history->vtb_buffer + sc_vtb_tail(scp->history) *
879 sizeof(u_int16_t) + ptr->x * sizeof(u_int16_t);
880 else
881 hstp = 0;
882
883 retval = 0;
884 for (lnum = 0; lnum < (ptr->y + ptr->ysize); lnum++) {
885 if (lnum < scp->ysize) {
886 frbp -= lsize;
887 } else {
888 hstp -= lsize;
889 if (hstp < scp->history->vtb_buffer)
890 hstp += scp->history->vtb_rows * lsize;
891 frbp = hstp;
892 }
893 if (lnum < ptr->y)
894 continue;
895 (vm_offset_t)outp -= csize;
896 retval = copyout((void *)frbp, outp, csize);
897 if (retval != 0)
898 break;
899 }
900 splx(s);
901 return retval;
902 }
903
904 case VT_SETMODE: /* set screen switcher mode */
905 {
906 struct vt_mode *mode;
907 struct proc *p1;
908
909 mode = (struct vt_mode *)data;
910 DPRINTF(5, ("sc%d: VT_SETMODE ", sc->unit));
911 if (scp->smode.mode == VT_PROCESS) {
912 p1 = pfind(scp->pid);
913 if (scp->proc == p1 && scp->proc != td->td_proc) {
914 if (p1)
915 PROC_UNLOCK(p1);
916 DPRINTF(5, ("error EPERM\n"));
917 return EPERM;
918 }
919 if (p1)
920 PROC_UNLOCK(p1);
921 }
922 s = spltty();
923 if (mode->mode == VT_AUTO) {
924 scp->smode.mode = VT_AUTO;
925 scp->proc = NULL;
926 scp->pid = 0;
927 DPRINTF(5, ("VT_AUTO, "));
928 if ((scp == sc->cur_scp) && (sc->unit == sc_console_unit))
929 cnavailable(sc_consptr, TRUE);
930 /* were we in the middle of the vty switching process? */
931 if (finish_vt_rel(scp, TRUE, &s) == 0)
932 DPRINTF(5, ("reset WAIT_REL, "));
933 if (finish_vt_acq(scp) == 0)
934 DPRINTF(5, ("reset WAIT_ACQ, "));
935 } else {
936 if (!ISSIGVALID(mode->relsig) || !ISSIGVALID(mode->acqsig)
937 || !ISSIGVALID(mode->frsig)) {
938 splx(s);
939 DPRINTF(5, ("error EINVAL\n"));
940 return EINVAL;
941 }
942 DPRINTF(5, ("VT_PROCESS %d, ", td->td_proc->p_pid));
943 bcopy(data, &scp->smode, sizeof(struct vt_mode));
944 scp->proc = td->td_proc;
945 scp->pid = scp->proc->p_pid;
946 if ((scp == sc->cur_scp) && (sc->unit == sc_console_unit))
947 cnavailable(sc_consptr, FALSE);
948 }
949 splx(s);
950 DPRINTF(5, ("\n"));
951 return 0;
952 }
953
954 case VT_GETMODE: /* get screen switcher mode */
955 bcopy(&scp->smode, data, sizeof(struct vt_mode));
956 return 0;
957
958 case VT_RELDISP: /* screen switcher ioctl */
959 s = spltty();
960 /*
961 * This must be the current vty which is in the VT_PROCESS
962 * switching mode...
963 */
964 if ((scp != sc->cur_scp) || (scp->smode.mode != VT_PROCESS)) {
965 splx(s);
966 return EINVAL;
967 }
968 /* ...and this process is controlling it. */
969 if (scp->proc != td->td_proc) {
970 splx(s);
971 return EPERM;
972 }
973 error = EINVAL;
974 switch(*(intptr_t *)data) {
975 case VT_FALSE: /* user refuses to release screen, abort */
976 if ((error = finish_vt_rel(scp, FALSE, &s)) == 0)
977 DPRINTF(5, ("sc%d: VT_FALSE\n", sc->unit));
978 break;
979 case VT_TRUE: /* user has released screen, go on */
980 if ((error = finish_vt_rel(scp, TRUE, &s)) == 0)
981 DPRINTF(5, ("sc%d: VT_TRUE\n", sc->unit));
982 break;
983 case VT_ACKACQ: /* acquire acknowledged, switch completed */
984 if ((error = finish_vt_acq(scp)) == 0)
985 DPRINTF(5, ("sc%d: VT_ACKACQ\n", sc->unit));
986 break;
987 default:
988 break;
989 }
990 splx(s);
991 return error;
992
993 case VT_OPENQRY: /* return free virtual console */
994 for (i = sc->first_vty; i < sc->first_vty + sc->vtys; i++) {
995 tp = VIRTUAL_TTY(sc, i);
996 if (!ISTTYOPEN(tp)) {
997 *(int *)data = i + 1;
998 return 0;
999 }
1000 }
1001 return EINVAL;
1002
1003 case VT_ACTIVATE: /* switch to screen *data */
1004 i = (*(intptr_t *)data == 0) ? scp->index : (*(intptr_t *)data - 1);
1005 s = spltty();
1006 sc_clean_up(sc->cur_scp);
1007 splx(s);
1008 return sc_switch_scr(sc, i);
1009
1010 case VT_WAITACTIVE: /* wait for switch to occur */
1011 i = (*(intptr_t *)data == 0) ? scp->index : (*(intptr_t *)data - 1);
1012 if ((i < sc->first_vty) || (i >= sc->first_vty + sc->vtys))
1013 return EINVAL;
1014 s = spltty();
1015 error = sc_clean_up(sc->cur_scp);
1016 splx(s);
1017 if (error)
1018 return error;
1019 scp = sc_get_stat(SC_DEV(sc, i));
1020 if (scp == scp->sc->cur_scp)
1021 return 0;
1022 while ((error=tsleep(&scp->smode, PZERO|PCATCH,
1023 "waitvt", 0)) == ERESTART) ;
1024 return error;
1025
1026 case VT_GETACTIVE: /* get active vty # */
1027 *(int *)data = sc->cur_scp->index + 1;
1028 return 0;
1029
1030 case VT_GETINDEX: /* get this vty # */
1031 *(int *)data = scp->index + 1;
1032 return 0;
1033
1034 case VT_LOCKSWITCH: /* prevent vty switching */
1035 if ((*(int *)data) & 0x01)
1036 sc->flags |= SC_SCRN_VTYLOCK;
1037 else
1038 sc->flags &= ~SC_SCRN_VTYLOCK;
1039 return 0;
1040
1041 case KDENABIO: /* allow io operations */
1042 error = suser(td);
1043 if (error != 0)
1044 return error;
1045 error = securelevel_gt(td->td_ucred, 0);
1046 if (error != 0)
1047 return error;
1048#ifdef __i386__
1049 td->td_frame->tf_eflags |= PSL_IOPL;
1050#endif
1051 return 0;
1052
1053 case KDDISABIO: /* disallow io operations (default) */
1054#ifdef __i386__
1055 td->td_frame->tf_eflags &= ~PSL_IOPL;
1056#endif
1057 return 0;
1058
1059 case KDSKBSTATE: /* set keyboard state (locks) */
1060 if (*(int *)data & ~LOCK_MASK)
1061 return EINVAL;
1062 scp->status &= ~LOCK_MASK;
1063 scp->status |= *(int *)data;
1064 if (scp == sc->cur_scp)
1065 update_kbd_state(scp, scp->status, LOCK_MASK);
1066 return 0;
1067
1068 case KDGKBSTATE: /* get keyboard state (locks) */
1069 if (scp == sc->cur_scp)
1070 save_kbd_state(scp);
1071 *(int *)data = scp->status & LOCK_MASK;
1072 return 0;
1073
1074 case KDGETREPEAT: /* get keyboard repeat & delay rates */
1075 case KDSETREPEAT: /* set keyboard repeat & delay rates (new) */
1076 error = kbd_ioctl(sc->kbd, cmd, data);
1077 if (error == ENOIOCTL)
1078 error = ENODEV;
1079 return error;
1080
1081 case KDSETRAD: /* set keyboard repeat & delay rates (old) */
1082 if (*(int *)data & ~0x7f)
1083 return EINVAL;
1084 error = kbd_ioctl(sc->kbd, cmd, data);
1085 if (error == ENOIOCTL)
1086 error = ENODEV;
1087 return error;
1088
1089 case KDSKBMODE: /* set keyboard mode */
1090 switch (*(int *)data) {
1091 case K_XLATE: /* switch to XLT ascii mode */
1092 case K_RAW: /* switch to RAW scancode mode */
1093 case K_CODE: /* switch to CODE mode */
1094 scp->kbd_mode = *(int *)data;
1095 if (scp == sc->cur_scp)
1096 kbd_ioctl(sc->kbd, cmd, data);
1097 return 0;
1098 default:
1099 return EINVAL;
1100 }
1101 /* NOT REACHED */
1102
1103 case KDGKBMODE: /* get keyboard mode */
1104 *(int *)data = scp->kbd_mode;
1105 return 0;
1106
1107 case KDGKBINFO:
1108 error = kbd_ioctl(sc->kbd, cmd, data);
1109 if (error == ENOIOCTL)
1110 error = ENODEV;
1111 return error;
1112
1113 case KDMKTONE: /* sound the bell */
1114 if (*(int*)data)
1115 sc_bell(scp, (*(int*)data)&0xffff,
1116 (((*(int*)data)>>16)&0xffff)*hz/1000);
1117 else
1118 sc_bell(scp, scp->bell_pitch, scp->bell_duration);
1119 return 0;
1120
1121 case KIOCSOUND: /* make tone (*data) hz */
1122 if (scp == sc->cur_scp) {
1123 if (*(int *)data)
1124 return sc_tone(*(int *)data);
1125 else
1126 return sc_tone(0);
1127 }
1128 return 0;
1129
1130 case KDGKBTYPE: /* get keyboard type */
1131 error = kbd_ioctl(sc->kbd, cmd, data);
1132 if (error == ENOIOCTL) {
1133 /* always return something? XXX */
1134 *(int *)data = 0;
1135 }
1136 return 0;
1137
1138 case KDSETLED: /* set keyboard LED status */
1139 if (*(int *)data & ~LED_MASK) /* FIXME: LOCK_MASK? */
1140 return EINVAL;
1141 scp->status &= ~LED_MASK;
1142 scp->status |= *(int *)data;
1143 if (scp == sc->cur_scp)
1144 update_kbd_leds(scp, scp->status);
1145 return 0;
1146
1147 case KDGETLED: /* get keyboard LED status */
1148 if (scp == sc->cur_scp)
1149 save_kbd_state(scp);
1150 *(int *)data = scp->status & LED_MASK;
1151 return 0;
1152
1153 case CONS_SETKBD: /* set the new keyboard */
1154 {
1155 keyboard_t *newkbd;
1156
1157 s = spltty();
1158 newkbd = kbd_get_keyboard(*(int *)data);
1159 if (newkbd == NULL) {
1160 splx(s);
1161 return EINVAL;
1162 }
1163 error = 0;
1164 if (sc->kbd != newkbd) {
1165 i = kbd_allocate(newkbd->kb_name, newkbd->kb_unit,
1166 (void *)&sc->keyboard, sckbdevent, sc);
1167 /* i == newkbd->kb_index */
1168 if (i >= 0) {
1169 if (sc->kbd != NULL) {
1170 save_kbd_state(sc->cur_scp);
1171 kbd_release(sc->kbd, (void *)&sc->keyboard);
1172 }
1173 sc->kbd = kbd_get_keyboard(i); /* sc->kbd == newkbd */
1174 sc->keyboard = i;
1175 kbd_ioctl(sc->kbd, KDSKBMODE,
1176 (caddr_t)&sc->cur_scp->kbd_mode);
1177 update_kbd_state(sc->cur_scp, sc->cur_scp->status,
1178 LOCK_MASK);
1179 } else {
1180 error = EPERM; /* XXX */
1181 }
1182 }
1183 splx(s);
1184 return error;
1185 }
1186
1187 case CONS_RELKBD: /* release the current keyboard */
1188 s = spltty();
1189 error = 0;
1190 if (sc->kbd != NULL) {
1191 save_kbd_state(sc->cur_scp);
1192 error = kbd_release(sc->kbd, (void *)&sc->keyboard);
1193 if (error == 0) {
1194 sc->kbd = NULL;
1195 sc->keyboard = -1;
1196 }
1197 }
1198 splx(s);
1199 return error;
1200
1201 case CONS_GETTERM: /* get the current terminal emulator info */
1202 {
1203 sc_term_sw_t *sw;
1204
1205 if (((term_info_t *)data)->ti_index == 0) {
1206 sw = scp->tsw;
1207 } else {
1208 sw = sc_term_match_by_number(((term_info_t *)data)->ti_index);
1209 }
1210 if (sw != NULL) {
1211 strncpy(((term_info_t *)data)->ti_name, sw->te_name,
1212 sizeof(((term_info_t *)data)->ti_name));
1213 strncpy(((term_info_t *)data)->ti_desc, sw->te_desc,
1214 sizeof(((term_info_t *)data)->ti_desc));
1215 ((term_info_t *)data)->ti_flags = 0;
1216 return 0;
1217 } else {
1218 ((term_info_t *)data)->ti_name[0] = '\0';
1219 ((term_info_t *)data)->ti_desc[0] = '\0';
1220 ((term_info_t *)data)->ti_flags = 0;
1221 return EINVAL;
1222 }
1223 }
1224
1225 case CONS_SETTERM: /* set the current terminal emulator */
1226 s = spltty();
1227 error = sc_init_emulator(scp, ((term_info_t *)data)->ti_name);
1228 /* FIXME: what if scp == sc_console! XXX */
1229 splx(s);
1230 return error;
1231
1232 case GIO_SCRNMAP: /* get output translation table */
1233 bcopy(&sc->scr_map, data, sizeof(sc->scr_map));
1234 return 0;
1235
1236 case PIO_SCRNMAP: /* set output translation table */
1237 bcopy(data, &sc->scr_map, sizeof(sc->scr_map));
1238 for (i=0; i<sizeof(sc->scr_map); i++) {
1239 sc->scr_rmap[sc->scr_map[i]] = i;
1240 }
1241 return 0;
1242
1243 case GIO_KEYMAP: /* get keyboard translation table */
1244 case PIO_KEYMAP: /* set keyboard translation table */
1245 case GIO_DEADKEYMAP: /* get accent key translation table */
1246 case PIO_DEADKEYMAP: /* set accent key translation table */
1247 case GETFKEY: /* get function key string */
1248 case SETFKEY: /* set function key string */
1249 error = kbd_ioctl(sc->kbd, cmd, data);
1250 if (error == ENOIOCTL)
1251 error = ENODEV;
1252 return error;
1253
1254#ifndef SC_NO_FONT_LOADING
1255
1256 case PIO_FONT8x8: /* set 8x8 dot font */
1257 if (!ISFONTAVAIL(sc->adp->va_flags))
1258 return ENXIO;
1259 bcopy(data, sc->font_8, 8*256);
1260 sc->fonts_loaded |= FONT_8;
1261 /*
1262 * FONT KLUDGE
1263 * Always use the font page #0. XXX
1264 * Don't load if the current font size is not 8x8.
1265 */
1266 if (ISTEXTSC(sc->cur_scp) && (sc->cur_scp->font_size < 14))
1267 sc_load_font(sc->cur_scp, 0, 8, sc->font_8, 0, 256);
1268 return 0;
1269
1270 case GIO_FONT8x8: /* get 8x8 dot font */
1271 if (!ISFONTAVAIL(sc->adp->va_flags))
1272 return ENXIO;
1273 if (sc->fonts_loaded & FONT_8) {
1274 bcopy(sc->font_8, data, 8*256);
1275 return 0;
1276 }
1277 else
1278 return ENXIO;
1279
1280 case PIO_FONT8x14: /* set 8x14 dot font */
1281 if (!ISFONTAVAIL(sc->adp->va_flags))
1282 return ENXIO;
1283 bcopy(data, sc->font_14, 14*256);
1284 sc->fonts_loaded |= FONT_14;
1285 /*
1286 * FONT KLUDGE
1287 * Always use the font page #0. XXX
1288 * Don't load if the current font size is not 8x14.
1289 */
1290 if (ISTEXTSC(sc->cur_scp)
1291 && (sc->cur_scp->font_size >= 14)
1292 && (sc->cur_scp->font_size < 16))
1293 sc_load_font(sc->cur_scp, 0, 14, sc->font_14, 0, 256);
1294 return 0;
1295
1296 case GIO_FONT8x14: /* get 8x14 dot font */
1297 if (!ISFONTAVAIL(sc->adp->va_flags))
1298 return ENXIO;
1299 if (sc->fonts_loaded & FONT_14) {
1300 bcopy(sc->font_14, data, 14*256);
1301 return 0;
1302 }
1303 else
1304 return ENXIO;
1305
1306 case PIO_FONT8x16: /* set 8x16 dot font */
1307 if (!ISFONTAVAIL(sc->adp->va_flags))
1308 return ENXIO;
1309 bcopy(data, sc->font_16, 16*256);
1310 sc->fonts_loaded |= FONT_16;
1311 /*
1312 * FONT KLUDGE
1313 * Always use the font page #0. XXX
1314 * Don't load if the current font size is not 8x16.
1315 */
1316 if (ISTEXTSC(sc->cur_scp) && (sc->cur_scp->font_size >= 16))
1317 sc_load_font(sc->cur_scp, 0, 16, sc->font_16, 0, 256);
1318 return 0;
1319
1320 case GIO_FONT8x16: /* get 8x16 dot font */
1321 if (!ISFONTAVAIL(sc->adp->va_flags))
1322 return ENXIO;
1323 if (sc->fonts_loaded & FONT_16) {
1324 bcopy(sc->font_16, data, 16*256);
1325 return 0;
1326 }
1327 else
1328 return ENXIO;
1329
1330#endif /* SC_NO_FONT_LOADING */
1331
1332#ifdef PC98
1333 case ADJUST_CLOCK: /* /dev/rtc for 98note resume */
1334 inittodr(0);
1335 return 0;
1336#endif
1337
1338 default:
1339 break;
1340 }
1341
1342 return (ttyioctl(dev, cmd, data, flag, td));
1343}
1344
1345static void
1346scstart(struct tty *tp)
1347{
1348 struct clist *rbp;
1349 int s, len;
1350 u_char buf[PCBURST];
1351 scr_stat *scp = sc_get_stat(tp->t_dev);
1352
1353 if (scp->status & SLKED ||
1354 (scp == scp->sc->cur_scp && scp->sc->blink_in_progress))
1355 return;
1356 s = spltty();
1357 if (!(tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP))) {
1358 tp->t_state |= TS_BUSY;
1359 rbp = &tp->t_outq;
1360 while (rbp->c_cc) {
1361 len = q_to_b(rbp, buf, PCBURST);
1362 splx(s);
1363 sc_puts(scp, buf, len);
1364 s = spltty();
1365 }
1366 tp->t_state &= ~TS_BUSY;
1367 ttwwakeup(tp);
1368 }
1369 splx(s);
1370}
1371
1372static void
1373sccnprobe(struct consdev *cp)
1374{
1375 int unit;
1376 int flags;
1377
1378 cp->cn_pri = sc_get_cons_priority(&unit, &flags);
1379
1380 /* a video card is always required */
1381 if (!scvidprobe(unit, flags, TRUE))
1382 cp->cn_pri = CN_DEAD;
1383
1384 /* syscons will become console even when there is no keyboard */
1385 sckbdprobe(unit, flags, TRUE);
1386
1387 if (cp->cn_pri == CN_DEAD)
1388 return;
1389
1390 /* initialize required fields */
1391 sprintf(cp->cn_name, "consolectl");
1392}
1393
1394static void
1395sccninit(struct consdev *cp)
1396{
1397 int unit;
1398 int flags;
1399
1400 sc_get_cons_priority(&unit, &flags);
1401 scinit(unit, flags | SC_KERNEL_CONSOLE);
1402 sc_console_unit = unit;
1403 sc_console = sc_get_stat(sc_get_softc(unit, SC_KERNEL_CONSOLE)->dev[0]);
1404 sc_consptr = cp;
1405}
1406
1407static void
1408sccnterm(struct consdev *cp)
1409{
1410 /* we are not the kernel console any more, release everything */
1411
1412 if (sc_console_unit < 0)
1413 return; /* shouldn't happen */
1414
1415#if 0 /* XXX */
1416 sc_clear_screen(sc_console);
1417 sccnupdate(sc_console);
1418#endif
1419
1420 scterm(sc_console_unit, SC_KERNEL_CONSOLE);
1421 sc_console_unit = -1;
1422 sc_console = NULL;
1423}
1424
1425static void
1426sccnputc(struct consdev *cd, int c)
1427{
1428 u_char buf[1];
1429 scr_stat *scp = sc_console;
1430 void *save;
1431#ifndef SC_NO_HISTORY
1432 struct tty *tp;
1433#endif /* !SC_NO_HISTORY */
1434 int s;
1435
1436 /* assert(sc_console != NULL) */
1437
1438#ifndef SC_NO_HISTORY
1439 if (scp == scp->sc->cur_scp && scp->status & SLKED) {
1440 scp->status &= ~SLKED;
1441 update_kbd_state(scp, scp->status, SLKED);
1442 if (scp->status & BUFFER_SAVED) {
1443 if (!sc_hist_restore(scp))
1444 sc_remove_cutmarking(scp);
1445 scp->status &= ~BUFFER_SAVED;
1446 scp->status |= CURSOR_ENABLED;
1447 sc_draw_cursor_image(scp);
1448 }
1449 tp = VIRTUAL_TTY(scp->sc, scp->index);
1450 if (ISTTYOPEN(tp))
1451 scstart(tp);
1452 }
1453#endif /* !SC_NO_HISTORY */
1454
1455 save = scp->ts;
1456 if (kernel_console_ts != NULL)
1457 scp->ts = kernel_console_ts;
1458 buf[0] = c;
1459 sc_puts(scp, buf, 1);
1460 scp->ts = save;
1461
1462 s = spltty(); /* block sckbdevent and scrn_timer */
1463 sccnupdate(scp);
1464 splx(s);
1465}
1466
1467static int
1468sccngetc(struct consdev *cd)
1469{
1470 return sccngetch(0);
1471}
1472
1473static int
1474sccncheckc(struct consdev *cd)
1475{
1476 return sccngetch(SCGETC_NONBLOCK);
1477}
1478
1479static void
1480sccndbctl(struct consdev *cd, int on)
1481{
1482 /* assert(sc_console_unit >= 0) */
1483 /* try to switch to the kernel console screen */
1484 if (on && debugger == 0) {
1485 /*
1486 * TRY to make sure the screen saver is stopped,
1487 * and the screen is updated before switching to
1488 * the vty0.
1489 */
1490 scrn_timer(NULL);
1491 if (!cold
1492 && sc_console->sc->cur_scp->smode.mode == VT_AUTO
1493 && sc_console->smode.mode == VT_AUTO) {
1494 sc_console->sc->cur_scp->status |= MOUSE_HIDDEN;
1495 ++debugger; /* XXX */
1496#ifdef DDB
1497 /* unlock vty switching */
1498 sc_console->sc->flags &= ~SC_SCRN_VTYLOCK;
1499#endif
1500 sc_switch_scr(sc_console->sc, sc_console->index);
1501 --debugger; /* XXX */
1502 }
1503 }
1504 if (on)
1505 ++debugger;
1506 else
1507 --debugger;
1508}
1509
1510static int
1511sccngetch(int flags)
1512{
1513 static struct fkeytab fkey;
1514 static int fkeycp;
1515 scr_stat *scp;
1516 u_char *p;
1517 int cur_mode;
1518 int s = spltty(); /* block sckbdevent and scrn_timer while we poll */
1519 int c;
1520
1521 /* assert(sc_console != NULL) */
1522
1523 /*
1524 * Stop the screen saver and update the screen if necessary.
1525 * What if we have been running in the screen saver code... XXX
1526 */
1527 sc_touch_scrn_saver();
1528 scp = sc_console->sc->cur_scp; /* XXX */
1529 sccnupdate(scp);
1530
1531 if (fkeycp < fkey.len) {
1532 splx(s);
1533 return fkey.str[fkeycp++];
1534 }
1535
1536 if (scp->sc->kbd == NULL) {
1537 splx(s);
1538 return -1;
1539 }
1540
1541 /*
1542 * Make sure the keyboard is accessible even when the kbd device
1543 * driver is disabled.
1544 */
1545 kbd_enable(scp->sc->kbd);
1546
1547 /* we shall always use the keyboard in the XLATE mode here */
1548 cur_mode = scp->kbd_mode;
1549 scp->kbd_mode = K_XLATE;
1550 kbd_ioctl(scp->sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
1551
1552 kbd_poll(scp->sc->kbd, TRUE);
1553 c = scgetc(scp->sc, SCGETC_CN | flags);
1554 kbd_poll(scp->sc->kbd, FALSE);
1555
1556 scp->kbd_mode = cur_mode;
1557 kbd_ioctl(scp->sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
1558 kbd_disable(scp->sc->kbd);
1559 splx(s);
1560
1561 switch (KEYFLAGS(c)) {
1562 case 0: /* normal char */
1563 return KEYCHAR(c);
1564 case FKEY: /* function key */
1565 p = kbd_get_fkeystr(scp->sc->kbd, KEYCHAR(c), (size_t *)&fkeycp);
1566 fkey.len = fkeycp;
1567 if ((p != NULL) && (fkey.len > 0)) {
1568 bcopy(p, fkey.str, fkey.len);
1569 fkeycp = 1;
1570 return fkey.str[0];
1571 }
1572 return c; /* XXX */
1573 case NOKEY:
1574 case ERRKEY:
1575 default:
1576 return -1;
1577 }
1578 /* NOT REACHED */
1579}
1580
1581static void
1582sccnupdate(scr_stat *scp)
1583{
1584 /* this is a cut-down version of scrn_timer()... */
1585
1586 if (scp->sc->font_loading_in_progress || scp->sc->videoio_in_progress)
1587 return;
1588
1589 if (debugger > 0 || panicstr || shutdown_in_progress) {
1590 sc_touch_scrn_saver();
1591 } else if (scp != scp->sc->cur_scp) {
1592 return;
1593 }
1594
1595 if (!run_scrn_saver)
1596 scp->sc->flags &= ~SC_SCRN_IDLE;
1597#ifdef DEV_SPLASH
1598 if ((saver_mode != CONS_LKM_SAVER) || !(scp->sc->flags & SC_SCRN_IDLE))
1599 if (scp->sc->flags & SC_SCRN_BLANKED)
1600 stop_scrn_saver(scp->sc, current_saver);
1601#endif
1602
1603 if (scp != scp->sc->cur_scp || scp->sc->blink_in_progress
1604 || scp->sc->switch_in_progress)
1605 return;
1606 /*
1607 * FIXME: unlike scrn_timer(), we call scrn_update() from here even
1608 * when write_in_progress is non-zero. XXX
1609 */
1610
1611 if (!ISGRAPHSC(scp) && !(scp->sc->flags & SC_SCRN_BLANKED))
1612 scrn_update(scp, TRUE);
1613}
1614
1615static void
1616scrn_timer(void *arg)
1617{
1618#ifndef PC98
1619 static int kbd_interval = 0;
1620#endif
1621 struct timeval tv;
1622 sc_softc_t *sc;
1623 scr_stat *scp;
1624 int again;
1625 int s;
1626
1627 again = (arg != NULL);
1628 if (arg != NULL)
1629 sc = (sc_softc_t *)arg;
1630 else if (sc_console != NULL)
1631 sc = sc_console->sc;
1632 else
1633 return;
1634
1635 /* don't do anything when we are performing some I/O operations */
1636 if (sc->font_loading_in_progress || sc->videoio_in_progress) {
1637 if (again)
1638 timeout(scrn_timer, sc, hz / 10);
1639 return;
1640 }
1641 s = spltty();
1642
1643#ifndef PC98
1644 if ((sc->kbd == NULL) && (sc->config & SC_AUTODETECT_KBD)) {
1645 /* try to allocate a keyboard automatically */
1646 if (++kbd_interval >= 25) {
1647 sc->keyboard = kbd_allocate("*", -1, (void *)&sc->keyboard,
1648 sckbdevent, sc);
1649 if (sc->keyboard >= 0) {
1650 sc->kbd = kbd_get_keyboard(sc->keyboard);
1651 kbd_ioctl(sc->kbd, KDSKBMODE,
1652 (caddr_t)&sc->cur_scp->kbd_mode);
1653 update_kbd_state(sc->cur_scp, sc->cur_scp->status,
1654 LOCK_MASK);
1655 }
1656 kbd_interval = 0;
1657 }
1658 }
1659#endif /* PC98 */
1660
1661 /* find the vty to update */
1662 scp = sc->cur_scp;
1663
1664 /* should we stop the screen saver? */
1665 getmicrouptime(&tv);
1666 if (debugger > 0 || panicstr || shutdown_in_progress)
1667 sc_touch_scrn_saver();
1668 if (run_scrn_saver) {
1669 if (tv.tv_sec > sc->scrn_time_stamp + scrn_blank_time)
1670 sc->flags |= SC_SCRN_IDLE;
1671 else
1672 sc->flags &= ~SC_SCRN_IDLE;
1673 } else {
1674 sc->scrn_time_stamp = tv.tv_sec;
1675 sc->flags &= ~SC_SCRN_IDLE;
1676 if (scrn_blank_time > 0)
1677 run_scrn_saver = TRUE;
1678 }
1679#ifdef DEV_SPLASH
1680 if ((saver_mode != CONS_LKM_SAVER) || !(sc->flags & SC_SCRN_IDLE))
1681 if (sc->flags & SC_SCRN_BLANKED)
1682 stop_scrn_saver(sc, current_saver);
1683#endif
1684
1685 /* should we just return ? */
1686 if (sc->blink_in_progress || sc->switch_in_progress
1687 || sc->write_in_progress) {
1688 if (again)
1689 timeout(scrn_timer, sc, hz / 10);
1690 splx(s);
1691 return;
1692 }
1693
1694 /* Update the screen */
1695 scp = sc->cur_scp; /* cur_scp may have changed... */
1696 if (!ISGRAPHSC(scp) && !(sc->flags & SC_SCRN_BLANKED))
1697 scrn_update(scp, TRUE);
1698
1699#ifdef DEV_SPLASH
1700 /* should we activate the screen saver? */
1701 if ((saver_mode == CONS_LKM_SAVER) && (sc->flags & SC_SCRN_IDLE))
1702 if (!ISGRAPHSC(scp) || (sc->flags & SC_SCRN_BLANKED))
1703 (*current_saver)(sc, TRUE);
1704#endif
1705
1706 if (again)
1707 timeout(scrn_timer, sc, hz / 25);
1708 splx(s);
1709}
1710
1711static int
1712and_region(int *s1, int *e1, int s2, int e2)
1713{
1714 if (*e1 < s2 || e2 < *s1)
1715 return FALSE;
1716 *s1 = imax(*s1, s2);
1717 *e1 = imin(*e1, e2);
1718 return TRUE;
1719}
1720
1721static void
1722scrn_update(scr_stat *scp, int show_cursor)
1723{
1724 int start;
1725 int end;
1726 int s;
1727 int e;
1728
1729 /* assert(scp == scp->sc->cur_scp) */
1730
1731 ++scp->sc->videoio_in_progress;
1732
1733#ifndef SC_NO_CUTPASTE
1734 /* remove the previous mouse pointer image if necessary */
1735 if (scp->status & MOUSE_VISIBLE) {
1736 s = scp->mouse_pos;
1737 e = scp->mouse_pos + scp->xsize + 1;
1738 if ((scp->status & (MOUSE_MOVED | MOUSE_HIDDEN))
1739 || and_region(&s, &e, scp->start, scp->end)
1740 || ((scp->status & CURSOR_ENABLED) &&
1741 (scp->cursor_pos != scp->cursor_oldpos) &&
1742 (and_region(&s, &e, scp->cursor_pos, scp->cursor_pos)
1743 || and_region(&s, &e, scp->cursor_oldpos, scp->cursor_oldpos)))) {
1744 sc_remove_mouse_image(scp);
1745 if (scp->end >= scp->xsize*scp->ysize)
1746 scp->end = scp->xsize*scp->ysize - 1;
1747 }
1748 }
1749#endif /* !SC_NO_CUTPASTE */
1750
1751#if 1
1752 /* debug: XXX */
1753 if (scp->end >= scp->xsize*scp->ysize) {
1754 printf("scrn_update(): scp->end %d > size_of_screen!!\n", scp->end);
1755 scp->end = scp->xsize*scp->ysize - 1;
1756 }
1757 if (scp->start < 0) {
1758 printf("scrn_update(): scp->start %d < 0\n", scp->start);
1759 scp->start = 0;
1760 }
1761#endif
1762
1763 /* update screen image */
1764 if (scp->start <= scp->end) {
1765 if (scp->mouse_cut_end >= 0) {
1766 /* there is a marked region for cut & paste */
1767 if (scp->mouse_cut_start <= scp->mouse_cut_end) {
1768 start = scp->mouse_cut_start;
1769 end = scp->mouse_cut_end;
1770 } else {
1771 start = scp->mouse_cut_end;
1772 end = scp->mouse_cut_start - 1;
1773 }
1774 s = start;
1775 e = end;
1776 /* does the cut-mark region overlap with the update region? */
1777 if (and_region(&s, &e, scp->start, scp->end)) {
1778 (*scp->rndr->draw)(scp, s, e - s + 1, TRUE);
1779 s = 0;
1780 e = start - 1;
1781 if (and_region(&s, &e, scp->start, scp->end))
1782 (*scp->rndr->draw)(scp, s, e - s + 1, FALSE);
1783 s = end + 1;
1784 e = scp->xsize*scp->ysize - 1;
1785 if (and_region(&s, &e, scp->start, scp->end))
1786 (*scp->rndr->draw)(scp, s, e - s + 1, FALSE);
1787 } else {
1788 (*scp->rndr->draw)(scp, scp->start,
1789 scp->end - scp->start + 1, FALSE);
1790 }
1791 } else {
1792 (*scp->rndr->draw)(scp, scp->start,
1793 scp->end - scp->start + 1, FALSE);
1794 }
1795 }
1796
1797 /* we are not to show the cursor and the mouse pointer... */
1798 if (!show_cursor) {
1799 scp->end = 0;
1800 scp->start = scp->xsize*scp->ysize - 1;
1801 --scp->sc->videoio_in_progress;
1802 return;
1803 }
1804
1805 /* update cursor image */
1806 if (scp->status & CURSOR_ENABLED) {
1807 s = scp->start;
1808 e = scp->end;
1809 /* did cursor move since last time ? */
1810 if (scp->cursor_pos != scp->cursor_oldpos) {
1811 /* do we need to remove old cursor image ? */
1812 if (!and_region(&s, &e, scp->cursor_oldpos, scp->cursor_oldpos))
1813 sc_remove_cursor_image(scp);
1814 sc_draw_cursor_image(scp);
1815 } else {
1816 if (and_region(&s, &e, scp->cursor_pos, scp->cursor_pos))
1817 /* cursor didn't move, but has been overwritten */
1818 sc_draw_cursor_image(scp);
1819 else if (scp->curs_attr.flags & CONS_BLINK_CURSOR)
1820 /* if it's a blinking cursor, update it */
1821 (*scp->rndr->blink_cursor)(scp, scp->cursor_pos,
1822 sc_inside_cutmark(scp,
1823 scp->cursor_pos));
1824 }
1825 }
1826
1827#ifndef SC_NO_CUTPASTE
1828 /* update "pseudo" mouse pointer image */
1829 if (scp->sc->flags & SC_MOUSE_ENABLED) {
1830 if (!(scp->status & (MOUSE_VISIBLE | MOUSE_HIDDEN))) {
1831 scp->status &= ~MOUSE_MOVED;
1832 sc_draw_mouse_image(scp);
1833 }
1834 }
1835#endif /* SC_NO_CUTPASTE */
1836
1837 scp->end = 0;
1838 scp->start = scp->xsize*scp->ysize - 1;
1839
1840 --scp->sc->videoio_in_progress;
1841}
1842
1843#ifdef DEV_SPLASH
1844static int
1845scsplash_callback(int event, void *arg)
1846{
1847 sc_softc_t *sc;
1848 int error;
1849
1850 sc = (sc_softc_t *)arg;
1851
1852 switch (event) {
1853 case SPLASH_INIT:
1854 if (add_scrn_saver(scsplash_saver) == 0) {
1855 sc->flags &= ~SC_SAVER_FAILED;
1856 run_scrn_saver = TRUE;
1857 if (cold && !(boothowto & (RB_VERBOSE | RB_CONFIG))) {
1858 scsplash_stick(TRUE);
1859 (*current_saver)(sc, TRUE);
1860 }
1861 }
1862 return 0;
1863
1864 case SPLASH_TERM:
1865 if (current_saver == scsplash_saver) {
1866 scsplash_stick(FALSE);
1867 error = remove_scrn_saver(scsplash_saver);
1868 if (error)
1869 return error;
1870 }
1871 return 0;
1872
1873 default:
1874 return EINVAL;
1875 }
1876}
1877
1878static void
1879scsplash_saver(sc_softc_t *sc, int show)
1880{
1881 static int busy = FALSE;
1882 scr_stat *scp;
1883
1884 if (busy)
1885 return;
1886 busy = TRUE;
1887
1888 scp = sc->cur_scp;
1889 if (show) {
1890 if (!(sc->flags & SC_SAVER_FAILED)) {
1891 if (!(sc->flags & SC_SCRN_BLANKED))
1892 set_scrn_saver_mode(scp, -1, NULL, 0);
1893 switch (splash(sc->adp, TRUE)) {
1894 case 0: /* succeeded */
1895 break;
1896 case EAGAIN: /* try later */
1897 restore_scrn_saver_mode(scp, FALSE);
1898 sc_touch_scrn_saver(); /* XXX */
1899 break;
1900 default:
1901 sc->flags |= SC_SAVER_FAILED;
1902 scsplash_stick(FALSE);
1903 restore_scrn_saver_mode(scp, TRUE);
1904 printf("scsplash_saver(): failed to put up the image\n");
1905 break;
1906 }
1907 }
1908 } else if (!sticky_splash) {
1909 if ((sc->flags & SC_SCRN_BLANKED) && (splash(sc->adp, FALSE) == 0))
1910 restore_scrn_saver_mode(scp, TRUE);
1911 }
1912 busy = FALSE;
1913}
1914
1915static int
1916add_scrn_saver(void (*this_saver)(sc_softc_t *, int))
1917{
1918#if 0
1919 int error;
1920
1921 if (current_saver != none_saver) {
1922 error = remove_scrn_saver(current_saver);
1923 if (error)
1924 return error;
1925 }
1926#endif
1927 if (current_saver != none_saver)
1928 return EBUSY;
1929
1930 run_scrn_saver = FALSE;
1931 saver_mode = CONS_LKM_SAVER;
1932 current_saver = this_saver;
1933 return 0;
1934}
1935
1936static int
1937remove_scrn_saver(void (*this_saver)(sc_softc_t *, int))
1938{
1939 if (current_saver != this_saver)
1940 return EINVAL;
1941
1942#if 0
1943 /*
1944 * In order to prevent `current_saver' from being called by
1945 * the timeout routine `scrn_timer()' while we manipulate
1946 * the saver list, we shall set `current_saver' to `none_saver'
1947 * before stopping the current saver, rather than blocking by `splXX()'.
1948 */
1949 current_saver = none_saver;
1950 if (scrn_blanked)
1951 stop_scrn_saver(this_saver);
1952#endif
1953
1954 /* unblank all blanked screens */
1955 wait_scrn_saver_stop(NULL);
1956 if (scrn_blanked)
1957 return EBUSY;
1958
1959 current_saver = none_saver;
1960 return 0;
1961}
1962
1963static int
1964set_scrn_saver_mode(scr_stat *scp, int mode, u_char *pal, int border)
1965{
1966 int s;
1967
1968 /* assert(scp == scp->sc->cur_scp) */
1969 s = spltty();
1970 if (!ISGRAPHSC(scp))
1971 sc_remove_cursor_image(scp);
1972 scp->splash_save_mode = scp->mode;
1973 scp->splash_save_status = scp->status & (GRAPHICS_MODE | PIXEL_MODE);
1974 scp->status &= ~(GRAPHICS_MODE | PIXEL_MODE);
1975 scp->status |= (UNKNOWN_MODE | SAVER_RUNNING);
1976 scp->sc->flags |= SC_SCRN_BLANKED;
1977 ++scrn_blanked;
1978 splx(s);
1979 if (mode < 0)
1980 return 0;
1981 scp->mode = mode;
1982 if (set_mode(scp) == 0) {
1983 if (scp->sc->adp->va_info.vi_flags & V_INFO_GRAPHICS)
1984 scp->status |= GRAPHICS_MODE;
1985#ifndef SC_NO_PALETTE_LOADING
1986 if (pal != NULL)
1987 load_palette(scp->sc->adp, pal);
1988#endif
1989 sc_set_border(scp, border);
1990 return 0;
1991 } else {
1992 s = spltty();
1993 scp->mode = scp->splash_save_mode;
1994 scp->status &= ~(UNKNOWN_MODE | SAVER_RUNNING);
1995 scp->status |= scp->splash_save_status;
1996 splx(s);
1997 return 1;
1998 }
1999}
2000
2001static int
2002restore_scrn_saver_mode(scr_stat *scp, int changemode)
2003{
2004 int mode;
2005 int status;
2006 int s;
2007
2008 /* assert(scp == scp->sc->cur_scp) */
2009 s = spltty();
2010 mode = scp->mode;
2011 status = scp->status;
2012 scp->mode = scp->splash_save_mode;
2013 scp->status &= ~(UNKNOWN_MODE | SAVER_RUNNING);
2014 scp->status |= scp->splash_save_status;
2015 scp->sc->flags &= ~SC_SCRN_BLANKED;
2016 if (!changemode) {
2017 if (!ISGRAPHSC(scp))
2018 sc_draw_cursor_image(scp);
2019 --scrn_blanked;
2020 splx(s);
2021 return 0;
2022 }
2023 if (set_mode(scp) == 0) {
2024#ifndef SC_NO_PALETTE_LOADING
2025 load_palette(scp->sc->adp, scp->sc->palette);
2026#endif
2027 --scrn_blanked;
2028 splx(s);
2029 return 0;
2030 } else {
2031 scp->mode = mode;
2032 scp->status = status;
2033 splx(s);
2034 return 1;
2035 }
2036}
2037
2038static void
2039stop_scrn_saver(sc_softc_t *sc, void (*saver)(sc_softc_t *, int))
2040{
2041 (*saver)(sc, FALSE);
2042 run_scrn_saver = FALSE;
2043 /* the screen saver may have chosen not to stop after all... */
2044 if (sc->flags & SC_SCRN_BLANKED)
2045 return;
2046
2047 mark_all(sc->cur_scp);
2048 if (sc->delayed_next_scr)
2049 sc_switch_scr(sc, sc->delayed_next_scr - 1);
2050 if (debugger == 0)
2051 wakeup(&scrn_blanked);
2052}
2053
2054static int
2055wait_scrn_saver_stop(sc_softc_t *sc)
2056{
2057 int error = 0;
2058
2059 while (scrn_blanked > 0) {
2060 run_scrn_saver = FALSE;
2061 if (sc && !(sc->flags & SC_SCRN_BLANKED)) {
2062 error = 0;
2063 break;
2064 }
2065 error = tsleep(&scrn_blanked, PZERO | PCATCH, "scrsav", 0);
2066 if ((error != 0) && (error != ERESTART))
2067 break;
2068 }
2069 run_scrn_saver = FALSE;
2070 return error;
2071}
2072#endif /* DEV_SPLASH */
2073
2074void
2075sc_touch_scrn_saver(void)
2076{
2077 scsplash_stick(FALSE);
2078 run_scrn_saver = FALSE;
2079}
2080
2081int
2082sc_switch_scr(sc_softc_t *sc, u_int next_scr)
2083{
2084 scr_stat *cur_scp;
2085 struct tty *tp;
2086 struct proc *p;
2087 int s;
2088
2089 DPRINTF(5, ("sc0: sc_switch_scr() %d ", next_scr + 1));
2090
2091 if (sc->cur_scp == NULL)
2092 return (0);
2093
2094 /* prevent switch if previously requested */
2095 if (sc->flags & SC_SCRN_VTYLOCK) {
2096 sc_bell(sc->cur_scp, sc->cur_scp->bell_pitch,
2097 sc->cur_scp->bell_duration);
2098 return EPERM;
2099 }
2100
2101 /* delay switch if the screen is blanked or being updated */
2102 if ((sc->flags & SC_SCRN_BLANKED) || sc->write_in_progress
2103 || sc->blink_in_progress || sc->videoio_in_progress) {
2104 sc->delayed_next_scr = next_scr + 1;
2105 sc_touch_scrn_saver();
2106 DPRINTF(5, ("switch delayed\n"));
2107 return 0;
2108 }
2109
2110 s = spltty();
2111 cur_scp = sc->cur_scp;
2112
2113 /* we are in the middle of the vty switching process... */
2114 if (sc->switch_in_progress
2115 && (cur_scp->smode.mode == VT_PROCESS)
2116 && cur_scp->proc) {
2117 p = pfind(cur_scp->pid);
2118 if (cur_scp->proc != p) {
2119 if (p)
2120 PROC_UNLOCK(p);
2121 /*
2122 * The controlling process has died!!. Do some clean up.
2123 * NOTE:`cur_scp->proc' and `cur_scp->smode.mode'
2124 * are not reset here yet; they will be cleared later.
2125 */
2126 DPRINTF(5, ("cur_scp controlling process %d died, ",
2127 cur_scp->pid));
2128 if (cur_scp->status & SWITCH_WAIT_REL) {
2129 /*
2130 * Force the previous switch to finish, but return now
2131 * with error.
2132 */
2133 DPRINTF(5, ("reset WAIT_REL, "));
2134 finish_vt_rel(cur_scp, TRUE, &s);
2135 splx(s);
2136 DPRINTF(5, ("finishing previous switch\n"));
2137 return EINVAL;
2138 } else if (cur_scp->status & SWITCH_WAIT_ACQ) {
2139 /* let's assume screen switch has been completed. */
2140 DPRINTF(5, ("reset WAIT_ACQ, "));
2141 finish_vt_acq(cur_scp);
2142 } else {
2143 /*
2144 * We are in between screen release and acquisition, and
2145 * reached here via scgetc() or scrn_timer() which has
2146 * interrupted exchange_scr(). Don't do anything stupid.
2147 */
2148 DPRINTF(5, ("waiting nothing, "));
2149 }
2150 } else {
2151 if (p)
2152 PROC_UNLOCK(p);
2153 /*
2154 * The controlling process is alive, but not responding...
2155 * It is either buggy or it may be just taking time.
2156 * The following code is a gross kludge to cope with this
2157 * problem for which there is no clean solution. XXX
2158 */
2159 if (cur_scp->status & SWITCH_WAIT_REL) {
2160 switch (sc->switch_in_progress++) {
2161 case 1:
2162 break;
2163 case 2:
2164 DPRINTF(5, ("sending relsig again, "));
2165 signal_vt_rel(cur_scp);
2166 break;
2167 case 3:
2168 break;
2169 case 4:
2170 default:
2171 /*
2172 * Act as if the controlling program returned
2173 * VT_FALSE.
2174 */
2175 DPRINTF(5, ("force reset WAIT_REL, "));
2176 finish_vt_rel(cur_scp, FALSE, &s);
2177 splx(s);
2178 DPRINTF(5, ("act as if VT_FALSE was seen\n"));
2179 return EINVAL;
2180 }
2181 } else if (cur_scp->status & SWITCH_WAIT_ACQ) {
2182 switch (sc->switch_in_progress++) {
2183 case 1:
2184 break;
2185 case 2:
2186 DPRINTF(5, ("sending acqsig again, "));
2187 signal_vt_acq(cur_scp);
2188 break;
2189 case 3:
2190 break;
2191 case 4:
2192 default:
2193 /* clear the flag and finish the previous switch */
2194 DPRINTF(5, ("force reset WAIT_ACQ, "));
2195 finish_vt_acq(cur_scp);
2196 break;
2197 }
2198 }
2199 }
2200 }
2201
2202 /*
2203 * Return error if an invalid argument is given, or vty switch
2204 * is still in progress.
2205 */
2206 if ((next_scr < sc->first_vty) || (next_scr >= sc->first_vty + sc->vtys)
2207 || sc->switch_in_progress) {
2208 splx(s);
2209 sc_bell(cur_scp, bios_value.bell_pitch, BELL_DURATION);
2210 DPRINTF(5, ("error 1\n"));
2211 return EINVAL;
2212 }
2213
2214 /*
2215 * Don't allow switching away from the graphics mode vty
2216 * if the switch mode is VT_AUTO, unless the next vty is the same
2217 * as the current or the current vty has been closed (but showing).
2218 */
2219 tp = VIRTUAL_TTY(sc, cur_scp->index);
2220 if ((cur_scp->index != next_scr)
2221 && ISTTYOPEN(tp)
2222 && (cur_scp->smode.mode == VT_AUTO)
2223 && ISGRAPHSC(cur_scp)) {
2224 splx(s);
2225 sc_bell(cur_scp, bios_value.bell_pitch, BELL_DURATION);
2226 DPRINTF(5, ("error, graphics mode\n"));
2227 return EINVAL;
2228 }
2229
2230 /*
2231 * Is the wanted vty open? Don't allow switching to a closed vty.
2232 * If we are in DDB, don't switch to a vty in the VT_PROCESS mode.
2233 * Note that we always allow the user to switch to the kernel
2234 * console even if it is closed.
2235 */
2236 if ((sc_console == NULL) || (next_scr != sc_console->index)) {
2237 tp = VIRTUAL_TTY(sc, next_scr);
2238 if (!ISTTYOPEN(tp)) {
2239 splx(s);
2240 sc_bell(cur_scp, bios_value.bell_pitch, BELL_DURATION);
2241 DPRINTF(5, ("error 2, requested vty isn't open!\n"));
2242 return EINVAL;
2243 }
2244 if ((debugger > 0) && (SC_STAT(tp->t_dev)->smode.mode == VT_PROCESS)) {
2245 splx(s);
2246 DPRINTF(5, ("error 3, requested vty is in the VT_PROCESS mode\n"));
2247 return EINVAL;
2248 }
2249 }
2250
2251 /* this is the start of vty switching process... */
2252 ++sc->switch_in_progress;
2253 sc->delayed_next_scr = 0;
2254 sc->old_scp = cur_scp;
2255 sc->new_scp = sc_get_stat(SC_DEV(sc, next_scr));
2256 if (sc->new_scp == sc->old_scp) {
2257 sc->switch_in_progress = 0;
2258 /*
2259 * XXX wakeup() calls mtx_lock(&sched_lock) which will hang if
2260 * sched_lock is in an in-between state, e.g., when we stop at
2261 * a breakpoint at fork_exit. It has always been wrong to call
2262 * wakeup() when the debugger is active. In RELENG_4, wakeup()
2263 * is supposed to be locked by splhigh(), but the debugger may
2264 * be invoked at splhigh().
2265 */
2266 if (debugger == 0)
2267 wakeup(&sc->new_scp->smode);
2268 splx(s);
2269 DPRINTF(5, ("switch done (new == old)\n"));
2270 return 0;
2271 }
2272
2273 /* has controlling process died? */
2274 vt_proc_alive(sc->old_scp);
2275 vt_proc_alive(sc->new_scp);
2276
2277 /* wait for the controlling process to release the screen, if necessary */
2278 if (signal_vt_rel(sc->old_scp)) {
2279 splx(s);
2280 return 0;
2281 }
2282
2283 /* go set up the new vty screen */
2284 splx(s);
2285 exchange_scr(sc);
2286 s = spltty();
2287
2288 /* wake up processes waiting for this vty */
2289 if (debugger == 0)
2290 wakeup(&sc->cur_scp->smode);
2291
2292 /* wait for the controlling process to acknowledge, if necessary */
2293 if (signal_vt_acq(sc->cur_scp)) {
2294 splx(s);
2295 return 0;
2296 }
2297
2298 sc->switch_in_progress = 0;
2299 if (sc->unit == sc_console_unit)
2300 cnavailable(sc_consptr, TRUE);
2301 splx(s);
2302 DPRINTF(5, ("switch done\n"));
2303
2304 return 0;
2305}
2306
2307static int
2308do_switch_scr(sc_softc_t *sc, int s)
2309{
2310 vt_proc_alive(sc->new_scp);
2311
2312 splx(s);
2313 exchange_scr(sc);
2314 s = spltty();
2315 /* sc->cur_scp == sc->new_scp */
2316 wakeup(&sc->cur_scp->smode);
2317
2318 /* wait for the controlling process to acknowledge, if necessary */
2319 if (!signal_vt_acq(sc->cur_scp)) {
2320 sc->switch_in_progress = 0;
2321 if (sc->unit == sc_console_unit)
2322 cnavailable(sc_consptr, TRUE);
2323 }
2324
2325 return s;
2326}
2327
2328static int
2329vt_proc_alive(scr_stat *scp)
2330{
2331 struct proc *p;
2332
2333 if (scp->proc) {
2334 if ((p = pfind(scp->pid)) != NULL)
2335 PROC_UNLOCK(p);
2336 if (scp->proc == p)
2337 return TRUE;
2338 scp->proc = NULL;
2339 scp->smode.mode = VT_AUTO;
2340 DPRINTF(5, ("vt controlling process %d died\n", scp->pid));
2341 }
2342 return FALSE;
2343}
2344
2345static int
2346signal_vt_rel(scr_stat *scp)
2347{
2348 if (scp->smode.mode != VT_PROCESS)
2349 return FALSE;
2350 scp->status |= SWITCH_WAIT_REL;
2351 PROC_LOCK(scp->proc);
2352 psignal(scp->proc, scp->smode.relsig);
2353 PROC_UNLOCK(scp->proc);
2354 DPRINTF(5, ("sending relsig to %d\n", scp->pid));
2355 return TRUE;
2356}
2357
2358static int
2359signal_vt_acq(scr_stat *scp)
2360{
2361 if (scp->smode.mode != VT_PROCESS)
2362 return FALSE;
2363 if (scp->sc->unit == sc_console_unit)
2364 cnavailable(sc_consptr, FALSE);
2365 scp->status |= SWITCH_WAIT_ACQ;
2366 PROC_LOCK(scp->proc);
2367 psignal(scp->proc, scp->smode.acqsig);
2368 PROC_UNLOCK(scp->proc);
2369 DPRINTF(5, ("sending acqsig to %d\n", scp->pid));
2370 return TRUE;
2371}
2372
2373static int
2374finish_vt_rel(scr_stat *scp, int release, int *s)
2375{
2376 if (scp == scp->sc->old_scp && scp->status & SWITCH_WAIT_REL) {
2377 scp->status &= ~SWITCH_WAIT_REL;
2378 if (release)
2379 *s = do_switch_scr(scp->sc, *s);
2380 else
2381 scp->sc->switch_in_progress = 0;
2382 return 0;
2383 }
2384 return EINVAL;
2385}
2386
2387static int
2388finish_vt_acq(scr_stat *scp)
2389{
2390 if (scp == scp->sc->new_scp && scp->status & SWITCH_WAIT_ACQ) {
2391 scp->status &= ~SWITCH_WAIT_ACQ;
2392 scp->sc->switch_in_progress = 0;
2393 return 0;
2394 }
2395 return EINVAL;
2396}
2397
2398static void
2399exchange_scr(sc_softc_t *sc)
2400{
2401 scr_stat *scp;
2402
2403 /* save the current state of video and keyboard */
2404 sc_move_cursor(sc->old_scp, sc->old_scp->xpos, sc->old_scp->ypos);
2405 if (!ISGRAPHSC(sc->old_scp))
2406 sc_remove_cursor_image(sc->old_scp);
2407 if (sc->old_scp->kbd_mode == K_XLATE)
2408 save_kbd_state(sc->old_scp);
2409
2410 /* set up the video for the new screen */
2411 scp = sc->cur_scp = sc->new_scp;
2412#ifdef PC98
2413 if (sc->old_scp->mode != scp->mode || ISUNKNOWNSC(sc->old_scp) || ISUNKNOWNSC(sc->new_scp))
2414#else
2415 if (sc->old_scp->mode != scp->mode || ISUNKNOWNSC(sc->old_scp))
2416#endif
2417 set_mode(scp);
2418#ifndef __sparc64__
2419 else
2420 sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, scp->xsize, scp->ysize,
2421 (void *)sc->adp->va_window, FALSE);
2422#endif
2423 scp->status |= MOUSE_HIDDEN;
2424 sc_move_cursor(scp, scp->xpos, scp->ypos);
2425 if (!ISGRAPHSC(scp))
2426 sc_set_cursor_image(scp);
2427#ifndef SC_NO_PALETTE_LOADING
2428 if (ISGRAPHSC(sc->old_scp))
2429 load_palette(sc->adp, sc->palette);
2430#endif
2431 sc_set_border(scp, scp->border);
2432
2433 /* set up the keyboard for the new screen */
2434 if (sc->old_scp->kbd_mode != scp->kbd_mode)
2435 kbd_ioctl(sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
2436 update_kbd_state(scp, scp->status, LOCK_MASK);
2437
2438 mark_all(scp);
2439}
2440
2441void
2442sc_puts(scr_stat *scp, u_char *buf, int len)
2443{
2444#ifdef DEV_SPLASH
2445 /* make screensaver happy */
2446 if (!sticky_splash && scp == scp->sc->cur_scp && !sc_saver_keyb_only)
2447 run_scrn_saver = FALSE;
2448#endif
2449
2450 if (scp->tsw)
2451 (*scp->tsw->te_puts)(scp, buf, len);
2452
2453 if (scp->sc->delayed_next_scr)
2454 sc_switch_scr(scp->sc, scp->sc->delayed_next_scr - 1);
2455}
2456
2457void
2458sc_draw_cursor_image(scr_stat *scp)
2459{
2460 /* assert(scp == scp->sc->cur_scp); */
2461 ++scp->sc->videoio_in_progress;
2462 (*scp->rndr->draw_cursor)(scp, scp->cursor_pos,
2463 scp->curs_attr.flags & CONS_BLINK_CURSOR, TRUE,
2464 sc_inside_cutmark(scp, scp->cursor_pos));
2465 scp->cursor_oldpos = scp->cursor_pos;
2466 --scp->sc->videoio_in_progress;
2467}
2468
2469void
2470sc_remove_cursor_image(scr_stat *scp)
2471{
2472 /* assert(scp == scp->sc->cur_scp); */
2473 ++scp->sc->videoio_in_progress;
2474 (*scp->rndr->draw_cursor)(scp, scp->cursor_oldpos,
2475 scp->curs_attr.flags & CONS_BLINK_CURSOR, FALSE,
2476 sc_inside_cutmark(scp, scp->cursor_oldpos));
2477 --scp->sc->videoio_in_progress;
2478}
2479
2480static void
2481update_cursor_image(scr_stat *scp)
2482{
2483 /* assert(scp == scp->sc->cur_scp); */
2484 sc_remove_cursor_image(scp);
2485 sc_set_cursor_image(scp);
2486 sc_draw_cursor_image(scp);
2487}
2488
2489void
2490sc_set_cursor_image(scr_stat *scp)
2491{
2492 scp->curs_attr.flags = scp->curr_curs_attr.flags;
2493 if (scp->curs_attr.flags & CONS_HIDDEN_CURSOR) {
2494 /* hidden cursor is internally represented as zero-height underline */
2495 scp->curs_attr.flags = CONS_CHAR_CURSOR;
2496 scp->curs_attr.base = scp->curs_attr.height = 0;
2497 } else if (scp->curs_attr.flags & CONS_CHAR_CURSOR) {
2498 scp->curs_attr.base = imin(scp->curr_curs_attr.base,
2499 scp->font_size - 1);
2500 scp->curs_attr.height = imin(scp->curr_curs_attr.height,
2501 scp->font_size - scp->curs_attr.base);
2502 } else { /* block cursor */
2503 scp->curs_attr.base = 0;
2504 scp->curs_attr.height = scp->font_size;
2505 }
2506
2507 /* assert(scp == scp->sc->cur_scp); */
2508 ++scp->sc->videoio_in_progress;
2509 (*scp->rndr->set_cursor)(scp, scp->curs_attr.base, scp->curs_attr.height,
2510 scp->curs_attr.flags & CONS_BLINK_CURSOR);
2511 --scp->sc->videoio_in_progress;
2512}
2513
2514static void
2515change_cursor_shape(scr_stat *scp, int flags, int base, int height)
2516{
2517 if ((scp == scp->sc->cur_scp) && !ISGRAPHSC(scp))
2518 sc_remove_cursor_image(scp);
2519
2520 if (base >= 0)
2521 scp->curr_curs_attr.base = base;
2522 if (height >= 0)
2523 scp->curr_curs_attr.height = height;
2524 if (flags & CONS_RESET_CURSOR)
2525 scp->curr_curs_attr = scp->dflt_curs_attr;
2526 else
2527 scp->curr_curs_attr.flags = flags & CONS_CURSOR_ATTRS;
2528
2529 if ((scp == scp->sc->cur_scp) && !ISGRAPHSC(scp)) {
2530 sc_set_cursor_image(scp);
2531 sc_draw_cursor_image(scp);
2532 }
2533}
2534
2535void
2536sc_change_cursor_shape(scr_stat *scp, int flags, int base, int height)
2537{
2538 sc_softc_t *sc;
2539 struct cdev *dev;
2540 int s;
2541 int i;
2542
2543 s = spltty();
2544 if ((flags != -1) && (flags & CONS_LOCAL_CURSOR)) {
2545 /* local (per vty) change */
2546 change_cursor_shape(scp, flags, base, height);
2547 splx(s);
2548 return;
2549 }
2550
2551 /* global change */
2552 sc = scp->sc;
2553 if (base >= 0)
2554 sc->curs_attr.base = base;
2555 if (height >= 0)
2556 sc->curs_attr.height = height;
2557 if (flags != -1) {
2558 if (flags & CONS_RESET_CURSOR)
2559 sc->curs_attr = sc->dflt_curs_attr;
2560 else
2561 sc->curs_attr.flags = flags & CONS_CURSOR_ATTRS;
2562 }
2563
2564 for (i = sc->first_vty; i < sc->first_vty + sc->vtys; ++i) {
2565 if ((dev = SC_DEV(sc, i)) == NULL)
2566 continue;
2567 if ((scp = sc_get_stat(dev)) == NULL)
2568 continue;
2569 scp->dflt_curs_attr = sc->curs_attr;
2570 change_cursor_shape(scp, CONS_RESET_CURSOR, -1, -1);
2571 }
2572 splx(s);
2573}
2574
2575static void
2576scinit(int unit, int flags)
2577{
2578 /*
2579 * When syscons is being initialized as the kernel console, malloc()
2580 * is not yet functional, because various kernel structures has not been
2581 * fully initialized yet. Therefore, we need to declare the following
2582 * static buffers for the console. This is less than ideal,
2583 * but is necessry evil for the time being. XXX
2584 */
2585#ifdef PC98
2586 static u_short sc_buffer[ROW*COL*2];/* XXX */
2587#else
2588 static u_short sc_buffer[ROW*COL]; /* XXX */
2589#endif
2590#ifndef SC_NO_FONT_LOADING
2591 static u_char font_8[256*8];
2592 static u_char font_14[256*14];
2593 static u_char font_16[256*16];
2594#endif
2595
2596 sc_softc_t *sc;
2597 scr_stat *scp;
2598 video_adapter_t *adp;
2599 int col;
2600 int row;
2601 int i;
2602
2603 /* one time initialization */
2604 if (init_done == COLD)
2605 sc_get_bios_values(&bios_value);
2606 init_done = WARM;
2607
2608 /*
2609 * Allocate resources. Even if we are being called for the second
2610 * time, we must allocate them again, because they might have
2611 * disappeared...
2612 */
2613 sc = sc_get_softc(unit, flags & SC_KERNEL_CONSOLE);
2614 adp = NULL;
2615 if (sc->adapter >= 0) {
2616 vid_release(sc->adp, (void *)&sc->adapter);
2617 adp = sc->adp;
2618 sc->adp = NULL;
2619 }
2620 if (sc->keyboard >= 0) {
2621 DPRINTF(5, ("sc%d: releasing kbd%d\n", unit, sc->keyboard));
2622 i = kbd_release(sc->kbd, (void *)&sc->keyboard);
2623 DPRINTF(5, ("sc%d: kbd_release returned %d\n", unit, i));
2624 if (sc->kbd != NULL) {
2625 DPRINTF(5, ("sc%d: kbd != NULL!, index:%d, unit:%d, flags:0x%x\n",
2626 unit, sc->kbd->kb_index, sc->kbd->kb_unit, sc->kbd->kb_flags));
2627 }
2628 sc->kbd = NULL;
2629 }
2630 sc->adapter = vid_allocate("*", unit, (void *)&sc->adapter);
2631 sc->adp = vid_get_adapter(sc->adapter);
2632 /* assert((sc->adapter >= 0) && (sc->adp != NULL)) */
2633 sc->keyboard = kbd_allocate("*", unit, (void *)&sc->keyboard,
2634 sckbdevent, sc);
2635 DPRINTF(1, ("sc%d: keyboard %d\n", unit, sc->keyboard));
2636 sc->kbd = kbd_get_keyboard(sc->keyboard);
2637 if (sc->kbd != NULL) {
2638 DPRINTF(1, ("sc%d: kbd index:%d, unit:%d, flags:0x%x\n",
2639 unit, sc->kbd->kb_index, sc->kbd->kb_unit, sc->kbd->kb_flags));
2640 }
2641
2642 if (!(sc->flags & SC_INIT_DONE) || (adp != sc->adp)) {
2643
2644 sc->initial_mode = sc->adp->va_initial_mode;
2645
2646#ifndef SC_NO_FONT_LOADING
2647 if (flags & SC_KERNEL_CONSOLE) {
2648 sc->font_8 = font_8;
2649 sc->font_14 = font_14;
2650 sc->font_16 = font_16;
2651 } else if (sc->font_8 == NULL) {
2652 /* assert(sc_malloc) */
2653 sc->font_8 = malloc(sizeof(font_8), M_DEVBUF, M_WAITOK);
2654 sc->font_14 = malloc(sizeof(font_14), M_DEVBUF, M_WAITOK);
2655 sc->font_16 = malloc(sizeof(font_16), M_DEVBUF, M_WAITOK);
2656 }
2657#endif
2658
2659 /* extract the hardware cursor location and hide the cursor for now */
2660 (*vidsw[sc->adapter]->read_hw_cursor)(sc->adp, &col, &row);
2661 (*vidsw[sc->adapter]->set_hw_cursor)(sc->adp, -1, -1);
2662
2663 /* set up the first console */
2664 sc->first_vty = unit*MAXCONS;
2665 sc->vtys = MAXCONS; /* XXX: should be configurable */
2666 if (flags & SC_KERNEL_CONSOLE) {
2667 /*
2668 * Set up devs structure but don't use it yet, calling make_dev()
2669 * might panic kernel. Wait for sc_attach_unit() to actually
2670 * create the devices.
2671 */
2672 sc->dev = main_devs;
2673 scp = &main_console;
2674 init_scp(sc, sc->first_vty, scp);
2675 sc_vtb_init(&scp->vtb, VTB_MEMORY, scp->xsize, scp->ysize,
2676 (void *)sc_buffer, FALSE);
2677 if (sc_init_emulator(scp, SC_DFLT_TERM))
2678 sc_init_emulator(scp, "*");
2679 (*scp->tsw->te_default_attr)(scp,
2680 kernel_default.std_color,
2681 kernel_default.rev_color);
2682 } else {
2683 /* assert(sc_malloc) */
2684 sc->dev = malloc(sizeof(struct cdev *)*sc->vtys, M_DEVBUF, M_WAITOK|M_ZERO);
2685 sc->dev[0] = make_dev(&sc_cdevsw, unit * MAXCONS,
2686 UID_ROOT, GID_WHEEL, 0600, "ttyv%r", unit * MAXCONS);
2687 sc->dev[0]->si_tty = ttymalloc(sc->dev[0]->si_tty);
2688 scp = alloc_scp(sc, sc->first_vty);
2689 SC_STAT(sc->dev[0]) = scp;
2690 }
2691 sc->cur_scp = scp;
2692
2693#ifndef __sparc64__
2694 /* copy screen to temporary buffer */
2695 sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, scp->xsize, scp->ysize,
2696 (void *)scp->sc->adp->va_window, FALSE);
2697 if (ISTEXTSC(scp))
2698 sc_vtb_copy(&scp->scr, 0, &scp->vtb, 0, scp->xsize*scp->ysize);
2699#endif
2700
2701 /* move cursors to the initial positions */
2702 if (col >= scp->xsize)
2703 col = 0;
2704 if (row >= scp->ysize)
2705 row = scp->ysize - 1;
2706 scp->xpos = col;
2707 scp->ypos = row;
2708 scp->cursor_pos = scp->cursor_oldpos = row*scp->xsize + col;
2709
2710 if (bios_value.cursor_end < scp->font_size)
2711 sc->dflt_curs_attr.base = scp->font_size -
2712 bios_value.cursor_end - 1;
2713 else
2714 sc->dflt_curs_attr.base = 0;
2715 i = bios_value.cursor_end - bios_value.cursor_start + 1;
2716 sc->dflt_curs_attr.height = imin(i, scp->font_size);
2717 sc->dflt_curs_attr.flags = 0;
2718 sc->curs_attr = sc->dflt_curs_attr;
2719 scp->curr_curs_attr = scp->dflt_curs_attr = sc->curs_attr;
2720
2721#ifndef SC_NO_SYSMOUSE
2722 sc_mouse_move(scp, scp->xpixel/2, scp->ypixel/2);
2723#endif
2724 if (!ISGRAPHSC(scp)) {
2725 sc_set_cursor_image(scp);
2726 sc_draw_cursor_image(scp);
2727 }
2728
2729 /* save font and palette */
2730#ifndef SC_NO_FONT_LOADING
2731 sc->fonts_loaded = 0;
2732 if (ISFONTAVAIL(sc->adp->va_flags)) {
2733#ifdef SC_DFLT_FONT
2734 bcopy(dflt_font_8, sc->font_8, sizeof(dflt_font_8));
2735 bcopy(dflt_font_14, sc->font_14, sizeof(dflt_font_14));
2736 bcopy(dflt_font_16, sc->font_16, sizeof(dflt_font_16));
2737 sc->fonts_loaded = FONT_16 | FONT_14 | FONT_8;
2738 if (scp->font_size < 14) {
2739 sc_load_font(scp, 0, 8, sc->font_8, 0, 256);
2740 } else if (scp->font_size >= 16) {
2741 sc_load_font(scp, 0, 16, sc->font_16, 0, 256);
2742 } else {
2743 sc_load_font(scp, 0, 14, sc->font_14, 0, 256);
2744 }
2745#else /* !SC_DFLT_FONT */
2746 if (scp->font_size < 14) {
2747 sc_save_font(scp, 0, 8, sc->font_8, 0, 256);
2748 sc->fonts_loaded = FONT_8;
2749 } else if (scp->font_size >= 16) {
2750 sc_save_font(scp, 0, 16, sc->font_16, 0, 256);
2751 sc->fonts_loaded = FONT_16;
2752 } else {
2753 sc_save_font(scp, 0, 14, sc->font_14, 0, 256);
2754 sc->fonts_loaded = FONT_14;
2755 }
2756#endif /* SC_DFLT_FONT */
2757 /* FONT KLUDGE: always use the font page #0. XXX */
2758 sc_show_font(scp, 0);
2759 }
2760#endif /* !SC_NO_FONT_LOADING */
2761
2762#ifndef SC_NO_PALETTE_LOADING
2763 save_palette(sc->adp, sc->palette);
2764#endif
2765
2766#ifdef DEV_SPLASH
2767 if (!(sc->flags & SC_SPLASH_SCRN) && (flags & SC_KERNEL_CONSOLE)) {
2768 /* we are ready to put up the splash image! */
2769 splash_init(sc->adp, scsplash_callback, sc);
2770 sc->flags |= SC_SPLASH_SCRN;
2771 }
2772#endif
2773 }
2774
2775 /* the rest is not necessary, if we have done it once */
2776 if (sc->flags & SC_INIT_DONE)
2777 return;
2778
2779 /* initialize mapscrn arrays to a one to one map */
2780 for (i = 0; i < sizeof(sc->scr_map); i++)
2781 sc->scr_map[i] = sc->scr_rmap[i] = i;
2782#ifdef PC98
2783 sc->scr_map[0x5c] = (u_char)0xfc; /* for backslash */
2784#endif
2785
2786 sc->flags |= SC_INIT_DONE;
2787}
2788
2789static void
2790scterm(int unit, int flags)
2791{
2792 sc_softc_t *sc;
2793 scr_stat *scp;
2794
2795 sc = sc_get_softc(unit, flags & SC_KERNEL_CONSOLE);
2796 if (sc == NULL)
2797 return; /* shouldn't happen */
2798
2799#ifdef DEV_SPLASH
2800 /* this console is no longer available for the splash screen */
2801 if (sc->flags & SC_SPLASH_SCRN) {
2802 splash_term(sc->adp);
2803 sc->flags &= ~SC_SPLASH_SCRN;
2804 }
2805#endif
2806
2807#if 0 /* XXX */
2808 /* move the hardware cursor to the upper-left corner */
2809 (*vidsw[sc->adapter]->set_hw_cursor)(sc->adp, 0, 0);
2810#endif
2811
2812 /* release the keyboard and the video card */
2813 if (sc->keyboard >= 0)
2814 kbd_release(sc->kbd, &sc->keyboard);
2815 if (sc->adapter >= 0)
2816 vid_release(sc->adp, &sc->adapter);
2817
2818 /* stop the terminal emulator, if any */
2819 scp = sc_get_stat(sc->dev[0]);
2820 if (scp->tsw)
2821 (*scp->tsw->te_term)(scp, &scp->ts);
2822 if (scp->ts != NULL)
2823 free(scp->ts, M_DEVBUF);
2824
2825 /* clear the structure */
2826 if (!(flags & SC_KERNEL_CONSOLE)) {
2827 /* XXX: We need delete_dev() for this */
2828 free(sc->dev, M_DEVBUF);
2829#if 0
2830 /* XXX: We need a ttyunregister for this */
2831 free(sc->tty, M_DEVBUF);
2832#endif
2833#ifndef SC_NO_FONT_LOADING
2834 free(sc->font_8, M_DEVBUF);
2835 free(sc->font_14, M_DEVBUF);
2836 free(sc->font_16, M_DEVBUF);
2837#endif
2838 /* XXX vtb, history */
2839 }
2840 bzero(sc, sizeof(*sc));
2841 sc->keyboard = -1;
2842 sc->adapter = -1;
2843}
2844
2845static void
2846scshutdown(void *arg, int howto)
2847{
2848 /* assert(sc_console != NULL) */
2849
2850 sc_touch_scrn_saver();
2851 if (!cold && sc_console
2852 && sc_console->sc->cur_scp->smode.mode == VT_AUTO
2853 && sc_console->smode.mode == VT_AUTO)
2854 sc_switch_scr(sc_console->sc, sc_console->index);
2855 shutdown_in_progress = TRUE;
2856}
2857
2858int
2859sc_clean_up(scr_stat *scp)
2860{
2861#ifdef DEV_SPLASH
2862 int error;
2863#endif
2864
2865 if (scp->sc->flags & SC_SCRN_BLANKED) {
2866 sc_touch_scrn_saver();
2867#ifdef DEV_SPLASH
2868 if ((error = wait_scrn_saver_stop(scp->sc)))
2869 return error;
2870#endif
2871 }
2872 scp->status |= MOUSE_HIDDEN;
2873 sc_remove_mouse_image(scp);
2874 sc_remove_cutmarking(scp);
2875 return 0;
2876}
2877
2878void
2879sc_alloc_scr_buffer(scr_stat *scp, int wait, int discard)
2880{
2881 sc_vtb_t new;
2882 sc_vtb_t old;
2883
2884 old = scp->vtb;
2885 sc_vtb_init(&new, VTB_MEMORY, scp->xsize, scp->ysize, NULL, wait);
2886 if (!discard && (old.vtb_flags & VTB_VALID)) {
2887 /* retain the current cursor position and buffer contants */
2888 scp->cursor_oldpos = scp->cursor_pos;
2889 /*
2890 * This works only if the old buffer has the same size as or larger
2891 * than the new one. XXX
2892 */
2893 sc_vtb_copy(&old, 0, &new, 0, scp->xsize*scp->ysize);
2894 scp->vtb = new;
2895 } else {
2896 scp->vtb = new;
2897 sc_vtb_destroy(&old);
2898 }
2899
2900#ifndef SC_NO_SYSMOUSE
2901 /* move the mouse cursor at the center of the screen */
2902 sc_mouse_move(scp, scp->xpixel / 2, scp->ypixel / 2);
2903#endif
2904}
2905
2906static scr_stat
2907*alloc_scp(sc_softc_t *sc, int vty)
2908{
2909 scr_stat *scp;
2910
2911 /* assert(sc_malloc) */
2912
2913 scp = (scr_stat *)malloc(sizeof(scr_stat), M_DEVBUF, M_WAITOK);
2914 init_scp(sc, vty, scp);
2915
2916 sc_alloc_scr_buffer(scp, TRUE, TRUE);
2917 if (sc_init_emulator(scp, SC_DFLT_TERM))
2918 sc_init_emulator(scp, "*");
2919
2920#ifndef SC_NO_CUTPASTE
2921 sc_alloc_cut_buffer(scp, TRUE);
2922#endif
2923
2924#ifndef SC_NO_HISTORY
2925 sc_alloc_history_buffer(scp, 0, 0, TRUE);
2926#endif
2927
2928 return scp;
2929}
2930
2931static void
2932init_scp(sc_softc_t *sc, int vty, scr_stat *scp)
2933{
2934 video_info_t info;
2935
2936 bzero(scp, sizeof(*scp));
2937
2938 scp->index = vty;
2939 scp->sc = sc;
2940 scp->status = 0;
2941 scp->mode = sc->initial_mode;
2942 (*vidsw[sc->adapter]->get_info)(sc->adp, scp->mode, &info);
2943 if (info.vi_flags & V_INFO_GRAPHICS) {
2944 scp->status |= GRAPHICS_MODE;
2945 scp->xpixel = info.vi_width;
2946 scp->ypixel = info.vi_height;
2947 scp->xsize = info.vi_width/info.vi_cwidth;
2948 scp->ysize = info.vi_height/info.vi_cheight;
2949 scp->font_size = 0;
2950 scp->font = NULL;
2951 } else {
2952 scp->xsize = info.vi_width;
2953 scp->ysize = info.vi_height;
2954 scp->xpixel = scp->xsize*info.vi_cwidth;
2955 scp->ypixel = scp->ysize*info.vi_cheight;
2956 scp->font_size = info.vi_cheight;
2957 scp->font_width = info.vi_cwidth;
2958 if (info.vi_cheight < 14) {
2959#ifndef SC_NO_FONT_LOADING
2960 scp->font = sc->font_8;
2961#else
2962 scp->font = NULL;
2963#endif
2964 } else if (info.vi_cheight >= 16) {
2965#ifndef SC_NO_FONT_LOADING
2966 scp->font = sc->font_16;
2967#else
2968 scp->font = NULL;
2969#endif
2970 } else {
2971#ifndef SC_NO_FONT_LOADING
2972 scp->font = sc->font_14;
2973#else
2974 scp->font = NULL;
2975#endif
2976 }
2977 }
2978 sc_vtb_init(&scp->vtb, VTB_MEMORY, 0, 0, NULL, FALSE);
2979#ifndef __sparc64__
2980 sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, 0, 0, NULL, FALSE);
2981#endif
2982 scp->xoff = scp->yoff = 0;
2983 scp->xpos = scp->ypos = 0;
2984 scp->start = scp->xsize * scp->ysize - 1;
2985 scp->end = 0;
2986 scp->tsw = NULL;
2987 scp->ts = NULL;
2988 scp->rndr = NULL;
2989 scp->border = BG_BLACK;
2990 scp->curr_curs_attr = scp->dflt_curs_attr = sc->curs_attr;
2991 scp->mouse_cut_start = scp->xsize*scp->ysize;
2992 scp->mouse_cut_end = -1;
2993 scp->mouse_signal = 0;
2994 scp->mouse_pid = 0;
2995 scp->mouse_proc = NULL;
2996 scp->kbd_mode = K_XLATE;
2997 scp->bell_pitch = bios_value.bell_pitch;
2998 scp->bell_duration = BELL_DURATION;
2999 scp->status |= (bios_value.shift_state & NLKED);
3000 scp->status |= CURSOR_ENABLED | MOUSE_HIDDEN;
3001 scp->pid = 0;
3002 scp->proc = NULL;
3003 scp->smode.mode = VT_AUTO;
3004 scp->history = NULL;
3005 scp->history_pos = 0;
3006 scp->history_size = 0;
3007}
3008
3009int
3010sc_init_emulator(scr_stat *scp, char *name)
3011{
3012 sc_term_sw_t *sw;
3013 sc_rndr_sw_t *rndr;
3014 void *p;
3015 int error;
3016
3017 if (name == NULL) /* if no name is given, use the current emulator */
3018 sw = scp->tsw;
3019 else /* ...otherwise find the named emulator */
3020 sw = sc_term_match(name);
3021 if (sw == NULL)
3022 return EINVAL;
3023
3024 rndr = NULL;
3025 if (strcmp(sw->te_renderer, "*") != 0) {
3026 rndr = sc_render_match(scp, sw->te_renderer,
3027 scp->status & (GRAPHICS_MODE | PIXEL_MODE));
3028 }
3029 if (rndr == NULL) {
3030 rndr = sc_render_match(scp, scp->sc->adp->va_name,
3031 scp->status & (GRAPHICS_MODE | PIXEL_MODE));
3032 if (rndr == NULL)
3033 return ENODEV;
3034 }
3035
3036 if (sw == scp->tsw) {
3037 error = (*sw->te_init)(scp, &scp->ts, SC_TE_WARM_INIT);
3038 scp->rndr = rndr;
3039 sc_clear_screen(scp);
3040 /* assert(error == 0); */
3041 return error;
3042 }
3043
3044 if (sc_malloc && (sw->te_size > 0))
3045 p = malloc(sw->te_size, M_DEVBUF, M_NOWAIT);
3046 else
3047 p = NULL;
3048 error = (*sw->te_init)(scp, &p, SC_TE_COLD_INIT);
3049 if (error)
3050 return error;
3051
3052 if (scp->tsw)
3053 (*scp->tsw->te_term)(scp, &scp->ts);
3054 if (scp->ts != NULL)
3055 free(scp->ts, M_DEVBUF);
3056 scp->tsw = sw;
3057 scp->ts = p;
3058 scp->rndr = rndr;
3059
3060 /* XXX */
3061 (*sw->te_default_attr)(scp, user_default.std_color, user_default.rev_color);
3062 sc_clear_screen(scp);
3063
3064 return 0;
3065}
3066
3067/*
3068 * scgetc(flags) - get character from keyboard.
3069 * If flags & SCGETC_CN, then avoid harmful side effects.
3070 * If flags & SCGETC_NONBLOCK, then wait until a key is pressed, else
3071 * return NOKEY if there is nothing there.
3072 */
3073static u_int
3074scgetc(sc_softc_t *sc, u_int flags)
3075{
3076 scr_stat *scp;
3077#ifndef SC_NO_HISTORY
3078 struct tty *tp;
3079#endif
3080 u_int c;
3081 int this_scr;
3082 int f;
3083 int i;
3084
3085 if (sc->kbd == NULL)
3086 return NOKEY;
3087
3088next_code:
3089#if 1
3090 /* I don't like this, but... XXX */
3091 if (flags & SCGETC_CN)
3092 sccnupdate(sc->cur_scp);
3093#endif
3094 scp = sc->cur_scp;
3095 /* first see if there is something in the keyboard port */
3096 for (;;) {
3097 c = kbd_read_char(sc->kbd, !(flags & SCGETC_NONBLOCK));
3098 if (c == ERRKEY) {
3099 if (!(flags & SCGETC_CN))
3100 sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3101 } else if (c == NOKEY)
3102 return c;
3103 else
3104 break;
3105 }
3106
3107 /* make screensaver happy */
3108 if (!(c & RELKEY))
3109 sc_touch_scrn_saver();
3110
3111 if (!(flags & SCGETC_CN))
3112 random_harvest(&c, sizeof(c), 1, 0, RANDOM_KEYBOARD);
3113
3114 if (scp->kbd_mode != K_XLATE)
3115 return KEYCHAR(c);
3116
3117 /* if scroll-lock pressed allow history browsing */
3118 if (!ISGRAPHSC(scp) && scp->history && scp->status & SLKED) {
3119
3120 scp->status &= ~CURSOR_ENABLED;
3121 sc_remove_cursor_image(scp);
3122
3123#ifndef SC_NO_HISTORY
3124 if (!(scp->status & BUFFER_SAVED)) {
3125 scp->status |= BUFFER_SAVED;
3126 sc_hist_save(scp);
3127 }
3128 switch (c) {
3129 /* FIXME: key codes */
3130 case SPCLKEY | FKEY | F(49): /* home key */
3131 sc_remove_cutmarking(scp);
3132 sc_hist_home(scp);
3133 goto next_code;
3134
3135 case SPCLKEY | FKEY | F(57): /* end key */
3136 sc_remove_cutmarking(scp);
3137 sc_hist_end(scp);
3138 goto next_code;
3139
3140 case SPCLKEY | FKEY | F(50): /* up arrow key */
3141 sc_remove_cutmarking(scp);
3142 if (sc_hist_up_line(scp))
3143 if (!(flags & SCGETC_CN))
3144 sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3145 goto next_code;
3146
3147 case SPCLKEY | FKEY | F(58): /* down arrow key */
3148 sc_remove_cutmarking(scp);
3149 if (sc_hist_down_line(scp))
3150 if (!(flags & SCGETC_CN))
3151 sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3152 goto next_code;
3153
3154 case SPCLKEY | FKEY | F(51): /* page up key */
3155 sc_remove_cutmarking(scp);
3156 for (i=0; i<scp->ysize; i++)
3157 if (sc_hist_up_line(scp)) {
3158 if (!(flags & SCGETC_CN))
3159 sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3160 break;
3161 }
3162 goto next_code;
3163
3164 case SPCLKEY | FKEY | F(59): /* page down key */
3165 sc_remove_cutmarking(scp);
3166 for (i=0; i<scp->ysize; i++)
3167 if (sc_hist_down_line(scp)) {
3168 if (!(flags & SCGETC_CN))
3169 sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3170 break;
3171 }
3172 goto next_code;
3173 }
3174#endif /* SC_NO_HISTORY */
3175 }
3176
3177 /*
3178 * Process and consume special keys here. Return a plain char code
3179 * or a char code with the META flag or a function key code.
3180 */
3181 if (c & RELKEY) {
3182 /* key released */
3183 /* goto next_code */
3184 } else {
3185 /* key pressed */
3186 if (c & SPCLKEY) {
3187 c &= ~SPCLKEY;
3188 switch (KEYCHAR(c)) {
3189 /* LOCKING KEYS */
3190 case NLK: case CLK: case ALK:
3191 break;
3192 case SLK:
3193 kbd_ioctl(sc->kbd, KDGKBSTATE, (caddr_t)&f);
3194 if (f & SLKED) {
3195 scp->status |= SLKED;
3196 } else {
3197 if (scp->status & SLKED) {
3198 scp->status &= ~SLKED;
3199#ifndef SC_NO_HISTORY
3200 if (scp->status & BUFFER_SAVED) {
3201 if (!sc_hist_restore(scp))
3202 sc_remove_cutmarking(scp);
3203 scp->status &= ~BUFFER_SAVED;
3204 scp->status |= CURSOR_ENABLED;
3205 sc_draw_cursor_image(scp);
3206 }
3207 tp = VIRTUAL_TTY(sc, scp->index);
3208 if (ISTTYOPEN(tp))
3209 scstart(tp);
3210#endif
3211 }
3212 }
3213 break;
3214
3215 case PASTE:
3216#ifndef SC_NO_CUTPASTE
3217 sc_mouse_paste(scp);
3218#endif
3219 break;
3220
3221 /* NON-LOCKING KEYS */
3222 case NOP:
3223 case LSH: case RSH: case LCTR: case RCTR:
3224 case LALT: case RALT: case ASH: case META:
3225 break;
3226
3227 case BTAB:
3228 if (!(sc->flags & SC_SCRN_BLANKED))
3229 return c;
3230 break;
3231
3232 case SPSC:
3233#ifdef DEV_SPLASH
3234 /* force activatation/deactivation of the screen saver */
3235 if (!(sc->flags & SC_SCRN_BLANKED)) {
3236 run_scrn_saver = TRUE;
3237 sc->scrn_time_stamp -= scrn_blank_time;
3238 }
3239 if (cold) {
3240 /*
3241 * While devices are being probed, the screen saver need
3242 * to be invoked explictly. XXX
3243 */
3244 if (sc->flags & SC_SCRN_BLANKED) {
3245 scsplash_stick(FALSE);
3246 stop_scrn_saver(sc, current_saver);
3247 } else {
3248 if (!ISGRAPHSC(scp)) {
3249 scsplash_stick(TRUE);
3250 (*current_saver)(sc, TRUE);
3251 }
3252 }
3253 }
3254#endif /* DEV_SPLASH */
3255 break;
3256
3257 case RBT:
3258#ifndef SC_DISABLE_REBOOT
3259 shutdown_nice(0);
3260#endif
3261 break;
3262
3263 case HALT:
3264#ifndef SC_DISABLE_REBOOT
3265 shutdown_nice(RB_HALT);
3266#endif
3267 break;
3268
3269 case PDWN:
3270#ifndef SC_DISABLE_REBOOT
3271 shutdown_nice(RB_HALT|RB_POWEROFF);
3272#endif
3273 break;
3274
3275 case SUSP:
3276 power_pm_suspend(POWER_SLEEP_STATE_SUSPEND);
3277 break;
3278 case STBY:
3279 power_pm_suspend(POWER_SLEEP_STATE_STANDBY);
3280 break;
3281
3282 case DBG:
3283#ifndef SC_DISABLE_KDBKEY
3284 kdb_enter("manual escape to debugger");
3285#endif
3286 break;
3287
3288 case PNC:
3289 if (enable_panic_key)
3290 panic("Forced by the panic key");
3291 break;
3292
3293 case NEXT:
3294 this_scr = scp->index;
3295 for (i = (this_scr - sc->first_vty + 1)%sc->vtys;
3296 sc->first_vty + i != this_scr;
3297 i = (i + 1)%sc->vtys) {
3298 struct tty *tp = VIRTUAL_TTY(sc, sc->first_vty + i);
3299 if (ISTTYOPEN(tp)) {
3300 sc_switch_scr(scp->sc, sc->first_vty + i);
3301 break;
3302 }
3303 }
3304 break;
3305
3306 case PREV:
3307 this_scr = scp->index;
3308 for (i = (this_scr - sc->first_vty + sc->vtys - 1)%sc->vtys;
3309 sc->first_vty + i != this_scr;
3310 i = (i + sc->vtys - 1)%sc->vtys) {
3311 struct tty *tp = VIRTUAL_TTY(sc, sc->first_vty + i);
3312 if (ISTTYOPEN(tp)) {
3313 sc_switch_scr(scp->sc, sc->first_vty + i);
3314 break;
3315 }
3316 }
3317 break;
3318
3319 default:
3320 if (KEYCHAR(c) >= F_SCR && KEYCHAR(c) <= L_SCR) {
3321 sc_switch_scr(scp->sc, sc->first_vty + KEYCHAR(c) - F_SCR);
3322 break;
3323 }
3324 /* assert(c & FKEY) */
3325 if (!(sc->flags & SC_SCRN_BLANKED))
3326 return c;
3327 break;
3328 }
3329 /* goto next_code */
3330 } else {
3331 /* regular keys (maybe MKEY is set) */
3332 if (!(sc->flags & SC_SCRN_BLANKED))
3333 return c;
3334 }
3335 }
3336
3337 goto next_code;
3338}
3339
3340static int
3341scmmap(struct cdev *dev, vm_offset_t offset, vm_paddr_t *paddr, int nprot)
3342{
3343 scr_stat *scp;
3344
3345 scp = sc_get_stat(dev);
3346 if (scp != scp->sc->cur_scp)
3347 return -1;
3348 return (*vidsw[scp->sc->adapter]->mmap)(scp->sc->adp, offset, paddr, nprot);
3349}
3350
3351static int
3352save_kbd_state(scr_stat *scp)
3353{
3354 int state;
3355 int error;
3356
3357 error = kbd_ioctl(scp->sc->kbd, KDGKBSTATE, (caddr_t)&state);
3358 if (error == ENOIOCTL)
3359 error = ENODEV;
3360 if (error == 0) {
3361 scp->status &= ~LOCK_MASK;
3362 scp->status |= state;
3363 }
3364 return error;
3365}
3366
3367static int
3368update_kbd_state(scr_stat *scp, int new_bits, int mask)
3369{
3370 int state;
3371 int error;
3372
3373 if (mask != LOCK_MASK) {
3374 error = kbd_ioctl(scp->sc->kbd, KDGKBSTATE, (caddr_t)&state);
3375 if (error == ENOIOCTL)
3376 error = ENODEV;
3377 if (error)
3378 return error;
3379 state &= ~mask;
3380 state |= new_bits & mask;
3381 } else {
3382 state = new_bits & LOCK_MASK;
3383 }
3384 error = kbd_ioctl(scp->sc->kbd, KDSKBSTATE, (caddr_t)&state);
3385 if (error == ENOIOCTL)
3386 error = ENODEV;
3387 return error;
3388}
3389
3390static int
3391update_kbd_leds(scr_stat *scp, int which)
3392{
3393 int error;
3394
3395 which &= LOCK_MASK;
3396 error = kbd_ioctl(scp->sc->kbd, KDSETLED, (caddr_t)&which);
3397 if (error == ENOIOCTL)
3398 error = ENODEV;
3399 return error;
3400}
3401
3402int
3403set_mode(scr_stat *scp)
3404{
3405 video_info_t info;
3406
3407 /* reject unsupported mode */
3408 if ((*vidsw[scp->sc->adapter]->get_info)(scp->sc->adp, scp->mode, &info))
3409 return 1;
3410
3411 /* if this vty is not currently showing, do nothing */
3412 if (scp != scp->sc->cur_scp)
3413 return 0;
3414
3415 /* setup video hardware for the given mode */
3416 (*vidsw[scp->sc->adapter]->set_mode)(scp->sc->adp, scp->mode);
3417#ifndef __sparc64__
3418 sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, scp->xsize, scp->ysize,
3419 (void *)scp->sc->adp->va_window, FALSE);
3420#endif
3421
3422#ifndef SC_NO_FONT_LOADING
3423 /* load appropriate font */
3424 if (!(scp->status & GRAPHICS_MODE)) {
3425 if (!(scp->status & PIXEL_MODE) && ISFONTAVAIL(scp->sc->adp->va_flags)) {
3426 if (scp->font_size < 14) {
3427 if (scp->sc->fonts_loaded & FONT_8)
3428 sc_load_font(scp, 0, 8, scp->sc->font_8, 0, 256);
3429 } else if (scp->font_size >= 16) {
3430 if (scp->sc->fonts_loaded & FONT_16)
3431 sc_load_font(scp, 0, 16, scp->sc->font_16, 0, 256);
3432 } else {
3433 if (scp->sc->fonts_loaded & FONT_14)
3434 sc_load_font(scp, 0, 14, scp->sc->font_14, 0, 256);
3435 }
3436 /*
3437 * FONT KLUDGE:
3438 * This is an interim kludge to display correct font.
3439 * Always use the font page #0 on the video plane 2.
3440 * Somehow we cannot show the font in other font pages on
3441 * some video cards... XXX
3442 */
3443 sc_show_font(scp, 0);
3444 }
3445 mark_all(scp);
3446 }
3447#endif /* !SC_NO_FONT_LOADING */
3448
3449 sc_set_border(scp, scp->border);
3450 sc_set_cursor_image(scp);
3451
3452 return 0;
3453}
3454
3455void
3456sc_set_border(scr_stat *scp, int color)
3457{
3458 ++scp->sc->videoio_in_progress;
3459 (*scp->rndr->draw_border)(scp, color);
3460 --scp->sc->videoio_in_progress;
3461}
3462
3463#ifndef SC_NO_FONT_LOADING
3464void
3465sc_load_font(scr_stat *scp, int page, int size, u_char *buf,
3466 int base, int count)
3467{
3468 sc_softc_t *sc;
3469
3470 sc = scp->sc;
3471 sc->font_loading_in_progress = TRUE;
3472 (*vidsw[sc->adapter]->load_font)(sc->adp, page, size, buf, base, count);
3473 sc->font_loading_in_progress = FALSE;
3474}
3475
3476void
3477sc_save_font(scr_stat *scp, int page, int size, u_char *buf,
3478 int base, int count)
3479{
3480 sc_softc_t *sc;
3481
3482 sc = scp->sc;
3483 sc->font_loading_in_progress = TRUE;
3484 (*vidsw[sc->adapter]->save_font)(sc->adp, page, size, buf, base, count);
3485 sc->font_loading_in_progress = FALSE;
3486}
3487
3488void
3489sc_show_font(scr_stat *scp, int page)
3490{
3491 (*vidsw[scp->sc->adapter]->show_font)(scp->sc->adp, page);
3492}
3493#endif /* !SC_NO_FONT_LOADING */
3494
3495void
3496sc_paste(scr_stat *scp, u_char *p, int count)
3497{
3498 struct tty *tp;
3499 u_char *rmap;
3500
3501 tp = VIRTUAL_TTY(scp->sc, scp->sc->cur_scp->index);
3502 if (!ISTTYOPEN(tp))
3503 return;
3504 rmap = scp->sc->scr_rmap;
3505 for (; count > 0; --count)
3506 ttyld_rint(tp, rmap[*p++]);
3507}
3508
3509void
3510sc_bell(scr_stat *scp, int pitch, int duration)
3511{
3512 if (cold || shutdown_in_progress || !enable_bell)
3513 return;
3514
3515 if (scp != scp->sc->cur_scp && (scp->sc->flags & SC_QUIET_BELL))
3516 return;
3517
3518 if (scp->sc->flags & SC_VISUAL_BELL) {
3519 if (scp->sc->blink_in_progress)
3520 return;
3521 scp->sc->blink_in_progress = 3;
3522 if (scp != scp->sc->cur_scp)
3523 scp->sc->blink_in_progress += 2;
3524 blink_screen(scp->sc->cur_scp);
3525 } else if (duration != 0 && pitch != 0) {
3526 if (scp != scp->sc->cur_scp)
3527 pitch *= 2;
3528 sysbeep(pitch, duration);
3529 }
3530}
3531
3532static void
3533blink_screen(void *arg)
3534{
3535 scr_stat *scp = arg;
3536 struct tty *tp;
3537
3538 if (ISGRAPHSC(scp) || (scp->sc->blink_in_progress <= 1)) {
3539 scp->sc->blink_in_progress = 0;
3540 mark_all(scp);
3541 tp = VIRTUAL_TTY(scp->sc, scp->index);
3542 if (ISTTYOPEN(tp))
3543 scstart(tp);
3544 if (scp->sc->delayed_next_scr)
3545 sc_switch_scr(scp->sc, scp->sc->delayed_next_scr - 1);
3546 }
3547 else {
3548 (*scp->rndr->draw)(scp, 0, scp->xsize*scp->ysize,
3549 scp->sc->blink_in_progress & 1);
3550 scp->sc->blink_in_progress--;
3551 timeout(blink_screen, scp, hz / 10);
3552 }
3553}
3554
3555/*
3556 * Until sc_attach_unit() gets called no dev structures will be available
3557 * to store the per-screen current status. This is the case when the
3558 * kernel is initially booting and needs access to its console. During
3559 * this early phase of booting the console's current status is kept in
3560 * one statically defined scr_stat structure, and any pointers to the
3561 * dev structures will be NULL.
3562 */
3563
3564static scr_stat *
3565sc_get_stat(struct cdev *devptr)
3566{
3567 if (devptr == NULL)
3568 return (&main_console);
3569 return (SC_STAT(devptr));
3570}
|