Fullscreen Splash Images

Enable by adding the following to cmdline.txt:
`fullscreen_logo_name=logo.tga fullscreen_logo=1`
Will show the logo file present in /lib/firmware/ on the screen.
This will be fullscreen and rendered early at boot.
Any remaining space is filled with solid color from the image border.
If TGA file is too big, image is clipped accordingly.

Signed-off-by: Ben Benson <ben.benson@raspberrypi.com>

Author: Ben Benson

drivers/video/fbdev/core/fb_logo.c

@@ -2,11 +2,24 @@
 
 #include <linux/fb.h>
 #include <linux/linux_logo.h>
+#include <linux/fs.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/uaccess.h>
+#include <linux/file.h>
+#include <linux/kernel.h>
+#include <linux/firmware.h>
 
 #include "fb_internal.h"
 
 bool fb_center_logo __read_mostly;
 int fb_logo_count __read_mostly = -1;
+static int fullscreen_logo_enabled __initdata;
+static char *fullscreen_logo_path __initdata;
+
+struct image_palette {
+	u8 colors[224][3];
+};
 
 static inline unsigned int safe_shift(unsigned int d, int n)
 {
@@ -79,6 +92,22 @@ static void  fb_set_logo_truepalette(struct fb_info *info,
 	}
 }
 
+static void fb_set_logo_RGB_palette(struct image_palette *palette,
+						 u32 *palette_to_write, int current_rows)
+{
+	// Set the kernel palette from an array of RGB values
+	uint32_t color_code;
+	int i;
+
+	// Color format is RGB565, remove LSB 3 bits, and move to correct position
+	for (i = 0; i < current_rows; i++) {
+		color_code = ((((uint16_t)palette->colors[i][0]) >> 3) << 11) |
+			     ((((uint16_t)palette->colors[i][1]) >> 2) << 5) |
+			     (((uint16_t)palette->colors[i][2]) >> 3);
+		palette_to_write[i+32] = color_code;
+	}
+}
+
 static void fb_set_logo_directpalette(struct fb_info *info,
 					     const struct linux_logo *logo,
 					     u32 *palette)
@@ -275,6 +304,166 @@ static void fb_do_show_logo(struct fb_info *info, struct fb_image *image,
 	}
 }
 
