[linux-2.6-block.git] / scripts / dtc / yamltree.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * (C) Copyright Linaro, Ltd. 2018
 * (C) Copyright Arm Holdings.  2017
 * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2005.
 */

#include <stdlib.h>
#include <yaml.h>
#include "dtc.h"
#include "srcpos.h"

char *yaml_error_name[] = {
	[YAML_NO_ERROR] = "no error",
	[YAML_MEMORY_ERROR] = "memory error",
	[YAML_READER_ERROR] = "reader error",
	[YAML_SCANNER_ERROR] = "scanner error",
	[YAML_PARSER_ERROR] = "parser error",
	[YAML_COMPOSER_ERROR] = "composer error",
	[YAML_WRITER_ERROR] = "writer error",
	[YAML_EMITTER_ERROR] = "emitter error",
};

#define yaml_emitter_emit_or_die(emitter, event) (			\
{									\
	if (!yaml_emitter_emit(emitter, event))				\
		die("yaml '%s': %s in %s, line %i\n",			\
		    yaml_error_name[(emitter)->error], 			\
		    (emitter)->problem, __func__, __LINE__);		\
})

static void yaml_propval_int(yaml_emitter_t *emitter, struct marker *markers, char *data, int len, int width)
{
	yaml_event_t event;
	void *tag;
	int off, start_offset = markers->offset;

	switch(width) {
		case 1: tag = "!u8"; break;
		case 2: tag = "!u16"; break;
		case 4: tag = "!u32"; break;
		case 8: tag = "!u64"; break;
		default:
			die("Invalid width %i", width);
	}
	assert(len % width == 0);

	yaml_sequence_start_event_initialize(&event, NULL,
		(yaml_char_t *)tag, width == 4, YAML_FLOW_SEQUENCE_STYLE);
	yaml_emitter_emit_or_die(emitter, &event);

	for (off = 0; off < len; off += width) {
		char buf[32];
		struct marker *m;
		bool is_phandle = false;

		switch(width) {
		case 1:
			sprintf(buf, "0x%"PRIx8, *(uint8_t*)(data + off));
			break;
		case 2:
			sprintf(buf, "0x%"PRIx16, fdt16_to_cpu(*(fdt16_t*)(data + off)));
			break;
		case 4:
			sprintf(buf, "0x%"PRIx32, fdt32_to_cpu(*(fdt32_t*)(data + off)));
			m = markers;
			is_phandle = false;
			for_each_marker_of_type(m, REF_PHANDLE) {
				if (m->offset == (start_offset + off)) {
					is_phandle = true;
					break;
				}
			}
			break;
		case 8:
			sprintf(buf, "0x%"PRIx64, fdt64_to_cpu(*(fdt64_t*)(data + off)));
			break;
		}

		if (is_phandle)
			yaml_scalar_event_initialize(&event, NULL,
				(yaml_char_t*)"!phandle", (yaml_char_t *)buf,
				strlen(buf), 0, 0, YAML_PLAIN_SCALAR_STYLE);
		else
			yaml_scalar_event_initialize(&event, NULL,
				(yaml_char_t*)YAML_INT_TAG, (yaml_char_t *)buf,
				strlen(buf), 1, 1, YAML_PLAIN_SCALAR_STYLE);
		yaml_emitter_emit_or_die(emitter, &event);
	}

	yaml_sequence_end_event_initialize(&event);
	yaml_emitter_emit_or_die(emitter, &event);
}

static void yaml_propval_string(yaml_emitter_t *emitter, char *str, int len)
{
	yaml_event_t event;
	int i;

	assert(str[len-1] == '\0');

	/* Make sure the entire string is in the lower 7-bit ascii range */
	for (i = 0; i < len; i++)
		assert(isascii(str[i]));

	yaml_scalar_event_initialize(&event, NULL,
		(yaml_char_t *)YAML_STR_TAG, (yaml_char_t*)str,
		len-1, 0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE);
	yaml_emitter_emit_or_die(emitter, &event);
}

