src/lib/render_bmp.c

/* SPDX-License-Identifier: GPL-2.0-or-later */

#include <boot/coreboot_tables.h>
#include <bootmode.h>
#include <bootsplash.h>
#include <bootstate.h>
#include <console/console.h>
#include <stdlib.h>
#include <string.h>

#include "render_bmp.h"

static bool is_bmp_image_valid(struct bmp_image_header *header)
{
	/* Check if the BMP Header Signature is valid */
	if (header->CharB != 'B' || header->CharM != 'M')
		return false;

	/* Check if the BMP Image Header Length is valid */
	if (!header->PixelHeight || !header->PixelWidth)
		return false;

	if (header->Size < header->ImageOffset)
		return false;

	if (header->ImageOffset < sizeof(struct bmp_image_header))
		return false;

	return true;
}

static bool is_bmp_image_compressed(struct bmp_image_header *header)
{
	return header->CompressionType != 0;
}

static bool is_bitmap_format_supported(struct bmp_image_header *header)
{
	/*
	 * Check BITMAP format is supported
	 * BMP_IMAGE_HEADER = BITMAP_FILE_HEADER + BITMAP_INFO_HEADER
	 */
	if (header->HeaderSize != sizeof(struct bmp_image_header) -
			 OFFSET_OF(struct bmp_image_header, HeaderSize))
		return false;

	return true;
}

static bool do_bmp_image_authentication(struct bmp_image_header *header)
{
	if (!is_bmp_image_valid(header)) {
		printk(BIOS_ERR, "%s: BMP Image Header is invalid.\n", __func__);
		return false;
	}

	/*
	 * BMP image compression is unsupported by FSP implementation,
	 * hence, exit if the BMP image is compressed.
	 */
	if (is_bmp_image_compressed(header)) {
		printk(BIOS_ERR, "%s: BMP Image Compression is unsupported.\n", __func__);
		return false;
	}

	if (!is_bitmap_format_supported(header)) {
		printk(BIOS_ERR, "%s: BmpHeader Header Size (0x%x) is not as expected.\n",
			 __func__, header->HeaderSize);
		return false;
	}

	return true;
}

static uint32_t calculate_blt_buffer_size(struct bmp_image_header *header)
{
	uint32_t blt_buffer_size;

	/* Calculate the size required for BLT buffer */
	blt_buffer_size = header->PixelWidth * header->PixelHeight *
			 sizeof(struct blt_pixel);
	if (!blt_buffer_size)
		return 0;

	return blt_buffer_size;
}

static int get_color_map_num(struct bmp_image_header *header)
{
	int col_map_number;

	switch (header->BitPerPixel) {
	case 1:
		col_map_number = 2;
		break;
	case 4:
		col_map_number = 16;
		break;
	case 8:
		col_map_number = 256;
		break;
	default:
		/*
		 * For other bit depths (e.g., 24-bit and 32-bit) that doesn't have
		 * a standard palette, col_map_number remains 0.
		 */
		col_map_number = 0;
		break;
	}

	/*
	 * At times BMP file may have padding data between its header section and the
	 * data section.
	 */
	if (header->ImageOffset - sizeof(struct bmp_image_header) <
			 sizeof(struct bmp_color_map) * col_map_number)
		return -1;

	return col_map_number;
}

