arch/x86/boot/video.c

   1 /* -*- linux-c -*- ------------------------------------------------------- *
   2  *
   3  *   Copyright (C) 1991, 1992 Linus Torvalds
   4  *   Copyright 2007 rPath, Inc. - All Rights Reserved
   5  *
   6  *   This file is part of the Linux kernel, and is made available under
   7  *   the terms of the GNU General Public License version 2.
   8  *
   9  * ----------------------------------------------------------------------- */
  10
  11 /*
  12  * arch/i386/boot/video.c
  13  *
  14  * Select video mode
  15  */
  16
  17 #include "boot.h"
  18 #include "video.h"
  19 #include "vesa.h"
  20
  21 /*
  22  * Mode list variables
  23  */
  24 static struct card_info cards[];    /* List of cards to probe for */
  25
  26 /*
  27  * Common variables
  28  */
  29 int adapter;                    /* 0=CGA/MDA/HGC, 1=EGA, 2=VGA+ */
  30 u16 video_segment;
  31 int force_x, force_y;   /* Don't query the BIOS for cols/rows */
  32
  33 int do_restore = 0;     /* Screen contents changed during mode flip */
  34 int graphic_mode;       /* Graphic mode with linear frame buffer */
  35
  36 static void store_cursor_position(void)
  37 {
  38         u16 curpos;
  39         u16 ax, bx;
  40
  41         ax = 0x0300;
  42         bx = 0;
  43         asm(INT10
  44             : "=d" (curpos), "+a" (ax), "+b" (bx)
  45             : : "ecx", "esi", "edi");
  46
  47         boot_params.screen_info.orig_x = curpos;
  48         boot_params.screen_info.orig_y = curpos >> 8;
  49 }
  50
  51 static void store_video_mode(void)
  52 {
  53         u16 ax, page;
  54
  55         /* N.B.: the saving of the video page here is a bit silly,
  56            since we pretty much assume page 0 everywhere. */
  57         ax = 0x0f00;
  58         asm(INT10
  59             : "+a" (ax), "=b" (page)
  60             : : "ecx", "edx", "esi", "edi");
  61
  62         /* Not all BIOSes are clean with respect to the top bit */
  63         boot_params.screen_info.orig_video_mode = ax & 0x7f;
  64         boot_params.screen_info.orig_video_page = page >> 8;
  65 }
  66
  67 /*
  68  * Store the video mode parameters for later usage by the kernel.
  69  * This is done by asking the BIOS except for the rows/columns
  70  * parameters in the default 80x25 mode -- these are set directly,
  71  * because some very obscure BIOSes supply insane values.
  72  */
  73 static void store_mode_params(void)
  74 {
  75         u16 font_size;
  76         int x, y;
  77
  78         /* For graphics mode, it is up to the mode-setting driver
  79            (currently only video-vesa.c) to store the parameters */
  80         if (graphic_mode)
  81                 return;
  82
  83         store_cursor_position();
  84         store_video_mode();
  85
  86         if (boot_params.screen_info.orig_video_mode == 0x07) {
  87                 /* MDA, HGC, or VGA in monochrome mode */
  88                 video_segment = 0xb000;
  89         } else {
  90                 /* CGA, EGA, VGA and so forth */
  91                 video_segment = 0xb800;
  92         }
  93
  94         set_fs(0);
  95         font_size = rdfs16(0x485); /* Font size, BIOS area */
  96         boot_params.screen_info.orig_video_points = font_size;
  97
  98         x = rdfs16(0x44a);
  99         y = (adapter == ADAPTER_CGA) ? 25 : rdfs8(0x484)+1;
 100
 101         if (force_x)
 102                 x = force_x;
 103         if (force_y)
 104                 y = force_y;
 105
 106         boot_params.screen_info.orig_video_cols  = x;
 107         boot_params.screen_info.orig_video_lines = y;
 108 }
 109
 110 /* Probe the video drivers and have them generate their mode lists. */
 111 static void probe_cards(int unsafe)
 112 {
 113         struct card_info *card;
 114         static u8 probed[2];
 115
 116         if (probed[unsafe])
 117                 return;
 118
 119         probed[unsafe] = 1;
 120
 121         for (card = video_cards; card < video_cards_end; card++) {
 122                 if (card->unsafe == unsafe) {
 123                         if (card->probe)
 124                                 card->nmodes = card->probe();
 125                         else
 126                                 card->nmodes = 0;
 127                 }
 128         }
 129 }
 130
 131 /* Test if a mode is defined */
 132 int mode_defined(u16 mode)
 133 {
 134         struct card_info *card;
 135         struct mode_info *mi;
 136         int i;
 137
 138         for (card = video_cards; card < video_cards_end; card++) {
 139                 mi = card->modes;
 140                 for (i = 0; i < card->nmodes; i++, mi++) {
 141                         if (mi->mode == mode)
 142                                 return 1;
 143                 }
 144         }
 145
 146         return 0;
 147 }
 148
 149 /* Set mode (without recalc) */
 150 static int raw_set_mode(u16 mode, u16 *real_mode)
 151 {
 152         int nmode, i;
 153         struct card_info *card;
 154         struct mode_info *mi;
 155
 156         /* Drop the recalc bit if set */
 157         mode &= ~VIDEO_RECALC;
 158
 159         /* Scan for mode based on fixed ID, position, or resolution */
 160         nmode = 0;
 161         for (card = video_cards; card < video_cards_end; card++) {
 162                 mi = card->modes;
 163                 for (i = 0; i < card->nmodes; i++, mi++) {
 164                         int visible = mi->x || mi->y;
 165
 166                         if ((mode == nmode && visible) ||
 167                             mode == mi->mode ||
 168                             mode == (mi->y << 8)+mi->x) {
 169                                 *real_mode = mi->mode;
 170                                 return card->set_mode(mi);
 171                         }
 172
 173                         if (visible)
 174                                 nmode++;
 175                 }
 176         }
 177
 178         /* Nothing found?  Is it an "exceptional" (unprobed) mode? */
 179         for (card = video_cards; card < video_cards_end; card++) {
 180                 if (mode >= card->xmode_first &&
 181                     mode < card->xmode_first+card->xmode_n) {
 182                         struct mode_info mix;
 183                         *real_mode = mix.mode = mode;
 184                         mix.x = mix.y = 0;
 185                         return card->set_mode(&mix);
 186                 }
 187         }
 188
 189         /* Otherwise, failure... */
 190         return -1;
 191 }
 192
 193 /*
 194  * Recalculate the vertical video cutoff (hack!)
 195  */
 196 static void vga_recalc_vertical(void)
 197 {
 198         unsigned int font_size, rows;
 199         u16 crtc;
 200         u8 pt, ov;
 201
 202         set_fs(0);
 203         font_size = rdfs8(0x485); /* BIOS: font size (pixels) */
 204         rows = force_y ? force_y : rdfs8(0x484)+1; /* Text rows */
 205
 206         rows *= font_size;      /* Visible scan lines */
 207         rows--;                 /* ... minus one */
 208
 209         crtc = vga_crtc();
 210
 211         pt = in_idx(crtc, 0x11);
 212         pt &= ~0x80;            /* Unlock CR0-7 */
 213         out_idx(pt, crtc, 0x11);
 214
 215         out_idx((u8)rows, crtc, 0x12); /* Lower height register */
 216
 217         ov = in_idx(crtc, 0x07); /* Overflow register */
 218         ov &= 0xbd;
 219         ov |= (rows >> (8-1)) & 0x02;
 220         ov |= (rows >> (9-6)) & 0x40;
 221         out_idx(ov, crtc, 0x07);
 222 }
 223
 224 /* Set mode (with recalc if specified) */
 225 static int set_mode(u16 mode)
 226 {
 227         int rv;
 228         u16 real_mode;
 229
 230         /* Very special mode numbers... */
 231         if (mode == VIDEO_CURRENT_MODE)
 232                 return 0;       /* Nothing to do... */
 233         else if (mode == NORMAL_VGA)
 234                 mode = VIDEO_80x25;
 235         else if (mode == EXTENDED_VGA)
 236                 mode = VIDEO_8POINT;
 237
 238         rv = raw_set_mode(mode, &real_mode);
 239         if (rv)
 240                 return rv;
 241
 242         if (mode & VIDEO_RECALC)
 243                 vga_recalc_vertical();
 244
 245         /* Save the canonical mode number for the kernel, not
 246            an alias, size specification or menu position */
 247         boot_params.hdr.vid_mode = real_mode;
 248         return 0;
 249 }
 250
 251 static unsigned int get_entry(void)
 252 {
 253         char entry_buf[4];
 254         int i, len = 0;
 255         int key;
 256         unsigned int v;
 257
 258         do {
 259                 key = getchar();
 260
 261                 if (key == '\b') {
 262                         if (len > 0) {
 263                                 puts("\b \b");
 264                                 len--;
 265                         }
 266                 } else if ((key >= '0' && key <= '9') ||
 267                            (key >= 'A' && key <= 'Z') ||
 268                            (key >= 'a' && key <= 'z')) {
 269                         if (len < sizeof entry_buf) {
 270                                 entry_buf[len++] = key;
 271                                 putchar(key);
 272                         }
 273                 }
 274         } while (key != '\r');
 275         putchar('\n');
 276
 277         if (len == 0)
 278                 return VIDEO_CURRENT_MODE; /* Default */
 279
 280         v = 0;
 281         for (i = 0; i < len; i++) {
 282                 v <<= 4;
 283                 key = entry_buf[i] | 0x20;
 284                 v += (key > '9') ? key-'a'+10 : key-'0';
 285         }
 286
 287         return v;
 288 }
 289
 290 static void display_menu(void)
 291 {
 292         struct card_info *card;
 293         struct mode_info *mi;
 294         char ch;
 295         int i;
 296         int nmodes;
 297         int modes_per_line;
 298         int col;
 299
 300         nmodes = 0;
 301         for (card = video_cards; card < video_cards_end; card++)
 302                 nmodes += card->nmodes;
 303
 304         modes_per_line = 1;
 305         if (nmodes >= 20)
 306                 modes_per_line = 3;
 307
 308         for (col = 0; col < modes_per_line; col++)
 309                 puts("Mode: Resolution:  Type: ");
 310         putchar('\n');
 311
 312         col = 0;
 313         ch = '0';
 314         for (card = video_cards; card < video_cards_end; card++) {
 315                 mi = card->modes;
 316                 for (i = 0; i < card->nmodes; i++, mi++) {
 317                         char resbuf[32];
 318                         int visible = mi->x && mi->y;
 319                         u16 mode_id = mi->mode ? mi->mode :
 320                                 (mi->y << 8)+mi->x;
 321
 322                         if (!visible)
 323                                 continue; /* Hidden mode */
 324
 325                         if (mi->depth)
 326                                 sprintf(resbuf, "%dx%d", mi->y, mi->depth);
 327                         else
 328                                 sprintf(resbuf, "%d", mi->y);
 329
 330                         printf("%c %03X %4dx%-7s %-6s",
 331                                ch, mode_id, mi->x, resbuf, card->card_name);
 332                         col++;
 333                         if (col >= modes_per_line) {
 334                                 putchar('\n');
 335                                 col = 0;
 336                         }
 337
 338                         if (ch == '9')
 339                                 ch = 'a';
 340                         else if (ch == 'z' || ch == ' ')
 341                                 ch = ' '; /* Out of keys... */
 342                         else
 343                                 ch++;
 344                 }
 345         }
 346         if (col)
 347                 putchar('\n');
 348 }
 349
 350 #define H(x)    ((x)-'a'+10)
 351 #define SCAN    ((H('s')<<12)+(H('c')<<8)+(H('a')<<4)+H('n'))
 352
 353 static unsigned int mode_menu(void)
 354 {
 355         int key;
 356         unsigned int sel;
 357
 358         puts("Press <ENTER> to see video modes available, "
 359              "<SPACE> to continue, or wait 30 sec\n");
 360
 361         kbd_flush();
 362         while (1) {
 363                 key = getchar_timeout();
 364                 if (key == ' ' || key == 0)
 365                         return VIDEO_CURRENT_MODE; /* Default */
 366                 if (key == '\r')
 367                         break;
 368                 putchar('\a');  /* Beep! */
 369         }
 370
 371
 372         for (;;) {
 373                 display_menu();
 374
 375                 puts("Enter a video mode or \"scan\" to scan for "
 376                      "additional modes: ");
 377                 sel = get_entry();
 378                 if (sel != SCAN)
 379                         return sel;
 380
 381                 probe_cards(1);
 382         }
 383 }
 384
 385 #ifdef CONFIG_VIDEO_RETAIN
 386 /* Save screen content to the heap */
 387 struct saved_screen {
 388         int x, y;
 389         int curx, cury;
 390         u16 *data;
 391 } saved;
 392
 393 static void save_screen(void)
 394 {
 395         /* Should be called after store_mode_params() */
 396         saved.x = boot_params.screen_info.orig_video_cols;
 397         saved.y = boot_params.screen_info.orig_video_lines;
 398         saved.curx = boot_params.screen_info.orig_x;
 399         saved.cury = boot_params.screen_info.orig_y;
 400
 401         if (!heap_free(saved.x*saved.y*sizeof(u16)+512))
 402                 return;         /* Not enough heap to save the screen */
 403
 404         saved.data = GET_HEAP(u16, saved.x*saved.y);
 405
 406         set_fs(video_segment);
 407         copy_from_fs(saved.data, 0, saved.x*saved.y*sizeof(u16));
 408 }
 409
 410 static void restore_screen(void)
 411 {
 412         /* Should be called after store_mode_params() */
 413         int xs = boot_params.screen_info.orig_video_cols;
 414         int ys = boot_params.screen_info.orig_video_lines;
 415         int y;
 416         addr_t dst = 0;
 417         u16 *src = saved.data;
 418         u16 ax, bx, dx;
 419
 420         if (graphic_mode)
 421                 return;         /* Can't restore onto a graphic mode */
 422
 423         if (!src)
 424                 return;         /* No saved screen contents */
 425
 426         /* Restore screen contents */
 427
 428         set_fs(video_segment);
 429         for (y = 0; y < ys; y++) {
 430                 int npad;
 431
 432                 if (y < saved.y) {
 433                         int copy = (xs < saved.x) ? xs : saved.x;
 434                         copy_to_fs(dst, src, copy*sizeof(u16));
 435                         dst += copy*sizeof(u16);
 436                         src += saved.x;
 437                         npad = (xs < saved.x) ? 0 : xs-saved.x;
 438                 } else {
 439                         npad = xs;
 440                 }
 441
 442                 /* Writes "npad" blank characters to
 443                    video_segment:dst and advances dst */
 444                 asm volatile("pushw %%es ; "
 445                              "movw %2,%%es ; "
 446                              "shrw %%cx ; "
 447                              "jnc 1f ; "
 448                              "stosw \n\t"
 449                              "1: rep;stosl ; "
 450                              "popw %%es"
 451                              : "+D" (dst), "+c" (npad)
 452                              : "bdS" (video_segment),
 453                                "a" (0x07200720));
 454         }
 455
 456         /* Restore cursor position */
 457         ax = 0x0200;            /* Set cursor position */
 458         bx = 0;                 /* Page number (<< 8) */
 459         dx = (saved.cury << 8)+saved.curx;
 460         asm volatile(INT10
 461                      : "+a" (ax), "+b" (bx), "+d" (dx)
 462                      : : "ecx", "esi", "edi");
 463 }
 464 #else
 465 #define save_screen()           ((void)0)
 466 #define restore_screen()        ((void)0)
 467 #endif
 468
 469 void set_video(void)
 470 {
 471         u16 mode = boot_params.hdr.vid_mode;
 472
 473         RESET_HEAP();
 474
 475         store_mode_params();
 476         save_screen();
 477         probe_cards(0);
 478
 479         for (;;) {
 480                 if (mode == ASK_VGA)
 481                         mode = mode_menu();
 482
 483                 if (!set_mode(mode))
 484                         break;
 485
 486                 printf("Undefined video mode number: %x\n", mode);
 487                 mode = ASK_VGA;
 488         }
 489         vesa_store_edid();
 490         store_mode_params();
 491
 492         if (do_restore)
 493                 restore_screen();
 494 }