]> git.sur5r.net Git - u-boot/blob - common/hwconfig.c
gpio: zynq: Remove non driver model code
[u-boot] / common / hwconfig.c
1 /*
2  * An inteface for configuring a hardware via u-boot environment.
3  *
4  * Copyright (c) 2009  MontaVista Software, Inc.
5  * Copyright 2011 Freescale Semiconductor, Inc.
6  *
7  * Author: Anton Vorontsov <avorontsov@ru.mvista.com>
8  *
9  * SPDX-License-Identifier:     GPL-2.0+
10  */
11
12 #ifndef HWCONFIG_TEST
13 #include <config.h>
14 #include <common.h>
15 #include <exports.h>
16 #include <hwconfig.h>
17 #include <linux/types.h>
18 #include <linux/string.h>
19 #else
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <assert.h>
24 #define min(a, b) (((a) < (b)) ? (a) : (b))
25 #endif /* HWCONFIG_TEST */
26
27 DECLARE_GLOBAL_DATA_PTR;
28
29 static const char *hwconfig_parse(const char *opts, size_t maxlen,
30                                   const char *opt, char *stopchs, char eqch,
31                                   size_t *arglen)
32 {
33         size_t optlen = strlen(opt);
34         char *str;
35         const char *start = opts;
36         const char *end;
37
38 next:
39         str = strstr(opts, opt);
40         end = str + optlen;
41         if (end - start > maxlen)
42                 return NULL;
43
44         if (str && (str == opts || strpbrk(str - 1, stopchs) == str - 1) &&
45                         (strpbrk(end, stopchs) == end || *end == eqch ||
46                          *end == '\0')) {
47                 const char *arg_end;
48
49                 if (!arglen)
50                         return str;
51
52                 if (*end != eqch)
53                         return NULL;
54
55                 arg_end = strpbrk(str, stopchs);
56                 if (!arg_end)
57                         *arglen = min(maxlen, strlen(str)) - optlen - 1;
58                 else
59                         *arglen = arg_end - end - 1;
60
61                 return end + 1;
62         } else if (str) {
63                 opts = end;
64                 goto next;
65         }
66         return NULL;
67 }
68
69 const char cpu_hwconfig[] __attribute__((weak)) = "";
70 const char board_hwconfig[] __attribute__((weak)) = "";
71
72 static const char *__hwconfig(const char *opt, size_t *arglen,
73                               const char *env_hwconfig)
74 {
75         const char *ret;
76
77         /* if we are passed a buffer use it, otherwise try the environment */
78         if (!env_hwconfig) {
79                 if (!(gd->flags & GD_FLG_ENV_READY)) {
80                         printf("WARNING: Calling __hwconfig without a buffer "
81                                         "and before environment is ready\n");
82                         return NULL;
83                 }
84                 env_hwconfig = getenv("hwconfig");
85         }
86
87         if (env_hwconfig) {
88                 ret = hwconfig_parse(env_hwconfig, strlen(env_hwconfig),
89                                       opt, ";", ':', arglen);
90                 if (ret)
91                         return ret;
92         }
93
94         ret = hwconfig_parse(board_hwconfig, strlen(board_hwconfig),
95                         opt, ";", ':', arglen);
96         if (ret)
97                 return ret;
98
99         return hwconfig_parse(cpu_hwconfig, strlen(cpu_hwconfig),
100                         opt, ";", ':', arglen);
101 }
102
103 /*
104  * hwconfig_f - query if a particular hwconfig option is specified
105  * @opt:        a string representing an option
106  * @buf:        if non-NULL use this buffer to parse, otherwise try env
107  *
108  * This call can be used to find out whether U-Boot should configure
109  * a particular hardware option.
110  *
111  * Returns non-zero value if the hardware option can be used and thus
112  * should be configured, 0 otherwise.
113  *
114  * This function also returns non-zero value if CONFIG_HWCONFIG is
115  * undefined.
116  *
117  * Returning non-zero value without CONFIG_HWCONFIG has its crucial
118  * purpose: the hwconfig() call should be a "transparent" interface,
119  * e.g. if a board doesn't need hwconfig facility, then we assume
120  * that the board file only calls things that are actually used, so
121  * hwconfig() will always return true result.
122  */
123 int hwconfig_f(const char *opt, char *buf)
124 {
125         return !!__hwconfig(opt, NULL, buf);
126 }
127
128 /*
129  * hwconfig_arg_f - get hwconfig option's argument
130  * @opt:        a string representing an option
131  * @arglen:     a pointer to an allocated size_t variable
132  * @buf:        if non-NULL use this buffer to parse, otherwise try env
133  *
134  * Unlike hwconfig_f() function, this function returns a pointer to the
135  * start of the hwconfig arguments, if option is not found or it has
136  * no specified arguments, the function returns NULL pointer.
137  *
138  * If CONFIG_HWCONFIG is undefined, the function returns "", and
139  * arglen is set to 0.
140  */
141 const char *hwconfig_arg_f(const char *opt, size_t *arglen, char *buf)
142 {
143         return __hwconfig(opt, arglen, buf);
144 }
145
146 /*
147  * hwconfig_arg_cmp_f - compare hwconfig option's argument
148  * @opt:        a string representing an option
149  * @arg:        a string for comparing an option's argument
150  * @buf:        if non-NULL use this buffer to parse, otherwise try env
151  *
152  * This call is similar to hwconfig_arg_f, but instead of returning
153  * hwconfig argument and its length, it is comparing it to @arg.
154  *
155  * Returns non-zero value if @arg matches, 0 otherwise.
156  *
157  * If CONFIG_HWCONFIG is undefined, the function returns a non-zero
158  * value, i.e. the argument matches.
159  */
160 int hwconfig_arg_cmp_f(const char *opt, const char *arg, char *buf)
161 {
162         const char *argstr;
163         size_t arglen;
164
165         argstr = hwconfig_arg_f(opt, &arglen, buf);
166         if (!argstr || arglen != strlen(arg))
167                 return 0;
168
169         return !strncmp(argstr, arg, arglen);
170 }
171
172 /*
173  * hwconfig_sub_f - query if a particular hwconfig sub-option is specified
174  * @opt:        a string representing an option
175  * @subopt:     a string representing a sub-option
176  * @buf:        if non-NULL use this buffer to parse, otherwise try env
177  *
178  * This call is similar to hwconfig_f(), except that it takes additional
179  * argument @subopt. In this example:
180  *      "dr_usb:mode=peripheral"
181  * "dr_usb" is an option, "mode" is a sub-option, and "peripheral" is its
182  * argument.
183  */
184 int hwconfig_sub_f(const char *opt, const char *subopt, char *buf)
185 {
186         size_t arglen;
187         const char *arg;
188
189         arg = __hwconfig(opt, &arglen, buf);
190         if (!arg)
191                 return 0;
192         return !!hwconfig_parse(arg, arglen, subopt, ",;", '=', NULL);
193 }
194
195 /*
196  * hwconfig_subarg_f - get hwconfig sub-option's argument
197  * @opt:        a string representing an option
198  * @subopt:     a string representing a sub-option
199  * @subarglen:  a pointer to an allocated size_t variable
200  * @buf:        if non-NULL use this buffer to parse, otherwise try env
201  *
202  * This call is similar to hwconfig_arg_f(), except that it takes an
203  * additional argument @subopt, and so works with sub-options.
204  */
205 const char *hwconfig_subarg_f(const char *opt, const char *subopt,
206                               size_t *subarglen, char *buf)
207 {
208         size_t arglen;
209         const char *arg;
210
211         arg = __hwconfig(opt, &arglen, buf);
212         if (!arg)
213                 return NULL;
214         return hwconfig_parse(arg, arglen, subopt, ",;", '=', subarglen);
215 }
216
217 /*
218  * hwconfig_arg_cmp_f - compare hwconfig sub-option's argument
219  * @opt:        a string representing an option
220  * @subopt:     a string representing a sub-option
221  * @subarg:     a string for comparing an sub-option's argument
222  * @buf:        if non-NULL use this buffer to parse, otherwise try env
223  *
224  * This call is similar to hwconfig_arg_cmp_f, except that it takes an
225  * additional argument @subopt, and so works with sub-options.
226  */
227 int hwconfig_subarg_cmp_f(const char *opt, const char *subopt,
228                           const char *subarg, char *buf)
229 {
230         const char *argstr;
231         size_t arglen;
232
233         argstr = hwconfig_subarg_f(opt, subopt, &arglen, buf);
234         if (!argstr || arglen != strlen(subarg))
235                 return 0;
236
237         return !strncmp(argstr, subarg, arglen);
238 }
239
240 #ifdef HWCONFIG_TEST
241 int main()
242 {
243         const char *ret;
244         size_t len;
245
246         setenv("hwconfig", "key1:subkey1=value1,subkey2=value2;key2:value3;;;;"
247                            "key3;:,:=;key4", 1);
248
249         ret = hwconfig_arg("key1", &len);
250         printf("%zd %.*s\n", len, (int)len, ret);
251         assert(len == 29);
252         assert(hwconfig_arg_cmp("key1", "subkey1=value1,subkey2=value2"));
253         assert(!strncmp(ret, "subkey1=value1,subkey2=value2", len));
254
255         ret = hwconfig_subarg("key1", "subkey1", &len);
256         printf("%zd %.*s\n", len, (int)len, ret);
257         assert(len == 6);
258         assert(hwconfig_subarg_cmp("key1", "subkey1", "value1"));
259         assert(!strncmp(ret, "value1", len));
260
261         ret = hwconfig_subarg("key1", "subkey2", &len);
262         printf("%zd %.*s\n", len, (int)len, ret);
263         assert(len == 6);
264         assert(hwconfig_subarg_cmp("key1", "subkey2", "value2"));
265         assert(!strncmp(ret, "value2", len));
266
267         ret = hwconfig_arg("key2", &len);
268         printf("%zd %.*s\n", len, (int)len, ret);
269         assert(len == 6);
270         assert(hwconfig_arg_cmp("key2", "value3"));
271         assert(!strncmp(ret, "value3", len));
272
273         assert(hwconfig("key3"));
274         assert(hwconfig_arg("key4", &len) == NULL);
275         assert(hwconfig_arg("bogus", &len) == NULL);
276
277         unsetenv("hwconfig");
278
279         assert(hwconfig(NULL) == 0);
280         assert(hwconfig("") == 0);
281         assert(hwconfig("key3") == 0);
282
283         return 0;
284 }
285 #endif /* HWCONFIG_TEST */