/*
 * Visual Representation of the Flipping:
 *
 * Original BMP Image:
 *
 *      0 -----------------------------------------PixelWidth-1
 *      |                                          |
 *      |                                          |
 *      |                                          |
 *      PixelHeight-1------------------------------|
 *
 * Blitting Region:
 *
 *      (x, y) ----------------------------------- (x + blt_width, y)
 *      |                                          |
 *      |                                          |
 *      (x, y + blt_height) -------------------- --(x + blt_width, y + blt_height)
 *
 * Flipped Coordinates:
 *
 * flipped_x:  Represents the horizontal coordinate from the `right` edge of the BMP,
 *             accounting for the blit width.
 *
 * flipped_y:  Represents the vertical coordinate from the `bottom` edge of the BMP,
 *             accounting for the blit height.
 *
 * Example (Orientation: LB_FB_ORIENTATION_BOTTOM_UP):
 *
 * If blt_width is small, flipped_x will be near PixelWidth.
 * If blt_height is small, flipped_y will be near PixelHeight.
 *
 * The blit then starts at (flipped_x, blt_height), effectively flipping the
 * horizontal position and using the original blit height.
 *
 * This allows for blitting from the bottom-left corner of the display panel.
 */
static bool calculate_adj_height_width(const struct bmp_image_header *header, size_t *adjusted_x,
	 size_t *adjusted_y, enum lb_fb_orientation orientation, int blt_width, int blt_height)
{
	size_t flipped_x = header->PixelWidth - blt_width - 1;
	size_t flipped_y = header->PixelHeight - blt_height - 1;

	switch (orientation) {
	case LB_FB_ORIENTATION_LEFT_UP:
		*adjusted_x = flipped_y;
		*adjusted_y = flipped_x;
		break;

	case LB_FB_ORIENTATION_BOTTOM_UP:
		*adjusted_x = flipped_x;
		*adjusted_y = blt_height;
		break;

	case LB_FB_ORIENTATION_RIGHT_UP:
		*adjusted_x = blt_height;
		*adjusted_y = blt_width;
		break;

	case LB_FB_ORIENTATION_NORMAL:
	default:
		*adjusted_x = blt_width;
		*adjusted_y = flipped_y;
		break;
	}

	return true;
}

/*
 * Visual Representation of gop_width and calculate linear offset into the GOP buffer:
 *
 * GOP Display Buffer:
 *
 *      +------------------------------------------------+
 *      | 0                                              |
 *      | |--> gop_width pixels in this row              |
 *      +------------------------------------------------+
 *      | gop_width                                      |
 *      |                                                |
 *      | gop_width                                      |
 *      | ...                                            |
 *      +------------------------------------------------+
 *      | gop_width                                      |
 *      +------------------------------------------------+
 *
 * gop_width: Represents the width of a row in the GOP buffer.
 * - It is determined by the `orientation` of the image.
 * - For `LEFT_UP` and `RIGHT_UP`, the GOP width is the BMP image's `PixelHeight`.
 * - For `BOTTOM_UP` and `NORMAL`, the GOP width is the BMP image's `PixelWidth`.
 *
 * gop_x, gop_y: Coordinates within the GOP buffer where the blit will start.
 * - These are calculated by `calculate_adj_height_width` based on the `orientation`,
 * `blt_width`, and `blt_height`.
 *
 * Pointer to the calculated pixel in the GOP blit buffer, or NULL on error.
 * - Calculate `gop_blt_offset`as `gop_y * gop_width + gop_x` to determine the offset
 *   to access the correct pixel within `gop_blt_buffer`.
 * - `gop_y * gop_width` calculates the offset of the row.
 * - `gop_x` calculates the offset within that row.
 */
static struct blt_pixel *get_gop_blt_pixel(
	struct blt_pixel *gop_blt_buffer, const struct bmp_image_header *header,
	 int blt_width, int blt_height, enum lb_fb_orientation orientation)
{
	size_t gop_x;
	size_t gop_y;
	size_t gop_width;

	switch (orientation) {
	case LB_FB_ORIENTATION_LEFT_UP:
	case LB_FB_ORIENTATION_RIGHT_UP:
		gop_width = header->PixelHeight;
		break;

	case LB_FB_ORIENTATION_BOTTOM_UP:
	case LB_FB_ORIENTATION_NORMAL:
	default:
		gop_width = header->PixelWidth;
		break;
	}

	if (!calculate_adj_height_width(header, &gop_x, &gop_y, orientation,
			 blt_width, blt_height))
		return NULL;

	/*
	 * Calculated pixel in the Graphics Output Protocol (GOP) blit buffer.
	 * This offset represents the starting position where the blitted region will be placed
	 * in the framebuffer.
	 */
	return &gop_blt_buffer[gop_y * gop_width + gop_x];
}

