// SPDX-License-Identifier: GPL-2.0
/*
 * Helper functions used by the EFI stub on multiple
 * architectures. This should be #included by the EFI stub
 * implementation files.
 *
 * Copyright 2011 Intel Corporation; author Matt Fleming
 */

#include <linux/efi.h>
#include <asm/efi.h>

#include "efistub.h"

#define MAX_FILENAME_SIZE	256

/*
 * Some firmware implementations have problems reading files in one go.
 * A read chunk size of 1MB seems to work for most platforms.
 *
 * Unfortunately, reading files in chunks triggers *other* bugs on some
 * platforms, so we provide a way to disable this workaround, which can
 * be done by passing "efi=nochunk" on the EFI boot stub command line.
 *
 * If you experience issues with initrd images being corrupt it's worth
 * trying efi=nochunk, but chunking is enabled by default on x86 because
 * there are far more machines that require the workaround than those that
 * break with it enabled.
 */
#define EFI_READ_CHUNK_SIZE	SZ_1M

struct finfo {
	efi_file_info_t info;
	efi_char16_t	filename[MAX_FILENAME_SIZE];
};

static efi_status_t efi_open_file(efi_file_protocol_t *volume,
				  struct finfo *fi,
				  efi_file_protocol_t **handle,
				  unsigned long *file_size,
				  bool silent)
{
	efi_guid_t info_guid = EFI_FILE_INFO_ID;
	efi_file_protocol_t *fh;
	unsigned long info_sz;
	efi_status_t status;

	status = volume->open(volume, &fh, fi->filename, EFI_FILE_MODE_READ, 0);
	if (status != EFI_SUCCESS) {
		if (!silent)
			efi_err("Failed to open file: %ls\n", fi->filename);
		return status;
	}

	info_sz = sizeof(struct finfo);
	status = fh->get_info(fh, &info_guid, &info_sz, fi);
	if (status != EFI_SUCCESS) {
		if (!silent)
			efi_err("Failed to get file info\n");
		fh->close(fh);
		return status;
	}

	*handle = fh;
	*file_size = fi->info.file_size;
	return EFI_SUCCESS;
}

static efi_status_t efi_open_volume(efi_loaded_image_t *image,
				    efi_file_protocol_t **fh)
{
	efi_guid_t fs_proto = EFI_FILE_SYSTEM_GUID;
	efi_simple_file_system_protocol_t *io;
	efi_status_t status;

	status = efi_bs_call(handle_protocol, image->device_handle, &fs_proto,
			     (void **)&io);
	if (status != EFI_SUCCESS) {
		efi_err("Failed to handle fs_proto\n");
		return status;
	}

	status = io->open_volume(io, fh);
	if (status != EFI_SUCCESS)
		efi_err("Failed to open volume\n");

	return status;
}

static int find_file_option(const efi_char16_t *cmdline, int cmdline_len,
			    const efi_char16_t *prefix, int prefix_size,
			    efi_char16_t *result, int result_len)
{
	int prefix_len = prefix_size / 2;
	bool found = false;
	int i;

	for (i = prefix_len; i < cmdline_len; i++) {
		if (!memcmp(&cmdline[i - prefix_len], prefix, prefix_size)) {
			found = true;
			break;
		}
	}

	if (!found)
		return 0;

	/* Skip any leading slashes */
	while (i < cmdline_len && (cmdline[i] == L'/' || cmdline[i] == L'\\'))
		i++;

	while (--result_len > 0 && i < cmdline_len) {
		efi_char16_t c = cmdline[i++];

		if (c == L'\0' || c == L'\n' || c == L' ')
			break;
		else if (c == L'/')
			/* Replace UNIX dir separators with EFI standard ones */
			*result++ = L'\\';
		else
			*result++ = c;
	}
	*result = L'\0';
	return i;
}

/*
 * Check the cmdline for a LILO-style file= arguments.
 *
 * We only support loading a file from the same filesystem as
 * the kernel image.
 */
