[J-u-boot.git] / boot / bootflow_menu.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Provide a menu of available bootflows and related options
 *
 * Copyright 2022 Google LLC
 * Written by Simon Glass <[email protected]>
 */

#define LOG_CATEGORY UCLASS_BOOTSTD

#include <bootflow.h>
#include <bootmeth.h>
#include <bootstd.h>
#include <cli.h>
#include <dm.h>
#include <expo.h>
#include <malloc.h>
#include <menu.h>
#include <video_console.h>
#include <watchdog.h>
#include <linux/delay.h>
#include "bootflow_internal.h"

/**
 * struct menu_priv - information about the menu
 *
 * @num_bootflows: Number of bootflows in the menu
 */
struct menu_priv {
	int num_bootflows;
};

int bootflow_menu_new(struct expo **expp)
{
	struct udevice *last_bootdev;
	struct scene_obj_menu *menu;
	struct menu_priv *priv;
	struct bootflow *bflow;
	struct scene *scn;
	struct expo *exp;
	void *logo;
	int ret, i;

	priv = calloc(1, sizeof(*priv));
	if (!priv)
		return log_msg_ret("prv", -ENOMEM);

	ret = expo_new("bootflows", priv, &exp);
	if (ret)
		return log_msg_ret("exp", ret);

	ret = scene_new(exp, "main", MAIN, &scn);
	if (ret < 0)
		return log_msg_ret("scn", ret);

	ret |= scene_txt_str(scn, "prompt", OBJ_PROMPT, STR_PROMPT,
			     "UP and DOWN to choose, ENTER to select", NULL);

	ret = scene_menu(scn, "main", OBJ_MENU, &menu);
	ret |= scene_obj_set_pos(scn, OBJ_MENU, MARGIN_LEFT, 100);
	ret |= scene_txt_str(scn, "title", OBJ_MENU_TITLE, STR_MENU_TITLE,
			     "U-Boot - Boot Menu", NULL);
	ret |= scene_menu_set_title(scn, OBJ_MENU, OBJ_PROMPT);

	logo = video_get_u_boot_logo();
	if (logo) {
		ret |= scene_img(scn, "ulogo", OBJ_U_BOOT_LOGO, logo, NULL);
		ret |= scene_obj_set_pos(scn, OBJ_U_BOOT_LOGO, -4, 4);
	}

	ret |= scene_txt_str(scn, "cur_item", OBJ_POINTER, STR_POINTER, ">",
			     NULL);
	ret |= scene_menu_set_pointer(scn, OBJ_MENU, OBJ_POINTER);
	if (ret < 0)
		return log_msg_ret("new", -EINVAL);

	last_bootdev = NULL;
	for (ret = bootflow_first_glob(&bflow), i = 0; !ret && i < 36;
	     ret = bootflow_next_glob(&bflow), i++) {
		struct bootmeth_uc_plat *ucp;
		char str[2], *label, *key;
		uint preview_id;
		bool add_gap;

		if (bflow->state != BOOTFLOWST_READY)
			continue;

		/* No media to show for BOOTMETHF_GLOBAL bootmeths */
		ucp = dev_get_uclass_plat(bflow->method);
		if (ucp->flags & BOOTMETHF_GLOBAL)
			continue;

		*str = i < 10 ? '0' + i : 'A' + i - 10;
		str[1] = '\0';
		key = strdup(str);
		if (!key)
			return log_msg_ret("key", -ENOMEM);
		label = strdup(dev_get_parent(bflow->dev)->name);
		if (!label) {
			free(key);
			return log_msg_ret("nam", -ENOMEM);
		}

		add_gap = last_bootdev != bflow->dev;
		last_bootdev = bflow->dev;

		ret = expo_str(exp, "prompt", STR_POINTER, ">");
		ret |= scene_txt_str(scn, "label", ITEM_LABEL + i,
				      STR_LABEL + i, label, NULL);
		ret |= scene_txt_str(scn, "desc", ITEM_DESC + i, STR_DESC + i,
				    bflow->os_name ? bflow->os_name :
				    bflow->name, NULL);
		ret |= scene_txt_str(scn, "key", ITEM_KEY + i, STR_KEY + i, key,
				      NULL);
		preview_id = 0;
		if (bflow->logo) {
			preview_id = ITEM_PREVIEW + i;
			ret |= scene_img(scn, "preview", preview_id,
					     bflow->logo, NULL);
		}
		ret |= scene_menuitem(scn, OBJ_MENU, "item", ITEM + i,
					  ITEM_KEY + i, ITEM_LABEL + i,
					  ITEM_DESC + i, preview_id,
					  add_gap ? SCENEMIF_GAP_BEFORE : 0,
					  NULL);

		if (ret < 0)
			return log_msg_ret("itm", -EINVAL);
		priv->num_bootflows++;
	}

	ret = scene_arrange(scn);
	if (ret)
		return log_msg_ret("arr", ret);

	*expp = exp;

	return 0;
}

