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

// SPDX-License-Identifier: GPL-2.0+
/*
 * Building an expo from an FDT description
 *
 * Copyright 2022 Google LLC
 * Written by Simon Glass <[email protected]>
 */

#define LOG_CATEGORY	LOGC_EXPO

#include <common.h>
#include <expo.h>
#include <fdtdec.h>
#include <log.h>
#include <malloc.h>
#include <dm/ofnode.h>
#include <linux/libfdt.h>

/**
 * struct build_info - Information to use when building
 *
 * @str_for_id: String for each ID in use, NULL if empty. The string is NULL
 *	if there is nothing for this ID. Since ID 0 is never used, the first
 *	element of this array is always NULL
 * @str_count: Number of entries in @str_for_id
 */
struct build_info {
	const char **str_for_id;
	int str_count;
};

/**
 * add_txt_str - Add a string or lookup its ID, then add to expo
 *
 * @info: Build information
 * @node: Node describing scene
 * @scn: Scene to add to
 * @find_name: Name to look for (e.g. "title"). This will find a property called
 * "title" if it exists, else will look up the string for "title-id"
 * Return: ID of added string, or -ve on error
 */
int add_txt_str(struct build_info *info, ofnode node, struct scene *scn,
		const char *find_name, uint obj_id)
{
	const char *text;
	uint str_id;
	int ret;

	text = ofnode_read_string(node, find_name);
	if (!text) {
		char name[40];
		u32 id;

		snprintf(name, sizeof(name), "%s-id", find_name);
		ret = ofnode_read_u32(node, name, &id);
		if (ret)
			return log_msg_ret("id", -EINVAL);

		if (id >= info->str_count)
			return log_msg_ret("id", -E2BIG);
		text = info->str_for_id[id];
		if (!text)
			return log_msg_ret("id", -EINVAL);
	}

	ret = expo_str(scn->expo, find_name, 0, text);
	if (ret < 0)
		return log_msg_ret("add", ret);
	str_id = ret;

	ret = scene_txt_str(scn, find_name, obj_id, str_id, text, NULL);
	if (ret < 0)
		return log_msg_ret("add", ret);

	return ret;
}

/**
 * add_txt_str_list - Add a list string or lookup its ID, then add to expo
 *
 * @info: Build information
 * @node: Node describing scene
 * @scn: Scene to add to
 * @find_name: Name to look for (e.g. "title"). This will find a string-list
 * property called "title" if it exists, else will look up the string in the
 * "title-id" string list.
 * Return: ID of added string, or -ve on error
 */
int add_txt_str_list(struct build_info *info, ofnode node, struct scene *scn,
		     const char *find_name, int index, uint obj_id)
{
	const char *text;
	uint str_id;
	int ret;

	ret = ofnode_read_string_index(node, find_name, index, &text);
	if (ret) {
		char name[40];
		u32 id;

		snprintf(name, sizeof(name), "%s-id", find_name);
		ret = ofnode_read_u32_index(node, name, index, &id);
		if (ret)
			return log_msg_ret("id", -ENOENT);

		if (id >= info->str_count)
			return log_msg_ret("id", -E2BIG);
		text = info->str_for_id[id];
		if (!text)
			return log_msg_ret("id", -EINVAL);
	}

	ret = expo_str(scn->expo, find_name, 0, text);
	if (ret < 0)
		return log_msg_ret("add", ret);
	str_id = ret;

	ret = scene_txt_str(scn, find_name, obj_id, str_id, text, NULL);
	if (ret < 0)
		return log_msg_ret("add", ret);

	return ret;
}

/*
 * build_element() - Handle creating a text object from a label
 *
 * Look up a property called @label or @label-id and create a string for it
 */
int build_element(void *ldtb, int node, const char *label)
{
	return 0;
}

/**
 * read_strings() - Read in the list of strings
 *
 * Read the strings into an ID-indexed list, so they can be used for building
 * an expo. The strings are in a /strings node and each has its own subnode
 * containing the ID and the string itself:
 *
 * example {
 *    id = <123>;
 *    value = "This is a test";
 * };
 *
 * Future work may add support for unicode and multiple languages
 *
 * @info: Build information
 * @root: Root node to read from
 * Returns: 0 if OK, -ENOMEM if out of memory, -EINVAL if there is a format
 * error
 */