/*
 * Fill BMP image into BLT buffer format with optional orientation
 *
 * +------------------------------------------------------------------+
 * |  BMP Image (header: bmp_image_header)                        |
 * |  (PixelWidth, PixelHeight)                                       |
 * +------------------------------------------------------------------+
 *        |
 *        | (blt_width, blt_height) : Region to blit
 *        V
 * +------------------------------------------------------------------+
 * |  calculate_adj_height_width(header, adjusted_x, adjusted_y,      |
 * |                               orientation, blt_width, blt_height)|
 * +------------------------------------------------------------------+
 *        |
 *        | Calculates adjusted coordinates based on orientation:
 *        |   - flipped_x = header->PixelWidth - blt_width - 1
 *        |   - flipped_y = header->PixelHeight - blt_height - 1
 *        |   - Depending on 'orientation', adjusted_x and adjusted_y are set.
 *        V
 * +-------------------------------------------------------------------+
 * |  get_gop_blt_pixel(gop_blt_buffer, header, blt_width, blt_height, |
 * |                                                  orientation)     |
 * +-------------------------------------------------------------------+
 *        |
 *        | 1. Determines gop_width based on orientation:
 *        |    - LEFT_UP/RIGHT_UP: gop_width = header->PixelHeight,
 *        |    - BOTTOM_UP/NORMAL: gop_width = header->PixelWidth,
 *        | 2. Calls calculate_adj_height_width to get gop_x and gop_y.
 *        | 3. GOP BLT offset: calculates linear offset into the GOP buffer
 *        |    - gop_blt_offset = gop_y * gop_width + gop_x
 *        | 4. GOP BLT offset is used to access the correct regions in:
 *        V
 * +------------------------------------------------------------------+
 * |  GOP Blit Buffer (Framebuffer)                                   |
 * +------------------------------------------------------------------+
 */
