common/hwconfig.c

   1 /*
   2  * An inteface for configuring a hardware via u-boot environment.
   3  *
   4  * Copyright (c) 2009  MontaVista Software, Inc.
   5  *
   6  * Author: Anton Vorontsov <avorontsov@ru.mvista.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of
  11  * the License, or (at your option) any later version.
  12  */
  13
  14 #ifndef HWCONFIG_TEST
  15 #include <config.h>
  16 #include <common.h>
  17 #include <exports.h>
  18 #include <hwconfig.h>
  19 #include <linux/types.h>
  20 #include <linux/string.h>
  21 #else
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <assert.h>
  26 #define min(a, b) (((a) < (b)) ? (a) : (b))
  27 #endif /* HWCONFIG_TEST */
  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 {
  74         const char *env_hwconfig = getenv("hwconfig");
  75
  76         if (env_hwconfig)
  77                 return hwconfig_parse(env_hwconfig, strlen(env_hwconfig),
  78                                       opt, ";", ':', arglen);
  79
  80         if (board_hwconfig)
  81                 return hwconfig_parse(board_hwconfig, strlen(board_hwconfig),
  82                                       opt, ";", ':', arglen);
  83
  84         if (cpu_hwconfig)
  85                 return hwconfig_parse(cpu_hwconfig, strlen(cpu_hwconfig),
  86                                       opt, ";", ':', arglen);
  87
  88         return NULL;
  89 }
  90
  91 /*
  92  * hwconfig - query if a particular hwconfig option is specified
  93  * @opt:        a string representing an option
  94  *
  95  * This call can be used to find out whether U-Boot should configure
  96  * a particular hardware option.
  97  *
  98  * Returns non-zero value if the hardware option can be used and thus
  99  * should be configured, 0 otherwise.
 100  *
 101  * This function also returns non-zero value if CONFIG_HWCONFIG is
 102  * undefined.
 103  *
 104  * Returning non-zero value without CONFIG_HWCONFIG has its crucial
 105  * purpose: the hwconfig() call should be a "transparent" interface,
 106  * e.g. if a board doesn't need hwconfig facility, then we assume
 107  * that the board file only calls things that are actually used, so
 108  * hwconfig() will always return true result.
 109  */
 110 int hwconfig(const char *opt)
 111 {
 112         return !!__hwconfig(opt, NULL);
 113 }
 114
 115 /*
 116  * hwconfig_arg - get hwconfig option's argument
 117  * @opt:        a string representing an option
 118  * @arglen:     a pointer to an allocated size_t variable
 119  *
 120  * Unlike hwconfig() function, this function returns a pointer to the
 121  * start of the hwconfig arguments, if option is not found or it has
 122  * no specified arguments, the function returns NULL pointer.
 123  *
 124  * If CONFIG_HWCONFIG is undefined, the function returns "", and
 125  * arglen is set to 0.
 126  */
 127 const char *hwconfig_arg(const char *opt, size_t *arglen)
 128 {
 129         return __hwconfig(opt, arglen);
 130 }
 131
 132 /*
 133  * hwconfig_arg_cmp - compare hwconfig option's argument
 134  * @opt:        a string representing an option
 135  * @arg:        a string for comparing an option's argument
 136  *
 137  * This call is similar to hwconfig_arg, but instead of returning
 138  * hwconfig argument and its length, it is comparing it to @arg.
 139  *
 140  * Returns non-zero value if @arg matches, 0 otherwise.
 141  *
 142  * If CONFIG_HWCONFIG is undefined, the function returns a non-zero
 143  * value, i.e. the argument matches.
 144  */
 145 int hwconfig_arg_cmp(const char *opt, const char *arg)
 146 {
 147         const char *argstr;
 148         size_t arglen;
 149
 150         argstr = hwconfig_arg(opt, &arglen);
 151         if (!argstr || arglen != strlen(arg))
 152                 return 0;
 153
 154         return !strncmp(argstr, arg, arglen);
 155 }
 156
 157 /*
 158  * hwconfig_sub - query if a particular hwconfig sub-option is specified
 159  * @opt:        a string representing an option
 160  * @subopt:     a string representing a sub-option
 161  *
 162  * This call is similar to hwconfig(), except that it takes additional
 163  * argument @subopt. In this example:
 164  *      "dr_usb:mode=peripheral"
 165  * "dr_usb" is an option, "mode" is a sub-option, and "peripheral" is its
 166  * argument.
 167  */
 168 int hwconfig_sub(const char *opt, const char *subopt)
 169 {
 170         size_t arglen;
 171         const char *arg;
 172
 173         arg = __hwconfig(opt, &arglen);
 174         if (!arg)
 175                 return 0;
 176         return !!hwconfig_parse(arg, arglen, subopt, ",;", '=', NULL);
 177 }
 178
 179 /*
 180  * hwconfig_subarg - get hwconfig sub-option's argument
 181  * @opt:        a string representing an option
 182  * @subopt:     a string representing a sub-option
 183  * @subarglen:  a pointer to an allocated size_t variable
 184  *
 185  * This call is similar to hwconfig_arg(), except that it takes an additional
 186  * argument @subopt, and so works with sub-options.
 187  */
 188 const char *hwconfig_subarg(const char *opt, const char *subopt,
 189                             size_t *subarglen)
 190 {
 191         size_t arglen;
 192         const char *arg;
 193
 194         arg = __hwconfig(opt, &arglen);
 195         if (!arg)
 196                 return NULL;
 197         return hwconfig_parse(arg, arglen, subopt, ",;", '=', subarglen);
 198 }
 199
 200 /*
 201  * hwconfig_arg_cmp - compare hwconfig sub-option's argument
 202  * @opt:        a string representing an option
 203  * @subopt:     a string representing a sub-option
 204  * @subarg:     a string for comparing an sub-option's argument
 205  *
 206  * This call is similar to hwconfig_arg_cmp, except that it takes an additional
 207  * argument @subopt, and so works with sub-options.
 208  */
 209 int hwconfig_subarg_cmp(const char *opt, const char *subopt, const char *subarg)
 210 {
 211         const char *argstr;
 212         size_t arglen;
 213
 214         argstr = hwconfig_subarg(opt, subopt, &arglen);
 215         if (!argstr || arglen != strlen(subarg))
 216                 return 0;
 217
 218         return !strncmp(argstr, subarg, arglen);
 219 }
 220
 221 #ifdef HWCONFIG_TEST
 222 int main()
 223 {
 224         const char *ret;
 225         size_t len;
 226
 227         setenv("hwconfig", "key1:subkey1=value1,subkey2=value2;key2:value3;;;;"
 228                            "key3;:,:=;key4", 1);
 229
 230         ret = hwconfig_arg("key1", &len);
 231         printf("%zd %.*s\n", len, (int)len, ret);
 232         assert(len == 29);
 233         assert(hwconfig_arg_cmp("key1", "subkey1=value1,subkey2=value2"));
 234         assert(!strncmp(ret, "subkey1=value1,subkey2=value2", len));
 235
 236         ret = hwconfig_subarg("key1", "subkey1", &len);
 237         printf("%zd %.*s\n", len, (int)len, ret);
 238         assert(len == 6);
 239         assert(hwconfig_subarg_cmp("key1", "subkey1", "value1"));
 240         assert(!strncmp(ret, "value1", len));
 241
 242         ret = hwconfig_subarg("key1", "subkey2", &len);
 243         printf("%zd %.*s\n", len, (int)len, ret);
 244         assert(len == 6);
 245         assert(hwconfig_subarg_cmp("key1", "subkey2", "value2"));
 246         assert(!strncmp(ret, "value2", len));
 247
 248         ret = hwconfig_arg("key2", &len);
 249         printf("%zd %.*s\n", len, (int)len, ret);
 250         assert(len == 6);
 251         assert(hwconfig_arg_cmp("key2", "value3"));
 252         assert(!strncmp(ret, "value3", len));
 253
 254         assert(hwconfig("key3"));
 255         assert(hwconfig_arg("key4", &len) == NULL);
 256         assert(hwconfig_arg("bogus", &len) == NULL);
 257
 258         unsetenv("hwconfig");
 259
 260         assert(hwconfig(NULL) == 0);
 261         assert(hwconfig("") == 0);
 262         assert(hwconfig("key3") == 0);
 263
 264         return 0;
 265 }
 266 #endif /* HWCONFIG_TEST */