efi_status_t handle_cmdline_files(efi_loaded_image_t *image,
				  const efi_char16_t *optstr,
				  int optstr_size,
				  unsigned long soft_limit,
				  unsigned long hard_limit,
				  unsigned long *load_addr,
				  unsigned long *load_size)
{
	const efi_char16_t *cmdline = image->load_options;
	int cmdline_len = image->load_options_size;
	unsigned long efi_chunk_size = ULONG_MAX;
	efi_file_protocol_t *volume = NULL;
	efi_file_protocol_t *file;
	unsigned long alloc_addr;
	unsigned long alloc_size;
	efi_status_t status;
	int offset;

	if (!load_addr || !load_size)
		return EFI_INVALID_PARAMETER;

	efi_apply_loadoptions_quirk((const void **)&cmdline, &cmdline_len);
	cmdline_len /= sizeof(*cmdline);

	if (IS_ENABLED(CONFIG_X86) && !efi_nochunk)
		efi_chunk_size = EFI_READ_CHUNK_SIZE;

	alloc_addr = alloc_size = 0;
	do {
		struct finfo fi;
		unsigned long size;
		void *addr;

		offset = find_file_option(cmdline, cmdline_len,
					  optstr, optstr_size,
					  fi.filename, ARRAY_SIZE(fi.filename));

		if (!offset)
			break;

		cmdline += offset;
		cmdline_len -= offset;

		if (!volume) {
			status = efi_open_volume(image, &volume);
			if (status != EFI_SUCCESS)
				return status;
		}

		status = efi_open_file(volume, &fi, &file, &size, false);
		if (status != EFI_SUCCESS)
			goto err_close_volume;

		/*
		 * Check whether the existing allocation can contain the next
		 * file. This condition will also trigger naturally during the
		 * first (and typically only) iteration of the loop, given that
		 * alloc_size == 0 in that case.
		 */
		if (round_up(alloc_size + size, EFI_ALLOC_ALIGN) >
		    round_up(alloc_size, EFI_ALLOC_ALIGN)) {
			unsigned long old_addr = alloc_addr;

			status = EFI_OUT_OF_RESOURCES;
			if (soft_limit < hard_limit)
				status = efi_allocate_pages(alloc_size + size,
							    &alloc_addr,
							    soft_limit);
			if (status == EFI_OUT_OF_RESOURCES)
				status = efi_allocate_pages(alloc_size + size,
							    &alloc_addr,
							    hard_limit);
			if (status != EFI_SUCCESS) {
				efi_err("Failed to allocate memory for files\n");
				goto err_close_file;
			}

			if (old_addr != 0) {
				/*
				 * This is not the first time we've gone
				 * around this loop, and so we are loading
				 * multiple files that need to be concatenated
				 * and returned in a single buffer.
				 */
				memcpy((void *)alloc_addr, (void *)old_addr, alloc_size);
				efi_free(alloc_size, old_addr);
			}
		}

		addr = (void *)alloc_addr + alloc_size;
		alloc_size += size;

		while (size) {
			unsigned long chunksize = min(size, efi_chunk_size);

			status = file->read(file, &chunksize, addr);
			if (status != EFI_SUCCESS) {
				efi_err("Failed to read file\n");
				goto err_close_file;
			}
			addr += chunksize;
			size -= chunksize;
		}
		file->close(file);
	} while (offset > 0);

	*load_addr = alloc_addr;
	*load_size = alloc_size;

	if (volume)
		volume->close(volume);
	return EFI_SUCCESS;

err_close_file:
	file->close(file);

err_close_volume:
	volume->close(volume);
	efi_free(alloc_size, alloc_addr);
	return status;
}

