xref: /openbmc/u-boot/common/eeprom/eeprom_field.c (revision f77d4410) 
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * (C) Copyright 2009-2016 CompuLab, Ltd.
4  *
5  * Authors: Nikita Kiryanov <nikita@compulab.co.il>
6  *	    Igor Grinberg <grinberg@compulab.co.il>
7  */
8 
9 #include <common.h>
10 #include <linux/string.h>
11 #include <eeprom_field.h>
12 
13 static void __eeprom_field_print_bin(const struct eeprom_field *field,
14 				     char *delimiter, bool reverse)
15 {
16 	int i;
17 	int from = reverse ? field->size - 1 : 0;
18 	int to = reverse ? 0 : field->size - 1;
19 
20 	printf(PRINT_FIELD_SEGMENT, field->name);
21 	for (i = from; i != to; reverse ? i-- : i++)
22 		printf("%02x%s", field->buf[i], delimiter);
23 
24 	printf("%02x\n", field->buf[i]);
25 }
26 
27 static int __eeprom_field_update_bin(struct eeprom_field *field,
28 				     const char *value, bool reverse)
29 {
30 	int len = strlen(value);
31 	int k, j, i = reverse ? len - 1 : 0;
32 	unsigned char byte;
33 	char *endptr;
34 
35 	/* each two characters in the string fit in one byte */
36 	if (len > field->size * 2)
37 		return -1;
38 
39 	memset(field->buf, 0, field->size);
40 
41 	/* i - string iterator, j - buf iterator */
42 	for (j = 0; j < field->size; j++) {
43 		byte = 0;
44 		char tmp[3] = { 0, 0, 0 };
45 
46 		if ((reverse && i < 0) || (!reverse && i >= len))
47 			break;
48 
49 		for (k = 0; k < 2; k++) {
50 			if (reverse && i == 0) {
51 				tmp[k] = value[i];
52 				break;
53 			}
54 
55 			tmp[k] = value[reverse ? i - 1 + k : i + k];
56 		}
57 
58 		byte = simple_strtoul(tmp, &endptr, 0);
59 		if (*endptr != '\0' || byte < 0)
60 			return -1;
61 
62 		field->buf[j] = byte;
63 		i = reverse ? i - 2 : i + 2;
64 	}
65 
66 	return 0;
67 }
68 
69 static int __eeprom_field_update_bin_delim(struct eeprom_field *field,
70 					   char *value, char *delimiter)
71 {
72 	int count = 0;
73 	int i, val;
74 	const char *tmp = value;
75 	char *tok;
76 	char *endptr;
77 
78 	tmp = strstr(tmp, delimiter);
79 	while (tmp != NULL) {
80 		count++;
81 		tmp++;
82 		tmp = strstr(tmp, delimiter);
83 	}
84 
85 	if (count > field->size)
86 		return -1;
87 
88 	tok = strtok(value, delimiter);
89 	for (i = 0; tok && i < field->size; i++) {
90 		val = simple_strtoul(tok, &endptr, 0);
91 		if (*endptr != '\0')
92 			return -1;
93 
94 		/* here we assume that each tok is no more than byte long */
95 		field->buf[i] = (unsigned char)val;
96 		tok = strtok(NULL, delimiter);
97 	}
98 
99 	return 0;
100 }
101 
102 /**
103  * eeprom_field_print_bin() - print a field which contains binary data
104  *
105  * Treat the field data as simple binary data, and print it as two digit
106  * hexadecimal values.
107  * Sample output:
108  *      Field Name       0102030405060708090a
109  *
110  * @field:	an initialized field to print
111  */
112 void eeprom_field_print_bin(const struct eeprom_field *field)
113 {
114 	__eeprom_field_print_bin(field, "", false);
115 }
116 
117 /**
118  * eeprom_field_update_bin() - Update field with new data in binary form
119  *
120  * @field:	an initialized field
121  * @value:	a string of values (i.e. "10b234a")
122  */
123 int eeprom_field_update_bin(struct eeprom_field *field, char *value)
124 {
125 	return __eeprom_field_update_bin(field, value, false);
126 }
127 
128 /**
129  * eeprom_field_update_reserved() - Update reserved field with new data in
130  *				    binary form
131  *
132  * @field:	an initialized field
133  * @value:	a space delimited string of byte values (i.e. "1 02 3 0x4")
134  */
135 int eeprom_field_update_reserved(struct eeprom_field *field, char *value)
136 {
137 	return __eeprom_field_update_bin_delim(field, value, " ");
138 }
139 
140 /**
141  * eeprom_field_print_bin_rev() - print a field which contains binary data in
142  *				  reverse order
143  *
144  * Treat the field data as simple binary data, and print it in reverse order
145  * as two digit hexadecimal values.
146  *
147  * Data in field:
148  *                      0102030405060708090a
149  * Sample output:
150  *      Field Name      0a090807060504030201
151  *
152  * @field:	an initialized field to print
153  */
154 void eeprom_field_print_bin_rev(const struct eeprom_field *field)
155 {
156 	__eeprom_field_print_bin(field, "", true);
157 }
158 
159 /**
160  * eeprom_field_update_bin_rev() - Update field with new data in binary form,
161  *				   storing it in reverse
162  *
163  * This function takes a string of byte values, and stores them
164  * in the field in the reverse order. i.e. if the input string was "1234",
165  * "3412" will be written to the field.
166  *
167  * @field:	an initialized field
168  * @value:	a string of byte values
169  */
170 int eeprom_field_update_bin_rev(struct eeprom_field *field, char *value)
171 {
172 	return __eeprom_field_update_bin(field, value, true);
173 }
174 
175 /**
176  * eeprom_field_print_mac_addr() - print a field which contains a mac address
177  *
178  * Treat the field data as simple binary data, and print it formatted as a MAC
179  * address.
180  * Sample output:
181  *      Field Name     01:02:03:04:05:06
182  *
183  * @field:	an initialized field to print
184  */
185 void eeprom_field_print_mac(const struct eeprom_field *field)
186 {
187 	__eeprom_field_print_bin(field, ":", false);
188 }
189 
190 /**
191  * eeprom_field_update_mac() - Update a mac address field which contains binary
192  *			       data
193  *
194  * @field:	an initialized field
195  * @value:	a colon delimited string of byte values (i.e. "1:02:3:ff")
196  */
197 int eeprom_field_update_mac(struct eeprom_field *field, char *value)
198 {
199 	return __eeprom_field_update_bin_delim(field, value, ":");
200 }
201 
202 /**
203  * eeprom_field_print_ascii() - print a field which contains ASCII data
204  * @field:	an initialized field to print
205  */
206 void eeprom_field_print_ascii(const struct eeprom_field *field)
207 {
208 	char format[8];
209 
210 	sprintf(format, "%%.%ds\n", field->size);
211 	printf(PRINT_FIELD_SEGMENT, field->name);
212 	printf(format, field->buf);
213 }
214 
215 /**
216  * eeprom_field_update_ascii() - Update field with new data in ASCII form
217  * @field:	an initialized field
218  * @value:	the new string data
219  *
220  * Returns 0 on success, -1 of failure (new string too long).
221  */
222 int eeprom_field_update_ascii(struct eeprom_field *field, char *value)
223 {
224 	if (strlen(value) >= field->size) {
225 		printf("%s: new data too long\n", field->name);
226 		return -1;
227 	}
228 
229 	strncpy((char *)field->buf, value, field->size - 1);
230 	field->buf[field->size - 1] = '\0';
231 
232 	return 0;
233 }
234 
235 /**
236  * eeprom_field_print_reserved() - print the "Reserved fields" field
237  *
238  * Print a notice that the following field_size bytes are reserved.
239  *
240  * Sample output:
241  *      Reserved fields              (64 bytes)
242  *
243  * @field:	an initialized field to print
244  */
245 void eeprom_field_print_reserved(const struct eeprom_field *field)
246 {
247 	printf(PRINT_FIELD_SEGMENT, "Reserved fields\t");
248 	printf("(%d bytes)\n", field->size);
249 }
250