common/miiphyutil.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2001
   4  * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com.
   5  */
   6
   7 /*
   8  * This provides a bit-banged interface to the ethernet MII management
   9  * channel.
  10  */
  11
  12 #include <common.h>
  13 #include <dm.h>
  14 #include <log.h>
  15 #include <miiphy.h>
  16 #include <phy.h>
  17
  18 #include <asm/types.h>
  19 #include <linux/list.h>
  20 #include <malloc.h>
  21 #include <net.h>
  22
  23 /* local debug macro */
  24 #undef MII_DEBUG
  25
  26 #undef debug
  27 #ifdef MII_DEBUG
  28 #define debug(fmt, args...)     printf(fmt, ##args)
  29 #else
  30 #define debug(fmt, args...)
  31 #endif /* MII_DEBUG */
  32
  33 static struct list_head mii_devs;
  34 static struct mii_dev *current_mii;
  35
  36 /*
  37  * Lookup the mii_dev struct by the registered device name.
  38  */
  39 struct mii_dev *miiphy_get_dev_by_name(const char *devname)
  40 {
  41         struct list_head *entry;
  42         struct mii_dev *dev;
  43
  44         if (!devname) {
  45                 printf("NULL device name!\n");
  46                 return NULL;
  47         }
  48
  49         list_for_each(entry, &mii_devs) {
  50                 dev = list_entry(entry, struct mii_dev, link);
  51                 if (strcmp(dev->name, devname) == 0)
  52                         return dev;
  53         }
  54
  55         return NULL;
  56 }
  57
  58 /*****************************************************************************
  59  *
  60  * Initialize global data. Need to be called before any other miiphy routine.
  61  */
  62 void miiphy_init(void)
  63 {
  64         INIT_LIST_HEAD(&mii_devs);
  65         current_mii = NULL;
  66 }
  67
  68 struct mii_dev *mdio_alloc(void)
  69 {
  70         struct mii_dev *bus;
  71
  72         bus = malloc(sizeof(*bus));
  73         if (!bus)
  74                 return bus;
  75
  76         memset(bus, 0, sizeof(*bus));
  77
  78         /* initalize mii_dev struct fields */
  79         INIT_LIST_HEAD(&bus->link);
  80
  81         return bus;
  82 }
  83
  84 void mdio_free(struct mii_dev *bus)
  85 {
  86         free(bus);
  87 }
  88
  89 int mdio_register(struct mii_dev *bus)
  90 {
  91         if (!bus || !bus->read || !bus->write)
  92                 return -1;
  93
  94         /* check if we have unique name */
  95         if (miiphy_get_dev_by_name(bus->name)) {
  96                 printf("mdio_register: non unique device name '%s'\n",
  97                         bus->name);
  98                 return -1;
  99         }
 100
 101         /* add it to the list */
 102         list_add_tail(&bus->link, &mii_devs);
 103
 104         if (!current_mii)
 105                 current_mii = bus;
 106
 107         return 0;
 108 }
 109
 110 int mdio_register_seq(struct mii_dev *bus, int seq)
 111 {
 112         int ret;
 113
 114         /* Setup a unique name for each mdio bus */
 115         ret = snprintf(bus->name, MDIO_NAME_LEN, "eth%d", seq);
 116         if (ret < 0)
 117                 return ret;
 118
 119         return mdio_register(bus);
 120 }
 121
 122 int mdio_unregister(struct mii_dev *bus)
 123 {
 124         if (!bus)
 125                 return 0;
 126
 127         /* delete it from the list */
 128         list_del(&bus->link);
 129
 130         if (current_mii == bus)
 131                 current_mii = NULL;
 132
 133         return 0;
 134 }
 135
 136 void mdio_list_devices(void)
 137 {
 138         struct list_head *entry;
 139
 140         list_for_each(entry, &mii_devs) {
 141                 int i;
 142                 struct mii_dev *bus = list_entry(entry, struct mii_dev, link);
 143
 144                 printf("%s:\n", bus->name);
 145
 146                 for (i = 0; i < PHY_MAX_ADDR; i++) {
 147                         struct phy_device *phydev = bus->phymap[i];
 148
 149                         if (phydev) {
 150                                 printf("%x - %s", i, phydev->drv->name);
 151
 152                                 if (phydev->dev)
 153                                         printf(" <--> %s\n", phydev->dev->name);
 154                                 else
 155                                         printf("\n");
 156                         }
 157                 }
 158         }
 159 }
 160
 161 int miiphy_set_current_dev(const char *devname)
 162 {
 163         struct mii_dev *dev;
 164
 165         dev = miiphy_get_dev_by_name(devname);
 166         if (dev) {
 167                 current_mii = dev;
 168                 return 0;
 169         }
 170
 171         printf("No such device: %s\n", devname);
 172
 173         return 1;
 174 }
 175
 176 struct mii_dev *mdio_get_current_dev(void)
 177 {
 178         return current_mii;
 179 }
 180
 181 struct list_head *mdio_get_list_head(void)
 182 {
 183         return &mii_devs;
 184 }
 185
 186 struct phy_device *mdio_phydev_for_ethname(const char *ethname)
 187 {
 188         struct list_head *entry;
 189         struct mii_dev *bus;
 190
 191         list_for_each(entry, &mii_devs) {
 192                 int i;
 193                 bus = list_entry(entry, struct mii_dev, link);
 194
 195                 for (i = 0; i < PHY_MAX_ADDR; i++) {
 196                         if (!bus->phymap[i] || !bus->phymap[i]->dev)
 197                                 continue;
 198
 199                         if (strcmp(bus->phymap[i]->dev->name, ethname) == 0)
 200                                 return bus->phymap[i];
 201                 }
 202         }
 203
 204         printf("%s is not a known ethernet\n", ethname);
 205         return NULL;
 206 }
 207
 208 const char *miiphy_get_current_dev(void)
 209 {
 210         if (current_mii)
 211                 return current_mii->name;
 212
 213         return NULL;
 214 }
 215
 216 static struct mii_dev *miiphy_get_active_dev(const char *devname)
 217 {
 218         /* If the current mii is the one we want, return it */
 219         if (current_mii)
 220                 if (strcmp(current_mii->name, devname) == 0)
 221                         return current_mii;
 222
 223         /* Otherwise, set the active one to the one we want */
 224         if (miiphy_set_current_dev(devname))
 225                 return NULL;
 226         else
 227                 return current_mii;
 228 }
 229
 230 /*****************************************************************************
 231  *
 232  * Read to variable <value> from the PHY attached to device <devname>,
 233  * use PHY address <addr> and register <reg>.
 234  *
 235  * This API is deprecated. Use phy_read on a phy_device found via phy_connect
 236  *
 237  * Returns:
 238  *   0 on success
 239  */
 240 int miiphy_read(const char *devname, unsigned char addr, unsigned char reg,
 241                  unsigned short *value)
 242 {
 243         struct mii_dev *bus;
 244         int ret;
 245
 246         bus = miiphy_get_active_dev(devname);
 247         if (!bus)
 248                 return 1;
 249
 250         ret = bus->read(bus, addr, MDIO_DEVAD_NONE, reg);
 251         if (ret < 0)
 252                 return 1;
 253
 254         *value = (unsigned short)ret;
 255         return 0;
 256 }
 257
 258 /*****************************************************************************
 259  *
 260  * Write <value> to the PHY attached to device <devname>,
 261  * use PHY address <addr> and register <reg>.
 262  *
 263  * This API is deprecated. Use phy_write on a phy_device found by phy_connect
 264  *
 265  * Returns:
 266  *   0 on success
 267  */
 268 int miiphy_write(const char *devname, unsigned char addr, unsigned char reg,
 269                   unsigned short value)
 270 {
 271         struct mii_dev *bus;
 272
 273         bus = miiphy_get_active_dev(devname);
 274         if (bus)
 275                 return bus->write(bus, addr, MDIO_DEVAD_NONE, reg, value);
 276
 277         return 1;
 278 }
 279
 280 /*****************************************************************************
 281  *
 282  * Print out list of registered MII capable devices.
 283  */
 284 void miiphy_listdev(void)
 285 {
 286         struct list_head *entry;
 287         struct mii_dev *dev;
 288
 289         puts("MII devices: ");
 290         list_for_each(entry, &mii_devs) {
 291                 dev = list_entry(entry, struct mii_dev, link);
 292                 printf("'%s' ", dev->name);
 293         }
 294         puts("\n");
 295
 296         if (current_mii)
 297                 printf("Current device: '%s'\n", current_mii->name);
 298 }
 299
 300 /*****************************************************************************
 301  *
 302  * Read the OUI, manufacture's model number, and revision number.
 303  *
 304  * OUI:     22 bits (unsigned int)
 305  * Model:    6 bits (unsigned char)
 306  * Revision: 4 bits (unsigned char)
 307  *
 308  * This API is deprecated.
 309  *
 310  * Returns:
 311  *   0 on success
 312  */
 313 int miiphy_info(const char *devname, unsigned char addr, unsigned int *oui,
 314                  unsigned char *model, unsigned char *rev)
 315 {
 316         unsigned int reg = 0;
 317         unsigned short tmp;
 318
 319         if (miiphy_read(devname, addr, MII_PHYSID2, &tmp) != 0) {
 320                 debug("PHY ID register 2 read failed\n");
 321                 return -1;
 322         }
 323         reg = tmp;
 324
 325         debug("MII_PHYSID2 @ 0x%x = 0x%04x\n", addr, reg);
 326
 327         if (reg == 0xFFFF) {
 328                 /* No physical device present at this address */
 329                 return -1;
 330         }
 331
 332         if (miiphy_read(devname, addr, MII_PHYSID1, &tmp) != 0) {
 333                 debug("PHY ID register 1 read failed\n");
 334                 return -1;
 335         }
 336         reg |= tmp << 16;
 337         debug("PHY_PHYIDR[1,2] @ 0x%x = 0x%08x\n", addr, reg);
 338
 339         *oui = (reg >> 10);
 340         *model = (unsigned char)((reg >> 4) & 0x0000003F);
 341         *rev = (unsigned char)(reg & 0x0000000F);
 342         return 0;
 343 }
 344
 345 #ifndef CONFIG_PHYLIB
 346 /*****************************************************************************
 347  *
 348  * Reset the PHY.
 349  *
 350  * This API is deprecated. Use PHYLIB.
 351  *
 352  * Returns:
 353  *   0 on success
 354  */
 355 int miiphy_reset(const char *devname, unsigned char addr)
 356 {
 357         unsigned short reg;
 358         int timeout = 500;
 359
 360         if (miiphy_read(devname, addr, MII_BMCR, &reg) != 0) {
 361                 debug("PHY status read failed\n");
 362                 return -1;
 363         }
 364         if (miiphy_write(devname, addr, MII_BMCR, reg | BMCR_RESET) != 0) {
 365                 debug("PHY reset failed\n");
 366                 return -1;
 367         }
 368 #ifdef CONFIG_PHY_RESET_DELAY
 369         udelay(CONFIG_PHY_RESET_DELAY); /* Intel LXT971A needs this */
 370 #endif
 371         /*
 372          * Poll the control register for the reset bit to go to 0 (it is
 373          * auto-clearing).  This should happen within 0.5 seconds per the
 374          * IEEE spec.
 375          */
 376         reg = 0x8000;
 377         while (((reg & 0x8000) != 0) && timeout--) {
 378                 if (miiphy_read(devname, addr, MII_BMCR, &reg) != 0) {
 379                         debug("PHY status read failed\n");
 380                         return -1;
 381                 }
 382                 udelay(1000);
 383         }
 384         if ((reg & 0x8000) == 0) {
 385                 return 0;
 386         } else {
 387                 puts("PHY reset timed out\n");
 388                 return -1;
 389         }
 390         return 0;
 391 }
 392 #endif /* !PHYLIB */
 393
 394 /*****************************************************************************
 395  *
 396  * Determine the ethernet speed (10/100/1000).  Return 10 on error.
 397  */
 398 int miiphy_speed(const char *devname, unsigned char addr)
 399 {
 400         u16 bmcr, anlpar, adv;
 401
 402 #if defined(CONFIG_PHY_GIGE)
 403         u16 btsr;
 404
 405         /*
 406          * Check for 1000BASE-X.  If it is supported, then assume that the speed
 407          * is 1000.
 408          */
 409         if (miiphy_is_1000base_x(devname, addr))
 410                 return _1000BASET;
 411
 412         /*
 413          * No 1000BASE-X, so assume 1000BASE-T/100BASE-TX/10BASE-T register set.
 414          */
 415         /* Check for 1000BASE-T. */
 416         if (miiphy_read(devname, addr, MII_STAT1000, &btsr)) {
 417                 printf("PHY 1000BT status");
 418                 goto miiphy_read_failed;
 419         }
 420         if (btsr != 0xFFFF &&
 421                         (btsr & (PHY_1000BTSR_1000FD | PHY_1000BTSR_1000HD)))
 422                 return _1000BASET;
 423 #endif /* CONFIG_PHY_GIGE */
 424
 425         /* Check Basic Management Control Register first. */
 426         if (miiphy_read(devname, addr, MII_BMCR, &bmcr)) {
 427                 printf("PHY speed");
 428                 goto miiphy_read_failed;
 429         }
 430         /* Check if auto-negotiation is on. */
 431         if (bmcr & BMCR_ANENABLE) {
 432                 /* Get auto-negotiation results. */
 433                 if (miiphy_read(devname, addr, MII_LPA, &anlpar)) {
 434                         printf("PHY AN speed");
 435                         goto miiphy_read_failed;
 436                 }
 437
 438                 if (miiphy_read(devname, addr, MII_ADVERTISE, &adv)) {
 439                         puts("PHY AN adv speed");
 440                         goto miiphy_read_failed;
 441                 }
 442                 return ((anlpar & adv) & LPA_100) ? _100BASET : _10BASET;
 443         }
 444         /* Get speed from basic control settings. */
 445         return (bmcr & BMCR_SPEED100) ? _100BASET : _10BASET;
 446
 447 miiphy_read_failed:
 448         printf(" read failed, assuming 10BASE-T\n");
 449         return _10BASET;
 450 }
 451
 452 /*****************************************************************************
 453  *
 454  * Determine full/half duplex.  Return half on error.
 455  */
 456 int miiphy_duplex(const char *devname, unsigned char addr)
 457 {
 458         u16 bmcr, anlpar, adv;
 459
 460 #if defined(CONFIG_PHY_GIGE)
 461         u16 btsr;
 462
 463         /* Check for 1000BASE-X. */
 464         if (miiphy_is_1000base_x(devname, addr)) {
 465                 /* 1000BASE-X */
 466                 if (miiphy_read(devname, addr, MII_LPA, &anlpar)) {
 467                         printf("1000BASE-X PHY AN duplex");
 468                         goto miiphy_read_failed;
 469                 }
 470         }
 471         /*
 472          * No 1000BASE-X, so assume 1000BASE-T/100BASE-TX/10BASE-T register set.
 473          */
 474         /* Check for 1000BASE-T. */
 475         if (miiphy_read(devname, addr, MII_STAT1000, &btsr)) {
 476                 printf("PHY 1000BT status");
 477                 goto miiphy_read_failed;
 478         }
 479         if (btsr != 0xFFFF) {
 480                 if (btsr & PHY_1000BTSR_1000FD) {
 481                         return FULL;
 482                 } else if (btsr & PHY_1000BTSR_1000HD) {
 483                         return HALF;
 484                 }
 485         }
 486 #endif /* CONFIG_PHY_GIGE */
 487
 488         /* Check Basic Management Control Register first. */
 489         if (miiphy_read(devname, addr, MII_BMCR, &bmcr)) {
 490                 puts("PHY duplex");
 491                 goto miiphy_read_failed;
 492         }
 493         /* Check if auto-negotiation is on. */
 494         if (bmcr & BMCR_ANENABLE) {
 495                 /* Get auto-negotiation results. */
 496                 if (miiphy_read(devname, addr, MII_LPA, &anlpar)) {
 497                         puts("PHY AN duplex");
 498                         goto miiphy_read_failed;
 499                 }
 500
 501                 if (miiphy_read(devname, addr, MII_ADVERTISE, &adv)) {
 502                         puts("PHY AN adv duplex");
 503                         goto miiphy_read_failed;
 504                 }
 505                 return ((anlpar & adv) & (LPA_10FULL | LPA_100FULL)) ?
 506                     FULL : HALF;
 507         }
 508         /* Get speed from basic control settings. */
 509         return (bmcr & BMCR_FULLDPLX) ? FULL : HALF;
 510
 511 miiphy_read_failed:
 512         printf(" read failed, assuming half duplex\n");
 513         return HALF;
 514 }
 515
 516 /*****************************************************************************
 517  *
 518  * Return 1 if PHY supports 1000BASE-X, 0 if PHY supports 10BASE-T/100BASE-TX/
 519  * 1000BASE-T, or on error.
 520  */
 521 int miiphy_is_1000base_x(const char *devname, unsigned char addr)
 522 {
 523 #if defined(CONFIG_PHY_GIGE)
 524         u16 exsr;
 525
 526         if (miiphy_read(devname, addr, MII_ESTATUS, &exsr)) {
 527                 printf("PHY extended status read failed, assuming no "
 528                         "1000BASE-X\n");
 529                 return 0;
 530         }
 531         return 0 != (exsr & (ESTATUS_1000XF | ESTATUS_1000XH));
 532 #else
 533         return 0;
 534 #endif
 535 }
 536
 537 #ifdef CONFIG_SYS_FAULT_ECHO_LINK_DOWN
 538 /*****************************************************************************
 539  *
 540  * Determine link status
 541  */
 542 int miiphy_link(const char *devname, unsigned char addr)
 543 {
 544         unsigned short reg;
 545
 546         /* dummy read; needed to latch some phys */
 547         (void)miiphy_read(devname, addr, MII_BMSR, &reg);
 548         if (miiphy_read(devname, addr, MII_BMSR, &reg)) {
 549                 puts("MII_BMSR read failed, assuming no link\n");
 550                 return 0;
 551         }
 552
 553         /* Determine if a link is active */
 554         if ((reg & BMSR_LSTATUS) != 0) {
 555                 return 1;
 556         } else {
 557                 return 0;
 558         }
 559 }
 560 #endif