static void *fill_blt_buffer(struct bmp_image_header *header,
	uintptr_t logo, size_t blt_buffer_size, enum lb_fb_orientation orientation)
{
	struct blt_pixel *gop_blt_buffer;
	struct blt_pixel *gop_blt_ptr;
	struct blt_pixel *gop_blt;
	uint8_t *bmp_image;
	uint8_t *bmp_header;
	struct bmp_color_map *color_map;
	size_t image_index;

	gop_blt_ptr = malloc(sizeof(blt_buffer_size));
	if (!gop_blt_ptr)
		die("%s: out of memory. Consider increasing the `CONFIG_HEAP_SIZE`\n",
			 __func__);

	bmp_image = ((uint8_t *)logo) + header->ImageOffset;
	bmp_header = bmp_image;
	gop_blt_buffer = gop_blt_ptr;
	color_map = (struct bmp_color_map *)(logo + sizeof(struct bmp_image_header));

	for (size_t height = 0; height < header->PixelHeight; height++) {
		for (size_t width = 0; width < header->PixelWidth; width++, bmp_image++) {
			size_t index = 0;

			gop_blt = get_gop_blt_pixel(gop_blt_buffer, header, width, height,
							 orientation);
			if (!gop_blt) {
				free(gop_blt_ptr);
				return NULL;
			}

			switch (header->BitPerPixel) {
			/* Translate 1-bit (2 colors) BMP to 24-bit color */
			case 1:
				for (index = 0; index < 8 && width < header->PixelWidth; index++) {
					uint8_t bit = ((*bmp_image) >> (7 - index)) & 0x1;
					gop_blt->Red = color_map[bit].Red;
					gop_blt->Green = color_map[bit].Green;
					gop_blt->Blue = color_map[bit].Blue;
					width++;
					gop_blt = get_gop_blt_pixel(gop_blt_buffer, header, width, height,
								 orientation);
					if (!gop_blt) {
						free(gop_blt_ptr);
						return NULL;
					}
				}
				width--;
				break;

			/* Translate 4-bit (16 colors) BMP Palette to 24-bit color */
			case 4:
				index = (*bmp_image) >> 4;
				gop_blt->Red = color_map[index].Red;
				gop_blt->Green = color_map[index].Green;
				gop_blt->Blue = color_map[index].Blue;
				if (width < (header->PixelWidth - 1)) {
					width++;
					gop_blt = get_gop_blt_pixel(gop_blt_buffer, header, width, height,
								 orientation);
					if (!gop_blt) {
						free(gop_blt_ptr);
						return NULL;
					}
					index = (*bmp_image) & 0x0f;
					gop_blt->Red = color_map[index].Red;
					gop_blt->Green = color_map[index].Green;
					gop_blt->Blue = color_map[index].Blue;
				}
				break;

			/* Translate 8-bit (256 colors) BMP Palette to 24-bit color */
			case 8:
				gop_blt->Red = color_map[*bmp_image].Red;
				gop_blt->Green = color_map[*bmp_image].Green;
				gop_blt->Blue = color_map[*bmp_image].Blue;
				break;

			/* For 24-bit BMP */
			case 24:
				gop_blt->Blue = *bmp_image++;
				gop_blt->Green = *bmp_image++;
				gop_blt->Red = *bmp_image;
				break;

			/* Convert 32 bit to 24bit bmp - just ignore the final byte of each pixel */
			case 32:
				gop_blt->Blue = *bmp_image++;
				gop_blt->Green = *bmp_image++;
				gop_blt->Red = *bmp_image++;
				break;

			/* Other bit format of BMP is not supported. */
			default:
				free(gop_blt_ptr);
				gop_blt_ptr = NULL;

				printk(BIOS_ERR, "%s, BMP Bit format not supported. 0x%X\n", __func__,
					 header->BitPerPixel);
				return NULL;
			}
		}
		image_index = (uintptr_t)bmp_image - (uintptr_t)bmp_header;
		/* Each row in BMP Image should be 4-byte align */
		if ((image_index % 4) != 0)
			bmp_image = bmp_image + (4 - (image_index % 4));
	}

	return gop_blt_ptr;
}

/* Helper function to perform the common BMP to GOP BLT conversion logic */
static bool convert_bmp_to_gop_blt_common(uintptr_t logo, size_t logo_size,
	uintptr_t *blt, size_t *blt_size, uint32_t *pixel_height,
	uint32_t *pixel_width, enum lb_fb_orientation orientation)
{
	size_t blt_buffer_size;
	struct bmp_image_header *bmp_header;

	bmp_header = (struct bmp_image_header *)logo;

	/* Authenticate BMP header and validate size against provided logo_size */
	if (!do_bmp_image_authentication(bmp_header) || (bmp_header->Size != logo_size))
		return false;

	blt_buffer_size = calculate_blt_buffer_size(bmp_header);
	if (!blt_buffer_size)
		return false;

	if (get_color_map_num(bmp_header) < 0)
		return false;

	bool is_standard_orientation = (orientation == LB_FB_ORIENTATION_NORMAL ||
					orientation == LB_FB_ORIENTATION_BOTTOM_UP);

	*blt_size = blt_buffer_size;
	*pixel_height = is_standard_orientation ? bmp_header->PixelHeight : bmp_header->PixelWidth;
	*pixel_width = is_standard_orientation ? bmp_header->PixelWidth : bmp_header->PixelHeight;
	*blt = (uintptr_t)fill_blt_buffer(bmp_header, logo, blt_buffer_size, orientation);

	return true;
}

