1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
|
/* SPDX-License-Identifier: GPL-2.0+ */
/*
* Common environment functions
*
* (C) Copyright 2000-2009
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
*/
#ifndef __ENV_H
#define __ENV_H
#include <stdbool.h>
#include <linux/types.h>
struct environment_s;
/**
* env_get_id() - Gets a sequence number for the environment
*
* This value increments every time the environment changes, so can be used an
* an indication of this
*
* @return environment ID
*/
int env_get_id(void);
/**
* env_init() - Set up the pre-relocation environment
*
* This locates the environment or uses the default if nothing is available.
* This must be called before env_get() will work.
*
* @return 0 if OK, -ENODEV if no environment drivers are enabled
*/
int env_init(void);
/**
* env_relocate() - Set up the post-relocation environment
*
* This loads the environment into RAM so that it can be modified. This is
* called after relocation, before the environment is used
*/
void env_relocate(void);
/**
* env_match() - Match a name / name=value pair
*
* This is used prior to relocation for finding envrionment variables
*
* @name: A simple 'name', or a 'name=value' pair.
* @index: The environment index for a 'name2=value2' pair.
* @return index for the value if the names match, else -1.
*/
int env_match(unsigned char *name, int index);
/**
* env_get() - Look up the value of an environment variable
*
* In U-Boot proper this can be called before relocation (which is when the
* environment is loaded from storage, i.e. GD_FLG_ENV_READY is 0). In that
* case this function calls env_get_f().
*
* @varname: Variable to look up
* @return value of variable, or NULL if not found
*/
char *env_get(const char *varname);
/**
* env_get_f() - Look up the value of an environment variable (early)
*
* This function is called from env_get() if the environment has not been
* loaded yet (GD_FLG_ENV_READY flag is 0). Some environment locations will
* support reading the value (slowly) and some will not.
*
* @varname: Variable to look up
* @return value of variable, or NULL if not found
*/
int env_get_f(const char *name, char *buf, unsigned int len);
/**
* env_get_yesno() - Read an environment variable as a boolean
*
* @return 1 if yes/true (Y/y/T/t), -1 if variable does not exist (i.e. default
* to true), 0 if otherwise
*/
int env_get_yesno(const char *var);
/**
* env_set() - set an environment variable
*
* This sets or deletes the value of an environment variable. For setting the
* value the variable is created if it does not already exist.
*
* @varname: Variable to adjust
* @value: Value to set for the variable, or NULL or "" to delete the variable
* @return 0 if OK, 1 on error
*/
int env_set(const char *varname, const char *value);
/**
* env_get_ulong() - Return an environment variable as an integer value
*
* Most U-Boot environment variables store hex values. For those which store
* (e.g.) base-10 integers, this function can be used to read the value.
*
* @name: Variable to look up
* @base: Base to use (e.g. 10 for base 10, 2 for binary)
* @default_val: Default value to return if no value is found
* @return the value found, or @default_val if none
*/
ulong env_get_ulong(const char *name, int base, ulong default_val);
/**
* env_set_ulong() - set an environment variable to an integer
*
* @varname: Variable to adjust
* @value: Value to set for the variable (will be converted to a string)
* @return 0 if OK, 1 on error
*/
int env_set_ulong(const char *varname, ulong value);
/**
* env_get_hex() - Return an environment variable as a hex value
*
* Decode an environment as a hex number (it may or may not have a 0x
* prefix). If the environment variable cannot be found, or does not start
* with hex digits, the default value is returned.
*
* @varname: Variable to decode
* @default_val: Value to return on error
*/
ulong env_get_hex(const char *varname, ulong default_val);
/**
* env_set_hex() - set an environment variable to a hex value
*
* @varname: Variable to adjust
* @value: Value to set for the variable (will be converted to a hex string)
* @return 0 if OK, 1 on error
*/
int env_set_hex(const char *varname, ulong value);
/**
* env_set_addr - Set an environment variable to an address in hex
*
* @varname: Environment variable to set
* @addr: Value to set it to
* @return 0 if ok, 1 on error
*/
static inline int env_set_addr(const char *varname, const void *addr)
{
return env_set_hex(varname, (ulong)addr);
}
/**
* env_complete() - return an auto-complete for environment variables
*
* @var: partial name to auto-complete
* @maxv: Maximum number of matches to return
* @cmdv: Returns a list of possible matches
* @maxsz: Size of buffer to use for matches
* @buf: Buffer to use for matches
* @dollar_comp: non-zero to wrap each match in ${...}
* @return number of matches found (in @cmdv)
*/
int env_complete(char *var, int maxv, char *cmdv[], int maxsz, char *buf,
bool dollar_comp);
/**
* eth_env_get_enetaddr() - Get an ethernet address from the environmnet
*
* @name: Environment variable to get (e.g. "ethaddr")
* @enetaddr: Place to put MAC address (6 bytes)
* @return 0 if OK, 1 on error
*/
int eth_env_get_enetaddr(const char *name, uint8_t *enetaddr);
/**
* eth_env_set_enetaddr() - Set an ethernet address in the environmnet
*
* @name: Environment variable to set (e.g. "ethaddr")
* @enetaddr: Pointer to MAC address to put into the variable (6 bytes)
* @return 0 if OK, 1 on error
*/
int eth_env_set_enetaddr(const char *name, const uint8_t *enetaddr);
/**
* env_fix_drivers() - Updates envdriver as per relocation
*/
void env_fix_drivers(void);
/**
* env_set_default_vars() - reset variables to their default value
*
* This resets individual variables to their value in the default environment
*
* @nvars: Number of variables to set/reset
* @vars: List of variables to set/reset
* @flags: Flags controlling matching (H_... - see search.h)
*/
int env_set_default_vars(int nvars, char *const vars[], int flags);
/**
* env_load() - Load the environment from storage
*
* @return 0 if OK, -ve on error
*/
int env_load(void);
/**
* env_save() - Save the environment to storage
*
* @return 0 if OK, -ve on error
*/
int env_save(void);
/**
* env_erase() - Erase the environment on storage
*
* @return 0 if OK, -ve on error
*/
int env_erase(void);
/**
* env_import() - Import from a binary representation into hash table
*
* This imports the environment from a buffer. The format for each variable is
* var=value\0 with a double \0 at the end of the buffer.
*
* @buf: Buffer containing the environment (struct environemnt_s *)
* @check: non-zero to check the CRC at the start of the environment, 0 to
* ignore it
* @return 0 if imported successfully, -ENOMSG if the CRC was bad, -EIO if
* something else went wrong
*/
int env_import(const char *buf, int check);
/**
* env_export() - Export the environment to a buffer
*
* Export from hash table into binary representation
*
* @env_out: Buffer to contain the environment (must be large enough!)
* @return 0 if OK, 1 on error
*/
int env_export(struct environment_s *env_out);
/**
* env_import_redund() - Select and import one of two redundant environments
*
* @buf1: First environment (struct environemnt_s *)
* @buf1_read_fail: 0 if buf1 is valid, non-zero if invalid
* @buf2: Second environment (struct environemnt_s *)
* @buf2_read_fail: 0 if buf2 is valid, non-zero if invalid
* @return 0 if OK, -EIO if no environment is valid, -ENOMSG if the CRC was bad
*/
int env_import_redund(const char *buf1, int buf1_read_fail,
const char *buf2, int buf2_read_fail);
/**
* env_get_default() - Look up a variable from the default environment
*
* @name: Variable to look up
* @return value if found, NULL if not found in default environment
*/
char *env_get_default(const char *name);
/* [re]set to the default environment */
void env_set_default(const char *s, int flags);
#endif
|