← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/u-boot/common/menu.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
roms/u-boot/common/menu.c
 
1
/*
 
2
 * Copyright 2010-2011 Calxeda, Inc.
 
3
 *
 
4
 * SPDX-License-Identifier:     GPL-2.0+
 
5
 */
 
6
 
 
7
#include <common.h>
 
8
#include <malloc.h>
 
9
#include <errno.h>
 
10
#include <linux/list.h>
 
11
 
 
12
#include "menu.h"
 
13
 
 
14
/*
 
15
 * Internally, each item in a menu is represented by a struct menu_item.
 
16
 *
 
17
 * These items will be alloc'd and initialized by menu_item_add and destroyed
 
18
 * by menu_item_destroy, and the consumer of the interface never sees that
 
19
 * this struct is used at all.
 
20
 */
 
21
struct menu_item {
 
22
        char *key;
 
23
        void *data;
 
24
        struct list_head list;
 
25
};
 
26
 
 
27
/*
 
28
 * The menu is composed of a list of items along with settings and callbacks
 
29
 * provided by the user. An incomplete definition of this struct is available
 
30
 * in menu.h, but the full definition is here to prevent consumers from
 
31
 * relying on its contents.
 
32
 */
 
33
struct menu {
 
34
        struct menu_item *default_item;
 
35
        int timeout;
 
36
        char *title;
 
37
        int prompt;
 
38
        void (*item_data_print)(void *);
 
39
        char *(*item_choice)(void *);
 
40
        void *item_choice_data;
 
41
        struct list_head items;
 
42
};
 
43
 
 
44
/*
 
45
 * An iterator function for menu items. callback will be called for each item
 
46
 * in m, with m, a pointer to the item, and extra being passed to callback. If
 
47
 * callback returns a value other than NULL, iteration stops and the value
 
48
 * return by callback is returned from menu_items_iter.  This allows it to be
 
49
 * used for search type operations. It is also safe for callback to remove the
 
50
 * item from the list of items.
 
51
 */
 
52
static inline void *menu_items_iter(struct menu *m,
 
53
                void *(*callback)(struct menu *, struct menu_item *, void *),
 
54
                void *extra)
 
55
{
 
56
        struct list_head *pos, *n;
 
57
        struct menu_item *item;
 
58
        void *ret;
 
59
 
 
60
        list_for_each_safe(pos, n, &m->items) {
 
61
                item = list_entry(pos, struct menu_item, list);
 
62
 
 
63
                ret = callback(m, item, extra);
 
64
 
 
65
                if (ret)
 
66
                        return ret;
 
67
        }
 
68
 
 
69
        return NULL;
 
70
}
 
71
 
 
72
/*
 
73
 * Print a menu_item. If the consumer provided an item_data_print function
 
74
 * when creating the menu, call it with a pointer to the item's private data.
 
75
 * Otherwise, print the key of the item.
 
76
 */
 
77
static inline void *menu_item_print(struct menu *m,
 
78
                                struct menu_item *item,
 
79
                                void *extra)
 
80
{
 
81
        if (!m->item_data_print) {
 
82
                puts(item->key);
 
83
                putc('\n');
 
84
        } else {
 
85
                m->item_data_print(item->data);
 
86
        }
 
87
 
 
88
        return NULL;
 
89
}
 
90
 
 
91
/*
 
92
 * Free the memory used by a menu item. This includes the memory used by its
 
93
 * key.
 
94
 */
 
95
static inline void *menu_item_destroy(struct menu *m,
 
96
                                struct menu_item *item,
 
97
                                void *extra)
 
98
{
 
99
        if (item->key)
 
100
                free(item->key);
 
101
 
 
102
        free(item);
 
103
 
 
104
        return NULL;
 
105
}
 
106
 
 
107
void __menu_display_statusline(struct menu *m)
 
108
{
 
109
        return;
 
110
}
 
111
void menu_display_statusline(struct menu *m)
 
112
        __attribute__ ((weak, alias("__menu_display_statusline")));
 
113
 
 
114
/*
 
115
 * Display a menu so the user can make a choice of an item. First display its
 
116
 * title, if any, and then each item in the menu.
 
117
 */
 
118
static inline void menu_display(struct menu *m)
 
119
{
 
120
        if (m->title) {
 
121
                puts(m->title);
 
122
                putc('\n');
 
123
        }
 
124
        menu_display_statusline(m);
 
125
 
 
126
        menu_items_iter(m, menu_item_print, NULL);
 
127
}
 
128
 
 
129
/*
 
130
 * Check if an item's key matches a provided string, pointed to by extra. If
 
131
 * extra is NULL, an item with a NULL key will match. Otherwise, the item's
 
132
 * key has to match according to strcmp.
 
133
 *
 
134
 * This is called via menu_items_iter, so it returns a pointer to the item if
 
135
 * the key matches, and returns NULL otherwise.
 
136
 */
 
137
static inline void *menu_item_key_match(struct menu *m,
 
138
                        struct menu_item *item, void *extra)
 
