Eric Lee / smarc-uboot | Embedian Git Server

Commit a085aa1f2737baf60d322296f02c066ee3c6a53e

Authored by Rob Clark 2017-09-14 06:12:21 +0800

Committed by Anatolij Gustschin 2017-09-29 23:53:21 +0800

Exists in smarc_8mq_lf_v2020.04 and in 17 other branches

dm: video: Add basic ANSI escape sequence support

Really just the subset that is needed by efi_console.  Perhaps more will
be added later, for example color support would be useful to implement
efi_cout_set_attribute().

Signed-off-by: Rob Clark <robdclark@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>

Showing 5 changed files with 135 additions and 3 deletions Inline Diff

drivers/video/Kconfig
drivers/video/vidconsole-uclass.c
drivers/video/video-uclass.c
include/video.h
include/video_console.h

drivers/video/Kconfig

Diff comments View file @ a085aa1

 #
 # Video configuration
 #
 menu "Graphics support"
 config DM_VIDEO
 	bool "Enable driver model support for LCD/video"
 	depends on DM
 	help
 	  This enables driver model for LCD and video devices. These support
 	  a bitmap display of various sizes and depths which can be drawn on
 	  to display a command-line console or splash screen. Enabling this
 	  option compiles in the video uclass and routes all LCD/video access
 	  through this.
 config BACKLIGHT_PWM
 	bool "Generic PWM based Backlight Driver"
 	depends on DM_VIDEO && DM_PWM
 	default y
 	help
 	  If you have a LCD backlight adjustable by PWM, say Y to enable
 	  this driver.
 	  This driver can be use with "simple-panel" and
 	  it understands the standard device tree
 	  (leds/backlight/pwm-backlight.txt)
 config BACKLIGHT_GPIO
 	bool "Generic GPIO based Backlight Driver"
 	depends on DM_VIDEO
 	help
 	  If you have a LCD backlight adjustable by GPIO, say Y to enable
 	  this driver.
 	  This driver can be used with "simple-panel" and
 	  it understands the standard device tree
 	  (leds/backlight/gpio-backlight.txt)
 config VIDEO_BPP8
 	bool "Support 8-bit-per-pixel displays"
 	depends on DM_VIDEO
 	default y if DM_VIDEO
 	help
 	  Support drawing text and bitmaps onto a 8-bit-per-pixel display.
 	  Enabling this will include code to support this display. Without
 	  this option, such displays will not be supported and console output
 	  will be empty.
 config VIDEO_BPP16
 	bool "Support 16-bit-per-pixel displays"
 	depends on DM_VIDEO
 	default y if DM_VIDEO
 	help
 	  Support drawing text and bitmaps onto a 16-bit-per-pixel display.
 	  Enabling this will include code to support this display. Without
 	  this option, such displays will not be supported and console output
 	  will be empty.
 config VIDEO_BPP32
 	bool "Support 32-bit-per-pixel displays"
 	depends on DM_VIDEO
 	default y if DM_VIDEO
 	help
 	  Support drawing text and bitmaps onto a 32-bit-per-pixel display.
 	  Enabling this will include code to support this display. Without
 	  this option, such displays will not be supported and console output
 	  will be empty.