/* Convert a *.BMP graphics image to a blt buffer */
void load_and_convert_bmp_to_blt(uintptr_t *logo, size_t *logo_size,
	uintptr_t *blt, size_t *blt_size, uint32_t *pixel_height, uint32_t *pixel_width,
	enum lb_fb_orientation orientation)
{
	uintptr_t bmp;
	size_t bmp_size;

	if (!logo || !logo_size || !blt || !blt_size || !pixel_height || !pixel_width)
		return;

	bmp = (uintptr_t)bmp_load_logo(&bmp_size);

	if (!bmp || bmp_size < sizeof(struct bmp_image_header))
		return;

	*logo = bmp;
	*logo_size = bmp_size;

	convert_bmp_to_gop_blt_common(*logo, *logo_size, blt, blt_size,
				      pixel_height, pixel_width, orientation);
}

/* Convert a *.BMP graphics image (as per input `logo`) to a GOP blt buffer */
void convert_bmp_to_blt(uintptr_t logo, size_t logo_size,
	uintptr_t *blt, size_t *blt_size, uint32_t *pixel_height, uint32_t *pixel_width,
	enum lb_fb_orientation orientation)
{
	if (!blt || !blt_size || !pixel_height || !pixel_width)
		return;

	if (!logo || logo_size < sizeof(struct bmp_image_header))
		return;

	convert_bmp_to_gop_blt_common(logo, logo_size, blt, blt_size,
				      pixel_height, pixel_width, orientation);
}

/*
 * Calculates the destination coordinates for the logo based on both horizontal and
 * vertical alignment settings.
 *
 * horizontal_resolution: The horizontal resolution of the display panel.
 * vertical_resolution: The vertical resolution of the display panel.
 * logo_width: The width of the logo bitmap.
 * logo_height: The height of the logo bitmap.
 * halignment: The horizontal alignment setting. Use FW_SPLASH_HALIGNMENT_NONE
 *             if only vertical alignment is specified.
 * valignment: The vertical alignment setting. Use FW_SPLASH_VALIGNMENT_NONE
 *             if only horizontal alignment is specified.
 *
 * Returning `struct logo_coordinates` that contains the calculated x and y coordinates
 * for rendering the logo.
 */
static struct logo_coordinates calculate_logo_coordinates(
	uint32_t horizontal_resolution, uint32_t vertical_resolution,
	uint32_t logo_width, uint32_t logo_height,
	enum fw_splash_horizontal_alignment halignment,
	enum fw_splash_vertical_alignment valignment)
{
	struct logo_coordinates coords;

	/* Calculate X coordinate */
	switch (halignment) {
	case FW_SPLASH_HALIGNMENT_LEFT:
		coords.x = 0;
		break;
	case FW_SPLASH_HALIGNMENT_RIGHT:
		coords.x = horizontal_resolution - logo_width;
		break;
	default: /* FW_SPLASH_HALIGNMENT_CENTER (default) */
		coords.x = (horizontal_resolution - logo_width) / 2;
		break;
	}

	/* Calculate Y coordinate */
	switch (valignment) {
	case FW_SPLASH_VALIGNMENT_MIDDLE:
		coords.y = vertical_resolution / 2;
		break;
	case FW_SPLASH_VALIGNMENT_TOP:
		coords.y = 0;
		break;
	case FW_SPLASH_VALIGNMENT_BOTTOM:
		coords.y = vertical_resolution - logo_height;
		break;
	default: /* FW_SPLASH_VALIGNMENT_CENTER (default) */
		coords.y = (vertical_resolution - logo_height) / 2;
		break;
	}

	return coords;
}

/*
 * Copies the logo to the framebuffer.
 *
 * framebuffer_base: The base address of the framebuffer.
 * bytes_per_scanline: The number of bytes per scanline in the framebuffer.
 * logo_buffer: The address of the logo data in BLT format.
 * logo_width: The width of the logo bitmap.
 * logo_height: The height of the logo bitmap.
 * dest_x: The destination x-coordinate in the framebuffer for rendering the logo.
 * dest_y: The destination y-coordinate in the framebuffer for rendering the logo.
 */
