开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
console.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：73k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

console.c：源码内容
  1. /*
  2.  *  linux/drivers/char/console.c
  3.  *
  4.  *  Copyright (C) 1991, 1992  Linus Torvalds
  5.  */
  7. /*
  8.  * Hopefully this will be a rather complete VT102 implementation.
  9.  *
  10.  * Beeping thanks to John T Kohl.
  11.  *
  12.  * Virtual Consoles, Screen Blanking, Screen Dumping, Color, Graphics
  13.  *   Chars, and VT100 enhancements by Peter MacDonald.
  14.  *
  15.  * Copy and paste function by Andrew Haylett,
  16.  *   some enhancements by Alessandro Rubini.
  17.  *
  18.  * Code to check for different video-cards mostly by Galen Hunt,
  19.  * <g-hunt@ee.utah.edu>
  20.  *
  21.  * Rudimentary ISO 10646/Unicode/UTF-8 character set support by
  22.  * Markus Kuhn, <mskuhn@immd4.informatik.uni-erlangen.de>.
  23.  *
  24.  * Dynamic allocation of consoles, aeb@cwi.nl, May 1994
  25.  * Resizing of consoles, aeb, 940926
  26.  *
  27.  * Code for xterm like mouse click reporting by Peter Orbaek 20-Jul-94
  28.  * <poe@daimi.aau.dk>
  29.  *
  30.  * User-defined bell sound, new setterm control sequences and printk
  31.  * redirection by Martin Mares <mj@k332.feld.cvut.cz> 19-Nov-95
  32.  *
  33.  * APM screenblank bug fixed Takashi Manabe <manabe@roy.dsl.tutics.tut.jp>
  34.  *
  35.  * Merge with the abstract console driver by Geert Uytterhoeven
  36.  * <geert@linux-m68k.org>, Jan 1997.
  37.  *
  38.  *   Original m68k console driver modifications by
  39.  *
  40.  *     - Arno Griffioen <arno@usn.nl>
  41.  *     - David Carter <carter@cs.bris.ac.uk>
  42.  * 
  43.  *   Note that the abstract console driver allows all consoles to be of
  44.  *   potentially different sizes, so the following variables depend on the
  45.  *   current console (currcons):
  46.  *
  47.  *     - video_num_columns
  48.  *     - video_num_lines
  49.  *     - video_size_row
  50.  *     - can_do_color
  51.  *
  52.  *   The abstract console driver provides a generic interface for a text
  53.  *   console. It supports VGA text mode, frame buffer based graphical consoles
  54.  *   and special graphics processors that are only accessible through some
  55.  *   registers (e.g. a TMS340x0 GSP).
  56.  *
  57.  *   The interface to the hardware is specified using a special structure
  58.  *   (struct consw) which contains function pointers to console operations
  59.  *   (see <linux/console.h> for more information).
  60.  *
  61.  * Support for changeable cursor shape
  62.  * by Pavel Machek <pavel@atrey.karlin.mff.cuni.cz>, August 1997
  63.  *
  64.  * Ported to i386 and con_scrolldelta fixed
  65.  * by Emmanuel Marty <core@ggi-project.org>, April 1998
  66.  *
  67.  * Resurrected character buffers in videoram plus lots of other trickery
  68.  * by Martin Mares <mj@atrey.karlin.mff.cuni.cz>, July 1998
  69.  *
  70.  * Removed old-style timers, introduced console_timer, made timer
  71.  * deletion SMP-safe.  17Jun00, Andrew Morton <andrewm@uow.edu.au>
  72.  *
  73.  * Removed console_lock, enabled interrupts across all console operations
  74.  * 13 March 2001, Andrew Morton
  75.  *
  76.  * Split out con_write_ctrl_* functions from do_con_write & changed
  77.  * vc_state to function pointer
  78.  * by Russell King <rmk@arm.linux.org.uk>, July 1998
  79.  */
  81. #define CONSOLE_WIP
  83. #include <linux/module.h>
  84. #include <linux/sched.h>
  85. #include <linux/tty.h>
  86. #include <linux/tty_flip.h>
  87. #include <linux/kernel.h>
  88. #include <linux/string.h>
  89. #include <linux/errno.h>
  90. #include <linux/kd.h>
  91. #include <linux/slab.h>
  92. #include <linux/major.h>
  93. #include <linux/mm.h>
  94. #include <linux/console.h>
  95. #include <linux/init.h>
  96. #include <linux/devfs_fs_kernel.h>
  97. #include <linux/vt_kern.h>
  98. #include <linux/selection.h>
  99. #include <linux/console_struct.h>
  100. #include <linux/kbd_kern.h>
  101. #include <linux/consolemap.h>
  102. #include <linux/timer.h>
  103. #include <linux/interrupt.h>
  104. #include <linux/config.h>
  105. #include <linux/version.h>
  106. #include <linux/tqueue.h>
  107. #include <linux/bootmem.h>
  108. #ifdef CONFIG_CONSOLE_PM // bushi
  109. #include <linux/pm.h>
  110. #endif
  111. #include <linux/smp_lock.h>
  113. #include <asm/io.h>
  114. #include <asm/system.h>
  115. #include <asm/uaccess.h>
  116. #include <asm/bitops.h>
  118. #include "console_macros.h"
  121. const struct consw *conswitchp;
  123. /* A bitmap for codes <32. A bit of 1 indicates that the code
  124.  * corresponding to that bit number invokes some special action
  125.  * (such as cursor movement) and should not be displayed as a
  126.  * glyph unless the disp_ctrl mode is explicitly enabled.
  127.  */
  128. #define CTRL_ACTION 0x0d00ff81
  129. #define CTRL_ALWAYS 0x0800f501 /* Cannot be overridden by disp_ctrl */
  131. /*
  132.  * Here is the default bell parameters: 750HZ, 1/8th of a second
  133.  */
  134. #define DEFAULT_BELL_PITCH 750
  135. #define DEFAULT_BELL_DURATION (HZ/8)
  137. extern void vcs_make_devfs (unsigned int index, int unregister);
  139. #ifndef MIN
  140. #define MIN(a,b) ((a) < (b) ? (a) : (b))
  141. #endif
  143. static struct tty_struct *console_table[MAX_NR_CONSOLES];
  144. static struct termios *console_termios[MAX_NR_CONSOLES];
  145. static struct termios *console_termios_locked[MAX_NR_CONSOLES];
  146. struct vc vc_cons [MAX_NR_CONSOLES];
  148. #ifndef VT_SINGLE_DRIVER
  149. static const struct consw *con_driver_map[MAX_NR_CONSOLES];
  150. #endif
  152. static int con_open(struct tty_struct *, struct file *);
  153. static void vc_init(unsigned int console, unsigned int rows,
  154.     unsigned int cols, int do_clear);
  155. static void gotoxy(int currcons, int new_x, int new_y);
  156. static void save_cur(int currcons);
  157. static void reset_terminal(int currcons, int do_clear);
  158. static void con_flush_chars(struct tty_struct *tty);
  159. #ifdef CONFIG_CONSOLE_PM // bushi
  160. static void blank_screen(unsigned long dummy);
  161. static void set_vesa_blanking(unsigned long arg);
  162. static void unblank_screen_t(unsigned long dummy);
  163. #endif
  164. static void set_cursor(int currcons);
  165. static void hide_cursor(int currcons);
  166. static void console_callback(void *ignored);
  168. static int printable; /* Is console ready for printing? */
  170. #ifdef CONFIG_CONSOLE_PM // bushi
  171. int do_poke_blanked_console;
  172. int console_blanked;
  174. static int vesa_blank_mode; /* 0:none 1:suspendV 2:suspendH 3:powerdown */
  175. static int blankinterval = 10*60*HZ;
  176. static int vesa_off_interval;
  177. #endif
  179. static struct tq_struct console_callback_tq = {
  180. routine: console_callback,
  181. };
  183. /*
  184.  * fg_console is the current virtual console,
  185.  * last_console is the last used one,
  186.  * want_console is the console we want to switch to,
  187.  * kmsg_redirect is the console for kernel messages,
  188.  */
  189. int fg_console;
  190. int last_console;
  191. int want_console = -1;
  192. int kmsg_redirect;
  194. /*
  195.  * For each existing display, we have a pointer to console currently visible
  196.  * on that display, allowing consoles other than fg_console to be refreshed
  197.  * appropriately. Unless the low-level driver supplies its own display_fg
  198.  * variable, we use this one for the "master display".
  199.  */
  200. static struct vc_data *master_display_fg;
  202. /*
  203.  * Unfortunately, we need to delay tty echo when we're currently writing to the
  204.  * console since the code is (and always was) not re-entrant, so we schedule
  205.  * all flip requests to process context with schedule-task() and run it from
  206.  * console_callback().
  207.  */
  209. /*
  210.  * For the same reason, we defer scrollback to the console callback.
  211.  */
  212. static int scrollback_delta;
  214. #ifdef CONFIG_CONSOLE_PM // bushi
  215. /*
  216.  * Hook so that the power management routines can (un)blank
  217.  * the console on our behalf.
  218.  */
  219. int (*console_blank_hook)(int);
  221. static struct timer_list console_timer;
  222. #endif
  224. /*
  225.  * Low-Level Functions
  226.  */
  228. #define IS_FG (currcons == fg_console)
  229. #define IS_VISIBLE CON_IS_VISIBLE(vc_cons[currcons].d)
  231. #ifdef VT_BUF_VRAM_ONLY
  232. #define DO_UPDATE 0
  233. #else
  234. #define DO_UPDATE IS_VISIBLE
  235. #endif
  237. #ifdef CONFIG_CONSOLE_PM // bushi
  238. static int pm_con_request(struct pm_dev *dev, pm_request_t rqst, void *data);
  239. static struct pm_dev *pm_con;
  240. #endif
  242. static inline unsigned short *screenpos(int currcons, int offset, int viewed)
  243. {
  244. unsigned short *p;
  246. if (!viewed)
  247. p = (unsigned short *)(origin + offset);
  248. else if (!sw->con_screen_pos)
  249. p = (unsigned short *)(visible_origin + offset);
  250. else
  251. p = sw->con_screen_pos(vc_cons[currcons].d, offset);
  252. return p;
  253. }
  255. static inline void scrolldelta(int lines)
  256. {
  257. scrollback_delta += lines;
  258. schedule_console_callback();
  259. }
  261. void schedule_console_callback(void)
  262. {
  263. schedule_task(&console_callback_tq);
  264. }
  266. static void scrup(int currcons, unsigned int t, unsigned int b, int nr)
  267. {
  268. unsigned short *d, *s;
  270. if (t+nr >= b)
  271. nr = b - t - 1;
  272. if (b > video_num_lines || t >= b || nr < 1)
  273. return;
  274. if (IS_VISIBLE && sw->con_scroll(vc_cons[currcons].d, t, b, SM_UP, nr))
  275. return;
  276. d = (unsigned short *) (origin+video_size_row*t);
  277. s = (unsigned short *) (origin+video_size_row*(t+nr));
  278. scr_memcpyw(d, s, (b-t-nr) * video_size_row);
  279. scr_memsetw(d + (b-t-nr) * video_num_columns, video_erase_char, video_size_row*nr);
  280. }
  282. static void
  283. scrdown(int currcons, unsigned int t, unsigned int b, int nr)
  284. {
  285. unsigned short *s;
  286. unsigned int step;
  288. if (t+nr >= b)
  289. nr = b - t - 1;
  290. if (b > video_num_lines || t >= b || nr < 1)
  291. return;
  292. if (IS_VISIBLE && sw->con_scroll(vc_cons[currcons].d, t, b, SM_DOWN, nr))
  293. return;
  294. s = (unsigned short *) (origin+video_size_row*t);
  295. step = video_num_columns * nr;
  296. scr_memmovew(s + step, s, (b-t-nr)*video_size_row);
  297. scr_memsetw(s, video_erase_char, 2*step);
  298. }
  300. static void do_update_region(int currcons, unsigned long start, int count)
  301. {
  302. #ifndef VT_BUF_VRAM_ONLY
  303. unsigned int xx, yy, offset;
  304. u16 *p;
  306. p = (u16 *) start;
  307. if (!sw->con_getxy) {
  308. offset = (start - origin) / 2;
  309. xx = offset % video_num_columns;
  310. yy = offset / video_num_columns;
  311. } else {
  312. int nxx, nyy;
  313. start = sw->con_getxy(vc_cons[currcons].d, start, &nxx, &nyy);
  314. xx = nxx; yy = nyy;
  315. }
  316. for(;;) {
  317. u16 attrib = scr_readw(p) & 0xff00;
  318. int startx = xx;
  319. u16 *q = p;
  320. while (xx < video_num_columns && count) {
  321. if (attrib != (scr_readw(p) & 0xff00)) {
  322. if (p > q)
  323. sw->con_putcs(vc_cons[currcons].d, q, p-q, yy, startx);
  324. startx = xx;
  325. q = p;
  326. attrib = scr_readw(p) & 0xff00;
  327. }
  328. p++;
  329. xx++;
  330. count--;
  331. }
  332. if (p > q)
  333. sw->con_putcs(vc_cons[currcons].d, q, p-q, yy, startx);
  334. if (!count)
  335. break;
  336. xx = 0;
  337. yy++;
  338. if (sw->con_getxy) {
  339. p = (u16 *)start;
  340. start = sw->con_getxy(vc_cons[currcons].d, start, NULL, NULL);
  341. }
  342. }
  343. #endif
  344. }
  346. void update_region(int currcons, unsigned long start, int count)
  347. {
  348. if (DO_UPDATE) {
  349. hide_cursor(currcons);
  350. do_update_region(currcons, start, count);
  351. set_cursor(currcons);
  352. }
  353. }
  355. /* Structure of attributes is hardware-dependent */
  357. static u8 build_attr(int currcons, u8 _color, u8 _intensity, u8 _blink, u8 _underline, u8 _reverse)
  358. {
  359. if (sw->con_build_attr)
  360. return sw->con_build_attr(vc_cons[currcons].d, _color, _intensity, _blink, _underline, _reverse);
  362. #ifndef VT_BUF_VRAM_ONLY
  363. /*
  364.  * ++roman: I completely changed the attribute format for monochrome
  365.  * mode (!can_do_color). The formerly used MDA (monochrome display
  366.  * adapter) format didn't allow the combination of certain effects.
  367.  * Now the attribute is just a bit vector:
  368.  *  Bit 0..1: intensity (0..2)
  369.  *  Bit 2   : underline
  370.  *  Bit 3   : reverse
  371.  *  Bit 7   : blink
  372.  */
  373. {
  374. u8 a = color;
  375. if (!can_do_color)
  376. return _intensity |
  377.        (_underline ? 4 : 0) |
  378.        (_reverse ? 8 : 0) |
  379.        (_blink ? 0x80 : 0);
  380. if (_underline)
  381. a = (a & 0xf0) | ulcolor;
  382. else if (_intensity == 0)
  383. a = (a & 0xf0) | halfcolor;
  384. if (_reverse)
  385. a = ((a) & 0x88) | ((((a) >> 4) | ((a) << 4)) & 0x77);
  386. if (_blink)
  387. a ^= 0x80;
  388. if (_intensity == 2)
  389. a ^= 0x08;
  390. if (hi_font_mask == 0x100)
  391. a <<= 1;
  392. return a;
  393. }
  394. #else
  395. return 0;
  396. #endif
  397. }
  399. static void update_attr(int currcons)
  400. {
  401. attr = build_attr(currcons, color, intensity, blink, underline, reverse ^ decscnm);
  402. video_erase_char = (build_attr(currcons, color, 1, blink, 0, decscnm) << 8) | ' ';
  403. }
  405. /* Note: inverting the screen twice should revert to the original state */
  407. void invert_screen(int currcons, int offset, int count, int viewed)
  408. {
  409. unsigned short *p;
  411. count /= 2;
  412. p = screenpos(currcons, offset, viewed);
  413. if (sw->con_invert_region)
  414. sw->con_invert_region(vc_cons[currcons].d, p, count);
  415. #ifndef VT_BUF_VRAM_ONLY
  416. else {
  417. u16 *q = p;
  418. int cnt = count;
  419. u16 a;
  421. if (!can_do_color) {
  422. while (cnt--) {
  423.     a = scr_readw(q);
  424.     a ^= 0x0800;
  425.     scr_writew(a, q);
  426.     q++;
  427. }
  428. } else if (hi_font_mask == 0x100) {
  429. while (cnt--) {
  430. a = scr_readw(q);
  431. a = ((a) & 0x11ff) | (((a) & 0xe000) >> 4) | (((a) & 0x0e00) << 4);
  432. scr_writew(a, q);
  433. q++;
  434. }
  435. } else {
  436. while (cnt--) {
  437. a = scr_readw(q);
  438. a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) | (((a) & 0x0700) << 4);
  439. scr_writew(a, q);
  440. q++;
  441. }
  442. }
  443. }
  444. #endif
  445. if (DO_UPDATE)
  446. do_update_region(currcons, (unsigned long) p, count);
  447. }
  449. /* used by selection: complement pointer position */
  450. void complement_pos(int currcons, int offset)
  451. {
  452. static unsigned short *p;
  453. static unsigned short old;
  454. static unsigned short oldx, oldy;
  456. if (p) {
  457. scr_writew(old, p);
  458. if (DO_UPDATE)
  459. sw->con_putc(vc_cons[currcons].d, old, oldy, oldx);
  460. }
  461. if (offset == -1)
  462. p = NULL;
  463. else {
  464. unsigned short new;
  465. p = screenpos(currcons, offset, 1);
  466. old = scr_readw(p);
  467. new = old ^ complement_mask;
  468. scr_writew(new, p);
  469. if (DO_UPDATE) {
  470. oldx = (offset >> 1) % video_num_columns;
  471. oldy = (offset >> 1) / video_num_columns;
  472. sw->con_putc(vc_cons[currcons].d, new, oldy, oldx);
  473. }
  474. }
  475. }
  477. static void insert_char(int currcons, unsigned int nr)
  478. {
  479. unsigned short *p, *q = (unsigned short *) pos;
  481. p = q + video_num_columns - nr - x;
  482. while (--p >= q)
  483. scr_writew(scr_readw(p), p + nr);
  484. scr_memsetw(q, video_erase_char, nr*2);
  485. need_wrap = 0;
  486. if (DO_UPDATE) {
  487. unsigned short oldattr = attr;
  488. sw->con_bmove(vc_cons[currcons].d,y,x,y,x+nr,1,
  489.       video_num_columns-x-nr);
  490. attr = video_erase_char >> 8;
  491. while (nr--)
  492. sw->con_putc(vc_cons[currcons].d,
  493.      video_erase_char,y,x+nr);
  494. attr = oldattr;
  495. }
  496. }
  498. static void delete_char(int currcons, unsigned int nr)
  499. {
  500. unsigned int i = x;
  501. unsigned short *p = (unsigned short *) pos;
  503. while (++i <= video_num_columns - nr) {
  504. scr_writew(scr_readw(p+nr), p);
  505. p++;
  506. }
  507. scr_memsetw(p, video_erase_char, nr*2);
  508. need_wrap = 0;
  509. if (DO_UPDATE) {
  510. unsigned short oldattr = attr;
  511. sw->con_bmove(vc_cons[currcons].d, y, x+nr, y, x, 1,
  512.       video_num_columns-x-nr);
  513. attr = video_erase_char >> 8;
  514. while (nr--)
  515. sw->con_putc(vc_cons[currcons].d,
  516.      video_erase_char, y,
  517.      video_num_columns-1-nr);
  518. attr = oldattr;
  519. }
  520. }
  522. #ifdef CONFIG_CONSOLE_PM // bushi
  523. static int softcursor_original;
  525. static void add_softcursor(int currcons)
  526. {
  527. int i = scr_readw((u16 *) pos);
  528. u32 type = cursor_type;
  530. if (! (type & 0x10)) return;
  531. if (softcursor_original != -1) return;
  532. softcursor_original = i;
  533. i |= ((type >> 8) & 0xff00 );
  534. i ^= ((type) & 0xff00 );
  535. if ((type & 0x20) && ((softcursor_original & 0x7000) == (i & 0x7000))) i ^= 0x7000;
  536. if ((type & 0x40) && ((i & 0x700) == ((i & 0x7000) >> 4))) i ^= 0x0700;
  537. scr_writew(i, (u16 *) pos);
  538. if (DO_UPDATE)
  539. sw->con_putc(vc_cons[currcons].d, i, y, x);
  540. }
  541. #endif
  543. static void hide_cursor(int currcons)
  544. {
  545. if (currcons == sel_cons)
  546. clear_selection();
  547. #ifdef CONFIG_CONSOLE_PM // bushi
  548. if (softcursor_original != -1) {
  549. scr_writew(softcursor_original,(u16 *) pos);
  550. if (DO_UPDATE)
  551. sw->con_putc(vc_cons[currcons].d, softcursor_original, y, x);
  552. softcursor_original = -1;
  553. }
  554. sw->con_cursor(vc_cons[currcons].d,CM_ERASE);
  555. #endif
  556. }
  558. static void set_cursor(int currcons)
  559. {
  560. #ifdef CONFIG_CONSOLE_PM // bushi
  561.     if (!IS_FG || console_blanked || vcmode == KD_GRAPHICS)
  562. return;
  563.     if (deccm) {
  564. if (currcons == sel_cons)
  565. clear_selection();
  566. add_softcursor(currcons);
  567. if ((cursor_type & 0x0f) != 1)
  568.     sw->con_cursor(vc_cons[currcons].d,CM_DRAW);
  569.     } else
  570. hide_cursor(currcons);
  571. #else
  572. if (!IS_FG || vcmode == KD_GRAPHICS)
  573. return;
  574. hide_cursor(currcons);
  575. #endif
  576. }
  578. static void set_origin(int currcons)
  579. {
  580. if (!IS_VISIBLE ||
  581.     !sw->con_set_origin ||
  582.     !sw->con_set_origin(vc_cons[currcons].d))
  583. origin = (unsigned long) screenbuf;
  584. visible_origin = origin;
  585. scr_end = origin + screenbuf_size;
  586. pos = origin + video_size_row*y + 2*x;
  587. }
  589. static inline void save_screen(int currcons)
  590. {
  591. if (sw->con_save_screen)
  592. sw->con_save_screen(vc_cons[currcons].d);
  593. }
  595. /*
  596.  * Redrawing of screen
  597.  */
  599. void redraw_screen(int new_console, int is_switch)
  600. {
  601. int redraw = 1;
  602. int currcons, old_console;
  604. if (!vc_cons_allocated(new_console)) {
  605. /* strange ... */
  606. /* printk("redraw_screen: tty %d not allocated ??n", new_console+1); */
  607. return;
  608. }
  610. if (is_switch) {
  611. currcons = fg_console;
  612. hide_cursor(currcons);
  613. if (fg_console != new_console) {
  614. struct vc_data **display = vc_cons[new_console].d->vc_display_fg;
  615. old_console = (*display) ? (*display)->vc_num : fg_console;
  616. *display = vc_cons[new_console].d;
  617. fg_console = new_console;
  618. currcons = old_console;
  619. if (!IS_VISIBLE) {
  620. save_screen(currcons);
  621. set_origin(currcons);
  622. }
  623. currcons = new_console;
  624. if (old_console == new_console)
  625. redraw = 0;
  626. }
  627. } else {
  628. currcons = new_console;
  629. hide_cursor(currcons);
  630. }
  632. if (redraw) {
  633. int update;
  634. set_origin(currcons);
  635. update = sw->con_switch(vc_cons[currcons].d);
  636. set_palette(currcons);
  637. if (update && vcmode != KD_GRAPHICS)
  638. do_update_region(currcons, origin, screenbuf_size/2);
  639. }
  640. set_cursor(currcons);
  641. if (is_switch) {
  642. set_leds();
  643. compute_shiftstate();
  644. }
  645. }
  647. /*
  648.  * Allocation, freeing and resizing of VTs.
  649.  */
  651. int vc_cons_allocated(unsigned int i)
  652. {
  653. return (i < MAX_NR_CONSOLES && vc_cons[i].d);
  654. }
  656. static void visual_init(int currcons, int init)
  657. {
  658.     /* ++Geert: sw->con_init determines console size */
  659.     sw = conswitchp;
  660. #ifndef VT_SINGLE_DRIVER
  661.     if (con_driver_map[currcons])
  662. sw = con_driver_map[currcons];
  663. #endif
  664.     cons_num = currcons;
  665.     display_fg = &master_display_fg;
  666.     vc_cons[currcons].d->vc_uni_pagedir_loc = &vc_cons[currcons].d->vc_uni_pagedir;
  667.     vc_cons[currcons].d->vc_uni_pagedir = 0;
  668.     hi_font_mask = 0;
  669.     complement_mask = 0;
  670.     can_do_color = 0;
  671.     sw->con_init(vc_cons[currcons].d, init);
  672.     if (!complement_mask)
  673.         complement_mask = can_do_color ? 0x7700 : 0x0800;
  674.     s_complement_mask = complement_mask;
  675.     video_size_row = video_num_columns<<1;
  676.     screenbuf_size = video_num_lines*video_size_row;
  677. }
  679. int vc_allocate(unsigned int currcons) /* return 0 on success */
  680. {
  681. if (currcons >= MAX_NR_CONSOLES)
  682. return -ENXIO;
  683. if (!vc_cons[currcons].d) {
  684.     long p, q;
  686.     /* prevent users from taking too much memory */
  687.     if (currcons >= MAX_NR_USER_CONSOLES && !capable(CAP_SYS_RESOURCE))
  688.       return -EPERM;
  690.     /* due to the granularity of kmalloc, we waste some memory here */
  691.     /* the alloc is done in two steps, to optimize the common situation
  692.        of a 25x80 console (structsize=216, screenbuf_size=4000) */
  693.     /* although the numbers above are not valid since long ago, the
  694.        point is still up-to-date and the comment still has its value
  695.        even if only as a historical artifact.  --mj, July 1998 */
  696.     p = (long) kmalloc(structsize, GFP_KERNEL);
  697.     if (!p)
  698. return -ENOMEM;
  699.     memset((void *)p, 0, structsize);
  700.     vc_cons[currcons].d = (struct vc_data *)p;
  701.     vt_cons[currcons] = (struct vt_struct *)(p+sizeof(struct vc_data));
  702.     visual_init(currcons, 1);
  703.     if (!*vc_cons[currcons].d->vc_uni_pagedir_loc)
  704. con_set_default_unimap(currcons);
  705.     q = (long)kmalloc(screenbuf_size, GFP_KERNEL);
  706.     if (!q) {
  707. kfree((char *) p);
  708. vc_cons[currcons].d = NULL;
  709. vt_cons[currcons] = NULL;
  710. return -ENOMEM;
  711.     }
  712.     screenbuf = (unsigned short *) q;
  713.     kmalloced = 1;
  714.     vc_init(currcons, video_num_lines, video_num_columns, 1);
  716. #ifdef CONFIG_CONSOLE_PM //bushi
  717.     if (!pm_con) {
  718.     pm_con = pm_register(PM_SYS_DEV,
  719.  PM_SYS_VGA,
  720.  pm_con_request);
  721.     }
  722. #endif
  723. }
  724. return 0;
  725. }
  727. /*
  728.  * Change # of rows and columns (0 means unchanged/the size of fg_console)
  729.  * [this is to be used together with some user program
  730.  * like resize that changes the hardware videomode]
  731.  */
  732. int vc_resize(unsigned int lines, unsigned int cols,
  733.       unsigned int first, unsigned int last)
  734. {
  735. unsigned int cc, ll, ss, sr, todo = 0;
  736. unsigned int currcons = fg_console, i;
  737. unsigned short *newscreens[MAX_NR_CONSOLES];
  739. cc = (cols ? cols : video_num_columns);
  740. ll = (lines ? lines : video_num_lines);
  741. sr = cc << 1;
  742. ss = sr * ll;
  744.   for (currcons = first; currcons <= last; currcons++) {
  745. if (!vc_cons_allocated(currcons) ||
  746.     (cc == video_num_columns && ll == video_num_lines))
  747. newscreens[currcons] = NULL;
  748. else {
  749. unsigned short *p = (unsigned short *) kmalloc(ss, GFP_USER);
  750. if (!p) {
  751. for (i = first; i< currcons; i++)
  752. if (newscreens[i])
  753. kfree(newscreens[i]);
  754. return -ENOMEM;
  755. }
  756. newscreens[currcons] = p;
  757. todo++;
  758. }
  759. }
  760. if (!todo)
  761. return 0;
  763. for (currcons = first; currcons <= last; currcons++) {
  764. unsigned int occ, oll, oss, osr;
  765. unsigned long ol, nl, nlend, rlth, rrem;
  766. if (!newscreens[currcons] || !vc_cons_allocated(currcons))
  767. continue;
  769. oll = video_num_lines;
  770. occ = video_num_columns;
  771. osr = video_size_row;
  772. oss = screenbuf_size;
  774. video_num_lines = ll;
  775. video_num_columns = cc;
  776. video_size_row = sr;
  777. screenbuf_size = ss;
  779. rlth = MIN(osr, sr);
  780. rrem = sr - rlth;
  781. ol = origin;
  782. nl = (long) newscreens[currcons];
  783. nlend = nl + ss;
  784. if (ll < oll)
  785. ol += (oll - ll) * osr;
  787. update_attr(currcons);
  789. while (ol < scr_end) {
  790. scr_memcpyw((unsigned short *) nl, (unsigned short *) ol, rlth);
  791. if (rrem)
  792. scr_memsetw((void *)(nl + rlth), video_erase_char, rrem);
  793. ol += osr;
  794. nl += sr;
  795. }
  796. if (nlend > nl)
  797. scr_memsetw((void *) nl, video_erase_char, nlend - nl);
  798. if (kmalloced)
  799. kfree(screenbuf);
  800. screenbuf = newscreens[currcons];
  801. kmalloced = 1;
  802. screenbuf_size = ss;
  803. set_origin(currcons);
  805. /* do part of a reset_terminal() */
  806. top = 0;
  807. bottom = video_num_lines;
  808. gotoxy(currcons, x, y);
  809. save_cur(currcons);
  811. if (console_table[currcons]) {
  812. struct winsize ws, *cws = &console_table[currcons]->winsize;
  813. memset(&ws, 0, sizeof(ws));
  814. ws.ws_row = video_num_lines;
  815. ws.ws_col = video_num_columns;
  816. if ((ws.ws_row != cws->ws_row || ws.ws_col != cws->ws_col) &&
  817.     console_table[currcons]->pgrp > 0)
  818. kill_pg(console_table[currcons]->pgrp, SIGWINCH, 1);
  819. *cws = ws;
  820. }
  822. if (IS_VISIBLE)
  823. update_screen(currcons);
  824. }
  826. return 0;
  827. }
  830. void vc_disallocate(unsigned int currcons)
  831. {
  832. acquire_console_sem();
  833. if (vc_cons_allocated(currcons)) {
  834.     sw->con_deinit(vc_cons[currcons].d);
  835.     if (kmalloced)
  836. kfree(screenbuf);
  837.     if (currcons >= MIN_NR_CONSOLES)
  838. kfree(vc_cons[currcons].d);
  839.     vc_cons[currcons].d = NULL;
  840. }
  841. release_console_sem();
  842. }
  844. /*
  845.  * VT102 emulator
  846.  */
  848. #define set_kbd(x) set_vc_kbd_mode(kbd_table+currcons,x)
  849. #define clr_kbd(x) clr_vc_kbd_mode(kbd_table+currcons,x)
  850. #define is_kbd(x) vc_kbd_mode(kbd_table+currcons,x)
  852. #define decarm VC_REPEAT
  853. #define decckm VC_CKMODE
  854. #define kbdapplic VC_APPLIC
  855. #define lnm VC_CRLF
  857. /*
  858.  * this is what the terminal answers to a ESC-Z or csi0c query.
  859.  */
  860. #define VT100ID "33[?1;2c"
  861. #define VT102ID "33[?6c"
  863. unsigned char color_table[] = { 0, 4, 2, 6, 1, 5, 3, 7,
  864.        8,12,10,14, 9,13,11,15 };
  866. /* the default colour table, for VGA+ colour systems */
  867. int default_red[] = {0x00,0xaa,0x00,0xaa,0x00,0xaa,0x00,0xaa,
  868.     0x55,0xff,0x55,0xff,0x55,0xff,0x55,0xff};
  869. int default_grn[] = {0x00,0x00,0xaa,0xaa,0x00,0x00,0xaa,0xaa,
  870.     0x55,0x55,0xff,0xff,0x55,0x55,0xff,0xff};
  871. int default_blu[] = {0x00,0x00,0x00,0x00,0xaa,0xaa,0xaa,0xaa,
  872.     0x55,0x55,0x55,0x55,0xff,0xff,0xff,0xff};
  874. /*
  875.  * gotoxy() must verify all boundaries, because the arguments
  876.  * might also be negative. If the given position is out of
  877.  * bounds, the cursor is placed at the nearest margin.
  878.  */
  879. static void gotoxy(int currcons, int new_x, int new_y)
  880. {
  881. int min_y, max_y;
  883. if (new_x < 0)
  884. x = 0;
  885. else
  886. if (new_x >= video_num_columns)
  887. x = video_num_columns - 1;
  888. else
  889. x = new_x;
  890.   if (decom) {
  891. min_y = top;
  892. max_y = bottom;
  893. } else {
  894. min_y = 0;
  895. max_y = video_num_lines;
  896. }
  897. if (new_y < min_y)
  898. y = min_y;
  899. else if (new_y >= max_y)
  900. y = max_y - 1;
  901. else
  902. y = new_y;
  903. pos = origin + y*video_size_row + (x<<1);
  904. need_wrap = 0;
  905. }
  907. /* for absolute user moves, when decom is set */
  908. static void gotoxay(int currcons, int new_x, int new_y)
  909. {
  910. gotoxy(currcons, new_x, decom ? (top+new_y) : new_y);
  911. }
  913. void scrollback(int lines)
  914. {
  915. int currcons = fg_console;
  917. if (!lines)
  918. lines = video_num_lines/2;
  919. scrolldelta(-lines);
  920. }
  922. void scrollfront(int lines)
  923. {
  924. int currcons = fg_console;
  926. if (!lines)
  927. lines = video_num_lines/2;
  928. scrolldelta(lines);
  929. }
  931. static void lf(int currcons)
  932. {
  933.      /* don't scroll if above bottom of scrolling region, or
  934.  * if below scrolling region
  935.  */
  936.      if (y+1 == bottom)
  937. scrup(currcons,top,bottom,1);
  938. else if (y < video_num_lines-1) {
  939.      y++;
  940. pos += video_size_row;
  941. }
  942. need_wrap = 0;
  943. }
  945. static void ri(int currcons)
  946. {
  947.      /* don't scroll if below top of scrolling region, or
  948.  * if above scrolling region
  949.  */
  950. if (y == top)
  951. scrdown(currcons,top,bottom,1);
  952. else if (y > 0) {
  953. y--;
  954. pos -= video_size_row;
  955. }
  956. need_wrap = 0;
  957. }
  959. static inline void cr(int currcons)
  960. {
  961. pos -= x<<1;
  962. need_wrap = x = 0;
  963. }
  965. static inline void bs(int currcons)
  966. {
  967. if (x) {
  968. pos -= 2;
  969. x--;
  970. need_wrap = 0;
  971. }
  972. }
  974. static inline void del(int currcons)
  975. {
  976. /* ignored */
  977. }
  979. static void csi_J(int currcons, int vpar)
  980. {
  981. unsigned int count;
  982. unsigned short * start;
  984. switch (vpar) {
  985. case 0: /* erase from cursor to end of display */
  986. count = (scr_end-pos)>>1;
  987. start = (unsigned short *) pos;
  988. if (DO_UPDATE) {
  989. /* do in two stages */
  990. sw->con_clear(vc_cons[currcons].d, y, x, 1,
  991.       video_num_columns-x);
  992. sw->con_clear(vc_cons[currcons].d, y+1, 0,
  993.       video_num_lines-y-1,
  994.       video_num_columns);
  995. }
  996. break;
  997. case 1: /* erase from start to cursor */
  998. count = ((pos-origin)>>1)+1;
  999. start = (unsigned short *) origin;
  1000. if (DO_UPDATE) {
  1001. /* do in two stages */
  1002. sw->con_clear(vc_cons[currcons].d, 0, 0, y,
  1003.       video_num_columns);
  1004. sw->con_clear(vc_cons[currcons].d, y, 0, 1,
  1005.       x + 1);
  1006. }
  1007. break;
  1008. case 2: /* erase whole display */
  1009. count = video_num_columns * video_num_lines;
  1010. start = (unsigned short *) origin;
  1011. if (DO_UPDATE)
  1012. sw->con_clear(vc_cons[currcons].d, 0, 0,
  1013.       video_num_lines,
  1014.       video_num_columns);
  1015. break;
  1016. default:
  1017. return;
  1018. }
  1019. scr_memsetw(start, video_erase_char, 2*count);
  1020. need_wrap = 0;
  1021. }
  1023. static void csi_K(int currcons, int vpar)
  1024. {
  1025. unsigned int count;
  1026. unsigned short * start;
  1028. switch (vpar) {
  1029. case 0: /* erase from cursor to end of line */
  1030. count = video_num_columns-x;
  1031. start = (unsigned short *) pos;
  1032. if (DO_UPDATE)
  1033. sw->con_clear(vc_cons[currcons].d, y, x, 1,
  1034.       video_num_columns-x);
  1035. break;
  1036. case 1: /* erase from start of line to cursor */
  1037. start = (unsigned short *) (pos - (x<<1));
  1038. count = x+1;
  1039. if (DO_UPDATE)
  1040. sw->con_clear(vc_cons[currcons].d, y, 0, 1,
  1041.       x + 1);
  1042. break;
  1043. case 2: /* erase whole line */
  1044. start = (unsigned short *) (pos - (x<<1));
  1045. count = video_num_columns;
  1046. if (DO_UPDATE)
  1047. sw->con_clear(vc_cons[currcons].d, y, 0, 1,
  1048.       video_num_columns);
  1049. break;
  1050. default:
  1051. return;
  1052. }
  1053. scr_memsetw(start, video_erase_char, 2 * count);
  1054. need_wrap = 0;
  1055. }
  1057. static void csi_X(int currcons, int vpar) /* erase the following vpar positions */
  1058. {   /* not vt100? */
  1059. int count;
  1061. if (!vpar)
  1062. vpar++;
  1063. count = (vpar > video_num_columns-x) ? (video_num_columns-x) : vpar;
  1065. scr_memsetw((unsigned short *) pos, video_erase_char, 2 * count);
  1066. if (DO_UPDATE)
  1067. sw->con_clear(vc_cons[currcons].d, y, x, 1, count);
  1068. need_wrap = 0;
  1069. }
  1071. static void default_attr(int currcons)
  1072. {
  1073. intensity = 1;
  1074. underline = 0;
  1075. reverse = 0;
  1076. blink = 0;
  1077. color = def_color;
  1078. }
  1080. /* console_sem is held */
  1081. static void csi_m(int currcons)
  1082. {
  1083. int i;
  1085. for (i=0;i<=npar;i++)
  1086. switch (par[i]) {
  1087. case 0: /* all attributes off */
  1088. default_attr(currcons);
  1089. break;
  1090. case 1:
  1091. intensity = 2;
  1092. break;
  1093. case 2:
  1094. intensity = 0;
  1095. break;
  1096. case 4:
  1097. underline = 1;
  1098. break;
  1099. case 5:
  1100. blink = 1;
  1101. break;
  1102. case 7:
  1103. reverse = 1;
  1104. break;
  1105. case 10: /* ANSI X3.64-1979 (SCO-ish?)
  1106.   * Select primary font, don't display
  1107.   * control chars if defined, don't set
  1108.   * bit 8 on output.
  1109.   */
  1110. translate = set_translate(charset == 0
  1111. ? G0_charset
  1112. : G1_charset,currcons);
  1113. disp_ctrl = 0;
  1114. toggle_meta = 0;
  1115. break;
  1116. case 11: /* ANSI X3.64-1979 (SCO-ish?)
  1117.   * Select first alternate font, lets
  1118.   * chars < 32 be displayed as ROM chars.
  1119.   */
  1120. translate = set_translate(IBMPC_MAP,currcons);
  1121. disp_ctrl = 1;
  1122. toggle_meta = 0;
  1123. break;
  1124. case 12: /* ANSI X3.64-1979 (SCO-ish?)
  1125.   * Select second alternate font, toggle
  1126.   * high bit before displaying as ROM char.
  1127.   */
  1128. translate = set_translate(IBMPC_MAP,currcons);
  1129. disp_ctrl = 1;
  1130. toggle_meta = 1;
  1131. break;
  1132. case 21:
  1133. case 22:
  1134. intensity = 1;
  1135. break;
  1136. case 24:
  1137. underline = 0;
  1138. break;
  1139. case 25:
  1140. blink = 0;
  1141. break;
  1142. case 27:
  1143. reverse = 0;
  1144. break;
  1145. case 38: /* ANSI X3.64-1979 (SCO-ish?)
  1146.   * Enables underscore, white foreground
  1147.   * with white underscore (Linux - use
  1148.   * default foreground).
  1149.   */
  1150. color = (def_color & 0x0f) | background;
  1151. underline = 1;
  1152. break;
  1153. case 39: /* ANSI X3.64-1979 (SCO-ish?)
  1154.   * Disable underline option.
  1155.   * Reset colour to default? It did this
  1156.   * before...
  1157.   */
  1158. color = (def_color & 0x0f) | background;
  1159. underline = 0;
  1160. break;
  1161. case 49:
  1162. color = (def_color & 0xf0) | foreground;
  1163. break;
  1164. default:
  1165. if (par[i] >= 30 && par[i] <= 37)
  1166. color = color_table[par[i]-30]
  1167. | background;
  1168. else if (par[i] >= 40 && par[i] <= 47)
  1169. color = (color_table[par[i]-40]<<4)
  1170. | foreground;
  1171. break;
  1172. }
  1173. update_attr(currcons);
  1174. }
  1176. static void respond_string(const char * p, struct tty_struct * tty)
  1177. {
  1178. while (*p) {
  1179. tty_insert_flip_char(tty, *p, 0);
  1180. p++;
  1181. }
  1182. con_schedule_flip(tty);
  1183. }
  1185. static void cursor_report(int currcons, struct tty_struct * tty)
  1186. {
  1187. char buf[40];
  1189. sprintf(buf, "33[%d;%dR", y + (decom ? top+1 : 1), x+1);
  1190. respond_string(buf, tty);
  1191. }
  1193. static inline void status_report(struct tty_struct * tty)
  1194. {
  1195. respond_string("33[0n", tty); /* Terminal ok */
  1196. }
  1198. static inline void respond_ID(struct tty_struct * tty)
  1199. {
  1200. respond_string(VT102ID, tty);
  1201. }
  1203. void mouse_report(struct tty_struct * tty, int butt, int mrx, int mry)
  1204. {
  1205. char buf[8];
  1207. sprintf(buf, "33[M%c%c%c", (char)(' ' + butt), (char)('!' + mrx),
  1208. (char)('!' + mry));
  1209. respond_string(buf, tty);
  1210. }
  1212. /* invoked via ioctl(TIOCLINUX) and through set_selection */
  1213. int mouse_reporting(void)
  1214. {
  1215. int currcons = fg_console;
  1217. return report_mouse;
  1218. }
  1220. /* console_sem is held */
  1221. static void set_mode(int currcons, int on_off)
  1222. {
  1223. int i;
  1225. for (i=0; i<=npar; i++)
  1226. if (ques) switch(par[i]) { /* DEC private modes set/reset */
  1227. case 1: /* Cursor keys send ^[Ox/^[[x */
  1228. if (on_off)
  1229. set_kbd(decckm);
  1230. else
  1231. clr_kbd(decckm);
  1232. break;
  1233. case 3: /* 80/132 mode switch unimplemented */
  1234. deccolm = on_off;
  1235. #if 0
  1236. (void) vc_resize(video_num_lines, deccolm ? 132 : 80);
  1237. /* this alone does not suffice; some user mode
  1238.    utility has to change the hardware regs */
  1239. #endif
  1240. break;
  1241. case 5: /* Inverted screen on/off */
  1242. if (decscnm != on_off) {
  1243. decscnm = on_off;
  1244. invert_screen(currcons, 0, screenbuf_size, 0);
  1245. update_attr(currcons);
  1246. }
  1247. break;
  1248. case 6: /* Origin relative/absolute */
  1249. decom = on_off;
  1250. gotoxay(currcons,0,0);
  1251. break;
  1252. case 7: /* Autowrap on/off */
  1253. decawm = on_off;
  1254. break;
  1255. case 8: /* Autorepeat on/off */
  1256. if (on_off)
  1257. set_kbd(decarm);
  1258. else
  1259. clr_kbd(decarm);
  1260. break;
  1261. case 9:
  1262. report_mouse = on_off ? 1 : 0;
  1263. break;
  1264. case 25: /* Cursor on/off */
  1265. deccm = on_off;
  1266. break;
  1267. case 1000:
  1268. report_mouse = on_off ? 2 : 0;
  1269. break;
  1270. } else switch(par[i]) { /* ANSI modes set/reset */
  1271. case 3: /* Monitor (display ctrls) */
  1272. disp_ctrl = on_off;
  1273. break;
  1274. case 4: /* Insert Mode on/off */
  1275. decim = on_off;
  1276. break;
  1277. case 20: /* Lf, Enter == CrLf/Lf */
  1278. if (on_off)
  1279. set_kbd(lnm);
  1280. else
  1281. clr_kbd(lnm);
  1282. break;
  1283. }
  1284. }
  1286. /* console_sem is held */
  1287. static void setterm_command(int currcons)
  1288. {
  1289. switch(par[0]) {
  1290. case 1: /* set color for underline mode */
  1291. if (can_do_color && par[1] < 16) {
  1292. ulcolor = color_table[par[1]];
  1293. if (underline)
  1294. update_attr(currcons);
  1295. }
  1296. break;
  1297. case 2: /* set color for half intensity mode */
  1298. if (can_do_color && par[1] < 16) {
  1299. halfcolor = color_table[par[1]];
  1300. if (intensity == 0)
  1301. update_attr(currcons);
  1302. }
  1303. break;
  1304. case 8: /* store colors as defaults */
  1305. def_color = attr;
  1306. if (hi_font_mask == 0x100)
  1307. def_color >>= 1;
  1308. default_attr(currcons);
  1309. update_attr(currcons);
  1310. break;
  1311. case 9: /* set blanking interval */
  1312. #ifdef CONFIG_CONSOLE_PM // bushi
  1313. blankinterval = ((par[1] < 60) ? par[1] : 60) * 60 * HZ;
  1314. poke_blanked_console();
  1315. #endif
  1316. break;
  1317. case 10: /* set bell frequency in Hz */
  1318. if (npar >= 1)
  1319. bell_pitch = par[1];
  1320. else
  1321. bell_pitch = DEFAULT_BELL_PITCH;
  1322. break;
  1323. case 11: /* set bell duration in msec */
  1324. if (npar >= 1)
  1325. bell_duration = (par[1] < 2000) ?
  1326. par[1]*HZ/1000 : 0;
  1327. else
  1328. bell_duration = DEFAULT_BELL_DURATION;
  1329. break;
  1330. case 12: /* bring specified console to the front */
  1331. if (par[1] >= 1 && vc_cons_allocated(par[1]-1))
  1332. set_console(par[1] - 1);
  1333. break;
  1334. case 13: /* unblank the screen */
  1335. #ifdef CONFIG_CONSOLE_PM // bushi
  1336. poke_blanked_console();
  1337. #endif
  1338. break;
  1339. case 14: /* set vesa powerdown interval */
  1340. #ifdef CONFIG_CONSOLE_PM // bushi
  1341. vesa_off_interval = ((par[1] < 60) ? par[1] : 60) * 60 * HZ;
  1342. #endif
  1343. break;
  1344. }
  1345. }
  1347. /* console_sem is held */
  1348. static void csi_at(int currcons, unsigned int nr)
  1349. {
  1350. if (nr > video_num_columns - x)
  1351. nr = video_num_columns - x;
  1352. else if (!nr)
  1353. nr = 1;
  1354. insert_char(currcons, nr);
  1355. }
  1357. /* console_sem is held */
  1358. static void csi_L(int currcons, unsigned int nr)
  1359. {
  1360. if (nr > video_num_lines - y)
  1361. nr = video_num_lines - y;
  1362. else if (!nr)
  1363. nr = 1;
  1364. scrdown(currcons,y,bottom,nr);
  1365. need_wrap = 0;
  1366. }
  1368. /* console_sem is held */
  1369. static void csi_P(int currcons, unsigned int nr)
  1370. {
  1371. if (nr > video_num_columns - x)
  1372. nr = video_num_columns - x;
  1373. else if (!nr)
  1374. nr = 1;
  1375. delete_char(currcons, nr);
  1376. }
  1378. /* console_sem is held */
  1379. static void csi_M(int currcons, unsigned int nr)
  1380. {
  1381. if (nr > video_num_lines - y)
  1382. nr = video_num_lines - y;
  1383. else if (!nr)
  1384. nr=1;
  1385. scrup(currcons,y,bottom,nr);
  1386. need_wrap = 0;
  1387. }
  1389. /* console_sem is held (except via vc_init->reset_terminal */
  1390. static void save_cur(int currcons)
  1391. {
  1392. saved_x = x;
  1393. saved_y = y;
  1394. s_intensity = intensity;
  1395. s_underline = underline;
  1396. s_blink = blink;
  1397. s_reverse = reverse;
  1398. s_charset = charset;
  1399. s_color = color;
  1400. saved_G0 = G0_charset;
  1401. saved_G1 = G1_charset;
  1402. }
  1404. /* console_sem is held */
  1405. static void restore_cur(int currcons)
  1406. {
  1407. gotoxy(currcons,saved_x,saved_y);
  1408. intensity = s_intensity;
  1409. underline = s_underline;
  1410. blink = s_blink;
  1411. reverse = s_reverse;
  1412. charset = s_charset;
  1413. color = s_color;
  1414. G0_charset = saved_G0;
  1415. G1_charset = saved_G1;
  1416. translate = set_translate(charset ? G1_charset : G0_charset,currcons);
  1417. update_attr(currcons);
  1418. need_wrap = 0;
  1419. }
  1421. static int con_write_ctrl_ESnormal(int, struct tty_struct *, unsigned int);
  1422. static int con_write_ctrl_ESesc(int, struct tty_struct *, unsigned int);
  1423. static int con_write_ctrl_ESnonstd(int, struct tty_struct *, unsigned int);
  1424. static int con_write_ctrl_ESpalette(int, struct tty_struct *, unsigned int);
  1425. static int con_write_ctrl_ESsquare(int, struct tty_struct *, unsigned int);
  1426. static int con_write_ctrl_ESgetpars(int, struct tty_struct *, unsigned int);
  1427. static int con_write_ctrl_ESgotpars(int, struct tty_struct *, unsigned int);
  1428. static int con_write_ctrl_ESpercent(int, struct tty_struct *, unsigned int);
  1429. static int con_write_ctrl_ESfunckey(int, struct tty_struct *, unsigned int);
  1430. static int con_write_ctrl_EShash(int, struct tty_struct *, unsigned int);
  1431. static int con_write_ctrl_ESsetG0(int, struct tty_struct *, unsigned int);
  1432. static int con_write_ctrl_ESsetG1(int, struct tty_struct *, unsigned int);
  1434. enum { ESnormal, ESesc, ESsquare, ESgetpars, ESgotpars, ESfunckey,
  1435. EShash, ESsetG0, ESsetG1, ESpercent, ESignore, ESnonstd,
  1436. ESpalette };
  1438. /* console_sem is held (except via vc_init()) */
  1439. static void reset_terminal(int currcons, int do_clear)
  1440. {
  1441. top = 0;
  1442. bottom = video_num_lines;
  1443. vc_state = con_write_ctrl_ESnormal;
  1444. ques = 0;
  1445. translate = set_translate(LAT1_MAP,currcons);
  1446. G0_charset = LAT1_MAP;
  1447. G1_charset = GRAF_MAP;
  1448. charset = 0;
  1449. need_wrap = 0;
  1450. report_mouse = 0;
  1451. utf             = 0;
  1452. utf_count       = 0;
  1454. disp_ctrl = 0;
  1455. toggle_meta = 0;
  1457. decscnm = 0;
  1458. decom = 0;
  1459. decawm = 1;
  1460. deccm = 1;
  1461. decim = 0;
  1463. set_kbd(decarm);
  1464. clr_kbd(decckm);
  1465. clr_kbd(kbdapplic);
  1466. clr_kbd(lnm);
  1467. kbd_table[currcons].lockstate = 0;
  1468. kbd_table[currcons].slockstate = 0;
  1469. kbd_table[currcons].ledmode = LED_SHOW_FLAGS;
  1470. kbd_table[currcons].ledflagstate = kbd_table[currcons].default_ledflagstate;
  1471. set_leds();
  1473. cursor_type = CUR_DEFAULT;
  1474. complement_mask = s_complement_mask;
  1476. default_attr(currcons);
  1477. update_attr(currcons);
  1479. tab_stop[0] = 0x01010100;
  1480. tab_stop[1] =
  1481. tab_stop[2] =
  1482. tab_stop[3] =
  1483. tab_stop[4] = 0x01010101;
  1485. bell_pitch = DEFAULT_BELL_PITCH;
  1486. bell_duration = DEFAULT_BELL_DURATION;
  1488. gotoxy(currcons,0,0);
  1489. save_cur(currcons);
  1490. if (do_clear)
  1491.     csi_J(currcons,2);
  1492. }
  1494. /* console_sem is held */
  1495. static void do_con_trol(struct tty_struct *tty, unsigned int currcons, int c)
  1496. {
  1497. /*
  1498.  *  Control characters can be used in the _middle_
  1499.  *  of an escape sequence.
  1500.  */
  1501. switch (c) {
  1502. case 0:
  1503. return;
  1504. case 7:
  1505. if (bell_duration)
  1506. kd_mksound(bell_pitch, bell_duration);
  1507. return;
  1508. case 8:
  1509. bs(currcons);
  1510. return;
  1511. case 9:
  1512. pos -= (x << 1);
  1513. while (x < video_num_columns - 1) {
  1514. x++;
  1515. if (tab_stop[x >> 5] & (1 << (x & 31)))
  1516. break;
  1517. }
  1518. pos += (x << 1);
  1519. return;
  1520. case 10: case 11: case 12:
  1521. lf(currcons);
  1522. if (!is_kbd(lnm))
  1523. return;
  1524. case 13:
  1525. cr(currcons);
  1526. return;
  1527. case 14:
  1528. charset = 1;
  1529. translate = set_translate(G1_charset,currcons);
  1530. disp_ctrl = 1;
  1531. return;
  1532. case 15:
  1533. charset = 0;
  1534. translate = set_translate(G0_charset,currcons);
  1535. disp_ctrl = 0;
  1536. return;
  1537. case 24: case 26:
  1538. vc_state = con_write_ctrl_ESnormal;
  1539. return;
  1540. case 27:
  1541. vc_state = con_write_ctrl_ESesc;
  1542. return;
  1543. case 127:
  1544. del(currcons);
  1545. return;
  1546. case 128+27:
  1547. vc_state = con_write_ctrl_ESsquare;
  1548. return;
  1549. }
  1550. vc_state(currcons, tty, c);
  1551. }
  1553. static int con_write_utf(int currcons, int c)
  1554. {
  1555. unsigned int chr;
  1557. /* Combine UTF-8 into Unicode */
  1558. /* Incomplete characters silently ignored */
  1559. if (c < 0x80) {
  1560. utf_count = 0;
  1561. return c;
  1562. }
  1564. if (utf_count > 0 && (c & 0xc0) == 0x80) {
  1565. chr = (utf_char << 6) | (c & 0x3f);
  1566. utf_count--;
  1567. if (utf_count == 0)
  1568. return chr;
  1569. } else {
  1570. unsigned int count;
  1571. if ((c & 0xe0) == 0xc0) {
  1572. count = 1;
  1573. chr = (c & 0x1f);
  1574. } else if ((c & 0xf0) == 0xe0) {
  1575. count = 2;
  1576. chr = (c & 0x0f);
  1577. } else if ((c & 0xf8) == 0xf0) {
  1578. count = 3;
  1579. chr = (c & 0x07);
  1580. } else if ((c & 0xfc) == 0xf8) {
  1581. count = 4;
  1582. chr = (c & 0x03);
  1583. } else if ((c & 0xfe) == 0xfc) {
  1584. count = 5;
  1585. chr = (c & 0x01);
  1586. } else {
  1587. count = 0;
  1588. chr = 0;
  1589. }
  1590. utf_count = count;
  1591. }
  1593. utf_char = chr;
  1594. return -1;
  1595. }
  1597. static int con_write_ctrl_ESnormal(int currcons, struct tty_struct *tty, unsigned int c)
  1598. {
  1599. return 0;
  1600. }
  1602. static int con_write_ctrl_ESesc(int currcons, struct tty_struct *tty, unsigned int c)
  1603. {
  1604. vc_state = con_write_ctrl_ESnormal;
  1605. switch (c) {
  1606. case '[':
  1607. vc_state = con_write_ctrl_ESsquare;
  1608. break;
  1609. case ']':
  1610. vc_state = con_write_ctrl_ESnonstd;
  1611. break;
  1612. case '%':
  1613. vc_state = con_write_ctrl_ESpercent;
  1614. break;
  1615. case 'E':
  1616. cr(currcons);
  1617. lf(currcons);
  1618. break;
  1619. case 'M':
  1620. ri(currcons);
  1621. break;
  1622. case 'D':
  1623. lf(currcons);
  1624. break;
  1625. case 'H':
  1626. tab_stop[x >> 5] |= (1 << (x & 31));
  1627. break;
  1628. case 'Z':
  1629. respond_ID(tty);
  1630. break;
  1631. case '7':
  1632. save_cur(currcons);
  1633. break;
  1634. case '8':
  1635. restore_cur(currcons);
  1636. return 1;
  1637. case '(':
  1638. vc_state = con_write_ctrl_ESsetG0;
  1639. break;
  1640. case ')':
  1641. vc_state = con_write_ctrl_ESsetG1;
  1642. break;
  1643. case '#':
  1644. vc_state = con_write_ctrl_EShash;
  1645. break;
  1646. case 'c':
  1647. reset_terminal(currcons,1);
  1648. return 1;
  1649. case '>':  /* Numeric keypad */
  1650. clr_kbd(kbdapplic);
  1651. break;
  1652. case '=':  /* Appl. keypad */
  1653. set_kbd(kbdapplic);
  1654.   break;
  1655. }
  1656. return 0;
  1657. }
  1659. static int con_write_ctrl_ESnonstd(int currcons, struct tty_struct *tty, unsigned int c)
  1660. {
  1661. switch (c) {
  1662. case 'P': /* palette escape sequence */
  1663. for (npar=0; npar<NPAR; npar++)
  1664. par[npar] = 0 ;
  1665. npar = 0 ;
  1666. vc_state = con_write_ctrl_ESpalette;
  1667. break;
  1668. case 'R': /* reset palette */
  1669. reset_palette (currcons);
  1670. default:
  1671. vc_state = con_write_ctrl_ESnormal;
  1672. }
  1673. return 0;
  1674. }
  1676. static int con_write_ctrl_ESpalette(int currcons, struct tty_struct *tty, unsigned int c)
  1677. {
  1678. if ( (c>='0'&&c<='9') || (c>='A'&&c<='F') || (c>='a'&&c<='f') ) {
  1679. par[npar++] = (c>'9' ? (c&0xDF)-'A'+10 : c-'0') ;
  1680. if (npar==7) {
  1681. int i = par[0]*3, j = 1;
  1682. palette[i] = 16*par[j++];
  1683. palette[i++] += par[j++];
  1684. palette[i] = 16*par[j++];
  1685. palette[i++] += par[j++];
  1686. palette[i] = 16*par[j++];
  1687. palette[i] += par[j];
  1688. set_palette(currcons);
  1689. vc_state = con_write_ctrl_ESnormal;
  1690. }
  1691. } else
  1692. vc_state = con_write_ctrl_ESnormal;
  1693. return 0;
  1694. }
  1696. static int con_write_ctrl_ESsquare(int currcons, struct tty_struct *tty, unsigned int c)
  1697. {
  1698. for(npar = 0 ; npar < NPAR ; npar++)
  1699. par[npar] = 0;
  1700. npar = 0;
  1701. vc_state = con_write_ctrl_ESgetpars;
  1702. if (c == '[') { /* Function key */
  1703. vc_state = con_write_ctrl_ESfunckey;
  1704. return 0;
  1705. }
  1706. ques = (c=='?');
  1707. if (ques)
  1708. return 0;
  1709. return con_write_ctrl_ESgetpars(currcons, tty, c);
  1710. }
  1712. static int con_write_ctrl_ESgetpars(int currcons, struct tty_struct *tty, unsigned int c)
  1713. {
  1714. if (c==';' && npar<NPAR-1) {
  1715. npar++;
  1716. return 0;
  1717. } else if (c>='0' && c<='9') {
  1718. par[npar] *= 10;
  1719. par[npar] += c-'0';
  1720. return 0;
  1721. } else vc_state = con_write_ctrl_ESgotpars;
  1722. return con_write_ctrl_ESgotpars(currcons, tty, c);
  1723. }
  1725. static int con_write_ctrl_ESgotpars(int currcons, struct tty_struct *tty, unsigned int c)
  1726. {
  1727. vc_state = con_write_ctrl_ESnormal;
  1728. switch(c) {
  1729. case 'h':
  1730. set_mode(currcons,1);
  1731. return 0;
  1732. case 'l':
  1733. set_mode(currcons,0);
  1734. return 0;
  1735. case 'c':
  1736. if (ques) {
  1737. if (par[0])
  1738. cursor_type = par[0] | (par[1]<<8) | (par[2]<<16);
  1739. else
  1740. cursor_type = CUR_DEFAULT;
  1741. return 0;
  1742. }
  1743. break;
  1744. case 'm':
  1745. if (ques) {
  1746. clear_selection();
  1747. if (par[0])
  1748. complement_mask = par[0]<<8 | par[1];
  1749. else
  1750. complement_mask = s_complement_mask;
  1751. return 0;
  1752. }
  1753. break;
  1754. case 'n':
  1755. if (!ques) {
  1756. if (par[0] == 5)
  1757. status_report(tty);
  1758. else if (par[0] == 6)
  1759. cursor_report(currcons,tty);
  1760. }
  1761. return 0;
  1762. }
  1763. if (ques) {
  1764. ques = 0;
  1765. return 0;
  1766. }
  1767. switch(c) {
  1768. case 'G': case '`':
  1769. if (par[0]) par[0]--;
  1770. gotoxy(currcons,par[0],y);
  1771. break;
  1772. case 'A':
  1773. if (!par[0]) par[0]++;
  1774. gotoxy(currcons,x,y-par[0]);
  1775. break;
  1776. case 'B': case 'e':
  1777. if (!par[0]) par[0]++;
  1778. gotoxy(currcons,x,y+par[0]);
  1779. break;
  1780. case 'C': case 'a':
  1781. if (!par[0]) par[0]++;
  1782. gotoxy(currcons,x+par[0],y);
  1783. break;
  1784. case 'D':
  1785. if (!par[0]) par[0]++;
  1786. gotoxy(currcons,x-par[0],y);
  1787. break;
  1788. case 'E':
  1789. if (!par[0]) par[0]++;
  1790. gotoxy(currcons,0,y+par[0]);
  1791. break;
  1792. case 'F':
  1793. if (!par[0]) par[0]++;
  1794. gotoxy(currcons,0,y-par[0]);
  1795. break;
  1796. case 'd':
  1797. if (par[0]) par[0]--;
  1798. gotoxay(currcons,x,par[0]);
  1799. break;
  1800. case 'H': case 'f':
  1801. if (par[0]) par[0]--;
  1802. if (par[1]) par[1]--;
  1803. gotoxay(currcons,par[1],par[0]);
  1804. break;
  1805. case 'J':
  1806. csi_J(currcons,par[0]);
  1807. break;
  1808. case 'K':
  1809. csi_K(currcons,par[0]);
  1810. break;
  1811. case 'L':
  1812. csi_L(currcons,par[0]);
  1813. break;
  1814. case 'M':
  1815. csi_M(currcons,par[0]);
  1816. break;
  1817. case 'P':
  1818. csi_P(currcons,par[0]);
  1819. break;
  1820. case 'c':
  1821. if (!par[0])
  1822. respond_ID(tty);
  1823. break;
  1824. case 'g':
  1825. if (!par[0])
  1826. tab_stop[x >> 5] &= ~(1 << (x & 31));
  1827. else if (par[0] == 3) {
  1828. tab_stop[0] =
  1829. tab_stop[1] =
  1830. tab_stop[2] =
  1831. tab_stop[3] =
  1832. tab_stop[4] = 0;
  1833. }
  1834. break;
  1835. case 'm':
  1836. csi_m(currcons);
  1837. return 1;
  1838. case 'q': /* DECLL - but only 3 leds */
  1839. /* map 0,1,2,3 to 0,1,2,4 */
  1840. if (par[0] < 4)
  1841.   setledstate(kbd_table + currcons,
  1842.       (par[0] < 3) ? par[0] : 4);
  1843. break;
  1844. case 'r':
  1845. if (!par[0])
  1846. par[0]++;
  1847. if (!par[1])
  1848. par[1] = video_num_lines;
  1849. /* Minimum allowed region is 2 lines */
  1850. if (par[0] < par[1] &&
  1851.     par[1] <= video_num_lines) {
  1852. top=par[0]-1;
  1853. bottom=par[1];
  1854. gotoxay(currcons,0,0);
  1855. }
  1856. break;
  1857. case 's':
  1858. save_cur(currcons);
  1859. break;
  1860. case 'u':
  1861. restore_cur(currcons);
  1862. return 1;
  1863. case 'X':
  1864. csi_X(currcons, par[0]);
  1865. break;
  1866. case '@':
  1867. csi_at(currcons,par[0]);
  1868. break;
  1869. case ']': /* setterm functions */
  1870. setterm_command(currcons);
  1871. break;
  1872. }
  1873. return 0;
  1874. }
  1876. static int con_write_ctrl_ESpercent(int currcons, struct tty_struct *tty, unsigned int c)
  1877. {
  1878. vc_state = con_write_ctrl_ESnormal;
  1879. switch (c) {
  1880. case '@':  /* defined in ISO 2022 */
  1881. utf = 0;
  1882. break;
  1883. case 'G':  /* prelim official escape code */
  1884. case '8':  /* retained for compatibility */
  1885. utf = 1;
  1886. break;
  1887. }
  1888. return 0;
  1889. }
  1891. static int con_write_ctrl_ESfunckey(int currcons, struct tty_struct *tty, unsigned int c)
  1892. {
  1893. vc_state = con_write_ctrl_ESnormal;
  1894. return 0;
  1895. }
  1897. static int con_write_ctrl_EShash(int currcons, struct tty_struct *tty, unsigned int c)
  1898. {
  1899. vc_state = con_write_ctrl_ESnormal;
  1900. if (c == '8') {
  1901. /* DEC screen alignment test. kludge :-) */
  1902. video_erase_char =
  1903. (video_erase_char & 0xff00) | 'E';
  1904. csi_J(currcons, 2);
  1905. video_erase_char =
  1906. (video_erase_char & 0xff00) | ' ';
  1907. do_update_region(currcons, origin, screenbuf_size/2);
  1908. }
  1909. return 0;
  1910. }
  1912. static int con_write_ctrl_ESsetG0(int currcons, struct tty_struct *tty, unsigned int c)
  1913. {
  1914. switch (c) {
  1915. case '0':
  1916. G0_charset = GRAF_MAP;
  1917. break;
  1918. case 'B':
  1919. G0_charset = LAT1_MAP;
  1920. break;
  1921. case 'U':
  1922. G0_charset = IBMPC_MAP;
  1923. break;
  1924. case 'K':
  1925. G0_charset = USER_MAP;
  1926. break;
  1927. }
  1928. if (charset == 0) {
  1929. translate = set_translate(G0_charset,currcons);
  1930. return 1;
  1931. }
  1932. vc_state = con_write_ctrl_ESnormal;
  1933. return 0;
  1934. }
  1936. static int con_write_ctrl_ESsetG1(int currcons, struct tty_struct *tty, unsigned int c)
  1937. {
  1938. switch (c) {
  1939. case '0':
  1940. G1_charset = GRAF_MAP;
  1941. break;
  1942. case 'B':
  1943. G1_charset = LAT1_MAP;
  1944. break;
  1945. case 'U':
  1946. G1_charset = IBMPC_MAP;
  1947. break;
  1948. case 'K':
  1949. G1_charset = USER_MAP;
  1950. break;
  1951. }
  1952. if (charset == 1) {
  1953. translate = set_translate(G1_charset,currcons);
  1954. return 1;
  1955. }
  1956. vc_state = con_write_ctrl_ESnormal;
  1957. return 0;
  1958. }
  1960. /* This is a temporary buffer used to prepare a tty console write
  1961.  * so that we can easily avoid touching user space while holding the
  1962.  * console spinlock.  It is allocated in con_init and is shared by
  1963.  * this code and the vc_screen read/write tty calls.
  1964.  *
  1965.  * We have to allocate this statically in the kernel data section
  1966.  * since console_init (and thus con_init) are called before any
  1967.  * kernel memory allocation is available.
  1968.  */
  1969. char con_buf[PAGE_SIZE];
  1970. #define CON_BUF_SIZE PAGE_SIZE
  1971. DECLARE_MUTEX(con_buf_sem);
  1973. /* acquires console_sem */
  1974. static int do_con_write(struct tty_struct * tty, int from_user,
  1975. const unsigned char *buf, int count)
  1976. {
  1977. #ifdef VT_BUF_VRAM_ONLY
  1978. #define FLUSH do { } while(0);
  1979. #else
  1980. #define FLUSH if (draw_x >= 0) { 
  1981. sw->con_putcs(vc_cons[currcons].d, (u16 *)draw_from, (u16 *)draw_to-(u16 *)draw_from, y, draw_x); 
  1982. draw_x = -1; 
  1983. }
  1984. #endif
  1986. int c, tc, ok, n = 0, draw_x = -1;
  1987. unsigned int currcons;
  1988. unsigned long draw_from = 0, draw_to = 0;
  1989. struct vt_struct *vt = (struct vt_struct *)tty->driver_data;
  1990. u16 himask, charmask;
  1991. const unsigned char *orig_buf;
  1992. int orig_count;
  1994. if (in_interrupt())
  1995. return count;
  1997. currcons = vt->vc_num;
  1998. if (!vc_cons_allocated(currcons)) {
  1999.     /* could this happen? */
  2000.     static int error = 0;
  2001.     if (!error) {
  2002. error = 1;
  2003. printk("con_write: tty %d not allocatedn", currcons+1);
  2004.     }
  2005.     return 0;
  2006. }
  2008. orig_buf = buf;
  2009. orig_count = count;
  2011. if (from_user) {
  2012. down(&con_buf_sem);
  2014. again:
  2015. if (count > CON_BUF_SIZE)
  2016. count = CON_BUF_SIZE;
  2017. console_conditional_schedule();
  2018. if (copy_from_user(con_buf, buf, count)) {
  2019. n = 0; /* ?? are error codes legal here ?? */
  2020. goto out;
  2021. }
  2023. buf = con_buf;
  2024. }
  2026. /* At this point 'buf' is guarenteed to be a kernel buffer
  2027.  * and therefore no access to userspace (and therefore sleeping)
  2028.  * will be needed.  The con_buf_sem serializes all tty based
  2029.  * console rendering and vcs write/read operations.  We hold
  2030.  * the console spinlock during the entire write.
  2031.  */
  2033. acquire_console_sem();
  2035. himask = hi_font_mask;
  2036. charmask = himask ? 0x1ff : 0xff;
  2038. /* undraw cursor first */
  2039. if (IS_FG)
  2040. hide_cursor(currcons);
  2042. while (!tty->stopped && count) {
  2043. c = *buf;
  2044. buf++;
  2045. n++;
  2046. count--;
  2048. if (utf) {
  2049. tc = con_write_utf(currcons, c);
  2050. if (tc < 0)
  2051. continue;
  2052. c = tc;
  2053. } else /* no utf */
  2054. tc = translate[toggle_meta ? (c|0x80) : c];
  2056.                 /* If the original code was a control character we
  2057.                  * only allow a glyph to be displayed if the code is
  2058.                  * not normally used (such as for cursor movement) or
  2059.                  * if the disp_ctrl mode has been explicitly enabled.
  2060.                  * Certain characters (as given by the CTRL_ALWAYS
  2061.                  * bitmap) are always displayed as control characters,
  2062.                  * as the console would be pretty useless without
  2063.                  * them; to display an arbitrary font position use the
  2064.                  * direct-to-font zone in UTF-8 mode.
  2065.                  */
  2066.                 ok = tc && (c >= 32 ||
  2067.                             (!utf && !(((disp_ctrl ? CTRL_ALWAYS
  2068.                                          : CTRL_ACTION) >> c) & 1)))
  2069.                         && (c != 127 || disp_ctrl)
  2070. && (c != 128+27);
  2072. if (vc_state == con_write_ctrl_ESnormal && ok) {
  2073. /* Now try to find out how to display it */
  2074. tc = conv_uni_to_pc(vc_cons[currcons].d, tc);
  2075. if ( tc == -4 ) {
  2076.                                 /* If we got -4 (not found) then see if we have
  2077.                                    defined a replacement character (U+FFFD) */
  2078.                                 tc = conv_uni_to_pc(vc_cons[currcons].d, 0xfffd);
  2080. /* One reason for the -4 can be that we just
  2081.    did a clear_unimap();
  2082.    try at least to show something. */
  2083. if (tc == -4)
  2084.      tc = c;
  2085.                         } else if ( tc == -3 ) {
  2086.                                 /* Bad hash table -- hope for the best */
  2087.                                 tc = c;
  2088.                         }
  2089. if (tc & ~charmask)
  2090.                                 continue; /* Conversion failed */
  2092. if (need_wrap || decim)
  2093. FLUSH
  2094. if (need_wrap) {
  2095. cr(currcons);
  2096. lf(currcons);
  2097. }
  2098. if (decim)
  2099. insert_char(currcons, 1);
  2100. scr_writew(himask ?
  2101.      ((attr << 8) & ~himask) + ((tc & 0x100) ? himask : 0) + (tc & 0xff) :
  2102.      (attr << 8) + tc,
  2103.    (u16 *) pos);
  2104. if (DO_UPDATE && draw_x < 0) {
  2105. draw_x = x;
  2106. draw_from = pos;
  2107. }
  2108. if (x == video_num_columns - 1) {
  2109. need_wrap = decawm;
  2110. draw_to = pos+2;
  2111. } else {
  2112. x++;
  2113. draw_to = (pos+=2);
  2114. }
  2115. continue;
  2116. }
  2117. FLUSH
  2118. do_con_trol(tty, currcons, c);
  2119. }
  2120. FLUSH
  2121. console_conditional_schedule();
  2122. release_console_sem();
  2124. out:
  2125. if (from_user) {
  2126. /* If the user requested something larger than
  2127.  * the CON_BUF_SIZE, and the tty is not stopped,
  2128.  * keep going.
  2129.  */
  2130. if ((orig_count > CON_BUF_SIZE) && !tty->stopped) {
  2131. orig_count -= CON_BUF_SIZE;
  2132. orig_buf += CON_BUF_SIZE;
  2133. count = orig_count;
  2134. buf = orig_buf;
  2135. goto again;
  2136. }
  2138. up(&con_buf_sem);
  2139. }
  2141. return n;
  2142. #undef FLUSH
  2143. }
  2145. /*
  2146.  * This is the console switching callback.
  2147.  *
  2148.  * Doing console switching in a process context allows
  2149.  * us to do the switches asynchronously (needed when we want
  2150.  * to switch due to a keyboard interrupt).  Synchronization
  2151.  * with other console code and prevention of re-entrancy is
  2152.  * ensured with console_sem.
  2153.  */
  2154. static void console_callback(void *ignored)
  2155. {
  2156. acquire_console_sem();
  2158. if (want_console >= 0) {
  2159. if (want_console != fg_console && vc_cons_allocated(want_console)) {
  2160. hide_cursor(fg_console);
  2161. change_console(want_console);
  2162. /* we only changed when the console had already
  2163.    been allocated - a new console is not created
  2164.    in an interrupt routine */
  2165. }
  2166. want_console = -1;
  2167. }
  2168. #ifdef CONFIG_CONSOLE_PM // bushi
  2169. if (do_poke_blanked_console) { /* do not unblank for a LED change */
  2170. do_poke_blanked_console = 0;
  2171. poke_blanked_console();
  2172. }
  2173. #endif
  2174. if (scrollback_delta) {
  2175. int currcons = fg_console;
  2176. clear_selection();
  2177. if (vcmode == KD_TEXT)
  2178. sw->con_scrolldelta(vc_cons[currcons].d, scrollback_delta);
  2179. scrollback_delta = 0;
  2180. }
  2182. release_console_sem();
  2183. }
  2185. void set_console(int nr)
  2186. {
  2187. want_console = nr;
  2188. schedule_console_callback();
  2189. }
  2191. #ifdef CONFIG_VT_CONSOLE
  2193. /*
  2194.  * Console on virtual terminal
  2195.  *
  2196.  * The console must be locked when we get here.
  2197.  */
  2199. void vt_console_print(struct console *co, const char * b, unsigned count)
  2200. {
  2201. int currcons = fg_console;
  2202. unsigned char c;
  2203. static unsigned long printing;
  2204. const ushort *start;
  2205. ushort cnt = 0;
  2206. ushort myx;
  2208. /* console busy or not yet initialized */
  2209. if (!printable || test_and_set_bit(0, &printing))
  2210. return;
  2212. #ifdef CONFIG_CONSOLE_PM // bushi
  2213. pm_access(pm_con);
  2214. #endif
  2216. if (kmsg_redirect && vc_cons_allocated(kmsg_redirect - 1))
  2217. currcons = kmsg_redirect - 1;
  2219. /* read `x' only after setting currcons properly (otherwise
  2220.    the `x' macro will read the x of the foreground console). */
  2221. myx = x;
  2223. if (!vc_cons_allocated(currcons)) {
  2224. /* impossible */
  2225. /* printk("vt_console_print: tty %d not allocated ??n", currcons+1); */
  2226. goto quit;
  2227. }
  2229. if (vcmode != KD_TEXT)
  2230. goto quit;
  2232. /* undraw cursor first */
  2233. if (IS_FG)
  2234. hide_cursor(currcons);
  2236. start = (ushort *)pos;
  2238. /* Contrived structure to try to emulate original need_wrap behaviour
  2239.  * Problems caused when we have need_wrap set on 'n' character */
  2240. while (count--) {
  2241. c = *b++;
  2242. if (c == 10 || c == 13 || c == 8 || need_wrap) {
  2243. if (cnt > 0) {
  2244. if (IS_VISIBLE)
  2245. sw->con_putcs(vc_cons[currcons].d, start, cnt, y, x);
  2246. x += cnt;
  2247. if (need_wrap)
  2248. x--;
  2249. cnt = 0;
  2250. }
  2251. if (c == 8) { /* backspace */
  2252. bs(currcons);
  2253. start = (ushort *)pos;
  2254. myx = x;
  2255. continue;
  2256. }
  2257. if (c != 13)
  2258. lf(currcons);
  2259. cr(currcons);
  2260. start = (ushort *)pos;
  2261. myx = x;
  2262. if (c == 10 || c == 13)
  2263. continue;
  2264. }
  2265. scr_writew((attr << 8) + c, (unsigned short *) pos);
  2266. cnt++;
  2267. if (myx == video_num_columns - 1) {
  2268. need_wrap = 1;
  2269. continue;
  2270. }
  2271. pos+=2;
  2272. myx++;
  2273. }
  2274. if (cnt > 0) {
  2275. if (IS_VISIBLE)
  2276. sw->con_putcs(vc_cons[currcons].d, start, cnt, y, x);
  2277. x += cnt;
  2278. if (x == video_num_columns) {
  2279. x--;
  2280. need_wrap = 1;
  2281. }
  2282. }
  2283. set_cursor(currcons);
  2285. #ifdef CONFIG_CONSOLE_PM // bushi
  2286. if (!oops_in_progress)
  2287. poke_blanked_console();
  2288. #endif
  2290. quit:
  2291. clear_bit(0, &printing);
  2292. }
  2294. static kdev_t vt_console_device(struct console *c)
  2295. {
  2296. return MKDEV(TTY_MAJOR, c->index ? c->index : fg_console + 1);
  2297. }
  2299. struct console vt_console_driver = {
  2300. name: "tty",
  2301. write: vt_console_print,
  2302. device: vt_console_device,
  2303. wait_key: keyboard_wait_for_keypress,
  2304. #ifdef CONFIG_CONSOLE_PM // bushi
  2305. unblank: unblank_screen,
  2306. #endif
  2307. flags: CON_PRINTBUFFER,
  2308. index: -1,
  2309. };
  2310. #endif
  2312. /*
  2313.  * Handling of Linux-specific VC ioctls
  2314.  */
  2316. /*
  2317.  * Generally a bit racy with respect to console_sem().
  2318.  *
  2319.  * There are some functions which don't need it.
  2320.  *
  2321.  * There are some functions which can sleep for arbitrary periods (paste_selection)
  2322.  * but we don't need the lock there anyway.
  2323.  *
  2324.  * set_selection has locking, and definitely needs it
  2325.  */
  2327. int tioclinux(struct tty_struct *tty, unsigned long arg)
  2328. {
  2329. char type, data;
  2330. int ret;
  2332. if (tty->driver.type != TTY_DRIVER_TYPE_CONSOLE)
  2333. return -EINVAL;
  2334. if (current->tty != tty && !capable(CAP_SYS_ADMIN))
  2335. return -EPERM;
  2336. if (get_user(type, (char *)arg))
  2337. return -EFAULT;
  2338. ret = 0;
  2339. switch (type)
  2340. {
  2341. case 2:
  2342. acquire_console_sem();
  2343. ret = set_selection(arg, tty, 1);
  2344. release_console_sem();
  2345. break;
  2346. case 3:
  2347. ret = paste_selection(tty);
  2348. break;
  2349. case 4:
  2350. #ifdef CONFIG_CONSOLE_PM // bushi
  2351. unblank_screen();
  2352. #endif
  2353. break;
  2354. case 5:
  2355. ret = sel_loadlut(arg);
  2356. break;
  2357. case 6:
  2359. /*
  2360.  * Make it possible to react to Shift+Mousebutton.
  2361.  * Note that 'shift_state' is an undocumented
  2362.  * kernel-internal variable; programs not closely
  2363.  * related to the kernel should not use this.
  2364.  */
  2365.   data = shift_state;
  2366. ret = __put_user(data, (char *) arg);
  2367. break;
  2368. case 7:
  2369. data = mouse_reporting();
  2370. ret = __put_user(data, (char *) arg);
  2371. break;
  2372. case 10:
  2373. #ifdef CONFIG_CONSOLE_PM //bushi
  2374. set_vesa_blanking(arg);
  2375. #endif
  2376. break;;
  2377. case 11: /* set kmsg redirect */
  2378. if (!capable(CAP_SYS_ADMIN)) {
  2379. ret = -EPERM;
  2380. } else {
  2381. if (get_user(data, (char *)arg+1))
  2382. ret = -EFAULT;
  2383. else
  2384. kmsg_redirect = data;
  2385. }
  2386. break;
  2387. case 12: /* get fg_console */
  2388. ret = fg_console;
  2389. break;
  2390. default:
  2391. ret = -EINVAL;
  2392. break;
  2393. }
  2394. return ret;
  2395. }
  2397. /*
  2398.  * /dev/ttyN handling
  2399.  */
  2401. static int con_write(struct tty_struct * tty, int from_user,
  2402.      const unsigned char *buf, int count)
  2403. {
  2404. int retval;
  2406. #ifdef CONFIG_CONSOLE_PM // bushi
  2407. pm_access(pm_con);
  2408. #endif
  2409. retval = do_con_write(tty, from_user, buf, count);
  2410. con_flush_chars(tty);
  2412. return retval;
  2413. }
  2415. static void con_put_char(struct tty_struct *tty, unsigned char ch)
  2416. {
  2417. if (in_interrupt())
  2418. return; /* n_r3964 calls put_char() from interrupt context */
  2419. #ifdef CONFIG_CONSOLE_PM // bushi
  2420. pm_access(pm_con);
  2421. #endif
  2422. do_con_write(tty, 0, &ch, 1);
  2423. }
  2425. static int con_write_room(struct tty_struct *tty)
  2426. {
  2427. if (tty->stopped)
  2428. return 0;
  2429. return 4096; /* No limit, really; we're not buffering */
  2430. }
  2432. static int con_chars_in_buffer(struct tty_struct *tty)
  2433. {
  2434. return 0; /* we're not buffering */
  2435. }
  2437. /*
  2438.  * con_throttle and con_unthrottle are only used for
  2439.  * paste_selection(), which has to stuff in a large number of
  2440.  * characters...
  2441.  */
  2442. static void con_throttle(struct tty_struct *tty)
  2443. {
  2444. }
  2446. static void con_unthrottle(struct tty_struct *tty)
  2447. {
  2448. struct vt_struct *vt = (struct vt_struct *) tty->driver_data;
  2450. wake_up_interruptible(&vt->paste_wait);
  2451. }
  2453. /*
  2454.  * Turn the Scroll-Lock LED on when the tty is stopped
  2455.  */
  2456. static void con_stop(struct tty_struct *tty)
  2457. {
  2458. int console_num;
  2459. if (!tty)
  2460. return;
  2461. console_num = MINOR(tty->device) - (tty->driver.minor_start);
  2462. if (!vc_cons_allocated(console_num))
  2463. return;
  2464. set_vc_kbd_led(kbd_table + console_num, VC_SCROLLOCK);
  2465. set_leds();
  2466. }
  2468. /*
  2469.  * Turn the Scroll-Lock LED off when the console is started
  2470.  */
  2471. static void con_start(struct tty_struct *tty)
  2472. {
  2473. int console_num;
  2474. if (!tty)
  2475. return;
  2476. console_num = MINOR(tty->device) - (tty->driver.minor_start);
  2477. if (!vc_cons_allocated(console_num))
  2478. return;
  2479. clr_vc_kbd_led(kbd_table + console_num, VC_SCROLLOCK);
  2480. set_leds();
  2481. }
  2483. /*
  2484.  * we can race here against con_close, so we grab the bkl
  2485.  * and check the pointer before calling set_cursor
  2486.  */
  2487. static void con_flush_chars(struct tty_struct *tty)
  2488. {
  2489. struct vt_struct *vt;
  2491. if (in_interrupt()) /* from flush_to_ldisc */
  2492. return;
  2494. #if 0
  2495. pm_access(pm_con);
  2496. #endif
  2497. lock_kernel();
  2498. acquire_console_sem();
  2499. vt = (struct vt_struct *)tty->driver_data;
  2500. if (vt)
  2501. set_cursor(vt->vc_num);
  2502. release_console_sem();
  2503. unlock_kernel();
  2504. }
  2506. /*
  2507.  * Allocate the console screen memory.
  2508.  */
  2509. static int con_open(struct tty_struct *tty, struct file * filp)
  2510. {
  2511. unsigned int currcons;
  2512. int i;
  2514. currcons = MINOR(tty->device) - tty->driver.minor_start;
  2516. i = vc_allocate(currcons);
  2517. if (i)
  2518. return i;
  2520. vt_cons[currcons]->vc_num = currcons;
  2521. tty->driver_data = vt_cons[currcons];
  2523. if (!tty->winsize.ws_row && !tty->winsize.ws_col) {
  2524. tty->winsize.ws_row = video_num_lines;
  2525. tty->winsize.ws_col = video_num_columns;
  2526. }
  2527. if (tty->count == 1)
  2528. vcs_make_devfs (currcons, 0);
  2529. return 0;
  2530. }
  2532. static void con_close(struct tty_struct *tty, struct file * filp)
  2533. {
  2534. if (!tty)
  2535. return;
  2536. if (tty->count != 1) return;
  2537. vcs_make_devfs (MINOR (tty->device) - tty->driver.minor_start, 1);
  2538. tty->driver_data = 0;
  2539. }
  2541. static void vc_init(unsigned int currcons, unsigned int rows, unsigned int cols, int do_clear)
  2542. {
  2543. int j, k ;
  2545. video_num_columns = cols;
  2546. video_num_lines = rows;
  2547. video_size_row = cols<<1;
  2548. screenbuf_size = video_num_lines * video_size_row;
  2550. set_origin(currcons);
  2551. pos = origin;
  2552. reset_vc(currcons);
  2553. for (j=k=0; j<16; j++) {
  2554. vc_cons[currcons].d->vc_palette[k++] = default_red[j] ;
  2555. vc_cons[currcons].d->vc_palette[k++] = default_grn[j] ;
  2556. vc_cons[currcons].d->vc_palette[k++] = default_blu[j] ;
  2557. }
  2558. def_color       = 0x07;   /* white */
  2559. ulcolor = 0x0f;   /* bold white */
  2560. halfcolor       = 0x08;   /* grey */
  2561. init_waitqueue_head(&vt_cons[currcons]->paste_wait);
  2562. reset_terminal(currcons, do_clear);
  2563. }
  2565. /*
  2566.  * This routine initializes console interrupts, and does nothing
  2567.  * else. If you want the screen to clear, call tty_write with
  2568.  * the appropriate escape-sequence.
  2569.  */
  2571. struct tty_driver console_driver;
  2572. static int console_refcount;
  2574. void __init con_init(void)
  2575. {
  2576. const char *display_desc = NULL;
  2577. unsigned int currcons = 0;
  2579. if (conswitchp)
  2580. display_desc = conswitchp->con_startup();
  2581. if (!display_desc) {
  2582. fg_console = 0;
  2583. return;
  2584. }
  2586. memset(&console_driver, 0, sizeof(struct tty_driver));
  2587. console_driver.magic = TTY_DRIVER_MAGIC;
  2588. console_driver.name = "vc/%d";
  2589. console_driver.name_base = 1;
  2590. console_driver.major = TTY_MAJOR;
  2591. console_driver.minor_start = 1;
  2592. console_driver.num = MAX_NR_CONSOLES;
  2593. console_driver.type = TTY_DRIVER_TYPE_CONSOLE;
  2594. console_driver.init_termios = tty_std_termios;
  2595. console_driver.flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS;
  2596. /* Tell tty_register_driver() to skip consoles because they are
  2597.  * registered before kmalloc() is ready. We'll patch them in later.
  2598.  * See comments at console_init(); see also con_init_devfs().
  2599.  */
  2600. console_driver.flags |= TTY_DRIVER_NO_DEVFS;
  2601. console_driver.refcount = &console_refcount;
  2602. console_driver.table = console_table;
  2603. console_driver.termios = console_termios;
  2604. console_driver.termios_locked = console_termios_locked;
  2606. console_driver.open = con_open;
  2607. console_driver.close = con_close;
  2608. console_driver.write = con_write;
  2609. console_driver.write_room = con_write_room;
  2610. console_driver.put_char = con_put_char;
  2611. console_driver.flush_chars = con_flush_chars;
  2612. console_driver.chars_in_buffer = con_chars_in_buffer;
  2613. console_driver.ioctl = vt_ioctl;
  2614. console_driver.stop = con_stop;
  2615. console_driver.start = con_start;
  2616. console_driver.throttle = con_throttle;
  2617. console_driver.unthrottle = con_unthrottle;
  2619. if (tty_register_driver(&console_driver))
  2620. panic("Couldn't register console drivern");
  2622. #ifdef CONFIG_CONSOLE_PM // bushi
  2623. init_timer(&console_timer);
  2624. console_timer.function = blank_screen;
  2625. if (blankinterval) {
  2626. mod_timer(&console_timer, jiffies + blankinterval);
  2627. }
  2628. #endif
  2630. /*
  2631.  * kmalloc is not running yet - we use the bootmem allocator.
  2632.  */
  2633. for (currcons = 0; currcons < MIN_NR_CONSOLES; currcons++) {
  2634. vc_cons[currcons].d = (struct vc_data *)
  2635. alloc_bootmem(sizeof(struct vc_data));
  2636. vt_cons[currcons] = (struct vt_struct *)
  2637. alloc_bootmem(sizeof(struct vt_struct));
  2638. visual_init(currcons, 1);
  2639. screenbuf = (unsigned short *) alloc_bootmem(screenbuf_size);
  2640. kmalloced = 0;
  2641. vc_init(currcons, video_num_lines, video_num_columns, 
  2642. currcons || !sw->con_save_screen);
  2643. }
  2644. currcons = fg_console = 0;
  2645. master_display_fg = vc_cons[currcons].d;
  2646. set_origin(currcons);
  2647. save_screen(currcons);
  2648. gotoxy(currcons,x,y);
  2649. csi_J(currcons, 0);
  2650. update_screen(fg_console);
  2651. printk("Console: %s %s %dx%d",
  2652. can_do_color ? "colour" : "mono",
  2653. display_desc, video_num_columns, video_num_lines);
  2654. printable = 1;
  2655. printk("n");
  2657. #ifdef CONFIG_VT_CONSOLE
  2658. register_console(&vt_console_driver);
  2659. #endif
  2660. }
  2662. #ifndef VT_SINGLE_DRIVER
  2664. static void clear_buffer_attributes(int currcons)
  2665. {
  2666. unsigned short *p = (unsigned short *) origin;
  2667. int count = screenbuf_size/2;
  2668. int mask = hi_font_mask | 0xff;
  2670. for (; count > 0; count--, p++) {
  2671. scr_writew((scr_readw(p)&mask) | (video_erase_char&~mask), p);
  2672. }
  2673. }
  2675. /*
  2676.  * If we support more console drivers, this function is used
  2677.  * when a driver wants to take over some existing consoles
  2678.  * and become default driver for newly opened ones.
  2679.  */
  2681. void take_over_console(const struct consw *csw, int first, int last, int deflt)
  2682. {
  2683. int i, j = -1;
  2684. const char *desc;
  2686. desc = csw->con_startup();
  2687. if (!desc) return;
  2688. if (deflt)
  2689. conswitchp = csw;
  2691. for (i = first; i <= last; i++) {
  2692. int old_was_color;
  2693. int currcons = i;
  2695. con_driver_map[i] = csw;
  2697. if (!vc_cons[i].d || !vc_cons[i].d->vc_sw)
  2698. continue;
  2700. j = i;
  2701. if (IS_VISIBLE)
  2702. save_screen(i);
  2703. old_was_color = vc_cons[i].d->vc_can_do_color;
  2704. vc_cons[i].d->vc_sw->con_deinit(vc_cons[i].d);
  2705. visual_init(i, 0);
  2706. update_attr(i);
  2708. /* If the console changed between mono <-> color, then
  2709.  * the attributes in the screenbuf will be wrong.  The
  2710.  * following resets all attributes to something sane.
  2711.  */
  2712. if (old_was_color != vc_cons[i].d->vc_can_do_color)
  2713. clear_buffer_attributes(i);
  2715. if (IS_VISIBLE)
  2716. update_screen(i);
  2717. }
  2718. printk("Console: switching ");
  2719. if (!deflt)
  2720. printk("consoles %d-%d ", first+1, last+1);
  2721. if (j >= 0)
  2722. printk("to %s %s %dx%dn",
  2723.        vc_cons[j].d->vc_can_do_color ? "colour" : "mono",
  2724.        desc, vc_cons[j].d->vc_cols, vc_cons[j].d->vc_rows);
  2725. else
  2726. printk("to %sn", desc);
  2727. }
  2729. void give_up_console(const struct consw *csw)
  2730. {
  2731. int i;
  2733. for(i = 0; i < MAX_NR_CONSOLES; i++)
  2734. if (con_driver_map[i] == csw)
  2735. con_driver_map[i] = NULL;
  2736. }
  2738. #endif
  2741. #ifdef CONFIG_CONSOLE_PM // bushi
  2742. /*
  2743.  * Screen blanking
  2744.  */
  2746. static void set_vesa_blanking(unsigned long arg)
  2747. {
  2748. char *argp = (char *)arg + 1;
  2749. unsigned int mode;
  2750. if (get_user(mode, argp) == 0)
  2751. vesa_blank_mode = (mode < 4) ? mode : 0;
  2752. }
  2753. #endif // CONFIG_CONSOLE_PM
  2755. /* We can't register the console with devfs during con_init(), because it
  2756.  * is called before kmalloc() works.  This function is called later to
  2757.  * do the registration.
  2758.  */
  2759. void __init con_init_devfs (void)
  2760. {
  2761. int i;
  2763. for (i = 0; i < console_driver.num; i++)
  2764. tty_register_devfs (&console_driver, DEVFS_FL_AOPEN_NOTIFY,
  2765.     console_driver.minor_start + i);
  2766. }
  2768. #ifdef CONFIG_CONSOLE_PM // bushi
  2769. /*
  2770.  * This is called by a timer handler
  2771.  */
  2772. static void vesa_powerdown(void)
  2773. {
  2774.     struct vc_data *c = vc_cons[fg_console].d;
  2775.     /*
  2776.      *  Power down if currently suspended (1 or 2),
  2777.      *  suspend if currently blanked (0),
  2778.      *  else do nothing (i.e. already powered down (3)).
  2779.      *  Called only if powerdown features are allowed.
  2780.      */
  2781.     switch (vesa_blank_mode) {
  2782. case VESA_NO_BLANKING:
  2783.     c->vc_sw->con_blank(c, VESA_VSYNC_SUSPEND+1);
  2784.     break;
  2785. case VESA_VSYNC_SUSPEND:
  2786. case VESA_HSYNC_SUSPEND:
  2787.     c->vc_sw->con_blank(c, VESA_POWERDOWN+1);
  2788.     break;
  2789.     }
  2790. }
  2792. /*
  2793.  * This is a timer handler
  2794.  */
  2795. static void vesa_powerdown_screen(unsigned long dummy)
  2796. {
  2797. console_timer.function = unblank_screen_t;
  2799. vesa_powerdown();
  2800. }
  2802. static void timer_do_blank_screen(int entering_gfx, int from_timer_handler)
  2803. {
  2804. int currcons = fg_console;
  2805. int i;
  2807. if (console_blanked)
  2808. return;
  2810. /* entering graphics mode? */
  2811. if (entering_gfx) {
  2812. hide_cursor(currcons);
  2813. save_screen(currcons);
  2814. sw->con_blank(vc_cons[currcons].d, -1);
  2815. console_blanked = fg_console + 1;
  2816. set_origin(currcons);
  2817. return;
  2818. }
  2820. /* don't blank graphics */
  2821. if (vcmode != KD_TEXT) {
  2822. console_blanked = fg_console + 1;
  2823. return;
  2824. }
  2826. hide_cursor(currcons);
  2827. if (!from_timer_handler)
  2828. del_timer_sync(&console_timer);
  2829. if (vesa_off_interval) {
  2830. console_timer.function = vesa_powerdown_screen;
  2831. mod_timer(&console_timer, jiffies + vesa_off_interval);
  2832. } else {
  2833. if (!from_timer_handler)
  2834. del_timer_sync(&console_timer);
  2835. console_timer.function = unblank_screen_t;
  2836. }
  2838. save_screen(currcons);
  2839. /* In case we need to reset origin, blanking hook returns 1 */
  2840. i = sw->con_blank(vc_cons[currcons].d, 1);
  2841. console_blanked = fg_console + 1;
  2842. if (i)
  2843. set_origin(currcons);
  2845. if (console_blank_hook && console_blank_hook(1))
  2846. return;
  2847. if (vesa_blank_mode)
  2848. sw->con_blank(vc_cons[currcons].d, vesa_blank_mode + 1);
  2849. }
  2851. void do_blank_screen(int entering_gfx)
  2852. {
  2853. timer_do_blank_screen(entering_gfx, 0);
  2854. }
  2856. /*
  2857.  * This is a timer handler
  2858.  */
  2859. static void unblank_screen_t(unsigned long dummy)
  2860. {
  2861. unblank_screen();
  2862. }
  2864. /*
  2865.  * Called by timer as well as from vt_console_driver
  2866.  */
  2867. void unblank_screen(void)
  2868. {
  2869. int currcons;
  2871. if (!console_blanked)
  2872. return;
  2873. if (!vc_cons_allocated(fg_console)) {
  2874. /* impossible */
  2875. printk("unblank_screen: tty %d not allocated ??n", fg_console+1);
  2876. return;
  2877. }
  2878. currcons = fg_console;
  2879. if (vcmode != KD_TEXT)
  2880. return; /* but leave console_blanked != 0 */
  2882. console_timer.function = blank_screen;
  2883. if (blankinterval) {
  2884. mod_timer(&console_timer, jiffies + blankinterval);
  2885. }
  2887. console_blanked = 0;
  2888. if (console_blank_hook)
  2889. console_blank_hook(0);
  2890. set_palette(currcons);
  2891. if (sw->con_blank(vc_cons[currcons].d, 0))
  2892. /* Low-level driver cannot restore -> do it ourselves */
  2893. update_screen(fg_console);
  2894. set_cursor(fg_console);
  2895. }
  2897. /*
  2898.  * This is both a user-level callable and a timer handler
  2899.  */
  2900. static void blank_screen(unsigned long dummy)
  2901. {
  2902. timer_do_blank_screen(0, 1);
  2903. }
  2905. void poke_blanked_console(void)
  2906. {
  2907. del_timer(&console_timer);
  2908. if (!vt_cons[fg_console] || vt_cons[fg_console]->vc_mode == KD_GRAPHICS)
  2909. return;
  2910. if (console_blanked) {
  2911. console_timer.function = unblank_screen_t;
  2912. mod_timer(&console_timer, jiffies); /* Now */
  2913. } else if (blankinterval) {
  2914. mod_timer(&console_timer, jiffies + blankinterval);
  2915. }
  2916. }
  2917. #endif // CONFIG_CONSOLE_PM - bushi
  2919. /*
  2920.  * Palettes
  2921.  */
  2923. void set_palette(int currcons)
  2924. {
  2925. if (vcmode != KD_GRAPHICS)
  2926. sw->con_set_palette(vc_cons[currcons].d, color_table);
  2927. }
  2929. static int set_get_cmap(unsigned char *arg, int set)
  2930. {
  2931.     int i, j, k;
  2933.     for (i = 0; i < 16; i++)
  2934. if (set) {
  2935.     get_user(default_red[i], arg++);
  2936.     get_user(default_grn[i], arg++);
  2937.     get_user(default_blu[i], arg++);
  2938. } else {
  2939.     put_user(default_red[i], arg++);
  2940.     put_user(default_grn[i], arg++);
  2941.     put_user(default_blu[i], arg++);
  2942. }
  2943.     if (set) {
  2944. for (i = 0; i < MAX_NR_CONSOLES; i++)
  2945.     if (vc_cons_allocated(i)) {
  2946. for (j = k = 0; j < 16; j++) {
  2947.     vc_cons[i].d->vc_palette[k++] = default_red[j];
  2948.     vc_cons[i].d->vc_palette[k++] = default_grn[j];
  2949.     vc_cons[i].d->vc_palette[k++] = default_blu[j];
  2950. }
  2951. set_palette(i);
  2952.     }
  2953.     }
  2954.     return 0;
  2955. }
  2957. /*
  2958.  * Load palette into the DAC registers. arg points to a colour
  2959.  * map, 3 bytes per colour, 16 colours, range from 0 to 255.
  2960.  */
  2962. int con_set_cmap(unsigned char *arg)
  2963. {
  2964. return set_get_cmap (arg,1);
  2965. }
  2967. int con_get_cmap(unsigned char *arg)
  2968. {
  2969. return set_get_cmap (arg,0);
  2970. }
  2972. void reset_palette(int currcons)
  2973. {
  2974. int j, k;
  2975. for (j=k=0; j<16; j++) {
  2976. palette[k++] = default_red[j];
  2977. palette[k++] = default_grn[j];
  2978. palette[k++] = default_blu[j];
  2979. }
  2980. set_palette(currcons);
  2981. }
  2983. /*
  2984.  *  Font switching
  2985.  *
  2986.  *  Currently we only support fonts up to 32 pixels wide, at a maximum height
  2987.  *  of 32 pixels. Userspace fontdata is stored with 32 bytes (shorts/ints, 
  2988.  *  depending on width) reserved for each character which is kinda wasty, but 
  2989.  *  this is done in order to maintain compatibility with the EGA/VGA fonts. It 
  2990.  *  is upto the actual low-level console-driver convert data into its favorite
  2991.  *  format (maybe we should add a `fontoffset' field to the `display'
  2992.  *  structure so we wont have to convert the fontdata all the time.
  2993.  *  /Jes
  2994.  */
  2996. #define max_font_size 65536
  2998. int con_font_op(int currcons, struct console_font_op *op)
  2999. {
  3000. int rc = -EINVAL;
  3001. int size = max_font_size, set;
  3002. u8 *temp = NULL;
  3003. struct console_font_op old_op;
  3005. if (vt_cons[currcons]->vc_mode != KD_TEXT)
  3006. goto quit;
  3007. memcpy(&old_op, op, sizeof(old_op));
  3008. if (op->op == KD_FONT_OP_SET) {
  3009. if (!op->data)
  3010. return -EINVAL;
  3011. if (op->charcount > 512)
  3012. goto quit;
  3013. if (!op->height) { /* Need to guess font height [compat] */
  3014. int h, i;
  3015. u8 *charmap = op->data, tmp;
  3017. /* If from KDFONTOP ioctl, don't allow things which can be done in userland,
  3018.    so that we can get rid of this soon */
  3019. if (!(op->flags & KD_FONT_FLAG_OLD))
  3020. goto quit;
  3021. rc = -EFAULT;
  3022. for (h = 32; h > 0; h--)
  3023. for (i = 0; i < op->charcount; i++) {
  3024. if (get_user(tmp, &charmap[32*i+h-1]))
  3025. goto quit;
  3026. if (tmp)
  3027. goto nonzero;
  3028. }
  3029. rc = -EINVAL;
  3030. goto quit;
  3031. nonzero:
  3032. rc = -EINVAL;
  3033. op->height = h;
  3034. }
  3035. if (op->width > 32 || op->height > 32)
  3036. goto quit;
  3037. size = (op->width+7)/8 * 32 * op->charcount;
  3038. if (size > max_font_size)
  3039. return -ENOSPC;
  3040. set = 1;
  3041. } else if (op->op == KD_FONT_OP_GET)
  3042. set = 0;
  3043. else
  3044. return sw->con_font_op(vc_cons[currcons].d, op);
  3045. if (op->data) {
  3046. temp = kmalloc(size, GFP_KERNEL);
  3047. if (!temp)
  3048. return -ENOMEM;
  3049. if (set && copy_from_user(temp, op->data, size)) {
  3050. rc = -EFAULT;
  3051. goto quit;
  3052. }
  3053. op->data = temp;
  3054. }
  3056. acquire_console_sem();
  3057. rc = sw->con_font_op(vc_cons[currcons].d, op);
  3058. release_console_sem();
  3060. op->data = old_op.data;
  3061. if (!rc && !set) {
  3062. int c = (op->width+7)/8 * 32 * op->charcount;
  3064. if (op->data && op->charcount > old_op.charcount)
  3065. rc = -ENOSPC;
  3066. if (!(op->flags & KD_FONT_FLAG_OLD)) {
  3067. if (op->width > old_op.width ||
  3068.     op->height > old_op.height)
  3069. rc = -ENOSPC;
  3070. } else {
  3071. if (op->width != 8)
  3072. rc = -EIO;
  3073. else if ((old_op.height && op->height > old_op.height) ||
  3074.  op->height > 32)
  3075. rc = -ENOSPC;
  3076. }
  3077. if (!rc && op->data && copy_to_user(op->data, temp, c))
  3078. rc = -EFAULT;
  3079. }
  3080. quit: if (temp)
  3081. kfree(temp);
  3082. return rc;
  3083. }
  3085. /*
  3086.  * Interface exported to selection and vcs.
  3087.  */
  3089. /* used by selection */
  3090. u16 screen_glyph(int currcons, int offset)
  3091. {
  3092. u16 w = scr_readw(screenpos(currcons, offset, 1));
  3093. u16 c = w & 0xff;
  3095. if (w & hi_font_mask)
  3096. c |= 0x100;
  3097. return c;
  3098. }
  3100. /* used by vcs - note the word offset */
  3101. unsigned short *screen_pos(int currcons, int w_offset, int viewed)
  3102. {
  3103. return screenpos(currcons, 2 * w_offset, viewed);
  3104. }
  3106. void getconsxy(int currcons, char *p)
  3107. {
  3108. p[0] = x;
  3109. p[1] = y;
  3110. }
  3112. void putconsxy(int currcons, char *p)
  3113. {
  3114. gotoxy(currcons, p[0], p[1]);
  3115. set_cursor(currcons);
  3116. }
  3118. u16 vcs_scr_readw(int currcons, const u16 *org)
  3119. {
  3120. #ifdef CONFIG_CONSOLE_PM // bushi
  3121. if ((unsigned long)org == pos && softcursor_original != -1)
  3122. return softcursor_original;
  3123. #endif
  3124. return scr_readw(org);
  3125. }
  3127. void vcs_scr_writew(int currcons, u16 val, u16 *org)
  3128. {
  3129. scr_writew(val, org);
  3130. #ifdef CONFIG_CONSOLE_PM // bushi
  3131. if ((unsigned long)org == pos) {
  3132. softcursor_original = -1;
  3133. add_softcursor(currcons);
  3134. }
  3135. #endif
  3136. }
  3138. #ifdef CONFIG_CONSOLE_PM // bushi
  3139. static int pm_con_request(struct pm_dev *dev, pm_request_t rqst, void *data)
  3140. {
  3141. switch (rqst)
  3142. {
  3143. case PM_RESUME:
  3144. unblank_screen();
  3145. break;
  3146. case PM_SUSPEND:
  3147. do_blank_screen(0);
  3148. break;
  3149. }
  3150. return 0;
  3151. }
  3152. #endif
  3154. /*
  3155.  * Visible symbols for modules
  3156.  */
  3158. EXPORT_SYMBOL(color_table);
  3159. EXPORT_SYMBOL(default_red);
  3160. EXPORT_SYMBOL(default_grn);
  3161. EXPORT_SYMBOL(default_blu);
  3162. EXPORT_SYMBOL(video_font_height);
  3163. EXPORT_SYMBOL(video_scan_lines);
  3164. EXPORT_SYMBOL(vc_resize);
  3165. EXPORT_SYMBOL(fg_console);
  3166. #ifdef CONFIG_CONSOLE_PM // bushi
  3167. EXPORT_SYMBOL(console_blank_hook);
  3168. #endif
  3169. #ifdef CONFIG_VT
  3170. EXPORT_SYMBOL(vt_cons);
  3171. #endif
  3172. #ifndef VT_SINGLE_DRIVER
  3173. EXPORT_SYMBOL(take_over_console);
  3174. EXPORT_SYMBOL(give_up_console);
  3175. #endif