+static int __init fb_fullscreen_logo_setup(char *str)
+{
+	fullscreen_logo_enabled = 1;
+	fullscreen_logo_path = str;
+	pr_info("Fullscreen Logo Enabled: %d", fullscreen_logo_enabled);
+	pr_info("Fullscreen Logo Path: %s", fullscreen_logo_path);
+	return 1;
+}
+
+__setup("fullscreen_logo_name=", fb_fullscreen_logo_setup);
+
+static bool fb_palette_contains_entry(struct image_palette *palette, int num_existing_rows,
+					   u8 *entry_to_add, int cols, int *index)
+{
+	for (int i = 0; i < num_existing_rows; i++) {
+		bool match = true;
+
+		for (int j = 0; j < cols; j++) {
+			if (palette->colors[i][j] != entry_to_add[j]) {
+				match = false;
+				break;
+			}
+		}
+		if (match) {
+			*index = i; // Update the index
+			return true; // Found a duplicate
+		}
+	}
+	return false; // No duplicate found
+}
+
+static void fb_set_logo_from_file(struct fb_info *info, const char *filepath,
+				   struct fb_image *image, u32 *palette,
+				   u32 *saved_pseudo_palette)
+{
+	struct image_palette image_palette;
+	const char *file_content = NULL;
+	unsigned char *read_logo = NULL;
+	long width = 0, height = 0;
+	ssize_t len;
+	int ret;
+	const struct firmware *fw;
+
+	ret = request_firmware(&fw, filepath, info->device);
+	if (ret) {
+		pr_info("Failed to load logo file '%s': %d\n", filepath, ret);
+		goto cleanup;
+	}
+	len = fw->size;
+	file_content = fw->data;
+
+	if (len > 0) {
+		int current_rows = 0;
+		const char *current_ptr = file_content;
+		const char *end_ptr = file_content + len;
+
+		if (len < 18) {
+			pr_info("Invalid logo file: TGA file too small for header\n");
+			goto cleanup;
+		}
+
+		unsigned char *header = (unsigned char *)file_content;
+
+		// Parse TGA header
+		unsigned char id_length = header[0];
+		unsigned char image_type = header[2];
+		// Skip color map info (bytes 3-7)
+		// Skip image origin (bytes 8-11)
+		width = header[12] | (header[13] << 8);
+		height = header[14] | (header[15] << 8);
+		image->width = width;
+		image->height = height;
+		unsigned char pixel_depth = header[16];
+		unsigned char image_descriptor = header[17];
+
+		// Only supports uncompressed true-color images (type 2) with 24-bit depth
+		if (image_type != 2 || pixel_depth != 24) {
+			pr_info("Unsupported TGA logo format: Type=%d, Depth=%d (only support Type=2, Depth=24)\n",
+				image_type, pixel_depth);
+			goto cleanup;
+		}
+		// Skip header + ID field
+		current_ptr = file_content + 18 + id_length;
+
+		read_logo = kmalloc_array(width, height, GFP_KERNEL);
+		if (read_logo == NULL)
+			goto cleanup;
+
+		image->data = read_logo;
+
+		// TGA pixels are stored bottom-to-top by default, unless bit 5 of
+		// image_descriptor is set
+		bool top_to_bottom = (image_descriptor & 0x20) != 0;
+		int skip_x = 0, skip_y = 0;
+
+		if (image->width > info->var.xres) {
+			pr_info("Logo is larger than screen, clipping horizontally");
+			skip_x = (image->width - info->var.xres) / 2;
+		}
+		if (image->height > info->var.yres) {
+			pr_info("Logo is larger than screen, clipping vertically");
+			skip_y = (image->height - info->var.yres) / 2;
+		}
+		current_ptr += skip_y * width * 3 + skip_x * 3;
+		// Parse pixel data (BGR format in TGA)
+		for (int i = 0; i < height - 2 * skip_y; i++) {
+			for (int j = 0; j < width - 2 * skip_x; j++) {
+				if (current_ptr + 3 > end_ptr) {
+					pr_info("TGA: Unexpected end of file\n");
+					goto cleanup;
+				}
+				u8 B = (unsigned char)*current_ptr++;
+				u8 G = (unsigned char)*current_ptr++;
+				u8 R = (unsigned char)*current_ptr++;
+				u8 entry[3] = {R, G, B};
+				int palette_index = 0;
+
+				if (!fb_palette_contains_entry(&image_palette, current_rows,
+								entry, 3, &palette_index)) {
+					for (int k = 0; k < 3; k++)
+						image_palette.colors[current_rows][k] = entry[k];
+					palette_index = current_rows;
+					current_rows++;
+				}
+				int actual_row = top_to_bottom ? i : (height - 1 - i);
+
+				read_logo[actual_row * (width - 2 * skip_x) + j] =
+					palette_index + 32;
+			}
+			current_ptr += skip_x * 3 * 2;
+		}
+
+		// Set logo palette
+		palette = kmalloc(256 * 4, GFP_KERNEL);
+		if (palette == NULL)
+			goto cleanup;
+		fb_set_logo_RGB_palette(&image_palette, palette, current_rows);
+		saved_pseudo_palette = info->pseudo_palette;
+		info->pseudo_palette = palette;
+
+	} else {
+		pr_info("Error: logo TGA file is empty. Not drawing fullscreen logo.\n");
+	}
+
+	image->width = min_t(unsigned int, width, info->var.xres);
+	image->height = min_t(unsigned int, height, info->var.yres);
+	image->dx = 0;
+	image->dy = 0;
+	image->depth = 8;
+
+	if (image->height < info->var.yres)
+		image->dy = (info->var.yres - image->height) / 2;
+	if (image->width < info->var.xres)
+		image->dx = (info->var.xres - image->width) / 2;
+
+cleanup:
+	if (file_content)
+		kvfree(file_content);
+}
+
 static int fb_show_logo_line(struct fb_info *info, int rotate,
 			     const struct linux_logo *logo, int y,
 			     unsigned int n)
@@ -288,66 +477,85 @@ static int fb_show_logo_line(struct fb_info *info, int rotate,
 	    info->fbops->owner)
 		return 0;
 