int bootflow_menu_apply_theme(struct expo *exp, ofnode node)
{
	struct menu_priv *priv = exp->priv;
	struct scene *scn;
	u32 font_size;
	int ret;

	log_debug("Applying theme %s\n", ofnode_get_name(node));
	scn = expo_lookup_scene_id(exp, MAIN);
	if (!scn)
		return log_msg_ret("scn", -ENOENT);

	/* Avoid error-checking optional items */
	if (!ofnode_read_u32(node, "font-size", &font_size)) {
		int i;

		log_debug("font size %d\n", font_size);
		scene_txt_set_font(scn, OBJ_PROMPT, NULL, font_size);
		scene_txt_set_font(scn, OBJ_POINTER, NULL, font_size);
		for (i = 0; i < priv->num_bootflows; i++) {
			ret = scene_txt_set_font(scn, ITEM_DESC + i, NULL,
						 font_size);
			if (ret)
				return log_msg_ret("des", ret);
			scene_txt_set_font(scn, ITEM_KEY + i, NULL, font_size);
			scene_txt_set_font(scn, ITEM_LABEL + i, NULL,
					   font_size);
		}
	}

	ret = scene_arrange(scn);
	if (ret)
		return log_msg_ret("arr", ret);

	return 0;
}

int bootflow_menu_run(struct bootstd_priv *std, bool text_mode,
		      struct bootflow **bflowp)
{
	struct cli_ch_state s_cch, *cch = &s_cch;
	struct bootflow *sel_bflow;
	struct udevice *dev;
	struct expo *exp;
	uint sel_id;
	bool done;
	int ret;

	cli_ch_init(cch);

	sel_bflow = NULL;
	*bflowp = NULL;

	ret = bootflow_menu_new(&exp);
	if (ret)
		return log_msg_ret("exp", ret);

	if (ofnode_valid(std->theme)) {
		ret = bootflow_menu_apply_theme(exp, std->theme);
		if (ret)
			return log_msg_ret("thm", ret);
	}

	/* For now we only support a video console */
	ret = uclass_first_device_err(UCLASS_VIDEO, &dev);
	if (ret)
		return log_msg_ret("vid", ret);
	ret = expo_set_display(exp, dev);
	if (ret)
		return log_msg_ret("dis", ret);

	ret = expo_set_scene_id(exp, MAIN);
	if (ret)
		return log_msg_ret("scn", ret);

	if (text_mode)
		expo_set_text_mode(exp, text_mode);