139
{
 
140
        char *item_key = extra;
 
141
 
 
142
        if (!item_key || !item->key) {
 
143
                if (item_key == item->key)
 
144
                        return item;
 
145
 
 
146
                return NULL;
 
147
        }
 
148
 
 
149
        if (strcmp(item->key, item_key) == 0)
 
150
                return item;
 
151
 
 
152
        return NULL;
 
153
}
 
154
 
 
155
/*
 
156
 * Find the first item with a key matching item_key, if any exists.
 
157
 */
 
158
static inline struct menu_item *menu_item_by_key(struct menu *m,
 
159
                                                        char *item_key)
 
160
{
 
161
        return menu_items_iter(m, menu_item_key_match, item_key);
 
162
}
 
163
 
 
164
/*
 
165
 * Set *choice to point to the default item's data, if any default item was
 
166
 * set, and returns 1. If no default item was set, returns -ENOENT.
 
167
 */
 
168
int menu_default_choice(struct menu *m, void **choice)
 
169
{
 
170
        if (m->default_item) {
 
171
                *choice = m->default_item->data;
 
172
                return 1;
 
173
        }
 
174
 
 
175
        return -ENOENT;
 
176
}
 
177
 
 
178
/*
 
179
 * Displays the menu and asks the user to choose an item. *choice will point
 
180
 * to the private data of the item the user chooses. The user makes a choice
 
181
 * by inputting a string matching the key of an item. Invalid choices will
 
182
 * cause the user to be prompted again, repeatedly, until the user makes a
 
183
 * valid choice. The user can exit the menu without making a choice via ^c.
 
184
 *
 
185
 * Returns 1 if the user made a choice, or -EINTR if they bail via ^c.
 
186
 */
 
187
static inline int menu_interactive_choice(struct menu *m, void **choice)
 
188
{
 
189
        char cbuf[CONFIG_SYS_CBSIZE];
 
190
        struct menu_item *choice_item = NULL;
 
191
        int readret;
 
192
 
 
193
        while (!choice_item) {
 
194
                cbuf[0] = '\0';
 
195
 
 
196
                menu_display(m);
 
197
 
 
198
                if (!m->item_choice) {
 
199
                        readret = readline_into_buffer("Enter choice: ", cbuf,
 
200
                                        m->timeout / 10);
 
201
 
 
202
                        if (readret >= 0) {
 
203
                                choice_item = menu_item_by_key(m, cbuf);
 
204
                                if (!choice_item)
 
205
                                        printf("%s not found\n", cbuf);
 
206
                        } else {
 
207
                                return menu_default_choice(m, choice);
 
208
                        }
 
209
                } else {
 
210
                        char *key = m->item_choice(m->item_choice_data);
 
211
 
 
212
                        if (key)
 
213
                                choice_item = menu_item_by_key(m, key);
 
214
                }
 
215
 
 
216
                if (!choice_item)
 
217
                        m->timeout = 0;
 
218
        }
 
219
 
 
220
        *choice = choice_item->data;
 
221
 
 
222
        return 1;
 
223
}
 
224
 
 
225
/*
 
226
 * menu_default_set() - Sets the default choice for the menu. This is safe to
 
227
 * call more than once on a menu.
 
228
 *
 
229
 * m - Points to a menu created by menu_create().
 
230
 *
 
231
 * item_key - Points to a string that, when compared using strcmp, matches the
 
232
 * key for an existing item in the menu.
 
233
 *
 
234
 * Returns 1 if successful, -EINVAL if m is NULL, or -ENOENT if no item with a
 
235
 * key matching item_key is found.
 
236
 */
 
237
int menu_default_set(struct menu *m, char *item_key)
 
238
{
 
239
        struct menu_item *item;
 
240
 
 
241
        if (!m)
 
242
                return -EINVAL;
 
243
 
 
244
        item = menu_item_by_key(m, item_key);
 
245
 
 
246
        if (!item)
 
247
                return -ENOENT;
 
248
 
 
249
        m->default_item = item;
 
250
 
 
251
        return 1;
 
252
}
 
253
 
 
254
/*
 
255
 * menu_get_choice() - Returns the user's selected menu entry, or the default
 
256
 * if the menu is set to not prompt or the timeout expires. This is safe to
 
257
 * call more than once.
 
258
 *
 
259
 * m - Points to a menu created by menu_create().
 
260
 *
 
261
 * choice - Points to a location that will store a pointer to the selected
 
262
 * menu item. If no item is selected or there is an error, no value will be
 
263
 * written at the location it points to.
 
264
 *
 
265
 * Returns 1 if successful, -EINVAL if m or choice is NULL, -ENOENT if no
 
266
 * default has been set and the menu is set to not prompt or the timeout
 
267
 * expires, or -EINTR if the user exits the menu via ^c.
 
268
 */
 
269
int menu_get_choice(struct menu *m, void **choice)
 
270
{
 
271
        if (!m || !choice)
 
272
                return -EINVAL;
 
273
 
 
274
        if (!m->prompt)
 
275
                return menu_default_choice(m, choice);
 
276
 
 
277
        return menu_interactive_choice(m, choice);
 
278
}
 
