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); }