+config VIDEO_ANSI
+	bool "Support ANSI escape sequences in video console"
+	depends on DM_VIDEO
+	default y if DM_VIDEO
+	help
+	  Enable ANSI escape sequence decoding for a more fully functional
+	  console.
 config CONSOLE_NORMAL
 	bool "Support a simple text console"
 	depends on DM_VIDEO
 	default y if DM_VIDEO
 	help
 	  Support drawing text on the frame buffer console so that it can be
 	  used as a console. Rotation is not supported by this driver (see
 	  CONFIG_CONSOLE_ROTATION for that). A built-in 8x16 font is used
 	  for the display.
 config CONSOLE_ROTATION
 	bool "Support rotated displays"
 	depends on DM_VIDEO
 	help
 	  Sometimes, for example if the display is mounted in portrait
 	  mode or even if it's mounted landscape but rotated by 180degree,
 	  we need to rotate our content of the display relative to the
 	  framebuffer, so that user can read the messages which are
 	  printed out. Enable this option to include a text driver which can
 	  support this. The rotation is set by the 'rot' parameter in
 	  struct video_priv: 0=unrotated, 1=90 degrees clockwise, 2=180
 	  degrees, 3=270 degrees.
 config CONSOLE_TRUETYPE
 	bool "Support a console that uses TrueType fonts"
 	depends on DM_VIDEO
 	help
 	  TrueTrype fonts can provide outline-drawing capability rather than
 	  needing to provide a bitmap for each font and size that is needed.
 	  With this option you can adjust the text size and use a variety of
 	  fonts. Note that this is noticeably slower than with normal console.
 config CONSOLE_TRUETYPE_SIZE
 	int "TrueType font size"
 	depends on CONSOLE_TRUETYPE
 	default 18
 	help
 	  This sets the font size for the console. The size is measured in
 	  pixels and is the nominal height of a character. Note that fonts
 	  are commonly measured in 'points', being 1/72 inch (about 3.52mm).
 	  However that measurement depends on the size of your display and
 	  there is no standard display density. At present there is not a
 	  method to select the display's physical size, which would allow
 	  U-Boot to calculate the correct font size.
 config SYS_WHITE_ON_BLACK
 	bool "Display console as white on a black background"
 	default y if ARCH_AT91 || ARCH_EXYNOS || ARCH_ROCKCHIP || TEGRA || X86
 	help
 	 Normally the display is black on a white background, Enable this
 	 option to invert this, i.e. white on a black background. This can be
 	 better in low-light situations or to reduce eye strain in some
 	 cases.
 config NO_FB_CLEAR
 	bool "Skip framebuffer clear"
 	help
 	  If firmware (whatever loads u-boot) has already put a splash image
 	  on screen, you might want to preserve it until whatever u-boot
 	  loads takes over the screen.  This, for example, can be used to
 	  keep splash image on screen until grub graphical boot menu starts.
 source "drivers/video/fonts/Kconfig"
 config VIDCONSOLE_AS_LCD
 	bool "Use 'vidconsole' when 'lcd' is seen in stdout"
 	depends on DM_VIDEO
 	help
 	  This is a work-around for boards which have 'lcd' in their stdout
 	  environment variable, but have moved to use driver model for video.
 	  In this case the console will no-longer work. While it is possible
 	  to update the environment, the breakage may be confusing for users.
 	  This option will be removed around the end of 2016.
 config VIDEO_COREBOOT
 	bool "Enable coreboot framebuffer driver support"
 	depends on X86 && SYS_COREBOOT
 	help
 	  Turn on this option to enable a framebuffer driver when U-Boot is
 	  loaded by coreboot where the graphics device is configured by
 	  coreboot already. This can in principle be used with any platform
 	  that coreboot supports.
 config VIDEO_VESA
 	bool "Enable VESA video driver support"
 	default n
 	help
 	  Turn on this option to enable a very simple driver which uses vesa
 	  to discover the video mode and then provides a frame buffer for use
 	  by U-Boot. This can in principle be used with any platform that
 	  supports PCI and video cards that support VESA BIOS Extension (VBE).
 config FRAMEBUFFER_SET_VESA_MODE
 	bool "Set framebuffer graphics resolution"
 	depends on VIDEO_VESA || VIDEO_BROADWELL_IGD
 	help
 	  Set VESA/native framebuffer mode (needed for bootsplash and graphical
 	  framebuffer console)
 choice
 	prompt "framebuffer graphics resolution"
 	default FRAMEBUFFER_VESA_MODE_117
 	depends on FRAMEBUFFER_SET_VESA_MODE
 	help
 	  This option sets the resolution used for the U-Boot framebuffer (and
 	  bootsplash screen).
 config FRAMEBUFFER_VESA_MODE_100
 	bool "640x400 256-color"
 config FRAMEBUFFER_VESA_MODE_101
 	bool "640x480 256-color"
 config FRAMEBUFFER_VESA_MODE_102
 	bool "800x600 16-color"
 config FRAMEBUFFER_VESA_MODE_103
 	bool "800x600 256-color"
 config FRAMEBUFFER_VESA_MODE_104
 	bool "1024x768 16-color"
 config FRAMEBUFFER_VESA_MODE_105
 	bool "1024x768 256-color"
 config FRAMEBUFFER_VESA_MODE_106
 	bool "1280x1024 16-color"
 config FRAMEBUFFER_VESA_MODE_107
 	bool "1280x1024 256-color"
 config FRAMEBUFFER_VESA_MODE_108
 	bool "80x60 text"
 config FRAMEBUFFER_VESA_MODE_109
 	bool "132x25 text"
 config FRAMEBUFFER_VESA_MODE_10A
 	bool "132x43 text"
 config FRAMEBUFFER_VESA_MODE_10B
 	bool "132x50 text"
 config FRAMEBUFFER_VESA_MODE_10C
 	bool "132x60 text"
 config FRAMEBUFFER_VESA_MODE_10D
 	bool "320x200 32k-color (1:5:5:5)"
 config FRAMEBUFFER_VESA_MODE_10E
 	bool "320x200 64k-color (5:6:5)"
 config FRAMEBUFFER_VESA_MODE_10F
 	bool "320x200 16.8M-color (8:8:8)"
 config FRAMEBUFFER_VESA_MODE_110
 	bool "640x480 32k-color (1:5:5:5)"
 config FRAMEBUFFER_VESA_MODE_111
 	bool "640x480 64k-color (5:6:5)"
 config FRAMEBUFFER_VESA_MODE_112
 	bool "640x480 16.8M-color (8:8:8)"
 config FRAMEBUFFER_VESA_MODE_113
 	bool "800x600 32k-color (1:5:5:5)"
 config FRAMEBUFFER_VESA_MODE_114
 	bool "800x600 64k-color (5:6:5)"
 config FRAMEBUFFER_VESA_MODE_115
 	bool "800x600 16.8M-color (8:8:8)"
 config FRAMEBUFFER_VESA_MODE_116
 	bool "1024x768 32k-color (1:5:5:5)"
 config FRAMEBUFFER_VESA_MODE_117
 	bool "1024x768 64k-color (5:6:5)"
 config FRAMEBUFFER_VESA_MODE_118
 	bool "1024x768 16.8M-color (8:8:8)"
 config FRAMEBUFFER_VESA_MODE_119
 	bool "1280x1024 32k-color (1:5:5:5)"
 config FRAMEBUFFER_VESA_MODE_11A
 	bool "1280x1024 64k-color (5:6:5)"
 config FRAMEBUFFER_VESA_MODE_11B
 	bool "1280x1024 16.8M-color (8:8:8)"
 config FRAMEBUFFER_VESA_MODE_USER
 	bool "Manually select VESA mode"
 endchoice
 # Map the config names to an integer (KB).
 config FRAMEBUFFER_VESA_MODE
 	prompt "VESA mode" if FRAMEBUFFER_VESA_MODE_USER
 	hex
 	default 0x100 if FRAMEBUFFER_VESA_MODE_100
 	default 0x101 if FRAMEBUFFER_VESA_MODE_101
 	default 0x102 if FRAMEBUFFER_VESA_MODE_102
 	default 0x103 if FRAMEBUFFER_VESA_MODE_103
 	default 0x104 if FRAMEBUFFER_VESA_MODE_104
 	default 0x105 if FRAMEBUFFER_VESA_MODE_105
 	default 0x106 if FRAMEBUFFER_VESA_MODE_106
 	default 0x107 if FRAMEBUFFER_VESA_MODE_107
 	default 0x108 if FRAMEBUFFER_VESA_MODE_108
 	default 0x109 if FRAMEBUFFER_VESA_MODE_109
 	default 0x10A if FRAMEBUFFER_VESA_MODE_10A
 	default 0x10B if FRAMEBUFFER_VESA_MODE_10B
 	default 0x10C if FRAMEBUFFER_VESA_MODE_10C
 	default 0x10D if FRAMEBUFFER_VESA_MODE_10D
 	default 0x10E if FRAMEBUFFER_VESA_MODE_10E
 	default 0x10F if FRAMEBUFFER_VESA_MODE_10F
 	default 0x110 if FRAMEBUFFER_VESA_MODE_110
 	default 0x111 if FRAMEBUFFER_VESA_MODE_111
 	default 0x112 if FRAMEBUFFER_VESA_MODE_112
 	default 0x113 if FRAMEBUFFER_VESA_MODE_113
 	default 0x114 if FRAMEBUFFER_VESA_MODE_114
 	default 0x115 if FRAMEBUFFER_VESA_MODE_115
 	default 0x116 if FRAMEBUFFER_VESA_MODE_116
 	default 0x117 if FRAMEBUFFER_VESA_MODE_117
 	default 0x118 if FRAMEBUFFER_VESA_MODE_118
 	default 0x119 if FRAMEBUFFER_VESA_MODE_119
 	default 0x11A if FRAMEBUFFER_VESA_MODE_11A
 	default 0x11B if FRAMEBUFFER_VESA_MODE_11B
 	default 0x117 if FRAMEBUFFER_VESA_MODE_USER
 config VIDEO_LCD_ANX9804
 	bool "ANX9804 bridge chip"
 	default n
 	---help---
 	Support for the ANX9804 bridge chip, which can take pixel data coming
 	from a parallel LCD interface and translate it on the fy into a DP
 	interface for driving eDP TFT displays. It uses I2C for configuration.
 config VIDEO_LCD_SSD2828
 	bool "SSD2828 bridge chip"
 	default n
 	---help---
 	Support for the SSD2828 bridge chip, which can take pixel data coming
 	from a parallel LCD interface and translate it on the fly into MIPI DSI
 	interface for driving a MIPI compatible LCD panel. It uses SPI for
 	configuration.
 config VIDEO_LCD_SSD2828_TX_CLK
 	int "SSD2828 TX_CLK frequency (in MHz)"
 	depends on VIDEO_LCD_SSD2828
 	default 0
 	---help---
 	The frequency of the crystal, which is clocking SSD2828. It may be
 	anything in the 8MHz-30MHz range and the exact value should be
 	retrieved from the board schematics. Or in the case of Allwinner
 	hardware, it can be usually found as 'lcd_xtal_freq' variable in
 	FEX files. It can be also set to 0 for selecting PCLK from the
 	parallel LCD interface instead of TX_CLK as the PLL clock source.
 config VIDEO_LCD_SSD2828_RESET
 	string "RESET pin of SSD2828"
 	depends on VIDEO_LCD_SSD2828
 	default ""
 	---help---
 	The reset pin of SSD2828 chip. This takes a string in the format
 	understood by 'name_to_gpio' function, e.g. PH1 for pin 1 of port H.
 config VIDEO_LCD_HITACHI_TX18D42VM
 	bool "Hitachi tx18d42vm LVDS LCD panel support"
 	depends on VIDEO
 	default n
 	---help---
 	Support for Hitachi tx18d42vm LVDS LCD panels, these panels have a
 	lcd controller which needs to be initialized over SPI, once that is
 	done they work like a regular LVDS panel.
 config VIDEO_LCD_SPI_CS
 	string "SPI CS pin for LCD related config job"
 	depends on VIDEO_LCD_SSD2828 || VIDEO_LCD_HITACHI_TX18D42VM
 	default ""
 	---help---
 	This is one of the SPI communication pins, involved in setting up a
 	working LCD configuration. The exact role of SPI may differ for
 	different hardware setups. The option takes a string in the format
 	understood by 'name_to_gpio' function, e.g. PH1 for pin 1 of port H.
 config VIDEO_LCD_SPI_SCLK
 	string "SPI SCLK pin for LCD related config job"
 	depends on VIDEO_LCD_SSD2828 || VIDEO_LCD_HITACHI_TX18D42VM
 	default ""
 	---help---
 	This is one of the SPI communication pins, involved in setting up a
 	working LCD configuration. The exact role of SPI may differ for
 	different hardware setups. The option takes a string in the format
 	understood by 'name_to_gpio' function, e.g. PH1 for pin 1 of port H.
 config VIDEO_LCD_SPI_MOSI
 	string "SPI MOSI pin for LCD related config job"
 	depends on VIDEO_LCD_SSD2828 || VIDEO_LCD_HITACHI_TX18D42VM
 	default ""
 	---help---
 	This is one of the SPI communication pins, involved in setting up a
 	working LCD configuration. The exact role of SPI may differ for
 	different hardware setups. The option takes a string in the format
 	understood by 'name_to_gpio' function, e.g. PH1 for pin 1 of port H.
 config VIDEO_LCD_SPI_MISO
 	string "SPI MISO pin for LCD related config job (optional)"
 	depends on VIDEO_LCD_SSD2828
 	default ""
 	---help---
 	This is one of the SPI communication pins, involved in setting up a
 	working LCD configuration. The exact role of SPI may differ for
 	different hardware setups. If wired up, this pin may provide additional
 	useful functionality. Such as bi-directional communication with the
 	hardware and LCD panel id retrieval (if the panel can report it). The
 	option takes a string in the format understood by 'name_to_gpio'
 	function, e.g. PH1 for pin 1 of port H.
 config VIDEO_MVEBU
 	bool "Armada XP LCD controller"
 	default n
 	---help---
 	Support for the LCD controller integrated in the Marvell
 	Armada XP SoC.
 config I2C_EDID
 	bool "Enable EDID library"
 	depends on DM_I2C
 	default n
 	help
 	   This enables library for accessing EDID data from an LCD panel.
 config DISPLAY
 	bool "Enable Display support"
 	depends on DM
 	default n
 	select I2C_EDID
 	help
 	   This supports drivers that provide a display, such as eDP (Embedded
 	   DisplayPort) and HDMI (High Definition Multimedia Interface).
 	   The devices provide a simple interface to start up the display,
 	   read display information and enable it.
 config ATMEL_HLCD
 	bool "Enable ATMEL video support using HLCDC"
 	depends on DM_VIDEO
 	help
 	   HLCDC supports video output to an attached LCD panel.
 config VIDEO_BROADWELL_IGD
 	bool "Enable Intel Broadwell integrated graphics device"
 	depends on X86
 	help
 	  This enables support for integrated graphics on Intel broadwell
 	  devices. Initialisation is mostly performed by a VGA boot ROM, with
 	  some setup handled by U-Boot itself. The graphics adaptor works as
 	  a VESA device and supports LCD panels, eDP and LVDS outputs.
 	  Configuration of most aspects of device operation is performed using
 	  a special tool which configures the VGA ROM, but the graphics
 	  resolution can be selected in U-Boot.
 config VIDEO_IVYBRIDGE_IGD
 	bool "Enable Intel Ivybridge integration graphics support"
 	depends on X86
 	help
 	  This enables support for integrated graphics on Intel ivybridge
 	  devices. Initialisation is mostly performed by a VGA boot ROM, with
 	  some setup handled by U-Boot itself. The graphics adaptor works as
 	  a VESA device and supports LCD panels, eDP and LVDS outputs.
 	  Configuration of most aspects of device operation is performed using
 	  a special tool which configures the VGA ROM, but the graphics
 	  resolution can be selected in U-Boot.
 config VIDEO_FSL_DCU_FB
 	bool "Enable Freescale Display Control Unit"
 	depends on VIDEO
 	help
 	 This enables support for Freescale Display Control Unit (DCU4)
 	 module found on Freescale Vybrid and QorIQ family of SoCs.
 config VIDEO_FSL_DCU_MAX_FB_SIZE_MB
 	int "Freescale DCU framebuffer size"
 	depends on VIDEO_FSL_DCU_FB
 	default 4194304
 	help
 	 Set maximum framebuffer size to be used for Freescale Display
 	 Controller Unit (DCU4).
 source "drivers/video/rockchip/Kconfig"
 config VIDEO_SANDBOX_SDL
 	bool "Enable sandbox video console using SDL"
 	depends on SANDBOX
 	help
 	  When using sandbox you can enable an emulated LCD display which
 	  appears as an SDL (Simple DirectMedia Layer) window. This is a
 	  console device and can display stdout output. Within U-Boot is is
 	  a normal bitmap display and can display images as well as text.
 source "drivers/video/stm32/Kconfig"
 config VIDEO_TEGRA20
 	bool "Enable LCD support on Tegra20"
 	depends on OF_CONTROL
 	help
 	   Tegra20 supports video output to an attached LCD panel as well as
 	   other options such as HDMI. Only the LCD is supported in U-Boot.
 	   This option enables this support which can be used on devices which
 	   have an LCD display connected.
 config VIDEO_TEGRA124
 	bool "Enable video support on Tegra124"
 	depends on DM_VIDEO
 	help
 	   Tegra124 supports many video output options including eDP and
 	   HDMI. At present only eDP is supported by U-Boot. This option
 	   enables this support which can be used on devices which
 	   have an eDP display connected.
 source "drivers/video/bridge/Kconfig"
 config VIDEO
 	bool "Enable legacy video support"
 	depends on !DM_VIDEO
 	help
 	  Define this for video support, without using driver model. Some
 	  drivers use this because they are not yet converted to driver
 	  model. Video drivers typically provide a colour text console and
 	  cursor.
 config VIDEO_IPUV3
 	bool "i.MX IPUv3 Core video support"
 	depends on VIDEO && MX6
 	help
 	  This enables framebuffer driver for i.MX processors working
 	  on the IPUv3(Image Processing Unit) internal graphic processor.
 config CFB_CONSOLE
 	bool "Enable colour frame buffer console"
 	depends on VIDEO
 	default y if VIDEO
 	help
 	  Enables the colour frame buffer driver. This supports colour
 	  output on a bitmap display from an in-memory frame buffer.
 	  Several colour devices are supported along with various options to
 	  adjust the supported features. The driver is implemented in
 	  cfb_console.c
 	  The following defines are needed (cf. smiLynxEM, i8042)
 		VIDEO_FB_LITTLE_ENDIAN	graphic memory organisation
 					(default big endian)
 		VIDEO_HW_RECTFILL	graphic chip supports
 					rectangle fill (cf. smiLynxEM)
 		VIDEO_HW_BITBLT		graphic chip supports
 					bit-blit (cf. smiLynxEM)
 		VIDEO_VISIBLE_COLS	visible pixel columns (cols=pitch)
 		VIDEO_VISIBLE_ROWS	visible pixel rows
 		VIDEO_PIXEL_SIZE	bytes per pixel
 		VIDEO_DATA_FORMAT	graphic data format
 					(0-5, cf. cfb_console.c)
 		VIDEO_FB_ADRS		framebuffer address
 		VIDEO_KBD_INIT_FCT	keyboard int fct (i.e. rx51_kp_init())
 		VIDEO_TSTC_FCT		test char fct (i.e. rx51_kp_tstc)
 		VIDEO_GETC_FCT		get char fct (i.e. rx51_kp_getc)
 		CONFIG_VIDEO_LOGO	display Linux logo in upper left corner
 		CONFIG_VIDEO_BMP_LOGO	use bmp_logo.h instead of linux_logo.h
 					for logo. Requires CONFIG_VIDEO_LOGO
 		CONFIG_CONSOLE_EXTRA_INFO
 					additional board info beside
 					the logo
 		CONFIG_HIDE_LOGO_VERSION
 					do not display bootloader
 					version string
 	  When CONFIG_CFB_CONSOLE is defined, the video console is the
 	  default console. The serial console can be forced by setting the
 	  environment 'console=serial'.
 config CFB_CONSOLE_ANSI
 	bool "Support ANSI escape sequences"
 	depends on CFB_CONSOLE
 	help
 	  This allows the colour buffer frame buffer driver to support
 	  a limited number of ANSI escape sequences (cursor control,
 	  erase functions and limited graphics rendition control). Normal
 	  output from U-Boot will pass through this filter.
 config VGA_AS_SINGLE_DEVICE
 	bool "Set the video as an output-only device"
 	depends on CFB_CONSOLE
 	default y
 	help
 	  If enable the framebuffer device will be initialized as an
 	  output-only device. The Keyboard driver will not be set up. This
 	  may be used if you have no keyboard device, or more than one
 	  (USB Keyboard, AT Keyboard).
 config VIDEO_SW_CURSOR
 	bool "Enable a software cursor"
 	depends on CFB_CONSOLE
 	default y if CFB_CONSOLE
 	help
 	  This draws a cursor after the last character. No blinking is
 	  provided. This makes it possible to see the current cursor
 	  position when entering text on the console. It is recommended to
 	  enable this.
 config CONSOLE_EXTRA_INFO
 	bool "Display additional board information"
 	depends on CFB_CONSOLE
 	help
 	  Display additional board information strings that normally go to
 	  the serial port. When this option is enabled, a board-specific
 	  function video_get_info_str() is called to get the string for
 	  each line of the display. The function should return the string,
 	  which can be empty if there is nothing to display for that line.
 config CONSOLE_SCROLL_LINES
 	int "Number of lines to scroll the console by"
 	depends on CFB_CONSOLE || DM_VIDEO || LCD
 	default 1
 	help
 	  When the console need to be scrolled, this is the number of
 	  lines to scroll by. It defaults to 1. Increasing this makes the
 	  console jump but can help speed up operation when scrolling
 	  is slow.
 config SYS_CONSOLE_BG_COL
 	hex "Background colour"
 	depends on CFB_CONSOLE
 	default 0x00
 	help
 	  Defines the background colour for the console. The value is from
 	  0x00 to 0xff and the meaning depends on the graphics card.
 	  Typically, 0x00 means black and 0xff means white. Do not set
 	  the background and foreground to the same colour or you will see
 	  nothing.
 config SYS_CONSOLE_FG_COL
 	hex "Foreground colour"
 	depends on CFB_CONSOLE
 	default 0xa0
 	help
 	  Defines the foreground colour for the console. The value is from
 	  0x00 to 0xff and the meaning depends on the graphics card.
 	  Typically, 0x00 means black and 0xff means white. Do not set
 	  the background and foreground to the same colour or you will see
 	  nothing.
 config LCD
 	bool "Enable legacy LCD support"
 	help
 	  Define this to enable LCD support (for output to LCD display).
 	  You will also need to select an LCD driver using an additional
 	  CONFIG option. See the README for details. Drives which have been
 	  converted to driver model will instead used CONFIG_DM_VIDEO.
 config VIDEO_DW_HDMI
 	bool
 	help
 	  Enables the common driver code for the Designware HDMI TX
 	  block found in SoCs from various vendors.
 	  As this does not provide any functionality by itself (but
 	  rather requires a SoC-specific glue driver to call it), it
 	  can not be enabled from the configuration menu.
 config VIDEO_SIMPLE
 	bool "Simple display driver for preconfigured display"
 	help
 	  Enables a simple generic display driver which utilizes the
 	  simple-framebuffer devicetree bindings.
 	  This driver assumes that the display hardware has been initialized
 	  before u-boot starts, and u-boot will simply render to the pre-
 	  allocated frame buffer surface.
 endmenu