static void yaml_propval(yaml_emitter_t *emitter, struct property *prop)
{
	yaml_event_t event;
	int len = prop->val.len;
	struct marker *m = prop->val.markers;

	/* Emit the property name */
	yaml_scalar_event_initialize(&event, NULL,
		(yaml_char_t *)YAML_STR_TAG, (yaml_char_t*)prop->name,
		strlen(prop->name), 1, 1, YAML_PLAIN_SCALAR_STYLE);
	yaml_emitter_emit_or_die(emitter, &event);

	/* Boolean properties are easiest to deal with. Length is zero, so just emit 'true' */
	if (len == 0) {
		yaml_scalar_event_initialize(&event, NULL,
			(yaml_char_t *)YAML_BOOL_TAG,
			(yaml_char_t*)"true",
			strlen("true"), 1, 0, YAML_PLAIN_SCALAR_STYLE);
		yaml_emitter_emit_or_die(emitter, &event);
		return;
	}

	if (!m)
		die("No markers present in property '%s' value\n", prop->name);

	yaml_sequence_start_event_initialize(&event, NULL,
		(yaml_char_t *)YAML_SEQ_TAG, 1, YAML_FLOW_SEQUENCE_STYLE);
	yaml_emitter_emit_or_die(emitter, &event);

	for_each_marker(m) {
		int chunk_len;
		char *data = &prop->val.val[m->offset];

		if (m->type < TYPE_UINT8)
			continue;

		chunk_len = type_marker_length(m) ? : len;
		assert(chunk_len > 0);
		len -= chunk_len;

		switch(m->type) {
		case TYPE_UINT16:
			yaml_propval_int(emitter, m, data, chunk_len, 2);
			break;
		case TYPE_UINT32:
			yaml_propval_int(emitter, m, data, chunk_len, 4);
			break;
		case TYPE_UINT64:
			yaml_propval_int(emitter, m, data, chunk_len, 8);
			break;
		case TYPE_STRING:
			yaml_propval_string(emitter, data, chunk_len);
			break;
		default:
			yaml_propval_int(emitter, m, data, chunk_len, 1);
			break;
		}
	}

	yaml_sequence_end_event_initialize(&event);
	yaml_emitter_emit_or_die(emitter, &event);
}


static void yaml_tree(struct node *tree, yaml_emitter_t *emitter)
{
	struct property *prop;
	struct node *child;
	yaml_event_t event;

	if (tree->deleted)
		return;

	yaml_mapping_start_event_initialize(&event, NULL,
		(yaml_char_t *)YAML_MAP_TAG, 1, YAML_ANY_MAPPING_STYLE);
	yaml_emitter_emit_or_die(emitter, &event);

	for_each_property(tree, prop)
		yaml_propval(emitter, prop);

	/* Loop over all the children, emitting them into the map */
	for_each_child(tree, child) {
		yaml_scalar_event_initialize(&event, NULL,
			(yaml_char_t *)YAML_STR_TAG, (yaml_char_t*)child->name,
			strlen(child->name), 1, 0, YAML_PLAIN_SCALAR_STYLE);
		yaml_emitter_emit_or_die(emitter, &event);
		yaml_tree(child, emitter);
	}

	yaml_mapping_end_event_initialize(&event);
	yaml_emitter_emit_or_die(emitter, &event);
}

