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  *   Copyright 2009 Intel Corporation; author H. Peter Anvin
   6  *
   7  *   This file is part of the Linux kernel, and is made available under
   8  *   the terms of the GNU General Public License version 2.
   9  *
  10  * ----------------------------------------------------------------------- */
  11
  12 /*
  13  * Select video mode
  14  */
  15
  16 #include "boot.h"
  17 #include "video.h"
  18 #include "vesa.h"
  19
  20 static void store_cursor_position(void)
  21 {
  22         struct biosregs ireg, oreg;
  23
  24         initregs(&ireg);
  25         ireg.ah = 0x03;
  26         intcall(0x10, &ireg, &oreg);
  27
  28         boot_params.screen_info.orig_x = oreg.dl;
  29         boot_params.screen_info.orig_y = oreg.dh;
  30 }
  31
  32 static void store_video_mode(void)
  33 {
  34         struct biosregs ireg, oreg;
  35
  36         /* N.B.: the saving of the video page here is a bit silly,
  37            since we pretty much assume page 0 everywhere. */
  38         initregs(&ireg);
  39         ireg.ah = 0x0f;
  40         intcall(0x10, &ireg, &oreg);
  41
  42         /* Not all BIOSes are clean with respect to the top bit */
  43         boot_params.screen_info.orig_video_mode = oreg.al & 0x7f;
  44         boot_params.screen_info.orig_video_page = oreg.bh;
  45 }
  46
  47 /*
  48  * Store the video mode parameters for later usage by the kernel.
  49  * This is done by asking the BIOS except for the rows/columns
  50  * parameters in the default 80x25 mode -- these are set directly,
  51  * because some very obscure BIOSes supply insane values.
  52  */
  53 static void store_mode_params(void)
  54 {
  55         u16 font_size;
  56         int x, y;
  57
  58         /* For graphics mode, it is up to the mode-setting driver
  59            (currently only video-vesa.c) to store the parameters */
  60         if (graphic_mode)
  61                 return;
  62
  63         store_cursor_position();
  64         store_video_mode();
  65
  66         if (boot_params.screen_info.orig_video_mode == 0x07) {
  67                 /* MDA, HGC, or VGA in monochrome mode */
  68                 video_segment = 0xb000;
  69         } else {
  70                 /* CGA, EGA, VGA and so forth */
  71                 video_segment = 0xb800;
  72         }
  73
  74         set_fs(0);
  75         font_size = rdfs16(0x485); /* Font size, BIOS area */
  76         boot_params.screen_info.orig_video_points = font_size;
  77
  78         x = rdfs16(0x44a);
  79         y = (adapter == ADAPTER_CGA) ? 25 : rdfs8(0x484)+1;
  80
  81         if (force_x)
  82                 x = force_x;
  83         if (force_y)
  84                 y = force_y;
  85
  86         boot_params.screen_info.orig_video_cols  = x;
  87         boot_params.screen_info.orig_video_lines = y;
  88 }
  89
  90 static unsigned int get_entry(void)
  91 {
  92         char entry_buf[4];
  93         int i, len = 0;
  94         int key;
  95         unsigned int v;
  96
  97         do {
  98                 key = getchar();
  99
 100                 if (key == '\b') {
 101                         if (len > 0) {
 102                                 puts("\b \b");
 103                                 len--;
 104                         }
 105                 } else if ((key >= '0' && key <= '9') ||
 106                            (key >= 'A' && key <= 'Z') ||
 107                            (key >= 'a' && key <= 'z')) {
 108                         if (len < sizeof entry_buf) {
 109                                 entry_buf[len++] = key;
 110                                 putchar(key);
 111                         }
 112                 }
 113         } while (key != '\r');
 114         putchar('\n');
 115
 116         if (len == 0)
 117                 return VIDEO_CURRENT_MODE; /* Default */
 118
 119         v = 0;
 120         for (i = 0; i < len; i++) {
 121                 v <<= 4;
 122                 key = entry_buf[i] | 0x20;
 123                 v += (key > '9') ? key-'a'+10 : key-'0';
 124         }
 125
 126         return v;
 127 }
 128
 129 static void display_menu(void)
 130 {
 131         struct card_info *card;
 132         struct mode_info *mi;
 133         char ch;
 134         int i;
 135         int nmodes;
 136         int modes_per_line;
 137         int col;
 138
 139         nmodes = 0;
 140         for (card = video_cards; card < video_cards_end; card++)
 141                 nmodes += card->nmodes;
 142
 143         modes_per_line = 1;
 144         if (nmodes >= 20)
 145                 modes_per_line = 3;
 146
 147         for (col = 0; col < modes_per_line; col++)
 148                 puts("Mode: Resolution:  Type: ");
 149         putchar('\n');
 150
 151         col = 0;
 152         ch = '0';
 153         for (card = video_cards; card < video_cards_end; card++) {
 154                 mi = card->modes;
 155                 for (i = 0; i < card->nmodes; i++, mi++) {
 156                         char resbuf[32];
 157                         int visible = mi->x && mi->y;
 158                         u16 mode_id = mi->mode ? mi->mode :
 159                                 (mi->y << 8)+mi->x;
 160
 161                         if (!visible)
 162                                 continue; /* Hidden mode */
 163
 164                         if (mi->depth)
 165                                 sprintf(resbuf, "%dx%d", mi->y, mi->depth);
 166                         else
 167                                 sprintf(resbuf, "%d", mi->y);
 168
 169                         printf("%c %03X %4dx%-7s %-6s",
 170                                ch, mode_id, mi->x, resbuf, card->card_name);
 171                         col++;
 172                         if (col >= modes_per_line) {
 173                                 putchar('\n');
 174                                 col = 0;
 175                         }
 176
 177                         if (ch == '9')
 178                                 ch = 'a';
 179                         else if (ch == 'z' || ch == ' ')
 180                                 ch = ' '; /* Out of keys... */
 181                         else
 182                                 ch++;
 183                 }
 184         }
 185         if (col)
 186                 putchar('\n');
 187 }
 188
 189 #define H(x)    ((x)-'a'+10)
 190 #define SCAN    ((H('s')<<12)+(H('c')<<8)+(H('a')<<4)+H('n'))
 191
 192 static unsigned int mode_menu(void)
 193 {
 194         int key;
 195         unsigned int sel;
 196
 197         puts("Press <ENTER> to see video modes available, "
 198              "<SPACE> to continue, or wait 30 sec\n");
 199
 200         kbd_flush();
 201         while (1) {
 202                 key = getchar_timeout();
 203                 if (key == ' ' || key == 0)
 204                         return VIDEO_CURRENT_MODE; /* Default */
 205                 if (key == '\r')
 206                         break;
 207                 putchar('\a');  /* Beep! */
 208         }
 209
 210
 211         for (;;) {
 212                 display_menu();
 213
 214                 puts("Enter a video mode or \"scan\" to scan for "
 215                      "additional modes: ");
 216                 sel = get_entry();
 217                 if (sel != SCAN)
 218                         return sel;
 219
 220                 probe_cards(1);
 221         }
 222 }
 223
 224 #ifdef CONFIG_VIDEO_RETAIN
 225 /* Save screen content to the heap */
 226 static struct saved_screen {
 227         int x, y;
 228         int curx, cury;
 229         u16 *data;
 230 } saved;
 231
 232 static void save_screen(void)
 233 {
 234         /* Should be called after store_mode_params() */
 235         saved.x = boot_params.screen_info.orig_video_cols;
 236         saved.y = boot_params.screen_info.orig_video_lines;
 237         saved.curx = boot_params.screen_info.orig_x;
 238         saved.cury = boot_params.screen_info.orig_y;
 239
 240         if (!heap_free(saved.x*saved.y*sizeof(u16)+512))
 241                 return;         /* Not enough heap to save the screen */
 242
 243         saved.data = GET_HEAP(u16, saved.x*saved.y);
 244
 245         set_fs(video_segment);
 246         copy_from_fs(saved.data, 0, saved.x*saved.y*sizeof(u16));
 247 }
 248
 249 static void restore_screen(void)
 250 {
 251         /* Should be called after store_mode_params() */
 252         int xs = boot_params.screen_info.orig_video_cols;
 253         int ys = boot_params.screen_info.orig_video_lines;
 254         int y;
 255         addr_t dst = 0;
 256         u16 *src = saved.data;
 257         struct biosregs ireg;
 258
 259         if (graphic_mode)
 260                 return;         /* Can't restore onto a graphic mode */
 261
 262         if (!src)
 263                 return;         /* No saved screen contents */
 264
 265         /* Restore screen contents */
 266
 267         set_fs(video_segment);
 268         for (y = 0; y < ys; y++) {
 269                 int npad;
 270
 271                 if (y < saved.y) {
 272                         int copy = (xs < saved.x) ? xs : saved.x;
 273                         copy_to_fs(dst, src, copy*sizeof(u16));
 274                         dst += copy*sizeof(u16);
 275                         src += saved.x;
 276                         npad = (xs < saved.x) ? 0 : xs-saved.x;
 277                 } else {
 278                         npad = xs;
 279                 }
 280
 281                 /* Writes "npad" blank characters to
 282                    video_segment:dst and advances dst */
 283                 asm volatile("pushw %%es ; "
 284                              "movw %2,%%es ; "
 285                              "shrw %%cx ; "
 286                              "jnc 1f ; "
 287                              "stosw \n\t"
 288                              "1: rep;stosl ; "
 289                              "popw %%es"
 290                              : "+D" (dst), "+c" (npad)
 291                              : "bdS" (video_segment),
 292                                "a" (0x07200720));
 293         }
 294
 295         /* Restore cursor position */
 296         initregs(&ireg);
 297         ireg.ah = 0x02;         /* Set cursor position */
 298         ireg.dh = saved.cury;
 299         ireg.dl = saved.curx;
 300         intcall(0x10, &ireg, NULL);
 301 }
 302 #else
 303 #define save_screen()           ((void)0)
 304 #define restore_screen()        ((void)0)
 305 #endif
 306
 307 void set_video(void)
 308 {
 309         u16 mode = boot_params.hdr.vid_mode;
 310
 311         RESET_HEAP();
 312
 313         store_mode_params();
 314         save_screen();
 315         probe_cards(0);
 316
 317         for (;;) {
 318                 if (mode == ASK_VGA)
 319                         mode = mode_menu();
 320
 321                 if (!set_mode(mode))
 322                         break;
 323
 324                 printf("Undefined video mode number: %x\n", mode);
 325                 mode = ASK_VGA;
 326         }
 327         boot_params.hdr.vid_mode = mode;
 328         vesa_store_edid();
 329         store_mode_params();
 330
 331         if (do_restore)
 332                 restore_screen();
 333 }