[mirror_ubuntu-bionic-kernel.git] / arch / x86 / boot / video.c

/* -*- linux-c -*- ------------------------------------------------------- *
 *
 *   Copyright (C) 1991, 1992 Linus Torvalds
 *   Copyright 2007 rPath, Inc. - All Rights Reserved
 *   Copyright 2009 Intel Corporation; author H. Peter Anvin
 *
 *   This file is part of the Linux kernel, and is made available under
 *   the terms of the GNU General Public License version 2.
 *
 * ----------------------------------------------------------------------- */

/*
 * Select video mode
 */

#include <uapi/asm/boot.h>

#include "boot.h"
#include "video.h"
#include "vesa.h"

static u16 video_segment;

static void store_cursor_position(void)
{
	struct biosregs ireg, oreg;

	initregs(&ireg);
	ireg.ah = 0x03;
	intcall(0x10, &ireg, &oreg);

	boot_params.screen_info.orig_x = oreg.dl;
	boot_params.screen_info.orig_y = oreg.dh;

	if (oreg.ch & 0x20)
		boot_params.screen_info.flags |= VIDEO_FLAGS_NOCURSOR;

	if ((oreg.ch & 0x1f) > (oreg.cl & 0x1f))
		boot_params.screen_info.flags |= VIDEO_FLAGS_NOCURSOR;
}

static void store_video_mode(void)
{
	struct biosregs ireg, oreg;

	/* N.B.: the saving of the video page here is a bit silly,
	   since we pretty much assume page 0 everywhere. */
	initregs(&ireg);
	ireg.ah = 0x0f;
	intcall(0x10, &ireg, &oreg);

	/* Not all BIOSes are clean with respect to the top bit */
	boot_params.screen_info.orig_video_mode = oreg.al & 0x7f;
	boot_params.screen_info.orig_video_page = oreg.bh;
}

/*
 * Store the video mode parameters for later usage by the kernel.
 * This is done by asking the BIOS except for the rows/columns
 * parameters in the default 80x25 mode -- these are set directly,
 * because some very obscure BIOSes supply insane values.
 */
static void store_mode_params(void)
{
	u16 font_size;
	int x, y;

	/* For graphics mode, it is up to the mode-setting driver
	   (currently only video-vesa.c) to store the parameters */
	if (graphic_mode)
		return;

	store_cursor_position();
	store_video_mode();

	if (boot_params.screen_info.orig_video_mode == 0x07) {
		/* MDA, HGC, or VGA in monochrome mode */
		video_segment = 0xb000;
	} else {
		/* CGA, EGA, VGA and so forth */
		video_segment = 0xb800;
	}

	set_fs(0);
	font_size = rdfs16(0x485); /* Font size, BIOS area */
	boot_params.screen_info.orig_video_points = font_size;

	x = rdfs16(0x44a);
	y = (adapter == ADAPTER_CGA) ? 25 : rdfs8(0x484)+1;

	if (force_x)
		x = force_x;
	if (force_y)
		y = force_y;

	boot_params.screen_info.orig_video_cols  = x;
	boot_params.screen_info.orig_video_lines = y;
}

static unsigned int get_entry(void)
{
	char entry_buf[4];
	int i, len = 0;
	int key;
	unsigned int v;

	do {
		key = getchar();

		if (key == '\b') {
			if (len > 0) {
				puts("\b \b");
				len--;
			}
		} else if ((key >= '0' && key <= '9') ||
			   (key >= 'A' && key <= 'Z') ||
			   (key >= 'a' && key <= 'z')) {
			if (len < sizeof entry_buf) {
				entry_buf[len++] = key;
				putchar(key);
			}
		}
	} while (key != '\r');
	putchar('\n');

	if (len == 0)
		return VIDEO_CURRENT_MODE; /* Default */

	v = 0;
	for (i = 0; i < len; i++) {
		v <<= 4;
		key = entry_buf[i] | 0x20;
		v += (key > '9') ? key-'a'+10 : key-'0';
	}

	return v;
}

