1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * (C) Copyright 2001-2015 4 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. 5 * Joe Hershberger, National Instruments 6 */ 7 8 #include <common.h> 9 #include <command.h> 10 #include <environment.h> 11 #include <net.h> 12 #include <phy.h> 13 #include <linux/errno.h> 14 #include "eth_internal.h" 15 16 DECLARE_GLOBAL_DATA_PTR; 17 18 /* 19 * CPU and board-specific Ethernet initializations. Aliased function 20 * signals caller to move on 21 */ 22 static int __def_eth_init(bd_t *bis) 23 { 24 return -1; 25 } 26 int cpu_eth_init(bd_t *bis) __attribute__((weak, alias("__def_eth_init"))); 27 int board_eth_init(bd_t *bis) __attribute__((weak, alias("__def_eth_init"))); 28 29 #ifdef CONFIG_API 30 static struct { 31 uchar data[PKTSIZE]; 32 int length; 33 } eth_rcv_bufs[PKTBUFSRX]; 34 35 static unsigned int eth_rcv_current, eth_rcv_last; 36 #endif 37 38 static struct eth_device *eth_devices; 39 struct eth_device *eth_current; 40 41 void eth_set_current_to_next(void) 42 { 43 eth_current = eth_current->next; 44 } 45 46 void eth_set_dev(struct eth_device *dev) 47 { 48 eth_current = dev; 49 } 50 51 struct eth_device *eth_get_dev_by_name(const char *devname) 52 { 53 struct eth_device *dev, *target_dev; 54 55 BUG_ON(devname == NULL); 56 57 if (!eth_devices) 58 return NULL; 59 60 dev = eth_devices; 61 target_dev = NULL; 62 do { 63 if (strcmp(devname, dev->name) == 0) { 64 target_dev = dev; 65 break; 66 } 67 dev = dev->next; 68 } while (dev != eth_devices); 69 70 return target_dev; 71 } 72 73 struct eth_device *eth_get_dev_by_index(int index) 74 { 75 struct eth_device *dev, *target_dev; 76 77 if (!eth_devices) 78 return NULL; 79 80 dev = eth_devices; 81 target_dev = NULL; 82 do { 83 if (dev->index == index) { 84 target_dev = dev; 85 break; 86 } 87 dev = dev->next; 88 } while (dev != eth_devices); 89 90 return target_dev; 91 } 92 93 int eth_get_dev_index(void) 94 { 95 if (!eth_current) 96 return -1; 97 98 return eth_current->index; 99 } 100 101 static int on_ethaddr(const char *name, const char *value, enum env_op op, 102 int flags) 103 { 104 int index; 105 struct eth_device *dev; 106 107 if (!eth_devices) 108 return 0; 109 110 /* look for an index after "eth" */ 111 index = simple_strtoul(name + 3, NULL, 10); 112 113 dev = eth_devices; 114 do { 115 if (dev->index == index) { 116 switch (op) { 117 case env_op_create: 118 case env_op_overwrite: 119 eth_parse_enetaddr(value, dev->enetaddr); 120 eth_write_hwaddr(dev, "eth", dev->index); 121 break; 122 case env_op_delete: 123 memset(dev->enetaddr, 0, ARP_HLEN); 124 } 125 } 126 dev = dev->next; 127 } while (dev != eth_devices); 128 129 return 0; 130 } 131 U_BOOT_ENV_CALLBACK(ethaddr, on_ethaddr); 132 133 int eth_write_hwaddr(struct eth_device *dev, const char *base_name, 134 int eth_number) 135 { 136 unsigned char env_enetaddr[ARP_HLEN]; 137 int ret = 0; 138 139 eth_env_get_enetaddr_by_index(base_name, eth_number, env_enetaddr); 140 141 if (!is_zero_ethaddr(env_enetaddr)) { 142 if (!is_zero_ethaddr(dev->enetaddr) && 143 memcmp(dev->enetaddr, env_enetaddr, ARP_HLEN)) { 144 printf("\nWarning: %s MAC addresses don't match:\n", 145 dev->name); 146 printf("Address in SROM is %pM\n", 147 dev->enetaddr); 148 printf("Address in environment is %pM\n", 149 env_enetaddr); 150 } 151 152 memcpy(dev->enetaddr, env_enetaddr, ARP_HLEN); 153 } else if (is_valid_ethaddr(dev->enetaddr)) { 154 eth_env_set_enetaddr_by_index(base_name, eth_number, 155 dev->enetaddr); 156 } else if (is_zero_ethaddr(dev->enetaddr)) { 157 #ifdef CONFIG_NET_RANDOM_ETHADDR 158 net_random_ethaddr(dev->enetaddr); 159 printf("\nWarning: %s (eth%d) using random MAC address - %pM\n", 160 dev->name, eth_number, dev->enetaddr); 161 #else 162 printf("\nError: %s address not set.\n", 163 dev->name); 164 return -EINVAL; 165 #endif 166 } 167 168 if (dev->write_hwaddr && !eth_mac_skip(eth_number)) { 169 if (!is_valid_ethaddr(dev->enetaddr)) { 170 printf("\nError: %s address %pM illegal value\n", 171 dev->name, dev->enetaddr); 172 return -EINVAL; 173 } 174 175 ret = dev->write_hwaddr(dev); 176 if (ret) 177 printf("\nWarning: %s failed to set MAC address\n", 178 dev->name); 179 } 180 181 return ret; 182 } 183 184 int eth_register(struct eth_device *dev) 185 { 186 struct eth_device *d; 187 static int index; 188 189 assert(strlen(dev->name) < sizeof(dev->name)); 190 191 if (!eth_devices) { 192 eth_devices = dev; 193 eth_current = dev; 194 eth_current_changed(); 195 } else { 196 for (d = eth_devices; d->next != eth_devices; d = d->next) 197 ; 198 d->next = dev; 199 } 200 201 dev->state = ETH_STATE_INIT; 202 dev->next = eth_devices; 203 dev->index = index++; 204 205 return 0; 206 } 207 208 int eth_unregister(struct eth_device *dev) 209 { 210 struct eth_device *cur; 211 212 /* No device */ 213 if (!eth_devices) 214 return -ENODEV; 215 216 for (cur = eth_devices; cur->next != eth_devices && cur->next != dev; 217 cur = cur->next) 218 ; 219 220 /* Device not found */ 221 if (cur->next != dev) 222 return -ENODEV; 223 224 cur->next = dev->next; 225 226 if (eth_devices == dev) 227 eth_devices = dev->next == eth_devices ? NULL : dev->next; 228 229 if (eth_current == dev) { 230 eth_current = eth_devices; 231 eth_current_changed(); 232 } 233 234 return 0; 235 } 236 237 int eth_initialize(void) 238 { 239 int num_devices = 0; 240 241 eth_devices = NULL; 242 eth_current = NULL; 243 eth_common_init(); 244 /* 245 * If board-specific initialization exists, call it. 246 * If not, call a CPU-specific one 247 */ 248 if (board_eth_init != __def_eth_init) { 249 if (board_eth_init(gd->bd) < 0) 250 printf("Board Net Initialization Failed\n"); 251 } else if (cpu_eth_init != __def_eth_init) { 252 if (cpu_eth_init(gd->bd) < 0) 253 printf("CPU Net Initialization Failed\n"); 254 } else { 255 printf("Net Initialization Skipped\n"); 256 } 257 258 if (!eth_devices) { 259 puts("No ethernet found.\n"); 260 bootstage_error(BOOTSTAGE_ID_NET_ETH_START); 261 } else { 262 struct eth_device *dev = eth_devices; 263 char *ethprime = env_get("ethprime"); 264 265 bootstage_mark(BOOTSTAGE_ID_NET_ETH_INIT); 266 do { 267 if (dev->index) 268 puts(", "); 269 270 printf("%s", dev->name); 271 272 if (ethprime && strcmp(dev->name, ethprime) == 0) { 273 eth_current = dev; 274 puts(" [PRIME]"); 275 } 276 277 if (strchr(dev->name, ' ')) 278 puts("\nWarning: eth device name has a space!" 279 "\n"); 280 281 eth_write_hwaddr(dev, "eth", dev->index); 282 283 dev = dev->next; 284 num_devices++; 285 } while (dev != eth_devices); 286 287 eth_current_changed(); 288 putc('\n'); 289 } 290 291 return num_devices; 292 } 293 294 /* Multicast. 295 * mcast_addr: multicast ipaddr from which multicast Mac is made 296 * join: 1=join, 0=leave. 297 */ 298 int eth_mcast_join(struct in_addr mcast_ip, int join) 299 { 300 u8 mcast_mac[ARP_HLEN]; 301 if (!eth_current || !eth_current->mcast) 302 return -1; 303 mcast_mac[5] = htonl(mcast_ip.s_addr) & 0xff; 304 mcast_mac[4] = (htonl(mcast_ip.s_addr)>>8) & 0xff; 305 mcast_mac[3] = (htonl(mcast_ip.s_addr)>>16) & 0x7f; 306 mcast_mac[2] = 0x5e; 307 mcast_mac[1] = 0x0; 308 mcast_mac[0] = 0x1; 309 return eth_current->mcast(eth_current, mcast_mac, join); 310 } 311 312 int eth_init(void) 313 { 314 struct eth_device *old_current; 315 316 if (!eth_current) { 317 puts("No ethernet found.\n"); 318 return -ENODEV; 319 } 320 321 old_current = eth_current; 322 do { 323 debug("Trying %s\n", eth_current->name); 324 325 if (eth_current->init(eth_current, gd->bd) >= 0) { 326 eth_current->state = ETH_STATE_ACTIVE; 327 328 return 0; 329 } 330 debug("FAIL\n"); 331 332 eth_try_another(0); 333 } while (old_current != eth_current); 334 335 return -ETIMEDOUT; 336 } 337 338 void eth_halt(void) 339 { 340 if (!eth_current) 341 return; 342 343 eth_current->halt(eth_current); 344 345 eth_current->state = ETH_STATE_PASSIVE; 346 } 347 348 int eth_is_active(struct eth_device *dev) 349 { 350 return dev && dev->state == ETH_STATE_ACTIVE; 351 } 352 353 int eth_send(void *packet, int length) 354 { 355 if (!eth_current) 356 return -ENODEV; 357 358 return eth_current->send(eth_current, packet, length); 359 } 360 361 int eth_rx(void) 362 { 363 if (!eth_current) 364 return -ENODEV; 365 366 return eth_current->recv(eth_current); 367 } 368 369 #ifdef CONFIG_API 370 static void eth_save_packet(void *packet, int length) 371 { 372 char *p = packet; 373 int i; 374 375 if ((eth_rcv_last+1) % PKTBUFSRX == eth_rcv_current) 376 return; 377 378 if (PKTSIZE < length) 379 return; 380 381 for (i = 0; i < length; i++) 382 eth_rcv_bufs[eth_rcv_last].data[i] = p[i]; 383 384 eth_rcv_bufs[eth_rcv_last].length = length; 385 eth_rcv_last = (eth_rcv_last + 1) % PKTBUFSRX; 386 } 387 388 int eth_receive(void *packet, int length) 389 { 390 char *p = packet; 391 void *pp = push_packet; 392 int i; 393 394 if (eth_rcv_current == eth_rcv_last) { 395 push_packet = eth_save_packet; 396 eth_rx(); 397 push_packet = pp; 398 399 if (eth_rcv_current == eth_rcv_last) 400 return -1; 401 } 402 403 length = min(eth_rcv_bufs[eth_rcv_current].length, length); 404 405 for (i = 0; i < length; i++) 406 p[i] = eth_rcv_bufs[eth_rcv_current].data[i]; 407 408 eth_rcv_current = (eth_rcv_current + 1) % PKTBUFSRX; 409 return length; 410 } 411 #endif /* CONFIG_API */ 412