static void copy_logo_to_framebuffer(
	uintptr_t framebuffer_base, uint32_t bytes_per_scanline,
	uintptr_t logo_buffer, uint32_t logo_width, uint32_t logo_height,
	uint32_t dest_x, uint32_t dest_y)
{
	size_t pixel_size = sizeof(struct blt_pixel);
	size_t bytes_per_logo_line = logo_width * pixel_size;
	uint8_t *framebuffer_offset = (uint8_t *)framebuffer_base + dest_y * bytes_per_scanline
					 + dest_x * pixel_size;
	uint8_t *dst_row_address = framebuffer_offset;
	uint8_t *src_row_address = (uint8_t *)logo_buffer;
	for (uint32_t i = 0; i < logo_height; i++) {
		memcpy(dst_row_address, src_row_address, bytes_per_logo_line);
		dst_row_address += bytes_per_scanline;
		src_row_address += bytes_per_logo_line;
	}
}

/*
 * Adjust logo layout based on the panel orientation.
 *
 * logo_type: Logo type.
 * config: Logo configuration information.
 * logo_halignment: Resultant horizontal alignment setting.
 * logo_valignment: Resultant vertical alignment setting.
 * logo_bottom_margin: Resultant bottom margin.
 */
static void get_logo_layout(
	enum bootsplash_type logo_type,
	struct logo_config *config,
	enum fw_splash_horizontal_alignment *logo_halignment,
	enum fw_splash_vertical_alignment *logo_valignment,
	uint8_t *logo_bottom_margin
)
{
	if (!config || !logo_halignment || !logo_valignment || !logo_bottom_margin)
		return;

	if (logo_type == BOOTSPLASH_LOW_BATTERY || logo_type == BOOTSPLASH_CENTER) {
		*logo_halignment = config->halignment;
		*logo_valignment = config->valignment;
		/* Override logo alignment if the default screen orientation is not normal */
		if (config->panel_orientation != LB_FB_ORIENTATION_NORMAL)
			*logo_valignment = FW_SPLASH_VALIGNMENT_CENTER;
		*logo_bottom_margin = 0;
	} else if (logo_type == BOOTSPLASH_FOOTER) {
		*logo_halignment = FW_SPLASH_HALIGNMENT_CENTER;
		*logo_valignment = FW_SPLASH_VALIGNMENT_CENTER;
		switch (config->panel_orientation) {
		case LB_FB_ORIENTATION_RIGHT_UP:
			*logo_halignment = FW_SPLASH_HALIGNMENT_LEFT;
			break;
		case LB_FB_ORIENTATION_LEFT_UP:
			*logo_halignment = FW_SPLASH_HALIGNMENT_RIGHT;
			break;
		case LB_FB_ORIENTATION_BOTTOM_UP:
			*logo_valignment = FW_SPLASH_VALIGNMENT_TOP;
			break;
		default: /* LB_FB_ORIENTATION_NORMAL (default) */
			*logo_valignment = FW_SPLASH_VALIGNMENT_BOTTOM;
			break;
		}
		*logo_bottom_margin = config->logo_bottom_margin;
	} else { // Default values
		*logo_halignment = FW_SPLASH_HALIGNMENT_CENTER;
		*logo_valignment = FW_SPLASH_VALIGNMENT_CENTER;
		*logo_bottom_margin = 0;
	}
}

/*
 * Loads, converts, and renders a BMP logo to the framebuffer.
 *
 * logo_type: Logo type.
 * config: Logo configuration information.
 *
 * Returns 0 on success, -1 on failure.
 */
