1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * (C) Copyright 2001-2015 4 * Wolfgang Denk, DENX Software Engineering, wd (at) denx.de. 5 * Joe Hershberger, National Instruments 6 */ 7 8 #include <common.h> 9 #include <dm.h> 10 #include <environment.h> 11 #include <net.h> 12 #include <dm/device-internal.h> 13 #include <dm/uclass-internal.h> 14 #include "eth_internal.h" 15 16 DECLARE_GLOBAL_DATA_PTR; 17 18 /** 19 * struct eth_device_priv - private structure for each Ethernet device 20 * 21 * @state: The state of the Ethernet MAC driver (defined by enum eth_state_t) 22 */ 23 struct eth_device_priv { 24 enum eth_state_t state; 25 }; 26 27 /** 28 * struct eth_uclass_priv - The structure attached to the uclass itself 29 * 30 * @current: The Ethernet device that the network functions are using 31 */ 32 struct eth_uclass_priv { 33 struct udevice *current; 34 }; 35 36 /* eth_errno - This stores the most recent failure code from DM functions */ 37 static int eth_errno; 38 39 static struct eth_uclass_priv *eth_get_uclass_priv(void) 40 { 41 struct uclass *uc; 42 43 uclass_get(UCLASS_ETH, &uc); 44 assert(uc); 45 return uc->priv; 46 } 47 48 void eth_set_current_to_next(void) 49 { 50 struct eth_uclass_priv *uc_priv; 51 52 uc_priv = eth_get_uclass_priv(); 53 if (uc_priv->current) 54 uclass_next_device(&uc_priv->current); 55 if (!uc_priv->current) 56 uclass_first_device(UCLASS_ETH, &uc_priv->current); 57 } 58 59 /* 60 * Typically this will simply return the active device. 61 * In the case where the most recent active device was unset, this will attempt 62 * to return the first device. If that device doesn't exist or fails to probe, 63 * this function will return NULL. 64 */ 65 struct udevice *eth_get_dev(void) 66 { 67 struct eth_uclass_priv *uc_priv; 68 69 uc_priv = eth_get_uclass_priv(); 70 if (!uc_priv->current) 71 eth_errno = uclass_first_device(UCLASS_ETH, 72 &uc_priv->current); 73 return uc_priv->current; 74 } 75 76 /* 77 * Typically this will just store a device pointer. 78 * In case it was not probed, we will attempt to do so. 79 * dev may be NULL to unset the active device. 80 */ 81 void eth_set_dev(struct udevice *dev) 82 { 83 if (dev && !device_active(dev)) { 84 eth_errno = device_probe(dev); 85 if (eth_errno) 86 dev = NULL; 87 } 88 89 eth_get_uclass_priv()->current = dev; 90 } 91 92 /* 93 * Find the udevice that either has the name passed in as devname or has an 94 * alias named devname. 95 */ 96 struct udevice *eth_get_dev_by_name(const char *devname) 97 { 98 int seq = -1; 99 char *endp = NULL; 100 const char *startp = NULL; 101 struct udevice *it; 102 struct uclass *uc; 103 int len = strlen("eth"); 104 105 /* Must be longer than 3 to be an alias */ 106 if (!strncmp(devname, "eth", len) && strlen(devname) > len) { 107 startp = devname + len; 108 seq = simple_strtoul(startp, &endp, 10); 109 } 110 111 uclass_get(UCLASS_ETH, &uc); 112 uclass_foreach_dev(it, uc) { 113 /* 114 * We need the seq to be valid, so try to probe it. 115 * If the probe fails, the seq will not match since it will be 116 * -1 instead of what we are looking for. 117 * We don't care about errors from probe here. Either they won't 118 * match an alias or it will match a literal name and we'll pick 119 * up the error when we try to probe again in eth_set_dev(). 120 */ 121 if (device_probe(it)) 122 continue; 123 /* Check for the name or the sequence number to match */ 124 if (strcmp(it->name, devname) == 0 || 125 (endp > startp && it->seq == seq)) 126 return it; 127 } 128 129 return NULL; 130 } 131 132 unsigned char *eth_get_ethaddr(void) 133 { 134 struct eth_pdata *pdata; 135 136 if (eth_get_dev()) { 137 pdata = eth_get_dev()->platdata; 138 return pdata->enetaddr; 139 } 140 141 return NULL; 142 } 143 144 /* Set active state without calling start on the driver */ 145 int eth_init_state_only(void) 146 { 147 struct udevice *current; 148 struct eth_device_priv *priv; 149 150 current = eth_get_dev(); 151 if (!current || !device_active(current)) 152 return -EINVAL; 153 154 priv = current->uclass_priv; 155 priv->state = ETH_STATE_ACTIVE; 156 157 return 0; 158 } 159 160 /* Set passive state without calling stop on the driver */ 161 void eth_halt_state_only(void) 162 { 163 struct udevice *current; 164 struct eth_device_priv *priv; 165 166 current = eth_get_dev(); 167 if (!current || !device_active(current)) 168 return; 169 170 priv = current->uclass_priv; 171 priv->state = ETH_STATE_PASSIVE; 172 } 173 174 int eth_get_dev_index(void) 175 { 176 if (eth_get_dev()) 177 return eth_get_dev()->seq; 178 return -1; 179 } 180 181 static int eth_write_hwaddr(struct udevice *dev) 182 { 183 struct eth_pdata *pdata; 184 int ret = 0; 185 186 if (!dev || !device_active(dev)) 187 return -EINVAL; 188 189 /* seq is valid since the device is active */ 190 if (eth_get_ops(dev)->write_hwaddr && !eth_mac_skip(dev->seq)) { 191 pdata = dev->platdata; 192 if (!is_valid_ethaddr(pdata->enetaddr)) { 193 printf("\nError: %s address %pM illegal value\n", 194 dev->name, pdata->enetaddr); 195 return -EINVAL; 196 } 197 198 /* 199 * Drivers are allowed to decide not to implement this at 200 * run-time. E.g. Some devices may use it and some may not. 201 */ 202 ret = eth_get_ops(dev)->write_hwaddr(dev); 203 if (ret == -ENOSYS) 204 ret = 0; 205 if (ret) 206 printf("\nWarning: %s failed to set MAC address\n", 207 dev->name); 208 } 209 210 return ret; 211 } 212 213 static int on_ethaddr(const char *name, const char *value, enum env_op op, 214 int flags) 215 { 216 int index; 217 int retval; 218 struct udevice *dev; 219 220 /* look for an index after "eth" */ 221 index = simple_strtoul(name + 3, NULL, 10); 222 223 retval = uclass_find_device_by_seq(UCLASS_ETH, index, false, &dev); 224 if (!retval) { 225 struct eth_pdata *pdata = dev->platdata; 226 switch (op) { 227 case env_op_create: 228 case env_op_overwrite: 229 eth_parse_enetaddr(value, pdata->enetaddr); 230 eth_write_hwaddr(dev); 231 break; 232 case env_op_delete: 233 memset(pdata->enetaddr, 0, ARP_HLEN); 234 } 235 } 236 237 return 0; 238 } 239 U_BOOT_ENV_CALLBACK(ethaddr, on_ethaddr); 240 241 int eth_init(void) 242 { 243 char *ethact = env_get("ethact"); 244 char *ethrotate = env_get("ethrotate"); 245 struct udevice *current = NULL; 246 struct udevice *old_current; 247 int ret = -ENODEV; 248 249 /* 250 * When 'ethrotate' variable is set to 'no' and 'ethact' variable 251 * is already set to an ethernet device, we should stick to 'ethact'. 252 */ 253 if ((ethrotate != NULL) && (strcmp(ethrotate, "no") == 0)) { 254 if (ethact) { 255 current = eth_get_dev_by_name(ethact); 256 if (!current) 257 return -EINVAL; 258 } 259 } 260 261 if (!current) { 262 current = eth_get_dev(); 263 if (!current) { 264 printf("No ethernet found.\n"); 265 return -ENODEV; 266 } 267 } 268 269 old_current = current; 270 do { 271 if (current) { 272 debug("Trying %s\n", current->name); 273 274 if (device_active(current)) { 275 ret = eth_get_ops(current)->start(current); 276 if (ret >= 0) { 277 struct eth_device_priv *priv = 278 current->uclass_priv; 279 280 priv->state = ETH_STATE_ACTIVE; 281 return 0; 282 } 283 } else { 284 ret = eth_errno; 285 } 286 287 debug("FAIL\n"); 288 } else { 289 debug("PROBE FAIL\n"); 290 } 291 292 /* 293 * If ethrotate is enabled, this will change "current", 294 * otherwise we will drop out of this while loop immediately 295 */ 296 eth_try_another(0); 297 /* This will ensure the new "current" attempted to probe */ 298 current = eth_get_dev(); 299 } while (old_current != current); 300 301 return ret; 302 } 303 304 void eth_halt(void) 305 { 306 struct udevice *current; 307 struct eth_device_priv *priv; 308 309 current = eth_get_dev(); 310 if (!current || !device_active(current)) 311 return; 312 313 eth_get_ops(current)->stop(current); 314 priv = current->uclass_priv; 315 priv->state = ETH_STATE_PASSIVE; 316 } 317 318 int eth_is_active(struct udevice *dev) 319 { 320 struct eth_device_priv *priv; 321 322 if (!dev || !device_active(dev)) 323 return 0; 324 325 priv = dev_get_uclass_priv(dev); 326 return priv->state == ETH_STATE_ACTIVE; 327 } 328 329 int eth_send(void *packet, int length) 330 { 331 struct udevice *current; 332 int ret; 333 334 current = eth_get_dev(); 335 if (!current) 336 return -ENODEV; 337 338 if (!eth_is_active(current)) 339 return -EINVAL; 340 341 ret = eth_get_ops(current)->send(current, packet, length); 342 if (ret < 0) { 343 /* We cannot completely return the error at present */ 344 debug("%s: send() returned error %d\n", __func__, ret); 345 } 346 return ret; 347 } 348 349 int eth_rx(void) 350 { 351 struct udevice *current; 352 uchar *packet; 353 int flags; 354 int ret; 355 int i; 356 357 current = eth_get_dev(); 358 if (!current) 359 return -ENODEV; 360 361 if (!eth_is_active(current)) 362 return -EINVAL; 363 364 /* Process up to 32 packets at one time */ 365 flags = ETH_RECV_CHECK_DEVICE; 366 for (i = 0; i < 32; i++) { 367 ret = eth_get_ops(current)->recv(current, flags, &packet); 368 flags = 0; 369 if (ret > 0) 370 net_process_received_packet(packet, ret); 371 if (ret >= 0 && eth_get_ops(current)->free_pkt) 372 eth_get_ops(current)->free_pkt(current, packet, ret); 373 if (ret <= 0) 374 break; 375 } 376 if (ret == -EAGAIN) 377 ret = 0; 378 if (ret < 0) { 379 /* We cannot completely return the error at present */ 380 debug("%s: recv() returned error %d\n", __func__, ret); 381 } 382 return ret; 383 } 384 385 int eth_initialize(void) 386 { 387 int num_devices = 0; 388 struct udevice *dev; 389 390 eth_common_init(); 391 392 /* 393 * Devices need to write the hwaddr even if not started so that Linux 394 * will have access to the hwaddr that u-boot stored for the device. 395 * This is accomplished by attempting to probe each device and calling 396 * their write_hwaddr() operation. 397 */ 398 uclass_first_device_check(UCLASS_ETH, &dev); 399 if (!dev) { 400 printf("No ethernet found.\n"); 401 bootstage_error(BOOTSTAGE_ID_NET_ETH_START); 402 } else { 403 char *ethprime = env_get("ethprime"); 404 struct udevice *prime_dev = NULL; 405 406 if (ethprime) 407 prime_dev = eth_get_dev_by_name(ethprime); 408 if (prime_dev) { 409 eth_set_dev(prime_dev); 410 eth_current_changed(); 411 } else { 412 eth_set_dev(NULL); 413 } 414 415 bootstage_mark(BOOTSTAGE_ID_NET_ETH_INIT); 416 do { 417 if (num_devices) 418 printf(", "); 419 420 printf("eth%d: %s", dev->seq, dev->name); 421 422 if (ethprime && dev == prime_dev) 423 printf(" [PRIME]"); 424 425 eth_write_hwaddr(dev); 426 427 uclass_next_device_check(&dev); 428 num_devices++; 429 } while (dev); 430 431 putc('\n'); 432 } 433 434 return num_devices; 435 } 436 437 static int eth_post_bind(struct udevice *dev) 438 { 439 if (strchr(dev->name, ' ')) { 440 printf("\nError: eth device name \"%s\" has a space!\n", 441 dev->name); 442 return -EINVAL; 443 } 444 445 return 0; 446 } 447 448 static int eth_pre_unbind(struct udevice *dev) 449 { 450 /* Don't hang onto a pointer that is going away */ 451 if (dev == eth_get_uclass_priv()->current) 452 eth_set_dev(NULL); 453 454 return 0; 455 } 456 457 static int eth_post_probe(struct udevice *dev) 458 { 459 struct eth_device_priv *priv = dev->uclass_priv; 460 struct eth_pdata *pdata = dev->platdata; 461 unsigned char env_enetaddr[ARP_HLEN]; 462 463 #if defined(CONFIG_NEEDS_MANUAL_RELOC) 464 struct eth_ops *ops = eth_get_ops(dev); 465 static int reloc_done; 466 467 if (!reloc_done) { 468 if (ops->start) 469 ops->start += gd->reloc_off; 470 if (ops->send) 471 ops->send += gd->reloc_off; 472 if (ops->recv) 473 ops->recv += gd->reloc_off; 474 if (ops->free_pkt) 475 ops->free_pkt += gd->reloc_off; 476 if (ops->stop) 477 ops->stop += gd->reloc_off; 478 #ifdef CONFIG_MCAST_TFTP 479 if (ops->mcast) 480 ops->mcast += gd->reloc_off; 481 #endif 482 if (ops->write_hwaddr) 483 ops->write_hwaddr += gd->reloc_off; 484 if (ops->read_rom_hwaddr) 485 ops->read_rom_hwaddr += gd->reloc_off; 486 487 reloc_done++; 488 } 489 #endif 490 491 priv->state = ETH_STATE_INIT; 492 493 /* Check if the device has a MAC address in ROM */ 494 if (eth_get_ops(dev)->read_rom_hwaddr) 495 eth_get_ops(dev)->read_rom_hwaddr(dev); 496 497 eth_env_get_enetaddr_by_index("eth", dev->seq, env_enetaddr); 498 if (!is_zero_ethaddr(env_enetaddr)) { 499 if (!is_zero_ethaddr(pdata->enetaddr) && 500 memcmp(pdata->enetaddr, env_enetaddr, ARP_HLEN)) { 501 printf("\nWarning: %s MAC addresses don't match:\n", 502 dev->name); 503 printf("Address in ROM is %pM\n", 504 pdata->enetaddr); 505 printf("Address in environment is %pM\n", 506 env_enetaddr); 507 } 508 509 /* Override the ROM MAC address */ 510 memcpy(pdata->enetaddr, env_enetaddr, ARP_HLEN); 511 } else if (is_valid_ethaddr(pdata->enetaddr)) { 512 eth_env_set_enetaddr_by_index("eth", dev->seq, pdata->enetaddr); 513 printf("\nWarning: %s using MAC address from ROM\n", 514 dev->name); 515 } else if (is_zero_ethaddr(pdata->enetaddr) || 516 !is_valid_ethaddr(pdata->enetaddr)) { 517 #ifdef CONFIG_NET_RANDOM_ETHADDR 518 net_random_ethaddr(pdata->enetaddr); 519 printf("\nWarning: %s (eth%d) using random MAC address - %pM\n", 520 dev->name, dev->seq, pdata->enetaddr); 521 #else 522 printf("\nError: %s address not set.\n", 523 dev->name); 524 return -EINVAL; 525 #endif 526 } 527 528 return 0; 529 } 530 531 static int eth_pre_remove(struct udevice *dev) 532 { 533 struct eth_pdata *pdata = dev->platdata; 534 535 eth_get_ops(dev)->stop(dev); 536 537 /* clear the MAC address */ 538 memset(pdata->enetaddr, 0, ARP_HLEN); 539 540 return 0; 541 } 542 543 UCLASS_DRIVER(eth) = { 544 .name = "eth", 545 .id = UCLASS_ETH, 546 .post_bind = eth_post_bind, 547 .pre_unbind = eth_pre_unbind, 548 .post_probe = eth_post_probe, 549 .pre_remove = eth_pre_remove, 550 .priv_auto_alloc_size = sizeof(struct eth_uclass_priv), 551 .per_device_auto_alloc_size = sizeof(struct eth_device_priv), 552 .flags = DM_UC_FLAG_SEQ_ALIAS, 553 }; 554