	done = false;
	do {
		struct expo_action act;
		int ichar, key;

		ret = expo_render(exp);
		if (ret)
			break;

		ichar = cli_ch_process(cch, 0);
		if (!ichar) {
			while (!ichar && !tstc()) {
				schedule();
				mdelay(2);
				ichar = cli_ch_process(cch, -ETIMEDOUT);
			}
			if (!ichar) {
				ichar = getchar();
				ichar = cli_ch_process(cch, ichar);
			}
		}

		key = 0;
		if (ichar) {
			key = bootmenu_conv_key(ichar);
			if (key == BKEY_NONE)
				key = ichar;
		}
		if (!key)
			continue;

		ret = expo_send_key(exp, key);
		if (ret)
			break;

		ret = expo_action_get(exp, &act);
		if (!ret) {
			switch (act.type) {
			case EXPOACT_SELECT:
				sel_id = act.select.id;
				done = true;
				break;
			case EXPOACT_QUIT:
				done = true;
				break;
			default:
				break;
			}
		}
	} while (!done);

	if (ret)
		return log_msg_ret("end", ret);

	if (sel_id) {
		struct bootflow *bflow;
		int i;

		for (ret = bootflow_first_glob(&bflow), i = 0; !ret && i < 36;
		     ret = bootflow_next_glob(&bflow), i++) {
			if (i == sel_id - ITEM) {
				sel_bflow = bflow;
				break;
			}
		}
	}

	expo_destroy(exp);

	if (!sel_bflow)
		return -EAGAIN;
	*bflowp = sel_bflow;

	return 0;
}
Commit	Line	Data
02d929bf SG	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Provide a menu of available bootflows and related options
	4	*
	5	* Copyright 2022 Google LLC
	6	* Written by Simon Glass <[email protected]>
	7	*/
	8
	9	#define LOG_CATEGORY UCLASS_BOOTSTD
	10
