[RFC PATCH v2 00/13] Kernel based bootsplash

@@ -102,6 +102,7 @@
 #include <linux/uaccess.h>
 #include <linux/kdb.h>
 #include <linux/ctype.h>
+#include <linux/bootsplash.h>
 
 #define MAX_NR_CON_DRIVER 16
 

@@ -3903,6 +3904,7 @@ void do_unblank_screen(int leaving_gfx)
 	}
 
 	console_blanked = 0;
+	bootsplash_mark_dirty();
 	if (vc->vc_sw->con_blank(vc, 0, leaving_gfx) || vt_force_oops_output(vc))
 		/* Low-level driver cannot restore -> do it ourselves */
 		update_screen(vc);

@@ -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);

@@ -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()

@@ -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

@@ -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

@@ -183,3 +183,13 @@ Hooks - how the bootsplash is integrated
   ``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.
+
+
+
+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.

@@ -1 +1,4 @@
 bootsplash-packer
+bootsplash
+logo.rgb
+throbber*.rgb

@@ -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

@@ -2715,6 +2715,7 @@ F:	drivers/video/fbdev/core/bootsplash*.*
 F:	drivers/video/fbdev/core/dummycon.c
 F:	include/linux/bootsplash.h
 F:	include/uapi/linux/bootsplash_file.h
+F:	tools/bootsplash/*
 
 BPF (Safe dynamic programs and tools)
 M:	Alexei Starovoitov <ast@kernel.org>

@@ -0,0 +1 @@
+bootsplash-packer

@@ -0,0 +1,9 @@
+CC := $(CROSS_COMPILE)gcc
+CFLAGS := -I../../usr/include
+
+PROGS := bootsplash-packer
+
+all: $(PROGS)
+
+clean:
+	rm -fr $(PROGS)

@@ -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;
+}

@@ -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.

@@ -0,0 +1,177 @@
+==========
+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˜0750
+
+
+
+Command line arguments
+===========
+
+``bootsplash.bootfile``
+  Which file in the initrd to load.
+  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.

@@ -2709,6 +2709,8 @@ BOOTSPLASH
 M:	Max Staudt <mstaudt@suse.de>
 L:	linux-fbdev@vger.kernel.org
 S:	Maintained
+F:	Documentation/ABI/testing/sysfs-platform-bootsplash
+F:	Documentation/bootsplash.rst
 F:	drivers/video/fbdev/core/bootsplash*.*
 F:	drivers/video/fbdev/core/dummycon.c
 F:	include/linux/bootsplash.h

@@ -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.

@@ -58,6 +58,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

@@ -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
 };