static int load_and_render_logo_to_framebuffer(
	enum bootsplash_type logo_type,
	struct logo_config *config
)
{
	uintptr_t logo;
	size_t logo_size;
	size_t blt_size;
	uintptr_t blt_buffer;
	uint32_t logo_height, logo_width;
	struct logo_coordinates logo_coords;
	enum fw_splash_horizontal_alignment halignment;
	enum fw_splash_vertical_alignment valignment;
	uint8_t logo_bottom_margin;

	if (!config)
		return -1;

	logo = (uintptr_t)bmp_load_logo_by_type(logo_type, &logo_size);

	if (!logo || logo_size < sizeof(struct bmp_image_header)) {
		printk(BIOS_ERR, "%s: BMP image (%zu) is less than expected minimum size (%zu).\n",
				 __func__, logo_size, sizeof(struct bmp_image_header));
		return -1;
	}

	convert_bmp_to_blt(logo, logo_size, &blt_buffer, &blt_size,
				   &logo_height, &logo_width, config->panel_orientation);

	get_logo_layout(logo_type, config, &halignment, &valignment, &logo_bottom_margin);

	logo_coords = calculate_logo_coordinates(config->horizontal_resolution,
		 config->vertical_resolution, logo_width, logo_height, halignment, valignment);

	if (logo_bottom_margin) {
		if (config->panel_orientation == LB_FB_ORIENTATION_BOTTOM_UP ||
				 config->panel_orientation == LB_FB_ORIENTATION_NORMAL)
			logo_coords.y -= logo_bottom_margin;
		else
			logo_coords.x -= logo_bottom_margin;
	}

	copy_logo_to_framebuffer(config->framebuffer_base, config->bytes_per_scanline, blt_buffer,
				 logo_width, logo_height, logo_coords.x, logo_coords.y);

	bmp_release_logo();

	return 0;
}

/*
 * Loads, converts, and renders a BMP logo to the framebuffer.
 * The logo type (primary or low battery etc.) is seletcted dynamically.
 *
 * config: Logo configuration information.
 *
 */
void render_logo_to_framebuffer(struct logo_config *config)
{
	if (!config)
		return;

	if (config->framebuffer_base == 0) {
		/* Try to load from already populated framebuffer information */
		struct lb_framebuffer framebuffer;
		memset(&framebuffer, 0, sizeof(struct lb_framebuffer));
		fill_lb_framebuffer(&framebuffer);
		/* Exit if framebuffer is still not available */
		if (framebuffer.physical_address == 0)
			return;
		config->framebuffer_base = framebuffer.physical_address;
		config->horizontal_resolution = framebuffer.x_resolution;
		config->vertical_resolution = framebuffer.y_resolution;
		config->bytes_per_scanline = framebuffer.bytes_per_line;
	}

	/*
	 * If the device is in low-battery mode and the low-battery splash screen is being
	 * displayed, prevent further operation and bail out early.
	 */
	if (platform_is_low_battery_shutdown_needed()) {
		if (load_and_render_logo_to_framebuffer(BOOTSPLASH_LOW_BATTERY, config) != 0) {
			printk(BIOS_ERR, "%s: Failed to render low-battery logo.\n", __func__);
		}
		return;
	}

	/* Render the main logo */
	if (load_and_render_logo_to_framebuffer(BOOTSPLASH_CENTER, config) != 0) {
		printk(BIOS_ERR, "%s: Failed to render main splash screen logo.\n", __func__);
	} else if (CONFIG(SPLASH_SCREEN_FOOTER)) {
		/* Render the footer logo */
		if (load_and_render_logo_to_framebuffer(BOOTSPLASH_FOOTER, config) != 0)
			printk(BIOS_ERR, "%s: Failed to render footer logo.\n", __func__);
	}
}

static void release_logo(void *arg_unused)
{
	bmp_release_logo();
}

BOOT_STATE_INIT_ENTRY(BS_PAYLOAD_LOAD, BS_ON_EXIT, release_logo, NULL);