common/menu.c - filogic/uboot - Gitiles

 // SPDX-License-Identifier: GPL-2.0+
 /*
  * Copyright 2010-2011 Calxeda, Inc.
  * Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
  */

 #include <ansi.h>
 #include <cli.h>
 #include <malloc.h>
 #include <errno.h>
 #include <linux/delay.h>
 #include <linux/list.h>
 #include <watchdog.h>

 #include "menu.h"

 #define ansi 1

 /*
  * Internally, each item in a menu is represented by a struct menu_item.
  *
  * These items will be alloc'd and initialized by menu_item_add and destroyed
  * by menu_item_destroy, and the consumer of the interface never sees that
  * this struct is used at all.
  */
 struct menu_item {
 	char *key;
 	void *data;
 	struct list_head list;
 };

 /*
  * The menu is composed of a list of items along with settings and callbacks
  * provided by the user. An incomplete definition of this struct is available
  * in menu.h, but the full definition is here to prevent consumers from
  * relying on its contents.
  */
 struct menu {
 	struct menu_item *default_item;
 	int timeout;
 	char *title;
 	int prompt;
 	void (*display_statusline)(struct menu *);
 	void (*item_data_print)(void *);
 	char *(*item_choice)(void *);
 	void *item_choice_data;
 	struct list_head items;
 	int item_cnt;
 };

 /*
  * An iterator function for menu items. callback will be called for each item
  * in m, with m, a pointer to the item, and extra being passed to callback. If
  * callback returns a value other than NULL, iteration stops and the value
  * return by callback is returned from menu_items_iter.  This allows it to be
  * used for search type operations. It is also safe for callback to remove the
  * item from the list of items.
  */
 static inline void *menu_items_iter(struct menu *m,
 		void *(*callback)(struct menu *, struct menu_item *, void *),
 		void *extra)
 {
 	struct list_head *pos, *n;
 	struct menu_item *item;
 	void *ret;

 	list_for_each_safe(pos, n, &m->items) {
 		item = list_entry(pos, struct menu_item, list);

 		ret = callback(m, item, extra);

 		if (ret)
 			return ret;
 	}

 	return NULL;
 }

 /*
  * Print a menu_item. If the consumer provided an item_data_print function
  * when creating the menu, call it with a pointer to the item's private data.
  * Otherwise, print the key of the item.
  */
 static inline void *menu_item_print(struct menu *m,
 				struct menu_item *item,
 				void *extra)
 {
 	if (!m->item_data_print) {
 		puts(item->key);
 		putc('\n');
 	} else {
 		m->item_data_print(item->data);
 	}

 	return NULL;
 }

 /*
  * Free the memory used by a menu item. This includes the memory used by its
  * key.
  */
 static inline void *menu_item_destroy(struct menu *m,
 				struct menu_item *item,
 				void *extra)
 {
 	if (item->key)
 		free(item->key);

 	free(item);

 	return NULL;
 }

 /*
  * Display a menu so the user can make a choice of an item. First display its
  * title, if any, and then each item in the menu.
  */
 static inline void menu_display(struct menu *m)
 {
 	if (m->title) {
 		puts(m->title);
 		putc('\n');
 	}
 	if (m->display_statusline)
 		m->display_statusline(m);

 	menu_items_iter(m, menu_item_print, NULL);
 }

 /*
  * Check if an item's key matches a provided string, pointed to by extra. If
  * extra is NULL, an item with a NULL key will match. Otherwise, the item's
  * key has to match according to strcmp.
  *
  * This is called via menu_items_iter, so it returns a pointer to the item if
  * the key matches, and returns NULL otherwise.
  */
 static inline void *menu_item_key_match(struct menu *m,
 			struct menu_item *item, void *extra)
 {
 	char *item_key = extra;

 	if (!item_key || !item->key) {
 		if (item_key == item->key)
 			return item;

 		return NULL;
 	}

 	if (strcmp(item->key, item_key) == 0)
 		return item;

 	return NULL;
 }

 /*
  * Find the first item with a key matching item_key, if any exists.
  */
 static inline struct menu_item *menu_item_by_key(struct menu *m,
 							char *item_key)
 {
 	return menu_items_iter(m, menu_item_key_match, item_key);
 }

 /*
  * Set *choice to point to the default item's data, if any default item was
  * set, and returns 1. If no default item was set, returns -ENOENT.
  */
 int menu_default_choice(struct menu *m, void **choice)
 {
 	if (m->default_item) {
 		*choice = m->default_item->data;
 		return 1;
 	}

 	return -ENOENT;
 }

 /*
  * Displays the menu and asks the user to choose an item. *choice will point
  * to the private data of the item the user chooses. The user makes a choice
  * by inputting a string matching the key of an item. Invalid choices will
  * cause the user to be prompted again, repeatedly, until the user makes a
  * valid choice. The user can exit the menu without making a choice via ^c.
  *
  * Returns 1 if the user made a choice, or -EINTR if they bail via ^c.
  */
 static inline int menu_interactive_choice(struct menu *m, void **choice)
 {
 	char cbuf[CONFIG_SYS_CBSIZE];
 	struct menu_item *choice_item = NULL;
 	int readret;

 	while (!choice_item) {
 		cbuf[0] = '\0';

 		menu_display(m);

 		if (!m->item_choice) {
 			readret = cli_readline_into_buffer("Enter choice: ",
 							   cbuf, m->timeout);

 			if (readret >= 0) {
 				choice_item = menu_item_by_key(m, cbuf);
 				if (!choice_item)
 					printf("%s not found\n", cbuf);
 			} else if (readret == -1)  {
 				printf("<INTERRUPT>\n");
 				return -EINTR;
 			} else {
 				return menu_default_choice(m, choice);
 			}
 		} else {
 			char *key = m->item_choice(m->item_choice_data);

 			if (key)
 				choice_item = menu_item_by_key(m, key);
 		}

 		if (!choice_item)
 			m->timeout = 0;
 	}

 	*choice = choice_item->data;

 	return 1;
 }

 /*
  * menu_default_set() - Sets the default choice for the menu. This is safe to
  * call more than once on a menu.
  *
  * m - Points to a menu created by menu_create().
  *
  * item_key - Points to a string that, when compared using strcmp, matches the
  * key for an existing item in the menu.
  *
  * Returns 1 if successful, -EINVAL if m is NULL, or -ENOENT if no item with a
  * key matching item_key is found.
  */
 int menu_default_set(struct menu *m, char *item_key)
 {
 	struct menu_item *item;

 	if (!m)
 		return -EINVAL;

 	item = menu_item_by_key(m, item_key);

 	if (!item)
 		return -ENOENT;

 	m->default_item = item;

 	return 1;
 }

 /*
  * menu_get_choice() - Returns the user's selected menu entry, or the default
  * if the menu is set to not prompt or the timeout expires. This is safe to
  * call more than once.
  *
  * m - Points to a menu created by menu_create().
  *
  * choice - Points to a location that will store a pointer to the selected
  * menu item. If no item is selected or there is an error, no value will be
  * written at the location it points to.
  *
  * Returns 1 if successful, -EINVAL if m or choice is NULL, -ENOENT if no
  * default has been set and the menu is set to not prompt or the timeout
  * expires, or -EINTR if the user exits the menu via ^c.
  */
 int menu_get_choice(struct menu *m, void **choice)
 {
 	if (!m || !choice)
 		return -EINVAL;

 	if (!m->item_cnt)
 		return -ENOENT;

 	if (!m->prompt)
 		return menu_default_choice(m, choice);

 	return menu_interactive_choice(m, choice);
 }

 /*
  * menu_item_add() - Adds or replaces a menu item. Note that this replaces the
  * data of an item if it already exists, but doesn't change the order of the
  * item.
  *
  * m - Points to a menu created by menu_create().
  *
  * item_key - Points to a string that will uniquely identify the item.  The
  * string will be copied to internal storage, and is safe to discard after
  * passing to menu_item_add.
  *
  * item_data - An opaque pointer associated with an item. It is never
  * dereferenced internally, but will be passed to the item_data_print, and
  * will be returned from menu_get_choice if the menu item is selected.
  *
  * Returns 1 if successful, -EINVAL if m is NULL, or -ENOMEM if there is
  * insufficient memory to add the menu item.
  */
 int menu_item_add(struct menu *m, char *item_key, void *item_data)
 {
 	struct menu_item *item;

 	if (!m)
 		return -EINVAL;

 	item = menu_item_by_key(m, item_key);

 	if (item) {
 		item->data = item_data;
 		return 1;
 	}

 	item = malloc(sizeof *item);
 	if (!item)
 		return -ENOMEM;

 	item->key = strdup(item_key);

 	if (!item->key) {
 		free(item);
 		return -ENOMEM;
 	}

 	item->data = item_data;

 	list_add_tail(&item->list, &m->items);
 	m->item_cnt++;

 	return 1;
 }

 /*
  * menu_create() - Creates a menu handle with default settings
  *
  * title - If not NULL, points to a string that will be displayed before the
  * list of menu items. It will be copied to internal storage, and is safe to
  * discard after passing to menu_create().
  *
  * timeout - A delay in seconds to wait for user input. If 0, timeout is
  * disabled, and the default choice will be returned unless prompt is 1.
  *
  * prompt - If 0, don't ask for user input unless there is an interrupted
  * timeout. If 1, the user will be prompted for input regardless of the value
  * of timeout.
  *
  * display_statusline - If not NULL, will be called to show a statusline when
  * the menu is displayed.
  *
  * item_data_print - If not NULL, will be called for each item when the menu
  * is displayed, with the pointer to the item's data passed as the argument.
  * If NULL, each item's key will be printed instead.  Since an item's key is
  * what must be entered to select an item, the item_data_print function should
  * make it obvious what the key for each entry is.
  *
  * item_choice - If not NULL, will be called when asking the user to choose an
  * item. Returns a key string corresponding to the chosen item or NULL if
  * no item has been selected.
  *
  * item_choice_data - Will be passed as the argument to the item_choice function
  *
  * Returns a pointer to the menu if successful, or NULL if there is
  * insufficient memory available to create the menu.
  */
 struct menu *menu_create(char *title, int timeout, int prompt,
 				void (*display_statusline)(struct menu *),
 				void (*item_data_print)(void *),
 				char *(*item_choice)(void *),
 				void *item_choice_data)
 {
 	struct menu *m;

 	m = malloc(sizeof *m);

 	if (!m)
 		return NULL;

 	m->default_item = NULL;
 	m->prompt = prompt;
 	m->timeout = timeout;
 	m->display_statusline = display_statusline;
 	m->item_data_print = item_data_print;
 	m->item_choice = item_choice;
 	m->item_choice_data = item_choice_data;
 	m->item_cnt = 0;

 	if (title) {
 		m->title = strdup(title);
 		if (!m->title) {
 			free(m);
 			return NULL;
 		}
 	} else
 		m->title = NULL;


 	INIT_LIST_HEAD(&m->items);

 	return m;
 }

 /*
  * menu_destroy() - frees the memory used by a menu and its items.
  *
  * m - Points to a menu created by menu_create().
  *
  * Returns 1 if successful, or -EINVAL if m is NULL.
  */
 int menu_destroy(struct menu *m)
 {
 	if (!m)
 		return -EINVAL;

 	menu_items_iter(m, menu_item_destroy, NULL);

 	if (m->title)
 		free(m->title);

 	free(m);

 	return 1;
 }

 enum bootmenu_key bootmenu_autoboot_loop(struct bootmenu_data *menu,
 					 struct cli_ch_state *cch)
 {
 	enum bootmenu_key key = BKEY_NONE;
 	int i, c;

 	while (menu->delay > 0) {
 		if (ansi)
 			printf(ANSI_CURSOR_POSITION, menu->count + 5, 3);
 		printf("Hit any key to stop autoboot: %d ", menu->delay);
 		for (i = 0; i < 100; ++i) {
 			int ichar;

 			if (!tstc()) {
 				schedule();
 				mdelay(10);
 				continue;
 			}

 			menu->delay = -1;
 			c = getchar();

 			ichar = cli_ch_process(cch, c);

 			switch (ichar) {
 			case '\0':
 				key = BKEY_NONE;
 				break;
 			case '\n':
 				key = BKEY_SELECT;
 				break;
 			case 0x3: /* ^C */
 				key = BKEY_QUIT;
 				break;
 			default:
 				key = BKEY_NONE;
 				break;
 			}
 			break;
 		}

 		if (menu->delay < 0)
 			break;

 		--menu->delay;
 	}

 	if (ansi)
 		printf(ANSI_CURSOR_POSITION ANSI_CLEAR_LINE, menu->count + 5, 1);

 	if (menu->delay == 0)
 		key = BKEY_SELECT;

 	return key;
 }

 enum bootmenu_key bootmenu_conv_key(int ichar)
 {
 	enum bootmenu_key key;

 	switch (ichar) {
 	case '\n':
 		/* enter key was pressed */
 		key = BKEY_SELECT;
 		break;
 	case CTL_CH('c'):
 	case '\e':
 		/* ^C was pressed */
 		key = BKEY_QUIT;
 		break;
 	case CTL_CH('p'):
 		key = BKEY_UP;
 		break;
 	case CTL_CH('n'):
 		key = BKEY_DOWN;
 		break;
 	case CTL_CH('s'):
 		key = BKEY_SAVE;
 		break;
 	case '+':
 		key = BKEY_PLUS;
 		break;
 	case '-':
 		key = BKEY_MINUS;
 		break;
 	case ' ':
 		key = BKEY_SPACE;
 		break;
 	default:
 		key = BKEY_NONE;
 		break;
 	}

 	return key;
 }

 enum bootmenu_key bootmenu_loop(struct bootmenu_data *menu,
 				struct cli_ch_state *cch)
 {
 	enum bootmenu_key key;
 	int c;

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

 	key = bootmenu_conv_key(c);

 	return key;
 }
	// SPDX-License-Identifier: GPL-2.0+
	/*
	* Copyright 2010-2011 Calxeda, Inc.
	* Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
	*/

	#include <ansi.h>
	#include <cli.h>
	#include <malloc.h>
	#include <errno.h>
	#include <linux/delay.h>
	#include <linux/list.h>
	#include <watchdog.h>

	#include "menu.h"

	#define ansi 1

	/*
	* Internally, each item in a menu is represented by a struct menu_item.
	*
	* These items will be alloc'd and initialized by menu_item_add and destroyed
	* by menu_item_destroy, and the consumer of the interface never sees that
	* this struct is used at all.
	*/
	struct menu_item {
	char *key;
	void *data;
	struct list_head list;
	};

	/*
	* The menu is composed of a list of items along with settings and callbacks
	* provided by the user. An incomplete definition of this struct is available
	* in menu.h, but the full definition is here to prevent consumers from
	* relying on its contents.
	*/
	struct menu {
	struct menu_item *default_item;
	int timeout;
	char *title;
	int prompt;
	void (display_statusline)(struct menu );
	void (item_data_print)(void );
	char (item_choice)(void *);
	void *item_choice_data;
	struct list_head items;
	int item_cnt;
	};

	/*
	* An iterator function for menu items. callback will be called for each item
	* in m, with m, a pointer to the item, and extra being passed to callback. If
	* callback returns a value other than NULL, iteration stops and the value
	* return by callback is returned from menu_items_iter. This allows it to be
	* used for search type operations. It is also safe for callback to remove the
	* item from the list of items.
	*/
	static inline void menu_items_iter(struct menu m,
	void (callback)(struct menu , struct menu_item , void *),
	void *extra)
	{
	struct list_head pos, n;
	struct menu_item *item;
	void *ret;

	list_for_each_safe(pos, n, &m->items) {
	item = list_entry(pos, struct menu_item, list);

	ret = callback(m, item, extra);

	if (ret)
	return ret;
	}

	return NULL;
	}

	/*
	* Print a menu_item. If the consumer provided an item_data_print function
	* when creating the menu, call it with a pointer to the item's private data.
	* Otherwise, print the key of the item.
	*/
	static inline void menu_item_print(struct menu m,
	struct menu_item *item,
	void *extra)
	{
	if (!m->item_data_print) {
	puts(item->key);
	putc('\n');
	} else {
	m->item_data_print(item->data);
	}

	return NULL;
	}

	/*
	* Free the memory used by a menu item. This includes the memory used by its
	* key.
	*/
	static inline void menu_item_destroy(struct menu m,
	struct menu_item *item,
	void *extra)
	{
	if (item->key)
	free(item->key);

	free(item);

	return NULL;
	}

	/*
	* Display a menu so the user can make a choice of an item. First display its
	* title, if any, and then each item in the menu.
	*/
	static inline void menu_display(struct menu *m)
	{
	if (m->title) {
	puts(m->title);
	putc('\n');
	}
	if (m->display_statusline)
	m->display_statusline(m);

	menu_items_iter(m, menu_item_print, NULL);
	}

	/*
	* Check if an item's key matches a provided string, pointed to by extra. If
	* extra is NULL, an item with a NULL key will match. Otherwise, the item's
	* key has to match according to strcmp.
	*
	* This is called via menu_items_iter, so it returns a pointer to the item if
	* the key matches, and returns NULL otherwise.
	*/
	static inline void menu_item_key_match(struct menu m,
	struct menu_item item, void extra)
	{
	char *item_key = extra;

	if (!item_key \|\| !item->key) {
	if (item_key == item->key)
	return item;

	return NULL;
	}

	if (strcmp(item->key, item_key) == 0)
	return item;

	return NULL;
	}

	/*
	* Find the first item with a key matching item_key, if any exists.
	*/
	static inline struct menu_item menu_item_by_key(struct menu m,
	char *item_key)
	{
	return menu_items_iter(m, menu_item_key_match, item_key);
	}

	/*
	* Set *choice to point to the default item's data, if any default item was
	* set, and returns 1. If no default item was set, returns -ENOENT.
	*/
	int menu_default_choice(struct menu m, void *choice)
	{
	if (m->default_item) {
	*choice = m->default_item->data;
	return 1;
	}

	return -ENOENT;
	}

	/*
	* Displays the menu and asks the user to choose an item. *choice will point
	* to the private data of the item the user chooses. The user makes a choice
	* by inputting a string matching the key of an item. Invalid choices will
	* cause the user to be prompted again, repeatedly, until the user makes a
	* valid choice. The user can exit the menu without making a choice via ^c.
	*
	* Returns 1 if the user made a choice, or -EINTR if they bail via ^c.
	*/
	static inline int menu_interactive_choice(struct menu m, void *choice)
	{
	char cbuf[CONFIG_SYS_CBSIZE];
	struct menu_item *choice_item = NULL;
	int readret;

	while (!choice_item) {
	cbuf[0] = '\0';

	menu_display(m);

	if (!m->item_choice) {
	readret = cli_readline_into_buffer("Enter choice: ",
	cbuf, m->timeout);

	if (readret >= 0) {
	choice_item = menu_item_by_key(m, cbuf);
	if (!choice_item)
	printf("%s not found\n", cbuf);
	} else if (readret == -1) {
	printf("<INTERRUPT>\n");
	return -EINTR;
	} else {
	return menu_default_choice(m, choice);
	}
	} else {
	char *key = m->item_choice(m->item_choice_data);

	if (key)
	choice_item = menu_item_by_key(m, key);
	}

	if (!choice_item)
	m->timeout = 0;
	}

	*choice = choice_item->data;

	return 1;
	}

	/*
	* menu_default_set() - Sets the default choice for the menu. This is safe to
	* call more than once on a menu.
	*
	* m - Points to a menu created by menu_create().
	*
	* item_key - Points to a string that, when compared using strcmp, matches the
	* key for an existing item in the menu.
	*
	* Returns 1 if successful, -EINVAL if m is NULL, or -ENOENT if no item with a
	* key matching item_key is found.
	*/
	int menu_default_set(struct menu m, char item_key)
	{
	struct menu_item *item;

	if (!m)
	return -EINVAL;

	item = menu_item_by_key(m, item_key);

	if (!item)
	return -ENOENT;

	m->default_item = item;

	return 1;
	}

	/*
	* menu_get_choice() - Returns the user's selected menu entry, or the default
	* if the menu is set to not prompt or the timeout expires. This is safe to
	* call more than once.
	*
	* m - Points to a menu created by menu_create().
	*
	* choice - Points to a location that will store a pointer to the selected
	* menu item. If no item is selected or there is an error, no value will be
	* written at the location it points to.
	*
	* Returns 1 if successful, -EINVAL if m or choice is NULL, -ENOENT if no
	* default has been set and the menu is set to not prompt or the timeout
	* expires, or -EINTR if the user exits the menu via ^c.
	*/
	int menu_get_choice(struct menu m, void *choice)
	{
	if (!m \|\| !choice)
	return -EINVAL;

	if (!m->item_cnt)
	return -ENOENT;

	if (!m->prompt)
	return menu_default_choice(m, choice);

	return menu_interactive_choice(m, choice);
	}

	/*
	* menu_item_add() - Adds or replaces a menu item. Note that this replaces the
	* data of an item if it already exists, but doesn't change the order of the
	* item.
	*
	* m - Points to a menu created by menu_create().
	*
	* item_key - Points to a string that will uniquely identify the item. The
	* string will be copied to internal storage, and is safe to discard after
	* passing to menu_item_add.
	*
	* item_data - An opaque pointer associated with an item. It is never
	* dereferenced internally, but will be passed to the item_data_print, and
	* will be returned from menu_get_choice if the menu item is selected.
	*
	* Returns 1 if successful, -EINVAL if m is NULL, or -ENOMEM if there is
	* insufficient memory to add the menu item.
	*/
	int menu_item_add(struct menu m, char item_key, void *item_data)
	{
	struct menu_item *item;

	if (!m)
	return -EINVAL;

	item = menu_item_by_key(m, item_key);

	if (item) {
	item->data = item_data;
	return 1;
	}

	item = malloc(sizeof *item);
	if (!item)
	return -ENOMEM;

	item->key = strdup(item_key);

	if (!item->key) {
	free(item);
	return -ENOMEM;
	}

	item->data = item_data;

	list_add_tail(&item->list, &m->items);
	m->item_cnt++;

	return 1;
	}

	/*
	* menu_create() - Creates a menu handle with default settings
	*
	* title - If not NULL, points to a string that will be displayed before the
	* list of menu items. It will be copied to internal storage, and is safe to
	* discard after passing to menu_create().
	*
	* timeout - A delay in seconds to wait for user input. If 0, timeout is
	* disabled, and the default choice will be returned unless prompt is 1.
	*
	* prompt - If 0, don't ask for user input unless there is an interrupted
	* timeout. If 1, the user will be prompted for input regardless of the value
	* of timeout.
	*
	* display_statusline - If not NULL, will be called to show a statusline when
	* the menu is displayed.
	*
	* item_data_print - If not NULL, will be called for each item when the menu
	* is displayed, with the pointer to the item's data passed as the argument.
	* If NULL, each item's key will be printed instead. Since an item's key is
	* what must be entered to select an item, the item_data_print function should
	* make it obvious what the key for each entry is.
	*
	* item_choice - If not NULL, will be called when asking the user to choose an
	* item. Returns a key string corresponding to the chosen item or NULL if
	* no item has been selected.
	*
	* item_choice_data - Will be passed as the argument to the item_choice function
	*
	* Returns a pointer to the menu if successful, or NULL if there is
	* insufficient memory available to create the menu.
	*/
	struct menu menu_create(char title, int timeout, int prompt,
	void (display_statusline)(struct menu ),
	void (item_data_print)(void ),
	char (item_choice)(void *),
	void *item_choice_data)
	{
	struct menu *m;

	m = malloc(sizeof *m);

	if (!m)
	return NULL;

	m->default_item = NULL;
	m->prompt = prompt;
	m->timeout = timeout;
	m->display_statusline = display_statusline;
	m->item_data_print = item_data_print;
	m->item_choice = item_choice;
	m->item_choice_data = item_choice_data;
	m->item_cnt = 0;

	if (title) {
	m->title = strdup(title);
	if (!m->title) {
	free(m);
	return NULL;
	}
	} else
	m->title = NULL;


	INIT_LIST_HEAD(&m->items);

	return m;
	}

	/*
	* menu_destroy() - frees the memory used by a menu and its items.
	*
	* m - Points to a menu created by menu_create().
	*
	* Returns 1 if successful, or -EINVAL if m is NULL.
	*/
	int menu_destroy(struct menu *m)
	{
	if (!m)
	return -EINVAL;

	menu_items_iter(m, menu_item_destroy, NULL);

	if (m->title)
	free(m->title);

	free(m);

	return 1;
	}

	enum bootmenu_key bootmenu_autoboot_loop(struct bootmenu_data *menu,
	struct cli_ch_state *cch)
	{
	enum bootmenu_key key = BKEY_NONE;
	int i, c;

	while (menu->delay > 0) {
	if (ansi)
	printf(ANSI_CURSOR_POSITION, menu->count + 5, 3);
	printf("Hit any key to stop autoboot: %d ", menu->delay);
	for (i = 0; i < 100; ++i) {
	int ichar;

	if (!tstc()) {
	schedule();
	mdelay(10);
	continue;
	}

	menu->delay = -1;
	c = getchar();

	ichar = cli_ch_process(cch, c);

	switch (ichar) {
	case '\0':
	key = BKEY_NONE;
	break;
	case '\n':
	key = BKEY_SELECT;
	break;
	case 0x3: /* ^C */
	key = BKEY_QUIT;
	break;
	default:
	key = BKEY_NONE;
	break;
	}
	break;
	}

	if (menu->delay < 0)
	break;

	--menu->delay;
	}

	if (ansi)
	printf(ANSI_CURSOR_POSITION ANSI_CLEAR_LINE, menu->count + 5, 1);

	if (menu->delay == 0)
	key = BKEY_SELECT;

	return key;
	}

	enum bootmenu_key bootmenu_conv_key(int ichar)
	{
	enum bootmenu_key key;

	switch (ichar) {
	case '\n':
	/* enter key was pressed */
	key = BKEY_SELECT;
	break;
	case CTL_CH('c'):
	case '\e':
	/* ^C was pressed */
	key = BKEY_QUIT;
	break;
	case CTL_CH('p'):
	key = BKEY_UP;
	break;
	case CTL_CH('n'):
	key = BKEY_DOWN;
	break;
	case CTL_CH('s'):
	key = BKEY_SAVE;
	break;
	case '+':
	key = BKEY_PLUS;
	break;
	case '-':
	key = BKEY_MINUS;
	break;
	case ' ':
	key = BKEY_SPACE;
	break;
	default:
	key = BKEY_NONE;
	break;
	}

	return key;
	}

	enum bootmenu_key bootmenu_loop(struct bootmenu_data *menu,
	struct cli_ch_state *cch)
	{
	enum bootmenu_key key;
	int c;

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

	key = bootmenu_conv_key(c);

	return key;
	}