02d929bf	11	#include <bootflow.h>
05b9665f	12	#include <bootmeth.h>
02d929bf SG	13	#include <bootstd.h>
	14	#include <cli.h>
	15	#include <dm.h>
	16	#include <expo.h>
	17	#include <malloc.h>
	18	#include <menu.h>
	19	#include <video_console.h>
	20	#include <watchdog.h>
	21	#include <linux/delay.h>
	22	#include "bootflow_internal.h"
	23
	24	/**
	25	* struct menu_priv - information about the menu
	26	*
	27	* @num_bootflows: Number of bootflows in the menu
	28	*/
	29	struct menu_priv {
	30	int num_bootflows;
	31	};
	32
	33	int bootflow_menu_new(struct expo **expp)
	34	{
	35	struct udevice *last_bootdev;
	36	struct scene_obj_menu *menu;
	37	struct menu_priv *priv;
	38	struct bootflow *bflow;
	39	struct scene *scn;
	40	struct expo *exp;
	41	void *logo;
	42	int ret, i;
	43
	44	priv = calloc(1, sizeof(*priv));
	45	if (!priv)
	46	return log_msg_ret("prv", -ENOMEM);
	47
	48	ret = expo_new("bootflows", priv, &exp);
	49	if (ret)
	50	return log_msg_ret("exp", ret);
	51
	52	ret = scene_new(exp, "main", MAIN, &scn);
	53	if (ret < 0)
	54	return log_msg_ret("scn", ret);
	55
	56	ret \|= scene_txt_str(scn, "prompt", OBJ_PROMPT, STR_PROMPT,
	57	"UP and DOWN to choose, ENTER to select", NULL);
	58
	59	ret = scene_menu(scn, "main", OBJ_MENU, &menu);
	60	ret \|= scene_obj_set_pos(scn, OBJ_MENU, MARGIN_LEFT, 100);
	61	ret \|= scene_txt_str(scn, "title", OBJ_MENU_TITLE, STR_MENU_TITLE,
	62	"U-Boot - Boot Menu", NULL);
	63	ret \|= scene_menu_set_title(scn, OBJ_MENU, OBJ_PROMPT);
	64
	65	logo = video_get_u_boot_logo();
	66	if (logo) {
	67	ret \|= scene_img(scn, "ulogo", OBJ_U_BOOT_LOGO, logo, NULL);
	68	ret \|= scene_obj_set_pos(scn, OBJ_U_BOOT_LOGO, -4, 4);
	69	}
	70
	71	ret \|= scene_txt_str(scn, "cur_item", OBJ_POINTER, STR_POINTER, ">",
	72	NULL);
	73	ret \|= scene_menu_set_pointer(scn, OBJ_MENU, OBJ_POINTER);
	74	if (ret < 0)
	75	return log_msg_ret("new", -EINVAL);
	76
77	last_bootdev = NULL;
78	for (ret = bootflow_first_glob(&bflow), i = 0; !ret && i < 36;
79	ret = bootflow_next_glob(&bflow), i++) {
05b9665f	80	struct bootmeth_uc_plat *ucp;
02d929bf SG	81	char str[2], label, key;
	82	uint preview_id;
	83	bool add_gap;
	84
	85	if (bflow->state != BOOTFLOWST_READY)
	86	continue;
	87
05b9665f QS	88	/* No media to show for BOOTMETHF_GLOBAL bootmeths */
	89	ucp = dev_get_uclass_plat(bflow->method);
	90	if (ucp->flags & BOOTMETHF_GLOBAL)
	91	continue;
	92
02d929bf SG	93	*str = i < 10 ? '0' + i : 'A' + i - 10;
	94	str[1] = '\0';
	95	key = strdup(str);
	96	if (!key)
	97	return log_msg_ret("key", -ENOMEM);
	98	label = strdup(dev_get_parent(bflow->dev)->name);
	99	if (!label) {
	100	free(key);
	101	return log_msg_ret("nam", -ENOMEM);
	102	}
	103
	104	add_gap = last_bootdev != bflow->dev;
	105	last_bootdev = bflow->dev;
	106
	107	ret = expo_str(exp, "prompt", STR_POINTER, ">");
	108	ret \|= scene_txt_str(scn, "label", ITEM_LABEL + i,
	109	STR_LABEL + i, label, NULL);
	110	ret \|= scene_txt_str(scn, "desc", ITEM_DESC + i, STR_DESC + i,
	111	bflow->os_name ? bflow->os_name :
	112	bflow->name, NULL);
	113	ret \|= scene_txt_str(scn, "key", ITEM_KEY + i, STR_KEY + i, key,
	114	NULL);
	115	preview_id = 0;
	116	if (bflow->logo) {
	117	preview_id = ITEM_PREVIEW + i;
	118	ret \|= scene_img(scn, "preview", preview_id,
	119	bflow->logo, NULL);
	120	}
	121	ret \|= scene_menuitem(scn, OBJ_MENU, "item", ITEM + i,
	122	ITEM_KEY + i, ITEM_LABEL + i,
	123	ITEM_DESC + i, preview_id,
	124	add_gap ? SCENEMIF_GAP_BEFORE : 0,
	125	NULL);
	126
	127	if (ret < 0)
	128	return log_msg_ret("itm", -EINVAL);
02d929bf SG	129	priv->num_bootflows++;
	130	}
	131
14a86a51 SG	132	ret = scene_arrange(scn);
	133	if (ret)
	134	return log_msg_ret("arr", ret);
	135
02d929bf SG	136	*expp = exp;
	137
	138	return 0;
	139	}
	140
e64c2952 SG	141	int bootflow_menu_apply_theme(struct expo *exp, ofnode node)
	142	{
	143	struct menu_priv *priv = exp->priv;
	144	struct scene *scn;
	145	u32 font_size;
	146	int ret;
	147
	148	log_debug("Applying theme %s\n", ofnode_get_name(node));
	149	scn = expo_lookup_scene_id(exp, MAIN);
	150	if (!scn)
	151	return log_msg_ret("scn", -ENOENT);
	152
	153	/* Avoid error-checking optional items */
	154	if (!ofnode_read_u32(node, "font-size", &font_size)) {
	155	int i;
	156
	157	log_debug("font size %d\n", font_size);
	158	scene_txt_set_font(scn, OBJ_PROMPT, NULL, font_size);
	159	scene_txt_set_font(scn, OBJ_POINTER, NULL, font_size);
	160	for (i = 0; i < priv->num_bootflows; i++) {
	161	ret = scene_txt_set_font(scn, ITEM_DESC + i, NULL,
	162	font_size);
	163	if (ret)
	164	return log_msg_ret("des", ret);
	165	scene_txt_set_font(scn, ITEM_KEY + i, NULL, font_size);
	166	scene_txt_set_font(scn, ITEM_LABEL + i, NULL,
	167	font_size);
	168	}
	169	}
	170
	171	ret = scene_arrange(scn);
	172	if (ret)
	173	return log_msg_ret("arr", ret);
	174
	175	return 0;
	176	}
	177