static efi_status_t avm_build_dtb_name_for(int hwrev, int hwsubrev,
					   efi_char16_t *path, size_t size)
{
	char apath[40];
	int len;

	len = snprintf(apath, sizeof(apath), "efi\\boot\\Fritz_Box_HW%u-%u.dtb",
		       hwrev, hwsubrev);

	if (len >= min(size, sizeof(apath)))
		return EFI_BUFFER_TOO_SMALL;

	for (; len >= 0; --len)
		path[len] = apath[len];

	return EFI_SUCCESS;
}

/*
 * Check the efi/boot folder for a suitable DTB and load it.
 *
 * If no DTB filename matches the HW-Subrevision, it will look up DTBs for
 * older subrevisions. If none is found, the function fails.
 */
efi_status_t avm_get_dtb_setup_data(efi_loaded_image_t *image,
				    struct setup_data **dtb_setup_data)
{
	unsigned long dtb_size, size, efi_varsiz;
	efi_file_protocol_t *volume, *dtb_file;
	struct setup_data *setup_data;
	efi_status_t status;
	int hwrev, hwsubrev;
	struct finfo fi;
	u8 efi_var[16];
	ssize_t len;
	__u8 *data;

	if (!dtb_setup_data)
		return EFI_INVALID_PARAMETER;

	efi_varsiz = sizeof(efi_var) - 1;
	status = get_efi_var(L"HWRevision", &EFI_AVM_VARIABLE_GUID, NULL,
			     &efi_varsiz, efi_var);
	if (status != EFI_SUCCESS) {
		efi_err("Error reading EFI variable: %d\n", status);
		return status;
	}

	efi_var[efi_varsiz] = '\0';
	hwrev = simple_strtol(efi_var, NULL, 10);

	efi_varsiz = sizeof(efi_var) - 1;
	status = get_efi_var(L"HWSubRevision", &EFI_AVM_VARIABLE_GUID, NULL,
			     &efi_varsiz, efi_var);
	if (status != EFI_SUCCESS)
		return status;

	efi_var[efi_varsiz] = '\0';
	hwsubrev = simple_strtol(efi_var, NULL, 10);

	status = efi_open_volume(image, &volume);
	if (status != EFI_SUCCESS)
		return status;

	for (;;) {
		status = avm_build_dtb_name_for(hwrev, hwsubrev, fi.filename,
						ARRAY_SIZE(fi.filename));
		if (status != EFI_SUCCESS)
			return status;

		status = efi_open_file(volume, &fi, &dtb_file, &dtb_size, true);
		if (status == EFI_SUCCESS)
			break;

		if (hwsubrev-- == 0) {
			efi_puts("No DTB found\n");
			return EFI_NOT_FOUND;
		}
	}

	efi_puts("DTB found: ");
	efi_char16_puts(fi.filename);
	efi_puts("\n");

	status = efi_allocate_pages(dtb_size + sizeof(struct setup_data),
				    (unsigned long *)&setup_data, ULONG_MAX);
	if (status != EFI_SUCCESS) {
		efi_err("Failed to alloc pages for setup_data: %d\n", status);
		goto close_dtb_file;
	}

	data = setup_data->data;
	size = dtb_size;
	while (size) {
		unsigned long chunksize = ULONG_MAX;

		if (IS_ENABLED(CONFIG_X86) && !efi_nochunk)
			chunksize = EFI_READ_CHUNK_SIZE;

		status = dtb_file->read(dtb_file, &chunksize, data);
		if (status != EFI_SUCCESS) {
			efi_err("Failed to read dtb file: %d\n", status);
			goto free_setup_data;
		}
		data += chunksize;
		size -= chunksize;
	}

	dtb_file->close(dtb_file);

	setup_data->type = SETUP_DTB;
	setup_data->len = (__u32)dtb_size;
	*dtb_setup_data = setup_data;

	return status;

free_setup_data:
	efi_free(dtb_size + sizeof(struct setup_data), (unsigned long)setup_data);
close_dtb_file:
	dtb_file->close(dtb_file);
	return status;
}