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, fullscreen at boot
Any remaining space is filled with solid color from the image border.
If TGA file is too big, image is clipped accordingly

Author: Ben Benson

drivers/video/fbdev/core/fb_logo.c

@@ -2,11 +2,21 @@
 
 #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;
+typedef long ImagePalette[224][3];
 
 static inline unsigned int safe_shift(unsigned int d, int n)
 {
@@ -79,6 +89,19 @@ static void  fb_set_logo_truepalette(struct fb_info *info,
 	}
 }
 
+static void fb_set_logo_RGB_palette(ImagePalette 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[i][0]) >> 3) << 11) | ((((uint16_t)palette[i][1]) >> 2) << 5) | (((uint16_t)palette[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 +298,162 @@ 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(ImagePalette palette, int num_existing_rows, long *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[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) {
+	ImagePalette 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) {
+			pr_info("Failed to allocate memory for fullscreen logo");
+			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;
+				}
+				long B = (unsigned char)*current_ptr++;
+				long G = (unsigned char)*current_ptr++;
+				long R = (unsigned char)*current_ptr++;
+				long 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[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((unsigned int)width, info->var.xres);
+	image->height = min((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,6 +467,11 @@ static int fb_show_logo_line(struct fb_info *info, int rotate,
 	    info->fbops->owner)
 		return 0;
 
+	
+	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;
 
@@ -350,6 +534,21 @@ static int fb_show_logo_line(struct fb_info *info, int 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);
 
 	kfree(palette);

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){
+	printk(KERN_ALERT "Fullscreen Logo Setup within FBCON");
+	fullscreen_logo_enabled = 1;
+	printk(KERN_ALERT "Fullscreen Logo Enabled (FBCON): %d", fullscreen_logo_enabled);
+	return 1;
+}
+
+__setup("fullscreen_logo=", fullscreen_logo_setup);
 #endif
 
 static int search_fb_in_map(int idx)
@@ -593,6 +603,9 @@ 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);