// SPDX-License-Identifier: GPL-2.0-only

  /* -*- linux-c -*- ------------------------------------------------------- *
   *
   *   Copyright (C) 1991, 1992 Linus Torvalds
   *   Copyright 2007 rPath, Inc. - All Rights Reserved

   *   Copyright 2009 Intel Corporation; author H. Peter Anvin

   *

   * ----------------------------------------------------------------------- */
  
  /*

   * 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('
  ');
  
  	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('
  ');
  
  	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('
  ');
  				col = 0;
  			}

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

  	if (col)
  		putchar('
  ');

  }
  
  #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
  ");
  
  	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 
  \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
  ", mode);
  		mode = ASK_VGA;
  	}

  	boot_params.hdr.vid_mode = mode;

  	vesa_store_edid();
  	store_mode_params();
  
  	if (do_restore)
  		restore_screen();
  }