-	image.depth = 8;
-	image.data = logo->data;
+	if (fullscreen_logo_enabled) {
+		fb_set_logo_from_file(info, fullscreen_logo_path,
+			&image, palette, saved_pseudo_palette);
+	} else {
+		image.depth = 8;
+		image.data = logo->data;
 
-	if (fb_logo.needs_cmapreset)
-		fb_set_logocmap(info, logo);
+		if (fb_logo.needs_cmapreset)
+			fb_set_logocmap(info, logo);
 
-	if (fb_logo.needs_truepalette ||
-	    fb_logo.needs_directpalette) {
-		palette = kmalloc(256 * 4, GFP_KERNEL);
-		if (palette == NULL)
-			return 0;
+		if (fb_logo.needs_truepalette ||
+			fb_logo.needs_directpalette) {
+			palette = kmalloc(256 * 4, GFP_KERNEL);
+			if (palette == NULL)
+				return 0;
 
-		if (fb_logo.needs_truepalette)
-			fb_set_logo_truepalette(info, logo, palette);
-		else
-			fb_set_logo_directpalette(info, logo, palette);
+			if (fb_logo.needs_truepalette)
+				fb_set_logo_truepalette(info, logo, palette);
+			else
+				fb_set_logo_directpalette(info, logo, palette);
 
-		saved_pseudo_palette = info->pseudo_palette;
-		info->pseudo_palette = palette;
-	}
+			saved_pseudo_palette = info->pseudo_palette;
+			info->pseudo_palette = palette;
+		}
 
-	if (fb_logo.depth <= 4) {
-		logo_new = kmalloc_array(logo->width, logo->height,
-					 GFP_KERNEL);
-		if (logo_new == NULL) {
-			kfree(palette);
-			if (saved_pseudo_palette)
-				info->pseudo_palette = saved_pseudo_palette;
-			return 0;
+		if (fb_logo.depth <= 4) {
+			logo_new = kmalloc_array(logo->width, logo->height,
+						GFP_KERNEL);
+			if (logo_new == NULL) {
+				kfree(palette);
+				if (saved_pseudo_palette)
+					info->pseudo_palette = saved_pseudo_palette;
+				return 0;
+			}
+			image.data = logo_new;
+			fb_set_logo(info, logo, logo_new, fb_logo.depth);
 		}
-		image.data = logo_new;
-		fb_set_logo(info, logo, logo_new, fb_logo.depth);
-	}
 
-	if (fb_center_logo) {
-		int xres = info->var.xres;
-		int yres = info->var.yres;
+		if (fb_center_logo) {
+			int xres = info->var.xres;
+			int yres = info->var.yres;
 
-		if (rotate == FB_ROTATE_CW || rotate == FB_ROTATE_CCW) {
-			xres = info->var.yres;
-			yres = info->var.xres;
-		}
+			if (rotate == FB_ROTATE_CW || rotate == FB_ROTATE_CCW) {
+				xres = info->var.yres;
+				yres = info->var.xres;
+			}
 
-		while (n && (n * (logo->width + 8) - 8 > xres))
-			--n;
-		image.dx = (xres - (n * (logo->width + 8) - 8)) / 2;
-		image.dy = y ?: (yres - logo->height) / 2;
-	} else {
-		image.dx = 0;
-		image.dy = y;
-	}
+			while (n && (n * (logo->width + 8) - 8 > xres))
+				--n;
+			image.dx = (xres - (n * (logo->width + 8) - 8)) / 2;
+			image.dy = y ?: (yres - logo->height) / 2;
+		} else {
+			image.dx = 0;
+			image.dy = y;
+		}
 
-	image.width = logo->width;
-	image.height = logo->height;
+		image.width = logo->width;
+		image.height = logo->height;
 
-	if (rotate) {
-		logo_rotate = kmalloc_array(logo->width, logo->height,
-					    GFP_KERNEL);
-		if (logo_rotate)
-			fb_rotate_logo(info, logo_rotate, &image, rotate);
+		if (rotate) {
+			logo_rotate = kmalloc_array(logo->width, logo->height,
+							GFP_KERNEL);
+			if (logo_rotate)
+				fb_rotate_logo(info, logo_rotate, &image, rotate);
+		}
+	}
+	if (fullscreen_logo_enabled) {
+		// Fullscreen logo data may not fill screen
+		// Fill remainder of screen with border color of logo for continuous feel
+		u32 fill_color = image.data[0];
+		struct fb_fillrect region;
+
+		region.color = fill_color;
+		region.dx = 0;
+		region.dy = 0;
+		region.width = info->var.xres;
+		region.height = info->var.yres;
+		region.rop = ROP_COPY;
+		info->fbops->fb_fillrect(info, &region);
 	}
 
 	fb_do_show_logo(info, &image, rotate, n);

drivers/video/fbdev/core/fbcon.c

@@ -107,6 +107,7 @@ static struct fbcon_display fb_display[MAX_NR_CONSOLES];
 
 static struct fb_info *fbcon_registered_fb[FB_MAX];
 static int fbcon_num_registered_fb;
+static int fullscreen_logo_enabled __initdata;
 
 #define fbcon_for_each_registered_fb(i)		\
 	for (i = 0; WARN_CONSOLE_UNLOCKED(), i < FB_MAX; i++)		\
@@ -510,6 +511,15 @@ static int __init fb_console_setup(char *this_opt)
 }
 
 __setup("fbcon=", fb_console_setup);
+
+static int __init fullscreen_logo_setup(char *str)
+{
+	pr_info("Fullscreen Logo Enabled");
+	fullscreen_logo_enabled = 1;
+	return 1;
+}
+
+__setup("fullscreen_logo=", fullscreen_logo_setup);
 #endif
 
 static int search_fb_in_map(int idx)
@@ -593,6 +603,8 @@ static void fbcon_prepare_logo(struct vc_data *vc, struct fb_info *info,
 	if (fb_get_color_depth(&info->var, &info->fix) == 1)
 		erase &= ~0x400;
 	logo_height = fb_prepare_logo(info, ops->rotate);
+	if (fullscreen_logo_enabled)
+		logo_height = info->var.yres - vc->vc_font.height;
 	logo_lines = DIV_ROUND_UP(logo_height, vc->vc_font.height);
 	q = (unsigned short *) (vc->vc_origin +
 				vc->vc_size_row * rows);