02d929bf SG	178	int bootflow_menu_run(struct bootstd_priv *std, bool text_mode,
	179	struct bootflow **bflowp)
	180	{
	181	struct cli_ch_state s_cch, *cch = &s_cch;
	182	struct bootflow *sel_bflow;
	183	struct udevice *dev;
	184	struct expo *exp;
	185	uint sel_id;
	186	bool done;
	187	int ret;
	188
	189	cli_ch_init(cch);
	190
	191	sel_bflow = NULL;
	192	*bflowp = NULL;
	193
	194	ret = bootflow_menu_new(&exp);
	195	if (ret)
	196	return log_msg_ret("exp", ret);
	197
e64c2952 SG	198	if (ofnode_valid(std->theme)) {
	199	ret = bootflow_menu_apply_theme(exp, std->theme);
	200	if (ret)
	201	return log_msg_ret("thm", ret);
	202	}
	203
02d929bf SG	204	/* For now we only support a video console */
	205	ret = uclass_first_device_err(UCLASS_VIDEO, &dev);
	206	if (ret)
	207	return log_msg_ret("vid", ret);
	208	ret = expo_set_display(exp, dev);
	209	if (ret)
	210	return log_msg_ret("dis", ret);
	211
	212	ret = expo_set_scene_id(exp, MAIN);
	213	if (ret)
	214	return log_msg_ret("scn", ret);
	215
	216	if (text_mode)
5904d953	217	expo_set_text_mode(exp, text_mode);
02d929bf SG	218
	219	done = false;
	220	do {
	221	struct expo_action act;
	222	int ichar, key;
	223
	224	ret = expo_render(exp);
	225	if (ret)
	226	break;
	227
	228	ichar = cli_ch_process(cch, 0);
	229	if (!ichar) {
	230	while (!ichar && !tstc()) {
	231	schedule();
	232	mdelay(2);
	233	ichar = cli_ch_process(cch, -ETIMEDOUT);
	234	}
	235	if (!ichar) {
	236	ichar = getchar();
	237	ichar = cli_ch_process(cch, ichar);
	238	}
	239	}
	240
	241	key = 0;
	242	if (ichar) {
	243	key = bootmenu_conv_key(ichar);
	244	if (key == BKEY_NONE)
	245	key = ichar;
	246	}
	247	if (!key)
	248	continue;
	249
	250	ret = expo_send_key(exp, key);
	251	if (ret)
	252	break;
	253
	254	ret = expo_action_get(exp, &act);
	255	if (!ret) {
	256	switch (act.type) {
	257	case EXPOACT_SELECT:
	258	sel_id = act.select.id;
	259	done = true;
	260	break;
	261	case EXPOACT_QUIT:
	262	done = true;
	263	break;
	264	default:
	265	break;
	266	}
	267	}
	268	} while (!done);
	269
	270	if (ret)
	271	return log_msg_ret("end", ret);
	272
	273	if (sel_id) {
	274	struct bootflow *bflow;
	275	int i;
	276
	277	for (ret = bootflow_first_glob(&bflow), i = 0; !ret && i < 36;
	278	ret = bootflow_next_glob(&bflow), i++) {
	279	if (i == sel_id - ITEM) {
	280	sel_bflow = bflow;
	281	break;
282	}
283	}
284	}
285
286	expo_destroy(exp);
287
288	if (!sel_bflow)
289	return -EAGAIN;
290	*bflowp = sel_bflow;
291
292	return 0;
293	}