kernel-release 5.10.10-1 (znver1;x86_64) 2021-13503
9999

Submitter bero [@T] lindev.ch
Platform rolling
Repository main
URL https://abf.openmandriva.org/build_lists/978771
Packages
bpftool-5.10.10-1.znver1.binary
cpupower-5.10.10-1.znver1.binary
cpupower-devel-5.10.10-1.znver1.binary
cross-aarch64-openmandriva-linux-android-kernel-release-headers-5.10.10-1.znver1.binary
cross-aarch64-openmandriva-linux-gnu-kernel-release-headers-5.10.10-1.znver1.binary
cross-aarch64-openmandriva-linux-musl-kernel-release-headers-5.10.10-1.znver1.binary
cross-aarch64-openmandriva-linux-uclibc-kernel-release-headers-5.10.10-1.znver1.binary
cross-armv7hnl-openmandriva-linux-gnueabihf-kernel-release-headers-5.10.10-1.znver1.binary
cross-armv7hnl-openmandriva-linux-musleabihf-kernel-release-headers-5.10.10-1.znver1.binary
cross-armv7hnl-openmandriva-linux-uclibceabihf-kernel-release-headers-5.10.10-1.znver1.binary
cross-armv7l-openmandriva-linux-androideabi-kernel-release-headers-5.10.10-1.znver1.binary
cross-armv8l-openmandriva-linux-androideabi-kernel-release-headers-5.10.10-1.znver1.binary
cross-i686-openmandriva-linux-gnu-kernel-release-headers-5.10.10-1.znver1.binary
cross-i686-openmandriva-linux-musl-kernel-release-headers-5.10.10-1.znver1.binary
cross-i686-openmandriva-linux-uclibc-kernel-release-headers-5.10.10-1.znver1.binary
cross-ppc64le-openmandriva-linux-gnu-kernel-release-headers-5.10.10-1.znver1.binary
cross-ppc64-openmandriva-linux-gnu-kernel-release-headers-5.10.10-1.znver1.binary
cross-riscv32-openmandriva-linux-gnu-kernel-release-headers-5.10.10-1.znver1.binary
cross-riscv32-openmandriva-linux-musl-kernel-release-headers-5.10.10-1.znver1.binary
cross-riscv32-openmandriva-linux-uclibc-kernel-release-headers-5.10.10-1.znver1.binary
cross-riscv64-openmandriva-linux-gnu-kernel-release-headers-5.10.10-1.znver1.binary
cross-riscv64-openmandriva-linux-musl-kernel-release-headers-5.10.10-1.znver1.binary
cross-riscv64-openmandriva-linux-uclibc-kernel-release-headers-5.10.10-1.znver1.binary
cross-x86_64-openmandriva-linux-android-kernel-release-headers-5.10.10-1.znver1.binary
cross-x86_64-openmandriva-linux-gnux32-kernel-release-headers-5.10.10-1.znver1.binary
cross-x86_64-openmandriva-linux-musl-kernel-release-headers-5.10.10-1.znver1.binary
cross-x86_64-openmandriva-linux-muslx32-kernel-release-headers-5.10.10-1.znver1.binary
cross-x86_64-openmandriva-linux-uclibc-kernel-release-headers-5.10.10-1.znver1.binary
cross-x86_64-openmandriva-linux-uclibcx32-kernel-release-headers-5.10.10-1.znver1.binary
kernel-release-5.10.10-1.znver1.source
kernel-release-desktop-5.10.10-1.znver1.binary
kernel-release-desktop-clang-5.10.10-1.znver1.binary
kernel-release-desktop-clang-devel-5.10.10-1.znver1.binary
kernel-release-desktop-devel-5.10.10-1.znver1.binary
kernel-release-headers-1:5.10.10-1.znver1.binary
kernel-release-server-5.10.10-1.znver1.binary
kernel-release-server-clang-5.10.10-1.znver1.binary
kernel-release-server-clang-devel-5.10.10-1.znver1.binary
kernel-release-server-devel-5.10.10-1.znver1.binary
kernel-release-source-5.10.10-1.znver1.binary
lib64bpf0-5.10.10-1.znver1.binary
lib64bpf-devel-5.10.10-1.znver1.binary
turbostat-5.10.10-1.znver1.binary
x86_energy_perf_policy-5.10.10-1.znver1.binary
bpftool-5.10.10-1.x86_64.binary
cpupower-5.10.10-1.x86_64.binary
cpupower-devel-5.10.10-1.x86_64.binary
cross-aarch64-openmandriva-linux-android-kernel-release-headers-5.10.10-1.x86_64.binary
cross-aarch64-openmandriva-linux-gnu-kernel-release-headers-5.10.10-1.x86_64.binary
cross-aarch64-openmandriva-linux-musl-kernel-release-headers-5.10.10-1.x86_64.binary
cross-aarch64-openmandriva-linux-uclibc-kernel-release-headers-5.10.10-1.x86_64.binary
cross-armv7hnl-openmandriva-linux-gnueabihf-kernel-release-headers-5.10.10-1.x86_64.binary
cross-armv7hnl-openmandriva-linux-musleabihf-kernel-release-headers-5.10.10-1.x86_64.binary
cross-armv7hnl-openmandriva-linux-uclibceabihf-kernel-release-headers-5.10.10-1.x86_64.binary
cross-armv7l-openmandriva-linux-androideabi-kernel-release-headers-5.10.10-1.x86_64.binary
cross-armv8l-openmandriva-linux-androideabi-kernel-release-headers-5.10.10-1.x86_64.binary
cross-i686-openmandriva-linux-gnu-kernel-release-headers-5.10.10-1.x86_64.binary
cross-i686-openmandriva-linux-musl-kernel-release-headers-5.10.10-1.x86_64.binary
cross-i686-openmandriva-linux-uclibc-kernel-release-headers-5.10.10-1.x86_64.binary
cross-ppc64le-openmandriva-linux-gnu-kernel-release-headers-5.10.10-1.x86_64.binary
cross-ppc64-openmandriva-linux-gnu-kernel-release-headers-5.10.10-1.x86_64.binary
cross-riscv32-openmandriva-linux-gnu-kernel-release-headers-5.10.10-1.x86_64.binary
cross-riscv32-openmandriva-linux-musl-kernel-release-headers-5.10.10-1.x86_64.binary
cross-riscv32-openmandriva-linux-uclibc-kernel-release-headers-5.10.10-1.x86_64.binary
cross-riscv64-openmandriva-linux-gnu-kernel-release-headers-5.10.10-1.x86_64.binary
cross-riscv64-openmandriva-linux-musl-kernel-release-headers-5.10.10-1.x86_64.binary
cross-riscv64-openmandriva-linux-uclibc-kernel-release-headers-5.10.10-1.x86_64.binary
cross-x86_64-openmandriva-linux-android-kernel-release-headers-5.10.10-1.x86_64.binary
cross-x86_64-openmandriva-linux-gnux32-kernel-release-headers-5.10.10-1.x86_64.binary
cross-x86_64-openmandriva-linux-musl-kernel-release-headers-5.10.10-1.x86_64.binary
cross-x86_64-openmandriva-linux-muslx32-kernel-release-headers-5.10.10-1.x86_64.binary
cross-x86_64-openmandriva-linux-uclibc-kernel-release-headers-5.10.10-1.x86_64.binary
cross-x86_64-openmandriva-linux-uclibcx32-kernel-release-headers-5.10.10-1.x86_64.binary
kernel-release-5.10.10-1.x86_64.source
kernel-release-desktop-5.10.10-1.x86_64.binary
kernel-release-desktop-clang-5.10.10-1.x86_64.binary
kernel-release-desktop-clang-devel-5.10.10-1.x86_64.binary
kernel-release-desktop-devel-5.10.10-1.x86_64.binary
kernel-release-headers-1:5.10.10-1.x86_64.binary
kernel-release-server-5.10.10-1.x86_64.binary
kernel-release-server-clang-5.10.10-1.x86_64.binary
kernel-release-server-clang-devel-5.10.10-1.x86_64.binary
kernel-release-server-devel-5.10.10-1.x86_64.binary
kernel-release-source-5.10.10-1.x86_64.binary
lib64bpf0-5.10.10-1.x86_64.binary
lib64bpf-devel-5.10.10-1.x86_64.binary
turbostat-5.10.10-1.x86_64.binary
x86_energy_perf_policy-5.10.10-1.x86_64.binary
Build Date 2021-01-24 01:32:49 +0000 UTC
Last Updated 2021-01-25 04:25:43.56073462 +0000 UTC
$ git diff --patch-with-stat --summary c8b822d29ce1a78dec8070252886d8536383f1c7..18969b7685c0ab5a9401572008504b1ab16f1504

 .abf.yml                                           |   5 +-
 ...ow-unusued-softback_lines-cursor-argument.patch | 150 +++++
 ...evert-fbcon-remove-no-op-fbcon_set_origin.patch |  31 +
 ...-revert-fbcon-remove-soft-scrollback-code.patch | 498 ++++++++++++++
 0501-bootsplash.patch                              | 714 +++++++++++++++++++++
 0502-bootsplash.patch                              | 657 +++++++++++++++++++
 0503-bootsplash.patch                              |  66 ++
 0504-bootsplash.patch                              | 215 +++++++
 0505-bootsplash.patch                              | 327 ++++++++++
 0506-bootsplash.patch                              |  82 +++
 0507-bootsplash.patch                              |  42 ++
 0508-bootsplash.patch                              |  19 +
 0509-bootsplash.patch                              |  21 +
 0510-bootsplash.patch                              | 308 +++++++++
 0511-bootsplash.patch                              | 129 ++++
 0512-bootsplash.patch                              | 499 ++++++++++++++
 0513-bootsplash.gitpatch                           | 162 +++++
 aarch64-desktop-omv-defconfig                      |   3 +-
 aarch64-server-omv-defconfig                       |   3 +-
 armv7hnl-desktop-omv-defconfig                     |   4 +-
 armv7hnl-server-omv-defconfig                      |   4 +-
 i686-desktop-gcc-omv-defconfig                     |   3 +-
 i686-server-gcc-omv-defconfig                      |   3 +-
 kernel-release.spec                                |  37 +-
 linux-5.10.tar.sign                                |  19 -
 linux-5.8.tar.sign                                 |  19 -
 x86_64-desktop-gcc-omv-defconfig                   |   3 +-
 x86_64-server-gcc-omv-defconfig                    |   3 +-
 x86_64-znver-desktop-gcc-omv-defconfig             |   3 +-
 x86_64-znver-server-gcc-omv-defconfig              |   3 +-
 30 files changed, 3978 insertions(+), 54 deletions(-)
 create mode 100644 0401-revert-fbcon-remove-now-unusued-softback_lines-cursor-argument.patch
 create mode 100644 0402-revert-fbcon-remove-no-op-fbcon_set_origin.patch
 create mode 100644 0403-revert-fbcon-remove-soft-scrollback-code.patch
 create mode 100644 0501-bootsplash.patch
 create mode 100644 0502-bootsplash.patch
 create mode 100644 0503-bootsplash.patch
 create mode 100644 0504-bootsplash.patch
 create mode 100644 0505-bootsplash.patch
 create mode 100644 0506-bootsplash.patch
 create mode 100644 0507-bootsplash.patch
 create mode 100644 0508-bootsplash.patch
 create mode 100644 0509-bootsplash.patch
 create mode 100644 0510-bootsplash.patch
 create mode 100644 0511-bootsplash.patch
 create mode 100644 0512-bootsplash.patch
 create mode 100644 0513-bootsplash.gitpatch
 delete mode 100644 linux-5.10.tar.sign
 delete mode 100644 linux-5.8.tar.sign

diff --git a/.abf.yml b/.abf.yml
index 4db0049..4c5249f 100644
--- a/.abf.yml
+++ b/.abf.yml
@@ -1,5 +1,6 @@
 sources:
   extra-wifi-drivers-20200301.tar.zst: 3390c738c7d91250714ce0f88d26371e93bc40b8
-  saa716x-driver.tar.xz: f9b6ef1cd6f1f71f53d9a8aadfba2cf6b5c3d7b6
+  linux-5.10.tar.sign: 42168c413497eb431304c83ebdaefe8ac2438ed5
   linux-5.10.tar.xz: be0b909f1fbb760cc2d5cf146e1da3b2af0cf899
