This source file includes following definitions.
- gotoxy
- __set_origin
- scrollback
- scrollfront
- set_origin
- hide_cursor
- set_cursor
- scrup
- scrdown
- lf
- ri
- cr
- bs
- del
- csi_J
- csi_K
- csi_X
- update_attr
- default_attr
- csi_m
- respond_string
- cursor_report
- mouse_report
- status_report
- respond_ID
- invert_screen
- set_mode
- setterm_command
- insert_char
- insert_line
- delete_char
- delete_line
- csi_at
- csi_L
- csi_P
- csi_M
- save_cur
- restore_cur
- reset_terminal
- con_stop
- con_start
- con_write
- con_write_room
- con_chars_in_buffer
- poke_blanked_console
- memsetw
- console_print
- con_throttle
- con_unthrottle
- con_init
- kbdsave
- get_scrmem
- set_scrmem
- blank_screen
- unblank_screen
- update_screen
- do_screendump
- con_open
- highlight
- highlight_pointer
- inword
- sel_loadlut
- atedge
- limit
- mouse_reporting
- set_selection
- paste_selection
- clear_selection
- set_get_font
- con_set_font
- con_get_font
- con_set_trans
- con_get_trans
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43 #define CAN_LOAD_EGA_FONTS
44
45
46
47
48
49
50
51
52 #include <linux/sched.h>
53 #include <linux/timer.h>
54 #include <linux/interrupt.h>
55 #include <linux/tty.h>
56 #include <linux/tty_flip.h>
57 #include <linux/config.h>
58 #include <linux/kernel.h>
59 #include <linux/string.h>
60 #include <linux/errno.h>
61 #include <linux/kd.h>
62 #include <linux/major.h>
63
64 #include <asm/io.h>
65 #include <asm/system.h>
66 #include <asm/segment.h>
67 #include <asm/bitops.h>
68
69 #include "kbd_kern.h"
70 #include "vt_kern.h"
71
72 #ifndef MIN
73 #define MIN(a,b) ((a) < (b) ? (a) : (b))
74 #endif
75
76 struct tty_driver console_driver;
77 static int console_refcount;
78 static struct tty_struct *console_table[NR_CONSOLES];
79 static struct termios *console_termios[NR_CONSOLES];
80 static struct termios *console_termios_locked[NR_CONSOLES];
81
82 #ifdef CONFIG_SELECTION
83 #include <linux/ctype.h>
84
85
86 int set_selection(const int arg, struct tty_struct *tty);
87 int paste_selection(struct tty_struct *tty);
88 static void clear_selection(void);
89 static void highlight_pointer(const int currcons, const int where);
90
91
92 #define SEL_BUFFER_SIZE 4096
93 static int sel_cons;
94 static int sel_start = -1;
95 static int sel_end;
96 static char sel_buffer[SEL_BUFFER_SIZE] = { '\0' };
97 #endif
98
99 #define NPAR 16
100
101 extern void vt_init(void);
102 extern void register_console(void (*proc)(const char *));
103 extern void compute_shiftstate(void);
104
105 unsigned long video_num_columns;
106 unsigned long video_num_lines;
107
108 static unsigned char video_type;
109 static unsigned long video_mem_base;
110 static unsigned long video_mem_term;
111 static unsigned long video_size_row;
112 static unsigned char video_page;
113 static unsigned short video_port_reg;
114 static unsigned short video_port_val;
115 static int can_do_color = 0;
116 static int printable = 0;
117
118 static struct {
119 unsigned short vc_video_erase_char;
120 unsigned char vc_attr;
121 unsigned char vc_def_color;
122 unsigned char vc_color;
123 unsigned char vc_s_color;
124 unsigned char vc_ulcolor;
125 unsigned char vc_halfcolor;
126 unsigned long vc_origin;
127 unsigned long vc_scr_end;
128 unsigned long vc_pos;
129 unsigned long vc_x,vc_y;
130 unsigned long vc_top,vc_bottom;
131 unsigned long vc_state;
132 unsigned long vc_npar,vc_par[NPAR];
133 unsigned long vc_video_mem_start;
134 unsigned long vc_video_mem_end;
135 unsigned long vc_saved_x;
136 unsigned long vc_saved_y;
137
138 unsigned long vc_charset : 1;
139 unsigned long vc_s_charset : 1;
140 unsigned long vc_disp_ctrl : 1;
141 unsigned long vc_toggle_meta : 1;
142 unsigned long vc_decscnm : 1;
143 unsigned long vc_decom : 1;
144 unsigned long vc_decawm : 1;
145 unsigned long vc_deccm : 1;
146 unsigned long vc_decim : 1;
147
148 unsigned long vc_intensity : 2;
149 unsigned long vc_underline : 1;
150 unsigned long vc_blink : 1;
151 unsigned long vc_reverse : 1;
152 unsigned long vc_s_intensity : 2;
153 unsigned long vc_s_underline : 1;
154 unsigned long vc_s_blink : 1;
155 unsigned long vc_s_reverse : 1;
156
157 unsigned long vc_ques : 1;
158 unsigned long vc_need_wrap : 1;
159 unsigned long vc_report_mouse : 2;
160 unsigned long vc_tab_stop[5];
161 unsigned char * vc_translate;
162 unsigned char * vc_G0_charset;
163 unsigned char * vc_G1_charset;
164 unsigned char * vc_saved_G0;
165 unsigned char * vc_saved_G1;
166
167 } vc_cons [NR_CONSOLES];
168
169 unsigned short *vc_scrbuf[NR_CONSOLES];
170 static unsigned short * vc_scrmembuf;
171 static int console_blanked = 0;
172
173 #define origin (vc_cons[currcons].vc_origin)
174 #define scr_end (vc_cons[currcons].vc_scr_end)
175 #define pos (vc_cons[currcons].vc_pos)
176 #define top (vc_cons[currcons].vc_top)
177 #define bottom (vc_cons[currcons].vc_bottom)
178 #define x (vc_cons[currcons].vc_x)
179 #define y (vc_cons[currcons].vc_y)
180 #define vc_state (vc_cons[currcons].vc_state)
181 #define npar (vc_cons[currcons].vc_npar)
182 #define par (vc_cons[currcons].vc_par)
183 #define ques (vc_cons[currcons].vc_ques)
184 #define attr (vc_cons[currcons].vc_attr)
185 #define saved_x (vc_cons[currcons].vc_saved_x)
186 #define saved_y (vc_cons[currcons].vc_saved_y)
187 #define translate (vc_cons[currcons].vc_translate)
188 #define G0_charset (vc_cons[currcons].vc_G0_charset)
189 #define G1_charset (vc_cons[currcons].vc_G1_charset)
190 #define saved_G0 (vc_cons[currcons].vc_saved_G0)
191 #define saved_G1 (vc_cons[currcons].vc_saved_G1)
192 #define video_mem_start (vc_cons[currcons].vc_video_mem_start)
193 #define video_mem_end (vc_cons[currcons].vc_video_mem_end)
194 #define video_erase_char (vc_cons[currcons].vc_video_erase_char)
195 #define disp_ctrl (vc_cons[currcons].vc_disp_ctrl)
196 #define toggle_meta (vc_cons[currcons].vc_toggle_meta)
197 #define decscnm (vc_cons[currcons].vc_decscnm)
198 #define decom (vc_cons[currcons].vc_decom)
199 #define decawm (vc_cons[currcons].vc_decawm)
200 #define deccm (vc_cons[currcons].vc_deccm)
201 #define decim (vc_cons[currcons].vc_decim)
202 #define need_wrap (vc_cons[currcons].vc_need_wrap)
203 #define report_mouse (vc_cons[currcons].vc_report_mouse)
204 #define color (vc_cons[currcons].vc_color)
205 #define s_color (vc_cons[currcons].vc_s_color)
206 #define def_color (vc_cons[currcons].vc_def_color)
207 #define foreground (color & 0x0f)
208 #define background (color & 0xf0)
209 #define charset (vc_cons[currcons].vc_charset)
210 #define s_charset (vc_cons[currcons].vc_s_charset)
211 #define intensity (vc_cons[currcons].vc_intensity)
212 #define underline (vc_cons[currcons].vc_underline)
213 #define blink (vc_cons[currcons].vc_blink)
214 #define reverse (vc_cons[currcons].vc_reverse)
215 #define s_intensity (vc_cons[currcons].vc_s_intensity)
216 #define s_underline (vc_cons[currcons].vc_s_underline)
217 #define s_blink (vc_cons[currcons].vc_s_blink)
218 #define s_reverse (vc_cons[currcons].vc_s_reverse)
219 #define ulcolor (vc_cons[currcons].vc_ulcolor)
220 #define halfcolor (vc_cons[currcons].vc_halfcolor)
221 #define tab_stop (vc_cons[currcons].vc_tab_stop)
222 #define vcmode (vt_cons[currcons].vc_mode)
223 #define vtmode (vt_cons[currcons].vt_mode)
224 #define vtpid (vt_cons[currcons].vt_pid)
225 #define vtnewvt (vt_cons[currcons].vt_newvt)
226
227 #define set_kbd(x) set_vc_kbd_mode(kbd_table+currcons,x)
228 #define clr_kbd(x) clr_vc_kbd_mode(kbd_table+currcons,x)
229 #define is_kbd(x) vc_kbd_mode(kbd_table+currcons,x)
230
231 #define decarm VC_REPEAT
232 #define decckm VC_CKMODE
233 #define kbdapplic VC_APPLIC
234 #define kbdraw VC_RAW
235 #define lnm VC_CRLF
236
237 int blankinterval = 10*60*HZ;
238 static int screen_size = 0;
239
240
241
242
243 #define VT100ID "\033[?1;2c"
244 #define VT102ID "\033[?6c"
245
246 static unsigned char * translations[] = {
247
248 (unsigned char *)
249 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
250 "\0\0\0\0\0\0\0\0\0\0\376\0\0\0\0\0"
251 " !\"#$%&'()*+,-./0123456789:;<=>?"
252 "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
253 "`abcdefghijklmnopqrstuvwxyz{|}~\0"
254 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
255 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
256 "\377\255\233\234\376\235\174\025\376\376\246\256\252\055\376\376"
257 "\370\361\375\376\376\346\024\371\376\376\247\257\254\253\376\250"
258 "\376\376\376\376\216\217\222\200\376\220\376\376\376\376\376\376"
259 "\376\245\376\376\376\376\231\376\350\376\376\376\232\376\376\341"
260 "\205\240\203\376\204\206\221\207\212\202\210\211\215\241\214\213"
261 "\376\244\225\242\223\376\224\366\355\227\243\226\201\376\376\230",
262
263 (unsigned char *)
264 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
265 "\0\0\0\0\0\0\0\0\0\0\376\0\0\0\0\0"
266 " !\"#$%&'()*+,-./0123456789:;<=>?"
267 "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^ "
268 "\004\261\007\007\007\007\370\361\007\007\331\277\332\300\305\304"
269 "\304\304\137\137\303\264\301\302\263\363\362\343\330\234\007\0"
270 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
271 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
272 "\377\255\233\234\376\235\174\025\376\376\246\256\252\055\376\376"
273 "\370\361\375\376\376\346\024\371\376\376\247\257\254\253\376\250"
274 "\376\376\376\376\216\217\222\200\376\220\376\376\376\376\376\376"
275 "\376\245\376\376\376\376\231\376\376\376\376\376\232\376\376\341"
276 "\205\240\203\376\204\206\221\207\212\202\210\211\215\241\214\213"
277 "\376\244\225\242\223\376\224\366\376\227\243\226\201\376\376\230",
278
279 (unsigned char *)
280 "\000\001\002\003\004\005\006\007\000\011\000\013\000\000\000\000"
281 "\020\021\022\023\024\025\026\027\030\031\032\000\034\035\036\037"
282 "\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
283 "\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
284 "\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
285 "\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
286 "\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
287 "\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
288 "\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
289 "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237"
290 "\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257"
291 "\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277"
292 "\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317"
293 "\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337"
294 "\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357"
295 "\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377",
296
297 (unsigned char *)
298 "\000\001\002\003\004\005\006\007\010\011\000\013\000\000\016\017"
299 "\020\021\022\023\024\025\026\027\030\031\032\000\034\035\036\037"
300 "\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
301 "\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
302 "\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
303 "\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
304 "\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
305 "\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
306 "\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
307 "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237"
308 "\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257"
309 "\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277"
310 "\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317"
311 "\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337"
312 "\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357"
313 "\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377"
314 };
315
316 #define NORM_TRANS (translations[0])
317 #define GRAF_TRANS (translations[1])
318 #define NULL_TRANS (translations[2])
319 #define USER_TRANS (translations[3])
320
321 static unsigned char color_table[] = { 0, 4, 2, 6, 1, 5, 3, 7,
322 8,12,10,14, 9,13,11,15 };
323
324
325
326
327
328
329 static void gotoxy(int currcons, int new_x, int new_y)
330 {
331 int max_y;
332
333 if (new_x < 0)
334 x = 0;
335 else
336 if (new_x >= video_num_columns)
337 x = video_num_columns - 1;
338 else
339 x = new_x;
340 if (decom) {
341 new_y += top;
342 max_y = bottom;
343 } else
344 max_y = video_num_lines;
345 if (new_y < 0)
346 y = 0;
347 else
348 if (new_y >= max_y)
349 y = max_y - 1;
350 else
351 y = new_y;
352 pos = origin + y*video_size_row + (x<<1);
353 need_wrap = 0;
354 }
355
356
357
358
359 static unsigned short __real_origin;
360 static unsigned short __origin;
361
362 static inline void __set_origin(unsigned short offset)
363 {
364 unsigned long flags;
365 #ifdef CONFIG_SELECTION
366 clear_selection();
367 #endif
368 save_flags(flags); cli();
369 __origin = offset;
370 outb_p(12, video_port_reg);
371 outb_p(offset >> 8, video_port_val);
372 outb_p(13, video_port_reg);
373 outb_p(offset, video_port_val);
374 restore_flags(flags);
375 }
376
377 void scrollback(int lines)
378 {
379 if (!lines)
380 lines = video_num_lines/2;
381 lines *= video_num_columns;
382 lines = __origin - lines;
383 if (lines < 0)
384 lines = 0;
385 __set_origin(lines);
386 }
387
388 void scrollfront(int lines)
389 {
390 if (!lines)
391 lines = video_num_lines/2;
392 lines *= video_num_columns;
393 lines = __origin + lines;
394 if (lines > __real_origin)
395 lines = __real_origin;
396 __set_origin(lines);
397 }
398
399 static void set_origin(int currcons)
400 {
401 if (video_type != VIDEO_TYPE_EGAC && video_type != VIDEO_TYPE_EGAM)
402 return;
403 if (currcons != fg_console || console_blanked || vcmode == KD_GRAPHICS)
404 return;
405 __real_origin = (origin-video_mem_base) >> 1;
406 __set_origin(__real_origin);
407 }
408
409
410
411
412 static inline void hide_cursor(void)
413 {
414
415
416
417 outb_p(14, video_port_reg);
418 outb_p(0xff&((video_mem_term-video_mem_base)>>9), video_port_val);
419 outb_p(15, video_port_reg);
420 outb_p(0xff&((video_mem_term-video_mem_base)>>1), video_port_val);
421 }
422
423 static inline void set_cursor(int currcons)
424 {
425 unsigned long flags;
426
427 if (currcons != fg_console || console_blanked || vcmode == KD_GRAPHICS)
428 return;
429 if (__real_origin != __origin)
430 set_origin(__real_origin);
431 save_flags(flags); cli();
432 if (deccm) {
433 outb_p(14, video_port_reg);
434 outb_p(0xff&((pos-video_mem_base)>>9), video_port_val);
435 outb_p(15, video_port_reg);
436 outb_p(0xff&((pos-video_mem_base)>>1), video_port_val);
437 } else
438 hide_cursor();
439 restore_flags(flags);
440 }
441
442 static void scrup(int currcons, unsigned int t, unsigned int b)
443 {
444 int hardscroll = 1;
445
446 if (b > video_num_lines || t >= b)
447 return;
448 if (video_type != VIDEO_TYPE_EGAC && video_type != VIDEO_TYPE_EGAM)
449 hardscroll = 0;
450 else if (t || b != video_num_lines)
451 hardscroll = 0;
452 if (hardscroll) {
453 origin += video_size_row;
454 pos += video_size_row;
455 scr_end += video_size_row;
456 if (scr_end > video_mem_end) {
457 __asm__("cld\n\t"
458 "rep\n\t"
459 "movsl\n\t"
460 "movl _video_num_columns,%1\n\t"
461 "rep\n\t"
462 "stosw"
463 :
464 :"a" (video_erase_char),
465 "c" ((video_num_lines-1)*video_num_columns>>1),
466 "D" (video_mem_start),
467 "S" (origin)
468 :"cx","di","si");
469 scr_end -= origin-video_mem_start;
470 pos -= origin-video_mem_start;
471 origin = video_mem_start;
472 } else {
473 __asm__("cld\n\t"
474 "rep\n\t"
475 "stosw"
476 :
477 :"a" (video_erase_char),
478 "c" (video_num_columns),
479 "D" (scr_end-video_size_row)
480 :"cx","di");
481 }
482 set_origin(currcons);
483 } else {
484 __asm__("cld\n\t"
485 "rep\n\t"
486 "movsl\n\t"
487 "movl _video_num_columns,%%ecx\n\t"
488 "rep\n\t"
489 "stosw"
490 :
491 :"a" (video_erase_char),
492 "c" ((b-t-1)*video_num_columns>>1),
493 "D" (origin+video_size_row*t),
494 "S" (origin+video_size_row*(t+1))
495 :"cx","di","si");
496 }
497 }
498
499 static void scrdown(int currcons, unsigned int t, unsigned int b)
500 {
501 if (b > video_num_lines || t >= b)
502 return;
503 __asm__("std\n\t"
504 "rep\n\t"
505 "movsl\n\t"
506 "addl $2,%%edi\n\t"
507 "movl _video_num_columns,%%ecx\n\t"
508 "rep\n\t"
509 "stosw\n\t"
510 "cld"
511 :
512 :"a" (video_erase_char),
513 "c" ((b-t-1)*video_num_columns>>1),
514 "D" (origin+video_size_row*b-4),
515 "S" (origin+video_size_row*(b-1)-4)
516 :"ax","cx","di","si");
517 }
518
519 static void lf(int currcons)
520 {
521 if (y+1<bottom) {
522 y++;
523 pos += video_size_row;
524 return;
525 } else
526 scrup(currcons,top,bottom);
527 need_wrap = 0;
528 }
529
530 static void ri(int currcons)
531 {
532 if (y>top) {
533 y--;
534 pos -= video_size_row;
535 return;
536 } else
537 scrdown(currcons,top,bottom);
538 need_wrap = 0;
539 }
540
541 static inline void cr(int currcons)
542 {
543 pos -= x<<1;
544 need_wrap = x = 0;
545 }
546
547 static inline void bs(int currcons)
548 {
549 if (x) {
550 pos -= 2;
551 x--;
552 need_wrap = 0;
553 }
554 }
555
556 static inline void del(int currcons)
557 {
558 #if 0
559 if (x) {
560 if (!need_wrap) {
561 pos -= 2;
562 x--;
563 }
564 *(unsigned short *)pos = video_erase_char;
565 need_wrap = 0;
566 }
567 #endif
568 }
569
570 static void csi_J(int currcons, int vpar)
571 {
572 unsigned long count;
573 unsigned long start;
574
575 switch (vpar) {
576 case 0:
577 count = (scr_end-pos)>>1;
578 start = pos;
579 break;
580 case 1:
581 count = ((pos-origin)>>1)+1;
582 start = origin;
583 break;
584 case 2:
585 count = video_num_columns * video_num_lines;
586 start = origin;
587 break;
588 default:
589 return;
590 }
591 __asm__("cld\n\t"
592 "rep\n\t"
593 "stosw\n\t"
594 :
595 :"c" (count),
596 "D" (start),"a" (video_erase_char)
597 :"cx","di");
598 need_wrap = 0;
599 }
600
601 static void csi_K(int currcons, int vpar)
602 {
603 long count;
604 long start;
605
606 switch (vpar) {
607 case 0:
608 count = video_num_columns-x;
609 start = pos;
610 break;
611 case 1:
612 start = pos - (x<<1);
613 count = x+1;
614 break;
615 case 2:
616 start = pos - (x<<1);
617 count = video_num_columns;
618 break;
619 default:
620 return;
621 }
622 __asm__("cld\n\t"
623 "rep\n\t"
624 "stosw\n\t"
625 :
626 :"c" (count),
627 "D" (start),"a" (video_erase_char)
628 :"cx","di");
629 need_wrap = 0;
630 }
631
632 static void csi_X(int currcons, int vpar)
633 {
634 long count;
635 long start;
636
637 if (!vpar)
638 vpar++;
639
640 start=pos;
641 count=(vpar > video_num_columns-x) ? (video_num_columns-x) : vpar;
642
643 __asm__("cld\n\t"
644 "rep\n\t"
645 "stosw\n\t"
646 :
647 :"c" (count),
648 "D" (start),"a" (video_erase_char)
649 :"cx","di");
650 need_wrap = 0;
651 }
652
653
654
655
656 static void update_attr(int currcons)
657 {
658 attr = color;
659 if (can_do_color) {
660 if (underline)
661 attr = (attr & 0xf0) | ulcolor;
662 else if (intensity == 0)
663 attr = (attr & 0xf0) | halfcolor;
664 }
665 if (reverse ^ decscnm)
666 attr = (attr & 0x88) | (((attr >> 4) | (attr << 4)) & 0x77);
667 if (blink)
668 attr ^= 0x80;
669 if (intensity == 2)
670 attr ^= 0x08;
671 if (!can_do_color) {
672 if (underline)
673 attr = (attr & 0xf8) | 0x01;
674 else if (intensity == 0)
675 attr = (attr & 0xf0) | 0x08;
676 }
677 if (decscnm)
678 video_erase_char = (((color & 0x88) | (((color >> 4) | (color << 4)) & 0x77)) << 8) | ' ';
679 else
680 video_erase_char = (color << 8) | ' ';
681 }
682
683 static void default_attr(int currcons)
684 {
685 intensity = 1;
686 underline = 0;
687 reverse = 0;
688 blink = 0;
689 color = def_color;
690 }
691
692 static void csi_m(int currcons)
693 {
694 int i;
695
696 for (i=0;i<=npar;i++)
697 switch (par[i]) {
698 case 0:
699 default_attr(currcons);
700 break;
701 case 1:
702 intensity = 2;
703 break;
704 case 2:
705 intensity = 0;
706 break;
707 case 4:
708 underline = 1;
709 break;
710 case 5:
711 blink = 1;
712 break;
713 case 7:
714 reverse = 1;
715 break;
716 case 10:
717
718
719
720
721 translate = (charset == 0
722 ? G0_charset
723 : G1_charset);
724 disp_ctrl = 0;
725 toggle_meta = 0;
726 break;
727 case 11:
728
729
730
731 translate = NULL_TRANS;
732 disp_ctrl = 1;
733 toggle_meta = 0;
734 break;
735 case 12:
736
737
738
739 translate = NULL_TRANS;
740 disp_ctrl = 1;
741 toggle_meta = 1;
742 break;
743 case 21:
744 case 22:
745 intensity = 1;
746 break;
747 case 24:
748 underline = 0;
749 break;
750 case 25:
751 blink = 0;
752 break;
753 case 27:
754 reverse = 0;
755 break;
756 case 38:
757
758
759
760
761 color = (def_color & 0x0f) | background;
762 underline = 1;
763 break;
764 case 39:
765
766
767
768
769 color = (def_color & 0x0f) | background;
770 underline = 0;
771 break;
772 case 49:
773 color = (def_color & 0xf0) | foreground;
774 break;
775 default:
776 if (par[i] >= 30 && par[i] <= 37)
777 color = color_table[par[i]-30]
778 | background;
779 else if (par[i] >= 40 && par[i] <= 47)
780 color = (color_table[par[i]-40]<<4)
781 | foreground;
782 break;
783 }
784 update_attr(currcons);
785 }
786
787 static void respond_string(char * p, struct tty_struct * tty)
788 {
789 while (*p) {
790 tty_insert_flip_char(tty, *p, 0);
791 p++;
792 }
793 tty_schedule_flip(tty);
794 }
795
796 static void cursor_report(int currcons, struct tty_struct * tty)
797 {
798 char buf[40];
799
800 sprintf(buf, "\033[%ld;%ldR", y + (decom ? top+1 : 1), x+1);
801 respond_string(buf, tty);
802 }
803
804 #ifdef CONFIG_SELECTION
805 static void mouse_report(int currcons, struct tty_struct * tty,
806 int butt, int mrx, int mry)
807 {
808 char buf[8];
809
810 sprintf(buf, "\033[M%c%c%c", (char)(' ' + butt), (char)('!' + mrx),
811 (char)('!' + mry));
812 respond_string(buf, tty);
813 }
814 #endif
815
816 static inline void status_report(int currcons, struct tty_struct * tty)
817 {
818 respond_string("\033[0n", tty);
819 }
820
821 static inline void respond_ID(int currcons, struct tty_struct * tty)
822 {
823 respond_string(VT102ID, tty);
824 }
825
826 static void invert_screen(int currcons) {
827 unsigned char *p;
828
829 if (can_do_color)
830 for (p = (unsigned char *)origin+1; p < (unsigned char *)scr_end; p+=2)
831 *p = (*p & 0x88) | (((*p >> 4) | (*p << 4)) & 0x77);
832 else
833 for (p = (unsigned char *)origin+1; p < (unsigned char *)scr_end; p+=2)
834 *p ^= *p & 0x07 == 1 ? 0x70 : 0x77;
835 }
836
837 static void set_mode(int currcons, int on_off)
838 {
839 int i;
840
841 for (i=0; i<=npar; i++)
842 if (ques) switch(par[i]) {
843 case 1:
844 if (on_off)
845 set_kbd(decckm);
846 else
847 clr_kbd(decckm);
848 break;
849 case 3:
850 csi_J(currcons,2);
851 gotoxy(currcons,0,0);
852 break;
853 case 5:
854 if (decscnm != on_off) {
855 decscnm = on_off;
856 invert_screen(currcons);
857 update_attr(currcons);
858 }
859 break;
860 case 6:
861 decom = on_off;
862 gotoxy(currcons,0,0);
863 break;
864 case 7:
865 decawm = on_off;
866 break;
867 case 8:
868 if (on_off)
869 set_kbd(decarm);
870 else
871 clr_kbd(decarm);
872 break;
873 case 9:
874 report_mouse = on_off ? 1 : 0;
875 break;
876 case 25:
877 deccm = on_off;
878 set_cursor(currcons);
879 break;
880 case 1000:
881 report_mouse = on_off ? 2 : 0;
882 break;
883 } else switch(par[i]) {
884 case 4:
885 decim = on_off;
886 break;
887 case 20:
888 if (on_off)
889 set_kbd(lnm);
890 else
891 clr_kbd(lnm);
892 break;
893 }
894 }
895
896 static void setterm_command(int currcons)
897 {
898 switch(par[0]) {
899 case 1:
900 if (can_do_color && par[1] < 16) {
901 ulcolor = color_table[par[1]];
902 if (underline)
903 update_attr(currcons);
904 }
905 break;
906 case 2:
907 if (can_do_color && par[1] < 16) {
908 halfcolor = color_table[par[1]];
909 if (intensity == 0)
910 update_attr(currcons);
911 }
912 break;
913 case 8:
914 def_color = attr;
915 default_attr(currcons);
916 update_attr(currcons);
917 break;
918 case 9:
919 blankinterval = ((par[1] < 60) ? par[1] : 60) * 60 * HZ;
920 break;
921 }
922 }
923
924 static void insert_char(int currcons)
925 {
926 unsigned int i = x;
927 unsigned short tmp, old = video_erase_char;
928 unsigned short * p = (unsigned short *) pos;
929
930 while (i++ < video_num_columns) {
931 tmp = *p;
932 *p = old;
933 old = tmp;
934 p++;
935 }
936 need_wrap = 0;
937 }
938
939 static void insert_line(int currcons)
940 {
941 scrdown(currcons,y,bottom);
942 need_wrap = 0;
943 }
944
945 static void delete_char(int currcons)
946 {
947 unsigned int i = x;
948 unsigned short * p = (unsigned short *) pos;
949
950 while (++i < video_num_columns) {
951 *p = *(p+1);
952 p++;
953 }
954 *p = video_erase_char;
955 need_wrap = 0;
956 }
957
958 static void delete_line(int currcons)
959 {
960 scrup(currcons,y,bottom);
961 need_wrap = 0;
962 }
963
964 static void csi_at(int currcons, unsigned int nr)
965 {
966 if (nr > video_num_columns)
967 nr = video_num_columns;
968 else if (!nr)
969 nr = 1;
970 while (nr--)
971 insert_char(currcons);
972 }
973
974 static void csi_L(int currcons, unsigned int nr)
975 {
976 if (nr > video_num_lines)
977 nr = video_num_lines;
978 else if (!nr)
979 nr = 1;
980 while (nr--)
981 insert_line(currcons);
982 }
983
984 static void csi_P(int currcons, unsigned int nr)
985 {
986 if (nr > video_num_columns)
987 nr = video_num_columns;
988 else if (!nr)
989 nr = 1;
990 while (nr--)
991 delete_char(currcons);
992 }
993
994 static void csi_M(int currcons, unsigned int nr)
995 {
996 if (nr > video_num_lines)
997 nr = video_num_lines;
998 else if (!nr)
999 nr=1;
1000 while (nr--)
1001 delete_line(currcons);
1002 }
1003
1004 static void save_cur(int currcons)
1005 {
1006 saved_x = x;
1007 saved_y = y;
1008 s_intensity = intensity;
1009 s_underline = underline;
1010 s_blink = blink;
1011 s_reverse = reverse;
1012 s_charset = charset;
1013 s_color = color;
1014 saved_G0 = G0_charset;
1015 saved_G1 = G1_charset;
1016 }
1017
1018 static void restore_cur(int currcons)
1019 {
1020 gotoxy(currcons,saved_x,saved_y);
1021 intensity = s_intensity;
1022 underline = s_underline;
1023 blink = s_blink;
1024 reverse = s_reverse;
1025 charset = s_charset;
1026 color = s_color;
1027 G0_charset = saved_G0;
1028 G1_charset = saved_G1;
1029 translate = charset ? G1_charset : G0_charset;
1030 update_attr(currcons);
1031 need_wrap = 0;
1032 }
1033
1034 enum { ESnormal, ESesc, ESsquare, ESgetpars, ESgotpars, ESfunckey,
1035 EShash, ESsetG0, ESsetG1, ESignore };
1036
1037 static void reset_terminal(int currcons, int do_clear)
1038 {
1039 top = 0;
1040 bottom = video_num_lines;
1041 vc_state = ESnormal;
1042 ques = 0;
1043 translate = NORM_TRANS;
1044 G0_charset = NORM_TRANS;
1045 G1_charset = GRAF_TRANS;
1046 charset = 0;
1047 need_wrap = 0;
1048 report_mouse = 0;
1049
1050 disp_ctrl = 0;
1051 toggle_meta = 0;
1052
1053 decscnm = 0;
1054 decom = 0;
1055 decawm = 1;
1056 deccm = 1;
1057 decim = 0;
1058
1059 set_kbd(decarm);
1060 clr_kbd(decckm);
1061 clr_kbd(kbdapplic);
1062 clr_kbd(lnm);
1063 kbd_table[currcons].lockstate = 0;
1064 kbd_table[currcons].ledstate = kbd_table[currcons].default_ledstate;
1065 set_leds();
1066
1067 default_attr(currcons);
1068 update_attr(currcons);
1069
1070 tab_stop[0] = 0x01010100;
1071 tab_stop[1] =
1072 tab_stop[2] =
1073 tab_stop[3] =
1074 tab_stop[4] = 0x01010101;
1075
1076 if (do_clear) {
1077 gotoxy(currcons,0,0);
1078 csi_J(currcons,2);
1079 save_cur(currcons);
1080 }
1081 }
1082
1083
1084
1085
1086 static void con_stop(struct tty_struct *tty)
1087 {
1088 set_vc_kbd_led(kbd_table + fg_console, VC_SCROLLOCK);
1089 set_leds();
1090 }
1091
1092
1093
1094
1095 static void con_start(struct tty_struct *tty)
1096 {
1097 clr_vc_kbd_led(kbd_table + fg_console, VC_SCROLLOCK);
1098 set_leds();
1099 }
1100
1101 static int con_write(struct tty_struct * tty, int from_user,
1102 unsigned char *buf, int count)
1103 {
1104 int c, n = 0;
1105 unsigned int currcons;
1106 struct vt_struct *vt = (struct vt_struct *)tty->driver_data;
1107
1108 currcons = vt->vc_num;
1109 if (currcons >= NR_CONSOLES) {
1110 printk("con_write: illegal vc index (%d)\n", currcons);
1111 return 0;
1112 }
1113 #ifdef CONFIG_SELECTION
1114
1115 if (currcons == sel_cons)
1116 clear_selection();
1117 #endif
1118 disable_bh(KEYBOARD_BH);
1119 while (!tty->stopped && count) {
1120 c = from_user ? get_fs_byte(buf) : *buf;
1121 buf++; n++; count--;
1122 if (vc_state == ESnormal
1123 && (c >= 32 || (disp_ctrl && (c&0x7f) != 27))
1124 && (toggle_meta ? translate[c|0x80] : translate[c])) {
1125 if (toggle_meta)
1126 c |= 0x80;
1127 if (need_wrap) {
1128 cr(currcons);
1129 lf(currcons);
1130 }
1131 if (decim)
1132 insert_char(currcons);
1133 c = translate[c];
1134 *(unsigned short *) pos = (attr << 8) + c;
1135 if (x == video_num_columns - 1)
1136 need_wrap = decawm;
1137 else {
1138 x++;
1139 pos+=2;
1140 }
1141 continue;
1142 }
1143
1144
1145
1146
1147
1148 switch (c) {
1149 case 7:
1150 kd_mksound(0x637, HZ/8);
1151 continue;
1152 case 8:
1153 bs(currcons);
1154 continue;
1155 case 9:
1156 pos -= (x << 1);
1157 while (x < video_num_columns - 1) {
1158 x++;
1159 if (tab_stop[x >> 5] & (1 << (x & 31)))
1160 break;
1161 }
1162 pos += (x << 1);
1163 continue;
1164 case 10: case 11: case 12:
1165 lf(currcons);
1166 if (!is_kbd(lnm))
1167 continue;
1168 case 13:
1169 cr(currcons);
1170 continue;
1171 case 14:
1172 charset = 1;
1173 translate = G1_charset;
1174 continue;
1175 case 15:
1176 charset = 0;
1177 translate = G0_charset;
1178 continue;
1179 case 24: case 26:
1180 vc_state = ESnormal;
1181 continue;
1182 case 27:
1183 vc_state = ESesc;
1184 continue;
1185 case 127:
1186 del(currcons);
1187 continue;
1188 case 128+27:
1189 vc_state = ESsquare;
1190 continue;
1191 }
1192 switch(vc_state) {
1193 case ESesc:
1194 vc_state = ESnormal;
1195 switch (c) {
1196 case '[':
1197 vc_state = ESsquare;
1198 continue;
1199 case 'E':
1200 cr(currcons);
1201 lf(currcons);
1202 continue;
1203 case 'M':
1204 ri(currcons);
1205 continue;
1206 case 'D':
1207 lf(currcons);
1208 continue;
1209 case 'H':
1210 tab_stop[x >> 5] |= (1 << (x & 31));
1211 continue;
1212 case 'Z':
1213 respond_ID(currcons,tty);
1214 continue;
1215 case '7':
1216 save_cur(currcons);
1217 continue;
1218 case '8':
1219 restore_cur(currcons);
1220 continue;
1221 case '(':
1222 vc_state = ESsetG0;
1223 continue;
1224 case ')':
1225 vc_state = ESsetG1;
1226 continue;
1227 case '#':
1228 vc_state = EShash;
1229 continue;
1230 case 'c':
1231 reset_terminal(currcons,1);
1232 continue;
1233 case '>':
1234 clr_kbd(kbdapplic);
1235 continue;
1236 case '=':
1237 set_kbd(kbdapplic);
1238 continue;
1239 }
1240 continue;
1241 case ESsquare:
1242 for(npar = 0 ; npar < NPAR ; npar++)
1243 par[npar] = 0;
1244 npar = 0;
1245 vc_state = ESgetpars;
1246 if (c == '[') {
1247 vc_state=ESfunckey;
1248 continue;
1249 }
1250 ques = (c=='?');
1251 if (ques)
1252 continue;
1253 case ESgetpars:
1254 if (c==';' && npar<NPAR-1) {
1255 npar++;
1256 continue;
1257 } else if (c>='0' && c<='9') {
1258 par[npar] *= 10;
1259 par[npar] += c-'0';
1260 continue;
1261 } else vc_state=ESgotpars;
1262 case ESgotpars:
1263 vc_state = ESnormal;
1264 switch(c) {
1265 case 'h':
1266 set_mode(currcons,1);
1267 continue;
1268 case 'l':
1269 set_mode(currcons,0);
1270 continue;
1271 case 'n':
1272 if (!ques)
1273 if (par[0] == 5)
1274 status_report(currcons,tty);
1275 else if (par[0] == 6)
1276 cursor_report(currcons,tty);
1277 continue;
1278 }
1279 if (ques) {
1280 ques = 0;
1281 continue;
1282 }
1283 switch(c) {
1284 case 'G': case '`':
1285 if (par[0]) par[0]--;
1286 gotoxy(currcons,par[0],y);
1287 continue;
1288 case 'A':
1289 if (!par[0]) par[0]++;
1290 gotoxy(currcons,x,y-par[0]);
1291 continue;
1292 case 'B': case 'e':
1293 if (!par[0]) par[0]++;
1294 gotoxy(currcons,x,y+par[0]);
1295 continue;
1296 case 'C': case 'a':
1297 if (!par[0]) par[0]++;
1298 gotoxy(currcons,x+par[0],y);
1299 continue;
1300 case 'D':
1301 if (!par[0]) par[0]++;
1302 gotoxy(currcons,x-par[0],y);
1303 continue;
1304 case 'E':
1305 if (!par[0]) par[0]++;
1306 gotoxy(currcons,0,y+par[0]);
1307 continue;
1308 case 'F':
1309 if (!par[0]) par[0]++;
1310 gotoxy(currcons,0,y-par[0]);
1311 continue;
1312 case 'd':
1313 if (par[0]) par[0]--;
1314 gotoxy(currcons,x,par[0]);
1315 continue;
1316 case 'H': case 'f':
1317 if (par[0]) par[0]--;
1318 if (par[1]) par[1]--;
1319 gotoxy(currcons,par[1],par[0]);
1320 continue;
1321 case 'J':
1322 csi_J(currcons,par[0]);
1323 continue;
1324 case 'K':
1325 csi_K(currcons,par[0]);
1326 continue;
1327 case 'L':
1328 csi_L(currcons,par[0]);
1329 continue;
1330 case 'M':
1331 csi_M(currcons,par[0]);
1332 continue;
1333 case 'P':
1334 csi_P(currcons,par[0]);
1335 continue;
1336 case 'c':
1337 if (!par[0])
1338 respond_ID(currcons,tty);
1339 continue;
1340 case 'g':
1341 if (!par[0])
1342 tab_stop[x >> 5] &= ~(1 << (x & 31));
1343 else if (par[0] == 3) {
1344 tab_stop[0] =
1345 tab_stop[1] =
1346 tab_stop[2] =
1347 tab_stop[3] =
1348 tab_stop[4] = 0;
1349 }
1350 continue;
1351 case 'm':
1352 csi_m(currcons);
1353 continue;
1354 case 'r':
1355 if (!par[0])
1356 par[0]++;
1357 if (!par[1])
1358 par[1] = video_num_lines;
1359
1360 if (par[0] < par[1] &&
1361 par[1] <= video_num_lines) {
1362 top=par[0]-1;
1363 bottom=par[1];
1364 gotoxy(currcons,0,0);
1365 }
1366 continue;
1367 case 's':
1368 save_cur(currcons);
1369 continue;
1370 case 'u':
1371 restore_cur(currcons);
1372 continue;
1373 case 'X':
1374 csi_X(currcons, par[0]);
1375 continue;
1376 case '@':
1377 csi_at(currcons,par[0]);
1378 continue;
1379 case ']':
1380 setterm_command(currcons);
1381 continue;
1382 }
1383 continue;
1384 case ESfunckey:
1385 vc_state = ESnormal;
1386 continue;
1387 case EShash:
1388 vc_state = ESnormal;
1389 if (c == '8') {
1390
1391 video_erase_char =
1392 (video_erase_char & 0xff00) | 'E';
1393 csi_J(currcons, 2);
1394 video_erase_char =
1395 (video_erase_char & 0xff00) | ' ';
1396 }
1397 continue;
1398 case ESsetG0:
1399 if (c == '0')
1400 G0_charset = GRAF_TRANS;
1401 else if (c == 'B')
1402 G0_charset = NORM_TRANS;
1403 else if (c == 'U')
1404 G0_charset = NULL_TRANS;
1405 else if (c == 'K')
1406 G0_charset = USER_TRANS;
1407 if (charset == 0)
1408 translate = G0_charset;
1409 vc_state = ESnormal;
1410 continue;
1411 case ESsetG1:
1412 if (c == '0')
1413 G1_charset = GRAF_TRANS;
1414 else if (c == 'B')
1415 G1_charset = NORM_TRANS;
1416 else if (c == 'U')
1417 G1_charset = NULL_TRANS;
1418 else if (c == 'K')
1419 G1_charset = USER_TRANS;
1420 if (charset == 1)
1421 translate = G1_charset;
1422 vc_state = ESnormal;
1423 continue;
1424 default:
1425 vc_state = ESnormal;
1426 }
1427 }
1428 if (vcmode != KD_GRAPHICS)
1429 set_cursor(currcons);
1430 enable_bh(KEYBOARD_BH);
1431 return n;
1432 }
1433
1434 static int con_write_room(struct tty_struct *tty)
1435 {
1436 if (tty->stopped)
1437 return 0;
1438 return 4096;
1439 }
1440
1441 static int con_chars_in_buffer(struct tty_struct *tty)
1442 {
1443 return 0;
1444 }
1445
1446 void poke_blanked_console(void)
1447 {
1448 timer_active &= ~(1<<BLANK_TIMER);
1449 if (vt_cons[fg_console].vc_mode == KD_GRAPHICS)
1450 return;
1451 if (console_blanked) {
1452 timer_table[BLANK_TIMER].expires = 0;
1453 timer_active |= 1<<BLANK_TIMER;
1454 } else if (blankinterval) {
1455 timer_table[BLANK_TIMER].expires = jiffies + blankinterval;
1456 timer_active |= 1<<BLANK_TIMER;
1457 }
1458 }
1459
1460 void * memsetw(void * s, unsigned short c, unsigned int count)
1461 {
1462 __asm__("cld\n\t"
1463 "rep\n\t"
1464 "stosw"
1465 :
1466 :"a" (c),"D" (s),"c" (count/2)
1467 :"cx","di");
1468 return s;
1469 }
1470
1471 void console_print(const char * b)
1472 {
1473 int currcons = fg_console;
1474 unsigned char c;
1475
1476 if (!printable || currcons<0 || currcons>=NR_CONSOLES)
1477 return;
1478 while ((c = *(b++)) != 0) {
1479 if (c == 10 || c == 13 || need_wrap) {
1480 if (c != 13)
1481 lf(currcons);
1482 cr(currcons);
1483 if (c == 10 || c == 13)
1484 continue;
1485 }
1486 *(unsigned short *) pos = (attr << 8) + c;
1487 if (x == video_num_columns - 1) {
1488 need_wrap = 1;
1489 continue;
1490 }
1491 x++;
1492 pos+=2;
1493 }
1494 set_cursor(currcons);
1495 if (vt_cons[fg_console].vc_mode == KD_GRAPHICS)
1496 return;
1497 timer_active &= ~(1<<BLANK_TIMER);
1498 if (console_blanked) {
1499 timer_table[BLANK_TIMER].expires = 0;
1500 timer_active |= 1<<BLANK_TIMER;
1501 } else if (blankinterval) {
1502 timer_table[BLANK_TIMER].expires = jiffies + blankinterval;
1503 timer_active |= 1<<BLANK_TIMER;
1504 }
1505 }
1506
1507
1508
1509
1510
1511
1512 static void con_throttle(struct tty_struct *tty)
1513 {
1514 }
1515
1516 static void con_unthrottle(struct tty_struct *tty)
1517 {
1518 struct vt_struct *vt = (struct vt_struct *) tty->driver_data;
1519
1520 wake_up_interruptible(&vt->paste_wait);
1521 }
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533 long con_init(long kmem_start)
1534 {
1535 char *display_desc = "????";
1536 int currcons = 0;
1537 long base;
1538 int orig_x = ORIG_X;
1539 int orig_y = ORIG_Y;
1540
1541 memset(&console_driver, 0, sizeof(struct tty_driver));
1542 console_driver.magic = TTY_DRIVER_MAGIC;
1543 console_driver.name = "tty";
1544 console_driver.name_base = 1;
1545 console_driver.major = TTY_MAJOR;
1546 console_driver.minor_start = 1;
1547 console_driver.num = NR_CONSOLES;
1548 console_driver.type = TTY_DRIVER_TYPE_CONSOLE;
1549 console_driver.init_termios = tty_std_termios;
1550 console_driver.flags = TTY_DRIVER_REAL_RAW;
1551 console_driver.refcount = &console_refcount;
1552 console_driver.table = console_table;
1553 console_driver.termios = console_termios;
1554 console_driver.termios_locked = console_termios_locked;
1555
1556 console_driver.open = con_open;
1557 console_driver.write = con_write;
1558 console_driver.write_room = con_write_room;
1559 console_driver.chars_in_buffer = con_chars_in_buffer;
1560 console_driver.ioctl = vt_ioctl;
1561 console_driver.stop = con_stop;
1562 console_driver.start = con_start;
1563 console_driver.throttle = con_throttle;
1564 console_driver.unthrottle = con_unthrottle;
1565
1566 if (tty_register_driver(&console_driver))
1567 panic("Couldn't register console driver\n");
1568
1569 vc_scrmembuf = (unsigned short *) kmem_start;
1570 video_num_columns = ORIG_VIDEO_COLS;
1571 video_size_row = video_num_columns * 2;
1572 video_num_lines = ORIG_VIDEO_LINES;
1573 video_page = ORIG_VIDEO_PAGE;
1574 screen_size = (video_num_lines * video_size_row);
1575 kmem_start += NR_CONSOLES * screen_size;
1576 timer_table[BLANK_TIMER].fn = blank_screen;
1577 timer_table[BLANK_TIMER].expires = 0;
1578 if (blankinterval) {
1579 timer_table[BLANK_TIMER].expires = jiffies+blankinterval;
1580 timer_active |= 1<<BLANK_TIMER;
1581 }
1582
1583 if (ORIG_VIDEO_MODE == 7)
1584 {
1585 video_mem_base = 0xb0000;
1586 video_port_reg = 0x3b4;
1587 video_port_val = 0x3b5;
1588 if ((ORIG_VIDEO_EGA_BX & 0xff) != 0x10)
1589 {
1590 video_type = VIDEO_TYPE_EGAM;
1591 video_mem_term = 0xb8000;
1592 display_desc = "EGA+";
1593 }
1594 else
1595 {
1596 video_type = VIDEO_TYPE_MDA;
1597 video_mem_term = 0xb2000;
1598 display_desc = "*MDA";
1599 }
1600 }
1601 else
1602 {
1603 can_do_color = 1;
1604 video_mem_base = 0xb8000;
1605 video_port_reg = 0x3d4;
1606 video_port_val = 0x3d5;
1607 if ((ORIG_VIDEO_EGA_BX & 0xff) != 0x10)
1608 {
1609 video_type = VIDEO_TYPE_EGAC;
1610 video_mem_term = 0xc0000;
1611 display_desc = "EGA+";
1612 }
1613 else
1614 {
1615 video_type = VIDEO_TYPE_CGA;
1616 video_mem_term = 0xba000;
1617 display_desc = "*CGA";
1618 }
1619 }
1620
1621
1622
1623 base = (long)vc_scrmembuf;
1624 for (currcons = 0; currcons<NR_CONSOLES; currcons++) {
1625 pos = origin = video_mem_start = base;
1626 scr_end = video_mem_end = (base += screen_size);
1627 vc_scrbuf[currcons] = (unsigned short *) origin;
1628 vcmode = KD_TEXT;
1629 vtmode.mode = VT_AUTO;
1630 vtmode.waitv = 0;
1631 vtmode.relsig = 0;
1632 vtmode.acqsig = 0;
1633 vtmode.frsig = 0;
1634 vtpid = -1;
1635 vtnewvt = -1;
1636 clr_kbd(kbdraw);
1637 def_color = 0x07;
1638 ulcolor = 0x0f;
1639 halfcolor = 0x08;
1640 vt_cons[currcons].paste_wait = 0;
1641 reset_terminal(currcons, currcons);
1642 }
1643 currcons = fg_console = 0;
1644
1645 video_mem_start = video_mem_base;
1646 video_mem_end = video_mem_term;
1647 origin = video_mem_start;
1648 scr_end = video_mem_start + video_num_lines * video_size_row;
1649 gotoxy(currcons,0,0);
1650 save_cur(currcons);
1651 gotoxy(currcons,orig_x,orig_y);
1652 update_screen(fg_console);
1653 printable = 1;
1654 printk("Console: %s %s %ldx%ld, %d virtual consoles\n",
1655 can_do_color?"colour":"mono",
1656 display_desc,
1657 video_num_columns,video_num_lines,
1658 NR_CONSOLES);
1659 register_console(console_print);
1660 return kmem_start;
1661 }
1662
1663
1664
1665
1666
1667 void kbdsave(int new_console)
1668 {
1669 }
1670
1671 static void get_scrmem(int currcons)
1672 {
1673 memcpy((void *)vc_scrbuf[currcons],(void *)origin, screen_size);
1674 video_mem_start = (unsigned long)vc_scrbuf[currcons];
1675 origin = video_mem_start;
1676 scr_end = video_mem_end = video_mem_start+screen_size;
1677 pos = origin + y*video_size_row + (x<<1);
1678 }
1679
1680 static void set_scrmem(int currcons)
1681 {
1682 #ifdef CONFIG_HGA
1683
1684
1685
1686
1687
1688
1689
1690 if (video_type == VIDEO_TYPE_MDA)
1691 {
1692 if (vcmode == KD_TEXT)
1693 {
1694
1695 int i;
1696 static char herc_txt_tbl[12] = {
1697 0x61,0x50,0x52,0x0f,0x19,6,0x19,0x19,2,0x0d,0x0b,0x0c };
1698 outb_p(0, 0x3bf);
1699 outb_p(0, 0x3b8);
1700 for ( i = 0 ; i < 12 ; i++ )
1701 {
1702 outb_p(i, 0x3b4);
1703 outb_p(herc_txt_tbl[i], 0x3b5);
1704 }
1705 }
1706 #define HGA_BLINKER_ON 0x20
1707 #define HGA_SCREEN_ON 8
1708
1709 outb_p(HGA_BLINKER_ON | HGA_SCREEN_ON, 0x3b8);
1710 }
1711 #endif CONFIG_HGA
1712
1713 video_mem_start = video_mem_base;
1714 video_mem_end = video_mem_term;
1715 origin = video_mem_start;
1716 scr_end = video_mem_start + screen_size;
1717 pos = origin + y*video_size_row + (x<<1);
1718 memcpy((void *)video_mem_base, (void *)vc_scrbuf[fg_console], screen_size);
1719 }
1720
1721 void blank_screen(void)
1722 {
1723 if (console_blanked)
1724 return;
1725 timer_table[BLANK_TIMER].fn = unblank_screen;
1726 get_scrmem(fg_console);
1727 hide_cursor();
1728 console_blanked = 1;
1729 memsetw((void *)video_mem_base, 0x0020, video_mem_term-video_mem_base );
1730 }
1731
1732 void unblank_screen(void)
1733 {
1734 if (!console_blanked)
1735 return;
1736 timer_table[BLANK_TIMER].fn = blank_screen;
1737 if (blankinterval) {
1738 timer_table[BLANK_TIMER].expires = jiffies + blankinterval;
1739 timer_active |= 1<<BLANK_TIMER;
1740 }
1741 console_blanked = 0;
1742 set_scrmem(fg_console);
1743 set_origin(fg_console);
1744 set_cursor(fg_console);
1745 }
1746
1747 void update_screen(int new_console)
1748 {
1749 static int lock = 0;
1750
1751 if (new_console == fg_console || lock)
1752 return;
1753 lock = 1;
1754 kbdsave(new_console);
1755 #ifdef CONFIG_SELECTION
1756 highlight_pointer(fg_console,-1);
1757 #endif
1758 get_scrmem(fg_console);
1759 fg_console = new_console;
1760 set_scrmem(fg_console);
1761 set_origin(fg_console);
1762 set_cursor(new_console);
1763 set_leds();
1764 compute_shiftstate();
1765 lock = 0;
1766 }
1767
1768 int do_screendump(int arg)
1769 {
1770 char *sptr, *buf = (char *)arg;
1771 int currcons, l;
1772
1773 if (!suser())
1774 return -EPERM;
1775 l = verify_area(VERIFY_WRITE, buf,2+video_num_columns*video_num_lines);
1776 if (l)
1777 return l;
1778 currcons = get_fs_byte(buf+1);
1779 if ((currcons<0) || (currcons>NR_CONSOLES))
1780 return -EIO;
1781 put_fs_byte((char)(video_num_lines),buf++);
1782 put_fs_byte((char)(video_num_columns),buf++);
1783 currcons = (currcons ? currcons-1 : fg_console);
1784 sptr = (char *) origin;
1785 for (l=video_num_lines*video_num_columns; l>0 ; l--, sptr++)
1786 put_fs_byte(*sptr++,buf++);
1787 return(0);
1788 }
1789
1790
1791
1792
1793
1794 int con_open(struct tty_struct *tty, struct file * filp)
1795 {
1796 int idx;
1797
1798 idx = MINOR(tty->device) - tty->driver.minor_start;
1799
1800 if (idx > NR_CONSOLES)
1801 return -ENODEV;
1802 vt_cons[idx].vc_num = idx;
1803 tty->driver_data = &vt_cons[idx];
1804
1805 if (!tty->winsize.ws_row && !tty->winsize.ws_col) {
1806 tty->winsize.ws_row = video_num_lines;
1807 tty->winsize.ws_col = video_num_columns;
1808 }
1809 return 0;
1810 }
1811
1812 #ifdef CONFIG_SELECTION
1813
1814 #define hwscroll_offset (currcons == fg_console ? ((__real_origin - __origin) << 1) : 0)
1815
1816
1817 static void highlight(const int currcons, const int s, const int e)
1818 {
1819 unsigned char *p, *p1, *p2;
1820
1821 p1 = (unsigned char *)origin - hwscroll_offset + s + 1;
1822 p2 = (unsigned char *)origin - hwscroll_offset + e + 1;
1823 if (p1 > p2)
1824 {
1825 p = p1;
1826 p1 = p2;
1827 p2 = p;
1828 }
1829 for (p = p1; p <= p2; p += 2)
1830 *p = (*p & 0x88) | ((*p << 4) & 0x70) | ((*p >> 4) & 0x07);
1831 }
1832
1833
1834 static void highlight_pointer(const int currcons, const int where)
1835 {
1836 unsigned char *p;
1837 static unsigned char *prev=NULL;
1838
1839 if (where==-1)
1840 {
1841 if (prev)
1842 {
1843 *prev ^= 0x77;
1844 prev=NULL;
1845 }
1846 }
1847 else
1848 {
1849 p = (unsigned char *)origin - hwscroll_offset + where + 1;
1850 *p ^= 0x77;
1851 if (prev) *prev ^= 0x77;
1852 prev=p;
1853 }
1854 }
1855
1856
1857
1858
1859
1860 static unsigned long inwordLut[4]={
1861 0x00000000,
1862 0x03FF0000,
1863 0x87FFFFFE,
1864 0x07FFFFFE
1865 };
1866 static inline int inword(const char c) {
1867 return ( inwordLut[(c>>5)&3] >> (c&0x1F) ) & 1;
1868 }
1869
1870
1871 int sel_loadlut(const int arg)
1872 {
1873 memcpy_fromfs(inwordLut,(unsigned long *)(arg+4),16);
1874 return 0;
1875 }
1876
1877
1878 static inline int atedge(const int p)
1879 {
1880 return (!(p % video_size_row) || !((p + 2) % video_size_row));
1881 }
1882
1883
1884 static inline short limit(const int v, const int l, const int u)
1885 {
1886 return (v < l) ? l : ((v > u) ? u : v);
1887 }
1888
1889
1890 int mouse_reporting(void)
1891 {
1892 int currcons = fg_console;
1893
1894 return report_mouse;
1895 }
1896
1897
1898 int set_selection(const int arg, struct tty_struct *tty)
1899 {
1900 unsigned short *args, xs, ys, xe, ye;
1901 int currcons = fg_console;
1902 int sel_mode, new_sel_start, new_sel_end, spc;
1903 char *bp, *obp, *spos;
1904 int i, ps, pe;
1905 char *off = (char *)origin - hwscroll_offset;
1906
1907 unblank_screen();
1908 args = (unsigned short *)(arg + 1);
1909 xs = get_fs_word(args++) - 1;
1910 ys = get_fs_word(args++) - 1;
1911 xe = get_fs_word(args++) - 1;
1912 ye = get_fs_word(args++) - 1;
1913 sel_mode = get_fs_word(args);
1914
1915 xs = limit(xs, 0, video_num_columns - 1);
1916 ys = limit(ys, 0, video_num_lines - 1);
1917 xe = limit(xe, 0, video_num_columns - 1);
1918 ye = limit(ye, 0, video_num_lines - 1);
1919 ps = ys * video_size_row + (xs << 1);
1920 pe = ye * video_size_row + (xe << 1);
1921
1922 if (report_mouse && (sel_mode & 16)) {
1923 mouse_report(currcons, tty, sel_mode & 15, xs, ys);
1924 return 0;
1925 }
1926
1927 if (ps > pe)
1928 {
1929 int tmp = ps;
1930 ps = pe;
1931 pe = tmp;
1932 }
1933
1934 switch (sel_mode)
1935 {
1936 case 0:
1937 new_sel_start = ps;
1938 new_sel_end = pe;
1939 break;
1940 case 1:
1941 spc = isspace(*(off + ps));
1942 for (new_sel_start = ps; ; ps -= 2)
1943 {
1944 if ((spc && !isspace(*(off + ps))) ||
1945 (!spc && !inword(*(off + ps))))
1946 break;
1947 new_sel_start = ps;
1948 if (!(ps % video_size_row))
1949 break;
1950 }
1951 spc = isspace(*(off + pe));
1952 for (new_sel_end = pe; ; pe += 2)
1953 {
1954 if ((spc && !isspace(*(off + pe))) ||
1955 (!spc && !inword(*(off + pe))))
1956 break;
1957 new_sel_end = pe;
1958 if (!((pe + 2) % video_size_row))
1959 break;
1960 }
1961 break;
1962 case 2:
1963 new_sel_start = ps - ps % video_size_row;
1964 new_sel_end = pe + video_size_row
1965 - pe % video_size_row - 2;
1966 break;
1967 case 3:
1968 if (sel_cons != currcons)
1969 {
1970 highlight_pointer(sel_cons,-1);
1971 clear_selection();
1972 sel_cons = currcons;
1973 }
1974 highlight_pointer(sel_cons,pe);
1975 return 0;
1976 default:
1977 return -EINVAL;
1978 }
1979
1980 if (new_sel_end > new_sel_start &&
1981 !atedge(new_sel_end) && isspace(*(off + new_sel_end)))
1982 {
1983 for (pe = new_sel_end + 2; ; pe += 2)
1984 {
1985 if (!isspace(*(off + pe)) || atedge(pe))
1986 break;
1987 }
1988 if (isspace(*(off + pe)))
1989 new_sel_end = pe;
1990 }
1991 if (sel_cons != currcons)
1992 {
1993 clear_selection();
1994 sel_cons = currcons;
1995 }
1996 if (sel_start == -1)
1997 highlight(sel_cons, new_sel_start, new_sel_end);
1998 else if (new_sel_start == sel_start)
1999 {
2000 if (new_sel_end == sel_end)
2001 return 0;
2002 else if (new_sel_end > sel_end)
2003 highlight(sel_cons, sel_end + 2, new_sel_end);
2004 else
2005 highlight(sel_cons, new_sel_end + 2, sel_end);
2006 }
2007 else if (new_sel_end == sel_end)
2008 {
2009 if (new_sel_start < sel_start)
2010 highlight(sel_cons, new_sel_start, sel_start - 2);
2011 else
2012 highlight(sel_cons, sel_start, new_sel_start - 2);
2013 }
2014 else
2015 {
2016 clear_selection();
2017 highlight(sel_cons, new_sel_start, new_sel_end);
2018 }
2019 sel_start = new_sel_start;
2020 sel_end = new_sel_end;
2021 obp = bp = sel_buffer;
2022 for (i = sel_start; i <= sel_end; i += 2)
2023 {
2024 spos = (char *)off + i;
2025 *bp++ = *spos;
2026 if (!isspace(*spos))
2027 obp = bp;
2028 if (! ((i + 2) % video_size_row))
2029 {
2030
2031
2032 if (obp != bp)
2033 {
2034 bp = obp;
2035 *bp++ = '\r';
2036 }
2037 obp = bp;
2038 }
2039
2040
2041 if (bp - sel_buffer > SEL_BUFFER_SIZE - 3)
2042 break;
2043 }
2044 *bp = '\0';
2045 return 0;
2046 }
2047
2048
2049
2050 int paste_selection(struct tty_struct *tty)
2051 {
2052 struct wait_queue wait = { current, NULL };
2053 char *bp = sel_buffer;
2054 int c, l;
2055 struct vt_struct *vt = (struct vt_struct *) tty->driver_data;
2056
2057 if (!sel_buffer[0])
2058 return 0;
2059 unblank_screen();
2060 c = strlen(sel_buffer);
2061 current->state = TASK_INTERRUPTIBLE;
2062 add_wait_queue(&vt->paste_wait, &wait);
2063 while (c) {
2064 if (test_bit(TTY_THROTTLED, &tty->flags)) {
2065 schedule();
2066 continue;
2067 }
2068 l = MIN(c, tty->ldisc.receive_room(tty));
2069 tty->ldisc.receive_buf(tty, bp, 0, l);
2070 c -= l;
2071 bp += l;
2072 }
2073 current->state = TASK_RUNNING;
2074 return 0;
2075 }
2076
2077
2078
2079 static void clear_selection()
2080 {
2081 highlight_pointer(sel_cons, -1);
2082 if (sel_start != -1)
2083 {
2084 highlight(sel_cons, sel_start, sel_end);
2085 sel_start = -1;
2086 }
2087 }
2088 #endif
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102 #define colourmap ((char *)0xa0000)
2103 #define blackwmap ((char *)0xb0000)
2104 #define cmapsz 8192
2105 #define seq_port_reg (0x3c4)
2106 #define seq_port_val (0x3c5)
2107 #define gr_port_reg (0x3ce)
2108 #define gr_port_val (0x3cf)
2109
2110 static int set_get_font(char * arg, int set)
2111 {
2112 #ifdef CAN_LOAD_EGA_FONTS
2113 int i;
2114 char *charmap;
2115 int beg;
2116
2117
2118
2119 if (video_type == VIDEO_TYPE_EGAC) {
2120 charmap = colourmap;
2121 beg = 0x0e;
2122 } else if (video_type == VIDEO_TYPE_EGAM) {
2123 charmap = blackwmap;
2124 beg = 0x0a;
2125 } else
2126 return -EINVAL;
2127
2128 i = verify_area(set ? VERIFY_READ : VERIFY_WRITE, (void *)arg, cmapsz);
2129 if (i)
2130 return i;
2131
2132 cli();
2133 outb_p( 0x00, seq_port_reg );
2134 outb_p( 0x01, seq_port_val );
2135 outb_p( 0x02, seq_port_reg );
2136 outb_p( 0x04, seq_port_val );
2137 outb_p( 0x04, seq_port_reg );
2138 outb_p( 0x07, seq_port_val );
2139 outb_p( 0x00, seq_port_reg );
2140 outb_p( 0x03, seq_port_val );
2141
2142 outb_p( 0x04, gr_port_reg );
2143 outb_p( 0x02, gr_port_val );
2144 outb_p( 0x05, gr_port_reg );
2145 outb_p( 0x00, gr_port_val );
2146 outb_p( 0x06, gr_port_reg );
2147 outb_p( 0x00, gr_port_val );
2148 sti();
2149
2150 if (set)
2151 for (i=0; i<cmapsz ; i++)
2152 *(charmap+i) = get_fs_byte(arg+i);
2153 else
2154 for (i=0; i<cmapsz ; i++)
2155 put_fs_byte(*(charmap+i), arg+i);
2156
2157 cli();
2158 outb_p( 0x00, seq_port_reg );
2159 outb_p( 0x01, seq_port_val );
2160 outb_p( 0x02, seq_port_reg );
2161 outb_p( 0x03, seq_port_val );
2162 outb_p( 0x04, seq_port_reg );
2163 outb_p( 0x03, seq_port_val );
2164 outb_p( 0x00, seq_port_reg );
2165 outb_p( 0x03, seq_port_val );
2166
2167 outb_p( 0x04, gr_port_reg );
2168 outb_p( 0x00, gr_port_val );
2169 outb_p( 0x05, gr_port_reg );
2170 outb_p( 0x10, gr_port_val );
2171 outb_p( 0x06, gr_port_reg );
2172 outb_p( beg, gr_port_val );
2173 sti();
2174
2175 return 0;
2176 #else
2177 return -EINVAL;
2178 #endif
2179 }
2180
2181
2182
2183
2184
2185
2186
2187 int con_set_font (char *arg)
2188 {
2189 return set_get_font (arg,1);
2190 }
2191
2192 int con_get_font (char *arg)
2193 {
2194 return set_get_font (arg,0);
2195 }
2196
2197
2198
2199
2200
2201
2202 int con_set_trans(char * arg)
2203 {
2204 int i;
2205
2206 i = verify_area(VERIFY_READ, (void *)arg, E_TABSZ);
2207 if (i)
2208 return i;
2209
2210 for (i=0; i<E_TABSZ ; i++) USER_TRANS[i] = get_fs_byte(arg+i);
2211 USER_TRANS[012]=0;
2212 USER_TRANS[014]=0;
2213 USER_TRANS[015]=0;
2214 USER_TRANS[033]=0;
2215 return 0;
2216 }
2217
2218 int con_get_trans(char * arg)
2219 {
2220 int i;
2221
2222 i = verify_area(VERIFY_WRITE, (void *)arg, E_TABSZ);
2223 if (i)
2224 return i;
2225
2226 for (i=0; i<E_TABSZ ; i++) put_fs_byte(USER_TRANS[i],arg+i);
2227 return 0;
2228 }