drivers/net/ep93xx_eth.c

   1 /*
   2  * Cirrus Logic EP93xx ethernet MAC / MII driver.
   3  *
   4  * Copyright (C) 2010, 2009
   5  * Matthias Kaehlcke <matthias@kaehlcke.net>
   6  *
   7  * Copyright (C) 2004, 2005
   8  * Cory T. Tusar, Videon Central, Inc., <ctusar@videon-central.com>
   9  *
  10  * Based on the original eth.[ch] Cirrus Logic EP93xx Rev D. Ethernet Driver,
  11  * which is
  12  *
  13  * (C) Copyright 2002 2003
  14  * Adam Bezanson, Network Audio Technologies, Inc.
  15  * <bezanson@netaudiotech.com>
  16  *
  17  * SPDX-License-Identifier:     GPL-2.0+
  18  */
  19
  20 #include <command.h>
  21 #include <common.h>
  22 #include <asm/arch/ep93xx.h>
  23 #include <asm/io.h>
  24 #include <malloc.h>
  25 #include <miiphy.h>
  26 #include <linux/types.h>
  27 #include "ep93xx_eth.h"
  28
  29 #define GET_PRIV(eth_dev)       ((struct ep93xx_priv *)(eth_dev)->priv)
  30 #define GET_REGS(eth_dev)       (GET_PRIV(eth_dev)->regs)
  31
  32 /* ep93xx_miiphy ops forward declarations */
  33 static int ep93xx_miiphy_read(struct mii_dev *bus, int addr, int devad,
  34                               int reg);
  35 static int ep93xx_miiphy_write(struct mii_dev *bus, int addr, int devad,
  36                                int reg, u16 value);
  37
  38 #if defined(EP93XX_MAC_DEBUG)
  39 /**
  40  * Dump ep93xx_mac values to the terminal.
  41  */
  42 static void dump_dev(struct eth_device *dev)
  43 {
  44         struct ep93xx_priv *priv = GET_PRIV(dev);
  45         int i;
  46
  47         printf("\ndump_dev()\n");
  48         printf("  rx_dq.base         %p\n", priv->rx_dq.base);
  49         printf("  rx_dq.current      %p\n", priv->rx_dq.current);
  50         printf("  rx_dq.end          %p\n", priv->rx_dq.end);
  51         printf("  rx_sq.base         %p\n", priv->rx_sq.base);
  52         printf("  rx_sq.current      %p\n", priv->rx_sq.current);
  53         printf("  rx_sq.end          %p\n", priv->rx_sq.end);
  54
  55         for (i = 0; i < NUMRXDESC; i++)
  56                 printf("  rx_buffer[%2.d]      %p\n", i, net_rx_packets[i]);
  57
  58         printf("  tx_dq.base         %p\n", priv->tx_dq.base);
  59         printf("  tx_dq.current      %p\n", priv->tx_dq.current);
  60         printf("  tx_dq.end          %p\n", priv->tx_dq.end);
  61         printf("  tx_sq.base         %p\n", priv->tx_sq.base);
  62         printf("  tx_sq.current      %p\n", priv->tx_sq.current);
  63         printf("  tx_sq.end          %p\n", priv->tx_sq.end);
  64 }
  65
  66 /**
  67  * Dump all RX status queue entries to the terminal.
  68  */
  69 static void dump_rx_status_queue(struct eth_device *dev)
  70 {
  71         struct ep93xx_priv *priv = GET_PRIV(dev);
  72         int i;
  73
  74         printf("\ndump_rx_status_queue()\n");
  75         printf("  descriptor address     word1           word2\n");
  76         for (i = 0; i < NUMRXDESC; i++) {
  77                 printf("  [ %p ]             %08X        %08X\n",
  78                         priv->rx_sq.base + i,
  79                         (priv->rx_sq.base + i)->word1,
  80                         (priv->rx_sq.base + i)->word2);
  81         }
  82 }
  83
  84 /**
  85  * Dump all RX descriptor queue entries to the terminal.
  86  */
  87 static void dump_rx_descriptor_queue(struct eth_device *dev)
  88 {
  89         struct ep93xx_priv *priv = GET_PRIV(dev);
  90         int i;
  91
  92         printf("\ndump_rx_descriptor_queue()\n");
  93         printf("  descriptor address     word1           word2\n");
  94         for (i = 0; i < NUMRXDESC; i++) {
  95                 printf("  [ %p ]             %08X        %08X\n",
  96                         priv->rx_dq.base + i,
  97                         (priv->rx_dq.base + i)->word1,
  98                         (priv->rx_dq.base + i)->word2);
  99         }
 100 }
 101
 102 /**
 103  * Dump all TX descriptor queue entries to the terminal.
 104  */
 105 static void dump_tx_descriptor_queue(struct eth_device *dev)
 106 {
 107         struct ep93xx_priv *priv = GET_PRIV(dev);
 108         int i;
 109
 110         printf("\ndump_tx_descriptor_queue()\n");
 111         printf("  descriptor address     word1           word2\n");
 112         for (i = 0; i < NUMTXDESC; i++) {
 113                 printf("  [ %p ]             %08X        %08X\n",
 114                         priv->tx_dq.base + i,
 115                         (priv->tx_dq.base + i)->word1,
 116                         (priv->tx_dq.base + i)->word2);
 117         }
 118 }
 119
 120 /**
 121  * Dump all TX status queue entries to the terminal.
 122  */
 123 static void dump_tx_status_queue(struct eth_device *dev)
 124 {
 125         struct ep93xx_priv *priv = GET_PRIV(dev);
 126         int i;
 127
 128         printf("\ndump_tx_status_queue()\n");
 129         printf("  descriptor address     word1\n");
 130         for (i = 0; i < NUMTXDESC; i++) {
 131                 printf("  [ %p ]             %08X\n",
 132                         priv->rx_sq.base + i,
 133                         (priv->rx_sq.base + i)->word1);
 134         }
 135 }
 136 #else
 137 #define dump_dev(x)
 138 #define dump_rx_descriptor_queue(x)
 139 #define dump_rx_status_queue(x)
 140 #define dump_tx_descriptor_queue(x)
 141 #define dump_tx_status_queue(x)
 142 #endif  /* defined(EP93XX_MAC_DEBUG) */
 143
 144 /**
 145  * Reset the EP93xx MAC by twiddling the soft reset bit and spinning until
 146  * it's cleared.
 147  */
 148 static void ep93xx_mac_reset(struct eth_device *dev)
 149 {
 150         struct mac_regs *mac = GET_REGS(dev);
 151         uint32_t value;
 152
 153         debug("+ep93xx_mac_reset");
 154
 155         value = readl(&mac->selfctl);
 156         value |= SELFCTL_RESET;
 157         writel(value, &mac->selfctl);
 158
 159         while (readl(&mac->selfctl) & SELFCTL_RESET)
 160                 ; /* noop */
 161
 162         debug("-ep93xx_mac_reset");
 163 }
 164
 165 /* Eth device open */
 166 static int ep93xx_eth_open(struct eth_device *dev, bd_t *bd)
 167 {
 168         struct ep93xx_priv *priv = GET_PRIV(dev);
 169         struct mac_regs *mac = GET_REGS(dev);
 170         uchar *mac_addr = dev->enetaddr;
 171         int i;
 172
 173         debug("+ep93xx_eth_open");
 174
 175         /* Reset the MAC */
 176         ep93xx_mac_reset(dev);
 177
 178         /* Reset the descriptor queues' current and end address values */
 179         priv->tx_dq.current = priv->tx_dq.base;
 180         priv->tx_dq.end = (priv->tx_dq.base + NUMTXDESC);
 181
 182         priv->tx_sq.current = priv->tx_sq.base;
 183         priv->tx_sq.end = (priv->tx_sq.base + NUMTXDESC);
 184
 185         priv->rx_dq.current = priv->rx_dq.base;
 186         priv->rx_dq.end = (priv->rx_dq.base + NUMRXDESC);
 187
 188         priv->rx_sq.current = priv->rx_sq.base;
 189         priv->rx_sq.end = (priv->rx_sq.base + NUMRXDESC);
 190
 191         /*
 192          * Set the transmit descriptor and status queues' base address,
 193          * current address, and length registers.  Set the maximum frame
 194          * length and threshold. Enable the transmit descriptor processor.
 195          */
 196         writel((uint32_t)priv->tx_dq.base, &mac->txdq.badd);
 197         writel((uint32_t)priv->tx_dq.base, &mac->txdq.curadd);
 198         writel(sizeof(struct tx_descriptor) * NUMTXDESC, &mac->txdq.blen);
 199
 200         writel((uint32_t)priv->tx_sq.base, &mac->txstsq.badd);
 201         writel((uint32_t)priv->tx_sq.base, &mac->txstsq.curadd);
 202         writel(sizeof(struct tx_status) * NUMTXDESC, &mac->txstsq.blen);
 203
 204         writel(0x00040000, &mac->txdthrshld);
 205         writel(0x00040000, &mac->txststhrshld);
 206
 207         writel((TXSTARTMAX << 0) | (PKTSIZE_ALIGN << 16), &mac->maxfrmlen);
 208         writel(BMCTL_TXEN, &mac->bmctl);
 209
 210         /*
 211          * Set the receive descriptor and status queues' base address,
 212          * current address, and length registers.  Enable the receive
 213          * descriptor processor.
 214          */
 215         writel((uint32_t)priv->rx_dq.base, &mac->rxdq.badd);
 216         writel((uint32_t)priv->rx_dq.base, &mac->rxdq.curadd);
 217         writel(sizeof(struct rx_descriptor) * NUMRXDESC, &mac->rxdq.blen);
 218
 219         writel((uint32_t)priv->rx_sq.base, &mac->rxstsq.badd);
 220         writel((uint32_t)priv->rx_sq.base, &mac->rxstsq.curadd);
 221         writel(sizeof(struct rx_status) * NUMRXDESC, &mac->rxstsq.blen);
 222
 223         writel(0x00040000, &mac->rxdthrshld);
 224
 225         writel(BMCTL_RXEN, &mac->bmctl);
 226
 227         writel(0x00040000, &mac->rxststhrshld);
 228
 229         /* Wait until the receive descriptor processor is active */
 230         while (!(readl(&mac->bmsts) & BMSTS_RXACT))
 231                 ; /* noop */
 232
 233         /*
 234          * Initialize the RX descriptor queue. Clear the TX descriptor queue.
 235          * Clear the RX and TX status queues. Enqueue the RX descriptor and
 236          * status entries to the MAC.
 237          */
 238         for (i = 0; i < NUMRXDESC; i++) {
 239                 /* set buffer address */
 240                 (priv->rx_dq.base + i)->word1 = (uint32_t)net_rx_packets[i];
 241
 242                 /* set buffer length, clear buffer index and NSOF */
 243                 (priv->rx_dq.base + i)->word2 = PKTSIZE_ALIGN;
 244         }
 245
 246         memset(priv->tx_dq.base, 0,
 247                 (sizeof(struct tx_descriptor) * NUMTXDESC));
 248         memset(priv->rx_sq.base, 0,
 249                 (sizeof(struct rx_status) * NUMRXDESC));
 250         memset(priv->tx_sq.base, 0,
 251                 (sizeof(struct tx_status) * NUMTXDESC));
 252
 253         writel(NUMRXDESC, &mac->rxdqenq);
 254         writel(NUMRXDESC, &mac->rxstsqenq);
 255
 256         /* Set the primary MAC address */
 257         writel(AFP_IAPRIMARY, &mac->afp);
 258         writel(mac_addr[0] | (mac_addr[1] << 8) |
 259                 (mac_addr[2] << 16) | (mac_addr[3] << 24),
 260                 &mac->indad);
 261         writel(mac_addr[4] | (mac_addr[5] << 8), &mac->indad_upper);
 262
 263         /* Turn on RX and TX */
 264         writel(RXCTL_IA0 | RXCTL_BA | RXCTL_SRXON |
 265                 RXCTL_RCRCA | RXCTL_MA, &mac->rxctl);
 266         writel(TXCTL_STXON, &mac->txctl);
 267
 268         /* Dump data structures if we're debugging */
 269         dump_dev(dev);
 270         dump_rx_descriptor_queue(dev);
 271         dump_rx_status_queue(dev);
 272         dump_tx_descriptor_queue(dev);
 273         dump_tx_status_queue(dev);
 274
 275         debug("-ep93xx_eth_open");
 276
 277         return 1;
 278 }
 279
 280 /**
 281  * Halt EP93xx MAC transmit and receive by clearing the TxCTL and RxCTL
 282  * registers.
 283  */
 284 static void ep93xx_eth_close(struct eth_device *dev)
 285 {
 286         struct mac_regs *mac = GET_REGS(dev);
 287
 288         debug("+ep93xx_eth_close");
 289
 290         writel(0x00000000, &mac->rxctl);
 291         writel(0x00000000, &mac->txctl);
 292
 293         debug("-ep93xx_eth_close");
 294 }
 295
 296 /**
 297  * Copy a frame of data from the MAC into the protocol layer for further
 298  * processing.
 299  */
 300 static int ep93xx_eth_rcv_packet(struct eth_device *dev)
 301 {
 302         struct mac_regs *mac = GET_REGS(dev);
 303         struct ep93xx_priv *priv = GET_PRIV(dev);
 304         int len = -1;
 305
 306         debug("+ep93xx_eth_rcv_packet");
 307
 308         if (RX_STATUS_RFP(priv->rx_sq.current)) {
 309                 if (RX_STATUS_RWE(priv->rx_sq.current)) {
 310                         /*
 311                          * We have a good frame. Extract the frame's length
 312                          * from the current rx_status_queue entry, and copy
 313                          * the frame's data into net_rx_packets[] of the
 314                          * protocol stack. We track the total number of
 315                          * bytes in the frame (nbytes_frame) which will be
 316                          * used when we pass the data off to the protocol
 317                          * layer via net_process_received_packet().
 318                          */
 319                         len = RX_STATUS_FRAME_LEN(priv->rx_sq.current);
 320
 321                         net_process_received_packet(
 322                                 (uchar *)priv->rx_dq.current->word1, len);
 323
 324                         debug("reporting %d bytes...\n", len);
 325                 } else {
 326                         /* Do we have an erroneous packet? */
 327                         pr_err("packet rx error, status %08X %08X",
 328                                 priv->rx_sq.current->word1,
 329                                 priv->rx_sq.current->word2);
 330                         dump_rx_descriptor_queue(dev);
 331                         dump_rx_status_queue(dev);
 332                 }
 333
 334                 /*
 335                  * Clear the associated status queue entry, and
 336                  * increment our current pointers to the next RX
 337                  * descriptor and status queue entries (making sure
 338                  * we wrap properly).
 339                  */
 340                 memset((void *)priv->rx_sq.current, 0,
 341                         sizeof(struct rx_status));
 342
 343                 priv->rx_sq.current++;
 344                 if (priv->rx_sq.current >= priv->rx_sq.end)
 345                         priv->rx_sq.current = priv->rx_sq.base;
 346
 347                 priv->rx_dq.current++;
 348                 if (priv->rx_dq.current >= priv->rx_dq.end)
 349                         priv->rx_dq.current = priv->rx_dq.base;
 350
 351                 /*
 352                  * Finally, return the RX descriptor and status entries
 353                  * back to the MAC engine, and loop again, checking for
 354                  * more descriptors to process.
 355                  */
 356                 writel(1, &mac->rxdqenq);
 357                 writel(1, &mac->rxstsqenq);
 358         } else {
 359                 len = 0;
 360         }
 361
 362         debug("-ep93xx_eth_rcv_packet %d", len);
 363         return len;
 364 }
 365
 366 /**
 367  * Send a block of data via ethernet.
 368  */
 369 static int ep93xx_eth_send_packet(struct eth_device *dev,
 370                                 void * const packet, int const length)
 371 {
 372         struct mac_regs *mac = GET_REGS(dev);
 373         struct ep93xx_priv *priv = GET_PRIV(dev);
 374         int ret = -1;
 375
 376         debug("+ep93xx_eth_send_packet");
 377
 378         /* Parameter check */
 379         BUG_ON(packet == NULL);
 380
 381         /*
 382          * Initialize the TX descriptor queue with the new packet's info.
 383          * Clear the associated status queue entry. Enqueue the packet
 384          * to the MAC for transmission.
 385          */
 386
 387         /* set buffer address */
 388         priv->tx_dq.current->word1 = (uint32_t)packet;
 389
 390         /* set buffer length and EOF bit */
 391         priv->tx_dq.current->word2 = length | TX_DESC_EOF;
 392
 393         /* clear tx status */
 394         priv->tx_sq.current->word1 = 0;
 395
 396         /* enqueue the TX descriptor */
 397         writel(1, &mac->txdqenq);
 398
 399         /* wait for the frame to become processed */
 400         while (!TX_STATUS_TXFP(priv->tx_sq.current))
 401                 ; /* noop */
 402
 403         if (!TX_STATUS_TXWE(priv->tx_sq.current)) {
 404                 pr_err("packet tx error, status %08X",
 405                         priv->tx_sq.current->word1);
 406                 dump_tx_descriptor_queue(dev);
 407                 dump_tx_status_queue(dev);
 408
 409                 /* TODO: Add better error handling? */
 410                 goto eth_send_out;
 411         }
 412
 413         ret = 0;
 414         /* Fall through */
 415
 416 eth_send_out:
 417         debug("-ep93xx_eth_send_packet %d", ret);
 418         return ret;
 419 }
 420
 421 #if defined(CONFIG_MII)
 422 int ep93xx_miiphy_initialize(bd_t * const bd)
 423 {
 424         int retval;
 425         struct mii_dev *mdiodev = mdio_alloc();
 426         if (!mdiodev)
 427                 return -ENOMEM;
 428         strncpy(mdiodev->name, "ep93xx_eth0", MDIO_NAME_LEN);
 429         mdiodev->read = ep93xx_miiphy_read;
 430         mdiodev->write = ep93xx_miiphy_write;
 431
 432         retval = mdio_register(mdiodev);
 433         if (retval < 0)
 434                 return retval;
 435         return 0;
 436 }
 437 #endif
 438
 439 /**
 440  * Initialize the EP93xx MAC.  The MAC hardware is reset.  Buffers are
 441  * allocated, if necessary, for the TX and RX descriptor and status queues,
 442  * as well as for received packets.  The EP93XX MAC hardware is initialized.
 443  * Transmit and receive operations are enabled.
 444  */
 445 int ep93xx_eth_initialize(u8 dev_num, int base_addr)
 446 {
 447         int ret = -1;
 448         struct eth_device *dev;
 449         struct ep93xx_priv *priv;
 450
 451         debug("+ep93xx_eth_initialize");
 452
 453         priv = malloc(sizeof(*priv));
 454         if (!priv) {
 455                 pr_err("malloc() failed");
 456                 goto eth_init_failed_0;
 457         }
 458         memset(priv, 0, sizeof(*priv));
 459
 460         priv->regs = (struct mac_regs *)base_addr;
 461
 462         priv->tx_dq.base = calloc(NUMTXDESC,
 463                                 sizeof(struct tx_descriptor));
 464         if (priv->tx_dq.base == NULL) {
 465                 pr_err("calloc() failed");
 466                 goto eth_init_failed_1;
 467         }
 468
 469         priv->tx_sq.base = calloc(NUMTXDESC,
 470                                 sizeof(struct tx_status));
 471         if (priv->tx_sq.base == NULL) {
 472                 pr_err("calloc() failed");
 473                 goto eth_init_failed_2;
 474         }
 475
 476         priv->rx_dq.base = calloc(NUMRXDESC,
 477                                 sizeof(struct rx_descriptor));
 478         if (priv->rx_dq.base == NULL) {
 479                 pr_err("calloc() failed");
 480                 goto eth_init_failed_3;
 481         }
 482
 483         priv->rx_sq.base = calloc(NUMRXDESC,
 484                                 sizeof(struct rx_status));
 485         if (priv->rx_sq.base == NULL) {
 486                 pr_err("calloc() failed");
 487                 goto eth_init_failed_4;
 488         }
 489
 490         dev = malloc(sizeof *dev);
 491         if (dev == NULL) {
 492                 pr_err("malloc() failed");
 493                 goto eth_init_failed_5;
 494         }
 495         memset(dev, 0, sizeof *dev);
 496
 497         dev->iobase = base_addr;
 498         dev->priv = priv;
 499         dev->init = ep93xx_eth_open;
 500         dev->halt = ep93xx_eth_close;
 501         dev->send = ep93xx_eth_send_packet;
 502         dev->recv = ep93xx_eth_rcv_packet;
 503
 504         sprintf(dev->name, "ep93xx_eth-%hu", dev_num);
 505
 506         eth_register(dev);
 507
 508         /* Done! */
 509         ret = 1;
 510         goto eth_init_done;
 511
 512 eth_init_failed_5:
 513         free(priv->rx_sq.base);
 514         /* Fall through */
 515
 516 eth_init_failed_4:
 517         free(priv->rx_dq.base);
 518         /* Fall through */
 519
 520 eth_init_failed_3:
 521         free(priv->tx_sq.base);
 522         /* Fall through */
 523
 524 eth_init_failed_2:
 525         free(priv->tx_dq.base);
 526         /* Fall through */
 527
 528 eth_init_failed_1:
 529         free(priv);
 530         /* Fall through */
 531
 532 eth_init_failed_0:
 533         /* Fall through */
 534
 535 eth_init_done:
 536         debug("-ep93xx_eth_initialize %d", ret);
 537         return ret;
 538 }
 539
 540 #if defined(CONFIG_MII)
 541
 542 /**
 543  * Maximum MII address we support
 544  */
 545 #define MII_ADDRESS_MAX                 31
 546
 547 /**
 548  * Maximum MII register address we support
 549  */
 550 #define MII_REGISTER_MAX                31
 551
 552 /**
 553  * Read a 16-bit value from an MII register.
 554  */
 555 static int ep93xx_miiphy_read(struct mii_dev *bus, int addr, int devad,
 556                               int reg)
 557 {
 558         unsigned short value = 0;
 559         struct mac_regs *mac = (struct mac_regs *)MAC_BASE;
 560         int ret = -1;
 561         uint32_t self_ctl;
 562
 563         debug("+ep93xx_miiphy_read");
 564
 565         /* Parameter checks */
 566         BUG_ON(bus->name == NULL);
 567         BUG_ON(addr > MII_ADDRESS_MAX);
 568         BUG_ON(reg > MII_REGISTER_MAX);
 569
 570         /*
 571          * Save the current SelfCTL register value.  Set MAC to suppress
 572          * preamble bits.  Wait for any previous MII command to complete
 573          * before issuing the new command.
 574          */
 575         self_ctl = readl(&mac->selfctl);
 576 #if defined(CONFIG_MII_SUPPRESS_PREAMBLE)
 577         writel(self_ctl & ~(1 << 8), &mac->selfctl);
 578 #endif  /* defined(CONFIG_MII_SUPPRESS_PREAMBLE) */
 579
 580         while (readl(&mac->miists) & MIISTS_BUSY)
 581                 ; /* noop */
 582
 583         /*
 584          * Issue the MII 'read' command.  Wait for the command to complete.
 585          * Read the MII data value.
 586          */
 587         writel(MIICMD_OPCODE_READ | ((uint32_t)addr << 5) | (uint32_t)reg,
 588                 &mac->miicmd);
 589         while (readl(&mac->miists) & MIISTS_BUSY)
 590                 ; /* noop */
 591
 592         value = (unsigned short)readl(&mac->miidata);
 593
 594         /* Restore the saved SelfCTL value and return. */
 595         writel(self_ctl, &mac->selfctl);
 596
 597         ret = 0;
 598         /* Fall through */
 599
 600         debug("-ep93xx_miiphy_read");
 601         if (ret < 0)
 602                 return ret;
 603         return value;
 604 }
 605
 606 /**
 607  * Write a 16-bit value to an MII register.
 608  */
 609 static int ep93xx_miiphy_write(struct mii_dev *bus, int addr, int devad,
 610                                int reg, u16 value)
 611 {
 612         struct mac_regs *mac = (struct mac_regs *)MAC_BASE;
 613         int ret = -1;
 614         uint32_t self_ctl;
 615
 616         debug("+ep93xx_miiphy_write");
 617
 618         /* Parameter checks */
 619         BUG_ON(bus->name == NULL);
 620         BUG_ON(addr > MII_ADDRESS_MAX);
 621         BUG_ON(reg > MII_REGISTER_MAX);
 622
 623         /*
 624          * Save the current SelfCTL register value.  Set MAC to suppress
 625          * preamble bits.  Wait for any previous MII command to complete
 626          * before issuing the new command.
 627          */
 628         self_ctl = readl(&mac->selfctl);
 629 #if defined(CONFIG_MII_SUPPRESS_PREAMBLE)
 630         writel(self_ctl & ~(1 << 8), &mac->selfctl);
 631 #endif  /* defined(CONFIG_MII_SUPPRESS_PREAMBLE) */
 632
 633         while (readl(&mac->miists) & MIISTS_BUSY)
 634                 ; /* noop */
 635
 636         /* Issue the MII 'write' command.  Wait for the command to complete. */
 637         writel((uint32_t)value, &mac->miidata);
 638         writel(MIICMD_OPCODE_WRITE | ((uint32_t)addr << 5) | (uint32_t)reg,
 639                 &mac->miicmd);
 640         while (readl(&mac->miists) & MIISTS_BUSY)
 641                 ; /* noop */
 642
 643         /* Restore the saved SelfCTL value and return. */
 644         writel(self_ctl, &mac->selfctl);
 645
 646         ret = 0;
 647         /* Fall through */
 648
 649         debug("-ep93xx_miiphy_write");
 650         return ret;
 651 }
 652 #endif  /* defined(CONFIG_MII) */