static int read_strings(struct build_info *info, ofnode root)
{
	ofnode strings, node;

	strings = ofnode_find_subnode(root, "strings");
	if (!ofnode_valid(strings))
		return log_msg_ret("str", -EINVAL);

	ofnode_for_each_subnode(node, strings) {
		const char *val;
		int ret;
		u32 id;

		ret = ofnode_read_u32(node, "id", &id);
		if (ret)
			return log_msg_ret("id", -EINVAL);
		val = ofnode_read_string(node, "value");
		if (!val)
			return log_msg_ret("val", -EINVAL);

		if (id >= info->str_count) {
			int new_count = info->str_count + 20;
			void *new_arr;

			new_arr = realloc(info->str_for_id,
					  new_count * sizeof(char *));
			if (!new_arr)
				return log_msg_ret("id", -ENOMEM);
			memset(new_arr + info->str_count, '\0',
			       (new_count - info->str_count) * sizeof(char *));
			info->str_for_id = new_arr;
			info->str_count = new_count;
		}

		info->str_for_id[id] = val;
	}

	return 0;
}

/**
 * list_strings() - List the available strings with their IDs
 *
 * @info: Build information
 */
static void list_strings(struct build_info *info)
{
	int i;

	for (i = 0; i < info->str_count; i++) {
		if (info->str_for_id[i])
			printf("%3d %s\n", i, info->str_for_id[i]);
	}
}

/**
 * menu_build() - Build a menu and add it to a scene
 *
 * See doc/developer/expo.rst for a description of the format
 *
 * @info: Build information
 * @node: Node containing the menu description
 * @scn: Scene to add the menu to
 * Returns: 0 if OK, -ENOMEM if out of memory, -EINVAL if there is a format
 * error, -ENOENT if there is a references to a non-existent string
 */
static int menu_build(struct build_info *info, ofnode node, struct scene *scn)
{
	struct scene_obj_menu *menu;
	uint title_id, menu_id;
	const u32 *item_ids;
	int ret, size, i;
	const char *name;
	u32 id;

	name = ofnode_get_name(node);
	ret = ofnode_read_u32(node, "id", &id);
	if (ret)
		return log_msg_ret("id", -EINVAL);

	ret = scene_menu(scn, name, id, &menu);
	if (ret < 0)
		return log_msg_ret("men", ret);
	menu_id = ret;

	/* Set the title */
	ret = add_txt_str(info, node, scn, "title", 0);
	if (ret < 0)
		return log_msg_ret("tit", ret);
	title_id = ret;
	ret = scene_menu_set_title(scn, menu_id, title_id);

	item_ids = ofnode_read_prop(node, "item-id", &size);
	if (!item_ids)
		return log_msg_ret("itm", -EINVAL);
	if (!size || size % sizeof(u32))
		return log_msg_ret("isz", -EINVAL);
	size /= sizeof(u32);

	for (i = 0; i < size; i++) {
		struct scene_menitem *item;
		uint label, key, desc;

		ret = add_txt_str_list(info, node, scn, "item-label", i, 0);
		if (ret < 0 && ret != -ENOENT)
			return log_msg_ret("lab", ret);
		label = max(0, ret);

		ret = add_txt_str_list(info, node, scn, "key-label", i, 0);
		if (ret < 0 && ret != -ENOENT)
			return log_msg_ret("key", ret);
		key = max(0, ret);

		ret = add_txt_str_list(info, node, scn, "desc-label", i, 0);
		if (ret < 0  && ret != -ENOENT)
			return log_msg_ret("lab", ret);
		desc = max(0, ret);

		ret = scene_menuitem(scn, menu_id, simple_xtoa(i),
				     fdt32_to_cpu(item_ids[i]), key, label,
				     desc, 0, 0, &item);
		if (ret < 0)
			return log_msg_ret("mi", ret);
	}

	return 0;
}