drivers/video/vidconsole-uclass.c

Diff comments View file @ a085aa1

 /*
  * Copyright (c) 2015 Google, Inc
  * (C) Copyright 2001-2015
  * DENX Software Engineering -- wd@denx.de
  * Compulab Ltd - http://compulab.co.il/
  * Bernecker & Rainer Industrieelektronik GmbH - http://www.br-automation.com
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <common.h>
+#include <linux/ctype.h>
 #include <dm.h>
 #include <video.h>
 #include <video_console.h>
 #include <video_font.h>		/* Get font data, width and height */
 /* By default we scroll by a single line */
 #ifndef CONFIG_CONSOLE_SCROLL_LINES
 #define CONFIG_CONSOLE_SCROLL_LINES 1
 #endif
 int vidconsole_putc_xy(struct udevice *dev, uint x, uint y, char ch)
 {
 	struct vidconsole_ops *ops = vidconsole_get_ops(dev);
 	if (!ops->putc_xy)
 		return -ENOSYS;
 	return ops->putc_xy(dev, x, y, ch);
 }
 int vidconsole_move_rows(struct udevice *dev, uint rowdst, uint rowsrc,
 			 uint count)
 {
 	struct vidconsole_ops *ops = vidconsole_get_ops(dev);
 	if (!ops->move_rows)
 		return -ENOSYS;
 	return ops->move_rows(dev, rowdst, rowsrc, count);
 }
 int vidconsole_set_row(struct udevice *dev, uint row, int clr)
 {
 	struct vidconsole_ops *ops = vidconsole_get_ops(dev);
 	if (!ops->set_row)
 		return -ENOSYS;
 	return ops->set_row(dev, row, clr);
 }
 static int vidconsole_entry_start(struct udevice *dev)
 {
 	struct vidconsole_ops *ops = vidconsole_get_ops(dev);
 	if (!ops->entry_start)
 		return -ENOSYS;
 	return ops->entry_start(dev);
 }
 /* Move backwards one space */
 static int vidconsole_back(struct udevice *dev)
 {
 	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 	struct vidconsole_ops *ops = vidconsole_get_ops(dev);
 	int ret;
 	if (ops->backspace) {
 		ret = ops->backspace(dev);
 		if (ret != -ENOSYS)
 			return ret;
 	}
 	priv->xcur_frac -= VID_TO_POS(priv->x_charsize);
 	if (priv->xcur_frac < priv->xstart_frac) {
 		priv->xcur_frac = (priv->cols - 1) *
 			VID_TO_POS(priv->x_charsize);
 		priv->ycur -= priv->y_charsize;
 		if (priv->ycur < 0)
 			priv->ycur = 0;
 	}
 	video_sync(dev->parent);
 	return 0;
 }
 /* Move to a newline, scrolling the display if necessary */
 static void vidconsole_newline(struct udevice *dev)
 {
 	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 	struct udevice *vid_dev = dev->parent;
 	struct video_priv *vid_priv = dev_get_uclass_priv(vid_dev);
 	const int rows = CONFIG_CONSOLE_SCROLL_LINES;
 	int i;
 	priv->xcur_frac = priv->xstart_frac;
 	priv->ycur += priv->y_charsize;
 	/* Check if we need to scroll the terminal */
 	if ((priv->ycur + priv->y_charsize) / priv->y_charsize > priv->rows) {
 		vidconsole_move_rows(dev, 0, rows, priv->rows - rows);
 		for (i = 0; i < rows; i++)
 			vidconsole_set_row(dev, priv->rows - i - 1,
 					   vid_priv->colour_bg);
 		priv->ycur -= rows * priv->y_charsize;
 	}
 	priv->last_ch = 0;
 	video_sync(dev->parent);
 }
