2 * Copyright 2010-2011 Calxeda, Inc.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the Free
6 * Software Foundation; either version 2 of the License, or (at your option)
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program. If not, see <http://www.gnu.org/licenses/>.
21 #include <linux/list.h>
26 * Internally, each item in a menu is represented by a struct menu_item.
28 * These items will be alloc'd and initialized by menu_item_add and destroyed
29 * by menu_item_destroy, and the consumer of the interface never sees that
30 * this struct is used at all.
35 struct list_head list;
39 * The menu is composed of a list of items along with settings and callbacks
40 * provided by the user. An incomplete definition of this struct is available
41 * in menu.h, but the full definition is here to prevent consumers from
42 * relying on its contents.
45 struct menu_item *default_item;
49 void (*item_data_print)(void *);
50 struct list_head items;
54 * An iterator function for menu items. callback will be called for each item
55 * in m, with m, a pointer to the item, and extra being passed to callback. If
56 * callback returns a value other than NULL, iteration stops and the value
57 * return by callback is returned from menu_items_iter. This allows it to be
58 * used for search type operations. It is also safe for callback to remove the
59 * item from the list of items.
61 static inline void *menu_items_iter(struct menu *m,
62 void *(*callback)(struct menu *, struct menu_item *, void *),
65 struct list_head *pos, *n;
66 struct menu_item *item;
69 list_for_each_safe(pos, n, &m->items) {
70 item = list_entry(pos, struct menu_item, list);
72 ret = callback(m, item, extra);
82 * Print a menu_item. If the consumer provided an item_data_print function
83 * when creating the menu, call it with a pointer to the item's private data.
84 * Otherwise, print the key of the item.
86 static inline void *menu_item_print(struct menu *m,
87 struct menu_item *item,
90 if (!m->item_data_print) {
94 m->item_data_print(item->data);
101 * Free the memory used by a menu item. This includes the memory used by its
104 static inline void *menu_item_destroy(struct menu *m,
105 struct menu_item *item,
117 * Display a menu so the user can make a choice of an item. First display its
118 * title, if any, and then each item in the menu.
120 static inline void menu_display(struct menu *m)
127 menu_items_iter(m, menu_item_print, NULL);
131 * Check if an item's key matches a provided string, pointed to by extra. If
132 * extra is NULL, an item with a NULL key will match. Otherwise, the item's
133 * key has to match according to strcmp.
135 * This is called via menu_items_iter, so it returns a pointer to the item if
136 * the key matches, and returns NULL otherwise.
138 static inline void *menu_item_key_match(struct menu *m,
139 struct menu_item *item, void *extra)
141 char *item_key = extra;
143 if (!item_key || !item->key) {
144 if (item_key == item->key)
150 if (strcmp(item->key, item_key) == 0)
157 * Find the first item with a key matching item_key, if any exists.
159 static inline struct menu_item *menu_item_by_key(struct menu *m,
162 return menu_items_iter(m, menu_item_key_match, item_key);
166 * Wait for the user to hit a key according to the timeout set for the menu.
167 * Returns 1 if the user hit a key, or 0 if the timeout expired.
169 static inline int menu_interrupted(struct menu *m)
174 if (abortboot(m->timeout/10))
181 * Checks whether or not the default menu item should be used without
182 * prompting for a user choice. If the menu is set to always prompt, or the
183 * user hits a key during the timeout period, return 0. Otherwise, return 1 to
184 * indicate we should use the default menu item.
186 static inline int menu_use_default(struct menu *m)
188 return !m->prompt && !menu_interrupted(m);
192 * Set *choice to point to the default item's data, if any default item was
193 * set, and returns 1. If no default item was set, returns -ENOENT.
195 static inline int menu_default_choice(struct menu *m, void **choice)
197 if (m->default_item) {
198 *choice = m->default_item->data;
206 * Displays the menu and asks the user to choose an item. *choice will point
207 * to the private data of the item the user chooses. The user makes a choice
208 * by inputting a string matching the key of an item. Invalid choices will
209 * cause the user to be prompted again, repeatedly, until the user makes a
210 * valid choice. The user can exit the menu without making a choice via ^c.
212 * Returns 1 if the user made a choice, or -EINTR if they bail via ^c.
214 static inline int menu_interactive_choice(struct menu *m, void **choice)
216 char cbuf[CONFIG_SYS_CBSIZE];
217 struct menu_item *choice_item = NULL;
220 while (!choice_item) {
225 readret = readline_into_buffer("Enter choice: ", cbuf);
228 choice_item = menu_item_by_key(m, cbuf);
231 printf("%s not found\n", cbuf);
238 *choice = choice_item->data;
244 * menu_default_set() - Sets the default choice for the menu. This is safe to
245 * call more than once on a menu.
247 * m - Points to a menu created by menu_create().
249 * item_key - Points to a string that, when compared using strcmp, matches the
250 * key for an existing item in the menu.
252 * Returns 1 if successful, -EINVAL if m is NULL, or -ENOENT if no item with a
253 * key matching item_key is found.
255 int menu_default_set(struct menu *m, char *item_key)
257 struct menu_item *item;
262 item = menu_item_by_key(m, item_key);
267 m->default_item = item;
273 * menu_get_choice() - Returns the user's selected menu entry, or the default
274 * if the menu is set to not prompt or the timeout expires. This is safe to
275 * call more than once.
277 * m - Points to a menu created by menu_create().
279 * choice - Points to a location that will store a pointer to the selected
280 * menu item. If no item is selected or there is an error, no value will be
281 * written at the location it points to.
283 * Returns 1 if successful, -EINVAL if m or choice is NULL, -ENOENT if no
284 * default has been set and the menu is set to not prompt or the timeout
285 * expires, or -EINTR if the user exits the menu via ^c.
287 int menu_get_choice(struct menu *m, void **choice)
292 if (menu_use_default(m))
293 return menu_default_choice(m, choice);
295 return menu_interactive_choice(m, choice);
299 * menu_item_add() - Adds or replaces a menu item. Note that this replaces the
300 * data of an item if it already exists, but doesn't change the order of the
303 * m - Points to a menu created by menu_create().
305 * item_key - Points to a string that will uniquely identify the item. The
306 * string will be copied to internal storage, and is safe to discard after
307 * passing to menu_item_add.
309 * item_data - An opaque pointer associated with an item. It is never
310 * dereferenced internally, but will be passed to the item_data_print, and
311 * will be returned from menu_get_choice if the menu item is selected.
313 * Returns 1 if successful, -EINVAL if m is NULL, or -ENOMEM if there is
314 * insufficient memory to add the menu item.
316 int menu_item_add(struct menu *m, char *item_key, void *item_data)
318 struct menu_item *item;
323 item = menu_item_by_key(m, item_key);
326 item->data = item_data;
330 item = malloc(sizeof *item);
334 item->key = strdup(item_key);
341 item->data = item_data;
343 list_add_tail(&item->list, &m->items);
349 * menu_create() - Creates a menu handle with default settings
351 * title - If not NULL, points to a string that will be displayed before the
352 * list of menu items. It will be copied to internal storage, and is safe to
353 * discard after passing to menu_create().
355 * timeout - A delay in seconds to wait for user input. If 0, timeout is
356 * disabled, and the default choice will be returned unless prompt is 1.
358 * prompt - If 0, don't ask for user input unless there is an interrupted
359 * timeout. If 1, the user will be prompted for input regardless of the value
362 * item_data_print - If not NULL, will be called for each item when the menu
363 * is displayed, with the pointer to the item's data passed as the argument.
364 * If NULL, each item's key will be printed instead. Since an item's key is
365 * what must be entered to select an item, the item_data_print function should
366 * make it obvious what the key for each entry is.
368 * Returns a pointer to the menu if successful, or NULL if there is
369 * insufficient memory available to create the menu.
371 struct menu *menu_create(char *title, int timeout, int prompt,
372 void (*item_data_print)(void *))
376 m = malloc(sizeof *m);
381 m->default_item = NULL;
383 m->timeout = timeout;
384 m->item_data_print = item_data_print;
387 m->title = strdup(title);
396 INIT_LIST_HEAD(&m->items);
402 * menu_destroy() - frees the memory used by a menu and its items.
404 * m - Points to a menu created by menu_create().
406 * Returns 1 if successful, or -EINVAL if m is NULL.
408 int menu_destroy(struct menu *m)
413 menu_items_iter(m, menu_item_destroy, NULL);