Merge branch 'x86-percpu-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[~shefty/rdma-dev.git] / 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 }