1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Copyright (C) 1991, 1992 Linus Torvalds 4 */ 5 6/* 7 * Hopefully this will be a rather complete VT102 implementation. 8 * 9 * Beeping thanks to John T Kohl. 10 * 11 * Virtual Consoles, Screen Blanking, Screen Dumping, Color, Graphics 12 * Chars, and VT100 enhancements by Peter MacDonald. 13 * 14 * Copy and paste function by Andrew Haylett, 15 * some enhancements by Alessandro Rubini. 16 * 17 * Code to check for different video-cards mostly by Galen Hunt, 18 * <g-hunt@ee.utah.edu> 19 * 20 * Rudimentary ISO 10646/Unicode/UTF-8 character set support by 21 * Markus Kuhn, <mskuhn@immd4.informatik.uni-erlangen.de>. 22 * 23 * Dynamic allocation of consoles, aeb@cwi.nl, May 1994 24 * Resizing of consoles, aeb, 940926 25 * 26 * Code for xterm like mouse click reporting by Peter Orbaek 20-Jul-94 27 * <poe@daimi.aau.dk> 28 * 29 * User-defined bell sound, new setterm control sequences and printk 30 * redirection by Martin Mares <mj@k332.feld.cvut.cz> 19-Nov-95 31 * 32 * APM screenblank bug fixed Takashi Manabe <manabe@roy.dsl.tutics.tut.jp> 33 * 34 * Merge with the abstract console driver by Geert Uytterhoeven 35 * <geert@linux-m68k.org>, Jan 1997. 36 * 37 * Original m68k console driver modifications by 38 * 39 * - Arno Griffioen <arno@usn.nl> 40 * - David Carter <carter@cs.bris.ac.uk> 41 * 42 * The abstract console driver provides a generic interface for a text 43 * console. It supports VGA text mode, frame buffer based graphical consoles 44 * and special graphics processors that are only accessible through some 45 * registers (e.g. a TMS340x0 GSP). 46 * 47 * The interface to the hardware is specified using a special structure 48 * (struct consw) which contains function pointers to console operations 49 * (see <linux/console.h> for more information). 50 * 51 * Support for changeable cursor shape 52 * by Pavel Machek <pavel@atrey.karlin.mff.cuni.cz>, August 1997 53 * 54 * Ported to i386 and con_scrolldelta fixed 55 * by Emmanuel Marty <core@ggi-project.org>, April 1998 56 * 57 * Resurrected character buffers in videoram plus lots of other trickery 58 * by Martin Mares <mj@atrey.karlin.mff.cuni.cz>, July 1998 59 * 60 * Removed old-style timers, introduced console_timer, made timer 61 * deletion SMP-safe. 17Jun00, Andrew Morton 62 * 63 * Removed console_lock, enabled interrupts across all console operations 64 * 13 March 2001, Andrew Morton 65 * 66 * Fixed UTF-8 mode so alternate charset modes always work according 67 * to control sequences interpreted in do_con_trol function 68 * preserving backward VT100 semigraphics compatibility, 69 * malformed UTF sequences represented as sequences of replacement glyphs, 70 * original codes or '?' as a last resort if replacement glyph is undefined 71 * by Adam Tla/lka <atlka@pg.gda.pl>, Aug 2006 72 */ 73 74#include <linux/module.h> 75#include <linux/types.h> 76#include <linux/sched/signal.h> 77#include <linux/tty.h> 78#include <linux/tty_flip.h> 79#include <linux/kernel.h> 80#include <linux/string.h> 81#include <linux/errno.h> 82#include <linux/kd.h> 83#include <linux/slab.h> 84#include <linux/vmalloc.h> 85#include <linux/major.h> 86#include <linux/mm.h> 87#include <linux/console.h> 88#include <linux/init.h> 89#include <linux/mutex.h> 90#include <linux/vt_kern.h> 91#include <linux/selection.h> 92#include <linux/tiocl.h> 93#include <linux/kbd_kern.h> 94#include <linux/consolemap.h> 95#include <linux/timer.h> 96#include <linux/interrupt.h> 97#include <linux/workqueue.h> 98#include <linux/pm.h> 99#include <linux/font.h> 100#include <linux/bitops.h> 101#include <linux/notifier.h> 102#include <linux/device.h> 103#include <linux/io.h> 104#include <linux/uaccess.h> 105#include <linux/kdb.h> 106#include <linux/ctype.h> 107#include <linux/bsearch.h> 108#include <linux/gcd.h> 109 110#define MAX_NR_CON_DRIVER 16 111 112#define CON_DRIVER_FLAG_MODULE 1 113#define CON_DRIVER_FLAG_INIT 2 114#define CON_DRIVER_FLAG_ATTR 4 115#define CON_DRIVER_FLAG_ZOMBIE 8 116 117struct con_driver { 118 const struct consw *con; 119 const char *desc; 120 struct device *dev; 121 int node; 122 int first; 123 int last; 124 int flag; 125}; 126 127static struct con_driver registered_con_driver[MAX_NR_CON_DRIVER]; 128const struct consw *conswitchp; 129 130/* 131 * Here is the default bell parameters: 750HZ, 1/8th of a second 132 */ 133#define DEFAULT_BELL_PITCH 750 134#define DEFAULT_BELL_DURATION (HZ/8) 135#define DEFAULT_CURSOR_BLINK_MS 200 136 137struct vc vc_cons [MAX_NR_CONSOLES]; 138 139#ifndef VT_SINGLE_DRIVER 140static const struct consw *con_driver_map[MAX_NR_CONSOLES]; 141#endif 142 143static int con_open(struct tty_struct *, struct file *); 144static void vc_init(struct vc_data *vc, unsigned int rows, 145 unsigned int cols, int do_clear); 146static void gotoxy(struct vc_data *vc, int new_x, int new_y); 147static void save_cur(struct vc_data *vc); 148static void reset_terminal(struct vc_data *vc, int do_clear); 149static void con_flush_chars(struct tty_struct *tty); 150static int set_vesa_blanking(char __user *p); 151static void set_cursor(struct vc_data *vc); 152static void hide_cursor(struct vc_data *vc); 153static void console_callback(struct work_struct *ignored); 154static void con_driver_unregister_callback(struct work_struct *ignored); 155static void blank_screen_t(struct timer_list *unused); 156static void set_palette(struct vc_data *vc); 157 158#define vt_get_kmsg_redirect() vt_kmsg_redirect(-1) 159 160static int printable; /* Is console ready for printing? */ 161int default_utf8 = true; 162module_param(default_utf8, int, S_IRUGO | S_IWUSR); 163int global_cursor_default = -1; 164module_param(global_cursor_default, int, S_IRUGO | S_IWUSR); 165 166static int cur_default = CUR_UNDERLINE; 167module_param(cur_default, int, S_IRUGO | S_IWUSR); 168 169/* 170 * ignore_poke: don't unblank the screen when things are typed. This is 171 * mainly for the privacy of braille terminal users. 172 */ 173static int ignore_poke; 174 175int do_poke_blanked_console; 176int console_blanked; 177 178static int vesa_blank_mode; /* 0:none 1:suspendV 2:suspendH 3:powerdown */ 179static int vesa_off_interval; 180static int blankinterval; 181core_param(consoleblank, blankinterval, int, 0444); 182 183static DECLARE_WORK(console_work, console_callback); 184static DECLARE_WORK(con_driver_unregister_work, con_driver_unregister_callback); 185 186/* 187 * fg_console is the current virtual console, 188 * last_console is the last used one, 189 * want_console is the console we want to switch to, 190 * saved_* variants are for save/restore around kernel debugger enter/leave 191 */ 192int fg_console; 193int last_console; 194int want_console = -1; 195static int saved_fg_console; 196static int saved_last_console; 197static int saved_want_console; 198static int saved_vc_mode; 199static int saved_console_blanked; 200 201/* 202 * For each existing display, we have a pointer to console currently visible 203 * on that display, allowing consoles other than fg_console to be refreshed 204 * appropriately. Unless the low-level driver supplies its own display_fg 205 * variable, we use this one for the "master display". 206 */ 207static struct vc_data *master_display_fg; 208 209/* 210 * Unfortunately, we need to delay tty echo when we're currently writing to the 211 * console since the code is (and always was) not re-entrant, so we schedule 212 * all flip requests to process context with schedule-task() and run it from 213 * console_callback(). 214 */ 215 216/* 217 * For the same reason, we defer scrollback to the console callback. 218 */ 219static int scrollback_delta; 220 221/* 222 * Hook so that the power management routines can (un)blank 223 * the console on our behalf. 224 */ 225int (*console_blank_hook)(int); 226 227static DEFINE_TIMER(console_timer, blank_screen_t); 228static int blank_state; 229static int blank_timer_expired; 230enum { 231 blank_off = 0, 232 blank_normal_wait, 233 blank_vesa_wait, 234}; 235 236/* 237 * /sys/class/tty/tty0/ 238 * 239 * the attribute 'active' contains the name of the current vc 240 * console and it supports poll() to detect vc switches 241 */ 242static struct device *tty0dev; 243 244/* 245 * Notifier list for console events. 246 */ 247static ATOMIC_NOTIFIER_HEAD(vt_notifier_list); 248 249int register_vt_notifier(struct notifier_block *nb) 250{ 251 return atomic_notifier_chain_register(&vt_notifier_list, nb); 252} 253EXPORT_SYMBOL_GPL(register_vt_notifier); 254 255int unregister_vt_notifier(struct notifier_block *nb) 256{ 257 return atomic_notifier_chain_unregister(&vt_notifier_list, nb); 258} 259EXPORT_SYMBOL_GPL(unregister_vt_notifier); 260 261static void notify_write(struct vc_data *vc, unsigned int unicode) 262{ 263 struct vt_notifier_param param = { .vc = vc, .c = unicode }; 264 atomic_notifier_call_chain(&vt_notifier_list, VT_WRITE, ¶m); 265} 266 267static void notify_update(struct vc_data *vc) 268{ 269 struct vt_notifier_param param = { .vc = vc }; 270 atomic_notifier_call_chain(&vt_notifier_list, VT_UPDATE, ¶m); 271} 272/* 273 * Low-Level Functions 274 */ 275 276static inline bool con_is_fg(const struct vc_data *vc) 277{ 278 return vc->vc_num == fg_console; 279} 280 281static inline bool con_should_update(const struct vc_data *vc) 282{ 283 return con_is_visible(vc) && !console_blanked; 284} 285 286static inline unsigned short *screenpos(const struct vc_data *vc, int offset, 287 bool viewed) 288{ 289 unsigned short *p; 290 291 if (!viewed) 292 p = (unsigned short *)(vc->vc_origin + offset); 293 else if (!vc->vc_sw->con_screen_pos) 294 p = (unsigned short *)(vc->vc_visible_origin + offset); 295 else 296 p = vc->vc_sw->con_screen_pos(vc, offset); 297 return p; 298} 299 300/* Called from the keyboard irq path.. */ 301static inline void scrolldelta(int lines) 302{ 303 /* FIXME */ 304 /* scrolldelta needs some kind of consistency lock, but the BKL was 305 and still is not protecting versus the scheduled back end */ 306 scrollback_delta += lines; 307 schedule_console_callback(); 308} 309 310void schedule_console_callback(void) 311{ 312 schedule_work(&console_work); 313} 314 315/* 316 * Code to manage unicode-based screen buffers 317 */ 318 319#ifdef NO_VC_UNI_SCREEN 320/* this disables and optimizes related code away at compile time */ 321#define get_vc_uniscr(vc) NULL 322#else 323#define get_vc_uniscr(vc) vc->vc_uni_screen 324#endif 325 326#define VC_UNI_SCREEN_DEBUG 0 327 328typedef uint32_t char32_t; 329 330/* 331 * Our screen buffer is preceded by an array of line pointers so that 332 * scrolling only implies some pointer shuffling. 333 */ 334struct uni_screen { 335 char32_t *lines[0]; 336}; 337 338static struct uni_screen *vc_uniscr_alloc(unsigned int cols, unsigned int rows) 339{ 340 struct uni_screen *uniscr; 341 void *p; 342 unsigned int memsize, i; 343 344 /* allocate everything in one go */ 345 memsize = cols * rows * sizeof(char32_t); 346 memsize += rows * sizeof(char32_t *); 347 p = vzalloc(memsize); 348 if (!p) 349 return NULL; 350 351 /* initial line pointers */ 352 uniscr = p; 353 p = uniscr->lines + rows; 354 for (i = 0; i < rows; i++) { 355 uniscr->lines[i] = p; 356 p += cols * sizeof(char32_t); 357 } 358 return uniscr; 359} 360 361static void vc_uniscr_free(struct uni_screen *uniscr) 362{ 363 vfree(uniscr); 364} 365 366static void vc_uniscr_set(struct vc_data *vc, struct uni_screen *new_uniscr) 367{ 368 vc_uniscr_free(vc->vc_uni_screen); 369 vc->vc_uni_screen = new_uniscr; 370} 371 372static void vc_uniscr_putc(struct vc_data *vc, char32_t uc) 373{ 374 struct uni_screen *uniscr = get_vc_uniscr(vc); 375 376 if (uniscr) 377 uniscr->lines[vc->state.y][vc->state.x] = uc; 378} 379 380static void vc_uniscr_insert(struct vc_data *vc, unsigned int nr) 381{ 382 struct uni_screen *uniscr = get_vc_uniscr(vc); 383 384 if (uniscr) { 385 char32_t *ln = uniscr->lines[vc->state.y]; 386 unsigned int x = vc->state.x, cols = vc->vc_cols; 387 388 memmove(&ln[x + nr], &ln[x], (cols - x - nr) * sizeof(*ln)); 389 memset32(&ln[x], ' ', nr); 390 } 391} 392 393static void vc_uniscr_delete(struct vc_data *vc, unsigned int nr) 394{ 395 struct uni_screen *uniscr = get_vc_uniscr(vc); 396 397 if (uniscr) { 398 char32_t *ln = uniscr->lines[vc->state.y]; 399 unsigned int x = vc->state.x, cols = vc->vc_cols; 400 401 memmove(&ln[x], &ln[x + nr], (cols - x - nr) * sizeof(*ln)); 402 memset32(&ln[cols - nr], ' ', nr); 403 } 404} 405 406static void vc_uniscr_clear_line(struct vc_data *vc, unsigned int x, 407 unsigned int nr) 408{ 409 struct uni_screen *uniscr = get_vc_uniscr(vc); 410 411 if (uniscr) { 412 char32_t *ln = uniscr->lines[vc->state.y]; 413 414 memset32(&ln[x], ' ', nr); 415 } 416} 417 418static void vc_uniscr_clear_lines(struct vc_data *vc, unsigned int y, 419 unsigned int nr) 420{ 421 struct uni_screen *uniscr = get_vc_uniscr(vc); 422 423 if (uniscr) { 424 unsigned int cols = vc->vc_cols; 425 426 while (nr--) 427 memset32(uniscr->lines[y++], ' ', cols); 428 } 429} 430 431static void vc_uniscr_scroll(struct vc_data *vc, unsigned int t, unsigned int b, 432 enum con_scroll dir, unsigned int nr) 433{ 434 struct uni_screen *uniscr = get_vc_uniscr(vc); 435 436 if (uniscr) { 437 unsigned int i, j, k, sz, d, clear; 438 439 sz = b - t; 440 clear = b - nr; 441 d = nr; 442 if (dir == SM_DOWN) { 443 clear = t; 444 d = sz - nr; 445 } 446 for (i = 0; i < gcd(d, sz); i++) { 447 char32_t *tmp = uniscr->lines[t + i]; 448 j = i; 449 while (1) { 450 k = j + d; 451 if (k >= sz) 452 k -= sz; 453 if (k == i) 454 break; 455 uniscr->lines[t + j] = uniscr->lines[t + k]; 456 j = k; 457 } 458 uniscr->lines[t + j] = tmp; 459 } 460 vc_uniscr_clear_lines(vc, clear, nr); 461 } 462} 463 464static void vc_uniscr_copy_area(struct uni_screen *dst, 465 unsigned int dst_cols, 466 unsigned int dst_rows, 467 struct uni_screen *src, 468 unsigned int src_cols, 469 unsigned int src_top_row, 470 unsigned int src_bot_row) 471{ 472 unsigned int dst_row = 0; 473 474 if (!dst) 475 return; 476 477 while (src_top_row < src_bot_row) { 478 char32_t *src_line = src->lines[src_top_row]; 479 char32_t *dst_line = dst->lines[dst_row]; 480 481 memcpy(dst_line, src_line, src_cols * sizeof(char32_t)); 482 if (dst_cols - src_cols) 483 memset32(dst_line + src_cols, ' ', dst_cols - src_cols); 484 src_top_row++; 485 dst_row++; 486 } 487 while (dst_row < dst_rows) { 488 char32_t *dst_line = dst->lines[dst_row]; 489 490 memset32(dst_line, ' ', dst_cols); 491 dst_row++; 492 } 493} 494 495/* 496 * Called from vcs_read() to make sure unicode screen retrieval is possible. 497 * This will initialize the unicode screen buffer if not already done. 498 * This returns 0 if OK, or a negative error code otherwise. 499 * In particular, -ENODATA is returned if the console is not in UTF-8 mode. 500 */ 501int vc_uniscr_check(struct vc_data *vc) 502{ 503 struct uni_screen *uniscr; 504 unsigned short *p; 505 int x, y, mask; 506 507 if (__is_defined(NO_VC_UNI_SCREEN)) 508 return -EOPNOTSUPP; 509 510 WARN_CONSOLE_UNLOCKED(); 511 512 if (!vc->vc_utf) 513 return -ENODATA; 514 515 if (vc->vc_uni_screen) 516 return 0; 517 518 uniscr = vc_uniscr_alloc(vc->vc_cols, vc->vc_rows); 519 if (!uniscr) 520 return -ENOMEM; 521 522 /* 523 * Let's populate it initially with (imperfect) reverse translation. 524 * This is the next best thing we can do short of having it enabled 525 * from the start even when no users rely on this functionality. True 526 * unicode content will be available after a complete screen refresh. 527 */ 528 p = (unsigned short *)vc->vc_origin; 529 mask = vc->vc_hi_font_mask | 0xff; 530 for (y = 0; y < vc->vc_rows; y++) { 531 char32_t *line = uniscr->lines[y]; 532 for (x = 0; x < vc->vc_cols; x++) { 533 u16 glyph = scr_readw(p++) & mask; 534 line[x] = inverse_translate(vc, glyph, true); 535 } 536 } 537 538 vc->vc_uni_screen = uniscr; 539 return 0; 540} 541 542/* 543 * Called from vcs_read() to get the unicode data from the screen. 544 * This must be preceded by a successful call to vc_uniscr_check() once 545 * the console lock has been taken. 546 */ 547void vc_uniscr_copy_line(const struct vc_data *vc, void *dest, bool viewed, 548 unsigned int row, unsigned int col, unsigned int nr) 549{ 550 struct uni_screen *uniscr = get_vc_uniscr(vc); 551 int offset = row * vc->vc_size_row + col * 2; 552 unsigned long pos; 553 554 BUG_ON(!uniscr); 555 556 pos = (unsigned long)screenpos(vc, offset, viewed); 557 if (pos >= vc->vc_origin && pos < vc->vc_scr_end) { 558 /* 559 * Desired position falls in the main screen buffer. 560 * However the actual row/col might be different if 561 * scrollback is active. 562 */ 563 row = (pos - vc->vc_origin) / vc->vc_size_row; 564 col = ((pos - vc->vc_origin) % vc->vc_size_row) / 2; 565 memcpy(dest, &uniscr->lines[row][col], nr * sizeof(char32_t)); 566 } else { 567 /* 568 * Scrollback is active. For now let's simply backtranslate 569 * the screen glyphs until the unicode screen buffer does 570 * synchronize with console display drivers for a scrollback 571 * buffer of its own. 572 */ 573 u16 *p = (u16 *)pos; 574 int mask = vc->vc_hi_font_mask | 0xff; 575 char32_t *uni_buf = dest; 576 while (nr--) { 577 u16 glyph = scr_readw(p++) & mask; 578 *uni_buf++ = inverse_translate(vc, glyph, true); 579 } 580 } 581} 582 583/* this is for validation and debugging only */ 584static void vc_uniscr_debug_check(struct vc_data *vc) 585{ 586 struct uni_screen *uniscr = get_vc_uniscr(vc); 587 unsigned short *p; 588 int x, y, mask; 589 590 if (!VC_UNI_SCREEN_DEBUG || !uniscr) 591 return; 592 593 WARN_CONSOLE_UNLOCKED(); 594 595 /* 596 * Make sure our unicode screen translates into the same glyphs 597 * as the actual screen. This is brutal indeed. 598 */ 599 p = (unsigned short *)vc->vc_origin; 600 mask = vc->vc_hi_font_mask | 0xff; 601 for (y = 0; y < vc->vc_rows; y++) { 602 char32_t *line = uniscr->lines[y]; 603 for (x = 0; x < vc->vc_cols; x++) { 604 u16 glyph = scr_readw(p++) & mask; 605 char32_t uc = line[x]; 606 int tc = conv_uni_to_pc(vc, uc); 607 if (tc == -4) 608 tc = conv_uni_to_pc(vc, 0xfffd); 609 if (tc == -4) 610 tc = conv_uni_to_pc(vc, '?'); 611 if (tc != glyph) 612 pr_err_ratelimited( 613 "%s: mismatch at %d,%d: glyph=%#x tc=%#x\n", 614 __func__, x, y, glyph, tc); 615 } 616 } 617} 618 619 620static void con_scroll(struct vc_data *vc, unsigned int t, unsigned int b, 621 enum con_scroll dir, unsigned int nr) 622{ 623 u16 *clear, *d, *s; 624 625 if (t + nr >= b) 626 nr = b - t - 1; 627 if (b > vc->vc_rows || t >= b || nr < 1) 628 return; 629 vc_uniscr_scroll(vc, t, b, dir, nr); 630 if (con_is_visible(vc) && vc->vc_sw->con_scroll(vc, t, b, dir, nr)) 631 return; 632 633 s = clear = (u16 *)(vc->vc_origin + vc->vc_size_row * t); 634 d = (u16 *)(vc->vc_origin + vc->vc_size_row * (t + nr)); 635 636 if (dir == SM_UP) { 637 clear = s + (b - t - nr) * vc->vc_cols; 638 swap(s, d); 639 } 640 scr_memmovew(d, s, (b - t - nr) * vc->vc_size_row); 641 scr_memsetw(clear, vc->vc_video_erase_char, vc->vc_size_row * nr); 642} 643 644static void do_update_region(struct vc_data *vc, unsigned long start, int count) 645{ 646 unsigned int xx, yy, offset; 647 u16 *p; 648 649 p = (u16 *) start; 650 if (!vc->vc_sw->con_getxy) { 651 offset = (start - vc->vc_origin) / 2; 652 xx = offset % vc->vc_cols; 653 yy = offset / vc->vc_cols; 654 } else { 655 int nxx, nyy; 656 start = vc->vc_sw->con_getxy(vc, start, &nxx, &nyy); 657 xx = nxx; yy = nyy; 658 } 659 for(;;) { 660 u16 attrib = scr_readw(p) & 0xff00; 661 int startx = xx; 662 u16 *q = p; 663 while (xx < vc->vc_cols && count) { 664 if (attrib != (scr_readw(p) & 0xff00)) { 665 if (p > q) 666 vc->vc_sw->con_putcs(vc, q, p-q, yy, startx); 667 startx = xx; 668 q = p; 669 attrib = scr_readw(p) & 0xff00; 670 } 671 p++; 672 xx++; 673 count--; 674 } 675 if (p > q) 676 vc->vc_sw->con_putcs(vc, q, p-q, yy, startx); 677 if (!count) 678 break; 679 xx = 0; 680 yy++; 681 if (vc->vc_sw->con_getxy) { 682 p = (u16 *)start; 683 start = vc->vc_sw->con_getxy(vc, start, NULL, NULL); 684 } 685 } 686} 687 688void update_region(struct vc_data *vc, unsigned long start, int count) 689{ 690 WARN_CONSOLE_UNLOCKED(); 691 692 if (con_should_update(vc)) { 693 hide_cursor(vc); 694 do_update_region(vc, start, count); 695 set_cursor(vc); 696 } 697} 698 699/* Structure of attributes is hardware-dependent */ 700 701static u8 build_attr(struct vc_data *vc, u8 _color, 702 enum vc_intensity _intensity, bool _blink, bool _underline, 703 bool _reverse, bool _italic) 704{ 705 if (vc->vc_sw->con_build_attr) 706 return vc->vc_sw->con_build_attr(vc, _color, _intensity, 707 _blink, _underline, _reverse, _italic); 708 709/* 710 * ++roman: I completely changed the attribute format for monochrome 711 * mode (!can_do_color). The formerly used MDA (monochrome display 712 * adapter) format didn't allow the combination of certain effects. 713 * Now the attribute is just a bit vector: 714 * Bit 0..1: intensity (0..2) 715 * Bit 2 : underline 716 * Bit 3 : reverse 717 * Bit 7 : blink 718 */ 719 { 720 u8 a = _color; 721 if (!vc->vc_can_do_color) 722 return _intensity | 723 (_italic << 1) | 724 (_underline << 2) | 725 (_reverse << 3) | 726 (_blink << 7); 727 if (_italic) 728 a = (a & 0xF0) | vc->vc_itcolor; 729 else if (_underline) 730 a = (a & 0xf0) | vc->vc_ulcolor; 731 else if (_intensity == VCI_HALF_BRIGHT) 732 a = (a & 0xf0) | vc->vc_halfcolor; 733 if (_reverse) 734 a = (a & 0x88) | (((a >> 4) | (a << 4)) & 0x77); 735 if (_blink) 736 a ^= 0x80; 737 if (_intensity == VCI_BOLD) 738 a ^= 0x08; 739 if (vc->vc_hi_font_mask == 0x100) 740 a <<= 1; 741 return a; 742 } 743} 744 745static void update_attr(struct vc_data *vc) 746{ 747 vc->vc_attr = build_attr(vc, vc->state.color, vc->state.intensity, 748 vc->state.blink, vc->state.underline, 749 vc->state.reverse ^ vc->vc_decscnm, vc->state.italic); 750 vc->vc_video_erase_char = ' ' | (build_attr(vc, vc->state.color, 751 VCI_NORMAL, vc->state.blink, false, 752 vc->vc_decscnm, false) << 8); 753} 754 755/* Note: inverting the screen twice should revert to the original state */ 756void invert_screen(struct vc_data *vc, int offset, int count, bool viewed) 757{ 758 unsigned short *p; 759 760 WARN_CONSOLE_UNLOCKED(); 761 762 count /= 2; 763 p = screenpos(vc, offset, viewed); 764 if (vc->vc_sw->con_invert_region) { 765 vc->vc_sw->con_invert_region(vc, p, count); 766 } else { 767 u16 *q = p; 768 int cnt = count; 769 u16 a; 770 771 if (!vc->vc_can_do_color) { 772 while (cnt--) { 773 a = scr_readw(q); 774 a ^= 0x0800; 775 scr_writew(a, q); 776 q++; 777 } 778 } else if (vc->vc_hi_font_mask == 0x100) { 779 while (cnt--) { 780 a = scr_readw(q); 781 a = (a & 0x11ff) | 782 ((a & 0xe000) >> 4) | 783 ((a & 0x0e00) << 4); 784 scr_writew(a, q); 785 q++; 786 } 787 } else { 788 while (cnt--) { 789 a = scr_readw(q); 790 a = (a & 0x88ff) | 791 ((a & 0x7000) >> 4) | 792 ((a & 0x0700) << 4); 793 scr_writew(a, q); 794 q++; 795 } 796 } 797 } 798 799 if (con_should_update(vc)) 800 do_update_region(vc, (unsigned long) p, count); 801 notify_update(vc); 802} 803 804/* used by selection: complement pointer position */ 805void complement_pos(struct vc_data *vc, int offset) 806{ 807 static int old_offset = -1; 808 static unsigned short old; 809 static unsigned short oldx, oldy; 810 811 WARN_CONSOLE_UNLOCKED(); 812 813 if (old_offset != -1 && old_offset >= 0 && 814 old_offset < vc->vc_screenbuf_size) { 815 scr_writew(old, screenpos(vc, old_offset, true)); 816 if (con_should_update(vc)) 817 vc->vc_sw->con_putc(vc, old, oldy, oldx); 818 notify_update(vc); 819 } 820 821 old_offset = offset; 822 823 if (offset != -1 && offset >= 0 && 824 offset < vc->vc_screenbuf_size) { 825 unsigned short new; 826 unsigned short *p; 827 p = screenpos(vc, offset, true); 828 old = scr_readw(p); 829 new = old ^ vc->vc_complement_mask; 830 scr_writew(new, p); 831 if (con_should_update(vc)) { 832 oldx = (offset >> 1) % vc->vc_cols; 833 oldy = (offset >> 1) / vc->vc_cols; 834 vc->vc_sw->con_putc(vc, new, oldy, oldx); 835 } 836 notify_update(vc); 837 } 838} 839 840static void insert_char(struct vc_data *vc, unsigned int nr) 841{ 842 unsigned short *p = (unsigned short *) vc->vc_pos; 843 844 vc_uniscr_insert(vc, nr); 845 scr_memmovew(p + nr, p, (vc->vc_cols - vc->state.x - nr) * 2); 846 scr_memsetw(p, vc->vc_video_erase_char, nr * 2); 847 vc->vc_need_wrap = 0; 848 if (con_should_update(vc)) 849 do_update_region(vc, (unsigned long) p, 850 vc->vc_cols - vc->state.x); 851} 852 853static void delete_char(struct vc_data *vc, unsigned int nr) 854{ 855 unsigned short *p = (unsigned short *) vc->vc_pos; 856 857 vc_uniscr_delete(vc, nr); 858 scr_memmovew(p, p + nr, (vc->vc_cols - vc->state.x - nr) * 2); 859 scr_memsetw(p + vc->vc_cols - vc->state.x - nr, vc->vc_video_erase_char, 860 nr * 2); 861 vc->vc_need_wrap = 0; 862 if (con_should_update(vc)) 863 do_update_region(vc, (unsigned long) p, 864 vc->vc_cols - vc->state.x); 865} 866 867static int softcursor_original = -1; 868 869static void add_softcursor(struct vc_data *vc) 870{ 871 int i = scr_readw((u16 *) vc->vc_pos); 872 u32 type = vc->vc_cursor_type; 873 874 if (!(type & CUR_SW)) 875 return; 876 if (softcursor_original != -1) 877 return; 878 softcursor_original = i; 879 i |= CUR_SET(type); 880 i ^= CUR_CHANGE(type); 881 if ((type & CUR_ALWAYS_BG) && 882 (softcursor_original & CUR_BG) == (i & CUR_BG)) 883 i ^= CUR_BG; 884 if ((type & CUR_INVERT_FG_BG) && (i & CUR_FG) == ((i & CUR_BG) >> 4)) 885 i ^= CUR_FG; 886 scr_writew(i, (u16 *)vc->vc_pos); 887 if (con_should_update(vc)) 888 vc->vc_sw->con_putc(vc, i, vc->state.y, vc->state.x); 889} 890 891static void hide_softcursor(struct vc_data *vc) 892{ 893 if (softcursor_original != -1) { 894 scr_writew(softcursor_original, (u16 *)vc->vc_pos); 895 if (con_should_update(vc)) 896 vc->vc_sw->con_putc(vc, softcursor_original, 897 vc->state.y, vc->state.x); 898 softcursor_original = -1; 899 } 900} 901 902static void hide_cursor(struct vc_data *vc) 903{ 904 if (vc_is_sel(vc)) 905 clear_selection(); 906 907 vc->vc_sw->con_cursor(vc, CM_ERASE); 908 hide_softcursor(vc); 909} 910 911static void set_cursor(struct vc_data *vc) 912{ 913 if (!con_is_fg(vc) || console_blanked || vc->vc_mode == KD_GRAPHICS) 914 return; 915 if (vc->vc_deccm) { 916 if (vc_is_sel(vc)) 917 clear_selection(); 918 add_softcursor(vc); 919 if (CUR_SIZE(vc->vc_cursor_type) != CUR_NONE) 920 vc->vc_sw->con_cursor(vc, CM_DRAW); 921 } else 922 hide_cursor(vc); 923} 924 925static void set_origin(struct vc_data *vc) 926{ 927 WARN_CONSOLE_UNLOCKED(); 928 929 if (!con_is_visible(vc) || 930 !vc->vc_sw->con_set_origin || 931 !vc->vc_sw->con_set_origin(vc)) 932 vc->vc_origin = (unsigned long)vc->vc_screenbuf; 933 vc->vc_visible_origin = vc->vc_origin; 934 vc->vc_scr_end = vc->vc_origin + vc->vc_screenbuf_size; 935 vc->vc_pos = vc->vc_origin + vc->vc_size_row * vc->state.y + 936 2 * vc->state.x; 937} 938 939static void save_screen(struct vc_data *vc) 940{ 941 WARN_CONSOLE_UNLOCKED(); 942 943 if (vc->vc_sw->con_save_screen) 944 vc->vc_sw->con_save_screen(vc); 945} 946 947static void flush_scrollback(struct vc_data *vc) 948{ 949 WARN_CONSOLE_UNLOCKED(); 950 951 set_origin(vc); 952 if (vc->vc_sw->con_flush_scrollback) { 953 vc->vc_sw->con_flush_scrollback(vc); 954 } else if (con_is_visible(vc)) { 955 /* 956 * When no con_flush_scrollback method is provided then the 957 * legacy way for flushing the scrollback buffer is to use 958 * a side effect of the con_switch method. We do it only on 959 * the foreground console as background consoles have no 960 * scrollback buffers in that case and we obviously don't 961 * want to switch to them. 962 */ 963 hide_cursor(vc); 964 vc->vc_sw->con_switch(vc); 965 set_cursor(vc); 966 } 967} 968 969/* 970 * Redrawing of screen 971 */ 972 973void clear_buffer_attributes(struct vc_data *vc) 974{ 975 unsigned short *p = (unsigned short *)vc->vc_origin; 976 int count = vc->vc_screenbuf_size / 2; 977 int mask = vc->vc_hi_font_mask | 0xff; 978 979 for (; count > 0; count--, p++) { 980 scr_writew((scr_readw(p)&mask) | (vc->vc_video_erase_char & ~mask), p); 981 } 982} 983 984void redraw_screen(struct vc_data *vc, int is_switch) 985{ 986 int redraw = 0; 987 988 WARN_CONSOLE_UNLOCKED(); 989 990 if (!vc) { 991 /* strange ... */ 992 /* printk("redraw_screen: tty %d not allocated ??\n", new_console+1); */ 993 return; 994 } 995 996 if (is_switch) { 997 struct vc_data *old_vc = vc_cons[fg_console].d; 998 if (old_vc == vc) 999 return; 1000 if (!con_is_visible(vc)) 1001 redraw = 1; 1002 *vc->vc_display_fg = vc; 1003 fg_console = vc->vc_num; 1004 hide_cursor(old_vc); 1005 if (!con_is_visible(old_vc)) { 1006 save_screen(old_vc); 1007 set_origin(old_vc); 1008 } 1009 if (tty0dev) 1010 sysfs_notify(&tty0dev->kobj, NULL, "active"); 1011 } else { 1012 hide_cursor(vc); 1013 redraw = 1; 1014 } 1015 1016 if (redraw) { 1017 int update; 1018 int old_was_color = vc->vc_can_do_color; 1019 1020 set_origin(vc); 1021 update = vc->vc_sw->con_switch(vc); 1022 set_palette(vc); 1023 /* 1024 * If console changed from mono<->color, the best we can do 1025 * is to clear the buffer attributes. As it currently stands, 1026 * rebuilding new attributes from the old buffer is not doable 1027 * without overly complex code. 1028 */ 1029 if (old_was_color != vc->vc_can_do_color) { 1030 update_attr(vc); 1031 clear_buffer_attributes(vc); 1032 } 1033 1034 if (update && vc->vc_mode != KD_GRAPHICS) 1035 do_update_region(vc, vc->vc_origin, vc->vc_screenbuf_size / 2); 1036 } 1037 set_cursor(vc); 1038 if (is_switch) { 1039 set_leds(); 1040 compute_shiftstate(); 1041 notify_update(vc); 1042 } 1043} 1044 1045/* 1046 * Allocation, freeing and resizing of VTs. 1047 */ 1048 1049int vc_cons_allocated(unsigned int i) 1050{ 1051 return (i < MAX_NR_CONSOLES && vc_cons[i].d); 1052} 1053 1054static void visual_init(struct vc_data *vc, int num, int init) 1055{ 1056 /* ++Geert: vc->vc_sw->con_init determines console size */ 1057 if (vc->vc_sw) 1058 module_put(vc->vc_sw->owner); 1059 vc->vc_sw = conswitchp; 1060#ifndef VT_SINGLE_DRIVER 1061 if (con_driver_map[num]) 1062 vc->vc_sw = con_driver_map[num]; 1063#endif 1064 __module_get(vc->vc_sw->owner); 1065 vc->vc_num = num; 1066 vc->vc_display_fg = &master_display_fg; 1067 if (vc->vc_uni_pagedir_loc) 1068 con_free_unimap(vc); 1069 vc->vc_uni_pagedir_loc = &vc->vc_uni_pagedir; 1070 vc->vc_uni_pagedir = NULL; 1071 vc->vc_hi_font_mask = 0; 1072 vc->vc_complement_mask = 0; 1073 vc->vc_can_do_color = 0; 1074 vc->vc_cur_blink_ms = DEFAULT_CURSOR_BLINK_MS; 1075 vc->vc_sw->con_init(vc, init); 1076 if (!vc->vc_complement_mask) 1077 vc->vc_complement_mask = vc->vc_can_do_color ? 0x7700 : 0x0800; 1078 vc->vc_s_complement_mask = vc->vc_complement_mask; 1079 vc->vc_size_row = vc->vc_cols << 1; 1080 vc->vc_screenbuf_size = vc->vc_rows * vc->vc_size_row; 1081} 1082 1083 1084static void visual_deinit(struct vc_data *vc) 1085{ 1086 vc->vc_sw->con_deinit(vc); 1087 module_put(vc->vc_sw->owner); 1088} 1089 1090static void vc_port_destruct(struct tty_port *port) 1091{ 1092 struct vc_data *vc = container_of(port, struct vc_data, port); 1093 1094 kfree(vc); 1095} 1096 1097static const struct tty_port_operations vc_port_ops = { 1098 .destruct = vc_port_destruct, 1099}; 1100 1101/* 1102 * Change # of rows and columns (0 means unchanged/the size of fg_console) 1103 * [this is to be used together with some user program 1104 * like resize that changes the hardware videomode] 1105 */ 1106#define VC_MAXCOL (32767) 1107#define VC_MAXROW (32767) 1108 1109int vc_allocate(unsigned int currcons) /* return 0 on success */ 1110{ 1111 struct vt_notifier_param param; 1112 struct vc_data *vc; 1113 int err; 1114 1115 WARN_CONSOLE_UNLOCKED(); 1116 1117 if (currcons >= MAX_NR_CONSOLES) 1118 return -ENXIO; 1119 1120 if (vc_cons[currcons].d) 1121 return 0; 1122 1123 /* due to the granularity of kmalloc, we waste some memory here */ 1124 /* the alloc is done in two steps, to optimize the common situation 1125 of a 25x80 console (structsize=216, screenbuf_size=4000) */ 1126 /* although the numbers above are not valid since long ago, the 1127 point is still up-to-date and the comment still has its value 1128 even if only as a historical artifact. --mj, July 1998 */ 1129 param.vc = vc = kzalloc(sizeof(struct vc_data), GFP_KERNEL); 1130 if (!vc) 1131 return -ENOMEM; 1132 1133 vc_cons[currcons].d = vc; 1134 tty_port_init(&vc->port); 1135 vc->port.ops = &vc_port_ops; 1136 INIT_WORK(&vc_cons[currcons].SAK_work, vc_SAK); 1137 1138 visual_init(vc, currcons, 1); 1139 1140 if (!*vc->vc_uni_pagedir_loc) 1141 con_set_default_unimap(vc); 1142 1143 err = -EINVAL; 1144 if (vc->vc_cols > VC_MAXCOL || vc->vc_rows > VC_MAXROW || 1145 vc->vc_screenbuf_size > KMALLOC_MAX_SIZE || !vc->vc_screenbuf_size) 1146 goto err_free; 1147 err = -ENOMEM; 1148 vc->vc_screenbuf = kzalloc(vc->vc_screenbuf_size, GFP_KERNEL); 1149 if (!vc->vc_screenbuf) 1150 goto err_free; 1151 1152 /* If no drivers have overridden us and the user didn't pass a 1153 boot option, default to displaying the cursor */ 1154 if (global_cursor_default == -1) 1155 global_cursor_default = 1; 1156 1157 vc_init(vc, vc->vc_rows, vc->vc_cols, 1); 1158 vcs_make_sysfs(currcons); 1159 atomic_notifier_call_chain(&vt_notifier_list, VT_ALLOCATE, ¶m); 1160 1161 return 0; 1162err_free: 1163 visual_deinit(vc); 1164 kfree(vc); 1165 vc_cons[currcons].d = NULL; 1166 return err; 1167} 1168 1169static inline int resize_screen(struct vc_data *vc, int width, int height, 1170 int user) 1171{ 1172 /* Resizes the resolution of the display adapater */ 1173 int err = 0; 1174 1175 if (vc->vc_sw->con_resize) 1176 err = vc->vc_sw->con_resize(vc, width, height, user); 1177 1178 return err; 1179} 1180 1181/** 1182 * vc_do_resize - resizing method for the tty 1183 * @tty: tty being resized 1184 * @vc: virtual console private data 1185 * @cols: columns 1186 * @lines: lines 1187 * 1188 * Resize a virtual console, clipping according to the actual constraints. 1189 * If the caller passes a tty structure then update the termios winsize 1190 * information and perform any necessary signal handling. 1191 * 1192 * Caller must hold the console semaphore. Takes the termios rwsem and 1193 * ctrl_lock of the tty IFF a tty is passed. 1194 */ 1195 1196static int vc_do_resize(struct tty_struct *tty, struct vc_data *vc, 1197 unsigned int cols, unsigned int lines) 1198{ 1199 unsigned long old_origin, new_origin, new_scr_end, rlth, rrem, err = 0; 1200 unsigned long end; 1201 unsigned int old_rows, old_row_size, first_copied_row; 1202 unsigned int new_cols, new_rows, new_row_size, new_screen_size; 1203 unsigned int user; 1204 unsigned short *oldscreen, *newscreen; 1205 struct uni_screen *new_uniscr = NULL; 1206 1207 WARN_CONSOLE_UNLOCKED(); 1208 1209 if (!vc) 1210 return -ENXIO; 1211 1212 user = vc->vc_resize_user; 1213 vc->vc_resize_user = 0; 1214 1215 if (cols > VC_MAXCOL || lines > VC_MAXROW) 1216 return -EINVAL; 1217 1218 new_cols = (cols ? cols : vc->vc_cols); 1219 new_rows = (lines ? lines : vc->vc_rows); 1220 new_row_size = new_cols << 1; 1221 new_screen_size = new_row_size * new_rows; 1222 1223 if (new_cols == vc->vc_cols && new_rows == vc->vc_rows) { 1224 /* 1225 * This function is being called here to cover the case 1226 * where the userspace calls the FBIOPUT_VSCREENINFO twice, 1227 * passing the same fb_var_screeninfo containing the fields 1228 * yres/xres equal to a number non-multiple of vc_font.height 1229 * and yres_virtual/xres_virtual equal to number lesser than the 1230 * vc_font.height and yres/xres. 1231 * In the second call, the struct fb_var_screeninfo isn't 1232 * being modified by the underlying driver because of the 1233 * if above, and this causes the fbcon_display->vrows to become 1234 * negative and it eventually leads to out-of-bound 1235 * access by the imageblit function. 1236 * To give the correct values to the struct and to not have 1237 * to deal with possible errors from the code below, we call 1238 * the resize_screen here as well. 1239 */ 1240 return resize_screen(vc, new_cols, new_rows, user); 1241 } 1242 1243 if (new_screen_size > KMALLOC_MAX_SIZE || !new_screen_size) 1244 return -EINVAL; 1245 newscreen = kzalloc(new_screen_size, GFP_USER); 1246 if (!newscreen) 1247 return -ENOMEM; 1248 1249 if (get_vc_uniscr(vc)) { 1250 new_uniscr = vc_uniscr_alloc(new_cols, new_rows); 1251 if (!new_uniscr) { 1252 kfree(newscreen); 1253 return -ENOMEM; 1254 } 1255 } 1256 1257 if (vc_is_sel(vc)) 1258 clear_selection(); 1259 1260 old_rows = vc->vc_rows; 1261 old_row_size = vc->vc_size_row; 1262 1263 err = resize_screen(vc, new_cols, new_rows, user); 1264 if (err) { 1265 kfree(newscreen); 1266 vc_uniscr_free(new_uniscr); 1267 return err; 1268 } 1269 1270 vc->vc_rows = new_rows; 1271 vc->vc_cols = new_cols; 1272 vc->vc_size_row = new_row_size; 1273 vc->vc_screenbuf_size = new_screen_size; 1274 1275 rlth = min(old_row_size, new_row_size); 1276 rrem = new_row_size - rlth; 1277 old_origin = vc->vc_origin; 1278 new_origin = (long) newscreen; 1279 new_scr_end = new_origin + new_screen_size; 1280 1281 if (vc->state.y > new_rows) { 1282 if (old_rows - vc->state.y < new_rows) { 1283 /* 1284 * Cursor near the bottom, copy contents from the 1285 * bottom of buffer 1286 */ 1287 first_copied_row = (old_rows - new_rows); 1288 } else { 1289 /* 1290 * Cursor is in no man's land, copy 1/2 screenful 1291 * from the top and bottom of cursor position 1292 */ 1293 first_copied_row = (vc->state.y - new_rows/2); 1294 } 1295 old_origin += first_copied_row * old_row_size; 1296 } else 1297 first_copied_row = 0; 1298 end = old_origin + old_row_size * min(old_rows, new_rows); 1299 1300 vc_uniscr_copy_area(new_uniscr, new_cols, new_rows, 1301 get_vc_uniscr(vc), rlth/2, first_copied_row, 1302 min(old_rows, new_rows)); 1303 vc_uniscr_set(vc, new_uniscr); 1304 1305 update_attr(vc); 1306 1307 while (old_origin < end) { 1308 scr_memcpyw((unsigned short *) new_origin, 1309 (unsigned short *) old_origin, rlth); 1310 if (rrem) 1311 scr_memsetw((void *)(new_origin + rlth), 1312 vc->vc_video_erase_char, rrem); 1313 old_origin += old_row_size; 1314 new_origin += new_row_size; 1315 } 1316 if (new_scr_end > new_origin) 1317 scr_memsetw((void *)new_origin, vc->vc_video_erase_char, 1318 new_scr_end - new_origin); 1319 oldscreen = vc->vc_screenbuf; 1320 vc->vc_screenbuf = newscreen; 1321 vc->vc_screenbuf_size = new_screen_size; 1322 set_origin(vc); 1323 kfree(oldscreen); 1324 1325 /* do part of a reset_terminal() */ 1326 vc->vc_top = 0; 1327 vc->vc_bottom = vc->vc_rows; 1328 gotoxy(vc, vc->state.x, vc->state.y); 1329 save_cur(vc); 1330 1331 if (tty) { 1332 /* Rewrite the requested winsize data with the actual 1333 resulting sizes */ 1334 struct winsize ws; 1335 memset(&ws, 0, sizeof(ws)); 1336 ws.ws_row = vc->vc_rows; 1337 ws.ws_col = vc->vc_cols; 1338 ws.ws_ypixel = vc->vc_scan_lines; 1339 tty_do_resize(tty, &ws); 1340 } 1341 1342 if (con_is_visible(vc)) 1343 update_screen(vc); 1344 vt_event_post(VT_EVENT_RESIZE, vc->vc_num, vc->vc_num); 1345 notify_update(vc); 1346 return err; 1347} 1348 1349/** 1350 * vc_resize - resize a VT 1351 * @vc: virtual console 1352 * @cols: columns 1353 * @rows: rows 1354 * 1355 * Resize a virtual console as seen from the console end of things. We 1356 * use the common vc_do_resize methods to update the structures. The 1357 * caller must hold the console sem to protect console internals and 1358 * vc->port.tty 1359 */ 1360 1361int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int rows) 1362{ 1363 return vc_do_resize(vc->port.tty, vc, cols, rows); 1364} 1365 1366/** 1367 * vt_resize - resize a VT 1368 * @tty: tty to resize 1369 * @ws: winsize attributes 1370 * 1371 * Resize a virtual terminal. This is called by the tty layer as we 1372 * register our own handler for resizing. The mutual helper does all 1373 * the actual work. 1374 * 1375 * Takes the console sem and the called methods then take the tty 1376 * termios_rwsem and the tty ctrl_lock in that order. 1377 */ 1378static int vt_resize(struct tty_struct *tty, struct winsize *ws) 1379{ 1380 struct vc_data *vc = tty->driver_data; 1381 int ret; 1382 1383 console_lock(); 1384 ret = vc_do_resize(tty, vc, ws->ws_col, ws->ws_row); 1385 console_unlock(); 1386 return ret; 1387} 1388 1389struct vc_data *vc_deallocate(unsigned int currcons) 1390{ 1391 struct vc_data *vc = NULL; 1392 1393 WARN_CONSOLE_UNLOCKED(); 1394 1395 if (vc_cons_allocated(currcons)) { 1396 struct vt_notifier_param param; 1397 1398 param.vc = vc = vc_cons[currcons].d; 1399 atomic_notifier_call_chain(&vt_notifier_list, VT_DEALLOCATE, ¶m); 1400 vcs_remove_sysfs(currcons); 1401 visual_deinit(vc); 1402 con_free_unimap(vc); 1403 put_pid(vc->vt_pid); 1404 vc_uniscr_set(vc, NULL); 1405 kfree(vc->vc_screenbuf); 1406 vc_cons[currcons].d = NULL; 1407 } 1408 return vc; 1409} 1410 1411/* 1412 * VT102 emulator 1413 */ 1414 1415enum { EPecma = 0, EPdec, EPeq, EPgt, EPlt}; 1416 1417#define set_kbd(vc, x) vt_set_kbd_mode_bit((vc)->vc_num, (x)) 1418#define clr_kbd(vc, x) vt_clr_kbd_mode_bit((vc)->vc_num, (x)) 1419#define is_kbd(vc, x) vt_get_kbd_mode_bit((vc)->vc_num, (x)) 1420 1421#define decarm VC_REPEAT 1422#define decckm VC_CKMODE 1423#define kbdapplic VC_APPLIC 1424#define lnm VC_CRLF 1425 1426const unsigned char color_table[] = { 0, 4, 2, 6, 1, 5, 3, 7, 1427 8,12,10,14, 9,13,11,15 }; 1428 1429/* the default colour table, for VGA+ colour systems */ 1430unsigned char default_red[] = { 1431 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 1432 0x55, 0xff, 0x55, 0xff, 0x55, 0xff, 0x55, 0xff 1433}; 1434module_param_array(default_red, byte, NULL, S_IRUGO | S_IWUSR); 1435 1436unsigned char default_grn[] = { 1437 0x00, 0x00, 0xaa, 0x55, 0x00, 0x00, 0xaa, 0xaa, 1438 0x55, 0x55, 0xff, 0xff, 0x55, 0x55, 0xff, 0xff 1439}; 1440module_param_array(default_grn, byte, NULL, S_IRUGO | S_IWUSR); 1441 1442unsigned char default_blu[] = { 1443 0x00, 0x00, 0x00, 0x00, 0xaa, 0xaa, 0xaa, 0xaa, 1444 0x55, 0x55, 0x55, 0x55, 0xff, 0xff, 0xff, 0xff 1445}; 1446module_param_array(default_blu, byte, NULL, S_IRUGO | S_IWUSR); 1447 1448/* 1449 * gotoxy() must verify all boundaries, because the arguments 1450 * might also be negative. If the given position is out of 1451 * bounds, the cursor is placed at the nearest margin. 1452 */ 1453static void gotoxy(struct vc_data *vc, int new_x, int new_y) 1454{ 1455 int min_y, max_y; 1456 1457 if (new_x < 0) 1458 vc->state.x = 0; 1459 else { 1460 if (new_x >= vc->vc_cols) 1461 vc->state.x = vc->vc_cols - 1; 1462 else 1463 vc->state.x = new_x; 1464 } 1465 1466 if (vc->vc_decom) { 1467 min_y = vc->vc_top; 1468 max_y = vc->vc_bottom; 1469 } else { 1470 min_y = 0; 1471 max_y = vc->vc_rows; 1472 } 1473 if (new_y < min_y) 1474 vc->state.y = min_y; 1475 else if (new_y >= max_y) 1476 vc->state.y = max_y - 1; 1477 else 1478 vc->state.y = new_y; 1479 vc->vc_pos = vc->vc_origin + vc->state.y * vc->vc_size_row + 1480 (vc->state.x << 1); 1481 vc->vc_need_wrap = 0; 1482} 1483 1484/* for absolute user moves, when decom is set */ 1485static void gotoxay(struct vc_data *vc, int new_x, int new_y) 1486{ 1487 gotoxy(vc, new_x, vc->vc_decom ? (vc->vc_top + new_y) : new_y); 1488} 1489 1490void scrollback(struct vc_data *vc) 1491{ 1492 scrolldelta(-(vc->vc_rows / 2)); 1493} 1494 1495void scrollfront(struct vc_data *vc, int lines) 1496{ 1497 if (!lines) 1498 lines = vc->vc_rows / 2; 1499 scrolldelta(lines); 1500} 1501 1502static void lf(struct vc_data *vc) 1503{ 1504 /* don't scroll if above bottom of scrolling region, or 1505 * if below scrolling region 1506 */ 1507 if (vc->state.y + 1 == vc->vc_bottom) 1508 con_scroll(vc, vc->vc_top, vc->vc_bottom, SM_UP, 1); 1509 else if (vc->state.y < vc->vc_rows - 1) { 1510 vc->state.y++; 1511 vc->vc_pos += vc->vc_size_row; 1512 } 1513 vc->vc_need_wrap = 0; 1514 notify_write(vc, '\n'); 1515} 1516 1517static void ri(struct vc_data *vc) 1518{ 1519 /* don't scroll if below top of scrolling region, or 1520 * if above scrolling region 1521 */ 1522 if (vc->state.y == vc->vc_top) 1523 con_scroll(vc, vc->vc_top, vc->vc_bottom, SM_DOWN, 1); 1524 else if (vc->state.y > 0) { 1525 vc->state.y--; 1526 vc->vc_pos -= vc->vc_size_row; 1527 } 1528 vc->vc_need_wrap = 0; 1529} 1530 1531static inline void cr(struct vc_data *vc) 1532{ 1533 vc->vc_pos -= vc->state.x << 1; 1534 vc->vc_need_wrap = vc->state.x = 0; 1535 notify_write(vc, '\r'); 1536} 1537 1538static inline void bs(struct vc_data *vc) 1539{ 1540 if (vc->state.x) { 1541 vc->vc_pos -= 2; 1542 vc->state.x--; 1543 vc->vc_need_wrap = 0; 1544 notify_write(vc, '\b'); 1545 } 1546} 1547 1548static inline void del(struct vc_data *vc) 1549{ 1550 /* ignored */ 1551} 1552 1553static void csi_J(struct vc_data *vc, int vpar) 1554{ 1555 unsigned int count; 1556 unsigned short * start; 1557 1558 switch (vpar) { 1559 case 0: /* erase from cursor to end of display */ 1560 vc_uniscr_clear_line(vc, vc->state.x, 1561 vc->vc_cols - vc->state.x); 1562 vc_uniscr_clear_lines(vc, vc->state.y + 1, 1563 vc->vc_rows - vc->state.y - 1); 1564 count = (vc->vc_scr_end - vc->vc_pos) >> 1; 1565 start = (unsigned short *)vc->vc_pos; 1566 break; 1567 case 1: /* erase from start to cursor */ 1568 vc_uniscr_clear_line(vc, 0, vc->state.x + 1); 1569 vc_uniscr_clear_lines(vc, 0, vc->state.y); 1570 count = ((vc->vc_pos - vc->vc_origin) >> 1) + 1; 1571 start = (unsigned short *)vc->vc_origin; 1572 break; 1573 case 3: /* include scrollback */ 1574 flush_scrollback(vc); 1575 fallthrough; 1576 case 2: /* erase whole display */ 1577 vc_uniscr_clear_lines(vc, 0, vc->vc_rows); 1578 count = vc->vc_cols * vc->vc_rows; 1579 start = (unsigned short *)vc->vc_origin; 1580 break; 1581 default: 1582 return; 1583 } 1584 scr_memsetw(start, vc->vc_video_erase_char, 2 * count); 1585 if (con_should_update(vc)) 1586 do_update_region(vc, (unsigned long) start, count); 1587 vc->vc_need_wrap = 0; 1588} 1589 1590static void csi_K(struct vc_data *vc, int vpar) 1591{ 1592 unsigned int count; 1593 unsigned short *start = (unsigned short *)vc->vc_pos; 1594 int offset; 1595 1596 switch (vpar) { 1597 case 0: /* erase from cursor to end of line */ 1598 offset = 0; 1599 count = vc->vc_cols - vc->state.x; 1600 break; 1601 case 1: /* erase from start of line to cursor */ 1602 offset = -vc->state.x; 1603 count = vc->state.x + 1; 1604 break; 1605 case 2: /* erase whole line */ 1606 offset = -vc->state.x; 1607 count = vc->vc_cols; 1608 break; 1609 default: 1610 return; 1611 } 1612 vc_uniscr_clear_line(vc, vc->state.x + offset, count); 1613 scr_memsetw(start + offset, vc->vc_video_erase_char, 2 * count); 1614 vc->vc_need_wrap = 0; 1615 if (con_should_update(vc)) 1616 do_update_region(vc, (unsigned long)(start + offset), count); 1617} 1618 1619/* erase the following vpar positions */ 1620static void csi_X(struct vc_data *vc, unsigned int vpar) 1621{ /* not vt100? */ 1622 unsigned int count; 1623 1624 if (!vpar) 1625 vpar++; 1626 1627 count = min(vpar, vc->vc_cols - vc->state.x); 1628 1629 vc_uniscr_clear_line(vc, vc->state.x, count); 1630 scr_memsetw((unsigned short *)vc->vc_pos, vc->vc_video_erase_char, 2 * count); 1631 if (con_should_update(vc)) 1632 vc->vc_sw->con_clear(vc, vc->state.y, vc->state.x, 1, count); 1633 vc->vc_need_wrap = 0; 1634} 1635 1636static void default_attr(struct vc_data *vc) 1637{ 1638 vc->state.intensity = VCI_NORMAL; 1639 vc->state.italic = false; 1640 vc->state.underline = false; 1641 vc->state.reverse = false; 1642 vc->state.blink = false; 1643 vc->state.color = vc->vc_def_color; 1644} 1645 1646struct rgb { u8 r; u8 g; u8 b; }; 1647 1648static void rgb_from_256(int i, struct rgb *c) 1649{ 1650 if (i < 8) { /* Standard colours. */ 1651 c->r = i&1 ? 0xaa : 0x00; 1652 c->g = i&2 ? 0xaa : 0x00; 1653 c->b = i&4 ? 0xaa : 0x00; 1654 } else if (i < 16) { 1655 c->r = i&1 ? 0xff : 0x55; 1656 c->g = i&2 ? 0xff : 0x55; 1657 c->b = i&4 ? 0xff : 0x55; 1658 } else if (i < 232) { /* 6x6x6 colour cube. */ 1659 c->r = (i - 16) / 36 * 85 / 2; 1660 c->g = (i - 16) / 6 % 6 * 85 / 2; 1661 c->b = (i - 16) % 6 * 85 / 2; 1662 } else /* Grayscale ramp. */ 1663 c->r = c->g = c->b = i * 10 - 2312; 1664} 1665 1666static void rgb_foreground(struct vc_data *vc, const struct rgb *c) 1667{ 1668 u8 hue = 0, max = max3(c->r, c->g, c->b); 1669 1670 if (c->r > max / 2) 1671 hue |= 4; 1672 if (c->g > max / 2) 1673 hue |= 2; 1674 if (c->b > max / 2) 1675 hue |= 1; 1676 1677 if (hue == 7 && max <= 0x55) { 1678 hue = 0; 1679 vc->state.intensity = VCI_BOLD; 1680 } else if (max > 0xaa) 1681 vc->state.intensity = VCI_BOLD; 1682 else 1683 vc->state.intensity = VCI_NORMAL; 1684 1685 vc->state.color = (vc->state.color & 0xf0) | hue; 1686} 1687 1688static void rgb_background(struct vc_data *vc, const struct rgb *c) 1689{ 1690 /* For backgrounds, err on the dark side. */ 1691 vc->state.color = (vc->state.color & 0x0f) 1692 | (c->r&0x80) >> 1 | (c->g&0x80) >> 2 | (c->b&0x80) >> 3; 1693} 1694 1695/* 1696 * ITU T.416 Higher colour modes. They break the usual properties of SGR codes 1697 * and thus need to be detected and ignored by hand. That standard also 1698 * wants : rather than ; as separators but sequences containing : are currently 1699 * completely ignored by the parser. 1700 * 1701 * Subcommands 3 (CMY) and 4 (CMYK) are so insane there's no point in 1702 * supporting them. 1703 */ 1704static int vc_t416_color(struct vc_data *vc, int i, 1705 void(*set_color)(struct vc_data *vc, const struct rgb *c)) 1706{ 1707 struct rgb c; 1708 1709 i++; 1710 if (i > vc->vc_npar) 1711 return i; 1712 1713 if (vc->vc_par[i] == 5 && i + 1 <= vc->vc_npar) { 1714 /* 256 colours */ 1715 i++; 1716 rgb_from_256(vc->vc_par[i], &c); 1717 } else if (vc->vc_par[i] == 2 && i + 3 <= vc->vc_npar) { 1718 /* 24 bit */ 1719 c.r = vc->vc_par[i + 1]; 1720 c.g = vc->vc_par[i + 2]; 1721 c.b = vc->vc_par[i + 3]; 1722 i += 3; 1723 } else 1724 return i; 1725 1726 set_color(vc, &c); 1727 1728 return i; 1729} 1730 1731/* console_lock is held */ 1732static void csi_m(struct vc_data *vc) 1733{ 1734 int i; 1735 1736 for (i = 0; i <= vc->vc_npar; i++) 1737 switch (vc->vc_par[i]) { 1738 case 0: /* all attributes off */ 1739 default_attr(vc); 1740 break; 1741 case 1: 1742 vc->state.intensity = VCI_BOLD; 1743 break; 1744 case 2: 1745 vc->state.intensity = VCI_HALF_BRIGHT; 1746 break; 1747 case 3: 1748 vc->state.italic = true; 1749 break; 1750 case 21: 1751 /* 1752 * No console drivers support double underline, so 1753 * convert it to a single underline. 1754 */ 1755 case 4: 1756 vc->state.underline = true; 1757 break; 1758 case 5: 1759 vc->state.blink = true; 1760 break; 1761 case 7: 1762 vc->state.reverse = true; 1763 break; 1764 case 10: /* ANSI X3.64-1979 (SCO-ish?) 1765 * Select primary font, don't display control chars if 1766 * defined, don't set bit 8 on output. 1767 */ 1768 vc->vc_translate = set_translate(vc->state.Gx_charset[vc->state.charset], vc); 1769 vc->vc_disp_ctrl = 0; 1770 vc->vc_toggle_meta = 0; 1771 break; 1772 case 11: /* ANSI X3.64-1979 (SCO-ish?) 1773 * Select first alternate font, lets chars < 32 be 1774 * displayed as ROM chars. 1775 */ 1776 vc->vc_translate = set_translate(IBMPC_MAP, vc); 1777 vc->vc_disp_ctrl = 1; 1778 vc->vc_toggle_meta = 0; 1779 break; 1780 case 12: /* ANSI X3.64-1979 (SCO-ish?) 1781 * Select second alternate font, toggle high bit 1782 * before displaying as ROM char. 1783 */ 1784 vc->vc_translate = set_translate(IBMPC_MAP, vc); 1785 vc->vc_disp_ctrl = 1; 1786 vc->vc_toggle_meta = 1; 1787 break; 1788 case 22: 1789 vc->state.intensity = VCI_NORMAL; 1790 break; 1791 case 23: 1792 vc->state.italic = false; 1793 break; 1794 case 24: 1795 vc->state.underline = false; 1796 break; 1797 case 25: 1798 vc->state.blink = false; 1799 break; 1800 case 27: 1801 vc->state.reverse = false; 1802 break; 1803 case 38: 1804 i = vc_t416_color(vc, i, rgb_foreground); 1805 break; 1806 case 48: 1807 i = vc_t416_color(vc, i, rgb_background); 1808 break; 1809 case 39: 1810 vc->state.color = (vc->vc_def_color & 0x0f) | 1811 (vc->state.color & 0xf0); 1812 break; 1813 case 49: 1814 vc->state.color = (vc->vc_def_color & 0xf0) | 1815 (vc->state.color & 0x0f); 1816 break; 1817 default: 1818 if (vc->vc_par[i] >= 90 && vc->vc_par[i] <= 107) { 1819 if (vc->vc_par[i] < 100) 1820 vc->state.intensity = VCI_BOLD; 1821 vc->vc_par[i] -= 60; 1822 } 1823 if (vc->vc_par[i] >= 30 && vc->vc_par[i] <= 37) 1824 vc->state.color = color_table[vc->vc_par[i] - 30] 1825 | (vc->state.color & 0xf0); 1826 else if (vc->vc_par[i] >= 40 && vc->vc_par[i] <= 47) 1827 vc->state.color = (color_table[vc->vc_par[i] - 40] << 4) 1828 | (vc->state.color & 0x0f); 1829 break; 1830 } 1831 update_attr(vc); 1832} 1833 1834static void respond_string(const char *p, size_t len, struct tty_port *port) 1835{ 1836 tty_insert_flip_string(port, p, len); 1837 tty_flip_buffer_push(port); 1838} 1839 1840static void cursor_report(struct vc_data *vc, struct tty_struct *tty) 1841{ 1842 char buf[40]; 1843 int len; 1844 1845 len = sprintf(buf, "\033[%d;%dR", vc->state.y + 1846 (vc->vc_decom ? vc->vc_top + 1 : 1), 1847 vc->state.x + 1); 1848 respond_string(buf, len, tty->port); 1849} 1850 1851static inline void status_report(struct tty_struct *tty) 1852{ 1853 static const char teminal_ok[] = "\033[0n"; 1854 1855 respond_string(teminal_ok, strlen(teminal_ok), tty->port); 1856} 1857 1858static inline void respond_ID(struct tty_struct *tty) 1859{ 1860 /* terminal answer to an ESC-Z or csi0c query. */ 1861 static const char vt102_id[] = "\033[?6c"; 1862 1863 respond_string(vt102_id, strlen(vt102_id), tty->port); 1864} 1865 1866void mouse_report(struct tty_struct *tty, int butt, int mrx, int mry) 1867{ 1868 char buf[8]; 1869 int len; 1870 1871 len = sprintf(buf, "\033[M%c%c%c", (char)(' ' + butt), 1872 (char)('!' + mrx), (char)('!' + mry)); 1873 respond_string(buf, len, tty->port); 1874} 1875 1876/* invoked via ioctl(TIOCLINUX) and through set_selection_user */ 1877int mouse_reporting(void) 1878{ 1879 return vc_cons[fg_console].d->vc_report_mouse; 1880} 1881 1882/* console_lock is held */ 1883static void set_mode(struct vc_data *vc, int on_off) 1884{ 1885 int i; 1886 1887 for (i = 0; i <= vc->vc_npar; i++) 1888 if (vc->vc_priv == EPdec) { 1889 switch(vc->vc_par[i]) { /* DEC private modes set/reset */ 1890 case 1: /* Cursor keys send ^[Ox/^[[x */ 1891 if (on_off) 1892 set_kbd(vc, decckm); 1893 else 1894 clr_kbd(vc, decckm); 1895 break; 1896 case 3: /* 80/132 mode switch unimplemented */ 1897#if 0 1898 vc_resize(deccolm ? 132 : 80, vc->vc_rows); 1899 /* this alone does not suffice; some user mode 1900 utility has to change the hardware regs */ 1901#endif 1902 break; 1903 case 5: /* Inverted screen on/off */ 1904 if (vc->vc_decscnm != on_off) { 1905 vc->vc_decscnm = on_off; 1906 invert_screen(vc, 0, 1907 vc->vc_screenbuf_size, 1908 false); 1909 update_attr(vc); 1910 } 1911 break; 1912 case 6: /* Origin relative/absolute */ 1913 vc->vc_decom = on_off; 1914 gotoxay(vc, 0, 0); 1915 break; 1916 case 7: /* Autowrap on/off */ 1917 vc->vc_decawm = on_off; 1918 break; 1919 case 8: /* Autorepeat on/off */ 1920 if (on_off) 1921 set_kbd(vc, decarm); 1922 else 1923 clr_kbd(vc, decarm); 1924 break; 1925 case 9: 1926 vc->vc_report_mouse = on_off ? 1 : 0; 1927 break; 1928 case 25: /* Cursor on/off */ 1929 vc->vc_deccm = on_off; 1930 break; 1931 case 1000: 1932 vc->vc_report_mouse = on_off ? 2 : 0; 1933 break; 1934 } 1935 } else { 1936 switch(vc->vc_par[i]) { /* ANSI modes set/reset */ 1937 case 3: /* Monitor (display ctrls) */ 1938 vc->vc_disp_ctrl = on_off; 1939 break; 1940 case 4: /* Insert Mode on/off */ 1941 vc->vc_decim = on_off; 1942 break; 1943 case 20: /* Lf, Enter == CrLf/Lf */ 1944 if (on_off) 1945 set_kbd(vc, lnm); 1946 else 1947 clr_kbd(vc, lnm); 1948 break; 1949 } 1950 } 1951} 1952 1953/* console_lock is held */ 1954static void setterm_command(struct vc_data *vc) 1955{ 1956 switch (vc->vc_par[0]) { 1957 case 1: /* set color for underline mode */ 1958 if (vc->vc_can_do_color && vc->vc_par[1] < 16) { 1959 vc->vc_ulcolor = color_table[vc->vc_par[1]]; 1960 if (vc->state.underline) 1961 update_attr(vc); 1962 } 1963 break; 1964 case 2: /* set color for half intensity mode */ 1965 if (vc->vc_can_do_color && vc->vc_par[1] < 16) { 1966 vc->vc_halfcolor = color_table[vc->vc_par[1]]; 1967 if (vc->state.intensity == VCI_HALF_BRIGHT) 1968 update_attr(vc); 1969 } 1970 break; 1971 case 8: /* store colors as defaults */ 1972 vc->vc_def_color = vc->vc_attr; 1973 if (vc->vc_hi_font_mask == 0x100) 1974 vc->vc_def_color >>= 1; 1975 default_attr(vc); 1976 update_attr(vc); 1977 break; 1978 case 9: /* set blanking interval */ 1979 blankinterval = min(vc->vc_par[1], 60U) * 60; 1980 poke_blanked_console(); 1981 break; 1982 case 10: /* set bell frequency in Hz */ 1983 if (vc->vc_npar >= 1) 1984 vc->vc_bell_pitch = vc->vc_par[1]; 1985 else 1986 vc->vc_bell_pitch = DEFAULT_BELL_PITCH; 1987 break; 1988 case 11: /* set bell duration in msec */ 1989 if (vc->vc_npar >= 1) 1990 vc->vc_bell_duration = (vc->vc_par[1] < 2000) ? 1991 msecs_to_jiffies(vc->vc_par[1]) : 0; 1992 else 1993 vc->vc_bell_duration = DEFAULT_BELL_DURATION; 1994 break; 1995 case 12: /* bring specified console to the front */ 1996 if (vc->vc_par[1] >= 1 && vc_cons_allocated(vc->vc_par[1] - 1)) 1997 set_console(vc->vc_par[1] - 1); 1998 break; 1999 case 13: /* unblank the screen */ 2000 poke_blanked_console(); 2001 break; 2002 case 14: /* set vesa powerdown interval */ 2003 vesa_off_interval = min(vc->vc_par[1], 60U) * 60 * HZ; 2004 break; 2005 case 15: /* activate the previous console */ 2006 set_console(last_console); 2007 break; 2008 case 16: /* set cursor blink duration in msec */ 2009 if (vc->vc_npar >= 1 && vc->vc_par[1] >= 50 && 2010 vc->vc_par[1] <= USHRT_MAX) 2011 vc->vc_cur_blink_ms = vc->vc_par[1]; 2012 else 2013 vc->vc_cur_blink_ms = DEFAULT_CURSOR_BLINK_MS; 2014 break; 2015 } 2016} 2017 2018/* console_lock is held */ 2019static void csi_at(struct vc_data *vc, unsigned int nr) 2020{ 2021 if (nr > vc->vc_cols - vc->state.x) 2022 nr = vc->vc_cols - vc->state.x; 2023 else if (!nr) 2024 nr = 1; 2025 insert_char(vc, nr); 2026} 2027 2028/* console_lock is held */ 2029static void csi_L(struct vc_data *vc, unsigned int nr) 2030{ 2031 if (nr > vc->vc_rows - vc->state.y) 2032 nr = vc->vc_rows - vc->state.y; 2033 else if (!nr) 2034 nr = 1; 2035 con_scroll(vc, vc->state.y, vc->vc_bottom, SM_DOWN, nr); 2036 vc->vc_need_wrap = 0; 2037} 2038 2039/* console_lock is held */ 2040static void csi_P(struct vc_data *vc, unsigned int nr) 2041{ 2042 if (nr > vc->vc_cols - vc->state.x) 2043 nr = vc->vc_cols - vc->state.x; 2044 else if (!nr) 2045 nr = 1; 2046 delete_char(vc, nr); 2047} 2048 2049/* console_lock is held */ 2050static void csi_M(struct vc_data *vc, unsigned int nr) 2051{ 2052 if (nr > vc->vc_rows - vc->state.y) 2053 nr = vc->vc_rows - vc->state.y; 2054 else if (!nr) 2055 nr=1; 2056 con_scroll(vc, vc->state.y, vc->vc_bottom, SM_UP, nr); 2057 vc->vc_need_wrap = 0; 2058} 2059 2060/* console_lock is held (except via vc_init->reset_terminal */ 2061static void save_cur(struct vc_data *vc) 2062{ 2063 memcpy(&vc->saved_state, &vc->state, sizeof(vc->state)); 2064} 2065 2066/* console_lock is held */ 2067static void restore_cur(struct vc_data *vc) 2068{ 2069 memcpy(&vc->state, &vc->saved_state, sizeof(vc->state)); 2070 2071 gotoxy(vc, vc->state.x, vc->state.y); 2072 vc->vc_translate = set_translate(vc->state.Gx_charset[vc->state.charset], 2073 vc); 2074 update_attr(vc); 2075 vc->vc_need_wrap = 0; 2076} 2077 2078enum { ESnormal, ESesc, ESsquare, ESgetpars, ESfunckey, 2079 EShash, ESsetG0, ESsetG1, ESpercent, EScsiignore, ESnonstd, 2080 ESpalette, ESosc, ESapc, ESpm, ESdcs }; 2081 2082/* console_lock is held (except via vc_init()) */ 2083static void reset_terminal(struct vc_data *vc, int do_clear) 2084{ 2085 unsigned int i; 2086 2087 vc->vc_top = 0; 2088 vc->vc_bottom = vc->vc_rows; 2089 vc->vc_state = ESnormal; 2090 vc->vc_priv = EPecma; 2091 vc->vc_translate = set_translate(LAT1_MAP, vc); 2092 vc->state.Gx_charset[0] = LAT1_MAP; 2093 vc->state.Gx_charset[1] = GRAF_MAP; 2094 vc->state.charset = 0; 2095 vc->vc_need_wrap = 0; 2096 vc->vc_report_mouse = 0; 2097 vc->vc_utf = default_utf8; 2098 vc->vc_utf_count = 0; 2099 2100 vc->vc_disp_ctrl = 0; 2101 vc->vc_toggle_meta = 0; 2102 2103 vc->vc_decscnm = 0; 2104 vc->vc_decom = 0; 2105 vc->vc_decawm = 1; 2106 vc->vc_deccm = global_cursor_default; 2107 vc->vc_decim = 0; 2108 2109 vt_reset_keyboard(vc->vc_num); 2110 2111 vc->vc_cursor_type = cur_default; 2112 vc->vc_complement_mask = vc->vc_s_complement_mask; 2113 2114 default_attr(vc); 2115 update_attr(vc); 2116 2117 bitmap_zero(vc->vc_tab_stop, VC_TABSTOPS_COUNT); 2118 for (i = 0; i < VC_TABSTOPS_COUNT; i += 8) 2119 set_bit(i, vc->vc_tab_stop); 2120 2121 vc->vc_bell_pitch = DEFAULT_BELL_PITCH; 2122 vc->vc_bell_duration = DEFAULT_BELL_DURATION; 2123 vc->vc_cur_blink_ms = DEFAULT_CURSOR_BLINK_MS; 2124 2125 gotoxy(vc, 0, 0); 2126 save_cur(vc); 2127 if (do_clear) 2128 csi_J(vc, 2); 2129} 2130 2131static void vc_setGx(struct vc_data *vc, unsigned int which, int c) 2132{ 2133 unsigned char *charset = &vc->state.Gx_charset[which]; 2134 2135 switch (c) { 2136 case '0': 2137 *charset = GRAF_MAP; 2138 break; 2139 case 'B': 2140 *charset = LAT1_MAP; 2141 break; 2142 case 'U': 2143 *charset = IBMPC_MAP; 2144 break; 2145 case 'K': 2146 *charset = USER_MAP; 2147 break; 2148 } 2149 2150 if (vc->state.charset == which) 2151 vc->vc_translate = set_translate(*charset, vc); 2152} 2153 2154/* is this state an ANSI control string? */ 2155static bool ansi_control_string(unsigned int state) 2156{ 2157 if (state == ESosc || state == ESapc || state == ESpm || state == ESdcs) 2158 return true; 2159 return false; 2160} 2161 2162/* console_lock is held */ 2163static void do_con_trol(struct tty_struct *tty, struct vc_data *vc, int c) 2164{ 2165 /* 2166 * Control characters can be used in the _middle_ 2167 * of an escape sequence, aside from ANSI control strings. 2168 */ 2169 if (ansi_control_string(vc->vc_state) && c >= 8 && c <= 13) 2170 return; 2171 switch (c) { 2172 case 0: 2173 return; 2174 case 7: 2175 if (ansi_control_string(vc->vc_state)) 2176 vc->vc_state = ESnormal; 2177 else if (vc->vc_bell_duration) 2178 kd_mksound(vc->vc_bell_pitch, vc->vc_bell_duration); 2179 return; 2180 case 8: 2181 bs(vc); 2182 return; 2183 case 9: 2184 vc->vc_pos -= (vc->state.x << 1); 2185 2186 vc->state.x = find_next_bit(vc->vc_tab_stop, 2187 min(vc->vc_cols - 1, VC_TABSTOPS_COUNT), 2188 vc->state.x + 1); 2189 if (vc->state.x >= VC_TABSTOPS_COUNT) 2190 vc->state.x = vc->vc_cols - 1; 2191 2192 vc->vc_pos += (vc->state.x << 1); 2193 notify_write(vc, '\t'); 2194 return; 2195 case 10: case 11: case 12: 2196 lf(vc); 2197 if (!is_kbd(vc, lnm)) 2198 return; 2199 fallthrough; 2200 case 13: 2201 cr(vc); 2202 return; 2203 case 14: 2204 vc->state.charset = 1; 2205 vc->vc_translate = set_translate(vc->state.Gx_charset[1], vc); 2206 vc->vc_disp_ctrl = 1; 2207 return; 2208 case 15: 2209 vc->state.charset = 0; 2210 vc->vc_translate = set_translate(vc->state.Gx_charset[0], vc); 2211 vc->vc_disp_ctrl = 0; 2212 return; 2213 case 24: case 26: 2214 vc->vc_state = ESnormal; 2215 return; 2216 case 27: 2217 vc->vc_state = ESesc; 2218 return; 2219 case 127: 2220 del(vc); 2221 return; 2222 case 128+27: 2223 vc->vc_state = ESsquare; 2224 return; 2225 } 2226 switch(vc->vc_state) { 2227 case ESesc: 2228 vc->vc_state = ESnormal; 2229 switch (c) { 2230 case '[': 2231 vc->vc_state = ESsquare; 2232 return; 2233 case ']': 2234 vc->vc_state = ESnonstd; 2235 return; 2236 case '_': 2237 vc->vc_state = ESapc; 2238 return; 2239 case '^': 2240 vc->vc_state = ESpm; 2241 return; 2242 case '%': 2243 vc->vc_state = ESpercent; 2244 return; 2245 case 'E': 2246 cr(vc); 2247 lf(vc); 2248 return; 2249 case 'M': 2250 ri(vc); 2251 return; 2252 case 'D': 2253 lf(vc); 2254 return; 2255 case 'H': 2256 if (vc->state.x < VC_TABSTOPS_COUNT) 2257 set_bit(vc->state.x, vc->vc_tab_stop); 2258 return; 2259 case 'P': 2260 vc->vc_state = ESdcs; 2261 return; 2262 case 'Z': 2263 respond_ID(tty); 2264 return; 2265 case '7': 2266 save_cur(vc); 2267 return; 2268 case '8': 2269 restore_cur(vc); 2270 return; 2271 case '(': 2272 vc->vc_state = ESsetG0; 2273 return; 2274 case ')': 2275 vc->vc_state = ESsetG1; 2276 return; 2277 case '#': 2278 vc->vc_state = EShash; 2279 return; 2280 case 'c': 2281 reset_terminal(vc, 1); 2282 return; 2283 case '>': /* Numeric keypad */ 2284 clr_kbd(vc, kbdapplic); 2285 return; 2286 case '=': /* Appl. keypad */ 2287 set_kbd(vc, kbdapplic); 2288 return; 2289 } 2290 return; 2291 case ESnonstd: 2292 if (c=='P') { /* palette escape sequence */ 2293 for (vc->vc_npar = 0; vc->vc_npar < NPAR; vc->vc_npar++) 2294 vc->vc_par[vc->vc_npar] = 0; 2295 vc->vc_npar = 0; 2296 vc->vc_state = ESpalette; 2297 return; 2298 } else if (c=='R') { /* reset palette */ 2299 reset_palette(vc); 2300 vc->vc_state = ESnormal; 2301 } else if (c>='0' && c<='9') 2302 vc->vc_state = ESosc; 2303 else 2304 vc->vc_state = ESnormal; 2305 return; 2306 case ESpalette: 2307 if (isxdigit(c)) { 2308 vc->vc_par[vc->vc_npar++] = hex_to_bin(c); 2309 if (vc->vc_npar == 7) { 2310 int i = vc->vc_par[0] * 3, j = 1; 2311 vc->vc_palette[i] = 16 * vc->vc_par[j++]; 2312 vc->vc_palette[i++] += vc->vc_par[j++]; 2313 vc->vc_palette[i] = 16 * vc->vc_par[j++]; 2314 vc->vc_palette[i++] += vc->vc_par[j++]; 2315 vc->vc_palette[i] = 16 * vc->vc_par[j++]; 2316 vc->vc_palette[i] += vc->vc_par[j]; 2317 set_palette(vc); 2318 vc->vc_state = ESnormal; 2319 } 2320 } else 2321 vc->vc_state = ESnormal; 2322 return; 2323 case ESsquare: 2324 for (vc->vc_npar = 0; vc->vc_npar < NPAR; vc->vc_npar++) 2325 vc->vc_par[vc->vc_npar] = 0; 2326 vc->vc_npar = 0; 2327 vc->vc_state = ESgetpars; 2328 if (c == '[') { /* Function key */ 2329 vc->vc_state=ESfunckey; 2330 return; 2331 } 2332 switch (c) { 2333 case '?': 2334 vc->vc_priv = EPdec; 2335 return; 2336 case '>': 2337 vc->vc_priv = EPgt; 2338 return; 2339 case '=': 2340 vc->vc_priv = EPeq; 2341 return; 2342 case '<': 2343 vc->vc_priv = EPlt; 2344 return; 2345 } 2346 vc->vc_priv = EPecma; 2347 fallthrough; 2348 case ESgetpars: 2349 if (c == ';' && vc->vc_npar < NPAR - 1) { 2350 vc->vc_npar++; 2351 return; 2352 } else if (c>='0' && c<='9') { 2353 vc->vc_par[vc->vc_npar] *= 10; 2354 vc->vc_par[vc->vc_npar] += c - '0'; 2355 return; 2356 } 2357 if (c >= 0x20 && c <= 0x3f) { /* 0x2x, 0x3a and 0x3c - 0x3f */ 2358 vc->vc_state = EScsiignore; 2359 return; 2360 } 2361 vc->vc_state = ESnormal; 2362 switch(c) { 2363 case 'h': 2364 if (vc->vc_priv <= EPdec) 2365 set_mode(vc, 1); 2366 return; 2367 case 'l': 2368 if (vc->vc_priv <= EPdec) 2369 set_mode(vc, 0); 2370 return; 2371 case 'c': 2372 if (vc->vc_priv == EPdec) { 2373 if (vc->vc_par[0]) 2374 vc->vc_cursor_type = 2375 CUR_MAKE(vc->vc_par[0], 2376 vc->vc_par[1], 2377 vc->vc_par[2]); 2378 else 2379 vc->vc_cursor_type = cur_default; 2380 return; 2381 } 2382 break; 2383 case 'm': 2384 if (vc->vc_priv == EPdec) { 2385 clear_selection(); 2386 if (vc->vc_par[0]) 2387 vc->vc_complement_mask = vc->vc_par[0] << 8 | vc->vc_par[1]; 2388 else 2389 vc->vc_complement_mask = vc->vc_s_complement_mask; 2390 return; 2391 } 2392 break; 2393 case 'n': 2394 if (vc->vc_priv == EPecma) { 2395 if (vc->vc_par[0] == 5) 2396 status_report(tty); 2397 else if (vc->vc_par[0] == 6) 2398 cursor_report(vc, tty); 2399 } 2400 return; 2401 } 2402 if (vc->vc_priv != EPecma) { 2403 vc->vc_priv = EPecma; 2404 return; 2405 } 2406 switch(c) { 2407 case 'G': case '`': 2408 if (vc->vc_par[0]) 2409 vc->vc_par[0]--; 2410 gotoxy(vc, vc->vc_par[0], vc->state.y); 2411 return; 2412 case 'A': 2413 if (!vc->vc_par[0]) 2414 vc->vc_par[0]++; 2415 gotoxy(vc, vc->state.x, vc->state.y - vc->vc_par[0]); 2416 return; 2417 case 'B': case 'e': 2418 if (!vc->vc_par[0]) 2419 vc->vc_par[0]++; 2420 gotoxy(vc, vc->state.x, vc->state.y + vc->vc_par[0]); 2421 return; 2422 case 'C': case 'a': 2423 if (!vc->vc_par[0]) 2424 vc->vc_par[0]++; 2425 gotoxy(vc, vc->state.x + vc->vc_par[0], vc->state.y); 2426 return; 2427 case 'D': 2428 if (!vc->vc_par[0]) 2429 vc->vc_par[0]++; 2430 gotoxy(vc, vc->state.x - vc->vc_par[0], vc->state.y); 2431 return; 2432 case 'E': 2433 if (!vc->vc_par[0]) 2434 vc->vc_par[0]++; 2435 gotoxy(vc, 0, vc->state.y + vc->vc_par[0]); 2436 return; 2437 case 'F': 2438 if (!vc->vc_par[0]) 2439 vc->vc_par[0]++; 2440 gotoxy(vc, 0, vc->state.y - vc->vc_par[0]); 2441 return; 2442 case 'd': 2443 if (vc->vc_par[0]) 2444 vc->vc_par[0]--; 2445 gotoxay(vc, vc->state.x ,vc->vc_par[0]); 2446 return; 2447 case 'H': case 'f': 2448 if (vc->vc_par[0]) 2449 vc->vc_par[0]--; 2450 if (vc->vc_par[1]) 2451 vc->vc_par[1]--; 2452 gotoxay(vc, vc->vc_par[1], vc->vc_par[0]); 2453 return; 2454 case 'J': 2455 csi_J(vc, vc->vc_par[0]); 2456 return; 2457 case 'K': 2458 csi_K(vc, vc->vc_par[0]); 2459 return; 2460 case 'L': 2461 csi_L(vc, vc->vc_par[0]); 2462 return; 2463 case 'M': 2464 csi_M(vc, vc->vc_par[0]); 2465 return; 2466 case 'P': 2467 csi_P(vc, vc->vc_par[0]); 2468 return; 2469 case 'c': 2470 if (!vc->vc_par[0]) 2471 respond_ID(tty); 2472 return; 2473 case 'g': 2474 if (!vc->vc_par[0] && vc->state.x < VC_TABSTOPS_COUNT) 2475 set_bit(vc->state.x, vc->vc_tab_stop); 2476 else if (vc->vc_par[0] == 3) 2477 bitmap_zero(vc->vc_tab_stop, VC_TABSTOPS_COUNT); 2478 return; 2479 case 'm': 2480 csi_m(vc); 2481 return; 2482 case 'q': /* DECLL - but only 3 leds */ 2483 /* map 0,1,2,3 to 0,1,2,4 */ 2484 if (vc->vc_par[0] < 4) 2485 vt_set_led_state(vc->vc_num, 2486 (vc->vc_par[0] < 3) ? vc->vc_par[0] : 4); 2487 return; 2488 case 'r': 2489 if (!vc->vc_par[0]) 2490 vc->vc_par[0]++; 2491 if (!vc->vc_par[1]) 2492 vc->vc_par[1] = vc->vc_rows; 2493 /* Minimum allowed region is 2 lines */ 2494 if (vc->vc_par[0] < vc->vc_par[1] && 2495 vc->vc_par[1] <= vc->vc_rows) { 2496 vc->vc_top = vc->vc_par[0] - 1; 2497 vc->vc_bottom = vc->vc_par[1]; 2498 gotoxay(vc, 0, 0); 2499 } 2500 return; 2501 case 's': 2502 save_cur(vc); 2503 return; 2504 case 'u': 2505 restore_cur(vc); 2506 return; 2507 case 'X': 2508 csi_X(vc, vc->vc_par[0]); 2509 return; 2510 case '@': 2511 csi_at(vc, vc->vc_par[0]); 2512 return; 2513 case ']': /* setterm functions */ 2514 setterm_command(vc); 2515 return; 2516 } 2517 return; 2518 case EScsiignore: 2519 if (c >= 20 && c <= 0x3f) 2520 return; 2521 vc->vc_state = ESnormal; 2522 return; 2523 case ESpercent: 2524 vc->vc_state = ESnormal; 2525 switch (c) { 2526 case '@': /* defined in ISO 2022 */ 2527 vc->vc_utf = 0; 2528 return; 2529 case 'G': /* prelim official escape code */ 2530 case '8': /* retained for compatibility */ 2531 vc->vc_utf = 1; 2532 return; 2533 } 2534 return; 2535 case ESfunckey: 2536 vc->vc_state = ESnormal; 2537 return; 2538 case EShash: 2539 vc->vc_state = ESnormal; 2540 if (c == '8') { 2541 /* DEC screen alignment test. kludge :-) */ 2542 vc->vc_video_erase_char = 2543 (vc->vc_video_erase_char & 0xff00) | 'E'; 2544 csi_J(vc, 2); 2545 vc->vc_video_erase_char = 2546 (vc->vc_video_erase_char & 0xff00) | ' '; 2547 do_update_region(vc, vc->vc_origin, vc->vc_screenbuf_size / 2); 2548 } 2549 return; 2550 case ESsetG0: 2551 vc_setGx(vc, 0, c); 2552 vc->vc_state = ESnormal; 2553 return; 2554 case ESsetG1: 2555 vc_setGx(vc, 1, c); 2556 vc->vc_state = ESnormal; 2557 return; 2558 case ESapc: 2559 return; 2560 case ESosc: 2561 return; 2562 case ESpm: 2563 return; 2564 case ESdcs: 2565 return; 2566 default: 2567 vc->vc_state = ESnormal; 2568 } 2569} 2570 2571/* is_double_width() is based on the wcwidth() implementation by 2572 * Markus Kuhn -- 2007-05-26 (Unicode 5.0) 2573 * Latest version: https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c 2574 */ 2575struct interval { 2576 uint32_t first; 2577 uint32_t last; 2578}; 2579 2580static int ucs_cmp(const void *key, const void *elt) 2581{ 2582 uint32_t ucs = *(uint32_t *)key; 2583 struct interval e = *(struct interval *) elt; 2584 2585 if (ucs > e.last) 2586 return 1; 2587 else if (ucs < e.first) 2588 return -1; 2589 return 0; 2590} 2591 2592static int is_double_width(uint32_t ucs) 2593{ 2594 static const struct interval double_width[] = { 2595 { 0x1100, 0x115F }, { 0x2329, 0x232A }, { 0x2E80, 0x303E }, 2596 { 0x3040, 0xA4CF }, { 0xAC00, 0xD7A3 }, { 0xF900, 0xFAFF }, 2597 { 0xFE10, 0xFE19 }, { 0xFE30, 0xFE6F }, { 0xFF00, 0xFF60 }, 2598 { 0xFFE0, 0xFFE6 }, { 0x20000, 0x2FFFD }, { 0x30000, 0x3FFFD } 2599 }; 2600 if (ucs < double_width[0].first || 2601 ucs > double_width[ARRAY_SIZE(double_width) - 1].last) 2602 return 0; 2603 2604 return bsearch(&ucs, double_width, ARRAY_SIZE(double_width), 2605 sizeof(struct interval), ucs_cmp) != NULL; 2606} 2607 2608struct vc_draw_region { 2609 unsigned long from, to; 2610 int x; 2611}; 2612 2613static void con_flush(struct vc_data *vc, struct vc_draw_region *draw) 2614{ 2615 if (draw->x < 0) 2616 return; 2617 2618 vc->vc_sw->con_putcs(vc, (u16 *)draw->from, 2619 (u16 *)draw->to - (u16 *)draw->from, vc->state.y, 2620 draw->x); 2621 draw->x = -1; 2622} 2623 2624static inline int vc_translate_ascii(const struct vc_data *vc, int c) 2625{ 2626 if (IS_ENABLED(CONFIG_CONSOLE_TRANSLATIONS)) { 2627 if (vc->vc_toggle_meta) 2628 c |= 0x80; 2629 2630 return vc->vc_translate[c]; 2631 } 2632 2633 return c; 2634} 2635 2636 2637/** 2638 * vc_sanitize_unicode -- Replace invalid Unicode code points with U+FFFD 2639 * @c: the received character, or U+FFFD for invalid sequences. 2640 */ 2641static inline int vc_sanitize_unicode(const int c) 2642{ 2643 if ((c >= 0xd800 && c <= 0xdfff) || c == 0xfffe || c == 0xffff) 2644 return 0xfffd; 2645 2646 return c; 2647} 2648 2649/** 2650 * vc_translate_unicode -- Combine UTF-8 into Unicode in @vc_utf_char 2651 * @vc: virtual console 2652 * @c: character to translate 2653 * @rescan: we return true if we need more (continuation) data 2654 * 2655 * @vc_utf_char is the being-constructed unicode character. 2656 * @vc_utf_count is the number of continuation bytes still expected to arrive. 2657 * @vc_npar is the number of continuation bytes arrived so far. 2658 */ 2659static int vc_translate_unicode(struct vc_data *vc, int c, bool *rescan) 2660{ 2661 static const u32 utf8_length_changes[] = { 2662 0x0000007f, 0x000007ff, 0x0000ffff, 2663 0x001fffff, 0x03ffffff, 0x7fffffff 2664 }; 2665 2666 /* Continuation byte received */ 2667 if ((c & 0xc0) == 0x80) { 2668 /* Unexpected continuation byte? */ 2669 if (!vc->vc_utf_count) 2670 return 0xfffd; 2671 2672 vc->vc_utf_char = (vc->vc_utf_char << 6) | (c & 0x3f); 2673 vc->vc_npar++; 2674 if (--vc->vc_utf_count) 2675 goto need_more_bytes; 2676 2677 /* Got a whole character */ 2678 c = vc->vc_utf_char; 2679 /* Reject overlong sequences */ 2680 if (c <= utf8_length_changes[vc->vc_npar - 1] || 2681 c > utf8_length_changes[vc->vc_npar]) 2682 return 0xfffd; 2683 2684 return vc_sanitize_unicode(c); 2685 } 2686 2687 /* Single ASCII byte or first byte of a sequence received */ 2688 if (vc->vc_utf_count) { 2689 /* Continuation byte expected */ 2690 *rescan = true; 2691 vc->vc_utf_count = 0; 2692 return 0xfffd; 2693 } 2694 2695 /* Nothing to do if an ASCII byte was received */ 2696 if (c <= 0x7f) 2697 return c; 2698 2699 /* First byte of a multibyte sequence received */ 2700 vc->vc_npar = 0; 2701 if ((c & 0xe0) == 0xc0) { 2702 vc->vc_utf_count = 1; 2703 vc->vc_utf_char = (c & 0x1f); 2704 } else if ((c & 0xf0) == 0xe0) { 2705 vc->vc_utf_count = 2; 2706 vc->vc_utf_char = (c & 0x0f); 2707 } else if ((c & 0xf8) == 0xf0) { 2708 vc->vc_utf_count = 3; 2709 vc->vc_utf_char = (c & 0x07); 2710 } else if ((c & 0xfc) == 0xf8) { 2711 vc->vc_utf_count = 4; 2712 vc->vc_utf_char = (c & 0x03); 2713 } else if ((c & 0xfe) == 0xfc) { 2714 vc->vc_utf_count = 5; 2715 vc->vc_utf_char = (c & 0x01); 2716 } else { 2717 /* 254 and 255 are invalid */ 2718 return 0xfffd; 2719 } 2720 2721need_more_bytes: 2722 return -1; 2723} 2724 2725static int vc_translate(struct vc_data *vc, int *c, bool *rescan) 2726{ 2727 /* Do no translation at all in control states */ 2728 if (vc->vc_state != ESnormal) 2729 return *c; 2730 2731 if (vc->vc_utf && !vc->vc_disp_ctrl) 2732 return *c = vc_translate_unicode(vc, *c, rescan); 2733 2734 /* no utf or alternate charset mode */ 2735 return vc_translate_ascii(vc, *c); 2736} 2737 2738static inline unsigned char vc_invert_attr(const struct vc_data *vc) 2739{ 2740 if (!vc->vc_can_do_color) 2741 return vc->vc_attr ^ 0x08; 2742 2743 if (vc->vc_hi_font_mask == 0x100) 2744 return (vc->vc_attr & 0x11) | 2745 ((vc->vc_attr & 0xe0) >> 4) | 2746 ((vc->vc_attr & 0x0e) << 4); 2747 2748 return (vc->vc_attr & 0x88) | 2749 ((vc->vc_attr & 0x70) >> 4) | 2750 ((vc->vc_attr & 0x07) << 4); 2751} 2752 2753static bool vc_is_control(struct vc_data *vc, int tc, int c) 2754{ 2755 /* 2756 * A bitmap for codes <32. A bit of 1 indicates that the code 2757 * corresponding to that bit number invokes some special action (such 2758 * as cursor movement) and should not be displayed as a glyph unless 2759 * the disp_ctrl mode is explicitly enabled. 2760 */ 2761 static const u32 CTRL_ACTION = 0x0d00ff81; 2762 /* Cannot be overridden by disp_ctrl */ 2763 static const u32 CTRL_ALWAYS = 0x0800f501; 2764 2765 if (vc->vc_state != ESnormal) 2766 return true; 2767 2768 if (!tc) 2769 return true; 2770 2771 /* 2772 * If the original code was a control character we only allow a glyph 2773 * to be displayed if the code is not normally used (such as for cursor 2774 * movement) or if the disp_ctrl mode has been explicitly enabled. 2775 * Certain characters (as given by the CTRL_ALWAYS bitmap) are always 2776 * displayed as control characters, as the console would be pretty 2777 * useless without them; to display an arbitrary font position use the 2778 * direct-to-font zone in UTF-8 mode. 2779 */ 2780 if (c < 32) { 2781 if (vc->vc_disp_ctrl) 2782 return CTRL_ALWAYS & BIT(c); 2783 else 2784 return vc->vc_utf || (CTRL_ACTION & BIT(c)); 2785 } 2786 2787 if (c == 127 && !vc->vc_disp_ctrl) 2788 return true; 2789 2790 if (c == 128 + 27) 2791 return true; 2792 2793 return false; 2794} 2795 2796static int vc_con_write_normal(struct vc_data *vc, int tc, int c, 2797 struct vc_draw_region *draw) 2798{ 2799 int next_c; 2800 unsigned char vc_attr = vc->vc_attr; 2801 u16 himask = vc->vc_hi_font_mask, charmask = himask ? 0x1ff : 0xff; 2802 u8 width = 1; 2803 bool inverse = false; 2804 2805 if (vc->vc_utf && !vc->vc_disp_ctrl) { 2806 if (is_double_width(c)) 2807 width = 2; 2808 } 2809 2810 /* Now try to find out how to display it */ 2811 tc = conv_uni_to_pc(vc, tc); 2812 if (tc & ~charmask) { 2813 if (tc == -1 || tc == -2) 2814 return -1; /* nothing to display */ 2815 2816 /* Glyph not found */ 2817 if ((!vc->vc_utf || vc->vc_disp_ctrl || c < 128) && 2818 !(c & ~charmask)) { 2819 /* 2820 * In legacy mode use the glyph we get by a 1:1 2821 * mapping. 2822 * This would make absolutely no sense with Unicode in 2823 * mind, but do this for ASCII characters since a font 2824 * may lack Unicode mapping info and we don't want to 2825 * end up with having question marks only. 2826 */ 2827 tc = c; 2828 } else { 2829 /* 2830 * Display U+FFFD. If it's not found, display an inverse 2831 * question mark. 2832 */ 2833 tc = conv_uni_to_pc(vc, 0xfffd); 2834 if (tc < 0) { 2835 inverse = true; 2836 tc = conv_uni_to_pc(vc, '?'); 2837 if (tc < 0) 2838 tc = '?'; 2839 2840 vc_attr = vc_invert_attr(vc); 2841 con_flush(vc, draw); 2842 } 2843 } 2844 } 2845 2846 next_c = c; 2847 while (1) { 2848 if (vc->vc_need_wrap || vc->vc_decim) 2849 con_flush(vc, draw); 2850 if (vc->vc_need_wrap) { 2851 cr(vc); 2852 lf(vc); 2853 } 2854 if (vc->vc_decim) 2855 insert_char(vc, 1); 2856 vc_uniscr_putc(vc, next_c); 2857 2858 if (himask) 2859 tc = ((tc & 0x100) ? himask : 0) | 2860 (tc & 0xff); 2861 tc |= (vc_attr << 8) & ~himask; 2862 2863 scr_writew(tc, (u16 *)vc->vc_pos); 2864 2865 if (con_should_update(vc) && draw->x < 0) { 2866 draw->x = vc->state.x; 2867 draw->from = vc->vc_pos; 2868 } 2869 if (vc->state.x == vc->vc_cols - 1) { 2870 vc->vc_need_wrap = vc->vc_decawm; 2871 draw->to = vc->vc_pos + 2; 2872 } else { 2873 vc->state.x++; 2874 draw->to = (vc->vc_pos += 2); 2875 } 2876 2877 if (!--width) 2878 break; 2879 2880 /* A space is printed in the second column */ 2881 tc = conv_uni_to_pc(vc, ' '); 2882 if (tc < 0) 2883 tc = ' '; 2884 next_c = ' '; 2885 } 2886 notify_write(vc, c); 2887 2888 if (inverse) 2889 con_flush(vc, draw); 2890 2891 return 0; 2892} 2893 2894/* acquires console_lock */ 2895static int do_con_write(struct tty_struct *tty, const unsigned char *buf, int count) 2896{ 2897 struct vc_draw_region draw = { 2898 .x = -1, 2899 }; 2900 int c, tc, n = 0; 2901 unsigned int currcons; 2902 struct vc_data *vc; 2903 struct vt_notifier_param param; 2904 bool rescan; 2905 2906 if (in_interrupt()) 2907 return count; 2908 2909 console_lock(); 2910 vc = tty->driver_data; 2911 if (vc == NULL) { 2912 pr_err("vt: argh, driver_data is NULL !\n"); 2913 console_unlock(); 2914 return 0; 2915 } 2916 2917 currcons = vc->vc_num; 2918 if (!vc_cons_allocated(currcons)) { 2919 /* could this happen? */ 2920 pr_warn_once("con_write: tty %d not allocated\n", currcons+1); 2921 console_unlock(); 2922 return 0; 2923 } 2924 2925 2926 /* undraw cursor first */ 2927 if (con_is_fg(vc)) 2928 hide_cursor(vc); 2929 2930 param.vc = vc; 2931 2932 while (!tty->stopped && count) { 2933 int orig = *buf; 2934 buf++; 2935 n++; 2936 count--; 2937rescan_last_byte: 2938 c = orig; 2939 rescan = false; 2940 2941 tc = vc_translate(vc, &c, &rescan); 2942 if (tc == -1) 2943 continue; 2944 2945 param.c = tc; 2946 if (atomic_notifier_call_chain(&vt_notifier_list, VT_PREWRITE, 2947 ¶m) == NOTIFY_STOP) 2948 continue; 2949 2950 if (vc_is_control(vc, tc, c)) { 2951 con_flush(vc, &draw); 2952 do_con_trol(tty, vc, orig); 2953 continue; 2954 } 2955 2956 if (vc_con_write_normal(vc, tc, c, &draw) < 0) 2957 continue; 2958 2959 if (rescan) 2960 goto rescan_last_byte; 2961 } 2962 con_flush(vc, &draw); 2963 vc_uniscr_debug_check(vc); 2964 console_conditional_schedule(); 2965 notify_update(vc); 2966 console_unlock(); 2967 return n; 2968} 2969 2970/* 2971 * This is the console switching callback. 2972 * 2973 * Doing console switching in a process context allows 2974 * us to do the switches asynchronously (needed when we want 2975 * to switch due to a keyboard interrupt). Synchronization 2976 * with other console code and prevention of re-entrancy is 2977 * ensured with console_lock. 2978 */ 2979static void console_callback(struct work_struct *ignored) 2980{ 2981 console_lock(); 2982 2983 if (want_console >= 0) { 2984 if (want_console != fg_console && 2985 vc_cons_allocated(want_console)) { 2986 hide_cursor(vc_cons[fg_console].d); 2987 change_console(vc_cons[want_console].d); 2988 /* we only changed when the console had already 2989 been allocated - a new console is not created 2990 in an interrupt routine */ 2991 } 2992 want_console = -1; 2993 } 2994 if (do_poke_blanked_console) { /* do not unblank for a LED change */ 2995 do_poke_blanked_console = 0; 2996 poke_blanked_console(); 2997 } 2998 if (scrollback_delta) { 2999 struct vc_data *vc = vc_cons[fg_console].d; 3000 clear_selection(); 3001 if (vc->vc_mode == KD_TEXT && vc->vc_sw->con_scrolldelta) 3002 vc->vc_sw->con_scrolldelta(vc, scrollback_delta); 3003 scrollback_delta = 0; 3004 } 3005 if (blank_timer_expired) { 3006 do_blank_screen(0); 3007 blank_timer_expired = 0; 3008 } 3009 notify_update(vc_cons[fg_console].d); 3010 3011 console_unlock(); 3012} 3013 3014int set_console(int nr) 3015{ 3016 struct vc_data *vc = vc_cons[fg_console].d; 3017 3018 if (!vc_cons_allocated(nr) || vt_dont_switch || 3019 (vc->vt_mode.mode == VT_AUTO && vc->vc_mode == KD_GRAPHICS)) { 3020 3021 /* 3022 * Console switch will fail in console_callback() or 3023 * change_console() so there is no point scheduling 3024 * the callback 3025 * 3026 * Existing set_console() users don't check the return 3027 * value so this shouldn't break anything 3028 */ 3029 return -EINVAL; 3030 } 3031 3032 want_console = nr; 3033 schedule_console_callback(); 3034 3035 return 0; 3036} 3037 3038struct tty_driver *console_driver; 3039 3040#ifdef CONFIG_VT_CONSOLE 3041 3042/** 3043 * vt_kmsg_redirect() - Sets/gets the kernel message console 3044 * @new: The new virtual terminal number or -1 if the console should stay 3045 * unchanged 3046 * 3047 * By default, the kernel messages are always printed on the current virtual 3048 * console. However, the user may modify that default with the 3049 * TIOCL_SETKMSGREDIRECT ioctl call. 3050 * 3051 * This function sets the kernel message console to be @new. It returns the old 3052 * virtual console number. The virtual terminal number 0 (both as parameter and 3053 * return value) means no redirection (i.e. always printed on the currently 3054 * active console). 3055 * 3056 * The parameter -1 means that only the current console is returned, but the 3057 * value is not modified. You may use the macro vt_get_kmsg_redirect() in that 3058 * case to make the code more understandable. 3059 * 3060 * When the kernel is compiled without CONFIG_VT_CONSOLE, this function ignores 3061 * the parameter and always returns 0. 3062 */ 3063int vt_kmsg_redirect(int new) 3064{ 3065 static int kmsg_con; 3066 3067 if (new != -1) 3068 return xchg(&kmsg_con, new); 3069 else 3070 return kmsg_con; 3071} 3072 3073/* 3074 * Console on virtual terminal 3075 * 3076 * The console must be locked when we get here. 3077 */ 3078 3079static void vt_console_print(struct console *co, const char *b, unsigned count) 3080{ 3081 struct vc_data *vc = vc_cons[fg_console].d; 3082 unsigned char c; 3083 static DEFINE_SPINLOCK(printing_lock); 3084 const ushort *start; 3085 ushort start_x, cnt; 3086 int kmsg_console; 3087 3088 /* console busy or not yet initialized */ 3089 if (!printable) 3090 return; 3091 if (!spin_trylock(&printing_lock)) 3092 return; 3093 3094 kmsg_console = vt_get_kmsg_redirect(); 3095 if (kmsg_console && vc_cons_allocated(kmsg_console - 1)) 3096 vc = vc_cons[kmsg_console - 1].d; 3097 3098 if (!vc_cons_allocated(fg_console)) { 3099 /* impossible */ 3100 /* printk("vt_console_print: tty %d not allocated ??\n", currcons+1); */ 3101 goto quit; 3102 } 3103 3104 if (vc->vc_mode != KD_TEXT) 3105 goto quit; 3106 3107 /* undraw cursor first */ 3108 if (con_is_fg(vc)) 3109 hide_cursor(vc); 3110 3111 start = (ushort *)vc->vc_pos; 3112 start_x = vc->state.x; 3113 cnt = 0; 3114 while (count--) { 3115 c = *b++; 3116 if (c == 10 || c == 13 || c == 8 || vc->vc_need_wrap) { 3117 if (cnt && con_is_visible(vc)) 3118 vc->vc_sw->con_putcs(vc, start, cnt, vc->state.y, start_x); 3119 cnt = 0; 3120 if (c == 8) { /* backspace */ 3121 bs(vc); 3122 start = (ushort *)vc->vc_pos; 3123 start_x = vc->state.x; 3124 continue; 3125 } 3126 if (c != 13) 3127 lf(vc); 3128 cr(vc); 3129 start = (ushort *)vc->vc_pos; 3130 start_x = vc->state.x; 3131 if (c == 10 || c == 13) 3132 continue; 3133 } 3134 vc_uniscr_putc(vc, c); 3135 scr_writew((vc->vc_attr << 8) + c, (unsigned short *)vc->vc_pos); 3136 notify_write(vc, c); 3137 cnt++; 3138 if (vc->state.x == vc->vc_cols - 1) { 3139 vc->vc_need_wrap = 1; 3140 } else { 3141 vc->vc_pos += 2; 3142 vc->state.x++; 3143 } 3144 } 3145 if (cnt && con_is_visible(vc)) 3146 vc->vc_sw->con_putcs(vc, start, cnt, vc->state.y, start_x); 3147 set_cursor(vc); 3148 notify_update(vc); 3149 3150quit: 3151 spin_unlock(&printing_lock); 3152} 3153 3154static struct tty_driver *vt_console_device(struct console *c, int *index) 3155{ 3156 *index = c->index ? c->index-1 : fg_console; 3157 return console_driver; 3158} 3159 3160static struct console vt_console_driver = { 3161 .name = "tty", 3162 .write = vt_console_print, 3163 .device = vt_console_device, 3164 .unblank = unblank_screen, 3165 .flags = CON_PRINTBUFFER, 3166 .index = -1, 3167}; 3168#endif 3169 3170/* 3171 * Handling of Linux-specific VC ioctls 3172 */ 3173 3174/* 3175 * Generally a bit racy with respect to console_lock();. 3176 * 3177 * There are some functions which don't need it. 3178 * 3179 * There are some functions which can sleep for arbitrary periods 3180 * (paste_selection) but we don't need the lock there anyway. 3181 * 3182 * set_selection_user has locking, and definitely needs it 3183 */ 3184 3185int tioclinux(struct tty_struct *tty, unsigned long arg) 3186{ 3187 char type, data; 3188 char __user *p = (char __user *)arg; 3189 int lines; 3190 int ret; 3191 3192 if (current->signal->tty != tty && !capable(CAP_SYS_ADMIN)) 3193 return -EPERM; 3194 if (get_user(type, p)) 3195 return -EFAULT; 3196 ret = 0; 3197 3198 switch (type) 3199 { 3200 case TIOCL_SETSEL: 3201 ret = set_selection_user((struct tiocl_selection 3202 __user *)(p+1), tty); 3203 break; 3204 case TIOCL_PASTESEL: 3205 ret = paste_selection(tty); 3206 break; 3207 case TIOCL_UNBLANKSCREEN: 3208 console_lock(); 3209 unblank_screen(); 3210 console_unlock(); 3211 break; 3212 case TIOCL_SELLOADLUT: 3213 console_lock(); 3214 ret = sel_loadlut(p); 3215 console_unlock(); 3216 break; 3217 case TIOCL_GETSHIFTSTATE: 3218 3219 /* 3220 * Make it possible to react to Shift+Mousebutton. 3221 * Note that 'shift_state' is an undocumented 3222 * kernel-internal variable; programs not closely 3223 * related to the kernel should not use this. 3224 */ 3225 data = vt_get_shift_state(); 3226 ret = put_user(data, p); 3227 break; 3228 case TIOCL_GETMOUSEREPORTING: 3229 console_lock(); /* May be overkill */ 3230 data = mouse_reporting(); 3231 console_unlock(); 3232 ret = put_user(data, p); 3233 break; 3234 case TIOCL_SETVESABLANK: 3235 console_lock(); 3236 ret = set_vesa_blanking(p); 3237 console_unlock(); 3238 break; 3239 case TIOCL_GETKMSGREDIRECT: 3240 data = vt_get_kmsg_redirect(); 3241 ret = put_user(data, p); 3242 break; 3243 case TIOCL_SETKMSGREDIRECT: 3244 if (!capable(CAP_SYS_ADMIN)) { 3245 ret = -EPERM; 3246 } else { 3247 if (get_user(data, p+1)) 3248 ret = -EFAULT; 3249 else 3250 vt_kmsg_redirect(data); 3251 } 3252 break; 3253 case TIOCL_GETFGCONSOLE: 3254 /* No locking needed as this is a transiently 3255 correct return anyway if the caller hasn't 3256 disabled switching */ 3257 ret = fg_console; 3258 break; 3259 case TIOCL_SCROLLCONSOLE: 3260 if (get_user(lines, (s32 __user *)(p+4))) { 3261 ret = -EFAULT; 3262 } else { 3263 /* Need the console lock here. Note that lots 3264 of other calls need fixing before the lock 3265 is actually useful ! */ 3266 console_lock(); 3267 scrollfront(vc_cons[fg_console].d, lines); 3268 console_unlock(); 3269 ret = 0; 3270 } 3271 break; 3272 case TIOCL_BLANKSCREEN: /* until explicitly unblanked, not only poked */ 3273 console_lock(); 3274 ignore_poke = 1; 3275 do_blank_screen(0); 3276 console_unlock(); 3277 break; 3278 case TIOCL_BLANKEDSCREEN: 3279 ret = console_blanked; 3280 break; 3281 default: 3282 ret = -EINVAL; 3283 break; 3284 } 3285 return ret; 3286} 3287 3288/* 3289 * /dev/ttyN handling 3290 */ 3291 3292static int con_write(struct tty_struct *tty, const unsigned char *buf, int count) 3293{ 3294 int retval; 3295 3296 retval = do_con_write(tty, buf, count); 3297 con_flush_chars(tty); 3298 3299 return retval; 3300} 3301 3302static int con_put_char(struct tty_struct *tty, unsigned char ch) 3303{ 3304 if (in_interrupt()) 3305 return 0; /* n_r3964 calls put_char() from interrupt context */ 3306 return do_con_write(tty, &ch, 1); 3307} 3308 3309static int con_write_room(struct tty_struct *tty) 3310{ 3311 if (tty->stopped) 3312 return 0; 3313 return 32768; /* No limit, really; we're not buffering */ 3314} 3315 3316static int con_chars_in_buffer(struct tty_struct *tty) 3317{ 3318 return 0; /* we're not buffering */ 3319} 3320 3321/* 3322 * con_throttle and con_unthrottle are only used for 3323 * paste_selection(), which has to stuff in a large number of 3324 * characters... 3325 */ 3326static void con_throttle(struct tty_struct *tty) 3327{ 3328} 3329 3330static void con_unthrottle(struct tty_struct *tty) 3331{ 3332 struct vc_data *vc = tty->driver_data; 3333 3334 wake_up_interruptible(&vc->paste_wait); 3335} 3336 3337/* 3338 * Turn the Scroll-Lock LED on when the tty is stopped 3339 */ 3340static void con_stop(struct tty_struct *tty) 3341{ 3342 int console_num; 3343 if (!tty) 3344 return; 3345 console_num = tty->index; 3346 if (!vc_cons_allocated(console_num)) 3347 return; 3348 vt_kbd_con_stop(console_num); 3349} 3350 3351/* 3352 * Turn the Scroll-Lock LED off when the console is started 3353 */ 3354static void con_start(struct tty_struct *tty) 3355{ 3356 int console_num; 3357 if (!tty) 3358 return; 3359 console_num = tty->index; 3360 if (!vc_cons_allocated(console_num)) 3361 return; 3362 vt_kbd_con_start(console_num); 3363} 3364 3365static void con_flush_chars(struct tty_struct *tty) 3366{ 3367 struct vc_data *vc; 3368 3369 if (in_interrupt()) /* from flush_to_ldisc */ 3370 return; 3371 3372 /* if we race with con_close(), vt may be null */ 3373 console_lock(); 3374 vc = tty->driver_data; 3375 if (vc) 3376 set_cursor(vc); 3377 console_unlock(); 3378} 3379 3380/* 3381 * Allocate the console screen memory. 3382 */ 3383static int con_install(struct tty_driver *driver, struct tty_struct *tty) 3384{ 3385 unsigned int currcons = tty->index; 3386 struct vc_data *vc; 3387 int ret; 3388 3389 console_lock(); 3390 ret = vc_allocate(currcons); 3391 if (ret) 3392 goto unlock; 3393 3394 vc = vc_cons[currcons].d; 3395 3396 /* Still being freed */ 3397 if (vc->port.tty) { 3398 ret = -ERESTARTSYS; 3399 goto unlock; 3400 } 3401 3402 ret = tty_port_install(&vc->port, driver, tty); 3403 if (ret) 3404 goto unlock; 3405 3406 tty->driver_data = vc; 3407 vc->port.tty = tty; 3408 tty_port_get(&vc->port); 3409 3410 if (!tty->winsize.ws_row && !tty->winsize.ws_col) { 3411 tty->winsize.ws_row = vc_cons[currcons].d->vc_rows; 3412 tty->winsize.ws_col = vc_cons[currcons].d->vc_cols; 3413 } 3414 if (vc->vc_utf) 3415 tty->termios.c_iflag |= IUTF8; 3416 else 3417 tty->termios.c_iflag &= ~IUTF8; 3418unlock: 3419 console_unlock(); 3420 return ret; 3421} 3422 3423static int con_open(struct tty_struct *tty, struct file *filp) 3424{ 3425 /* everything done in install */ 3426 return 0; 3427} 3428 3429 3430static void con_close(struct tty_struct *tty, struct file *filp) 3431{ 3432 /* Nothing to do - we defer to shutdown */ 3433} 3434 3435static void con_shutdown(struct tty_struct *tty) 3436{ 3437 struct vc_data *vc = tty->driver_data; 3438 BUG_ON(vc == NULL); 3439 console_lock(); 3440 vc->port.tty = NULL; 3441 console_unlock(); 3442} 3443 3444static void con_cleanup(struct tty_struct *tty) 3445{ 3446 struct vc_data *vc = tty->driver_data; 3447 3448 tty_port_put(&vc->port); 3449} 3450 3451static int default_color = 7; /* white */ 3452static int default_italic_color = 2; // green (ASCII) 3453static int default_underline_color = 3; // cyan (ASCII) 3454module_param_named(color, default_color, int, S_IRUGO | S_IWUSR); 3455module_param_named(italic, default_italic_color, int, S_IRUGO | S_IWUSR); 3456module_param_named(underline, default_underline_color, int, S_IRUGO | S_IWUSR); 3457 3458static void vc_init(struct vc_data *vc, unsigned int rows, 3459 unsigned int cols, int do_clear) 3460{ 3461 int j, k ; 3462 3463 vc->vc_cols = cols; 3464 vc->vc_rows = rows; 3465 vc->vc_size_row = cols << 1; 3466 vc->vc_screenbuf_size = vc->vc_rows * vc->vc_size_row; 3467 3468 set_origin(vc); 3469 vc->vc_pos = vc->vc_origin; 3470 reset_vc(vc); 3471 for (j=k=0; j<16; j++) { 3472 vc->vc_palette[k++] = default_red[j] ; 3473 vc->vc_palette[k++] = default_grn[j] ; 3474 vc->vc_palette[k++] = default_blu[j] ; 3475 } 3476 vc->vc_def_color = default_color; 3477 vc->vc_ulcolor = default_underline_color; 3478 vc->vc_itcolor = default_italic_color; 3479 vc->vc_halfcolor = 0x08; /* grey */ 3480 init_waitqueue_head(&vc->paste_wait); 3481 reset_terminal(vc, do_clear); 3482} 3483 3484/* 3485 * This routine initializes console interrupts, and does nothing 3486 * else. If you want the screen to clear, call tty_write with 3487 * the appropriate escape-sequence. 3488 */ 3489 3490static int __init con_init(void) 3491{ 3492 const char *display_desc = NULL; 3493 struct vc_data *vc; 3494 unsigned int currcons = 0, i; 3495 3496 console_lock(); 3497 3498 if (!conswitchp) 3499 conswitchp = &dummy_con; 3500 display_desc = conswitchp->con_startup(); 3501 if (!display_desc) { 3502 fg_console = 0; 3503 console_unlock(); 3504 return 0; 3505 } 3506 3507 for (i = 0; i < MAX_NR_CON_DRIVER; i++) { 3508 struct con_driver *con_driver = ®istered_con_driver[i]; 3509 3510 if (con_driver->con == NULL) { 3511 con_driver->con = conswitchp; 3512 con_driver->desc = display_desc; 3513 con_driver->flag = CON_DRIVER_FLAG_INIT; 3514 con_driver->first = 0; 3515 con_driver->last = MAX_NR_CONSOLES - 1; 3516 break; 3517 } 3518 } 3519 3520 for (i = 0; i < MAX_NR_CONSOLES; i++) 3521 con_driver_map[i] = conswitchp; 3522 3523 if (blankinterval) { 3524 blank_state = blank_normal_wait; 3525 mod_timer(&console_timer, jiffies + (blankinterval * HZ)); 3526 } 3527 3528 for (currcons = 0; currcons < MIN_NR_CONSOLES; currcons++) { 3529 vc_cons[currcons].d = vc = kzalloc(sizeof(struct vc_data), GFP_NOWAIT); 3530 INIT_WORK(&vc_cons[currcons].SAK_work, vc_SAK); 3531 tty_port_init(&vc->port); 3532 visual_init(vc, currcons, 1); 3533 /* Assuming vc->vc_{cols,rows,screenbuf_size} are sane here. */ 3534 vc->vc_screenbuf = kzalloc(vc->vc_screenbuf_size, GFP_NOWAIT); 3535 vc_init(vc, vc->vc_rows, vc->vc_cols, 3536 currcons || !vc->vc_sw->con_save_screen); 3537 } 3538 currcons = fg_console = 0; 3539 master_display_fg = vc = vc_cons[currcons].d; 3540 set_origin(vc); 3541 save_screen(vc); 3542 gotoxy(vc, vc->state.x, vc->state.y); 3543 csi_J(vc, 0); 3544 update_screen(vc); 3545 pr_info("Console: %s %s %dx%d\n", 3546 vc->vc_can_do_color ? "colour" : "mono", 3547 display_desc, vc->vc_cols, vc->vc_rows); 3548 printable = 1; 3549 3550 console_unlock(); 3551 3552#ifdef CONFIG_VT_CONSOLE 3553 register_console(&vt_console_driver); 3554#endif 3555 return 0; 3556} 3557console_initcall(con_init); 3558 3559static const struct tty_operations con_ops = { 3560 .install = con_install, 3561 .open = con_open, 3562 .close = con_close, 3563 .write = con_write, 3564 .write_room = con_write_room, 3565 .put_char = con_put_char, 3566 .flush_chars = con_flush_chars, 3567 .chars_in_buffer = con_chars_in_buffer, 3568 .ioctl = vt_ioctl, 3569#ifdef CONFIG_COMPAT 3570 .compat_ioctl = vt_compat_ioctl, 3571#endif 3572 .stop = con_stop, 3573 .start = con_start, 3574 .throttle = con_throttle, 3575 .unthrottle = con_unthrottle, 3576 .resize = vt_resize, 3577 .shutdown = con_shutdown, 3578 .cleanup = con_cleanup, 3579}; 3580 3581static struct cdev vc0_cdev; 3582 3583static ssize_t show_tty_active(struct device *dev, 3584 struct device_attribute *attr, char *buf) 3585{ 3586 return sprintf(buf, "tty%d\n", fg_console + 1); 3587} 3588static DEVICE_ATTR(active, S_IRUGO, show_tty_active, NULL); 3589 3590static struct attribute *vt_dev_attrs[] = { 3591 &dev_attr_active.attr, 3592 NULL 3593}; 3594 3595ATTRIBUTE_GROUPS(vt_dev); 3596 3597int __init vty_init(const struct file_operations *console_fops) 3598{ 3599 cdev_init(&vc0_cdev, console_fops); 3600 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) || 3601 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0) 3602 panic("Couldn't register /dev/tty0 driver\n"); 3603 tty0dev = device_create_with_groups(tty_class, NULL, 3604 MKDEV(TTY_MAJOR, 0), NULL, 3605 vt_dev_groups, "tty0"); 3606 if (IS_ERR(tty0dev)) 3607 tty0dev = NULL; 3608 3609 vcs_init(); 3610 3611 console_driver = alloc_tty_driver(MAX_NR_CONSOLES); 3612 if (!console_driver) 3613 panic("Couldn't allocate console driver\n"); 3614 3615 console_driver->name = "tty"; 3616 console_driver->name_base = 1; 3617 console_driver->major = TTY_MAJOR; 3618 console_driver->minor_start = 1; 3619 console_driver->type = TTY_DRIVER_TYPE_CONSOLE; 3620 console_driver->init_termios = tty_std_termios; 3621 if (default_utf8) 3622 console_driver->init_termios.c_iflag |= IUTF8; 3623 console_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS; 3624 tty_set_operations(console_driver, &con_ops); 3625 if (tty_register_driver(console_driver)) 3626 panic("Couldn't register console driver\n"); 3627 kbd_init(); 3628 console_map_init(); 3629#ifdef CONFIG_MDA_CONSOLE 3630 mda_console_init(); 3631#endif 3632 return 0; 3633} 3634 3635#ifndef VT_SINGLE_DRIVER 3636 3637static struct class *vtconsole_class; 3638 3639static int do_bind_con_driver(const struct consw *csw, int first, int last, 3640 int deflt) 3641{ 3642 struct module *owner = csw->owner; 3643 const char *desc = NULL; 3644 struct con_driver *con_driver; 3645 int i, j = -1, k = -1, retval = -ENODEV; 3646 3647 if (!try_module_get(owner)) 3648 return -ENODEV; 3649 3650 WARN_CONSOLE_UNLOCKED(); 3651 3652 /* check if driver is registered */ 3653 for (i = 0; i < MAX_NR_CON_DRIVER; i++) { 3654 con_driver = ®istered_con_driver[i]; 3655 3656 if (con_driver->con == csw) { 3657 desc = con_driver->desc; 3658 retval = 0; 3659 break; 3660 } 3661 } 3662 3663 if (retval) 3664 goto err; 3665 3666 if (!(con_driver->flag & CON_DRIVER_FLAG_INIT)) { 3667 csw->con_startup(); 3668 con_driver->flag |= CON_DRIVER_FLAG_INIT; 3669 } 3670 3671 if (deflt) { 3672 if (conswitchp) 3673 module_put(conswitchp->owner); 3674 3675 __module_get(owner); 3676 conswitchp = csw; 3677 } 3678 3679 first = max(first, con_driver->first); 3680 last = min(last, con_driver->last); 3681 3682 for (i = first; i <= last; i++) { 3683 int old_was_color; 3684 struct vc_data *vc = vc_cons[i].d; 3685 3686 if (con_driver_map[i]) 3687 module_put(con_driver_map[i]->owner); 3688 __module_get(owner); 3689 con_driver_map[i] = csw; 3690 3691 if (!vc || !vc->vc_sw) 3692 continue; 3693 3694 j = i; 3695 3696 if (con_is_visible(vc)) { 3697 k = i; 3698 save_screen(vc); 3699 } 3700 3701 old_was_color = vc->vc_can_do_color; 3702 vc->vc_sw->con_deinit(vc); 3703 vc->vc_origin = (unsigned long)vc->vc_screenbuf; 3704 visual_init(vc, i, 0); 3705 set_origin(vc); 3706 update_attr(vc); 3707 3708 /* If the console changed between mono <-> color, then 3709 * the attributes in the screenbuf will be wrong. The 3710 * following resets all attributes to something sane. 3711 */ 3712 if (old_was_color != vc->vc_can_do_color) 3713 clear_buffer_attributes(vc); 3714 } 3715 3716 pr_info("Console: switching "); 3717 if (!deflt) 3718 pr_cont("consoles %d-%d ", first + 1, last + 1); 3719 if (j >= 0) { 3720 struct vc_data *vc = vc_cons[j].d; 3721 3722 pr_cont("to %s %s %dx%d\n", 3723 vc->vc_can_do_color ? "colour" : "mono", 3724 desc, vc->vc_cols, vc->vc_rows); 3725 3726 if (k >= 0) { 3727 vc = vc_cons[k].d; 3728 update_screen(vc); 3729 } 3730 } else { 3731 pr_cont("to %s\n", desc); 3732 } 3733 3734 retval = 0; 3735err: 3736 module_put(owner); 3737 return retval; 3738}; 3739 3740 3741#ifdef CONFIG_VT_HW_CONSOLE_BINDING 3742int do_unbind_con_driver(const struct consw *csw, int first, int last, int deflt) 3743{ 3744 struct module *owner = csw->owner; 3745 const struct consw *defcsw = NULL; 3746 struct con_driver *con_driver = NULL, *con_back = NULL; 3747 int i, retval = -ENODEV; 3748 3749 if (!try_module_get(owner)) 3750 return -ENODEV; 3751 3752 WARN_CONSOLE_UNLOCKED(); 3753 3754 /* check if driver is registered and if it is unbindable */ 3755 for (i = 0; i < MAX_NR_CON_DRIVER; i++) { 3756 con_driver = ®istered_con_driver[i]; 3757 3758 if (con_driver->con == csw && 3759 con_driver->flag & CON_DRIVER_FLAG_MODULE) { 3760 retval = 0; 3761 break; 3762 } 3763 } 3764 3765 if (retval) 3766 goto err; 3767 3768 retval = -ENODEV; 3769 3770 /* check if backup driver exists */ 3771 for (i = 0; i < MAX_NR_CON_DRIVER; i++) { 3772 con_back = ®istered_con_driver[i]; 3773 3774 if (con_back->con && con_back->con != csw) { 3775 defcsw = con_back->con; 3776 retval = 0; 3777 break; 3778 } 3779 } 3780 3781 if (retval) 3782 goto err; 3783 3784 if (!con_is_bound(csw)) 3785 goto err; 3786 3787 first = max(first, con_driver->first); 3788 last = min(last, con_driver->last); 3789 3790 for (i = first; i <= last; i++) { 3791 if (con_driver_map[i] == csw) { 3792 module_put(csw->owner); 3793 con_driver_map[i] = NULL; 3794 } 3795 } 3796 3797 if (!con_is_bound(defcsw)) { 3798 const struct consw *defconsw = conswitchp; 3799 3800 defcsw->con_startup(); 3801 con_back->flag |= CON_DRIVER_FLAG_INIT; 3802 /* 3803 * vgacon may change the default driver to point 3804 * to dummycon, we restore it here... 3805 */ 3806 conswitchp = defconsw; 3807 } 3808 3809 if (!con_is_bound(csw)) 3810 con_driver->flag &= ~CON_DRIVER_FLAG_INIT; 3811 3812 /* ignore return value, binding should not fail */ 3813 do_bind_con_driver(defcsw, first, last, deflt); 3814err: 3815 module_put(owner); 3816 return retval; 3817 3818} 3819EXPORT_SYMBOL_GPL(do_unbind_con_driver); 3820 3821static int vt_bind(struct con_driver *con) 3822{ 3823 const struct consw *defcsw = NULL, *csw = NULL; 3824 int i, more = 1, first = -1, last = -1, deflt = 0; 3825 3826 if (!con->con || !(con->flag & CON_DRIVER_FLAG_MODULE)) 3827 goto err; 3828 3829 csw = con->con; 3830 3831 for (i = 0; i < MAX_NR_CON_DRIVER; i++) { 3832 struct con_driver *con = ®istered_con_driver[i]; 3833 3834 if (con->con && !(con->flag & CON_DRIVER_FLAG_MODULE)) { 3835 defcsw = con->con; 3836 break; 3837 } 3838 } 3839 3840 if (!defcsw) 3841 goto err; 3842 3843 while (more) { 3844 more = 0; 3845 3846 for (i = con->first; i <= con->last; i++) { 3847 if (con_driver_map[i] == defcsw) { 3848 if (first == -1) 3849 first = i; 3850 last = i; 3851 more = 1; 3852 } else if (first != -1) 3853 break; 3854 } 3855 3856 if (first == 0 && last == MAX_NR_CONSOLES -1) 3857 deflt = 1; 3858 3859 if (first != -1) 3860 do_bind_con_driver(csw, first, last, deflt); 3861 3862 first = -1; 3863 last = -1; 3864 deflt = 0; 3865 } 3866 3867err: 3868 return 0; 3869} 3870 3871static int vt_unbind(struct con_driver *con) 3872{ 3873 const struct consw *csw = NULL; 3874 int i, more = 1, first = -1, last = -1, deflt = 0; 3875 int ret; 3876 3877 if (!con->con || !(con->flag & CON_DRIVER_FLAG_MODULE)) 3878 goto err; 3879 3880 csw = con->con; 3881 3882 while (more) { 3883 more = 0; 3884 3885 for (i = con->first; i <= con->last; i++) { 3886 if (con_driver_map[i] == csw) { 3887 if (first == -1) 3888 first = i; 3889 last = i; 3890 more = 1; 3891 } else if (first != -1) 3892 break; 3893 } 3894 3895 if (first == 0 && last == MAX_NR_CONSOLES -1) 3896 deflt = 1; 3897 3898 if (first != -1) { 3899 ret = do_unbind_con_driver(csw, first, last, deflt); 3900 if (ret != 0) 3901 return ret; 3902 } 3903 3904 first = -1; 3905 last = -1; 3906 deflt = 0; 3907 } 3908 3909err: 3910 return 0; 3911} 3912#else 3913static inline int vt_bind(struct con_driver *con) 3914{ 3915 return 0; 3916} 3917static inline int vt_unbind(struct con_driver *con) 3918{ 3919 return 0; 3920} 3921#endif /* CONFIG_VT_HW_CONSOLE_BINDING */ 3922 3923static ssize_t store_bind(struct device *dev, struct device_attribute *attr, 3924 const char *buf, size_t count) 3925{ 3926 struct con_driver *con = dev_get_drvdata(dev); 3927 int bind = simple_strtoul(buf, NULL, 0); 3928 3929 console_lock(); 3930 3931 if (bind) 3932 vt_bind(con); 3933 else 3934 vt_unbind(con); 3935 3936 console_unlock(); 3937 3938 return count; 3939} 3940 3941static ssize_t show_bind(struct device *dev, struct device_attribute *attr, 3942 char *buf) 3943{ 3944 struct con_driver *con = dev_get_drvdata(dev); 3945 int bind; 3946 3947 console_lock(); 3948 bind = con_is_bound(con->con); 3949 console_unlock(); 3950 3951 return snprintf(buf, PAGE_SIZE, "%i\n", bind); 3952} 3953 3954static ssize_t show_name(struct device *dev, struct device_attribute *attr, 3955 char *buf) 3956{ 3957 struct con_driver *con = dev_get_drvdata(dev); 3958 3959 return snprintf(buf, PAGE_SIZE, "%s %s\n", 3960 (con->flag & CON_DRIVER_FLAG_MODULE) ? "(M)" : "(S)", 3961 con->desc); 3962 3963} 3964 3965static DEVICE_ATTR(bind, S_IRUGO|S_IWUSR, show_bind, store_bind); 3966static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); 3967 3968static struct attribute *con_dev_attrs[] = { 3969 &dev_attr_bind.attr, 3970 &dev_attr_name.attr, 3971 NULL 3972}; 3973 3974ATTRIBUTE_GROUPS(con_dev); 3975 3976static int vtconsole_init_device(struct con_driver *con) 3977{ 3978 con->flag |= CON_DRIVER_FLAG_ATTR; 3979 return 0; 3980} 3981 3982static void vtconsole_deinit_device(struct con_driver *con) 3983{ 3984 con->flag &= ~CON_DRIVER_FLAG_ATTR; 3985} 3986 3987/** 3988 * con_is_bound - checks if driver is bound to the console 3989 * @csw: console driver 3990 * 3991 * RETURNS: zero if unbound, nonzero if bound 3992 * 3993 * Drivers can call this and if zero, they should release 3994 * all resources allocated on con_startup() 3995 */ 3996int con_is_bound(const struct consw *csw) 3997{ 3998 int i, bound = 0; 3999 4000 WARN_CONSOLE_UNLOCKED(); 4001 4002 for (i = 0; i < MAX_NR_CONSOLES; i++) { 4003 if (con_driver_map[i] == csw) { 4004 bound = 1; 4005 break; 4006 } 4007 } 4008 4009 return bound; 4010} 4011EXPORT_SYMBOL(con_is_bound); 4012 4013/** 4014 * con_is_visible - checks whether the current console is visible 4015 * @vc: virtual console 4016 * 4017 * RETURNS: zero if not visible, nonzero if visible 4018 */ 4019bool con_is_visible(const struct vc_data *vc) 4020{ 4021 WARN_CONSOLE_UNLOCKED(); 4022 4023 return *vc->vc_display_fg == vc; 4024} 4025EXPORT_SYMBOL(con_is_visible); 4026 4027/** 4028 * con_debug_enter - prepare the console for the kernel debugger 4029 * @vc: virtual console 4030 * 4031 * Called when the console is taken over by the kernel debugger, this 4032 * function needs to save the current console state, then put the console 4033 * into a state suitable for the kernel debugger. 4034 * 4035 * RETURNS: 4036 * Zero on success, nonzero if a failure occurred when trying to prepare 4037 * the console for the debugger. 4038 */ 4039int con_debug_enter(struct vc_data *vc) 4040{ 4041 int ret = 0; 4042 4043 saved_fg_console = fg_console; 4044 saved_last_console = last_console; 4045 saved_want_console = want_console; 4046 saved_vc_mode = vc->vc_mode; 4047 saved_console_blanked = console_blanked; 4048 vc->vc_mode = KD_TEXT; 4049 console_blanked = 0; 4050 if (vc->vc_sw->con_debug_enter) 4051 ret = vc->vc_sw->con_debug_enter(vc); 4052#ifdef CONFIG_KGDB_KDB 4053 /* Set the initial LINES variable if it is not already set */ 4054 if (vc->vc_rows < 999) { 4055 int linecount; 4056 char lns[4]; 4057 const char *setargs[3] = { 4058 "set", 4059 "LINES", 4060 lns, 4061 }; 4062 if (kdbgetintenv(setargs[0], &linecount)) { 4063 snprintf(lns, 4, "%i", vc->vc_rows); 4064 kdb_set(2, setargs); 4065 } 4066 } 4067 if (vc->vc_cols < 999) { 4068 int colcount; 4069 char cols[4]; 4070 const char *setargs[3] = { 4071 "set", 4072 "COLUMNS", 4073 cols, 4074 }; 4075 if (kdbgetintenv(setargs[0], &colcount)) { 4076 snprintf(cols, 4, "%i", vc->vc_cols); 4077 kdb_set(2, setargs); 4078 } 4079 } 4080#endif /* CONFIG_KGDB_KDB */ 4081 return ret; 4082} 4083EXPORT_SYMBOL_GPL(con_debug_enter); 4084 4085/** 4086 * con_debug_leave - restore console state 4087 * 4088 * Restore the console state to what it was before the kernel debugger 4089 * was invoked. 4090 * 4091 * RETURNS: 4092 * Zero on success, nonzero if a failure occurred when trying to restore 4093 * the console. 4094 */ 4095int con_debug_leave(void) 4096{ 4097 struct vc_data *vc; 4098 int ret = 0; 4099 4100 fg_console = saved_fg_console; 4101 last_console = saved_last_console; 4102 want_console = saved_want_console; 4103 console_blanked = saved_console_blanked; 4104 vc_cons[fg_console].d->vc_mode = saved_vc_mode; 4105 4106 vc = vc_cons[fg_console].d; 4107 if (vc->vc_sw->con_debug_leave) 4108 ret = vc->vc_sw->con_debug_leave(vc); 4109 return ret; 4110} 4111EXPORT_SYMBOL_GPL(con_debug_leave); 4112 4113static int do_register_con_driver(const struct consw *csw, int first, int last) 4114{ 4115 struct module *owner = csw->owner; 4116 struct con_driver *con_driver; 4117 const char *desc; 4118 int i, retval; 4119 4120 WARN_CONSOLE_UNLOCKED(); 4121 4122 if (!try_module_get(owner)) 4123 return -ENODEV; 4124 4125 for (i = 0; i < MAX_NR_CON_DRIVER; i++) { 4126 con_driver = ®istered_con_driver[i]; 4127 4128 /* already registered */ 4129 if (con_driver->con == csw) { 4130 retval = -EBUSY; 4131 goto err; 4132 } 4133 } 4134 4135 desc = csw->con_startup(); 4136 if (!desc) { 4137 retval = -ENODEV; 4138 goto err; 4139 } 4140 4141 retval = -EINVAL; 4142 4143 for (i = 0; i < MAX_NR_CON_DRIVER; i++) { 4144 con_driver = ®istered_con_driver[i]; 4145 4146 if (con_driver->con == NULL && 4147 !(con_driver->flag & CON_DRIVER_FLAG_ZOMBIE)) { 4148 con_driver->con = csw; 4149 con_driver->desc = desc; 4150 con_driver->node = i; 4151 con_driver->flag = CON_DRIVER_FLAG_MODULE | 4152 CON_DRIVER_FLAG_INIT; 4153 con_driver->first = first; 4154 con_driver->last = last; 4155 retval = 0; 4156 break; 4157 } 4158 } 4159 4160 if (retval) 4161 goto err; 4162 4163 con_driver->dev = 4164 device_create_with_groups(vtconsole_class, NULL, 4165 MKDEV(0, con_driver->node), 4166 con_driver, con_dev_groups, 4167 "vtcon%i", con_driver->node); 4168 if (IS_ERR(con_driver->dev)) { 4169 pr_warn("Unable to create device for %s; errno = %ld\n", 4170 con_driver->desc, PTR_ERR(con_driver->dev)); 4171 con_driver->dev = NULL; 4172 } else { 4173 vtconsole_init_device(con_driver); 4174 } 4175 4176err: 4177 module_put(owner); 4178 return retval; 4179} 4180 4181 4182/** 4183 * do_unregister_con_driver - unregister console driver from console layer 4184 * @csw: console driver 4185 * 4186 * DESCRIPTION: All drivers that registers to the console layer must 4187 * call this function upon exit, or if the console driver is in a state 4188 * where it won't be able to handle console services, such as the 4189 * framebuffer console without loaded framebuffer drivers. 4190 * 4191 * The driver must unbind first prior to unregistration. 4192 */ 4193int do_unregister_con_driver(const struct consw *csw) 4194{ 4195 int i; 4196 4197 /* cannot unregister a bound driver */ 4198 if (con_is_bound(csw)) 4199 return -EBUSY; 4200 4201 if (csw == conswitchp) 4202 return -EINVAL; 4203 4204 for (i = 0; i < MAX_NR_CON_DRIVER; i++) { 4205 struct con_driver *con_driver = ®istered_con_driver[i]; 4206 4207 if (con_driver->con == csw) { 4208 /* 4209 * Defer the removal of the sysfs entries since that 4210 * will acquire the kernfs s_active lock and we can't 4211 * acquire this lock while holding the console lock: 4212 * the unbind sysfs entry imposes already the opposite 4213 * order. Reset con already here to prevent any later 4214 * lookup to succeed and mark this slot as zombie, so 4215 * it won't get reused until we complete the removal 4216 * in the deferred work. 4217 */ 4218 con_driver->con = NULL; 4219 con_driver->flag = CON_DRIVER_FLAG_ZOMBIE; 4220 schedule_work(&con_driver_unregister_work); 4221 4222 return 0; 4223 } 4224 } 4225 4226 return -ENODEV; 4227} 4228EXPORT_SYMBOL_GPL(do_unregister_con_driver); 4229 4230static void con_driver_unregister_callback(struct work_struct *ignored) 4231{ 4232 int i; 4233 4234 console_lock(); 4235 4236 for (i = 0; i < MAX_NR_CON_DRIVER; i++) { 4237 struct con_driver *con_driver = ®istered_con_driver[i]; 4238 4239 if (!(con_driver->flag & CON_DRIVER_FLAG_ZOMBIE)) 4240 continue; 4241 4242 console_unlock(); 4243 4244 vtconsole_deinit_device(con_driver); 4245 device_destroy(vtconsole_class, MKDEV(0, con_driver->node)); 4246 4247 console_lock(); 4248 4249 if (WARN_ON_ONCE(con_driver->con)) 4250 con_driver->con = NULL; 4251 con_driver->desc = NULL; 4252 con_driver->dev = NULL; 4253 con_driver->node = 0; 4254 WARN_ON_ONCE(con_driver->flag != CON_DRIVER_FLAG_ZOMBIE); 4255 con_driver->flag = 0; 4256 con_driver->first = 0; 4257 con_driver->last = 0; 4258 } 4259 4260 console_unlock(); 4261} 4262 4263/* 4264 * If we support more console drivers, this function is used 4265 * when a driver wants to take over some existing consoles 4266 * and become default driver for newly opened ones. 4267 * 4268 * do_take_over_console is basically a register followed by bind 4269 */ 4270int do_take_over_console(const struct consw *csw, int first, int last, int deflt) 4271{ 4272 int err; 4273 4274 err = do_register_con_driver(csw, first, last); 4275 /* 4276 * If we get an busy error we still want to bind the console driver 4277 * and return success, as we may have unbound the console driver 4278 * but not unregistered it. 4279 */ 4280 if (err == -EBUSY) 4281 err = 0; 4282 if (!err) 4283 do_bind_con_driver(csw, first, last, deflt); 4284 4285 return err; 4286} 4287EXPORT_SYMBOL_GPL(do_take_over_console); 4288 4289 4290/* 4291 * give_up_console is a wrapper to unregister_con_driver. It will only 4292 * work if driver is fully unbound. 4293 */ 4294void give_up_console(const struct consw *csw) 4295{ 4296 console_lock(); 4297 do_unregister_con_driver(csw); 4298 console_unlock(); 4299} 4300 4301static int __init vtconsole_class_init(void) 4302{ 4303 int i; 4304 4305 vtconsole_class = class_create(THIS_MODULE, "vtconsole"); 4306 if (IS_ERR(vtconsole_class)) { 4307 pr_warn("Unable to create vt console class; errno = %ld\n", 4308 PTR_ERR(vtconsole_class)); 4309 vtconsole_class = NULL; 4310 } 4311 4312 /* Add system drivers to sysfs */ 4313 for (i = 0; i < MAX_NR_CON_DRIVER; i++) { 4314 struct con_driver *con = ®istered_con_driver[i]; 4315 4316 if (con->con && !con->dev) { 4317 con->dev = 4318 device_create_with_groups(vtconsole_class, NULL, 4319 MKDEV(0, con->node), 4320 con, con_dev_groups, 4321 "vtcon%i", con->node); 4322 4323 if (IS_ERR(con->dev)) { 4324 pr_warn("Unable to create device for %s; errno = %ld\n", 4325 con->desc, PTR_ERR(con->dev)); 4326 con->dev = NULL; 4327 } else { 4328 vtconsole_init_device(con); 4329 } 4330 } 4331 } 4332 4333 return 0; 4334} 4335postcore_initcall(vtconsole_class_init); 4336 4337#endif 4338 4339/* 4340 * Screen blanking 4341 */ 4342 4343static int set_vesa_blanking(char __user *p) 4344{ 4345 unsigned int mode; 4346 4347 if (get_user(mode, p + 1)) 4348 return -EFAULT; 4349 4350 vesa_blank_mode = (mode < 4) ? mode : 0; 4351 return 0; 4352} 4353 4354void do_blank_screen(int entering_gfx) 4355{ 4356 struct vc_data *vc = vc_cons[fg_console].d; 4357 int i; 4358 4359 might_sleep(); 4360 4361 WARN_CONSOLE_UNLOCKED(); 4362 4363 if (console_blanked) { 4364 if (blank_state == blank_vesa_wait) { 4365 blank_state = blank_off; 4366 vc->vc_sw->con_blank(vc, vesa_blank_mode + 1, 0); 4367 } 4368 return; 4369 } 4370 4371 /* entering graphics mode? */ 4372 if (entering_gfx) { 4373 hide_cursor(vc); 4374 save_screen(vc); 4375 vc->vc_sw->con_blank(vc, -1, 1); 4376 console_blanked = fg_console + 1; 4377 blank_state = blank_off; 4378 set_origin(vc); 4379 return; 4380 } 4381 4382 blank_state = blank_off; 4383 4384 /* don't blank graphics */ 4385 if (vc->vc_mode != KD_TEXT) { 4386 console_blanked = fg_console + 1; 4387 return; 4388 } 4389 4390 hide_cursor(vc); 4391 del_timer_sync(&console_timer); 4392 blank_timer_expired = 0; 4393 4394 save_screen(vc); 4395 /* In case we need to reset origin, blanking hook returns 1 */ 4396 i = vc->vc_sw->con_blank(vc, vesa_off_interval ? 1 : (vesa_blank_mode + 1), 0); 4397 console_blanked = fg_console + 1; 4398 if (i) 4399 set_origin(vc); 4400 4401 if (console_blank_hook && console_blank_hook(1)) 4402 return; 4403 4404 if (vesa_off_interval && vesa_blank_mode) { 4405 blank_state = blank_vesa_wait; 4406 mod_timer(&console_timer, jiffies + vesa_off_interval); 4407 } 4408 vt_event_post(VT_EVENT_BLANK, vc->vc_num, vc->vc_num); 4409} 4410EXPORT_SYMBOL(do_blank_screen); 4411 4412/* 4413 * Called by timer as well as from vt_console_driver 4414 */ 4415void do_unblank_screen(int leaving_gfx) 4416{ 4417 struct vc_data *vc; 4418 4419 /* This should now always be called from a "sane" (read: can schedule) 4420 * context for the sake of the low level drivers, except in the special 4421 * case of oops_in_progress 4422 */ 4423 if (!oops_in_progress) 4424 might_sleep(); 4425 4426 WARN_CONSOLE_UNLOCKED(); 4427 4428 ignore_poke = 0; 4429 if (!console_blanked) 4430 return; 4431 if (!vc_cons_allocated(fg_console)) { 4432 /* impossible */ 4433 pr_warn("unblank_screen: tty %d not allocated ??\n", 4434 fg_console + 1); 4435 return; 4436 } 4437 vc = vc_cons[fg_console].d; 4438 if (vc->vc_mode != KD_TEXT) 4439 return; /* but leave console_blanked != 0 */ 4440 4441 if (blankinterval) { 4442 mod_timer(&console_timer, jiffies + (blankinterval * HZ)); 4443 blank_state = blank_normal_wait; 4444 } 4445 4446 console_blanked = 0; 4447 if (vc->vc_sw->con_blank(vc, 0, leaving_gfx)) 4448 /* Low-level driver cannot restore -> do it ourselves */ 4449 update_screen(vc); 4450 if (console_blank_hook) 4451 console_blank_hook(0); 4452 set_palette(vc); 4453 set_cursor(vc); 4454 vt_event_post(VT_EVENT_UNBLANK, vc->vc_num, vc->vc_num); 4455} 4456EXPORT_SYMBOL(do_unblank_screen); 4457 4458/* 4459 * This is called by the outside world to cause a forced unblank, mostly for 4460 * oopses. Currently, I just call do_unblank_screen(0), but we could eventually 4461 * call it with 1 as an argument and so force a mode restore... that may kill 4462 * X or at least garbage the screen but would also make the Oops visible... 4463 */ 4464void unblank_screen(void) 4465{ 4466 do_unblank_screen(0); 4467} 4468 4469/* 4470 * We defer the timer blanking to work queue so it can take the console mutex 4471 * (console operations can still happen at irq time, but only from printk which 4472 * has the console mutex. Not perfect yet, but better than no locking 4473 */ 4474static void blank_screen_t(struct timer_list *unused) 4475{ 4476 blank_timer_expired = 1; 4477 schedule_work(&console_work); 4478} 4479 4480void poke_blanked_console(void) 4481{ 4482 WARN_CONSOLE_UNLOCKED(); 4483 4484 /* Add this so we quickly catch whoever might call us in a non 4485 * safe context. Nowadays, unblank_screen() isn't to be called in 4486 * atomic contexts and is allowed to schedule (with the special case 4487 * of oops_in_progress, but that isn't of any concern for this 4488 * function. --BenH. 4489 */ 4490 might_sleep(); 4491 4492 /* This isn't perfectly race free, but a race here would be mostly harmless, 4493 * at worse, we'll do a spurrious blank and it's unlikely 4494 */ 4495 del_timer(&console_timer); 4496 blank_timer_expired = 0; 4497 4498 if (ignore_poke || !vc_cons[fg_console].d || vc_cons[fg_console].d->vc_mode == KD_GRAPHICS) 4499 return; 4500 if (console_blanked) 4501 unblank_screen(); 4502 else if (blankinterval) { 4503 mod_timer(&console_timer, jiffies + (blankinterval * HZ)); 4504 blank_state = blank_normal_wait; 4505 } 4506} 4507 4508/* 4509 * Palettes 4510 */ 4511 4512static void set_palette(struct vc_data *vc) 4513{ 4514 WARN_CONSOLE_UNLOCKED(); 4515 4516 if (vc->vc_mode != KD_GRAPHICS && vc->vc_sw->con_set_palette) 4517 vc->vc_sw->con_set_palette(vc, color_table); 4518} 4519 4520/* 4521 * Load palette into the DAC registers. arg points to a colour 4522 * map, 3 bytes per colour, 16 colours, range from 0 to 255. 4523 */ 4524 4525int con_set_cmap(unsigned char __user *arg) 4526{ 4527 int i, j, k; 4528 unsigned char colormap[3*16]; 4529 4530 if (copy_from_user(colormap, arg, sizeof(colormap))) 4531 return -EFAULT; 4532 4533 console_lock(); 4534 for (i = k = 0; i < 16; i++) { 4535 default_red[i] = colormap[k++]; 4536 default_grn[i] = colormap[k++]; 4537 default_blu[i] = colormap[k++]; 4538 } 4539 for (i = 0; i < MAX_NR_CONSOLES; i++) { 4540 if (!vc_cons_allocated(i)) 4541 continue; 4542 for (j = k = 0; j < 16; j++) { 4543 vc_cons[i].d->vc_palette[k++] = default_red[j]; 4544 vc_cons[i].d->vc_palette[k++] = default_grn[j]; 4545 vc_cons[i].d->vc_palette[k++] = default_blu[j]; 4546 } 4547 set_palette(vc_cons[i].d); 4548 } 4549 console_unlock(); 4550 4551 return 0; 4552} 4553 4554int con_get_cmap(unsigned char __user *arg) 4555{ 4556 int i, k; 4557 unsigned char colormap[3*16]; 4558 4559 console_lock(); 4560 for (i = k = 0; i < 16; i++) { 4561 colormap[k++] = default_red[i]; 4562 colormap[k++] = default_grn[i]; 4563 colormap[k++] = default_blu[i]; 4564 } 4565 console_unlock(); 4566 4567 if (copy_to_user(arg, colormap, sizeof(colormap))) 4568 return -EFAULT; 4569 4570 return 0; 4571} 4572 4573void reset_palette(struct vc_data *vc) 4574{ 4575 int j, k; 4576 for (j=k=0; j<16; j++) { 4577 vc->vc_palette[k++] = default_red[j]; 4578 vc->vc_palette[k++] = default_grn[j]; 4579 vc->vc_palette[k++] = default_blu[j]; 4580 } 4581 set_palette(vc); 4582} 4583 4584/* 4585 * Font switching 4586 * 4587 * Currently we only support fonts up to 32 pixels wide, at a maximum height 4588 * of 32 pixels. Userspace fontdata is stored with 32 bytes (shorts/ints, 4589 * depending on width) reserved for each character which is kinda wasty, but 4590 * this is done in order to maintain compatibility with the EGA/VGA fonts. It 4591 * is up to the actual low-level console-driver convert data into its favorite 4592 * format (maybe we should add a `fontoffset' field to the `display' 4593 * structure so we won't have to convert the fontdata all the time. 4594 * /Jes 4595 */ 4596 4597#define max_font_size 65536 4598 4599static int con_font_get(struct vc_data *vc, struct console_font_op *op) 4600{ 4601 struct console_font font; 4602 int rc = -EINVAL; 4603 int c; 4604 4605 if (op->data) { 4606 font.data = kmalloc(max_font_size, GFP_KERNEL); 4607 if (!font.data) 4608 return -ENOMEM; 4609 } else 4610 font.data = NULL; 4611 4612 console_lock(); 4613 if (vc->vc_mode != KD_TEXT) 4614 rc = -EINVAL; 4615 else if (vc->vc_sw->con_font_get) 4616 rc = vc->vc_sw->con_font_get(vc, &font); 4617 else 4618 rc = -ENOSYS; 4619 console_unlock(); 4620 4621 if (rc) 4622 goto out; 4623 4624 c = (font.width+7)/8 * 32 * font.charcount; 4625 4626 if (op->data && font.charcount > op->charcount) 4627 rc = -ENOSPC; 4628 if (font.width > op->width || font.height > op->height) 4629 rc = -ENOSPC; 4630 if (rc) 4631 goto out; 4632 4633 op->height = font.height; 4634 op->width = font.width; 4635 op->charcount = font.charcount; 4636 4637 if (op->data && copy_to_user(op->data, font.data, c)) 4638 rc = -EFAULT; 4639 4640out: 4641 kfree(font.data); 4642 return rc; 4643} 4644 4645static int con_font_set(struct vc_data *vc, struct console_font_op *op) 4646{ 4647 struct console_font font; 4648 int rc = -EINVAL; 4649 int size; 4650 4651 if (vc->vc_mode != KD_TEXT) 4652 return -EINVAL; 4653 if (!op->data) 4654 return -EINVAL; 4655 if (op->charcount > 512) 4656 return -EINVAL; 4657 if (op->width <= 0 || op->width > 32 || !op->height || op->height > 32) 4658 return -EINVAL; 4659 size = (op->width+7)/8 * 32 * op->charcount; 4660 if (size > max_font_size) 4661 return -ENOSPC; 4662 4663 font.data = memdup_user(op->data, size); 4664 if (IS_ERR(font.data)) 4665 return PTR_ERR(font.data); 4666 4667 font.charcount = op->charcount; 4668 font.width = op->width; 4669 font.height = op->height; 4670 4671 console_lock(); 4672 if (vc->vc_mode != KD_TEXT) 4673 rc = -EINVAL; 4674 else if (vc->vc_sw->con_font_set) { 4675 if (vc_is_sel(vc)) 4676 clear_selection(); 4677 rc = vc->vc_sw->con_font_set(vc, &font, op->flags); 4678 } else 4679 rc = -ENOSYS; 4680 console_unlock(); 4681 kfree(font.data); 4682 return rc; 4683} 4684 4685static int con_font_default(struct vc_data *vc, struct console_font_op *op) 4686{ 4687 struct console_font font = {.width = op->width, .height = op->height}; 4688 char name[MAX_FONT_NAME]; 4689 char *s = name; 4690 int rc; 4691 4692 4693 if (!op->data) 4694 s = NULL; 4695 else if (strncpy_from_user(name, op->data, MAX_FONT_NAME - 1) < 0) 4696 return -EFAULT; 4697 else 4698 name[MAX_FONT_NAME - 1] = 0; 4699 4700 console_lock(); 4701 if (vc->vc_mode != KD_TEXT) { 4702 console_unlock(); 4703 return -EINVAL; 4704 } 4705 if (vc->vc_sw->con_font_default) { 4706 if (vc_is_sel(vc)) 4707 clear_selection(); 4708 rc = vc->vc_sw->con_font_default(vc, &font, s); 4709 } else 4710 rc = -ENOSYS; 4711 console_unlock(); 4712 if (!rc) { 4713 op->width = font.width; 4714 op->height = font.height; 4715 } 4716 return rc; 4717} 4718 4719int con_font_op(struct vc_data *vc, struct console_font_op *op) 4720{ 4721 switch (op->op) { 4722 case KD_FONT_OP_SET: 4723 return con_font_set(vc, op); 4724 case KD_FONT_OP_GET: 4725 return con_font_get(vc, op); 4726 case KD_FONT_OP_SET_DEFAULT: 4727 return con_font_default(vc, op); 4728 case KD_FONT_OP_COPY: 4729 /* was buggy and never really used */ 4730 return -EINVAL; 4731 } 4732 return -ENOSYS; 4733} 4734 4735/* 4736 * Interface exported to selection and vcs. 4737 */ 4738 4739/* used by selection */ 4740u16 screen_glyph(const struct vc_data *vc, int offset) 4741{ 4742 u16 w = scr_readw(screenpos(vc, offset, true)); 4743 u16 c = w & 0xff; 4744 4745 if (w & vc->vc_hi_font_mask) 4746 c |= 0x100; 4747 return c; 4748} 4749EXPORT_SYMBOL_GPL(screen_glyph); 4750 4751u32 screen_glyph_unicode(const struct vc_data *vc, int n) 4752{ 4753 struct uni_screen *uniscr = get_vc_uniscr(vc); 4754 4755 if (uniscr) 4756 return uniscr->lines[n / vc->vc_cols][n % vc->vc_cols]; 4757 return inverse_translate(vc, screen_glyph(vc, n * 2), 1); 4758} 4759EXPORT_SYMBOL_GPL(screen_glyph_unicode); 4760 4761/* used by vcs - note the word offset */ 4762unsigned short *screen_pos(const struct vc_data *vc, int w_offset, bool viewed) 4763{ 4764 return screenpos(vc, 2 * w_offset, viewed); 4765} 4766EXPORT_SYMBOL_GPL(screen_pos); 4767 4768void getconsxy(const struct vc_data *vc, unsigned char xy[static 2]) 4769{ 4770 /* clamp values if they don't fit */ 4771 xy[0] = min(vc->state.x, 0xFFu); 4772 xy[1] = min(vc->state.y, 0xFFu); 4773} 4774 4775void putconsxy(struct vc_data *vc, unsigned char xy[static const 2]) 4776{ 4777 hide_cursor(vc); 4778 gotoxy(vc, xy[0], xy[1]); 4779 set_cursor(vc); 4780} 4781 4782u16 vcs_scr_readw(const struct vc_data *vc, const u16 *org) 4783{ 4784 if ((unsigned long)org == vc->vc_pos && softcursor_original != -1) 4785 return softcursor_original; 4786 return scr_readw(org); 4787} 4788 4789void vcs_scr_writew(struct vc_data *vc, u16 val, u16 *org) 4790{ 4791 scr_writew(val, org); 4792 if ((unsigned long)org == vc->vc_pos) { 4793 softcursor_original = -1; 4794 add_softcursor(vc); 4795 } 4796} 4797 4798void vcs_scr_updated(struct vc_data *vc) 4799{ 4800 notify_update(vc); 4801} 4802 4803void vc_scrolldelta_helper(struct vc_data *c, int lines, 4804 unsigned int rolled_over, void *base, unsigned int size) 4805{ 4806 unsigned long ubase = (unsigned long)base; 4807 ptrdiff_t scr_end = (void *)c->vc_scr_end - base; 4808 ptrdiff_t vorigin = (void *)c->vc_visible_origin - base; 4809 ptrdiff_t origin = (void *)c->vc_origin - base; 4810 int margin = c->vc_size_row * 4; 4811 int from, wrap, from_off, avail; 4812 4813 /* Turn scrollback off */ 4814 if (!lines) { 4815 c->vc_visible_origin = c->vc_origin; 4816 return; 4817 } 4818 4819 /* Do we have already enough to allow jumping from 0 to the end? */ 4820 if (rolled_over > scr_end + margin) { 4821 from = scr_end; 4822 wrap = rolled_over + c->vc_size_row; 4823 } else { 4824 from = 0; 4825 wrap = size; 4826 } 4827 4828 from_off = (vorigin - from + wrap) % wrap + lines * c->vc_size_row; 4829 avail = (origin - from + wrap) % wrap; 4830 4831 /* Only a little piece would be left? Show all incl. the piece! */ 4832 if (avail < 2 * margin) 4833 margin = 0; 4834 if (from_off < margin) 4835 from_off = 0; 4836 if (from_off > avail - margin) 4837 from_off = avail; 4838 4839 c->vc_visible_origin = ubase + (from + from_off) % wrap; 4840} 4841EXPORT_SYMBOL_GPL(vc_scrolldelta_helper); 4842 4843/* 4844 * Visible symbols for modules 4845 */ 4846 4847EXPORT_SYMBOL(color_table); 4848EXPORT_SYMBOL(default_red); 4849EXPORT_SYMBOL(default_grn); 4850EXPORT_SYMBOL(default_blu); 4851EXPORT_SYMBOL(update_region); 4852EXPORT_SYMBOL(redraw_screen); 4853EXPORT_SYMBOL(vc_resize); 4854EXPORT_SYMBOL(fg_console); 4855EXPORT_SYMBOL(console_blank_hook); 4856EXPORT_SYMBOL(console_blanked); 4857EXPORT_SYMBOL(vc_cons); 4858EXPORT_SYMBOL(global_cursor_default); 4859#ifndef VT_SINGLE_DRIVER 4860EXPORT_SYMBOL(give_up_console); 4861#endif 4862