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
- update_attr
- default_attr
- csi_m
- respond_string
- respond_num
- cursor_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_write
- do_keyboard_interrupt
- memsetw
- console_print
- con_init
- kbdsave
- get_scrmem
- set_scrmem
- blank_screen
- unblank_screen
- update_screen
- do_screendump
- con_open
- highlight
- inword
- atedge
- limit
- set_selection
- paste_selection
- clear_selection
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 #include <linux/sched.h>
41 #include <linux/timer.h>
42 #include <linux/tty.h>
43 #include <linux/config.h>
44 #include <linux/kernel.h>
45 #include <linux/string.h>
46 #include <linux/errno.h>
47 #include <linux/kd.h>
48 #include <linux/keyboard.h>
49
50 #include <asm/io.h>
51 #include <asm/system.h>
52 #include <asm/segment.h>
53
54 #include "vt_kern.h"
55
56 #ifdef CONFIG_SELECTION
57 #include <linux/ctype.h>
58
59
60 int set_selection(const int arg);
61 int paste_selection(struct tty_struct *tty);
62 static void clear_selection(void);
63
64
65 #define SEL_BUFFER_SIZE TTY_BUF_SIZE
66 static int sel_cons;
67 static int sel_start = -1;
68 static int sel_end;
69 static char sel_buffer[SEL_BUFFER_SIZE] = { '\0' };
70 #endif
71
72 #define NPAR 16
73
74 extern void vt_init(void);
75 extern void register_console(void (*proc)(const char *));
76 extern void compute_shiftstate(void);
77
78 unsigned long video_num_columns;
79 unsigned long video_num_lines;
80
81 static unsigned char video_type;
82 static unsigned long video_mem_base;
83 static unsigned long video_mem_term;
84 static unsigned long video_size_row;
85 static unsigned char video_page;
86 static unsigned short video_port_reg;
87 static unsigned short video_port_val;
88 static int can_do_color = 0;
89 static int printable = 0;
90
91 static struct {
92 unsigned short vc_video_erase_char;
93 unsigned char vc_attr;
94 unsigned char vc_def_color;
95 unsigned char vc_color;
96 unsigned char vc_s_color;
97 unsigned char vc_ulcolor;
98 unsigned char vc_halfcolor;
99 unsigned long vc_origin;
100 unsigned long vc_scr_end;
101 unsigned long vc_pos;
102 unsigned long vc_x,vc_y;
103 unsigned long vc_top,vc_bottom;
104 unsigned long vc_state;
105 unsigned long vc_npar,vc_par[NPAR];
106 unsigned long vc_video_mem_start;
107 unsigned long vc_video_mem_end;
108 unsigned long vc_saved_x;
109 unsigned long vc_saved_y;
110
111 unsigned long vc_charset : 1;
112 unsigned long vc_s_charset : 1;
113 unsigned long vc_decscnm : 1;
114 unsigned long vc_decom : 1;
115 unsigned long vc_decawm : 1;
116 unsigned long vc_deccm : 1;
117 unsigned long vc_decim : 1;
118
119 unsigned long vc_intensity : 2;
120 unsigned long vc_underline : 1;
121 unsigned long vc_blink : 1;
122 unsigned long vc_reverse : 1;
123 unsigned long vc_s_intensity : 2;
124 unsigned long vc_s_underline : 1;
125 unsigned long vc_s_blink : 1;
126 unsigned long vc_s_reverse : 1;
127
128 unsigned long vc_ques : 1;
129 unsigned long vc_need_wrap : 1;
130 unsigned long vc_tab_stop[5];
131 unsigned char vc_kbdmode;
132 unsigned char * vc_translate;
133 unsigned char * vc_G0_charset;
134 unsigned char * vc_G1_charset;
135 unsigned char * vc_saved_G0;
136 unsigned char * vc_saved_G1;
137
138 } vc_cons [NR_CONSOLES];
139
140 unsigned short *vc_scrbuf[NR_CONSOLES];
141 static unsigned short * vc_scrmembuf;
142 static int console_blanked = 0;
143
144 #define origin (vc_cons[currcons].vc_origin)
145 #define scr_end (vc_cons[currcons].vc_scr_end)
146 #define pos (vc_cons[currcons].vc_pos)
147 #define top (vc_cons[currcons].vc_top)
148 #define bottom (vc_cons[currcons].vc_bottom)
149 #define x (vc_cons[currcons].vc_x)
150 #define y (vc_cons[currcons].vc_y)
151 #define state (vc_cons[currcons].vc_state)
152 #define npar (vc_cons[currcons].vc_npar)
153 #define par (vc_cons[currcons].vc_par)
154 #define ques (vc_cons[currcons].vc_ques)
155 #define attr (vc_cons[currcons].vc_attr)
156 #define saved_x (vc_cons[currcons].vc_saved_x)
157 #define saved_y (vc_cons[currcons].vc_saved_y)
158 #define translate (vc_cons[currcons].vc_translate)
159 #define G0_charset (vc_cons[currcons].vc_G0_charset)
160 #define G1_charset (vc_cons[currcons].vc_G1_charset)
161 #define saved_G0 (vc_cons[currcons].vc_saved_G0)
162 #define saved_G1 (vc_cons[currcons].vc_saved_G1)
163 #define video_mem_start (vc_cons[currcons].vc_video_mem_start)
164 #define video_mem_end (vc_cons[currcons].vc_video_mem_end)
165 #define video_erase_char (vc_cons[currcons].vc_video_erase_char)
166 #define decscnm (vc_cons[currcons].vc_decscnm)
167 #define decom (vc_cons[currcons].vc_decom)
168 #define decawm (vc_cons[currcons].vc_decawm)
169 #define deccm (vc_cons[currcons].vc_deccm)
170 #define decim (vc_cons[currcons].vc_decim)
171 #define need_wrap (vc_cons[currcons].vc_need_wrap)
172 #define color (vc_cons[currcons].vc_color)
173 #define s_color (vc_cons[currcons].vc_s_color)
174 #define def_color (vc_cons[currcons].vc_def_color)
175 #define foreground (color & 0x0f)
176 #define background (color & 0xf0)
177 #define charset (vc_cons[currcons].vc_charset)
178 #define s_charset (vc_cons[currcons].vc_s_charset)
179 #define intensity (vc_cons[currcons].vc_intensity)
180 #define underline (vc_cons[currcons].vc_underline)
181 #define blink (vc_cons[currcons].vc_blink)
182 #define reverse (vc_cons[currcons].vc_reverse)
183 #define s_intensity (vc_cons[currcons].vc_s_intensity)
184 #define s_underline (vc_cons[currcons].vc_s_underline)
185 #define s_blink (vc_cons[currcons].vc_s_blink)
186 #define s_reverse (vc_cons[currcons].vc_s_reverse)
187 #define ulcolor (vc_cons[currcons].vc_ulcolor)
188 #define halfcolor (vc_cons[currcons].vc_halfcolor)
189 #define kbdmode (vc_cons[currcons].vc_kbdmode)
190 #define tab_stop (vc_cons[currcons].vc_tab_stop)
191 #define vcmode (vt_cons[currcons].vc_mode)
192 #define vtmode (vt_cons[currcons].vt_mode)
193 #define vtpid (vt_cons[currcons].vt_pid)
194 #define vtnewvt (vt_cons[currcons].vt_newvt)
195
196 #define set_kbd(x) set_vc_kbd_flag(kbd_table+currcons,x)
197 #define clr_kbd(x) clr_vc_kbd_flag(kbd_table+currcons,x)
198 #define is_kbd(x) vc_kbd_flag(kbd_table+currcons,x)
199
200 #define decarm VC_REPEAT
201 #define decckm VC_CKMODE
202 #define kbdapplic VC_APPLIC
203 #define kbdraw VC_RAW
204 #define lnm VC_CRLF
205
206 int blankinterval = 10*60*HZ;
207 static int screen_size = 0;
208
209
210
211
212 #define VT100ID "\033[?1;2c"
213 #define VT102ID "\033[?6c"
214
215 static unsigned char * translations[] = {
216
217 (unsigned char *)
218 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
219 "\0\0\0\0\0\0\0\0\0\0\376\0\0\0\0\0"
220 " !\"#$%&'()*+,-./0123456789:;<=>?"
221 "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
222 "`abcdefghijklmnopqrstuvwxyz{|}~\0"
223 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
224 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
225 "\377\255\233\234\376\235\174\025\376\376\246\256\252\055\376\376"
226 "\370\361\375\376\376\346\024\371\376\376\247\257\254\253\376\250"
227 "\376\376\376\376\216\217\222\200\376\220\376\376\376\376\376\376"
228 "\376\245\376\376\376\376\231\376\350\376\376\376\232\376\376\341"
229 "\205\240\203\376\204\206\221\207\212\202\210\211\215\241\214\213"
230 "\376\244\225\242\223\376\224\366\355\227\243\226\201\376\376\230",
231
232 (unsigned char *)
233 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
234 "\0\0\0\0\0\0\0\0\0\0\376\0\0\0\0\0"
235 " !\"#$%&'()*+,-./0123456789:;<=>?"
236 "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^ "
237 "\004\261\007\007\007\007\370\361\007\007\331\277\332\300\305\304"
238 "\304\304\137\137\303\264\301\302\263\363\362\343\330\234\007\0"
239 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
240 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
241 "\377\255\233\234\376\235\174\025\376\376\246\256\252\055\376\376"
242 "\370\361\375\376\376\346\024\371\376\376\247\257\254\253\376\250"
243 "\376\376\376\376\216\217\222\200\376\220\376\376\376\376\376\376"
244 "\376\245\376\376\376\376\231\376\376\376\376\376\232\376\376\341"
245 "\205\240\203\376\204\206\221\207\212\202\210\211\215\241\214\213"
246 "\376\244\225\242\223\376\224\366\376\227\243\226\201\376\376\230",
247
248 (unsigned char *)
249 "\000\001\002\003\004\005\006\007\000\011\000\013\000\000\000\000"
250 "\020\021\022\023\024\025\026\027\030\031\032\000\034\035\036\037"
251 "\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057"
252 "\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077"
253 "\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117"
254 "\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137"
255 "\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157"
256 "\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177"
257 "\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
258 "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237"
259 "\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257"
260 "\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277"
261 "\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317"
262 "\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337"
263 "\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357"
264 "\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377"
265 };
266
267 #define NORM_TRANS (translations[0])
268 #define GRAF_TRANS (translations[1])
269 #define NULL_TRANS (translations[2])
270
271 static unsigned char color_table[] = { 0, 4, 2, 6, 1, 5, 3, 7,
272 8,12,10,14, 9,13,11,15 };
273
274
275
276
277
278
279 static void gotoxy(int currcons, int new_x, int new_y)
280 {
281 int max_y;
282
283 if (new_x < 0)
284 x = 0;
285 else
286 if (new_x >= video_num_columns)
287 x = video_num_columns - 1;
288 else
289 x = new_x;
290 if (decom) {
291 new_y += top;
292 max_y = bottom;
293 } else
294 max_y = video_num_lines;
295 if (new_y < 0)
296 y = 0;
297 else
298 if (new_y >= max_y)
299 y = max_y - 1;
300 else
301 y = new_y;
302 pos = origin + y*video_size_row + (x<<1);
303 need_wrap = 0;
304 }
305
306
307
308
309 static unsigned short __real_origin;
310 static unsigned short __origin;
311
312 static inline void __set_origin(unsigned short offset)
313 {
314 unsigned long flags;
315 #ifdef CONFIG_SELECTION
316 clear_selection();
317 #endif
318 save_flags(flags); cli();
319 __origin = offset;
320 outb_p(12, video_port_reg);
321 outb_p(offset >> 8, video_port_val);
322 outb_p(13, video_port_reg);
323 outb_p(offset, video_port_val);
324 restore_flags(flags);
325 }
326
327 void scrollback(int lines)
328 {
329 if (!lines)
330 lines = video_num_lines/2;
331 lines *= video_num_columns;
332 lines = __origin - lines;
333 if (lines < 0)
334 lines = 0;
335 __set_origin(lines);
336 }
337
338 void scrollfront(int lines)
339 {
340 if (!lines)
341 lines = video_num_lines/2;
342 lines *= video_num_columns;
343 lines = __origin + lines;
344 if (lines > __real_origin)
345 lines = __real_origin;
346 __set_origin(lines);
347 }
348
349 static void set_origin(int currcons)
350 {
351 if (video_type != VIDEO_TYPE_EGAC && video_type != VIDEO_TYPE_EGAM)
352 return;
353 if (currcons != fg_console || console_blanked || vcmode == KD_GRAPHICS)
354 return;
355 __real_origin = (origin-video_mem_base) >> 1;
356 __set_origin(__real_origin);
357 }
358
359 static inline void hide_cursor(int currcons)
360 {
361 outb_p(14, video_port_reg);
362 outb_p(0xff&((scr_end-video_mem_base)>>9), video_port_val);
363 outb_p(15, video_port_reg);
364 outb_p(0xff&((scr_end-video_mem_base)>>1), video_port_val);
365 }
366
367 static inline void set_cursor(int currcons)
368 {
369 unsigned long flags;
370
371 if (currcons != fg_console || console_blanked || vcmode == KD_GRAPHICS)
372 return;
373 if (__real_origin != __origin)
374 set_origin(__real_origin);
375 save_flags(flags); cli();
376 if (deccm) {
377 outb_p(14, video_port_reg);
378 outb_p(0xff&((pos-video_mem_base)>>9), video_port_val);
379 outb_p(15, video_port_reg);
380 outb_p(0xff&((pos-video_mem_base)>>1), video_port_val);
381 } else
382 hide_cursor(currcons);
383 restore_flags(flags);
384 }
385
386 static void scrup(int currcons, unsigned int t, unsigned int b)
387 {
388 int hardscroll = 1;
389
390 if (b > video_num_lines || t >= b)
391 return;
392 if (video_type != VIDEO_TYPE_EGAC && video_type != VIDEO_TYPE_EGAM)
393 hardscroll = 0;
394 else if (t || b != video_num_lines)
395 hardscroll = 0;
396 if (hardscroll) {
397 origin += video_size_row;
398 pos += video_size_row;
399 scr_end += video_size_row;
400 if (scr_end > video_mem_end) {
401 __asm__("cld\n\t"
402 "rep\n\t"
403 "movsl\n\t"
404 "movl _video_num_columns,%1\n\t"
405 "rep\n\t"
406 "stosw"
407 :
408 :"a" (video_erase_char),
409 "c" ((video_num_lines-1)*video_num_columns>>1),
410 "D" (video_mem_start),
411 "S" (origin)
412 :"cx","di","si");
413 scr_end -= origin-video_mem_start;
414 pos -= origin-video_mem_start;
415 origin = video_mem_start;
416 } else {
417 __asm__("cld\n\t"
418 "rep\n\t"
419 "stosw"
420 :
421 :"a" (video_erase_char),
422 "c" (video_num_columns),
423 "D" (scr_end-video_size_row)
424 :"cx","di");
425 }
426 set_origin(currcons);
427 } else {
428 __asm__("cld\n\t"
429 "rep\n\t"
430 "movsl\n\t"
431 "movl _video_num_columns,%%ecx\n\t"
432 "rep\n\t"
433 "stosw"
434 :
435 :"a" (video_erase_char),
436 "c" ((b-t-1)*video_num_columns>>1),
437 "D" (origin+video_size_row*t),
438 "S" (origin+video_size_row*(t+1))
439 :"cx","di","si");
440 }
441 }
442
443 static void scrdown(int currcons, unsigned int t, unsigned int b)
444 {
445 if (b > video_num_lines || t >= b)
446 return;
447 __asm__("std\n\t"
448 "rep\n\t"
449 "movsl\n\t"
450 "addl $2,%%edi\n\t"
451 "movl _video_num_columns,%%ecx\n\t"
452 "rep\n\t"
453 "stosw\n\t"
454 "cld"
455 :
456 :"a" (video_erase_char),
457 "c" ((b-t-1)*video_num_columns>>1),
458 "D" (origin+video_size_row*b-4),
459 "S" (origin+video_size_row*(b-1)-4)
460 :"ax","cx","di","si");
461 }
462
463 static void lf(int currcons)
464 {
465 if (y+1<bottom) {
466 y++;
467 pos += video_size_row;
468 return;
469 } else
470 scrup(currcons,top,bottom);
471 need_wrap = 0;
472 }
473
474 static void ri(int currcons)
475 {
476 if (y>top) {
477 y--;
478 pos -= video_size_row;
479 return;
480 } else
481 scrdown(currcons,top,bottom);
482 need_wrap = 0;
483 }
484
485 static inline void cr(int currcons)
486 {
487 pos -= x<<1;
488 need_wrap = x = 0;
489 }
490
491 static inline void bs(int currcons)
492 {
493 if (x) {
494 pos -= 2;
495 x--;
496 need_wrap = 0;
497 }
498 }
499
500 static inline void del(int currcons)
501 {
502 #if 0
503 if (x) {
504 if (!need_wrap) {
505 pos -= 2;
506 x--;
507 }
508 *(unsigned short *)pos = video_erase_char;
509 need_wrap = 0;
510 }
511 #endif
512 }
513
514 static void csi_J(int currcons, int vpar)
515 {
516 unsigned long count;
517 unsigned long start;
518
519 switch (vpar) {
520 case 0:
521 count = (scr_end-pos)>>1;
522 start = pos;
523 break;
524 case 1:
525 count = ((pos-origin)>>1)+1;
526 start = origin;
527 break;
528 case 2:
529 count = video_num_columns * video_num_lines;
530 start = origin;
531 break;
532 default:
533 return;
534 }
535 __asm__("cld\n\t"
536 "rep\n\t"
537 "stosw\n\t"
538 :
539 :"c" (count),
540 "D" (start),"a" (video_erase_char)
541 :"cx","di");
542 need_wrap = 0;
543 }
544
545 static void csi_K(int currcons, int vpar)
546 {
547 long count;
548 long start;
549
550 switch (vpar) {
551 case 0:
552 count = video_num_columns-x;
553 start = pos;
554 break;
555 case 1:
556 start = pos - (x<<1);
557 count = x+1;
558 break;
559 case 2:
560 start = pos - (x<<1);
561 count = video_num_columns;
562 break;
563 default:
564 return;
565 }
566 __asm__("cld\n\t"
567 "rep\n\t"
568 "stosw\n\t"
569 :
570 :"c" (count),
571 "D" (start),"a" (video_erase_char)
572 :"cx","di");
573 need_wrap = 0;
574 }
575
576
577
578
579 static void update_attr(int currcons)
580 {
581 attr = color;
582 if (can_do_color) {
583 if (underline)
584 attr = (attr & 0xf0) | ulcolor;
585 else if (intensity == 0)
586 attr = (attr & 0xf0) | halfcolor;
587 }
588 if (reverse ^ decscnm)
589 attr = (attr & 0x88) | (((attr >> 4) | (attr << 4)) & 0x77);
590 if (blink)
591 attr ^= 0x80;
592 if (intensity == 2)
593 attr ^= 0x08;
594 if (!can_do_color) {
595 if (underline)
596 attr = (attr & 0xf8) | 0x01;
597 else if (intensity == 0)
598 attr = (attr & 0xf0) | 0x08;
599 }
600 if (decscnm)
601 video_erase_char = ((color & 0x88) | (((color >> 4) |
602 (color << 4)) & 0x77) << 8) | ' ';
603 else
604 video_erase_char = (color << 8) | ' ';
605 }
606
607 static void default_attr(int currcons)
608 {
609 intensity = 1;
610 underline = 0;
611 reverse = 0;
612 blink = 0;
613 color = def_color;
614 }
615
616 static void csi_m(int currcons)
617 {
618 int i;
619
620 for (i=0;i<=npar;i++)
621 switch (par[i]) {
622 case 0:
623 default_attr(currcons);
624 break;
625 case 1:
626 intensity = 2;
627 break;
628 case 2:
629 intensity = 0;
630 break;
631 case 4:
632 underline = 1;
633 break;
634 case 5:
635 blink = 1;
636 break;
637 case 7:
638 reverse = 1;
639 break;
640 case 21:
641 case 22:
642 intensity = 1;
643 break;
644 case 24:
645 underline = 0;
646 break;
647 case 25:
648 blink = 0;
649 break;
650 case 27:
651 reverse = 0;
652 break;
653 case 39:
654 color = (def_color & 0x0f) | background;
655 break;
656 case 49:
657 color = (def_color & 0xf0) | foreground;
658 break;
659 default:
660 if (par[i] >= 30 && par[i] <= 37)
661 color = color_table[par[i]-30]
662 | background;
663 else if (par[i] >= 40 && par[i] <= 47)
664 color = (color_table[par[i]-40]<<4)
665 | foreground;
666 break;
667 }
668 update_attr(currcons);
669 }
670
671 static void respond_string(char * p, int currcons, struct tty_struct * tty)
672 {
673 while (*p) {
674 put_tty_queue(*p, &tty->read_q);
675 p++;
676 }
677 TTY_READ_FLUSH(tty);
678 }
679
680 static void respond_num(unsigned int n, int currcons, struct tty_struct * tty)
681 {
682 char buff[3];
683 int i = 0;
684
685 do {
686 buff[i++] = (n%10)+'0';
687 n /= 10;
688 } while(n && i < 3);
689 while (i--) {
690 put_tty_queue(buff[i], &tty->read_q);
691 }
692
693 }
694
695 static void cursor_report(int currcons, struct tty_struct * tty)
696 {
697 put_tty_queue('\033', &tty->read_q);
698 put_tty_queue('[', &tty->read_q);
699 respond_num(y + (decom ? top+1 : 1), currcons, tty);
700 put_tty_queue(';', &tty->read_q);
701 respond_num(x+1, currcons, tty);
702 put_tty_queue('R', &tty->read_q);
703 TTY_READ_FLUSH(tty);
704 }
705
706 static inline void status_report(int currcons, struct tty_struct * tty)
707 {
708 respond_string("\033[0n", currcons, tty);
709 }
710
711 static inline void respond_ID(int currcons, struct tty_struct * tty)
712 {
713 respond_string(VT102ID, currcons, tty);
714 }
715
716 static void invert_screen(int currcons) {
717 unsigned char *p;
718
719 if (can_do_color)
720 for (p = (unsigned char *)origin+1; p < (unsigned char *)scr_end; p+=2)
721 *p = (*p & 0x88) | (((*p >> 4) | (*p << 4)) & 0x77);
722 else
723 for (p = (unsigned char *)origin+1; p < (unsigned char *)scr_end; p+=2)
724 *p ^= *p & 0x07 == 1 ? 0x70 : 0x77;
725 }
726
727 static void set_mode(int currcons, int on_off)
728 {
729 int i;
730
731 for (i=0; i<=npar; i++)
732 if (ques) switch(par[i]) {
733 case 1:
734 if (on_off)
735 set_kbd(decckm);
736 else
737 clr_kbd(decckm);
738 break;
739 case 3:
740 csi_J(currcons,2);
741 gotoxy(currcons,0,0);
742 break;
743 case 5:
744 if (decscnm != on_off) {
745 decscnm = on_off;
746 invert_screen(currcons);
747 update_attr(currcons);
748 }
749 break;
750 case 6:
751 decom = on_off;
752 gotoxy(currcons,0,0);
753 break;
754 case 7:
755 decawm = on_off;
756 break;
757 case 8:
758 if (on_off)
759 set_kbd(decarm);
760 else
761 clr_kbd(decarm);
762 break;
763 case 25:
764 deccm = on_off;
765 set_cursor(currcons);
766 break;
767 } else switch(par[i]) {
768 case 4:
769 decim = on_off;
770 break;
771 case 20:
772 if (on_off)
773 set_kbd(lnm);
774 else
775 clr_kbd(lnm);
776 break;
777 }
778 }
779
780 static void setterm_command(int currcons)
781 {
782 switch(par[0]) {
783 case 1:
784 if (can_do_color && par[1] < 16) {
785 ulcolor = color_table[par[1]];
786 if (underline)
787 update_attr(currcons);
788 }
789 break;
790 case 2:
791 if (can_do_color && par[1] < 16) {
792 halfcolor = color_table[par[1]];
793 if (intensity == 0)
794 update_attr(currcons);
795 }
796 break;
797 case 8:
798 def_color = attr;
799 default_attr(currcons);
800 update_attr(currcons);
801 break;
802 case 9:
803 blankinterval = ((par[1] < 60) ? par[1] : 60) * 60 * HZ;
804 break;
805 }
806 }
807
808 static void insert_char(int currcons)
809 {
810 unsigned int i = x;
811 unsigned short tmp, old = video_erase_char;
812 unsigned short * p = (unsigned short *) pos;
813
814 while (i++ < video_num_columns) {
815 tmp = *p;
816 *p = old;
817 old = tmp;
818 p++;
819 }
820 need_wrap = 0;
821 }
822
823 static void insert_line(int currcons)
824 {
825 scrdown(currcons,y,bottom);
826 need_wrap = 0;
827 }
828
829 static void delete_char(int currcons)
830 {
831 unsigned int i = x;
832 unsigned short * p = (unsigned short *) pos;
833
834 while (++i < video_num_columns) {
835 *p = *(p+1);
836 p++;
837 }
838 *p = video_erase_char;
839 need_wrap = 0;
840 }
841
842 static void delete_line(int currcons)
843 {
844 scrup(currcons,y,bottom);
845 need_wrap = 0;
846 }
847
848 static void csi_at(int currcons, unsigned int nr)
849 {
850 if (nr > video_num_columns)
851 nr = video_num_columns;
852 else if (!nr)
853 nr = 1;
854 while (nr--)
855 insert_char(currcons);
856 }
857
858 static void csi_L(int currcons, unsigned int nr)
859 {
860 if (nr > video_num_lines)
861 nr = video_num_lines;
862 else if (!nr)
863 nr = 1;
864 while (nr--)
865 insert_line(currcons);
866 }
867
868 static void csi_P(int currcons, unsigned int nr)
869 {
870 if (nr > video_num_columns)
871 nr = video_num_columns;
872 else if (!nr)
873 nr = 1;
874 while (nr--)
875 delete_char(currcons);
876 }
877
878 static void csi_M(int currcons, unsigned int nr)
879 {
880 if (nr > video_num_lines)
881 nr = video_num_lines;
882 else if (!nr)
883 nr=1;
884 while (nr--)
885 delete_line(currcons);
886 }
887
888 static void save_cur(int currcons)
889 {
890 saved_x = x;
891 saved_y = y;
892 s_intensity = intensity;
893 s_underline = underline;
894 s_blink = blink;
895 s_reverse = reverse;
896 s_charset = charset;
897 s_color = color;
898 saved_G0 = G0_charset;
899 saved_G1 = G1_charset;
900 }
901
902 static void restore_cur(int currcons)
903 {
904 gotoxy(currcons,saved_x,saved_y);
905 intensity = s_intensity;
906 underline = s_underline;
907 blink = s_blink;
908 reverse = s_reverse;
909 charset = s_charset;
910 color = s_color;
911 G0_charset = saved_G0;
912 G1_charset = saved_G1;
913 translate = charset ? G1_charset : G0_charset;
914 update_attr(currcons);
915 need_wrap = 0;
916 }
917
918 enum { ESnormal, ESesc, ESsquare, ESgetpars, ESgotpars, ESfunckey,
919 EShash, ESsetG0, ESsetG1, ESignore };
920
921 static void reset_terminal(int currcons, int do_clear)
922 {
923 top = 0;
924 bottom = video_num_lines;
925 state = ESnormal;
926 ques = 0;
927 translate = NORM_TRANS;
928 G0_charset = NORM_TRANS;
929 G1_charset = GRAF_TRANS;
930 charset = 0;
931 need_wrap = 0;
932
933 decscnm = 0;
934 decom = 0;
935 decawm = 1;
936 deccm = 1;
937 decim = 0;
938
939 set_kbd(decarm);
940 clr_kbd(decckm);
941 clr_kbd(kbdapplic);
942 clr_kbd(lnm);
943 kbd_table[currcons].flags =
944 (kbd_table[currcons].flags & ~LED_MASK) |
945 (kbd_table[currcons].default_flags & LED_MASK);
946 kbdmode = 0;
947 set_leds();
948
949 default_attr(currcons);
950 update_attr(currcons);
951
952 tab_stop[0] = 0x01010100;
953 tab_stop[1] =
954 tab_stop[2] =
955 tab_stop[3] =
956 tab_stop[4] = 0x01010101;
957
958 if (do_clear) {
959 gotoxy(currcons,0,0);
960 csi_J(currcons,2);
961 save_cur(currcons);
962 }
963 }
964
965 void con_write(struct tty_struct * tty)
966 {
967 int c;
968 unsigned int currcons;
969
970 currcons = tty->line - 1;
971 if (currcons >= NR_CONSOLES) {
972 printk("con_write: illegal tty (%d)\n", currcons);
973 return;
974 }
975 #ifdef CONFIG_SELECTION
976
977
978 if (!EMPTY(&tty->write_q) && currcons == sel_cons)
979 clear_selection();
980 #endif
981 disable_bh(KEYBOARD_BH);
982 while (!tty->stopped && (c = get_tty_queue(&tty->write_q)) >= 0) {
983 if (state == ESnormal && translate[c]) {
984 if (need_wrap) {
985 cr(currcons);
986 lf(currcons);
987 }
988 if (decim)
989 insert_char(currcons);
990 c = translate[c];
991 *(unsigned short *) pos = (attr << 8) + c;
992 if (x == video_num_columns - 1)
993 need_wrap = decawm;
994 else {
995 x++;
996 pos+=2;
997 }
998 continue;
999 }
1000
1001
1002
1003
1004
1005 switch (c) {
1006 case 7:
1007 kd_mksound(0x637, HZ/8);
1008 continue;
1009 case 8:
1010 bs(currcons);
1011 continue;
1012 case 9:
1013 pos -= (x << 1);
1014 while (x < video_num_columns - 1) {
1015 x++;
1016 if (tab_stop[x >> 5] & (1 << (x & 31)))
1017 break;
1018 }
1019 pos += (x << 1);
1020 continue;
1021 case 10: case 11: case 12:
1022 lf(currcons);
1023 if (!is_kbd(lnm))
1024 continue;
1025 case 13:
1026 cr(currcons);
1027 continue;
1028 case 14:
1029 charset = 1;
1030 translate = G1_charset;
1031 continue;
1032 case 15:
1033 charset = 0;
1034 translate = G0_charset;
1035 continue;
1036 case 24: case 26:
1037 state = ESnormal;
1038 continue;
1039 case 27:
1040 state = ESesc;
1041 continue;
1042 case 127:
1043 del(currcons);
1044 continue;
1045 case 128+27:
1046 state = ESsquare;
1047 continue;
1048 }
1049 switch(state) {
1050 case ESesc:
1051 state = ESnormal;
1052 switch (c) {
1053 case '[':
1054 state = ESsquare;
1055 continue;
1056 case 'E':
1057 cr(currcons);
1058 lf(currcons);
1059 continue;
1060 case 'M':
1061 ri(currcons);
1062 continue;
1063 case 'D':
1064 lf(currcons);
1065 continue;
1066 case 'H':
1067 tab_stop[x >> 5] |= (1 << (x & 31));
1068 continue;
1069 case 'Z':
1070 respond_ID(currcons,tty);
1071 continue;
1072 case '7':
1073 save_cur(currcons);
1074 continue;
1075 case '8':
1076 restore_cur(currcons);
1077 continue;
1078 case '(':
1079 state = ESsetG0;
1080 continue;
1081 case ')':
1082 state = ESsetG1;
1083 continue;
1084 case '#':
1085 state = EShash;
1086 continue;
1087 case 'c':
1088 reset_terminal(currcons,1);
1089 continue;
1090 case '>':
1091 clr_kbd(kbdapplic);
1092 continue;
1093 case '=':
1094 set_kbd(kbdapplic);
1095 continue;
1096 }
1097 continue;
1098 case ESsquare:
1099 for(npar = 0 ; npar < NPAR ; npar++)
1100 par[npar] = 0;
1101 npar = 0;
1102 state = ESgetpars;
1103 if (c == '[') {
1104 state=ESfunckey;
1105 continue;
1106 }
1107 ques = (c=='?');
1108 if (ques)
1109 continue;
1110 case ESgetpars:
1111 if (c==';' && npar<NPAR-1) {
1112 npar++;
1113 continue;
1114 } else if (c>='0' && c<='9') {
1115 par[npar] *= 10;
1116 par[npar] += c-'0';
1117 continue;
1118 } else state=ESgotpars;
1119 case ESgotpars:
1120 state = ESnormal;
1121 switch(c) {
1122 case 'h':
1123 set_mode(currcons,1);
1124 continue;
1125 case 'l':
1126 set_mode(currcons,0);
1127 continue;
1128 case 'n':
1129 if (!ques)
1130 if (par[0] == 5)
1131 status_report(currcons,tty);
1132 else if (par[0] == 6)
1133 cursor_report(currcons,tty);
1134 continue;
1135 }
1136 if (ques) {
1137 ques = 0;
1138 continue;
1139 }
1140 switch(c) {
1141 case 'G': case '`':
1142 if (par[0]) par[0]--;
1143 gotoxy(currcons,par[0],y);
1144 continue;
1145 case 'A':
1146 if (!par[0]) par[0]++;
1147 gotoxy(currcons,x,y-par[0]);
1148 continue;
1149 case 'B': case 'e':
1150 if (!par[0]) par[0]++;
1151 gotoxy(currcons,x,y+par[0]);
1152 continue;
1153 case 'C': case 'a':
1154 if (!par[0]) par[0]++;
1155 gotoxy(currcons,x+par[0],y);
1156 continue;
1157 case 'D':
1158 if (!par[0]) par[0]++;
1159 gotoxy(currcons,x-par[0],y);
1160 continue;
1161 case 'E':
1162 if (!par[0]) par[0]++;
1163 gotoxy(currcons,0,y+par[0]);
1164 continue;
1165 case 'F':
1166 if (!par[0]) par[0]++;
1167 gotoxy(currcons,0,y-par[0]);
1168 continue;
1169 case 'd':
1170 if (par[0]) par[0]--;
1171 gotoxy(currcons,x,par[0]);
1172 continue;
1173 case 'H': case 'f':
1174 if (par[0]) par[0]--;
1175 if (par[1]) par[1]--;
1176 gotoxy(currcons,par[1],par[0]);
1177 continue;
1178 case 'J':
1179 csi_J(currcons,par[0]);
1180 continue;
1181 case 'K':
1182 csi_K(currcons,par[0]);
1183 continue;
1184 case 'L':
1185 csi_L(currcons,par[0]);
1186 continue;
1187 case 'M':
1188 csi_M(currcons,par[0]);
1189 continue;
1190 case 'P':
1191 csi_P(currcons,par[0]);
1192 continue;
1193 case 'c':
1194 if (!par[0])
1195 respond_ID(currcons,tty);
1196 continue;
1197 case 'g':
1198 if (!par[0])
1199 tab_stop[x >> 5] &= ~(1 << (x & 31));
1200 else if (par[0] == 3) {
1201 tab_stop[0] =
1202 tab_stop[1] =
1203 tab_stop[2] =
1204 tab_stop[3] =
1205 tab_stop[4] = 0;
1206 }
1207 continue;
1208 case 'm':
1209 csi_m(currcons);
1210 continue;
1211 case 'r':
1212 if (!par[0])
1213 par[0]++;
1214 if (!par[1])
1215 par[1] = video_num_lines;
1216
1217 if (par[0] < par[1] &&
1218 par[1] <= video_num_lines) {
1219 top=par[0]-1;
1220 bottom=par[1];
1221 gotoxy(currcons,0,0);
1222 }
1223 continue;
1224 case 's':
1225 save_cur(currcons);
1226 continue;
1227 case 'u':
1228 restore_cur(currcons);
1229 continue;
1230 case '@':
1231 csi_at(currcons,par[0]);
1232 continue;
1233 case ']':
1234 setterm_command(currcons);
1235 continue;
1236 }
1237 continue;
1238 case ESfunckey:
1239 state = ESnormal;
1240 continue;
1241 case EShash:
1242 state = ESnormal;
1243 if (c == '8') {
1244
1245 video_erase_char =
1246 (video_erase_char & 0xff00) | 'E';
1247 csi_J(currcons, 2);
1248 video_erase_char =
1249 (video_erase_char & 0xff00) | ' ';
1250 }
1251 continue;
1252 case ESsetG0:
1253 if (c == '0')
1254 G0_charset = GRAF_TRANS;
1255 else if (c == 'B')
1256 G0_charset = NORM_TRANS;
1257 else if (c == 'U')
1258 G0_charset = NULL_TRANS;
1259 if (charset == 0)
1260 translate = G0_charset;
1261 state = ESnormal;
1262 continue;
1263 case ESsetG1:
1264 if (c == '0')
1265 G1_charset = GRAF_TRANS;
1266 else if (c == 'B')
1267 G1_charset = NORM_TRANS;
1268 else if (c == 'U')
1269 G1_charset = NULL_TRANS;
1270 if (charset == 1)
1271 translate = G1_charset;
1272 state = ESnormal;
1273 continue;
1274 default:
1275 state = ESnormal;
1276 }
1277 }
1278 if (vcmode != KD_GRAPHICS)
1279 set_cursor(currcons);
1280 enable_bh(KEYBOARD_BH);
1281 if (LEFT(&tty->write_q) > WAKEUP_CHARS)
1282 wake_up_interruptible(&tty->write_q.proc_list);
1283 }
1284
1285 void do_keyboard_interrupt(void)
1286 {
1287 TTY_READ_FLUSH(TTY_TABLE(0));
1288 timer_active &= ~(1<<BLANK_TIMER);
1289 if (vt_cons[fg_console].vc_mode == KD_GRAPHICS)
1290 return;
1291 if (console_blanked) {
1292 timer_table[BLANK_TIMER].expires = 0;
1293 timer_active |= 1<<BLANK_TIMER;
1294 } else if (blankinterval) {
1295 timer_table[BLANK_TIMER].expires = jiffies + blankinterval;
1296 timer_active |= 1<<BLANK_TIMER;
1297 }
1298 }
1299
1300 void * memsetw(void * s,unsigned short c,int count)
1301 {
1302 __asm__("cld\n\t"
1303 "rep\n\t"
1304 "stosw"
1305 :
1306 :"a" (c),"D" (s),"c" (count)
1307 :"cx","di");
1308 return s;
1309 }
1310
1311 void console_print(const char * b)
1312 {
1313 int currcons = fg_console;
1314 unsigned char c;
1315
1316 if (!printable || currcons<0 || currcons>=NR_CONSOLES)
1317 return;
1318 while ((c = *(b++)) != 0) {
1319 if (c == 10 || c == 13 || need_wrap) {
1320 if (c != 13)
1321 lf(currcons);
1322 cr(currcons);
1323 if (c == 10 || c == 13)
1324 continue;
1325 }
1326 *(unsigned short *) pos = (attr << 8) + c;
1327 if (x == video_num_columns - 1) {
1328 need_wrap = 1;
1329 continue;
1330 }
1331 x++;
1332 pos+=2;
1333 }
1334 set_cursor(currcons);
1335 if (vt_cons[fg_console].vc_mode == KD_GRAPHICS)
1336 return;
1337 timer_active &= ~(1<<BLANK_TIMER);
1338 if (console_blanked) {
1339 timer_table[BLANK_TIMER].expires = 0;
1340 timer_active |= 1<<BLANK_TIMER;
1341 } else if (blankinterval) {
1342 timer_table[BLANK_TIMER].expires = jiffies + blankinterval;
1343 timer_active |= 1<<BLANK_TIMER;
1344 }
1345 }
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357 long con_init(long kmem_start)
1358 {
1359 char *display_desc = "????";
1360 int currcons = 0;
1361 long base;
1362 int orig_x = ORIG_X;
1363 int orig_y = ORIG_Y;
1364
1365 vc_scrmembuf = (unsigned short *) kmem_start;
1366 video_num_columns = ORIG_VIDEO_COLS;
1367 video_size_row = video_num_columns * 2;
1368 video_num_lines = ORIG_VIDEO_LINES;
1369 video_page = ORIG_VIDEO_PAGE;
1370 screen_size = (video_num_lines * video_size_row);
1371 kmem_start += NR_CONSOLES * screen_size;
1372 timer_table[BLANK_TIMER].fn = blank_screen;
1373 timer_table[BLANK_TIMER].expires = 0;
1374 if (blankinterval) {
1375 timer_table[BLANK_TIMER].expires = jiffies+blankinterval;
1376 timer_active |= 1<<BLANK_TIMER;
1377 }
1378
1379 if (ORIG_VIDEO_MODE == 7)
1380 {
1381 video_mem_base = 0xb0000;
1382 video_port_reg = 0x3b4;
1383 video_port_val = 0x3b5;
1384 if ((ORIG_VIDEO_EGA_BX & 0xff) != 0x10)
1385 {
1386 video_type = VIDEO_TYPE_EGAM;
1387 video_mem_term = 0xb8000;
1388 display_desc = "EGA+";
1389 }
1390 else
1391 {
1392 video_type = VIDEO_TYPE_MDA;
1393 video_mem_term = 0xb2000;
1394 display_desc = "*MDA";
1395 }
1396 }
1397 else
1398 {
1399 can_do_color = 1;
1400 video_mem_base = 0xb8000;
1401 video_port_reg = 0x3d4;
1402 video_port_val = 0x3d5;
1403 if ((ORIG_VIDEO_EGA_BX & 0xff) != 0x10)
1404 {
1405 video_type = VIDEO_TYPE_EGAC;
1406 video_mem_term = 0xc0000;
1407 display_desc = "EGA+";
1408 }
1409 else
1410 {
1411 video_type = VIDEO_TYPE_CGA;
1412 video_mem_term = 0xba000;
1413 display_desc = "*CGA";
1414 }
1415 }
1416
1417
1418
1419 base = (long)vc_scrmembuf;
1420 for (currcons = 0; currcons<NR_CONSOLES; currcons++) {
1421 pos = origin = video_mem_start = base;
1422 scr_end = video_mem_end = (base += screen_size);
1423 vc_scrbuf[currcons] = (unsigned short *) origin;
1424 vcmode = KD_TEXT;
1425 vtmode.mode = VT_AUTO;
1426 vtmode.waitv = 0;
1427 vtmode.relsig = 0;
1428 vtmode.acqsig = 0;
1429 vtmode.frsig = 0;
1430 vtpid = -1;
1431 vtnewvt = -1;
1432 clr_kbd(kbdraw);
1433 def_color = 0x07;
1434 ulcolor = 0x0f;
1435 halfcolor = 0x08;
1436 reset_terminal(currcons, currcons);
1437 }
1438 currcons = fg_console = 0;
1439
1440 video_mem_start = video_mem_base;
1441 video_mem_end = video_mem_term;
1442 origin = video_mem_start;
1443 scr_end = video_mem_start + video_num_lines * video_size_row;
1444 gotoxy(currcons,0,0);
1445 save_cur(currcons);
1446 gotoxy(currcons,orig_x,orig_y);
1447 update_screen(fg_console);
1448 printable = 1;
1449 printk("Console: %s %s %ldx%ld, %d virtual consoles\n",
1450 can_do_color?"colour":"mono",
1451 display_desc,
1452 video_num_columns,video_num_lines,
1453 NR_CONSOLES);
1454 register_console(console_print);
1455 return kmem_start;
1456 }
1457
1458
1459
1460
1461
1462 void kbdsave(int new_console)
1463 {
1464 }
1465
1466 static void get_scrmem(int currcons)
1467 {
1468 memcpy((void *)vc_scrbuf[currcons],(void *)origin, screen_size);
1469 video_mem_start = (unsigned long)vc_scrbuf[currcons];
1470 origin = video_mem_start;
1471 scr_end = video_mem_end = video_mem_start+screen_size;
1472 pos = origin + y*video_size_row + (x<<1);
1473 }
1474
1475 static void set_scrmem(int currcons)
1476 {
1477 #ifdef CONFIG_HGA
1478
1479
1480
1481
1482
1483
1484
1485 if (video_type == VIDEO_TYPE_MDA)
1486 {
1487 if (vcmode == KD_TEXT)
1488 {
1489
1490 int i;
1491 static char herc_txt_tbl[12] = {
1492 0x61,0x50,0x52,0x0f,0x19,6,0x19,0x19,2,0x0d,0x0b,0x0c };
1493 outb_p(0, 0x3bf);
1494 outb_p(0, 0x3b8);
1495 for ( i = 0 ; i < 12 ; i++ )
1496 {
1497 outb_p(i, 0x3b4);
1498 outb_p(herc_txt_tbl[i], 0x3b5);
1499 }
1500 }
1501 #define HGA_BLINKER_ON 0x20
1502 #define HGA_SCREEN_ON 8
1503
1504 outb_p(HGA_BLINKER_ON | HGA_SCREEN_ON, 0x3b8);
1505 }
1506 #endif CONFIG_HGA
1507
1508 video_mem_start = video_mem_base;
1509 video_mem_end = video_mem_term;
1510 origin = video_mem_start;
1511 scr_end = video_mem_start + screen_size;
1512 pos = origin + y*video_size_row + (x<<1);
1513 memcpy((void *)video_mem_base, (void *)vc_scrbuf[fg_console], screen_size);
1514 }
1515
1516 void blank_screen(void)
1517 {
1518 if (console_blanked)
1519 return;
1520 timer_table[BLANK_TIMER].fn = unblank_screen;
1521 get_scrmem(fg_console);
1522 hide_cursor(fg_console);
1523 console_blanked = 1;
1524 memsetw((void *)video_mem_base, 0x0020, video_mem_term-video_mem_base );
1525 }
1526
1527 void unblank_screen(void)
1528 {
1529 if (!console_blanked)
1530 return;
1531 timer_table[BLANK_TIMER].fn = blank_screen;
1532 if (blankinterval) {
1533 timer_table[BLANK_TIMER].expires = jiffies + blankinterval;
1534 timer_active |= 1<<BLANK_TIMER;
1535 }
1536 console_blanked = 0;
1537 set_scrmem(fg_console);
1538 set_origin(fg_console);
1539 set_cursor(fg_console);
1540 }
1541
1542 void update_screen(int new_console)
1543 {
1544 static int lock = 0;
1545
1546 if (new_console == fg_console || lock)
1547 return;
1548 lock = 1;
1549 kbdsave(new_console);
1550 get_scrmem(fg_console);
1551 fg_console = new_console;
1552 set_scrmem(fg_console);
1553 set_origin(fg_console);
1554 set_cursor(new_console);
1555 set_leds();
1556 compute_shiftstate();
1557 lock = 0;
1558 }
1559
1560 int do_screendump(int arg)
1561 {
1562 char *sptr, *buf = (char *)arg;
1563 int currcons, l;
1564
1565 if (!suser())
1566 return -EPERM;
1567 l = verify_area(VERIFY_WRITE, buf,2+video_num_columns*video_num_lines);
1568 if (l)
1569 return l;
1570 currcons = get_fs_byte(buf+1);
1571 if ((currcons<0) || (currcons>NR_CONSOLES))
1572 return -EIO;
1573 put_fs_byte((char)(video_num_lines),buf++);
1574 put_fs_byte((char)(video_num_columns),buf++);
1575 currcons = (currcons ? currcons-1 : fg_console);
1576 sptr = (char *) origin;
1577 for (l=video_num_lines*video_num_columns; l>0 ; l--, sptr++)
1578 put_fs_byte(*sptr++,buf++);
1579 return(0);
1580 }
1581
1582
1583
1584
1585
1586 int con_open(struct tty_struct *tty, struct file * filp)
1587 {
1588 tty->write = con_write;
1589 tty->ioctl = vt_ioctl;
1590 if (tty->line > NR_CONSOLES)
1591 return -ENODEV;
1592 return 0;
1593 }
1594
1595 #ifdef CONFIG_SELECTION
1596
1597 #define hwscroll_offset (currcons == fg_console ? ((__real_origin - __origin) << 1) : 0)
1598
1599
1600 static void highlight(const int currcons, const int s, const int e)
1601 {
1602 unsigned char *p, *p1, *p2;
1603
1604 p1 = (unsigned char *)origin - hwscroll_offset + s + 1;
1605 p2 = (unsigned char *)origin - hwscroll_offset + e + 1;
1606 if (p1 > p2)
1607 {
1608 p = p1;
1609 p1 = p2;
1610 p2 = p;
1611 }
1612 for (p = p1; p <= p2; p += 2)
1613 *p = (*p & 0x88) | ((*p << 4) & 0x70) | ((*p >> 4) & 0x07);
1614 }
1615
1616
1617 static inline int inword(const char c) { return (isalnum(c) || c == '_'); }
1618
1619
1620 static inline int atedge(const int p)
1621 {
1622 return (!(p % video_size_row) || !((p + 2) % video_size_row));
1623 }
1624
1625
1626 static inline short limit(const int v, const int l, const int u)
1627 {
1628 return (v < l) ? l : ((v > u) ? u : v);
1629 }
1630
1631
1632 int set_selection(const int arg)
1633 {
1634 unsigned short *args, xs, ys, xe, ye;
1635 int currcons = fg_console;
1636 int sel_mode, new_sel_start, new_sel_end, spc;
1637 char *bp, *obp, *spos;
1638 int i, ps, pe;
1639 char *off = (char *)origin - hwscroll_offset;
1640
1641 unblank_screen();
1642 args = (unsigned short *)(arg + 1);
1643 xs = get_fs_word(args++) - 1;
1644 ys = get_fs_word(args++) - 1;
1645 xe = get_fs_word(args++) - 1;
1646 ye = get_fs_word(args++) - 1;
1647 sel_mode = get_fs_word(args);
1648
1649 xs = limit(xs, 0, video_num_columns - 1);
1650 ys = limit(ys, 0, video_num_lines - 1);
1651 xe = limit(xe, 0, video_num_columns - 1);
1652 ye = limit(ye, 0, video_num_lines - 1);
1653 ps = ys * video_size_row + (xs << 1);
1654 pe = ye * video_size_row + (xe << 1);
1655
1656 if (ps > pe)
1657 {
1658 int tmp = ps;
1659 ps = pe;
1660 pe = tmp;
1661 }
1662
1663 switch (sel_mode)
1664 {
1665 case 0:
1666 default:
1667 new_sel_start = ps;
1668 new_sel_end = pe;
1669 break;
1670 case 1:
1671 spc = isspace(*(off + ps));
1672 for (new_sel_start = ps; ; ps -= 2)
1673 {
1674 if ((spc && !isspace(*(off + ps))) ||
1675 (!spc && !inword(*(off + ps))))
1676 break;
1677 new_sel_start = ps;
1678 if (!(ps % video_size_row))
1679 break;
1680 }
1681 spc = isspace(*(off + pe));
1682 for (new_sel_end = pe; ; pe += 2)
1683 {
1684 if ((spc && !isspace(*(off + pe))) ||
1685 (!spc && !inword(*(off + pe))))
1686 break;
1687 new_sel_end = pe;
1688 if (!((pe + 2) % video_size_row))
1689 break;
1690 }
1691 break;
1692 case 2:
1693 new_sel_start = ps - ps % video_size_row;
1694 new_sel_end = pe + video_size_row
1695 - pe % video_size_row - 2;
1696 break;
1697 }
1698
1699 if (new_sel_end > new_sel_start &&
1700 !atedge(new_sel_end) && isspace(*(off + new_sel_end)))
1701 {
1702 for (pe = new_sel_end + 2; ; pe += 2)
1703 {
1704 if (!isspace(*(off + pe)) || atedge(pe))
1705 break;
1706 }
1707 if (isspace(*(off + pe)))
1708 new_sel_end = pe;
1709 }
1710 if (sel_cons != currcons)
1711 {
1712 clear_selection();
1713 sel_cons = currcons;
1714 }
1715 if (sel_start == -1)
1716 highlight(sel_cons, new_sel_start, new_sel_end);
1717 else if (new_sel_start == sel_start)
1718 {
1719 if (new_sel_end == sel_end)
1720 return 0;
1721 else if (new_sel_end > sel_end)
1722 highlight(sel_cons, sel_end + 2, new_sel_end);
1723 else
1724 highlight(sel_cons, new_sel_end + 2, sel_end);
1725 }
1726 else if (new_sel_end == sel_end)
1727 {
1728 if (new_sel_start < sel_start)
1729 highlight(sel_cons, new_sel_start, sel_start - 2);
1730 else
1731 highlight(sel_cons, sel_start, new_sel_start - 2);
1732 }
1733 else
1734 {
1735 clear_selection();
1736 highlight(sel_cons, new_sel_start, new_sel_end);
1737 }
1738 sel_start = new_sel_start;
1739 sel_end = new_sel_end;
1740 obp = bp = sel_buffer;
1741 for (i = sel_start; i <= sel_end; i += 2)
1742 {
1743 spos = (char *)off + i;
1744 *bp++ = *spos;
1745 if (!isspace(*spos))
1746 obp = bp;
1747 if (! ((i + 2) % video_size_row))
1748 {
1749
1750
1751 if (obp != bp)
1752 {
1753 bp = obp;
1754 *bp++ = '\r';
1755 }
1756 obp = bp;
1757 }
1758
1759
1760 if (bp - sel_buffer > SEL_BUFFER_SIZE - 3)
1761 break;
1762 }
1763 *bp = '\0';
1764 return 0;
1765 }
1766
1767
1768
1769 int paste_selection(struct tty_struct *tty)
1770 {
1771 char *bp = sel_buffer;
1772
1773 if (! *bp)
1774 return 0;
1775 unblank_screen();
1776 while (*bp)
1777 {
1778 put_tty_queue(*bp, &tty->read_q);
1779 bp++;
1780 }
1781 TTY_READ_FLUSH(tty);
1782 return 0;
1783 }
1784
1785
1786
1787 static void clear_selection()
1788 {
1789 if (sel_start != -1)
1790 {
1791 highlight(sel_cons, sel_start, sel_end);
1792 sel_start = -1;
1793 }
1794 }
1795 #endif