omap3: cm-t3517: enable 'netretry' and setup timeout
[oweals/u-boot.git] / net / eth.c
1 /*
2  * (C) Copyright 2001-2015
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  * Joe Hershberger, National Instruments
5  *
6  * SPDX-License-Identifier:     GPL-2.0+
7  */
8
9 #include <common.h>
10 #include <command.h>
11 #include <dm.h>
12 #include <environment.h>
13 #include <net.h>
14 #include <miiphy.h>
15 #include <phy.h>
16 #include <asm/errno.h>
17 #include <dm/device-internal.h>
18 #include <dm/uclass-internal.h>
19
20 DECLARE_GLOBAL_DATA_PTR;
21
22 void eth_parse_enetaddr(const char *addr, uchar *enetaddr)
23 {
24         char *end;
25         int i;
26
27         for (i = 0; i < 6; ++i) {
28                 enetaddr[i] = addr ? simple_strtoul(addr, &end, 16) : 0;
29                 if (addr)
30                         addr = (*end) ? end + 1 : end;
31         }
32 }
33
34 int eth_getenv_enetaddr(char *name, uchar *enetaddr)
35 {
36         eth_parse_enetaddr(getenv(name), enetaddr);
37         return is_valid_ethaddr(enetaddr);
38 }
39
40 int eth_setenv_enetaddr(char *name, const uchar *enetaddr)
41 {
42         char buf[20];
43
44         sprintf(buf, "%pM", enetaddr);
45
46         return setenv(name, buf);
47 }
48
49 int eth_getenv_enetaddr_by_index(const char *base_name, int index,
50                                  uchar *enetaddr)
51 {
52         char enetvar[32];
53         sprintf(enetvar, index ? "%s%daddr" : "%saddr", base_name, index);
54         return eth_getenv_enetaddr(enetvar, enetaddr);
55 }
56
57 static inline int eth_setenv_enetaddr_by_index(const char *base_name, int index,
58                                  uchar *enetaddr)
59 {
60         char enetvar[32];
61         sprintf(enetvar, index ? "%s%daddr" : "%saddr", base_name, index);
62         return eth_setenv_enetaddr(enetvar, enetaddr);
63 }
64
65 static int eth_mac_skip(int index)
66 {
67         char enetvar[15];
68         char *skip_state;
69
70         sprintf(enetvar, index ? "eth%dmacskip" : "ethmacskip", index);
71         skip_state = getenv(enetvar);
72         return skip_state != NULL;
73 }
74
75 static void eth_current_changed(void);
76
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 }
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")));
87
88 static void eth_common_init(void)
89 {
90         bootstage_mark(BOOTSTAGE_ID_NET_ETH_START);
91 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) || defined(CONFIG_PHYLIB)
92         miiphy_init();
93 #endif
94
95 #ifdef CONFIG_PHYLIB
96         phy_init();
97 #endif
98
99         /*
100          * If board-specific initialization exists, call it.
101          * If not, call a CPU-specific one
102          */
103         if (board_eth_init != __def_eth_init) {
104                 if (board_eth_init(gd->bd) < 0)
105                         printf("Board Net Initialization Failed\n");
106         } else if (cpu_eth_init != __def_eth_init) {
107                 if (cpu_eth_init(gd->bd) < 0)
108                         printf("CPU Net Initialization Failed\n");
109         } else {
110 #ifndef CONFIG_DM_ETH
111                 printf("Net Initialization Skipped\n");
112 #endif
113         }
114 }
115
116 #ifdef CONFIG_DM_ETH
117 /**
118  * struct eth_device_priv - private structure for each Ethernet device
119  *
120  * @state: The state of the Ethernet MAC driver (defined by enum eth_state_t)
121  */
122 struct eth_device_priv {
123         enum eth_state_t state;
124 };
125
126 /**
127  * struct eth_uclass_priv - The structure attached to the uclass itself
128  *
129  * @current: The Ethernet device that the network functions are using
130  */
131 struct eth_uclass_priv {
132         struct udevice *current;
133 };
134
135 /* eth_errno - This stores the most recent failure code from DM functions */
136 static int eth_errno;
137
138 static struct eth_uclass_priv *eth_get_uclass_priv(void)
139 {
140         struct uclass *uc;
141
142         uclass_get(UCLASS_ETH, &uc);
143         assert(uc);
144         return uc->priv;
145 }
146
147 static void eth_set_current_to_next(void)
148 {
149         struct eth_uclass_priv *uc_priv;
150
151         uc_priv = eth_get_uclass_priv();
152         if (uc_priv->current)
153                 uclass_next_device(&uc_priv->current);
154         if (!uc_priv->current)
155                 uclass_first_device(UCLASS_ETH, &uc_priv->current);
156 }
157
158 /*
159  * Typically this will simply return the active device.
160  * In the case where the most recent active device was unset, this will attempt
161  * to return the first device. If that device doesn't exist or fails to probe,
162  * this function will return NULL.
163  */
164 struct udevice *eth_get_dev(void)
165 {
166         struct eth_uclass_priv *uc_priv;
167
168         uc_priv = eth_get_uclass_priv();
169         if (!uc_priv->current)
170                 eth_errno = uclass_first_device(UCLASS_ETH,
171                                     &uc_priv->current);
172         return uc_priv->current;
173 }
174
175 /*
176  * Typically this will just store a device pointer.
177  * In case it was not probed, we will attempt to do so.
178  * dev may be NULL to unset the active device.
179  */
180 static void eth_set_dev(struct udevice *dev)
181 {
182         if (dev && !device_active(dev))
183                 eth_errno = device_probe(dev);
184         eth_get_uclass_priv()->current = dev;
185 }
186
187 /*
188  * Find the udevice that either has the name passed in as devname or has an
189  * alias named devname.
190  */
191 struct udevice *eth_get_dev_by_name(const char *devname)
192 {
193         int seq = -1;
194         char *endp = NULL;
195         const char *startp = NULL;
196         struct udevice *it;
197         struct uclass *uc;
198         int len = strlen("eth");
199
200         /* Must be longer than 3 to be an alias */
201         if (!strncmp(devname, "eth", len) && strlen(devname) > len) {
202                 startp = devname + len;
203                 seq = simple_strtoul(startp, &endp, 10);
204         }
205
206         uclass_get(UCLASS_ETH, &uc);
207         uclass_foreach_dev(it, uc) {
208                 /*
209                  * We need the seq to be valid, so try to probe it.
210                  * If the probe fails, the seq will not match since it will be
211                  * -1 instead of what we are looking for.
212                  * We don't care about errors from probe here. Either they won't
213                  * match an alias or it will match a literal name and we'll pick
214                  * up the error when we try to probe again in eth_set_dev().
215                  */
216                 device_probe(it);
217                 /*
218                  * Check for the name or the sequence number to match
219                  */
220                 if (strcmp(it->name, devname) == 0 ||
221                     (endp > startp && it->seq == seq))
222                         return it;
223         }
224
225         return NULL;
226 }
227
228 unsigned char *eth_get_ethaddr(void)
229 {
230         struct eth_pdata *pdata;
231
232         if (eth_get_dev()) {
233                 pdata = eth_get_dev()->platdata;
234                 return pdata->enetaddr;
235         }
236
237         return NULL;
238 }
239
240 /* Set active state without calling start on the driver */
241 int eth_init_state_only(void)
242 {
243         struct udevice *current;
244         struct eth_device_priv *priv;
245
246         current = eth_get_dev();
247         if (!current || !device_active(current))
248                 return -EINVAL;
249
250         priv = current->uclass_priv;
251         priv->state = ETH_STATE_ACTIVE;
252
253         return 0;
254 }
255
256 /* Set passive state without calling stop on the driver */
257 void eth_halt_state_only(void)
258 {
259         struct udevice *current;
260         struct eth_device_priv *priv;
261
262         current = eth_get_dev();
263         if (!current || !device_active(current))
264                 return;
265
266         priv = current->uclass_priv;
267         priv->state = ETH_STATE_PASSIVE;
268 }
269
270 int eth_get_dev_index(void)
271 {
272         if (eth_get_dev())
273                 return eth_get_dev()->seq;
274         return -1;
275 }
276
277 static int eth_write_hwaddr(struct udevice *dev)
278 {
279         struct eth_pdata *pdata = dev->platdata;
280         int ret = 0;
281
282         if (!dev || !device_active(dev))
283                 return -EINVAL;
284
285         /* seq is valid since the device is active */
286         if (eth_get_ops(dev)->write_hwaddr && !eth_mac_skip(dev->seq)) {
287                 if (!is_valid_ethaddr(pdata->enetaddr)) {
288                         printf("\nError: %s address %pM illegal value\n",
289                                dev->name, pdata->enetaddr);
290                         return -EINVAL;
291                 }
292
293                 /*
294                  * Drivers are allowed to decide not to implement this at
295                  * run-time. E.g. Some devices may use it and some may not.
296                  */
297                 ret = eth_get_ops(dev)->write_hwaddr(dev);
298                 if (ret == -ENOSYS)
299                         ret = 0;
300                 if (ret)
301                         printf("\nWarning: %s failed to set MAC address\n",
302                                dev->name);
303         }
304
305         return ret;
306 }
307
308 static int on_ethaddr(const char *name, const char *value, enum env_op op,
309         int flags)
310 {
311         int index;
312         int retval;
313         struct udevice *dev;
314
315         /* look for an index after "eth" */
316         index = simple_strtoul(name + 3, NULL, 10);
317
318         retval = uclass_find_device_by_seq(UCLASS_ETH, index, false, &dev);
319         if (!retval) {
320                 struct eth_pdata *pdata = dev->platdata;
321                 switch (op) {
322                 case env_op_create:
323                 case env_op_overwrite:
324                         eth_parse_enetaddr(value, pdata->enetaddr);
325                         break;
326                 case env_op_delete:
327                         memset(pdata->enetaddr, 0, 6);
328                 }
329         }
330
331         return 0;
332 }
333 U_BOOT_ENV_CALLBACK(ethaddr, on_ethaddr);
334
335 int eth_init(void)
336 {
337         struct udevice *current;
338         struct udevice *old_current;
339         int ret = -ENODEV;
340
341         current = eth_get_dev();
342         if (!current) {
343                 printf("No ethernet found.\n");
344                 return -ENODEV;
345         }
346
347         old_current = current;
348         do {
349                 debug("Trying %s\n", current->name);
350
351                 if (device_active(current)) {
352                         ret = eth_get_ops(current)->start(current);
353                         if (ret >= 0) {
354                                 struct eth_device_priv *priv =
355                                         current->uclass_priv;
356
357                                 priv->state = ETH_STATE_ACTIVE;
358                                 return 0;
359                         }
360                 } else {
361                         ret = eth_errno;
362                 }
363
364                 debug("FAIL\n");
365
366                 /*
367                  * If ethrotate is enabled, this will change "current",
368                  * otherwise we will drop out of this while loop immediately
369                  */
370                 eth_try_another(0);
371                 /* This will ensure the new "current" attempted to probe */
372                 current = eth_get_dev();
373         } while (old_current != current);
374
375         return ret;
376 }
377
378 void eth_halt(void)
379 {
380         struct udevice *current;
381         struct eth_device_priv *priv;
382
383         current = eth_get_dev();
384         if (!current || !device_active(current))
385                 return;
386
387         eth_get_ops(current)->stop(current);
388         priv = current->uclass_priv;
389         priv->state = ETH_STATE_PASSIVE;
390 }
391
392 int eth_send(void *packet, int length)
393 {
394         struct udevice *current;
395         int ret;
396
397         current = eth_get_dev();
398         if (!current)
399                 return -ENODEV;
400
401         if (!device_active(current))
402                 return -EINVAL;
403
404         ret = eth_get_ops(current)->send(current, packet, length);
405         if (ret < 0) {
406                 /* We cannot completely return the error at present */
407                 debug("%s: send() returned error %d\n", __func__, ret);
408         }
409         return ret;
410 }
411
412 int eth_rx(void)
413 {
414         struct udevice *current;
415         uchar *packet;
416         int flags;
417         int ret;
418         int i;
419
420         current = eth_get_dev();
421         if (!current)
422                 return -ENODEV;
423
424         if (!device_active(current))
425                 return -EINVAL;
426
427         /* Process up to 32 packets at one time */
428         flags = ETH_RECV_CHECK_DEVICE;
429         for (i = 0; i < 32; i++) {
430                 ret = eth_get_ops(current)->recv(current, flags, &packet);
431                 flags = 0;
432                 if (ret > 0)
433                         net_process_received_packet(packet, ret);
434                 if (ret >= 0 && eth_get_ops(current)->free_pkt)
435                         eth_get_ops(current)->free_pkt(current, packet, ret);
436                 if (ret <= 0)
437                         break;
438         }
439         if (ret == -EAGAIN)
440                 ret = 0;
441         if (ret < 0) {
442                 /* We cannot completely return the error at present */
443                 debug("%s: recv() returned error %d\n", __func__, ret);
444         }
445         return ret;
446 }
447
448 int eth_initialize(void)
449 {
450         int num_devices = 0;
451         struct udevice *dev;
452
453         eth_common_init();
454
455         /*
456          * Devices need to write the hwaddr even if not started so that Linux
457          * will have access to the hwaddr that u-boot stored for the device.
458          * This is accomplished by attempting to probe each device and calling
459          * their write_hwaddr() operation.
460          */
461         uclass_first_device(UCLASS_ETH, &dev);
462         if (!dev) {
463                 printf("No ethernet found.\n");
464                 bootstage_error(BOOTSTAGE_ID_NET_ETH_START);
465         } else {
466                 char *ethprime = getenv("ethprime");
467                 struct udevice *prime_dev = NULL;
468
469                 if (ethprime)
470                         prime_dev = eth_get_dev_by_name(ethprime);
471                 if (prime_dev) {
472                         eth_set_dev(prime_dev);
473                         eth_current_changed();
474                 } else {
475                         eth_set_dev(NULL);
476                 }
477
478                 bootstage_mark(BOOTSTAGE_ID_NET_ETH_INIT);
479                 do {
480                         if (num_devices)
481                                 printf(", ");
482
483                         printf("eth%d: %s", dev->seq, dev->name);
484
485                         if (ethprime && dev == prime_dev)
486                                 printf(" [PRIME]");
487
488                         eth_write_hwaddr(dev);
489
490                         uclass_next_device(&dev);
491                         num_devices++;
492                 } while (dev);
493
494                 putc('\n');
495         }
496
497         return num_devices;
498 }
499
500 static int eth_post_bind(struct udevice *dev)
501 {
502         if (strchr(dev->name, ' ')) {
503                 printf("\nError: eth device name \"%s\" has a space!\n",
504                        dev->name);
505                 return -EINVAL;
506         }
507
508         return 0;
509 }
510
511 static int eth_pre_unbind(struct udevice *dev)
512 {
513         /* Don't hang onto a pointer that is going away */
514         if (dev == eth_get_uclass_priv()->current)
515                 eth_set_dev(NULL);
516
517         return 0;
518 }
519
520 static int eth_post_probe(struct udevice *dev)
521 {
522         struct eth_device_priv *priv = dev->uclass_priv;
523         struct eth_pdata *pdata = dev->platdata;
524         unsigned char env_enetaddr[6];
525
526         priv->state = ETH_STATE_INIT;
527
528         /* Check if the device has a MAC address in ROM */
529         if (eth_get_ops(dev)->read_rom_hwaddr)
530                 eth_get_ops(dev)->read_rom_hwaddr(dev);
531
532         eth_getenv_enetaddr_by_index("eth", dev->seq, env_enetaddr);
533         if (!is_zero_ethaddr(env_enetaddr)) {
534                 if (!is_zero_ethaddr(pdata->enetaddr) &&
535                     memcmp(pdata->enetaddr, env_enetaddr, 6)) {
536                         printf("\nWarning: %s MAC addresses don't match:\n",
537                                dev->name);
538                         printf("Address in SROM is         %pM\n",
539                                pdata->enetaddr);
540                         printf("Address in environment is  %pM\n",
541                                env_enetaddr);
542                 }
543
544                 /* Override the ROM MAC address */
545                 memcpy(pdata->enetaddr, env_enetaddr, 6);
546         } else if (is_valid_ethaddr(pdata->enetaddr)) {
547                 eth_setenv_enetaddr_by_index("eth", dev->seq, pdata->enetaddr);
548                 printf("\nWarning: %s using MAC address from ROM\n",
549                        dev->name);
550         } else if (is_zero_ethaddr(pdata->enetaddr)) {
551 #ifdef CONFIG_NET_RANDOM_ETHADDR
552                 net_random_ethaddr(pdata->enetaddr);
553                 printf("\nWarning: %s (eth%d) using random MAC address - %pM\n",
554                        dev->name, dev->seq, pdata->enetaddr);
555 #else
556                 printf("\nError: %s address not set.\n",
557                        dev->name);
558                 return -EINVAL;
559 #endif
560         }
561
562         return 0;
563 }
564
565 static int eth_pre_remove(struct udevice *dev)
566 {
567         eth_get_ops(dev)->stop(dev);
568
569         return 0;
570 }
571
572 UCLASS_DRIVER(eth) = {
573         .name           = "eth",
574         .id             = UCLASS_ETH,
575         .post_bind      = eth_post_bind,
576         .pre_unbind     = eth_pre_unbind,
577         .post_probe     = eth_post_probe,
578         .pre_remove     = eth_pre_remove,
579         .priv_auto_alloc_size = sizeof(struct eth_uclass_priv),
580         .per_device_auto_alloc_size = sizeof(struct eth_device_priv),
581         .flags          = DM_UC_FLAG_SEQ_ALIAS,
582 };
583 #endif
584
585 #ifndef CONFIG_DM_ETH
586
587 #ifdef CONFIG_API
588 static struct {
589         uchar data[PKTSIZE];
590         int length;
591 } eth_rcv_bufs[PKTBUFSRX];
592
593 static unsigned int eth_rcv_current, eth_rcv_last;
594 #endif
595
596 static struct eth_device *eth_devices;
597 struct eth_device *eth_current;
598
599 static void eth_set_current_to_next(void)
600 {
601         eth_current = eth_current->next;
602 }
603
604 static void eth_set_dev(struct eth_device *dev)
605 {
606         eth_current = dev;
607 }
608
609 struct eth_device *eth_get_dev_by_name(const char *devname)
610 {
611         struct eth_device *dev, *target_dev;
612
613         BUG_ON(devname == NULL);
614
615         if (!eth_devices)
616                 return NULL;
617
618         dev = eth_devices;
619         target_dev = NULL;
620         do {
621                 if (strcmp(devname, dev->name) == 0) {
622                         target_dev = dev;
623                         break;
624                 }
625                 dev = dev->next;
626         } while (dev != eth_devices);
627
628         return target_dev;
629 }
630
631 struct eth_device *eth_get_dev_by_index(int index)
632 {
633         struct eth_device *dev, *target_dev;
634
635         if (!eth_devices)
636                 return NULL;
637
638         dev = eth_devices;
639         target_dev = NULL;
640         do {
641                 if (dev->index == index) {
642                         target_dev = dev;
643                         break;
644                 }
645                 dev = dev->next;
646         } while (dev != eth_devices);
647
648         return target_dev;
649 }
650
651 int eth_get_dev_index(void)
652 {
653         if (!eth_current)
654                 return -1;
655
656         return eth_current->index;
657 }
658
659 static int on_ethaddr(const char *name, const char *value, enum env_op op,
660         int flags)
661 {
662         int index;
663         struct eth_device *dev;
664
665         if (!eth_devices)
666                 return 0;
667
668         /* look for an index after "eth" */
669         index = simple_strtoul(name + 3, NULL, 10);
670
671         dev = eth_devices;
672         do {
673                 if (dev->index == index) {
674                         switch (op) {
675                         case env_op_create:
676                         case env_op_overwrite:
677                                 eth_parse_enetaddr(value, dev->enetaddr);
678                                 break;
679                         case env_op_delete:
680                                 memset(dev->enetaddr, 0, 6);
681                         }
682                 }
683         } while (dev != eth_devices);
684
685         return 0;
686 }
687 U_BOOT_ENV_CALLBACK(ethaddr, on_ethaddr);
688
689 int eth_write_hwaddr(struct eth_device *dev, const char *base_name,
690                    int eth_number)
691 {
692         unsigned char env_enetaddr[6];
693         int ret = 0;
694
695         eth_getenv_enetaddr_by_index(base_name, eth_number, env_enetaddr);
696
697         if (!is_zero_ethaddr(env_enetaddr)) {
698                 if (!is_zero_ethaddr(dev->enetaddr) &&
699                     memcmp(dev->enetaddr, env_enetaddr, 6)) {
700                         printf("\nWarning: %s MAC addresses don't match:\n",
701                                dev->name);
702                         printf("Address in SROM is         %pM\n",
703                                dev->enetaddr);
704                         printf("Address in environment is  %pM\n",
705                                env_enetaddr);
706                 }
707
708                 memcpy(dev->enetaddr, env_enetaddr, 6);
709         } else if (is_valid_ethaddr(dev->enetaddr)) {
710                 eth_setenv_enetaddr_by_index(base_name, eth_number,
711                                              dev->enetaddr);
712                 printf("\nWarning: %s using MAC address from net device\n",
713                        dev->name);
714         } else if (is_zero_ethaddr(dev->enetaddr)) {
715 #ifdef CONFIG_NET_RANDOM_ETHADDR
716                 net_random_ethaddr(dev->enetaddr);
717                 printf("\nWarning: %s (eth%d) using random MAC address - %pM\n",
718                        dev->name, eth_number, dev->enetaddr);
719 #else
720                 printf("\nError: %s address not set.\n",
721                        dev->name);
722                 return -EINVAL;
723 #endif
724         }
725
726         if (dev->write_hwaddr && !eth_mac_skip(eth_number)) {
727                 if (!is_valid_ethaddr(dev->enetaddr)) {
728                         printf("\nError: %s address %pM illegal value\n",
729                                dev->name, dev->enetaddr);
730                         return -EINVAL;
731                 }
732
733                 ret = dev->write_hwaddr(dev);
734                 if (ret)
735                         printf("\nWarning: %s failed to set MAC address\n",
736                                dev->name);
737         }
738
739         return ret;
740 }
741
742 int eth_register(struct eth_device *dev)
743 {
744         struct eth_device *d;
745         static int index;
746
747         assert(strlen(dev->name) < sizeof(dev->name));
748
749         if (!eth_devices) {
750                 eth_devices = dev;
751                 eth_current = dev;
752                 eth_current_changed();
753         } else {
754                 for (d = eth_devices; d->next != eth_devices; d = d->next)
755                         ;
756                 d->next = dev;
757         }
758
759         dev->state = ETH_STATE_INIT;
760         dev->next  = eth_devices;
761         dev->index = index++;
762
763         return 0;
764 }
765
766 int eth_unregister(struct eth_device *dev)
767 {
768         struct eth_device *cur;
769
770         /* No device */
771         if (!eth_devices)
772                 return -ENODEV;
773
774         for (cur = eth_devices; cur->next != eth_devices && cur->next != dev;
775              cur = cur->next)
776                 ;
777
778         /* Device not found */
779         if (cur->next != dev)
780                 return -ENODEV;
781
782         cur->next = dev->next;
783
784         if (eth_devices == dev)
785                 eth_devices = dev->next == eth_devices ? NULL : dev->next;
786
787         if (eth_current == dev) {
788                 eth_current = eth_devices;
789                 eth_current_changed();
790         }
791
792         return 0;
793 }
794
795 int eth_initialize(void)
796 {
797         int num_devices = 0;
798
799         eth_devices = NULL;
800         eth_current = NULL;
801         eth_common_init();
802
803         if (!eth_devices) {
804                 puts("No ethernet found.\n");
805                 bootstage_error(BOOTSTAGE_ID_NET_ETH_START);
806         } else {
807                 struct eth_device *dev = eth_devices;
808                 char *ethprime = getenv("ethprime");
809
810                 bootstage_mark(BOOTSTAGE_ID_NET_ETH_INIT);
811                 do {
812                         if (dev->index)
813                                 puts(", ");
814
815                         printf("%s", dev->name);
816
817                         if (ethprime && strcmp(dev->name, ethprime) == 0) {
818                                 eth_current = dev;
819                                 puts(" [PRIME]");
820                         }
821
822                         if (strchr(dev->name, ' '))
823                                 puts("\nWarning: eth device name has a space!"
824                                         "\n");
825
826                         eth_write_hwaddr(dev, "eth", dev->index);
827
828                         dev = dev->next;
829                         num_devices++;
830                 } while (dev != eth_devices);
831
832                 eth_current_changed();
833                 putc('\n');
834         }
835
836         return num_devices;
837 }
838
839 #ifdef CONFIG_MCAST_TFTP
840 /* Multicast.
841  * mcast_addr: multicast ipaddr from which multicast Mac is made
842  * join: 1=join, 0=leave.
843  */
844 int eth_mcast_join(struct in_addr mcast_ip, int join)
845 {
846         u8 mcast_mac[6];
847         if (!eth_current || !eth_current->mcast)
848                 return -1;
849         mcast_mac[5] = htonl(mcast_ip.s_addr) & 0xff;
850         mcast_mac[4] = (htonl(mcast_ip.s_addr)>>8) & 0xff;
851         mcast_mac[3] = (htonl(mcast_ip.s_addr)>>16) & 0x7f;
852         mcast_mac[2] = 0x5e;
853         mcast_mac[1] = 0x0;
854         mcast_mac[0] = 0x1;
855         return eth_current->mcast(eth_current, mcast_mac, join);
856 }
857
858 /* the 'way' for ethernet-CRC-32. Spliced in from Linux lib/crc32.c
859  * and this is the ethernet-crc method needed for TSEC -- and perhaps
860  * some other adapter -- hash tables
861  */
862 #define CRCPOLY_LE 0xedb88320
863 u32 ether_crc(size_t len, unsigned char const *p)
864 {
865         int i;
866         u32 crc;
867         crc = ~0;
868         while (len--) {
869                 crc ^= *p++;
870                 for (i = 0; i < 8; i++)
871                         crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0);
872         }
873         /* an reverse the bits, cuz of way they arrive -- last-first */
874         crc = (crc >> 16) | (crc << 16);
875         crc = (crc >> 8 & 0x00ff00ff) | (crc << 8 & 0xff00ff00);
876         crc = (crc >> 4 & 0x0f0f0f0f) | (crc << 4 & 0xf0f0f0f0);
877         crc = (crc >> 2 & 0x33333333) | (crc << 2 & 0xcccccccc);
878         crc = (crc >> 1 & 0x55555555) | (crc << 1 & 0xaaaaaaaa);
879         return crc;
880 }
881
882 #endif
883
884
885 int eth_init(void)
886 {
887         struct eth_device *old_current;
888
889         if (!eth_current) {
890                 puts("No ethernet found.\n");
891                 return -ENODEV;
892         }
893
894         old_current = eth_current;
895         do {
896                 debug("Trying %s\n", eth_current->name);
897
898                 if (eth_current->init(eth_current, gd->bd) >= 0) {
899                         eth_current->state = ETH_STATE_ACTIVE;
900
901                         return 0;
902                 }
903                 debug("FAIL\n");
904
905                 eth_try_another(0);
906         } while (old_current != eth_current);
907
908         return -ETIMEDOUT;
909 }
910
911 void eth_halt(void)
912 {
913         if (!eth_current)
914                 return;
915
916         eth_current->halt(eth_current);
917
918         eth_current->state = ETH_STATE_PASSIVE;
919 }
920
921 int eth_send(void *packet, int length)
922 {
923         if (!eth_current)
924                 return -ENODEV;
925
926         return eth_current->send(eth_current, packet, length);
927 }
928
929 int eth_rx(void)
930 {
931         if (!eth_current)
932                 return -ENODEV;
933
934         return eth_current->recv(eth_current);
935 }
936 #endif /* ifndef CONFIG_DM_ETH */
937
938 #ifdef CONFIG_API
939 static void eth_save_packet(void *packet, int length)
940 {
941         char *p = packet;
942         int i;
943
944         if ((eth_rcv_last+1) % PKTBUFSRX == eth_rcv_current)
945                 return;
946
947         if (PKTSIZE < length)
948                 return;
949
950         for (i = 0; i < length; i++)
951                 eth_rcv_bufs[eth_rcv_last].data[i] = p[i];
952
953         eth_rcv_bufs[eth_rcv_last].length = length;
954         eth_rcv_last = (eth_rcv_last + 1) % PKTBUFSRX;
955 }
956
957 int eth_receive(void *packet, int length)
958 {
959         char *p = packet;
960         void *pp = push_packet;
961         int i;
962
963         if (eth_rcv_current == eth_rcv_last) {
964                 push_packet = eth_save_packet;
965                 eth_rx();
966                 push_packet = pp;
967
968                 if (eth_rcv_current == eth_rcv_last)
969                         return -1;
970         }
971
972         length = min(eth_rcv_bufs[eth_rcv_current].length, length);
973
974         for (i = 0; i < length; i++)
975                 p[i] = eth_rcv_bufs[eth_rcv_current].data[i];
976
977         eth_rcv_current = (eth_rcv_current + 1) % PKTBUFSRX;
978         return length;
979 }
980 #endif /* CONFIG_API */
981
982 static void eth_current_changed(void)
983 {
984         char *act = getenv("ethact");
985         /* update current ethernet name */
986         if (eth_get_dev()) {
987                 if (act == NULL || strcmp(act, eth_get_name()) != 0)
988                         setenv("ethact", eth_get_name());
989         }
990         /*
991          * remove the variable completely if there is no active
992          * interface
993          */
994         else if (act != NULL)
995                 setenv("ethact", NULL);
996 }
997
998 void eth_try_another(int first_restart)
999 {
1000         static void *first_failed;
1001         char *ethrotate;
1002
1003         /*
1004          * Do not rotate between network interfaces when
1005          * 'ethrotate' variable is set to 'no'.
1006          */
1007         ethrotate = getenv("ethrotate");
1008         if ((ethrotate != NULL) && (strcmp(ethrotate, "no") == 0))
1009                 return;
1010
1011         if (!eth_get_dev())
1012                 return;
1013
1014         if (first_restart)
1015                 first_failed = eth_get_dev();
1016
1017         eth_set_current_to_next();
1018
1019         eth_current_changed();
1020
1021         if (first_failed == eth_get_dev())
1022                 net_restart_wrap = 1;
1023 }
1024
1025 void eth_set_current(void)
1026 {
1027         static char *act;
1028         static int  env_changed_id;
1029         int     env_id;
1030
1031         env_id = get_env_id();
1032         if ((act == NULL) || (env_changed_id != env_id)) {
1033                 act = getenv("ethact");
1034                 env_changed_id = env_id;
1035         }
1036
1037         if (act == NULL) {
1038                 char *ethprime = getenv("ethprime");
1039                 void *dev = NULL;
1040
1041                 if (ethprime)
1042                         dev = eth_get_dev_by_name(ethprime);
1043                 if (dev)
1044                         eth_set_dev(dev);
1045                 else
1046                         eth_set_dev(NULL);
1047         } else {
1048                 eth_set_dev(eth_get_dev_by_name(act));
1049         }
1050
1051         eth_current_changed();
1052 }
1053
1054 const char *eth_get_name(void)
1055 {
1056         return eth_get_dev() ? eth_get_dev()->name : "unknown";
1057 }