/**
 * menu_build() - Build an expo object and add it to a scene
 *
 * See doc/developer/expo.rst for a description of the format
 *
 * @info: Build information
 * @node: Node containing the object description
 * @scn: Scene to add the object to
 * Returns: 0 if OK, -ENOMEM if out of memory, -EINVAL if there is a format
 * error, -ENOENT if there is a references to a non-existent string
 */
static int obj_build(struct build_info *info, ofnode node, struct scene *scn)
{
	const char *type;
	u32 id;
	int ret;

	log_debug("- object %s\n", ofnode_get_name(node));
	ret = ofnode_read_u32(node, "id", &id);
	if (ret)
		return log_msg_ret("id", -EINVAL);

	type = ofnode_read_string(node, "type");
	if (!type)
		return log_msg_ret("typ", -EINVAL);

	if (!strcmp("menu", type))
		ret = menu_build(info, node, scn);
	 else
		ret = -EINVAL;
	if (ret)
		return log_msg_ret("bld", ret);

	return 0;
}

/**
 * scene_build() - Build a scene and all its objects
 *
 * See doc/developer/expo.rst for a description of the format
 *
 * @info: Build information
 * @node: Node containing the scene description
 * @scn: Scene to add the object to
 * Returns: 0 if OK, -ENOMEM if out of memory, -EINVAL if there is a format
 * error, -ENOENT if there is a references to a non-existent string
 */
static int scene_build(struct build_info *info, ofnode scn_node,
		       struct expo *exp)
{
	const char *name;
	struct scene *scn;
	uint id, title_id;
	ofnode node;
	int ret;

	name = ofnode_get_name(scn_node);
	log_debug("Building scene %s\n", name);
	ret = ofnode_read_u32(scn_node, "id", &id);
	if (ret)
		return log_msg_ret("id", -EINVAL);

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

	ret = add_txt_str(info, scn_node, scn, "title", 0);
	if (ret < 0)
		return log_msg_ret("tit", ret);
	title_id = ret;
	scene_title_set(scn, title_id);

	ret = add_txt_str(info, scn_node, scn, "prompt", 0);
	if (ret < 0)
		return log_msg_ret("pr", ret);

	ofnode_for_each_subnode(node, scn_node) {
		ret = obj_build(info, node, scn);
		if (ret < 0)
			return log_msg_ret("mit", ret);
	}

	return 0;
}

