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 #include <config.h>
  15 #include <common.h>
  16 #include <exports.h>
  17 #include <hwconfig.h>
  18 #include <linux/types.h>
  19 #include <linux/string.h>
  20
  21 static const char *hwconfig_parse(const char *opts, size_t maxlen,
  22                                   const char *opt, char stopch, char eqch,
  23                                   size_t *arglen)
  24 {
  25         size_t optlen = strlen(opt);
  26         char *str;
  27         const char *start = opts;
  28         const char *end;
  29
  30 next:
  31         str = strstr(opts, opt);
  32         end = str + optlen;
  33         if (end - start > maxlen)
  34                 return NULL;
  35
  36         if (str && (str == opts || str[-1] == stopch) &&
  37                         (*end == stopch || *end == eqch || *end == '\0')) {
  38                 const char *arg_end;
  39
  40                 if (!arglen)
  41                         return str;
  42
  43                 if (*end != eqch)
  44                         return NULL;
  45
  46                 arg_end = strchr(str, stopch);
  47                 if (!arg_end)
  48                         *arglen = min(maxlen, strlen(str)) - optlen - 1;
  49                 else
  50                         *arglen = arg_end - end - 1;
  51
  52                 return end + 1;
  53         } else if (str) {
  54                 opts = end;
  55                 goto next;
  56         }
  57         return NULL;
  58 }
  59
  60 const char *cpu_hwconfig __attribute__((weak));
  61 const char *board_hwconfig __attribute__((weak));
  62
  63 static const char *__hwconfig(const char *opt, size_t *arglen)
  64 {
  65         const char *env_hwconfig = getenv("hwconfig");
  66
  67         if (env_hwconfig)
  68                 return hwconfig_parse(env_hwconfig, strlen(env_hwconfig),
  69                                       opt, ';', ':', arglen);
  70
  71         if (board_hwconfig)
  72                 return hwconfig_parse(board_hwconfig, strlen(board_hwconfig),
  73                                       opt, ';', ':', arglen);
  74
  75         if (cpu_hwconfig)
  76                 return hwconfig_parse(cpu_hwconfig, strlen(cpu_hwconfig),
  77                                       opt, ';', ':', arglen);
  78
  79         return NULL;
  80 }
  81
  82 /*
  83  * hwconfig - query if a particular hwconfig option is specified
  84  * @opt:        a string representing an option
  85  *
  86  * This call can be used to find out whether U-Boot should configure
  87  * a particular hardware option.
  88  *
  89  * Returns non-zero value if the hardware option can be used and thus
  90  * should be configured, 0 otherwise.
  91  *
  92  * This function also returns non-zero value if CONFIG_HWCONFIG is
  93  * undefined.
  94  *
  95  * Returning non-zero value without CONFIG_HWCONFIG has its crucial
  96  * purpose: the hwconfig() call should be a "transparent" interface,
  97  * e.g. if a board doesn't need hwconfig facility, then we assume
  98  * that the board file only calls things that are actually used, so
  99  * hwconfig() will always return true result.
 100  */
 101 int hwconfig(const char *opt)
 102 {
 103         return !!__hwconfig(opt, NULL);
 104 }
 105
 106 /*
 107  * hwconfig_arg - get hwconfig option's argument
 108  * @opt:        a string representing an option
 109  * @arglen:     a pointer to an allocated size_t variable
 110  *
 111  * Unlike hwconfig() function, this function returns a pointer to the
 112  * start of the hwconfig arguments, if option is not found or it has
 113  * no specified arguments, the function returns NULL pointer.
 114  *
 115  * If CONFIG_HWCONFIG is undefined, the function returns "", and
 116  * arglen is set to 0.
 117  */
 118 const char *hwconfig_arg(const char *opt, size_t *arglen)
 119 {
 120         return __hwconfig(opt, arglen);
 121 }
 122
 123 /*
 124  * hwconfig_arg_cmp - compare hwconfig option's argument
 125  * @opt:        a string representing an option
 126  * @arg:        a string for comparing an option's argument
 127  *
 128  * This call is similar to hwconfig_arg, but instead of returning
 129  * hwconfig argument and its length, it is comparing it to @arg.
 130  *
 131  * Returns non-zero value if @arg matches, 0 otherwise.
 132  *
 133  * If CONFIG_HWCONFIG is undefined, the function returns a non-zero
 134  * value, i.e. the argument matches.
 135  */
 136 int hwconfig_arg_cmp(const char *opt, const char *arg)
 137 {
 138         const char *argstr;
 139         size_t arglen;
 140
 141         argstr = hwconfig_arg(opt, &arglen);
 142         if (!argstr || arglen != strlen(arg))
 143                 return 0;
 144
 145         return !strncmp(argstr, arg, arglen);
 146 }
 147
 148 /*
 149  * hwconfig_sub - query if a particular hwconfig sub-option is specified
 150  * @opt:        a string representing an option
 151  * @subopt:     a string representing a sub-option
 152  *
 153  * This call is similar to hwconfig(), except that it takes additional
 154  * argument @subopt. In this example:
 155  *      "dr_usb:mode=peripheral"
 156  * "dr_usb" is an option, "mode" is a sub-option, and "peripheral" is its
 157  * argument.
 158  */
 159 int hwconfig_sub(const char *opt, const char *subopt)
 160 {
 161         size_t arglen;
 162         const char *arg;
 163
 164         arg = __hwconfig(opt, &arglen);
 165         if (!arg)
 166                 return 0;
 167         return !!hwconfig_parse(arg, arglen, subopt, ',', '=', NULL);
 168 }
 169
 170 /*
 171  * hwconfig_subarg - get hwconfig sub-option's argument
 172  * @opt:        a string representing an option
 173  * @subopt:     a string representing a sub-option
 174  * @subarglen:  a pointer to an allocated size_t variable
 175  *
 176  * This call is similar to hwconfig_arg(), except that it takes an additional
 177  * argument @subopt, and so works with sub-options.
 178  */
 179 const char *hwconfig_subarg(const char *opt, const char *subopt,
 180                             size_t *subarglen)
 181 {
 182         size_t arglen;
 183         const char *arg;
 184
 185         arg = __hwconfig(opt, &arglen);
 186         if (!arg)
 187                 return NULL;
 188         return hwconfig_parse(arg, arglen, subopt, ',', '=', subarglen);
 189 }
 190
 191 /*
 192  * hwconfig_arg_cmp - compare hwconfig sub-option's argument
 193  * @opt:        a string representing an option
 194  * @subopt:     a string representing a sub-option
 195  * @subarg:     a string for comparing an sub-option's argument
 196  *
 197  * This call is similar to hwconfig_arg_cmp, except that it takes an additional
 198  * argument @subopt, and so works with sub-options.
 199  */
 200 int hwconfig_subarg_cmp(const char *opt, const char *subopt, const char *subarg)
 201 {
 202         const char *argstr;
 203         size_t arglen;
 204
 205         argstr = hwconfig_subarg(opt, subopt, &arglen);
 206         if (!argstr || arglen != strlen(subarg))
 207                 return 0;
 208
 209         return !strncmp(argstr, subarg, arglen);
 210 }