-  patch-5.10.6.xz: a0d664cb8188c684ec3a63ea50df070965288336
+  saa716x-driver.tar.xz: f9b6ef1cd6f1f71f53d9a8aadfba2cf6b5c3d7b6
+  patch-5.10.10.xz: a107b535159e5060f048e35339b1b66dba306cd1
diff --git a/0401-revert-fbcon-remove-now-unusued-softback_lines-cursor-argument.patch b/0401-revert-fbcon-remove-now-unusued-softback_lines-cursor-argument.patch
new file mode 100644
index 0000000..c126888
--- /dev/null
+++ b/0401-revert-fbcon-remove-now-unusued-softback_lines-cursor-argument.patch
@@ -0,0 +1,150 @@
+--- b/drivers/video/fbdev/core/bitblit.c
++++ a/drivers/video/fbdev/core/bitblit.c
+@@ -234,7 +234,7 @@
+ }
+ 
+ static void bit_cursor(struct vc_data *vc, struct fb_info *info, int mode,
++		       int softback_lines, int fg, int bg)
+-		       int fg, int bg)
+ {
+ 	struct fb_cursor cursor;
+ 	struct fbcon_ops *ops = info->fbcon_par;
+@@ -247,6 +247,15 @@
+ 
+ 	cursor.set = 0;
+ 
++	if (softback_lines) {
++		if (y + softback_lines >= vc->vc_rows) {
++			mode = CM_ERASE;
++			ops->cursor_flash = 0;
++			return;
++		} else
++			y += softback_lines;
++	}
++
+  	c = scr_readw((u16 *) vc->vc_pos);
+ 	attribute = get_attribute(info, c);
+ 	src = vc->vc_font.data + ((c & charmask) * (w * vc->vc_font.height));
+--- b/drivers/video/fbdev/core/fbcon.c
++++ a/drivers/video/fbdev/core/fbcon.c
+@@ -394,7 +394,7 @@
+ 	c = scr_readw((u16 *) vc->vc_pos);
+ 	mode = (!ops->cursor_flash || ops->cursor_state.enable) ?
+ 		CM_ERASE : CM_DRAW;
++	ops->cursor(vc, info, mode, 0, get_color(vc, info, c, 1),
+-	ops->cursor(vc, info, mode, get_color(vc, info, c, 1),
+ 		    get_color(vc, info, c, 0));
+ 	console_unlock();
+ }
+@@ -1345,7 +1345,7 @@
+ 
+ 	ops->cursor_flash = (mode == CM_ERASE) ? 0 : 1;
+ 
++	ops->cursor(vc, info, mode, 0, get_color(vc, info, c, 1),
+-	ops->cursor(vc, info, mode, get_color(vc, info, c, 1),
+ 		    get_color(vc, info, c, 0));
+ }
+ 
+--- b/drivers/video/fbdev/core/fbcon.h
++++ a/drivers/video/fbdev/core/fbcon.h
+@@ -62,7 +62,7 @@
+ 	void (*clear_margins)(struct vc_data *vc, struct fb_info *info,
+ 			      int color, int bottom_only);
+ 	void (*cursor)(struct vc_data *vc, struct fb_info *info, int mode,
++		       int softback_lines, int fg, int bg);
+-		       int fg, int bg);
+ 	int  (*update_start)(struct fb_info *info);
+ 	int  (*rotate_font)(struct fb_info *info, struct vc_data *vc);
+ 	struct fb_var_screeninfo var;  /* copy of the current fb_var_screeninfo */
+--- b/drivers/video/fbdev/core/fbcon_ccw.c
++++ a/drivers/video/fbdev/core/fbcon_ccw.c
+@@ -219,7 +219,7 @@
+ }
+ 
+ static void ccw_cursor(struct vc_data *vc, struct fb_info *info, int mode,
++		       int softback_lines, int fg, int bg)
+-		       int fg, int bg)
+ {
+ 	struct fb_cursor cursor;
+ 	struct fbcon_ops *ops = info->fbcon_par;
+@@ -236,6 +236,15 @@
+ 
+ 	cursor.set = 0;
+ 
++	if (softback_lines) {
++		if (y + softback_lines >= vc->vc_rows) {
++			mode = CM_ERASE;
++			ops->cursor_flash = 0;
++			return;
++		} else
++			y += softback_lines;
++	}
++
+  	c = scr_readw((u16 *) vc->vc_pos);
+ 	attribute = get_attribute(info, c);
+ 	src = ops->fontbuffer + ((c & charmask) * (w * vc->vc_font.width));
+--- b/drivers/video/fbdev/core/fbcon_cw.c
++++ a/drivers/video/fbdev/core/fbcon_cw.c
+@@ -202,7 +202,7 @@
+ }
+ 
+ static void cw_cursor(struct vc_data *vc, struct fb_info *info, int mode,
++		      int softback_lines, int fg, int bg)
+-		      int fg, int bg)
+ {
+ 	struct fb_cursor cursor;
+ 	struct fbcon_ops *ops = info->fbcon_par;
+@@ -219,6 +219,15 @@
+ 
+ 	cursor.set = 0;
+ 
++	if (softback_lines) {
++		if (y + softback_lines >= vc->vc_rows) {
++			mode = CM_ERASE;
++			ops->cursor_flash = 0;
++			return;
++		} else
++			y += softback_lines;
++	}
++
+  	c = scr_readw((u16 *) vc->vc_pos);
+ 	attribute = get_attribute(info, c);
+ 	src = ops->fontbuffer + ((c & charmask) * (w * vc->vc_font.width));
+--- b/drivers/video/fbdev/core/fbcon_ud.c
++++ a/drivers/video/fbdev/core/fbcon_ud.c
+@@ -249,7 +249,7 @@
+ }
+ 
+ static void ud_cursor(struct vc_data *vc, struct fb_info *info, int mode,
++		      int softback_lines, int fg, int bg)
+-		      int fg, int bg)
+ {
+ 	struct fb_cursor cursor;
+ 	struct fbcon_ops *ops = info->fbcon_par;
+@@ -267,6 +267,15 @@
+ 
+ 	cursor.set = 0;
+ 
++	if (softback_lines) {
++		if (y + softback_lines >= vc->vc_rows) {
++			mode = CM_ERASE;
++			ops->cursor_flash = 0;
++			return;
++		} else
++			y += softback_lines;
++	}
++
+  	c = scr_readw((u16 *) vc->vc_pos);
+ 	attribute = get_attribute(info, c);
+ 	src = ops->fontbuffer + ((c & charmask) * (w * vc->vc_font.height));
+--- b/drivers/video/fbdev/core/tileblit.c
++++ a/drivers/video/fbdev/core/tileblit.c
+@@ -80,7 +80,7 @@
+ }
+ 
+ static void tile_cursor(struct vc_data *vc, struct fb_info *info, int mode,
++			int softback_lines, int fg, int bg)
+-			int fg, int bg)
+ {
+ 	struct fb_tilecursor cursor;
+ 	int use_sw = vc->vc_cursor_type & CUR_SW;
diff --git a/0402-revert-fbcon-remove-no-op-fbcon_set_origin.patch b/0402-revert-fbcon-remove-no-op-fbcon_set_origin.patch
new file mode 100644
index 0000000..6491c54
--- /dev/null
+++ b/0402-revert-fbcon-remove-no-op-fbcon_set_origin.patch
@@ -0,0 +1,31 @@
+--- b/drivers/video/fbdev/core/fbcon.c
++++ a/drivers/video/fbdev/core/fbcon.c
+@@ -163,6 +163,8 @@
+ 
+ #define advance_row(p, delta) (unsigned short *)((unsigned long)(p) + (delta) * vc->vc_size_row)
+ 
++static int fbcon_set_origin(struct vc_data *);
++
+ static int fbcon_cursor_noblink;
+ 
+ #define divides(a, b)	((!(a) || (b)%(a)) ? 0 : 1)
+@@ -2633,6 +2635,11 @@
+ 	}
+ }
+ 
++static int fbcon_set_origin(struct vc_data *vc)
++{
++	return 0;
++}
++
+ void fbcon_suspended(struct fb_info *info)
+ {
+ 	struct vc_data *vc = NULL;
+@@ -3103,6 +3110,7 @@
+ 	.con_font_default	= fbcon_set_def_font,
+ 	.con_font_copy 		= fbcon_copy_font,
+ 	.con_set_palette 	= fbcon_set_palette,
++	.con_set_origin 	= fbcon_set_origin,
+ 	.con_invert_region 	= fbcon_invert_region,
+ 	.con_screen_pos 	= fbcon_screen_pos,
+ 	.con_getxy 		= fbcon_getxy,
diff --git a/0403-revert-fbcon-remove-soft-scrollback-code.patch b/0403-revert-fbcon-remove-soft-scrollback-code.patch
new file mode 100644
index 0000000..716ffe0
--- /dev/null
+++ b/0403-revert-fbcon-remove-soft-scrollback-code.patch
@@ -0,0 +1,498 @@
+diff -up linux-5.10/drivers/video/fbdev/core/fbcon.c.58~ linux-5.10/drivers/video/fbdev/core/fbcon.c
+--- linux-5.10/drivers/video/fbdev/core/fbcon.c.58~	2021-01-19 23:02:34.611103889 +0100
++++ linux-5.10/drivers/video/fbdev/core/fbcon.c	2021-01-19 23:05:28.560860927 +0100
+@@ -122,6 +122,12 @@ static int logo_lines;
+ /* logo_shown is an index to vc_cons when >= 0; otherwise follows FBCON_LOGO
+    enums.  */
+ static int logo_shown = FBCON_LOGO_CANSHOW;
++/* Software scrollback */
++static int fbcon_softback_size = 32768;
++static unsigned long softback_buf, softback_curr;
++static unsigned long softback_in;
++static unsigned long softback_top, softback_end;
++static int softback_lines;
+ /* console mappings */
+ static int first_fb_vc;
+ static int last_fb_vc = MAX_NR_CONSOLES - 1;
+@@ -161,6 +167,8 @@ static int margin_color;
+ 
+ static const struct consw fb_con;
+ 
++#define CM_SOFTBACK	(8)
++
+ #define advance_row(p, delta) (unsigned short *)((unsigned long)(p) + (delta) * vc->vc_size_row)
+ 
+ static int fbcon_set_origin(struct vc_data *);
+@@ -365,6 +373,18 @@ static int get_color(struct vc_data *vc,
+ 	return color;
+ }
+ 
++static void fbcon_update_softback(struct vc_data *vc)
++{
++	int l = fbcon_softback_size / vc->vc_size_row;
++
++	if (l > 5)
++		softback_end = softback_buf + l * vc->vc_size_row;
++	else
++		/* Smaller scrollback makes no sense, and 0 would screw
++		   the operation totally */
++		softback_top = 0;
++}
++
+ static void fb_flashcursor(struct work_struct *work)
+ {
+ 	struct fb_info *info = container_of(work, struct fb_info, queue);
+@@ -394,7 +414,7 @@ static void fb_flashcursor(struct work_s
+ 	c = scr_readw((u16 *) vc->vc_pos);
+ 	mode = (!ops->cursor_flash || ops->cursor_state.enable) ?
+ 		CM_ERASE : CM_DRAW;
+-	ops->cursor(vc, info, mode, 0, get_color(vc, info, c, 1),
++	ops->cursor(vc, info, mode, softback_lines, get_color(vc, info, c, 1),
+ 		    get_color(vc, info, c, 0));
+ 	console_unlock();
+ }
+@@ -451,7 +471,13 @@ static int __init fb_console_setup(char
+ 		}
+ 		
+ 		if (!strncmp(options, "scrollback:", 11)) {
+-			pr_warn("Ignoring scrollback size option\n");
++			options += 11;
++			if (*options) {
++				fbcon_softback_size = simple_strtoul(options, &options, 0);
++				if (*options == 'k' || *options == 'K') {
++					fbcon_softback_size *= 1024;
++				}
++			}
+ 			continue;
+ 		}
+ 		
+@@ -996,6 +1022,31 @@ static const char *fbcon_startup(void)
+ 
+ 	set_blitting_type(vc, info);
+ 
++	if (info->fix.type != FB_TYPE_TEXT) {
++		if (fbcon_softback_size) {
++			if (!softback_buf) {
++				softback_buf =
++				    (unsigned long)
++				    kvmalloc(fbcon_softback_size,
++					    GFP_KERNEL);
++				if (!softback_buf) {
++					fbcon_softback_size = 0;
++					softback_top = 0;
++				}
++			}
++		} else {
++			if (softback_buf) {
++				kvfree((void *) softback_buf);
++				softback_buf = 0;
++				softback_top = 0;
++			}
++		}
++		if (softback_buf)
++			softback_in = softback_top = softback_curr =
++			    softback_buf;
++		softback_lines = 0;
++	}
++
+ 	/* Setup default font */
+ 	if (!p->fontdata && !vc->vc_font.data) {
+ 		if (!fontname[0] || !(font = find_font(fontname)))
+@@ -1170,6 +1221,9 @@ static void fbcon_init(struct vc_data *v
+ 	if (logo)
+ 		fbcon_prepare_logo(vc, info, cols, rows, new_cols, new_rows);
+ 
++	if (vc == svc && softback_buf)
++		fbcon_update_softback(vc);
++
+ 	if (ops->rotate_font && ops->rotate_font(info, vc)) {
+ 		ops->rotate = FB_ROTATE_UR;
+ 		set_blitting_type(vc, info);
+@@ -1332,6 +1386,7 @@ static void fbcon_cursor(struct vc_data
+ {
+ 	struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
+ 	struct fbcon_ops *ops = info->fbcon_par;
++	int y;
+  	int c = scr_readw((u16 *) vc->vc_pos);
+ 
+ 	ops->cur_blink_jiffies = msecs_to_jiffies(vc->vc_cur_blink_ms);
+@@ -1345,8 +1400,16 @@ static void fbcon_cursor(struct vc_data
+ 		fbcon_add_cursor_timer(info);
+ 
+ 	ops->cursor_flash = (mode == CM_ERASE) ? 0 : 1;
++	if (mode & CM_SOFTBACK) {
++		mode &= ~CM_SOFTBACK;
++		y = softback_lines;
++	} else {
++		if (softback_lines)
++			fbcon_set_origin(vc);
++		y = 0;
++	}
+ 
+-	ops->cursor(vc, info, mode, 0, get_color(vc, info, c, 1),
++	ops->cursor(vc, info, mode, y, get_color(vc, info, c, 1),
+ 		    get_color(vc, info, c, 0));
+ }
+ 
+@@ -1417,6 +1480,8 @@ static void fbcon_set_disp(struct fb_inf
+ 
+ 	if (con_is_visible(vc)) {
+ 		update_screen(vc);
++		if (softback_buf)
++			fbcon_update_softback(vc);
+ 	}
+ }
+ 
+@@ -1554,6 +1619,99 @@ static __inline__ void ypan_down_redraw(
+ 	scrollback_current = 0;
+ }
+ 
++static void fbcon_redraw_softback(struct vc_data *vc, struct fbcon_display *p,
++				  long delta)
++{
++	int count = vc->vc_rows;
++	unsigned short *d, *s;
++	unsigned long n;
++	int line = 0;
++
++	d = (u16 *) softback_curr;
++	if (d == (u16 *) softback_in)
++		d = (u16 *) vc->vc_origin;
++	n = softback_curr + delta * vc->vc_size_row;
++	softback_lines -= delta;
++	if (delta < 0) {
++		if (softback_curr < softback_top && n < softback_buf) {
++			n += softback_end - softback_buf;
++			if (n < softback_top) {
++				softback_lines -=
++				    (softback_top - n) / vc->vc_size_row;
++				n = softback_top;
++			}
++		} else if (softback_curr >= softback_top
++			   && n < softback_top) {
++			softback_lines -=
++			    (softback_top - n) / vc->vc_size_row;
++			n = softback_top;
++		}
++	} else {
++		if (softback_curr > softback_in && n >= softback_end) {
++			n += softback_buf - softback_end;
++			if (n > softback_in) {
++				n = softback_in;
++				softback_lines = 0;
++			}
++		} else if (softback_curr <= softback_in && n > softback_in) {
++			n = softback_in;
++			softback_lines = 0;
++		}
++	}
++	if (n == softback_curr)
++		return;
++	softback_curr = n;
++	s = (u16 *) softback_curr;
++	if (s == (u16 *) softback_in)
++		s = (u16 *) vc->vc_origin;
++	while (count--) {
++		unsigned short *start;
++		unsigned short *le;
++		unsigned short c;
++		int x = 0;
++		unsigned short attr = 1;
++
++		start = s;
++		le = advance_row(s, 1);
++		do {
++			c = scr_readw(s);
++			if (attr != (c & 0xff00)) {
++				attr = c & 0xff00;
++				if (s > start) {
++					fbcon_putcs(vc, start, s - start,
++						    line, x);
++					x += s - start;
++					start = s;
++				}
++			}
++			if (c == scr_readw(d)) {
++				if (s > start) {
++					fbcon_putcs(vc, start, s - start,
++						    line, x);
++					x += s - start + 1;
++					start = s + 1;
++				} else {
++					x++;
++					start++;
++				}
++			}
++			s++;
++			d++;
++		} while (s < le);
++		if (s > start)
++			fbcon_putcs(vc, start, s - start, line, x);
++		line++;
++		if (d == (u16 *) softback_end)
++			d = (u16 *) softback_buf;
++		if (d == (u16 *) softback_in)
++			d = (u16 *) vc->vc_origin;
++		if (s == (u16 *) softback_end)
++			s = (u16 *) softback_buf;
++		if (s == (u16 *) softback_in)
++			s = (u16 *) vc->vc_origin;
++	}
++}
++
+ static void fbcon_redraw_move(struct vc_data *vc, struct fbcon_display *p,
+ 			      int line, int count, int dy)
+ {
+@@ -1693,6 +1851,31 @@ static void fbcon_redraw(struct vc_data
+ 	}
+ }
+ 
++static inline void fbcon_softback_note(struct vc_data *vc, int t,
++				       int count)
++{
++	unsigned short *p;
++
++	if (vc->vc_num != fg_console)
++		return;
++	p = (unsigned short *) (vc->vc_origin + t * vc->vc_size_row);
++
++	while (count) {
++		scr_memcpyw((u16 *) softback_in, p, vc->vc_size_row);
++		count--;
++		p = advance_row(p, 1);
++		softback_in += vc->vc_size_row;
++		if (softback_in == softback_end)
++			softback_in = softback_buf;
++		if (softback_in == softback_top) {
++			softback_top += vc->vc_size_row;
++			if (softback_top == softback_end)
++				softback_top = softback_buf;
++		}
++	}
++	softback_curr = softback_in;
++}
++
+ static bool fbcon_scroll(struct vc_data *vc, unsigned int t, unsigned int b,
+ 		enum con_scroll dir, unsigned int count)
+ {
+@@ -1715,6 +1898,8 @@ static bool fbcon_scroll(struct vc_data
+ 	case SM_UP:
+ 		if (count > vc->vc_rows)	/* Maximum realistic size */
+ 			count = vc->vc_rows;
++		if (softback_top)
++			fbcon_softback_note(vc, t, count);
+ 		if (logo_shown >= 0)
+ 			goto redraw_up;
+ 		switch (p->scrollmode) {
+@@ -2053,6 +2238,14 @@ static int fbcon_switch(struct vc_data *
+ 	info = registered_fb[con2fb_map[vc->vc_num]];
+ 	ops = info->fbcon_par;
+ 
++	if (softback_top) {
++		if (softback_lines)
++			fbcon_set_origin(vc);
++		softback_top = softback_curr = softback_in = softback_buf;
++		softback_lines = 0;
++		fbcon_update_softback(vc);
++	}
++
+ 	if (logo_shown >= 0) {
+ 		struct vc_data *conp2 = vc_cons[logo_shown].d;
+ 
+@@ -2388,6 +2581,9 @@ static int fbcon_do_set_font(struct vc_d
+ 	int cnt;
+ 	char *old_data = NULL;
+ 
++	if (con_is_visible(vc) && softback_lines)
++		fbcon_set_origin(vc);
++
+ 	resize = (w != vc->vc_font.width) || (h != vc->vc_font.height);
+ 	if (p->userfont)
+ 		old_data = vc->vc_font.data;
+@@ -2413,6 +2609,8 @@ static int fbcon_do_set_font(struct vc_d
+ 		cols /= w;
+ 		rows /= h;
+ 		vc_resize(vc, cols, rows);
++		if (con_is_visible(vc) && softback_buf)
++			fbcon_update_softback(vc);
+ 	} else if (con_is_visible(vc)
+ 		   && vc->vc_mode == KD_TEXT) {
+ 		fbcon_clear_margins(vc, 0);
+@@ -2571,7 +2769,19 @@ static void fbcon_set_palette(struct vc_
+ 
+ static u16 *fbcon_screen_pos(const struct vc_data *vc, int offset)
+ {
+-	return (u16 *) (vc->vc_origin + offset);
++	unsigned long p;
++	int line;
++	
++	if (vc->vc_num != fg_console || !softback_lines)
++		return (u16 *) (vc->vc_origin + offset);
++	line = offset / vc->vc_size_row;
++	if (line >= softback_lines)
++		return (u16 *) (vc->vc_origin + offset -
++				softback_lines * vc->vc_size_row);
++	p = softback_curr + offset;
++	if (p >= softback_end)
++		p += softback_buf - softback_end;
++	return (u16 *) p;
+ }
+ 
+ static unsigned long fbcon_getxy(struct vc_data *vc, unsigned long pos,
+@@ -2585,7 +2795,22 @@ static unsigned long fbcon_getxy(struct
+ 
+ 		x = offset % vc->vc_cols;
+ 		y = offset / vc->vc_cols;
++		if (vc->vc_num == fg_console)
++			y += softback_lines;
+ 		ret = pos + (vc->vc_cols - x) * 2;
++	} else if (vc->vc_num == fg_console && softback_lines) {
++		unsigned long offset = pos - softback_curr;
++
++		if (pos < softback_curr)
++			offset += softback_end - softback_buf;
++		offset /= 2;
++		x = offset % vc->vc_cols;
++		y = offset / vc->vc_cols;
++		ret = pos + (vc->vc_cols - x) * 2;
++		if (ret == softback_end)
++			ret = softback_buf;
++		if (ret == softback_in)
++			ret = vc->vc_origin;
+ 	} else {
+ 		/* Should not happen */
+ 		x = y = 0;
+@@ -2613,11 +2838,106 @@ static void fbcon_invert_region(struct v
+ 			a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) |
+ 			    (((a) & 0x0700) << 4);
+ 		scr_writew(a, p++);
++		if (p == (u16 *) softback_end)
++			p = (u16 *) softback_buf;
++		if (p == (u16 *) softback_in)
++			p = (u16 *) vc->vc_origin;
++	}
++}
++
++static void fbcon_scrolldelta(struct vc_data *vc, int lines)
++{
++	struct fb_info *info = registered_fb[con2fb_map[fg_console]];
++	struct fbcon_ops *ops = info->fbcon_par;
++	struct fbcon_display *disp = &fb_display[fg_console];
++	int offset, limit, scrollback_old;
++
++	if (softback_top) {
++		if (vc->vc_num != fg_console)
++			return;
++		if (vc->vc_mode != KD_TEXT || !lines)
++			return;
++		if (logo_shown >= 0) {
++			struct vc_data *conp2 = vc_cons[logo_shown].d;
++
++			if (conp2->vc_top == logo_lines
++			    && conp2->vc_bottom == conp2->vc_rows)
++				conp2->vc_top = 0;
++			if (logo_shown == vc->vc_num) {
++				unsigned long p, q;
++				int i;
++
++				p = softback_in;
++				q = vc->vc_origin +
++				    logo_lines * vc->vc_size_row;
++				for (i = 0; i < logo_lines; i++) {
++					if (p == softback_top)
++						break;
++					if (p == softback_buf)
++						p = softback_end;
++					p -= vc->vc_size_row;
++					q -= vc->vc_size_row;
++					scr_memcpyw((u16 *) q, (u16 *) p,
++						    vc->vc_size_row);
++				}
++				softback_in = softback_curr = p;
++				update_region(vc, vc->vc_origin,
++					      logo_lines * vc->vc_cols);
++			}
++			logo_shown = FBCON_LOGO_CANSHOW;
++		}
++		fbcon_cursor(vc, CM_ERASE | CM_SOFTBACK);
++		fbcon_redraw_softback(vc, disp, lines);
++		fbcon_cursor(vc, CM_DRAW | CM_SOFTBACK);
++		return;
+ 	}
++
++	if (!scrollback_phys_max)
++		return;
++
++	scrollback_old = scrollback_current;
++	scrollback_current -= lines;
++	if (scrollback_current < 0)
++		scrollback_current = 0;
++	else if (scrollback_current > scrollback_max)
++		scrollback_current = scrollback_max;
++	if (scrollback_current == scrollback_old)
++		return;
++
++	if (fbcon_is_inactive(vc, info))
++		return;
++
++	fbcon_cursor(vc, CM_ERASE);
++
++	offset = disp->yscroll - scrollback_current;
++	limit = disp->vrows;
++	switch (disp->scrollmode) {
++	case SCROLL_WRAP_MOVE:
++		info->var.vmode |= FB_VMODE_YWRAP;
++		break;
++	case SCROLL_PAN_MOVE:
++	case SCROLL_PAN_REDRAW:
++		limit -= vc->vc_rows;
++		info->var.vmode &= ~FB_VMODE_YWRAP;
++		break;
++	}
++	if (offset < 0)
++		offset += limit;
++	else if (offset >= limit)
++		offset -= limit;
++
++	ops->var.xoffset = 0;
++	ops->var.yoffset = offset * vc->vc_font.height;
++	ops->update_start(info);
++
++	if (!scrollback_current)
++		fbcon_cursor(vc, CM_DRAW);
+ }
+ 
+ static int fbcon_set_origin(struct vc_data *vc)
+ {
++	if (softback_lines)
++		fbcon_scrolldelta(vc, softback_lines);
+ 	return 0;
+ }
+ 
+@@ -2681,6 +3001,8 @@ static void fbcon_modechanged(struct fb_
+ 
+ 		fbcon_set_palette(vc, color_table);
+ 		update_screen(vc);
++		if (softback_buf)
++			fbcon_update_softback(vc);
+ 	}
+ }
+ 
+@@ -3091,6 +3413,7 @@ static const struct consw fb_con = {
+ 	.con_font_default	= fbcon_set_def_font,
+ 	.con_font_copy 		= fbcon_copy_font,
+ 	.con_set_palette 	= fbcon_set_palette,
++	.con_scrolldelta 	= fbcon_scrolldelta,
+ 	.con_set_origin 	= fbcon_set_origin,
+ 	.con_invert_region 	= fbcon_invert_region,
+ 	.con_screen_pos 	= fbcon_screen_pos,
+@@ -3325,6 +3648,9 @@ static void fbcon_exit(void)
+ 	}
+ #endif
+ 
++	kvfree((void *)softback_buf);
++	softback_buf = 0UL;
++
+ 	for_each_registered_fb(i) {
+ 		int pending = 0;
+ 
diff --git a/0501-bootsplash.patch b/0501-bootsplash.patch
new file mode 100644
index 0000000..4370f87
--- /dev/null
+++ b/0501-bootsplash.patch
@@ -0,0 +1,714 @@
+diff -up linux-5.10/drivers/video/console/Kconfig.59~ linux-5.10/drivers/video/console/Kconfig
+--- linux-5.10/drivers/video/console/Kconfig.59~	2021-01-19 23:05:51.694607935 +0100
++++ linux-5.10/drivers/video/console/Kconfig	2021-01-19 23:07:32.109742870 +0100
+@@ -115,6 +115,30 @@ config FRAMEBUFFER_CONSOLE_DEFERRED_TAKE
+ 	  by the firmware in place, rather then replacing the contents with a
+ 	  black screen as soon as fbcon loads.
+ 
++config BOOTSPLASH
++	bool "Bootup splash screen"
++	depends on FRAMEBUFFER_CONSOLE
++	help
++	  This option enables the Linux bootsplash screen.
++
++	  The bootsplash is a full-screen logo or animation indicating a
++	  booting system. It replaces the classic scrolling text with a
++	  graphical alternative, similar to other systems.
++
++	  Since this is technically implemented as a hook on top of fbcon,
++	  it can only work if the FRAMEBUFFER_CONSOLE is enabled and a
++	  framebuffer driver is active. Thus, to get a text-free boot,
++	  the system needs to boot with vesafb, efifb, or similar.
++
++	  Once built into the kernel, the bootsplash needs to be enabled
++	  with bootsplash.enabled=1 and a splash file needs to be supplied.
++
++	  Further documentation can be found in:
++	    Documentation/fb/bootsplash.txt
++
++	  If unsure, say N.
++	  This is typically used by distributors and system integrators.
++
+ config STI_CONSOLE
+ 	bool "STI text console"
+ 	depends on PARISC && HAS_IOMEM
+diff -up linux-5.10/drivers/video/fbdev/core/bootsplash.c.59~ linux-5.10/drivers/video/fbdev/core/bootsplash.c
+--- linux-5.10/drivers/video/fbdev/core/bootsplash.c.59~	2021-01-19 23:05:51.694607935 +0100
++++ linux-5.10/drivers/video/fbdev/core/bootsplash.c	2021-01-19 23:05:51.694607935 +0100
+@@ -0,0 +1,294 @@
++/*
++ * Kernel based bootsplash.
++ *
++ * (Main file: Glue code, workers, timer, PM, kernel and userland API)
++ *
++ * Authors:
++ * Max Staudt <mstaudt@suse.de>
++ *
++ * SPDX-License-Identifier: GPL-2.0
++ */
++
++#define pr_fmt(fmt) "bootsplash: " fmt
++
++
++#include <linux/atomic.h>
++#include <linux/bootsplash.h>
++#include <linux/console.h>
++#include <linux/device.h> /* dev_warn() */
++#include <linux/fb.h>
++#include <linux/fs.h>
++#include <linux/kernel.h>
++#include <linux/jiffies.h>
++#include <linux/module.h>
++#include <linux/mutex.h>
++#include <linux/platform_device.h>
++#include <linux/printk.h>
++#include <linux/selection.h> /* console_blanked */
++#include <linux/stringify.h>
++#include <linux/types.h>
++#include <linux/vmalloc.h>
++#include <linux/vt_kern.h>
++#include <linux/workqueue.h>
++
++#include "bootsplash_internal.h"
++
++
++/*
++ * We only have one splash screen, so let's keep a single
++ * instance of the internal state.
++ */
++static struct splash_priv splash_state;
++
++
++static void splash_callback_redraw_vc(struct work_struct *ignored)
++{
++	if (console_blanked)
++		return;
++
++	console_lock();
++	if (vc_cons[fg_console].d)
++		update_screen(vc_cons[fg_console].d);
++	console_unlock();
++}
++
++
++static bool is_fb_compatible(const struct fb_info *info)
++{
++	if (!(info->flags & FBINFO_BE_MATH)
++	    != !fb_be_math((struct fb_info *)info)) {
++		dev_warn(info->device,
++			 "Can't draw on foreign endianness framebuffer.\n");
++
++		return false;
++	}
++
++	if (info->flags & FBINFO_MISC_TILEBLITTING) {
++		dev_warn(info->device,
++			 "Can't draw splash on tiling framebuffer.\n");
++
++		return false;
++	}
++
++	if (info->fix.type != FB_TYPE_PACKED_PIXELS
++	    || (info->fix.visual != FB_VISUAL_TRUECOLOR
++		&& info->fix.visual != FB_VISUAL_DIRECTCOLOR)) {
++		dev_warn(info->device,
++			 "Can't draw splash on non-packed or non-truecolor framebuffer.\n");
++
++		dev_warn(info->device,
++			 "  type: %u   visual: %u\n",
++			 info->fix.type, info->fix.visual);
++
++		return false;
++	}
++
++	if (info->var.bits_per_pixel != 16
++	    && info->var.bits_per_pixel != 24
++	    && info->var.bits_per_pixel != 32) {
++		dev_warn(info->device,
++			 "We only support drawing on framebuffers with 16, 24, or 32 bpp, not %d.\n",
++			 info->var.bits_per_pixel);
++
++		return false;
++	}
++
++	return true;
++}
++
++
++/*
++ * Called by fbcon_switch() when an instance is activated or refreshed.
++ */
++void bootsplash_render_full(struct fb_info *info)
++{
++	if (!is_fb_compatible(info))
++		return;
++
++	bootsplash_do_render_background(info);
++}
++
++
++/*
++ * External status enquiry and on/off switch
++ */
++bool bootsplash_would_render_now(void)
++{
++	return !oops_in_progress
++		&& !console_blanked
++		&& bootsplash_is_enabled();
++}
++
++bool bootsplash_is_enabled(void)
++{
++	bool was_enabled;
++
++	/* Make sure we have the newest state */
++	smp_rmb();
++
++	was_enabled = test_bit(0, &splash_state.enabled);
++
++	return was_enabled;
++}
++
++void bootsplash_disable(void)
++{
++	int was_enabled;
++
++	was_enabled = test_and_clear_bit(0, &splash_state.enabled);
++
++	if (was_enabled) {
++		if (oops_in_progress) {
++			/* Redraw screen now so we can see a panic */
++			if (vc_cons[fg_console].d)
++				update_screen(vc_cons[fg_console].d);
++		} else {
++			/* No urgency, redraw at next opportunity */
++			schedule_work(&splash_state.work_redraw_vc);
++		}
++	}
++}
++
++void bootsplash_enable(void)
++{
++	bool was_enabled;
++
++	if (oops_in_progress)
++		return;
++
++	was_enabled = test_and_set_bit(0, &splash_state.enabled);
++
++	if (!was_enabled)
++		schedule_work(&splash_state.work_redraw_vc);
++}
++
++
++/*
++ * Userland API via platform device in sysfs
++ */
++static ssize_t splash_show_enabled(struct device *dev,
++				   struct device_attribute *attr, char *buf)
++{
++	return sprintf(buf, "%d\n", bootsplash_is_enabled());
++}
++
++static ssize_t splash_store_enabled(struct device *device,
++				    struct device_attribute *attr,
++				    const char *buf, size_t count)
++{
++	bool enable;
++	int err;
++
++	if (!buf || !count)
++		return -EFAULT;
++
++	err = kstrtobool(buf, &enable);
++	if (err)
++		return err;
++
++	if (enable)
++		bootsplash_enable();
++	else
++		bootsplash_disable();
++
++	return count;
++}
++
++static DEVICE_ATTR(enabled, 0644, splash_show_enabled, splash_store_enabled);
++
++
++static struct attribute *splash_dev_attrs[] = {
++	&dev_attr_enabled.attr,
++	NULL
++};
++
++ATTRIBUTE_GROUPS(splash_dev);
++
++
++
++
++/*
++ * Power management fixup via platform device
++ *
++ * When the system is woken from sleep or restored after hibernating, we
++ * cannot expect the screen contents to still be present in video RAM.
++ * Thus, we have to redraw the splash if we're currently active.
++ */
++static int splash_resume(struct device *device)
++{
++	if (bootsplash_would_render_now())
++		schedule_work(&splash_state.work_redraw_vc);
++
++	return 0;
++}
++
++static int splash_suspend(struct device *device)
++{
++	cancel_work_sync(&splash_state.work_redraw_vc);
++
++	return 0;
++}
++
++
++static const struct dev_pm_ops splash_pm_ops = {
++	.thaw = splash_resume,
++	.restore = splash_resume,
++	.resume = splash_resume,
++	.suspend = splash_suspend,
++	.freeze = splash_suspend,
++};
++
++static struct platform_driver splash_driver = {
++	.driver = {
++		.name = "bootsplash",
++		.pm = &splash_pm_ops,
++	},
++};
++
++
++/*
++ * Main init
++ */
++void bootsplash_init(void)
++{
++	int ret;
++
++	/* Initialized already? */
++	if (splash_state.splash_device)
++		return;
++
++
++	/* Register platform device to export user API */
++	ret = platform_driver_register(&splash_driver);
++	if (ret) {
++		pr_err("platform_driver_register() failed: %d\n", ret);
++		goto err;
++	}
++
++	splash_state.splash_device
++		= platform_device_alloc("bootsplash", 0);
++
++	if (!splash_state.splash_device)
++		goto err_driver;
++
++	splash_state.splash_device->dev.groups = splash_dev_groups;
++
++	ret = platform_device_add(splash_state.splash_device);
++	if (ret) {
++		pr_err("platform_device_add() failed: %d\n", ret);
++		goto err_device;
++	}
++
++
++	INIT_WORK(&splash_state.work_redraw_vc, splash_callback_redraw_vc);
++
++	return;
++
++err_device:
++	platform_device_put(splash_state.splash_device);
++	splash_state.splash_device = NULL;
++err_driver:
++	platform_driver_unregister(&splash_driver);
++err:
++	pr_err("Failed to initialize.\n");
++}
+diff -up linux-5.10/drivers/video/fbdev/core/bootsplash_internal.h.59~ linux-5.10/drivers/video/fbdev/core/bootsplash_internal.h
+--- linux-5.10/drivers/video/fbdev/core/bootsplash_internal.h.59~	2021-01-19 23:05:51.697941328 +0100
++++ linux-5.10/drivers/video/fbdev/core/bootsplash_internal.h	2021-01-19 23:05:51.697941328 +0100
+@@ -0,0 +1,55 @@
++/*
++ * Kernel based bootsplash.
++ *
++ * (Internal data structures used at runtime)
++ *
++ * Authors:
++ * Max Staudt <mstaudt@suse.de>
++ *
++ * SPDX-License-Identifier: GPL-2.0
++ */
++
++#ifndef __BOOTSPLASH_INTERNAL_H
++#define __BOOTSPLASH_INTERNAL_H
++
++
++#include <linux/types.h>
++#include <linux/fb.h>
++#include <linux/kernel.h>
++#include <linux/mutex.h>
++#include <linux/spinlock.h>
++
++
++/*
++ * Runtime types
++ */
++struct splash_priv {
++	/*
++	 * Enabled/disabled state, to be used with atomic bit operations.
++	 *   Bit 0: 0 = Splash hidden
++	 *          1 = Splash shown
++	 *
++	 * Note: fbcon.c uses this twice, by calling
++	 *       bootsplash_would_render_now() in set_blitting_type() and
++	 *       in fbcon_switch().
++	 *       This is racy, but eventually consistent: Turning the
++	 *       splash on/off will cause a redraw, which calls
++	 *       fbcon_switch(), which calls set_blitting_type().
++	 *       So the last on/off toggle will make things consistent.
++	 */
++	unsigned long enabled;
++
++	/* Our gateway to userland via sysfs */
++	struct platform_device *splash_device;
++
++	struct work_struct work_redraw_vc;
++};
++
++
++
++/*
++ * Rendering functions
++ */
++void bootsplash_do_render_background(struct fb_info *info);
++
++#endif
+diff -up linux-5.10/drivers/video/fbdev/core/bootsplash_render.c.59~ linux-5.10/drivers/video/fbdev/core/bootsplash_render.c
+--- linux-5.10/drivers/video/fbdev/core/bootsplash_render.c.59~	2021-01-19 23:05:51.697941328 +0100
++++ linux-5.10/drivers/video/fbdev/core/bootsplash_render.c	2021-01-19 23:05:51.697941328 +0100
+@@ -0,0 +1,93 @@
++/*
++ * Kernel based bootsplash.
++ *
++ * (Rendering functions)
++ *
++ * Authors:
++ * Max Staudt <mstaudt@suse.de>
++ *
++ * SPDX-License-Identifier: GPL-2.0
++ */
++
++#define pr_fmt(fmt) "bootsplash: " fmt
++
++
++#include <linux/bootsplash.h>
++#include <linux/fb.h>
++#include <linux/kernel.h>
++#include <linux/printk.h>
++#include <linux/types.h>
++
++#include "bootsplash_internal.h"
++
++
++
++
++/*
++ * Rendering: Internal drawing routines
++ */
++
++
++/*
++ * Pack pixel into target format and do Big/Little Endian handling.
++ * This would be a good place to handle endianness conversion if necessary.
++ */
++static inline u32 pack_pixel(const struct fb_var_screeninfo *dst_var,
++			     u8 red, u8 green, u8 blue)
++{
++	u32 dstpix;
++
++	/* Quantize pixel */
++	red = red >> (8 - dst_var->red.length);
++	green = green >> (8 - dst_var->green.length);
++	blue = blue >> (8 - dst_var->blue.length);
++
++	/* Pack pixel */
++	dstpix = red << (dst_var->red.offset)
++		| green << (dst_var->green.offset)
++		| blue << (dst_var->blue.offset);
++
++	/*
++	 * Move packed pixel to the beginning of the memory cell,
++	 * so we can memcpy() it out easily
++	 */
++#ifdef __BIG_ENDIAN
++	switch (dst_var->bits_per_pixel) {
++	case 16:
++		dstpix <<= 16;
++		break;
++	case 24:
++		dstpix <<= 8;
++		break;
++	case 32:
++		break;
++	}
++#else
++	/* This is intrinsically unnecessary on Little Endian */
++#endif
++
++	return dstpix;
++}
++
++
++void bootsplash_do_render_background(struct fb_info *info)
++{
++	unsigned int x, y;
++	u32 dstpix;
++	u32 dst_octpp = info->var.bits_per_pixel / 8;
++
++	dstpix = pack_pixel(&info->var,
++			    0,
++			    0,
++			    0);
++
++	for (y = 0; y < info->var.yres_virtual; y++) {
++		u8 *dstline = info->screen_buffer + (y * info->fix.line_length);
++
++		for (x = 0; x < info->var.xres_virtual; x++) {
++			memcpy(dstline, &dstpix, dst_octpp);
++
++			dstline += dst_octpp;
++		}
++	}
++}
+diff -up linux-5.10/drivers/video/fbdev/core/dummyblit.c.59~ linux-5.10/drivers/video/fbdev/core/dummyblit.c
+--- linux-5.10/drivers/video/fbdev/core/dummyblit.c.59~	2021-01-19 23:05:51.697941328 +0100
++++ linux-5.10/drivers/video/fbdev/core/dummyblit.c	2021-01-19 23:05:51.697941328 +0100
+@@ -0,0 +1,89 @@
++/*
++ *  linux/drivers/video/fbdev/core/dummyblit.c -- Dummy Blitting Operation
++ *
++ *  Authors:
++ *  Max Staudt <mstaudt@suse.de>
++ *
++ *  These functions are used in place of blitblit/tileblit to suppress
++ *  fbcon's text output while a splash is shown.
++ *
++ *  Only suppressing actual rendering keeps the text buffer in the VC layer
++ *  intact and makes it easy to switch back from the bootsplash to a full
++ *  text console with a simple redraw (with the original functions in place).
++ *
++ *  Based on linux/drivers/video/fbdev/core/bitblit.c
++ *       and linux/drivers/video/fbdev/core/tileblit.c
++ *
++ * SPDX-License-Identifier: GPL-2.0
++ */
++
++#include <linux/module.h>
++#include <linux/fb.h>
++#include <linux/vt_kern.h>
++#include <linux/console.h>
++#include <asm/types.h>
++#include "fbcon.h"
++
++static void dummy_bmove(struct vc_data *vc, struct fb_info *info, int sy,
++			int sx, int dy, int dx, int height, int width)
++{
++	;
++}
++
++static void dummy_clear(struct vc_data *vc, struct fb_info *info, int sy,
++			int sx, int height, int width)
++{
++	;
++}
++
++static void dummy_putcs(struct vc_data *vc, struct fb_info *info,
++			const unsigned short *s, int count, int yy, int xx,
++			int fg, int bg)
++{
++	;
++}
++
++static void dummy_clear_margins(struct vc_data *vc, struct fb_info *info,
++				int color, int bottom_only)
++{
++	;
++}
++
++static void dummy_cursor(struct vc_data *vc, struct fb_info *info, int mode,
++			int softback_lines, int fg, int bg)
++{
++	;
++}
++
++static int dummy_update_start(struct fb_info *info)
++{
++	/*
++	 * Copied from bitblit.c and tileblit.c
++	 *
++	 * As of Linux 4.12, nobody seems to care about our return value.
++	 */
++	struct fbcon_ops *ops = info->fbcon_par;
++	int err;
++
++	err = fb_pan_display(info, &ops->var);
++	ops->var.xoffset = info->var.xoffset;
++	ops->var.yoffset = info->var.yoffset;
++	ops->var.vmode = info->var.vmode;
++	return err;
++}
++
++void fbcon_set_dummyops(struct fbcon_ops *ops)
++{
++	ops->bmove = dummy_bmove;
++	ops->clear = dummy_clear;
++	ops->putcs = dummy_putcs;
++	ops->clear_margins = dummy_clear_margins;
++	ops->cursor = dummy_cursor;
++	ops->update_start = dummy_update_start;
++	ops->rotate_font = NULL;
++}
++EXPORT_SYMBOL_GPL(fbcon_set_dummyops);
++
++MODULE_AUTHOR("Max Staudt <mstaudt@suse.de>");
++MODULE_DESCRIPTION("Dummy Blitting Operation");
++MODULE_LICENSE("GPL");
+diff -up linux-5.10/drivers/video/fbdev/core/fbcon.c.59~ linux-5.10/drivers/video/fbdev/core/fbcon.c
+--- linux-5.10/drivers/video/fbdev/core/fbcon.c.59~	2021-01-19 23:05:51.691274541 +0100
++++ linux-5.10/drivers/video/fbdev/core/fbcon.c	2021-01-19 23:05:51.697941328 +0100
+@@ -81,6 +81,7 @@
+ #include <asm/irq.h>
+ 
+ #include "fbcon.h"
++#include <linux/bootsplash.h>
+ 
+ #ifdef FBCONDEBUG
+ #  define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __func__ , ## args)
+@@ -585,6 +586,8 @@ static int do_fbcon_takeover(int show_lo
+ 	for (i = first_fb_vc; i <= last_fb_vc; i++)
+ 		con2fb_map[i] = info_idx;
+ 
++	bootsplash_init();
++
+ 	err = do_take_over_console(&fb_con, first_fb_vc, last_fb_vc,
+ 				fbcon_is_default);
+ 
+@@ -708,6 +711,9 @@ static void set_blitting_type(struct vc_
+ 	else {
+ 		fbcon_set_rotation(info);
+ 		fbcon_set_bitops(ops);
++
++		if (bootsplash_would_render_now())
++			fbcon_set_dummyops(ops);
+ 	}
+ }
+ 
+@@ -730,6 +736,19 @@ static void set_blitting_type(struct vc_
+ 	ops->p = &fb_display[vc->vc_num];
+ 	fbcon_set_rotation(info);
+ 	fbcon_set_bitops(ops);
++
++	/*
++	 * Note:
++	 * This is *eventually correct*.
++	 * Setting the fbcon operations and drawing the splash happen at
++	 * different points in time. If the splash is enabled/disabled
++	 * in between, then bootsplash_{en,dis}able will schedule a
++	 * redraw, which will again render the splash (or not) and set
++	 * the correct fbcon ops.
++	 * The last run will then be the right one.
++	 */
++	if (bootsplash_would_render_now())
++		fbcon_set_dummyops(ops);
+ }
+ 
+ static int fbcon_invalid_charcount(struct fb_info *info, unsigned charcount)
+@@ -2238,6 +2257,9 @@ static int fbcon_switch(struct vc_data *
+ 	info = registered_fb[con2fb_map[vc->vc_num]];
+ 	ops = info->fbcon_par;
+ 
++	if (bootsplash_would_render_now())
++		bootsplash_render_full(info);
++
+ 	if (softback_top) {
+ 		if (softback_lines)
+ 			fbcon_set_origin(vc);
+diff -up linux-5.10/drivers/video/fbdev/core/fbcon.h.59~ linux-5.10/drivers/video/fbdev/core/fbcon.h
+--- linux-5.10/drivers/video/fbdev/core/fbcon.h.59~	2021-01-19 23:05:51.687941149 +0100
++++ linux-5.10/drivers/video/fbdev/core/fbcon.h	2021-01-19 23:05:51.697941328 +0100
+@@ -208,6 +208,11 @@ static inline int attr_col_ec(int shift,
+ #define SCROLL_REDRAW	   0x004
+ #define SCROLL_PAN_REDRAW  0x005
+ 
++#ifdef CONFIG_BOOTSPLASH
++extern void fbcon_set_dummyops(struct fbcon_ops *ops);
++#else /* CONFIG_BOOTSPLASH */
++#define fbcon_set_dummyops(x)
++#endif /* CONFIG_BOOTSPLASH */
+ #ifdef CONFIG_FB_TILEBLITTING
+ extern void fbcon_set_tileops(struct vc_data *vc, struct fb_info *info);
+ #endif
+diff -up linux-5.10/drivers/video/fbdev/core/Makefile.59~ linux-5.10/drivers/video/fbdev/core/Makefile
+--- linux-5.10/drivers/video/fbdev/core/Makefile.59~	2020-12-13 23:41:30.000000000 +0100
++++ linux-5.10/drivers/video/fbdev/core/Makefile	2021-01-19 23:05:51.694607935 +0100
+@@ -26,3 +26,6 @@ obj-$(CONFIG_FB_SYS_IMAGEBLIT) += sysimg
+ obj-$(CONFIG_FB_SYS_FOPS)      += fb_sys_fops.o
+ obj-$(CONFIG_FB_SVGALIB)       += svgalib.o
+ obj-$(CONFIG_FB_DDC)           += fb_ddc.o
++
++obj-$(CONFIG_BOOTSPLASH)       += bootsplash.o bootsplash_render.o \
++                                  dummyblit.o
+diff -up linux-5.10/include/linux/bootsplash.h.59~ linux-5.10/include/linux/bootsplash.h
+--- linux-5.10/include/linux/bootsplash.h.59~	2021-01-19 23:05:51.697941328 +0100
++++ linux-5.10/include/linux/bootsplash.h	2021-01-19 23:05:51.697941328 +0100
+@@ -0,0 +1,43 @@
++/*
++ * Kernel based bootsplash.
++ *
++ * Authors:
++ * Max Staudt <mstaudt@suse.de>
++ *
++ * SPDX-License-Identifier: GPL-2.0
++ */
++
++#ifndef __LINUX_BOOTSPLASH_H
++#define __LINUX_BOOTSPLASH_H
++
++#include <linux/fb.h>
++
++
++#ifdef CONFIG_BOOTSPLASH
++
++extern void bootsplash_render_full(struct fb_info *info);
++
++extern bool bootsplash_would_render_now(void);
++
++extern bool bootsplash_is_enabled(void);
++extern void bootsplash_disable(void);
++extern void bootsplash_enable(void);
++
++extern void bootsplash_init(void);
++
++#else /* CONFIG_BOOTSPLASH */
++
++#define bootsplash_render_full(x)
++
++#define bootsplash_would_render_now() (false)
++
++#define bootsplash_is_enabled() (false)
++#define bootsplash_disable()
++#define bootsplash_enable()
++
++#define bootsplash_init()
++
++#endif /* CONFIG_BOOTSPLASH */
++
++
++#endif
+diff -up linux-5.10/MAINTAINERS.59~ linux-5.10/MAINTAINERS
diff --git a/0502-bootsplash.patch b/0502-bootsplash.patch
new file mode 100644
index 0000000..e8d4cc8
--- /dev/null
+++ b/0502-bootsplash.patch
@@ -0,0 +1,657 @@
+diff --git a/drivers/video/fbdev/core/Makefile b/drivers/video/fbdev/core/Makefile
+index 66895321928e..6a8d1bab8a01 100644
+--- a/drivers/video/fbdev/core/Makefile
++++ b/drivers/video/fbdev/core/Makefile
+@@ -31,4 +31,4 @@ obj-$(CONFIG_FB_SVGALIB)       += svgalib.o
+ obj-$(CONFIG_FB_DDC)           += fb_ddc.o
+ 
+ obj-$(CONFIG_BOOTSPLASH)       += bootsplash.o bootsplash_render.o \
+-                                  dummyblit.o
++                                  bootsplash_load.o dummyblit.o
+diff --git a/drivers/video/fbdev/core/bootsplash.c b/drivers/video/fbdev/core/bootsplash.c
+index e449755af268..843c5400fefc 100644
+--- a/drivers/video/fbdev/core/bootsplash.c
++++ b/drivers/video/fbdev/core/bootsplash.c
+@@ -32,6 +32,7 @@
+ #include <linux/workqueue.h>
+ 
+ #include "bootsplash_internal.h"
++#include "uapi/linux/bootsplash_file.h"
+ 
+ 
+ /*
+@@ -102,10 +103,17 @@ static bool is_fb_compatible(const struct fb_info *info)
+  */
+ void bootsplash_render_full(struct fb_info *info)
+ {
++	mutex_lock(&splash_state.data_lock);
++
+ 	if (!is_fb_compatible(info))
+-		return;
++		goto out;
++
++	bootsplash_do_render_background(info, splash_state.file);
++
++	bootsplash_do_render_pictures(info, splash_state.file);
+ 
+-	bootsplash_do_render_background(info);
++out:
++	mutex_unlock(&splash_state.data_lock);
+ }
+ 
+ 
+@@ -116,6 +124,7 @@ bool bootsplash_would_render_now(void)
+ {
+ 	return !oops_in_progress
+ 		&& !console_blanked
++		&& splash_state.file
+ 		&& bootsplash_is_enabled();
+ }
+ 
+@@ -252,6 +261,7 @@ static struct platform_driver splash_driver = {
+ void bootsplash_init(void)
+ {
+ 	int ret;
++	struct splash_file_priv *fp;
+ 
+ 	/* Initialized already? */
+ 	if (splash_state.splash_device)
+@@ -280,8 +290,26 @@ void bootsplash_init(void)
+ 	}
+ 
+ 
++	mutex_init(&splash_state.data_lock);
++	set_bit(0, &splash_state.enabled);
++
+ 	INIT_WORK(&splash_state.work_redraw_vc, splash_callback_redraw_vc);
+ 
++
++	if (!splash_state.bootfile || !strlen(splash_state.bootfile))
++		return;
++
++	fp = bootsplash_load_firmware(&splash_state.splash_device->dev,
++				      splash_state.bootfile);
++
++	if (!fp)
++		goto err;
++
++	mutex_lock(&splash_state.data_lock);
++	splash_state.splash_fb = NULL;
++	splash_state.file = fp;
++	mutex_unlock(&splash_state.data_lock);
++
+ 	return;
+ 
+ err_device:
+@@ -292,3 +320,7 @@ void bootsplash_init(void)
+ err:
+ 	pr_err("Failed to initialize.\n");
+ }
++
++
++module_param_named(bootfile, splash_state.bootfile, charp, 0444);
++MODULE_PARM_DESC(bootfile, "Bootsplash file to load on boot");
+diff --git a/drivers/video/fbdev/core/bootsplash_internal.h b/drivers/video/fbdev/core/bootsplash_internal.h
+index b11da5cb90bf..71e2a27ac0b8 100644
+--- a/drivers/video/fbdev/core/bootsplash_internal.h
++++ b/drivers/video/fbdev/core/bootsplash_internal.h
+@@ -15,15 +15,43 @@
+ 
+ #include <linux/types.h>
+ #include <linux/fb.h>
++#include <linux/firmware.h>
+ #include <linux/kernel.h>
+ #include <linux/mutex.h>
+ #include <linux/spinlock.h>
+ 
++#include "uapi/linux/bootsplash_file.h"
++
+ 
+ /*
+  * Runtime types
+  */
++struct splash_blob_priv {
++	struct splash_blob_header *blob_header;
++	const void *data;
++};
++
++
++struct splash_pic_priv {
++	const struct splash_pic_header *pic_header;
++
++	struct splash_blob_priv *blobs;
++	u16 blobs_loaded;
++};
++
++
++struct splash_file_priv {
++	const struct firmware *fw;
++	const struct splash_file_header *header;
++
++	struct splash_pic_priv *pics;
++};
++
++
+ struct splash_priv {
++	/* Bootup and runtime state */
++	char *bootfile;
++
+ 	/*
+ 	 * Enabled/disabled state, to be used with atomic bit operations.
+ 	 *   Bit 0: 0 = Splash hidden
+@@ -43,6 +71,13 @@ struct splash_priv {
+ 	struct platform_device *splash_device;
+ 
+ 	struct work_struct work_redraw_vc;
++
++	/* Splash data structures including lock for everything below */
++	struct mutex data_lock;
++
++	struct fb_info *splash_fb;
++
++	struct splash_file_priv *file;
+ };
+ 
+ 
+@@ -50,6 +85,14 @@ struct splash_priv {
+ /*
+  * Rendering functions
+  */
+-void bootsplash_do_render_background(struct fb_info *info);
++void bootsplash_do_render_background(struct fb_info *info,
++				     const struct splash_file_priv *fp);
++void bootsplash_do_render_pictures(struct fb_info *info,
++				   const struct splash_file_priv *fp);
++
++
++void bootsplash_free_file(struct splash_file_priv *fp);
++struct splash_file_priv *bootsplash_load_firmware(struct device *device,
++						  const char *path);
+ 
+ #endif
+diff --git a/drivers/video/fbdev/core/bootsplash_load.c b/drivers/video/fbdev/core/bootsplash_load.c
+new file mode 100644
+index 000000000000..fd807571ab7d
+--- /dev/null
++++ b/drivers/video/fbdev/core/bootsplash_load.c
+@@ -0,0 +1,225 @@
++/*
++ * Kernel based bootsplash.
++ *
++ * (Loading and freeing functions)
++ *
++ * Authors:
++ * Max Staudt <mstaudt@suse.de>
++ *
++ * SPDX-License-Identifier: GPL-2.0
++ */
++
++#define pr_fmt(fmt) "bootsplash: " fmt
++
++
++#include <linux/bootsplash.h>
++#include <linux/fb.h>
++#include <linux/firmware.h>
++#include <linux/kernel.h>
++#include <linux/mutex.h>
++#include <linux/printk.h>
++#include <linux/types.h>
++#include <linux/vmalloc.h>
++
++#include "bootsplash_internal.h"
++#include "uapi/linux/bootsplash_file.h"
++
++
++
++
++/*
++ * Free all vmalloc()'d resources describing a splash file.
++ */
++void bootsplash_free_file(struct splash_file_priv *fp)
++{
++	if (!fp)
++		return;
++
++	if (fp->pics) {
++		unsigned int i;
++
++		for (i = 0; i < fp->header->num_pics; i++) {
++			struct splash_pic_priv *pp = &fp->pics[i];
++
++			if (pp->blobs)
++				vfree(pp->blobs);
++		}
++
++		vfree(fp->pics);
++	}
++
++	release_firmware(fp->fw);
++	vfree(fp);
++}
++
++
++
++
++/*
++ * Load a splash screen from a "firmware" file.
++ *
++ * Parsing, and sanity checks.
++ */
++#ifdef __BIG_ENDIAN
++	#define BOOTSPLASH_MAGIC BOOTSPLASH_MAGIC_BE
++#else
++	#define BOOTSPLASH_MAGIC BOOTSPLASH_MAGIC_LE
++#endif
++
++struct splash_file_priv *bootsplash_load_firmware(struct device *device,
++						  const char *path)
++{
++	const struct firmware *fw;
++	struct splash_file_priv *fp;
++	unsigned int i;
++	const u8 *walker;
++
++	if (request_firmware(&fw, path, device))
++		return NULL;
++
++	if (fw->size < sizeof(struct splash_file_header)
++	    || memcmp(fw->data, BOOTSPLASH_MAGIC, sizeof(fp->header->id))) {
++		pr_err("Not a bootsplash file.\n");
++
++		release_firmware(fw);
++		return NULL;
++	}
++
++	fp = vzalloc(sizeof(struct splash_file_priv));
++	if (!fp) {
++		release_firmware(fw);
++		return NULL;
++	}
++
++	pr_info("Loading splash file (%li bytes)\n", fw->size);
++
++	fp->fw = fw;
++	fp->header = (struct splash_file_header *)fw->data;
++
++	/* Sanity checks */
++	if (fp->header->version != BOOTSPLASH_VERSION) {
++		pr_err("Loaded v%d file, but we only support version %d\n",
++			fp->header->version,
++			BOOTSPLASH_VERSION);
++
++		goto err;
++	}
++
++	if (fw->size < sizeof(struct splash_file_header)
++		+ fp->header->num_pics
++			* sizeof(struct splash_pic_header)
++		+ fp->header->num_blobs
++			* sizeof(struct splash_blob_header)) {
++		pr_err("File incomplete.\n");
++
++		goto err;
++	}
++
++	/* Read picture headers */
++	if (fp->header->num_pics) {
++		fp->pics = vzalloc(fp->header->num_pics
++				   * sizeof(struct splash_pic_priv));
++		if (!fp->pics)
++			goto err;
++	}
++
++	walker = fw->data + sizeof(struct splash_file_header);
++	for (i = 0; i < fp->header->num_pics; i++) {
++		struct splash_pic_priv *pp = &fp->pics[i];
++		struct splash_pic_header *ph = (void *)walker;
++
++		pr_debug("Picture %u: Size %ux%u\n", i, ph->width, ph->height);
++
++		if (ph->num_blobs < 1) {
++			pr_err("Picture %u: Zero blobs? Aborting load.\n", i);
++			goto err;
++		}
++
++		pp->pic_header = ph;
++		pp->blobs = vzalloc(ph->num_blobs
++					* sizeof(struct splash_blob_priv));
++		if (!pp->blobs)
++			goto err;
++
++		walker += sizeof(struct splash_pic_header);
++	}
++
++	/* Read blob headers */
++	for (i = 0; i < fp->header->num_blobs; i++) {
++		struct splash_blob_header *bh = (void *)walker;
++		struct splash_pic_priv *pp;
++
++		if (walker + sizeof(struct splash_blob_header)
++		    > fw->data + fw->size)
++			goto err;
++
++		walker += sizeof(struct splash_blob_header);
++
++		if (walker + bh->length > fw->data + fw->size)
++			goto err;
++
++		if (bh->picture_id >= fp->header->num_pics)
++			goto nextblob;
++
++		pp = &fp->pics[bh->picture_id];
++
++		pr_debug("Blob %u, pic %u, blobs_loaded %u, num_blobs %u.\n",
++			 i, bh->picture_id,
++			 pp->blobs_loaded, pp->pic_header->num_blobs);
++
++		if (pp->blobs_loaded >= pp->pic_header->num_blobs)
++			goto nextblob;
++
++		switch (bh->type) {
++		case 0:
++			/* Raw 24-bit packed pixels */
++			if (bh->length != pp->pic_header->width
++					* pp->pic_header->height * 3) {
++				pr_err("Blob %u, type 1: Length doesn't match picture.\n",
++				       i);
++
++				goto err;
++			}
++			break;
++		default:
++			pr_warn("Blob %u, unknown type %u.\n", i, bh->type);
++			goto nextblob;
++		}
++
++		pp->blobs[pp->blobs_loaded].blob_header = bh;
++		pp->blobs[pp->blobs_loaded].data = walker;
++		pp->blobs_loaded++;
++
++nextblob:
++		walker += bh->length;
++		if (bh->length % 16)
++			walker += 16 - (bh->length % 16);
++	}
++
++	if (walker != fw->data + fw->size)
++		pr_warn("Trailing data in splash file.\n");
++
++	/* Walk over pictures and ensure all blob slots are filled */
++	for (i = 0; i < fp->header->num_pics; i++) {
++		struct splash_pic_priv *pp = &fp->pics[i];
++
++		if (pp->blobs_loaded != pp->pic_header->num_blobs) {
++			pr_err("Picture %u doesn't have all blob slots filled.\n",
++			       i);
++
++			goto err;
++		}
++	}
++
++	pr_info("Loaded (%ld bytes, %u pics, %u blobs).\n",
++		fw->size,
++		fp->header->num_pics,
++		fp->header->num_blobs);
++
++	return fp;
++
++
++err:
++	bootsplash_free_file(fp);
++	return NULL;
++}
+diff --git a/drivers/video/fbdev/core/bootsplash_render.c b/drivers/video/fbdev/core/bootsplash_render.c
+index 4d7e0117f653..2ae36949d0e3 100644
+--- a/drivers/video/fbdev/core/bootsplash_render.c
++++ b/drivers/video/fbdev/core/bootsplash_render.c
+@@ -19,6 +19,7 @@
+ #include <linux/types.h>
+ 
+ #include "bootsplash_internal.h"
++#include "uapi/linux/bootsplash_file.h"
+ 
+ 
+ 
+@@ -70,16 +71,69 @@ static inline u32 pack_pixel(const struct fb_var_screeninfo *dst_var,
+ }
+ 
+ 
+-void bootsplash_do_render_background(struct fb_info *info)
++/*
++ * Copy from source and blend into the destination picture.
++ * Currently assumes that the source picture is 24bpp.
++ * Currently assumes that the destination is <= 32bpp.
++ */
++static int splash_convert_to_fb(u8 *dst,
++				const struct fb_var_screeninfo *dst_var,
++				unsigned int dst_stride,
++				unsigned int dst_xoff,
++				unsigned int dst_yoff,
++				const u8 *src,
++				unsigned int src_width,
++				unsigned int src_height)
++{
++	unsigned int x, y;
++	unsigned int src_stride = 3 * src_width; /* Assume 24bpp packed */
++	u32 dst_octpp = dst_var->bits_per_pixel / 8;
++
++	dst_xoff += dst_var->xoffset;
++	dst_yoff += dst_var->yoffset;
++
++	/* Copy with stride and pixel size adjustment */
++	for (y = 0;
++	     y < src_height && y + dst_yoff < dst_var->yres_virtual;
++	     y++) {
++		const u8 *srcline = src + (y * src_stride);
++		u8 *dstline = dst + ((y + dst_yoff) * dst_stride)
++				  + (dst_xoff * dst_octpp);
++
++		for (x = 0;
++		     x < src_width && x + dst_xoff < dst_var->xres_virtual;
++		     x++) {
++			u8 red, green, blue;
++			u32 dstpix;
++
++			/* Read pixel */
++			red = *srcline++;
++			green = *srcline++;
++			blue = *srcline++;
++
++			/* Write pixel */
++			dstpix = pack_pixel(dst_var, red, green, blue);
++			memcpy(dstline, &dstpix, dst_octpp);
++
++			dstline += dst_octpp;
++		}
++	}
++
++	return 0;
++}
++
++
++void bootsplash_do_render_background(struct fb_info *info,
++				     const struct splash_file_priv *fp)
+ {
+ 	unsigned int x, y;
+ 	u32 dstpix;
+ 	u32 dst_octpp = info->var.bits_per_pixel / 8;
+ 
+ 	dstpix = pack_pixel(&info->var,
+-			    0,
+-			    0,
+-			    0);
++			    fp->header->bg_red,
++			    fp->header->bg_green,
++			    fp->header->bg_blue);
+ 
+ 	for (y = 0; y < info->var.yres_virtual; y++) {
+ 		u8 *dstline = info->screen_buffer + (y * info->fix.line_length);
+@@ -91,3 +145,44 @@ void bootsplash_do_render_background(struct fb_info *info)
+ 		}
+ 	}
+ }
++
++
++void bootsplash_do_render_pictures(struct fb_info *info,
++				   const struct splash_file_priv *fp)
++{
++	unsigned int i;
++
++	for (i = 0; i < fp->header->num_pics; i++) {
++		struct splash_blob_priv *bp;
++		struct splash_pic_priv *pp = &fp->pics[i];
++		long dst_xoff, dst_yoff;
++
++		if (pp->blobs_loaded < 1)
++			continue;
++
++		bp = &pp->blobs[0];
++
++		if (!bp || bp->blob_header->type != 0)
++			continue;
++
++		dst_xoff = (info->var.xres - pp->pic_header->width) / 2;
++		dst_yoff = (info->var.yres - pp->pic_header->height) / 2;
++
++		if (dst_xoff < 0
++		    || dst_yoff < 0
++		    || dst_xoff + pp->pic_header->width > info->var.xres
++		    || dst_yoff + pp->pic_header->height > info->var.yres) {
++			pr_info_once("Picture %u is out of bounds at current resolution: %dx%d\n"
++				     "(this will only be printed once every reboot)\n",
++				     i, info->var.xres, info->var.yres);
++
++			continue;
++		}
++
++		/* Draw next splash frame */
++		splash_convert_to_fb(info->screen_buffer, &info->var,
++				info->fix.line_length, dst_xoff, dst_yoff,
++				bp->data,
++				pp->pic_header->width, pp->pic_header->height);
++	}
++}
+diff --git a/include/uapi/linux/bootsplash_file.h b/include/uapi/linux/bootsplash_file.h
+new file mode 100644
+index 000000000000..89dc9cca8f0c
+--- /dev/null
++++ b/include/uapi/linux/bootsplash_file.h
+@@ -0,0 +1,118 @@
++/*
++ * Kernel based bootsplash.
++ *
++ * (File format)
++ *
++ * Authors:
++ * Max Staudt <mstaudt@suse.de>
++ *
++ * SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note
++ */
++
++#ifndef __BOOTSPLASH_FILE_H
++#define __BOOTSPLASH_FILE_H
++
++
++#define BOOTSPLASH_VERSION 55561
++
++
++#include <linux/kernel.h>
++#include <linux/types.h>
++
++
++/*
++ * On-disk types
++ *
++ * A splash file consists of:
++ *  - One single 'struct splash_file_header'
++ *  - An array of 'struct splash_pic_header'
++ *  - An array of raw data blocks, each padded to 16 bytes and
++ *    preceded by a 'struct splash_blob_header'
++ *
++ * A single-frame splash may look like this:
++ *
++ * +--------------------+
++ * |                    |
++ * | splash_file_header |
++ * |  -> num_blobs = 1  |
++ * |  -> num_pics = 1   |
++ * |                    |
++ * +--------------------+
++ * |                    |
++ * | splash_pic_header  |
++ * |                    |
++ * +--------------------+
++ * |                    |
++ * | splash_blob_header |
++ * |  -> type = 0       |
++ * |  -> picture_id = 0 |
++ * |                    |
++ * | (raw RGB data)     |
++ * | (pad to 16 bytes)  |
++ * |                    |
++ * +--------------------+
++ *
++ * All multi-byte values are stored on disk in the native format
++ * expected by the system the file will be used on.
++ */
++#define BOOTSPLASH_MAGIC_BE "Linux bootsplash"
++#define BOOTSPLASH_MAGIC_LE "hsalpstoob xuniL"
++
++struct splash_file_header {
++	uint8_t  id[16]; /* "Linux bootsplash" (no trailing NUL) */
++
++	/* Splash file format version to avoid clashes */
++	uint16_t version;
++
++	/* The background color */
++	uint8_t bg_red;
++	uint8_t bg_green;
++	uint8_t bg_blue;
++	uint8_t bg_reserved;
++
++	/*
++	 * Number of pic/blobs so we can allocate memory for internal
++	 * structures ahead of time when reading the file
++	 */
++	uint16_t num_blobs;
++	uint8_t num_pics;
++
++	uint8_t padding[103];
++} __attribute__((__packed__));
++
++
++struct splash_pic_header {
++	uint16_t width;
++	uint16_t height;
++
++	/*
++	 * Number of data packages associated with this picture.
++	 * Currently, the only use for more than 1 is for animations.
++	 */
++	uint8_t num_blobs;
++
++	uint8_t padding[27];
++} __attribute__((__packed__));
++
++
++struct splash_blob_header {
++	/* Length of the data block in bytes. */
++	uint32_t length;
++
++	/*
++	 * Type of the contents.
++	 *  0 - Raw RGB data.
++	 */
++	uint16_t type;
++
++	/*
++	 * Picture this blob is associated with.
++	 * Blobs will be added to a picture in the order they are
++	 * found in the file.
++	 */
++	uint8_t picture_id;
++
++	uint8_t padding[9];
++} __attribute__((__packed__));
++
++#endif
diff --git a/0503-bootsplash.patch b/0503-bootsplash.patch
new file mode 100644
index 0000000..2169537
--- /dev/null
+++ b/0503-bootsplash.patch
@@ -0,0 +1,66 @@
+diff --git a/drivers/video/fbdev/core/bootsplash.c b/drivers/video/fbdev/core/bootsplash.c
+index 843c5400fefc..815b007f81ca 100644
+--- a/drivers/video/fbdev/core/bootsplash.c
++++ b/drivers/video/fbdev/core/bootsplash.c
+@@ -112,6 +112,8 @@ void bootsplash_render_full(struct fb_info *info)
+ 
+ 	bootsplash_do_render_pictures(info, splash_state.file);
+ 
++	bootsplash_do_render_flush(info);
++
+ out:
+ 	mutex_unlock(&splash_state.data_lock);
+ }
+diff --git a/drivers/video/fbdev/core/bootsplash_internal.h b/drivers/video/fbdev/core/bootsplash_internal.h
+index 71e2a27ac0b8..0acb383aa4e3 100644
+--- a/drivers/video/fbdev/core/bootsplash_internal.h
++++ b/drivers/video/fbdev/core/bootsplash_internal.h
+@@ -89,6 +89,7 @@ void bootsplash_do_render_background(struct fb_info *info,
+ 				     const struct splash_file_priv *fp);
+ void bootsplash_do_render_pictures(struct fb_info *info,
+ 				   const struct splash_file_priv *fp);
++void bootsplash_do_render_flush(struct fb_info *info);
+ 
+ 
+ void bootsplash_free_file(struct splash_file_priv *fp);
+diff --git a/drivers/video/fbdev/core/bootsplash_render.c b/drivers/video/fbdev/core/bootsplash_render.c
+index 2ae36949d0e3..8c09c306ff67 100644
+--- a/drivers/video/fbdev/core/bootsplash_render.c
++++ b/drivers/video/fbdev/core/bootsplash_render.c
+@@ -186,3 +186,36 @@ void bootsplash_do_render_pictures(struct fb_info *info,
+ 				pp->pic_header->width, pp->pic_header->height);
+ 	}
+ }
++
++
++void bootsplash_do_render_flush(struct fb_info *info)
++{
++	/*
++	 * FB drivers using deferred_io (such as Xen) need to sync the
++	 * screen after modifying its contents. When the FB is mmap()ed
++	 * from userspace, this happens via a dirty pages callback, but
++	 * when modifying the FB from the kernel, there is no such thing.
++	 *
++	 * So let's issue a fake fb_copyarea (copying the FB onto itself)
++	 * to trick the FB driver into syncing the screen.
++	 *
++	 * A few DRM drivers' FB implementations are broken by not using
++	 * deferred_io when they really should - we match on the known
++	 * bad ones manually for now.
++	 */
++	if (info->fbdefio
++	    || !strcmp(info->fix.id, "astdrmfb")
++	    || !strcmp(info->fix.id, "cirrusdrmfb")
++	    || !strcmp(info->fix.id, "mgadrmfb")) {
++		struct fb_copyarea area;
++
++		area.dx = 0;
++		area.dy = 0;
++		area.width = info->var.xres;
++		area.height = info->var.yres;
++		area.sx = 0;
++		area.sy = 0;
++
++		info->fbops->fb_copyarea(info, &area);
++	}
++}
diff --git a/0504-bootsplash.patch b/0504-bootsplash.patch
new file mode 100644
index 0000000..7eb54af
--- /dev/null
+++ b/0504-bootsplash.patch
@@ -0,0 +1,215 @@
+diff --git a/drivers/video/fbdev/core/bootsplash_render.c b/drivers/video/fbdev/core/bootsplash_render.c
+index 8c09c306ff67..07e3a4eab811 100644
+--- a/drivers/video/fbdev/core/bootsplash_render.c
++++ b/drivers/video/fbdev/core/bootsplash_render.c
+@@ -155,6 +155,7 @@ void bootsplash_do_render_pictures(struct fb_info *info,
+ 	for (i = 0; i < fp->header->num_pics; i++) {
+ 		struct splash_blob_priv *bp;
+ 		struct splash_pic_priv *pp = &fp->pics[i];
++		const struct splash_pic_header *ph = pp->pic_header;
+ 		long dst_xoff, dst_yoff;
+ 
+ 		if (pp->blobs_loaded < 1)
+@@ -165,8 +166,139 @@ void bootsplash_do_render_pictures(struct fb_info *info,
+ 		if (!bp || bp->blob_header->type != 0)
+ 			continue;
+ 
+-		dst_xoff = (info->var.xres - pp->pic_header->width) / 2;
+-		dst_yoff = (info->var.yres - pp->pic_header->height) / 2;
++		switch (ph->position) {
++		case SPLASH_POS_FLAG_CORNER | SPLASH_CORNER_TOP_LEFT:
++			dst_xoff = 0;
++			dst_yoff = 0;
++
++			dst_xoff += ph->position_offset;
++			dst_yoff += ph->position_offset;
++			break;
++		case SPLASH_POS_FLAG_CORNER | SPLASH_CORNER_TOP:
++			dst_xoff = info->var.xres - pp->pic_header->width;
++			dst_xoff /= 2;
++			dst_yoff = 0;
++
++			dst_yoff += ph->position_offset;
++			break;
++		case SPLASH_POS_FLAG_CORNER | SPLASH_CORNER_TOP_RIGHT:
++			dst_xoff = info->var.xres - pp->pic_header->width;
++			dst_yoff = 0;
++
++			dst_xoff -= ph->position_offset;
++			dst_yoff += ph->position_offset;
++			break;
++		case SPLASH_POS_FLAG_CORNER | SPLASH_CORNER_RIGHT:
++			dst_xoff = info->var.xres - pp->pic_header->width;
++			dst_yoff = info->var.yres - pp->pic_header->height;
++			dst_yoff /= 2;
++
++			dst_xoff -= ph->position_offset;
++			break;
++		case SPLASH_POS_FLAG_CORNER | SPLASH_CORNER_BOTTOM_RIGHT:
++			dst_xoff = info->var.xres - pp->pic_header->width;
++			dst_yoff = info->var.yres - pp->pic_header->height;
++
++			dst_xoff -= ph->position_offset;
++			dst_yoff -= ph->position_offset;
++			break;
++		case SPLASH_POS_FLAG_CORNER | SPLASH_CORNER_BOTTOM:
++			dst_xoff = info->var.xres - pp->pic_header->width;
++			dst_xoff /= 2;
++			dst_yoff = info->var.yres - pp->pic_header->height;
++
++			dst_yoff -= ph->position_offset;
++			break;
++		case SPLASH_POS_FLAG_CORNER | SPLASH_CORNER_BOTTOM_LEFT:
++			dst_xoff = 0 + ph->position_offset;
++			dst_yoff = info->var.yres - pp->pic_header->height
++						  - ph->position_offset;
++			break;
++		case SPLASH_POS_FLAG_CORNER | SPLASH_CORNER_LEFT:
++			dst_xoff = 0;
++			dst_yoff = info->var.yres - pp->pic_header->height;
++			dst_yoff /= 2;
++
++			dst_xoff += ph->position_offset;
++			break;
++
++		case SPLASH_CORNER_TOP_LEFT:
++			dst_xoff = info->var.xres - pp->pic_header->width;
++			dst_xoff /= 2;
++			dst_yoff = info->var.yres - pp->pic_header->height;
++			dst_yoff /= 2;
++
++			dst_xoff -= ph->position_offset;
++			dst_yoff -= ph->position_offset;
++			break;
++		case SPLASH_CORNER_TOP:
++			dst_xoff = info->var.xres - pp->pic_header->width;
++			dst_xoff /= 2;
++			dst_yoff = info->var.yres - pp->pic_header->height;
++			dst_yoff /= 2;
++
++			dst_yoff -= ph->position_offset;
++			break;
++		case SPLASH_CORNER_TOP_RIGHT:
++			dst_xoff = info->var.xres - pp->pic_header->width;
++			dst_xoff /= 2;
++			dst_yoff = info->var.yres - pp->pic_header->height;
++			dst_yoff /= 2;
++
++			dst_xoff += ph->position_offset;
++			dst_yoff -= ph->position_offset;
++			break;
++		case SPLASH_CORNER_RIGHT:
++			dst_xoff = info->var.xres - pp->pic_header->width;
++			dst_xoff /= 2;
++			dst_yoff = info->var.yres - pp->pic_header->height;
++			dst_yoff /= 2;
++
++			dst_xoff += ph->position_offset;
++			break;
++		case SPLASH_CORNER_BOTTOM_RIGHT:
++			dst_xoff = info->var.xres - pp->pic_header->width;
++			dst_xoff /= 2;
++			dst_yoff = info->var.yres - pp->pic_header->height;
++			dst_yoff /= 2;
++
++			dst_xoff += ph->position_offset;
++			dst_yoff += ph->position_offset;
++			break;
++		case SPLASH_CORNER_BOTTOM:
++			dst_xoff = info->var.xres - pp->pic_header->width;
++			dst_xoff /= 2;
++			dst_yoff = info->var.yres - pp->pic_header->height;
++			dst_yoff /= 2;
++
++			dst_yoff += ph->position_offset;
++			break;
++		case SPLASH_CORNER_BOTTOM_LEFT:
++			dst_xoff = info->var.xres - pp->pic_header->width;
++			dst_xoff /= 2;
++			dst_yoff = info->var.yres - pp->pic_header->height;
++			dst_yoff /= 2;
++
++			dst_xoff -= ph->position_offset;
++			dst_yoff += ph->position_offset;
++			break;
++		case SPLASH_CORNER_LEFT:
++			dst_xoff = info->var.xres - pp->pic_header->width;
++			dst_xoff /= 2;
++			dst_yoff = info->var.yres - pp->pic_header->height;
++			dst_yoff /= 2;
++
++			dst_xoff -= ph->position_offset;
++			break;
++
++		default:
++			/* As a fallback, center the picture. */
++			dst_xoff = info->var.xres - pp->pic_header->width;
++			dst_xoff /= 2;
++			dst_yoff = info->var.yres - pp->pic_header->height;
++			dst_yoff /= 2;
++			break;
++		}
+ 
+ 		if (dst_xoff < 0
+ 		    || dst_yoff < 0
+diff --git a/include/uapi/linux/bootsplash_file.h b/include/uapi/linux/bootsplash_file.h
+index 89dc9cca8f0c..71cedcc68933 100644
+--- a/include/uapi/linux/bootsplash_file.h
++++ b/include/uapi/linux/bootsplash_file.h
+@@ -91,7 +91,32 @@ struct splash_pic_header {
+ 	 */
+ 	uint8_t num_blobs;
+ 
+-	uint8_t padding[27];
++	/*
++	 * Corner to move the picture to / from.
++	 *  0x00 - Top left
++	 *  0x01 - Top
++	 *  0x02 - Top right
++	 *  0x03 - Right
++	 *  0x04 - Bottom right
++	 *  0x05 - Bottom
++	 *  0x06 - Bottom left
++	 *  0x07 - Left
++	 *
++	 * Flags:
++	 *  0x10 - Calculate offset from the corner towards the center,
++	 *         rather than from the center towards the corner
++	 */
++	uint8_t position;
++
++	/*
++	 * Pixel offset from the selected position.
++	 * Example: If the picture is in the top right corner, it will
++	 *          be placed position_offset pixels from the top and
++	 *          position_offset pixels from the right margin.
++	 */
++	uint16_t position_offset;
++
++	uint8_t padding[24];
+ } __attribute__((__packed__));
+ 
+ 
+@@ -115,4 +140,22 @@ struct splash_blob_header {
+ 	uint8_t padding[9];
+ } __attribute__((__packed__));
+ 
++
++
++
++/*
++ * Enums for on-disk types
++ */
++enum splash_position {
++	SPLASH_CORNER_TOP_LEFT = 0,
++	SPLASH_CORNER_TOP = 1,
++	SPLASH_CORNER_TOP_RIGHT = 2,
++	SPLASH_CORNER_RIGHT = 3,
++	SPLASH_CORNER_BOTTOM_RIGHT = 4,
++	SPLASH_CORNER_BOTTOM = 5,
++	SPLASH_CORNER_BOTTOM_LEFT = 6,
++	SPLASH_CORNER_LEFT = 7,
++	SPLASH_POS_FLAG_CORNER = 0x10,
++};
++
+ #endif
diff --git a/0505-bootsplash.patch b/0505-bootsplash.patch
new file mode 100644
index 0000000..2785c5e
--- /dev/null
+++ b/0505-bootsplash.patch
@@ -0,0 +1,327 @@
+diff --git a/drivers/video/fbdev/core/bootsplash.c b/drivers/video/fbdev/core/bootsplash.c
+index 815b007f81ca..c8642142cfea 100644
+--- a/drivers/video/fbdev/core/bootsplash.c
++++ b/drivers/video/fbdev/core/bootsplash.c
+@@ -53,6 +53,14 @@ static void splash_callback_redraw_vc(struct work_struct *ignored)
+ 	console_unlock();
+ }
+ 
++static void splash_callback_animation(struct work_struct *ignored)
++{
++	if (bootsplash_would_render_now()) {
++		/* This will also re-schedule this delayed worker */
++		splash_callback_redraw_vc(ignored);
++	}
++}
++
+ 
+ static bool is_fb_compatible(const struct fb_info *info)
+ {
+@@ -103,17 +111,44 @@ static bool is_fb_compatible(const struct fb_info *info)
+  */
+ void bootsplash_render_full(struct fb_info *info)
+ {
++	bool is_update = false;
++
+ 	mutex_lock(&splash_state.data_lock);
+ 
+-	if (!is_fb_compatible(info))
+-		goto out;
++	/*
++	 * If we've painted on this FB recently, we don't have to do
++	 * the sanity checks and background drawing again.
++	 */
++	if (splash_state.splash_fb == info)
++		is_update = true;
++
++
++	if (!is_update) {
++		/* Check whether we actually support this FB. */
++		splash_state.splash_fb = NULL;
++
++		if (!is_fb_compatible(info))
++			goto out;
++
++		/* Draw the background only once */
++		bootsplash_do_render_background(info, splash_state.file);
+ 
+-	bootsplash_do_render_background(info, splash_state.file);
++		/* Mark this FB as last seen */
++		splash_state.splash_fb = info;
++	}
+ 
+-	bootsplash_do_render_pictures(info, splash_state.file);
++	bootsplash_do_render_pictures(info, splash_state.file, is_update);
+ 
+ 	bootsplash_do_render_flush(info);
+ 
++	bootsplash_do_step_animations(splash_state.file);
++
++	/* Schedule update for animated splash screens */
++	if (splash_state.file->frame_ms > 0)
++		schedule_delayed_work(&splash_state.dwork_animation,
++				      msecs_to_jiffies(
++				      splash_state.file->frame_ms));
++
+ out:
+ 	mutex_unlock(&splash_state.data_lock);
+ }
+@@ -169,8 +204,14 @@ void bootsplash_enable(void)
+ 
+ 	was_enabled = test_and_set_bit(0, &splash_state.enabled);
+ 
+-	if (!was_enabled)
++	if (!was_enabled) {
++		/* Force a full redraw when the splash is re-activated */
++		mutex_lock(&splash_state.data_lock);
++		splash_state.splash_fb = NULL;
++		mutex_unlock(&splash_state.data_lock);
++
+ 		schedule_work(&splash_state.work_redraw_vc);
++	}
+ }
+ 
+ 
+@@ -227,6 +268,14 @@ ATTRIBUTE_GROUPS(splash_dev);
+  */
+ static int splash_resume(struct device *device)
+ {
++	/*
++	 * Force full redraw on resume since we've probably lost the
++	 * framebuffer's contents meanwhile
++	 */
++	mutex_lock(&splash_state.data_lock);
++	splash_state.splash_fb = NULL;
++	mutex_unlock(&splash_state.data_lock);
++
+ 	if (bootsplash_would_render_now())
+ 		schedule_work(&splash_state.work_redraw_vc);
+ 
+@@ -235,6 +284,7 @@ static int splash_resume(struct device *device)
+ 
+ static int splash_suspend(struct device *device)
+ {
++	cancel_delayed_work_sync(&splash_state.dwork_animation);
+ 	cancel_work_sync(&splash_state.work_redraw_vc);
+ 
+ 	return 0;
+@@ -296,6 +346,8 @@ void bootsplash_init(void)
+ 	set_bit(0, &splash_state.enabled);
+ 
+ 	INIT_WORK(&splash_state.work_redraw_vc, splash_callback_redraw_vc);
++	INIT_DELAYED_WORK(&splash_state.dwork_animation,
++			  splash_callback_animation);
+ 
+ 
+ 	if (!splash_state.bootfile || !strlen(splash_state.bootfile))
+diff --git a/drivers/video/fbdev/core/bootsplash_internal.h b/drivers/video/fbdev/core/bootsplash_internal.h
+index 0acb383aa4e3..b3a74835d90f 100644
+--- a/drivers/video/fbdev/core/bootsplash_internal.h
++++ b/drivers/video/fbdev/core/bootsplash_internal.h
+@@ -37,6 +37,8 @@ struct splash_pic_priv {
+ 
+ 	struct splash_blob_priv *blobs;
+ 	u16 blobs_loaded;
++
++	u16 anim_nextframe;
+ };
+ 
+ 
+@@ -45,6 +47,12 @@ struct splash_file_priv {
+ 	const struct splash_file_header *header;
+ 
+ 	struct splash_pic_priv *pics;
++
++	/*
++	 * A local copy of the frame delay in the header.
++	 * We modify it to keep the code simple.
++	 */
++	u16 frame_ms;
+ };
+ 
+ 
+@@ -71,6 +79,7 @@ struct splash_priv {
+ 	struct platform_device *splash_device;
+ 
+ 	struct work_struct work_redraw_vc;
++	struct delayed_work dwork_animation;
+ 
+ 	/* Splash data structures including lock for everything below */
+ 	struct mutex data_lock;
+@@ -88,8 +97,10 @@ struct splash_priv {
+ void bootsplash_do_render_background(struct fb_info *info,
+ 				     const struct splash_file_priv *fp);
+ void bootsplash_do_render_pictures(struct fb_info *info,
+-				   const struct splash_file_priv *fp);
++				   const struct splash_file_priv *fp,
++				   bool is_update);
+ void bootsplash_do_render_flush(struct fb_info *info);
++void bootsplash_do_step_animations(struct splash_file_priv *fp);
+ 
+ 
+ void bootsplash_free_file(struct splash_file_priv *fp);
+diff --git a/drivers/video/fbdev/core/bootsplash_load.c b/drivers/video/fbdev/core/bootsplash_load.c
+index fd807571ab7d..1f661b2d4cc9 100644
+--- a/drivers/video/fbdev/core/bootsplash_load.c
++++ b/drivers/video/fbdev/core/bootsplash_load.c
+@@ -71,6 +71,7 @@ struct splash_file_priv *bootsplash_load_firmware(struct device *device,
+ {
+ 	const struct firmware *fw;
+ 	struct splash_file_priv *fp;
++	bool have_anim = false;
+ 	unsigned int i;
+ 	const u8 *walker;
+ 
+@@ -135,6 +136,13 @@ struct splash_file_priv *bootsplash_load_firmware(struct device *device,
+ 			goto err;
+ 		}
+ 
++		if (ph->anim_type > SPLASH_ANIM_LOOP_FORWARD) {
++			pr_warn("Picture %u: Unsupported animation type %u.\n",
++				i, ph->anim_type);
++
++			ph->anim_type = SPLASH_ANIM_NONE;
++		}
++
+ 		pp->pic_header = ph;
+ 		pp->blobs = vzalloc(ph->num_blobs
+ 					* sizeof(struct splash_blob_priv));
+@@ -202,6 +210,7 @@ struct splash_file_priv *bootsplash_load_firmware(struct device *device,
+ 	/* Walk over pictures and ensure all blob slots are filled */
+ 	for (i = 0; i < fp->header->num_pics; i++) {
+ 		struct splash_pic_priv *pp = &fp->pics[i];
++		const struct splash_pic_header *ph = pp->pic_header;
+ 
+ 		if (pp->blobs_loaded != pp->pic_header->num_blobs) {
+ 			pr_err("Picture %u doesn't have all blob slots filled.\n",
+@@ -209,8 +218,20 @@ struct splash_file_priv *bootsplash_load_firmware(struct device *device,
+ 
+ 			goto err;
+ 		}
++
++		if (ph->anim_type
++		    && ph->num_blobs > 1
++		    && ph->anim_loop < pp->blobs_loaded)
++			have_anim = true;
+ 	}
+ 
++	if (!have_anim)
++		/* Disable animation timer if there is nothing to animate */
++		fp->frame_ms = 0;
++	else
++		/* Enforce minimum delay between frames */
++		fp->frame_ms = max((u16)20, fp->header->frame_ms);
++
+ 	pr_info("Loaded (%ld bytes, %u pics, %u blobs).\n",
+ 		fw->size,
+ 		fp->header->num_pics,
+diff --git a/drivers/video/fbdev/core/bootsplash_render.c b/drivers/video/fbdev/core/bootsplash_render.c
+index 07e3a4eab811..76033606ca8a 100644
+--- a/drivers/video/fbdev/core/bootsplash_render.c
++++ b/drivers/video/fbdev/core/bootsplash_render.c
+@@ -148,7 +148,8 @@ void bootsplash_do_render_background(struct fb_info *info,
+ 
+ 
+ void bootsplash_do_render_pictures(struct fb_info *info,
+-				   const struct splash_file_priv *fp)
++				   const struct splash_file_priv *fp,
++				   bool is_update)
+ {
+ 	unsigned int i;
+ 
+@@ -161,7 +162,11 @@ void bootsplash_do_render_pictures(struct fb_info *info,
+ 		if (pp->blobs_loaded < 1)
+ 			continue;
+ 
+-		bp = &pp->blobs[0];
++		/* Skip static pictures when refreshing animations */
++		if (ph->anim_type == SPLASH_ANIM_NONE && is_update)
++			continue;
++
++		bp = &pp->blobs[pp->anim_nextframe];
+ 
+ 		if (!bp || bp->blob_header->type != 0)
+ 			continue;
+@@ -351,3 +356,24 @@ void bootsplash_do_render_flush(struct fb_info *info)
+ 		info->fbops->fb_copyarea(info, &area);
+ 	}
+ }
++
++
++void bootsplash_do_step_animations(struct splash_file_priv *fp)
++{
++	unsigned int i;
++
++	/* Step every animation once */
++	for (i = 0; i < fp->header->num_pics; i++) {
++		struct splash_pic_priv *pp = &fp->pics[i];
++
++		if (pp->blobs_loaded < 2
++		    || pp->pic_header->anim_loop > pp->blobs_loaded)
++			continue;
++
++		if (pp->pic_header->anim_type == SPLASH_ANIM_LOOP_FORWARD) {
++			pp->anim_nextframe++;
++			if (pp->anim_nextframe >= pp->pic_header->num_blobs)
++				pp->anim_nextframe = pp->pic_header->anim_loop;
++		}
++	}
++}
+diff --git a/include/uapi/linux/bootsplash_file.h b/include/uapi/linux/bootsplash_file.h
+index 71cedcc68933..b3af0a3c6487 100644
+--- a/include/uapi/linux/bootsplash_file.h
++++ b/include/uapi/linux/bootsplash_file.h
+@@ -77,7 +77,17 @@ struct splash_file_header {
+ 	uint16_t num_blobs;
+ 	uint8_t num_pics;
+ 
+-	uint8_t padding[103];
++	uint8_t unused_1;
++
++	/*
++	 * Milliseconds to wait before painting the next frame in
++	 * an animation.
++	 * This is actually a minimum, as the system is allowed to
++	 * stall for longer between frames.
++	 */
++	uint16_t frame_ms;
++
++	uint8_t padding[100];
+ } __attribute__((__packed__));
+ 
+ 
+@@ -116,7 +126,23 @@ struct splash_pic_header {
+ 	 */
+ 	uint16_t position_offset;
+ 
+-	uint8_t padding[24];
++	/*
++	 * Animation type.
++	 *  0 - off
++	 *  1 - forward loop
++	 */
++	uint8_t anim_type;
++
++	/*
++	 * Animation loop point.
++	 * Actual meaning depends on animation type:
++	 * Type 0 - Unused
++	 *      1 - Frame at which to restart the forward loop
++	 *          (allowing for "intro" frames)
++	 */
++	uint8_t anim_loop;
++
++	uint8_t padding[22];
+ } __attribute__((__packed__));
+ 
+ 
+@@ -158,4 +184,9 @@ enum splash_position {
+ 	SPLASH_POS_FLAG_CORNER = 0x10,
+ };
+ 
++enum splash_anim_type {
++	SPLASH_ANIM_NONE = 0,
++	SPLASH_ANIM_LOOP_FORWARD = 1,
++};
++
+ #endif
diff --git a/0506-bootsplash.patch b/0506-bootsplash.patch
new file mode 100644
index 0000000..d6c6db6
--- /dev/null
+++ b/0506-bootsplash.patch
@@ -0,0 +1,82 @@
+diff --git a/drivers/tty/vt/vt.c b/drivers/tty/vt/vt.c
+index 2ebaba16f785..416735ab6dc1 100644
+--- a/drivers/tty/vt/vt.c
++++ b/drivers/tty/vt/vt.c
+@@ -105,6 +105,7 @@
+ #include <linux/ctype.h>
+ #include <linux/bsearch.h>
+ #include <linux/gcd.h>
++#include <linux/bootsplash.h>
+ 
+ #define MAX_NR_CON_DRIVER 16
+ 
+@@ -4235,6 +4236,7 @@ void do_unblank_screen(int leaving_gfx)
+ 	}
+ 
+ 	console_blanked = 0;
++	bootsplash_mark_dirty();
+ 	if (vc->vc_sw->con_blank(vc, 0, leaving_gfx))
+ 		/* Low-level driver cannot restore -> do it ourselves */
+ 		update_screen(vc);
+diff --git a/drivers/video/fbdev/core/bootsplash.c b/drivers/video/fbdev/core/bootsplash.c
+index c8642142cfea..13fcaabbc2ca 100644
+--- a/drivers/video/fbdev/core/bootsplash.c
++++ b/drivers/video/fbdev/core/bootsplash.c
+@@ -165,6 +165,13 @@ bool bootsplash_would_render_now(void)
+ 		&& bootsplash_is_enabled();
+ }
+ 
++void bootsplash_mark_dirty(void)
++{
++	mutex_lock(&splash_state.data_lock);
++	splash_state.splash_fb = NULL;
++	mutex_unlock(&splash_state.data_lock);
++}
++
+ bool bootsplash_is_enabled(void)
+ {
+ 	bool was_enabled;
+@@ -206,9 +213,7 @@ void bootsplash_enable(void)
+ 
+ 	if (!was_enabled) {
+ 		/* Force a full redraw when the splash is re-activated */
+-		mutex_lock(&splash_state.data_lock);
+-		splash_state.splash_fb = NULL;
+-		mutex_unlock(&splash_state.data_lock);
++		bootsplash_mark_dirty();
+ 
+ 		schedule_work(&splash_state.work_redraw_vc);
+ 	}
+@@ -272,9 +277,7 @@ static int splash_resume(struct device *device)
+ 	 * Force full redraw on resume since we've probably lost the
+ 	 * framebuffer's contents meanwhile
+ 	 */
+-	mutex_lock(&splash_state.data_lock);
+-	splash_state.splash_fb = NULL;
+-	mutex_unlock(&splash_state.data_lock);
++	bootsplash_mark_dirty();
+ 
+ 	if (bootsplash_would_render_now())
+ 		schedule_work(&splash_state.work_redraw_vc);
+diff --git a/include/linux/bootsplash.h b/include/linux/bootsplash.h
+index c6dd0b43180d..4075098aaadd 100644
+--- a/include/linux/bootsplash.h
++++ b/include/linux/bootsplash.h
+@@ -19,6 +19,8 @@ extern void bootsplash_render_full(struct fb_info *info);
+ 
+ extern bool bootsplash_would_render_now(void);
+ 
++extern void bootsplash_mark_dirty(void);
++
+ extern bool bootsplash_is_enabled(void);
+ extern void bootsplash_disable(void);
+ extern void bootsplash_enable(void);
+@@ -31,6 +33,8 @@ extern void bootsplash_init(void);
+ 
+ #define bootsplash_would_render_now() (false)
+ 
++#define bootsplash_mark_dirty()
++
+ #define bootsplash_is_enabled() (false)
+ #define bootsplash_disable()
+ #define bootsplash_enable()
diff --git a/0507-bootsplash.patch b/0507-bootsplash.patch
new file mode 100644
index 0000000..e8cd479
--- /dev/null
+++ b/0507-bootsplash.patch
@@ -0,0 +1,42 @@
+diff --git a/drivers/tty/vt/keyboard.c b/drivers/tty/vt/keyboard.c
+index f4166263bb3a..a248429194bb 100644
+--- a/drivers/tty/vt/keyboard.c
++++ b/drivers/tty/vt/keyboard.c
+@@ -47,6 +47,8 @@
+ 
+ #include <asm/irq_regs.h>
+ 
++#include <linux/bootsplash.h>
++
+ extern void ctrl_alt_del(void);
+ 
+ /*
+@@ -1353,6 +1355,28 @@ static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
+ 	}
+ #endif
+ 
++	/* Trap keys when bootsplash is shown */
++	if (bootsplash_would_render_now()) {
++		/* Deactivate bootsplash on ESC or Alt+Fxx VT switch */
++		if (keycode >= KEY_F1 && keycode <= KEY_F12) {
++			bootsplash_disable();
++
++			/*
++			 * No return here since we want to actually
++			 * perform the VT switch.
++			 */
++		} else {
++			if (keycode == KEY_ESC)
++				bootsplash_disable();
++
++			/*
++			 * Just drop any other keys.
++			 * Their effect would be hidden by the splash.
++			 */
++			return;
++		}
++	}
++
+ 	if (kbd->kbdmode == VC_MEDIUMRAW) {
+ 		/*
+ 		 * This is extended medium raw mode, with keys above 127
diff --git a/0508-bootsplash.patch b/0508-bootsplash.patch
new file mode 100644
index 0000000..09bd4c3
--- /dev/null
+++ b/0508-bootsplash.patch
@@ -0,0 +1,19 @@
+diff -up linux-5.10/drivers/tty/sysrq.c.66~ linux-5.10/drivers/tty/sysrq.c
+--- linux-5.10/drivers/tty/sysrq.c.66~	2020-12-13 23:41:30.000000000 +0100
++++ linux-5.10/drivers/tty/sysrq.c	2021-01-19 23:09:45.408605180 +0100
+@@ -51,6 +51,7 @@
+ #include <linux/syscalls.h>
+ #include <linux/of.h>
+ #include <linux/rcupdate.h>
++#include <linux/bootsplash.h>
+ 
+ #include <asm/ptrace.h>
+ #include <asm/irq_regs.h>
+@@ -119,6 +120,7 @@ static void sysrq_handle_SAK(int key)
+ {
+ 	struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
+ 	schedule_work(SAK_work);
++	bootsplash_disable();
+ }
+ static const struct sysrq_key_op sysrq_SAK_op = {
+ 	.handler	= sysrq_handle_SAK,
diff --git a/0509-bootsplash.patch b/0509-bootsplash.patch
new file mode 100644
index 0000000..add68e7
--- /dev/null
+++ b/0509-bootsplash.patch
@@ -0,0 +1,21 @@
+diff --git a/drivers/video/fbdev/core/fbcon.c b/drivers/video/fbdev/core/fbcon.c
+index 9a39a6fcfe98..8a9c67e1c5d8 100644
+--- a/drivers/video/fbdev/core/fbcon.c
++++ b/drivers/video/fbdev/core/fbcon.c
+@@ -1343,6 +1343,16 @@ static void fbcon_cursor(struct vc_data *vc, int mode)
+ 	int y;
+  	int c = scr_readw((u16 *) vc->vc_pos);
+ 
++	/*
++	 * Disable the splash here so we don't have to hook into
++	 * vt_console_print() in drivers/tty/vt/vt.c
++	 *
++	 * We'd disable the splash just before the call to
++	 * hide_cursor() anyway, so this spot is just fine.
++	 */
++	if (oops_in_progress)
++		bootsplash_disable();
++
+ 	ops->cur_blink_jiffies = msecs_to_jiffies(vc->vc_cur_blink_ms);
+ 
+ 	if (fbcon_is_inactive(vc, info) || vc->vc_deccm != 1)
diff --git a/0510-bootsplash.patch b/0510-bootsplash.patch
new file mode 100644
index 0000000..c74b4da
--- /dev/null
+++ b/0510-bootsplash.patch
@@ -0,0 +1,308 @@
+diff --git a/Documentation/ABI/testing/sysfs-platform-bootsplash b/Documentation/ABI/testing/sysfs-platform-bootsplash
+new file mode 100644
+index 000000000000..742c7b035ded
+--- /dev/null
++++ b/Documentation/ABI/testing/sysfs-platform-bootsplash
+@@ -0,0 +1,11 @@
++What:		/sys/devices/platform/bootsplash.0/enabled
++Date:		Oct 2017
++KernelVersion:	4.14
++Contact:	Max Staudt <mstaudt@suse.de>
++Description:
++		Can be set and read.
++
++		0: Splash is disabled.
++		1: Splash is shown whenever fbcon would show a text console
++		   (i.e. no graphical application is running), and a splash
++		   file is loaded.
+diff --git a/Documentation/bootsplash.rst b/Documentation/bootsplash.rst
+new file mode 100644
+index 000000000000..611f0c558925
+--- /dev/null
++++ b/Documentation/bootsplash.rst
+@@ -0,0 +1,285 @@
++====================
++The Linux bootsplash
++====================
++
++:Date: November, 2017
++:Author: Max Staudt <mstaudt@suse.de>
++
++
++The Linux bootsplash is a graphical replacement for the '``quiet``' boot
++option, typically showing a logo and a spinner animation as the system starts.
++
++Currently, it is a part of the Framebuffer Console support, and can be found
++as ``CONFIG_BOOTSPLASH`` in the kernel configuration. This means that as long
++as it is enabled, it hijacks fbcon's output and draws a splash screen instead.
++
++Purely compiling in the bootsplash will not render it functional - to actually
++render a splash, you will also need a splash theme file. See the example
++utility and script in ``tools/bootsplash`` for a live demo.
++
++
++
++Motivation
++==========
++
++- The '``quiet``' boot option only suppresses most messages during boot, but
++  errors are still shown.
++
++- A user space implementation can only show a logo once user space has been
++  initialized far enough to allow this. A kernel splash can display a splash
++  immediately as soon as fbcon can be displayed.
++
++- Implementing a splash screen in user space (e.g. Plymouth) is problematic
++  due to resource conflicts.
++
++  For example, if Plymouth is keeping ``/dev/fb0`` (provided via vesafb/efifb)
++  open, then most DRM drivers can't replace it because the address space is
++  still busy - thus leading to a VRAM reservation error.
++
++  See: https://bugzilla.opensuse.org/show_bug.cgi?id=980750
++
++
++
++Command line arguments
++======================
++
++``bootsplash.bootfile``
++  Which file in the initramfs to load.
++
++  The splash theme is loaded via request_firmware(), thus to load
++  ``/lib/firmware/bootsplash/mytheme`` pass the command line:
++
++  ``bootsplash.bootfile=bootsplash/mytheme``
++
++  Note: The splash file *has to be* in the initramfs, as it needs to be
++  available when the splash is initialized early on.
++
++  Default: none, i.e. a non-functional splash, falling back to showing text.
++
++
++
++sysfs run-time configuration
++============================
++
++``/sys/devices/platform/bootsplash.0/enabled``
++  Enable/disable the bootsplash.
++  The system boots with this set to 1, but will not show a splash unless
++  a splash theme file is also loaded.
++
++
++
++Kconfig
++=======
++
++``BOOTSPLASH``
++  Whether to compile in bootsplash support
++  (depends on fbcon compiled in, i.e. ``FRAMEBUFFER_CONSOLE=y``)
++
++
++
++Bootsplash file format
++======================
++
++A file specified in the kernel configuration as ``CONFIG_BOOTSPLASH_FILE``
++or specified on the command line as ``bootsplash.bootfile`` will be loaded
++and displayed as soon as fbcon is initialized.
++
++
++Main blocks
++-----------
++
++There are 3 main blocks in each file:
++
++  - one File header
++  -   n Picture headers
++  -   m (Blob header + payload) blocks
++
++
++Structures
++----------
++
++The on-disk structures are defined in
++``drivers/video/fbdev/core/bootsplash_file.h`` and represent these blocks:
++
++  - ``struct splash_file_header``
++
++    Represents the file header, with splash-wide information including:
++
++      - The magic string "``Linux bootsplash``" on big-endian platforms
++        (the reverse on little endian)
++      - The file format version (for incompatible updates, hopefully never)
++      - The background color
++      - Number of picture and blob blocks
++      - Animation speed (we only allow one delay for all animations)
++
++    The file header is followed by the first picture header.
++
++
++  - ``struct splash_picture_header``
++
++    Represents an object (picture) drawn on screen, including its immutable
++    properties:
++      - Width, height
++      - Positioning relative to screen corners or in the center
++      - Animation, if any
++      - Animation type
++      - Number of blobs
++
++    The picture header is followed by another picture header, up until n
++    picture headers (as defined in the file header) have been read. Then,
++    the (blob header, payload) pairs follow.
++
++
++  - ``struct splash_blob_header``
++    (followed by payload)
++
++    Represents one raw data stream. So far, only picture data is defined.
++
++    The blob header is followed by a payload, then padding to n*16 bytes,
++    then (if further blobs are defined in the file header) a further blob
++    header.
++
++
++Alignment
++---------
++
++The bootsplash file is designed to be loaded into memory as-is.
++
++All structures are a multiple of 16 bytes long, all elements therein are
++aligned to multiples of their length, and the payloads are always padded
++up to multiples of 16 bytes. This is to allow aligned accesses in all
++cases while still simply mapping the structures over an in-memory copy of
++the bootsplash file.
++
++
++Further information
++-------------------
++
++Please see ``drivers/video/fbdev/core/bootsplash_file.h`` for further
++details and possible values in the file.
++
++
++
++Hooks - how the bootsplash is integrated
++========================================
++
++``drivers/video/fbdev/core/fbcon.c``
++  ``fbcon_init()`` calls ``bootsplash_init()``, which loads the default
++  bootsplash file or the one specified on the kernel command line.
++
++  ``fbcon_switch()`` draws the bootsplash when it's active, and is also
++  one of the callers of ``set_blitting_type()``.
++
++  ``set_blitting_type()`` calls ``fbcon_set_dummyops()`` when the
++  bootsplash is active, overriding the text rendering functions.
++
++  ``fbcon_cursor()`` will call ``bootsplash_disable()`` when an oops is
++  being printed in order to make a kernel panic visible.
++
++``drivers/video/fbdev/core/dummyblit.c``
++  This contains the dummy text rendering functions used to suppress text
++  output while the bootsplash is shown.
++
++``drivers/tty/vt/keyboard.c``
++  ``kbd_keycode()`` can call ``bootsplash_disable()`` when the user
++  presses ESC or F1-F12 (changing VT). This is to provide a built-in way
++  of disabling the splash manually at any time.
++
++
++
++FAQ: Frequently Asked Questions
++===============================
++
++I want to see the log! How do I show the log?
++---------------------------------------------
++
++Press ESC while the splash is shown, or remove the ``bootsplash.bootfile``
++parameter from the kernel cmdline. Without that parameter, the bootsplash
++will boot disabled.
++
++
++Why use FB instead of modern DRM/KMS?
++-------------------------------------
++
++This is a semantic problem:
++ - What memory to draw the splash to?
++ - And what mode will the screen be set to?
++
++Using the fbdev emulation solves these issues.
++
++Let's start from a bare KMS system, without fbcon, and without fbdev
++emulation. In this case, as long as userspace doesn't open the KMS
++device, the state of the screen is undefined. No framebuffer is
++allocated in video RAM, and no particular mode is set.
++
++In this case, we'd have to allocate a framebuffer to show the splash,
++and set our mode ourselves. This either wastes a screenful of video RAM
++if the splash is to co-exist with the userspace program's own allocated
++framebuffer, or there is a flicker as we deactivate and delete the
++bootsplash's framebuffer and hand control over to userspace. Since we
++may set a different mode than userspace, we'd also have flicker due
++to mode switching.
++
++This logic is already contained in every KMS driver that performs fbdev
++emulation. So we might as well use that. And the correct API to do so is
++fbdev. Plus, we get compatibility with old, pure fbdev drivers for free.
++With the fbdev emulation, there is *always* a well-defined framebuffer
++to draw on. And the selection of mode has already been done by the
++graphics driver, so we don't need to reinvent that wheel, either.
++Finally, if userspace decides to use /dev/fbX, we don't have to worry
++about wasting video RAM, either.
++
++
++Why is the bootsplash integrated in fbcon?
++------------------------------------------
++
++Right now, the bootsplash is drawn from within fbcon, as this allows us
++to easily know *when* to draw - i.e. when we're safe from fbcon and
++userspace drawing all over our beautiful splash logo.
++
++Separating them is not easy - see the to-do list below.
++
++
++
++TO DO list for future development
++=================================
++
++Second enable/disable switch for the system
++-------------------------------------------
++
++It may be helpful to differentiate between the system and the user
++switching off the bootsplash. Thus, the system may make it disappear and
++reappear e.g. for a password prompt, yet once the user has pressed ESC,
++it could stay gone.
++
++
++Fix buggy DRM/KMS drivers
++-------------------------
++
++Currently, the splash code manually checks for fbdev emulation provided by
++the ast, cirrus, and mgag200 DRM/KMS drivers.
++These drivers use a manual mechanism similar to deferred I/O for their FB
++emulation, and thus need to be manually flushed onto the screen in the same
++way.
++
++This may be improved upon in several ways:
++
++1. Changing these drivers to expose the fbdev BO's memory directly, like
++   bochsdrmfb does.
++2. Creating a new fb_ops->fb_flush() API to allow the kernel to flush the
++   framebuffer once the bootsplash has been drawn into it.
++
++
++Separating from fbcon
++---------------------
++
++Separating these two components would yield independence from fbcon being
++compiled into the kernel, and thus lowering code size in embedded
++applications.
++
++To do this cleanly will involve a clean separation of users of an FB device
++within the kernel, i.e. fbcon, bootsplash, and userspace. Right now, the
++legacy fbcon code and VT code co-operate to switch between fbcon and
++userspace (by setting the VT into KD_GRAPHICS mode). Installing a muxer
++between these components ensues refactoring of old code and checking for
++correct locking.
diff --git a/0511-bootsplash.patch b/0511-bootsplash.patch
new file mode 100644
index 0000000..8e87eb4
--- /dev/null
+++ b/0511-bootsplash.patch
@@ -0,0 +1,129 @@
+diff --git a/Documentation/ABI/testing/sysfs-platform-bootsplash b/Documentation/ABI/testing/sysfs-platform-bootsplash
+index 742c7b035ded..f8f4b259220e 100644
+--- a/Documentation/ABI/testing/sysfs-platform-bootsplash
++++ b/Documentation/ABI/testing/sysfs-platform-bootsplash
+@@ -9,3 +9,35 @@ Description:
+ 		1: Splash is shown whenever fbcon would show a text console
+ 		   (i.e. no graphical application is running), and a splash
+ 		   file is loaded.
++
++What:		/sys/devices/platform/bootsplash.0/drop_splash
++Date:		Oct 2017
++KernelVersion:	4.14
++Contact:	Max Staudt <mstaudt@suse.de>
++Description:
++		Can only be set.
++
++		Any value written will cause the current splash theme file
++		to be unloaded and the text console to be redrawn.
++
++What:		/sys/devices/platform/bootsplash.0/load_file
++Date:		Oct 2017
++KernelVersion:	4.14
++Contact:	Max Staudt <mstaudt@suse.de>
++Description:
++		Can only be set.
++
++		Any value written will cause the splash to be disabled and
++		internal memory structures to be freed.
++
++		A firmware path written will cause a new theme file to be
++		loaded and the current bootsplash to be replaced.
++		The current enabled/disabled status is not touched.
++		If the splash is already active, it will be redrawn.
++
++		The path has to be a path in /lib/firmware since
++		request_firmware() is used to fetch the data.
++
++		When setting the splash from the shell, echo -n has to be
++		used as any trailing '\n' newline will be interpreted as
++		part of the path.
+diff --git a/Documentation/bootsplash.rst b/Documentation/bootsplash.rst
+index 611f0c558925..b35aba5093e8 100644
+--- a/Documentation/bootsplash.rst
++++ b/Documentation/bootsplash.rst
+@@ -67,6 +67,14 @@ sysfs run-time configuration
+   a splash theme file is also loaded.
+ 
+ 
++``/sys/devices/platform/bootsplash.0/drop_splash``
++  Unload splash data and free memory.
++
++``/sys/devices/platform/bootsplash.0/load_file``
++  Load a splash file from ``/lib/firmware/``.
++  Note that trailing newlines will be interpreted as part of the file name.
++
++
+ 
+ Kconfig
+ =======
+diff --git a/drivers/video/fbdev/core/bootsplash.c b/drivers/video/fbdev/core/bootsplash.c
+index 13fcaabbc2ca..16cb0493629d 100644
+--- a/drivers/video/fbdev/core/bootsplash.c
++++ b/drivers/video/fbdev/core/bootsplash.c
+@@ -251,11 +251,65 @@ static ssize_t splash_store_enabled(struct device *device,
+ 	return count;
+ }
+ 
++static ssize_t splash_store_drop_splash(struct device *device,
++					struct device_attribute *attr,
++					const char *buf, size_t count)
++{
++	struct splash_file_priv *fp;
++
++	if (!buf || !count || !splash_state.file)
++		return count;
++
++	mutex_lock(&splash_state.data_lock);
++	fp = splash_state.file;
++	splash_state.file = NULL;
++	mutex_unlock(&splash_state.data_lock);
++
++	/* Redraw the text console */
++	schedule_work(&splash_state.work_redraw_vc);
++
++	bootsplash_free_file(fp);
++
++	return count;
++}
++
++static ssize_t splash_store_load_file(struct device *device,
++				      struct device_attribute *attr,
++				      const char *buf, size_t count)
++{
++	struct splash_file_priv *fp, *fp_old;
++
++	if (!count)
++		return 0;
++
++	fp = bootsplash_load_firmware(&splash_state.splash_device->dev,
++				      buf);
++
++	if (!fp)
++		return -ENXIO;
++
++	mutex_lock(&splash_state.data_lock);
++	fp_old = splash_state.file;
++	splash_state.splash_fb = NULL;
++	splash_state.file = fp;
++	mutex_unlock(&splash_state.data_lock);
++
++	/* Update the splash or text console */
++	schedule_work(&splash_state.work_redraw_vc);
++
++	bootsplash_free_file(fp_old);
++	return count;
++}
++
+ static DEVICE_ATTR(enabled, 0644, splash_show_enabled, splash_store_enabled);
++static DEVICE_ATTR(drop_splash, 0200, NULL, splash_store_drop_splash);
++static DEVICE_ATTR(load_file, 0200, NULL, splash_store_load_file);
+ 
+ 
+ static struct attribute *splash_dev_attrs[] = {
+ 	&dev_attr_enabled.attr,
++	&dev_attr_drop_splash.attr,
++	&dev_attr_load_file.attr,
+ 	NULL
+ };
+ 
diff --git a/0512-bootsplash.patch b/0512-bootsplash.patch
new file mode 100644
index 0000000..4e0c98f
--- /dev/null
+++ b/0512-bootsplash.patch
@@ -0,0 +1,499 @@
+diff --git a/tools/bootsplash/.gitignore b/tools/bootsplash/.gitignore
+new file mode 100644
+index 000000000000..091b99a17567
+--- /dev/null
++++ b/tools/bootsplash/.gitignore
+@@ -0,0 +1 @@
++bootsplash-packer
+diff --git a/tools/bootsplash/Makefile b/tools/bootsplash/Makefile
+new file mode 100644
+index 000000000000..0ad8e8a84942
+--- /dev/null
++++ b/tools/bootsplash/Makefile
+@@ -0,0 +1,9 @@
++CC := $(CROSS_COMPILE)gcc
++CFLAGS := -I../../usr/include
++
++PROGS := bootsplash-packer
++
++all: $(PROGS)
++
++clean:
++	rm -fr $(PROGS)
+diff --git a/tools/bootsplash/bootsplash-packer.c b/tools/bootsplash/bootsplash-packer.c
+new file mode 100644
+index 000000000000..ffb6a8b69885
+--- /dev/null
++++ b/tools/bootsplash/bootsplash-packer.c
+@@ -0,0 +1,471 @@
++/*
++ * Kernel based bootsplash.
++ *
++ * (Splash file packer tool)
++ *
++ * Authors:
++ * Max Staudt <mstaudt@suse.de>
++ *
++ * SPDX-License-Identifier: GPL-2.0
++ */
++
++#include <endian.h>
++#include <getopt.h>
++#include <stdint.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++
++#include <linux/bootsplash_file.h>
++
++
++static void print_help(char *progname)
++{
++	printf("Usage: %s [OPTIONS] outfile\n", progname);
++	printf("\n"
++	       "Options, executed in order given:\n"
++	       "  -h, --help                   Print this help message\n"
++	       "\n"
++	       "  --bg_red <u8>                Background color (red part)\n"
++	       "  --bg_green <u8>              Background color (green part)\n"
++	       "  --bg_blue <u8>               Background color (blue part)\n"
++	       "  --bg_reserved <u8>           (do not use)\n"
++	       "  --frame_ms <u16>             Minimum milliseconds between animation steps\n"
++	       "\n"
++	       "  --picture                    Start describing the next picture\n"
++	       "  --pic_width <u16>            Picture width in pixels\n"
++	       "  --pic_height <u16>           Picture height in pixels\n"
++	       "  --pic_position <u8>             Coarse picture placement:\n"
++	       "                                  0x00 - Top left\n"
++	       "                                  0x01 - Top\n"
++	       "                                  0x02 - Top right\n"
++	       "                                  0x03 - Right\n"
++	       "                                  0x04 - Bottom right\n"
++	       "                                  0x05 - Bottom\n"
++	       "                                  0x06 - Bottom left\n"
++	       "                                  0x07 - Left\n"
++	       "\n"
++	       "                                Flags:\n"
++	       "                                 0x10 - Calculate offset from corner towards center,\n"
++	       "                                         rather than from center towards corner\n"
++	       "  --pic_position_offset <u16>  Distance from base position in pixels\n"
++	       "  --pic_anim_type <u8>         Animation type:\n"
++	       "                                 0 - None\n"
++	       "                                 1 - Forward loop\n"
++	       "  --pic_anim_loop <u8>         Loop point for animation\n"
++	       "\n"
++	       "  --blob <filename>            Include next data stream\n"
++	       "  --blob_type <u16>            Type of data\n"
++	       "  --blob_picture_id <u8>       Picture to associate this blob with, starting at 0\n"
++	       "                                 (default: number of last --picture)\n"
++	       "\n");
++	printf("This tool will write %s files.\n\n",
++#if __BYTE_ORDER == __BIG_ENDIAN
++	       "Big Endian (BE)");
++#elif __BYTE_ORDER == __LITTLE_ENDIAN
++	       "Little Endian (LE)");
++#else
++#error
++#endif
++}
++
++
++struct blob_entry {
++	struct blob_entry *next;
++
++	char *fn;
++
++	struct splash_blob_header header;
++};
++
++
++static void dump_file_header(struct splash_file_header *h)
++{
++	printf(" --- File header ---\n");
++	printf("\n");
++	printf("  version:     %5u\n", h->version);
++	printf("\n");
++	printf("  bg_red:      %5u\n", h->bg_red);
++	printf("  bg_green:    %5u\n", h->bg_green);
++	printf("  bg_blue:     %5u\n", h->bg_blue);
++	printf("  bg_reserved: %5u\n", h->bg_reserved);
++	printf("\n");
++	printf("  num_blobs:   %5u\n", h->num_blobs);
++	printf("  num_pics:    %5u\n", h->num_pics);
++	printf("\n");
++	printf("  frame_ms:    %5u\n", h->frame_ms);
++	printf("\n");
++}
++
++static void dump_pic_header(struct splash_pic_header *ph)
++{
++	printf(" --- Picture header ---\n");
++	printf("\n");
++	printf("  width:           %5u\n", ph->width);
++	printf("  height:          %5u\n", ph->height);
++	printf("\n");
++	printf("  num_blobs:       %5u\n", ph->num_blobs);
++	printf("\n");
++	printf("  position:        %0x3x\n", ph->position);
++	printf("  position_offset: %5u\n", ph->position_offset);
++	printf("\n");
++	printf("  anim_type:       %5u\n", ph->anim_type);
++	printf("  anim_loop:       %5u\n", ph->anim_loop);
++	printf("\n");
++}
++
++static void dump_blob(struct blob_entry *b)
++{
++	printf(" --- Blob header ---\n");
++	printf("\n");
++	printf("  length:     %7u\n", b->header.length);
++	printf("  type:       %7u\n", b->header.type);
++	printf("\n");
++	printf("  picture_id: %7u\n", b->header.picture_id);
++	printf("\n");
++}
++
++
++#define OPT_MAX(var, max) \
++	do { \
++		if ((var) > max) { \
++			fprintf(stderr, "--%s: Invalid value\n", \
++			long_options[option_index].name); \
++			break; \
++		} \
++	} while (0)
++
++static struct option long_options[] = {
++	{"help", 0, 0, 'h'},
++	{"bg_red", 1, 0, 10001},
++	{"bg_green", 1, 0, 10002},
++	{"bg_blue", 1, 0, 10003},
++	{"bg_reserved", 1, 0, 10004},
++	{"frame_ms", 1, 0, 10005},
++	{"picture", 0, 0, 20000},
++	{"pic_width", 1, 0, 20001},
++	{"pic_height", 1, 0, 20002},
++	{"pic_position", 1, 0, 20003},
++	{"pic_position_offset", 1, 0, 20004},
++	{"pic_anim_type", 1, 0, 20005},
++	{"pic_anim_loop", 1, 0, 20006},
++	{"blob", 1, 0, 30000},
++	{"blob_type", 1, 0, 30001},
++	{"blob_picture_id", 1, 0, 30002},
++	{NULL, 0, NULL, 0}
++};
++
++
++int main(int argc, char **argv)
++{
++	FILE *of;
++	char *ofn;
++	int c;
++	int option_index = 0;
++
++	unsigned long ul;
++	struct splash_file_header fh = {};
++	struct splash_pic_header ph[255];
++	struct blob_entry *blob_first = NULL;
++	struct blob_entry *blob_last = NULL;
++	struct blob_entry *blob_cur = NULL;
++
++	if (argc < 2) {
++		print_help(argv[0]);
++		return EXIT_FAILURE;
++	}
++
++
++	/* Parse and and execute user commands */
++	while ((c = getopt_long(argc, argv, "h",
++			  long_options, &option_index)) != -1) {
++		switch (c) {
++		case 10001:	/* bg_red */
++			ul = strtoul(optarg, NULL, 0);
++			OPT_MAX(ul, 255);
++			fh.bg_red = ul;
++			break;
++		case 10002:	/* bg_green */
++			ul = strtoul(optarg, NULL, 0);
++			OPT_MAX(ul, 255);
++			fh.bg_green = ul;
++			break;
++		case 10003:	/* bg_blue */
++			ul = strtoul(optarg, NULL, 0);
++			OPT_MAX(ul, 255);
++			fh.bg_blue = ul;
++			break;
++		case 10004:	/* bg_reserved */
++			ul = strtoul(optarg, NULL, 0);
++			OPT_MAX(ul, 255);
++			fh.bg_reserved = ul;
++			break;
++		case 10005:	/* frame_ms */
++			ul = strtoul(optarg, NULL, 0);
++			OPT_MAX(ul, 65535);
++			fh.frame_ms = ul;
++			break;
++
++
++		case 20000:	/* picture */
++			if (fh.num_pics >= 255) {
++				fprintf(stderr, "--%s: Picture array full\n",
++					long_options[option_index].name);
++				break;
++			}
++
++			fh.num_pics++;
++			break;
++
++		case 20001:	/* pic_width */
++			ul = strtoul(optarg, NULL, 0);
++			OPT_MAX(ul, 65535);
++			ph[fh.num_pics - 1].width = ul;
++			break;
++
++		case 20002:	/* pic_height */
++			ul = strtoul(optarg, NULL, 0);
++			OPT_MAX(ul, 65535);
++			ph[fh.num_pics - 1].height = ul;
++			break;
++
++		case 20003:	/* pic_position */
++			ul = strtoul(optarg, NULL, 0);
++			OPT_MAX(ul, 255);
++			ph[fh.num_pics - 1].position = ul;
++			break;
++
++		case 20004:	/* pic_position_offset */
++			ul = strtoul(optarg, NULL, 0);
++			OPT_MAX(ul, 255);
++			ph[fh.num_pics - 1].position_offset = ul;
++			break;
++
++		case 20005:	/* pic_anim_type */
++			ul = strtoul(optarg, NULL, 0);
++			OPT_MAX(ul, 255);
++			ph[fh.num_pics - 1].anim_type = ul;
++			break;
++
++		case 20006:	/* pic_anim_loop */
++			ul = strtoul(optarg, NULL, 0);
++			OPT_MAX(ul, 255);
++			ph[fh.num_pics - 1].anim_loop = ul;
++			break;
++
++
++		case 30000:	/* blob */
++			if (fh.num_blobs >= 65535) {
++				fprintf(stderr, "--%s: Blob array full\n",
++					long_options[option_index].name);
++				break;
++			}
++
++			blob_cur = calloc(1, sizeof(struct blob_entry));
++			if (!blob_cur) {
++				fprintf(stderr, "--%s: Out of memory\n",
++					long_options[option_index].name);
++				break;
++			}
++
++			blob_cur->fn = optarg;
++			if (fh.num_pics)
++				blob_cur->header.picture_id = fh.num_pics - 1;
++
++			if (!blob_first)
++				blob_first = blob_cur;
++			if (blob_last)
++				blob_last->next = blob_cur;
++			blob_last = blob_cur;
++			fh.num_blobs++;
++			break;
++
++		case 30001:	/* blob_type */
++			if (!blob_cur) {
++				fprintf(stderr, "--%s: No blob selected\n",
++					long_options[option_index].name);
++				break;
++			}
++
++			ul = strtoul(optarg, NULL, 0);
++			OPT_MAX(ul, 255);
++			blob_cur->header.type = ul;
++			break;
++
++		case 30002:	/* blob_picture_id */
++			if (!blob_cur) {
++				fprintf(stderr, "--%s: No blob selected\n",
++					long_options[option_index].name);
++				break;
++			}
++
++			ul = strtoul(optarg, NULL, 0);
++			OPT_MAX(ul, 255);
++			blob_cur->header.picture_id = ul;
++			break;
++
++
++
++		case 'h':
++		case '?':
++		default:
++			print_help(argv[0]);
++			goto EXIT;
++		} /* switch (c) */
++	} /* while ((c = getopt_long(...)) != -1) */
++
++	/* Consume and drop lone arguments */
++	while (optind < argc) {
++		ofn = argv[optind];
++		optind++;
++	}
++
++
++	/* Read file lengths */
++	for (blob_cur = blob_first; blob_cur; blob_cur = blob_cur->next) {
++		FILE *f;
++		long pos;
++		int i;
++
++		if (!blob_cur->fn)
++			continue;
++
++		f = fopen(blob_cur->fn, "rb");
++		if (!f)
++			goto ERR_FILE_LEN;
++
++		if (fseek(f, 0, SEEK_END))
++			goto ERR_FILE_LEN;
++
++		pos = ftell(f);
++		if (pos < 0 || pos > (1 << 30))
++			goto ERR_FILE_LEN;
++
++		blob_cur->header.length = pos;
++
++		fclose(f);
++		continue;
++
++ERR_FILE_LEN:
++		fprintf(stderr, "Error getting file length (or too long): %s\n",
++			blob_cur->fn);
++		if (f)
++			fclose(f);
++		continue;
++	}
++
++
++	/* Set magic headers */
++#if __BYTE_ORDER == __BIG_ENDIAN
++	memcpy(&fh.id[0], BOOTSPLASH_MAGIC_BE, 16);
++#elif __BYTE_ORDER == __LITTLE_ENDIAN
++	memcpy(&fh.id[0], BOOTSPLASH_MAGIC_LE, 16);
++#else
++#error
++#endif
++	fh.version = BOOTSPLASH_VERSION;
++
++	/* Set blob counts */
++	for (blob_cur = blob_first; blob_cur; blob_cur = blob_cur->next) {
++		if (blob_cur->header.picture_id < fh.num_pics)
++			ph[blob_cur->header.picture_id].num_blobs++;
++	}
++
++
++	/* Dump structs */
++	dump_file_header(&fh);
++
++	for (ul = 0; ul < fh.num_pics; ul++)
++		dump_pic_header(&ph[ul]);
++
++	for (blob_cur = blob_first; blob_cur; blob_cur = blob_cur->next)
++		dump_blob(blob_cur);
++
++
++	/* Write to file */
++	printf("Writing splash to file: %s\n", ofn);
++	of = fopen(ofn, "wb");
++	if (!of)
++		goto ERR_WRITING;
++
++	if (fwrite(&fh, sizeof(struct splash_file_header), 1, of) != 1)
++		goto ERR_WRITING;
++
++	for (ul = 0; ul < fh.num_pics; ul++) {
++		if (fwrite(&ph[ul], sizeof(struct splash_pic_header), 1, of)
++		    != 1)
++			goto ERR_WRITING;
++	}
++
++	blob_cur = blob_first;
++	while (blob_cur) {
++		struct blob_entry *blob_old = blob_cur;
++		FILE *f;
++		char *buf[256];
++		uint32_t left;
++
++		if (fwrite(&blob_cur->header,
++			   sizeof(struct splash_blob_header), 1, of) != 1)
++			goto ERR_WRITING;
++
++		if (!blob_cur->header.length || !blob_cur->fn)
++			continue;
++
++		f = fopen(blob_cur->fn, "rb");
++		if (!f)
++			goto ERR_FILE_COPY;
++
++		left = blob_cur->header.length;
++		while (left >= sizeof(buf)) {
++			if (fread(buf, sizeof(buf), 1, f) != 1)
++				goto ERR_FILE_COPY;
++			if (fwrite(buf, sizeof(buf), 1, of) != 1)
++				goto ERR_FILE_COPY;
++			left -= sizeof(buf);
++		}
++		if (left) {
++			if (fread(buf, left, 1, f) != 1)
++				goto ERR_FILE_COPY;
++			if (fwrite(buf, left, 1, of) != 1)
++				goto ERR_FILE_COPY;
++		}
++
++		/* Pad data stream to 16 bytes */
++		if (left % 16) {
++			if (fwrite("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0",
++					16 - (left % 16), 1, of) != 1)
++				goto ERR_FILE_COPY;
++		}
++
++		fclose(f);
++		blob_cur = blob_cur->next;
++		free(blob_old);
++		continue;
++
++ERR_FILE_COPY:
++		if (f)
++			fclose(f);
++		goto ERR_WRITING;
++	}
++
++	fclose(of);
++
++EXIT:
++	return EXIT_SUCCESS;
++
++
++ERR_WRITING:
++	fprintf(stderr, "Error writing splash.\n");
++	fprintf(stderr, "The output file is probably corrupt.\n");
++	if (of)
++		fclose(of);
++
++	while (blob_cur) {
++		struct blob_entry *blob_old = blob_cur;
++
++		blob_cur = blob_cur->next;
++		free(blob_old);
++	}
++
++	return EXIT_FAILURE;
++}
diff --git a/0513-bootsplash.gitpatch b/0513-bootsplash.gitpatch
new file mode 100644
index 0000000..124ad07
--- /dev/null
+++ b/0513-bootsplash.gitpatch
@@ -0,0 +1,162 @@
+diff --git a/Documentation/bootsplash.rst b/Documentation/bootsplash.rst
+index b35aba5093e8..d4f132eca615 100644
+--- a/Documentation/bootsplash.rst
++++ b/Documentation/bootsplash.rst
+@@ -195,6 +195,16 @@ Hooks - how the bootsplash is integrated
+ 
+ 
+ 
++Crating a bootsplash theme file
++===============================
++
++A simple tool for theme file creation is included in ``tools/bootsplash``.
++
++There is also an example shell script, as an example on how to use the tool
++and in order to generate a reference bootsplash file.
++
++
++
+ FAQ: Frequently Asked Questions
+ ===============================
+ 
+diff --git a/tools/bootsplash/.gitignore b/tools/bootsplash/.gitignore
+index 091b99a17567..5dfced41ba82 100644
+--- a/tools/bootsplash/.gitignore
++++ b/tools/bootsplash/.gitignore
+@@ -1 +1,4 @@
+ bootsplash-packer
++bootsplash
++logo.rgb
++throbber*.rgb
+diff --git a/tools/bootsplash/ajax-loader.gif b/tools/bootsplash/ajax-loader.gif
+new file mode 100644
+index 0000000000000000000000000000000000000000..3288d1035d70bb86517e2c233f1a904e41f06b29
+GIT binary patch
+literal 3208
+zcmc(iX;4#H9>pJdFE7h`I{IF)0|5<6L}(j=N}5%L009EB2nYfyF)E0PvIqo$u!IC;
+z4PgyY5|S9AEh38G)(9eq4TbH7_UHg@yWrlIJ$6smIADL7s^P;_O;ykRc<bJ}b<Y2s
+zU)AOL`#QVCGXW;>9soXl`UC*LwQJXkii*0rx|*7rI2=x7WaRkx_~XZqFJ8R3c=2Kg
+zf@aSAv8+BJ8+^hyay>(QR@t*blbKzsf0}bscEqRc5Hd3o(-N5RyW=zWB*zQw6Zh>*
+z2CROCDAbu#D`)S|J_<lj7Yz9)#_Og>o(lL9Yn3l*+8RdiRD_>iNz$#_IAzCna&Wl5
+zSF_(rRCDD!wi#i8oAm&jYtn2_@VB%2-H*G%bN#|(6R6N?wM)3u`PiGzwuX7qmTgyF
+zpE)h0kuoxQ9?=kW7Y!=R@DmhU9)vwT<ZMc0Y;&y4jY1%TT3z!|H=R-GXDHPiKcVWh
+zY+!etO=DI2rIs8{iFWtPv(Lu|O3u|$F3Sbq;+xF{gTX$#T%m?MUUZy&ug3$=zXgXj
+zrxrf}reg*D3HB~8JyLgl$UCyV?EQ`@OKjW@tGrvh6ZqPD#+m=rK0T{FT01>*EZWzJ
+zrt+=2tqFts72yIp?|gvdLhs8Hfku^Z(){gmN%Y=K#<L1VKWYjwV^JDyeS;Y$p1xw*
+z#3VzfAV>P|%fkvg<hUP3U1Q=Hdgg~ik+2zyAc79kpuA<f*-~l+ZBH3*S2jBrEOF0w
+zrxe9#Vx$SxnL0JE4WeeXY1)ppOIy3@Vvexu&oeIa&QvoD`jBE#Gd7rT{j&OMLz1Wu
+zOEj;)PR^=mxjCG0NOUJb&U;ui6*-`3&wmcQ>Uj~HfIp3CuXqCtYGtJ#me+n+-LmP(
+z*XNuk%!aH8bIE@_Bj46>M*dSro|7<6vZ7WUHh5YQzN$>IJFqCb|CT!wj~R2C2%=q{
+zpt8rzY$aw?W?=Ustv{jo?Ow@<k6~~d?F>ZRkLe<)NItY>Cyhle*wR59dTdF6(@{5^
+zAQBOB*hNtc3bkY-8{Cm$nFS@elbTtSqrt7MB{h_4y+~`!mVa}?c&N>&?P}GqdMuhQ
+z&@TD5Czd((DcG_Su~dKKV)Pj$-qi1WHM8_vc^O4?^!oY|tmK~i!{fjd&@_1E(T~r7
+z_REZy&hMT^ySJB3W7l<L=l9ZMvC<Gz>$4YhR`M(J7S5S~+4Q&3HPa)z%zPpisOp$^
+zTEe99ig2$5_qFr!$;<oK+H}=wcaT3=%Nm!;Kw7MHnU5paWS{tI1+DOU?!7xefZ57L
+ze_iPrUrRQct0FSCtTFLtg*<#jo}Z3{E?T{skj>7A6CJ}PJmRhli>w?LC}Y`#HLGy6
+zMU4<C6_PR!wGq`HQyoWJb;nj8>EhL~dKCN5Ut;U2jd*83ShB<kA1Y@1U)Ar;N|HhS
+znIkwkT(&i5XhkI;xwmC%DvPhGNIi?aY<|8rajSt<ap(2E-#qSPQxAp@jIY@-@>Niu
+zcJB0l9>1Modc?-oM<<M{t-|U0{*W+=Ct2ZY_02y-De{7vW<f^HJQhd1l&4)Gw2oOS
+zm46KASlsKI@J$sA#$$|7D5QMbewIaFv4fXyNbL5Ac~kS&g^#5XHaYBvNxbF3Y2L*6
+ztrn?JmgOFAo1lh99BEb^pp>R<Z&2wFwWd*z2wF6&nmW9}nyMfWMO`hc&zkr2AeBP3
+zj75NZQ8-VthLviI^j@e=FN6wxR@1uCRv<b;Y<3t(dr<e}N%b}FQtKxHi9xU2C!#0Z
+zO2<#(;s&964KtWfkQVi``vIFT7kbT~d;ITb0T9+U1AwIgET*ciil)~4gl;xgoy5M!
+z-UJHerGNh_`lO!vA)%ly=~<}ykhlnQnoP$oqido+`qK(cOpmt^pbhf`n-FQaIK5ix
+zq@=#Sl2Y&s<pe8B!1!YA78W7dA?2Xu9v7QHc?}NN)sx(o6iZ#|kHX64nijZG(yB1J
+zfMQm;1rb5O!-+1Pov;csFu7z>4?<d6>}3g}UJ%@K);kriq>)e*rh%hdqM)5Q)*+O8
+zXm;SEbs@koiYS!9YXIclSg+5m_s~yrW#kKMdiRszg(gCP5HPmP7L)vCf8@fxUh6qY
+z@Z#TmkjzAZX{rwE+q|K~F2v5{_@vt%>yT_a#fF03SFt{0RX<yi^Bg0BS3UHmG;U4d
+z`2QlHs<l7ezUo)s<V^9ZccYv>vDAiaY~K9CgS1O>frXgAjBCS}mEd4mIWZ$=ovd5|
+zR?GRdU}d6+Q`+JRW)|=v7$)X<at#L3(d9WVd8CstDNPh>Nkn3yE`!nAiSCvOB1jKT
+zG<1aK3s<0b0m==egTD#8i(<nFTpHvxfx|aIng5yR81z6E<naz8-Ow^p@sCs8mz=%h
+zO$v$X0NS?ofjnp~62AE}^z%gY8Nsqj=NwUqyj+o6s$@kK@d+U4Vp-^_G32vzv@8nI
+z01{`FL$DXQL%WB*9R<xn7$ya31flsbiVh+-0m=YeB_ocaW;YRxI51d(jP?N!ane91
+z9~^yzJ;S;OWRKC8PrrXYkZCaruNYE>Of=1pGDTOCho0XpIOMQ&P87cVKY1W=C6kIg
+z9cH=@a&zbm2+`|{(_?YC9fdm?1TY~-pwlBn?>=(~1pDKbco6jloP;0-cqRiwV1A_S
+zEyV0Dj8Pwy!nekzaN>{)7rgZ&_QLxK{~1yRe865^<m)Ax^m58MY|zev&92(G7#vQU
+zn~8r)5oUrwM9`}05|I<Nx*n}jlvg&C9_310Dd4OT2txd91Z*_U8bRtrNaq+nGd{E#
+zVGckZFpr^;mv}%%T{jHtz<a=^%;mPXVY7SR`@6_Uw@(0*>yx>}+a!ECd>#MMwddow
+z@CU{l+Rt$xuXuf}?ga{3IAr?Raql^c@a%sI0U5m}HvJ5O1#I%_MMPt#BH>OqUZ{-k
+zt>4Xzz=%jT*FVW(uYkWyx}9Gw$HdN*qU?Bit#ji(Wi7p-u|_8?h^%szIS^s^fNM}b
+zgGy>|=cbEufpguY5_6w~&ZLv=Bo06UF9EYIY;Er-1VK)SyF&!|J{axiE1z^(hXwVq
+zsFS=K-#zC}CcOs^8W{KAt+kK)jYDgDYbCXv{{<mZ_TMxh0{w%6lzzG*pm+Dj4XaZ5
+zoJwkk5)~fyUmzYbwMERR3j)XePHj^2P!5GK`~^RXuEz>rwsgqtIU3<910$CJi)s??
+z_t8k{>7*0~4l~LLF7$WXT5OSq5QCTbP_l!SN|{R}3D&eWA8~0ltWh1IL+ZBX4rRSt
+zWF6Om3WDMu4xK^1(BF`2cL}rUCzhHAB`@j5&R-yk_l*t;mPGY|u2^o|myvcOdrg0W
+z%=lX;f^Vkqfp?u7*4qQq%A3Mpf!xspWBSKS@O%r*TSM}?dl(@*%{0Jm_8;(h{R__M
+Bt<?Yk
+
+literal 0
+HcmV?d00001
+
+diff --git a/tools/bootsplash/bootsplash-tux.sh b/tools/bootsplash/bootsplash-tux.sh
+new file mode 100755
+index 000000000000..1078f87644b9
+--- /dev/null
++++ b/tools/bootsplash/bootsplash-tux.sh
+@@ -0,0 +1,66 @@
++#!/bin/bash
++#
++# A simple script to show how to create a bootsplash.
++# Do with it whatever you wish.
++#
++# This needs ImageMagick for the 'convert' and 'identify' tools.
++#
++
++LOGO=../../Documentation/logo.gif
++LOGO_WIDTH=$(identify $LOGO | cut -d " " -f 3 | cut -d x -f 1)
++LOGO_HEIGHT=$(identify $LOGO | cut -d " " -f 3 | cut -d x -f 2)
++
++THROBBER=ajax-loader.gif
++THROBBER_WIDTH=$(identify $THROBBER | head -1 | cut -d " " -f 3 | \
++						cut -d x -f 1)
++THROBBER_HEIGHT=$(identify $THROBBER | head -1 | cut -d " " -f 3 | \
++						 cut -d x -f 2)
++
++convert -alpha remove \
++	-background "#ff3a40" \
++	$LOGO \
++	logo.rgb
++
++convert -alpha remove \
++	-background "#ff3a40" \
++	$THROBBER \
++	throbber%02d.rgb
++
++
++make clean
++make bootsplash-packer
++
++
++# Let's put Tux in the center of an orange background.
++./bootsplash-packer \
++	--bg_red 0xff \
++	--bg_green 0x3a \
++	--bg_blue 0x40 \
++	--frame_ms 48 \
++	--picture \
++	--pic_width $LOGO_WIDTH \
++	--pic_height $LOGO_HEIGHT \
++	--pic_position 0 \
++	--blob logo.rgb \
++	--picture \
++	--pic_width $THROBBER_WIDTH \
++	--pic_height $THROBBER_HEIGHT \
++	--pic_position 0x14 \
++	--pic_position_offset 20 \
++	--pic_anim_type 1 \
++	--pic_anim_loop 0 \
++	--blob throbber00.rgb \
++	--blob throbber01.rgb \
++	--blob throbber02.rgb \
++	--blob throbber03.rgb \
++	--blob throbber04.rgb \
++	--blob throbber05.rgb \
++	--blob throbber06.rgb \
++	--blob throbber07.rgb \
++	--blob throbber08.rgb \
++	--blob throbber09.rgb \
++	--blob throbber10.rgb \
++	--blob throbber11.rgb \
++	bootsplash
++
++rm *.rgb
diff --git a/aarch64-desktop-omv-defconfig b/aarch64-desktop-omv-defconfig
index ba02a98..12df697 100644
--- a/aarch64-desktop-omv-defconfig
+++ b/aarch64-desktop-omv-defconfig
@@ -149,7 +149,7 @@ CONFIG_CGROUP_WRITEBACK=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_FAIR_GROUP_SCHED=y
 CONFIG_CFS_BANDWIDTH=y
-CONFIG_RT_GROUP_SCHED=y
+# CONFIG_RT_GROUP_SCHED is not set
 CONFIG_UCLAMP_TASK_GROUP=y
 CONFIG_CGROUP_PIDS=y
 CONFIG_CGROUP_RDMA=y
@@ -6478,6 +6478,7 @@ CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 # CONFIG_FRAMEBUFFER_CONSOLE_ROTATION is not set
 # CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER is not set
+# CONFIG_BOOTSPLASH is not set
 # end of Console display driver support
 
 CONFIG_LOGO=y
diff --git a/aarch64-server-omv-defconfig b/aarch64-server-omv-defconfig
index 7112a0c..fda30b4 100644
--- a/aarch64-server-omv-defconfig
+++ b/aarch64-server-omv-defconfig
@@ -149,7 +149,7 @@ CONFIG_CGROUP_WRITEBACK=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_FAIR_GROUP_SCHED=y
 CONFIG_CFS_BANDWIDTH=y
-CONFIG_RT_GROUP_SCHED=y
+# CONFIG_RT_GROUP_SCHED is not set
 CONFIG_UCLAMP_TASK_GROUP=y
 CONFIG_CGROUP_PIDS=y
 CONFIG_CGROUP_RDMA=y
@@ -6478,6 +6478,7 @@ CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 # CONFIG_FRAMEBUFFER_CONSOLE_ROTATION is not set
 # CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER is not set
+# CONFIG_BOOTSPLASH is not set
 # end of Console display driver support
 
 CONFIG_LOGO=y
diff --git a/armv7hnl-desktop-omv-defconfig b/armv7hnl-desktop-omv-defconfig
index 901ca4d..9bc8ab7 100644
--- a/armv7hnl-desktop-omv-defconfig
+++ b/armv7hnl-desktop-omv-defconfig
@@ -152,7 +152,7 @@ CONFIG_CGROUP_WRITEBACK=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_FAIR_GROUP_SCHED=y
 CONFIG_CFS_BANDWIDTH=y
-CONFIG_RT_GROUP_SCHED=y
+# CONFIG_RT_GROUP_SCHED is not set
 CONFIG_CGROUP_PIDS=y
 CONFIG_CGROUP_RDMA=y
 CONFIG_CGROUP_FREEZER=y
@@ -7234,6 +7234,7 @@ CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y
 CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER=y
+# CONFIG_BOOTSPLASH is not set
 # end of Console display driver support
 
 CONFIG_LOGO=y
@@ -11603,6 +11604,7 @@ CONFIG_BRANCH_PROFILE_NONE=y
 # CONFIG_PROFILE_ANNOTATED_BRANCHES is not set
 CONFIG_BLK_DEV_IO_TRACE=y
 CONFIG_KPROBE_EVENTS=y
+# CONFIG_KPROBE_EVENTS_ON_NOTRACE is not set
 # CONFIG_UPROBE_EVENTS is not set
 CONFIG_BPF_EVENTS=y
 CONFIG_DYNAMIC_EVENTS=y
diff --git a/armv7hnl-server-omv-defconfig b/armv7hnl-server-omv-defconfig
index 512597b..4a17126 100644
--- a/armv7hnl-server-omv-defconfig
+++ b/armv7hnl-server-omv-defconfig
@@ -152,7 +152,7 @@ CONFIG_CGROUP_WRITEBACK=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_FAIR_GROUP_SCHED=y
 CONFIG_CFS_BANDWIDTH=y
-CONFIG_RT_GROUP_SCHED=y
+# CONFIG_RT_GROUP_SCHED is not set
 CONFIG_CGROUP_PIDS=y
 CONFIG_CGROUP_RDMA=y
 CONFIG_CGROUP_FREEZER=y
@@ -7234,6 +7234,7 @@ CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y
 CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER=y
+# CONFIG_BOOTSPLASH is not set
 # end of Console display driver support
 
 CONFIG_LOGO=y
@@ -11603,6 +11604,7 @@ CONFIG_BRANCH_PROFILE_NONE=y
 # CONFIG_PROFILE_ANNOTATED_BRANCHES is not set
 CONFIG_BLK_DEV_IO_TRACE=y
 CONFIG_KPROBE_EVENTS=y
+# CONFIG_KPROBE_EVENTS_ON_NOTRACE is not set
 # CONFIG_UPROBE_EVENTS is not set
 CONFIG_BPF_EVENTS=y
 CONFIG_DYNAMIC_EVENTS=y
diff --git a/i686-desktop-gcc-omv-defconfig b/i686-desktop-gcc-omv-defconfig
index a496c17..9323789 100644
--- a/i686-desktop-gcc-omv-defconfig
+++ b/i686-desktop-gcc-omv-defconfig
@@ -160,7 +160,7 @@ CONFIG_CGROUP_WRITEBACK=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_FAIR_GROUP_SCHED=y
 CONFIG_CFS_BANDWIDTH=y
-CONFIG_RT_GROUP_SCHED=y
+# CONFIG_RT_GROUP_SCHED is not set
 CONFIG_CGROUP_PIDS=y
 CONFIG_CGROUP_RDMA=y
 CONFIG_CGROUP_FREEZER=y
@@ -6555,6 +6555,7 @@ CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y
 CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER=y
+# CONFIG_BOOTSPLASH is not set
 # end of Console display driver support
 
 # CONFIG_LOGO is not set
diff --git a/i686-server-gcc-omv-defconfig b/i686-server-gcc-omv-defconfig
index f034eaf..80e0d52 100644
--- a/i686-server-gcc-omv-defconfig
+++ b/i686-server-gcc-omv-defconfig
@@ -157,7 +157,7 @@ CONFIG_CGROUP_WRITEBACK=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_FAIR_GROUP_SCHED=y
 CONFIG_CFS_BANDWIDTH=y
-CONFIG_RT_GROUP_SCHED=y
+# CONFIG_RT_GROUP_SCHED is not set
 CONFIG_CGROUP_PIDS=y
 CONFIG_CGROUP_RDMA=y
 CONFIG_CGROUP_FREEZER=y
@@ -6554,6 +6554,7 @@ CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y
 CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER=y
+# CONFIG_BOOTSPLASH is not set
 # end of Console display driver support
 
 # CONFIG_LOGO is not set
diff --git a/kernel-release.spec b/kernel-release.spec
index 55a86c6..6e3e0ae 100644
--- a/kernel-release.spec
+++ b/kernel-release.spec
@@ -22,7 +22,7 @@
 # compose tar.xz name and release
 %define kernelversion	5
 %define patchlevel	10
-%define sublevel	6
+%define sublevel	10
 %define relc		%{nil}
 # Only ever wrong on x.0 releases...
 %define previous	%{kernelversion}.%(echo $((%{patchlevel}-1)))
@@ -369,6 +369,25 @@ Patch307:	PATCH-v16-08-10-fs-ntfs3-Add-Kconfig-Makefile-and-doc.patch
 Patch308:	PATCH-v16-09-10-fs-ntfs3-Add-NTFS3-in-fs-Kconfig-and-fs-Makefile.patch
 Patch309:	PATCH-v16-10-10-fs-ntfs3-Add-MAINTAINERS.patch
 
+# Bootsplash support
+# based on https://gitlab.manjaro.org/packages/core/linux510/-/tree/master
+Patch401:	0401-revert-fbcon-remove-now-unusued-softback_lines-cursor-argument.patch
+Patch402:	0402-revert-fbcon-remove-no-op-fbcon_set_origin.patch
+Patch403:	0403-revert-fbcon-remove-soft-scrollback-code.patch
+Patch501:	0501-bootsplash.patch
+Patch502:	0502-bootsplash.patch
+Patch503:	0503-bootsplash.patch
+Patch504:	0504-bootsplash.patch
+Patch505:	0505-bootsplash.patch
+Patch506:	0506-bootsplash.patch
+Patch507:	0507-bootsplash.patch
+Patch508:	0508-bootsplash.patch
+Patch509:	0509-bootsplash.patch
+Patch510:	0510-bootsplash.patch
+Patch511:	0511-bootsplash.patch
+Patch512:	0512-bootsplash.patch
+Source513:	0513-bootsplash.gitpatch
+
 # Patches to external modules
 # Marked SourceXXX instead of PatchXXX because the modules
 # being touched aren't in the tree at the time %%autopatch -p1
@@ -891,6 +910,9 @@ xzcat %{SOURCE1000} |git apply - || git apply %{SOURCE1000}
 rm -rf .git
 %endif
 %autopatch -p1
+git apply %{SOURCE513}
+
+sed -i -e "s,' ' -f 2,' ' -f 4," scripts/lld-version.sh
 
 %ifarch %{aarch64}
 # FIXME SynQuacer workaround
@@ -1000,7 +1022,7 @@ find . -name "*.g*ignore" -delete
 chmod 755 tools/objtool/sync-check.sh
 
 %build
-%setup_compile_flags
+%set_build_flags
 
 ############################################################
 ###  Linker end2 > Check point to build for omv or rosa ###
@@ -1019,13 +1041,20 @@ chmod 755 tools/objtool/sync-check.sh
 
 
 CheckConfig() {
-
 	if [ ! -e $(pwd)/.config ]; then
 		printf '%s\n' "Kernel config in $(pwd) missing, killing the build."
 		exit 1
 	fi
 }
 
+VerifyConfig() {
+# (tpg) please add CONFIG that were carelessly enabled, while it is known these MUST be disabled
+    if grep -Fxq "CONFIG_RT_GROUP_SCHED=y" $(pwd)/.config $(pwd)/*-defconfig; then
+	printf '%s\n' "Please stop enabling CONFIG_RT_GROUP_SCHED - this option is not recommended with systemd systemd/systemd#553, killing the build."
+	exit 1
+    fi
+}
+
 clangify() {
 	sed -i \
 		-e '/^CONFIG_CC_VERSION_TEXT=/d' \
@@ -1057,7 +1086,6 @@ CreateConfig() {
 	CONFIGS=""
 	rm -fv .config
 
-
 	if echo $type |grep -q clang; then
 		# (crazy) we could use LLVM=1 this will take care of all the clang stuff
 		# however on bugs where we have to change LD or some other tool we cannot do that
@@ -1228,6 +1256,7 @@ PrepareKernel() {
 	extension=$2
 	config_dir=%{_sourcedir}
 	printf '%s\n' "Make config for kernel $extension"
+	VerifyConfig
 	%make_build -s mrproper
 %ifarch znver1
 	CreateConfig %{_target_cpu} ${flavour}
diff --git a/linux-5.10.tar.sign b/linux-5.10.tar.sign
deleted file mode 100644
index d62c35d..0000000
--- a/linux-5.10.tar.sign
+++ /dev/null
@@ -1,19 +0,0 @@
------BEGIN PGP SIGNATURE-----
-Comment: This signature is for the .tar version of the archive
-Comment: git archive --format tar --prefix=linux-5.10/ v5.10
-Comment: git version 2.29.2
-
-iQIzBAABCAAdFiEEZH8oZUiU471FcZm+ONu9yGCSaT4FAl/W/LUACgkQONu9yGCS
-aT6/cBAAqwOUE+4DCHuYnqLPO23Elg46TPPO+K/c49mEq4Z2NimoNeiguHns/aeA
-TLxuysw/YJKA+Yvv27jtf+g+dlrvr8QeWwl8GN8p0qWPwRHclcg1hkvQ0jD+tCz7
-uKpKF06P4oLhn/XxKbhvagZaea0fzrr7BWVsc91X5F7sCDZQzkKFkeCpUyCRyWEw
-0GIbc09MnpqT1iInSKYoGc7LxmZLD43jOK0eNtq4xJNPELqJhw0t24ubwOwOWKEk
-yBd4bRWIl+wrDQAzVBrAnIAtUGgL5OIIakoSrUi/kqf95sUqW8vlBxBcVruQ+kRf
-b8cpLfe1z84Vwrra5zf8ZEBoKLQV5eGYsrQgc/D37lHFGcrk3Q95AH4s+NHTkCPi
-UP61aZM3Td29IpBY/J6l33XWL7r8fTNYTnlCx5LzrmFXE/VnCZ6slZcoxDyC4NR3
-2UBS2xBcc/7xIFh0+IJecC7zfGZIQ+aXwgAwROft6SzRcQjgnV+zZSlemuJZDQR2
-eMCz7vfD7XJqeZ/Mpbm3u7zJ8em2hJj0O1ObFRuJ3l2peH/+grIkIaiikPhhvIur
-I2oPIgcmDkM+DsIP8bip+M4iFSHc2ciriER5PaJDz757rc4oupvqXeGM4lMZ5dJq
-ra7Q6eBLoTw5VCOYvyvKQhvSvfwT8utxPEKbCKxAtLsNA8lkBV0=
-=RzX+
------END PGP SIGNATURE-----
diff --git a/linux-5.8.tar.sign b/linux-5.8.tar.sign
deleted file mode 100644
index c243088..0000000
--- a/linux-5.8.tar.sign
+++ /dev/null
@@ -1,19 +0,0 @@
------BEGIN PGP SIGNATURE-----
-Comment: This signature is for the .tar version of the archive
-Comment: git archive --format tar --prefix=linux-5.8/ v5.8
-Comment: git version 2.28.0
-
-iQIzBAABCAAdFiEEZH8oZUiU471FcZm+ONu9yGCSaT4FAl8nkEEACgkQONu9yGCS
-aT5S2g/+Ndv+CYgXJA6pPq4OCPek7uLGS8ACKhOZLmCqGWeYHHI4cFqMG8ly8Q4h
-C41SbQ02IqHTYZO8MCbrEXSO7CygxWofneTFWA7VByG4pELpC8CPg9+Vd0+9beCE
-uE+iBDnVfQi02Rd4LJZhZms1U1ZXFvfoHzAHwwc3v9ocxu3e2BVmE/cdI0AkxJv1
-xwh6wh+ppI/yUdrru2iQdN+hQ+uLrxE5HJezS/cTuI8RNop0CvwxIodfXn5o9xab
-av+CI/V6CpUVXztipTTsL2xpkI6O67jFdpgYwIylO1wnyyzi4uGGQLQ16C8aiCX2
-omaF4DpKyshkJKfiChEs6f9+9lmc1eMzALY54LgczZP3Qr6vEOPEuFc2hw69hndI
-lNIB5Kw3N3Tm06tl1QaW4KypulUzXueKV0K8GD5r9+z+R+r2z9DWadNLTslACBnI
-dgg4KlNrMoY8/reguTSv02rdOLWKJI5UV/8OO3urjs11OtYs1uW8p8h8des73k7Z
-SfLj/T/bcDzymN5G8prLM8WIvihxc/nQHGmICWNRqoFns6EEvprZeA9RWFBvn3x3
-8e10uR18P+rBiaIyxn4IzLxxKUP7SvKhWdIxySwaEZZhDo5KxOpLgQEKQCZgFXXQ
-/IqseyAItaAFoI5UxVopUUPQzzZLveLraAweB9aOfiBAshIZWGI=
-=pEA9
------END PGP SIGNATURE-----
diff --git a/x86_64-desktop-gcc-omv-defconfig b/x86_64-desktop-gcc-omv-defconfig
index 3e61da2..d4bfee4 100644
--- a/x86_64-desktop-gcc-omv-defconfig
+++ b/x86_64-desktop-gcc-omv-defconfig
@@ -169,7 +169,7 @@ CONFIG_CGROUP_WRITEBACK=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_FAIR_GROUP_SCHED=y
 CONFIG_CFS_BANDWIDTH=y
-CONFIG_RT_GROUP_SCHED=y
+# CONFIG_RT_GROUP_SCHED is not set
 CONFIG_CGROUP_PIDS=y
 CONFIG_CGROUP_RDMA=y
 CONFIG_CGROUP_FREEZER=y
@@ -6517,6 +6517,7 @@ CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y
 CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER=y
+# CONFIG_BOOTSPLASH is not set
 # end of Console display driver support
 
 # CONFIG_LOGO is not set
diff --git a/x86_64-server-gcc-omv-defconfig b/x86_64-server-gcc-omv-defconfig
index 2e0b36d..14674b7 100644
--- a/x86_64-server-gcc-omv-defconfig
+++ b/x86_64-server-gcc-omv-defconfig
@@ -166,7 +166,7 @@ CONFIG_CGROUP_WRITEBACK=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_FAIR_GROUP_SCHED=y
 CONFIG_CFS_BANDWIDTH=y
-CONFIG_RT_GROUP_SCHED=y
+# CONFIG_RT_GROUP_SCHED is not set
 CONFIG_CGROUP_PIDS=y
 CONFIG_CGROUP_RDMA=y
 CONFIG_CGROUP_FREEZER=y
@@ -6438,6 +6438,7 @@ CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y
 CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER=y
+# CONFIG_BOOTSPLASH is not set
 # end of Console display driver support
 
 # CONFIG_LOGO is not set
diff --git a/x86_64-znver-desktop-gcc-omv-defconfig b/x86_64-znver-desktop-gcc-omv-defconfig
index b0a69dc..c083563 100644
--- a/x86_64-znver-desktop-gcc-omv-defconfig
+++ b/x86_64-znver-desktop-gcc-omv-defconfig
@@ -169,7 +169,7 @@ CONFIG_CGROUP_WRITEBACK=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_FAIR_GROUP_SCHED=y
 CONFIG_CFS_BANDWIDTH=y
-CONFIG_RT_GROUP_SCHED=y
+# CONFIG_RT_GROUP_SCHED is not set
 CONFIG_CGROUP_PIDS=y
 CONFIG_CGROUP_RDMA=y
 CONFIG_CGROUP_FREEZER=y
@@ -6439,6 +6439,7 @@ CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y
 CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER=y
+# CONFIG_BOOTSPLASH is not set
 # end of Console display driver support
 
 # CONFIG_LOGO is not set
diff --git a/x86_64-znver-server-gcc-omv-defconfig b/x86_64-znver-server-gcc-omv-defconfig
index 272ad4a..54b773f 100644
--- a/x86_64-znver-server-gcc-omv-defconfig
+++ b/x86_64-znver-server-gcc-omv-defconfig
@@ -166,7 +166,7 @@ CONFIG_CGROUP_WRITEBACK=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_FAIR_GROUP_SCHED=y
 CONFIG_CFS_BANDWIDTH=y
-CONFIG_RT_GROUP_SCHED=y
+# CONFIG_RT_GROUP_SCHED is not set
 CONFIG_CGROUP_PIDS=y
 CONFIG_CGROUP_RDMA=y
 CONFIG_CGROUP_FREEZER=y
@@ -6437,6 +6437,7 @@ CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y
 CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER=y
+# CONFIG_BOOTSPLASH is not set
 # end of Console display driver support
 
 # CONFIG_LOGO is not set
Not Available
benbullard79 [@T] cox.netNo Comment.35d 02hrs
benbullard79 [@T] cox.netNo Comment.35d 01hrs