+static char *parsenum(char *s, int *num)
+{
+	char *end;
+	*num = simple_strtol(s, &end, 10);
+	return end;
+}
+/*
+ * Process a character while accumulating an escape string.  Chars are
+ * accumulated into escape_buf until the end of escape sequence is
+ * found, at which point the sequence is parsed and processed.
+ */
+static void vidconsole_escape_char(struct udevice *dev, char ch)
+{
+	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
+	if (!IS_ENABLED(CONFIG_VIDEO_ANSI))
+		goto error;
+	/* Sanity checking for bogus ESC sequences: */
+	if (priv->escape_len >= sizeof(priv->escape_buf))
+		goto error;
+	if (priv->escape_len == 0 && ch != '[')
+		goto error;
+	priv->escape_buf[priv->escape_len++] = ch;
+	/*
+	 * Escape sequences are terminated by a letter, so keep
+	 * accumulating until we get one:
+	 */
+	if (!isalpha(ch))
+		return;
+	/*
+	 * clear escape mode first, otherwise things will get highly
+	 * surprising if you hit any debug prints that come back to
+	 * this console.
+	 */
+	priv->escape = 0;
+	switch (ch) {
+	case 'H':
+	case 'f': {
+		int row, col;
+		char *s = priv->escape_buf;
+		/*
+		 * Set cursor position: [%d;%df or [%d;%dH
+		 */
+		s++;    /* [ */
+		s = parsenum(s, &row);
+		s++;    /* ; */
+		s = parsenum(s, &col);
+		priv->ycur = row * priv->y_charsize;
+		priv->xcur_frac = priv->xstart_frac +
+			VID_TO_POS(col * priv->x_charsize);
+		break;
+	}
+	case 'J': {
+		int mode;
+		/*
+		 * Clear part/all screen:
+		 *   [J or [0J - clear screen from cursor down
+		 *   [1J       - clear screen from cursor up
+		 *   [2J       - clear entire screen
+		 *
+		 * TODO we really only handle entire-screen case, others
+		 * probably require some additions to video-uclass (and
+		 * are not really needed yet by efi_console)
+		 */
+		parsenum(priv->escape_buf + 1, &mode);
+		if (mode == 2) {
+			video_clear(dev->parent);
+			video_sync(dev->parent);
+			priv->ycur = 0;
+			priv->xcur_frac = priv->xstart_frac;
+		} else {
+			debug("unsupported clear mode: %d\n", mode);
+		}
+		break;
+	}
+	default:
+		debug("unrecognized escape sequence: %*s\n",
+		      priv->escape_len, priv->escape_buf);
+	}
+	return;
+error:
+	/* something went wrong, just revert to normal mode: */
+	priv->escape = 0;
+}
 int vidconsole_put_char(struct udevice *dev, char ch)
 {
 	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 	int ret;
+	if (priv->escape) {
+		vidconsole_escape_char(dev, ch);
+		return 0;
+	}
 	switch (ch) {
+	case '\x1b':
+		priv->escape_len = 0;
+		priv->escape = 1;
+		break;
 	case '\a':
 		/* beep */
 		break;
 	case '\r':
 		priv->xcur_frac = priv->xstart_frac;
 		break;
 	case '\n':
 		vidconsole_newline(dev);
 		vidconsole_entry_start(dev);
 		break;
 	case '\t':	/* Tab (8 chars alignment) */
 		priv->xcur_frac = ((priv->xcur_frac / priv->tab_width_frac)
 				+ 1) * priv->tab_width_frac;
 		if (priv->xcur_frac >= priv->xsize_frac)
 			vidconsole_newline(dev);
 		break;
 	case '\b':
 		vidconsole_back(dev);
 		priv->last_ch = 0;
 		break;
 	default:
 		/*
 		 * Failure of this function normally indicates an unsupported
 		 * colour depth. Check this and return an error to help with
 		 * diagnosis.
 		 */
 		ret = vidconsole_putc_xy(dev, priv->xcur_frac, priv->ycur, ch);
 		if (ret == -EAGAIN) {
 			vidconsole_newline(dev);
 			ret = vidconsole_putc_xy(dev, priv->xcur_frac,
 						 priv->ycur, ch);
 		}
 		if (ret < 0)
 			return ret;
 		priv->xcur_frac += ret;
 		priv->last_ch = ch;
 		if (priv->xcur_frac >= priv->xsize_frac)
 			vidconsole_newline(dev);
 		break;
 	}
 	return 0;
 }
 static void vidconsole_putc(struct stdio_dev *sdev, const char ch)
 {
 	struct udevice *dev = sdev->priv;
 	vidconsole_put_char(dev, ch);
 	video_sync(dev->parent);
 }
 static void vidconsole_puts(struct stdio_dev *sdev, const char *s)
 {
 	struct udevice *dev = sdev->priv;
 	while (*s)
 		vidconsole_put_char(dev, *s++);
 	video_sync(dev->parent);
 }
 /* Set up the number of rows and colours (rotated drivers override this) */
 static int vidconsole_pre_probe(struct udevice *dev)
 {
 	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 	struct udevice *vid = dev->parent;
 	struct video_priv *vid_priv = dev_get_uclass_priv(vid);
 	priv->xsize_frac = VID_TO_POS(vid_priv->xsize);
 	return 0;
 }
 /* Register the device with stdio */
 static int vidconsole_post_probe(struct udevice *dev)
 {
 	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 	struct stdio_dev *sdev = &priv->sdev;
 	if (!priv->tab_width_frac)
 		priv->tab_width_frac = VID_TO_POS(priv->x_charsize) * 8;
 	if (dev->seq) {
 		snprintf(sdev->name, sizeof(sdev->name), "vidconsole%d",
 			 dev->seq);
 	} else {
 		strcpy(sdev->name, "vidconsole");
 	}
 	sdev->flags = DEV_FLAGS_OUTPUT;
 	sdev->putc = vidconsole_putc;
 	sdev->puts = vidconsole_puts;
 	sdev->priv = dev;
 	return stdio_register(sdev);
 }
 UCLASS_DRIVER(vidconsole) = {
 	.id		= UCLASS_VIDEO_CONSOLE,
 	.name		= "vidconsole0",
 	.pre_probe	= vidconsole_pre_probe,
 	.post_probe	= vidconsole_post_probe,
 	.per_device_auto_alloc_size	= sizeof(struct vidconsole_priv),
 };
 void vidconsole_position_cursor(struct udevice *dev, unsigned col, unsigned row)
 {
 	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 	struct udevice *vid_dev = dev->parent;
 	struct video_priv *vid_priv = dev_get_uclass_priv(vid_dev);
 	priv->xcur_frac = VID_TO_POS(min_t(short, col, vid_priv->xsize - 1));
 	priv->ycur = min_t(short, row, vid_priv->ysize - 1);
 }
 static int do_video_setcursor(cmd_tbl_t *cmdtp, int flag, int argc,
 			      char *const argv[])
 {
 	unsigned int col, row;
 	struct udevice *dev;
 	if (argc != 3)
 		return CMD_RET_USAGE;
 	if (uclass_first_device_err(UCLASS_VIDEO_CONSOLE, &dev))
 		return CMD_RET_FAILURE;
 	col = simple_strtoul(argv[1], NULL, 10);
 	row = simple_strtoul(argv[2], NULL, 10);
 	vidconsole_position_cursor(dev, col, row);
 	return 0;
 }
 static int do_video_puts(cmd_tbl_t *cmdtp, int flag, int argc,
 			 char *const argv[])
 {
 	struct udevice *dev;
 	const char *s;
 	if (argc != 2)
 		return CMD_RET_USAGE;
 	if (uclass_first_device_err(UCLASS_VIDEO_CONSOLE, &dev))
 		return CMD_RET_FAILURE;
 	for (s = argv[1]; *s; s++)
 		vidconsole_put_char(dev, *s);
 	video_sync(dev->parent);
 	return 0;
 }
 U_BOOT_CMD(
 	setcurs, 3,	1,	do_video_setcursor,
 	"set cursor position within screen",
 	"    <col> <row> in character"
 );
 U_BOOT_CMD(
 	lcdputs, 2,	1,	do_video_puts,
 	"print string on video framebuffer",
 	"    <string>"
 );

