mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-29 05:18:51 +09:00
![Kumar Gala](/assets/img/avatar_default.png)
There are several users of the hwconfig APIs (8xxx DDR) before we have the environment properly setup. This causes issues because of the numerous ways the environment might be accessed because of the non-volatile memory it might be stored in. Additionally the access might be so early that memory isn't even properly setup for us. Towards resolving these issues we provide versions of all the hwconfig APIs that can be passed in a buffer to parse and leave it to the caller to determine how to allocate and populate the buffer. We use the _f naming convention for these new APIs even though they are perfectly useable after relocation and the environment being ready. We also now warn if the non-f APIs are called before the environment is ready to allow users to address the issues. Finally, we convert the 8xxx DDR code to utilize the new APIs to hopefully address the issue once and for all. We have the 8xxx DDR code create a buffer on the stack and populate it via getenv_f(). Signed-off-by: Kumar Gala <galak@kernel.crashing.org> Acked-by: Wolfgang Denk <wd@denx.de>
289 lines
8.0 KiB
C
289 lines
8.0 KiB
C
/*
|
|
* An inteface for configuring a hardware via u-boot environment.
|
|
*
|
|
* Copyright (c) 2009 MontaVista Software, Inc.
|
|
* Copyright 2011 Freescale Semiconductor, Inc.
|
|
*
|
|
* Author: Anton Vorontsov <avorontsov@ru.mvista.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of
|
|
* the License, or (at your option) any later version.
|
|
*/
|
|
|
|
#ifndef HWCONFIG_TEST
|
|
#include <config.h>
|
|
#include <common.h>
|
|
#include <exports.h>
|
|
#include <hwconfig.h>
|
|
#include <linux/types.h>
|
|
#include <linux/string.h>
|
|
#else
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#define min(a, b) (((a) < (b)) ? (a) : (b))
|
|
#endif /* HWCONFIG_TEST */
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
static const char *hwconfig_parse(const char *opts, size_t maxlen,
|
|
const char *opt, char *stopchs, char eqch,
|
|
size_t *arglen)
|
|
{
|
|
size_t optlen = strlen(opt);
|
|
char *str;
|
|
const char *start = opts;
|
|
const char *end;
|
|
|
|
next:
|
|
str = strstr(opts, opt);
|
|
end = str + optlen;
|
|
if (end - start > maxlen)
|
|
return NULL;
|
|
|
|
if (str && (str == opts || strpbrk(str - 1, stopchs) == str - 1) &&
|
|
(strpbrk(end, stopchs) == end || *end == eqch ||
|
|
*end == '\0')) {
|
|
const char *arg_end;
|
|
|
|
if (!arglen)
|
|
return str;
|
|
|
|
if (*end != eqch)
|
|
return NULL;
|
|
|
|
arg_end = strpbrk(str, stopchs);
|
|
if (!arg_end)
|
|
*arglen = min(maxlen, strlen(str)) - optlen - 1;
|
|
else
|
|
*arglen = arg_end - end - 1;
|
|
|
|
return end + 1;
|
|
} else if (str) {
|
|
opts = end;
|
|
goto next;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const char cpu_hwconfig[] __attribute__((weak)) = "";
|
|
const char board_hwconfig[] __attribute__((weak)) = "";
|
|
|
|
static const char *__hwconfig(const char *opt, size_t *arglen,
|
|
const char *env_hwconfig)
|
|
{
|
|
const char *ret;
|
|
|
|
/* if we are passed a buffer use it, otherwise try the environment */
|
|
if (!env_hwconfig) {
|
|
if (!(gd->flags & GD_FLG_ENV_READY)) {
|
|
printf("WARNING: Calling __hwconfig without a buffer "
|
|
"and before environment is ready\n");
|
|
return NULL;
|
|
}
|
|
env_hwconfig = getenv("hwconfig");
|
|
}
|
|
|
|
if (env_hwconfig) {
|
|
ret = hwconfig_parse(env_hwconfig, strlen(env_hwconfig),
|
|
opt, ";", ':', arglen);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
ret = hwconfig_parse(board_hwconfig, strlen(board_hwconfig),
|
|
opt, ";", ':', arglen);
|
|
if (ret)
|
|
return ret;
|
|
|
|
return hwconfig_parse(cpu_hwconfig, strlen(cpu_hwconfig),
|
|
opt, ";", ':', arglen);
|
|
}
|
|
|
|
/*
|
|
* hwconfig_f - query if a particular hwconfig option is specified
|
|
* @opt: a string representing an option
|
|
* @buf: if non-NULL use this buffer to parse, otherwise try env
|
|
*
|
|
* This call can be used to find out whether U-Boot should configure
|
|
* a particular hardware option.
|
|
*
|
|
* Returns non-zero value if the hardware option can be used and thus
|
|
* should be configured, 0 otherwise.
|
|
*
|
|
* This function also returns non-zero value if CONFIG_HWCONFIG is
|
|
* undefined.
|
|
*
|
|
* Returning non-zero value without CONFIG_HWCONFIG has its crucial
|
|
* purpose: the hwconfig() call should be a "transparent" interface,
|
|
* e.g. if a board doesn't need hwconfig facility, then we assume
|
|
* that the board file only calls things that are actually used, so
|
|
* hwconfig() will always return true result.
|
|
*/
|
|
int hwconfig_f(const char *opt, char *buf)
|
|
{
|
|
return !!__hwconfig(opt, NULL, buf);
|
|
}
|
|
|
|
/*
|
|
* hwconfig_arg_f - get hwconfig option's argument
|
|
* @opt: a string representing an option
|
|
* @arglen: a pointer to an allocated size_t variable
|
|
* @buf: if non-NULL use this buffer to parse, otherwise try env
|
|
*
|
|
* Unlike hwconfig_f() function, this function returns a pointer to the
|
|
* start of the hwconfig arguments, if option is not found or it has
|
|
* no specified arguments, the function returns NULL pointer.
|
|
*
|
|
* If CONFIG_HWCONFIG is undefined, the function returns "", and
|
|
* arglen is set to 0.
|
|
*/
|
|
const char *hwconfig_arg_f(const char *opt, size_t *arglen, char *buf)
|
|
{
|
|
return __hwconfig(opt, arglen, buf);
|
|
}
|
|
|
|
/*
|
|
* hwconfig_arg_cmp_f - compare hwconfig option's argument
|
|
* @opt: a string representing an option
|
|
* @arg: a string for comparing an option's argument
|
|
* @buf: if non-NULL use this buffer to parse, otherwise try env
|
|
*
|
|
* This call is similar to hwconfig_arg_f, but instead of returning
|
|
* hwconfig argument and its length, it is comparing it to @arg.
|
|
*
|
|
* Returns non-zero value if @arg matches, 0 otherwise.
|
|
*
|
|
* If CONFIG_HWCONFIG is undefined, the function returns a non-zero
|
|
* value, i.e. the argument matches.
|
|
*/
|
|
int hwconfig_arg_cmp_f(const char *opt, const char *arg, char *buf)
|
|
{
|
|
const char *argstr;
|
|
size_t arglen;
|
|
|
|
argstr = hwconfig_arg_f(opt, &arglen, buf);
|
|
if (!argstr || arglen != strlen(arg))
|
|
return 0;
|
|
|
|
return !strncmp(argstr, arg, arglen);
|
|
}
|
|
|
|
/*
|
|
* hwconfig_sub_f - query if a particular hwconfig sub-option is specified
|
|
* @opt: a string representing an option
|
|
* @subopt: a string representing a sub-option
|
|
* @buf: if non-NULL use this buffer to parse, otherwise try env
|
|
*
|
|
* This call is similar to hwconfig_f(), except that it takes additional
|
|
* argument @subopt. In this example:
|
|
* "dr_usb:mode=peripheral"
|
|
* "dr_usb" is an option, "mode" is a sub-option, and "peripheral" is its
|
|
* argument.
|
|
*/
|
|
int hwconfig_sub_f(const char *opt, const char *subopt, char *buf)
|
|
{
|
|
size_t arglen;
|
|
const char *arg;
|
|
|
|
arg = __hwconfig(opt, &arglen, buf);
|
|
if (!arg)
|
|
return 0;
|
|
return !!hwconfig_parse(arg, arglen, subopt, ",;", '=', NULL);
|
|
}
|
|
|
|
/*
|
|
* hwconfig_subarg_f - get hwconfig sub-option's argument
|
|
* @opt: a string representing an option
|
|
* @subopt: a string representing a sub-option
|
|
* @subarglen: a pointer to an allocated size_t variable
|
|
* @buf: if non-NULL use this buffer to parse, otherwise try env
|
|
*
|
|
* This call is similar to hwconfig_arg_f(), except that it takes an
|
|
* additional argument @subopt, and so works with sub-options.
|
|
*/
|
|
const char *hwconfig_subarg_f(const char *opt, const char *subopt,
|
|
size_t *subarglen, char *buf)
|
|
{
|
|
size_t arglen;
|
|
const char *arg;
|
|
|
|
arg = __hwconfig(opt, &arglen, buf);
|
|
if (!arg)
|
|
return NULL;
|
|
return hwconfig_parse(arg, arglen, subopt, ",;", '=', subarglen);
|
|
}
|
|
|
|
/*
|
|
* hwconfig_arg_cmp_f - compare hwconfig sub-option's argument
|
|
* @opt: a string representing an option
|
|
* @subopt: a string representing a sub-option
|
|
* @subarg: a string for comparing an sub-option's argument
|
|
* @buf: if non-NULL use this buffer to parse, otherwise try env
|
|
*
|
|
* This call is similar to hwconfig_arg_cmp_f, except that it takes an
|
|
* additional argument @subopt, and so works with sub-options.
|
|
*/
|
|
int hwconfig_subarg_cmp_f(const char *opt, const char *subopt,
|
|
const char *subarg, char *buf)
|
|
{
|
|
const char *argstr;
|
|
size_t arglen;
|
|
|
|
argstr = hwconfig_subarg_f(opt, subopt, &arglen, buf);
|
|
if (!argstr || arglen != strlen(subarg))
|
|
return 0;
|
|
|
|
return !strncmp(argstr, subarg, arglen);
|
|
}
|
|
|
|
#ifdef HWCONFIG_TEST
|
|
int main()
|
|
{
|
|
const char *ret;
|
|
size_t len;
|
|
|
|
setenv("hwconfig", "key1:subkey1=value1,subkey2=value2;key2:value3;;;;"
|
|
"key3;:,:=;key4", 1);
|
|
|
|
ret = hwconfig_arg("key1", &len);
|
|
printf("%zd %.*s\n", len, (int)len, ret);
|
|
assert(len == 29);
|
|
assert(hwconfig_arg_cmp("key1", "subkey1=value1,subkey2=value2"));
|
|
assert(!strncmp(ret, "subkey1=value1,subkey2=value2", len));
|
|
|
|
ret = hwconfig_subarg("key1", "subkey1", &len);
|
|
printf("%zd %.*s\n", len, (int)len, ret);
|
|
assert(len == 6);
|
|
assert(hwconfig_subarg_cmp("key1", "subkey1", "value1"));
|
|
assert(!strncmp(ret, "value1", len));
|
|
|
|
ret = hwconfig_subarg("key1", "subkey2", &len);
|
|
printf("%zd %.*s\n", len, (int)len, ret);
|
|
assert(len == 6);
|
|
assert(hwconfig_subarg_cmp("key1", "subkey2", "value2"));
|
|
assert(!strncmp(ret, "value2", len));
|
|
|
|
ret = hwconfig_arg("key2", &len);
|
|
printf("%zd %.*s\n", len, (int)len, ret);
|
|
assert(len == 6);
|
|
assert(hwconfig_arg_cmp("key2", "value3"));
|
|
assert(!strncmp(ret, "value3", len));
|
|
|
|
assert(hwconfig("key3"));
|
|
assert(hwconfig_arg("key4", &len) == NULL);
|
|
assert(hwconfig_arg("bogus", &len) == NULL);
|
|
|
|
unsetenv("hwconfig");
|
|
|
|
assert(hwconfig(NULL) == 0);
|
|
assert(hwconfig("") == 0);
|
|
assert(hwconfig("key3") == 0);
|
|
|
|
return 0;
|
|
}
|
|
#endif /* HWCONFIG_TEST */
|