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