drivers/video/video-uclass.c

Diff comments View file @ a085aa1

 /*
  * Copyright (c) 2015 Google, Inc
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <common.h>
 #include <dm.h>
 #include <mapmem.h>
 #include <stdio_dev.h>
 #include <video.h>
 #include <video_console.h>
 #include <dm/lists.h>
 #include <dm/device-internal.h>
 #include <dm/uclass-internal.h>
 #ifdef CONFIG_SANDBOX
 #include <asm/sdl.h>
 #endif
 /*
  * Theory of operation:
  *
  * Before relocation each device is bound. The driver for each device must
  * set the @align and @size values in struct video_uc_platdata. This
  * information represents the requires size and alignment of the frame buffer
  * for the device. The values can be an over-estimate but cannot be too
  * small. The actual values will be suppled (in the same manner) by the bind()
  * method after relocation.
  *
  * This information is then picked up by video_reserve() which works out how
  * much memory is needed for all devices. This is allocated between
  * gd->video_bottom and gd->video_top.
  *
  * After relocation the same process occurs. The driver supplies the same
  * @size and @align information and this time video_post_bind() checks that
  * the drivers does not overflow the allocated memory.
  *
  * The frame buffer address is actually set (to plat->base) in
  * video_post_probe(). This function also clears the frame buffer and
  * allocates a suitable text console device. This can then be used to write
  * text to the video device.
  */
 DECLARE_GLOBAL_DATA_PTR;
 void video_set_flush_dcache(struct udevice *dev, bool flush)
 {
 	struct video_priv *priv = dev_get_uclass_priv(dev);
 	priv->flush_dcache = flush;
 }
 static ulong alloc_fb(struct udevice *dev, ulong *addrp)
 {
 	struct video_uc_platdata *plat = dev_get_uclass_platdata(dev);
 	ulong base, align, size;
 	if (!plat->size)
 		return 0;
 	align = plat->align ? plat->align : 1 << 20;
 	base = *addrp - plat->size;
 	base &= ~(align - 1);
 	plat->base = base;
 	size = *addrp - base;
 	*addrp = base;
 	return size;
 }
 int video_reserve(ulong *addrp)
 {
 	struct udevice *dev;
 	ulong size;
 	gd->video_top = *addrp;
 	for (uclass_find_first_device(UCLASS_VIDEO, &dev);
 	     dev;
 	     uclass_find_next_device(&dev)) {
 		size = alloc_fb(dev, addrp);
 		debug("%s: Reserving %lx bytes at %lx for video device '%s'\n",
 		      __func__, size, *addrp, dev->name);
 	}
 	gd->video_bottom = *addrp;
 	debug("Video frame buffers from %lx to %lx\n", gd->video_bottom,
 	      gd->video_top);
 	return 0;
 }