void dt_to_yaml(FILE *f, struct dt_info *dti)
{
	yaml_emitter_t emitter;
	yaml_event_t event;

	yaml_emitter_initialize(&emitter);
	yaml_emitter_set_output_file(&emitter, f);
	yaml_stream_start_event_initialize(&event, YAML_UTF8_ENCODING);
	yaml_emitter_emit_or_die(&emitter, &event);

	yaml_document_start_event_initialize(&event, NULL, NULL, NULL, 0);
	yaml_emitter_emit_or_die(&emitter, &event);

	yaml_sequence_start_event_initialize(&event, NULL, (yaml_char_t *)YAML_SEQ_TAG, 1, YAML_ANY_SEQUENCE_STYLE);
	yaml_emitter_emit_or_die(&emitter, &event);

	yaml_tree(dti->dt, &emitter);

	yaml_sequence_end_event_initialize(&event);
	yaml_emitter_emit_or_die(&emitter, &event);

	yaml_document_end_event_initialize(&event, 0);
	yaml_emitter_emit_or_die(&emitter, &event);

	yaml_stream_end_event_initialize(&event);
	yaml_emitter_emit_or_die(&emitter, &event);

	yaml_emitter_delete(&emitter);
}
Commit	Line	Data
1a59d1b8	1	// SPDX-License-Identifier: GPL-2.0-or-later
f858927f RH	2	/*
	3	* (C) Copyright Linaro, Ltd. 2018
	4	* (C) Copyright Arm Holdings. 2017
	5	* (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation. 2005.
f858927f RH	6	*/
	7
	8	#include <stdlib.h>
	9	#include <yaml.h>
	10	#include "dtc.h"
	11	#include "srcpos.h"
	12
	13	char *yaml_error_name[] = {
	14	[YAML_NO_ERROR] = "no error",
	15	[YAML_MEMORY_ERROR] = "memory error",
	16	[YAML_READER_ERROR] = "reader error",
	17	[YAML_SCANNER_ERROR] = "scanner error",
	18	[YAML_PARSER_ERROR] = "parser error",
	19	[YAML_COMPOSER_ERROR] = "composer error",
	20	[YAML_WRITER_ERROR] = "writer error",
	21	[YAML_EMITTER_ERROR] = "emitter error",
	22	};
	23
	24	#define yaml_emitter_emit_or_die(emitter, event) ( \
	25	{ \
	26	if (!yaml_emitter_emit(emitter, event)) \
	27	die("yaml '%s': %s in %s, line %i\n", \
	28	yaml_error_name[(emitter)->error], \
	29	(emitter)->problem, __func__, __LINE__); \
	30	})
	31
	32	static void yaml_propval_int(yaml_emitter_t emitter, struct marker markers, char *data, int len, int width)
	33	{
	34	yaml_event_t event;
	35	void *tag;
	36	int off, start_offset = markers->offset;
	37
	38	switch(width) {
	39	case 1: tag = "!u8"; break;
	40	case 2: tag = "!u16"; break;
	41	case 4: tag = "!u32"; break;
	42	case 8: tag = "!u64"; break;
	43	default:
	44	die("Invalid width %i", width);
	45	}
	46	assert(len % width == 0);
	47
	48	yaml_sequence_start_event_initialize(&event, NULL,
	49	(yaml_char_t *)tag, width == 4, YAML_FLOW_SEQUENCE_STYLE);
	50	yaml_emitter_emit_or_die(emitter, &event);
	51
	52	for (off = 0; off < len; off += width) {
	53	char buf[32];
	54	struct marker *m;
	55	bool is_phandle = false;
	56
	57	switch(width) {
	58	case 1:
	59	sprintf(buf, "0x%"PRIx8, (uint8_t)(data + off));
	60	break;
	61	case 2:
	62	sprintf(buf, "0x%"PRIx16, fdt16_to_cpu((fdt16_t)(data + off)));
	63	break;
	64	case 4:
	65	sprintf(buf, "0x%"PRIx32, fdt32_to_cpu((fdt32_t)(data + off)));
	66	m = markers;
	67	is_phandle = false;
	68	for_each_marker_of_type(m, REF_PHANDLE) {
	69	if (m->offset == (start_offset + off)) {
70	is_phandle = true;
71	break;
72	}
73	}
74	break;
75	case 8:
76	sprintf(buf, "0x%"PRIx64, fdt64_to_cpu((fdt64_t)(data + off)));
77	break;
78	}
79
80	if (is_phandle)
81	yaml_scalar_event_initialize(&event, NULL,
82	(yaml_char_t)"!phandle", (yaml_char_t )buf,
83	strlen(buf), 0, 0, YAML_PLAIN_SCALAR_STYLE);
84	else
85	yaml_scalar_event_initialize(&event, NULL,
86	(yaml_char_t)YAML_INT_TAG, (yaml_char_t )buf,
87	strlen(buf), 1, 1, YAML_PLAIN_SCALAR_STYLE);
88	yaml_emitter_emit_or_die(emitter, &event);
89	}
90
91	yaml_sequence_end_event_initialize(&event);
92	yaml_emitter_emit_or_die(emitter, &event);
93	}
94
95	static void yaml_propval_string(yaml_emitter_t emitter, char str, int len)
96	{
97	yaml_event_t event;
98	int i;
99
100	assert(str[len-1] == '\0');
101
102	/* Make sure the entire string is in the lower 7-bit ascii range */
103	for (i = 0; i < len; i++)
104	assert(isascii(str[i]));
105
106	yaml_scalar_event_initialize(&event, NULL,
107	(yaml_char_t )YAML_STR_TAG, (yaml_char_t)str,
108	len-1, 0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE);
109	yaml_emitter_emit_or_die(emitter, &event);
110	}
111
112	static void yaml_propval(yaml_emitter_t emitter, struct property prop)
113	{
114	yaml_event_t event;
115	int len = prop->val.len;
116	struct marker *m = prop->val.markers;
117
118	/* Emit the property name */
119	yaml_scalar_event_initialize(&event, NULL,
120	(yaml_char_t )YAML_STR_TAG, (yaml_char_t)prop->name,
121	strlen(prop->name), 1, 1, YAML_PLAIN_SCALAR_STYLE);
122	yaml_emitter_emit_or_die(emitter, &event);
123
124	/* Boolean properties are easiest to deal with. Length is zero, so just emit 'true' */
125	if (len == 0) {
126	yaml_scalar_event_initialize(&event, NULL,
127	(yaml_char_t *)YAML_BOOL_TAG,
128	(yaml_char_t*)"true",
129	strlen("true"), 1, 0, YAML_PLAIN_SCALAR_STYLE);
130	yaml_emitter_emit_or_die(emitter, &event);
131	return;
132	}
133
134	if (!m)
135	die("No markers present in property '%s' value\n", prop->name);
136
137	yaml_sequence_start_event_initialize(&event, NULL,
138	(yaml_char_t *)YAML_SEQ_TAG, 1, YAML_FLOW_SEQUENCE_STYLE);
139	yaml_emitter_emit_or_die(emitter, &event);
140
141	for_each_marker(m) {
142	int chunk_len;
143	char *data = &prop->val.val[m->offset];
144
145	if (m->type < TYPE_UINT8)
146	continue;
147
148	chunk_len = type_marker_length(m) ? : len;
149	assert(chunk_len > 0);
150	len -= chunk_len;
151
152	switch(m->type) {
153	case TYPE_UINT16:
154	yaml_propval_int(emitter, m, data, chunk_len, 2);
155	break;
156	case TYPE_UINT32:
157	yaml_propval_int(emitter, m, data, chunk_len, 4);
158	break;
159	case TYPE_UINT64:
160	yaml_propval_int(emitter, m, data, chunk_len, 8);
161	break;
162	case TYPE_STRING:
163	yaml_propval_string(emitter, data, chunk_len);
164	break;
165	default:
166	yaml_propval_int(emitter, m, data, chunk_len, 1);
167	break;
168	}
169	}
170
171	yaml_sequence_end_event_initialize(&event);
172	yaml_emitter_emit_or_die(emitter, &event);
173	}
174
175
176	static void yaml_tree(struct node tree, yaml_emitter_t emitter)
177	{
178	struct property *prop;
179	struct node *child;
180	yaml_event_t event;
181
182	if (tree->deleted)
183	return;
184
185	yaml_mapping_start_event_initialize(&event, NULL,
186	(yaml_char_t *)YAML_MAP_TAG, 1, YAML_ANY_MAPPING_STYLE);
187	yaml_emitter_emit_or_die(emitter, &event);
188
189	for_each_property(tree, prop)
190	yaml_propval(emitter, prop);
191
192	/* Loop over all the children, emitting them into the map */
193	for_each_child(tree, child) {
194	yaml_scalar_event_initialize(&event, NULL,
195	(yaml_char_t )YAML_STR_TAG, (yaml_char_t)child->name,
196	strlen(child->name), 1, 0, YAML_PLAIN_SCALAR_STYLE);
197	yaml_emitter_emit_or_die(emitter, &event);
198	yaml_tree(child, emitter);
199	}
200
201	yaml_mapping_end_event_initialize(&event);
202	yaml_emitter_emit_or_die(emitter, &event);
203	}
204
205	void dt_to_yaml(FILE f, struct dt_info dti)
206	{
207	yaml_emitter_t emitter;
208	yaml_event_t event;
209
210	yaml_emitter_initialize(&emitter);
211	yaml_emitter_set_output_file(&emitter, f);
212	yaml_stream_start_event_initialize(&event, YAML_UTF8_ENCODING);
213	yaml_emitter_emit_or_die(&emitter, &event);
214
215	yaml_document_start_event_initialize(&event, NULL, NULL, NULL, 0);
216	yaml_emitter_emit_or_die(&emitter, &event);
217
218	yaml_sequence_start_event_initialize(&event, NULL, (yaml_char_t *)YAML_SEQ_TAG, 1, YAML_ANY_SEQUENCE_STYLE);
219	yaml_emitter_emit_or_die(&emitter, &event);
220
221	yaml_tree(dti->dt, &emitter);
222
223	yaml_sequence_end_event_initialize(&event);
224	yaml_emitter_emit_or_die(&emitter, &event);
225
226	yaml_document_end_event_initialize(&event, 0);
227	yaml_emitter_emit_or_die(&emitter, &event);
228
229	yaml_stream_end_event_initialize(&event);
230	yaml_emitter_emit_or_die(&emitter, &event);
231
232	yaml_emitter_delete(&emitter);
233	}