drivers/net/dm9000x.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *   dm9000.c: Version 1.2 12/15/2003
   4  *
   5  *      A Davicom DM9000 ISA NIC fast Ethernet driver for Linux.
   6  *      Copyright (C) 1997  Sten Wang
   7  *
   8  *   (C)Copyright 1997-1998 DAVICOM Semiconductor,Inc. All Rights Reserved.
   9  *
  10  * V0.11        06/20/2001      REG_0A bit3=1, default enable BP with DA match
  11  *      06/22/2001      Support DM9801 progrmming
  12  *                      E3: R25 = ((R24 + NF) & 0x00ff) | 0xf000
  13  *                      E4: R25 = ((R24 + NF) & 0x00ff) | 0xc200
  14  *              R17 = (R17 & 0xfff0) | NF + 3
  15  *                      E5: R25 = ((R24 + NF - 3) & 0x00ff) | 0xc200
  16  *              R17 = (R17 & 0xfff0) | NF
  17  *
  18  * v1.00                        modify by simon 2001.9.5
  19  *                      change for kernel 2.4.x
  20  *
  21  * v1.1   11/09/2001    fix force mode bug
  22  *
  23  * v1.2   03/18/2003       Weilun Huang <weilun_huang@davicom.com.tw>:
  24  *                      Fixed phy reset.
  25  *                      Added tx/rx 32 bit mode.
  26  *                      Cleaned up for kernel merge.
  27  *
  28  * --------------------------------------
  29  *
  30  *        12/15/2003       Initial port to u-boot by
  31  *                      Sascha Hauer <saschahauer@web.de>
  32  *
  33  *        06/03/2008    Remy Bohmer <linux@bohmer.net>
  34  *                      - Fixed the driver to work with DM9000A.
  35  *                        (check on ISR receive status bit before reading the
  36  *                        FIFO as described in DM9000 programming guide and
  37  *                        application notes)
  38  *                      - Added autodetect of databus width.
  39  *                      - Made debug code compile again.
  40  *                      - Adapt eth_send such that it matches the DM9000*
  41  *                        application notes. Needed to make it work properly
  42  *                        for DM9000A.
  43  *                      - Adapted reset procedure to match DM9000 application
  44  *                        notes (i.e. double reset)
  45  *                      - some minor code cleanups
  46  *                      These changes are tested with DM9000{A,EP,E} together
  47  *                      with a 200MHz Atmel AT91SAM9261 core
  48  *
  49  * TODO: external MII is not functional, only internal at the moment.
  50  */
  51
  52 #include <common.h>
  53 #include <command.h>
  54 #include <dm.h>
  55 #include <malloc.h>
  56 #include <net.h>
  57 #include <asm/io.h>
  58 #include <linux/delay.h>
  59
  60 #include "dm9000x.h"
  61
  62 /* Structure/enum declaration ------------------------------- */
  63 struct dm9000_priv {
  64         u32 runt_length_counter;        /* counter: RX length < 64byte */
  65         u32 long_length_counter;        /* counter: RX length > 1514byte */
  66         u32 reset_counter;      /* counter: RESET */
  67         u32 reset_tx_timeout;   /* RESET caused by TX Timeout */
  68         u32 reset_rx_status;    /* RESET caused by RX Statsus wrong */
  69         u16 tx_pkt_cnt;
  70         u16 queue_start_addr;
  71         u16 dbug_cnt;
  72         u8 phy_addr;
  73         u8 device_wait_reset;   /* device state */
  74         unsigned char srom[128];
  75         void (*outblk)(struct dm9000_priv *db, void *data_ptr, int count);
  76         void (*inblk)(struct dm9000_priv *db, void *data_ptr, int count);
  77         void (*rx_status)(struct dm9000_priv *db, u16 *rxstatus, u16 *rxlen);
  78 #ifndef CONFIG_DM_ETH
  79         struct eth_device dev;
  80 #endif
  81         void __iomem *base_io;
  82         void __iomem *base_data;
  83 };
  84
  85 /* DM9000 network board routine ---------------------------- */
  86 #ifndef CONFIG_DM9000_BYTE_SWAPPED
  87 #define dm9000_outb(d, r) writeb((d), (r))
  88 #define dm9000_outw(d, r) writew((d), (r))
  89 #define dm9000_outl(d, r) writel((d), (r))
  90 #define dm9000_inb(r) readb(r)
  91 #define dm9000_inw(r) readw(r)
  92 #define dm9000_inl(r) readl(r)
  93 #else
  94 #define dm9000_outb(d, r) __raw_writeb(d, r)
  95 #define dm9000_outw(d, r) __raw_writew(d, r)
  96 #define dm9000_outl(d, r) __raw_writel(d, r)
  97 #define dm9000_inb(r) __raw_readb(r)
  98 #define dm9000_inw(r) __raw_readw(r)
  99 #define dm9000_inl(r) __raw_readl(r)
 100 #endif
 101
 102 #ifdef DEBUG
 103 static void dm9000_dump_packet(const char *func, u8 *packet, int length)
 104 {
 105         int i;
 106
 107         printf("%s: length: %d\n", func, length);
 108
 109         for (i = 0; i < length; i++) {
 110                 if (i % 8 == 0)
 111                         printf("\n%s: %02x: ", func, i);
 112                 printf("%02x ", packet[i]);
 113         }
 114
 115         printf("\n");
 116 }
 117 #else
 118 static void dm9000_dump_packet(const char *func, u8 *packet, int length) {}
 119 #endif
 120
 121 static void dm9000_outblk_8bit(struct dm9000_priv *db, void *data_ptr, int count)
 122 {
 123         int i;
 124
 125         for (i = 0; i < count; i++)
 126                 dm9000_outb((((u8 *)data_ptr)[i] & 0xff), db->base_data);
 127 }
 128
 129 static void dm9000_outblk_16bit(struct dm9000_priv *db, void *data_ptr, int count)
 130 {
 131         int i;
 132         u32 tmplen = (count + 1) / 2;
 133
 134         for (i = 0; i < tmplen; i++)
 135                 dm9000_outw(((u16 *)data_ptr)[i], db->base_data);
 136 }
 137
 138 static void dm9000_outblk_32bit(struct dm9000_priv *db, void *data_ptr, int count)
 139 {
 140         int i;
 141         u32 tmplen = (count + 3) / 4;
 142
 143         for (i = 0; i < tmplen; i++)
 144                 dm9000_outl(((u32 *)data_ptr)[i], db->base_data);
 145 }
 146
 147 static void dm9000_inblk_8bit(struct dm9000_priv *db, void *data_ptr, int count)
 148 {
 149         int i;
 150
 151         for (i = 0; i < count; i++)
 152                 ((u8 *)data_ptr)[i] = dm9000_inb(db->base_data);
 153 }
 154
 155 static void dm9000_inblk_16bit(struct dm9000_priv *db, void *data_ptr, int count)
 156 {
 157         int i;
 158         u32 tmplen = (count + 1) / 2;
 159
 160         for (i = 0; i < tmplen; i++)
 161                 ((u16 *)data_ptr)[i] = dm9000_inw(db->base_data);
 162 }
 163
 164 static void dm9000_inblk_32bit(struct dm9000_priv *db, void *data_ptr, int count)
 165 {
 166         int i;
 167         u32 tmplen = (count + 3) / 4;
 168
 169         for (i = 0; i < tmplen; i++)
 170                 ((u32 *)data_ptr)[i] = dm9000_inl(db->base_data);
 171 }
 172
 173 static void dm9000_rx_status_32bit(struct dm9000_priv *db, u16 *rxstatus, u16 *rxlen)
 174 {
 175         u32 tmpdata;
 176
 177         dm9000_outb(DM9000_MRCMD, db->base_io);
 178
 179         tmpdata = dm9000_inl(db->base_data);
 180         *rxstatus = __le16_to_cpu(tmpdata);
 181         *rxlen = __le16_to_cpu(tmpdata >> 16);
 182 }
 183
 184 static void dm9000_rx_status_16bit(struct dm9000_priv *db, u16 *rxstatus, u16 *rxlen)
 185 {
 186         dm9000_outb(DM9000_MRCMD, db->base_io);
 187
 188         *rxstatus = __le16_to_cpu(dm9000_inw(db->base_data));
 189         *rxlen = __le16_to_cpu(dm9000_inw(db->base_data));
 190 }
 191
 192 static void dm9000_rx_status_8bit(struct dm9000_priv *db, u16 *rxstatus, u16 *rxlen)
 193 {
 194         dm9000_outb(DM9000_MRCMD, db->base_io);
 195
 196         *rxstatus =
 197             __le16_to_cpu(dm9000_inb(db->base_data) +
 198                           (dm9000_inb(db->base_data) << 8));
 199         *rxlen =
 200             __le16_to_cpu(dm9000_inb(db->base_data) +
 201                           (dm9000_inb(db->base_data) << 8));
 202 }
 203
 204 /*
 205  *  Read a byte from I/O port
 206  */
 207 static u8 dm9000_ior(struct dm9000_priv *db, int reg)
 208 {
 209         dm9000_outb(reg, db->base_io);
 210         return dm9000_inb(db->base_data);
 211 }
 212
 213 /*
 214  *  Write a byte to I/O port
 215  */
 216 static void dm9000_iow(struct dm9000_priv *db, int reg, u8 value)
 217 {
 218         dm9000_outb(reg, db->base_io);
 219         dm9000_outb(value, db->base_data);
 220 }
 221
 222 /*
 223  *  Read a word from phyxcer
 224  */
 225 static u16 dm9000_phy_read(struct dm9000_priv *db, int reg)
 226 {
 227         u16 val;
 228
 229         /* Fill the phyxcer register into REG_0C */
 230         dm9000_iow(db, DM9000_EPAR, DM9000_PHY | reg);
 231         dm9000_iow(db, DM9000_EPCR, 0xc);       /* Issue phyxcer read command */
 232         udelay(100);                    /* Wait read complete */
 233         dm9000_iow(db, DM9000_EPCR, 0x0);       /* Clear phyxcer read command */
 234         val = (dm9000_ior(db, DM9000_EPDRH) << 8) |
 235               dm9000_ior(db, DM9000_EPDRL);
 236
 237         /* The read data keeps on REG_0D & REG_0E */
 238         debug("%s(0x%x): 0x%x\n", __func__, reg, val);
 239         return val;
 240 }
 241
 242 /*
 243  *  Write a word to phyxcer
 244  */
 245 static void dm9000_phy_write(struct dm9000_priv *db, int reg, u16 value)
 246 {
 247         /* Fill the phyxcer register into REG_0C */
 248         dm9000_iow(db, DM9000_EPAR, DM9000_PHY | reg);
 249
 250         /* Fill the written data into REG_0D & REG_0E */
 251         dm9000_iow(db, DM9000_EPDRL, (value & 0xff));
 252         dm9000_iow(db, DM9000_EPDRH, ((value >> 8) & 0xff));
 253         dm9000_iow(db, DM9000_EPCR, 0xa);       /* Issue phyxcer write command */
 254         udelay(500);                    /* Wait write complete */
 255         dm9000_iow(db, DM9000_EPCR, 0x0);       /* Clear phyxcer write command */
 256         debug("%s(reg:0x%x, value:0x%x)\n", __func__, reg, value);
 257 }
 258
 259 /*
 260  * Search DM9000 board, allocate space and register it
 261  */
 262 static int dm9000_probe(struct dm9000_priv *db)
 263 {
 264         u32 id_val;
 265
 266         id_val = dm9000_ior(db, DM9000_VIDL);
 267         id_val |= dm9000_ior(db, DM9000_VIDH) << 8;
 268         id_val |= dm9000_ior(db, DM9000_PIDL) << 16;
 269         id_val |= dm9000_ior(db, DM9000_PIDH) << 24;
 270         if (id_val != DM9000_ID) {
 271                 printf("dm9000 not found at 0x%p id: 0x%08x\n",
 272                        db->base_io, id_val);
 273                 return -1;
 274         }
 275
 276         printf("dm9000 i/o: 0x%p, id: 0x%x\n", db->base_io, id_val);
 277         return 0;
 278 }
 279
 280 /* General Purpose dm9000 reset routine */
 281 static void dm9000_reset(struct dm9000_priv *db)
 282 {
 283         debug("resetting DM9000\n");
 284
 285         /*
 286          * Reset DM9000,
 287          * see DM9000 Application Notes V1.22 Jun 11, 2004 page 29
 288          */
 289
 290         /* DEBUG: Make all GPIO0 outputs, all others inputs */
 291         dm9000_iow(db, DM9000_GPCR, GPCR_GPIO0_OUT);
 292         /* Step 1: Power internal PHY by writing 0 to GPIO0 pin */
 293         dm9000_iow(db, DM9000_GPR, 0);
 294         /* Step 2: Software reset */
 295         dm9000_iow(db, DM9000_NCR, (NCR_LBK_INT_MAC | NCR_RST));
 296
 297         do {
 298                 debug("resetting the DM9000, 1st reset\n");
 299                 udelay(25); /* Wait at least 20 us */
 300         } while (dm9000_ior(db, DM9000_NCR) & 1);
 301
 302         dm9000_iow(db, DM9000_NCR, 0);
 303         dm9000_iow(db, DM9000_NCR, (NCR_LBK_INT_MAC | NCR_RST)); /* Issue a second reset */
 304
 305         do {
 306                 debug("resetting the DM9000, 2nd reset\n");
 307                 udelay(25); /* Wait at least 20 us */
 308         } while (dm9000_ior(db, DM9000_NCR) & 1);
 309
 310         /* Check whether the ethernet controller is present */
 311         if ((dm9000_ior(db, DM9000_PIDL) != 0x0) ||
 312             (dm9000_ior(db, DM9000_PIDH) != 0x90))
 313                 printf("ERROR: resetting DM9000 -> not responding\n");
 314 }
 315
 316 /* Initialize dm9000 board */
 317 static int dm9000_init_common(struct dm9000_priv *db, u8 enetaddr[6])
 318 {
 319         int i, oft, lnk;
 320         u8 io_mode;
 321
 322         /* RESET device */
 323         dm9000_reset(db);
 324
 325         if (dm9000_probe(db) < 0)
 326                 return -1;
 327
 328         /* Auto-detect 8/16/32 bit mode, ISR Bit 6+7 indicate bus width */
 329         io_mode = dm9000_ior(db, DM9000_ISR) >> 6;
 330
 331         switch (io_mode) {
 332         case 0x0:  /* 16-bit mode */
 333                 printf("DM9000: running in 16 bit mode\n");
 334                 db->outblk    = dm9000_outblk_16bit;
 335                 db->inblk     = dm9000_inblk_16bit;
 336                 db->rx_status = dm9000_rx_status_16bit;
 337                 break;
 338         case 0x01:  /* 32-bit mode */
 339                 printf("DM9000: running in 32 bit mode\n");
 340                 db->outblk    = dm9000_outblk_32bit;
 341                 db->inblk     = dm9000_inblk_32bit;
 342                 db->rx_status = dm9000_rx_status_32bit;
 343                 break;
 344         case 0x02: /* 8 bit mode */
 345                 printf("DM9000: running in 8 bit mode\n");
 346                 db->outblk    = dm9000_outblk_8bit;
 347                 db->inblk     = dm9000_inblk_8bit;
 348                 db->rx_status = dm9000_rx_status_8bit;
 349                 break;
 350         default:
 351                 /* Assume 8 bit mode, will probably not work anyway */
 352                 printf("DM9000: Undefined IO-mode:0x%x\n", io_mode);
 353                 db->outblk    = dm9000_outblk_8bit;
 354                 db->inblk     = dm9000_inblk_8bit;
 355                 db->rx_status = dm9000_rx_status_8bit;
 356                 break;
 357         }
 358
 359         /* Program operating register, only internal phy supported */
 360         dm9000_iow(db, DM9000_NCR, 0x0);
 361         /* TX Polling clear */
 362         dm9000_iow(db, DM9000_TCR, 0);
 363         /* Less 3Kb, 200us */
 364         dm9000_iow(db, DM9000_BPTR, BPTR_BPHW(3) | BPTR_JPT_600US);
 365         /* Flow Control : High/Low Water */
 366         dm9000_iow(db, DM9000_FCTR, FCTR_HWOT(3) | FCTR_LWOT(8));
 367         /* SH FIXME: This looks strange! Flow Control */
 368         dm9000_iow(db, DM9000_FCR, 0x0);
 369         /* Special Mode */
 370         dm9000_iow(db, DM9000_SMCR, 0);
 371         /* clear TX status */
 372         dm9000_iow(db, DM9000_NSR, NSR_WAKEST | NSR_TX2END | NSR_TX1END);
 373         /* Clear interrupt status */
 374         dm9000_iow(db, DM9000_ISR, ISR_ROOS | ISR_ROS | ISR_PTS | ISR_PRS);
 375
 376         printf("MAC: %pM\n", enetaddr);
 377         if (!is_valid_ethaddr(enetaddr))
 378                 printf("WARNING: Bad MAC address (uninitialized EEPROM?)\n");
 379
 380         /* fill device MAC address registers */
 381         for (i = 0, oft = DM9000_PAR; i < 6; i++, oft++)
 382                 dm9000_iow(db, oft, enetaddr[i]);
 383         for (i = 0, oft = 0x16; i < 8; i++, oft++)
 384                 dm9000_iow(db, oft, 0xff);
 385
 386         /* read back mac, just to be sure */
 387         for (i = 0, oft = 0x10; i < 6; i++, oft++)
 388                 debug("%02x:", dm9000_ior(db, oft));
 389         debug("\n");
 390
 391         /* Activate DM9000 */
 392         /* RX enable */
 393         dm9000_iow(db, DM9000_RCR, RCR_DIS_LONG | RCR_DIS_CRC | RCR_RXEN);
 394         /* Enable TX/RX interrupt mask */
 395         dm9000_iow(db, DM9000_IMR, IMR_PAR);
 396
 397         i = 0;
 398         while (!(dm9000_phy_read(db, 1) & 0x20)) {      /* autonegation complete bit */
 399                 udelay(1000);
 400                 i++;
 401                 if (i == 10000) {
 402                         printf("could not establish link\n");
 403                         return 0;
 404                 }
 405         }
 406
 407         /* see what we've got */
 408         lnk = dm9000_phy_read(db, 17) >> 12;
 409         printf("operating at ");
 410         switch (lnk) {
 411         case 1:
 412                 printf("10M half duplex ");
 413                 break;
 414         case 2:
 415                 printf("10M full duplex ");
 416                 break;
 417         case 4:
 418                 printf("100M half duplex ");
 419                 break;
 420         case 8:
 421                 printf("100M full duplex ");
 422                 break;
 423         default:
 424                 printf("unknown: %d ", lnk);
 425                 break;
 426         }
 427         printf("mode\n");
 428         return 0;
 429 }
 430
 431 /*
 432  * Hardware start transmission.
 433  * Send a packet to media from the upper layer.
 434  */
 435 static int dm9000_send_common(struct dm9000_priv *db, void *packet, int length)
 436 {
 437         int tmo;
 438
 439         dm9000_dump_packet(__func__, packet, length);
 440
 441         dm9000_iow(db, DM9000_ISR, IMR_PTM); /* Clear Tx bit in ISR */
 442
 443         /* Move data to DM9000 TX RAM */
 444         dm9000_outb(DM9000_MWCMD, db->base_io); /* Prepare for TX-data */
 445
 446         /* push the data to the TX-fifo */
 447         db->outblk(db, packet, length);
 448
 449         /* Set TX length to DM9000 */
 450         dm9000_iow(db, DM9000_TXPLL, length & 0xff);
 451         dm9000_iow(db, DM9000_TXPLH, (length >> 8) & 0xff);
 452
 453         /* Issue TX polling command */
 454         dm9000_iow(db, DM9000_TCR, TCR_TXREQ); /* Cleared after TX complete */
 455
 456         /* wait for end of transmission */
 457         tmo = get_timer(0) + 5 * CONFIG_SYS_HZ;
 458         while (!(dm9000_ior(db, DM9000_NSR) & (NSR_TX1END | NSR_TX2END)) ||
 459                !(dm9000_ior(db, DM9000_ISR) & IMR_PTM)) {
 460                 if (get_timer(0) >= tmo) {
 461                         printf("transmission timeout\n");
 462                         break;
 463                 }
 464         }
 465         dm9000_iow(db, DM9000_ISR, IMR_PTM); /* Clear Tx bit in ISR */
 466
 467         debug("transmit done\n\n");
 468         return 0;
 469 }
 470
 471 /*
 472  * Stop the interface.
 473  * The interface is stopped when it is brought.
 474  */
 475 static void dm9000_halt_common(struct dm9000_priv *db)
 476 {
 477         /* RESET device */
 478         dm9000_phy_write(db, 0, 0x8000);        /* PHY RESET */
 479         dm9000_iow(db, DM9000_GPR, 0x01);       /* Power-Down PHY */
 480         dm9000_iow(db, DM9000_IMR, 0x80);       /* Disable all interrupt */
 481         dm9000_iow(db, DM9000_RCR, 0x00);       /* Disable RX */
 482 }
 483
 484 /*
 485  * Received a packet and pass to upper layer
 486  */
 487 static int dm9000_recv_common(struct dm9000_priv *db, uchar *rdptr)
 488 {
 489         u8 rxbyte;
 490         u16 rxstatus, rxlen = 0;
 491
 492         /*
 493          * Check packet ready or not, we must check
 494          * the ISR status first for DM9000A
 495          */
 496         if (!(dm9000_ior(db, DM9000_ISR) & 0x01)) /* Rx-ISR bit must be set. */
 497                 return 0;
 498
 499         dm9000_iow(db, DM9000_ISR, 0x01); /* clear PR status latched in bit 0 */
 500
 501         /* There is _at least_ 1 package in the fifo, read them all */
 502         dm9000_ior(db, DM9000_MRCMDX);  /* Dummy read */
 503
 504         /*
 505          * Get most updated data,
 506          * only look at bits 0:1, See application notes DM9000
 507          */
 508         rxbyte = dm9000_inb(db->base_data) & 0x03;
 509
 510         /* Status check: this byte must be 0 or 1 */
 511         if (rxbyte > DM9000_PKT_RDY) {
 512                 dm9000_iow(db, DM9000_RCR, 0x00);       /* Stop Device */
 513                 dm9000_iow(db, DM9000_ISR, 0x80);       /* Stop INT request */
 514                 printf("DM9000 error: status check fail: 0x%x\n",
 515                        rxbyte);
 516                 return -EINVAL;
 517         }
 518
 519         if (rxbyte != DM9000_PKT_RDY)
 520                 return 0; /* No packet received, ignore */
 521
 522         debug("receiving packet\n");
 523
 524         /* A packet ready now  & Get status/length */
 525         db->rx_status(db, &rxstatus, &rxlen);
 526
 527         debug("rx status: 0x%04x rx len: %d\n", rxstatus, rxlen);
 528
 529         /* Move data from DM9000 */
 530         /* Read received packet from RX SRAM */
 531         db->inblk(db, rdptr, rxlen);
 532
 533         if (rxstatus & 0xbf00 || rxlen < 0x40 || rxlen > DM9000_PKT_MAX) {
 534                 if (rxstatus & 0x100)
 535                         printf("rx fifo error\n");
 536                 if (rxstatus & 0x200)
 537                         printf("rx crc error\n");
 538                 if (rxstatus & 0x8000)
 539                         printf("rx length error\n");
 540                 if (rxlen > DM9000_PKT_MAX) {
 541                         printf("rx length too big\n");
 542                         dm9000_reset(db);
 543                 }
 544                 return -EINVAL;
 545         }
 546
 547         return rxlen;
 548 }
 549
 550 /*
 551  * Read a word data from SROM
 552  */
 553 #if !defined(CONFIG_DM9000_NO_SROM)
 554 static void dm9000_read_srom_word(struct dm9000_priv *db, int offset, u8 *to)
 555 {
 556         dm9000_iow(db, DM9000_EPAR, offset);
 557         dm9000_iow(db, DM9000_EPCR, 0x4);
 558         mdelay(8);
 559         dm9000_iow(db, DM9000_EPCR, 0x0);
 560         to[0] = dm9000_ior(db, DM9000_EPDRL);
 561         to[1] = dm9000_ior(db, DM9000_EPDRH);
 562 }
 563
 564 static void dm9000_get_enetaddr(struct dm9000_priv *db, u8 *enetaddr)
 565 {
 566         int i;
 567
 568         for (i = 0; i < 3; i++)
 569                 dm9000_read_srom_word(db, i, enetaddr + (2 * i));
 570 }
 571 #else
 572 static void dm9000_get_enetaddr(struct dm9000_priv *db, u8 *enetaddr) {}
 573 #endif
 574
 575 #ifndef CONFIG_DM_ETH
 576 static int dm9000_init(struct eth_device *dev, struct bd_info *bd)
 577 {
 578         struct dm9000_priv *db = container_of(dev, struct dm9000_priv, dev);
 579
 580         return dm9000_init_common(db, dev->enetaddr);
 581 }
 582
 583 static void dm9000_halt(struct eth_device *dev)
 584 {
 585         struct dm9000_priv *db = container_of(dev, struct dm9000_priv, dev);
 586
 587         dm9000_halt_common(db);
 588 }
 589
 590 static int dm9000_send(struct eth_device *dev, void *packet, int length)
 591 {
 592         struct dm9000_priv *db = container_of(dev, struct dm9000_priv, dev);
 593
 594         return dm9000_send_common(db, packet, length);
 595 }
 596
 597 static int dm9000_recv(struct eth_device *dev)
 598 {
 599         struct dm9000_priv *db = container_of(dev, struct dm9000_priv, dev);
 600         int ret;
 601
 602         ret = dm9000_recv_common(db, net_rx_packets[0]);
 603         if (ret > 0)
 604                 net_process_received_packet(net_rx_packets[0], ret);
 605
 606         return ret;
 607 }
 608
 609 int dm9000_initialize(struct bd_info *bis)
 610 {
 611         struct dm9000_priv *priv;
 612         struct eth_device *dev;
 613
 614         priv = calloc(1, sizeof(*priv));
 615         if (!priv)
 616                 return -ENOMEM;
 617
 618         dev = &priv->dev;
 619
 620         priv->base_io = (void __iomem *)DM9000_IO;
 621         priv->base_data = (void __iomem *)DM9000_DATA;
 622
 623         /* Load MAC address from EEPROM */
 624         dm9000_get_enetaddr(priv, dev->enetaddr);
 625
 626         dev->init = dm9000_init;
 627         dev->halt = dm9000_halt;
 628         dev->send = dm9000_send;
 629         dev->recv = dm9000_recv;
 630         strcpy(dev->name, "dm9000");
 631
 632         eth_register(&priv->dev);
 633
 634         return 0;
 635 }
 636 #else   /* ifdef CONFIG_DM_ETH */
 637 static int dm9000_start(struct udevice *dev)
 638 {
 639         struct dm9000_priv *db = dev_get_priv(dev);
 640         struct eth_pdata *pdata = dev_get_plat(dev);
 641
 642         return dm9000_init_common(db, pdata->enetaddr);
 643 }
 644
 645 static void dm9000_stop(struct udevice *dev)
 646 {
 647         struct dm9000_priv *db = dev_get_priv(dev);
 648
 649         dm9000_halt_common(db);
 650 }
 651
 652 static int dm9000_send(struct udevice *dev, void *packet, int length)
 653 {
 654         struct dm9000_priv *db = dev_get_priv(dev);
 655         int ret;
 656
 657         ret = dm9000_send_common(db, packet, length);
 658
 659         return ret ? 0 : -ETIMEDOUT;
 660 }
 661
 662 static int dm9000_recv(struct udevice *dev, int flags, uchar **packetp)
 663 {
 664         struct dm9000_priv *db = dev_get_priv(dev);
 665         uchar *data = net_rx_packets[0];
 666         int ret;
 667
 668         ret = dm9000_recv_common(db, data);
 669         if (ret > 0)
 670                 *packetp = (void *)data;
 671
 672         return ret >= 0 ? ret : -EAGAIN;
 673 }
 674
 675 static int dm9000_write_hwaddr(struct udevice *dev)
 676 {
 677         struct dm9000_priv *db = dev_get_priv(dev);
 678         struct eth_pdata *pdata = dev_get_plat(dev);
 679         int i, oft;
 680
 681         /* fill device MAC address registers */
 682         for (i = 0, oft = DM9000_PAR; i < 6; i++, oft++)
 683                 dm9000_iow(db, oft, pdata->enetaddr[i]);
 684
 685         for (i = 0, oft = 0x16; i < 8; i++, oft++)
 686                 dm9000_iow(db, oft, 0xff);
 687
 688         /* read back mac, just to be sure */
 689         for (i = 0, oft = 0x10; i < 6; i++, oft++)
 690                 debug("%02x:", dm9000_ior(db, oft));
 691
 692         debug("\n");
 693
 694         return 0;
 695 }
 696
 697 static int dm9000_read_rom_hwaddr(struct udevice *dev)
 698 {
 699         struct dm9000_priv *db = dev_get_priv(dev);
 700         struct eth_pdata *pdata = dev_get_plat(dev);
 701
 702         dm9000_get_enetaddr(db, pdata->enetaddr);
 703
 704         return !is_valid_ethaddr(pdata->enetaddr);
 705 }
 706
 707 static int dm9000_bind(struct udevice *dev)
 708 {
 709         return device_set_name(dev, dev->name);
 710 }
 711
 712 static int dm9000_of_to_plat(struct udevice *dev)
 713 {
 714         struct dm9000_priv *db = dev_get_priv(dev);
 715         struct eth_pdata *pdata = dev_get_plat(dev);
 716
 717         pdata->iobase = dev_read_addr_index(dev, 0);
 718         db->base_io = (void __iomem *)pdata->iobase;
 719         db->base_data = (void __iomem *)dev_read_addr_index(dev, 1);
 720
 721         return 0;
 722 }
 723
 724 static const struct eth_ops dm9000_ops = {
 725         .start          = dm9000_start,
 726         .stop           = dm9000_stop,
 727         .send           = dm9000_send,
 728         .recv           = dm9000_recv,
 729         .write_hwaddr   = dm9000_write_hwaddr,
 730         .read_rom_hwaddr = dm9000_read_rom_hwaddr,
 731 };
 732
 733 static const struct udevice_id dm9000_ids[] = {
 734         { .compatible = "davicom,dm9000" },
 735         { }
 736 };
 737
 738 U_BOOT_DRIVER(dm9000) = {
 739         .name           = "eth_dm9000",
 740         .id             = UCLASS_ETH,
 741         .of_match       = dm9000_ids,
 742         .bind           = dm9000_bind,
 743         .of_to_plat = dm9000_of_to_plat,
 744         .ops            = &dm9000_ops,
 745         .priv_auto      = sizeof(struct dm9000_priv),
 746         .plat_auto      = sizeof(struct eth_pdata),
 747         .flags          = DM_FLAG_ALLOC_PRIV_DMA,
 748 };
 749 #endif