-static int video_clear(struct udevice *dev)
+void video_clear(struct udevice *dev)
 {
 	struct video_priv *priv = dev_get_uclass_priv(dev);
 	if (priv->bpix == VIDEO_BPP32) {
 		u32 *ppix = priv->fb;
 		u32 *end = priv->fb + priv->fb_size;
 		while (ppix < end)
 			*ppix++ = priv->colour_bg;
 	} else {
 		memset(priv->fb, priv->colour_bg, priv->fb_size);
 	}
-	return 0;
 }
 /* Flush video activity to the caches */
 void video_sync(struct udevice *vid)
 {
 	/*
 	 * flush_dcache_range() is declared in common.h but it seems that some
 	 * architectures do not actually implement it. Is there a way to find
 	 * out whether it exists? For now, ARM is safe.
 	 */
 #if defined(CONFIG_ARM) && !defined(CONFIG_SYS_DCACHE_OFF)
 	struct video_priv *priv = dev_get_uclass_priv(vid);
 	if (priv->flush_dcache) {
 		flush_dcache_range((ulong)priv->fb,
 				   ALIGN((ulong)priv->fb + priv->fb_size,
 					 CONFIG_SYS_CACHELINE_SIZE));
 	}
 #elif defined(CONFIG_VIDEO_SANDBOX_SDL)
 	struct video_priv *priv = dev_get_uclass_priv(vid);
 	static ulong last_sync;
 	if (get_timer(last_sync) > 10) {
 		sandbox_sdl_sync(priv->fb);
 		last_sync = get_timer(0);
 	}
 #endif
 }
 void video_sync_all(void)
 {
 	struct udevice *dev;
 	for (uclass_find_first_device(UCLASS_VIDEO, &dev);
 	     dev;
 	     uclass_find_next_device(&dev)) {
 		if (device_active(dev))
 			video_sync(dev);
 	}
 }
 int video_get_xsize(struct udevice *dev)
 {
 	struct video_priv *priv = dev_get_uclass_priv(dev);
 	return priv->xsize;
 }
 int video_get_ysize(struct udevice *dev)
 {
 	struct video_priv *priv = dev_get_uclass_priv(dev);
 	return priv->ysize;
 }
 /* Set up the colour map */
 static int video_pre_probe(struct udevice *dev)
 {
 	struct video_priv *priv = dev_get_uclass_priv(dev);
 	priv->cmap = calloc(256, sizeof(ushort));
 	if (!priv->cmap)
 		return -ENOMEM;
 	return 0;
 }
 static int video_pre_remove(struct udevice *dev)
 {
 	struct video_priv *priv = dev_get_uclass_priv(dev);
 	free(priv->cmap);
 	return 0;
 }
 /* Set up the display ready for use */
 static int video_post_probe(struct udevice *dev)
 {
 	struct video_uc_platdata *plat = dev_get_uclass_platdata(dev);
 	struct video_priv *priv = dev_get_uclass_priv(dev);
 	char name[30], drv[15], *str;
 	const char *drv_name = drv;
 	struct udevice *cons;
 	int ret;
 	/* Set up the line and display size */
 	priv->fb = map_sysmem(plat->base, plat->size);
 	priv->line_length = priv->xsize * VNBYTES(priv->bpix);
 	priv->fb_size = priv->line_length * priv->ysize;
 	/* Set up colours - we could in future support other colours */
 #ifdef CONFIG_SYS_WHITE_ON_BLACK
 	priv->colour_fg = 0xffffff;
 #else
 	priv->colour_bg = 0xffffff;
 #endif
 	if (!CONFIG_IS_ENABLED(NO_FB_CLEAR))
 		video_clear(dev);
 	/*
 	 * Create a text console device. For now we always do this, although
 	 * it might be useful to support only bitmap drawing on the device
 	 * for boards that don't need to display text. We create a TrueType
 	 * console if enabled, a rotated console if the video driver requests
 	 * it, otherwise a normal console.
 	 *
 	 * The console can be override by setting vidconsole_drv_name before
 	 * probing this video driver, or in the probe() method.
 	 *
 	 * TrueType does not support rotation at present so fall back to the
 	 * rotated console in that case.
 	 */
 	if (!priv->rot && IS_ENABLED(CONFIG_CONSOLE_TRUETYPE)) {
 		snprintf(name, sizeof(name), "%s.vidconsole_tt", dev->name);
 		strcpy(drv, "vidconsole_tt");
 	} else {
 		snprintf(name, sizeof(name), "%s.vidconsole%d", dev->name,
 			 priv->rot);
 		snprintf(drv, sizeof(drv), "vidconsole%d", priv->rot);
 	}
 	str = strdup(name);
 	if (!str)
 		return -ENOMEM;
 	if (priv->vidconsole_drv_name)
 		drv_name = priv->vidconsole_drv_name;
 	ret = device_bind_driver(dev, drv_name, str, &cons);
 	if (ret) {
 		debug("%s: Cannot bind console driver\n", __func__);
 		return ret;
 	}
 	ret = device_probe(cons);
 	if (ret) {
 		debug("%s: Cannot probe console driver\n", __func__);
 		return ret;
 	}
 	return 0;
 };
 /* Post-relocation, allocate memory for the frame buffer */
 static int video_post_bind(struct udevice *dev)
 {
 	ulong addr = gd->video_top;
 	ulong size;
 	/* Before relocation there is nothing to do here */
 	if ((!gd->flags & GD_FLG_RELOC))
 		return 0;
 	size = alloc_fb(dev, &addr);
 	if (addr < gd->video_bottom) {
 		/* Device tree node may need the 'u-boot,dm-pre-reloc' tag */
 		printf("Video device '%s' cannot allocate frame buffer memory -ensure the device is set up before relocation\n",
 		       dev->name);
 		return -ENOSPC;
 	}
 	debug("%s: Claiming %lx bytes at %lx for video device '%s'\n",
 	      __func__, size, addr, dev->name);
 	gd->video_bottom = addr;
 	return 0;
 }
 UCLASS_DRIVER(video) = {
 	.id		= UCLASS_VIDEO,
 	.name		= "video",
 	.flags		= DM_UC_FLAG_SEQ_ALIAS,
 	.post_bind	= video_post_bind,
 	.pre_probe	= video_pre_probe,
 	.post_probe	= video_post_probe,
 	.pre_remove	= video_pre_remove,
 	.per_device_auto_alloc_size	= sizeof(struct video_priv),
 	.per_device_platdata_auto_alloc_size = sizeof(struct video_uc_platdata),
 };

