int last_stage_init(void)
{
#if defined(CONFIG_KMCOGE4)
/* on KMCOGE4, the BFTIC4 is on the LBAPP2 */
struct bfticu_iomap *bftic4 =
(struct bfticu_iomap *)CONFIG_SYS_LBAPP2_BASE;
u8 dip_switch = in_8((u8 *)&(bftic4->mswitch)) & BFTICU_DIPSWITCH_MASK;
if (dip_switch != 0) {
/* start bootloader */
puts("DIP: Enabled\n");
env_set("actual_bank", "0");
}
#endif
set_km_env();
return 0;
}
/* Tries to use $APPDATA/Vifm as configuration directory. Returns non-zero on
* success, otherwise zero is returned. */
static int
try_appdata_for_conf(void)
{
LOG_FUNC_ENTER;
#ifndef _WIN32
return 0;
#else
char vifm[PATH_MAX];
const char *appdata = env_get("APPDATA");
if(appdata == NULL || !is_dir(appdata))
return 0;
snprintf(vifm, sizeof(vifm), "%s/Vifm", appdata);
to_forward_slash(vifm);
env_set(VIFM_EV, vifm);
return 1;
#endif
}
/* tries to use USERPROFILE environment variable to find home directory */
static int
try_userprofile_envvar_for_home(void)
{
LOG_FUNC_ENTER;
#ifndef _WIN32
return 0;
#else
char home[PATH_MAX];
const char *userprofile = env_get("USERPROFILE");
if(userprofile == NULL || !is_dir(userprofile))
return 0;
snprintf(home, sizeof(home), "%s", userprofile);
to_forward_slash(home);
env_set(HOME_EV, home);
return 1;
#endif
}
int main()
{
const char *ret;
size_t len;
env_set("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);
unenv_set("hwconfig");
assert(hwconfig(NULL) == 0);
assert(hwconfig("") == 0);
assert(hwconfig("key3") == 0);
return 0;
}
/* tries to use vifmrc in directory of executable file as configuration file */
static int
try_exe_directory_for_vifmrc(void)
{
LOG_FUNC_ENTER;
#ifndef _WIN32
return 0;
#else
char vifmrc[PATH_MAX];
GetModuleFileNameA(NULL, vifmrc, sizeof(vifmrc));
to_forward_slash(vifmrc);
*strrchr(vifmrc, '/') = '\0';
strcat(vifmrc, "/" VIFMRC);
if(!path_exists(vifmrc))
return 0;
env_set(MYVIFMRC_EV, vifmrc);
return 1;
#endif
}
int
strm_var_set(strm_state* state, strm_string* name, strm_value val)
{
strm_env *e;
if (!state) {
if (!globals) {
globals = kh_init(env);
}
e = globals;
}
else {
if (!state->env) {
state->env = kh_init(env);
}
e = state->env;
}
return env_set(e, name, val);
}
int board_late_init(void)
{
if (gpio_request(HOT_WATER_BUTTON, "hot-water-button") < 0) {
puts("Failed to get hot-water-button pin\n");
return -ENODEV;
}
gpio_direction_input(HOT_WATER_BUTTON);
/*
* if hot-water-button is pressed
* change bootcmd
*/
if (gpio_get_value(HOT_WATER_BUTTON))
return 0;
env_set("bootcmd", "run swupdate");
return 0;
}
/* Adds a path to PATH environment variable. */
static void
add_to_path(const char *path)
{
const char *old_path;
char *new_path;
old_path = env_get("PATH");
new_path = malloc(strlen(path) + 1 + strlen(old_path) + 1);
#ifndef _WIN32
sprintf(new_path, "%s:%s", path, old_path);
#else
sprintf(new_path, "%s;%s", path, old_path);
to_back_slash(new_path);
#endif
env_set("PATH", new_path);
free(new_path);
}
int board_late_init(void)
{
int ret;
char tmp[2 * MAX_STRING_LENGTH + 2];
omap_nand_switch_ecc(1, 8);
if (factory_dat.asn[0] != 0)
sprintf(tmp, "%s_%s", factory_dat.asn,
factory_dat.comp_version);
else
strcpy(tmp, "QMX7.E38_4.0");
ret = env_set("boardid", tmp);
if (ret)
printf("error setting board id\n");
return 0;
}
/**
* This test case is trying to test the following scenario:
* - All ethernet devices are not probed
* - "ethaddr" for all ethernet devices are not set
* - "ethact" is set to a valid ethernet device name
*
* With Sandbox default test configuration, all ethernet devices are
* probed after power-up, so we have to manually create such scenario:
* - Remove all ethernet devices
* - Remove all "ethaddr" environment variables
* - Set "ethact" to the first ethernet device
*
* Do a ping test to see if anything goes wrong.
*/
static int dm_test_eth_act(struct unit_test_state *uts)
{
struct udevice *dev[DM_TEST_ETH_NUM];
const char *ethname[DM_TEST_ETH_NUM] = {"eth@10002000", "eth@10003000",
"sbe5", "eth@10004000"};
const char *addrname[DM_TEST_ETH_NUM] = {"ethaddr", "eth5addr",
"eth3addr", "eth1addr"};
char ethaddr[DM_TEST_ETH_NUM][18];
int i;
memset(ethaddr, '\0', sizeof(ethaddr));
net_ping_ip = string_to_ip("1.1.2.2");
/* Prepare the test scenario */
for (i = 0; i < DM_TEST_ETH_NUM; i++) {
ut_assertok(uclass_find_device_by_name(UCLASS_ETH,
ethname[i], &dev[i]));
ut_assertok(device_remove(dev[i], DM_REMOVE_NORMAL));
/* Invalidate MAC address */
strncpy(ethaddr[i], env_get(addrname[i]), 17);
/* Must disable access protection for ethaddr before clearing */
env_set(".flags", addrname[i]);
env_set(addrname[i], NULL);
}
/* Set ethact to "eth@10002000" */
env_set("ethact", ethname[0]);
/* Segment fault might happen if something is wrong */
ut_asserteq(-ENODEV, net_loop(PING));
for (i = 0; i < DM_TEST_ETH_NUM; i++) {
/* Restore the env */
env_set(".flags", addrname[i]);
env_set(addrname[i], ethaddr[i]);
/* Probe the device again */
ut_assertok(device_probe(dev[i]));
}
env_set(".flags", NULL);
env_set("ethact", NULL);
return 0;
}
int board_late_init(void)
{
#if (defined(CONFIG_KM_COGE5UN) | defined(CONFIG_KM_MGCOGE3UN))
u8 dip_switch = kw_gpio_get_value(KM_FLASH_ERASE_ENABLE);
/* if pin 1 do full erase */
if (dip_switch != 0) {
/* start bootloader */
puts("DIP: Enabled\n");
env_set("actual_bank", "0");
}
#endif
#if defined(CONFIG_KM_FPGA_CONFIG)
wait_for_fpga_config();
fpga_reset();
toggle_eeprom_spi_bus();
#endif
return 0;
}
/* Tries to use directory of executable file as configuration directory.
* Returns non-zero on success, otherwise zero is returned. */
static int
try_exe_directory_for_conf(void)
{
LOG_FUNC_ENTER;
char exe_dir[PATH_MAX + 1];
if(get_exe_dir(exe_dir, sizeof(exe_dir)) != 0)
{
return 0;
}
if(!path_exists_at(exe_dir, VIFMRC, DEREF))
{
return 0;
}
env_set(VIFM_EV, exe_dir);
return 1;
}
int board_late_init(void)
{
setup_board_eeprom_env();
u8 val;
/*
* DEV_CTRL.DEV_ON = 1 please - else palmas switches off in 8 seconds
* This is the POWERHOLD-in-Low behavior.
*/
palmas_i2c_write_u8(TPS65903X_CHIP_P1, 0xA0, 0x1);
/*
* Default FIT boot on HS devices. Non FIT images are not allowed
* on HS devices.
*/
if (get_device_type() == HS_DEVICE)
env_set("boot_fit", "1");
/*
* Set the GPIO7 Pad to POWERHOLD. This has higher priority
* over DEV_CTRL.DEV_ON bit. This can be reset in case of
* PMIC Power off. So to be on the safer side set it back
* to POWERHOLD mode irrespective of the current state.
*/
palmas_i2c_read_u8(TPS65903X_CHIP_P1, TPS65903X_PRIMARY_SECONDARY_PAD2,
&val);
val = val | TPS65903X_PAD2_POWERHOLD_MASK;
palmas_i2c_write_u8(TPS65903X_CHIP_P1, TPS65903X_PRIMARY_SECONDARY_PAD2,
val);
omap_die_id_serial();
omap_set_fastboot_vars();
am57x_idk_lcd_detect();
#if !defined(CONFIG_SPL_BUILD)
board_ti_set_ethaddr(2);
#endif
return 0;
}
int board_late_init(void)
{
#ifdef CONFIG_ENV_VARS_UBOOT_RUNTIME_CONFIG
char *name = "unknown";
if (is_dra72x()) {
if (board_is_dra72x_revc_or_later())
name = "dra72x-revc";
else if (board_is_dra71x_evm())
name = "dra71x";
else
name = "dra72x";
} else if (is_dra76x_abz()) {
name = "dra76x_abz";
} else if (is_dra76x_acd()) {
name = "dra76x_acd";
} else {
name = "dra7xx";
}
set_board_info_env(name);
/*
* Default FIT boot on HS devices. Non FIT images are not allowed
* on HS devices.
*/
if (get_device_type() == HS_DEVICE)
env_set("boot_fit", "1");
omap_die_id_serial();
omap_set_fastboot_vars();
/*
* Hook the LDO1 regulator to EN pin. This applies only to LP8733
* Rest all regulators are hooked to EN Pin at reset.
*/
if (board_is_dra71x_evm())
palmas_i2c_write_u8(LP873X_I2C_SLAVE_ADDR, 0x9, 0x7);
#endif
return 0;
}
static int dm_test_eth_rotate(struct unit_test_state *uts)
{
char ethaddr[18];
int retval;
/* Set target IP to mock ping */
net_ping_ip = string_to_ip("1.1.2.2");
/* Invalidate eth1's MAC address */
memset(ethaddr, '\0', sizeof(ethaddr));
strncpy(ethaddr, env_get("eth1addr"), 17);
/* Must disable access protection for eth1addr before clearing */
env_set(".flags", "eth1addr");
env_set("eth1addr", NULL);
retval = _dm_test_eth_rotate1(uts);
/* Restore the env */
env_set("eth1addr", ethaddr);
env_set("ethrotate", NULL);
if (!retval) {
/* Invalidate eth0's MAC address */
strncpy(ethaddr, env_get("ethaddr"), 17);
/* Must disable access protection for ethaddr before clearing */
env_set(".flags", "ethaddr");
env_set("ethaddr", NULL);
retval = _dm_test_eth_rotate2(uts);
/* Restore the env */
env_set("ethaddr", ethaddr);
}
/* Restore the env */
env_set(".flags", NULL);
return retval;
}
/* ensures existence of configuration directory */
static void
create_config_dir(void)
{
LOG_FUNC_ENTER;
/* ensure existence of configuration directory */
if(!is_dir(cfg.config_dir))
{
#ifndef _WIN32
FILE *f;
char help_file[PATH_MAX];
char rc_file[PATH_MAX];
if(make_dir(cfg.config_dir, 0777) != 0)
return;
snprintf(help_file, sizeof(help_file), "%s/" VIFM_HELP, cfg.config_dir);
if((f = fopen(help_file, "r")) == NULL)
create_help_file();
else
fclose(f);
snprintf(rc_file, sizeof(rc_file), "%s/" VIFMRC, cfg.config_dir);
if((f = fopen(rc_file, "r")) == NULL)
create_rc_file();
else
fclose(f);
/* This should be first start of Vifm, ensure that newly created sample
* vifmrc file is used right away. */
env_set(MYVIFMRC_EV, rc_file);
#else
if(make_dir(cfg.config_dir, 0777) != 0)
return;
#endif
add_default_bookmarks();
}
}
int do_uuid(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
char uuid[UUID_STR_LEN + 1];
int str_format;
if (!strcmp(argv[0], "uuid"))
str_format = UUID_STR_FORMAT_STD;
else
str_format = UUID_STR_FORMAT_GUID;
if (argc > 2)
return CMD_RET_USAGE;
gen_rand_uuid_str(uuid, str_format);
if (argc == 1)
printf("%s\n", uuid);
else
env_set(argv[1], uuid);
return CMD_RET_SUCCESS;
}
int spl_dfu_cmd(int usbctrl, char *dfu_alt_info, char *interface, char *devstr)
{
char *str_env;
int ret;
/* set default environment */
set_default_env(0);
str_env = env_get(dfu_alt_info);
if (!str_env) {
error("\"dfu_alt_info\" env variable not defined!\n");
return -EINVAL;
}
ret = env_set("dfu_alt_info", str_env);
if (ret) {
error("unable to set env variable \"dfu_alt_info\"!\n");
return -EINVAL;
}
/* invoke dfu command */
return run_dfu(usbctrl, interface, devstr);
}
/* Tries to use vifmrc in directory of executable file as configuration file.
* Returns non-zero on success, otherwise zero is returned. */
static int
try_exe_directory_for_vifmrc(void)
{
LOG_FUNC_ENTER;
char exe_dir[PATH_MAX + 1];
char vifmrc[PATH_MAX + 1];
if(get_exe_dir(exe_dir, sizeof(exe_dir)) != 0)
{
return 0;
}
snprintf(vifmrc, sizeof(vifmrc), "%s/" VIFMRC, exe_dir);
if(!path_exists(vifmrc, DEREF))
{
return 0;
}
env_set(MYVIFMRC_EV, vifmrc);
return 1;
}
/* Tries to use $HOME/.vifm as configuration directory. Tries harder on force.
* Returns non-zero on success, otherwise zero is returned. */
static int
try_home_envvar_for_conf(int force)
{
LOG_FUNC_ENTER;
char vifm[PATH_MAX + 1];
const char *home = env_get(HOME_EV);
if(home == NULL || !is_dir(home))
{
return 0;
}
snprintf(vifm, sizeof(vifm), "%s/.vifm", home);
if(!force && !is_dir(vifm))
{
return 0;
}
env_set(VIFM_EV, vifm);
return 1;
}
/* Tries to use $HOMEDRIVE/$HOMEPATH as home directory. Returns non-zero on
* success, otherwise zero is returned. */
static int
try_homepath_envvar_for_home(void)
{
LOG_FUNC_ENTER;
#ifndef _WIN32
return 0;
#else
char home[PATH_MAX + 1];
const char *homedrive = env_get("HOMEDRIVE");
const char *homepath = env_get("HOMEPATH");
if(homedrive == NULL || !is_dir(homedrive))
return 0;
if(homepath == NULL || !is_dir(homepath))
return 0;
snprintf(home, sizeof(home), "%s%s", homedrive, homepath);
system_to_internal_slashes(home);
env_set(HOME_EV, home);
return 1;
#endif
}
static void
set_envvar(const char *name, const char *val)
{
envvar_t *record;
char *p;
record = get_record(name);
if(record == NULL)
{
text_buffer_add("Not enough memory");
return;
}
p = strdup(val);
if(p == NULL)
{
text_buffer_add("Not enough memory");
return;
}
free(record->val);
record->val = p;
env_set(name, val);
}
/// We separate this from path_create() for two reasons. First it's only caused if there is a
/// problem, and thus is not central to the behavior of that function. Second, we only want to issue
/// the message once. If the current shell starts a new fish shell (e.g., by running `fish -c` from
/// a function) we don't want that subshell to issue the same warnings.
static void maybe_issue_path_warning(const wcstring &which_dir, const wcstring &custom_error_msg,
bool using_xdg, const wcstring &xdg_var, const wcstring &path,
int saved_errno) {
wcstring warning_var_name = L"_FISH_WARNED_" + which_dir;
if (env_exist(warning_var_name.c_str(), ENV_GLOBAL | ENV_EXPORT)) {
return;
}
env_set(warning_var_name, L"1", ENV_GLOBAL | ENV_EXPORT);
debug(0, custom_error_msg.c_str());
if (path.empty()) {
debug(0, _(L"Unable to locate the %ls directory."), which_dir.c_str());
debug(0, _(L"Please set the %ls or HOME environment variable before starting fish."),
xdg_var.c_str());
} else {
const wchar_t *env_var = using_xdg ? xdg_var.c_str() : L"HOME";
debug(0, _(L"Unable to locate %ls directory derived from $%ls: '%ls'."), which_dir.c_str(),
env_var, path.c_str());
debug(0, _(L"The error was '%s'."), strerror(saved_errno));
debug(0, _(L"Please set $%ls to a directory where you have write access."), env_var);
}
write(STDERR_FILENO, "\n", 1);
}
static void
set_envvar(const char *name, const char *val)
{
var_t *record;
char *p;
record = get_record(name);
if(record == NULL)
{
print_msg(1, "", "Not enough memory");
return;
}
p = strdup(val);
if(p == NULL)
{
print_msg(1, "", "Not enough memory");
return;
}
free(record->val);
record->val = p;
env_set(name, val);
}
static int do_esbc_validate(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
char *hash_str = NULL;
uintptr_t haddr;
int ret;
uintptr_t img_addr = 0;
char buf[20];
if (argc < 2)
return cmd_usage(cmdtp);
else if (argc > 2)
/* Second arg - Optional - Hash Str*/
hash_str = argv[2];
/* First argument - header address -32/64bit */
haddr = (uintptr_t)simple_strtoul(argv[1], NULL, 16);
/* With esbc_validate command, Image address must be
* part of header. So, the function is called
* by passing this argument as 0.
*/
ret = fsl_secboot_validate(haddr, hash_str, &img_addr);
/* Need to set "img_addr" even if validation failure.
* Required when SB_EN in RCW set and non-fatal error
* to continue U-Boot
*/
sprintf(buf, "%lx", img_addr);
env_set("img_addr", buf);
if (ret)
return 1;
printf("esbc_validate command successful\n");
return 0;
}
void __maybe_unused set_board_info_env(char *name)
{
char *unknown = "unknown";
struct ti_common_eeprom *ep = TI_EEPROM_DATA;
if (name)
env_set("board_name", name);
else if (ep->name)
env_set("board_name", ep->name);
else
env_set("board_name", unknown);
if (ep->version)
env_set("board_rev", ep->version);
else
env_set("board_rev", unknown);
if (ep->serial)
env_set("board_serial", ep->serial);
else
env_set("board_serial", unknown);
}
static void
append_envvar(const char *name, const char *val)
{
envvar_t *record;
char *p;
record = find_record(name);
if(record == NULL)
{
set_envvar(name, val);
return;
}
p = realloc(record->val, strlen(record->val) + strlen(val) + 1);
if(p == NULL)
{
text_buffer_add("Not enough memory");
return;
}
record->val = p;
strcat(record->val, val);
env_set(name, record->val);
}
int misc_init_r(void)
{
u8 mac_addr[EFUSE_MAC_SIZE];
char serial[EFUSE_SN_SIZE];
ssize_t len;
meson_eth_init(PHY_INTERFACE_MODE_RMII, 0);
if (!eth_env_get_enetaddr("ethaddr", mac_addr)) {
len = meson_sm_read_efuse(EFUSE_MAC_OFFSET,
mac_addr, EFUSE_MAC_SIZE);
if (len == EFUSE_MAC_SIZE && is_valid_ethaddr(mac_addr))
eth_env_set_enetaddr("ethaddr", mac_addr);
}
if (!env_get("serial#")) {
len = meson_sm_read_efuse(EFUSE_SN_OFFSET, serial,
EFUSE_SN_SIZE);
if (len == EFUSE_SN_SIZE)
env_set("serial#", serial);
}
return 0;
}
void
env_build(struct page *p, struct lacy_env *env)
{
env->p_stack->size++;
if (NULL == p || NULL == p->inherits
|| MAX_INHERIT <= env->p_stack->size) {
env->p_stack->stack =
calloc(env->p_stack->size, sizeof (struct page *));
}
else if (NULL != p->inherits) {
env_build(p->inherits, env);
}
else {
return;
}
env->p_stack->stack[env->p_stack->pos] = p;
env->p_stack->pos++;
struct page_attr *t = p->attr_top;
while (t != NULL) {
env_set(env, t->name.s, t->value.s);
t = t->next;
}
}
static void rk3288_detect_reset_reason(void)
{
struct rk3288_cru *cru = rockchip_get_cru();
const char *reason;
if (IS_ERR(cru))
return;
switch (cru->cru_glb_rst_st) {
case GLB_POR_RST:
reason = "POR";
break;
case FST_GLB_RST_ST:
case SND_GLB_RST_ST:
reason = "RST";
break;
case FST_GLB_TSADC_RST_ST:
case SND_GLB_TSADC_RST_ST:
reason = "THERMAL";
break;
case FST_GLB_WDT_RST_ST:
case SND_GLB_WDT_RST_ST:
reason = "WDOG";
break;
default:
reason = "unknown reset";
}
env_set("reset_reason", reason);
/*
* Clear cru_glb_rst_st, so we can determine the last reset cause
* for following resets.
*/
rk_clrreg(&cru->cru_glb_rst_st, GLB_RST_ST_MASK);
}
