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