include/video.h

Diff comments View file @ a085aa1

 /*
  * Video uclass and legacy implementation
  *
  * Copyright (c) 2015 Google, Inc
  *
  * MPC823 Video Controller
  * =======================
  * (C) 2000 by Paolo Scaffardi (arsenio@tin.it)
  * AIRVENT SAM s.p.a - RIMINI(ITALY)
  *
  */
 #ifndef _VIDEO_H_
 #define _VIDEO_H_
 #ifdef CONFIG_DM_VIDEO
 #include <stdio_dev.h>
 struct video_uc_platdata {
 	uint align;
 	uint size;
 	ulong base;
 };
 enum video_polarity {
 	VIDEO_ACTIVE_HIGH,	/* Pins are active high */
 	VIDEO_ACTIVE_LOW,	/* Pins are active low */
 };
 /*
  * Bits per pixel selector. Each value n is such that the bits-per-pixel is
  * 2 ^ n
  */
 enum video_log2_bpp {
 	VIDEO_BPP1	= 0,
 	VIDEO_BPP2,
 	VIDEO_BPP4,
 	VIDEO_BPP8,
 	VIDEO_BPP16,
 	VIDEO_BPP32,
 };
 /*
  * Convert enum video_log2_bpp to bytes and bits. Note we omit the outer
  * brackets to allow multiplication by fractional pixels.
  */
 #define VNBYTES(bpix)	(1 << (bpix)) / 8
 #define VNBITS(bpix)	(1 << (bpix))
 /**
  * struct video_priv - Device information used by the video uclass
  *
  * @xsize:	Number of pixel columns (e.g. 1366)
  * @ysize:	Number of pixels rows (e.g.. 768)
  * @rot:	Display rotation (0=none, 1=90 degrees clockwise, etc.)
  * @bpix:	Encoded bits per pixel
  * @vidconsole_drv_name:	Driver to use for the text console, NULL to
  *		select automatically
  * @font_size:	Font size in pixels (0 to use a default value)
  * @fb:		Frame buffer
  * @fb_size:	Frame buffer size
  * @line_length:	Length of each frame buffer line, in bytes
  * @colour_fg:	Foreground colour (pixel value)
  * @colour_bg:	Background colour (pixel value)
  * @flush_dcache:	true to enable flushing of the data cache after
  *		the LCD is updated
  * @cmap:	Colour map for 8-bit-per-pixel displays
  */
 struct video_priv {
 	/* Things set up by the driver: */
 	ushort xsize;
 	ushort ysize;
 	ushort rot;
 	enum video_log2_bpp bpix;
 	const char *vidconsole_drv_name;
 	int font_size;
 	/*
 	 * Things that are private to the uclass: don't use these in the
 	 * driver
 	 */
 	void *fb;
 	int fb_size;
 	int line_length;
 	int colour_fg;
 	int colour_bg;
 	bool flush_dcache;
 	ushort *cmap;
 };
 /* Placeholder - there are no video operations at present */
 struct video_ops {
 };
 #define video_get_ops(dev)        ((struct video_ops *)(dev)->driver->ops)
 /**
  * video_reserve() - Reserve frame-buffer memory for video devices
  *
  * Note: This function is for internal use.
  *
  * This uses the uclass platdata's @size and @align members to figure out
  * a size and position for each frame buffer as part of the pre-relocation
  * process of determining the post-relocation memory layout.
  *
  * gd->video_top is set to the initial value of *@addrp and gd->video_bottom
  * is set to the final value.
  *
  * @addrp:	On entry, the top of available memory. On exit, the new top,
  *		after allocating the required memory.
  * @return 0
  */
 int video_reserve(ulong *addrp);
 /**
+ * video_clear() - Clear a device's frame buffer to background color.
+ *
+ * @dev:	Device to clear
+ */
+void video_clear(struct udevice *dev);
+/**
  * video_sync() - Sync a device's frame buffer with its hardware
  *
  * Some frame buffers are cached or have a secondary frame buffer. This
  * function syncs these up so that the current contents of the U-Boot frame
  * buffer are displayed to the user.
  *
  * @dev:	Device to sync
  */
 void video_sync(struct udevice *vid);
 /**
  * video_sync_all() - Sync all devices' frame buffers with there hardware
  *
  * This calls video_sync() on all active video devices.
  */
 void video_sync_all(void);
 /**
  * video_bmp_display() - Display a BMP file
  *
  * @dev:	Device to display the bitmap on
  * @bmp_image:	Address of bitmap image to display
  * @x:		X position in pixels from the left
  * @y:		Y position in pixels from the top
  * @align:	true to adjust the coordinates to centre the image. If false
  *		the coordinates are used as is. If true:
  *
  *		- if a coordinate is 0x7fff then the image will be centred in
  *		  that direction
  *		- if a coordinate is -ve then it will be offset to the
  *		  left/top of the centre by that many pixels
  *		- if a coordinate is positive it will be used unchnaged.
  * @return 0 if OK, -ve on error
  */
 int video_bmp_display(struct udevice *dev, ulong bmp_image, int x, int y,
 		      bool align);
 /**
  * video_get_xsize() - Get the width of the display in pixels
  *
  * @dev:	Device to check
  * @return device frame buffer width in pixels
  */
 int video_get_xsize(struct udevice *dev);
 /**
  * video_get_ysize() - Get the height of the display in pixels
  *
  * @dev:	Device to check
  * @return device frame buffer height in pixels
  */
 int video_get_ysize(struct udevice *dev);
 /**
  * Set whether we need to flush the dcache when changing the image. This
  * defaults to off.
  *
  * @param flush		non-zero to flush cache after update, 0 to skip
  */
 void video_set_flush_dcache(struct udevice *dev, bool flush);
 #endif /* CONFIG_DM_VIDEO */
 #ifndef CONFIG_DM_VIDEO
 /* Video functions */
 struct stdio_dev;
 int	video_init(void *videobase);
 void	video_putc(struct stdio_dev *dev, const char c);
 void	video_puts(struct stdio_dev *dev, const char *s);
 /**
  * Display a BMP format bitmap on the screen
  *
  * @param bmp_image	Address of BMP image
  * @param x		X position to draw image
  * @param y		Y position to draw image
  */
 int video_display_bitmap(ulong bmp_image, int x, int y);
 /**
  * Get the width of the screen in pixels
  *
  * @return width of screen in pixels
  */
 int video_get_pixel_width(void);
 /**
  * Get the height of the screen in pixels
  *
  * @return height of screen in pixels
  */
 int video_get_pixel_height(void);
 /**
  * Get the number of text lines/rows on the screen
  *
  * @return number of rows
  */
 int video_get_screen_rows(void);
 /**
  * Get the number of text columns on the screen
  *
  * @return number of columns
  */
 int video_get_screen_columns(void);
 /**
  * Set the position of the text cursor
  *
  * @param col	Column to place cursor (0 = left side)
  * @param row	Row to place cursor (0 = top line)
  */
 void video_position_cursor(unsigned col, unsigned row);
 /* Clear the display */
 void video_clear(void);
 #if defined(CONFIG_FORMIKE)
 int kwh043st20_f01_spi_startup(unsigned int bus, unsigned int cs,
 	unsigned int max_hz, unsigned int spi_mode);
 #endif
 #if defined(CONFIG_LG4573)
 int lg4573_spi_startup(unsigned int bus, unsigned int cs,
 	unsigned int max_hz, unsigned int spi_mode);
 #endif
 /*
  * video_get_info_str() - obtain a board string: type, speed, etc.
  *
  * This is called if CONFIG_CONSOLE_EXTRA_INFO is enabled.
  *
  * line_number:	location to place info string beside logo
  * info:	buffer for info string (empty if nothing to display on this
  * line)
  */
 void video_get_info_str(int line_number, char *info);
 #endif /* CONFIG_DM_VIDEO */
 #endif