static void display_menu(void)
{
	struct card_info *card;
	struct mode_info *mi;
	char ch;
	int i;
	int nmodes;
	int modes_per_line;
	int col;

	nmodes = 0;
	for (card = video_cards; card < video_cards_end; card++)
		nmodes += card->nmodes;

	modes_per_line = 1;
	if (nmodes >= 20)
		modes_per_line = 3;

	for (col = 0; col < modes_per_line; col++)
		puts("Mode: Resolution:  Type: ");
	putchar('\n');

	col = 0;
	ch = '0';
	for (card = video_cards; card < video_cards_end; card++) {
		mi = card->modes;
		for (i = 0; i < card->nmodes; i++, mi++) {
			char resbuf[32];
			int visible = mi->x && mi->y;
			u16 mode_id = mi->mode ? mi->mode :
				(mi->y << 8)+mi->x;

			if (!visible)
				continue; /* Hidden mode */

			if (mi->depth)
				sprintf(resbuf, "%dx%d", mi->y, mi->depth);
			else
				sprintf(resbuf, "%d", mi->y);

			printf("%c %03X %4dx%-7s %-6s",
			       ch, mode_id, mi->x, resbuf, card->card_name);
			col++;
			if (col >= modes_per_line) {
				putchar('\n');
				col = 0;
			}

			if (ch == '9')
				ch = 'a';
			else if (ch == 'z' || ch == ' ')
				ch = ' '; /* Out of keys... */
			else
				ch++;
		}
	}
	if (col)
		putchar('\n');
}

#define H(x)	((x)-'a'+10)
#define SCAN	((H('s')<<12)+(H('c')<<8)+(H('a')<<4)+H('n'))

static unsigned int mode_menu(void)
{
	int key;
	unsigned int sel;

	puts("Press <ENTER> to see video modes available, "
	     "<SPACE> to continue, or wait 30 sec\n");

	kbd_flush();
	while (1) {
		key = getchar_timeout();
		if (key == ' ' || key == 0)
			return VIDEO_CURRENT_MODE; /* Default */
		if (key == '\r')
			break;
		putchar('\a');	/* Beep! */
	}


	for (;;) {
		display_menu();

		puts("Enter a video mode or \"scan\" to scan for "
		     "additional modes: ");
		sel = get_entry();
		if (sel != SCAN)
			return sel;

		probe_cards(1);
	}
}

/* Save screen content to the heap */
static struct saved_screen {
	int x, y;
	int curx, cury;
	u16 *data;
} saved;

static void save_screen(void)
{
	/* Should be called after store_mode_params() */
	saved.x = boot_params.screen_info.orig_video_cols;
	saved.y = boot_params.screen_info.orig_video_lines;
	saved.curx = boot_params.screen_info.orig_x;
	saved.cury = boot_params.screen_info.orig_y;

	if (!heap_free(saved.x*saved.y*sizeof(u16)+512))
		return;		/* Not enough heap to save the screen */

	saved.data = GET_HEAP(u16, saved.x*saved.y);

	set_fs(video_segment);
	copy_from_fs(saved.data, 0, saved.x*saved.y*sizeof(u16));
}

static void restore_screen(void)
{
	/* Should be called after store_mode_params() */
	int xs = boot_params.screen_info.orig_video_cols;
	int ys = boot_params.screen_info.orig_video_lines;
	int y;
	addr_t dst = 0;
	u16 *src = saved.data;
	struct biosregs ireg;

	if (graphic_mode)
		return;		/* Can't restore onto a graphic mode */

	if (!src)
		return;		/* No saved screen contents */

	/* Restore screen contents */

	set_fs(video_segment);
	for (y = 0; y < ys; y++) {
		int npad;

		if (y < saved.y) {
			int copy = (xs < saved.x) ? xs : saved.x;
			copy_to_fs(dst, src, copy*sizeof(u16));
			dst += copy*sizeof(u16);
			src += saved.x;
			npad = (xs < saved.x) ? 0 : xs-saved.x;
		} else {
			npad = xs;
		}

		/* Writes "npad" blank characters to
		   video_segment:dst and advances dst */
		asm volatile("pushw %%es ; "
			     "movw %2,%%es ; "
			     "shrw %%cx ; "
			     "jnc 1f ; "
			     "stosw \n\t"
			     "1: rep;stosl ; "
			     "popw %%es"
			     : "+D" (dst), "+c" (npad)
			     : "bdS" (video_segment),
			       "a" (0x07200720));
	}

	/* Restore cursor position */
	if (saved.curx >= xs)
		saved.curx = xs-1;
	if (saved.cury >= ys)
		saved.cury = ys-1;

	initregs(&ireg);
	ireg.ah = 0x02;		/* Set cursor position */
	ireg.dh = saved.cury;
	ireg.dl = saved.curx;
	intcall(0x10, &ireg, NULL);

	store_cursor_position();
}

void set_video(void)
{
	u16 mode = boot_params.hdr.vid_mode;

	RESET_HEAP();

	store_mode_params();
	save_screen();
	probe_cards(0);

	for (;;) {
		if (mode == ASK_VGA)
			mode = mode_menu();

		if (!set_mode(mode))
			break;

		printf("Undefined video mode number: %x\n", mode);
		mode = ASK_VGA;
	}
	boot_params.hdr.vid_mode = mode;
	vesa_store_edid();
	store_mode_params();

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