initial commit
[freebsd-arm:freebsd-arm.git] / boot / arm / at91 / bootiic / env_vars.c
1 /******************************************************************************
2  *
3  * Filename: env_vars.c
4  *
5  * Instantiation of environment variables, structures, and other globals.
6  *
7  * Revision information:
8  *
9  * 20AUG2004    kb_admin        initial creation
10  *
11  * BEGIN_KBDD_BLOCK
12  * No warranty, expressed or implied, is included with this software.  It is
13  * provided "AS IS" and no warranty of any kind including statutory or aspects
14  * relating to merchantability or fitness for any purpose is provided.  All
15  * intellectual property rights of others is maintained with the respective
16  * owners.  This software is not copyrighted and is intended for reference
17  * only.
18  * END_BLOCK
19  *
20  * $FreeBSD$
21  *****************************************************************************/
22
23 #include "env_vars.h"
24 #include "loader_prompt.h"
25 #include "lib.h"
26
27 /******************************* GLOBALS *************************************/
28 char    boot_commands[MAX_BOOT_COMMANDS][MAX_INPUT_SIZE];
29
30 char    env_table[MAX_ENV_SIZE_BYTES];
31
32 extern char     BootCommandSection;
33
34 /************************** PRIVATE FUNCTIONS ********************************/
35
36
37 static int      currentIndex;
38 static int      currentOffset;
39
40
41 /*
42  * .KB_C_FN_DEFINITION_START
43  * int ReadCharFromEnvironment(char *)
44  *  This private function reads characters from the enviroment variables
45  * to service the command prompt during auto-boot or just to setup the
46  * default environment.  Returns positive value if valid character was
47  * set in the pointer.  Returns negative value to signal input stream
48  * terminated.  Returns 0 to indicate _wait_ condition.
49  * .KB_C_FN_DEFINITION_END
50  */
51 static int
52 ReadCharFromEnvironment(int timeout)
53 {
54         int ch;
55
56         if (currentIndex < MAX_BOOT_COMMANDS) {
57                 ch = boot_commands[currentIndex][currentOffset++];
58                 if (ch == '\0' || (currentOffset >= MAX_INPUT_SIZE)) {
59                         currentOffset = 0;
60                         ++currentIndex;
61                         ch = '\r';
62                 }
63                 return (ch);
64         }
65
66         return (-1);
67 }
68
69
70 /*************************** GLOBAL FUNCTIONS ********************************/
71
72
73 /*
74  * .KB_C_FN_DEFINITION_START
75  * void WriteCommandTable(void)
76  *  This global function write the current command table to the non-volatile
77  * memory.
78  * .KB_C_FN_DEFINITION_END
79  */
80 void
81 WriteCommandTable(void)
82 {
83         int     i, size = MAX_ENV_SIZE_BYTES, copySize;
84         char    *cPtr = env_table;
85
86         p_memset(env_table, 0, sizeof(env_table));
87
88         for (i = 0; i < MAX_BOOT_COMMANDS; ++i) {
89
90                 copySize = p_strlen(boot_commands[i]);
91                 size -= copySize + 1;
92
93                 if (size < 0) {
94                         continue;
95                 }
96                 memcpy(cPtr, boot_commands[i], copySize);
97                 cPtr += copySize;
98                 *cPtr++ = 0;
99         }
100
101         /* We're executing in low RAM so addr in ram == offset in eeprom */
102         WriteEEPROM((unsigned)&BootCommandSection, env_table,
103             sizeof(env_table));
104 }
105
106
107 /*
108  * .KB_C_FN_DEFINITION_START
109  * void SetBootCommand(int index, char *command)
110  *  This global function replaces the specified index with the string residing
111  * at command.  Execute this function with a NULL string to clear the
112  * associated command index.
113  * .KB_C_FN_DEFINITION_END
114  */
115 void
116 SetBootCommand(int index, char *command)
117 {
118         int     i;
119
120         if ((unsigned)index < MAX_BOOT_COMMANDS) {
121
122                 p_memset(boot_commands[index], 0, MAX_INPUT_SIZE);
123
124                 if (!command)
125                         return ;
126
127                 for (i = 0; i < MAX_INPUT_SIZE; ++i) {
128                         boot_commands[index][i] = command[i];
129                         if (!(boot_commands[index][i]))
130                                 return;
131                 }
132         }
133 }
134
135
136 /*
137  * .KB_C_FN_DEFINITION_START
138  * void DumpBootCommands(void)
139  *  This global function displays the current boot commands.
140  * .KB_C_FN_DEFINITION_END
141  */
142 void
143 DumpBootCommands(void)
144 {
145         int     i, j;
146
147         for (i = 0; i < MAX_BOOT_COMMANDS; ++i) {
148                 printf("0x%x : ", i);
149                 for (j = 0; j < MAX_INPUT_SIZE; ++j) {
150                         putchar(boot_commands[i][j]);
151                         if (!(boot_commands[i][j]))
152                                 break;
153                 }
154                 printf("[E]\n\r");
155         }
156 }
157
158
159 /*
160  * .KB_C_FN_DEFINITION_START
161  * void LoadBootCommands(void)
162  *  This global function loads the existing boot commands from raw format and
163  * coverts it to the standard, command-index format.  Notice, the processed
164  * boot command table has much more space allocated than the actual table
165  * stored in non-volatile memory.  This is because the processed table
166  * exists in RAM which is larger than the non-volatile space.
167  * .KB_C_FN_DEFINITION_END
168  */
169 void
170 LoadBootCommands(void)
171 {
172         int     index, j, size;
173         char    *cPtr;
174
175         p_memset((char*)boot_commands, 0, sizeof(boot_commands));
176
177         cPtr = &BootCommandSection;
178
179         size = MAX_ENV_SIZE_BYTES;
180
181         for (index = 0; (index < MAX_BOOT_COMMANDS) && size; ++index) {
182                 for (j = 0; (j < MAX_INPUT_SIZE) && size; ++j) {
183                         size--;
184                         boot_commands[index][j] = *cPtr++;
185                         if (!(boot_commands[index][j])) {
186                                 break;
187                         }
188                 }
189         }
190 }
191
192
193 /*
194  * .KB_C_FN_DEFINITION_START
195  * void ExecuteEnvironmentFunctions(void)
196  *  This global function executes applicable entries in the environment.
197  * .KB_C_FN_DEFINITION_END
198  */
199 void
200 ExecuteEnvironmentFunctions(void)
201 {
202         currentIndex = 0;
203         currentOffset = 0;
204
205         DumpBootCommands();
206         Bootloader(ReadCharFromEnvironment);
207 }