include/video_console.h

Diff comments View file @ a085aa1

 /*
  * Copyright (c) 2015 Google, Inc
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #ifndef __video_console_h
 #define __video_console_h
 #define VID_FRAC_DIV	256
 #define VID_TO_PIXEL(x)	((x) / VID_FRAC_DIV)
 #define VID_TO_POS(x)	((x) * VID_FRAC_DIV)
 /**
  * struct vidconsole_priv - uclass-private data about a console device
  *
  * Drivers must set up @rows, @cols, @x_charsize, @y_charsize in their probe()
  * method. Drivers may set up @xstart_frac if desired.
  *
  * @sdev:	stdio device, acting as an output sink
  * @xcur_frac:	Current X position, in fractional units (VID_TO_POS(x))
  * @curr_row:	Current Y position in pixels (0=top)
  * @rows:	Number of text rows
  * @cols:	Number of text columns
  * @x_charsize:	Character width in pixels
  * @y_charsize:	Character height in pixels
  * @tab_width_frac:	Tab width in fractional units
  * @xsize_frac:	Width of the display in fractional units
  * @xstart_frac:	Left margin for the text console in fractional units
  * @last_ch:	Last character written to the text console on this line
+ * @escape:	TRUE if currently accumulating an ANSI escape sequence
+ * @escape_len:	Length of accumulated escape sequence so far
+ * @escape_buf:	Buffer to accumulate escape sequence
  */
 struct vidconsole_priv {
 	struct stdio_dev sdev;
 	int xcur_frac;
 	int ycur;
 	int rows;
 	int cols;
 	int x_charsize;
 	int y_charsize;
 	int tab_width_frac;
 	int xsize_frac;
 	int xstart_frac;
 	int last_ch;
+	/*
+	 * ANSI escape sequences are accumulated character by character,
+	 * starting after the ESC char (0x1b) until the entire sequence
+	 * is consumed at which point it is acted upon.
+	 */
+	int escape;
+	int escape_len;
+	char escape_buf[32];
 };
 /**
  * struct vidconsole_ops - Video console operations
  *
  * These operations work on either an absolute console position (measured
  * in pixels) or a text row number (measured in rows, where each row consists
  * of an entire line of text - typically 16 pixels).
  */
 struct vidconsole_ops {
 	/**
 	 * putc_xy() - write a single character to a position
 	 *
 	 * @dev:	Device to write to
 	 * @x_frac:	Fractional pixel X position (0=left-most pixel) which
 	 *		is the X position multipled by VID_FRAC_DIV.
 	 * @y:		Pixel Y position (0=top-most pixel)
 	 * @ch:		Character to write
 	 * @return number of fractional pixels that the cursor should move,
 	 * if all is OK, -EAGAIN if we ran out of space on this line, other -ve
 	 * on error
 	 */
 	int (*putc_xy)(struct udevice *dev, uint x_frac, uint y, char ch);
 	/**
 	 * move_rows() - Move text rows from one place to another
 	 *
 	 * @dev:	Device to adjust
 	 * @rowdst:	Destination text row (0=top)
 	 * @rowsrc:	Source start text row
 	 * @count:	Number of text rows to move
 	 * @return 0 if OK, -ve on error
 	 */
 	int (*move_rows)(struct udevice *dev, uint rowdst, uint rowsrc,
 			  uint count);
 	/**
 	 * set_row() - Set the colour of a text row
 	 *
 	 * Every pixel contained within the text row is adjusted
 	 *
 	 * @dev:	Device to adjust
 	 * @row:	Text row to adjust (0=top)
 	 * @clr:	Raw colour (pixel value) to write to each pixel
 	 * @return 0 if OK, -ve on error
 	 */
 	int (*set_row)(struct udevice *dev, uint row, int clr);
 	/**
 	 * entry_start() - Indicate that text entry is starting afresh
 	 *
 	 * Consoles which use proportional fonts need to track the position of
 	 * each character output so that backspace will return to the correct
 	 * place. This method signals to the console driver that a new entry
 	 * line is being start (e.g. the user pressed return to start a new
 	 * command). The driver can use this signal to empty its list of
 	 * positions.
 	 */
 	int (*entry_start)(struct udevice *dev);
 	/**
 	 * backspace() - Handle erasing the last character
 	 *
 	 * With proportional fonts the vidconsole uclass cannot itself erase
 	 * the previous character. This optional method will be called when
 	 * a backspace is needed. The driver should erase the previous
 	 * character and update the cursor position (xcur_frac, ycur) to the
 	 * start of the previous character.
 	 *
 	 * If not implement, default behaviour will work for fixed-width
 	 * characters.
 	 */
 	int (*backspace)(struct udevice *dev);
 };
 /* Get a pointer to the driver operations for a video console device */
 #define vidconsole_get_ops(dev)  ((struct vidconsole_ops *)(dev)->driver->ops)
 /**
  * vidconsole_putc_xy() - write a single character to a position
  *
  * @dev:	Device to write to
  * @x_frac:	Fractional pixel X position (0=left-most pixel) which
  *		is the X position multipled by VID_FRAC_DIV.
  * @y:		Pixel Y position (0=top-most pixel)
  * @ch:		Character to write
  * @return number of fractional pixels that the cursor should move,
  * if all is OK, -EAGAIN if we ran out of space on this line, other -ve
  * on error
  */
 int vidconsole_putc_xy(struct udevice *dev, uint x, uint y, char ch);
 /**
  * vidconsole_move_rows() - Move text rows from one place to another
  *
  * @dev:	Device to adjust
  * @rowdst:	Destination text row (0=top)
  * @rowsrc:	Source start text row
  * @count:	Number of text rows to move
  * @return 0 if OK, -ve on error
  */
 int vidconsole_move_rows(struct udevice *dev, uint rowdst, uint rowsrc,
 			 uint count);
 /**
  * vidconsole_set_row() - Set the colour of a text row
  *
  * Every pixel contained within the text row is adjusted
  *
  * @dev:	Device to adjust
  * @row:	Text row to adjust (0=top)
  * @clr:	Raw colour (pixel value) to write to each pixel
  * @return 0 if OK, -ve on error
  */
 int vidconsole_set_row(struct udevice *dev, uint row, int clr);
 /**
  * vidconsole_put_char() - Output a character to the current console position
  *
  * Outputs a character to the console and advances the cursor. This function
  * handles wrapping to new lines and scrolling the console. Special
  * characters are handled also: \n, \r, \b and \t.
  *
  * The device always starts with the cursor at position 0,0 (top left). It
  * can be adjusted manually using vidconsole_position_cursor().
  *
  * @dev:	Device to adjust
  * @ch:		Character to write
  * @return 0 if OK, -ve on error
  */
 int vidconsole_put_char(struct udevice *dev, char ch);
 /**
  * vidconsole_position_cursor() - Move the text cursor
  *
  * @dev:	Device to adjust
  * @col:	New cursor text column
  * @row:	New cursor text row
  * @return 0 if OK, -ve on error
  */
 void vidconsole_position_cursor(struct udevice *dev, unsigned col,
 				unsigned row);
 #endif