]>
Commit | Line | Data |
---|---|---|
c609719b | 1 | /* |
aba4b69d | 2 | * (C) Copyright 2001-2010 |
c609719b WD |
3 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. |
4 | * | |
1a459660 | 5 | * SPDX-License-Identifier: GPL-2.0+ |
c609719b WD |
6 | */ |
7 | ||
8 | #include <common.h> | |
9 | #include <command.h> | |
10 | #include <net.h> | |
d9785c14 | 11 | #include <miiphy.h> |
5f184715 | 12 | #include <phy.h> |
75d9a45c | 13 | #include <asm/errno.h> |
c609719b | 14 | |
3f6e6993 MF |
15 | void eth_parse_enetaddr(const char *addr, uchar *enetaddr) |
16 | { | |
17 | char *end; | |
18 | int i; | |
19 | ||
20 | for (i = 0; i < 6; ++i) { | |
21 | enetaddr[i] = addr ? simple_strtoul(addr, &end, 16) : 0; | |
22 | if (addr) | |
23 | addr = (*end) ? end + 1 : end; | |
24 | } | |
25 | } | |
26 | ||
27 | int eth_getenv_enetaddr(char *name, uchar *enetaddr) | |
28 | { | |
29 | eth_parse_enetaddr(getenv(name), enetaddr); | |
30 | return is_valid_ether_addr(enetaddr); | |
31 | } | |
32 | ||
33 | int eth_setenv_enetaddr(char *name, const uchar *enetaddr) | |
34 | { | |
35 | char buf[20]; | |
36 | ||
37 | sprintf(buf, "%pM", enetaddr); | |
38 | ||
39 | return setenv(name, buf); | |
40 | } | |
86848a74 | 41 | |
7616e785 SG |
42 | int eth_getenv_enetaddr_by_index(const char *base_name, int index, |
43 | uchar *enetaddr) | |
86848a74 MF |
44 | { |
45 | char enetvar[32]; | |
7616e785 | 46 | sprintf(enetvar, index ? "%s%daddr" : "%saddr", base_name, index); |
86848a74 MF |
47 | return eth_getenv_enetaddr(enetvar, enetaddr); |
48 | } | |
3f6e6993 | 49 | |
154177e1 | 50 | static inline int eth_setenv_enetaddr_by_index(const char *base_name, int index, |
c88ef3c1 RH |
51 | uchar *enetaddr) |
52 | { | |
53 | char enetvar[32]; | |
54 | sprintf(enetvar, index ? "%s%daddr" : "%saddr", base_name, index); | |
55 | return eth_setenv_enetaddr(enetvar, enetaddr); | |
56 | } | |
57 | ||
84eb1fba JH |
58 | static void eth_env_init(void) |
59 | { | |
60 | const char *s; | |
61 | ||
62 | s = getenv("bootfile"); | |
63 | if (s != NULL) | |
64 | copy_filename(BootFile, s, sizeof(BootFile)); | |
65 | } | |
c88ef3c1 | 66 | |
ecee9324 BW |
67 | static int eth_mac_skip(int index) |
68 | { | |
69 | char enetvar[15]; | |
70 | char *skip_state; | |
71 | sprintf(enetvar, index ? "eth%dmacskip" : "ethmacskip", index); | |
72 | return ((skip_state = getenv(enetvar)) != NULL); | |
73 | } | |
74 | ||
84eb1fba JH |
75 | static void eth_current_changed(void); |
76 | ||
dd35479a BW |
77 | /* |
78 | * CPU and board-specific Ethernet initializations. Aliased function | |
79 | * signals caller to move on | |
80 | */ | |
81 | static int __def_eth_init(bd_t *bis) | |
82 | { | |
83 | return -1; | |
84 | } | |
f9a109b3 PT |
85 | int cpu_eth_init(bd_t *bis) __attribute__((weak, alias("__def_eth_init"))); |
86 | int board_eth_init(bd_t *bis) __attribute__((weak, alias("__def_eth_init"))); | |
dd35479a | 87 | |
f85b6071 | 88 | #ifdef CONFIG_API |
f85b6071 RJ |
89 | static struct { |
90 | uchar data[PKTSIZE]; | |
91 | int length; | |
92 | } eth_rcv_bufs[PKTBUFSRX]; | |
93 | ||
66c7385a | 94 | static unsigned int eth_rcv_current, eth_rcv_last; |
f85b6071 RJ |
95 | #endif |
96 | ||
f8be7d65 JH |
97 | static struct eth_device *eth_devices; |
98 | struct eth_device *eth_current; | |
c609719b | 99 | |
84eb1fba JH |
100 | static void eth_set_current_to_next(void) |
101 | { | |
102 | eth_current = eth_current->next; | |
103 | } | |
104 | ||
d7fb9bcf | 105 | struct eth_device *eth_get_dev_by_name(const char *devname) |
63ff004c MB |
106 | { |
107 | struct eth_device *dev, *target_dev; | |
108 | ||
7e7f903f HR |
109 | BUG_ON(devname == NULL); |
110 | ||
63ff004c MB |
111 | if (!eth_devices) |
112 | return NULL; | |
113 | ||
114 | dev = eth_devices; | |
115 | target_dev = NULL; | |
116 | do { | |
117 | if (strcmp(devname, dev->name) == 0) { | |
118 | target_dev = dev; | |
119 | break; | |
120 | } | |
121 | dev = dev->next; | |
122 | } while (dev != eth_devices); | |
123 | ||
124 | return target_dev; | |
125 | } | |
126 | ||
9e56986a AF |
127 | struct eth_device *eth_get_dev_by_index(int index) |
128 | { | |
129 | struct eth_device *dev, *target_dev; | |
9e56986a AF |
130 | |
131 | if (!eth_devices) | |
132 | return NULL; | |
133 | ||
134 | dev = eth_devices; | |
135 | target_dev = NULL; | |
136 | do { | |
fea7dcae | 137 | if (dev->index == index) { |
9e56986a AF |
138 | target_dev = dev; |
139 | break; | |
140 | } | |
141 | dev = dev->next; | |
9e56986a AF |
142 | } while (dev != eth_devices); |
143 | ||
144 | return target_dev; | |
145 | } | |
146 | ||
66c7385a | 147 | int eth_get_dev_index(void) |
c609719b | 148 | { |
66c7385a | 149 | if (!eth_current) |
fea7dcae | 150 | return -1; |
c609719b | 151 | |
fea7dcae | 152 | return eth_current->index; |
c609719b WD |
153 | } |
154 | ||
7616e785 SG |
155 | int eth_write_hwaddr(struct eth_device *dev, const char *base_name, |
156 | int eth_number) | |
157 | { | |
158 | unsigned char env_enetaddr[6]; | |
159 | int ret = 0; | |
160 | ||
69376644 | 161 | eth_getenv_enetaddr_by_index(base_name, eth_number, env_enetaddr); |
7616e785 | 162 | |
4c7c65af JH |
163 | if (!is_zero_ether_addr(env_enetaddr)) { |
164 | if (!is_zero_ether_addr(dev->enetaddr) && | |
165 | memcmp(dev->enetaddr, env_enetaddr, 6)) { | |
7616e785 SG |
166 | printf("\nWarning: %s MAC addresses don't match:\n", |
167 | dev->name); | |
168 | printf("Address in SROM is %pM\n", | |
169 | dev->enetaddr); | |
170 | printf("Address in environment is %pM\n", | |
171 | env_enetaddr); | |
172 | } | |
173 | ||
174 | memcpy(dev->enetaddr, env_enetaddr, 6); | |
c88ef3c1 RH |
175 | } else if (is_valid_ether_addr(dev->enetaddr)) { |
176 | eth_setenv_enetaddr_by_index(base_name, eth_number, | |
177 | dev->enetaddr); | |
178 | printf("\nWarning: %s using MAC address from net device\n", | |
179 | dev->name); | |
4c7c65af | 180 | } else if (is_zero_ether_addr(dev->enetaddr)) { |
75d9a45c PM |
181 | printf("\nError: %s address not set.\n", |
182 | dev->name); | |
183 | return -EINVAL; | |
7616e785 SG |
184 | } |
185 | ||
75d9a45c PM |
186 | if (dev->write_hwaddr && !eth_mac_skip(eth_number)) { |
187 | if (!is_valid_ether_addr(dev->enetaddr)) { | |
188 | printf("\nError: %s address %pM illegal value\n", | |
189 | dev->name, dev->enetaddr); | |
190 | return -EINVAL; | |
191 | } | |
460f949f | 192 | |
7616e785 | 193 | ret = dev->write_hwaddr(dev); |
75d9a45c PM |
194 | if (ret) |
195 | printf("\nWarning: %s failed to set MAC address\n", dev->name); | |
460f949f | 196 | } |
7616e785 SG |
197 | |
198 | return ret; | |
199 | } | |
200 | ||
89d48367 SG |
201 | int eth_register(struct eth_device *dev) |
202 | { | |
203 | struct eth_device *d; | |
66c7385a | 204 | static int index; |
58c583b6 | 205 | |
f6add132 | 206 | assert(strlen(dev->name) < sizeof(dev->name)); |
58c583b6 | 207 | |
89d48367 SG |
208 | if (!eth_devices) { |
209 | eth_current = eth_devices = dev; | |
210 | eth_current_changed(); | |
c609719b | 211 | } else { |
66c7385a | 212 | for (d = eth_devices; d->next != eth_devices; d = d->next) |
aba4b69d | 213 | ; |
c609719b WD |
214 | d->next = dev; |
215 | } | |
216 | ||
217 | dev->state = ETH_STATE_INIT; | |
218 | dev->next = eth_devices; | |
fea7dcae | 219 | dev->index = index++; |
c609719b WD |
220 | |
221 | return 0; | |
222 | } | |
223 | ||
e7e982d6 VP |
224 | int eth_unregister(struct eth_device *dev) |
225 | { | |
226 | struct eth_device *cur; | |
227 | ||
228 | /* No device */ | |
229 | if (!eth_devices) | |
05324a48 | 230 | return -ENODEV; |
e7e982d6 VP |
231 | |
232 | for (cur = eth_devices; cur->next != eth_devices && cur->next != dev; | |
233 | cur = cur->next) | |
234 | ; | |
235 | ||
236 | /* Device not found */ | |
237 | if (cur->next != dev) | |
05324a48 | 238 | return -ENODEV; |
e7e982d6 VP |
239 | |
240 | cur->next = dev->next; | |
241 | ||
242 | if (eth_devices == dev) | |
243 | eth_devices = dev->next == eth_devices ? NULL : dev->next; | |
244 | ||
245 | if (eth_current == dev) { | |
246 | eth_current = eth_devices; | |
247 | eth_current_changed(); | |
248 | } | |
249 | ||
250 | return 0; | |
251 | } | |
252 | ||
c609719b WD |
253 | int eth_initialize(bd_t *bis) |
254 | { | |
fea7dcae | 255 | int num_devices = 0; |
c609719b WD |
256 | eth_devices = NULL; |
257 | eth_current = NULL; | |
258 | ||
770605e4 | 259 | bootstage_mark(BOOTSTAGE_ID_NET_ETH_START); |
27ee59af | 260 | #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) || defined(CONFIG_PHYLIB) |
d9785c14 MB |
261 | miiphy_init(); |
262 | #endif | |
5f184715 AF |
263 | |
264 | #ifdef CONFIG_PHYLIB | |
265 | phy_init(); | |
266 | #endif | |
267 | ||
84eb1fba | 268 | eth_env_init(); |
de30122b | 269 | |
8ad25bf8 BW |
270 | /* |
271 | * If board-specific initialization exists, call it. | |
272 | * If not, call a CPU-specific one | |
273 | */ | |
274 | if (board_eth_init != __def_eth_init) { | |
275 | if (board_eth_init(bis) < 0) | |
276 | printf("Board Net Initialization Failed\n"); | |
277 | } else if (cpu_eth_init != __def_eth_init) { | |
278 | if (cpu_eth_init(bis) < 0) | |
279 | printf("CPU Net Initialization Failed\n"); | |
280 | } else | |
281 | printf("Net Initialization Skipped\n"); | |
d9785c14 | 282 | |
c609719b | 283 | if (!eth_devices) { |
66c7385a | 284 | puts("No ethernet found.\n"); |
770605e4 | 285 | bootstage_error(BOOTSTAGE_ID_NET_ETH_START); |
c609719b WD |
286 | } else { |
287 | struct eth_device *dev = eth_devices; | |
66c7385a | 288 | char *ethprime = getenv("ethprime"); |
c609719b | 289 | |
770605e4 | 290 | bootstage_mark(BOOTSTAGE_ID_NET_ETH_INIT); |
c609719b | 291 | do { |
fea7dcae | 292 | if (dev->index) |
66c7385a | 293 | puts(", "); |
c609719b WD |
294 | |
295 | printf("%s", dev->name); | |
296 | ||
66c7385a | 297 | if (ethprime && strcmp(dev->name, ethprime) == 0) { |
c609719b | 298 | eth_current = dev; |
66c7385a | 299 | puts(" [PRIME]"); |
c609719b WD |
300 | } |
301 | ||
1384f3bb | 302 | if (strchr(dev->name, ' ')) |
66c7385a JH |
303 | puts("\nWarning: eth device name has a space!" |
304 | "\n"); | |
1384f3bb | 305 | |
75d9a45c | 306 | eth_write_hwaddr(dev, "eth", dev->index); |
c609719b | 307 | |
c609719b | 308 | dev = dev->next; |
fea7dcae | 309 | num_devices++; |
66c7385a | 310 | } while (dev != eth_devices); |
c609719b | 311 | |
89d48367 | 312 | eth_current_changed(); |
66c7385a | 313 | putc('\n'); |
c609719b WD |
314 | } |
315 | ||
fea7dcae | 316 | return num_devices; |
c609719b WD |
317 | } |
318 | ||
53a5c424 DU |
319 | #ifdef CONFIG_MCAST_TFTP |
320 | /* Multicast. | |
321 | * mcast_addr: multicast ipaddr from which multicast Mac is made | |
85eb5caf | 322 | * join: 1=join, 0=leave. |
53a5c424 | 323 | */ |
fce6900b | 324 | int eth_mcast_join(IPaddr_t mcast_ip, int join) |
53a5c424 | 325 | { |
66c7385a | 326 | u8 mcast_mac[6]; |
85eb5caf | 327 | if (!eth_current || !eth_current->mcast) |
53a5c424 DU |
328 | return -1; |
329 | mcast_mac[5] = htonl(mcast_ip) & 0xff; | |
330 | mcast_mac[4] = (htonl(mcast_ip)>>8) & 0xff; | |
331 | mcast_mac[3] = (htonl(mcast_ip)>>16) & 0x7f; | |
332 | mcast_mac[2] = 0x5e; | |
333 | mcast_mac[1] = 0x0; | |
334 | mcast_mac[0] = 0x1; | |
335 | return eth_current->mcast(eth_current, mcast_mac, join); | |
336 | } | |
337 | ||
85eb5caf WD |
338 | /* the 'way' for ethernet-CRC-32. Spliced in from Linux lib/crc32.c |
339 | * and this is the ethernet-crc method needed for TSEC -- and perhaps | |
53a5c424 DU |
340 | * some other adapter -- hash tables |
341 | */ | |
342 | #define CRCPOLY_LE 0xedb88320 | |
66c7385a | 343 | u32 ether_crc(size_t len, unsigned char const *p) |
53a5c424 DU |
344 | { |
345 | int i; | |
346 | u32 crc; | |
347 | crc = ~0; | |
348 | while (len--) { | |
349 | crc ^= *p++; | |
350 | for (i = 0; i < 8; i++) | |
351 | crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0); | |
352 | } | |
353 | /* an reverse the bits, cuz of way they arrive -- last-first */ | |
354 | crc = (crc >> 16) | (crc << 16); | |
355 | crc = (crc >> 8 & 0x00ff00ff) | (crc << 8 & 0xff00ff00); | |
356 | crc = (crc >> 4 & 0x0f0f0f0f) | (crc << 4 & 0xf0f0f0f0); | |
357 | crc = (crc >> 2 & 0x33333333) | (crc << 2 & 0xcccccccc); | |
358 | crc = (crc >> 1 & 0x55555555) | (crc << 1 & 0xaaaaaaaa); | |
359 | return crc; | |
360 | } | |
361 | ||
362 | #endif | |
363 | ||
c609719b WD |
364 | |
365 | int eth_init(bd_t *bis) | |
366 | { | |
86848a74 | 367 | struct eth_device *old_current, *dev; |
c609719b | 368 | |
6bc11388 | 369 | if (!eth_current) { |
66c7385a | 370 | puts("No ethernet found.\n"); |
05324a48 | 371 | return -ENODEV; |
6bc11388 | 372 | } |
c609719b | 373 | |
86848a74 | 374 | /* Sync environment with network devices */ |
86848a74 MF |
375 | dev = eth_devices; |
376 | do { | |
377 | uchar env_enetaddr[6]; | |
378 | ||
fea7dcae | 379 | if (eth_getenv_enetaddr_by_index("eth", dev->index, |
7616e785 | 380 | env_enetaddr)) |
86848a74 MF |
381 | memcpy(dev->enetaddr, env_enetaddr, 6); |
382 | ||
86848a74 MF |
383 | dev = dev->next; |
384 | } while (dev != eth_devices); | |
385 | ||
c609719b WD |
386 | old_current = eth_current; |
387 | do { | |
0ebf04c6 | 388 | debug("Trying %s\n", eth_current->name); |
c609719b | 389 | |
66c7385a | 390 | if (eth_current->init(eth_current, bis) >= 0) { |
c609719b WD |
391 | eth_current->state = ETH_STATE_ACTIVE; |
392 | ||
505be87a | 393 | return 0; |
c609719b | 394 | } |
0ebf04c6 | 395 | debug("FAIL\n"); |
c609719b WD |
396 | |
397 | eth_try_another(0); | |
398 | } while (old_current != eth_current); | |
399 | ||
05324a48 | 400 | return -ETIMEDOUT; |
c609719b WD |
401 | } |
402 | ||
403 | void eth_halt(void) | |
404 | { | |
405 | if (!eth_current) | |
406 | return; | |
407 | ||
408 | eth_current->halt(eth_current); | |
409 | ||
410 | eth_current->state = ETH_STATE_PASSIVE; | |
411 | } | |
412 | ||
db288a96 | 413 | int eth_send(void *packet, int length) |
c609719b WD |
414 | { |
415 | if (!eth_current) | |
05324a48 | 416 | return -ENODEV; |
c609719b WD |
417 | |
418 | return eth_current->send(eth_current, packet, length); | |
419 | } | |
420 | ||
421 | int eth_rx(void) | |
422 | { | |
423 | if (!eth_current) | |
05324a48 | 424 | return -ENODEV; |
c609719b WD |
425 | |
426 | return eth_current->recv(eth_current); | |
427 | } | |
428 | ||
f85b6071 | 429 | #ifdef CONFIG_API |
db288a96 | 430 | static void eth_save_packet(void *packet, int length) |
f85b6071 | 431 | { |
db288a96 | 432 | char *p = packet; |
f85b6071 RJ |
433 | int i; |
434 | ||
435 | if ((eth_rcv_last+1) % PKTBUFSRX == eth_rcv_current) | |
436 | return; | |
437 | ||
438 | if (PKTSIZE < length) | |
439 | return; | |
440 | ||
441 | for (i = 0; i < length; i++) | |
442 | eth_rcv_bufs[eth_rcv_last].data[i] = p[i]; | |
443 | ||
444 | eth_rcv_bufs[eth_rcv_last].length = length; | |
445 | eth_rcv_last = (eth_rcv_last + 1) % PKTBUFSRX; | |
446 | } | |
447 | ||
db288a96 | 448 | int eth_receive(void *packet, int length) |
f85b6071 | 449 | { |
db288a96 | 450 | char *p = packet; |
f85b6071 RJ |
451 | void *pp = push_packet; |
452 | int i; | |
453 | ||
454 | if (eth_rcv_current == eth_rcv_last) { | |
455 | push_packet = eth_save_packet; | |
456 | eth_rx(); | |
457 | push_packet = pp; | |
458 | ||
459 | if (eth_rcv_current == eth_rcv_last) | |
460 | return -1; | |
461 | } | |
462 | ||
46c07bcf | 463 | length = min(eth_rcv_bufs[eth_rcv_current].length, length); |
f85b6071 RJ |
464 | |
465 | for (i = 0; i < length; i++) | |
466 | p[i] = eth_rcv_bufs[eth_rcv_current].data[i]; | |
467 | ||
468 | eth_rcv_current = (eth_rcv_current + 1) % PKTBUFSRX; | |
469 | return length; | |
470 | } | |
471 | #endif /* CONFIG_API */ | |
472 | ||
84eb1fba JH |
473 | static void eth_current_changed(void) |
474 | { | |
475 | char *act = getenv("ethact"); | |
476 | /* update current ethernet name */ | |
477 | if (eth_get_dev()) { | |
478 | if (act == NULL || strcmp(act, eth_get_name()) != 0) | |
479 | setenv("ethact", eth_get_name()); | |
480 | } | |
481 | /* | |
482 | * remove the variable completely if there is no active | |
483 | * interface | |
484 | */ | |
485 | else if (act != NULL) | |
486 | setenv("ethact", NULL); | |
487 | } | |
488 | ||
c609719b WD |
489 | void eth_try_another(int first_restart) |
490 | { | |
66c7385a | 491 | static struct eth_device *first_failed; |
c650e1be | 492 | char *ethrotate; |
e1692577 MF |
493 | |
494 | /* | |
495 | * Do not rotate between network interfaces when | |
496 | * 'ethrotate' variable is set to 'no'. | |
497 | */ | |
66c7385a JH |
498 | ethrotate = getenv("ethrotate"); |
499 | if ((ethrotate != NULL) && (strcmp(ethrotate, "no") == 0)) | |
e1692577 | 500 | return; |
c609719b | 501 | |
84eb1fba | 502 | if (!eth_get_dev()) |
c609719b WD |
503 | return; |
504 | ||
66c7385a | 505 | if (first_restart) |
84eb1fba | 506 | first_failed = eth_get_dev(); |
c609719b | 507 | |
84eb1fba | 508 | eth_set_current_to_next(); |
c609719b | 509 | |
89d48367 | 510 | eth_current_changed(); |
a3d991bd | 511 | |
84eb1fba | 512 | if (first_failed == eth_get_dev()) |
c609719b | 513 | NetRestartWrap = 1; |
c609719b WD |
514 | } |
515 | ||
a3d991bd WD |
516 | void eth_set_current(void) |
517 | { | |
66c7385a JH |
518 | static char *act; |
519 | static int env_changed_id; | |
520 | struct eth_device *old_current; | |
2f70c49e | 521 | int env_id; |
a3d991bd | 522 | |
84eb1fba | 523 | if (!eth_get_dev()) /* XXX no current */ |
a3d991bd WD |
524 | return; |
525 | ||
2f70c49e HS |
526 | env_id = get_env_id(); |
527 | if ((act == NULL) || (env_changed_id != env_id)) { | |
528 | act = getenv("ethact"); | |
529 | env_changed_id = env_id; | |
530 | } | |
a3d991bd | 531 | if (act != NULL) { |
84eb1fba | 532 | old_current = eth_get_dev(); |
a3d991bd | 533 | do { |
84eb1fba | 534 | if (strcmp(eth_get_name(), act) == 0) |
a3d991bd | 535 | return; |
84eb1fba JH |
536 | eth_set_current_to_next(); |
537 | } while (old_current != eth_get_dev()); | |
a3d991bd WD |
538 | } |
539 | ||
89d48367 | 540 | eth_current_changed(); |
a3d991bd | 541 | } |
a3d991bd | 542 | |
84eb1fba | 543 | const char *eth_get_name(void) |
5bb226e8 | 544 | { |
84eb1fba | 545 | return eth_get_dev() ? eth_get_dev()->name : "unknown"; |
5bb226e8 | 546 | } |