?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Expand PMF_FN_* macros.
[netbsd-mini2440.git] / sys / dev / wscons / wsemul_sun.c
blob8733f0958c6ae6c03f4883156eb673942d5e40e3
1 /* $NetBSD: wsemul_sun.c,v 1.25 2006/10/12 01:32:06 christos Exp $ */
2
3 /*
4 * Copyright (c) 1996, 1997 Christopher G. Demetriou. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. All advertising materials mentioning features or use of this software
15 * must display the following acknowledgement:
16 * This product includes software developed by Christopher G. Demetriou
17 * for the NetBSD Project.
18 * 4. The name of the author may not be used to endorse or promote products
19 * derived from this software without specific prior written permission
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 /* XXX DESCRIPTION/SOURCE OF INFORMATION */
34
35 #include <sys/cdefs.h>
36 __KERNEL_RCSID(0, "$NetBSD: wsemul_sun.c,v 1.25 2006/10/12 01:32:06 christos Exp $");
37
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/time.h>
41 #include <sys/malloc.h>
42 #include <sys/fcntl.h>
43
44 #include <dev/wscons/wsconsio.h>
45 #include <dev/wscons/wsdisplayvar.h>
46 #include <dev/wscons/wsemulvar.h>
47 #include <dev/wscons/wsksymdef.h>
48 #include <dev/wscons/ascii.h>
49
50 void *wsemul_sun_cnattach(const struct wsscreen_descr *, void *,
51 int, int, long);
52 void *wsemul_sun_attach(int console, const struct wsscreen_descr *,
53 void *, int, int, void *, long);
54 void wsemul_sun_output(void *cookie, const u_char *data, u_int count,
55 int);
56 int wsemul_sun_translate(void *cookie, keysym_t, const char **);
57 void wsemul_sun_detach(void *cookie, u_int *crowp, u_int *ccolp);
58 void wsemul_sun_resetop(void *, enum wsemul_resetops);
59
60 const struct wsemul_ops wsemul_sun_ops = {
61 "sun",
62 wsemul_sun_cnattach,
63 wsemul_sun_attach,
64 wsemul_sun_output,
65 wsemul_sun_translate,
66 wsemul_sun_detach,
67 wsemul_sun_resetop,
68 NULL, /* getmsgattrs */
69 NULL, /* setmsgattrs */
70 };
71
72 #define SUN_EMUL_STATE_NORMAL 0 /* normal processing */
73 #define SUN_EMUL_STATE_HAVEESC 1 /* seen start of ctl seq */
74 #define SUN_EMUL_STATE_CONTROL 2 /* processing ctl seq */
75
76 #define SUN_EMUL_NARGS 2 /* max # of args to a command */
77
78 struct wsemul_sun_emuldata {
79 const struct wsdisplay_emulops *emulops;
80 void *emulcookie;
81 void *cbcookie;
82 int scrcapabilities;
83 u_int nrows, ncols, crow, ccol;
84
85 u_int state; /* processing state */
86 u_int args[SUN_EMUL_NARGS]; /* command args, if CONTROL */
87 u_int scrolldist; /* distance to scroll */
88 long defattr; /* default attribute (rendition) */
89 long bowattr; /* attribute for reversed mode */
90 int rendflags;
91 #define REND_BOW 1
92 #define REND_SO 2
93 long curattr; /* currently used attribute */
94 long kernattr; /* attribute for kernel output */
95 #ifdef DIAGNOSTIC
96 int console;
97 #endif
98 };
99
100 static u_int wsemul_sun_output_normal(struct wsemul_sun_emuldata *,
101 u_char, int);
102 static u_int wsemul_sun_output_haveesc(struct wsemul_sun_emuldata *, u_char);
103 static u_int wsemul_sun_output_control(struct wsemul_sun_emuldata *, u_char);
104 static void wsemul_sun_control(struct wsemul_sun_emuldata *, u_char);
105
106 struct wsemul_sun_emuldata wsemul_sun_console_emuldata;
107
108 /* some useful utility macros */
109 #define ARG(n) (edp->args[(n)])
110 #define NORMALIZE_ARG(n) (ARG(n) ? ARG(n) : 1)
111 #define COLS_LEFT (edp->ncols - edp->ccol - 1)
112 #define ROWS_LEFT (edp->nrows - edp->crow - 1)
113
114 void *
115 wsemul_sun_cnattach(const struct wsscreen_descr *type, void *cookie,
116 int ccol, int crow, long defattr)
117 {
118 struct wsemul_sun_emuldata *edp;
119 int res;
120
121 edp = &wsemul_sun_console_emuldata;
122
123 edp->emulops = type->textops;
124 edp->emulcookie = cookie;
125 edp->scrcapabilities = type->capabilities;
126 edp->nrows = type->nrows;
127 edp->ncols = type->ncols;
128 edp->crow = crow;
129 edp->ccol = ccol;
130 edp->curattr = edp->defattr = defattr;
131 #if defined(WS_KERNEL_FG) || defined(WS_KERNEL_BG) || \
132 defined(WS_KERNEL_COLATTR) || defined(WS_KERNEL_MONOATTR)
133 #ifndef WS_KERNEL_FG
134 #define WS_KERNEL_FG WSCOL_WHITE
135 #endif
136 #ifndef WS_KERNEL_BG
137 #define WS_KERNEL_BG WSCOL_BLACK
138 #endif
139 #ifndef WS_KERNEL_COLATTR
140 #define WS_KERNEL_COLATTR 0
141 #endif
142 #ifndef WS_KERNEL_MONOATTR
143 #define WS_KERNEL_MONOATTR 0
144 #endif
145 if (type->capabilities & WSSCREEN_WSCOLORS)
146 res = (*edp->emulops->allocattr)(cookie,
147 WS_KERNEL_FG, WS_KERNEL_BG,
148 WS_KERNEL_COLATTR | WSATTR_WSCOLORS,
149 &edp->kernattr);
150 else
151 res = (*edp->emulops->allocattr)(cookie, 0, 0,
152 WS_KERNEL_MONOATTR,
153 &edp->kernattr);
154 if (res)
155 #else
156 res = 0; /* XXX gcc */
157 #endif
158 edp->kernattr = defattr;
159
160 edp->cbcookie = NULL;
161
162 edp->state = SUN_EMUL_STATE_NORMAL;
163 edp->scrolldist = 1;
164 #ifdef DIAGNOSTIC
165 edp->console = 1;
166 #endif
167 return (edp);
168 }
169
170 void *
171 wsemul_sun_attach(int console, const struct wsscreen_descr *type,
172 void *cookie, int ccol, int crow, void *cbcookie, long defattr)
173 {
174 struct wsemul_sun_emuldata *edp;
175
176 if (console) {
177 edp = &wsemul_sun_console_emuldata;
178 #ifdef DIAGNOSTIC
179 KASSERT(edp->console == 1);
180 #endif
181 } else {
182 edp = malloc(sizeof *edp, M_DEVBUF, M_WAITOK);
183
184 edp->emulops = type->textops;
185 edp->emulcookie = cookie;
186 edp->scrcapabilities = type->capabilities;
187 edp->nrows = type->nrows;
188 edp->ncols = type->ncols;
189 edp->crow = crow;
190 edp->ccol = ccol;
191 edp->defattr = defattr;
192
193 edp->state = SUN_EMUL_STATE_NORMAL;
194 edp->scrolldist = 1;
195 #ifdef DIAGNOSTIC
196 edp->console = 0;
197 #endif
198 }
199
200 edp->cbcookie = cbcookie;
201
202 if ((!(edp->scrcapabilities & WSSCREEN_REVERSE) ||
203 (*edp->emulops->allocattr)(edp->emulcookie, 0, 0,
204 WSATTR_REVERSE,
205 &edp->bowattr)) &&
206 (!(edp->scrcapabilities & WSSCREEN_WSCOLORS) ||
207 (*edp->emulops->allocattr)(edp->emulcookie,
208 WSCOL_BLACK, WSCOL_WHITE,
209 WSATTR_WSCOLORS,
210 &edp->bowattr)))
211 edp->bowattr = edp->defattr;
212
213 edp->curattr = edp->defattr;
214 edp->rendflags = 0;
215
216 return (edp);
217 }
218
219 static inline u_int
220 wsemul_sun_output_normal(struct wsemul_sun_emuldata *edp, u_char c, int kernel)
221 {
222 u_int newstate = SUN_EMUL_STATE_NORMAL;
223 u_int n;
224
225 switch (c) {
226 case ASCII_BEL: /* "Bell (BEL)" */
227 wsdisplay_emulbell(edp->cbcookie);
228 break;
229
230 case ASCII_BS: /* "Backspace (BS)" */
231 if (edp->ccol > 0)
232 edp->ccol--;
233 break;
234
235 case ASCII_CR: /* "Return (CR)" */
236 edp->ccol = 0;
237 break;
238
239 case ASCII_HT: /* "Tab (TAB)" */
240 n = min(8 - (edp->ccol & 7), COLS_LEFT);
241 (*edp->emulops->erasecols)(edp->emulcookie, edp->crow,
242 edp->ccol, n,
243 kernel ? edp->kernattr : edp->curattr);
244 edp->ccol += n;
245 break;
246
247 case ASCII_FF: /* "Form Feed (FF)" */
248 (*edp->emulops->eraserows)(edp->emulcookie, 0, edp->nrows,
249 kernel ? edp->kernattr : edp->curattr);
250 /* XXX possible in kernel output? */
251 edp->ccol = 0;
252 edp->crow = 0;
253 break;
254
255 case ASCII_VT: /* "Reverse Line Feed" */
256 if (edp->crow > 0)
257 edp->crow--;
258 break;
259
260 case ASCII_ESC: /* "Escape (ESC)" */
261 if (kernel) {
262 printf("wsemul_sun_output_normal: ESC in kernel output ignored\n");
263 break; /* ignore the ESC */
264 }
265
266 if (edp->state == SUN_EMUL_STATE_NORMAL) {
267 newstate = SUN_EMUL_STATE_HAVEESC;
268 break;
269 }
270 /* special case: fall through, we're printing one out */
271 /* FALLTHRU */
272
273 default: /* normal character */
274 (*edp->emulops->putchar)(edp->emulcookie, edp->crow, edp->ccol,
275 c, kernel ? edp->kernattr : edp->curattr);
276 edp->ccol++;
277
278 /* if cur col is still on cur line, done. */
279 if (edp->ccol < edp->ncols)
280 break;
281
282 /* wrap the column around. */
283 edp->ccol = 0;
284
285 /* FALLTHRU */
286
287 case ASCII_LF: /* "Line Feed (LF)" */
288 /* if the cur line isn't the last, incr and leave. */
289 if (edp->crow < edp->nrows - 1) {
290 edp->crow++;
291 break;
292 }
293
294 /*
295 * if we're in wrap-around mode, go to the first
296 * line and clear it.
297 */
298 if (edp->scrolldist == 0) {
299 edp->crow = 0;
300 (*edp->emulops->eraserows)(edp->emulcookie, 0, 1,
301 edp->curattr);
302 break;
303 }
304
305 /* scroll by the scrolling distance. */
306 (*edp->emulops->copyrows)(edp->emulcookie, edp->scrolldist, 0,
307 edp->nrows - edp->scrolldist);
308 (*edp->emulops->eraserows)(edp->emulcookie,
309 edp->nrows - edp->scrolldist, edp->scrolldist,
310 edp->curattr);
311 edp->crow -= edp->scrolldist - 1;
312 break;
313 }
314
315 return (newstate);
316 }
317
318 static inline u_int
319 wsemul_sun_output_haveesc(struct wsemul_sun_emuldata *edp, u_char c)
320 {
321 u_int newstate;
322
323 switch (c) {
324 case '[': /* continuation of multi-char sequence */
325 memset(edp->args, 0, sizeof (edp->args));
326 newstate = SUN_EMUL_STATE_CONTROL;
327 break;
328
329 default:
330 /* spit out the escape char (???), then the new character */
331 wsemul_sun_output_normal(edp, ASCII_ESC, 0); /* ??? */
332 newstate = wsemul_sun_output_normal(edp, c, 0);
333 break;
334 }
335
336 return (newstate);
337 }
338
339 static inline void
340 wsemul_sun_control(struct wsemul_sun_emuldata *edp, u_char c)
341 {
342 u_int n, src, dst;
343
344 switch (c) {
345 case '@': /* "Insert Character (ICH)" */
346 n = min(NORMALIZE_ARG(0), COLS_LEFT + 1);
347 src = edp->ccol;
348 dst = edp->ccol + n;
349 if (dst < edp->ncols) {
350 (*edp->emulops->copycols)(edp->emulcookie, edp->crow,
351 src, dst, edp->ncols - dst);
352 }
353 (*edp->emulops->erasecols)(edp->emulcookie, edp->crow,
354 src, dst - src, edp->curattr);
355 break;
356
357 case 'A': /* "Cursor Up (CUU)" */
358 edp->crow -= min(NORMALIZE_ARG(0), edp->crow);
359 break;
360
361 case 'E': /* "Cursor Next Line (CNL)" */
362 edp->ccol = 0;
363 /* FALLTHRU */
364 case 'B': /* "Cursor Down (CUD)" */
365 edp->crow += min(NORMALIZE_ARG(0), ROWS_LEFT);
366 break;
367
368 case 'C': /* "Cursor Forward (CUF)" */
369 edp->ccol += min(NORMALIZE_ARG(0), COLS_LEFT);
370 break;
371
372 case 'D': /* "Cursor Backward (CUB)" */
373 edp->ccol -= min(NORMALIZE_ARG(0), edp->ccol);
374 break;
375
376 case 'f': /* "Horizontal And Vertical Position (HVP)" */
377 case 'H': /* "Cursor Position (CUP)" */
378 edp->crow = min(NORMALIZE_ARG(1), edp->nrows) - 1;
379 edp->ccol = min(NORMALIZE_ARG(0), edp->ncols) - 1;
380 break;
381
382 case 'J': /* "Erase in Display (ED)" */
383 if (ROWS_LEFT > 0) {
384 (*edp->emulops->eraserows)(edp->emulcookie,
385 edp->crow + 1, ROWS_LEFT, edp->curattr);
386 }
387 /* FALLTHRU */
388 case 'K': /* "Erase in Line (EL)" */
389 (*edp->emulops->erasecols)(edp->emulcookie, edp->crow,
390 edp->ccol, COLS_LEFT + 1, edp->curattr);
391 break;
392
393 case 'L': /* "Insert Line (IL)" */
394 n = min(NORMALIZE_ARG(0), ROWS_LEFT + 1);
395 src = edp->crow;
396 dst = edp->crow + n;
397 if (dst < edp->nrows) {
398 (*edp->emulops->copyrows)(edp->emulcookie,
399 src, dst, edp->nrows - dst);
400 }
401 (*edp->emulops->eraserows)(edp->emulcookie,
402 src, dst - src, edp->curattr);
403 break;
404
405 case 'M': /* "Delete Line (DL)" */
406 n = min(NORMALIZE_ARG(0), ROWS_LEFT + 1);
407 src = edp->crow + n;
408 dst = edp->crow;
409 if (src < edp->nrows) {
410 (*edp->emulops->copyrows)(edp->emulcookie,
411 src, dst, edp->nrows - src);
412 }
413 (*edp->emulops->eraserows)(edp->emulcookie,
414 dst + edp->nrows - src, src - dst, edp->curattr);
415 break;
416
417 case 'P': /* "Delete Character (DCH)" */
418 n = min(NORMALIZE_ARG(0), COLS_LEFT + 1);
419 src = edp->ccol + n;
420 dst = edp->ccol;
421 if (src < edp->ncols) {
422 (*edp->emulops->copycols)(edp->emulcookie, edp->crow,
423 src, dst, edp->ncols - src);
424 }
425 (*edp->emulops->erasecols)(edp->emulcookie, edp->crow,
426 dst + edp->ncols - src, src - dst, edp->curattr);
427 break;
428
429 case 'm': /* "Select Graphic Rendition (SGR)" */
430 if (ARG(0))
431 edp->rendflags |= REND_SO;
432 else
433 edp->rendflags &= ~REND_SO;
434 goto setattr;
435
436 case 'p': /* "Black On White (SUNBOW)" */
437 edp->rendflags |= REND_BOW;
438 goto setattr;
439
440 case 'q': /* "White On Black (SUNWOB)" */
441 edp->rendflags &= ~REND_BOW;
442 goto setattr;
443
444 case 'r': /* "Set Scrolling (SUNSCRL)" */
445 edp->scrolldist = min(ARG(0), edp->nrows);
446 break;
447
448 case 's': /* "Reset Terminal Emulator (SUNRESET)" */
449 edp->scrolldist = 1;
450 edp->rendflags = 0;
451 setattr:
452 if (((edp->rendflags & REND_BOW) != 0) ^
453 ((edp->rendflags & REND_SO) != 0))
454 edp->curattr = edp->bowattr;
455 else
456 edp->curattr = edp->defattr;
457 break;
458 }
459 }
460
461 static inline u_int
462 wsemul_sun_output_control(struct wsemul_sun_emuldata *edp, u_char c)
463 {
464 u_int newstate = SUN_EMUL_STATE_CONTROL;
465 u_int i;
466
467 switch (c) {
468 case '0': case '1': case '2': case '3': case '4': /* argument digit */
469 case '5': case '6': case '7': case '8': case '9':
470 edp->args[0] = (edp->args[0] * 10) + (c - '0');
471 break;
472
473 case ';': /* argument terminator */
474 for (i = 1; i < SUN_EMUL_NARGS; i++)
475 edp->args[i] = edp->args[i - 1];
476 edp->args[0] = 0;
477 break;
478
479 default: /* end of escape sequence */
480 wsemul_sun_control(edp, c);
481 newstate = SUN_EMUL_STATE_NORMAL;
482 break;
483 }
484 return (newstate);
485 }
486
487 void
488 wsemul_sun_output(void *cookie, const u_char *data, u_int count, int kernel)
489 {
490 struct wsemul_sun_emuldata *edp = cookie;
491 u_int newstate;
492
493 #ifdef DIAGNOSTIC
494 if (kernel && !edp->console)
495 panic("wsemul_sun_output: kernel output, not console");
496 #endif
497
498 /* XXX */
499 (*edp->emulops->cursor)(edp->emulcookie, 0, edp->crow, edp->ccol);
500 for (; count > 0; data++, count--) {
501 if (kernel) {
502 wsemul_sun_output_normal(edp, *data, 1);
503 continue;
504 }
505 switch (edp->state) {
506 case SUN_EMUL_STATE_NORMAL:
507 /* XXX SCAN INPUT FOR NEWLINES, DO PRESCROLLING */
508 newstate = wsemul_sun_output_normal(edp, *data, 0);
509 break;
510 case SUN_EMUL_STATE_HAVEESC:
511 newstate = wsemul_sun_output_haveesc(edp, *data);
512 break;
513 case SUN_EMUL_STATE_CONTROL:
514 newstate = wsemul_sun_output_control(edp, *data);
515 break;
516 default:
517 #ifdef DIAGNOSTIC
518 panic("wsemul_sun: invalid state %d", edp->state);
519 #endif
520 /* try to recover, if things get screwed up... */
521 newstate = wsemul_sun_output_normal(edp, *data, 0);
522 break;
523 }
524 edp->state = newstate;
525 }
526 /* XXX */
527 (*edp->emulops->cursor)(edp->emulcookie, 1, edp->crow, edp->ccol);
528 }
529
530 static const char *sun_fkeys[] = {
531 "\033[224z", /* F1 */
532 "\033[225z",
533 "\033[226z",
534 "\033[227z",
535 "\033[228z",
536 "\033[229z",
537 "\033[230z",
538 "\033[231z",
539 "\033[232z",
540 "\033[233z", /* F10 */
541 };
542
543 int
544 wsemul_sun_translate(void *cookie, keysym_t in, const char **out)
545 {
546 static char c;
547
548 if (KS_GROUP(in) == KS_GROUP_Keypad && (in & 0x80) == 0) {
549 c = in & 0xff; /* turn into ASCII */
550 *out = &c;
551 return (1);
552 }
553
554 if (in >= KS_f1 && in <= KS_f10) {
555 *out = sun_fkeys[in - KS_f1];
556 return (6);
557 }
558 if (in >= KS_F1 && in <= KS_F10) {
559 *out = sun_fkeys[in - KS_F1];
560 return (6);
561 }
562 if (in >= KS_KP_F1 && in <= KS_KP_F4) {
563 *out = sun_fkeys[in - KS_KP_F1];
564 return (6);
565 }
566
567 switch (in) {
568 case KS_Home:
569 case KS_KP_Home:
570 case KS_KP_Begin:
571 *out = "\033[214z";
572 return (6);
573 case KS_Prior:
574 case KS_KP_Prior:
575 *out = "\033[216z";
576 return (6);
577 case KS_Next:
578 case KS_KP_Next:
579 *out = "\033[222z";
580 return (6);
581 case KS_Up:
582 case KS_KP_Up:
583 *out = "\033[A";
584 return (3);
585 case KS_Down:
586 case KS_KP_Down:
587 *out = "\033[B";
588 return (3);
589 case KS_Left:
590 case KS_KP_Left:
591 *out = "\033[D";
592 return (3);
593 case KS_Right:
594 case KS_KP_Right:
595 *out = "\033[C";
596 return (3);
597 case KS_KP_Delete:
598 *out = "\177";
599 return (1);
600 }
601 return (0);
602 }
603
604 void
605 wsemul_sun_detach(void *cookie, u_int *crowp, u_int *ccolp)
606 {
607 struct wsemul_sun_emuldata *edp = cookie;
608
609 *crowp = edp->crow;
610 *ccolp = edp->ccol;
611 if (edp != &wsemul_sun_console_emuldata)
612 free(edp, M_DEVBUF);
613 }
614
615 void
616 wsemul_sun_resetop(void *cookie, enum wsemul_resetops op)
617 {
618 struct wsemul_sun_emuldata *edp = cookie;
619
620 switch (op) {
621 case WSEMUL_RESET:
622 edp->state = SUN_EMUL_STATE_NORMAL;
623 edp->scrolldist = 1;
624 edp->rendflags = 0;
625 edp->curattr = edp->defattr;
626 break;
627 case WSEMUL_CLEARSCREEN:
628 (*edp->emulops->eraserows)(edp->emulcookie, 0, edp->nrows,
629 edp->defattr);
630 edp->ccol = edp->crow = 0;
631 (*edp->emulops->cursor)(edp->emulcookie, 1, 0, 0);
632 break;
633 default:
634 break;
635 }
636 }
NetBSD on the FriendlyARM MINI2440