279
 
 
280
/*
 
281
 * menu_item_add() - Adds or replaces a menu item. Note that this replaces the
 
282
 * data of an item if it already exists, but doesn't change the order of the
 
283
 * item.
 
284
 *
 
285
 * m - Points to a menu created by menu_create().
 
286
 *
 
287
 * item_key - Points to a string that will uniquely identify the item.  The
 
288
 * string will be copied to internal storage, and is safe to discard after
 
289
 * passing to menu_item_add.
 
290
 *
 
291
 * item_data - An opaque pointer associated with an item. It is never
 
292
 * dereferenced internally, but will be passed to the item_data_print, and
 
293
 * will be returned from menu_get_choice if the menu item is selected.
 
294
 *
 
295
 * Returns 1 if successful, -EINVAL if m is NULL, or -ENOMEM if there is
 
296
 * insufficient memory to add the menu item.
 
297
 */
 
298
int menu_item_add(struct menu *m, char *item_key, void *item_data)
 
299
{
 
300
        struct menu_item *item;
 
301
 
 
302
        if (!m)
 
303
                return -EINVAL;
 
304
 
 
305
        item = menu_item_by_key(m, item_key);
 
306
 
 
307
        if (item) {
 
308
                item->data = item_data;
 
309
                return 1;
 
310
        }
 
311
 
 
312
        item = malloc(sizeof *item);
 
313
        if (!item)
 
314
                return -ENOMEM;
 
315
 
 
316
        item->key = strdup(item_key);
 
317
 
 
318
        if (!item->key) {
 
319
                free(item);
 
320
                return -ENOMEM;
 
321
        }
 
322
 
 
323
        item->data = item_data;
 
324
 
 
325
        list_add_tail(&item->list, &m->items);
 
326
 
 
327
        return 1;
 
328
}
 
329
 
 
330
/*
 
331
 * menu_create() - Creates a menu handle with default settings
 
332
 *
 
333
 * title - If not NULL, points to a string that will be displayed before the
 
334
 * list of menu items. It will be copied to internal storage, and is safe to
 
335
 * discard after passing to menu_create().
 
336
 *
 
337
 * timeout - A delay in seconds to wait for user input. If 0, timeout is
 
338
 * disabled, and the default choice will be returned unless prompt is 1.
 
339
 *
 
340
 * prompt - If 0, don't ask for user input unless there is an interrupted
 
341
 * timeout. If 1, the user will be prompted for input regardless of the value
 
342
 * of timeout.
 
343
 *
 
344
 * item_data_print - If not NULL, will be called for each item when the menu
 
345
 * is displayed, with the pointer to the item's data passed as the argument.
 
346
 * If NULL, each item's key will be printed instead.  Since an item's key is
 
347
 * what must be entered to select an item, the item_data_print function should
 
348
 * make it obvious what the key for each entry is.
 
349
 *
 
350
 * item_choice - If not NULL, will be called when asking the user to choose an
 
351
 * item. Returns a key string corresponding to the choosen item or NULL if
 
352
 * no item has been selected.
 
353
 *
 
354
 * item_choice_data - Will be passed as the argument to the item_choice function
 
355
 *
 
356
 * Returns a pointer to the menu if successful, or NULL if there is
 
357
 * insufficient memory available to create the menu.
 
358
 */
 
359
struct menu *menu_create(char *title, int timeout, int prompt,
 
360
                                void (*item_data_print)(void *),
 
361
                                char *(*item_choice)(void *),
 
362
                                void *item_choice_data)
 
363
{
 
364
        struct menu *m;
 
365
 
 
366
        m = malloc(sizeof *m);
 
367
 
 
368
        if (!m)
 
369
                return NULL;
 
370
 
 
371
        m->default_item = NULL;
 
372
        m->prompt = prompt;
 
373
        m->timeout = timeout;
 
374
        m->item_data_print = item_data_print;
 
375
        m->item_choice = item_choice;
 
376
        m->item_choice_data = item_choice_data;
 
377
 
 
378
        if (title) {
 
379
                m->title = strdup(title);
 
380
                if (!m->title) {
 
381
                        free(m);
 
382
                        return NULL;
 
383
                }
 
384
        } else
 
385
                m->title = NULL;
 
386
 
 
387
 
 
388
        INIT_LIST_HEAD(&m->items);
 
389
 
 
390
        return m;
 
391
}
 
392
 
 
393
/*
 
394
 * menu_destroy() - frees the memory used by a menu and its items.
 
395
 *
 
396
 * m - Points to a menu created by menu_create().
 
397
 *
 
398
 * Returns 1 if successful, or -EINVAL if m is NULL.
 
399
 */
 
400
int menu_destroy(struct menu *m)
 
401
{
 
402
        if (!m)
 
403
                return -EINVAL;
 
404
 
 
405
        menu_items_iter(m, menu_item_destroy, NULL);
 
406
 
 
407
        if (m->title)
 
408
                free(m->title);
 
409
 
 
410
        free(m);
 
411
 
 
412
        return 1;
 
413
}