int expo_build(ofnode root, struct expo **expp)
{
	struct build_info info;
	ofnode scenes, node;
	struct expo *exp;
	u32 dyn_start;
	int ret;

	memset(&info, '\0', sizeof(info));
	ret = read_strings(&info, root);
	if (ret)
		return log_msg_ret("str", ret);
	list_strings(&info);

	ret = expo_new("name", NULL, &exp);
	if (ret)
		return log_msg_ret("exp", ret);

	if (!ofnode_read_u32(root, "dynamic-start", &dyn_start))
		expo_set_dynamic_start(exp, dyn_start);

	scenes = ofnode_find_subnode(root, "scenes");
	if (!ofnode_valid(scenes))
		return log_msg_ret("sno", -EINVAL);

	ofnode_for_each_subnode(node, scenes) {
		ret = scene_build(&info, node, exp);
		if (ret < 0)
			return log_msg_ret("scn", ret);
	}
	*expp = exp;

	return 0;
}
Commit	Line	Data
82cafee1 SG	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Building an expo from an FDT description
	4	*
	5	* Copyright 2022 Google LLC
	6	* Written by Simon Glass <[email protected]>
	7	*/
	8
	9	#define LOG_CATEGORY LOGC_EXPO
	10
	11	#include <common.h>
	12	#include <expo.h>
	13	#include <fdtdec.h>
	14	#include <log.h>
	15	#include <malloc.h>
	16	#include <dm/ofnode.h>
	17	#include <linux/libfdt.h>
	18
	19	/**
	20	* struct build_info - Information to use when building
	21	*
	22	* @str_for_id: String for each ID in use, NULL if empty. The string is NULL
	23	* if there is nothing for this ID. Since ID 0 is never used, the first
	24	* element of this array is always NULL
	25	* @str_count: Number of entries in @str_for_id
	26	*/
	27	struct build_info {
	28	const char **str_for_id;
	29	int str_count;
	30	};
	31
	32	/**
	33	* add_txt_str - Add a string or lookup its ID, then add to expo
	34	*
	35	* @info: Build information
	36	* @node: Node describing scene
	37	* @scn: Scene to add to
	38	* @find_name: Name to look for (e.g. "title"). This will find a property called
	39	* "title" if it exists, else will look up the string for "title-id"
	40	* Return: ID of added string, or -ve on error
	41	*/
	42	int add_txt_str(struct build_info info, ofnode node, struct scene scn,
	43	const char *find_name, uint obj_id)
	44	{
	45	const char *text;
	46	uint str_id;
	47	int ret;
	48
	49	text = ofnode_read_string(node, find_name);
	50	if (!text) {
	51	char name[40];
	52	u32 id;
	53
	54	snprintf(name, sizeof(name), "%s-id", find_name);
	55	ret = ofnode_read_u32(node, name, &id);
	56	if (ret)
	57	return log_msg_ret("id", -EINVAL);
	58
	59	if (id >= info->str_count)
	60	return log_msg_ret("id", -E2BIG);
	61	text = info->str_for_id[id];
	62	if (!text)
	63	return log_msg_ret("id", -EINVAL);
	64	}
65
66	ret = expo_str(scn->expo, find_name, 0, text);
67	if (ret < 0)
68	return log_msg_ret("add", ret);
69	str_id = ret;
70
71	ret = scene_txt_str(scn, find_name, obj_id, str_id, text, NULL);
72	if (ret < 0)
73	return log_msg_ret("add", ret);
74
75	return ret;
76	}
77
78	/**
79	* add_txt_str_list - Add a list string or lookup its ID, then add to expo
80	*
81	* @info: Build information
82	* @node: Node describing scene
83	* @scn: Scene to add to
84	* @find_name: Name to look for (e.g. "title"). This will find a string-list
85	* property called "title" if it exists, else will look up the string in the
86	* "title-id" string list.
87	* Return: ID of added string, or -ve on error
88	*/
89	int add_txt_str_list(struct build_info info, ofnode node, struct scene scn,
90	const char *find_name, int index, uint obj_id)
91	{
92	const char *text;
93	uint str_id;
94	int ret;
95
96	ret = ofnode_read_string_index(node, find_name, index, &text);
97	if (ret) {
98	char name[40];
99	u32 id;
100
101	snprintf(name, sizeof(name), "%s-id", find_name);
102	ret = ofnode_read_u32_index(node, name, index, &id);
103	if (ret)
104	return log_msg_ret("id", -ENOENT);
105
106	if (id >= info->str_count)
107	return log_msg_ret("id", -E2BIG);
108	text = info->str_for_id[id];
109	if (!text)
110	return log_msg_ret("id", -EINVAL);
111	}
112
113	ret = expo_str(scn->expo, find_name, 0, text);
114	if (ret < 0)
115	return log_msg_ret("add", ret);
116	str_id = ret;
117
118	ret = scene_txt_str(scn, find_name, obj_id, str_id, text, NULL);
119	if (ret < 0)
120	return log_msg_ret("add", ret);
121
122	return ret;
123	}
124
125	/*
126	* build_element() - Handle creating a text object from a label
127	*
128	* Look up a property called @label or @label-id and create a string for it
129	*/
130	int build_element(void ldtb, int node, const char label)
131	{
132	return 0;
133	}
134
135	/**
136	* read_strings() - Read in the list of strings
137	*
138	* Read the strings into an ID-indexed list, so they can be used for building
139	* an expo. The strings are in a /strings node and each has its own subnode
140	* containing the ID and the string itself:
141	*
142	* example {
143	* id = <123>;
144	* value = "This is a test";
145	* };
146	*
147	* Future work may add support for unicode and multiple languages
148	*
149	* @info: Build information
150	* @root: Root node to read from
151	* Returns: 0 if OK, -ENOMEM if out of memory, -EINVAL if there is a format
152	* error
153	*/
154	static int read_strings(struct build_info *info, ofnode root)
155	{
156	ofnode strings, node;
157
158	strings = ofnode_find_subnode(root, "strings");
159	if (!ofnode_valid(strings))
160	return log_msg_ret("str", -EINVAL);
161
162	ofnode_for_each_subnode(node, strings) {
163	const char *val;
164	int ret;
165	u32 id;
166
167	ret = ofnode_read_u32(node, "id", &id);
168	if (ret)
169	return log_msg_ret("id", -EINVAL);
170	val = ofnode_read_string(node, "value");
171	if (!val)
172	return log_msg_ret("val", -EINVAL);
173
174	if (id >= info->str_count) {
175	int new_count = info->str_count + 20;
176	void *new_arr;
177
178	new_arr = realloc(info->str_for_id,
179	new_count * sizeof(char *));
180	if (!new_arr)
181	return log_msg_ret("id", -ENOMEM);
182	memset(new_arr + info->str_count, '\0',
183	(new_count - info->str_count) * sizeof(char *));
184	info->str_for_id = new_arr;
185	info->str_count = new_count;
186	}
187
188	info->str_for_id[id] = val;
189	}
190
191	return 0;
192	}
193
194	/**
195	* list_strings() - List the available strings with their IDs
196	*
197	* @info: Build information
198	*/
199	static void list_strings(struct build_info *info)
200	{
201	int i;
202
203	for (i = 0; i < info->str_count; i++) {
204	if (info->str_for_id[i])
205	printf("%3d %s\n", i, info->str_for_id[i]);
206	}
207	}
208
209	/**
210	* menu_build() - Build a menu and add it to a scene
211	*
212	* See doc/developer/expo.rst for a description of the format
213	*
214	* @info: Build information
215	* @node: Node containing the menu description
216	* @scn: Scene to add the menu to
217	* Returns: 0 if OK, -ENOMEM if out of memory, -EINVAL if there is a format
218	* error, -ENOENT if there is a references to a non-existent string
219	*/
220	static int menu_build(struct build_info info, ofnode node, struct scene scn)
221	{
222	struct scene_obj_menu *menu;
223	uint title_id, menu_id;
224	const u32 *item_ids;
225	int ret, size, i;
226	const char *name;
227	u32 id;
228
229	name = ofnode_get_name(node);
230	ret = ofnode_read_u32(node, "id", &id);
231	if (ret)
232	return log_msg_ret("id", -EINVAL);
233
234	ret = scene_menu(scn, name, id, &menu);
235	if (ret < 0)
236	return log_msg_ret("men", ret);
237	menu_id = ret;
238
239	/* Set the title */
240	ret = add_txt_str(info, node, scn, "title", 0);
241	if (ret < 0)
242	return log_msg_ret("tit", ret);
243	title_id = ret;
244	ret = scene_menu_set_title(scn, menu_id, title_id);
245
246	item_ids = ofnode_read_prop(node, "item-id", &size);
247	if (!item_ids)
248	return log_msg_ret("itm", -EINVAL);
249	if (!size \|\| size % sizeof(u32))
250	return log_msg_ret("isz", -EINVAL);
251	size /= sizeof(u32);
252
253	for (i = 0; i < size; i++) {
254	struct scene_menitem *item;
255	uint label, key, desc;
256
257	ret = add_txt_str_list(info, node, scn, "item-label", i, 0);
258	if (ret < 0 && ret != -ENOENT)
259	return log_msg_ret("lab", ret);
260	label = max(0, ret);
261
262	ret = add_txt_str_list(info, node, scn, "key-label", i, 0);
263	if (ret < 0 && ret != -ENOENT)
264	return log_msg_ret("key", ret);
265	key = max(0, ret);
266
267	ret = add_txt_str_list(info, node, scn, "desc-label", i, 0);
268	if (ret < 0 && ret != -ENOENT)
269	return log_msg_ret("lab", ret);
270	desc = max(0, ret);
271
272	ret = scene_menuitem(scn, menu_id, simple_xtoa(i),
273	fdt32_to_cpu(item_ids[i]), key, label,
274	desc, 0, 0, &item);
275	if (ret < 0)
276	return log_msg_ret("mi", ret);
277	}
278
279	return 0;
280	}
281
282	/**
283	* menu_build() - Build an expo object and add it to a scene
284	*
285	* See doc/developer/expo.rst for a description of the format
286	*
287	* @info: Build information
288	* @node: Node containing the object description
289	* @scn: Scene to add the object to
290	* Returns: 0 if OK, -ENOMEM if out of memory, -EINVAL if there is a format
291	* error, -ENOENT if there is a references to a non-existent string
292	*/
293	static int obj_build(struct build_info info, ofnode node, struct scene scn)
294	{
295	const char *type;
296	u32 id;
297	int ret;
298
299	log_debug("- object %s\n", ofnode_get_name(node));
300	ret = ofnode_read_u32(node, "id", &id);
301	if (ret)
302	return log_msg_ret("id", -EINVAL);
303
304	type = ofnode_read_string(node, "type");
305	if (!type)
306	return log_msg_ret("typ", -EINVAL);
307
308	if (!strcmp("menu", type))
309	ret = menu_build(info, node, scn);
310	else
311	ret = -EINVAL;
312	if (ret)
313	return log_msg_ret("bld", ret);
314
315	return 0;
316	}
317
318	/**
319	* scene_build() - Build a scene and all its objects
320	*
321	* See doc/developer/expo.rst for a description of the format
322	*
323	* @info: Build information
324	* @node: Node containing the scene description
325	* @scn: Scene to add the object to
326	* Returns: 0 if OK, -ENOMEM if out of memory, -EINVAL if there is a format
327	* error, -ENOENT if there is a references to a non-existent string
328	*/
329	static int scene_build(struct build_info *info, ofnode scn_node,
330	struct expo *exp)
331	{
332	const char *name;
333	struct scene *scn;
334	uint id, title_id;
335	ofnode node;
336	int ret;
337
338	name = ofnode_get_name(scn_node);
339	log_debug("Building scene %s\n", name);
340	ret = ofnode_read_u32(scn_node, "id", &id);
341	if (ret)
342	return log_msg_ret("id", -EINVAL);
343
344	ret = scene_new(exp, name, id, &scn);
345	if (ret < 0)
346	return log_msg_ret("scn", ret);
347
348	ret = add_txt_str(info, scn_node, scn, "title", 0);
349	if (ret < 0)
350	return log_msg_ret("tit", ret);
351	title_id = ret;
352	scene_title_set(scn, title_id);
353
354	ret = add_txt_str(info, scn_node, scn, "prompt", 0);
355	if (ret < 0)
356	return log_msg_ret("pr", ret);
357
358	ofnode_for_each_subnode(node, scn_node) {
359	ret = obj_build(info, node, scn);
360	if (ret < 0)
361	return log_msg_ret("mit", ret);
362	}
363
364	return 0;
365	}
366
367	int expo_build(ofnode root, struct expo **expp)
368	{
369	struct build_info info;
370	ofnode scenes, node;
371	struct expo *exp;
372	u32 dyn_start;
373	int ret;
374
375	memset(&info, '\0', sizeof(info));
376	ret = read_strings(&info, root);
377	if (ret)
378	return log_msg_ret("str", ret);
379	list_strings(&info);
380
381	ret = expo_new("name", NULL, &exp);
382	if (ret)
383	return log_msg_ret("exp", ret);
384
385	if (!ofnode_read_u32(root, "dynamic-start", &dyn_start))
386	expo_set_dynamic_start(exp, dyn_start);
387
388	scenes = ofnode_find_subnode(root, "scenes");
389	if (!ofnode_valid(scenes))
390	return log_msg_ret("sno", -EINVAL);
391
392	ofnode_for_each_subnode(node, scenes) {
393	ret = scene_build(&info, node, exp);
394	if (ret < 0)
395	return log_msg_ret("scn", ret);
396	}
397	*expp = exp;
398
399	return 0;
400	}