]>
Commit | Line | Data |
---|---|---|
c2485364 HS |
1 | /* |
2 | * (C) Copyright 2008 | |
3 | * Heiko Schocher, DENX Software Engineering, hs@denx.de. | |
4 | * | |
4f745bf4 HB |
5 | * (C) Copyright 2011 |
6 | * Holger Brunck, Keymile GmbH Hannover, holger.brunck@keymile.com | |
7 | * | |
1a459660 | 8 | * SPDX-License-Identifier: GPL-2.0+ |
c2485364 HS |
9 | */ |
10 | ||
11 | #include <common.h> | |
c2485364 | 12 | #include <ioports.h> |
a9417ce7 | 13 | #include <command.h> |
c2485364 | 14 | #include <malloc.h> |
eca86fad | 15 | #include <cli_hush.h> |
210c8c00 | 16 | #include <net.h> |
62ddcf05 | 17 | #include <netdev.h> |
210c8c00 | 18 | #include <asm/io.h> |
92c91080 | 19 | #include <linux/ctype.h> |
c2485364 | 20 | |
c1b3d841 TH |
21 | #if defined(CONFIG_POST) |
22 | #include "post.h" | |
23 | #endif | |
4f745bf4 | 24 | #include "common.h" |
c2485364 | 25 | #include <i2c.h> |
c2485364 | 26 | |
f1fef1d8 | 27 | DECLARE_GLOBAL_DATA_PTR; |
6c11aeaf | 28 | |
f1fef1d8 HS |
29 | /* |
30 | * Set Keymile specific environment variables | |
31 | * Currently only some memory layout variables are calculated here | |
32 | * ... ------------------------------------------------ | |
33 | * ... |@rootfsaddr |@pnvramaddr |@varaddr |@reserved |@END_OF_RAM | |
34 | * ... |<------------------- pram ------------------->| | |
35 | * ... ------------------------------------------------ | |
36 | * @END_OF_RAM: denotes the RAM size | |
37 | * @pnvramaddr: Startadress of pseudo non volatile RAM in hex | |
38 | * @pram : preserved ram size in k | |
39 | * @varaddr : startadress for /var mounted into RAM | |
40 | */ | |
41 | int set_km_env(void) | |
42 | { | |
43 | uchar buf[32]; | |
44 | unsigned int pnvramaddr; | |
45 | unsigned int pram; | |
46 | unsigned int varaddr; | |
2a7714ce AH |
47 | unsigned int kernelmem; |
48 | char *p; | |
49 | unsigned long rootfssize = 0; | |
f1fef1d8 HS |
50 | |
51 | pnvramaddr = gd->ram_size - CONFIG_KM_RESERVED_PRAM - CONFIG_KM_PHRAM | |
52 | - CONFIG_KM_PNVRAM; | |
53 | sprintf((char *)buf, "0x%x", pnvramaddr); | |
382bee57 | 54 | env_set("pnvramaddr", (char *)buf); |
f1fef1d8 | 55 | |
62a3b7dd | 56 | /* try to read rootfssize (ram image) from environment */ |
2a7714ce AH |
57 | p = getenv("rootfssize"); |
58 | if (p != NULL) | |
59 | strict_strtoul(p, 16, &rootfssize); | |
60 | pram = (rootfssize + CONFIG_KM_RESERVED_PRAM + CONFIG_KM_PHRAM + | |
61 | CONFIG_KM_PNVRAM) / 0x400; | |
f1fef1d8 | 62 | sprintf((char *)buf, "0x%x", pram); |
382bee57 | 63 | env_set("pram", (char *)buf); |
f1fef1d8 HS |
64 | |
65 | varaddr = gd->ram_size - CONFIG_KM_RESERVED_PRAM - CONFIG_KM_PHRAM; | |
66 | sprintf((char *)buf, "0x%x", varaddr); | |
382bee57 | 67 | env_set("varaddr", (char *)buf); |
2a7714ce AH |
68 | |
69 | kernelmem = gd->ram_size - 0x400 * pram; | |
70 | sprintf((char *)buf, "0x%x", kernelmem); | |
382bee57 | 71 | env_set("kernelmem", (char *)buf); |
2a7714ce | 72 | |
f1fef1d8 HS |
73 | return 0; |
74 | } | |
75 | ||
e792affe | 76 | #if defined(CONFIG_SYS_I2C_INIT_BOARD) |
6c11aeaf | 77 | static void i2c_write_start_seq(void) |
c2485364 | 78 | { |
b11f53f3 HS |
79 | set_sda(1); |
80 | udelay(DELAY_HALF_PERIOD); | |
81 | set_scl(1); | |
82 | udelay(DELAY_HALF_PERIOD); | |
83 | set_sda(0); | |
84 | udelay(DELAY_HALF_PERIOD); | |
85 | set_scl(0); | |
86 | udelay(DELAY_HALF_PERIOD); | |
c2485364 HS |
87 | } |
88 | ||
b11f53f3 HS |
89 | /* |
90 | * I2C is a synchronous protocol and resets of the processor in the middle | |
91 | * of an access can block the I2C Bus until a powerdown of the full unit is | |
92 | * done. This function toggles the SCL until the SCL and SCA line are | |
93 | * released, but max. 16 times, after this a I2C start-sequence is sent. | |
94 | * This I2C Deblocking mechanism was developed by Keymile in association | |
95 | * with Anatech and Atmel in 1998. | |
c2485364 | 96 | */ |
4f745bf4 | 97 | int i2c_make_abort(void) |
c2485364 HS |
98 | { |
99 | int scl_state = 0; | |
100 | int sda_state = 0; | |
101 | int i = 0; | |
102 | int ret = 0; | |
103 | ||
b11f53f3 | 104 | if (!get_sda()) { |
c2485364 HS |
105 | ret = -1; |
106 | while (i < 16) { | |
107 | i++; | |
b11f53f3 HS |
108 | set_scl(0); |
109 | udelay(DELAY_ABORT_SEQ); | |
110 | set_scl(1); | |
111 | udelay(DELAY_ABORT_SEQ); | |
112 | scl_state = get_scl(); | |
113 | sda_state = get_sda(); | |
c2485364 HS |
114 | if (scl_state && sda_state) { |
115 | ret = 0; | |
116 | break; | |
117 | } | |
118 | } | |
119 | } | |
b11f53f3 HS |
120 | if (ret == 0) |
121 | for (i = 0; i < 5; i++) | |
6c11aeaf | 122 | i2c_write_start_seq(); |
b11f53f3 | 123 | |
6c11aeaf HS |
124 | /* respect stop setup time */ |
125 | udelay(DELAY_ABORT_SEQ); | |
126 | set_scl(1); | |
127 | udelay(DELAY_ABORT_SEQ); | |
128 | set_sda(1); | |
b11f53f3 | 129 | get_sda(); |
6c11aeaf | 130 | |
c2485364 HS |
131 | return ret; |
132 | } | |
c2485364 | 133 | |
6c11aeaf HS |
134 | /** |
135 | * i2c_init_board - reset i2c bus. When the board is powercycled during a | |
136 | * bus transfer it might hang; for details see doc/I2C_Edge_Conditions. | |
137 | */ | |
138 | void i2c_init_board(void) | |
139 | { | |
c2485364 | 140 | /* Now run the AbortSequence() */ |
b11f53f3 | 141 | i2c_make_abort(); |
c2485364 | 142 | } |
e792affe HB |
143 | #endif |
144 | ||
99f6249a | 145 | #if defined(CONFIG_KM_COMMON_ETH_INIT) |
b11f53f3 | 146 | int board_eth_init(bd_t *bis) |
210c8c00 | 147 | { |
b11f53f3 | 148 | if (ethernet_present()) |
62ddcf05 HS |
149 | return cpu_eth_init(bis); |
150 | ||
151 | return -1; | |
210c8c00 | 152 | } |
99f6249a | 153 | #endif |
a9417ce7 HB |
154 | |
155 | /* | |
156 | * do_setboardid command | |
157 | * read out the board id and the hw key from the intventory EEPROM and set | |
158 | * this values as environment variables. | |
159 | */ | |
160 | static int do_setboardid(cmd_tbl_t *cmdtp, int flag, int argc, | |
161 | char *const argv[]) | |
162 | { | |
163 | unsigned char buf[32]; | |
164 | char *p; | |
165 | ||
166 | p = get_local_var("IVM_BoardId"); | |
167 | if (p == NULL) { | |
168 | printf("can't get the IVM_Boardid\n"); | |
169 | return 1; | |
170 | } | |
192bc694 | 171 | strcpy((char *)buf, p); |
382bee57 | 172 | env_set("boardid", (char *)buf); |
9485e779 | 173 | printf("set boardid=%s\n", buf); |
a9417ce7 HB |
174 | |
175 | p = get_local_var("IVM_HWKey"); | |
176 | if (p == NULL) { | |
177 | printf("can't get the IVM_HWKey\n"); | |
178 | return 1; | |
179 | } | |
192bc694 | 180 | strcpy((char *)buf, p); |
382bee57 | 181 | env_set("hwkey", (char *)buf); |
9485e779 HB |
182 | printf("set hwkey=%s\n", buf); |
183 | printf("Execute manually saveenv for persistent storage.\n"); | |
a9417ce7 HB |
184 | |
185 | return 0; | |
186 | } | |
187 | ||
188 | U_BOOT_CMD(km_setboardid, 1, 0, do_setboardid, "setboardid", "read out bid and " | |
189 | "hwkey from IVM and set in environment"); | |
92c91080 TH |
190 | |
191 | /* | |
192 | * command km_checkbidhwk | |
193 | * if "boardid" and "hwkey" are not already set in the environment, do: | |
194 | * if a "boardIdListHex" exists in the environment: | |
195 | * - read ivm data for boardid and hwkey | |
196 | * - compare each entry of the boardIdListHex with the | |
197 | * IVM data: | |
198 | * if match: | |
199 | * set environment variables boardid, boardId, | |
200 | * hwkey, hwKey to the found values | |
201 | * both (boardid and boardId) are set because | |
202 | * they might be used differently in the | |
203 | * application and in the init scripts (?) | |
204 | * return 0 in case of match, 1 if not match or error | |
205 | */ | |
283857da | 206 | static int do_checkboardidhwk(cmd_tbl_t *cmdtp, int flag, int argc, |
92c91080 TH |
207 | char *const argv[]) |
208 | { | |
209 | unsigned long ivmbid = 0, ivmhwkey = 0; | |
210 | unsigned long envbid = 0, envhwkey = 0; | |
211 | char *p; | |
212 | int verbose = argc > 1 && *argv[1] == 'v'; | |
213 | int rc = 0; | |
214 | ||
215 | /* | |
216 | * first read out the real inventory values, these values are | |
217 | * already stored in the local hush variables | |
218 | */ | |
219 | p = get_local_var("IVM_BoardId"); | |
220 | if (p == NULL) { | |
221 | printf("can't get the IVM_Boardid\n"); | |
222 | return 1; | |
223 | } | |
224 | rc = strict_strtoul(p, 16, &ivmbid); | |
225 | ||
226 | p = get_local_var("IVM_HWKey"); | |
227 | if (p == NULL) { | |
228 | printf("can't get the IVM_HWKey\n"); | |
229 | return 1; | |
230 | } | |
231 | rc = strict_strtoul(p, 16, &ivmhwkey); | |
232 | ||
233 | if (!ivmbid || !ivmhwkey) { | |
234 | printf("Error: IVM_BoardId and/or IVM_HWKey not set!\n"); | |
235 | return rc; | |
236 | } | |
237 | ||
238 | /* now try to read values from environment if available */ | |
239 | p = getenv("boardid"); | |
240 | if (p != NULL) | |
241 | rc = strict_strtoul(p, 16, &envbid); | |
242 | p = getenv("hwkey"); | |
243 | if (p != NULL) | |
244 | rc = strict_strtoul(p, 16, &envhwkey); | |
245 | ||
246 | if (rc != 0) { | |
247 | printf("strict_strtoul returns error: %d", rc); | |
248 | return rc; | |
249 | } | |
250 | ||
251 | if (!envbid || !envhwkey) { | |
252 | /* | |
253 | * BoardId/HWkey not available in the environment, so try the | |
254 | * environment variable for BoardId/HWkey list | |
255 | */ | |
256 | char *bidhwklist = getenv("boardIdListHex"); | |
257 | ||
258 | if (bidhwklist) { | |
259 | int found = 0; | |
260 | char *rest = bidhwklist; | |
261 | char *endp; | |
262 | ||
263 | if (verbose) { | |
264 | printf("IVM_BoardId: %ld, IVM_HWKey=%ld\n", | |
265 | ivmbid, ivmhwkey); | |
266 | printf("boardIdHwKeyList: %s\n", | |
267 | bidhwklist); | |
268 | } | |
269 | while (!found) { | |
270 | /* loop over each bid/hwkey pair in the list */ | |
271 | unsigned long bid = 0; | |
272 | unsigned long hwkey = 0; | |
273 | ||
274 | while (*rest && !isxdigit(*rest)) | |
275 | rest++; | |
276 | /* | |
277 | * use simple_strtoul because we need &end and | |
278 | * we know we got non numeric char at the end | |
279 | */ | |
280 | bid = simple_strtoul(rest, &endp, 16); | |
281 | /* BoardId and HWkey are separated with a "_" */ | |
282 | if (*endp == '_') { | |
283 | rest = endp + 1; | |
284 | /* | |
285 | * use simple_strtoul because we need | |
286 | * &end | |
287 | */ | |
288 | hwkey = simple_strtoul(rest, &endp, 16); | |
289 | rest = endp; | |
290 | while (*rest && !isxdigit(*rest)) | |
291 | rest++; | |
292 | } | |
293 | if ((!bid) || (!hwkey)) { | |
294 | /* end of list */ | |
295 | break; | |
296 | } | |
297 | if (verbose) { | |
298 | printf("trying bid=0x%lX, hwkey=%ld\n", | |
299 | bid, hwkey); | |
300 | } | |
301 | /* | |
302 | * Compare the values of the found entry in the | |
303 | * list with the valid values which are stored | |
304 | * in the inventory eeprom. If they are equal | |
ba8be32a | 305 | * set the values in environment variables. |
92c91080 TH |
306 | */ |
307 | if ((bid == ivmbid) && (hwkey == ivmhwkey)) { | |
308 | char buf[10]; | |
309 | ||
310 | found = 1; | |
311 | envbid = bid; | |
312 | envhwkey = hwkey; | |
313 | sprintf(buf, "%lx", bid); | |
382bee57 | 314 | env_set("boardid", buf); |
92c91080 | 315 | sprintf(buf, "%lx", hwkey); |
382bee57 | 316 | env_set("hwkey", buf); |
92c91080 TH |
317 | } |
318 | } /* end while( ! found ) */ | |
319 | } | |
320 | } | |
321 | ||
322 | /* compare now the values */ | |
323 | if ((ivmbid == envbid) && (ivmhwkey == envhwkey)) { | |
324 | printf("boardid=0x%3lX, hwkey=%ld\n", envbid, envhwkey); | |
325 | rc = 0; /* match */ | |
326 | } else { | |
9485e779 HB |
327 | printf("Error: env boardid=0x%3lX, hwkey=%ld\n", envbid, |
328 | envhwkey); | |
92c91080 TH |
329 | printf(" IVM bId=0x%3lX, hwKey=%ld\n", ivmbid, ivmhwkey); |
330 | rc = 1; /* don't match */ | |
331 | } | |
332 | return rc; | |
333 | } | |
334 | ||
335 | U_BOOT_CMD(km_checkbidhwk, 2, 0, do_checkboardidhwk, | |
336 | "check boardid and hwkey", | |
337 | "[v]\n - check environment parameter "\ | |
338 | "\"boardIdListHex\" against stored boardid and hwkey "\ | |
339 | "from the IVM\n v: verbose output" | |
340 | ); | |
c1b3d841 TH |
341 | |
342 | /* | |
343 | * command km_checktestboot | |
344 | * if the testpin of the board is asserted, return 1 | |
345 | * * else return 0 | |
346 | */ | |
283857da | 347 | static int do_checktestboot(cmd_tbl_t *cmdtp, int flag, int argc, |
c1b3d841 TH |
348 | char *const argv[]) |
349 | { | |
350 | int testpin = 0; | |
351 | char *s = NULL; | |
352 | int testboot = 0; | |
353 | int verbose = argc > 1 && *argv[1] == 'v'; | |
354 | ||
355 | #if defined(CONFIG_POST) | |
356 | testpin = post_hotkeys_pressed(); | |
d3f1d6f4 HB |
357 | #endif |
358 | s = getenv("test_bank"); | |
c1b3d841 TH |
359 | /* when test_bank is not set, act as if testpin is not asserted */ |
360 | testboot = (testpin != 0) && (s); | |
361 | if (verbose) { | |
362 | printf("testpin = %d\n", testpin); | |
0060517a | 363 | /* cppcheck-suppress nullPointer */ |
c1b3d841 TH |
364 | printf("test_bank = %s\n", s ? s : "not set"); |
365 | printf("boot test app : %s\n", (testboot) ? "yes" : "no"); | |
366 | } | |
367 | /* return 0 means: testboot, therefore we need the inversion */ | |
368 | return !testboot; | |
369 | } | |
370 | ||
371 | U_BOOT_CMD(km_checktestboot, 2, 0, do_checktestboot, | |
372 | "check if testpin is asserted", | |
373 | "[v]\n v - verbose output" | |
374 | ); |